drivers/media/dvb/dvb-usb/af9015.c

   1 /*
   2  * DVB USB Linux driver for Afatech AF9015 DVB-T USB2.0 receiver
   3  *
   4  * Copyright (C) 2007 Antti Palosaari <crope@iki.fi>
   5  *
   6  * Thanks to Afatech who kindly provided information.
   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 as published by
  10  *    the Free Software Foundation; either version 2 of the License, or
  11  *    (at your option) any later version.
  12  *
  13  *    This program is distributed in the hope that it will be useful,
  14  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *    GNU General Public License for more details.
  17  *
  18  *    You should have received a copy of the GNU General Public License
  19  *    along with this program; if not, write to the Free Software
  20  *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21  *
  22  */
  23
  24 #include <linux/hash.h>
  25 #include <linux/slab.h>
  26
  27 #include "af9015.h"
  28 #include "af9013.h"
  29 #include "mt2060.h"
  30 #include "qt1010.h"
  31 #include "tda18271.h"
  32 #include "mxl5005s.h"
  33 #include "mc44s803.h"
  34 #include "tda18218.h"
  35 #include "mxl5007t.h"
  36
  37 static int dvb_usb_af9015_debug;
  38 module_param_named(debug, dvb_usb_af9015_debug, int, 0644);
  39 MODULE_PARM_DESC(debug, "set debugging level" DVB_USB_DEBUG_STATUS);
  40 static int dvb_usb_af9015_remote;
  41 module_param_named(remote, dvb_usb_af9015_remote, int, 0644);
  42 MODULE_PARM_DESC(remote, "select remote");
  43 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
  44
  45 static DEFINE_MUTEX(af9015_usb_mutex);
  46
  47 static struct af9015_config af9015_config;
  48 static struct dvb_usb_device_properties af9015_properties[3];
  49 static int af9015_properties_count = ARRAY_SIZE(af9015_properties);
  50
  51 static struct af9013_config af9015_af9013_config[] = {
  52         {
  53                 .demod_address = AF9015_I2C_DEMOD,
  54                 .output_mode = AF9013_OUTPUT_MODE_USB,
  55                 .api_version = { 0, 1, 9, 0 },
  56                 .gpio[0] = AF9013_GPIO_HI,
  57                 .gpio[3] = AF9013_GPIO_TUNER_ON,
  58
  59         }, {
  60                 .output_mode = AF9013_OUTPUT_MODE_SERIAL,
  61                 .api_version = { 0, 1, 9, 0 },
  62                 .gpio[0] = AF9013_GPIO_TUNER_ON,
  63                 .gpio[1] = AF9013_GPIO_LO,
  64         }
  65 };
  66
  67 static int af9015_rw_udev(struct usb_device *udev, struct req_t *req)
  68 {
  69 #define BUF_LEN 63
  70 #define REQ_HDR_LEN 8 /* send header size */
  71 #define ACK_HDR_LEN 2 /* rece header size */
  72         int act_len, ret;
  73         u8 buf[BUF_LEN];
  74         u8 write = 1;
  75         u8 msg_len = REQ_HDR_LEN;
  76         static u8 seq; /* packet sequence number */
  77
  78         if (mutex_lock_interruptible(&af9015_usb_mutex) < 0)
  79                 return -EAGAIN;
  80
  81         buf[0] = req->cmd;
  82         buf[1] = seq++;
  83         buf[2] = req->i2c_addr;
  84         buf[3] = req->addr >> 8;
  85         buf[4] = req->addr & 0xff;
  86         buf[5] = req->mbox;
  87         buf[6] = req->addr_len;
  88         buf[7] = req->data_len;
  89
  90         switch (req->cmd) {
  91         case GET_CONFIG:
  92         case READ_MEMORY:
  93         case RECONNECT_USB:
  94         case GET_IR_CODE:
  95                 write = 0;
  96                 break;
  97         case READ_I2C:
  98                 write = 0;
  99                 buf[2] |= 0x01; /* set I2C direction */
 100         case WRITE_I2C:
 101                 buf[0] = READ_WRITE_I2C;
 102                 break;
 103         case WRITE_MEMORY:
 104                 if (((req->addr & 0xff00) == 0xff00) ||
 105                     ((req->addr & 0xff00) == 0xae00))
 106                         buf[0] = WRITE_VIRTUAL_MEMORY;
 107         case WRITE_VIRTUAL_MEMORY:
 108         case COPY_FIRMWARE:
 109         case DOWNLOAD_FIRMWARE:
 110         case BOOT:
 111                 break;
 112         default:
 113                 err("unknown command:%d", req->cmd);
 114                 ret = -1;
 115                 goto error_unlock;
 116         }
 117
 118         /* buffer overflow check */
 119         if ((write && (req->data_len > BUF_LEN - REQ_HDR_LEN)) ||
 120                 (!write && (req->data_len > BUF_LEN - ACK_HDR_LEN))) {
 121                 err("too much data; cmd:%d len:%d", req->cmd, req->data_len);
 122                 ret = -EINVAL;
 123                 goto error_unlock;
 124         }
 125
 126         /* write requested */
 127         if (write) {
 128                 memcpy(&buf[REQ_HDR_LEN], req->data, req->data_len);
 129                 msg_len += req->data_len;
 130         }
 131
 132         deb_xfer(">>> ");
 133         debug_dump(buf, msg_len, deb_xfer);
 134
 135         /* send req */
 136         ret = usb_bulk_msg(udev, usb_sndbulkpipe(udev, 0x02), buf, msg_len,
 137                 &act_len, AF9015_USB_TIMEOUT);
 138         if (ret)
 139                 err("bulk message failed:%d (%d/%d)", ret, msg_len, act_len);
 140         else
 141                 if (act_len != msg_len)
 142                         ret = -1; /* all data is not send */
 143         if (ret)
 144                 goto error_unlock;
 145
 146         /* no ack for those packets */
 147         if (req->cmd == DOWNLOAD_FIRMWARE || req->cmd == RECONNECT_USB)
 148                 goto exit_unlock;
 149
 150         /* write receives seq + status = 2 bytes
 151            read receives seq + status + data = 2 + N bytes */
 152         msg_len = ACK_HDR_LEN;
 153         if (!write)
 154                 msg_len += req->data_len;
 155
 156         ret = usb_bulk_msg(udev, usb_rcvbulkpipe(udev, 0x81), buf, msg_len,
 157                 &act_len, AF9015_USB_TIMEOUT);
 158         if (ret) {
 159                 err("recv bulk message failed:%d", ret);
 160                 ret = -1;
 161                 goto error_unlock;
 162         }
 163
 164         deb_xfer("<<< ");
 165         debug_dump(buf, act_len, deb_xfer);
 166
 167         /* remote controller query status is 1 if remote code is not received */
 168         if (req->cmd == GET_IR_CODE && buf[1] == 1) {
 169                 buf[1] = 0; /* clear command "error" status */
 170                 memset(&buf[2], 0, req->data_len);
 171                 buf[3] = 1; /* no remote code received mark */
 172         }
 173
 174         /* check status */
 175         if (buf[1]) {
 176                 err("command failed:%d", buf[1]);
 177                 ret = -1;
 178                 goto error_unlock;
 179         }
 180
 181         /* read request, copy returned data to return buf */
 182         if (!write)
 183                 memcpy(req->data, &buf[ACK_HDR_LEN], req->data_len);
 184
 185 error_unlock:
 186 exit_unlock:
 187         mutex_unlock(&af9015_usb_mutex);
 188
 189         return ret;
 190 }
 191
 192 static int af9015_ctrl_msg(struct dvb_usb_device *d, struct req_t *req)
 193 {
 194         return af9015_rw_udev(d->udev, req);
 195 }
 196
 197 static int af9015_write_regs(struct dvb_usb_device *d, u16 addr, u8 *val,
 198         u8 len)
 199 {
 200         struct req_t req = {WRITE_MEMORY, AF9015_I2C_DEMOD, addr, 0, 0, len,
 201                 val};
 202         return af9015_ctrl_msg(d, &req);
 203 }
 204
 205 static int af9015_write_reg(struct dvb_usb_device *d, u16 addr, u8 val)
 206 {
 207         return af9015_write_regs(d, addr, &val, 1);
 208 }
 209
 210 static int af9015_read_regs(struct dvb_usb_device *d, u16 addr, u8 *val, u8 len)
 211 {
 212         struct req_t req = {READ_MEMORY, AF9015_I2C_DEMOD, addr, 0, 0, len,
 213                 val};
 214         return af9015_ctrl_msg(d, &req);
 215 }
 216
 217 static int af9015_read_reg(struct dvb_usb_device *d, u16 addr, u8 *val)
 218 {
 219         return af9015_read_regs(d, addr, val, 1);
 220 }
 221
 222 static int af9015_write_reg_i2c(struct dvb_usb_device *d, u8 addr, u16 reg,
 223         u8 val)
 224 {
 225         struct req_t req = {WRITE_I2C, addr, reg, 1, 1, 1, &val};
 226
 227         if (addr == af9015_af9013_config[0].demod_address ||
 228             addr == af9015_af9013_config[1].demod_address)
 229                 req.addr_len = 3;
 230
 231         return af9015_ctrl_msg(d, &req);
 232 }
 233
 234 static int af9015_read_reg_i2c(struct dvb_usb_device *d, u8 addr, u16 reg,
 235         u8 *val)
 236 {
 237         struct req_t req = {READ_I2C, addr, reg, 0, 1, 1, val};
 238
 239         if (addr == af9015_af9013_config[0].demod_address ||
 240             addr == af9015_af9013_config[1].demod_address)
 241                 req.addr_len = 3;
 242
 243         return af9015_ctrl_msg(d, &req);
 244 }
 245
 246 static int af9015_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
 247         int num)
 248 {
 249         struct dvb_usb_device *d = i2c_get_adapdata(adap);
 250         int ret = 0, i = 0;
 251         u16 addr;
 252         u8 uninitialized_var(mbox), addr_len;
 253         struct req_t req;
 254
 255 /* TODO: implement bus lock
 256
 257 The bus lock is needed because there is two tuners both using same I2C-address.
 258 Due to that the only way to select correct tuner is use demodulator I2C-gate.
 259
 260 ................................................
 261 . AF9015 includes integrated AF9013 demodulator.
 262 . ____________                   ____________  .                ____________
 263 .|     uC     |                 |   demod    | .               |    tuner   |
 264 .|------------|                 |------------| .               |------------|
 265 .|   AF9015   |                 |  AF9013/5  | .               |   MXL5003  |
 266 .|            |--+----I2C-------|-----/ -----|-.-----I2C-------|            |
 267 .|            |  |              | addr 0x38  | .               |  addr 0xc6 |
 268 .|____________|  |              |____________| .               |____________|
 269 .................|..............................
 270                  |               ____________                   ____________
 271                  |              |   demod    |                 |    tuner   |
 272                  |              |------------|                 |------------|
 273                  |              |   AF9013   |                 |   MXL5003  |
 274                  +----I2C-------|-----/ -----|-------I2C-------|            |
 275                                 | addr 0x3a  |                 |  addr 0xc6 |
 276                                 |____________|                 |____________|
 277 */
 278         if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
 279                 return -EAGAIN;
 280
 281         while (i < num) {
 282                 if (msg[i].addr == af9015_af9013_config[0].demod_address ||
 283                     msg[i].addr == af9015_af9013_config[1].demod_address) {
 284                         addr = msg[i].buf[0] << 8;
 285                         addr += msg[i].buf[1];
 286                         mbox = msg[i].buf[2];
 287                         addr_len = 3;
 288                 } else {
 289                         addr = msg[i].buf[0];
 290                         addr_len = 1;
 291                         /* mbox is don't care in that case */
 292                 }
 293
 294                 if (num > i + 1 && (msg[i+1].flags & I2C_M_RD)) {
 295                         if (msg[i].addr ==
 296                                 af9015_af9013_config[0].demod_address)
 297                                 req.cmd = READ_MEMORY;
 298                         else
 299                                 req.cmd = READ_I2C;
 300                         req.i2c_addr = msg[i].addr;
 301                         req.addr = addr;
 302                         req.mbox = mbox;
 303                         req.addr_len = addr_len;
 304                         req.data_len = msg[i+1].len;
 305                         req.data = &msg[i+1].buf[0];
 306                         ret = af9015_ctrl_msg(d, &req);
 307                         i += 2;
 308                 } else if (msg[i].flags & I2C_M_RD) {
 309                         ret = -EINVAL;
 310                         if (msg[i].addr ==
 311                                 af9015_af9013_config[0].demod_address)
 312                                 goto error;
 313                         else
 314                                 req.cmd = READ_I2C;
 315                         req.i2c_addr = msg[i].addr;
 316                         req.addr = addr;
 317                         req.mbox = mbox;
 318                         req.addr_len = addr_len;
 319                         req.data_len = msg[i].len;
 320                         req.data = &msg[i].buf[0];
 321                         ret = af9015_ctrl_msg(d, &req);
 322                         i += 1;
 323                 } else {
 324                         if (msg[i].addr ==
 325                                 af9015_af9013_config[0].demod_address)
 326                                 req.cmd = WRITE_MEMORY;
 327                         else
 328                                 req.cmd = WRITE_I2C;
 329                         req.i2c_addr = msg[i].addr;
 330                         req.addr = addr;
 331                         req.mbox = mbox;
 332                         req.addr_len = addr_len;
 333                         req.data_len = msg[i].len-addr_len;
 334                         req.data = &msg[i].buf[addr_len];
 335                         ret = af9015_ctrl_msg(d, &req);
 336                         i += 1;
 337                 }
 338                 if (ret)
 339                         goto error;
 340
 341         }
 342         ret = i;
 343
 344 error:
 345         mutex_unlock(&d->i2c_mutex);
 346
 347         return ret;
 348 }
 349
 350 static u32 af9015_i2c_func(struct i2c_adapter *adapter)
 351 {
 352         return I2C_FUNC_I2C;
 353 }
 354
 355 static struct i2c_algorithm af9015_i2c_algo = {
 356         .master_xfer = af9015_i2c_xfer,
 357         .functionality = af9015_i2c_func,
 358 };
 359
 360 static int af9015_do_reg_bit(struct dvb_usb_device *d, u16 addr, u8 bit, u8 op)
 361 {
 362         int ret;
 363         u8 val, mask = 0x01;
 364
 365         ret = af9015_read_reg(d, addr, &val);
 366         if (ret)
 367                 return ret;
 368
 369         mask <<= bit;
 370         if (op) {
 371                 /* set bit */
 372                 val |= mask;
 373         } else {
 374                 /* clear bit */
 375                 mask ^= 0xff;
 376                 val &= mask;
 377         }
 378
 379         return af9015_write_reg(d, addr, val);
 380 }
 381
 382 static int af9015_set_reg_bit(struct dvb_usb_device *d, u16 addr, u8 bit)
 383 {
 384         return af9015_do_reg_bit(d, addr, bit, 1);
 385 }
 386
 387 static int af9015_clear_reg_bit(struct dvb_usb_device *d, u16 addr, u8 bit)
 388 {
 389         return af9015_do_reg_bit(d, addr, bit, 0);
 390 }
 391
 392 static int af9015_init_endpoint(struct dvb_usb_device *d)
 393 {
 394         int ret;
 395         u16 frame_size;
 396         u8  packet_size;
 397         deb_info("%s: USB speed:%d\n", __func__, d->udev->speed);
 398
 399         /* Windows driver uses packet count 21 for USB1.1 and 348 for USB2.0.
 400            We use smaller - about 1/4 from the original, 5 and 87. */
 401 #define TS_PACKET_SIZE            188
 402
 403 #define TS_USB20_PACKET_COUNT      87
 404 #define TS_USB20_FRAME_SIZE       (TS_PACKET_SIZE*TS_USB20_PACKET_COUNT)
 405
 406 #define TS_USB11_PACKET_COUNT       5
 407 #define TS_USB11_FRAME_SIZE       (TS_PACKET_SIZE*TS_USB11_PACKET_COUNT)
 408
 409 #define TS_USB20_MAX_PACKET_SIZE  512
 410 #define TS_USB11_MAX_PACKET_SIZE   64
 411
 412         if (d->udev->speed == USB_SPEED_FULL) {
 413                 frame_size = TS_USB11_FRAME_SIZE/4;
 414                 packet_size = TS_USB11_MAX_PACKET_SIZE/4;
 415         } else {
 416                 frame_size = TS_USB20_FRAME_SIZE/4;
 417                 packet_size = TS_USB20_MAX_PACKET_SIZE/4;
 418         }
 419
 420         ret = af9015_set_reg_bit(d, 0xd507, 2); /* assert EP4 reset */
 421         if (ret)
 422                 goto error;
 423         ret = af9015_set_reg_bit(d, 0xd50b, 1); /* assert EP5 reset */
 424         if (ret)
 425                 goto error;
 426         ret = af9015_clear_reg_bit(d, 0xdd11, 5); /* disable EP4 */
 427         if (ret)
 428                 goto error;
 429         ret = af9015_clear_reg_bit(d, 0xdd11, 6); /* disable EP5 */
 430         if (ret)
 431                 goto error;
 432         ret = af9015_set_reg_bit(d, 0xdd11, 5); /* enable EP4 */
 433         if (ret)
 434                 goto error;
 435         if (af9015_config.dual_mode) {
 436                 ret = af9015_set_reg_bit(d, 0xdd11, 6); /* enable EP5 */
 437                 if (ret)
 438                         goto error;
 439         }
 440         ret = af9015_clear_reg_bit(d, 0xdd13, 5); /* disable EP4 NAK */
 441         if (ret)
 442                 goto error;
 443         if (af9015_config.dual_mode) {
 444                 ret = af9015_clear_reg_bit(d, 0xdd13, 6); /* disable EP5 NAK */
 445                 if (ret)
 446                         goto error;
 447         }
 448         /* EP4 xfer length */
 449         ret = af9015_write_reg(d, 0xdd88, frame_size & 0xff);
 450         if (ret)
 451                 goto error;
 452         ret = af9015_write_reg(d, 0xdd89, frame_size >> 8);
 453         if (ret)
 454                 goto error;
 455         /* EP5 xfer length */
 456         ret = af9015_write_reg(d, 0xdd8a, frame_size & 0xff);
 457         if (ret)
 458                 goto error;
 459         ret = af9015_write_reg(d, 0xdd8b, frame_size >> 8);
 460         if (ret)
 461                 goto error;
 462         ret = af9015_write_reg(d, 0xdd0c, packet_size); /* EP4 packet size */
 463         if (ret)
 464                 goto error;
 465         ret = af9015_write_reg(d, 0xdd0d, packet_size); /* EP5 packet size */
 466         if (ret)
 467                 goto error;
 468         ret = af9015_clear_reg_bit(d, 0xd507, 2); /* negate EP4 reset */
 469         if (ret)
 470                 goto error;
 471         if (af9015_config.dual_mode) {
 472                 ret = af9015_clear_reg_bit(d, 0xd50b, 1); /* negate EP5 reset */
 473                 if (ret)
 474                         goto error;
 475         }
 476
 477         /* enable / disable mp2if2 */
 478         if (af9015_config.dual_mode)
 479                 ret = af9015_set_reg_bit(d, 0xd50b, 0);
 480         else
 481                 ret = af9015_clear_reg_bit(d, 0xd50b, 0);
 482
 483 error:
 484         if (ret)
 485                 err("endpoint init failed:%d", ret);
 486         return ret;
 487 }
 488
 489 static int af9015_copy_firmware(struct dvb_usb_device *d)
 490 {
 491         int ret;
 492         u8 fw_params[4];
 493         u8 val, i;
 494         struct req_t req = {COPY_FIRMWARE, 0, 0x5100, 0, 0, sizeof(fw_params),
 495                 fw_params };
 496         deb_info("%s:\n", __func__);
 497
 498         fw_params[0] = af9015_config.firmware_size >> 8;
 499         fw_params[1] = af9015_config.firmware_size & 0xff;
 500         fw_params[2] = af9015_config.firmware_checksum >> 8;
 501         fw_params[3] = af9015_config.firmware_checksum & 0xff;
 502
 503         /* wait 2nd demodulator ready */
 504         msleep(100);
 505
 506         ret = af9015_read_reg_i2c(d,
 507                 af9015_af9013_config[1].demod_address, 0x98be, &val);
 508         if (ret)
 509                 goto error;
 510         else
 511                 deb_info("%s: firmware status:%02x\n", __func__, val);
 512
 513         if (val == 0x0c) /* fw is running, no need for download */
 514                 goto exit;
 515
 516         /* set I2C master clock to fast (to speed up firmware copy) */
 517         ret = af9015_write_reg(d, 0xd416, 0x04); /* 0x04 * 400ns */
 518         if (ret)
 519                 goto error;
 520
 521         msleep(50);
 522
 523         /* copy firmware */
 524         ret = af9015_ctrl_msg(d, &req);
 525         if (ret)
 526                 err("firmware copy cmd failed:%d", ret);
 527         deb_info("%s: firmware copy done\n", __func__);
 528
 529         /* set I2C master clock back to normal */
 530         ret = af9015_write_reg(d, 0xd416, 0x14); /* 0x14 * 400ns */
 531         if (ret)
 532                 goto error;
 533
 534         /* request boot firmware */
 535         ret = af9015_write_reg_i2c(d, af9015_af9013_config[1].demod_address,
 536                 0xe205, 1);
 537         deb_info("%s: firmware boot cmd status:%d\n", __func__, ret);
 538         if (ret)
 539                 goto error;
 540
 541         for (i = 0; i < 15; i++) {
 542                 msleep(100);
 543
 544                 /* check firmware status */
 545                 ret = af9015_read_reg_i2c(d,
 546                         af9015_af9013_config[1].demod_address, 0x98be, &val);
 547                 deb_info("%s: firmware status cmd status:%d fw status:%02x\n",
 548                         __func__, ret, val);
 549                 if (ret)
 550                         goto error;
 551
 552                 if (val == 0x0c || val == 0x04) /* success or fail */
 553                         break;
 554         }
 555
 556         if (val == 0x04) {
 557                 err("firmware did not run");
 558                 ret = -1;
 559         } else if (val != 0x0c) {
 560                 err("firmware boot timeout");
 561                 ret = -1;
 562         }
 563
 564 error:
 565 exit:
 566         return ret;
 567 }
 568
 569 /* hash (and dump) eeprom */
 570 static int af9015_eeprom_hash(struct usb_device *udev)
 571 {
 572         static const unsigned int eeprom_size = 256;
 573         unsigned int reg;
 574         int ret;
 575         u8 val, *eeprom;
 576         struct req_t req = {READ_I2C, AF9015_I2C_EEPROM, 0, 0, 1, 1, &val};
 577
 578         eeprom = kmalloc(eeprom_size, GFP_KERNEL);
 579         if (eeprom == NULL)
 580                 return -ENOMEM;
 581
 582         for (reg = 0; reg < eeprom_size; reg++) {
 583                 req.addr = reg;
 584                 ret = af9015_rw_udev(udev, &req);
 585                 if (ret)
 586                         goto free;
 587                 eeprom[reg] = val;
 588         }
 589
 590         if (dvb_usb_af9015_debug & 0x01)
 591                 print_hex_dump_bytes("", DUMP_PREFIX_OFFSET, eeprom,
 592                                 eeprom_size);
 593
 594         BUG_ON(eeprom_size % 4);
 595
 596         af9015_config.eeprom_sum = 0;
 597         for (reg = 0; reg < eeprom_size / sizeof(u32); reg++) {
 598                 af9015_config.eeprom_sum *= GOLDEN_RATIO_PRIME_32;
 599                 af9015_config.eeprom_sum += le32_to_cpu(((u32 *)eeprom)[reg]);
 600         }
 601
 602         deb_info("%s: eeprom sum=%.8x\n", __func__, af9015_config.eeprom_sum);
 603
 604         ret = 0;
 605 free:
 606         kfree(eeprom);
 607         return ret;
 608 }
 609
 610 static int af9015_init(struct dvb_usb_device *d)
 611 {
 612         int ret;
 613         deb_info("%s:\n", __func__);
 614
 615         /* init RC canary */
 616         ret = af9015_write_reg(d, 0x98e9, 0xff);
 617         if (ret)
 618                 goto error;
 619
 620         ret = af9015_init_endpoint(d);
 621         if (ret)
 622                 goto error;
 623
 624 error:
 625         return ret;
 626 }
 627
 628 static int af9015_pid_filter_ctrl(struct dvb_usb_adapter *adap, int onoff)
 629 {
 630         int ret;
 631         deb_info("%s: onoff:%d\n", __func__, onoff);
 632
 633         if (onoff)
 634                 ret = af9015_set_reg_bit(adap->dev, 0xd503, 0);
 635         else
 636                 ret = af9015_clear_reg_bit(adap->dev, 0xd503, 0);
 637
 638         return ret;
 639 }
 640
 641 static int af9015_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid,
 642         int onoff)
 643 {
 644         int ret;
 645         u8 idx;
 646
 647         deb_info("%s: set pid filter, index %d, pid %x, onoff %d\n",
 648                 __func__, index, pid, onoff);
 649
 650         ret = af9015_write_reg(adap->dev, 0xd505, (pid & 0xff));
 651         if (ret)
 652                 goto error;
 653
 654         ret = af9015_write_reg(adap->dev, 0xd506, (pid >> 8));
 655         if (ret)
 656                 goto error;
 657
 658         idx = ((index & 0x1f) | (1 << 5));
 659         ret = af9015_write_reg(adap->dev, 0xd504, idx);
 660
 661 error:
 662         return ret;
 663 }
 664
 665 static int af9015_download_firmware(struct usb_device *udev,
 666         const struct firmware *fw)
 667 {
 668         int i, len, remaining, ret;
 669         struct req_t req = {DOWNLOAD_FIRMWARE, 0, 0, 0, 0, 0, NULL};
 670         u16 checksum = 0;
 671
 672         deb_info("%s:\n", __func__);
 673
 674         /* calc checksum */
 675         for (i = 0; i < fw->size; i++)
 676                 checksum += fw->data[i];
 677
 678         af9015_config.firmware_size = fw->size;
 679         af9015_config.firmware_checksum = checksum;
 680
 681         #define FW_ADDR 0x5100 /* firmware start address */
 682         #define LEN_MAX 55 /* max packet size */
 683         for (remaining = fw->size; remaining > 0; remaining -= LEN_MAX) {
 684                 len = remaining;
 685                 if (len > LEN_MAX)
 686                         len = LEN_MAX;
 687
 688                 req.data_len = len;
 689                 req.data = (u8 *) &fw->data[fw->size - remaining];
 690                 req.addr = FW_ADDR + fw->size - remaining;
 691
 692                 ret = af9015_rw_udev(udev, &req);
 693                 if (ret) {
 694                         err("firmware download failed:%d", ret);
 695                         goto error;
 696                 }
 697         }
 698
 699         /* firmware loaded, request boot */
 700         req.cmd = BOOT;
 701         ret = af9015_rw_udev(udev, &req);
 702         if (ret) {
 703                 err("firmware boot failed:%d", ret);
 704                 goto error;
 705         }
 706
 707 error:
 708         return ret;
 709 }
 710
 711 struct af9015_rc_setup {
 712         unsigned int id;
 713         char *rc_codes;
 714 };
 715
 716 static char *af9015_rc_setup_match(unsigned int id,
 717         const struct af9015_rc_setup *table)
 718 {
 719         for (; table->rc_codes; table++)
 720                 if (table->id == id)
 721                         return table->rc_codes;
 722         return NULL;
 723 }
 724
 725 static const struct af9015_rc_setup af9015_rc_setup_modparam[] = {
 726         { AF9015_REMOTE_A_LINK_DTU_M, RC_MAP_ALINK_DTU_M },
 727         { AF9015_REMOTE_MSI_DIGIVOX_MINI_II_V3, RC_MAP_MSI_DIGIVOX_II },
 728         { AF9015_REMOTE_MYGICTV_U718, RC_MAP_TOTAL_MEDIA_IN_HAND },
 729         { AF9015_REMOTE_DIGITTRADE_DVB_T, RC_MAP_DIGITTRADE },
 730         { AF9015_REMOTE_AVERMEDIA_KS, RC_MAP_AVERMEDIA_RM_KS },
 731         { }
 732 };
 733
 734 static const struct af9015_rc_setup af9015_rc_setup_hashes[] = {
 735         { 0xb8feb708, RC_MAP_MSI_DIGIVOX_II },
 736         { 0xa3703d00, RC_MAP_ALINK_DTU_M },
 737         { 0x9b7dc64e, RC_MAP_TOTAL_MEDIA_IN_HAND }, /* MYGICTV U718 */
 738         { }
 739 };
 740
 741 static const struct af9015_rc_setup af9015_rc_setup_usbids[] = {
 742         { (USB_VID_TERRATEC << 16) + USB_PID_TERRATEC_CINERGY_T_STICK_RC,
 743                 RC_MAP_TERRATEC_SLIM_2 },
 744         { (USB_VID_TERRATEC << 16) + USB_PID_TERRATEC_CINERGY_T_STICK_DUAL_RC,
 745                 RC_MAP_TERRATEC_SLIM },
 746         { (USB_VID_VISIONPLUS << 16) + USB_PID_AZUREWAVE_AD_TU700,
 747                 RC_MAP_AZUREWAVE_AD_TU700 },
 748         { (USB_VID_VISIONPLUS << 16) + USB_PID_TINYTWIN,
 749                 RC_MAP_AZUREWAVE_AD_TU700 },
 750         { (USB_VID_MSI_2 << 16) + USB_PID_MSI_DIGI_VOX_MINI_III,
 751                 RC_MAP_MSI_DIGIVOX_III },
 752         { (USB_VID_LEADTEK << 16) + USB_PID_WINFAST_DTV_DONGLE_GOLD,
 753                 RC_MAP_LEADTEK_Y04G0051 },
 754         { (USB_VID_AVERMEDIA << 16) + USB_PID_AVERMEDIA_VOLAR_X,
 755                 RC_MAP_AVERMEDIA_M135A },
 756         { (USB_VID_AFATECH << 16) + USB_PID_TREKSTOR_DVBT,
 757                 RC_MAP_TREKSTOR },
 758         { (USB_VID_KWORLD_2 << 16) + USB_PID_TINYTWIN_2,
 759                 RC_MAP_DIGITALNOW_TINYTWIN },
 760         { (USB_VID_GTEK << 16) + USB_PID_TINYTWIN_3,
 761                 RC_MAP_DIGITALNOW_TINYTWIN },
 762         { }
 763 };
 764
 765 static void af9015_set_remote_config(struct usb_device *udev,
 766                 struct dvb_usb_device_properties *props)
 767 {
 768         u16 vid = le16_to_cpu(udev->descriptor.idVendor);
 769         u16 pid = le16_to_cpu(udev->descriptor.idProduct);
 770
 771         /* try to load remote based module param */
 772         props->rc.core.rc_codes = af9015_rc_setup_match(
 773                 dvb_usb_af9015_remote, af9015_rc_setup_modparam);
 774
 775         /* try to load remote based eeprom hash */
 776         if (!props->rc.core.rc_codes)
 777                 props->rc.core.rc_codes = af9015_rc_setup_match(
 778                         af9015_config.eeprom_sum, af9015_rc_setup_hashes);
 779
 780         /* try to load remote based USB ID */
 781         if (!props->rc.core.rc_codes)
 782                 props->rc.core.rc_codes = af9015_rc_setup_match(
 783                         (vid << 16) + pid, af9015_rc_setup_usbids);
 784
 785         /* try to load remote based USB iManufacturer string */
 786         if (!props->rc.core.rc_codes && vid == USB_VID_AFATECH) {
 787                 /* Check USB manufacturer and product strings and try
 788                    to determine correct remote in case of chip vendor
 789                    reference IDs are used.
 790                    DO NOT ADD ANYTHING NEW HERE. Use hashes instead. */
 791                 char manufacturer[10];
 792                 memset(manufacturer, 0, sizeof(manufacturer));
 793                 usb_string(udev, udev->descriptor.iManufacturer,
 794                         manufacturer, sizeof(manufacturer));
 795                 if (!strcmp("MSI", manufacturer)) {
 796                         /* iManufacturer 1 MSI
 797                            iProduct      2 MSI K-VOX */
 798                         props->rc.core.rc_codes = af9015_rc_setup_match(
 799                                 AF9015_REMOTE_MSI_DIGIVOX_MINI_II_V3,
 800                                 af9015_rc_setup_modparam);
 801                 }
 802         }
 803
 804         /* finally load "empty" just for leaving IR receiver enabled */
 805         if (!props->rc.core.rc_codes)
 806                 props->rc.core.rc_codes = RC_MAP_EMPTY;
 807
 808         return;
 809 }
 810
 811 static int af9015_read_config(struct usb_device *udev)
 812 {
 813         int ret;
 814         u8 val, i, offset = 0;
 815         struct req_t req = {READ_I2C, AF9015_I2C_EEPROM, 0, 0, 1, 1, &val};
 816
 817         /* IR remote controller */
 818         req.addr = AF9015_EEPROM_IR_MODE;
 819         /* first message will timeout often due to possible hw bug */
 820         for (i = 0; i < 4; i++) {
 821                 ret = af9015_rw_udev(udev, &req);
 822                 if (!ret)
 823                         break;
 824         }
 825         if (ret)
 826                 goto error;
 827
 828         ret = af9015_eeprom_hash(udev);
 829         if (ret)
 830                 goto error;
 831
 832         deb_info("%s: IR mode:%d\n", __func__, val);
 833         for (i = 0; i < af9015_properties_count; i++) {
 834                 if (val == AF9015_IR_MODE_DISABLED)
 835                         af9015_properties[i].rc.core.rc_codes = NULL;
 836                 else
 837                         af9015_set_remote_config(udev, &af9015_properties[i]);
 838         }
 839
 840         /* TS mode - one or two receivers */
 841         req.addr = AF9015_EEPROM_TS_MODE;
 842         ret = af9015_rw_udev(udev, &req);
 843         if (ret)
 844                 goto error;
 845         af9015_config.dual_mode = val;
 846         deb_info("%s: TS mode:%d\n", __func__, af9015_config.dual_mode);
 847
 848         /* Set adapter0 buffer size according to USB port speed, adapter1 buffer
 849            size can be static because it is enabled only USB2.0 */
 850         for (i = 0; i < af9015_properties_count; i++) {
 851                 /* USB1.1 set smaller buffersize and disable 2nd adapter */
 852                 if (udev->speed == USB_SPEED_FULL) {
 853                         af9015_properties[i].adapter[0].stream.u.bulk.buffersize
 854                                 = TS_USB11_FRAME_SIZE;
 855                         /* disable 2nd adapter because we don't have
 856                            PID-filters */
 857                         af9015_config.dual_mode = 0;
 858                 } else {
 859                         af9015_properties[i].adapter[0].stream.u.bulk.buffersize
 860                                 = TS_USB20_FRAME_SIZE;
 861                 }
 862         }
 863
 864         if (af9015_config.dual_mode) {
 865                 /* read 2nd demodulator I2C address */
 866                 req.addr = AF9015_EEPROM_DEMOD2_I2C;
 867                 ret = af9015_rw_udev(udev, &req);
 868                 if (ret)
 869                         goto error;
 870                 af9015_af9013_config[1].demod_address = val;
 871
 872                 /* enable 2nd adapter */
 873                 for (i = 0; i < af9015_properties_count; i++)
 874                         af9015_properties[i].num_adapters = 2;
 875
 876         } else {
 877                  /* disable 2nd adapter */
 878                 for (i = 0; i < af9015_properties_count; i++)
 879                         af9015_properties[i].num_adapters = 1;
 880         }
 881
 882         for (i = 0; i < af9015_properties[0].num_adapters; i++) {
 883                 if (i == 1)
 884                         offset = AF9015_EEPROM_OFFSET;
 885                 /* xtal */
 886                 req.addr = AF9015_EEPROM_XTAL_TYPE1 + offset;
 887                 ret = af9015_rw_udev(udev, &req);
 888                 if (ret)
 889                         goto error;
 890                 switch (val) {
 891                 case 0:
 892                         af9015_af9013_config[i].adc_clock = 28800;
 893                         break;
 894                 case 1:
 895                         af9015_af9013_config[i].adc_clock = 20480;
 896                         break;
 897                 case 2:
 898                         af9015_af9013_config[i].adc_clock = 28000;
 899                         break;
 900                 case 3:
 901                         af9015_af9013_config[i].adc_clock = 25000;
 902                         break;
 903                 };
 904                 deb_info("%s: [%d] xtal:%d set adc_clock:%d\n", __func__, i,
 905                         val, af9015_af9013_config[i].adc_clock);
 906
 907                 /* tuner IF */
 908                 req.addr = AF9015_EEPROM_IF1H + offset;
 909                 ret = af9015_rw_udev(udev, &req);
 910                 if (ret)
 911                         goto error;
 912                 af9015_af9013_config[i].tuner_if = val << 8;
 913                 req.addr = AF9015_EEPROM_IF1L + offset;
 914                 ret = af9015_rw_udev(udev, &req);
 915                 if (ret)
 916                         goto error;
 917                 af9015_af9013_config[i].tuner_if += val;
 918                 deb_info("%s: [%d] IF1:%d\n", __func__, i,
 919                         af9015_af9013_config[0].tuner_if);
 920
 921                 /* MT2060 IF1 */
 922                 req.addr = AF9015_EEPROM_MT2060_IF1H  + offset;
 923                 ret = af9015_rw_udev(udev, &req);
 924                 if (ret)
 925                         goto error;
 926                 af9015_config.mt2060_if1[i] = val << 8;
 927                 req.addr = AF9015_EEPROM_MT2060_IF1L + offset;
 928                 ret = af9015_rw_udev(udev, &req);
 929                 if (ret)
 930                         goto error;
 931                 af9015_config.mt2060_if1[i] += val;
 932                 deb_info("%s: [%d] MT2060 IF1:%d\n", __func__, i,
 933                         af9015_config.mt2060_if1[i]);
 934
 935                 /* tuner */
 936                 req.addr =  AF9015_EEPROM_TUNER_ID1 + offset;
 937                 ret = af9015_rw_udev(udev, &req);
 938                 if (ret)
 939                         goto error;
 940                 switch (val) {
 941                 case AF9013_TUNER_ENV77H11D5:
 942                 case AF9013_TUNER_MT2060:
 943                 case AF9013_TUNER_QT1010:
 944                 case AF9013_TUNER_UNKNOWN:
 945                 case AF9013_TUNER_MT2060_2:
 946                 case AF9013_TUNER_TDA18271:
 947                 case AF9013_TUNER_QT1010A:
 948                 case AF9013_TUNER_TDA18218:
 949                         af9015_af9013_config[i].rf_spec_inv = 1;
 950                         break;
 951                 case AF9013_TUNER_MXL5003D:
 952                 case AF9013_TUNER_MXL5005D:
 953                 case AF9013_TUNER_MXL5005R:
 954                 case AF9013_TUNER_MXL5007T:
 955                         af9015_af9013_config[i].rf_spec_inv = 0;
 956                         break;
 957                 case AF9013_TUNER_MC44S803:
 958                         af9015_af9013_config[i].gpio[1] = AF9013_GPIO_LO;
 959                         af9015_af9013_config[i].rf_spec_inv = 1;
 960                         break;
 961                 default:
 962                         warn("tuner id:%d not supported, please report!", val);
 963                         return -ENODEV;
 964                 };
 965
 966                 af9015_af9013_config[i].tuner = val;
 967                 deb_info("%s: [%d] tuner id:%d\n", __func__, i, val);
 968         }
 969
 970 error:
 971         if (ret)
 972                 err("eeprom read failed:%d", ret);
 973
 974         /* AverMedia AVerTV Volar Black HD (A850) device have bad EEPROM
 975            content :-( Override some wrong values here. Ditto for the
 976            AVerTV Red HD+ (A850T) device. */
 977         if (le16_to_cpu(udev->descriptor.idVendor) == USB_VID_AVERMEDIA &&
 978                 ((le16_to_cpu(udev->descriptor.idProduct) ==
 979                         USB_PID_AVERMEDIA_A850) ||
 980                 (le16_to_cpu(udev->descriptor.idProduct) ==
 981                         USB_PID_AVERMEDIA_A850T))) {
 982                 deb_info("%s: AverMedia A850: overriding config\n", __func__);
 983                 /* disable dual mode */
 984                 af9015_config.dual_mode = 0;
 985                  /* disable 2nd adapter */
 986                 for (i = 0; i < af9015_properties_count; i++)
 987                         af9015_properties[i].num_adapters = 1;
 988
 989                 /* set correct IF */
 990                 af9015_af9013_config[0].tuner_if = 4570;
 991         }
 992
 993         return ret;
 994 }
 995
 996 static int af9015_identify_state(struct usb_device *udev,
 997                                  struct dvb_usb_device_properties *props,
 998                                  struct dvb_usb_device_description **desc,
 999                                  int *cold)
1000 {
1001         int ret;
1002         u8 reply;
1003         struct req_t req = {GET_CONFIG, 0, 0, 0, 0, 1, &reply};
1004
1005         ret = af9015_rw_udev(udev, &req);
1006         if (ret)
1007                 return ret;
1008
1009         deb_info("%s: reply:%02x\n", __func__, reply);
1010         if (reply == 0x02)
1011                 *cold = 0;
1012         else
1013                 *cold = 1;
1014
1015         return ret;
1016 }
1017
1018 static int af9015_rc_query(struct dvb_usb_device *d)
1019 {
1020         struct af9015_state *priv = d->priv;
1021         int ret;
1022         u8 buf[17];
1023
1024         /* read registers needed to detect remote controller code */
1025         ret = af9015_read_regs(d, 0x98d9, buf, sizeof(buf));
1026         if (ret)
1027                 goto error;
1028
1029         /* If any of these are non-zero, assume invalid data */
1030         if (buf[1] || buf[2] || buf[3])
1031                 return ret;
1032
1033         /* Check for repeat of previous code */
1034         if ((priv->rc_repeat != buf[6] || buf[0]) &&
1035                                         !memcmp(&buf[12], priv->rc_last, 4)) {
1036                 deb_rc("%s: key repeated\n", __func__);
1037                 rc_keydown(d->rc_dev, priv->rc_keycode, 0);
1038                 priv->rc_repeat = buf[6];
1039                 return ret;
1040         }
1041
1042         /* Only process key if canary killed */
1043         if (buf[16] != 0xff && buf[0] != 0x01) {
1044                 deb_rc("%s: key pressed %02x %02x %02x %02x\n", __func__,
1045                         buf[12], buf[13], buf[14], buf[15]);
1046
1047                 /* Reset the canary */
1048                 ret = af9015_write_reg(d, 0x98e9, 0xff);
1049                 if (ret)
1050                         goto error;
1051
1052                 /* Remember this key */
1053                 memcpy(priv->rc_last, &buf[12], 4);
1054                 if (buf[14] == (u8) ~buf[15]) {
1055                         if (buf[12] == (u8) ~buf[13]) {
1056                                 /* NEC */
1057                                 priv->rc_keycode = buf[12] << 8 | buf[14];
1058                         } else {
1059                                 /* NEC extended*/
1060                                 priv->rc_keycode = buf[12] << 16 |
1061                                         buf[13] << 8 | buf[14];
1062                         }
1063                 } else {
1064                         /* 32 bit NEC */
1065                         priv->rc_keycode = buf[12] << 24 | buf[13] << 16 |
1066                                         buf[14] << 8 | buf[15];
1067                 }
1068                 rc_keydown(d->rc_dev, priv->rc_keycode, 0);
1069         } else {
1070                 deb_rc("%s: no key press\n", __func__);
1071                 /* Invalidate last keypress */
1072                 /* Not really needed, but helps with debug */
1073                 priv->rc_last[2] = priv->rc_last[3];
1074         }
1075
1076         priv->rc_repeat = buf[6];
1077
1078 error:
1079         if (ret)
1080                 err("%s: failed:%d", __func__, ret);
1081
1082         return ret;
1083 }
1084
1085 /* init 2nd I2C adapter */
1086 static int af9015_i2c_init(struct dvb_usb_device *d)
1087 {
1088         int ret;
1089         struct af9015_state *state = d->priv;
1090         deb_info("%s:\n", __func__);
1091
1092         strncpy(state->i2c_adap.name, d->desc->name,
1093                 sizeof(state->i2c_adap.name));
1094         state->i2c_adap.algo      = d->props.i2c_algo;
1095         state->i2c_adap.algo_data = NULL;
1096         state->i2c_adap.dev.parent = &d->udev->dev;
1097
1098         i2c_set_adapdata(&state->i2c_adap, d);
1099
1100         ret = i2c_add_adapter(&state->i2c_adap);
1101         if (ret < 0)
1102                 err("could not add i2c adapter");
1103
1104         return ret;
1105 }
1106
1107 static int af9015_af9013_frontend_attach(struct dvb_usb_adapter *adap)
1108 {
1109         int ret;
1110         struct af9015_state *state = adap->dev->priv;
1111         struct i2c_adapter *i2c_adap;
1112
1113         if (adap->id == 0) {
1114                 /* select I2C adapter */
1115                 i2c_adap = &adap->dev->i2c_adap;
1116
1117                 deb_info("%s: init I2C\n", __func__);
1118                 ret = af9015_i2c_init(adap->dev);
1119         } else {
1120                 /* select I2C adapter */
1121                 i2c_adap = &state->i2c_adap;
1122
1123                 /* copy firmware to 2nd demodulator */
1124                 if (af9015_config.dual_mode) {
1125                         ret = af9015_copy_firmware(adap->dev);
1126                         if (ret) {
1127                                 err("firmware copy to 2nd frontend " \
1128                                         "failed, will disable it");
1129                                 af9015_config.dual_mode = 0;
1130                                 return -ENODEV;
1131                         }
1132                 } else {
1133                         return -ENODEV;
1134                 }
1135         }
1136
1137         /* attach demodulator */
1138         adap->fe = dvb_attach(af9013_attach, &af9015_af9013_config[adap->id],
1139                 i2c_adap);
1140
1141         return adap->fe == NULL ? -ENODEV : 0;
1142 }
1143
1144 static struct mt2060_config af9015_mt2060_config = {
1145         .i2c_address = 0xc0,
1146         .clock_out = 0,
1147 };
1148
1149 static struct qt1010_config af9015_qt1010_config = {
1150         .i2c_address = 0xc4,
1151 };
1152
1153 static struct tda18271_config af9015_tda18271_config = {
1154         .gate = TDA18271_GATE_DIGITAL,
1155         .small_i2c = TDA18271_16_BYTE_CHUNK_INIT,
1156 };
1157
1158 static struct mxl5005s_config af9015_mxl5003_config = {
1159         .i2c_address     = 0xc6,
1160         .if_freq         = IF_FREQ_4570000HZ,
1161         .xtal_freq       = CRYSTAL_FREQ_16000000HZ,
1162         .agc_mode        = MXL_SINGLE_AGC,
1163         .tracking_filter = MXL_TF_DEFAULT,
1164         .rssi_enable     = MXL_RSSI_ENABLE,
1165         .cap_select      = MXL_CAP_SEL_ENABLE,
1166         .div_out         = MXL_DIV_OUT_4,
1167         .clock_out       = MXL_CLOCK_OUT_DISABLE,
1168         .output_load     = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
1169         .top             = MXL5005S_TOP_25P2,
1170         .mod_mode        = MXL_DIGITAL_MODE,
1171         .if_mode         = MXL_ZERO_IF,
1172         .AgcMasterByte   = 0x00,
1173 };
1174
1175 static struct mxl5005s_config af9015_mxl5005_config = {
1176         .i2c_address     = 0xc6,
1177         .if_freq         = IF_FREQ_4570000HZ,
1178         .xtal_freq       = CRYSTAL_FREQ_16000000HZ,
1179         .agc_mode        = MXL_SINGLE_AGC,
1180         .tracking_filter = MXL_TF_OFF,
1181         .rssi_enable     = MXL_RSSI_ENABLE,
1182         .cap_select      = MXL_CAP_SEL_ENABLE,
1183         .div_out         = MXL_DIV_OUT_4,
1184         .clock_out       = MXL_CLOCK_OUT_DISABLE,
1185         .output_load     = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
1186         .top             = MXL5005S_TOP_25P2,
1187         .mod_mode        = MXL_DIGITAL_MODE,
1188         .if_mode         = MXL_ZERO_IF,
1189         .AgcMasterByte   = 0x00,
1190 };
1191
1192 static struct mc44s803_config af9015_mc44s803_config = {
1193         .i2c_address = 0xc0,
1194         .dig_out = 1,
1195 };
1196
1197 static struct tda18218_config af9015_tda18218_config = {
1198         .i2c_address = 0xc0,
1199         .i2c_wr_max = 21, /* max wr bytes AF9015 I2C adap can handle at once */
1200 };
1201
1202 static struct mxl5007t_config af9015_mxl5007t_config = {
1203         .xtal_freq_hz = MxL_XTAL_24_MHZ,
1204         .if_freq_hz = MxL_IF_4_57_MHZ,
1205 };
1206
1207 static int af9015_tuner_attach(struct dvb_usb_adapter *adap)
1208 {
1209         struct af9015_state *state = adap->dev->priv;
1210         struct i2c_adapter *i2c_adap;
1211         int ret;
1212         deb_info("%s:\n", __func__);
1213
1214         /* select I2C adapter */
1215         if (adap->id == 0)
1216                 i2c_adap = &adap->dev->i2c_adap;
1217         else
1218                 i2c_adap = &state->i2c_adap;
1219
1220         switch (af9015_af9013_config[adap->id].tuner) {
1221         case AF9013_TUNER_MT2060:
1222         case AF9013_TUNER_MT2060_2:
1223                 ret = dvb_attach(mt2060_attach, adap->fe, i2c_adap,
1224                         &af9015_mt2060_config,
1225                         af9015_config.mt2060_if1[adap->id])
1226                         == NULL ? -ENODEV : 0;
1227                 break;
1228         case AF9013_TUNER_QT1010:
1229         case AF9013_TUNER_QT1010A:
1230                 ret = dvb_attach(qt1010_attach, adap->fe, i2c_adap,
1231                         &af9015_qt1010_config) == NULL ? -ENODEV : 0;
1232                 break;
1233         case AF9013_TUNER_TDA18271:
1234                 ret = dvb_attach(tda18271_attach, adap->fe, 0xc0, i2c_adap,
1235                         &af9015_tda18271_config) == NULL ? -ENODEV : 0;
1236                 break;
1237         case AF9013_TUNER_TDA18218:
1238                 ret = dvb_attach(tda18218_attach, adap->fe, i2c_adap,
1239                         &af9015_tda18218_config) == NULL ? -ENODEV : 0;
1240                 break;
1241         case AF9013_TUNER_MXL5003D:
1242                 ret = dvb_attach(mxl5005s_attach, adap->fe, i2c_adap,
1243                         &af9015_mxl5003_config) == NULL ? -ENODEV : 0;
1244                 break;
1245         case AF9013_TUNER_MXL5005D:
1246         case AF9013_TUNER_MXL5005R:
1247                 ret = dvb_attach(mxl5005s_attach, adap->fe, i2c_adap,
1248                         &af9015_mxl5005_config) == NULL ? -ENODEV : 0;
1249                 break;
1250         case AF9013_TUNER_ENV77H11D5:
1251                 ret = dvb_attach(dvb_pll_attach, adap->fe, 0xc0, i2c_adap,
1252                         DVB_PLL_TDA665X) == NULL ? -ENODEV : 0;
1253                 break;
1254         case AF9013_TUNER_MC44S803:
1255                 ret = dvb_attach(mc44s803_attach, adap->fe, i2c_adap,
1256                         &af9015_mc44s803_config) == NULL ? -ENODEV : 0;
1257                 break;
1258         case AF9013_TUNER_MXL5007T:
1259                 ret = dvb_attach(mxl5007t_attach, adap->fe, i2c_adap,
1260                         0xc0, &af9015_mxl5007t_config) == NULL ? -ENODEV : 0;
1261                 break;
1262         case AF9013_TUNER_UNKNOWN:
1263         default:
1264                 ret = -ENODEV;
1265                 err("Unknown tuner id:%d",
1266                         af9015_af9013_config[adap->id].tuner);
1267         }
1268         return ret;
1269 }
1270
1271 static struct usb_device_id af9015_usb_table[] = {
1272 /*  0 */{USB_DEVICE(USB_VID_AFATECH,   USB_PID_AFATECH_AF9015_9015)},
1273         {USB_DEVICE(USB_VID_AFATECH,   USB_PID_AFATECH_AF9015_9016)},
1274         {USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV_DONGLE_GOLD)},
1275         {USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV71E)},
1276         {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_KWORLD_399U)},
1277 /*  5 */{USB_DEVICE(USB_VID_VISIONPLUS,
1278                 USB_PID_TINYTWIN)},
1279         {USB_DEVICE(USB_VID_VISIONPLUS,
1280                 USB_PID_AZUREWAVE_AD_TU700)},
1281         {USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_T_USB_XE_REV2)},
1282         {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_KWORLD_PC160_2T)},
1283         {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_X)},
1284 /* 10 */{USB_DEVICE(USB_VID_XTENSIONS, USB_PID_XTENSIONS_XD_380)},
1285         {USB_DEVICE(USB_VID_MSI_2,     USB_PID_MSI_DIGIVOX_DUO)},
1286         {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_X_2)},
1287         {USB_DEVICE(USB_VID_TELESTAR,  USB_PID_TELESTAR_STARSTICK_2)},
1288         {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A309)},
1289 /* 15 */{USB_DEVICE(USB_VID_MSI_2,     USB_PID_MSI_DIGI_VOX_MINI_III)},
1290         {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_KWORLD_395U)},
1291         {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_KWORLD_395U_2)},
1292         {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_KWORLD_395U_3)},
1293         {USB_DEVICE(USB_VID_AFATECH,   USB_PID_TREKSTOR_DVBT)},
1294 /* 20 */{USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A850)},
1295         {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A805)},
1296         {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_CONCEPTRONIC_CTVDIGRCU)},
1297         {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_KWORLD_MC810)},
1298         {USB_DEVICE(USB_VID_KYE,       USB_PID_GENIUS_TVGO_DVB_T03)},
1299 /* 25 */{USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_KWORLD_399U_2)},
1300         {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_KWORLD_PC160_T)},
1301         {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_SVEON_STV20)},
1302         {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_TINYTWIN_2)},
1303         {USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV2000DS)},
1304 /* 30 */{USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_KWORLD_UB383_T)},
1305         {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_KWORLD_395U_4)},
1306         {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A815M)},
1307         {USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_T_STICK_RC)},
1308         {USB_DEVICE(USB_VID_TERRATEC,
1309                 USB_PID_TERRATEC_CINERGY_T_STICK_DUAL_RC)},
1310 /* 35 */{USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A850T)},
1311         {USB_DEVICE(USB_VID_GTEK,      USB_PID_TINYTWIN_3)},
1312         {0},
1313 };
1314 MODULE_DEVICE_TABLE(usb, af9015_usb_table);
1315
1316 #define AF9015_RC_INTERVAL 500
1317 static struct dvb_usb_device_properties af9015_properties[] = {
1318         {
1319                 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1320
1321                 .usb_ctrl = DEVICE_SPECIFIC,
1322                 .download_firmware = af9015_download_firmware,
1323                 .firmware = "dvb-usb-af9015.fw",
1324                 .no_reconnect = 1,
1325
1326                 .size_of_priv = sizeof(struct af9015_state),
1327
1328                 .num_adapters = 2,
1329                 .adapter = {
1330                         {
1331                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1332                                 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1333
1334                                 .pid_filter_count = 32,
1335                                 .pid_filter       = af9015_pid_filter,
1336                                 .pid_filter_ctrl  = af9015_pid_filter_ctrl,
1337
1338                                 .frontend_attach =
1339                                         af9015_af9013_frontend_attach,
1340                                 .tuner_attach    = af9015_tuner_attach,
1341                                 .stream = {
1342                                         .type = USB_BULK,
1343                                         .count = 6,
1344                                         .endpoint = 0x84,
1345                                 },
1346                         },
1347                         {
1348                                 .frontend_attach =
1349                                         af9015_af9013_frontend_attach,
1350                                 .tuner_attach    = af9015_tuner_attach,
1351                                 .stream = {
1352                                         .type = USB_BULK,
1353                                         .count = 6,
1354                                         .endpoint = 0x85,
1355                                         .u = {
1356                                                 .bulk = {
1357                                                         .buffersize =
1358                                                 TS_USB20_FRAME_SIZE,
1359                                                 }
1360                                         }
1361                                 },
1362                         }
1363                 },
1364
1365                 .identify_state = af9015_identify_state,
1366
1367                 .rc.core = {
1368                         .protocol         = RC_TYPE_NEC,
1369                         .module_name      = "af9015",
1370                         .rc_query         = af9015_rc_query,
1371                         .rc_interval      = AF9015_RC_INTERVAL,
1372                         .allowed_protos   = RC_TYPE_NEC,
1373                 },
1374
1375                 .i2c_algo = &af9015_i2c_algo,
1376
1377                 .num_device_descs = 12, /* check max from dvb-usb.h */
1378                 .devices = {
1379                         {
1380                                 .name = "Afatech AF9015 DVB-T USB2.0 stick",
1381                                 .cold_ids = {&af9015_usb_table[0],
1382                                              &af9015_usb_table[1], NULL},
1383                                 .warm_ids = {NULL},
1384                         },
1385                         {
1386                                 .name = "Leadtek WinFast DTV Dongle Gold",
1387                                 .cold_ids = {&af9015_usb_table[2], NULL},
1388                                 .warm_ids = {NULL},
1389                         },
1390                         {
1391                                 .name = "Pinnacle PCTV 71e",
1392                                 .cold_ids = {&af9015_usb_table[3], NULL},
1393                                 .warm_ids = {NULL},
1394                         },
1395                         {
1396                                 .name = "KWorld PlusTV Dual DVB-T Stick " \
1397                                         "(DVB-T 399U)",
1398                                 .cold_ids = {&af9015_usb_table[4],
1399                                              &af9015_usb_table[25], NULL},
1400                                 .warm_ids = {NULL},
1401                         },
1402                         {
1403                                 .name = "DigitalNow TinyTwin DVB-T Receiver",
1404                                 .cold_ids = {&af9015_usb_table[5],
1405                                              &af9015_usb_table[28],
1406                                              &af9015_usb_table[36], NULL},
1407                                 .warm_ids = {NULL},
1408                         },
1409                         {
1410                                 .name = "TwinHan AzureWave AD-TU700(704J)",
1411                                 .cold_ids = {&af9015_usb_table[6], NULL},
1412                                 .warm_ids = {NULL},
1413                         },
1414                         {
1415                                 .name = "TerraTec Cinergy T USB XE",
1416                                 .cold_ids = {&af9015_usb_table[7], NULL},
1417                                 .warm_ids = {NULL},
1418                         },
1419                         {
1420                                 .name = "KWorld PlusTV Dual DVB-T PCI " \
1421                                         "(DVB-T PC160-2T)",
1422                                 .cold_ids = {&af9015_usb_table[8], NULL},
1423                                 .warm_ids = {NULL},
1424                         },
1425                         {
1426                                 .name = "AVerMedia AVerTV DVB-T Volar X",
1427                                 .cold_ids = {&af9015_usb_table[9], NULL},
1428                                 .warm_ids = {NULL},
1429                         },
1430                         {
1431                                 .name = "TerraTec Cinergy T Stick RC",
1432                                 .cold_ids = {&af9015_usb_table[33], NULL},
1433                                 .warm_ids = {NULL},
1434                         },
1435                         {
1436                                 .name = "TerraTec Cinergy T Stick Dual RC",
1437                                 .cold_ids = {&af9015_usb_table[34], NULL},
1438                                 .warm_ids = {NULL},
1439                         },
1440                         {
1441                                 .name = "AverMedia AVerTV Red HD+ (A850T)",
1442                                 .cold_ids = {&af9015_usb_table[35], NULL},
1443                                 .warm_ids = {NULL},
1444                         },
1445                 }
1446         }, {
1447                 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1448
1449                 .usb_ctrl = DEVICE_SPECIFIC,
1450                 .download_firmware = af9015_download_firmware,
1451                 .firmware = "dvb-usb-af9015.fw",
1452                 .no_reconnect = 1,
1453
1454                 .size_of_priv = sizeof(struct af9015_state),
1455
1456                 .num_adapters = 2,
1457                 .adapter = {
1458                         {
1459                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1460                                 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1461
1462                                 .pid_filter_count = 32,
1463                                 .pid_filter       = af9015_pid_filter,
1464                                 .pid_filter_ctrl  = af9015_pid_filter_ctrl,
1465
1466                                 .frontend_attach =
1467                                         af9015_af9013_frontend_attach,
1468                                 .tuner_attach    = af9015_tuner_attach,
1469                                 .stream = {
1470                                         .type = USB_BULK,
1471                                         .count = 6,
1472                                         .endpoint = 0x84,
1473                                 },
1474                         },
1475                         {
1476                                 .frontend_attach =
1477                                         af9015_af9013_frontend_attach,
1478                                 .tuner_attach    = af9015_tuner_attach,
1479                                 .stream = {
1480                                         .type = USB_BULK,
1481                                         .count = 6,
1482                                         .endpoint = 0x85,
1483                                         .u = {
1484                                                 .bulk = {
1485                                                         .buffersize =
1486                                                 TS_USB20_FRAME_SIZE,
1487                                                 }
1488                                         }
1489                                 },
1490                         }
1491                 },
1492
1493                 .identify_state = af9015_identify_state,
1494
1495                 .rc.core = {
1496                         .protocol         = RC_TYPE_NEC,
1497                         .module_name      = "af9015",
1498                         .rc_query         = af9015_rc_query,
1499                         .rc_interval      = AF9015_RC_INTERVAL,
1500                         .allowed_protos   = RC_TYPE_NEC,
1501                 },
1502
1503                 .i2c_algo = &af9015_i2c_algo,
1504
1505                 .num_device_descs = 9, /* check max from dvb-usb.h */
1506                 .devices = {
1507                         {
1508                                 .name = "Xtensions XD-380",
1509                                 .cold_ids = {&af9015_usb_table[10], NULL},
1510                                 .warm_ids = {NULL},
1511                         },
1512                         {
1513                                 .name = "MSI DIGIVOX Duo",
1514                                 .cold_ids = {&af9015_usb_table[11], NULL},
1515                                 .warm_ids = {NULL},
1516                         },
1517                         {
1518                                 .name = "Fujitsu-Siemens Slim Mobile USB DVB-T",
1519                                 .cold_ids = {&af9015_usb_table[12], NULL},
1520                                 .warm_ids = {NULL},
1521                         },
1522                         {
1523                                 .name = "Telestar Starstick 2",
1524                                 .cold_ids = {&af9015_usb_table[13], NULL},
1525                                 .warm_ids = {NULL},
1526                         },
1527                         {
1528                                 .name = "AVerMedia A309",
1529                                 .cold_ids = {&af9015_usb_table[14], NULL},
1530                                 .warm_ids = {NULL},
1531                         },
1532                         {
1533                                 .name = "MSI Digi VOX mini III",
1534                                 .cold_ids = {&af9015_usb_table[15], NULL},
1535                                 .warm_ids = {NULL},
1536                         },
1537                         {
1538                                 .name = "KWorld USB DVB-T TV Stick II " \
1539                                         "(VS-DVB-T 395U)",
1540                                 .cold_ids = {&af9015_usb_table[16],
1541                                              &af9015_usb_table[17],
1542                                              &af9015_usb_table[18],
1543                                              &af9015_usb_table[31], NULL},
1544                                 .warm_ids = {NULL},
1545                         },
1546                         {
1547                                 .name = "TrekStor DVB-T USB Stick",
1548                                 .cold_ids = {&af9015_usb_table[19], NULL},
1549                                 .warm_ids = {NULL},
1550                         },
1551                         {
1552                                 .name = "AverMedia AVerTV Volar Black HD " \
1553                                         "(A850)",
1554                                 .cold_ids = {&af9015_usb_table[20], NULL},
1555                                 .warm_ids = {NULL},
1556                         },
1557                 }
1558         }, {
1559                 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1560
1561                 .usb_ctrl = DEVICE_SPECIFIC,
1562                 .download_firmware = af9015_download_firmware,
1563                 .firmware = "dvb-usb-af9015.fw",
1564                 .no_reconnect = 1,
1565
1566                 .size_of_priv = sizeof(struct af9015_state),
1567
1568                 .num_adapters = 2,
1569                 .adapter = {
1570                         {
1571                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1572                                 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1573
1574                                 .pid_filter_count = 32,
1575                                 .pid_filter       = af9015_pid_filter,
1576                                 .pid_filter_ctrl  = af9015_pid_filter_ctrl,
1577
1578                                 .frontend_attach =
1579                                         af9015_af9013_frontend_attach,
1580                                 .tuner_attach    = af9015_tuner_attach,
1581                                 .stream = {
1582                                         .type = USB_BULK,
1583                                         .count = 6,
1584                                         .endpoint = 0x84,
1585                                 },
1586                         },
1587                         {
1588                                 .frontend_attach =
1589                                         af9015_af9013_frontend_attach,
1590                                 .tuner_attach    = af9015_tuner_attach,
1591                                 .stream = {
1592                                         .type = USB_BULK,
1593                                         .count = 6,
1594                                         .endpoint = 0x85,
1595                                         .u = {
1596                                                 .bulk = {
1597                                                         .buffersize =
1598                                                 TS_USB20_FRAME_SIZE,
1599                                                 }
1600                                         }
1601                                 },
1602                         }
1603                 },
1604
1605                 .identify_state = af9015_identify_state,
1606
1607                 .rc.core = {
1608                         .protocol         = RC_TYPE_NEC,
1609                         .module_name      = "af9015",
1610                         .rc_query         = af9015_rc_query,
1611                         .rc_interval      = AF9015_RC_INTERVAL,
1612                         .allowed_protos   = RC_TYPE_NEC,
1613                 },
1614
1615                 .i2c_algo = &af9015_i2c_algo,
1616
1617                 .num_device_descs = 9, /* check max from dvb-usb.h */
1618                 .devices = {
1619                         {
1620                                 .name = "AverMedia AVerTV Volar GPS 805 (A805)",
1621                                 .cold_ids = {&af9015_usb_table[21], NULL},
1622                                 .warm_ids = {NULL},
1623                         },
1624                         {
1625                                 .name = "Conceptronic USB2.0 DVB-T CTVDIGRCU " \
1626                                         "V3.0",
1627                                 .cold_ids = {&af9015_usb_table[22], NULL},
1628                                 .warm_ids = {NULL},
1629                         },
1630                         {
1631                                 .name = "KWorld Digial MC-810",
1632                                 .cold_ids = {&af9015_usb_table[23], NULL},
1633                                 .warm_ids = {NULL},
1634                         },
1635                         {
1636                                 .name = "Genius TVGo DVB-T03",
1637                                 .cold_ids = {&af9015_usb_table[24], NULL},
1638                                 .warm_ids = {NULL},
1639                         },
1640                         {
1641                                 .name = "KWorld PlusTV DVB-T PCI Pro Card " \
1642                                         "(DVB-T PC160-T)",
1643                                 .cold_ids = {&af9015_usb_table[26], NULL},
1644                                 .warm_ids = {NULL},
1645                         },
1646                         {
1647                                 .name = "Sveon STV20 Tuner USB DVB-T HDTV",
1648                                 .cold_ids = {&af9015_usb_table[27], NULL},
1649                                 .warm_ids = {NULL},
1650                         },
1651                         {
1652                                 .name = "Leadtek WinFast DTV2000DS",
1653                                 .cold_ids = {&af9015_usb_table[29], NULL},
1654                                 .warm_ids = {NULL},
1655                         },
1656                         {
1657                                 .name = "KWorld USB DVB-T Stick Mobile " \
1658                                         "(UB383-T)",
1659                                 .cold_ids = {&af9015_usb_table[30], NULL},
1660                                 .warm_ids = {NULL},
1661                         },
1662                         {
1663                                 .name = "AverMedia AVerTV Volar M (A815Mac)",
1664                                 .cold_ids = {&af9015_usb_table[32], NULL},
1665                                 .warm_ids = {NULL},
1666                         },
1667                 }
1668         },
1669 };
1670
1671 static int af9015_usb_probe(struct usb_interface *intf,
1672                             const struct usb_device_id *id)
1673 {
1674         int ret = 0;
1675         struct dvb_usb_device *d = NULL;
1676         struct usb_device *udev = interface_to_usbdev(intf);
1677         u8 i;
1678
1679         deb_info("%s: interface:%d\n", __func__,
1680                 intf->cur_altsetting->desc.bInterfaceNumber);
1681
1682         /* interface 0 is used by DVB-T receiver and
1683            interface 1 is for remote controller (HID) */
1684         if (intf->cur_altsetting->desc.bInterfaceNumber == 0) {
1685                 ret = af9015_read_config(udev);
1686                 if (ret)
1687                         return ret;
1688
1689                 for (i = 0; i < af9015_properties_count; i++) {
1690                         ret = dvb_usb_device_init(intf, &af9015_properties[i],
1691                                 THIS_MODULE, &d, adapter_nr);
1692                         if (!ret)
1693                                 break;
1694                         if (ret != -ENODEV)
1695                                 return ret;
1696                 }
1697                 if (ret)
1698                         return ret;
1699
1700                 if (d)
1701                         ret = af9015_init(d);
1702         }
1703
1704         return ret;
1705 }
1706
1707 static void af9015_i2c_exit(struct dvb_usb_device *d)
1708 {
1709         struct af9015_state *state = d->priv;
1710         deb_info("%s:\n", __func__);
1711
1712         /* remove 2nd I2C adapter */
1713         if (d->state & DVB_USB_STATE_I2C)
1714                 i2c_del_adapter(&state->i2c_adap);
1715 }
1716
1717 static void af9015_usb_device_exit(struct usb_interface *intf)
1718 {
1719         struct dvb_usb_device *d = usb_get_intfdata(intf);
1720         deb_info("%s:\n", __func__);
1721
1722         /* remove 2nd I2C adapter */
1723         if (d != NULL && d->desc != NULL)
1724                 af9015_i2c_exit(d);
1725
1726         dvb_usb_device_exit(intf);
1727 }
1728
1729 /* usb specific object needed to register this driver with the usb subsystem */
1730 static struct usb_driver af9015_usb_driver = {
1731         .name = "dvb_usb_af9015",
1732         .probe = af9015_usb_probe,
1733         .disconnect = af9015_usb_device_exit,
1734         .id_table = af9015_usb_table,
1735 };
1736
1737 /* module stuff */
1738 static int __init af9015_usb_module_init(void)
1739 {
1740         int ret;
1741         ret = usb_register(&af9015_usb_driver);
1742         if (ret)
1743                 err("module init failed:%d", ret);
1744
1745         return ret;
1746 }
1747
1748 static void __exit af9015_usb_module_exit(void)
1749 {
1750         /* deregister this driver from the USB subsystem */
1751         usb_deregister(&af9015_usb_driver);
1752 }
1753
1754 module_init(af9015_usb_module_init);
1755 module_exit(af9015_usb_module_exit);
1756
1757 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1758 MODULE_DESCRIPTION("Driver for Afatech AF9015 DVB-T");
1759 MODULE_LICENSE("GPL");