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