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