1 /* 2 * TTUSB DEC Driver 3 * 4 * Copyright (C) 2003-2004 Alex Woods <linux-dvb@giblets.org> 5 * IR support by Peter Beutner <p.beutner@gmx.net> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2 of the License, or 10 * (at your option) any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 * 21 */ 22 23 #include <linux/list.h> 24 #include <linux/module.h> 25 #include <linux/pci.h> 26 #include <linux/slab.h> 27 #include <linux/spinlock.h> 28 #include <linux/usb.h> 29 #include <linux/interrupt.h> 30 #include <linux/firmware.h> 31 #include <linux/crc32.h> 32 #include <linux/init.h> 33 #include <linux/input.h> 34 35 #include <linux/mutex.h> 36 37 #include "dmxdev.h" 38 #include "dvb_demux.h" 39 #include "dvb_filter.h" 40 #include "dvb_frontend.h" 41 #include "dvb_net.h" 42 #include "ttusbdecfe.h" 43 44 static int debug; 45 static int output_pva; 46 static int enable_rc; 47 48 module_param(debug, int, 0644); 49 MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off)."); 50 module_param(output_pva, int, 0444); 51 MODULE_PARM_DESC(output_pva, "Output PVA from dvr device (default:off)"); 52 module_param(enable_rc, int, 0644); 53 MODULE_PARM_DESC(enable_rc, "Turn on/off IR remote control(default: off)"); 54 55 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); 56 57 #define dprintk if (debug) printk 58 59 #define DRIVER_NAME "TechnoTrend/Hauppauge DEC USB" 60 61 #define COMMAND_PIPE 0x03 62 #define RESULT_PIPE 0x04 63 #define IN_PIPE 0x08 64 #define OUT_PIPE 0x07 65 #define IRQ_PIPE 0x0A 66 67 #define COMMAND_PACKET_SIZE 0x3c 68 #define ARM_PACKET_SIZE 0x1000 69 #define IRQ_PACKET_SIZE 0x8 70 71 #define ISO_BUF_COUNT 0x04 72 #define FRAMES_PER_ISO_BUF 0x04 73 #define ISO_FRAME_SIZE 0x0380 74 75 #define MAX_PVA_LENGTH 6144 76 77 enum ttusb_dec_model { 78 TTUSB_DEC2000T, 79 TTUSB_DEC2540T, 80 TTUSB_DEC3000S 81 }; 82 83 enum ttusb_dec_packet_type { 84 TTUSB_DEC_PACKET_PVA, 85 TTUSB_DEC_PACKET_SECTION, 86 TTUSB_DEC_PACKET_EMPTY 87 }; 88 89 enum ttusb_dec_interface { 90 TTUSB_DEC_INTERFACE_INITIAL, 91 TTUSB_DEC_INTERFACE_IN, 92 TTUSB_DEC_INTERFACE_OUT 93 }; 94 95 struct ttusb_dec { 96 enum ttusb_dec_model model; 97 char *model_name; 98 char *firmware_name; 99 int can_playback; 100 101 /* DVB bits */ 102 struct dvb_adapter adapter; 103 struct dmxdev dmxdev; 104 struct dvb_demux demux; 105 struct dmx_frontend frontend; 106 struct dvb_net dvb_net; 107 struct dvb_frontend* fe; 108 109 u16 pid[DMX_PES_OTHER]; 110 111 /* USB bits */ 112 struct usb_device *udev; 113 u8 trans_count; 114 unsigned int command_pipe; 115 unsigned int result_pipe; 116 unsigned int in_pipe; 117 unsigned int out_pipe; 118 unsigned int irq_pipe; 119 enum ttusb_dec_interface interface; 120 struct mutex usb_mutex; 121 122 void *irq_buffer; 123 struct urb *irq_urb; 124 dma_addr_t irq_dma_handle; 125 void *iso_buffer; 126 dma_addr_t iso_dma_handle; 127 struct urb *iso_urb[ISO_BUF_COUNT]; 128 int iso_stream_count; 129 struct mutex iso_mutex; 130 131 u8 packet[MAX_PVA_LENGTH + 4]; 132 enum ttusb_dec_packet_type packet_type; 133 int packet_state; 134 int packet_length; 135 int packet_payload_length; 136 u16 next_packet_id; 137 138 int pva_stream_count; 139 int filter_stream_count; 140 141 struct dvb_filter_pes2ts a_pes2ts; 142 struct dvb_filter_pes2ts v_pes2ts; 143 144 u8 v_pes[16 + MAX_PVA_LENGTH]; 145 int v_pes_length; 146 int v_pes_postbytes; 147 148 struct list_head urb_frame_list; 149 struct tasklet_struct urb_tasklet; 150 spinlock_t urb_frame_list_lock; 151 152 struct dvb_demux_filter *audio_filter; 153 struct dvb_demux_filter *video_filter; 154 struct list_head filter_info_list; 155 spinlock_t filter_info_list_lock; 156 157 struct input_dev *rc_input_dev; 158 char rc_phys[64]; 159 160 int active; /* Loaded successfully */ 161 }; 162 163 struct urb_frame { 164 u8 data[ISO_FRAME_SIZE]; 165 int length; 166 struct list_head urb_frame_list; 167 }; 168 169 struct filter_info { 170 u8 stream_id; 171 struct dvb_demux_filter *filter; 172 struct list_head filter_info_list; 173 }; 174 175 static u16 rc_keys[] = { 176 KEY_POWER, 177 KEY_MUTE, 178 KEY_1, 179 KEY_2, 180 KEY_3, 181 KEY_4, 182 KEY_5, 183 KEY_6, 184 KEY_7, 185 KEY_8, 186 KEY_9, 187 KEY_0, 188 KEY_CHANNELUP, 189 KEY_VOLUMEDOWN, 190 KEY_OK, 191 KEY_VOLUMEUP, 192 KEY_CHANNELDOWN, 193 KEY_PREVIOUS, 194 KEY_ESC, 195 KEY_RED, 196 KEY_GREEN, 197 KEY_YELLOW, 198 KEY_BLUE, 199 KEY_OPTION, 200 KEY_M, 201 KEY_RADIO 202 }; 203 204 static void ttusb_dec_set_model(struct ttusb_dec *dec, 205 enum ttusb_dec_model model); 206 207 static void ttusb_dec_handle_irq( struct urb *urb) 208 { 209 struct ttusb_dec * dec = urb->context; 210 char *buffer = dec->irq_buffer; 211 int retval; 212 213 switch(urb->status) { 214 case 0: /*success*/ 215 break; 216 case -ECONNRESET: 217 case -ENOENT: 218 case -ESHUTDOWN: 219 case -ETIME: 220 /* this urb is dead, cleanup */ 221 dprintk("%s:urb shutting down with status: %d\n", 222 __func__, urb->status); 223 return; 224 default: 225 dprintk("%s:nonzero status received: %d\n", 226 __func__,urb->status); 227 goto exit; 228 } 229 230 if( (buffer[0] == 0x1) && (buffer[2] == 0x15) ) { 231 /* IR - Event */ 232 /* this is an fact a bit too simple implementation; 233 * the box also reports a keyrepeat signal 234 * (with buffer[3] == 0x40) in an intervall of ~100ms. 235 * But to handle this correctly we had to imlemenent some 236 * kind of timer which signals a 'key up' event if no 237 * keyrepeat signal is received for lets say 200ms. 238 * this should/could be added later ... 239 * for now lets report each signal as a key down and up*/ 240 dprintk("%s:rc signal:%d\n", __func__, buffer[4]); 241 input_report_key(dec->rc_input_dev, rc_keys[buffer[4] - 1], 1); 242 input_sync(dec->rc_input_dev); 243 input_report_key(dec->rc_input_dev, rc_keys[buffer[4] - 1], 0); 244 input_sync(dec->rc_input_dev); 245 } 246 247 exit: retval = usb_submit_urb(urb, GFP_ATOMIC); 248 if(retval) 249 printk("%s - usb_commit_urb failed with result: %d\n", 250 __func__, retval); 251 } 252 253 static u16 crc16(u16 crc, const u8 *buf, size_t len) 254 { 255 u16 tmp; 256 257 while (len--) { 258 crc ^= *buf++; 259 crc ^= (u8)crc >> 4; 260 tmp = (u8)crc; 261 crc ^= (tmp ^ (tmp << 1)) << 4; 262 } 263 return crc; 264 } 265 266 static int ttusb_dec_send_command(struct ttusb_dec *dec, const u8 command, 267 int param_length, const u8 params[], 268 int *result_length, u8 cmd_result[]) 269 { 270 int result, actual_len, i; 271 u8 *b; 272 273 dprintk("%s\n", __func__); 274 275 b = kmalloc(COMMAND_PACKET_SIZE + 4, GFP_KERNEL); 276 if (!b) 277 return -ENOMEM; 278 279 if ((result = mutex_lock_interruptible(&dec->usb_mutex))) { 280 kfree(b); 281 printk("%s: Failed to lock usb mutex.\n", __func__); 282 return result; 283 } 284 285 b[0] = 0xaa; 286 b[1] = ++dec->trans_count; 287 b[2] = command; 288 b[3] = param_length; 289 290 if (params) 291 memcpy(&b[4], params, param_length); 292 293 if (debug) { 294 printk("%s: command: ", __func__); 295 for (i = 0; i < param_length + 4; i++) 296 printk("0x%02X ", b[i]); 297 printk("\n"); 298 } 299 300 result = usb_bulk_msg(dec->udev, dec->command_pipe, b, 301 COMMAND_PACKET_SIZE + 4, &actual_len, 1000); 302 303 if (result) { 304 printk("%s: command bulk message failed: error %d\n", 305 __func__, result); 306 mutex_unlock(&dec->usb_mutex); 307 kfree(b); 308 return result; 309 } 310 311 result = usb_bulk_msg(dec->udev, dec->result_pipe, b, 312 COMMAND_PACKET_SIZE + 4, &actual_len, 1000); 313 314 if (result) { 315 printk("%s: result bulk message failed: error %d\n", 316 __func__, result); 317 mutex_unlock(&dec->usb_mutex); 318 kfree(b); 319 return result; 320 } else { 321 if (debug) { 322 printk("%s: result: ", __func__); 323 for (i = 0; i < actual_len; i++) 324 printk("0x%02X ", b[i]); 325 printk("\n"); 326 } 327 328 if (result_length) 329 *result_length = b[3]; 330 if (cmd_result && b[3] > 0) 331 memcpy(cmd_result, &b[4], b[3]); 332 333 mutex_unlock(&dec->usb_mutex); 334 335 kfree(b); 336 return 0; 337 } 338 } 339 340 static int ttusb_dec_get_stb_state (struct ttusb_dec *dec, unsigned int *mode, 341 unsigned int *model, unsigned int *version) 342 { 343 u8 c[COMMAND_PACKET_SIZE]; 344 int c_length; 345 int result; 346 __be32 tmp; 347 348 dprintk("%s\n", __func__); 349 350 result = ttusb_dec_send_command(dec, 0x08, 0, NULL, &c_length, c); 351 if (result) 352 return result; 353 354 if (c_length >= 0x0c) { 355 if (mode != NULL) { 356 memcpy(&tmp, c, 4); 357 *mode = ntohl(tmp); 358 } 359 if (model != NULL) { 360 memcpy(&tmp, &c[4], 4); 361 *model = ntohl(tmp); 362 } 363 if (version != NULL) { 364 memcpy(&tmp, &c[8], 4); 365 *version = ntohl(tmp); 366 } 367 return 0; 368 } else { 369 return -ENOENT; 370 } 371 } 372 373 static int ttusb_dec_audio_pes2ts_cb(void *priv, unsigned char *data) 374 { 375 struct ttusb_dec *dec = priv; 376 377 dec->audio_filter->feed->cb.ts(data, 188, NULL, 0, 378 &dec->audio_filter->feed->feed.ts); 379 380 return 0; 381 } 382 383 static int ttusb_dec_video_pes2ts_cb(void *priv, unsigned char *data) 384 { 385 struct ttusb_dec *dec = priv; 386 387 dec->video_filter->feed->cb.ts(data, 188, NULL, 0, 388 &dec->video_filter->feed->feed.ts); 389 390 return 0; 391 } 392 393 static void ttusb_dec_set_pids(struct ttusb_dec *dec) 394 { 395 u8 b[] = { 0x00, 0x00, 0x00, 0x00, 396 0x00, 0x00, 0xff, 0xff, 397 0xff, 0xff, 0xff, 0xff }; 398 399 __be16 pcr = htons(dec->pid[DMX_PES_PCR]); 400 __be16 audio = htons(dec->pid[DMX_PES_AUDIO]); 401 __be16 video = htons(dec->pid[DMX_PES_VIDEO]); 402 403 dprintk("%s\n", __func__); 404 405 memcpy(&b[0], &pcr, 2); 406 memcpy(&b[2], &audio, 2); 407 memcpy(&b[4], &video, 2); 408 409 ttusb_dec_send_command(dec, 0x50, sizeof(b), b, NULL, NULL); 410 411 dvb_filter_pes2ts_init(&dec->a_pes2ts, dec->pid[DMX_PES_AUDIO], 412 ttusb_dec_audio_pes2ts_cb, dec); 413 dvb_filter_pes2ts_init(&dec->v_pes2ts, dec->pid[DMX_PES_VIDEO], 414 ttusb_dec_video_pes2ts_cb, dec); 415 dec->v_pes_length = 0; 416 dec->v_pes_postbytes = 0; 417 } 418 419 static void ttusb_dec_process_pva(struct ttusb_dec *dec, u8 *pva, int length) 420 { 421 if (length < 8) { 422 printk("%s: packet too short - discarding\n", __func__); 423 return; 424 } 425 426 if (length > 8 + MAX_PVA_LENGTH) { 427 printk("%s: packet too long - discarding\n", __func__); 428 return; 429 } 430 431 switch (pva[2]) { 432 433 case 0x01: { /* VideoStream */ 434 int prebytes = pva[5] & 0x03; 435 int postbytes = (pva[5] & 0x0c) >> 2; 436 __be16 v_pes_payload_length; 437 438 if (output_pva) { 439 dec->video_filter->feed->cb.ts(pva, length, NULL, 0, 440 &dec->video_filter->feed->feed.ts); 441 return; 442 } 443 444 if (dec->v_pes_postbytes > 0 && 445 dec->v_pes_postbytes == prebytes) { 446 memcpy(&dec->v_pes[dec->v_pes_length], 447 &pva[12], prebytes); 448 449 dvb_filter_pes2ts(&dec->v_pes2ts, dec->v_pes, 450 dec->v_pes_length + prebytes, 1); 451 } 452 453 if (pva[5] & 0x10) { 454 dec->v_pes[7] = 0x80; 455 dec->v_pes[8] = 0x05; 456 457 dec->v_pes[9] = 0x21 | ((pva[8] & 0xc0) >> 5); 458 dec->v_pes[10] = ((pva[8] & 0x3f) << 2) | 459 ((pva[9] & 0xc0) >> 6); 460 dec->v_pes[11] = 0x01 | 461 ((pva[9] & 0x3f) << 2) | 462 ((pva[10] & 0x80) >> 6); 463 dec->v_pes[12] = ((pva[10] & 0x7f) << 1) | 464 ((pva[11] & 0xc0) >> 7); 465 dec->v_pes[13] = 0x01 | ((pva[11] & 0x7f) << 1); 466 467 memcpy(&dec->v_pes[14], &pva[12 + prebytes], 468 length - 12 - prebytes); 469 dec->v_pes_length = 14 + length - 12 - prebytes; 470 } else { 471 dec->v_pes[7] = 0x00; 472 dec->v_pes[8] = 0x00; 473 474 memcpy(&dec->v_pes[9], &pva[8], length - 8); 475 dec->v_pes_length = 9 + length - 8; 476 } 477 478 dec->v_pes_postbytes = postbytes; 479 480 if (dec->v_pes[9 + dec->v_pes[8]] == 0x00 && 481 dec->v_pes[10 + dec->v_pes[8]] == 0x00 && 482 dec->v_pes[11 + dec->v_pes[8]] == 0x01) 483 dec->v_pes[6] = 0x84; 484 else 485 dec->v_pes[6] = 0x80; 486 487 v_pes_payload_length = htons(dec->v_pes_length - 6 + 488 postbytes); 489 memcpy(&dec->v_pes[4], &v_pes_payload_length, 2); 490 491 if (postbytes == 0) 492 dvb_filter_pes2ts(&dec->v_pes2ts, dec->v_pes, 493 dec->v_pes_length, 1); 494 495 break; 496 } 497 498 case 0x02: /* MainAudioStream */ 499 if (output_pva) { 500 dec->audio_filter->feed->cb.ts(pva, length, NULL, 0, 501 &dec->audio_filter->feed->feed.ts); 502 return; 503 } 504 505 dvb_filter_pes2ts(&dec->a_pes2ts, &pva[8], length - 8, 506 pva[5] & 0x10); 507 break; 508 509 default: 510 printk("%s: unknown PVA type: %02x.\n", __func__, 511 pva[2]); 512 break; 513 } 514 } 515 516 static void ttusb_dec_process_filter(struct ttusb_dec *dec, u8 *packet, 517 int length) 518 { 519 struct list_head *item; 520 struct filter_info *finfo; 521 struct dvb_demux_filter *filter = NULL; 522 unsigned long flags; 523 u8 sid; 524 525 sid = packet[1]; 526 spin_lock_irqsave(&dec->filter_info_list_lock, flags); 527 for (item = dec->filter_info_list.next; item != &dec->filter_info_list; 528 item = item->next) { 529 finfo = list_entry(item, struct filter_info, filter_info_list); 530 if (finfo->stream_id == sid) { 531 filter = finfo->filter; 532 break; 533 } 534 } 535 spin_unlock_irqrestore(&dec->filter_info_list_lock, flags); 536 537 if (filter) 538 filter->feed->cb.sec(&packet[2], length - 2, NULL, 0, 539 &filter->filter); 540 } 541 542 static void ttusb_dec_process_packet(struct ttusb_dec *dec) 543 { 544 int i; 545 u16 csum = 0; 546 u16 packet_id; 547 548 if (dec->packet_length % 2) { 549 printk("%s: odd sized packet - discarding\n", __func__); 550 return; 551 } 552 553 for (i = 0; i < dec->packet_length; i += 2) 554 csum ^= ((dec->packet[i] << 8) + dec->packet[i + 1]); 555 556 if (csum) { 557 printk("%s: checksum failed - discarding\n", __func__); 558 return; 559 } 560 561 packet_id = dec->packet[dec->packet_length - 4] << 8; 562 packet_id += dec->packet[dec->packet_length - 3]; 563 564 if ((packet_id != dec->next_packet_id) && dec->next_packet_id) { 565 printk("%s: warning: lost packets between %u and %u\n", 566 __func__, dec->next_packet_id - 1, packet_id); 567 } 568 569 if (packet_id == 0xffff) 570 dec->next_packet_id = 0x8000; 571 else 572 dec->next_packet_id = packet_id + 1; 573 574 switch (dec->packet_type) { 575 case TTUSB_DEC_PACKET_PVA: 576 if (dec->pva_stream_count) 577 ttusb_dec_process_pva(dec, dec->packet, 578 dec->packet_payload_length); 579 break; 580 581 case TTUSB_DEC_PACKET_SECTION: 582 if (dec->filter_stream_count) 583 ttusb_dec_process_filter(dec, dec->packet, 584 dec->packet_payload_length); 585 break; 586 587 case TTUSB_DEC_PACKET_EMPTY: 588 break; 589 } 590 } 591 592 static void swap_bytes(u8 *b, int length) 593 { 594 length -= length % 2; 595 for (; length; b += 2, length -= 2) 596 swap(*b, *(b + 1)); 597 } 598 599 static void ttusb_dec_process_urb_frame(struct ttusb_dec *dec, u8 *b, 600 int length) 601 { 602 swap_bytes(b, length); 603 604 while (length) { 605 switch (dec->packet_state) { 606 607 case 0: 608 case 1: 609 case 2: 610 if (*b++ == 0xaa) 611 dec->packet_state++; 612 else 613 dec->packet_state = 0; 614 615 length--; 616 break; 617 618 case 3: 619 if (*b == 0x00) { 620 dec->packet_state++; 621 dec->packet_length = 0; 622 } else if (*b != 0xaa) { 623 dec->packet_state = 0; 624 } 625 626 b++; 627 length--; 628 break; 629 630 case 4: 631 dec->packet[dec->packet_length++] = *b++; 632 633 if (dec->packet_length == 2) { 634 if (dec->packet[0] == 'A' && 635 dec->packet[1] == 'V') { 636 dec->packet_type = 637 TTUSB_DEC_PACKET_PVA; 638 dec->packet_state++; 639 } else if (dec->packet[0] == 'S') { 640 dec->packet_type = 641 TTUSB_DEC_PACKET_SECTION; 642 dec->packet_state++; 643 } else if (dec->packet[0] == 0x00) { 644 dec->packet_type = 645 TTUSB_DEC_PACKET_EMPTY; 646 dec->packet_payload_length = 2; 647 dec->packet_state = 7; 648 } else { 649 printk("%s: unknown packet type: " 650 "%02x%02x\n", __func__, 651 dec->packet[0], dec->packet[1]); 652 dec->packet_state = 0; 653 } 654 } 655 656 length--; 657 break; 658 659 case 5: 660 dec->packet[dec->packet_length++] = *b++; 661 662 if (dec->packet_type == TTUSB_DEC_PACKET_PVA && 663 dec->packet_length == 8) { 664 dec->packet_state++; 665 dec->packet_payload_length = 8 + 666 (dec->packet[6] << 8) + 667 dec->packet[7]; 668 } else if (dec->packet_type == 669 TTUSB_DEC_PACKET_SECTION && 670 dec->packet_length == 5) { 671 dec->packet_state++; 672 dec->packet_payload_length = 5 + 673 ((dec->packet[3] & 0x0f) << 8) + 674 dec->packet[4]; 675 } 676 677 length--; 678 break; 679 680 case 6: { 681 int remainder = dec->packet_payload_length - 682 dec->packet_length; 683 684 if (length >= remainder) { 685 memcpy(dec->packet + dec->packet_length, 686 b, remainder); 687 dec->packet_length += remainder; 688 b += remainder; 689 length -= remainder; 690 dec->packet_state++; 691 } else { 692 memcpy(&dec->packet[dec->packet_length], 693 b, length); 694 dec->packet_length += length; 695 length = 0; 696 } 697 698 break; 699 } 700 701 case 7: { 702 int tail = 4; 703 704 dec->packet[dec->packet_length++] = *b++; 705 706 if (dec->packet_type == TTUSB_DEC_PACKET_SECTION && 707 dec->packet_payload_length % 2) 708 tail++; 709 710 if (dec->packet_length == 711 dec->packet_payload_length + tail) { 712 ttusb_dec_process_packet(dec); 713 dec->packet_state = 0; 714 } 715 716 length--; 717 break; 718 } 719 720 default: 721 printk("%s: illegal packet state encountered.\n", 722 __func__); 723 dec->packet_state = 0; 724 } 725 } 726 } 727 728 static void ttusb_dec_process_urb_frame_list(unsigned long data) 729 { 730 struct ttusb_dec *dec = (struct ttusb_dec *)data; 731 struct list_head *item; 732 struct urb_frame *frame; 733 unsigned long flags; 734 735 while (1) { 736 spin_lock_irqsave(&dec->urb_frame_list_lock, flags); 737 if ((item = dec->urb_frame_list.next) != &dec->urb_frame_list) { 738 frame = list_entry(item, struct urb_frame, 739 urb_frame_list); 740 list_del(&frame->urb_frame_list); 741 } else { 742 spin_unlock_irqrestore(&dec->urb_frame_list_lock, 743 flags); 744 return; 745 } 746 spin_unlock_irqrestore(&dec->urb_frame_list_lock, flags); 747 748 ttusb_dec_process_urb_frame(dec, frame->data, frame->length); 749 kfree(frame); 750 } 751 } 752 753 static void ttusb_dec_process_urb(struct urb *urb) 754 { 755 struct ttusb_dec *dec = urb->context; 756 757 if (!urb->status) { 758 int i; 759 760 for (i = 0; i < FRAMES_PER_ISO_BUF; i++) { 761 struct usb_iso_packet_descriptor *d; 762 u8 *b; 763 int length; 764 struct urb_frame *frame; 765 766 d = &urb->iso_frame_desc[i]; 767 b = urb->transfer_buffer + d->offset; 768 length = d->actual_length; 769 770 if ((frame = kmalloc(sizeof(struct urb_frame), 771 GFP_ATOMIC))) { 772 unsigned long flags; 773 774 memcpy(frame->data, b, length); 775 frame->length = length; 776 777 spin_lock_irqsave(&dec->urb_frame_list_lock, 778 flags); 779 list_add_tail(&frame->urb_frame_list, 780 &dec->urb_frame_list); 781 spin_unlock_irqrestore(&dec->urb_frame_list_lock, 782 flags); 783 784 tasklet_schedule(&dec->urb_tasklet); 785 } 786 } 787 } else { 788 /* -ENOENT is expected when unlinking urbs */ 789 if (urb->status != -ENOENT) 790 dprintk("%s: urb error: %d\n", __func__, 791 urb->status); 792 } 793 794 if (dec->iso_stream_count) 795 usb_submit_urb(urb, GFP_ATOMIC); 796 } 797 798 static void ttusb_dec_setup_urbs(struct ttusb_dec *dec) 799 { 800 int i, j, buffer_offset = 0; 801 802 dprintk("%s\n", __func__); 803 804 for (i = 0; i < ISO_BUF_COUNT; i++) { 805 int frame_offset = 0; 806 struct urb *urb = dec->iso_urb[i]; 807 808 urb->dev = dec->udev; 809 urb->context = dec; 810 urb->complete = ttusb_dec_process_urb; 811 urb->pipe = dec->in_pipe; 812 urb->transfer_flags = URB_ISO_ASAP; 813 urb->interval = 1; 814 urb->number_of_packets = FRAMES_PER_ISO_BUF; 815 urb->transfer_buffer_length = ISO_FRAME_SIZE * 816 FRAMES_PER_ISO_BUF; 817 urb->transfer_buffer = dec->iso_buffer + buffer_offset; 818 buffer_offset += ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF; 819 820 for (j = 0; j < FRAMES_PER_ISO_BUF; j++) { 821 urb->iso_frame_desc[j].offset = frame_offset; 822 urb->iso_frame_desc[j].length = ISO_FRAME_SIZE; 823 frame_offset += ISO_FRAME_SIZE; 824 } 825 } 826 } 827 828 static void ttusb_dec_stop_iso_xfer(struct ttusb_dec *dec) 829 { 830 int i; 831 832 dprintk("%s\n", __func__); 833 834 if (mutex_lock_interruptible(&dec->iso_mutex)) 835 return; 836 837 dec->iso_stream_count--; 838 839 if (!dec->iso_stream_count) { 840 for (i = 0; i < ISO_BUF_COUNT; i++) 841 usb_kill_urb(dec->iso_urb[i]); 842 } 843 844 mutex_unlock(&dec->iso_mutex); 845 } 846 847 /* Setting the interface of the DEC tends to take down the USB communications 848 * for a short period, so it's important not to call this function just before 849 * trying to talk to it. 850 */ 851 static int ttusb_dec_set_interface(struct ttusb_dec *dec, 852 enum ttusb_dec_interface interface) 853 { 854 int result = 0; 855 u8 b[] = { 0x05 }; 856 857 if (interface != dec->interface) { 858 switch (interface) { 859 case TTUSB_DEC_INTERFACE_INITIAL: 860 result = usb_set_interface(dec->udev, 0, 0); 861 break; 862 case TTUSB_DEC_INTERFACE_IN: 863 result = ttusb_dec_send_command(dec, 0x80, sizeof(b), 864 b, NULL, NULL); 865 if (result) 866 return result; 867 result = usb_set_interface(dec->udev, 0, 8); 868 break; 869 case TTUSB_DEC_INTERFACE_OUT: 870 result = usb_set_interface(dec->udev, 0, 1); 871 break; 872 } 873 874 if (result) 875 return result; 876 877 dec->interface = interface; 878 } 879 880 return 0; 881 } 882 883 static int ttusb_dec_start_iso_xfer(struct ttusb_dec *dec) 884 { 885 int i, result; 886 887 dprintk("%s\n", __func__); 888 889 if (mutex_lock_interruptible(&dec->iso_mutex)) 890 return -EAGAIN; 891 892 if (!dec->iso_stream_count) { 893 ttusb_dec_setup_urbs(dec); 894 895 dec->packet_state = 0; 896 dec->v_pes_postbytes = 0; 897 dec->next_packet_id = 0; 898 899 for (i = 0; i < ISO_BUF_COUNT; i++) { 900 if ((result = usb_submit_urb(dec->iso_urb[i], 901 GFP_ATOMIC))) { 902 printk("%s: failed urb submission %d: " 903 "error %d\n", __func__, i, result); 904 905 while (i) { 906 usb_kill_urb(dec->iso_urb[i - 1]); 907 i--; 908 } 909 910 mutex_unlock(&dec->iso_mutex); 911 return result; 912 } 913 } 914 } 915 916 dec->iso_stream_count++; 917 918 mutex_unlock(&dec->iso_mutex); 919 920 return 0; 921 } 922 923 static int ttusb_dec_start_ts_feed(struct dvb_demux_feed *dvbdmxfeed) 924 { 925 struct dvb_demux *dvbdmx = dvbdmxfeed->demux; 926 struct ttusb_dec *dec = dvbdmx->priv; 927 u8 b0[] = { 0x05 }; 928 int result = 0; 929 930 dprintk("%s\n", __func__); 931 932 dprintk(" ts_type:"); 933 934 if (dvbdmxfeed->ts_type & TS_DECODER) 935 dprintk(" TS_DECODER"); 936 937 if (dvbdmxfeed->ts_type & TS_PACKET) 938 dprintk(" TS_PACKET"); 939 940 if (dvbdmxfeed->ts_type & TS_PAYLOAD_ONLY) 941 dprintk(" TS_PAYLOAD_ONLY"); 942 943 dprintk("\n"); 944 945 switch (dvbdmxfeed->pes_type) { 946 947 case DMX_PES_VIDEO: 948 dprintk(" pes_type: DMX_PES_VIDEO\n"); 949 dec->pid[DMX_PES_PCR] = dvbdmxfeed->pid; 950 dec->pid[DMX_PES_VIDEO] = dvbdmxfeed->pid; 951 dec->video_filter = dvbdmxfeed->filter; 952 ttusb_dec_set_pids(dec); 953 break; 954 955 case DMX_PES_AUDIO: 956 dprintk(" pes_type: DMX_PES_AUDIO\n"); 957 dec->pid[DMX_PES_AUDIO] = dvbdmxfeed->pid; 958 dec->audio_filter = dvbdmxfeed->filter; 959 ttusb_dec_set_pids(dec); 960 break; 961 962 case DMX_PES_TELETEXT: 963 dec->pid[DMX_PES_TELETEXT] = dvbdmxfeed->pid; 964 dprintk(" pes_type: DMX_PES_TELETEXT(not supported)\n"); 965 return -ENOSYS; 966 967 case DMX_PES_PCR: 968 dprintk(" pes_type: DMX_PES_PCR\n"); 969 dec->pid[DMX_PES_PCR] = dvbdmxfeed->pid; 970 ttusb_dec_set_pids(dec); 971 break; 972 973 case DMX_PES_OTHER: 974 dprintk(" pes_type: DMX_PES_OTHER(not supported)\n"); 975 return -ENOSYS; 976 977 default: 978 dprintk(" pes_type: unknown (%d)\n", dvbdmxfeed->pes_type); 979 return -EINVAL; 980 981 } 982 983 result = ttusb_dec_send_command(dec, 0x80, sizeof(b0), b0, NULL, NULL); 984 if (result) 985 return result; 986 987 dec->pva_stream_count++; 988 return ttusb_dec_start_iso_xfer(dec); 989 } 990 991 static int ttusb_dec_start_sec_feed(struct dvb_demux_feed *dvbdmxfeed) 992 { 993 struct ttusb_dec *dec = dvbdmxfeed->demux->priv; 994 u8 b0[] = { 0x00, 0x00, 0x00, 0x01, 995 0x00, 0x00, 0x00, 0x00, 996 0x00, 0x00, 0x00, 0x00, 997 0x00, 0x00, 0x00, 0x00, 998 0x00, 0xff, 0x00, 0x00, 999 0x00, 0x00, 0x00, 0x00, 1000 0x00, 0x00, 0x00, 0x00, 1001 0x00 }; 1002 __be16 pid; 1003 u8 c[COMMAND_PACKET_SIZE]; 1004 int c_length; 1005 int result; 1006 struct filter_info *finfo; 1007 unsigned long flags; 1008 u8 x = 1; 1009 1010 dprintk("%s\n", __func__); 1011 1012 pid = htons(dvbdmxfeed->pid); 1013 memcpy(&b0[0], &pid, 2); 1014 memcpy(&b0[4], &x, 1); 1015 memcpy(&b0[5], &dvbdmxfeed->filter->filter.filter_value[0], 1); 1016 1017 result = ttusb_dec_send_command(dec, 0x60, sizeof(b0), b0, 1018 &c_length, c); 1019 1020 if (!result) { 1021 if (c_length == 2) { 1022 if (!(finfo = kmalloc(sizeof(struct filter_info), 1023 GFP_ATOMIC))) 1024 return -ENOMEM; 1025 1026 finfo->stream_id = c[1]; 1027 finfo->filter = dvbdmxfeed->filter; 1028 1029 spin_lock_irqsave(&dec->filter_info_list_lock, flags); 1030 list_add_tail(&finfo->filter_info_list, 1031 &dec->filter_info_list); 1032 spin_unlock_irqrestore(&dec->filter_info_list_lock, 1033 flags); 1034 1035 dvbdmxfeed->priv = finfo; 1036 1037 dec->filter_stream_count++; 1038 return ttusb_dec_start_iso_xfer(dec); 1039 } 1040 1041 return -EAGAIN; 1042 } else 1043 return result; 1044 } 1045 1046 static int ttusb_dec_start_feed(struct dvb_demux_feed *dvbdmxfeed) 1047 { 1048 struct dvb_demux *dvbdmx = dvbdmxfeed->demux; 1049 1050 dprintk("%s\n", __func__); 1051 1052 if (!dvbdmx->dmx.frontend) 1053 return -EINVAL; 1054 1055 dprintk(" pid: 0x%04X\n", dvbdmxfeed->pid); 1056 1057 switch (dvbdmxfeed->type) { 1058 1059 case DMX_TYPE_TS: 1060 return ttusb_dec_start_ts_feed(dvbdmxfeed); 1061 break; 1062 1063 case DMX_TYPE_SEC: 1064 return ttusb_dec_start_sec_feed(dvbdmxfeed); 1065 break; 1066 1067 default: 1068 dprintk(" type: unknown (%d)\n", dvbdmxfeed->type); 1069 return -EINVAL; 1070 1071 } 1072 } 1073 1074 static int ttusb_dec_stop_ts_feed(struct dvb_demux_feed *dvbdmxfeed) 1075 { 1076 struct ttusb_dec *dec = dvbdmxfeed->demux->priv; 1077 u8 b0[] = { 0x00 }; 1078 1079 ttusb_dec_send_command(dec, 0x81, sizeof(b0), b0, NULL, NULL); 1080 1081 dec->pva_stream_count--; 1082 1083 ttusb_dec_stop_iso_xfer(dec); 1084 1085 return 0; 1086 } 1087 1088 static int ttusb_dec_stop_sec_feed(struct dvb_demux_feed *dvbdmxfeed) 1089 { 1090 struct ttusb_dec *dec = dvbdmxfeed->demux->priv; 1091 u8 b0[] = { 0x00, 0x00 }; 1092 struct filter_info *finfo = (struct filter_info *)dvbdmxfeed->priv; 1093 unsigned long flags; 1094 1095 b0[1] = finfo->stream_id; 1096 spin_lock_irqsave(&dec->filter_info_list_lock, flags); 1097 list_del(&finfo->filter_info_list); 1098 spin_unlock_irqrestore(&dec->filter_info_list_lock, flags); 1099 kfree(finfo); 1100 ttusb_dec_send_command(dec, 0x62, sizeof(b0), b0, NULL, NULL); 1101 1102 dec->filter_stream_count--; 1103 1104 ttusb_dec_stop_iso_xfer(dec); 1105 1106 return 0; 1107 } 1108 1109 static int ttusb_dec_stop_feed(struct dvb_demux_feed *dvbdmxfeed) 1110 { 1111 dprintk("%s\n", __func__); 1112 1113 switch (dvbdmxfeed->type) { 1114 case DMX_TYPE_TS: 1115 return ttusb_dec_stop_ts_feed(dvbdmxfeed); 1116 break; 1117 1118 case DMX_TYPE_SEC: 1119 return ttusb_dec_stop_sec_feed(dvbdmxfeed); 1120 break; 1121 } 1122 1123 return 0; 1124 } 1125 1126 static void ttusb_dec_free_iso_urbs(struct ttusb_dec *dec) 1127 { 1128 int i; 1129 1130 dprintk("%s\n", __func__); 1131 1132 for (i = 0; i < ISO_BUF_COUNT; i++) 1133 usb_free_urb(dec->iso_urb[i]); 1134 1135 pci_free_consistent(NULL, 1136 ISO_FRAME_SIZE * (FRAMES_PER_ISO_BUF * 1137 ISO_BUF_COUNT), 1138 dec->iso_buffer, dec->iso_dma_handle); 1139 } 1140 1141 static int ttusb_dec_alloc_iso_urbs(struct ttusb_dec *dec) 1142 { 1143 int i; 1144 1145 dprintk("%s\n", __func__); 1146 1147 dec->iso_buffer = pci_zalloc_consistent(NULL, 1148 ISO_FRAME_SIZE * (FRAMES_PER_ISO_BUF * ISO_BUF_COUNT), 1149 &dec->iso_dma_handle); 1150 1151 if (!dec->iso_buffer) { 1152 dprintk("%s: pci_alloc_consistent - not enough memory\n", 1153 __func__); 1154 return -ENOMEM; 1155 } 1156 1157 for (i = 0; i < ISO_BUF_COUNT; i++) { 1158 struct urb *urb; 1159 1160 if (!(urb = usb_alloc_urb(FRAMES_PER_ISO_BUF, GFP_ATOMIC))) { 1161 ttusb_dec_free_iso_urbs(dec); 1162 return -ENOMEM; 1163 } 1164 1165 dec->iso_urb[i] = urb; 1166 } 1167 1168 ttusb_dec_setup_urbs(dec); 1169 1170 return 0; 1171 } 1172 1173 static void ttusb_dec_init_tasklet(struct ttusb_dec *dec) 1174 { 1175 spin_lock_init(&dec->urb_frame_list_lock); 1176 INIT_LIST_HEAD(&dec->urb_frame_list); 1177 tasklet_init(&dec->urb_tasklet, ttusb_dec_process_urb_frame_list, 1178 (unsigned long)dec); 1179 } 1180 1181 static int ttusb_init_rc( struct ttusb_dec *dec) 1182 { 1183 struct input_dev *input_dev; 1184 u8 b[] = { 0x00, 0x01 }; 1185 int i; 1186 int err; 1187 1188 usb_make_path(dec->udev, dec->rc_phys, sizeof(dec->rc_phys)); 1189 strlcat(dec->rc_phys, "/input0", sizeof(dec->rc_phys)); 1190 1191 input_dev = input_allocate_device(); 1192 if (!input_dev) 1193 return -ENOMEM; 1194 1195 input_dev->name = "ttusb_dec remote control"; 1196 input_dev->phys = dec->rc_phys; 1197 input_dev->evbit[0] = BIT_MASK(EV_KEY); 1198 input_dev->keycodesize = sizeof(u16); 1199 input_dev->keycodemax = 0x1a; 1200 input_dev->keycode = rc_keys; 1201 1202 for (i = 0; i < ARRAY_SIZE(rc_keys); i++) 1203 set_bit(rc_keys[i], input_dev->keybit); 1204 1205 err = input_register_device(input_dev); 1206 if (err) { 1207 input_free_device(input_dev); 1208 return err; 1209 } 1210 1211 dec->rc_input_dev = input_dev; 1212 if (usb_submit_urb(dec->irq_urb, GFP_KERNEL)) 1213 printk("%s: usb_submit_urb failed\n",__func__); 1214 /* enable irq pipe */ 1215 ttusb_dec_send_command(dec,0xb0,sizeof(b),b,NULL,NULL); 1216 1217 return 0; 1218 } 1219 1220 static void ttusb_dec_init_v_pes(struct ttusb_dec *dec) 1221 { 1222 dprintk("%s\n", __func__); 1223 1224 dec->v_pes[0] = 0x00; 1225 dec->v_pes[1] = 0x00; 1226 dec->v_pes[2] = 0x01; 1227 dec->v_pes[3] = 0xe0; 1228 } 1229 1230 static int ttusb_dec_init_usb(struct ttusb_dec *dec) 1231 { 1232 int result; 1233 1234 dprintk("%s\n", __func__); 1235 1236 mutex_init(&dec->usb_mutex); 1237 mutex_init(&dec->iso_mutex); 1238 1239 dec->command_pipe = usb_sndbulkpipe(dec->udev, COMMAND_PIPE); 1240 dec->result_pipe = usb_rcvbulkpipe(dec->udev, RESULT_PIPE); 1241 dec->in_pipe = usb_rcvisocpipe(dec->udev, IN_PIPE); 1242 dec->out_pipe = usb_sndisocpipe(dec->udev, OUT_PIPE); 1243 dec->irq_pipe = usb_rcvintpipe(dec->udev, IRQ_PIPE); 1244 1245 if(enable_rc) { 1246 dec->irq_urb = usb_alloc_urb(0, GFP_KERNEL); 1247 if(!dec->irq_urb) { 1248 return -ENOMEM; 1249 } 1250 dec->irq_buffer = usb_alloc_coherent(dec->udev,IRQ_PACKET_SIZE, 1251 GFP_KERNEL, &dec->irq_dma_handle); 1252 if(!dec->irq_buffer) { 1253 usb_free_urb(dec->irq_urb); 1254 return -ENOMEM; 1255 } 1256 usb_fill_int_urb(dec->irq_urb, dec->udev,dec->irq_pipe, 1257 dec->irq_buffer, IRQ_PACKET_SIZE, 1258 ttusb_dec_handle_irq, dec, 1); 1259 dec->irq_urb->transfer_dma = dec->irq_dma_handle; 1260 dec->irq_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 1261 } 1262 1263 result = ttusb_dec_alloc_iso_urbs(dec); 1264 if (result) { 1265 usb_free_urb(dec->irq_urb); 1266 usb_free_coherent(dec->udev, IRQ_PACKET_SIZE, 1267 dec->irq_buffer, dec->irq_dma_handle); 1268 } 1269 return result; 1270 } 1271 1272 static int ttusb_dec_boot_dsp(struct ttusb_dec *dec) 1273 { 1274 int i, j, actual_len, result, size, trans_count; 1275 u8 b0[] = { 0x00, 0x00, 0x00, 0x00, 1276 0x00, 0x00, 0x00, 0x00, 1277 0x61, 0x00 }; 1278 u8 b1[] = { 0x61 }; 1279 u8 *b; 1280 char idstring[21]; 1281 const u8 *firmware = NULL; 1282 size_t firmware_size = 0; 1283 u16 firmware_csum = 0; 1284 __be16 firmware_csum_ns; 1285 __be32 firmware_size_nl; 1286 u32 crc32_csum, crc32_check; 1287 __be32 tmp; 1288 const struct firmware *fw_entry = NULL; 1289 1290 dprintk("%s\n", __func__); 1291 1292 result = request_firmware(&fw_entry, dec->firmware_name, &dec->udev->dev); 1293 if (result) { 1294 printk(KERN_ERR "%s: Firmware (%s) unavailable.\n", 1295 __func__, dec->firmware_name); 1296 return result; 1297 } 1298 1299 firmware = fw_entry->data; 1300 firmware_size = fw_entry->size; 1301 1302 if (firmware_size < 60) { 1303 printk("%s: firmware size too small for DSP code (%zu < 60).\n", 1304 __func__, firmware_size); 1305 release_firmware(fw_entry); 1306 return -ENOENT; 1307 } 1308 1309 /* a 32 bit checksum over the first 56 bytes of the DSP Code is stored 1310 at offset 56 of file, so use it to check if the firmware file is 1311 valid. */ 1312 crc32_csum = crc32(~0L, firmware, 56) ^ ~0L; 1313 memcpy(&tmp, &firmware[56], 4); 1314 crc32_check = ntohl(tmp); 1315 if (crc32_csum != crc32_check) { 1316 printk("%s: crc32 check of DSP code failed (calculated " 1317 "0x%08x != 0x%08x in file), file invalid.\n", 1318 __func__, crc32_csum, crc32_check); 1319 release_firmware(fw_entry); 1320 return -ENOENT; 1321 } 1322 memcpy(idstring, &firmware[36], 20); 1323 idstring[20] = '\0'; 1324 printk(KERN_INFO "ttusb_dec: found DSP code \"%s\".\n", idstring); 1325 1326 firmware_size_nl = htonl(firmware_size); 1327 memcpy(b0, &firmware_size_nl, 4); 1328 firmware_csum = crc16(~0, firmware, firmware_size) ^ ~0; 1329 firmware_csum_ns = htons(firmware_csum); 1330 memcpy(&b0[6], &firmware_csum_ns, 2); 1331 1332 result = ttusb_dec_send_command(dec, 0x41, sizeof(b0), b0, NULL, NULL); 1333 1334 if (result) { 1335 release_firmware(fw_entry); 1336 return result; 1337 } 1338 1339 trans_count = 0; 1340 j = 0; 1341 1342 b = kmalloc(ARM_PACKET_SIZE, GFP_KERNEL); 1343 if (b == NULL) { 1344 release_firmware(fw_entry); 1345 return -ENOMEM; 1346 } 1347 1348 for (i = 0; i < firmware_size; i += COMMAND_PACKET_SIZE) { 1349 size = firmware_size - i; 1350 if (size > COMMAND_PACKET_SIZE) 1351 size = COMMAND_PACKET_SIZE; 1352 1353 b[j + 0] = 0xaa; 1354 b[j + 1] = trans_count++; 1355 b[j + 2] = 0xf0; 1356 b[j + 3] = size; 1357 memcpy(&b[j + 4], &firmware[i], size); 1358 1359 j += COMMAND_PACKET_SIZE + 4; 1360 1361 if (j >= ARM_PACKET_SIZE) { 1362 result = usb_bulk_msg(dec->udev, dec->command_pipe, b, 1363 ARM_PACKET_SIZE, &actual_len, 1364 100); 1365 j = 0; 1366 } else if (size < COMMAND_PACKET_SIZE) { 1367 result = usb_bulk_msg(dec->udev, dec->command_pipe, b, 1368 j - COMMAND_PACKET_SIZE + size, 1369 &actual_len, 100); 1370 } 1371 } 1372 1373 result = ttusb_dec_send_command(dec, 0x43, sizeof(b1), b1, NULL, NULL); 1374 1375 release_firmware(fw_entry); 1376 kfree(b); 1377 1378 return result; 1379 } 1380 1381 static int ttusb_dec_init_stb(struct ttusb_dec *dec) 1382 { 1383 int result; 1384 unsigned int mode = 0, model = 0, version = 0; 1385 1386 dprintk("%s\n", __func__); 1387 1388 result = ttusb_dec_get_stb_state(dec, &mode, &model, &version); 1389 if (result) 1390 return result; 1391 1392 if (!mode) { 1393 if (version == 0xABCDEFAB) 1394 printk(KERN_INFO "ttusb_dec: no version " 1395 "info in Firmware\n"); 1396 else 1397 printk(KERN_INFO "ttusb_dec: Firmware " 1398 "%x.%02x%c%c\n", 1399 version >> 24, (version >> 16) & 0xff, 1400 (version >> 8) & 0xff, version & 0xff); 1401 1402 result = ttusb_dec_boot_dsp(dec); 1403 if (result) 1404 return result; 1405 } else { 1406 /* We can't trust the USB IDs that some firmwares 1407 give the box */ 1408 switch (model) { 1409 case 0x00070001: 1410 case 0x00070008: 1411 case 0x0007000c: 1412 ttusb_dec_set_model(dec, TTUSB_DEC3000S); 1413 break; 1414 case 0x00070009: 1415 case 0x00070013: 1416 ttusb_dec_set_model(dec, TTUSB_DEC2000T); 1417 break; 1418 case 0x00070011: 1419 ttusb_dec_set_model(dec, TTUSB_DEC2540T); 1420 break; 1421 default: 1422 printk(KERN_ERR "%s: unknown model returned " 1423 "by firmware (%08x) - please report\n", 1424 __func__, model); 1425 return -ENOENT; 1426 } 1427 if (version >= 0x01770000) 1428 dec->can_playback = 1; 1429 } 1430 return 0; 1431 } 1432 1433 static int ttusb_dec_init_dvb(struct ttusb_dec *dec) 1434 { 1435 int result; 1436 1437 dprintk("%s\n", __func__); 1438 1439 if ((result = dvb_register_adapter(&dec->adapter, 1440 dec->model_name, THIS_MODULE, 1441 &dec->udev->dev, 1442 adapter_nr)) < 0) { 1443 printk("%s: dvb_register_adapter failed: error %d\n", 1444 __func__, result); 1445 1446 return result; 1447 } 1448 1449 dec->demux.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING; 1450 1451 dec->demux.priv = (void *)dec; 1452 dec->demux.filternum = 31; 1453 dec->demux.feednum = 31; 1454 dec->demux.start_feed = ttusb_dec_start_feed; 1455 dec->demux.stop_feed = ttusb_dec_stop_feed; 1456 dec->demux.write_to_decoder = NULL; 1457 1458 if ((result = dvb_dmx_init(&dec->demux)) < 0) { 1459 printk("%s: dvb_dmx_init failed: error %d\n", __func__, 1460 result); 1461 1462 dvb_unregister_adapter(&dec->adapter); 1463 1464 return result; 1465 } 1466 1467 dec->dmxdev.filternum = 32; 1468 dec->dmxdev.demux = &dec->demux.dmx; 1469 dec->dmxdev.capabilities = 0; 1470 1471 if ((result = dvb_dmxdev_init(&dec->dmxdev, &dec->adapter)) < 0) { 1472 printk("%s: dvb_dmxdev_init failed: error %d\n", 1473 __func__, result); 1474 1475 dvb_dmx_release(&dec->demux); 1476 dvb_unregister_adapter(&dec->adapter); 1477 1478 return result; 1479 } 1480 1481 dec->frontend.source = DMX_FRONTEND_0; 1482 1483 if ((result = dec->demux.dmx.add_frontend(&dec->demux.dmx, 1484 &dec->frontend)) < 0) { 1485 printk("%s: dvb_dmx_init failed: error %d\n", __func__, 1486 result); 1487 1488 dvb_dmxdev_release(&dec->dmxdev); 1489 dvb_dmx_release(&dec->demux); 1490 dvb_unregister_adapter(&dec->adapter); 1491 1492 return result; 1493 } 1494 1495 if ((result = dec->demux.dmx.connect_frontend(&dec->demux.dmx, 1496 &dec->frontend)) < 0) { 1497 printk("%s: dvb_dmx_init failed: error %d\n", __func__, 1498 result); 1499 1500 dec->demux.dmx.remove_frontend(&dec->demux.dmx, &dec->frontend); 1501 dvb_dmxdev_release(&dec->dmxdev); 1502 dvb_dmx_release(&dec->demux); 1503 dvb_unregister_adapter(&dec->adapter); 1504 1505 return result; 1506 } 1507 1508 dvb_net_init(&dec->adapter, &dec->dvb_net, &dec->demux.dmx); 1509 1510 return 0; 1511 } 1512 1513 static void ttusb_dec_exit_dvb(struct ttusb_dec *dec) 1514 { 1515 dprintk("%s\n", __func__); 1516 1517 dvb_net_release(&dec->dvb_net); 1518 dec->demux.dmx.close(&dec->demux.dmx); 1519 dec->demux.dmx.remove_frontend(&dec->demux.dmx, &dec->frontend); 1520 dvb_dmxdev_release(&dec->dmxdev); 1521 dvb_dmx_release(&dec->demux); 1522 if (dec->fe) { 1523 dvb_unregister_frontend(dec->fe); 1524 if (dec->fe->ops.release) 1525 dec->fe->ops.release(dec->fe); 1526 } 1527 dvb_unregister_adapter(&dec->adapter); 1528 } 1529 1530 static void ttusb_dec_exit_rc(struct ttusb_dec *dec) 1531 { 1532 dprintk("%s\n", __func__); 1533 1534 if (dec->rc_input_dev) { 1535 input_unregister_device(dec->rc_input_dev); 1536 dec->rc_input_dev = NULL; 1537 } 1538 } 1539 1540 1541 static void ttusb_dec_exit_usb(struct ttusb_dec *dec) 1542 { 1543 int i; 1544 1545 dprintk("%s\n", __func__); 1546 1547 if (enable_rc) { 1548 /* we have to check whether the irq URB is already submitted. 1549 * As the irq is submitted after the interface is changed, 1550 * this is the best method i figured out. 1551 * Any others?*/ 1552 if (dec->interface == TTUSB_DEC_INTERFACE_IN) 1553 usb_kill_urb(dec->irq_urb); 1554 1555 usb_free_urb(dec->irq_urb); 1556 1557 usb_free_coherent(dec->udev, IRQ_PACKET_SIZE, 1558 dec->irq_buffer, dec->irq_dma_handle); 1559 } 1560 1561 dec->iso_stream_count = 0; 1562 1563 for (i = 0; i < ISO_BUF_COUNT; i++) 1564 usb_kill_urb(dec->iso_urb[i]); 1565 1566 ttusb_dec_free_iso_urbs(dec); 1567 } 1568 1569 static void ttusb_dec_exit_tasklet(struct ttusb_dec *dec) 1570 { 1571 struct list_head *item; 1572 struct urb_frame *frame; 1573 1574 tasklet_kill(&dec->urb_tasklet); 1575 1576 while ((item = dec->urb_frame_list.next) != &dec->urb_frame_list) { 1577 frame = list_entry(item, struct urb_frame, urb_frame_list); 1578 list_del(&frame->urb_frame_list); 1579 kfree(frame); 1580 } 1581 } 1582 1583 static void ttusb_dec_init_filters(struct ttusb_dec *dec) 1584 { 1585 INIT_LIST_HEAD(&dec->filter_info_list); 1586 spin_lock_init(&dec->filter_info_list_lock); 1587 } 1588 1589 static void ttusb_dec_exit_filters(struct ttusb_dec *dec) 1590 { 1591 struct list_head *item; 1592 struct filter_info *finfo; 1593 1594 while ((item = dec->filter_info_list.next) != &dec->filter_info_list) { 1595 finfo = list_entry(item, struct filter_info, filter_info_list); 1596 list_del(&finfo->filter_info_list); 1597 kfree(finfo); 1598 } 1599 } 1600 1601 static int fe_send_command(struct dvb_frontend* fe, const u8 command, 1602 int param_length, const u8 params[], 1603 int *result_length, u8 cmd_result[]) 1604 { 1605 struct ttusb_dec* dec = fe->dvb->priv; 1606 return ttusb_dec_send_command(dec, command, param_length, params, result_length, cmd_result); 1607 } 1608 1609 static struct ttusbdecfe_config fe_config = { 1610 .send_command = fe_send_command 1611 }; 1612 1613 static int ttusb_dec_probe(struct usb_interface *intf, 1614 const struct usb_device_id *id) 1615 { 1616 struct usb_device *udev; 1617 struct ttusb_dec *dec; 1618 int result; 1619 1620 dprintk("%s\n", __func__); 1621 1622 udev = interface_to_usbdev(intf); 1623 1624 if (!(dec = kzalloc(sizeof(struct ttusb_dec), GFP_KERNEL))) { 1625 printk("%s: couldn't allocate memory.\n", __func__); 1626 return -ENOMEM; 1627 } 1628 1629 usb_set_intfdata(intf, (void *)dec); 1630 1631 switch (id->idProduct) { 1632 case 0x1006: 1633 ttusb_dec_set_model(dec, TTUSB_DEC3000S); 1634 break; 1635 1636 case 0x1008: 1637 ttusb_dec_set_model(dec, TTUSB_DEC2000T); 1638 break; 1639 1640 case 0x1009: 1641 ttusb_dec_set_model(dec, TTUSB_DEC2540T); 1642 break; 1643 } 1644 1645 dec->udev = udev; 1646 1647 result = ttusb_dec_init_usb(dec); 1648 if (result) 1649 goto err_usb; 1650 result = ttusb_dec_init_stb(dec); 1651 if (result) 1652 goto err_stb; 1653 result = ttusb_dec_init_dvb(dec); 1654 if (result) 1655 goto err_stb; 1656 1657 dec->adapter.priv = dec; 1658 switch (id->idProduct) { 1659 case 0x1006: 1660 dec->fe = ttusbdecfe_dvbs_attach(&fe_config); 1661 break; 1662 1663 case 0x1008: 1664 case 0x1009: 1665 dec->fe = ttusbdecfe_dvbt_attach(&fe_config); 1666 break; 1667 } 1668 1669 if (dec->fe == NULL) { 1670 printk("dvb-ttusb-dec: A frontend driver was not found for device [%04x:%04x]\n", 1671 le16_to_cpu(dec->udev->descriptor.idVendor), 1672 le16_to_cpu(dec->udev->descriptor.idProduct)); 1673 } else { 1674 if (dvb_register_frontend(&dec->adapter, dec->fe)) { 1675 printk("budget-ci: Frontend registration failed!\n"); 1676 if (dec->fe->ops.release) 1677 dec->fe->ops.release(dec->fe); 1678 dec->fe = NULL; 1679 } 1680 } 1681 1682 ttusb_dec_init_v_pes(dec); 1683 ttusb_dec_init_filters(dec); 1684 ttusb_dec_init_tasklet(dec); 1685 1686 dec->active = 1; 1687 1688 ttusb_dec_set_interface(dec, TTUSB_DEC_INTERFACE_IN); 1689 1690 if (enable_rc) 1691 ttusb_init_rc(dec); 1692 1693 return 0; 1694 err_stb: 1695 ttusb_dec_exit_usb(dec); 1696 err_usb: 1697 kfree(dec); 1698 return result; 1699 } 1700 1701 static void ttusb_dec_disconnect(struct usb_interface *intf) 1702 { 1703 struct ttusb_dec *dec = usb_get_intfdata(intf); 1704 1705 usb_set_intfdata(intf, NULL); 1706 1707 dprintk("%s\n", __func__); 1708 1709 if (dec->active) { 1710 ttusb_dec_exit_tasklet(dec); 1711 ttusb_dec_exit_filters(dec); 1712 if(enable_rc) 1713 ttusb_dec_exit_rc(dec); 1714 ttusb_dec_exit_usb(dec); 1715 ttusb_dec_exit_dvb(dec); 1716 } 1717 1718 kfree(dec); 1719 } 1720 1721 static void ttusb_dec_set_model(struct ttusb_dec *dec, 1722 enum ttusb_dec_model model) 1723 { 1724 dec->model = model; 1725 1726 switch (model) { 1727 case TTUSB_DEC2000T: 1728 dec->model_name = "DEC2000-t"; 1729 dec->firmware_name = "dvb-ttusb-dec-2000t.fw"; 1730 break; 1731 1732 case TTUSB_DEC2540T: 1733 dec->model_name = "DEC2540-t"; 1734 dec->firmware_name = "dvb-ttusb-dec-2540t.fw"; 1735 break; 1736 1737 case TTUSB_DEC3000S: 1738 dec->model_name = "DEC3000-s"; 1739 dec->firmware_name = "dvb-ttusb-dec-3000s.fw"; 1740 break; 1741 } 1742 } 1743 1744 static struct usb_device_id ttusb_dec_table[] = { 1745 {USB_DEVICE(0x0b48, 0x1006)}, /* DEC3000-s */ 1746 /*{USB_DEVICE(0x0b48, 0x1007)}, Unconfirmed */ 1747 {USB_DEVICE(0x0b48, 0x1008)}, /* DEC2000-t */ 1748 {USB_DEVICE(0x0b48, 0x1009)}, /* DEC2540-t */ 1749 {} 1750 }; 1751 1752 static struct usb_driver ttusb_dec_driver = { 1753 .name = "ttusb-dec", 1754 .probe = ttusb_dec_probe, 1755 .disconnect = ttusb_dec_disconnect, 1756 .id_table = ttusb_dec_table, 1757 }; 1758 1759 module_usb_driver(ttusb_dec_driver); 1760 1761 MODULE_AUTHOR("Alex Woods <linux-dvb@giblets.org>"); 1762 MODULE_DESCRIPTION(DRIVER_NAME); 1763 MODULE_LICENSE("GPL"); 1764 MODULE_DEVICE_TABLE(usb, ttusb_dec_table); 1765