1 /* DVB USB compliant Linux driver for the Afatech 9005 2 * USB1.1 DVB-T receiver. 3 * 4 * Copyright (C) 2007 Luca Olivetti (luca@ventoso.org) 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 * see Documentation/media/dvb-drivers/dvb-usb.rst for more information 19 */ 20 #include "af9005.h" 21 22 /* debug */ 23 int dvb_usb_af9005_debug; 24 module_param_named(debug, dvb_usb_af9005_debug, int, 0644); 25 MODULE_PARM_DESC(debug, 26 "set debugging level (1=info,xfer=2,rc=4,reg=8,i2c=16,fw=32 (or-able))." 27 DVB_USB_DEBUG_STATUS); 28 /* enable obnoxious led */ 29 bool dvb_usb_af9005_led = true; 30 module_param_named(led, dvb_usb_af9005_led, bool, 0644); 31 MODULE_PARM_DESC(led, "enable led (default: 1)."); 32 33 /* eeprom dump */ 34 static int dvb_usb_af9005_dump_eeprom; 35 module_param_named(dump_eeprom, dvb_usb_af9005_dump_eeprom, int, 0); 36 MODULE_PARM_DESC(dump_eeprom, "dump contents of the eeprom."); 37 38 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); 39 40 /* remote control decoder */ 41 static int (*rc_decode) (struct dvb_usb_device *d, u8 *data, int len, 42 u32 *event, int *state); 43 static void *rc_keys; 44 static int *rc_keys_size; 45 46 u8 regmask[8] = { 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff }; 47 48 struct af9005_device_state { 49 u8 sequence; 50 int led_state; 51 unsigned char data[256]; 52 }; 53 54 static int af9005_generic_read_write(struct dvb_usb_device *d, u16 reg, 55 int readwrite, int type, u8 * values, int len) 56 { 57 struct af9005_device_state *st = d->priv; 58 u8 command, seq; 59 int i, ret; 60 61 if (len < 1) { 62 err("generic read/write, less than 1 byte. Makes no sense."); 63 return -EINVAL; 64 } 65 if (len > 8) { 66 err("generic read/write, more than 8 bytes. Not supported."); 67 return -EINVAL; 68 } 69 70 mutex_lock(&d->data_mutex); 71 st->data[0] = 14; /* rest of buffer length low */ 72 st->data[1] = 0; /* rest of buffer length high */ 73 74 st->data[2] = AF9005_REGISTER_RW; /* register operation */ 75 st->data[3] = 12; /* rest of buffer length */ 76 77 st->data[4] = seq = st->sequence++; /* sequence number */ 78 79 st->data[5] = (u8) (reg >> 8); /* register address */ 80 st->data[6] = (u8) (reg & 0xff); 81 82 if (type == AF9005_OFDM_REG) { 83 command = AF9005_CMD_OFDM_REG; 84 } else { 85 command = AF9005_CMD_TUNER; 86 } 87 88 if (len > 1) 89 command |= 90 AF9005_CMD_BURST | AF9005_CMD_AUTOINC | (len - 1) << 3; 91 command |= readwrite; 92 if (readwrite == AF9005_CMD_WRITE) 93 for (i = 0; i < len; i++) 94 st->data[8 + i] = values[i]; 95 else if (type == AF9005_TUNER_REG) 96 /* read command for tuner, the first byte contains the i2c address */ 97 st->data[8] = values[0]; 98 st->data[7] = command; 99 100 ret = dvb_usb_generic_rw(d, st->data, 16, st->data, 17, 0); 101 if (ret) 102 goto ret; 103 104 /* sanity check */ 105 if (st->data[2] != AF9005_REGISTER_RW_ACK) { 106 err("generic read/write, wrong reply code."); 107 ret = -EIO; 108 goto ret; 109 } 110 if (st->data[3] != 0x0d) { 111 err("generic read/write, wrong length in reply."); 112 ret = -EIO; 113 goto ret; 114 } 115 if (st->data[4] != seq) { 116 err("generic read/write, wrong sequence in reply."); 117 ret = -EIO; 118 goto ret; 119 } 120 /* 121 * In thesis, both input and output buffers should have 122 * identical values for st->data[5] to st->data[8]. 123 * However, windows driver doesn't check these fields, in fact 124 * sometimes the register in the reply is different that what 125 * has been sent 126 */ 127 if (st->data[16] != 0x01) { 128 err("generic read/write wrong status code in reply."); 129 ret = -EIO; 130 goto ret; 131 } 132 133 if (readwrite == AF9005_CMD_READ) 134 for (i = 0; i < len; i++) 135 values[i] = st->data[8 + i]; 136 137 ret: 138 mutex_unlock(&d->data_mutex); 139 return ret; 140 141 } 142 143 int af9005_read_ofdm_register(struct dvb_usb_device *d, u16 reg, u8 * value) 144 { 145 int ret; 146 deb_reg("read register %x ", reg); 147 ret = af9005_generic_read_write(d, reg, 148 AF9005_CMD_READ, AF9005_OFDM_REG, 149 value, 1); 150 if (ret) 151 deb_reg("failed\n"); 152 else 153 deb_reg("value %x\n", *value); 154 return ret; 155 } 156 157 int af9005_read_ofdm_registers(struct dvb_usb_device *d, u16 reg, 158 u8 * values, int len) 159 { 160 int ret; 161 deb_reg("read %d registers %x ", len, reg); 162 ret = af9005_generic_read_write(d, reg, 163 AF9005_CMD_READ, AF9005_OFDM_REG, 164 values, len); 165 if (ret) 166 deb_reg("failed\n"); 167 else 168 debug_dump(values, len, deb_reg); 169 return ret; 170 } 171 172 int af9005_write_ofdm_register(struct dvb_usb_device *d, u16 reg, u8 value) 173 { 174 int ret; 175 u8 temp = value; 176 deb_reg("write register %x value %x ", reg, value); 177 ret = af9005_generic_read_write(d, reg, 178 AF9005_CMD_WRITE, AF9005_OFDM_REG, 179 &temp, 1); 180 if (ret) 181 deb_reg("failed\n"); 182 else 183 deb_reg("ok\n"); 184 return ret; 185 } 186 187 int af9005_write_ofdm_registers(struct dvb_usb_device *d, u16 reg, 188 u8 * values, int len) 189 { 190 int ret; 191 deb_reg("write %d registers %x values ", len, reg); 192 debug_dump(values, len, deb_reg); 193 194 ret = af9005_generic_read_write(d, reg, 195 AF9005_CMD_WRITE, AF9005_OFDM_REG, 196 values, len); 197 if (ret) 198 deb_reg("failed\n"); 199 else 200 deb_reg("ok\n"); 201 return ret; 202 } 203 204 int af9005_read_register_bits(struct dvb_usb_device *d, u16 reg, u8 pos, 205 u8 len, u8 * value) 206 { 207 u8 temp; 208 int ret; 209 deb_reg("read bits %x %x %x", reg, pos, len); 210 ret = af9005_read_ofdm_register(d, reg, &temp); 211 if (ret) { 212 deb_reg(" failed\n"); 213 return ret; 214 } 215 *value = (temp >> pos) & regmask[len - 1]; 216 deb_reg(" value %x\n", *value); 217 return 0; 218 219 } 220 221 int af9005_write_register_bits(struct dvb_usb_device *d, u16 reg, u8 pos, 222 u8 len, u8 value) 223 { 224 u8 temp, mask; 225 int ret; 226 deb_reg("write bits %x %x %x value %x\n", reg, pos, len, value); 227 if (pos == 0 && len == 8) 228 return af9005_write_ofdm_register(d, reg, value); 229 ret = af9005_read_ofdm_register(d, reg, &temp); 230 if (ret) 231 return ret; 232 mask = regmask[len - 1] << pos; 233 temp = (temp & ~mask) | ((value << pos) & mask); 234 return af9005_write_ofdm_register(d, reg, temp); 235 236 } 237 238 static int af9005_usb_read_tuner_registers(struct dvb_usb_device *d, 239 u16 reg, u8 * values, int len) 240 { 241 return af9005_generic_read_write(d, reg, 242 AF9005_CMD_READ, AF9005_TUNER_REG, 243 values, len); 244 } 245 246 static int af9005_usb_write_tuner_registers(struct dvb_usb_device *d, 247 u16 reg, u8 * values, int len) 248 { 249 return af9005_generic_read_write(d, reg, 250 AF9005_CMD_WRITE, 251 AF9005_TUNER_REG, values, len); 252 } 253 254 int af9005_write_tuner_registers(struct dvb_usb_device *d, u16 reg, 255 u8 * values, int len) 256 { 257 /* don't let the name of this function mislead you: it's just used 258 as an interface from the firmware to the i2c bus. The actual 259 i2c addresses are contained in the data */ 260 int ret, i, done = 0, fail = 0; 261 u8 temp; 262 ret = af9005_usb_write_tuner_registers(d, reg, values, len); 263 if (ret) 264 return ret; 265 if (reg != 0xffff) { 266 /* check if write done (0xa40d bit 1) or fail (0xa40d bit 2) */ 267 for (i = 0; i < 200; i++) { 268 ret = 269 af9005_read_ofdm_register(d, 270 xd_I2C_i2c_m_status_wdat_done, 271 &temp); 272 if (ret) 273 return ret; 274 done = temp & (regmask[i2c_m_status_wdat_done_len - 1] 275 << i2c_m_status_wdat_done_pos); 276 if (done) 277 break; 278 fail = temp & (regmask[i2c_m_status_wdat_fail_len - 1] 279 << i2c_m_status_wdat_fail_pos); 280 if (fail) 281 break; 282 msleep(50); 283 } 284 if (i == 200) 285 return -ETIMEDOUT; 286 if (fail) { 287 /* clear write fail bit */ 288 af9005_write_register_bits(d, 289 xd_I2C_i2c_m_status_wdat_fail, 290 i2c_m_status_wdat_fail_pos, 291 i2c_m_status_wdat_fail_len, 292 1); 293 return -EIO; 294 } 295 /* clear write done bit */ 296 ret = 297 af9005_write_register_bits(d, 298 xd_I2C_i2c_m_status_wdat_fail, 299 i2c_m_status_wdat_done_pos, 300 i2c_m_status_wdat_done_len, 1); 301 if (ret) 302 return ret; 303 } 304 return 0; 305 } 306 307 int af9005_read_tuner_registers(struct dvb_usb_device *d, u16 reg, u8 addr, 308 u8 * values, int len) 309 { 310 /* don't let the name of this function mislead you: it's just used 311 as an interface from the firmware to the i2c bus. The actual 312 i2c addresses are contained in the data */ 313 int ret, i; 314 u8 temp, buf[2]; 315 316 buf[0] = addr; /* tuner i2c address */ 317 buf[1] = values[0]; /* tuner register */ 318 319 values[0] = addr + 0x01; /* i2c read address */ 320 321 if (reg == APO_REG_I2C_RW_SILICON_TUNER) { 322 /* write tuner i2c address to tuner, 0c00c0 undocumented, found by sniffing */ 323 ret = af9005_write_tuner_registers(d, 0x00c0, buf, 2); 324 if (ret) 325 return ret; 326 } 327 328 /* send read command to ofsm */ 329 ret = af9005_usb_read_tuner_registers(d, reg, values, 1); 330 if (ret) 331 return ret; 332 333 /* check if read done */ 334 for (i = 0; i < 200; i++) { 335 ret = af9005_read_ofdm_register(d, 0xa408, &temp); 336 if (ret) 337 return ret; 338 if (temp & 0x01) 339 break; 340 msleep(50); 341 } 342 if (i == 200) 343 return -ETIMEDOUT; 344 345 /* clear read done bit (by writing 1) */ 346 ret = af9005_write_ofdm_register(d, xd_I2C_i2c_m_data8, 1); 347 if (ret) 348 return ret; 349 350 /* get read data (available from 0xa400) */ 351 for (i = 0; i < len; i++) { 352 ret = af9005_read_ofdm_register(d, 0xa400 + i, &temp); 353 if (ret) 354 return ret; 355 values[i] = temp; 356 } 357 return 0; 358 } 359 360 static int af9005_i2c_write(struct dvb_usb_device *d, u8 i2caddr, u8 reg, 361 u8 * data, int len) 362 { 363 int ret, i; 364 u8 buf[3]; 365 deb_i2c("i2c_write i2caddr %x, reg %x, len %d data ", i2caddr, 366 reg, len); 367 debug_dump(data, len, deb_i2c); 368 369 for (i = 0; i < len; i++) { 370 buf[0] = i2caddr; 371 buf[1] = reg + (u8) i; 372 buf[2] = data[i]; 373 ret = 374 af9005_write_tuner_registers(d, 375 APO_REG_I2C_RW_SILICON_TUNER, 376 buf, 3); 377 if (ret) { 378 deb_i2c("i2c_write failed\n"); 379 return ret; 380 } 381 } 382 deb_i2c("i2c_write ok\n"); 383 return 0; 384 } 385 386 static int af9005_i2c_read(struct dvb_usb_device *d, u8 i2caddr, u8 reg, 387 u8 * data, int len) 388 { 389 int ret, i; 390 u8 temp; 391 deb_i2c("i2c_read i2caddr %x, reg %x, len %d\n ", i2caddr, reg, len); 392 for (i = 0; i < len; i++) { 393 temp = reg + i; 394 ret = 395 af9005_read_tuner_registers(d, 396 APO_REG_I2C_RW_SILICON_TUNER, 397 i2caddr, &temp, 1); 398 if (ret) { 399 deb_i2c("i2c_read failed\n"); 400 return ret; 401 } 402 data[i] = temp; 403 } 404 deb_i2c("i2c data read: "); 405 debug_dump(data, len, deb_i2c); 406 return 0; 407 } 408 409 static int af9005_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[], 410 int num) 411 { 412 /* only implements what the mt2060 module does, don't know how 413 to make it really generic */ 414 struct dvb_usb_device *d = i2c_get_adapdata(adap); 415 int ret; 416 u8 reg, addr; 417 u8 *value; 418 419 if (mutex_lock_interruptible(&d->i2c_mutex) < 0) 420 return -EAGAIN; 421 422 if (num > 2) 423 warn("more than 2 i2c messages at a time is not handled yet. TODO."); 424 425 if (num == 2) { 426 /* reads a single register */ 427 reg = *msg[0].buf; 428 addr = msg[0].addr; 429 value = msg[1].buf; 430 ret = af9005_i2c_read(d, addr, reg, value, 1); 431 if (ret == 0) 432 ret = 2; 433 } else { 434 /* write one or more registers */ 435 reg = msg[0].buf[0]; 436 addr = msg[0].addr; 437 value = &msg[0].buf[1]; 438 ret = af9005_i2c_write(d, addr, reg, value, msg[0].len - 1); 439 if (ret == 0) 440 ret = 1; 441 } 442 443 mutex_unlock(&d->i2c_mutex); 444 return ret; 445 } 446 447 static u32 af9005_i2c_func(struct i2c_adapter *adapter) 448 { 449 return I2C_FUNC_I2C; 450 } 451 452 static struct i2c_algorithm af9005_i2c_algo = { 453 .master_xfer = af9005_i2c_xfer, 454 .functionality = af9005_i2c_func, 455 }; 456 457 int af9005_send_command(struct dvb_usb_device *d, u8 command, u8 * wbuf, 458 int wlen, u8 * rbuf, int rlen) 459 { 460 struct af9005_device_state *st = d->priv; 461 462 int ret, i, packet_len; 463 u8 seq; 464 465 if (wlen < 0) { 466 err("send command, wlen less than 0 bytes. Makes no sense."); 467 return -EINVAL; 468 } 469 if (wlen > 54) { 470 err("send command, wlen more than 54 bytes. Not supported."); 471 return -EINVAL; 472 } 473 if (rlen > 54) { 474 err("send command, rlen more than 54 bytes. Not supported."); 475 return -EINVAL; 476 } 477 packet_len = wlen + 5; 478 479 mutex_lock(&d->data_mutex); 480 481 st->data[0] = (u8) (packet_len & 0xff); 482 st->data[1] = (u8) ((packet_len & 0xff00) >> 8); 483 484 st->data[2] = 0x26; /* packet type */ 485 st->data[3] = wlen + 3; 486 st->data[4] = seq = st->sequence++; 487 st->data[5] = command; 488 st->data[6] = wlen; 489 for (i = 0; i < wlen; i++) 490 st->data[7 + i] = wbuf[i]; 491 ret = dvb_usb_generic_rw(d, st->data, wlen + 7, st->data, rlen + 7, 0); 492 if (st->data[2] != 0x27) { 493 err("send command, wrong reply code."); 494 ret = -EIO; 495 } else if (st->data[4] != seq) { 496 err("send command, wrong sequence in reply."); 497 ret = -EIO; 498 } else if (st->data[5] != 0x01) { 499 err("send command, wrong status code in reply."); 500 ret = -EIO; 501 } else if (st->data[6] != rlen) { 502 err("send command, invalid data length in reply."); 503 ret = -EIO; 504 } 505 if (!ret) { 506 for (i = 0; i < rlen; i++) 507 rbuf[i] = st->data[i + 7]; 508 } 509 510 mutex_unlock(&d->data_mutex); 511 return ret; 512 } 513 514 int af9005_read_eeprom(struct dvb_usb_device *d, u8 address, u8 * values, 515 int len) 516 { 517 struct af9005_device_state *st = d->priv; 518 u8 seq; 519 int ret, i; 520 521 mutex_lock(&d->data_mutex); 522 523 memset(st->data, 0, sizeof(st->data)); 524 525 st->data[0] = 14; /* length of rest of packet low */ 526 st->data[1] = 0; /* length of rest of packer high */ 527 528 st->data[2] = 0x2a; /* read/write eeprom */ 529 530 st->data[3] = 12; /* size */ 531 532 st->data[4] = seq = st->sequence++; 533 534 st->data[5] = 0; /* read */ 535 536 st->data[6] = len; 537 st->data[7] = address; 538 ret = dvb_usb_generic_rw(d, st->data, 16, st->data, 14, 0); 539 if (st->data[2] != 0x2b) { 540 err("Read eeprom, invalid reply code"); 541 ret = -EIO; 542 } else if (st->data[3] != 10) { 543 err("Read eeprom, invalid reply length"); 544 ret = -EIO; 545 } else if (st->data[4] != seq) { 546 err("Read eeprom, wrong sequence in reply "); 547 ret = -EIO; 548 } else if (st->data[5] != 1) { 549 err("Read eeprom, wrong status in reply "); 550 ret = -EIO; 551 } 552 553 if (!ret) { 554 for (i = 0; i < len; i++) 555 values[i] = st->data[6 + i]; 556 } 557 mutex_unlock(&d->data_mutex); 558 559 return ret; 560 } 561 562 static int af9005_boot_packet(struct usb_device *udev, int type, u8 *reply, 563 u8 *buf, int size) 564 { 565 u16 checksum; 566 int act_len, i, ret; 567 568 memset(buf, 0, size); 569 buf[0] = (u8) (FW_BULKOUT_SIZE & 0xff); 570 buf[1] = (u8) ((FW_BULKOUT_SIZE >> 8) & 0xff); 571 switch (type) { 572 case FW_CONFIG: 573 buf[2] = 0x11; 574 buf[3] = 0x04; 575 buf[4] = 0x00; /* sequence number, original driver doesn't increment it here */ 576 buf[5] = 0x03; 577 checksum = buf[4] + buf[5]; 578 buf[6] = (u8) ((checksum >> 8) & 0xff); 579 buf[7] = (u8) (checksum & 0xff); 580 break; 581 case FW_CONFIRM: 582 buf[2] = 0x11; 583 buf[3] = 0x04; 584 buf[4] = 0x00; /* sequence number, original driver doesn't increment it here */ 585 buf[5] = 0x01; 586 checksum = buf[4] + buf[5]; 587 buf[6] = (u8) ((checksum >> 8) & 0xff); 588 buf[7] = (u8) (checksum & 0xff); 589 break; 590 case FW_BOOT: 591 buf[2] = 0x10; 592 buf[3] = 0x08; 593 buf[4] = 0x00; /* sequence number, original driver doesn't increment it here */ 594 buf[5] = 0x97; 595 buf[6] = 0xaa; 596 buf[7] = 0x55; 597 buf[8] = 0xa5; 598 buf[9] = 0x5a; 599 checksum = 0; 600 for (i = 4; i <= 9; i++) 601 checksum += buf[i]; 602 buf[10] = (u8) ((checksum >> 8) & 0xff); 603 buf[11] = (u8) (checksum & 0xff); 604 break; 605 default: 606 err("boot packet invalid boot packet type"); 607 return -EINVAL; 608 } 609 deb_fw(">>> "); 610 debug_dump(buf, FW_BULKOUT_SIZE + 2, deb_fw); 611 612 ret = usb_bulk_msg(udev, 613 usb_sndbulkpipe(udev, 0x02), 614 buf, FW_BULKOUT_SIZE + 2, &act_len, 2000); 615 if (ret) 616 err("boot packet bulk message failed: %d (%d/%d)", ret, 617 FW_BULKOUT_SIZE + 2, act_len); 618 else 619 ret = act_len != FW_BULKOUT_SIZE + 2 ? -1 : 0; 620 if (ret) 621 return ret; 622 memset(buf, 0, 9); 623 ret = usb_bulk_msg(udev, 624 usb_rcvbulkpipe(udev, 0x01), buf, 9, &act_len, 2000); 625 if (ret) { 626 err("boot packet recv bulk message failed: %d", ret); 627 return ret; 628 } 629 deb_fw("<<< "); 630 debug_dump(buf, act_len, deb_fw); 631 checksum = 0; 632 switch (type) { 633 case FW_CONFIG: 634 if (buf[2] != 0x11) { 635 err("boot bad config header."); 636 return -EIO; 637 } 638 if (buf[3] != 0x05) { 639 err("boot bad config size."); 640 return -EIO; 641 } 642 if (buf[4] != 0x00) { 643 err("boot bad config sequence."); 644 return -EIO; 645 } 646 if (buf[5] != 0x04) { 647 err("boot bad config subtype."); 648 return -EIO; 649 } 650 for (i = 4; i <= 6; i++) 651 checksum += buf[i]; 652 if (buf[7] * 256 + buf[8] != checksum) { 653 err("boot bad config checksum."); 654 return -EIO; 655 } 656 *reply = buf[6]; 657 break; 658 case FW_CONFIRM: 659 if (buf[2] != 0x11) { 660 err("boot bad confirm header."); 661 return -EIO; 662 } 663 if (buf[3] != 0x05) { 664 err("boot bad confirm size."); 665 return -EIO; 666 } 667 if (buf[4] != 0x00) { 668 err("boot bad confirm sequence."); 669 return -EIO; 670 } 671 if (buf[5] != 0x02) { 672 err("boot bad confirm subtype."); 673 return -EIO; 674 } 675 for (i = 4; i <= 6; i++) 676 checksum += buf[i]; 677 if (buf[7] * 256 + buf[8] != checksum) { 678 err("boot bad confirm checksum."); 679 return -EIO; 680 } 681 *reply = buf[6]; 682 break; 683 case FW_BOOT: 684 if (buf[2] != 0x10) { 685 err("boot bad boot header."); 686 return -EIO; 687 } 688 if (buf[3] != 0x05) { 689 err("boot bad boot size."); 690 return -EIO; 691 } 692 if (buf[4] != 0x00) { 693 err("boot bad boot sequence."); 694 return -EIO; 695 } 696 if (buf[5] != 0x01) { 697 err("boot bad boot pattern 01."); 698 return -EIO; 699 } 700 if (buf[6] != 0x10) { 701 err("boot bad boot pattern 10."); 702 return -EIO; 703 } 704 for (i = 4; i <= 6; i++) 705 checksum += buf[i]; 706 if (buf[7] * 256 + buf[8] != checksum) { 707 err("boot bad boot checksum."); 708 return -EIO; 709 } 710 break; 711 712 } 713 714 return 0; 715 } 716 717 static int af9005_download_firmware(struct usb_device *udev, const struct firmware *fw) 718 { 719 int i, packets, ret, act_len; 720 721 u8 *buf; 722 u8 reply; 723 724 buf = kmalloc(FW_BULKOUT_SIZE + 2, GFP_KERNEL); 725 if (!buf) 726 return -ENOMEM; 727 728 ret = af9005_boot_packet(udev, FW_CONFIG, &reply, buf, 729 FW_BULKOUT_SIZE + 2); 730 if (ret) 731 goto err; 732 if (reply != 0x01) { 733 err("before downloading firmware, FW_CONFIG expected 0x01, received 0x%x", reply); 734 ret = -EIO; 735 goto err; 736 } 737 packets = fw->size / FW_BULKOUT_SIZE; 738 buf[0] = (u8) (FW_BULKOUT_SIZE & 0xff); 739 buf[1] = (u8) ((FW_BULKOUT_SIZE >> 8) & 0xff); 740 for (i = 0; i < packets; i++) { 741 memcpy(&buf[2], fw->data + i * FW_BULKOUT_SIZE, 742 FW_BULKOUT_SIZE); 743 deb_fw(">>> "); 744 debug_dump(buf, FW_BULKOUT_SIZE + 2, deb_fw); 745 ret = usb_bulk_msg(udev, 746 usb_sndbulkpipe(udev, 0x02), 747 buf, FW_BULKOUT_SIZE + 2, &act_len, 1000); 748 if (ret) { 749 err("firmware download failed at packet %d with code %d", i, ret); 750 goto err; 751 } 752 } 753 ret = af9005_boot_packet(udev, FW_CONFIRM, &reply, 754 buf, FW_BULKOUT_SIZE + 2); 755 if (ret) 756 goto err; 757 if (reply != (u8) (packets & 0xff)) { 758 err("after downloading firmware, FW_CONFIRM expected 0x%x, received 0x%x", packets & 0xff, reply); 759 ret = -EIO; 760 goto err; 761 } 762 ret = af9005_boot_packet(udev, FW_BOOT, &reply, buf, 763 FW_BULKOUT_SIZE + 2); 764 if (ret) 765 goto err; 766 ret = af9005_boot_packet(udev, FW_CONFIG, &reply, buf, 767 FW_BULKOUT_SIZE + 2); 768 if (ret) 769 goto err; 770 if (reply != 0x02) { 771 err("after downloading firmware, FW_CONFIG expected 0x02, received 0x%x", reply); 772 ret = -EIO; 773 goto err; 774 } 775 776 err: 777 kfree(buf); 778 return ret; 779 780 } 781 782 int af9005_led_control(struct dvb_usb_device *d, int onoff) 783 { 784 struct af9005_device_state *st = d->priv; 785 int temp, ret; 786 787 if (onoff && dvb_usb_af9005_led) 788 temp = 1; 789 else 790 temp = 0; 791 if (st->led_state != temp) { 792 ret = 793 af9005_write_register_bits(d, xd_p_reg_top_locken1, 794 reg_top_locken1_pos, 795 reg_top_locken1_len, temp); 796 if (ret) 797 return ret; 798 ret = 799 af9005_write_register_bits(d, xd_p_reg_top_lock1, 800 reg_top_lock1_pos, 801 reg_top_lock1_len, temp); 802 if (ret) 803 return ret; 804 st->led_state = temp; 805 } 806 return 0; 807 } 808 809 static int af9005_frontend_attach(struct dvb_usb_adapter *adap) 810 { 811 u8 buf[8]; 812 int i; 813 814 /* without these calls the first commands after downloading 815 the firmware fail. I put these calls here to simulate 816 what it is done in dvb-usb-init.c. 817 */ 818 struct usb_device *udev = adap->dev->udev; 819 usb_clear_halt(udev, usb_sndbulkpipe(udev, 2)); 820 usb_clear_halt(udev, usb_rcvbulkpipe(udev, 1)); 821 if (dvb_usb_af9005_dump_eeprom) { 822 printk("EEPROM DUMP\n"); 823 for (i = 0; i < 255; i += 8) { 824 af9005_read_eeprom(adap->dev, i, buf, 8); 825 debug_dump(buf, 8, printk); 826 } 827 } 828 adap->fe_adap[0].fe = af9005_fe_attach(adap->dev); 829 return 0; 830 } 831 832 static int af9005_rc_query(struct dvb_usb_device *d, u32 * event, int *state) 833 { 834 struct af9005_device_state *st = d->priv; 835 int ret, len; 836 u8 seq; 837 838 *state = REMOTE_NO_KEY_PRESSED; 839 if (rc_decode == NULL) { 840 /* it shouldn't never come here */ 841 return 0; 842 } 843 844 mutex_lock(&d->data_mutex); 845 846 /* deb_info("rc_query\n"); */ 847 st->data[0] = 3; /* rest of packet length low */ 848 st->data[1] = 0; /* rest of packet length high */ 849 st->data[2] = 0x40; /* read remote */ 850 st->data[3] = 1; /* rest of packet length */ 851 st->data[4] = seq = st->sequence++; /* sequence number */ 852 ret = dvb_usb_generic_rw(d, st->data, 5, st->data, 256, 0); 853 if (ret) { 854 err("rc query failed"); 855 goto ret; 856 } 857 if (st->data[2] != 0x41) { 858 err("rc query bad header."); 859 ret = -EIO; 860 goto ret; 861 } else if (st->data[4] != seq) { 862 err("rc query bad sequence."); 863 ret = -EIO; 864 goto ret; 865 } 866 len = st->data[5]; 867 if (len > 246) { 868 err("rc query invalid length"); 869 ret = -EIO; 870 goto ret; 871 } 872 if (len > 0) { 873 deb_rc("rc data (%d) ", len); 874 debug_dump((st->data + 6), len, deb_rc); 875 ret = rc_decode(d, &st->data[6], len, event, state); 876 if (ret) { 877 err("rc_decode failed"); 878 goto ret; 879 } else { 880 deb_rc("rc_decode state %x event %x\n", *state, *event); 881 if (*state == REMOTE_KEY_REPEAT) 882 *event = d->last_event; 883 } 884 } 885 886 ret: 887 mutex_unlock(&d->data_mutex); 888 return ret; 889 } 890 891 static int af9005_power_ctrl(struct dvb_usb_device *d, int onoff) 892 { 893 894 return 0; 895 } 896 897 static int af9005_pid_filter_control(struct dvb_usb_adapter *adap, int onoff) 898 { 899 int ret; 900 deb_info("pid filter control onoff %d\n", onoff); 901 if (onoff) { 902 ret = 903 af9005_write_ofdm_register(adap->dev, XD_MP2IF_DMX_CTRL, 1); 904 if (ret) 905 return ret; 906 ret = 907 af9005_write_register_bits(adap->dev, 908 XD_MP2IF_DMX_CTRL, 1, 1, 1); 909 if (ret) 910 return ret; 911 ret = 912 af9005_write_ofdm_register(adap->dev, XD_MP2IF_DMX_CTRL, 1); 913 } else 914 ret = 915 af9005_write_ofdm_register(adap->dev, XD_MP2IF_DMX_CTRL, 0); 916 if (ret) 917 return ret; 918 deb_info("pid filter control ok\n"); 919 return 0; 920 } 921 922 static int af9005_pid_filter(struct dvb_usb_adapter *adap, int index, 923 u16 pid, int onoff) 924 { 925 u8 cmd = index & 0x1f; 926 int ret; 927 deb_info("set pid filter, index %d, pid %x, onoff %d\n", index, 928 pid, onoff); 929 if (onoff) { 930 /* cannot use it as pid_filter_ctrl since it has to be done 931 before setting the first pid */ 932 if (adap->feedcount == 1) { 933 deb_info("first pid set, enable pid table\n"); 934 ret = af9005_pid_filter_control(adap, onoff); 935 if (ret) 936 return ret; 937 } 938 ret = 939 af9005_write_ofdm_register(adap->dev, 940 XD_MP2IF_PID_DATA_L, 941 (u8) (pid & 0xff)); 942 if (ret) 943 return ret; 944 ret = 945 af9005_write_ofdm_register(adap->dev, 946 XD_MP2IF_PID_DATA_H, 947 (u8) (pid >> 8)); 948 if (ret) 949 return ret; 950 cmd |= 0x20 | 0x40; 951 } else { 952 if (adap->feedcount == 0) { 953 deb_info("last pid unset, disable pid table\n"); 954 ret = af9005_pid_filter_control(adap, onoff); 955 if (ret) 956 return ret; 957 } 958 } 959 ret = af9005_write_ofdm_register(adap->dev, XD_MP2IF_PID_IDX, cmd); 960 if (ret) 961 return ret; 962 deb_info("set pid ok\n"); 963 return 0; 964 } 965 966 static int af9005_identify_state(struct usb_device *udev, 967 struct dvb_usb_device_properties *props, 968 struct dvb_usb_device_description **desc, 969 int *cold) 970 { 971 int ret; 972 u8 reply, *buf; 973 974 buf = kmalloc(FW_BULKOUT_SIZE + 2, GFP_KERNEL); 975 if (!buf) 976 return -ENOMEM; 977 978 ret = af9005_boot_packet(udev, FW_CONFIG, &reply, 979 buf, FW_BULKOUT_SIZE + 2); 980 if (ret) 981 goto err; 982 deb_info("result of FW_CONFIG in identify state %d\n", reply); 983 if (reply == 0x01) 984 *cold = 1; 985 else if (reply == 0x02) 986 *cold = 0; 987 else 988 return -EIO; 989 deb_info("Identify state cold = %d\n", *cold); 990 991 err: 992 kfree(buf); 993 return ret; 994 } 995 996 static struct dvb_usb_device_properties af9005_properties; 997 998 static int af9005_usb_probe(struct usb_interface *intf, 999 const struct usb_device_id *id) 1000 { 1001 return dvb_usb_device_init(intf, &af9005_properties, 1002 THIS_MODULE, NULL, adapter_nr); 1003 } 1004 1005 enum af9005_usb_table_entry { 1006 AFATECH_AF9005, 1007 TERRATEC_AF9005, 1008 ANSONIC_AF9005, 1009 }; 1010 1011 static struct usb_device_id af9005_usb_table[] = { 1012 [AFATECH_AF9005] = {USB_DEVICE(USB_VID_AFATECH, 1013 USB_PID_AFATECH_AF9005)}, 1014 [TERRATEC_AF9005] = {USB_DEVICE(USB_VID_TERRATEC, 1015 USB_PID_TERRATEC_CINERGY_T_USB_XE)}, 1016 [ANSONIC_AF9005] = {USB_DEVICE(USB_VID_ANSONIC, 1017 USB_PID_ANSONIC_DVBT_USB)}, 1018 { } 1019 }; 1020 1021 MODULE_DEVICE_TABLE(usb, af9005_usb_table); 1022 1023 static struct dvb_usb_device_properties af9005_properties = { 1024 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 1025 1026 .usb_ctrl = DEVICE_SPECIFIC, 1027 .firmware = "af9005.fw", 1028 .download_firmware = af9005_download_firmware, 1029 .no_reconnect = 1, 1030 1031 .size_of_priv = sizeof(struct af9005_device_state), 1032 1033 .num_adapters = 1, 1034 .adapter = { 1035 { 1036 .num_frontends = 1, 1037 .fe = {{ 1038 .caps = 1039 DVB_USB_ADAP_HAS_PID_FILTER | 1040 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, 1041 .pid_filter_count = 32, 1042 .pid_filter = af9005_pid_filter, 1043 /* .pid_filter_ctrl = af9005_pid_filter_control, */ 1044 .frontend_attach = af9005_frontend_attach, 1045 /* .tuner_attach = af9005_tuner_attach, */ 1046 /* parameter for the MPEG2-data transfer */ 1047 .stream = { 1048 .type = USB_BULK, 1049 .count = 10, 1050 .endpoint = 0x04, 1051 .u = { 1052 .bulk = { 1053 .buffersize = 4096, /* actual size seen is 3948 */ 1054 } 1055 } 1056 }, 1057 }}, 1058 } 1059 }, 1060 .power_ctrl = af9005_power_ctrl, 1061 .identify_state = af9005_identify_state, 1062 1063 .i2c_algo = &af9005_i2c_algo, 1064 1065 .rc.legacy = { 1066 .rc_interval = 200, 1067 .rc_map_table = NULL, 1068 .rc_map_size = 0, 1069 .rc_query = af9005_rc_query, 1070 }, 1071 1072 .generic_bulk_ctrl_endpoint = 2, 1073 .generic_bulk_ctrl_endpoint_response = 1, 1074 1075 .num_device_descs = 3, 1076 .devices = { 1077 {.name = "Afatech DVB-T USB1.1 stick", 1078 .cold_ids = {&af9005_usb_table[AFATECH_AF9005], NULL}, 1079 .warm_ids = {NULL}, 1080 }, 1081 {.name = "TerraTec Cinergy T USB XE", 1082 .cold_ids = {&af9005_usb_table[TERRATEC_AF9005], NULL}, 1083 .warm_ids = {NULL}, 1084 }, 1085 {.name = "Ansonic DVB-T USB1.1 stick", 1086 .cold_ids = {&af9005_usb_table[ANSONIC_AF9005], NULL}, 1087 .warm_ids = {NULL}, 1088 }, 1089 {NULL}, 1090 } 1091 }; 1092 1093 /* usb specific object needed to register this driver with the usb subsystem */ 1094 static struct usb_driver af9005_usb_driver = { 1095 .name = "dvb_usb_af9005", 1096 .probe = af9005_usb_probe, 1097 .disconnect = dvb_usb_device_exit, 1098 .id_table = af9005_usb_table, 1099 }; 1100 1101 /* module stuff */ 1102 static int __init af9005_usb_module_init(void) 1103 { 1104 int result; 1105 if ((result = usb_register(&af9005_usb_driver))) { 1106 err("usb_register failed. (%d)", result); 1107 return result; 1108 } 1109 #if IS_MODULE(CONFIG_DVB_USB_AF9005) || defined(CONFIG_DVB_USB_AF9005_REMOTE) 1110 /* FIXME: convert to todays kernel IR infrastructure */ 1111 rc_decode = symbol_request(af9005_rc_decode); 1112 rc_keys = symbol_request(rc_map_af9005_table); 1113 rc_keys_size = symbol_request(rc_map_af9005_table_size); 1114 #endif 1115 if (rc_decode == NULL || rc_keys == NULL || rc_keys_size == NULL) { 1116 err("af9005_rc_decode function not found, disabling remote"); 1117 af9005_properties.rc.legacy.rc_query = NULL; 1118 } else { 1119 af9005_properties.rc.legacy.rc_map_table = rc_keys; 1120 af9005_properties.rc.legacy.rc_map_size = *rc_keys_size; 1121 } 1122 1123 return 0; 1124 } 1125 1126 static void __exit af9005_usb_module_exit(void) 1127 { 1128 /* release rc decode symbols */ 1129 if (rc_decode != NULL) 1130 symbol_put(af9005_rc_decode); 1131 if (rc_keys != NULL) 1132 symbol_put(rc_map_af9005_table); 1133 if (rc_keys_size != NULL) 1134 symbol_put(rc_map_af9005_table_size); 1135 /* deregister this driver from the USB subsystem */ 1136 usb_deregister(&af9005_usb_driver); 1137 } 1138 1139 module_init(af9005_usb_module_init); 1140 module_exit(af9005_usb_module_exit); 1141 1142 MODULE_AUTHOR("Luca Olivetti <luca@ventoso.org>"); 1143 MODULE_DESCRIPTION("Driver for Afatech 9005 DVB-T USB1.1 stick"); 1144 MODULE_VERSION("1.0"); 1145 MODULE_LICENSE("GPL"); 1146