projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'stable-4.6' of git://git.infradead.org/users/pcmoore/selinux into next
[deliverable/linux.git] / drivers / media / usb / ttusb-dec / ttusb_dec.c
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 const 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);
Linux kernel - Deliverables
This page took 0.069263 seconds and 5 git commands to generate.