SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/media/dvb/dvb-usb/m920x.c

   1 /* DVB USB compliant linux driver for MSI Mega Sky 580 DVB-T USB2.0 receiver
   2  *
   3  * Copyright (C) 2006 Aapo Tahkola (aet@rasterburn.org)
   4  *
   5  *      This program is free software; you can redistribute it and/or modify it
   6  *      under the terms of the GNU General Public License as published by the Free
   7  *      Software Foundation, version 2.
   8  *
   9  * see Documentation/dvb/README.dvb-usb for more information
  10  */
  11
  12 #include "m920x.h"
  13
  14 #include "mt352.h"
  15 #include "mt352_priv.h"
  16 #include "qt1010.h"
  17 #include "tda1004x.h"
  18 #include "tda827x.h"
  19
  20 /* debug */
  21 static int dvb_usb_m920x_debug;
  22 module_param_named(debug,dvb_usb_m920x_debug, int, 0644);
  23 MODULE_PARM_DESC(debug, "set debugging level (1=rc (or-able))." DVB_USB_DEBUG_STATUS);
  24
  25 static struct dvb_usb_rc_key megasky_rc_keys [] = {
  26         { 0x0, 0x12, KEY_POWER },
  27         { 0x0, 0x1e, KEY_CYCLEWINDOWS }, /* min/max */
  28         { 0x0, 0x02, KEY_CHANNELUP },
  29         { 0x0, 0x05, KEY_CHANNELDOWN },
  30         { 0x0, 0x03, KEY_VOLUMEUP },
  31         { 0x0, 0x06, KEY_VOLUMEDOWN },
  32         { 0x0, 0x04, KEY_MUTE },
  33         { 0x0, 0x07, KEY_OK }, /* TS */
  34         { 0x0, 0x08, KEY_STOP },
  35         { 0x0, 0x09, KEY_MENU }, /* swap */
  36         { 0x0, 0x0a, KEY_REWIND },
  37         { 0x0, 0x1b, KEY_PAUSE },
  38         { 0x0, 0x1f, KEY_FASTFORWARD },
  39         { 0x0, 0x0c, KEY_RECORD },
  40         { 0x0, 0x0d, KEY_CAMERA }, /* screenshot */
  41         { 0x0, 0x0e, KEY_COFFEE }, /* "MTS" */
  42 };
  43
  44 static inline int m9206_read(struct usb_device *udev, u8 request, u16 value,\
  45                              u16 index, void *data, int size)
  46 {
  47         int ret;
  48
  49         ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
  50                               request, USB_TYPE_VENDOR | USB_DIR_IN,
  51                               value, index, data, size, 2000);
  52         if (ret < 0) {
  53                 printk(KERN_INFO "m920x_read = error: %d\n", ret);
  54                 return ret;
  55         }
  56
  57         if (ret != size) {
  58                 deb_rc("m920x_read = no data\n");
  59                 return -EIO;
  60         }
  61
  62         return 0;
  63 }
  64
  65 static inline int m9206_write(struct usb_device *udev, u8 request,
  66                               u16 value, u16 index)
  67 {
  68         int ret;
  69
  70         ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
  71                               request, USB_TYPE_VENDOR | USB_DIR_OUT,
  72                               value, index, NULL, 0, 2000);
  73
  74         return ret;
  75 }
  76
  77 static int m9206_init(struct dvb_usb_device *d)
  78 {
  79         int ret = 0;
  80
  81         /* Remote controller init. */
  82         if (d->props.rc_query) {
  83                 if ((ret = m9206_write(d->udev, M9206_CORE, 0xa8, M9206_RC_INIT2)) != 0)
  84                         return ret;
  85
  86                 if ((ret = m9206_write(d->udev, M9206_CORE, 0x51, M9206_RC_INIT1)) != 0)
  87                         return ret;
  88         }
  89
  90         return ret;
  91 }
  92
  93 static int m9206_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
  94 {
  95         struct m9206_state *m = d->priv;
  96         int i, ret = 0;
  97         u8 rc_state[2];
  98
  99         if ((ret = m9206_read(d->udev, M9206_CORE, 0x0, M9206_RC_STATE, rc_state, 1)) != 0)
 100                 goto unlock;
 101
 102         if ((ret = m9206_read(d->udev, M9206_CORE, 0x0, M9206_RC_KEY, rc_state + 1, 1)) != 0)
 103                 goto unlock;
 104
 105         for (i = 0; i < d->props.rc_key_map_size; i++)
 106                 if (d->props.rc_key_map[i].data == rc_state[1]) {
 107                         *event = d->props.rc_key_map[i].event;
 108
 109                         switch(rc_state[0]) {
 110                         case 0x80:
 111                                 *state = REMOTE_NO_KEY_PRESSED;
 112                                 goto unlock;
 113
 114                         case 0x93:
 115                         case 0x92:
 116                                 m->rep_count = 0;
 117                                 *state = REMOTE_KEY_PRESSED;
 118                                 goto unlock;
 119
 120                         case 0x91:
 121                                 /* For comfort. */
 122                                 if (++m->rep_count > 2)
 123                                         *state = REMOTE_KEY_REPEAT;
 124                                 goto unlock;
 125
 126                         default:
 127                                 deb_rc("Unexpected rc response %x\n", rc_state[0]);
 128                                 *state = REMOTE_NO_KEY_PRESSED;
 129                                 goto unlock;
 130                         }
 131                 }
 132
 133         if (rc_state[1] != 0)
 134                 deb_rc("Unknown rc key %x\n", rc_state[1]);
 135
 136         *state = REMOTE_NO_KEY_PRESSED;
 137
 138         unlock:
 139
 140         return ret;
 141 }
 142
 143 /* I2C */
 144 static int m9206_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
 145                           int num)
 146 {
 147         struct dvb_usb_device *d = i2c_get_adapdata(adap);
 148         int i, j;
 149         int ret = 0;
 150
 151         if (!num)
 152                 return -EINVAL;
 153
 154         if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
 155                 return -EAGAIN;
 156
 157         for (i = 0; i < num; i++) {
 158                 if (msg[i].flags & (I2C_M_NO_RD_ACK|I2C_M_IGNORE_NAK|I2C_M_TEN) ||
 159                     msg[i].len == 0) {
 160                         /* For a 0 byte message, I think sending the address to index 0x80|0x40
 161                          * would be the correct thing to do.  However, zero byte messages are
 162                          * only used for probing, and since we don't know how to get the slave's
 163                          * ack, we can't probe. */
 164                         ret = -ENOTSUPP;
 165                         goto unlock;
 166                 }
 167                 /* Send START & address/RW bit */
 168                 if (!(msg[i].flags & I2C_M_NOSTART)) {
 169                         if ((ret = m9206_write(d->udev, M9206_I2C, (msg[i].addr<<1)|(msg[i].flags&I2C_M_RD?0x01:0), 0x80)) != 0)
 170                                 goto unlock;
 171                         /* Should check for ack here, if we knew how. */
 172                 }
 173                 if (msg[i].flags & I2C_M_RD) {
 174                         for (j = 0; j < msg[i].len; j++) {
 175                                 /* Last byte of transaction? Send STOP, otherwise send ACK. */
 176                                 int stop = (i+1 == num && j+1 == msg[i].len)?0x40:0x01;
 177                                 if ((ret = m9206_read(d->udev, M9206_I2C, 0x0, 0x20|stop, &msg[i].buf[j], 1)) != 0)
 178                                         goto unlock;
 179                         }
 180                 } else {
 181                         for (j = 0; j < msg[i].len; j++) {
 182                                 /* Last byte of transaction? Then send STOP. */
 183                                 int stop = (i+1 == num && j+1 == msg[i].len)?0x40:0x00;
 184                                 if ((ret = m9206_write(d->udev, M9206_I2C, msg[i].buf[j], stop)) != 0)
 185                                         goto unlock;
 186                                 /* Should check for ack here too. */
 187                         }
 188                 }
 189         }
 190         ret = num;
 191
 192 unlock:
 193         mutex_unlock(&d->i2c_mutex);
 194
 195         return ret;
 196 }
 197
 198 static u32 m9206_i2c_func(struct i2c_adapter *adapter)
 199 {
 200         return I2C_FUNC_I2C;
 201 }
 202
 203 static struct i2c_algorithm m9206_i2c_algo = {
 204         .master_xfer   = m9206_i2c_xfer,
 205         .functionality = m9206_i2c_func,
 206 };
 207
 208
 209 static int m9206_set_filter(struct dvb_usb_adapter *adap, int type, int idx,
 210                             int pid)
 211 {
 212         int ret = 0;
 213
 214         if (pid >= 0x8000)
 215                 return -EINVAL;
 216
 217         pid |= 0x8000;
 218
 219         if ((ret = m9206_write(adap->dev->udev, M9206_FILTER, pid, (type << 8) | (idx * 4) )) != 0)
 220                 return ret;
 221
 222         if ((ret = m9206_write(adap->dev->udev, M9206_FILTER, 0, (type << 8) | (idx * 4) )) != 0)
 223                 return ret;
 224
 225         return ret;
 226 }
 227
 228 static int m9206_update_filters(struct dvb_usb_adapter *adap)
 229 {
 230         struct m9206_state *m = adap->dev->priv;
 231         int enabled = m->filtering_enabled;
 232         int i, ret = 0, filter = 0;
 233
 234         for (i = 0; i < M9206_MAX_FILTERS; i++)
 235                 if (m->filters[i] == 8192)
 236                         enabled = 0;
 237
 238         /* Disable all filters */
 239         if ((ret = m9206_set_filter(adap, 0x81, 1, enabled)) != 0)
 240                 return ret;
 241
 242         for (i = 0; i < M9206_MAX_FILTERS; i++)
 243                 if ((ret = m9206_set_filter(adap, 0x81, i + 2, 0)) != 0)
 244                         return ret;
 245
 246         if ((ret = m9206_set_filter(adap, 0x82, 0, 0x0)) != 0)
 247                 return ret;
 248
 249         /* Set */
 250         if (enabled) {
 251                 for (i = 0; i < M9206_MAX_FILTERS; i++) {
 252                         if (m->filters[i] == 0)
 253                                 continue;
 254
 255                         if ((ret = m9206_set_filter(adap, 0x81, filter + 2, m->filters[i])) != 0)
 256                                 return ret;
 257
 258                         filter++;
 259                 }
 260         }
 261
 262         if ((ret = m9206_set_filter(adap, 0x82, 0, 0x02f5)) != 0)
 263                 return ret;
 264
 265         return ret;
 266 }
 267
 268 static int m9206_pid_filter_ctrl(struct dvb_usb_adapter *adap, int onoff)
 269 {
 270         struct m9206_state *m = adap->dev->priv;
 271
 272         m->filtering_enabled = onoff ? 1 : 0;
 273
 274         return m9206_update_filters(adap);
 275 }
 276
 277 static int m9206_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid,
 278                             int onoff)
 279 {
 280         struct m9206_state *m = adap->dev->priv;
 281
 282         m->filters[index] = onoff ? pid : 0;
 283
 284         return m9206_update_filters(adap);
 285 }
 286
 287 static int m9206_firmware_download(struct usb_device *udev,
 288                                    const struct firmware *fw)
 289 {
 290         u16 value, index, size;
 291         u8 read[4], *buff;
 292         int i, pass, ret = 0;
 293
 294         buff = kmalloc(65536, GFP_KERNEL);
 295
 296         if ((ret = m9206_read(udev, M9206_FILTER, 0x0, 0x8000, read, 4)) != 0)
 297                 goto done;
 298         deb_rc("%x %x %x %x\n", read[0], read[1], read[2], read[3]);
 299
 300         if ((ret = m9206_read(udev, M9206_FW, 0x0, 0x0, read, 1)) != 0)
 301                 goto done;
 302         deb_rc("%x\n", read[0]);
 303
 304         for (pass = 0; pass < 2; pass++) {
 305                 for (i = 0; i + (sizeof(u16) * 3) < fw->size;) {
 306                         value = le16_to_cpu(*(u16 *)(fw->data + i));
 307                         i += sizeof(u16);
 308
 309                         index = le16_to_cpu(*(u16 *)(fw->data + i));
 310                         i += sizeof(u16);
 311
 312                         size = le16_to_cpu(*(u16 *)(fw->data + i));
 313                         i += sizeof(u16);
 314
 315                         if (pass == 1) {
 316                                 /* Will stall if using fw->data ... */
 317                                 memcpy(buff, fw->data + i, size);
 318
 319                                 ret = usb_control_msg(udev, usb_sndctrlpipe(udev,0),
 320                                             M9206_FW,
 321                                             USB_TYPE_VENDOR | USB_DIR_OUT,
 322                                             value, index, buff, size, 20);
 323                                 if (ret != size) {
 324                                         deb_rc("error while uploading fw!\n");
 325                                         ret = -EIO;
 326                                         goto done;
 327                                 }
 328                                 msleep(3);
 329                         }
 330                         i += size;
 331                 }
 332                 if (i != fw->size) {
 333                         deb_rc("bad firmware file!\n");
 334                         ret = -EINVAL;
 335                         goto done;
 336                 }
 337         }
 338
 339         msleep(36);
 340
 341         /* m9206 will disconnect itself from the bus after this. */
 342         (void) m9206_write(udev, M9206_CORE, 0x01, M9206_FW_GO);
 343         deb_rc("firmware uploaded!\n");
 344
 345         done:
 346         kfree(buff);
 347
 348         return ret;
 349 }
 350
 351 /* Callbacks for DVB USB */
 352 static int m920x_identify_state(struct usb_device *udev,
 353                                 struct dvb_usb_device_properties *props,
 354                                 struct dvb_usb_device_description **desc,
 355                                 int *cold)
 356 {
 357         struct usb_host_interface *alt;
 358
 359         alt = usb_altnum_to_altsetting(usb_ifnum_to_if(udev, 0), 1);
 360         *cold = (alt == NULL) ? 1 : 0;
 361
 362         return 0;
 363 }
 364
 365 static int megasky_mt352_demod_init(struct dvb_frontend *fe)
 366 {
 367         u8 config[] = { CONFIG, 0x3d };
 368         u8 clock[] = { CLOCK_CTL, 0x30 };
 369         u8 reset[] = { RESET, 0x80 };
 370         u8 adc_ctl[] = { ADC_CTL_1, 0x40 };
 371         u8 agc[] = { AGC_TARGET, 0x1c, 0x20 };
 372         u8 sec_agc[] = { 0x69, 0x00, 0xff, 0xff, 0x40, 0xff, 0x00, 0x40, 0x40 };
 373         u8 unk1[] = { 0x93, 0x1a };
 374         u8 unk2[] = { 0xb5, 0x7a };
 375
 376         mt352_write(fe, config, ARRAY_SIZE(config));
 377         mt352_write(fe, clock, ARRAY_SIZE(clock));
 378         mt352_write(fe, reset, ARRAY_SIZE(reset));
 379         mt352_write(fe, adc_ctl, ARRAY_SIZE(adc_ctl));
 380         mt352_write(fe, agc, ARRAY_SIZE(agc));
 381         mt352_write(fe, sec_agc, ARRAY_SIZE(sec_agc));
 382         mt352_write(fe, unk1, ARRAY_SIZE(unk1));
 383         mt352_write(fe, unk2, ARRAY_SIZE(unk2));
 384
 385         deb_rc("Demod init!\n");
 386
 387         return 0;
 388 }
 389
 390 static struct mt352_config megasky_mt352_config = {
 391         .demod_address = 0x0f,
 392         .no_tuner = 1,
 393         .demod_init = megasky_mt352_demod_init,
 394 };
 395
 396 static int megasky_mt352_frontend_attach(struct dvb_usb_adapter *adap)
 397 {
 398         deb_rc("megasky_frontend_attach!\n");
 399
 400         if ((adap->fe = dvb_attach(mt352_attach, &megasky_mt352_config, &adap->dev->i2c_adap)) == NULL)
 401                 return -EIO;
 402
 403         return 0;
 404 }
 405
 406 static struct qt1010_config megasky_qt1010_config = {
 407         .i2c_address = 0x62
 408 };
 409
 410 static int megasky_qt1010_tuner_attach(struct dvb_usb_adapter *adap)
 411 {
 412         if (dvb_attach(qt1010_attach, adap->fe, &adap->dev->i2c_adap,
 413                        &megasky_qt1010_config) == NULL)
 414                 return -ENODEV;
 415
 416         return 0;
 417 }
 418
 419 static struct tda1004x_config digivox_tda10046_config = {
 420         .demod_address = 0x08,
 421         .invert = 0,
 422         .invert_oclk = 0,
 423         .ts_mode = TDA10046_TS_SERIAL,
 424         .xtal_freq = TDA10046_XTAL_16M,
 425         .if_freq = TDA10046_FREQ_045,
 426         .agc_config = TDA10046_AGC_TDA827X,
 427         .gpio_config = TDA10046_GPTRI,
 428         .request_firmware = NULL,
 429 };
 430
 431 static int digivox_tda10046_frontend_attach(struct dvb_usb_adapter *adap)
 432 {
 433         deb_rc("digivox_tda10046_frontend_attach!\n");
 434
 435         if ((adap->fe = dvb_attach(tda10046_attach, &digivox_tda10046_config,
 436                                    &adap->dev->i2c_adap)) == NULL)
 437                 return -EIO;
 438
 439         return 0;
 440 }
 441
 442 static int digivox_tda8275_tuner_attach(struct dvb_usb_adapter *adap)
 443 {
 444         if (dvb_attach(tda827x_attach, adap->fe, 0x60, &adap->dev->i2c_adap,
 445                        NULL) == NULL)
 446                 return -ENODEV;
 447         return 0;
 448 }
 449
 450 /* DVB USB Driver stuff */
 451 static struct dvb_usb_device_properties megasky_properties;
 452 static struct dvb_usb_device_properties digivox_mini_ii_properties;
 453
 454 static int m920x_probe(struct usb_interface *intf,
 455                        const struct usb_device_id *id)
 456 {
 457         struct dvb_usb_device *d;
 458         struct usb_host_interface *alt;
 459         int ret;
 460
 461         deb_rc("Probed!\n");
 462
 463         if (((ret = dvb_usb_device_init(intf, &megasky_properties, THIS_MODULE, &d)) == 0) ||
 464             ((ret = dvb_usb_device_init(intf, &digivox_mini_ii_properties, THIS_MODULE, &d)) == 0))
 465                 goto found;
 466
 467         return ret;
 468
 469 found:
 470         alt = usb_altnum_to_altsetting(intf, 1);
 471         if (alt == NULL) {
 472                 deb_rc("No alt found!\n");
 473                 return -ENODEV;
 474         }
 475
 476         ret = usb_set_interface(d->udev, alt->desc.bInterfaceNumber,
 477                                 alt->desc.bAlternateSetting);
 478         if (ret < 0)
 479                 return ret;
 480
 481         if ((ret = m9206_init(d)) != 0)
 482                 return ret;
 483
 484         return ret;
 485 }
 486
 487 static struct usb_device_id m920x_table [] = {
 488                 { USB_DEVICE(USB_VID_MSI, USB_PID_MSI_MEGASKY580) },
 489                 { USB_DEVICE(USB_VID_ANUBIS_ELECTRONIC,
 490                              USB_PID_MSI_DIGI_VOX_MINI_II) },
 491                 { }             /* Terminating entry */
 492 };
 493 MODULE_DEVICE_TABLE (usb, m920x_table);
 494
 495 static struct dvb_usb_device_properties megasky_properties = {
 496         .caps = DVB_USB_IS_AN_I2C_ADAPTER,
 497
 498         .usb_ctrl = DEVICE_SPECIFIC,
 499         .firmware = "dvb-usb-megasky-02.fw",
 500         .download_firmware = m9206_firmware_download,
 501
 502         .rc_interval      = 100,
 503         .rc_key_map       = megasky_rc_keys,
 504         .rc_key_map_size  = ARRAY_SIZE(megasky_rc_keys),
 505         .rc_query         = m9206_rc_query,
 506
 507         .size_of_priv     = sizeof(struct m9206_state),
 508
 509         .identify_state   = m920x_identify_state,
 510         .num_adapters = 1,
 511         .adapter = {{
 512                 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
 513                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
 514
 515                 .pid_filter_count = 8,
 516                 .pid_filter       = m9206_pid_filter,
 517                 .pid_filter_ctrl  = m9206_pid_filter_ctrl,
 518
 519                 .frontend_attach  = megasky_mt352_frontend_attach,
 520                 .tuner_attach     = megasky_qt1010_tuner_attach,
 521
 522                 .stream = {
 523                         .type = USB_BULK,
 524                         .count = 8,
 525                         .endpoint = 0x81,
 526                         .u = {
 527                                 .bulk = {
 528                                         .buffersize = 512,
 529                                 }
 530                         }
 531                 },
 532         }},
 533         .i2c_algo         = &m9206_i2c_algo,
 534
 535         .num_device_descs = 1,
 536         .devices = {
 537                 {   "MSI Mega Sky 580 DVB-T USB2.0",
 538                         { &m920x_table[0], NULL },
 539                         { NULL },
 540                 }
 541         }
 542 };
 543
 544 static struct dvb_usb_device_properties digivox_mini_ii_properties = {
 545         .caps = DVB_USB_IS_AN_I2C_ADAPTER,
 546
 547         .usb_ctrl = DEVICE_SPECIFIC,
 548         .firmware = "dvb-usb-digivox-02.fw",
 549         .download_firmware = m9206_firmware_download,
 550
 551         .size_of_priv     = sizeof(struct m9206_state),
 552
 553         .identify_state   = m920x_identify_state,
 554         .num_adapters = 1,
 555         .adapter = {{
 556                 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
 557                 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
 558
 559                 .pid_filter_count = 8,
 560                 .pid_filter       = m9206_pid_filter,
 561                 .pid_filter_ctrl  = m9206_pid_filter_ctrl,
 562
 563                 .frontend_attach  = digivox_tda10046_frontend_attach,
 564                 .tuner_attach     = digivox_tda8275_tuner_attach,
 565
 566                 .stream = {
 567                         .type = USB_BULK,
 568                         .count = 8,
 569                         .endpoint = 0x81,
 570                         .u = {
 571                                 .bulk = {
 572                                         .buffersize = 0x4000,
 573                                 }
 574                         }
 575                 },
 576         }},
 577         .i2c_algo         = &m9206_i2c_algo,
 578
 579         .num_device_descs = 1,
 580         .devices = {
 581                 {   "MSI DIGI VOX mini II DVB-T USB2.0",
 582                         { &m920x_table[1], NULL },
 583                         { NULL },
 584                 },
 585         }
 586 };
 587
 588 static struct usb_driver m920x_driver = {
 589         .name           = "dvb_usb_m920x",
 590         .probe          = m920x_probe,
 591         .disconnect     = dvb_usb_device_exit,
 592         .id_table       = m920x_table,
 593 };
 594
 595 /* module stuff */
 596 static int __init m920x_module_init(void)
 597 {
 598         int ret;
 599
 600         if ((ret = usb_register(&m920x_driver))) {
 601                 err("usb_register failed. Error number %d", ret);
 602                 return ret;
 603         }
 604
 605         return 0;
 606 }
 607
 608 static void __exit m920x_module_exit(void)
 609 {
 610         /* deregister this driver from the USB subsystem */
 611         usb_deregister(&m920x_driver);
 612 }
 613
 614 module_init (m920x_module_init);
 615 module_exit (m920x_module_exit);
 616
 617 MODULE_AUTHOR("Aapo Tahkola <aet@rasterburn.org>");
 618 MODULE_DESCRIPTION("Driver MSI Mega Sky 580 DVB-T USB2.0 / Uli m920x");
 619 MODULE_VERSION("0.1");
 620 MODULE_LICENSE("GPL");