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#include <linux/module.h>
30#include <linux/kernel.h>
31#include <linux/slab.h>
32#include <linux/sched.h>
33
34#include <linux/videodev2.h>
35#include <linux/i2c.h>
36#include <media/v4l2-device.h>
37#include <media/v4l2-ctrls.h>
38
39MODULE_DESCRIPTION("Philips SAA717x audio/video decoder driver");
40MODULE_AUTHOR("K. Ohta, T. Adachi, Hans Verkuil");
41MODULE_LICENSE("GPL");
42
43static int debug;
44module_param(debug, int, 0644);
45MODULE_PARM_DESC(debug, "Debug level (0-1)");
46
47
48
49
50
51
52struct saa717x_state {
53 struct v4l2_subdev sd;
54 struct v4l2_ctrl_handler hdl;
55 v4l2_std_id std;
56 int input;
57 int enable;
58 int radio;
59 int playback;
60 int audio;
61 int tuner_audio_mode;
62 int audio_main_mute;
63 int audio_main_vol_r;
64 int audio_main_vol_l;
65 u16 audio_main_bass;
66 u16 audio_main_treble;
67 u16 audio_main_volume;
68 u16 audio_main_balance;
69 int audio_input;
70};
71
72static inline struct saa717x_state *to_state(struct v4l2_subdev *sd)
73{
74 return container_of(sd, struct saa717x_state, sd);
75}
76
77static inline struct v4l2_subdev *to_sd(struct v4l2_ctrl *ctrl)
78{
79 return &container_of(ctrl->handler, struct saa717x_state, hdl)->sd;
80}
81
82
83
84
85#define TUNER_AUDIO_MONO 0
86#define TUNER_AUDIO_STEREO 1
87#define TUNER_AUDIO_LANG1 2
88#define TUNER_AUDIO_LANG2 3
89
90#define SAA717X_NTSC_WIDTH (704)
91#define SAA717X_NTSC_HEIGHT (480)
92
93
94
95static int saa717x_write(struct v4l2_subdev *sd, u32 reg, u32 value)
96{
97 struct i2c_client *client = v4l2_get_subdevdata(sd);
98 struct i2c_adapter *adap = client->adapter;
99 int fw_addr = reg == 0x454 || (reg >= 0x464 && reg <= 0x478) || reg == 0x480 || reg == 0x488;
100 unsigned char mm1[6];
101 struct i2c_msg msg;
102
103 msg.flags = 0;
104 msg.addr = client->addr;
105 mm1[0] = (reg >> 8) & 0xff;
106 mm1[1] = reg & 0xff;
107
108 if (fw_addr) {
109 mm1[4] = (value >> 16) & 0xff;
110 mm1[3] = (value >> 8) & 0xff;
111 mm1[2] = value & 0xff;
112 } else {
113 mm1[2] = value & 0xff;
114 }
115 msg.len = fw_addr ? 5 : 3;
116 msg.buf = mm1;
117 v4l2_dbg(2, debug, sd, "wrote: reg 0x%03x=%08x\n", reg, value);
118 return i2c_transfer(adap, &msg, 1) == 1;
119}
120
121static void saa717x_write_regs(struct v4l2_subdev *sd, u32 *data)
122{
123 while (data[0] || data[1]) {
124 saa717x_write(sd, data[0], data[1]);
125 data += 2;
126 }
127}
128
129static u32 saa717x_read(struct v4l2_subdev *sd, u32 reg)
130{
131 struct i2c_client *client = v4l2_get_subdevdata(sd);
132 struct i2c_adapter *adap = client->adapter;
133 int fw_addr = (reg >= 0x404 && reg <= 0x4b8) || reg == 0x528;
134 unsigned char mm1[2];
135 unsigned char mm2[4] = { 0, 0, 0, 0 };
136 struct i2c_msg msgs[2];
137 u32 value;
138
139 msgs[0].flags = 0;
140 msgs[1].flags = I2C_M_RD;
141 msgs[0].addr = msgs[1].addr = client->addr;
142 mm1[0] = (reg >> 8) & 0xff;
143 mm1[1] = reg & 0xff;
144 msgs[0].len = 2;
145 msgs[0].buf = mm1;
146 msgs[1].len = fw_addr ? 3 : 1;
147 msgs[1].buf = mm2;
148 i2c_transfer(adap, msgs, 2);
149
150 if (fw_addr)
151 value = (mm2[2] << 16) | (mm2[1] << 8) | mm2[0];
152 else
153 value = mm2[0];
154
155 v4l2_dbg(2, debug, sd, "read: reg 0x%03x=0x%08x\n", reg, value);
156 return value;
157}
158
159
160
161static u32 reg_init_initialize[] =
162{
163
164 0x101, 0x008,
165
166 0x103, 0x000,
167 0x104, 0x090,
168 0x105, 0x090,
169 0x106, 0x0eb,
170 0x107, 0x0e0,
171 0x109, 0x055,
172
173 0x10f, 0x02a,
174 0x110, 0x000,
175
176 0x114, 0x045,
177
178 0x118, 0x040,
179 0x119, 0x080,
180
181 0x044, 0x000,
182 0x045, 0x000,
183 0x046, 0x0cf,
184 0x047, 0x002,
185
186 0x049, 0x000,
187
188 0x04c, 0x0d0,
189 0x04d, 0x002,
190
191 0x064, 0x080,
192 0x065, 0x040,
193 0x066, 0x040,
194
195 0x068, 0x000,
196 0x069, 0x004,
197 0x06a, 0x000,
198
199 0x06e, 0x000,
200 0x06f, 0x000,
201
202 0x072, 0x000,
203
204 0x084, 0x000,
205 0x085, 0x000,
206 0x086, 0x0cf,
207 0x087, 0x002,
208
209 0x089, 0x000,
210
211 0x08c, 0x0d0,
212 0x08d, 0x002,
213
214 0x0a4, 0x080,
215 0x0a5, 0x040,
216 0x0a6, 0x040,
217
218 0x0a8, 0x000,
219 0x0a9, 0x004,
220 0x0aa, 0x000,
221
222 0x0ae, 0x000,
223 0x0af, 0x000,
224
225 0x0b2, 0x000,
226
227 0x00c, 0x000,
228 0x00d, 0x000,
229 0x00e, 0x000,
230
231 0x010, 0x010,
232 0x011, 0x020,
233 0x012, 0x030,
234 0x013, 0x040,
235 0x014, 0x050,
236 0x015, 0x060,
237 0x016, 0x070,
238 0x017, 0x080,
239 0x018, 0x090,
240 0x019, 0x0a0,
241 0x01a, 0x0b0,
242 0x01b, 0x0c0,
243 0x01c, 0x0d0,
244 0x01d, 0x0e0,
245 0x01e, 0x0f0,
246 0x01f, 0x0ff,
247
248 0x020, 0x010,
249 0x021, 0x020,
250 0x022, 0x030,
251 0x023, 0x040,
252 0x024, 0x050,
253 0x025, 0x060,
254 0x026, 0x070,
255 0x027, 0x080,
256 0x028, 0x090,
257 0x029, 0x0a0,
258 0x02a, 0x0b0,
259 0x02b, 0x0c0,
260 0x02c, 0x0d0,
261 0x02d, 0x0e0,
262 0x02e, 0x0f0,
263 0x02f, 0x0ff,
264
265 0x030, 0x010,
266 0x031, 0x020,
267 0x032, 0x030,
268 0x033, 0x040,
269 0x034, 0x050,
270 0x035, 0x060,
271 0x036, 0x070,
272 0x037, 0x080,
273 0x038, 0x090,
274 0x039, 0x0a0,
275 0x03a, 0x0b0,
276 0x03b, 0x0c0,
277 0x03c, 0x0d0,
278 0x03d, 0x0e0,
279 0x03e, 0x0f0,
280 0x03f, 0x0ff,
281
282 0x109, 0x085,
283
284
285 0x584, 0x000,
286 0x585, 0x000,
287 0x586, 0x003,
288 0x588, 0x0ff,
289 0x589, 0x00f,
290 0x58a, 0x000,
291 0x58b, 0x000,
292 0x58c, 0x010,
293 0x58d, 0x032,
294 0x58e, 0x054,
295 0x58f, 0x023,
296 0x590, 0x000,
297
298 0x595, 0x000,
299 0x596, 0x000,
300 0x597, 0x000,
301
302 0x464, 0x00,
303
304 0x46c, 0xbbbb10,
305 0x470, 0x101010,
306
307 0x478, 0x00,
308
309 0x474, 0x18,
310
311 0x454, 0x0425b9,
312 0x454, 0x042539,
313
314
315
316 0x042, 0x003,
317
318 0x082, 0x003,
319
320 0x108, 0x0f8,
321 0x2a9, 0x0fd,
322 0x102, 0x089,
323 0x111, 0x000,
324
325 0x10e, 0x00a,
326
327 0x594, 0x002,
328
329 0x454, 0x0425b9,
330 0x454, 0x042539,
331
332 0x111, 0x000,
333 0x10e, 0x00a,
334 0x464, 0x000,
335 0x300, 0x000,
336 0x301, 0x006,
337 0x302, 0x000,
338 0x303, 0x006,
339 0x308, 0x040,
340 0x309, 0x000,
341 0x30a, 0x000,
342 0x30b, 0x000,
343 0x000, 0x002,
344 0x001, 0x000,
345 0x002, 0x000,
346 0x003, 0x000,
347 0x004, 0x033,
348 0x040, 0x01d,
349 0x041, 0x001,
350 0x042, 0x004,
351 0x043, 0x000,
352 0x080, 0x01e,
353 0x081, 0x001,
354 0x082, 0x004,
355 0x083, 0x000,
356 0x190, 0x018,
357 0x115, 0x000,
358 0x116, 0x012,
359 0x117, 0x018,
360 0x04a, 0x011,
361 0x08a, 0x011,
362 0x04b, 0x000,
363 0x08b, 0x000,
364 0x048, 0x000,
365 0x088, 0x000,
366 0x04e, 0x012,
367 0x08e, 0x012,
368 0x058, 0x012,
369 0x098, 0x012,
370 0x059, 0x000,
371 0x099, 0x000,
372 0x05a, 0x003,
373 0x09a, 0x003,
374 0x05b, 0x001,
375 0x09b, 0x001,
376 0x054, 0x008,
377 0x094, 0x008,
378 0x055, 0x000,
379 0x095, 0x000,
380 0x056, 0x0c7,
381 0x096, 0x0c7,
382 0x057, 0x002,
383 0x097, 0x002,
384 0x0ff, 0x0ff,
385 0x060, 0x001,
386 0x0a0, 0x001,
387 0x061, 0x000,
388 0x0a1, 0x000,
389 0x062, 0x000,
390 0x0a2, 0x000,
391 0x063, 0x000,
392 0x0a3, 0x000,
393 0x070, 0x000,
394 0x0b0, 0x000,
395 0x071, 0x004,
396 0x0b1, 0x004,
397 0x06c, 0x0e9,
398 0x0ac, 0x0e9,
399 0x06d, 0x003,
400 0x0ad, 0x003,
401 0x05c, 0x0d0,
402 0x09c, 0x0d0,
403 0x05d, 0x002,
404 0x09d, 0x002,
405 0x05e, 0x0f2,
406 0x09e, 0x0f2,
407 0x05f, 0x000,
408 0x09f, 0x000,
409 0x074, 0x000,
410 0x0b4, 0x000,
411 0x075, 0x000,
412 0x0b5, 0x000,
413 0x076, 0x000,
414 0x0b6, 0x000,
415 0x077, 0x000,
416 0x0b7, 0x000,
417 0x195, 0x008,
418 0x0ff, 0x0ff,
419 0x108, 0x0f8,
420 0x111, 0x000,
421 0x10e, 0x00a,
422 0x2a9, 0x0fd,
423 0x464, 0x001,
424 0x454, 0x042135,
425 0x598, 0x0e7,
426 0x599, 0x07d,
427 0x59a, 0x018,
428 0x59c, 0x066,
429 0x59d, 0x090,
430 0x59e, 0x001,
431 0x584, 0x000,
432 0x585, 0x000,
433 0x586, 0x003,
434 0x588, 0x0ff,
435 0x589, 0x00f,
436 0x58a, 0x000,
437 0x58b, 0x000,
438 0x58c, 0x010,
439 0x58d, 0x032,
440 0x58e, 0x054,
441 0x58f, 0x023,
442 0x590, 0x000,
443 0x595, 0x000,
444 0x596, 0x000,
445 0x597, 0x000,
446 0x464, 0x000,
447 0x46c, 0xbbbb10,
448 0x470, 0x101010,
449
450
451 0x478, 0x000,
452 0x474, 0x018,
453 0x454, 0x042135,
454 0x598, 0x0e7,
455 0x599, 0x07d,
456 0x59a, 0x018,
457 0x59c, 0x066,
458 0x59d, 0x090,
459 0x59e, 0x001,
460 0x584, 0x000,
461 0x585, 0x000,
462 0x586, 0x003,
463 0x588, 0x0ff,
464 0x589, 0x00f,
465 0x58a, 0x000,
466 0x58b, 0x000,
467 0x58c, 0x010,
468 0x58d, 0x032,
469 0x58e, 0x054,
470 0x58f, 0x023,
471 0x590, 0x000,
472 0x595, 0x000,
473 0x596, 0x000,
474 0x597, 0x000,
475 0x464, 0x000,
476 0x46c, 0xbbbb10,
477 0x470, 0x101010,
478
479 0x478, 0x000,
480 0x474, 0x018,
481 0x454, 0x042135,
482 0x598, 0x0e7,
483 0x599, 0x07d,
484 0x59a, 0x018,
485 0x59c, 0x066,
486 0x59d, 0x090,
487 0x59e, 0x001,
488 0x584, 0x000,
489 0x585, 0x000,
490 0x586, 0x003,
491 0x588, 0x0ff,
492 0x589, 0x00f,
493 0x58a, 0x000,
494 0x58b, 0x000,
495 0x58c, 0x010,
496 0x58d, 0x032,
497 0x58e, 0x054,
498 0x58f, 0x023,
499 0x590, 0x000,
500 0x595, 0x000,
501 0x596, 0x000,
502 0x597, 0x000,
503 0x464, 0x000,
504 0x46c, 0xbbbb10,
505 0x470, 0x101010,
506 0x478, 0x000,
507 0x474, 0x018,
508 0x454, 0x042135,
509 0x193, 0x000,
510 0x300, 0x000,
511 0x301, 0x006,
512 0x302, 0x000,
513 0x303, 0x006,
514 0x308, 0x040,
515 0x309, 0x000,
516 0x30a, 0x000,
517 0x30b, 0x000,
518 0x000, 0x002,
519 0x001, 0x000,
520 0x002, 0x000,
521 0x003, 0x000,
522 0x004, 0x033,
523 0x040, 0x01d,
524 0x041, 0x001,
525 0x042, 0x004,
526 0x043, 0x000,
527 0x080, 0x01e,
528 0x081, 0x001,
529 0x082, 0x004,
530 0x083, 0x000,
531 0x190, 0x018,
532 0x115, 0x000,
533 0x116, 0x012,
534 0x117, 0x018,
535 0x04a, 0x011,
536 0x08a, 0x011,
537 0x04b, 0x000,
538 0x08b, 0x000,
539 0x048, 0x000,
540 0x088, 0x000,
541 0x04e, 0x012,
542 0x08e, 0x012,
543 0x058, 0x012,
544 0x098, 0x012,
545 0x059, 0x000,
546 0x099, 0x000,
547 0x05a, 0x003,
548 0x09a, 0x003,
549 0x05b, 0x001,
550 0x09b, 0x001,
551 0x054, 0x008,
552 0x094, 0x008,
553 0x055, 0x000,
554 0x095, 0x000,
555 0x056, 0x0c7,
556 0x096, 0x0c7,
557 0x057, 0x002,
558 0x097, 0x002,
559 0x060, 0x001,
560 0x0a0, 0x001,
561 0x061, 0x000,
562 0x0a1, 0x000,
563 0x062, 0x000,
564 0x0a2, 0x000,
565 0x063, 0x000,
566 0x0a3, 0x000,
567 0x070, 0x000,
568 0x0b0, 0x000,
569 0x071, 0x004,
570 0x0b1, 0x004,
571 0x06c, 0x0e9,
572 0x0ac, 0x0e9,
573 0x06d, 0x003,
574 0x0ad, 0x003,
575 0x05c, 0x0d0,
576 0x09c, 0x0d0,
577 0x05d, 0x002,
578 0x09d, 0x002,
579 0x05e, 0x0f2,
580 0x09e, 0x0f2,
581 0x05f, 0x000,
582 0x09f, 0x000,
583 0x074, 0x000,
584 0x0b4, 0x000,
585 0x075, 0x000,
586 0x0b5, 0x000,
587 0x076, 0x000,
588 0x0b6, 0x000,
589 0x077, 0x000,
590 0x0b7, 0x000,
591 0x195, 0x008,
592 0x598, 0x0e7,
593 0x599, 0x07d,
594 0x59a, 0x018,
595 0x59c, 0x066,
596 0x59d, 0x090,
597 0x59e, 0x001,
598 0x584, 0x000,
599 0x585, 0x000,
600 0x586, 0x003,
601 0x588, 0x0ff,
602 0x589, 0x00f,
603 0x58a, 0x000,
604 0x58b, 0x000,
605 0x58c, 0x010,
606 0x58d, 0x032,
607 0x58e, 0x054,
608 0x58f, 0x023,
609 0x590, 0x000,
610 0x595, 0x000,
611 0x596, 0x000,
612 0x597, 0x000,
613 0x464, 0x000,
614 0x46c, 0xbbbb10,
615 0x470, 0x101010,
616 0x478, 0x000,
617 0x474, 0x018,
618 0x454, 0x042135,
619 0x193, 0x0a6,
620 0x108, 0x0f8,
621 0x042, 0x003,
622 0x082, 0x003,
623 0x454, 0x0425b9,
624 0x454, 0x042539,
625 0x193, 0x000,
626 0x193, 0x0a6,
627 0x464, 0x000,
628
629 0, 0
630};
631
632
633static u32 reg_init_tuner_input[] = {
634 0x108, 0x0f8,
635 0x111, 0x000,
636 0x10e, 0x00a,
637 0, 0
638};
639
640
641static u32 reg_init_composite_input[] = {
642 0x108, 0x0e8,
643 0x111, 0x000,
644 0x10e, 0x04a,
645 0, 0
646};
647
648
649static u32 reg_init_svideo_input[] = {
650 0x108, 0x0e8,
651 0x111, 0x000,
652 0x10e, 0x04a,
653 0, 0
654};
655
656static u32 reg_set_audio_template[4][2] =
657{
658 {
659
660
661
662
663
664
665
666
667
668 0xbbbb00,
669
670
671
672
673
674 0x00,
675 },
676 {
677 0xbbbb10, 0x101010,
678 },
679 {
680 0xbbbb00, 0x00,
681 },
682 {
683 0xbbbb11, 0x111111,
684 }
685};
686
687
688
689static void get_inf_dev_status(struct v4l2_subdev *sd,
690 int *dual_flag, int *stereo_flag)
691{
692 u32 reg_data3;
693
694 static char *stdres[0x20] = {
695 [0x00] = "no standard detected",
696 [0x01] = "B/G (in progress)",
697 [0x02] = "D/K (in progress)",
698 [0x03] = "M (in progress)",
699
700 [0x04] = "B/G A2",
701 [0x05] = "B/G NICAM",
702 [0x06] = "D/K A2 (1)",
703 [0x07] = "D/K A2 (2)",
704 [0x08] = "D/K A2 (3)",
705 [0x09] = "D/K NICAM",
706 [0x0a] = "L NICAM",
707 [0x0b] = "I NICAM",
708
709 [0x0c] = "M Korea",
710 [0x0d] = "M BTSC ",
711 [0x0e] = "M EIAJ",
712
713 [0x0f] = "FM radio / IF 10.7 / 50 deemp",
714 [0x10] = "FM radio / IF 10.7 / 75 deemp",
715 [0x11] = "FM radio / IF sel / 50 deemp",
716 [0x12] = "FM radio / IF sel / 75 deemp",
717
718 [0x13 ... 0x1e] = "unknown",
719 [0x1f] = "??? [in progress]",
720 };
721
722
723 *dual_flag = *stereo_flag = 0;
724
725
726
727
728 reg_data3 = saa717x_read(sd, 0x0528);
729
730 v4l2_dbg(1, debug, sd, "tvaudio thread status: 0x%x [%s%s%s]\n",
731 reg_data3, stdres[reg_data3 & 0x1f],
732 (reg_data3 & 0x000020) ? ",stereo" : "",
733 (reg_data3 & 0x000040) ? ",dual" : "");
734 v4l2_dbg(1, debug, sd, "detailed status: "
735 "%s#%s#%s#%s#%s#%s#%s#%s#%s#%s#%s#%s#%s#%s\n",
736 (reg_data3 & 0x000080) ? " A2/EIAJ pilot tone " : "",
737 (reg_data3 & 0x000100) ? " A2/EIAJ dual " : "",
738 (reg_data3 & 0x000200) ? " A2/EIAJ stereo " : "",
739 (reg_data3 & 0x000400) ? " A2/EIAJ noise mute " : "",
740
741 (reg_data3 & 0x000800) ? " BTSC/FM radio pilot " : "",
742 (reg_data3 & 0x001000) ? " SAP carrier " : "",
743 (reg_data3 & 0x002000) ? " BTSC stereo noise mute " : "",
744 (reg_data3 & 0x004000) ? " SAP noise mute " : "",
745 (reg_data3 & 0x008000) ? " VDSP " : "",
746
747 (reg_data3 & 0x010000) ? " NICST " : "",
748 (reg_data3 & 0x020000) ? " NICDU " : "",
749 (reg_data3 & 0x040000) ? " NICAM muted " : "",
750 (reg_data3 & 0x080000) ? " NICAM reserve sound " : "",
751
752 (reg_data3 & 0x100000) ? " init done " : "");
753
754 if (reg_data3 & 0x000220) {
755 v4l2_dbg(1, debug, sd, "ST!!!\n");
756 *stereo_flag = 1;
757 }
758
759 if (reg_data3 & 0x000140) {
760 v4l2_dbg(1, debug, sd, "DUAL!!!\n");
761 *dual_flag = 1;
762 }
763}
764
765
766static void set_audio_mode(struct v4l2_subdev *sd, int audio_mode)
767{
768 v4l2_dbg(1, debug, sd, "writing registers to set audio mode by set %d\n",
769 audio_mode);
770
771 saa717x_write(sd, 0x46c, reg_set_audio_template[audio_mode][0]);
772 saa717x_write(sd, 0x470, reg_set_audio_template[audio_mode][1]);
773}
774
775
776static int set_audio_regs(struct v4l2_subdev *sd,
777 struct saa717x_state *decoder)
778{
779 u8 mute = 0xac;
780 u32 val;
781 unsigned int work_l, work_r;
782
783
784 saa717x_write(sd, 0x0594, decoder->audio_input);
785 v4l2_dbg(1, debug, sd, "set audio input %d\n",
786 decoder->audio_input);
787
788
789 work_l = (min(65536 - decoder->audio_main_balance, 32768) * decoder->audio_main_volume) / 32768;
790 work_r = (min(decoder->audio_main_balance, (u16)32768) * decoder->audio_main_volume) / 32768;
791 decoder->audio_main_vol_l = (long)work_l * (24 - (-40)) / 65535 - 40;
792 decoder->audio_main_vol_r = (long)work_r * (24 - (-40)) / 65535 - 40;
793
794
795
796
797
798 if (decoder->audio_main_mute) {
799 val = mute | (mute << 8);
800 } else {
801 val = (u8)decoder->audio_main_vol_l |
802 ((u8)decoder->audio_main_vol_r << 8);
803 }
804
805 saa717x_write(sd, 0x480, val);
806
807
808 val = decoder->audio_main_bass & 0x1f;
809 val |= (decoder->audio_main_treble & 0x1f) << 5;
810 saa717x_write(sd, 0x488, val);
811 return 0;
812}
813
814
815static void set_h_prescale(struct v4l2_subdev *sd,
816 int task, int prescale)
817{
818 static const struct {
819 int xpsc;
820 int xacl;
821 int xc2_1;
822 int xdcg;
823 int vpfy;
824 } vals[] = {
825
826 { 1, 0, 0, 0, 0 },
827 { 2, 2, 1, 2, 2 },
828 { 3, 4, 1, 3, 2 },
829 { 4, 8, 1, 4, 2 },
830 { 5, 8, 1, 4, 2 },
831 { 6, 8, 1, 4, 3 },
832 { 7, 8, 1, 4, 3 },
833 { 8, 15, 0, 4, 3 },
834 { 9, 15, 0, 4, 3 },
835 { 10, 16, 1, 5, 3 },
836 };
837 static const int count = ARRAY_SIZE(vals);
838 int i, task_shift;
839
840 task_shift = task * 0x40;
841 for (i = 0; i < count; i++)
842 if (vals[i].xpsc == prescale)
843 break;
844 if (i == count)
845 return;
846
847
848 saa717x_write(sd, 0x60 + task_shift, vals[i].xpsc);
849
850 saa717x_write(sd, 0x61 + task_shift, vals[i].xacl);
851
852 saa717x_write(sd, 0x62 + task_shift,
853 (vals[i].xc2_1 << 3) | vals[i].xdcg);
854
855 saa717x_write(sd, 0x63 + task_shift,
856 (vals[i].vpfy << 2) | vals[i].vpfy);
857}
858
859
860static void set_v_scale(struct v4l2_subdev *sd, int task, int yscale)
861{
862 int task_shift;
863
864 task_shift = task * 0x40;
865
866 saa717x_write(sd, 0x70 + task_shift, yscale & 0xff);
867
868 saa717x_write(sd, 0x71 + task_shift, yscale >> 8);
869}
870
871static int saa717x_s_ctrl(struct v4l2_ctrl *ctrl)
872{
873 struct v4l2_subdev *sd = to_sd(ctrl);
874 struct saa717x_state *state = to_state(sd);
875
876 switch (ctrl->id) {
877 case V4L2_CID_BRIGHTNESS:
878 saa717x_write(sd, 0x10a, ctrl->val);
879 return 0;
880
881 case V4L2_CID_CONTRAST:
882 saa717x_write(sd, 0x10b, ctrl->val);
883 return 0;
884
885 case V4L2_CID_SATURATION:
886 saa717x_write(sd, 0x10c, ctrl->val);
887 return 0;
888
889 case V4L2_CID_HUE:
890 saa717x_write(sd, 0x10d, ctrl->val);
891 return 0;
892
893 case V4L2_CID_AUDIO_MUTE:
894 state->audio_main_mute = ctrl->val;
895 break;
896
897 case V4L2_CID_AUDIO_VOLUME:
898 state->audio_main_volume = ctrl->val;
899 break;
900
901 case V4L2_CID_AUDIO_BALANCE:
902 state->audio_main_balance = ctrl->val;
903 break;
904
905 case V4L2_CID_AUDIO_TREBLE:
906 state->audio_main_treble = ctrl->val;
907 break;
908
909 case V4L2_CID_AUDIO_BASS:
910 state->audio_main_bass = ctrl->val;
911 break;
912
913 default:
914 return 0;
915 }
916 set_audio_regs(sd, state);
917 return 0;
918}
919
920static int saa717x_s_video_routing(struct v4l2_subdev *sd,
921 u32 input, u32 output, u32 config)
922{
923 struct saa717x_state *decoder = to_state(sd);
924 int is_tuner = input & 0x80;
925
926 input &= 0x7f;
927
928 v4l2_dbg(1, debug, sd, "decoder set input (%d)\n", input);
929
930
931 if (input > 9 || input == 5)
932 return -EINVAL;
933
934 if (decoder->input != input) {
935 int input_line = input;
936
937 decoder->input = input_line;
938 v4l2_dbg(1, debug, sd, "now setting %s input %d\n",
939 input_line >= 6 ? "S-Video" : "Composite",
940 input_line);
941
942
943 saa717x_write(sd, 0x102,
944 (saa717x_read(sd, 0x102) & 0xf0) |
945 input_line);
946
947
948 saa717x_write(sd, 0x109,
949 (saa717x_read(sd, 0x109) & 0x7f) |
950 (input_line < 6 ? 0x0 : 0x80));
951
952
953 if (is_tuner) {
954
955 set_audio_mode(sd, decoder->tuner_audio_mode);
956 } else {
957
958
959 set_audio_mode(sd, TUNER_AUDIO_STEREO);
960 }
961
962 if (is_tuner)
963 saa717x_write_regs(sd, reg_init_tuner_input);
964 else if (input_line >= 6)
965 saa717x_write_regs(sd, reg_init_svideo_input);
966 else
967 saa717x_write_regs(sd, reg_init_composite_input);
968 }
969
970 return 0;
971}
972
973#ifdef CONFIG_VIDEO_ADV_DEBUG
974static int saa717x_g_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
975{
976 reg->val = saa717x_read(sd, reg->reg);
977 reg->size = 1;
978 return 0;
979}
980
981static int saa717x_s_register(struct v4l2_subdev *sd, const struct v4l2_dbg_register *reg)
982{
983 u16 addr = reg->reg & 0xffff;
984 u8 val = reg->val & 0xff;
985
986 saa717x_write(sd, addr, val);
987 return 0;
988}
989#endif
990
991static int saa717x_set_fmt(struct v4l2_subdev *sd,
992 struct v4l2_subdev_pad_config *cfg,
993 struct v4l2_subdev_format *format)
994{
995 struct v4l2_mbus_framefmt *fmt = &format->format;
996 int prescale, h_scale, v_scale;
997
998 v4l2_dbg(1, debug, sd, "decoder set size\n");
999
1000 if (format->pad || fmt->code != MEDIA_BUS_FMT_FIXED)
1001 return -EINVAL;
1002
1003
1004 if (fmt->width < 1 || fmt->width > 1440)
1005 return -EINVAL;
1006 if (fmt->height < 1 || fmt->height > 960)
1007 return -EINVAL;
1008
1009 fmt->field = V4L2_FIELD_INTERLACED;
1010 fmt->colorspace = V4L2_COLORSPACE_SMPTE170M;
1011
1012 if (format->which == V4L2_SUBDEV_FORMAT_TRY)
1013 return 0;
1014
1015
1016
1017 prescale = SAA717X_NTSC_WIDTH / fmt->width;
1018 if (prescale == 0)
1019 prescale = 1;
1020 h_scale = 1024 * SAA717X_NTSC_WIDTH / prescale / fmt->width;
1021
1022 v_scale = 512 * 2 * SAA717X_NTSC_HEIGHT / fmt->height;
1023
1024
1025 set_h_prescale(sd, 0, prescale);
1026 set_h_prescale(sd, 1, prescale);
1027
1028
1029
1030 saa717x_write(sd, 0x6C, (u8)(h_scale & 0xFF));
1031 saa717x_write(sd, 0x6D, (u8)((h_scale >> 8) & 0xFF));
1032
1033 saa717x_write(sd, 0xAC, (u8)(h_scale & 0xFF));
1034 saa717x_write(sd, 0xAD, (u8)((h_scale >> 8) & 0xFF));
1035
1036
1037 set_v_scale(sd, 0, v_scale);
1038 set_v_scale(sd, 1, v_scale);
1039
1040
1041
1042
1043 saa717x_write(sd, 0x5C, (u8)(fmt->width & 0xFF));
1044 saa717x_write(sd, 0x5D, (u8)((fmt->width >> 8) & 0xFF));
1045
1046 saa717x_write(sd, 0x9C, (u8)(fmt->width & 0xFF));
1047 saa717x_write(sd, 0x9D, (u8)((fmt->width >> 8) & 0xFF));
1048
1049
1050
1051 saa717x_write(sd, 0x5E, (u8)(fmt->height & 0xFF));
1052 saa717x_write(sd, 0x5F, (u8)((fmt->height >> 8) & 0xFF));
1053
1054 saa717x_write(sd, 0x9E, (u8)(fmt->height & 0xFF));
1055 saa717x_write(sd, 0x9F, (u8)((fmt->height >> 8) & 0xFF));
1056 return 0;
1057}
1058
1059static int saa717x_s_radio(struct v4l2_subdev *sd)
1060{
1061 struct saa717x_state *decoder = to_state(sd);
1062
1063 decoder->radio = 1;
1064 return 0;
1065}
1066
1067static int saa717x_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
1068{
1069 struct saa717x_state *decoder = to_state(sd);
1070
1071 v4l2_dbg(1, debug, sd, "decoder set norm ");
1072 v4l2_dbg(1, debug, sd, "(not yet implemented)\n");
1073
1074 decoder->radio = 0;
1075 decoder->std = std;
1076 return 0;
1077}
1078
1079static int saa717x_s_audio_routing(struct v4l2_subdev *sd,
1080 u32 input, u32 output, u32 config)
1081{
1082 struct saa717x_state *decoder = to_state(sd);
1083
1084 if (input < 3) {
1085 decoder->audio_input = input;
1086 v4l2_dbg(1, debug, sd,
1087 "set decoder audio input to %d\n",
1088 decoder->audio_input);
1089 set_audio_regs(sd, decoder);
1090 return 0;
1091 }
1092 return -ERANGE;
1093}
1094
1095static int saa717x_s_stream(struct v4l2_subdev *sd, int enable)
1096{
1097 struct saa717x_state *decoder = to_state(sd);
1098
1099 v4l2_dbg(1, debug, sd, "decoder %s output\n",
1100 enable ? "enable" : "disable");
1101 decoder->enable = enable;
1102 saa717x_write(sd, 0x193, enable ? 0xa6 : 0x26);
1103 return 0;
1104}
1105
1106
1107static int saa717x_s_tuner(struct v4l2_subdev *sd, const struct v4l2_tuner *vt)
1108{
1109 struct saa717x_state *decoder = to_state(sd);
1110 int audio_mode;
1111 char *mes[4] = {
1112 "MONO", "STEREO", "LANG1", "LANG2/SAP"
1113 };
1114
1115 audio_mode = TUNER_AUDIO_STEREO;
1116
1117 switch (vt->audmode) {
1118 case V4L2_TUNER_MODE_MONO:
1119 audio_mode = TUNER_AUDIO_MONO;
1120 break;
1121 case V4L2_TUNER_MODE_STEREO:
1122 audio_mode = TUNER_AUDIO_STEREO;
1123 break;
1124 case V4L2_TUNER_MODE_LANG2:
1125 audio_mode = TUNER_AUDIO_LANG2;
1126 break;
1127 case V4L2_TUNER_MODE_LANG1:
1128 audio_mode = TUNER_AUDIO_LANG1;
1129 break;
1130 }
1131
1132 v4l2_dbg(1, debug, sd, "change audio mode to %s\n",
1133 mes[audio_mode]);
1134 decoder->tuner_audio_mode = audio_mode;
1135
1136
1137 set_audio_mode(sd, decoder->tuner_audio_mode);
1138 return 0;
1139}
1140
1141static int saa717x_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1142{
1143 struct saa717x_state *decoder = to_state(sd);
1144 int dual_f, stereo_f;
1145
1146 if (decoder->radio)
1147 return 0;
1148 get_inf_dev_status(sd, &dual_f, &stereo_f);
1149
1150 v4l2_dbg(1, debug, sd, "DETECT==st:%d dual:%d\n",
1151 stereo_f, dual_f);
1152
1153
1154 if ((dual_f == 0) && (stereo_f == 0)) {
1155 vt->rxsubchans = V4L2_TUNER_SUB_MONO;
1156 v4l2_dbg(1, debug, sd, "DETECT==MONO\n");
1157 }
1158
1159
1160 if (stereo_f == 1) {
1161 if (vt->audmode == V4L2_TUNER_MODE_STEREO ||
1162 vt->audmode == V4L2_TUNER_MODE_LANG1) {
1163 vt->rxsubchans = V4L2_TUNER_SUB_STEREO;
1164 v4l2_dbg(1, debug, sd, "DETECT==ST(ST)\n");
1165 } else {
1166 vt->rxsubchans = V4L2_TUNER_SUB_MONO;
1167 v4l2_dbg(1, debug, sd, "DETECT==ST(MONO)\n");
1168 }
1169 }
1170
1171
1172 if (dual_f == 1) {
1173 if (vt->audmode == V4L2_TUNER_MODE_LANG2) {
1174 vt->rxsubchans = V4L2_TUNER_SUB_LANG2 | V4L2_TUNER_SUB_MONO;
1175 v4l2_dbg(1, debug, sd, "DETECT==DUAL1\n");
1176 } else {
1177 vt->rxsubchans = V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_MONO;
1178 v4l2_dbg(1, debug, sd, "DETECT==DUAL2\n");
1179 }
1180 }
1181 return 0;
1182}
1183
1184static int saa717x_log_status(struct v4l2_subdev *sd)
1185{
1186 struct saa717x_state *state = to_state(sd);
1187
1188 v4l2_ctrl_handler_log_status(&state->hdl, sd->name);
1189 return 0;
1190}
1191
1192
1193
1194static const struct v4l2_ctrl_ops saa717x_ctrl_ops = {
1195 .s_ctrl = saa717x_s_ctrl,
1196};
1197
1198static const struct v4l2_subdev_core_ops saa717x_core_ops = {
1199#ifdef CONFIG_VIDEO_ADV_DEBUG
1200 .g_register = saa717x_g_register,
1201 .s_register = saa717x_s_register,
1202#endif
1203 .log_status = saa717x_log_status,
1204};
1205
1206static const struct v4l2_subdev_tuner_ops saa717x_tuner_ops = {
1207 .g_tuner = saa717x_g_tuner,
1208 .s_tuner = saa717x_s_tuner,
1209 .s_radio = saa717x_s_radio,
1210};
1211
1212static const struct v4l2_subdev_video_ops saa717x_video_ops = {
1213 .s_std = saa717x_s_std,
1214 .s_routing = saa717x_s_video_routing,
1215 .s_stream = saa717x_s_stream,
1216};
1217
1218static const struct v4l2_subdev_audio_ops saa717x_audio_ops = {
1219 .s_routing = saa717x_s_audio_routing,
1220};
1221
1222static const struct v4l2_subdev_pad_ops saa717x_pad_ops = {
1223 .set_fmt = saa717x_set_fmt,
1224};
1225
1226static const struct v4l2_subdev_ops saa717x_ops = {
1227 .core = &saa717x_core_ops,
1228 .tuner = &saa717x_tuner_ops,
1229 .audio = &saa717x_audio_ops,
1230 .video = &saa717x_video_ops,
1231 .pad = &saa717x_pad_ops,
1232};
1233
1234
1235
1236
1237
1238
1239
1240static int saa717x_probe(struct i2c_client *client,
1241 const struct i2c_device_id *did)
1242{
1243 struct saa717x_state *decoder;
1244 struct v4l2_ctrl_handler *hdl;
1245 struct v4l2_subdev *sd;
1246 u8 id = 0;
1247 char *p = "";
1248
1249
1250 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1251 return -EIO;
1252
1253 decoder = devm_kzalloc(&client->dev, sizeof(*decoder), GFP_KERNEL);
1254 if (decoder == NULL)
1255 return -ENOMEM;
1256
1257 sd = &decoder->sd;
1258 v4l2_i2c_subdev_init(sd, client, &saa717x_ops);
1259
1260 if (saa717x_write(sd, 0x5a4, 0xfe) &&
1261 saa717x_write(sd, 0x5a5, 0x0f) &&
1262 saa717x_write(sd, 0x5a6, 0x00) &&
1263 saa717x_write(sd, 0x5a7, 0x01))
1264 id = saa717x_read(sd, 0x5a0);
1265 if (id != 0xc2 && id != 0x32 && id != 0xf2 && id != 0x6c) {
1266 v4l2_dbg(1, debug, sd, "saa717x not found (id=%02x)\n", id);
1267 return -ENODEV;
1268 }
1269 if (id == 0xc2)
1270 p = "saa7173";
1271 else if (id == 0x32)
1272 p = "saa7174A";
1273 else if (id == 0x6c)
1274 p = "saa7174HL";
1275 else
1276 p = "saa7171";
1277 v4l2_info(sd, "%s found @ 0x%x (%s)\n", p,
1278 client->addr << 1, client->adapter->name);
1279
1280 hdl = &decoder->hdl;
1281 v4l2_ctrl_handler_init(hdl, 9);
1282
1283 v4l2_ctrl_new_std(hdl, &saa717x_ctrl_ops,
1284 V4L2_CID_BRIGHTNESS, 0, 255, 1, 128);
1285 v4l2_ctrl_new_std(hdl, &saa717x_ctrl_ops,
1286 V4L2_CID_CONTRAST, 0, 255, 1, 68);
1287 v4l2_ctrl_new_std(hdl, &saa717x_ctrl_ops,
1288 V4L2_CID_SATURATION, 0, 255, 1, 64);
1289 v4l2_ctrl_new_std(hdl, &saa717x_ctrl_ops,
1290 V4L2_CID_HUE, -128, 127, 1, 0);
1291 v4l2_ctrl_new_std(hdl, &saa717x_ctrl_ops,
1292 V4L2_CID_AUDIO_VOLUME, 0, 65535, 65535 / 100, 42000);
1293 v4l2_ctrl_new_std(hdl, &saa717x_ctrl_ops,
1294 V4L2_CID_AUDIO_BALANCE, 0, 65535, 65535 / 100, 32768);
1295 v4l2_ctrl_new_std(hdl, &saa717x_ctrl_ops,
1296 V4L2_CID_AUDIO_BASS, -16, 15, 1, 0);
1297 v4l2_ctrl_new_std(hdl, &saa717x_ctrl_ops,
1298 V4L2_CID_AUDIO_TREBLE, -16, 15, 1, 0);
1299 v4l2_ctrl_new_std(hdl, &saa717x_ctrl_ops,
1300 V4L2_CID_AUDIO_MUTE, 0, 1, 1, 0);
1301 sd->ctrl_handler = hdl;
1302 if (hdl->error) {
1303 int err = hdl->error;
1304
1305 v4l2_ctrl_handler_free(hdl);
1306 return err;
1307 }
1308
1309 decoder->std = V4L2_STD_NTSC;
1310 decoder->input = -1;
1311 decoder->enable = 1;
1312
1313
1314 decoder->playback = 0;
1315 decoder->audio = 1;
1316
1317 decoder->audio_input = 2;
1318
1319 decoder->tuner_audio_mode = TUNER_AUDIO_STEREO;
1320
1321 decoder->audio_main_vol_l = 6;
1322 decoder->audio_main_vol_r = 6;
1323
1324 v4l2_dbg(1, debug, sd, "writing init values\n");
1325
1326
1327 saa717x_write_regs(sd, reg_init_initialize);
1328
1329 v4l2_ctrl_handler_setup(hdl);
1330
1331 set_current_state(TASK_INTERRUPTIBLE);
1332 schedule_timeout(2*HZ);
1333 return 0;
1334}
1335
1336static int saa717x_remove(struct i2c_client *client)
1337{
1338 struct v4l2_subdev *sd = i2c_get_clientdata(client);
1339
1340 v4l2_device_unregister_subdev(sd);
1341 v4l2_ctrl_handler_free(sd->ctrl_handler);
1342 return 0;
1343}
1344
1345
1346
1347static const struct i2c_device_id saa717x_id[] = {
1348 { "saa717x", 0 },
1349 { }
1350};
1351MODULE_DEVICE_TABLE(i2c, saa717x_id);
1352
1353static struct i2c_driver saa717x_driver = {
1354 .driver = {
1355 .name = "saa717x",
1356 },
1357 .probe = saa717x_probe,
1358 .remove = saa717x_remove,
1359 .id_table = saa717x_id,
1360};
1361
1362module_i2c_driver(saa717x_driver);
1363