Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
af9005.c
Go to the documentation of this file.
1 /* DVB USB compliant Linux driver for the Afatech 9005
2  * USB1.1 DVB-T receiver.
3  *
4  * Copyright (C) 2007 Luca Olivetti ([email protected])
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 */
30  "set debugging level (1=info,xfer=2,rc=4,reg=8,i2c=16,fw=32 (or-able))."
32 /* enable obnoxious led */
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 
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 
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 
148 {
149  int ret;
150  deb_reg("read register %x ", reg);
151  ret = af9005_generic_read_write(d, 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 
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,
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 
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,
183  &temp, 1);
184  if (ret)
185  deb_reg("failed\n");
186  else
187  deb_reg("ok\n");
188  return ret;
189 }
190 
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,
200  values, len);
201  if (ret)
202  deb_reg("failed\n");
203  else
204  deb_reg("ok\n");
205  return ret;
206 }
207 
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 
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,
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,
255  AF9005_TUNER_REG, values, len);
256 }
257 
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 =
275  &temp);
276  if (ret)
277  return ret;
278  done = temp & (regmask[i2c_m_status_wdat_done_len - 1]
280  if (done)
281  break;
282  fail = temp & (regmask[i2c_m_status_wdat_fail_len - 1]
284  if (fail)
285  break;
286  msleep(50);
287  }
288  if (i == 200)
289  return -ETIMEDOUT;
290  if (fail) {
291  /* clear write fail bit */
296  1);
297  return -EIO;
298  }
299  /* clear write done bit */
300  ret =
305  if (ret)
306  return ret;
307  }
308  return 0;
309 }
310 
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) */
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 =
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 =
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 
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 =
784  reg_top_locken1_len, temp);
785  if (ret)
786  return ret;
787  ret =
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 =
888  if (ret)
889  return ret;
890  ret =
892  XD_MP2IF_DMX_CTRL, 1, 1, 1);
893  if (ret)
894  return ret;
895  ret =
897  } else
898  ret =
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 =
925  (u8) (pid & 0xff));
926  if (ret)
927  return ret;
928  ret =
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  }
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,
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,
978 }
979 
984 };
985 
986 static struct usb_device_id af9005_usb_table[] = {
987  [AFATECH_AF9005] = {USB_DEVICE(USB_VID_AFATECH,
989  [TERRATEC_AF9005] = {USB_DEVICE(USB_VID_TERRATEC,
991  [ANSONIC_AF9005] = {USB_DEVICE(USB_VID_ANSONIC,
993  { }
994 };
995 
996 MODULE_DEVICE_TABLE(usb, af9005_usb_table);
997 
998 static struct dvb_usb_device_properties af9005_properties = {
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 =
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);
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)
1103  if (rc_keys != NULL)
1105  if (rc_keys_size != NULL)
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 <[email protected]>");
1115 MODULE_DESCRIPTION("Driver for Afatech 9005 DVB-T USB1.1 stick");
1116 MODULE_VERSION("1.0");
1117 MODULE_LICENSE("GPL");