Pileus Git - ~andy/linux/blob - drivers/media/usb/dvb-usb-v2/lmedm04.c

   1 /* DVB USB compliant linux driver for
   2  *
   3  * DM04/QQBOX DVB-S USB BOX     LME2510C + SHARP:BS2F7HZ7395
   4  *                              LME2510C + LG TDQY-P001F
   5  *                              LME2510C + BS2F7HZ0194
   6  *                              LME2510 + LG TDQY-P001F
   7  *                              LME2510 + BS2F7HZ0194
   8  *
   9  * MVB7395 (LME2510C+SHARP:BS2F7HZ7395)
  10  * SHARP:BS2F7HZ7395 = (STV0288+Sharp IX2505V)
  11  *
  12  * MV001F (LME2510+LGTDQY-P001F)
  13  * LG TDQY - P001F =(TDA8263 + TDA10086H)
  14  *
  15  * MVB0001F (LME2510C+LGTDQT-P001F)
  16  *
  17  * MV0194 (LME2510+SHARP:BS2F7HZ0194)
  18  * SHARP:BS2F7HZ0194 = (STV0299+IX2410)
  19  *
  20  * MVB0194 (LME2510C+SHARP0194)
  21  *
  22  * LME2510C + M88RS2000
  23  *
  24  * For firmware see Documentation/dvb/lmedm04.txt
  25  *
  26  * I2C addresses:
  27  * 0xd0 - STV0288       - Demodulator
  28  * 0xc0 - Sharp IX2505V - Tuner
  29  * --
  30  * 0x1c - TDA10086   - Demodulator
  31  * 0xc0 - TDA8263    - Tuner
  32  * --
  33  * 0xd0 - STV0299       - Demodulator
  34  * 0xc0 - IX2410        - Tuner
  35  *
  36  *
  37  * VID = 3344  PID LME2510=1122 LME2510C=1120
  38  *
  39  * Copyright (C) 2010 Malcolm Priestley (tvboxspy@gmail.com)
  40  * LME2510(C)(C) Leaguerme (Shenzhen) MicroElectronics Co., Ltd.
  41  *
  42  * This program is free software; you can redistribute it and/or modify
  43  * it under the terms of the GNU General Public License Version 2, as
  44  * published by the Free Software Foundation.
  45  *
  46  * This program is distributed in the hope that it will be useful,
  47  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  48  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  49  * GNU General Public License for more details.
  50  *
  51  * You should have received a copy of the GNU General Public License
  52  * along with this program; if not, write to the Free Software
  53  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  54  *
  55  *
  56  * see Documentation/dvb/README.dvb-usb for more information
  57  *
  58  * Known Issues :
  59  *      LME2510: Non Intel USB chipsets fail to maintain High Speed on
  60  * Boot or Hot Plug.
  61  *
  62  * QQbox suffers from noise on LNB voltage.
  63  *
  64  *      LME2510: SHARP:BS2F7HZ0194(MV0194) cannot cold reset and share system
  65  * with other tuners. After a cold reset streaming will not start.
  66  *
  67  * M88RS2000 suffers from loss of lock.
  68  */
  69 #define DVB_USB_LOG_PREFIX "LME2510(C)"
  70 #include <linux/usb.h>
  71 #include <linux/usb/input.h>
  72 #include <media/rc-core.h>
  73
  74 #include "dvb_usb.h"
  75 #include "lmedm04.h"
  76 #include "tda826x.h"
  77 #include "tda10086.h"
  78 #include "stv0288.h"
  79 #include "ix2505v.h"
  80 #include "stv0299.h"
  81 #include "dvb-pll.h"
  82 #include "z0194a.h"
  83 #include "m88rs2000.h"
  84 #include "ts2020.h"
  85
  86
  87 #define LME2510_C_S7395 "dvb-usb-lme2510c-s7395.fw";
  88 #define LME2510_C_LG    "dvb-usb-lme2510c-lg.fw";
  89 #define LME2510_C_S0194 "dvb-usb-lme2510c-s0194.fw";
  90 #define LME2510_C_RS2000 "dvb-usb-lme2510c-rs2000.fw";
  91 #define LME2510_LG      "dvb-usb-lme2510-lg.fw";
  92 #define LME2510_S0194   "dvb-usb-lme2510-s0194.fw";
  93
  94 /* debug */
  95 static int dvb_usb_lme2510_debug;
  96 #define lme_debug(var, level, args...) do { \
  97         if ((var >= level)) \
  98                 pr_debug(DVB_USB_LOG_PREFIX": " args); \
  99 } while (0)
 100 #define deb_info(level, args...) lme_debug(dvb_usb_lme2510_debug, level, args)
 101 #define debug_data_snipet(level, name, p) \
 102          deb_info(level, name" (%02x%02x%02x%02x%02x%02x%02x%02x)", \
 103                 *p, *(p+1), *(p+2), *(p+3), *(p+4), \
 104                         *(p+5), *(p+6), *(p+7));
 105 #define info(args...) pr_info(DVB_USB_LOG_PREFIX": "args)
 106
 107 module_param_named(debug, dvb_usb_lme2510_debug, int, 0644);
 108 MODULE_PARM_DESC(debug, "set debugging level (1=info (or-able)).");
 109
 110 static int dvb_usb_lme2510_firmware;
 111 module_param_named(firmware, dvb_usb_lme2510_firmware, int, 0644);
 112 MODULE_PARM_DESC(firmware, "set default firmware 0=Sharp7395 1=LG");
 113
 114 static int pid_filter;
 115 module_param_named(pid, pid_filter, int, 0644);
 116 MODULE_PARM_DESC(pid, "set default 0=default 1=off 2=on");
 117
 118
 119 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
 120
 121 #define TUNER_DEFAULT   0x0
 122 #define TUNER_LG        0x1
 123 #define TUNER_S7395     0x2
 124 #define TUNER_S0194     0x3
 125 #define TUNER_RS2000    0x4
 126
 127 struct lme2510_state {
 128         u8 id;
 129         u8 tuner_config;
 130         u8 signal_lock;
 131         u8 signal_level;
 132         u8 signal_sn;
 133         u8 time_key;
 134         u8 last_key;
 135         u8 key_timeout;
 136         u8 i2c_talk_onoff;
 137         u8 i2c_gate;
 138         u8 i2c_tuner_gate_w;
 139         u8 i2c_tuner_gate_r;
 140         u8 i2c_tuner_addr;
 141         u8 stream_on;
 142         u8 pid_size;
 143         u8 pid_off;
 144         void *buffer;
 145         struct urb *lme_urb;
 146         void *usb_buffer;
 147         int (*fe_set_voltage)(struct dvb_frontend *, fe_sec_voltage_t);
 148         u8 dvb_usb_lme2510_firmware;
 149 };
 150
 151 static int lme2510_bulk_write(struct usb_device *dev,
 152                                 u8 *snd, int len, u8 pipe)
 153 {
 154         int ret, actual_l;
 155
 156         ret = usb_bulk_msg(dev, usb_sndbulkpipe(dev, pipe),
 157                                 snd, len , &actual_l, 100);
 158         return ret;
 159 }
 160
 161 static int lme2510_bulk_read(struct usb_device *dev,
 162                                 u8 *rev, int len, u8 pipe)
 163 {
 164         int ret, actual_l;
 165
 166         ret = usb_bulk_msg(dev, usb_rcvbulkpipe(dev, pipe),
 167                                  rev, len , &actual_l, 200);
 168         return ret;
 169 }
 170
 171 static int lme2510_usb_talk(struct dvb_usb_device *d,
 172                 u8 *wbuf, int wlen, u8 *rbuf, int rlen)
 173 {
 174         struct lme2510_state *st = d->priv;
 175         u8 *buff;
 176         int ret = 0;
 177
 178         if (st->usb_buffer == NULL) {
 179                 st->usb_buffer = kmalloc(64, GFP_KERNEL);
 180                 if (st->usb_buffer == NULL) {
 181                         info("MEM Error no memory");
 182                         return -ENOMEM;
 183                 }
 184         }
 185         buff = st->usb_buffer;
 186
 187         ret = mutex_lock_interruptible(&d->usb_mutex);
 188
 189         if (ret < 0)
 190                 return -EAGAIN;
 191
 192         /* the read/write capped at 64 */
 193         memcpy(buff, wbuf, (wlen < 64) ? wlen : 64);
 194
 195         ret |= lme2510_bulk_write(d->udev, buff, wlen , 0x01);
 196
 197         ret |= lme2510_bulk_read(d->udev, buff, (rlen < 64) ?
 198                         rlen : 64 , 0x01);
 199
 200         if (rlen > 0)
 201                 memcpy(rbuf, buff, rlen);
 202
 203         mutex_unlock(&d->usb_mutex);
 204
 205         return (ret < 0) ? -ENODEV : 0;
 206 }
 207
 208 static int lme2510_stream_restart(struct dvb_usb_device *d)
 209 {
 210         struct lme2510_state *st = d->priv;
 211         u8 all_pids[] = LME_ALL_PIDS;
 212         u8 stream_on[] = LME_ST_ON_W;
 213         int ret;
 214         u8 rbuff[1];
 215         if (st->pid_off)
 216                 ret = lme2510_usb_talk(d, all_pids, sizeof(all_pids),
 217                         rbuff, sizeof(rbuff));
 218         /*Restart Stream Command*/
 219         ret = lme2510_usb_talk(d, stream_on, sizeof(stream_on),
 220                         rbuff, sizeof(rbuff));
 221         return ret;
 222 }
 223
 224 static int lme2510_enable_pid(struct dvb_usb_device *d, u8 index, u16 pid_out)
 225 {
 226         struct lme2510_state *st = d->priv;
 227         static u8 pid_buff[] = LME_ZERO_PID;
 228         static u8 rbuf[1];
 229         u8 pid_no = index * 2;
 230         u8 pid_len = pid_no + 2;
 231         int ret = 0;
 232         deb_info(1, "PID Setting Pid %04x", pid_out);
 233
 234         if (st->pid_size == 0)
 235                 ret |= lme2510_stream_restart(d);
 236
 237         pid_buff[2] = pid_no;
 238         pid_buff[3] = (u8)pid_out & 0xff;
 239         pid_buff[4] = pid_no + 1;
 240         pid_buff[5] = (u8)(pid_out >> 8);
 241
 242         if (pid_len > st->pid_size)
 243                 st->pid_size = pid_len;
 244         pid_buff[7] = 0x80 + st->pid_size;
 245
 246         ret |= lme2510_usb_talk(d, pid_buff ,
 247                 sizeof(pid_buff) , rbuf, sizeof(rbuf));
 248
 249         if (st->stream_on)
 250                 ret |= lme2510_stream_restart(d);
 251
 252         return ret;
 253 }
 254
 255 static void lme2510_int_response(struct urb *lme_urb)
 256 {
 257         struct dvb_usb_adapter *adap = lme_urb->context;
 258         struct lme2510_state *st = adap_to_priv(adap);
 259         static u8 *ibuf, *rbuf;
 260         int i = 0, offset;
 261         u32 key;
 262
 263         switch (lme_urb->status) {
 264         case 0:
 265         case -ETIMEDOUT:
 266                 break;
 267         case -ECONNRESET:
 268         case -ENOENT:
 269         case -ESHUTDOWN:
 270                 return;
 271         default:
 272                 info("Error %x", lme_urb->status);
 273                 break;
 274         }
 275
 276         rbuf = (u8 *) lme_urb->transfer_buffer;
 277
 278         offset = ((lme_urb->actual_length/8) > 4)
 279                         ? 4 : (lme_urb->actual_length/8) ;
 280
 281         for (i = 0; i < offset; ++i) {
 282                 ibuf = (u8 *)&rbuf[i*8];
 283                 deb_info(5, "INT O/S C =%02x C/O=%02x Type =%02x%02x",
 284                 offset, i, ibuf[0], ibuf[1]);
 285
 286                 switch (ibuf[0]) {
 287                 case 0xaa:
 288                         debug_data_snipet(1, "INT Remote data snipet", ibuf);
 289                         if ((ibuf[4] + ibuf[5]) == 0xff) {
 290                                 key = ibuf[5];
 291                                 key += (ibuf[3] > 0)
 292                                         ? (ibuf[3] ^ 0xff) << 8 : 0;
 293                                 key += (ibuf[2] ^ 0xff) << 16;
 294                                 deb_info(1, "INT Key =%08x", key);
 295                                 if (adap_to_d(adap)->rc_dev != NULL)
 296                                         rc_keydown(adap_to_d(adap)->rc_dev,
 297                                                 key, 0);
 298                         }
 299                         break;
 300                 case 0xbb:
 301                         switch (st->tuner_config) {
 302                         case TUNER_LG:
 303                                 if (ibuf[2] > 0)
 304                                         st->signal_lock = ibuf[2];
 305                                 st->signal_level = ibuf[4];
 306                                 st->signal_sn = ibuf[3];
 307                                 st->time_key = ibuf[7];
 308                                 break;
 309                         case TUNER_S7395:
 310                         case TUNER_S0194:
 311                                 /* Tweak for earlier firmware*/
 312                                 if (ibuf[1] == 0x03) {
 313                                         if (ibuf[2] > 1)
 314                                                 st->signal_lock = ibuf[2];
 315                                         st->signal_level = ibuf[3];
 316                                         st->signal_sn = ibuf[4];
 317                                 } else {
 318                                         st->signal_level = ibuf[4];
 319                                         st->signal_sn = ibuf[5];
 320                                         st->signal_lock =
 321                                                 (st->signal_lock & 0xf7) +
 322                                                 ((ibuf[2] & 0x01) << 0x03);
 323                                 }
 324                                 break;
 325                         case TUNER_RS2000:
 326                                 if (ibuf[1] == 0x3 &&  ibuf[6] == 0xff)
 327                                         st->signal_lock = 0xff;
 328                                 else
 329                                         st->signal_lock = 0x00;
 330                                 st->signal_level = ibuf[5];
 331                                 st->signal_sn = ibuf[4];
 332                                 st->time_key = ibuf[7];
 333                         default:
 334                                 break;
 335                         }
 336                         debug_data_snipet(5, "INT Remote data snipet in", ibuf);
 337                 break;
 338                 case 0xcc:
 339                         debug_data_snipet(1, "INT Control data snipet", ibuf);
 340                         break;
 341                 default:
 342                         debug_data_snipet(1, "INT Unknown data snipet", ibuf);
 343                 break;
 344                 }
 345         }
 346         usb_submit_urb(lme_urb, GFP_ATOMIC);
 347 }
 348
 349 static int lme2510_int_read(struct dvb_usb_adapter *adap)
 350 {
 351         struct dvb_usb_device *d = adap_to_d(adap);
 352         struct lme2510_state *lme_int = adap_to_priv(adap);
 353
 354         lme_int->lme_urb = usb_alloc_urb(0, GFP_ATOMIC);
 355
 356         if (lme_int->lme_urb == NULL)
 357                         return -ENOMEM;
 358
 359         lme_int->buffer = usb_alloc_coherent(d->udev, 128, GFP_ATOMIC,
 360                                         &lme_int->lme_urb->transfer_dma);
 361
 362         if (lme_int->buffer == NULL)
 363                         return -ENOMEM;
 364
 365         usb_fill_int_urb(lme_int->lme_urb,
 366                                 d->udev,
 367                                 usb_rcvintpipe(d->udev, 0xa),
 368                                 lme_int->buffer,
 369                                 128,
 370                                 lme2510_int_response,
 371                                 adap,
 372                                 8);
 373
 374         lme_int->lme_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 375
 376         usb_submit_urb(lme_int->lme_urb, GFP_ATOMIC);
 377         info("INT Interrupt Service Started");
 378
 379         return 0;
 380 }
 381
 382 static int lme2510_pid_filter_ctrl(struct dvb_usb_adapter *adap, int onoff)
 383 {
 384         struct dvb_usb_device *d = adap_to_d(adap);
 385         struct lme2510_state *st = adap_to_priv(adap);
 386         static u8 clear_pid_reg[] = LME_ALL_PIDS;
 387         static u8 rbuf[1];
 388         int ret = 0;
 389
 390         deb_info(1, "PID Clearing Filter");
 391
 392         mutex_lock(&d->i2c_mutex);
 393
 394         if (!onoff) {
 395                 ret |= lme2510_usb_talk(d, clear_pid_reg,
 396                         sizeof(clear_pid_reg), rbuf, sizeof(rbuf));
 397                 st->pid_off = true;
 398         } else
 399                 st->pid_off = false;
 400
 401         st->pid_size = 0;
 402
 403         mutex_unlock(&d->i2c_mutex);
 404
 405         return 0;
 406 }
 407
 408 static int lme2510_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid,
 409         int onoff)
 410 {
 411         struct dvb_usb_device *d = adap_to_d(adap);
 412         int ret = 0;
 413
 414         deb_info(3, "%s PID=%04x Index=%04x onoff=%02x", __func__,
 415                 pid, index, onoff);
 416
 417         if (onoff) {
 418                 mutex_lock(&d->i2c_mutex);
 419                 ret |= lme2510_enable_pid(d, index, pid);
 420                 mutex_unlock(&d->i2c_mutex);
 421         }
 422
 423
 424         return ret;
 425 }
 426
 427
 428 static int lme2510_return_status(struct dvb_usb_device *d)
 429 {
 430         int ret = 0;
 431         u8 *data;
 432
 433         data = kzalloc(10, GFP_KERNEL);
 434         if (!data)
 435                 return -ENOMEM;
 436
 437         ret |= usb_control_msg(d->udev, usb_rcvctrlpipe(d->udev, 0),
 438                         0x06, 0x80, 0x0302, 0x00, data, 0x0006, 200);
 439         info("Firmware Status: %x (%x)", ret , data[2]);
 440
 441         ret = (ret < 0) ? -ENODEV : data[2];
 442         kfree(data);
 443         return ret;
 444 }
 445
 446 static int lme2510_msg(struct dvb_usb_device *d,
 447                 u8 *wbuf, int wlen, u8 *rbuf, int rlen)
 448 {
 449         int ret = 0;
 450         struct lme2510_state *st = d->priv;
 451
 452         if (st->i2c_talk_onoff == 1) {
 453
 454                 ret = lme2510_usb_talk(d, wbuf, wlen, rbuf, rlen);
 455
 456                 switch (st->tuner_config) {
 457                 case TUNER_LG:
 458                         if (wbuf[2] == 0x1c) {
 459                                 if (wbuf[3] == 0x0e) {
 460                                         st->signal_lock = rbuf[1];
 461                                         if ((st->stream_on & 1) &&
 462                                                 (st->signal_lock & 0x10)) {
 463                                                 lme2510_stream_restart(d);
 464                                                 st->i2c_talk_onoff = 0;
 465                                         }
 466                                         msleep(80);
 467                                 }
 468                         }
 469                         break;
 470                 case TUNER_S7395:
 471                         if (wbuf[2] == 0xd0) {
 472                                 if (wbuf[3] == 0x24) {
 473                                         st->signal_lock = rbuf[1];
 474                                         if ((st->stream_on & 1) &&
 475                                                 (st->signal_lock & 0x8)) {
 476                                                 lme2510_stream_restart(d);
 477                                                 st->i2c_talk_onoff = 0;
 478                                         }
 479                                 }
 480                         }
 481                         break;
 482                 case TUNER_S0194:
 483                         if (wbuf[2] == 0xd0) {
 484                                 if (wbuf[3] == 0x1b) {
 485                                         st->signal_lock = rbuf[1];
 486                                         if ((st->stream_on & 1) &&
 487                                                 (st->signal_lock & 0x8)) {
 488                                                 lme2510_stream_restart(d);
 489                                                 st->i2c_talk_onoff = 0;
 490                                         }
 491                                 }
 492                         }
 493                         break;
 494                 case TUNER_RS2000:
 495                 default:
 496                         break;
 497                 }
 498         } else {
 499                 /* TODO rewrite this section */
 500                 switch (st->tuner_config) {
 501                 case TUNER_LG:
 502                         switch (wbuf[3]) {
 503                         case 0x0e:
 504                                 rbuf[0] = 0x55;
 505                                 rbuf[1] = st->signal_lock;
 506                                 break;
 507                         case 0x43:
 508                                 rbuf[0] = 0x55;
 509                                 rbuf[1] = st->signal_level;
 510                                 break;
 511                         case 0x1c:
 512                                 rbuf[0] = 0x55;
 513                                 rbuf[1] = st->signal_sn;
 514                                 break;
 515                         case 0x15:
 516                         case 0x16:
 517                         case 0x17:
 518                         case 0x18:
 519                                 rbuf[0] = 0x55;
 520                                 rbuf[1] = 0x00;
 521                                 break;
 522                         default:
 523                                 lme2510_usb_talk(d, wbuf, wlen, rbuf, rlen);
 524                                 st->i2c_talk_onoff = 1;
 525                                 break;
 526                         }
 527                         break;
 528                 case TUNER_S7395:
 529                         switch (wbuf[3]) {
 530                         case 0x10:
 531                                 rbuf[0] = 0x55;
 532                                 rbuf[1] = (st->signal_level & 0x80)
 533                                                 ? 0 : (st->signal_level * 2);
 534                                 break;
 535                         case 0x2d:
 536                                 rbuf[0] = 0x55;
 537                                 rbuf[1] = st->signal_sn;
 538                                 break;
 539                         case 0x24:
 540                                 rbuf[0] = 0x55;
 541                                 rbuf[1] = st->signal_lock;
 542                                 break;
 543                         case 0x2e:
 544                         case 0x26:
 545                         case 0x27:
 546                                 rbuf[0] = 0x55;
 547                                 rbuf[1] = 0x00;
 548                                 break;
 549                         default:
 550                                 lme2510_usb_talk(d, wbuf, wlen, rbuf, rlen);
 551                                 st->i2c_talk_onoff = 1;
 552                                 break;
 553                         }
 554                         break;
 555                 case TUNER_S0194:
 556                         switch (wbuf[3]) {
 557                         case 0x18:
 558                                 rbuf[0] = 0x55;
 559                                 rbuf[1] = (st->signal_level & 0x80)
 560                                                 ? 0 : (st->signal_level * 2);
 561                                 break;
 562                         case 0x24:
 563                                 rbuf[0] = 0x55;
 564                                 rbuf[1] = st->signal_sn;
 565                                 break;
 566                         case 0x1b:
 567                                 rbuf[0] = 0x55;
 568                                 rbuf[1] = st->signal_lock;
 569                                 break;
 570                         case 0x19:
 571                         case 0x25:
 572                         case 0x1e:
 573                         case 0x1d:
 574                                 rbuf[0] = 0x55;
 575                                 rbuf[1] = 0x00;
 576                                 break;
 577                         default:
 578                                 lme2510_usb_talk(d, wbuf, wlen, rbuf, rlen);
 579                                 st->i2c_talk_onoff = 1;
 580                                 break;
 581                         }
 582                         break;
 583                 case TUNER_RS2000:
 584                         switch (wbuf[3]) {
 585                         case 0x8c:
 586                                 rbuf[0] = 0x55;
 587                                 rbuf[1] = 0xff;
 588                                 if (st->last_key == st->time_key) {
 589                                         st->key_timeout++;
 590                                         if (st->key_timeout > 5)
 591                                                 rbuf[1] = 0;
 592                                 } else
 593                                         st->key_timeout = 0;
 594                                 st->last_key = st->time_key;
 595                                 break;
 596                         default:
 597                                 lme2510_usb_talk(d, wbuf, wlen, rbuf, rlen);
 598                                 st->i2c_talk_onoff = 1;
 599                                 break;
 600                         }
 601                 default:
 602                         break;
 603                 }
 604
 605                 deb_info(4, "I2C From Interrupt Message out(%02x) in(%02x)",
 606                                 wbuf[3], rbuf[1]);
 607
 608         }
 609
 610         return ret;
 611 }
 612
 613
 614 static int lme2510_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
 615                                  int num)
 616 {
 617         struct dvb_usb_device *d = i2c_get_adapdata(adap);
 618         struct lme2510_state *st = d->priv;
 619         static u8 obuf[64], ibuf[64];
 620         int i, read, read_o;
 621         u16 len;
 622         u8 gate = st->i2c_gate;
 623
 624         mutex_lock(&d->i2c_mutex);
 625
 626         if (gate == 0)
 627                 gate = 5;
 628
 629         for (i = 0; i < num; i++) {
 630                 read_o = msg[i].flags & I2C_M_RD;
 631                 read = i + 1 < num && msg[i + 1].flags & I2C_M_RD;
 632                 read |= read_o;
 633                 gate = (msg[i].addr == st->i2c_tuner_addr)
 634                         ? (read)        ? st->i2c_tuner_gate_r
 635                                         : st->i2c_tuner_gate_w
 636                         : st->i2c_gate;
 637                 obuf[0] = gate | (read << 7);
 638
 639                 if (gate == 5)
 640                         obuf[1] = (read) ? 2 : msg[i].len + 1;
 641                 else
 642                         obuf[1] = msg[i].len + read + 1;
 643
 644                 obuf[2] = msg[i].addr << 1;
 645
 646                 if (read) {
 647                         if (read_o)
 648                                 len = 3;
 649                         else {
 650                                 memcpy(&obuf[3], msg[i].buf, msg[i].len);
 651                                 obuf[msg[i].len+3] = msg[i+1].len;
 652                                 len = msg[i].len+4;
 653                         }
 654                 } else {
 655                         memcpy(&obuf[3], msg[i].buf, msg[i].len);
 656                         len = msg[i].len+3;
 657                 }
 658
 659                 if (lme2510_msg(d, obuf, len, ibuf, 64) < 0) {
 660                         deb_info(1, "i2c transfer failed.");
 661                         mutex_unlock(&d->i2c_mutex);
 662                         return -EAGAIN;
 663                 }
 664
 665                 if (read) {
 666                         if (read_o)
 667                                 memcpy(msg[i].buf, &ibuf[1], msg[i].len);
 668                         else {
 669                                 memcpy(msg[i+1].buf, &ibuf[1], msg[i+1].len);
 670                                 i++;
 671                         }
 672                 }
 673         }
 674
 675         mutex_unlock(&d->i2c_mutex);
 676         return i;
 677 }
 678
 679 static u32 lme2510_i2c_func(struct i2c_adapter *adapter)
 680 {
 681         return I2C_FUNC_I2C;
 682 }
 683
 684 static struct i2c_algorithm lme2510_i2c_algo = {
 685         .master_xfer   = lme2510_i2c_xfer,
 686         .functionality = lme2510_i2c_func,
 687 };
 688
 689 static int lme2510_streaming_ctrl(struct dvb_frontend *fe, int onoff)
 690 {
 691         struct dvb_usb_adapter *adap = fe_to_adap(fe);
 692         struct dvb_usb_device *d = adap_to_d(adap);
 693         struct lme2510_state *st = adap_to_priv(adap);
 694         static u8 clear_reg_3[] = LME_ALL_PIDS;
 695         static u8 rbuf[1];
 696         int ret = 0, rlen = sizeof(rbuf);
 697
 698         deb_info(1, "STM  (%02x)", onoff);
 699
 700         /* Streaming is started by FE_HAS_LOCK */
 701         if (onoff == 1)
 702                 st->stream_on = 1;
 703         else {
 704                 deb_info(1, "STM Steam Off");
 705                 /* mutex is here only to avoid collision with I2C */
 706                 mutex_lock(&d->i2c_mutex);
 707
 708                 ret = lme2510_usb_talk(d, clear_reg_3,
 709                                 sizeof(clear_reg_3), rbuf, rlen);
 710                 st->stream_on = 0;
 711                 st->i2c_talk_onoff = 1;
 712
 713                 mutex_unlock(&d->i2c_mutex);
 714         }
 715
 716         return (ret < 0) ? -ENODEV : 0;
 717 }
 718
 719 static u8 check_sum(u8 *p, u8 len)
 720 {
 721         u8 sum = 0;
 722         while (len--)
 723                 sum += *p++;
 724         return sum;
 725 }
 726
 727 static int lme2510_download_firmware(struct dvb_usb_device *d,
 728                                         const struct firmware *fw)
 729 {
 730         int ret = 0;
 731         u8 *data;
 732         u16 j, wlen, len_in, start, end;
 733         u8 packet_size, dlen, i;
 734         u8 *fw_data;
 735
 736         packet_size = 0x31;
 737         len_in = 1;
 738
 739         data = kzalloc(128, GFP_KERNEL);
 740         if (!data) {
 741                 info("FRM Could not start Firmware Download"\
 742                         "(Buffer allocation failed)");
 743                 return -ENOMEM;
 744         }
 745
 746         info("FRM Starting Firmware Download");
 747
 748         for (i = 1; i < 3; i++) {
 749                 start = (i == 1) ? 0 : 512;
 750                 end = (i == 1) ? 512 : fw->size;
 751                 for (j = start; j < end; j += (packet_size+1)) {
 752                         fw_data = (u8 *)(fw->data + j);
 753                         if ((end - j) > packet_size) {
 754                                 data[0] = i;
 755                                 dlen = packet_size;
 756                         } else {
 757                                 data[0] = i | 0x80;
 758                                 dlen = (u8)(end - j)-1;
 759                         }
 760                         data[1] = dlen;
 761                         memcpy(&data[2], fw_data, dlen+1);
 762                         wlen = (u8) dlen + 4;
 763                         data[wlen-1] = check_sum(fw_data, dlen+1);
 764                         deb_info(1, "Data S=%02x:E=%02x CS= %02x", data[3],
 765                                 data[dlen+2], data[dlen+3]);
 766                         lme2510_usb_talk(d, data, wlen, data, len_in);
 767                         ret |= (data[0] == 0x88) ? 0 : -1;
 768                 }
 769         }
 770
 771         data[0] = 0x8a;
 772         len_in = 1;
 773         msleep(2000);
 774         lme2510_usb_talk(d, data, len_in, data, len_in);
 775         msleep(400);
 776
 777         if (ret < 0)
 778                 info("FRM Firmware Download Failed (%04x)" , ret);
 779         else
 780                 info("FRM Firmware Download Completed - Resetting Device");
 781
 782         kfree(data);
 783         return RECONNECTS_USB;
 784 }
 785
 786 static void lme_coldreset(struct dvb_usb_device *d)
 787 {
 788         u8 data[1] = {0};
 789         data[0] = 0x0a;
 790         info("FRM Firmware Cold Reset");
 791
 792         lme2510_usb_talk(d, data, sizeof(data), data, sizeof(data));
 793
 794         return;
 795 }
 796
 797 static const char fw_c_s7395[] = LME2510_C_S7395;
 798 static const char fw_c_lg[] = LME2510_C_LG;
 799 static const char fw_c_s0194[] = LME2510_C_S0194;
 800 static const char fw_c_rs2000[] = LME2510_C_RS2000;
 801 static const char fw_lg[] = LME2510_LG;
 802 static const char fw_s0194[] = LME2510_S0194;
 803
 804 static const char *lme_firmware_switch(struct dvb_usb_device *d, int cold)
 805 {
 806         struct lme2510_state *st = d->priv;
 807         struct usb_device *udev = d->udev;
 808         const struct firmware *fw = NULL;
 809         const char *fw_lme;
 810         int ret = 0;
 811
 812         cold = (cold > 0) ? (cold & 1) : 0;
 813
 814         switch (le16_to_cpu(udev->descriptor.idProduct)) {
 815         case 0x1122:
 816                 switch (st->dvb_usb_lme2510_firmware) {
 817                 default:
 818                         st->dvb_usb_lme2510_firmware = TUNER_S0194;
 819                 case TUNER_S0194:
 820                         fw_lme = fw_s0194;
 821                         ret = request_firmware(&fw, fw_lme, &udev->dev);
 822                         if (ret == 0) {
 823                                 cold = 0;
 824                                 break;
 825                         }
 826                         st->dvb_usb_lme2510_firmware = TUNER_LG;
 827                 case TUNER_LG:
 828                         fw_lme = fw_lg;
 829                         ret = request_firmware(&fw, fw_lme, &udev->dev);
 830                         if (ret == 0)
 831                                 break;
 832                         st->dvb_usb_lme2510_firmware = TUNER_DEFAULT;
 833                         break;
 834                 }
 835                 break;
 836         case 0x1120:
 837                 switch (st->dvb_usb_lme2510_firmware) {
 838                 default:
 839                         st->dvb_usb_lme2510_firmware = TUNER_S7395;
 840                 case TUNER_S7395:
 841                         fw_lme = fw_c_s7395;
 842                         ret = request_firmware(&fw, fw_lme, &udev->dev);
 843                         if (ret == 0) {
 844                                 cold = 0;
 845                                 break;
 846                         }
 847                         st->dvb_usb_lme2510_firmware = TUNER_LG;
 848                 case TUNER_LG:
 849                         fw_lme = fw_c_lg;
 850                         ret = request_firmware(&fw, fw_lme, &udev->dev);
 851                         if (ret == 0)
 852                                 break;
 853                         st->dvb_usb_lme2510_firmware = TUNER_S0194;
 854                 case TUNER_S0194:
 855                         fw_lme = fw_c_s0194;
 856                         ret = request_firmware(&fw, fw_lme, &udev->dev);
 857                         if (ret == 0)
 858                                 break;
 859                         st->dvb_usb_lme2510_firmware = TUNER_DEFAULT;
 860                         cold = 0;
 861                         break;
 862                 }
 863                 break;
 864         case 0x22f0:
 865                 fw_lme = fw_c_rs2000;
 866                 st->dvb_usb_lme2510_firmware = TUNER_RS2000;
 867                 break;
 868         default:
 869                 fw_lme = fw_c_s7395;
 870         }
 871
 872         release_firmware(fw);
 873
 874         if (cold) {
 875                 dvb_usb_lme2510_firmware = st->dvb_usb_lme2510_firmware;
 876                 info("FRM Changing to %s firmware", fw_lme);
 877                 lme_coldreset(d);
 878                 return NULL;
 879         }
 880
 881         return fw_lme;
 882 }
 883
 884 static int lme2510_kill_urb(struct usb_data_stream *stream)
 885 {
 886         int i;
 887
 888         for (i = 0; i < stream->urbs_submitted; i++) {
 889                 deb_info(3, "killing URB no. %d.", i);
 890                 /* stop the URB */
 891                 usb_kill_urb(stream->urb_list[i]);
 892         }
 893         stream->urbs_submitted = 0;
 894
 895         return 0;
 896 }
 897
 898 static struct tda10086_config tda10086_config = {
 899         .demod_address = 0x0e,
 900         .invert = 0,
 901         .diseqc_tone = 1,
 902         .xtal_freq = TDA10086_XTAL_16M,
 903 };
 904
 905 static struct stv0288_config lme_config = {
 906         .demod_address = 0x68,
 907         .min_delay_ms = 15,
 908         .inittab = s7395_inittab,
 909 };
 910
 911 static struct ix2505v_config lme_tuner = {
 912         .tuner_address = 0x60,
 913         .min_delay_ms = 100,
 914         .tuner_gain = 0x0,
 915         .tuner_chargepump = 0x3,
 916 };
 917
 918 static struct stv0299_config sharp_z0194_config = {
 919         .demod_address = 0x68,
 920         .inittab = sharp_z0194a_inittab,
 921         .mclk = 88000000UL,
 922         .invert = 0,
 923         .skip_reinit = 0,
 924         .lock_output = STV0299_LOCKOUTPUT_1,
 925         .volt13_op0_op1 = STV0299_VOLT13_OP1,
 926         .min_delay_ms = 100,
 927         .set_symbol_rate = sharp_z0194a_set_symbol_rate,
 928 };
 929
 930 static int dm04_rs2000_set_ts_param(struct dvb_frontend *fe,
 931         int caller)
 932 {
 933         struct dvb_usb_adapter *adap = fe_to_adap(fe);
 934         struct dvb_usb_device *d = adap_to_d(adap);
 935         struct lme2510_state *st = d->priv;
 936
 937         mutex_lock(&d->i2c_mutex);
 938         if ((st->i2c_talk_onoff == 1) && (st->stream_on & 1)) {
 939                 st->i2c_talk_onoff = 0;
 940                 lme2510_stream_restart(d);
 941         }
 942         mutex_unlock(&d->i2c_mutex);
 943
 944         return 0;
 945 }
 946
 947 static struct m88rs2000_config m88rs2000_config = {
 948         .demod_addr = 0x68,
 949         .set_ts_params = dm04_rs2000_set_ts_param,
 950 };
 951
 952 static struct ts2020_config ts2020_config = {
 953         .tuner_address = 0x60,
 954         .clk_out_div = 7,
 955 };
 956
 957 static int dm04_lme2510_set_voltage(struct dvb_frontend *fe,
 958                                         fe_sec_voltage_t voltage)
 959 {
 960         struct dvb_usb_device *d = fe_to_d(fe);
 961         struct lme2510_state *st = fe_to_priv(fe);
 962         static u8 voltage_low[] = LME_VOLTAGE_L;
 963         static u8 voltage_high[] = LME_VOLTAGE_H;
 964         static u8 rbuf[1];
 965         int ret = 0, len = 3, rlen = 1;
 966
 967         mutex_lock(&d->i2c_mutex);
 968
 969         switch (voltage) {
 970         case SEC_VOLTAGE_18:
 971                 ret |= lme2510_usb_talk(d,
 972                         voltage_high, len, rbuf, rlen);
 973                 break;
 974
 975         case SEC_VOLTAGE_OFF:
 976         case SEC_VOLTAGE_13:
 977         default:
 978                 ret |= lme2510_usb_talk(d,
 979                                 voltage_low, len, rbuf, rlen);
 980                 break;
 981         }
 982
 983         mutex_unlock(&d->i2c_mutex);
 984
 985         if (st->tuner_config == TUNER_RS2000)
 986                 if (st->fe_set_voltage)
 987                         st->fe_set_voltage(fe, voltage);
 988
 989
 990         return (ret < 0) ? -ENODEV : 0;
 991 }
 992
 993 static int dm04_rs2000_read_signal_strength(struct dvb_frontend *fe,
 994         u16 *strength)
 995 {
 996         struct lme2510_state *st = fe_to_priv(fe);
 997
 998         *strength = (u16)((u32)st->signal_level * 0xffff / 0xff);
 999
1000         return 0;
1001 }
1002
1003 static int dm04_rs2000_read_snr(struct dvb_frontend *fe, u16 *snr)
1004 {
1005         struct lme2510_state *st = fe_to_priv(fe);
1006
1007         *snr = (u16)((u32)st->signal_sn * 0xffff / 0x7f);
1008
1009         return 0;
1010 }
1011
1012 static int dm04_read_ber(struct dvb_frontend *fe, u32 *ber)
1013 {
1014         *ber = 0;
1015
1016         return 0;
1017 }
1018
1019 static int dm04_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
1020 {
1021         *ucblocks = 0;
1022
1023         return 0;
1024 }
1025
1026 static int lme_name(struct dvb_usb_adapter *adap)
1027 {
1028         struct dvb_usb_device *d = adap_to_d(adap);
1029         struct lme2510_state *st = adap_to_priv(adap);
1030         const char *desc = d->name;
1031         char *fe_name[] = {"", " LG TDQY-P001F", " SHARP:BS2F7HZ7395",
1032                                 " SHARP:BS2F7HZ0194", " RS2000"};
1033         char *name = adap->fe[0]->ops.info.name;
1034
1035         strlcpy(name, desc, 128);
1036         strlcat(name, fe_name[st->tuner_config], 128);
1037
1038         return 0;
1039 }
1040
1041 static int dm04_lme2510_frontend_attach(struct dvb_usb_adapter *adap)
1042 {
1043         struct dvb_usb_device *d = adap_to_d(adap);
1044         struct lme2510_state *st = d->priv;
1045         int ret = 0;
1046
1047         st->i2c_talk_onoff = 1;
1048         switch (le16_to_cpu(d->udev->descriptor.idProduct)) {
1049         case 0x1122:
1050         case 0x1120:
1051                 st->i2c_gate = 4;
1052                 adap->fe[0] = dvb_attach(tda10086_attach,
1053                         &tda10086_config, &d->i2c_adap);
1054                 if (adap->fe[0]) {
1055                         info("TUN Found Frontend TDA10086");
1056                         st->i2c_tuner_gate_w = 4;
1057                         st->i2c_tuner_gate_r = 4;
1058                         st->i2c_tuner_addr = 0x60;
1059                         st->tuner_config = TUNER_LG;
1060                         if (st->dvb_usb_lme2510_firmware != TUNER_LG) {
1061                                 st->dvb_usb_lme2510_firmware = TUNER_LG;
1062                                 ret = lme_firmware_switch(d, 1) ? 0 : -ENODEV;
1063                         }
1064                         break;
1065                 }
1066
1067                 st->i2c_gate = 4;
1068                 adap->fe[0] = dvb_attach(stv0299_attach,
1069                                 &sharp_z0194_config, &d->i2c_adap);
1070                 if (adap->fe[0]) {
1071                         info("FE Found Stv0299");
1072                         st->i2c_tuner_gate_w = 4;
1073                         st->i2c_tuner_gate_r = 5;
1074                         st->i2c_tuner_addr = 0x60;
1075                         st->tuner_config = TUNER_S0194;
1076                         if (st->dvb_usb_lme2510_firmware != TUNER_S0194) {
1077                                 st->dvb_usb_lme2510_firmware = TUNER_S0194;
1078                                 ret = lme_firmware_switch(d, 1) ? 0 : -ENODEV;
1079                         }
1080                         break;
1081                 }
1082
1083                 st->i2c_gate = 5;
1084                 adap->fe[0] = dvb_attach(stv0288_attach, &lme_config,
1085                         &d->i2c_adap);
1086
1087                 if (adap->fe[0]) {
1088                         info("FE Found Stv0288");
1089                         st->i2c_tuner_gate_w = 4;
1090                         st->i2c_tuner_gate_r = 5;
1091                         st->i2c_tuner_addr = 0x60;
1092                         st->tuner_config = TUNER_S7395;
1093                         if (st->dvb_usb_lme2510_firmware != TUNER_S7395) {
1094                                 st->dvb_usb_lme2510_firmware = TUNER_S7395;
1095                                 ret = lme_firmware_switch(d, 1) ? 0 : -ENODEV;
1096                         }
1097                         break;
1098                 }
1099         case 0x22f0:
1100                 st->i2c_gate = 5;
1101                 adap->fe[0] = dvb_attach(m88rs2000_attach,
1102                         &m88rs2000_config, &d->i2c_adap);
1103
1104                 if (adap->fe[0]) {
1105                         info("FE Found M88RS2000");
1106                         dvb_attach(ts2020_attach, adap->fe[0], &ts2020_config,
1107                                         &d->i2c_adap);
1108                         st->i2c_tuner_gate_w = 5;
1109                         st->i2c_tuner_gate_r = 5;
1110                         st->i2c_tuner_addr = 0x60;
1111                         st->tuner_config = TUNER_RS2000;
1112                         st->fe_set_voltage =
1113                                 adap->fe[0]->ops.set_voltage;
1114
1115                         adap->fe[0]->ops.read_signal_strength =
1116                                 dm04_rs2000_read_signal_strength;
1117                         adap->fe[0]->ops.read_snr =
1118                                 dm04_rs2000_read_snr;
1119                         adap->fe[0]->ops.read_ber =
1120                                 dm04_read_ber;
1121                         adap->fe[0]->ops.read_ucblocks =
1122                                 dm04_read_ucblocks;
1123                 }
1124                 break;
1125         }
1126
1127         if (adap->fe[0] == NULL) {
1128                 info("DM04/QQBOX Not Powered up or not Supported");
1129                 return -ENODEV;
1130         }
1131
1132         if (ret) {
1133                 if (adap->fe[0]) {
1134                         dvb_frontend_detach(adap->fe[0]);
1135                         adap->fe[0] = NULL;
1136                 }
1137                 d->rc_map = NULL;
1138                 return -ENODEV;
1139         }
1140
1141         adap->fe[0]->ops.set_voltage = dm04_lme2510_set_voltage;
1142         ret = lme_name(adap);
1143         return ret;
1144 }
1145
1146 static int dm04_lme2510_tuner(struct dvb_usb_adapter *adap)
1147 {
1148         struct dvb_usb_device *d = adap_to_d(adap);
1149         struct lme2510_state *st = adap_to_priv(adap);
1150         char *tun_msg[] = {"", "TDA8263", "IX2505V", "DVB_PLL_OPERA", "RS2000"};
1151         int ret = 0;
1152
1153         switch (st->tuner_config) {
1154         case TUNER_LG:
1155                 if (dvb_attach(tda826x_attach, adap->fe[0], 0x60,
1156                         &d->i2c_adap, 1))
1157                         ret = st->tuner_config;
1158                 break;
1159         case TUNER_S7395:
1160                 if (dvb_attach(ix2505v_attach , adap->fe[0], &lme_tuner,
1161                         &d->i2c_adap))
1162                         ret = st->tuner_config;
1163                 break;
1164         case TUNER_S0194:
1165                 if (dvb_attach(dvb_pll_attach , adap->fe[0], 0x60,
1166                         &d->i2c_adap, DVB_PLL_OPERA1))
1167                         ret = st->tuner_config;
1168                 break;
1169         case TUNER_RS2000:
1170                 ret = st->tuner_config;
1171                 break;
1172         default:
1173                 break;
1174         }
1175
1176         if (ret)
1177                 info("TUN Found %s tuner", tun_msg[ret]);
1178         else {
1179                 info("TUN No tuner found --- resetting device");
1180                 lme_coldreset(d);
1181                 return -ENODEV;
1182         }
1183
1184         /* Start the Interrupt*/
1185         ret = lme2510_int_read(adap);
1186         if (ret < 0) {
1187                 info("INT Unable to start Interrupt Service");
1188                 return -ENODEV;
1189         }
1190
1191         return ret;
1192 }
1193
1194 static int lme2510_powerup(struct dvb_usb_device *d, int onoff)
1195 {
1196         struct lme2510_state *st = d->priv;
1197         static u8 lnb_on[] = LNB_ON;
1198         static u8 lnb_off[] = LNB_OFF;
1199         static u8 rbuf[1];
1200         int ret = 0, len = 3, rlen = 1;
1201
1202         mutex_lock(&d->i2c_mutex);
1203
1204         if (onoff)
1205                 ret = lme2510_usb_talk(d, lnb_on, len, rbuf, rlen);
1206         else
1207                 ret = lme2510_usb_talk(d, lnb_off, len, rbuf, rlen);
1208
1209         st->i2c_talk_onoff = 1;
1210
1211         mutex_unlock(&d->i2c_mutex);
1212
1213         return ret;
1214 }
1215
1216 static int lme2510_get_adapter_count(struct dvb_usb_device *d)
1217 {
1218         return 1;
1219 }
1220
1221 static int lme2510_identify_state(struct dvb_usb_device *d, const char **name)
1222 {
1223         struct lme2510_state *st = d->priv;
1224
1225         usb_reset_configuration(d->udev);
1226
1227         usb_set_interface(d->udev,
1228                 d->props->bInterfaceNumber, 1);
1229
1230         st->dvb_usb_lme2510_firmware = dvb_usb_lme2510_firmware;
1231
1232         if (lme2510_return_status(d) == 0x44) {
1233                 *name = lme_firmware_switch(d, 0);
1234                 return COLD;
1235         }
1236
1237         return 0;
1238 }
1239
1240 static int lme2510_get_stream_config(struct dvb_frontend *fe, u8 *ts_type,
1241                 struct usb_data_stream_properties *stream)
1242 {
1243         struct dvb_usb_adapter *adap = fe_to_adap(fe);
1244         struct dvb_usb_device *d;
1245
1246         if (adap == NULL)
1247                 return 0;
1248
1249         d = adap_to_d(adap);
1250
1251         /* Turn PID filter on the fly by module option */
1252         if (pid_filter == 2) {
1253                 adap->pid_filtering  = 1;
1254                 adap->max_feed_count = 15;
1255         }
1256
1257         if (!(le16_to_cpu(d->udev->descriptor.idProduct)
1258                 == 0x1122))
1259                 stream->endpoint = 0x8;
1260
1261         return 0;
1262 }
1263
1264 static int lme2510_get_rc_config(struct dvb_usb_device *d,
1265         struct dvb_usb_rc *rc)
1266 {
1267         rc->allowed_protos = RC_BIT_NEC;
1268         return 0;
1269 }
1270
1271 static void *lme2510_exit_int(struct dvb_usb_device *d)
1272 {
1273         struct lme2510_state *st = d->priv;
1274         struct dvb_usb_adapter *adap = &d->adapter[0];
1275         void *buffer = NULL;
1276
1277         if (adap != NULL) {
1278                 lme2510_kill_urb(&adap->stream);
1279         }
1280
1281         if (st->usb_buffer != NULL) {
1282                 st->i2c_talk_onoff = 1;
1283                 st->signal_lock = 0;
1284                 st->signal_level = 0;
1285                 st->signal_sn = 0;
1286                 buffer = st->usb_buffer;
1287         }
1288
1289         if (st->lme_urb != NULL) {
1290                 usb_kill_urb(st->lme_urb);
1291                 usb_free_coherent(d->udev, 128, st->buffer,
1292                                   st->lme_urb->transfer_dma);
1293                 info("Interrupt Service Stopped");
1294         }
1295
1296         return buffer;
1297 }
1298
1299 static void lme2510_exit(struct dvb_usb_device *d)
1300 {
1301         void *usb_buffer;
1302
1303         if (d != NULL) {
1304                 usb_buffer = lme2510_exit_int(d);
1305                 kfree(usb_buffer);
1306         }
1307 }
1308
1309 static struct dvb_usb_device_properties lme2510_props = {
1310         .driver_name = KBUILD_MODNAME,
1311         .owner = THIS_MODULE,
1312         .bInterfaceNumber = 0,
1313         .adapter_nr = adapter_nr,
1314         .size_of_priv = sizeof(struct lme2510_state),
1315
1316         .download_firmware = lme2510_download_firmware,
1317
1318         .power_ctrl       = lme2510_powerup,
1319         .identify_state   = lme2510_identify_state,
1320         .i2c_algo         = &lme2510_i2c_algo,
1321
1322         .frontend_attach  = dm04_lme2510_frontend_attach,
1323         .tuner_attach = dm04_lme2510_tuner,
1324         .get_stream_config = lme2510_get_stream_config,
1325         .get_adapter_count = lme2510_get_adapter_count,
1326         .streaming_ctrl   = lme2510_streaming_ctrl,
1327
1328         .get_rc_config = lme2510_get_rc_config,
1329
1330         .exit = lme2510_exit,
1331         .adapter = {
1332                 {
1333                         .caps = DVB_USB_ADAP_HAS_PID_FILTER|
1334                                 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1335                         .pid_filter_count = 15,
1336                         .pid_filter = lme2510_pid_filter,
1337                         .pid_filter_ctrl  = lme2510_pid_filter_ctrl,
1338                         .stream =
1339                         DVB_USB_STREAM_BULK(0x86, 10, 4096),
1340                 },
1341                 {
1342                 }
1343         },
1344 };
1345
1346 static const struct usb_device_id lme2510_id_table[] = {
1347         {       DVB_USB_DEVICE(0x3344, 0x1122, &lme2510_props,
1348                 "DM04_LME2510_DVB-S", RC_MAP_LME2510)   },
1349         {       DVB_USB_DEVICE(0x3344, 0x1120, &lme2510_props,
1350                 "DM04_LME2510C_DVB-S", RC_MAP_LME2510)  },
1351         {       DVB_USB_DEVICE(0x3344, 0x22f0, &lme2510_props,
1352                 "DM04_LME2510C_DVB-S RS2000", RC_MAP_LME2510)   },
1353         {}              /* Terminating entry */
1354 };
1355
1356 MODULE_DEVICE_TABLE(usb, lme2510_id_table);
1357
1358 static struct usb_driver lme2510_driver = {
1359         .name           = KBUILD_MODNAME,
1360         .probe          = dvb_usbv2_probe,
1361         .disconnect     = dvb_usbv2_disconnect,
1362         .id_table       = lme2510_id_table,
1363         .no_dynamic_id = 1,
1364         .soft_unbind = 1,
1365 };
1366
1367 module_usb_driver(lme2510_driver);
1368
1369 MODULE_AUTHOR("Malcolm Priestley <tvboxspy@gmail.com>");
1370 MODULE_DESCRIPTION("LME2510(C) DVB-S USB2.0");
1371 MODULE_VERSION("2.06");
1372 MODULE_LICENSE("GPL");
1373 MODULE_FIRMWARE(LME2510_C_S7395);
1374 MODULE_FIRMWARE(LME2510_C_LG);
1375 MODULE_FIRMWARE(LME2510_C_S0194);
1376 MODULE_FIRMWARE(LME2510_C_RS2000);
1377 MODULE_FIRMWARE(LME2510_LG);
1378 MODULE_FIRMWARE(LME2510_S0194);
1379