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