android_kernel_xiaomi_sm8350/drivers/media/dvb/ttusb-dec/ttusb_dec.c
Jiri Slaby 7b19ada2ed get rid of input BIT* duplicate defines
get rid of input BIT* duplicate defines

use newly global defined macros for input layer. Also remove includes of
input.h from non-input sources only for BIT macro definiton. Define the
macro temporarily in local manner, all those local definitons will be
removed further in this patchset (to not break bisecting).
BIT macro will be globally defined (1<<x)

Signed-off-by: Jiri Slaby <jirislaby@gmail.com>
Cc: <dtor@mail.ru>
Acked-by: Jiri Kosina <jkosina@suse.cz>
Cc: <lenb@kernel.org>
Acked-by: Marcel Holtmann <marcel@holtmann.org>
Cc: <perex@suse.cz>
Acked-by: Mauro Carvalho Chehab <mchehab@infradead.org>
Cc: <vernux@us.ibm.com>
Cc: <malattia@linux.it>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-19 11:53:42 -07:00

1772 lines
40 KiB
C

/*
* 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.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
*/
#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 "dmxdev.h"
#include "dvb_demux.h"
#include "dvb_filter.h"
#include "dvb_frontend.h"
#include "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)");
#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
};
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;
dma_addr_t iso_dma_handle;
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 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",
__FUNCTION__, urb->status);
return;
default:
dprintk("%s:nonzero status received: %d\n",
__FUNCTION__,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 recieved for lets say 200ms.
* this should/could be added later ...
* for now lets report each signal as a key down and up*/
dprintk("%s:rc signal:%d\n", __FUNCTION__, 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",
__FUNCTION__, 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, i;
u8 *b;
dprintk("%s\n", __FUNCTION__);
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", __FUNCTION__);
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("%s: command: ", __FUNCTION__);
for (i = 0; i < param_length + 4; i++)
printk("0x%02X ", b[i]);
printk("\n");
}
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",
__FUNCTION__, 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",
__FUNCTION__, result);
mutex_unlock(&dec->usb_mutex);
kfree(b);
return result;
} else {
if (debug) {
printk("%s: result: ", __FUNCTION__);
for (i = 0; i < actual_len; i++)
printk("0x%02X ", b[i]);
printk("\n");
}
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;
unsigned int tmp;
dprintk("%s\n", __FUNCTION__);
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 -1;
}
}
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,
DMX_OK);
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,
DMX_OK);
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 };
u16 pcr = htons(dec->pid[DMX_PES_PCR]);
u16 audio = htons(dec->pid[DMX_PES_AUDIO]);
u16 video = htons(dec->pid[DMX_PES_VIDEO]);
dprintk("%s\n", __FUNCTION__);
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", __FUNCTION__);
return;
}
if (length > 8 + MAX_PVA_LENGTH) {
printk("%s: packet too long - discarding\n", __FUNCTION__);
return;
}
switch (pva[2]) {
case 0x01: { /* VideoStream */
int prebytes = pva[5] & 0x03;
int postbytes = (pva[5] & 0x0c) >> 2;
u16 v_pes_payload_length;
if (output_pva) {
dec->video_filter->feed->cb.ts(pva, length, NULL, 0,
&dec->video_filter->feed->feed.ts, DMX_OK);
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, DMX_OK);
return;
}
dvb_filter_pes2ts(&dec->a_pes2ts, &pva[8], length - 8,
pva[5] & 0x10);
break;
default:
printk("%s: unknown PVA type: %02x.\n", __FUNCTION__,
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, DMX_OK);
}
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", __FUNCTION__);
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", __FUNCTION__);
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",
__FUNCTION__, 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)
{
u8 c;
length -= length % 2;
for (; length; b += 2, length -= 2) {
c = *b;
*b = *(b + 1);
*(b + 1) = c;
}
}
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", __FUNCTION__,
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",
__FUNCTION__);
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", __FUNCTION__,
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", __FUNCTION__);
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", __FUNCTION__);
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", __FUNCTION__);
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", __FUNCTION__, 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", __FUNCTION__);
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_TS_PES_VIDEO:
dprintk(" pes_type: DMX_TS_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_TS_PES_AUDIO:
dprintk(" pes_type: DMX_TS_PES_AUDIO\n");
dec->pid[DMX_PES_AUDIO] = dvbdmxfeed->pid;
dec->audio_filter = dvbdmxfeed->filter;
ttusb_dec_set_pids(dec);
break;
case DMX_TS_PES_TELETEXT:
dec->pid[DMX_PES_TELETEXT] = dvbdmxfeed->pid;
dprintk(" pes_type: DMX_TS_PES_TELETEXT(not supported)\n");
return -ENOSYS;
case DMX_TS_PES_PCR:
dprintk(" pes_type: DMX_TS_PES_PCR\n");
dec->pid[DMX_PES_PCR] = dvbdmxfeed->pid;
ttusb_dec_set_pids(dec);
break;
case DMX_TS_PES_OTHER:
dprintk(" pes_type: DMX_TS_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 };
u16 pid;
u8 c[COMMAND_PACKET_SIZE];
int c_length;
int result;
struct filter_info *finfo;
unsigned long flags;
u8 x = 1;
dprintk("%s\n", __FUNCTION__);
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", __FUNCTION__);
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", __FUNCTION__);
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", __FUNCTION__);
for (i = 0; i < ISO_BUF_COUNT; i++)
usb_free_urb(dec->iso_urb[i]);
pci_free_consistent(NULL,
ISO_FRAME_SIZE * (FRAMES_PER_ISO_BUF *
ISO_BUF_COUNT),
dec->iso_buffer, dec->iso_dma_handle);
}
static int ttusb_dec_alloc_iso_urbs(struct ttusb_dec *dec)
{
int i;
dprintk("%s\n", __FUNCTION__);
dec->iso_buffer = pci_alloc_consistent(NULL,
ISO_FRAME_SIZE *
(FRAMES_PER_ISO_BUF *
ISO_BUF_COUNT),
&dec->iso_dma_handle);
memset(dec->iso_buffer, 0,
ISO_FRAME_SIZE * (FRAMES_PER_ISO_BUF * ISO_BUF_COUNT));
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));
strlcpy(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",__FUNCTION__);
/* 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", __FUNCTION__);
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)
{
dprintk("%s\n", __FUNCTION__);
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_buffer_alloc(dec->udev,IRQ_PACKET_SIZE,
GFP_ATOMIC, &dec->irq_dma_handle);
if(!dec->irq_buffer) {
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;
}
return ttusb_dec_alloc_iso_urbs(dec);
}
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];
u8 *firmware = NULL;
size_t firmware_size = 0;
u16 firmware_csum = 0;
u16 firmware_csum_ns;
u32 firmware_size_nl;
u32 crc32_csum, crc32_check, tmp;
const struct firmware *fw_entry = NULL;
dprintk("%s\n", __FUNCTION__);
if (request_firmware(&fw_entry, dec->firmware_name, &dec->udev->dev)) {
printk(KERN_ERR "%s: Firmware (%s) unavailable.\n",
__FUNCTION__, dec->firmware_name);
return 1;
}
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",
__FUNCTION__, firmware_size);
release_firmware(fw_entry);
return -1;
}
/* 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 = htonl(tmp);
if (crc32_csum != crc32_check) {
printk("%s: crc32 check of DSP code failed (calculated "
"0x%08x != 0x%08x in file), file invalid.\n",
__FUNCTION__, crc32_csum, crc32_check);
release_firmware(fw_entry);
return -1;
}
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, model, version;
dprintk("%s\n", __FUNCTION__);
result = ttusb_dec_get_stb_state(dec, &mode, &model, &version);
if (!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
return 1;
} 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",
__FUNCTION__, model);
return -1;
break;
}
if (version >= 0x01770000)
dec->can_playback = 1;
return 0;
}
}
else
return result;
}
static int ttusb_dec_init_dvb(struct ttusb_dec *dec)
{
int result;
dprintk("%s\n", __FUNCTION__);
if ((result = dvb_register_adapter(&dec->adapter,
dec->model_name, THIS_MODULE, &dec->udev->dev)) < 0) {
printk("%s: dvb_register_adapter failed: error %d\n",
__FUNCTION__, 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", __FUNCTION__,
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",
__FUNCTION__, 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", __FUNCTION__,
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", __FUNCTION__,
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", __FUNCTION__);
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", __FUNCTION__);
/* 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_buffer_free(dec->udev,IRQ_PACKET_SIZE,
dec->irq_buffer, dec->irq_dma_handle);
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", __FUNCTION__);
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 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;
dprintk("%s\n", __FUNCTION__);
udev = interface_to_usbdev(intf);
if (!(dec = kzalloc(sizeof(struct ttusb_dec), GFP_KERNEL))) {
printk("%s: couldn't allocate memory.\n", __FUNCTION__);
return -ENOMEM;
}
usb_set_intfdata(intf, (void *)dec);
switch (le16_to_cpu(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;
if (ttusb_dec_init_usb(dec))
return 0;
if (ttusb_dec_init_stb(dec)) {
ttusb_dec_exit_usb(dec);
return 0;
}
ttusb_dec_init_dvb(dec);
dec->adapter.priv = dec;
switch (le16_to_cpu(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;
}
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", __FUNCTION__);
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 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,
};
static int __init ttusb_dec_init(void)
{
int result;
if ((result = usb_register(&ttusb_dec_driver)) < 0) {
printk("%s: initialisation failed: error %d.\n", __FUNCTION__,
result);
return result;
}
return 0;
}
static void __exit ttusb_dec_exit(void)
{
usb_deregister(&ttusb_dec_driver);
}
module_init(ttusb_dec_init);
module_exit(ttusb_dec_exit);
MODULE_AUTHOR("Alex Woods <linux-dvb@giblets.org>");
MODULE_DESCRIPTION(DRIVER_NAME);
MODULE_LICENSE("GPL");
MODULE_DEVICE_TABLE(usb, ttusb_dec_table);