1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50#include <linux/kernel.h>
51#include <linux/module.h>
52#include <linux/slab.h>
53#include <linux/i2c.h>
54#include <linux/kthread.h>
55#include <linux/freezer.h>
56#include <linux/videodev2.h>
57#include <media/v4l2-device.h>
58#include <media/v4l2-ioctl.h>
59#include <media/v4l2-i2c-drv.h>
60#include <media/msp3400.h>
61#include <media/tvaudio.h>
62#include "msp3400-driver.h"
63
64
65
66MODULE_DESCRIPTION("device driver for msp34xx TV sound processor");
67MODULE_AUTHOR("Gerd Knorr");
68MODULE_LICENSE("GPL");
69
70
71static int opmode = OPMODE_AUTO;
72int msp_debug;
73int msp_once;
74int msp_amsound;
75
76int msp_standard = 1;
77
78int msp_dolby;
79
80int msp_stereo_thresh = 0x190;
81
82
83
84module_param(opmode, int, 0444);
85
86
87module_param_named(once, msp_once, bool, 0644);
88module_param_named(debug, msp_debug, int, 0644);
89module_param_named(stereo_threshold, msp_stereo_thresh, int, 0644);
90module_param_named(standard, msp_standard, int, 0644);
91module_param_named(amsound, msp_amsound, bool, 0644);
92module_param_named(dolby, msp_dolby, bool, 0644);
93
94MODULE_PARM_DESC(opmode, "Forces a MSP3400 opmode. 0=Manual, 1=Autodetect, 2=Autodetect and autoselect");
95MODULE_PARM_DESC(once, "No continuous stereo monitoring");
96MODULE_PARM_DESC(debug, "Enable debug messages [0-3]");
97MODULE_PARM_DESC(stereo_threshold, "Sets signal threshold to activate stereo");
98MODULE_PARM_DESC(standard, "Specify audio standard: 32 = NTSC, 64 = radio, Default: Autodetect");
99MODULE_PARM_DESC(amsound, "Hardwire AM sound at 6.5Hz (France), FM can autoscan");
100MODULE_PARM_DESC(dolby, "Activates Dolby processsing");
101
102
103
104
105#define I2C_MSP_CONTROL 0x00
106
107#define I2C_MSP_DEM 0x10
108
109#define I2C_MSP_DSP 0x12
110
111
112
113
114
115int msp_reset(struct i2c_client *client)
116{
117
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
141static 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 schedule_timeout_interruptible(msecs_to_jiffies(10));
161 }
162 if (err == 3) {
163 v4l_warn(client, "resetting chip, sound will go off.\n");
164 msp_reset(client);
165 return -1;
166 }
167 retval = read[0] << 8 | read[1];
168 v4l_dbg(3, msp_debug, client, "msp_read(0x%x, 0x%x): 0x%x\n",
169 dev, addr, retval);
170 return retval;
171}
172
173int msp_read_dem(struct i2c_client *client, int addr)
174{
175 return msp_read(client, I2C_MSP_DEM, addr);
176}
177
178int msp_read_dsp(struct i2c_client *client, int addr)
179{
180 return msp_read(client, I2C_MSP_DSP, addr);
181}
182
183static 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",
195 dev, addr, val);
196 for (err = 0; err < 3; err++) {
197 if (i2c_master_send(client, buffer, 5) == 5)
198 break;
199 v4l_warn(client, "I/O error #%d (write 0x%02x/0x%02x)\n", err,
200 dev, addr);
201 schedule_timeout_interruptible(msecs_to_jiffies(10));
202 }
203 if (err == 3) {
204 v4l_warn(client, "resetting chip, sound will go off.\n");
205 msp_reset(client);
206 return -1;
207 }
208 return 0;
209}
210
211int msp_write_dem(struct i2c_client *client, int addr, int val)
212{
213 return msp_write(client, I2C_MSP_DEM, addr, val);
214}
215
216int 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
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248static int scarts[3][9] = {
249
250
251 { 0x0320, 0x0000, 0x0200, 0x0300, 0x0020, -1, -1, 0x0100, 0x0320 },
252
253 { 0x0c40, 0x0440, 0x0400, 0x0000, 0x0840, 0x0c00, 0x0040, 0x0800, 0x0c40 },
254
255 { 0x3080, 0x1000, 0x1080, 0x2080, 0x3080, 0x0000, 0x0080, 0x2000, 0x3000 },
256};
257
258static char *scart_names[] = {
259 "in1", "in2", "in3", "in4", "in1 da", "in2 da", "mono", "mute"
260};
261
262void msp_set_scart(struct i2c_client *client, int in, int out)
263{
264 struct msp_state *state = to_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;
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
282 if (state->has_i2s_conf)
283 msp_write_dem(client, 0x40, state->i2s_mode);
284}
285
286void msp_set_audio(struct i2c_client *client)
287{
288 struct msp_state *state = to_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",
298 state->scan_in_progress ? "yes" : "no",
299 state->volume);
300
301 msp_write_dsp(client, 0x0000, val);
302 msp_write_dsp(client, 0x0007, reallymuted ? 0x1 : (val | 0x1));
303 if (state->has_scart2_out_volume)
304 msp_write_dsp(client, 0x0040, reallymuted ? 0x1 : (val | 0x1));
305 if (state->has_headphones)
306 msp_write_dsp(client, 0x0006, val);
307 if (!state->has_sound_processing)
308 return;
309
310 if (val)
311 bal = (u8)((state->balance / 256) - 128);
312 bass = ((state->bass - 32768) * 0x60 / 65535) << 8;
313 treble = ((state->treble - 32768) * 0x60 / 65535) << 8;
314 loudness = state->loudness ? ((5 * 4) << 8) : 0;
315
316 v4l_dbg(1, msp_debug, client, "balance=%d bass=%d treble=%d loudness=%d\n",
317 state->balance, state->bass, state->treble, state->loudness);
318
319 msp_write_dsp(client, 0x0001, bal << 8);
320 msp_write_dsp(client, 0x0002, bass);
321 msp_write_dsp(client, 0x0003, treble);
322 msp_write_dsp(client, 0x0004, loudness);
323 if (!state->has_headphones)
324 return;
325 msp_write_dsp(client, 0x0030, bal << 8);
326 msp_write_dsp(client, 0x0031, bass);
327 msp_write_dsp(client, 0x0032, treble);
328 msp_write_dsp(client, 0x0033, loudness);
329}
330
331
332
333static void msp_wake_thread(struct i2c_client *client)
334{
335 struct msp_state *state = to_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
344int 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
366static int msp_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
367{
368 struct msp_state *state = to_state(sd);
369
370 switch (ctrl->id) {
371 case V4L2_CID_AUDIO_VOLUME:
372 ctrl->value = state->volume;
373 break;
374
375 case V4L2_CID_AUDIO_MUTE:
376 ctrl->value = state->muted;
377 break;
378
379 case V4L2_CID_AUDIO_BALANCE:
380 if (!state->has_sound_processing)
381 return -EINVAL;
382 ctrl->value = state->balance;
383 break;
384
385 case V4L2_CID_AUDIO_BASS:
386 if (!state->has_sound_processing)
387 return -EINVAL;
388 ctrl->value = state->bass;
389 break;
390
391 case V4L2_CID_AUDIO_TREBLE:
392 if (!state->has_sound_processing)
393 return -EINVAL;
394 ctrl->value = state->treble;
395 break;
396
397 case V4L2_CID_AUDIO_LOUDNESS:
398 if (!state->has_sound_processing)
399 return -EINVAL;
400 ctrl->value = state->loudness;
401 break;
402
403 default:
404 return -EINVAL;
405 }
406 return 0;
407}
408
409static int msp_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
410{
411 struct msp_state *state = to_state(sd);
412 struct i2c_client *client = v4l2_get_subdevdata(sd);
413
414 switch (ctrl->id) {
415 case V4L2_CID_AUDIO_VOLUME:
416 state->volume = ctrl->value;
417 if (state->volume == 0)
418 state->balance = 32768;
419 break;
420
421 case V4L2_CID_AUDIO_MUTE:
422 if (ctrl->value < 0 || ctrl->value >= 2)
423 return -ERANGE;
424 state->muted = ctrl->value;
425 break;
426
427 case V4L2_CID_AUDIO_BASS:
428 if (!state->has_sound_processing)
429 return -EINVAL;
430 state->bass = ctrl->value;
431 break;
432
433 case V4L2_CID_AUDIO_TREBLE:
434 if (!state->has_sound_processing)
435 return -EINVAL;
436 state->treble = ctrl->value;
437 break;
438
439 case V4L2_CID_AUDIO_LOUDNESS:
440 if (!state->has_sound_processing)
441 return -EINVAL;
442 state->loudness = ctrl->value;
443 break;
444
445 case V4L2_CID_AUDIO_BALANCE:
446 if (!state->has_sound_processing)
447 return -EINVAL;
448 state->balance = ctrl->value;
449 break;
450
451 default:
452 return -EINVAL;
453 }
454 msp_set_audio(client);
455 return 0;
456}
457
458
459static int msp_s_radio(struct v4l2_subdev *sd)
460{
461 struct msp_state *state = to_state(sd);
462 struct i2c_client *client = v4l2_get_subdevdata(sd);
463
464 if (state->radio)
465 return 0;
466 state->radio = 1;
467 v4l_dbg(1, msp_debug, client, "switching to radio mode\n");
468 state->watch_stereo = 0;
469 switch (state->opmode) {
470 case OPMODE_MANUAL:
471
472 msp3400c_set_mode(client, MSP_MODE_FM_RADIO);
473 msp3400c_set_carrier(client, MSP_CARRIER(10.7),
474 MSP_CARRIER(10.7));
475 msp_set_audio(client);
476 break;
477 case OPMODE_AUTODETECT:
478 case OPMODE_AUTOSELECT:
479
480 msp_wake_thread(client);
481 break;
482 }
483 return 0;
484}
485
486static int msp_s_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *freq)
487{
488 struct i2c_client *client = v4l2_get_subdevdata(sd);
489
490
491 msp_wake_thread(client);
492 return 0;
493}
494
495static int msp_s_std(struct v4l2_subdev *sd, v4l2_std_id id)
496{
497 struct msp_state *state = to_state(sd);
498 struct i2c_client *client = v4l2_get_subdevdata(sd);
499 int update = state->radio || state->v4l2_std != id;
500
501 state->v4l2_std = id;
502 state->radio = 0;
503 if (update)
504 msp_wake_thread(client);
505 return 0;
506}
507
508static int msp_s_routing(struct v4l2_subdev *sd,
509 u32 input, u32 output, u32 config)
510{
511 struct msp_state *state = to_state(sd);
512 struct i2c_client *client = v4l2_get_subdevdata(sd);
513 int tuner = (input >> 3) & 1;
514 int sc_in = input & 0x7;
515 int sc1_out = output & 0xf;
516 int sc2_out = (output >> 4) & 0xf;
517 u16 val, reg;
518 int i;
519 int extern_input = 1;
520
521 if (state->route_in == input && state->route_out == output)
522 return 0;
523 state->route_in = input;
524 state->route_out = output;
525
526 for (i = 0; i < 5; i++) {
527 if (((input >> (4 + i * 4)) & 0xf) == 0)
528 extern_input = 0;
529 }
530 state->mode = extern_input ? MSP_MODE_EXTERN : MSP_MODE_AM_DETECT;
531 state->rxsubchans = V4L2_TUNER_SUB_STEREO;
532 msp_set_scart(client, sc_in, 0);
533 msp_set_scart(client, sc1_out, 1);
534 msp_set_scart(client, sc2_out, 2);
535 msp_set_audmode(client);
536 reg = (state->opmode == OPMODE_AUTOSELECT) ? 0x30 : 0xbb;
537 val = msp_read_dem(client, reg);
538 msp_write_dem(client, reg, (val & ~0x100) | (tuner << 8));
539
540 msp_wake_thread(client);
541 return 0;
542}
543
544static int msp_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
545{
546 struct msp_state *state = to_state(sd);
547 struct i2c_client *client = v4l2_get_subdevdata(sd);
548
549 if (state->radio)
550 return 0;
551 if (state->opmode == OPMODE_AUTOSELECT)
552 msp_detect_stereo(client);
553 vt->audmode = state->audmode;
554 vt->rxsubchans = state->rxsubchans;
555 vt->capability |= V4L2_TUNER_CAP_STEREO |
556 V4L2_TUNER_CAP_LANG1 | V4L2_TUNER_CAP_LANG2;
557 return 0;
558}
559
560static int msp_s_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
561{
562 struct msp_state *state = to_state(sd);
563 struct i2c_client *client = v4l2_get_subdevdata(sd);
564
565 if (state->radio)
566 return 0;
567 if (state->audmode == vt->audmode)
568 return 0;
569 state->audmode = vt->audmode;
570
571 msp_set_audmode(client);
572 return 0;
573}
574
575static int msp_s_i2s_clock_freq(struct v4l2_subdev *sd, u32 freq)
576{
577 struct msp_state *state = to_state(sd);
578 struct i2c_client *client = v4l2_get_subdevdata(sd);
579
580 v4l_dbg(1, msp_debug, client, "Setting I2S speed to %d\n", freq);
581
582 switch (freq) {
583 case 1024000:
584 state->i2s_mode = 0;
585 break;
586 case 2048000:
587 state->i2s_mode = 1;
588 break;
589 default:
590 return -EINVAL;
591 }
592 return 0;
593}
594
595static int msp_queryctrl(struct v4l2_subdev *sd, struct v4l2_queryctrl *qc)
596{
597 struct msp_state *state = to_state(sd);
598
599 switch (qc->id) {
600 case V4L2_CID_AUDIO_VOLUME:
601 return v4l2_ctrl_query_fill(qc, 0, 65535, 65535 / 100, 58880);
602 case V4L2_CID_AUDIO_MUTE:
603 return v4l2_ctrl_query_fill(qc, 0, 1, 1, 0);
604 default:
605 break;
606 }
607 if (!state->has_sound_processing)
608 return -EINVAL;
609 switch (qc->id) {
610 case V4L2_CID_AUDIO_LOUDNESS:
611 return v4l2_ctrl_query_fill(qc, 0, 1, 1, 0);
612 case V4L2_CID_AUDIO_BALANCE:
613 case V4L2_CID_AUDIO_BASS:
614 case V4L2_CID_AUDIO_TREBLE:
615 return v4l2_ctrl_query_fill(qc, 0, 65535, 65535 / 100, 32768);
616 default:
617 return -EINVAL;
618 }
619 return 0;
620}
621
622static int msp_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip)
623{
624 struct msp_state *state = to_state(sd);
625 struct i2c_client *client = v4l2_get_subdevdata(sd);
626
627 return v4l2_chip_ident_i2c_client(client, chip, state->ident,
628 (state->rev1 << 16) | state->rev2);
629}
630
631static int msp_log_status(struct v4l2_subdev *sd)
632{
633 struct msp_state *state = to_state(sd);
634 struct i2c_client *client = v4l2_get_subdevdata(sd);
635 const char *p;
636
637 if (state->opmode == OPMODE_AUTOSELECT)
638 msp_detect_stereo(client);
639 v4l_info(client, "%s rev1 = 0x%04x rev2 = 0x%04x\n",
640 client->name, state->rev1, state->rev2);
641 v4l_info(client, "Audio: volume %d%s\n",
642 state->volume, state->muted ? " (muted)" : "");
643 if (state->has_sound_processing) {
644 v4l_info(client, "Audio: balance %d bass %d treble %d loudness %s\n",
645 state->balance, state->bass,
646 state->treble,
647 state->loudness ? "on" : "off");
648 }
649 switch (state->mode) {
650 case MSP_MODE_AM_DETECT: p = "AM (for carrier detect)"; break;
651 case MSP_MODE_FM_RADIO: p = "FM Radio"; break;
652 case MSP_MODE_FM_TERRA: p = "Terrestial FM-mono/stereo"; break;
653 case MSP_MODE_FM_SAT: p = "Satellite FM-mono"; break;
654 case MSP_MODE_FM_NICAM1: p = "NICAM/FM (B/G, D/K)"; break;
655 case MSP_MODE_FM_NICAM2: p = "NICAM/FM (I)"; break;
656 case MSP_MODE_AM_NICAM: p = "NICAM/AM (L)"; break;
657 case MSP_MODE_BTSC: p = "BTSC"; break;
658 case MSP_MODE_EXTERN: p = "External input"; break;
659 default: p = "unknown"; break;
660 }
661 if (state->mode == MSP_MODE_EXTERN) {
662 v4l_info(client, "Mode: %s\n", p);
663 } else if (state->opmode == OPMODE_MANUAL) {
664 v4l_info(client, "Mode: %s (%s%s)\n", p,
665 (state->rxsubchans & V4L2_TUNER_SUB_STEREO) ? "stereo" : "mono",
666 (state->rxsubchans & V4L2_TUNER_SUB_LANG2) ? ", dual" : "");
667 } else {
668 if (state->opmode == OPMODE_AUTODETECT)
669 v4l_info(client, "Mode: %s\n", p);
670 v4l_info(client, "Standard: %s (%s%s)\n",
671 msp_standard_std_name(state->std),
672 (state->rxsubchans & V4L2_TUNER_SUB_STEREO) ? "stereo" : "mono",
673 (state->rxsubchans & V4L2_TUNER_SUB_LANG2) ? ", dual" : "");
674 }
675 v4l_info(client, "Audmode: 0x%04x\n", state->audmode);
676 v4l_info(client, "Routing: 0x%08x (input) 0x%08x (output)\n",
677 state->route_in, state->route_out);
678 v4l_info(client, "ACB: 0x%04x\n", state->acb);
679 return 0;
680}
681
682static int msp_suspend(struct i2c_client *client, pm_message_t state)
683{
684 v4l_dbg(1, msp_debug, client, "suspend\n");
685 msp_reset(client);
686 return 0;
687}
688
689static int msp_resume(struct i2c_client *client)
690{
691 v4l_dbg(1, msp_debug, client, "resume\n");
692 msp_wake_thread(client);
693 return 0;
694}
695
696
697
698static const struct v4l2_subdev_core_ops msp_core_ops = {
699 .log_status = msp_log_status,
700 .g_chip_ident = msp_g_chip_ident,
701 .g_ctrl = msp_g_ctrl,
702 .s_ctrl = msp_s_ctrl,
703 .queryctrl = msp_queryctrl,
704 .s_std = msp_s_std,
705};
706
707static const struct v4l2_subdev_tuner_ops msp_tuner_ops = {
708 .s_frequency = msp_s_frequency,
709 .g_tuner = msp_g_tuner,
710 .s_tuner = msp_s_tuner,
711 .s_radio = msp_s_radio,
712};
713
714static const struct v4l2_subdev_audio_ops msp_audio_ops = {
715 .s_routing = msp_s_routing,
716 .s_i2s_clock_freq = msp_s_i2s_clock_freq,
717};
718
719static const struct v4l2_subdev_ops msp_ops = {
720 .core = &msp_core_ops,
721 .tuner = &msp_tuner_ops,
722 .audio = &msp_audio_ops,
723};
724
725
726
727static int msp_probe(struct i2c_client *client, const struct i2c_device_id *id)
728{
729 struct msp_state *state;
730 struct v4l2_subdev *sd;
731 int (*thread_func)(void *data) = NULL;
732 int msp_hard;
733 int msp_family;
734 int msp_revision;
735 int msp_product, msp_prod_hi, msp_prod_lo;
736 int msp_rom;
737
738 if (!id)
739 strlcpy(client->name, "msp3400", sizeof(client->name));
740
741 if (msp_reset(client) == -1) {
742 v4l_dbg(1, msp_debug, client, "msp3400 not found\n");
743 return -ENODEV;
744 }
745
746 state = kzalloc(sizeof(*state), GFP_KERNEL);
747 if (!state)
748 return -ENOMEM;
749
750 sd = &state->sd;
751 v4l2_i2c_subdev_init(sd, client, &msp_ops);
752
753 state->v4l2_std = V4L2_STD_NTSC;
754 state->audmode = V4L2_TUNER_MODE_STEREO;
755 state->volume = 58880;
756 state->balance = 32768;
757 state->bass = 32768;
758 state->treble = 32768;
759 state->loudness = 0;
760 state->input = -1;
761 state->muted = 0;
762 state->i2s_mode = 0;
763 init_waitqueue_head(&state->wq);
764
765 state->route_in = MSP_INPUT_DEFAULT;
766 state->route_out = MSP_OUTPUT_DEFAULT;
767
768 state->rev1 = msp_read_dsp(client, 0x1e);
769 if (state->rev1 != -1)
770 state->rev2 = msp_read_dsp(client, 0x1f);
771 v4l_dbg(1, msp_debug, client, "rev1=0x%04x, rev2=0x%04x\n",
772 state->rev1, state->rev2);
773 if (state->rev1 == -1 || (state->rev1 == 0 && state->rev2 == 0)) {
774 v4l_dbg(1, msp_debug, client,
775 "not an msp3400 (cannot read chip version)\n");
776 kfree(state);
777 return -ENODEV;
778 }
779
780 msp_set_audio(client);
781
782 msp_family = ((state->rev1 >> 4) & 0x0f) + 3;
783 msp_product = (state->rev2 >> 8) & 0xff;
784 msp_prod_hi = msp_product / 10;
785 msp_prod_lo = msp_product % 10;
786 msp_revision = (state->rev1 & 0x0f) + '@';
787 msp_hard = ((state->rev1 >> 8) & 0xff) + '@';
788 msp_rom = state->rev2 & 0x1f;
789
790 state->ident = msp_family * 10000 + 4000 + msp_product * 10 +
791 msp_revision - '@';
792
793
794 state->has_nicam =
795 msp_prod_hi == 1 || msp_prod_hi == 5;
796
797 state->has_radio =
798 msp_revision >= 'G';
799
800 state->has_headphones =
801 msp_prod_lo < 5;
802
803 state->has_scart2 =
804 msp_family >= 4 || msp_prod_lo < 7;
805
806 state->has_scart3 =
807 msp_family >= 4 || msp_prod_lo < 5;
808
809 state->has_scart4 =
810 msp_family >= 4 || (msp_revision >= 'D' && msp_prod_lo < 5);
811
812
813 state->has_scart2_out =
814 msp_family >= 4 || msp_prod_lo < 5;
815
816 state->has_scart2_out_volume =
817 msp_revision > 'C' && state->has_scart2_out;
818
819 state->has_i2s_conf =
820 msp_revision >= 'G' && msp_prod_lo < 7;
821
822
823 state->has_subwoofer =
824 msp_revision >= 'D' && msp_prod_lo < 5;
825
826
827 state->has_sound_processing =
828 msp_prod_lo < 7;
829
830 state->has_virtual_dolby_surround =
831 msp_revision == 'G' && msp_prod_lo == 1;
832
833 state->has_dolby_pro_logic =
834 msp_revision == 'G' && msp_prod_lo == 2;
835
836
837 state->force_btsc =
838 msp_family == 3 && msp_revision == 'G' && msp_prod_hi == 3;
839
840 state->opmode = opmode;
841 if (state->opmode == OPMODE_AUTO) {
842
843 if (msp_revision >= 'G')
844 state->opmode = OPMODE_AUTOSELECT;
845
846 else if (msp_revision >= 'D')
847 state->opmode = OPMODE_AUTODETECT;
848 else
849 state->opmode = OPMODE_MANUAL;
850 }
851
852
853 v4l_info(client, "MSP%d4%02d%c-%c%d found @ 0x%x (%s)\n",
854 msp_family, msp_product,
855 msp_revision, msp_hard, msp_rom,
856 client->addr << 1, client->adapter->name);
857 v4l_info(client, "%s ", client->name);
858 if (state->has_nicam && state->has_radio)
859 printk(KERN_CONT "supports nicam and radio, ");
860 else if (state->has_nicam)
861 printk(KERN_CONT "supports nicam, ");
862 else if (state->has_radio)
863 printk(KERN_CONT "supports radio, ");
864 printk(KERN_CONT "mode is ");
865
866
867 switch (state->opmode) {
868 case OPMODE_MANUAL:
869 printk(KERN_CONT "manual");
870 thread_func = msp3400c_thread;
871 break;
872 case OPMODE_AUTODETECT:
873 printk(KERN_CONT "autodetect");
874 thread_func = msp3410d_thread;
875 break;
876 case OPMODE_AUTOSELECT:
877 printk(KERN_CONT "autodetect and autoselect");
878 thread_func = msp34xxg_thread;
879 break;
880 }
881 printk(KERN_CONT "\n");
882
883
884 if (thread_func) {
885 state->kthread = kthread_run(thread_func, client, "msp34xx");
886
887 if (IS_ERR(state->kthread))
888 v4l_warn(client, "kernel_thread() failed\n");
889 msp_wake_thread(client);
890 }
891 return 0;
892}
893
894static int msp_remove(struct i2c_client *client)
895{
896 struct msp_state *state = to_state(i2c_get_clientdata(client));
897
898 v4l2_device_unregister_subdev(&state->sd);
899
900 if (state->kthread) {
901 state->restart = 1;
902 kthread_stop(state->kthread);
903 }
904 msp_reset(client);
905
906 kfree(state);
907 return 0;
908}
909
910
911
912static const struct i2c_device_id msp_id[] = {
913 { "msp3400", 0 },
914 { }
915};
916MODULE_DEVICE_TABLE(i2c, msp_id);
917
918static struct v4l2_i2c_driver_data v4l2_i2c_data = {
919 .name = "msp3400",
920 .probe = msp_probe,
921 .remove = msp_remove,
922 .suspend = msp_suspend,
923 .resume = msp_resume,
924 .id_table = msp_id,
925};
926
927
928
929
930
931
932
933
934