1 /* Linux driver for devices based on the DiBcom DiB0700 USB bridge 2 * 3 * This program is free software; you can redistribute it and/or modify it 4 * under the terms of the GNU General Public License as published by the Free 5 * Software Foundation, version 2. 6 * 7 * Copyright (C) 2005-6 DiBcom, SA 8 */ 9 #include "dib0700.h" 10 11 /* debug */ 12 int dvb_usb_dib0700_debug; 13 module_param_named(debug,dvb_usb_dib0700_debug, int, 0644); 14 MODULE_PARM_DESC(debug, "set debugging level (1=info,2=fw,4=fwdata,8=data (or-able))." DVB_USB_DEBUG_STATUS); 15 16 static int nb_packet_buffer_size = 21; 17 module_param(nb_packet_buffer_size, int, 0644); 18 MODULE_PARM_DESC(nb_packet_buffer_size, 19 "Set the dib0700 driver data buffer size. This parameter corresponds to the number of TS packets. The actual size of the data buffer corresponds to this parameter multiplied by 188 (default: 21)"); 20 21 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); 22 23 24 int dib0700_get_version(struct dvb_usb_device *d, u32 *hwversion, 25 u32 *romversion, u32 *ramversion, u32 *fwtype) 26 { 27 struct dib0700_state *st = d->priv; 28 int ret; 29 30 if (mutex_lock_interruptible(&d->usb_mutex) < 0) { 31 err("could not acquire lock"); 32 return -EINTR; 33 } 34 35 ret = usb_control_msg(d->udev, usb_rcvctrlpipe(d->udev, 0), 36 REQUEST_GET_VERSION, 37 USB_TYPE_VENDOR | USB_DIR_IN, 0, 0, 38 st->buf, 16, USB_CTRL_GET_TIMEOUT); 39 if (hwversion != NULL) 40 *hwversion = (st->buf[0] << 24) | (st->buf[1] << 16) | 41 (st->buf[2] << 8) | st->buf[3]; 42 if (romversion != NULL) 43 *romversion = (st->buf[4] << 24) | (st->buf[5] << 16) | 44 (st->buf[6] << 8) | st->buf[7]; 45 if (ramversion != NULL) 46 *ramversion = (st->buf[8] << 24) | (st->buf[9] << 16) | 47 (st->buf[10] << 8) | st->buf[11]; 48 if (fwtype != NULL) 49 *fwtype = (st->buf[12] << 24) | (st->buf[13] << 16) | 50 (st->buf[14] << 8) | st->buf[15]; 51 mutex_unlock(&d->usb_mutex); 52 return ret; 53 } 54 55 /* expecting rx buffer: request data[0] data[1] ... data[2] */ 56 static int dib0700_ctrl_wr(struct dvb_usb_device *d, u8 *tx, u8 txlen) 57 { 58 int status; 59 60 deb_data(">>> "); 61 debug_dump(tx, txlen, deb_data); 62 63 status = usb_control_msg(d->udev, usb_sndctrlpipe(d->udev,0), 64 tx[0], USB_TYPE_VENDOR | USB_DIR_OUT, 0, 0, tx, txlen, 65 USB_CTRL_GET_TIMEOUT); 66 67 if (status != txlen) 68 deb_data("ep 0 write error (status = %d, len: %d)\n",status,txlen); 69 70 return status < 0 ? status : 0; 71 } 72 73 /* expecting tx buffer: request data[0] ... data[n] (n <= 4) */ 74 int dib0700_ctrl_rd(struct dvb_usb_device *d, u8 *tx, u8 txlen, u8 *rx, u8 rxlen) 75 { 76 u16 index, value; 77 int status; 78 79 if (txlen < 2) { 80 err("tx buffer length is smaller than 2. Makes no sense."); 81 return -EINVAL; 82 } 83 if (txlen > 4) { 84 err("tx buffer length is larger than 4. Not supported."); 85 return -EINVAL; 86 } 87 88 deb_data(">>> "); 89 debug_dump(tx,txlen,deb_data); 90 91 value = ((txlen - 2) << 8) | tx[1]; 92 index = 0; 93 if (txlen > 2) 94 index |= (tx[2] << 8); 95 if (txlen > 3) 96 index |= tx[3]; 97 98 status = usb_control_msg(d->udev, usb_rcvctrlpipe(d->udev,0), tx[0], 99 USB_TYPE_VENDOR | USB_DIR_IN, value, index, rx, rxlen, 100 USB_CTRL_GET_TIMEOUT); 101 102 if (status < 0) 103 deb_info("ep 0 read error (status = %d)\n",status); 104 105 deb_data("<<< "); 106 debug_dump(rx, rxlen, deb_data); 107 108 return status; /* length in case of success */ 109 } 110 111 int dib0700_set_gpio(struct dvb_usb_device *d, enum dib07x0_gpios gpio, u8 gpio_dir, u8 gpio_val) 112 { 113 struct dib0700_state *st = d->priv; 114 int ret; 115 116 if (mutex_lock_interruptible(&d->usb_mutex) < 0) { 117 err("could not acquire lock"); 118 return -EINTR; 119 } 120 121 st->buf[0] = REQUEST_SET_GPIO; 122 st->buf[1] = gpio; 123 st->buf[2] = ((gpio_dir & 0x01) << 7) | ((gpio_val & 0x01) << 6); 124 125 ret = dib0700_ctrl_wr(d, st->buf, 3); 126 127 mutex_unlock(&d->usb_mutex); 128 return ret; 129 } 130 131 static int dib0700_set_usb_xfer_len(struct dvb_usb_device *d, u16 nb_ts_packets) 132 { 133 struct dib0700_state *st = d->priv; 134 int ret; 135 136 if (st->fw_version >= 0x10201) { 137 if (mutex_lock_interruptible(&d->usb_mutex) < 0) { 138 err("could not acquire lock"); 139 return -EINTR; 140 } 141 142 st->buf[0] = REQUEST_SET_USB_XFER_LEN; 143 st->buf[1] = (nb_ts_packets >> 8) & 0xff; 144 st->buf[2] = nb_ts_packets & 0xff; 145 146 deb_info("set the USB xfer len to %i Ts packet\n", nb_ts_packets); 147 148 ret = dib0700_ctrl_wr(d, st->buf, 3); 149 mutex_unlock(&d->usb_mutex); 150 } else { 151 deb_info("this firmware does not allow to change the USB xfer len\n"); 152 ret = -EIO; 153 } 154 155 return ret; 156 } 157 158 /* 159 * I2C master xfer function (supported in 1.20 firmware) 160 */ 161 static int dib0700_i2c_xfer_new(struct i2c_adapter *adap, struct i2c_msg *msg, 162 int num) 163 { 164 /* The new i2c firmware messages are more reliable and in particular 165 properly support i2c read calls not preceded by a write */ 166 167 struct dvb_usb_device *d = i2c_get_adapdata(adap); 168 struct dib0700_state *st = d->priv; 169 uint8_t bus_mode = 1; /* 0=eeprom bus, 1=frontend bus */ 170 uint8_t gen_mode = 0; /* 0=master i2c, 1=gpio i2c */ 171 uint8_t en_start = 0; 172 uint8_t en_stop = 0; 173 int result, i; 174 175 /* Ensure nobody else hits the i2c bus while we're sending our 176 sequence of messages, (such as the remote control thread) */ 177 if (mutex_lock_interruptible(&d->i2c_mutex) < 0) 178 return -EINTR; 179 180 for (i = 0; i < num; i++) { 181 if (i == 0) { 182 /* First message in the transaction */ 183 en_start = 1; 184 } else if (!(msg[i].flags & I2C_M_NOSTART)) { 185 /* Device supports repeated-start */ 186 en_start = 1; 187 } else { 188 /* Not the first packet and device doesn't support 189 repeated start */ 190 en_start = 0; 191 } 192 if (i == (num - 1)) { 193 /* Last message in the transaction */ 194 en_stop = 1; 195 } 196 197 if (msg[i].flags & I2C_M_RD) { 198 /* Read request */ 199 u16 index, value; 200 uint8_t i2c_dest; 201 202 i2c_dest = (msg[i].addr << 1); 203 value = ((en_start << 7) | (en_stop << 6) | 204 (msg[i].len & 0x3F)) << 8 | i2c_dest; 205 /* I2C ctrl + FE bus; */ 206 index = ((gen_mode << 6) & 0xC0) | 207 ((bus_mode << 4) & 0x30); 208 209 result = usb_control_msg(d->udev, 210 usb_rcvctrlpipe(d->udev, 0), 211 REQUEST_NEW_I2C_READ, 212 USB_TYPE_VENDOR | USB_DIR_IN, 213 value, index, st->buf, 214 msg[i].len, 215 USB_CTRL_GET_TIMEOUT); 216 if (result < 0) { 217 deb_info("i2c read error (status = %d)\n", result); 218 goto unlock; 219 } 220 221 if (msg[i].len > sizeof(st->buf)) { 222 deb_info("buffer too small to fit %d bytes\n", 223 msg[i].len); 224 result = -EIO; 225 goto unlock; 226 } 227 228 memcpy(msg[i].buf, st->buf, msg[i].len); 229 230 deb_data("<<< "); 231 debug_dump(msg[i].buf, msg[i].len, deb_data); 232 233 } else { 234 /* Write request */ 235 if (mutex_lock_interruptible(&d->usb_mutex) < 0) { 236 err("could not acquire lock"); 237 result = -EINTR; 238 goto unlock; 239 } 240 st->buf[0] = REQUEST_NEW_I2C_WRITE; 241 st->buf[1] = msg[i].addr << 1; 242 st->buf[2] = (en_start << 7) | (en_stop << 6) | 243 (msg[i].len & 0x3F); 244 /* I2C ctrl + FE bus; */ 245 st->buf[3] = ((gen_mode << 6) & 0xC0) | 246 ((bus_mode << 4) & 0x30); 247 248 if (msg[i].len > sizeof(st->buf) - 4) { 249 deb_info("i2c message to big: %d\n", 250 msg[i].len); 251 mutex_unlock(&d->usb_mutex); 252 result = -EIO; 253 goto unlock; 254 } 255 256 /* The Actual i2c payload */ 257 memcpy(&st->buf[4], msg[i].buf, msg[i].len); 258 259 deb_data(">>> "); 260 debug_dump(st->buf, msg[i].len + 4, deb_data); 261 262 result = usb_control_msg(d->udev, 263 usb_sndctrlpipe(d->udev, 0), 264 REQUEST_NEW_I2C_WRITE, 265 USB_TYPE_VENDOR | USB_DIR_OUT, 266 0, 0, st->buf, msg[i].len + 4, 267 USB_CTRL_GET_TIMEOUT); 268 mutex_unlock(&d->usb_mutex); 269 if (result < 0) { 270 deb_info("i2c write error (status = %d)\n", result); 271 break; 272 } 273 } 274 } 275 result = i; 276 277 unlock: 278 mutex_unlock(&d->i2c_mutex); 279 return result; 280 } 281 282 /* 283 * I2C master xfer function (pre-1.20 firmware) 284 */ 285 static int dib0700_i2c_xfer_legacy(struct i2c_adapter *adap, 286 struct i2c_msg *msg, int num) 287 { 288 struct dvb_usb_device *d = i2c_get_adapdata(adap); 289 struct dib0700_state *st = d->priv; 290 int i, len, result; 291 292 if (mutex_lock_interruptible(&d->i2c_mutex) < 0) 293 return -EINTR; 294 if (mutex_lock_interruptible(&d->usb_mutex) < 0) { 295 err("could not acquire lock"); 296 mutex_unlock(&d->i2c_mutex); 297 return -EINTR; 298 } 299 300 for (i = 0; i < num; i++) { 301 /* fill in the address */ 302 st->buf[1] = msg[i].addr << 1; 303 /* fill the buffer */ 304 if (msg[i].len > sizeof(st->buf) - 2) { 305 deb_info("i2c xfer to big: %d\n", 306 msg[i].len); 307 result = -EIO; 308 goto unlock; 309 } 310 memcpy(&st->buf[2], msg[i].buf, msg[i].len); 311 312 /* write/read request */ 313 if (i+1 < num && (msg[i+1].flags & I2C_M_RD)) { 314 st->buf[0] = REQUEST_I2C_READ; 315 st->buf[1] |= 1; 316 317 /* special thing in the current firmware: when length is zero the read-failed */ 318 len = dib0700_ctrl_rd(d, st->buf, msg[i].len + 2, 319 st->buf, msg[i + 1].len); 320 if (len <= 0) { 321 deb_info("I2C read failed on address 0x%02x\n", 322 msg[i].addr); 323 result = -EIO; 324 goto unlock; 325 } 326 327 if (msg[i + 1].len > sizeof(st->buf)) { 328 deb_info("i2c xfer buffer to small for %d\n", 329 msg[i].len); 330 result = -EIO; 331 goto unlock; 332 } 333 memcpy(msg[i + 1].buf, st->buf, msg[i + 1].len); 334 335 msg[i+1].len = len; 336 337 i++; 338 } else { 339 st->buf[0] = REQUEST_I2C_WRITE; 340 result = dib0700_ctrl_wr(d, st->buf, msg[i].len + 2); 341 if (result < 0) 342 goto unlock; 343 } 344 } 345 result = i; 346 unlock: 347 mutex_unlock(&d->usb_mutex); 348 mutex_unlock(&d->i2c_mutex); 349 350 return result; 351 } 352 353 static int dib0700_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg *msg, 354 int num) 355 { 356 struct dvb_usb_device *d = i2c_get_adapdata(adap); 357 struct dib0700_state *st = d->priv; 358 359 if (st->fw_use_new_i2c_api == 1) { 360 /* User running at least fw 1.20 */ 361 return dib0700_i2c_xfer_new(adap, msg, num); 362 } else { 363 /* Use legacy calls */ 364 return dib0700_i2c_xfer_legacy(adap, msg, num); 365 } 366 } 367 368 static u32 dib0700_i2c_func(struct i2c_adapter *adapter) 369 { 370 return I2C_FUNC_I2C; 371 } 372 373 struct i2c_algorithm dib0700_i2c_algo = { 374 .master_xfer = dib0700_i2c_xfer, 375 .functionality = dib0700_i2c_func, 376 }; 377 378 int dib0700_identify_state(struct usb_device *udev, struct dvb_usb_device_properties *props, 379 struct dvb_usb_device_description **desc, int *cold) 380 { 381 s16 ret; 382 u8 *b; 383 384 b = kmalloc(16, GFP_KERNEL); 385 if (!b) 386 return -ENOMEM; 387 388 389 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 390 REQUEST_GET_VERSION, USB_TYPE_VENDOR | USB_DIR_IN, 0, 0, b, 16, USB_CTRL_GET_TIMEOUT); 391 392 deb_info("FW GET_VERSION length: %d\n",ret); 393 394 *cold = ret <= 0; 395 deb_info("cold: %d\n", *cold); 396 397 kfree(b); 398 return 0; 399 } 400 401 static int dib0700_set_clock(struct dvb_usb_device *d, u8 en_pll, 402 u8 pll_src, u8 pll_range, u8 clock_gpio3, u16 pll_prediv, 403 u16 pll_loopdiv, u16 free_div, u16 dsuScaler) 404 { 405 struct dib0700_state *st = d->priv; 406 int ret; 407 408 if (mutex_lock_interruptible(&d->usb_mutex) < 0) { 409 err("could not acquire lock"); 410 return -EINTR; 411 } 412 413 st->buf[0] = REQUEST_SET_CLOCK; 414 st->buf[1] = (en_pll << 7) | (pll_src << 6) | 415 (pll_range << 5) | (clock_gpio3 << 4); 416 st->buf[2] = (pll_prediv >> 8) & 0xff; /* MSB */ 417 st->buf[3] = pll_prediv & 0xff; /* LSB */ 418 st->buf[4] = (pll_loopdiv >> 8) & 0xff; /* MSB */ 419 st->buf[5] = pll_loopdiv & 0xff; /* LSB */ 420 st->buf[6] = (free_div >> 8) & 0xff; /* MSB */ 421 st->buf[7] = free_div & 0xff; /* LSB */ 422 st->buf[8] = (dsuScaler >> 8) & 0xff; /* MSB */ 423 st->buf[9] = dsuScaler & 0xff; /* LSB */ 424 425 ret = dib0700_ctrl_wr(d, st->buf, 10); 426 mutex_unlock(&d->usb_mutex); 427 428 return ret; 429 } 430 431 int dib0700_set_i2c_speed(struct dvb_usb_device *d, u16 scl_kHz) 432 { 433 struct dib0700_state *st = d->priv; 434 u16 divider; 435 int ret; 436 437 if (scl_kHz == 0) 438 return -EINVAL; 439 440 if (mutex_lock_interruptible(&d->usb_mutex) < 0) { 441 err("could not acquire lock"); 442 return -EINTR; 443 } 444 445 st->buf[0] = REQUEST_SET_I2C_PARAM; 446 divider = (u16) (30000 / scl_kHz); 447 st->buf[1] = 0; 448 st->buf[2] = (u8) (divider >> 8); 449 st->buf[3] = (u8) (divider & 0xff); 450 divider = (u16) (72000 / scl_kHz); 451 st->buf[4] = (u8) (divider >> 8); 452 st->buf[5] = (u8) (divider & 0xff); 453 divider = (u16) (72000 / scl_kHz); /* clock: 72MHz */ 454 st->buf[6] = (u8) (divider >> 8); 455 st->buf[7] = (u8) (divider & 0xff); 456 457 deb_info("setting I2C speed: %04x %04x %04x (%d kHz).", 458 (st->buf[2] << 8) | (st->buf[3]), (st->buf[4] << 8) | 459 st->buf[5], (st->buf[6] << 8) | st->buf[7], scl_kHz); 460 461 ret = dib0700_ctrl_wr(d, st->buf, 8); 462 mutex_unlock(&d->usb_mutex); 463 464 return ret; 465 } 466 467 468 int dib0700_ctrl_clock(struct dvb_usb_device *d, u32 clk_MHz, u8 clock_out_gp3) 469 { 470 switch (clk_MHz) { 471 case 72: dib0700_set_clock(d, 1, 0, 1, clock_out_gp3, 2, 24, 0, 0x4c); break; 472 default: return -EINVAL; 473 } 474 return 0; 475 } 476 477 static int dib0700_jumpram(struct usb_device *udev, u32 address) 478 { 479 int ret = 0, actlen; 480 u8 *buf; 481 482 buf = kmalloc(8, GFP_KERNEL); 483 if (!buf) 484 return -ENOMEM; 485 buf[0] = REQUEST_JUMPRAM; 486 buf[1] = 0; 487 buf[2] = 0; 488 buf[3] = 0; 489 buf[4] = (address >> 24) & 0xff; 490 buf[5] = (address >> 16) & 0xff; 491 buf[6] = (address >> 8) & 0xff; 492 buf[7] = address & 0xff; 493 494 if ((ret = usb_bulk_msg(udev, usb_sndbulkpipe(udev, 0x01),buf,8,&actlen,1000)) < 0) { 495 deb_fw("jumpram to 0x%x failed\n",address); 496 goto out; 497 } 498 if (actlen != 8) { 499 deb_fw("jumpram to 0x%x failed\n",address); 500 ret = -EIO; 501 goto out; 502 } 503 out: 504 kfree(buf); 505 return ret; 506 } 507 508 int dib0700_download_firmware(struct usb_device *udev, const struct firmware *fw) 509 { 510 struct hexline hx; 511 int pos = 0, ret, act_len, i, adap_num; 512 u8 *buf; 513 u32 fw_version; 514 515 buf = kmalloc(260, GFP_KERNEL); 516 if (!buf) 517 return -ENOMEM; 518 519 while ((ret = dvb_usb_get_hexline(fw, &hx, &pos)) > 0) { 520 deb_fwdata("writing to address 0x%08x (buffer: 0x%02x %02x)\n", 521 hx.addr, hx.len, hx.chk); 522 523 buf[0] = hx.len; 524 buf[1] = (hx.addr >> 8) & 0xff; 525 buf[2] = hx.addr & 0xff; 526 buf[3] = hx.type; 527 memcpy(&buf[4],hx.data,hx.len); 528 buf[4+hx.len] = hx.chk; 529 530 ret = usb_bulk_msg(udev, 531 usb_sndbulkpipe(udev, 0x01), 532 buf, 533 hx.len + 5, 534 &act_len, 535 1000); 536 537 if (ret < 0) { 538 err("firmware download failed at %d with %d",pos,ret); 539 goto out; 540 } 541 } 542 543 if (ret == 0) { 544 /* start the firmware */ 545 if ((ret = dib0700_jumpram(udev, 0x70000000)) == 0) { 546 info("firmware started successfully."); 547 msleep(500); 548 } 549 } else 550 ret = -EIO; 551 552 /* the number of ts packet has to be at least 1 */ 553 if (nb_packet_buffer_size < 1) 554 nb_packet_buffer_size = 1; 555 556 /* get the firmware version */ 557 usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 558 REQUEST_GET_VERSION, 559 USB_TYPE_VENDOR | USB_DIR_IN, 0, 0, 560 buf, 16, USB_CTRL_GET_TIMEOUT); 561 fw_version = (buf[8] << 24) | (buf[9] << 16) | (buf[10] << 8) | buf[11]; 562 563 /* set the buffer size - DVB-USB is allocating URB buffers 564 * only after the firwmare download was successful */ 565 for (i = 0; i < dib0700_device_count; i++) { 566 for (adap_num = 0; adap_num < dib0700_devices[i].num_adapters; 567 adap_num++) { 568 if (fw_version >= 0x10201) { 569 dib0700_devices[i].adapter[adap_num].fe[0].stream.u.bulk.buffersize = 188*nb_packet_buffer_size; 570 } else { 571 /* for fw version older than 1.20.1, 572 * the buffersize has to be n times 512 */ 573 dib0700_devices[i].adapter[adap_num].fe[0].stream.u.bulk.buffersize = ((188*nb_packet_buffer_size+188/2)/512)*512; 574 if (dib0700_devices[i].adapter[adap_num].fe[0].stream.u.bulk.buffersize < 512) 575 dib0700_devices[i].adapter[adap_num].fe[0].stream.u.bulk.buffersize = 512; 576 } 577 } 578 } 579 out: 580 kfree(buf); 581 return ret; 582 } 583 584 int dib0700_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff) 585 { 586 struct dib0700_state *st = adap->dev->priv; 587 int ret; 588 589 if ((onoff != 0) && (st->fw_version >= 0x10201)) { 590 /* for firmware later than 1.20.1, 591 * the USB xfer length can be set */ 592 ret = dib0700_set_usb_xfer_len(adap->dev, 593 st->nb_packet_buffer_size); 594 if (ret < 0) { 595 deb_info("can not set the USB xfer len\n"); 596 return ret; 597 } 598 } 599 600 mutex_lock(&adap->dev->usb_mutex); 601 602 st->buf[0] = REQUEST_ENABLE_VIDEO; 603 /* this bit gives a kind of command, 604 * rather than enabling something or not */ 605 st->buf[1] = (onoff << 4) | 0x00; 606 607 if (st->disable_streaming_master_mode == 1) 608 st->buf[2] = 0x00; 609 else 610 st->buf[2] = 0x01 << 4; /* Master mode */ 611 612 st->buf[3] = 0x00; 613 614 deb_info("modifying (%d) streaming state for %d\n", onoff, adap->id); 615 616 st->channel_state &= ~0x3; 617 if ((adap->fe_adap[0].stream.props.endpoint != 2) 618 && (adap->fe_adap[0].stream.props.endpoint != 3)) { 619 deb_info("the endpoint number (%i) is not correct, use the adapter id instead", adap->fe_adap[0].stream.props.endpoint); 620 if (onoff) 621 st->channel_state |= 1 << (adap->id); 622 else 623 st->channel_state |= 1 << ~(adap->id); 624 } else { 625 if (onoff) 626 st->channel_state |= 1 << (adap->fe_adap[0].stream.props.endpoint-2); 627 else 628 st->channel_state |= 1 << (3-adap->fe_adap[0].stream.props.endpoint); 629 } 630 631 st->buf[2] |= st->channel_state; 632 633 deb_info("data for streaming: %x %x\n", st->buf[1], st->buf[2]); 634 635 ret = dib0700_ctrl_wr(adap->dev, st->buf, 4); 636 mutex_unlock(&adap->dev->usb_mutex); 637 638 return ret; 639 } 640 641 int dib0700_change_protocol(struct rc_dev *rc, u64 *rc_proto) 642 { 643 struct dvb_usb_device *d = rc->priv; 644 struct dib0700_state *st = d->priv; 645 int new_proto, ret; 646 647 if (mutex_lock_interruptible(&d->usb_mutex) < 0) { 648 err("could not acquire lock"); 649 return -EINTR; 650 } 651 652 st->buf[0] = REQUEST_SET_RC; 653 st->buf[1] = 0; 654 st->buf[2] = 0; 655 656 /* Set the IR mode */ 657 if (*rc_proto & RC_PROTO_BIT_RC5) { 658 new_proto = 1; 659 *rc_proto = RC_PROTO_BIT_RC5; 660 } else if (*rc_proto & RC_PROTO_BIT_NEC) { 661 new_proto = 0; 662 *rc_proto = RC_PROTO_BIT_NEC; 663 } else if (*rc_proto & RC_PROTO_BIT_RC6_MCE) { 664 if (st->fw_version < 0x10200) { 665 ret = -EINVAL; 666 goto out; 667 } 668 new_proto = 2; 669 *rc_proto = RC_PROTO_BIT_RC6_MCE; 670 } else { 671 ret = -EINVAL; 672 goto out; 673 } 674 675 st->buf[1] = new_proto; 676 677 ret = dib0700_ctrl_wr(d, st->buf, 3); 678 if (ret < 0) { 679 err("ir protocol setup failed"); 680 goto out; 681 } 682 683 d->props.rc.core.protocol = *rc_proto; 684 685 out: 686 mutex_unlock(&d->usb_mutex); 687 return ret; 688 } 689 690 /* This is the structure of the RC response packet starting in firmware 1.20 */ 691 struct dib0700_rc_response { 692 u8 report_id; 693 u8 data_state; 694 union { 695 struct { 696 u8 system; 697 u8 not_system; 698 u8 data; 699 u8 not_data; 700 } nec; 701 struct { 702 u8 not_used; 703 u8 system; 704 u8 data; 705 u8 not_data; 706 } rc5; 707 }; 708 }; 709 #define RC_MSG_SIZE_V1_20 6 710 711 static void dib0700_rc_urb_completion(struct urb *purb) 712 { 713 struct dvb_usb_device *d = purb->context; 714 struct dib0700_rc_response *poll_reply; 715 enum rc_proto protocol; 716 u32 keycode; 717 u8 toggle; 718 719 deb_info("%s()\n", __func__); 720 if (d->rc_dev == NULL) { 721 /* This will occur if disable_rc_polling=1 */ 722 kfree(purb->transfer_buffer); 723 usb_free_urb(purb); 724 return; 725 } 726 727 poll_reply = purb->transfer_buffer; 728 729 if (purb->status < 0) { 730 deb_info("discontinuing polling\n"); 731 kfree(purb->transfer_buffer); 732 usb_free_urb(purb); 733 return; 734 } 735 736 if (purb->actual_length != RC_MSG_SIZE_V1_20) { 737 deb_info("malformed rc msg size=%d\n", purb->actual_length); 738 goto resubmit; 739 } 740 741 deb_data("IR ID = %02X state = %02X System = %02X %02X Cmd = %02X %02X (len %d)\n", 742 poll_reply->report_id, poll_reply->data_state, 743 poll_reply->nec.system, poll_reply->nec.not_system, 744 poll_reply->nec.data, poll_reply->nec.not_data, 745 purb->actual_length); 746 747 switch (d->props.rc.core.protocol) { 748 case RC_PROTO_BIT_NEC: 749 toggle = 0; 750 751 /* NEC protocol sends repeat code as 0 0 0 FF */ 752 if (poll_reply->nec.system == 0x00 && 753 poll_reply->nec.not_system == 0x00 && 754 poll_reply->nec.data == 0x00 && 755 poll_reply->nec.not_data == 0xff) { 756 poll_reply->data_state = 2; 757 rc_repeat(d->rc_dev); 758 goto resubmit; 759 } 760 761 if ((poll_reply->nec.data ^ poll_reply->nec.not_data) != 0xff) { 762 deb_data("NEC32 protocol\n"); 763 keycode = RC_SCANCODE_NEC32(poll_reply->nec.system << 24 | 764 poll_reply->nec.not_system << 16 | 765 poll_reply->nec.data << 8 | 766 poll_reply->nec.not_data); 767 protocol = RC_PROTO_NEC32; 768 } else if ((poll_reply->nec.system ^ poll_reply->nec.not_system) != 0xff) { 769 deb_data("NEC extended protocol\n"); 770 keycode = RC_SCANCODE_NECX(poll_reply->nec.system << 8 | 771 poll_reply->nec.not_system, 772 poll_reply->nec.data); 773 774 protocol = RC_PROTO_NECX; 775 } else { 776 deb_data("NEC normal protocol\n"); 777 keycode = RC_SCANCODE_NEC(poll_reply->nec.system, 778 poll_reply->nec.data); 779 protocol = RC_PROTO_NEC; 780 } 781 782 break; 783 default: 784 deb_data("RC5 protocol\n"); 785 protocol = RC_PROTO_RC5; 786 toggle = poll_reply->report_id; 787 keycode = RC_SCANCODE_RC5(poll_reply->rc5.system, poll_reply->rc5.data); 788 789 if ((poll_reply->rc5.data ^ poll_reply->rc5.not_data) != 0xff) { 790 /* Key failed integrity check */ 791 err("key failed integrity check: %02x %02x %02x %02x", 792 poll_reply->rc5.not_used, poll_reply->rc5.system, 793 poll_reply->rc5.data, poll_reply->rc5.not_data); 794 goto resubmit; 795 } 796 797 break; 798 } 799 800 rc_keydown(d->rc_dev, protocol, keycode, toggle); 801 802 resubmit: 803 /* Clean the buffer before we requeue */ 804 memset(purb->transfer_buffer, 0, RC_MSG_SIZE_V1_20); 805 806 /* Requeue URB */ 807 usb_submit_urb(purb, GFP_ATOMIC); 808 } 809 810 int dib0700_rc_setup(struct dvb_usb_device *d, struct usb_interface *intf) 811 { 812 struct dib0700_state *st = d->priv; 813 struct urb *purb; 814 const struct usb_endpoint_descriptor *e; 815 int ret, rc_ep = 1; 816 unsigned int pipe = 0; 817 818 /* Poll-based. Don't initialize bulk mode */ 819 if (st->fw_version < 0x10200 || !intf) 820 return 0; 821 822 /* Starting in firmware 1.20, the RC info is provided on a bulk pipe */ 823 824 if (intf->altsetting[0].desc.bNumEndpoints < rc_ep + 1) 825 return -ENODEV; 826 827 purb = usb_alloc_urb(0, GFP_KERNEL); 828 if (purb == NULL) 829 return -ENOMEM; 830 831 purb->transfer_buffer = kzalloc(RC_MSG_SIZE_V1_20, GFP_KERNEL); 832 if (purb->transfer_buffer == NULL) { 833 err("rc kzalloc failed"); 834 usb_free_urb(purb); 835 return -ENOMEM; 836 } 837 838 purb->status = -EINPROGRESS; 839 840 /* 841 * Some devices like the Hauppauge NovaTD model 52009 use an interrupt 842 * endpoint, while others use a bulk one. 843 */ 844 e = &intf->altsetting[0].endpoint[rc_ep].desc; 845 if (usb_endpoint_dir_in(e)) { 846 if (usb_endpoint_xfer_bulk(e)) { 847 pipe = usb_rcvbulkpipe(d->udev, rc_ep); 848 usb_fill_bulk_urb(purb, d->udev, pipe, 849 purb->transfer_buffer, 850 RC_MSG_SIZE_V1_20, 851 dib0700_rc_urb_completion, d); 852 853 } else if (usb_endpoint_xfer_int(e)) { 854 pipe = usb_rcvintpipe(d->udev, rc_ep); 855 usb_fill_int_urb(purb, d->udev, pipe, 856 purb->transfer_buffer, 857 RC_MSG_SIZE_V1_20, 858 dib0700_rc_urb_completion, d, 1); 859 } 860 } 861 862 if (!pipe) { 863 err("There's no endpoint for remote controller"); 864 kfree(purb->transfer_buffer); 865 usb_free_urb(purb); 866 return 0; 867 } 868 869 ret = usb_submit_urb(purb, GFP_ATOMIC); 870 if (ret) { 871 err("rc submit urb failed"); 872 kfree(purb->transfer_buffer); 873 usb_free_urb(purb); 874 } 875 876 return ret; 877 } 878 879 static int dib0700_probe(struct usb_interface *intf, 880 const struct usb_device_id *id) 881 { 882 int i; 883 struct dvb_usb_device *dev; 884 885 for (i = 0; i < dib0700_device_count; i++) 886 if (dvb_usb_device_init(intf, &dib0700_devices[i], THIS_MODULE, 887 &dev, adapter_nr) == 0) { 888 struct dib0700_state *st = dev->priv; 889 u32 hwversion, romversion, fw_version, fwtype; 890 891 dib0700_get_version(dev, &hwversion, &romversion, 892 &fw_version, &fwtype); 893 894 deb_info("Firmware version: %x, %d, 0x%x, %d\n", 895 hwversion, romversion, fw_version, fwtype); 896 897 st->fw_version = fw_version; 898 st->nb_packet_buffer_size = (u32)nb_packet_buffer_size; 899 900 /* Disable polling mode on newer firmwares */ 901 if (st->fw_version >= 0x10200) 902 dev->props.rc.core.bulk_mode = true; 903 else 904 dev->props.rc.core.bulk_mode = false; 905 906 dib0700_rc_setup(dev, intf); 907 908 return 0; 909 } 910 911 return -ENODEV; 912 } 913 914 static void dib0700_disconnect(struct usb_interface *intf) 915 { 916 struct dvb_usb_device *d = usb_get_intfdata(intf); 917 struct dib0700_state *st = d->priv; 918 struct i2c_client *client; 919 920 /* remove I2C client for tuner */ 921 client = st->i2c_client_tuner; 922 if (client) { 923 module_put(client->dev.driver->owner); 924 i2c_unregister_device(client); 925 } 926 927 /* remove I2C client for demodulator */ 928 client = st->i2c_client_demod; 929 if (client) { 930 module_put(client->dev.driver->owner); 931 i2c_unregister_device(client); 932 } 933 934 dvb_usb_device_exit(intf); 935 } 936 937 938 static struct usb_driver dib0700_driver = { 939 .name = "dvb_usb_dib0700", 940 .probe = dib0700_probe, 941 .disconnect = dib0700_disconnect, 942 .id_table = dib0700_usb_id_table, 943 }; 944 945 module_usb_driver(dib0700_driver); 946 947 MODULE_FIRMWARE("dvb-usb-dib0700-1.20.fw"); 948 MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@posteo.de>"); 949 MODULE_DESCRIPTION("Driver for devices based on DiBcom DiB0700 - USB bridge"); 950 MODULE_VERSION("1.0"); 951 MODULE_LICENSE("GPL"); 952