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/drv-intf/msp3400.h> 60 #include <media/i2c/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 #if defined(CONFIG_MEDIA_CONTROLLER) 692 int ret; 693 #endif 694 695 if (!id) 696 strlcpy(client->name, "msp3400", sizeof(client->name)); 697 698 if (msp_reset(client) == -1) { 699 v4l_dbg(1, msp_debug, client, "msp3400 not found\n"); 700 return -ENODEV; 701 } 702 703 state = devm_kzalloc(&client->dev, sizeof(*state), GFP_KERNEL); 704 if (!state) 705 return -ENOMEM; 706 707 sd = &state->sd; 708 v4l2_i2c_subdev_init(sd, client, &msp_ops); 709 710 #if defined(CONFIG_MEDIA_CONTROLLER) 711 state->pads[IF_AUD_DEC_PAD_IF_INPUT].flags = MEDIA_PAD_FL_SINK; 712 state->pads[IF_AUD_DEC_PAD_OUT].flags = MEDIA_PAD_FL_SOURCE; 713 714 sd->entity.function = MEDIA_ENT_F_IF_AUD_DECODER; 715 716 ret = media_entity_pads_init(&sd->entity, 2, state->pads); 717 if (ret < 0) 718 return ret; 719 #endif 720 721 state->v4l2_std = V4L2_STD_NTSC; 722 state->detected_std = V4L2_STD_ALL; 723 state->audmode = V4L2_TUNER_MODE_STEREO; 724 state->input = -1; 725 state->i2s_mode = 0; 726 init_waitqueue_head(&state->wq); 727 /* These are the reset input/output positions */ 728 state->route_in = MSP_INPUT_DEFAULT; 729 state->route_out = MSP_OUTPUT_DEFAULT; 730 731 state->rev1 = msp_read_dsp(client, 0x1e); 732 if (state->rev1 != -1) 733 state->rev2 = msp_read_dsp(client, 0x1f); 734 v4l_dbg(1, msp_debug, client, "rev1=0x%04x, rev2=0x%04x\n", 735 state->rev1, state->rev2); 736 if (state->rev1 == -1 || (state->rev1 == 0 && state->rev2 == 0)) { 737 v4l_dbg(1, msp_debug, client, 738 "not an msp3400 (cannot read chip version)\n"); 739 return -ENODEV; 740 } 741 742 msp_family = ((state->rev1 >> 4) & 0x0f) + 3; 743 msp_product = (state->rev2 >> 8) & 0xff; 744 msp_prod_hi = msp_product / 10; 745 msp_prod_lo = msp_product % 10; 746 msp_revision = (state->rev1 & 0x0f) + '@'; 747 msp_hard = ((state->rev1 >> 8) & 0xff) + '@'; 748 msp_rom = state->rev2 & 0x1f; 749 /* Rev B=2, C=3, D=4, G=7 */ 750 state->ident = msp_family * 10000 + 4000 + msp_product * 10 + 751 msp_revision - '@'; 752 753 /* Has NICAM support: all mspx41x and mspx45x products have NICAM */ 754 state->has_nicam = 755 msp_prod_hi == 1 || msp_prod_hi == 5; 756 /* Has radio support: was added with revision G */ 757 state->has_radio = 758 msp_revision >= 'G'; 759 /* Has headphones output: not for stripped down products */ 760 state->has_headphones = 761 msp_prod_lo < 5; 762 /* Has scart2 input: not in stripped down products of the '3' family */ 763 state->has_scart2 = 764 msp_family >= 4 || msp_prod_lo < 7; 765 /* Has scart3 input: not in stripped down products of the '3' family */ 766 state->has_scart3 = 767 msp_family >= 4 || msp_prod_lo < 5; 768 /* Has scart4 input: not in pre D revisions, not in stripped D revs */ 769 state->has_scart4 = 770 msp_family >= 4 || (msp_revision >= 'D' && msp_prod_lo < 5); 771 /* Has scart2 output: not in stripped down products of 772 * the '3' family */ 773 state->has_scart2_out = 774 msp_family >= 4 || msp_prod_lo < 5; 775 /* Has scart2 a volume control? Not in pre-D revisions. */ 776 state->has_scart2_out_volume = 777 msp_revision > 'C' && state->has_scart2_out; 778 /* Has a configurable i2s out? */ 779 state->has_i2s_conf = 780 msp_revision >= 'G' && msp_prod_lo < 7; 781 /* Has subwoofer output: not in pre-D revs and not in stripped down 782 * products */ 783 state->has_subwoofer = 784 msp_revision >= 'D' && msp_prod_lo < 5; 785 /* Has soundprocessing (bass/treble/balance/loudness/equalizer): 786 * not in stripped down products */ 787 state->has_sound_processing = 788 msp_prod_lo < 7; 789 /* Has Virtual Dolby Surround: only in msp34x1 */ 790 state->has_virtual_dolby_surround = 791 msp_revision == 'G' && msp_prod_lo == 1; 792 /* Has Virtual Dolby Surround & Dolby Pro Logic: only in msp34x2 */ 793 state->has_dolby_pro_logic = 794 msp_revision == 'G' && msp_prod_lo == 2; 795 /* The msp343xG supports BTSC only and cannot do Automatic Standard 796 * Detection. */ 797 state->force_btsc = 798 msp_family == 3 && msp_revision == 'G' && msp_prod_hi == 3; 799 800 state->opmode = opmode; 801 if (state->opmode == OPMODE_AUTO) { 802 /* MSP revision G and up have both autodetect and autoselect */ 803 if (msp_revision >= 'G') 804 state->opmode = OPMODE_AUTOSELECT; 805 /* MSP revision D and up have autodetect */ 806 else if (msp_revision >= 'D') 807 state->opmode = OPMODE_AUTODETECT; 808 else 809 state->opmode = OPMODE_MANUAL; 810 } 811 812 hdl = &state->hdl; 813 v4l2_ctrl_handler_init(hdl, 6); 814 if (state->has_sound_processing) { 815 v4l2_ctrl_new_std(hdl, &msp_ctrl_ops, 816 V4L2_CID_AUDIO_BASS, 0, 65535, 65535 / 100, 32768); 817 v4l2_ctrl_new_std(hdl, &msp_ctrl_ops, 818 V4L2_CID_AUDIO_TREBLE, 0, 65535, 65535 / 100, 32768); 819 v4l2_ctrl_new_std(hdl, &msp_ctrl_ops, 820 V4L2_CID_AUDIO_LOUDNESS, 0, 1, 1, 0); 821 } 822 state->volume = v4l2_ctrl_new_std(hdl, &msp_ctrl_ops, 823 V4L2_CID_AUDIO_VOLUME, 0, 65535, 65535 / 100, 58880); 824 v4l2_ctrl_new_std(hdl, &msp_ctrl_ops, 825 V4L2_CID_AUDIO_BALANCE, 0, 65535, 65535 / 100, 32768); 826 state->muted = v4l2_ctrl_new_std(hdl, &msp_ctrl_ops, 827 V4L2_CID_AUDIO_MUTE, 0, 1, 1, 0); 828 sd->ctrl_handler = hdl; 829 if (hdl->error) { 830 int err = hdl->error; 831 832 v4l2_ctrl_handler_free(hdl); 833 return err; 834 } 835 836 v4l2_ctrl_cluster(2, &state->volume); 837 v4l2_ctrl_handler_setup(hdl); 838 839 /* hello world :-) */ 840 v4l_info(client, "MSP%d4%02d%c-%c%d found @ 0x%x (%s)\n", 841 msp_family, msp_product, 842 msp_revision, msp_hard, msp_rom, 843 client->addr << 1, client->adapter->name); 844 v4l_info(client, "%s ", client->name); 845 if (state->has_nicam && state->has_radio) 846 printk(KERN_CONT "supports nicam and radio, "); 847 else if (state->has_nicam) 848 printk(KERN_CONT "supports nicam, "); 849 else if (state->has_radio) 850 printk(KERN_CONT "supports radio, "); 851 printk(KERN_CONT "mode is "); 852 853 /* version-specific initialization */ 854 switch (state->opmode) { 855 case OPMODE_MANUAL: 856 printk(KERN_CONT "manual"); 857 thread_func = msp3400c_thread; 858 break; 859 case OPMODE_AUTODETECT: 860 printk(KERN_CONT "autodetect"); 861 thread_func = msp3410d_thread; 862 break; 863 case OPMODE_AUTOSELECT: 864 printk(KERN_CONT "autodetect and autoselect"); 865 thread_func = msp34xxg_thread; 866 break; 867 } 868 printk(KERN_CONT "\n"); 869 870 /* startup control thread if needed */ 871 if (thread_func) { 872 state->kthread = kthread_run(thread_func, client, "msp34xx"); 873 874 if (IS_ERR(state->kthread)) 875 v4l_warn(client, "kernel_thread() failed\n"); 876 msp_wake_thread(client); 877 } 878 return 0; 879 } 880 881 static int msp_remove(struct i2c_client *client) 882 { 883 struct msp_state *state = to_state(i2c_get_clientdata(client)); 884 885 v4l2_device_unregister_subdev(&state->sd); 886 /* shutdown control thread */ 887 if (state->kthread) { 888 state->restart = 1; 889 kthread_stop(state->kthread); 890 } 891 msp_reset(client); 892 893 v4l2_ctrl_handler_free(&state->hdl); 894 return 0; 895 } 896 897 /* ----------------------------------------------------------------------- */ 898 899 static const struct dev_pm_ops msp3400_pm_ops = { 900 SET_SYSTEM_SLEEP_PM_OPS(msp_suspend, msp_resume) 901 }; 902 903 static const struct i2c_device_id msp_id[] = { 904 { "msp3400", 0 }, 905 { } 906 }; 907 MODULE_DEVICE_TABLE(i2c, msp_id); 908 909 static struct i2c_driver msp_driver = { 910 .driver = { 911 .name = "msp3400", 912 .pm = &msp3400_pm_ops, 913 }, 914 .probe = msp_probe, 915 .remove = msp_remove, 916 .id_table = msp_id, 917 }; 918 919 module_i2c_driver(msp_driver); 920