treewide: Replace GPLv2 boilerplate/reference with SPDX - rule 157
[sfrench/cifs-2.6.git] / drivers / media / usb / dvb-usb-v2 / af9015.c
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                 /* fall through */
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);