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 fe_sec_tone_mode_t tone; 115 fe_sec_voltage_t 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, fe_sec_voltage_t voltage) 515 { 516 struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv; 517 518 ttusb->voltage = voltage; 519 return ttusb_update_lnb(ttusb); 520 } 521 522 #ifdef TTUSB_TONE 523 static int ttusb_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone) 524 { 525 struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv; 526 527 ttusb->tone = tone; 528 return ttusb_update_lnb(ttusb); 529 } 530 #endif 531 532 533 #if 0 534 static void ttusb_set_led_freq(struct ttusb *ttusb, u8 freq) 535 { 536 u8 b[] = { 0xaa, ++ttusb->c, 0x19, 1, freq }; 537 int err, actual_len; 538 539 err = ttusb_cmd(ttusb, b, sizeof(b), 0); 540 if (err) { 541 dprintk("%s: usb_bulk_msg() failed, return value %i!\n", 542 __func__, err); 543 } 544 } 545 #endif 546 547 /*****************************************************************************/ 548 549 #ifdef TTUSB_HWSECTIONS 550 static void ttusb_handle_ts_data(struct ttusb_channel *channel, 551 const u8 * data, int len); 552 static void ttusb_handle_sec_data(struct ttusb_channel *channel, 553 const u8 * data, int len); 554 #endif 555 556 static int numpkt, numts, numstuff, numsec, numinvalid; 557 static unsigned long lastj; 558 559 static void ttusb_process_muxpack(struct ttusb *ttusb, const u8 * muxpack, 560 int len) 561 { 562 u16 csum = 0, cc; 563 int i; 564 565 if (len < 4 || len & 0x1) { 566 pr_warn("%s: muxpack has invalid len %d\n", __func__, len); 567 numinvalid++; 568 return; 569 } 570 571 for (i = 0; i < len; i += 2) 572 csum ^= le16_to_cpup((__le16 *) (muxpack + i)); 573 if (csum) { 574 printk("%s: muxpack with incorrect checksum, ignoring\n", 575 __func__); 576 numinvalid++; 577 return; 578 } 579 580 cc = (muxpack[len - 4] << 8) | muxpack[len - 3]; 581 cc &= 0x7FFF; 582 if ((cc != ttusb->cc) && (ttusb->cc != -1)) 583 printk("%s: cc discontinuity (%d frames missing)\n", 584 __func__, (cc - ttusb->cc) & 0x7FFF); 585 ttusb->cc = (cc + 1) & 0x7FFF; 586 if (muxpack[0] & 0x80) { 587 #ifdef TTUSB_HWSECTIONS 588 /* section data */ 589 int pusi = muxpack[0] & 0x40; 590 int channel = muxpack[0] & 0x1F; 591 int payload = muxpack[1]; 592 const u8 *data = muxpack + 2; 593 /* check offset flag */ 594 if (muxpack[0] & 0x20) 595 data++; 596 597 ttusb_handle_sec_data(ttusb->channel + channel, data, 598 payload); 599 data += payload; 600 601 if ((!!(ttusb->muxpack[0] & 0x20)) ^ 602 !!(ttusb->muxpack[1] & 1)) 603 data++; 604 #warning TODO: pusi 605 printk("cc: %04x\n", (data[0] << 8) | data[1]); 606 #endif 607 numsec++; 608 } else if (muxpack[0] == 0x47) { 609 #ifdef TTUSB_HWSECTIONS 610 /* we have TS data here! */ 611 int pid = ((muxpack[1] & 0x0F) << 8) | muxpack[2]; 612 int channel; 613 for (channel = 0; channel < TTUSB_MAXCHANNEL; ++channel) 614 if (ttusb->channel[channel].active 615 && (pid == ttusb->channel[channel].pid)) 616 ttusb_handle_ts_data(ttusb->channel + 617 channel, muxpack, 618 188); 619 #endif 620 numts++; 621 dvb_dmx_swfilter_packets(&ttusb->dvb_demux, muxpack, 1); 622 } else if (muxpack[0] != 0) { 623 numinvalid++; 624 printk("illegal muxpack type %02x\n", muxpack[0]); 625 } else 626 numstuff++; 627 } 628 629 static void ttusb_process_frame(struct ttusb *ttusb, u8 * data, int len) 630 { 631 int maxwork = 1024; 632 while (len) { 633 if (!(maxwork--)) { 634 printk("%s: too much work\n", __func__); 635 break; 636 } 637 638 switch (ttusb->mux_state) { 639 case 0: 640 case 1: 641 case 2: 642 len--; 643 if (*data++ == 0xAA) 644 ++ttusb->mux_state; 645 else { 646 ttusb->mux_state = 0; 647 if (ttusb->insync) { 648 dprintk("%s: %02x\n", 649 __func__, data[-1]); 650 printk(KERN_INFO "%s: lost sync.\n", 651 __func__); 652 ttusb->insync = 0; 653 } 654 } 655 break; 656 case 3: 657 ttusb->insync = 1; 658 len--; 659 ttusb->mux_npacks = *data++; 660 ++ttusb->mux_state; 661 ttusb->muxpack_ptr = 0; 662 /* maximum bytes, until we know the length */ 663 ttusb->muxpack_len = 2; 664 break; 665 case 4: 666 { 667 int avail; 668 avail = len; 669 if (avail > 670 (ttusb->muxpack_len - 671 ttusb->muxpack_ptr)) 672 avail = 673 ttusb->muxpack_len - 674 ttusb->muxpack_ptr; 675 memcpy(ttusb->muxpack + ttusb->muxpack_ptr, 676 data, avail); 677 ttusb->muxpack_ptr += avail; 678 BUG_ON(ttusb->muxpack_ptr > 264); 679 data += avail; 680 len -= avail; 681 /* determine length */ 682 if (ttusb->muxpack_ptr == 2) { 683 if (ttusb->muxpack[0] & 0x80) { 684 ttusb->muxpack_len = 685 ttusb->muxpack[1] + 2; 686 if (ttusb-> 687 muxpack[0] & 0x20) 688 ttusb-> 689 muxpack_len++; 690 if ((!! 691 (ttusb-> 692 muxpack[0] & 0x20)) ^ 693 !!(ttusb-> 694 muxpack[1] & 1)) 695 ttusb-> 696 muxpack_len++; 697 ttusb->muxpack_len += 4; 698 } else if (ttusb->muxpack[0] == 699 0x47) 700 ttusb->muxpack_len = 701 188 + 4; 702 else if (ttusb->muxpack[0] == 0x00) 703 ttusb->muxpack_len = 704 ttusb->muxpack[1] + 2 + 705 4; 706 else { 707 dprintk 708 ("%s: invalid state: first byte is %x\n", 709 __func__, 710 ttusb->muxpack[0]); 711 ttusb->mux_state = 0; 712 } 713 } 714 715 /** 716 * if length is valid and we reached the end: 717 * goto next muxpack 718 */ 719 if ((ttusb->muxpack_ptr >= 2) && 720 (ttusb->muxpack_ptr == 721 ttusb->muxpack_len)) { 722 ttusb_process_muxpack(ttusb, 723 ttusb-> 724 muxpack, 725 ttusb-> 726 muxpack_ptr); 727 ttusb->muxpack_ptr = 0; 728 /* maximum bytes, until we know the length */ 729 ttusb->muxpack_len = 2; 730 731 /** 732 * no muxpacks left? 733 * return to search-sync state 734 */ 735 if (!ttusb->mux_npacks--) { 736 ttusb->mux_state = 0; 737 break; 738 } 739 } 740 break; 741 } 742 default: 743 BUG(); 744 break; 745 } 746 } 747 } 748 749 static void ttusb_iso_irq(struct urb *urb) 750 { 751 struct ttusb *ttusb = urb->context; 752 struct usb_iso_packet_descriptor *d; 753 u8 *data; 754 int len, i; 755 756 if (!ttusb->iso_streaming) 757 return; 758 759 #if 0 760 printk("%s: status %d, errcount == %d, length == %i\n", 761 __func__, 762 urb->status, urb->error_count, urb->actual_length); 763 #endif 764 765 if (!urb->status) { 766 for (i = 0; i < urb->number_of_packets; ++i) { 767 numpkt++; 768 if (time_after_eq(jiffies, lastj + HZ)) { 769 dprintk("frames/s: %lu (ts: %d, stuff %d, " 770 "sec: %d, invalid: %d, all: %d)\n", 771 numpkt * HZ / (jiffies - lastj), 772 numts, numstuff, numsec, numinvalid, 773 numts + numstuff + numsec + numinvalid); 774 numts = numstuff = numsec = numinvalid = 0; 775 lastj = jiffies; 776 numpkt = 0; 777 } 778 d = &urb->iso_frame_desc[i]; 779 data = urb->transfer_buffer + d->offset; 780 len = d->actual_length; 781 d->actual_length = 0; 782 d->status = 0; 783 ttusb_process_frame(ttusb, data, len); 784 } 785 } 786 usb_submit_urb(urb, GFP_ATOMIC); 787 } 788 789 static void ttusb_free_iso_urbs(struct ttusb *ttusb) 790 { 791 int i; 792 793 for (i = 0; i < ISO_BUF_COUNT; i++) 794 if (ttusb->iso_urb[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_alloc_consistent(NULL, 808 ISO_FRAME_SIZE * 809 FRAMES_PER_ISO_BUF * 810 ISO_BUF_COUNT, 811 &ttusb->iso_dma_handle); 812 813 if (!ttusb->iso_buffer) { 814 dprintk("%s: pci_alloc_consistent - not enough memory\n", 815 __func__); 816 return -ENOMEM; 817 } 818 819 memset(ttusb->iso_buffer, 0, 820 ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF * ISO_BUF_COUNT); 821 822 for (i = 0; i < ISO_BUF_COUNT; i++) { 823 struct urb *urb; 824 825 if (! 826 (urb = 827 usb_alloc_urb(FRAMES_PER_ISO_BUF, GFP_ATOMIC))) { 828 ttusb_free_iso_urbs(ttusb); 829 return -ENOMEM; 830 } 831 832 ttusb->iso_urb[i] = urb; 833 } 834 835 return 0; 836 } 837 838 static void ttusb_stop_iso_xfer(struct ttusb *ttusb) 839 { 840 int i; 841 842 for (i = 0; i < ISO_BUF_COUNT; i++) 843 usb_kill_urb(ttusb->iso_urb[i]); 844 845 ttusb->iso_streaming = 0; 846 } 847 848 static int ttusb_start_iso_xfer(struct ttusb *ttusb) 849 { 850 int i, j, err, buffer_offset = 0; 851 852 if (ttusb->iso_streaming) { 853 printk("%s: iso xfer already running!\n", __func__); 854 return 0; 855 } 856 857 ttusb->cc = -1; 858 ttusb->insync = 0; 859 ttusb->mux_state = 0; 860 861 for (i = 0; i < ISO_BUF_COUNT; i++) { 862 int frame_offset = 0; 863 struct urb *urb = ttusb->iso_urb[i]; 864 865 urb->dev = ttusb->dev; 866 urb->context = ttusb; 867 urb->complete = ttusb_iso_irq; 868 urb->pipe = ttusb->isoc_in_pipe; 869 urb->transfer_flags = URB_ISO_ASAP; 870 urb->interval = 1; 871 urb->number_of_packets = FRAMES_PER_ISO_BUF; 872 urb->transfer_buffer_length = 873 ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF; 874 urb->transfer_buffer = ttusb->iso_buffer + buffer_offset; 875 buffer_offset += ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF; 876 877 for (j = 0; j < FRAMES_PER_ISO_BUF; j++) { 878 urb->iso_frame_desc[j].offset = frame_offset; 879 urb->iso_frame_desc[j].length = ISO_FRAME_SIZE; 880 frame_offset += ISO_FRAME_SIZE; 881 } 882 } 883 884 for (i = 0; i < ISO_BUF_COUNT; i++) { 885 if ((err = usb_submit_urb(ttusb->iso_urb[i], GFP_ATOMIC))) { 886 ttusb_stop_iso_xfer(ttusb); 887 printk 888 ("%s: failed urb submission (%i: err = %i)!\n", 889 __func__, i, err); 890 return err; 891 } 892 } 893 894 ttusb->iso_streaming = 1; 895 896 return 0; 897 } 898 899 #ifdef TTUSB_HWSECTIONS 900 static void ttusb_handle_ts_data(struct dvb_demux_feed *dvbdmxfeed, const u8 * data, 901 int len) 902 { 903 dvbdmxfeed->cb.ts(data, len, 0, 0, &dvbdmxfeed->feed.ts, 0); 904 } 905 906 static void ttusb_handle_sec_data(struct dvb_demux_feed *dvbdmxfeed, const u8 * data, 907 int len) 908 { 909 // struct dvb_demux_feed *dvbdmxfeed = channel->dvbdmxfeed; 910 #error TODO: handle ugly stuff 911 // dvbdmxfeed->cb.sec(data, len, 0, 0, &dvbdmxfeed->feed.sec, 0); 912 } 913 #endif 914 915 static int ttusb_start_feed(struct dvb_demux_feed *dvbdmxfeed) 916 { 917 struct ttusb *ttusb = (struct ttusb *) dvbdmxfeed->demux; 918 int feed_type = 1; 919 920 dprintk("ttusb_start_feed\n"); 921 922 switch (dvbdmxfeed->type) { 923 case DMX_TYPE_TS: 924 break; 925 case DMX_TYPE_SEC: 926 break; 927 default: 928 return -EINVAL; 929 } 930 931 if (dvbdmxfeed->type == DMX_TYPE_TS) { 932 switch (dvbdmxfeed->pes_type) { 933 case DMX_PES_VIDEO: 934 case DMX_PES_AUDIO: 935 case DMX_PES_TELETEXT: 936 case DMX_PES_PCR: 937 case DMX_PES_OTHER: 938 break; 939 default: 940 return -EINVAL; 941 } 942 } 943 944 #ifdef TTUSB_HWSECTIONS 945 #error TODO: allocate filters 946 if (dvbdmxfeed->type == DMX_TYPE_TS) { 947 feed_type = 1; 948 } else if (dvbdmxfeed->type == DMX_TYPE_SEC) { 949 feed_type = 2; 950 } 951 #endif 952 953 ttusb_set_channel(ttusb, dvbdmxfeed->index, feed_type, dvbdmxfeed->pid); 954 955 if (0 == ttusb->running_feed_count++) 956 ttusb_start_iso_xfer(ttusb); 957 958 return 0; 959 } 960 961 static int ttusb_stop_feed(struct dvb_demux_feed *dvbdmxfeed) 962 { 963 struct ttusb *ttusb = (struct ttusb *) dvbdmxfeed->demux; 964 965 ttusb_del_channel(ttusb, dvbdmxfeed->index); 966 967 if (--ttusb->running_feed_count == 0) 968 ttusb_stop_iso_xfer(ttusb); 969 970 return 0; 971 } 972 973 static int ttusb_setup_interfaces(struct ttusb *ttusb) 974 { 975 usb_set_interface(ttusb->dev, 1, 1); 976 977 ttusb->bulk_out_pipe = usb_sndbulkpipe(ttusb->dev, 1); 978 ttusb->bulk_in_pipe = usb_rcvbulkpipe(ttusb->dev, 1); 979 ttusb->isoc_in_pipe = usb_rcvisocpipe(ttusb->dev, 2); 980 981 return 0; 982 } 983 984 #if 0 985 static u8 stc_firmware[8192]; 986 987 static int stc_open(struct inode *inode, struct file *file) 988 { 989 struct ttusb *ttusb = file->private_data; 990 int addr; 991 992 for (addr = 0; addr < 8192; addr += 16) { 993 u8 snd_buf[2] = { addr >> 8, addr & 0xFF }; 994 ttusb_i2c_msg(ttusb, 0x50, snd_buf, 2, stc_firmware + addr, 995 16); 996 } 997 998 return 0; 999 } 1000 1001 static ssize_t stc_read(struct file *file, char *buf, size_t count, 1002 loff_t *offset) 1003 { 1004 return simple_read_from_buffer(buf, count, offset, stc_firmware, 8192); 1005 } 1006 1007 static int stc_release(struct inode *inode, struct file *file) 1008 { 1009 return 0; 1010 } 1011 1012 static const struct file_operations stc_fops = { 1013 .owner = THIS_MODULE, 1014 .read = stc_read, 1015 .open = stc_open, 1016 .release = stc_release, 1017 }; 1018 #endif 1019 1020 static u32 functionality(struct i2c_adapter *adapter) 1021 { 1022 return I2C_FUNC_I2C; 1023 } 1024 1025 1026 1027 static int alps_tdmb7_tuner_set_params(struct dvb_frontend *fe) 1028 { 1029 struct dtv_frontend_properties *p = &fe->dtv_property_cache; 1030 struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv; 1031 u8 data[4]; 1032 struct i2c_msg msg = {.addr=0x61, .flags=0, .buf=data, .len=sizeof(data) }; 1033 u32 div; 1034 1035 div = (p->frequency + 36166667) / 166667; 1036 1037 data[0] = (div >> 8) & 0x7f; 1038 data[1] = div & 0xff; 1039 data[2] = ((div >> 10) & 0x60) | 0x85; 1040 data[3] = p->frequency < 592000000 ? 0x40 : 0x80; 1041 1042 if (fe->ops.i2c_gate_ctrl) 1043 fe->ops.i2c_gate_ctrl(fe, 1); 1044 if (i2c_transfer(&ttusb->i2c_adap, &msg, 1) != 1) return -EIO; 1045 return 0; 1046 } 1047 1048 static struct cx22700_config alps_tdmb7_config = { 1049 .demod_address = 0x43, 1050 }; 1051 1052 1053 1054 1055 1056 static int philips_tdm1316l_tuner_init(struct dvb_frontend* fe) 1057 { 1058 struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv; 1059 static u8 td1316_init[] = { 0x0b, 0xf5, 0x85, 0xab }; 1060 static u8 disable_mc44BC374c[] = { 0x1d, 0x74, 0xa0, 0x68 }; 1061 struct i2c_msg tuner_msg = { .addr=0x60, .flags=0, .buf=td1316_init, .len=sizeof(td1316_init) }; 1062 1063 // setup PLL configuration 1064 if (fe->ops.i2c_gate_ctrl) 1065 fe->ops.i2c_gate_ctrl(fe, 1); 1066 if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1) return -EIO; 1067 msleep(1); 1068 1069 // disable the mc44BC374c (do not check for errors) 1070 tuner_msg.addr = 0x65; 1071 tuner_msg.buf = disable_mc44BC374c; 1072 tuner_msg.len = sizeof(disable_mc44BC374c); 1073 if (fe->ops.i2c_gate_ctrl) 1074 fe->ops.i2c_gate_ctrl(fe, 1); 1075 if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1) { 1076 i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1); 1077 } 1078 1079 return 0; 1080 } 1081 1082 static int philips_tdm1316l_tuner_set_params(struct dvb_frontend *fe) 1083 { 1084 struct dtv_frontend_properties *p = &fe->dtv_property_cache; 1085 struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv; 1086 u8 tuner_buf[4]; 1087 struct i2c_msg tuner_msg = {.addr=0x60, .flags=0, .buf=tuner_buf, .len=sizeof(tuner_buf) }; 1088 int tuner_frequency = 0; 1089 u8 band, cp, filter; 1090 1091 // determine charge pump 1092 tuner_frequency = p->frequency + 36130000; 1093 if (tuner_frequency < 87000000) return -EINVAL; 1094 else if (tuner_frequency < 130000000) cp = 3; 1095 else if (tuner_frequency < 160000000) cp = 5; 1096 else if (tuner_frequency < 200000000) cp = 6; 1097 else if (tuner_frequency < 290000000) cp = 3; 1098 else if (tuner_frequency < 420000000) cp = 5; 1099 else if (tuner_frequency < 480000000) cp = 6; 1100 else if (tuner_frequency < 620000000) cp = 3; 1101 else if (tuner_frequency < 830000000) cp = 5; 1102 else if (tuner_frequency < 895000000) cp = 7; 1103 else return -EINVAL; 1104 1105 // determine band 1106 if (p->frequency < 49000000) 1107 return -EINVAL; 1108 else if (p->frequency < 159000000) 1109 band = 1; 1110 else if (p->frequency < 444000000) 1111 band = 2; 1112 else if (p->frequency < 861000000) 1113 band = 4; 1114 else return -EINVAL; 1115 1116 // setup PLL filter 1117 switch (p->bandwidth_hz) { 1118 case 6000000: 1119 tda1004x_writereg(fe, 0x0C, 0); 1120 filter = 0; 1121 break; 1122 1123 case 7000000: 1124 tda1004x_writereg(fe, 0x0C, 0); 1125 filter = 0; 1126 break; 1127 1128 case 8000000: 1129 tda1004x_writereg(fe, 0x0C, 0xFF); 1130 filter = 1; 1131 break; 1132 1133 default: 1134 return -EINVAL; 1135 } 1136 1137 // calculate divisor 1138 // ((36130000+((1000000/6)/2)) + Finput)/(1000000/6) 1139 tuner_frequency = (((p->frequency / 1000) * 6) + 217280) / 1000; 1140 1141 // setup tuner buffer 1142 tuner_buf[0] = tuner_frequency >> 8; 1143 tuner_buf[1] = tuner_frequency & 0xff; 1144 tuner_buf[2] = 0xca; 1145 tuner_buf[3] = (cp << 5) | (filter << 3) | band; 1146 1147 if (fe->ops.i2c_gate_ctrl) 1148 fe->ops.i2c_gate_ctrl(fe, 1); 1149 if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1) 1150 return -EIO; 1151 1152 msleep(1); 1153 return 0; 1154 } 1155 1156 static int philips_tdm1316l_request_firmware(struct dvb_frontend* fe, const struct firmware **fw, char* name) 1157 { 1158 struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv; 1159 1160 return request_firmware(fw, name, &ttusb->dev->dev); 1161 } 1162 1163 static struct tda1004x_config philips_tdm1316l_config = { 1164 1165 .demod_address = 0x8, 1166 .invert = 1, 1167 .invert_oclk = 0, 1168 .request_firmware = philips_tdm1316l_request_firmware, 1169 }; 1170 1171 static u8 alps_bsbe1_inittab[] = { 1172 0x01, 0x15, 1173 0x02, 0x30, 1174 0x03, 0x00, 1175 0x04, 0x7d, /* F22FR = 0x7d, F22 = f_VCO / 128 / 0x7d = 22 kHz */ 1176 0x05, 0x35, /* I2CT = 0, SCLT = 1, SDAT = 1 */ 1177 0x06, 0x40, /* DAC not used, set to high impendance mode */ 1178 0x07, 0x00, /* DAC LSB */ 1179 0x08, 0x40, /* DiSEqC off, LNB power on OP2/LOCK pin on */ 1180 0x09, 0x00, /* FIFO */ 1181 0x0c, 0x51, /* OP1 ctl = Normal, OP1 val = 1 (LNB Power ON) */ 1182 0x0d, 0x82, /* DC offset compensation = ON, beta_agc1 = 2 */ 1183 0x0e, 0x23, /* alpha_tmg = 2, beta_tmg = 3 */ 1184 0x10, 0x3f, // AGC2 0x3d 1185 0x11, 0x84, 1186 0x12, 0xb9, 1187 0x15, 0xc9, // lock detector threshold 1188 0x16, 0x00, 1189 0x17, 0x00, 1190 0x18, 0x00, 1191 0x19, 0x00, 1192 0x1a, 0x00, 1193 0x1f, 0x50, 1194 0x20, 0x00, 1195 0x21, 0x00, 1196 0x22, 0x00, 1197 0x23, 0x00, 1198 0x28, 0x00, // out imp: normal out type: parallel FEC mode:0 1199 0x29, 0x1e, // 1/2 threshold 1200 0x2a, 0x14, // 2/3 threshold 1201 0x2b, 0x0f, // 3/4 threshold 1202 0x2c, 0x09, // 5/6 threshold 1203 0x2d, 0x05, // 7/8 threshold 1204 0x2e, 0x01, 1205 0x31, 0x1f, // test all FECs 1206 0x32, 0x19, // viterbi and synchro search 1207 0x33, 0xfc, // rs control 1208 0x34, 0x93, // error control 1209 0x0f, 0x92, 1210 0xff, 0xff 1211 }; 1212 1213 static u8 alps_bsru6_inittab[] = { 1214 0x01, 0x15, 1215 0x02, 0x30, 1216 0x03, 0x00, 1217 0x04, 0x7d, /* F22FR = 0x7d, F22 = f_VCO / 128 / 0x7d = 22 kHz */ 1218 0x05, 0x35, /* I2CT = 0, SCLT = 1, SDAT = 1 */ 1219 0x06, 0x40, /* DAC not used, set to high impendance mode */ 1220 0x07, 0x00, /* DAC LSB */ 1221 0x08, 0x40, /* DiSEqC off, LNB power on OP2/LOCK pin on */ 1222 0x09, 0x00, /* FIFO */ 1223 0x0c, 0x51, /* OP1 ctl = Normal, OP1 val = 1 (LNB Power ON) */ 1224 0x0d, 0x82, /* DC offset compensation = ON, beta_agc1 = 2 */ 1225 0x0e, 0x23, /* alpha_tmg = 2, beta_tmg = 3 */ 1226 0x10, 0x3f, // AGC2 0x3d 1227 0x11, 0x84, 1228 0x12, 0xb9, 1229 0x15, 0xc9, // lock detector threshold 1230 0x16, 0x00, 1231 0x17, 0x00, 1232 0x18, 0x00, 1233 0x19, 0x00, 1234 0x1a, 0x00, 1235 0x1f, 0x50, 1236 0x20, 0x00, 1237 0x21, 0x00, 1238 0x22, 0x00, 1239 0x23, 0x00, 1240 0x28, 0x00, // out imp: normal out type: parallel FEC mode:0 1241 0x29, 0x1e, // 1/2 threshold 1242 0x2a, 0x14, // 2/3 threshold 1243 0x2b, 0x0f, // 3/4 threshold 1244 0x2c, 0x09, // 5/6 threshold 1245 0x2d, 0x05, // 7/8 threshold 1246 0x2e, 0x01, 1247 0x31, 0x1f, // test all FECs 1248 0x32, 0x19, // viterbi and synchro search 1249 0x33, 0xfc, // rs control 1250 0x34, 0x93, // error control 1251 0x0f, 0x52, 1252 0xff, 0xff 1253 }; 1254 1255 static int alps_stv0299_set_symbol_rate(struct dvb_frontend *fe, u32 srate, u32 ratio) 1256 { 1257 u8 aclk = 0; 1258 u8 bclk = 0; 1259 1260 if (srate < 1500000) { 1261 aclk = 0xb7; 1262 bclk = 0x47; 1263 } else if (srate < 3000000) { 1264 aclk = 0xb7; 1265 bclk = 0x4b; 1266 } else if (srate < 7000000) { 1267 aclk = 0xb7; 1268 bclk = 0x4f; 1269 } else if (srate < 14000000) { 1270 aclk = 0xb7; 1271 bclk = 0x53; 1272 } else if (srate < 30000000) { 1273 aclk = 0xb6; 1274 bclk = 0x53; 1275 } else if (srate < 45000000) { 1276 aclk = 0xb4; 1277 bclk = 0x51; 1278 } 1279 1280 stv0299_writereg(fe, 0x13, aclk); 1281 stv0299_writereg(fe, 0x14, bclk); 1282 stv0299_writereg(fe, 0x1f, (ratio >> 16) & 0xff); 1283 stv0299_writereg(fe, 0x20, (ratio >> 8) & 0xff); 1284 stv0299_writereg(fe, 0x21, (ratio) & 0xf0); 1285 1286 return 0; 1287 } 1288 1289 static int philips_tsa5059_tuner_set_params(struct dvb_frontend *fe) 1290 { 1291 struct dtv_frontend_properties *p = &fe->dtv_property_cache; 1292 struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv; 1293 u8 buf[4]; 1294 u32 div; 1295 struct i2c_msg msg = {.addr = 0x61,.flags = 0,.buf = buf,.len = sizeof(buf) }; 1296 1297 if ((p->frequency < 950000) || (p->frequency > 2150000)) 1298 return -EINVAL; 1299 1300 div = (p->frequency + (125 - 1)) / 125; /* round correctly */ 1301 buf[0] = (div >> 8) & 0x7f; 1302 buf[1] = div & 0xff; 1303 buf[2] = 0x80 | ((div & 0x18000) >> 10) | 4; 1304 buf[3] = 0xC4; 1305 1306 if (p->frequency > 1530000) 1307 buf[3] = 0xC0; 1308 1309 /* BSBE1 wants XCE bit set */ 1310 if (ttusb->revision == TTUSB_REV_2_2) 1311 buf[3] |= 0x20; 1312 1313 if (fe->ops.i2c_gate_ctrl) 1314 fe->ops.i2c_gate_ctrl(fe, 1); 1315 if (i2c_transfer(&ttusb->i2c_adap, &msg, 1) != 1) 1316 return -EIO; 1317 1318 return 0; 1319 } 1320 1321 static struct stv0299_config alps_stv0299_config = { 1322 .demod_address = 0x68, 1323 .inittab = alps_bsru6_inittab, 1324 .mclk = 88000000UL, 1325 .invert = 1, 1326 .skip_reinit = 0, 1327 .lock_output = STV0299_LOCKOUTPUT_1, 1328 .volt13_op0_op1 = STV0299_VOLT13_OP1, 1329 .min_delay_ms = 100, 1330 .set_symbol_rate = alps_stv0299_set_symbol_rate, 1331 }; 1332 1333 static int ttusb_novas_grundig_29504_491_tuner_set_params(struct dvb_frontend *fe) 1334 { 1335 struct dtv_frontend_properties *p = &fe->dtv_property_cache; 1336 struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv; 1337 u8 buf[4]; 1338 u32 div; 1339 struct i2c_msg msg = {.addr = 0x61,.flags = 0,.buf = buf,.len = sizeof(buf) }; 1340 1341 div = p->frequency / 125; 1342 1343 buf[0] = (div >> 8) & 0x7f; 1344 buf[1] = div & 0xff; 1345 buf[2] = 0x8e; 1346 buf[3] = 0x00; 1347 1348 if (fe->ops.i2c_gate_ctrl) 1349 fe->ops.i2c_gate_ctrl(fe, 1); 1350 if (i2c_transfer(&ttusb->i2c_adap, &msg, 1) != 1) 1351 return -EIO; 1352 1353 return 0; 1354 } 1355 1356 static struct tda8083_config ttusb_novas_grundig_29504_491_config = { 1357 1358 .demod_address = 0x68, 1359 }; 1360 1361 static int alps_tdbe2_tuner_set_params(struct dvb_frontend *fe) 1362 { 1363 struct dtv_frontend_properties *p = &fe->dtv_property_cache; 1364 struct ttusb* ttusb = fe->dvb->priv; 1365 u32 div; 1366 u8 data[4]; 1367 struct i2c_msg msg = { .addr = 0x62, .flags = 0, .buf = data, .len = sizeof(data) }; 1368 1369 div = (p->frequency + 35937500 + 31250) / 62500; 1370 1371 data[0] = (div >> 8) & 0x7f; 1372 data[1] = div & 0xff; 1373 data[2] = 0x85 | ((div >> 10) & 0x60); 1374 data[3] = (p->frequency < 174000000 ? 0x88 : p->frequency < 470000000 ? 0x84 : 0x81); 1375 1376 if (fe->ops.i2c_gate_ctrl) 1377 fe->ops.i2c_gate_ctrl(fe, 1); 1378 if (i2c_transfer (&ttusb->i2c_adap, &msg, 1) != 1) 1379 return -EIO; 1380 1381 return 0; 1382 } 1383 1384 1385 static struct ves1820_config alps_tdbe2_config = { 1386 .demod_address = 0x09, 1387 .xin = 57840000UL, 1388 .invert = 1, 1389 .selagc = VES1820_SELAGC_SIGNAMPERR, 1390 }; 1391 1392 static u8 read_pwm(struct ttusb* ttusb) 1393 { 1394 u8 b = 0xff; 1395 u8 pwm; 1396 struct i2c_msg msg[] = { { .addr = 0x50,.flags = 0,.buf = &b,.len = 1 }, 1397 { .addr = 0x50,.flags = I2C_M_RD,.buf = &pwm,.len = 1} }; 1398 1399 if ((i2c_transfer(&ttusb->i2c_adap, msg, 2) != 2) || (pwm == 0xff)) 1400 pwm = 0x48; 1401 1402 return pwm; 1403 } 1404 1405 1406 static int dvbc_philips_tdm1316l_tuner_set_params(struct dvb_frontend *fe) 1407 { 1408 struct dtv_frontend_properties *p = &fe->dtv_property_cache; 1409 struct ttusb *ttusb = (struct ttusb *) fe->dvb->priv; 1410 u8 tuner_buf[5]; 1411 struct i2c_msg tuner_msg = {.addr = 0x60, 1412 .flags = 0, 1413 .buf = tuner_buf, 1414 .len = sizeof(tuner_buf) }; 1415 int tuner_frequency = 0; 1416 u8 band, cp, filter; 1417 1418 // determine charge pump 1419 tuner_frequency = p->frequency; 1420 if (tuner_frequency < 87000000) {return -EINVAL;} 1421 else if (tuner_frequency < 130000000) {cp = 3; band = 1;} 1422 else if (tuner_frequency < 160000000) {cp = 5; band = 1;} 1423 else if (tuner_frequency < 200000000) {cp = 6; band = 1;} 1424 else if (tuner_frequency < 290000000) {cp = 3; band = 2;} 1425 else if (tuner_frequency < 420000000) {cp = 5; band = 2;} 1426 else if (tuner_frequency < 480000000) {cp = 6; band = 2;} 1427 else if (tuner_frequency < 620000000) {cp = 3; band = 4;} 1428 else if (tuner_frequency < 830000000) {cp = 5; band = 4;} 1429 else if (tuner_frequency < 895000000) {cp = 7; band = 4;} 1430 else {return -EINVAL;} 1431 1432 // assume PLL filter should always be 8MHz for the moment. 1433 filter = 1; 1434 1435 // calculate divisor 1436 // (Finput + Fif)/Fref; Fif = 36125000 Hz, Fref = 62500 Hz 1437 tuner_frequency = ((p->frequency + 36125000) / 62500); 1438 1439 // setup tuner buffer 1440 tuner_buf[0] = tuner_frequency >> 8; 1441 tuner_buf[1] = tuner_frequency & 0xff; 1442 tuner_buf[2] = 0xc8; 1443 tuner_buf[3] = (cp << 5) | (filter << 3) | band; 1444 tuner_buf[4] = 0x80; 1445 1446 if (fe->ops.i2c_gate_ctrl) 1447 fe->ops.i2c_gate_ctrl(fe, 1); 1448 if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1) { 1449 printk("dvb-ttusb-budget: dvbc_philips_tdm1316l_pll_set Error 1\n"); 1450 return -EIO; 1451 } 1452 1453 msleep(50); 1454 1455 if (fe->ops.i2c_gate_ctrl) 1456 fe->ops.i2c_gate_ctrl(fe, 1); 1457 if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1) { 1458 printk("dvb-ttusb-budget: dvbc_philips_tdm1316l_pll_set Error 2\n"); 1459 return -EIO; 1460 } 1461 1462 msleep(1); 1463 1464 return 0; 1465 } 1466 1467 static u8 dvbc_philips_tdm1316l_inittab[] = { 1468 0x80, 0x21, 1469 0x80, 0x20, 1470 0x81, 0x01, 1471 0x81, 0x00, 1472 0x00, 0x09, 1473 0x01, 0x69, 1474 0x03, 0x00, 1475 0x04, 0x00, 1476 0x07, 0x00, 1477 0x08, 0x00, 1478 0x20, 0x00, 1479 0x21, 0x40, 1480 0x22, 0x00, 1481 0x23, 0x00, 1482 0x24, 0x40, 1483 0x25, 0x88, 1484 0x30, 0xff, 1485 0x31, 0x00, 1486 0x32, 0xff, 1487 0x33, 0x00, 1488 0x34, 0x50, 1489 0x35, 0x7f, 1490 0x36, 0x00, 1491 0x37, 0x20, 1492 0x38, 0x00, 1493 0x40, 0x1c, 1494 0x41, 0xff, 1495 0x42, 0x29, 1496 0x43, 0x20, 1497 0x44, 0xff, 1498 0x45, 0x00, 1499 0x46, 0x00, 1500 0x49, 0x04, 1501 0x4a, 0xff, 1502 0x4b, 0x7f, 1503 0x52, 0x30, 1504 0x55, 0xae, 1505 0x56, 0x47, 1506 0x57, 0xe1, 1507 0x58, 0x3a, 1508 0x5a, 0x1e, 1509 0x5b, 0x34, 1510 0x60, 0x00, 1511 0x63, 0x00, 1512 0x64, 0x00, 1513 0x65, 0x00, 1514 0x66, 0x00, 1515 0x67, 0x00, 1516 0x68, 0x00, 1517 0x69, 0x00, 1518 0x6a, 0x02, 1519 0x6b, 0x00, 1520 0x70, 0xff, 1521 0x71, 0x00, 1522 0x72, 0x00, 1523 0x73, 0x00, 1524 0x74, 0x0c, 1525 0x80, 0x00, 1526 0x81, 0x00, 1527 0x82, 0x00, 1528 0x83, 0x00, 1529 0x84, 0x04, 1530 0x85, 0x80, 1531 0x86, 0x24, 1532 0x87, 0x78, 1533 0x88, 0x00, 1534 0x89, 0x00, 1535 0x90, 0x01, 1536 0x91, 0x01, 1537 0xa0, 0x00, 1538 0xa1, 0x00, 1539 0xa2, 0x00, 1540 0xb0, 0x91, 1541 0xb1, 0x0b, 1542 0xc0, 0x4b, 1543 0xc1, 0x00, 1544 0xc2, 0x00, 1545 0xd0, 0x00, 1546 0xd1, 0x00, 1547 0xd2, 0x00, 1548 0xd3, 0x00, 1549 0xd4, 0x00, 1550 0xd5, 0x00, 1551 0xde, 0x00, 1552 0xdf, 0x00, 1553 0x61, 0x38, 1554 0x62, 0x0a, 1555 0x53, 0x13, 1556 0x59, 0x08, 1557 0x55, 0x00, 1558 0x56, 0x40, 1559 0x57, 0x08, 1560 0x58, 0x3d, 1561 0x88, 0x10, 1562 0xa0, 0x00, 1563 0xa0, 0x00, 1564 0xa0, 0x00, 1565 0xa0, 0x04, 1566 0xff, 0xff, 1567 }; 1568 1569 static struct stv0297_config dvbc_philips_tdm1316l_config = { 1570 .demod_address = 0x1c, 1571 .inittab = dvbc_philips_tdm1316l_inittab, 1572 .invert = 0, 1573 }; 1574 1575 static void frontend_init(struct ttusb* ttusb) 1576 { 1577 switch(le16_to_cpu(ttusb->dev->descriptor.idProduct)) { 1578 case 0x1003: // Hauppauge/TT Nova-USB-S budget (stv0299/ALPS BSRU6|BSBE1(tsa5059)) 1579 // try the stv0299 based first 1580 ttusb->fe = dvb_attach(stv0299_attach, &alps_stv0299_config, &ttusb->i2c_adap); 1581 if (ttusb->fe != NULL) { 1582 ttusb->fe->ops.tuner_ops.set_params = philips_tsa5059_tuner_set_params; 1583 1584 if(ttusb->revision == TTUSB_REV_2_2) { // ALPS BSBE1 1585 alps_stv0299_config.inittab = alps_bsbe1_inittab; 1586 dvb_attach(lnbp21_attach, ttusb->fe, &ttusb->i2c_adap, 0, 0); 1587 } else { // ALPS BSRU6 1588 ttusb->fe->ops.set_voltage = ttusb_set_voltage; 1589 } 1590 break; 1591 } 1592 1593 // Grundig 29504-491 1594 ttusb->fe = dvb_attach(tda8083_attach, &ttusb_novas_grundig_29504_491_config, &ttusb->i2c_adap); 1595 if (ttusb->fe != NULL) { 1596 ttusb->fe->ops.tuner_ops.set_params = ttusb_novas_grundig_29504_491_tuner_set_params; 1597 ttusb->fe->ops.set_voltage = ttusb_set_voltage; 1598 break; 1599 } 1600 break; 1601 1602 case 0x1004: // Hauppauge/TT DVB-C budget (ves1820/ALPS TDBE2(sp5659)) 1603 ttusb->fe = dvb_attach(ves1820_attach, &alps_tdbe2_config, &ttusb->i2c_adap, read_pwm(ttusb)); 1604 if (ttusb->fe != NULL) { 1605 ttusb->fe->ops.tuner_ops.set_params = alps_tdbe2_tuner_set_params; 1606 break; 1607 } 1608 1609 ttusb->fe = dvb_attach(stv0297_attach, &dvbc_philips_tdm1316l_config, &ttusb->i2c_adap); 1610 if (ttusb->fe != NULL) { 1611 ttusb->fe->ops.tuner_ops.set_params = dvbc_philips_tdm1316l_tuner_set_params; 1612 break; 1613 } 1614 break; 1615 1616 case 0x1005: // Hauppauge/TT Nova-USB-t budget (tda10046/Philips td1316(tda6651tt) OR cx22700/ALPS TDMB7(??)) 1617 // try the ALPS TDMB7 first 1618 ttusb->fe = dvb_attach(cx22700_attach, &alps_tdmb7_config, &ttusb->i2c_adap); 1619 if (ttusb->fe != NULL) { 1620 ttusb->fe->ops.tuner_ops.set_params = alps_tdmb7_tuner_set_params; 1621 break; 1622 } 1623 1624 // Philips td1316 1625 ttusb->fe = dvb_attach(tda10046_attach, &philips_tdm1316l_config, &ttusb->i2c_adap); 1626 if (ttusb->fe != NULL) { 1627 ttusb->fe->ops.tuner_ops.init = philips_tdm1316l_tuner_init; 1628 ttusb->fe->ops.tuner_ops.set_params = philips_tdm1316l_tuner_set_params; 1629 break; 1630 } 1631 break; 1632 } 1633 1634 if (ttusb->fe == NULL) { 1635 printk("dvb-ttusb-budget: A frontend driver was not found for device [%04x:%04x]\n", 1636 le16_to_cpu(ttusb->dev->descriptor.idVendor), 1637 le16_to_cpu(ttusb->dev->descriptor.idProduct)); 1638 } else { 1639 if (dvb_register_frontend(&ttusb->adapter, ttusb->fe)) { 1640 printk("dvb-ttusb-budget: Frontend registration failed!\n"); 1641 dvb_frontend_detach(ttusb->fe); 1642 ttusb->fe = NULL; 1643 } 1644 } 1645 } 1646 1647 1648 1649 static struct i2c_algorithm ttusb_dec_algo = { 1650 .master_xfer = master_xfer, 1651 .functionality = functionality, 1652 }; 1653 1654 static int ttusb_probe(struct usb_interface *intf, const struct usb_device_id *id) 1655 { 1656 struct usb_device *udev; 1657 struct ttusb *ttusb; 1658 int result; 1659 1660 dprintk("%s: TTUSB DVB connected\n", __func__); 1661 1662 udev = interface_to_usbdev(intf); 1663 1664 if (intf->altsetting->desc.bInterfaceNumber != 1) return -ENODEV; 1665 1666 if (!(ttusb = kzalloc(sizeof(struct ttusb), GFP_KERNEL))) 1667 return -ENOMEM; 1668 1669 ttusb->dev = udev; 1670 ttusb->c = 0; 1671 ttusb->mux_state = 0; 1672 mutex_init(&ttusb->semi2c); 1673 1674 mutex_lock(&ttusb->semi2c); 1675 1676 mutex_init(&ttusb->semusb); 1677 1678 ttusb_setup_interfaces(ttusb); 1679 1680 result = ttusb_alloc_iso_urbs(ttusb); 1681 if (result < 0) { 1682 dprintk("%s: ttusb_alloc_iso_urbs - failed\n", __func__); 1683 mutex_unlock(&ttusb->semi2c); 1684 kfree(ttusb); 1685 return result; 1686 } 1687 1688 if (ttusb_init_controller(ttusb)) 1689 printk("ttusb_init_controller: error\n"); 1690 1691 mutex_unlock(&ttusb->semi2c); 1692 1693 result = dvb_register_adapter(&ttusb->adapter, 1694 "Technotrend/Hauppauge Nova-USB", 1695 THIS_MODULE, &udev->dev, adapter_nr); 1696 if (result < 0) { 1697 ttusb_free_iso_urbs(ttusb); 1698 kfree(ttusb); 1699 return result; 1700 } 1701 ttusb->adapter.priv = ttusb; 1702 1703 /* i2c */ 1704 memset(&ttusb->i2c_adap, 0, sizeof(struct i2c_adapter)); 1705 strcpy(ttusb->i2c_adap.name, "TTUSB DEC"); 1706 1707 i2c_set_adapdata(&ttusb->i2c_adap, ttusb); 1708 1709 ttusb->i2c_adap.algo = &ttusb_dec_algo; 1710 ttusb->i2c_adap.algo_data = NULL; 1711 ttusb->i2c_adap.dev.parent = &udev->dev; 1712 1713 result = i2c_add_adapter(&ttusb->i2c_adap); 1714 if (result) 1715 goto err_unregister_adapter; 1716 1717 memset(&ttusb->dvb_demux, 0, sizeof(ttusb->dvb_demux)); 1718 1719 ttusb->dvb_demux.dmx.capabilities = 1720 DMX_TS_FILTERING | DMX_SECTION_FILTERING; 1721 ttusb->dvb_demux.priv = NULL; 1722 #ifdef TTUSB_HWSECTIONS 1723 ttusb->dvb_demux.filternum = TTUSB_MAXFILTER; 1724 #else 1725 ttusb->dvb_demux.filternum = 32; 1726 #endif 1727 ttusb->dvb_demux.feednum = TTUSB_MAXCHANNEL; 1728 ttusb->dvb_demux.start_feed = ttusb_start_feed; 1729 ttusb->dvb_demux.stop_feed = ttusb_stop_feed; 1730 ttusb->dvb_demux.write_to_decoder = NULL; 1731 1732 result = dvb_dmx_init(&ttusb->dvb_demux); 1733 if (result < 0) { 1734 printk("ttusb_dvb: dvb_dmx_init failed (errno = %d)\n", result); 1735 result = -ENODEV; 1736 goto err_i2c_del_adapter; 1737 } 1738 //FIXME dmxdev (nur WAS?) 1739 ttusb->dmxdev.filternum = ttusb->dvb_demux.filternum; 1740 ttusb->dmxdev.demux = &ttusb->dvb_demux.dmx; 1741 ttusb->dmxdev.capabilities = 0; 1742 1743 result = dvb_dmxdev_init(&ttusb->dmxdev, &ttusb->adapter); 1744 if (result < 0) { 1745 printk("ttusb_dvb: dvb_dmxdev_init failed (errno = %d)\n", 1746 result); 1747 result = -ENODEV; 1748 goto err_release_dmx; 1749 } 1750 1751 if (dvb_net_init(&ttusb->adapter, &ttusb->dvbnet, &ttusb->dvb_demux.dmx)) { 1752 printk("ttusb_dvb: dvb_net_init failed!\n"); 1753 result = -ENODEV; 1754 goto err_release_dmxdev; 1755 } 1756 1757 usb_set_intfdata(intf, (void *) ttusb); 1758 1759 frontend_init(ttusb); 1760 1761 return 0; 1762 1763 err_release_dmxdev: 1764 dvb_dmxdev_release(&ttusb->dmxdev); 1765 err_release_dmx: 1766 dvb_dmx_release(&ttusb->dvb_demux); 1767 err_i2c_del_adapter: 1768 i2c_del_adapter(&ttusb->i2c_adap); 1769 err_unregister_adapter: 1770 dvb_unregister_adapter (&ttusb->adapter); 1771 ttusb_free_iso_urbs(ttusb); 1772 kfree(ttusb); 1773 return result; 1774 } 1775 1776 static void ttusb_disconnect(struct usb_interface *intf) 1777 { 1778 struct ttusb *ttusb = usb_get_intfdata(intf); 1779 1780 usb_set_intfdata(intf, NULL); 1781 1782 ttusb->disconnecting = 1; 1783 1784 ttusb_stop_iso_xfer(ttusb); 1785 1786 ttusb->dvb_demux.dmx.close(&ttusb->dvb_demux.dmx); 1787 dvb_net_release(&ttusb->dvbnet); 1788 dvb_dmxdev_release(&ttusb->dmxdev); 1789 dvb_dmx_release(&ttusb->dvb_demux); 1790 if (ttusb->fe != NULL) { 1791 dvb_unregister_frontend(ttusb->fe); 1792 dvb_frontend_detach(ttusb->fe); 1793 } 1794 i2c_del_adapter(&ttusb->i2c_adap); 1795 dvb_unregister_adapter(&ttusb->adapter); 1796 1797 ttusb_free_iso_urbs(ttusb); 1798 1799 kfree(ttusb); 1800 1801 dprintk("%s: TTUSB DVB disconnected\n", __func__); 1802 } 1803 1804 static struct usb_device_id ttusb_table[] = { 1805 {USB_DEVICE(0xb48, 0x1003)}, 1806 {USB_DEVICE(0xb48, 0x1004)}, 1807 {USB_DEVICE(0xb48, 0x1005)}, 1808 {} 1809 }; 1810 1811 MODULE_DEVICE_TABLE(usb, ttusb_table); 1812 1813 static struct usb_driver ttusb_driver = { 1814 .name = "ttusb", 1815 .probe = ttusb_probe, 1816 .disconnect = ttusb_disconnect, 1817 .id_table = ttusb_table, 1818 }; 1819 1820 module_usb_driver(ttusb_driver); 1821 1822 MODULE_AUTHOR("Holger Waechtler <holger@convergence.de>"); 1823 MODULE_DESCRIPTION("TTUSB DVB Driver"); 1824 MODULE_LICENSE("GPL"); 1825 MODULE_FIRMWARE("ttusb-budget/dspbootcode.bin"); 1826