1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
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
47MODULE_DESCRIPTION("Conexant CX25840 audio/video decoder driver");
48MODULE_AUTHOR("Ulf Eklund, Chris Kennedy, Hans Verkuil, Tyler Trafford");
49MODULE_LICENSE("GPL");
50
51static int cx25840_debug;
52
53module_param_named(debug,cx25840_debug, int, 0644);
54
55MODULE_PARM_DESC(debug, "Debugging messages [0=Off (default) 1=On]");
56
57
58
59
60int 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
69int 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
81u8 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
96u32 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
112int 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
122static int set_input(struct i2c_client *client, enum cx25840_video_input vid_input,
123 enum cx25840_audio_input aud_input);
124
125
126
127static void init_dll1(struct i2c_client *client)
128{
129
130
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
143static void init_dll2(struct i2c_client *client)
144{
145
146
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
156static void cx25836_initialize(struct i2c_client *client)
157{
158
159
160 cx25840_and_or(client, 0x000, ~0x01, 0x01);
161 cx25840_and_or(client, 0x000, ~0x01, 0x00);
162
163 cx25840_and_or(client, 0x15a, ~0x70, 0x00);
164
165 cx25840_and_or(client, 0x15b, ~0x1e, 0x06);
166
167 cx25840_and_or(client, 0x159, ~0x02, 0x02);
168
169 udelay(10);
170
171 cx25840_and_or(client, 0x159, ~0x02, 0x00);
172
173 cx25840_and_or(client, 0x159, ~0xc0, 0xc0);
174
175 cx25840_and_or(client, 0x159, ~0x01, 0x00);
176 cx25840_and_or(client, 0x159, ~0x01, 0x01);
177
178 cx25840_and_or(client, 0x15b, ~0x1e, 0x10);
179}
180
181static 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
188static 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
195
196 cx25840_and_or(client, 0x803, ~0x10, 0x00);
197
198
199 cx25840_write(client, 0x000, 0x04);
200
201 init_dll1(client);
202 init_dll2(client);
203 cx25840_write(client, 0x136, 0x0a);
204
205 cx25840_write(client, 0x13c, 0x01);
206 cx25840_write(client, 0x13c, 0x00);
207
208
209
210
211
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
222 cx25840_write(client, 0x115, 0x8c);
223 cx25840_write(client, 0x116, 0x07);
224 cx25840_write(client, 0x118, 0x02);
225
226 cx25840_write(client, 0x4a5, 0x80);
227 cx25840_write(client, 0x4a5, 0x00);
228 cx25840_write(client, 0x402, 0x00);
229
230 cx25840_and_or(client, 0x401, ~0x18, 0);
231 cx25840_and_or(client, 0x4a2, ~0x10, 0x10);
232
233
234 cx25840_write(client, 0x8d3, 0x1f);
235 cx25840_write(client, 0x8e3, 0x03);
236
237 cx25840_std_setup(client);
238
239
240 cx25840_write(client, 0x914, 0xa0);
241 cx25840_write(client, 0x918, 0xa0);
242 cx25840_write(client, 0x919, 0x01);
243
244
245 cx25840_write(client, 0x809, 0x04);
246
247 cx25840_write(client, 0x8cf, 0x0f);
248
249
250 set_input(client, state->vid_input, state->aud_input);
251
252
253 cx25840_and_or(client, 0x803, ~0x10, 0x10);
254}
255
256static 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
263 cx25840_and_or(client, 0x102, ~0x01, 0x01);
264 cx25840_and_or(client, 0x102, ~0x01, 0x00);
265
266
267 cx25840_and_or(client, 0x803, ~0x10, 0x00);
268
269
270 cx25840_write(client, 0x398, 0);
271
272
273
274 cx25840_write(client, 0x2, 0x76);
275
276
277 cx25840_write(client, 0x1, 0x40);
278
279
280 cx25840_write4(client, 0x11c, 0x01d1744c);
281
282
283 cx25840_write4(client, 0x118, 0x00000416);
284
285
286 cx25840_write4(client, 0x33c, 0x00000001);
287
288
289 cx25840_write4(client, 0x340, 0x0df7df83);
290
291
292 cx25840_write4(client, 0x10c, 0x01b6db7b);
293
294
295 cx25840_write4(client, 0x108, 0x00000512);
296
297
298 cx25840_write4(client, 0x414, 0x00107d12);
299
300
301 cx25840_write4(client, 0x420, 0x3d008282);
302
303
304 cx25840_write4(client, 0x114, 0x017dbf48);
305
306
307 cx25840_write4(client, 0x110, 0x000a030e);
308
309
310 cx25840_write(client, 0x102, 0x10);
311
312
313 cx25840_write(client, 0x103, 0x11);
314
315
316 cx25840_write(client, 0x400, 0);
317
318
319 cx25840_write(client, 0x401, 0xe8);
320
321
322 cx25840_write(client, 0x144, 0x05);
323
324
325
326
327
328
329
330 cx25840_write(client, 0x160, 0x1d);
331 cx25840_write(client, 0x164, 0x00);
332
333
334
335
336
337 INIT_WORK(&state->fw_work, cx25840_work_handler);
338 init_waitqueue_head(&state->fw_wait);
339 q = create_singlethread_workqueue("cx25840_fw");
340 prepare_to_wait(&state->fw_wait, &wait, TASK_UNINTERRUPTIBLE);
341 queue_work(q, &state->fw_work);
342 schedule();
343 finish_wait(&state->fw_wait, &wait);
344 destroy_workqueue(q);
345
346 cx25840_std_setup(client);
347
348
349 set_input(client, state->vid_input, state->aud_input);
350
351
352 cx25840_and_or(client, 0x803, ~0x10, 0x10);
353}
354
355
356
357static void cx231xx_initialize(struct i2c_client *client)
358{
359 DEFINE_WAIT(wait);
360 struct cx25840_state *state = to_state(i2c_get_clientdata(client));
361 struct workqueue_struct *q;
362
363
364 cx25840_and_or(client, 0x102, ~0x01, 0x01);
365 cx25840_and_or(client, 0x102, ~0x01, 0x00);
366
367
368 cx25840_and_or(client, 0x803, ~0x10, 0x00);
369
370
371 cx25840_write(client, 0x398, 0);
372
373
374
375 cx25840_write(client, 0x2, 0x76);
376
377
378 cx25840_write(client, 0x1, 0x40);
379
380
381 cx25840_write4(client, 0x33c, 0x00000001);
382
383
384 cx25840_write4(client, 0x340, 0x0df7df83);
385
386
387 cx25840_write4(client, 0x414, 0x00107d12);
388
389
390 cx25840_write4(client, 0x420, 0x3d008282);
391
392
393 cx25840_write(client, 0x102, 0x10);
394
395
396 cx25840_write(client, 0x103, 0x11);
397
398
399 cx25840_write(client, 0x400, 0);
400
401
402 cx25840_write(client, 0x401, 0xe8);
403
404
405
406
407
408 INIT_WORK(&state->fw_work, cx25840_work_handler);
409 init_waitqueue_head(&state->fw_wait);
410 q = create_singlethread_workqueue("cx25840_fw");
411 prepare_to_wait(&state->fw_wait, &wait, TASK_UNINTERRUPTIBLE);
412 queue_work(q, &state->fw_work);
413 schedule();
414 finish_wait(&state->fw_wait, &wait);
415 destroy_workqueue(q);
416
417 cx25840_std_setup(client);
418
419
420 set_input(client, state->vid_input, state->aud_input);
421
422
423 cx25840_and_or(client, 0x803, ~0x10, 0x10);
424}
425
426
427
428void cx25840_std_setup(struct i2c_client *client)
429{
430 struct cx25840_state *state = to_state(i2c_get_clientdata(client));
431 v4l2_std_id std = state->std;
432 int hblank, hactive, burst, vblank, vactive, sc;
433 int vblank656, src_decimation;
434 int luma_lpf, uv_lpf, comb;
435 u32 pll_int, pll_frac, pll_post;
436
437
438 if (std & ~V4L2_STD_NTSC)
439 cx25840_write(client, 0x49f, 0x11);
440 else
441 cx25840_write(client, 0x49f, 0x14);
442
443 if (std & V4L2_STD_625_50) {
444 hblank = 132;
445 hactive = 720;
446 burst = 93;
447 vblank = 36;
448 vactive = 580;
449 vblank656 = 40;
450 src_decimation = 0x21f;
451 luma_lpf = 2;
452
453 if (std & V4L2_STD_SECAM) {
454 uv_lpf = 0;
455 comb = 0;
456 sc = 0x0a425f;
457 } else if (std == V4L2_STD_PAL_Nc) {
458 uv_lpf = 1;
459 comb = 0x20;
460 sc = 556453;
461 } else {
462 uv_lpf = 1;
463 comb = 0x20;
464 sc = 688739;
465 }
466 } else {
467 hactive = 720;
468 hblank = 122;
469 vactive = 487;
470 luma_lpf = 1;
471 uv_lpf = 1;
472
473 src_decimation = 0x21f;
474 if (std == V4L2_STD_PAL_60) {
475 vblank = 26;
476 vblank656 = 26;
477 burst = 0x5b;
478 luma_lpf = 2;
479 comb = 0x20;
480 sc = 688739;
481 } else if (std == V4L2_STD_PAL_M) {
482 vblank = 20;
483 vblank656 = 24;
484 burst = 0x61;
485 comb = 0x20;
486 sc = 555452;
487 } else {
488 vblank = 26;
489 vblank656 = 26;
490 burst = 0x5b;
491 comb = 0x66;
492 sc = 556063;
493 }
494 }
495
496
497 if (!state->is_cx231xx) {
498 pll_int = cx25840_read(client, 0x108);
499 pll_frac = cx25840_read4(client, 0x10c) & 0x1ffffff;
500 pll_post = cx25840_read(client, 0x109);
501 v4l_dbg(1, cx25840_debug, client,
502 "PLL regs = int: %u, frac: %u, post: %u\n",
503 pll_int, pll_frac, pll_post);
504
505 if (pll_post) {
506 int fin, fsc;
507 int pll = (28636363L * ((((u64)pll_int) << 25L) + pll_frac)) >> 25L;
508
509 pll /= pll_post;
510 v4l_dbg(1, cx25840_debug, client, "PLL = %d.%06d MHz\n",
511 pll / 1000000, pll % 1000000);
512 v4l_dbg(1, cx25840_debug, client, "PLL/8 = %d.%06d MHz\n",
513 pll / 8000000, (pll / 8) % 1000000);
514
515 fin = ((u64)src_decimation * pll) >> 12;
516 v4l_dbg(1, cx25840_debug, client,
517 "ADC Sampling freq = %d.%06d MHz\n",
518 fin / 1000000, fin % 1000000);
519
520 fsc = (((u64)sc) * pll) >> 24L;
521 v4l_dbg(1, cx25840_debug, client,
522 "Chroma sub-carrier freq = %d.%06d MHz\n",
523 fsc / 1000000, fsc % 1000000);
524
525 v4l_dbg(1, cx25840_debug, client, "hblank %i, hactive %i, "
526 "vblank %i, vactive %i, vblank656 %i, src_dec %i, "
527 "burst 0x%02x, luma_lpf %i, uv_lpf %i, comb 0x%02x, "
528 "sc 0x%06x\n",
529 hblank, hactive, vblank, vactive, vblank656,
530 src_decimation, burst, luma_lpf, uv_lpf, comb, sc);
531 }
532 }
533
534
535 cx25840_write(client, 0x470, hblank);
536 cx25840_write(client, 0x471,
537 0xff & (((hblank >> 8) & 0x3) | (hactive << 4)));
538 cx25840_write(client, 0x472, hactive >> 4);
539
540
541 cx25840_write(client, 0x473, burst);
542
543
544 cx25840_write(client, 0x474, vblank);
545 cx25840_write(client, 0x475,
546 0xff & (((vblank >> 8) & 0x3) | (vactive << 4)));
547 cx25840_write(client, 0x476, vactive >> 4);
548 cx25840_write(client, 0x477, vblank656);
549
550
551 cx25840_write(client, 0x478, 0xff & src_decimation);
552 cx25840_write(client, 0x479, 0xff & (src_decimation >> 8));
553
554
555 cx25840_write(client, 0x47a, luma_lpf << 6 | ((uv_lpf << 4) & 0x30));
556
557
558 cx25840_write(client, 0x47b, comb);
559
560
561 cx25840_write(client, 0x47c, sc);
562 cx25840_write(client, 0x47d, 0xff & sc >> 8);
563 cx25840_write(client, 0x47e, 0xff & sc >> 16);
564
565
566 if (std & V4L2_STD_625_50) {
567 cx25840_write(client, 0x47f, 0x01);
568 state->vbi_line_offset = 5;
569 } else {
570 cx25840_write(client, 0x47f, 0x00);
571 state->vbi_line_offset = 8;
572 }
573}
574
575
576
577static void input_change(struct i2c_client *client)
578{
579 struct cx25840_state *state = to_state(i2c_get_clientdata(client));
580 v4l2_std_id std = state->std;
581
582
583 if (std & V4L2_STD_SECAM) {
584 cx25840_write(client, 0x402, 0);
585 }
586 else {
587 cx25840_write(client, 0x402, 0x04);
588 cx25840_write(client, 0x49f, (std & V4L2_STD_NTSC) ? 0x14 : 0x11);
589 }
590 cx25840_and_or(client, 0x401, ~0x60, 0);
591 cx25840_and_or(client, 0x401, ~0x60, 0x60);
592 cx25840_and_or(client, 0x810, ~0x01, 1);
593
594 if (state->radio) {
595 cx25840_write(client, 0x808, 0xf9);
596 cx25840_write(client, 0x80b, 0x00);
597 }
598 else if (std & V4L2_STD_525_60) {
599
600
601
602
603
604 int hw_fix = state->pvr150_workaround;
605
606 if (std == V4L2_STD_NTSC_M_JP) {
607
608 cx25840_write(client, 0x808, hw_fix ? 0x2f : 0xf7);
609 } else if (std == V4L2_STD_NTSC_M_KR) {
610
611 cx25840_write(client, 0x808, hw_fix ? 0x3f : 0xf8);
612 } else {
613
614 cx25840_write(client, 0x808, hw_fix ? 0x1f : 0xf6);
615 }
616 cx25840_write(client, 0x80b, 0x00);
617 } else if (std & V4L2_STD_PAL) {
618
619 cx25840_write(client, 0x808, 0xff);
620 cx25840_write(client, 0x80b, 0x10);
621 } else if (std & V4L2_STD_SECAM) {
622
623 cx25840_write(client, 0x808, 0xff);
624 cx25840_write(client, 0x80b, 0x10);
625 }
626
627 cx25840_and_or(client, 0x810, ~0x01, 0);
628}
629
630static int set_input(struct i2c_client *client, enum cx25840_video_input vid_input,
631 enum cx25840_audio_input aud_input)
632{
633 struct cx25840_state *state = to_state(i2c_get_clientdata(client));
634 u8 is_composite = (vid_input >= CX25840_COMPOSITE1 &&
635 vid_input <= CX25840_COMPOSITE8);
636 u8 reg;
637
638 v4l_dbg(1, cx25840_debug, client,
639 "decoder set video input %d, audio input %d\n",
640 vid_input, aud_input);
641
642 if (vid_input >= CX25840_VIN1_CH1) {
643 v4l_dbg(1, cx25840_debug, client, "vid_input 0x%x\n",
644 vid_input);
645 reg = vid_input & 0xff;
646 if ((vid_input & CX25840_SVIDEO_ON) == CX25840_SVIDEO_ON)
647 is_composite = 0;
648 else
649 is_composite = 1;
650
651 v4l_dbg(1, cx25840_debug, client, "mux cfg 0x%x comp=%d\n",
652 reg, is_composite);
653 } else
654 if (is_composite) {
655 reg = 0xf0 + (vid_input - CX25840_COMPOSITE1);
656 } else {
657 int luma = vid_input & 0xf0;
658 int chroma = vid_input & 0xf00;
659
660 if ((vid_input & ~0xff0) ||
661 luma < CX25840_SVIDEO_LUMA1 || luma > CX25840_SVIDEO_LUMA8 ||
662 chroma < CX25840_SVIDEO_CHROMA4 || chroma > CX25840_SVIDEO_CHROMA8) {
663 v4l_err(client, "0x%04x is not a valid video input!\n",
664 vid_input);
665 return -EINVAL;
666 }
667 reg = 0xf0 + ((luma - CX25840_SVIDEO_LUMA1) >> 4);
668 if (chroma >= CX25840_SVIDEO_CHROMA7) {
669 reg &= 0x3f;
670 reg |= (chroma - CX25840_SVIDEO_CHROMA7) >> 2;
671 } else {
672 reg &= 0xcf;
673 reg |= (chroma - CX25840_SVIDEO_CHROMA4) >> 4;
674 }
675 }
676
677
678
679
680
681 if (!state->is_cx23885 && !state->is_cx231xx) {
682 switch (aud_input) {
683 case CX25840_AUDIO_SERIAL:
684
685 break;
686 case CX25840_AUDIO4: reg &= ~0x30; break;
687 case CX25840_AUDIO5: reg &= ~0x30; reg |= 0x10; break;
688 case CX25840_AUDIO6: reg &= ~0x30; reg |= 0x20; break;
689 case CX25840_AUDIO7: reg &= ~0xc0; break;
690 case CX25840_AUDIO8: reg &= ~0xc0; reg |= 0x40; break;
691
692 default:
693 v4l_err(client, "0x%04x is not a valid audio input!\n",
694 aud_input);
695 return -EINVAL;
696 }
697 }
698
699 cx25840_write(client, 0x103, reg);
700
701
702 cx25840_and_or(client, 0x401, ~0x6, is_composite ? 0 : 0x02);
703
704 if (!state->is_cx23885 && !state->is_cx231xx) {
705
706 cx25840_and_or(client, 0x102, ~0x2, (reg & 0x80) == 0 ? 2 : 0);
707
708 if ((reg & 0xc0) != 0xc0 && (reg & 0x30) != 0x30)
709 cx25840_and_or(client, 0x102, ~0x4, 4);
710 else
711 cx25840_and_or(client, 0x102, ~0x4, 0);
712 } else {
713 if (is_composite)
714
715 cx25840_and_or(client, 0x102, ~0x2, 0);
716 else
717
718 cx25840_and_or(client, 0x102, ~0x2, 2);
719 }
720
721 state->vid_input = vid_input;
722 state->aud_input = aud_input;
723 if (!state->is_cx25836) {
724 cx25840_audio_set_path(client);
725 input_change(client);
726 }
727
728 if (state->is_cx23885) {
729
730 cx25840_write(client, 0x124, 0x03);
731
732
733 cx25840_write(client, 0x144, 0x05);
734
735
736 cx25840_write(client, 0x914, 0xa0);
737
738
739
740
741
742 cx25840_write(client, 0x918, 0xa0);
743 cx25840_write(client, 0x919, 0x01);
744 } else if (state->is_cx231xx) {
745
746 cx25840_write(client, 0x124, 0x03);
747
748
749 cx25840_write(client, 0x914, 0xa0);
750
751
752
753
754
755 cx25840_write(client, 0x918, 0xa0);
756 cx25840_write(client, 0x919, 0x01);
757 }
758
759 return 0;
760}
761
762
763
764static int set_v4lstd(struct i2c_client *client)
765{
766 struct cx25840_state *state = to_state(i2c_get_clientdata(client));
767 u8 fmt = 0;
768 u8 pal_m = 0;
769
770
771 if (state->std == V4L2_STD_NTSC_M_JP) {
772 fmt = 0x2;
773 } else if (state->std == V4L2_STD_NTSC_443) {
774 fmt = 0x3;
775 } else if (state->std == V4L2_STD_PAL_M) {
776 pal_m = 1;
777 fmt = 0x5;
778 } else if (state->std == V4L2_STD_PAL_N) {
779 fmt = 0x6;
780 } else if (state->std == V4L2_STD_PAL_Nc) {
781 fmt = 0x7;
782 } else if (state->std == V4L2_STD_PAL_60) {
783 fmt = 0x8;
784 } else {
785
786 if (state->std & V4L2_STD_NTSC)
787 fmt = 0x1;
788 else if (state->std & V4L2_STD_PAL)
789 fmt = 0x4;
790 else if (state->std & V4L2_STD_SECAM)
791 fmt = 0xc;
792 }
793
794 v4l_dbg(1, cx25840_debug, client, "changing video std to fmt %i\n",fmt);
795
796
797
798
799 if (fmt >= 4 && fmt < 8) {
800
801 cx25840_and_or(client, 0x400, ~0xf, 1);
802
803 cx25840_and_or(client, 0x47b, ~6, 0);
804 }
805 cx25840_and_or(client, 0x400, ~0xf, fmt);
806 cx25840_and_or(client, 0x403, ~0x3, pal_m);
807 cx25840_std_setup(client);
808 if (!state->is_cx25836)
809 input_change(client);
810 return 0;
811}
812
813
814
815static int cx25840_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
816{
817 struct cx25840_state *state = to_state(sd);
818 struct i2c_client *client = v4l2_get_subdevdata(sd);
819
820 switch (ctrl->id) {
821 case CX25840_CID_ENABLE_PVR150_WORKAROUND:
822 state->pvr150_workaround = ctrl->value;
823 set_input(client, state->vid_input, state->aud_input);
824 break;
825
826 case V4L2_CID_BRIGHTNESS:
827 if (ctrl->value < 0 || ctrl->value > 255) {
828 v4l_err(client, "invalid brightness setting %d\n",
829 ctrl->value);
830 return -ERANGE;
831 }
832
833 cx25840_write(client, 0x414, ctrl->value - 128);
834 break;
835
836 case V4L2_CID_CONTRAST:
837 if (ctrl->value < 0 || ctrl->value > 127) {
838 v4l_err(client, "invalid contrast setting %d\n",
839 ctrl->value);
840 return -ERANGE;
841 }
842
843 cx25840_write(client, 0x415, ctrl->value << 1);
844 break;
845
846 case V4L2_CID_SATURATION:
847 if (ctrl->value < 0 || ctrl->value > 127) {
848 v4l_err(client, "invalid saturation setting %d\n",
849 ctrl->value);
850 return -ERANGE;
851 }
852
853 cx25840_write(client, 0x420, ctrl->value << 1);
854 cx25840_write(client, 0x421, ctrl->value << 1);
855 break;
856
857 case V4L2_CID_HUE:
858 if (ctrl->value < -128 || ctrl->value > 127) {
859 v4l_err(client, "invalid hue setting %d\n", ctrl->value);
860 return -ERANGE;
861 }
862
863 cx25840_write(client, 0x422, ctrl->value);
864 break;
865
866 case V4L2_CID_AUDIO_VOLUME:
867 case V4L2_CID_AUDIO_BASS:
868 case V4L2_CID_AUDIO_TREBLE:
869 case V4L2_CID_AUDIO_BALANCE:
870 case V4L2_CID_AUDIO_MUTE:
871 if (state->is_cx25836)
872 return -EINVAL;
873 return cx25840_audio_s_ctrl(sd, ctrl);
874
875 default:
876 return -EINVAL;
877 }
878
879 return 0;
880}
881
882static int cx25840_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
883{
884 struct cx25840_state *state = to_state(sd);
885 struct i2c_client *client = v4l2_get_subdevdata(sd);
886
887 switch (ctrl->id) {
888 case CX25840_CID_ENABLE_PVR150_WORKAROUND:
889 ctrl->value = state->pvr150_workaround;
890 break;
891 case V4L2_CID_BRIGHTNESS:
892 ctrl->value = (s8)cx25840_read(client, 0x414) + 128;
893 break;
894 case V4L2_CID_CONTRAST:
895 ctrl->value = cx25840_read(client, 0x415) >> 1;
896 break;
897 case V4L2_CID_SATURATION:
898 ctrl->value = cx25840_read(client, 0x420) >> 1;
899 break;
900 case V4L2_CID_HUE:
901 ctrl->value = (s8)cx25840_read(client, 0x422);
902 break;
903 case V4L2_CID_AUDIO_VOLUME:
904 case V4L2_CID_AUDIO_BASS:
905 case V4L2_CID_AUDIO_TREBLE:
906 case V4L2_CID_AUDIO_BALANCE:
907 case V4L2_CID_AUDIO_MUTE:
908 if (state->is_cx25836)
909 return -EINVAL;
910 return cx25840_audio_g_ctrl(sd, ctrl);
911 default:
912 return -EINVAL;
913 }
914
915 return 0;
916}
917
918
919
920static int cx25840_g_fmt(struct v4l2_subdev *sd, struct v4l2_format *fmt)
921{
922 switch (fmt->type) {
923 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
924 return cx25840_vbi_g_fmt(sd, fmt);
925 default:
926 return -EINVAL;
927 }
928 return 0;
929}
930
931static int cx25840_s_fmt(struct v4l2_subdev *sd, struct v4l2_format *fmt)
932{
933 struct cx25840_state *state = to_state(sd);
934 struct i2c_client *client = v4l2_get_subdevdata(sd);
935 struct v4l2_pix_format *pix;
936 int HSC, VSC, Vsrc, Hsrc, filter, Vlines;
937 int is_50Hz = !(state->std & V4L2_STD_525_60);
938
939 switch (fmt->type) {
940 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
941 pix = &(fmt->fmt.pix);
942
943 Vsrc = (cx25840_read(client, 0x476) & 0x3f) << 4;
944 Vsrc |= (cx25840_read(client, 0x475) & 0xf0) >> 4;
945
946 Hsrc = (cx25840_read(client, 0x472) & 0x3f) << 4;
947 Hsrc |= (cx25840_read(client, 0x471) & 0xf0) >> 4;
948
949 Vlines = pix->height + (is_50Hz ? 4 : 7);
950
951 if ((pix->width * 16 < Hsrc) || (Hsrc < pix->width) ||
952 (Vlines * 8 < Vsrc) || (Vsrc < Vlines)) {
953 v4l_err(client, "%dx%d is not a valid size!\n",
954 pix->width, pix->height);
955 return -ERANGE;
956 }
957
958 HSC = (Hsrc * (1 << 20)) / pix->width - (1 << 20);
959 VSC = (1 << 16) - (Vsrc * (1 << 9) / Vlines - (1 << 9));
960 VSC &= 0x1fff;
961
962 if (pix->width >= 385)
963 filter = 0;
964 else if (pix->width > 192)
965 filter = 1;
966 else if (pix->width > 96)
967 filter = 2;
968 else
969 filter = 3;
970
971 v4l_dbg(1, cx25840_debug, client, "decoder set size %dx%d -> scale %ux%u\n",
972 pix->width, pix->height, HSC, VSC);
973
974
975 cx25840_write(client, 0x418, HSC & 0xff);
976 cx25840_write(client, 0x419, (HSC >> 8) & 0xff);
977 cx25840_write(client, 0x41a, HSC >> 16);
978
979 cx25840_write(client, 0x41c, VSC & 0xff);
980 cx25840_write(client, 0x41d, VSC >> 8);
981
982 cx25840_write(client, 0x41e, 0x8 | filter);
983 break;
984
985 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
986 return cx25840_vbi_s_fmt(sd, fmt);
987
988 case V4L2_BUF_TYPE_VBI_CAPTURE:
989 return cx25840_vbi_s_fmt(sd, fmt);
990
991 default:
992 return -EINVAL;
993 }
994
995 return 0;
996}
997
998
999
1000static void log_video_status(struct i2c_client *client)
1001{
1002 static const char *const fmt_strs[] = {
1003 "0x0",
1004 "NTSC-M", "NTSC-J", "NTSC-4.43",
1005 "PAL-BDGHI", "PAL-M", "PAL-N", "PAL-Nc", "PAL-60",
1006 "0x9", "0xA", "0xB",
1007 "SECAM",
1008 "0xD", "0xE", "0xF"
1009 };
1010
1011 struct cx25840_state *state = to_state(i2c_get_clientdata(client));
1012 u8 vidfmt_sel = cx25840_read(client, 0x400) & 0xf;
1013 u8 gen_stat1 = cx25840_read(client, 0x40d);
1014 u8 gen_stat2 = cx25840_read(client, 0x40e);
1015 int vid_input = state->vid_input;
1016
1017 v4l_info(client, "Video signal: %spresent\n",
1018 (gen_stat2 & 0x20) ? "" : "not ");
1019 v4l_info(client, "Detected format: %s\n",
1020 fmt_strs[gen_stat1 & 0xf]);
1021
1022 v4l_info(client, "Specified standard: %s\n",
1023 vidfmt_sel ? fmt_strs[vidfmt_sel] : "automatic detection");
1024
1025 if (vid_input >= CX25840_COMPOSITE1 &&
1026 vid_input <= CX25840_COMPOSITE8) {
1027 v4l_info(client, "Specified video input: Composite %d\n",
1028 vid_input - CX25840_COMPOSITE1 + 1);
1029 } else {
1030 v4l_info(client, "Specified video input: S-Video (Luma In%d, Chroma In%d)\n",
1031 (vid_input & 0xf0) >> 4, (vid_input & 0xf00) >> 8);
1032 }
1033
1034 v4l_info(client, "Specified audioclock freq: %d Hz\n", state->audclk_freq);
1035}
1036
1037
1038
1039static void log_audio_status(struct i2c_client *client)
1040{
1041 struct cx25840_state *state = to_state(i2c_get_clientdata(client));
1042 u8 download_ctl = cx25840_read(client, 0x803);
1043 u8 mod_det_stat0 = cx25840_read(client, 0x804);
1044 u8 mod_det_stat1 = cx25840_read(client, 0x805);
1045 u8 audio_config = cx25840_read(client, 0x808);
1046 u8 pref_mode = cx25840_read(client, 0x809);
1047 u8 afc0 = cx25840_read(client, 0x80b);
1048 u8 mute_ctl = cx25840_read(client, 0x8d3);
1049 int aud_input = state->aud_input;
1050 char *p;
1051
1052 switch (mod_det_stat0) {
1053 case 0x00: p = "mono"; break;
1054 case 0x01: p = "stereo"; break;
1055 case 0x02: p = "dual"; break;
1056 case 0x04: p = "tri"; break;
1057 case 0x10: p = "mono with SAP"; break;
1058 case 0x11: p = "stereo with SAP"; break;
1059 case 0x12: p = "dual with SAP"; break;
1060 case 0x14: p = "tri with SAP"; break;
1061 case 0xfe: p = "forced mode"; break;
1062 default: p = "not defined";
1063 }
1064 v4l_info(client, "Detected audio mode: %s\n", p);
1065
1066 switch (mod_det_stat1) {
1067 case 0x00: p = "not defined"; break;
1068 case 0x01: p = "EIAJ"; break;
1069 case 0x02: p = "A2-M"; break;
1070 case 0x03: p = "A2-BG"; break;
1071 case 0x04: p = "A2-DK1"; break;
1072 case 0x05: p = "A2-DK2"; break;
1073 case 0x06: p = "A2-DK3"; break;
1074 case 0x07: p = "A1 (6.0 MHz FM Mono)"; break;
1075 case 0x08: p = "AM-L"; break;
1076 case 0x09: p = "NICAM-BG"; break;
1077 case 0x0a: p = "NICAM-DK"; break;
1078 case 0x0b: p = "NICAM-I"; break;
1079 case 0x0c: p = "NICAM-L"; break;
1080 case 0x0d: p = "BTSC/EIAJ/A2-M Mono (4.5 MHz FMMono)"; break;
1081 case 0x0e: p = "IF FM Radio"; break;
1082 case 0x0f: p = "BTSC"; break;
1083 case 0x10: p = "high-deviation FM"; break;
1084 case 0x11: p = "very high-deviation FM"; break;
1085 case 0xfd: p = "unknown audio standard"; break;
1086 case 0xfe: p = "forced audio standard"; break;
1087 case 0xff: p = "no detected audio standard"; break;
1088 default: p = "not defined";
1089 }
1090 v4l_info(client, "Detected audio standard: %s\n", p);
1091 v4l_info(client, "Audio muted: %s\n",
1092 (state->unmute_volume >= 0) ? "yes" : "no");
1093 v4l_info(client, "Audio microcontroller: %s\n",
1094 (download_ctl & 0x10) ?
1095 ((mute_ctl & 0x2) ? "detecting" : "running") : "stopped");
1096
1097 switch (audio_config >> 4) {
1098 case 0x00: p = "undefined"; break;
1099 case 0x01: p = "BTSC"; break;
1100 case 0x02: p = "EIAJ"; break;
1101 case 0x03: p = "A2-M"; break;
1102 case 0x04: p = "A2-BG"; break;
1103 case 0x05: p = "A2-DK1"; break;
1104 case 0x06: p = "A2-DK2"; break;
1105 case 0x07: p = "A2-DK3"; break;
1106 case 0x08: p = "A1 (6.0 MHz FM Mono)"; break;
1107 case 0x09: p = "AM-L"; break;
1108 case 0x0a: p = "NICAM-BG"; break;
1109 case 0x0b: p = "NICAM-DK"; break;
1110 case 0x0c: p = "NICAM-I"; break;
1111 case 0x0d: p = "NICAM-L"; break;
1112 case 0x0e: p = "FM radio"; break;
1113 case 0x0f: p = "automatic detection"; break;
1114 default: p = "undefined";
1115 }
1116 v4l_info(client, "Configured audio standard: %s\n", p);
1117
1118 if ((audio_config >> 4) < 0xF) {
1119 switch (audio_config & 0xF) {
1120 case 0x00: p = "MONO1 (LANGUAGE A/Mono L+R channel for BTSC, EIAJ, A2)"; break;
1121 case 0x01: p = "MONO2 (LANGUAGE B)"; break;
1122 case 0x02: p = "MONO3 (STEREO forced MONO)"; break;
1123 case 0x03: p = "MONO4 (NICAM ANALOG-Language C/Analog Fallback)"; break;
1124 case 0x04: p = "STEREO"; break;
1125 case 0x05: p = "DUAL1 (AB)"; break;
1126 case 0x06: p = "DUAL2 (AC) (FM)"; break;
1127 case 0x07: p = "DUAL3 (BC) (FM)"; break;
1128 case 0x08: p = "DUAL4 (AC) (AM)"; break;
1129 case 0x09: p = "DUAL5 (BC) (AM)"; break;
1130 case 0x0a: p = "SAP"; break;
1131 default: p = "undefined";
1132 }
1133 v4l_info(client, "Configured audio mode: %s\n", p);
1134 } else {
1135 switch (audio_config & 0xF) {
1136 case 0x00: p = "BG"; break;
1137 case 0x01: p = "DK1"; break;
1138 case 0x02: p = "DK2"; break;
1139 case 0x03: p = "DK3"; break;
1140 case 0x04: p = "I"; break;
1141 case 0x05: p = "L"; break;
1142 case 0x06: p = "BTSC"; break;
1143 case 0x07: p = "EIAJ"; break;
1144 case 0x08: p = "A2-M"; break;
1145 case 0x09: p = "FM Radio"; break;
1146 case 0x0f: p = "automatic standard and mode detection"; break;
1147 default: p = "undefined";
1148 }
1149 v4l_info(client, "Configured audio system: %s\n", p);
1150 }
1151
1152 if (aud_input) {
1153 v4l_info(client, "Specified audio input: Tuner (In%d)\n", aud_input);
1154 } else {
1155 v4l_info(client, "Specified audio input: External\n");
1156 }
1157
1158 switch (pref_mode & 0xf) {
1159 case 0: p = "mono/language A"; break;
1160 case 1: p = "language B"; break;
1161 case 2: p = "language C"; break;
1162 case 3: p = "analog fallback"; break;
1163 case 4: p = "stereo"; break;
1164 case 5: p = "language AC"; break;
1165 case 6: p = "language BC"; break;
1166 case 7: p = "language AB"; break;
1167 default: p = "undefined";
1168 }
1169 v4l_info(client, "Preferred audio mode: %s\n", p);
1170
1171 if ((audio_config & 0xf) == 0xf) {
1172 switch ((afc0 >> 3) & 0x3) {
1173 case 0: p = "system DK"; break;
1174 case 1: p = "system L"; break;
1175 case 2: p = "autodetect"; break;
1176 default: p = "undefined";
1177 }
1178 v4l_info(client, "Selected 65 MHz format: %s\n", p);
1179
1180 switch (afc0 & 0x7) {
1181 case 0: p = "chroma"; break;
1182 case 1: p = "BTSC"; break;
1183 case 2: p = "EIAJ"; break;
1184 case 3: p = "A2-M"; break;
1185 case 4: p = "autodetect"; break;
1186 default: p = "undefined";
1187 }
1188 v4l_info(client, "Selected 45 MHz format: %s\n", p);
1189 }
1190}
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204static int cx25840_load_fw(struct v4l2_subdev *sd)
1205{
1206 struct cx25840_state *state = to_state(sd);
1207 struct i2c_client *client = v4l2_get_subdevdata(sd);
1208
1209 if (!state->is_initialized) {
1210
1211 state->is_initialized = 1;
1212 if (state->is_cx25836)
1213 cx25836_initialize(client);
1214 else if (state->is_cx23885)
1215 cx23885_initialize(client);
1216 else if (state->is_cx231xx)
1217 cx231xx_initialize(client);
1218 else
1219 cx25840_initialize(client);
1220 }
1221 return 0;
1222}
1223
1224#ifdef CONFIG_VIDEO_ADV_DEBUG
1225static int cx25840_g_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
1226{
1227 struct i2c_client *client = v4l2_get_subdevdata(sd);
1228
1229 if (!v4l2_chip_match_i2c_client(client, ®->match))
1230 return -EINVAL;
1231 if (!capable(CAP_SYS_ADMIN))
1232 return -EPERM;
1233 reg->size = 1;
1234 reg->val = cx25840_read(client, reg->reg & 0x0fff);
1235 return 0;
1236}
1237
1238static int cx25840_s_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
1239{
1240 struct i2c_client *client = v4l2_get_subdevdata(sd);
1241
1242 if (!v4l2_chip_match_i2c_client(client, ®->match))
1243 return -EINVAL;
1244 if (!capable(CAP_SYS_ADMIN))
1245 return -EPERM;
1246 cx25840_write(client, reg->reg & 0x0fff, reg->val & 0xff);
1247 return 0;
1248}
1249#endif
1250
1251static int cx25840_s_stream(struct v4l2_subdev *sd, int enable)
1252{
1253 struct cx25840_state *state = to_state(sd);
1254 struct i2c_client *client = v4l2_get_subdevdata(sd);
1255
1256 v4l_dbg(1, cx25840_debug, client, "%s output\n",
1257 enable ? "enable" : "disable");
1258 if (enable) {
1259 if (state->is_cx23885 || state->is_cx231xx) {
1260 u8 v = (cx25840_read(client, 0x421) | 0x0b);
1261 cx25840_write(client, 0x421, v);
1262 } else {
1263 cx25840_write(client, 0x115,
1264 state->is_cx25836 ? 0x0c : 0x8c);
1265 cx25840_write(client, 0x116,
1266 state->is_cx25836 ? 0x04 : 0x07);
1267 }
1268 } else {
1269 if (state->is_cx23885 || state->is_cx231xx) {
1270 u8 v = cx25840_read(client, 0x421) & ~(0x0b);
1271 cx25840_write(client, 0x421, v);
1272 } else {
1273 cx25840_write(client, 0x115, 0x00);
1274 cx25840_write(client, 0x116, 0x00);
1275 }
1276 }
1277 return 0;
1278}
1279
1280static int cx25840_queryctrl(struct v4l2_subdev *sd, struct v4l2_queryctrl *qc)
1281{
1282 struct cx25840_state *state = to_state(sd);
1283
1284 switch (qc->id) {
1285 case V4L2_CID_BRIGHTNESS:
1286 return v4l2_ctrl_query_fill(qc, 0, 255, 1, 128);
1287 case V4L2_CID_CONTRAST:
1288 case V4L2_CID_SATURATION:
1289 return v4l2_ctrl_query_fill(qc, 0, 127, 1, 64);
1290 case V4L2_CID_HUE:
1291 return v4l2_ctrl_query_fill(qc, -128, 127, 1, 0);
1292 default:
1293 break;
1294 }
1295 if (state->is_cx25836)
1296 return -EINVAL;
1297
1298 switch (qc->id) {
1299 case V4L2_CID_AUDIO_VOLUME:
1300 return v4l2_ctrl_query_fill(qc, 0, 65535,
1301 65535 / 100, state->default_volume);
1302 case V4L2_CID_AUDIO_MUTE:
1303 return v4l2_ctrl_query_fill(qc, 0, 1, 1, 0);
1304 case V4L2_CID_AUDIO_BALANCE:
1305 case V4L2_CID_AUDIO_BASS:
1306 case V4L2_CID_AUDIO_TREBLE:
1307 return v4l2_ctrl_query_fill(qc, 0, 65535, 65535 / 100, 32768);
1308 default:
1309 return -EINVAL;
1310 }
1311 return -EINVAL;
1312}
1313
1314static int cx25840_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
1315{
1316 struct cx25840_state *state = to_state(sd);
1317 struct i2c_client *client = v4l2_get_subdevdata(sd);
1318
1319 if (state->radio == 0 && state->std == std)
1320 return 0;
1321 state->radio = 0;
1322 state->std = std;
1323 return set_v4lstd(client);
1324}
1325
1326static int cx25840_s_radio(struct v4l2_subdev *sd)
1327{
1328 struct cx25840_state *state = to_state(sd);
1329
1330 state->radio = 1;
1331 return 0;
1332}
1333
1334static int cx25840_s_video_routing(struct v4l2_subdev *sd,
1335 u32 input, u32 output, u32 config)
1336{
1337 struct cx25840_state *state = to_state(sd);
1338 struct i2c_client *client = v4l2_get_subdevdata(sd);
1339
1340 return set_input(client, input, state->aud_input);
1341}
1342
1343static int cx25840_s_audio_routing(struct v4l2_subdev *sd,
1344 u32 input, u32 output, u32 config)
1345{
1346 struct cx25840_state *state = to_state(sd);
1347 struct i2c_client *client = v4l2_get_subdevdata(sd);
1348
1349 if (state->is_cx25836)
1350 return -EINVAL;
1351 return set_input(client, state->vid_input, input);
1352}
1353
1354static int cx25840_s_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *freq)
1355{
1356 struct cx25840_state *state = to_state(sd);
1357 struct i2c_client *client = v4l2_get_subdevdata(sd);
1358
1359 if (!state->is_cx25836)
1360 input_change(client);
1361 return 0;
1362}
1363
1364static int cx25840_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1365{
1366 struct cx25840_state *state = to_state(sd);
1367 struct i2c_client *client = v4l2_get_subdevdata(sd);
1368 u8 vpres = cx25840_read(client, 0x40e) & 0x20;
1369 u8 mode;
1370 int val = 0;
1371
1372 if (state->radio)
1373 return 0;
1374
1375 vt->signal = vpres ? 0xffff : 0x0;
1376 if (state->is_cx25836)
1377 return 0;
1378
1379 vt->capability |=
1380 V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_LANG1 |
1381 V4L2_TUNER_CAP_LANG2 | V4L2_TUNER_CAP_SAP;
1382
1383 mode = cx25840_read(client, 0x804);
1384
1385
1386 if ((mode & 0xf) == 1)
1387 val |= V4L2_TUNER_SUB_STEREO;
1388 else
1389 val |= V4L2_TUNER_SUB_MONO;
1390
1391 if (mode == 2 || mode == 4)
1392 val = V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_LANG2;
1393
1394 if (mode & 0x10)
1395 val |= V4L2_TUNER_SUB_SAP;
1396
1397 vt->rxsubchans = val;
1398 vt->audmode = state->audmode;
1399 return 0;
1400}
1401
1402static int cx25840_s_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1403{
1404 struct cx25840_state *state = to_state(sd);
1405 struct i2c_client *client = v4l2_get_subdevdata(sd);
1406
1407 if (state->radio || state->is_cx25836)
1408 return 0;
1409
1410 switch (vt->audmode) {
1411 case V4L2_TUNER_MODE_MONO:
1412
1413
1414
1415 cx25840_and_or(client, 0x809, ~0xf, 0x00);
1416 break;
1417 case V4L2_TUNER_MODE_STEREO:
1418 case V4L2_TUNER_MODE_LANG1:
1419
1420
1421
1422 cx25840_and_or(client, 0x809, ~0xf, 0x04);
1423 break;
1424 case V4L2_TUNER_MODE_LANG1_LANG2:
1425
1426
1427
1428 cx25840_and_or(client, 0x809, ~0xf, 0x07);
1429 break;
1430 case V4L2_TUNER_MODE_LANG2:
1431
1432
1433
1434 cx25840_and_or(client, 0x809, ~0xf, 0x01);
1435 break;
1436 default:
1437 return -EINVAL;
1438 }
1439 state->audmode = vt->audmode;
1440 return 0;
1441}
1442
1443static int cx25840_reset(struct v4l2_subdev *sd, u32 val)
1444{
1445 struct cx25840_state *state = to_state(sd);
1446 struct i2c_client *client = v4l2_get_subdevdata(sd);
1447
1448 if (state->is_cx25836)
1449 cx25836_initialize(client);
1450 else if (state->is_cx23885)
1451 cx23885_initialize(client);
1452 else if (state->is_cx231xx)
1453 cx231xx_initialize(client);
1454 else
1455 cx25840_initialize(client);
1456 return 0;
1457}
1458
1459static int cx25840_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip)
1460{
1461 struct cx25840_state *state = to_state(sd);
1462 struct i2c_client *client = v4l2_get_subdevdata(sd);
1463
1464 return v4l2_chip_ident_i2c_client(client, chip, state->id, state->rev);
1465}
1466
1467static int cx25840_log_status(struct v4l2_subdev *sd)
1468{
1469 struct cx25840_state *state = to_state(sd);
1470 struct i2c_client *client = v4l2_get_subdevdata(sd);
1471
1472 log_video_status(client);
1473 if (!state->is_cx25836)
1474 log_audio_status(client);
1475 return 0;
1476}
1477
1478
1479
1480static const struct v4l2_subdev_core_ops cx25840_core_ops = {
1481 .log_status = cx25840_log_status,
1482 .g_chip_ident = cx25840_g_chip_ident,
1483 .g_ctrl = cx25840_g_ctrl,
1484 .s_ctrl = cx25840_s_ctrl,
1485 .queryctrl = cx25840_queryctrl,
1486 .s_std = cx25840_s_std,
1487 .reset = cx25840_reset,
1488 .load_fw = cx25840_load_fw,
1489#ifdef CONFIG_VIDEO_ADV_DEBUG
1490 .g_register = cx25840_g_register,
1491 .s_register = cx25840_s_register,
1492#endif
1493};
1494
1495static const struct v4l2_subdev_tuner_ops cx25840_tuner_ops = {
1496 .s_frequency = cx25840_s_frequency,
1497 .s_radio = cx25840_s_radio,
1498 .g_tuner = cx25840_g_tuner,
1499 .s_tuner = cx25840_s_tuner,
1500};
1501
1502static const struct v4l2_subdev_audio_ops cx25840_audio_ops = {
1503 .s_clock_freq = cx25840_s_clock_freq,
1504 .s_routing = cx25840_s_audio_routing,
1505};
1506
1507static const struct v4l2_subdev_video_ops cx25840_video_ops = {
1508 .s_routing = cx25840_s_video_routing,
1509 .g_fmt = cx25840_g_fmt,
1510 .s_fmt = cx25840_s_fmt,
1511 .decode_vbi_line = cx25840_decode_vbi_line,
1512 .s_stream = cx25840_s_stream,
1513};
1514
1515static const struct v4l2_subdev_ops cx25840_ops = {
1516 .core = &cx25840_core_ops,
1517 .tuner = &cx25840_tuner_ops,
1518 .audio = &cx25840_audio_ops,
1519 .video = &cx25840_video_ops,
1520};
1521
1522
1523
1524static int cx25840_probe(struct i2c_client *client,
1525 const struct i2c_device_id *did)
1526{
1527 struct cx25840_state *state;
1528 struct v4l2_subdev *sd;
1529 u32 id;
1530 u16 device_id;
1531
1532
1533 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1534 return -EIO;
1535
1536 v4l_dbg(1, cx25840_debug, client, "detecting cx25840 client on address 0x%x\n", client->addr << 1);
1537
1538 device_id = cx25840_read(client, 0x101) << 8;
1539 device_id |= cx25840_read(client, 0x100);
1540 v4l_dbg(1, cx25840_debug, client, "device_id = 0x%04x\n", device_id);
1541
1542
1543
1544 if ((device_id & 0xff00) == 0x8300) {
1545 id = V4L2_IDENT_CX25836 + ((device_id >> 4) & 0xf) - 6;
1546 }
1547 else if ((device_id & 0xff00) == 0x8400) {
1548 id = V4L2_IDENT_CX25840 + ((device_id >> 4) & 0xf);
1549 } else if (device_id == 0x0000) {
1550 id = V4L2_IDENT_CX25836 + ((device_id >> 4) & 0xf) - 6;
1551 } else if (device_id == 0x1313) {
1552 id = V4L2_IDENT_CX25836 + ((device_id >> 4) & 0xf) - 6;
1553 } else if ((device_id & 0xfff0) == 0x5A30) {
1554 id = V4L2_IDENT_CX25840 + ((device_id >> 4) & 0xf);
1555 }
1556 else {
1557 v4l_dbg(1, cx25840_debug, client, "cx25840 not found\n");
1558 return -ENODEV;
1559 }
1560
1561 state = kzalloc(sizeof(struct cx25840_state), GFP_KERNEL);
1562 if (state == NULL)
1563 return -ENOMEM;
1564
1565 sd = &state->sd;
1566 v4l2_i2c_subdev_init(sd, client, &cx25840_ops);
1567
1568
1569 v4l_info(client, "cx25%3x-2%x found @ 0x%x (%s)\n",
1570 (device_id & 0xfff0) >> 4,
1571 (device_id & 0x0f) < 3 ? (device_id & 0x0f) + 1 : (device_id & 0x0f),
1572 client->addr << 1, client->adapter->name);
1573
1574 state->c = client;
1575 state->is_cx25836 = ((device_id & 0xff00) == 0x8300);
1576 state->is_cx23885 = (device_id == 0x0000) || (device_id == 0x1313);
1577 state->is_cx231xx = (device_id == 0x5a3e);
1578 state->vid_input = CX25840_COMPOSITE7;
1579 state->aud_input = CX25840_AUDIO8;
1580 state->audclk_freq = 48000;
1581 state->pvr150_workaround = 0;
1582 state->audmode = V4L2_TUNER_MODE_LANG1;
1583 state->unmute_volume = -1;
1584 state->default_volume = 228 - cx25840_read(client, 0x8d4);
1585 state->default_volume = ((state->default_volume / 2) + 23) << 9;
1586 state->vbi_line_offset = 8;
1587 state->id = id;
1588 state->rev = device_id;
1589
1590 return 0;
1591}
1592
1593static int cx25840_remove(struct i2c_client *client)
1594{
1595 struct v4l2_subdev *sd = i2c_get_clientdata(client);
1596
1597 v4l2_device_unregister_subdev(sd);
1598 kfree(to_state(sd));
1599 return 0;
1600}
1601
1602static const struct i2c_device_id cx25840_id[] = {
1603 { "cx25840", 0 },
1604 { }
1605};
1606MODULE_DEVICE_TABLE(i2c, cx25840_id);
1607
1608static struct v4l2_i2c_driver_data v4l2_i2c_data = {
1609 .name = "cx25840",
1610 .probe = cx25840_probe,
1611 .remove = cx25840_remove,
1612 .id_table = cx25840_id,
1613};
1614