?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Committer: Michael Beasley <mike@snafu.setup>
[mikesnafu-overlay.git] / drivers / media / video / cx25840 / cx25840-core.c
blob756a1eeb274e0da969e49a0ad6424e7ea3339035
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@hauppauge.com>.
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-legacy.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 unsigned short normal_i2c[] = { 0x88 >> 1, I2C_CLIENT_END };
52
53
54 int cx25840_debug;
55
56 module_param_named(debug,cx25840_debug, int, 0644);
57
58 MODULE_PARM_DESC(debug, "Debugging messages [0=Off (default) 1=On]");
59
60 I2C_CLIENT_INSMOD;
61
62 /* ----------------------------------------------------------------------- */
63
64 int cx25840_write(struct i2c_client *client, u16 addr, u8 value)
65 {
66 u8 buffer[3];
67 buffer[0] = addr >> 8;
68 buffer[1] = addr & 0xff;
69 buffer[2] = value;
70 return i2c_master_send(client, buffer, 3);
71 }
72
73 int cx25840_write4(struct i2c_client *client, u16 addr, u32 value)
74 {
75 u8 buffer[6];
76 buffer[0] = addr >> 8;
77 buffer[1] = addr & 0xff;
78 buffer[2] = value & 0xff;
79 buffer[3] = (value >> 8) & 0xff;
80 buffer[4] = (value >> 16) & 0xff;
81 buffer[5] = value >> 24;
82 return i2c_master_send(client, buffer, 6);
83 }
84
85 u8 cx25840_read(struct i2c_client * client, u16 addr)
86 {
87 u8 buffer[2];
88 buffer[0] = addr >> 8;
89 buffer[1] = addr & 0xff;
90
91 if (i2c_master_send(client, buffer, 2) < 2)
92 return 0;
93
94 if (i2c_master_recv(client, buffer, 1) < 1)
95 return 0;
96
97 return buffer[0];
98 }
99
100 u32 cx25840_read4(struct i2c_client * client, u16 addr)
101 {
102 u8 buffer[4];
103 buffer[0] = addr >> 8;
104 buffer[1] = addr & 0xff;
105
106 if (i2c_master_send(client, buffer, 2) < 2)
107 return 0;
108
109 if (i2c_master_recv(client, buffer, 4) < 4)
110 return 0;
111
112 return (buffer[3] << 24) | (buffer[2] << 16) |
113 (buffer[1] << 8) | buffer[0];
114 }
115
116 int cx25840_and_or(struct i2c_client *client, u16 addr, unsigned and_mask,
117 u8 or_value)
118 {
119 return cx25840_write(client, addr,
120 (cx25840_read(client, addr) & and_mask) |
121 or_value);
122 }
123
124 /* ----------------------------------------------------------------------- */
125
126 static int set_input(struct i2c_client *client, enum cx25840_video_input vid_input,
127 enum cx25840_audio_input aud_input);
128
129 /* ----------------------------------------------------------------------- */
130
131 static void init_dll1(struct i2c_client *client)
132 {
133 /* This is the Hauppauge sequence used to
134 * initialize the Delay Lock Loop 1 (ADC DLL). */
135 cx25840_write(client, 0x159, 0x23);
136 cx25840_write(client, 0x15a, 0x87);
137 cx25840_write(client, 0x15b, 0x06);
138 udelay(10);
139 cx25840_write(client, 0x159, 0xe1);
140 udelay(10);
141 cx25840_write(client, 0x15a, 0x86);
142 cx25840_write(client, 0x159, 0xe0);
143 cx25840_write(client, 0x159, 0xe1);
144 cx25840_write(client, 0x15b, 0x10);
145 }
146
147 static void init_dll2(struct i2c_client *client)
148 {
149 /* This is the Hauppauge sequence used to
150 * initialize the Delay Lock Loop 2 (ADC DLL). */
151 cx25840_write(client, 0x15d, 0xe3);
152 cx25840_write(client, 0x15e, 0x86);
153 cx25840_write(client, 0x15f, 0x06);
154 udelay(10);
155 cx25840_write(client, 0x15d, 0xe1);
156 cx25840_write(client, 0x15d, 0xe0);
157 cx25840_write(client, 0x15d, 0xe1);
158 }
159
160 static void cx25836_initialize(struct i2c_client *client)
161 {
162 /* reset configuration is described on page 3-77 of the CX25836 datasheet */
163 /* 2. */
164 cx25840_and_or(client, 0x000, ~0x01, 0x01);
165 cx25840_and_or(client, 0x000, ~0x01, 0x00);
166 /* 3a. */
167 cx25840_and_or(client, 0x15a, ~0x70, 0x00);
168 /* 3b. */
169 cx25840_and_or(client, 0x15b, ~0x1e, 0x06);
170 /* 3c. */
171 cx25840_and_or(client, 0x159, ~0x02, 0x02);
172 /* 3d. */
173 udelay(10);
174 /* 3e. */
175 cx25840_and_or(client, 0x159, ~0x02, 0x00);
176 /* 3f. */
177 cx25840_and_or(client, 0x159, ~0xc0, 0xc0);
178 /* 3g. */
179 cx25840_and_or(client, 0x159, ~0x01, 0x00);
180 cx25840_and_or(client, 0x159, ~0x01, 0x01);
181 /* 3h. */
182 cx25840_and_or(client, 0x15b, ~0x1e, 0x10);
183 }
184
185 static void cx25840_work_handler(struct work_struct *work)
186 {
187 struct cx25840_state *state = container_of(work, struct cx25840_state, fw_work);
188 cx25840_loadfw(state->c);
189 wake_up(&state->fw_wait);
190 }
191
192 static void cx25840_initialize(struct i2c_client *client)
193 {
194 DEFINE_WAIT(wait);
195 struct cx25840_state *state = i2c_get_clientdata(client);
196 struct workqueue_struct *q;
197
198 /* datasheet startup in numbered steps, refer to page 3-77 */
199 /* 2. */
200 cx25840_and_or(client, 0x803, ~0x10, 0x00);
201 /* The default of this register should be 4, but I get 0 instead.
202 * Set this register to 4 manually. */
203 cx25840_write(client, 0x000, 0x04);
204 /* 3. */
205 init_dll1(client);
206 init_dll2(client);
207 cx25840_write(client, 0x136, 0x0a);
208 /* 4. */
209 cx25840_write(client, 0x13c, 0x01);
210 cx25840_write(client, 0x13c, 0x00);
211 /* 5. */
212 /* Do the firmware load in a work handler to prevent.
213 Otherwise the kernel is blocked waiting for the
214 bit-banging i2c interface to finish uploading the
215 firmware. */
216 INIT_WORK(&state->fw_work, cx25840_work_handler);
217 init_waitqueue_head(&state->fw_wait);
218 q = create_singlethread_workqueue("cx25840_fw");
219 prepare_to_wait(&state->fw_wait, &wait, TASK_UNINTERRUPTIBLE);
220 queue_work(q, &state->fw_work);
221 schedule();
222 finish_wait(&state->fw_wait, &wait);
223 destroy_workqueue(q);
224
225 /* 6. */
226 cx25840_write(client, 0x115, 0x8c);
227 cx25840_write(client, 0x116, 0x07);
228 cx25840_write(client, 0x118, 0x02);
229 /* 7. */
230 cx25840_write(client, 0x4a5, 0x80);
231 cx25840_write(client, 0x4a5, 0x00);
232 cx25840_write(client, 0x402, 0x00);
233 /* 8. */
234 cx25840_and_or(client, 0x401, ~0x18, 0);
235 cx25840_and_or(client, 0x4a2, ~0x10, 0x10);
236 /* steps 8c and 8d are done in change_input() */
237 /* 10. */
238 cx25840_write(client, 0x8d3, 0x1f);
239 cx25840_write(client, 0x8e3, 0x03);
240
241 cx25840_vbi_setup(client);
242
243 /* trial and error says these are needed to get audio */
244 cx25840_write(client, 0x914, 0xa0);
245 cx25840_write(client, 0x918, 0xa0);
246 cx25840_write(client, 0x919, 0x01);
247
248 /* stereo prefered */
249 cx25840_write(client, 0x809, 0x04);
250 /* AC97 shift */
251 cx25840_write(client, 0x8cf, 0x0f);
252
253 /* (re)set input */
254 set_input(client, state->vid_input, state->aud_input);
255
256 /* start microcontroller */
257 cx25840_and_or(client, 0x803, ~0x10, 0x10);
258 }
259
260 static void cx23885_initialize(struct i2c_client *client)
261 {
262 DEFINE_WAIT(wait);
263 struct cx25840_state *state = i2c_get_clientdata(client);
264 struct workqueue_struct *q;
265
266 /* Internal Reset */
267 cx25840_and_or(client, 0x102, ~0x01, 0x01);
268 cx25840_and_or(client, 0x102, ~0x01, 0x00);
269
270 /* Stop microcontroller */
271 cx25840_and_or(client, 0x803, ~0x10, 0x00);
272
273 /* DIF in reset? */
274 cx25840_write(client, 0x398, 0);
275
276 /* Trust the default xtal, no division */
277 /* This changes for the cx23888 products */
278 cx25840_write(client, 0x2, 0x76);
279
280 /* Bring down the regulator for AUX clk */
281 cx25840_write(client, 0x1, 0x40);
282
283 /* Sys PLL frac */
284 cx25840_write4(client, 0x11c, 0x01d1744c);
285
286 /* Sys PLL int */
287 cx25840_write4(client, 0x118, 0x00000416);
288
289 /* Disable DIF bypass */
290 cx25840_write4(client, 0x33c, 0x00000001);
291
292 /* DIF Src phase inc */
293 cx25840_write4(client, 0x340, 0x0df7df83);
294
295 /* Vid PLL frac */
296 cx25840_write4(client, 0x10c, 0x01b6db7b);
297
298 /* Vid PLL int */
299 cx25840_write4(client, 0x108, 0x00000512);
300
301 /* Luma */
302 cx25840_write4(client, 0x414, 0x00107d12);
303
304 /* Chroma */
305 cx25840_write4(client, 0x420, 0x3d008282);
306
307 /* Aux PLL frac */
308 cx25840_write4(client, 0x114, 0x017dbf48);
309
310 /* Aux PLL int */
311 cx25840_write4(client, 0x110, 0x000a030e);
312
313 /* ADC2 input select */
314 cx25840_write(client, 0x102, 0x10);
315
316 /* VIN1 & VIN5 */
317 cx25840_write(client, 0x103, 0x11);
318
319 /* Enable format auto detect */
320 cx25840_write(client, 0x400, 0);
321 /* Fast subchroma lock */
322 /* White crush, Chroma AGC & Chroma Killer enabled */
323 cx25840_write(client, 0x401, 0xe8);
324
325 /* Select AFE clock pad output source */
326 cx25840_write(client, 0x144, 0x05);
327
328 /* Do the firmware load in a work handler to prevent.
329 Otherwise the kernel is blocked waiting for the
330 bit-banging i2c interface to finish uploading the
331 firmware. */
332 INIT_WORK(&state->fw_work, cx25840_work_handler);
333 init_waitqueue_head(&state->fw_wait);
334 q = create_singlethread_workqueue("cx25840_fw");
335 prepare_to_wait(&state->fw_wait, &wait, TASK_UNINTERRUPTIBLE);
336 queue_work(q, &state->fw_work);
337 schedule();
338 finish_wait(&state->fw_wait, &wait);
339 destroy_workqueue(q);
340
341 cx25840_vbi_setup(client);
342
343 /* (re)set input */
344 set_input(client, state->vid_input, state->aud_input);
345
346 /* start microcontroller */
347 cx25840_and_or(client, 0x803, ~0x10, 0x10);
348 }
349
350 /* ----------------------------------------------------------------------- */
351
352 static void input_change(struct i2c_client *client)
353 {
354 struct cx25840_state *state = i2c_get_clientdata(client);
355 v4l2_std_id std = cx25840_get_v4lstd(client);
356
357 /* Follow step 8c and 8d of section 3.16 in the cx25840 datasheet */
358 if (std & V4L2_STD_SECAM) {
359 cx25840_write(client, 0x402, 0);
360 }
361 else {
362 cx25840_write(client, 0x402, 0x04);
363 cx25840_write(client, 0x49f, (std & V4L2_STD_NTSC) ? 0x14 : 0x11);
364 }
365 cx25840_and_or(client, 0x401, ~0x60, 0);
366 cx25840_and_or(client, 0x401, ~0x60, 0x60);
367 cx25840_and_or(client, 0x810, ~0x01, 1);
368
369 if (state->radio) {
370 cx25840_write(client, 0x808, 0xf9);
371 cx25840_write(client, 0x80b, 0x00);
372 }
373 else if (std & V4L2_STD_525_60) {
374 /* Certain Hauppauge PVR150 models have a hardware bug
375 that causes audio to drop out. For these models the
376 audio standard must be set explicitly.
377 To be precise: it affects cards with tuner models
378 85, 99 and 112 (model numbers from tveeprom). */
379 int hw_fix = state->pvr150_workaround;
380
381 if (std == V4L2_STD_NTSC_M_JP) {
382 /* Japan uses EIAJ audio standard */
383 cx25840_write(client, 0x808, hw_fix ? 0x2f : 0xf7);
384 } else if (std == V4L2_STD_NTSC_M_KR) {
385 /* South Korea uses A2 audio standard */
386 cx25840_write(client, 0x808, hw_fix ? 0x3f : 0xf8);
387 } else {
388 /* Others use the BTSC audio standard */
389 cx25840_write(client, 0x808, hw_fix ? 0x1f : 0xf6);
390 }
391 cx25840_write(client, 0x80b, 0x00);
392 } else if (std & V4L2_STD_PAL) {
393 /* Follow tuner change procedure for PAL */
394 cx25840_write(client, 0x808, 0xff);
395 cx25840_write(client, 0x80b, 0x10);
396 } else if (std & V4L2_STD_SECAM) {
397 /* Select autodetect for SECAM */
398 cx25840_write(client, 0x808, 0xff);
399 cx25840_write(client, 0x80b, 0x10);
400 }
401
402 cx25840_and_or(client, 0x810, ~0x01, 0);
403 }
404
405 static int set_input(struct i2c_client *client, enum cx25840_video_input vid_input,
406 enum cx25840_audio_input aud_input)
407 {
408 struct cx25840_state *state = i2c_get_clientdata(client);
409 u8 is_composite = (vid_input >= CX25840_COMPOSITE1 &&
410 vid_input <= CX25840_COMPOSITE8);
411 u8 reg;
412
413 v4l_dbg(1, cx25840_debug, client,
414 "decoder set video input %d, audio input %d\n",
415 vid_input, aud_input);
416
417 if (vid_input >= CX25840_VIN1_CH1) {
418 v4l_dbg(1, cx25840_debug, client, "vid_input 0x%x\n",
419 vid_input);
420 reg = vid_input & 0xff;
421 if ((vid_input & CX25840_SVIDEO_ON) == CX25840_SVIDEO_ON)
422 is_composite = 0;
423 else
424 is_composite = 1;
425
426 v4l_dbg(1, cx25840_debug, client, "mux cfg 0x%x comp=%d\n",
427 reg, is_composite);
428 } else
429 if (is_composite) {
430 reg = 0xf0 + (vid_input - CX25840_COMPOSITE1);
431 } else {
432 int luma = vid_input & 0xf0;
433 int chroma = vid_input & 0xf00;
434
435 if ((vid_input & ~0xff0) ||
436 luma < CX25840_SVIDEO_LUMA1 || luma > CX25840_SVIDEO_LUMA4 ||
437 chroma < CX25840_SVIDEO_CHROMA4 || chroma > CX25840_SVIDEO_CHROMA8) {
438 v4l_err(client, "0x%04x is not a valid video input!\n",
439 vid_input);
440 return -EINVAL;
441 }
442 reg = 0xf0 + ((luma - CX25840_SVIDEO_LUMA1) >> 4);
443 if (chroma >= CX25840_SVIDEO_CHROMA7) {
444 reg &= 0x3f;
445 reg |= (chroma - CX25840_SVIDEO_CHROMA7) >> 2;
446 } else {
447 reg &= 0xcf;
448 reg |= (chroma - CX25840_SVIDEO_CHROMA4) >> 4;
449 }
450 }
451
452 /* The caller has previously prepared the correct routing
453 * configuration in reg (for the cx23885) so we have no
454 * need to attempt to flip bits for earlier av decoders.
455 */
456 if (!state->is_cx23885) {
457 switch (aud_input) {
458 case CX25840_AUDIO_SERIAL:
459 /* do nothing, use serial audio input */
460 break;
461 case CX25840_AUDIO4: reg &= ~0x30; break;
462 case CX25840_AUDIO5: reg &= ~0x30; reg |= 0x10; break;
463 case CX25840_AUDIO6: reg &= ~0x30; reg |= 0x20; break;
464 case CX25840_AUDIO7: reg &= ~0xc0; break;
465 case CX25840_AUDIO8: reg &= ~0xc0; reg |= 0x40; break;
466
467 default:
468 v4l_err(client, "0x%04x is not a valid audio input!\n",
469 aud_input);
470 return -EINVAL;
471 }
472 }
473
474 cx25840_write(client, 0x103, reg);
475
476 /* Set INPUT_MODE to Composite (0) or S-Video (1) */
477 cx25840_and_or(client, 0x401, ~0x6, is_composite ? 0 : 0x02);
478
479 if (!state->is_cx23885) {
480 /* Set CH_SEL_ADC2 to 1 if input comes from CH3 */
481 cx25840_and_or(client, 0x102, ~0x2, (reg & 0x80) == 0 ? 2 : 0);
482 /* Set DUAL_MODE_ADC2 to 1 if input comes from both CH2&CH3 */
483 if ((reg & 0xc0) != 0xc0 && (reg & 0x30) != 0x30)
484 cx25840_and_or(client, 0x102, ~0x4, 4);
485 else
486 cx25840_and_or(client, 0x102, ~0x4, 0);
487 } else {
488 if (is_composite)
489 /* ADC2 input select channel 2 */
490 cx25840_and_or(client, 0x102, ~0x2, 0);
491 else
492 /* ADC2 input select channel 3 */
493 cx25840_and_or(client, 0x102, ~0x2, 2);
494 }
495
496 state->vid_input = vid_input;
497 state->aud_input = aud_input;
498 if (!state->is_cx25836) {
499 cx25840_audio_set_path(client);
500 input_change(client);
501 }
502
503 if (state->is_cx23885) {
504 /* Audio channel 1 src : Parallel 1 */
505 cx25840_write(client, 0x124, 0x03);
506
507 /* Select AFE clock pad output source */
508 cx25840_write(client, 0x144, 0x05);
509
510 /* I2S_IN_CTL: I2S_IN_SONY_MODE, LEFT SAMPLE on WS=1 */
511 cx25840_write(client, 0x914, 0xa0);
512
513 /* I2S_OUT_CTL:
514 * I2S_IN_SONY_MODE, LEFT SAMPLE on WS=1
515 * I2S_OUT_MASTER_MODE = Master
516 */
517 cx25840_write(client, 0x918, 0xa0);
518 cx25840_write(client, 0x919, 0x01);
519 }
520
521 return 0;
522 }
523
524 /* ----------------------------------------------------------------------- */
525
526 static int set_v4lstd(struct i2c_client *client, v4l2_std_id std)
527 {
528 u8 fmt=0; /* zero is autodetect */
529
530 /* First tests should be against specific std */
531 if (std == V4L2_STD_NTSC_M_JP) {
532 fmt=0x2;
533 } else if (std == V4L2_STD_NTSC_443) {
534 fmt=0x3;
535 } else if (std == V4L2_STD_PAL_M) {
536 fmt=0x5;
537 } else if (std == V4L2_STD_PAL_N) {
538 fmt=0x6;
539 } else if (std == V4L2_STD_PAL_Nc) {
540 fmt=0x7;
541 } else if (std == V4L2_STD_PAL_60) {
542 fmt=0x8;
543 } else {
544 /* Then, test against generic ones */
545 if (std & V4L2_STD_NTSC) {
546 fmt=0x1;
547 } else if (std & V4L2_STD_PAL) {
548 fmt=0x4;
549 } else if (std & V4L2_STD_SECAM) {
550 fmt=0xc;
551 }
552 }
553
554 v4l_dbg(1, cx25840_debug, client, "changing video std to fmt %i\n",fmt);
555
556 /* Follow step 9 of section 3.16 in the cx25840 datasheet.
557 Without this PAL may display a vertical ghosting effect.
558 This happens for example with the Yuan MPC622. */
559 if (fmt >= 4 && fmt < 8) {
560 /* Set format to NTSC-M */
561 cx25840_and_or(client, 0x400, ~0xf, 1);
562 /* Turn off LCOMB */
563 cx25840_and_or(client, 0x47b, ~6, 0);
564 }
565 cx25840_and_or(client, 0x400, ~0xf, fmt);
566 cx25840_vbi_setup(client);
567 return 0;
568 }
569
570 v4l2_std_id cx25840_get_v4lstd(struct i2c_client * client)
571 {
572 struct cx25840_state *state = i2c_get_clientdata(client);
573 /* check VID_FMT_SEL first */
574 u8 fmt = cx25840_read(client, 0x400) & 0xf;
575
576 if (!fmt) {
577 /* check AFD_FMT_STAT if set to autodetect */
578 fmt = cx25840_read(client, 0x40d) & 0xf;
579 }
580
581 switch (fmt) {
582 case 0x1:
583 {
584 /* if the audio std is A2-M, then this is the South Korean
585 NTSC standard */
586 if (!state->is_cx25836 && cx25840_read(client, 0x805) == 2)
587 return V4L2_STD_NTSC_M_KR;
588 return V4L2_STD_NTSC_M;
589 }
590 case 0x2: return V4L2_STD_NTSC_M_JP;
591 case 0x3: return V4L2_STD_NTSC_443;
592 case 0x4: return V4L2_STD_PAL;
593 case 0x5: return V4L2_STD_PAL_M;
594 case 0x6: return V4L2_STD_PAL_N;
595 case 0x7: return V4L2_STD_PAL_Nc;
596 case 0x8: return V4L2_STD_PAL_60;
597 case 0xc: return V4L2_STD_SECAM;
598 default: return V4L2_STD_UNKNOWN;
599 }
600 }
601
602 /* ----------------------------------------------------------------------- */
603
604 static int set_v4lctrl(struct i2c_client *client, struct v4l2_control *ctrl)
605 {
606 struct cx25840_state *state = i2c_get_clientdata(client);
607
608 switch (ctrl->id) {
609 case CX25840_CID_ENABLE_PVR150_WORKAROUND:
610 state->pvr150_workaround = ctrl->value;
611 set_input(client, state->vid_input, state->aud_input);
612 break;
613
614 case V4L2_CID_BRIGHTNESS:
615 if (ctrl->value < 0 || ctrl->value > 255) {
616 v4l_err(client, "invalid brightness setting %d\n",
617 ctrl->value);
618 return -ERANGE;
619 }
620
621 cx25840_write(client, 0x414, ctrl->value - 128);
622 break;
623
624 case V4L2_CID_CONTRAST:
625 if (ctrl->value < 0 || ctrl->value > 127) {
626 v4l_err(client, "invalid contrast setting %d\n",
627 ctrl->value);
628 return -ERANGE;
629 }
630
631 cx25840_write(client, 0x415, ctrl->value << 1);
632 break;
633
634 case V4L2_CID_SATURATION:
635 if (ctrl->value < 0 || ctrl->value > 127) {
636 v4l_err(client, "invalid saturation setting %d\n",
637 ctrl->value);
638 return -ERANGE;
639 }
640
641 cx25840_write(client, 0x420, ctrl->value << 1);
642 cx25840_write(client, 0x421, ctrl->value << 1);
643 break;
644
645 case V4L2_CID_HUE:
646 if (ctrl->value < -127 || ctrl->value > 127) {
647 v4l_err(client, "invalid hue setting %d\n", ctrl->value);
648 return -ERANGE;
649 }
650
651 cx25840_write(client, 0x422, ctrl->value);
652 break;
653
654 case V4L2_CID_AUDIO_VOLUME:
655 case V4L2_CID_AUDIO_BASS:
656 case V4L2_CID_AUDIO_TREBLE:
657 case V4L2_CID_AUDIO_BALANCE:
658 case V4L2_CID_AUDIO_MUTE:
659 if (state->is_cx25836)
660 return -EINVAL;
661 return cx25840_audio(client, VIDIOC_S_CTRL, ctrl);
662
663 default:
664 return -EINVAL;
665 }
666
667 return 0;
668 }
669
670 static int get_v4lctrl(struct i2c_client *client, struct v4l2_control *ctrl)
671 {
672 struct cx25840_state *state = i2c_get_clientdata(client);
673
674 switch (ctrl->id) {
675 case CX25840_CID_ENABLE_PVR150_WORKAROUND:
676 ctrl->value = state->pvr150_workaround;
677 break;
678 case V4L2_CID_BRIGHTNESS:
679 ctrl->value = (s8)cx25840_read(client, 0x414) + 128;
680 break;
681 case V4L2_CID_CONTRAST:
682 ctrl->value = cx25840_read(client, 0x415) >> 1;
683 break;
684 case V4L2_CID_SATURATION:
685 ctrl->value = cx25840_read(client, 0x420) >> 1;
686 break;
687 case V4L2_CID_HUE:
688 ctrl->value = (s8)cx25840_read(client, 0x422);
689 break;
690 case V4L2_CID_AUDIO_VOLUME:
691 case V4L2_CID_AUDIO_BASS:
692 case V4L2_CID_AUDIO_TREBLE:
693 case V4L2_CID_AUDIO_BALANCE:
694 case V4L2_CID_AUDIO_MUTE:
695 if (state->is_cx25836)
696 return -EINVAL;
697 return cx25840_audio(client, VIDIOC_G_CTRL, ctrl);
698 default:
699 return -EINVAL;
700 }
701
702 return 0;
703 }
704
705 /* ----------------------------------------------------------------------- */
706
707 static int get_v4lfmt(struct i2c_client *client, struct v4l2_format *fmt)
708 {
709 switch (fmt->type) {
710 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
711 return cx25840_vbi(client, VIDIOC_G_FMT, fmt);
712 default:
713 return -EINVAL;
714 }
715
716 return 0;
717 }
718
719 static int set_v4lfmt(struct i2c_client *client, struct v4l2_format *fmt)
720 {
721 struct v4l2_pix_format *pix;
722 int HSC, VSC, Vsrc, Hsrc, filter, Vlines;
723 int is_50Hz = !(cx25840_get_v4lstd(client) & V4L2_STD_525_60);
724
725 switch (fmt->type) {
726 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
727 pix = &(fmt->fmt.pix);
728
729 Vsrc = (cx25840_read(client, 0x476) & 0x3f) << 4;
730 Vsrc |= (cx25840_read(client, 0x475) & 0xf0) >> 4;
731
732 Hsrc = (cx25840_read(client, 0x472) & 0x3f) << 4;
733 Hsrc |= (cx25840_read(client, 0x471) & 0xf0) >> 4;
734
735 Vlines = pix->height + (is_50Hz ? 4 : 7);
736
737 if ((pix->width * 16 < Hsrc) || (Hsrc < pix->width) ||
738 (Vlines * 8 < Vsrc) || (Vsrc < Vlines)) {
739 v4l_err(client, "%dx%d is not a valid size!\n",
740 pix->width, pix->height);
741 return -ERANGE;
742 }
743
744 HSC = (Hsrc * (1 << 20)) / pix->width - (1 << 20);
745 VSC = (1 << 16) - (Vsrc * (1 << 9) / Vlines - (1 << 9));
746 VSC &= 0x1fff;
747
748 if (pix->width >= 385)
749 filter = 0;
750 else if (pix->width > 192)
751 filter = 1;
752 else if (pix->width > 96)
753 filter = 2;
754 else
755 filter = 3;
756
757 v4l_dbg(1, cx25840_debug, client, "decoder set size %dx%d -> scale %ux%u\n",
758 pix->width, pix->height, HSC, VSC);
759
760 /* HSCALE=HSC */
761 cx25840_write(client, 0x418, HSC & 0xff);
762 cx25840_write(client, 0x419, (HSC >> 8) & 0xff);
763 cx25840_write(client, 0x41a, HSC >> 16);
764 /* VSCALE=VSC */
765 cx25840_write(client, 0x41c, VSC & 0xff);
766 cx25840_write(client, 0x41d, VSC >> 8);
767 /* VS_INTRLACE=1 VFILT=filter */
768 cx25840_write(client, 0x41e, 0x8 | filter);
769 break;
770
771 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
772 return cx25840_vbi(client, VIDIOC_S_FMT, fmt);
773
774 case V4L2_BUF_TYPE_VBI_CAPTURE:
775 return cx25840_vbi(client, VIDIOC_S_FMT, fmt);
776
777 default:
778 return -EINVAL;
779 }
780
781 return 0;
782 }
783
784 /* ----------------------------------------------------------------------- */
785
786 static void log_video_status(struct i2c_client *client)
787 {
788 static const char *const fmt_strs[] = {
789 "0x0",
790 "NTSC-M", "NTSC-J", "NTSC-4.43",
791 "PAL-BDGHI", "PAL-M", "PAL-N", "PAL-Nc", "PAL-60",
792 "0x9", "0xA", "0xB",
793 "SECAM",
794 "0xD", "0xE", "0xF"
795 };
796
797 struct cx25840_state *state = i2c_get_clientdata(client);
798 u8 vidfmt_sel = cx25840_read(client, 0x400) & 0xf;
799 u8 gen_stat1 = cx25840_read(client, 0x40d);
800 u8 gen_stat2 = cx25840_read(client, 0x40e);
801 int vid_input = state->vid_input;
802
803 v4l_info(client, "Video signal: %spresent\n",
804 (gen_stat2 & 0x20) ? "" : "not ");
805 v4l_info(client, "Detected format: %s\n",
806 fmt_strs[gen_stat1 & 0xf]);
807
808 v4l_info(client, "Specified standard: %s\n",
809 vidfmt_sel ? fmt_strs[vidfmt_sel] : "automatic detection");
810
811 if (vid_input >= CX25840_COMPOSITE1 &&
812 vid_input <= CX25840_COMPOSITE8) {
813 v4l_info(client, "Specified video input: Composite %d\n",
814 vid_input - CX25840_COMPOSITE1 + 1);
815 } else {
816 v4l_info(client, "Specified video input: S-Video (Luma In%d, Chroma In%d)\n",
817 (vid_input & 0xf0) >> 4, (vid_input & 0xf00) >> 8);
818 }
819
820 v4l_info(client, "Specified audioclock freq: %d Hz\n", state->audclk_freq);
821 }
822
823 /* ----------------------------------------------------------------------- */
824
825 static void log_audio_status(struct i2c_client *client)
826 {
827 struct cx25840_state *state = i2c_get_clientdata(client);
828 u8 download_ctl = cx25840_read(client, 0x803);
829 u8 mod_det_stat0 = cx25840_read(client, 0x804);
830 u8 mod_det_stat1 = cx25840_read(client, 0x805);
831 u8 audio_config = cx25840_read(client, 0x808);
832 u8 pref_mode = cx25840_read(client, 0x809);
833 u8 afc0 = cx25840_read(client, 0x80b);
834 u8 mute_ctl = cx25840_read(client, 0x8d3);
835 int aud_input = state->aud_input;
836 char *p;
837
838 switch (mod_det_stat0) {
839 case 0x00: p = "mono"; break;
840 case 0x01: p = "stereo"; break;
841 case 0x02: p = "dual"; break;
842 case 0x04: p = "tri"; break;
843 case 0x10: p = "mono with SAP"; break;
844 case 0x11: p = "stereo with SAP"; break;
845 case 0x12: p = "dual with SAP"; break;
846 case 0x14: p = "tri with SAP"; break;
847 case 0xfe: p = "forced mode"; break;
848 default: p = "not defined";
849 }
850 v4l_info(client, "Detected audio mode: %s\n", p);
851
852 switch (mod_det_stat1) {
853 case 0x00: p = "not defined"; break;
854 case 0x01: p = "EIAJ"; break;
855 case 0x02: p = "A2-M"; break;
856 case 0x03: p = "A2-BG"; break;
857 case 0x04: p = "A2-DK1"; break;
858 case 0x05: p = "A2-DK2"; break;
859 case 0x06: p = "A2-DK3"; break;
860 case 0x07: p = "A1 (6.0 MHz FM Mono)"; break;
861 case 0x08: p = "AM-L"; break;
862 case 0x09: p = "NICAM-BG"; break;
863 case 0x0a: p = "NICAM-DK"; break;
864 case 0x0b: p = "NICAM-I"; break;
865 case 0x0c: p = "NICAM-L"; break;
866 case 0x0d: p = "BTSC/EIAJ/A2-M Mono (4.5 MHz FMMono)"; break;
867 case 0x0e: p = "IF FM Radio"; break;
868 case 0x0f: p = "BTSC"; break;
869 case 0x10: p = "high-deviation FM"; break;
870 case 0x11: p = "very high-deviation FM"; break;
871 case 0xfd: p = "unknown audio standard"; break;
872 case 0xfe: p = "forced audio standard"; break;
873 case 0xff: p = "no detected audio standard"; break;
874 default: p = "not defined";
875 }
876 v4l_info(client, "Detected audio standard: %s\n", p);
877 v4l_info(client, "Audio muted: %s\n",
878 (state->unmute_volume >= 0) ? "yes" : "no");
879 v4l_info(client, "Audio microcontroller: %s\n",
880 (download_ctl & 0x10) ?
881 ((mute_ctl & 0x2) ? "detecting" : "running") : "stopped");
882
883 switch (audio_config >> 4) {
884 case 0x00: p = "undefined"; break;
885 case 0x01: p = "BTSC"; break;
886 case 0x02: p = "EIAJ"; break;
887 case 0x03: p = "A2-M"; break;
888 case 0x04: p = "A2-BG"; break;
889 case 0x05: p = "A2-DK1"; break;
890 case 0x06: p = "A2-DK2"; break;
891 case 0x07: p = "A2-DK3"; break;
892 case 0x08: p = "A1 (6.0 MHz FM Mono)"; break;
893 case 0x09: p = "AM-L"; break;
894 case 0x0a: p = "NICAM-BG"; break;
895 case 0x0b: p = "NICAM-DK"; break;
896 case 0x0c: p = "NICAM-I"; break;
897 case 0x0d: p = "NICAM-L"; break;
898 case 0x0e: p = "FM radio"; break;
899 case 0x0f: p = "automatic detection"; break;
900 default: p = "undefined";
901 }
902 v4l_info(client, "Configured audio standard: %s\n", p);
903
904 if ((audio_config >> 4) < 0xF) {
905 switch (audio_config & 0xF) {
906 case 0x00: p = "MONO1 (LANGUAGE A/Mono L+R channel for BTSC, EIAJ, A2)"; break;
907 case 0x01: p = "MONO2 (LANGUAGE B)"; break;
908 case 0x02: p = "MONO3 (STEREO forced MONO)"; break;
909 case 0x03: p = "MONO4 (NICAM ANALOG-Language C/Analog Fallback)"; break;
910 case 0x04: p = "STEREO"; break;
911 case 0x05: p = "DUAL1 (AB)"; break;
912 case 0x06: p = "DUAL2 (AC) (FM)"; break;
913 case 0x07: p = "DUAL3 (BC) (FM)"; break;
914 case 0x08: p = "DUAL4 (AC) (AM)"; break;
915 case 0x09: p = "DUAL5 (BC) (AM)"; break;
916 case 0x0a: p = "SAP"; break;
917 default: p = "undefined";
918 }
919 v4l_info(client, "Configured audio mode: %s\n", p);
920 } else {
921 switch (audio_config & 0xF) {
922 case 0x00: p = "BG"; break;
923 case 0x01: p = "DK1"; break;
924 case 0x02: p = "DK2"; break;
925 case 0x03: p = "DK3"; break;
926 case 0x04: p = "I"; break;
927 case 0x05: p = "L"; break;
928 case 0x06: p = "BTSC"; break;
929 case 0x07: p = "EIAJ"; break;
930 case 0x08: p = "A2-M"; break;
931 case 0x09: p = "FM Radio"; break;
932 case 0x0f: p = "automatic standard and mode detection"; break;
933 default: p = "undefined";
934 }
935 v4l_info(client, "Configured audio system: %s\n", p);
936 }
937
938 if (aud_input) {
939 v4l_info(client, "Specified audio input: Tuner (In%d)\n", aud_input);
940 } else {
941 v4l_info(client, "Specified audio input: External\n");
942 }
943
944 switch (pref_mode & 0xf) {
945 case 0: p = "mono/language A"; break;
946 case 1: p = "language B"; break;
947 case 2: p = "language C"; break;
948 case 3: p = "analog fallback"; break;
949 case 4: p = "stereo"; break;
950 case 5: p = "language AC"; break;
951 case 6: p = "language BC"; break;
952 case 7: p = "language AB"; break;
953 default: p = "undefined";
954 }
955 v4l_info(client, "Preferred audio mode: %s\n", p);
956
957 if ((audio_config & 0xf) == 0xf) {
958 switch ((afc0 >> 3) & 0x3) {
959 case 0: p = "system DK"; break;
960 case 1: p = "system L"; break;
961 case 2: p = "autodetect"; break;
962 default: p = "undefined";
963 }
964 v4l_info(client, "Selected 65 MHz format: %s\n", p);
965
966 switch (afc0 & 0x7) {
967 case 0: p = "chroma"; break;
968 case 1: p = "BTSC"; break;
969 case 2: p = "EIAJ"; break;
970 case 3: p = "A2-M"; break;
971 case 4: p = "autodetect"; break;
972 default: p = "undefined";
973 }
974 v4l_info(client, "Selected 45 MHz format: %s\n", p);
975 }
976 }
977
978 /* ----------------------------------------------------------------------- */
979
980 static int cx25840_command(struct i2c_client *client, unsigned int cmd,
981 void *arg)
982 {
983 struct cx25840_state *state = i2c_get_clientdata(client);
984 struct v4l2_tuner *vt = arg;
985 struct v4l2_routing *route = arg;
986
987 /* ignore these commands */
988 switch (cmd) {
989 case TUNER_SET_TYPE_ADDR:
990 return 0;
991 }
992
993 if (!state->is_initialized) {
994 v4l_dbg(1, cx25840_debug, client, "cmd %08x triggered fw load\n", cmd);
995 /* initialize on first use */
996 state->is_initialized = 1;
997 if (state->is_cx25836)
998 cx25836_initialize(client);
999 else if (state->is_cx23885)
1000 cx23885_initialize(client);
1001 else
1002 cx25840_initialize(client);
1003 }
1004
1005 switch (cmd) {
1006 #ifdef CONFIG_VIDEO_ADV_DEBUG
1007 /* ioctls to allow direct access to the
1008 * cx25840 registers for testing */
1009 case VIDIOC_DBG_G_REGISTER:
1010 case VIDIOC_DBG_S_REGISTER:
1011 {
1012 struct v4l2_register *reg = arg;
1013
1014 if (!v4l2_chip_match_i2c_client(client, reg->match_type, reg->match_chip))
1015 return -EINVAL;
1016 if (!capable(CAP_SYS_ADMIN))
1017 return -EPERM;
1018
1019 if (cmd == VIDIOC_DBG_G_REGISTER)
1020 reg->val = cx25840_read(client, reg->reg & 0x0fff);
1021 else
1022 cx25840_write(client, reg->reg & 0x0fff, reg->val & 0xff);
1023 break;
1024 }
1025 #endif
1026
1027 case VIDIOC_INT_DECODE_VBI_LINE:
1028 return cx25840_vbi(client, cmd, arg);
1029
1030 case VIDIOC_INT_AUDIO_CLOCK_FREQ:
1031 return cx25840_audio(client, cmd, arg);
1032
1033 case VIDIOC_STREAMON:
1034 v4l_dbg(1, cx25840_debug, client, "enable output\n");
1035 if (state->is_cx23885) {
1036 u8 v = (cx25840_read(client, 0x421) | 0x0b);
1037 cx25840_write(client, 0x421, v);
1038 } else {
1039 cx25840_write(client, 0x115,
1040 state->is_cx25836 ? 0x0c : 0x8c);
1041 cx25840_write(client, 0x116,
1042 state->is_cx25836 ? 0x04 : 0x07);
1043 }
1044 break;
1045
1046 case VIDIOC_STREAMOFF:
1047 v4l_dbg(1, cx25840_debug, client, "disable output\n");
1048 if (state->is_cx23885) {
1049 u8 v = cx25840_read(client, 0x421) & ~(0x0b);
1050 cx25840_write(client, 0x421, v);
1051 } else {
1052 cx25840_write(client, 0x115, 0x00);
1053 cx25840_write(client, 0x116, 0x00);
1054 }
1055 break;
1056
1057 case VIDIOC_LOG_STATUS:
1058 log_video_status(client);
1059 if (!state->is_cx25836)
1060 log_audio_status(client);
1061 break;
1062
1063 case VIDIOC_G_CTRL:
1064 return get_v4lctrl(client, (struct v4l2_control *)arg);
1065
1066 case VIDIOC_S_CTRL:
1067 return set_v4lctrl(client, (struct v4l2_control *)arg);
1068
1069 case VIDIOC_QUERYCTRL:
1070 {
1071 struct v4l2_queryctrl *qc = arg;
1072
1073 switch (qc->id) {
1074 case V4L2_CID_BRIGHTNESS:
1075 case V4L2_CID_CONTRAST:
1076 case V4L2_CID_SATURATION:
1077 case V4L2_CID_HUE:
1078 return v4l2_ctrl_query_fill_std(qc);
1079 default:
1080 break;
1081 }
1082 if (state->is_cx25836)
1083 return -EINVAL;
1084
1085 switch (qc->id) {
1086 case V4L2_CID_AUDIO_VOLUME:
1087 case V4L2_CID_AUDIO_MUTE:
1088 case V4L2_CID_AUDIO_BALANCE:
1089 case V4L2_CID_AUDIO_BASS:
1090 case V4L2_CID_AUDIO_TREBLE:
1091 return v4l2_ctrl_query_fill_std(qc);
1092 default:
1093 return -EINVAL;
1094 }
1095 return -EINVAL;
1096 }
1097
1098 case VIDIOC_G_STD:
1099 *(v4l2_std_id *)arg = cx25840_get_v4lstd(client);
1100 break;
1101
1102 case VIDIOC_S_STD:
1103 state->radio = 0;
1104 return set_v4lstd(client, *(v4l2_std_id *)arg);
1105
1106 case AUDC_SET_RADIO:
1107 state->radio = 1;
1108 break;
1109
1110 case VIDIOC_INT_G_VIDEO_ROUTING:
1111 route->input = state->vid_input;
1112 route->output = 0;
1113 break;
1114
1115 case VIDIOC_INT_S_VIDEO_ROUTING:
1116 return set_input(client, route->input, state->aud_input);
1117
1118 case VIDIOC_INT_G_AUDIO_ROUTING:
1119 if (state->is_cx25836)
1120 return -EINVAL;
1121 route->input = state->aud_input;
1122 route->output = 0;
1123 break;
1124
1125 case VIDIOC_INT_S_AUDIO_ROUTING:
1126 if (state->is_cx25836)
1127 return -EINVAL;
1128 return set_input(client, state->vid_input, route->input);
1129
1130 case VIDIOC_S_FREQUENCY:
1131 if (!state->is_cx25836) {
1132 input_change(client);
1133 }
1134 break;
1135
1136 case VIDIOC_G_TUNER:
1137 {
1138 u8 vpres = cx25840_read(client, 0x40e) & 0x20;
1139 u8 mode;
1140 int val = 0;
1141
1142 if (state->radio)
1143 break;
1144
1145 vt->signal = vpres ? 0xffff : 0x0;
1146 if (state->is_cx25836)
1147 break;
1148
1149 vt->capability |=
1150 V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_LANG1 |
1151 V4L2_TUNER_CAP_LANG2 | V4L2_TUNER_CAP_SAP;
1152
1153 mode = cx25840_read(client, 0x804);
1154
1155 /* get rxsubchans and audmode */
1156 if ((mode & 0xf) == 1)
1157 val |= V4L2_TUNER_SUB_STEREO;
1158 else
1159 val |= V4L2_TUNER_SUB_MONO;
1160
1161 if (mode == 2 || mode == 4)
1162 val = V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_LANG2;
1163
1164 if (mode & 0x10)
1165 val |= V4L2_TUNER_SUB_SAP;
1166
1167 vt->rxsubchans = val;
1168 vt->audmode = state->audmode;
1169 break;
1170 }
1171
1172 case VIDIOC_S_TUNER:
1173 if (state->radio || state->is_cx25836)
1174 break;
1175
1176 switch (vt->audmode) {
1177 case V4L2_TUNER_MODE_MONO:
1178 /* mono -> mono
1179 stereo -> mono
1180 bilingual -> lang1 */
1181 cx25840_and_or(client, 0x809, ~0xf, 0x00);
1182 break;
1183 case V4L2_TUNER_MODE_STEREO:
1184 case V4L2_TUNER_MODE_LANG1:
1185 /* mono -> mono
1186 stereo -> stereo
1187 bilingual -> lang1 */
1188 cx25840_and_or(client, 0x809, ~0xf, 0x04);
1189 break;
1190 case V4L2_TUNER_MODE_LANG1_LANG2:
1191 /* mono -> mono
1192 stereo -> stereo
1193 bilingual -> lang1/lang2 */
1194 cx25840_and_or(client, 0x809, ~0xf, 0x07);
1195 break;
1196 case V4L2_TUNER_MODE_LANG2:
1197 /* mono -> mono
1198 stereo -> stereo
1199 bilingual -> lang2 */
1200 cx25840_and_or(client, 0x809, ~0xf, 0x01);
1201 break;
1202 default:
1203 return -EINVAL;
1204 }
1205 state->audmode = vt->audmode;
1206 break;
1207
1208 case VIDIOC_G_FMT:
1209 return get_v4lfmt(client, (struct v4l2_format *)arg);
1210
1211 case VIDIOC_S_FMT:
1212 return set_v4lfmt(client, (struct v4l2_format *)arg);
1213
1214 case VIDIOC_INT_RESET:
1215 if (state->is_cx25836)
1216 cx25836_initialize(client);
1217 else if (state->is_cx23885)
1218 cx23885_initialize(client);
1219 else
1220 cx25840_initialize(client);
1221 break;
1222
1223 case VIDIOC_G_CHIP_IDENT:
1224 return v4l2_chip_ident_i2c_client(client, arg, state->id, state->rev);
1225
1226 default:
1227 return -EINVAL;
1228 }
1229
1230 return 0;
1231 }
1232
1233 /* ----------------------------------------------------------------------- */
1234
1235 static int cx25840_probe(struct i2c_client *client)
1236 {
1237 struct cx25840_state *state;
1238 u32 id;
1239 u16 device_id;
1240
1241 /* Check if the adapter supports the needed features */
1242 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1243 return -EIO;
1244
1245 v4l_dbg(1, cx25840_debug, client, "detecting cx25840 client on address 0x%x\n", client->addr << 1);
1246
1247 device_id = cx25840_read(client, 0x101) << 8;
1248 device_id |= cx25840_read(client, 0x100);
1249 v4l_dbg(1, cx25840_debug, client, "device_id = 0x%04x\n", device_id);
1250
1251 /* The high byte of the device ID should be
1252 * 0x83 for the cx2583x and 0x84 for the cx2584x */
1253 if ((device_id & 0xff00) == 0x8300) {
1254 id = V4L2_IDENT_CX25836 + ((device_id >> 4) & 0xf) - 6;
1255 }
1256 else if ((device_id & 0xff00) == 0x8400) {
1257 id = V4L2_IDENT_CX25840 + ((device_id >> 4) & 0xf);
1258 } else if (device_id == 0x0000) {
1259 id = V4L2_IDENT_CX25836 + ((device_id >> 4) & 0xf) - 6;
1260 } else if (device_id == 0x1313) {
1261 id = V4L2_IDENT_CX25836 + ((device_id >> 4) & 0xf) - 6;
1262 }
1263 else {
1264 v4l_dbg(1, cx25840_debug, client, "cx25840 not found\n");
1265 return -ENODEV;
1266 }
1267
1268 state = kzalloc(sizeof(struct cx25840_state), GFP_KERNEL);
1269 if (state == NULL) {
1270 return -ENOMEM;
1271 }
1272
1273 /* Note: revision '(device_id & 0x0f) == 2' was never built. The
1274 marking skips from 0x1 == 22 to 0x3 == 23. */
1275 v4l_info(client, "cx25%3x-2%x found @ 0x%x (%s)\n",
1276 (device_id & 0xfff0) >> 4,
1277 (device_id & 0x0f) < 3 ? (device_id & 0x0f) + 1 : (device_id & 0x0f),
1278 client->addr << 1, client->adapter->name);
1279
1280 i2c_set_clientdata(client, state);
1281 state->c = client;
1282 state->is_cx25836 = ((device_id & 0xff00) == 0x8300);
1283 state->is_cx23885 = (device_id == 0x0000) || (device_id == 0x1313);
1284 state->vid_input = CX25840_COMPOSITE7;
1285 state->aud_input = CX25840_AUDIO8;
1286 state->audclk_freq = 48000;
1287 state->pvr150_workaround = 0;
1288 state->audmode = V4L2_TUNER_MODE_LANG1;
1289 state->unmute_volume = -1;
1290 state->vbi_line_offset = 8;
1291 state->id = id;
1292 state->rev = device_id;
1293
1294 return 0;
1295 }
1296
1297 static int cx25840_remove(struct i2c_client *client)
1298 {
1299 kfree(i2c_get_clientdata(client));
1300 return 0;
1301 }
1302
1303 static struct v4l2_i2c_driver_data v4l2_i2c_data = {
1304 .name = "cx25840",
1305 .driverid = I2C_DRIVERID_CX25840,
1306 .command = cx25840_command,
1307 .probe = cx25840_probe,
1308 .remove = cx25840_remove,
1309 };
mah project overlay