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