drivers/media/usb/dvb-usb-v2/it913x.c

   1 /*
   2  * DVB USB compliant linux driver for ITE IT9135 and IT9137
   3  *
   4  * Copyright (C) 2011 Malcolm Priestley (tvboxspy@gmail.com)
   5  * IT9135 (C) ITE Tech Inc.
   6  * IT9137 (C) ITE Tech Inc.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License Version 2, as
  10  * published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  *
  21  *
  22  * see Documentation/dvb/README.dvb-usb for more information
  23  * see Documentation/dvb/it9137.txt for firmware information
  24  *
  25  */
  26 #define DVB_USB_LOG_PREFIX "it913x"
  27
  28 #include <linux/usb.h>
  29 #include <linux/usb/input.h>
  30 #include <media/rc-core.h>
  31
  32 #include "dvb_usb.h"
  33 #include "it913x-fe.h"
  34
  35 /* debug */
  36 static int dvb_usb_it913x_debug;
  37 #define it_debug(var, level, args...) \
  38         do { if ((var & level)) pr_debug(DVB_USB_LOG_PREFIX": " args); \
  39 } while (0)
  40 #define deb_info(level, args...) it_debug(dvb_usb_it913x_debug, level, args)
  41 #define info(args...) pr_info(DVB_USB_LOG_PREFIX": " args)
  42
  43 module_param_named(debug, dvb_usb_it913x_debug, int, 0644);
  44 MODULE_PARM_DESC(debug, "set debugging level (1=info (or-able)).");
  45
  46 static int dvb_usb_it913x_firmware;
  47 module_param_named(firmware, dvb_usb_it913x_firmware, int, 0644);
  48 MODULE_PARM_DESC(firmware, "set firmware 0=auto"\
  49         "1=IT9137 2=IT9135 V1 3=IT9135 V2");
  50 #define FW_IT9137 "dvb-usb-it9137-01.fw"
  51 #define FW_IT9135_V1 "dvb-usb-it9135-01.fw"
  52 #define FW_IT9135_V2 "dvb-usb-it9135-02.fw"
  53
  54 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
  55
  56 struct it913x_state {
  57         struct ite_config it913x_config;
  58         u8 pid_filter_onoff;
  59         bool proprietary_ir;
  60         int cmd_counter;
  61 };
  62
  63 static u16 check_sum(u8 *p, u8 len)
  64 {
  65         u16 sum = 0;
  66         u8 i = 1;
  67         while (i < len)
  68                 sum += (i++ & 1) ? (*p++) << 8 : *p++;
  69         return ~sum;
  70 }
  71
  72 static int it913x_io(struct dvb_usb_device *d, u8 mode, u8 pro,
  73                         u8 cmd, u32 reg, u8 addr, u8 *data, u8 len)
  74 {
  75         struct it913x_state *st = d->priv;
  76         int ret = 0, i, buf_size = 1;
  77         u8 *buff;
  78         u8 rlen;
  79         u16 chk_sum;
  80
  81         buff = kzalloc(256, GFP_KERNEL);
  82         if (!buff) {
  83                 info("USB Buffer Failed");
  84                 return -ENOMEM;
  85         }
  86
  87         buff[buf_size++] = pro;
  88         buff[buf_size++] = cmd;
  89         buff[buf_size++] = st->cmd_counter;
  90
  91         switch (mode) {
  92         case READ_LONG:
  93         case WRITE_LONG:
  94                 buff[buf_size++] = len;
  95                 buff[buf_size++] = 2;
  96                 buff[buf_size++] = (reg >> 24);
  97                 buff[buf_size++] = (reg >> 16) & 0xff;
  98                 buff[buf_size++] = (reg >> 8) & 0xff;
  99                 buff[buf_size++] = reg & 0xff;
 100         break;
 101         case READ_SHORT:
 102                 buff[buf_size++] = addr;
 103                 break;
 104         case WRITE_SHORT:
 105                 buff[buf_size++] = len;
 106                 buff[buf_size++] = addr;
 107                 buff[buf_size++] = (reg >> 8) & 0xff;
 108                 buff[buf_size++] = reg & 0xff;
 109         break;
 110         case READ_DATA:
 111         case WRITE_DATA:
 112                 break;
 113         case WRITE_CMD:
 114                 mode = 7;
 115                 break;
 116         default:
 117                 kfree(buff);
 118                 return -EINVAL;
 119         }
 120
 121         if (mode & 1) {
 122                 for (i = 0; i < len ; i++)
 123                         buff[buf_size++] = data[i];
 124         }
 125         chk_sum = check_sum(&buff[1], buf_size);
 126
 127         buff[buf_size++] = chk_sum >> 8;
 128         buff[0] = buf_size;
 129         buff[buf_size++] = (chk_sum & 0xff);
 130
 131         ret = dvb_usbv2_generic_rw(d, buff, buf_size, buff, (mode & 1) ?
 132                         5 : len + 5);
 133         if (ret < 0)
 134                 goto error;
 135
 136         rlen = (mode & 0x1) ? 0x1 : len;
 137
 138         if (mode & 1)
 139                 ret = buff[2];
 140         else
 141                 memcpy(data, &buff[3], rlen);
 142
 143         st->cmd_counter++;
 144
 145 error:  kfree(buff);
 146
 147         return ret;
 148 }
 149
 150 static int it913x_wr_reg(struct dvb_usb_device *d, u8 pro, u32 reg , u8 data)
 151 {
 152         int ret;
 153         u8 b[1];
 154         b[0] = data;
 155         ret = it913x_io(d, WRITE_LONG, pro,
 156                         CMD_DEMOD_WRITE, reg, 0, b, sizeof(b));
 157
 158         return ret;
 159 }
 160
 161 static int it913x_read_reg(struct dvb_usb_device *d, u32 reg)
 162 {
 163         int ret;
 164         u8 data[1];
 165
 166         ret = it913x_io(d, READ_LONG, DEV_0,
 167                         CMD_DEMOD_READ, reg, 0, &data[0], sizeof(data));
 168
 169         return (ret < 0) ? ret : data[0];
 170 }
 171
 172 static int it913x_query(struct dvb_usb_device *d, u8 pro)
 173 {
 174         struct it913x_state *st = d->priv;
 175         int ret, i;
 176         u8 data[4];
 177         u8 ver;
 178
 179         for (i = 0; i < 5; i++) {
 180                 ret = it913x_io(d, READ_LONG, pro, CMD_DEMOD_READ,
 181                         0x1222, 0, &data[0], 3);
 182                 ver = data[0];
 183                 if (ver > 0 && ver < 3)
 184                         break;
 185                 msleep(100);
 186         }
 187
 188         if (ver < 1 || ver > 2) {
 189                 info("Failed to identify chip version applying 1");
 190                 st->it913x_config.chip_ver = 0x1;
 191                 st->it913x_config.chip_type = 0x9135;
 192                 return 0;
 193         }
 194
 195         st->it913x_config.chip_ver = ver;
 196         st->it913x_config.chip_type = (u16)(data[2] << 8) + data[1];
 197
 198         info("Chip Version=%02x Chip Type=%04x", st->it913x_config.chip_ver,
 199                 st->it913x_config.chip_type);
 200
 201         ret = it913x_io(d, READ_SHORT, pro,
 202                         CMD_QUERYINFO, 0, 0x1, &data[0], 4);
 203
 204         st->it913x_config.firmware = (data[0] << 24) | (data[1] << 16) |
 205                         (data[2] << 8) | data[3];
 206
 207         return ret;
 208 }
 209
 210 static int it913x_pid_filter_ctrl(struct dvb_usb_adapter *adap, int onoff)
 211 {
 212         struct dvb_usb_device *d = adap_to_d(adap);
 213         struct it913x_state *st = adap_to_priv(adap);
 214         int ret;
 215         u8 pro = (adap->id == 0) ? DEV_0_DMOD : DEV_1_DMOD;
 216
 217         mutex_lock(&d->i2c_mutex);
 218
 219         deb_info(1, "PID_C  (%02x)", onoff);
 220
 221         ret = it913x_wr_reg(d, pro, PID_EN, st->pid_filter_onoff);
 222
 223         mutex_unlock(&d->i2c_mutex);
 224         return ret;
 225 }
 226
 227 static int it913x_pid_filter(struct dvb_usb_adapter *adap,
 228                 int index, u16 pid, int onoff)
 229 {
 230         struct dvb_usb_device *d = adap_to_d(adap);
 231         struct it913x_state *st = adap_to_priv(adap);
 232         int ret;
 233         u8 pro = (adap->id == 0) ? DEV_0_DMOD : DEV_1_DMOD;
 234
 235         mutex_lock(&d->i2c_mutex);
 236
 237         deb_info(1, "PID_F  (%02x)", onoff);
 238
 239         ret = it913x_wr_reg(d, pro, PID_LSB, (u8)(pid & 0xff));
 240
 241         ret |= it913x_wr_reg(d, pro, PID_MSB, (u8)(pid >> 8));
 242
 243         ret |= it913x_wr_reg(d, pro, PID_INX_EN, (u8)onoff);
 244
 245         ret |= it913x_wr_reg(d, pro, PID_INX, (u8)(index & 0x1f));
 246
 247         if (d->udev->speed == USB_SPEED_HIGH && pid == 0x2000) {
 248                         ret |= it913x_wr_reg(d , pro, PID_EN, !onoff);
 249                         st->pid_filter_onoff = !onoff;
 250         } else
 251                 st->pid_filter_onoff =
 252                         adap->pid_filtering;
 253
 254         mutex_unlock(&d->i2c_mutex);
 255         return 0;
 256 }
 257
 258
 259 static int it913x_return_status(struct dvb_usb_device *d)
 260 {
 261         struct it913x_state *st = d->priv;
 262         int ret = it913x_query(d, DEV_0);
 263         if (st->it913x_config.firmware > 0)
 264                 info("Firmware Version %d", st->it913x_config.firmware);
 265
 266         return ret;
 267 }
 268
 269 static int it913x_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
 270                                  int num)
 271 {
 272         struct dvb_usb_device *d = i2c_get_adapdata(adap);
 273         static u8 data[256];
 274         int ret;
 275         u32 reg;
 276         u8 pro;
 277
 278         mutex_lock(&d->i2c_mutex);
 279
 280         deb_info(2, "num of messages %d address %02x", num, msg[0].addr);
 281
 282         pro = (msg[0].addr & 0x2) ?  DEV_0_DMOD : 0x0;
 283         pro |= (msg[0].addr & 0x20) ? DEV_1 : DEV_0;
 284         memcpy(data, msg[0].buf, msg[0].len);
 285         reg = (data[0] << 24) + (data[1] << 16) +
 286                         (data[2] << 8) + data[3];
 287         if (num == 2) {
 288                 ret = it913x_io(d, READ_LONG, pro,
 289                         CMD_DEMOD_READ, reg, 0, data, msg[1].len);
 290                 memcpy(msg[1].buf, data, msg[1].len);
 291         } else
 292                 ret = it913x_io(d, WRITE_LONG, pro, CMD_DEMOD_WRITE,
 293                         reg, 0, &data[4], msg[0].len - 4);
 294
 295         mutex_unlock(&d->i2c_mutex);
 296
 297         return ret;
 298 }
 299
 300 static u32 it913x_i2c_func(struct i2c_adapter *adapter)
 301 {
 302         return I2C_FUNC_I2C;
 303 }
 304
 305 static struct i2c_algorithm it913x_i2c_algo = {
 306         .master_xfer   = it913x_i2c_xfer,
 307         .functionality = it913x_i2c_func,
 308 };
 309
 310 /* Callbacks for DVB USB */
 311 #define IT913X_POLL 250
 312 static int it913x_rc_query(struct dvb_usb_device *d)
 313 {
 314         u8 ibuf[4];
 315         int ret;
 316         u32 key;
 317         /* Avoid conflict with frontends*/
 318         mutex_lock(&d->i2c_mutex);
 319
 320         ret = it913x_io(d, READ_LONG, PRO_LINK, CMD_IR_GET,
 321                 0, 0, &ibuf[0], sizeof(ibuf));
 322
 323         if ((ibuf[2] + ibuf[3]) == 0xff) {
 324                 key = ibuf[2];
 325                 key += ibuf[0] << 16;
 326                 key += ibuf[1] << 8;
 327                 deb_info(1, "NEC Extended Key =%08x", key);
 328                 if (d->rc_dev != NULL)
 329                         rc_keydown(d->rc_dev, key, 0);
 330         }
 331
 332         mutex_unlock(&d->i2c_mutex);
 333
 334         return ret;
 335 }
 336
 337 /* Firmware sets raw */
 338 static const char fw_it9135_v1[] = FW_IT9135_V1;
 339 static const char fw_it9135_v2[] = FW_IT9135_V2;
 340 static const char fw_it9137[] = FW_IT9137;
 341
 342 static void ite_get_firmware_name(struct dvb_usb_device *d,
 343         const char **name)
 344 {
 345         struct it913x_state *st = d->priv;
 346         int sw;
 347         /* auto switch */
 348         if (le16_to_cpu(d->udev->descriptor.idVendor) == USB_VID_KWORLD_2)
 349                 sw = IT9137_FW;
 350         else if (st->it913x_config.chip_ver == 1)
 351                 sw = IT9135_V1_FW;
 352         else
 353                 sw = IT9135_V2_FW;
 354
 355         /* force switch */
 356         if (dvb_usb_it913x_firmware != IT9135_AUTO)
 357                 sw = dvb_usb_it913x_firmware;
 358
 359         switch (sw) {
 360         case IT9135_V1_FW:
 361                 st->it913x_config.firmware_ver = 1;
 362                 st->it913x_config.adc_x2 = 1;
 363                 st->it913x_config.read_slevel = false;
 364                 *name = fw_it9135_v1;
 365                 break;
 366         case IT9135_V2_FW:
 367                 st->it913x_config.firmware_ver = 1;
 368                 st->it913x_config.adc_x2 = 1;
 369                 st->it913x_config.read_slevel = false;
 370                 *name = fw_it9135_v2;
 371                 switch (st->it913x_config.tuner_id_0) {
 372                 case IT9135_61:
 373                 case IT9135_62:
 374                         break;
 375                 default:
 376                         info("Unknown tuner ID applying default 0x60");
 377                 case IT9135_60:
 378                         st->it913x_config.tuner_id_0 = IT9135_60;
 379                 }
 380                 break;
 381         case IT9137_FW:
 382         default:
 383                 st->it913x_config.firmware_ver = 0;
 384                 st->it913x_config.adc_x2 = 0;
 385                 st->it913x_config.read_slevel = true;
 386                 *name = fw_it9137;
 387         }
 388
 389         return;
 390 }
 391
 392 #define TS_MPEG_PKT_SIZE        188
 393 #define EP_LOW                  21
 394 #define TS_BUFFER_SIZE_PID      (EP_LOW*TS_MPEG_PKT_SIZE)
 395 #define EP_HIGH                 348
 396 #define TS_BUFFER_SIZE_MAX      (EP_HIGH*TS_MPEG_PKT_SIZE)
 397
 398 static int it913x_get_stream_config(struct dvb_frontend *fe, u8 *ts_type,
 399                 struct usb_data_stream_properties *stream)
 400 {
 401         struct dvb_usb_adapter *adap = fe_to_adap(fe);
 402         if (adap->pid_filtering)
 403                 stream->u.bulk.buffersize = TS_BUFFER_SIZE_PID;
 404         else
 405                 stream->u.bulk.buffersize = TS_BUFFER_SIZE_MAX;
 406
 407         return 0;
 408 }
 409
 410 static int it913x_select_config(struct dvb_usb_device *d)
 411 {
 412         struct it913x_state *st = d->priv;
 413         int ret, reg;
 414
 415         ret = it913x_return_status(d);
 416         if (ret < 0)
 417                 return ret;
 418
 419         if (st->it913x_config.chip_ver == 0x02
 420                         && st->it913x_config.chip_type == 0x9135)
 421                 reg = it913x_read_reg(d, 0x461d);
 422         else
 423                 reg = it913x_read_reg(d, 0x461b);
 424
 425         if (reg < 0)
 426                 return reg;
 427
 428         if (reg == 0) {
 429                 st->it913x_config.dual_mode = 0;
 430                 st->it913x_config.tuner_id_0 = IT9135_38;
 431                 st->proprietary_ir = true;
 432         } else {
 433                 /* TS mode */
 434                 reg =  it913x_read_reg(d, 0x49c5);
 435                 if (reg < 0)
 436                         return reg;
 437                 st->it913x_config.dual_mode = reg;
 438
 439                 /* IR mode type */
 440                 reg = it913x_read_reg(d, 0x49ac);
 441                 if (reg < 0)
 442                         return reg;
 443                 if (reg == 5) {
 444                         info("Remote propriety (raw) mode");
 445                         st->proprietary_ir = true;
 446                 } else if (reg == 1) {
 447                         info("Remote HID mode NOT SUPPORTED");
 448                         st->proprietary_ir = false;
 449                 }
 450
 451                 /* Tuner_id */
 452                 reg = it913x_read_reg(d, 0x49d0);
 453                 if (reg < 0)
 454                         return reg;
 455                 st->it913x_config.tuner_id_0 = reg;
 456         }
 457
 458         info("Dual mode=%x Tuner Type=%x", st->it913x_config.dual_mode,
 459                 st->it913x_config.tuner_id_0);
 460
 461         return ret;
 462 }
 463
 464 static int it913x_streaming_ctrl(struct dvb_frontend *fe, int onoff)
 465 {
 466         struct dvb_usb_adapter *adap = fe_to_adap(fe);
 467         struct dvb_usb_device *d = adap_to_d(adap);
 468         struct it913x_state *st = fe_to_priv(fe);
 469         int ret = 0;
 470         u8 pro = (adap->id == 0) ? DEV_0_DMOD : DEV_1_DMOD;
 471
 472         deb_info(1, "STM  (%02x)", onoff);
 473
 474         if (!onoff) {
 475                 mutex_lock(&d->i2c_mutex);
 476
 477                 ret = it913x_wr_reg(d, pro, PID_RST, 0x1);
 478
 479                 mutex_unlock(&d->i2c_mutex);
 480                 st->pid_filter_onoff =
 481                         adap->pid_filtering;
 482
 483         }
 484
 485         return ret;
 486 }
 487
 488 static int it913x_identify_state(struct dvb_usb_device *d, const char **name)
 489 {
 490         struct it913x_state *st = d->priv;
 491         int ret;
 492         u8 reg;
 493
 494         /* Read and select config */
 495         ret = it913x_select_config(d);
 496         if (ret < 0)
 497                 return ret;
 498
 499         ite_get_firmware_name(d, name);
 500
 501         if (st->it913x_config.firmware > 0)
 502                 return WARM;
 503
 504         if (st->it913x_config.dual_mode) {
 505                 st->it913x_config.tuner_id_1 = it913x_read_reg(d, 0x49e0);
 506                 ret = it913x_wr_reg(d, DEV_0, GPIOH1_EN, 0x1);
 507                 ret |= it913x_wr_reg(d, DEV_0, GPIOH1_ON, 0x1);
 508                 ret |= it913x_wr_reg(d, DEV_0, GPIOH1_O, 0x1);
 509                 msleep(50);
 510                 ret |= it913x_wr_reg(d, DEV_0, GPIOH1_O, 0x0);
 511                 msleep(50);
 512                 reg = it913x_read_reg(d, GPIOH1_O);
 513                 if (reg == 0) {
 514                         ret |= it913x_wr_reg(d, DEV_0,  GPIOH1_O, 0x1);
 515                         ret |= it913x_return_status(d);
 516                         if (ret != 0)
 517                                 ret = it913x_wr_reg(d, DEV_0,
 518                                         GPIOH1_O, 0x0);
 519                 }
 520         }
 521
 522         reg = it913x_read_reg(d, IO_MUX_POWER_CLK);
 523
 524         if (st->it913x_config.dual_mode) {
 525                 ret |= it913x_wr_reg(d, DEV_0, 0x4bfb, CHIP2_I2C_ADDR);
 526                 if (st->it913x_config.firmware_ver == 1)
 527                         ret |= it913x_wr_reg(d, DEV_0,  0xcfff, 0x1);
 528                 else
 529                         ret |= it913x_wr_reg(d, DEV_0,  CLK_O_EN, 0x1);
 530         } else {
 531                 ret |= it913x_wr_reg(d, DEV_0, 0x4bfb, 0x0);
 532                 if (st->it913x_config.firmware_ver == 1)
 533                         ret |= it913x_wr_reg(d, DEV_0,  0xcfff, 0x0);
 534                 else
 535                         ret |= it913x_wr_reg(d, DEV_0,  CLK_O_EN, 0x0);
 536         }
 537
 538         ret |= it913x_wr_reg(d, DEV_0,  I2C_CLK, I2C_CLK_100);
 539
 540         return (ret < 0) ? ret : COLD;
 541 }
 542
 543 static int it913x_download_firmware(struct dvb_usb_device *d,
 544                                         const struct firmware *fw)
 545 {
 546         struct it913x_state *st = d->priv;
 547         int ret = 0, i = 0, pos = 0;
 548         u8 packet_size, min_pkt;
 549         u8 *fw_data;
 550
 551         ret = it913x_wr_reg(d, DEV_0,  I2C_CLK, I2C_CLK_100);
 552
 553         info("FRM Starting Firmware Download");
 554
 555         /* Multi firmware loader */
 556         /* This uses scatter write firmware headers */
 557         /* The firmware must start with 03 XX 00 */
 558         /* and be the extact firmware length */
 559
 560         if (st->it913x_config.chip_ver == 2)
 561                 min_pkt = 0x11;
 562         else
 563                 min_pkt = 0x19;
 564
 565         while (i <= fw->size) {
 566                 if (((fw->data[i] == 0x3) && (fw->data[i + 2] == 0x0))
 567                         || (i == fw->size)) {
 568                         packet_size = i - pos;
 569                         if ((packet_size > min_pkt) || (i == fw->size)) {
 570                                 fw_data = (u8 *)(fw->data + pos);
 571                                 pos += packet_size;
 572                                 if (packet_size > 0) {
 573                                         ret = it913x_io(d, WRITE_DATA,
 574                                                 DEV_0, CMD_SCATTER_WRITE, 0,
 575                                                 0, fw_data, packet_size);
 576                                         if (ret < 0)
 577                                                 break;
 578                                 }
 579                                 udelay(1000);
 580                         }
 581                 }
 582                 i++;
 583         }
 584
 585         if (ret < 0)
 586                 info("FRM Firmware Download Failed (%d)" , ret);
 587         else
 588                 info("FRM Firmware Download Completed - Resetting Device");
 589
 590         msleep(30);
 591
 592         ret = it913x_io(d, WRITE_CMD, DEV_0, CMD_BOOT, 0, 0, NULL, 0);
 593         if (ret < 0)
 594                 info("FRM Device not responding to reboot");
 595
 596         ret = it913x_return_status(d);
 597         if (st->it913x_config.firmware == 0) {
 598                 info("FRM Failed to reboot device");
 599                 return -ENODEV;
 600         }
 601
 602         msleep(30);
 603
 604         ret = it913x_wr_reg(d, DEV_0,  I2C_CLK, I2C_CLK_400);
 605
 606         msleep(30);
 607
 608         /* Tuner function */
 609         if (st->it913x_config.dual_mode)
 610                 ret |= it913x_wr_reg(d, DEV_0_DMOD , 0xec4c, 0xa0);
 611         else
 612                 ret |= it913x_wr_reg(d, DEV_0_DMOD , 0xec4c, 0x68);
 613
 614         if ((st->it913x_config.chip_ver == 1) &&
 615                 (st->it913x_config.chip_type == 0x9135)) {
 616                 ret |= it913x_wr_reg(d, DEV_0,  PADODPU, 0x0);
 617                 ret |= it913x_wr_reg(d, DEV_0,  AGC_O_D, 0x0);
 618                 if (st->it913x_config.dual_mode) {
 619                         ret |= it913x_wr_reg(d, DEV_1,  PADODPU, 0x0);
 620                         ret |= it913x_wr_reg(d, DEV_1,  AGC_O_D, 0x0);
 621                 }
 622         }
 623
 624         return (ret < 0) ? -ENODEV : 0;
 625 }
 626
 627 static int it913x_name(struct dvb_usb_adapter *adap)
 628 {
 629         struct dvb_usb_device *d = adap_to_d(adap);
 630         const char *desc = d->name;
 631         char *fe_name[] = {"_1", "_2", "_3", "_4"};
 632         char *name = adap->fe[0]->ops.info.name;
 633
 634         strlcpy(name, desc, 128);
 635         strlcat(name, fe_name[adap->id], 128);
 636
 637         return 0;
 638 }
 639
 640 static int it913x_frontend_attach(struct dvb_usb_adapter *adap)
 641 {
 642         struct dvb_usb_device *d = adap_to_d(adap);
 643         struct it913x_state *st = d->priv;
 644         int ret = 0;
 645         u8 adap_addr = I2C_BASE_ADDR + (adap->id << 5);
 646         u16 ep_size = adap->stream.buf_size / 4;
 647         u8 pkt_size = 0x80;
 648
 649         if (d->udev->speed != USB_SPEED_HIGH)
 650                 pkt_size = 0x10;
 651
 652         st->it913x_config.adf = it913x_read_reg(d, IO_MUX_POWER_CLK);
 653
 654         adap->fe[0] = dvb_attach(it913x_fe_attach,
 655                 &d->i2c_adap, adap_addr, &st->it913x_config);
 656
 657         if (adap->id == 0 && adap->fe[0]) {
 658                 it913x_wr_reg(d, DEV_0_DMOD, MP2_SW_RST, 0x1);
 659                 it913x_wr_reg(d, DEV_0_DMOD, MP2IF2_SW_RST, 0x1);
 660                 it913x_wr_reg(d, DEV_0, EP0_TX_EN, 0x0f);
 661                 it913x_wr_reg(d, DEV_0, EP0_TX_NAK, 0x1b);
 662                 if (st->proprietary_ir == false) /* Enable endpoint 3 */
 663                         it913x_wr_reg(d, DEV_0, EP0_TX_EN, 0x3f);
 664                 else
 665                         it913x_wr_reg(d, DEV_0, EP0_TX_EN, 0x2f);
 666                 it913x_wr_reg(d, DEV_0, EP4_TX_LEN_LSB,
 667                                         ep_size & 0xff);
 668                 it913x_wr_reg(d, DEV_0, EP4_TX_LEN_MSB, ep_size >> 8);
 669                 ret = it913x_wr_reg(d, DEV_0, EP4_MAX_PKT, pkt_size);
 670         } else if (adap->id == 1 && adap->fe[0]) {
 671                 if (st->proprietary_ir == false)
 672                         it913x_wr_reg(d, DEV_0, EP0_TX_EN, 0x7f);
 673                 else
 674                         it913x_wr_reg(d, DEV_0, EP0_TX_EN, 0x6f);
 675                 it913x_wr_reg(d, DEV_0, EP5_TX_LEN_LSB,
 676                                         ep_size & 0xff);
 677                 it913x_wr_reg(d, DEV_0, EP5_TX_LEN_MSB, ep_size >> 8);
 678                 it913x_wr_reg(d, DEV_0, EP5_MAX_PKT, pkt_size);
 679                 it913x_wr_reg(d, DEV_0_DMOD, MP2IF2_EN, 0x1);
 680                 it913x_wr_reg(d, DEV_1_DMOD, MP2IF_SERIAL, 0x1);
 681                 it913x_wr_reg(d, DEV_1, TOP_HOSTB_SER_MODE, 0x1);
 682                 it913x_wr_reg(d, DEV_0_DMOD, TSIS_ENABLE, 0x1);
 683                 it913x_wr_reg(d, DEV_0_DMOD, MP2_SW_RST, 0x0);
 684                 it913x_wr_reg(d, DEV_0_DMOD, MP2IF2_SW_RST, 0x0);
 685                 it913x_wr_reg(d, DEV_0_DMOD, MP2IF2_HALF_PSB, 0x0);
 686                 it913x_wr_reg(d, DEV_0_DMOD, MP2IF_STOP_EN, 0x1);
 687                 it913x_wr_reg(d, DEV_1_DMOD, MPEG_FULL_SPEED, 0x0);
 688                 ret = it913x_wr_reg(d, DEV_1_DMOD, MP2IF_STOP_EN, 0x0);
 689         } else
 690                 return -ENODEV;
 691
 692         ret |= it913x_name(adap);
 693
 694         return ret;
 695 }
 696
 697 /* DVB USB Driver */
 698 static int it913x_get_rc_config(struct dvb_usb_device *d, struct dvb_usb_rc *rc)
 699 {
 700         struct it913x_state *st = d->priv;
 701
 702         if (st->proprietary_ir == false) {
 703                 rc->map_name = NULL;
 704                 return 0;
 705         }
 706
 707         rc->allowed_protos = RC_BIT_NEC;
 708         rc->query = it913x_rc_query;
 709         rc->interval = 250;
 710
 711         return 0;
 712 }
 713
 714 static int it913x_get_adapter_count(struct dvb_usb_device *d)
 715 {
 716         struct it913x_state *st = d->priv;
 717         if (st->it913x_config.dual_mode)
 718                 return 2;
 719         return 1;
 720 }
 721
 722 static struct dvb_usb_device_properties it913x_properties = {
 723         .driver_name = KBUILD_MODNAME,
 724         .owner = THIS_MODULE,
 725         .bInterfaceNumber = 0,
 726         .generic_bulk_ctrl_endpoint = 0x02,
 727         .generic_bulk_ctrl_endpoint_response = 0x81,
 728
 729         .adapter_nr = adapter_nr,
 730         .size_of_priv = sizeof(struct it913x_state),
 731
 732         .identify_state = it913x_identify_state,
 733         .i2c_algo = &it913x_i2c_algo,
 734
 735         .download_firmware = it913x_download_firmware,
 736
 737         .frontend_attach  = it913x_frontend_attach,
 738         .get_rc_config = it913x_get_rc_config,
 739         .get_stream_config = it913x_get_stream_config,
 740         .get_adapter_count = it913x_get_adapter_count,
 741         .streaming_ctrl   = it913x_streaming_ctrl,
 742
 743
 744         .adapter = {
 745                 {
 746                         .caps = DVB_USB_ADAP_HAS_PID_FILTER|
 747                                 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
 748                         .pid_filter_count = 32,
 749                         .pid_filter = it913x_pid_filter,
 750                         .pid_filter_ctrl  = it913x_pid_filter_ctrl,
 751                         .stream =
 752                         DVB_USB_STREAM_BULK(0x84, 10, TS_BUFFER_SIZE_MAX),
 753                 },
 754                 {
 755                         .caps = DVB_USB_ADAP_HAS_PID_FILTER|
 756                                 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
 757                         .pid_filter_count = 32,
 758                         .pid_filter = it913x_pid_filter,
 759                         .pid_filter_ctrl  = it913x_pid_filter_ctrl,
 760                         .stream =
 761                         DVB_USB_STREAM_BULK(0x85, 10, TS_BUFFER_SIZE_MAX),
 762                 }
 763         }
 764 };
 765
 766 static const struct usb_device_id it913x_id_table[] = {
 767         { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_UB499_2T_T09,
 768                 &it913x_properties, "Kworld UB499-2T T09(IT9137)",
 769                         RC_MAP_IT913X_V1) },
 770         { DVB_USB_DEVICE(USB_VID_ITETECH, USB_PID_ITETECH_IT9135,
 771                 &it913x_properties, "ITE 9135 Generic",
 772                         RC_MAP_IT913X_V1) },
 773         { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_SVEON_STV22_IT9137,
 774                 &it913x_properties, "Sveon STV22 Dual DVB-T HDTV(IT9137)",
 775                         RC_MAP_IT913X_V1) },
 776         { DVB_USB_DEVICE(USB_VID_ITETECH, USB_PID_ITETECH_IT9135_9005,
 777                 &it913x_properties, "ITE 9135(9005) Generic",
 778                         RC_MAP_IT913X_V2) },
 779         { DVB_USB_DEVICE(USB_VID_ITETECH, USB_PID_ITETECH_IT9135_9006,
 780                 &it913x_properties, "ITE 9135(9006) Generic",
 781                         RC_MAP_IT913X_V1) },
 782         {}              /* Terminating entry */
 783 };
 784
 785 MODULE_DEVICE_TABLE(usb, it913x_id_table);
 786
 787 static struct usb_driver it913x_driver = {
 788         .name           = KBUILD_MODNAME,
 789         .probe          = dvb_usbv2_probe,
 790         .disconnect     = dvb_usbv2_disconnect,
 791         .suspend        = dvb_usbv2_suspend,
 792         .resume         = dvb_usbv2_resume,
 793         .id_table       = it913x_id_table,
 794 };
 795
 796 module_usb_driver(it913x_driver);
 797
 798 MODULE_AUTHOR("Malcolm Priestley <tvboxspy@gmail.com>");
 799 MODULE_DESCRIPTION("it913x USB 2 Driver");
 800 MODULE_VERSION("1.32");
 801 MODULE_LICENSE("GPL");
 802 MODULE_FIRMWARE(FW_IT9135_V1);
 803 MODULE_FIRMWARE(FW_IT9135_V2);
 804 MODULE_FIRMWARE(FW_IT9137);
 805