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 #if defined(CONFIG_RC_CORE) || defined(CONFIG_RC_CORE_MODULE)
 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 static int it913x_get_rc_config(struct dvb_usb_device *d, struct dvb_usb_rc *rc)
 338 {
 339         struct it913x_state *st = d->priv;
 340
 341         if (st->proprietary_ir == false) {
 342                 rc->map_name = NULL;
 343                 return 0;
 344         }
 345
 346         rc->allowed_protos = RC_BIT_NEC;
 347         rc->query = it913x_rc_query;
 348         rc->interval = 250;
 349
 350         return 0;
 351 }
 352 #else
 353         #define it913x_get_rc_config NULL
 354 #endif
 355
 356 /* Firmware sets raw */
 357 static const char fw_it9135_v1[] = FW_IT9135_V1;
 358 static const char fw_it9135_v2[] = FW_IT9135_V2;
 359 static const char fw_it9137[] = FW_IT9137;
 360
 361 static void ite_get_firmware_name(struct dvb_usb_device *d,
 362         const char **name)
 363 {
 364         struct it913x_state *st = d->priv;
 365         int sw;
 366         /* auto switch */
 367         if (le16_to_cpu(d->udev->descriptor.idVendor) == USB_VID_KWORLD_2)
 368                 sw = IT9137_FW;
 369         else if (st->it913x_config.chip_ver == 1)
 370                 sw = IT9135_V1_FW;
 371         else
 372                 sw = IT9135_V2_FW;
 373
 374         /* force switch */
 375         if (dvb_usb_it913x_firmware != IT9135_AUTO)
 376                 sw = dvb_usb_it913x_firmware;
 377
 378         switch (sw) {
 379         case IT9135_V1_FW:
 380                 st->it913x_config.firmware_ver = 1;
 381                 st->it913x_config.adc_x2 = 1;
 382                 st->it913x_config.read_slevel = false;
 383                 *name = fw_it9135_v1;
 384                 break;
 385         case IT9135_V2_FW:
 386                 st->it913x_config.firmware_ver = 1;
 387                 st->it913x_config.adc_x2 = 1;
 388                 st->it913x_config.read_slevel = false;
 389                 *name = fw_it9135_v2;
 390                 switch (st->it913x_config.tuner_id_0) {
 391                 case IT9135_61:
 392                 case IT9135_62:
 393                         break;
 394                 default:
 395                         info("Unknown tuner ID applying default 0x60");
 396                 case IT9135_60:
 397                         st->it913x_config.tuner_id_0 = IT9135_60;
 398                 }
 399                 break;
 400         case IT9137_FW:
 401         default:
 402                 st->it913x_config.firmware_ver = 0;
 403                 st->it913x_config.adc_x2 = 0;
 404                 st->it913x_config.read_slevel = true;
 405                 *name = fw_it9137;
 406         }
 407
 408         return;
 409 }
 410
 411 #define TS_MPEG_PKT_SIZE        188
 412 #define EP_LOW                  21
 413 #define TS_BUFFER_SIZE_PID      (EP_LOW*TS_MPEG_PKT_SIZE)
 414 #define EP_HIGH                 348
 415 #define TS_BUFFER_SIZE_MAX      (EP_HIGH*TS_MPEG_PKT_SIZE)
 416
 417 static int it913x_get_stream_config(struct dvb_frontend *fe, u8 *ts_type,
 418                 struct usb_data_stream_properties *stream)
 419 {
 420         struct dvb_usb_adapter *adap = fe_to_adap(fe);
 421         if (adap->pid_filtering)
 422                 stream->u.bulk.buffersize = TS_BUFFER_SIZE_PID;
 423         else
 424                 stream->u.bulk.buffersize = TS_BUFFER_SIZE_MAX;
 425
 426         return 0;
 427 }
 428
 429 static int it913x_select_config(struct dvb_usb_device *d)
 430 {
 431         struct it913x_state *st = d->priv;
 432         int ret, reg;
 433
 434         ret = it913x_return_status(d);
 435         if (ret < 0)
 436                 return ret;
 437
 438         if (st->it913x_config.chip_ver == 0x02
 439                         && st->it913x_config.chip_type == 0x9135)
 440                 reg = it913x_read_reg(d, 0x461d);
 441         else
 442                 reg = it913x_read_reg(d, 0x461b);
 443
 444         if (reg < 0)
 445                 return reg;
 446
 447         if (reg == 0) {
 448                 st->it913x_config.dual_mode = 0;
 449                 st->it913x_config.tuner_id_0 = IT9135_38;
 450                 st->proprietary_ir = true;
 451         } else {
 452                 /* TS mode */
 453                 reg =  it913x_read_reg(d, 0x49c5);
 454                 if (reg < 0)
 455                         return reg;
 456                 st->it913x_config.dual_mode = reg;
 457
 458                 /* IR mode type */
 459                 reg = it913x_read_reg(d, 0x49ac);
 460                 if (reg < 0)
 461                         return reg;
 462                 if (reg == 5) {
 463                         info("Remote propriety (raw) mode");
 464                         st->proprietary_ir = true;
 465                 } else if (reg == 1) {
 466                         info("Remote HID mode NOT SUPPORTED");
 467                         st->proprietary_ir = false;
 468                 }
 469
 470                 /* Tuner_id */
 471                 reg = it913x_read_reg(d, 0x49d0);
 472                 if (reg < 0)
 473                         return reg;
 474                 st->it913x_config.tuner_id_0 = reg;
 475         }
 476
 477         info("Dual mode=%x Tuner Type=%x", st->it913x_config.dual_mode,
 478                 st->it913x_config.tuner_id_0);
 479
 480         return ret;
 481 }
 482
 483 static int it913x_streaming_ctrl(struct dvb_frontend *fe, int onoff)
 484 {
 485         struct dvb_usb_adapter *adap = fe_to_adap(fe);
 486         struct dvb_usb_device *d = adap_to_d(adap);
 487         struct it913x_state *st = fe_to_priv(fe);
 488         int ret = 0;
 489         u8 pro = (adap->id == 0) ? DEV_0_DMOD : DEV_1_DMOD;
 490
 491         deb_info(1, "STM  (%02x)", onoff);
 492
 493         if (!onoff) {
 494                 mutex_lock(&d->i2c_mutex);
 495
 496                 ret = it913x_wr_reg(d, pro, PID_RST, 0x1);
 497
 498                 mutex_unlock(&d->i2c_mutex);
 499                 st->pid_filter_onoff =
 500                         adap->pid_filtering;
 501
 502         }
 503
 504         return ret;
 505 }
 506
 507 static int it913x_identify_state(struct dvb_usb_device *d, const char **name)
 508 {
 509         struct it913x_state *st = d->priv;
 510         int ret;
 511         u8 reg;
 512
 513         /* Read and select config */
 514         ret = it913x_select_config(d);
 515         if (ret < 0)
 516                 return ret;
 517
 518         ite_get_firmware_name(d, name);
 519
 520         if (st->it913x_config.firmware > 0)
 521                 return WARM;
 522
 523         if (st->it913x_config.dual_mode) {
 524                 st->it913x_config.tuner_id_1 = it913x_read_reg(d, 0x49e0);
 525                 ret = it913x_wr_reg(d, DEV_0, GPIOH1_EN, 0x1);
 526                 ret |= it913x_wr_reg(d, DEV_0, GPIOH1_ON, 0x1);
 527                 ret |= it913x_wr_reg(d, DEV_0, GPIOH1_O, 0x1);
 528                 msleep(50);
 529                 ret |= it913x_wr_reg(d, DEV_0, GPIOH1_O, 0x0);
 530                 msleep(50);
 531                 reg = it913x_read_reg(d, GPIOH1_O);
 532                 if (reg == 0) {
 533                         ret |= it913x_wr_reg(d, DEV_0,  GPIOH1_O, 0x1);
 534                         ret |= it913x_return_status(d);
 535                         if (ret != 0)
 536                                 ret = it913x_wr_reg(d, DEV_0,
 537                                         GPIOH1_O, 0x0);
 538                 }
 539         }
 540
 541         reg = it913x_read_reg(d, IO_MUX_POWER_CLK);
 542
 543         if (st->it913x_config.dual_mode) {
 544                 ret |= it913x_wr_reg(d, DEV_0, 0x4bfb, CHIP2_I2C_ADDR);
 545                 if (st->it913x_config.firmware_ver == 1)
 546                         ret |= it913x_wr_reg(d, DEV_0,  0xcfff, 0x1);
 547                 else
 548                         ret |= it913x_wr_reg(d, DEV_0,  CLK_O_EN, 0x1);
 549         } else {
 550                 ret |= it913x_wr_reg(d, DEV_0, 0x4bfb, 0x0);
 551                 if (st->it913x_config.firmware_ver == 1)
 552                         ret |= it913x_wr_reg(d, DEV_0,  0xcfff, 0x0);
 553                 else
 554                         ret |= it913x_wr_reg(d, DEV_0,  CLK_O_EN, 0x0);
 555         }
 556
 557         ret |= it913x_wr_reg(d, DEV_0,  I2C_CLK, I2C_CLK_100);
 558
 559         return (ret < 0) ? ret : COLD;
 560 }
 561
 562 static int it913x_download_firmware(struct dvb_usb_device *d,
 563                                         const struct firmware *fw)
 564 {
 565         struct it913x_state *st = d->priv;
 566         int ret = 0, i = 0, pos = 0;
 567         u8 packet_size, min_pkt;
 568         u8 *fw_data;
 569
 570         ret = it913x_wr_reg(d, DEV_0,  I2C_CLK, I2C_CLK_100);
 571
 572         info("FRM Starting Firmware Download");
 573
 574         /* Multi firmware loader */
 575         /* This uses scatter write firmware headers */
 576         /* The firmware must start with 03 XX 00 */
 577         /* and be the extact firmware length */
 578
 579         if (st->it913x_config.chip_ver == 2)
 580                 min_pkt = 0x11;
 581         else
 582                 min_pkt = 0x19;
 583
 584         while (i <= fw->size) {
 585                 if (((fw->data[i] == 0x3) && (fw->data[i + 2] == 0x0))
 586                         || (i == fw->size)) {
 587                         packet_size = i - pos;
 588                         if ((packet_size > min_pkt) || (i == fw->size)) {
 589                                 fw_data = (u8 *)(fw->data + pos);
 590                                 pos += packet_size;
 591                                 if (packet_size > 0) {
 592                                         ret = it913x_io(d, WRITE_DATA,
 593                                                 DEV_0, CMD_SCATTER_WRITE, 0,
 594                                                 0, fw_data, packet_size);
 595                                         if (ret < 0)
 596                                                 break;
 597                                 }
 598                                 udelay(1000);
 599                         }
 600                 }
 601                 i++;
 602         }
 603
 604         if (ret < 0)
 605                 info("FRM Firmware Download Failed (%d)" , ret);
 606         else
 607                 info("FRM Firmware Download Completed - Resetting Device");
 608
 609         msleep(30);
 610
 611         ret = it913x_io(d, WRITE_CMD, DEV_0, CMD_BOOT, 0, 0, NULL, 0);
 612         if (ret < 0)
 613                 info("FRM Device not responding to reboot");
 614
 615         ret = it913x_return_status(d);
 616         if (st->it913x_config.firmware == 0) {
 617                 info("FRM Failed to reboot device");
 618                 return -ENODEV;
 619         }
 620
 621         msleep(30);
 622
 623         ret = it913x_wr_reg(d, DEV_0,  I2C_CLK, I2C_CLK_400);
 624
 625         msleep(30);
 626
 627         /* Tuner function */
 628         if (st->it913x_config.dual_mode)
 629                 ret |= it913x_wr_reg(d, DEV_0_DMOD , 0xec4c, 0xa0);
 630         else
 631                 ret |= it913x_wr_reg(d, DEV_0_DMOD , 0xec4c, 0x68);
 632
 633         if ((st->it913x_config.chip_ver == 1) &&
 634                 (st->it913x_config.chip_type == 0x9135)) {
 635                 ret |= it913x_wr_reg(d, DEV_0,  PADODPU, 0x0);
 636                 ret |= it913x_wr_reg(d, DEV_0,  AGC_O_D, 0x0);
 637                 if (st->it913x_config.dual_mode) {
 638                         ret |= it913x_wr_reg(d, DEV_1,  PADODPU, 0x0);
 639                         ret |= it913x_wr_reg(d, DEV_1,  AGC_O_D, 0x0);
 640                 }
 641         }
 642
 643         return (ret < 0) ? -ENODEV : 0;
 644 }
 645
 646 static int it913x_name(struct dvb_usb_adapter *adap)
 647 {
 648         struct dvb_usb_device *d = adap_to_d(adap);
 649         const char *desc = d->name;
 650         char *fe_name[] = {"_1", "_2", "_3", "_4"};
 651         char *name = adap->fe[0]->ops.info.name;
 652
 653         strlcpy(name, desc, 128);
 654         strlcat(name, fe_name[adap->id], 128);
 655
 656         return 0;
 657 }
 658
 659 static int it913x_frontend_attach(struct dvb_usb_adapter *adap)
 660 {
 661         struct dvb_usb_device *d = adap_to_d(adap);
 662         struct it913x_state *st = d->priv;
 663         int ret = 0;
 664         u8 adap_addr = I2C_BASE_ADDR + (adap->id << 5);
 665         u16 ep_size = (adap->pid_filtering) ? TS_BUFFER_SIZE_PID / 4 :
 666                 TS_BUFFER_SIZE_MAX / 4;
 667         u8 pkt_size = 0x80;
 668
 669         if (d->udev->speed != USB_SPEED_HIGH)
 670                 pkt_size = 0x10;
 671
 672         st->it913x_config.adf = it913x_read_reg(d, IO_MUX_POWER_CLK);
 673
 674         adap->fe[0] = dvb_attach(it913x_fe_attach,
 675                 &d->i2c_adap, adap_addr, &st->it913x_config);
 676
 677         if (adap->id == 0 && adap->fe[0]) {
 678                 it913x_wr_reg(d, DEV_0_DMOD, MP2_SW_RST, 0x1);
 679                 it913x_wr_reg(d, DEV_0_DMOD, MP2IF2_SW_RST, 0x1);
 680                 it913x_wr_reg(d, DEV_0, EP0_TX_EN, 0x0f);
 681                 it913x_wr_reg(d, DEV_0, EP0_TX_NAK, 0x1b);
 682                 if (st->proprietary_ir == false) /* Enable endpoint 3 */
 683                         it913x_wr_reg(d, DEV_0, EP0_TX_EN, 0x3f);
 684                 else
 685                         it913x_wr_reg(d, DEV_0, EP0_TX_EN, 0x2f);
 686                 it913x_wr_reg(d, DEV_0, EP4_TX_LEN_LSB,
 687                                         ep_size & 0xff);
 688                 it913x_wr_reg(d, DEV_0, EP4_TX_LEN_MSB, ep_size >> 8);
 689                 ret = it913x_wr_reg(d, DEV_0, EP4_MAX_PKT, pkt_size);
 690         } else if (adap->id == 1 && adap->fe[0]) {
 691                 if (st->proprietary_ir == false)
 692                         it913x_wr_reg(d, DEV_0, EP0_TX_EN, 0x7f);
 693                 else
 694                         it913x_wr_reg(d, DEV_0, EP0_TX_EN, 0x6f);
 695                 it913x_wr_reg(d, DEV_0, EP5_TX_LEN_LSB,
 696                                         ep_size & 0xff);
 697                 it913x_wr_reg(d, DEV_0, EP5_TX_LEN_MSB, ep_size >> 8);
 698                 it913x_wr_reg(d, DEV_0, EP5_MAX_PKT, pkt_size);
 699                 it913x_wr_reg(d, DEV_0_DMOD, MP2IF2_EN, 0x1);
 700                 it913x_wr_reg(d, DEV_1_DMOD, MP2IF_SERIAL, 0x1);
 701                 it913x_wr_reg(d, DEV_1, TOP_HOSTB_SER_MODE, 0x1);
 702                 it913x_wr_reg(d, DEV_0_DMOD, TSIS_ENABLE, 0x1);
 703                 it913x_wr_reg(d, DEV_0_DMOD, MP2_SW_RST, 0x0);
 704                 it913x_wr_reg(d, DEV_0_DMOD, MP2IF2_SW_RST, 0x0);
 705                 it913x_wr_reg(d, DEV_0_DMOD, MP2IF2_HALF_PSB, 0x0);
 706                 it913x_wr_reg(d, DEV_0_DMOD, MP2IF_STOP_EN, 0x1);
 707                 it913x_wr_reg(d, DEV_1_DMOD, MPEG_FULL_SPEED, 0x0);
 708                 ret = it913x_wr_reg(d, DEV_1_DMOD, MP2IF_STOP_EN, 0x0);
 709         } else
 710                 return -ENODEV;
 711
 712         ret |= it913x_name(adap);
 713
 714         return ret;
 715 }
 716
 717 /* DVB USB Driver */
 718 static int it913x_get_adapter_count(struct dvb_usb_device *d)
 719 {
 720         struct it913x_state *st = d->priv;
 721         if (st->it913x_config.dual_mode)
 722                 return 2;
 723         return 1;
 724 }
 725
 726 static struct dvb_usb_device_properties it913x_properties = {
 727         .driver_name = KBUILD_MODNAME,
 728         .owner = THIS_MODULE,
 729         .bInterfaceNumber = 0,
 730         .generic_bulk_ctrl_endpoint = 0x02,
 731         .generic_bulk_ctrl_endpoint_response = 0x81,
 732
 733         .adapter_nr = adapter_nr,
 734         .size_of_priv = sizeof(struct it913x_state),
 735
 736         .identify_state = it913x_identify_state,
 737         .i2c_algo = &it913x_i2c_algo,
 738
 739         .download_firmware = it913x_download_firmware,
 740
 741         .frontend_attach  = it913x_frontend_attach,
 742         .get_rc_config = it913x_get_rc_config,
 743         .get_stream_config = it913x_get_stream_config,
 744         .get_adapter_count = it913x_get_adapter_count,
 745         .streaming_ctrl   = it913x_streaming_ctrl,
 746
 747
 748         .adapter = {
 749                 {
 750                         .caps = DVB_USB_ADAP_HAS_PID_FILTER|
 751                                 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
 752                         .pid_filter_count = 32,
 753                         .pid_filter = it913x_pid_filter,
 754                         .pid_filter_ctrl  = it913x_pid_filter_ctrl,
 755                         .stream =
 756                         DVB_USB_STREAM_BULK(0x84, 10, TS_BUFFER_SIZE_MAX),
 757                 },
 758                 {
 759                         .caps = DVB_USB_ADAP_HAS_PID_FILTER|
 760                                 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
 761                         .pid_filter_count = 32,
 762                         .pid_filter = it913x_pid_filter,
 763                         .pid_filter_ctrl  = it913x_pid_filter_ctrl,
 764                         .stream =
 765                         DVB_USB_STREAM_BULK(0x85, 10, TS_BUFFER_SIZE_MAX),
 766                 }
 767         }
 768 };
 769
 770 static const struct usb_device_id it913x_id_table[] = {
 771         { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_UB499_2T_T09,
 772                 &it913x_properties, "Kworld UB499-2T T09(IT9137)",
 773                         RC_MAP_IT913X_V1) },
 774         { DVB_USB_DEVICE(USB_VID_ITETECH, USB_PID_ITETECH_IT9135,
 775                 &it913x_properties, "ITE 9135 Generic",
 776                         RC_MAP_IT913X_V1) },
 777         { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_SVEON_STV22_IT9137,
 778                 &it913x_properties, "Sveon STV22 Dual DVB-T HDTV(IT9137)",
 779                         RC_MAP_IT913X_V1) },
 780         { DVB_USB_DEVICE(USB_VID_ITETECH, USB_PID_ITETECH_IT9135_9005,
 781                 &it913x_properties, "ITE 9135(9005) Generic",
 782                         RC_MAP_IT913X_V2) },
 783         { DVB_USB_DEVICE(USB_VID_ITETECH, USB_PID_ITETECH_IT9135_9006,
 784                 &it913x_properties, "ITE 9135(9006) Generic",
 785                         RC_MAP_IT913X_V1) },
 786         { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A835B_1835,
 787                 &it913x_properties, "Avermedia A835B(1835)",
 788                         RC_MAP_IT913X_V2) },
 789         { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A835B_2835,
 790                 &it913x_properties, "Avermedia A835B(2835)",
 791                         RC_MAP_IT913X_V2) },
 792         { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A835B_3835,
 793                 &it913x_properties, "Avermedia A835B(3835)",
 794                         RC_MAP_IT913X_V2) },
 795         { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A835B_4835,
 796                 &it913x_properties, "Avermedia A835B(4835)",
 797                         RC_MAP_IT913X_V2) },
 798         {}              /* Terminating entry */
 799 };
 800
 801 MODULE_DEVICE_TABLE(usb, it913x_id_table);
 802
 803 static struct usb_driver it913x_driver = {
 804         .name           = KBUILD_MODNAME,
 805         .probe          = dvb_usbv2_probe,
 806         .disconnect     = dvb_usbv2_disconnect,
 807         .suspend        = dvb_usbv2_suspend,
 808         .resume         = dvb_usbv2_resume,
 809         .id_table       = it913x_id_table,
 810 };
 811
 812 module_usb_driver(it913x_driver);
 813
 814 MODULE_AUTHOR("Malcolm Priestley <tvboxspy@gmail.com>");
 815 MODULE_DESCRIPTION("it913x USB 2 Driver");
 816 MODULE_VERSION("1.33");
 817 MODULE_LICENSE("GPL");
 818 MODULE_FIRMWARE(FW_IT9135_V1);
 819 MODULE_FIRMWARE(FW_IT9135_V2);
 820 MODULE_FIRMWARE(FW_IT9137);
 821