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