| Author | Tokens | Token Proportion | Commits | Commit Proportion |
|---|---|---|---|---|
| Michael Hunold | 5023 | 58.66% | 8 | 12.70% |
| Andrew Morton | 1913 | 22.34% | 4 | 6.35% |
| Johannes Stezenbach | 644 | 7.52% | 6 | 9.52% |
| Mauro Carvalho Chehab | 396 | 4.62% | 7 | 11.11% |
| Alexey Khoroshilov | 147 | 1.72% | 1 | 1.59% |
| Dmitry Torokhov | 120 | 1.40% | 2 | 3.17% |
| Harvey Harrison | 52 | 0.61% | 1 | 1.59% |
| Oliver Neukum | 48 | 0.56% | 1 | 1.59% |
| Andrew de Quincey | 32 | 0.37% | 2 | 3.17% |
| Anssi Hannula | 29 | 0.34% | 1 | 1.59% |
| Ingo Molnar | 27 | 0.32% | 1 | 1.59% |
| Dave Jones | 25 | 0.29% | 1 | 1.59% |
| Douglas Schilling Landgraf | 18 | 0.21% | 2 | 3.17% |
| Al Viro | 16 | 0.19% | 3 | 4.76% |
| Alex Woods | 11 | 0.13% | 1 | 1.59% |
| Thomas Gleixner | 8 | 0.09% | 1 | 1.59% |
| Greg Kroah-Hartman | 8 | 0.09% | 2 | 3.17% |
| Janne Grunau | 7 | 0.08% | 1 | 1.59% |
| Hans Verkuil | 6 | 0.07% | 1 | 1.59% |
| David S. Miller | 5 | 0.06% | 2 | 3.17% |
| Christoph Hellwig | 5 | 0.06% | 1 | 1.59% |
| Fabian Frederick | 4 | 0.05% | 1 | 1.59% |
| Nishanth Aravamudan | 4 | 0.05% | 1 | 1.59% |
| Trent Piepho | 3 | 0.04% | 1 | 1.59% |
| Patrick Boettcher | 2 | 0.02% | 1 | 1.59% |
| Márton Németh | 1 | 0.01% | 1 | 1.59% |
| Arvind Yadav | 1 | 0.01% | 1 | 1.59% |
| Sakari Ailus | 1 | 0.01% | 1 | 1.59% |
| Pete Zaitcev | 1 | 0.01% | 1 | 1.59% |
| Jiri Slaby | 1 | 0.01% | 1 | 1.59% |
| Björn Helgaas | 1 | 0.01% | 1 | 1.59% |
| David Woodhouse | 1 | 0.01% | 1 | 1.59% |
| Julia Lawall | 1 | 0.01% | 1 | 1.59% |
| Panagiotis Issaris | 1 | 0.01% | 1 | 1.59% |
| Daniel Mack | 1 | 0.01% | 1 | 1.59% |
| Total | 8563 | 63 |
/* * TTUSB DEC Driver * * Copyright (C) 2003-2004 Alex Woods <linux-dvb@giblets.org> * IR support by Peter Beutner <p.beutner@gmx.net> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * */ #include <linux/list.h> #include <linux/module.h> #include <linux/pci.h> #include <linux/slab.h> #include <linux/spinlock.h> #include <linux/usb.h> #include <linux/interrupt.h> #include <linux/firmware.h> #include <linux/crc32.h> #include <linux/init.h> #include <linux/input.h> #include <linux/mutex.h> #include <media/dmxdev.h> #include <media/dvb_demux.h> #include <media/dvb_frontend.h> #include <media/dvb_net.h> #include "ttusbdecfe.h" static int debug; static int output_pva; static int enable_rc; module_param(debug, int, 0644); MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off)."); module_param(output_pva, int, 0444); MODULE_PARM_DESC(output_pva, "Output PVA from dvr device (default:off)"); module_param(enable_rc, int, 0644); MODULE_PARM_DESC(enable_rc, "Turn on/off IR remote control(default: off)"); DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); #define dprintk if (debug) printk #define DRIVER_NAME "TechnoTrend/Hauppauge DEC USB" #define COMMAND_PIPE 0x03 #define RESULT_PIPE 0x04 #define IN_PIPE 0x08 #define OUT_PIPE 0x07 #define IRQ_PIPE 0x0A #define COMMAND_PACKET_SIZE 0x3c #define ARM_PACKET_SIZE 0x1000 #define IRQ_PACKET_SIZE 0x8 #define ISO_BUF_COUNT 0x04 #define FRAMES_PER_ISO_BUF 0x04 #define ISO_FRAME_SIZE 0x0380 #define MAX_PVA_LENGTH 6144 enum ttusb_dec_model { TTUSB_DEC2000T, TTUSB_DEC2540T, TTUSB_DEC3000S }; enum ttusb_dec_packet_type { TTUSB_DEC_PACKET_PVA, TTUSB_DEC_PACKET_SECTION, TTUSB_DEC_PACKET_EMPTY }; enum ttusb_dec_interface { TTUSB_DEC_INTERFACE_INITIAL, TTUSB_DEC_INTERFACE_IN, TTUSB_DEC_INTERFACE_OUT }; typedef int (dvb_filter_pes2ts_cb_t) (void *, unsigned char *); struct dvb_filter_pes2ts { unsigned char buf[188]; unsigned char cc; dvb_filter_pes2ts_cb_t *cb; void *priv; }; struct ttusb_dec { enum ttusb_dec_model model; char *model_name; char *firmware_name; int can_playback; /* DVB bits */ struct dvb_adapter adapter; struct dmxdev dmxdev; struct dvb_demux demux; struct dmx_frontend frontend; struct dvb_net dvb_net; struct dvb_frontend* fe; u16 pid[DMX_PES_OTHER]; /* USB bits */ struct usb_device *udev; u8 trans_count; unsigned int command_pipe; unsigned int result_pipe; unsigned int in_pipe; unsigned int out_pipe; unsigned int irq_pipe; enum ttusb_dec_interface interface; struct mutex usb_mutex; void *irq_buffer; struct urb *irq_urb; dma_addr_t irq_dma_handle; void *iso_buffer; struct urb *iso_urb[ISO_BUF_COUNT]; int iso_stream_count; struct mutex iso_mutex; u8 packet[MAX_PVA_LENGTH + 4]; enum ttusb_dec_packet_type packet_type; int packet_state; int packet_length; int packet_payload_length; u16 next_packet_id; int pva_stream_count; int filter_stream_count; struct dvb_filter_pes2ts a_pes2ts; struct dvb_filter_pes2ts v_pes2ts; u8 v_pes[16 + MAX_PVA_LENGTH]; int v_pes_length; int v_pes_postbytes; struct list_head urb_frame_list; struct tasklet_struct urb_tasklet; spinlock_t urb_frame_list_lock; struct dvb_demux_filter *audio_filter; struct dvb_demux_filter *video_filter; struct list_head filter_info_list; spinlock_t filter_info_list_lock; struct input_dev *rc_input_dev; char rc_phys[64]; int active; /* Loaded successfully */ }; struct urb_frame { u8 data[ISO_FRAME_SIZE]; int length; struct list_head urb_frame_list; }; struct filter_info { u8 stream_id; struct dvb_demux_filter *filter; struct list_head filter_info_list; }; static u16 rc_keys[] = { KEY_POWER, KEY_MUTE, KEY_1, KEY_2, KEY_3, KEY_4, KEY_5, KEY_6, KEY_7, KEY_8, KEY_9, KEY_0, KEY_CHANNELUP, KEY_VOLUMEDOWN, KEY_OK, KEY_VOLUMEUP, KEY_CHANNELDOWN, KEY_PREVIOUS, KEY_ESC, KEY_RED, KEY_GREEN, KEY_YELLOW, KEY_BLUE, KEY_OPTION, KEY_M, KEY_RADIO }; static void dvb_filter_pes2ts_init(struct dvb_filter_pes2ts *p2ts, unsigned short pid, dvb_filter_pes2ts_cb_t *cb, void *priv) { unsigned char *buf=p2ts->buf; buf[0]=0x47; buf[1]=(pid>>8); buf[2]=pid&0xff; p2ts->cc=0; p2ts->cb=cb; p2ts->priv=priv; } static int dvb_filter_pes2ts(struct dvb_filter_pes2ts *p2ts, unsigned char *pes, int len, int payload_start) { unsigned char *buf=p2ts->buf; int ret=0, rest; //len=6+((pes[4]<<8)|pes[5]); if (payload_start) buf[1]|=0x40; else buf[1]&=~0x40; while (len>=184) { buf[3]=0x10|((p2ts->cc++)&0x0f); memcpy(buf+4, pes, 184); if ((ret=p2ts->cb(p2ts->priv, buf))) return ret; len-=184; pes+=184; buf[1]&=~0x40; } if (!len) return 0; buf[3]=0x30|((p2ts->cc++)&0x0f); rest=183-len; if (rest) { buf[5]=0x00; if (rest-1) memset(buf+6, 0xff, rest-1); } buf[4]=rest; memcpy(buf+5+rest, pes, len); return p2ts->cb(p2ts->priv, buf); } static void ttusb_dec_set_model(struct ttusb_dec *dec, enum ttusb_dec_model model); static void ttusb_dec_handle_irq( struct urb *urb) { struct ttusb_dec *dec = urb->context; char *buffer = dec->irq_buffer; int retval; switch(urb->status) { case 0: /*success*/ break; case -ECONNRESET: case -ENOENT: case -ESHUTDOWN: case -ETIME: /* this urb is dead, cleanup */ dprintk("%s:urb shutting down with status: %d\n", __func__, urb->status); return; default: dprintk("%s:nonzero status received: %d\n", __func__,urb->status); goto exit; } if ((buffer[0] == 0x1) && (buffer[2] == 0x15)) { /* * IR - Event * * this is an fact a bit too simple implementation; * the box also reports a keyrepeat signal * (with buffer[3] == 0x40) in an intervall of ~100ms. * But to handle this correctly we had to imlemenent some * kind of timer which signals a 'key up' event if no * keyrepeat signal is received for lets say 200ms. * this should/could be added later ... * for now lets report each signal as a key down and up */ if (buffer[4] - 1 < ARRAY_SIZE(rc_keys)) { dprintk("%s:rc signal:%d\n", __func__, buffer[4]); input_report_key(dec->rc_input_dev, rc_keys[buffer[4] - 1], 1); input_sync(dec->rc_input_dev); input_report_key(dec->rc_input_dev, rc_keys[buffer[4] - 1], 0); input_sync(dec->rc_input_dev); } } exit: retval = usb_submit_urb(urb, GFP_ATOMIC); if (retval) printk("%s - usb_commit_urb failed with result: %d\n", __func__, retval); } static u16 crc16(u16 crc, const u8 *buf, size_t len) { u16 tmp; while (len--) { crc ^= *buf++; crc ^= (u8)crc >> 4; tmp = (u8)crc; crc ^= (tmp ^ (tmp << 1)) << 4; } return crc; } static int ttusb_dec_send_command(struct ttusb_dec *dec, const u8 command, int param_length, const u8 params[], int *result_length, u8 cmd_result[]) { int result, actual_len; u8 *b; dprintk("%s\n", __func__); b = kmalloc(COMMAND_PACKET_SIZE + 4, GFP_KERNEL); if (!b) return -ENOMEM; if ((result = mutex_lock_interruptible(&dec->usb_mutex))) { kfree(b); printk("%s: Failed to lock usb mutex.\n", __func__); return result; } b[0] = 0xaa; b[1] = ++dec->trans_count; b[2] = command; b[3] = param_length; if (params) memcpy(&b[4], params, param_length); if (debug) { printk(KERN_DEBUG "%s: command: %*ph\n", __func__, param_length, b); } result = usb_bulk_msg(dec->udev, dec->command_pipe, b, COMMAND_PACKET_SIZE + 4, &actual_len, 1000); if (result) { printk("%s: command bulk message failed: error %d\n", __func__, result); mutex_unlock(&dec->usb_mutex); kfree(b); return result; } result = usb_bulk_msg(dec->udev, dec->result_pipe, b, COMMAND_PACKET_SIZE + 4, &actual_len, 1000); if (result) { printk("%s: result bulk message failed: error %d\n", __func__, result); mutex_unlock(&dec->usb_mutex); kfree(b); return result; } else { if (debug) { printk(KERN_DEBUG "%s: result: %*ph\n", __func__, actual_len, b); } if (result_length) *result_length = b[3]; if (cmd_result && b[3] > 0) memcpy(cmd_result, &b[4], b[3]); mutex_unlock(&dec->usb_mutex); kfree(b); return 0; } } static int ttusb_dec_get_stb_state (struct ttusb_dec *dec, unsigned int *mode, unsigned int *model, unsigned int *version) { u8 c[COMMAND_PACKET_SIZE]; int c_length; int result; __be32 tmp; dprintk("%s\n", __func__); result = ttusb_dec_send_command(dec, 0x08, 0, NULL, &c_length, c); if (result) return result; if (c_length >= 0x0c) { if (mode != NULL) { memcpy(&tmp, c, 4); *mode = ntohl(tmp); } if (model != NULL) { memcpy(&tmp, &c[4], 4); *model = ntohl(tmp); } if (version != NULL) { memcpy(&tmp, &c[8], 4); *version = ntohl(tmp); } return 0; } else { return -ENOENT; } } static int ttusb_dec_audio_pes2ts_cb(void *priv, unsigned char *data) { struct ttusb_dec *dec = priv; dec->audio_filter->feed->cb.ts(data, 188, NULL, 0, &dec->audio_filter->feed->feed.ts, NULL); return 0; } static int ttusb_dec_video_pes2ts_cb(void *priv, unsigned char *data) { struct ttusb_dec *dec = priv; dec->video_filter->feed->cb.ts(data, 188, NULL, 0, &dec->video_filter->feed->feed.ts, NULL); return 0; } static void ttusb_dec_set_pids(struct ttusb_dec *dec) { u8 b[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; __be16 pcr = htons(dec->pid[DMX_PES_PCR]); __be16 audio = htons(dec->pid[DMX_PES_AUDIO]); __be16 video = htons(dec->pid[DMX_PES_VIDEO]); dprintk("%s\n", __func__); memcpy(&b[0], &pcr, 2); memcpy(&b[2], &audio, 2); memcpy(&b[4], &video, 2); ttusb_dec_send_command(dec, 0x50, sizeof(b), b, NULL, NULL); dvb_filter_pes2ts_init(&dec->a_pes2ts, dec->pid[DMX_PES_AUDIO], ttusb_dec_audio_pes2ts_cb, dec); dvb_filter_pes2ts_init(&dec->v_pes2ts, dec->pid[DMX_PES_VIDEO], ttusb_dec_video_pes2ts_cb, dec); dec->v_pes_length = 0; dec->v_pes_postbytes = 0; } static void ttusb_dec_process_pva(struct ttusb_dec *dec, u8 *pva, int length) { if (length < 8) { printk("%s: packet too short - discarding\n", __func__); return; } if (length > 8 + MAX_PVA_LENGTH) { printk("%s: packet too long - discarding\n", __func__); return; } switch (pva[2]) { case 0x01: { /* VideoStream */ int prebytes = pva[5] & 0x03; int postbytes = (pva[5] & 0x0c) >> 2; __be16 v_pes_payload_length; if (output_pva) { dec->video_filter->feed->cb.ts(pva, length, NULL, 0, &dec->video_filter->feed->feed.ts, NULL); return; } if (dec->v_pes_postbytes > 0 && dec->v_pes_postbytes == prebytes) { memcpy(&dec->v_pes[dec->v_pes_length], &pva[12], prebytes); dvb_filter_pes2ts(&dec->v_pes2ts, dec->v_pes, dec->v_pes_length + prebytes, 1); } if (pva[5] & 0x10) { dec->v_pes[7] = 0x80; dec->v_pes[8] = 0x05; dec->v_pes[9] = 0x21 | ((pva[8] & 0xc0) >> 5); dec->v_pes[10] = ((pva[8] & 0x3f) << 2) | ((pva[9] & 0xc0) >> 6); dec->v_pes[11] = 0x01 | ((pva[9] & 0x3f) << 2) | ((pva[10] & 0x80) >> 6); dec->v_pes[12] = ((pva[10] & 0x7f) << 1) | ((pva[11] & 0xc0) >> 7); dec->v_pes[13] = 0x01 | ((pva[11] & 0x7f) << 1); memcpy(&dec->v_pes[14], &pva[12 + prebytes], length - 12 - prebytes); dec->v_pes_length = 14 + length - 12 - prebytes; } else { dec->v_pes[7] = 0x00; dec->v_pes[8] = 0x00; memcpy(&dec->v_pes[9], &pva[8], length - 8); dec->v_pes_length = 9 + length - 8; } dec->v_pes_postbytes = postbytes; if (dec->v_pes[9 + dec->v_pes[8]] == 0x00 && dec->v_pes[10 + dec->v_pes[8]] == 0x00 && dec->v_pes[11 + dec->v_pes[8]] == 0x01) dec->v_pes[6] = 0x84; else dec->v_pes[6] = 0x80; v_pes_payload_length = htons(dec->v_pes_length - 6 + postbytes); memcpy(&dec->v_pes[4], &v_pes_payload_length, 2); if (postbytes == 0) dvb_filter_pes2ts(&dec->v_pes2ts, dec->v_pes, dec->v_pes_length, 1); break; } case 0x02: /* MainAudioStream */ if (output_pva) { dec->audio_filter->feed->cb.ts(pva, length, NULL, 0, &dec->audio_filter->feed->feed.ts, NULL); return; } dvb_filter_pes2ts(&dec->a_pes2ts, &pva[8], length - 8, pva[5] & 0x10); break; default: printk("%s: unknown PVA type: %02x.\n", __func__, pva[2]); break; } } static void ttusb_dec_process_filter(struct ttusb_dec *dec, u8 *packet, int length) { struct list_head *item; struct filter_info *finfo; struct dvb_demux_filter *filter = NULL; unsigned long flags; u8 sid; sid = packet[1]; spin_lock_irqsave(&dec->filter_info_list_lock, flags); for (item = dec->filter_info_list.next; item != &dec->filter_info_list; item = item->next) { finfo = list_entry(item, struct filter_info, filter_info_list); if (finfo->stream_id == sid) { filter = finfo->filter; break; } } spin_unlock_irqrestore(&dec->filter_info_list_lock, flags); if (filter) filter->feed->cb.sec(&packet[2], length - 2, NULL, 0, &filter->filter, NULL); } static void ttusb_dec_process_packet(struct ttusb_dec *dec) { int i; u16 csum = 0; u16 packet_id; if (dec->packet_length % 2) { printk("%s: odd sized packet - discarding\n", __func__); return; } for (i = 0; i < dec->packet_length; i += 2) csum ^= ((dec->packet[i] << 8) + dec->packet[i + 1]); if (csum) { printk("%s: checksum failed - discarding\n", __func__); return; } packet_id = dec->packet[dec->packet_length - 4] << 8; packet_id += dec->packet[dec->packet_length - 3]; if ((packet_id != dec->next_packet_id) && dec->next_packet_id) { printk("%s: warning: lost packets between %u and %u\n", __func__, dec->next_packet_id - 1, packet_id); } if (packet_id == 0xffff) dec->next_packet_id = 0x8000; else dec->next_packet_id = packet_id + 1; switch (dec->packet_type) { case TTUSB_DEC_PACKET_PVA: if (dec->pva_stream_count) ttusb_dec_process_pva(dec, dec->packet, dec->packet_payload_length); break; case TTUSB_DEC_PACKET_SECTION: if (dec->filter_stream_count) ttusb_dec_process_filter(dec, dec->packet, dec->packet_payload_length); break; case TTUSB_DEC_PACKET_EMPTY: break; } } static void swap_bytes(u8 *b, int length) { length -= length % 2; for (; length; b += 2, length -= 2) swap(*b, *(b + 1)); } static void ttusb_dec_process_urb_frame(struct ttusb_dec *dec, u8 *b, int length) { swap_bytes(b, length); while (length) { switch (dec->packet_state) { case 0: case 1: case 2: if (*b++ == 0xaa) dec->packet_state++; else dec->packet_state = 0; length--; break; case 3: if (*b == 0x00) { dec->packet_state++; dec->packet_length = 0; } else if (*b != 0xaa) { dec->packet_state = 0; } b++; length--; break; case 4: dec->packet[dec->packet_length++] = *b++; if (dec->packet_length == 2) { if (dec->packet[0] == 'A' && dec->packet[1] == 'V') { dec->packet_type = TTUSB_DEC_PACKET_PVA; dec->packet_state++; } else if (dec->packet[0] == 'S') { dec->packet_type = TTUSB_DEC_PACKET_SECTION; dec->packet_state++; } else if (dec->packet[0] == 0x00) { dec->packet_type = TTUSB_DEC_PACKET_EMPTY; dec->packet_payload_length = 2; dec->packet_state = 7; } else { printk("%s: unknown packet type: %02x%02x\n", __func__, dec->packet[0], dec->packet[1]); dec->packet_state = 0; } } length--; break; case 5: dec->packet[dec->packet_length++] = *b++; if (dec->packet_type == TTUSB_DEC_PACKET_PVA && dec->packet_length == 8) { dec->packet_state++; dec->packet_payload_length = 8 + (dec->packet[6] << 8) + dec->packet[7]; } else if (dec->packet_type == TTUSB_DEC_PACKET_SECTION && dec->packet_length == 5) { dec->packet_state++; dec->packet_payload_length = 5 + ((dec->packet[3] & 0x0f) << 8) + dec->packet[4]; } length--; break; case 6: { int remainder = dec->packet_payload_length - dec->packet_length; if (length >= remainder) { memcpy(dec->packet + dec->packet_length, b, remainder); dec->packet_length += remainder; b += remainder; length -= remainder; dec->packet_state++; } else { memcpy(&dec->packet[dec->packet_length], b, length); dec->packet_length += length; length = 0; } break; } case 7: { int tail = 4; dec->packet[dec->packet_length++] = *b++; if (dec->packet_type == TTUSB_DEC_PACKET_SECTION && dec->packet_payload_length % 2) tail++; if (dec->packet_length == dec->packet_payload_length + tail) { ttusb_dec_process_packet(dec); dec->packet_state = 0; } length--; break; } default: printk("%s: illegal packet state encountered.\n", __func__); dec->packet_state = 0; } } } static void ttusb_dec_process_urb_frame_list(unsigned long data) { struct ttusb_dec *dec = (struct ttusb_dec *)data; struct list_head *item; struct urb_frame *frame; unsigned long flags; while (1) { spin_lock_irqsave(&dec->urb_frame_list_lock, flags); if ((item = dec->urb_frame_list.next) != &dec->urb_frame_list) { frame = list_entry(item, struct urb_frame, urb_frame_list); list_del(&frame->urb_frame_list); } else { spin_unlock_irqrestore(&dec->urb_frame_list_lock, flags); return; } spin_unlock_irqrestore(&dec->urb_frame_list_lock, flags); ttusb_dec_process_urb_frame(dec, frame->data, frame->length); kfree(frame); } } static void ttusb_dec_process_urb(struct urb *urb) { struct ttusb_dec *dec = urb->context; if (!urb->status) { int i; for (i = 0; i < FRAMES_PER_ISO_BUF; i++) { struct usb_iso_packet_descriptor *d; u8 *b; int length; struct urb_frame *frame; d = &urb->iso_frame_desc[i]; b = urb->transfer_buffer + d->offset; length = d->actual_length; if ((frame = kmalloc(sizeof(struct urb_frame), GFP_ATOMIC))) { unsigned long flags; memcpy(frame->data, b, length); frame->length = length; spin_lock_irqsave(&dec->urb_frame_list_lock, flags); list_add_tail(&frame->urb_frame_list, &dec->urb_frame_list); spin_unlock_irqrestore(&dec->urb_frame_list_lock, flags); tasklet_schedule(&dec->urb_tasklet); } } } else { /* -ENOENT is expected when unlinking urbs */ if (urb->status != -ENOENT) dprintk("%s: urb error: %d\n", __func__, urb->status); } if (dec->iso_stream_count) usb_submit_urb(urb, GFP_ATOMIC); } static void ttusb_dec_setup_urbs(struct ttusb_dec *dec) { int i, j, buffer_offset = 0; dprintk("%s\n", __func__); for (i = 0; i < ISO_BUF_COUNT; i++) { int frame_offset = 0; struct urb *urb = dec->iso_urb[i]; urb->dev = dec->udev; urb->context = dec; urb->complete = ttusb_dec_process_urb; urb->pipe = dec->in_pipe; urb->transfer_flags = URB_ISO_ASAP; urb->interval = 1; urb->number_of_packets = FRAMES_PER_ISO_BUF; urb->transfer_buffer_length = ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF; urb->transfer_buffer = dec->iso_buffer + buffer_offset; buffer_offset += ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF; for (j = 0; j < FRAMES_PER_ISO_BUF; j++) { urb->iso_frame_desc[j].offset = frame_offset; urb->iso_frame_desc[j].length = ISO_FRAME_SIZE; frame_offset += ISO_FRAME_SIZE; } } } static void ttusb_dec_stop_iso_xfer(struct ttusb_dec *dec) { int i; dprintk("%s\n", __func__); if (mutex_lock_interruptible(&dec->iso_mutex)) return; dec->iso_stream_count--; if (!dec->iso_stream_count) { for (i = 0; i < ISO_BUF_COUNT; i++) usb_kill_urb(dec->iso_urb[i]); } mutex_unlock(&dec->iso_mutex); } /* Setting the interface of the DEC tends to take down the USB communications * for a short period, so it's important not to call this function just before * trying to talk to it. */ static int ttusb_dec_set_interface(struct ttusb_dec *dec, enum ttusb_dec_interface interface) { int result = 0; u8 b[] = { 0x05 }; if (interface != dec->interface) { switch (interface) { case TTUSB_DEC_INTERFACE_INITIAL: result = usb_set_interface(dec->udev, 0, 0); break; case TTUSB_DEC_INTERFACE_IN: result = ttusb_dec_send_command(dec, 0x80, sizeof(b), b, NULL, NULL); if (result) return result; result = usb_set_interface(dec->udev, 0, 8); break; case TTUSB_DEC_INTERFACE_OUT: result = usb_set_interface(dec->udev, 0, 1); break; } if (result) return result; dec->interface = interface; } return 0; } static int ttusb_dec_start_iso_xfer(struct ttusb_dec *dec) { int i, result; dprintk("%s\n", __func__); if (mutex_lock_interruptible(&dec->iso_mutex)) return -EAGAIN; if (!dec->iso_stream_count) { ttusb_dec_setup_urbs(dec); dec->packet_state = 0; dec->v_pes_postbytes = 0; dec->next_packet_id = 0; for (i = 0; i < ISO_BUF_COUNT; i++) { if ((result = usb_submit_urb(dec->iso_urb[i], GFP_ATOMIC))) { printk("%s: failed urb submission %d: error %d\n", __func__, i, result); while (i) { usb_kill_urb(dec->iso_urb[i - 1]); i--; } mutex_unlock(&dec->iso_mutex); return result; } } } dec->iso_stream_count++; mutex_unlock(&dec->iso_mutex); return 0; } static int ttusb_dec_start_ts_feed(struct dvb_demux_feed *dvbdmxfeed) { struct dvb_demux *dvbdmx = dvbdmxfeed->demux; struct ttusb_dec *dec = dvbdmx->priv; u8 b0[] = { 0x05 }; int result = 0; dprintk("%s\n", __func__); dprintk(" ts_type:"); if (dvbdmxfeed->ts_type & TS_DECODER) dprintk(" TS_DECODER"); if (dvbdmxfeed->ts_type & TS_PACKET) dprintk(" TS_PACKET"); if (dvbdmxfeed->ts_type & TS_PAYLOAD_ONLY) dprintk(" TS_PAYLOAD_ONLY"); dprintk("\n"); switch (dvbdmxfeed->pes_type) { case DMX_PES_VIDEO: dprintk(" pes_type: DMX_PES_VIDEO\n"); dec->pid[DMX_PES_PCR] = dvbdmxfeed->pid; dec->pid[DMX_PES_VIDEO] = dvbdmxfeed->pid; dec->video_filter = dvbdmxfeed->filter; ttusb_dec_set_pids(dec); break; case DMX_PES_AUDIO: dprintk(" pes_type: DMX_PES_AUDIO\n"); dec->pid[DMX_PES_AUDIO] = dvbdmxfeed->pid; dec->audio_filter = dvbdmxfeed->filter; ttusb_dec_set_pids(dec); break; case DMX_PES_TELETEXT: dec->pid[DMX_PES_TELETEXT] = dvbdmxfeed->pid; dprintk(" pes_type: DMX_PES_TELETEXT(not supported)\n"); return -ENOSYS; case DMX_PES_PCR: dprintk(" pes_type: DMX_PES_PCR\n"); dec->pid[DMX_PES_PCR] = dvbdmxfeed->pid; ttusb_dec_set_pids(dec); break; case DMX_PES_OTHER: dprintk(" pes_type: DMX_PES_OTHER(not supported)\n"); return -ENOSYS; default: dprintk(" pes_type: unknown (%d)\n", dvbdmxfeed->pes_type); return -EINVAL; } result = ttusb_dec_send_command(dec, 0x80, sizeof(b0), b0, NULL, NULL); if (result) return result; dec->pva_stream_count++; return ttusb_dec_start_iso_xfer(dec); } static int ttusb_dec_start_sec_feed(struct dvb_demux_feed *dvbdmxfeed) { struct ttusb_dec *dec = dvbdmxfeed->demux->priv; u8 b0[] = { 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; __be16 pid; u8 c[COMMAND_PACKET_SIZE]; int c_length; int result; struct filter_info *finfo; unsigned long flags; u8 x = 1; dprintk("%s\n", __func__); pid = htons(dvbdmxfeed->pid); memcpy(&b0[0], &pid, 2); memcpy(&b0[4], &x, 1); memcpy(&b0[5], &dvbdmxfeed->filter->filter.filter_value[0], 1); result = ttusb_dec_send_command(dec, 0x60, sizeof(b0), b0, &c_length, c); if (!result) { if (c_length == 2) { if (!(finfo = kmalloc(sizeof(struct filter_info), GFP_ATOMIC))) return -ENOMEM; finfo->stream_id = c[1]; finfo->filter = dvbdmxfeed->filter; spin_lock_irqsave(&dec->filter_info_list_lock, flags); list_add_tail(&finfo->filter_info_list, &dec->filter_info_list); spin_unlock_irqrestore(&dec->filter_info_list_lock, flags); dvbdmxfeed->priv = finfo; dec->filter_stream_count++; return ttusb_dec_start_iso_xfer(dec); } return -EAGAIN; } else return result; } static int ttusb_dec_start_feed(struct dvb_demux_feed *dvbdmxfeed) { struct dvb_demux *dvbdmx = dvbdmxfeed->demux; dprintk("%s\n", __func__); if (!dvbdmx->dmx.frontend) return -EINVAL; dprintk(" pid: 0x%04X\n", dvbdmxfeed->pid); switch (dvbdmxfeed->type) { case DMX_TYPE_TS: return ttusb_dec_start_ts_feed(dvbdmxfeed); break; case DMX_TYPE_SEC: return ttusb_dec_start_sec_feed(dvbdmxfeed); break; default: dprintk(" type: unknown (%d)\n", dvbdmxfeed->type); return -EINVAL; } } static int ttusb_dec_stop_ts_feed(struct dvb_demux_feed *dvbdmxfeed) { struct ttusb_dec *dec = dvbdmxfeed->demux->priv; u8 b0[] = { 0x00 }; ttusb_dec_send_command(dec, 0x81, sizeof(b0), b0, NULL, NULL); dec->pva_stream_count--; ttusb_dec_stop_iso_xfer(dec); return 0; } static int ttusb_dec_stop_sec_feed(struct dvb_demux_feed *dvbdmxfeed) { struct ttusb_dec *dec = dvbdmxfeed->demux->priv; u8 b0[] = { 0x00, 0x00 }; struct filter_info *finfo = (struct filter_info *)dvbdmxfeed->priv; unsigned long flags; b0[1] = finfo->stream_id; spin_lock_irqsave(&dec->filter_info_list_lock, flags); list_del(&finfo->filter_info_list); spin_unlock_irqrestore(&dec->filter_info_list_lock, flags); kfree(finfo); ttusb_dec_send_command(dec, 0x62, sizeof(b0), b0, NULL, NULL); dec->filter_stream_count--; ttusb_dec_stop_iso_xfer(dec); return 0; } static int ttusb_dec_stop_feed(struct dvb_demux_feed *dvbdmxfeed) { dprintk("%s\n", __func__); switch (dvbdmxfeed->type) { case DMX_TYPE_TS: return ttusb_dec_stop_ts_feed(dvbdmxfeed); break; case DMX_TYPE_SEC: return ttusb_dec_stop_sec_feed(dvbdmxfeed); break; } return 0; } static void ttusb_dec_free_iso_urbs(struct ttusb_dec *dec) { int i; dprintk("%s\n", __func__); for (i = 0; i < ISO_BUF_COUNT; i++) usb_free_urb(dec->iso_urb[i]); kfree(dec->iso_buffer); } static int ttusb_dec_alloc_iso_urbs(struct ttusb_dec *dec) { int i; dprintk("%s\n", __func__); dec->iso_buffer = kcalloc(FRAMES_PER_ISO_BUF * ISO_BUF_COUNT, ISO_FRAME_SIZE, GFP_KERNEL); if (!dec->iso_buffer) return -ENOMEM; for (i = 0; i < ISO_BUF_COUNT; i++) { struct urb *urb; if (!(urb = usb_alloc_urb(FRAMES_PER_ISO_BUF, GFP_ATOMIC))) { ttusb_dec_free_iso_urbs(dec); return -ENOMEM; } dec->iso_urb[i] = urb; } ttusb_dec_setup_urbs(dec); return 0; } static void ttusb_dec_init_tasklet(struct ttusb_dec *dec) { spin_lock_init(&dec->urb_frame_list_lock); INIT_LIST_HEAD(&dec->urb_frame_list); tasklet_init(&dec->urb_tasklet, ttusb_dec_process_urb_frame_list, (unsigned long)dec); } static int ttusb_init_rc( struct ttusb_dec *dec) { struct input_dev *input_dev; u8 b[] = { 0x00, 0x01 }; int i; int err; usb_make_path(dec->udev, dec->rc_phys, sizeof(dec->rc_phys)); strlcat(dec->rc_phys, "/input0", sizeof(dec->rc_phys)); input_dev = input_allocate_device(); if (!input_dev) return -ENOMEM; input_dev->name = "ttusb_dec remote control"; input_dev->phys = dec->rc_phys; input_dev->evbit[0] = BIT_MASK(EV_KEY); input_dev->keycodesize = sizeof(u16); input_dev->keycodemax = 0x1a; input_dev->keycode = rc_keys; for (i = 0; i < ARRAY_SIZE(rc_keys); i++) set_bit(rc_keys[i], input_dev->keybit); err = input_register_device(input_dev); if (err) { input_free_device(input_dev); return err; } dec->rc_input_dev = input_dev; if (usb_submit_urb(dec->irq_urb, GFP_KERNEL)) printk("%s: usb_submit_urb failed\n",__func__); /* enable irq pipe */ ttusb_dec_send_command(dec,0xb0,sizeof(b),b,NULL,NULL); return 0; } static void ttusb_dec_init_v_pes(struct ttusb_dec *dec) { dprintk("%s\n", __func__); dec->v_pes[0] = 0x00; dec->v_pes[1] = 0x00; dec->v_pes[2] = 0x01; dec->v_pes[3] = 0xe0; } static int ttusb_dec_init_usb(struct ttusb_dec *dec) { int result; dprintk("%s\n", __func__); mutex_init(&dec->usb_mutex); mutex_init(&dec->iso_mutex); dec->command_pipe = usb_sndbulkpipe(dec->udev, COMMAND_PIPE); dec->result_pipe = usb_rcvbulkpipe(dec->udev, RESULT_PIPE); dec->in_pipe = usb_rcvisocpipe(dec->udev, IN_PIPE); dec->out_pipe = usb_sndisocpipe(dec->udev, OUT_PIPE); dec->irq_pipe = usb_rcvintpipe(dec->udev, IRQ_PIPE); if(enable_rc) { dec->irq_urb = usb_alloc_urb(0, GFP_KERNEL); if(!dec->irq_urb) { return -ENOMEM; } dec->irq_buffer = usb_alloc_coherent(dec->udev,IRQ_PACKET_SIZE, GFP_KERNEL, &dec->irq_dma_handle); if(!dec->irq_buffer) { usb_free_urb(dec->irq_urb); return -ENOMEM; } usb_fill_int_urb(dec->irq_urb, dec->udev,dec->irq_pipe, dec->irq_buffer, IRQ_PACKET_SIZE, ttusb_dec_handle_irq, dec, 1); dec->irq_urb->transfer_dma = dec->irq_dma_handle; dec->irq_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; } result = ttusb_dec_alloc_iso_urbs(dec); if (result) { usb_free_urb(dec->irq_urb); usb_free_coherent(dec->udev, IRQ_PACKET_SIZE, dec->irq_buffer, dec->irq_dma_handle); } return result; } static int ttusb_dec_boot_dsp(struct ttusb_dec *dec) { int i, j, actual_len, result, size, trans_count; u8 b0[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x61, 0x00 }; u8 b1[] = { 0x61 }; u8 *b; char idstring[21]; const u8 *firmware = NULL; size_t firmware_size = 0; u16 firmware_csum = 0; __be16 firmware_csum_ns; __be32 firmware_size_nl; u32 crc32_csum, crc32_check; __be32 tmp; const struct firmware *fw_entry = NULL; dprintk("%s\n", __func__); result = request_firmware(&fw_entry, dec->firmware_name, &dec->udev->dev); if (result) { printk(KERN_ERR "%s: Firmware (%s) unavailable.\n", __func__, dec->firmware_name); return result; } firmware = fw_entry->data; firmware_size = fw_entry->size; if (firmware_size < 60) { printk("%s: firmware size too small for DSP code (%zu < 60).\n", __func__, firmware_size); release_firmware(fw_entry); return -ENOENT; } /* a 32 bit checksum over the first 56 bytes of the DSP Code is stored at offset 56 of file, so use it to check if the firmware file is valid. */ crc32_csum = crc32(~0L, firmware, 56) ^ ~0L; memcpy(&tmp, &firmware[56], 4); crc32_check = ntohl(tmp); if (crc32_csum != crc32_check) { printk("%s: crc32 check of DSP code failed (calculated 0x%08x != 0x%08x in file), file invalid.\n", __func__, crc32_csum, crc32_check); release_firmware(fw_entry); return -ENOENT; } memcpy(idstring, &firmware[36], 20); idstring[20] = '\0'; printk(KERN_INFO "ttusb_dec: found DSP code \"%s\".\n", idstring); firmware_size_nl = htonl(firmware_size); memcpy(b0, &firmware_size_nl, 4); firmware_csum = crc16(~0, firmware, firmware_size) ^ ~0; firmware_csum_ns = htons(firmware_csum); memcpy(&b0[6], &firmware_csum_ns, 2); result = ttusb_dec_send_command(dec, 0x41, sizeof(b0), b0, NULL, NULL); if (result) { release_firmware(fw_entry); return result; } trans_count = 0; j = 0; b = kmalloc(ARM_PACKET_SIZE, GFP_KERNEL); if (b == NULL) { release_firmware(fw_entry); return -ENOMEM; } for (i = 0; i < firmware_size; i += COMMAND_PACKET_SIZE) { size = firmware_size - i; if (size > COMMAND_PACKET_SIZE) size = COMMAND_PACKET_SIZE; b[j + 0] = 0xaa; b[j + 1] = trans_count++; b[j + 2] = 0xf0; b[j + 3] = size; memcpy(&b[j + 4], &firmware[i], size); j += COMMAND_PACKET_SIZE + 4; if (j >= ARM_PACKET_SIZE) { result = usb_bulk_msg(dec->udev, dec->command_pipe, b, ARM_PACKET_SIZE, &actual_len, 100); j = 0; } else if (size < COMMAND_PACKET_SIZE) { result = usb_bulk_msg(dec->udev, dec->command_pipe, b, j - COMMAND_PACKET_SIZE + size, &actual_len, 100); } } result = ttusb_dec_send_command(dec, 0x43, sizeof(b1), b1, NULL, NULL); release_firmware(fw_entry); kfree(b); return result; } static int ttusb_dec_init_stb(struct ttusb_dec *dec) { int result; unsigned int mode = 0, model = 0, version = 0; dprintk("%s\n", __func__); result = ttusb_dec_get_stb_state(dec, &mode, &model, &version); if (result) return result; if (!mode) { if (version == 0xABCDEFAB) printk(KERN_INFO "ttusb_dec: no version info in Firmware\n"); else printk(KERN_INFO "ttusb_dec: Firmware %x.%02x%c%c\n", version >> 24, (version >> 16) & 0xff, (version >> 8) & 0xff, version & 0xff); result = ttusb_dec_boot_dsp(dec); if (result) return result; } else { /* We can't trust the USB IDs that some firmwares give the box */ switch (model) { case 0x00070001: case 0x00070008: case 0x0007000c: ttusb_dec_set_model(dec, TTUSB_DEC3000S); break; case 0x00070009: case 0x00070013: ttusb_dec_set_model(dec, TTUSB_DEC2000T); break; case 0x00070011: ttusb_dec_set_model(dec, TTUSB_DEC2540T); break; default: printk(KERN_ERR "%s: unknown model returned by firmware (%08x) - please report\n", __func__, model); return -ENOENT; } if (version >= 0x01770000) dec->can_playback = 1; } return 0; } static int ttusb_dec_init_dvb(struct ttusb_dec *dec) { int result; dprintk("%s\n", __func__); if ((result = dvb_register_adapter(&dec->adapter, dec->model_name, THIS_MODULE, &dec->udev->dev, adapter_nr)) < 0) { printk("%s: dvb_register_adapter failed: error %d\n", __func__, result); return result; } dec->demux.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING; dec->demux.priv = (void *)dec; dec->demux.filternum = 31; dec->demux.feednum = 31; dec->demux.start_feed = ttusb_dec_start_feed; dec->demux.stop_feed = ttusb_dec_stop_feed; dec->demux.write_to_decoder = NULL; if ((result = dvb_dmx_init(&dec->demux)) < 0) { printk("%s: dvb_dmx_init failed: error %d\n", __func__, result); dvb_unregister_adapter(&dec->adapter); return result; } dec->dmxdev.filternum = 32; dec->dmxdev.demux = &dec->demux.dmx; dec->dmxdev.capabilities = 0; if ((result = dvb_dmxdev_init(&dec->dmxdev, &dec->adapter)) < 0) { printk("%s: dvb_dmxdev_init failed: error %d\n", __func__, result); dvb_dmx_release(&dec->demux); dvb_unregister_adapter(&dec->adapter); return result; } dec->frontend.source = DMX_FRONTEND_0; if ((result = dec->demux.dmx.add_frontend(&dec->demux.dmx, &dec->frontend)) < 0) { printk("%s: dvb_dmx_init failed: error %d\n", __func__, result); dvb_dmxdev_release(&dec->dmxdev); dvb_dmx_release(&dec->demux); dvb_unregister_adapter(&dec->adapter); return result; } if ((result = dec->demux.dmx.connect_frontend(&dec->demux.dmx, &dec->frontend)) < 0) { printk("%s: dvb_dmx_init failed: error %d\n", __func__, result); dec->demux.dmx.remove_frontend(&dec->demux.dmx, &dec->frontend); dvb_dmxdev_release(&dec->dmxdev); dvb_dmx_release(&dec->demux); dvb_unregister_adapter(&dec->adapter); return result; } dvb_net_init(&dec->adapter, &dec->dvb_net, &dec->demux.dmx); return 0; } static void ttusb_dec_exit_dvb(struct ttusb_dec *dec) { dprintk("%s\n", __func__); dvb_net_release(&dec->dvb_net); dec->demux.dmx.close(&dec->demux.dmx); dec->demux.dmx.remove_frontend(&dec->demux.dmx, &dec->frontend); dvb_dmxdev_release(&dec->dmxdev); dvb_dmx_release(&dec->demux); if (dec->fe) { dvb_unregister_frontend(dec->fe); if (dec->fe->ops.release) dec->fe->ops.release(dec->fe); } dvb_unregister_adapter(&dec->adapter); } static void ttusb_dec_exit_rc(struct ttusb_dec *dec) { dprintk("%s\n", __func__); if (dec->rc_input_dev) { input_unregister_device(dec->rc_input_dev); dec->rc_input_dev = NULL; } } static void ttusb_dec_exit_usb(struct ttusb_dec *dec) { int i; dprintk("%s\n", __func__); if (enable_rc) { /* we have to check whether the irq URB is already submitted. * As the irq is submitted after the interface is changed, * this is the best method i figured out. * Any others?*/ if (dec->interface == TTUSB_DEC_INTERFACE_IN) usb_kill_urb(dec->irq_urb); usb_free_urb(dec->irq_urb); usb_free_coherent(dec->udev, IRQ_PACKET_SIZE, dec->irq_buffer, dec->irq_dma_handle); } dec->iso_stream_count = 0; for (i = 0; i < ISO_BUF_COUNT; i++) usb_kill_urb(dec->iso_urb[i]); ttusb_dec_free_iso_urbs(dec); } static void ttusb_dec_exit_tasklet(struct ttusb_dec *dec) { struct list_head *item; struct urb_frame *frame; tasklet_kill(&dec->urb_tasklet); while ((item = dec->urb_frame_list.next) != &dec->urb_frame_list) { frame = list_entry(item, struct urb_frame, urb_frame_list); list_del(&frame->urb_frame_list); kfree(frame); } } static void ttusb_dec_init_filters(struct ttusb_dec *dec) { INIT_LIST_HEAD(&dec->filter_info_list); spin_lock_init(&dec->filter_info_list_lock); } static void ttusb_dec_exit_filters(struct ttusb_dec *dec) { struct list_head *item; struct filter_info *finfo; while ((item = dec->filter_info_list.next) != &dec->filter_info_list) { finfo = list_entry(item, struct filter_info, filter_info_list); list_del(&finfo->filter_info_list); kfree(finfo); } } static int fe_send_command(struct dvb_frontend* fe, const u8 command, int param_length, const u8 params[], int *result_length, u8 cmd_result[]) { struct ttusb_dec* dec = fe->dvb->priv; return ttusb_dec_send_command(dec, command, param_length, params, result_length, cmd_result); } static const struct ttusbdecfe_config fe_config = { .send_command = fe_send_command }; static int ttusb_dec_probe(struct usb_interface *intf, const struct usb_device_id *id) { struct usb_device *udev; struct ttusb_dec *dec; int result; dprintk("%s\n", __func__); udev = interface_to_usbdev(intf); if (!(dec = kzalloc(sizeof(struct ttusb_dec), GFP_KERNEL))) { printk("%s: couldn't allocate memory.\n", __func__); return -ENOMEM; } usb_set_intfdata(intf, (void *)dec); switch (id->idProduct) { case 0x1006: ttusb_dec_set_model(dec, TTUSB_DEC3000S); break; case 0x1008: ttusb_dec_set_model(dec, TTUSB_DEC2000T); break; case 0x1009: ttusb_dec_set_model(dec, TTUSB_DEC2540T); break; } dec->udev = udev; result = ttusb_dec_init_usb(dec); if (result) goto err_usb; result = ttusb_dec_init_stb(dec); if (result) goto err_stb; result = ttusb_dec_init_dvb(dec); if (result) goto err_stb; dec->adapter.priv = dec; switch (id->idProduct) { case 0x1006: dec->fe = ttusbdecfe_dvbs_attach(&fe_config); break; case 0x1008: case 0x1009: dec->fe = ttusbdecfe_dvbt_attach(&fe_config); break; } if (dec->fe == NULL) { printk("dvb-ttusb-dec: A frontend driver was not found for device [%04x:%04x]\n", le16_to_cpu(dec->udev->descriptor.idVendor), le16_to_cpu(dec->udev->descriptor.idProduct)); } else { if (dvb_register_frontend(&dec->adapter, dec->fe)) { printk("budget-ci: Frontend registration failed!\n"); if (dec->fe->ops.release) dec->fe->ops.release(dec->fe); dec->fe = NULL; } } ttusb_dec_init_v_pes(dec); ttusb_dec_init_filters(dec); ttusb_dec_init_tasklet(dec); dec->active = 1; ttusb_dec_set_interface(dec, TTUSB_DEC_INTERFACE_IN); if (enable_rc) ttusb_init_rc(dec); return 0; err_stb: ttusb_dec_exit_usb(dec); err_usb: kfree(dec); return result; } static void ttusb_dec_disconnect(struct usb_interface *intf) { struct ttusb_dec *dec = usb_get_intfdata(intf); usb_set_intfdata(intf, NULL); dprintk("%s\n", __func__); if (dec->active) { ttusb_dec_exit_tasklet(dec); ttusb_dec_exit_filters(dec); if(enable_rc) ttusb_dec_exit_rc(dec); ttusb_dec_exit_usb(dec); ttusb_dec_exit_dvb(dec); } kfree(dec); } static void ttusb_dec_set_model(struct ttusb_dec *dec, enum ttusb_dec_model model) { dec->model = model; switch (model) { case TTUSB_DEC2000T: dec->model_name = "DEC2000-t"; dec->firmware_name = "dvb-ttusb-dec-2000t.fw"; break; case TTUSB_DEC2540T: dec->model_name = "DEC2540-t"; dec->firmware_name = "dvb-ttusb-dec-2540t.fw"; break; case TTUSB_DEC3000S: dec->model_name = "DEC3000-s"; dec->firmware_name = "dvb-ttusb-dec-3000s.fw"; break; } } static const struct usb_device_id ttusb_dec_table[] = { {USB_DEVICE(0x0b48, 0x1006)}, /* DEC3000-s */ /*{USB_DEVICE(0x0b48, 0x1007)}, Unconfirmed */ {USB_DEVICE(0x0b48, 0x1008)}, /* DEC2000-t */ {USB_DEVICE(0x0b48, 0x1009)}, /* DEC2540-t */ {} }; static struct usb_driver ttusb_dec_driver = { .name = "ttusb-dec", .probe = ttusb_dec_probe, .disconnect = ttusb_dec_disconnect, .id_table = ttusb_dec_table, }; module_usb_driver(ttusb_dec_driver); MODULE_AUTHOR("Alex Woods <linux-dvb@giblets.org>"); MODULE_DESCRIPTION(DRIVER_NAME); MODULE_LICENSE("GPL"); MODULE_DEVICE_TABLE(usb, ttusb_dec_table);
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1