1 /* 2 * TTUSB DVB driver 3 * 4 * Copyright (c) 2002 Holger Waechtler <holger@convergence.de> 5 * Copyright (c) 2003 Felix Domke <tmbinc@elitedvb.net> 6 * 7 * This program is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License as 9 * published by the Free Software Foundation; either version 2 of 10 * the License, or (at your option) any later version. 11 */ 12 #include <linux/init.h> 13 #include <linux/slab.h> 14 #include <linux/wait.h> 15 #include <linux/fs.h> 16 #include <linux/module.h> 17 #include <linux/usb.h> 18 #include <linux/delay.h> 19 #include <linux/time.h> 20 #include <linux/errno.h> 21 #include <linux/jiffies.h> 22 #include <linux/mutex.h> 23 #include <linux/firmware.h> 24 25 #include "dvb_frontend.h" 26 #include "dmxdev.h" 27 #include "dvb_demux.h" 28 #include "dvb_net.h" 29 #include "ves1820.h" 30 #include "cx22700.h" 31 #include "tda1004x.h" 32 #include "stv0299.h" 33 #include "tda8083.h" 34 #include "stv0297.h" 35 #include "lnbp21.h" 36 37 #include <linux/dvb/frontend.h> 38 #include <linux/dvb/dmx.h> 39 #include <linux/pci.h> 40 41 /* 42 TTUSB_HWSECTIONS: 43 the DSP supports filtering in hardware, however, since the "muxstream" 44 is a bit braindead (no matching channel masks or no matching filter mask), 45 we won't support this - yet. it doesn't event support negative filters, 46 so the best way is maybe to keep TTUSB_HWSECTIONS undef'd and just 47 parse TS data. USB bandwidth will be a problem when having large 48 datastreams, especially for dvb-net, but hey, that's not my problem. 49 50 TTUSB_DISEQC, TTUSB_TONE: 51 let the STC do the diseqc/tone stuff. this isn't supported at least with 52 my TTUSB, so let it undef'd unless you want to implement another 53 frontend. never tested. 54 55 debug: 56 define it to > 3 for really hardcore debugging. you probably don't want 57 this unless the device doesn't load at all. > 2 for bandwidth statistics. 58 */ 59 60 static int debug; 61 module_param(debug, int, 0644); 62 MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off)."); 63 64 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); 65 66 #define dprintk(x...) do { if (debug) printk(KERN_DEBUG x); } while (0) 67 68 #define ISO_BUF_COUNT 4 69 #define FRAMES_PER_ISO_BUF 4 70 #define ISO_FRAME_SIZE 912 71 #define TTUSB_MAXCHANNEL 32 72 #ifdef TTUSB_HWSECTIONS 73 #define TTUSB_MAXFILTER 16 /* ??? */ 74 #endif 75 76 #define TTUSB_REV_2_2 0x22 77 #define TTUSB_BUDGET_NAME "ttusb_stc_fw" 78 79 /** 80 * since we're casting (struct ttusb*) <-> (struct dvb_demux*) around 81 * the dvb_demux field must be the first in struct!! 82 */ 83 struct ttusb { 84 struct dvb_demux dvb_demux; 85 struct dmxdev dmxdev; 86 struct dvb_net dvbnet; 87 88 /* and one for USB access. */ 89 struct mutex semi2c; 90 struct mutex semusb; 91 92 struct dvb_adapter adapter; 93 struct usb_device *dev; 94 95 struct i2c_adapter i2c_adap; 96 97 int disconnecting; 98 int iso_streaming; 99 100 unsigned int bulk_out_pipe; 101 unsigned int bulk_in_pipe; 102 unsigned int isoc_in_pipe; 103 104 void *iso_buffer; 105 dma_addr_t iso_dma_handle; 106 107 struct urb *iso_urb[ISO_BUF_COUNT]; 108 109 int running_feed_count; 110 int last_channel; 111 int last_filter; 112 113 u8 c; /* transaction counter, wraps around... */ 114 enum fe_sec_tone_mode tone; 115 enum fe_sec_voltage voltage; 116 117 int mux_state; // 0..2 - MuxSyncWord, 3 - nMuxPacks, 4 - muxpack 118 u8 mux_npacks; 119 u8 muxpack[256 + 8]; 120 int muxpack_ptr, muxpack_len; 121 122 int insync; 123 124 int cc; /* MuxCounter - will increment on EVERY MUX PACKET */ 125 /* (including stuffing. yes. really.) */ 126 127 u8 last_result[32]; 128 129 int revision; 130 131 struct dvb_frontend* fe; 132 }; 133 134 /* ugly workaround ... don't know why it's necessary to read */ 135 /* all result codes. */ 136 137 static int ttusb_cmd(struct ttusb *ttusb, 138 const u8 * data, int len, int needresult) 139 { 140 int actual_len; 141 int err; 142 int i; 143 144 if (debug >= 3) { 145 printk(KERN_DEBUG ">"); 146 for (i = 0; i < len; ++i) 147 printk(KERN_CONT " %02x", data[i]); 148 printk(KERN_CONT "\n"); 149 } 150 151 if (mutex_lock_interruptible(&ttusb->semusb) < 0) 152 return -EAGAIN; 153 154 err = usb_bulk_msg(ttusb->dev, ttusb->bulk_out_pipe, 155 (u8 *) data, len, &actual_len, 1000); 156 if (err != 0) { 157 dprintk("%s: usb_bulk_msg(send) failed, err == %i!\n", 158 __func__, err); 159 mutex_unlock(&ttusb->semusb); 160 return err; 161 } 162 if (actual_len != len) { 163 dprintk("%s: only wrote %d of %d bytes\n", __func__, 164 actual_len, len); 165 mutex_unlock(&ttusb->semusb); 166 return -1; 167 } 168 169 err = usb_bulk_msg(ttusb->dev, ttusb->bulk_in_pipe, 170 ttusb->last_result, 32, &actual_len, 1000); 171 172 if (err != 0) { 173 printk("%s: failed, receive error %d\n", __func__, 174 err); 175 mutex_unlock(&ttusb->semusb); 176 return err; 177 } 178 179 if (debug >= 3) { 180 actual_len = ttusb->last_result[3] + 4; 181 printk(KERN_DEBUG "<"); 182 for (i = 0; i < actual_len; ++i) 183 printk(KERN_CONT " %02x", ttusb->last_result[i]); 184 printk(KERN_CONT "\n"); 185 } 186 187 if (!needresult) 188 mutex_unlock(&ttusb->semusb); 189 return 0; 190 } 191 192 static int ttusb_result(struct ttusb *ttusb, u8 * data, int len) 193 { 194 memcpy(data, ttusb->last_result, len); 195 mutex_unlock(&ttusb->semusb); 196 return 0; 197 } 198 199 static int ttusb_i2c_msg(struct ttusb *ttusb, 200 u8 addr, u8 * snd_buf, u8 snd_len, u8 * rcv_buf, 201 u8 rcv_len) 202 { 203 u8 b[0x28]; 204 u8 id = ++ttusb->c; 205 int i, err; 206 207 if (snd_len > 0x28 - 7 || rcv_len > 0x20 - 7) 208 return -EINVAL; 209 210 b[0] = 0xaa; 211 b[1] = id; 212 b[2] = 0x31; 213 b[3] = snd_len + 3; 214 b[4] = addr << 1; 215 b[5] = snd_len; 216 b[6] = rcv_len; 217 218 for (i = 0; i < snd_len; i++) 219 b[7 + i] = snd_buf[i]; 220 221 err = ttusb_cmd(ttusb, b, snd_len + 7, 1); 222 223 if (err) 224 return -EREMOTEIO; 225 226 err = ttusb_result(ttusb, b, 0x20); 227 228 /* check if the i2c transaction was successful */ 229 if ((snd_len != b[5]) || (rcv_len != b[6])) return -EREMOTEIO; 230 231 if (rcv_len > 0) { 232 233 if (err || b[0] != 0x55 || b[1] != id) { 234 dprintk 235 ("%s: usb_bulk_msg(recv) failed, err == %i, id == %02x, b == ", 236 __func__, err, id); 237 return -EREMOTEIO; 238 } 239 240 for (i = 0; i < rcv_len; i++) 241 rcv_buf[i] = b[7 + i]; 242 } 243 244 return rcv_len; 245 } 246 247 static int master_xfer(struct i2c_adapter* adapter, struct i2c_msg *msg, int num) 248 { 249 struct ttusb *ttusb = i2c_get_adapdata(adapter); 250 int i = 0; 251 int inc; 252 253 if (mutex_lock_interruptible(&ttusb->semi2c) < 0) 254 return -EAGAIN; 255 256 while (i < num) { 257 u8 addr, snd_len, rcv_len, *snd_buf, *rcv_buf; 258 int err; 259 260 if (num > i + 1 && (msg[i + 1].flags & I2C_M_RD)) { 261 addr = msg[i].addr; 262 snd_buf = msg[i].buf; 263 snd_len = msg[i].len; 264 rcv_buf = msg[i + 1].buf; 265 rcv_len = msg[i + 1].len; 266 inc = 2; 267 } else { 268 addr = msg[i].addr; 269 snd_buf = msg[i].buf; 270 snd_len = msg[i].len; 271 rcv_buf = NULL; 272 rcv_len = 0; 273 inc = 1; 274 } 275 276 err = ttusb_i2c_msg(ttusb, addr, 277 snd_buf, snd_len, rcv_buf, rcv_len); 278 279 if (err < rcv_len) { 280 dprintk("%s: i == %i\n", __func__, i); 281 break; 282 } 283 284 i += inc; 285 } 286 287 mutex_unlock(&ttusb->semi2c); 288 return i; 289 } 290 291 static int ttusb_boot_dsp(struct ttusb *ttusb) 292 { 293 const struct firmware *fw; 294 int i, err; 295 u8 b[40]; 296 297 err = request_firmware(&fw, "ttusb-budget/dspbootcode.bin", 298 &ttusb->dev->dev); 299 if (err) { 300 printk(KERN_ERR "ttusb-budget: failed to request firmware\n"); 301 return err; 302 } 303 304 /* BootBlock */ 305 b[0] = 0xaa; 306 b[2] = 0x13; 307 b[3] = 28; 308 309 /* upload dsp code in 32 byte steps (36 didn't work for me ...) */ 310 /* 32 is max packet size, no messages should be splitted. */ 311 for (i = 0; i < fw->size; i += 28) { 312 memcpy(&b[4], &fw->data[i], 28); 313 314 b[1] = ++ttusb->c; 315 316 err = ttusb_cmd(ttusb, b, 32, 0); 317 if (err) 318 goto done; 319 } 320 321 /* last block ... */ 322 b[1] = ++ttusb->c; 323 b[2] = 0x13; 324 b[3] = 0; 325 326 err = ttusb_cmd(ttusb, b, 4, 0); 327 if (err) 328 goto done; 329 330 /* BootEnd */ 331 b[1] = ++ttusb->c; 332 b[2] = 0x14; 333 b[3] = 0; 334 335 err = ttusb_cmd(ttusb, b, 4, 0); 336 337 done: 338 release_firmware(fw); 339 if (err) { 340 dprintk("%s: usb_bulk_msg() failed, return value %i!\n", 341 __func__, err); 342 } 343 344 return err; 345 } 346 347 static int ttusb_set_channel(struct ttusb *ttusb, int chan_id, int filter_type, 348 int pid) 349 { 350 int err; 351 /* SetChannel */ 352 u8 b[] = { 0xaa, ++ttusb->c, 0x22, 4, chan_id, filter_type, 353 (pid >> 8) & 0xff, pid & 0xff 354 }; 355 356 err = ttusb_cmd(ttusb, b, sizeof(b), 0); 357 return err; 358 } 359 360 static int ttusb_del_channel(struct ttusb *ttusb, int channel_id) 361 { 362 int err; 363 /* DelChannel */ 364 u8 b[] = { 0xaa, ++ttusb->c, 0x23, 1, channel_id }; 365 366 err = ttusb_cmd(ttusb, b, sizeof(b), 0); 367 return err; 368 } 369 370 #ifdef TTUSB_HWSECTIONS 371 static int ttusb_set_filter(struct ttusb *ttusb, int filter_id, 372 int associated_chan, u8 filter[8], u8 mask[8]) 373 { 374 int err; 375 /* SetFilter */ 376 u8 b[] = { 0xaa, 0, 0x24, 0x1a, filter_id, associated_chan, 377 filter[0], filter[1], filter[2], filter[3], 378 filter[4], filter[5], filter[6], filter[7], 379 filter[8], filter[9], filter[10], filter[11], 380 mask[0], mask[1], mask[2], mask[3], 381 mask[4], mask[5], mask[6], mask[7], 382 mask[8], mask[9], mask[10], mask[11] 383 }; 384 385 err = ttusb_cmd(ttusb, b, sizeof(b), 0); 386 return err; 387 } 388 389 static int ttusb_del_filter(struct ttusb *ttusb, int filter_id) 390 { 391 int err; 392 /* DelFilter */ 393 u8 b[] = { 0xaa, ++ttusb->c, 0x25, 1, filter_id }; 394 395 err = ttusb_cmd(ttusb, b, sizeof(b), 0); 396 return err; 397 } 398 #endif 399 400 static int ttusb_init_controller(struct ttusb *ttusb) 401 { 402 u8 b0[] = { 0xaa, ++ttusb->c, 0x15, 1, 0 }; 403 u8 b1[] = { 0xaa, ++ttusb->c, 0x15, 1, 1 }; 404 u8 b2[] = { 0xaa, ++ttusb->c, 0x32, 1, 0 }; 405 /* i2c write read: 5 bytes, addr 0x10, 0x02 bytes write, 1 bytes read. */ 406 u8 b3[] = 407 { 0xaa, ++ttusb->c, 0x31, 5, 0x10, 0x02, 0x01, 0x00, 0x1e }; 408 u8 b4[] = 409 { 0x55, ttusb->c, 0x31, 4, 0x10, 0x02, 0x01, 0x00, 0x1e }; 410 411 u8 get_version[] = { 0xaa, ++ttusb->c, 0x17, 5, 0, 0, 0, 0, 0 }; 412 u8 get_dsp_version[0x20] = 413 { 0xaa, ++ttusb->c, 0x26, 28, 0, 0, 0, 0, 0 }; 414 int err; 415 416 /* reset board */ 417 if ((err = ttusb_cmd(ttusb, b0, sizeof(b0), 0))) 418 return err; 419 420 /* reset board (again?) */ 421 if ((err = ttusb_cmd(ttusb, b1, sizeof(b1), 0))) 422 return err; 423 424 ttusb_boot_dsp(ttusb); 425 426 /* set i2c bit rate */ 427 if ((err = ttusb_cmd(ttusb, b2, sizeof(b2), 0))) 428 return err; 429 430 if ((err = ttusb_cmd(ttusb, b3, sizeof(b3), 1))) 431 return err; 432 433 err = ttusb_result(ttusb, b4, sizeof(b4)); 434 435 if ((err = ttusb_cmd(ttusb, get_version, sizeof(get_version), 1))) 436 return err; 437 438 if ((err = ttusb_result(ttusb, get_version, sizeof(get_version)))) 439 return err; 440 441 dprintk("%s: stc-version: %c%c%c%c%c\n", __func__, 442 get_version[4], get_version[5], get_version[6], 443 get_version[7], get_version[8]); 444 445 if (memcmp(get_version + 4, "V 0.0", 5) && 446 memcmp(get_version + 4, "V 1.1", 5) && 447 memcmp(get_version + 4, "V 2.1", 5) && 448 memcmp(get_version + 4, "V 2.2", 5)) { 449 printk 450 ("%s: unknown STC version %c%c%c%c%c, please report!\n", 451 __func__, get_version[4], get_version[5], 452 get_version[6], get_version[7], get_version[8]); 453 } 454 455 ttusb->revision = ((get_version[6] - '0') << 4) | 456 (get_version[8] - '0'); 457 458 err = 459 ttusb_cmd(ttusb, get_dsp_version, sizeof(get_dsp_version), 1); 460 if (err) 461 return err; 462 463 err = 464 ttusb_result(ttusb, get_dsp_version, sizeof(get_dsp_version)); 465 if (err) 466 return err; 467 printk("%s: dsp-version: %c%c%c\n", __func__, 468 get_dsp_version[4], get_dsp_version[5], get_dsp_version[6]); 469 return 0; 470 } 471 472 #ifdef TTUSB_DISEQC 473 static int ttusb_send_diseqc(struct dvb_frontend* fe, 474 const struct dvb_diseqc_master_cmd *cmd) 475 { 476 struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv; 477 u8 b[12] = { 0xaa, ++ttusb->c, 0x18 }; 478 479 int err; 480 481 b[3] = 4 + 2 + cmd->msg_len; 482 b[4] = 0xFF; /* send diseqc master, not burst */ 483 b[5] = cmd->msg_len; 484 485 memcpy(b + 5, cmd->msg, cmd->msg_len); 486 487 /* Diseqc */ 488 if ((err = ttusb_cmd(ttusb, b, 4 + b[3], 0))) { 489 dprintk("%s: usb_bulk_msg() failed, return value %i!\n", 490 __func__, err); 491 } 492 493 return err; 494 } 495 #endif 496 497 static int ttusb_update_lnb(struct ttusb *ttusb) 498 { 499 u8 b[] = { 0xaa, ++ttusb->c, 0x16, 5, /*power: */ 1, 500 ttusb->voltage == SEC_VOLTAGE_18 ? 0 : 1, 501 ttusb->tone == SEC_TONE_ON ? 1 : 0, 1, 1 502 }; 503 int err; 504 505 /* SetLNB */ 506 if ((err = ttusb_cmd(ttusb, b, sizeof(b), 0))) { 507 dprintk("%s: usb_bulk_msg() failed, return value %i!\n", 508 __func__, err); 509 } 510 511 return err; 512 } 513 514 static int ttusb_set_voltage(struct dvb_frontend *fe, 515 enum fe_sec_voltage voltage) 516 { 517 struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv; 518 519 ttusb->voltage = voltage; 520 return ttusb_update_lnb(ttusb); 521 } 522 523 #ifdef TTUSB_TONE 524 static int ttusb_set_tone(struct dvb_frontend *fe, enum fe_sec_tone_mode tone) 525 { 526 struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv; 527 528 ttusb->tone = tone; 529 return ttusb_update_lnb(ttusb); 530 } 531 #endif 532 533 534 #if 0 535 static void ttusb_set_led_freq(struct ttusb *ttusb, u8 freq) 536 { 537 u8 b[] = { 0xaa, ++ttusb->c, 0x19, 1, freq }; 538 int err, actual_len; 539 540 err = ttusb_cmd(ttusb, b, sizeof(b), 0); 541 if (err) { 542 dprintk("%s: usb_bulk_msg() failed, return value %i!\n", 543 __func__, err); 544 } 545 } 546 #endif 547 548 /*****************************************************************************/ 549 550 #ifdef TTUSB_HWSECTIONS 551 static void ttusb_handle_ts_data(struct ttusb_channel *channel, 552 const u8 * data, int len); 553 static void ttusb_handle_sec_data(struct ttusb_channel *channel, 554 const u8 * data, int len); 555 #endif 556 557 static int numpkt, numts, numstuff, numsec, numinvalid; 558 static unsigned long lastj; 559 560 static void ttusb_process_muxpack(struct ttusb *ttusb, const u8 * muxpack, 561 int len) 562 { 563 u16 csum = 0, cc; 564 int i; 565 566 if (len < 4 || len & 0x1) { 567 pr_warn("%s: muxpack has invalid len %d\n", __func__, len); 568 numinvalid++; 569 return; 570 } 571 572 for (i = 0; i < len; i += 2) 573 csum ^= le16_to_cpup((__le16 *) (muxpack + i)); 574 if (csum) { 575 printk("%s: muxpack with incorrect checksum, ignoring\n", 576 __func__); 577 numinvalid++; 578 return; 579 } 580 581 cc = (muxpack[len - 4] << 8) | muxpack[len - 3]; 582 cc &= 0x7FFF; 583 if ((cc != ttusb->cc) && (ttusb->cc != -1)) 584 printk("%s: cc discontinuity (%d frames missing)\n", 585 __func__, (cc - ttusb->cc) & 0x7FFF); 586 ttusb->cc = (cc + 1) & 0x7FFF; 587 if (muxpack[0] & 0x80) { 588 #ifdef TTUSB_HWSECTIONS 589 /* section data */ 590 int pusi = muxpack[0] & 0x40; 591 int channel = muxpack[0] & 0x1F; 592 int payload = muxpack[1]; 593 const u8 *data = muxpack + 2; 594 /* check offset flag */ 595 if (muxpack[0] & 0x20) 596 data++; 597 598 ttusb_handle_sec_data(ttusb->channel + channel, data, 599 payload); 600 data += payload; 601 602 if ((!!(ttusb->muxpack[0] & 0x20)) ^ 603 !!(ttusb->muxpack[1] & 1)) 604 data++; 605 #warning TODO: pusi 606 printk("cc: %04x\n", (data[0] << 8) | data[1]); 607 #endif 608 numsec++; 609 } else if (muxpack[0] == 0x47) { 610 #ifdef TTUSB_HWSECTIONS 611 /* we have TS data here! */ 612 int pid = ((muxpack[1] & 0x0F) << 8) | muxpack[2]; 613 int channel; 614 for (channel = 0; channel < TTUSB_MAXCHANNEL; ++channel) 615 if (ttusb->channel[channel].active 616 && (pid == ttusb->channel[channel].pid)) 617 ttusb_handle_ts_data(ttusb->channel + 618 channel, muxpack, 619 188); 620 #endif 621 numts++; 622 dvb_dmx_swfilter_packets(&ttusb->dvb_demux, muxpack, 1); 623 } else if (muxpack[0] != 0) { 624 numinvalid++; 625 printk("illegal muxpack type %02x\n", muxpack[0]); 626 } else 627 numstuff++; 628 } 629 630 static void ttusb_process_frame(struct ttusb *ttusb, u8 * data, int len) 631 { 632 int maxwork = 1024; 633 while (len) { 634 if (!(maxwork--)) { 635 printk("%s: too much work\n", __func__); 636 break; 637 } 638 639 switch (ttusb->mux_state) { 640 case 0: 641 case 1: 642 case 2: 643 len--; 644 if (*data++ == 0xAA) 645 ++ttusb->mux_state; 646 else { 647 ttusb->mux_state = 0; 648 if (ttusb->insync) { 649 dprintk("%s: %02x\n", 650 __func__, data[-1]); 651 printk(KERN_INFO "%s: lost sync.\n", 652 __func__); 653 ttusb->insync = 0; 654 } 655 } 656 break; 657 case 3: 658 ttusb->insync = 1; 659 len--; 660 ttusb->mux_npacks = *data++; 661 ++ttusb->mux_state; 662 ttusb->muxpack_ptr = 0; 663 /* maximum bytes, until we know the length */ 664 ttusb->muxpack_len = 2; 665 break; 666 case 4: 667 { 668 int avail; 669 avail = len; 670 if (avail > 671 (ttusb->muxpack_len - 672 ttusb->muxpack_ptr)) 673 avail = 674 ttusb->muxpack_len - 675 ttusb->muxpack_ptr; 676 memcpy(ttusb->muxpack + ttusb->muxpack_ptr, 677 data, avail); 678 ttusb->muxpack_ptr += avail; 679 BUG_ON(ttusb->muxpack_ptr > 264); 680 data += avail; 681 len -= avail; 682 /* determine length */ 683 if (ttusb->muxpack_ptr == 2) { 684 if (ttusb->muxpack[0] & 0x80) { 685 ttusb->muxpack_len = 686 ttusb->muxpack[1] + 2; 687 if (ttusb-> 688 muxpack[0] & 0x20) 689 ttusb-> 690 muxpack_len++; 691 if ((!! 692 (ttusb-> 693 muxpack[0] & 0x20)) ^ 694 !!(ttusb-> 695 muxpack[1] & 1)) 696 ttusb-> 697 muxpack_len++; 698 ttusb->muxpack_len += 4; 699 } else if (ttusb->muxpack[0] == 700 0x47) 701 ttusb->muxpack_len = 702 188 + 4; 703 else if (ttusb->muxpack[0] == 0x00) 704 ttusb->muxpack_len = 705 ttusb->muxpack[1] + 2 + 706 4; 707 else { 708 dprintk 709 ("%s: invalid state: first byte is %x\n", 710 __func__, 711 ttusb->muxpack[0]); 712 ttusb->mux_state = 0; 713 } 714 } 715 716 /** 717 * if length is valid and we reached the end: 718 * goto next muxpack 719 */ 720 if ((ttusb->muxpack_ptr >= 2) && 721 (ttusb->muxpack_ptr == 722 ttusb->muxpack_len)) { 723 ttusb_process_muxpack(ttusb, 724 ttusb-> 725 muxpack, 726 ttusb-> 727 muxpack_ptr); 728 ttusb->muxpack_ptr = 0; 729 /* maximum bytes, until we know the length */ 730 ttusb->muxpack_len = 2; 731 732 /** 733 * no muxpacks left? 734 * return to search-sync state 735 */ 736 if (!ttusb->mux_npacks--) { 737 ttusb->mux_state = 0; 738 break; 739 } 740 } 741 break; 742 } 743 default: 744 BUG(); 745 break; 746 } 747 } 748 } 749 750 static void ttusb_iso_irq(struct urb *urb) 751 { 752 struct ttusb *ttusb = urb->context; 753 struct usb_iso_packet_descriptor *d; 754 u8 *data; 755 int len, i; 756 757 if (!ttusb->iso_streaming) 758 return; 759 760 #if 0 761 printk("%s: status %d, errcount == %d, length == %i\n", 762 __func__, 763 urb->status, urb->error_count, urb->actual_length); 764 #endif 765 766 if (!urb->status) { 767 for (i = 0; i < urb->number_of_packets; ++i) { 768 numpkt++; 769 if (time_after_eq(jiffies, lastj + HZ)) { 770 dprintk("frames/s: %lu (ts: %d, stuff %d, " 771 "sec: %d, invalid: %d, all: %d)\n", 772 numpkt * HZ / (jiffies - lastj), 773 numts, numstuff, numsec, numinvalid, 774 numts + numstuff + numsec + numinvalid); 775 numts = numstuff = numsec = numinvalid = 0; 776 lastj = jiffies; 777 numpkt = 0; 778 } 779 d = &urb->iso_frame_desc[i]; 780 data = urb->transfer_buffer + d->offset; 781 len = d->actual_length; 782 d->actual_length = 0; 783 d->status = 0; 784 ttusb_process_frame(ttusb, data, len); 785 } 786 } 787 usb_submit_urb(urb, GFP_ATOMIC); 788 } 789 790 static void ttusb_free_iso_urbs(struct ttusb *ttusb) 791 { 792 int i; 793 794 for (i = 0; i < ISO_BUF_COUNT; i++) 795 usb_free_urb(ttusb->iso_urb[i]); 796 797 pci_free_consistent(NULL, 798 ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF * 799 ISO_BUF_COUNT, ttusb->iso_buffer, 800 ttusb->iso_dma_handle); 801 } 802 803 static int ttusb_alloc_iso_urbs(struct ttusb *ttusb) 804 { 805 int i; 806 807 ttusb->iso_buffer = pci_zalloc_consistent(NULL, 808 ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF * ISO_BUF_COUNT, 809 &ttusb->iso_dma_handle); 810 811 if (!ttusb->iso_buffer) { 812 dprintk("%s: pci_alloc_consistent - not enough memory\n", 813 __func__); 814 return -ENOMEM; 815 } 816 817 for (i = 0; i < ISO_BUF_COUNT; i++) { 818 struct urb *urb; 819 820 if (! 821 (urb = 822 usb_alloc_urb(FRAMES_PER_ISO_BUF, GFP_ATOMIC))) { 823 ttusb_free_iso_urbs(ttusb); 824 return -ENOMEM; 825 } 826 827 ttusb->iso_urb[i] = urb; 828 } 829 830 return 0; 831 } 832 833 static void ttusb_stop_iso_xfer(struct ttusb *ttusb) 834 { 835 int i; 836 837 for (i = 0; i < ISO_BUF_COUNT; i++) 838 usb_kill_urb(ttusb->iso_urb[i]); 839 840 ttusb->iso_streaming = 0; 841 } 842 843 static int ttusb_start_iso_xfer(struct ttusb *ttusb) 844 { 845 int i, j, err, buffer_offset = 0; 846 847 if (ttusb->iso_streaming) { 848 printk("%s: iso xfer already running!\n", __func__); 849 return 0; 850 } 851 852 ttusb->cc = -1; 853 ttusb->insync = 0; 854 ttusb->mux_state = 0; 855 856 for (i = 0; i < ISO_BUF_COUNT; i++) { 857 int frame_offset = 0; 858 struct urb *urb = ttusb->iso_urb[i]; 859 860 urb->dev = ttusb->dev; 861 urb->context = ttusb; 862 urb->complete = ttusb_iso_irq; 863 urb->pipe = ttusb->isoc_in_pipe; 864 urb->transfer_flags = URB_ISO_ASAP; 865 urb->interval = 1; 866 urb->number_of_packets = FRAMES_PER_ISO_BUF; 867 urb->transfer_buffer_length = 868 ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF; 869 urb->transfer_buffer = ttusb->iso_buffer + buffer_offset; 870 buffer_offset += ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF; 871 872 for (j = 0; j < FRAMES_PER_ISO_BUF; j++) { 873 urb->iso_frame_desc[j].offset = frame_offset; 874 urb->iso_frame_desc[j].length = ISO_FRAME_SIZE; 875 frame_offset += ISO_FRAME_SIZE; 876 } 877 } 878 879 for (i = 0; i < ISO_BUF_COUNT; i++) { 880 if ((err = usb_submit_urb(ttusb->iso_urb[i], GFP_ATOMIC))) { 881 ttusb_stop_iso_xfer(ttusb); 882 printk 883 ("%s: failed urb submission (%i: err = %i)!\n", 884 __func__, i, err); 885 return err; 886 } 887 } 888 889 ttusb->iso_streaming = 1; 890 891 return 0; 892 } 893 894 #ifdef TTUSB_HWSECTIONS 895 static void ttusb_handle_ts_data(struct dvb_demux_feed *dvbdmxfeed, const u8 * data, 896 int len) 897 { 898 dvbdmxfeed->cb.ts(data, len, 0, 0, &dvbdmxfeed->feed.ts, 0); 899 } 900 901 static void ttusb_handle_sec_data(struct dvb_demux_feed *dvbdmxfeed, const u8 * data, 902 int len) 903 { 904 // struct dvb_demux_feed *dvbdmxfeed = channel->dvbdmxfeed; 905 #error TODO: handle ugly stuff 906 // dvbdmxfeed->cb.sec(data, len, 0, 0, &dvbdmxfeed->feed.sec, 0); 907 } 908 #endif 909 910 static int ttusb_start_feed(struct dvb_demux_feed *dvbdmxfeed) 911 { 912 struct ttusb *ttusb = (struct ttusb *) dvbdmxfeed->demux; 913 int feed_type = 1; 914 915 dprintk("ttusb_start_feed\n"); 916 917 switch (dvbdmxfeed->type) { 918 case DMX_TYPE_TS: 919 break; 920 case DMX_TYPE_SEC: 921 break; 922 default: 923 return -EINVAL; 924 } 925 926 if (dvbdmxfeed->type == DMX_TYPE_TS) { 927 switch (dvbdmxfeed->pes_type) { 928 case DMX_PES_VIDEO: 929 case DMX_PES_AUDIO: 930 case DMX_PES_TELETEXT: 931 case DMX_PES_PCR: 932 case DMX_PES_OTHER: 933 break; 934 default: 935 return -EINVAL; 936 } 937 } 938 939 #ifdef TTUSB_HWSECTIONS 940 #error TODO: allocate filters 941 if (dvbdmxfeed->type == DMX_TYPE_TS) { 942 feed_type = 1; 943 } else if (dvbdmxfeed->type == DMX_TYPE_SEC) { 944 feed_type = 2; 945 } 946 #endif 947 948 ttusb_set_channel(ttusb, dvbdmxfeed->index, feed_type, dvbdmxfeed->pid); 949 950 if (0 == ttusb->running_feed_count++) 951 ttusb_start_iso_xfer(ttusb); 952 953 return 0; 954 } 955 956 static int ttusb_stop_feed(struct dvb_demux_feed *dvbdmxfeed) 957 { 958 struct ttusb *ttusb = (struct ttusb *) dvbdmxfeed->demux; 959 960 ttusb_del_channel(ttusb, dvbdmxfeed->index); 961 962 if (--ttusb->running_feed_count == 0) 963 ttusb_stop_iso_xfer(ttusb); 964 965 return 0; 966 } 967 968 static int ttusb_setup_interfaces(struct ttusb *ttusb) 969 { 970 usb_set_interface(ttusb->dev, 1, 1); 971 972 ttusb->bulk_out_pipe = usb_sndbulkpipe(ttusb->dev, 1); 973 ttusb->bulk_in_pipe = usb_rcvbulkpipe(ttusb->dev, 1); 974 ttusb->isoc_in_pipe = usb_rcvisocpipe(ttusb->dev, 2); 975 976 return 0; 977 } 978 979 #if 0 980 static u8 stc_firmware[8192]; 981 982 static int stc_open(struct inode *inode, struct file *file) 983 { 984 struct ttusb *ttusb = file->private_data; 985 int addr; 986 987 for (addr = 0; addr < 8192; addr += 16) { 988 u8 snd_buf[2] = { addr >> 8, addr & 0xFF }; 989 ttusb_i2c_msg(ttusb, 0x50, snd_buf, 2, stc_firmware + addr, 990 16); 991 } 992 993 return 0; 994 } 995 996 static ssize_t stc_read(struct file *file, char *buf, size_t count, 997 loff_t *offset) 998 { 999 return simple_read_from_buffer(buf, count, offset, stc_firmware, 8192); 1000 } 1001 1002 static int stc_release(struct inode *inode, struct file *file) 1003 { 1004 return 0; 1005 } 1006 1007 static const struct file_operations stc_fops = { 1008 .owner = THIS_MODULE, 1009 .read = stc_read, 1010 .open = stc_open, 1011 .release = stc_release, 1012 }; 1013 #endif 1014 1015 static u32 functionality(struct i2c_adapter *adapter) 1016 { 1017 return I2C_FUNC_I2C; 1018 } 1019 1020 1021 1022 static int alps_tdmb7_tuner_set_params(struct dvb_frontend *fe) 1023 { 1024 struct dtv_frontend_properties *p = &fe->dtv_property_cache; 1025 struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv; 1026 u8 data[4]; 1027 struct i2c_msg msg = {.addr=0x61, .flags=0, .buf=data, .len=sizeof(data) }; 1028 u32 div; 1029 1030 div = (p->frequency + 36166667) / 166667; 1031 1032 data[0] = (div >> 8) & 0x7f; 1033 data[1] = div & 0xff; 1034 data[2] = ((div >> 10) & 0x60) | 0x85; 1035 data[3] = p->frequency < 592000000 ? 0x40 : 0x80; 1036 1037 if (fe->ops.i2c_gate_ctrl) 1038 fe->ops.i2c_gate_ctrl(fe, 1); 1039 if (i2c_transfer(&ttusb->i2c_adap, &msg, 1) != 1) return -EIO; 1040 return 0; 1041 } 1042 1043 static struct cx22700_config alps_tdmb7_config = { 1044 .demod_address = 0x43, 1045 }; 1046 1047 1048 1049 1050 1051 static int philips_tdm1316l_tuner_init(struct dvb_frontend* fe) 1052 { 1053 struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv; 1054 static u8 td1316_init[] = { 0x0b, 0xf5, 0x85, 0xab }; 1055 static u8 disable_mc44BC374c[] = { 0x1d, 0x74, 0xa0, 0x68 }; 1056 struct i2c_msg tuner_msg = { .addr=0x60, .flags=0, .buf=td1316_init, .len=sizeof(td1316_init) }; 1057 1058 // setup PLL configuration 1059 if (fe->ops.i2c_gate_ctrl) 1060 fe->ops.i2c_gate_ctrl(fe, 1); 1061 if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1) return -EIO; 1062 msleep(1); 1063 1064 // disable the mc44BC374c (do not check for errors) 1065 tuner_msg.addr = 0x65; 1066 tuner_msg.buf = disable_mc44BC374c; 1067 tuner_msg.len = sizeof(disable_mc44BC374c); 1068 if (fe->ops.i2c_gate_ctrl) 1069 fe->ops.i2c_gate_ctrl(fe, 1); 1070 if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1) { 1071 i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1); 1072 } 1073 1074 return 0; 1075 } 1076 1077 static int philips_tdm1316l_tuner_set_params(struct dvb_frontend *fe) 1078 { 1079 struct dtv_frontend_properties *p = &fe->dtv_property_cache; 1080 struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv; 1081 u8 tuner_buf[4]; 1082 struct i2c_msg tuner_msg = {.addr=0x60, .flags=0, .buf=tuner_buf, .len=sizeof(tuner_buf) }; 1083 int tuner_frequency = 0; 1084 u8 band, cp, filter; 1085 1086 // determine charge pump 1087 tuner_frequency = p->frequency + 36130000; 1088 if (tuner_frequency < 87000000) return -EINVAL; 1089 else if (tuner_frequency < 130000000) cp = 3; 1090 else if (tuner_frequency < 160000000) cp = 5; 1091 else if (tuner_frequency < 200000000) cp = 6; 1092 else if (tuner_frequency < 290000000) cp = 3; 1093 else if (tuner_frequency < 420000000) cp = 5; 1094 else if (tuner_frequency < 480000000) cp = 6; 1095 else if (tuner_frequency < 620000000) cp = 3; 1096 else if (tuner_frequency < 830000000) cp = 5; 1097 else if (tuner_frequency < 895000000) cp = 7; 1098 else return -EINVAL; 1099 1100 // determine band 1101 if (p->frequency < 49000000) 1102 return -EINVAL; 1103 else if (p->frequency < 159000000) 1104 band = 1; 1105 else if (p->frequency < 444000000) 1106 band = 2; 1107 else if (p->frequency < 861000000) 1108 band = 4; 1109 else return -EINVAL; 1110 1111 // setup PLL filter 1112 switch (p->bandwidth_hz) { 1113 case 6000000: 1114 tda1004x_writereg(fe, 0x0C, 0); 1115 filter = 0; 1116 break; 1117 1118 case 7000000: 1119 tda1004x_writereg(fe, 0x0C, 0); 1120 filter = 0; 1121 break; 1122 1123 case 8000000: 1124 tda1004x_writereg(fe, 0x0C, 0xFF); 1125 filter = 1; 1126 break; 1127 1128 default: 1129 return -EINVAL; 1130 } 1131 1132 // calculate divisor 1133 // ((36130000+((1000000/6)/2)) + Finput)/(1000000/6) 1134 tuner_frequency = (((p->frequency / 1000) * 6) + 217280) / 1000; 1135 1136 // setup tuner buffer 1137 tuner_buf[0] = tuner_frequency >> 8; 1138 tuner_buf[1] = tuner_frequency & 0xff; 1139 tuner_buf[2] = 0xca; 1140 tuner_buf[3] = (cp << 5) | (filter << 3) | band; 1141 1142 if (fe->ops.i2c_gate_ctrl) 1143 fe->ops.i2c_gate_ctrl(fe, 1); 1144 if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1) 1145 return -EIO; 1146 1147 msleep(1); 1148 return 0; 1149 } 1150 1151 static int philips_tdm1316l_request_firmware(struct dvb_frontend* fe, const struct firmware **fw, char* name) 1152 { 1153 struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv; 1154 1155 return request_firmware(fw, name, &ttusb->dev->dev); 1156 } 1157 1158 static struct tda1004x_config philips_tdm1316l_config = { 1159 1160 .demod_address = 0x8, 1161 .invert = 1, 1162 .invert_oclk = 0, 1163 .request_firmware = philips_tdm1316l_request_firmware, 1164 }; 1165 1166 static u8 alps_bsbe1_inittab[] = { 1167 0x01, 0x15, 1168 0x02, 0x30, 1169 0x03, 0x00, 1170 0x04, 0x7d, /* F22FR = 0x7d, F22 = f_VCO / 128 / 0x7d = 22 kHz */ 1171 0x05, 0x35, /* I2CT = 0, SCLT = 1, SDAT = 1 */ 1172 0x06, 0x40, /* DAC not used, set to high impendance mode */ 1173 0x07, 0x00, /* DAC LSB */ 1174 0x08, 0x40, /* DiSEqC off, LNB power on OP2/LOCK pin on */ 1175 0x09, 0x00, /* FIFO */ 1176 0x0c, 0x51, /* OP1 ctl = Normal, OP1 val = 1 (LNB Power ON) */ 1177 0x0d, 0x82, /* DC offset compensation = ON, beta_agc1 = 2 */ 1178 0x0e, 0x23, /* alpha_tmg = 2, beta_tmg = 3 */ 1179 0x10, 0x3f, // AGC2 0x3d 1180 0x11, 0x84, 1181 0x12, 0xb9, 1182 0x15, 0xc9, // lock detector threshold 1183 0x16, 0x00, 1184 0x17, 0x00, 1185 0x18, 0x00, 1186 0x19, 0x00, 1187 0x1a, 0x00, 1188 0x1f, 0x50, 1189 0x20, 0x00, 1190 0x21, 0x00, 1191 0x22, 0x00, 1192 0x23, 0x00, 1193 0x28, 0x00, // out imp: normal out type: parallel FEC mode:0 1194 0x29, 0x1e, // 1/2 threshold 1195 0x2a, 0x14, // 2/3 threshold 1196 0x2b, 0x0f, // 3/4 threshold 1197 0x2c, 0x09, // 5/6 threshold 1198 0x2d, 0x05, // 7/8 threshold 1199 0x2e, 0x01, 1200 0x31, 0x1f, // test all FECs 1201 0x32, 0x19, // viterbi and synchro search 1202 0x33, 0xfc, // rs control 1203 0x34, 0x93, // error control 1204 0x0f, 0x92, 1205 0xff, 0xff 1206 }; 1207 1208 static u8 alps_bsru6_inittab[] = { 1209 0x01, 0x15, 1210 0x02, 0x30, 1211 0x03, 0x00, 1212 0x04, 0x7d, /* F22FR = 0x7d, F22 = f_VCO / 128 / 0x7d = 22 kHz */ 1213 0x05, 0x35, /* I2CT = 0, SCLT = 1, SDAT = 1 */ 1214 0x06, 0x40, /* DAC not used, set to high impendance mode */ 1215 0x07, 0x00, /* DAC LSB */ 1216 0x08, 0x40, /* DiSEqC off, LNB power on OP2/LOCK pin on */ 1217 0x09, 0x00, /* FIFO */ 1218 0x0c, 0x51, /* OP1 ctl = Normal, OP1 val = 1 (LNB Power ON) */ 1219 0x0d, 0x82, /* DC offset compensation = ON, beta_agc1 = 2 */ 1220 0x0e, 0x23, /* alpha_tmg = 2, beta_tmg = 3 */ 1221 0x10, 0x3f, // AGC2 0x3d 1222 0x11, 0x84, 1223 0x12, 0xb9, 1224 0x15, 0xc9, // lock detector threshold 1225 0x16, 0x00, 1226 0x17, 0x00, 1227 0x18, 0x00, 1228 0x19, 0x00, 1229 0x1a, 0x00, 1230 0x1f, 0x50, 1231 0x20, 0x00, 1232 0x21, 0x00, 1233 0x22, 0x00, 1234 0x23, 0x00, 1235 0x28, 0x00, // out imp: normal out type: parallel FEC mode:0 1236 0x29, 0x1e, // 1/2 threshold 1237 0x2a, 0x14, // 2/3 threshold 1238 0x2b, 0x0f, // 3/4 threshold 1239 0x2c, 0x09, // 5/6 threshold 1240 0x2d, 0x05, // 7/8 threshold 1241 0x2e, 0x01, 1242 0x31, 0x1f, // test all FECs 1243 0x32, 0x19, // viterbi and synchro search 1244 0x33, 0xfc, // rs control 1245 0x34, 0x93, // error control 1246 0x0f, 0x52, 1247 0xff, 0xff 1248 }; 1249 1250 static int alps_stv0299_set_symbol_rate(struct dvb_frontend *fe, u32 srate, u32 ratio) 1251 { 1252 u8 aclk = 0; 1253 u8 bclk = 0; 1254 1255 if (srate < 1500000) { 1256 aclk = 0xb7; 1257 bclk = 0x47; 1258 } else if (srate < 3000000) { 1259 aclk = 0xb7; 1260 bclk = 0x4b; 1261 } else if (srate < 7000000) { 1262 aclk = 0xb7; 1263 bclk = 0x4f; 1264 } else if (srate < 14000000) { 1265 aclk = 0xb7; 1266 bclk = 0x53; 1267 } else if (srate < 30000000) { 1268 aclk = 0xb6; 1269 bclk = 0x53; 1270 } else if (srate < 45000000) { 1271 aclk = 0xb4; 1272 bclk = 0x51; 1273 } 1274 1275 stv0299_writereg(fe, 0x13, aclk); 1276 stv0299_writereg(fe, 0x14, bclk); 1277 stv0299_writereg(fe, 0x1f, (ratio >> 16) & 0xff); 1278 stv0299_writereg(fe, 0x20, (ratio >> 8) & 0xff); 1279 stv0299_writereg(fe, 0x21, (ratio) & 0xf0); 1280 1281 return 0; 1282 } 1283 1284 static int philips_tsa5059_tuner_set_params(struct dvb_frontend *fe) 1285 { 1286 struct dtv_frontend_properties *p = &fe->dtv_property_cache; 1287 struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv; 1288 u8 buf[4]; 1289 u32 div; 1290 struct i2c_msg msg = {.addr = 0x61,.flags = 0,.buf = buf,.len = sizeof(buf) }; 1291 1292 if ((p->frequency < 950000) || (p->frequency > 2150000)) 1293 return -EINVAL; 1294 1295 div = (p->frequency + (125 - 1)) / 125; /* round correctly */ 1296 buf[0] = (div >> 8) & 0x7f; 1297 buf[1] = div & 0xff; 1298 buf[2] = 0x80 | ((div & 0x18000) >> 10) | 4; 1299 buf[3] = 0xC4; 1300 1301 if (p->frequency > 1530000) 1302 buf[3] = 0xC0; 1303 1304 /* BSBE1 wants XCE bit set */ 1305 if (ttusb->revision == TTUSB_REV_2_2) 1306 buf[3] |= 0x20; 1307 1308 if (fe->ops.i2c_gate_ctrl) 1309 fe->ops.i2c_gate_ctrl(fe, 1); 1310 if (i2c_transfer(&ttusb->i2c_adap, &msg, 1) != 1) 1311 return -EIO; 1312 1313 return 0; 1314 } 1315 1316 static struct stv0299_config alps_stv0299_config = { 1317 .demod_address = 0x68, 1318 .inittab = alps_bsru6_inittab, 1319 .mclk = 88000000UL, 1320 .invert = 1, 1321 .skip_reinit = 0, 1322 .lock_output = STV0299_LOCKOUTPUT_1, 1323 .volt13_op0_op1 = STV0299_VOLT13_OP1, 1324 .min_delay_ms = 100, 1325 .set_symbol_rate = alps_stv0299_set_symbol_rate, 1326 }; 1327 1328 static int ttusb_novas_grundig_29504_491_tuner_set_params(struct dvb_frontend *fe) 1329 { 1330 struct dtv_frontend_properties *p = &fe->dtv_property_cache; 1331 struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv; 1332 u8 buf[4]; 1333 u32 div; 1334 struct i2c_msg msg = {.addr = 0x61,.flags = 0,.buf = buf,.len = sizeof(buf) }; 1335 1336 div = p->frequency / 125; 1337 1338 buf[0] = (div >> 8) & 0x7f; 1339 buf[1] = div & 0xff; 1340 buf[2] = 0x8e; 1341 buf[3] = 0x00; 1342 1343 if (fe->ops.i2c_gate_ctrl) 1344 fe->ops.i2c_gate_ctrl(fe, 1); 1345 if (i2c_transfer(&ttusb->i2c_adap, &msg, 1) != 1) 1346 return -EIO; 1347 1348 return 0; 1349 } 1350 1351 static struct tda8083_config ttusb_novas_grundig_29504_491_config = { 1352 1353 .demod_address = 0x68, 1354 }; 1355 1356 static int alps_tdbe2_tuner_set_params(struct dvb_frontend *fe) 1357 { 1358 struct dtv_frontend_properties *p = &fe->dtv_property_cache; 1359 struct ttusb* ttusb = fe->dvb->priv; 1360 u32 div; 1361 u8 data[4]; 1362 struct i2c_msg msg = { .addr = 0x62, .flags = 0, .buf = data, .len = sizeof(data) }; 1363 1364 div = (p->frequency + 35937500 + 31250) / 62500; 1365 1366 data[0] = (div >> 8) & 0x7f; 1367 data[1] = div & 0xff; 1368 data[2] = 0x85 | ((div >> 10) & 0x60); 1369 data[3] = (p->frequency < 174000000 ? 0x88 : p->frequency < 470000000 ? 0x84 : 0x81); 1370 1371 if (fe->ops.i2c_gate_ctrl) 1372 fe->ops.i2c_gate_ctrl(fe, 1); 1373 if (i2c_transfer (&ttusb->i2c_adap, &msg, 1) != 1) 1374 return -EIO; 1375 1376 return 0; 1377 } 1378 1379 1380 static struct ves1820_config alps_tdbe2_config = { 1381 .demod_address = 0x09, 1382 .xin = 57840000UL, 1383 .invert = 1, 1384 .selagc = VES1820_SELAGC_SIGNAMPERR, 1385 }; 1386 1387 static u8 read_pwm(struct ttusb* ttusb) 1388 { 1389 u8 b = 0xff; 1390 u8 pwm; 1391 struct i2c_msg msg[] = { { .addr = 0x50,.flags = 0,.buf = &b,.len = 1 }, 1392 { .addr = 0x50,.flags = I2C_M_RD,.buf = &pwm,.len = 1} }; 1393 1394 if ((i2c_transfer(&ttusb->i2c_adap, msg, 2) != 2) || (pwm == 0xff)) 1395 pwm = 0x48; 1396 1397 return pwm; 1398 } 1399 1400 1401 static int dvbc_philips_tdm1316l_tuner_set_params(struct dvb_frontend *fe) 1402 { 1403 struct dtv_frontend_properties *p = &fe->dtv_property_cache; 1404 struct ttusb *ttusb = (struct ttusb *) fe->dvb->priv; 1405 u8 tuner_buf[5]; 1406 struct i2c_msg tuner_msg = {.addr = 0x60, 1407 .flags = 0, 1408 .buf = tuner_buf, 1409 .len = sizeof(tuner_buf) }; 1410 int tuner_frequency = 0; 1411 u8 band, cp, filter; 1412 1413 // determine charge pump 1414 tuner_frequency = p->frequency; 1415 if (tuner_frequency < 87000000) {return -EINVAL;} 1416 else if (tuner_frequency < 130000000) {cp = 3; band = 1;} 1417 else if (tuner_frequency < 160000000) {cp = 5; band = 1;} 1418 else if (tuner_frequency < 200000000) {cp = 6; band = 1;} 1419 else if (tuner_frequency < 290000000) {cp = 3; band = 2;} 1420 else if (tuner_frequency < 420000000) {cp = 5; band = 2;} 1421 else if (tuner_frequency < 480000000) {cp = 6; band = 2;} 1422 else if (tuner_frequency < 620000000) {cp = 3; band = 4;} 1423 else if (tuner_frequency < 830000000) {cp = 5; band = 4;} 1424 else if (tuner_frequency < 895000000) {cp = 7; band = 4;} 1425 else {return -EINVAL;} 1426 1427 // assume PLL filter should always be 8MHz for the moment. 1428 filter = 1; 1429 1430 // calculate divisor 1431 // (Finput + Fif)/Fref; Fif = 36125000 Hz, Fref = 62500 Hz 1432 tuner_frequency = ((p->frequency + 36125000) / 62500); 1433 1434 // setup tuner buffer 1435 tuner_buf[0] = tuner_frequency >> 8; 1436 tuner_buf[1] = tuner_frequency & 0xff; 1437 tuner_buf[2] = 0xc8; 1438 tuner_buf[3] = (cp << 5) | (filter << 3) | band; 1439 tuner_buf[4] = 0x80; 1440 1441 if (fe->ops.i2c_gate_ctrl) 1442 fe->ops.i2c_gate_ctrl(fe, 1); 1443 if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1) { 1444 printk("dvb-ttusb-budget: dvbc_philips_tdm1316l_pll_set Error 1\n"); 1445 return -EIO; 1446 } 1447 1448 msleep(50); 1449 1450 if (fe->ops.i2c_gate_ctrl) 1451 fe->ops.i2c_gate_ctrl(fe, 1); 1452 if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1) { 1453 printk("dvb-ttusb-budget: dvbc_philips_tdm1316l_pll_set Error 2\n"); 1454 return -EIO; 1455 } 1456 1457 msleep(1); 1458 1459 return 0; 1460 } 1461 1462 static u8 dvbc_philips_tdm1316l_inittab[] = { 1463 0x80, 0x21, 1464 0x80, 0x20, 1465 0x81, 0x01, 1466 0x81, 0x00, 1467 0x00, 0x09, 1468 0x01, 0x69, 1469 0x03, 0x00, 1470 0x04, 0x00, 1471 0x07, 0x00, 1472 0x08, 0x00, 1473 0x20, 0x00, 1474 0x21, 0x40, 1475 0x22, 0x00, 1476 0x23, 0x00, 1477 0x24, 0x40, 1478 0x25, 0x88, 1479 0x30, 0xff, 1480 0x31, 0x00, 1481 0x32, 0xff, 1482 0x33, 0x00, 1483 0x34, 0x50, 1484 0x35, 0x7f, 1485 0x36, 0x00, 1486 0x37, 0x20, 1487 0x38, 0x00, 1488 0x40, 0x1c, 1489 0x41, 0xff, 1490 0x42, 0x29, 1491 0x43, 0x20, 1492 0x44, 0xff, 1493 0x45, 0x00, 1494 0x46, 0x00, 1495 0x49, 0x04, 1496 0x4a, 0xff, 1497 0x4b, 0x7f, 1498 0x52, 0x30, 1499 0x55, 0xae, 1500 0x56, 0x47, 1501 0x57, 0xe1, 1502 0x58, 0x3a, 1503 0x5a, 0x1e, 1504 0x5b, 0x34, 1505 0x60, 0x00, 1506 0x63, 0x00, 1507 0x64, 0x00, 1508 0x65, 0x00, 1509 0x66, 0x00, 1510 0x67, 0x00, 1511 0x68, 0x00, 1512 0x69, 0x00, 1513 0x6a, 0x02, 1514 0x6b, 0x00, 1515 0x70, 0xff, 1516 0x71, 0x00, 1517 0x72, 0x00, 1518 0x73, 0x00, 1519 0x74, 0x0c, 1520 0x80, 0x00, 1521 0x81, 0x00, 1522 0x82, 0x00, 1523 0x83, 0x00, 1524 0x84, 0x04, 1525 0x85, 0x80, 1526 0x86, 0x24, 1527 0x87, 0x78, 1528 0x88, 0x00, 1529 0x89, 0x00, 1530 0x90, 0x01, 1531 0x91, 0x01, 1532 0xa0, 0x00, 1533 0xa1, 0x00, 1534 0xa2, 0x00, 1535 0xb0, 0x91, 1536 0xb1, 0x0b, 1537 0xc0, 0x4b, 1538 0xc1, 0x00, 1539 0xc2, 0x00, 1540 0xd0, 0x00, 1541 0xd1, 0x00, 1542 0xd2, 0x00, 1543 0xd3, 0x00, 1544 0xd4, 0x00, 1545 0xd5, 0x00, 1546 0xde, 0x00, 1547 0xdf, 0x00, 1548 0x61, 0x38, 1549 0x62, 0x0a, 1550 0x53, 0x13, 1551 0x59, 0x08, 1552 0x55, 0x00, 1553 0x56, 0x40, 1554 0x57, 0x08, 1555 0x58, 0x3d, 1556 0x88, 0x10, 1557 0xa0, 0x00, 1558 0xa0, 0x00, 1559 0xa0, 0x00, 1560 0xa0, 0x04, 1561 0xff, 0xff, 1562 }; 1563 1564 static struct stv0297_config dvbc_philips_tdm1316l_config = { 1565 .demod_address = 0x1c, 1566 .inittab = dvbc_philips_tdm1316l_inittab, 1567 .invert = 0, 1568 }; 1569 1570 static void frontend_init(struct ttusb* ttusb) 1571 { 1572 switch(le16_to_cpu(ttusb->dev->descriptor.idProduct)) { 1573 case 0x1003: // Hauppauge/TT Nova-USB-S budget (stv0299/ALPS BSRU6|BSBE1(tsa5059)) 1574 // try the stv0299 based first 1575 ttusb->fe = dvb_attach(stv0299_attach, &alps_stv0299_config, &ttusb->i2c_adap); 1576 if (ttusb->fe != NULL) { 1577 ttusb->fe->ops.tuner_ops.set_params = philips_tsa5059_tuner_set_params; 1578 1579 if(ttusb->revision == TTUSB_REV_2_2) { // ALPS BSBE1 1580 alps_stv0299_config.inittab = alps_bsbe1_inittab; 1581 dvb_attach(lnbp21_attach, ttusb->fe, &ttusb->i2c_adap, 0, 0); 1582 } else { // ALPS BSRU6 1583 ttusb->fe->ops.set_voltage = ttusb_set_voltage; 1584 } 1585 break; 1586 } 1587 1588 // Grundig 29504-491 1589 ttusb->fe = dvb_attach(tda8083_attach, &ttusb_novas_grundig_29504_491_config, &ttusb->i2c_adap); 1590 if (ttusb->fe != NULL) { 1591 ttusb->fe->ops.tuner_ops.set_params = ttusb_novas_grundig_29504_491_tuner_set_params; 1592 ttusb->fe->ops.set_voltage = ttusb_set_voltage; 1593 break; 1594 } 1595 break; 1596 1597 case 0x1004: // Hauppauge/TT DVB-C budget (ves1820/ALPS TDBE2(sp5659)) 1598 ttusb->fe = dvb_attach(ves1820_attach, &alps_tdbe2_config, &ttusb->i2c_adap, read_pwm(ttusb)); 1599 if (ttusb->fe != NULL) { 1600 ttusb->fe->ops.tuner_ops.set_params = alps_tdbe2_tuner_set_params; 1601 break; 1602 } 1603 1604 ttusb->fe = dvb_attach(stv0297_attach, &dvbc_philips_tdm1316l_config, &ttusb->i2c_adap); 1605 if (ttusb->fe != NULL) { 1606 ttusb->fe->ops.tuner_ops.set_params = dvbc_philips_tdm1316l_tuner_set_params; 1607 break; 1608 } 1609 break; 1610 1611 case 0x1005: // Hauppauge/TT Nova-USB-t budget (tda10046/Philips td1316(tda6651tt) OR cx22700/ALPS TDMB7(??)) 1612 // try the ALPS TDMB7 first 1613 ttusb->fe = dvb_attach(cx22700_attach, &alps_tdmb7_config, &ttusb->i2c_adap); 1614 if (ttusb->fe != NULL) { 1615 ttusb->fe->ops.tuner_ops.set_params = alps_tdmb7_tuner_set_params; 1616 break; 1617 } 1618 1619 // Philips td1316 1620 ttusb->fe = dvb_attach(tda10046_attach, &philips_tdm1316l_config, &ttusb->i2c_adap); 1621 if (ttusb->fe != NULL) { 1622 ttusb->fe->ops.tuner_ops.init = philips_tdm1316l_tuner_init; 1623 ttusb->fe->ops.tuner_ops.set_params = philips_tdm1316l_tuner_set_params; 1624 break; 1625 } 1626 break; 1627 } 1628 1629 if (ttusb->fe == NULL) { 1630 printk("dvb-ttusb-budget: A frontend driver was not found for device [%04x:%04x]\n", 1631 le16_to_cpu(ttusb->dev->descriptor.idVendor), 1632 le16_to_cpu(ttusb->dev->descriptor.idProduct)); 1633 } else { 1634 if (dvb_register_frontend(&ttusb->adapter, ttusb->fe)) { 1635 printk("dvb-ttusb-budget: Frontend registration failed!\n"); 1636 dvb_frontend_detach(ttusb->fe); 1637 ttusb->fe = NULL; 1638 } 1639 } 1640 } 1641 1642 1643 1644 static struct i2c_algorithm ttusb_dec_algo = { 1645 .master_xfer = master_xfer, 1646 .functionality = functionality, 1647 }; 1648 1649 static int ttusb_probe(struct usb_interface *intf, const struct usb_device_id *id) 1650 { 1651 struct usb_device *udev; 1652 struct ttusb *ttusb; 1653 int result; 1654 1655 dprintk("%s: TTUSB DVB connected\n", __func__); 1656 1657 udev = interface_to_usbdev(intf); 1658 1659 if (intf->altsetting->desc.bInterfaceNumber != 1) return -ENODEV; 1660 1661 if (!(ttusb = kzalloc(sizeof(struct ttusb), GFP_KERNEL))) 1662 return -ENOMEM; 1663 1664 ttusb->dev = udev; 1665 ttusb->c = 0; 1666 ttusb->mux_state = 0; 1667 mutex_init(&ttusb->semi2c); 1668 1669 mutex_lock(&ttusb->semi2c); 1670 1671 mutex_init(&ttusb->semusb); 1672 1673 ttusb_setup_interfaces(ttusb); 1674 1675 result = ttusb_alloc_iso_urbs(ttusb); 1676 if (result < 0) { 1677 dprintk("%s: ttusb_alloc_iso_urbs - failed\n", __func__); 1678 mutex_unlock(&ttusb->semi2c); 1679 kfree(ttusb); 1680 return result; 1681 } 1682 1683 if (ttusb_init_controller(ttusb)) 1684 printk("ttusb_init_controller: error\n"); 1685 1686 mutex_unlock(&ttusb->semi2c); 1687 1688 result = dvb_register_adapter(&ttusb->adapter, 1689 "Technotrend/Hauppauge Nova-USB", 1690 THIS_MODULE, &udev->dev, adapter_nr); 1691 if (result < 0) { 1692 ttusb_free_iso_urbs(ttusb); 1693 kfree(ttusb); 1694 return result; 1695 } 1696 ttusb->adapter.priv = ttusb; 1697 1698 /* i2c */ 1699 memset(&ttusb->i2c_adap, 0, sizeof(struct i2c_adapter)); 1700 strcpy(ttusb->i2c_adap.name, "TTUSB DEC"); 1701 1702 i2c_set_adapdata(&ttusb->i2c_adap, ttusb); 1703 1704 ttusb->i2c_adap.algo = &ttusb_dec_algo; 1705 ttusb->i2c_adap.algo_data = NULL; 1706 ttusb->i2c_adap.dev.parent = &udev->dev; 1707 1708 result = i2c_add_adapter(&ttusb->i2c_adap); 1709 if (result) 1710 goto err_unregister_adapter; 1711 1712 memset(&ttusb->dvb_demux, 0, sizeof(ttusb->dvb_demux)); 1713 1714 ttusb->dvb_demux.dmx.capabilities = 1715 DMX_TS_FILTERING | DMX_SECTION_FILTERING; 1716 ttusb->dvb_demux.priv = NULL; 1717 #ifdef TTUSB_HWSECTIONS 1718 ttusb->dvb_demux.filternum = TTUSB_MAXFILTER; 1719 #else 1720 ttusb->dvb_demux.filternum = 32; 1721 #endif 1722 ttusb->dvb_demux.feednum = TTUSB_MAXCHANNEL; 1723 ttusb->dvb_demux.start_feed = ttusb_start_feed; 1724 ttusb->dvb_demux.stop_feed = ttusb_stop_feed; 1725 ttusb->dvb_demux.write_to_decoder = NULL; 1726 1727 result = dvb_dmx_init(&ttusb->dvb_demux); 1728 if (result < 0) { 1729 printk("ttusb_dvb: dvb_dmx_init failed (errno = %d)\n", result); 1730 result = -ENODEV; 1731 goto err_i2c_del_adapter; 1732 } 1733 //FIXME dmxdev (nur WAS?) 1734 ttusb->dmxdev.filternum = ttusb->dvb_demux.filternum; 1735 ttusb->dmxdev.demux = &ttusb->dvb_demux.dmx; 1736 ttusb->dmxdev.capabilities = 0; 1737 1738 result = dvb_dmxdev_init(&ttusb->dmxdev, &ttusb->adapter); 1739 if (result < 0) { 1740 printk("ttusb_dvb: dvb_dmxdev_init failed (errno = %d)\n", 1741 result); 1742 result = -ENODEV; 1743 goto err_release_dmx; 1744 } 1745 1746 if (dvb_net_init(&ttusb->adapter, &ttusb->dvbnet, &ttusb->dvb_demux.dmx)) { 1747 printk("ttusb_dvb: dvb_net_init failed!\n"); 1748 result = -ENODEV; 1749 goto err_release_dmxdev; 1750 } 1751 1752 usb_set_intfdata(intf, (void *) ttusb); 1753 1754 frontend_init(ttusb); 1755 1756 return 0; 1757 1758 err_release_dmxdev: 1759 dvb_dmxdev_release(&ttusb->dmxdev); 1760 err_release_dmx: 1761 dvb_dmx_release(&ttusb->dvb_demux); 1762 err_i2c_del_adapter: 1763 i2c_del_adapter(&ttusb->i2c_adap); 1764 err_unregister_adapter: 1765 dvb_unregister_adapter (&ttusb->adapter); 1766 ttusb_free_iso_urbs(ttusb); 1767 kfree(ttusb); 1768 return result; 1769 } 1770 1771 static void ttusb_disconnect(struct usb_interface *intf) 1772 { 1773 struct ttusb *ttusb = usb_get_intfdata(intf); 1774 1775 usb_set_intfdata(intf, NULL); 1776 1777 ttusb->disconnecting = 1; 1778 1779 ttusb_stop_iso_xfer(ttusb); 1780 1781 ttusb->dvb_demux.dmx.close(&ttusb->dvb_demux.dmx); 1782 dvb_net_release(&ttusb->dvbnet); 1783 dvb_dmxdev_release(&ttusb->dmxdev); 1784 dvb_dmx_release(&ttusb->dvb_demux); 1785 if (ttusb->fe != NULL) { 1786 dvb_unregister_frontend(ttusb->fe); 1787 dvb_frontend_detach(ttusb->fe); 1788 } 1789 i2c_del_adapter(&ttusb->i2c_adap); 1790 dvb_unregister_adapter(&ttusb->adapter); 1791 1792 ttusb_free_iso_urbs(ttusb); 1793 1794 kfree(ttusb); 1795 1796 dprintk("%s: TTUSB DVB disconnected\n", __func__); 1797 } 1798 1799 static struct usb_device_id ttusb_table[] = { 1800 {USB_DEVICE(0xb48, 0x1003)}, 1801 {USB_DEVICE(0xb48, 0x1004)}, 1802 {USB_DEVICE(0xb48, 0x1005)}, 1803 {} 1804 }; 1805 1806 MODULE_DEVICE_TABLE(usb, ttusb_table); 1807 1808 static struct usb_driver ttusb_driver = { 1809 .name = "ttusb", 1810 .probe = ttusb_probe, 1811 .disconnect = ttusb_disconnect, 1812 .id_table = ttusb_table, 1813 }; 1814 1815 module_usb_driver(ttusb_driver); 1816 1817 MODULE_AUTHOR("Holger Waechtler <holger@convergence.de>"); 1818 MODULE_DESCRIPTION("TTUSB DVB Driver"); 1819 MODULE_LICENSE("GPL"); 1820 MODULE_FIRMWARE("ttusb-budget/dspbootcode.bin"); 1821