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/msp3400.h>
60#include <media/tvaudio.h>
61#include "msp3400-driver.h"
62
63
64
65MODULE_DESCRIPTION("device driver for msp34xx TV sound processor");
66MODULE_AUTHOR("Gerd Knorr");
67MODULE_LICENSE("GPL");
68
69
70static int opmode = OPMODE_AUTO;
71int msp_debug;
72int msp_once;
73int msp_amsound;
74
75int msp_standard = 1;
76
77int msp_dolby;
78
79int msp_stereo_thresh = 0x190;
80
81
82
83module_param(opmode, int, 0444);
84
85
86module_param_named(once, msp_once, bool, 0644);
87module_param_named(debug, msp_debug, int, 0644);
88module_param_named(stereo_threshold, msp_stereo_thresh, int, 0644);
89module_param_named(standard, msp_standard, int, 0644);
90module_param_named(amsound, msp_amsound, bool, 0644);
91module_param_named(dolby, msp_dolby, bool, 0644);
92
93MODULE_PARM_DESC(opmode, "Forces a MSP3400 opmode. 0=Manual, 1=Autodetect, 2=Autodetect and autoselect");
94MODULE_PARM_DESC(once, "No continuous stereo monitoring");
95MODULE_PARM_DESC(debug, "Enable debug messages [0-3]");
96MODULE_PARM_DESC(stereo_threshold, "Sets signal threshold to activate stereo");
97MODULE_PARM_DESC(standard, "Specify audio standard: 32 = NTSC, 64 = radio, Default: Autodetect");
98MODULE_PARM_DESC(amsound, "Hardwire AM sound at 6.5Hz (France), FM can autoscan");
99MODULE_PARM_DESC(dolby, "Activates Dolby processing");
100
101
102
103
104#define I2C_MSP_CONTROL 0x00
105
106#define I2C_MSP_DEM 0x10
107
108#define I2C_MSP_DSP 0x12
109
110
111
112
113
114int msp_reset(struct i2c_client *client)
115{
116
117 static u8 reset_off[3] = { I2C_MSP_CONTROL, 0x80, 0x00 };
118 static u8 reset_on[3] = { I2C_MSP_CONTROL, 0x00, 0x00 };
119 static u8 write[3] = { I2C_MSP_DSP + 1, 0x00, 0x1e };
120 u8 read[2];
121 struct i2c_msg reset[2] = {
122 { client->addr, I2C_M_IGNORE_NAK, 3, reset_off },
123 { client->addr, I2C_M_IGNORE_NAK, 3, reset_on },
124 };
125 struct i2c_msg test[2] = {
126 { client->addr, 0, 3, write },
127 { client->addr, I2C_M_RD, 2, read },
128 };
129
130 v4l_dbg(3, msp_debug, client, "msp_reset\n");
131 if (i2c_transfer(client->adapter, &reset[0], 1) != 1 ||
132 i2c_transfer(client->adapter, &reset[1], 1) != 1 ||
133 i2c_transfer(client->adapter, test, 2) != 2) {
134 v4l_err(client, "chip reset failed\n");
135 return -1;
136 }
137 return 0;
138}
139
140static int msp_read(struct i2c_client *client, int dev, int addr)
141{
142 int err, retval;
143 u8 write[3];
144 u8 read[2];
145 struct i2c_msg msgs[2] = {
146 { client->addr, 0, 3, write },
147 { client->addr, I2C_M_RD, 2, read }
148 };
149
150 write[0] = dev + 1;
151 write[1] = addr >> 8;
152 write[2] = addr & 0xff;
153
154 for (err = 0; err < 3; err++) {
155 if (i2c_transfer(client->adapter, msgs, 2) == 2)
156 break;
157 v4l_warn(client, "I/O error #%d (read 0x%02x/0x%02x)\n", err,
158 dev, addr);
159 schedule_timeout_interruptible(msecs_to_jiffies(10));
160 }
161 if (err == 3) {
162 v4l_warn(client, "resetting chip, sound will go off.\n");
163 msp_reset(client);
164 return -1;
165 }
166 retval = read[0] << 8 | read[1];
167 v4l_dbg(3, msp_debug, client, "msp_read(0x%x, 0x%x): 0x%x\n",
168 dev, addr, retval);
169 return retval;
170}
171
172int msp_read_dem(struct i2c_client *client, int addr)
173{
174 return msp_read(client, I2C_MSP_DEM, addr);
175}
176
177int msp_read_dsp(struct i2c_client *client, int addr)
178{
179 return msp_read(client, I2C_MSP_DSP, addr);
180}
181
182static int msp_write(struct i2c_client *client, int dev, int addr, int val)
183{
184 int err;
185 u8 buffer[5];
186
187 buffer[0] = dev;
188 buffer[1] = addr >> 8;
189 buffer[2] = addr & 0xff;
190 buffer[3] = val >> 8;
191 buffer[4] = val & 0xff;
192
193 v4l_dbg(3, msp_debug, client, "msp_write(0x%x, 0x%x, 0x%x)\n",
194 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 schedule_timeout_interruptible(msecs_to_jiffies(10));
201 }
202 if (err == 3) {
203 v4l_warn(client, "resetting chip, sound will go off.\n");
204 msp_reset(client);
205 return -1;
206 }
207 return 0;
208}
209
210int msp_write_dem(struct i2c_client *client, int addr, int val)
211{
212 return msp_write(client, I2C_MSP_DEM, addr, val);
213}
214
215int msp_write_dsp(struct i2c_client *client, int addr, int val)
216{
217 return msp_write(client, I2C_MSP_DSP, addr, val);
218}
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
247static int scarts[3][9] = {
248
249
250 { 0x0320, 0x0000, 0x0200, 0x0300, 0x0020, -1, -1, 0x0100, 0x0320 },
251
252 { 0x0c40, 0x0440, 0x0400, 0x0000, 0x0840, 0x0c00, 0x0040, 0x0800, 0x0c40 },
253
254 { 0x3080, 0x1000, 0x1080, 0x2080, 0x3080, 0x0000, 0x0080, 0x2000, 0x3000 },
255};
256
257static char *scart_names[] = {
258 "in1", "in2", "in3", "in4", "in1 da", "in2 da", "mono", "mute"
259};
260
261void msp_set_scart(struct i2c_client *client, int in, int out)
262{
263 struct msp_state *state = to_state(i2c_get_clientdata(client));
264
265 state->in_scart = in;
266
267 if (in >= 0 && in <= 7 && out >= 0 && out <= 2) {
268 if (-1 == scarts[out][in + 1])
269 return;
270
271 state->acb &= ~scarts[out][0];
272 state->acb |= scarts[out][in + 1];
273 } else
274 state->acb = 0xf60;
275
276 v4l_dbg(1, msp_debug, client, "scart switch: %s => %d (ACB=0x%04x)\n",
277 scart_names[in], out, state->acb);
278 msp_write_dsp(client, 0x13, state->acb);
279
280
281 if (state->has_i2s_conf)
282 msp_write_dem(client, 0x40, state->i2s_mode);
283}
284
285
286
287static void msp_wake_thread(struct i2c_client *client)
288{
289 struct msp_state *state = to_state(i2c_get_clientdata(client));
290
291 if (NULL == state->kthread)
292 return;
293 state->watch_stereo = 0;
294 state->restart = 1;
295 wake_up_interruptible(&state->wq);
296}
297
298int msp_sleep(struct msp_state *state, int timeout)
299{
300 DECLARE_WAITQUEUE(wait, current);
301
302 add_wait_queue(&state->wq, &wait);
303 if (!kthread_should_stop()) {
304 if (timeout < 0) {
305 set_current_state(TASK_INTERRUPTIBLE);
306 schedule();
307 } else {
308 schedule_timeout_interruptible
309 (msecs_to_jiffies(timeout));
310 }
311 }
312
313 remove_wait_queue(&state->wq, &wait);
314 try_to_freeze();
315 return state->restart;
316}
317
318
319
320static int msp_s_ctrl(struct v4l2_ctrl *ctrl)
321{
322 struct msp_state *state = ctrl_to_state(ctrl);
323 struct i2c_client *client = v4l2_get_subdevdata(&state->sd);
324 int val = ctrl->val;
325
326 switch (ctrl->id) {
327 case V4L2_CID_AUDIO_VOLUME: {
328
329 int reallymuted = state->muted->val | state->scan_in_progress;
330
331 if (!reallymuted)
332 val = (val * 0x7f / 65535) << 8;
333
334 v4l_dbg(1, msp_debug, client, "mute=%s scanning=%s volume=%d\n",
335 state->muted->val ? "on" : "off",
336 state->scan_in_progress ? "yes" : "no",
337 state->volume->val);
338
339 msp_write_dsp(client, 0x0000, val);
340 msp_write_dsp(client, 0x0007, reallymuted ? 0x1 : (val | 0x1));
341 if (state->has_scart2_out_volume)
342 msp_write_dsp(client, 0x0040, reallymuted ? 0x1 : (val | 0x1));
343 if (state->has_headphones)
344 msp_write_dsp(client, 0x0006, val);
345 break;
346 }
347
348 case V4L2_CID_AUDIO_BASS:
349 val = ((val - 32768) * 0x60 / 65535) << 8;
350 msp_write_dsp(client, 0x0002, val);
351 if (state->has_headphones)
352 msp_write_dsp(client, 0x0031, val);
353 break;
354
355 case V4L2_CID_AUDIO_TREBLE:
356 val = ((val - 32768) * 0x60 / 65535) << 8;
357 msp_write_dsp(client, 0x0003, val);
358 if (state->has_headphones)
359 msp_write_dsp(client, 0x0032, val);
360 break;
361
362 case V4L2_CID_AUDIO_LOUDNESS:
363 val = val ? ((5 * 4) << 8) : 0;
364 msp_write_dsp(client, 0x0004, val);
365 if (state->has_headphones)
366 msp_write_dsp(client, 0x0033, val);
367 break;
368
369 case V4L2_CID_AUDIO_BALANCE:
370 val = (u8)((val / 256) - 128);
371 msp_write_dsp(client, 0x0001, val << 8);
372 if (state->has_headphones)
373 msp_write_dsp(client, 0x0030, val << 8);
374 break;
375
376 default:
377 return -EINVAL;
378 }
379 return 0;
380}
381
382void msp_update_volume(struct msp_state *state)
383{
384
385 v4l2_ctrl_lock(state->volume);
386 state->volume->val = state->volume->cur.val;
387 state->muted->val = state->muted->cur.val;
388 msp_s_ctrl(state->volume);
389 v4l2_ctrl_unlock(state->volume);
390}
391
392
393static int msp_s_radio(struct v4l2_subdev *sd)
394{
395 struct msp_state *state = to_state(sd);
396 struct i2c_client *client = v4l2_get_subdevdata(sd);
397
398 if (state->radio)
399 return 0;
400 state->radio = 1;
401 v4l_dbg(1, msp_debug, client, "switching to radio mode\n");
402 state->watch_stereo = 0;
403 switch (state->opmode) {
404 case OPMODE_MANUAL:
405
406 msp3400c_set_mode(client, MSP_MODE_FM_RADIO);
407 msp3400c_set_carrier(client, MSP_CARRIER(10.7),
408 MSP_CARRIER(10.7));
409 msp_update_volume(state);
410 break;
411 case OPMODE_AUTODETECT:
412 case OPMODE_AUTOSELECT:
413
414 msp_wake_thread(client);
415 break;
416 }
417 return 0;
418}
419
420static int msp_s_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *freq)
421{
422 struct i2c_client *client = v4l2_get_subdevdata(sd);
423
424
425 msp_wake_thread(client);
426 return 0;
427}
428
429static int msp_s_std(struct v4l2_subdev *sd, v4l2_std_id id)
430{
431 struct msp_state *state = to_state(sd);
432 struct i2c_client *client = v4l2_get_subdevdata(sd);
433 int update = state->radio || state->v4l2_std != id;
434
435 state->v4l2_std = id;
436 state->radio = 0;
437 if (update)
438 msp_wake_thread(client);
439 return 0;
440}
441
442static int msp_s_routing(struct v4l2_subdev *sd,
443 u32 input, u32 output, u32 config)
444{
445 struct msp_state *state = to_state(sd);
446 struct i2c_client *client = v4l2_get_subdevdata(sd);
447 int tuner = (input >> 3) & 1;
448 int sc_in = input & 0x7;
449 int sc1_out = output & 0xf;
450 int sc2_out = (output >> 4) & 0xf;
451 u16 val, reg;
452 int i;
453 int extern_input = 1;
454
455 if (state->route_in == input && state->route_out == output)
456 return 0;
457 state->route_in = input;
458 state->route_out = output;
459
460 for (i = 0; i < 5; i++) {
461 if (((input >> (4 + i * 4)) & 0xf) == 0)
462 extern_input = 0;
463 }
464 state->mode = extern_input ? MSP_MODE_EXTERN : MSP_MODE_AM_DETECT;
465 state->rxsubchans = V4L2_TUNER_SUB_STEREO;
466 msp_set_scart(client, sc_in, 0);
467 msp_set_scart(client, sc1_out, 1);
468 msp_set_scart(client, sc2_out, 2);
469 msp_set_audmode(client);
470 reg = (state->opmode == OPMODE_AUTOSELECT) ? 0x30 : 0xbb;
471 val = msp_read_dem(client, reg);
472 msp_write_dem(client, reg, (val & ~0x100) | (tuner << 8));
473
474 msp_wake_thread(client);
475 return 0;
476}
477
478static int msp_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
479{
480 struct msp_state *state = to_state(sd);
481 struct i2c_client *client = v4l2_get_subdevdata(sd);
482
483 if (vt->type != V4L2_TUNER_ANALOG_TV)
484 return 0;
485 if (!state->radio) {
486 if (state->opmode == OPMODE_AUTOSELECT)
487 msp_detect_stereo(client);
488 vt->rxsubchans = state->rxsubchans;
489 }
490 vt->audmode = state->audmode;
491 vt->capability |= V4L2_TUNER_CAP_STEREO |
492 V4L2_TUNER_CAP_LANG1 | V4L2_TUNER_CAP_LANG2;
493 return 0;
494}
495
496static int msp_s_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
497{
498 struct msp_state *state = to_state(sd);
499 struct i2c_client *client = v4l2_get_subdevdata(sd);
500
501 if (state->radio)
502 return 0;
503 if (state->audmode == vt->audmode)
504 return 0;
505 state->audmode = vt->audmode;
506
507 msp_set_audmode(client);
508 return 0;
509}
510
511static int msp_s_i2s_clock_freq(struct v4l2_subdev *sd, u32 freq)
512{
513 struct msp_state *state = to_state(sd);
514 struct i2c_client *client = v4l2_get_subdevdata(sd);
515
516 v4l_dbg(1, msp_debug, client, "Setting I2S speed to %d\n", freq);
517
518 switch (freq) {
519 case 1024000:
520 state->i2s_mode = 0;
521 break;
522 case 2048000:
523 state->i2s_mode = 1;
524 break;
525 default:
526 return -EINVAL;
527 }
528 return 0;
529}
530
531static int msp_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip)
532{
533 struct msp_state *state = to_state(sd);
534 struct i2c_client *client = v4l2_get_subdevdata(sd);
535
536 return v4l2_chip_ident_i2c_client(client, chip, state->ident,
537 (state->rev1 << 16) | state->rev2);
538}
539
540static int msp_log_status(struct v4l2_subdev *sd)
541{
542 struct msp_state *state = to_state(sd);
543 struct i2c_client *client = v4l2_get_subdevdata(sd);
544 const char *p;
545 char prefix[V4L2_SUBDEV_NAME_SIZE + 20];
546
547 if (state->opmode == OPMODE_AUTOSELECT)
548 msp_detect_stereo(client);
549 v4l_info(client, "%s rev1 = 0x%04x rev2 = 0x%04x\n",
550 client->name, state->rev1, state->rev2);
551 snprintf(prefix, sizeof(prefix), "%s: Audio: ", sd->name);
552 v4l2_ctrl_handler_log_status(&state->hdl, prefix);
553 switch (state->mode) {
554 case MSP_MODE_AM_DETECT: p = "AM (for carrier detect)"; break;
555 case MSP_MODE_FM_RADIO: p = "FM Radio"; break;
556 case MSP_MODE_FM_TERRA: p = "Terrestrial FM-mono/stereo"; break;
557 case MSP_MODE_FM_SAT: p = "Satellite FM-mono"; break;
558 case MSP_MODE_FM_NICAM1: p = "NICAM/FM (B/G, D/K)"; break;
559 case MSP_MODE_FM_NICAM2: p = "NICAM/FM (I)"; break;
560 case MSP_MODE_AM_NICAM: p = "NICAM/AM (L)"; break;
561 case MSP_MODE_BTSC: p = "BTSC"; break;
562 case MSP_MODE_EXTERN: p = "External input"; break;
563 default: p = "unknown"; break;
564 }
565 if (state->mode == MSP_MODE_EXTERN) {
566 v4l_info(client, "Mode: %s\n", p);
567 } else if (state->opmode == OPMODE_MANUAL) {
568 v4l_info(client, "Mode: %s (%s%s)\n", p,
569 (state->rxsubchans & V4L2_TUNER_SUB_STEREO) ? "stereo" : "mono",
570 (state->rxsubchans & V4L2_TUNER_SUB_LANG2) ? ", dual" : "");
571 } else {
572 if (state->opmode == OPMODE_AUTODETECT)
573 v4l_info(client, "Mode: %s\n", p);
574 v4l_info(client, "Standard: %s (%s%s)\n",
575 msp_standard_std_name(state->std),
576 (state->rxsubchans & V4L2_TUNER_SUB_STEREO) ? "stereo" : "mono",
577 (state->rxsubchans & V4L2_TUNER_SUB_LANG2) ? ", dual" : "");
578 }
579 v4l_info(client, "Audmode: 0x%04x\n", state->audmode);
580 v4l_info(client, "Routing: 0x%08x (input) 0x%08x (output)\n",
581 state->route_in, state->route_out);
582 v4l_info(client, "ACB: 0x%04x\n", state->acb);
583 return 0;
584}
585
586static int msp_suspend(struct i2c_client *client, pm_message_t state)
587{
588 v4l_dbg(1, msp_debug, client, "suspend\n");
589 msp_reset(client);
590 return 0;
591}
592
593static int msp_resume(struct i2c_client *client)
594{
595 v4l_dbg(1, msp_debug, client, "resume\n");
596 msp_wake_thread(client);
597 return 0;
598}
599
600
601
602static const struct v4l2_ctrl_ops msp_ctrl_ops = {
603 .s_ctrl = msp_s_ctrl,
604};
605
606static const struct v4l2_subdev_core_ops msp_core_ops = {
607 .log_status = msp_log_status,
608 .g_chip_ident = msp_g_chip_ident,
609 .g_ext_ctrls = v4l2_subdev_g_ext_ctrls,
610 .try_ext_ctrls = v4l2_subdev_try_ext_ctrls,
611 .s_ext_ctrls = v4l2_subdev_s_ext_ctrls,
612 .g_ctrl = v4l2_subdev_g_ctrl,
613 .s_ctrl = v4l2_subdev_s_ctrl,
614 .queryctrl = v4l2_subdev_queryctrl,
615 .querymenu = v4l2_subdev_querymenu,
616 .s_std = msp_s_std,
617};
618
619static const struct v4l2_subdev_tuner_ops msp_tuner_ops = {
620 .s_frequency = msp_s_frequency,
621 .g_tuner = msp_g_tuner,
622 .s_tuner = msp_s_tuner,
623 .s_radio = msp_s_radio,
624};
625
626static const struct v4l2_subdev_audio_ops msp_audio_ops = {
627 .s_routing = msp_s_routing,
628 .s_i2s_clock_freq = msp_s_i2s_clock_freq,
629};
630
631static const struct v4l2_subdev_ops msp_ops = {
632 .core = &msp_core_ops,
633 .tuner = &msp_tuner_ops,
634 .audio = &msp_audio_ops,
635};
636
637
638
639static int msp_probe(struct i2c_client *client, const struct i2c_device_id *id)
640{
641 struct msp_state *state;
642 struct v4l2_subdev *sd;
643 struct v4l2_ctrl_handler *hdl;
644 int (*thread_func)(void *data) = NULL;
645 int msp_hard;
646 int msp_family;
647 int msp_revision;
648 int msp_product, msp_prod_hi, msp_prod_lo;
649 int msp_rom;
650
651 if (!id)
652 strlcpy(client->name, "msp3400", sizeof(client->name));
653
654 if (msp_reset(client) == -1) {
655 v4l_dbg(1, msp_debug, client, "msp3400 not found\n");
656 return -ENODEV;
657 }
658
659 state = kzalloc(sizeof(*state), GFP_KERNEL);
660 if (!state)
661 return -ENOMEM;
662
663 sd = &state->sd;
664 v4l2_i2c_subdev_init(sd, client, &msp_ops);
665
666 state->v4l2_std = V4L2_STD_NTSC;
667 state->audmode = V4L2_TUNER_MODE_STEREO;
668 state->input = -1;
669 state->i2s_mode = 0;
670 init_waitqueue_head(&state->wq);
671
672 state->route_in = MSP_INPUT_DEFAULT;
673 state->route_out = MSP_OUTPUT_DEFAULT;
674
675 state->rev1 = msp_read_dsp(client, 0x1e);
676 if (state->rev1 != -1)
677 state->rev2 = msp_read_dsp(client, 0x1f);
678 v4l_dbg(1, msp_debug, client, "rev1=0x%04x, rev2=0x%04x\n",
679 state->rev1, state->rev2);
680 if (state->rev1 == -1 || (state->rev1 == 0 && state->rev2 == 0)) {
681 v4l_dbg(1, msp_debug, client,
682 "not an msp3400 (cannot read chip version)\n");
683 kfree(state);
684 return -ENODEV;
685 }
686
687 msp_family = ((state->rev1 >> 4) & 0x0f) + 3;
688 msp_product = (state->rev2 >> 8) & 0xff;
689 msp_prod_hi = msp_product / 10;
690 msp_prod_lo = msp_product % 10;
691 msp_revision = (state->rev1 & 0x0f) + '@';
692 msp_hard = ((state->rev1 >> 8) & 0xff) + '@';
693 msp_rom = state->rev2 & 0x1f;
694
695 state->ident = msp_family * 10000 + 4000 + msp_product * 10 +
696 msp_revision - '@';
697
698
699 state->has_nicam =
700 msp_prod_hi == 1 || msp_prod_hi == 5;
701
702 state->has_radio =
703 msp_revision >= 'G';
704
705 state->has_headphones =
706 msp_prod_lo < 5;
707
708 state->has_scart2 =
709 msp_family >= 4 || msp_prod_lo < 7;
710
711 state->has_scart3 =
712 msp_family >= 4 || msp_prod_lo < 5;
713
714 state->has_scart4 =
715 msp_family >= 4 || (msp_revision >= 'D' && msp_prod_lo < 5);
716
717
718 state->has_scart2_out =
719 msp_family >= 4 || msp_prod_lo < 5;
720
721 state->has_scart2_out_volume =
722 msp_revision > 'C' && state->has_scart2_out;
723
724 state->has_i2s_conf =
725 msp_revision >= 'G' && msp_prod_lo < 7;
726
727
728 state->has_subwoofer =
729 msp_revision >= 'D' && msp_prod_lo < 5;
730
731
732 state->has_sound_processing =
733 msp_prod_lo < 7;
734
735 state->has_virtual_dolby_surround =
736 msp_revision == 'G' && msp_prod_lo == 1;
737
738 state->has_dolby_pro_logic =
739 msp_revision == 'G' && msp_prod_lo == 2;
740
741
742 state->force_btsc =
743 msp_family == 3 && msp_revision == 'G' && msp_prod_hi == 3;
744
745 state->opmode = opmode;
746 if (state->opmode == OPMODE_AUTO) {
747
748 if (msp_revision >= 'G')
749 state->opmode = OPMODE_AUTOSELECT;
750
751 else if (msp_revision >= 'D')
752 state->opmode = OPMODE_AUTODETECT;
753 else
754 state->opmode = OPMODE_MANUAL;
755 }
756
757 hdl = &state->hdl;
758 v4l2_ctrl_handler_init(hdl, 6);
759 if (state->has_sound_processing) {
760 v4l2_ctrl_new_std(hdl, &msp_ctrl_ops,
761 V4L2_CID_AUDIO_BASS, 0, 65535, 65535 / 100, 32768);
762 v4l2_ctrl_new_std(hdl, &msp_ctrl_ops,
763 V4L2_CID_AUDIO_TREBLE, 0, 65535, 65535 / 100, 32768);
764 v4l2_ctrl_new_std(hdl, &msp_ctrl_ops,
765 V4L2_CID_AUDIO_LOUDNESS, 0, 1, 1, 0);
766 }
767 state->volume = v4l2_ctrl_new_std(hdl, &msp_ctrl_ops,
768 V4L2_CID_AUDIO_VOLUME, 0, 65535, 65535 / 100, 58880);
769 v4l2_ctrl_new_std(hdl, &msp_ctrl_ops,
770 V4L2_CID_AUDIO_BALANCE, 0, 65535, 65535 / 100, 32768);
771 state->muted = v4l2_ctrl_new_std(hdl, &msp_ctrl_ops,
772 V4L2_CID_AUDIO_MUTE, 0, 1, 1, 0);
773 sd->ctrl_handler = hdl;
774 if (hdl->error) {
775 int err = hdl->error;
776
777 v4l2_ctrl_handler_free(hdl);
778 kfree(state);
779 return err;
780 }
781
782 v4l2_ctrl_cluster(2, &state->volume);
783 v4l2_ctrl_handler_setup(hdl);
784
785
786 v4l_info(client, "MSP%d4%02d%c-%c%d found @ 0x%x (%s)\n",
787 msp_family, msp_product,
788 msp_revision, msp_hard, msp_rom,
789 client->addr << 1, client->adapter->name);
790 v4l_info(client, "%s ", client->name);
791 if (state->has_nicam && state->has_radio)
792 printk(KERN_CONT "supports nicam and radio, ");
793 else if (state->has_nicam)
794 printk(KERN_CONT "supports nicam, ");
795 else if (state->has_radio)
796 printk(KERN_CONT "supports radio, ");
797 printk(KERN_CONT "mode is ");
798
799
800 switch (state->opmode) {
801 case OPMODE_MANUAL:
802 printk(KERN_CONT "manual");
803 thread_func = msp3400c_thread;
804 break;
805 case OPMODE_AUTODETECT:
806 printk(KERN_CONT "autodetect");
807 thread_func = msp3410d_thread;
808 break;
809 case OPMODE_AUTOSELECT:
810 printk(KERN_CONT "autodetect and autoselect");
811 thread_func = msp34xxg_thread;
812 break;
813 }
814 printk(KERN_CONT "\n");
815
816
817 if (thread_func) {
818 state->kthread = kthread_run(thread_func, client, "msp34xx");
819
820 if (IS_ERR(state->kthread))
821 v4l_warn(client, "kernel_thread() failed\n");
822 msp_wake_thread(client);
823 }
824 return 0;
825}
826
827static int msp_remove(struct i2c_client *client)
828{
829 struct msp_state *state = to_state(i2c_get_clientdata(client));
830
831 v4l2_device_unregister_subdev(&state->sd);
832
833 if (state->kthread) {
834 state->restart = 1;
835 kthread_stop(state->kthread);
836 }
837 msp_reset(client);
838
839 v4l2_ctrl_handler_free(&state->hdl);
840 kfree(state);
841 return 0;
842}
843
844
845
846static const struct i2c_device_id msp_id[] = {
847 { "msp3400", 0 },
848 { }
849};
850MODULE_DEVICE_TABLE(i2c, msp_id);
851
852static struct i2c_driver msp_driver = {
853 .driver = {
854 .owner = THIS_MODULE,
855 .name = "msp3400",
856 },
857 .probe = msp_probe,
858 .remove = msp_remove,
859 .suspend = msp_suspend,
860 .resume = msp_resume,
861 .id_table = msp_id,
862};
863
864static __init int init_msp(void)
865{
866 return i2c_add_driver(&msp_driver);
867}
868
869static __exit void exit_msp(void)
870{
871 i2c_del_driver(&msp_driver);
872}
873
874module_init(init_msp);
875module_exit(exit_msp);
876
877
878
879
880
881
882
883
884