?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 3.11-rc3
[cris-mirror.git] / drivers / media / usb / dvb-usb-v2 / af9015.c
blobd556042cf312c280ede9bc1851efc1effda5c042
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 /* hash (and dump) eeprom */
401 static int af9015_eeprom_hash(struct dvb_usb_device *d)
402 {
403 struct af9015_state *state = d_to_priv(d);
404 int ret, i;
405 static const unsigned int AF9015_EEPROM_SIZE = 256;
406 u8 buf[AF9015_EEPROM_SIZE];
407 struct req_t req = {READ_I2C, AF9015_I2C_EEPROM, 0, 0, 1, 1, NULL};
408
409 /* read eeprom */
410 for (i = 0; i < AF9015_EEPROM_SIZE; i++) {
411 req.addr = i;
412 req.data = &buf[i];
413 ret = af9015_ctrl_msg(d, &req);
414 if (ret < 0)
415 goto err;
416 }
417
418 /* calculate checksum */
419 for (i = 0; i < AF9015_EEPROM_SIZE / sizeof(u32); i++) {
420 state->eeprom_sum *= GOLDEN_RATIO_PRIME_32;
421 state->eeprom_sum += le32_to_cpu(((u32 *)buf)[i]);
422 }
423
424 for (i = 0; i < AF9015_EEPROM_SIZE; i += 16)
425 dev_dbg(&d->udev->dev, "%s: %*ph\n", __func__, 16, buf + i);
426
427 dev_dbg(&d->udev->dev, "%s: eeprom sum=%.8x\n",
428 __func__, state->eeprom_sum);
429 return 0;
430 err:
431 dev_err(&d->udev->dev, "%s: eeprom failed=%d\n", KBUILD_MODNAME, ret);
432 return ret;
433 }
434
435 static int af9015_read_config(struct dvb_usb_device *d)
436 {
437 struct af9015_state *state = d_to_priv(d);
438 int ret;
439 u8 val, i, offset = 0;
440 struct req_t req = {READ_I2C, AF9015_I2C_EEPROM, 0, 0, 1, 1, &val};
441
442 dev_dbg(&d->udev->dev, "%s:\n", __func__);
443
444 /* IR remote controller */
445 req.addr = AF9015_EEPROM_IR_MODE;
446 /* first message will timeout often due to possible hw bug */
447 for (i = 0; i < 4; i++) {
448 ret = af9015_ctrl_msg(d, &req);
449 if (!ret)
450 break;
451 }
452 if (ret)
453 goto error;
454
455 ret = af9015_eeprom_hash(d);
456 if (ret)
457 goto error;
458
459 state->ir_mode = val;
460 dev_dbg(&d->udev->dev, "%s: IR mode=%d\n", __func__, val);
461
462 /* TS mode - one or two receivers */
463 req.addr = AF9015_EEPROM_TS_MODE;
464 ret = af9015_ctrl_msg(d, &req);
465 if (ret)
466 goto error;
467
468 state->dual_mode = val;
469 dev_dbg(&d->udev->dev, "%s: TS mode=%d\n", __func__, state->dual_mode);
470
471 /* disable 2nd adapter because we don't have PID-filters */
472 if (d->udev->speed == USB_SPEED_FULL)
473 state->dual_mode = 0;
474
475 if (state->dual_mode) {
476 /* read 2nd demodulator I2C address */
477 req.addr = AF9015_EEPROM_DEMOD2_I2C;
478 ret = af9015_ctrl_msg(d, &req);
479 if (ret)
480 goto error;
481
482 state->af9013_config[1].i2c_addr = val;
483 }
484
485 for (i = 0; i < state->dual_mode + 1; i++) {
486 if (i == 1)
487 offset = AF9015_EEPROM_OFFSET;
488 /* xtal */
489 req.addr = AF9015_EEPROM_XTAL_TYPE1 + offset;
490 ret = af9015_ctrl_msg(d, &req);
491 if (ret)
492 goto error;
493 switch (val) {
494 case 0:
495 state->af9013_config[i].clock = 28800000;
496 break;
497 case 1:
498 state->af9013_config[i].clock = 20480000;
499 break;
500 case 2:
501 state->af9013_config[i].clock = 28000000;
502 break;
503 case 3:
504 state->af9013_config[i].clock = 25000000;
505 break;
506 }
507 dev_dbg(&d->udev->dev, "%s: [%d] xtal=%d set clock=%d\n",
508 __func__, i, val,
509 state->af9013_config[i].clock);
510
511 /* IF frequency */
512 req.addr = AF9015_EEPROM_IF1H + offset;
513 ret = af9015_ctrl_msg(d, &req);
514 if (ret)
515 goto error;
516
517 state->af9013_config[i].if_frequency = val << 8;
518
519 req.addr = AF9015_EEPROM_IF1L + offset;
520 ret = af9015_ctrl_msg(d, &req);
521 if (ret)
522 goto error;
523
524 state->af9013_config[i].if_frequency += val;
525 state->af9013_config[i].if_frequency *= 1000;
526 dev_dbg(&d->udev->dev, "%s: [%d] IF frequency=%d\n", __func__,
527 i, state->af9013_config[i].if_frequency);
528
529 /* MT2060 IF1 */
530 req.addr = AF9015_EEPROM_MT2060_IF1H + offset;
531 ret = af9015_ctrl_msg(d, &req);
532 if (ret)
533 goto error;
534 state->mt2060_if1[i] = val << 8;
535 req.addr = AF9015_EEPROM_MT2060_IF1L + offset;
536 ret = af9015_ctrl_msg(d, &req);
537 if (ret)
538 goto error;
539 state->mt2060_if1[i] += val;
540 dev_dbg(&d->udev->dev, "%s: [%d] MT2060 IF1=%d\n", __func__, i,
541 state->mt2060_if1[i]);
542
543 /* tuner */
544 req.addr = AF9015_EEPROM_TUNER_ID1 + offset;
545 ret = af9015_ctrl_msg(d, &req);
546 if (ret)
547 goto error;
548 switch (val) {
549 case AF9013_TUNER_ENV77H11D5:
550 case AF9013_TUNER_MT2060:
551 case AF9013_TUNER_QT1010:
552 case AF9013_TUNER_UNKNOWN:
553 case AF9013_TUNER_MT2060_2:
554 case AF9013_TUNER_TDA18271:
555 case AF9013_TUNER_QT1010A:
556 case AF9013_TUNER_TDA18218:
557 state->af9013_config[i].spec_inv = 1;
558 break;
559 case AF9013_TUNER_MXL5003D:
560 case AF9013_TUNER_MXL5005D:
561 case AF9013_TUNER_MXL5005R:
562 case AF9013_TUNER_MXL5007T:
563 state->af9013_config[i].spec_inv = 0;
564 break;
565 case AF9013_TUNER_MC44S803:
566 state->af9013_config[i].gpio[1] = AF9013_GPIO_LO;
567 state->af9013_config[i].spec_inv = 1;
568 break;
569 default:
570 dev_err(&d->udev->dev, "%s: tuner id=%d not " \
571 "supported, please report!\n",
572 KBUILD_MODNAME, val);
573 return -ENODEV;
574 }
575
576 state->af9013_config[i].tuner = val;
577 dev_dbg(&d->udev->dev, "%s: [%d] tuner id=%d\n",
578 __func__, i, val);
579 }
580
581 error:
582 if (ret)
583 dev_err(&d->udev->dev, "%s: eeprom read failed=%d\n",
584 KBUILD_MODNAME, ret);
585
586 /* AverMedia AVerTV Volar Black HD (A850) device have bad EEPROM
587 content :-( Override some wrong values here. Ditto for the
588 AVerTV Red HD+ (A850T) device. */
589 if (le16_to_cpu(d->udev->descriptor.idVendor) == USB_VID_AVERMEDIA &&
590 ((le16_to_cpu(d->udev->descriptor.idProduct) ==
591 USB_PID_AVERMEDIA_A850) ||
592 (le16_to_cpu(d->udev->descriptor.idProduct) ==
593 USB_PID_AVERMEDIA_A850T))) {
594 dev_dbg(&d->udev->dev,
595 "%s: AverMedia A850: overriding config\n",
596 __func__);
597 /* disable dual mode */
598 state->dual_mode = 0;
599
600 /* set correct IF */
601 state->af9013_config[0].if_frequency = 4570000;
602 }
603
604 return ret;
605 }
606
607 static int af9015_get_stream_config(struct dvb_frontend *fe, u8 *ts_type,
608 struct usb_data_stream_properties *stream)
609 {
610 struct dvb_usb_device *d = fe_to_d(fe);
611 dev_dbg(&d->udev->dev, "%s: adap=%d\n", __func__, fe_to_adap(fe)->id);
612
613 if (d->udev->speed == USB_SPEED_FULL)
614 stream->u.bulk.buffersize = TS_USB11_FRAME_SIZE;
615
616 return 0;
617 }
618
619 static int af9015_get_adapter_count(struct dvb_usb_device *d)
620 {
621 struct af9015_state *state = d_to_priv(d);
622 return state->dual_mode + 1;
623 }
624
625 /* override demod callbacks for resource locking */
626 static int af9015_af9013_set_frontend(struct dvb_frontend *fe)
627 {
628 int ret;
629 struct af9015_state *state = fe_to_priv(fe);
630
631 if (mutex_lock_interruptible(&state->fe_mutex))
632 return -EAGAIN;
633
634 ret = state->set_frontend[fe_to_adap(fe)->id](fe);
635
636 mutex_unlock(&state->fe_mutex);
637
638 return ret;
639 }
640
641 /* override demod callbacks for resource locking */
642 static int af9015_af9013_read_status(struct dvb_frontend *fe,
643 fe_status_t *status)
644 {
645 int ret;
646 struct af9015_state *state = fe_to_priv(fe);
647
648 if (mutex_lock_interruptible(&state->fe_mutex))
649 return -EAGAIN;
650
651 ret = state->read_status[fe_to_adap(fe)->id](fe, status);
652
653 mutex_unlock(&state->fe_mutex);
654
655 return ret;
656 }
657
658 /* override demod callbacks for resource locking */
659 static int af9015_af9013_init(struct dvb_frontend *fe)
660 {
661 int ret;
662 struct af9015_state *state = fe_to_priv(fe);
663
664 if (mutex_lock_interruptible(&state->fe_mutex))
665 return -EAGAIN;
666
667 ret = state->init[fe_to_adap(fe)->id](fe);
668
669 mutex_unlock(&state->fe_mutex);
670
671 return ret;
672 }
673
674 /* override demod callbacks for resource locking */
675 static int af9015_af9013_sleep(struct dvb_frontend *fe)
676 {
677 int ret;
678 struct af9015_state *state = fe_to_priv(fe);
679
680 if (mutex_lock_interruptible(&state->fe_mutex))
681 return -EAGAIN;
682
683 ret = state->sleep[fe_to_adap(fe)->id](fe);
684
685 mutex_unlock(&state->fe_mutex);
686
687 return ret;
688 }
689
690 /* override tuner callbacks for resource locking */
691 static int af9015_tuner_init(struct dvb_frontend *fe)
692 {
693 int ret;
694 struct af9015_state *state = fe_to_priv(fe);
695
696 if (mutex_lock_interruptible(&state->fe_mutex))
697 return -EAGAIN;
698
699 ret = state->tuner_init[fe_to_adap(fe)->id](fe);
700
701 mutex_unlock(&state->fe_mutex);
702
703 return ret;
704 }
705
706 /* override tuner callbacks for resource locking */
707 static int af9015_tuner_sleep(struct dvb_frontend *fe)
708 {
709 int ret;
710 struct af9015_state *state = fe_to_priv(fe);
711
712 if (mutex_lock_interruptible(&state->fe_mutex))
713 return -EAGAIN;
714
715 ret = state->tuner_sleep[fe_to_adap(fe)->id](fe);
716
717 mutex_unlock(&state->fe_mutex);
718
719 return ret;
720 }
721
722 static int af9015_copy_firmware(struct dvb_usb_device *d)
723 {
724 struct af9015_state *state = d_to_priv(d);
725 int ret;
726 u8 fw_params[4];
727 u8 val, i;
728 struct req_t req = {COPY_FIRMWARE, 0, 0x5100, 0, 0, sizeof(fw_params),
729 fw_params };
730 dev_dbg(&d->udev->dev, "%s:\n", __func__);
731
732 fw_params[0] = state->firmware_size >> 8;
733 fw_params[1] = state->firmware_size & 0xff;
734 fw_params[2] = state->firmware_checksum >> 8;
735 fw_params[3] = state->firmware_checksum & 0xff;
736
737 /* wait 2nd demodulator ready */
738 msleep(100);
739
740 ret = af9015_read_reg_i2c(d, state->af9013_config[1].i2c_addr,
741 0x98be, &val);
742 if (ret)
743 goto error;
744 else
745 dev_dbg(&d->udev->dev, "%s: firmware status=%02x\n",
746 __func__, val);
747
748 if (val == 0x0c) /* fw is running, no need for download */
749 goto exit;
750
751 /* set I2C master clock to fast (to speed up firmware copy) */
752 ret = af9015_write_reg(d, 0xd416, 0x04); /* 0x04 * 400ns */
753 if (ret)
754 goto error;
755
756 msleep(50);
757
758 /* copy firmware */
759 ret = af9015_ctrl_msg(d, &req);
760 if (ret)
761 dev_err(&d->udev->dev, "%s: firmware copy cmd failed=%d\n",
762 KBUILD_MODNAME, ret);
763
764 dev_dbg(&d->udev->dev, "%s: firmware copy done\n", __func__);
765
766 /* set I2C master clock back to normal */
767 ret = af9015_write_reg(d, 0xd416, 0x14); /* 0x14 * 400ns */
768 if (ret)
769 goto error;
770
771 /* request boot firmware */
772 ret = af9015_write_reg_i2c(d, state->af9013_config[1].i2c_addr,
773 0xe205, 1);
774 dev_dbg(&d->udev->dev, "%s: firmware boot cmd status=%d\n",
775 __func__, ret);
776 if (ret)
777 goto error;
778
779 for (i = 0; i < 15; i++) {
780 msleep(100);
781
782 /* check firmware status */
783 ret = af9015_read_reg_i2c(d, state->af9013_config[1].i2c_addr,
784 0x98be, &val);
785 dev_dbg(&d->udev->dev, "%s: firmware status cmd status=%d " \
786 "firmware status=%02x\n", __func__, ret, val);
787 if (ret)
788 goto error;
789
790 if (val == 0x0c || val == 0x04) /* success or fail */
791 break;
792 }
793
794 if (val == 0x04) {
795 dev_err(&d->udev->dev, "%s: firmware did not run\n",
796 KBUILD_MODNAME);
797 ret = -ETIMEDOUT;
798 } else if (val != 0x0c) {
799 dev_err(&d->udev->dev, "%s: firmware boot timeout\n",
800 KBUILD_MODNAME);
801 ret = -ETIMEDOUT;
802 }
803
804 error:
805 exit:
806 return ret;
807 }
808
809 static int af9015_af9013_frontend_attach(struct dvb_usb_adapter *adap)
810 {
811 int ret;
812 struct af9015_state *state = adap_to_priv(adap);
813
814 if (adap->id == 0) {
815 state->af9013_config[0].ts_mode = AF9013_TS_USB;
816 memcpy(state->af9013_config[0].api_version, "\x0\x1\x9\x0", 4);
817 state->af9013_config[0].gpio[0] = AF9013_GPIO_HI;
818 state->af9013_config[0].gpio[3] = AF9013_GPIO_TUNER_ON;
819 } else if (adap->id == 1) {
820 state->af9013_config[1].ts_mode = AF9013_TS_SERIAL;
821 memcpy(state->af9013_config[1].api_version, "\x0\x1\x9\x0", 4);
822 state->af9013_config[1].gpio[0] = AF9013_GPIO_TUNER_ON;
823 state->af9013_config[1].gpio[1] = AF9013_GPIO_LO;
824
825 /* copy firmware to 2nd demodulator */
826 if (state->dual_mode) {
827 ret = af9015_copy_firmware(adap_to_d(adap));
828 if (ret) {
829 dev_err(&adap_to_d(adap)->udev->dev,
830 "%s: firmware copy to 2nd " \
831 "frontend failed, will " \
832 "disable it\n", KBUILD_MODNAME);
833 state->dual_mode = 0;
834 return -ENODEV;
835 }
836 } else {
837 return -ENODEV;
838 }
839 }
840
841 /* attach demodulator */
842 adap->fe[0] = dvb_attach(af9013_attach,
843 &state->af9013_config[adap->id], &adap_to_d(adap)->i2c_adap);
844
845 /*
846 * AF9015 firmware does not like if it gets interrupted by I2C adapter
847 * request on some critical phases. During normal operation I2C adapter
848 * is used only 2nd demodulator and tuner on dual tuner devices.
849 * Override demodulator callbacks and use mutex for limit access to
850 * those "critical" paths to keep AF9015 happy.
851 */
852 if (adap->fe[0]) {
853 state->set_frontend[adap->id] =
854 adap->fe[0]->ops.set_frontend;
855 adap->fe[0]->ops.set_frontend =
856 af9015_af9013_set_frontend;
857
858 state->read_status[adap->id] =
859 adap->fe[0]->ops.read_status;
860 adap->fe[0]->ops.read_status =
861 af9015_af9013_read_status;
862
863 state->init[adap->id] = adap->fe[0]->ops.init;
864 adap->fe[0]->ops.init = af9015_af9013_init;
865
866 state->sleep[adap->id] = adap->fe[0]->ops.sleep;
867 adap->fe[0]->ops.sleep = af9015_af9013_sleep;
868 }
869
870 return adap->fe[0] == NULL ? -ENODEV : 0;
871 }
872
873 static struct mt2060_config af9015_mt2060_config = {
874 .i2c_address = 0xc0,
875 .clock_out = 0,
876 };
877
878 static struct qt1010_config af9015_qt1010_config = {
879 .i2c_address = 0xc4,
880 };
881
882 static struct tda18271_config af9015_tda18271_config = {
883 .gate = TDA18271_GATE_DIGITAL,
884 .small_i2c = TDA18271_16_BYTE_CHUNK_INIT,
885 };
886
887 static struct mxl5005s_config af9015_mxl5003_config = {
888 .i2c_address = 0xc6,
889 .if_freq = IF_FREQ_4570000HZ,
890 .xtal_freq = CRYSTAL_FREQ_16000000HZ,
891 .agc_mode = MXL_SINGLE_AGC,
892 .tracking_filter = MXL_TF_DEFAULT,
893 .rssi_enable = MXL_RSSI_ENABLE,
894 .cap_select = MXL_CAP_SEL_ENABLE,
895 .div_out = MXL_DIV_OUT_4,
896 .clock_out = MXL_CLOCK_OUT_DISABLE,
897 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
898 .top = MXL5005S_TOP_25P2,
899 .mod_mode = MXL_DIGITAL_MODE,
900 .if_mode = MXL_ZERO_IF,
901 .AgcMasterByte = 0x00,
902 };
903
904 static struct mxl5005s_config af9015_mxl5005_config = {
905 .i2c_address = 0xc6,
906 .if_freq = IF_FREQ_4570000HZ,
907 .xtal_freq = CRYSTAL_FREQ_16000000HZ,
908 .agc_mode = MXL_SINGLE_AGC,
909 .tracking_filter = MXL_TF_OFF,
910 .rssi_enable = MXL_RSSI_ENABLE,
911 .cap_select = MXL_CAP_SEL_ENABLE,
912 .div_out = MXL_DIV_OUT_4,
913 .clock_out = MXL_CLOCK_OUT_DISABLE,
914 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
915 .top = MXL5005S_TOP_25P2,
916 .mod_mode = MXL_DIGITAL_MODE,
917 .if_mode = MXL_ZERO_IF,
918 .AgcMasterByte = 0x00,
919 };
920
921 static struct mc44s803_config af9015_mc44s803_config = {
922 .i2c_address = 0xc0,
923 .dig_out = 1,
924 };
925
926 static struct tda18218_config af9015_tda18218_config = {
927 .i2c_address = 0xc0,
928 .i2c_wr_max = 21, /* max wr bytes AF9015 I2C adap can handle at once */
929 };
930
931 static struct mxl5007t_config af9015_mxl5007t_config = {
932 .xtal_freq_hz = MxL_XTAL_24_MHZ,
933 .if_freq_hz = MxL_IF_4_57_MHZ,
934 };
935
936 static int af9015_tuner_attach(struct dvb_usb_adapter *adap)
937 {
938 struct dvb_usb_device *d = adap_to_d(adap);
939 struct af9015_state *state = d_to_priv(d);
940 int ret;
941 dev_dbg(&d->udev->dev, "%s:\n", __func__);
942
943 switch (state->af9013_config[adap->id].tuner) {
944 case AF9013_TUNER_MT2060:
945 case AF9013_TUNER_MT2060_2:
946 ret = dvb_attach(mt2060_attach, adap->fe[0],
947 &adap_to_d(adap)->i2c_adap, &af9015_mt2060_config,
948 state->mt2060_if1[adap->id])
949 == NULL ? -ENODEV : 0;
950 break;
951 case AF9013_TUNER_QT1010:
952 case AF9013_TUNER_QT1010A:
953 ret = dvb_attach(qt1010_attach, adap->fe[0],
954 &adap_to_d(adap)->i2c_adap,
955 &af9015_qt1010_config) == NULL ? -ENODEV : 0;
956 break;
957 case AF9013_TUNER_TDA18271:
958 ret = dvb_attach(tda18271_attach, adap->fe[0], 0xc0,
959 &adap_to_d(adap)->i2c_adap,
960 &af9015_tda18271_config) == NULL ? -ENODEV : 0;
961 break;
962 case AF9013_TUNER_TDA18218:
963 ret = dvb_attach(tda18218_attach, adap->fe[0],
964 &adap_to_d(adap)->i2c_adap,
965 &af9015_tda18218_config) == NULL ? -ENODEV : 0;
966 break;
967 case AF9013_TUNER_MXL5003D:
968 ret = dvb_attach(mxl5005s_attach, adap->fe[0],
969 &adap_to_d(adap)->i2c_adap,
970 &af9015_mxl5003_config) == NULL ? -ENODEV : 0;
971 break;
972 case AF9013_TUNER_MXL5005D:
973 case AF9013_TUNER_MXL5005R:
974 ret = dvb_attach(mxl5005s_attach, adap->fe[0],
975 &adap_to_d(adap)->i2c_adap,
976 &af9015_mxl5005_config) == NULL ? -ENODEV : 0;
977 break;
978 case AF9013_TUNER_ENV77H11D5:
979 ret = dvb_attach(dvb_pll_attach, adap->fe[0], 0xc0,
980 &adap_to_d(adap)->i2c_adap,
981 DVB_PLL_TDA665X) == NULL ? -ENODEV : 0;
982 break;
983 case AF9013_TUNER_MC44S803:
984 ret = dvb_attach(mc44s803_attach, adap->fe[0],
985 &adap_to_d(adap)->i2c_adap,
986 &af9015_mc44s803_config) == NULL ? -ENODEV : 0;
987 break;
988 case AF9013_TUNER_MXL5007T:
989 ret = dvb_attach(mxl5007t_attach, adap->fe[0],
990 &adap_to_d(adap)->i2c_adap,
991 0xc0, &af9015_mxl5007t_config) == NULL ? -ENODEV : 0;
992 break;
993 case AF9013_TUNER_UNKNOWN:
994 default:
995 dev_err(&d->udev->dev, "%s: unknown tuner id=%d\n",
996 KBUILD_MODNAME,
997 state->af9013_config[adap->id].tuner);
998 ret = -ENODEV;
999 }
1000
1001 if (adap->fe[0]->ops.tuner_ops.init) {
1002 state->tuner_init[adap->id] =
1003 adap->fe[0]->ops.tuner_ops.init;
1004 adap->fe[0]->ops.tuner_ops.init = af9015_tuner_init;
1005 }
1006
1007 if (adap->fe[0]->ops.tuner_ops.sleep) {
1008 state->tuner_sleep[adap->id] =
1009 adap->fe[0]->ops.tuner_ops.sleep;
1010 adap->fe[0]->ops.tuner_ops.sleep = af9015_tuner_sleep;
1011 }
1012
1013 return ret;
1014 }
1015
1016 static int af9015_pid_filter_ctrl(struct dvb_usb_adapter *adap, int onoff)
1017 {
1018 struct dvb_usb_device *d = adap_to_d(adap);
1019 int ret;
1020 dev_dbg(&d->udev->dev, "%s: onoff=%d\n", __func__, onoff);
1021
1022 if (onoff)
1023 ret = af9015_set_reg_bit(d, 0xd503, 0);
1024 else
1025 ret = af9015_clear_reg_bit(d, 0xd503, 0);
1026
1027 return ret;
1028 }
1029
1030 static int af9015_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid,
1031 int onoff)
1032 {
1033 struct dvb_usb_device *d = adap_to_d(adap);
1034 int ret;
1035 u8 idx;
1036 dev_dbg(&d->udev->dev, "%s: index=%d pid=%04x onoff=%d\n",
1037 __func__, index, pid, onoff);
1038
1039 ret = af9015_write_reg(d, 0xd505, (pid & 0xff));
1040 if (ret)
1041 goto error;
1042
1043 ret = af9015_write_reg(d, 0xd506, (pid >> 8));
1044 if (ret)
1045 goto error;
1046
1047 idx = ((index & 0x1f) | (1 << 5));
1048 ret = af9015_write_reg(d, 0xd504, idx);
1049
1050 error:
1051 return ret;
1052 }
1053
1054 static int af9015_init_endpoint(struct dvb_usb_device *d)
1055 {
1056 struct af9015_state *state = d_to_priv(d);
1057 int ret;
1058 u16 frame_size;
1059 u8 packet_size;
1060 dev_dbg(&d->udev->dev, "%s: USB speed=%d\n", __func__, d->udev->speed);
1061
1062 if (d->udev->speed == USB_SPEED_FULL) {
1063 frame_size = TS_USB11_FRAME_SIZE/4;
1064 packet_size = TS_USB11_MAX_PACKET_SIZE/4;
1065 } else {
1066 frame_size = TS_USB20_FRAME_SIZE/4;
1067 packet_size = TS_USB20_MAX_PACKET_SIZE/4;
1068 }
1069
1070 ret = af9015_set_reg_bit(d, 0xd507, 2); /* assert EP4 reset */
1071 if (ret)
1072 goto error;
1073 ret = af9015_set_reg_bit(d, 0xd50b, 1); /* assert EP5 reset */
1074 if (ret)
1075 goto error;
1076 ret = af9015_clear_reg_bit(d, 0xdd11, 5); /* disable EP4 */
1077 if (ret)
1078 goto error;
1079 ret = af9015_clear_reg_bit(d, 0xdd11, 6); /* disable EP5 */
1080 if (ret)
1081 goto error;
1082 ret = af9015_set_reg_bit(d, 0xdd11, 5); /* enable EP4 */
1083 if (ret)
1084 goto error;
1085 if (state->dual_mode) {
1086 ret = af9015_set_reg_bit(d, 0xdd11, 6); /* enable EP5 */
1087 if (ret)
1088 goto error;
1089 }
1090 ret = af9015_clear_reg_bit(d, 0xdd13, 5); /* disable EP4 NAK */
1091 if (ret)
1092 goto error;
1093 if (state->dual_mode) {
1094 ret = af9015_clear_reg_bit(d, 0xdd13, 6); /* disable EP5 NAK */
1095 if (ret)
1096 goto error;
1097 }
1098 /* EP4 xfer length */
1099 ret = af9015_write_reg(d, 0xdd88, frame_size & 0xff);
1100 if (ret)
1101 goto error;
1102 ret = af9015_write_reg(d, 0xdd89, frame_size >> 8);
1103 if (ret)
1104 goto error;
1105 /* EP5 xfer length */
1106 ret = af9015_write_reg(d, 0xdd8a, frame_size & 0xff);
1107 if (ret)
1108 goto error;
1109 ret = af9015_write_reg(d, 0xdd8b, frame_size >> 8);
1110 if (ret)
1111 goto error;
1112 ret = af9015_write_reg(d, 0xdd0c, packet_size); /* EP4 packet size */
1113 if (ret)
1114 goto error;
1115 ret = af9015_write_reg(d, 0xdd0d, packet_size); /* EP5 packet size */
1116 if (ret)
1117 goto error;
1118 ret = af9015_clear_reg_bit(d, 0xd507, 2); /* negate EP4 reset */
1119 if (ret)
1120 goto error;
1121 if (state->dual_mode) {
1122 ret = af9015_clear_reg_bit(d, 0xd50b, 1); /* negate EP5 reset */
1123 if (ret)
1124 goto error;
1125 }
1126
1127 /* enable / disable mp2if2 */
1128 if (state->dual_mode)
1129 ret = af9015_set_reg_bit(d, 0xd50b, 0);
1130 else
1131 ret = af9015_clear_reg_bit(d, 0xd50b, 0);
1132
1133 error:
1134 if (ret)
1135 dev_err(&d->udev->dev, "%s: endpoint init failed=%d\n",
1136 KBUILD_MODNAME, ret);
1137
1138 return ret;
1139 }
1140
1141 static int af9015_init(struct dvb_usb_device *d)
1142 {
1143 struct af9015_state *state = d_to_priv(d);
1144 int ret;
1145 dev_dbg(&d->udev->dev, "%s:\n", __func__);
1146
1147 mutex_init(&state->fe_mutex);
1148
1149 /* init RC canary */
1150 ret = af9015_write_reg(d, 0x98e9, 0xff);
1151 if (ret)
1152 goto error;
1153
1154 ret = af9015_init_endpoint(d);
1155 if (ret)
1156 goto error;
1157
1158 error:
1159 return ret;
1160 }
1161
1162 #if IS_ENABLED(CONFIG_RC_CORE)
1163 struct af9015_rc_setup {
1164 unsigned int id;
1165 char *rc_codes;
1166 };
1167
1168 static char *af9015_rc_setup_match(unsigned int id,
1169 const struct af9015_rc_setup *table)
1170 {
1171 for (; table->rc_codes; table++)
1172 if (table->id == id)
1173 return table->rc_codes;
1174 return NULL;
1175 }
1176
1177 static const struct af9015_rc_setup af9015_rc_setup_modparam[] = {
1178 { AF9015_REMOTE_A_LINK_DTU_M, RC_MAP_ALINK_DTU_M },
1179 { AF9015_REMOTE_MSI_DIGIVOX_MINI_II_V3, RC_MAP_MSI_DIGIVOX_II },
1180 { AF9015_REMOTE_MYGICTV_U718, RC_MAP_TOTAL_MEDIA_IN_HAND },
1181 { AF9015_REMOTE_DIGITTRADE_DVB_T, RC_MAP_DIGITTRADE },
1182 { AF9015_REMOTE_AVERMEDIA_KS, RC_MAP_AVERMEDIA_RM_KS },
1183 { }
1184 };
1185
1186 static const struct af9015_rc_setup af9015_rc_setup_hashes[] = {
1187 { 0xb8feb708, RC_MAP_MSI_DIGIVOX_II },
1188 { 0xa3703d00, RC_MAP_ALINK_DTU_M },
1189 { 0x9b7dc64e, RC_MAP_TOTAL_MEDIA_IN_HAND }, /* MYGICTV U718 */
1190 { 0x5d49e3db, RC_MAP_DIGITTRADE }, /* LC-Power LC-USB-DVBT */
1191 { }
1192 };
1193
1194 static int af9015_rc_query(struct dvb_usb_device *d)
1195 {
1196 struct af9015_state *state = d_to_priv(d);
1197 int ret;
1198 u8 buf[17];
1199
1200 /* read registers needed to detect remote controller code */
1201 ret = af9015_read_regs(d, 0x98d9, buf, sizeof(buf));
1202 if (ret)
1203 goto error;
1204
1205 /* If any of these are non-zero, assume invalid data */
1206 if (buf[1] || buf[2] || buf[3]) {
1207 dev_dbg(&d->udev->dev, "%s: invalid data\n", __func__);
1208 return ret;
1209 }
1210
1211 /* Check for repeat of previous code */
1212 if ((state->rc_repeat != buf[6] || buf[0]) &&
1213 !memcmp(&buf[12], state->rc_last, 4)) {
1214 dev_dbg(&d->udev->dev, "%s: key repeated\n", __func__);
1215 rc_keydown(d->rc_dev, state->rc_keycode, 0);
1216 state->rc_repeat = buf[6];
1217 return ret;
1218 }
1219
1220 /* Only process key if canary killed */
1221 if (buf[16] != 0xff && buf[0] != 0x01) {
1222 dev_dbg(&d->udev->dev, "%s: key pressed %*ph\n",
1223 __func__, 4, buf + 12);
1224
1225 /* Reset the canary */
1226 ret = af9015_write_reg(d, 0x98e9, 0xff);
1227 if (ret)
1228 goto error;
1229
1230 /* Remember this key */
1231 memcpy(state->rc_last, &buf[12], 4);
1232 if (buf[14] == (u8) ~buf[15]) {
1233 if (buf[12] == (u8) ~buf[13]) {
1234 /* NEC */
1235 state->rc_keycode = buf[12] << 8 | buf[14];
1236 } else {
1237 /* NEC extended*/
1238 state->rc_keycode = buf[12] << 16 |
1239 buf[13] << 8 | buf[14];
1240 }
1241 } else {
1242 /* 32 bit NEC */
1243 state->rc_keycode = buf[12] << 24 | buf[13] << 16 |
1244 buf[14] << 8 | buf[15];
1245 }
1246 rc_keydown(d->rc_dev, state->rc_keycode, 0);
1247 } else {
1248 dev_dbg(&d->udev->dev, "%s: no key press\n", __func__);
1249 /* Invalidate last keypress */
1250 /* Not really needed, but helps with debug */
1251 state->rc_last[2] = state->rc_last[3];
1252 }
1253
1254 state->rc_repeat = buf[6];
1255 state->rc_failed = false;
1256
1257 error:
1258 if (ret) {
1259 dev_warn(&d->udev->dev, "%s: rc query failed=%d\n",
1260 KBUILD_MODNAME, ret);
1261
1262 /* allow random errors as dvb-usb will stop polling on error */
1263 if (!state->rc_failed)
1264 ret = 0;
1265
1266 state->rc_failed = true;
1267 }
1268
1269 return ret;
1270 }
1271
1272 static int af9015_get_rc_config(struct dvb_usb_device *d, struct dvb_usb_rc *rc)
1273 {
1274 struct af9015_state *state = d_to_priv(d);
1275 u16 vid = le16_to_cpu(d->udev->descriptor.idVendor);
1276
1277 if (state->ir_mode == AF9015_IR_MODE_DISABLED)
1278 return 0;
1279
1280 /* try to load remote based module param */
1281 if (!rc->map_name)
1282 rc->map_name = af9015_rc_setup_match(dvb_usb_af9015_remote,
1283 af9015_rc_setup_modparam);
1284
1285 /* try to load remote based eeprom hash */
1286 if (!rc->map_name)
1287 rc->map_name = af9015_rc_setup_match(state->eeprom_sum,
1288 af9015_rc_setup_hashes);
1289
1290 /* try to load remote based USB iManufacturer string */
1291 if (!rc->map_name && vid == USB_VID_AFATECH) {
1292 /* Check USB manufacturer and product strings and try
1293 to determine correct remote in case of chip vendor
1294 reference IDs are used.
1295 DO NOT ADD ANYTHING NEW HERE. Use hashes instead. */
1296 char manufacturer[10];
1297 memset(manufacturer, 0, sizeof(manufacturer));
1298 usb_string(d->udev, d->udev->descriptor.iManufacturer,
1299 manufacturer, sizeof(manufacturer));
1300 if (!strcmp("MSI", manufacturer)) {
1301 /* iManufacturer 1 MSI
1302 iProduct 2 MSI K-VOX */
1303 rc->map_name = af9015_rc_setup_match(
1304 AF9015_REMOTE_MSI_DIGIVOX_MINI_II_V3,
1305 af9015_rc_setup_modparam);
1306 }
1307 }
1308
1309 /* load empty to enable rc */
1310 if (!rc->map_name)
1311 rc->map_name = RC_MAP_EMPTY;
1312
1313 rc->allowed_protos = RC_BIT_NEC;
1314 rc->query = af9015_rc_query;
1315 rc->interval = 500;
1316
1317 return 0;
1318 }
1319 #else
1320 #define af9015_get_rc_config NULL
1321 #endif
1322
1323 static int af9015_probe(struct usb_interface *intf,
1324 const struct usb_device_id *id)
1325 {
1326 struct usb_device *udev = interface_to_usbdev(intf);
1327 char manufacturer[sizeof("ITE Technologies, Inc.")];
1328
1329 memset(manufacturer, 0, sizeof(manufacturer));
1330 usb_string(udev, udev->descriptor.iManufacturer,
1331 manufacturer, sizeof(manufacturer));
1332 /*
1333 * There is two devices having same ID but different chipset. One uses
1334 * AF9015 and the other IT9135 chipset. Only difference seen on lsusb
1335 * is iManufacturer string.
1336 *
1337 * idVendor 0x0ccd TerraTec Electronic GmbH
1338 * idProduct 0x0099
1339 * bcdDevice 2.00
1340 * iManufacturer 1 Afatech
1341 * iProduct 2 DVB-T 2
1342 *
1343 * idVendor 0x0ccd TerraTec Electronic GmbH
1344 * idProduct 0x0099
1345 * bcdDevice 2.00
1346 * iManufacturer 1 ITE Technologies, Inc.
1347 * iProduct 2 DVB-T TV Stick
1348 */
1349 if ((le16_to_cpu(udev->descriptor.idVendor) == USB_VID_TERRATEC) &&
1350 (le16_to_cpu(udev->descriptor.idProduct) == 0x0099)) {
1351 if (!strcmp("ITE Technologies, Inc.", manufacturer)) {
1352 dev_dbg(&udev->dev, "%s: rejecting device\n", __func__);
1353 return -ENODEV;
1354 }
1355 }
1356
1357 return dvb_usbv2_probe(intf, id);
1358 }
1359
1360 /* interface 0 is used by DVB-T receiver and
1361 interface 1 is for remote controller (HID) */
1362 static struct dvb_usb_device_properties af9015_props = {
1363 .driver_name = KBUILD_MODNAME,
1364 .owner = THIS_MODULE,
1365 .adapter_nr = adapter_nr,
1366 .size_of_priv = sizeof(struct af9015_state),
1367
1368 .generic_bulk_ctrl_endpoint = 0x02,
1369 .generic_bulk_ctrl_endpoint_response = 0x81,
1370
1371 .identify_state = af9015_identify_state,
1372 .firmware = AF9015_FIRMWARE,
1373 .download_firmware = af9015_download_firmware,
1374
1375 .i2c_algo = &af9015_i2c_algo,
1376 .read_config = af9015_read_config,
1377 .frontend_attach = af9015_af9013_frontend_attach,
1378 .tuner_attach = af9015_tuner_attach,
1379 .init = af9015_init,
1380 .get_rc_config = af9015_get_rc_config,
1381 .get_stream_config = af9015_get_stream_config,
1382
1383 .get_adapter_count = af9015_get_adapter_count,
1384 .adapter = {
1385 {
1386 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1387 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1388 .pid_filter_count = 32,
1389 .pid_filter = af9015_pid_filter,
1390 .pid_filter_ctrl = af9015_pid_filter_ctrl,
1391
1392 .stream = DVB_USB_STREAM_BULK(0x84, 8, TS_USB20_FRAME_SIZE),
1393 }, {
1394 .stream = DVB_USB_STREAM_BULK(0x85, 8, TS_USB20_FRAME_SIZE),
1395 },
1396 },
1397 };
1398
1399 static const struct usb_device_id af9015_id_table[] = {
1400 { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9015_9015,
1401 &af9015_props, "Afatech AF9015 reference design", NULL) },
1402 { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9015_9016,
1403 &af9015_props, "Afatech AF9015 reference design", NULL) },
1404 { DVB_USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV_DONGLE_GOLD,
1405 &af9015_props, "Leadtek WinFast DTV Dongle Gold", RC_MAP_LEADTEK_Y04G0051) },
1406 { DVB_USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV71E,
1407 &af9015_props, "Pinnacle PCTV 71e", NULL) },
1408 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_399U,
1409 &af9015_props, "KWorld PlusTV Dual DVB-T Stick (DVB-T 399U)", NULL) },
1410 { DVB_USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_TINYTWIN,
1411 &af9015_props, "DigitalNow TinyTwin", RC_MAP_AZUREWAVE_AD_TU700) },
1412 { DVB_USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_AZUREWAVE_AD_TU700,
1413 &af9015_props, "TwinHan AzureWave AD-TU700(704J)", RC_MAP_AZUREWAVE_AD_TU700) },
1414 { DVB_USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_USB_XE_REV2,
1415 &af9015_props, "TerraTec Cinergy T USB XE", NULL) },
1416 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_PC160_2T,
1417 &af9015_props, "KWorld PlusTV Dual DVB-T PCI (DVB-T PC160-2T)", NULL) },
1418 { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_X,
1419 &af9015_props, "AVerMedia AVerTV DVB-T Volar X", RC_MAP_AVERMEDIA_M135A) },
1420 { DVB_USB_DEVICE(USB_VID_XTENSIONS, USB_PID_XTENSIONS_XD_380,
1421 &af9015_props, "Xtensions XD-380", NULL) },
1422 { DVB_USB_DEVICE(USB_VID_MSI_2, USB_PID_MSI_DIGIVOX_DUO,
1423 &af9015_props, "MSI DIGIVOX Duo", RC_MAP_MSI_DIGIVOX_III) },
1424 { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_X_2,
1425 &af9015_props, "Fujitsu-Siemens Slim Mobile USB DVB-T", NULL) },
1426 { DVB_USB_DEVICE(USB_VID_TELESTAR, USB_PID_TELESTAR_STARSTICK_2,
1427 &af9015_props, "Telestar Starstick 2", NULL) },
1428 { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A309,
1429 &af9015_props, "AVerMedia A309", NULL) },
1430 { DVB_USB_DEVICE(USB_VID_MSI_2, USB_PID_MSI_DIGI_VOX_MINI_III,
1431 &af9015_props, "MSI Digi VOX mini III", RC_MAP_MSI_DIGIVOX_III) },
1432 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U,
1433 &af9015_props, "KWorld USB DVB-T TV Stick II (VS-DVB-T 395U)", NULL) },
1434 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U_2,
1435 &af9015_props, "KWorld USB DVB-T TV Stick II (VS-DVB-T 395U)", NULL) },
1436 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U_3,
1437 &af9015_props, "KWorld USB DVB-T TV Stick II (VS-DVB-T 395U)", NULL) },
1438 { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_TREKSTOR_DVBT,
1439 &af9015_props, "TrekStor DVB-T USB Stick", RC_MAP_TREKSTOR) },
1440 { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A850,
1441 &af9015_props, "AverMedia AVerTV Volar Black HD (A850)", NULL) },
1442 { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A805,
1443 &af9015_props, "AverMedia AVerTV Volar GPS 805 (A805)", NULL) },
1444 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_CONCEPTRONIC_CTVDIGRCU,
1445 &af9015_props, "Conceptronic USB2.0 DVB-T CTVDIGRCU V3.0", NULL) },
1446 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_MC810,
1447 &af9015_props, "KWorld Digial MC-810", NULL) },
1448 { DVB_USB_DEVICE(USB_VID_KYE, USB_PID_GENIUS_TVGO_DVB_T03,
1449 &af9015_props, "Genius TVGo DVB-T03", NULL) },
1450 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_399U_2,
1451 &af9015_props, "KWorld PlusTV Dual DVB-T Stick (DVB-T 399U)", NULL) },
1452 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_PC160_T,
1453 &af9015_props, "KWorld PlusTV DVB-T PCI Pro Card (DVB-T PC160-T)", NULL) },
1454 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_SVEON_STV20,
1455 &af9015_props, "Sveon STV20 Tuner USB DVB-T HDTV", NULL) },
1456 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_TINYTWIN_2,
1457 &af9015_props, "DigitalNow TinyTwin v2", RC_MAP_DIGITALNOW_TINYTWIN) },
1458 { DVB_USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV2000DS,
1459 &af9015_props, "Leadtek WinFast DTV2000DS", RC_MAP_LEADTEK_Y04G0051) },
1460 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_UB383_T,
1461 &af9015_props, "KWorld USB DVB-T Stick Mobile (UB383-T)", NULL) },
1462 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U_4,
1463 &af9015_props, "KWorld USB DVB-T TV Stick II (VS-DVB-T 395U)", NULL) },
1464 { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A815M,
1465 &af9015_props, "AverMedia AVerTV Volar M (A815Mac)", NULL) },
1466 { DVB_USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_STICK_RC,
1467 &af9015_props, "TerraTec Cinergy T Stick RC", RC_MAP_TERRATEC_SLIM_2) },
1468 /* XXX: that same ID [0ccd:0099] is used by af9035 driver too */
1469 { DVB_USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_STICK_DUAL_RC,
1470 &af9015_props, "TerraTec Cinergy T Stick Dual RC", RC_MAP_TERRATEC_SLIM) },
1471 { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A850T,
1472 &af9015_props, "AverMedia AVerTV Red HD+ (A850T)", NULL) },
1473 { DVB_USB_DEVICE(USB_VID_GTEK, USB_PID_TINYTWIN_3,
1474 &af9015_props, "DigitalNow TinyTwin v3", RC_MAP_DIGITALNOW_TINYTWIN) },
1475 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_SVEON_STV22,
1476 &af9015_props, "Sveon STV22 Dual USB DVB-T Tuner HDTV", RC_MAP_MSI_DIGIVOX_III) },
1477 { }
1478 };
1479 MODULE_DEVICE_TABLE(usb, af9015_id_table);
1480
1481 /* usb specific object needed to register this driver with the usb subsystem */
1482 static struct usb_driver af9015_usb_driver = {
1483 .name = KBUILD_MODNAME,
1484 .id_table = af9015_id_table,
1485 .probe = af9015_probe,
1486 .disconnect = dvb_usbv2_disconnect,
1487 .suspend = dvb_usbv2_suspend,
1488 .resume = dvb_usbv2_resume,
1489 .reset_resume = dvb_usbv2_reset_resume,
1490 .no_dynamic_id = 1,
1491 .soft_unbind = 1,
1492 };
1493
1494 module_usb_driver(af9015_usb_driver);
1495
1496 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1497 MODULE_DESCRIPTION("Afatech AF9015 driver");
1498 MODULE_LICENSE("GPL");
1499 MODULE_FIRMWARE(AF9015_FIRMWARE);
CRIS linux kernel tree