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

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