1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#include "af9005.h"
25
26
27int dvb_usb_af9005_debug;
28module_param_named(debug, dvb_usb_af9005_debug, int, 0644);
29MODULE_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
33bool dvb_usb_af9005_led = true;
34module_param_named(led, dvb_usb_af9005_led, bool, 0644);
35MODULE_PARM_DESC(led, "enable led (default: 1).");
36
37
38static int dvb_usb_af9005_dump_eeprom;
39module_param_named(dump_eeprom, dvb_usb_af9005_dump_eeprom, int, 0);
40MODULE_PARM_DESC(dump_eeprom, "dump contents of the eeprom.");
41
42DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
43
44
45static int (*rc_decode) (struct dvb_usb_device *d, u8 *data, int len,
46 u32 *event, int *state);
47static void *rc_keys;
48static int *rc_keys_size;
49
50u8 regmask[8] = { 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff };
51
52struct af9005_device_state {
53 u8 sequence;
54 int led_state;
55 unsigned char data[256];
56};
57
58static int af9005_generic_read_write(struct dvb_usb_device *d, u16 reg,
59 int readwrite, int type, u8 * values, int len)
60{
61 struct af9005_device_state *st = d->priv;
62 u8 command, seq;
63 int i, ret;
64
65 if (len < 1) {
66 err("generic read/write, less than 1 byte. Makes no sense.");
67 return -EINVAL;
68 }
69 if (len > 8) {
70 err("generic read/write, more than 8 bytes. Not supported.");
71 return -EINVAL;
72 }
73
74 mutex_lock(&d->data_mutex);
75 st->data[0] = 14;
76 st->data[1] = 0;
77
78 st->data[2] = AF9005_REGISTER_RW;
79 st->data[3] = 12;
80
81 st->data[4] = seq = st->sequence++;
82
83 st->data[5] = (u8) (reg >> 8);
84 st->data[6] = (u8) (reg & 0xff);
85
86 if (type == AF9005_OFDM_REG) {
87 command = AF9005_CMD_OFDM_REG;
88 } else {
89 command = AF9005_CMD_TUNER;
90 }
91
92 if (len > 1)
93 command |=
94 AF9005_CMD_BURST | AF9005_CMD_AUTOINC | (len - 1) << 3;
95 command |= readwrite;
96 if (readwrite == AF9005_CMD_WRITE)
97 for (i = 0; i < len; i++)
98 st->data[8 + i] = values[i];
99 else if (type == AF9005_TUNER_REG)
100
101 st->data[8] = values[0];
102 st->data[7] = command;
103
104 ret = dvb_usb_generic_rw(d, st->data, 16, st->data, 17, 0);
105 if (ret)
106 goto ret;
107
108
109 if (st->data[2] != AF9005_REGISTER_RW_ACK) {
110 err("generic read/write, wrong reply code.");
111 ret = -EIO;
112 goto ret;
113 }
114 if (st->data[3] != 0x0d) {
115 err("generic read/write, wrong length in reply.");
116 ret = -EIO;
117 goto ret;
118 }
119 if (st->data[4] != seq) {
120 err("generic read/write, wrong sequence in reply.");
121 ret = -EIO;
122 goto ret;
123 }
124
125
126
127
128
129
130
131 if (st->data[16] != 0x01) {
132 err("generic read/write wrong status code in reply.");
133 ret = -EIO;
134 goto ret;
135 }
136
137 if (readwrite == AF9005_CMD_READ)
138 for (i = 0; i < len; i++)
139 values[i] = st->data[8 + i];
140
141ret:
142 mutex_unlock(&d->data_mutex);
143 return ret;
144
145}
146
147int 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
161int 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
176int 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
191int 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
208int 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
225int 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
242static 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
250static 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
258int af9005_write_tuner_registers(struct dvb_usb_device *d, u16 reg,
259 u8 * values, int len)
260{
261
262
263
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
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
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
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
311int af9005_read_tuner_registers(struct dvb_usb_device *d, u16 reg, u8 addr,
312 u8 * values, int len)
313{
314
315
316
317 int ret, i;
318 u8 temp, buf[2];
319
320 buf[0] = addr;
321 buf[1] = values[0];
322
323 values[0] = addr + 0x01;
324
325 if (reg == APO_REG_I2C_RW_SILICON_TUNER) {
326
327 ret = af9005_write_tuner_registers(d, 0x00c0, buf, 2);
328 if (ret)
329 return ret;
330 }
331
332
333 ret = af9005_usb_read_tuner_registers(d, reg, values, 1);
334 if (ret)
335 return ret;
336
337
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
350 ret = af9005_write_ofdm_register(d, xd_I2C_i2c_m_data8, 1);
351 if (ret)
352 return ret;
353
354
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
364static 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
390static 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
413static int af9005_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
414 int num)
415{
416
417
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
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
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
451static u32 af9005_i2c_func(struct i2c_adapter *adapter)
452{
453 return I2C_FUNC_I2C;
454}
455
456static struct i2c_algorithm af9005_i2c_algo = {
457 .master_xfer = af9005_i2c_xfer,
458 .functionality = af9005_i2c_func,
459};
460
461int 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 seq;
468
469 if (wlen < 0) {
470 err("send command, wlen less than 0 bytes. Makes no sense.");
471 return -EINVAL;
472 }
473 if (wlen > 54) {
474 err("send command, wlen more than 54 bytes. Not supported.");
475 return -EINVAL;
476 }
477 if (rlen > 54) {
478 err("send command, rlen more than 54 bytes. Not supported.");
479 return -EINVAL;
480 }
481 packet_len = wlen + 5;
482
483 mutex_lock(&d->data_mutex);
484
485 st->data[0] = (u8) (packet_len & 0xff);
486 st->data[1] = (u8) ((packet_len & 0xff00) >> 8);
487
488 st->data[2] = 0x26;
489 st->data[3] = wlen + 3;
490 st->data[4] = seq = st->sequence++;
491 st->data[5] = command;
492 st->data[6] = wlen;
493 for (i = 0; i < wlen; i++)
494 st->data[7 + i] = wbuf[i];
495 ret = dvb_usb_generic_rw(d, st->data, wlen + 7, st->data, rlen + 7, 0);
496 if (st->data[2] != 0x27) {
497 err("send command, wrong reply code.");
498 ret = -EIO;
499 } else if (st->data[4] != seq) {
500 err("send command, wrong sequence in reply.");
501 ret = -EIO;
502 } else if (st->data[5] != 0x01) {
503 err("send command, wrong status code in reply.");
504 ret = -EIO;
505 } else if (st->data[6] != rlen) {
506 err("send command, invalid data length in reply.");
507 ret = -EIO;
508 }
509 if (!ret) {
510 for (i = 0; i < rlen; i++)
511 rbuf[i] = st->data[i + 7];
512 }
513
514 mutex_unlock(&d->data_mutex);
515 return ret;
516}
517
518int af9005_read_eeprom(struct dvb_usb_device *d, u8 address, u8 * values,
519 int len)
520{
521 struct af9005_device_state *st = d->priv;
522 u8 seq;
523 int ret, i;
524
525 mutex_lock(&d->data_mutex);
526
527 memset(st->data, 0, sizeof(st->data));
528
529 st->data[0] = 14;
530 st->data[1] = 0;
531
532 st->data[2] = 0x2a;
533
534 st->data[3] = 12;
535
536 st->data[4] = seq = st->sequence++;
537
538 st->data[5] = 0;
539
540 st->data[6] = len;
541 st->data[7] = address;
542 ret = dvb_usb_generic_rw(d, st->data, 16, st->data, 14, 0);
543 if (st->data[2] != 0x2b) {
544 err("Read eeprom, invalid reply code");
545 ret = -EIO;
546 } else if (st->data[3] != 10) {
547 err("Read eeprom, invalid reply length");
548 ret = -EIO;
549 } else if (st->data[4] != seq) {
550 err("Read eeprom, wrong sequence in reply ");
551 ret = -EIO;
552 } else if (st->data[5] != 1) {
553 err("Read eeprom, wrong status in reply ");
554 ret = -EIO;
555 }
556
557 if (!ret) {
558 for (i = 0; i < len; i++)
559 values[i] = st->data[6 + i];
560 }
561 mutex_unlock(&d->data_mutex);
562
563 return ret;
564}
565
566static int af9005_boot_packet(struct usb_device *udev, int type, u8 *reply,
567 u8 *buf, int size)
568{
569 u16 checksum;
570 int act_len, i, ret;
571
572 memset(buf, 0, size);
573 buf[0] = (u8) (FW_BULKOUT_SIZE & 0xff);
574 buf[1] = (u8) ((FW_BULKOUT_SIZE >> 8) & 0xff);
575 switch (type) {
576 case FW_CONFIG:
577 buf[2] = 0x11;
578 buf[3] = 0x04;
579 buf[4] = 0x00;
580 buf[5] = 0x03;
581 checksum = buf[4] + buf[5];
582 buf[6] = (u8) ((checksum >> 8) & 0xff);
583 buf[7] = (u8) (checksum & 0xff);
584 break;
585 case FW_CONFIRM:
586 buf[2] = 0x11;
587 buf[3] = 0x04;
588 buf[4] = 0x00;
589 buf[5] = 0x01;
590 checksum = buf[4] + buf[5];
591 buf[6] = (u8) ((checksum >> 8) & 0xff);
592 buf[7] = (u8) (checksum & 0xff);
593 break;
594 case FW_BOOT:
595 buf[2] = 0x10;
596 buf[3] = 0x08;
597 buf[4] = 0x00;
598 buf[5] = 0x97;
599 buf[6] = 0xaa;
600 buf[7] = 0x55;
601 buf[8] = 0xa5;
602 buf[9] = 0x5a;
603 checksum = 0;
604 for (i = 4; i <= 9; i++)
605 checksum += buf[i];
606 buf[10] = (u8) ((checksum >> 8) & 0xff);
607 buf[11] = (u8) (checksum & 0xff);
608 break;
609 default:
610 err("boot packet invalid boot packet type");
611 return -EINVAL;
612 }
613 deb_fw(">>> ");
614 debug_dump(buf, FW_BULKOUT_SIZE + 2, deb_fw);
615
616 ret = usb_bulk_msg(udev,
617 usb_sndbulkpipe(udev, 0x02),
618 buf, FW_BULKOUT_SIZE + 2, &act_len, 2000);
619 if (ret)
620 err("boot packet bulk message failed: %d (%d/%d)", ret,
621 FW_BULKOUT_SIZE + 2, act_len);
622 else
623 ret = act_len != FW_BULKOUT_SIZE + 2 ? -1 : 0;
624 if (ret)
625 return ret;
626 memset(buf, 0, 9);
627 ret = usb_bulk_msg(udev,
628 usb_rcvbulkpipe(udev, 0x01), buf, 9, &act_len, 2000);
629 if (ret) {
630 err("boot packet recv bulk message failed: %d", ret);
631 return ret;
632 }
633 deb_fw("<<< ");
634 debug_dump(buf, act_len, deb_fw);
635 checksum = 0;
636 switch (type) {
637 case FW_CONFIG:
638 if (buf[2] != 0x11) {
639 err("boot bad config header.");
640 return -EIO;
641 }
642 if (buf[3] != 0x05) {
643 err("boot bad config size.");
644 return -EIO;
645 }
646 if (buf[4] != 0x00) {
647 err("boot bad config sequence.");
648 return -EIO;
649 }
650 if (buf[5] != 0x04) {
651 err("boot bad config subtype.");
652 return -EIO;
653 }
654 for (i = 4; i <= 6; i++)
655 checksum += buf[i];
656 if (buf[7] * 256 + buf[8] != checksum) {
657 err("boot bad config checksum.");
658 return -EIO;
659 }
660 *reply = buf[6];
661 break;
662 case FW_CONFIRM:
663 if (buf[2] != 0x11) {
664 err("boot bad confirm header.");
665 return -EIO;
666 }
667 if (buf[3] != 0x05) {
668 err("boot bad confirm size.");
669 return -EIO;
670 }
671 if (buf[4] != 0x00) {
672 err("boot bad confirm sequence.");
673 return -EIO;
674 }
675 if (buf[5] != 0x02) {
676 err("boot bad confirm subtype.");
677 return -EIO;
678 }
679 for (i = 4; i <= 6; i++)
680 checksum += buf[i];
681 if (buf[7] * 256 + buf[8] != checksum) {
682 err("boot bad confirm checksum.");
683 return -EIO;
684 }
685 *reply = buf[6];
686 break;
687 case FW_BOOT:
688 if (buf[2] != 0x10) {
689 err("boot bad boot header.");
690 return -EIO;
691 }
692 if (buf[3] != 0x05) {
693 err("boot bad boot size.");
694 return -EIO;
695 }
696 if (buf[4] != 0x00) {
697 err("boot bad boot sequence.");
698 return -EIO;
699 }
700 if (buf[5] != 0x01) {
701 err("boot bad boot pattern 01.");
702 return -EIO;
703 }
704 if (buf[6] != 0x10) {
705 err("boot bad boot pattern 10.");
706 return -EIO;
707 }
708 for (i = 4; i <= 6; i++)
709 checksum += buf[i];
710 if (buf[7] * 256 + buf[8] != checksum) {
711 err("boot bad boot checksum.");
712 return -EIO;
713 }
714 break;
715
716 }
717
718 return 0;
719}
720
721static int af9005_download_firmware(struct usb_device *udev, const struct firmware *fw)
722{
723 int i, packets, ret, act_len;
724
725 u8 *buf;
726 u8 reply;
727
728 buf = kmalloc(FW_BULKOUT_SIZE + 2, GFP_KERNEL);
729 if (!buf)
730 return -ENOMEM;
731
732 ret = af9005_boot_packet(udev, FW_CONFIG, &reply, buf,
733 FW_BULKOUT_SIZE + 2);
734 if (ret)
735 goto err;
736 if (reply != 0x01) {
737 err("before downloading firmware, FW_CONFIG expected 0x01, received 0x%x", reply);
738 ret = -EIO;
739 goto err;
740 }
741 packets = fw->size / FW_BULKOUT_SIZE;
742 buf[0] = (u8) (FW_BULKOUT_SIZE & 0xff);
743 buf[1] = (u8) ((FW_BULKOUT_SIZE >> 8) & 0xff);
744 for (i = 0; i < packets; i++) {
745 memcpy(&buf[2], fw->data + i * FW_BULKOUT_SIZE,
746 FW_BULKOUT_SIZE);
747 deb_fw(">>> ");
748 debug_dump(buf, FW_BULKOUT_SIZE + 2, deb_fw);
749 ret = usb_bulk_msg(udev,
750 usb_sndbulkpipe(udev, 0x02),
751 buf, FW_BULKOUT_SIZE + 2, &act_len, 1000);
752 if (ret) {
753 err("firmware download failed at packet %d with code %d", i, ret);
754 goto err;
755 }
756 }
757 ret = af9005_boot_packet(udev, FW_CONFIRM, &reply,
758 buf, FW_BULKOUT_SIZE + 2);
759 if (ret)
760 goto err;
761 if (reply != (u8) (packets & 0xff)) {
762 err("after downloading firmware, FW_CONFIRM expected 0x%x, received 0x%x", packets & 0xff, reply);
763 ret = -EIO;
764 goto err;
765 }
766 ret = af9005_boot_packet(udev, FW_BOOT, &reply, buf,
767 FW_BULKOUT_SIZE + 2);
768 if (ret)
769 goto err;
770 ret = af9005_boot_packet(udev, FW_CONFIG, &reply, buf,
771 FW_BULKOUT_SIZE + 2);
772 if (ret)
773 goto err;
774 if (reply != 0x02) {
775 err("after downloading firmware, FW_CONFIG expected 0x02, received 0x%x", reply);
776 ret = -EIO;
777 goto err;
778 }
779
780err:
781 kfree(buf);
782 return ret;
783
784}
785
786int af9005_led_control(struct dvb_usb_device *d, int onoff)
787{
788 struct af9005_device_state *st = d->priv;
789 int temp, ret;
790
791 if (onoff && dvb_usb_af9005_led)
792 temp = 1;
793 else
794 temp = 0;
795 if (st->led_state != temp) {
796 ret =
797 af9005_write_register_bits(d, xd_p_reg_top_locken1,
798 reg_top_locken1_pos,
799 reg_top_locken1_len, temp);
800 if (ret)
801 return ret;
802 ret =
803 af9005_write_register_bits(d, xd_p_reg_top_lock1,
804 reg_top_lock1_pos,
805 reg_top_lock1_len, temp);
806 if (ret)
807 return ret;
808 st->led_state = temp;
809 }
810 return 0;
811}
812
813static int af9005_frontend_attach(struct dvb_usb_adapter *adap)
814{
815 u8 buf[8];
816 int i;
817
818
819
820
821
822 struct usb_device *udev = adap->dev->udev;
823 usb_clear_halt(udev, usb_sndbulkpipe(udev, 2));
824 usb_clear_halt(udev, usb_rcvbulkpipe(udev, 1));
825 if (dvb_usb_af9005_dump_eeprom) {
826 printk("EEPROM DUMP\n");
827 for (i = 0; i < 255; i += 8) {
828 af9005_read_eeprom(adap->dev, i, buf, 8);
829 printk("ADDR %x ", i);
830 debug_dump(buf, 8, printk);
831 }
832 }
833 adap->fe_adap[0].fe = af9005_fe_attach(adap->dev);
834 return 0;
835}
836
837static int af9005_rc_query(struct dvb_usb_device *d, u32 * event, int *state)
838{
839 struct af9005_device_state *st = d->priv;
840 int ret, len;
841 u8 seq;
842
843 *state = REMOTE_NO_KEY_PRESSED;
844 if (rc_decode == NULL) {
845
846 return 0;
847 }
848
849 mutex_lock(&d->data_mutex);
850
851
852 st->data[0] = 3;
853 st->data[1] = 0;
854 st->data[2] = 0x40;
855 st->data[3] = 1;
856 st->data[4] = seq = st->sequence++;
857 ret = dvb_usb_generic_rw(d, st->data, 5, st->data, 256, 0);
858 if (ret) {
859 err("rc query failed");
860 goto ret;
861 }
862 if (st->data[2] != 0x41) {
863 err("rc query bad header.");
864 ret = -EIO;
865 goto ret;
866 } else if (st->data[4] != seq) {
867 err("rc query bad sequence.");
868 ret = -EIO;
869 goto ret;
870 }
871 len = st->data[5];
872 if (len > 246) {
873 err("rc query invalid length");
874 ret = -EIO;
875 goto ret;
876 }
877 if (len > 0) {
878 deb_rc("rc data (%d) ", len);
879 debug_dump((st->data + 6), len, deb_rc);
880 ret = rc_decode(d, &st->data[6], len, event, state);
881 if (ret) {
882 err("rc_decode failed");
883 goto ret;
884 } else {
885 deb_rc("rc_decode state %x event %x\n", *state, *event);
886 if (*state == REMOTE_KEY_REPEAT)
887 *event = d->last_event;
888 }
889 }
890
891ret:
892 mutex_unlock(&d->data_mutex);
893 return ret;
894}
895
896static int af9005_power_ctrl(struct dvb_usb_device *d, int onoff)
897{
898
899 return 0;
900}
901
902static int af9005_pid_filter_control(struct dvb_usb_adapter *adap, int onoff)
903{
904 int ret;
905 deb_info("pid filter control onoff %d\n", onoff);
906 if (onoff) {
907 ret =
908 af9005_write_ofdm_register(adap->dev, XD_MP2IF_DMX_CTRL, 1);
909 if (ret)
910 return ret;
911 ret =
912 af9005_write_register_bits(adap->dev,
913 XD_MP2IF_DMX_CTRL, 1, 1, 1);
914 if (ret)
915 return ret;
916 ret =
917 af9005_write_ofdm_register(adap->dev, XD_MP2IF_DMX_CTRL, 1);
918 } else
919 ret =
920 af9005_write_ofdm_register(adap->dev, XD_MP2IF_DMX_CTRL, 0);
921 if (ret)
922 return ret;
923 deb_info("pid filter control ok\n");
924 return 0;
925}
926
927static int af9005_pid_filter(struct dvb_usb_adapter *adap, int index,
928 u16 pid, int onoff)
929{
930 u8 cmd = index & 0x1f;
931 int ret;
932 deb_info("set pid filter, index %d, pid %x, onoff %d\n", index,
933 pid, onoff);
934 if (onoff) {
935
936
937 if (adap->feedcount == 1) {
938 deb_info("first pid set, enable pid table\n");
939 ret = af9005_pid_filter_control(adap, onoff);
940 if (ret)
941 return ret;
942 }
943 ret =
944 af9005_write_ofdm_register(adap->dev,
945 XD_MP2IF_PID_DATA_L,
946 (u8) (pid & 0xff));
947 if (ret)
948 return ret;
949 ret =
950 af9005_write_ofdm_register(adap->dev,
951 XD_MP2IF_PID_DATA_H,
952 (u8) (pid >> 8));
953 if (ret)
954 return ret;
955 cmd |= 0x20 | 0x40;
956 } else {
957 if (adap->feedcount == 0) {
958 deb_info("last pid unset, disable pid table\n");
959 ret = af9005_pid_filter_control(adap, onoff);
960 if (ret)
961 return ret;
962 }
963 }
964 ret = af9005_write_ofdm_register(adap->dev, XD_MP2IF_PID_IDX, cmd);
965 if (ret)
966 return ret;
967 deb_info("set pid ok\n");
968 return 0;
969}
970
971static int af9005_identify_state(struct usb_device *udev,
972 struct dvb_usb_device_properties *props,
973 struct dvb_usb_device_description **desc,
974 int *cold)
975{
976 int ret;
977 u8 reply, *buf;
978
979 buf = kmalloc(FW_BULKOUT_SIZE + 2, GFP_KERNEL);
980 if (!buf)
981 return -ENOMEM;
982
983 ret = af9005_boot_packet(udev, FW_CONFIG, &reply,
984 buf, FW_BULKOUT_SIZE + 2);
985 if (ret)
986 goto err;
987 deb_info("result of FW_CONFIG in identify state %d\n", reply);
988 if (reply == 0x01)
989 *cold = 1;
990 else if (reply == 0x02)
991 *cold = 0;
992 else
993 return -EIO;
994 deb_info("Identify state cold = %d\n", *cold);
995
996err:
997 kfree(buf);
998 return ret;
999}
1000
1001static struct dvb_usb_device_properties af9005_properties;
1002
1003static int af9005_usb_probe(struct usb_interface *intf,
1004 const struct usb_device_id *id)
1005{
1006 return dvb_usb_device_init(intf, &af9005_properties,
1007 THIS_MODULE, NULL, adapter_nr);
1008}
1009
1010enum af9005_usb_table_entry {
1011 AFATECH_AF9005,
1012 TERRATEC_AF9005,
1013 ANSONIC_AF9005,
1014};
1015
1016static struct usb_device_id af9005_usb_table[] = {
1017 [AFATECH_AF9005] = {USB_DEVICE(USB_VID_AFATECH,
1018 USB_PID_AFATECH_AF9005)},
1019 [TERRATEC_AF9005] = {USB_DEVICE(USB_VID_TERRATEC,
1020 USB_PID_TERRATEC_CINERGY_T_USB_XE)},
1021 [ANSONIC_AF9005] = {USB_DEVICE(USB_VID_ANSONIC,
1022 USB_PID_ANSONIC_DVBT_USB)},
1023 { }
1024};
1025
1026MODULE_DEVICE_TABLE(usb, af9005_usb_table);
1027
1028static struct dvb_usb_device_properties af9005_properties = {
1029 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1030
1031 .usb_ctrl = DEVICE_SPECIFIC,
1032 .firmware = "af9005.fw",
1033 .download_firmware = af9005_download_firmware,
1034 .no_reconnect = 1,
1035
1036 .size_of_priv = sizeof(struct af9005_device_state),
1037
1038 .num_adapters = 1,
1039 .adapter = {
1040 {
1041 .num_frontends = 1,
1042 .fe = {{
1043 .caps =
1044 DVB_USB_ADAP_HAS_PID_FILTER |
1045 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1046 .pid_filter_count = 32,
1047 .pid_filter = af9005_pid_filter,
1048
1049 .frontend_attach = af9005_frontend_attach,
1050
1051
1052 .stream = {
1053 .type = USB_BULK,
1054 .count = 10,
1055 .endpoint = 0x04,
1056 .u = {
1057 .bulk = {
1058 .buffersize = 4096,
1059 }
1060 }
1061 },
1062 }},
1063 }
1064 },
1065 .power_ctrl = af9005_power_ctrl,
1066 .identify_state = af9005_identify_state,
1067
1068 .i2c_algo = &af9005_i2c_algo,
1069
1070 .rc.legacy = {
1071 .rc_interval = 200,
1072 .rc_map_table = NULL,
1073 .rc_map_size = 0,
1074 .rc_query = af9005_rc_query,
1075 },
1076
1077 .generic_bulk_ctrl_endpoint = 2,
1078 .generic_bulk_ctrl_endpoint_response = 1,
1079
1080 .num_device_descs = 3,
1081 .devices = {
1082 {.name = "Afatech DVB-T USB1.1 stick",
1083 .cold_ids = {&af9005_usb_table[AFATECH_AF9005], NULL},
1084 .warm_ids = {NULL},
1085 },
1086 {.name = "TerraTec Cinergy T USB XE",
1087 .cold_ids = {&af9005_usb_table[TERRATEC_AF9005], NULL},
1088 .warm_ids = {NULL},
1089 },
1090 {.name = "Ansonic DVB-T USB1.1 stick",
1091 .cold_ids = {&af9005_usb_table[ANSONIC_AF9005], NULL},
1092 .warm_ids = {NULL},
1093 },
1094 {NULL},
1095 }
1096};
1097
1098
1099static struct usb_driver af9005_usb_driver = {
1100 .name = "dvb_usb_af9005",
1101 .probe = af9005_usb_probe,
1102 .disconnect = dvb_usb_device_exit,
1103 .id_table = af9005_usb_table,
1104};
1105
1106
1107static int __init af9005_usb_module_init(void)
1108{
1109 int result;
1110 if ((result = usb_register(&af9005_usb_driver))) {
1111 err("usb_register failed. (%d)", result);
1112 return result;
1113 }
1114#if IS_MODULE(CONFIG_DVB_USB_AF9005) || defined(CONFIG_DVB_USB_AF9005_REMOTE)
1115
1116 rc_decode = symbol_request(af9005_rc_decode);
1117 rc_keys = symbol_request(rc_map_af9005_table);
1118 rc_keys_size = symbol_request(rc_map_af9005_table_size);
1119#endif
1120 if (rc_decode == NULL || rc_keys == NULL || rc_keys_size == NULL) {
1121 err("af9005_rc_decode function not found, disabling remote");
1122 af9005_properties.rc.legacy.rc_query = NULL;
1123 } else {
1124 af9005_properties.rc.legacy.rc_map_table = rc_keys;
1125 af9005_properties.rc.legacy.rc_map_size = *rc_keys_size;
1126 }
1127
1128 return 0;
1129}
1130
1131static void __exit af9005_usb_module_exit(void)
1132{
1133
1134 if (rc_decode != NULL)
1135 symbol_put(af9005_rc_decode);
1136 if (rc_keys != NULL)
1137 symbol_put(rc_map_af9005_table);
1138 if (rc_keys_size != NULL)
1139 symbol_put(rc_map_af9005_table_size);
1140
1141 usb_deregister(&af9005_usb_driver);
1142}
1143
1144module_init(af9005_usb_module_init);
1145module_exit(af9005_usb_module_exit);
1146
1147MODULE_AUTHOR("Luca Olivetti <luca@ventoso.org>");
1148MODULE_DESCRIPTION("Driver for Afatech 9005 DVB-T USB1.1 stick");
1149MODULE_VERSION("1.0");
1150MODULE_LICENSE("GPL");
1151