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