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