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