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

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

DEFINITIONS
