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