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 bool msp_once; /* no continuous stereo monitoring */ 73 bool 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 bool 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 { 123 .addr = client->addr, 124 .flags = I2C_M_IGNORE_NAK, 125 .len = 3, 126 .buf = reset_off 127 }, 128 { 129 .addr = client->addr, 130 .flags = I2C_M_IGNORE_NAK, 131 .len = 3, 132 .buf = reset_on 133 }, 134 }; 135 struct i2c_msg test[2] = { 136 { 137 .addr = client->addr, 138 .len = 3, 139 .buf = write 140 }, 141 { 142 .addr = client->addr, 143 .flags = I2C_M_RD, 144 .len = 2, 145 .buf = read 146 }, 147 }; 148 149 v4l_dbg(3, msp_debug, client, "msp_reset\n"); 150 if (i2c_transfer(client->adapter, &reset[0], 1) != 1 || 151 i2c_transfer(client->adapter, &reset[1], 1) != 1 || 152 i2c_transfer(client->adapter, test, 2) != 2) { 153 v4l_err(client, "chip reset failed\n"); 154 return -1; 155 } 156 return 0; 157 } 158 159 static int msp_read(struct i2c_client *client, int dev, int addr) 160 { 161 int err, retval; 162 u8 write[3]; 163 u8 read[2]; 164 struct i2c_msg msgs[2] = { 165 { 166 .addr = client->addr, 167 .len = 3, 168 .buf = write 169 }, 170 { 171 .addr = client->addr, 172 .flags = I2C_M_RD, 173 .len = 2, 174 .buf = read 175 } 176 }; 177 178 write[0] = dev + 1; 179 write[1] = addr >> 8; 180 write[2] = addr & 0xff; 181 182 for (err = 0; err < 3; err++) { 183 if (i2c_transfer(client->adapter, msgs, 2) == 2) 184 break; 185 v4l_warn(client, "I/O error #%d (read 0x%02x/0x%02x)\n", err, 186 dev, addr); 187 schedule_timeout_interruptible(msecs_to_jiffies(10)); 188 } 189 if (err == 3) { 190 v4l_warn(client, "resetting chip, sound will go off.\n"); 191 msp_reset(client); 192 return -1; 193 } 194 retval = read[0] << 8 | read[1]; 195 v4l_dbg(3, msp_debug, client, "msp_read(0x%x, 0x%x): 0x%x\n", 196 dev, addr, retval); 197 return retval; 198 } 199 200 int msp_read_dem(struct i2c_client *client, int addr) 201 { 202 return msp_read(client, I2C_MSP_DEM, addr); 203 } 204 205 int msp_read_dsp(struct i2c_client *client, int addr) 206 { 207 return msp_read(client, I2C_MSP_DSP, addr); 208 } 209 210 static int msp_write(struct i2c_client *client, int dev, int addr, int val) 211 { 212 int err; 213 u8 buffer[5]; 214 215 buffer[0] = dev; 216 buffer[1] = addr >> 8; 217 buffer[2] = addr & 0xff; 218 buffer[3] = val >> 8; 219 buffer[4] = val & 0xff; 220 221 v4l_dbg(3, msp_debug, client, "msp_write(0x%x, 0x%x, 0x%x)\n", 222 dev, addr, val); 223 for (err = 0; err < 3; err++) { 224 if (i2c_master_send(client, buffer, 5) == 5) 225 break; 226 v4l_warn(client, "I/O error #%d (write 0x%02x/0x%02x)\n", err, 227 dev, addr); 228 schedule_timeout_interruptible(msecs_to_jiffies(10)); 229 } 230 if (err == 3) { 231 v4l_warn(client, "resetting chip, sound will go off.\n"); 232 msp_reset(client); 233 return -1; 234 } 235 return 0; 236 } 237 238 int msp_write_dem(struct i2c_client *client, int addr, int val) 239 { 240 return msp_write(client, I2C_MSP_DEM, addr, val); 241 } 242 243 int msp_write_dsp(struct i2c_client *client, int addr, int val) 244 { 245 return msp_write(client, I2C_MSP_DSP, addr, val); 246 } 247 248 /* ----------------------------------------------------------------------- * 249 * bits 9 8 5 - SCART DSP input Select: 250 * 0 0 0 - SCART 1 to DSP input (reset position) 251 * 0 1 0 - MONO to DSP input 252 * 1 0 0 - SCART 2 to DSP input 253 * 1 1 1 - Mute DSP input 254 * 255 * bits 11 10 6 - SCART 1 Output Select: 256 * 0 0 0 - undefined (reset position) 257 * 0 1 0 - SCART 2 Input to SCART 1 Output (for devices with 2 SCARTS) 258 * 1 0 0 - MONO input to SCART 1 Output 259 * 1 1 0 - SCART 1 DA to SCART 1 Output 260 * 0 0 1 - SCART 2 DA to SCART 1 Output 261 * 0 1 1 - SCART 1 Input to SCART 1 Output 262 * 1 1 1 - Mute SCART 1 Output 263 * 264 * bits 13 12 7 - SCART 2 Output Select (for devices with 2 Output SCART): 265 * 0 0 0 - SCART 1 DA to SCART 2 Output (reset position) 266 * 0 1 0 - SCART 1 Input to SCART 2 Output 267 * 1 0 0 - MONO input to SCART 2 Output 268 * 0 0 1 - SCART 2 DA to SCART 2 Output 269 * 0 1 1 - SCART 2 Input to SCART 2 Output 270 * 1 1 0 - Mute SCART 2 Output 271 * 272 * Bits 4 to 0 should be zero. 273 * ----------------------------------------------------------------------- */ 274 275 static int scarts[3][9] = { 276 /* MASK IN1 IN2 IN3 IN4 IN1_DA IN2_DA MONO MUTE */ 277 /* SCART DSP Input select */ 278 { 0x0320, 0x0000, 0x0200, 0x0300, 0x0020, -1, -1, 0x0100, 0x0320 }, 279 /* SCART1 Output select */ 280 { 0x0c40, 0x0440, 0x0400, 0x0000, 0x0840, 0x0c00, 0x0040, 0x0800, 0x0c40 }, 281 /* SCART2 Output select */ 282 { 0x3080, 0x1000, 0x1080, 0x2080, 0x3080, 0x0000, 0x0080, 0x2000, 0x3000 }, 283 }; 284 285 static char *scart_names[] = { 286 "in1", "in2", "in3", "in4", "in1 da", "in2 da", "mono", "mute" 287 }; 288 289 void msp_set_scart(struct i2c_client *client, int in, int out) 290 { 291 struct msp_state *state = to_state(i2c_get_clientdata(client)); 292 293 state->in_scart = in; 294 295 if (in >= 0 && in <= 7 && out >= 0 && out <= 2) { 296 if (-1 == scarts[out][in + 1]) 297 return; 298 299 state->acb &= ~scarts[out][0]; 300 state->acb |= scarts[out][in + 1]; 301 } else 302 state->acb = 0xf60; /* Mute Input and SCART 1 Output */ 303 304 v4l_dbg(1, msp_debug, client, "scart switch: %s => %d (ACB=0x%04x)\n", 305 scart_names[in], out, state->acb); 306 msp_write_dsp(client, 0x13, state->acb); 307 308 /* Sets I2S speed 0 = 1.024 Mbps, 1 = 2.048 Mbps */ 309 if (state->has_i2s_conf) 310 msp_write_dem(client, 0x40, state->i2s_mode); 311 } 312 313 /* ------------------------------------------------------------------------ */ 314 315 static void msp_wake_thread(struct i2c_client *client) 316 { 317 struct msp_state *state = to_state(i2c_get_clientdata(client)); 318 319 if (NULL == state->kthread) 320 return; 321 state->watch_stereo = 0; 322 state->restart = 1; 323 wake_up_interruptible(&state->wq); 324 } 325 326 int msp_sleep(struct msp_state *state, int timeout) 327 { 328 DECLARE_WAITQUEUE(wait, current); 329 330 add_wait_queue(&state->wq, &wait); 331 if (!kthread_should_stop()) { 332 if (timeout < 0) { 333 set_current_state(TASK_INTERRUPTIBLE); 334 schedule(); 335 } else { 336 schedule_timeout_interruptible 337 (msecs_to_jiffies(timeout)); 338 } 339 } 340 341 remove_wait_queue(&state->wq, &wait); 342 try_to_freeze(); 343 return state->restart; 344 } 345 346 /* ------------------------------------------------------------------------ */ 347 348 static int msp_s_ctrl(struct v4l2_ctrl *ctrl) 349 { 350 struct msp_state *state = ctrl_to_state(ctrl); 351 struct i2c_client *client = v4l2_get_subdevdata(&state->sd); 352 int val = ctrl->val; 353 354 switch (ctrl->id) { 355 case V4L2_CID_AUDIO_VOLUME: { 356 /* audio volume cluster */ 357 int reallymuted = state->muted->val | state->scan_in_progress; 358 359 if (!reallymuted) 360 val = (val * 0x7f / 65535) << 8; 361 362 v4l_dbg(1, msp_debug, client, "mute=%s scanning=%s volume=%d\n", 363 state->muted->val ? "on" : "off", 364 state->scan_in_progress ? "yes" : "no", 365 state->volume->val); 366 367 msp_write_dsp(client, 0x0000, val); 368 msp_write_dsp(client, 0x0007, reallymuted ? 0x1 : (val | 0x1)); 369 if (state->has_scart2_out_volume) 370 msp_write_dsp(client, 0x0040, reallymuted ? 0x1 : (val | 0x1)); 371 if (state->has_headphones) 372 msp_write_dsp(client, 0x0006, val); 373 break; 374 } 375 376 case V4L2_CID_AUDIO_BASS: 377 val = ((val - 32768) * 0x60 / 65535) << 8; 378 msp_write_dsp(client, 0x0002, val); 379 if (state->has_headphones) 380 msp_write_dsp(client, 0x0031, val); 381 break; 382 383 case V4L2_CID_AUDIO_TREBLE: 384 val = ((val - 32768) * 0x60 / 65535) << 8; 385 msp_write_dsp(client, 0x0003, val); 386 if (state->has_headphones) 387 msp_write_dsp(client, 0x0032, val); 388 break; 389 390 case V4L2_CID_AUDIO_LOUDNESS: 391 val = val ? ((5 * 4) << 8) : 0; 392 msp_write_dsp(client, 0x0004, val); 393 if (state->has_headphones) 394 msp_write_dsp(client, 0x0033, val); 395 break; 396 397 case V4L2_CID_AUDIO_BALANCE: 398 val = (u8)((val / 256) - 128); 399 msp_write_dsp(client, 0x0001, val << 8); 400 if (state->has_headphones) 401 msp_write_dsp(client, 0x0030, val << 8); 402 break; 403 404 default: 405 return -EINVAL; 406 } 407 return 0; 408 } 409 410 void msp_update_volume(struct msp_state *state) 411 { 412 /* Force an update of the volume/mute cluster */ 413 v4l2_ctrl_lock(state->volume); 414 state->volume->val = state->volume->cur.val; 415 state->muted->val = state->muted->cur.val; 416 msp_s_ctrl(state->volume); 417 v4l2_ctrl_unlock(state->volume); 418 } 419 420 /* --- v4l2 ioctls --- */ 421 static int msp_s_radio(struct v4l2_subdev *sd) 422 { 423 struct msp_state *state = to_state(sd); 424 struct i2c_client *client = v4l2_get_subdevdata(sd); 425 426 if (state->radio) 427 return 0; 428 state->radio = 1; 429 v4l_dbg(1, msp_debug, client, "switching to radio mode\n"); 430 state->watch_stereo = 0; 431 switch (state->opmode) { 432 case OPMODE_MANUAL: 433 /* set msp3400 to FM radio mode */ 434 msp3400c_set_mode(client, MSP_MODE_FM_RADIO); 435 msp3400c_set_carrier(client, MSP_CARRIER(10.7), 436 MSP_CARRIER(10.7)); 437 msp_update_volume(state); 438 break; 439 case OPMODE_AUTODETECT: 440 case OPMODE_AUTOSELECT: 441 /* the thread will do for us */ 442 msp_wake_thread(client); 443 break; 444 } 445 return 0; 446 } 447 448 static int msp_s_frequency(struct v4l2_subdev *sd, const struct v4l2_frequency *freq) 449 { 450 struct i2c_client *client = v4l2_get_subdevdata(sd); 451 452 /* new channel -- kick audio carrier scan */ 453 msp_wake_thread(client); 454 return 0; 455 } 456 457 static int msp_querystd(struct v4l2_subdev *sd, v4l2_std_id *id) 458 { 459 struct msp_state *state = to_state(sd); 460 struct i2c_client *client = v4l2_get_subdevdata(sd); 461 462 *id &= state->detected_std; 463 464 v4l_dbg(2, msp_debug, client, 465 "detected standard: %s(0x%08Lx)\n", 466 msp_standard_std_name(state->std), state->detected_std); 467 468 return 0; 469 } 470 471 static int msp_s_std(struct v4l2_subdev *sd, v4l2_std_id id) 472 { 473 struct msp_state *state = to_state(sd); 474 struct i2c_client *client = v4l2_get_subdevdata(sd); 475 int update = state->radio || state->v4l2_std != id; 476 477 state->v4l2_std = id; 478 state->radio = 0; 479 if (update) 480 msp_wake_thread(client); 481 return 0; 482 } 483 484 static int msp_s_routing(struct v4l2_subdev *sd, 485 u32 input, u32 output, u32 config) 486 { 487 struct msp_state *state = to_state(sd); 488 struct i2c_client *client = v4l2_get_subdevdata(sd); 489 int tuner = (input >> 3) & 1; 490 int sc_in = input & 0x7; 491 int sc1_out = output & 0xf; 492 int sc2_out = (output >> 4) & 0xf; 493 u16 val, reg; 494 int i; 495 int extern_input = 1; 496 497 if (state->route_in == input && state->route_out == output) 498 return 0; 499 state->route_in = input; 500 state->route_out = output; 501 /* check if the tuner input is used */ 502 for (i = 0; i < 5; i++) { 503 if (((input >> (4 + i * 4)) & 0xf) == 0) 504 extern_input = 0; 505 } 506 state->mode = extern_input ? MSP_MODE_EXTERN : MSP_MODE_AM_DETECT; 507 state->rxsubchans = V4L2_TUNER_SUB_STEREO; 508 msp_set_scart(client, sc_in, 0); 509 msp_set_scart(client, sc1_out, 1); 510 msp_set_scart(client, sc2_out, 2); 511 msp_set_audmode(client); 512 reg = (state->opmode == OPMODE_AUTOSELECT) ? 0x30 : 0xbb; 513 val = msp_read_dem(client, reg); 514 msp_write_dem(client, reg, (val & ~0x100) | (tuner << 8)); 515 /* wake thread when a new input is chosen */ 516 msp_wake_thread(client); 517 return 0; 518 } 519 520 static int msp_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt) 521 { 522 struct msp_state *state = to_state(sd); 523 struct i2c_client *client = v4l2_get_subdevdata(sd); 524 525 if (vt->type != V4L2_TUNER_ANALOG_TV) 526 return 0; 527 if (!state->radio) { 528 if (state->opmode == OPMODE_AUTOSELECT) 529 msp_detect_stereo(client); 530 vt->rxsubchans = state->rxsubchans; 531 } 532 vt->audmode = state->audmode; 533 vt->capability |= V4L2_TUNER_CAP_STEREO | 534 V4L2_TUNER_CAP_LANG1 | V4L2_TUNER_CAP_LANG2; 535 return 0; 536 } 537 538 static int msp_s_tuner(struct v4l2_subdev *sd, const struct v4l2_tuner *vt) 539 { 540 struct msp_state *state = to_state(sd); 541 struct i2c_client *client = v4l2_get_subdevdata(sd); 542 543 if (state->radio) /* TODO: add mono/stereo support for radio */ 544 return 0; 545 if (state->audmode == vt->audmode) 546 return 0; 547 state->audmode = vt->audmode; 548 /* only set audmode */ 549 msp_set_audmode(client); 550 return 0; 551 } 552 553 static int msp_s_i2s_clock_freq(struct v4l2_subdev *sd, u32 freq) 554 { 555 struct msp_state *state = to_state(sd); 556 struct i2c_client *client = v4l2_get_subdevdata(sd); 557 558 v4l_dbg(1, msp_debug, client, "Setting I2S speed to %d\n", freq); 559 560 switch (freq) { 561 case 1024000: 562 state->i2s_mode = 0; 563 break; 564 case 2048000: 565 state->i2s_mode = 1; 566 break; 567 default: 568 return -EINVAL; 569 } 570 return 0; 571 } 572 573 static int msp_log_status(struct v4l2_subdev *sd) 574 { 575 struct msp_state *state = to_state(sd); 576 struct i2c_client *client = v4l2_get_subdevdata(sd); 577 const char *p; 578 char prefix[V4L2_SUBDEV_NAME_SIZE + 20]; 579 580 if (state->opmode == OPMODE_AUTOSELECT) 581 msp_detect_stereo(client); 582 v4l_info(client, "%s rev1 = 0x%04x rev2 = 0x%04x\n", 583 client->name, state->rev1, state->rev2); 584 snprintf(prefix, sizeof(prefix), "%s: Audio: ", sd->name); 585 v4l2_ctrl_handler_log_status(&state->hdl, prefix); 586 switch (state->mode) { 587 case MSP_MODE_AM_DETECT: p = "AM (for carrier detect)"; break; 588 case MSP_MODE_FM_RADIO: p = "FM Radio"; break; 589 case MSP_MODE_FM_TERRA: p = "Terrestrial FM-mono/stereo"; break; 590 case MSP_MODE_FM_SAT: p = "Satellite FM-mono"; break; 591 case MSP_MODE_FM_NICAM1: p = "NICAM/FM (B/G, D/K)"; break; 592 case MSP_MODE_FM_NICAM2: p = "NICAM/FM (I)"; break; 593 case MSP_MODE_AM_NICAM: p = "NICAM/AM (L)"; break; 594 case MSP_MODE_BTSC: p = "BTSC"; break; 595 case MSP_MODE_EXTERN: p = "External input"; break; 596 default: p = "unknown"; break; 597 } 598 if (state->mode == MSP_MODE_EXTERN) { 599 v4l_info(client, "Mode: %s\n", p); 600 } else if (state->opmode == OPMODE_MANUAL) { 601 v4l_info(client, "Mode: %s (%s%s)\n", p, 602 (state->rxsubchans & V4L2_TUNER_SUB_STEREO) ? "stereo" : "mono", 603 (state->rxsubchans & V4L2_TUNER_SUB_LANG2) ? ", dual" : ""); 604 } else { 605 if (state->opmode == OPMODE_AUTODETECT) 606 v4l_info(client, "Mode: %s\n", p); 607 v4l_info(client, "Standard: %s (%s%s)\n", 608 msp_standard_std_name(state->std), 609 (state->rxsubchans & V4L2_TUNER_SUB_STEREO) ? "stereo" : "mono", 610 (state->rxsubchans & V4L2_TUNER_SUB_LANG2) ? ", dual" : ""); 611 } 612 v4l_info(client, "Audmode: 0x%04x\n", state->audmode); 613 v4l_info(client, "Routing: 0x%08x (input) 0x%08x (output)\n", 614 state->route_in, state->route_out); 615 v4l_info(client, "ACB: 0x%04x\n", state->acb); 616 return 0; 617 } 618 619 #ifdef CONFIG_PM_SLEEP 620 static int msp_suspend(struct device *dev) 621 { 622 struct i2c_client *client = to_i2c_client(dev); 623 v4l_dbg(1, msp_debug, client, "suspend\n"); 624 msp_reset(client); 625 return 0; 626 } 627 628 static int msp_resume(struct device *dev) 629 { 630 struct i2c_client *client = to_i2c_client(dev); 631 v4l_dbg(1, msp_debug, client, "resume\n"); 632 msp_wake_thread(client); 633 return 0; 634 } 635 #endif 636 637 /* ----------------------------------------------------------------------- */ 638 639 static const struct v4l2_ctrl_ops msp_ctrl_ops = { 640 .s_ctrl = msp_s_ctrl, 641 }; 642 643 static const struct v4l2_subdev_core_ops msp_core_ops = { 644 .log_status = msp_log_status, 645 .g_ext_ctrls = v4l2_subdev_g_ext_ctrls, 646 .try_ext_ctrls = v4l2_subdev_try_ext_ctrls, 647 .s_ext_ctrls = v4l2_subdev_s_ext_ctrls, 648 .g_ctrl = v4l2_subdev_g_ctrl, 649 .s_ctrl = v4l2_subdev_s_ctrl, 650 .queryctrl = v4l2_subdev_queryctrl, 651 .querymenu = v4l2_subdev_querymenu, 652 }; 653 654 static const struct v4l2_subdev_video_ops msp_video_ops = { 655 .s_std = msp_s_std, 656 .querystd = msp_querystd, 657 }; 658 659 static const struct v4l2_subdev_tuner_ops msp_tuner_ops = { 660 .s_frequency = msp_s_frequency, 661 .g_tuner = msp_g_tuner, 662 .s_tuner = msp_s_tuner, 663 .s_radio = msp_s_radio, 664 }; 665 666 static const struct v4l2_subdev_audio_ops msp_audio_ops = { 667 .s_routing = msp_s_routing, 668 .s_i2s_clock_freq = msp_s_i2s_clock_freq, 669 }; 670 671 static const struct v4l2_subdev_ops msp_ops = { 672 .core = &msp_core_ops, 673 .video = &msp_video_ops, 674 .tuner = &msp_tuner_ops, 675 .audio = &msp_audio_ops, 676 }; 677 678 /* ----------------------------------------------------------------------- */ 679 680 static int msp_probe(struct i2c_client *client, const struct i2c_device_id *id) 681 { 682 struct msp_state *state; 683 struct v4l2_subdev *sd; 684 struct v4l2_ctrl_handler *hdl; 685 int (*thread_func)(void *data) = NULL; 686 int msp_hard; 687 int msp_family; 688 int msp_revision; 689 int msp_product, msp_prod_hi, msp_prod_lo; 690 int msp_rom; 691 692 if (!id) 693 strlcpy(client->name, "msp3400", sizeof(client->name)); 694 695 if (msp_reset(client) == -1) { 696 v4l_dbg(1, msp_debug, client, "msp3400 not found\n"); 697 return -ENODEV; 698 } 699 700 state = devm_kzalloc(&client->dev, sizeof(*state), GFP_KERNEL); 701 if (!state) 702 return -ENOMEM; 703 704 sd = &state->sd; 705 v4l2_i2c_subdev_init(sd, client, &msp_ops); 706 707 state->v4l2_std = V4L2_STD_NTSC; 708 state->detected_std = V4L2_STD_ALL; 709 state->audmode = V4L2_TUNER_MODE_STEREO; 710 state->input = -1; 711 state->i2s_mode = 0; 712 init_waitqueue_head(&state->wq); 713 /* These are the reset input/output positions */ 714 state->route_in = MSP_INPUT_DEFAULT; 715 state->route_out = MSP_OUTPUT_DEFAULT; 716 717 state->rev1 = msp_read_dsp(client, 0x1e); 718 if (state->rev1 != -1) 719 state->rev2 = msp_read_dsp(client, 0x1f); 720 v4l_dbg(1, msp_debug, client, "rev1=0x%04x, rev2=0x%04x\n", 721 state->rev1, state->rev2); 722 if (state->rev1 == -1 || (state->rev1 == 0 && state->rev2 == 0)) { 723 v4l_dbg(1, msp_debug, client, 724 "not an msp3400 (cannot read chip version)\n"); 725 return -ENODEV; 726 } 727 728 msp_family = ((state->rev1 >> 4) & 0x0f) + 3; 729 msp_product = (state->rev2 >> 8) & 0xff; 730 msp_prod_hi = msp_product / 10; 731 msp_prod_lo = msp_product % 10; 732 msp_revision = (state->rev1 & 0x0f) + '@'; 733 msp_hard = ((state->rev1 >> 8) & 0xff) + '@'; 734 msp_rom = state->rev2 & 0x1f; 735 /* Rev B=2, C=3, D=4, G=7 */ 736 state->ident = msp_family * 10000 + 4000 + msp_product * 10 + 737 msp_revision - '@'; 738 739 /* Has NICAM support: all mspx41x and mspx45x products have NICAM */ 740 state->has_nicam = 741 msp_prod_hi == 1 || msp_prod_hi == 5; 742 /* Has radio support: was added with revision G */ 743 state->has_radio = 744 msp_revision >= 'G'; 745 /* Has headphones output: not for stripped down products */ 746 state->has_headphones = 747 msp_prod_lo < 5; 748 /* Has scart2 input: not in stripped down products of the '3' family */ 749 state->has_scart2 = 750 msp_family >= 4 || msp_prod_lo < 7; 751 /* Has scart3 input: not in stripped down products of the '3' family */ 752 state->has_scart3 = 753 msp_family >= 4 || msp_prod_lo < 5; 754 /* Has scart4 input: not in pre D revisions, not in stripped D revs */ 755 state->has_scart4 = 756 msp_family >= 4 || (msp_revision >= 'D' && msp_prod_lo < 5); 757 /* Has scart2 output: not in stripped down products of 758 * the '3' family */ 759 state->has_scart2_out = 760 msp_family >= 4 || msp_prod_lo < 5; 761 /* Has scart2 a volume control? Not in pre-D revisions. */ 762 state->has_scart2_out_volume = 763 msp_revision > 'C' && state->has_scart2_out; 764 /* Has a configurable i2s out? */ 765 state->has_i2s_conf = 766 msp_revision >= 'G' && msp_prod_lo < 7; 767 /* Has subwoofer output: not in pre-D revs and not in stripped down 768 * products */ 769 state->has_subwoofer = 770 msp_revision >= 'D' && msp_prod_lo < 5; 771 /* Has soundprocessing (bass/treble/balance/loudness/equalizer): 772 * not in stripped down products */ 773 state->has_sound_processing = 774 msp_prod_lo < 7; 775 /* Has Virtual Dolby Surround: only in msp34x1 */ 776 state->has_virtual_dolby_surround = 777 msp_revision == 'G' && msp_prod_lo == 1; 778 /* Has Virtual Dolby Surround & Dolby Pro Logic: only in msp34x2 */ 779 state->has_dolby_pro_logic = 780 msp_revision == 'G' && msp_prod_lo == 2; 781 /* The msp343xG supports BTSC only and cannot do Automatic Standard 782 * Detection. */ 783 state->force_btsc = 784 msp_family == 3 && msp_revision == 'G' && msp_prod_hi == 3; 785 786 state->opmode = opmode; 787 if (state->opmode == OPMODE_AUTO) { 788 /* MSP revision G and up have both autodetect and autoselect */ 789 if (msp_revision >= 'G') 790 state->opmode = OPMODE_AUTOSELECT; 791 /* MSP revision D and up have autodetect */ 792 else if (msp_revision >= 'D') 793 state->opmode = OPMODE_AUTODETECT; 794 else 795 state->opmode = OPMODE_MANUAL; 796 } 797 798 hdl = &state->hdl; 799 v4l2_ctrl_handler_init(hdl, 6); 800 if (state->has_sound_processing) { 801 v4l2_ctrl_new_std(hdl, &msp_ctrl_ops, 802 V4L2_CID_AUDIO_BASS, 0, 65535, 65535 / 100, 32768); 803 v4l2_ctrl_new_std(hdl, &msp_ctrl_ops, 804 V4L2_CID_AUDIO_TREBLE, 0, 65535, 65535 / 100, 32768); 805 v4l2_ctrl_new_std(hdl, &msp_ctrl_ops, 806 V4L2_CID_AUDIO_LOUDNESS, 0, 1, 1, 0); 807 } 808 state->volume = v4l2_ctrl_new_std(hdl, &msp_ctrl_ops, 809 V4L2_CID_AUDIO_VOLUME, 0, 65535, 65535 / 100, 58880); 810 v4l2_ctrl_new_std(hdl, &msp_ctrl_ops, 811 V4L2_CID_AUDIO_BALANCE, 0, 65535, 65535 / 100, 32768); 812 state->muted = v4l2_ctrl_new_std(hdl, &msp_ctrl_ops, 813 V4L2_CID_AUDIO_MUTE, 0, 1, 1, 0); 814 sd->ctrl_handler = hdl; 815 if (hdl->error) { 816 int err = hdl->error; 817 818 v4l2_ctrl_handler_free(hdl); 819 return err; 820 } 821 822 v4l2_ctrl_cluster(2, &state->volume); 823 v4l2_ctrl_handler_setup(hdl); 824 825 /* hello world :-) */ 826 v4l_info(client, "MSP%d4%02d%c-%c%d found @ 0x%x (%s)\n", 827 msp_family, msp_product, 828 msp_revision, msp_hard, msp_rom, 829 client->addr << 1, client->adapter->name); 830 v4l_info(client, "%s ", client->name); 831 if (state->has_nicam && state->has_radio) 832 printk(KERN_CONT "supports nicam and radio, "); 833 else if (state->has_nicam) 834 printk(KERN_CONT "supports nicam, "); 835 else if (state->has_radio) 836 printk(KERN_CONT "supports radio, "); 837 printk(KERN_CONT "mode is "); 838 839 /* version-specific initialization */ 840 switch (state->opmode) { 841 case OPMODE_MANUAL: 842 printk(KERN_CONT "manual"); 843 thread_func = msp3400c_thread; 844 break; 845 case OPMODE_AUTODETECT: 846 printk(KERN_CONT "autodetect"); 847 thread_func = msp3410d_thread; 848 break; 849 case OPMODE_AUTOSELECT: 850 printk(KERN_CONT "autodetect and autoselect"); 851 thread_func = msp34xxg_thread; 852 break; 853 } 854 printk(KERN_CONT "\n"); 855 856 /* startup control thread if needed */ 857 if (thread_func) { 858 state->kthread = kthread_run(thread_func, client, "msp34xx"); 859 860 if (IS_ERR(state->kthread)) 861 v4l_warn(client, "kernel_thread() failed\n"); 862 msp_wake_thread(client); 863 } 864 return 0; 865 } 866 867 static int msp_remove(struct i2c_client *client) 868 { 869 struct msp_state *state = to_state(i2c_get_clientdata(client)); 870 871 v4l2_device_unregister_subdev(&state->sd); 872 /* shutdown control thread */ 873 if (state->kthread) { 874 state->restart = 1; 875 kthread_stop(state->kthread); 876 } 877 msp_reset(client); 878 879 v4l2_ctrl_handler_free(&state->hdl); 880 return 0; 881 } 882 883 /* ----------------------------------------------------------------------- */ 884 885 static const struct dev_pm_ops msp3400_pm_ops = { 886 SET_SYSTEM_SLEEP_PM_OPS(msp_suspend, msp_resume) 887 }; 888 889 static const struct i2c_device_id msp_id[] = { 890 { "msp3400", 0 }, 891 { } 892 }; 893 MODULE_DEVICE_TABLE(i2c, msp_id); 894 895 static struct i2c_driver msp_driver = { 896 .driver = { 897 .name = "msp3400", 898 .pm = &msp3400_pm_ops, 899 }, 900 .probe = msp_probe, 901 .remove = msp_remove, 902 .id_table = msp_id, 903 }; 904 905 module_i2c_driver(msp_driver); 906