?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
perf tools: Don't clone maps from parent when synthesizing forks
[linux/fpc-iii.git] / drivers / media / usb / dvb-usb / af9005.c
blob16e946e01d2caab9eaf68546067b3fb92f18731d
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 lentgh 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");
Linux with added FPC-III support