1557 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * DVB USB Linux driver for Afatech AF9015 DVB-T USB2.0 receiver4 *5 * Copyright (C) 2007 Antti Palosaari <crope@iki.fi>6 *7 * Thanks to Afatech who kindly provided information.8 */9 10#include "af9015.h"11 12static int dvb_usb_af9015_remote;13module_param_named(remote, dvb_usb_af9015_remote, int, 0644);14MODULE_PARM_DESC(remote, "select remote");15DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);16 17static int af9015_ctrl_msg(struct dvb_usb_device *d, struct req_t *req)18{19#define REQ_HDR_LEN 8 /* send header size */20#define ACK_HDR_LEN 2 /* rece header size */21 struct af9015_state *state = d_to_priv(d);22 struct usb_interface *intf = d->intf;23 int ret, wlen, rlen;24 u8 write = 1;25 26 mutex_lock(&d->usb_mutex);27 28 state->buf[0] = req->cmd;29 state->buf[1] = state->seq++;30 state->buf[2] = req->i2c_addr << 1;31 state->buf[3] = req->addr >> 8;32 state->buf[4] = req->addr & 0xff;33 state->buf[5] = req->mbox;34 state->buf[6] = req->addr_len;35 state->buf[7] = req->data_len;36 37 switch (req->cmd) {38 case GET_CONFIG:39 case READ_MEMORY:40 case RECONNECT_USB:41 write = 0;42 break;43 case READ_I2C:44 write = 0;45 state->buf[2] |= 0x01; /* set I2C direction */46 fallthrough;47 case WRITE_I2C:48 state->buf[0] = READ_WRITE_I2C;49 break;50 case WRITE_MEMORY:51 if (((req->addr & 0xff00) == 0xff00) ||52 ((req->addr & 0xff00) == 0xae00))53 state->buf[0] = WRITE_VIRTUAL_MEMORY;54 break;55 case WRITE_VIRTUAL_MEMORY:56 case COPY_FIRMWARE:57 case DOWNLOAD_FIRMWARE:58 case BOOT:59 break;60 default:61 dev_err(&intf->dev, "unknown cmd %d\n", req->cmd);62 ret = -EIO;63 goto error;64 }65 66 /* Buffer overflow check */67 if ((write && (req->data_len > BUF_LEN - REQ_HDR_LEN)) ||68 (!write && (req->data_len > BUF_LEN - ACK_HDR_LEN))) {69 dev_err(&intf->dev, "too much data, cmd %u, len %u\n",70 req->cmd, req->data_len);71 ret = -EINVAL;72 goto error;73 }74 75 /*76 * Write receives seq + status = 2 bytes77 * Read receives seq + status + data = 2 + N bytes78 */79 wlen = REQ_HDR_LEN;80 rlen = ACK_HDR_LEN;81 if (write) {82 wlen += req->data_len;83 memcpy(&state->buf[REQ_HDR_LEN], req->data, req->data_len);84 } else {85 rlen += req->data_len;86 }87 88 /* no ack for these packets */89 if (req->cmd == DOWNLOAD_FIRMWARE || req->cmd == RECONNECT_USB)90 rlen = 0;91 92 ret = dvb_usbv2_generic_rw_locked(d, state->buf, wlen,93 state->buf, rlen);94 if (ret)95 goto error;96 97 /* check status */98 if (rlen && state->buf[1]) {99 dev_err(&intf->dev, "cmd failed %u\n", state->buf[1]);100 ret = -EIO;101 goto error;102 }103 104 /* read request, copy returned data to return buf */105 if (!write)106 memcpy(req->data, &state->buf[ACK_HDR_LEN], req->data_len);107error:108 mutex_unlock(&d->usb_mutex);109 110 return ret;111}112 113static int af9015_write_reg_i2c(struct dvb_usb_device *d, u8 addr, u16 reg,114 u8 val)115{116 struct af9015_state *state = d_to_priv(d);117 struct req_t req = {WRITE_I2C, addr, reg, 1, 1, 1, &val};118 119 if (addr == state->af9013_i2c_addr[0] ||120 addr == state->af9013_i2c_addr[1])121 req.addr_len = 3;122 123 return af9015_ctrl_msg(d, &req);124}125 126static int af9015_read_reg_i2c(struct dvb_usb_device *d, u8 addr, u16 reg,127 u8 *val)128{129 struct af9015_state *state = d_to_priv(d);130 struct req_t req = {READ_I2C, addr, reg, 0, 1, 1, val};131 132 if (addr == state->af9013_i2c_addr[0] ||133 addr == state->af9013_i2c_addr[1])134 req.addr_len = 3;135 136 return af9015_ctrl_msg(d, &req);137}138 139static int af9015_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],140 int num)141{142 struct dvb_usb_device *d = i2c_get_adapdata(adap);143 struct af9015_state *state = d_to_priv(d);144 struct usb_interface *intf = d->intf;145 int ret;146 u16 addr;147 u8 mbox, addr_len;148 struct req_t req;149 150 /*151 * I2C multiplexing:152 * There could be two tuners, both using same I2C address. Demodulator153 * I2C-gate is only possibility to select correct tuner.154 *155 * ...........................................156 * . AF9015 integrates AF9013 demodulator .157 * . ____________ ____________ . ____________158 * .| USB IF | | demod |. | tuner |159 * .|------------| |------------|. |------------|160 * .| AF9015 | | AF9013 |. | MXL5003 |161 * .| |--+--I2C-----|-----/ -----|.----I2C-----| |162 * .| | | | addr 0x1c |. | addr 0x63 |163 * .|____________| | |____________|. |____________|164 * .................|.........................165 * | ____________ ____________166 * | | demod | | tuner |167 * | |------------| |------------|168 * | | AF9013 | | MXL5003 |169 * +--I2C-----|-----/ -----|-----I2C-----| |170 * | addr 0x1d | | addr 0x63 |171 * |____________| |____________|172 */173 174 if (msg[0].len == 0 || msg[0].flags & I2C_M_RD) {175 addr = 0x0000;176 mbox = 0;177 addr_len = 0;178 } else if (msg[0].len == 1) {179 addr = msg[0].buf[0];180 mbox = 0;181 addr_len = 1;182 } else if (msg[0].len == 2) {183 addr = msg[0].buf[0] << 8 | msg[0].buf[1] << 0;184 mbox = 0;185 addr_len = 2;186 } else {187 addr = msg[0].buf[0] << 8 | msg[0].buf[1] << 0;188 mbox = msg[0].buf[2];189 addr_len = 3;190 }191 192 if (num == 1 && !(msg[0].flags & I2C_M_RD)) {193 /* i2c write */194 if (msg[0].len > 21) {195 ret = -EOPNOTSUPP;196 goto err;197 }198 if (msg[0].addr == state->af9013_i2c_addr[0])199 req.cmd = WRITE_MEMORY;200 else201 req.cmd = WRITE_I2C;202 req.i2c_addr = msg[0].addr;203 req.addr = addr;204 req.mbox = mbox;205 req.addr_len = addr_len;206 req.data_len = msg[0].len - addr_len;207 req.data = &msg[0].buf[addr_len];208 ret = af9015_ctrl_msg(d, &req);209 } else if (num == 2 && !(msg[0].flags & I2C_M_RD) &&210 (msg[1].flags & I2C_M_RD)) {211 /* i2c write + read */212 if (msg[0].len > 3 || msg[1].len > 61) {213 ret = -EOPNOTSUPP;214 goto err;215 }216 if (msg[0].addr == state->af9013_i2c_addr[0])217 req.cmd = READ_MEMORY;218 else219 req.cmd = READ_I2C;220 req.i2c_addr = msg[0].addr;221 req.addr = addr;222 req.mbox = mbox;223 req.addr_len = addr_len;224 req.data_len = msg[1].len;225 req.data = &msg[1].buf[0];226 ret = af9015_ctrl_msg(d, &req);227 } else if (num == 1 && (msg[0].flags & I2C_M_RD)) {228 /* i2c read */229 if (msg[0].len > 61) {230 ret = -EOPNOTSUPP;231 goto err;232 }233 if (msg[0].addr == state->af9013_i2c_addr[0]) {234 ret = -EINVAL;235 goto err;236 }237 req.cmd = READ_I2C;238 req.i2c_addr = msg[0].addr;239 req.addr = addr;240 req.mbox = mbox;241 req.addr_len = addr_len;242 req.data_len = msg[0].len;243 req.data = &msg[0].buf[0];244 ret = af9015_ctrl_msg(d, &req);245 } else {246 ret = -EOPNOTSUPP;247 dev_dbg(&intf->dev, "unknown msg, num %u\n", num);248 }249 if (ret)250 goto err;251 252 return num;253err:254 dev_dbg(&intf->dev, "failed %d\n", ret);255 return ret;256}257 258static u32 af9015_i2c_func(struct i2c_adapter *adapter)259{260 return I2C_FUNC_I2C;261}262 263static struct i2c_algorithm af9015_i2c_algo = {264 .master_xfer = af9015_i2c_xfer,265 .functionality = af9015_i2c_func,266};267 268static int af9015_identify_state(struct dvb_usb_device *d, const char **name)269{270 struct usb_interface *intf = d->intf;271 int ret;272 u8 reply;273 struct req_t req = {GET_CONFIG, 0, 0, 0, 0, 1, &reply};274 275 ret = af9015_ctrl_msg(d, &req);276 if (ret)277 return ret;278 279 dev_dbg(&intf->dev, "reply %02x\n", reply);280 281 if (reply == 0x02)282 ret = WARM;283 else284 ret = COLD;285 286 return ret;287}288 289static int af9015_download_firmware(struct dvb_usb_device *d,290 const struct firmware *firmware)291{292 struct af9015_state *state = d_to_priv(d);293 struct usb_interface *intf = d->intf;294 int ret, i, rem;295 struct req_t req = {DOWNLOAD_FIRMWARE, 0, 0, 0, 0, 0, NULL};296 u16 checksum;297 298 dev_dbg(&intf->dev, "\n");299 300 /* Calc checksum, we need it when copy firmware to slave demod */301 for (i = 0, checksum = 0; i < firmware->size; i++)302 checksum += firmware->data[i];303 304 state->firmware_size = firmware->size;305 state->firmware_checksum = checksum;306 307 #define LEN_MAX (BUF_LEN - REQ_HDR_LEN) /* Max payload size */308 for (rem = firmware->size; rem > 0; rem -= LEN_MAX) {309 req.data_len = min(LEN_MAX, rem);310 req.data = (u8 *)&firmware->data[firmware->size - rem];311 req.addr = 0x5100 + firmware->size - rem;312 ret = af9015_ctrl_msg(d, &req);313 if (ret) {314 dev_err(&intf->dev, "firmware download failed %d\n",315 ret);316 goto err;317 }318 }319 320 req.cmd = BOOT;321 req.data_len = 0;322 ret = af9015_ctrl_msg(d, &req);323 if (ret) {324 dev_err(&intf->dev, "firmware boot failed %d\n", ret);325 goto err;326 }327 328 return 0;329err:330 dev_dbg(&intf->dev, "failed %d\n", ret);331 return ret;332}333 334#define AF9015_EEPROM_SIZE 256335/* 2^31 + 2^29 - 2^25 + 2^22 - 2^19 - 2^16 + 1 */336#define GOLDEN_RATIO_PRIME_32 0x9e370001UL337 338/* hash (and dump) eeprom */339static int af9015_eeprom_hash(struct dvb_usb_device *d)340{341 struct af9015_state *state = d_to_priv(d);342 struct usb_interface *intf = d->intf;343 int ret, i;344 u8 buf[AF9015_EEPROM_SIZE];345 struct req_t req = {READ_I2C, AF9015_I2C_EEPROM, 0, 0, 1, 1, NULL};346 347 /* read eeprom */348 for (i = 0; i < AF9015_EEPROM_SIZE; i++) {349 req.addr = i;350 req.data = &buf[i];351 ret = af9015_ctrl_msg(d, &req);352 if (ret < 0)353 goto err;354 }355 356 /* calculate checksum */357 for (i = 0; i < AF9015_EEPROM_SIZE / sizeof(u32); i++) {358 state->eeprom_sum *= GOLDEN_RATIO_PRIME_32;359 state->eeprom_sum += le32_to_cpu(((__le32 *)buf)[i]);360 }361 362 for (i = 0; i < AF9015_EEPROM_SIZE; i += 16)363 dev_dbg(&intf->dev, "%*ph\n", 16, buf + i);364 365 dev_dbg(&intf->dev, "eeprom sum %.8x\n", state->eeprom_sum);366 return 0;367err:368 dev_dbg(&intf->dev, "failed %d\n", ret);369 return ret;370}371 372static int af9015_read_config(struct dvb_usb_device *d)373{374 struct af9015_state *state = d_to_priv(d);375 struct usb_interface *intf = d->intf;376 int ret;377 u8 val, i, offset = 0;378 struct req_t req = {READ_I2C, AF9015_I2C_EEPROM, 0, 0, 1, 1, &val};379 380 dev_dbg(&intf->dev, "\n");381 382 /* IR remote controller */383 req.addr = AF9015_EEPROM_IR_MODE;384 /* first message will timeout often due to possible hw bug */385 for (i = 0; i < 4; i++) {386 ret = af9015_ctrl_msg(d, &req);387 if (!ret)388 break;389 }390 if (ret)391 goto error;392 393 ret = af9015_eeprom_hash(d);394 if (ret)395 goto error;396 397 state->ir_mode = val;398 dev_dbg(&intf->dev, "ir mode %02x\n", val);399 400 /* TS mode - one or two receivers */401 req.addr = AF9015_EEPROM_TS_MODE;402 ret = af9015_ctrl_msg(d, &req);403 if (ret)404 goto error;405 406 state->dual_mode = val;407 dev_dbg(&intf->dev, "ts mode %02x\n", state->dual_mode);408 409 state->af9013_i2c_addr[0] = AF9015_I2C_DEMOD;410 411 if (state->dual_mode) {412 /* read 2nd demodulator I2C address */413 req.addr = AF9015_EEPROM_DEMOD2_I2C;414 ret = af9015_ctrl_msg(d, &req);415 if (ret)416 goto error;417 418 state->af9013_i2c_addr[1] = val >> 1;419 }420 421 for (i = 0; i < state->dual_mode + 1; i++) {422 if (i == 1)423 offset = AF9015_EEPROM_OFFSET;424 /* xtal */425 req.addr = AF9015_EEPROM_XTAL_TYPE1 + offset;426 ret = af9015_ctrl_msg(d, &req);427 if (ret)428 goto error;429 switch (val) {430 case 0:431 state->af9013_pdata[i].clk = 28800000;432 break;433 case 1:434 state->af9013_pdata[i].clk = 20480000;435 break;436 case 2:437 state->af9013_pdata[i].clk = 28000000;438 break;439 case 3:440 state->af9013_pdata[i].clk = 25000000;441 break;442 }443 dev_dbg(&intf->dev, "[%d] xtal %02x, clk %u\n",444 i, val, state->af9013_pdata[i].clk);445 446 /* IF frequency */447 req.addr = AF9015_EEPROM_IF1H + offset;448 ret = af9015_ctrl_msg(d, &req);449 if (ret)450 goto error;451 452 state->af9013_pdata[i].if_frequency = val << 8;453 454 req.addr = AF9015_EEPROM_IF1L + offset;455 ret = af9015_ctrl_msg(d, &req);456 if (ret)457 goto error;458 459 state->af9013_pdata[i].if_frequency += val;460 state->af9013_pdata[i].if_frequency *= 1000;461 dev_dbg(&intf->dev, "[%d] if frequency %u\n",462 i, state->af9013_pdata[i].if_frequency);463 464 /* MT2060 IF1 */465 req.addr = AF9015_EEPROM_MT2060_IF1H + offset;466 ret = af9015_ctrl_msg(d, &req);467 if (ret)468 goto error;469 state->mt2060_if1[i] = val << 8;470 req.addr = AF9015_EEPROM_MT2060_IF1L + offset;471 ret = af9015_ctrl_msg(d, &req);472 if (ret)473 goto error;474 state->mt2060_if1[i] += val;475 dev_dbg(&intf->dev, "[%d] MT2060 IF1 %u\n",476 i, state->mt2060_if1[i]);477 478 /* tuner */479 req.addr = AF9015_EEPROM_TUNER_ID1 + offset;480 ret = af9015_ctrl_msg(d, &req);481 if (ret)482 goto error;483 switch (val) {484 case AF9013_TUNER_ENV77H11D5:485 case AF9013_TUNER_MT2060:486 case AF9013_TUNER_QT1010:487 case AF9013_TUNER_UNKNOWN:488 case AF9013_TUNER_MT2060_2:489 case AF9013_TUNER_TDA18271:490 case AF9013_TUNER_QT1010A:491 case AF9013_TUNER_TDA18218:492 state->af9013_pdata[i].spec_inv = 1;493 break;494 case AF9013_TUNER_MXL5003D:495 case AF9013_TUNER_MXL5005D:496 case AF9013_TUNER_MXL5005R:497 case AF9013_TUNER_MXL5007T:498 state->af9013_pdata[i].spec_inv = 0;499 break;500 case AF9013_TUNER_MC44S803:501 state->af9013_pdata[i].gpio[1] = AF9013_GPIO_LO;502 state->af9013_pdata[i].spec_inv = 1;503 break;504 default:505 dev_err(&intf->dev,506 "tuner id %02x not supported, please report!\n",507 val);508 return -ENODEV;509 }510 511 state->af9013_pdata[i].tuner = val;512 dev_dbg(&intf->dev, "[%d] tuner id %02x\n", i, val);513 }514 515error:516 if (ret)517 dev_err(&intf->dev, "eeprom read failed %d\n", ret);518 519 /*520 * AverMedia AVerTV Volar Black HD (A850) device have bad EEPROM521 * content :-( Override some wrong values here. Ditto for the522 * AVerTV Red HD+ (A850T) device.523 */524 if (le16_to_cpu(d->udev->descriptor.idVendor) == USB_VID_AVERMEDIA &&525 ((le16_to_cpu(d->udev->descriptor.idProduct) == USB_PID_AVERMEDIA_A850) ||526 (le16_to_cpu(d->udev->descriptor.idProduct) == USB_PID_AVERMEDIA_A850T))) {527 dev_dbg(&intf->dev, "AverMedia A850: overriding config\n");528 /* disable dual mode */529 state->dual_mode = 0;530 531 /* set correct IF */532 state->af9013_pdata[0].if_frequency = 4570000;533 }534 535 return ret;536}537 538static int af9015_get_stream_config(struct dvb_frontend *fe, u8 *ts_type,539 struct usb_data_stream_properties *stream)540{541 struct dvb_usb_device *d = fe_to_d(fe);542 struct usb_interface *intf = d->intf;543 544 dev_dbg(&intf->dev, "adap %u\n", fe_to_adap(fe)->id);545 546 if (d->udev->speed == USB_SPEED_FULL)547 stream->u.bulk.buffersize = 5 * 188;548 549 return 0;550}551 552static int af9015_streaming_ctrl(struct dvb_frontend *fe, int onoff)553{554 struct dvb_usb_device *d = fe_to_d(fe);555 struct af9015_state *state = d_to_priv(d);556 struct usb_interface *intf = d->intf;557 int ret;558 unsigned int utmp1, utmp2, reg1, reg2;559 u8 buf[2];560 const unsigned int adap_id = fe_to_adap(fe)->id;561 562 dev_dbg(&intf->dev, "adap id %d, onoff %d\n", adap_id, onoff);563 564 if (!state->usb_ts_if_configured[adap_id]) {565 dev_dbg(&intf->dev, "set usb and ts interface\n");566 567 /* USB IF stream settings */568 utmp1 = (d->udev->speed == USB_SPEED_FULL ? 5 : 87) * 188 / 4;569 utmp2 = (d->udev->speed == USB_SPEED_FULL ? 64 : 512) / 4;570 571 buf[0] = (utmp1 >> 0) & 0xff;572 buf[1] = (utmp1 >> 8) & 0xff;573 if (adap_id == 0) {574 /* 1st USB IF (EP4) stream settings */575 reg1 = 0xdd88;576 reg2 = 0xdd0c;577 } else {578 /* 2nd USB IF (EP5) stream settings */579 reg1 = 0xdd8a;580 reg2 = 0xdd0d;581 }582 ret = regmap_bulk_write(state->regmap, reg1, buf, 2);583 if (ret)584 goto err;585 ret = regmap_write(state->regmap, reg2, utmp2);586 if (ret)587 goto err;588 589 /* TS IF settings */590 if (state->dual_mode) {591 utmp1 = 0x01;592 utmp2 = 0x10;593 } else {594 utmp1 = 0x00;595 utmp2 = 0x00;596 }597 ret = regmap_update_bits(state->regmap, 0xd50b, 0x01, utmp1);598 if (ret)599 goto err;600 ret = regmap_update_bits(state->regmap, 0xd520, 0x10, utmp2);601 if (ret)602 goto err;603 604 state->usb_ts_if_configured[adap_id] = true;605 }606 607 if (adap_id == 0 && onoff) {608 /* Adapter 0 stream on. EP4: clear NAK, enable, clear reset */609 ret = regmap_update_bits(state->regmap, 0xdd13, 0x20, 0x00);610 if (ret)611 goto err;612 ret = regmap_update_bits(state->regmap, 0xdd11, 0x20, 0x20);613 if (ret)614 goto err;615 ret = regmap_update_bits(state->regmap, 0xd507, 0x04, 0x00);616 if (ret)617 goto err;618 } else if (adap_id == 1 && onoff) {619 /* Adapter 1 stream on. EP5: clear NAK, enable, clear reset */620 ret = regmap_update_bits(state->regmap, 0xdd13, 0x40, 0x00);621 if (ret)622 goto err;623 ret = regmap_update_bits(state->regmap, 0xdd11, 0x40, 0x40);624 if (ret)625 goto err;626 ret = regmap_update_bits(state->regmap, 0xd50b, 0x02, 0x00);627 if (ret)628 goto err;629 } else if (adap_id == 0 && !onoff) {630 /* Adapter 0 stream off. EP4: set reset, disable, set NAK */631 ret = regmap_update_bits(state->regmap, 0xd507, 0x04, 0x04);632 if (ret)633 goto err;634 ret = regmap_update_bits(state->regmap, 0xdd11, 0x20, 0x00);635 if (ret)636 goto err;637 ret = regmap_update_bits(state->regmap, 0xdd13, 0x20, 0x20);638 if (ret)639 goto err;640 } else if (adap_id == 1 && !onoff) {641 /* Adapter 1 stream off. EP5: set reset, disable, set NAK */642 ret = regmap_update_bits(state->regmap, 0xd50b, 0x02, 0x02);643 if (ret)644 goto err;645 ret = regmap_update_bits(state->regmap, 0xdd11, 0x40, 0x00);646 if (ret)647 goto err;648 ret = regmap_update_bits(state->regmap, 0xdd13, 0x40, 0x40);649 if (ret)650 goto err;651 }652 653 return 0;654err:655 dev_dbg(&intf->dev, "failed %d\n", ret);656 return ret;657}658 659static int af9015_get_adapter_count(struct dvb_usb_device *d)660{661 struct af9015_state *state = d_to_priv(d);662 663 return state->dual_mode + 1;664}665 666/* override demod callbacks for resource locking */667static int af9015_af9013_set_frontend(struct dvb_frontend *fe)668{669 int ret;670 struct af9015_state *state = fe_to_priv(fe);671 672 if (mutex_lock_interruptible(&state->fe_mutex))673 return -EAGAIN;674 675 ret = state->set_frontend[fe_to_adap(fe)->id](fe);676 677 mutex_unlock(&state->fe_mutex);678 679 return ret;680}681 682/* override demod callbacks for resource locking */683static int af9015_af9013_read_status(struct dvb_frontend *fe,684 enum fe_status *status)685{686 int ret;687 struct af9015_state *state = fe_to_priv(fe);688 689 if (mutex_lock_interruptible(&state->fe_mutex))690 return -EAGAIN;691 692 ret = state->read_status[fe_to_adap(fe)->id](fe, status);693 694 mutex_unlock(&state->fe_mutex);695 696 return ret;697}698 699/* override demod callbacks for resource locking */700static int af9015_af9013_init(struct dvb_frontend *fe)701{702 int ret;703 struct af9015_state *state = fe_to_priv(fe);704 705 if (mutex_lock_interruptible(&state->fe_mutex))706 return -EAGAIN;707 708 ret = state->init[fe_to_adap(fe)->id](fe);709 710 mutex_unlock(&state->fe_mutex);711 712 return ret;713}714 715/* override demod callbacks for resource locking */716static int af9015_af9013_sleep(struct dvb_frontend *fe)717{718 int ret;719 struct af9015_state *state = fe_to_priv(fe);720 721 if (mutex_lock_interruptible(&state->fe_mutex))722 return -EAGAIN;723 724 ret = state->sleep[fe_to_adap(fe)->id](fe);725 726 mutex_unlock(&state->fe_mutex);727 728 return ret;729}730 731/* override tuner callbacks for resource locking */732static int af9015_tuner_init(struct dvb_frontend *fe)733{734 int ret;735 struct af9015_state *state = fe_to_priv(fe);736 737 if (mutex_lock_interruptible(&state->fe_mutex))738 return -EAGAIN;739 740 ret = state->tuner_init[fe_to_adap(fe)->id](fe);741 742 mutex_unlock(&state->fe_mutex);743 744 return ret;745}746 747/* override tuner callbacks for resource locking */748static int af9015_tuner_sleep(struct dvb_frontend *fe)749{750 int ret;751 struct af9015_state *state = fe_to_priv(fe);752 753 if (mutex_lock_interruptible(&state->fe_mutex))754 return -EAGAIN;755 756 ret = state->tuner_sleep[fe_to_adap(fe)->id](fe);757 758 mutex_unlock(&state->fe_mutex);759 760 return ret;761}762 763static int af9015_copy_firmware(struct dvb_usb_device *d)764{765 struct af9015_state *state = d_to_priv(d);766 struct usb_interface *intf = d->intf;767 int ret;768 unsigned long timeout;769 u8 val, firmware_info[4];770 struct req_t req = {COPY_FIRMWARE, 0, 0x5100, 0, 0, 4, firmware_info};771 772 dev_dbg(&intf->dev, "\n");773 774 firmware_info[0] = (state->firmware_size >> 8) & 0xff;775 firmware_info[1] = (state->firmware_size >> 0) & 0xff;776 firmware_info[2] = (state->firmware_checksum >> 8) & 0xff;777 firmware_info[3] = (state->firmware_checksum >> 0) & 0xff;778 779 /* Check whether firmware is already running */780 ret = af9015_read_reg_i2c(d, state->af9013_i2c_addr[1], 0x98be, &val);781 if (ret)782 goto err;783 784 dev_dbg(&intf->dev, "firmware status %02x\n", val);785 786 if (val == 0x0c)787 return 0;788 789 /* Set i2c clock to 625kHz to speed up firmware copy */790 ret = regmap_write(state->regmap, 0xd416, 0x04);791 if (ret)792 goto err;793 794 /* Copy firmware from master demod to slave demod */795 ret = af9015_ctrl_msg(d, &req);796 if (ret) {797 dev_err(&intf->dev, "firmware copy cmd failed %d\n", ret);798 goto err;799 }800 801 /* Set i2c clock to 125kHz */802 ret = regmap_write(state->regmap, 0xd416, 0x14);803 if (ret)804 goto err;805 806 /* Boot firmware */807 ret = af9015_write_reg_i2c(d, state->af9013_i2c_addr[1], 0xe205, 0x01);808 if (ret)809 goto err;810 811 /* Poll firmware ready */812 for (val = 0x00, timeout = jiffies + msecs_to_jiffies(1000);813 !time_after(jiffies, timeout) && val != 0x0c && val != 0x04;) {814 msleep(20);815 816 /* Check firmware status. 0c=OK, 04=fail */817 ret = af9015_read_reg_i2c(d, state->af9013_i2c_addr[1],818 0x98be, &val);819 if (ret)820 goto err;821 822 dev_dbg(&intf->dev, "firmware status %02x\n", val);823 }824 825 dev_dbg(&intf->dev, "firmware boot took %u ms\n",826 jiffies_to_msecs(jiffies) - (jiffies_to_msecs(timeout) - 1000));827 828 if (val == 0x04) {829 ret = -ENODEV;830 dev_err(&intf->dev, "firmware did not run\n");831 goto err;832 } else if (val != 0x0c) {833 ret = -ETIMEDOUT;834 dev_err(&intf->dev, "firmware boot timeout\n");835 goto err;836 }837 838 return 0;839err:840 dev_dbg(&intf->dev, "failed %d\n", ret);841 return ret;842}843 844static int af9015_af9013_frontend_attach(struct dvb_usb_adapter *adap)845{846 struct af9015_state *state = adap_to_priv(adap);847 struct dvb_usb_device *d = adap_to_d(adap);848 struct usb_interface *intf = d->intf;849 struct i2c_client *client;850 int ret;851 852 dev_dbg(&intf->dev, "adap id %u\n", adap->id);853 854 if (adap->id == 0) {855 state->af9013_pdata[0].ts_mode = AF9013_TS_MODE_USB;856 memcpy(state->af9013_pdata[0].api_version, "\x0\x1\x9\x0", 4);857 state->af9013_pdata[0].gpio[0] = AF9013_GPIO_HI;858 state->af9013_pdata[0].gpio[3] = AF9013_GPIO_TUNER_ON;859 } else if (adap->id == 1) {860 state->af9013_pdata[1].ts_mode = AF9013_TS_MODE_SERIAL;861 state->af9013_pdata[1].ts_output_pin = 7;862 memcpy(state->af9013_pdata[1].api_version, "\x0\x1\x9\x0", 4);863 state->af9013_pdata[1].gpio[0] = AF9013_GPIO_TUNER_ON;864 state->af9013_pdata[1].gpio[1] = AF9013_GPIO_LO;865 866 /* copy firmware to 2nd demodulator */867 if (state->dual_mode) {868 /* Wait 2nd demodulator ready */869 msleep(100);870 871 ret = af9015_copy_firmware(adap_to_d(adap));872 if (ret) {873 dev_err(&intf->dev,874 "firmware copy to 2nd frontend failed, will disable it\n");875 state->dual_mode = 0;876 goto err;877 }878 } else {879 ret = -ENODEV;880 goto err;881 }882 }883 884 /* Add I2C demod */885 client = dvb_module_probe("af9013", NULL, &d->i2c_adap,886 state->af9013_i2c_addr[adap->id],887 &state->af9013_pdata[adap->id]);888 if (!client) {889 ret = -ENODEV;890 goto err;891 }892 adap->fe[0] = state->af9013_pdata[adap->id].get_dvb_frontend(client);893 state->demod_i2c_client[adap->id] = client;894 895 /*896 * AF9015 firmware does not like if it gets interrupted by I2C adapter897 * request on some critical phases. During normal operation I2C adapter898 * is used only 2nd demodulator and tuner on dual tuner devices.899 * Override demodulator callbacks and use mutex for limit access to900 * those "critical" paths to keep AF9015 happy.901 */902 if (adap->fe[0]) {903 state->set_frontend[adap->id] = adap->fe[0]->ops.set_frontend;904 adap->fe[0]->ops.set_frontend = af9015_af9013_set_frontend;905 state->read_status[adap->id] = adap->fe[0]->ops.read_status;906 adap->fe[0]->ops.read_status = af9015_af9013_read_status;907 state->init[adap->id] = adap->fe[0]->ops.init;908 adap->fe[0]->ops.init = af9015_af9013_init;909 state->sleep[adap->id] = adap->fe[0]->ops.sleep;910 adap->fe[0]->ops.sleep = af9015_af9013_sleep;911 }912 913 return 0;914err:915 dev_dbg(&intf->dev, "failed %d\n", ret);916 return ret;917}918 919static int af9015_frontend_detach(struct dvb_usb_adapter *adap)920{921 struct af9015_state *state = adap_to_priv(adap);922 struct dvb_usb_device *d = adap_to_d(adap);923 struct usb_interface *intf = d->intf;924 struct i2c_client *client;925 926 dev_dbg(&intf->dev, "adap id %u\n", adap->id);927 928 /* Remove I2C demod */929 client = state->demod_i2c_client[adap->id];930 dvb_module_release(client);931 932 return 0;933}934 935static struct mt2060_config af9015_mt2060_config = {936 .i2c_address = 0x60,937 .clock_out = 0,938};939 940static struct qt1010_config af9015_qt1010_config = {941 .i2c_address = 0x62,942};943 944static struct tda18271_config af9015_tda18271_config = {945 .gate = TDA18271_GATE_DIGITAL,946 .small_i2c = TDA18271_16_BYTE_CHUNK_INIT,947};948 949static struct mxl5005s_config af9015_mxl5003_config = {950 .i2c_address = 0x63,951 .if_freq = IF_FREQ_4570000HZ,952 .xtal_freq = CRYSTAL_FREQ_16000000HZ,953 .agc_mode = MXL_SINGLE_AGC,954 .tracking_filter = MXL_TF_DEFAULT,955 .rssi_enable = MXL_RSSI_ENABLE,956 .cap_select = MXL_CAP_SEL_ENABLE,957 .div_out = MXL_DIV_OUT_4,958 .clock_out = MXL_CLOCK_OUT_DISABLE,959 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM,960 .top = MXL5005S_TOP_25P2,961 .mod_mode = MXL_DIGITAL_MODE,962 .if_mode = MXL_ZERO_IF,963 .AgcMasterByte = 0x00,964};965 966static struct mxl5005s_config af9015_mxl5005_config = {967 .i2c_address = 0x63,968 .if_freq = IF_FREQ_4570000HZ,969 .xtal_freq = CRYSTAL_FREQ_16000000HZ,970 .agc_mode = MXL_SINGLE_AGC,971 .tracking_filter = MXL_TF_OFF,972 .rssi_enable = MXL_RSSI_ENABLE,973 .cap_select = MXL_CAP_SEL_ENABLE,974 .div_out = MXL_DIV_OUT_4,975 .clock_out = MXL_CLOCK_OUT_DISABLE,976 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM,977 .top = MXL5005S_TOP_25P2,978 .mod_mode = MXL_DIGITAL_MODE,979 .if_mode = MXL_ZERO_IF,980 .AgcMasterByte = 0x00,981};982 983static struct mc44s803_config af9015_mc44s803_config = {984 .i2c_address = 0x60,985 .dig_out = 1,986};987 988static struct tda18218_config af9015_tda18218_config = {989 .i2c_address = 0x60,990 .i2c_wr_max = 21, /* max wr bytes AF9015 I2C adap can handle at once */991};992 993static struct mxl5007t_config af9015_mxl5007t_config = {994 .xtal_freq_hz = MxL_XTAL_24_MHZ,995 .if_freq_hz = MxL_IF_4_57_MHZ,996};997 998static int af9015_tuner_attach(struct dvb_usb_adapter *adap)999{1000 struct dvb_usb_device *d = adap_to_d(adap);1001 struct af9015_state *state = d_to_priv(d);1002 struct usb_interface *intf = d->intf;1003 struct i2c_client *client;1004 struct i2c_adapter *adapter;1005 int ret;1006 1007 dev_dbg(&intf->dev, "adap id %u\n", adap->id);1008 1009 client = state->demod_i2c_client[adap->id];1010 adapter = state->af9013_pdata[adap->id].get_i2c_adapter(client);1011 1012 switch (state->af9013_pdata[adap->id].tuner) {1013 case AF9013_TUNER_MT2060:1014 case AF9013_TUNER_MT2060_2:1015 ret = dvb_attach(mt2060_attach, adap->fe[0], adapter,1016 &af9015_mt2060_config,1017 state->mt2060_if1[adap->id]) == NULL ? -ENODEV : 0;1018 break;1019 case AF9013_TUNER_QT1010:1020 case AF9013_TUNER_QT1010A:1021 ret = dvb_attach(qt1010_attach, adap->fe[0], adapter,1022 &af9015_qt1010_config) == NULL ? -ENODEV : 0;1023 break;1024 case AF9013_TUNER_TDA18271:1025 ret = dvb_attach(tda18271_attach, adap->fe[0], 0x60, adapter,1026 &af9015_tda18271_config) == NULL ? -ENODEV : 0;1027 break;1028 case AF9013_TUNER_TDA18218:1029 ret = dvb_attach(tda18218_attach, adap->fe[0], adapter,1030 &af9015_tda18218_config) == NULL ? -ENODEV : 0;1031 break;1032 case AF9013_TUNER_MXL5003D:1033 ret = dvb_attach(mxl5005s_attach, adap->fe[0], adapter,1034 &af9015_mxl5003_config) == NULL ? -ENODEV : 0;1035 break;1036 case AF9013_TUNER_MXL5005D:1037 case AF9013_TUNER_MXL5005R:1038 ret = dvb_attach(mxl5005s_attach, adap->fe[0], adapter,1039 &af9015_mxl5005_config) == NULL ? -ENODEV : 0;1040 break;1041 case AF9013_TUNER_ENV77H11D5:1042 ret = dvb_attach(dvb_pll_attach, adap->fe[0], 0x60, adapter,1043 DVB_PLL_TDA665X) == NULL ? -ENODEV : 0;1044 break;1045 case AF9013_TUNER_MC44S803:1046 ret = dvb_attach(mc44s803_attach, adap->fe[0], adapter,1047 &af9015_mc44s803_config) == NULL ? -ENODEV : 0;1048 break;1049 case AF9013_TUNER_MXL5007T:1050 ret = dvb_attach(mxl5007t_attach, adap->fe[0], adapter,1051 0x60, &af9015_mxl5007t_config) == NULL ? -ENODEV : 0;1052 break;1053 case AF9013_TUNER_UNKNOWN:1054 default:1055 dev_err(&intf->dev, "unknown tuner, tuner id %02x\n",1056 state->af9013_pdata[adap->id].tuner);1057 ret = -ENODEV;1058 }1059 1060 if (adap->fe[0]->ops.tuner_ops.init) {1061 state->tuner_init[adap->id] =1062 adap->fe[0]->ops.tuner_ops.init;1063 adap->fe[0]->ops.tuner_ops.init = af9015_tuner_init;1064 }1065 1066 if (adap->fe[0]->ops.tuner_ops.sleep) {1067 state->tuner_sleep[adap->id] =1068 adap->fe[0]->ops.tuner_ops.sleep;1069 adap->fe[0]->ops.tuner_ops.sleep = af9015_tuner_sleep;1070 }1071 1072 return ret;1073}1074 1075static int af9015_pid_filter_ctrl(struct dvb_usb_adapter *adap, int onoff)1076{1077 struct af9015_state *state = adap_to_priv(adap);1078 struct af9013_platform_data *pdata = &state->af9013_pdata[adap->id];1079 int ret;1080 1081 mutex_lock(&state->fe_mutex);1082 ret = pdata->pid_filter_ctrl(adap->fe[0], onoff);1083 mutex_unlock(&state->fe_mutex);1084 1085 return ret;1086}1087 1088static int af9015_pid_filter(struct dvb_usb_adapter *adap, int index,1089 u16 pid, int onoff)1090{1091 struct af9015_state *state = adap_to_priv(adap);1092 struct af9013_platform_data *pdata = &state->af9013_pdata[adap->id];1093 int ret;1094 1095 mutex_lock(&state->fe_mutex);1096 ret = pdata->pid_filter(adap->fe[0], index, pid, onoff);1097 mutex_unlock(&state->fe_mutex);1098 1099 return ret;1100}1101 1102static int af9015_init(struct dvb_usb_device *d)1103{1104 struct af9015_state *state = d_to_priv(d);1105 struct usb_interface *intf = d->intf;1106 int ret;1107 1108 dev_dbg(&intf->dev, "\n");1109 1110 mutex_init(&state->fe_mutex);1111 1112 /* init RC canary */1113 ret = regmap_write(state->regmap, 0x98e9, 0xff);1114 if (ret)1115 goto error;1116 1117error:1118 return ret;1119}1120 1121#if IS_ENABLED(CONFIG_RC_CORE)1122struct af9015_rc_setup {1123 unsigned int id;1124 char *rc_codes;1125};1126 1127static char *af9015_rc_setup_match(unsigned int id,1128 const struct af9015_rc_setup *table)1129{1130 for (; table->rc_codes; table++)1131 if (table->id == id)1132 return table->rc_codes;1133 return NULL;1134}1135 1136static const struct af9015_rc_setup af9015_rc_setup_modparam[] = {1137 { AF9015_REMOTE_A_LINK_DTU_M, RC_MAP_ALINK_DTU_M },1138 { AF9015_REMOTE_MSI_DIGIVOX_MINI_II_V3, RC_MAP_MSI_DIGIVOX_II },1139 { AF9015_REMOTE_MYGICTV_U718, RC_MAP_TOTAL_MEDIA_IN_HAND },1140 { AF9015_REMOTE_DIGITTRADE_DVB_T, RC_MAP_DIGITTRADE },1141 { AF9015_REMOTE_AVERMEDIA_KS, RC_MAP_AVERMEDIA_RM_KS },1142 { }1143};1144 1145static const struct af9015_rc_setup af9015_rc_setup_hashes[] = {1146 { 0xb8feb708, RC_MAP_MSI_DIGIVOX_II },1147 { 0xa3703d00, RC_MAP_ALINK_DTU_M },1148 { 0x9b7dc64e, RC_MAP_TOTAL_MEDIA_IN_HAND }, /* MYGICTV U718 */1149 { 0x5d49e3db, RC_MAP_DIGITTRADE }, /* LC-Power LC-USB-DVBT */1150 { }1151};1152 1153static int af9015_rc_query(struct dvb_usb_device *d)1154{1155 struct af9015_state *state = d_to_priv(d);1156 struct usb_interface *intf = d->intf;1157 int ret;1158 u8 buf[17];1159 1160 /* read registers needed to detect remote controller code */1161 ret = regmap_bulk_read(state->regmap, 0x98d9, buf, sizeof(buf));1162 if (ret)1163 goto error;1164 1165 /* If any of these are non-zero, assume invalid data */1166 if (buf[1] || buf[2] || buf[3]) {1167 dev_dbg(&intf->dev, "invalid data\n");1168 return 0;1169 }1170 1171 /* Check for repeat of previous code */1172 if ((state->rc_repeat != buf[6] || buf[0]) &&1173 !memcmp(&buf[12], state->rc_last, 4)) {1174 dev_dbg(&intf->dev, "key repeated\n");1175 rc_repeat(d->rc_dev);1176 state->rc_repeat = buf[6];1177 return 0;1178 }1179 1180 /* Only process key if canary killed */1181 if (buf[16] != 0xff && buf[0] != 0x01) {1182 enum rc_proto proto;1183 1184 dev_dbg(&intf->dev, "key pressed %*ph\n", 4, buf + 12);1185 1186 /* Reset the canary */1187 ret = regmap_write(state->regmap, 0x98e9, 0xff);1188 if (ret)1189 goto error;1190 1191 /* Remember this key */1192 memcpy(state->rc_last, &buf[12], 4);1193 if (buf[14] == (u8)~buf[15]) {1194 if (buf[12] == (u8)~buf[13]) {1195 /* NEC */1196 state->rc_keycode = RC_SCANCODE_NEC(buf[12],1197 buf[14]);1198 proto = RC_PROTO_NEC;1199 } else {1200 /* NEC extended*/1201 state->rc_keycode = RC_SCANCODE_NECX(buf[12] << 8 |1202 buf[13],1203 buf[14]);1204 proto = RC_PROTO_NECX;1205 }1206 } else {1207 /* 32 bit NEC */1208 state->rc_keycode = RC_SCANCODE_NEC32(buf[12] << 24 |1209 buf[13] << 16 |1210 buf[14] << 8 |1211 buf[15]);1212 proto = RC_PROTO_NEC32;1213 }1214 rc_keydown(d->rc_dev, proto, state->rc_keycode, 0);1215 } else {1216 dev_dbg(&intf->dev, "no key press\n");1217 /* Invalidate last keypress */1218 /* Not really needed, but helps with debug */1219 state->rc_last[2] = state->rc_last[3];1220 }1221 1222 state->rc_repeat = buf[6];1223 state->rc_failed = false;1224 1225error:1226 if (ret) {1227 dev_warn(&intf->dev, "rc query failed %d\n", ret);1228 1229 /* allow random errors as dvb-usb will stop polling on error */1230 if (!state->rc_failed)1231 ret = 0;1232 1233 state->rc_failed = true;1234 }1235 1236 return ret;1237}1238 1239static int af9015_get_rc_config(struct dvb_usb_device *d, struct dvb_usb_rc *rc)1240{1241 struct af9015_state *state = d_to_priv(d);1242 u16 vid = le16_to_cpu(d->udev->descriptor.idVendor);1243 1244 if (state->ir_mode == AF9015_IR_MODE_DISABLED)1245 return 0;1246 1247 /* try to load remote based module param */1248 if (!rc->map_name)1249 rc->map_name = af9015_rc_setup_match(dvb_usb_af9015_remote,1250 af9015_rc_setup_modparam);1251 1252 /* try to load remote based eeprom hash */1253 if (!rc->map_name)1254 rc->map_name = af9015_rc_setup_match(state->eeprom_sum,1255 af9015_rc_setup_hashes);1256 1257 /* try to load remote based USB iManufacturer string */1258 if (!rc->map_name && vid == USB_VID_AFATECH) {1259 /*1260 * Check USB manufacturer and product strings and try1261 * to determine correct remote in case of chip vendor1262 * reference IDs are used.1263 * DO NOT ADD ANYTHING NEW HERE. Use hashes instead.1264 */1265 char manufacturer[10];1266 1267 memset(manufacturer, 0, sizeof(manufacturer));1268 usb_string(d->udev, d->udev->descriptor.iManufacturer,1269 manufacturer, sizeof(manufacturer));1270 if (!strcmp("MSI", manufacturer)) {1271 /*1272 * iManufacturer 1 MSI1273 * iProduct 2 MSI K-VOX1274 */1275 rc->map_name = af9015_rc_setup_match(AF9015_REMOTE_MSI_DIGIVOX_MINI_II_V3,1276 af9015_rc_setup_modparam);1277 }1278 }1279 1280 /* load empty to enable rc */1281 if (!rc->map_name)1282 rc->map_name = RC_MAP_EMPTY;1283 1284 rc->allowed_protos = RC_PROTO_BIT_NEC | RC_PROTO_BIT_NECX |1285 RC_PROTO_BIT_NEC32;1286 rc->query = af9015_rc_query;1287 rc->interval = 500;1288 1289 return 0;1290}1291#else1292 #define af9015_get_rc_config NULL1293#endif1294 1295static int af9015_regmap_write(void *context, const void *data, size_t count)1296{1297 struct dvb_usb_device *d = context;1298 struct usb_interface *intf = d->intf;1299 int ret;1300 u16 reg = ((u8 *)data)[0] << 8 | ((u8 *)data)[1] << 0;1301 u8 *val = &((u8 *)data)[2];1302 const unsigned int len = count - 2;1303 struct req_t req = {WRITE_MEMORY, 0, reg, 0, 0, len, val};1304 1305 ret = af9015_ctrl_msg(d, &req);1306 if (ret)1307 goto err;1308 1309 return 0;1310err:1311 dev_dbg(&intf->dev, "failed %d\n", ret);1312 return ret;1313}1314 1315static int af9015_regmap_read(void *context, const void *reg_buf,1316 size_t reg_size, void *val_buf, size_t val_size)1317{1318 struct dvb_usb_device *d = context;1319 struct usb_interface *intf = d->intf;1320 int ret;1321 u16 reg = ((u8 *)reg_buf)[0] << 8 | ((u8 *)reg_buf)[1] << 0;1322 u8 *val = &((u8 *)val_buf)[0];1323 const unsigned int len = val_size;1324 struct req_t req = {READ_MEMORY, 0, reg, 0, 0, len, val};1325 1326 ret = af9015_ctrl_msg(d, &req);1327 if (ret)1328 goto err;1329 1330 return 0;1331err:1332 dev_dbg(&intf->dev, "failed %d\n", ret);1333 return ret;1334}1335 1336static int af9015_probe(struct dvb_usb_device *d)1337{1338 struct af9015_state *state = d_to_priv(d);1339 struct usb_interface *intf = d->intf;1340 struct usb_device *udev = interface_to_usbdev(intf);1341 int ret;1342 char manufacturer[sizeof("ITE Technologies, Inc.")];1343 static const struct regmap_config regmap_config = {1344 .reg_bits = 16,1345 .val_bits = 8,1346 };1347 static const struct regmap_bus regmap_bus = {1348 .read = af9015_regmap_read,1349 .write = af9015_regmap_write,1350 };1351 1352 dev_dbg(&intf->dev, "\n");1353 1354 memset(manufacturer, 0, sizeof(manufacturer));1355 usb_string(udev, udev->descriptor.iManufacturer,1356 manufacturer, sizeof(manufacturer));1357 /*1358 * There is two devices having same ID but different chipset. One uses1359 * AF9015 and the other IT9135 chipset. Only difference seen on lsusb1360 * is iManufacturer string.1361 *1362 * idVendor 0x0ccd TerraTec Electronic GmbH1363 * idProduct 0x00991364 * bcdDevice 2.001365 * iManufacturer 1 Afatech1366 * iProduct 2 DVB-T 21367 *1368 * idVendor 0x0ccd TerraTec Electronic GmbH1369 * idProduct 0x00991370 * bcdDevice 2.001371 * iManufacturer 1 ITE Technologies, Inc.1372 * iProduct 2 DVB-T TV Stick1373 */1374 if ((le16_to_cpu(udev->descriptor.idVendor) == USB_VID_TERRATEC) &&1375 (le16_to_cpu(udev->descriptor.idProduct) == 0x0099)) {1376 if (!strcmp("ITE Technologies, Inc.", manufacturer)) {1377 ret = -ENODEV;1378 dev_dbg(&intf->dev, "rejecting device\n");1379 goto err;1380 }1381 }1382 1383 state->regmap = regmap_init(&intf->dev, ®map_bus, d, ®map_config);1384 if (IS_ERR(state->regmap)) {1385 ret = PTR_ERR(state->regmap);1386 goto err;1387 }1388 1389 return 0;1390err:1391 dev_dbg(&intf->dev, "failed %d\n", ret);1392 return ret;1393}1394 1395static void af9015_disconnect(struct dvb_usb_device *d)1396{1397 struct af9015_state *state = d_to_priv(d);1398 struct usb_interface *intf = d->intf;1399 1400 dev_dbg(&intf->dev, "\n");1401 1402 regmap_exit(state->regmap);1403}1404 1405/*1406 * Interface 0 is used by DVB-T receiver and1407 * interface 1 is for remote controller (HID)1408 */1409static const struct dvb_usb_device_properties af9015_props = {1410 .driver_name = KBUILD_MODNAME,1411 .owner = THIS_MODULE,1412 .adapter_nr = adapter_nr,1413 .size_of_priv = sizeof(struct af9015_state),1414 1415 .generic_bulk_ctrl_endpoint = 0x02,1416 .generic_bulk_ctrl_endpoint_response = 0x81,1417 1418 .probe = af9015_probe,1419 .disconnect = af9015_disconnect,1420 .identify_state = af9015_identify_state,1421 .firmware = AF9015_FIRMWARE,1422 .download_firmware = af9015_download_firmware,1423 1424 .i2c_algo = &af9015_i2c_algo,1425 .read_config = af9015_read_config,1426 .frontend_attach = af9015_af9013_frontend_attach,1427 .frontend_detach = af9015_frontend_detach,1428 .tuner_attach = af9015_tuner_attach,1429 .init = af9015_init,1430 .get_rc_config = af9015_get_rc_config,1431 .get_stream_config = af9015_get_stream_config,1432 .streaming_ctrl = af9015_streaming_ctrl,1433 1434 .get_adapter_count = af9015_get_adapter_count,1435 .adapter = {1436 {1437 .caps = DVB_USB_ADAP_HAS_PID_FILTER |1438 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,1439 .pid_filter_count = 32,1440 .pid_filter = af9015_pid_filter,1441 .pid_filter_ctrl = af9015_pid_filter_ctrl,1442 1443 .stream = DVB_USB_STREAM_BULK(0x84, 6, 87 * 188),1444 }, {1445 .caps = DVB_USB_ADAP_HAS_PID_FILTER |1446 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,1447 .pid_filter_count = 32,1448 .pid_filter = af9015_pid_filter,1449 .pid_filter_ctrl = af9015_pid_filter_ctrl,1450 1451 .stream = DVB_USB_STREAM_BULK(0x85, 6, 87 * 188),1452 },1453 },1454};1455 1456static const struct usb_device_id af9015_id_table[] = {1457 { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9015_9015,1458 &af9015_props, "Afatech AF9015 reference design", NULL) },1459 { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9015_9016,1460 &af9015_props, "Afatech AF9015 reference design", NULL) },1461 { DVB_USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV_DONGLE_GOLD,1462 &af9015_props, "Leadtek WinFast DTV Dongle Gold", RC_MAP_LEADTEK_Y04G0051) },1463 { DVB_USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV71E,1464 &af9015_props, "Pinnacle PCTV 71e", NULL) },1465 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_399U,1466 &af9015_props, "KWorld PlusTV Dual DVB-T Stick (DVB-T 399U)", NULL) },1467 { DVB_USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_TINYTWIN,1468 &af9015_props, "DigitalNow TinyTwin", RC_MAP_AZUREWAVE_AD_TU700) },1469 { DVB_USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_AZUREWAVE_AD_TU700,1470 &af9015_props, "TwinHan AzureWave AD-TU700(704J)", RC_MAP_AZUREWAVE_AD_TU700) },1471 { DVB_USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_USB_XE_REV2,1472 &af9015_props, "TerraTec Cinergy T USB XE", NULL) },1473 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_PC160_2T,1474 &af9015_props, "KWorld PlusTV Dual DVB-T PCI (DVB-T PC160-2T)", NULL) },1475 { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_X,1476 &af9015_props, "AVerMedia AVerTV DVB-T Volar X", RC_MAP_AVERMEDIA_M135A) },1477 { DVB_USB_DEVICE(USB_VID_XTENSIONS, USB_PID_XTENSIONS_XD_380,1478 &af9015_props, "Xtensions XD-380", NULL) },1479 { DVB_USB_DEVICE(USB_VID_MSI_2, USB_PID_MSI_DIGIVOX_DUO,1480 &af9015_props, "MSI DIGIVOX Duo", RC_MAP_MSI_DIGIVOX_III) },1481 { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_X_2,1482 &af9015_props, "Fujitsu-Siemens Slim Mobile USB DVB-T", NULL) },1483 { DVB_USB_DEVICE(USB_VID_TELESTAR, USB_PID_TELESTAR_STARSTICK_2,1484 &af9015_props, "Telestar Starstick 2", NULL) },1485 { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A309,1486 &af9015_props, "AVerMedia A309", NULL) },1487 { DVB_USB_DEVICE(USB_VID_MSI_2, USB_PID_MSI_DIGI_VOX_MINI_III,1488 &af9015_props, "MSI Digi VOX mini III", RC_MAP_MSI_DIGIVOX_III) },1489 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U,1490 &af9015_props, "KWorld USB DVB-T TV Stick II (VS-DVB-T 395U)", NULL) },1491 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U_2,1492 &af9015_props, "KWorld USB DVB-T TV Stick II (VS-DVB-T 395U)", NULL) },1493 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U_3,1494 &af9015_props, "KWorld USB DVB-T TV Stick II (VS-DVB-T 395U)", NULL) },1495 { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_TREKSTOR_DVBT,1496 &af9015_props, "TrekStor DVB-T USB Stick", RC_MAP_TREKSTOR) },1497 { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A850,1498 &af9015_props, "AverMedia AVerTV Volar Black HD (A850)", NULL) },1499 { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A805,1500 &af9015_props, "AverMedia AVerTV Volar GPS 805 (A805)", NULL) },1501 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_CONCEPTRONIC_CTVDIGRCU,1502 &af9015_props, "Conceptronic USB2.0 DVB-T CTVDIGRCU V3.0", NULL) },1503 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_MC810,1504 &af9015_props, "KWorld Digital MC-810", NULL) },1505 { DVB_USB_DEVICE(USB_VID_KYE, USB_PID_GENIUS_TVGO_DVB_T03,1506 &af9015_props, "Genius TVGo DVB-T03", NULL) },1507 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_399U_2,1508 &af9015_props, "KWorld PlusTV Dual DVB-T Stick (DVB-T 399U)", NULL) },1509 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_PC160_T,1510 &af9015_props, "KWorld PlusTV DVB-T PCI Pro Card (DVB-T PC160-T)", NULL) },1511 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_SVEON_STV20,1512 &af9015_props, "Sveon STV20 Tuner USB DVB-T HDTV", NULL) },1513 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_TINYTWIN_2,1514 &af9015_props, "DigitalNow TinyTwin v2", RC_MAP_DIGITALNOW_TINYTWIN) },1515 { DVB_USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV2000DS,1516 &af9015_props, "Leadtek WinFast DTV2000DS", RC_MAP_LEADTEK_Y04G0051) },1517 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_UB383_T,1518 &af9015_props, "KWorld USB DVB-T Stick Mobile (UB383-T)", NULL) },1519 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U_4,1520 &af9015_props, "KWorld USB DVB-T TV Stick II (VS-DVB-T 395U)", NULL) },1521 { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A815M,1522 &af9015_props, "AverMedia AVerTV Volar M (A815Mac)", NULL) },1523 { DVB_USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_STICK_RC,1524 &af9015_props, "TerraTec Cinergy T Stick RC", RC_MAP_TERRATEC_SLIM_2) },1525 /* XXX: that same ID [0ccd:0099] is used by af9035 driver too */1526 { DVB_USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_STICK_DUAL_RC,1527 &af9015_props, "TerraTec Cinergy T Stick Dual RC", RC_MAP_TERRATEC_SLIM) },1528 { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A850T,1529 &af9015_props, "AverMedia AVerTV Red HD+ (A850T)", NULL) },1530 { DVB_USB_DEVICE(USB_VID_GTEK, USB_PID_TINYTWIN_3,1531 &af9015_props, "DigitalNow TinyTwin v3", RC_MAP_DIGITALNOW_TINYTWIN) },1532 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_SVEON_STV22,1533 &af9015_props, "Sveon STV22 Dual USB DVB-T Tuner HDTV", RC_MAP_MSI_DIGIVOX_III) },1534 { }1535};1536MODULE_DEVICE_TABLE(usb, af9015_id_table);1537 1538/* usb specific object needed to register this driver with the usb subsystem */1539static struct usb_driver af9015_usb_driver = {1540 .name = KBUILD_MODNAME,1541 .id_table = af9015_id_table,1542 .probe = dvb_usbv2_probe,1543 .disconnect = dvb_usbv2_disconnect,1544 .suspend = dvb_usbv2_suspend,1545 .resume = dvb_usbv2_resume,1546 .reset_resume = dvb_usbv2_reset_resume,1547 .no_dynamic_id = 1,1548 .soft_unbind = 1,1549};1550 1551module_usb_driver(af9015_usb_driver);1552 1553MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");1554MODULE_DESCRIPTION("Afatech AF9015 driver");1555MODULE_LICENSE("GPL");1556MODULE_FIRMWARE(AF9015_FIRMWARE);1557