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