?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mst/vhost
[cris-mirror.git] / drivers / media / usb / dvb-usb-v2 / anysee.c
blob20ee7eea2a91ef238d19d73fc622addf1529005b
1 /*
2 * DVB USB Linux driver for Anysee E30 DVB-C & DVB-T USB2.0 receiver
3 *
4 * Copyright (C) 2007 Antti Palosaari <crope@iki.fi>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * TODO:
17 * - add smart card reader support for Conditional Access (CA)
18 *
19 * Card reader in Anysee is nothing more than ISO 7816 card reader.
20 * There is no hardware CAM in any Anysee device sold.
21 * In my understanding it should be implemented by making own module
22 * for ISO 7816 card reader, like dvb_ca_en50221 is implemented. This
23 * module registers serial interface that can be used to communicate
24 * with any ISO 7816 smart card.
25 *
26 * Any help according to implement serial smart card reader support
27 * is highly welcome!
28 */
29
30 #include "anysee.h"
31 #include "dvb-pll.h"
32 #include "tda1002x.h"
33 #include "mt352.h"
34 #include "mt352_priv.h"
35 #include "zl10353.h"
36 #include "tda18212.h"
37 #include "cx24116.h"
38 #include "stv0900.h"
39 #include "stv6110.h"
40 #include "isl6423.h"
41 #include "cxd2820r.h"
42
43 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
44
45 static int anysee_ctrl_msg(struct dvb_usb_device *d,
46 u8 *sbuf, u8 slen, u8 *rbuf, u8 rlen)
47 {
48 struct anysee_state *state = d_to_priv(d);
49 int act_len, ret, i;
50
51 mutex_lock(&d->usb_mutex);
52
53 memcpy(&state->buf[0], sbuf, slen);
54 state->buf[60] = state->seq++;
55
56 dev_dbg(&d->udev->dev, "%s: >>> %*ph\n", __func__, slen, state->buf);
57
58 /* We need receive one message more after dvb_usb_generic_rw due
59 to weird transaction flow, which is 1 x send + 2 x receive. */
60 ret = dvb_usbv2_generic_rw_locked(d, state->buf, sizeof(state->buf),
61 state->buf, sizeof(state->buf));
62 if (ret)
63 goto error_unlock;
64
65 /* TODO FIXME: dvb_usb_generic_rw() fails rarely with error code -32
66 * (EPIPE, Broken pipe). Function supports currently msleep() as a
67 * parameter but I would not like to use it, since according to
68 * Documentation/timers/timers-howto.txt it should not be used such
69 * short, under < 20ms, sleeps. Repeating failed message would be
70 * better choice as not to add unwanted delays...
71 * Fixing that correctly is one of those or both;
72 * 1) use repeat if possible
73 * 2) add suitable delay
74 */
75
76 /* get answer, retry few times if error returned */
77 for (i = 0; i < 3; i++) {
78 /* receive 2nd answer */
79 ret = usb_bulk_msg(d->udev, usb_rcvbulkpipe(d->udev,
80 d->props->generic_bulk_ctrl_endpoint),
81 state->buf, sizeof(state->buf), &act_len, 2000);
82 if (ret) {
83 dev_dbg(&d->udev->dev,
84 "%s: recv bulk message failed=%d\n",
85 __func__, ret);
86 } else {
87 dev_dbg(&d->udev->dev, "%s: <<< %*ph\n", __func__,
88 rlen, state->buf);
89
90 if (state->buf[63] != 0x4f)
91 dev_dbg(&d->udev->dev,
92 "%s: cmd failed\n", __func__);
93 break;
94 }
95 }
96
97 if (ret) {
98 /* all retries failed, it is fatal */
99 dev_err(&d->udev->dev, "%s: recv bulk message failed=%d\n",
100 KBUILD_MODNAME, ret);
101 goto error_unlock;
102 }
103
104 /* read request, copy returned data to return buf */
105 if (rbuf && rlen)
106 memcpy(rbuf, state->buf, rlen);
107
108 error_unlock:
109 mutex_unlock(&d->usb_mutex);
110 return ret;
111 }
112
113 static int anysee_read_reg(struct dvb_usb_device *d, u16 reg, u8 *val)
114 {
115 u8 buf[] = {CMD_REG_READ, reg >> 8, reg & 0xff, 0x01};
116 int ret;
117 ret = anysee_ctrl_msg(d, buf, sizeof(buf), val, 1);
118 dev_dbg(&d->udev->dev, "%s: reg=%04x val=%02x\n", __func__, reg, *val);
119 return ret;
120 }
121
122 static int anysee_write_reg(struct dvb_usb_device *d, u16 reg, u8 val)
123 {
124 u8 buf[] = {CMD_REG_WRITE, reg >> 8, reg & 0xff, 0x01, val};
125 dev_dbg(&d->udev->dev, "%s: reg=%04x val=%02x\n", __func__, reg, val);
126 return anysee_ctrl_msg(d, buf, sizeof(buf), NULL, 0);
127 }
128
129 /* write single register with mask */
130 static int anysee_wr_reg_mask(struct dvb_usb_device *d, u16 reg, u8 val,
131 u8 mask)
132 {
133 int ret;
134 u8 tmp;
135
136 /* no need for read if whole reg is written */
137 if (mask != 0xff) {
138 ret = anysee_read_reg(d, reg, &tmp);
139 if (ret)
140 return ret;
141
142 val &= mask;
143 tmp &= ~mask;
144 val |= tmp;
145 }
146
147 return anysee_write_reg(d, reg, val);
148 }
149
150 /* read single register with mask */
151 static int anysee_rd_reg_mask(struct dvb_usb_device *d, u16 reg, u8 *val,
152 u8 mask)
153 {
154 int ret, i;
155 u8 tmp;
156
157 ret = anysee_read_reg(d, reg, &tmp);
158 if (ret)
159 return ret;
160
161 tmp &= mask;
162
163 /* find position of the first bit */
164 for (i = 0; i < 8; i++) {
165 if ((mask >> i) & 0x01)
166 break;
167 }
168 *val = tmp >> i;
169
170 return 0;
171 }
172
173 static int anysee_get_hw_info(struct dvb_usb_device *d, u8 *id)
174 {
175 u8 buf[] = {CMD_GET_HW_INFO};
176 return anysee_ctrl_msg(d, buf, sizeof(buf), id, 3);
177 }
178
179 static int anysee_streaming_ctrl(struct dvb_frontend *fe, int onoff)
180 {
181 u8 buf[] = {CMD_STREAMING_CTRL, (u8)onoff, 0x00};
182 dev_dbg(&fe_to_d(fe)->udev->dev, "%s: onoff=%d\n", __func__, onoff);
183 return anysee_ctrl_msg(fe_to_d(fe), buf, sizeof(buf), NULL, 0);
184 }
185
186 static int anysee_led_ctrl(struct dvb_usb_device *d, u8 mode, u8 interval)
187 {
188 u8 buf[] = {CMD_LED_AND_IR_CTRL, 0x01, mode, interval};
189 dev_dbg(&d->udev->dev, "%s: state=%d interval=%d\n", __func__,
190 mode, interval);
191 return anysee_ctrl_msg(d, buf, sizeof(buf), NULL, 0);
192 }
193
194 static int anysee_ir_ctrl(struct dvb_usb_device *d, u8 onoff)
195 {
196 u8 buf[] = {CMD_LED_AND_IR_CTRL, 0x02, onoff};
197 dev_dbg(&d->udev->dev, "%s: onoff=%d\n", __func__, onoff);
198 return anysee_ctrl_msg(d, buf, sizeof(buf), NULL, 0);
199 }
200
201 /* I2C */
202 static int anysee_master_xfer(struct i2c_adapter *adap, struct i2c_msg *msg,
203 int num)
204 {
205 struct dvb_usb_device *d = i2c_get_adapdata(adap);
206 int ret = 0, inc, i = 0;
207 u8 buf[52]; /* 4 + 48 (I2C WR USB command header + I2C WR max) */
208
209 if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
210 return -EAGAIN;
211
212 while (i < num) {
213 if (num > i + 1 && (msg[i+1].flags & I2C_M_RD)) {
214 if (msg[i].len > 2 || msg[i+1].len > 60) {
215 ret = -EOPNOTSUPP;
216 break;
217 }
218 buf[0] = CMD_I2C_READ;
219 buf[1] = (msg[i].addr << 1) | 0x01;
220 buf[2] = msg[i].buf[0];
221 buf[3] = msg[i].buf[1];
222 buf[4] = msg[i].len-1;
223 buf[5] = msg[i+1].len;
224 ret = anysee_ctrl_msg(d, buf, 6, msg[i+1].buf,
225 msg[i+1].len);
226 inc = 2;
227 } else {
228 if (msg[i].len > 48) {
229 ret = -EOPNOTSUPP;
230 break;
231 }
232 buf[0] = CMD_I2C_WRITE;
233 buf[1] = (msg[i].addr << 1);
234 buf[2] = msg[i].len;
235 buf[3] = 0x01;
236 memcpy(&buf[4], msg[i].buf, msg[i].len);
237 ret = anysee_ctrl_msg(d, buf, 4 + msg[i].len, NULL, 0);
238 inc = 1;
239 }
240 if (ret)
241 break;
242
243 i += inc;
244 }
245
246 mutex_unlock(&d->i2c_mutex);
247
248 return ret ? ret : i;
249 }
250
251 static u32 anysee_i2c_func(struct i2c_adapter *adapter)
252 {
253 return I2C_FUNC_I2C;
254 }
255
256 static struct i2c_algorithm anysee_i2c_algo = {
257 .master_xfer = anysee_master_xfer,
258 .functionality = anysee_i2c_func,
259 };
260
261 static int anysee_mt352_demod_init(struct dvb_frontend *fe)
262 {
263 static u8 clock_config[] = { CLOCK_CTL, 0x38, 0x28 };
264 static u8 reset[] = { RESET, 0x80 };
265 static u8 adc_ctl_1_cfg[] = { ADC_CTL_1, 0x40 };
266 static u8 agc_cfg[] = { AGC_TARGET, 0x28, 0x20 };
267 static u8 gpp_ctl_cfg[] = { GPP_CTL, 0x33 };
268 static u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 };
269
270 mt352_write(fe, clock_config, sizeof(clock_config));
271 udelay(200);
272 mt352_write(fe, reset, sizeof(reset));
273 mt352_write(fe, adc_ctl_1_cfg, sizeof(adc_ctl_1_cfg));
274
275 mt352_write(fe, agc_cfg, sizeof(agc_cfg));
276 mt352_write(fe, gpp_ctl_cfg, sizeof(gpp_ctl_cfg));
277 mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg));
278
279 return 0;
280 }
281
282 /* Callbacks for DVB USB */
283 static struct tda10023_config anysee_tda10023_config = {
284 .demod_address = (0x1a >> 1),
285 .invert = 0,
286 .xtal = 16000000,
287 .pll_m = 11,
288 .pll_p = 3,
289 .pll_n = 1,
290 .output_mode = TDA10023_OUTPUT_MODE_PARALLEL_C,
291 .deltaf = 0xfeeb,
292 };
293
294 static struct mt352_config anysee_mt352_config = {
295 .demod_address = (0x1e >> 1),
296 .demod_init = anysee_mt352_demod_init,
297 };
298
299 static struct zl10353_config anysee_zl10353_config = {
300 .demod_address = (0x1e >> 1),
301 .parallel_ts = 1,
302 };
303
304 static struct zl10353_config anysee_zl10353_tda18212_config2 = {
305 .demod_address = (0x1e >> 1),
306 .parallel_ts = 1,
307 .disable_i2c_gate_ctrl = 1,
308 .no_tuner = 1,
309 .if2 = 41500,
310 };
311
312 static struct zl10353_config anysee_zl10353_tda18212_config = {
313 .demod_address = (0x18 >> 1),
314 .parallel_ts = 1,
315 .disable_i2c_gate_ctrl = 1,
316 .no_tuner = 1,
317 .if2 = 41500,
318 };
319
320 static struct tda10023_config anysee_tda10023_tda18212_config = {
321 .demod_address = (0x1a >> 1),
322 .xtal = 16000000,
323 .pll_m = 12,
324 .pll_p = 3,
325 .pll_n = 1,
326 .output_mode = TDA10023_OUTPUT_MODE_PARALLEL_B,
327 .deltaf = 0xba02,
328 };
329
330 static struct tda18212_config anysee_tda18212_config = {
331 .if_dvbt_6 = 4150,
332 .if_dvbt_7 = 4150,
333 .if_dvbt_8 = 4150,
334 .if_dvbc = 5000,
335 };
336
337 static struct tda18212_config anysee_tda18212_config2 = {
338 .if_dvbt_6 = 3550,
339 .if_dvbt_7 = 3700,
340 .if_dvbt_8 = 4150,
341 .if_dvbt2_6 = 3250,
342 .if_dvbt2_7 = 4000,
343 .if_dvbt2_8 = 4000,
344 .if_dvbc = 5000,
345 };
346
347 static struct cx24116_config anysee_cx24116_config = {
348 .demod_address = (0xaa >> 1),
349 .mpg_clk_pos_pol = 0x00,
350 .i2c_wr_max = 48,
351 };
352
353 static struct stv0900_config anysee_stv0900_config = {
354 .demod_address = (0xd0 >> 1),
355 .demod_mode = 0,
356 .xtal = 8000000,
357 .clkmode = 3,
358 .diseqc_mode = 2,
359 .tun1_maddress = 0,
360 .tun1_adc = 1, /* 1 Vpp */
361 .path1_mode = 3,
362 };
363
364 static struct stv6110_config anysee_stv6110_config = {
365 .i2c_address = (0xc0 >> 1),
366 .mclk = 16000000,
367 .clk_div = 1,
368 };
369
370 static struct isl6423_config anysee_isl6423_config = {
371 .current_max = SEC_CURRENT_800m,
372 .curlim = SEC_CURRENT_LIM_OFF,
373 .mod_extern = 1,
374 .addr = (0x10 >> 1),
375 };
376
377 static struct cxd2820r_config anysee_cxd2820r_config = {
378 .i2c_address = 0x6d, /* (0xda >> 1) */
379 .ts_mode = 0x38,
380 };
381
382 /*
383 * New USB device strings: Mfr=1, Product=2, SerialNumber=0
384 * Manufacturer: AMT.CO.KR
385 *
386 * E30 VID=04b4 PID=861f HW=2 FW=2.1 Product=????????
387 * PCB: ?
388 * parts: DNOS404ZH102A(MT352, DTT7579(?))
389 *
390 * E30 VID=04b4 PID=861f HW=2 FW=2.1 "anysee-T(LP)"
391 * PCB: PCB 507T (rev1.61)
392 * parts: DNOS404ZH103A(ZL10353, DTT7579(?))
393 * OEA=0a OEB=00 OEC=00 OED=ff OEE=00
394 * IOA=45 IOB=ff IOC=00 IOD=ff IOE=00
395 *
396 * E30 Plus VID=04b4 PID=861f HW=6 FW=1.0 "anysee"
397 * PCB: 507CD (rev1.1)
398 * parts: DNOS404ZH103A(ZL10353, DTT7579(?)), CST56I01
399 * OEA=80 OEB=00 OEC=00 OED=ff OEE=fe
400 * IOA=4f IOB=ff IOC=00 IOD=06 IOE=01
401 * IOD[0] ZL10353 1=enabled
402 * IOA[7] TS 0=enabled
403 * tuner is not behind ZL10353 I2C-gate (no care if gate disabled or not)
404 *
405 * E30 C Plus VID=04b4 PID=861f HW=10 FW=1.0 "anysee-DC(LP)"
406 * PCB: 507DC (rev0.2)
407 * parts: TDA10023, DTOS403IH102B TM, CST56I01
408 * OEA=80 OEB=00 OEC=00 OED=ff OEE=fe
409 * IOA=4f IOB=ff IOC=00 IOD=26 IOE=01
410 * IOD[0] TDA10023 1=enabled
411 *
412 * E30 S2 Plus VID=04b4 PID=861f HW=11 FW=0.1 "anysee-S2(LP)"
413 * PCB: 507SI (rev2.1)
414 * parts: BS2N10WCC01(CX24116, CX24118), ISL6423, TDA8024
415 * OEA=80 OEB=00 OEC=ff OED=ff OEE=fe
416 * IOA=4d IOB=ff IOC=00 IOD=26 IOE=01
417 * IOD[0] CX24116 1=enabled
418 *
419 * E30 C Plus VID=1c73 PID=861f HW=15 FW=1.2 "anysee-FA(LP)"
420 * PCB: 507FA (rev0.4)
421 * parts: TDA10023, DTOS403IH102B TM, TDA8024
422 * OEA=80 OEB=00 OEC=ff OED=ff OEE=ff
423 * IOA=4d IOB=ff IOC=00 IOD=00 IOE=c0
424 * IOD[5] TDA10023 1=enabled
425 * IOE[0] tuner 1=enabled
426 *
427 * E30 Combo Plus VID=1c73 PID=861f HW=15 FW=1.2 "anysee-FA(LP)"
428 * PCB: 507FA (rev1.1)
429 * parts: ZL10353, TDA10023, DTOS403IH102B TM, TDA8024
430 * OEA=80 OEB=00 OEC=ff OED=ff OEE=ff
431 * IOA=4d IOB=ff IOC=00 IOD=00 IOE=c0
432 * DVB-C:
433 * IOD[5] TDA10023 1=enabled
434 * IOE[0] tuner 1=enabled
435 * DVB-T:
436 * IOD[0] ZL10353 1=enabled
437 * IOE[0] tuner 0=enabled
438 * tuner is behind ZL10353 I2C-gate
439 * tuner is behind TDA10023 I2C-gate
440 *
441 * E7 TC VID=1c73 PID=861f HW=18 FW=0.7 AMTCI=0.5 "anysee-E7TC(LP)"
442 * PCB: 508TC (rev0.6)
443 * parts: ZL10353, TDA10023, DNOD44CDH086A(TDA18212)
444 * OEA=80 OEB=00 OEC=03 OED=f7 OEE=ff
445 * IOA=4d IOB=00 IOC=cc IOD=48 IOE=e4
446 * IOA[7] TS 1=enabled
447 * IOE[4] TDA18212 1=enabled
448 * DVB-C:
449 * IOD[6] ZL10353 0=disabled
450 * IOD[5] TDA10023 1=enabled
451 * IOE[0] IF 1=enabled
452 * DVB-T:
453 * IOD[5] TDA10023 0=disabled
454 * IOD[6] ZL10353 1=enabled
455 * IOE[0] IF 0=enabled
456 *
457 * E7 S2 VID=1c73 PID=861f HW=19 FW=0.4 AMTCI=0.5 "anysee-E7S2(LP)"
458 * PCB: 508S2 (rev0.7)
459 * parts: DNBU10512IST(STV0903, STV6110), ISL6423
460 * OEA=80 OEB=00 OEC=03 OED=f7 OEE=ff
461 * IOA=4d IOB=00 IOC=c4 IOD=08 IOE=e4
462 * IOA[7] TS 1=enabled
463 * IOE[5] STV0903 1=enabled
464 *
465 * E7 T2C VID=1c73 PID=861f HW=20 FW=0.1 AMTCI=0.5 "anysee-E7T2C(LP)"
466 * PCB: 508T2C (rev0.3)
467 * parts: DNOQ44QCH106A(CXD2820R, TDA18212), TDA8024
468 * OEA=80 OEB=00 OEC=03 OED=f7 OEE=ff
469 * IOA=4d IOB=00 IOC=cc IOD=48 IOE=e4
470 * IOA[7] TS 1=enabled
471 * IOE[5] CXD2820R 1=enabled
472 *
473 * E7 PTC VID=1c73 PID=861f HW=21 FW=0.1 AMTCI=?? "anysee-E7PTC(LP)"
474 * PCB: 508PTC (rev0.5)
475 * parts: ZL10353, TDA10023, DNOD44CDH086A(TDA18212)
476 * OEA=80 OEB=00 OEC=03 OED=f7 OEE=ff
477 * IOA=4d IOB=00 IOC=cc IOD=48 IOE=e4
478 * IOA[7] TS 1=enabled
479 * IOE[4] TDA18212 1=enabled
480 * DVB-C:
481 * IOD[6] ZL10353 0=disabled
482 * IOD[5] TDA10023 1=enabled
483 * IOE[0] IF 1=enabled
484 * DVB-T:
485 * IOD[5] TDA10023 0=disabled
486 * IOD[6] ZL10353 1=enabled
487 * IOE[0] IF 0=enabled
488 *
489 * E7 PS2 VID=1c73 PID=861f HW=22 FW=0.1 AMTCI=?? "anysee-E7PS2(LP)"
490 * PCB: 508PS2 (rev0.4)
491 * parts: DNBU10512IST(STV0903, STV6110), ISL6423
492 * OEA=80 OEB=00 OEC=03 OED=f7 OEE=ff
493 * IOA=4d IOB=00 IOC=c4 IOD=08 IOE=e4
494 * IOA[7] TS 1=enabled
495 * IOE[5] STV0903 1=enabled
496 */
497
498 static int anysee_read_config(struct dvb_usb_device *d)
499 {
500 struct anysee_state *state = d_to_priv(d);
501 int ret;
502 u8 hw_info[3];
503
504 /*
505 * Check which hardware we have.
506 * We must do this call two times to get reliable values (hw/fw bug).
507 */
508 ret = anysee_get_hw_info(d, hw_info);
509 if (ret)
510 goto error;
511
512 ret = anysee_get_hw_info(d, hw_info);
513 if (ret)
514 goto error;
515
516 /*
517 * Meaning of these info bytes are guessed.
518 */
519 dev_info(&d->udev->dev, "%s: firmware version %d.%d hardware id %d\n",
520 KBUILD_MODNAME, hw_info[1], hw_info[2], hw_info[0]);
521
522 state->hw = hw_info[0];
523 error:
524 return ret;
525 }
526
527 /* external I2C gate used for DNOD44CDH086A(TDA18212) tuner module */
528 static int anysee_i2c_gate_ctrl(struct dvb_frontend *fe, int enable)
529 {
530 /* enable / disable tuner access on IOE[4] */
531 return anysee_wr_reg_mask(fe_to_d(fe), REG_IOE, (enable << 4), 0x10);
532 }
533
534 static int anysee_frontend_ctrl(struct dvb_frontend *fe, int onoff)
535 {
536 struct anysee_state *state = fe_to_priv(fe);
537 struct dvb_usb_device *d = fe_to_d(fe);
538 int ret;
539 dev_dbg(&d->udev->dev, "%s: fe=%d onoff=%d\n", __func__, fe->id, onoff);
540
541 /* no frontend sleep control */
542 if (onoff == 0)
543 return 0;
544
545 switch (state->hw) {
546 case ANYSEE_HW_507FA: /* 15 */
547 /* E30 Combo Plus */
548 /* E30 C Plus */
549
550 if (fe->id == 0) {
551 /* disable DVB-T demod on IOD[0] */
552 ret = anysee_wr_reg_mask(d, REG_IOD, (0 << 0), 0x01);
553 if (ret)
554 goto error;
555
556 /* enable DVB-C demod on IOD[5] */
557 ret = anysee_wr_reg_mask(d, REG_IOD, (1 << 5), 0x20);
558 if (ret)
559 goto error;
560
561 /* enable DVB-C tuner on IOE[0] */
562 ret = anysee_wr_reg_mask(d, REG_IOE, (1 << 0), 0x01);
563 if (ret)
564 goto error;
565 } else {
566 /* disable DVB-C demod on IOD[5] */
567 ret = anysee_wr_reg_mask(d, REG_IOD, (0 << 5), 0x20);
568 if (ret)
569 goto error;
570
571 /* enable DVB-T demod on IOD[0] */
572 ret = anysee_wr_reg_mask(d, REG_IOD, (1 << 0), 0x01);
573 if (ret)
574 goto error;
575
576 /* enable DVB-T tuner on IOE[0] */
577 ret = anysee_wr_reg_mask(d, REG_IOE, (0 << 0), 0x01);
578 if (ret)
579 goto error;
580 }
581
582 break;
583 case ANYSEE_HW_508TC: /* 18 */
584 case ANYSEE_HW_508PTC: /* 21 */
585 /* E7 TC */
586 /* E7 PTC */
587
588 if (fe->id == 0) {
589 /* disable DVB-T demod on IOD[6] */
590 ret = anysee_wr_reg_mask(d, REG_IOD, (0 << 6), 0x40);
591 if (ret)
592 goto error;
593
594 /* enable DVB-C demod on IOD[5] */
595 ret = anysee_wr_reg_mask(d, REG_IOD, (1 << 5), 0x20);
596 if (ret)
597 goto error;
598
599 /* enable IF route on IOE[0] */
600 ret = anysee_wr_reg_mask(d, REG_IOE, (1 << 0), 0x01);
601 if (ret)
602 goto error;
603 } else {
604 /* disable DVB-C demod on IOD[5] */
605 ret = anysee_wr_reg_mask(d, REG_IOD, (0 << 5), 0x20);
606 if (ret)
607 goto error;
608
609 /* enable DVB-T demod on IOD[6] */
610 ret = anysee_wr_reg_mask(d, REG_IOD, (1 << 6), 0x40);
611 if (ret)
612 goto error;
613
614 /* enable IF route on IOE[0] */
615 ret = anysee_wr_reg_mask(d, REG_IOE, (0 << 0), 0x01);
616 if (ret)
617 goto error;
618 }
619
620 break;
621 default:
622 ret = 0;
623 }
624
625 error:
626 return ret;
627 }
628
629 static int anysee_add_i2c_dev(struct dvb_usb_device *d, const char *type,
630 u8 addr, void *platform_data)
631 {
632 int ret, num;
633 struct anysee_state *state = d_to_priv(d);
634 struct i2c_client *client;
635 struct i2c_adapter *adapter = &d->i2c_adap;
636 struct i2c_board_info board_info = {
637 .addr = addr,
638 .platform_data = platform_data,
639 };
640
641 strlcpy(board_info.type, type, I2C_NAME_SIZE);
642
643 /* find first free client */
644 for (num = 0; num < ANYSEE_I2C_CLIENT_MAX; num++) {
645 if (state->i2c_client[num] == NULL)
646 break;
647 }
648
649 dev_dbg(&d->udev->dev, "%s: num=%d\n", __func__, num);
650
651 if (num == ANYSEE_I2C_CLIENT_MAX) {
652 dev_err(&d->udev->dev, "%s: I2C client out of index\n",
653 KBUILD_MODNAME);
654 ret = -ENODEV;
655 goto err;
656 }
657
658 request_module("%s", board_info.type);
659
660 /* register I2C device */
661 client = i2c_new_device(adapter, &board_info);
662 if (client == NULL || client->dev.driver == NULL) {
663 ret = -ENODEV;
664 goto err;
665 }
666
667 /* increase I2C driver usage count */
668 if (!try_module_get(client->dev.driver->owner)) {
669 i2c_unregister_device(client);
670 ret = -ENODEV;
671 goto err;
672 }
673
674 state->i2c_client[num] = client;
675 return 0;
676 err:
677 dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
678 return ret;
679 }
680
681 static void anysee_del_i2c_dev(struct dvb_usb_device *d)
682 {
683 int num;
684 struct anysee_state *state = d_to_priv(d);
685 struct i2c_client *client;
686
687 /* find last used client */
688 num = ANYSEE_I2C_CLIENT_MAX;
689 while (num--) {
690 if (state->i2c_client[num] != NULL)
691 break;
692 }
693
694 dev_dbg(&d->udev->dev, "%s: num=%d\n", __func__, num);
695
696 if (num == -1) {
697 dev_err(&d->udev->dev, "%s: I2C client out of index\n",
698 KBUILD_MODNAME);
699 goto err;
700 }
701
702 client = state->i2c_client[num];
703
704 /* decrease I2C driver usage count */
705 module_put(client->dev.driver->owner);
706
707 /* unregister I2C device */
708 i2c_unregister_device(client);
709
710 state->i2c_client[num] = NULL;
711 err:
712 dev_dbg(&d->udev->dev, "%s: failed\n", __func__);
713 }
714
715 static int anysee_frontend_attach(struct dvb_usb_adapter *adap)
716 {
717 struct anysee_state *state = adap_to_priv(adap);
718 struct dvb_usb_device *d = adap_to_d(adap);
719 int ret = 0;
720 u8 tmp;
721 struct i2c_msg msg[2] = {
722 {
723 .addr = 0x60,
724 .flags = 0,
725 .len = 1,
726 .buf = "\x00",
727 }, {
728 .addr = 0x60,
729 .flags = I2C_M_RD,
730 .len = 1,
731 .buf = &tmp,
732 }
733 };
734
735 switch (state->hw) {
736 case ANYSEE_HW_507T: /* 2 */
737 /* E30 */
738
739 /* attach demod */
740 adap->fe[0] = dvb_attach(mt352_attach, &anysee_mt352_config,
741 &d->i2c_adap);
742 if (adap->fe[0])
743 break;
744
745 /* attach demod */
746 adap->fe[0] = dvb_attach(zl10353_attach, &anysee_zl10353_config,
747 &d->i2c_adap);
748
749 break;
750 case ANYSEE_HW_507CD: /* 6 */
751 /* E30 Plus */
752
753 /* enable DVB-T demod on IOD[0] */
754 ret = anysee_wr_reg_mask(d, REG_IOD, (1 << 0), 0x01);
755 if (ret)
756 goto error;
757
758 /* enable transport stream on IOA[7] */
759 ret = anysee_wr_reg_mask(d, REG_IOA, (0 << 7), 0x80);
760 if (ret)
761 goto error;
762
763 /* attach demod */
764 adap->fe[0] = dvb_attach(zl10353_attach, &anysee_zl10353_config,
765 &d->i2c_adap);
766
767 break;
768 case ANYSEE_HW_507DC: /* 10 */
769 /* E30 C Plus */
770
771 /* enable DVB-C demod on IOD[0] */
772 ret = anysee_wr_reg_mask(d, REG_IOD, (1 << 0), 0x01);
773 if (ret)
774 goto error;
775
776 /* attach demod */
777 adap->fe[0] = dvb_attach(tda10023_attach,
778 &anysee_tda10023_config, &d->i2c_adap, 0x48);
779
780 break;
781 case ANYSEE_HW_507SI: /* 11 */
782 /* E30 S2 Plus */
783
784 /* enable DVB-S/S2 demod on IOD[0] */
785 ret = anysee_wr_reg_mask(d, REG_IOD, (1 << 0), 0x01);
786 if (ret)
787 goto error;
788
789 /* attach demod */
790 adap->fe[0] = dvb_attach(cx24116_attach, &anysee_cx24116_config,
791 &d->i2c_adap);
792
793 break;
794 case ANYSEE_HW_507FA: /* 15 */
795 /* E30 Combo Plus */
796 /* E30 C Plus */
797
798 /* enable tuner on IOE[4] */
799 ret = anysee_wr_reg_mask(d, REG_IOE, (1 << 4), 0x10);
800 if (ret)
801 goto error;
802
803 /* probe TDA18212 */
804 tmp = 0;
805 ret = i2c_transfer(&d->i2c_adap, msg, 2);
806 if (ret == 2 && tmp == 0xc7) {
807 dev_dbg(&d->udev->dev, "%s: TDA18212 found\n",
808 __func__);
809 state->has_tda18212 = true;
810 }
811 else
812 tmp = 0;
813
814 /* disable tuner on IOE[4] */
815 ret = anysee_wr_reg_mask(d, REG_IOE, (0 << 4), 0x10);
816 if (ret)
817 goto error;
818
819 /* disable DVB-T demod on IOD[0] */
820 ret = anysee_wr_reg_mask(d, REG_IOD, (0 << 0), 0x01);
821 if (ret)
822 goto error;
823
824 /* enable DVB-C demod on IOD[5] */
825 ret = anysee_wr_reg_mask(d, REG_IOD, (1 << 5), 0x20);
826 if (ret)
827 goto error;
828
829 /* attach demod */
830 if (tmp == 0xc7) {
831 /* TDA18212 config */
832 adap->fe[0] = dvb_attach(tda10023_attach,
833 &anysee_tda10023_tda18212_config,
834 &d->i2c_adap, 0x48);
835
836 /* I2C gate for DNOD44CDH086A(TDA18212) tuner module */
837 if (adap->fe[0])
838 adap->fe[0]->ops.i2c_gate_ctrl =
839 anysee_i2c_gate_ctrl;
840 } else {
841 /* PLL config */
842 adap->fe[0] = dvb_attach(tda10023_attach,
843 &anysee_tda10023_config,
844 &d->i2c_adap, 0x48);
845 }
846
847 /* break out if first frontend attaching fails */
848 if (!adap->fe[0])
849 break;
850
851 /* disable DVB-C demod on IOD[5] */
852 ret = anysee_wr_reg_mask(d, REG_IOD, (0 << 5), 0x20);
853 if (ret)
854 goto error;
855
856 /* enable DVB-T demod on IOD[0] */
857 ret = anysee_wr_reg_mask(d, REG_IOD, (1 << 0), 0x01);
858 if (ret)
859 goto error;
860
861 /* attach demod */
862 if (tmp == 0xc7) {
863 /* TDA18212 config */
864 adap->fe[1] = dvb_attach(zl10353_attach,
865 &anysee_zl10353_tda18212_config2,
866 &d->i2c_adap);
867
868 /* I2C gate for DNOD44CDH086A(TDA18212) tuner module */
869 if (adap->fe[1])
870 adap->fe[1]->ops.i2c_gate_ctrl =
871 anysee_i2c_gate_ctrl;
872 } else {
873 /* PLL config */
874 adap->fe[1] = dvb_attach(zl10353_attach,
875 &anysee_zl10353_config,
876 &d->i2c_adap);
877 }
878
879 break;
880 case ANYSEE_HW_508TC: /* 18 */
881 case ANYSEE_HW_508PTC: /* 21 */
882 /* E7 TC */
883 /* E7 PTC */
884
885 /* disable DVB-T demod on IOD[6] */
886 ret = anysee_wr_reg_mask(d, REG_IOD, (0 << 6), 0x40);
887 if (ret)
888 goto error;
889
890 /* enable DVB-C demod on IOD[5] */
891 ret = anysee_wr_reg_mask(d, REG_IOD, (1 << 5), 0x20);
892 if (ret)
893 goto error;
894
895 /* attach demod */
896 adap->fe[0] = dvb_attach(tda10023_attach,
897 &anysee_tda10023_tda18212_config,
898 &d->i2c_adap, 0x48);
899
900 /* I2C gate for DNOD44CDH086A(TDA18212) tuner module */
901 if (adap->fe[0])
902 adap->fe[0]->ops.i2c_gate_ctrl = anysee_i2c_gate_ctrl;
903
904 /* break out if first frontend attaching fails */
905 if (!adap->fe[0])
906 break;
907
908 /* disable DVB-C demod on IOD[5] */
909 ret = anysee_wr_reg_mask(d, REG_IOD, (0 << 5), 0x20);
910 if (ret)
911 goto error;
912
913 /* enable DVB-T demod on IOD[6] */
914 ret = anysee_wr_reg_mask(d, REG_IOD, (1 << 6), 0x40);
915 if (ret)
916 goto error;
917
918 /* attach demod */
919 adap->fe[1] = dvb_attach(zl10353_attach,
920 &anysee_zl10353_tda18212_config,
921 &d->i2c_adap);
922
923 /* I2C gate for DNOD44CDH086A(TDA18212) tuner module */
924 if (adap->fe[1])
925 adap->fe[1]->ops.i2c_gate_ctrl = anysee_i2c_gate_ctrl;
926
927 state->has_ci = true;
928
929 break;
930 case ANYSEE_HW_508S2: /* 19 */
931 case ANYSEE_HW_508PS2: /* 22 */
932 /* E7 S2 */
933 /* E7 PS2 */
934
935 /* enable DVB-S/S2 demod on IOE[5] */
936 ret = anysee_wr_reg_mask(d, REG_IOE, (1 << 5), 0x20);
937 if (ret)
938 goto error;
939
940 /* attach demod */
941 adap->fe[0] = dvb_attach(stv0900_attach,
942 &anysee_stv0900_config, &d->i2c_adap, 0);
943
944 state->has_ci = true;
945
946 break;
947 case ANYSEE_HW_508T2C: /* 20 */
948 /* E7 T2C */
949
950 /* enable DVB-T/T2/C demod on IOE[5] */
951 ret = anysee_wr_reg_mask(d, REG_IOE, (1 << 5), 0x20);
952 if (ret)
953 goto error;
954
955 /* attach demod */
956 adap->fe[0] = dvb_attach(cxd2820r_attach,
957 &anysee_cxd2820r_config, &d->i2c_adap, NULL);
958
959 state->has_ci = true;
960
961 break;
962 }
963
964 if (!adap->fe[0]) {
965 /* we have no frontend :-( */
966 ret = -ENODEV;
967 dev_err(&d->udev->dev,
968 "%s: Unsupported Anysee version. Please report to <linux-media@vger.kernel.org>.\n",
969 KBUILD_MODNAME);
970 }
971 error:
972 return ret;
973 }
974
975 static int anysee_tuner_attach(struct dvb_usb_adapter *adap)
976 {
977 struct anysee_state *state = adap_to_priv(adap);
978 struct dvb_usb_device *d = adap_to_d(adap);
979 struct dvb_frontend *fe;
980 int ret;
981 dev_dbg(&d->udev->dev, "%s:\n", __func__);
982
983 switch (state->hw) {
984 case ANYSEE_HW_507T: /* 2 */
985 /* E30 */
986
987 /* attach tuner */
988 fe = dvb_attach(dvb_pll_attach, adap->fe[0], (0xc2 >> 1), NULL,
989 DVB_PLL_THOMSON_DTT7579);
990
991 break;
992 case ANYSEE_HW_507CD: /* 6 */
993 /* E30 Plus */
994
995 /* attach tuner */
996 fe = dvb_attach(dvb_pll_attach, adap->fe[0], (0xc2 >> 1),
997 &d->i2c_adap, DVB_PLL_THOMSON_DTT7579);
998
999 break;
1000 case ANYSEE_HW_507DC: /* 10 */
1001 /* E30 C Plus */
1002
1003 /* attach tuner */
1004 fe = dvb_attach(dvb_pll_attach, adap->fe[0], (0xc0 >> 1),
1005 &d->i2c_adap, DVB_PLL_SAMSUNG_DTOS403IH102A);
1006
1007 break;
1008 case ANYSEE_HW_507SI: /* 11 */
1009 /* E30 S2 Plus */
1010
1011 /* attach LNB controller */
1012 fe = dvb_attach(isl6423_attach, adap->fe[0], &d->i2c_adap,
1013 &anysee_isl6423_config);
1014
1015 break;
1016 case ANYSEE_HW_507FA: /* 15 */
1017 /* E30 Combo Plus */
1018 /* E30 C Plus */
1019
1020 /* Try first attach TDA18212 silicon tuner on IOE[4], if that
1021 * fails attach old simple PLL. */
1022
1023 /* attach tuner */
1024 if (state->has_tda18212) {
1025 struct tda18212_config tda18212_config =
1026 anysee_tda18212_config;
1027
1028 tda18212_config.fe = adap->fe[0];
1029 ret = anysee_add_i2c_dev(d, "tda18212", 0x60,
1030 &tda18212_config);
1031 if (ret)
1032 goto err;
1033
1034 /* copy tuner ops for 2nd FE as tuner is shared */
1035 if (adap->fe[1]) {
1036 adap->fe[1]->tuner_priv =
1037 adap->fe[0]->tuner_priv;
1038 memcpy(&adap->fe[1]->ops.tuner_ops,
1039 &adap->fe[0]->ops.tuner_ops,
1040 sizeof(struct dvb_tuner_ops));
1041 }
1042
1043 return 0;
1044 } else {
1045 /* attach tuner */
1046 fe = dvb_attach(dvb_pll_attach, adap->fe[0],
1047 (0xc0 >> 1), &d->i2c_adap,
1048 DVB_PLL_SAMSUNG_DTOS403IH102A);
1049
1050 if (fe && adap->fe[1]) {
1051 /* attach tuner for 2nd FE */
1052 fe = dvb_attach(dvb_pll_attach, adap->fe[1],
1053 (0xc0 >> 1), &d->i2c_adap,
1054 DVB_PLL_SAMSUNG_DTOS403IH102A);
1055 }
1056 }
1057
1058 break;
1059 case ANYSEE_HW_508TC: /* 18 */
1060 case ANYSEE_HW_508PTC: /* 21 */
1061 {
1062 /* E7 TC */
1063 /* E7 PTC */
1064 struct tda18212_config tda18212_config = anysee_tda18212_config;
1065
1066 tda18212_config.fe = adap->fe[0];
1067 ret = anysee_add_i2c_dev(d, "tda18212", 0x60, &tda18212_config);
1068 if (ret)
1069 goto err;
1070
1071 /* copy tuner ops for 2nd FE as tuner is shared */
1072 if (adap->fe[1]) {
1073 adap->fe[1]->tuner_priv = adap->fe[0]->tuner_priv;
1074 memcpy(&adap->fe[1]->ops.tuner_ops,
1075 &adap->fe[0]->ops.tuner_ops,
1076 sizeof(struct dvb_tuner_ops));
1077 }
1078
1079 return 0;
1080 }
1081 case ANYSEE_HW_508S2: /* 19 */
1082 case ANYSEE_HW_508PS2: /* 22 */
1083 /* E7 S2 */
1084 /* E7 PS2 */
1085
1086 /* attach tuner */
1087 fe = dvb_attach(stv6110_attach, adap->fe[0],
1088 &anysee_stv6110_config, &d->i2c_adap);
1089
1090 if (fe) {
1091 /* attach LNB controller */
1092 fe = dvb_attach(isl6423_attach, adap->fe[0],
1093 &d->i2c_adap, &anysee_isl6423_config);
1094 }
1095
1096 break;
1097
1098 case ANYSEE_HW_508T2C: /* 20 */
1099 {
1100 /* E7 T2C */
1101 struct tda18212_config tda18212_config =
1102 anysee_tda18212_config2;
1103
1104 tda18212_config.fe = adap->fe[0];
1105 ret = anysee_add_i2c_dev(d, "tda18212", 0x60, &tda18212_config);
1106 if (ret)
1107 goto err;
1108
1109 return 0;
1110 }
1111 default:
1112 fe = NULL;
1113 }
1114
1115 if (fe)
1116 ret = 0;
1117 else
1118 ret = -ENODEV;
1119 err:
1120 return ret;
1121 }
1122
1123 #if IS_ENABLED(CONFIG_RC_CORE)
1124 static int anysee_rc_query(struct dvb_usb_device *d)
1125 {
1126 u8 buf[] = {CMD_GET_IR_CODE};
1127 u8 ircode[2];
1128 int ret;
1129
1130 /* Remote controller is basic NEC using address byte 0x08.
1131 Anysee device RC query returns only two bytes, status and code,
1132 address byte is dropped. Also it does not return any value for
1133 NEC RCs having address byte other than 0x08. Due to that, we
1134 cannot use that device as standard NEC receiver.
1135 It could be possible make hack which reads whole code directly
1136 from device memory... */
1137
1138 ret = anysee_ctrl_msg(d, buf, sizeof(buf), ircode, sizeof(ircode));
1139 if (ret)
1140 return ret;
1141
1142 if (ircode[0]) {
1143 dev_dbg(&d->udev->dev, "%s: key pressed %02x\n", __func__,
1144 ircode[1]);
1145 rc_keydown(d->rc_dev, RC_PROTO_NEC,
1146 RC_SCANCODE_NEC(0x08, ircode[1]), 0);
1147 }
1148
1149 return 0;
1150 }
1151
1152 static int anysee_get_rc_config(struct dvb_usb_device *d, struct dvb_usb_rc *rc)
1153 {
1154 rc->allowed_protos = RC_PROTO_BIT_NEC;
1155 rc->query = anysee_rc_query;
1156 rc->interval = 250; /* windows driver uses 500ms */
1157
1158 return 0;
1159 }
1160 #else
1161 #define anysee_get_rc_config NULL
1162 #endif
1163
1164 static int anysee_ci_read_attribute_mem(struct dvb_ca_en50221 *ci, int slot,
1165 int addr)
1166 {
1167 struct dvb_usb_device *d = ci->data;
1168 int ret;
1169 u8 buf[] = {CMD_CI, 0x02, 0x40 | addr >> 8, addr & 0xff, 0x00, 1};
1170 u8 val;
1171
1172 ret = anysee_ctrl_msg(d, buf, sizeof(buf), &val, 1);
1173 if (ret)
1174 return ret;
1175
1176 return val;
1177 }
1178
1179 static int anysee_ci_write_attribute_mem(struct dvb_ca_en50221 *ci, int slot,
1180 int addr, u8 val)
1181 {
1182 struct dvb_usb_device *d = ci->data;
1183 int ret;
1184 u8 buf[] = {CMD_CI, 0x03, 0x40 | addr >> 8, addr & 0xff, 0x00, 1, val};
1185
1186 ret = anysee_ctrl_msg(d, buf, sizeof(buf), NULL, 0);
1187 if (ret)
1188 return ret;
1189
1190 return 0;
1191 }
1192
1193 static int anysee_ci_read_cam_control(struct dvb_ca_en50221 *ci, int slot,
1194 u8 addr)
1195 {
1196 struct dvb_usb_device *d = ci->data;
1197 int ret;
1198 u8 buf[] = {CMD_CI, 0x04, 0x40, addr, 0x00, 1};
1199 u8 val;
1200
1201 ret = anysee_ctrl_msg(d, buf, sizeof(buf), &val, 1);
1202 if (ret)
1203 return ret;
1204
1205 return val;
1206 }
1207
1208 static int anysee_ci_write_cam_control(struct dvb_ca_en50221 *ci, int slot,
1209 u8 addr, u8 val)
1210 {
1211 struct dvb_usb_device *d = ci->data;
1212 int ret;
1213 u8 buf[] = {CMD_CI, 0x05, 0x40, addr, 0x00, 1, val};
1214
1215 ret = anysee_ctrl_msg(d, buf, sizeof(buf), NULL, 0);
1216 if (ret)
1217 return ret;
1218
1219 return 0;
1220 }
1221
1222 static int anysee_ci_slot_reset(struct dvb_ca_en50221 *ci, int slot)
1223 {
1224 struct dvb_usb_device *d = ci->data;
1225 int ret;
1226 struct anysee_state *state = d_to_priv(d);
1227
1228 state->ci_cam_ready = jiffies + msecs_to_jiffies(1000);
1229
1230 ret = anysee_wr_reg_mask(d, REG_IOA, (0 << 7), 0x80);
1231 if (ret)
1232 return ret;
1233
1234 msleep(300);
1235
1236 ret = anysee_wr_reg_mask(d, REG_IOA, (1 << 7), 0x80);
1237 if (ret)
1238 return ret;
1239
1240 return 0;
1241 }
1242
1243 static int anysee_ci_slot_shutdown(struct dvb_ca_en50221 *ci, int slot)
1244 {
1245 struct dvb_usb_device *d = ci->data;
1246 int ret;
1247
1248 ret = anysee_wr_reg_mask(d, REG_IOA, (0 << 7), 0x80);
1249 if (ret)
1250 return ret;
1251
1252 msleep(30);
1253
1254 ret = anysee_wr_reg_mask(d, REG_IOA, (1 << 7), 0x80);
1255 if (ret)
1256 return ret;
1257
1258 return 0;
1259 }
1260
1261 static int anysee_ci_slot_ts_enable(struct dvb_ca_en50221 *ci, int slot)
1262 {
1263 struct dvb_usb_device *d = ci->data;
1264 int ret;
1265
1266 ret = anysee_wr_reg_mask(d, REG_IOD, (0 << 1), 0x02);
1267 if (ret)
1268 return ret;
1269
1270 return 0;
1271 }
1272
1273 static int anysee_ci_poll_slot_status(struct dvb_ca_en50221 *ci, int slot,
1274 int open)
1275 {
1276 struct dvb_usb_device *d = ci->data;
1277 struct anysee_state *state = d_to_priv(d);
1278 int ret;
1279 u8 tmp = 0;
1280
1281 ret = anysee_rd_reg_mask(d, REG_IOC, &tmp, 0x40);
1282 if (ret)
1283 return ret;
1284
1285 if (tmp == 0) {
1286 ret = DVB_CA_EN50221_POLL_CAM_PRESENT;
1287 if (time_after(jiffies, state->ci_cam_ready))
1288 ret |= DVB_CA_EN50221_POLL_CAM_READY;
1289 }
1290
1291 return ret;
1292 }
1293
1294 static int anysee_ci_init(struct dvb_usb_device *d)
1295 {
1296 struct anysee_state *state = d_to_priv(d);
1297 int ret;
1298
1299 state->ci.owner = THIS_MODULE;
1300 state->ci.read_attribute_mem = anysee_ci_read_attribute_mem;
1301 state->ci.write_attribute_mem = anysee_ci_write_attribute_mem;
1302 state->ci.read_cam_control = anysee_ci_read_cam_control;
1303 state->ci.write_cam_control = anysee_ci_write_cam_control;
1304 state->ci.slot_reset = anysee_ci_slot_reset;
1305 state->ci.slot_shutdown = anysee_ci_slot_shutdown;
1306 state->ci.slot_ts_enable = anysee_ci_slot_ts_enable;
1307 state->ci.poll_slot_status = anysee_ci_poll_slot_status;
1308 state->ci.data = d;
1309
1310 ret = anysee_wr_reg_mask(d, REG_IOA, (1 << 7), 0x80);
1311 if (ret)
1312 return ret;
1313
1314 ret = anysee_wr_reg_mask(d, REG_IOD, (0 << 2)|(0 << 1)|(0 << 0), 0x07);
1315 if (ret)
1316 return ret;
1317
1318 ret = anysee_wr_reg_mask(d, REG_IOD, (1 << 2)|(1 << 1)|(1 << 0), 0x07);
1319 if (ret)
1320 return ret;
1321
1322 ret = dvb_ca_en50221_init(&d->adapter[0].dvb_adap, &state->ci, 0, 1);
1323 if (ret)
1324 return ret;
1325
1326 state->ci_attached = true;
1327
1328 return 0;
1329 }
1330
1331 static void anysee_ci_release(struct dvb_usb_device *d)
1332 {
1333 struct anysee_state *state = d_to_priv(d);
1334
1335 /* detach CI */
1336 if (state->ci_attached)
1337 dvb_ca_en50221_release(&state->ci);
1338
1339 return;
1340 }
1341
1342 static int anysee_init(struct dvb_usb_device *d)
1343 {
1344 struct anysee_state *state = d_to_priv(d);
1345 int ret;
1346
1347 /* There is one interface with two alternate settings.
1348 Alternate setting 0 is for bulk transfer.
1349 Alternate setting 1 is for isochronous transfer.
1350 We use bulk transfer (alternate setting 0). */
1351 ret = usb_set_interface(d->udev, 0, 0);
1352 if (ret)
1353 return ret;
1354
1355 /* LED light */
1356 ret = anysee_led_ctrl(d, 0x01, 0x03);
1357 if (ret)
1358 return ret;
1359
1360 /* enable IR */
1361 ret = anysee_ir_ctrl(d, 1);
1362 if (ret)
1363 return ret;
1364
1365 /* attach CI */
1366 if (state->has_ci) {
1367 ret = anysee_ci_init(d);
1368 if (ret)
1369 return ret;
1370 }
1371
1372 return 0;
1373 }
1374
1375 static void anysee_exit(struct dvb_usb_device *d)
1376 {
1377 struct anysee_state *state = d_to_priv(d);
1378
1379 if (state->i2c_client[0])
1380 anysee_del_i2c_dev(d);
1381
1382 return anysee_ci_release(d);
1383 }
1384
1385 /* DVB USB Driver stuff */
1386 static struct dvb_usb_device_properties anysee_props = {
1387 .driver_name = KBUILD_MODNAME,
1388 .owner = THIS_MODULE,
1389 .adapter_nr = adapter_nr,
1390 .size_of_priv = sizeof(struct anysee_state),
1391
1392 .generic_bulk_ctrl_endpoint = 0x01,
1393 .generic_bulk_ctrl_endpoint_response = 0x81,
1394
1395 .i2c_algo = &anysee_i2c_algo,
1396 .read_config = anysee_read_config,
1397 .frontend_attach = anysee_frontend_attach,
1398 .tuner_attach = anysee_tuner_attach,
1399 .init = anysee_init,
1400 .get_rc_config = anysee_get_rc_config,
1401 .frontend_ctrl = anysee_frontend_ctrl,
1402 .streaming_ctrl = anysee_streaming_ctrl,
1403 .exit = anysee_exit,
1404
1405 .num_adapters = 1,
1406 .adapter = {
1407 {
1408 .stream = DVB_USB_STREAM_BULK(0x82, 8, 16 * 512),
1409 }
1410 }
1411 };
1412
1413 static const struct usb_device_id anysee_id_table[] = {
1414 { DVB_USB_DEVICE(USB_VID_CYPRESS, USB_PID_ANYSEE,
1415 &anysee_props, "Anysee", RC_MAP_ANYSEE) },
1416 { DVB_USB_DEVICE(USB_VID_AMT, USB_PID_ANYSEE,
1417 &anysee_props, "Anysee", RC_MAP_ANYSEE) },
1418 { }
1419 };
1420 MODULE_DEVICE_TABLE(usb, anysee_id_table);
1421
1422 static struct usb_driver anysee_usb_driver = {
1423 .name = KBUILD_MODNAME,
1424 .id_table = anysee_id_table,
1425 .probe = dvb_usbv2_probe,
1426 .disconnect = dvb_usbv2_disconnect,
1427 .suspend = dvb_usbv2_suspend,
1428 .resume = dvb_usbv2_resume,
1429 .reset_resume = dvb_usbv2_reset_resume,
1430 .no_dynamic_id = 1,
1431 .soft_unbind = 1,
1432 };
1433
1434 module_usb_driver(anysee_usb_driver);
1435
1436 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1437 MODULE_DESCRIPTION("Driver Anysee E30 DVB-C & DVB-T USB2.0");
1438 MODULE_LICENSE("GPL");
CRIS linux kernel tree