1// SPDX-License-Identifier: GPL-2.0-or-later
2/* DVB USB compliant Linux driver for the Afatech 9005
3 * USB1.1 DVB-T receiver.
4 *
5 * Copyright (C) 2007 Luca Olivetti (luca@ventoso.org)
6 *
7 * Thanks to Afatech who kindly provided information.
8 *
9 * see Documentation/driver-api/media/drivers/dvb-usb.rst for more information
10 */
11#include "af9005.h"
12
13/* debug */
14int dvb_usb_af9005_debug;
15module_param_named(debug, dvb_usb_af9005_debug, int, 0644);
16MODULE_PARM_DESC(debug,
17		 "set debugging level (1=info,xfer=2,rc=4,reg=8,i2c=16,fw=32 (or-able))."
18		 DVB_USB_DEBUG_STATUS);
19/* enable obnoxious led */
20bool dvb_usb_af9005_led = true;
21module_param_named(led, dvb_usb_af9005_led, bool, 0644);
22MODULE_PARM_DESC(led, "enable led (default: 1).");
23
24/* eeprom dump */
25static int dvb_usb_af9005_dump_eeprom;
26module_param_named(dump_eeprom, dvb_usb_af9005_dump_eeprom, int, 0);
27MODULE_PARM_DESC(dump_eeprom, "dump contents of the eeprom.");
28
29DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
30
31/* remote control decoder */
32static int (*rc_decode) (struct dvb_usb_device *d, u8 *data, int len,
33		u32 *event, int *state);
34static void *rc_keys;
35static int *rc_keys_size;
36
37u8 regmask[8] = { 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff };
38
39struct af9005_device_state {
40	u8 sequence;
41	int led_state;
42	unsigned char data[256];
43};
44
45static int af9005_generic_read_write(struct dvb_usb_device *d, u16 reg,
46			      int readwrite, int type, u8 * values, int len)
47{
48	struct af9005_device_state *st = d->priv;
49	u8 command, seq;
50	int i, ret;
51
52	if (len < 1) {
53		err("generic read/write, less than 1 byte. Makes no sense.");
54		return -EINVAL;
55	}
56	if (len > 8) {
57		err("generic read/write, more than 8 bytes. Not supported.");
58		return -EINVAL;
59	}
60
61	mutex_lock(&d->data_mutex);
62	st->data[0] = 14;		/* rest of buffer length low */
63	st->data[1] = 0;		/* rest of buffer length high */
64
65	st->data[2] = AF9005_REGISTER_RW;	/* register operation */
66	st->data[3] = 12;		/* rest of buffer length */
67
68	st->data[4] = seq = st->sequence++;	/* sequence number */
69
70	st->data[5] = (u8) (reg >> 8);	/* register address */
71	st->data[6] = (u8) (reg & 0xff);
72
73	if (type == AF9005_OFDM_REG) {
74		command = AF9005_CMD_OFDM_REG;
75	} else {
76		command = AF9005_CMD_TUNER;
77	}
78
79	if (len > 1)
80		command |=
81		    AF9005_CMD_BURST | AF9005_CMD_AUTOINC | (len - 1) << 3;
82	command |= readwrite;
83	if (readwrite == AF9005_CMD_WRITE)
84		for (i = 0; i < len; i++)
85			st->data[8 + i] = values[i];
86	else if (type == AF9005_TUNER_REG)
87		/* read command for tuner, the first byte contains the i2c address */
88		st->data[8] = values[0];
89	st->data[7] = command;
90
91	ret = dvb_usb_generic_rw(d, st->data, 16, st->data, 17, 0);
92	if (ret)
93		goto ret;
94
95	/* sanity check */
96	if (st->data[2] != AF9005_REGISTER_RW_ACK) {
97		err("generic read/write, wrong reply code.");
98		ret = -EIO;
99		goto ret;
100	}
101	if (st->data[3] != 0x0d) {
102		err("generic read/write, wrong length in reply.");
103		ret = -EIO;
104		goto ret;
105	}
106	if (st->data[4] != seq) {
107		err("generic read/write, wrong sequence in reply.");
108		ret = -EIO;
109		goto ret;
110	}
111	/*
112	 * In thesis, both input and output buffers should have
113	 * identical values for st->data[5] to st->data[8].
114	 * However, windows driver doesn't check these fields, in fact
115	 * sometimes the register in the reply is different that what
116	 * has been sent
117	 */
118	if (st->data[16] != 0x01) {
119		err("generic read/write wrong status code in reply.");
120		ret = -EIO;
121		goto ret;
122	}
123
124	if (readwrite == AF9005_CMD_READ)
125		for (i = 0; i < len; i++)
126			values[i] = st->data[8 + i];
127
128ret:
129	mutex_unlock(&d->data_mutex);
130	return ret;
131
132}
133
134int af9005_read_ofdm_register(struct dvb_usb_device *d, u16 reg, u8 * value)
135{
136	int ret;
137	deb_reg("read register %x ", reg);
138	ret = af9005_generic_read_write(d, reg,
139					AF9005_CMD_READ, AF9005_OFDM_REG,
140					value, 1);
141	if (ret)
142		deb_reg("failed\n");
143	else
144		deb_reg("value %x\n", *value);
145	return ret;
146}
147
148int af9005_read_ofdm_registers(struct dvb_usb_device *d, u16 reg,
149			       u8 * values, int len)
150{
151	int ret;
152	deb_reg("read %d registers %x ", len, reg);
153	ret = af9005_generic_read_write(d, reg,
154					AF9005_CMD_READ, AF9005_OFDM_REG,
155					values, len);
156	if (ret)
157		deb_reg("failed\n");
158	else
159		debug_dump(values, len, deb_reg);
160	return ret;
161}
162
163int af9005_write_ofdm_register(struct dvb_usb_device *d, u16 reg, u8 value)
164{
165	int ret;
166	u8 temp = value;
167	deb_reg("write register %x value %x ", reg, value);
168	ret = af9005_generic_read_write(d, reg,
169					AF9005_CMD_WRITE, AF9005_OFDM_REG,
170					&temp, 1);
171	if (ret)
172		deb_reg("failed\n");
173	else
174		deb_reg("ok\n");
175	return ret;
176}
177
178int af9005_write_ofdm_registers(struct dvb_usb_device *d, u16 reg,
179				u8 * values, int len)
180{
181	int ret;
182	deb_reg("write %d registers %x values ", len, reg);
183	debug_dump(values, len, deb_reg);
184
185	ret = af9005_generic_read_write(d, reg,
186					AF9005_CMD_WRITE, AF9005_OFDM_REG,
187					values, len);
188	if (ret)
189		deb_reg("failed\n");
190	else
191		deb_reg("ok\n");
192	return ret;
193}
194
195int af9005_read_register_bits(struct dvb_usb_device *d, u16 reg, u8 pos,
196			      u8 len, u8 * value)
197{
198	u8 temp;
199	int ret;
200	deb_reg("read bits %x %x %x", reg, pos, len);
201	ret = af9005_read_ofdm_register(d, reg, &temp);
202	if (ret) {
203		deb_reg(" failed\n");
204		return ret;
205	}
206	*value = (temp >> pos) & regmask[len - 1];
207	deb_reg(" value %x\n", *value);
208	return 0;
209
210}
211
212int af9005_write_register_bits(struct dvb_usb_device *d, u16 reg, u8 pos,
213			       u8 len, u8 value)
214{
215	u8 temp, mask;
216	int ret;
217	deb_reg("write bits %x %x %x value %x\n", reg, pos, len, value);
218	if (pos == 0 && len == 8)
219		return af9005_write_ofdm_register(d, reg, value);
220	ret = af9005_read_ofdm_register(d, reg, &temp);
221	if (ret)
222		return ret;
223	mask = regmask[len - 1] << pos;
224	temp = (temp & ~mask) | ((value << pos) & mask);
225	return af9005_write_ofdm_register(d, reg, temp);
226
227}
228
229static int af9005_usb_read_tuner_registers(struct dvb_usb_device *d,
230					   u16 reg, u8 * values, int len)
231{
232	return af9005_generic_read_write(d, reg,
233					 AF9005_CMD_READ, AF9005_TUNER_REG,
234					 values, len);
235}
236
237static int af9005_usb_write_tuner_registers(struct dvb_usb_device *d,
238					    u16 reg, u8 * values, int len)
239{
240	return af9005_generic_read_write(d, reg,
241					 AF9005_CMD_WRITE,
242					 AF9005_TUNER_REG, values, len);
243}
244
245int af9005_write_tuner_registers(struct dvb_usb_device *d, u16 reg,
246				 u8 * values, int len)
247{
248	/* don't let the name of this function mislead you: it's just used
249	   as an interface from the firmware to the i2c bus. The actual
250	   i2c addresses are contained in the data */
251	int ret, i, done = 0, fail = 0;
252	u8 temp;
253	ret = af9005_usb_write_tuner_registers(d, reg, values, len);
254	if (ret)
255		return ret;
256	if (reg != 0xffff) {
257		/* check if write done (0xa40d bit 1) or fail (0xa40d bit 2) */
258		for (i = 0; i < 200; i++) {
259			ret =
260			    af9005_read_ofdm_register(d,
261						      xd_I2C_i2c_m_status_wdat_done,
262						      &temp);
263			if (ret)
264				return ret;
265			done = temp & (regmask[i2c_m_status_wdat_done_len - 1]
266				       << i2c_m_status_wdat_done_pos);
267			if (done)
268				break;
269			fail = temp & (regmask[i2c_m_status_wdat_fail_len - 1]
270				       << i2c_m_status_wdat_fail_pos);
271			if (fail)
272				break;
273			msleep(50);
274		}
275		if (i == 200)
276			return -ETIMEDOUT;
277		if (fail) {
278			/* clear write fail bit */
279			af9005_write_register_bits(d,
280						   xd_I2C_i2c_m_status_wdat_fail,
281						   i2c_m_status_wdat_fail_pos,
282						   i2c_m_status_wdat_fail_len,
283						   1);
284			return -EIO;
285		}
286		/* clear write done bit */
287		ret =
288		    af9005_write_register_bits(d,
289					       xd_I2C_i2c_m_status_wdat_fail,
290					       i2c_m_status_wdat_done_pos,
291					       i2c_m_status_wdat_done_len, 1);
292		if (ret)
293			return ret;
294	}
295	return 0;
296}
297
298int af9005_read_tuner_registers(struct dvb_usb_device *d, u16 reg, u8 addr,
299				u8 * values, int len)
300{
301	/* don't let the name of this function mislead you: it's just used
302	   as an interface from the firmware to the i2c bus. The actual
303	   i2c addresses are contained in the data */
304	int ret, i;
305	u8 temp, buf[2];
306
307	buf[0] = addr;		/* tuner i2c address */
308	buf[1] = values[0];	/* tuner register */
309
310	values[0] = addr + 0x01;	/* i2c read address */
311
312	if (reg == APO_REG_I2C_RW_SILICON_TUNER) {
313		/* write tuner i2c address to tuner, 0c00c0 undocumented, found by sniffing */
314		ret = af9005_write_tuner_registers(d, 0x00c0, buf, 2);
315		if (ret)
316			return ret;
317	}
318
319	/* send read command to ofsm */
320	ret = af9005_usb_read_tuner_registers(d, reg, values, 1);
321	if (ret)
322		return ret;
323
324	/* check if read done */
325	for (i = 0; i < 200; i++) {
326		ret = af9005_read_ofdm_register(d, 0xa408, &temp);
327		if (ret)
328			return ret;
329		if (temp & 0x01)
330			break;
331		msleep(50);
332	}
333	if (i == 200)
334		return -ETIMEDOUT;
335
336	/* clear read done bit (by writing 1) */
337	ret = af9005_write_ofdm_register(d, xd_I2C_i2c_m_data8, 1);
338	if (ret)
339		return ret;
340
341	/* get read data (available from 0xa400) */
342	for (i = 0; i < len; i++) {
343		ret = af9005_read_ofdm_register(d, 0xa400 + i, &temp);
344		if (ret)
345			return ret;
346		values[i] = temp;
347	}
348	return 0;
349}
350
351static int af9005_i2c_write(struct dvb_usb_device *d, u8 i2caddr, u8 reg,
352			    u8 * data, int len)
353{
354	int ret, i;
355	u8 buf[3];
356	deb_i2c("i2c_write i2caddr %x, reg %x, len %d data ", i2caddr,
357		reg, len);
358	debug_dump(data, len, deb_i2c);
359
360	for (i = 0; i < len; i++) {
361		buf[0] = i2caddr;
362		buf[1] = reg + (u8) i;
363		buf[2] = data[i];
364		ret =
365		    af9005_write_tuner_registers(d,
366						 APO_REG_I2C_RW_SILICON_TUNER,
367						 buf, 3);
368		if (ret) {
369			deb_i2c("i2c_write failed\n");
370			return ret;
371		}
372	}
373	deb_i2c("i2c_write ok\n");
374	return 0;
375}
376
377static int af9005_i2c_read(struct dvb_usb_device *d, u8 i2caddr, u8 reg,
378			   u8 * data, int len)
379{
380	int ret, i;
381	u8 temp;
382	deb_i2c("i2c_read i2caddr %x, reg %x, len %d\n ", i2caddr, reg, len);
383	for (i = 0; i < len; i++) {
384		temp = reg + i;
385		ret =
386		    af9005_read_tuner_registers(d,
387						APO_REG_I2C_RW_SILICON_TUNER,
388						i2caddr, &temp, 1);
389		if (ret) {
390			deb_i2c("i2c_read failed\n");
391			return ret;
392		}
393		data[i] = temp;
394	}
395	deb_i2c("i2c data read: ");
396	debug_dump(data, len, deb_i2c);
397	return 0;
398}
399
400static int af9005_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
401			   int num)
402{
403	/* only implements what the mt2060 module does, don't know how
404	   to make it really generic */
405	struct dvb_usb_device *d = i2c_get_adapdata(adap);
406	int ret;
407	u8 reg, addr;
408	u8 *value;
409
410	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
411		return -EAGAIN;
412
413	if (num > 2)
414		warn("more than 2 i2c messages at a time is not handled yet. TODO.");
415
416	if (num == 2) {
417		/* reads a single register */
418		reg = *msg[0].buf;
419		addr = msg[0].addr;
420		value = msg[1].buf;
421		ret = af9005_i2c_read(d, addr, reg, value, 1);
422		if (ret == 0)
423			ret = 2;
424	} else {
425		if (msg[0].len < 2) {
426			ret = -EOPNOTSUPP;
427			goto unlock;
428		}
429		/* write one or more registers */
430		reg = msg[0].buf[0];
431		addr = msg[0].addr;
432		value = &msg[0].buf[1];
433		ret = af9005_i2c_write(d, addr, reg, value, msg[0].len - 1);
434		if (ret == 0)
435			ret = 1;
436	}
437
438unlock:
439	mutex_unlock(&d->i2c_mutex);
440	return ret;
441}
442
443static u32 af9005_i2c_func(struct i2c_adapter *adapter)
444{
445	return I2C_FUNC_I2C;
446}
447
448static struct i2c_algorithm af9005_i2c_algo = {
449	.master_xfer = af9005_i2c_xfer,
450	.functionality = af9005_i2c_func,
451};
452
453int af9005_send_command(struct dvb_usb_device *d, u8 command, u8 * wbuf,
454			int wlen, u8 * rbuf, int rlen)
455{
456	struct af9005_device_state *st = d->priv;
457
458	int ret, i, packet_len;
459	u8 seq;
460
461	if (wlen < 0) {
462		err("send command, wlen less than 0 bytes. Makes no sense.");
463		return -EINVAL;
464	}
465	if (wlen > 54) {
466		err("send command, wlen more than 54 bytes. Not supported.");
467		return -EINVAL;
468	}
469	if (rlen > 54) {
470		err("send command, rlen more than 54 bytes. Not supported.");
471		return -EINVAL;
472	}
473	packet_len = wlen + 5;
474
475	mutex_lock(&d->data_mutex);
476
477	st->data[0] = (u8) (packet_len & 0xff);
478	st->data[1] = (u8) ((packet_len & 0xff00) >> 8);
479
480	st->data[2] = 0x26;		/* packet type */
481	st->data[3] = wlen + 3;
482	st->data[4] = seq = st->sequence++;
483	st->data[5] = command;
484	st->data[6] = wlen;
485	for (i = 0; i < wlen; i++)
486		st->data[7 + i] = wbuf[i];
487	ret = dvb_usb_generic_rw(d, st->data, wlen + 7, st->data, rlen + 7, 0);
488	if (st->data[2] != 0x27) {
489		err("send command, wrong reply code.");
490		ret = -EIO;
491	} else if (st->data[4] != seq) {
492		err("send command, wrong sequence in reply.");
493		ret = -EIO;
494	} else if (st->data[5] != 0x01) {
495		err("send command, wrong status code in reply.");
496		ret = -EIO;
497	} else if (st->data[6] != rlen) {
498		err("send command, invalid data length in reply.");
499		ret = -EIO;
500	}
501	if (!ret) {
502		for (i = 0; i < rlen; i++)
503			rbuf[i] = st->data[i + 7];
504	}
505
506	mutex_unlock(&d->data_mutex);
507	return ret;
508}
509
510int af9005_read_eeprom(struct dvb_usb_device *d, u8 address, u8 * values,
511		       int len)
512{
513	struct af9005_device_state *st = d->priv;
514	u8 seq;
515	int ret, i;
516
517	mutex_lock(&d->data_mutex);
518
519	memset(st->data, 0, sizeof(st->data));
520
521	st->data[0] = 14;		/* length of rest of packet low */
522	st->data[1] = 0;		/* length of rest of packer high */
523
524	st->data[2] = 0x2a;		/* read/write eeprom */
525
526	st->data[3] = 12;		/* size */
527
528	st->data[4] = seq = st->sequence++;
529
530	st->data[5] = 0;		/* read */
531
532	st->data[6] = len;
533	st->data[7] = address;
534	ret = dvb_usb_generic_rw(d, st->data, 16, st->data, 14, 0);
535	if (st->data[2] != 0x2b) {
536		err("Read eeprom, invalid reply code");
537		ret = -EIO;
538	} else if (st->data[3] != 10) {
539		err("Read eeprom, invalid reply length");
540		ret = -EIO;
541	} else if (st->data[4] != seq) {
542		err("Read eeprom, wrong sequence in reply ");
543		ret = -EIO;
544	} else if (st->data[5] != 1) {
545		err("Read eeprom, wrong status in reply ");
546		ret = -EIO;
547	}
548
549	if (!ret) {
550		for (i = 0; i < len; i++)
551			values[i] = st->data[6 + i];
552	}
553	mutex_unlock(&d->data_mutex);
554
555	return ret;
556}
557
558static int af9005_boot_packet(struct usb_device *udev, int type, u8 *reply,
559			      u8 *buf, int size)
560{
561	u16 checksum;
562	int act_len = 0, i, ret;
563
564	memset(buf, 0, size);
565	buf[0] = (u8) (FW_BULKOUT_SIZE & 0xff);
566	buf[1] = (u8) ((FW_BULKOUT_SIZE >> 8) & 0xff);
567	switch (type) {
568	case FW_CONFIG:
569		buf[2] = 0x11;
570		buf[3] = 0x04;
571		buf[4] = 0x00;	/* sequence number, original driver doesn't increment it here */
572		buf[5] = 0x03;
573		checksum = buf[4] + buf[5];
574		buf[6] = (u8) ((checksum >> 8) & 0xff);
575		buf[7] = (u8) (checksum & 0xff);
576		break;
577	case FW_CONFIRM:
578		buf[2] = 0x11;
579		buf[3] = 0x04;
580		buf[4] = 0x00;	/* sequence number, original driver doesn't increment it here */
581		buf[5] = 0x01;
582		checksum = buf[4] + buf[5];
583		buf[6] = (u8) ((checksum >> 8) & 0xff);
584		buf[7] = (u8) (checksum & 0xff);
585		break;
586	case FW_BOOT:
587		buf[2] = 0x10;
588		buf[3] = 0x08;
589		buf[4] = 0x00;	/* sequence number, original driver doesn't increment it here */
590		buf[5] = 0x97;
591		buf[6] = 0xaa;
592		buf[7] = 0x55;
593		buf[8] = 0xa5;
594		buf[9] = 0x5a;
595		checksum = 0;
596		for (i = 4; i <= 9; i++)
597			checksum += buf[i];
598		buf[10] = (u8) ((checksum >> 8) & 0xff);
599		buf[11] = (u8) (checksum & 0xff);
600		break;
601	default:
602		err("boot packet invalid boot packet type");
603		return -EINVAL;
604	}
605	deb_fw(">>> ");
606	debug_dump(buf, FW_BULKOUT_SIZE + 2, deb_fw);
607
608	ret = usb_bulk_msg(udev,
609			   usb_sndbulkpipe(udev, 0x02),
610			   buf, FW_BULKOUT_SIZE + 2, &act_len, 2000);
611	if (ret)
612		err("boot packet bulk message failed: %d (%d/%d)", ret,
613		    FW_BULKOUT_SIZE + 2, act_len);
614	else
615		ret = act_len != FW_BULKOUT_SIZE + 2 ? -1 : 0;
616	if (ret)
617		return ret;
618	memset(buf, 0, 9);
619	ret = usb_bulk_msg(udev,
620			   usb_rcvbulkpipe(udev, 0x01), buf, 9, &act_len, 2000);
621	if (ret) {
622		err("boot packet recv bulk message failed: %d", ret);
623		return ret;
624	}
625	deb_fw("<<< ");
626	debug_dump(buf, act_len, deb_fw);
627	checksum = 0;
628	switch (type) {
629	case FW_CONFIG:
630		if (buf[2] != 0x11) {
631			err("boot bad config header.");
632			return -EIO;
633		}
634		if (buf[3] != 0x05) {
635			err("boot bad config size.");
636			return -EIO;
637		}
638		if (buf[4] != 0x00) {
639			err("boot bad config sequence.");
640			return -EIO;
641		}
642		if (buf[5] != 0x04) {
643			err("boot bad config subtype.");
644			return -EIO;
645		}
646		for (i = 4; i <= 6; i++)
647			checksum += buf[i];
648		if (buf[7] * 256 + buf[8] != checksum) {
649			err("boot bad config checksum.");
650			return -EIO;
651		}
652		*reply = buf[6];
653		break;
654	case FW_CONFIRM:
655		if (buf[2] != 0x11) {
656			err("boot bad confirm header.");
657			return -EIO;
658		}
659		if (buf[3] != 0x05) {
660			err("boot bad confirm size.");
661			return -EIO;
662		}
663		if (buf[4] != 0x00) {
664			err("boot bad confirm sequence.");
665			return -EIO;
666		}
667		if (buf[5] != 0x02) {
668			err("boot bad confirm subtype.");
669			return -EIO;
670		}
671		for (i = 4; i <= 6; i++)
672			checksum += buf[i];
673		if (buf[7] * 256 + buf[8] != checksum) {
674			err("boot bad confirm checksum.");
675			return -EIO;
676		}
677		*reply = buf[6];
678		break;
679	case FW_BOOT:
680		if (buf[2] != 0x10) {
681			err("boot bad boot header.");
682			return -EIO;
683		}
684		if (buf[3] != 0x05) {
685			err("boot bad boot size.");
686			return -EIO;
687		}
688		if (buf[4] != 0x00) {
689			err("boot bad boot sequence.");
690			return -EIO;
691		}
692		if (buf[5] != 0x01) {
693			err("boot bad boot pattern 01.");
694			return -EIO;
695		}
696		if (buf[6] != 0x10) {
697			err("boot bad boot pattern 10.");
698			return -EIO;
699		}
700		for (i = 4; i <= 6; i++)
701			checksum += buf[i];
702		if (buf[7] * 256 + buf[8] != checksum) {
703			err("boot bad boot checksum.");
704			return -EIO;
705		}
706		break;
707
708	}
709
710	return 0;
711}
712
713static int af9005_download_firmware(struct usb_device *udev, const struct firmware *fw)
714{
715	int i, packets, ret, act_len;
716
717	u8 *buf;
718	u8 reply;
719
720	buf = kmalloc(FW_BULKOUT_SIZE + 2, GFP_KERNEL);
721	if (!buf)
722		return -ENOMEM;
723
724	ret = af9005_boot_packet(udev, FW_CONFIG, &reply, buf,
725				 FW_BULKOUT_SIZE + 2);
726	if (ret)
727		goto err;
728	if (reply != 0x01) {
729		err("before downloading firmware, FW_CONFIG expected 0x01, received 0x%x", reply);
730		ret = -EIO;
731		goto err;
732	}
733	packets = fw->size / FW_BULKOUT_SIZE;
734	buf[0] = (u8) (FW_BULKOUT_SIZE & 0xff);
735	buf[1] = (u8) ((FW_BULKOUT_SIZE >> 8) & 0xff);
736	for (i = 0; i < packets; i++) {
737		memcpy(&buf[2], fw->data + i * FW_BULKOUT_SIZE,
738		       FW_BULKOUT_SIZE);
739		deb_fw(">>> ");
740		debug_dump(buf, FW_BULKOUT_SIZE + 2, deb_fw);
741		ret = usb_bulk_msg(udev,
742				   usb_sndbulkpipe(udev, 0x02),
743				   buf, FW_BULKOUT_SIZE + 2, &act_len, 1000);
744		if (ret) {
745			err("firmware download failed at packet %d with code %d", i, ret);
746			goto err;
747		}
748	}
749	ret = af9005_boot_packet(udev, FW_CONFIRM, &reply,
750				 buf, FW_BULKOUT_SIZE + 2);
751	if (ret)
752		goto err;
753	if (reply != (u8) (packets & 0xff)) {
754		err("after downloading firmware, FW_CONFIRM expected 0x%x, received 0x%x", packets & 0xff, reply);
755		ret = -EIO;
756		goto err;
757	}
758	ret = af9005_boot_packet(udev, FW_BOOT, &reply, buf,
759				 FW_BULKOUT_SIZE + 2);
760	if (ret)
761		goto err;
762	ret = af9005_boot_packet(udev, FW_CONFIG, &reply, buf,
763				 FW_BULKOUT_SIZE + 2);
764	if (ret)
765		goto err;
766	if (reply != 0x02) {
767		err("after downloading firmware, FW_CONFIG expected 0x02, received 0x%x", reply);
768		ret = -EIO;
769		goto err;
770	}
771
772err:
773	kfree(buf);
774	return ret;
775
776}
777
778int af9005_led_control(struct dvb_usb_device *d, int onoff)
779{
780	struct af9005_device_state *st = d->priv;
781	int temp, ret;
782
783	if (onoff && dvb_usb_af9005_led)
784		temp = 1;
785	else
786		temp = 0;
787	if (st->led_state != temp) {
788		ret =
789		    af9005_write_register_bits(d, xd_p_reg_top_locken1,
790					       reg_top_locken1_pos,
791					       reg_top_locken1_len, temp);
792		if (ret)
793			return ret;
794		ret =
795		    af9005_write_register_bits(d, xd_p_reg_top_lock1,
796					       reg_top_lock1_pos,
797					       reg_top_lock1_len, temp);
798		if (ret)
799			return ret;
800		st->led_state = temp;
801	}
802	return 0;
803}
804
805static int af9005_frontend_attach(struct dvb_usb_adapter *adap)
806{
807	u8 buf[8];
808	int i;
809
810	/* without these calls the first commands after downloading
811	   the firmware fail. I put these calls here to simulate
812	   what it is done in dvb-usb-init.c.
813	 */
814	struct usb_device *udev = adap->dev->udev;
815	usb_clear_halt(udev, usb_sndbulkpipe(udev, 2));
816	usb_clear_halt(udev, usb_rcvbulkpipe(udev, 1));
817	if (dvb_usb_af9005_dump_eeprom) {
818		printk("EEPROM DUMP\n");
819		for (i = 0; i < 255; i += 8) {
820			af9005_read_eeprom(adap->dev, i, buf, 8);
821			debug_dump(buf, 8, printk);
822		}
823	}
824	adap->fe_adap[0].fe = af9005_fe_attach(adap->dev);
825	return 0;
826}
827
828static int af9005_rc_query(struct dvb_usb_device *d, u32 * event, int *state)
829{
830	struct af9005_device_state *st = d->priv;
831	int ret, len;
832	u8 seq;
833
834	*state = REMOTE_NO_KEY_PRESSED;
835	if (rc_decode == NULL) {
836		/* it shouldn't never come here */
837		return 0;
838	}
839
840	mutex_lock(&d->data_mutex);
841
842	/* deb_info("rc_query\n"); */
843	st->data[0] = 3;		/* rest of packet length low */
844	st->data[1] = 0;		/* rest of packet length high */
845	st->data[2] = 0x40;		/* read remote */
846	st->data[3] = 1;		/* rest of packet length */
847	st->data[4] = seq = st->sequence++;	/* sequence number */
848	ret = dvb_usb_generic_rw(d, st->data, 5, st->data, 256, 0);
849	if (ret) {
850		err("rc query failed");
851		goto ret;
852	}
853	if (st->data[2] != 0x41) {
854		err("rc query bad header.");
855		ret = -EIO;
856		goto ret;
857	} else if (st->data[4] != seq) {
858		err("rc query bad sequence.");
859		ret = -EIO;
860		goto ret;
861	}
862	len = st->data[5];
863	if (len > 246) {
864		err("rc query invalid length");
865		ret = -EIO;
866		goto ret;
867	}
868	if (len > 0) {
869		deb_rc("rc data (%d) ", len);
870		debug_dump((st->data + 6), len, deb_rc);
871		ret = rc_decode(d, &st->data[6], len, event, state);
872		if (ret) {
873			err("rc_decode failed");
874			goto ret;
875		} else {
876			deb_rc("rc_decode state %x event %x\n", *state, *event);
877			if (*state == REMOTE_KEY_REPEAT)
878				*event = d->last_event;
879		}
880	}
881
882ret:
883	mutex_unlock(&d->data_mutex);
884	return ret;
885}
886
887static int af9005_power_ctrl(struct dvb_usb_device *d, int onoff)
888{
889
890	return 0;
891}
892
893static int af9005_pid_filter_control(struct dvb_usb_adapter *adap, int onoff)
894{
895	int ret;
896	deb_info("pid filter control  onoff %d\n", onoff);
897	if (onoff) {
898		ret =
899		    af9005_write_ofdm_register(adap->dev, XD_MP2IF_DMX_CTRL, 1);
900		if (ret)
901			return ret;
902		ret =
903		    af9005_write_register_bits(adap->dev,
904					       XD_MP2IF_DMX_CTRL, 1, 1, 1);
905		if (ret)
906			return ret;
907		ret =
908		    af9005_write_ofdm_register(adap->dev, XD_MP2IF_DMX_CTRL, 1);
909	} else
910		ret =
911		    af9005_write_ofdm_register(adap->dev, XD_MP2IF_DMX_CTRL, 0);
912	if (ret)
913		return ret;
914	deb_info("pid filter control ok\n");
915	return 0;
916}
917
918static int af9005_pid_filter(struct dvb_usb_adapter *adap, int index,
919			     u16 pid, int onoff)
920{
921	u8 cmd = index & 0x1f;
922	int ret;
923	deb_info("set pid filter, index %d, pid %x, onoff %d\n", index,
924		 pid, onoff);
925	if (onoff) {
926		/* cannot use it as pid_filter_ctrl since it has to be done
927		   before setting the first pid */
928		if (adap->feedcount == 1) {
929			deb_info("first pid set, enable pid table\n");
930			ret = af9005_pid_filter_control(adap, onoff);
931			if (ret)
932				return ret;
933		}
934		ret =
935		    af9005_write_ofdm_register(adap->dev,
936					       XD_MP2IF_PID_DATA_L,
937					       (u8) (pid & 0xff));
938		if (ret)
939			return ret;
940		ret =
941		    af9005_write_ofdm_register(adap->dev,
942					       XD_MP2IF_PID_DATA_H,
943					       (u8) (pid >> 8));
944		if (ret)
945			return ret;
946		cmd |= 0x20 | 0x40;
947	} else {
948		if (adap->feedcount == 0) {
949			deb_info("last pid unset, disable pid table\n");
950			ret = af9005_pid_filter_control(adap, onoff);
951			if (ret)
952				return ret;
953		}
954	}
955	ret = af9005_write_ofdm_register(adap->dev, XD_MP2IF_PID_IDX, cmd);
956	if (ret)
957		return ret;
958	deb_info("set pid ok\n");
959	return 0;
960}
961
962static int af9005_identify_state(struct usb_device *udev,
963				 const struct dvb_usb_device_properties *props,
964				 const struct dvb_usb_device_description **desc,
965				 int *cold)
966{
967	int ret;
968	u8 reply, *buf;
969
970	buf = kmalloc(FW_BULKOUT_SIZE + 2, GFP_KERNEL);
971	if (!buf)
972		return -ENOMEM;
973
974	ret = af9005_boot_packet(udev, FW_CONFIG, &reply,
975				 buf, FW_BULKOUT_SIZE + 2);
976	if (ret)
977		goto err;
978	deb_info("result of FW_CONFIG in identify state %d\n", reply);
979	if (reply == 0x01)
980		*cold = 1;
981	else if (reply == 0x02)
982		*cold = 0;
983	else
984		ret = -EIO;
985	if (!ret)
986		deb_info("Identify state cold = %d\n", *cold);
987
988err:
989	kfree(buf);
990	return ret;
991}
992
993static struct dvb_usb_device_properties af9005_properties;
994
995static int af9005_usb_probe(struct usb_interface *intf,
996			    const struct usb_device_id *id)
997{
998	return dvb_usb_device_init(intf, &af9005_properties,
999				  THIS_MODULE, NULL, adapter_nr);
1000}
1001
1002enum af9005_usb_table_entry {
1003	AFATECH_AF9005,
1004	TERRATEC_AF9005,
1005	ANSONIC_AF9005,
1006};
1007
1008static struct usb_device_id af9005_usb_table[] = {
1009	[AFATECH_AF9005] = {USB_DEVICE(USB_VID_AFATECH,
1010				USB_PID_AFATECH_AF9005)},
1011	[TERRATEC_AF9005] = {USB_DEVICE(USB_VID_TERRATEC,
1012				USB_PID_TERRATEC_CINERGY_T_USB_XE)},
1013	[ANSONIC_AF9005] = {USB_DEVICE(USB_VID_ANSONIC,
1014				USB_PID_ANSONIC_DVBT_USB)},
1015	{ }
1016};
1017
1018MODULE_DEVICE_TABLE(usb, af9005_usb_table);
1019
1020static struct dvb_usb_device_properties af9005_properties = {
1021	.caps = DVB_USB_IS_AN_I2C_ADAPTER,
1022
1023	.usb_ctrl = DEVICE_SPECIFIC,
1024	.firmware = "af9005.fw",
1025	.download_firmware = af9005_download_firmware,
1026	.no_reconnect = 1,
1027
1028	.size_of_priv = sizeof(struct af9005_device_state),
1029
1030	.num_adapters = 1,
1031	.adapter = {
1032		    {
1033		    .num_frontends = 1,
1034		    .fe = {{
1035		     .caps =
1036		     DVB_USB_ADAP_HAS_PID_FILTER |
1037		     DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1038		     .pid_filter_count = 32,
1039		     .pid_filter = af9005_pid_filter,
1040		     /* .pid_filter_ctrl = af9005_pid_filter_control, */
1041		     .frontend_attach = af9005_frontend_attach,
1042		     /* .tuner_attach     = af9005_tuner_attach, */
1043		     /* parameter for the MPEG2-data transfer */
1044		     .stream = {
1045				.type = USB_BULK,
1046				.count = 10,
1047				.endpoint = 0x04,
1048				.u = {
1049				      .bulk = {
1050					       .buffersize = 4096,	/* actual size seen is 3948 */
1051					       }
1052				      }
1053				},
1054		     }},
1055		     }
1056		    },
1057	.power_ctrl = af9005_power_ctrl,
1058	.identify_state = af9005_identify_state,
1059
1060	.i2c_algo = &af9005_i2c_algo,
1061
1062	.rc.legacy = {
1063		.rc_interval = 200,
1064		.rc_map_table = NULL,
1065		.rc_map_size = 0,
1066		.rc_query = af9005_rc_query,
1067	},
1068
1069	.generic_bulk_ctrl_endpoint          = 2,
1070	.generic_bulk_ctrl_endpoint_response = 1,
1071
1072	.num_device_descs = 3,
1073	.devices = {
1074		    {.name = "Afatech DVB-T USB1.1 stick",
1075		     .cold_ids = {&af9005_usb_table[AFATECH_AF9005], NULL},
1076		     .warm_ids = {NULL},
1077		     },
1078		    {.name = "TerraTec Cinergy T USB XE",
1079		     .cold_ids = {&af9005_usb_table[TERRATEC_AF9005], NULL},
1080		     .warm_ids = {NULL},
1081		     },
1082		    {.name = "Ansonic DVB-T USB1.1 stick",
1083		     .cold_ids = {&af9005_usb_table[ANSONIC_AF9005], NULL},
1084		     .warm_ids = {NULL},
1085		     },
1086		    {NULL},
1087		    }
1088};
1089
1090/* usb specific object needed to register this driver with the usb subsystem */
1091static struct usb_driver af9005_usb_driver = {
1092	.name = "dvb_usb_af9005",
1093	.probe = af9005_usb_probe,
1094	.disconnect = dvb_usb_device_exit,
1095	.id_table = af9005_usb_table,
1096};
1097
1098/* module stuff */
1099static int __init af9005_usb_module_init(void)
1100{
1101	int result;
1102	if ((result = usb_register(&af9005_usb_driver))) {
1103		err("usb_register failed. (%d)", result);
1104		return result;
1105	}
1106#if IS_MODULE(CONFIG_DVB_USB_AF9005) || defined(CONFIG_DVB_USB_AF9005_REMOTE)
1107	/* FIXME: convert to todays kernel IR infrastructure */
1108	rc_decode = symbol_request(af9005_rc_decode);
1109	rc_keys = symbol_request(rc_map_af9005_table);
1110	rc_keys_size = symbol_request(rc_map_af9005_table_size);
1111#endif
1112	if (rc_decode == NULL || rc_keys == NULL || rc_keys_size == NULL) {
1113		err("af9005_rc_decode function not found, disabling remote");
1114		af9005_properties.rc.legacy.rc_query = NULL;
1115	} else {
1116		af9005_properties.rc.legacy.rc_map_table = rc_keys;
1117		af9005_properties.rc.legacy.rc_map_size = *rc_keys_size;
1118	}
1119
1120	return 0;
1121}
1122
1123static void __exit af9005_usb_module_exit(void)
1124{
1125	/* release rc decode symbols */
1126	if (rc_decode != NULL)
1127		symbol_put(af9005_rc_decode);
1128	if (rc_keys != NULL)
1129		symbol_put(rc_map_af9005_table);
1130	if (rc_keys_size != NULL)
1131		symbol_put(rc_map_af9005_table_size);
1132	/* deregister this driver from the USB subsystem */
1133	usb_deregister(&af9005_usb_driver);
1134}
1135
1136module_init(af9005_usb_module_init);
1137module_exit(af9005_usb_module_exit);
1138
1139MODULE_AUTHOR("Luca Olivetti <luca@ventoso.org>");
1140MODULE_DESCRIPTION("Driver for Afatech 9005 DVB-T USB1.1 stick");
1141MODULE_VERSION("1.0");
1142MODULE_LICENSE("GPL");
1143