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

   1 /*
   2  * Driver for DVBSky USB2.0 receiver
   3  *
   4  * Copyright (C) 2013 Max nibble <nibble.max@gmail.com>
   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
  21 #include "dvb_usb.h"
  22 #include "m88ds3103.h"
  23 #include "m88ts2022.h"
  24
  25 #define DVBSKY_MSG_DELAY        0/*2000*/
  26 #define DVBSKY_BUF_LEN  64
  27
  28 static int dvb_usb_dvbsky_disable_rc;
  29 module_param_named(disable_rc, dvb_usb_dvbsky_disable_rc, int, 0644);
  30 MODULE_PARM_DESC(disable_rc, "Disable inbuilt IR receiver.");
  31
  32 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
  33
  34 struct dvbsky_state {
  35         struct mutex stream_mutex;
  36         u8 ibuf[DVBSKY_BUF_LEN];
  37         u8 obuf[DVBSKY_BUF_LEN];
  38         u8 last_lock;
  39         struct i2c_client *i2c_client_tuner;
  40
  41         /* fe hook functions*/
  42         int (*fe_set_voltage)(struct dvb_frontend *fe,
  43                 fe_sec_voltage_t voltage);
  44         int (*fe_read_status)(struct dvb_frontend *fe,
  45                 fe_status_t *status);
  46 };
  47
  48 static int dvbsky_usb_generic_rw(struct dvb_usb_device *d,
  49                 u8 *wbuf, u16 wlen, u8 *rbuf, u16 rlen)
  50 {
  51         int ret;
  52         struct dvbsky_state *state = d_to_priv(d);
  53
  54         mutex_lock(&d->usb_mutex);
  55         if (wlen != 0)
  56                 memcpy(state->obuf, wbuf, wlen);
  57
  58         ret = dvb_usbv2_generic_rw_locked(d, state->obuf, wlen,
  59                         state->ibuf, rlen);
  60
  61         if (!ret && (rlen != 0))
  62                 memcpy(rbuf, state->ibuf, rlen);
  63
  64         mutex_unlock(&d->usb_mutex);
  65         return ret;
  66 }
  67
  68 static int dvbsky_stream_ctrl(struct dvb_usb_device *d, u8 onoff)
  69 {
  70         struct dvbsky_state *state = d_to_priv(d);
  71         int ret;
  72         u8 obuf_pre[3] = { 0x37, 0, 0 };
  73         u8 obuf_post[3] = { 0x36, 3, 0 };
  74
  75         mutex_lock(&state->stream_mutex);
  76         ret = dvbsky_usb_generic_rw(d, obuf_pre, 3, NULL, 0);
  77         if (!ret && onoff) {
  78                 msleep(20);
  79                 ret = dvbsky_usb_generic_rw(d, obuf_post, 3, NULL, 0);
  80         }
  81         mutex_unlock(&state->stream_mutex);
  82         return ret;
  83 }
  84
  85 static int dvbsky_streaming_ctrl(struct dvb_frontend *fe, int onoff)
  86 {
  87         struct dvb_usb_device *d = fe_to_d(fe);
  88
  89         return dvbsky_stream_ctrl(d, (onoff == 0) ? 0 : 1);
  90 }
  91
  92 /* GPIO */
  93 static int dvbsky_gpio_ctrl(struct dvb_usb_device *d, u8 gport, u8 value)
  94 {
  95         int ret;
  96         u8 obuf[3], ibuf[2];
  97
  98         obuf[0] = 0x0e;
  99         obuf[1] = gport;
 100         obuf[2] = value;
 101         ret = dvbsky_usb_generic_rw(d, obuf, 3, ibuf, 1);
 102         if (ret)
 103                 dev_err(&d->udev->dev, "failed=%d\n", ret);
 104         return ret;
 105 }
 106
 107 /* I2C */
 108 static int dvbsky_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
 109         int num)
 110 {
 111         struct dvb_usb_device *d = i2c_get_adapdata(adap);
 112         int ret = 0;
 113         u8 ibuf[64], obuf[64];
 114
 115         if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
 116                 return -EAGAIN;
 117
 118         if (num > 2) {
 119                 dev_err(&d->udev->dev,
 120                 "too many i2c messages[%d], max 2.", num);
 121                 ret = -EOPNOTSUPP;
 122                 goto i2c_error;
 123         }
 124
 125         if (num == 1) {
 126                 if (msg[0].len > 60) {
 127                         dev_err(&d->udev->dev,
 128                         "too many i2c bytes[%d], max 60.",
 129                         msg[0].len);
 130                         ret = -EOPNOTSUPP;
 131                         goto i2c_error;
 132                 }
 133                 if (msg[0].flags & I2C_M_RD) {
 134                         /* single read */
 135                         obuf[0] = 0x09;
 136                         obuf[1] = 0;
 137                         obuf[2] = msg[0].len;
 138                         obuf[3] = msg[0].addr;
 139                         ret = dvbsky_usb_generic_rw(d, obuf, 4,
 140                                         ibuf, msg[0].len + 1);
 141                         if (ret)
 142                                 dev_err(&d->udev->dev, "failed=%d\n", ret);
 143                         if (!ret)
 144                                 memcpy(msg[0].buf, &ibuf[1], msg[0].len);
 145                 } else {
 146                         /* write */
 147                         obuf[0] = 0x08;
 148                         obuf[1] = msg[0].addr;
 149                         obuf[2] = msg[0].len;
 150                         memcpy(&obuf[3], msg[0].buf, msg[0].len);
 151                         ret = dvbsky_usb_generic_rw(d, obuf,
 152                                         msg[0].len + 3, ibuf, 1);
 153                         if (ret)
 154                                 dev_err(&d->udev->dev, "failed=%d\n", ret);
 155                 }
 156         } else {
 157                 if ((msg[0].len > 60) || (msg[1].len > 60)) {
 158                         dev_err(&d->udev->dev,
 159                         "too many i2c bytes[w-%d][r-%d], max 60.",
 160                         msg[0].len, msg[1].len);
 161                         ret = -EOPNOTSUPP;
 162                         goto i2c_error;
 163                 }
 164                 /* write then read */
 165                 obuf[0] = 0x09;
 166                 obuf[1] = msg[0].len;
 167                 obuf[2] = msg[1].len;
 168                 obuf[3] = msg[0].addr;
 169                 memcpy(&obuf[4], msg[0].buf, msg[0].len);
 170                 ret = dvbsky_usb_generic_rw(d, obuf,
 171                         msg[0].len + 4, ibuf, msg[1].len + 1);
 172                 if (ret)
 173                         dev_err(&d->udev->dev, "failed=%d\n", ret);
 174
 175                 if (!ret)
 176                         memcpy(msg[1].buf, &ibuf[1], msg[1].len);
 177         }
 178 i2c_error:
 179         mutex_unlock(&d->i2c_mutex);
 180         return (ret) ? ret : num;
 181 }
 182
 183 static u32 dvbsky_i2c_func(struct i2c_adapter *adapter)
 184 {
 185         return I2C_FUNC_I2C;
 186 }
 187
 188 static struct i2c_algorithm dvbsky_i2c_algo = {
 189         .master_xfer   = dvbsky_i2c_xfer,
 190         .functionality = dvbsky_i2c_func,
 191 };
 192
 193 #if IS_ENABLED(CONFIG_RC_CORE)
 194 static int dvbsky_rc_query(struct dvb_usb_device *d)
 195 {
 196         u32 code = 0xffff, scancode;
 197         u8 rc5_command, rc5_system;
 198         u8 obuf[2], ibuf[2], toggle;
 199         int ret;
 200
 201         obuf[0] = 0x10;
 202         ret = dvbsky_usb_generic_rw(d, obuf, 1, ibuf, 2);
 203         if (ret)
 204                 dev_err(&d->udev->dev, "failed=%d\n", ret);
 205         if (ret == 0)
 206                 code = (ibuf[0] << 8) | ibuf[1];
 207         if (code != 0xffff) {
 208                 dev_dbg(&d->udev->dev, "rc code: %x\n", code);
 209                 rc5_command = code & 0x3F;
 210                 rc5_system = (code & 0x7C0) >> 6;
 211                 toggle = (code & 0x800) ? 1 : 0;
 212                 scancode = rc5_system << 8 | rc5_command;
 213                 rc_keydown(d->rc_dev, RC_TYPE_RC5, scancode, toggle);
 214         }
 215         return 0;
 216 }
 217
 218 static int dvbsky_get_rc_config(struct dvb_usb_device *d, struct dvb_usb_rc *rc)
 219 {
 220         if (dvb_usb_dvbsky_disable_rc) {
 221                 rc->map_name = NULL;
 222                 return 0;
 223         }
 224
 225         rc->allowed_protos = RC_BIT_RC5;
 226         rc->query          = dvbsky_rc_query;
 227         rc->interval       = 300;
 228         return 0;
 229 }
 230 #else
 231         #define dvbsky_get_rc_config NULL
 232 #endif
 233
 234 static int dvbsky_usb_set_voltage(struct dvb_frontend *fe,
 235         fe_sec_voltage_t voltage)
 236 {
 237         struct dvb_usb_device *d = fe_to_d(fe);
 238         struct dvbsky_state *state = d_to_priv(d);
 239         u8 value;
 240
 241         if (voltage == SEC_VOLTAGE_OFF)
 242                 value = 0;
 243         else
 244                 value = 1;
 245         dvbsky_gpio_ctrl(d, 0x80, value);
 246
 247         return state->fe_set_voltage(fe, voltage);
 248 }
 249
 250 static int dvbsky_read_mac_addr(struct dvb_usb_adapter *adap, u8 mac[6])
 251 {
 252         struct dvb_usb_device *d = adap_to_d(adap);
 253         u8 obuf[] = { 0x1e, 0x00 };
 254         u8 ibuf[6] = { 0 };
 255         struct i2c_msg msg[] = {
 256                 {
 257                         .addr = 0x51,
 258                         .flags = 0,
 259                         .buf = obuf,
 260                         .len = 2,
 261                 }, {
 262                         .addr = 0x51,
 263                         .flags = I2C_M_RD,
 264                         .buf = ibuf,
 265                         .len = 6,
 266                 }
 267         };
 268
 269         if (i2c_transfer(&d->i2c_adap, msg, 2) == 2)
 270                 memcpy(mac, ibuf, 6);
 271
 272         return 0;
 273 }
 274
 275 static int dvbsky_usb_read_status(struct dvb_frontend *fe, fe_status_t *status)
 276 {
 277         struct dvb_usb_device *d = fe_to_d(fe);
 278         struct dvbsky_state *state = d_to_priv(d);
 279         int ret;
 280
 281         ret = state->fe_read_status(fe, status);
 282
 283         /* it need resync slave fifo when signal change from unlock to lock.*/
 284         if ((*status & FE_HAS_LOCK) && (!state->last_lock))
 285                 dvbsky_stream_ctrl(d, 1);
 286
 287         state->last_lock = (*status & FE_HAS_LOCK) ? 1 : 0;
 288         return ret;
 289 }
 290
 291 static const struct m88ds3103_config dvbsky_s960_m88ds3103_config = {
 292         .i2c_addr = 0x68,
 293         .clock = 27000000,
 294         .i2c_wr_max = 33,
 295         .clock_out = 0,
 296         .ts_mode = M88DS3103_TS_CI,
 297         .ts_clk = 16000,
 298         .ts_clk_pol = 0,
 299         .agc = 0x99,
 300         .lnb_hv_pol = 1,
 301         .lnb_en_pol = 1,
 302 };
 303
 304 static int dvbsky_s960_attach(struct dvb_usb_adapter *adap)
 305 {
 306         struct dvbsky_state *state = adap_to_priv(adap);
 307         struct dvb_usb_device *d = adap_to_d(adap);
 308         int ret = 0;
 309         /* demod I2C adapter */
 310         struct i2c_adapter *i2c_adapter;
 311         struct i2c_client *client;
 312         struct i2c_board_info info;
 313         struct m88ts2022_config m88ts2022_config = {
 314                         .clock = 27000000,
 315                 };
 316         memset(&info, 0, sizeof(struct i2c_board_info));
 317
 318         /* attach demod */
 319         adap->fe[0] = dvb_attach(m88ds3103_attach,
 320                         &dvbsky_s960_m88ds3103_config,
 321                         &d->i2c_adap,
 322                         &i2c_adapter);
 323         if (!adap->fe[0]) {
 324                 dev_err(&d->udev->dev, "dvbsky_s960_attach fail.\n");
 325                 ret = -ENODEV;
 326                 goto fail_attach;
 327         }
 328
 329         /* attach tuner */
 330         m88ts2022_config.fe = adap->fe[0];
 331         strlcpy(info.type, "m88ts2022", I2C_NAME_SIZE);
 332         info.addr = 0x60;
 333         info.platform_data = &m88ts2022_config;
 334         request_module("m88ts2022");
 335         client = i2c_new_device(i2c_adapter, &info);
 336         if (client == NULL || client->dev.driver == NULL) {
 337                 dvb_frontend_detach(adap->fe[0]);
 338                 ret = -ENODEV;
 339                 goto fail_attach;
 340         }
 341
 342         if (!try_module_get(client->dev.driver->owner)) {
 343                 i2c_unregister_device(client);
 344                 dvb_frontend_detach(adap->fe[0]);
 345                 ret = -ENODEV;
 346                 goto fail_attach;
 347         }
 348
 349         /* delegate signal strength measurement to tuner */
 350         adap->fe[0]->ops.read_signal_strength =
 351                         adap->fe[0]->ops.tuner_ops.get_rf_strength;
 352
 353         /* hook fe: need to resync the slave fifo when signal locks. */
 354         state->fe_read_status = adap->fe[0]->ops.read_status;
 355         adap->fe[0]->ops.read_status = dvbsky_usb_read_status;
 356
 357         /* hook fe: LNB off/on is control by Cypress usb chip. */
 358         state->fe_set_voltage = adap->fe[0]->ops.set_voltage;
 359         adap->fe[0]->ops.set_voltage = dvbsky_usb_set_voltage;
 360
 361         state->i2c_client_tuner = client;
 362
 363 fail_attach:
 364         return ret;
 365 }
 366
 367 static int dvbsky_identify_state(struct dvb_usb_device *d, const char **name)
 368 {
 369         dvbsky_gpio_ctrl(d, 0x04, 1);
 370         msleep(20);
 371         dvbsky_gpio_ctrl(d, 0x83, 0);
 372         dvbsky_gpio_ctrl(d, 0xc0, 1);
 373         msleep(100);
 374         dvbsky_gpio_ctrl(d, 0x83, 1);
 375         dvbsky_gpio_ctrl(d, 0xc0, 0);
 376         msleep(50);
 377
 378         return WARM;
 379 }
 380
 381 static int dvbsky_init(struct dvb_usb_device *d)
 382 {
 383         struct dvbsky_state *state = d_to_priv(d);
 384
 385         /* use default interface */
 386         /*
 387         ret = usb_set_interface(d->udev, 0, 0);
 388         if (ret)
 389                 return ret;
 390         */
 391         mutex_init(&state->stream_mutex);
 392
 393         state->last_lock = 0;
 394
 395         return 0;
 396 }
 397
 398 static void dvbsky_exit(struct dvb_usb_device *d)
 399 {
 400         struct dvbsky_state *state = d_to_priv(d);
 401         struct i2c_client *client;
 402
 403         client = state->i2c_client_tuner;
 404         /* remove I2C tuner */
 405         if (client) {
 406                 module_put(client->dev.driver->owner);
 407                 i2c_unregister_device(client);
 408         }
 409 }
 410
 411 /* DVB USB Driver stuff */
 412 static struct dvb_usb_device_properties dvbsky_s960_props = {
 413         .driver_name = KBUILD_MODNAME,
 414         .owner = THIS_MODULE,
 415         .adapter_nr = adapter_nr,
 416         .size_of_priv = sizeof(struct dvbsky_state),
 417
 418         .generic_bulk_ctrl_endpoint = 0x01,
 419         .generic_bulk_ctrl_endpoint_response = 0x81,
 420         .generic_bulk_ctrl_delay = DVBSKY_MSG_DELAY,
 421
 422         .i2c_algo         = &dvbsky_i2c_algo,
 423         .frontend_attach  = dvbsky_s960_attach,
 424         .init             = dvbsky_init,
 425         .get_rc_config    = dvbsky_get_rc_config,
 426         .streaming_ctrl   = dvbsky_streaming_ctrl,
 427         .identify_state   = dvbsky_identify_state,
 428         .exit             = dvbsky_exit,
 429         .read_mac_address = dvbsky_read_mac_addr,
 430
 431         .num_adapters = 1,
 432         .adapter = {
 433                 {
 434                         .stream = DVB_USB_STREAM_BULK(0x82, 8, 4096),
 435                 }
 436         }
 437 };
 438
 439 static const struct usb_device_id dvbsky_id_table[] = {
 440         { DVB_USB_DEVICE(0x0572, 0x6831,
 441                 &dvbsky_s960_props, "DVBSky S960/S860", RC_MAP_DVBSKY) },
 442         { }
 443 };
 444 MODULE_DEVICE_TABLE(usb, dvbsky_id_table);
 445
 446 static struct usb_driver dvbsky_usb_driver = {
 447         .name = KBUILD_MODNAME,
 448         .id_table = dvbsky_id_table,
 449         .probe = dvb_usbv2_probe,
 450         .disconnect = dvb_usbv2_disconnect,
 451         .suspend = dvb_usbv2_suspend,
 452         .resume = dvb_usbv2_resume,
 453         .reset_resume = dvb_usbv2_reset_resume,
 454         .no_dynamic_id = 1,
 455         .soft_unbind = 1,
 456 };
 457
 458 module_usb_driver(dvbsky_usb_driver);
 459
 460 MODULE_AUTHOR("Max nibble <nibble.max@gmail.com>");
 461 MODULE_DESCRIPTION("Driver for DVBSky USB");
 462 MODULE_LICENSE("GPL");