Commit | Line | Data |
---|---|---|
7f882c2e AP |
1 | /* |
2 | * Afatech AF9035 DVB USB driver | |
3 | * | |
4 | * Copyright (C) 2009 Antti Palosaari <crope@iki.fi> | |
5 | * Copyright (C) 2012 Antti Palosaari <crope@iki.fi> | |
6 | * | |
7 | * This program is free software; you can redistribute it and/or modify | |
8 | * it under the terms of the GNU General Public License as published by | |
9 | * the Free Software Foundation; either version 2 of the License, or | |
10 | * (at your option) any later version. | |
11 | * | |
12 | * This program is distributed in the hope that it will be useful, | |
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | * GNU General Public License for more details. | |
16 | * | |
17 | * You should have received a copy of the GNU General Public License along | |
18 | * with this program; if not, write to the Free Software Foundation, Inc., | |
19 | * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. | |
20 | */ | |
21 | ||
22 | #include "af9035.h" | |
7f882c2e | 23 | |
7760e148 MCC |
24 | /* Max transfer size done by I2C transfer functions */ |
25 | #define MAX_XFER_SIZE 64 | |
26 | ||
7f882c2e | 27 | DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); |
7f882c2e | 28 | |
b1a9599a MB |
29 | static u16 af9035_checksum(const u8 *buf, size_t len) |
30 | { | |
31 | size_t i; | |
32 | u16 checksum = 0; | |
33 | ||
34 | for (i = 1; i < len; i++) { | |
35 | if (i % 2) | |
36 | checksum += buf[i] << 8; | |
37 | else | |
38 | checksum += buf[i]; | |
39 | } | |
40 | checksum = ~checksum; | |
41 | ||
42 | return checksum; | |
43 | } | |
44 | ||
5da2aecb | 45 | static int af9035_ctrl_msg(struct dvb_usb_device *d, struct usb_req *req) |
7f882c2e | 46 | { |
7f882c2e AP |
47 | #define REQ_HDR_LEN 4 /* send header size */ |
48 | #define ACK_HDR_LEN 3 /* rece header size */ | |
49 | #define CHECKSUM_LEN 2 | |
50 | #define USB_TIMEOUT 2000 | |
5da2aecb AP |
51 | struct state *state = d_to_priv(d); |
52 | int ret, wlen, rlen; | |
6fb39c50 | 53 | u16 checksum, tmp_checksum; |
7f882c2e | 54 | |
3484d37a AP |
55 | mutex_lock(&d->usb_mutex); |
56 | ||
7f882c2e AP |
57 | /* buffer overflow check */ |
58 | if (req->wlen > (BUF_LEN - REQ_HDR_LEN - CHECKSUM_LEN) || | |
119f7a8c AP |
59 | req->rlen > (BUF_LEN - ACK_HDR_LEN - CHECKSUM_LEN)) { |
60 | dev_err(&d->udev->dev, "%s: too much data wlen=%d rlen=%d\n", | |
e8292e28 | 61 | KBUILD_MODNAME, req->wlen, req->rlen); |
3484d37a | 62 | ret = -EINVAL; |
0170a39b | 63 | goto exit; |
7f882c2e AP |
64 | } |
65 | ||
3484d37a AP |
66 | state->buf[0] = REQ_HDR_LEN + req->wlen + CHECKSUM_LEN - 1; |
67 | state->buf[1] = req->mbox; | |
68 | state->buf[2] = req->cmd; | |
69 | state->buf[3] = state->seq++; | |
70 | memcpy(&state->buf[REQ_HDR_LEN], req->wbuf, req->wlen); | |
5da2aecb AP |
71 | |
72 | wlen = REQ_HDR_LEN + req->wlen + CHECKSUM_LEN; | |
73 | rlen = ACK_HDR_LEN + req->rlen + CHECKSUM_LEN; | |
7f882c2e AP |
74 | |
75 | /* calc and add checksum */ | |
3484d37a AP |
76 | checksum = af9035_checksum(state->buf, state->buf[0] - 1); |
77 | state->buf[state->buf[0] - 1] = (checksum >> 8); | |
78 | state->buf[state->buf[0] - 0] = (checksum & 0xff); | |
7f882c2e | 79 | |
5da2aecb AP |
80 | /* no ack for these packets */ |
81 | if (req->cmd == CMD_FW_DL) | |
82 | rlen = 0; | |
7f882c2e | 83 | |
3484d37a AP |
84 | ret = dvb_usbv2_generic_rw_locked(d, |
85 | state->buf, wlen, state->buf, rlen); | |
5da2aecb | 86 | if (ret) |
0170a39b | 87 | goto exit; |
7f882c2e AP |
88 | |
89 | /* no ack for those packets */ | |
90 | if (req->cmd == CMD_FW_DL) | |
5da2aecb | 91 | goto exit; |
7f882c2e | 92 | |
b1a9599a | 93 | /* verify checksum */ |
3484d37a AP |
94 | checksum = af9035_checksum(state->buf, rlen - 2); |
95 | tmp_checksum = (state->buf[rlen - 2] << 8) | state->buf[rlen - 1]; | |
6fb39c50 | 96 | if (tmp_checksum != checksum) { |
cb9114e9 AP |
97 | dev_err(&d->udev->dev, |
98 | "%s: command=%02x checksum mismatch (%04x != %04x)\n", | |
99 | KBUILD_MODNAME, req->cmd, tmp_checksum, | |
100 | checksum); | |
b1a9599a | 101 | ret = -EIO; |
0170a39b | 102 | goto exit; |
b1a9599a | 103 | } |
6fb39c50 | 104 | |
7f882c2e | 105 | /* check status */ |
3484d37a | 106 | if (state->buf[2]) { |
1bfd5294 | 107 | /* fw returns status 1 when IR code was not received */ |
0170a39b WY |
108 | if (req->cmd == CMD_IR_GET || state->buf[2] == 1) { |
109 | ret = 1; | |
110 | goto exit; | |
111 | } | |
1bfd5294 | 112 | |
119f7a8c | 113 | dev_dbg(&d->udev->dev, "%s: command=%02x failed fw error=%d\n", |
3484d37a | 114 | __func__, req->cmd, state->buf[2]); |
7f882c2e | 115 | ret = -EIO; |
0170a39b | 116 | goto exit; |
7f882c2e AP |
117 | } |
118 | ||
119 | /* read request, copy returned data to return buf */ | |
120 | if (req->rlen) | |
3484d37a | 121 | memcpy(req->rbuf, &state->buf[ACK_HDR_LEN], req->rlen); |
5da2aecb | 122 | exit: |
3484d37a | 123 | mutex_unlock(&d->usb_mutex); |
0170a39b | 124 | if (ret < 0) |
3484d37a | 125 | dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret); |
7f882c2e AP |
126 | return ret; |
127 | } | |
128 | ||
129 | /* write multiple registers */ | |
130 | static int af9035_wr_regs(struct dvb_usb_device *d, u32 reg, u8 *val, int len) | |
131 | { | |
7760e148 | 132 | u8 wbuf[MAX_XFER_SIZE]; |
7f882c2e | 133 | u8 mbox = (reg >> 16) & 0xff; |
9323297d | 134 | struct usb_req req = { CMD_MEM_WR, mbox, 6 + len, wbuf, 0, NULL }; |
7f882c2e | 135 | |
7760e148 MCC |
136 | if (6 + len > sizeof(wbuf)) { |
137 | dev_warn(&d->udev->dev, "%s: i2c wr: len=%d is too big!\n", | |
138 | KBUILD_MODNAME, len); | |
139 | return -EOPNOTSUPP; | |
140 | } | |
141 | ||
7f882c2e AP |
142 | wbuf[0] = len; |
143 | wbuf[1] = 2; | |
144 | wbuf[2] = 0; | |
145 | wbuf[3] = 0; | |
146 | wbuf[4] = (reg >> 8) & 0xff; | |
147 | wbuf[5] = (reg >> 0) & 0xff; | |
148 | memcpy(&wbuf[6], val, len); | |
149 | ||
5da2aecb | 150 | return af9035_ctrl_msg(d, &req); |
7f882c2e AP |
151 | } |
152 | ||
153 | /* read multiple registers */ | |
154 | static int af9035_rd_regs(struct dvb_usb_device *d, u32 reg, u8 *val, int len) | |
155 | { | |
156 | u8 wbuf[] = { len, 2, 0, 0, (reg >> 8) & 0xff, reg & 0xff }; | |
157 | u8 mbox = (reg >> 16) & 0xff; | |
158 | struct usb_req req = { CMD_MEM_RD, mbox, sizeof(wbuf), wbuf, len, val }; | |
159 | ||
5da2aecb | 160 | return af9035_ctrl_msg(d, &req); |
7f882c2e AP |
161 | } |
162 | ||
163 | /* write single register */ | |
164 | static int af9035_wr_reg(struct dvb_usb_device *d, u32 reg, u8 val) | |
165 | { | |
166 | return af9035_wr_regs(d, reg, &val, 1); | |
167 | } | |
168 | ||
169 | /* read single register */ | |
170 | static int af9035_rd_reg(struct dvb_usb_device *d, u32 reg, u8 *val) | |
171 | { | |
172 | return af9035_rd_regs(d, reg, val, 1); | |
173 | } | |
174 | ||
175 | /* write single register with mask */ | |
176 | static int af9035_wr_reg_mask(struct dvb_usb_device *d, u32 reg, u8 val, | |
177 | u8 mask) | |
178 | { | |
179 | int ret; | |
180 | u8 tmp; | |
181 | ||
182 | /* no need for read if whole reg is written */ | |
183 | if (mask != 0xff) { | |
184 | ret = af9035_rd_regs(d, reg, &tmp, 1); | |
185 | if (ret) | |
186 | return ret; | |
187 | ||
188 | val &= mask; | |
189 | tmp &= ~mask; | |
190 | val |= tmp; | |
191 | } | |
192 | ||
193 | return af9035_wr_regs(d, reg, &val, 1); | |
194 | } | |
195 | ||
3b2a5e8c AP |
196 | static int af9035_add_i2c_dev(struct dvb_usb_device *d, char *type, u8 addr, |
197 | void *platform_data) | |
198 | { | |
199 | int ret, num; | |
200 | struct state *state = d_to_priv(d); | |
201 | struct i2c_client *client; | |
202 | struct i2c_adapter *adapter = &d->i2c_adap; | |
203 | struct i2c_board_info board_info = { | |
204 | .addr = addr, | |
205 | .platform_data = platform_data, | |
206 | }; | |
207 | ||
208 | strlcpy(board_info.type, type, I2C_NAME_SIZE); | |
209 | ||
210 | /* find first free client */ | |
211 | for (num = 0; num < AF9035_I2C_CLIENT_MAX; num++) { | |
212 | if (state->i2c_client[num] == NULL) | |
213 | break; | |
214 | } | |
215 | ||
216 | dev_dbg(&d->udev->dev, "%s: num=%d\n", __func__, num); | |
217 | ||
218 | if (num == AF9035_I2C_CLIENT_MAX) { | |
219 | dev_err(&d->udev->dev, "%s: I2C client out of index\n", | |
220 | KBUILD_MODNAME); | |
221 | ret = -ENODEV; | |
222 | goto err; | |
223 | } | |
224 | ||
225 | request_module(board_info.type); | |
226 | ||
227 | /* register I2C device */ | |
228 | client = i2c_new_device(adapter, &board_info); | |
229 | if (client == NULL || client->dev.driver == NULL) { | |
230 | ret = -ENODEV; | |
231 | goto err; | |
232 | } | |
233 | ||
234 | /* increase I2C driver usage count */ | |
235 | if (!try_module_get(client->dev.driver->owner)) { | |
236 | i2c_unregister_device(client); | |
237 | ret = -ENODEV; | |
238 | goto err; | |
239 | } | |
240 | ||
241 | state->i2c_client[num] = client; | |
242 | return 0; | |
243 | err: | |
244 | dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret); | |
245 | return ret; | |
246 | } | |
247 | ||
248 | static void af9035_del_i2c_dev(struct dvb_usb_device *d) | |
249 | { | |
250 | int num; | |
251 | struct state *state = d_to_priv(d); | |
252 | struct i2c_client *client; | |
253 | ||
254 | /* find last used client */ | |
255 | num = AF9035_I2C_CLIENT_MAX; | |
256 | while (num--) { | |
257 | if (state->i2c_client[num] != NULL) | |
258 | break; | |
259 | } | |
260 | ||
261 | dev_dbg(&d->udev->dev, "%s: num=%d\n", __func__, num); | |
262 | ||
263 | if (num == -1) { | |
264 | dev_err(&d->udev->dev, "%s: I2C client out of index\n", | |
265 | KBUILD_MODNAME); | |
266 | goto err; | |
267 | } | |
268 | ||
269 | client = state->i2c_client[num]; | |
270 | ||
271 | /* decrease I2C driver usage count */ | |
272 | module_put(client->dev.driver->owner); | |
273 | ||
274 | /* unregister I2C device */ | |
275 | i2c_unregister_device(client); | |
276 | ||
277 | state->i2c_client[num] = NULL; | |
278 | return; | |
279 | err: | |
280 | dev_dbg(&d->udev->dev, "%s: failed\n", __func__); | |
281 | } | |
282 | ||
7f882c2e AP |
283 | static int af9035_i2c_master_xfer(struct i2c_adapter *adap, |
284 | struct i2c_msg msg[], int num) | |
285 | { | |
286 | struct dvb_usb_device *d = i2c_get_adapdata(adap); | |
5da2aecb | 287 | struct state *state = d_to_priv(d); |
7f882c2e AP |
288 | int ret; |
289 | ||
290 | if (mutex_lock_interruptible(&d->i2c_mutex) < 0) | |
291 | return -EAGAIN; | |
292 | ||
ad30e91b AP |
293 | /* |
294 | * I2C sub header is 5 bytes long. Meaning of those bytes are: | |
295 | * 0: data len | |
296 | * 1: I2C addr << 1 | |
297 | * 2: reg addr len | |
298 | * byte 3 and 4 can be used as reg addr | |
299 | * 3: reg addr MSB | |
300 | * used when reg addr len is set to 2 | |
301 | * 4: reg addr LSB | |
302 | * used when reg addr len is set to 1 or 2 | |
303 | * | |
304 | * For the simplify we do not use register addr at all. | |
305 | * NOTE: As a firmware knows tuner type there is very small possibility | |
306 | * there could be some tuner I2C hacks done by firmware and this may | |
307 | * lead problems if firmware expects those bytes are used. | |
308 | */ | |
7f882c2e AP |
309 | if (num == 2 && !(msg[0].flags & I2C_M_RD) && |
310 | (msg[1].flags & I2C_M_RD)) { | |
311 | if (msg[0].len > 40 || msg[1].len > 40) { | |
312 | /* TODO: correct limits > 40 */ | |
313 | ret = -EOPNOTSUPP; | |
9805992f JAR |
314 | } else if ((msg[0].addr == state->af9033_config[0].i2c_addr) || |
315 | (msg[0].addr == state->af9033_config[1].i2c_addr)) { | |
bf97b637 | 316 | /* demod access via firmware interface */ |
7f882c2e AP |
317 | u32 reg = msg[0].buf[0] << 16 | msg[0].buf[1] << 8 | |
318 | msg[0].buf[2]; | |
bf97b637 AP |
319 | |
320 | if (msg[0].addr == state->af9033_config[1].i2c_addr) | |
9805992f | 321 | reg |= 0x100000; |
bf97b637 | 322 | |
7f882c2e AP |
323 | ret = af9035_rd_regs(d, reg, &msg[1].buf[0], |
324 | msg[1].len); | |
325 | } else { | |
326 | /* I2C */ | |
7760e148 | 327 | u8 buf[MAX_XFER_SIZE]; |
9323297d | 328 | struct usb_req req = { CMD_I2C_RD, 0, 5 + msg[0].len, |
7f882c2e | 329 | buf, msg[1].len, msg[1].buf }; |
7760e148 MCC |
330 | |
331 | if (5 + msg[0].len > sizeof(buf)) { | |
332 | dev_warn(&d->udev->dev, | |
333 | "%s: i2c xfer: len=%d is too big!\n", | |
334 | KBUILD_MODNAME, msg[0].len); | |
3189ef02 DC |
335 | ret = -EOPNOTSUPP; |
336 | goto unlock; | |
7760e148 | 337 | } |
9805992f | 338 | req.mbox |= ((msg[0].addr & 0x80) >> 3); |
812fe6d9 | 339 | buf[0] = msg[1].len; |
bf97b637 | 340 | buf[1] = msg[0].addr << 1; |
ad30e91b AP |
341 | buf[2] = 0x00; /* reg addr len */ |
342 | buf[3] = 0x00; /* reg addr MSB */ | |
343 | buf[4] = 0x00; /* reg addr LSB */ | |
344 | memcpy(&buf[5], msg[0].buf, msg[0].len); | |
5da2aecb | 345 | ret = af9035_ctrl_msg(d, &req); |
7f882c2e AP |
346 | } |
347 | } else if (num == 1 && !(msg[0].flags & I2C_M_RD)) { | |
348 | if (msg[0].len > 40) { | |
349 | /* TODO: correct limits > 40 */ | |
350 | ret = -EOPNOTSUPP; | |
9805992f JAR |
351 | } else if ((msg[0].addr == state->af9033_config[0].i2c_addr) || |
352 | (msg[0].addr == state->af9033_config[1].i2c_addr)) { | |
bf97b637 | 353 | /* demod access via firmware interface */ |
7f882c2e AP |
354 | u32 reg = msg[0].buf[0] << 16 | msg[0].buf[1] << 8 | |
355 | msg[0].buf[2]; | |
bf97b637 AP |
356 | |
357 | if (msg[0].addr == state->af9033_config[1].i2c_addr) | |
9805992f | 358 | reg |= 0x100000; |
bf97b637 | 359 | |
7f882c2e AP |
360 | ret = af9035_wr_regs(d, reg, &msg[0].buf[3], |
361 | msg[0].len - 3); | |
362 | } else { | |
363 | /* I2C */ | |
7760e148 | 364 | u8 buf[MAX_XFER_SIZE]; |
9323297d AP |
365 | struct usb_req req = { CMD_I2C_WR, 0, 5 + msg[0].len, |
366 | buf, 0, NULL }; | |
7760e148 MCC |
367 | |
368 | if (5 + msg[0].len > sizeof(buf)) { | |
369 | dev_warn(&d->udev->dev, | |
370 | "%s: i2c xfer: len=%d is too big!\n", | |
371 | KBUILD_MODNAME, msg[0].len); | |
3189ef02 DC |
372 | ret = -EOPNOTSUPP; |
373 | goto unlock; | |
7760e148 | 374 | } |
9805992f | 375 | req.mbox |= ((msg[0].addr & 0x80) >> 3); |
7f882c2e | 376 | buf[0] = msg[0].len; |
bf97b637 | 377 | buf[1] = msg[0].addr << 1; |
ad30e91b AP |
378 | buf[2] = 0x00; /* reg addr len */ |
379 | buf[3] = 0x00; /* reg addr MSB */ | |
380 | buf[4] = 0x00; /* reg addr LSB */ | |
381 | memcpy(&buf[5], msg[0].buf, msg[0].len); | |
5da2aecb | 382 | ret = af9035_ctrl_msg(d, &req); |
7f882c2e | 383 | } |
3b98c347 AP |
384 | } else if (num == 1 && (msg[0].flags & I2C_M_RD)) { |
385 | if (msg[0].len > 40) { | |
386 | /* TODO: correct limits > 40 */ | |
387 | ret = -EOPNOTSUPP; | |
388 | } else { | |
389 | /* I2C */ | |
390 | u8 buf[5]; | |
391 | struct usb_req req = { CMD_I2C_RD, 0, sizeof(buf), | |
392 | buf, msg[0].len, msg[0].buf }; | |
393 | req.mbox |= ((msg[0].addr & 0x80) >> 3); | |
394 | buf[0] = msg[0].len; | |
395 | buf[1] = msg[0].addr << 1; | |
396 | buf[2] = 0x00; /* reg addr len */ | |
397 | buf[3] = 0x00; /* reg addr MSB */ | |
398 | buf[4] = 0x00; /* reg addr LSB */ | |
399 | ret = af9035_ctrl_msg(d, &req); | |
400 | } | |
7f882c2e AP |
401 | } else { |
402 | /* | |
3b98c347 AP |
403 | * We support only three kind of I2C transactions: |
404 | * 1) 1 x read + 1 x write (repeated start) | |
7f882c2e | 405 | * 2) 1 x write |
3b98c347 | 406 | * 3) 1 x read |
7f882c2e AP |
407 | */ |
408 | ret = -EOPNOTSUPP; | |
409 | } | |
410 | ||
3189ef02 | 411 | unlock: |
7f882c2e AP |
412 | mutex_unlock(&d->i2c_mutex); |
413 | ||
414 | if (ret < 0) | |
415 | return ret; | |
416 | else | |
417 | return num; | |
418 | } | |
419 | ||
420 | static u32 af9035_i2c_functionality(struct i2c_adapter *adapter) | |
421 | { | |
422 | return I2C_FUNC_I2C; | |
423 | } | |
424 | ||
425 | static struct i2c_algorithm af9035_i2c_algo = { | |
426 | .master_xfer = af9035_i2c_master_xfer, | |
427 | .functionality = af9035_i2c_functionality, | |
428 | }; | |
429 | ||
a0921af7 | 430 | static int af9035_identify_state(struct dvb_usb_device *d, const char **name) |
7f882c2e | 431 | { |
74c1883a | 432 | struct state *state = d_to_priv(d); |
7f882c2e AP |
433 | int ret; |
434 | u8 wbuf[1] = { 1 }; | |
435 | u8 rbuf[4]; | |
436 | struct usb_req req = { CMD_FW_QUERYINFO, 0, sizeof(wbuf), wbuf, | |
437 | sizeof(rbuf), rbuf }; | |
438 | ||
74c1883a AP |
439 | ret = af9035_rd_regs(d, 0x1222, rbuf, 3); |
440 | if (ret < 0) | |
441 | goto err; | |
442 | ||
443 | state->chip_version = rbuf[0]; | |
444 | state->chip_type = rbuf[2] << 8 | rbuf[1] << 0; | |
445 | ||
446 | ret = af9035_rd_reg(d, 0x384f, &state->prechip_version); | |
447 | if (ret < 0) | |
448 | goto err; | |
449 | ||
450 | dev_info(&d->udev->dev, | |
451 | "%s: prechip_version=%02x chip_version=%02x chip_type=%04x\n", | |
e8292e28 AP |
452 | KBUILD_MODNAME, state->prechip_version, |
453 | state->chip_version, state->chip_type); | |
74c1883a AP |
454 | |
455 | if (state->chip_type == 0x9135) { | |
bc3c9e10 | 456 | if (state->chip_version == 0x02) |
74c1883a AP |
457 | *name = AF9035_FIRMWARE_IT9135_V2; |
458 | else | |
459 | *name = AF9035_FIRMWARE_IT9135_V1; | |
df8f1be1 | 460 | state->eeprom_addr = EEPROM_BASE_IT9135; |
74c1883a AP |
461 | } else { |
462 | *name = AF9035_FIRMWARE_AF9035; | |
df8f1be1 | 463 | state->eeprom_addr = EEPROM_BASE_AF9035; |
74c1883a AP |
464 | } |
465 | ||
5da2aecb | 466 | ret = af9035_ctrl_msg(d, &req); |
7f882c2e AP |
467 | if (ret < 0) |
468 | goto err; | |
469 | ||
119f7a8c | 470 | dev_dbg(&d->udev->dev, "%s: reply=%*ph\n", __func__, 4, rbuf); |
7f882c2e | 471 | if (rbuf[0] || rbuf[1] || rbuf[2] || rbuf[3]) |
5da2aecb | 472 | ret = WARM; |
7f882c2e | 473 | else |
5da2aecb | 474 | ret = COLD; |
7f882c2e | 475 | |
5da2aecb | 476 | return ret; |
7f882c2e AP |
477 | |
478 | err: | |
119f7a8c | 479 | dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret); |
7f882c2e AP |
480 | |
481 | return ret; | |
482 | } | |
483 | ||
8229da50 | 484 | static int af9035_download_firmware_old(struct dvb_usb_device *d, |
7f882c2e AP |
485 | const struct firmware *fw) |
486 | { | |
77c5ff2d | 487 | int ret, i, j, len; |
7f882c2e | 488 | u8 wbuf[1]; |
7f882c2e AP |
489 | struct usb_req req = { 0, 0, 0, NULL, 0, NULL }; |
490 | struct usb_req req_fw_dl = { CMD_FW_DL, 0, 0, wbuf, 0, NULL }; | |
df8f1be1 | 491 | u8 hdr_core; |
77c5ff2d | 492 | u16 hdr_addr, hdr_data_len, hdr_checksum; |
6fb39c50 | 493 | #define MAX_DATA 58 |
77c5ff2d AP |
494 | #define HDR_SIZE 7 |
495 | ||
496 | /* | |
497 | * Thanks to Daniel Glöckner <daniel-gl@gmx.net> about that info! | |
498 | * | |
499 | * byte 0: MCS 51 core | |
500 | * There are two inside the AF9035 (1=Link and 2=OFDM) with separate | |
501 | * address spaces | |
502 | * byte 1-2: Big endian destination address | |
503 | * byte 3-4: Big endian number of data bytes following the header | |
504 | * byte 5-6: Big endian header checksum, apparently ignored by the chip | |
505 | * Calculated as ~(h[0]*256+h[1]+h[2]*256+h[3]+h[4]*256) | |
506 | */ | |
507 | ||
508 | for (i = fw->size; i > HDR_SIZE;) { | |
509 | hdr_core = fw->data[fw->size - i + 0]; | |
510 | hdr_addr = fw->data[fw->size - i + 1] << 8; | |
511 | hdr_addr |= fw->data[fw->size - i + 2] << 0; | |
512 | hdr_data_len = fw->data[fw->size - i + 3] << 8; | |
513 | hdr_data_len |= fw->data[fw->size - i + 4] << 0; | |
514 | hdr_checksum = fw->data[fw->size - i + 5] << 8; | |
515 | hdr_checksum |= fw->data[fw->size - i + 6] << 0; | |
516 | ||
cb9114e9 AP |
517 | dev_dbg(&d->udev->dev, |
518 | "%s: core=%d addr=%04x data_len=%d checksum=%04x\n", | |
519 | __func__, hdr_core, hdr_addr, hdr_data_len, | |
520 | hdr_checksum); | |
77c5ff2d AP |
521 | |
522 | if (((hdr_core != 1) && (hdr_core != 2)) || | |
523 | (hdr_data_len > i)) { | |
119f7a8c | 524 | dev_dbg(&d->udev->dev, "%s: bad firmware\n", __func__); |
77c5ff2d AP |
525 | break; |
526 | } | |
7f882c2e | 527 | |
77c5ff2d AP |
528 | /* download begin packet */ |
529 | req.cmd = CMD_FW_DL_BEGIN; | |
5da2aecb | 530 | ret = af9035_ctrl_msg(d, &req); |
41d44a81 AP |
531 | if (ret < 0) |
532 | goto err; | |
77c5ff2d AP |
533 | |
534 | /* download firmware packet(s) */ | |
535 | for (j = HDR_SIZE + hdr_data_len; j > 0; j -= MAX_DATA) { | |
536 | len = j; | |
537 | if (len > MAX_DATA) | |
538 | len = MAX_DATA; | |
539 | req_fw_dl.wlen = len; | |
540 | req_fw_dl.wbuf = (u8 *) &fw->data[fw->size - i + | |
541 | HDR_SIZE + hdr_data_len - j]; | |
5da2aecb | 542 | ret = af9035_ctrl_msg(d, &req_fw_dl); |
77c5ff2d | 543 | if (ret < 0) |
7f882c2e | 544 | goto err; |
7f882c2e | 545 | } |
77c5ff2d AP |
546 | |
547 | /* download end packet */ | |
548 | req.cmd = CMD_FW_DL_END; | |
5da2aecb | 549 | ret = af9035_ctrl_msg(d, &req); |
77c5ff2d AP |
550 | if (ret < 0) |
551 | goto err; | |
552 | ||
553 | i -= hdr_data_len + HDR_SIZE; | |
554 | ||
119f7a8c AP |
555 | dev_dbg(&d->udev->dev, "%s: data uploaded=%zu\n", |
556 | __func__, fw->size - i); | |
7f882c2e AP |
557 | } |
558 | ||
ff4e3fe8 AP |
559 | /* print warn if firmware is bad, continue and see what happens */ |
560 | if (i) | |
561 | dev_warn(&d->udev->dev, "%s: bad firmware\n", KBUILD_MODNAME); | |
562 | ||
7f882c2e AP |
563 | return 0; |
564 | ||
565 | err: | |
119f7a8c | 566 | dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret); |
7f882c2e AP |
567 | |
568 | return ret; | |
569 | } | |
570 | ||
8229da50 | 571 | static int af9035_download_firmware_new(struct dvb_usb_device *d, |
f2b61d0c AP |
572 | const struct firmware *fw) |
573 | { | |
574 | int ret, i, i_prev; | |
f2b61d0c | 575 | struct usb_req req_fw_dl = { CMD_FW_SCATTER_WR, 0, 0, NULL, 0, NULL }; |
f2b61d0c AP |
576 | #define HDR_SIZE 7 |
577 | ||
578 | /* | |
579 | * There seems to be following firmware header. Meaning of bytes 0-3 | |
580 | * is unknown. | |
581 | * | |
582 | * 0: 3 | |
583 | * 1: 0, 1 | |
584 | * 2: 0 | |
585 | * 3: 1, 2, 3 | |
586 | * 4: addr MSB | |
587 | * 5: addr LSB | |
588 | * 6: count of data bytes ? | |
589 | */ | |
f2b61d0c AP |
590 | for (i = HDR_SIZE, i_prev = 0; i <= fw->size; i++) { |
591 | if (i == fw->size || | |
592 | (fw->data[i + 0] == 0x03 && | |
593 | (fw->data[i + 1] == 0x00 || | |
594 | fw->data[i + 1] == 0x01) && | |
595 | fw->data[i + 2] == 0x00)) { | |
596 | req_fw_dl.wlen = i - i_prev; | |
597 | req_fw_dl.wbuf = (u8 *) &fw->data[i_prev]; | |
598 | i_prev = i; | |
5da2aecb | 599 | ret = af9035_ctrl_msg(d, &req_fw_dl); |
f2b61d0c AP |
600 | if (ret < 0) |
601 | goto err; | |
602 | ||
119f7a8c AP |
603 | dev_dbg(&d->udev->dev, "%s: data uploaded=%d\n", |
604 | __func__, i); | |
f2b61d0c AP |
605 | } |
606 | } | |
607 | ||
df8f1be1 AP |
608 | return 0; |
609 | ||
610 | err: | |
611 | dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret); | |
612 | ||
613 | return ret; | |
614 | } | |
615 | ||
616 | static int af9035_download_firmware(struct dvb_usb_device *d, | |
617 | const struct firmware *fw) | |
618 | { | |
619 | struct state *state = d_to_priv(d); | |
620 | int ret; | |
621 | u8 wbuf[1]; | |
622 | u8 rbuf[4]; | |
623 | u8 tmp; | |
624 | struct usb_req req = { 0, 0, 0, NULL, 0, NULL }; | |
cb9114e9 | 625 | struct usb_req req_fw_ver = { CMD_FW_QUERYINFO, 0, 1, wbuf, 4, rbuf }; |
c10989a2 | 626 | |
df8f1be1 AP |
627 | dev_dbg(&d->udev->dev, "%s:\n", __func__); |
628 | ||
629 | /* | |
630 | * In case of dual tuner configuration we need to do some extra | |
631 | * initialization in order to download firmware to slave demod too, | |
632 | * which is done by master demod. | |
633 | * Master feeds also clock and controls power via GPIO. | |
634 | */ | |
d716ef46 | 635 | ret = af9035_rd_reg(d, state->eeprom_addr + EEPROM_TS_MODE, &tmp); |
df8f1be1 AP |
636 | if (ret < 0) |
637 | goto err; | |
638 | ||
d716ef46 | 639 | if (tmp == 1 || tmp == 3) { |
df8f1be1 AP |
640 | /* configure gpioh1, reset & power slave demod */ |
641 | ret = af9035_wr_reg_mask(d, 0x00d8b0, 0x01, 0x01); | |
642 | if (ret < 0) | |
643 | goto err; | |
644 | ||
645 | ret = af9035_wr_reg_mask(d, 0x00d8b1, 0x01, 0x01); | |
646 | if (ret < 0) | |
647 | goto err; | |
648 | ||
649 | ret = af9035_wr_reg_mask(d, 0x00d8af, 0x00, 0x01); | |
650 | if (ret < 0) | |
651 | goto err; | |
652 | ||
653 | usleep_range(10000, 50000); | |
654 | ||
655 | ret = af9035_wr_reg_mask(d, 0x00d8af, 0x01, 0x01); | |
656 | if (ret < 0) | |
657 | goto err; | |
658 | ||
659 | /* tell the slave I2C address */ | |
660 | ret = af9035_rd_reg(d, | |
661 | state->eeprom_addr + EEPROM_2ND_DEMOD_ADDR, | |
662 | &tmp); | |
663 | if (ret < 0) | |
664 | goto err; | |
665 | ||
14992f01 AP |
666 | /* use default I2C address if eeprom has no address set */ |
667 | if (!tmp) | |
668 | tmp = 0x3a; | |
a1310ff4 | 669 | |
14992f01 | 670 | if (state->chip_type == 0x9135) { |
df8f1be1 AP |
671 | ret = af9035_wr_reg(d, 0x004bfb, tmp); |
672 | if (ret < 0) | |
673 | goto err; | |
674 | } else { | |
675 | ret = af9035_wr_reg(d, 0x00417f, tmp); | |
676 | if (ret < 0) | |
677 | goto err; | |
678 | ||
679 | /* enable clock out */ | |
680 | ret = af9035_wr_reg_mask(d, 0x00d81a, 0x01, 0x01); | |
681 | if (ret < 0) | |
682 | goto err; | |
683 | } | |
684 | } | |
685 | ||
8229da50 AP |
686 | if (fw->data[0] == 0x01) |
687 | ret = af9035_download_firmware_old(d, fw); | |
df8f1be1 | 688 | else |
8229da50 | 689 | ret = af9035_download_firmware_new(d, fw); |
df8f1be1 AP |
690 | if (ret < 0) |
691 | goto err; | |
692 | ||
f2b61d0c AP |
693 | /* firmware loaded, request boot */ |
694 | req.cmd = CMD_FW_BOOT; | |
5da2aecb | 695 | ret = af9035_ctrl_msg(d, &req); |
f2b61d0c AP |
696 | if (ret < 0) |
697 | goto err; | |
698 | ||
699 | /* ensure firmware starts */ | |
700 | wbuf[0] = 1; | |
5da2aecb | 701 | ret = af9035_ctrl_msg(d, &req_fw_ver); |
f2b61d0c AP |
702 | if (ret < 0) |
703 | goto err; | |
704 | ||
705 | if (!(rbuf[0] || rbuf[1] || rbuf[2] || rbuf[3])) { | |
119f7a8c AP |
706 | dev_err(&d->udev->dev, "%s: firmware did not run\n", |
707 | KBUILD_MODNAME); | |
f2b61d0c AP |
708 | ret = -ENODEV; |
709 | goto err; | |
710 | } | |
711 | ||
119f7a8c AP |
712 | dev_info(&d->udev->dev, "%s: firmware version=%d.%d.%d.%d", |
713 | KBUILD_MODNAME, rbuf[0], rbuf[1], rbuf[2], rbuf[3]); | |
f2b61d0c AP |
714 | |
715 | return 0; | |
716 | ||
717 | err: | |
119f7a8c | 718 | dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret); |
f2b61d0c AP |
719 | |
720 | return ret; | |
721 | } | |
722 | ||
9ea3681d | 723 | static int af9035_read_config(struct dvb_usb_device *d) |
7f882c2e | 724 | { |
5da2aecb | 725 | struct state *state = d_to_priv(d); |
9ea3681d | 726 | int ret, i; |
7f882c2e | 727 | u8 tmp; |
9ea3681d | 728 | u16 tmp16, addr; |
7f882c2e | 729 | |
bf97b637 AP |
730 | /* demod I2C "address" */ |
731 | state->af9033_config[0].i2c_addr = 0x38; | |
14992f01 | 732 | state->af9033_config[1].i2c_addr = 0x3a; |
0d94d6a0 | 733 | state->af9033_config[0].adc_multiplier = AF9033_ADC_MULTIPLIER_2X; |
df8f1be1 | 734 | state->af9033_config[1].adc_multiplier = AF9033_ADC_MULTIPLIER_2X; |
ab56ad6a AP |
735 | state->af9033_config[0].ts_mode = AF9033_TS_MODE_USB; |
736 | state->af9033_config[1].ts_mode = AF9033_TS_MODE_SERIAL; | |
bf97b637 | 737 | |
9ea3681d | 738 | if (state->chip_type == 0x9135) { |
15ba8202 AP |
739 | /* feed clock for integrated RF tuner */ |
740 | state->af9033_config[0].dyn0_clk = true; | |
741 | state->af9033_config[1].dyn0_clk = true; | |
742 | ||
bc3c9e10 AP |
743 | if (state->chip_version == 0x02) { |
744 | state->af9033_config[0].tuner = AF9033_TUNER_IT9135_60; | |
df8f1be1 | 745 | state->af9033_config[1].tuner = AF9033_TUNER_IT9135_60; |
15ba8202 | 746 | tmp16 = 0x00461d; /* eeprom memory mapped location */ |
bc3c9e10 AP |
747 | } else { |
748 | state->af9033_config[0].tuner = AF9033_TUNER_IT9135_38; | |
df8f1be1 | 749 | state->af9033_config[1].tuner = AF9033_TUNER_IT9135_38; |
15ba8202 | 750 | tmp16 = 0x00461b; /* eeprom memory mapped location */ |
bc3c9e10 AP |
751 | } |
752 | ||
9ea3681d | 753 | /* check if eeprom exists */ |
bc3c9e10 | 754 | ret = af9035_rd_reg(d, tmp16, &tmp); |
9ea3681d AP |
755 | if (ret < 0) |
756 | goto err; | |
757 | ||
431a6d4a | 758 | if (tmp == 0x00) { |
bc3c9e10 | 759 | dev_dbg(&d->udev->dev, "%s: no eeprom\n", __func__); |
9ea3681d AP |
760 | goto skip_eeprom; |
761 | } | |
9ea3681d AP |
762 | } |
763 | ||
7f882c2e | 764 | /* check if there is dual tuners */ |
d716ef46 | 765 | ret = af9035_rd_reg(d, state->eeprom_addr + EEPROM_TS_MODE, &tmp); |
7f882c2e AP |
766 | if (ret < 0) |
767 | goto err; | |
768 | ||
d716ef46 AP |
769 | if (tmp == 1 || tmp == 3) |
770 | state->dual_mode = true; | |
771 | ||
772 | dev_dbg(&d->udev->dev, "%s: ts mode=%d dual mode=%d\n", __func__, | |
773 | tmp, state->dual_mode); | |
7f882c2e | 774 | |
9805992f JAR |
775 | if (state->dual_mode) { |
776 | /* read 2nd demodulator I2C address */ | |
431a6d4a AP |
777 | ret = af9035_rd_reg(d, |
778 | state->eeprom_addr + EEPROM_2ND_DEMOD_ADDR, | |
779 | &tmp); | |
9805992f JAR |
780 | if (ret < 0) |
781 | goto err; | |
bf97b637 | 782 | |
14992f01 AP |
783 | if (tmp) |
784 | state->af9033_config[1].i2c_addr = tmp; | |
a1310ff4 | 785 | |
bf97b637 AP |
786 | dev_dbg(&d->udev->dev, "%s: 2nd demod I2C addr=%02x\n", |
787 | __func__, tmp); | |
9805992f JAR |
788 | } |
789 | ||
431a6d4a AP |
790 | addr = state->eeprom_addr; |
791 | ||
5da2aecb | 792 | for (i = 0; i < state->dual_mode + 1; i++) { |
7f882c2e | 793 | /* tuner */ |
9ea3681d | 794 | ret = af9035_rd_reg(d, addr + EEPROM_1_TUNER_ID, &tmp); |
7f882c2e AP |
795 | if (ret < 0) |
796 | goto err; | |
797 | ||
1cbbf90d AP |
798 | dev_dbg(&d->udev->dev, "%s: [%d]tuner=%02x\n", |
799 | __func__, i, tmp); | |
800 | ||
801 | /* tuner sanity check */ | |
802 | if (state->chip_type == 0x9135) { | |
803 | if (state->chip_version == 0x02) { | |
804 | /* IT9135 BX (v2) */ | |
805 | switch (tmp) { | |
806 | case AF9033_TUNER_IT9135_60: | |
807 | case AF9033_TUNER_IT9135_61: | |
808 | case AF9033_TUNER_IT9135_62: | |
809 | state->af9033_config[i].tuner = tmp; | |
810 | break; | |
811 | } | |
812 | } else { | |
813 | /* IT9135 AX (v1) */ | |
814 | switch (tmp) { | |
815 | case AF9033_TUNER_IT9135_38: | |
816 | case AF9033_TUNER_IT9135_51: | |
817 | case AF9033_TUNER_IT9135_52: | |
818 | state->af9033_config[i].tuner = tmp; | |
819 | break; | |
820 | } | |
821 | } | |
822 | } else { | |
823 | /* AF9035 */ | |
bc3c9e10 | 824 | state->af9033_config[i].tuner = tmp; |
1cbbf90d | 825 | } |
7f882c2e | 826 | |
1cbbf90d AP |
827 | if (state->af9033_config[i].tuner != tmp) { |
828 | dev_info(&d->udev->dev, | |
829 | "%s: [%d] overriding tuner from %02x to %02x\n", | |
830 | KBUILD_MODNAME, i, tmp, | |
831 | state->af9033_config[i].tuner); | |
832 | } | |
9ea3681d AP |
833 | |
834 | switch (state->af9033_config[i].tuner) { | |
7f882c2e | 835 | case AF9033_TUNER_TUA9001: |
ffc501f6 | 836 | case AF9033_TUNER_FC0011: |
540fd4ba | 837 | case AF9033_TUNER_MXL5007T: |
ce1fe379 | 838 | case AF9033_TUNER_TDA18218: |
d67ceb33 | 839 | case AF9033_TUNER_FC2580: |
7e0bc296 | 840 | case AF9033_TUNER_FC0012: |
2a79eefa | 841 | state->af9033_config[i].spec_inv = 1; |
7f882c2e | 842 | break; |
9ea3681d AP |
843 | case AF9033_TUNER_IT9135_38: |
844 | case AF9033_TUNER_IT9135_51: | |
845 | case AF9033_TUNER_IT9135_52: | |
846 | case AF9033_TUNER_IT9135_60: | |
847 | case AF9033_TUNER_IT9135_61: | |
848 | case AF9033_TUNER_IT9135_62: | |
849 | break; | |
7f882c2e | 850 | default: |
9ea3681d AP |
851 | dev_warn(&d->udev->dev, |
852 | "%s: tuner id=%02x not supported, please report!", | |
119f7a8c | 853 | KBUILD_MODNAME, tmp); |
c2c1b415 | 854 | } |
7f882c2e | 855 | |
bf97b637 AP |
856 | /* disable dual mode if driver does not support it */ |
857 | if (i == 1) | |
df8f1be1 | 858 | switch (state->af9033_config[i].tuner) { |
0bb3d8ac | 859 | case AF9033_TUNER_FC0012: |
df8f1be1 AP |
860 | case AF9033_TUNER_IT9135_38: |
861 | case AF9033_TUNER_IT9135_51: | |
862 | case AF9033_TUNER_IT9135_52: | |
863 | case AF9033_TUNER_IT9135_60: | |
864 | case AF9033_TUNER_IT9135_61: | |
865 | case AF9033_TUNER_IT9135_62: | |
78c7bc4b | 866 | case AF9033_TUNER_MXL5007T: |
0bb3d8ac | 867 | break; |
bf97b637 AP |
868 | default: |
869 | state->dual_mode = false; | |
9ea3681d AP |
870 | dev_info(&d->udev->dev, |
871 | "%s: driver does not support 2nd tuner and will disable it", | |
872 | KBUILD_MODNAME); | |
bf97b637 AP |
873 | } |
874 | ||
7f882c2e | 875 | /* tuner IF frequency */ |
9ea3681d | 876 | ret = af9035_rd_reg(d, addr + EEPROM_1_IF_L, &tmp); |
7f882c2e AP |
877 | if (ret < 0) |
878 | goto err; | |
879 | ||
880 | tmp16 = tmp; | |
881 | ||
9ea3681d | 882 | ret = af9035_rd_reg(d, addr + EEPROM_1_IF_H, &tmp); |
7f882c2e AP |
883 | if (ret < 0) |
884 | goto err; | |
885 | ||
886 | tmp16 |= tmp << 8; | |
887 | ||
119f7a8c | 888 | dev_dbg(&d->udev->dev, "%s: [%d]IF=%d\n", __func__, i, tmp16); |
7f882c2e | 889 | |
9ea3681d | 890 | addr += 0x10; /* shift for the 2nd tuner params */ |
7f882c2e AP |
891 | } |
892 | ||
9ea3681d | 893 | skip_eeprom: |
7f882c2e AP |
894 | /* get demod clock */ |
895 | ret = af9035_rd_reg(d, 0x00d800, &tmp); | |
896 | if (ret < 0) | |
897 | goto err; | |
898 | ||
899 | tmp = (tmp >> 0) & 0x0f; | |
900 | ||
9ea3681d AP |
901 | for (i = 0; i < ARRAY_SIZE(state->af9033_config); i++) { |
902 | if (state->chip_type == 0x9135) | |
903 | state->af9033_config[i].clock = clock_lut_it9135[tmp]; | |
904 | else | |
905 | state->af9033_config[i].clock = clock_lut_af9035[tmp]; | |
74c1883a AP |
906 | } |
907 | ||
f2b61d0c AP |
908 | return 0; |
909 | ||
910 | err: | |
119f7a8c | 911 | dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret); |
f2b61d0c AP |
912 | |
913 | return ret; | |
914 | } | |
915 | ||
51639be3 AP |
916 | static int af9035_tua9001_tuner_callback(struct dvb_usb_device *d, |
917 | int cmd, int arg) | |
918 | { | |
919 | int ret; | |
920 | u8 val; | |
921 | ||
922 | dev_dbg(&d->udev->dev, "%s: cmd=%d arg=%d\n", __func__, cmd, arg); | |
923 | ||
924 | /* | |
925 | * CEN always enabled by hardware wiring | |
926 | * RESETN GPIOT3 | |
927 | * RXEN GPIOT2 | |
928 | */ | |
929 | ||
930 | switch (cmd) { | |
931 | case TUA9001_CMD_RESETN: | |
932 | if (arg) | |
933 | val = 0x00; | |
934 | else | |
935 | val = 0x01; | |
936 | ||
937 | ret = af9035_wr_reg_mask(d, 0x00d8e7, val, 0x01); | |
938 | if (ret < 0) | |
939 | goto err; | |
940 | break; | |
941 | case TUA9001_CMD_RXEN: | |
942 | if (arg) | |
943 | val = 0x01; | |
944 | else | |
945 | val = 0x00; | |
946 | ||
947 | ret = af9035_wr_reg_mask(d, 0x00d8eb, val, 0x01); | |
948 | if (ret < 0) | |
949 | goto err; | |
950 | break; | |
951 | } | |
952 | ||
953 | return 0; | |
954 | ||
955 | err: | |
956 | dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret); | |
957 | ||
958 | return ret; | |
959 | } | |
960 | ||
961 | ||
ffc501f6 | 962 | static int af9035_fc0011_tuner_callback(struct dvb_usb_device *d, |
daacd5b2 | 963 | int cmd, int arg) |
ffc501f6 | 964 | { |
daacd5b2 | 965 | int ret; |
ffc501f6 MB |
966 | |
967 | switch (cmd) { | |
968 | case FC0011_FE_CALLBACK_POWER: | |
969 | /* Tuner enable */ | |
daacd5b2 AP |
970 | ret = af9035_wr_reg_mask(d, 0xd8eb, 1, 1); |
971 | if (ret < 0) | |
972 | goto err; | |
973 | ||
974 | ret = af9035_wr_reg_mask(d, 0xd8ec, 1, 1); | |
975 | if (ret < 0) | |
976 | goto err; | |
977 | ||
978 | ret = af9035_wr_reg_mask(d, 0xd8ed, 1, 1); | |
979 | if (ret < 0) | |
980 | goto err; | |
981 | ||
ffc501f6 | 982 | /* LED */ |
daacd5b2 AP |
983 | ret = af9035_wr_reg_mask(d, 0xd8d0, 1, 1); |
984 | if (ret < 0) | |
985 | goto err; | |
986 | ||
987 | ret = af9035_wr_reg_mask(d, 0xd8d1, 1, 1); | |
988 | if (ret < 0) | |
989 | goto err; | |
990 | ||
de2bec5e | 991 | usleep_range(10000, 50000); |
ffc501f6 MB |
992 | break; |
993 | case FC0011_FE_CALLBACK_RESET: | |
daacd5b2 AP |
994 | ret = af9035_wr_reg(d, 0xd8e9, 1); |
995 | if (ret < 0) | |
996 | goto err; | |
997 | ||
998 | ret = af9035_wr_reg(d, 0xd8e8, 1); | |
999 | if (ret < 0) | |
1000 | goto err; | |
1001 | ||
1002 | ret = af9035_wr_reg(d, 0xd8e7, 1); | |
1003 | if (ret < 0) | |
1004 | goto err; | |
1005 | ||
de2bec5e | 1006 | usleep_range(10000, 20000); |
daacd5b2 AP |
1007 | |
1008 | ret = af9035_wr_reg(d, 0xd8e7, 0); | |
1009 | if (ret < 0) | |
1010 | goto err; | |
1011 | ||
de2bec5e | 1012 | usleep_range(10000, 20000); |
ffc501f6 MB |
1013 | break; |
1014 | default: | |
daacd5b2 AP |
1015 | ret = -EINVAL; |
1016 | goto err; | |
ffc501f6 MB |
1017 | } |
1018 | ||
1019 | return 0; | |
daacd5b2 AP |
1020 | |
1021 | err: | |
119f7a8c | 1022 | dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret); |
daacd5b2 AP |
1023 | |
1024 | return ret; | |
ffc501f6 MB |
1025 | } |
1026 | ||
1027 | static int af9035_tuner_callback(struct dvb_usb_device *d, int cmd, int arg) | |
1028 | { | |
5da2aecb | 1029 | struct state *state = d_to_priv(d); |
2a79eefa AP |
1030 | |
1031 | switch (state->af9033_config[0].tuner) { | |
ffc501f6 MB |
1032 | case AF9033_TUNER_FC0011: |
1033 | return af9035_fc0011_tuner_callback(d, cmd, arg); | |
51639be3 AP |
1034 | case AF9033_TUNER_TUA9001: |
1035 | return af9035_tua9001_tuner_callback(d, cmd, arg); | |
ffc501f6 MB |
1036 | default: |
1037 | break; | |
1038 | } | |
1039 | ||
1835af10 | 1040 | return 0; |
ffc501f6 MB |
1041 | } |
1042 | ||
1043 | static int af9035_frontend_callback(void *adapter_priv, int component, | |
1044 | int cmd, int arg) | |
1045 | { | |
1046 | struct i2c_adapter *adap = adapter_priv; | |
1047 | struct dvb_usb_device *d = i2c_get_adapdata(adap); | |
1048 | ||
1835af10 AP |
1049 | dev_dbg(&d->udev->dev, "%s: component=%d cmd=%d arg=%d\n", |
1050 | __func__, component, cmd, arg); | |
1051 | ||
ffc501f6 MB |
1052 | switch (component) { |
1053 | case DVB_FRONTEND_COMPONENT_TUNER: | |
1054 | return af9035_tuner_callback(d, cmd, arg); | |
1055 | default: | |
1056 | break; | |
1057 | } | |
1058 | ||
1835af10 | 1059 | return 0; |
ffc501f6 MB |
1060 | } |
1061 | ||
9805992f JAR |
1062 | static int af9035_get_adapter_count(struct dvb_usb_device *d) |
1063 | { | |
1064 | struct state *state = d_to_priv(d); | |
c10989a2 | 1065 | |
b24c2b4f | 1066 | return state->dual_mode + 1; |
9805992f JAR |
1067 | } |
1068 | ||
7f882c2e AP |
1069 | static int af9035_frontend_attach(struct dvb_usb_adapter *adap) |
1070 | { | |
5da2aecb AP |
1071 | struct state *state = adap_to_priv(adap); |
1072 | struct dvb_usb_device *d = adap_to_d(adap); | |
7f882c2e | 1073 | int ret; |
c10989a2 | 1074 | |
df8f1be1 | 1075 | dev_dbg(&d->udev->dev, "%s:\n", __func__); |
7f882c2e | 1076 | |
1cbabf9c AP |
1077 | if (!state->af9033_config[adap->id].tuner) { |
1078 | /* unsupported tuner */ | |
5a9abae4 AP |
1079 | ret = -ENODEV; |
1080 | goto err; | |
1081 | } | |
1082 | ||
7f882c2e | 1083 | /* attach demodulator */ |
bf97b637 | 1084 | adap->fe[0] = dvb_attach(af9033_attach, &state->af9033_config[adap->id], |
ed97a6fe | 1085 | &d->i2c_adap, &state->ops); |
5da2aecb | 1086 | if (adap->fe[0] == NULL) { |
7f882c2e AP |
1087 | ret = -ENODEV; |
1088 | goto err; | |
1089 | } | |
852f0d9d AP |
1090 | |
1091 | /* disable I2C-gate */ | |
5da2aecb AP |
1092 | adap->fe[0]->ops.i2c_gate_ctrl = NULL; |
1093 | adap->fe[0]->callback = af9035_frontend_callback; | |
7f882c2e AP |
1094 | |
1095 | return 0; | |
1096 | ||
1097 | err: | |
119f7a8c | 1098 | dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret); |
7f882c2e AP |
1099 | |
1100 | return ret; | |
1101 | } | |
1102 | ||
1103 | static struct tua9001_config af9035_tua9001_config = { | |
1104 | .i2c_addr = 0x60, | |
1105 | }; | |
1106 | ||
ffc501f6 MB |
1107 | static const struct fc0011_config af9035_fc0011_config = { |
1108 | .i2c_address = 0x60, | |
1109 | }; | |
1110 | ||
9805992f JAR |
1111 | static struct mxl5007t_config af9035_mxl5007t_config[] = { |
1112 | { | |
1113 | .xtal_freq_hz = MxL_XTAL_24_MHZ, | |
1114 | .if_freq_hz = MxL_IF_4_57_MHZ, | |
1115 | .invert_if = 0, | |
1116 | .loop_thru_enable = 0, | |
1117 | .clk_out_enable = 0, | |
1118 | .clk_out_amp = MxL_CLKOUT_AMP_0_94V, | |
1119 | }, { | |
1120 | .xtal_freq_hz = MxL_XTAL_24_MHZ, | |
1121 | .if_freq_hz = MxL_IF_4_57_MHZ, | |
1122 | .invert_if = 0, | |
1123 | .loop_thru_enable = 1, | |
1124 | .clk_out_enable = 1, | |
1125 | .clk_out_amp = MxL_CLKOUT_AMP_0_94V, | |
1126 | } | |
540fd4ba HFV |
1127 | }; |
1128 | ||
ce1fe379 GG |
1129 | static struct tda18218_config af9035_tda18218_config = { |
1130 | .i2c_address = 0x60, | |
1131 | .i2c_wr_max = 21, | |
1132 | }; | |
1133 | ||
d67ceb33 OS |
1134 | static const struct fc2580_config af9035_fc2580_config = { |
1135 | .i2c_addr = 0x56, | |
1136 | .clock = 16384000, | |
1137 | }; | |
1138 | ||
0bb3d8ac AP |
1139 | static const struct fc0012_config af9035_fc0012_config[] = { |
1140 | { | |
1141 | .i2c_address = 0x63, | |
1142 | .xtal_freq = FC_XTAL_36_MHZ, | |
3a984772 | 1143 | .dual_master = true, |
0bb3d8ac AP |
1144 | .loop_through = true, |
1145 | .clock_out = true, | |
1146 | }, { | |
1147 | .i2c_address = 0x63 | 0x80, /* I2C bus select hack */ | |
1148 | .xtal_freq = FC_XTAL_36_MHZ, | |
3a984772 | 1149 | .dual_master = true, |
0bb3d8ac | 1150 | } |
ad3a758b AP |
1151 | }; |
1152 | ||
7f882c2e AP |
1153 | static int af9035_tuner_attach(struct dvb_usb_adapter *adap) |
1154 | { | |
5da2aecb AP |
1155 | struct state *state = adap_to_priv(adap); |
1156 | struct dvb_usb_device *d = adap_to_d(adap); | |
7f882c2e AP |
1157 | int ret; |
1158 | struct dvb_frontend *fe; | |
0bb3d8ac | 1159 | struct i2c_msg msg[1]; |
bf97b637 | 1160 | u8 tuner_addr; |
c10989a2 | 1161 | |
df8f1be1 AP |
1162 | dev_dbg(&d->udev->dev, "%s:\n", __func__); |
1163 | ||
bf97b637 AP |
1164 | /* |
1165 | * XXX: Hack used in that function: we abuse unused I2C address bit [7] | |
1166 | * to carry info about used I2C bus for dual tuner configuration. | |
1167 | */ | |
7f882c2e | 1168 | |
2a79eefa | 1169 | switch (state->af9033_config[adap->id].tuner) { |
7f882c2e AP |
1170 | case AF9033_TUNER_TUA9001: |
1171 | /* AF9035 gpiot3 = TUA9001 RESETN | |
1172 | AF9035 gpiot2 = TUA9001 RXEN */ | |
1173 | ||
1174 | /* configure gpiot2 and gpiot2 as output */ | |
5da2aecb | 1175 | ret = af9035_wr_reg_mask(d, 0x00d8ec, 0x01, 0x01); |
7f882c2e AP |
1176 | if (ret < 0) |
1177 | goto err; | |
1178 | ||
5da2aecb | 1179 | ret = af9035_wr_reg_mask(d, 0x00d8ed, 0x01, 0x01); |
7f882c2e AP |
1180 | if (ret < 0) |
1181 | goto err; | |
1182 | ||
5da2aecb | 1183 | ret = af9035_wr_reg_mask(d, 0x00d8e8, 0x01, 0x01); |
7f882c2e AP |
1184 | if (ret < 0) |
1185 | goto err; | |
1186 | ||
5da2aecb | 1187 | ret = af9035_wr_reg_mask(d, 0x00d8e9, 0x01, 0x01); |
7f882c2e AP |
1188 | if (ret < 0) |
1189 | goto err; | |
1190 | ||
7f882c2e | 1191 | /* attach tuner */ |
5da2aecb AP |
1192 | fe = dvb_attach(tua9001_attach, adap->fe[0], |
1193 | &d->i2c_adap, &af9035_tua9001_config); | |
7f882c2e | 1194 | break; |
ffc501f6 | 1195 | case AF9033_TUNER_FC0011: |
5da2aecb AP |
1196 | fe = dvb_attach(fc0011_attach, adap->fe[0], |
1197 | &d->i2c_adap, &af9035_fc0011_config); | |
ffc501f6 | 1198 | break; |
540fd4ba | 1199 | case AF9033_TUNER_MXL5007T: |
9805992f JAR |
1200 | if (adap->id == 0) { |
1201 | ret = af9035_wr_reg(d, 0x00d8e0, 1); | |
1202 | if (ret < 0) | |
1203 | goto err; | |
bf97b637 | 1204 | |
9805992f JAR |
1205 | ret = af9035_wr_reg(d, 0x00d8e1, 1); |
1206 | if (ret < 0) | |
1207 | goto err; | |
bf97b637 | 1208 | |
9805992f JAR |
1209 | ret = af9035_wr_reg(d, 0x00d8df, 0); |
1210 | if (ret < 0) | |
1211 | goto err; | |
540fd4ba | 1212 | |
9805992f | 1213 | msleep(30); |
540fd4ba | 1214 | |
9805992f JAR |
1215 | ret = af9035_wr_reg(d, 0x00d8df, 1); |
1216 | if (ret < 0) | |
1217 | goto err; | |
540fd4ba | 1218 | |
9805992f | 1219 | msleep(300); |
540fd4ba | 1220 | |
9805992f JAR |
1221 | ret = af9035_wr_reg(d, 0x00d8c0, 1); |
1222 | if (ret < 0) | |
1223 | goto err; | |
bf97b637 | 1224 | |
9805992f JAR |
1225 | ret = af9035_wr_reg(d, 0x00d8c1, 1); |
1226 | if (ret < 0) | |
1227 | goto err; | |
bf97b637 | 1228 | |
9805992f JAR |
1229 | ret = af9035_wr_reg(d, 0x00d8bf, 0); |
1230 | if (ret < 0) | |
1231 | goto err; | |
bf97b637 | 1232 | |
9805992f JAR |
1233 | ret = af9035_wr_reg(d, 0x00d8b4, 1); |
1234 | if (ret < 0) | |
1235 | goto err; | |
bf97b637 | 1236 | |
9805992f JAR |
1237 | ret = af9035_wr_reg(d, 0x00d8b5, 1); |
1238 | if (ret < 0) | |
1239 | goto err; | |
bf97b637 | 1240 | |
9805992f JAR |
1241 | ret = af9035_wr_reg(d, 0x00d8b3, 1); |
1242 | if (ret < 0) | |
1243 | goto err; | |
bf97b637 AP |
1244 | |
1245 | tuner_addr = 0x60; | |
1246 | } else { | |
1247 | tuner_addr = 0x60 | 0x80; /* I2C bus hack */ | |
9805992f | 1248 | } |
540fd4ba HFV |
1249 | |
1250 | /* attach tuner */ | |
bf97b637 AP |
1251 | fe = dvb_attach(mxl5007t_attach, adap->fe[0], &d->i2c_adap, |
1252 | tuner_addr, &af9035_mxl5007t_config[adap->id]); | |
540fd4ba | 1253 | break; |
ce1fe379 GG |
1254 | case AF9033_TUNER_TDA18218: |
1255 | /* attach tuner */ | |
5da2aecb AP |
1256 | fe = dvb_attach(tda18218_attach, adap->fe[0], |
1257 | &d->i2c_adap, &af9035_tda18218_config); | |
ce1fe379 | 1258 | break; |
d67ceb33 OS |
1259 | case AF9033_TUNER_FC2580: |
1260 | /* Tuner enable using gpiot2_o, gpiot2_en and gpiot2_on */ | |
1261 | ret = af9035_wr_reg_mask(d, 0xd8eb, 0x01, 0x01); | |
1262 | if (ret < 0) | |
1263 | goto err; | |
1264 | ||
1265 | ret = af9035_wr_reg_mask(d, 0xd8ec, 0x01, 0x01); | |
1266 | if (ret < 0) | |
1267 | goto err; | |
1268 | ||
1269 | ret = af9035_wr_reg_mask(d, 0xd8ed, 0x01, 0x01); | |
1270 | if (ret < 0) | |
1271 | goto err; | |
1272 | ||
1273 | usleep_range(10000, 50000); | |
1274 | /* attach tuner */ | |
1275 | fe = dvb_attach(fc2580_attach, adap->fe[0], | |
1276 | &d->i2c_adap, &af9035_fc2580_config); | |
1277 | break; | |
7e0bc296 AP |
1278 | case AF9033_TUNER_FC0012: |
1279 | /* | |
1280 | * AF9035 gpiot2 = FC0012 enable | |
1281 | * XXX: there seems to be something on gpioh8 too, but on my | |
1282 | * my test I didn't find any difference. | |
1283 | */ | |
1284 | ||
0bb3d8ac AP |
1285 | if (adap->id == 0) { |
1286 | /* configure gpiot2 as output and high */ | |
1287 | ret = af9035_wr_reg_mask(d, 0xd8eb, 0x01, 0x01); | |
1288 | if (ret < 0) | |
1289 | goto err; | |
7e0bc296 | 1290 | |
0bb3d8ac AP |
1291 | ret = af9035_wr_reg_mask(d, 0xd8ec, 0x01, 0x01); |
1292 | if (ret < 0) | |
1293 | goto err; | |
7e0bc296 | 1294 | |
0bb3d8ac AP |
1295 | ret = af9035_wr_reg_mask(d, 0xd8ed, 0x01, 0x01); |
1296 | if (ret < 0) | |
1297 | goto err; | |
1298 | } else { | |
1299 | /* | |
1300 | * FIXME: That belongs for the FC0012 driver. | |
1301 | * Write 02 to FC0012 master tuner register 0d directly | |
1302 | * in order to make slave tuner working. | |
1303 | */ | |
1304 | msg[0].addr = 0x63; | |
1305 | msg[0].flags = 0; | |
1306 | msg[0].len = 2; | |
1307 | msg[0].buf = "\x0d\x02"; | |
1308 | ret = i2c_transfer(&d->i2c_adap, msg, 1); | |
1309 | if (ret < 0) | |
1310 | goto err; | |
1311 | } | |
7e0bc296 AP |
1312 | |
1313 | usleep_range(10000, 50000); | |
1314 | ||
ad3a758b | 1315 | fe = dvb_attach(fc0012_attach, adap->fe[0], &d->i2c_adap, |
0bb3d8ac | 1316 | &af9035_fc0012_config[adap->id]); |
7e0bc296 | 1317 | break; |
ac77fb0f | 1318 | case AF9033_TUNER_IT9135_38: |
74c1883a AP |
1319 | case AF9033_TUNER_IT9135_51: |
1320 | case AF9033_TUNER_IT9135_52: | |
3b2a5e8c AP |
1321 | { |
1322 | struct it913x_config it913x_config = { | |
1323 | .fe = adap->fe[0], | |
1324 | .chip_ver = 1, | |
1325 | }; | |
1326 | ||
1327 | ret = af9035_add_i2c_dev(d, "it913x", | |
1328 | state->af9033_config[adap->id].i2c_addr, | |
1329 | &it913x_config); | |
1330 | if (ret) | |
1331 | goto err; | |
1332 | ||
1333 | fe = adap->fe[0]; | |
1334 | break; | |
1335 | } | |
74c1883a AP |
1336 | case AF9033_TUNER_IT9135_60: |
1337 | case AF9033_TUNER_IT9135_61: | |
1338 | case AF9033_TUNER_IT9135_62: | |
3b2a5e8c AP |
1339 | { |
1340 | struct it913x_config it913x_config = { | |
1341 | .fe = adap->fe[0], | |
1342 | .chip_ver = 2, | |
1343 | }; | |
1344 | ||
1345 | ret = af9035_add_i2c_dev(d, "it913x", | |
df8f1be1 | 1346 | state->af9033_config[adap->id].i2c_addr, |
3b2a5e8c AP |
1347 | &it913x_config); |
1348 | if (ret) | |
1349 | goto err; | |
1350 | ||
1351 | fe = adap->fe[0]; | |
ac77fb0f | 1352 | break; |
3b2a5e8c | 1353 | } |
7f882c2e AP |
1354 | default: |
1355 | fe = NULL; | |
1356 | } | |
1357 | ||
1358 | if (fe == NULL) { | |
1359 | ret = -ENODEV; | |
1360 | goto err; | |
1361 | } | |
1362 | ||
1363 | return 0; | |
1364 | ||
1365 | err: | |
119f7a8c | 1366 | dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret); |
7f882c2e AP |
1367 | |
1368 | return ret; | |
1369 | } | |
1370 | ||
5da2aecb AP |
1371 | static int af9035_init(struct dvb_usb_device *d) |
1372 | { | |
1373 | struct state *state = d_to_priv(d); | |
1374 | int ret, i; | |
bada342e AP |
1375 | u16 frame_size = (d->udev->speed == USB_SPEED_FULL ? 5 : 87) * 188 / 4; |
1376 | u8 packet_size = (d->udev->speed == USB_SPEED_FULL ? 64 : 512) / 4; | |
5da2aecb AP |
1377 | struct reg_val_mask tab[] = { |
1378 | { 0x80f99d, 0x01, 0x01 }, | |
1379 | { 0x80f9a4, 0x01, 0x01 }, | |
1380 | { 0x00dd11, 0x00, 0x20 }, | |
1381 | { 0x00dd11, 0x00, 0x40 }, | |
1382 | { 0x00dd13, 0x00, 0x20 }, | |
1383 | { 0x00dd13, 0x00, 0x40 }, | |
1384 | { 0x00dd11, 0x20, 0x20 }, | |
1385 | { 0x00dd88, (frame_size >> 0) & 0xff, 0xff}, | |
1386 | { 0x00dd89, (frame_size >> 8) & 0xff, 0xff}, | |
1387 | { 0x00dd0c, packet_size, 0xff}, | |
1388 | { 0x00dd11, state->dual_mode << 6, 0x40 }, | |
1389 | { 0x00dd8a, (frame_size >> 0) & 0xff, 0xff}, | |
1390 | { 0x00dd8b, (frame_size >> 8) & 0xff, 0xff}, | |
1391 | { 0x00dd0d, packet_size, 0xff }, | |
9805992f JAR |
1392 | { 0x80f9a3, state->dual_mode, 0x01 }, |
1393 | { 0x80f9cd, state->dual_mode, 0x01 }, | |
5da2aecb AP |
1394 | { 0x80f99d, 0x00, 0x01 }, |
1395 | { 0x80f9a4, 0x00, 0x01 }, | |
1396 | }; | |
7f882c2e | 1397 | |
cb9114e9 AP |
1398 | dev_dbg(&d->udev->dev, |
1399 | "%s: USB speed=%d frame_size=%04x packet_size=%02x\n", | |
1400 | __func__, d->udev->speed, frame_size, packet_size); | |
7f882c2e | 1401 | |
5da2aecb AP |
1402 | /* init endpoints */ |
1403 | for (i = 0; i < ARRAY_SIZE(tab); i++) { | |
1404 | ret = af9035_wr_reg_mask(d, tab[i].reg, tab[i].val, | |
1405 | tab[i].mask); | |
1406 | if (ret < 0) | |
1407 | goto err; | |
1408 | } | |
7f882c2e | 1409 | |
5da2aecb | 1410 | return 0; |
7f882c2e | 1411 | |
5da2aecb | 1412 | err: |
119f7a8c | 1413 | dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret); |
f2b61d0c | 1414 | |
5da2aecb AP |
1415 | return ret; |
1416 | } | |
f2b61d0c | 1417 | |
3b2a5e8c AP |
1418 | static void af9035_exit(struct dvb_usb_device *d) |
1419 | { | |
1420 | struct state *state = d_to_priv(d); | |
1421 | ||
1422 | dev_dbg(&d->udev->dev, "%s:\n", __func__); | |
1423 | ||
1424 | if (state->i2c_client[1]) | |
1425 | af9035_del_i2c_dev(d); | |
1426 | ||
1427 | if (state->i2c_client[0]) | |
1428 | af9035_del_i2c_dev(d); | |
1429 | } | |
1430 | ||
37b44a0f | 1431 | #if IS_ENABLED(CONFIG_RC_CORE) |
5da2aecb AP |
1432 | static int af9035_rc_query(struct dvb_usb_device *d) |
1433 | { | |
5da2aecb | 1434 | int ret; |
75cd5886 AP |
1435 | u32 key; |
1436 | u8 buf[4]; | |
1437 | struct usb_req req = { CMD_IR_GET, 0, 0, NULL, 4, buf }; | |
f2b61d0c | 1438 | |
5da2aecb | 1439 | ret = af9035_ctrl_msg(d, &req); |
1bfd5294 AP |
1440 | if (ret == 1) |
1441 | return 0; | |
1442 | else if (ret < 0) | |
5da2aecb | 1443 | goto err; |
7f882c2e | 1444 | |
75cd5886 AP |
1445 | if ((buf[2] + buf[3]) == 0xff) { |
1446 | if ((buf[0] + buf[1]) == 0xff) { | |
1447 | /* NEC standard 16bit */ | |
120703f9 | 1448 | key = RC_SCANCODE_NEC(buf[0], buf[2]); |
5da2aecb | 1449 | } else { |
75cd5886 | 1450 | /* NEC extended 24bit */ |
120703f9 | 1451 | key = RC_SCANCODE_NECX(buf[0] << 8 | buf[1], buf[2]); |
7f882c2e | 1452 | } |
5da2aecb | 1453 | } else { |
75cd5886 | 1454 | /* NEC full code 32bit */ |
120703f9 DH |
1455 | key = RC_SCANCODE_NEC32(buf[0] << 24 | buf[1] << 16 | |
1456 | buf[2] << 8 | buf[3]); | |
7f882c2e AP |
1457 | } |
1458 | ||
75cd5886 AP |
1459 | dev_dbg(&d->udev->dev, "%s: %*ph\n", __func__, 4, buf); |
1460 | ||
120703f9 | 1461 | rc_keydown(d->rc_dev, RC_TYPE_NEC, key, 0); |
7f882c2e | 1462 | |
5da2aecb | 1463 | return 0; |
1bfd5294 AP |
1464 | |
1465 | err: | |
1466 | dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret); | |
1467 | ||
1468 | return ret; | |
5da2aecb | 1469 | } |
7f882c2e | 1470 | |
5da2aecb AP |
1471 | static int af9035_get_rc_config(struct dvb_usb_device *d, struct dvb_usb_rc *rc) |
1472 | { | |
74c1883a | 1473 | struct state *state = d_to_priv(d); |
5da2aecb AP |
1474 | int ret; |
1475 | u8 tmp; | |
7f882c2e | 1476 | |
431a6d4a | 1477 | ret = af9035_rd_reg(d, state->eeprom_addr + EEPROM_IR_MODE, &tmp); |
7f882c2e AP |
1478 | if (ret < 0) |
1479 | goto err; | |
1480 | ||
119f7a8c | 1481 | dev_dbg(&d->udev->dev, "%s: ir_mode=%02x\n", __func__, tmp); |
5da2aecb AP |
1482 | |
1483 | /* don't activate rc if in HID mode or if not available */ | |
1484 | if (tmp == 5) { | |
431a6d4a | 1485 | ret = af9035_rd_reg(d, state->eeprom_addr + EEPROM_IR_TYPE, |
9ea3681d | 1486 | &tmp); |
7f882c2e AP |
1487 | if (ret < 0) |
1488 | goto err; | |
5da2aecb | 1489 | |
119f7a8c | 1490 | dev_dbg(&d->udev->dev, "%s: ir_type=%02x\n", __func__, tmp); |
5da2aecb AP |
1491 | |
1492 | switch (tmp) { | |
1493 | case 0: /* NEC */ | |
1494 | default: | |
c003ab1b | 1495 | rc->allowed_protos = RC_BIT_NEC; |
5da2aecb AP |
1496 | break; |
1497 | case 1: /* RC6 */ | |
c003ab1b | 1498 | rc->allowed_protos = RC_BIT_RC6_MCE; |
5da2aecb AP |
1499 | break; |
1500 | } | |
1501 | ||
1502 | rc->query = af9035_rc_query; | |
1503 | rc->interval = 500; | |
de73beee AP |
1504 | |
1505 | /* load empty to enable rc */ | |
1506 | if (!rc->map_name) | |
1507 | rc->map_name = RC_MAP_EMPTY; | |
7f882c2e AP |
1508 | } |
1509 | ||
1510 | return 0; | |
1511 | ||
1512 | err: | |
119f7a8c | 1513 | dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret); |
7f882c2e AP |
1514 | |
1515 | return ret; | |
1516 | } | |
eed5670a AP |
1517 | #else |
1518 | #define af9035_get_rc_config NULL | |
1519 | #endif | |
7f882c2e | 1520 | |
bada342e AP |
1521 | static int af9035_get_stream_config(struct dvb_frontend *fe, u8 *ts_type, |
1522 | struct usb_data_stream_properties *stream) | |
1523 | { | |
1524 | struct dvb_usb_device *d = fe_to_d(fe); | |
c10989a2 | 1525 | |
bada342e AP |
1526 | dev_dbg(&d->udev->dev, "%s: adap=%d\n", __func__, fe_to_adap(fe)->id); |
1527 | ||
1528 | if (d->udev->speed == USB_SPEED_FULL) | |
1529 | stream->u.bulk.buffersize = 5 * 188; | |
1530 | ||
1531 | return 0; | |
1532 | } | |
1533 | ||
bada342e AP |
1534 | static int af9035_pid_filter_ctrl(struct dvb_usb_adapter *adap, int onoff) |
1535 | { | |
ed97a6fe MCC |
1536 | struct state *state = adap_to_priv(adap); |
1537 | ||
1538 | return state->ops.pid_filter_ctrl(adap->fe[0], onoff); | |
bada342e AP |
1539 | } |
1540 | ||
1541 | static int af9035_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid, | |
1542 | int onoff) | |
1543 | { | |
ed97a6fe MCC |
1544 | struct state *state = adap_to_priv(adap); |
1545 | ||
1546 | return state->ops.pid_filter(adap->fe[0], index, pid, onoff); | |
bada342e AP |
1547 | } |
1548 | ||
b799b810 AP |
1549 | static int af9035_probe(struct usb_interface *intf, |
1550 | const struct usb_device_id *id) | |
1551 | { | |
1552 | struct usb_device *udev = interface_to_usbdev(intf); | |
1553 | char manufacturer[sizeof("Afatech")]; | |
1554 | ||
1555 | memset(manufacturer, 0, sizeof(manufacturer)); | |
1556 | usb_string(udev, udev->descriptor.iManufacturer, | |
1557 | manufacturer, sizeof(manufacturer)); | |
1558 | /* | |
1559 | * There is two devices having same ID but different chipset. One uses | |
1560 | * AF9015 and the other IT9135 chipset. Only difference seen on lsusb | |
1561 | * is iManufacturer string. | |
1562 | * | |
1563 | * idVendor 0x0ccd TerraTec Electronic GmbH | |
1564 | * idProduct 0x0099 | |
1565 | * bcdDevice 2.00 | |
1566 | * iManufacturer 1 Afatech | |
1567 | * iProduct 2 DVB-T 2 | |
1568 | * | |
1569 | * idVendor 0x0ccd TerraTec Electronic GmbH | |
1570 | * idProduct 0x0099 | |
1571 | * bcdDevice 2.00 | |
1572 | * iManufacturer 1 ITE Technologies, Inc. | |
1573 | * iProduct 2 DVB-T TV Stick | |
1574 | */ | |
1575 | if ((le16_to_cpu(udev->descriptor.idVendor) == USB_VID_TERRATEC) && | |
1576 | (le16_to_cpu(udev->descriptor.idProduct) == 0x0099)) { | |
1577 | if (!strcmp("Afatech", manufacturer)) { | |
1578 | dev_dbg(&udev->dev, "%s: rejecting device\n", __func__); | |
1579 | return -ENODEV; | |
1580 | } | |
1581 | } | |
1582 | ||
1583 | return dvb_usbv2_probe(intf, id); | |
1584 | } | |
1585 | ||
5da2aecb AP |
1586 | /* interface 0 is used by DVB-T receiver and |
1587 | interface 1 is for remote controller (HID) */ | |
1588 | static const struct dvb_usb_device_properties af9035_props = { | |
1589 | .driver_name = KBUILD_MODNAME, | |
1590 | .owner = THIS_MODULE, | |
1591 | .adapter_nr = adapter_nr, | |
1592 | .size_of_priv = sizeof(struct state), | |
1593 | ||
1594 | .generic_bulk_ctrl_endpoint = 0x02, | |
1595 | .generic_bulk_ctrl_endpoint_response = 0x81, | |
1596 | ||
1597 | .identify_state = af9035_identify_state, | |
5da2aecb AP |
1598 | .download_firmware = af9035_download_firmware, |
1599 | ||
1600 | .i2c_algo = &af9035_i2c_algo, | |
1601 | .read_config = af9035_read_config, | |
1602 | .frontend_attach = af9035_frontend_attach, | |
1603 | .tuner_attach = af9035_tuner_attach, | |
1604 | .init = af9035_init, | |
1605 | .get_rc_config = af9035_get_rc_config, | |
bada342e | 1606 | .get_stream_config = af9035_get_stream_config, |
3b2a5e8c | 1607 | .exit = af9035_exit, |
5da2aecb | 1608 | |
9805992f | 1609 | .get_adapter_count = af9035_get_adapter_count, |
5da2aecb AP |
1610 | .adapter = { |
1611 | { | |
bada342e AP |
1612 | .caps = DVB_USB_ADAP_HAS_PID_FILTER | |
1613 | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, | |
1614 | ||
1615 | .pid_filter_count = 32, | |
1616 | .pid_filter_ctrl = af9035_pid_filter_ctrl, | |
1617 | .pid_filter = af9035_pid_filter, | |
1618 | ||
5da2aecb AP |
1619 | .stream = DVB_USB_STREAM_BULK(0x84, 6, 87 * 188), |
1620 | }, { | |
b24c2b4f AP |
1621 | .caps = DVB_USB_ADAP_HAS_PID_FILTER | |
1622 | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, | |
1623 | ||
1624 | .pid_filter_count = 32, | |
1625 | .pid_filter_ctrl = af9035_pid_filter_ctrl, | |
1626 | .pid_filter = af9035_pid_filter, | |
1627 | ||
5da2aecb AP |
1628 | .stream = DVB_USB_STREAM_BULK(0x85, 6, 87 * 188), |
1629 | }, | |
1630 | }, | |
1631 | }; | |
1632 | ||
5da2aecb | 1633 | static const struct usb_device_id af9035_id_table[] = { |
bc3c9e10 | 1634 | /* AF9035 devices */ |
5da2aecb AP |
1635 | { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9035_9035, |
1636 | &af9035_props, "Afatech AF9035 reference design", NULL) }, | |
1637 | { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9035_1000, | |
1638 | &af9035_props, "Afatech AF9035 reference design", NULL) }, | |
1639 | { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9035_1001, | |
1640 | &af9035_props, "Afatech AF9035 reference design", NULL) }, | |
1641 | { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9035_1002, | |
1642 | &af9035_props, "Afatech AF9035 reference design", NULL) }, | |
1643 | { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9035_1003, | |
1644 | &af9035_props, "Afatech AF9035 reference design", NULL) }, | |
1645 | { DVB_USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_STICK, | |
1646 | &af9035_props, "TerraTec Cinergy T Stick", NULL) }, | |
1647 | { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A835, | |
1648 | &af9035_props, "AVerMedia AVerTV Volar HD/PRO (A835)", NULL) }, | |
1649 | { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_B835, | |
1650 | &af9035_props, "AVerMedia AVerTV Volar HD/PRO (A835)", NULL) }, | |
1651 | { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_1867, | |
1652 | &af9035_props, "AVerMedia HD Volar (A867)", NULL) }, | |
1653 | { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A867, | |
1654 | &af9035_props, "AVerMedia HD Volar (A867)", NULL) }, | |
1655 | { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_TWINSTAR, | |
1656 | &af9035_props, "AVerMedia Twinstar (A825)", NULL) }, | |
d67ceb33 OS |
1657 | { DVB_USB_DEVICE(USB_VID_ASUS, USB_PID_ASUS_U3100MINI_PLUS, |
1658 | &af9035_props, "Asus U3100Mini Plus", NULL) }, | |
cb9114e9 | 1659 | { DVB_USB_DEVICE(USB_VID_TERRATEC, 0x00aa, |
d9b7595b | 1660 | &af9035_props, "TerraTec Cinergy T Stick (rev. 2)", NULL) }, |
bc3c9e10 | 1661 | /* IT9135 devices */ |
7a541ce0 MP |
1662 | { DVB_USB_DEVICE(USB_VID_ITETECH, USB_PID_ITETECH_IT9135, |
1663 | &af9035_props, "ITE 9135 Generic", RC_MAP_IT913X_V1) }, | |
1664 | { DVB_USB_DEVICE(USB_VID_ITETECH, USB_PID_ITETECH_IT9135_9005, | |
1665 | &af9035_props, "ITE 9135(9005) Generic", RC_MAP_IT913X_V2) }, | |
1666 | { DVB_USB_DEVICE(USB_VID_ITETECH, USB_PID_ITETECH_IT9135_9006, | |
1667 | &af9035_props, "ITE 9135(9006) Generic", RC_MAP_IT913X_V1) }, | |
1668 | { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A835B_1835, | |
1669 | &af9035_props, "Avermedia A835B(1835)", RC_MAP_IT913X_V2) }, | |
1670 | { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A835B_2835, | |
1671 | &af9035_props, "Avermedia A835B(2835)", RC_MAP_IT913X_V2) }, | |
1672 | { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A835B_3835, | |
1673 | &af9035_props, "Avermedia A835B(3835)", RC_MAP_IT913X_V2) }, | |
1674 | { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A835B_4835, | |
1675 | &af9035_props, "Avermedia A835B(4835)", RC_MAP_IT913X_V2) }, | |
1676 | { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_H335, | |
1677 | &af9035_props, "Avermedia H335", RC_MAP_IT913X_V2) }, | |
37973e01 MP |
1678 | { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_UB499_2T_T09, |
1679 | &af9035_props, "Kworld UB499-2T T09", RC_MAP_IT913X_V1) }, | |
1680 | { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_SVEON_STV22_IT9137, | |
1681 | &af9035_props, "Sveon STV22 Dual DVB-T HDTV", | |
1682 | RC_MAP_IT913X_V1) }, | |
1683 | { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_CTVDIGDUAL_V2, | |
1684 | &af9035_props, "Digital Dual TV Receiver CTVDIGDUAL_V2", | |
1685 | RC_MAP_IT913X_V1) }, | |
b799b810 AP |
1686 | /* XXX: that same ID [0ccd:0099] is used by af9015 driver too */ |
1687 | { DVB_USB_DEVICE(USB_VID_TERRATEC, 0x0099, | |
c10989a2 AP |
1688 | &af9035_props, "TerraTec Cinergy T Stick Dual RC (rev. 2)", |
1689 | NULL) }, | |
0c413d10 AP |
1690 | { DVB_USB_DEVICE(USB_VID_LEADTEK, 0x6a05, |
1691 | &af9035_props, "Leadtek WinFast DTV Dongle Dual", NULL) }, | |
261cb200 AP |
1692 | { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xf900, |
1693 | &af9035_props, "Hauppauge WinTV-MiniStick 2", NULL) }, | |
a04646c0 MP |
1694 | { DVB_USB_DEVICE(USB_VID_PCTV, USB_PID_PCTV_78E, |
1695 | &af9035_props, "PCTV 78e", RC_MAP_IT913X_V1) }, | |
1696 | { DVB_USB_DEVICE(USB_VID_PCTV, USB_PID_PCTV_79E, | |
1697 | &af9035_props, "PCTV 79e", RC_MAP_IT913X_V2) }, | |
5da2aecb AP |
1698 | { } |
1699 | }; | |
1700 | MODULE_DEVICE_TABLE(usb, af9035_id_table); | |
1701 | ||
7f882c2e | 1702 | static struct usb_driver af9035_usb_driver = { |
5da2aecb AP |
1703 | .name = KBUILD_MODNAME, |
1704 | .id_table = af9035_id_table, | |
b799b810 | 1705 | .probe = af9035_probe, |
5da2aecb AP |
1706 | .disconnect = dvb_usbv2_disconnect, |
1707 | .suspend = dvb_usbv2_suspend, | |
1708 | .resume = dvb_usbv2_resume, | |
04966aa8 | 1709 | .reset_resume = dvb_usbv2_reset_resume, |
5da2aecb AP |
1710 | .no_dynamic_id = 1, |
1711 | .soft_unbind = 1, | |
7f882c2e AP |
1712 | }; |
1713 | ||
48bf7e1a | 1714 | module_usb_driver(af9035_usb_driver); |
7f882c2e AP |
1715 | |
1716 | MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>"); | |
1717 | MODULE_DESCRIPTION("Afatech AF9035 driver"); | |
1718 | MODULE_LICENSE("GPL"); | |
4395e4b7 | 1719 | MODULE_FIRMWARE(AF9035_FIRMWARE_AF9035); |
74c1883a AP |
1720 | MODULE_FIRMWARE(AF9035_FIRMWARE_IT9135_V1); |
1721 | MODULE_FIRMWARE(AF9035_FIRMWARE_IT9135_V2); |