projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[PATCH] Add include/linux/freezer.h and move definitions from sched.h
[deliverable/linux.git] / drivers / media / video / msp3400-driver.c
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 if (extern_input)
637 state->mode = MSP_MODE_EXTERN;
638 else
639 state->mode = MSP_MODE_AM_DETECT;
640 msp_set_scart(client, sc_in, 0);
641 msp_set_scart(client, sc1_out, 1);
642 msp_set_scart(client, sc2_out, 2);
643 msp_set_audmode(client);
644 reg = (state->opmode == OPMODE_AUTOSELECT) ? 0x30 : 0xbb;
645 val = msp_read_dem(client, reg);
646 msp_write_dem(client, reg, (val & ~0x100) | (tuner << 8));
647 /* wake thread when a new input is chosen */
648 msp_wake_thread(client);
649 break;
650 }
651
652 case VIDIOC_G_TUNER:
653 {
654 struct v4l2_tuner *vt = arg;
655
656 if (state->radio)
657 break;
658 if (state->opmode == OPMODE_AUTOSELECT)
659 msp_detect_stereo(client);
660 vt->audmode = state->audmode;
661 vt->rxsubchans = state->rxsubchans;
662 vt->capability |= V4L2_TUNER_CAP_STEREO |
663 V4L2_TUNER_CAP_LANG1 | V4L2_TUNER_CAP_LANG2;
664 break;
665 }
666
667 case VIDIOC_S_TUNER:
668 {
669 struct v4l2_tuner *vt = (struct v4l2_tuner *)arg;
670
671 if (state->radio) /* TODO: add mono/stereo support for radio */
672 break;
673 if (state->audmode == vt->audmode)
674 break;
675 state->audmode = vt->audmode;
676 /* only set audmode */
677 msp_set_audmode(client);
678 break;
679 }
680
681 case VIDIOC_INT_I2S_CLOCK_FREQ:
682 {
683 u32 *a = (u32 *)arg;
684
685 v4l_dbg(1, msp_debug, client, "Setting I2S speed to %d\n", *a);
686
687 switch (*a) {
688 case 1024000:
689 state->i2s_mode = 0;
690 break;
691 case 2048000:
692 state->i2s_mode = 1;
693 break;
694 default:
695 return -EINVAL;
696 }
697 break;
698 }
699
700 case VIDIOC_QUERYCTRL:
701 {
702 struct v4l2_queryctrl *qc = arg;
703
704 switch (qc->id) {
705 case V4L2_CID_AUDIO_VOLUME:
706 case V4L2_CID_AUDIO_MUTE:
707 return v4l2_ctrl_query_fill_std(qc);
708 default:
709 break;
710 }
711 if (!state->has_sound_processing)
712 return -EINVAL;
713 switch (qc->id) {
714 case V4L2_CID_AUDIO_LOUDNESS:
715 case V4L2_CID_AUDIO_BALANCE:
716 case V4L2_CID_AUDIO_BASS:
717 case V4L2_CID_AUDIO_TREBLE:
718 return v4l2_ctrl_query_fill_std(qc);
719 default:
720 return -EINVAL;
721 }
722 }
723
724 case VIDIOC_G_CTRL:
725 return msp_get_ctrl(client, arg);
726
727 case VIDIOC_S_CTRL:
728 return msp_set_ctrl(client, arg);
729
730 case VIDIOC_LOG_STATUS:
731 {
732 const char *p;
733
734 if (state->opmode == OPMODE_AUTOSELECT)
735 msp_detect_stereo(client);
736 v4l_info(client, "%s rev1 = 0x%04x rev2 = 0x%04x\n",
737 client->name, state->rev1, state->rev2);
738 v4l_info(client, "Audio: volume %d%s\n",
739 state->volume, state->muted ? " (muted)" : "");
740 if (state->has_sound_processing) {
741 v4l_info(client, "Audio: balance %d bass %d treble %d loudness %s\n",
742 state->balance, state->bass, state->treble,
743 state->loudness ? "on" : "off");
744 }
745 switch (state->mode) {
746 case MSP_MODE_AM_DETECT: p = "AM (for carrier detect)"; break;
747 case MSP_MODE_FM_RADIO: p = "FM Radio"; break;
748 case MSP_MODE_FM_TERRA: p = "Terrestial FM-mono + FM-stereo"; break;
749 case MSP_MODE_FM_SAT: p = "Satellite FM-mono"; break;
750 case MSP_MODE_FM_NICAM1: p = "NICAM/FM (B/G, D/K)"; break;
751 case MSP_MODE_FM_NICAM2: p = "NICAM/FM (I)"; break;
752 case MSP_MODE_AM_NICAM: p = "NICAM/AM (L)"; break;
753 case MSP_MODE_BTSC: p = "BTSC"; break;
754 case MSP_MODE_EXTERN: p = "External input"; break;
755 default: p = "unknown"; break;
756 }
757 if (state->mode == MSP_MODE_EXTERN) {
758 v4l_info(client, "Mode: %s\n", p);
759 } else if (state->opmode == OPMODE_MANUAL) {
760 v4l_info(client, "Mode: %s (%s%s)\n", p,
761 (state->rxsubchans & V4L2_TUNER_SUB_STEREO) ? "stereo" : "mono",
762 (state->rxsubchans & V4L2_TUNER_SUB_LANG2) ? ", dual" : "");
763 } else {
764 if (state->opmode == OPMODE_AUTODETECT)
765 v4l_info(client, "Mode: %s\n", p);
766 v4l_info(client, "Standard: %s (%s%s)\n",
767 msp_standard_std_name(state->std),
768 (state->rxsubchans & V4L2_TUNER_SUB_STEREO) ? "stereo" : "mono",
769 (state->rxsubchans & V4L2_TUNER_SUB_LANG2) ? ", dual" : "");
770 }
771 v4l_info(client, "Audmode: 0x%04x\n", state->audmode);
772 v4l_info(client, "Routing: 0x%08x (input) 0x%08x (output)\n",
773 state->routing.input, state->routing.output);
774 v4l_info(client, "ACB: 0x%04x\n", state->acb);
775 break;
776 }
777
778 default:
779 /* unknown */
780 return -EINVAL;
781 }
782 return 0;
783 }
784
785 static int msp_suspend(struct device * dev, pm_message_t state)
786 {
787 struct i2c_client *client = container_of(dev, struct i2c_client, dev);
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 device * dev)
795 {
796 struct i2c_client *client = container_of(dev, struct i2c_client, dev);
797
798 v4l_dbg(1, msp_debug, client, "resume\n");
799 msp_wake_thread(client);
800 return 0;
801 }
802
803 /* ----------------------------------------------------------------------- */
804
805 static struct i2c_driver i2c_driver;
806
807 static int msp_attach(struct i2c_adapter *adapter, int address, int kind)
808 {
809 struct i2c_client *client;
810 struct msp_state *state;
811 int (*thread_func)(void *data) = NULL;
812 int msp_hard;
813 int msp_family;
814 int msp_revision;
815 int msp_product, msp_prod_hi, msp_prod_lo;
816 int msp_rom;
817
818 client = kmalloc(sizeof(*client), GFP_KERNEL);
819 if (client == NULL)
820 return -ENOMEM;
821 memset(client, 0, sizeof(*client));
822 client->addr = address;
823 client->adapter = adapter;
824 client->driver = &i2c_driver;
825 snprintf(client->name, sizeof(client->name) - 1, "msp3400");
826
827 if (msp_reset(client) == -1) {
828 v4l_dbg(1, msp_debug, client, "msp3400 not found\n");
829 kfree(client);
830 return -1;
831 }
832
833 state = kmalloc(sizeof(*state), GFP_KERNEL);
834 if (state == NULL) {
835 kfree(client);
836 return -ENOMEM;
837 }
838 i2c_set_clientdata(client, state);
839
840 memset(state, 0, sizeof(*state));
841 state->v4l2_std = V4L2_STD_NTSC;
842 state->audmode = V4L2_TUNER_MODE_STEREO;
843 state->volume = 58880; /* 0db gain */
844 state->balance = 32768; /* 0db gain */
845 state->bass = 32768;
846 state->treble = 32768;
847 state->loudness = 0;
848 state->input = -1;
849 state->muted = 0;
850 state->i2s_mode = 0;
851 init_waitqueue_head(&state->wq);
852 /* These are the reset input/output positions */
853 state->routing.input = MSP_INPUT_DEFAULT;
854 state->routing.output = MSP_OUTPUT_DEFAULT;
855
856 state->rev1 = msp_read_dsp(client, 0x1e);
857 if (state->rev1 != -1)
858 state->rev2 = msp_read_dsp(client, 0x1f);
859 v4l_dbg(1, msp_debug, client, "rev1=0x%04x, rev2=0x%04x\n", state->rev1, state->rev2);
860 if (state->rev1 == -1 || (state->rev1 == 0 && state->rev2 == 0)) {
861 v4l_dbg(1, msp_debug, client, "not an msp3400 (cannot read chip version)\n");
862 kfree(state);
863 kfree(client);
864 return -1;
865 }
866
867 msp_set_audio(client);
868
869 msp_family = ((state->rev1 >> 4) & 0x0f) + 3;
870 msp_product = (state->rev2 >> 8) & 0xff;
871 msp_prod_hi = msp_product / 10;
872 msp_prod_lo = msp_product % 10;
873 msp_revision = (state->rev1 & 0x0f) + '@';
874 msp_hard = ((state->rev1 >> 8) & 0xff) + '@';
875 msp_rom = state->rev2 & 0x1f;
876 snprintf(client->name, sizeof(client->name), "MSP%d4%02d%c-%c%d",
877 msp_family, msp_product,
878 msp_revision, msp_hard, msp_rom);
879
880 /* Has NICAM support: all mspx41x and mspx45x products have NICAM */
881 state->has_nicam = msp_prod_hi == 1 || msp_prod_hi == 5;
882 /* Has radio support: was added with revision G */
883 state->has_radio = msp_revision >= 'G';
884 /* Has headphones output: not for stripped down products */
885 state->has_headphones = msp_prod_lo < 5;
886 /* Has scart2 input: not in stripped down products of the '3' family */
887 state->has_scart2 = msp_family >= 4 || msp_prod_lo < 7;
888 /* Has scart3 input: not in stripped down products of the '3' family */
889 state->has_scart3 = msp_family >= 4 || msp_prod_lo < 5;
890 /* Has scart4 input: not in pre D revisions, not in stripped D revs */
891 state->has_scart4 = msp_family >= 4 || (msp_revision >= 'D' && msp_prod_lo < 5);
892 /* Has scart2 output: not in stripped down products of the '3' family */
893 state->has_scart2_out = msp_family >= 4 || msp_prod_lo < 5;
894 /* Has scart2 a volume control? Not in pre-D revisions. */
895 state->has_scart2_out_volume = msp_revision > 'C' && state->has_scart2_out;
896 /* Has a configurable i2s out? */
897 state->has_i2s_conf = msp_revision >= 'G' && msp_prod_lo < 7;
898 /* Has subwoofer output: not in pre-D revs and not in stripped down products */
899 state->has_subwoofer = msp_revision >= 'D' && msp_prod_lo < 5;
900 /* Has soundprocessing (bass/treble/balance/loudness/equalizer): not in
901 stripped down products */
902 state->has_sound_processing = msp_prod_lo < 7;
903 /* Has Virtual Dolby Surround: only in msp34x1 */
904 state->has_virtual_dolby_surround = msp_revision == 'G' && msp_prod_lo == 1;
905 /* Has Virtual Dolby Surround & Dolby Pro Logic: only in msp34x2 */
906 state->has_dolby_pro_logic = msp_revision == 'G' && msp_prod_lo == 2;
907 /* The msp343xG supports BTSC only and cannot do Automatic Standard Detection. */
908 state->force_btsc = msp_family == 3 && msp_revision == 'G' && msp_prod_hi == 3;
909
910 state->opmode = opmode;
911 if (state->opmode == OPMODE_AUTO) {
912 /* MSP revision G and up have both autodetect and autoselect */
913 if (msp_revision >= 'G')
914 state->opmode = OPMODE_AUTOSELECT;
915 /* MSP revision D and up have autodetect */
916 else if (msp_revision >= 'D')
917 state->opmode = OPMODE_AUTODETECT;
918 else
919 state->opmode = OPMODE_MANUAL;
920 }
921
922 /* hello world :-) */
923 v4l_info(client, "%s found @ 0x%x (%s)\n", client->name, address << 1, adapter->name);
924 v4l_info(client, "%s ", client->name);
925 if (state->has_nicam && state->has_radio)
926 printk("supports nicam and radio, ");
927 else if (state->has_nicam)
928 printk("supports nicam, ");
929 else if (state->has_radio)
930 printk("supports radio, ");
931 printk("mode is ");
932
933 /* version-specific initialization */
934 switch (state->opmode) {
935 case OPMODE_MANUAL:
936 printk("manual");
937 thread_func = msp3400c_thread;
938 break;
939 case OPMODE_AUTODETECT:
940 printk("autodetect");
941 thread_func = msp3410d_thread;
942 break;
943 case OPMODE_AUTOSELECT:
944 printk("autodetect and autoselect");
945 thread_func = msp34xxg_thread;
946 break;
947 }
948 printk("\n");
949
950 /* startup control thread if needed */
951 if (thread_func) {
952 state->kthread = kthread_run(thread_func, client, "msp34xx");
953
954 if (state->kthread == NULL)
955 v4l_warn(client, "kernel_thread() failed\n");
956 msp_wake_thread(client);
957 }
958
959 /* done */
960 i2c_attach_client(client);
961
962 return 0;
963 }
964
965 static int msp_probe(struct i2c_adapter *adapter)
966 {
967 if (adapter->class & I2C_CLASS_TV_ANALOG)
968 return i2c_probe(adapter, &addr_data, msp_attach);
969 return 0;
970 }
971
972 static int msp_detach(struct i2c_client *client)
973 {
974 struct msp_state *state = i2c_get_clientdata(client);
975 int err;
976
977 /* shutdown control thread */
978 if (state->kthread) {
979 state->restart = 1;
980 kthread_stop(state->kthread);
981 }
982 msp_reset(client);
983
984 err = i2c_detach_client(client);
985 if (err) {
986 return err;
987 }
988
989 kfree(state);
990 kfree(client);
991 return 0;
992 }
993
994 /* ----------------------------------------------------------------------- */
995
996 /* i2c implementation */
997 static struct i2c_driver i2c_driver = {
998 .id = I2C_DRIVERID_MSP3400,
999 .attach_adapter = msp_probe,
1000 .detach_client = msp_detach,
1001 .command = msp_command,
1002 .driver = {
1003 .name = "msp3400",
1004 .suspend = msp_suspend,
1005 .resume = msp_resume,
1006 },
1007 };
1008
1009 static int __init msp3400_init_module(void)
1010 {
1011 return i2c_add_driver(&i2c_driver);
1012 }
1013
1014 static void __exit msp3400_cleanup_module(void)
1015 {
1016 i2c_del_driver(&i2c_driver);
1017 }
1018
1019 module_init(msp3400_init_module);
1020 module_exit(msp3400_cleanup_module);
1021
1022 /*
1023 * Overrides for Emacs so that we follow Linus's tabbing style.
1024 * ---------------------------------------------------------------------------
1025 * Local variables:
1026 * c-basic-offset: 8
1027 * End:
1028 */
Linux kernel - Deliverables
This page took 0.0867 seconds and 5 git commands to generate.