[media] msp3400: fill in v4l2_tuner based on vt->type field
[linux-2.6.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
46  * 02110-1301, USA.
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
65 MODULE_DESCRIPTION("device driver for msp34xx TV sound processor");
66 MODULE_AUTHOR("Gerd Knorr");
67 MODULE_LICENSE("GPL");
68
69 /* module parameters */
70 static int opmode   = OPMODE_AUTO;
71 int msp_debug;           /* msp_debug output */
72 int msp_once;            /* no continuous stereo monitoring */
73 int msp_amsound;         /* hard-wire AM sound at 6.5 Hz (france),
74                             the autoscan seems work well only with FM... */
75 int msp_standard = 1;    /* Override auto detect of audio msp_standard,
76                             if needed. */
77 int msp_dolby;
78
79 int msp_stereo_thresh = 0x190; /* a2 threshold for stereo/bilingual
80                                         (msp34xxg only) 0x00a0-0x03c0 */
81
82 /* read-only */
83 module_param(opmode,           int, 0444);
84
85 /* read-write */
86 module_param_named(once, msp_once,                      bool, 0644);
87 module_param_named(debug, msp_debug,                    int,  0644);
88 module_param_named(stereo_threshold, msp_stereo_thresh, int,  0644);
89 module_param_named(standard, msp_standard,              int,  0644);
90 module_param_named(amsound, msp_amsound,                bool, 0644);
91 module_param_named(dolby, msp_dolby,                    bool, 0644);
92
93 MODULE_PARM_DESC(opmode, "Forces a MSP3400 opmode. 0=Manual, 1=Autodetect, 2=Autodetect and autoselect");
94 MODULE_PARM_DESC(once, "No continuous stereo monitoring");
95 MODULE_PARM_DESC(debug, "Enable debug messages [0-3]");
96 MODULE_PARM_DESC(stereo_threshold, "Sets signal threshold to activate stereo");
97 MODULE_PARM_DESC(standard, "Specify audio standard: 32 = NTSC, 64 = radio, Default: Autodetect");
98 MODULE_PARM_DESC(amsound, "Hardwire AM sound at 6.5Hz (France), FM can autoscan");
99 MODULE_PARM_DESC(dolby, "Activates Dolby processing");
100
101 /* ---------------------------------------------------------------------- */
102
103 /* control subaddress */
104 #define I2C_MSP_CONTROL 0x00
105 /* demodulator unit subaddress */
106 #define I2C_MSP_DEM     0x10
107 /* DSP unit subaddress */
108 #define I2C_MSP_DSP     0x12
109
110
111 /* ----------------------------------------------------------------------- */
112 /* functions for talking to the MSP3400C Sound processor                   */
113
114 int msp_reset(struct i2c_client *client)
115 {
116         /* reset and read revision code */
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
140 static 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
172 int msp_read_dem(struct i2c_client *client, int addr)
173 {
174         return msp_read(client, I2C_MSP_DEM, addr);
175 }
176
177 int msp_read_dsp(struct i2c_client *client, int addr)
178 {
179         return msp_read(client, I2C_MSP_DSP, addr);
180 }
181
182 static 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
210 int msp_write_dem(struct i2c_client *client, int addr, int val)
211 {
212         return msp_write(client, I2C_MSP_DEM, addr, val);
213 }
214
215 int 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  * bits  9  8  5 - SCART DSP input Select:
222  *       0  0  0 - SCART 1 to DSP input (reset position)
223  *       0  1  0 - MONO to DSP input
224  *       1  0  0 - SCART 2 to DSP input
225  *       1  1  1 - Mute DSP input
226  *
227  * bits 11 10  6 - SCART 1 Output Select:
228  *       0  0  0 - undefined (reset position)
229  *       0  1  0 - SCART 2 Input to SCART 1 Output (for devices with 2 SCARTS)
230  *       1  0  0 - MONO input to SCART 1 Output
231  *       1  1  0 - SCART 1 DA to SCART 1 Output
232  *       0  0  1 - SCART 2 DA to SCART 1 Output
233  *       0  1  1 - SCART 1 Input to SCART 1 Output
234  *       1  1  1 - Mute SCART 1 Output
235  *
236  * bits 13 12  7 - SCART 2 Output Select (for devices with 2 Output SCART):
237  *       0  0  0 - SCART 1 DA to SCART 2 Output (reset position)
238  *       0  1  0 - SCART 1 Input to SCART 2 Output
239  *       1  0  0 - MONO input to SCART 2 Output
240  *       0  0  1 - SCART 2 DA to SCART 2 Output
241  *       0  1  1 - SCART 2 Input to SCART 2 Output
242  *       1  1  0 - Mute SCART 2 Output
243  *
244  * Bits 4 to 0 should be zero.
245  * ----------------------------------------------------------------------- */
246
247 static int scarts[3][9] = {
248         /* MASK   IN1     IN2     IN3     IN4     IN1_DA  IN2_DA  MONO    MUTE   */
249         /* SCART DSP Input select */
250         { 0x0320, 0x0000, 0x0200, 0x0300, 0x0020, -1,     -1,     0x0100, 0x0320 },
251         /* SCART1 Output select */
252         { 0x0c40, 0x0440, 0x0400, 0x0000, 0x0840, 0x0c00, 0x0040, 0x0800, 0x0c40 },
253         /* SCART2 Output select */
254         { 0x3080, 0x1000, 0x1080, 0x2080, 0x3080, 0x0000, 0x0080, 0x2000, 0x3000 },
255 };
256
257 static char *scart_names[] = {
258         "in1", "in2", "in3", "in4", "in1 da", "in2 da", "mono", "mute"
259 };
260
261 void 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; /* Mute Input and SCART 1 Output */
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         /* Sets I2S speed 0 = 1.024 Mbps, 1 = 2.048 Mbps */
281         if (state->has_i2s_conf)
282                 msp_write_dem(client, 0x40, state->i2s_mode);
283 }
284
285 /* ------------------------------------------------------------------------ */
286
287 static 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
298 int 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
320 static 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                 /* audio volume cluster */
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
382 void msp_update_volume(struct msp_state *state)
383 {
384         /* Force an update of the volume/mute cluster */
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 /* --- v4l2 ioctls --- */
393 static 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                 /* set msp3400 to FM radio mode */
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                 /* the thread will do for us */
414                 msp_wake_thread(client);
415                 break;
416         }
417         return 0;
418 }
419
420 static int msp_s_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *freq)
421 {
422         struct i2c_client *client = v4l2_get_subdevdata(sd);
423
424         /* new channel -- kick audio carrier scan */
425         msp_wake_thread(client);
426         return 0;
427 }
428
429 static 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
442 static 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         /* check if the tuner input is used */
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         /* wake thread when a new input is chosen */
474         msp_wake_thread(client);
475         return 0;
476 }
477
478 static 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
496 static 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)  /* TODO: add mono/stereo support for radio */
502                 return 0;
503         if (state->audmode == vt->audmode)
504                 return 0;
505         state->audmode = vt->audmode;
506         /* only set audmode */
507         msp_set_audmode(client);
508         return 0;
509 }
510
511 static 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
531 static 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
540 static 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
586 static 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
593 static 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
602 static const struct v4l2_ctrl_ops msp_ctrl_ops = {
603         .s_ctrl = msp_s_ctrl,
604 };
605
606 static 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
619 static 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
626 static 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
631 static 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
639 static 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         /* These are the reset input/output positions */
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         /* Rev B=2, C=3, D=4, G=7 */
695         state->ident = msp_family * 10000 + 4000 + msp_product * 10 +
696                         msp_revision - '@';
697
698         /* Has NICAM support: all mspx41x and mspx45x products have NICAM */
699         state->has_nicam =
700                 msp_prod_hi == 1 || msp_prod_hi == 5;
701         /* Has radio support: was added with revision G */
702         state->has_radio =
703                 msp_revision >= 'G';
704         /* Has headphones output: not for stripped down products */
705         state->has_headphones =
706                 msp_prod_lo < 5;
707         /* Has scart2 input: not in stripped down products of the '3' family */
708         state->has_scart2 =
709                 msp_family >= 4 || msp_prod_lo < 7;
710         /* Has scart3 input: not in stripped down products of the '3' family */
711         state->has_scart3 =
712                 msp_family >= 4 || msp_prod_lo < 5;
713         /* Has scart4 input: not in pre D revisions, not in stripped D revs */
714         state->has_scart4 =
715                 msp_family >= 4 || (msp_revision >= 'D' && msp_prod_lo < 5);
716         /* Has scart2 output: not in stripped down products of
717          * the '3' family */
718         state->has_scart2_out =
719                 msp_family >= 4 || msp_prod_lo < 5;
720         /* Has scart2 a volume control? Not in pre-D revisions. */
721         state->has_scart2_out_volume =
722                 msp_revision > 'C' && state->has_scart2_out;
723         /* Has a configurable i2s out? */
724         state->has_i2s_conf =
725                 msp_revision >= 'G' && msp_prod_lo < 7;
726         /* Has subwoofer output: not in pre-D revs and not in stripped down
727          * products */
728         state->has_subwoofer =
729                 msp_revision >= 'D' && msp_prod_lo < 5;
730         /* Has soundprocessing (bass/treble/balance/loudness/equalizer):
731          *  not in stripped down products */
732         state->has_sound_processing =
733                 msp_prod_lo < 7;
734         /* Has Virtual Dolby Surround: only in msp34x1 */
735         state->has_virtual_dolby_surround =
736                 msp_revision == 'G' && msp_prod_lo == 1;
737         /* Has Virtual Dolby Surround & Dolby Pro Logic: only in msp34x2 */
738         state->has_dolby_pro_logic =
739                 msp_revision == 'G' && msp_prod_lo == 2;
740         /* The msp343xG supports BTSC only and cannot do Automatic Standard
741          * Detection. */
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                 /* MSP revision G and up have both autodetect and autoselect */
748                 if (msp_revision >= 'G')
749                         state->opmode = OPMODE_AUTOSELECT;
750                 /* MSP revision D and up have autodetect */
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         /* hello world :-) */
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         /* version-specific initialization */
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         /* startup control thread if needed */
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
827 static 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         /* shutdown control thread */
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
846 static const struct i2c_device_id msp_id[] = {
847         { "msp3400", 0 },
848         { }
849 };
850 MODULE_DEVICE_TABLE(i2c, msp_id);
851
852 static 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
864 static __init int init_msp(void)
865 {
866         return i2c_add_driver(&msp_driver);
867 }
868
869 static __exit void exit_msp(void)
870 {
871         i2c_del_driver(&msp_driver);
872 }
873
874 module_init(init_msp);
875 module_exit(exit_msp);
876
877 /*
878  * Overrides for Emacs so that we follow Linus's tabbing style.
879  * ---------------------------------------------------------------------------
880  * Local variables:
881  * c-basic-offset: 8
882  * End:
883  */