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