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