Commit | Line | Data |
---|---|---|
af4e067e LO |
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 | * | |
395cf969 | 22 | * see Documentation/dvb/README.dvb-usb for more information |
af4e067e LO |
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 */ | |
61f6a056 | 33 | bool dvb_usb_af9005_led = true; |
af4e067e LO |
34 | module_param_named(led, dvb_usb_af9005_led, bool, 0644); |
35 | MODULE_PARM_DESC(led, "enable led (default: 1)."); | |
36 | ||
37 | /* eeprom dump */ | |
d45b9b8a | 38 | static int dvb_usb_af9005_dump_eeprom; |
af4e067e LO |
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 | ||
78e92006 JG |
42 | DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); |
43 | ||
af4e067e | 44 | /* remote control decoder */ |
d45b9b8a HV |
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; | |
af4e067e LO |
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 | ||
d45b9b8a | 57 | static int af9005_generic_read_write(struct dvb_usb_device *d, u16 reg, |
af4e067e LO |
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 | ||
17f93e1e | 105 | ret = dvb_usb_generic_rw(d, obuf, 16, ibuf, 17, 0); |
af4e067e LO |
106 | if (ret) |
107 | return ret; | |
108 | ||
109 | /* sanity check */ | |
110 | if (ibuf[2] != AF9005_REGISTER_RW_ACK) { | |
111 | err("generic read/write, wrong reply code."); | |
112 | return -EIO; | |
113 | } | |
114 | if (ibuf[3] != 0x0d) { | |
115 | err("generic read/write, wrong length in reply."); | |
116 | return -EIO; | |
117 | } | |
118 | if (ibuf[4] != obuf[4]) { | |
119 | err("generic read/write, wrong sequence in reply."); | |
120 | return -EIO; | |
121 | } | |
122 | /* | |
123 | Windows driver doesn't check these fields, in fact sometimes | |
124 | the register in the reply is different that what has been sent | |
125 | ||
126 | if (ibuf[5] != obuf[5] || ibuf[6] != obuf[6]) { | |
127 | err("generic read/write, wrong register in reply."); | |
128 | return -EIO; | |
129 | } | |
130 | if (ibuf[7] != command) { | |
131 | err("generic read/write wrong command in reply."); | |
132 | return -EIO; | |
133 | } | |
134 | */ | |
135 | if (ibuf[16] != 0x01) { | |
136 | err("generic read/write wrong status code in reply."); | |
137 | return -EIO; | |
138 | } | |
139 | if (readwrite == AF9005_CMD_READ) | |
140 | for (i = 0; i < len; i++) | |
141 | values[i] = ibuf[8 + i]; | |
142 | ||
143 | return 0; | |
144 | ||
145 | } | |
146 | ||
147 | int af9005_read_ofdm_register(struct dvb_usb_device *d, u16 reg, u8 * value) | |
148 | { | |
149 | int ret; | |
150 | deb_reg("read register %x ", reg); | |
151 | ret = af9005_generic_read_write(d, reg, | |
152 | AF9005_CMD_READ, AF9005_OFDM_REG, | |
153 | value, 1); | |
154 | if (ret) | |
155 | deb_reg("failed\n"); | |
156 | else | |
157 | deb_reg("value %x\n", *value); | |
158 | return ret; | |
159 | } | |
160 | ||
161 | int af9005_read_ofdm_registers(struct dvb_usb_device *d, u16 reg, | |
162 | u8 * values, int len) | |
163 | { | |
164 | int ret; | |
165 | deb_reg("read %d registers %x ", len, reg); | |
166 | ret = af9005_generic_read_write(d, reg, | |
167 | AF9005_CMD_READ, AF9005_OFDM_REG, | |
168 | values, len); | |
169 | if (ret) | |
170 | deb_reg("failed\n"); | |
171 | else | |
172 | debug_dump(values, len, deb_reg); | |
173 | return ret; | |
174 | } | |
175 | ||
176 | int af9005_write_ofdm_register(struct dvb_usb_device *d, u16 reg, u8 value) | |
177 | { | |
178 | int ret; | |
179 | u8 temp = value; | |
180 | deb_reg("write register %x value %x ", reg, value); | |
181 | ret = af9005_generic_read_write(d, reg, | |
182 | AF9005_CMD_WRITE, AF9005_OFDM_REG, | |
183 | &temp, 1); | |
184 | if (ret) | |
185 | deb_reg("failed\n"); | |
186 | else | |
187 | deb_reg("ok\n"); | |
188 | return ret; | |
189 | } | |
190 | ||
191 | int af9005_write_ofdm_registers(struct dvb_usb_device *d, u16 reg, | |
192 | u8 * values, int len) | |
193 | { | |
194 | int ret; | |
195 | deb_reg("write %d registers %x values ", len, reg); | |
196 | debug_dump(values, len, deb_reg); | |
197 | ||
198 | ret = af9005_generic_read_write(d, reg, | |
199 | AF9005_CMD_WRITE, AF9005_OFDM_REG, | |
200 | values, len); | |
201 | if (ret) | |
202 | deb_reg("failed\n"); | |
203 | else | |
204 | deb_reg("ok\n"); | |
205 | return ret; | |
206 | } | |
207 | ||
208 | int af9005_read_register_bits(struct dvb_usb_device *d, u16 reg, u8 pos, | |
209 | u8 len, u8 * value) | |
210 | { | |
211 | u8 temp; | |
212 | int ret; | |
213 | deb_reg("read bits %x %x %x", reg, pos, len); | |
214 | ret = af9005_read_ofdm_register(d, reg, &temp); | |
215 | if (ret) { | |
216 | deb_reg(" failed\n"); | |
217 | return ret; | |
218 | } | |
219 | *value = (temp >> pos) & regmask[len - 1]; | |
220 | deb_reg(" value %x\n", *value); | |
221 | return 0; | |
222 | ||
223 | } | |
224 | ||
225 | int af9005_write_register_bits(struct dvb_usb_device *d, u16 reg, u8 pos, | |
226 | u8 len, u8 value) | |
227 | { | |
228 | u8 temp, mask; | |
229 | int ret; | |
230 | deb_reg("write bits %x %x %x value %x\n", reg, pos, len, value); | |
231 | if (pos == 0 && len == 8) | |
232 | return af9005_write_ofdm_register(d, reg, value); | |
233 | ret = af9005_read_ofdm_register(d, reg, &temp); | |
234 | if (ret) | |
235 | return ret; | |
236 | mask = regmask[len - 1] << pos; | |
237 | temp = (temp & ~mask) | ((value << pos) & mask); | |
238 | return af9005_write_ofdm_register(d, reg, temp); | |
239 | ||
240 | } | |
241 | ||
242 | static int af9005_usb_read_tuner_registers(struct dvb_usb_device *d, | |
243 | u16 reg, u8 * values, int len) | |
244 | { | |
245 | return af9005_generic_read_write(d, reg, | |
246 | AF9005_CMD_READ, AF9005_TUNER_REG, | |
247 | values, len); | |
248 | } | |
249 | ||
250 | static int af9005_usb_write_tuner_registers(struct dvb_usb_device *d, | |
251 | u16 reg, u8 * values, int len) | |
252 | { | |
253 | return af9005_generic_read_write(d, reg, | |
254 | AF9005_CMD_WRITE, | |
255 | AF9005_TUNER_REG, values, len); | |
256 | } | |
257 | ||
258 | int af9005_write_tuner_registers(struct dvb_usb_device *d, u16 reg, | |
259 | u8 * values, int len) | |
260 | { | |
261 | /* don't let the name of this function mislead you: it's just used | |
262 | as an interface from the firmware to the i2c bus. The actual | |
263 | i2c addresses are contained in the data */ | |
264 | int ret, i, done = 0, fail = 0; | |
265 | u8 temp; | |
266 | ret = af9005_usb_write_tuner_registers(d, reg, values, len); | |
267 | if (ret) | |
268 | return ret; | |
269 | if (reg != 0xffff) { | |
270 | /* check if write done (0xa40d bit 1) or fail (0xa40d bit 2) */ | |
271 | for (i = 0; i < 200; i++) { | |
272 | ret = | |
273 | af9005_read_ofdm_register(d, | |
274 | xd_I2C_i2c_m_status_wdat_done, | |
275 | &temp); | |
276 | if (ret) | |
277 | return ret; | |
278 | done = temp & (regmask[i2c_m_status_wdat_done_len - 1] | |
279 | << i2c_m_status_wdat_done_pos); | |
280 | if (done) | |
281 | break; | |
282 | fail = temp & (regmask[i2c_m_status_wdat_fail_len - 1] | |
283 | << i2c_m_status_wdat_fail_pos); | |
284 | if (fail) | |
285 | break; | |
286 | msleep(50); | |
287 | } | |
288 | if (i == 200) | |
289 | return -ETIMEDOUT; | |
290 | if (fail) { | |
291 | /* clear write fail bit */ | |
292 | af9005_write_register_bits(d, | |
293 | xd_I2C_i2c_m_status_wdat_fail, | |
294 | i2c_m_status_wdat_fail_pos, | |
295 | i2c_m_status_wdat_fail_len, | |
296 | 1); | |
297 | return -EIO; | |
298 | } | |
299 | /* clear write done bit */ | |
300 | ret = | |
301 | af9005_write_register_bits(d, | |
302 | xd_I2C_i2c_m_status_wdat_fail, | |
303 | i2c_m_status_wdat_done_pos, | |
304 | i2c_m_status_wdat_done_len, 1); | |
305 | if (ret) | |
306 | return ret; | |
307 | } | |
308 | return 0; | |
309 | } | |
310 | ||
311 | int af9005_read_tuner_registers(struct dvb_usb_device *d, u16 reg, u8 addr, | |
312 | u8 * values, int len) | |
313 | { | |
314 | /* don't let the name of this function mislead you: it's just used | |
315 | as an interface from the firmware to the i2c bus. The actual | |
316 | i2c addresses are contained in the data */ | |
317 | int ret, i; | |
318 | u8 temp, buf[2]; | |
319 | ||
320 | buf[0] = addr; /* tuner i2c address */ | |
321 | buf[1] = values[0]; /* tuner register */ | |
322 | ||
323 | values[0] = addr + 0x01; /* i2c read address */ | |
324 | ||
325 | if (reg == APO_REG_I2C_RW_SILICON_TUNER) { | |
326 | /* write tuner i2c address to tuner, 0c00c0 undocumented, found by sniffing */ | |
327 | ret = af9005_write_tuner_registers(d, 0x00c0, buf, 2); | |
328 | if (ret) | |
329 | return ret; | |
330 | } | |
331 | ||
332 | /* send read command to ofsm */ | |
333 | ret = af9005_usb_read_tuner_registers(d, reg, values, 1); | |
334 | if (ret) | |
335 | return ret; | |
336 | ||
337 | /* check if read done */ | |
338 | for (i = 0; i < 200; i++) { | |
339 | ret = af9005_read_ofdm_register(d, 0xa408, &temp); | |
340 | if (ret) | |
341 | return ret; | |
342 | if (temp & 0x01) | |
343 | break; | |
344 | msleep(50); | |
345 | } | |
346 | if (i == 200) | |
347 | return -ETIMEDOUT; | |
348 | ||
349 | /* clear read done bit (by writing 1) */ | |
350 | ret = af9005_write_ofdm_register(d, xd_I2C_i2c_m_data8, 1); | |
351 | if (ret) | |
352 | return ret; | |
353 | ||
354 | /* get read data (available from 0xa400) */ | |
355 | for (i = 0; i < len; i++) { | |
356 | ret = af9005_read_ofdm_register(d, 0xa400 + i, &temp); | |
357 | if (ret) | |
358 | return ret; | |
359 | values[i] = temp; | |
360 | } | |
361 | return 0; | |
362 | } | |
363 | ||
364 | static int af9005_i2c_write(struct dvb_usb_device *d, u8 i2caddr, u8 reg, | |
365 | u8 * data, int len) | |
366 | { | |
367 | int ret, i; | |
368 | u8 buf[3]; | |
369 | deb_i2c("i2c_write i2caddr %x, reg %x, len %d data ", i2caddr, | |
370 | reg, len); | |
371 | debug_dump(data, len, deb_i2c); | |
372 | ||
373 | for (i = 0; i < len; i++) { | |
374 | buf[0] = i2caddr; | |
375 | buf[1] = reg + (u8) i; | |
376 | buf[2] = data[i]; | |
377 | ret = | |
378 | af9005_write_tuner_registers(d, | |
379 | APO_REG_I2C_RW_SILICON_TUNER, | |
380 | buf, 3); | |
381 | if (ret) { | |
382 | deb_i2c("i2c_write failed\n"); | |
383 | return ret; | |
384 | } | |
385 | } | |
386 | deb_i2c("i2c_write ok\n"); | |
387 | return 0; | |
388 | } | |
389 | ||
390 | static int af9005_i2c_read(struct dvb_usb_device *d, u8 i2caddr, u8 reg, | |
391 | u8 * data, int len) | |
392 | { | |
393 | int ret, i; | |
394 | u8 temp; | |
395 | deb_i2c("i2c_read i2caddr %x, reg %x, len %d\n ", i2caddr, reg, len); | |
396 | for (i = 0; i < len; i++) { | |
397 | temp = reg + i; | |
398 | ret = | |
399 | af9005_read_tuner_registers(d, | |
400 | APO_REG_I2C_RW_SILICON_TUNER, | |
401 | i2caddr, &temp, 1); | |
402 | if (ret) { | |
403 | deb_i2c("i2c_read failed\n"); | |
404 | return ret; | |
405 | } | |
406 | data[i] = temp; | |
407 | } | |
408 | deb_i2c("i2c data read: "); | |
409 | debug_dump(data, len, deb_i2c); | |
410 | return 0; | |
411 | } | |
412 | ||
413 | static int af9005_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[], | |
414 | int num) | |
415 | { | |
416 | /* only implements what the mt2060 module does, don't know how | |
417 | to make it really generic */ | |
418 | struct dvb_usb_device *d = i2c_get_adapdata(adap); | |
419 | int ret; | |
420 | u8 reg, addr; | |
421 | u8 *value; | |
422 | ||
423 | if (mutex_lock_interruptible(&d->i2c_mutex) < 0) | |
424 | return -EAGAIN; | |
425 | ||
426 | if (num > 2) | |
427 | warn("more than 2 i2c messages at a time is not handled yet. TODO."); | |
428 | ||
429 | if (num == 2) { | |
430 | /* reads a single register */ | |
431 | reg = *msg[0].buf; | |
432 | addr = msg[0].addr; | |
433 | value = msg[1].buf; | |
434 | ret = af9005_i2c_read(d, addr, reg, value, 1); | |
435 | if (ret == 0) | |
436 | ret = 2; | |
437 | } else { | |
438 | /* write one or more registers */ | |
439 | reg = msg[0].buf[0]; | |
440 | addr = msg[0].addr; | |
441 | value = &msg[0].buf[1]; | |
442 | ret = af9005_i2c_write(d, addr, reg, value, msg[0].len - 1); | |
443 | if (ret == 0) | |
444 | ret = 1; | |
445 | } | |
446 | ||
447 | mutex_unlock(&d->i2c_mutex); | |
448 | return ret; | |
449 | } | |
450 | ||
451 | static u32 af9005_i2c_func(struct i2c_adapter *adapter) | |
452 | { | |
453 | return I2C_FUNC_I2C; | |
454 | } | |
455 | ||
456 | static struct i2c_algorithm af9005_i2c_algo = { | |
457 | .master_xfer = af9005_i2c_xfer, | |
458 | .functionality = af9005_i2c_func, | |
459 | }; | |
460 | ||
461 | int af9005_send_command(struct dvb_usb_device *d, u8 command, u8 * wbuf, | |
462 | int wlen, u8 * rbuf, int rlen) | |
463 | { | |
464 | struct af9005_device_state *st = d->priv; | |
465 | ||
466 | int ret, i, packet_len; | |
467 | u8 buf[64]; | |
468 | u8 ibuf[64]; | |
469 | ||
470 | if (wlen < 0) { | |
471 | err("send command, wlen less than 0 bytes. Makes no sense."); | |
472 | return -EINVAL; | |
473 | } | |
474 | if (wlen > 54) { | |
475 | err("send command, wlen more than 54 bytes. Not supported."); | |
476 | return -EINVAL; | |
477 | } | |
478 | if (rlen > 54) { | |
479 | err("send command, rlen more than 54 bytes. Not supported."); | |
480 | return -EINVAL; | |
481 | } | |
482 | packet_len = wlen + 5; | |
483 | buf[0] = (u8) (packet_len & 0xff); | |
484 | buf[1] = (u8) ((packet_len & 0xff00) >> 8); | |
485 | ||
486 | buf[2] = 0x26; /* packet type */ | |
487 | buf[3] = wlen + 3; | |
488 | buf[4] = st->sequence++; | |
489 | buf[5] = command; | |
490 | buf[6] = wlen; | |
491 | for (i = 0; i < wlen; i++) | |
492 | buf[7 + i] = wbuf[i]; | |
17f93e1e | 493 | ret = dvb_usb_generic_rw(d, buf, wlen + 7, ibuf, rlen + 7, 0); |
af4e067e LO |
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; | |
17f93e1e | 540 | ret = dvb_usb_generic_rw(d, obuf, 16, ibuf, 14, 0); |
af4e067e LO |
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 | ||
d45b9b8a | 719 | static int af9005_download_firmware(struct usb_device *udev, const struct firmware *fw) |
af4e067e LO |
720 | { |
721 | int i, packets, ret, act_len; | |
722 | ||
723 | u8 buf[FW_BULKOUT_SIZE + 2]; | |
724 | u8 reply; | |
725 | ||
726 | ret = af9005_boot_packet(udev, FW_CONFIG, &reply); | |
727 | if (ret) | |
728 | return ret; | |
729 | if (reply != 0x01) { | |
730 | err("before downloading firmware, FW_CONFIG expected 0x01, received 0x%x", reply); | |
731 | return -EIO; | |
732 | } | |
733 | packets = fw->size / FW_BULKOUT_SIZE; | |
734 | buf[0] = (u8) (FW_BULKOUT_SIZE & 0xff); | |
735 | buf[1] = (u8) ((FW_BULKOUT_SIZE >> 8) & 0xff); | |
736 | for (i = 0; i < packets; i++) { | |
737 | memcpy(&buf[2], fw->data + i * FW_BULKOUT_SIZE, | |
738 | FW_BULKOUT_SIZE); | |
739 | deb_fw(">>> "); | |
740 | debug_dump(buf, FW_BULKOUT_SIZE + 2, deb_fw); | |
741 | ret = usb_bulk_msg(udev, | |
742 | usb_sndbulkpipe(udev, 0x02), | |
743 | buf, FW_BULKOUT_SIZE + 2, &act_len, 1000); | |
744 | if (ret) { | |
745 | err("firmware download failed at packet %d with code %d", i, ret); | |
746 | return ret; | |
747 | } | |
748 | } | |
749 | ret = af9005_boot_packet(udev, FW_CONFIRM, &reply); | |
750 | if (ret) | |
751 | return ret; | |
752 | if (reply != (u8) (packets & 0xff)) { | |
753 | err("after downloading firmware, FW_CONFIRM expected 0x%x, received 0x%x", packets & 0xff, reply); | |
754 | return -EIO; | |
755 | } | |
756 | ret = af9005_boot_packet(udev, FW_BOOT, &reply); | |
757 | if (ret) | |
758 | return ret; | |
759 | ret = af9005_boot_packet(udev, FW_CONFIG, &reply); | |
760 | if (ret) | |
761 | return ret; | |
762 | if (reply != 0x02) { | |
763 | err("after downloading firmware, FW_CONFIG expected 0x02, received 0x%x", reply); | |
764 | return -EIO; | |
765 | } | |
766 | ||
767 | return 0; | |
768 | ||
769 | } | |
770 | ||
771 | int af9005_led_control(struct dvb_usb_device *d, int onoff) | |
772 | { | |
773 | struct af9005_device_state *st = d->priv; | |
774 | int temp, ret; | |
775 | ||
776 | if (onoff && dvb_usb_af9005_led) | |
777 | temp = 1; | |
778 | else | |
779 | temp = 0; | |
780 | if (st->led_state != temp) { | |
781 | ret = | |
782 | af9005_write_register_bits(d, xd_p_reg_top_locken1, | |
783 | reg_top_locken1_pos, | |
784 | reg_top_locken1_len, temp); | |
785 | if (ret) | |
786 | return ret; | |
787 | ret = | |
788 | af9005_write_register_bits(d, xd_p_reg_top_lock1, | |
789 | reg_top_lock1_pos, | |
790 | reg_top_lock1_len, temp); | |
791 | if (ret) | |
792 | return ret; | |
793 | st->led_state = temp; | |
794 | } | |
795 | return 0; | |
796 | } | |
797 | ||
798 | static int af9005_frontend_attach(struct dvb_usb_adapter *adap) | |
799 | { | |
800 | u8 buf[8]; | |
801 | int i; | |
802 | ||
803 | /* without these calls the first commands after downloading | |
804 | the firmware fail. I put these calls here to simulate | |
805 | what it is done in dvb-usb-init.c. | |
806 | */ | |
807 | struct usb_device *udev = adap->dev->udev; | |
808 | usb_clear_halt(udev, usb_sndbulkpipe(udev, 2)); | |
809 | usb_clear_halt(udev, usb_rcvbulkpipe(udev, 1)); | |
810 | if (dvb_usb_af9005_dump_eeprom) { | |
811 | printk("EEPROM DUMP\n"); | |
812 | for (i = 0; i < 255; i += 8) { | |
813 | af9005_read_eeprom(adap->dev, i, buf, 8); | |
814 | printk("ADDR %x ", i); | |
815 | debug_dump(buf, 8, printk); | |
816 | } | |
817 | } | |
77eed219 | 818 | adap->fe_adap[0].fe = af9005_fe_attach(adap->dev); |
af4e067e LO |
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 */ | |
17f93e1e | 841 | ret = dvb_usb_generic_rw(d, obuf, 5, ibuf, 256, 0); |
af4e067e LO |
842 | if (ret) { |
843 | err("rc query failed"); | |
844 | return ret; | |
845 | } | |
846 | if (ibuf[2] != 0x41) { | |
847 | err("rc query bad header."); | |
848 | return -EIO; | |
849 | } | |
850 | if (ibuf[4] != obuf[4]) { | |
851 | err("rc query bad sequence."); | |
852 | return -EIO; | |
853 | } | |
854 | len = ibuf[5]; | |
855 | if (len > 246) { | |
856 | err("rc query invalid length"); | |
857 | return -EIO; | |
858 | } | |
859 | if (len > 0) { | |
860 | deb_rc("rc data (%d) ", len); | |
861 | debug_dump((ibuf + 6), len, deb_rc); | |
862 | ret = rc_decode(d, &ibuf[6], len, event, state); | |
863 | if (ret) { | |
864 | err("rc_decode failed"); | |
865 | return ret; | |
866 | } else { | |
867 | deb_rc("rc_decode state %x event %x\n", *state, *event); | |
868 | if (*state == REMOTE_KEY_REPEAT) | |
869 | *event = d->last_event; | |
870 | } | |
871 | } | |
872 | return 0; | |
873 | } | |
874 | ||
875 | static int af9005_power_ctrl(struct dvb_usb_device *d, int onoff) | |
876 | { | |
877 | ||
878 | return 0; | |
879 | } | |
880 | ||
881 | static int af9005_pid_filter_control(struct dvb_usb_adapter *adap, int onoff) | |
882 | { | |
883 | int ret; | |
884 | deb_info("pid filter control onoff %d\n", onoff); | |
885 | if (onoff) { | |
886 | ret = | |
887 | af9005_write_ofdm_register(adap->dev, XD_MP2IF_DMX_CTRL, 1); | |
888 | if (ret) | |
889 | return ret; | |
890 | ret = | |
891 | af9005_write_register_bits(adap->dev, | |
892 | XD_MP2IF_DMX_CTRL, 1, 1, 1); | |
893 | if (ret) | |
894 | return ret; | |
895 | ret = | |
896 | af9005_write_ofdm_register(adap->dev, XD_MP2IF_DMX_CTRL, 1); | |
897 | } else | |
898 | ret = | |
899 | af9005_write_ofdm_register(adap->dev, XD_MP2IF_DMX_CTRL, 0); | |
900 | if (ret) | |
901 | return ret; | |
902 | deb_info("pid filter control ok\n"); | |
903 | return 0; | |
904 | } | |
905 | ||
906 | static int af9005_pid_filter(struct dvb_usb_adapter *adap, int index, | |
907 | u16 pid, int onoff) | |
908 | { | |
909 | u8 cmd = index & 0x1f; | |
910 | int ret; | |
911 | deb_info("set pid filter, index %d, pid %x, onoff %d\n", index, | |
912 | pid, onoff); | |
913 | if (onoff) { | |
914 | /* cannot use it as pid_filter_ctrl since it has to be done | |
915 | before setting the first pid */ | |
916 | if (adap->feedcount == 1) { | |
917 | deb_info("first pid set, enable pid table\n"); | |
918 | ret = af9005_pid_filter_control(adap, onoff); | |
919 | if (ret) | |
920 | return ret; | |
921 | } | |
922 | ret = | |
923 | af9005_write_ofdm_register(adap->dev, | |
924 | XD_MP2IF_PID_DATA_L, | |
925 | (u8) (pid & 0xff)); | |
926 | if (ret) | |
927 | return ret; | |
928 | ret = | |
929 | af9005_write_ofdm_register(adap->dev, | |
930 | XD_MP2IF_PID_DATA_H, | |
931 | (u8) (pid >> 8)); | |
932 | if (ret) | |
933 | return ret; | |
934 | cmd |= 0x20 | 0x40; | |
935 | } else { | |
936 | if (adap->feedcount == 0) { | |
937 | deb_info("last pid unset, disable pid table\n"); | |
938 | ret = af9005_pid_filter_control(adap, onoff); | |
939 | if (ret) | |
940 | return ret; | |
941 | } | |
942 | } | |
943 | ret = af9005_write_ofdm_register(adap->dev, XD_MP2IF_PID_IDX, cmd); | |
944 | if (ret) | |
945 | return ret; | |
946 | deb_info("set pid ok\n"); | |
947 | return 0; | |
948 | } | |
949 | ||
950 | static int af9005_identify_state(struct usb_device *udev, | |
951 | struct dvb_usb_device_properties *props, | |
952 | struct dvb_usb_device_description **desc, | |
953 | int *cold) | |
954 | { | |
955 | int ret; | |
956 | u8 reply; | |
957 | ret = af9005_boot_packet(udev, FW_CONFIG, &reply); | |
958 | if (ret) | |
959 | return ret; | |
960 | deb_info("result of FW_CONFIG in identify state %d\n", reply); | |
961 | if (reply == 0x01) | |
962 | *cold = 1; | |
963 | else if (reply == 0x02) | |
964 | *cold = 0; | |
965 | else | |
966 | return -EIO; | |
967 | deb_info("Identify state cold = %d\n", *cold); | |
968 | return 0; | |
969 | } | |
970 | ||
971 | static struct dvb_usb_device_properties af9005_properties; | |
972 | ||
973 | static int af9005_usb_probe(struct usb_interface *intf, | |
974 | const struct usb_device_id *id) | |
975 | { | |
78e92006 JG |
976 | return dvb_usb_device_init(intf, &af9005_properties, |
977 | THIS_MODULE, NULL, adapter_nr); | |
af4e067e LO |
978 | } |
979 | ||
d07b901f JN |
980 | enum af9005_usb_table_entry { |
981 | AFATECH_AF9005, | |
982 | TERRATEC_AF9005, | |
983 | ANSONIC_AF9005, | |
984 | }; | |
985 | ||
af4e067e | 986 | static struct usb_device_id af9005_usb_table[] = { |
d07b901f JN |
987 | [AFATECH_AF9005] = {USB_DEVICE(USB_VID_AFATECH, |
988 | USB_PID_AFATECH_AF9005)}, | |
989 | [TERRATEC_AF9005] = {USB_DEVICE(USB_VID_TERRATEC, | |
990 | USB_PID_TERRATEC_CINERGY_T_USB_XE)}, | |
991 | [ANSONIC_AF9005] = {USB_DEVICE(USB_VID_ANSONIC, | |
992 | USB_PID_ANSONIC_DVBT_USB)}, | |
993 | { } | |
af4e067e LO |
994 | }; |
995 | ||
996 | MODULE_DEVICE_TABLE(usb, af9005_usb_table); | |
997 | ||
998 | static struct dvb_usb_device_properties af9005_properties = { | |
999 | .caps = DVB_USB_IS_AN_I2C_ADAPTER, | |
1000 | ||
1001 | .usb_ctrl = DEVICE_SPECIFIC, | |
1002 | .firmware = "af9005.fw", | |
1003 | .download_firmware = af9005_download_firmware, | |
1004 | .no_reconnect = 1, | |
1005 | ||
1006 | .size_of_priv = sizeof(struct af9005_device_state), | |
1007 | ||
1008 | .num_adapters = 1, | |
1009 | .adapter = { | |
1010 | { | |
77eed219 MK |
1011 | .num_frontends = 1, |
1012 | .fe = {{ | |
af4e067e LO |
1013 | .caps = |
1014 | DVB_USB_ADAP_HAS_PID_FILTER | | |
1015 | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, | |
1016 | .pid_filter_count = 32, | |
1017 | .pid_filter = af9005_pid_filter, | |
1018 | /* .pid_filter_ctrl = af9005_pid_filter_control, */ | |
1019 | .frontend_attach = af9005_frontend_attach, | |
1020 | /* .tuner_attach = af9005_tuner_attach, */ | |
1021 | /* parameter for the MPEG2-data transfer */ | |
1022 | .stream = { | |
1023 | .type = USB_BULK, | |
1024 | .count = 10, | |
1025 | .endpoint = 0x04, | |
1026 | .u = { | |
1027 | .bulk = { | |
1028 | .buffersize = 4096, /* actual size seen is 3948 */ | |
1029 | } | |
1030 | } | |
1031 | }, | |
77eed219 | 1032 | }}, |
af4e067e LO |
1033 | } |
1034 | }, | |
1035 | .power_ctrl = af9005_power_ctrl, | |
1036 | .identify_state = af9005_identify_state, | |
1037 | ||
1038 | .i2c_algo = &af9005_i2c_algo, | |
1039 | ||
f72a27b8 MCC |
1040 | .rc.legacy = { |
1041 | .rc_interval = 200, | |
2f4f58d6 MCC |
1042 | .rc_map_table = NULL, |
1043 | .rc_map_size = 0, | |
f72a27b8 MCC |
1044 | .rc_query = af9005_rc_query, |
1045 | }, | |
af4e067e | 1046 | |
17f93e1e MK |
1047 | .generic_bulk_ctrl_endpoint = 2, |
1048 | .generic_bulk_ctrl_endpoint_response = 1, | |
1049 | ||
8cb93293 | 1050 | .num_device_descs = 3, |
af4e067e LO |
1051 | .devices = { |
1052 | {.name = "Afatech DVB-T USB1.1 stick", | |
d07b901f | 1053 | .cold_ids = {&af9005_usb_table[AFATECH_AF9005], NULL}, |
af4e067e LO |
1054 | .warm_ids = {NULL}, |
1055 | }, | |
1056 | {.name = "TerraTec Cinergy T USB XE", | |
d07b901f | 1057 | .cold_ids = {&af9005_usb_table[TERRATEC_AF9005], NULL}, |
af4e067e LO |
1058 | .warm_ids = {NULL}, |
1059 | }, | |
8cb93293 | 1060 | {.name = "Ansonic DVB-T USB1.1 stick", |
d07b901f | 1061 | .cold_ids = {&af9005_usb_table[ANSONIC_AF9005], NULL}, |
8cb93293 LO |
1062 | .warm_ids = {NULL}, |
1063 | }, | |
af4e067e LO |
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 | } | |
22799487 FS |
1084 | #if IS_MODULE(CONFIG_DVB_USB_AF9005) || defined(CONFIG_DVB_USB_AF9005_REMOTE) |
1085 | /* FIXME: convert to todays kernel IR infrastructure */ | |
af4e067e | 1086 | rc_decode = symbol_request(af9005_rc_decode); |
2f4f58d6 MCC |
1087 | rc_keys = symbol_request(rc_map_af9005_table); |
1088 | rc_keys_size = symbol_request(rc_map_af9005_table_size); | |
22799487 | 1089 | #endif |
af4e067e LO |
1090 | if (rc_decode == NULL || rc_keys == NULL || rc_keys_size == NULL) { |
1091 | err("af9005_rc_decode function not found, disabling remote"); | |
f72a27b8 | 1092 | af9005_properties.rc.legacy.rc_query = NULL; |
af4e067e | 1093 | } else { |
2f4f58d6 MCC |
1094 | af9005_properties.rc.legacy.rc_map_table = rc_keys; |
1095 | af9005_properties.rc.legacy.rc_map_size = *rc_keys_size; | |
af4e067e LO |
1096 | } |
1097 | ||
1098 | return 0; | |
1099 | } | |
1100 | ||
1101 | static void __exit af9005_usb_module_exit(void) | |
1102 | { | |
1103 | /* release rc decode symbols */ | |
1104 | if (rc_decode != NULL) | |
1105 | symbol_put(af9005_rc_decode); | |
1106 | if (rc_keys != NULL) | |
2f4f58d6 | 1107 | symbol_put(rc_map_af9005_table); |
af4e067e | 1108 | if (rc_keys_size != NULL) |
2f4f58d6 | 1109 | symbol_put(rc_map_af9005_table_size); |
af4e067e LO |
1110 | /* deregister this driver from the USB subsystem */ |
1111 | usb_deregister(&af9005_usb_driver); | |
1112 | } | |
1113 | ||
1114 | module_init(af9005_usb_module_init); | |
1115 | module_exit(af9005_usb_module_exit); | |
1116 | ||
1117 | MODULE_AUTHOR("Luca Olivetti <luca@ventoso.org>"); | |
1118 | MODULE_DESCRIPTION("Driver for Afatech 9005 DVB-T USB1.1 stick"); | |
1119 | MODULE_VERSION("1.0"); | |
1120 | MODULE_LICENSE("GPL"); |