kernel/drivers/media/usb/dvb-usb-v2/dvbsky.c

   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
  31 static int dvb_usb_dvbsky_disable_rc;
  32 module_param_named(disable_rc, dvb_usb_dvbsky_disable_rc, int, 0644);
  33 MODULE_PARM_DESC(disable_rc, "Disable inbuilt IR receiver.");
  34
  35 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
  36
  37 struct 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
  53 static 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
  73 static 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
  90 static 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 */
  98 static 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 */
 113 static 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         }
 183 i2c_error:
 184         mutex_unlock(&d->i2c_mutex);
 185         return (ret) ? ret : num;
 186 }
 187
 188 static u32 dvbsky_i2c_func(struct i2c_adapter *adapter)
 189 {
 190         return I2C_FUNC_I2C;
 191 }
 192
 193 static 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)
 199 static 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
 223 static 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
 239 static 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
 255 static 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
 280 static 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
 296 static 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
 309 static 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
 366 fail_attach:
 367         return ret;
 368 }
 369
 370 static 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
 386 static 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;
 412 err:
 413         dev_err(&d->udev->dev, "ci control failed=%d\n", ret);
 414         return ret;
 415 }
 416
 417 static 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
 430 static 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;
 507 fail_ci_module:
 508         i2c_unregister_device(client_ci);
 509 fail_ci_device:
 510         module_put(client_tuner->dev.driver->owner);
 511 fail_tuner_module:
 512         i2c_unregister_device(client_tuner);
 513 fail_tuner_device:
 514         dvb_frontend_detach(adap->fe[0]);
 515 fail_attach:
 516         return ret;
 517 }
 518
 519 static 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;
 588 fail_ci_module:
 589         i2c_unregister_device(client_ci);
 590 fail_ci_device:
 591         module_put(client_tuner->dev.driver->owner);
 592 fail_tuner_module:
 593         i2c_unregister_device(client_tuner);
 594 fail_tuner_device:
 595         module_put(client_demod->dev.driver->owner);
 596 fail_demod_module:
 597         i2c_unregister_device(client_demod);
 598 fail_demod_device:
 599         ret = -ENODEV;
 600         return ret;
 601 }
 602
 603 static 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;
 651 fail_tuner_module:
 652         i2c_unregister_device(client_tuner);
 653 fail_tuner_device:
 654         module_put(client_demod->dev.driver->owner);
 655 fail_demod_module:
 656         i2c_unregister_device(client_demod);
 657 fail_demod_device:
 658         ret = -ENODEV;
 659         return ret;
 660 }
 661
 662 static 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
 676 static 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
 693 static 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 */
 719 static 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
 746 static 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
 773 static 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
 800 static 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
 827 static 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 };
 846 MODULE_DEVICE_TABLE(usb, dvbsky_id_table);
 847
 848 static 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
 860 module_usb_driver(dvbsky_usb_driver);
 861
 862 MODULE_AUTHOR("Max nibble <nibble.max@gmail.com>");
 863 MODULE_DESCRIPTION("Driver for DVBSky USB");
 864 MODULE_LICENSE("GPL");