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