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