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