1 /* Linux driver for devices based on the DiBcom DiB0700 USB bridge
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.
7 * Copyright (C) 2005-6 DiBcom, SA
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);
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)");
21 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
24 int dib0700_get_version(struct dvb_usb_device *d, u32 *hwversion,
25 u32 *romversion, u32 *ramversion, u32 *fwtype)
27 struct dib0700_state *st = d->priv;
30 if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
31 err("could not acquire lock");
35 ret = usb_control_msg(d->udev, usb_rcvctrlpipe(d->udev, 0),
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];
49 *fwtype = (st->buf[12] << 24) | (st->buf[13] << 16) |
50 (st->buf[14] << 8) | st->buf[15];
51 mutex_unlock(&d->usb_mutex);
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)
61 debug_dump(tx, txlen, deb_data);
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);
68 deb_data("ep 0 write error (status = %d, len: %d)\n",status,txlen);
70 return status < 0 ? status : 0;
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)
80 err("tx buffer length is smaller than 2. Makes no sense.");
84 err("tx buffer length is larger than 4. Not supported.");
89 debug_dump(tx,txlen,deb_data);
91 value = ((txlen - 2) << 8) | tx[1];
94 index |= (tx[2] << 8);
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);
103 deb_info("ep 0 read error (status = %d)\n",status);
106 debug_dump(rx, rxlen, deb_data);
108 return status; /* length in case of success */
111 int dib0700_set_gpio(struct dvb_usb_device *d, enum dib07x0_gpios gpio, u8 gpio_dir, u8 gpio_val)
113 struct dib0700_state *st = d->priv;
116 if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
117 err("could not acquire lock");
121 st->buf[0] = REQUEST_SET_GPIO;
123 st->buf[2] = ((gpio_dir & 0x01) << 7) | ((gpio_val & 0x01) << 6);
125 ret = dib0700_ctrl_wr(d, st->buf, 3);
127 mutex_unlock(&d->usb_mutex);
131 static int dib0700_set_usb_xfer_len(struct dvb_usb_device *d, u16 nb_ts_packets)
133 struct dib0700_state *st = d->priv;
136 if (st->fw_version >= 0x10201) {
137 if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
138 err("could not acquire lock");
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;
146 deb_info("set the USB xfer len to %i Ts packet\n", nb_ts_packets);
148 ret = dib0700_ctrl_wr(d, st->buf, 3);
149 mutex_unlock(&d->usb_mutex);
151 deb_info("this firmware does not allow to change the USB xfer len\n");
159 * I2C master xfer function (supported in 1.20 firmware)
161 static int dib0700_i2c_xfer_new(struct i2c_adapter *adap, struct i2c_msg *msg,
164 /* The new i2c firmware messages are more reliable and in particular
165 properly support i2c read calls not preceded by a write */
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;
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)
180 for (i = 0; i < num; i++) {
182 /* First message in the transaction */
184 } else if (!(msg[i].flags & I2C_M_NOSTART)) {
185 /* Device supports repeated-start */
188 /* Not the first packet and device doesn't support
192 if (i == (num - 1)) {
193 /* Last message in the transaction */
197 if (msg[i].flags & I2C_M_RD) {
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);
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,
215 USB_CTRL_GET_TIMEOUT);
217 deb_info("i2c read error (status = %d)\n", result);
221 if (msg[i].len > sizeof(st->buf)) {
222 deb_info("buffer too small to fit %d bytes\n",
228 memcpy(msg[i].buf, st->buf, msg[i].len);
231 debug_dump(msg[i].buf, msg[i].len, deb_data);
235 if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
236 err("could not acquire lock");
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) |
244 /* I2C ctrl + FE bus; */
245 st->buf[3] = ((gen_mode << 6) & 0xC0) |
246 ((bus_mode << 4) & 0x30);
248 if (msg[i].len > sizeof(st->buf) - 4) {
249 deb_info("i2c message to big: %d\n",
251 mutex_unlock(&d->usb_mutex);
256 /* The Actual i2c payload */
257 memcpy(&st->buf[4], msg[i].buf, msg[i].len);
260 debug_dump(st->buf, msg[i].len + 4, deb_data);
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);
270 deb_info("i2c write error (status = %d)\n", result);
278 mutex_unlock(&d->i2c_mutex);
283 * I2C master xfer function (pre-1.20 firmware)
285 static int dib0700_i2c_xfer_legacy(struct i2c_adapter *adap,
286 struct i2c_msg *msg, int num)
288 struct dvb_usb_device *d = i2c_get_adapdata(adap);
289 struct dib0700_state *st = d->priv;
292 if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
294 if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
295 err("could not acquire lock");
296 mutex_unlock(&d->i2c_mutex);
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",
310 memcpy(&st->buf[2], msg[i].buf, msg[i].len);
312 /* write/read request */
313 if (i+1 < num && (msg[i+1].flags & I2C_M_RD)) {
314 st->buf[0] = REQUEST_I2C_READ;
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);
321 deb_info("I2C read failed on address 0x%02x\n",
327 if (msg[i + 1].len > sizeof(st->buf)) {
328 deb_info("i2c xfer buffer to small for %d\n",
333 memcpy(msg[i + 1].buf, st->buf, msg[i + 1].len);
339 st->buf[0] = REQUEST_I2C_WRITE;
340 result = dib0700_ctrl_wr(d, st->buf, msg[i].len + 2);
347 mutex_unlock(&d->usb_mutex);
348 mutex_unlock(&d->i2c_mutex);
353 static int dib0700_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg *msg,
356 struct dvb_usb_device *d = i2c_get_adapdata(adap);
357 struct dib0700_state *st = d->priv;
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);
363 /* Use legacy calls */
364 return dib0700_i2c_xfer_legacy(adap, msg, num);
368 static u32 dib0700_i2c_func(struct i2c_adapter *adapter)
373 struct i2c_algorithm dib0700_i2c_algo = {
374 .master_xfer = dib0700_i2c_xfer,
375 .functionality = dib0700_i2c_func,
378 int dib0700_identify_state(struct usb_device *udev, struct dvb_usb_device_properties *props,
379 struct dvb_usb_device_description **desc, int *cold)
384 b = kmalloc(16, GFP_KERNEL);
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);
392 deb_info("FW GET_VERSION length: %d\n",ret);
395 deb_info("cold: %d\n", *cold);
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)
405 struct dib0700_state *st = d->priv;
408 if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
409 err("could not acquire lock");
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 */
425 ret = dib0700_ctrl_wr(d, st->buf, 10);
426 mutex_unlock(&d->usb_mutex);
431 int dib0700_set_i2c_speed(struct dvb_usb_device *d, u16 scl_kHz)
433 struct dib0700_state *st = d->priv;
440 if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
441 err("could not acquire lock");
445 st->buf[0] = REQUEST_SET_I2C_PARAM;
446 divider = (u16) (30000 / scl_kHz);
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);
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);
461 ret = dib0700_ctrl_wr(d, st->buf, 8);
462 mutex_unlock(&d->usb_mutex);
468 int dib0700_ctrl_clock(struct dvb_usb_device *d, u32 clk_MHz, u8 clock_out_gp3)
471 case 72: dib0700_set_clock(d, 1, 0, 1, clock_out_gp3, 2, 24, 0, 0x4c); break;
472 default: return -EINVAL;
477 static int dib0700_jumpram(struct usb_device *udev, u32 address)
482 buf = kmalloc(8, GFP_KERNEL);
485 buf[0] = REQUEST_JUMPRAM;
489 buf[4] = (address >> 24) & 0xff;
490 buf[5] = (address >> 16) & 0xff;
491 buf[6] = (address >> 8) & 0xff;
492 buf[7] = address & 0xff;
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);
499 deb_fw("jumpram to 0x%x failed\n",address);
508 int dib0700_download_firmware(struct usb_device *udev, const struct firmware *fw)
511 int pos = 0, ret, act_len, i, adap_num;
515 buf = kmalloc(260, GFP_KERNEL);
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);
524 buf[1] = (hx.addr >> 8) & 0xff;
525 buf[2] = hx.addr & 0xff;
527 memcpy(&buf[4],hx.data,hx.len);
528 buf[4+hx.len] = hx.chk;
530 ret = usb_bulk_msg(udev,
531 usb_sndbulkpipe(udev, 0x01),
538 err("firmware download failed at %d with %d",pos,ret);
544 /* start the firmware */
545 if ((ret = dib0700_jumpram(udev, 0x70000000)) == 0) {
546 info("firmware started successfully.");
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;
556 /* get the firmware version */
557 usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
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];
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;
568 if (fw_version >= 0x10201) {
569 dib0700_devices[i].adapter[adap_num].fe[0].stream.u.bulk.buffersize = 188*nb_packet_buffer_size;
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;
584 int dib0700_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
586 struct dib0700_state *st = adap->dev->priv;
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);
595 deb_info("can not set the USB xfer len\n");
600 mutex_lock(&adap->dev->usb_mutex);
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;
607 if (st->disable_streaming_master_mode == 1)
610 st->buf[2] = 0x01 << 4; /* Master mode */
614 deb_info("modifying (%d) streaming state for %d\n", onoff, adap->id);
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);
621 st->channel_state |= 1 << (adap->id);
624 st->channel_state |= 1 << (adap->fe_adap[0].stream.props.endpoint-2);
626 st->channel_state |= 1 << (3-adap->fe_adap[0].stream.props.endpoint);
629 st->buf[2] |= st->channel_state;
631 deb_info("data for streaming: %x %x\n", st->buf[1], st->buf[2]);
633 ret = dib0700_ctrl_wr(adap->dev, st->buf, 4);
634 mutex_unlock(&adap->dev->usb_mutex);
639 int dib0700_change_protocol(struct rc_dev *rc, u64 *rc_proto)
641 struct dvb_usb_device *d = rc->priv;
642 struct dib0700_state *st = d->priv;
645 if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
646 err("could not acquire lock");
650 st->buf[0] = REQUEST_SET_RC;
654 /* Set the IR mode */
655 if (*rc_proto & RC_PROTO_BIT_RC5) {
657 *rc_proto = RC_PROTO_BIT_RC5;
658 } else if (*rc_proto & RC_PROTO_BIT_NEC) {
660 *rc_proto = RC_PROTO_BIT_NEC;
661 } else if (*rc_proto & RC_PROTO_BIT_RC6_MCE) {
662 if (st->fw_version < 0x10200) {
667 *rc_proto = RC_PROTO_BIT_RC6_MCE;
673 st->buf[1] = new_proto;
675 ret = dib0700_ctrl_wr(d, st->buf, 3);
677 err("ir protocol setup failed");
681 d->props.rc.core.protocol = *rc_proto;
684 mutex_unlock(&d->usb_mutex);
688 /* This is the structure of the RC response packet starting in firmware 1.20 */
689 struct dib0700_rc_response {
707 #define RC_MSG_SIZE_V1_20 6
709 static void dib0700_rc_urb_completion(struct urb *purb)
711 struct dvb_usb_device *d = purb->context;
712 struct dib0700_rc_response *poll_reply;
713 enum rc_proto protocol;
717 deb_info("%s()\n", __func__);
718 if (d->rc_dev == NULL) {
719 /* This will occur if disable_rc_polling=1 */
720 kfree(purb->transfer_buffer);
725 poll_reply = purb->transfer_buffer;
727 if (purb->status < 0) {
728 deb_info("discontinuing polling\n");
729 kfree(purb->transfer_buffer);
734 if (purb->actual_length != RC_MSG_SIZE_V1_20) {
735 deb_info("malformed rc msg size=%d\n", purb->actual_length);
739 deb_data("IR ID = %02X state = %02X System = %02X %02X Cmd = %02X %02X (len %d)\n",
740 poll_reply->report_id, poll_reply->data_state,
741 poll_reply->nec.system, poll_reply->nec.not_system,
742 poll_reply->nec.data, poll_reply->nec.not_data,
743 purb->actual_length);
745 switch (d->props.rc.core.protocol) {
746 case RC_PROTO_BIT_NEC:
749 /* NEC protocol sends repeat code as 0 0 0 FF */
750 if (poll_reply->nec.system == 0x00 &&
751 poll_reply->nec.not_system == 0x00 &&
752 poll_reply->nec.data == 0x00 &&
753 poll_reply->nec.not_data == 0xff) {
754 poll_reply->data_state = 2;
755 rc_repeat(d->rc_dev);
759 if ((poll_reply->nec.data ^ poll_reply->nec.not_data) != 0xff) {
760 deb_data("NEC32 protocol\n");
761 keycode = RC_SCANCODE_NEC32(poll_reply->nec.system << 24 |
762 poll_reply->nec.not_system << 16 |
763 poll_reply->nec.data << 8 |
764 poll_reply->nec.not_data);
765 protocol = RC_PROTO_NEC32;
766 } else if ((poll_reply->nec.system ^ poll_reply->nec.not_system) != 0xff) {
767 deb_data("NEC extended protocol\n");
768 keycode = RC_SCANCODE_NECX(poll_reply->nec.system << 8 |
769 poll_reply->nec.not_system,
770 poll_reply->nec.data);
772 protocol = RC_PROTO_NECX;
774 deb_data("NEC normal protocol\n");
775 keycode = RC_SCANCODE_NEC(poll_reply->nec.system,
776 poll_reply->nec.data);
777 protocol = RC_PROTO_NEC;
782 deb_data("RC5 protocol\n");
783 protocol = RC_PROTO_RC5;
784 toggle = poll_reply->report_id;
785 keycode = RC_SCANCODE_RC5(poll_reply->rc5.system, poll_reply->rc5.data);
787 if ((poll_reply->rc5.data ^ poll_reply->rc5.not_data) != 0xff) {
788 /* Key failed integrity check */
789 err("key failed integrity check: %02x %02x %02x %02x",
790 poll_reply->rc5.not_used, poll_reply->rc5.system,
791 poll_reply->rc5.data, poll_reply->rc5.not_data);
798 rc_keydown(d->rc_dev, protocol, keycode, toggle);
801 /* Clean the buffer before we requeue */
802 memset(purb->transfer_buffer, 0, RC_MSG_SIZE_V1_20);
805 usb_submit_urb(purb, GFP_ATOMIC);
808 int dib0700_rc_setup(struct dvb_usb_device *d, struct usb_interface *intf)
810 struct dib0700_state *st = d->priv;
812 const struct usb_endpoint_descriptor *e;
814 unsigned int pipe = 0;
816 /* Poll-based. Don't initialize bulk mode */
817 if (st->fw_version < 0x10200 || !intf)
820 /* Starting in firmware 1.20, the RC info is provided on a bulk pipe */
822 if (intf->cur_altsetting->desc.bNumEndpoints < rc_ep + 1)
825 purb = usb_alloc_urb(0, GFP_KERNEL);
829 purb->transfer_buffer = kzalloc(RC_MSG_SIZE_V1_20, GFP_KERNEL);
830 if (purb->transfer_buffer == NULL) {
831 err("rc kzalloc failed");
836 purb->status = -EINPROGRESS;
839 * Some devices like the Hauppauge NovaTD model 52009 use an interrupt
840 * endpoint, while others use a bulk one.
842 e = &intf->cur_altsetting->endpoint[rc_ep].desc;
843 if (usb_endpoint_dir_in(e)) {
844 if (usb_endpoint_xfer_bulk(e)) {
845 pipe = usb_rcvbulkpipe(d->udev, rc_ep);
846 usb_fill_bulk_urb(purb, d->udev, pipe,
847 purb->transfer_buffer,
849 dib0700_rc_urb_completion, d);
851 } else if (usb_endpoint_xfer_int(e)) {
852 pipe = usb_rcvintpipe(d->udev, rc_ep);
853 usb_fill_int_urb(purb, d->udev, pipe,
854 purb->transfer_buffer,
856 dib0700_rc_urb_completion, d, 1);
861 err("There's no endpoint for remote controller");
862 kfree(purb->transfer_buffer);
867 ret = usb_submit_urb(purb, GFP_ATOMIC);
869 err("rc submit urb failed");
870 kfree(purb->transfer_buffer);
877 static int dib0700_probe(struct usb_interface *intf,
878 const struct usb_device_id *id)
881 struct dvb_usb_device *dev;
883 for (i = 0; i < dib0700_device_count; i++)
884 if (dvb_usb_device_init(intf, &dib0700_devices[i], THIS_MODULE,
885 &dev, adapter_nr) == 0) {
886 struct dib0700_state *st = dev->priv;
887 u32 hwversion, romversion, fw_version, fwtype;
889 dib0700_get_version(dev, &hwversion, &romversion,
890 &fw_version, &fwtype);
892 deb_info("Firmware version: %x, %d, 0x%x, %d\n",
893 hwversion, romversion, fw_version, fwtype);
895 st->fw_version = fw_version;
896 st->nb_packet_buffer_size = (u32)nb_packet_buffer_size;
898 /* Disable polling mode on newer firmwares */
899 if (st->fw_version >= 0x10200)
900 dev->props.rc.core.bulk_mode = true;
902 dev->props.rc.core.bulk_mode = false;
904 dib0700_rc_setup(dev, intf);
912 static struct usb_driver dib0700_driver = {
913 .name = "dvb_usb_dib0700",
914 .probe = dib0700_probe,
915 .disconnect = dvb_usb_device_exit,
916 .id_table = dib0700_usb_id_table,
919 module_usb_driver(dib0700_driver);
922 MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@posteo.de>");
923 MODULE_DESCRIPTION("Driver for devices based on DiBcom DiB0700 - USB bridge");
924 MODULE_VERSION("1.0");
925 MODULE_LICENSE("GPL");