1/* 2 * Driver for DVBSky USB2.0 receiver 3 * 4 * Copyright (C) 2013 Max nibble <nibble.max@gmail.com> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 */ 20 21#include "dvb_usb.h" 22#include "m88ds3103.h" 23#include "ts2020.h" 24#include "sp2.h" 25#include "si2168.h" 26#include "si2157.h" 27 28#define DVBSKY_MSG_DELAY 0/*2000*/ 29#define DVBSKY_BUF_LEN 64 30 31static int dvb_usb_dvbsky_disable_rc; 32module_param_named(disable_rc, dvb_usb_dvbsky_disable_rc, int, 0644); 33MODULE_PARM_DESC(disable_rc, "Disable inbuilt IR receiver."); 34 35DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); 36 37struct dvbsky_state { 38 struct mutex stream_mutex; 39 u8 ibuf[DVBSKY_BUF_LEN]; 40 u8 obuf[DVBSKY_BUF_LEN]; 41 u8 last_lock; 42 struct i2c_client *i2c_client_demod; 43 struct i2c_client *i2c_client_tuner; 44 struct i2c_client *i2c_client_ci; 45 46 /* fe hook functions*/ 47 int (*fe_set_voltage)(struct dvb_frontend *fe, 48 fe_sec_voltage_t voltage); 49 int (*fe_read_status)(struct dvb_frontend *fe, 50 fe_status_t *status); 51}; 52 53static int dvbsky_usb_generic_rw(struct dvb_usb_device *d, 54 u8 *wbuf, u16 wlen, u8 *rbuf, u16 rlen) 55{ 56 int ret; 57 struct dvbsky_state *state = d_to_priv(d); 58 59 mutex_lock(&d->usb_mutex); 60 if (wlen != 0) 61 memcpy(state->obuf, wbuf, wlen); 62 63 ret = dvb_usbv2_generic_rw_locked(d, state->obuf, wlen, 64 state->ibuf, rlen); 65 66 if (!ret && (rlen != 0)) 67 memcpy(rbuf, state->ibuf, rlen); 68 69 mutex_unlock(&d->usb_mutex); 70 return ret; 71} 72 73static int dvbsky_stream_ctrl(struct dvb_usb_device *d, u8 onoff) 74{ 75 struct dvbsky_state *state = d_to_priv(d); 76 int ret; 77 u8 obuf_pre[3] = { 0x37, 0, 0 }; 78 u8 obuf_post[3] = { 0x36, 3, 0 }; 79 80 mutex_lock(&state->stream_mutex); 81 ret = dvbsky_usb_generic_rw(d, obuf_pre, 3, NULL, 0); 82 if (!ret && onoff) { 83 msleep(20); 84 ret = dvbsky_usb_generic_rw(d, obuf_post, 3, NULL, 0); 85 } 86 mutex_unlock(&state->stream_mutex); 87 return ret; 88} 89 90static int dvbsky_streaming_ctrl(struct dvb_frontend *fe, int onoff) 91{ 92 struct dvb_usb_device *d = fe_to_d(fe); 93 94 return dvbsky_stream_ctrl(d, (onoff == 0) ? 0 : 1); 95} 96 97/* GPIO */ 98static int dvbsky_gpio_ctrl(struct dvb_usb_device *d, u8 gport, u8 value) 99{ 100 int ret; 101 u8 obuf[3], ibuf[2]; 102 103 obuf[0] = 0x0e; 104 obuf[1] = gport; 105 obuf[2] = value; 106 ret = dvbsky_usb_generic_rw(d, obuf, 3, ibuf, 1); 107 if (ret) 108 dev_err(&d->udev->dev, "failed=%d\n", ret); 109 return ret; 110} 111 112/* I2C */ 113static int dvbsky_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[], 114 int num) 115{ 116 struct dvb_usb_device *d = i2c_get_adapdata(adap); 117 int ret = 0; 118 u8 ibuf[64], obuf[64]; 119 120 if (mutex_lock_interruptible(&d->i2c_mutex) < 0) 121 return -EAGAIN; 122 123 if (num > 2) { 124 dev_err(&d->udev->dev, 125 "too many i2c messages[%d], max 2.", num); 126 ret = -EOPNOTSUPP; 127 goto i2c_error; 128 } 129 130 if (num == 1) { 131 if (msg[0].len > 60) { 132 dev_err(&d->udev->dev, 133 "too many i2c bytes[%d], max 60.", 134 msg[0].len); 135 ret = -EOPNOTSUPP; 136 goto i2c_error; 137 } 138 if (msg[0].flags & I2C_M_RD) { 139 /* single read */ 140 obuf[0] = 0x09; 141 obuf[1] = 0; 142 obuf[2] = msg[0].len; 143 obuf[3] = msg[0].addr; 144 ret = dvbsky_usb_generic_rw(d, obuf, 4, 145 ibuf, msg[0].len + 1); 146 if (ret) 147 dev_err(&d->udev->dev, "failed=%d\n", ret); 148 if (!ret) 149 memcpy(msg[0].buf, &ibuf[1], msg[0].len); 150 } else { 151 /* write */ 152 obuf[0] = 0x08; 153 obuf[1] = msg[0].addr; 154 obuf[2] = msg[0].len; 155 memcpy(&obuf[3], msg[0].buf, msg[0].len); 156 ret = dvbsky_usb_generic_rw(d, obuf, 157 msg[0].len + 3, ibuf, 1); 158 if (ret) 159 dev_err(&d->udev->dev, "failed=%d\n", ret); 160 } 161 } else { 162 if ((msg[0].len > 60) || (msg[1].len > 60)) { 163 dev_err(&d->udev->dev, 164 "too many i2c bytes[w-%d][r-%d], max 60.", 165 msg[0].len, msg[1].len); 166 ret = -EOPNOTSUPP; 167 goto i2c_error; 168 } 169 /* write then read */ 170 obuf[0] = 0x09; 171 obuf[1] = msg[0].len; 172 obuf[2] = msg[1].len; 173 obuf[3] = msg[0].addr; 174 memcpy(&obuf[4], msg[0].buf, msg[0].len); 175 ret = dvbsky_usb_generic_rw(d, obuf, 176 msg[0].len + 4, ibuf, msg[1].len + 1); 177 if (ret) 178 dev_err(&d->udev->dev, "failed=%d\n", ret); 179 180 if (!ret) 181 memcpy(msg[1].buf, &ibuf[1], msg[1].len); 182 } 183i2c_error: 184 mutex_unlock(&d->i2c_mutex); 185 return (ret) ? ret : num; 186} 187 188static u32 dvbsky_i2c_func(struct i2c_adapter *adapter) 189{ 190 return I2C_FUNC_I2C; 191} 192 193static struct i2c_algorithm dvbsky_i2c_algo = { 194 .master_xfer = dvbsky_i2c_xfer, 195 .functionality = dvbsky_i2c_func, 196}; 197 198#if IS_ENABLED(CONFIG_RC_CORE) 199static int dvbsky_rc_query(struct dvb_usb_device *d) 200{ 201 u32 code = 0xffff, scancode; 202 u8 rc5_command, rc5_system; 203 u8 obuf[2], ibuf[2], toggle; 204 int ret; 205 206 obuf[0] = 0x10; 207 ret = dvbsky_usb_generic_rw(d, obuf, 1, ibuf, 2); 208 if (ret) 209 dev_err(&d->udev->dev, "failed=%d\n", ret); 210 if (ret == 0) 211 code = (ibuf[0] << 8) | ibuf[1]; 212 if (code != 0xffff) { 213 dev_dbg(&d->udev->dev, "rc code: %x\n", code); 214 rc5_command = code & 0x3F; 215 rc5_system = (code & 0x7C0) >> 6; 216 toggle = (code & 0x800) ? 1 : 0; 217 scancode = rc5_system << 8 | rc5_command; 218 rc_keydown(d->rc_dev, RC_TYPE_RC5, scancode, toggle); 219 } 220 return 0; 221} 222 223static int dvbsky_get_rc_config(struct dvb_usb_device *d, struct dvb_usb_rc *rc) 224{ 225 if (dvb_usb_dvbsky_disable_rc) { 226 rc->map_name = NULL; 227 return 0; 228 } 229 230 rc->allowed_protos = RC_BIT_RC5; 231 rc->query = dvbsky_rc_query; 232 rc->interval = 300; 233 return 0; 234} 235#else 236 #define dvbsky_get_rc_config NULL 237#endif 238 239static int dvbsky_usb_set_voltage(struct dvb_frontend *fe, 240 fe_sec_voltage_t voltage) 241{ 242 struct dvb_usb_device *d = fe_to_d(fe); 243 struct dvbsky_state *state = d_to_priv(d); 244 u8 value; 245 246 if (voltage == SEC_VOLTAGE_OFF) 247 value = 0; 248 else 249 value = 1; 250 dvbsky_gpio_ctrl(d, 0x80, value); 251 252 return state->fe_set_voltage(fe, voltage); 253} 254 255static int dvbsky_read_mac_addr(struct dvb_usb_adapter *adap, u8 mac[6]) 256{ 257 struct dvb_usb_device *d = adap_to_d(adap); 258 u8 obuf[] = { 0x1e, 0x00 }; 259 u8 ibuf[6] = { 0 }; 260 struct i2c_msg msg[] = { 261 { 262 .addr = 0x51, 263 .flags = 0, 264 .buf = obuf, 265 .len = 2, 266 }, { 267 .addr = 0x51, 268 .flags = I2C_M_RD, 269 .buf = ibuf, 270 .len = 6, 271 } 272 }; 273 274 if (i2c_transfer(&d->i2c_adap, msg, 2) == 2) 275 memcpy(mac, ibuf, 6); 276 277 return 0; 278} 279 280static int dvbsky_usb_read_status(struct dvb_frontend *fe, fe_status_t *status) 281{ 282 struct dvb_usb_device *d = fe_to_d(fe); 283 struct dvbsky_state *state = d_to_priv(d); 284 int ret; 285 286 ret = state->fe_read_status(fe, status); 287 288 /* it need resync slave fifo when signal change from unlock to lock.*/ 289 if ((*status & FE_HAS_LOCK) && (!state->last_lock)) 290 dvbsky_stream_ctrl(d, 1); 291 292 state->last_lock = (*status & FE_HAS_LOCK) ? 1 : 0; 293 return ret; 294} 295 296static const struct m88ds3103_config dvbsky_s960_m88ds3103_config = { 297 .i2c_addr = 0x68, 298 .clock = 27000000, 299 .i2c_wr_max = 33, 300 .clock_out = 0, 301 .ts_mode = M88DS3103_TS_CI, 302 .ts_clk = 16000, 303 .ts_clk_pol = 0, 304 .agc = 0x99, 305 .lnb_hv_pol = 1, 306 .lnb_en_pol = 1, 307}; 308 309static int dvbsky_s960_attach(struct dvb_usb_adapter *adap) 310{ 311 struct dvbsky_state *state = adap_to_priv(adap); 312 struct dvb_usb_device *d = adap_to_d(adap); 313 int ret = 0; 314 /* demod I2C adapter */ 315 struct i2c_adapter *i2c_adapter; 316 struct i2c_client *client; 317 struct i2c_board_info info; 318 struct ts2020_config ts2020_config = {}; 319 memset(&info, 0, sizeof(struct i2c_board_info)); 320 321 /* attach demod */ 322 adap->fe[0] = dvb_attach(m88ds3103_attach, 323 &dvbsky_s960_m88ds3103_config, 324 &d->i2c_adap, 325 &i2c_adapter); 326 if (!adap->fe[0]) { 327 dev_err(&d->udev->dev, "dvbsky_s960_attach fail.\n"); 328 ret = -ENODEV; 329 goto fail_attach; 330 } 331 332 /* attach tuner */ 333 ts2020_config.fe = adap->fe[0]; 334 strlcpy(info.type, "ts2020", I2C_NAME_SIZE); 335 info.addr = 0x60; 336 info.platform_data = &ts2020_config; 337 request_module("ts2020"); 338 client = i2c_new_device(i2c_adapter, &info); 339 if (client == NULL || client->dev.driver == NULL) { 340 dvb_frontend_detach(adap->fe[0]); 341 ret = -ENODEV; 342 goto fail_attach; 343 } 344 345 if (!try_module_get(client->dev.driver->owner)) { 346 i2c_unregister_device(client); 347 dvb_frontend_detach(adap->fe[0]); 348 ret = -ENODEV; 349 goto fail_attach; 350 } 351 352 /* delegate signal strength measurement to tuner */ 353 adap->fe[0]->ops.read_signal_strength = 354 adap->fe[0]->ops.tuner_ops.get_rf_strength; 355 356 /* hook fe: need to resync the slave fifo when signal locks. */ 357 state->fe_read_status = adap->fe[0]->ops.read_status; 358 adap->fe[0]->ops.read_status = dvbsky_usb_read_status; 359 360 /* hook fe: LNB off/on is control by Cypress usb chip. */ 361 state->fe_set_voltage = adap->fe[0]->ops.set_voltage; 362 adap->fe[0]->ops.set_voltage = dvbsky_usb_set_voltage; 363 364 state->i2c_client_tuner = client; 365 366fail_attach: 367 return ret; 368} 369 370static int dvbsky_usb_ci_set_voltage(struct dvb_frontend *fe, 371 fe_sec_voltage_t voltage) 372{ 373 struct dvb_usb_device *d = fe_to_d(fe); 374 struct dvbsky_state *state = d_to_priv(d); 375 u8 value; 376 377 if (voltage == SEC_VOLTAGE_OFF) 378 value = 0; 379 else 380 value = 1; 381 dvbsky_gpio_ctrl(d, 0x00, value); 382 383 return state->fe_set_voltage(fe, voltage); 384} 385 386static int dvbsky_ci_ctrl(void *priv, u8 read, int addr, 387 u8 data, int *mem) 388{ 389 struct dvb_usb_device *d = priv; 390 int ret = 0; 391 u8 command[4], respond[2], command_size, respond_size; 392 393 command[1] = (u8)((addr >> 8) & 0xff); /*high part of address*/ 394 command[2] = (u8)(addr & 0xff); /*low part of address*/ 395 if (read) { 396 command[0] = 0x71; 397 command_size = 3; 398 respond_size = 2; 399 } else { 400 command[0] = 0x70; 401 command[3] = data; 402 command_size = 4; 403 respond_size = 1; 404 } 405 ret = dvbsky_usb_generic_rw(d, command, command_size, 406 respond, respond_size); 407 if (ret) 408 goto err; 409 if (read) 410 *mem = respond[1]; 411 return ret; 412err: 413 dev_err(&d->udev->dev, "ci control failed=%d\n", ret); 414 return ret; 415} 416 417static const struct m88ds3103_config dvbsky_s960c_m88ds3103_config = { 418 .i2c_addr = 0x68, 419 .clock = 27000000, 420 .i2c_wr_max = 33, 421 .clock_out = 0, 422 .ts_mode = M88DS3103_TS_CI, 423 .ts_clk = 10000, 424 .ts_clk_pol = 1, 425 .agc = 0x99, 426 .lnb_hv_pol = 0, 427 .lnb_en_pol = 1, 428}; 429 430static int dvbsky_s960c_attach(struct dvb_usb_adapter *adap) 431{ 432 struct dvbsky_state *state = adap_to_priv(adap); 433 struct dvb_usb_device *d = adap_to_d(adap); 434 int ret = 0; 435 /* demod I2C adapter */ 436 struct i2c_adapter *i2c_adapter; 437 struct i2c_client *client_tuner, *client_ci; 438 struct i2c_board_info info; 439 struct sp2_config sp2_config; 440 struct ts2020_config ts2020_config = {}; 441 memset(&info, 0, sizeof(struct i2c_board_info)); 442 443 /* attach demod */ 444 adap->fe[0] = dvb_attach(m88ds3103_attach, 445 &dvbsky_s960c_m88ds3103_config, 446 &d->i2c_adap, 447 &i2c_adapter); 448 if (!adap->fe[0]) { 449 dev_err(&d->udev->dev, "dvbsky_s960ci_attach fail.\n"); 450 ret = -ENODEV; 451 goto fail_attach; 452 } 453 454 /* attach tuner */ 455 ts2020_config.fe = adap->fe[0]; 456 strlcpy(info.type, "ts2020", I2C_NAME_SIZE); 457 info.addr = 0x60; 458 info.platform_data = &ts2020_config; 459 request_module("ts2020"); 460 client_tuner = i2c_new_device(i2c_adapter, &info); 461 if (client_tuner == NULL || client_tuner->dev.driver == NULL) { 462 ret = -ENODEV; 463 goto fail_tuner_device; 464 } 465 466 if (!try_module_get(client_tuner->dev.driver->owner)) { 467 ret = -ENODEV; 468 goto fail_tuner_module; 469 } 470 471 /* attach ci controller */ 472 memset(&sp2_config, 0, sizeof(sp2_config)); 473 sp2_config.dvb_adap = &adap->dvb_adap; 474 sp2_config.priv = d; 475 sp2_config.ci_control = dvbsky_ci_ctrl; 476 memset(&info, 0, sizeof(struct i2c_board_info)); 477 strlcpy(info.type, "sp2", I2C_NAME_SIZE); 478 info.addr = 0x40; 479 info.platform_data = &sp2_config; 480 request_module("sp2"); 481 client_ci = i2c_new_device(&d->i2c_adap, &info); 482 if (client_ci == NULL || client_ci->dev.driver == NULL) { 483 ret = -ENODEV; 484 goto fail_ci_device; 485 } 486 487 if (!try_module_get(client_ci->dev.driver->owner)) { 488 ret = -ENODEV; 489 goto fail_ci_module; 490 } 491 492 /* delegate signal strength measurement to tuner */ 493 adap->fe[0]->ops.read_signal_strength = 494 adap->fe[0]->ops.tuner_ops.get_rf_strength; 495 496 /* hook fe: need to resync the slave fifo when signal locks. */ 497 state->fe_read_status = adap->fe[0]->ops.read_status; 498 adap->fe[0]->ops.read_status = dvbsky_usb_read_status; 499 500 /* hook fe: LNB off/on is control by Cypress usb chip. */ 501 state->fe_set_voltage = adap->fe[0]->ops.set_voltage; 502 adap->fe[0]->ops.set_voltage = dvbsky_usb_ci_set_voltage; 503 504 state->i2c_client_tuner = client_tuner; 505 state->i2c_client_ci = client_ci; 506 return ret; 507fail_ci_module: 508 i2c_unregister_device(client_ci); 509fail_ci_device: 510 module_put(client_tuner->dev.driver->owner); 511fail_tuner_module: 512 i2c_unregister_device(client_tuner); 513fail_tuner_device: 514 dvb_frontend_detach(adap->fe[0]); 515fail_attach: 516 return ret; 517} 518 519static int dvbsky_t680c_attach(struct dvb_usb_adapter *adap) 520{ 521 struct dvbsky_state *state = adap_to_priv(adap); 522 struct dvb_usb_device *d = adap_to_d(adap); 523 int ret = 0; 524 struct i2c_adapter *i2c_adapter; 525 struct i2c_client *client_demod, *client_tuner, *client_ci; 526 struct i2c_board_info info; 527 struct si2168_config si2168_config; 528 struct si2157_config si2157_config; 529 struct sp2_config sp2_config; 530 531 /* attach demod */ 532 memset(&si2168_config, 0, sizeof(si2168_config)); 533 si2168_config.i2c_adapter = &i2c_adapter; 534 si2168_config.fe = &adap->fe[0]; 535 si2168_config.ts_mode = SI2168_TS_PARALLEL; 536 memset(&info, 0, sizeof(struct i2c_board_info)); 537 strlcpy(info.type, "si2168", I2C_NAME_SIZE); 538 info.addr = 0x64; 539 info.platform_data = &si2168_config; 540 541 request_module(info.type); 542 client_demod = i2c_new_device(&d->i2c_adap, &info); 543 if (client_demod == NULL || 544 client_demod->dev.driver == NULL) 545 goto fail_demod_device; 546 if (!try_module_get(client_demod->dev.driver->owner)) 547 goto fail_demod_module; 548 549 /* attach tuner */ 550 memset(&si2157_config, 0, sizeof(si2157_config)); 551 si2157_config.fe = adap->fe[0]; 552 memset(&info, 0, sizeof(struct i2c_board_info)); 553 strlcpy(info.type, "si2157", I2C_NAME_SIZE); 554 info.addr = 0x60; 555 info.platform_data = &si2157_config; 556 557 request_module(info.type); 558 client_tuner = i2c_new_device(i2c_adapter, &info); 559 if (client_tuner == NULL || 560 client_tuner->dev.driver == NULL) 561 goto fail_tuner_device; 562 if (!try_module_get(client_tuner->dev.driver->owner)) 563 goto fail_tuner_module; 564 565 /* attach ci controller */ 566 memset(&sp2_config, 0, sizeof(sp2_config)); 567 sp2_config.dvb_adap = &adap->dvb_adap; 568 sp2_config.priv = d; 569 sp2_config.ci_control = dvbsky_ci_ctrl; 570 memset(&info, 0, sizeof(struct i2c_board_info)); 571 strlcpy(info.type, "sp2", I2C_NAME_SIZE); 572 info.addr = 0x40; 573 info.platform_data = &sp2_config; 574 575 request_module(info.type); 576 client_ci = i2c_new_device(&d->i2c_adap, &info); 577 578 if (client_ci == NULL || client_ci->dev.driver == NULL) 579 goto fail_ci_device; 580 581 if (!try_module_get(client_ci->dev.driver->owner)) 582 goto fail_ci_module; 583 584 state->i2c_client_demod = client_demod; 585 state->i2c_client_tuner = client_tuner; 586 state->i2c_client_ci = client_ci; 587 return ret; 588fail_ci_module: 589 i2c_unregister_device(client_ci); 590fail_ci_device: 591 module_put(client_tuner->dev.driver->owner); 592fail_tuner_module: 593 i2c_unregister_device(client_tuner); 594fail_tuner_device: 595 module_put(client_demod->dev.driver->owner); 596fail_demod_module: 597 i2c_unregister_device(client_demod); 598fail_demod_device: 599 ret = -ENODEV; 600 return ret; 601} 602 603static int dvbsky_t330_attach(struct dvb_usb_adapter *adap) 604{ 605 struct dvbsky_state *state = adap_to_priv(adap); 606 struct dvb_usb_device *d = adap_to_d(adap); 607 int ret = 0; 608 struct i2c_adapter *i2c_adapter; 609 struct i2c_client *client_demod, *client_tuner; 610 struct i2c_board_info info; 611 struct si2168_config si2168_config; 612 struct si2157_config si2157_config; 613 614 /* attach demod */ 615 memset(&si2168_config, 0, sizeof(si2168_config)); 616 si2168_config.i2c_adapter = &i2c_adapter; 617 si2168_config.fe = &adap->fe[0]; 618 si2168_config.ts_mode = SI2168_TS_PARALLEL | 0x40; 619 memset(&info, 0, sizeof(struct i2c_board_info)); 620 strlcpy(info.type, "si2168", I2C_NAME_SIZE); 621 info.addr = 0x64; 622 info.platform_data = &si2168_config; 623 624 request_module(info.type); 625 client_demod = i2c_new_device(&d->i2c_adap, &info); 626 if (client_demod == NULL || 627 client_demod->dev.driver == NULL) 628 goto fail_demod_device; 629 if (!try_module_get(client_demod->dev.driver->owner)) 630 goto fail_demod_module; 631 632 /* attach tuner */ 633 memset(&si2157_config, 0, sizeof(si2157_config)); 634 si2157_config.fe = adap->fe[0]; 635 memset(&info, 0, sizeof(struct i2c_board_info)); 636 strlcpy(info.type, "si2157", I2C_NAME_SIZE); 637 info.addr = 0x60; 638 info.platform_data = &si2157_config; 639 640 request_module(info.type); 641 client_tuner = i2c_new_device(i2c_adapter, &info); 642 if (client_tuner == NULL || 643 client_tuner->dev.driver == NULL) 644 goto fail_tuner_device; 645 if (!try_module_get(client_tuner->dev.driver->owner)) 646 goto fail_tuner_module; 647 648 state->i2c_client_demod = client_demod; 649 state->i2c_client_tuner = client_tuner; 650 return ret; 651fail_tuner_module: 652 i2c_unregister_device(client_tuner); 653fail_tuner_device: 654 module_put(client_demod->dev.driver->owner); 655fail_demod_module: 656 i2c_unregister_device(client_demod); 657fail_demod_device: 658 ret = -ENODEV; 659 return ret; 660} 661 662static int dvbsky_identify_state(struct dvb_usb_device *d, const char **name) 663{ 664 dvbsky_gpio_ctrl(d, 0x04, 1); 665 msleep(20); 666 dvbsky_gpio_ctrl(d, 0x83, 0); 667 dvbsky_gpio_ctrl(d, 0xc0, 1); 668 msleep(100); 669 dvbsky_gpio_ctrl(d, 0x83, 1); 670 dvbsky_gpio_ctrl(d, 0xc0, 0); 671 msleep(50); 672 673 return WARM; 674} 675 676static int dvbsky_init(struct dvb_usb_device *d) 677{ 678 struct dvbsky_state *state = d_to_priv(d); 679 680 /* use default interface */ 681 /* 682 ret = usb_set_interface(d->udev, 0, 0); 683 if (ret) 684 return ret; 685 */ 686 mutex_init(&state->stream_mutex); 687 688 state->last_lock = 0; 689 690 return 0; 691} 692 693static void dvbsky_exit(struct dvb_usb_device *d) 694{ 695 struct dvbsky_state *state = d_to_priv(d); 696 struct i2c_client *client; 697 698 client = state->i2c_client_tuner; 699 /* remove I2C tuner */ 700 if (client) { 701 module_put(client->dev.driver->owner); 702 i2c_unregister_device(client); 703 } 704 client = state->i2c_client_demod; 705 /* remove I2C demod */ 706 if (client) { 707 module_put(client->dev.driver->owner); 708 i2c_unregister_device(client); 709 } 710 client = state->i2c_client_ci; 711 /* remove I2C ci */ 712 if (client) { 713 module_put(client->dev.driver->owner); 714 i2c_unregister_device(client); 715 } 716} 717 718/* DVB USB Driver stuff */ 719static struct dvb_usb_device_properties dvbsky_s960_props = { 720 .driver_name = KBUILD_MODNAME, 721 .owner = THIS_MODULE, 722 .adapter_nr = adapter_nr, 723 .size_of_priv = sizeof(struct dvbsky_state), 724 725 .generic_bulk_ctrl_endpoint = 0x01, 726 .generic_bulk_ctrl_endpoint_response = 0x81, 727 .generic_bulk_ctrl_delay = DVBSKY_MSG_DELAY, 728 729 .i2c_algo = &dvbsky_i2c_algo, 730 .frontend_attach = dvbsky_s960_attach, 731 .init = dvbsky_init, 732 .get_rc_config = dvbsky_get_rc_config, 733 .streaming_ctrl = dvbsky_streaming_ctrl, 734 .identify_state = dvbsky_identify_state, 735 .exit = dvbsky_exit, 736 .read_mac_address = dvbsky_read_mac_addr, 737 738 .num_adapters = 1, 739 .adapter = { 740 { 741 .stream = DVB_USB_STREAM_BULK(0x82, 8, 4096), 742 } 743 } 744}; 745 746static struct dvb_usb_device_properties dvbsky_s960c_props = { 747 .driver_name = KBUILD_MODNAME, 748 .owner = THIS_MODULE, 749 .adapter_nr = adapter_nr, 750 .size_of_priv = sizeof(struct dvbsky_state), 751 752 .generic_bulk_ctrl_endpoint = 0x01, 753 .generic_bulk_ctrl_endpoint_response = 0x81, 754 .generic_bulk_ctrl_delay = DVBSKY_MSG_DELAY, 755 756 .i2c_algo = &dvbsky_i2c_algo, 757 .frontend_attach = dvbsky_s960c_attach, 758 .init = dvbsky_init, 759 .get_rc_config = dvbsky_get_rc_config, 760 .streaming_ctrl = dvbsky_streaming_ctrl, 761 .identify_state = dvbsky_identify_state, 762 .exit = dvbsky_exit, 763 .read_mac_address = dvbsky_read_mac_addr, 764 765 .num_adapters = 1, 766 .adapter = { 767 { 768 .stream = DVB_USB_STREAM_BULK(0x82, 8, 4096), 769 } 770 } 771}; 772 773static struct dvb_usb_device_properties dvbsky_t680c_props = { 774 .driver_name = KBUILD_MODNAME, 775 .owner = THIS_MODULE, 776 .adapter_nr = adapter_nr, 777 .size_of_priv = sizeof(struct dvbsky_state), 778 779 .generic_bulk_ctrl_endpoint = 0x01, 780 .generic_bulk_ctrl_endpoint_response = 0x81, 781 .generic_bulk_ctrl_delay = DVBSKY_MSG_DELAY, 782 783 .i2c_algo = &dvbsky_i2c_algo, 784 .frontend_attach = dvbsky_t680c_attach, 785 .init = dvbsky_init, 786 .get_rc_config = dvbsky_get_rc_config, 787 .streaming_ctrl = dvbsky_streaming_ctrl, 788 .identify_state = dvbsky_identify_state, 789 .exit = dvbsky_exit, 790 .read_mac_address = dvbsky_read_mac_addr, 791 792 .num_adapters = 1, 793 .adapter = { 794 { 795 .stream = DVB_USB_STREAM_BULK(0x82, 8, 4096), 796 } 797 } 798}; 799 800static struct dvb_usb_device_properties dvbsky_t330_props = { 801 .driver_name = KBUILD_MODNAME, 802 .owner = THIS_MODULE, 803 .adapter_nr = adapter_nr, 804 .size_of_priv = sizeof(struct dvbsky_state), 805 806 .generic_bulk_ctrl_endpoint = 0x01, 807 .generic_bulk_ctrl_endpoint_response = 0x81, 808 .generic_bulk_ctrl_delay = DVBSKY_MSG_DELAY, 809 810 .i2c_algo = &dvbsky_i2c_algo, 811 .frontend_attach = dvbsky_t330_attach, 812 .init = dvbsky_init, 813 .get_rc_config = dvbsky_get_rc_config, 814 .streaming_ctrl = dvbsky_streaming_ctrl, 815 .identify_state = dvbsky_identify_state, 816 .exit = dvbsky_exit, 817 .read_mac_address = dvbsky_read_mac_addr, 818 819 .num_adapters = 1, 820 .adapter = { 821 { 822 .stream = DVB_USB_STREAM_BULK(0x82, 8, 4096), 823 } 824 } 825}; 826 827static const struct usb_device_id dvbsky_id_table[] = { 828 { DVB_USB_DEVICE(0x0572, 0x6831, 829 &dvbsky_s960_props, "DVBSky S960/S860", RC_MAP_DVBSKY) }, 830 { DVB_USB_DEVICE(0x0572, 0x960c, 831 &dvbsky_s960c_props, "DVBSky S960CI", RC_MAP_DVBSKY) }, 832 { DVB_USB_DEVICE(0x0572, 0x680c, 833 &dvbsky_t680c_props, "DVBSky T680CI", RC_MAP_DVBSKY) }, 834 { DVB_USB_DEVICE(0x0572, 0x0320, 835 &dvbsky_t330_props, "DVBSky T330", RC_MAP_DVBSKY) }, 836 { DVB_USB_DEVICE(USB_VID_TECHNOTREND, 837 USB_PID_TECHNOTREND_TVSTICK_CT2_4400, 838 &dvbsky_t330_props, "TechnoTrend TVStick CT2-4400", 839 RC_MAP_TT_1500) }, 840 { DVB_USB_DEVICE(USB_VID_TECHNOTREND, 841 USB_PID_TECHNOTREND_CONNECT_CT2_4650_CI, 842 &dvbsky_t680c_props, "TechnoTrend TT-connect CT2-4650 CI", 843 RC_MAP_TT_1500) }, 844 { } 845}; 846MODULE_DEVICE_TABLE(usb, dvbsky_id_table); 847 848static struct usb_driver dvbsky_usb_driver = { 849 .name = KBUILD_MODNAME, 850 .id_table = dvbsky_id_table, 851 .probe = dvb_usbv2_probe, 852 .disconnect = dvb_usbv2_disconnect, 853 .suspend = dvb_usbv2_suspend, 854 .resume = dvb_usbv2_resume, 855 .reset_resume = dvb_usbv2_reset_resume, 856 .no_dynamic_id = 1, 857 .soft_unbind = 1, 858}; 859 860module_usb_driver(dvbsky_usb_driver); 861 862MODULE_AUTHOR("Max nibble <nibble.max@gmail.com>"); 863MODULE_DESCRIPTION("Driver for DVBSky USB"); 864MODULE_LICENSE("GPL"); 865