2 * For the STS-Thompson TDA7432 audio processor chip
4 * Handles audio functions: volume, balance, tone, loudness
5 * This driver will not complain if used with any
6 * other i2c device with the same address.
8 * Muting and tone control by Jonathan Isom <jisom@ematic.com>
10 * Copyright (c) 2000 Eric Sandeen <eric_sandeen@bigfoot.com>
11 * Copyright (c) 2006 Mauro Carvalho Chehab <mchehab@infradead.org>
12 * This code is placed under the terms of the GNU General Public License
13 * Based on tda9855.c by Steve VanDeBogart (vandebo@uclink.berkeley.edu)
14 * Which was based on tda8425.c by Greg Alexander (c) 1998
17 * debug - set to 1 if you'd like to see debug messages
18 * set to 2 if you'd like to be inundated with debug messages
20 * loudness - set between 0 and 15 for varying degrees of loudness effect
22 * maxvol - set maximium volume to +20db (1), default is 0db(0)
25 * Revision: 0.7 - maxvol module parm to set maximium volume 0db or +20db
26 * store if muted so we can return it
27 * change balance only if flaged to
28 * Revision: 0.6 - added tone controls
29 * Revision: 0.5 - Fixed odd balance problem
30 * Revision: 0.4 - added muting
31 * Revision: 0.3 - Fixed silly reversed volume controls. :)
32 * Revision: 0.2 - Cleaned up #defines
33 * fixed volume control
34 * Added I2C_DRIVERID_TDA7432
35 * added loudness insmod control
36 * Revision: 0.1 - initial version
39 #include <linux/module.h>
40 #include <linux/init.h>
41 #include <linux/kernel.h>
42 #include <linux/string.h>
43 #include <linux/timer.h>
44 #include <linux/delay.h>
45 #include <linux/errno.h>
46 #include <linux/slab.h>
47 #include <linux/videodev2.h>
48 #include <linux/i2c.h>
50 #include <media/v4l2-common.h>
51 #include <media/v4l2-ioctl.h>
52 #include <media/i2c-addr.h>
54 #ifndef VIDEO_AUDIO_BALANCE
55 # define VIDEO_AUDIO_BALANCE 32
58 MODULE_AUTHOR("Eric Sandeen <eric_sandeen@bigfoot.com>");
59 MODULE_DESCRIPTION("bttv driver for the tda7432 audio processor chip");
60 MODULE_LICENSE("GPL");
63 static int loudness
; /* disable loudness by default */
64 static int debug
; /* insmod parameter */
65 module_param(debug
, int, S_IRUGO
| S_IWUSR
);
66 module_param(loudness
, int, S_IRUGO
);
67 MODULE_PARM_DESC(maxvol
,"Set maximium volume to +20db (0), default is 0db(1)");
68 module_param(maxvol
, int, S_IRUGO
| S_IWUSR
);
71 /* Address to scan (I2C address of this chip) */
72 static unsigned short normal_i2c
[] = {
73 I2C_ADDR_TDA7432
>> 1,
79 /* Structure of address and subaddresses for the tda7432 */
91 static struct i2c_driver driver
;
92 static struct i2c_client client_template
;
94 /* The TDA7432 is made by STS-Thompson
96 * http://us.st.com/stonline/books/pdf/docs/4056.pdf
98 * TDA7432: I2C-bus controlled basic audio processor
100 * The TDA7432 controls basic audio functions like volume, balance,
101 * and tone control (including loudness). It also has four channel
102 * output (for front and rear). Since most vidcap cards probably
103 * don't have 4 channel output, this driver will set front & rear
104 * together (no independent control).
107 /* Subaddresses for TDA7432 */
109 #define TDA7432_IN 0x00 /* Input select */
110 #define TDA7432_VL 0x01 /* Volume */
111 #define TDA7432_TN 0x02 /* Bass, Treble (Tone) */
112 #define TDA7432_LF 0x03 /* Attenuation LF (Left Front) */
113 #define TDA7432_LR 0x04 /* Attenuation LR (Left Rear) */
114 #define TDA7432_RF 0x05 /* Attenuation RF (Right Front) */
115 #define TDA7432_RR 0x06 /* Attenuation RR (Right Rear) */
116 #define TDA7432_LD 0x07 /* Loudness */
119 /* Masks for bits in TDA7432 subaddresses */
121 /* Many of these not used - just for documentation */
123 /* Subaddress 0x00 - Input selection and bass control */
125 /* Bits 0,1,2 control input:
126 * 0x00 - Stereo input
128 * 0x03 - Mute (Using Attenuators Plays better with modules)
129 * Mono probably isn't used - I'm guessing only the stereo
130 * input is connected on most cards, so we'll set it to stereo.
132 * Bit 3 controls bass cut: 0/1 is non-symmetric/symmetric bass cut
133 * Bit 4 controls bass range: 0/1 is extended/standard bass range
135 * Highest 3 bits not used
138 #define TDA7432_STEREO_IN 0
139 #define TDA7432_MONO_IN 2 /* Probably won't be used */
140 #define TDA7432_BASS_SYM 1 << 3
141 #define TDA7432_BASS_NORM 1 << 4
143 /* Subaddress 0x01 - Volume */
145 /* Lower 7 bits control volume from -79dB to +32dB in 1dB steps
146 * Recommended maximum is +20 dB
153 * MSB (bit 7) controls loudness: 1/0 is loudness on/off
156 #define TDA7432_VOL_0DB 0x20
157 #define TDA7432_LD_ON 1 << 7
160 /* Subaddress 0x02 - Tone control */
162 /* Bits 0,1,2 control absolute treble gain from 0dB to 14dB
163 * 0x0 is 14dB, 0x7 is 0dB
165 * Bit 3 controls treble attenuation/gain (sign)
167 * 0 = attenuation (-)
169 * Bits 4,5,6 control absolute bass gain from 0dB to 14dB
170 * (This is only true for normal base range, set in 0x00)
171 * 0x0 << 4 is 14dB, 0x7 is 0dB
173 * Bit 7 controls bass attenuation/gain (sign)
175 * 0 << 7 = attenuation (-)
178 * 1 1 0 1 0 1 0 1 is +4dB bass, -4dB treble
181 #define TDA7432_TREBLE_0DB 0xf
182 #define TDA7432_TREBLE 7
183 #define TDA7432_TREBLE_GAIN 1 << 3
184 #define TDA7432_BASS_0DB 0xf
185 #define TDA7432_BASS 7 << 4
186 #define TDA7432_BASS_GAIN 1 << 7
189 /* Subaddress 0x03 - Left Front attenuation */
190 /* Subaddress 0x04 - Left Rear attenuation */
191 /* Subaddress 0x05 - Right Front attenuation */
192 /* Subaddress 0x06 - Right Rear attenuation */
194 /* Bits 0,1,2,3,4 control attenuation from 0dB to -37.5dB
200 * Bit 5 mutes that channel when set (1 = mute, 0 = unmute)
201 * We'll use the mute on the input, though (above)
205 #define TDA7432_ATTEN_0DB 0x00
206 #define TDA7432_MUTE 0x1 << 5
209 /* Subaddress 0x07 - Loudness Control */
211 /* Bits 0,1,2,3 control loudness from 0dB to -15dB in 1dB steps
212 * when bit 4 is NOT set
217 * If bit 4 is set, then there is a flat attenuation according to
218 * the lower 4 bits, as above.
227 static int tda7432_write(struct i2c_client
*client
, int subaddr
, int val
)
229 unsigned char buffer
[2];
230 v4l_dbg(2, debug
,client
,"In tda7432_write\n");
231 v4l_dbg(1, debug
,client
,"Writing %d 0x%x\n", subaddr
, val
);
234 if (2 != i2c_master_send(client
,buffer
,2)) {
235 v4l_err(client
,"I/O error, trying (write %d 0x%x)\n",
242 /* I don't think we ever actually _read_ the chip... */
244 static int tda7432_set(struct i2c_client
*client
)
246 struct tda7432
*t
= i2c_get_clientdata(client
);
247 unsigned char buf
[16];
248 v4l_dbg(2, debug
,client
,"In tda7432_set\n");
250 v4l_dbg(1, debug
,client
,
251 "tda7432: 7432_set(0x%02x,0x%02x,0x%02x,0x%02x,0x%02x,0x%02x,0x%02x,0x%02x,0x%02x)\n",
252 t
->input
,t
->volume
,t
->bass
,t
->treble
,t
->lf
,t
->lr
,t
->rf
,t
->rr
,t
->loud
);
263 if (10 != i2c_master_send(client
,buf
,10)) {
264 v4l_err(client
,"I/O error, trying tda7432_set\n");
271 static void do_tda7432_init(struct i2c_client
*client
)
273 struct tda7432
*t
= i2c_get_clientdata(client
);
274 v4l_dbg(2, debug
,client
,"In tda7432_init\n");
276 t
->input
= TDA7432_STEREO_IN
| /* Main (stereo) input */
277 TDA7432_BASS_SYM
| /* Symmetric bass cut */
278 TDA7432_BASS_NORM
; /* Normal bass range */
279 t
->volume
= 0x3b ; /* -27dB Volume */
280 if (loudness
) /* Turn loudness on? */
281 t
->volume
|= TDA7432_LD_ON
;
283 t
->treble
= TDA7432_TREBLE_0DB
; /* 0dB Treble */
284 t
->bass
= TDA7432_BASS_0DB
; /* 0dB Bass */
285 t
->lf
= TDA7432_ATTEN_0DB
; /* 0dB attenuation */
286 t
->lr
= TDA7432_ATTEN_0DB
; /* 0dB attenuation */
287 t
->rf
= TDA7432_ATTEN_0DB
; /* 0dB attenuation */
288 t
->rr
= TDA7432_ATTEN_0DB
; /* 0dB attenuation */
289 t
->loud
= loudness
; /* insmod parameter */
294 /* *********************** *
295 * i2c interface functions *
296 * *********************** */
298 static int tda7432_attach(struct i2c_adapter
*adap
, int addr
, int kind
)
301 struct i2c_client
*client
;
303 t
= kzalloc(sizeof *t
,GFP_KERNEL
);
308 memcpy(client
,&client_template
,sizeof(struct i2c_client
));
309 client
->adapter
= adap
;
311 i2c_set_clientdata(client
, t
);
313 do_tda7432_init(client
);
314 i2c_attach_client(client
);
316 v4l_info(client
, "chip found @ 0x%x (%s)\n", addr
<< 1, adap
->name
);
320 static int tda7432_probe(struct i2c_adapter
*adap
)
322 if (adap
->class & I2C_CLASS_TV_ANALOG
)
323 return i2c_probe(adap
, &addr_data
, tda7432_attach
);
327 static int tda7432_detach(struct i2c_client
*client
)
329 struct tda7432
*t
= i2c_get_clientdata(client
);
331 do_tda7432_init(client
);
332 i2c_detach_client(client
);
338 static int tda7432_get_ctrl(struct i2c_client
*client
,
339 struct v4l2_control
*ctrl
)
341 struct tda7432
*t
= i2c_get_clientdata(client
);
344 case V4L2_CID_AUDIO_MUTE
:
345 ctrl
->value
=t
->muted
;
347 case V4L2_CID_AUDIO_VOLUME
:
348 if (!maxvol
){ /* max +20db */
349 ctrl
->value
= ( 0x6f - (t
->volume
& 0x7F) ) * 630;
350 } else { /* max 0db */
351 ctrl
->value
= ( 0x6f - (t
->volume
& 0x7F) ) * 829;
354 case V4L2_CID_AUDIO_BALANCE
:
356 if ( (t
->lf
) < (t
->rf
) )
357 /* right is attenuated, balance shifted left */
358 ctrl
->value
= (32768 - 1057*(t
->rf
));
360 /* left is attenuated, balance shifted right */
361 ctrl
->value
= (32768 + 1057*(t
->lf
));
364 case V4L2_CID_AUDIO_BASS
:
366 /* Bass/treble 4 bits each */
369 bass
= ~(bass
- 0x8) & 0xf;
370 ctrl
->value
= (bass
<< 12)+(bass
<< 8)+(bass
<< 4)+(bass
);
373 case V4L2_CID_AUDIO_TREBLE
:
375 int treble
=t
->treble
;
377 treble
= ~(treble
- 0x8) & 0xf;
378 ctrl
->value
= (treble
<< 12)+(treble
<< 8)+(treble
<< 4)+(treble
);
385 static int tda7432_set_ctrl(struct i2c_client
*client
,
386 struct v4l2_control
*ctrl
)
388 struct tda7432
*t
= i2c_get_clientdata(client
);
391 case V4L2_CID_AUDIO_MUTE
:
392 t
->muted
=ctrl
->value
;
394 case V4L2_CID_AUDIO_VOLUME
:
395 if(!maxvol
){ /* max +20db */
396 t
->volume
= 0x6f - ((ctrl
->value
)/630);
397 } else { /* max 0db */
398 t
->volume
= 0x6f - ((ctrl
->value
)/829);
400 if (loudness
) /* Turn on the loudness bit */
401 t
->volume
|= TDA7432_LD_ON
;
403 tda7432_write(client
,TDA7432_VL
, t
->volume
);
405 case V4L2_CID_AUDIO_BALANCE
:
406 if (ctrl
->value
< 32768) {
407 /* shifted to left, attenuate right */
408 t
->rr
= (32768 - ctrl
->value
)/1057;
410 t
->lr
= TDA7432_ATTEN_0DB
;
411 t
->lf
= TDA7432_ATTEN_0DB
;
412 } else if(ctrl
->value
> 32769) {
413 /* shifted to right, attenuate left */
414 t
->lf
= (ctrl
->value
- 32768)/1057;
416 t
->rr
= TDA7432_ATTEN_0DB
;
417 t
->rf
= TDA7432_ATTEN_0DB
;
420 t
->rr
= TDA7432_ATTEN_0DB
;
421 t
->rf
= TDA7432_ATTEN_0DB
;
422 t
->lf
= TDA7432_ATTEN_0DB
;
423 t
->lr
= TDA7432_ATTEN_0DB
;
426 case V4L2_CID_AUDIO_BASS
:
427 t
->bass
= ctrl
->value
>> 12;
429 t
->bass
= (~t
->bass
& 0xf) + 0x8 ;
431 tda7432_write(client
,TDA7432_TN
, 0x10 | (t
->bass
<< 4) | t
->treble
);
433 case V4L2_CID_AUDIO_TREBLE
:
434 t
->treble
= ctrl
->value
>> 12;
436 t
->treble
= (~t
->treble
& 0xf) + 0x8 ;
438 tda7432_write(client
,TDA7432_TN
, 0x10 | (t
->bass
<< 4) | t
->treble
);
444 /* Used for both mute and balance changes */
447 /* Mute & update balance*/
448 tda7432_write(client
,TDA7432_LF
, t
->lf
| TDA7432_MUTE
);
449 tda7432_write(client
,TDA7432_LR
, t
->lr
| TDA7432_MUTE
);
450 tda7432_write(client
,TDA7432_RF
, t
->rf
| TDA7432_MUTE
);
451 tda7432_write(client
,TDA7432_RR
, t
->rr
| TDA7432_MUTE
);
453 tda7432_write(client
,TDA7432_LF
, t
->lf
);
454 tda7432_write(client
,TDA7432_LR
, t
->lr
);
455 tda7432_write(client
,TDA7432_RF
, t
->rf
);
456 tda7432_write(client
,TDA7432_RR
, t
->rr
);
461 static int tda7432_command(struct i2c_client
*client
,
462 unsigned int cmd
, void *arg
)
464 v4l_dbg(2, debug
,client
,"In tda7432_command\n");
466 v4l_i2c_print_ioctl(client
,cmd
);
469 /* --- v4l ioctls --- */
470 /* take care: bttv does userspace copying, we'll get a
471 kernel pointer here... */
472 case VIDIOC_QUERYCTRL
:
474 struct v4l2_queryctrl
*qc
= arg
;
477 case V4L2_CID_AUDIO_MUTE
:
478 case V4L2_CID_AUDIO_VOLUME
:
479 case V4L2_CID_AUDIO_BALANCE
:
480 case V4L2_CID_AUDIO_BASS
:
481 case V4L2_CID_AUDIO_TREBLE
:
485 return v4l2_ctrl_query_fill_std(qc
);
488 return tda7432_set_ctrl(client
, arg
);
491 return tda7432_get_ctrl(client
, arg
);
493 } /* end of (cmd) switch */
498 static struct i2c_driver driver
= {
502 .id
= I2C_DRIVERID_TDA7432
,
503 .attach_adapter
= tda7432_probe
,
504 .detach_client
= tda7432_detach
,
505 .command
= tda7432_command
,
508 static struct i2c_client client_template
=
514 static int __init
tda7432_init(void)
516 if ( (loudness
< 0) || (loudness
> 15) ) {
517 printk(KERN_ERR
"loudness parameter must be between 0 and 15\n");
521 return i2c_add_driver(&driver
);
524 static void __exit
tda7432_fini(void)
526 i2c_del_driver(&driver
);
529 module_init(tda7432_init
);
530 module_exit(tda7432_fini
);