?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
OMAP3 SRF: Generic shared resource f/w
[linux-ginger.git] / drivers / media / video / cx25840 / cx25840-core.c
blob1aeaf18a9bea3010c2889380e22cd81d344d6f08
1 /* cx25840 - Conexant CX25840 audio/video decoder driver
2 *
3 * Copyright (C) 2004 Ulf Eklund
4 *
5 * Based on the saa7115 driver and on the first verison of Chris Kennedy's
6 * cx25840 driver.
7 *
8 * Changes by Tyler Trafford <tatrafford@comcast.net>
9 * - cleanup/rewrite for V4L2 API (2005)
10 *
11 * VBI support by Hans Verkuil <hverkuil@xs4all.nl>.
12 *
13 * NTSC sliced VBI support by Christopher Neufeld <television@cneufeld.ca>
14 * with additional fixes by Hans Verkuil <hverkuil@xs4all.nl>.
15 *
16 * CX23885 support by Steven Toth <stoth@linuxtv.org>.
17 *
18 * This program is free software; you can redistribute it and/or
19 * modify it under the terms of the GNU General Public License
20 * as published by the Free Software Foundation; either version 2
21 * of the License, or (at your option) any later version.
22 *
23 * This program is distributed in the hope that it will be useful,
24 * but WITHOUT ANY WARRANTY; without even the implied warranty of
25 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
26 * GNU General Public License for more details.
27 *
28 * You should have received a copy of the GNU General Public License
29 * along with this program; if not, write to the Free Software
30 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
31 */
32
33
34 #include <linux/kernel.h>
35 #include <linux/module.h>
36 #include <linux/slab.h>
37 #include <linux/videodev2.h>
38 #include <linux/i2c.h>
39 #include <linux/delay.h>
40 #include <media/v4l2-common.h>
41 #include <media/v4l2-chip-ident.h>
42 #include <media/v4l2-i2c-drv.h>
43 #include <media/cx25840.h>
44
45 #include "cx25840-core.h"
46
47 MODULE_DESCRIPTION("Conexant CX25840 audio/video decoder driver");
48 MODULE_AUTHOR("Ulf Eklund, Chris Kennedy, Hans Verkuil, Tyler Trafford");
49 MODULE_LICENSE("GPL");
50
51 static int cx25840_debug;
52
53 module_param_named(debug,cx25840_debug, int, 0644);
54
55 MODULE_PARM_DESC(debug, "Debugging messages [0=Off (default) 1=On]");
56
57
58 /* ----------------------------------------------------------------------- */
59
60 int cx25840_write(struct i2c_client *client, u16 addr, u8 value)
61 {
62 u8 buffer[3];
63 buffer[0] = addr >> 8;
64 buffer[1] = addr & 0xff;
65 buffer[2] = value;
66 return i2c_master_send(client, buffer, 3);
67 }
68
69 int cx25840_write4(struct i2c_client *client, u16 addr, u32 value)
70 {
71 u8 buffer[6];
72 buffer[0] = addr >> 8;
73 buffer[1] = addr & 0xff;
74 buffer[2] = value & 0xff;
75 buffer[3] = (value >> 8) & 0xff;
76 buffer[4] = (value >> 16) & 0xff;
77 buffer[5] = value >> 24;
78 return i2c_master_send(client, buffer, 6);
79 }
80
81 u8 cx25840_read(struct i2c_client * client, u16 addr)
82 {
83 u8 buffer[2];
84 buffer[0] = addr >> 8;
85 buffer[1] = addr & 0xff;
86
87 if (i2c_master_send(client, buffer, 2) < 2)
88 return 0;
89
90 if (i2c_master_recv(client, buffer, 1) < 1)
91 return 0;
92
93 return buffer[0];
94 }
95
96 u32 cx25840_read4(struct i2c_client * client, u16 addr)
97 {
98 u8 buffer[4];
99 buffer[0] = addr >> 8;
100 buffer[1] = addr & 0xff;
101
102 if (i2c_master_send(client, buffer, 2) < 2)
103 return 0;
104
105 if (i2c_master_recv(client, buffer, 4) < 4)
106 return 0;
107
108 return (buffer[3] << 24) | (buffer[2] << 16) |
109 (buffer[1] << 8) | buffer[0];
110 }
111
112 int cx25840_and_or(struct i2c_client *client, u16 addr, unsigned and_mask,
113 u8 or_value)
114 {
115 return cx25840_write(client, addr,
116 (cx25840_read(client, addr) & and_mask) |
117 or_value);
118 }
119
120 /* ----------------------------------------------------------------------- */
121
122 static int set_input(struct i2c_client *client, enum cx25840_video_input vid_input,
123 enum cx25840_audio_input aud_input);
124
125 /* ----------------------------------------------------------------------- */
126
127 static void init_dll1(struct i2c_client *client)
128 {
129 /* This is the Hauppauge sequence used to
130 * initialize the Delay Lock Loop 1 (ADC DLL). */
131 cx25840_write(client, 0x159, 0x23);
132 cx25840_write(client, 0x15a, 0x87);
133 cx25840_write(client, 0x15b, 0x06);
134 udelay(10);
135 cx25840_write(client, 0x159, 0xe1);
136 udelay(10);
137 cx25840_write(client, 0x15a, 0x86);
138 cx25840_write(client, 0x159, 0xe0);
139 cx25840_write(client, 0x159, 0xe1);
140 cx25840_write(client, 0x15b, 0x10);
141 }
142
143 static void init_dll2(struct i2c_client *client)
144 {
145 /* This is the Hauppauge sequence used to
146 * initialize the Delay Lock Loop 2 (ADC DLL). */
147 cx25840_write(client, 0x15d, 0xe3);
148 cx25840_write(client, 0x15e, 0x86);
149 cx25840_write(client, 0x15f, 0x06);
150 udelay(10);
151 cx25840_write(client, 0x15d, 0xe1);
152 cx25840_write(client, 0x15d, 0xe0);
153 cx25840_write(client, 0x15d, 0xe1);
154 }
155
156 static void cx25836_initialize(struct i2c_client *client)
157 {
158 /* reset configuration is described on page 3-77 of the CX25836 datasheet */
159 /* 2. */
160 cx25840_and_or(client, 0x000, ~0x01, 0x01);
161 cx25840_and_or(client, 0x000, ~0x01, 0x00);
162 /* 3a. */
163 cx25840_and_or(client, 0x15a, ~0x70, 0x00);
164 /* 3b. */
165 cx25840_and_or(client, 0x15b, ~0x1e, 0x06);
166 /* 3c. */
167 cx25840_and_or(client, 0x159, ~0x02, 0x02);
168 /* 3d. */
169 udelay(10);
170 /* 3e. */
171 cx25840_and_or(client, 0x159, ~0x02, 0x00);
172 /* 3f. */
173 cx25840_and_or(client, 0x159, ~0xc0, 0xc0);
174 /* 3g. */
175 cx25840_and_or(client, 0x159, ~0x01, 0x00);
176 cx25840_and_or(client, 0x159, ~0x01, 0x01);
177 /* 3h. */
178 cx25840_and_or(client, 0x15b, ~0x1e, 0x10);
179 }
180
181 static void cx25840_work_handler(struct work_struct *work)
182 {
183 struct cx25840_state *state = container_of(work, struct cx25840_state, fw_work);
184 cx25840_loadfw(state->c);
185 wake_up(&state->fw_wait);
186 }
187
188 static void cx25840_initialize(struct i2c_client *client)
189 {
190 DEFINE_WAIT(wait);
191 struct cx25840_state *state = to_state(i2c_get_clientdata(client));
192 struct workqueue_struct *q;
193
194 /* datasheet startup in numbered steps, refer to page 3-77 */
195 /* 2. */
196 cx25840_and_or(client, 0x803, ~0x10, 0x00);
197 /* The default of this register should be 4, but I get 0 instead.
198 * Set this register to 4 manually. */
199 cx25840_write(client, 0x000, 0x04);
200 /* 3. */
201 init_dll1(client);
202 init_dll2(client);
203 cx25840_write(client, 0x136, 0x0a);
204 /* 4. */
205 cx25840_write(client, 0x13c, 0x01);
206 cx25840_write(client, 0x13c, 0x00);
207 /* 5. */
208 /* Do the firmware load in a work handler to prevent.
209 Otherwise the kernel is blocked waiting for the
210 bit-banging i2c interface to finish uploading the
211 firmware. */
212 INIT_WORK(&state->fw_work, cx25840_work_handler);
213 init_waitqueue_head(&state->fw_wait);
214 q = create_singlethread_workqueue("cx25840_fw");
215 prepare_to_wait(&state->fw_wait, &wait, TASK_UNINTERRUPTIBLE);
216 queue_work(q, &state->fw_work);
217 schedule();
218 finish_wait(&state->fw_wait, &wait);
219 destroy_workqueue(q);
220
221 /* 6. */
222 cx25840_write(client, 0x115, 0x8c);
223 cx25840_write(client, 0x116, 0x07);
224 cx25840_write(client, 0x118, 0x02);
225 /* 7. */
226 cx25840_write(client, 0x4a5, 0x80);
227 cx25840_write(client, 0x4a5, 0x00);
228 cx25840_write(client, 0x402, 0x00);
229 /* 8. */
230 cx25840_and_or(client, 0x401, ~0x18, 0);
231 cx25840_and_or(client, 0x4a2, ~0x10, 0x10);
232 /* steps 8c and 8d are done in change_input() */
233 /* 10. */
234 cx25840_write(client, 0x8d3, 0x1f);
235 cx25840_write(client, 0x8e3, 0x03);
236
237 cx25840_std_setup(client);
238
239 /* trial and error says these are needed to get audio */
240 cx25840_write(client, 0x914, 0xa0);
241 cx25840_write(client, 0x918, 0xa0);
242 cx25840_write(client, 0x919, 0x01);
243
244 /* stereo prefered */
245 cx25840_write(client, 0x809, 0x04);
246 /* AC97 shift */
247 cx25840_write(client, 0x8cf, 0x0f);
248
249 /* (re)set input */
250 set_input(client, state->vid_input, state->aud_input);
251
252 /* start microcontroller */
253 cx25840_and_or(client, 0x803, ~0x10, 0x10);
254 }
255
256 static void cx23885_initialize(struct i2c_client *client)
257 {
258 DEFINE_WAIT(wait);
259 struct cx25840_state *state = to_state(i2c_get_clientdata(client));
260 struct workqueue_struct *q;
261
262 /* Internal Reset */
263 cx25840_and_or(client, 0x102, ~0x01, 0x01);
264 cx25840_and_or(client, 0x102, ~0x01, 0x00);
265
266 /* Stop microcontroller */
267 cx25840_and_or(client, 0x803, ~0x10, 0x00);
268
269 /* DIF in reset? */
270 cx25840_write(client, 0x398, 0);
271
272 /* Trust the default xtal, no division */
273 /* This changes for the cx23888 products */
274 cx25840_write(client, 0x2, 0x76);
275
276 /* Bring down the regulator for AUX clk */
277 cx25840_write(client, 0x1, 0x40);
278
279 /* Sys PLL frac */
280 cx25840_write4(client, 0x11c, 0x01d1744c);
281
282 /* Sys PLL int */
283 cx25840_write4(client, 0x118, 0x00000416);
284
285 /* Disable DIF bypass */
286 cx25840_write4(client, 0x33c, 0x00000001);
287
288 /* DIF Src phase inc */
289 cx25840_write4(client, 0x340, 0x0df7df83);
290
291 /* Vid PLL frac */
292 cx25840_write4(client, 0x10c, 0x01b6db7b);
293
294 /* Vid PLL int */
295 cx25840_write4(client, 0x108, 0x00000512);
296
297 /* Luma */
298 cx25840_write4(client, 0x414, 0x00107d12);
299
300 /* Chroma */
301 cx25840_write4(client, 0x420, 0x3d008282);
302
303 /* Aux PLL frac */
304 cx25840_write4(client, 0x114, 0x017dbf48);
305
306 /* Aux PLL int */
307 cx25840_write4(client, 0x110, 0x000a030e);
308
309 /* ADC2 input select */
310 cx25840_write(client, 0x102, 0x10);
311
312 /* VIN1 & VIN5 */
313 cx25840_write(client, 0x103, 0x11);
314
315 /* Enable format auto detect */
316 cx25840_write(client, 0x400, 0);
317 /* Fast subchroma lock */
318 /* White crush, Chroma AGC & Chroma Killer enabled */
319 cx25840_write(client, 0x401, 0xe8);
320
321 /* Select AFE clock pad output source */
322 cx25840_write(client, 0x144, 0x05);
323
324 /* Drive GPIO2 direction and values for HVR1700
325 * where an onboard mux selects the output of demodulator
326 * vs the 417. Failure to set this results in no DTV.
327 * It's safe to set this across all Hauppauge boards
328 * currently, regardless of the board type.
329 */
330 cx25840_write(client, 0x160, 0x1d);
331 cx25840_write(client, 0x164, 0x00);
332
333 /* Do the firmware load in a work handler to prevent.
334 Otherwise the kernel is blocked waiting for the
335 bit-banging i2c interface to finish uploading the
336 firmware. */
337 INIT_WORK(&state->fw_work, cx25840_work_handler);
338 init_waitqueue_head(&state->fw_wait);
339 q = create_singlethread_workqueue("cx25840_fw");
340 prepare_to_wait(&state->fw_wait, &wait, TASK_UNINTERRUPTIBLE);
341 queue_work(q, &state->fw_work);
342 schedule();
343 finish_wait(&state->fw_wait, &wait);
344 destroy_workqueue(q);
345
346 cx25840_std_setup(client);
347
348 /* (re)set input */
349 set_input(client, state->vid_input, state->aud_input);
350
351 /* start microcontroller */
352 cx25840_and_or(client, 0x803, ~0x10, 0x10);
353 }
354
355 /* ----------------------------------------------------------------------- */
356
357 static void cx231xx_initialize(struct i2c_client *client)
358 {
359 DEFINE_WAIT(wait);
360 struct cx25840_state *state = to_state(i2c_get_clientdata(client));
361 struct workqueue_struct *q;
362
363 /* Internal Reset */
364 cx25840_and_or(client, 0x102, ~0x01, 0x01);
365 cx25840_and_or(client, 0x102, ~0x01, 0x00);
366
367 /* Stop microcontroller */
368 cx25840_and_or(client, 0x803, ~0x10, 0x00);
369
370 /* DIF in reset? */
371 cx25840_write(client, 0x398, 0);
372
373 /* Trust the default xtal, no division */
374 /* This changes for the cx23888 products */
375 cx25840_write(client, 0x2, 0x76);
376
377 /* Bring down the regulator for AUX clk */
378 cx25840_write(client, 0x1, 0x40);
379
380 /* Disable DIF bypass */
381 cx25840_write4(client, 0x33c, 0x00000001);
382
383 /* DIF Src phase inc */
384 cx25840_write4(client, 0x340, 0x0df7df83);
385
386 /* Luma */
387 cx25840_write4(client, 0x414, 0x00107d12);
388
389 /* Chroma */
390 cx25840_write4(client, 0x420, 0x3d008282);
391
392 /* ADC2 input select */
393 cx25840_write(client, 0x102, 0x10);
394
395 /* VIN1 & VIN5 */
396 cx25840_write(client, 0x103, 0x11);
397
398 /* Enable format auto detect */
399 cx25840_write(client, 0x400, 0);
400 /* Fast subchroma lock */
401 /* White crush, Chroma AGC & Chroma Killer enabled */
402 cx25840_write(client, 0x401, 0xe8);
403
404 /* Do the firmware load in a work handler to prevent.
405 Otherwise the kernel is blocked waiting for the
406 bit-banging i2c interface to finish uploading the
407 firmware. */
408 INIT_WORK(&state->fw_work, cx25840_work_handler);
409 init_waitqueue_head(&state->fw_wait);
410 q = create_singlethread_workqueue("cx25840_fw");
411 prepare_to_wait(&state->fw_wait, &wait, TASK_UNINTERRUPTIBLE);
412 queue_work(q, &state->fw_work);
413 schedule();
414 finish_wait(&state->fw_wait, &wait);
415 destroy_workqueue(q);
416
417 cx25840_std_setup(client);
418
419 /* (re)set input */
420 set_input(client, state->vid_input, state->aud_input);
421
422 /* start microcontroller */
423 cx25840_and_or(client, 0x803, ~0x10, 0x10);
424 }
425
426 /* ----------------------------------------------------------------------- */
427
428 void cx25840_std_setup(struct i2c_client *client)
429 {
430 struct cx25840_state *state = to_state(i2c_get_clientdata(client));
431 v4l2_std_id std = state->std;
432 int hblank, hactive, burst, vblank, vactive, sc;
433 int vblank656, src_decimation;
434 int luma_lpf, uv_lpf, comb;
435 u32 pll_int, pll_frac, pll_post;
436
437 /* datasheet startup, step 8d */
438 if (std & ~V4L2_STD_NTSC)
439 cx25840_write(client, 0x49f, 0x11);
440 else
441 cx25840_write(client, 0x49f, 0x14);
442
443 if (std & V4L2_STD_625_50) {
444 hblank = 132;
445 hactive = 720;
446 burst = 93;
447 vblank = 36;
448 vactive = 580;
449 vblank656 = 40;
450 src_decimation = 0x21f;
451 luma_lpf = 2;
452
453 if (std & V4L2_STD_SECAM) {
454 uv_lpf = 0;
455 comb = 0;
456 sc = 0x0a425f;
457 } else if (std == V4L2_STD_PAL_Nc) {
458 uv_lpf = 1;
459 comb = 0x20;
460 sc = 556453;
461 } else {
462 uv_lpf = 1;
463 comb = 0x20;
464 sc = 688739;
465 }
466 } else {
467 hactive = 720;
468 hblank = 122;
469 vactive = 487;
470 luma_lpf = 1;
471 uv_lpf = 1;
472
473 src_decimation = 0x21f;
474 if (std == V4L2_STD_PAL_60) {
475 vblank = 26;
476 vblank656 = 26;
477 burst = 0x5b;
478 luma_lpf = 2;
479 comb = 0x20;
480 sc = 688739;
481 } else if (std == V4L2_STD_PAL_M) {
482 vblank = 20;
483 vblank656 = 24;
484 burst = 0x61;
485 comb = 0x20;
486 sc = 555452;
487 } else {
488 vblank = 26;
489 vblank656 = 26;
490 burst = 0x5b;
491 comb = 0x66;
492 sc = 556063;
493 }
494 }
495
496 /* DEBUG: Displays configured PLL frequency */
497 if (!state->is_cx231xx) {
498 pll_int = cx25840_read(client, 0x108);
499 pll_frac = cx25840_read4(client, 0x10c) & 0x1ffffff;
500 pll_post = cx25840_read(client, 0x109);
501 v4l_dbg(1, cx25840_debug, client,
502 "PLL regs = int: %u, frac: %u, post: %u\n",
503 pll_int, pll_frac, pll_post);
504
505 if (pll_post) {
506 int fin, fsc;
507 int pll = (28636363L * ((((u64)pll_int) << 25L) + pll_frac)) >> 25L;
508
509 pll /= pll_post;
510 v4l_dbg(1, cx25840_debug, client, "PLL = %d.%06d MHz\n",
511 pll / 1000000, pll % 1000000);
512 v4l_dbg(1, cx25840_debug, client, "PLL/8 = %d.%06d MHz\n",
513 pll / 8000000, (pll / 8) % 1000000);
514
515 fin = ((u64)src_decimation * pll) >> 12;
516 v4l_dbg(1, cx25840_debug, client,
517 "ADC Sampling freq = %d.%06d MHz\n",
518 fin / 1000000, fin % 1000000);
519
520 fsc = (((u64)sc) * pll) >> 24L;
521 v4l_dbg(1, cx25840_debug, client,
522 "Chroma sub-carrier freq = %d.%06d MHz\n",
523 fsc / 1000000, fsc % 1000000);
524
525 v4l_dbg(1, cx25840_debug, client, "hblank %i, hactive %i, "
526 "vblank %i, vactive %i, vblank656 %i, src_dec %i, "
527 "burst 0x%02x, luma_lpf %i, uv_lpf %i, comb 0x%02x, "
528 "sc 0x%06x\n",
529 hblank, hactive, vblank, vactive, vblank656,
530 src_decimation, burst, luma_lpf, uv_lpf, comb, sc);
531 }
532 }
533
534 /* Sets horizontal blanking delay and active lines */
535 cx25840_write(client, 0x470, hblank);
536 cx25840_write(client, 0x471,
537 0xff & (((hblank >> 8) & 0x3) | (hactive << 4)));
538 cx25840_write(client, 0x472, hactive >> 4);
539
540 /* Sets burst gate delay */
541 cx25840_write(client, 0x473, burst);
542
543 /* Sets vertical blanking delay and active duration */
544 cx25840_write(client, 0x474, vblank);
545 cx25840_write(client, 0x475,
546 0xff & (((vblank >> 8) & 0x3) | (vactive << 4)));
547 cx25840_write(client, 0x476, vactive >> 4);
548 cx25840_write(client, 0x477, vblank656);
549
550 /* Sets src decimation rate */
551 cx25840_write(client, 0x478, 0xff & src_decimation);
552 cx25840_write(client, 0x479, 0xff & (src_decimation >> 8));
553
554 /* Sets Luma and UV Low pass filters */
555 cx25840_write(client, 0x47a, luma_lpf << 6 | ((uv_lpf << 4) & 0x30));
556
557 /* Enables comb filters */
558 cx25840_write(client, 0x47b, comb);
559
560 /* Sets SC Step*/
561 cx25840_write(client, 0x47c, sc);
562 cx25840_write(client, 0x47d, 0xff & sc >> 8);
563 cx25840_write(client, 0x47e, 0xff & sc >> 16);
564
565 /* Sets VBI parameters */
566 if (std & V4L2_STD_625_50) {
567 cx25840_write(client, 0x47f, 0x01);
568 state->vbi_line_offset = 5;
569 } else {
570 cx25840_write(client, 0x47f, 0x00);
571 state->vbi_line_offset = 8;
572 }
573 }
574
575 /* ----------------------------------------------------------------------- */
576
577 static void input_change(struct i2c_client *client)
578 {
579 struct cx25840_state *state = to_state(i2c_get_clientdata(client));
580 v4l2_std_id std = state->std;
581
582 /* Follow step 8c and 8d of section 3.16 in the cx25840 datasheet */
583 if (std & V4L2_STD_SECAM) {
584 cx25840_write(client, 0x402, 0);
585 }
586 else {
587 cx25840_write(client, 0x402, 0x04);
588 cx25840_write(client, 0x49f, (std & V4L2_STD_NTSC) ? 0x14 : 0x11);
589 }
590 cx25840_and_or(client, 0x401, ~0x60, 0);
591 cx25840_and_or(client, 0x401, ~0x60, 0x60);
592 cx25840_and_or(client, 0x810, ~0x01, 1);
593
594 if (state->radio) {
595 cx25840_write(client, 0x808, 0xf9);
596 cx25840_write(client, 0x80b, 0x00);
597 }
598 else if (std & V4L2_STD_525_60) {
599 /* Certain Hauppauge PVR150 models have a hardware bug
600 that causes audio to drop out. For these models the
601 audio standard must be set explicitly.
602 To be precise: it affects cards with tuner models
603 85, 99 and 112 (model numbers from tveeprom). */
604 int hw_fix = state->pvr150_workaround;
605
606 if (std == V4L2_STD_NTSC_M_JP) {
607 /* Japan uses EIAJ audio standard */
608 cx25840_write(client, 0x808, hw_fix ? 0x2f : 0xf7);
609 } else if (std == V4L2_STD_NTSC_M_KR) {
610 /* South Korea uses A2 audio standard */
611 cx25840_write(client, 0x808, hw_fix ? 0x3f : 0xf8);
612 } else {
613 /* Others use the BTSC audio standard */
614 cx25840_write(client, 0x808, hw_fix ? 0x1f : 0xf6);
615 }
616 cx25840_write(client, 0x80b, 0x00);
617 } else if (std & V4L2_STD_PAL) {
618 /* Follow tuner change procedure for PAL */
619 cx25840_write(client, 0x808, 0xff);
620 cx25840_write(client, 0x80b, 0x10);
621 } else if (std & V4L2_STD_SECAM) {
622 /* Select autodetect for SECAM */
623 cx25840_write(client, 0x808, 0xff);
624 cx25840_write(client, 0x80b, 0x10);
625 }
626
627 cx25840_and_or(client, 0x810, ~0x01, 0);
628 }
629
630 static int set_input(struct i2c_client *client, enum cx25840_video_input vid_input,
631 enum cx25840_audio_input aud_input)
632 {
633 struct cx25840_state *state = to_state(i2c_get_clientdata(client));
634 u8 is_composite = (vid_input >= CX25840_COMPOSITE1 &&
635 vid_input <= CX25840_COMPOSITE8);
636 u8 reg;
637
638 v4l_dbg(1, cx25840_debug, client,
639 "decoder set video input %d, audio input %d\n",
640 vid_input, aud_input);
641
642 if (vid_input >= CX25840_VIN1_CH1) {
643 v4l_dbg(1, cx25840_debug, client, "vid_input 0x%x\n",
644 vid_input);
645 reg = vid_input & 0xff;
646 if ((vid_input & CX25840_SVIDEO_ON) == CX25840_SVIDEO_ON)
647 is_composite = 0;
648 else
649 is_composite = 1;
650
651 v4l_dbg(1, cx25840_debug, client, "mux cfg 0x%x comp=%d\n",
652 reg, is_composite);
653 } else
654 if (is_composite) {
655 reg = 0xf0 + (vid_input - CX25840_COMPOSITE1);
656 } else {
657 int luma = vid_input & 0xf0;
658 int chroma = vid_input & 0xf00;
659
660 if ((vid_input & ~0xff0) ||
661 luma < CX25840_SVIDEO_LUMA1 || luma > CX25840_SVIDEO_LUMA8 ||
662 chroma < CX25840_SVIDEO_CHROMA4 || chroma > CX25840_SVIDEO_CHROMA8) {
663 v4l_err(client, "0x%04x is not a valid video input!\n",
664 vid_input);
665 return -EINVAL;
666 }
667 reg = 0xf0 + ((luma - CX25840_SVIDEO_LUMA1) >> 4);
668 if (chroma >= CX25840_SVIDEO_CHROMA7) {
669 reg &= 0x3f;
670 reg |= (chroma - CX25840_SVIDEO_CHROMA7) >> 2;
671 } else {
672 reg &= 0xcf;
673 reg |= (chroma - CX25840_SVIDEO_CHROMA4) >> 4;
674 }
675 }
676
677 /* The caller has previously prepared the correct routing
678 * configuration in reg (for the cx23885) so we have no
679 * need to attempt to flip bits for earlier av decoders.
680 */
681 if (!state->is_cx23885 && !state->is_cx231xx) {
682 switch (aud_input) {
683 case CX25840_AUDIO_SERIAL:
684 /* do nothing, use serial audio input */
685 break;
686 case CX25840_AUDIO4: reg &= ~0x30; break;
687 case CX25840_AUDIO5: reg &= ~0x30; reg |= 0x10; break;
688 case CX25840_AUDIO6: reg &= ~0x30; reg |= 0x20; break;
689 case CX25840_AUDIO7: reg &= ~0xc0; break;
690 case CX25840_AUDIO8: reg &= ~0xc0; reg |= 0x40; break;
691
692 default:
693 v4l_err(client, "0x%04x is not a valid audio input!\n",
694 aud_input);
695 return -EINVAL;
696 }
697 }
698
699 cx25840_write(client, 0x103, reg);
700
701 /* Set INPUT_MODE to Composite (0) or S-Video (1) */
702 cx25840_and_or(client, 0x401, ~0x6, is_composite ? 0 : 0x02);
703
704 if (!state->is_cx23885 && !state->is_cx231xx) {
705 /* Set CH_SEL_ADC2 to 1 if input comes from CH3 */
706 cx25840_and_or(client, 0x102, ~0x2, (reg & 0x80) == 0 ? 2 : 0);
707 /* Set DUAL_MODE_ADC2 to 1 if input comes from both CH2&CH3 */
708 if ((reg & 0xc0) != 0xc0 && (reg & 0x30) != 0x30)
709 cx25840_and_or(client, 0x102, ~0x4, 4);
710 else
711 cx25840_and_or(client, 0x102, ~0x4, 0);
712 } else {
713 if (is_composite)
714 /* ADC2 input select channel 2 */
715 cx25840_and_or(client, 0x102, ~0x2, 0);
716 else
717 /* ADC2 input select channel 3 */
718 cx25840_and_or(client, 0x102, ~0x2, 2);
719 }
720
721 state->vid_input = vid_input;
722 state->aud_input = aud_input;
723 if (!state->is_cx25836) {
724 cx25840_audio_set_path(client);
725 input_change(client);
726 }
727
728 if (state->is_cx23885) {
729 /* Audio channel 1 src : Parallel 1 */
730 cx25840_write(client, 0x124, 0x03);
731
732 /* Select AFE clock pad output source */
733 cx25840_write(client, 0x144, 0x05);
734
735 /* I2S_IN_CTL: I2S_IN_SONY_MODE, LEFT SAMPLE on WS=1 */
736 cx25840_write(client, 0x914, 0xa0);
737
738 /* I2S_OUT_CTL:
739 * I2S_IN_SONY_MODE, LEFT SAMPLE on WS=1
740 * I2S_OUT_MASTER_MODE = Master
741 */
742 cx25840_write(client, 0x918, 0xa0);
743 cx25840_write(client, 0x919, 0x01);
744 } else if (state->is_cx231xx) {
745 /* Audio channel 1 src : Parallel 1 */
746 cx25840_write(client, 0x124, 0x03);
747
748 /* I2S_IN_CTL: I2S_IN_SONY_MODE, LEFT SAMPLE on WS=1 */
749 cx25840_write(client, 0x914, 0xa0);
750
751 /* I2S_OUT_CTL:
752 * I2S_IN_SONY_MODE, LEFT SAMPLE on WS=1
753 * I2S_OUT_MASTER_MODE = Master
754 */
755 cx25840_write(client, 0x918, 0xa0);
756 cx25840_write(client, 0x919, 0x01);
757 }
758
759 return 0;
760 }
761
762 /* ----------------------------------------------------------------------- */
763
764 static int set_v4lstd(struct i2c_client *client)
765 {
766 struct cx25840_state *state = to_state(i2c_get_clientdata(client));
767 u8 fmt = 0; /* zero is autodetect */
768 u8 pal_m = 0;
769
770 /* First tests should be against specific std */
771 if (state->std == V4L2_STD_NTSC_M_JP) {
772 fmt = 0x2;
773 } else if (state->std == V4L2_STD_NTSC_443) {
774 fmt = 0x3;
775 } else if (state->std == V4L2_STD_PAL_M) {
776 pal_m = 1;
777 fmt = 0x5;
778 } else if (state->std == V4L2_STD_PAL_N) {
779 fmt = 0x6;
780 } else if (state->std == V4L2_STD_PAL_Nc) {
781 fmt = 0x7;
782 } else if (state->std == V4L2_STD_PAL_60) {
783 fmt = 0x8;
784 } else {
785 /* Then, test against generic ones */
786 if (state->std & V4L2_STD_NTSC)
787 fmt = 0x1;
788 else if (state->std & V4L2_STD_PAL)
789 fmt = 0x4;
790 else if (state->std & V4L2_STD_SECAM)
791 fmt = 0xc;
792 }
793
794 v4l_dbg(1, cx25840_debug, client, "changing video std to fmt %i\n",fmt);
795
796 /* Follow step 9 of section 3.16 in the cx25840 datasheet.
797 Without this PAL may display a vertical ghosting effect.
798 This happens for example with the Yuan MPC622. */
799 if (fmt >= 4 && fmt < 8) {
800 /* Set format to NTSC-M */
801 cx25840_and_or(client, 0x400, ~0xf, 1);
802 /* Turn off LCOMB */
803 cx25840_and_or(client, 0x47b, ~6, 0);
804 }
805 cx25840_and_or(client, 0x400, ~0xf, fmt);
806 cx25840_and_or(client, 0x403, ~0x3, pal_m);
807 cx25840_std_setup(client);
808 if (!state->is_cx25836)
809 input_change(client);
810 return 0;
811 }
812
813 /* ----------------------------------------------------------------------- */
814
815 static int cx25840_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
816 {
817 struct cx25840_state *state = to_state(sd);
818 struct i2c_client *client = v4l2_get_subdevdata(sd);
819
820 switch (ctrl->id) {
821 case CX25840_CID_ENABLE_PVR150_WORKAROUND:
822 state->pvr150_workaround = ctrl->value;
823 set_input(client, state->vid_input, state->aud_input);
824 break;
825
826 case V4L2_CID_BRIGHTNESS:
827 if (ctrl->value < 0 || ctrl->value > 255) {
828 v4l_err(client, "invalid brightness setting %d\n",
829 ctrl->value);
830 return -ERANGE;
831 }
832
833 cx25840_write(client, 0x414, ctrl->value - 128);
834 break;
835
836 case V4L2_CID_CONTRAST:
837 if (ctrl->value < 0 || ctrl->value > 127) {
838 v4l_err(client, "invalid contrast setting %d\n",
839 ctrl->value);
840 return -ERANGE;
841 }
842
843 cx25840_write(client, 0x415, ctrl->value << 1);
844 break;
845
846 case V4L2_CID_SATURATION:
847 if (ctrl->value < 0 || ctrl->value > 127) {
848 v4l_err(client, "invalid saturation setting %d\n",
849 ctrl->value);
850 return -ERANGE;
851 }
852
853 cx25840_write(client, 0x420, ctrl->value << 1);
854 cx25840_write(client, 0x421, ctrl->value << 1);
855 break;
856
857 case V4L2_CID_HUE:
858 if (ctrl->value < -128 || ctrl->value > 127) {
859 v4l_err(client, "invalid hue setting %d\n", ctrl->value);
860 return -ERANGE;
861 }
862
863 cx25840_write(client, 0x422, ctrl->value);
864 break;
865
866 case V4L2_CID_AUDIO_VOLUME:
867 case V4L2_CID_AUDIO_BASS:
868 case V4L2_CID_AUDIO_TREBLE:
869 case V4L2_CID_AUDIO_BALANCE:
870 case V4L2_CID_AUDIO_MUTE:
871 if (state->is_cx25836)
872 return -EINVAL;
873 return cx25840_audio_s_ctrl(sd, ctrl);
874
875 default:
876 return -EINVAL;
877 }
878
879 return 0;
880 }
881
882 static int cx25840_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
883 {
884 struct cx25840_state *state = to_state(sd);
885 struct i2c_client *client = v4l2_get_subdevdata(sd);
886
887 switch (ctrl->id) {
888 case CX25840_CID_ENABLE_PVR150_WORKAROUND:
889 ctrl->value = state->pvr150_workaround;
890 break;
891 case V4L2_CID_BRIGHTNESS:
892 ctrl->value = (s8)cx25840_read(client, 0x414) + 128;
893 break;
894 case V4L2_CID_CONTRAST:
895 ctrl->value = cx25840_read(client, 0x415) >> 1;
896 break;
897 case V4L2_CID_SATURATION:
898 ctrl->value = cx25840_read(client, 0x420) >> 1;
899 break;
900 case V4L2_CID_HUE:
901 ctrl->value = (s8)cx25840_read(client, 0x422);
902 break;
903 case V4L2_CID_AUDIO_VOLUME:
904 case V4L2_CID_AUDIO_BASS:
905 case V4L2_CID_AUDIO_TREBLE:
906 case V4L2_CID_AUDIO_BALANCE:
907 case V4L2_CID_AUDIO_MUTE:
908 if (state->is_cx25836)
909 return -EINVAL;
910 return cx25840_audio_g_ctrl(sd, ctrl);
911 default:
912 return -EINVAL;
913 }
914
915 return 0;
916 }
917
918 /* ----------------------------------------------------------------------- */
919
920 static int cx25840_g_fmt(struct v4l2_subdev *sd, struct v4l2_format *fmt)
921 {
922 switch (fmt->type) {
923 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
924 return cx25840_vbi_g_fmt(sd, fmt);
925 default:
926 return -EINVAL;
927 }
928 return 0;
929 }
930
931 static int cx25840_s_fmt(struct v4l2_subdev *sd, struct v4l2_format *fmt)
932 {
933 struct cx25840_state *state = to_state(sd);
934 struct i2c_client *client = v4l2_get_subdevdata(sd);
935 struct v4l2_pix_format *pix;
936 int HSC, VSC, Vsrc, Hsrc, filter, Vlines;
937 int is_50Hz = !(state->std & V4L2_STD_525_60);
938
939 switch (fmt->type) {
940 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
941 pix = &(fmt->fmt.pix);
942
943 Vsrc = (cx25840_read(client, 0x476) & 0x3f) << 4;
944 Vsrc |= (cx25840_read(client, 0x475) & 0xf0) >> 4;
945
946 Hsrc = (cx25840_read(client, 0x472) & 0x3f) << 4;
947 Hsrc |= (cx25840_read(client, 0x471) & 0xf0) >> 4;
948
949 Vlines = pix->height + (is_50Hz ? 4 : 7);
950
951 if ((pix->width * 16 < Hsrc) || (Hsrc < pix->width) ||
952 (Vlines * 8 < Vsrc) || (Vsrc < Vlines)) {
953 v4l_err(client, "%dx%d is not a valid size!\n",
954 pix->width, pix->height);
955 return -ERANGE;
956 }
957
958 HSC = (Hsrc * (1 << 20)) / pix->width - (1 << 20);
959 VSC = (1 << 16) - (Vsrc * (1 << 9) / Vlines - (1 << 9));
960 VSC &= 0x1fff;
961
962 if (pix->width >= 385)
963 filter = 0;
964 else if (pix->width > 192)
965 filter = 1;
966 else if (pix->width > 96)
967 filter = 2;
968 else
969 filter = 3;
970
971 v4l_dbg(1, cx25840_debug, client, "decoder set size %dx%d -> scale %ux%u\n",
972 pix->width, pix->height, HSC, VSC);
973
974 /* HSCALE=HSC */
975 cx25840_write(client, 0x418, HSC & 0xff);
976 cx25840_write(client, 0x419, (HSC >> 8) & 0xff);
977 cx25840_write(client, 0x41a, HSC >> 16);
978 /* VSCALE=VSC */
979 cx25840_write(client, 0x41c, VSC & 0xff);
980 cx25840_write(client, 0x41d, VSC >> 8);
981 /* VS_INTRLACE=1 VFILT=filter */
982 cx25840_write(client, 0x41e, 0x8 | filter);
983 break;
984
985 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
986 return cx25840_vbi_s_fmt(sd, fmt);
987
988 case V4L2_BUF_TYPE_VBI_CAPTURE:
989 return cx25840_vbi_s_fmt(sd, fmt);
990
991 default:
992 return -EINVAL;
993 }
994
995 return 0;
996 }
997
998 /* ----------------------------------------------------------------------- */
999
1000 static void log_video_status(struct i2c_client *client)
1001 {
1002 static const char *const fmt_strs[] = {
1003 "0x0",
1004 "NTSC-M", "NTSC-J", "NTSC-4.43",
1005 "PAL-BDGHI", "PAL-M", "PAL-N", "PAL-Nc", "PAL-60",
1006 "0x9", "0xA", "0xB",
1007 "SECAM",
1008 "0xD", "0xE", "0xF"
1009 };
1010
1011 struct cx25840_state *state = to_state(i2c_get_clientdata(client));
1012 u8 vidfmt_sel = cx25840_read(client, 0x400) & 0xf;
1013 u8 gen_stat1 = cx25840_read(client, 0x40d);
1014 u8 gen_stat2 = cx25840_read(client, 0x40e);
1015 int vid_input = state->vid_input;
1016
1017 v4l_info(client, "Video signal: %spresent\n",
1018 (gen_stat2 & 0x20) ? "" : "not ");
1019 v4l_info(client, "Detected format: %s\n",
1020 fmt_strs[gen_stat1 & 0xf]);
1021
1022 v4l_info(client, "Specified standard: %s\n",
1023 vidfmt_sel ? fmt_strs[vidfmt_sel] : "automatic detection");
1024
1025 if (vid_input >= CX25840_COMPOSITE1 &&
1026 vid_input <= CX25840_COMPOSITE8) {
1027 v4l_info(client, "Specified video input: Composite %d\n",
1028 vid_input - CX25840_COMPOSITE1 + 1);
1029 } else {
1030 v4l_info(client, "Specified video input: S-Video (Luma In%d, Chroma In%d)\n",
1031 (vid_input & 0xf0) >> 4, (vid_input & 0xf00) >> 8);
1032 }
1033
1034 v4l_info(client, "Specified audioclock freq: %d Hz\n", state->audclk_freq);
1035 }
1036
1037 /* ----------------------------------------------------------------------- */
1038
1039 static void log_audio_status(struct i2c_client *client)
1040 {
1041 struct cx25840_state *state = to_state(i2c_get_clientdata(client));
1042 u8 download_ctl = cx25840_read(client, 0x803);
1043 u8 mod_det_stat0 = cx25840_read(client, 0x804);
1044 u8 mod_det_stat1 = cx25840_read(client, 0x805);
1045 u8 audio_config = cx25840_read(client, 0x808);
1046 u8 pref_mode = cx25840_read(client, 0x809);
1047 u8 afc0 = cx25840_read(client, 0x80b);
1048 u8 mute_ctl = cx25840_read(client, 0x8d3);
1049 int aud_input = state->aud_input;
1050 char *p;
1051
1052 switch (mod_det_stat0) {
1053 case 0x00: p = "mono"; break;
1054 case 0x01: p = "stereo"; break;
1055 case 0x02: p = "dual"; break;
1056 case 0x04: p = "tri"; break;
1057 case 0x10: p = "mono with SAP"; break;
1058 case 0x11: p = "stereo with SAP"; break;
1059 case 0x12: p = "dual with SAP"; break;
1060 case 0x14: p = "tri with SAP"; break;
1061 case 0xfe: p = "forced mode"; break;
1062 default: p = "not defined";
1063 }
1064 v4l_info(client, "Detected audio mode: %s\n", p);
1065
1066 switch (mod_det_stat1) {
1067 case 0x00: p = "not defined"; break;
1068 case 0x01: p = "EIAJ"; break;
1069 case 0x02: p = "A2-M"; break;
1070 case 0x03: p = "A2-BG"; break;
1071 case 0x04: p = "A2-DK1"; break;
1072 case 0x05: p = "A2-DK2"; break;
1073 case 0x06: p = "A2-DK3"; break;
1074 case 0x07: p = "A1 (6.0 MHz FM Mono)"; break;
1075 case 0x08: p = "AM-L"; break;
1076 case 0x09: p = "NICAM-BG"; break;
1077 case 0x0a: p = "NICAM-DK"; break;
1078 case 0x0b: p = "NICAM-I"; break;
1079 case 0x0c: p = "NICAM-L"; break;
1080 case 0x0d: p = "BTSC/EIAJ/A2-M Mono (4.5 MHz FMMono)"; break;
1081 case 0x0e: p = "IF FM Radio"; break;
1082 case 0x0f: p = "BTSC"; break;
1083 case 0x10: p = "high-deviation FM"; break;
1084 case 0x11: p = "very high-deviation FM"; break;
1085 case 0xfd: p = "unknown audio standard"; break;
1086 case 0xfe: p = "forced audio standard"; break;
1087 case 0xff: p = "no detected audio standard"; break;
1088 default: p = "not defined";
1089 }
1090 v4l_info(client, "Detected audio standard: %s\n", p);
1091 v4l_info(client, "Audio muted: %s\n",
1092 (state->unmute_volume >= 0) ? "yes" : "no");
1093 v4l_info(client, "Audio microcontroller: %s\n",
1094 (download_ctl & 0x10) ?
1095 ((mute_ctl & 0x2) ? "detecting" : "running") : "stopped");
1096
1097 switch (audio_config >> 4) {
1098 case 0x00: p = "undefined"; break;
1099 case 0x01: p = "BTSC"; break;
1100 case 0x02: p = "EIAJ"; break;
1101 case 0x03: p = "A2-M"; break;
1102 case 0x04: p = "A2-BG"; break;
1103 case 0x05: p = "A2-DK1"; break;
1104 case 0x06: p = "A2-DK2"; break;
1105 case 0x07: p = "A2-DK3"; break;
1106 case 0x08: p = "A1 (6.0 MHz FM Mono)"; break;
1107 case 0x09: p = "AM-L"; break;
1108 case 0x0a: p = "NICAM-BG"; break;
1109 case 0x0b: p = "NICAM-DK"; break;
1110 case 0x0c: p = "NICAM-I"; break;
1111 case 0x0d: p = "NICAM-L"; break;
1112 case 0x0e: p = "FM radio"; break;
1113 case 0x0f: p = "automatic detection"; break;
1114 default: p = "undefined";
1115 }
1116 v4l_info(client, "Configured audio standard: %s\n", p);
1117
1118 if ((audio_config >> 4) < 0xF) {
1119 switch (audio_config & 0xF) {
1120 case 0x00: p = "MONO1 (LANGUAGE A/Mono L+R channel for BTSC, EIAJ, A2)"; break;
1121 case 0x01: p = "MONO2 (LANGUAGE B)"; break;
1122 case 0x02: p = "MONO3 (STEREO forced MONO)"; break;
1123 case 0x03: p = "MONO4 (NICAM ANALOG-Language C/Analog Fallback)"; break;
1124 case 0x04: p = "STEREO"; break;
1125 case 0x05: p = "DUAL1 (AB)"; break;
1126 case 0x06: p = "DUAL2 (AC) (FM)"; break;
1127 case 0x07: p = "DUAL3 (BC) (FM)"; break;
1128 case 0x08: p = "DUAL4 (AC) (AM)"; break;
1129 case 0x09: p = "DUAL5 (BC) (AM)"; break;
1130 case 0x0a: p = "SAP"; break;
1131 default: p = "undefined";
1132 }
1133 v4l_info(client, "Configured audio mode: %s\n", p);
1134 } else {
1135 switch (audio_config & 0xF) {
1136 case 0x00: p = "BG"; break;
1137 case 0x01: p = "DK1"; break;
1138 case 0x02: p = "DK2"; break;
1139 case 0x03: p = "DK3"; break;
1140 case 0x04: p = "I"; break;
1141 case 0x05: p = "L"; break;
1142 case 0x06: p = "BTSC"; break;
1143 case 0x07: p = "EIAJ"; break;
1144 case 0x08: p = "A2-M"; break;
1145 case 0x09: p = "FM Radio"; break;
1146 case 0x0f: p = "automatic standard and mode detection"; break;
1147 default: p = "undefined";
1148 }
1149 v4l_info(client, "Configured audio system: %s\n", p);
1150 }
1151
1152 if (aud_input) {
1153 v4l_info(client, "Specified audio input: Tuner (In%d)\n", aud_input);
1154 } else {
1155 v4l_info(client, "Specified audio input: External\n");
1156 }
1157
1158 switch (pref_mode & 0xf) {
1159 case 0: p = "mono/language A"; break;
1160 case 1: p = "language B"; break;
1161 case 2: p = "language C"; break;
1162 case 3: p = "analog fallback"; break;
1163 case 4: p = "stereo"; break;
1164 case 5: p = "language AC"; break;
1165 case 6: p = "language BC"; break;
1166 case 7: p = "language AB"; break;
1167 default: p = "undefined";
1168 }
1169 v4l_info(client, "Preferred audio mode: %s\n", p);
1170
1171 if ((audio_config & 0xf) == 0xf) {
1172 switch ((afc0 >> 3) & 0x3) {
1173 case 0: p = "system DK"; break;
1174 case 1: p = "system L"; break;
1175 case 2: p = "autodetect"; break;
1176 default: p = "undefined";
1177 }
1178 v4l_info(client, "Selected 65 MHz format: %s\n", p);
1179
1180 switch (afc0 & 0x7) {
1181 case 0: p = "chroma"; break;
1182 case 1: p = "BTSC"; break;
1183 case 2: p = "EIAJ"; break;
1184 case 3: p = "A2-M"; break;
1185 case 4: p = "autodetect"; break;
1186 default: p = "undefined";
1187 }
1188 v4l_info(client, "Selected 45 MHz format: %s\n", p);
1189 }
1190 }
1191
1192 /* ----------------------------------------------------------------------- */
1193
1194 /* This load_fw operation must be called to load the driver's firmware.
1195 Without this the audio standard detection will fail and you will
1196 only get mono.
1197
1198 Since loading the firmware is often problematic when the driver is
1199 compiled into the kernel I recommend postponing calling this function
1200 until the first open of the video device. Another reason for
1201 postponing it is that loading this firmware takes a long time (seconds)
1202 due to the slow i2c bus speed. So it will speed up the boot process if
1203 you can avoid loading the fw as long as the video device isn't used. */
1204 static int cx25840_load_fw(struct v4l2_subdev *sd)
1205 {
1206 struct cx25840_state *state = to_state(sd);
1207 struct i2c_client *client = v4l2_get_subdevdata(sd);
1208
1209 if (!state->is_initialized) {
1210 /* initialize and load firmware */
1211 state->is_initialized = 1;
1212 if (state->is_cx25836)
1213 cx25836_initialize(client);
1214 else if (state->is_cx23885)
1215 cx23885_initialize(client);
1216 else if (state->is_cx231xx)
1217 cx231xx_initialize(client);
1218 else
1219 cx25840_initialize(client);
1220 }
1221 return 0;
1222 }
1223
1224 #ifdef CONFIG_VIDEO_ADV_DEBUG
1225 static int cx25840_g_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
1226 {
1227 struct i2c_client *client = v4l2_get_subdevdata(sd);
1228
1229 if (!v4l2_chip_match_i2c_client(client, &reg->match))
1230 return -EINVAL;
1231 if (!capable(CAP_SYS_ADMIN))
1232 return -EPERM;
1233 reg->size = 1;
1234 reg->val = cx25840_read(client, reg->reg & 0x0fff);
1235 return 0;
1236 }
1237
1238 static int cx25840_s_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
1239 {
1240 struct i2c_client *client = v4l2_get_subdevdata(sd);
1241
1242 if (!v4l2_chip_match_i2c_client(client, &reg->match))
1243 return -EINVAL;
1244 if (!capable(CAP_SYS_ADMIN))
1245 return -EPERM;
1246 cx25840_write(client, reg->reg & 0x0fff, reg->val & 0xff);
1247 return 0;
1248 }
1249 #endif
1250
1251 static int cx25840_s_stream(struct v4l2_subdev *sd, int enable)
1252 {
1253 struct cx25840_state *state = to_state(sd);
1254 struct i2c_client *client = v4l2_get_subdevdata(sd);
1255
1256 v4l_dbg(1, cx25840_debug, client, "%s output\n",
1257 enable ? "enable" : "disable");
1258 if (enable) {
1259 if (state->is_cx23885 || state->is_cx231xx) {
1260 u8 v = (cx25840_read(client, 0x421) | 0x0b);
1261 cx25840_write(client, 0x421, v);
1262 } else {
1263 cx25840_write(client, 0x115,
1264 state->is_cx25836 ? 0x0c : 0x8c);
1265 cx25840_write(client, 0x116,
1266 state->is_cx25836 ? 0x04 : 0x07);
1267 }
1268 } else {
1269 if (state->is_cx23885 || state->is_cx231xx) {
1270 u8 v = cx25840_read(client, 0x421) & ~(0x0b);
1271 cx25840_write(client, 0x421, v);
1272 } else {
1273 cx25840_write(client, 0x115, 0x00);
1274 cx25840_write(client, 0x116, 0x00);
1275 }
1276 }
1277 return 0;
1278 }
1279
1280 static int cx25840_queryctrl(struct v4l2_subdev *sd, struct v4l2_queryctrl *qc)
1281 {
1282 struct cx25840_state *state = to_state(sd);
1283
1284 switch (qc->id) {
1285 case V4L2_CID_BRIGHTNESS:
1286 return v4l2_ctrl_query_fill(qc, 0, 255, 1, 128);
1287 case V4L2_CID_CONTRAST:
1288 case V4L2_CID_SATURATION:
1289 return v4l2_ctrl_query_fill(qc, 0, 127, 1, 64);
1290 case V4L2_CID_HUE:
1291 return v4l2_ctrl_query_fill(qc, -128, 127, 1, 0);
1292 default:
1293 break;
1294 }
1295 if (state->is_cx25836)
1296 return -EINVAL;
1297
1298 switch (qc->id) {
1299 case V4L2_CID_AUDIO_VOLUME:
1300 return v4l2_ctrl_query_fill(qc, 0, 65535,
1301 65535 / 100, state->default_volume);
1302 case V4L2_CID_AUDIO_MUTE:
1303 return v4l2_ctrl_query_fill(qc, 0, 1, 1, 0);
1304 case V4L2_CID_AUDIO_BALANCE:
1305 case V4L2_CID_AUDIO_BASS:
1306 case V4L2_CID_AUDIO_TREBLE:
1307 return v4l2_ctrl_query_fill(qc, 0, 65535, 65535 / 100, 32768);
1308 default:
1309 return -EINVAL;
1310 }
1311 return -EINVAL;
1312 }
1313
1314 static int cx25840_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
1315 {
1316 struct cx25840_state *state = to_state(sd);
1317 struct i2c_client *client = v4l2_get_subdevdata(sd);
1318
1319 if (state->radio == 0 && state->std == std)
1320 return 0;
1321 state->radio = 0;
1322 state->std = std;
1323 return set_v4lstd(client);
1324 }
1325
1326 static int cx25840_s_radio(struct v4l2_subdev *sd)
1327 {
1328 struct cx25840_state *state = to_state(sd);
1329
1330 state->radio = 1;
1331 return 0;
1332 }
1333
1334 static int cx25840_s_video_routing(struct v4l2_subdev *sd,
1335 u32 input, u32 output, u32 config)
1336 {
1337 struct cx25840_state *state = to_state(sd);
1338 struct i2c_client *client = v4l2_get_subdevdata(sd);
1339
1340 return set_input(client, input, state->aud_input);
1341 }
1342
1343 static int cx25840_s_audio_routing(struct v4l2_subdev *sd,
1344 u32 input, u32 output, u32 config)
1345 {
1346 struct cx25840_state *state = to_state(sd);
1347 struct i2c_client *client = v4l2_get_subdevdata(sd);
1348
1349 if (state->is_cx25836)
1350 return -EINVAL;
1351 return set_input(client, state->vid_input, input);
1352 }
1353
1354 static int cx25840_s_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *freq)
1355 {
1356 struct cx25840_state *state = to_state(sd);
1357 struct i2c_client *client = v4l2_get_subdevdata(sd);
1358
1359 if (!state->is_cx25836)
1360 input_change(client);
1361 return 0;
1362 }
1363
1364 static int cx25840_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1365 {
1366 struct cx25840_state *state = to_state(sd);
1367 struct i2c_client *client = v4l2_get_subdevdata(sd);
1368 u8 vpres = cx25840_read(client, 0x40e) & 0x20;
1369 u8 mode;
1370 int val = 0;
1371
1372 if (state->radio)
1373 return 0;
1374
1375 vt->signal = vpres ? 0xffff : 0x0;
1376 if (state->is_cx25836)
1377 return 0;
1378
1379 vt->capability |=
1380 V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_LANG1 |
1381 V4L2_TUNER_CAP_LANG2 | V4L2_TUNER_CAP_SAP;
1382
1383 mode = cx25840_read(client, 0x804);
1384
1385 /* get rxsubchans and audmode */
1386 if ((mode & 0xf) == 1)
1387 val |= V4L2_TUNER_SUB_STEREO;
1388 else
1389 val |= V4L2_TUNER_SUB_MONO;
1390
1391 if (mode == 2 || mode == 4)
1392 val = V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_LANG2;
1393
1394 if (mode & 0x10)
1395 val |= V4L2_TUNER_SUB_SAP;
1396
1397 vt->rxsubchans = val;
1398 vt->audmode = state->audmode;
1399 return 0;
1400 }
1401
1402 static int cx25840_s_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1403 {
1404 struct cx25840_state *state = to_state(sd);
1405 struct i2c_client *client = v4l2_get_subdevdata(sd);
1406
1407 if (state->radio || state->is_cx25836)
1408 return 0;
1409
1410 switch (vt->audmode) {
1411 case V4L2_TUNER_MODE_MONO:
1412 /* mono -> mono
1413 stereo -> mono
1414 bilingual -> lang1 */
1415 cx25840_and_or(client, 0x809, ~0xf, 0x00);
1416 break;
1417 case V4L2_TUNER_MODE_STEREO:
1418 case V4L2_TUNER_MODE_LANG1:
1419 /* mono -> mono
1420 stereo -> stereo
1421 bilingual -> lang1 */
1422 cx25840_and_or(client, 0x809, ~0xf, 0x04);
1423 break;
1424 case V4L2_TUNER_MODE_LANG1_LANG2:
1425 /* mono -> mono
1426 stereo -> stereo
1427 bilingual -> lang1/lang2 */
1428 cx25840_and_or(client, 0x809, ~0xf, 0x07);
1429 break;
1430 case V4L2_TUNER_MODE_LANG2:
1431 /* mono -> mono
1432 stereo -> stereo
1433 bilingual -> lang2 */
1434 cx25840_and_or(client, 0x809, ~0xf, 0x01);
1435 break;
1436 default:
1437 return -EINVAL;
1438 }
1439 state->audmode = vt->audmode;
1440 return 0;
1441 }
1442
1443 static int cx25840_reset(struct v4l2_subdev *sd, u32 val)
1444 {
1445 struct cx25840_state *state = to_state(sd);
1446 struct i2c_client *client = v4l2_get_subdevdata(sd);
1447
1448 if (state->is_cx25836)
1449 cx25836_initialize(client);
1450 else if (state->is_cx23885)
1451 cx23885_initialize(client);
1452 else if (state->is_cx231xx)
1453 cx231xx_initialize(client);
1454 else
1455 cx25840_initialize(client);
1456 return 0;
1457 }
1458
1459 static int cx25840_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip)
1460 {
1461 struct cx25840_state *state = to_state(sd);
1462 struct i2c_client *client = v4l2_get_subdevdata(sd);
1463
1464 return v4l2_chip_ident_i2c_client(client, chip, state->id, state->rev);
1465 }
1466
1467 static int cx25840_log_status(struct v4l2_subdev *sd)
1468 {
1469 struct cx25840_state *state = to_state(sd);
1470 struct i2c_client *client = v4l2_get_subdevdata(sd);
1471
1472 log_video_status(client);
1473 if (!state->is_cx25836)
1474 log_audio_status(client);
1475 return 0;
1476 }
1477
1478 /* ----------------------------------------------------------------------- */
1479
1480 static const struct v4l2_subdev_core_ops cx25840_core_ops = {
1481 .log_status = cx25840_log_status,
1482 .g_chip_ident = cx25840_g_chip_ident,
1483 .g_ctrl = cx25840_g_ctrl,
1484 .s_ctrl = cx25840_s_ctrl,
1485 .queryctrl = cx25840_queryctrl,
1486 .s_std = cx25840_s_std,
1487 .reset = cx25840_reset,
1488 .load_fw = cx25840_load_fw,
1489 #ifdef CONFIG_VIDEO_ADV_DEBUG
1490 .g_register = cx25840_g_register,
1491 .s_register = cx25840_s_register,
1492 #endif
1493 };
1494
1495 static const struct v4l2_subdev_tuner_ops cx25840_tuner_ops = {
1496 .s_frequency = cx25840_s_frequency,
1497 .s_radio = cx25840_s_radio,
1498 .g_tuner = cx25840_g_tuner,
1499 .s_tuner = cx25840_s_tuner,
1500 };
1501
1502 static const struct v4l2_subdev_audio_ops cx25840_audio_ops = {
1503 .s_clock_freq = cx25840_s_clock_freq,
1504 .s_routing = cx25840_s_audio_routing,
1505 };
1506
1507 static const struct v4l2_subdev_video_ops cx25840_video_ops = {
1508 .s_routing = cx25840_s_video_routing,
1509 .g_fmt = cx25840_g_fmt,
1510 .s_fmt = cx25840_s_fmt,
1511 .decode_vbi_line = cx25840_decode_vbi_line,
1512 .s_stream = cx25840_s_stream,
1513 };
1514
1515 static const struct v4l2_subdev_ops cx25840_ops = {
1516 .core = &cx25840_core_ops,
1517 .tuner = &cx25840_tuner_ops,
1518 .audio = &cx25840_audio_ops,
1519 .video = &cx25840_video_ops,
1520 };
1521
1522 /* ----------------------------------------------------------------------- */
1523
1524 static int cx25840_probe(struct i2c_client *client,
1525 const struct i2c_device_id *did)
1526 {
1527 struct cx25840_state *state;
1528 struct v4l2_subdev *sd;
1529 u32 id;
1530 u16 device_id;
1531
1532 /* Check if the adapter supports the needed features */
1533 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1534 return -EIO;
1535
1536 v4l_dbg(1, cx25840_debug, client, "detecting cx25840 client on address 0x%x\n", client->addr << 1);
1537
1538 device_id = cx25840_read(client, 0x101) << 8;
1539 device_id |= cx25840_read(client, 0x100);
1540 v4l_dbg(1, cx25840_debug, client, "device_id = 0x%04x\n", device_id);
1541
1542 /* The high byte of the device ID should be
1543 * 0x83 for the cx2583x and 0x84 for the cx2584x */
1544 if ((device_id & 0xff00) == 0x8300) {
1545 id = V4L2_IDENT_CX25836 + ((device_id >> 4) & 0xf) - 6;
1546 }
1547 else if ((device_id & 0xff00) == 0x8400) {
1548 id = V4L2_IDENT_CX25840 + ((device_id >> 4) & 0xf);
1549 } else if (device_id == 0x0000) {
1550 id = V4L2_IDENT_CX25836 + ((device_id >> 4) & 0xf) - 6;
1551 } else if (device_id == 0x1313) {
1552 id = V4L2_IDENT_CX25836 + ((device_id >> 4) & 0xf) - 6;
1553 } else if ((device_id & 0xfff0) == 0x5A30) {
1554 id = V4L2_IDENT_CX25840 + ((device_id >> 4) & 0xf);
1555 }
1556 else {
1557 v4l_dbg(1, cx25840_debug, client, "cx25840 not found\n");
1558 return -ENODEV;
1559 }
1560
1561 state = kzalloc(sizeof(struct cx25840_state), GFP_KERNEL);
1562 if (state == NULL)
1563 return -ENOMEM;
1564
1565 sd = &state->sd;
1566 v4l2_i2c_subdev_init(sd, client, &cx25840_ops);
1567 /* Note: revision '(device_id & 0x0f) == 2' was never built. The
1568 marking skips from 0x1 == 22 to 0x3 == 23. */
1569 v4l_info(client, "cx25%3x-2%x found @ 0x%x (%s)\n",
1570 (device_id & 0xfff0) >> 4,
1571 (device_id & 0x0f) < 3 ? (device_id & 0x0f) + 1 : (device_id & 0x0f),
1572 client->addr << 1, client->adapter->name);
1573
1574 state->c = client;
1575 state->is_cx25836 = ((device_id & 0xff00) == 0x8300);
1576 state->is_cx23885 = (device_id == 0x0000) || (device_id == 0x1313);
1577 state->is_cx231xx = (device_id == 0x5a3e);
1578 state->vid_input = CX25840_COMPOSITE7;
1579 state->aud_input = CX25840_AUDIO8;
1580 state->audclk_freq = 48000;
1581 state->pvr150_workaround = 0;
1582 state->audmode = V4L2_TUNER_MODE_LANG1;
1583 state->unmute_volume = -1;
1584 state->default_volume = 228 - cx25840_read(client, 0x8d4);
1585 state->default_volume = ((state->default_volume / 2) + 23) << 9;
1586 state->vbi_line_offset = 8;
1587 state->id = id;
1588 state->rev = device_id;
1589
1590 return 0;
1591 }
1592
1593 static int cx25840_remove(struct i2c_client *client)
1594 {
1595 struct v4l2_subdev *sd = i2c_get_clientdata(client);
1596
1597 v4l2_device_unregister_subdev(sd);
1598 kfree(to_state(sd));
1599 return 0;
1600 }
1601
1602 static const struct i2c_device_id cx25840_id[] = {
1603 { "cx25840", 0 },
1604 { }
1605 };
1606 MODULE_DEVICE_TABLE(i2c, cx25840_id);
1607
1608 static struct v4l2_i2c_driver_data v4l2_i2c_data = {
1609 .name = "cx25840",
1610 .probe = cx25840_probe,
1611 .remove = cx25840_remove,
1612 .id_table = cx25840_id,
1613 };
Linux for Ginger Game Console