xref: /openbmc/linux/drivers/media/usb/dvb-usb-v2/af9015.c (revision 9a87ffc99ec8eb8d35eed7c4f816d75f5cc9662e)
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  
af9015_ctrl_msg(struct dvb_usb_device * d,struct req_t * req)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  
af9015_write_reg_i2c(struct dvb_usb_device * d,u8 addr,u16 reg,u8 val)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  
af9015_read_reg_i2c(struct dvb_usb_device * d,u8 addr,u16 reg,u8 * val)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  
af9015_i2c_xfer(struct i2c_adapter * adap,struct i2c_msg msg[],int num)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  
af9015_i2c_func(struct i2c_adapter * adapter)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  
af9015_identify_state(struct dvb_usb_device * d,const char ** name)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  
af9015_download_firmware(struct dvb_usb_device * d,const struct firmware * firmware)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 */
af9015_eeprom_hash(struct dvb_usb_device * d)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  
af9015_read_config(struct dvb_usb_device * d)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  
af9015_get_stream_config(struct dvb_frontend * fe,u8 * ts_type,struct usb_data_stream_properties * stream)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  
af9015_streaming_ctrl(struct dvb_frontend * fe,int onoff)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  
af9015_get_adapter_count(struct dvb_usb_device * d)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 */
af9015_af9013_set_frontend(struct dvb_frontend * fe)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 */
af9015_af9013_read_status(struct dvb_frontend * fe,enum fe_status * status)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 */
af9015_af9013_init(struct dvb_frontend * fe)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 */
af9015_af9013_sleep(struct dvb_frontend * fe)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 */
af9015_tuner_init(struct dvb_frontend * fe)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 */
af9015_tuner_sleep(struct dvb_frontend * fe)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  
af9015_copy_firmware(struct dvb_usb_device * d)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  
af9015_af9013_frontend_attach(struct dvb_usb_adapter * adap)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  
af9015_frontend_detach(struct dvb_usb_adapter * adap)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  
af9015_tuner_attach(struct dvb_usb_adapter * adap)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  
af9015_pid_filter_ctrl(struct dvb_usb_adapter * adap,int onoff)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  
af9015_pid_filter(struct dvb_usb_adapter * adap,int index,u16 pid,int onoff)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  
af9015_init(struct dvb_usb_device * d)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  
af9015_rc_setup_match(unsigned int id,const struct af9015_rc_setup * table)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  
af9015_rc_query(struct dvb_usb_device * d)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  
af9015_get_rc_config(struct dvb_usb_device * d,struct dvb_usb_rc * rc)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  
af9015_regmap_write(void * context,const void * data,size_t count)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  
af9015_regmap_read(void * context,const void * reg_buf,size_t reg_size,void * val_buf,size_t val_size)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  
af9015_probe(struct dvb_usb_device * d)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  
af9015_disconnect(struct dvb_usb_device * d)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);
1557