4 * Copyright (C) 2003-2004 Alex Woods <linux-dvb@giblets.org>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 #include <asm/semaphore.h>
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 #if defined(CONFIG_CRC32) || defined(CONFIG_CRC32_MODULE)
32 #include <linux/crc32.h>
34 #warning "CRC checking of firmware not available"
36 #include <linux/init.h>
39 #include "dvb_demux.h"
41 #include "dvb_filter.h"
42 #include "dvb_frontend.h"
46 static int output_pva = 0;
48 #define dprintk if (debug) printk
50 #define DRIVER_NAME "TechnoTrend/Hauppauge DEC USB"
52 #define COMMAND_PIPE 0x03
53 #define RESULT_PIPE 0x84
57 #define COMMAND_PACKET_SIZE 0x3c
58 #define ARM_PACKET_SIZE 0x1000
60 #define ISO_BUF_COUNT 0x04
61 #define FRAMES_PER_ISO_BUF 0x04
62 #define ISO_FRAME_SIZE 0x03FF
64 #define MAX_PVA_LENGTH 6144
66 #define LOF_HI 10600000
67 #define LOF_LO 9750000
69 enum ttusb_dec_model {
75 enum ttusb_dec_packet_type {
77 TTUSB_DEC_PACKET_SECTION,
78 TTUSB_DEC_PACKET_EMPTY
81 enum ttusb_dec_interface {
82 TTUSB_DEC_INTERFACE_INITIAL,
83 TTUSB_DEC_INTERFACE_IN,
84 TTUSB_DEC_INTERFACE_OUT
88 enum ttusb_dec_model model;
94 struct dvb_adapter *adapter;
96 struct dvb_demux demux;
97 struct dmx_frontend frontend;
98 struct dvb_i2c_bus i2c_bus;
99 struct dvb_net dvb_net;
100 struct dvb_frontend_info *frontend_info;
101 int (*frontend_ioctl) (struct dvb_frontend *, unsigned int, void *);
103 u16 pid[DMX_PES_OTHER];
108 struct usb_device *udev;
110 unsigned int command_pipe;
111 unsigned int result_pipe;
112 unsigned int in_pipe;
113 unsigned int out_pipe;
114 enum ttusb_dec_interface interface;
115 struct semaphore usb_sem;
118 dma_addr_t iso_dma_handle;
119 struct urb *iso_urb[ISO_BUF_COUNT];
120 int iso_stream_count;
121 struct semaphore iso_sem;
123 u8 packet[MAX_PVA_LENGTH + 4];
124 enum ttusb_dec_packet_type packet_type;
127 int packet_payload_length;
130 int pva_stream_count;
131 int filter_stream_count;
133 struct dvb_filter_pes2ts a_pes2ts;
134 struct dvb_filter_pes2ts v_pes2ts;
136 u8 v_pes[16 + MAX_PVA_LENGTH];
140 struct list_head urb_frame_list;
141 struct tasklet_struct urb_tasklet;
142 spinlock_t urb_frame_list_lock;
144 struct dvb_demux_filter *audio_filter;
145 struct dvb_demux_filter *video_filter;
146 struct list_head filter_info_list;
147 spinlock_t filter_info_list_lock;
149 int active; /* Loaded successfully */
153 u8 data[ISO_FRAME_SIZE];
155 struct list_head urb_frame_list;
160 struct dvb_demux_filter *filter;
161 struct list_head filter_info_list;
164 static struct dvb_frontend_info dec2000t_frontend_info = {
165 .name = "TechnoTrend/Hauppauge DEC2000-t Frontend",
167 .frequency_min = 51000000,
168 .frequency_max = 858000000,
169 .frequency_stepsize = 62500,
170 .caps = FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
171 FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
172 FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QAM_AUTO |
173 FE_CAN_TRANSMISSION_MODE_AUTO | FE_CAN_GUARD_INTERVAL_AUTO |
174 FE_CAN_HIERARCHY_AUTO,
177 static struct dvb_frontend_info dec3000s_frontend_info = {
178 .name = "TechnoTrend/Hauppauge DEC3000-s Frontend",
180 .frequency_min = 950000,
181 .frequency_max = 2150000,
182 .frequency_stepsize = 125,
183 .caps = FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
184 FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
185 FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QAM_AUTO |
186 FE_CAN_TRANSMISSION_MODE_AUTO | FE_CAN_GUARD_INTERVAL_AUTO |
187 FE_CAN_HIERARCHY_AUTO,
190 static void ttusb_dec_set_model(struct ttusb_dec *dec,
191 enum ttusb_dec_model model);
193 static u16 crc16(u16 crc, const u8 *buf, size_t len)
201 crc ^= (tmp ^ (tmp << 1)) << 4;
206 static int ttusb_dec_send_command(struct ttusb_dec *dec, const u8 command,
207 int param_length, const u8 params[],
208 int *result_length, u8 cmd_result[])
210 int result, actual_len, i;
213 dprintk("%s\n", __FUNCTION__);
215 b = kmalloc(COMMAND_PACKET_SIZE + 4, GFP_KERNEL);
219 if ((result = down_interruptible(&dec->usb_sem))) {
221 printk("%s: Failed to down usb semaphore.\n", __FUNCTION__);
226 b[1] = ++dec->trans_count;
231 memcpy(&b[4], params, param_length);
234 printk("%s: command: ", __FUNCTION__);
235 for (i = 0; i < param_length + 4; i++)
236 printk("0x%02X ", b[i]);
240 result = usb_bulk_msg(dec->udev, dec->command_pipe, b,
241 COMMAND_PACKET_SIZE + 4, &actual_len, HZ);
244 printk("%s: command bulk message failed: error %d\n",
245 __FUNCTION__, result);
251 result = usb_bulk_msg(dec->udev, dec->result_pipe, b,
252 COMMAND_PACKET_SIZE + 4, &actual_len, HZ);
255 printk("%s: result bulk message failed: error %d\n",
256 __FUNCTION__, result);
262 printk("%s: result: ", __FUNCTION__);
263 for (i = 0; i < actual_len; i++)
264 printk("0x%02X ", b[i]);
269 *result_length = b[3];
270 if (cmd_result && b[3] > 0)
271 memcpy(cmd_result, &b[4], b[3]);
280 static int ttusb_dec_get_stb_state (struct ttusb_dec *dec, unsigned int *mode,
281 unsigned int *model, unsigned int *version)
283 u8 c[COMMAND_PACKET_SIZE];
288 dprintk("%s\n", __FUNCTION__);
290 result = ttusb_dec_send_command(dec, 0x08, 0, NULL, &c_length, c);
294 if (c_length >= 0x0c) {
300 memcpy(&tmp, &c[4], 4);
303 if (version != NULL) {
304 memcpy(&tmp, &c[8], 4);
305 *version = ntohl(tmp);
313 static int ttusb_dec_audio_pes2ts_cb(void *priv, unsigned char *data)
315 struct ttusb_dec *dec = (struct ttusb_dec *)priv;
317 dec->audio_filter->feed->cb.ts(data, 188, NULL, 0,
318 &dec->audio_filter->feed->feed.ts,
324 static int ttusb_dec_video_pes2ts_cb(void *priv, unsigned char *data)
326 struct ttusb_dec *dec = (struct ttusb_dec *)priv;
328 dec->video_filter->feed->cb.ts(data, 188, NULL, 0,
329 &dec->video_filter->feed->feed.ts,
335 static void ttusb_dec_set_pids(struct ttusb_dec *dec)
337 u8 b[] = { 0x00, 0x00, 0x00, 0x00,
338 0x00, 0x00, 0xff, 0xff,
339 0xff, 0xff, 0xff, 0xff };
341 u16 pcr = htons(dec->pid[DMX_PES_PCR]);
342 u16 audio = htons(dec->pid[DMX_PES_AUDIO]);
343 u16 video = htons(dec->pid[DMX_PES_VIDEO]);
345 dprintk("%s\n", __FUNCTION__);
347 memcpy(&b[0], &pcr, 2);
348 memcpy(&b[2], &audio, 2);
349 memcpy(&b[4], &video, 2);
351 ttusb_dec_send_command(dec, 0x50, sizeof(b), b, NULL, NULL);
353 dvb_filter_pes2ts_init(&dec->a_pes2ts, dec->pid[DMX_PES_AUDIO],
354 ttusb_dec_audio_pes2ts_cb, dec);
355 dvb_filter_pes2ts_init(&dec->v_pes2ts, dec->pid[DMX_PES_VIDEO],
356 ttusb_dec_video_pes2ts_cb, dec);
357 dec->v_pes_length = 0;
358 dec->v_pes_postbytes = 0;
361 static void ttusb_dec_process_pva(struct ttusb_dec *dec, u8 *pva, int length)
364 printk("%s: packet too short - discarding\n", __FUNCTION__);
368 if (length > 8 + MAX_PVA_LENGTH) {
369 printk("%s: packet too long - discarding\n", __FUNCTION__);
375 case 0x01: { /* VideoStream */
376 int prebytes = pva[5] & 0x03;
377 int postbytes = (pva[5] & 0x0c) >> 2;
378 u16 v_pes_payload_length;
381 dec->video_filter->feed->cb.ts(pva, length, NULL, 0,
382 &dec->video_filter->feed->feed.ts, DMX_OK);
386 if (dec->v_pes_postbytes > 0 &&
387 dec->v_pes_postbytes == prebytes) {
388 memcpy(&dec->v_pes[dec->v_pes_length],
391 dvb_filter_pes2ts(&dec->v_pes2ts, dec->v_pes,
392 dec->v_pes_length + prebytes, 1);
396 dec->v_pes[7] = 0x80;
397 dec->v_pes[8] = 0x05;
399 dec->v_pes[9] = 0x21 | ((pva[8] & 0xc0) >> 5);
400 dec->v_pes[10] = ((pva[8] & 0x3f) << 2) |
401 ((pva[9] & 0xc0) >> 6);
402 dec->v_pes[11] = 0x01 |
403 ((pva[9] & 0x3f) << 2) |
404 ((pva[10] & 0x80) >> 6);
405 dec->v_pes[12] = ((pva[10] & 0x7f) << 1) |
406 ((pva[11] & 0xc0) >> 7);
407 dec->v_pes[13] = 0x01 | ((pva[11] & 0x7f) << 1);
409 memcpy(&dec->v_pes[14], &pva[12 + prebytes],
410 length - 12 - prebytes);
411 dec->v_pes_length = 14 + length - 12 - prebytes;
413 dec->v_pes[7] = 0x00;
414 dec->v_pes[8] = 0x00;
416 memcpy(&dec->v_pes[9], &pva[8], length - 8);
417 dec->v_pes_length = 9 + length - 8;
420 dec->v_pes_postbytes = postbytes;
422 if (dec->v_pes[9 + dec->v_pes[8]] == 0x00 &&
423 dec->v_pes[10 + dec->v_pes[8]] == 0x00 &&
424 dec->v_pes[11 + dec->v_pes[8]] == 0x01)
425 dec->v_pes[6] = 0x84;
427 dec->v_pes[6] = 0x80;
429 v_pes_payload_length = htons(dec->v_pes_length - 6 +
431 memcpy(&dec->v_pes[4], &v_pes_payload_length, 2);
434 dvb_filter_pes2ts(&dec->v_pes2ts, dec->v_pes,
435 dec->v_pes_length, 1);
440 case 0x02: /* MainAudioStream */
442 dec->audio_filter->feed->cb.ts(pva, length, NULL, 0,
443 &dec->audio_filter->feed->feed.ts, DMX_OK);
447 dvb_filter_pes2ts(&dec->a_pes2ts, &pva[8], length - 8,
452 printk("%s: unknown PVA type: %02x.\n", __FUNCTION__,
458 static void ttusb_dec_process_filter(struct ttusb_dec *dec, u8 *packet,
461 struct list_head *item;
462 struct filter_info *finfo;
463 struct dvb_demux_filter *filter = NULL;
468 spin_lock_irqsave(&dec->filter_info_list_lock, flags);
469 for (item = dec->filter_info_list.next; item != &dec->filter_info_list;
471 finfo = list_entry(item, struct filter_info, filter_info_list);
472 if (finfo->stream_id == sid) {
473 filter = finfo->filter;
477 spin_unlock_irqrestore(&dec->filter_info_list_lock, flags);
480 filter->feed->cb.sec(&packet[2], length - 2, NULL, 0,
481 &filter->filter, DMX_OK);
484 static void ttusb_dec_process_packet(struct ttusb_dec *dec)
490 if (dec->packet_length % 2) {
491 printk("%s: odd sized packet - discarding\n", __FUNCTION__);
495 for (i = 0; i < dec->packet_length; i += 2)
496 csum ^= ((dec->packet[i] << 8) + dec->packet[i + 1]);
499 printk("%s: checksum failed - discarding\n", __FUNCTION__);
503 packet_id = dec->packet[dec->packet_length - 4] << 8;
504 packet_id += dec->packet[dec->packet_length - 3];
506 if ((packet_id != dec->next_packet_id) && dec->next_packet_id) {
507 printk("%s: warning: lost packets between %u and %u\n",
508 __FUNCTION__, dec->next_packet_id - 1, packet_id);
511 if (packet_id == 0xffff)
512 dec->next_packet_id = 0x8000;
514 dec->next_packet_id = packet_id + 1;
516 switch (dec->packet_type) {
517 case TTUSB_DEC_PACKET_PVA:
518 if (dec->pva_stream_count)
519 ttusb_dec_process_pva(dec, dec->packet,
520 dec->packet_payload_length);
523 case TTUSB_DEC_PACKET_SECTION:
524 if (dec->filter_stream_count)
525 ttusb_dec_process_filter(dec, dec->packet,
526 dec->packet_payload_length);
529 case TTUSB_DEC_PACKET_EMPTY:
534 static void swap_bytes(u8 *b, int length)
538 length -= length % 2;
539 for (; length; b += 2, length -= 2) {
546 static void ttusb_dec_process_urb_frame(struct ttusb_dec * dec, u8 * b,
549 swap_bytes(b, length);
552 switch (dec->packet_state) {
560 dec->packet_state = 0;
568 dec->packet_length = 0;
569 } else if (*b != 0xaa) {
570 dec->packet_state = 0;
578 dec->packet[dec->packet_length++] = *b++;
580 if (dec->packet_length == 2) {
581 if (dec->packet[0] == 'A' &&
582 dec->packet[1] == 'V') {
584 TTUSB_DEC_PACKET_PVA;
586 } else if (dec->packet[0] == 'S') {
588 TTUSB_DEC_PACKET_SECTION;
590 } else if (dec->packet[0] == 0x00) {
592 TTUSB_DEC_PACKET_EMPTY;
593 dec->packet_payload_length = 2;
594 dec->packet_state = 7;
596 printk("%s: unknown packet type: "
597 "%02x%02x\n", __FUNCTION__,
598 dec->packet[0], dec->packet[1]);
599 dec->packet_state = 0;
607 dec->packet[dec->packet_length++] = *b++;
609 if (dec->packet_type == TTUSB_DEC_PACKET_PVA &&
610 dec->packet_length == 8) {
612 dec->packet_payload_length = 8 +
613 (dec->packet[6] << 8) +
615 } else if (dec->packet_type ==
616 TTUSB_DEC_PACKET_SECTION &&
617 dec->packet_length == 5) {
619 dec->packet_payload_length = 5 +
620 ((dec->packet[3] & 0x0f) << 8) +
628 int remainder = dec->packet_payload_length -
631 if (length >= remainder) {
632 memcpy(dec->packet + dec->packet_length,
634 dec->packet_length += remainder;
639 memcpy(&dec->packet[dec->packet_length],
641 dec->packet_length += length;
651 dec->packet[dec->packet_length++] = *b++;
653 if (dec->packet_type == TTUSB_DEC_PACKET_SECTION &&
654 dec->packet_payload_length % 2)
657 if (dec->packet_length ==
658 dec->packet_payload_length + tail) {
659 ttusb_dec_process_packet(dec);
660 dec->packet_state = 0;
668 printk("%s: illegal packet state encountered.\n",
670 dec->packet_state = 0;
675 static void ttusb_dec_process_urb_frame_list(unsigned long data)
677 struct ttusb_dec *dec = (struct ttusb_dec *)data;
678 struct list_head *item;
679 struct urb_frame *frame;
683 spin_lock_irqsave(&dec->urb_frame_list_lock, flags);
684 if ((item = dec->urb_frame_list.next) != &dec->urb_frame_list) {
685 frame = list_entry(item, struct urb_frame,
687 list_del(&frame->urb_frame_list);
689 spin_unlock_irqrestore(&dec->urb_frame_list_lock,
693 spin_unlock_irqrestore(&dec->urb_frame_list_lock, flags);
695 ttusb_dec_process_urb_frame(dec, frame->data, frame->length);
700 static void ttusb_dec_process_urb(struct urb *urb, struct pt_regs *ptregs)
702 struct ttusb_dec *dec = urb->context;
707 for (i = 0; i < FRAMES_PER_ISO_BUF; i++) {
708 struct usb_iso_packet_descriptor *d;
712 struct urb_frame *frame;
714 d = &urb->iso_frame_desc[i];
715 b = urb->transfer_buffer + d->offset;
716 length = d->actual_length;
718 if ((frame = kmalloc(sizeof(struct urb_frame),
722 memcpy(frame->data, b, length);
723 frame->length = length;
725 spin_lock_irqsave(&dec->urb_frame_list_lock,
727 list_add_tail(&frame->urb_frame_list,
728 &dec->urb_frame_list);
729 spin_unlock_irqrestore(&dec->urb_frame_list_lock,
732 tasklet_schedule(&dec->urb_tasklet);
736 /* -ENOENT is expected when unlinking urbs */
737 if (urb->status != -ENOENT)
738 dprintk("%s: urb error: %d\n", __FUNCTION__,
742 if (dec->iso_stream_count)
743 usb_submit_urb(urb, GFP_ATOMIC);
746 static void ttusb_dec_setup_urbs(struct ttusb_dec *dec)
748 int i, j, buffer_offset = 0;
750 dprintk("%s\n", __FUNCTION__);
752 for (i = 0; i < ISO_BUF_COUNT; i++) {
753 int frame_offset = 0;
754 struct urb *urb = dec->iso_urb[i];
756 urb->dev = dec->udev;
758 urb->complete = ttusb_dec_process_urb;
759 urb->pipe = dec->in_pipe;
760 urb->transfer_flags = URB_ISO_ASAP;
762 urb->number_of_packets = FRAMES_PER_ISO_BUF;
763 urb->transfer_buffer_length = ISO_FRAME_SIZE *
765 urb->transfer_buffer = dec->iso_buffer + buffer_offset;
766 buffer_offset += ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF;
768 for (j = 0; j < FRAMES_PER_ISO_BUF; j++) {
769 urb->iso_frame_desc[j].offset = frame_offset;
770 urb->iso_frame_desc[j].length = ISO_FRAME_SIZE;
771 frame_offset += ISO_FRAME_SIZE;
776 static void ttusb_dec_stop_iso_xfer(struct ttusb_dec *dec)
780 dprintk("%s\n", __FUNCTION__);
782 if (down_interruptible(&dec->iso_sem))
785 dec->iso_stream_count--;
787 if (!dec->iso_stream_count) {
788 for (i = 0; i < ISO_BUF_COUNT; i++)
789 usb_unlink_urb(dec->iso_urb[i]);
795 /* Setting the interface of the DEC tends to take down the USB communications
796 * for a short period, so it's important not to call this function just before
797 * trying to talk to it.
799 static int ttusb_dec_set_interface(struct ttusb_dec *dec,
800 enum ttusb_dec_interface interface)
805 if (interface != dec->interface) {
807 case TTUSB_DEC_INTERFACE_INITIAL:
808 result = usb_set_interface(dec->udev, 0, 0);
810 case TTUSB_DEC_INTERFACE_IN:
811 result = ttusb_dec_send_command(dec, 0x80, sizeof(b),
815 result = usb_set_interface(dec->udev, 0, 7);
817 case TTUSB_DEC_INTERFACE_OUT:
818 result = usb_set_interface(dec->udev, 0, 1);
825 dec->interface = interface;
831 static int ttusb_dec_start_iso_xfer(struct ttusb_dec *dec)
835 dprintk("%s\n", __FUNCTION__);
837 if (down_interruptible(&dec->iso_sem))
840 if (!dec->iso_stream_count) {
841 ttusb_dec_setup_urbs(dec);
843 dec->packet_state = 0;
844 dec->v_pes_postbytes = 0;
845 dec->next_packet_id = 0;
847 for (i = 0; i < ISO_BUF_COUNT; i++) {
848 if ((result = usb_submit_urb(dec->iso_urb[i],
850 printk("%s: failed urb submission %d: "
851 "error %d\n", __FUNCTION__, i, result);
854 usb_unlink_urb(dec->iso_urb[i - 1]);
864 dec->iso_stream_count++;
871 static int ttusb_dec_start_ts_feed(struct dvb_demux_feed *dvbdmxfeed)
873 struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
874 struct ttusb_dec *dec = dvbdmx->priv;
878 dprintk("%s\n", __FUNCTION__);
880 dprintk(" ts_type:");
882 if (dvbdmxfeed->ts_type & TS_DECODER)
883 dprintk(" TS_DECODER");
885 if (dvbdmxfeed->ts_type & TS_PACKET)
886 dprintk(" TS_PACKET");
888 if (dvbdmxfeed->ts_type & TS_PAYLOAD_ONLY)
889 dprintk(" TS_PAYLOAD_ONLY");
893 switch (dvbdmxfeed->pes_type) {
895 case DMX_TS_PES_VIDEO:
896 dprintk(" pes_type: DMX_TS_PES_VIDEO\n");
897 dec->pid[DMX_PES_PCR] = dvbdmxfeed->pid;
898 dec->pid[DMX_PES_VIDEO] = dvbdmxfeed->pid;
899 dec->video_filter = dvbdmxfeed->filter;
900 ttusb_dec_set_pids(dec);
903 case DMX_TS_PES_AUDIO:
904 dprintk(" pes_type: DMX_TS_PES_AUDIO\n");
905 dec->pid[DMX_PES_AUDIO] = dvbdmxfeed->pid;
906 dec->audio_filter = dvbdmxfeed->filter;
907 ttusb_dec_set_pids(dec);
910 case DMX_TS_PES_TELETEXT:
911 dec->pid[DMX_PES_TELETEXT] = dvbdmxfeed->pid;
912 dprintk(" pes_type: DMX_TS_PES_TELETEXT\n");
916 dprintk(" pes_type: DMX_TS_PES_PCR\n");
917 dec->pid[DMX_PES_PCR] = dvbdmxfeed->pid;
918 ttusb_dec_set_pids(dec);
921 case DMX_TS_PES_OTHER:
922 dprintk(" pes_type: DMX_TS_PES_OTHER\n");
926 dprintk(" pes_type: unknown (%d)\n", dvbdmxfeed->pes_type);
931 result = ttusb_dec_send_command(dec, 0x80, sizeof(b0), b0, NULL, NULL);
935 dec->pva_stream_count++;
936 return ttusb_dec_start_iso_xfer(dec);
939 static int ttusb_dec_start_sec_feed(struct dvb_demux_feed *dvbdmxfeed)
941 struct ttusb_dec *dec = dvbdmxfeed->demux->priv;
942 u8 b0[] = { 0x00, 0x00, 0x00, 0x01,
943 0x00, 0x00, 0x00, 0x00,
944 0x00, 0x00, 0x00, 0x00,
945 0x00, 0x00, 0x00, 0x00,
946 0x00, 0xff, 0x00, 0x00,
947 0x00, 0x00, 0x00, 0x00,
948 0x00, 0x00, 0x00, 0x00,
951 u8 c[COMMAND_PACKET_SIZE];
954 struct filter_info *finfo;
958 dprintk("%s\n", __FUNCTION__);
960 pid = htons(dvbdmxfeed->pid);
961 memcpy(&b0[0], &pid, 2);
962 memcpy(&b0[4], &x, 1);
963 memcpy(&b0[5], &dvbdmxfeed->filter->filter.filter_value[0], 1);
965 result = ttusb_dec_send_command(dec, 0x60, sizeof(b0), b0,
970 if (!(finfo = kmalloc(sizeof(struct filter_info),
974 finfo->stream_id = c[1];
975 finfo->filter = dvbdmxfeed->filter;
977 spin_lock_irqsave(&dec->filter_info_list_lock, flags);
978 list_add_tail(&finfo->filter_info_list,
979 &dec->filter_info_list);
980 spin_unlock_irqrestore(&dec->filter_info_list_lock,
983 dvbdmxfeed->priv = finfo;
985 dec->filter_stream_count++;
986 return ttusb_dec_start_iso_xfer(dec);
994 static int ttusb_dec_start_feed(struct dvb_demux_feed *dvbdmxfeed)
996 struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
998 dprintk("%s\n", __FUNCTION__);
1000 if (!dvbdmx->dmx.frontend)
1003 dprintk(" pid: 0x%04X\n", dvbdmxfeed->pid);
1005 switch (dvbdmxfeed->type) {
1008 return ttusb_dec_start_ts_feed(dvbdmxfeed);
1012 return ttusb_dec_start_sec_feed(dvbdmxfeed);
1016 dprintk(" type: unknown (%d)\n", dvbdmxfeed->type);
1022 static int ttusb_dec_stop_ts_feed(struct dvb_demux_feed *dvbdmxfeed)
1024 struct ttusb_dec *dec = dvbdmxfeed->demux->priv;
1027 ttusb_dec_send_command(dec, 0x81, sizeof(b0), b0, NULL, NULL);
1029 dec->pva_stream_count--;
1031 ttusb_dec_stop_iso_xfer(dec);
1036 static int ttusb_dec_stop_sec_feed(struct dvb_demux_feed *dvbdmxfeed)
1038 struct ttusb_dec *dec = dvbdmxfeed->demux->priv;
1039 u8 b0[] = { 0x00, 0x00 };
1040 struct filter_info *finfo = (struct filter_info *)dvbdmxfeed->priv;
1041 unsigned long flags;
1043 b0[1] = finfo->stream_id;
1044 spin_lock_irqsave(&dec->filter_info_list_lock, flags);
1045 list_del(&finfo->filter_info_list);
1046 spin_unlock_irqrestore(&dec->filter_info_list_lock, flags);
1048 ttusb_dec_send_command(dec, 0x62, sizeof(b0), b0, NULL, NULL);
1050 dec->filter_stream_count--;
1052 ttusb_dec_stop_iso_xfer(dec);
1057 static int ttusb_dec_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
1059 dprintk("%s\n", __FUNCTION__);
1061 switch (dvbdmxfeed->type) {
1063 return ttusb_dec_stop_ts_feed(dvbdmxfeed);
1067 return ttusb_dec_stop_sec_feed(dvbdmxfeed);
1074 static void ttusb_dec_free_iso_urbs(struct ttusb_dec *dec)
1078 dprintk("%s\n", __FUNCTION__);
1080 for (i = 0; i < ISO_BUF_COUNT; i++)
1081 if (dec->iso_urb[i])
1082 usb_free_urb(dec->iso_urb[i]);
1084 pci_free_consistent(NULL,
1085 ISO_FRAME_SIZE * (FRAMES_PER_ISO_BUF *
1087 dec->iso_buffer, dec->iso_dma_handle);
1090 static int ttusb_dec_alloc_iso_urbs(struct ttusb_dec *dec)
1094 dprintk("%s\n", __FUNCTION__);
1096 dec->iso_buffer = pci_alloc_consistent(NULL,
1098 (FRAMES_PER_ISO_BUF *
1100 &dec->iso_dma_handle);
1102 memset(dec->iso_buffer, 0,
1103 sizeof(ISO_FRAME_SIZE * (FRAMES_PER_ISO_BUF * ISO_BUF_COUNT)));
1105 for (i = 0; i < ISO_BUF_COUNT; i++) {
1108 if (!(urb = usb_alloc_urb(FRAMES_PER_ISO_BUF, GFP_ATOMIC))) {
1109 ttusb_dec_free_iso_urbs(dec);
1113 dec->iso_urb[i] = urb;
1116 ttusb_dec_setup_urbs(dec);
1121 static void ttusb_dec_init_tasklet(struct ttusb_dec *dec)
1123 dec->urb_frame_list_lock = SPIN_LOCK_UNLOCKED;
1124 INIT_LIST_HEAD(&dec->urb_frame_list);
1125 tasklet_init(&dec->urb_tasklet, ttusb_dec_process_urb_frame_list,
1126 (unsigned long)dec);
1129 static void ttusb_dec_init_v_pes(struct ttusb_dec *dec)
1131 dprintk("%s\n", __FUNCTION__);
1133 dec->v_pes[0] = 0x00;
1134 dec->v_pes[1] = 0x00;
1135 dec->v_pes[2] = 0x01;
1136 dec->v_pes[3] = 0xe0;
1139 static void ttusb_dec_init_usb(struct ttusb_dec *dec)
1141 dprintk("%s\n", __FUNCTION__);
1143 sema_init(&dec->usb_sem, 1);
1144 sema_init(&dec->iso_sem, 1);
1146 dec->command_pipe = usb_sndbulkpipe(dec->udev, COMMAND_PIPE);
1147 dec->result_pipe = usb_rcvbulkpipe(dec->udev, RESULT_PIPE);
1148 dec->in_pipe = usb_rcvisocpipe(dec->udev, IN_PIPE);
1149 dec->out_pipe = usb_sndisocpipe(dec->udev, OUT_PIPE);
1151 ttusb_dec_alloc_iso_urbs(dec);
1154 static int ttusb_dec_boot_dsp(struct ttusb_dec *dec)
1156 int i, j, actual_len, result, size, trans_count;
1157 u8 b0[] = { 0x00, 0x00, 0x00, 0x00,
1158 0x00, 0x00, 0x00, 0x00,
1163 u8 *firmware = NULL;
1164 size_t firmware_size = 0;
1165 u16 firmware_csum = 0;
1166 u16 firmware_csum_ns;
1167 u32 firmware_size_nl;
1168 #if defined(CONFIG_CRC32) || defined(CONFIG_CRC32_MODULE)
1169 u32 crc32_csum, crc32_check, tmp;
1171 const struct firmware *fw_entry = NULL;
1172 dprintk("%s\n", __FUNCTION__);
1174 if (request_firmware(&fw_entry, dec->firmware_name, &dec->udev->dev)) {
1175 printk(KERN_ERR "%s: Firmware (%s) unavailable.\n",
1176 __FUNCTION__, dec->firmware_name);
1180 firmware = fw_entry->data;
1181 firmware_size = fw_entry->size;
1183 if (firmware_size < 60) {
1184 printk("%s: firmware size too small for DSP code (%zu < 60).\n",
1185 __FUNCTION__, firmware_size);
1189 /* a 32 bit checksum over the first 56 bytes of the DSP Code is stored
1190 at offset 56 of file, so use it to check if the firmware file is
1192 #if defined(CONFIG_CRC32) || defined(CONFIG_CRC32_MODULE)
1193 crc32_csum = crc32(~0L, firmware, 56) ^ ~0L;
1194 memcpy(&tmp, &firmware[56], 4);
1195 crc32_check = htonl(tmp);
1196 if (crc32_csum != crc32_check) {
1197 printk("%s: crc32 check of DSP code failed (calculated "
1198 "0x%08x != 0x%08x in file), file invalid.\n",
1199 __FUNCTION__, crc32_csum, crc32_check);
1203 memcpy(idstring, &firmware[36], 20);
1204 idstring[20] = '\0';
1205 printk(KERN_INFO "ttusb_dec: found DSP code \"%s\".\n", idstring);
1207 firmware_size_nl = htonl(firmware_size);
1208 memcpy(b0, &firmware_size_nl, 4);
1209 firmware_csum = crc16(~0, firmware, firmware_size) ^ ~0;
1210 firmware_csum_ns = htons(firmware_csum);
1211 memcpy(&b0[6], &firmware_csum_ns, 2);
1213 result = ttusb_dec_send_command(dec, 0x41, sizeof(b0), b0, NULL, NULL);
1221 b = kmalloc(ARM_PACKET_SIZE, GFP_KERNEL);
1225 for (i = 0; i < firmware_size; i += COMMAND_PACKET_SIZE) {
1226 size = firmware_size - i;
1227 if (size > COMMAND_PACKET_SIZE)
1228 size = COMMAND_PACKET_SIZE;
1231 b[j + 1] = trans_count++;
1234 memcpy(&b[j + 4], &firmware[i], size);
1236 j += COMMAND_PACKET_SIZE + 4;
1238 if (j >= ARM_PACKET_SIZE) {
1239 result = usb_bulk_msg(dec->udev, dec->command_pipe, b,
1240 ARM_PACKET_SIZE, &actual_len,
1243 } else if (size < COMMAND_PACKET_SIZE) {
1244 result = usb_bulk_msg(dec->udev, dec->command_pipe, b,
1245 j - COMMAND_PACKET_SIZE + size,
1246 &actual_len, HZ / 10);
1250 result = ttusb_dec_send_command(dec, 0x43, sizeof(b1), b1, NULL, NULL);
1257 static int ttusb_dec_init_stb(struct ttusb_dec *dec)
1260 unsigned int mode, model, version;
1262 dprintk("%s\n", __FUNCTION__);
1264 result = ttusb_dec_get_stb_state(dec, &mode, &model, &version);
1268 if (version == 0xABCDEFAB)
1269 printk(KERN_INFO "ttusb_dec: no version "
1270 "info in Firmware\n");
1272 printk(KERN_INFO "ttusb_dec: Firmware "
1274 version >> 24, (version >> 16) & 0xff,
1275 (version >> 8) & 0xff, version & 0xff);
1277 result = ttusb_dec_boot_dsp(dec);
1283 /* We can't trust the USB IDs that some firmwares
1288 ttusb_dec_set_model(dec, TTUSB_DEC3000S);
1291 ttusb_dec_set_model(dec, TTUSB_DEC2000T);
1294 ttusb_dec_set_model(dec, TTUSB_DEC2540T);
1297 printk(KERN_ERR "%s: unknown model returned "
1298 "by firmware (%08x) - please report\n",
1299 __FUNCTION__, model);
1304 if (version >= 0x01770000)
1305 dec->can_playback = 1;
1314 static int ttusb_dec_init_dvb(struct ttusb_dec *dec)
1318 dprintk("%s\n", __FUNCTION__);
1320 if ((result = dvb_register_adapter(&dec->adapter,
1321 dec->model_name, THIS_MODULE)) < 0) {
1322 printk("%s: dvb_register_adapter failed: error %d\n",
1323 __FUNCTION__, result);
1328 dec->demux.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING;
1330 dec->demux.priv = (void *)dec;
1331 dec->demux.filternum = 31;
1332 dec->demux.feednum = 31;
1333 dec->demux.start_feed = ttusb_dec_start_feed;
1334 dec->demux.stop_feed = ttusb_dec_stop_feed;
1335 dec->demux.write_to_decoder = NULL;
1337 if ((result = dvb_dmx_init(&dec->demux)) < 0) {
1338 printk("%s: dvb_dmx_init failed: error %d\n", __FUNCTION__,
1341 dvb_unregister_adapter(dec->adapter);
1346 dec->dmxdev.filternum = 32;
1347 dec->dmxdev.demux = &dec->demux.dmx;
1348 dec->dmxdev.capabilities = 0;
1350 if ((result = dvb_dmxdev_init(&dec->dmxdev, dec->adapter)) < 0) {
1351 printk("%s: dvb_dmxdev_init failed: error %d\n",
1352 __FUNCTION__, result);
1354 dvb_dmx_release(&dec->demux);
1355 dvb_unregister_adapter(dec->adapter);
1360 dec->frontend.source = DMX_FRONTEND_0;
1362 if ((result = dec->demux.dmx.add_frontend(&dec->demux.dmx,
1363 &dec->frontend)) < 0) {
1364 printk("%s: dvb_dmx_init failed: error %d\n", __FUNCTION__,
1367 dvb_dmxdev_release(&dec->dmxdev);
1368 dvb_dmx_release(&dec->demux);
1369 dvb_unregister_adapter(dec->adapter);
1374 if ((result = dec->demux.dmx.connect_frontend(&dec->demux.dmx,
1375 &dec->frontend)) < 0) {
1376 printk("%s: dvb_dmx_init failed: error %d\n", __FUNCTION__,
1379 dec->demux.dmx.remove_frontend(&dec->demux.dmx, &dec->frontend);
1380 dvb_dmxdev_release(&dec->dmxdev);
1381 dvb_dmx_release(&dec->demux);
1382 dvb_unregister_adapter(dec->adapter);
1387 dvb_net_init(dec->adapter, &dec->dvb_net, &dec->demux.dmx);
1392 static void ttusb_dec_exit_dvb(struct ttusb_dec *dec)
1394 dprintk("%s\n", __FUNCTION__);
1396 dvb_net_release(&dec->dvb_net);
1397 dec->demux.dmx.close(&dec->demux.dmx);
1398 dec->demux.dmx.remove_frontend(&dec->demux.dmx, &dec->frontend);
1399 dvb_dmxdev_release(&dec->dmxdev);
1400 dvb_dmx_release(&dec->demux);
1401 dvb_unregister_adapter(dec->adapter);
1404 static void ttusb_dec_exit_usb(struct ttusb_dec *dec)
1408 dprintk("%s\n", __FUNCTION__);
1410 dec->iso_stream_count = 0;
1412 for (i = 0; i < ISO_BUF_COUNT; i++)
1413 usb_unlink_urb(dec->iso_urb[i]);
1415 ttusb_dec_free_iso_urbs(dec);
1418 static void ttusb_dec_exit_tasklet(struct ttusb_dec *dec)
1420 struct list_head *item;
1421 struct urb_frame *frame;
1423 tasklet_kill(&dec->urb_tasklet);
1425 while ((item = dec->urb_frame_list.next) != &dec->urb_frame_list) {
1426 frame = list_entry(item, struct urb_frame, urb_frame_list);
1427 list_del(&frame->urb_frame_list);
1432 static int ttusb_dec_2000t_frontend_ioctl(struct dvb_frontend *fe, unsigned int cmd,
1435 struct ttusb_dec *dec = fe->data;
1437 dprintk("%s\n", __FUNCTION__);
1442 dprintk("%s: FE_GET_INFO\n", __FUNCTION__);
1443 memcpy(arg, dec->frontend_info,
1444 sizeof (struct dvb_frontend_info));
1447 case FE_READ_STATUS: {
1448 fe_status_t *status = (fe_status_t *)arg;
1449 dprintk("%s: FE_READ_STATUS\n", __FUNCTION__);
1450 *status = FE_HAS_SIGNAL | FE_HAS_VITERBI |
1451 FE_HAS_SYNC | FE_HAS_CARRIER | FE_HAS_LOCK;
1456 u32 *ber = (u32 *)arg;
1457 dprintk("%s: FE_READ_BER\n", __FUNCTION__);
1463 case FE_READ_SIGNAL_STRENGTH: {
1464 dprintk("%s: FE_READ_SIGNAL_STRENGTH\n", __FUNCTION__);
1471 dprintk("%s: FE_READ_SNR\n", __FUNCTION__);
1476 case FE_READ_UNCORRECTED_BLOCKS:
1477 dprintk("%s: FE_READ_UNCORRECTED_BLOCKS\n", __FUNCTION__);
1482 case FE_SET_FRONTEND: {
1483 struct dvb_frontend_parameters *p =
1484 (struct dvb_frontend_parameters *)arg;
1485 u8 b[] = { 0x00, 0x00, 0x00, 0x03,
1486 0x00, 0x00, 0x00, 0x00,
1487 0x00, 0x00, 0x00, 0x01,
1488 0x00, 0x00, 0x00, 0xff,
1489 0x00, 0x00, 0x00, 0xff };
1492 dprintk("%s: FE_SET_FRONTEND\n", __FUNCTION__);
1494 dprintk(" frequency->%d\n", p->frequency);
1495 dprintk(" symbol_rate->%d\n",
1496 p->u.qam.symbol_rate);
1497 dprintk(" inversion->%d\n", p->inversion);
1499 freq = htonl(p->frequency / 1000);
1500 memcpy(&b[4], &freq, sizeof (u32));
1501 ttusb_dec_send_command(dec, 0x71, sizeof(b), b, NULL, NULL);
1506 case FE_GET_FRONTEND:
1507 dprintk("%s: FE_GET_FRONTEND\n", __FUNCTION__);
1511 dprintk("%s: FE_SLEEP\n", __FUNCTION__);
1516 dprintk("%s: FE_INIT\n", __FUNCTION__);
1520 dprintk("%s: unknown IOCTL (0x%X)\n", __FUNCTION__, cmd);
1528 static int ttusb_dec_3000s_frontend_ioctl(struct dvb_frontend *fe,
1529 unsigned int cmd, void *arg)
1531 struct ttusb_dec *dec = fe->data;
1533 dprintk("%s\n", __FUNCTION__);
1538 dprintk("%s: FE_GET_INFO\n", __FUNCTION__);
1539 memcpy(arg, dec->frontend_info,
1540 sizeof (struct dvb_frontend_info));
1543 case FE_READ_STATUS: {
1544 fe_status_t *status = (fe_status_t *)arg;
1545 dprintk("%s: FE_READ_STATUS\n", __FUNCTION__);
1546 *status = FE_HAS_SIGNAL | FE_HAS_VITERBI |
1547 FE_HAS_SYNC | FE_HAS_CARRIER | FE_HAS_LOCK;
1552 u32 *ber = (u32 *)arg;
1553 dprintk("%s: FE_READ_BER\n", __FUNCTION__);
1559 case FE_READ_SIGNAL_STRENGTH: {
1560 dprintk("%s: FE_READ_SIGNAL_STRENGTH\n", __FUNCTION__);
1567 dprintk("%s: FE_READ_SNR\n", __FUNCTION__);
1572 case FE_READ_UNCORRECTED_BLOCKS:
1573 dprintk("%s: FE_READ_UNCORRECTED_BLOCKS\n", __FUNCTION__);
1578 case FE_SET_FRONTEND: {
1579 struct dvb_frontend_parameters *p =
1580 (struct dvb_frontend_parameters *)arg;
1581 u8 b[] = { 0x00, 0x00, 0x00, 0x01,
1582 0x00, 0x00, 0x00, 0x00,
1583 0x00, 0x00, 0x00, 0x01,
1584 0x00, 0x00, 0x00, 0x00,
1585 0x00, 0x00, 0x00, 0x00,
1586 0x00, 0x00, 0x00, 0x00,
1587 0x00, 0x00, 0x00, 0x00,
1588 0x00, 0x00, 0x00, 0x00,
1589 0x00, 0x00, 0x00, 0x00,
1590 0x00, 0x00, 0x00, 0x00 };
1596 dprintk("%s: FE_SET_FRONTEND\n", __FUNCTION__);
1598 dprintk(" frequency->%d\n", p->frequency);
1599 dprintk(" symbol_rate->%d\n",
1600 p->u.qam.symbol_rate);
1601 dprintk(" inversion->%d\n", p->inversion);
1603 freq = htonl(p->frequency * 1000 +
1604 (dec->hi_band ? LOF_HI : LOF_LO));
1605 memcpy(&b[4], &freq, sizeof(u32));
1606 sym_rate = htonl(p->u.qam.symbol_rate);
1607 memcpy(&b[12], &sym_rate, sizeof(u32));
1608 band = htonl(dec->hi_band ? LOF_HI : LOF_LO);
1609 memcpy(&b[24], &band, sizeof(u32));
1610 lnb_voltage = htonl(dec->voltage);
1611 memcpy(&b[28], &lnb_voltage, sizeof(u32));
1613 ttusb_dec_send_command(dec, 0x71, sizeof(b), b, NULL, NULL);
1618 case FE_GET_FRONTEND:
1619 dprintk("%s: FE_GET_FRONTEND\n", __FUNCTION__);
1623 dprintk("%s: FE_SLEEP\n", __FUNCTION__);
1628 dprintk("%s: FE_INIT\n", __FUNCTION__);
1631 case FE_DISEQC_SEND_MASTER_CMD:
1632 dprintk("%s: FE_DISEQC_SEND_MASTER_CMD\n", __FUNCTION__);
1635 case FE_DISEQC_SEND_BURST:
1636 dprintk("%s: FE_DISEQC_SEND_BURST\n", __FUNCTION__);
1640 fe_sec_tone_mode_t tone = (fe_sec_tone_mode_t)arg;
1641 dprintk("%s: FE_SET_TONE\n", __FUNCTION__);
1642 dec->hi_band = (SEC_TONE_ON == tone);
1646 case FE_SET_VOLTAGE:
1647 dprintk("%s: FE_SET_VOLTAGE\n", __FUNCTION__);
1648 switch ((fe_sec_voltage_t) arg) {
1649 case SEC_VOLTAGE_13:
1652 case SEC_VOLTAGE_18:
1662 dprintk("%s: unknown IOCTL (0x%X)\n", __FUNCTION__, cmd);
1670 static void ttusb_dec_init_frontend(struct ttusb_dec *dec)
1672 dec->i2c_bus.adapter = dec->adapter;
1674 dvb_register_frontend(dec->frontend_ioctl, &dec->i2c_bus, (void *)dec,
1675 dec->frontend_info);
1678 static void ttusb_dec_exit_frontend(struct ttusb_dec *dec)
1680 dvb_unregister_frontend(dec->frontend_ioctl, &dec->i2c_bus);
1683 static void ttusb_dec_init_filters(struct ttusb_dec *dec)
1685 INIT_LIST_HEAD(&dec->filter_info_list);
1686 dec->filter_info_list_lock = SPIN_LOCK_UNLOCKED;
1689 static void ttusb_dec_exit_filters(struct ttusb_dec *dec)
1691 struct list_head *item;
1692 struct filter_info *finfo;
1694 while ((item = dec->filter_info_list.next) != &dec->filter_info_list) {
1695 finfo = list_entry(item, struct filter_info, filter_info_list);
1696 list_del(&finfo->filter_info_list);
1701 static int ttusb_dec_probe(struct usb_interface *intf,
1702 const struct usb_device_id *id)
1704 struct usb_device *udev;
1705 struct ttusb_dec *dec;
1707 dprintk("%s\n", __FUNCTION__);
1709 udev = interface_to_usbdev(intf);
1711 if (!(dec = kmalloc(sizeof(struct ttusb_dec), GFP_KERNEL))) {
1712 printk("%s: couldn't allocate memory.\n", __FUNCTION__);
1716 usb_set_intfdata(intf, (void *)dec);
1718 memset(dec, 0, sizeof(struct ttusb_dec));
1720 switch (id->idProduct) {
1722 ttusb_dec_set_model(dec, TTUSB_DEC3000S);
1726 ttusb_dec_set_model(dec, TTUSB_DEC2000T);
1730 ttusb_dec_set_model(dec, TTUSB_DEC2540T);
1736 ttusb_dec_init_usb(dec);
1737 if (ttusb_dec_init_stb(dec)) {
1738 ttusb_dec_exit_usb(dec);
1741 ttusb_dec_init_dvb(dec);
1742 ttusb_dec_init_frontend(dec);
1743 ttusb_dec_init_v_pes(dec);
1744 ttusb_dec_init_filters(dec);
1745 ttusb_dec_init_tasklet(dec);
1749 ttusb_dec_set_interface(dec, TTUSB_DEC_INTERFACE_IN);
1754 static void ttusb_dec_disconnect(struct usb_interface *intf)
1756 struct ttusb_dec *dec = usb_get_intfdata(intf);
1758 usb_set_intfdata(intf, NULL);
1760 dprintk("%s\n", __FUNCTION__);
1763 ttusb_dec_exit_tasklet(dec);
1764 ttusb_dec_exit_filters(dec);
1765 ttusb_dec_exit_usb(dec);
1766 ttusb_dec_exit_frontend(dec);
1767 ttusb_dec_exit_dvb(dec);
1773 static void ttusb_dec_set_model(struct ttusb_dec *dec,
1774 enum ttusb_dec_model model)
1779 case TTUSB_DEC2000T:
1780 dec->model_name = "DEC2000-t";
1781 dec->firmware_name = "dvb-ttusb-dec-2000t.fw";
1782 dec->frontend_info = &dec2000t_frontend_info;
1783 dec->frontend_ioctl = ttusb_dec_2000t_frontend_ioctl;
1786 case TTUSB_DEC2540T:
1787 dec->model_name = "DEC2540-t";
1788 dec->firmware_name = "dvb-ttusb-dec-2540t.fw";
1789 dec->frontend_info = &dec2000t_frontend_info;
1790 dec->frontend_ioctl = ttusb_dec_2000t_frontend_ioctl;
1793 case TTUSB_DEC3000S:
1794 dec->model_name = "DEC3000-s";
1795 dec->firmware_name = "dvb-ttusb-dec-3000s.fw";
1796 dec->frontend_info = &dec3000s_frontend_info;
1797 dec->frontend_ioctl = ttusb_dec_3000s_frontend_ioctl;
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 */
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,
1817 static int __init ttusb_dec_init(void)
1821 if ((result = usb_register(&ttusb_dec_driver)) < 0) {
1822 printk("%s: initialisation failed: error %d.\n", __FUNCTION__,
1830 static void __exit ttusb_dec_exit(void)
1832 usb_deregister(&ttusb_dec_driver);
1835 module_init(ttusb_dec_init);
1836 module_exit(ttusb_dec_exit);
1838 MODULE_AUTHOR("Alex Woods <linux-dvb@giblets.org>");
1839 MODULE_DESCRIPTION(DRIVER_NAME);
1840 MODULE_LICENSE("GPL");
1841 MODULE_DEVICE_TABLE(usb, ttusb_dec_table);
1843 MODULE_PARM(debug, "i");
1844 MODULE_PARM_DESC(debug, "Debug level");
1845 MODULE_PARM(output_pva, "i");
1846 MODULE_PARM_DESC(output_pva, "Output PVA from dvr device");