Version:  2.0.40 2.2.26 2.4.37 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18

Linux/drivers/media/usb/dvb-usb-v2/anysee.c

  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");
1443 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us