?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
V4L/DVB (9623): tvaudio: Improve debug msg by printing something more human
[linux-2.6/linux-2.6-openrd.git] / drivers / media / video / tvaudio.c
blobfb46ce4a1090a8fdfafe795f029615c101cc045c
1 /*
2 * Driver for simple i2c audio chips.
3 *
4 * Copyright (c) 2000 Gerd Knorr
5 * based on code by:
6 * Eric Sandeen (eric_sandeen@bigfoot.com)
7 * Steve VanDeBogart (vandebo@uclink.berkeley.edu)
8 * Greg Alexander (galexand@acm.org)
9 *
10 * Copyright(c) 2005-2008 Mauro Carvalho Chehab
11 * - Some cleanups, code fixes, etc
12 * - Convert it to V4L2 API
13 *
14 * This code is placed under the terms of the GNU General Public License
15 *
16 * OPTIONS:
17 * debug - set to 1 if you'd like to see debug messages
18 *
19 */
20
21 #include <linux/module.h>
22 #include <linux/kernel.h>
23 #include <linux/sched.h>
24 #include <linux/string.h>
25 #include <linux/timer.h>
26 #include <linux/delay.h>
27 #include <linux/errno.h>
28 #include <linux/slab.h>
29 #include <linux/videodev.h>
30 #include <linux/i2c.h>
31 #include <linux/init.h>
32 #include <linux/kthread.h>
33 #include <linux/freezer.h>
34
35 #include <media/tvaudio.h>
36 #include <media/v4l2-common.h>
37 #include <media/v4l2-ioctl.h>
38 #include <media/v4l2-chip-ident.h>
39 #include <media/v4l2-i2c-drv-legacy.h>
40
41 #include <media/i2c-addr.h>
42
43 /* ---------------------------------------------------------------------- */
44 /* insmod args */
45
46 static int debug; /* insmod parameter */
47 module_param(debug, int, 0644);
48
49 MODULE_DESCRIPTION("device driver for various i2c TV sound decoder / audiomux chips");
50 MODULE_AUTHOR("Eric Sandeen, Steve VanDeBogart, Greg Alexander, Gerd Knorr");
51 MODULE_LICENSE("GPL");
52
53 #define UNSET (-1U)
54
55 /* ---------------------------------------------------------------------- */
56 /* our structs */
57
58 #define MAXREGS 64
59
60 struct CHIPSTATE;
61 typedef int (*getvalue)(int);
62 typedef int (*checkit)(struct CHIPSTATE*);
63 typedef int (*initialize)(struct CHIPSTATE*);
64 typedef int (*getmode)(struct CHIPSTATE*);
65 typedef void (*setmode)(struct CHIPSTATE*, int mode);
66
67 /* i2c command */
68 typedef struct AUDIOCMD {
69 int count; /* # of bytes to send */
70 unsigned char bytes[MAXREGS+1]; /* addr, data, data, ... */
71 } audiocmd;
72
73 /* chip description */
74 struct CHIPDESC {
75 char *name; /* chip name */
76 int addr_lo, addr_hi; /* i2c address range */
77 int registers; /* # of registers */
78
79 int *insmodopt;
80 checkit checkit;
81 initialize initialize;
82 int flags;
83 #define CHIP_HAS_VOLUME 1
84 #define CHIP_HAS_BASSTREBLE 2
85 #define CHIP_HAS_INPUTSEL 4
86 #define CHIP_NEED_CHECKMODE 8
87
88 /* various i2c command sequences */
89 audiocmd init;
90
91 /* which register has which value */
92 int leftreg,rightreg,treblereg,bassreg;
93
94 /* initialize with (defaults to 65535/65535/32768/32768 */
95 int leftinit,rightinit,trebleinit,bassinit;
96
97 /* functions to convert the values (v4l -> chip) */
98 getvalue volfunc,treblefunc,bassfunc;
99
100 /* get/set mode */
101 getmode getmode;
102 setmode setmode;
103
104 /* input switch register + values for v4l inputs */
105 int inputreg;
106 int inputmap[4];
107 int inputmute;
108 int inputmask;
109 };
110
111 /* current state of the chip */
112 struct CHIPSTATE {
113 struct i2c_client *c;
114
115 /* chip-specific description - should point to
116 an entry at CHIPDESC table */
117 struct CHIPDESC *desc;
118
119 /* shadow register set */
120 audiocmd shadow;
121
122 /* current settings */
123 __u16 left,right,treble,bass,muted,mode;
124 int prevmode;
125 int radio;
126 int input;
127
128 /* thread */
129 struct task_struct *thread;
130 struct timer_list wt;
131 int watch_stereo;
132 int audmode;
133 };
134
135 /* ---------------------------------------------------------------------- */
136 /* i2c addresses */
137
138 static unsigned short normal_i2c[] = {
139 I2C_ADDR_TDA8425 >> 1,
140 I2C_ADDR_TEA6300 >> 1,
141 I2C_ADDR_TEA6420 >> 1,
142 I2C_ADDR_TDA9840 >> 1,
143 I2C_ADDR_TDA985x_L >> 1,
144 I2C_ADDR_TDA985x_H >> 1,
145 I2C_ADDR_TDA9874 >> 1,
146 I2C_ADDR_PIC16C54 >> 1,
147 I2C_CLIENT_END };
148 I2C_CLIENT_INSMOD;
149
150 /* ---------------------------------------------------------------------- */
151 /* i2c I/O functions */
152
153 static int chip_write(struct CHIPSTATE *chip, int subaddr, int val)
154 {
155 unsigned char buffer[2];
156
157 if (subaddr < 0) {
158 v4l_dbg(1, debug, chip->c, "%s: chip_write: 0x%x\n",
159 chip->c->name, val);
160 chip->shadow.bytes[1] = val;
161 buffer[0] = val;
162 if (1 != i2c_master_send(chip->c,buffer,1)) {
163 v4l_warn(chip->c, "%s: I/O error (write 0x%x)\n",
164 chip->c->name, val);
165 return -1;
166 }
167 } else {
168 if (subaddr + 1 >= ARRAY_SIZE(chip->shadow.bytes)) {
169 v4l_info(chip->c,
170 "Tried to access a non-existent register: %d\n",
171 subaddr);
172 return -EINVAL;
173 }
174
175 v4l_dbg(1, debug, chip->c, "%s: chip_write: reg%d=0x%x\n",
176 chip->c->name, subaddr, val);
177 chip->shadow.bytes[subaddr+1] = val;
178 buffer[0] = subaddr;
179 buffer[1] = val;
180 if (2 != i2c_master_send(chip->c,buffer,2)) {
181 v4l_warn(chip->c, "%s: I/O error (write reg%d=0x%x)\n",
182 chip->c->name, subaddr, val);
183 return -1;
184 }
185 }
186 return 0;
187 }
188
189 static int chip_write_masked(struct CHIPSTATE *chip,
190 int subaddr, int val, int mask)
191 {
192 if (mask != 0) {
193 if (subaddr < 0) {
194 val = (chip->shadow.bytes[1] & ~mask) | (val & mask);
195 } else {
196 if (subaddr + 1 >= ARRAY_SIZE(chip->shadow.bytes)) {
197 v4l_info(chip->c,
198 "Tried to access a non-existent register: %d\n",
199 subaddr);
200 return -EINVAL;
201 }
202
203 val = (chip->shadow.bytes[subaddr+1] & ~mask) | (val & mask);
204 }
205 }
206 return chip_write(chip, subaddr, val);
207 }
208
209 static int chip_read(struct CHIPSTATE *chip)
210 {
211 unsigned char buffer;
212
213 if (1 != i2c_master_recv(chip->c,&buffer,1)) {
214 v4l_warn(chip->c, "%s: I/O error (read)\n",
215 chip->c->name);
216 return -1;
217 }
218 v4l_dbg(1, debug, chip->c, "%s: chip_read: 0x%x\n",chip->c->name, buffer);
219 return buffer;
220 }
221
222 static int chip_read2(struct CHIPSTATE *chip, int subaddr)
223 {
224 unsigned char write[1];
225 unsigned char read[1];
226 struct i2c_msg msgs[2] = {
227 { chip->c->addr, 0, 1, write },
228 { chip->c->addr, I2C_M_RD, 1, read }
229 };
230 write[0] = subaddr;
231
232 if (2 != i2c_transfer(chip->c->adapter,msgs,2)) {
233 v4l_warn(chip->c, "%s: I/O error (read2)\n", chip->c->name);
234 return -1;
235 }
236 v4l_dbg(1, debug, chip->c, "%s: chip_read2: reg%d=0x%x\n",
237 chip->c->name, subaddr,read[0]);
238 return read[0];
239 }
240
241 static int chip_cmd(struct CHIPSTATE *chip, char *name, audiocmd *cmd)
242 {
243 int i;
244
245 if (0 == cmd->count)
246 return 0;
247
248 if (cmd->count + cmd->bytes[0] - 1 >= ARRAY_SIZE(chip->shadow.bytes)) {
249 v4l_info(chip->c,
250 "Tried to access a non-existent register range: %d to %d\n",
251 cmd->bytes[0] + 1, cmd->bytes[0] + cmd->count - 1);
252 return -EINVAL;
253 }
254
255 /* FIXME: it seems that the shadow bytes are wrong bellow !*/
256
257 /* update our shadow register set; print bytes if (debug > 0) */
258 v4l_dbg(1, debug, chip->c, "%s: chip_cmd(%s): reg=%d, data:",
259 chip->c->name, name,cmd->bytes[0]);
260 for (i = 1; i < cmd->count; i++) {
261 if (debug)
262 printk(" 0x%x",cmd->bytes[i]);
263 chip->shadow.bytes[i+cmd->bytes[0]] = cmd->bytes[i];
264 }
265 if (debug)
266 printk("\n");
267
268 /* send data to the chip */
269 if (cmd->count != i2c_master_send(chip->c,cmd->bytes,cmd->count)) {
270 v4l_warn(chip->c, "%s: I/O error (%s)\n", chip->c->name, name);
271 return -1;
272 }
273 return 0;
274 }
275
276 /* ---------------------------------------------------------------------- */
277 /* kernel thread for doing i2c stuff asyncronly
278 * right now it is used only to check the audio mode (mono/stereo/whatever)
279 * some time after switching to another TV channel, then turn on stereo
280 * if available, ...
281 */
282
283 static void chip_thread_wake(unsigned long data)
284 {
285 struct CHIPSTATE *chip = (struct CHIPSTATE*)data;
286 wake_up_process(chip->thread);
287 }
288
289 static int chip_thread(void *data)
290 {
291 struct CHIPSTATE *chip = data;
292 struct CHIPDESC *desc = chip->desc;
293 int mode;
294
295 v4l_dbg(1, debug, chip->c, "%s: thread started\n", chip->c->name);
296 set_freezable();
297 for (;;) {
298 set_current_state(TASK_INTERRUPTIBLE);
299 if (!kthread_should_stop())
300 schedule();
301 set_current_state(TASK_RUNNING);
302 try_to_freeze();
303 if (kthread_should_stop())
304 break;
305 v4l_dbg(1, debug, chip->c, "%s: thread wakeup\n", chip->c->name);
306
307 /* don't do anything for radio or if mode != auto */
308 if (chip->radio || chip->mode != 0)
309 continue;
310
311 /* have a look what's going on */
312 mode = desc->getmode(chip);
313 if (mode == chip->prevmode)
314 continue;
315
316 /* chip detected a new audio mode - set it */
317 v4l_dbg(1, debug, chip->c, "%s: thread checkmode\n",
318 chip->c->name);
319
320 chip->prevmode = mode;
321
322 if (mode & V4L2_TUNER_MODE_STEREO)
323 desc->setmode(chip, V4L2_TUNER_MODE_STEREO);
324 if (mode & V4L2_TUNER_MODE_LANG1_LANG2)
325 desc->setmode(chip, V4L2_TUNER_MODE_STEREO);
326 else if (mode & V4L2_TUNER_MODE_LANG1)
327 desc->setmode(chip, V4L2_TUNER_MODE_LANG1);
328 else if (mode & V4L2_TUNER_MODE_LANG2)
329 desc->setmode(chip, V4L2_TUNER_MODE_LANG2);
330 else
331 desc->setmode(chip, V4L2_TUNER_MODE_MONO);
332
333 /* schedule next check */
334 mod_timer(&chip->wt, jiffies+msecs_to_jiffies(2000));
335 }
336
337 v4l_dbg(1, debug, chip->c, "%s: thread exiting\n", chip->c->name);
338 return 0;
339 }
340
341 /* ---------------------------------------------------------------------- */
342 /* audio chip descriptions - defines+functions for tda9840 */
343
344 #define TDA9840_SW 0x00
345 #define TDA9840_LVADJ 0x02
346 #define TDA9840_STADJ 0x03
347 #define TDA9840_TEST 0x04
348
349 #define TDA9840_MONO 0x10
350 #define TDA9840_STEREO 0x2a
351 #define TDA9840_DUALA 0x12
352 #define TDA9840_DUALB 0x1e
353 #define TDA9840_DUALAB 0x1a
354 #define TDA9840_DUALBA 0x16
355 #define TDA9840_EXTERNAL 0x7a
356
357 #define TDA9840_DS_DUAL 0x20 /* Dual sound identified */
358 #define TDA9840_ST_STEREO 0x40 /* Stereo sound identified */
359 #define TDA9840_PONRES 0x80 /* Power-on reset detected if = 1 */
360
361 #define TDA9840_TEST_INT1SN 0x1 /* Integration time 0.5s when set */
362 #define TDA9840_TEST_INTFU 0x02 /* Disables integrator function */
363
364 static int tda9840_getmode(struct CHIPSTATE *chip)
365 {
366 int val, mode;
367
368 val = chip_read(chip);
369 mode = V4L2_TUNER_MODE_MONO;
370 if (val & TDA9840_DS_DUAL)
371 mode |= V4L2_TUNER_MODE_LANG1 | V4L2_TUNER_MODE_LANG2;
372 if (val & TDA9840_ST_STEREO)
373 mode |= V4L2_TUNER_MODE_STEREO;
374
375 v4l_dbg(1, debug, chip->c, "tda9840_getmode(): raw chip read: %d, return: %d\n",
376 val, mode);
377 return mode;
378 }
379
380 static void tda9840_setmode(struct CHIPSTATE *chip, int mode)
381 {
382 int update = 1;
383 int t = chip->shadow.bytes[TDA9840_SW + 1] & ~0x7e;
384
385 switch (mode) {
386 case V4L2_TUNER_MODE_MONO:
387 t |= TDA9840_MONO;
388 break;
389 case V4L2_TUNER_MODE_STEREO:
390 t |= TDA9840_STEREO;
391 break;
392 case V4L2_TUNER_MODE_LANG1:
393 t |= TDA9840_DUALA;
394 break;
395 case V4L2_TUNER_MODE_LANG2:
396 t |= TDA9840_DUALB;
397 break;
398 default:
399 update = 0;
400 }
401
402 if (update)
403 chip_write(chip, TDA9840_SW, t);
404 }
405
406 static int tda9840_checkit(struct CHIPSTATE *chip)
407 {
408 int rc;
409 rc = chip_read(chip);
410 /* lower 5 bits should be 0 */
411 return ((rc & 0x1f) == 0) ? 1 : 0;
412 }
413
414 /* ---------------------------------------------------------------------- */
415 /* audio chip descriptions - defines+functions for tda985x */
416
417 /* subaddresses for TDA9855 */
418 #define TDA9855_VR 0x00 /* Volume, right */
419 #define TDA9855_VL 0x01 /* Volume, left */
420 #define TDA9855_BA 0x02 /* Bass */
421 #define TDA9855_TR 0x03 /* Treble */
422 #define TDA9855_SW 0x04 /* Subwoofer - not connected on DTV2000 */
423
424 /* subaddresses for TDA9850 */
425 #define TDA9850_C4 0x04 /* Control 1 for TDA9850 */
426
427 /* subaddesses for both chips */
428 #define TDA985x_C5 0x05 /* Control 2 for TDA9850, Control 1 for TDA9855 */
429 #define TDA985x_C6 0x06 /* Control 3 for TDA9850, Control 2 for TDA9855 */
430 #define TDA985x_C7 0x07 /* Control 4 for TDA9850, Control 3 for TDA9855 */
431 #define TDA985x_A1 0x08 /* Alignment 1 for both chips */
432 #define TDA985x_A2 0x09 /* Alignment 2 for both chips */
433 #define TDA985x_A3 0x0a /* Alignment 3 for both chips */
434
435 /* Masks for bits in TDA9855 subaddresses */
436 /* 0x00 - VR in TDA9855 */
437 /* 0x01 - VL in TDA9855 */
438 /* lower 7 bits control gain from -71dB (0x28) to 16dB (0x7f)
439 * in 1dB steps - mute is 0x27 */
440
441
442 /* 0x02 - BA in TDA9855 */
443 /* lower 5 bits control bass gain from -12dB (0x06) to 16.5dB (0x19)
444 * in .5dB steps - 0 is 0x0E */
445
446
447 /* 0x03 - TR in TDA9855 */
448 /* 4 bits << 1 control treble gain from -12dB (0x3) to 12dB (0xb)
449 * in 3dB steps - 0 is 0x7 */
450
451 /* Masks for bits in both chips' subaddresses */
452 /* 0x04 - SW in TDA9855, C4/Control 1 in TDA9850 */
453 /* Unique to TDA9855: */
454 /* 4 bits << 2 control subwoofer/surround gain from -14db (0x1) to 14db (0xf)
455 * in 3dB steps - mute is 0x0 */
456
457 /* Unique to TDA9850: */
458 /* lower 4 bits control stereo noise threshold, over which stereo turns off
459 * set to values of 0x00 through 0x0f for Ster1 through Ster16 */
460
461
462 /* 0x05 - C5 - Control 1 in TDA9855 , Control 2 in TDA9850*/
463 /* Unique to TDA9855: */
464 #define TDA9855_MUTE 1<<7 /* GMU, Mute at outputs */
465 #define TDA9855_AVL 1<<6 /* AVL, Automatic Volume Level */
466 #define TDA9855_LOUD 1<<5 /* Loudness, 1==off */
467 #define TDA9855_SUR 1<<3 /* Surround / Subwoofer 1==.5(L-R) 0==.5(L+R) */
468 /* Bits 0 to 3 select various combinations
469 * of line in and line out, only the
470 * interesting ones are defined */
471 #define TDA9855_EXT 1<<2 /* Selects inputs LIR and LIL. Pins 41 & 12 */
472 #define TDA9855_INT 0 /* Selects inputs LOR and LOL. (internal) */
473
474 /* Unique to TDA9850: */
475 /* lower 4 bits contol SAP noise threshold, over which SAP turns off
476 * set to values of 0x00 through 0x0f for SAP1 through SAP16 */
477
478
479 /* 0x06 - C6 - Control 2 in TDA9855, Control 3 in TDA9850 */
480 /* Common to TDA9855 and TDA9850: */
481 #define TDA985x_SAP 3<<6 /* Selects SAP output, mute if not received */
482 #define TDA985x_STEREO 1<<6 /* Selects Stereo ouput, mono if not received */
483 #define TDA985x_MONO 0 /* Forces Mono output */
484 #define TDA985x_LMU 1<<3 /* Mute (LOR/LOL for 9855, OUTL/OUTR for 9850) */
485
486 /* Unique to TDA9855: */
487 #define TDA9855_TZCM 1<<5 /* If set, don't mute till zero crossing */
488 #define TDA9855_VZCM 1<<4 /* If set, don't change volume till zero crossing*/
489 #define TDA9855_LINEAR 0 /* Linear Stereo */
490 #define TDA9855_PSEUDO 1 /* Pseudo Stereo */
491 #define TDA9855_SPAT_30 2 /* Spatial Stereo, 30% anti-phase crosstalk */
492 #define TDA9855_SPAT_50 3 /* Spatial Stereo, 52% anti-phase crosstalk */
493 #define TDA9855_E_MONO 7 /* Forced mono - mono select elseware, so useless*/
494
495 /* 0x07 - C7 - Control 3 in TDA9855, Control 4 in TDA9850 */
496 /* Common to both TDA9855 and TDA9850: */
497 /* lower 4 bits control input gain from -3.5dB (0x0) to 4dB (0xF)
498 * in .5dB steps - 0dB is 0x7 */
499
500 /* 0x08, 0x09 - A1 and A2 (read/write) */
501 /* Common to both TDA9855 and TDA9850: */
502 /* lower 5 bites are wideband and spectral expander alignment
503 * from 0x00 to 0x1f - nominal at 0x0f and 0x10 (read/write) */
504 #define TDA985x_STP 1<<5 /* Stereo Pilot/detect (read-only) */
505 #define TDA985x_SAPP 1<<6 /* SAP Pilot/detect (read-only) */
506 #define TDA985x_STS 1<<7 /* Stereo trigger 1= <35mV 0= <30mV (write-only)*/
507
508 /* 0x0a - A3 */
509 /* Common to both TDA9855 and TDA9850: */
510 /* lower 3 bits control timing current for alignment: -30% (0x0), -20% (0x1),
511 * -10% (0x2), nominal (0x3), +10% (0x6), +20% (0x5), +30% (0x4) */
512 #define TDA985x_ADJ 1<<7 /* Stereo adjust on/off (wideband and spectral */
513
514 static int tda9855_volume(int val) { return val/0x2e8+0x27; }
515 static int tda9855_bass(int val) { return val/0xccc+0x06; }
516 static int tda9855_treble(int val) { return (val/0x1c71+0x3)<<1; }
517
518 static int tda985x_getmode(struct CHIPSTATE *chip)
519 {
520 int mode;
521
522 mode = ((TDA985x_STP | TDA985x_SAPP) &
523 chip_read(chip)) >> 4;
524 /* Add mono mode regardless of SAP and stereo */
525 /* Allows forced mono */
526 return mode | V4L2_TUNER_MODE_MONO;
527 }
528
529 static void tda985x_setmode(struct CHIPSTATE *chip, int mode)
530 {
531 int update = 1;
532 int c6 = chip->shadow.bytes[TDA985x_C6+1] & 0x3f;
533
534 switch (mode) {
535 case V4L2_TUNER_MODE_MONO:
536 c6 |= TDA985x_MONO;
537 break;
538 case V4L2_TUNER_MODE_STEREO:
539 c6 |= TDA985x_STEREO;
540 break;
541 case V4L2_TUNER_MODE_LANG1:
542 c6 |= TDA985x_SAP;
543 break;
544 default:
545 update = 0;
546 }
547 if (update)
548 chip_write(chip,TDA985x_C6,c6);
549 }
550
551
552 /* ---------------------------------------------------------------------- */
553 /* audio chip descriptions - defines+functions for tda9873h */
554
555 /* Subaddresses for TDA9873H */
556
557 #define TDA9873_SW 0x00 /* Switching */
558 #define TDA9873_AD 0x01 /* Adjust */
559 #define TDA9873_PT 0x02 /* Port */
560
561 /* Subaddress 0x00: Switching Data
562 * B7..B0:
563 *
564 * B1, B0: Input source selection
565 * 0, 0 internal
566 * 1, 0 external stereo
567 * 0, 1 external mono
568 */
569 #define TDA9873_INP_MASK 3
570 #define TDA9873_INTERNAL 0
571 #define TDA9873_EXT_STEREO 2
572 #define TDA9873_EXT_MONO 1
573
574 /* B3, B2: output signal select
575 * B4 : transmission mode
576 * 0, 0, 1 Mono
577 * 1, 0, 0 Stereo
578 * 1, 1, 1 Stereo (reversed channel)
579 * 0, 0, 0 Dual AB
580 * 0, 0, 1 Dual AA
581 * 0, 1, 0 Dual BB
582 * 0, 1, 1 Dual BA
583 */
584
585 #define TDA9873_TR_MASK (7 << 2)
586 #define TDA9873_TR_MONO 4
587 #define TDA9873_TR_STEREO 1 << 4
588 #define TDA9873_TR_REVERSE (1 << 3) & (1 << 2)
589 #define TDA9873_TR_DUALA 1 << 2
590 #define TDA9873_TR_DUALB 1 << 3
591
592 /* output level controls
593 * B5: output level switch (0 = reduced gain, 1 = normal gain)
594 * B6: mute (1 = muted)
595 * B7: auto-mute (1 = auto-mute enabled)
596 */
597
598 #define TDA9873_GAIN_NORMAL 1 << 5
599 #define TDA9873_MUTE 1 << 6
600 #define TDA9873_AUTOMUTE 1 << 7
601
602 /* Subaddress 0x01: Adjust/standard */
603
604 /* Lower 4 bits (C3..C0) control stereo adjustment on R channel (-0.6 - +0.7 dB)
605 * Recommended value is +0 dB
606 */
607
608 #define TDA9873_STEREO_ADJ 0x06 /* 0dB gain */
609
610 /* Bits C6..C4 control FM stantard
611 * C6, C5, C4
612 * 0, 0, 0 B/G (PAL FM)
613 * 0, 0, 1 M
614 * 0, 1, 0 D/K(1)
615 * 0, 1, 1 D/K(2)
616 * 1, 0, 0 D/K(3)
617 * 1, 0, 1 I
618 */
619 #define TDA9873_BG 0
620 #define TDA9873_M 1
621 #define TDA9873_DK1 2
622 #define TDA9873_DK2 3
623 #define TDA9873_DK3 4
624 #define TDA9873_I 5
625
626 /* C7 controls identification response time (1=fast/0=normal)
627 */
628 #define TDA9873_IDR_NORM 0
629 #define TDA9873_IDR_FAST 1 << 7
630
631
632 /* Subaddress 0x02: Port data */
633
634 /* E1, E0 free programmable ports P1/P2
635 0, 0 both ports low
636 0, 1 P1 high
637 1, 0 P2 high
638 1, 1 both ports high
639 */
640
641 #define TDA9873_PORTS 3
642
643 /* E2: test port */
644 #define TDA9873_TST_PORT 1 << 2
645
646 /* E5..E3 control mono output channel (together with transmission mode bit B4)
647 *
648 * E5 E4 E3 B4 OUTM
649 * 0 0 0 0 mono
650 * 0 0 1 0 DUAL B
651 * 0 1 0 1 mono (from stereo decoder)
652 */
653 #define TDA9873_MOUT_MONO 0
654 #define TDA9873_MOUT_FMONO 0
655 #define TDA9873_MOUT_DUALA 0
656 #define TDA9873_MOUT_DUALB 1 << 3
657 #define TDA9873_MOUT_ST 1 << 4
658 #define TDA9873_MOUT_EXTM (1 << 4 ) & (1 << 3)
659 #define TDA9873_MOUT_EXTL 1 << 5
660 #define TDA9873_MOUT_EXTR (1 << 5 ) & (1 << 3)
661 #define TDA9873_MOUT_EXTLR (1 << 5 ) & (1 << 4)
662 #define TDA9873_MOUT_MUTE (1 << 5 ) & (1 << 4) & (1 << 3)
663
664 /* Status bits: (chip read) */
665 #define TDA9873_PONR 0 /* Power-on reset detected if = 1 */
666 #define TDA9873_STEREO 2 /* Stereo sound is identified */
667 #define TDA9873_DUAL 4 /* Dual sound is identified */
668
669 static int tda9873_getmode(struct CHIPSTATE *chip)
670 {
671 int val,mode;
672
673 val = chip_read(chip);
674 mode = V4L2_TUNER_MODE_MONO;
675 if (val & TDA9873_STEREO)
676 mode |= V4L2_TUNER_MODE_STEREO;
677 if (val & TDA9873_DUAL)
678 mode |= V4L2_TUNER_MODE_LANG1 | V4L2_TUNER_MODE_LANG2;
679 v4l_dbg(1, debug, chip->c, "tda9873_getmode(): raw chip read: %d, return: %d\n",
680 val, mode);
681 return mode;
682 }
683
684 static void tda9873_setmode(struct CHIPSTATE *chip, int mode)
685 {
686 int sw_data = chip->shadow.bytes[TDA9873_SW+1] & ~ TDA9873_TR_MASK;
687 /* int adj_data = chip->shadow.bytes[TDA9873_AD+1] ; */
688
689 if ((sw_data & TDA9873_INP_MASK) != TDA9873_INTERNAL) {
690 v4l_dbg(1, debug, chip->c, "tda9873_setmode(): external input\n");
691 return;
692 }
693
694 v4l_dbg(1, debug, chip->c, "tda9873_setmode(): chip->shadow.bytes[%d] = %d\n", TDA9873_SW+1, chip->shadow.bytes[TDA9873_SW+1]);
695 v4l_dbg(1, debug, chip->c, "tda9873_setmode(): sw_data = %d\n", sw_data);
696
697 switch (mode) {
698 case V4L2_TUNER_MODE_MONO:
699 sw_data |= TDA9873_TR_MONO;
700 break;
701 case V4L2_TUNER_MODE_STEREO:
702 sw_data |= TDA9873_TR_STEREO;
703 break;
704 case V4L2_TUNER_MODE_LANG1:
705 sw_data |= TDA9873_TR_DUALA;
706 break;
707 case V4L2_TUNER_MODE_LANG2:
708 sw_data |= TDA9873_TR_DUALB;
709 break;
710 default:
711 chip->mode = 0;
712 return;
713 }
714
715 chip_write(chip, TDA9873_SW, sw_data);
716 v4l_dbg(1, debug, chip->c, "tda9873_setmode(): req. mode %d; chip_write: %d\n",
717 mode, sw_data);
718 }
719
720 static int tda9873_checkit(struct CHIPSTATE *chip)
721 {
722 int rc;
723
724 if (-1 == (rc = chip_read2(chip,254)))
725 return 0;
726 return (rc & ~0x1f) == 0x80;
727 }
728
729
730 /* ---------------------------------------------------------------------- */
731 /* audio chip description - defines+functions for tda9874h and tda9874a */
732 /* Dariusz Kowalewski <darekk@automex.pl> */
733
734 /* Subaddresses for TDA9874H and TDA9874A (slave rx) */
735 #define TDA9874A_AGCGR 0x00 /* AGC gain */
736 #define TDA9874A_GCONR 0x01 /* general config */
737 #define TDA9874A_MSR 0x02 /* monitor select */
738 #define TDA9874A_C1FRA 0x03 /* carrier 1 freq. */
739 #define TDA9874A_C1FRB 0x04 /* carrier 1 freq. */
740 #define TDA9874A_C1FRC 0x05 /* carrier 1 freq. */
741 #define TDA9874A_C2FRA 0x06 /* carrier 2 freq. */
742 #define TDA9874A_C2FRB 0x07 /* carrier 2 freq. */
743 #define TDA9874A_C2FRC 0x08 /* carrier 2 freq. */
744 #define TDA9874A_DCR 0x09 /* demodulator config */
745 #define TDA9874A_FMER 0x0a /* FM de-emphasis */
746 #define TDA9874A_FMMR 0x0b /* FM dematrix */
747 #define TDA9874A_C1OLAR 0x0c /* ch.1 output level adj. */
748 #define TDA9874A_C2OLAR 0x0d /* ch.2 output level adj. */
749 #define TDA9874A_NCONR 0x0e /* NICAM config */
750 #define TDA9874A_NOLAR 0x0f /* NICAM output level adj. */
751 #define TDA9874A_NLELR 0x10 /* NICAM lower error limit */
752 #define TDA9874A_NUELR 0x11 /* NICAM upper error limit */
753 #define TDA9874A_AMCONR 0x12 /* audio mute control */
754 #define TDA9874A_SDACOSR 0x13 /* stereo DAC output select */
755 #define TDA9874A_AOSR 0x14 /* analog output select */
756 #define TDA9874A_DAICONR 0x15 /* digital audio interface config */
757 #define TDA9874A_I2SOSR 0x16 /* I2S-bus output select */
758 #define TDA9874A_I2SOLAR 0x17 /* I2S-bus output level adj. */
759 #define TDA9874A_MDACOSR 0x18 /* mono DAC output select (tda9874a) */
760 #define TDA9874A_ESP 0xFF /* easy standard progr. (tda9874a) */
761
762 /* Subaddresses for TDA9874H and TDA9874A (slave tx) */
763 #define TDA9874A_DSR 0x00 /* device status */
764 #define TDA9874A_NSR 0x01 /* NICAM status */
765 #define TDA9874A_NECR 0x02 /* NICAM error count */
766 #define TDA9874A_DR1 0x03 /* add. data LSB */
767 #define TDA9874A_DR2 0x04 /* add. data MSB */
768 #define TDA9874A_LLRA 0x05 /* monitor level read-out LSB */
769 #define TDA9874A_LLRB 0x06 /* monitor level read-out MSB */
770 #define TDA9874A_SIFLR 0x07 /* SIF level */
771 #define TDA9874A_TR2 252 /* test reg. 2 */
772 #define TDA9874A_TR1 253 /* test reg. 1 */
773 #define TDA9874A_DIC 254 /* device id. code */
774 #define TDA9874A_SIC 255 /* software id. code */
775
776
777 static int tda9874a_mode = 1; /* 0: A2, 1: NICAM */
778 static int tda9874a_GCONR = 0xc0; /* default config. input pin: SIFSEL=0 */
779 static int tda9874a_NCONR = 0x01; /* default NICAM config.: AMSEL=0,AMUTE=1 */
780 static int tda9874a_ESP = 0x07; /* default standard: NICAM D/K */
781 static int tda9874a_dic = -1; /* device id. code */
782
783 /* insmod options for tda9874a */
784 static unsigned int tda9874a_SIF = UNSET;
785 static unsigned int tda9874a_AMSEL = UNSET;
786 static unsigned int tda9874a_STD = UNSET;
787 module_param(tda9874a_SIF, int, 0444);
788 module_param(tda9874a_AMSEL, int, 0444);
789 module_param(tda9874a_STD, int, 0444);
790
791 /*
792 * initialization table for tda9874 decoder:
793 * - carrier 1 freq. registers (3 bytes)
794 * - carrier 2 freq. registers (3 bytes)
795 * - demudulator config register
796 * - FM de-emphasis register (slow identification mode)
797 * Note: frequency registers must be written in single i2c transfer.
798 */
799 static struct tda9874a_MODES {
800 char *name;
801 audiocmd cmd;
802 } tda9874a_modelist[9] = {
803 { "A2, B/G", /* default */
804 { 9, { TDA9874A_C1FRA, 0x72,0x95,0x55, 0x77,0xA0,0x00, 0x00,0x00 }} },
805 { "A2, M (Korea)",
806 { 9, { TDA9874A_C1FRA, 0x5D,0xC0,0x00, 0x62,0x6A,0xAA, 0x20,0x22 }} },
807 { "A2, D/K (1)",
808 { 9, { TDA9874A_C1FRA, 0x87,0x6A,0xAA, 0x82,0x60,0x00, 0x00,0x00 }} },
809 { "A2, D/K (2)",
810 { 9, { TDA9874A_C1FRA, 0x87,0x6A,0xAA, 0x8C,0x75,0x55, 0x00,0x00 }} },
811 { "A2, D/K (3)",
812 { 9, { TDA9874A_C1FRA, 0x87,0x6A,0xAA, 0x77,0xA0,0x00, 0x00,0x00 }} },
813 { "NICAM, I",
814 { 9, { TDA9874A_C1FRA, 0x7D,0x00,0x00, 0x88,0x8A,0xAA, 0x08,0x33 }} },
815 { "NICAM, B/G",
816 { 9, { TDA9874A_C1FRA, 0x72,0x95,0x55, 0x79,0xEA,0xAA, 0x08,0x33 }} },
817 { "NICAM, D/K",
818 { 9, { TDA9874A_C1FRA, 0x87,0x6A,0xAA, 0x79,0xEA,0xAA, 0x08,0x33 }} },
819 { "NICAM, L",
820 { 9, { TDA9874A_C1FRA, 0x87,0x6A,0xAA, 0x79,0xEA,0xAA, 0x09,0x33 }} }
821 };
822
823 static int tda9874a_setup(struct CHIPSTATE *chip)
824 {
825 chip_write(chip, TDA9874A_AGCGR, 0x00); /* 0 dB */
826 chip_write(chip, TDA9874A_GCONR, tda9874a_GCONR);
827 chip_write(chip, TDA9874A_MSR, (tda9874a_mode) ? 0x03:0x02);
828 if(tda9874a_dic == 0x11) {
829 chip_write(chip, TDA9874A_FMMR, 0x80);
830 } else { /* dic == 0x07 */
831 chip_cmd(chip,"tda9874_modelist",&tda9874a_modelist[tda9874a_STD].cmd);
832 chip_write(chip, TDA9874A_FMMR, 0x00);
833 }
834 chip_write(chip, TDA9874A_C1OLAR, 0x00); /* 0 dB */
835 chip_write(chip, TDA9874A_C2OLAR, 0x00); /* 0 dB */
836 chip_write(chip, TDA9874A_NCONR, tda9874a_NCONR);
837 chip_write(chip, TDA9874A_NOLAR, 0x00); /* 0 dB */
838 /* Note: If signal quality is poor you may want to change NICAM */
839 /* error limit registers (NLELR and NUELR) to some greater values. */
840 /* Then the sound would remain stereo, but won't be so clear. */
841 chip_write(chip, TDA9874A_NLELR, 0x14); /* default */
842 chip_write(chip, TDA9874A_NUELR, 0x50); /* default */
843
844 if(tda9874a_dic == 0x11) {
845 chip_write(chip, TDA9874A_AMCONR, 0xf9);
846 chip_write(chip, TDA9874A_SDACOSR, (tda9874a_mode) ? 0x81:0x80);
847 chip_write(chip, TDA9874A_AOSR, 0x80);
848 chip_write(chip, TDA9874A_MDACOSR, (tda9874a_mode) ? 0x82:0x80);
849 chip_write(chip, TDA9874A_ESP, tda9874a_ESP);
850 } else { /* dic == 0x07 */
851 chip_write(chip, TDA9874A_AMCONR, 0xfb);
852 chip_write(chip, TDA9874A_SDACOSR, (tda9874a_mode) ? 0x81:0x80);
853 chip_write(chip, TDA9874A_AOSR, 0x00); /* or 0x10 */
854 }
855 v4l_dbg(1, debug, chip->c, "tda9874a_setup(): %s [0x%02X].\n",
856 tda9874a_modelist[tda9874a_STD].name,tda9874a_STD);
857 return 1;
858 }
859
860 static int tda9874a_getmode(struct CHIPSTATE *chip)
861 {
862 int dsr,nsr,mode;
863 int necr; /* just for debugging */
864
865 mode = V4L2_TUNER_MODE_MONO;
866
867 if(-1 == (dsr = chip_read2(chip,TDA9874A_DSR)))
868 return mode;
869 if(-1 == (nsr = chip_read2(chip,TDA9874A_NSR)))
870 return mode;
871 if(-1 == (necr = chip_read2(chip,TDA9874A_NECR)))
872 return mode;
873
874 /* need to store dsr/nsr somewhere */
875 chip->shadow.bytes[MAXREGS-2] = dsr;
876 chip->shadow.bytes[MAXREGS-1] = nsr;
877
878 if(tda9874a_mode) {
879 /* Note: DSR.RSSF and DSR.AMSTAT bits are also checked.
880 * If NICAM auto-muting is enabled, DSR.AMSTAT=1 indicates
881 * that sound has (temporarily) switched from NICAM to
882 * mono FM (or AM) on 1st sound carrier due to high NICAM bit
883 * error count. So in fact there is no stereo in this case :-(
884 * But changing the mode to V4L2_TUNER_MODE_MONO would switch
885 * external 4052 multiplexer in audio_hook().
886 */
887 if(nsr & 0x02) /* NSR.S/MB=1 */
888 mode |= V4L2_TUNER_MODE_STEREO;
889 if(nsr & 0x01) /* NSR.D/SB=1 */
890 mode |= V4L2_TUNER_MODE_LANG1 | V4L2_TUNER_MODE_LANG2;
891 } else {
892 if(dsr & 0x02) /* DSR.IDSTE=1 */
893 mode |= V4L2_TUNER_MODE_STEREO;
894 if(dsr & 0x04) /* DSR.IDDUA=1 */
895 mode |= V4L2_TUNER_MODE_LANG1 | V4L2_TUNER_MODE_LANG2;
896 }
897
898 v4l_dbg(1, debug, chip->c, "tda9874a_getmode(): DSR=0x%X, NSR=0x%X, NECR=0x%X, return: %d.\n",
899 dsr, nsr, necr, mode);
900 return mode;
901 }
902
903 static void tda9874a_setmode(struct CHIPSTATE *chip, int mode)
904 {
905 /* Disable/enable NICAM auto-muting (based on DSR.RSSF status bit). */
906 /* If auto-muting is disabled, we can hear a signal of degrading quality. */
907 if(tda9874a_mode) {
908 if(chip->shadow.bytes[MAXREGS-2] & 0x20) /* DSR.RSSF=1 */
909 tda9874a_NCONR &= 0xfe; /* enable */
910 else
911 tda9874a_NCONR |= 0x01; /* disable */
912 chip_write(chip, TDA9874A_NCONR, tda9874a_NCONR);
913 }
914
915 /* Note: TDA9874A supports automatic FM dematrixing (FMMR register)
916 * and has auto-select function for audio output (AOSR register).
917 * Old TDA9874H doesn't support these features.
918 * TDA9874A also has additional mono output pin (OUTM), which
919 * on same (all?) tv-cards is not used, anyway (as well as MONOIN).
920 */
921 if(tda9874a_dic == 0x11) {
922 int aosr = 0x80;
923 int mdacosr = (tda9874a_mode) ? 0x82:0x80;
924
925 switch(mode) {
926 case V4L2_TUNER_MODE_MONO:
927 case V4L2_TUNER_MODE_STEREO:
928 break;
929 case V4L2_TUNER_MODE_LANG1:
930 aosr = 0x80; /* auto-select, dual A/A */
931 mdacosr = (tda9874a_mode) ? 0x82:0x80;
932 break;
933 case V4L2_TUNER_MODE_LANG2:
934 aosr = 0xa0; /* auto-select, dual B/B */
935 mdacosr = (tda9874a_mode) ? 0x83:0x81;
936 break;
937 default:
938 chip->mode = 0;
939 return;
940 }
941 chip_write(chip, TDA9874A_AOSR, aosr);
942 chip_write(chip, TDA9874A_MDACOSR, mdacosr);
943
944 v4l_dbg(1, debug, chip->c, "tda9874a_setmode(): req. mode %d; AOSR=0x%X, MDACOSR=0x%X.\n",
945 mode, aosr, mdacosr);
946
947 } else { /* dic == 0x07 */
948 int fmmr,aosr;
949
950 switch(mode) {
951 case V4L2_TUNER_MODE_MONO:
952 fmmr = 0x00; /* mono */
953 aosr = 0x10; /* A/A */
954 break;
955 case V4L2_TUNER_MODE_STEREO:
956 if(tda9874a_mode) {
957 fmmr = 0x00;
958 aosr = 0x00; /* handled by NICAM auto-mute */
959 } else {
960 fmmr = (tda9874a_ESP == 1) ? 0x05 : 0x04; /* stereo */
961 aosr = 0x00;
962 }
963 break;
964 case V4L2_TUNER_MODE_LANG1:
965 fmmr = 0x02; /* dual */
966 aosr = 0x10; /* dual A/A */
967 break;
968 case V4L2_TUNER_MODE_LANG2:
969 fmmr = 0x02; /* dual */
970 aosr = 0x20; /* dual B/B */
971 break;
972 default:
973 chip->mode = 0;
974 return;
975 }
976 chip_write(chip, TDA9874A_FMMR, fmmr);
977 chip_write(chip, TDA9874A_AOSR, aosr);
978
979 v4l_dbg(1, debug, chip->c, "tda9874a_setmode(): req. mode %d; FMMR=0x%X, AOSR=0x%X.\n",
980 mode, fmmr, aosr);
981 }
982 }
983
984 static int tda9874a_checkit(struct CHIPSTATE *chip)
985 {
986 int dic,sic; /* device id. and software id. codes */
987
988 if(-1 == (dic = chip_read2(chip,TDA9874A_DIC)))
989 return 0;
990 if(-1 == (sic = chip_read2(chip,TDA9874A_SIC)))
991 return 0;
992
993 v4l_dbg(1, debug, chip->c, "tda9874a_checkit(): DIC=0x%X, SIC=0x%X.\n", dic, sic);
994
995 if((dic == 0x11)||(dic == 0x07)) {
996 v4l_info(chip->c, "found tda9874%s.\n", (dic == 0x11) ? "a":"h");
997 tda9874a_dic = dic; /* remember device id. */
998 return 1;
999 }
1000 return 0; /* not found */
1001 }
1002
1003 static int tda9874a_initialize(struct CHIPSTATE *chip)
1004 {
1005 if (tda9874a_SIF > 2)
1006 tda9874a_SIF = 1;
1007 if (tda9874a_STD >= ARRAY_SIZE(tda9874a_modelist))
1008 tda9874a_STD = 0;
1009 if(tda9874a_AMSEL > 1)
1010 tda9874a_AMSEL = 0;
1011
1012 if(tda9874a_SIF == 1)
1013 tda9874a_GCONR = 0xc0; /* sound IF input 1 */
1014 else
1015 tda9874a_GCONR = 0xc1; /* sound IF input 2 */
1016
1017 tda9874a_ESP = tda9874a_STD;
1018 tda9874a_mode = (tda9874a_STD < 5) ? 0 : 1;
1019
1020 if(tda9874a_AMSEL == 0)
1021 tda9874a_NCONR = 0x01; /* auto-mute: analog mono input */
1022 else
1023 tda9874a_NCONR = 0x05; /* auto-mute: 1st carrier FM or AM */
1024
1025 tda9874a_setup(chip);
1026 return 0;
1027 }
1028
1029
1030 /* ---------------------------------------------------------------------- */
1031 /* audio chip descriptions - defines+functions for tea6420 */
1032
1033 #define TEA6300_VL 0x00 /* volume left */
1034 #define TEA6300_VR 0x01 /* volume right */
1035 #define TEA6300_BA 0x02 /* bass */
1036 #define TEA6300_TR 0x03 /* treble */
1037 #define TEA6300_FA 0x04 /* fader control */
1038 #define TEA6300_S 0x05 /* switch register */
1039 /* values for those registers: */
1040 #define TEA6300_S_SA 0x01 /* stereo A input */
1041 #define TEA6300_S_SB 0x02 /* stereo B */
1042 #define TEA6300_S_SC 0x04 /* stereo C */
1043 #define TEA6300_S_GMU 0x80 /* general mute */
1044
1045 #define TEA6320_V 0x00 /* volume (0-5)/loudness off (6)/zero crossing mute(7) */
1046 #define TEA6320_FFR 0x01 /* fader front right (0-5) */
1047 #define TEA6320_FFL 0x02 /* fader front left (0-5) */
1048 #define TEA6320_FRR 0x03 /* fader rear right (0-5) */
1049 #define TEA6320_FRL 0x04 /* fader rear left (0-5) */
1050 #define TEA6320_BA 0x05 /* bass (0-4) */
1051 #define TEA6320_TR 0x06 /* treble (0-4) */
1052 #define TEA6320_S 0x07 /* switch register */
1053 /* values for those registers: */
1054 #define TEA6320_S_SA 0x07 /* stereo A input */
1055 #define TEA6320_S_SB 0x06 /* stereo B */
1056 #define TEA6320_S_SC 0x05 /* stereo C */
1057 #define TEA6320_S_SD 0x04 /* stereo D */
1058 #define TEA6320_S_GMU 0x80 /* general mute */
1059
1060 #define TEA6420_S_SA 0x00 /* stereo A input */
1061 #define TEA6420_S_SB 0x01 /* stereo B */
1062 #define TEA6420_S_SC 0x02 /* stereo C */
1063 #define TEA6420_S_SD 0x03 /* stereo D */
1064 #define TEA6420_S_SE 0x04 /* stereo E */
1065 #define TEA6420_S_GMU 0x05 /* general mute */
1066
1067 static int tea6300_shift10(int val) { return val >> 10; }
1068 static int tea6300_shift12(int val) { return val >> 12; }
1069
1070 /* Assumes 16bit input (values 0x3f to 0x0c are unique, values less than */
1071 /* 0x0c mirror those immediately higher) */
1072 static int tea6320_volume(int val) { return (val / (65535/(63-12)) + 12) & 0x3f; }
1073 static int tea6320_shift11(int val) { return val >> 11; }
1074 static int tea6320_initialize(struct CHIPSTATE * chip)
1075 {
1076 chip_write(chip, TEA6320_FFR, 0x3f);
1077 chip_write(chip, TEA6320_FFL, 0x3f);
1078 chip_write(chip, TEA6320_FRR, 0x3f);
1079 chip_write(chip, TEA6320_FRL, 0x3f);
1080
1081 return 0;
1082 }
1083
1084
1085 /* ---------------------------------------------------------------------- */
1086 /* audio chip descriptions - defines+functions for tda8425 */
1087
1088 #define TDA8425_VL 0x00 /* volume left */
1089 #define TDA8425_VR 0x01 /* volume right */
1090 #define TDA8425_BA 0x02 /* bass */
1091 #define TDA8425_TR 0x03 /* treble */
1092 #define TDA8425_S1 0x08 /* switch functions */
1093 /* values for those registers: */
1094 #define TDA8425_S1_OFF 0xEE /* audio off (mute on) */
1095 #define TDA8425_S1_CH1 0xCE /* audio channel 1 (mute off) - "linear stereo" mode */
1096 #define TDA8425_S1_CH2 0xCF /* audio channel 2 (mute off) - "linear stereo" mode */
1097 #define TDA8425_S1_MU 0x20 /* mute bit */
1098 #define TDA8425_S1_STEREO 0x18 /* stereo bits */
1099 #define TDA8425_S1_STEREO_SPATIAL 0x18 /* spatial stereo */
1100 #define TDA8425_S1_STEREO_LINEAR 0x08 /* linear stereo */
1101 #define TDA8425_S1_STEREO_PSEUDO 0x10 /* pseudo stereo */
1102 #define TDA8425_S1_STEREO_MONO 0x00 /* forced mono */
1103 #define TDA8425_S1_ML 0x06 /* language selector */
1104 #define TDA8425_S1_ML_SOUND_A 0x02 /* sound a */
1105 #define TDA8425_S1_ML_SOUND_B 0x04 /* sound b */
1106 #define TDA8425_S1_ML_STEREO 0x06 /* stereo */
1107 #define TDA8425_S1_IS 0x01 /* channel selector */
1108
1109
1110 static int tda8425_shift10(int val) { return (val >> 10) | 0xc0; }
1111 static int tda8425_shift12(int val) { return (val >> 12) | 0xf0; }
1112
1113 static int tda8425_initialize(struct CHIPSTATE *chip)
1114 {
1115 struct CHIPDESC *desc = chip->desc;
1116 int inputmap[4] = { /* tuner */ TDA8425_S1_CH2, /* radio */ TDA8425_S1_CH1,
1117 /* extern */ TDA8425_S1_CH1, /* intern */ TDA8425_S1_OFF};
1118
1119 if (chip->c->adapter->id == I2C_HW_B_RIVA) {
1120 memcpy (desc->inputmap, inputmap, sizeof (inputmap));
1121 }
1122 return 0;
1123 }
1124
1125 static void tda8425_setmode(struct CHIPSTATE *chip, int mode)
1126 {
1127 int s1 = chip->shadow.bytes[TDA8425_S1+1] & 0xe1;
1128
1129 if (mode & V4L2_TUNER_MODE_LANG1) {
1130 s1 |= TDA8425_S1_ML_SOUND_A;
1131 s1 |= TDA8425_S1_STEREO_PSEUDO;
1132
1133 } else if (mode & V4L2_TUNER_MODE_LANG2) {
1134 s1 |= TDA8425_S1_ML_SOUND_B;
1135 s1 |= TDA8425_S1_STEREO_PSEUDO;
1136
1137 } else {
1138 s1 |= TDA8425_S1_ML_STEREO;
1139
1140 if (mode & V4L2_TUNER_MODE_MONO)
1141 s1 |= TDA8425_S1_STEREO_MONO;
1142 if (mode & V4L2_TUNER_MODE_STEREO)
1143 s1 |= TDA8425_S1_STEREO_SPATIAL;
1144 }
1145 chip_write(chip,TDA8425_S1,s1);
1146 }
1147
1148
1149 /* ---------------------------------------------------------------------- */
1150 /* audio chip descriptions - defines+functions for pic16c54 (PV951) */
1151
1152 /* the registers of 16C54, I2C sub address. */
1153 #define PIC16C54_REG_KEY_CODE 0x01 /* Not use. */
1154 #define PIC16C54_REG_MISC 0x02
1155
1156 /* bit definition of the RESET register, I2C data. */
1157 #define PIC16C54_MISC_RESET_REMOTE_CTL 0x01 /* bit 0, Reset to receive the key */
1158 /* code of remote controller */
1159 #define PIC16C54_MISC_MTS_MAIN 0x02 /* bit 1 */
1160 #define PIC16C54_MISC_MTS_SAP 0x04 /* bit 2 */
1161 #define PIC16C54_MISC_MTS_BOTH 0x08 /* bit 3 */
1162 #define PIC16C54_MISC_SND_MUTE 0x10 /* bit 4, Mute Audio(Line-in and Tuner) */
1163 #define PIC16C54_MISC_SND_NOTMUTE 0x20 /* bit 5 */
1164 #define PIC16C54_MISC_SWITCH_TUNER 0x40 /* bit 6 , Switch to Line-in */
1165 #define PIC16C54_MISC_SWITCH_LINE 0x80 /* bit 7 , Switch to Tuner */
1166
1167 /* ---------------------------------------------------------------------- */
1168 /* audio chip descriptions - defines+functions for TA8874Z */
1169
1170 /* write 1st byte */
1171 #define TA8874Z_LED_STE 0x80
1172 #define TA8874Z_LED_BIL 0x40
1173 #define TA8874Z_LED_EXT 0x20
1174 #define TA8874Z_MONO_SET 0x10
1175 #define TA8874Z_MUTE 0x08
1176 #define TA8874Z_F_MONO 0x04
1177 #define TA8874Z_MODE_SUB 0x02
1178 #define TA8874Z_MODE_MAIN 0x01
1179
1180 /* write 2nd byte */
1181 /*#define TA8874Z_TI 0x80 */ /* test mode */
1182 #define TA8874Z_SEPARATION 0x3f
1183 #define TA8874Z_SEPARATION_DEFAULT 0x10
1184
1185 /* read */
1186 #define TA8874Z_B1 0x80
1187 #define TA8874Z_B0 0x40
1188 #define TA8874Z_CHAG_FLAG 0x20
1189
1190 /*
1191 * B1 B0
1192 * mono L H
1193 * stereo L L
1194 * BIL H L
1195 */
1196 static int ta8874z_getmode(struct CHIPSTATE *chip)
1197 {
1198 int val, mode;
1199
1200 val = chip_read(chip);
1201 mode = V4L2_TUNER_MODE_MONO;
1202 if (val & TA8874Z_B1){
1203 mode |= V4L2_TUNER_MODE_LANG1 | V4L2_TUNER_MODE_LANG2;
1204 }else if (!(val & TA8874Z_B0)){
1205 mode |= V4L2_TUNER_MODE_STEREO;
1206 }
1207 /* v4l_dbg(1, debug, chip->c, "ta8874z_getmode(): raw chip read: 0x%02x, return: 0x%02x\n", val, mode); */
1208 return mode;
1209 }
1210
1211 static audiocmd ta8874z_stereo = { 2, {0, TA8874Z_SEPARATION_DEFAULT}};
1212 static audiocmd ta8874z_mono = {2, { TA8874Z_MONO_SET, TA8874Z_SEPARATION_DEFAULT}};
1213 static audiocmd ta8874z_main = {2, { 0, TA8874Z_SEPARATION_DEFAULT}};
1214 static audiocmd ta8874z_sub = {2, { TA8874Z_MODE_SUB, TA8874Z_SEPARATION_DEFAULT}};
1215
1216 static void ta8874z_setmode(struct CHIPSTATE *chip, int mode)
1217 {
1218 int update = 1;
1219 audiocmd *t = NULL;
1220 v4l_dbg(1, debug, chip->c, "ta8874z_setmode(): mode: 0x%02x\n", mode);
1221
1222 switch(mode){
1223 case V4L2_TUNER_MODE_MONO:
1224 t = &ta8874z_mono;
1225 break;
1226 case V4L2_TUNER_MODE_STEREO:
1227 t = &ta8874z_stereo;
1228 break;
1229 case V4L2_TUNER_MODE_LANG1:
1230 t = &ta8874z_main;
1231 break;
1232 case V4L2_TUNER_MODE_LANG2:
1233 t = &ta8874z_sub;
1234 break;
1235 default:
1236 update = 0;
1237 }
1238
1239 if(update)
1240 chip_cmd(chip, "TA8874Z", t);
1241 }
1242
1243 static int ta8874z_checkit(struct CHIPSTATE *chip)
1244 {
1245 int rc;
1246 rc = chip_read(chip);
1247 return ((rc & 0x1f) == 0x1f) ? 1 : 0;
1248 }
1249
1250 /* ---------------------------------------------------------------------- */
1251 /* audio chip descriptions - struct CHIPDESC */
1252
1253 /* insmod options to enable/disable individual audio chips */
1254 static int tda8425 = 1;
1255 static int tda9840 = 1;
1256 static int tda9850 = 1;
1257 static int tda9855 = 1;
1258 static int tda9873 = 1;
1259 static int tda9874a = 1;
1260 static int tea6300; /* default 0 - address clash with msp34xx */
1261 static int tea6320; /* default 0 - address clash with msp34xx */
1262 static int tea6420 = 1;
1263 static int pic16c54 = 1;
1264 static int ta8874z; /* default 0 - address clash with tda9840 */
1265
1266 module_param(tda8425, int, 0444);
1267 module_param(tda9840, int, 0444);
1268 module_param(tda9850, int, 0444);
1269 module_param(tda9855, int, 0444);
1270 module_param(tda9873, int, 0444);
1271 module_param(tda9874a, int, 0444);
1272 module_param(tea6300, int, 0444);
1273 module_param(tea6320, int, 0444);
1274 module_param(tea6420, int, 0444);
1275 module_param(pic16c54, int, 0444);
1276 module_param(ta8874z, int, 0444);
1277
1278 static struct CHIPDESC chiplist[] = {
1279 {
1280 .name = "tda9840",
1281 .insmodopt = &tda9840,
1282 .addr_lo = I2C_ADDR_TDA9840 >> 1,
1283 .addr_hi = I2C_ADDR_TDA9840 >> 1,
1284 .registers = 5,
1285 .flags = CHIP_NEED_CHECKMODE,
1286
1287 /* callbacks */
1288 .checkit = tda9840_checkit,
1289 .getmode = tda9840_getmode,
1290 .setmode = tda9840_setmode,
1291
1292 .init = { 2, { TDA9840_TEST, TDA9840_TEST_INT1SN
1293 /* ,TDA9840_SW, TDA9840_MONO */} }
1294 },
1295 {
1296 .name = "tda9873h",
1297 .insmodopt = &tda9873,
1298 .addr_lo = I2C_ADDR_TDA985x_L >> 1,
1299 .addr_hi = I2C_ADDR_TDA985x_H >> 1,
1300 .registers = 3,
1301 .flags = CHIP_HAS_INPUTSEL | CHIP_NEED_CHECKMODE,
1302
1303 /* callbacks */
1304 .checkit = tda9873_checkit,
1305 .getmode = tda9873_getmode,
1306 .setmode = tda9873_setmode,
1307
1308 .init = { 4, { TDA9873_SW, 0xa4, 0x06, 0x03 } },
1309 .inputreg = TDA9873_SW,
1310 .inputmute = TDA9873_MUTE | TDA9873_AUTOMUTE,
1311 .inputmap = {0xa0, 0xa2, 0xa0, 0xa0},
1312 .inputmask = TDA9873_INP_MASK|TDA9873_MUTE|TDA9873_AUTOMUTE,
1313
1314 },
1315 {
1316 .name = "tda9874h/a",
1317 .insmodopt = &tda9874a,
1318 .addr_lo = I2C_ADDR_TDA9874 >> 1,
1319 .addr_hi = I2C_ADDR_TDA9874 >> 1,
1320 .flags = CHIP_NEED_CHECKMODE,
1321
1322 /* callbacks */
1323 .initialize = tda9874a_initialize,
1324 .checkit = tda9874a_checkit,
1325 .getmode = tda9874a_getmode,
1326 .setmode = tda9874a_setmode,
1327 },
1328 {
1329 .name = "tda9850",
1330 .insmodopt = &tda9850,
1331 .addr_lo = I2C_ADDR_TDA985x_L >> 1,
1332 .addr_hi = I2C_ADDR_TDA985x_H >> 1,
1333 .registers = 11,
1334
1335 .getmode = tda985x_getmode,
1336 .setmode = tda985x_setmode,
1337
1338 .init = { 8, { TDA9850_C4, 0x08, 0x08, TDA985x_STEREO, 0x07, 0x10, 0x10, 0x03 } }
1339 },
1340 {
1341 .name = "tda9855",
1342 .insmodopt = &tda9855,
1343 .addr_lo = I2C_ADDR_TDA985x_L >> 1,
1344 .addr_hi = I2C_ADDR_TDA985x_H >> 1,
1345 .registers = 11,
1346 .flags = CHIP_HAS_VOLUME | CHIP_HAS_BASSTREBLE,
1347
1348 .leftreg = TDA9855_VL,
1349 .rightreg = TDA9855_VR,
1350 .bassreg = TDA9855_BA,
1351 .treblereg = TDA9855_TR,
1352
1353 /* callbacks */
1354 .volfunc = tda9855_volume,
1355 .bassfunc = tda9855_bass,
1356 .treblefunc = tda9855_treble,
1357 .getmode = tda985x_getmode,
1358 .setmode = tda985x_setmode,
1359
1360 .init = { 12, { 0, 0x6f, 0x6f, 0x0e, 0x07<<1, 0x8<<2,
1361 TDA9855_MUTE | TDA9855_AVL | TDA9855_LOUD | TDA9855_INT,
1362 TDA985x_STEREO | TDA9855_LINEAR | TDA9855_TZCM | TDA9855_VZCM,
1363 0x07, 0x10, 0x10, 0x03 }}
1364 },
1365 {
1366 .name = "tea6300",
1367 .insmodopt = &tea6300,
1368 .addr_lo = I2C_ADDR_TEA6300 >> 1,
1369 .addr_hi = I2C_ADDR_TEA6300 >> 1,
1370 .registers = 6,
1371 .flags = CHIP_HAS_VOLUME | CHIP_HAS_BASSTREBLE | CHIP_HAS_INPUTSEL,
1372
1373 .leftreg = TEA6300_VR,
1374 .rightreg = TEA6300_VL,
1375 .bassreg = TEA6300_BA,
1376 .treblereg = TEA6300_TR,
1377
1378 /* callbacks */
1379 .volfunc = tea6300_shift10,
1380 .bassfunc = tea6300_shift12,
1381 .treblefunc = tea6300_shift12,
1382
1383 .inputreg = TEA6300_S,
1384 .inputmap = { TEA6300_S_SA, TEA6300_S_SB, TEA6300_S_SC },
1385 .inputmute = TEA6300_S_GMU,
1386 },
1387 {
1388 .name = "tea6320",
1389 .insmodopt = &tea6320,
1390 .addr_lo = I2C_ADDR_TEA6300 >> 1,
1391 .addr_hi = I2C_ADDR_TEA6300 >> 1,
1392 .registers = 8,
1393 .flags = CHIP_HAS_VOLUME | CHIP_HAS_BASSTREBLE | CHIP_HAS_INPUTSEL,
1394
1395 .leftreg = TEA6320_V,
1396 .rightreg = TEA6320_V,
1397 .bassreg = TEA6320_BA,
1398 .treblereg = TEA6320_TR,
1399
1400 /* callbacks */
1401 .initialize = tea6320_initialize,
1402 .volfunc = tea6320_volume,
1403 .bassfunc = tea6320_shift11,
1404 .treblefunc = tea6320_shift11,
1405
1406 .inputreg = TEA6320_S,
1407 .inputmap = { TEA6320_S_SA, TEA6420_S_SB, TEA6300_S_SC, TEA6320_S_SD },
1408 .inputmute = TEA6300_S_GMU,
1409 },
1410 {
1411 .name = "tea6420",
1412 .insmodopt = &tea6420,
1413 .addr_lo = I2C_ADDR_TEA6420 >> 1,
1414 .addr_hi = I2C_ADDR_TEA6420 >> 1,
1415 .registers = 1,
1416 .flags = CHIP_HAS_INPUTSEL,
1417
1418 .inputreg = -1,
1419 .inputmap = { TEA6420_S_SA, TEA6420_S_SB, TEA6420_S_SC },
1420 .inputmute = TEA6300_S_GMU,
1421 },
1422 {
1423 .name = "tda8425",
1424 .insmodopt = &tda8425,
1425 .addr_lo = I2C_ADDR_TDA8425 >> 1,
1426 .addr_hi = I2C_ADDR_TDA8425 >> 1,
1427 .registers = 9,
1428 .flags = CHIP_HAS_VOLUME | CHIP_HAS_BASSTREBLE | CHIP_HAS_INPUTSEL,
1429
1430 .leftreg = TDA8425_VL,
1431 .rightreg = TDA8425_VR,
1432 .bassreg = TDA8425_BA,
1433 .treblereg = TDA8425_TR,
1434
1435 /* callbacks */
1436 .initialize = tda8425_initialize,
1437 .volfunc = tda8425_shift10,
1438 .bassfunc = tda8425_shift12,
1439 .treblefunc = tda8425_shift12,
1440 .setmode = tda8425_setmode,
1441
1442 .inputreg = TDA8425_S1,
1443 .inputmap = { TDA8425_S1_CH1, TDA8425_S1_CH1, TDA8425_S1_CH1 },
1444 .inputmute = TDA8425_S1_OFF,
1445
1446 },
1447 {
1448 .name = "pic16c54 (PV951)",
1449 .insmodopt = &pic16c54,
1450 .addr_lo = I2C_ADDR_PIC16C54 >> 1,
1451 .addr_hi = I2C_ADDR_PIC16C54>> 1,
1452 .registers = 2,
1453 .flags = CHIP_HAS_INPUTSEL,
1454
1455 .inputreg = PIC16C54_REG_MISC,
1456 .inputmap = {PIC16C54_MISC_SND_NOTMUTE|PIC16C54_MISC_SWITCH_TUNER,
1457 PIC16C54_MISC_SND_NOTMUTE|PIC16C54_MISC_SWITCH_LINE,
1458 PIC16C54_MISC_SND_NOTMUTE|PIC16C54_MISC_SWITCH_LINE,
1459 PIC16C54_MISC_SND_MUTE},
1460 .inputmute = PIC16C54_MISC_SND_MUTE,
1461 },
1462 {
1463 .name = "ta8874z",
1464 .checkit = ta8874z_checkit,
1465 .insmodopt = &ta8874z,
1466 .addr_lo = I2C_ADDR_TDA9840 >> 1,
1467 .addr_hi = I2C_ADDR_TDA9840 >> 1,
1468 .registers = 2,
1469 .flags = CHIP_NEED_CHECKMODE,
1470
1471 /* callbacks */
1472 .getmode = ta8874z_getmode,
1473 .setmode = ta8874z_setmode,
1474
1475 .init = {2, { TA8874Z_MONO_SET, TA8874Z_SEPARATION_DEFAULT}},
1476 },
1477 { .name = NULL } /* EOF */
1478 };
1479
1480
1481 /* ---------------------------------------------------------------------- */
1482 /* i2c registration */
1483
1484 static int chip_probe(struct i2c_client *client, const struct i2c_device_id *id)
1485 {
1486 struct CHIPSTATE *chip;
1487 struct CHIPDESC *desc;
1488
1489 if (debug) {
1490 printk(KERN_INFO "tvaudio: TV audio decoder + audio/video mux driver\n");
1491 printk(KERN_INFO "tvaudio: known chips: ");
1492 for (desc = chiplist; desc->name != NULL; desc++)
1493 printk("%s%s", (desc == chiplist) ? "" : ", ", desc->name);
1494 printk("\n");
1495 }
1496
1497 chip = kzalloc(sizeof(*chip),GFP_KERNEL);
1498 if (!chip)
1499 return -ENOMEM;
1500 chip->c = client;
1501 i2c_set_clientdata(client, chip);
1502
1503 /* find description for the chip */
1504 v4l_dbg(1, debug, client, "chip found @ 0x%x\n", client->addr<<1);
1505 for (desc = chiplist; desc->name != NULL; desc++) {
1506 if (0 == *(desc->insmodopt))
1507 continue;
1508 if (client->addr < desc->addr_lo ||
1509 client->addr > desc->addr_hi)
1510 continue;
1511 if (desc->checkit && !desc->checkit(chip))
1512 continue;
1513 break;
1514 }
1515 if (desc->name == NULL) {
1516 v4l_dbg(1, debug, client, "no matching chip description found\n");
1517 kfree(chip);
1518 return -EIO;
1519 }
1520 v4l_info(client, "%s found @ 0x%x (%s)\n", desc->name, client->addr<<1, client->adapter->name);
1521 if (desc->flags) {
1522 v4l_dbg(1, debug, client, "matches:%s%s%s.\n",
1523 (desc->flags & CHIP_HAS_VOLUME) ? " volume" : "",
1524 (desc->flags & CHIP_HAS_BASSTREBLE) ? " bass/treble" : "",
1525 (desc->flags & CHIP_HAS_INPUTSEL) ? " audiomux" : "");
1526 }
1527
1528 /* fill required data structures */
1529 if (!id)
1530 strlcpy(client->name, desc->name, I2C_NAME_SIZE);
1531 chip->desc = desc;
1532 chip->shadow.count = desc->registers+1;
1533 chip->prevmode = -1;
1534 chip->audmode = V4L2_TUNER_MODE_LANG1;
1535
1536 /* initialization */
1537 if (desc->initialize != NULL)
1538 desc->initialize(chip);
1539 else
1540 chip_cmd(chip,"init",&desc->init);
1541
1542 if (desc->flags & CHIP_HAS_VOLUME) {
1543 if (!desc->volfunc) {
1544 /* This shouldn't be happen. Warn user, but keep working
1545 without volume controls
1546 */
1547 v4l_info(chip->c, "volume callback undefined!\n");
1548 desc->flags &= ~CHIP_HAS_VOLUME;
1549 } else {
1550 chip->left = desc->leftinit ? desc->leftinit : 65535;
1551 chip->right = desc->rightinit ? desc->rightinit : 65535;
1552 chip_write(chip, desc->leftreg,
1553 desc->volfunc(chip->left));
1554 chip_write(chip, desc->rightreg,
1555 desc->volfunc(chip->right));
1556 }
1557 }
1558 if (desc->flags & CHIP_HAS_BASSTREBLE) {
1559 if (!desc->bassfunc || !desc->treblefunc) {
1560 /* This shouldn't be happen. Warn user, but keep working
1561 without bass/treble controls
1562 */
1563 v4l_info(chip->c, "bass/treble callbacks undefined!\n");
1564 desc->flags &= ~CHIP_HAS_BASSTREBLE;
1565 } else {
1566 chip->treble = desc->trebleinit ?
1567 desc->trebleinit : 32768;
1568 chip->bass = desc->bassinit ?
1569 desc->bassinit : 32768;
1570 chip_write(chip, desc->bassreg,
1571 desc->bassfunc(chip->bass));
1572 chip_write(chip, desc->treblereg,
1573 desc->treblefunc(chip->treble));
1574 }
1575 }
1576
1577 chip->thread = NULL;
1578 if (desc->flags & CHIP_NEED_CHECKMODE) {
1579 if (!desc->getmode || !desc->setmode) {
1580 /* This shouldn't be happen. Warn user, but keep working
1581 without kthread
1582 */
1583 v4l_info(chip->c, "set/get mode callbacks undefined!\n");
1584 return 0;
1585 }
1586 /* start async thread */
1587 init_timer(&chip->wt);
1588 chip->wt.function = chip_thread_wake;
1589 chip->wt.data = (unsigned long)chip;
1590 chip->thread = kthread_run(chip_thread, chip, chip->c->name);
1591 if (IS_ERR(chip->thread)) {
1592 v4l_warn(chip->c, "%s: failed to create kthread\n",
1593 chip->c->name);
1594 chip->thread = NULL;
1595 }
1596 }
1597 return 0;
1598 }
1599
1600 static int chip_remove(struct i2c_client *client)
1601 {
1602 struct CHIPSTATE *chip = i2c_get_clientdata(client);
1603
1604 del_timer_sync(&chip->wt);
1605 if (chip->thread) {
1606 /* shutdown async thread */
1607 kthread_stop(chip->thread);
1608 chip->thread = NULL;
1609 }
1610
1611 kfree(chip);
1612 return 0;
1613 }
1614
1615 static int tvaudio_get_ctrl(struct CHIPSTATE *chip,
1616 struct v4l2_control *ctrl)
1617 {
1618 struct CHIPDESC *desc = chip->desc;
1619
1620 switch (ctrl->id) {
1621 case V4L2_CID_AUDIO_MUTE:
1622 ctrl->value=chip->muted;
1623 return 0;
1624 case V4L2_CID_AUDIO_VOLUME:
1625 if (!(desc->flags & CHIP_HAS_VOLUME))
1626 break;
1627 ctrl->value = max(chip->left,chip->right);
1628 return 0;
1629 case V4L2_CID_AUDIO_BALANCE:
1630 {
1631 int volume;
1632 if (!(desc->flags & CHIP_HAS_VOLUME))
1633 break;
1634 volume = max(chip->left,chip->right);
1635 if (volume)
1636 ctrl->value=(32768*min(chip->left,chip->right))/volume;
1637 else
1638 ctrl->value=32768;
1639 return 0;
1640 }
1641 case V4L2_CID_AUDIO_BASS:
1642 if (desc->flags & CHIP_HAS_BASSTREBLE)
1643 break;
1644 ctrl->value = chip->bass;
1645 return 0;
1646 case V4L2_CID_AUDIO_TREBLE:
1647 if (desc->flags & CHIP_HAS_BASSTREBLE)
1648 return -EINVAL;
1649 ctrl->value = chip->treble;
1650 return 0;
1651 }
1652 return -EINVAL;
1653 }
1654
1655 static int tvaudio_set_ctrl(struct CHIPSTATE *chip,
1656 struct v4l2_control *ctrl)
1657 {
1658 struct CHIPDESC *desc = chip->desc;
1659
1660 switch (ctrl->id) {
1661 case V4L2_CID_AUDIO_MUTE:
1662 if (ctrl->value < 0 || ctrl->value >= 2)
1663 return -ERANGE;
1664 chip->muted = ctrl->value;
1665 if (chip->muted)
1666 chip_write_masked(chip,desc->inputreg,desc->inputmute,desc->inputmask);
1667 else
1668 chip_write_masked(chip,desc->inputreg,
1669 desc->inputmap[chip->input],desc->inputmask);
1670 return 0;
1671 case V4L2_CID_AUDIO_VOLUME:
1672 {
1673 int volume,balance;
1674
1675 if (!(desc->flags & CHIP_HAS_VOLUME))
1676 break;
1677
1678 volume = max(chip->left,chip->right);
1679 if (volume)
1680 balance=(32768*min(chip->left,chip->right))/volume;
1681 else
1682 balance=32768;
1683
1684 volume=ctrl->value;
1685 chip->left = (min(65536 - balance,32768) * volume) / 32768;
1686 chip->right = (min(balance,volume *(__u16)32768)) / 32768;
1687
1688 chip_write(chip,desc->leftreg,desc->volfunc(chip->left));
1689 chip_write(chip,desc->rightreg,desc->volfunc(chip->right));
1690
1691 return 0;
1692 }
1693 case V4L2_CID_AUDIO_BALANCE:
1694 {
1695 int volume, balance;
1696 if (!(desc->flags & CHIP_HAS_VOLUME))
1697 break;
1698
1699 volume = max(chip->left,chip->right);
1700 balance = ctrl->value;
1701
1702 chip_write(chip,desc->leftreg,desc->volfunc(chip->left));
1703 chip_write(chip,desc->rightreg,desc->volfunc(chip->right));
1704
1705 return 0;
1706 }
1707 case V4L2_CID_AUDIO_BASS:
1708 if (desc->flags & CHIP_HAS_BASSTREBLE)
1709 break;
1710 chip->bass = ctrl->value;
1711 chip_write(chip,desc->bassreg,desc->bassfunc(chip->bass));
1712
1713 return 0;
1714 case V4L2_CID_AUDIO_TREBLE:
1715 if (desc->flags & CHIP_HAS_BASSTREBLE)
1716 return -EINVAL;
1717
1718 chip->treble = ctrl->value;
1719 chip_write(chip,desc->treblereg,desc->treblefunc(chip->treble));
1720
1721 return 0;
1722 }
1723 return -EINVAL;
1724 }
1725
1726
1727 /* ---------------------------------------------------------------------- */
1728 /* video4linux interface */
1729
1730 static int chip_command(struct i2c_client *client,
1731 unsigned int cmd, void *arg)
1732 {
1733 struct CHIPSTATE *chip = i2c_get_clientdata(client);
1734 struct CHIPDESC *desc = chip->desc;
1735
1736 if (debug > 0) {
1737 v4l_i2c_print_ioctl(chip->c, cmd);
1738 printk("\n");
1739 }
1740
1741 switch (cmd) {
1742 case AUDC_SET_RADIO:
1743 chip->radio = 1;
1744 chip->watch_stereo = 0;
1745 /* del_timer(&chip->wt); */
1746 break;
1747 /* --- v4l ioctls --- */
1748 /* take care: bttv does userspace copying, we'll get a
1749 kernel pointer here... */
1750 case VIDIOC_QUERYCTRL:
1751 {
1752 struct v4l2_queryctrl *qc = arg;
1753
1754 switch (qc->id) {
1755 case V4L2_CID_AUDIO_MUTE:
1756 break;
1757 case V4L2_CID_AUDIO_VOLUME:
1758 case V4L2_CID_AUDIO_BALANCE:
1759 if (!(desc->flags & CHIP_HAS_VOLUME))
1760 return -EINVAL;
1761 break;
1762 case V4L2_CID_AUDIO_BASS:
1763 case V4L2_CID_AUDIO_TREBLE:
1764 if (desc->flags & CHIP_HAS_BASSTREBLE)
1765 return -EINVAL;
1766 break;
1767 default:
1768 return -EINVAL;
1769 }
1770 return v4l2_ctrl_query_fill_std(qc);
1771 }
1772 case VIDIOC_S_CTRL:
1773 return tvaudio_set_ctrl(chip, arg);
1774
1775 case VIDIOC_G_CTRL:
1776 return tvaudio_get_ctrl(chip, arg);
1777 case VIDIOC_INT_G_AUDIO_ROUTING:
1778 {
1779 struct v4l2_routing *rt = arg;
1780
1781 rt->input = chip->input;
1782 rt->output = 0;
1783 break;
1784 }
1785 case VIDIOC_INT_S_AUDIO_ROUTING:
1786 {
1787 struct v4l2_routing *rt = arg;
1788
1789 if (!(desc->flags & CHIP_HAS_INPUTSEL) || rt->input >= 4)
1790 return -EINVAL;
1791 /* There are four inputs: tuner, radio, extern and intern. */
1792 chip->input = rt->input;
1793 if (chip->muted)
1794 break;
1795 chip_write_masked(chip, desc->inputreg,
1796 desc->inputmap[chip->input], desc->inputmask);
1797 break;
1798 }
1799 case VIDIOC_S_TUNER:
1800 {
1801 struct v4l2_tuner *vt = arg;
1802 int mode = 0;
1803
1804 if (chip->radio)
1805 break;
1806 switch (vt->audmode) {
1807 case V4L2_TUNER_MODE_MONO:
1808 case V4L2_TUNER_MODE_STEREO:
1809 case V4L2_TUNER_MODE_LANG1:
1810 case V4L2_TUNER_MODE_LANG2:
1811 mode = vt->audmode;
1812 break;
1813 case V4L2_TUNER_MODE_LANG1_LANG2:
1814 mode = V4L2_TUNER_MODE_STEREO;
1815 break;
1816 default:
1817 return -EINVAL;
1818 }
1819 chip->audmode = vt->audmode;
1820
1821 if (desc->setmode && mode) {
1822 chip->watch_stereo = 0;
1823 /* del_timer(&chip->wt); */
1824 chip->mode = mode;
1825 desc->setmode(chip, mode);
1826 }
1827 break;
1828 }
1829 case VIDIOC_G_TUNER:
1830 {
1831 struct v4l2_tuner *vt = arg;
1832 int mode = V4L2_TUNER_MODE_MONO;
1833
1834 if (chip->radio)
1835 break;
1836 vt->audmode = chip->audmode;
1837 vt->rxsubchans = 0;
1838 vt->capability = V4L2_TUNER_CAP_STEREO |
1839 V4L2_TUNER_CAP_LANG1 | V4L2_TUNER_CAP_LANG2;
1840
1841 if (desc->getmode)
1842 mode = desc->getmode(chip);
1843
1844 if (mode & V4L2_TUNER_MODE_MONO)
1845 vt->rxsubchans |= V4L2_TUNER_SUB_MONO;
1846 if (mode & V4L2_TUNER_MODE_STEREO)
1847 vt->rxsubchans |= V4L2_TUNER_SUB_STEREO;
1848 /* Note: for SAP it should be mono/lang2 or stereo/lang2.
1849 When this module is converted fully to v4l2, then this
1850 should change for those chips that can detect SAP. */
1851 if (mode & V4L2_TUNER_MODE_LANG1)
1852 vt->rxsubchans = V4L2_TUNER_SUB_LANG1 |
1853 V4L2_TUNER_SUB_LANG2;
1854 break;
1855 }
1856 case VIDIOC_S_STD:
1857 chip->radio = 0;
1858 break;
1859 case VIDIOC_S_FREQUENCY:
1860 chip->mode = 0; /* automatic */
1861
1862 /* For chips that provide getmode and setmode, and doesn't
1863 automatically follows the stereo carrier, a kthread is
1864 created to set the audio standard. In this case, when then
1865 the video channel is changed, tvaudio starts on MONO mode.
1866 After waiting for 2 seconds, the kernel thread is called,
1867 to follow whatever audio standard is pointed by the
1868 audio carrier.
1869 */
1870 if (chip->thread) {
1871 desc->setmode(chip,V4L2_TUNER_MODE_MONO);
1872 if (chip->prevmode != V4L2_TUNER_MODE_MONO)
1873 chip->prevmode = -1; /* reset previous mode */
1874 mod_timer(&chip->wt, jiffies+msecs_to_jiffies(2000));
1875 }
1876 break;
1877
1878 case VIDIOC_G_CHIP_IDENT:
1879 return v4l2_chip_ident_i2c_client(client, arg, V4L2_IDENT_TVAUDIO, 0);
1880 }
1881 return 0;
1882 }
1883
1884 static int chip_legacy_probe(struct i2c_adapter *adap)
1885 {
1886 /* don't attach on saa7146 based cards,
1887 because dedicated drivers are used */
1888 if ((adap->id == I2C_HW_SAA7146))
1889 return 0;
1890 if (adap->class & I2C_CLASS_TV_ANALOG)
1891 return 1;
1892 return 0;
1893 }
1894
1895 /* This driver supports many devices and the idea is to let the driver
1896 detect which device is present. So rather than listing all supported
1897 devices here, we pretend to support a single, fake device type. */
1898 static const struct i2c_device_id chip_id[] = {
1899 { "tvaudio", 0 },
1900 { }
1901 };
1902 MODULE_DEVICE_TABLE(i2c, chip_id);
1903
1904 static struct v4l2_i2c_driver_data v4l2_i2c_data = {
1905 .name = "tvaudio",
1906 .driverid = I2C_DRIVERID_TVAUDIO,
1907 .command = chip_command,
1908 .probe = chip_probe,
1909 .remove = chip_remove,
1910 .legacy_probe = chip_legacy_probe,
1911 .id_table = chip_id,
1912 };
linux 2.6 git repository for openrd