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