1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * Afatech AF9035 DVB USB driver |
4 | * |
5 | * Copyright (C) 2009 Antti Palosaari <crope@iki.fi> |
6 | * Copyright (C) 2012 Antti Palosaari <crope@iki.fi> |
7 | */ |
8 | |
9 | #include "af9035.h" |
10 | |
11 | /* Max transfer size done by I2C transfer functions */ |
12 | #define MAX_XFER_SIZE 64 |
13 | |
14 | DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); |
15 | |
16 | static u16 af9035_checksum(const u8 *buf, size_t len) |
17 | { |
18 | size_t i; |
19 | u16 checksum = 0; |
20 | |
21 | for (i = 1; i < len; i++) { |
22 | if (i % 2) |
23 | checksum += buf[i] << 8; |
24 | else |
25 | checksum += buf[i]; |
26 | } |
27 | checksum = ~checksum; |
28 | |
29 | return checksum; |
30 | } |
31 | |
32 | static int af9035_ctrl_msg(struct dvb_usb_device *d, struct usb_req *req) |
33 | { |
34 | #define REQ_HDR_LEN 4 /* send header size */ |
35 | #define ACK_HDR_LEN 3 /* rece header size */ |
36 | #define CHECKSUM_LEN 2 |
37 | #define USB_TIMEOUT 2000 |
38 | struct state *state = d_to_priv(d); |
39 | struct usb_interface *intf = d->intf; |
40 | int ret, wlen, rlen; |
41 | u16 checksum, tmp_checksum; |
42 | |
43 | mutex_lock(&d->usb_mutex); |
44 | |
45 | /* buffer overflow check */ |
46 | if (req->wlen > (BUF_LEN - REQ_HDR_LEN - CHECKSUM_LEN) || |
47 | req->rlen > (BUF_LEN - ACK_HDR_LEN - CHECKSUM_LEN)) { |
48 | dev_err(&intf->dev, "too much data wlen=%d rlen=%d\n" , |
49 | req->wlen, req->rlen); |
50 | ret = -EINVAL; |
51 | goto exit; |
52 | } |
53 | |
54 | state->buf[0] = REQ_HDR_LEN + req->wlen + CHECKSUM_LEN - 1; |
55 | state->buf[1] = req->mbox; |
56 | state->buf[2] = req->cmd; |
57 | state->buf[3] = state->seq++; |
58 | memcpy(&state->buf[REQ_HDR_LEN], req->wbuf, req->wlen); |
59 | |
60 | wlen = REQ_HDR_LEN + req->wlen + CHECKSUM_LEN; |
61 | rlen = ACK_HDR_LEN + req->rlen + CHECKSUM_LEN; |
62 | |
63 | /* calc and add checksum */ |
64 | checksum = af9035_checksum(buf: state->buf, len: state->buf[0] - 1); |
65 | state->buf[state->buf[0] - 1] = (checksum >> 8); |
66 | state->buf[state->buf[0] - 0] = (checksum & 0xff); |
67 | |
68 | /* no ack for these packets */ |
69 | if (req->cmd == CMD_FW_DL) |
70 | rlen = 0; |
71 | |
72 | ret = dvb_usbv2_generic_rw_locked(d, |
73 | state->buf, wlen, state->buf, rlen); |
74 | if (ret) |
75 | goto exit; |
76 | |
77 | /* no ack for those packets */ |
78 | if (req->cmd == CMD_FW_DL) |
79 | goto exit; |
80 | |
81 | /* verify checksum */ |
82 | checksum = af9035_checksum(buf: state->buf, len: rlen - 2); |
83 | tmp_checksum = (state->buf[rlen - 2] << 8) | state->buf[rlen - 1]; |
84 | if (tmp_checksum != checksum) { |
85 | dev_err(&intf->dev, "command=%02x checksum mismatch (%04x != %04x)\n" , |
86 | req->cmd, tmp_checksum, checksum); |
87 | ret = -EIO; |
88 | goto exit; |
89 | } |
90 | |
91 | /* check status */ |
92 | if (state->buf[2]) { |
93 | /* fw returns status 1 when IR code was not received */ |
94 | if (req->cmd == CMD_IR_GET || state->buf[2] == 1) { |
95 | ret = 1; |
96 | goto exit; |
97 | } |
98 | |
99 | dev_dbg(&intf->dev, "command=%02x failed fw error=%d\n" , |
100 | req->cmd, state->buf[2]); |
101 | ret = -EIO; |
102 | goto exit; |
103 | } |
104 | |
105 | /* read request, copy returned data to return buf */ |
106 | if (req->rlen) |
107 | memcpy(req->rbuf, &state->buf[ACK_HDR_LEN], req->rlen); |
108 | exit: |
109 | mutex_unlock(lock: &d->usb_mutex); |
110 | return ret; |
111 | } |
112 | |
113 | /* write multiple registers */ |
114 | static int af9035_wr_regs(struct dvb_usb_device *d, u32 reg, u8 *val, int len) |
115 | { |
116 | struct usb_interface *intf = d->intf; |
117 | u8 wbuf[MAX_XFER_SIZE]; |
118 | u8 mbox = (reg >> 16) & 0xff; |
119 | struct usb_req req = { CMD_MEM_WR, mbox, 6 + len, wbuf, 0, NULL }; |
120 | |
121 | if (6 + len > sizeof(wbuf)) { |
122 | dev_warn(&intf->dev, "i2c wr: len=%d is too big!\n" , len); |
123 | return -EOPNOTSUPP; |
124 | } |
125 | |
126 | wbuf[0] = len; |
127 | wbuf[1] = 2; |
128 | wbuf[2] = 0; |
129 | wbuf[3] = 0; |
130 | wbuf[4] = (reg >> 8) & 0xff; |
131 | wbuf[5] = (reg >> 0) & 0xff; |
132 | memcpy(&wbuf[6], val, len); |
133 | |
134 | return af9035_ctrl_msg(d, req: &req); |
135 | } |
136 | |
137 | /* read multiple registers */ |
138 | static int af9035_rd_regs(struct dvb_usb_device *d, u32 reg, u8 *val, int len) |
139 | { |
140 | u8 wbuf[] = { len, 2, 0, 0, (reg >> 8) & 0xff, reg & 0xff }; |
141 | u8 mbox = (reg >> 16) & 0xff; |
142 | struct usb_req req = { CMD_MEM_RD, mbox, sizeof(wbuf), wbuf, len, val }; |
143 | |
144 | return af9035_ctrl_msg(d, req: &req); |
145 | } |
146 | |
147 | /* write single register */ |
148 | static int af9035_wr_reg(struct dvb_usb_device *d, u32 reg, u8 val) |
149 | { |
150 | return af9035_wr_regs(d, reg, val: &val, len: 1); |
151 | } |
152 | |
153 | /* read single register */ |
154 | static int af9035_rd_reg(struct dvb_usb_device *d, u32 reg, u8 *val) |
155 | { |
156 | return af9035_rd_regs(d, reg, val, len: 1); |
157 | } |
158 | |
159 | /* write single register with mask */ |
160 | static int af9035_wr_reg_mask(struct dvb_usb_device *d, u32 reg, u8 val, |
161 | u8 mask) |
162 | { |
163 | int ret; |
164 | u8 tmp; |
165 | |
166 | /* no need for read if whole reg is written */ |
167 | if (mask != 0xff) { |
168 | ret = af9035_rd_regs(d, reg, val: &tmp, len: 1); |
169 | if (ret) |
170 | return ret; |
171 | |
172 | val &= mask; |
173 | tmp &= ~mask; |
174 | val |= tmp; |
175 | } |
176 | |
177 | return af9035_wr_regs(d, reg, val: &val, len: 1); |
178 | } |
179 | |
180 | static int af9035_add_i2c_dev(struct dvb_usb_device *d, const char *type, |
181 | u8 addr, void *platform_data, struct i2c_adapter *adapter) |
182 | { |
183 | int ret, num; |
184 | struct state *state = d_to_priv(d); |
185 | struct usb_interface *intf = d->intf; |
186 | struct i2c_client *client; |
187 | struct i2c_board_info board_info = { |
188 | .addr = addr, |
189 | .platform_data = platform_data, |
190 | }; |
191 | |
192 | strscpy(board_info.type, type, I2C_NAME_SIZE); |
193 | |
194 | /* find first free client */ |
195 | for (num = 0; num < AF9035_I2C_CLIENT_MAX; num++) { |
196 | if (state->i2c_client[num] == NULL) |
197 | break; |
198 | } |
199 | |
200 | dev_dbg(&intf->dev, "num=%d\n" , num); |
201 | |
202 | if (num == AF9035_I2C_CLIENT_MAX) { |
203 | dev_err(&intf->dev, "I2C client out of index\n" ); |
204 | ret = -ENODEV; |
205 | goto err; |
206 | } |
207 | |
208 | request_module("%s" , board_info.type); |
209 | |
210 | /* register I2C device */ |
211 | client = i2c_new_client_device(adap: adapter, info: &board_info); |
212 | if (!i2c_client_has_driver(client)) { |
213 | dev_err(&intf->dev, "failed to bind i2c device to %s driver\n" , type); |
214 | ret = -ENODEV; |
215 | goto err; |
216 | } |
217 | |
218 | /* increase I2C driver usage count */ |
219 | if (!try_module_get(module: client->dev.driver->owner)) { |
220 | i2c_unregister_device(client); |
221 | ret = -ENODEV; |
222 | goto err; |
223 | } |
224 | |
225 | state->i2c_client[num] = client; |
226 | return 0; |
227 | err: |
228 | dev_dbg(&intf->dev, "failed=%d\n" , ret); |
229 | return ret; |
230 | } |
231 | |
232 | static void af9035_del_i2c_dev(struct dvb_usb_device *d) |
233 | { |
234 | int num; |
235 | struct state *state = d_to_priv(d); |
236 | struct usb_interface *intf = d->intf; |
237 | struct i2c_client *client; |
238 | |
239 | /* find last used client */ |
240 | num = AF9035_I2C_CLIENT_MAX; |
241 | while (num--) { |
242 | if (state->i2c_client[num] != NULL) |
243 | break; |
244 | } |
245 | |
246 | dev_dbg(&intf->dev, "num=%d\n" , num); |
247 | |
248 | if (num == -1) { |
249 | dev_err(&intf->dev, "I2C client out of index\n" ); |
250 | goto err; |
251 | } |
252 | |
253 | client = state->i2c_client[num]; |
254 | |
255 | /* decrease I2C driver usage count */ |
256 | module_put(module: client->dev.driver->owner); |
257 | |
258 | /* unregister I2C device */ |
259 | i2c_unregister_device(client); |
260 | |
261 | state->i2c_client[num] = NULL; |
262 | return; |
263 | err: |
264 | dev_dbg(&intf->dev, "failed\n" ); |
265 | } |
266 | |
267 | static int af9035_i2c_master_xfer(struct i2c_adapter *adap, |
268 | struct i2c_msg msg[], int num) |
269 | { |
270 | struct dvb_usb_device *d = i2c_get_adapdata(adap); |
271 | struct state *state = d_to_priv(d); |
272 | int ret; |
273 | |
274 | if (mutex_lock_interruptible(&d->i2c_mutex) < 0) |
275 | return -EAGAIN; |
276 | |
277 | /* |
278 | * AF9035 I2C sub header is 5 bytes long. Meaning of those bytes are: |
279 | * 0: data len |
280 | * 1: I2C addr << 1 |
281 | * 2: reg addr len |
282 | * byte 3 and 4 can be used as reg addr |
283 | * 3: reg addr MSB |
284 | * used when reg addr len is set to 2 |
285 | * 4: reg addr LSB |
286 | * used when reg addr len is set to 1 or 2 |
287 | * |
288 | * For the simplify we do not use register addr at all. |
289 | * NOTE: As a firmware knows tuner type there is very small possibility |
290 | * there could be some tuner I2C hacks done by firmware and this may |
291 | * lead problems if firmware expects those bytes are used. |
292 | * |
293 | * TODO: Here is few hacks. AF9035 chip integrates AF9033 demodulator. |
294 | * IT9135 chip integrates AF9033 demodulator and RF tuner. For dual |
295 | * tuner devices, there is also external AF9033 demodulator connected |
296 | * via external I2C bus. All AF9033 demod I2C traffic, both single and |
297 | * dual tuner configuration, is covered by firmware - actual USB IO |
298 | * looks just like a memory access. |
299 | * In case of IT913x chip, there is own tuner driver. It is implemented |
300 | * currently as a I2C driver, even tuner IP block is likely build |
301 | * directly into the demodulator memory space and there is no own I2C |
302 | * bus. I2C subsystem does not allow register multiple devices to same |
303 | * bus, having same slave address. Due to that we reuse demod address, |
304 | * shifted by one bit, on that case. |
305 | * |
306 | * For IT930x we use a different command and the sub header is |
307 | * different as well: |
308 | * 0: data len |
309 | * 1: I2C bus (0x03 seems to be only value used) |
310 | * 2: I2C addr << 1 |
311 | */ |
312 | #define AF9035_IS_I2C_XFER_WRITE_READ(_msg, _num) \ |
313 | (_num == 2 && !(_msg[0].flags & I2C_M_RD) && (_msg[1].flags & I2C_M_RD)) |
314 | #define AF9035_IS_I2C_XFER_WRITE(_msg, _num) \ |
315 | (_num == 1 && !(_msg[0].flags & I2C_M_RD)) |
316 | #define AF9035_IS_I2C_XFER_READ(_msg, _num) \ |
317 | (_num == 1 && (_msg[0].flags & I2C_M_RD)) |
318 | |
319 | if (AF9035_IS_I2C_XFER_WRITE_READ(msg, num)) { |
320 | if (msg[0].len > 40 || msg[1].len > 40) { |
321 | /* TODO: correct limits > 40 */ |
322 | ret = -EOPNOTSUPP; |
323 | } else if ((msg[0].addr == state->af9033_i2c_addr[0]) || |
324 | (msg[0].addr == state->af9033_i2c_addr[1])) { |
325 | if (msg[0].len < 3 || msg[1].len < 1) { |
326 | ret = -EOPNOTSUPP; |
327 | goto unlock; |
328 | } |
329 | /* demod access via firmware interface */ |
330 | u32 reg = msg[0].buf[0] << 16 | msg[0].buf[1] << 8 | |
331 | msg[0].buf[2]; |
332 | |
333 | if (msg[0].addr == state->af9033_i2c_addr[1]) |
334 | reg |= 0x100000; |
335 | |
336 | ret = af9035_rd_regs(d, reg, val: &msg[1].buf[0], |
337 | len: msg[1].len); |
338 | } else if (state->no_read) { |
339 | memset(msg[1].buf, 0, msg[1].len); |
340 | ret = 0; |
341 | } else { |
342 | /* I2C write + read */ |
343 | u8 buf[MAX_XFER_SIZE]; |
344 | struct usb_req req = { CMD_I2C_RD, 0, 5 + msg[0].len, |
345 | buf, msg[1].len, msg[1].buf }; |
346 | |
347 | if (state->chip_type == 0x9306) { |
348 | req.cmd = CMD_GENERIC_I2C_RD; |
349 | req.wlen = 3 + msg[0].len; |
350 | } |
351 | req.mbox |= ((msg[0].addr & 0x80) >> 3); |
352 | |
353 | buf[0] = msg[1].len; |
354 | if (state->chip_type == 0x9306) { |
355 | buf[1] = 0x03; /* I2C bus */ |
356 | buf[2] = msg[0].addr << 1; |
357 | memcpy(&buf[3], msg[0].buf, msg[0].len); |
358 | } else { |
359 | buf[1] = msg[0].addr << 1; |
360 | buf[3] = 0x00; /* reg addr MSB */ |
361 | buf[4] = 0x00; /* reg addr LSB */ |
362 | |
363 | /* Keep prev behavior for write req len > 2*/ |
364 | if (msg[0].len > 2) { |
365 | buf[2] = 0x00; /* reg addr len */ |
366 | memcpy(&buf[5], msg[0].buf, msg[0].len); |
367 | |
368 | /* Use reg addr fields if write req len <= 2 */ |
369 | } else { |
370 | req.wlen = 5; |
371 | buf[2] = msg[0].len; |
372 | if (msg[0].len == 2) { |
373 | buf[3] = msg[0].buf[0]; |
374 | buf[4] = msg[0].buf[1]; |
375 | } else if (msg[0].len == 1) { |
376 | buf[4] = msg[0].buf[0]; |
377 | } |
378 | } |
379 | } |
380 | ret = af9035_ctrl_msg(d, req: &req); |
381 | } |
382 | } else if (AF9035_IS_I2C_XFER_WRITE(msg, num)) { |
383 | if (msg[0].len > 40) { |
384 | /* TODO: correct limits > 40 */ |
385 | ret = -EOPNOTSUPP; |
386 | } else if ((msg[0].addr == state->af9033_i2c_addr[0]) || |
387 | (msg[0].addr == state->af9033_i2c_addr[1])) { |
388 | if (msg[0].len < 3) { |
389 | ret = -EOPNOTSUPP; |
390 | goto unlock; |
391 | } |
392 | /* demod access via firmware interface */ |
393 | u32 reg = msg[0].buf[0] << 16 | msg[0].buf[1] << 8 | |
394 | msg[0].buf[2]; |
395 | |
396 | if (msg[0].addr == state->af9033_i2c_addr[1]) |
397 | reg |= 0x100000; |
398 | |
399 | ret = af9035_wr_regs(d, reg, val: &msg[0].buf[3], len: msg[0].len - 3); |
400 | } else { |
401 | /* I2C write */ |
402 | u8 buf[MAX_XFER_SIZE]; |
403 | struct usb_req req = { CMD_I2C_WR, 0, 5 + msg[0].len, |
404 | buf, 0, NULL }; |
405 | |
406 | if (state->chip_type == 0x9306) { |
407 | req.cmd = CMD_GENERIC_I2C_WR; |
408 | req.wlen = 3 + msg[0].len; |
409 | } |
410 | |
411 | req.mbox |= ((msg[0].addr & 0x80) >> 3); |
412 | buf[0] = msg[0].len; |
413 | if (state->chip_type == 0x9306) { |
414 | buf[1] = 0x03; /* I2C bus */ |
415 | buf[2] = msg[0].addr << 1; |
416 | memcpy(&buf[3], msg[0].buf, msg[0].len); |
417 | } else { |
418 | buf[1] = msg[0].addr << 1; |
419 | buf[2] = 0x00; /* reg addr len */ |
420 | buf[3] = 0x00; /* reg addr MSB */ |
421 | buf[4] = 0x00; /* reg addr LSB */ |
422 | memcpy(&buf[5], msg[0].buf, msg[0].len); |
423 | } |
424 | ret = af9035_ctrl_msg(d, req: &req); |
425 | } |
426 | } else if (AF9035_IS_I2C_XFER_READ(msg, num)) { |
427 | if (msg[0].len > 40) { |
428 | /* TODO: correct limits > 40 */ |
429 | ret = -EOPNOTSUPP; |
430 | } else if (state->no_read) { |
431 | memset(msg[0].buf, 0, msg[0].len); |
432 | ret = 0; |
433 | } else { |
434 | /* I2C read */ |
435 | u8 buf[5]; |
436 | struct usb_req req = { CMD_I2C_RD, 0, sizeof(buf), |
437 | buf, msg[0].len, msg[0].buf }; |
438 | |
439 | if (state->chip_type == 0x9306) { |
440 | req.cmd = CMD_GENERIC_I2C_RD; |
441 | req.wlen = 3; |
442 | } |
443 | req.mbox |= ((msg[0].addr & 0x80) >> 3); |
444 | buf[0] = msg[0].len; |
445 | if (state->chip_type == 0x9306) { |
446 | buf[1] = 0x03; /* I2C bus */ |
447 | buf[2] = msg[0].addr << 1; |
448 | } else { |
449 | buf[1] = msg[0].addr << 1; |
450 | buf[2] = 0x00; /* reg addr len */ |
451 | buf[3] = 0x00; /* reg addr MSB */ |
452 | buf[4] = 0x00; /* reg addr LSB */ |
453 | } |
454 | ret = af9035_ctrl_msg(d, req: &req); |
455 | } |
456 | } else { |
457 | /* |
458 | * We support only three kind of I2C transactions: |
459 | * 1) 1 x write + 1 x read (repeated start) |
460 | * 2) 1 x write |
461 | * 3) 1 x read |
462 | */ |
463 | ret = -EOPNOTSUPP; |
464 | } |
465 | |
466 | unlock: |
467 | mutex_unlock(lock: &d->i2c_mutex); |
468 | |
469 | if (ret < 0) |
470 | return ret; |
471 | else |
472 | return num; |
473 | } |
474 | |
475 | static u32 af9035_i2c_functionality(struct i2c_adapter *adapter) |
476 | { |
477 | return I2C_FUNC_I2C; |
478 | } |
479 | |
480 | static struct i2c_algorithm af9035_i2c_algo = { |
481 | .master_xfer = af9035_i2c_master_xfer, |
482 | .functionality = af9035_i2c_functionality, |
483 | }; |
484 | |
485 | static int af9035_identify_state(struct dvb_usb_device *d, const char **name) |
486 | { |
487 | struct state *state = d_to_priv(d); |
488 | struct usb_interface *intf = d->intf; |
489 | int ret, i, ts_mode_invalid; |
490 | unsigned int utmp, eeprom_addr; |
491 | u8 tmp; |
492 | u8 wbuf[1] = { 1 }; |
493 | u8 rbuf[4]; |
494 | struct usb_req req = { CMD_FW_QUERYINFO, 0, sizeof(wbuf), wbuf, |
495 | sizeof(rbuf), rbuf }; |
496 | |
497 | ret = af9035_rd_regs(d, reg: 0x1222, val: rbuf, len: 3); |
498 | if (ret < 0) |
499 | goto err; |
500 | |
501 | state->chip_version = rbuf[0]; |
502 | state->chip_type = rbuf[2] << 8 | rbuf[1] << 0; |
503 | |
504 | ret = af9035_rd_reg(d, reg: 0x384f, val: &state->prechip_version); |
505 | if (ret < 0) |
506 | goto err; |
507 | |
508 | dev_info(&intf->dev, "prechip_version=%02x chip_version=%02x chip_type=%04x\n" , |
509 | state->prechip_version, state->chip_version, state->chip_type); |
510 | |
511 | if (state->chip_type == 0x9135) { |
512 | if (state->chip_version == 0x02) { |
513 | *name = AF9035_FIRMWARE_IT9135_V2; |
514 | utmp = 0x00461d; |
515 | } else { |
516 | *name = AF9035_FIRMWARE_IT9135_V1; |
517 | utmp = 0x00461b; |
518 | } |
519 | |
520 | /* Check if eeprom exists */ |
521 | ret = af9035_rd_reg(d, reg: utmp, val: &tmp); |
522 | if (ret < 0) |
523 | goto err; |
524 | |
525 | if (tmp == 0x00) { |
526 | dev_dbg(&intf->dev, "no eeprom\n" ); |
527 | state->no_eeprom = true; |
528 | goto check_firmware_status; |
529 | } |
530 | |
531 | eeprom_addr = EEPROM_BASE_IT9135; |
532 | } else if (state->chip_type == 0x9306) { |
533 | *name = AF9035_FIRMWARE_IT9303; |
534 | state->no_eeprom = true; |
535 | goto check_firmware_status; |
536 | } else { |
537 | *name = AF9035_FIRMWARE_AF9035; |
538 | eeprom_addr = EEPROM_BASE_AF9035; |
539 | } |
540 | |
541 | /* Read and store eeprom */ |
542 | for (i = 0; i < 256; i += 32) { |
543 | ret = af9035_rd_regs(d, reg: eeprom_addr + i, val: &state->eeprom[i], len: 32); |
544 | if (ret < 0) |
545 | goto err; |
546 | } |
547 | |
548 | dev_dbg(&intf->dev, "eeprom dump:\n" ); |
549 | for (i = 0; i < 256; i += 16) |
550 | dev_dbg(&intf->dev, "%*ph\n" , 16, &state->eeprom[i]); |
551 | |
552 | /* check for dual tuner mode */ |
553 | tmp = state->eeprom[EEPROM_TS_MODE]; |
554 | ts_mode_invalid = 0; |
555 | switch (tmp) { |
556 | case 0: |
557 | break; |
558 | case 1: |
559 | case 3: |
560 | state->dual_mode = true; |
561 | break; |
562 | case 5: |
563 | if (state->chip_type != 0x9135 && state->chip_type != 0x9306) |
564 | state->dual_mode = true; /* AF9035 */ |
565 | else |
566 | ts_mode_invalid = 1; |
567 | break; |
568 | default: |
569 | ts_mode_invalid = 1; |
570 | } |
571 | |
572 | dev_dbg(&intf->dev, "ts mode=%d dual mode=%d\n" , tmp, state->dual_mode); |
573 | |
574 | if (ts_mode_invalid) |
575 | dev_info(&intf->dev, "ts mode=%d not supported, defaulting to single tuner mode!" , tmp); |
576 | |
577 | check_firmware_status: |
578 | ret = af9035_ctrl_msg(d, req: &req); |
579 | if (ret < 0) |
580 | goto err; |
581 | |
582 | dev_dbg(&intf->dev, "reply=%*ph\n" , 4, rbuf); |
583 | if (rbuf[0] || rbuf[1] || rbuf[2] || rbuf[3]) |
584 | ret = WARM; |
585 | else |
586 | ret = COLD; |
587 | |
588 | return ret; |
589 | |
590 | err: |
591 | dev_dbg(&intf->dev, "failed=%d\n" , ret); |
592 | |
593 | return ret; |
594 | } |
595 | |
596 | static int af9035_download_firmware_old(struct dvb_usb_device *d, |
597 | const struct firmware *fw) |
598 | { |
599 | struct usb_interface *intf = d->intf; |
600 | int ret, i, j, len; |
601 | u8 wbuf[1]; |
602 | struct usb_req req = { 0, 0, 0, NULL, 0, NULL }; |
603 | struct usb_req req_fw_dl = { CMD_FW_DL, 0, 0, wbuf, 0, NULL }; |
604 | u8 hdr_core; |
605 | u16 hdr_addr, hdr_data_len, hdr_checksum; |
606 | #define MAX_DATA 58 |
607 | #define HDR_SIZE 7 |
608 | |
609 | /* |
610 | * Thanks to Daniel Glöckner <daniel-gl@gmx.net> about that info! |
611 | * |
612 | * byte 0: MCS 51 core |
613 | * There are two inside the AF9035 (1=Link and 2=OFDM) with separate |
614 | * address spaces |
615 | * byte 1-2: Big endian destination address |
616 | * byte 3-4: Big endian number of data bytes following the header |
617 | * byte 5-6: Big endian header checksum, apparently ignored by the chip |
618 | * Calculated as ~(h[0]*256+h[1]+h[2]*256+h[3]+h[4]*256) |
619 | */ |
620 | |
621 | for (i = fw->size; i > HDR_SIZE;) { |
622 | hdr_core = fw->data[fw->size - i + 0]; |
623 | hdr_addr = fw->data[fw->size - i + 1] << 8; |
624 | hdr_addr |= fw->data[fw->size - i + 2] << 0; |
625 | hdr_data_len = fw->data[fw->size - i + 3] << 8; |
626 | hdr_data_len |= fw->data[fw->size - i + 4] << 0; |
627 | hdr_checksum = fw->data[fw->size - i + 5] << 8; |
628 | hdr_checksum |= fw->data[fw->size - i + 6] << 0; |
629 | |
630 | dev_dbg(&intf->dev, "core=%d addr=%04x data_len=%d checksum=%04x\n" , |
631 | hdr_core, hdr_addr, hdr_data_len, hdr_checksum); |
632 | |
633 | if (((hdr_core != 1) && (hdr_core != 2)) || |
634 | (hdr_data_len > i)) { |
635 | dev_dbg(&intf->dev, "bad firmware\n" ); |
636 | break; |
637 | } |
638 | |
639 | /* download begin packet */ |
640 | req.cmd = CMD_FW_DL_BEGIN; |
641 | ret = af9035_ctrl_msg(d, req: &req); |
642 | if (ret < 0) |
643 | goto err; |
644 | |
645 | /* download firmware packet(s) */ |
646 | for (j = HDR_SIZE + hdr_data_len; j > 0; j -= MAX_DATA) { |
647 | len = j; |
648 | if (len > MAX_DATA) |
649 | len = MAX_DATA; |
650 | req_fw_dl.wlen = len; |
651 | req_fw_dl.wbuf = (u8 *) &fw->data[fw->size - i + |
652 | HDR_SIZE + hdr_data_len - j]; |
653 | ret = af9035_ctrl_msg(d, req: &req_fw_dl); |
654 | if (ret < 0) |
655 | goto err; |
656 | } |
657 | |
658 | /* download end packet */ |
659 | req.cmd = CMD_FW_DL_END; |
660 | ret = af9035_ctrl_msg(d, req: &req); |
661 | if (ret < 0) |
662 | goto err; |
663 | |
664 | i -= hdr_data_len + HDR_SIZE; |
665 | |
666 | dev_dbg(&intf->dev, "data uploaded=%zu\n" , fw->size - i); |
667 | } |
668 | |
669 | /* print warn if firmware is bad, continue and see what happens */ |
670 | if (i) |
671 | dev_warn(&intf->dev, "bad firmware\n" ); |
672 | |
673 | return 0; |
674 | |
675 | err: |
676 | dev_dbg(&intf->dev, "failed=%d\n" , ret); |
677 | |
678 | return ret; |
679 | } |
680 | |
681 | static int af9035_download_firmware_new(struct dvb_usb_device *d, |
682 | const struct firmware *fw) |
683 | { |
684 | struct usb_interface *intf = d->intf; |
685 | int ret, i, i_prev; |
686 | struct usb_req req_fw_dl = { CMD_FW_SCATTER_WR, 0, 0, NULL, 0, NULL }; |
687 | #define HDR_SIZE 7 |
688 | |
689 | /* |
690 | * There seems to be following firmware header. Meaning of bytes 0-3 |
691 | * is unknown. |
692 | * |
693 | * 0: 3 |
694 | * 1: 0, 1 |
695 | * 2: 0 |
696 | * 3: 1, 2, 3 |
697 | * 4: addr MSB |
698 | * 5: addr LSB |
699 | * 6: count of data bytes ? |
700 | */ |
701 | for (i = HDR_SIZE, i_prev = 0; i <= fw->size; i++) { |
702 | if (i == fw->size || |
703 | (fw->data[i + 0] == 0x03 && |
704 | (fw->data[i + 1] == 0x00 || |
705 | fw->data[i + 1] == 0x01) && |
706 | fw->data[i + 2] == 0x00)) { |
707 | req_fw_dl.wlen = i - i_prev; |
708 | req_fw_dl.wbuf = (u8 *) &fw->data[i_prev]; |
709 | i_prev = i; |
710 | ret = af9035_ctrl_msg(d, req: &req_fw_dl); |
711 | if (ret < 0) |
712 | goto err; |
713 | |
714 | dev_dbg(&intf->dev, "data uploaded=%d\n" , i); |
715 | } |
716 | } |
717 | |
718 | return 0; |
719 | |
720 | err: |
721 | dev_dbg(&intf->dev, "failed=%d\n" , ret); |
722 | |
723 | return ret; |
724 | } |
725 | |
726 | static int af9035_download_firmware(struct dvb_usb_device *d, |
727 | const struct firmware *fw) |
728 | { |
729 | struct usb_interface *intf = d->intf; |
730 | struct state *state = d_to_priv(d); |
731 | int ret; |
732 | u8 wbuf[1]; |
733 | u8 rbuf[4]; |
734 | u8 tmp; |
735 | struct usb_req req = { 0, 0, 0, NULL, 0, NULL }; |
736 | struct usb_req req_fw_ver = { CMD_FW_QUERYINFO, 0, 1, wbuf, 4, rbuf }; |
737 | |
738 | dev_dbg(&intf->dev, "\n" ); |
739 | |
740 | /* |
741 | * In case of dual tuner configuration we need to do some extra |
742 | * initialization in order to download firmware to slave demod too, |
743 | * which is done by master demod. |
744 | * Master feeds also clock and controls power via GPIO. |
745 | */ |
746 | if (state->dual_mode) { |
747 | /* configure gpioh1, reset & power slave demod */ |
748 | ret = af9035_wr_reg_mask(d, reg: 0x00d8b0, val: 0x01, mask: 0x01); |
749 | if (ret < 0) |
750 | goto err; |
751 | |
752 | ret = af9035_wr_reg_mask(d, reg: 0x00d8b1, val: 0x01, mask: 0x01); |
753 | if (ret < 0) |
754 | goto err; |
755 | |
756 | ret = af9035_wr_reg_mask(d, reg: 0x00d8af, val: 0x00, mask: 0x01); |
757 | if (ret < 0) |
758 | goto err; |
759 | |
760 | usleep_range(min: 10000, max: 50000); |
761 | |
762 | ret = af9035_wr_reg_mask(d, reg: 0x00d8af, val: 0x01, mask: 0x01); |
763 | if (ret < 0) |
764 | goto err; |
765 | |
766 | /* tell the slave I2C address */ |
767 | tmp = state->eeprom[EEPROM_2ND_DEMOD_ADDR]; |
768 | |
769 | /* Use default I2C address if eeprom has no address set */ |
770 | if (!tmp) |
771 | tmp = 0x1d << 1; /* 8-bit format used by chip */ |
772 | |
773 | if ((state->chip_type == 0x9135) || |
774 | (state->chip_type == 0x9306)) { |
775 | ret = af9035_wr_reg(d, reg: 0x004bfb, val: tmp); |
776 | if (ret < 0) |
777 | goto err; |
778 | } else { |
779 | ret = af9035_wr_reg(d, reg: 0x00417f, val: tmp); |
780 | if (ret < 0) |
781 | goto err; |
782 | |
783 | /* enable clock out */ |
784 | ret = af9035_wr_reg_mask(d, reg: 0x00d81a, val: 0x01, mask: 0x01); |
785 | if (ret < 0) |
786 | goto err; |
787 | } |
788 | } |
789 | |
790 | if (fw->data[0] == 0x01) |
791 | ret = af9035_download_firmware_old(d, fw); |
792 | else |
793 | ret = af9035_download_firmware_new(d, fw); |
794 | if (ret < 0) |
795 | goto err; |
796 | |
797 | /* firmware loaded, request boot */ |
798 | req.cmd = CMD_FW_BOOT; |
799 | ret = af9035_ctrl_msg(d, req: &req); |
800 | if (ret < 0) |
801 | goto err; |
802 | |
803 | /* ensure firmware starts */ |
804 | wbuf[0] = 1; |
805 | ret = af9035_ctrl_msg(d, req: &req_fw_ver); |
806 | if (ret < 0) |
807 | goto err; |
808 | |
809 | if (!(rbuf[0] || rbuf[1] || rbuf[2] || rbuf[3])) { |
810 | dev_err(&intf->dev, "firmware did not run\n" ); |
811 | ret = -ENODEV; |
812 | goto err; |
813 | } |
814 | |
815 | dev_info(&intf->dev, "firmware version=%d.%d.%d.%d" , |
816 | rbuf[0], rbuf[1], rbuf[2], rbuf[3]); |
817 | |
818 | return 0; |
819 | |
820 | err: |
821 | dev_dbg(&intf->dev, "failed=%d\n" , ret); |
822 | |
823 | return ret; |
824 | } |
825 | |
826 | static int af9035_read_config(struct dvb_usb_device *d) |
827 | { |
828 | struct usb_interface *intf = d->intf; |
829 | struct state *state = d_to_priv(d); |
830 | int ret, i; |
831 | u8 tmp; |
832 | u16 tmp16; |
833 | |
834 | /* Demod I2C address */ |
835 | state->af9033_i2c_addr[0] = 0x1c; |
836 | state->af9033_i2c_addr[1] = 0x1d; |
837 | state->af9033_config[0].adc_multiplier = AF9033_ADC_MULTIPLIER_2X; |
838 | state->af9033_config[1].adc_multiplier = AF9033_ADC_MULTIPLIER_2X; |
839 | state->af9033_config[0].ts_mode = AF9033_TS_MODE_USB; |
840 | state->af9033_config[1].ts_mode = AF9033_TS_MODE_SERIAL; |
841 | state->it930x_addresses = 0; |
842 | |
843 | if (state->chip_type == 0x9135) { |
844 | /* feed clock for integrated RF tuner */ |
845 | state->af9033_config[0].dyn0_clk = true; |
846 | state->af9033_config[1].dyn0_clk = true; |
847 | |
848 | if (state->chip_version == 0x02) { |
849 | state->af9033_config[0].tuner = AF9033_TUNER_IT9135_60; |
850 | state->af9033_config[1].tuner = AF9033_TUNER_IT9135_60; |
851 | } else { |
852 | state->af9033_config[0].tuner = AF9033_TUNER_IT9135_38; |
853 | state->af9033_config[1].tuner = AF9033_TUNER_IT9135_38; |
854 | } |
855 | |
856 | if (state->no_eeprom) { |
857 | /* Remote controller to NEC polling by default */ |
858 | state->ir_mode = 0x05; |
859 | state->ir_type = 0x00; |
860 | |
861 | goto skip_eeprom; |
862 | } |
863 | } else if (state->chip_type == 0x9306) { |
864 | /* |
865 | * IT930x is an USB bridge, only single demod-single tuner |
866 | * configurations seen so far. |
867 | */ |
868 | if ((le16_to_cpu(d->udev->descriptor.idVendor) == USB_VID_AVERMEDIA) && |
869 | (le16_to_cpu(d->udev->descriptor.idProduct) == USB_PID_AVERMEDIA_TD310)) { |
870 | state->it930x_addresses = 1; |
871 | } |
872 | return 0; |
873 | } |
874 | |
875 | /* Remote controller */ |
876 | state->ir_mode = state->eeprom[EEPROM_IR_MODE]; |
877 | state->ir_type = state->eeprom[EEPROM_IR_TYPE]; |
878 | |
879 | if (state->dual_mode) { |
880 | /* Read 2nd demodulator I2C address. 8-bit format on eeprom */ |
881 | tmp = state->eeprom[EEPROM_2ND_DEMOD_ADDR]; |
882 | if (tmp) |
883 | state->af9033_i2c_addr[1] = tmp >> 1; |
884 | |
885 | dev_dbg(&intf->dev, "2nd demod I2C addr=%02x\n" , |
886 | state->af9033_i2c_addr[1]); |
887 | } |
888 | |
889 | for (i = 0; i < state->dual_mode + 1; i++) { |
890 | unsigned int eeprom_offset = 0; |
891 | |
892 | /* tuner */ |
893 | tmp = state->eeprom[EEPROM_1_TUNER_ID + eeprom_offset]; |
894 | dev_dbg(&intf->dev, "[%d]tuner=%02x\n" , i, tmp); |
895 | |
896 | /* tuner sanity check */ |
897 | if (state->chip_type == 0x9135) { |
898 | if (state->chip_version == 0x02) { |
899 | /* IT9135 BX (v2) */ |
900 | switch (tmp) { |
901 | case AF9033_TUNER_IT9135_60: |
902 | case AF9033_TUNER_IT9135_61: |
903 | case AF9033_TUNER_IT9135_62: |
904 | state->af9033_config[i].tuner = tmp; |
905 | break; |
906 | } |
907 | } else { |
908 | /* IT9135 AX (v1) */ |
909 | switch (tmp) { |
910 | case AF9033_TUNER_IT9135_38: |
911 | case AF9033_TUNER_IT9135_51: |
912 | case AF9033_TUNER_IT9135_52: |
913 | state->af9033_config[i].tuner = tmp; |
914 | break; |
915 | } |
916 | } |
917 | } else { |
918 | /* AF9035 */ |
919 | state->af9033_config[i].tuner = tmp; |
920 | } |
921 | |
922 | if (state->af9033_config[i].tuner != tmp) { |
923 | dev_info(&intf->dev, "[%d] overriding tuner from %02x to %02x\n" , |
924 | i, tmp, state->af9033_config[i].tuner); |
925 | } |
926 | |
927 | switch (state->af9033_config[i].tuner) { |
928 | case AF9033_TUNER_TUA9001: |
929 | case AF9033_TUNER_FC0011: |
930 | case AF9033_TUNER_MXL5007T: |
931 | case AF9033_TUNER_TDA18218: |
932 | case AF9033_TUNER_FC2580: |
933 | case AF9033_TUNER_FC0012: |
934 | state->af9033_config[i].spec_inv = 1; |
935 | break; |
936 | case AF9033_TUNER_IT9135_38: |
937 | case AF9033_TUNER_IT9135_51: |
938 | case AF9033_TUNER_IT9135_52: |
939 | case AF9033_TUNER_IT9135_60: |
940 | case AF9033_TUNER_IT9135_61: |
941 | case AF9033_TUNER_IT9135_62: |
942 | break; |
943 | default: |
944 | dev_warn(&intf->dev, "tuner id=%02x not supported, please report!" , |
945 | tmp); |
946 | } |
947 | |
948 | /* disable dual mode if driver does not support it */ |
949 | if (i == 1) |
950 | switch (state->af9033_config[i].tuner) { |
951 | case AF9033_TUNER_FC0012: |
952 | case AF9033_TUNER_IT9135_38: |
953 | case AF9033_TUNER_IT9135_51: |
954 | case AF9033_TUNER_IT9135_52: |
955 | case AF9033_TUNER_IT9135_60: |
956 | case AF9033_TUNER_IT9135_61: |
957 | case AF9033_TUNER_IT9135_62: |
958 | case AF9033_TUNER_MXL5007T: |
959 | break; |
960 | default: |
961 | state->dual_mode = false; |
962 | dev_info(&intf->dev, "driver does not support 2nd tuner and will disable it" ); |
963 | } |
964 | |
965 | /* tuner IF frequency */ |
966 | tmp = state->eeprom[EEPROM_1_IF_L + eeprom_offset]; |
967 | tmp16 = tmp << 0; |
968 | tmp = state->eeprom[EEPROM_1_IF_H + eeprom_offset]; |
969 | tmp16 |= tmp << 8; |
970 | dev_dbg(&intf->dev, "[%d]IF=%d\n" , i, tmp16); |
971 | |
972 | eeprom_offset += 0x10; /* shift for the 2nd tuner params */ |
973 | } |
974 | |
975 | skip_eeprom: |
976 | /* get demod clock */ |
977 | ret = af9035_rd_reg(d, reg: 0x00d800, val: &tmp); |
978 | if (ret < 0) |
979 | goto err; |
980 | |
981 | tmp = (tmp >> 0) & 0x0f; |
982 | |
983 | for (i = 0; i < ARRAY_SIZE(state->af9033_config); i++) { |
984 | if (state->chip_type == 0x9135) |
985 | state->af9033_config[i].clock = clock_lut_it9135[tmp]; |
986 | else |
987 | state->af9033_config[i].clock = clock_lut_af9035[tmp]; |
988 | } |
989 | |
990 | state->no_read = false; |
991 | /* Some MXL5007T devices cannot properly handle tuner I2C read ops. */ |
992 | if (state->af9033_config[0].tuner == AF9033_TUNER_MXL5007T && |
993 | le16_to_cpu(d->udev->descriptor.idVendor) == USB_VID_AVERMEDIA) |
994 | |
995 | switch (le16_to_cpu(d->udev->descriptor.idProduct)) { |
996 | case USB_PID_AVERMEDIA_A867: |
997 | case USB_PID_AVERMEDIA_TWINSTAR: |
998 | dev_info(&intf->dev, |
999 | "Device may have issues with I2C read operations. Enabling fix.\n" ); |
1000 | state->no_read = true; |
1001 | break; |
1002 | } |
1003 | |
1004 | return 0; |
1005 | |
1006 | err: |
1007 | dev_dbg(&intf->dev, "failed=%d\n" , ret); |
1008 | |
1009 | return ret; |
1010 | } |
1011 | |
1012 | static int af9035_tua9001_tuner_callback(struct dvb_usb_device *d, |
1013 | int cmd, int arg) |
1014 | { |
1015 | struct usb_interface *intf = d->intf; |
1016 | int ret; |
1017 | u8 val; |
1018 | |
1019 | dev_dbg(&intf->dev, "cmd=%d arg=%d\n" , cmd, arg); |
1020 | |
1021 | /* |
1022 | * CEN always enabled by hardware wiring |
1023 | * RESETN GPIOT3 |
1024 | * RXEN GPIOT2 |
1025 | */ |
1026 | |
1027 | switch (cmd) { |
1028 | case TUA9001_CMD_RESETN: |
1029 | if (arg) |
1030 | val = 0x00; |
1031 | else |
1032 | val = 0x01; |
1033 | |
1034 | ret = af9035_wr_reg_mask(d, reg: 0x00d8e7, val, mask: 0x01); |
1035 | if (ret < 0) |
1036 | goto err; |
1037 | break; |
1038 | case TUA9001_CMD_RXEN: |
1039 | if (arg) |
1040 | val = 0x01; |
1041 | else |
1042 | val = 0x00; |
1043 | |
1044 | ret = af9035_wr_reg_mask(d, reg: 0x00d8eb, val, mask: 0x01); |
1045 | if (ret < 0) |
1046 | goto err; |
1047 | break; |
1048 | } |
1049 | |
1050 | return 0; |
1051 | |
1052 | err: |
1053 | dev_dbg(&intf->dev, "failed=%d\n" , ret); |
1054 | |
1055 | return ret; |
1056 | } |
1057 | |
1058 | |
1059 | static int af9035_fc0011_tuner_callback(struct dvb_usb_device *d, |
1060 | int cmd, int arg) |
1061 | { |
1062 | struct usb_interface *intf = d->intf; |
1063 | int ret; |
1064 | |
1065 | switch (cmd) { |
1066 | case FC0011_FE_CALLBACK_POWER: |
1067 | /* Tuner enable */ |
1068 | ret = af9035_wr_reg_mask(d, reg: 0xd8eb, val: 1, mask: 1); |
1069 | if (ret < 0) |
1070 | goto err; |
1071 | |
1072 | ret = af9035_wr_reg_mask(d, reg: 0xd8ec, val: 1, mask: 1); |
1073 | if (ret < 0) |
1074 | goto err; |
1075 | |
1076 | ret = af9035_wr_reg_mask(d, reg: 0xd8ed, val: 1, mask: 1); |
1077 | if (ret < 0) |
1078 | goto err; |
1079 | |
1080 | /* LED */ |
1081 | ret = af9035_wr_reg_mask(d, reg: 0xd8d0, val: 1, mask: 1); |
1082 | if (ret < 0) |
1083 | goto err; |
1084 | |
1085 | ret = af9035_wr_reg_mask(d, reg: 0xd8d1, val: 1, mask: 1); |
1086 | if (ret < 0) |
1087 | goto err; |
1088 | |
1089 | usleep_range(min: 10000, max: 50000); |
1090 | break; |
1091 | case FC0011_FE_CALLBACK_RESET: |
1092 | ret = af9035_wr_reg(d, reg: 0xd8e9, val: 1); |
1093 | if (ret < 0) |
1094 | goto err; |
1095 | |
1096 | ret = af9035_wr_reg(d, reg: 0xd8e8, val: 1); |
1097 | if (ret < 0) |
1098 | goto err; |
1099 | |
1100 | ret = af9035_wr_reg(d, reg: 0xd8e7, val: 1); |
1101 | if (ret < 0) |
1102 | goto err; |
1103 | |
1104 | usleep_range(min: 10000, max: 20000); |
1105 | |
1106 | ret = af9035_wr_reg(d, reg: 0xd8e7, val: 0); |
1107 | if (ret < 0) |
1108 | goto err; |
1109 | |
1110 | usleep_range(min: 10000, max: 20000); |
1111 | break; |
1112 | default: |
1113 | ret = -EINVAL; |
1114 | goto err; |
1115 | } |
1116 | |
1117 | return 0; |
1118 | |
1119 | err: |
1120 | dev_dbg(&intf->dev, "failed=%d\n" , ret); |
1121 | |
1122 | return ret; |
1123 | } |
1124 | |
1125 | static int af9035_tuner_callback(struct dvb_usb_device *d, int cmd, int arg) |
1126 | { |
1127 | struct state *state = d_to_priv(d); |
1128 | |
1129 | switch (state->af9033_config[0].tuner) { |
1130 | case AF9033_TUNER_FC0011: |
1131 | return af9035_fc0011_tuner_callback(d, cmd, arg); |
1132 | case AF9033_TUNER_TUA9001: |
1133 | return af9035_tua9001_tuner_callback(d, cmd, arg); |
1134 | default: |
1135 | break; |
1136 | } |
1137 | |
1138 | return 0; |
1139 | } |
1140 | |
1141 | static int af9035_frontend_callback(void *adapter_priv, int component, |
1142 | int cmd, int arg) |
1143 | { |
1144 | struct i2c_adapter *adap = adapter_priv; |
1145 | struct dvb_usb_device *d = i2c_get_adapdata(adap); |
1146 | struct usb_interface *intf = d->intf; |
1147 | |
1148 | dev_dbg(&intf->dev, "component=%d cmd=%d arg=%d\n" , |
1149 | component, cmd, arg); |
1150 | |
1151 | switch (component) { |
1152 | case DVB_FRONTEND_COMPONENT_TUNER: |
1153 | return af9035_tuner_callback(d, cmd, arg); |
1154 | default: |
1155 | break; |
1156 | } |
1157 | |
1158 | return 0; |
1159 | } |
1160 | |
1161 | static int af9035_get_adapter_count(struct dvb_usb_device *d) |
1162 | { |
1163 | struct state *state = d_to_priv(d); |
1164 | |
1165 | return state->dual_mode + 1; |
1166 | } |
1167 | |
1168 | static int af9035_frontend_attach(struct dvb_usb_adapter *adap) |
1169 | { |
1170 | struct state *state = adap_to_priv(adap); |
1171 | struct dvb_usb_device *d = adap_to_d(adap); |
1172 | struct usb_interface *intf = d->intf; |
1173 | int ret; |
1174 | |
1175 | dev_dbg(&intf->dev, "adap->id=%d\n" , adap->id); |
1176 | |
1177 | if (!state->af9033_config[adap->id].tuner) { |
1178 | /* unsupported tuner */ |
1179 | ret = -ENODEV; |
1180 | goto err; |
1181 | } |
1182 | |
1183 | state->af9033_config[adap->id].fe = &adap->fe[0]; |
1184 | state->af9033_config[adap->id].ops = &state->ops; |
1185 | ret = af9035_add_i2c_dev(d, type: "af9033" , addr: state->af9033_i2c_addr[adap->id], |
1186 | platform_data: &state->af9033_config[adap->id], adapter: &d->i2c_adap); |
1187 | if (ret) |
1188 | goto err; |
1189 | |
1190 | if (adap->fe[0] == NULL) { |
1191 | ret = -ENODEV; |
1192 | goto err; |
1193 | } |
1194 | |
1195 | /* disable I2C-gate */ |
1196 | adap->fe[0]->ops.i2c_gate_ctrl = NULL; |
1197 | adap->fe[0]->callback = af9035_frontend_callback; |
1198 | |
1199 | return 0; |
1200 | |
1201 | err: |
1202 | dev_dbg(&intf->dev, "failed=%d\n" , ret); |
1203 | |
1204 | return ret; |
1205 | } |
1206 | |
1207 | /* |
1208 | * The I2C speed register is calculated with: |
1209 | * I2C speed register = (1000000000 / (24.4 * 16 * I2C_speed)) |
1210 | * |
1211 | * The default speed register for it930x is 7, with means a |
1212 | * speed of ~366 kbps |
1213 | */ |
1214 | #define I2C_SPEED_366K 7 |
1215 | |
1216 | static int it930x_frontend_attach(struct dvb_usb_adapter *adap) |
1217 | { |
1218 | struct state *state = adap_to_priv(adap); |
1219 | struct dvb_usb_device *d = adap_to_d(adap); |
1220 | struct usb_interface *intf = d->intf; |
1221 | int ret; |
1222 | struct si2168_config si2168_config; |
1223 | struct i2c_adapter *adapter; |
1224 | |
1225 | dev_dbg(&intf->dev, "adap->id=%d\n" , adap->id); |
1226 | |
1227 | /* I2C master bus 2 clock speed 366k */ |
1228 | ret = af9035_wr_reg(d, reg: 0x00f6a7, I2C_SPEED_366K); |
1229 | if (ret < 0) |
1230 | goto err; |
1231 | |
1232 | /* I2C master bus 1,3 clock speed 366k */ |
1233 | ret = af9035_wr_reg(d, reg: 0x00f103, I2C_SPEED_366K); |
1234 | if (ret < 0) |
1235 | goto err; |
1236 | |
1237 | /* set gpio11 low */ |
1238 | ret = af9035_wr_reg_mask(d, reg: 0xd8d4, val: 0x01, mask: 0x01); |
1239 | if (ret < 0) |
1240 | goto err; |
1241 | |
1242 | ret = af9035_wr_reg_mask(d, reg: 0xd8d5, val: 0x01, mask: 0x01); |
1243 | if (ret < 0) |
1244 | goto err; |
1245 | |
1246 | ret = af9035_wr_reg_mask(d, reg: 0xd8d3, val: 0x01, mask: 0x01); |
1247 | if (ret < 0) |
1248 | goto err; |
1249 | |
1250 | /* Tuner enable using gpiot2_en, gpiot2_on and gpiot2_o (reset) */ |
1251 | ret = af9035_wr_reg_mask(d, reg: 0xd8b8, val: 0x01, mask: 0x01); |
1252 | if (ret < 0) |
1253 | goto err; |
1254 | |
1255 | ret = af9035_wr_reg_mask(d, reg: 0xd8b9, val: 0x01, mask: 0x01); |
1256 | if (ret < 0) |
1257 | goto err; |
1258 | |
1259 | ret = af9035_wr_reg_mask(d, reg: 0xd8b7, val: 0x00, mask: 0x01); |
1260 | if (ret < 0) |
1261 | goto err; |
1262 | |
1263 | msleep(msecs: 200); |
1264 | |
1265 | ret = af9035_wr_reg_mask(d, reg: 0xd8b7, val: 0x01, mask: 0x01); |
1266 | if (ret < 0) |
1267 | goto err; |
1268 | |
1269 | memset(&si2168_config, 0, sizeof(si2168_config)); |
1270 | si2168_config.i2c_adapter = &adapter; |
1271 | si2168_config.fe = &adap->fe[0]; |
1272 | si2168_config.ts_mode = SI2168_TS_SERIAL; |
1273 | |
1274 | state->af9033_config[adap->id].fe = &adap->fe[0]; |
1275 | state->af9033_config[adap->id].ops = &state->ops; |
1276 | ret = af9035_add_i2c_dev(d, type: "si2168" , |
1277 | addr: it930x_addresses_table[state->it930x_addresses].frontend_i2c_addr, |
1278 | platform_data: &si2168_config, adapter: &d->i2c_adap); |
1279 | if (ret) |
1280 | goto err; |
1281 | |
1282 | if (adap->fe[0] == NULL) { |
1283 | ret = -ENODEV; |
1284 | goto err; |
1285 | } |
1286 | state->i2c_adapter_demod = adapter; |
1287 | |
1288 | return 0; |
1289 | |
1290 | err: |
1291 | dev_dbg(&intf->dev, "failed=%d\n" , ret); |
1292 | |
1293 | return ret; |
1294 | } |
1295 | |
1296 | static int af9035_frontend_detach(struct dvb_usb_adapter *adap) |
1297 | { |
1298 | struct state *state = adap_to_priv(adap); |
1299 | struct dvb_usb_device *d = adap_to_d(adap); |
1300 | struct usb_interface *intf = d->intf; |
1301 | |
1302 | dev_dbg(&intf->dev, "adap->id=%d\n" , adap->id); |
1303 | |
1304 | if (adap->id == 1) { |
1305 | if (state->i2c_client[1]) |
1306 | af9035_del_i2c_dev(d); |
1307 | } else if (adap->id == 0) { |
1308 | if (state->i2c_client[0]) |
1309 | af9035_del_i2c_dev(d); |
1310 | } |
1311 | |
1312 | return 0; |
1313 | } |
1314 | |
1315 | static const struct fc0011_config af9035_fc0011_config = { |
1316 | .i2c_address = 0x60, |
1317 | }; |
1318 | |
1319 | static struct mxl5007t_config af9035_mxl5007t_config[] = { |
1320 | { |
1321 | .xtal_freq_hz = MxL_XTAL_24_MHZ, |
1322 | .if_freq_hz = MxL_IF_4_57_MHZ, |
1323 | .invert_if = 0, |
1324 | .loop_thru_enable = 0, |
1325 | .clk_out_enable = 0, |
1326 | .clk_out_amp = MxL_CLKOUT_AMP_0_94V, |
1327 | }, { |
1328 | .xtal_freq_hz = MxL_XTAL_24_MHZ, |
1329 | .if_freq_hz = MxL_IF_4_57_MHZ, |
1330 | .invert_if = 0, |
1331 | .loop_thru_enable = 1, |
1332 | .clk_out_enable = 1, |
1333 | .clk_out_amp = MxL_CLKOUT_AMP_0_94V, |
1334 | } |
1335 | }; |
1336 | |
1337 | static struct tda18218_config af9035_tda18218_config = { |
1338 | .i2c_address = 0x60, |
1339 | .i2c_wr_max = 21, |
1340 | }; |
1341 | |
1342 | static const struct fc0012_config af9035_fc0012_config[] = { |
1343 | { |
1344 | .i2c_address = 0x63, |
1345 | .xtal_freq = FC_XTAL_36_MHZ, |
1346 | .dual_master = true, |
1347 | .loop_through = true, |
1348 | .clock_out = true, |
1349 | }, { |
1350 | .i2c_address = 0x63 | 0x80, /* I2C bus select hack */ |
1351 | .xtal_freq = FC_XTAL_36_MHZ, |
1352 | .dual_master = true, |
1353 | } |
1354 | }; |
1355 | |
1356 | static int af9035_tuner_attach(struct dvb_usb_adapter *adap) |
1357 | { |
1358 | struct state *state = adap_to_priv(adap); |
1359 | struct dvb_usb_device *d = adap_to_d(adap); |
1360 | struct usb_interface *intf = d->intf; |
1361 | int ret; |
1362 | struct dvb_frontend *fe; |
1363 | struct i2c_msg msg[1]; |
1364 | u8 tuner_addr; |
1365 | |
1366 | dev_dbg(&intf->dev, "adap->id=%d\n" , adap->id); |
1367 | |
1368 | /* |
1369 | * XXX: Hack used in that function: we abuse unused I2C address bit [7] |
1370 | * to carry info about used I2C bus for dual tuner configuration. |
1371 | */ |
1372 | |
1373 | switch (state->af9033_config[adap->id].tuner) { |
1374 | case AF9033_TUNER_TUA9001: { |
1375 | struct tua9001_platform_data tua9001_pdata = { |
1376 | .dvb_frontend = adap->fe[0], |
1377 | }; |
1378 | |
1379 | /* |
1380 | * AF9035 gpiot3 = TUA9001 RESETN |
1381 | * AF9035 gpiot2 = TUA9001 RXEN |
1382 | */ |
1383 | |
1384 | /* configure gpiot2 and gpiot2 as output */ |
1385 | ret = af9035_wr_reg_mask(d, reg: 0x00d8ec, val: 0x01, mask: 0x01); |
1386 | if (ret < 0) |
1387 | goto err; |
1388 | |
1389 | ret = af9035_wr_reg_mask(d, reg: 0x00d8ed, val: 0x01, mask: 0x01); |
1390 | if (ret < 0) |
1391 | goto err; |
1392 | |
1393 | ret = af9035_wr_reg_mask(d, reg: 0x00d8e8, val: 0x01, mask: 0x01); |
1394 | if (ret < 0) |
1395 | goto err; |
1396 | |
1397 | ret = af9035_wr_reg_mask(d, reg: 0x00d8e9, val: 0x01, mask: 0x01); |
1398 | if (ret < 0) |
1399 | goto err; |
1400 | |
1401 | /* attach tuner */ |
1402 | ret = af9035_add_i2c_dev(d, type: "tua9001" , addr: 0x60, platform_data: &tua9001_pdata, |
1403 | adapter: &d->i2c_adap); |
1404 | if (ret) |
1405 | goto err; |
1406 | |
1407 | fe = adap->fe[0]; |
1408 | break; |
1409 | } |
1410 | case AF9033_TUNER_FC0011: |
1411 | fe = dvb_attach(fc0011_attach, adap->fe[0], |
1412 | &d->i2c_adap, &af9035_fc0011_config); |
1413 | break; |
1414 | case AF9033_TUNER_MXL5007T: |
1415 | if (adap->id == 0) { |
1416 | ret = af9035_wr_reg(d, reg: 0x00d8e0, val: 1); |
1417 | if (ret < 0) |
1418 | goto err; |
1419 | |
1420 | ret = af9035_wr_reg(d, reg: 0x00d8e1, val: 1); |
1421 | if (ret < 0) |
1422 | goto err; |
1423 | |
1424 | ret = af9035_wr_reg(d, reg: 0x00d8df, val: 0); |
1425 | if (ret < 0) |
1426 | goto err; |
1427 | |
1428 | msleep(msecs: 30); |
1429 | |
1430 | ret = af9035_wr_reg(d, reg: 0x00d8df, val: 1); |
1431 | if (ret < 0) |
1432 | goto err; |
1433 | |
1434 | msleep(msecs: 300); |
1435 | |
1436 | ret = af9035_wr_reg(d, reg: 0x00d8c0, val: 1); |
1437 | if (ret < 0) |
1438 | goto err; |
1439 | |
1440 | ret = af9035_wr_reg(d, reg: 0x00d8c1, val: 1); |
1441 | if (ret < 0) |
1442 | goto err; |
1443 | |
1444 | ret = af9035_wr_reg(d, reg: 0x00d8bf, val: 0); |
1445 | if (ret < 0) |
1446 | goto err; |
1447 | |
1448 | ret = af9035_wr_reg(d, reg: 0x00d8b4, val: 1); |
1449 | if (ret < 0) |
1450 | goto err; |
1451 | |
1452 | ret = af9035_wr_reg(d, reg: 0x00d8b5, val: 1); |
1453 | if (ret < 0) |
1454 | goto err; |
1455 | |
1456 | ret = af9035_wr_reg(d, reg: 0x00d8b3, val: 1); |
1457 | if (ret < 0) |
1458 | goto err; |
1459 | |
1460 | tuner_addr = 0x60; |
1461 | } else { |
1462 | tuner_addr = 0x60 | 0x80; /* I2C bus hack */ |
1463 | } |
1464 | |
1465 | /* attach tuner */ |
1466 | fe = dvb_attach(mxl5007t_attach, adap->fe[0], &d->i2c_adap, |
1467 | tuner_addr, &af9035_mxl5007t_config[adap->id]); |
1468 | break; |
1469 | case AF9033_TUNER_TDA18218: |
1470 | /* attach tuner */ |
1471 | fe = dvb_attach(tda18218_attach, adap->fe[0], |
1472 | &d->i2c_adap, &af9035_tda18218_config); |
1473 | break; |
1474 | case AF9033_TUNER_FC2580: { |
1475 | struct fc2580_platform_data fc2580_pdata = { |
1476 | .dvb_frontend = adap->fe[0], |
1477 | }; |
1478 | |
1479 | /* Tuner enable using gpiot2_o, gpiot2_en and gpiot2_on */ |
1480 | ret = af9035_wr_reg_mask(d, reg: 0xd8eb, val: 0x01, mask: 0x01); |
1481 | if (ret < 0) |
1482 | goto err; |
1483 | |
1484 | ret = af9035_wr_reg_mask(d, reg: 0xd8ec, val: 0x01, mask: 0x01); |
1485 | if (ret < 0) |
1486 | goto err; |
1487 | |
1488 | ret = af9035_wr_reg_mask(d, reg: 0xd8ed, val: 0x01, mask: 0x01); |
1489 | if (ret < 0) |
1490 | goto err; |
1491 | |
1492 | usleep_range(min: 10000, max: 50000); |
1493 | /* attach tuner */ |
1494 | ret = af9035_add_i2c_dev(d, type: "fc2580" , addr: 0x56, platform_data: &fc2580_pdata, |
1495 | adapter: &d->i2c_adap); |
1496 | if (ret) |
1497 | goto err; |
1498 | |
1499 | fe = adap->fe[0]; |
1500 | break; |
1501 | } |
1502 | case AF9033_TUNER_FC0012: |
1503 | /* |
1504 | * AF9035 gpiot2 = FC0012 enable |
1505 | * XXX: there seems to be something on gpioh8 too, but on my |
1506 | * test I didn't find any difference. |
1507 | */ |
1508 | |
1509 | if (adap->id == 0) { |
1510 | /* configure gpiot2 as output and high */ |
1511 | ret = af9035_wr_reg_mask(d, reg: 0xd8eb, val: 0x01, mask: 0x01); |
1512 | if (ret < 0) |
1513 | goto err; |
1514 | |
1515 | ret = af9035_wr_reg_mask(d, reg: 0xd8ec, val: 0x01, mask: 0x01); |
1516 | if (ret < 0) |
1517 | goto err; |
1518 | |
1519 | ret = af9035_wr_reg_mask(d, reg: 0xd8ed, val: 0x01, mask: 0x01); |
1520 | if (ret < 0) |
1521 | goto err; |
1522 | } else { |
1523 | /* |
1524 | * FIXME: That belongs for the FC0012 driver. |
1525 | * Write 02 to FC0012 master tuner register 0d directly |
1526 | * in order to make slave tuner working. |
1527 | */ |
1528 | msg[0].addr = 0x63; |
1529 | msg[0].flags = 0; |
1530 | msg[0].len = 2; |
1531 | msg[0].buf = "\x0d\x02" ; |
1532 | ret = i2c_transfer(adap: &d->i2c_adap, msgs: msg, num: 1); |
1533 | if (ret < 0) |
1534 | goto err; |
1535 | } |
1536 | |
1537 | usleep_range(min: 10000, max: 50000); |
1538 | |
1539 | fe = dvb_attach(fc0012_attach, adap->fe[0], &d->i2c_adap, |
1540 | &af9035_fc0012_config[adap->id]); |
1541 | break; |
1542 | case AF9033_TUNER_IT9135_38: |
1543 | case AF9033_TUNER_IT9135_51: |
1544 | case AF9033_TUNER_IT9135_52: |
1545 | case AF9033_TUNER_IT9135_60: |
1546 | case AF9033_TUNER_IT9135_61: |
1547 | case AF9033_TUNER_IT9135_62: |
1548 | { |
1549 | struct platform_device *pdev; |
1550 | const char *name; |
1551 | struct it913x_platform_data it913x_pdata = { |
1552 | .regmap = state->af9033_config[adap->id].regmap, |
1553 | .fe = adap->fe[0], |
1554 | }; |
1555 | |
1556 | switch (state->af9033_config[adap->id].tuner) { |
1557 | case AF9033_TUNER_IT9135_38: |
1558 | case AF9033_TUNER_IT9135_51: |
1559 | case AF9033_TUNER_IT9135_52: |
1560 | name = "it9133ax-tuner" ; |
1561 | break; |
1562 | case AF9033_TUNER_IT9135_60: |
1563 | case AF9033_TUNER_IT9135_61: |
1564 | case AF9033_TUNER_IT9135_62: |
1565 | name = "it9133bx-tuner" ; |
1566 | break; |
1567 | default: |
1568 | ret = -ENODEV; |
1569 | goto err; |
1570 | } |
1571 | |
1572 | if (state->dual_mode) { |
1573 | if (adap->id == 0) |
1574 | it913x_pdata.role = IT913X_ROLE_DUAL_MASTER; |
1575 | else |
1576 | it913x_pdata.role = IT913X_ROLE_DUAL_SLAVE; |
1577 | } else { |
1578 | it913x_pdata.role = IT913X_ROLE_SINGLE; |
1579 | } |
1580 | |
1581 | request_module("%s" , "it913x" ); |
1582 | pdev = platform_device_register_data(parent: &d->intf->dev, name, |
1583 | PLATFORM_DEVID_AUTO, |
1584 | data: &it913x_pdata, |
1585 | size: sizeof(it913x_pdata)); |
1586 | if (IS_ERR(ptr: pdev) || !pdev->dev.driver) { |
1587 | ret = -ENODEV; |
1588 | goto err; |
1589 | } |
1590 | if (!try_module_get(module: pdev->dev.driver->owner)) { |
1591 | platform_device_unregister(pdev); |
1592 | ret = -ENODEV; |
1593 | goto err; |
1594 | } |
1595 | |
1596 | state->platform_device_tuner[adap->id] = pdev; |
1597 | fe = adap->fe[0]; |
1598 | break; |
1599 | } |
1600 | default: |
1601 | fe = NULL; |
1602 | } |
1603 | |
1604 | if (fe == NULL) { |
1605 | ret = -ENODEV; |
1606 | goto err; |
1607 | } |
1608 | |
1609 | return 0; |
1610 | |
1611 | err: |
1612 | dev_dbg(&intf->dev, "failed=%d\n" , ret); |
1613 | |
1614 | return ret; |
1615 | } |
1616 | |
1617 | static int it930x_tuner_attach(struct dvb_usb_adapter *adap) |
1618 | { |
1619 | struct state *state = adap_to_priv(adap); |
1620 | struct dvb_usb_device *d = adap_to_d(adap); |
1621 | struct usb_interface *intf = d->intf; |
1622 | int ret; |
1623 | struct si2157_config si2157_config; |
1624 | |
1625 | dev_dbg(&intf->dev, "adap->id=%d\n" , adap->id); |
1626 | |
1627 | memset(&si2157_config, 0, sizeof(si2157_config)); |
1628 | si2157_config.fe = adap->fe[0]; |
1629 | |
1630 | /* |
1631 | * HACK: The Logilink VG0022A and TerraTec TC2 Stick have |
1632 | * a bug: when the si2157 firmware that came with the device |
1633 | * is replaced by a new one, the I2C transfers to the tuner |
1634 | * will return just 0xff. |
1635 | * |
1636 | * Probably, the vendor firmware has some patch specifically |
1637 | * designed for this device. So, we can't replace by the |
1638 | * generic firmware. The right solution would be to extract |
1639 | * the si2157 firmware from the original driver and ask the |
1640 | * driver to load the specifically designed firmware, but, |
1641 | * while we don't have that, the next best solution is to just |
1642 | * keep the original firmware at the device. |
1643 | */ |
1644 | if ((le16_to_cpu(d->udev->descriptor.idVendor) == USB_VID_DEXATEK && |
1645 | le16_to_cpu(d->udev->descriptor.idProduct) == 0x0100) || |
1646 | (le16_to_cpu(d->udev->descriptor.idVendor) == USB_VID_TERRATEC && |
1647 | le16_to_cpu(d->udev->descriptor.idProduct) == USB_PID_TERRATEC_CINERGY_TC2_STICK)) |
1648 | si2157_config.dont_load_firmware = true; |
1649 | |
1650 | si2157_config.if_port = it930x_addresses_table[state->it930x_addresses].tuner_if_port; |
1651 | ret = af9035_add_i2c_dev(d, type: "si2157" , |
1652 | addr: it930x_addresses_table[state->it930x_addresses].tuner_i2c_addr, |
1653 | platform_data: &si2157_config, adapter: state->i2c_adapter_demod); |
1654 | if (ret) |
1655 | goto err; |
1656 | |
1657 | return 0; |
1658 | |
1659 | err: |
1660 | dev_dbg(&intf->dev, "failed=%d\n" , ret); |
1661 | |
1662 | return ret; |
1663 | } |
1664 | |
1665 | |
1666 | static int it930x_tuner_detach(struct dvb_usb_adapter *adap) |
1667 | { |
1668 | struct state *state = adap_to_priv(adap); |
1669 | struct dvb_usb_device *d = adap_to_d(adap); |
1670 | struct usb_interface *intf = d->intf; |
1671 | |
1672 | dev_dbg(&intf->dev, "adap->id=%d\n" , adap->id); |
1673 | |
1674 | if (adap->id == 1) { |
1675 | if (state->i2c_client[3]) |
1676 | af9035_del_i2c_dev(d); |
1677 | } else if (adap->id == 0) { |
1678 | if (state->i2c_client[1]) |
1679 | af9035_del_i2c_dev(d); |
1680 | } |
1681 | |
1682 | return 0; |
1683 | } |
1684 | |
1685 | |
1686 | static int af9035_tuner_detach(struct dvb_usb_adapter *adap) |
1687 | { |
1688 | struct state *state = adap_to_priv(adap); |
1689 | struct dvb_usb_device *d = adap_to_d(adap); |
1690 | struct usb_interface *intf = d->intf; |
1691 | |
1692 | dev_dbg(&intf->dev, "adap->id=%d\n" , adap->id); |
1693 | |
1694 | switch (state->af9033_config[adap->id].tuner) { |
1695 | case AF9033_TUNER_TUA9001: |
1696 | case AF9033_TUNER_FC2580: |
1697 | if (adap->id == 1) { |
1698 | if (state->i2c_client[3]) |
1699 | af9035_del_i2c_dev(d); |
1700 | } else if (adap->id == 0) { |
1701 | if (state->i2c_client[1]) |
1702 | af9035_del_i2c_dev(d); |
1703 | } |
1704 | break; |
1705 | case AF9033_TUNER_IT9135_38: |
1706 | case AF9033_TUNER_IT9135_51: |
1707 | case AF9033_TUNER_IT9135_52: |
1708 | case AF9033_TUNER_IT9135_60: |
1709 | case AF9033_TUNER_IT9135_61: |
1710 | case AF9033_TUNER_IT9135_62: |
1711 | { |
1712 | struct platform_device *pdev; |
1713 | |
1714 | pdev = state->platform_device_tuner[adap->id]; |
1715 | if (pdev) { |
1716 | module_put(module: pdev->dev.driver->owner); |
1717 | platform_device_unregister(pdev); |
1718 | } |
1719 | break; |
1720 | } |
1721 | } |
1722 | |
1723 | return 0; |
1724 | } |
1725 | |
1726 | static int af9035_init(struct dvb_usb_device *d) |
1727 | { |
1728 | struct state *state = d_to_priv(d); |
1729 | struct usb_interface *intf = d->intf; |
1730 | int ret, i; |
1731 | u16 frame_size = (d->udev->speed == USB_SPEED_FULL ? 5 : 87) * 188 / 4; |
1732 | u8 packet_size = (d->udev->speed == USB_SPEED_FULL ? 64 : 512) / 4; |
1733 | struct reg_val_mask tab[] = { |
1734 | { .reg: 0x80f99d, .val: 0x01, .mask: 0x01 }, |
1735 | { 0x80f9a4, 0x01, 0x01 }, |
1736 | { 0x00dd11, 0x00, 0x20 }, |
1737 | { 0x00dd11, 0x00, 0x40 }, |
1738 | { 0x00dd13, 0x00, 0x20 }, |
1739 | { 0x00dd13, 0x00, 0x40 }, |
1740 | { 0x00dd11, 0x20, 0x20 }, |
1741 | { 0x00dd88, (frame_size >> 0) & 0xff, 0xff}, |
1742 | { 0x00dd89, (frame_size >> 8) & 0xff, 0xff}, |
1743 | { 0x00dd0c, packet_size, 0xff}, |
1744 | { 0x00dd11, state->dual_mode << 6, 0x40 }, |
1745 | { 0x00dd8a, (frame_size >> 0) & 0xff, 0xff}, |
1746 | { 0x00dd8b, (frame_size >> 8) & 0xff, 0xff}, |
1747 | { 0x00dd0d, packet_size, 0xff }, |
1748 | { 0x80f9a3, state->dual_mode, 0x01 }, |
1749 | { 0x80f9cd, state->dual_mode, 0x01 }, |
1750 | { 0x80f99d, 0x00, 0x01 }, |
1751 | { 0x80f9a4, 0x00, 0x01 }, |
1752 | }; |
1753 | |
1754 | dev_dbg(&intf->dev, "USB speed=%d frame_size=%04x packet_size=%02x\n" , |
1755 | d->udev->speed, frame_size, packet_size); |
1756 | |
1757 | /* init endpoints */ |
1758 | for (i = 0; i < ARRAY_SIZE(tab); i++) { |
1759 | ret = af9035_wr_reg_mask(d, reg: tab[i].reg, val: tab[i].val, |
1760 | mask: tab[i].mask); |
1761 | if (ret < 0) |
1762 | goto err; |
1763 | } |
1764 | |
1765 | return 0; |
1766 | |
1767 | err: |
1768 | dev_dbg(&intf->dev, "failed=%d\n" , ret); |
1769 | |
1770 | return ret; |
1771 | } |
1772 | |
1773 | static int it930x_init(struct dvb_usb_device *d) |
1774 | { |
1775 | struct state *state = d_to_priv(d); |
1776 | struct usb_interface *intf = d->intf; |
1777 | int ret, i; |
1778 | u16 frame_size = (d->udev->speed == USB_SPEED_FULL ? 5 : 816) * 188 / 4; |
1779 | u8 packet_size = (d->udev->speed == USB_SPEED_FULL ? 64 : 512) / 4; |
1780 | struct reg_val_mask tab[] = { |
1781 | { .reg: 0x00da1a, .val: 0x00, .mask: 0x01 }, /* ignore_sync_byte */ |
1782 | { 0x00f41f, 0x04, 0x04 }, /* dvbt_inten */ |
1783 | { 0x00da10, 0x00, 0x01 }, /* mpeg_full_speed */ |
1784 | { 0x00f41a, 0x01, 0x01 }, /* dvbt_en */ |
1785 | { 0x00da1d, 0x01, 0x01 }, /* mp2_sw_rst, reset EP4 */ |
1786 | { 0x00dd11, 0x00, 0x20 }, /* ep4_tx_en, disable EP4 */ |
1787 | { 0x00dd13, 0x00, 0x20 }, /* ep4_tx_nak, disable EP4 NAK */ |
1788 | { 0x00dd11, 0x20, 0x20 }, /* ep4_tx_en, enable EP4 */ |
1789 | { 0x00dd11, 0x00, 0x40 }, /* ep5_tx_en, disable EP5 */ |
1790 | { 0x00dd13, 0x00, 0x40 }, /* ep5_tx_nak, disable EP5 NAK */ |
1791 | { 0x00dd11, state->dual_mode << 6, 0x40 }, /* enable EP5 */ |
1792 | { 0x00dd88, (frame_size >> 0) & 0xff, 0xff}, |
1793 | { 0x00dd89, (frame_size >> 8) & 0xff, 0xff}, |
1794 | { 0x00dd0c, packet_size, 0xff}, |
1795 | { 0x00dd8a, (frame_size >> 0) & 0xff, 0xff}, |
1796 | { 0x00dd8b, (frame_size >> 8) & 0xff, 0xff}, |
1797 | { 0x00dd0d, packet_size, 0xff }, |
1798 | { 0x00da1d, 0x00, 0x01 }, /* mp2_sw_rst, disable */ |
1799 | { 0x00d833, 0x01, 0xff }, /* slew rate ctrl: slew rate boosts */ |
1800 | { 0x00d830, 0x00, 0xff }, /* Bit 0 of output driving control */ |
1801 | { 0x00d831, 0x01, 0xff }, /* Bit 1 of output driving control */ |
1802 | { 0x00d832, 0x00, 0xff }, /* Bit 2 of output driving control */ |
1803 | |
1804 | /* suspend gpio1 for TS-C */ |
1805 | { 0x00d8b0, 0x01, 0xff }, /* gpio1 */ |
1806 | { 0x00d8b1, 0x01, 0xff }, /* gpio1 */ |
1807 | { 0x00d8af, 0x00, 0xff }, /* gpio1 */ |
1808 | |
1809 | /* suspend gpio7 for TS-D */ |
1810 | { 0x00d8c4, 0x01, 0xff }, /* gpio7 */ |
1811 | { 0x00d8c5, 0x01, 0xff }, /* gpio7 */ |
1812 | { 0x00d8c3, 0x00, 0xff }, /* gpio7 */ |
1813 | |
1814 | /* suspend gpio13 for TS-B */ |
1815 | { 0x00d8dc, 0x01, 0xff }, /* gpio13 */ |
1816 | { 0x00d8dd, 0x01, 0xff }, /* gpio13 */ |
1817 | { 0x00d8db, 0x00, 0xff }, /* gpio13 */ |
1818 | |
1819 | /* suspend gpio14 for TS-E */ |
1820 | { 0x00d8e4, 0x01, 0xff }, /* gpio14 */ |
1821 | { 0x00d8e5, 0x01, 0xff }, /* gpio14 */ |
1822 | { 0x00d8e3, 0x00, 0xff }, /* gpio14 */ |
1823 | |
1824 | /* suspend gpio15 for TS-A */ |
1825 | { 0x00d8e8, 0x01, 0xff }, /* gpio15 */ |
1826 | { 0x00d8e9, 0x01, 0xff }, /* gpio15 */ |
1827 | { 0x00d8e7, 0x00, 0xff }, /* gpio15 */ |
1828 | |
1829 | { 0x00da58, 0x00, 0x01 }, /* ts_in_src, serial */ |
1830 | { 0x00da73, 0x01, 0xff }, /* ts0_aggre_mode */ |
1831 | { 0x00da78, 0x47, 0xff }, /* ts0_sync_byte */ |
1832 | { 0x00da4c, 0x01, 0xff }, /* ts0_en */ |
1833 | { 0x00da5a, 0x1f, 0xff }, /* ts_fail_ignore */ |
1834 | }; |
1835 | |
1836 | dev_dbg(&intf->dev, "USB speed=%d frame_size=%04x packet_size=%02x\n" , |
1837 | d->udev->speed, frame_size, packet_size); |
1838 | |
1839 | /* init endpoints */ |
1840 | for (i = 0; i < ARRAY_SIZE(tab); i++) { |
1841 | ret = af9035_wr_reg_mask(d, reg: tab[i].reg, |
1842 | val: tab[i].val, mask: tab[i].mask); |
1843 | |
1844 | if (ret < 0) |
1845 | goto err; |
1846 | } |
1847 | |
1848 | return 0; |
1849 | err: |
1850 | dev_dbg(&intf->dev, "failed=%d\n" , ret); |
1851 | |
1852 | return ret; |
1853 | } |
1854 | |
1855 | |
1856 | #if IS_ENABLED(CONFIG_RC_CORE) |
1857 | static int af9035_rc_query(struct dvb_usb_device *d) |
1858 | { |
1859 | struct usb_interface *intf = d->intf; |
1860 | int ret; |
1861 | enum rc_proto proto; |
1862 | u32 key; |
1863 | u8 buf[4]; |
1864 | struct usb_req req = { CMD_IR_GET, 0, 0, NULL, 4, buf }; |
1865 | |
1866 | ret = af9035_ctrl_msg(d, req: &req); |
1867 | if (ret == 1) |
1868 | return 0; |
1869 | else if (ret < 0) |
1870 | goto err; |
1871 | |
1872 | if ((buf[2] + buf[3]) == 0xff) { |
1873 | if ((buf[0] + buf[1]) == 0xff) { |
1874 | /* NEC standard 16bit */ |
1875 | key = RC_SCANCODE_NEC(buf[0], buf[2]); |
1876 | proto = RC_PROTO_NEC; |
1877 | } else { |
1878 | /* NEC extended 24bit */ |
1879 | key = RC_SCANCODE_NECX(buf[0] << 8 | buf[1], buf[2]); |
1880 | proto = RC_PROTO_NECX; |
1881 | } |
1882 | } else { |
1883 | /* NEC full code 32bit */ |
1884 | key = RC_SCANCODE_NEC32(buf[0] << 24 | buf[1] << 16 | |
1885 | buf[2] << 8 | buf[3]); |
1886 | proto = RC_PROTO_NEC32; |
1887 | } |
1888 | |
1889 | dev_dbg(&intf->dev, "%*ph\n" , 4, buf); |
1890 | |
1891 | rc_keydown(dev: d->rc_dev, protocol: proto, scancode: key, toggle: 0); |
1892 | |
1893 | return 0; |
1894 | |
1895 | err: |
1896 | dev_dbg(&intf->dev, "failed=%d\n" , ret); |
1897 | |
1898 | return ret; |
1899 | } |
1900 | |
1901 | static int af9035_get_rc_config(struct dvb_usb_device *d, struct dvb_usb_rc *rc) |
1902 | { |
1903 | struct state *state = d_to_priv(d); |
1904 | struct usb_interface *intf = d->intf; |
1905 | |
1906 | dev_dbg(&intf->dev, "ir_mode=%02x ir_type=%02x\n" , |
1907 | state->ir_mode, state->ir_type); |
1908 | |
1909 | /* don't activate rc if in HID mode or if not available */ |
1910 | if (state->ir_mode == 0x05) { |
1911 | switch (state->ir_type) { |
1912 | case 0: /* NEC */ |
1913 | default: |
1914 | rc->allowed_protos = RC_PROTO_BIT_NEC | |
1915 | RC_PROTO_BIT_NECX | RC_PROTO_BIT_NEC32; |
1916 | break; |
1917 | case 1: /* RC6 */ |
1918 | rc->allowed_protos = RC_PROTO_BIT_RC6_MCE; |
1919 | break; |
1920 | } |
1921 | |
1922 | rc->query = af9035_rc_query; |
1923 | rc->interval = 500; |
1924 | |
1925 | /* load empty to enable rc */ |
1926 | if (!rc->map_name) |
1927 | rc->map_name = RC_MAP_EMPTY; |
1928 | } |
1929 | |
1930 | return 0; |
1931 | } |
1932 | #else |
1933 | #define af9035_get_rc_config NULL |
1934 | #endif |
1935 | |
1936 | static int af9035_get_stream_config(struct dvb_frontend *fe, u8 *ts_type, |
1937 | struct usb_data_stream_properties *stream) |
1938 | { |
1939 | struct dvb_usb_device *d = fe_to_d(fe); |
1940 | struct usb_interface *intf = d->intf; |
1941 | |
1942 | dev_dbg(&intf->dev, "adap=%d\n" , fe_to_adap(fe)->id); |
1943 | |
1944 | if (d->udev->speed == USB_SPEED_FULL) |
1945 | stream->u.bulk.buffersize = 5 * 188; |
1946 | |
1947 | return 0; |
1948 | } |
1949 | |
1950 | static int af9035_pid_filter_ctrl(struct dvb_usb_adapter *adap, int onoff) |
1951 | { |
1952 | struct state *state = adap_to_priv(adap); |
1953 | |
1954 | return state->ops.pid_filter_ctrl(adap->fe[0], onoff); |
1955 | } |
1956 | |
1957 | static int af9035_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid, |
1958 | int onoff) |
1959 | { |
1960 | struct state *state = adap_to_priv(adap); |
1961 | |
1962 | return state->ops.pid_filter(adap->fe[0], index, pid, onoff); |
1963 | } |
1964 | |
1965 | static int af9035_probe(struct usb_interface *intf, |
1966 | const struct usb_device_id *id) |
1967 | { |
1968 | struct usb_device *udev = interface_to_usbdev(intf); |
1969 | char manufacturer[sizeof("Afatech" )]; |
1970 | |
1971 | memset(manufacturer, 0, sizeof(manufacturer)); |
1972 | usb_string(dev: udev, index: udev->descriptor.iManufacturer, |
1973 | buf: manufacturer, size: sizeof(manufacturer)); |
1974 | /* |
1975 | * There is two devices having same ID but different chipset. One uses |
1976 | * AF9015 and the other IT9135 chipset. Only difference seen on lsusb |
1977 | * is iManufacturer string. |
1978 | * |
1979 | * idVendor 0x0ccd TerraTec Electronic GmbH |
1980 | * idProduct 0x0099 |
1981 | * bcdDevice 2.00 |
1982 | * iManufacturer 1 Afatech |
1983 | * iProduct 2 DVB-T 2 |
1984 | * |
1985 | * idVendor 0x0ccd TerraTec Electronic GmbH |
1986 | * idProduct 0x0099 |
1987 | * bcdDevice 2.00 |
1988 | * iManufacturer 1 ITE Technologies, Inc. |
1989 | * iProduct 2 DVB-T TV Stick |
1990 | */ |
1991 | if ((le16_to_cpu(udev->descriptor.idVendor) == USB_VID_TERRATEC) && |
1992 | (le16_to_cpu(udev->descriptor.idProduct) == 0x0099)) { |
1993 | if (!strcmp("Afatech" , manufacturer)) { |
1994 | dev_dbg(&udev->dev, "rejecting device\n" ); |
1995 | return -ENODEV; |
1996 | } |
1997 | } |
1998 | |
1999 | return dvb_usbv2_probe(intf, id); |
2000 | } |
2001 | |
2002 | /* interface 0 is used by DVB-T receiver and |
2003 | interface 1 is for remote controller (HID) */ |
2004 | static const struct dvb_usb_device_properties af9035_props = { |
2005 | .driver_name = KBUILD_MODNAME, |
2006 | .owner = THIS_MODULE, |
2007 | .adapter_nr = adapter_nr, |
2008 | .size_of_priv = sizeof(struct state), |
2009 | |
2010 | .generic_bulk_ctrl_endpoint = 0x02, |
2011 | .generic_bulk_ctrl_endpoint_response = 0x81, |
2012 | |
2013 | .identify_state = af9035_identify_state, |
2014 | .download_firmware = af9035_download_firmware, |
2015 | |
2016 | .i2c_algo = &af9035_i2c_algo, |
2017 | .read_config = af9035_read_config, |
2018 | .frontend_attach = af9035_frontend_attach, |
2019 | .frontend_detach = af9035_frontend_detach, |
2020 | .tuner_attach = af9035_tuner_attach, |
2021 | .tuner_detach = af9035_tuner_detach, |
2022 | .init = af9035_init, |
2023 | .get_rc_config = af9035_get_rc_config, |
2024 | .get_stream_config = af9035_get_stream_config, |
2025 | |
2026 | .get_adapter_count = af9035_get_adapter_count, |
2027 | .adapter = { |
2028 | { |
2029 | .caps = DVB_USB_ADAP_HAS_PID_FILTER | |
2030 | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, |
2031 | |
2032 | .pid_filter_count = 32, |
2033 | .pid_filter_ctrl = af9035_pid_filter_ctrl, |
2034 | .pid_filter = af9035_pid_filter, |
2035 | |
2036 | .stream = DVB_USB_STREAM_BULK(0x84, 6, 87 * 188), |
2037 | }, { |
2038 | .caps = DVB_USB_ADAP_HAS_PID_FILTER | |
2039 | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, |
2040 | |
2041 | .pid_filter_count = 32, |
2042 | .pid_filter_ctrl = af9035_pid_filter_ctrl, |
2043 | .pid_filter = af9035_pid_filter, |
2044 | |
2045 | .stream = DVB_USB_STREAM_BULK(0x85, 6, 87 * 188), |
2046 | }, |
2047 | }, |
2048 | }; |
2049 | |
2050 | static const struct dvb_usb_device_properties it930x_props = { |
2051 | .driver_name = KBUILD_MODNAME, |
2052 | .owner = THIS_MODULE, |
2053 | .adapter_nr = adapter_nr, |
2054 | .size_of_priv = sizeof(struct state), |
2055 | |
2056 | .generic_bulk_ctrl_endpoint = 0x02, |
2057 | .generic_bulk_ctrl_endpoint_response = 0x81, |
2058 | |
2059 | .identify_state = af9035_identify_state, |
2060 | .download_firmware = af9035_download_firmware, |
2061 | |
2062 | .i2c_algo = &af9035_i2c_algo, |
2063 | .read_config = af9035_read_config, |
2064 | .frontend_attach = it930x_frontend_attach, |
2065 | .frontend_detach = af9035_frontend_detach, |
2066 | .tuner_attach = it930x_tuner_attach, |
2067 | .tuner_detach = it930x_tuner_detach, |
2068 | .init = it930x_init, |
2069 | .get_stream_config = af9035_get_stream_config, |
2070 | |
2071 | .get_adapter_count = af9035_get_adapter_count, |
2072 | .adapter = { |
2073 | { |
2074 | .stream = DVB_USB_STREAM_BULK(0x84, 4, 816 * 188), |
2075 | }, { |
2076 | .stream = DVB_USB_STREAM_BULK(0x85, 4, 816 * 188), |
2077 | }, |
2078 | }, |
2079 | }; |
2080 | |
2081 | static const struct usb_device_id af9035_id_table[] = { |
2082 | /* AF9035 devices */ |
2083 | { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9035_9035, |
2084 | &af9035_props, "Afatech AF9035 reference design" , NULL) }, |
2085 | { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9035_1000, |
2086 | &af9035_props, "Afatech AF9035 reference design" , NULL) }, |
2087 | { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9035_1001, |
2088 | &af9035_props, "Afatech AF9035 reference design" , NULL) }, |
2089 | { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9035_1002, |
2090 | &af9035_props, "Afatech AF9035 reference design" , NULL) }, |
2091 | { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9035_1003, |
2092 | &af9035_props, "Afatech AF9035 reference design" , NULL) }, |
2093 | { DVB_USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_STICK, |
2094 | &af9035_props, "TerraTec Cinergy T Stick" , NULL) }, |
2095 | { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A835, |
2096 | &af9035_props, "AVerMedia AVerTV Volar HD/PRO (A835)" , NULL) }, |
2097 | { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_B835, |
2098 | &af9035_props, "AVerMedia AVerTV Volar HD/PRO (A835)" , NULL) }, |
2099 | { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_1867, |
2100 | &af9035_props, "AVerMedia HD Volar (A867)" , NULL) }, |
2101 | { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A867, |
2102 | &af9035_props, "AVerMedia HD Volar (A867)" , NULL) }, |
2103 | { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_TWINSTAR, |
2104 | &af9035_props, "AVerMedia Twinstar (A825)" , NULL) }, |
2105 | { DVB_USB_DEVICE(USB_VID_ASUS, USB_PID_ASUS_U3100MINI_PLUS, |
2106 | &af9035_props, "Asus U3100Mini Plus" , NULL) }, |
2107 | { DVB_USB_DEVICE(USB_VID_TERRATEC, 0x00aa, |
2108 | &af9035_props, "TerraTec Cinergy T Stick (rev. 2)" , NULL) }, |
2109 | { DVB_USB_DEVICE(USB_VID_AVERMEDIA, 0x0337, |
2110 | &af9035_props, "AVerMedia HD Volar (A867)" , NULL) }, |
2111 | { DVB_USB_DEVICE(USB_VID_GTEK, USB_PID_EVOLVEO_XTRATV_STICK, |
2112 | &af9035_props, "EVOLVEO XtraTV stick" , NULL) }, |
2113 | |
2114 | /* IT9135 devices */ |
2115 | { DVB_USB_DEVICE(USB_VID_ITETECH, USB_PID_ITETECH_IT9135, |
2116 | &af9035_props, "ITE 9135 Generic" , RC_MAP_IT913X_V1) }, |
2117 | { DVB_USB_DEVICE(USB_VID_ITETECH, USB_PID_ITETECH_IT9135_9005, |
2118 | &af9035_props, "ITE 9135(9005) Generic" , RC_MAP_IT913X_V2) }, |
2119 | { DVB_USB_DEVICE(USB_VID_ITETECH, USB_PID_ITETECH_IT9135_9006, |
2120 | &af9035_props, "ITE 9135(9006) Generic" , RC_MAP_IT913X_V1) }, |
2121 | { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A835B_1835, |
2122 | &af9035_props, "Avermedia A835B(1835)" , RC_MAP_IT913X_V2) }, |
2123 | { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A835B_2835, |
2124 | &af9035_props, "Avermedia A835B(2835)" , RC_MAP_IT913X_V2) }, |
2125 | { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A835B_3835, |
2126 | &af9035_props, "Avermedia A835B(3835)" , RC_MAP_IT913X_V2) }, |
2127 | { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A835B_4835, |
2128 | &af9035_props, "Avermedia A835B(4835)" , RC_MAP_IT913X_V2) }, |
2129 | { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_TD110, |
2130 | &af9035_props, "Avermedia AverTV Volar HD 2 (TD110)" , RC_MAP_AVERMEDIA_RM_KS) }, |
2131 | { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_H335, |
2132 | &af9035_props, "Avermedia H335" , RC_MAP_IT913X_V2) }, |
2133 | { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_UB499_2T_T09, |
2134 | &af9035_props, "Kworld UB499-2T T09" , RC_MAP_IT913X_V1) }, |
2135 | { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_SVEON_STV22_IT9137, |
2136 | &af9035_props, "Sveon STV22 Dual DVB-T HDTV" , |
2137 | RC_MAP_IT913X_V1) }, |
2138 | { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_CTVDIGDUAL_V2, |
2139 | &af9035_props, "Digital Dual TV Receiver CTVDIGDUAL_V2" , |
2140 | RC_MAP_IT913X_V1) }, |
2141 | { DVB_USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_T1, |
2142 | &af9035_props, "TerraTec T1" , RC_MAP_IT913X_V1) }, |
2143 | /* XXX: that same ID [0ccd:0099] is used by af9015 driver too */ |
2144 | { DVB_USB_DEVICE(USB_VID_TERRATEC, 0x0099, |
2145 | &af9035_props, "TerraTec Cinergy T Stick Dual RC (rev. 2)" , |
2146 | NULL) }, |
2147 | { DVB_USB_DEVICE(USB_VID_LEADTEK, 0x6a05, |
2148 | &af9035_props, "Leadtek WinFast DTV Dongle Dual" , NULL) }, |
2149 | { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xf900, |
2150 | &af9035_props, "Hauppauge WinTV-MiniStick 2" , NULL) }, |
2151 | { DVB_USB_DEVICE(USB_VID_PCTV, USB_PID_PCTV_78E, |
2152 | &af9035_props, "PCTV AndroiDTV (78e)" , RC_MAP_IT913X_V1) }, |
2153 | { DVB_USB_DEVICE(USB_VID_PCTV, USB_PID_PCTV_79E, |
2154 | &af9035_props, "PCTV microStick (79e)" , RC_MAP_IT913X_V2) }, |
2155 | |
2156 | /* IT930x devices */ |
2157 | { DVB_USB_DEVICE(USB_VID_ITETECH, USB_PID_ITETECH_IT9303, |
2158 | &it930x_props, "ITE 9303 Generic" , NULL) }, |
2159 | { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_TD310, |
2160 | &it930x_props, "AVerMedia TD310 DVB-T2" , NULL) }, |
2161 | { DVB_USB_DEVICE(USB_VID_DEXATEK, 0x0100, |
2162 | &it930x_props, "Logilink VG0022A" , NULL) }, |
2163 | { DVB_USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_TC2_STICK, |
2164 | &it930x_props, "TerraTec Cinergy TC2 Stick" , NULL) }, |
2165 | { } |
2166 | }; |
2167 | MODULE_DEVICE_TABLE(usb, af9035_id_table); |
2168 | |
2169 | static struct usb_driver af9035_usb_driver = { |
2170 | .name = KBUILD_MODNAME, |
2171 | .id_table = af9035_id_table, |
2172 | .probe = af9035_probe, |
2173 | .disconnect = dvb_usbv2_disconnect, |
2174 | .suspend = dvb_usbv2_suspend, |
2175 | .resume = dvb_usbv2_resume, |
2176 | .reset_resume = dvb_usbv2_reset_resume, |
2177 | .no_dynamic_id = 1, |
2178 | .soft_unbind = 1, |
2179 | }; |
2180 | |
2181 | module_usb_driver(af9035_usb_driver); |
2182 | |
2183 | MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>" ); |
2184 | MODULE_DESCRIPTION("Afatech AF9035 driver" ); |
2185 | MODULE_LICENSE("GPL" ); |
2186 | MODULE_FIRMWARE(AF9035_FIRMWARE_AF9035); |
2187 | MODULE_FIRMWARE(AF9035_FIRMWARE_IT9135_V1); |
2188 | MODULE_FIRMWARE(AF9035_FIRMWARE_IT9135_V2); |
2189 | MODULE_FIRMWARE(AF9035_FIRMWARE_IT9303); |
2190 | |