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         .i2c_address = (0xc0 >> 1),
 336         .if_dvbt_6 = 4150,
 337         .if_dvbt_7 = 4150,
 338         .if_dvbt_8 = 4150,
 339         .if_dvbc = 5000,
 340 };
 341
 342 static struct tda18212_config anysee_tda18212_config2 = {
 343         .i2c_address = 0x60 /* (0xc0 >> 1) */,
 344         .if_dvbt_6 = 3550,
 345         .if_dvbt_7 = 3700,
 346         .if_dvbt_8 = 4150,
 347         .if_dvbt2_6 = 3250,
 348         .if_dvbt2_7 = 4000,
 349         .if_dvbt2_8 = 4000,
 350         .if_dvbc = 5000,
 351 };
 352
 353 static struct cx24116_config anysee_cx24116_config = {
 354         .demod_address = (0xaa >> 1),
 355         .mpg_clk_pos_pol = 0x00,
 356         .i2c_wr_max = 48,
 357 };
 358
 359 static struct stv0900_config anysee_stv0900_config = {
 360         .demod_address = (0xd0 >> 1),
 361         .demod_mode = 0,
 362         .xtal = 8000000,
 363         .clkmode = 3,
 364         .diseqc_mode = 2,
 365         .tun1_maddress = 0,
 366         .tun1_adc = 1, /* 1 Vpp */
 367         .path1_mode = 3,
 368 };
 369
 370 static struct stv6110_config anysee_stv6110_config = {
 371         .i2c_address = (0xc0 >> 1),
 372         .mclk = 16000000,
 373         .clk_div = 1,
 374 };
 375
 376 static struct isl6423_config anysee_isl6423_config = {
 377         .current_max = SEC_CURRENT_800m,
 378         .curlim  = SEC_CURRENT_LIM_OFF,
 379         .mod_extern = 1,
 380         .addr = (0x10 >> 1),
 381 };
 382
 383 static struct cxd2820r_config anysee_cxd2820r_config = {
 384         .i2c_address = 0x6d, /* (0xda >> 1) */
 385         .ts_mode = 0x38,
 386 };
 387
 388 /*
 389  * New USB device strings: Mfr=1, Product=2, SerialNumber=0
 390  * Manufacturer: AMT.CO.KR
 391  *
 392  * E30 VID=04b4 PID=861f HW=2 FW=2.1 Product=????????
 393  * PCB: ?
 394  * parts: DNOS404ZH102A(MT352, DTT7579(?))
 395  *
 396  * E30 VID=04b4 PID=861f HW=2 FW=2.1 "anysee-T(LP)"
 397  * PCB: PCB 507T (rev1.61)
 398  * parts: DNOS404ZH103A(ZL10353, DTT7579(?))
 399  * OEA=0a OEB=00 OEC=00 OED=ff OEE=00
 400  * IOA=45 IOB=ff IOC=00 IOD=ff IOE=00
 401  *
 402  * E30 Plus VID=04b4 PID=861f HW=6 FW=1.0 "anysee"
 403  * PCB: 507CD (rev1.1)
 404  * parts: DNOS404ZH103A(ZL10353, DTT7579(?)), CST56I01
 405  * OEA=80 OEB=00 OEC=00 OED=ff OEE=fe
 406  * IOA=4f IOB=ff IOC=00 IOD=06 IOE=01
 407  * IOD[0] ZL10353 1=enabled
 408  * IOA[7] TS 0=enabled
 409  * tuner is not behind ZL10353 I2C-gate (no care if gate disabled or not)
 410  *
 411  * E30 C Plus VID=04b4 PID=861f HW=10 FW=1.0 "anysee-DC(LP)"
 412  * PCB: 507DC (rev0.2)
 413  * parts: TDA10023, DTOS403IH102B TM, CST56I01
 414  * OEA=80 OEB=00 OEC=00 OED=ff OEE=fe
 415  * IOA=4f IOB=ff IOC=00 IOD=26 IOE=01
 416  * IOD[0] TDA10023 1=enabled
 417  *
 418  * E30 S2 Plus VID=04b4 PID=861f HW=11 FW=0.1 "anysee-S2(LP)"
 419  * PCB: 507SI (rev2.1)
 420  * parts: BS2N10WCC01(CX24116, CX24118), ISL6423, TDA8024
 421  * OEA=80 OEB=00 OEC=ff OED=ff OEE=fe
 422  * IOA=4d IOB=ff IOC=00 IOD=26 IOE=01
 423  * IOD[0] CX24116 1=enabled
 424  *
 425  * E30 C Plus VID=1c73 PID=861f HW=15 FW=1.2 "anysee-FA(LP)"
 426  * PCB: 507FA (rev0.4)
 427  * parts: TDA10023, DTOS403IH102B TM, TDA8024
 428  * OEA=80 OEB=00 OEC=ff OED=ff OEE=ff
 429  * IOA=4d IOB=ff IOC=00 IOD=00 IOE=c0
 430  * IOD[5] TDA10023 1=enabled
 431  * IOE[0] tuner 1=enabled
 432  *
 433  * E30 Combo Plus VID=1c73 PID=861f HW=15 FW=1.2 "anysee-FA(LP)"
 434  * PCB: 507FA (rev1.1)
 435  * parts: ZL10353, TDA10023, DTOS403IH102B TM, TDA8024
 436  * OEA=80 OEB=00 OEC=ff OED=ff OEE=ff
 437  * IOA=4d IOB=ff IOC=00 IOD=00 IOE=c0
 438  * DVB-C:
 439  * IOD[5] TDA10023 1=enabled
 440  * IOE[0] tuner 1=enabled
 441  * DVB-T:
 442  * IOD[0] ZL10353 1=enabled
 443  * IOE[0] tuner 0=enabled
 444  * tuner is behind ZL10353 I2C-gate
 445  *
 446  * E7 TC VID=1c73 PID=861f HW=18 FW=0.7 AMTCI=0.5 "anysee-E7TC(LP)"
 447  * PCB: 508TC (rev0.6)
 448  * parts: ZL10353, TDA10023, DNOD44CDH086A(TDA18212)
 449  * OEA=80 OEB=00 OEC=03 OED=f7 OEE=ff
 450  * IOA=4d IOB=00 IOC=cc IOD=48 IOE=e4
 451  * IOA[7] TS 1=enabled
 452  * IOE[4] TDA18212 1=enabled
 453  * DVB-C:
 454  * IOD[6] ZL10353 0=disabled
 455  * IOD[5] TDA10023 1=enabled
 456  * IOE[0] IF 1=enabled
 457  * DVB-T:
 458  * IOD[5] TDA10023 0=disabled
 459  * IOD[6] ZL10353 1=enabled
 460  * IOE[0] IF 0=enabled
 461  *
 462  * E7 S2 VID=1c73 PID=861f HW=19 FW=0.4 AMTCI=0.5 "anysee-E7S2(LP)"
 463  * PCB: 508S2 (rev0.7)
 464  * parts: DNBU10512IST(STV0903, STV6110), ISL6423
 465  * OEA=80 OEB=00 OEC=03 OED=f7 OEE=ff
 466  * IOA=4d IOB=00 IOC=c4 IOD=08 IOE=e4
 467  * IOA[7] TS 1=enabled
 468  * IOE[5] STV0903 1=enabled
 469  *
 470  * E7 T2C VID=1c73 PID=861f HW=20 FW=0.1 AMTCI=0.5 "anysee-E7T2C(LP)"
 471  * PCB: 508T2C (rev0.3)
 472  * parts: DNOQ44QCH106A(CXD2820R, TDA18212), TDA8024
 473  * OEA=80 OEB=00 OEC=03 OED=f7 OEE=ff
 474  * IOA=4d IOB=00 IOC=cc IOD=48 IOE=e4
 475  * IOA[7] TS 1=enabled
 476  * IOE[5] CXD2820R 1=enabled
 477  *
 478  * E7 PTC VID=1c73 PID=861f HW=21 FW=0.1 AMTCI=?? "anysee-E7PTC(LP)"
 479  * PCB: 508PTC (rev0.5)
 480  * parts: ZL10353, TDA10023, DNOD44CDH086A(TDA18212)
 481  * OEA=80 OEB=00 OEC=03 OED=f7 OEE=ff
 482  * IOA=4d IOB=00 IOC=cc IOD=48 IOE=e4
 483  * IOA[7] TS 1=enabled
 484  * IOE[4] TDA18212 1=enabled
 485  * DVB-C:
 486  * IOD[6] ZL10353 0=disabled
 487  * IOD[5] TDA10023 1=enabled
 488  * IOE[0] IF 1=enabled
 489  * DVB-T:
 490  * IOD[5] TDA10023 0=disabled
 491  * IOD[6] ZL10353 1=enabled
 492  * IOE[0] IF 0=enabled
 493  *
 494  * E7 PS2 VID=1c73 PID=861f HW=22 FW=0.1 AMTCI=?? "anysee-E7PS2(LP)"
 495  * PCB: 508PS2 (rev0.4)
 496  * parts: DNBU10512IST(STV0903, STV6110), ISL6423
 497  * OEA=80 OEB=00 OEC=03 OED=f7 OEE=ff
 498  * IOA=4d IOB=00 IOC=c4 IOD=08 IOE=e4
 499  * IOA[7] TS 1=enabled
 500  * IOE[5] STV0903 1=enabled
 501  */
 502
 503 static int anysee_read_config(struct dvb_usb_device *d)
 504 {
 505         struct anysee_state *state = d_to_priv(d);
 506         int ret;
 507         u8 hw_info[3];
 508
 509         /*
 510          * Check which hardware we have.
 511          * We must do this call two times to get reliable values (hw/fw bug).
 512          */
 513         ret = anysee_get_hw_info(d, hw_info);
 514         if (ret)
 515                 goto error;
 516
 517         ret = anysee_get_hw_info(d, hw_info);
 518         if (ret)
 519                 goto error;
 520
 521         /*
 522          * Meaning of these info bytes are guessed.
 523          */
 524         dev_info(&d->udev->dev, "%s: firmware version %d.%d hardware id %d\n",
 525                         KBUILD_MODNAME, hw_info[1], hw_info[2], hw_info[0]);
 526
 527         state->hw = hw_info[0];
 528 error:
 529         return ret;
 530 }
 531
 532 /* external I2C gate used for DNOD44CDH086A(TDA18212) tuner module */
 533 static int anysee_i2c_gate_ctrl(struct dvb_frontend *fe, int enable)
 534 {
 535         /* enable / disable tuner access on IOE[4] */
 536         return anysee_wr_reg_mask(fe_to_d(fe), REG_IOE, (enable << 4), 0x10);
 537 }
 538
 539 static int anysee_frontend_ctrl(struct dvb_frontend *fe, int onoff)
 540 {
 541         struct anysee_state *state = fe_to_priv(fe);
 542         struct dvb_usb_device *d = fe_to_d(fe);
 543         int ret;
 544         dev_dbg(&d->udev->dev, "%s: fe=%d onoff=%d\n", __func__, fe->id, onoff);
 545
 546         /* no frontend sleep control */
 547         if (onoff == 0)
 548                 return 0;
 549
 550         switch (state->hw) {
 551         case ANYSEE_HW_507FA: /* 15 */
 552                 /* E30 Combo Plus */
 553                 /* E30 C Plus */
 554
 555                 if (fe->id == 0)  {
 556                         /* disable DVB-T demod on IOD[0] */
 557                         ret = anysee_wr_reg_mask(d, REG_IOD, (0 << 0), 0x01);
 558                         if (ret)
 559                                 goto error;
 560
 561                         /* enable DVB-C demod on IOD[5] */
 562                         ret = anysee_wr_reg_mask(d, REG_IOD, (1 << 5), 0x20);
 563                         if (ret)
 564                                 goto error;
 565
 566                         /* enable DVB-C tuner on IOE[0] */
 567                         ret = anysee_wr_reg_mask(d, REG_IOE, (1 << 0), 0x01);
 568                         if (ret)
 569                                 goto error;
 570                 } else {
 571                         /* disable DVB-C demod on IOD[5] */
 572                         ret = anysee_wr_reg_mask(d, REG_IOD, (0 << 5), 0x20);
 573                         if (ret)
 574                                 goto error;
 575
 576                         /* enable DVB-T demod on IOD[0] */
 577                         ret = anysee_wr_reg_mask(d, REG_IOD, (1 << 0), 0x01);
 578                         if (ret)
 579                                 goto error;
 580
 581                         /* enable DVB-T tuner on IOE[0] */
 582                         ret = anysee_wr_reg_mask(d, REG_IOE, (0 << 0), 0x01);
 583                         if (ret)
 584                                 goto error;
 585                 }
 586
 587                 break;
 588         case ANYSEE_HW_508TC: /* 18 */
 589         case ANYSEE_HW_508PTC: /* 21 */
 590                 /* E7 TC */
 591                 /* E7 PTC */
 592
 593                 if (fe->id == 0)  {
 594                         /* disable DVB-T demod on IOD[6] */
 595                         ret = anysee_wr_reg_mask(d, REG_IOD, (0 << 6), 0x40);
 596                         if (ret)
 597                                 goto error;
 598
 599                         /* enable DVB-C demod on IOD[5] */
 600                         ret = anysee_wr_reg_mask(d, REG_IOD, (1 << 5), 0x20);
 601                         if (ret)
 602                                 goto error;
 603
 604                         /* enable IF route on IOE[0] */
 605                         ret = anysee_wr_reg_mask(d, REG_IOE, (1 << 0), 0x01);
 606                         if (ret)
 607                                 goto error;
 608                 } else {
 609                         /* disable DVB-C demod on IOD[5] */
 610                         ret = anysee_wr_reg_mask(d, REG_IOD, (0 << 5), 0x20);
 611                         if (ret)
 612                                 goto error;
 613
 614                         /* enable DVB-T demod on IOD[6] */
 615                         ret = anysee_wr_reg_mask(d, REG_IOD, (1 << 6), 0x40);
 616                         if (ret)
 617                                 goto error;
 618
 619                         /* enable IF route on IOE[0] */
 620                         ret = anysee_wr_reg_mask(d, REG_IOE, (0 << 0), 0x01);
 621                         if (ret)
 622                                 goto error;
 623                 }
 624
 625                 break;
 626         default:
 627                 ret = 0;
 628         }
 629
 630 error:
 631         return ret;
 632 }
 633
 634 static int anysee_frontend_attach(struct dvb_usb_adapter *adap)
 635 {
 636         struct anysee_state *state = adap_to_priv(adap);
 637         struct dvb_usb_device *d = adap_to_d(adap);
 638         int ret = 0;
 639         u8 tmp;
 640         struct i2c_msg msg[2] = {
 641                 {
 642                         .addr = anysee_tda18212_config.i2c_address,
 643                         .flags = 0,
 644                         .len = 1,
 645                         .buf = "\x00",
 646                 }, {
 647                         .addr = anysee_tda18212_config.i2c_address,
 648                         .flags = I2C_M_RD,
 649                         .len = 1,
 650                         .buf = &tmp,
 651                 }
 652         };
 653
 654         switch (state->hw) {
 655         case ANYSEE_HW_507T: /* 2 */
 656                 /* E30 */
 657
 658                 /* attach demod */
 659                 adap->fe[0] = dvb_attach(mt352_attach, &anysee_mt352_config,
 660                                 &d->i2c_adap);
 661                 if (adap->fe[0])
 662                         break;
 663
 664                 /* attach demod */
 665                 adap->fe[0] = dvb_attach(zl10353_attach, &anysee_zl10353_config,
 666                                 &d->i2c_adap);
 667
 668                 break;
 669         case ANYSEE_HW_507CD: /* 6 */
 670                 /* E30 Plus */
 671
 672                 /* enable DVB-T demod on IOD[0] */
 673                 ret = anysee_wr_reg_mask(d, REG_IOD, (1 << 0), 0x01);
 674                 if (ret)
 675                         goto error;
 676
 677                 /* enable transport stream on IOA[7] */
 678                 ret = anysee_wr_reg_mask(d, REG_IOA, (0 << 7), 0x80);
 679                 if (ret)
 680                         goto error;
 681
 682                 /* attach demod */
 683                 adap->fe[0] = dvb_attach(zl10353_attach, &anysee_zl10353_config,
 684                                 &d->i2c_adap);
 685
 686                 break;
 687         case ANYSEE_HW_507DC: /* 10 */
 688                 /* E30 C Plus */
 689
 690                 /* enable DVB-C demod on IOD[0] */
 691                 ret = anysee_wr_reg_mask(d, REG_IOD, (1 << 0), 0x01);
 692                 if (ret)
 693                         goto error;
 694
 695                 /* attach demod */
 696                 adap->fe[0] = dvb_attach(tda10023_attach,
 697                                 &anysee_tda10023_config, &d->i2c_adap, 0x48);
 698
 699                 break;
 700         case ANYSEE_HW_507SI: /* 11 */
 701                 /* E30 S2 Plus */
 702
 703                 /* enable DVB-S/S2 demod on IOD[0] */
 704                 ret = anysee_wr_reg_mask(d, REG_IOD, (1 << 0), 0x01);
 705                 if (ret)
 706                         goto error;
 707
 708                 /* attach demod */
 709                 adap->fe[0] = dvb_attach(cx24116_attach, &anysee_cx24116_config,
 710                                 &d->i2c_adap);
 711
 712                 break;
 713         case ANYSEE_HW_507FA: /* 15 */
 714                 /* E30 Combo Plus */
 715                 /* E30 C Plus */
 716
 717                 /* enable tuner on IOE[4] */
 718                 ret = anysee_wr_reg_mask(d, REG_IOE, (1 << 4), 0x10);
 719                 if (ret)
 720                         goto error;
 721
 722                 /* probe TDA18212 */
 723                 tmp = 0;
 724                 ret = i2c_transfer(&d->i2c_adap, msg, 2);
 725                 if (ret == 2 && tmp == 0xc7)
 726                         dev_dbg(&d->udev->dev, "%s: TDA18212 found\n",
 727                                         __func__);
 728                 else
 729                         tmp = 0;
 730
 731                 /* disable tuner on IOE[4] */
 732                 ret = anysee_wr_reg_mask(d, REG_IOE, (0 << 4), 0x10);
 733                 if (ret)
 734                         goto error;
 735
 736                 /* disable DVB-T demod on IOD[0] */
 737                 ret = anysee_wr_reg_mask(d, REG_IOD, (0 << 0), 0x01);
 738                 if (ret)
 739                         goto error;
 740
 741                 /* enable DVB-C demod on IOD[5] */
 742                 ret = anysee_wr_reg_mask(d, REG_IOD, (1 << 5), 0x20);
 743                 if (ret)
 744                         goto error;
 745
 746                 /* attach demod */
 747                 if (tmp == 0xc7) {
 748                         /* TDA18212 config */
 749                         adap->fe[0] = dvb_attach(tda10023_attach,
 750                                         &anysee_tda10023_tda18212_config,
 751                                         &d->i2c_adap, 0x48);
 752
 753                         /* I2C gate for DNOD44CDH086A(TDA18212) tuner module */
 754                         if (adap->fe[0])
 755                                 adap->fe[0]->ops.i2c_gate_ctrl =
 756                                                 anysee_i2c_gate_ctrl;
 757                 } else {
 758                         /* PLL config */
 759                         adap->fe[0] = dvb_attach(tda10023_attach,
 760                                         &anysee_tda10023_config,
 761                                         &d->i2c_adap, 0x48);
 762                 }
 763
 764                 /* break out if first frontend attaching fails */
 765                 if (!adap->fe[0])
 766                         break;
 767
 768                 /* disable DVB-C demod on IOD[5] */
 769                 ret = anysee_wr_reg_mask(d, REG_IOD, (0 << 5), 0x20);
 770                 if (ret)
 771                         goto error;
 772
 773                 /* enable DVB-T demod on IOD[0] */
 774                 ret = anysee_wr_reg_mask(d, REG_IOD, (1 << 0), 0x01);
 775                 if (ret)
 776                         goto error;
 777
 778                 /* attach demod */
 779                 if (tmp == 0xc7) {
 780                         /* TDA18212 config */
 781                         adap->fe[1] = dvb_attach(zl10353_attach,
 782                                         &anysee_zl10353_tda18212_config2,
 783                                         &d->i2c_adap);
 784
 785                         /* I2C gate for DNOD44CDH086A(TDA18212) tuner module */
 786                         if (adap->fe[1])
 787                                 adap->fe[1]->ops.i2c_gate_ctrl =
 788                                                 anysee_i2c_gate_ctrl;
 789                 } else {
 790                         /* PLL config */
 791                         adap->fe[1] = dvb_attach(zl10353_attach,
 792                                         &anysee_zl10353_config,
 793                                         &d->i2c_adap);
 794                 }
 795
 796                 break;
 797         case ANYSEE_HW_508TC: /* 18 */
 798         case ANYSEE_HW_508PTC: /* 21 */
 799                 /* E7 TC */
 800                 /* E7 PTC */
 801
 802                 /* disable DVB-T demod on IOD[6] */
 803                 ret = anysee_wr_reg_mask(d, REG_IOD, (0 << 6), 0x40);
 804                 if (ret)
 805                         goto error;
 806
 807                 /* enable DVB-C demod on IOD[5] */
 808                 ret = anysee_wr_reg_mask(d, REG_IOD, (1 << 5), 0x20);
 809                 if (ret)
 810                         goto error;
 811
 812                 /* attach demod */
 813                 adap->fe[0] = dvb_attach(tda10023_attach,
 814                                 &anysee_tda10023_tda18212_config,
 815                                 &d->i2c_adap, 0x48);
 816
 817                 /* I2C gate for DNOD44CDH086A(TDA18212) tuner module */
 818                 if (adap->fe[0])
 819                         adap->fe[0]->ops.i2c_gate_ctrl = anysee_i2c_gate_ctrl;
 820
 821                 /* break out if first frontend attaching fails */
 822                 if (!adap->fe[0])
 823                         break;
 824
 825                 /* disable DVB-C demod on IOD[5] */
 826                 ret = anysee_wr_reg_mask(d, REG_IOD, (0 << 5), 0x20);
 827                 if (ret)
 828                         goto error;
 829
 830                 /* enable DVB-T demod on IOD[6] */
 831                 ret = anysee_wr_reg_mask(d, REG_IOD, (1 << 6), 0x40);
 832                 if (ret)
 833                         goto error;
 834
 835                 /* attach demod */
 836                 adap->fe[1] = dvb_attach(zl10353_attach,
 837                                 &anysee_zl10353_tda18212_config,
 838                                 &d->i2c_adap);
 839
 840                 /* I2C gate for DNOD44CDH086A(TDA18212) tuner module */
 841                 if (adap->fe[1])
 842                         adap->fe[1]->ops.i2c_gate_ctrl = anysee_i2c_gate_ctrl;
 843
 844                 state->has_ci = true;
 845
 846                 break;
 847         case ANYSEE_HW_508S2: /* 19 */
 848         case ANYSEE_HW_508PS2: /* 22 */
 849                 /* E7 S2 */
 850                 /* E7 PS2 */
 851
 852                 /* enable DVB-S/S2 demod on IOE[5] */
 853                 ret = anysee_wr_reg_mask(d, REG_IOE, (1 << 5), 0x20);
 854                 if (ret)
 855                         goto error;
 856
 857                 /* attach demod */
 858                 adap->fe[0] = dvb_attach(stv0900_attach,
 859                                 &anysee_stv0900_config, &d->i2c_adap, 0);
 860
 861                 state->has_ci = true;
 862
 863                 break;
 864         case ANYSEE_HW_508T2C: /* 20 */
 865                 /* E7 T2C */
 866
 867                 /* enable DVB-T/T2/C demod on IOE[5] */
 868                 ret = anysee_wr_reg_mask(d, REG_IOE, (1 << 5), 0x20);
 869                 if (ret)
 870                         goto error;
 871
 872                 /* attach demod */
 873                 adap->fe[0] = dvb_attach(cxd2820r_attach,
 874                                 &anysee_cxd2820r_config, &d->i2c_adap, NULL);
 875
 876                 state->has_ci = true;
 877
 878                 break;
 879         }
 880
 881         if (!adap->fe[0]) {
 882                 /* we have no frontend :-( */
 883                 ret = -ENODEV;
 884                 dev_err(&d->udev->dev,
 885                                 "%s: Unsupported Anysee version. Please report to <linux-media@vger.kernel.org>.\n",
 886                                 KBUILD_MODNAME);
 887         }
 888 error:
 889         return ret;
 890 }
 891
 892 static int anysee_tuner_attach(struct dvb_usb_adapter *adap)
 893 {
 894         struct anysee_state *state = adap_to_priv(adap);
 895         struct dvb_usb_device *d = adap_to_d(adap);
 896         struct dvb_frontend *fe;
 897         int ret;
 898         dev_dbg(&d->udev->dev, "%s:\n", __func__);
 899
 900         switch (state->hw) {
 901         case ANYSEE_HW_507T: /* 2 */
 902                 /* E30 */
 903
 904                 /* attach tuner */
 905                 fe = dvb_attach(dvb_pll_attach, adap->fe[0], (0xc2 >> 1), NULL,
 906                                 DVB_PLL_THOMSON_DTT7579);
 907
 908                 break;
 909         case ANYSEE_HW_507CD: /* 6 */
 910                 /* E30 Plus */
 911
 912                 /* attach tuner */
 913                 fe = dvb_attach(dvb_pll_attach, adap->fe[0], (0xc2 >> 1),
 914                                 &d->i2c_adap, DVB_PLL_THOMSON_DTT7579);
 915
 916                 break;
 917         case ANYSEE_HW_507DC: /* 10 */
 918                 /* E30 C Plus */
 919
 920                 /* attach tuner */
 921                 fe = dvb_attach(dvb_pll_attach, adap->fe[0], (0xc0 >> 1),
 922                                 &d->i2c_adap, DVB_PLL_SAMSUNG_DTOS403IH102A);
 923
 924                 break;
 925         case ANYSEE_HW_507SI: /* 11 */
 926                 /* E30 S2 Plus */
 927
 928                 /* attach LNB controller */
 929                 fe = dvb_attach(isl6423_attach, adap->fe[0], &d->i2c_adap,
 930                                 &anysee_isl6423_config);
 931
 932                 break;
 933         case ANYSEE_HW_507FA: /* 15 */
 934                 /* E30 Combo Plus */
 935                 /* E30 C Plus */
 936
 937                 /* Try first attach TDA18212 silicon tuner on IOE[4], if that
 938                  * fails attach old simple PLL. */
 939
 940                 /* attach tuner */
 941                 fe = dvb_attach(tda18212_attach, adap->fe[0], &d->i2c_adap,
 942                                 &anysee_tda18212_config);
 943
 944                 if (fe && adap->fe[1]) {
 945                         /* attach tuner for 2nd FE */
 946                         fe = dvb_attach(tda18212_attach, adap->fe[1],
 947                                         &d->i2c_adap, &anysee_tda18212_config);
 948                         break;
 949                 } else if (fe) {
 950                         break;
 951                 }
 952
 953                 /* attach tuner */
 954                 fe = dvb_attach(dvb_pll_attach, adap->fe[0], (0xc0 >> 1),
 955                                 &d->i2c_adap, DVB_PLL_SAMSUNG_DTOS403IH102A);
 956
 957                 if (fe && adap->fe[1]) {
 958                         /* attach tuner for 2nd FE */
 959                         fe = dvb_attach(dvb_pll_attach, adap->fe[0],
 960                                         (0xc0 >> 1), &d->i2c_adap,
 961                                         DVB_PLL_SAMSUNG_DTOS403IH102A);
 962                 }
 963
 964                 break;
 965         case ANYSEE_HW_508TC: /* 18 */
 966         case ANYSEE_HW_508PTC: /* 21 */
 967                 /* E7 TC */
 968                 /* E7 PTC */
 969
 970                 /* attach tuner */
 971                 fe = dvb_attach(tda18212_attach, adap->fe[0], &d->i2c_adap,
 972                                 &anysee_tda18212_config);
 973
 974                 if (fe) {
 975                         /* attach tuner for 2nd FE */
 976                         fe = dvb_attach(tda18212_attach, adap->fe[1],
 977                                         &d->i2c_adap, &anysee_tda18212_config);
 978                 }
 979
 980                 break;
 981         case ANYSEE_HW_508S2: /* 19 */
 982         case ANYSEE_HW_508PS2: /* 22 */
 983                 /* E7 S2 */
 984                 /* E7 PS2 */
 985
 986                 /* attach tuner */
 987                 fe = dvb_attach(stv6110_attach, adap->fe[0],
 988                                 &anysee_stv6110_config, &d->i2c_adap);
 989
 990                 if (fe) {
 991                         /* attach LNB controller */
 992                         fe = dvb_attach(isl6423_attach, adap->fe[0],
 993                                         &d->i2c_adap, &anysee_isl6423_config);
 994                 }
 995
 996                 break;
 997
 998         case ANYSEE_HW_508T2C: /* 20 */
 999                 /* E7 T2C */
1000
1001                 /* attach tuner */
1002                 fe = dvb_attach(tda18212_attach, adap->fe[0], &d->i2c_adap,
1003                                 &anysee_tda18212_config2);
1004
1005                 break;
1006         default:
1007                 fe = NULL;
1008         }
1009
1010         if (fe)
1011                 ret = 0;
1012         else
1013                 ret = -ENODEV;
1014
1015         return ret;
1016 }
1017
1018 #if IS_ENABLED(CONFIG_RC_CORE)
1019 static int anysee_rc_query(struct dvb_usb_device *d)
1020 {
1021         u8 buf[] = {CMD_GET_IR_CODE};
1022         u8 ircode[2];
1023         int ret;
1024
1025         /* Remote controller is basic NEC using address byte 0x08.
1026            Anysee device RC query returns only two bytes, status and code,
1027            address byte is dropped. Also it does not return any value for
1028            NEC RCs having address byte other than 0x08. Due to that, we
1029            cannot use that device as standard NEC receiver.
1030            It could be possible make hack which reads whole code directly
1031            from device memory... */
1032
1033         ret = anysee_ctrl_msg(d, buf, sizeof(buf), ircode, sizeof(ircode));
1034         if (ret)
1035                 return ret;
1036
1037         if (ircode[0]) {
1038                 dev_dbg(&d->udev->dev, "%s: key pressed %02x\n", __func__,
1039                                 ircode[1]);
1040                 rc_keydown(d->rc_dev, 0x08 << 8 | ircode[1], 0);
1041         }
1042
1043         return 0;
1044 }
1045
1046 static int anysee_get_rc_config(struct dvb_usb_device *d, struct dvb_usb_rc *rc)
1047 {
1048         rc->allowed_protos = RC_BIT_NEC;
1049         rc->query          = anysee_rc_query;
1050         rc->interval       = 250;  /* windows driver uses 500ms */
1051
1052         return 0;
1053 }
1054 #else
1055         #define anysee_get_rc_config NULL
1056 #endif
1057
1058 static int anysee_ci_read_attribute_mem(struct dvb_ca_en50221 *ci, int slot,
1059         int addr)
1060 {
1061         struct dvb_usb_device *d = ci->data;
1062         int ret;
1063         u8 buf[] = {CMD_CI, 0x02, 0x40 | addr >> 8, addr & 0xff, 0x00, 1};
1064         u8 val;
1065
1066         ret = anysee_ctrl_msg(d, buf, sizeof(buf), &val, 1);
1067         if (ret)
1068                 return ret;
1069
1070         return val;
1071 }
1072
1073 static int anysee_ci_write_attribute_mem(struct dvb_ca_en50221 *ci, int slot,
1074         int addr, u8 val)
1075 {
1076         struct dvb_usb_device *d = ci->data;
1077         int ret;
1078         u8 buf[] = {CMD_CI, 0x03, 0x40 | addr >> 8, addr & 0xff, 0x00, 1, val};
1079
1080         ret = anysee_ctrl_msg(d, buf, sizeof(buf), NULL, 0);
1081         if (ret)
1082                 return ret;
1083
1084         return 0;
1085 }
1086
1087 static int anysee_ci_read_cam_control(struct dvb_ca_en50221 *ci, int slot,
1088         u8 addr)
1089 {
1090         struct dvb_usb_device *d = ci->data;
1091         int ret;
1092         u8 buf[] = {CMD_CI, 0x04, 0x40, addr, 0x00, 1};
1093         u8 val;
1094
1095         ret = anysee_ctrl_msg(d, buf, sizeof(buf), &val, 1);
1096         if (ret)
1097                 return ret;
1098
1099         return val;
1100 }
1101
1102 static int anysee_ci_write_cam_control(struct dvb_ca_en50221 *ci, int slot,
1103         u8 addr, u8 val)
1104 {
1105         struct dvb_usb_device *d = ci->data;
1106         int ret;
1107         u8 buf[] = {CMD_CI, 0x05, 0x40, addr, 0x00, 1, val};
1108
1109         ret = anysee_ctrl_msg(d, buf, sizeof(buf), NULL, 0);
1110         if (ret)
1111                 return ret;
1112
1113         return 0;
1114 }
1115
1116 static int anysee_ci_slot_reset(struct dvb_ca_en50221 *ci, int slot)
1117 {
1118         struct dvb_usb_device *d = ci->data;
1119         int ret;
1120         struct anysee_state *state = d_to_priv(d);
1121
1122         state->ci_cam_ready = jiffies + msecs_to_jiffies(1000);
1123
1124         ret = anysee_wr_reg_mask(d, REG_IOA, (0 << 7), 0x80);
1125         if (ret)
1126                 return ret;
1127
1128         msleep(300);
1129
1130         ret = anysee_wr_reg_mask(d, REG_IOA, (1 << 7), 0x80);
1131         if (ret)
1132                 return ret;
1133
1134         return 0;
1135 }
1136
1137 static int anysee_ci_slot_shutdown(struct dvb_ca_en50221 *ci, int slot)
1138 {
1139         struct dvb_usb_device *d = ci->data;
1140         int ret;
1141
1142         ret = anysee_wr_reg_mask(d, REG_IOA, (0 << 7), 0x80);
1143         if (ret)
1144                 return ret;
1145
1146         msleep(30);
1147
1148         ret = anysee_wr_reg_mask(d, REG_IOA, (1 << 7), 0x80);
1149         if (ret)
1150                 return ret;
1151
1152         return 0;
1153 }
1154
1155 static int anysee_ci_slot_ts_enable(struct dvb_ca_en50221 *ci, int slot)
1156 {
1157         struct dvb_usb_device *d = ci->data;
1158         int ret;
1159
1160         ret = anysee_wr_reg_mask(d, REG_IOD, (0 << 1), 0x02);
1161         if (ret)
1162                 return ret;
1163
1164         return 0;
1165 }
1166
1167 static int anysee_ci_poll_slot_status(struct dvb_ca_en50221 *ci, int slot,
1168         int open)
1169 {
1170         struct dvb_usb_device *d = ci->data;
1171         struct anysee_state *state = d_to_priv(d);
1172         int ret;
1173         u8 tmp = 0;
1174
1175         ret = anysee_rd_reg_mask(d, REG_IOC, &tmp, 0x40);
1176         if (ret)
1177                 return ret;
1178
1179         if (tmp == 0) {
1180                 ret = DVB_CA_EN50221_POLL_CAM_PRESENT;
1181                 if (time_after(jiffies, state->ci_cam_ready))
1182                         ret |= DVB_CA_EN50221_POLL_CAM_READY;
1183         }
1184
1185         return ret;
1186 }
1187
1188 static int anysee_ci_init(struct dvb_usb_device *d)
1189 {
1190         struct anysee_state *state = d_to_priv(d);
1191         int ret;
1192
1193         state->ci.owner               = THIS_MODULE;
1194         state->ci.read_attribute_mem  = anysee_ci_read_attribute_mem;
1195         state->ci.write_attribute_mem = anysee_ci_write_attribute_mem;
1196         state->ci.read_cam_control    = anysee_ci_read_cam_control;
1197         state->ci.write_cam_control   = anysee_ci_write_cam_control;
1198         state->ci.slot_reset          = anysee_ci_slot_reset;
1199         state->ci.slot_shutdown       = anysee_ci_slot_shutdown;
1200         state->ci.slot_ts_enable      = anysee_ci_slot_ts_enable;
1201         state->ci.poll_slot_status    = anysee_ci_poll_slot_status;
1202         state->ci.data                = d;
1203
1204         ret = anysee_wr_reg_mask(d, REG_IOA, (1 << 7), 0x80);
1205         if (ret)
1206                 return ret;
1207
1208         ret = anysee_wr_reg_mask(d, REG_IOD, (0 << 2)|(0 << 1)|(0 << 0), 0x07);
1209         if (ret)
1210                 return ret;
1211
1212         ret = anysee_wr_reg_mask(d, REG_IOD, (1 << 2)|(1 << 1)|(1 << 0), 0x07);
1213         if (ret)
1214                 return ret;
1215
1216         ret = dvb_ca_en50221_init(&d->adapter[0].dvb_adap, &state->ci, 0, 1);
1217         if (ret)
1218                 return ret;
1219
1220         state->ci_attached = true;
1221
1222         return 0;
1223 }
1224
1225 static void anysee_ci_release(struct dvb_usb_device *d)
1226 {
1227         struct anysee_state *state = d_to_priv(d);
1228
1229         /* detach CI */
1230         if (state->ci_attached)
1231                 dvb_ca_en50221_release(&state->ci);
1232
1233         return;
1234 }
1235
1236 static int anysee_init(struct dvb_usb_device *d)
1237 {
1238         struct anysee_state *state = d_to_priv(d);
1239         int ret;
1240
1241         /* There is one interface with two alternate settings.
1242            Alternate setting 0 is for bulk transfer.
1243            Alternate setting 1 is for isochronous transfer.
1244            We use bulk transfer (alternate setting 0). */
1245         ret = usb_set_interface(d->udev, 0, 0);
1246         if (ret)
1247                 return ret;
1248
1249         /* LED light */
1250         ret = anysee_led_ctrl(d, 0x01, 0x03);
1251         if (ret)
1252                 return ret;
1253
1254         /* enable IR */
1255         ret = anysee_ir_ctrl(d, 1);
1256         if (ret)
1257                 return ret;
1258
1259         /* attach CI */
1260         if (state->has_ci) {
1261                 ret = anysee_ci_init(d);
1262                 if (ret)
1263                         return ret;
1264         }
1265
1266         return 0;
1267 }
1268
1269 static void anysee_exit(struct dvb_usb_device *d)
1270 {
1271         return anysee_ci_release(d);
1272 }
1273
1274 /* DVB USB Driver stuff */
1275 static struct dvb_usb_device_properties anysee_props = {
1276         .driver_name = KBUILD_MODNAME,
1277         .owner = THIS_MODULE,
1278         .adapter_nr = adapter_nr,
1279         .size_of_priv = sizeof(struct anysee_state),
1280
1281         .generic_bulk_ctrl_endpoint = 0x01,
1282         .generic_bulk_ctrl_endpoint_response = 0x81,
1283
1284         .i2c_algo         = &anysee_i2c_algo,
1285         .read_config      = anysee_read_config,
1286         .frontend_attach  = anysee_frontend_attach,
1287         .tuner_attach     = anysee_tuner_attach,
1288         .init             = anysee_init,
1289         .get_rc_config    = anysee_get_rc_config,
1290         .frontend_ctrl    = anysee_frontend_ctrl,
1291         .streaming_ctrl   = anysee_streaming_ctrl,
1292         .exit             = anysee_exit,
1293
1294         .num_adapters = 1,
1295         .adapter = {
1296                 {
1297                         .stream = DVB_USB_STREAM_BULK(0x82, 8, 16 * 512),
1298                 }
1299         }
1300 };
1301
1302 static const struct usb_device_id anysee_id_table[] = {
1303         { DVB_USB_DEVICE(USB_VID_CYPRESS, USB_PID_ANYSEE,
1304                 &anysee_props, "Anysee", RC_MAP_ANYSEE) },
1305         { DVB_USB_DEVICE(USB_VID_AMT, USB_PID_ANYSEE,
1306                 &anysee_props, "Anysee", RC_MAP_ANYSEE) },
1307         { }
1308 };
1309 MODULE_DEVICE_TABLE(usb, anysee_id_table);
1310
1311 static struct usb_driver anysee_usb_driver = {
1312         .name = KBUILD_MODNAME,
1313         .id_table = anysee_id_table,
1314         .probe = dvb_usbv2_probe,
1315         .disconnect = dvb_usbv2_disconnect,
1316         .suspend = dvb_usbv2_suspend,
1317         .resume = dvb_usbv2_resume,
1318         .reset_resume = dvb_usbv2_reset_resume,
1319         .no_dynamic_id = 1,
1320         .soft_unbind = 1,
1321 };
1322
1323 module_usb_driver(anysee_usb_driver);
1324
1325 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1326 MODULE_DESCRIPTION("Driver Anysee E30 DVB-C & DVB-T USB2.0");
1327 MODULE_LICENSE("GPL");