?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[WATCHDOG] change s3c2410_wdt to using dev_() macros for output
[linux-2.6/mini2440.git] / drivers / media / video / msp3400-driver.c
blob3bb7d6634862be289f789b810a7b1d73c7fd3ac7
1 /*
2 * Programming the mspx4xx sound processor family
3 *
4 * (c) 1997-2001 Gerd Knorr <kraxel@bytesex.org>
5 *
6 * what works and what doesn't:
7 *
8 * AM-Mono
9 * Support for Hauppauge cards added (decoding handled by tuner) added by
10 * Frederic Crozat <fcrozat@mail.dotcom.fr>
11 *
12 * FM-Mono
13 * should work. The stereo modes are backward compatible to FM-mono,
14 * therefore FM-Mono should be allways available.
15 *
16 * FM-Stereo (B/G, used in germany)
17 * should work, with autodetect
18 *
19 * FM-Stereo (satellite)
20 * should work, no autodetect (i.e. default is mono, but you can
21 * switch to stereo -- untested)
22 *
23 * NICAM (B/G, L , used in UK, Scandinavia, Spain and France)
24 * should work, with autodetect. Support for NICAM was added by
25 * Pekka Pietikainen <pp@netppl.fi>
26 *
27 * TODO:
28 * - better SAT support
29 *
30 * 980623 Thomas Sailer (sailer@ife.ee.ethz.ch)
31 * using soundcore instead of OSS
32 *
33 * This program is free software; you can redistribute it and/or
34 * modify it under the terms of the GNU General Public License
35 * as published by the Free Software Foundation; either version 2
36 * of the License, or (at your option) any later version.
37 *
38 * This program is distributed in the hope that it will be useful,
39 * but WITHOUT ANY WARRANTY; without even the implied warranty of
40 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
41 * GNU General Public License for more details.
42 *
43 * You should have received a copy of the GNU General Public License
44 * along with this program; if not, write to the Free Software
45 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
46 */
47
48
49 #include <linux/kernel.h>
50 #include <linux/module.h>
51 #include <linux/slab.h>
52 #include <linux/i2c.h>
53 #include <linux/videodev.h>
54 #include <linux/videodev2.h>
55 #include <media/v4l2-common.h>
56 #include <media/tvaudio.h>
57 #include <media/msp3400.h>
58 #include <linux/kthread.h>
59 #include <linux/freezer.h>
60 #include "msp3400-driver.h"
61
62 /* ---------------------------------------------------------------------- */
63
64 MODULE_DESCRIPTION("device driver for msp34xx TV sound processor");
65 MODULE_AUTHOR("Gerd Knorr");
66 MODULE_LICENSE("GPL");
67
68 /* module parameters */
69 static int opmode = OPMODE_AUTO;
70 int msp_debug; /* msp_debug output */
71 int msp_once; /* no continous stereo monitoring */
72 int msp_amsound; /* hard-wire AM sound at 6.5 Hz (france),
73 the autoscan seems work well only with FM... */
74 int msp_standard = 1; /* Override auto detect of audio msp_standard, if needed. */
75 int msp_dolby;
76
77 int msp_stereo_thresh = 0x190; /* a2 threshold for stereo/bilingual
78 (msp34xxg only) 0x00a0-0x03c0 */
79
80 /* read-only */
81 module_param(opmode, int, 0444);
82
83 /* read-write */
84 module_param_named(once,msp_once, bool, 0644);
85 module_param_named(debug,msp_debug, int, 0644);
86 module_param_named(stereo_threshold,msp_stereo_thresh, int, 0644);
87 module_param_named(standard,msp_standard, int, 0644);
88 module_param_named(amsound,msp_amsound, bool, 0644);
89 module_param_named(dolby,msp_dolby, bool, 0644);
90
91 MODULE_PARM_DESC(opmode, "Forces a MSP3400 opmode. 0=Manual, 1=Autodetect, 2=Autodetect and autoselect");
92 MODULE_PARM_DESC(once, "No continuous stereo monitoring");
93 MODULE_PARM_DESC(debug, "Enable debug messages [0-3]");
94 MODULE_PARM_DESC(stereo_threshold, "Sets signal threshold to activate stereo");
95 MODULE_PARM_DESC(standard, "Specify audio standard: 32 = NTSC, 64 = radio, Default: Autodetect");
96 MODULE_PARM_DESC(amsound, "Hardwire AM sound at 6.5Hz (France), FM can autoscan");
97 MODULE_PARM_DESC(dolby, "Activates Dolby processsing");
98
99 /* ---------------------------------------------------------------------- */
100
101 /* control subaddress */
102 #define I2C_MSP_CONTROL 0x00
103 /* demodulator unit subaddress */
104 #define I2C_MSP_DEM 0x10
105 /* DSP unit subaddress */
106 #define I2C_MSP_DSP 0x12
107
108 /* Addresses to scan */
109 static unsigned short normal_i2c[] = { 0x80 >> 1, 0x88 >> 1, I2C_CLIENT_END };
110 I2C_CLIENT_INSMOD;
111
112 /* ----------------------------------------------------------------------- */
113 /* functions for talking to the MSP3400C Sound processor */
114
115 int msp_reset(struct i2c_client *client)
116 {
117 /* reset and read revision code */
118 static u8 reset_off[3] = { I2C_MSP_CONTROL, 0x80, 0x00 };
119 static u8 reset_on[3] = { I2C_MSP_CONTROL, 0x00, 0x00 };
120 static u8 write[3] = { I2C_MSP_DSP + 1, 0x00, 0x1e };
121 u8 read[2];
122 struct i2c_msg reset[2] = {
123 { client->addr, I2C_M_IGNORE_NAK, 3, reset_off },
124 { client->addr, I2C_M_IGNORE_NAK, 3, reset_on },
125 };
126 struct i2c_msg test[2] = {
127 { client->addr, 0, 3, write },
128 { client->addr, I2C_M_RD, 2, read },
129 };
130
131 v4l_dbg(3, msp_debug, client, "msp_reset\n");
132 if (i2c_transfer(client->adapter, &reset[0], 1) != 1 ||
133 i2c_transfer(client->adapter, &reset[1], 1) != 1 ||
134 i2c_transfer(client->adapter, test, 2) != 2) {
135 v4l_err(client, "chip reset failed\n");
136 return -1;
137 }
138 return 0;
139 }
140
141 static int msp_read(struct i2c_client *client, int dev, int addr)
142 {
143 int err, retval;
144 u8 write[3];
145 u8 read[2];
146 struct i2c_msg msgs[2] = {
147 { client->addr, 0, 3, write },
148 { client->addr, I2C_M_RD, 2, read }
149 };
150
151 write[0] = dev + 1;
152 write[1] = addr >> 8;
153 write[2] = addr & 0xff;
154
155 for (err = 0; err < 3; err++) {
156 if (i2c_transfer(client->adapter, msgs, 2) == 2)
157 break;
158 v4l_warn(client, "I/O error #%d (read 0x%02x/0x%02x)\n", err,
159 dev, addr);
160 current->state = TASK_INTERRUPTIBLE;
161 schedule_timeout(msecs_to_jiffies(10));
162 }
163 if (err == 3) {
164 v4l_warn(client, "giving up, resetting chip. Sound will go off, sorry folks :-|\n");
165 msp_reset(client);
166 return -1;
167 }
168 retval = read[0] << 8 | read[1];
169 v4l_dbg(3, msp_debug, client, "msp_read(0x%x, 0x%x): 0x%x\n", dev, addr, retval);
170 return retval;
171 }
172
173 int msp_read_dem(struct i2c_client *client, int addr)
174 {
175 return msp_read(client, I2C_MSP_DEM, addr);
176 }
177
178 int msp_read_dsp(struct i2c_client *client, int addr)
179 {
180 return msp_read(client, I2C_MSP_DSP, addr);
181 }
182
183 static int msp_write(struct i2c_client *client, int dev, int addr, int val)
184 {
185 int err;
186 u8 buffer[5];
187
188 buffer[0] = dev;
189 buffer[1] = addr >> 8;
190 buffer[2] = addr & 0xff;
191 buffer[3] = val >> 8;
192 buffer[4] = val & 0xff;
193
194 v4l_dbg(3, msp_debug, client, "msp_write(0x%x, 0x%x, 0x%x)\n", dev, addr, val);
195 for (err = 0; err < 3; err++) {
196 if (i2c_master_send(client, buffer, 5) == 5)
197 break;
198 v4l_warn(client, "I/O error #%d (write 0x%02x/0x%02x)\n", err,
199 dev, addr);
200 current->state = TASK_INTERRUPTIBLE;
201 schedule_timeout(msecs_to_jiffies(10));
202 }
203 if (err == 3) {
204 v4l_warn(client, "giving up, resetting chip. Sound will go off, sorry folks :-|\n");
205 msp_reset(client);
206 return -1;
207 }
208 return 0;
209 }
210
211 int msp_write_dem(struct i2c_client *client, int addr, int val)
212 {
213 return msp_write(client, I2C_MSP_DEM, addr, val);
214 }
215
216 int msp_write_dsp(struct i2c_client *client, int addr, int val)
217 {
218 return msp_write(client, I2C_MSP_DSP, addr, val);
219 }
220
221 /* ----------------------------------------------------------------------- *
222 * bits 9 8 5 - SCART DSP input Select:
223 * 0 0 0 - SCART 1 to DSP input (reset position)
224 * 0 1 0 - MONO to DSP input
225 * 1 0 0 - SCART 2 to DSP input
226 * 1 1 1 - Mute DSP input
227 *
228 * bits 11 10 6 - SCART 1 Output Select:
229 * 0 0 0 - undefined (reset position)
230 * 0 1 0 - SCART 2 Input to SCART 1 Output (for devices with 2 SCARTS)
231 * 1 0 0 - MONO input to SCART 1 Output
232 * 1 1 0 - SCART 1 DA to SCART 1 Output
233 * 0 0 1 - SCART 2 DA to SCART 1 Output
234 * 0 1 1 - SCART 1 Input to SCART 1 Output
235 * 1 1 1 - Mute SCART 1 Output
236 *
237 * bits 13 12 7 - SCART 2 Output Select (for devices with 2 Output SCART):
238 * 0 0 0 - SCART 1 DA to SCART 2 Output (reset position)
239 * 0 1 0 - SCART 1 Input to SCART 2 Output
240 * 1 0 0 - MONO input to SCART 2 Output
241 * 0 0 1 - SCART 2 DA to SCART 2 Output
242 * 0 1 1 - SCART 2 Input to SCART 2 Output
243 * 1 1 0 - Mute SCART 2 Output
244 *
245 * Bits 4 to 0 should be zero.
246 * ----------------------------------------------------------------------- */
247
248 static int scarts[3][9] = {
249 /* MASK IN1 IN2 IN3 IN4 IN1_DA IN2_DA MONO MUTE */
250 /* SCART DSP Input select */
251 { 0x0320, 0x0000, 0x0200, 0x0300, 0x0020, -1, -1, 0x0100, 0x0320 },
252 /* SCART1 Output select */
253 { 0x0c40, 0x0440, 0x0400, 0x0000, 0x0840, 0x0c00, 0x0040, 0x0800, 0x0c40 },
254 /* SCART2 Output select */
255 { 0x3080, 0x1000, 0x1080, 0x2080, 0x3080, 0x0000, 0x0080, 0x2000, 0x3000 },
256 };
257
258 static char *scart_names[] = {
259 "in1", "in2", "in3", "in4", "in1 da", "in2 da", "mono", "mute"
260 };
261
262 void msp_set_scart(struct i2c_client *client, int in, int out)
263 {
264 struct msp_state *state = i2c_get_clientdata(client);
265
266 state->in_scart = in;
267
268 if (in >= 0 && in <= 7 && out >= 0 && out <= 2) {
269 if (-1 == scarts[out][in + 1])
270 return;
271
272 state->acb &= ~scarts[out][0];
273 state->acb |= scarts[out][in + 1];
274 } else
275 state->acb = 0xf60; /* Mute Input and SCART 1 Output */
276
277 v4l_dbg(1, msp_debug, client, "scart switch: %s => %d (ACB=0x%04x)\n",
278 scart_names[in], out, state->acb);
279 msp_write_dsp(client, 0x13, state->acb);
280
281 /* Sets I2S speed 0 = 1.024 Mbps, 1 = 2.048 Mbps */
282 if (state->has_i2s_conf)
283 msp_write_dem(client, 0x40, state->i2s_mode);
284 }
285
286 void msp_set_audio(struct i2c_client *client)
287 {
288 struct msp_state *state = i2c_get_clientdata(client);
289 int bal = 0, bass, treble, loudness;
290 int val = 0;
291 int reallymuted = state->muted | state->scan_in_progress;
292
293 if (!reallymuted)
294 val = (state->volume * 0x7f / 65535) << 8;
295
296 v4l_dbg(1, msp_debug, client, "mute=%s scanning=%s volume=%d\n",
297 state->muted ? "on" : "off", state->scan_in_progress ? "yes" : "no",
298 state->volume);
299
300 msp_write_dsp(client, 0x0000, val);
301 msp_write_dsp(client, 0x0007, reallymuted ? 0x1 : (val | 0x1));
302 if (state->has_scart2_out_volume)
303 msp_write_dsp(client, 0x0040, reallymuted ? 0x1 : (val | 0x1));
304 if (state->has_headphones)
305 msp_write_dsp(client, 0x0006, val);
306 if (!state->has_sound_processing)
307 return;
308
309 if (val)
310 bal = (u8)((state->balance / 256) - 128);
311 bass = ((state->bass - 32768) * 0x60 / 65535) << 8;
312 treble = ((state->treble - 32768) * 0x60 / 65535) << 8;
313 loudness = state->loudness ? ((5 * 4) << 8) : 0;
314
315 v4l_dbg(1, msp_debug, client, "balance=%d bass=%d treble=%d loudness=%d\n",
316 state->balance, state->bass, state->treble, state->loudness);
317
318 msp_write_dsp(client, 0x0001, bal << 8);
319 msp_write_dsp(client, 0x0002, bass);
320 msp_write_dsp(client, 0x0003, treble);
321 msp_write_dsp(client, 0x0004, loudness);
322 if (!state->has_headphones)
323 return;
324 msp_write_dsp(client, 0x0030, bal << 8);
325 msp_write_dsp(client, 0x0031, bass);
326 msp_write_dsp(client, 0x0032, treble);
327 msp_write_dsp(client, 0x0033, loudness);
328 }
329
330 /* ------------------------------------------------------------------------ */
331
332
333 static void msp_wake_thread(struct i2c_client *client)
334 {
335 struct msp_state *state = i2c_get_clientdata(client);
336
337 if (NULL == state->kthread)
338 return;
339 state->watch_stereo = 0;
340 state->restart = 1;
341 wake_up_interruptible(&state->wq);
342 }
343
344 int msp_sleep(struct msp_state *state, int timeout)
345 {
346 DECLARE_WAITQUEUE(wait, current);
347
348 add_wait_queue(&state->wq, &wait);
349 if (!kthread_should_stop()) {
350 if (timeout < 0) {
351 set_current_state(TASK_INTERRUPTIBLE);
352 schedule();
353 } else {
354 schedule_timeout_interruptible
355 (msecs_to_jiffies(timeout));
356 }
357 }
358
359 remove_wait_queue(&state->wq, &wait);
360 try_to_freeze();
361 return state->restart;
362 }
363
364 /* ------------------------------------------------------------------------ */
365 #ifdef CONFIG_VIDEO_V4L1
366 static int msp_mode_v4l2_to_v4l1(int rxsubchans, int audmode)
367 {
368 if (rxsubchans == V4L2_TUNER_SUB_MONO)
369 return VIDEO_SOUND_MONO;
370 if (rxsubchans == V4L2_TUNER_SUB_STEREO)
371 return VIDEO_SOUND_STEREO;
372 if (audmode == V4L2_TUNER_MODE_LANG2)
373 return VIDEO_SOUND_LANG2;
374 return VIDEO_SOUND_LANG1;
375 }
376
377 static int msp_mode_v4l1_to_v4l2(int mode)
378 {
379 if (mode & VIDEO_SOUND_STEREO)
380 return V4L2_TUNER_MODE_STEREO;
381 if (mode & VIDEO_SOUND_LANG2)
382 return V4L2_TUNER_MODE_LANG2;
383 if (mode & VIDEO_SOUND_LANG1)
384 return V4L2_TUNER_MODE_LANG1;
385 return V4L2_TUNER_MODE_MONO;
386 }
387 #endif
388
389 static int msp_get_ctrl(struct i2c_client *client, struct v4l2_control *ctrl)
390 {
391 struct msp_state *state = i2c_get_clientdata(client);
392
393 switch (ctrl->id) {
394 case V4L2_CID_AUDIO_VOLUME:
395 ctrl->value = state->volume;
396 break;
397
398 case V4L2_CID_AUDIO_MUTE:
399 ctrl->value = state->muted;
400 break;
401
402 case V4L2_CID_AUDIO_BALANCE:
403 if (!state->has_sound_processing)
404 return -EINVAL;
405 ctrl->value = state->balance;
406 break;
407
408 case V4L2_CID_AUDIO_BASS:
409 if (!state->has_sound_processing)
410 return -EINVAL;
411 ctrl->value = state->bass;
412 break;
413
414 case V4L2_CID_AUDIO_TREBLE:
415 if (!state->has_sound_processing)
416 return -EINVAL;
417 ctrl->value = state->treble;
418 break;
419
420 case V4L2_CID_AUDIO_LOUDNESS:
421 if (!state->has_sound_processing)
422 return -EINVAL;
423 ctrl->value = state->loudness;
424 break;
425
426 default:
427 return -EINVAL;
428 }
429 return 0;
430 }
431
432 static int msp_set_ctrl(struct i2c_client *client, struct v4l2_control *ctrl)
433 {
434 struct msp_state *state = i2c_get_clientdata(client);
435
436 switch (ctrl->id) {
437 case V4L2_CID_AUDIO_VOLUME:
438 state->volume = ctrl->value;
439 if (state->volume == 0)
440 state->balance = 32768;
441 break;
442
443 case V4L2_CID_AUDIO_MUTE:
444 if (ctrl->value < 0 || ctrl->value >= 2)
445 return -ERANGE;
446 state->muted = ctrl->value;
447 break;
448
449 case V4L2_CID_AUDIO_BASS:
450 if (!state->has_sound_processing)
451 return -EINVAL;
452 state->bass = ctrl->value;
453 break;
454
455 case V4L2_CID_AUDIO_TREBLE:
456 if (!state->has_sound_processing)
457 return -EINVAL;
458 state->treble = ctrl->value;
459 break;
460
461 case V4L2_CID_AUDIO_LOUDNESS:
462 if (!state->has_sound_processing)
463 return -EINVAL;
464 state->loudness = ctrl->value;
465 break;
466
467 case V4L2_CID_AUDIO_BALANCE:
468 if (!state->has_sound_processing)
469 return -EINVAL;
470 state->balance = ctrl->value;
471 break;
472
473 default:
474 return -EINVAL;
475 }
476 msp_set_audio(client);
477 return 0;
478 }
479
480 static int msp_command(struct i2c_client *client, unsigned int cmd, void *arg)
481 {
482 struct msp_state *state = i2c_get_clientdata(client);
483
484 if (msp_debug >= 2)
485 v4l_i2c_print_ioctl(client, cmd);
486
487 switch (cmd) {
488 case AUDC_SET_RADIO:
489 if (state->radio)
490 return 0;
491 state->radio = 1;
492 v4l_dbg(1, msp_debug, client, "switching to radio mode\n");
493 state->watch_stereo = 0;
494 switch (state->opmode) {
495 case OPMODE_MANUAL:
496 /* set msp3400 to FM radio mode */
497 msp3400c_set_mode(client, MSP_MODE_FM_RADIO);
498 msp3400c_set_carrier(client, MSP_CARRIER(10.7),
499 MSP_CARRIER(10.7));
500 msp_set_audio(client);
501 break;
502 case OPMODE_AUTODETECT:
503 case OPMODE_AUTOSELECT:
504 /* the thread will do for us */
505 msp_wake_thread(client);
506 break;
507 }
508 break;
509
510 /* --- v4l ioctls --- */
511 /* take care: bttv does userspace copying, we'll get a
512 kernel pointer here... */
513 #ifdef CONFIG_VIDEO_V4L1
514 case VIDIOCGAUDIO:
515 {
516 struct video_audio *va = arg;
517
518 va->flags |= VIDEO_AUDIO_VOLUME | VIDEO_AUDIO_MUTABLE;
519 if (state->has_sound_processing)
520 va->flags |= VIDEO_AUDIO_BALANCE |
521 VIDEO_AUDIO_BASS |
522 VIDEO_AUDIO_TREBLE;
523 if (state->muted)
524 va->flags |= VIDEO_AUDIO_MUTE;
525 va->volume = state->volume;
526 va->balance = state->volume ? state->balance : 32768;
527 va->bass = state->bass;
528 va->treble = state->treble;
529
530 if (state->radio)
531 break;
532 if (state->opmode == OPMODE_AUTOSELECT)
533 msp_detect_stereo(client);
534 va->mode = msp_mode_v4l2_to_v4l1(state->rxsubchans, state->audmode);
535 break;
536 }
537
538 case VIDIOCSAUDIO:
539 {
540 struct video_audio *va = arg;
541
542 state->muted = (va->flags & VIDEO_AUDIO_MUTE);
543 state->volume = va->volume;
544 state->balance = va->balance;
545 state->bass = va->bass;
546 state->treble = va->treble;
547 msp_set_audio(client);
548
549 if (va->mode != 0 && state->radio == 0 &&
550 state->audmode != msp_mode_v4l1_to_v4l2(va->mode)) {
551 state->audmode = msp_mode_v4l1_to_v4l2(va->mode);
552 msp_set_audmode(client);
553 }
554 break;
555 }
556
557 case VIDIOCSCHAN:
558 {
559 struct video_channel *vc = arg;
560 int update = 0;
561 v4l2_std_id std;
562
563 if (state->radio)
564 update = 1;
565 state->radio = 0;
566 if (vc->norm == VIDEO_MODE_PAL)
567 std = V4L2_STD_PAL;
568 else if (vc->norm == VIDEO_MODE_SECAM)
569 std = V4L2_STD_SECAM;
570 else
571 std = V4L2_STD_NTSC;
572 if (std != state->v4l2_std) {
573 state->v4l2_std = std;
574 update = 1;
575 }
576 if (update)
577 msp_wake_thread(client);
578 break;
579 }
580
581 case VIDIOCSFREQ:
582 {
583 /* new channel -- kick audio carrier scan */
584 msp_wake_thread(client);
585 break;
586 }
587 #endif
588 case VIDIOC_S_FREQUENCY:
589 {
590 /* new channel -- kick audio carrier scan */
591 msp_wake_thread(client);
592 break;
593 }
594
595 /* --- v4l2 ioctls --- */
596 case VIDIOC_S_STD:
597 {
598 v4l2_std_id *id = arg;
599 int update = state->radio || state->v4l2_std != *id;
600
601 state->v4l2_std = *id;
602 state->radio = 0;
603 if (update)
604 msp_wake_thread(client);
605 return 0;
606 }
607
608 case VIDIOC_INT_G_AUDIO_ROUTING:
609 {
610 struct v4l2_routing *rt = arg;
611
612 *rt = state->routing;
613 break;
614 }
615
616 case VIDIOC_INT_S_AUDIO_ROUTING:
617 {
618 struct v4l2_routing *rt = arg;
619 int tuner = (rt->input >> 3) & 1;
620 int sc_in = rt->input & 0x7;
621 int sc1_out = rt->output & 0xf;
622 int sc2_out = (rt->output >> 4) & 0xf;
623 u16 val, reg;
624 int i;
625 int extern_input = 1;
626
627 if (state->routing.input == rt->input &&
628 state->routing.output == rt->output)
629 break;
630 state->routing = *rt;
631 /* check if the tuner input is used */
632 for (i = 0; i < 5; i++) {
633 if (((rt->input >> (4 + i * 4)) & 0xf) == 0)
634 extern_input = 0;
635 }
636 state->mode = extern_input ? MSP_MODE_EXTERN : MSP_MODE_AM_DETECT;
637 state->rxsubchans = V4L2_TUNER_SUB_STEREO;
638 msp_set_scart(client, sc_in, 0);
639 msp_set_scart(client, sc1_out, 1);
640 msp_set_scart(client, sc2_out, 2);
641 msp_set_audmode(client);
642 reg = (state->opmode == OPMODE_AUTOSELECT) ? 0x30 : 0xbb;
643 val = msp_read_dem(client, reg);
644 msp_write_dem(client, reg, (val & ~0x100) | (tuner << 8));
645 /* wake thread when a new input is chosen */
646 msp_wake_thread(client);
647 break;
648 }
649
650 case VIDIOC_G_TUNER:
651 {
652 struct v4l2_tuner *vt = arg;
653
654 if (state->radio)
655 break;
656 if (state->opmode == OPMODE_AUTOSELECT)
657 msp_detect_stereo(client);
658 vt->audmode = state->audmode;
659 vt->rxsubchans = state->rxsubchans;
660 vt->capability |= V4L2_TUNER_CAP_STEREO |
661 V4L2_TUNER_CAP_LANG1 | V4L2_TUNER_CAP_LANG2;
662 break;
663 }
664
665 case VIDIOC_S_TUNER:
666 {
667 struct v4l2_tuner *vt = (struct v4l2_tuner *)arg;
668
669 if (state->radio) /* TODO: add mono/stereo support for radio */
670 break;
671 if (state->audmode == vt->audmode)
672 break;
673 state->audmode = vt->audmode;
674 /* only set audmode */
675 msp_set_audmode(client);
676 break;
677 }
678
679 case VIDIOC_INT_I2S_CLOCK_FREQ:
680 {
681 u32 *a = (u32 *)arg;
682
683 v4l_dbg(1, msp_debug, client, "Setting I2S speed to %d\n", *a);
684
685 switch (*a) {
686 case 1024000:
687 state->i2s_mode = 0;
688 break;
689 case 2048000:
690 state->i2s_mode = 1;
691 break;
692 default:
693 return -EINVAL;
694 }
695 break;
696 }
697
698 case VIDIOC_QUERYCTRL:
699 {
700 struct v4l2_queryctrl *qc = arg;
701
702 switch (qc->id) {
703 case V4L2_CID_AUDIO_VOLUME:
704 case V4L2_CID_AUDIO_MUTE:
705 return v4l2_ctrl_query_fill_std(qc);
706 default:
707 break;
708 }
709 if (!state->has_sound_processing)
710 return -EINVAL;
711 switch (qc->id) {
712 case V4L2_CID_AUDIO_LOUDNESS:
713 case V4L2_CID_AUDIO_BALANCE:
714 case V4L2_CID_AUDIO_BASS:
715 case V4L2_CID_AUDIO_TREBLE:
716 return v4l2_ctrl_query_fill_std(qc);
717 default:
718 return -EINVAL;
719 }
720 }
721
722 case VIDIOC_G_CTRL:
723 return msp_get_ctrl(client, arg);
724
725 case VIDIOC_S_CTRL:
726 return msp_set_ctrl(client, arg);
727
728 case VIDIOC_LOG_STATUS:
729 {
730 const char *p;
731
732 if (state->opmode == OPMODE_AUTOSELECT)
733 msp_detect_stereo(client);
734 v4l_info(client, "%s rev1 = 0x%04x rev2 = 0x%04x\n",
735 client->name, state->rev1, state->rev2);
736 v4l_info(client, "Audio: volume %d%s\n",
737 state->volume, state->muted ? " (muted)" : "");
738 if (state->has_sound_processing) {
739 v4l_info(client, "Audio: balance %d bass %d treble %d loudness %s\n",
740 state->balance, state->bass, state->treble,
741 state->loudness ? "on" : "off");
742 }
743 switch (state->mode) {
744 case MSP_MODE_AM_DETECT: p = "AM (for carrier detect)"; break;
745 case MSP_MODE_FM_RADIO: p = "FM Radio"; break;
746 case MSP_MODE_FM_TERRA: p = "Terrestial FM-mono + FM-stereo"; break;
747 case MSP_MODE_FM_SAT: p = "Satellite FM-mono"; break;
748 case MSP_MODE_FM_NICAM1: p = "NICAM/FM (B/G, D/K)"; break;
749 case MSP_MODE_FM_NICAM2: p = "NICAM/FM (I)"; break;
750 case MSP_MODE_AM_NICAM: p = "NICAM/AM (L)"; break;
751 case MSP_MODE_BTSC: p = "BTSC"; break;
752 case MSP_MODE_EXTERN: p = "External input"; break;
753 default: p = "unknown"; break;
754 }
755 if (state->mode == MSP_MODE_EXTERN) {
756 v4l_info(client, "Mode: %s\n", p);
757 } else if (state->opmode == OPMODE_MANUAL) {
758 v4l_info(client, "Mode: %s (%s%s)\n", p,
759 (state->rxsubchans & V4L2_TUNER_SUB_STEREO) ? "stereo" : "mono",
760 (state->rxsubchans & V4L2_TUNER_SUB_LANG2) ? ", dual" : "");
761 } else {
762 if (state->opmode == OPMODE_AUTODETECT)
763 v4l_info(client, "Mode: %s\n", p);
764 v4l_info(client, "Standard: %s (%s%s)\n",
765 msp_standard_std_name(state->std),
766 (state->rxsubchans & V4L2_TUNER_SUB_STEREO) ? "stereo" : "mono",
767 (state->rxsubchans & V4L2_TUNER_SUB_LANG2) ? ", dual" : "");
768 }
769 v4l_info(client, "Audmode: 0x%04x\n", state->audmode);
770 v4l_info(client, "Routing: 0x%08x (input) 0x%08x (output)\n",
771 state->routing.input, state->routing.output);
772 v4l_info(client, "ACB: 0x%04x\n", state->acb);
773 break;
774 }
775
776 case VIDIOC_G_CHIP_IDENT:
777 return v4l2_chip_ident_i2c_client(client, arg, state->ident, (state->rev1 << 16) | state->rev2);
778
779 default:
780 /* unknown */
781 return -EINVAL;
782 }
783 return 0;
784 }
785
786 static int msp_suspend(struct i2c_client *client, pm_message_t state)
787 {
788
789 v4l_dbg(1, msp_debug, client, "suspend\n");
790 msp_reset(client);
791 return 0;
792 }
793
794 static int msp_resume(struct i2c_client *client)
795 {
796
797 v4l_dbg(1, msp_debug, client, "resume\n");
798 msp_wake_thread(client);
799 return 0;
800 }
801
802 /* ----------------------------------------------------------------------- */
803
804 static struct i2c_driver i2c_driver;
805
806 static int msp_attach(struct i2c_adapter *adapter, int address, int kind)
807 {
808 struct i2c_client *client;
809 struct msp_state *state;
810 int (*thread_func)(void *data) = NULL;
811 int msp_hard;
812 int msp_family;
813 int msp_revision;
814 int msp_product, msp_prod_hi, msp_prod_lo;
815 int msp_rom;
816
817 client = kmalloc(sizeof(*client), GFP_KERNEL);
818 if (client == NULL)
819 return -ENOMEM;
820 memset(client, 0, sizeof(*client));
821 client->addr = address;
822 client->adapter = adapter;
823 client->driver = &i2c_driver;
824 snprintf(client->name, sizeof(client->name) - 1, "msp3400");
825
826 if (msp_reset(client) == -1) {
827 v4l_dbg(1, msp_debug, client, "msp3400 not found\n");
828 kfree(client);
829 return 0;
830 }
831
832 state = kmalloc(sizeof(*state), GFP_KERNEL);
833 if (state == NULL) {
834 kfree(client);
835 return -ENOMEM;
836 }
837 i2c_set_clientdata(client, state);
838
839 memset(state, 0, sizeof(*state));
840 state->v4l2_std = V4L2_STD_NTSC;
841 state->audmode = V4L2_TUNER_MODE_STEREO;
842 state->volume = 58880; /* 0db gain */
843 state->balance = 32768; /* 0db gain */
844 state->bass = 32768;
845 state->treble = 32768;
846 state->loudness = 0;
847 state->input = -1;
848 state->muted = 0;
849 state->i2s_mode = 0;
850 init_waitqueue_head(&state->wq);
851 /* These are the reset input/output positions */
852 state->routing.input = MSP_INPUT_DEFAULT;
853 state->routing.output = MSP_OUTPUT_DEFAULT;
854
855 state->rev1 = msp_read_dsp(client, 0x1e);
856 if (state->rev1 != -1)
857 state->rev2 = msp_read_dsp(client, 0x1f);
858 v4l_dbg(1, msp_debug, client, "rev1=0x%04x, rev2=0x%04x\n", state->rev1, state->rev2);
859 if (state->rev1 == -1 || (state->rev1 == 0 && state->rev2 == 0)) {
860 v4l_dbg(1, msp_debug, client, "not an msp3400 (cannot read chip version)\n");
861 kfree(state);
862 kfree(client);
863 return 0;
864 }
865
866 msp_set_audio(client);
867
868 msp_family = ((state->rev1 >> 4) & 0x0f) + 3;
869 msp_product = (state->rev2 >> 8) & 0xff;
870 msp_prod_hi = msp_product / 10;
871 msp_prod_lo = msp_product % 10;
872 msp_revision = (state->rev1 & 0x0f) + '@';
873 msp_hard = ((state->rev1 >> 8) & 0xff) + '@';
874 msp_rom = state->rev2 & 0x1f;
875 snprintf(client->name, sizeof(client->name), "MSP%d4%02d%c-%c%d",
876 msp_family, msp_product,
877 msp_revision, msp_hard, msp_rom);
878 /* Rev B=2, C=3, D=4, G=7 */
879 state->ident = msp_family * 10000 + 4000 + msp_product * 10 + msp_revision - '@';
880
881 /* Has NICAM support: all mspx41x and mspx45x products have NICAM */
882 state->has_nicam = msp_prod_hi == 1 || msp_prod_hi == 5;
883 /* Has radio support: was added with revision G */
884 state->has_radio = msp_revision >= 'G';
885 /* Has headphones output: not for stripped down products */
886 state->has_headphones = msp_prod_lo < 5;
887 /* Has scart2 input: not in stripped down products of the '3' family */
888 state->has_scart2 = msp_family >= 4 || msp_prod_lo < 7;
889 /* Has scart3 input: not in stripped down products of the '3' family */
890 state->has_scart3 = msp_family >= 4 || msp_prod_lo < 5;
891 /* Has scart4 input: not in pre D revisions, not in stripped D revs */
892 state->has_scart4 = msp_family >= 4 || (msp_revision >= 'D' && msp_prod_lo < 5);
893 /* Has scart2 output: not in stripped down products of the '3' family */
894 state->has_scart2_out = msp_family >= 4 || msp_prod_lo < 5;
895 /* Has scart2 a volume control? Not in pre-D revisions. */
896 state->has_scart2_out_volume = msp_revision > 'C' && state->has_scart2_out;
897 /* Has a configurable i2s out? */
898 state->has_i2s_conf = msp_revision >= 'G' && msp_prod_lo < 7;
899 /* Has subwoofer output: not in pre-D revs and not in stripped down products */
900 state->has_subwoofer = msp_revision >= 'D' && msp_prod_lo < 5;
901 /* Has soundprocessing (bass/treble/balance/loudness/equalizer): not in
902 stripped down products */
903 state->has_sound_processing = msp_prod_lo < 7;
904 /* Has Virtual Dolby Surround: only in msp34x1 */
905 state->has_virtual_dolby_surround = msp_revision == 'G' && msp_prod_lo == 1;
906 /* Has Virtual Dolby Surround & Dolby Pro Logic: only in msp34x2 */
907 state->has_dolby_pro_logic = msp_revision == 'G' && msp_prod_lo == 2;
908 /* The msp343xG supports BTSC only and cannot do Automatic Standard Detection. */
909 state->force_btsc = msp_family == 3 && msp_revision == 'G' && msp_prod_hi == 3;
910
911 state->opmode = opmode;
912 if (state->opmode == OPMODE_AUTO) {
913 /* MSP revision G and up have both autodetect and autoselect */
914 if (msp_revision >= 'G')
915 state->opmode = OPMODE_AUTOSELECT;
916 /* MSP revision D and up have autodetect */
917 else if (msp_revision >= 'D')
918 state->opmode = OPMODE_AUTODETECT;
919 else
920 state->opmode = OPMODE_MANUAL;
921 }
922
923 /* hello world :-) */
924 v4l_info(client, "%s found @ 0x%x (%s)\n", client->name, address << 1, adapter->name);
925 v4l_info(client, "%s ", client->name);
926 if (state->has_nicam && state->has_radio)
927 printk("supports nicam and radio, ");
928 else if (state->has_nicam)
929 printk("supports nicam, ");
930 else if (state->has_radio)
931 printk("supports radio, ");
932 printk("mode is ");
933
934 /* version-specific initialization */
935 switch (state->opmode) {
936 case OPMODE_MANUAL:
937 printk("manual");
938 thread_func = msp3400c_thread;
939 break;
940 case OPMODE_AUTODETECT:
941 printk("autodetect");
942 thread_func = msp3410d_thread;
943 break;
944 case OPMODE_AUTOSELECT:
945 printk("autodetect and autoselect");
946 thread_func = msp34xxg_thread;
947 break;
948 }
949 printk("\n");
950
951 /* startup control thread if needed */
952 if (thread_func) {
953 state->kthread = kthread_run(thread_func, client, "msp34xx");
954
955 if (IS_ERR(state->kthread))
956 v4l_warn(client, "kernel_thread() failed\n");
957 msp_wake_thread(client);
958 }
959
960 /* done */
961 i2c_attach_client(client);
962
963 return 0;
964 }
965
966 static int msp_probe(struct i2c_adapter *adapter)
967 {
968 if (adapter->class & I2C_CLASS_TV_ANALOG)
969 return i2c_probe(adapter, &addr_data, msp_attach);
970 return 0;
971 }
972
973 static int msp_detach(struct i2c_client *client)
974 {
975 struct msp_state *state = i2c_get_clientdata(client);
976 int err;
977
978 /* shutdown control thread */
979 if (state->kthread) {
980 state->restart = 1;
981 kthread_stop(state->kthread);
982 }
983 msp_reset(client);
984
985 err = i2c_detach_client(client);
986 if (err) {
987 return err;
988 }
989
990 kfree(state);
991 kfree(client);
992 return 0;
993 }
994
995 /* ----------------------------------------------------------------------- */
996
997 /* i2c implementation */
998 static struct i2c_driver i2c_driver = {
999 .id = I2C_DRIVERID_MSP3400,
1000 .attach_adapter = msp_probe,
1001 .detach_client = msp_detach,
1002 .suspend = msp_suspend,
1003 .resume = msp_resume,
1004 .command = msp_command,
1005 .driver = {
1006 .name = "msp3400",
1007 },
1008 };
1009
1010 static int __init msp3400_init_module(void)
1011 {
1012 return i2c_add_driver(&i2c_driver);
1013 }
1014
1015 static void __exit msp3400_cleanup_module(void)
1016 {
1017 i2c_del_driver(&i2c_driver);
1018 }
1019
1020 module_init(msp3400_init_module);
1021 module_exit(msp3400_cleanup_module);
1022
1023 /*
1024 * Overrides for Emacs so that we follow Linus's tabbing style.
1025 * ---------------------------------------------------------------------------
1026 * Local variables:
1027 * c-basic-offset: 8
1028 * End:
1029 */
Support for the Chinese Samsung S3C2440 based development boards