1 /* cx25840 - Conexant CX25840 audio/video decoder driver
3 * Copyright (C) 2004 Ulf Eklund
5 * Based on the saa7115 driver and on the first verison of Chris Kennedy's
8 * Changes by Tyler Trafford <tatrafford@comcast.net>
9 * - cleanup/rewrite for V4L2 API (2005)
11 * VBI support by Hans Verkuil <hverkuil@xs4all.nl>.
13 * NTSC sliced VBI support by Christopher Neufeld <television@cneufeld.ca>
14 * with additional fixes by Hans Verkuil <hverkuil@xs4all.nl>.
16 * CX23885 support by Steven Toth <stoth@linuxtv.org>.
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.
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.
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.
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-legacy.h>
43 #include <media/cx25840.h>
45 #include "cx25840-core.h"
47 MODULE_DESCRIPTION("Conexant CX25840 audio/video decoder driver");
48 MODULE_AUTHOR("Ulf Eklund, Chris Kennedy, Hans Verkuil, Tyler Trafford");
49 MODULE_LICENSE("GPL");
51 static unsigned short normal_i2c[] = { 0x88 >> 1, I2C_CLIENT_END };
53 static int cx25840_debug;
55 module_param_named(debug,cx25840_debug, int, 0644);
57 MODULE_PARM_DESC(debug, "Debugging messages [0=Off (default) 1=On]");
61 /* ----------------------------------------------------------------------- */
63 int cx25840_write(struct i2c_client *client, u16 addr, u8 value)
66 buffer[0] = addr >> 8;
67 buffer[1] = addr & 0xff;
69 return i2c_master_send(client, buffer, 3);
72 int cx25840_write4(struct i2c_client *client, u16 addr, u32 value)
75 buffer[0] = addr >> 8;
76 buffer[1] = addr & 0xff;
77 buffer[2] = value & 0xff;
78 buffer[3] = (value >> 8) & 0xff;
79 buffer[4] = (value >> 16) & 0xff;
80 buffer[5] = value >> 24;
81 return i2c_master_send(client, buffer, 6);
84 u8 cx25840_read(struct i2c_client * client, u16 addr)
87 buffer[0] = addr >> 8;
88 buffer[1] = addr & 0xff;
90 if (i2c_master_send(client, buffer, 2) < 2)
93 if (i2c_master_recv(client, buffer, 1) < 1)
99 u32 cx25840_read4(struct i2c_client * client, u16 addr)
102 buffer[0] = addr >> 8;
103 buffer[1] = addr & 0xff;
105 if (i2c_master_send(client, buffer, 2) < 2)
108 if (i2c_master_recv(client, buffer, 4) < 4)
111 return (buffer[3] << 24) | (buffer[2] << 16) |
112 (buffer[1] << 8) | buffer[0];
115 int cx25840_and_or(struct i2c_client *client, u16 addr, unsigned and_mask,
118 return cx25840_write(client, addr,
119 (cx25840_read(client, addr) & and_mask) |
123 /* ----------------------------------------------------------------------- */
125 static int set_input(struct i2c_client *client, enum cx25840_video_input vid_input,
126 enum cx25840_audio_input aud_input);
128 /* ----------------------------------------------------------------------- */
130 static void init_dll1(struct i2c_client *client)
132 /* This is the Hauppauge sequence used to
133 * initialize the Delay Lock Loop 1 (ADC DLL). */
134 cx25840_write(client, 0x159, 0x23);
135 cx25840_write(client, 0x15a, 0x87);
136 cx25840_write(client, 0x15b, 0x06);
138 cx25840_write(client, 0x159, 0xe1);
140 cx25840_write(client, 0x15a, 0x86);
141 cx25840_write(client, 0x159, 0xe0);
142 cx25840_write(client, 0x159, 0xe1);
143 cx25840_write(client, 0x15b, 0x10);
146 static void init_dll2(struct i2c_client *client)
148 /* This is the Hauppauge sequence used to
149 * initialize the Delay Lock Loop 2 (ADC DLL). */
150 cx25840_write(client, 0x15d, 0xe3);
151 cx25840_write(client, 0x15e, 0x86);
152 cx25840_write(client, 0x15f, 0x06);
154 cx25840_write(client, 0x15d, 0xe1);
155 cx25840_write(client, 0x15d, 0xe0);
156 cx25840_write(client, 0x15d, 0xe1);
159 static void cx25836_initialize(struct i2c_client *client)
161 /* reset configuration is described on page 3-77 of the CX25836 datasheet */
163 cx25840_and_or(client, 0x000, ~0x01, 0x01);
164 cx25840_and_or(client, 0x000, ~0x01, 0x00);
166 cx25840_and_or(client, 0x15a, ~0x70, 0x00);
168 cx25840_and_or(client, 0x15b, ~0x1e, 0x06);
170 cx25840_and_or(client, 0x159, ~0x02, 0x02);
174 cx25840_and_or(client, 0x159, ~0x02, 0x00);
176 cx25840_and_or(client, 0x159, ~0xc0, 0xc0);
178 cx25840_and_or(client, 0x159, ~0x01, 0x00);
179 cx25840_and_or(client, 0x159, ~0x01, 0x01);
181 cx25840_and_or(client, 0x15b, ~0x1e, 0x10);
184 static void cx25840_work_handler(struct work_struct *work)
186 struct cx25840_state *state = container_of(work, struct cx25840_state, fw_work);
187 cx25840_loadfw(state->c);
188 wake_up(&state->fw_wait);
191 static void cx25840_initialize(struct i2c_client *client)
194 struct cx25840_state *state = to_state(i2c_get_clientdata(client));
195 struct workqueue_struct *q;
197 /* datasheet startup in numbered steps, refer to page 3-77 */
199 cx25840_and_or(client, 0x803, ~0x10, 0x00);
200 /* The default of this register should be 4, but I get 0 instead.
201 * Set this register to 4 manually. */
202 cx25840_write(client, 0x000, 0x04);
206 cx25840_write(client, 0x136, 0x0a);
208 cx25840_write(client, 0x13c, 0x01);
209 cx25840_write(client, 0x13c, 0x00);
211 /* Do the firmware load in a work handler to prevent.
212 Otherwise the kernel is blocked waiting for the
213 bit-banging i2c interface to finish uploading the
215 INIT_WORK(&state->fw_work, cx25840_work_handler);
216 init_waitqueue_head(&state->fw_wait);
217 q = create_singlethread_workqueue("cx25840_fw");
218 prepare_to_wait(&state->fw_wait, &wait, TASK_UNINTERRUPTIBLE);
219 queue_work(q, &state->fw_work);
221 finish_wait(&state->fw_wait, &wait);
222 destroy_workqueue(q);
225 cx25840_write(client, 0x115, 0x8c);
226 cx25840_write(client, 0x116, 0x07);
227 cx25840_write(client, 0x118, 0x02);
229 cx25840_write(client, 0x4a5, 0x80);
230 cx25840_write(client, 0x4a5, 0x00);
231 cx25840_write(client, 0x402, 0x00);
233 cx25840_and_or(client, 0x401, ~0x18, 0);
234 cx25840_and_or(client, 0x4a2, ~0x10, 0x10);
235 /* steps 8c and 8d are done in change_input() */
237 cx25840_write(client, 0x8d3, 0x1f);
238 cx25840_write(client, 0x8e3, 0x03);
240 cx25840_std_setup(client);
242 /* trial and error says these are needed to get audio */
243 cx25840_write(client, 0x914, 0xa0);
244 cx25840_write(client, 0x918, 0xa0);
245 cx25840_write(client, 0x919, 0x01);
247 /* stereo prefered */
248 cx25840_write(client, 0x809, 0x04);
250 cx25840_write(client, 0x8cf, 0x0f);
253 set_input(client, state->vid_input, state->aud_input);
255 /* start microcontroller */
256 cx25840_and_or(client, 0x803, ~0x10, 0x10);
259 static void cx23885_initialize(struct i2c_client *client)
262 struct cx25840_state *state = to_state(i2c_get_clientdata(client));
263 struct workqueue_struct *q;
266 cx25840_and_or(client, 0x102, ~0x01, 0x01);
267 cx25840_and_or(client, 0x102, ~0x01, 0x00);
269 /* Stop microcontroller */
270 cx25840_and_or(client, 0x803, ~0x10, 0x00);
273 cx25840_write(client, 0x398, 0);
275 /* Trust the default xtal, no division */
276 /* This changes for the cx23888 products */
277 cx25840_write(client, 0x2, 0x76);
279 /* Bring down the regulator for AUX clk */
280 cx25840_write(client, 0x1, 0x40);
283 cx25840_write4(client, 0x11c, 0x01d1744c);
286 cx25840_write4(client, 0x118, 0x00000416);
288 /* Disable DIF bypass */
289 cx25840_write4(client, 0x33c, 0x00000001);
291 /* DIF Src phase inc */
292 cx25840_write4(client, 0x340, 0x0df7df83);
295 cx25840_write4(client, 0x10c, 0x01b6db7b);
298 cx25840_write4(client, 0x108, 0x00000512);
301 cx25840_write4(client, 0x414, 0x00107d12);
304 cx25840_write4(client, 0x420, 0x3d008282);
307 cx25840_write4(client, 0x114, 0x017dbf48);
310 cx25840_write4(client, 0x110, 0x000a030e);
312 /* ADC2 input select */
313 cx25840_write(client, 0x102, 0x10);
316 cx25840_write(client, 0x103, 0x11);
318 /* Enable format auto detect */
319 cx25840_write(client, 0x400, 0);
320 /* Fast subchroma lock */
321 /* White crush, Chroma AGC & Chroma Killer enabled */
322 cx25840_write(client, 0x401, 0xe8);
324 /* Select AFE clock pad output source */
325 cx25840_write(client, 0x144, 0x05);
327 /* Do the firmware load in a work handler to prevent.
328 Otherwise the kernel is blocked waiting for the
329 bit-banging i2c interface to finish uploading the
331 INIT_WORK(&state->fw_work, cx25840_work_handler);
332 init_waitqueue_head(&state->fw_wait);
333 q = create_singlethread_workqueue("cx25840_fw");
334 prepare_to_wait(&state->fw_wait, &wait, TASK_UNINTERRUPTIBLE);
335 queue_work(q, &state->fw_work);
337 finish_wait(&state->fw_wait, &wait);
338 destroy_workqueue(q);
340 cx25840_std_setup(client);
343 set_input(client, state->vid_input, state->aud_input);
345 /* start microcontroller */
346 cx25840_and_or(client, 0x803, ~0x10, 0x10);
349 /* ----------------------------------------------------------------------- */
351 void cx25840_std_setup(struct i2c_client *client)
353 struct cx25840_state *state = to_state(i2c_get_clientdata(client));
354 v4l2_std_id std = state->std;
355 int hblank, hactive, burst, vblank, vactive, sc;
356 int vblank656, src_decimation;
357 int luma_lpf, uv_lpf, comb;
358 u32 pll_int, pll_frac, pll_post;
360 /* datasheet startup, step 8d */
361 if (std & ~V4L2_STD_NTSC)
362 cx25840_write(client, 0x49f, 0x11);
364 cx25840_write(client, 0x49f, 0x14);
366 if (std & V4L2_STD_625_50) {
373 src_decimation = 0x21f;
376 if (std & V4L2_STD_SECAM) {
380 } else if (std == V4L2_STD_PAL_Nc) {
396 src_decimation = 0x21f;
397 if (std == V4L2_STD_PAL_60) {
404 } else if (std == V4L2_STD_PAL_M) {
419 /* DEBUG: Displays configured PLL frequency */
420 pll_int = cx25840_read(client, 0x108);
421 pll_frac = cx25840_read4(client, 0x10c) & 0x1ffffff;
422 pll_post = cx25840_read(client, 0x109);
423 v4l_dbg(1, cx25840_debug, client,
424 "PLL regs = int: %u, frac: %u, post: %u\n",
425 pll_int, pll_frac, pll_post);
429 int pll = (28636363L * ((((u64)pll_int) << 25L) + pll_frac)) >> 25L;
432 v4l_dbg(1, cx25840_debug, client, "PLL = %d.%06d MHz\n",
433 pll / 1000000, pll % 1000000);
434 v4l_dbg(1, cx25840_debug, client, "PLL/8 = %d.%06d MHz\n",
435 pll / 8000000, (pll / 8) % 1000000);
437 fin = ((u64)src_decimation * pll) >> 12;
438 v4l_dbg(1, cx25840_debug, client,
439 "ADC Sampling freq = %d.%06d MHz\n",
440 fin / 1000000, fin % 1000000);
442 fsc = (((u64)sc) * pll) >> 24L;
443 v4l_dbg(1, cx25840_debug, client,
444 "Chroma sub-carrier freq = %d.%06d MHz\n",
445 fsc / 1000000, fsc % 1000000);
447 v4l_dbg(1, cx25840_debug, client, "hblank %i, hactive %i, "
448 "vblank %i, vactive %i, vblank656 %i, src_dec %i, "
449 "burst 0x%02x, luma_lpf %i, uv_lpf %i, comb 0x%02x, "
451 hblank, hactive, vblank, vactive, vblank656,
452 src_decimation, burst, luma_lpf, uv_lpf, comb, sc);
455 /* Sets horizontal blanking delay and active lines */
456 cx25840_write(client, 0x470, hblank);
457 cx25840_write(client, 0x471,
458 0xff & (((hblank >> 8) & 0x3) | (hactive << 4)));
459 cx25840_write(client, 0x472, hactive >> 4);
461 /* Sets burst gate delay */
462 cx25840_write(client, 0x473, burst);
464 /* Sets vertical blanking delay and active duration */
465 cx25840_write(client, 0x474, vblank);
466 cx25840_write(client, 0x475,
467 0xff & (((vblank >> 8) & 0x3) | (vactive << 4)));
468 cx25840_write(client, 0x476, vactive >> 4);
469 cx25840_write(client, 0x477, vblank656);
471 /* Sets src decimation rate */
472 cx25840_write(client, 0x478, 0xff & src_decimation);
473 cx25840_write(client, 0x479, 0xff & (src_decimation >> 8));
475 /* Sets Luma and UV Low pass filters */
476 cx25840_write(client, 0x47a, luma_lpf << 6 | ((uv_lpf << 4) & 0x30));
478 /* Enables comb filters */
479 cx25840_write(client, 0x47b, comb);
482 cx25840_write(client, 0x47c, sc);
483 cx25840_write(client, 0x47d, 0xff & sc >> 8);
484 cx25840_write(client, 0x47e, 0xff & sc >> 16);
486 /* Sets VBI parameters */
487 if (std & V4L2_STD_625_50) {
488 cx25840_write(client, 0x47f, 0x01);
489 state->vbi_line_offset = 5;
491 cx25840_write(client, 0x47f, 0x00);
492 state->vbi_line_offset = 8;
496 /* ----------------------------------------------------------------------- */
498 static void input_change(struct i2c_client *client)
500 struct cx25840_state *state = to_state(i2c_get_clientdata(client));
501 v4l2_std_id std = state->std;
503 /* Follow step 8c and 8d of section 3.16 in the cx25840 datasheet */
504 if (std & V4L2_STD_SECAM) {
505 cx25840_write(client, 0x402, 0);
508 cx25840_write(client, 0x402, 0x04);
509 cx25840_write(client, 0x49f, (std & V4L2_STD_NTSC) ? 0x14 : 0x11);
511 cx25840_and_or(client, 0x401, ~0x60, 0);
512 cx25840_and_or(client, 0x401, ~0x60, 0x60);
513 cx25840_and_or(client, 0x810, ~0x01, 1);
516 cx25840_write(client, 0x808, 0xf9);
517 cx25840_write(client, 0x80b, 0x00);
519 else if (std & V4L2_STD_525_60) {
520 /* Certain Hauppauge PVR150 models have a hardware bug
521 that causes audio to drop out. For these models the
522 audio standard must be set explicitly.
523 To be precise: it affects cards with tuner models
524 85, 99 and 112 (model numbers from tveeprom). */
525 int hw_fix = state->pvr150_workaround;
527 if (std == V4L2_STD_NTSC_M_JP) {
528 /* Japan uses EIAJ audio standard */
529 cx25840_write(client, 0x808, hw_fix ? 0x2f : 0xf7);
530 } else if (std == V4L2_STD_NTSC_M_KR) {
531 /* South Korea uses A2 audio standard */
532 cx25840_write(client, 0x808, hw_fix ? 0x3f : 0xf8);
534 /* Others use the BTSC audio standard */
535 cx25840_write(client, 0x808, hw_fix ? 0x1f : 0xf6);
537 cx25840_write(client, 0x80b, 0x00);
538 } else if (std & V4L2_STD_PAL) {
539 /* Follow tuner change procedure for PAL */
540 cx25840_write(client, 0x808, 0xff);
541 cx25840_write(client, 0x80b, 0x10);
542 } else if (std & V4L2_STD_SECAM) {
543 /* Select autodetect for SECAM */
544 cx25840_write(client, 0x808, 0xff);
545 cx25840_write(client, 0x80b, 0x10);
548 cx25840_and_or(client, 0x810, ~0x01, 0);
551 static int set_input(struct i2c_client *client, enum cx25840_video_input vid_input,
552 enum cx25840_audio_input aud_input)
554 struct cx25840_state *state = to_state(i2c_get_clientdata(client));
555 u8 is_composite = (vid_input >= CX25840_COMPOSITE1 &&
556 vid_input <= CX25840_COMPOSITE8);
559 v4l_dbg(1, cx25840_debug, client,
560 "decoder set video input %d, audio input %d\n",
561 vid_input, aud_input);
563 if (vid_input >= CX25840_VIN1_CH1) {
564 v4l_dbg(1, cx25840_debug, client, "vid_input 0x%x\n",
566 reg = vid_input & 0xff;
567 if ((vid_input & CX25840_SVIDEO_ON) == CX25840_SVIDEO_ON)
572 v4l_dbg(1, cx25840_debug, client, "mux cfg 0x%x comp=%d\n",
576 reg = 0xf0 + (vid_input - CX25840_COMPOSITE1);
578 int luma = vid_input & 0xf0;
579 int chroma = vid_input & 0xf00;
581 if ((vid_input & ~0xff0) ||
582 luma < CX25840_SVIDEO_LUMA1 || luma > CX25840_SVIDEO_LUMA8 ||
583 chroma < CX25840_SVIDEO_CHROMA4 || chroma > CX25840_SVIDEO_CHROMA8) {
584 v4l_err(client, "0x%04x is not a valid video input!\n",
588 reg = 0xf0 + ((luma - CX25840_SVIDEO_LUMA1) >> 4);
589 if (chroma >= CX25840_SVIDEO_CHROMA7) {
591 reg |= (chroma - CX25840_SVIDEO_CHROMA7) >> 2;
594 reg |= (chroma - CX25840_SVIDEO_CHROMA4) >> 4;
598 /* The caller has previously prepared the correct routing
599 * configuration in reg (for the cx23885) so we have no
600 * need to attempt to flip bits for earlier av decoders.
602 if (!state->is_cx23885) {
604 case CX25840_AUDIO_SERIAL:
605 /* do nothing, use serial audio input */
607 case CX25840_AUDIO4: reg &= ~0x30; break;
608 case CX25840_AUDIO5: reg &= ~0x30; reg |= 0x10; break;
609 case CX25840_AUDIO6: reg &= ~0x30; reg |= 0x20; break;
610 case CX25840_AUDIO7: reg &= ~0xc0; break;
611 case CX25840_AUDIO8: reg &= ~0xc0; reg |= 0x40; break;
614 v4l_err(client, "0x%04x is not a valid audio input!\n",
620 cx25840_write(client, 0x103, reg);
622 /* Set INPUT_MODE to Composite (0) or S-Video (1) */
623 cx25840_and_or(client, 0x401, ~0x6, is_composite ? 0 : 0x02);
625 if (!state->is_cx23885) {
626 /* Set CH_SEL_ADC2 to 1 if input comes from CH3 */
627 cx25840_and_or(client, 0x102, ~0x2, (reg & 0x80) == 0 ? 2 : 0);
628 /* Set DUAL_MODE_ADC2 to 1 if input comes from both CH2&CH3 */
629 if ((reg & 0xc0) != 0xc0 && (reg & 0x30) != 0x30)
630 cx25840_and_or(client, 0x102, ~0x4, 4);
632 cx25840_and_or(client, 0x102, ~0x4, 0);
635 /* ADC2 input select channel 2 */
636 cx25840_and_or(client, 0x102, ~0x2, 0);
638 /* ADC2 input select channel 3 */
639 cx25840_and_or(client, 0x102, ~0x2, 2);
642 state->vid_input = vid_input;
643 state->aud_input = aud_input;
644 if (!state->is_cx25836) {
645 cx25840_audio_set_path(client);
646 input_change(client);
649 if (state->is_cx23885) {
650 /* Audio channel 1 src : Parallel 1 */
651 cx25840_write(client, 0x124, 0x03);
653 /* Select AFE clock pad output source */
654 cx25840_write(client, 0x144, 0x05);
656 /* I2S_IN_CTL: I2S_IN_SONY_MODE, LEFT SAMPLE on WS=1 */
657 cx25840_write(client, 0x914, 0xa0);
660 * I2S_IN_SONY_MODE, LEFT SAMPLE on WS=1
661 * I2S_OUT_MASTER_MODE = Master
663 cx25840_write(client, 0x918, 0xa0);
664 cx25840_write(client, 0x919, 0x01);
670 /* ----------------------------------------------------------------------- */
672 static int set_v4lstd(struct i2c_client *client)
674 struct cx25840_state *state = to_state(i2c_get_clientdata(client));
675 u8 fmt = 0; /* zero is autodetect */
678 /* First tests should be against specific std */
679 if (state->std == V4L2_STD_NTSC_M_JP) {
681 } else if (state->std == V4L2_STD_NTSC_443) {
683 } else if (state->std == V4L2_STD_PAL_M) {
686 } else if (state->std == V4L2_STD_PAL_N) {
688 } else if (state->std == V4L2_STD_PAL_Nc) {
690 } else if (state->std == V4L2_STD_PAL_60) {
693 /* Then, test against generic ones */
694 if (state->std & V4L2_STD_NTSC)
696 else if (state->std & V4L2_STD_PAL)
698 else if (state->std & V4L2_STD_SECAM)
702 v4l_dbg(1, cx25840_debug, client, "changing video std to fmt %i\n",fmt);
704 /* Follow step 9 of section 3.16 in the cx25840 datasheet.
705 Without this PAL may display a vertical ghosting effect.
706 This happens for example with the Yuan MPC622. */
707 if (fmt >= 4 && fmt < 8) {
708 /* Set format to NTSC-M */
709 cx25840_and_or(client, 0x400, ~0xf, 1);
711 cx25840_and_or(client, 0x47b, ~6, 0);
713 cx25840_and_or(client, 0x400, ~0xf, fmt);
714 cx25840_and_or(client, 0x403, ~0x3, pal_m);
715 cx25840_std_setup(client);
716 if (!state->is_cx25836)
717 input_change(client);
721 /* ----------------------------------------------------------------------- */
723 static int cx25840_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
725 struct cx25840_state *state = to_state(sd);
726 struct i2c_client *client = v4l2_get_subdevdata(sd);
729 case CX25840_CID_ENABLE_PVR150_WORKAROUND:
730 state->pvr150_workaround = ctrl->value;
731 set_input(client, state->vid_input, state->aud_input);
734 case V4L2_CID_BRIGHTNESS:
735 if (ctrl->value < 0 || ctrl->value > 255) {
736 v4l_err(client, "invalid brightness setting %d\n",
741 cx25840_write(client, 0x414, ctrl->value - 128);
744 case V4L2_CID_CONTRAST:
745 if (ctrl->value < 0 || ctrl->value > 127) {
746 v4l_err(client, "invalid contrast setting %d\n",
751 cx25840_write(client, 0x415, ctrl->value << 1);
754 case V4L2_CID_SATURATION:
755 if (ctrl->value < 0 || ctrl->value > 127) {
756 v4l_err(client, "invalid saturation setting %d\n",
761 cx25840_write(client, 0x420, ctrl->value << 1);
762 cx25840_write(client, 0x421, ctrl->value << 1);
766 if (ctrl->value < -128 || ctrl->value > 127) {
767 v4l_err(client, "invalid hue setting %d\n", ctrl->value);
771 cx25840_write(client, 0x422, ctrl->value);
774 case V4L2_CID_AUDIO_VOLUME:
775 case V4L2_CID_AUDIO_BASS:
776 case V4L2_CID_AUDIO_TREBLE:
777 case V4L2_CID_AUDIO_BALANCE:
778 case V4L2_CID_AUDIO_MUTE:
779 if (state->is_cx25836)
781 return cx25840_audio(client, VIDIOC_S_CTRL, ctrl);
790 static int cx25840_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
792 struct cx25840_state *state = to_state(sd);
793 struct i2c_client *client = v4l2_get_subdevdata(sd);
796 case CX25840_CID_ENABLE_PVR150_WORKAROUND:
797 ctrl->value = state->pvr150_workaround;
799 case V4L2_CID_BRIGHTNESS:
800 ctrl->value = (s8)cx25840_read(client, 0x414) + 128;
802 case V4L2_CID_CONTRAST:
803 ctrl->value = cx25840_read(client, 0x415) >> 1;
805 case V4L2_CID_SATURATION:
806 ctrl->value = cx25840_read(client, 0x420) >> 1;
809 ctrl->value = (s8)cx25840_read(client, 0x422);
811 case V4L2_CID_AUDIO_VOLUME:
812 case V4L2_CID_AUDIO_BASS:
813 case V4L2_CID_AUDIO_TREBLE:
814 case V4L2_CID_AUDIO_BALANCE:
815 case V4L2_CID_AUDIO_MUTE:
816 if (state->is_cx25836)
818 return cx25840_audio(client, VIDIOC_G_CTRL, ctrl);
826 /* ----------------------------------------------------------------------- */
828 static int cx25840_g_fmt(struct v4l2_subdev *sd, struct v4l2_format *fmt)
830 struct i2c_client *client = v4l2_get_subdevdata(sd);
833 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
834 return cx25840_vbi(client, VIDIOC_G_FMT, fmt);
841 static int cx25840_s_fmt(struct v4l2_subdev *sd, struct v4l2_format *fmt)
843 struct cx25840_state *state = to_state(sd);
844 struct i2c_client *client = v4l2_get_subdevdata(sd);
845 struct v4l2_pix_format *pix;
846 int HSC, VSC, Vsrc, Hsrc, filter, Vlines;
847 int is_50Hz = !(state->std & V4L2_STD_525_60);
850 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
851 pix = &(fmt->fmt.pix);
853 Vsrc = (cx25840_read(client, 0x476) & 0x3f) << 4;
854 Vsrc |= (cx25840_read(client, 0x475) & 0xf0) >> 4;
856 Hsrc = (cx25840_read(client, 0x472) & 0x3f) << 4;
857 Hsrc |= (cx25840_read(client, 0x471) & 0xf0) >> 4;
859 Vlines = pix->height + (is_50Hz ? 4 : 7);
861 if ((pix->width * 16 < Hsrc) || (Hsrc < pix->width) ||
862 (Vlines * 8 < Vsrc) || (Vsrc < Vlines)) {
863 v4l_err(client, "%dx%d is not a valid size!\n",
864 pix->width, pix->height);
868 HSC = (Hsrc * (1 << 20)) / pix->width - (1 << 20);
869 VSC = (1 << 16) - (Vsrc * (1 << 9) / Vlines - (1 << 9));
872 if (pix->width >= 385)
874 else if (pix->width > 192)
876 else if (pix->width > 96)
881 v4l_dbg(1, cx25840_debug, client, "decoder set size %dx%d -> scale %ux%u\n",
882 pix->width, pix->height, HSC, VSC);
885 cx25840_write(client, 0x418, HSC & 0xff);
886 cx25840_write(client, 0x419, (HSC >> 8) & 0xff);
887 cx25840_write(client, 0x41a, HSC >> 16);
889 cx25840_write(client, 0x41c, VSC & 0xff);
890 cx25840_write(client, 0x41d, VSC >> 8);
891 /* VS_INTRLACE=1 VFILT=filter */
892 cx25840_write(client, 0x41e, 0x8 | filter);
895 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
896 return cx25840_vbi(client, VIDIOC_S_FMT, fmt);
898 case V4L2_BUF_TYPE_VBI_CAPTURE:
899 return cx25840_vbi(client, VIDIOC_S_FMT, fmt);
908 /* ----------------------------------------------------------------------- */
910 static void log_video_status(struct i2c_client *client)
912 static const char *const fmt_strs[] = {
914 "NTSC-M", "NTSC-J", "NTSC-4.43",
915 "PAL-BDGHI", "PAL-M", "PAL-N", "PAL-Nc", "PAL-60",
921 struct cx25840_state *state = to_state(i2c_get_clientdata(client));
922 u8 vidfmt_sel = cx25840_read(client, 0x400) & 0xf;
923 u8 gen_stat1 = cx25840_read(client, 0x40d);
924 u8 gen_stat2 = cx25840_read(client, 0x40e);
925 int vid_input = state->vid_input;
927 v4l_info(client, "Video signal: %spresent\n",
928 (gen_stat2 & 0x20) ? "" : "not ");
929 v4l_info(client, "Detected format: %s\n",
930 fmt_strs[gen_stat1 & 0xf]);
932 v4l_info(client, "Specified standard: %s\n",
933 vidfmt_sel ? fmt_strs[vidfmt_sel] : "automatic detection");
935 if (vid_input >= CX25840_COMPOSITE1 &&
936 vid_input <= CX25840_COMPOSITE8) {
937 v4l_info(client, "Specified video input: Composite %d\n",
938 vid_input - CX25840_COMPOSITE1 + 1);
940 v4l_info(client, "Specified video input: S-Video (Luma In%d, Chroma In%d)\n",
941 (vid_input & 0xf0) >> 4, (vid_input & 0xf00) >> 8);
944 v4l_info(client, "Specified audioclock freq: %d Hz\n", state->audclk_freq);
947 /* ----------------------------------------------------------------------- */
949 static void log_audio_status(struct i2c_client *client)
951 struct cx25840_state *state = to_state(i2c_get_clientdata(client));
952 u8 download_ctl = cx25840_read(client, 0x803);
953 u8 mod_det_stat0 = cx25840_read(client, 0x804);
954 u8 mod_det_stat1 = cx25840_read(client, 0x805);
955 u8 audio_config = cx25840_read(client, 0x808);
956 u8 pref_mode = cx25840_read(client, 0x809);
957 u8 afc0 = cx25840_read(client, 0x80b);
958 u8 mute_ctl = cx25840_read(client, 0x8d3);
959 int aud_input = state->aud_input;
962 switch (mod_det_stat0) {
963 case 0x00: p = "mono"; break;
964 case 0x01: p = "stereo"; break;
965 case 0x02: p = "dual"; break;
966 case 0x04: p = "tri"; break;
967 case 0x10: p = "mono with SAP"; break;
968 case 0x11: p = "stereo with SAP"; break;
969 case 0x12: p = "dual with SAP"; break;
970 case 0x14: p = "tri with SAP"; break;
971 case 0xfe: p = "forced mode"; break;
972 default: p = "not defined";
974 v4l_info(client, "Detected audio mode: %s\n", p);
976 switch (mod_det_stat1) {
977 case 0x00: p = "not defined"; break;
978 case 0x01: p = "EIAJ"; break;
979 case 0x02: p = "A2-M"; break;
980 case 0x03: p = "A2-BG"; break;
981 case 0x04: p = "A2-DK1"; break;
982 case 0x05: p = "A2-DK2"; break;
983 case 0x06: p = "A2-DK3"; break;
984 case 0x07: p = "A1 (6.0 MHz FM Mono)"; break;
985 case 0x08: p = "AM-L"; break;
986 case 0x09: p = "NICAM-BG"; break;
987 case 0x0a: p = "NICAM-DK"; break;
988 case 0x0b: p = "NICAM-I"; break;
989 case 0x0c: p = "NICAM-L"; break;
990 case 0x0d: p = "BTSC/EIAJ/A2-M Mono (4.5 MHz FMMono)"; break;
991 case 0x0e: p = "IF FM Radio"; break;
992 case 0x0f: p = "BTSC"; break;
993 case 0x10: p = "high-deviation FM"; break;
994 case 0x11: p = "very high-deviation FM"; break;
995 case 0xfd: p = "unknown audio standard"; break;
996 case 0xfe: p = "forced audio standard"; break;
997 case 0xff: p = "no detected audio standard"; break;
998 default: p = "not defined";
1000 v4l_info(client, "Detected audio standard: %s\n", p);
1001 v4l_info(client, "Audio muted: %s\n",
1002 (state->unmute_volume >= 0) ? "yes" : "no");
1003 v4l_info(client, "Audio microcontroller: %s\n",
1004 (download_ctl & 0x10) ?
1005 ((mute_ctl & 0x2) ? "detecting" : "running") : "stopped");
1007 switch (audio_config >> 4) {
1008 case 0x00: p = "undefined"; break;
1009 case 0x01: p = "BTSC"; break;
1010 case 0x02: p = "EIAJ"; break;
1011 case 0x03: p = "A2-M"; break;
1012 case 0x04: p = "A2-BG"; break;
1013 case 0x05: p = "A2-DK1"; break;
1014 case 0x06: p = "A2-DK2"; break;
1015 case 0x07: p = "A2-DK3"; break;
1016 case 0x08: p = "A1 (6.0 MHz FM Mono)"; break;
1017 case 0x09: p = "AM-L"; break;
1018 case 0x0a: p = "NICAM-BG"; break;
1019 case 0x0b: p = "NICAM-DK"; break;
1020 case 0x0c: p = "NICAM-I"; break;
1021 case 0x0d: p = "NICAM-L"; break;
1022 case 0x0e: p = "FM radio"; break;
1023 case 0x0f: p = "automatic detection"; break;
1024 default: p = "undefined";
1026 v4l_info(client, "Configured audio standard: %s\n", p);
1028 if ((audio_config >> 4) < 0xF) {
1029 switch (audio_config & 0xF) {
1030 case 0x00: p = "MONO1 (LANGUAGE A/Mono L+R channel for BTSC, EIAJ, A2)"; break;
1031 case 0x01: p = "MONO2 (LANGUAGE B)"; break;
1032 case 0x02: p = "MONO3 (STEREO forced MONO)"; break;
1033 case 0x03: p = "MONO4 (NICAM ANALOG-Language C/Analog Fallback)"; break;
1034 case 0x04: p = "STEREO"; break;
1035 case 0x05: p = "DUAL1 (AB)"; break;
1036 case 0x06: p = "DUAL2 (AC) (FM)"; break;
1037 case 0x07: p = "DUAL3 (BC) (FM)"; break;
1038 case 0x08: p = "DUAL4 (AC) (AM)"; break;
1039 case 0x09: p = "DUAL5 (BC) (AM)"; break;
1040 case 0x0a: p = "SAP"; break;
1041 default: p = "undefined";
1043 v4l_info(client, "Configured audio mode: %s\n", p);
1045 switch (audio_config & 0xF) {
1046 case 0x00: p = "BG"; break;
1047 case 0x01: p = "DK1"; break;
1048 case 0x02: p = "DK2"; break;
1049 case 0x03: p = "DK3"; break;
1050 case 0x04: p = "I"; break;
1051 case 0x05: p = "L"; break;
1052 case 0x06: p = "BTSC"; break;
1053 case 0x07: p = "EIAJ"; break;
1054 case 0x08: p = "A2-M"; break;
1055 case 0x09: p = "FM Radio"; break;
1056 case 0x0f: p = "automatic standard and mode detection"; break;
1057 default: p = "undefined";
1059 v4l_info(client, "Configured audio system: %s\n", p);
1063 v4l_info(client, "Specified audio input: Tuner (In%d)\n", aud_input);
1065 v4l_info(client, "Specified audio input: External\n");
1068 switch (pref_mode & 0xf) {
1069 case 0: p = "mono/language A"; break;
1070 case 1: p = "language B"; break;
1071 case 2: p = "language C"; break;
1072 case 3: p = "analog fallback"; break;
1073 case 4: p = "stereo"; break;
1074 case 5: p = "language AC"; break;
1075 case 6: p = "language BC"; break;
1076 case 7: p = "language AB"; break;
1077 default: p = "undefined";
1079 v4l_info(client, "Preferred audio mode: %s\n", p);
1081 if ((audio_config & 0xf) == 0xf) {
1082 switch ((afc0 >> 3) & 0x3) {
1083 case 0: p = "system DK"; break;
1084 case 1: p = "system L"; break;
1085 case 2: p = "autodetect"; break;
1086 default: p = "undefined";
1088 v4l_info(client, "Selected 65 MHz format: %s\n", p);
1090 switch (afc0 & 0x7) {
1091 case 0: p = "chroma"; break;
1092 case 1: p = "BTSC"; break;
1093 case 2: p = "EIAJ"; break;
1094 case 3: p = "A2-M"; break;
1095 case 4: p = "autodetect"; break;
1096 default: p = "undefined";
1098 v4l_info(client, "Selected 45 MHz format: %s\n", p);
1102 /* ----------------------------------------------------------------------- */
1104 /* This init operation must be called to load the driver's firmware.
1105 Without this the audio standard detection will fail and you will
1108 Since loading the firmware is often problematic when the driver is
1109 compiled into the kernel I recommend postponing calling this function
1110 until the first open of the video device. Another reason for
1111 postponing it is that loading this firmware takes a long time (seconds)
1112 due to the slow i2c bus speed. So it will speed up the boot process if
1113 you can avoid loading the fw as long as the video device isn't used. */
1114 static int cx25840_init(struct v4l2_subdev *sd, u32 val)
1116 struct cx25840_state *state = to_state(sd);
1117 struct i2c_client *client = v4l2_get_subdevdata(sd);
1119 if (!state->is_initialized) {
1120 /* initialize on first use */
1121 state->is_initialized = 1;
1122 if (state->is_cx25836)
1123 cx25836_initialize(client);
1124 else if (state->is_cx23885)
1125 cx23885_initialize(client);
1127 cx25840_initialize(client);
1132 #ifdef CONFIG_VIDEO_ADV_DEBUG
1133 static int cx25840_g_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
1135 struct i2c_client *client = v4l2_get_subdevdata(sd);
1137 if (!v4l2_chip_match_i2c_client(client, ®->match))
1139 if (!capable(CAP_SYS_ADMIN))
1142 reg->val = cx25840_read(client, reg->reg & 0x0fff);
1146 static int cx25840_s_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
1148 struct i2c_client *client = v4l2_get_subdevdata(sd);
1150 if (!v4l2_chip_match_i2c_client(client, ®->match))
1152 if (!capable(CAP_SYS_ADMIN))
1154 cx25840_write(client, reg->reg & 0x0fff, reg->val & 0xff);
1159 static int cx25840_decode_vbi_line(struct v4l2_subdev *sd, struct v4l2_decode_vbi_line *vbi)
1161 struct i2c_client *client = v4l2_get_subdevdata(sd);
1163 return cx25840_vbi(client, VIDIOC_INT_DECODE_VBI_LINE, vbi);
1166 static int cx25840_s_clock_freq(struct v4l2_subdev *sd, u32 freq)
1168 struct i2c_client *client = v4l2_get_subdevdata(sd);
1170 return cx25840_audio(client, VIDIOC_INT_AUDIO_CLOCK_FREQ, &freq);
1173 static int cx25840_s_stream(struct v4l2_subdev *sd, int enable)
1175 struct cx25840_state *state = to_state(sd);
1176 struct i2c_client *client = v4l2_get_subdevdata(sd);
1178 v4l_dbg(1, cx25840_debug, client, "%s output\n",
1179 enable ? "enable" : "disable");
1181 if (state->is_cx23885) {
1182 u8 v = (cx25840_read(client, 0x421) | 0x0b);
1183 cx25840_write(client, 0x421, v);
1185 cx25840_write(client, 0x115,
1186 state->is_cx25836 ? 0x0c : 0x8c);
1187 cx25840_write(client, 0x116,
1188 state->is_cx25836 ? 0x04 : 0x07);
1191 if (state->is_cx23885) {
1192 u8 v = cx25840_read(client, 0x421) & ~(0x0b);
1193 cx25840_write(client, 0x421, v);
1195 cx25840_write(client, 0x115, 0x00);
1196 cx25840_write(client, 0x116, 0x00);
1202 static int cx25840_queryctrl(struct v4l2_subdev *sd, struct v4l2_queryctrl *qc)
1204 struct cx25840_state *state = to_state(sd);
1207 case V4L2_CID_BRIGHTNESS:
1208 return v4l2_ctrl_query_fill(qc, 0, 255, 1, 128);
1209 case V4L2_CID_CONTRAST:
1210 case V4L2_CID_SATURATION:
1211 return v4l2_ctrl_query_fill(qc, 0, 127, 1, 64);
1213 return v4l2_ctrl_query_fill(qc, -128, 127, 1, 0);
1217 if (state->is_cx25836)
1221 case V4L2_CID_AUDIO_VOLUME:
1222 return v4l2_ctrl_query_fill(qc, 0, 65535,
1223 65535 / 100, state->default_volume);
1224 case V4L2_CID_AUDIO_MUTE:
1225 return v4l2_ctrl_query_fill(qc, 0, 1, 1, 0);
1226 case V4L2_CID_AUDIO_BALANCE:
1227 case V4L2_CID_AUDIO_BASS:
1228 case V4L2_CID_AUDIO_TREBLE:
1229 return v4l2_ctrl_query_fill(qc, 0, 65535, 65535 / 100, 32768);
1236 static int cx25840_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
1238 struct cx25840_state *state = to_state(sd);
1239 struct i2c_client *client = v4l2_get_subdevdata(sd);
1241 if (state->radio == 0 && state->std == std)
1245 return set_v4lstd(client);
1248 static int cx25840_s_radio(struct v4l2_subdev *sd)
1250 struct cx25840_state *state = to_state(sd);
1256 static int cx25840_s_video_routing(struct v4l2_subdev *sd, const struct v4l2_routing *route)
1258 struct cx25840_state *state = to_state(sd);
1259 struct i2c_client *client = v4l2_get_subdevdata(sd);
1261 return set_input(client, route->input, state->aud_input);
1264 static int cx25840_s_audio_routing(struct v4l2_subdev *sd, const struct v4l2_routing *route)
1266 struct cx25840_state *state = to_state(sd);
1267 struct i2c_client *client = v4l2_get_subdevdata(sd);
1269 if (state->is_cx25836)
1271 return set_input(client, state->vid_input, route->input);
1274 static int cx25840_s_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *freq)
1276 struct cx25840_state *state = to_state(sd);
1277 struct i2c_client *client = v4l2_get_subdevdata(sd);
1279 if (!state->is_cx25836)
1280 input_change(client);
1284 static int cx25840_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1286 struct cx25840_state *state = to_state(sd);
1287 struct i2c_client *client = v4l2_get_subdevdata(sd);
1288 u8 vpres = cx25840_read(client, 0x40e) & 0x20;
1295 vt->signal = vpres ? 0xffff : 0x0;
1296 if (state->is_cx25836)
1300 V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_LANG1 |
1301 V4L2_TUNER_CAP_LANG2 | V4L2_TUNER_CAP_SAP;
1303 mode = cx25840_read(client, 0x804);
1305 /* get rxsubchans and audmode */
1306 if ((mode & 0xf) == 1)
1307 val |= V4L2_TUNER_SUB_STEREO;
1309 val |= V4L2_TUNER_SUB_MONO;
1311 if (mode == 2 || mode == 4)
1312 val = V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_LANG2;
1315 val |= V4L2_TUNER_SUB_SAP;
1317 vt->rxsubchans = val;
1318 vt->audmode = state->audmode;
1322 static int cx25840_s_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1324 struct cx25840_state *state = to_state(sd);
1325 struct i2c_client *client = v4l2_get_subdevdata(sd);
1327 if (state->radio || state->is_cx25836)
1330 switch (vt->audmode) {
1331 case V4L2_TUNER_MODE_MONO:
1334 bilingual -> lang1 */
1335 cx25840_and_or(client, 0x809, ~0xf, 0x00);
1337 case V4L2_TUNER_MODE_STEREO:
1338 case V4L2_TUNER_MODE_LANG1:
1341 bilingual -> lang1 */
1342 cx25840_and_or(client, 0x809, ~0xf, 0x04);
1344 case V4L2_TUNER_MODE_LANG1_LANG2:
1347 bilingual -> lang1/lang2 */
1348 cx25840_and_or(client, 0x809, ~0xf, 0x07);
1350 case V4L2_TUNER_MODE_LANG2:
1353 bilingual -> lang2 */
1354 cx25840_and_or(client, 0x809, ~0xf, 0x01);
1359 state->audmode = vt->audmode;
1363 static int cx25840_reset(struct v4l2_subdev *sd, u32 val)
1365 struct cx25840_state *state = to_state(sd);
1366 struct i2c_client *client = v4l2_get_subdevdata(sd);
1368 if (state->is_cx25836)
1369 cx25836_initialize(client);
1370 else if (state->is_cx23885)
1371 cx23885_initialize(client);
1373 cx25840_initialize(client);
1377 static int cx25840_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip)
1379 struct cx25840_state *state = to_state(sd);
1380 struct i2c_client *client = v4l2_get_subdevdata(sd);
1382 return v4l2_chip_ident_i2c_client(client, chip, state->id, state->rev);
1385 static int cx25840_log_status(struct v4l2_subdev *sd)
1387 struct cx25840_state *state = to_state(sd);
1388 struct i2c_client *client = v4l2_get_subdevdata(sd);
1390 log_video_status(client);
1391 if (!state->is_cx25836)
1392 log_audio_status(client);
1396 static int cx25840_command(struct i2c_client *client, unsigned cmd, void *arg)
1398 /* ignore this command */
1399 if (cmd == TUNER_SET_TYPE_ADDR || cmd == TUNER_SET_CONFIG)
1402 /* Old-style drivers rely on initialization on first use, so
1403 call the init whenever a command is issued to this driver.
1404 New-style drivers using v4l2_subdev should call init explicitly. */
1405 cx25840_init(i2c_get_clientdata(client), 0);
1406 return v4l2_subdev_command(i2c_get_clientdata(client), cmd, arg);
1409 /* ----------------------------------------------------------------------- */
1411 static const struct v4l2_subdev_core_ops cx25840_core_ops = {
1412 .log_status = cx25840_log_status,
1413 .g_chip_ident = cx25840_g_chip_ident,
1414 .g_ctrl = cx25840_g_ctrl,
1415 .s_ctrl = cx25840_s_ctrl,
1416 .queryctrl = cx25840_queryctrl,
1417 .reset = cx25840_reset,
1418 .init = cx25840_init,
1419 #ifdef CONFIG_VIDEO_ADV_DEBUG
1420 .g_register = cx25840_g_register,
1421 .s_register = cx25840_s_register,
1425 static const struct v4l2_subdev_tuner_ops cx25840_tuner_ops = {
1426 .s_frequency = cx25840_s_frequency,
1427 .s_std = cx25840_s_std,
1428 .s_radio = cx25840_s_radio,
1429 .g_tuner = cx25840_g_tuner,
1430 .s_tuner = cx25840_s_tuner,
1433 static const struct v4l2_subdev_audio_ops cx25840_audio_ops = {
1434 .s_clock_freq = cx25840_s_clock_freq,
1435 .s_routing = cx25840_s_audio_routing,
1438 static const struct v4l2_subdev_video_ops cx25840_video_ops = {
1439 .s_routing = cx25840_s_video_routing,
1440 .g_fmt = cx25840_g_fmt,
1441 .s_fmt = cx25840_s_fmt,
1442 .decode_vbi_line = cx25840_decode_vbi_line,
1443 .s_stream = cx25840_s_stream,
1446 static const struct v4l2_subdev_ops cx25840_ops = {
1447 .core = &cx25840_core_ops,
1448 .tuner = &cx25840_tuner_ops,
1449 .audio = &cx25840_audio_ops,
1450 .video = &cx25840_video_ops,
1453 /* ----------------------------------------------------------------------- */
1455 static int cx25840_probe(struct i2c_client *client,
1456 const struct i2c_device_id *did)
1458 struct cx25840_state *state;
1459 struct v4l2_subdev *sd;
1463 /* Check if the adapter supports the needed features */
1464 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1467 v4l_dbg(1, cx25840_debug, client, "detecting cx25840 client on address 0x%x\n", client->addr << 1);
1469 device_id = cx25840_read(client, 0x101) << 8;
1470 device_id |= cx25840_read(client, 0x100);
1471 v4l_dbg(1, cx25840_debug, client, "device_id = 0x%04x\n", device_id);
1473 /* The high byte of the device ID should be
1474 * 0x83 for the cx2583x and 0x84 for the cx2584x */
1475 if ((device_id & 0xff00) == 0x8300) {
1476 id = V4L2_IDENT_CX25836 + ((device_id >> 4) & 0xf) - 6;
1478 else if ((device_id & 0xff00) == 0x8400) {
1479 id = V4L2_IDENT_CX25840 + ((device_id >> 4) & 0xf);
1480 } else if (device_id == 0x0000) {
1481 id = V4L2_IDENT_CX25836 + ((device_id >> 4) & 0xf) - 6;
1482 } else if (device_id == 0x1313) {
1483 id = V4L2_IDENT_CX25836 + ((device_id >> 4) & 0xf) - 6;
1486 v4l_dbg(1, cx25840_debug, client, "cx25840 not found\n");
1490 state = kzalloc(sizeof(struct cx25840_state), GFP_KERNEL);
1495 v4l2_i2c_subdev_init(sd, client, &cx25840_ops);
1496 /* Note: revision '(device_id & 0x0f) == 2' was never built. The
1497 marking skips from 0x1 == 22 to 0x3 == 23. */
1498 v4l_info(client, "cx25%3x-2%x found @ 0x%x (%s)\n",
1499 (device_id & 0xfff0) >> 4,
1500 (device_id & 0x0f) < 3 ? (device_id & 0x0f) + 1 : (device_id & 0x0f),
1501 client->addr << 1, client->adapter->name);
1504 state->is_cx25836 = ((device_id & 0xff00) == 0x8300);
1505 state->is_cx23885 = (device_id == 0x0000) || (device_id == 0x1313);
1506 state->vid_input = CX25840_COMPOSITE7;
1507 state->aud_input = CX25840_AUDIO8;
1508 state->audclk_freq = 48000;
1509 state->pvr150_workaround = 0;
1510 state->audmode = V4L2_TUNER_MODE_LANG1;
1511 state->unmute_volume = -1;
1512 state->default_volume = 228 - cx25840_read(client, 0x8d4);
1513 state->default_volume = ((state->default_volume / 2) + 23) << 9;
1514 state->vbi_line_offset = 8;
1516 state->rev = device_id;
1518 if (state->is_cx23885) {
1519 /* Drive GPIO2 direction and values */
1520 cx25840_write(client, 0x160, 0x1d);
1521 cx25840_write(client, 0x164, 0x00);
1527 static int cx25840_remove(struct i2c_client *client)
1529 struct v4l2_subdev *sd = i2c_get_clientdata(client);
1531 v4l2_device_unregister_subdev(sd);
1532 kfree(to_state(sd));
1536 static const struct i2c_device_id cx25840_id[] = {
1540 MODULE_DEVICE_TABLE(i2c, cx25840_id);
1542 static struct v4l2_i2c_driver_data v4l2_i2c_data = {
1544 .driverid = I2C_DRIVERID_CX25840,
1545 .command = cx25840_command,
1546 .probe = cx25840_probe,
1547 .remove = cx25840_remove,
1548 .id_table = cx25840_id,