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