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 1380