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