2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* TTUSB DVB driver
|
|
|
|
*
|
|
|
|
* Copyright (c) 2002 Holger Waechtler <holger@convergence.de>
|
|
|
|
* Copyright (c) 2003 Felix Domke <tmbinc@elitedvb.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.
|
|
|
|
*/
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/wait.h>
|
2008-07-04 09:33:20 +00:00
|
|
|
#include <linux/fs.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/usb.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/time.h>
|
|
|
|
#include <linux/errno.h>
|
2005-09-09 20:03:15 +00:00
|
|
|
#include <linux/jiffies.h>
|
2006-02-07 08:49:14 +00:00
|
|
|
#include <linux/mutex.h>
|
2008-05-29 16:50:06 +00:00
|
|
|
#include <linux/firmware.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#include "dvb_frontend.h"
|
|
|
|
#include "dmxdev.h"
|
|
|
|
#include "dvb_demux.h"
|
|
|
|
#include "dvb_net.h"
|
2005-07-08 00:58:04 +00:00
|
|
|
#include "ves1820.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
#include "cx22700.h"
|
|
|
|
#include "tda1004x.h"
|
|
|
|
#include "stv0299.h"
|
|
|
|
#include "tda8083.h"
|
2006-04-28 00:45:20 +00:00
|
|
|
#include "stv0297.h"
|
2006-04-28 00:45:01 +00:00
|
|
|
#include "lnbp21.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#include <linux/dvb/frontend.h>
|
|
|
|
#include <linux/dvb/dmx.h>
|
|
|
|
#include <linux/pci.h>
|
|
|
|
|
|
|
|
/*
|
|
|
|
TTUSB_HWSECTIONS:
|
|
|
|
the DSP supports filtering in hardware, however, since the "muxstream"
|
|
|
|
is a bit braindead (no matching channel masks or no matching filter mask),
|
|
|
|
we won't support this - yet. it doesn't event support negative filters,
|
|
|
|
so the best way is maybe to keep TTUSB_HWSECTIONS undef'd and just
|
2006-06-30 16:19:55 +00:00
|
|
|
parse TS data. USB bandwidth will be a problem when having large
|
2005-04-16 22:20:36 +00:00
|
|
|
datastreams, especially for dvb-net, but hey, that's not my problem.
|
|
|
|
|
|
|
|
TTUSB_DISEQC, TTUSB_TONE:
|
|
|
|
let the STC do the diseqc/tone stuff. this isn't supported at least with
|
|
|
|
my TTUSB, so let it undef'd unless you want to implement another
|
|
|
|
frontend. never tested.
|
|
|
|
|
2011-03-24 15:56:16 +00:00
|
|
|
debug:
|
2005-04-16 22:20:36 +00:00
|
|
|
define it to > 3 for really hardcore debugging. you probably don't want
|
|
|
|
this unless the device doesn't load at all. > 2 for bandwidth statistics.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int debug;
|
|
|
|
module_param(debug, int, 0644);
|
|
|
|
MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
|
|
|
|
|
2008-04-09 22:13:13 +00:00
|
|
|
DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#define dprintk(x...) do { if (debug) printk(KERN_DEBUG x); } while (0)
|
|
|
|
|
|
|
|
#define ISO_BUF_COUNT 4
|
|
|
|
#define FRAMES_PER_ISO_BUF 4
|
|
|
|
#define ISO_FRAME_SIZE 912
|
|
|
|
#define TTUSB_MAXCHANNEL 32
|
|
|
|
#ifdef TTUSB_HWSECTIONS
|
|
|
|
#define TTUSB_MAXFILTER 16 /* ??? */
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#define TTUSB_REV_2_2 0x22
|
|
|
|
#define TTUSB_BUDGET_NAME "ttusb_stc_fw"
|
|
|
|
|
|
|
|
/**
|
|
|
|
* since we're casting (struct ttusb*) <-> (struct dvb_demux*) around
|
|
|
|
* the dvb_demux field must be the first in struct!!
|
|
|
|
*/
|
|
|
|
struct ttusb {
|
|
|
|
struct dvb_demux dvb_demux;
|
|
|
|
struct dmxdev dmxdev;
|
|
|
|
struct dvb_net dvbnet;
|
|
|
|
|
|
|
|
/* and one for USB access. */
|
2006-02-07 08:49:14 +00:00
|
|
|
struct mutex semi2c;
|
|
|
|
struct mutex semusb;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-05-17 04:54:39 +00:00
|
|
|
struct dvb_adapter adapter;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct usb_device *dev;
|
|
|
|
|
|
|
|
struct i2c_adapter i2c_adap;
|
|
|
|
|
|
|
|
int disconnecting;
|
|
|
|
int iso_streaming;
|
|
|
|
|
|
|
|
unsigned int bulk_out_pipe;
|
|
|
|
unsigned int bulk_in_pipe;
|
|
|
|
unsigned int isoc_in_pipe;
|
|
|
|
|
|
|
|
void *iso_buffer;
|
|
|
|
dma_addr_t iso_dma_handle;
|
|
|
|
|
|
|
|
struct urb *iso_urb[ISO_BUF_COUNT];
|
|
|
|
|
|
|
|
int running_feed_count;
|
|
|
|
int last_channel;
|
|
|
|
int last_filter;
|
|
|
|
|
|
|
|
u8 c; /* transaction counter, wraps around... */
|
|
|
|
fe_sec_tone_mode_t tone;
|
|
|
|
fe_sec_voltage_t voltage;
|
|
|
|
|
|
|
|
int mux_state; // 0..2 - MuxSyncWord, 3 - nMuxPacks, 4 - muxpack
|
|
|
|
u8 mux_npacks;
|
|
|
|
u8 muxpack[256 + 8];
|
|
|
|
int muxpack_ptr, muxpack_len;
|
|
|
|
|
|
|
|
int insync;
|
|
|
|
|
|
|
|
int cc; /* MuxCounter - will increment on EVERY MUX PACKET */
|
|
|
|
/* (including stuffing. yes. really.) */
|
|
|
|
|
|
|
|
u8 last_result[32];
|
|
|
|
|
|
|
|
int revision;
|
|
|
|
|
|
|
|
struct dvb_frontend* fe;
|
|
|
|
};
|
|
|
|
|
2007-10-19 21:10:43 +00:00
|
|
|
/* ugly workaround ... don't know why it's necessary to read */
|
2005-04-16 22:20:36 +00:00
|
|
|
/* all result codes. */
|
|
|
|
|
|
|
|
static int ttusb_cmd(struct ttusb *ttusb,
|
|
|
|
const u8 * data, int len, int needresult)
|
|
|
|
{
|
|
|
|
int actual_len;
|
|
|
|
int err;
|
|
|
|
int i;
|
|
|
|
|
2011-03-24 15:56:16 +00:00
|
|
|
if (debug >= 3) {
|
|
|
|
printk(KERN_DEBUG ">");
|
|
|
|
for (i = 0; i < len; ++i)
|
|
|
|
printk(KERN_CONT " %02x", data[i]);
|
|
|
|
printk(KERN_CONT "\n");
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-02-07 08:49:14 +00:00
|
|
|
if (mutex_lock_interruptible(&ttusb->semusb) < 0)
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EAGAIN;
|
|
|
|
|
|
|
|
err = usb_bulk_msg(ttusb->dev, ttusb->bulk_out_pipe,
|
|
|
|
(u8 *) data, len, &actual_len, 1000);
|
|
|
|
if (err != 0) {
|
|
|
|
dprintk("%s: usb_bulk_msg(send) failed, err == %i!\n",
|
2008-04-09 02:20:00 +00:00
|
|
|
__func__, err);
|
2006-02-07 08:49:14 +00:00
|
|
|
mutex_unlock(&ttusb->semusb);
|
2005-04-16 22:20:36 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
if (actual_len != len) {
|
2008-04-09 02:20:00 +00:00
|
|
|
dprintk("%s: only wrote %d of %d bytes\n", __func__,
|
2005-04-16 22:20:36 +00:00
|
|
|
actual_len, len);
|
2006-02-07 08:49:14 +00:00
|
|
|
mutex_unlock(&ttusb->semusb);
|
2005-04-16 22:20:36 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = usb_bulk_msg(ttusb->dev, ttusb->bulk_in_pipe,
|
|
|
|
ttusb->last_result, 32, &actual_len, 1000);
|
|
|
|
|
|
|
|
if (err != 0) {
|
2008-04-09 02:20:00 +00:00
|
|
|
printk("%s: failed, receive error %d\n", __func__,
|
2005-04-16 22:20:36 +00:00
|
|
|
err);
|
2006-02-07 08:49:14 +00:00
|
|
|
mutex_unlock(&ttusb->semusb);
|
2005-04-16 22:20:36 +00:00
|
|
|
return err;
|
|
|
|
}
|
2011-03-24 15:56:16 +00:00
|
|
|
|
|
|
|
if (debug >= 3) {
|
|
|
|
actual_len = ttusb->last_result[3] + 4;
|
|
|
|
printk(KERN_DEBUG "<");
|
|
|
|
for (i = 0; i < actual_len; ++i)
|
|
|
|
printk(KERN_CONT " %02x", ttusb->last_result[i]);
|
|
|
|
printk(KERN_CONT "\n");
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!needresult)
|
2006-02-07 08:49:14 +00:00
|
|
|
mutex_unlock(&ttusb->semusb);
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ttusb_result(struct ttusb *ttusb, u8 * data, int len)
|
|
|
|
{
|
|
|
|
memcpy(data, ttusb->last_result, len);
|
2006-02-07 08:49:14 +00:00
|
|
|
mutex_unlock(&ttusb->semusb);
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ttusb_i2c_msg(struct ttusb *ttusb,
|
|
|
|
u8 addr, u8 * snd_buf, u8 snd_len, u8 * rcv_buf,
|
|
|
|
u8 rcv_len)
|
|
|
|
{
|
|
|
|
u8 b[0x28];
|
|
|
|
u8 id = ++ttusb->c;
|
|
|
|
int i, err;
|
|
|
|
|
|
|
|
if (snd_len > 0x28 - 7 || rcv_len > 0x20 - 7)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
b[0] = 0xaa;
|
|
|
|
b[1] = id;
|
|
|
|
b[2] = 0x31;
|
|
|
|
b[3] = snd_len + 3;
|
|
|
|
b[4] = addr << 1;
|
|
|
|
b[5] = snd_len;
|
|
|
|
b[6] = rcv_len;
|
|
|
|
|
|
|
|
for (i = 0; i < snd_len; i++)
|
|
|
|
b[7 + i] = snd_buf[i];
|
|
|
|
|
|
|
|
err = ttusb_cmd(ttusb, b, snd_len + 7, 1);
|
|
|
|
|
|
|
|
if (err)
|
|
|
|
return -EREMOTEIO;
|
|
|
|
|
|
|
|
err = ttusb_result(ttusb, b, 0x20);
|
|
|
|
|
2005-12-12 08:37:24 +00:00
|
|
|
/* check if the i2c transaction was successful */
|
|
|
|
if ((snd_len != b[5]) || (rcv_len != b[6])) return -EREMOTEIO;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (rcv_len > 0) {
|
|
|
|
|
|
|
|
if (err || b[0] != 0x55 || b[1] != id) {
|
|
|
|
dprintk
|
|
|
|
("%s: usb_bulk_msg(recv) failed, err == %i, id == %02x, b == ",
|
2008-04-09 02:20:00 +00:00
|
|
|
__func__, err, id);
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EREMOTEIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < rcv_len; i++)
|
|
|
|
rcv_buf[i] = b[7 + i];
|
|
|
|
}
|
|
|
|
|
|
|
|
return rcv_len;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int master_xfer(struct i2c_adapter* adapter, struct i2c_msg *msg, int num)
|
|
|
|
{
|
|
|
|
struct ttusb *ttusb = i2c_get_adapdata(adapter);
|
|
|
|
int i = 0;
|
|
|
|
int inc;
|
|
|
|
|
2006-02-07 08:49:14 +00:00
|
|
|
if (mutex_lock_interruptible(&ttusb->semi2c) < 0)
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EAGAIN;
|
|
|
|
|
|
|
|
while (i < num) {
|
|
|
|
u8 addr, snd_len, rcv_len, *snd_buf, *rcv_buf;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (num > i + 1 && (msg[i + 1].flags & I2C_M_RD)) {
|
|
|
|
addr = msg[i].addr;
|
|
|
|
snd_buf = msg[i].buf;
|
|
|
|
snd_len = msg[i].len;
|
|
|
|
rcv_buf = msg[i + 1].buf;
|
|
|
|
rcv_len = msg[i + 1].len;
|
|
|
|
inc = 2;
|
|
|
|
} else {
|
|
|
|
addr = msg[i].addr;
|
|
|
|
snd_buf = msg[i].buf;
|
|
|
|
snd_len = msg[i].len;
|
|
|
|
rcv_buf = NULL;
|
|
|
|
rcv_len = 0;
|
|
|
|
inc = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = ttusb_i2c_msg(ttusb, addr,
|
|
|
|
snd_buf, snd_len, rcv_buf, rcv_len);
|
|
|
|
|
|
|
|
if (err < rcv_len) {
|
2008-04-09 02:20:00 +00:00
|
|
|
dprintk("%s: i == %i\n", __func__, i);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
i += inc;
|
|
|
|
}
|
|
|
|
|
2006-02-07 08:49:14 +00:00
|
|
|
mutex_unlock(&ttusb->semi2c);
|
2005-04-16 22:20:36 +00:00
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ttusb_boot_dsp(struct ttusb *ttusb)
|
|
|
|
{
|
2008-05-29 16:50:06 +00:00
|
|
|
const struct firmware *fw;
|
2005-04-16 22:20:36 +00:00
|
|
|
int i, err;
|
|
|
|
u8 b[40];
|
|
|
|
|
2008-05-29 16:50:06 +00:00
|
|
|
err = request_firmware(&fw, "ttusb-budget/dspbootcode.bin",
|
|
|
|
&ttusb->dev->dev);
|
|
|
|
if (err) {
|
|
|
|
printk(KERN_ERR "ttusb-budget: failed to request firmware\n");
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* BootBlock */
|
|
|
|
b[0] = 0xaa;
|
|
|
|
b[2] = 0x13;
|
|
|
|
b[3] = 28;
|
|
|
|
|
|
|
|
/* upload dsp code in 32 byte steps (36 didn't work for me ...) */
|
|
|
|
/* 32 is max packet size, no messages should be splitted. */
|
2008-05-29 16:50:06 +00:00
|
|
|
for (i = 0; i < fw->size; i += 28) {
|
|
|
|
memcpy(&b[4], &fw->data[i], 28);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
b[1] = ++ttusb->c;
|
|
|
|
|
|
|
|
err = ttusb_cmd(ttusb, b, 32, 0);
|
|
|
|
if (err)
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* last block ... */
|
|
|
|
b[1] = ++ttusb->c;
|
|
|
|
b[2] = 0x13;
|
|
|
|
b[3] = 0;
|
|
|
|
|
|
|
|
err = ttusb_cmd(ttusb, b, 4, 0);
|
|
|
|
if (err)
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
/* BootEnd */
|
|
|
|
b[1] = ++ttusb->c;
|
|
|
|
b[2] = 0x14;
|
|
|
|
b[3] = 0;
|
|
|
|
|
|
|
|
err = ttusb_cmd(ttusb, b, 4, 0);
|
|
|
|
|
|
|
|
done:
|
2011-02-06 20:49:02 +00:00
|
|
|
release_firmware(fw);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (err) {
|
|
|
|
dprintk("%s: usb_bulk_msg() failed, return value %i!\n",
|
2008-04-09 02:20:00 +00:00
|
|
|
__func__, err);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ttusb_set_channel(struct ttusb *ttusb, int chan_id, int filter_type,
|
|
|
|
int pid)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
/* SetChannel */
|
|
|
|
u8 b[] = { 0xaa, ++ttusb->c, 0x22, 4, chan_id, filter_type,
|
|
|
|
(pid >> 8) & 0xff, pid & 0xff
|
|
|
|
};
|
|
|
|
|
|
|
|
err = ttusb_cmd(ttusb, b, sizeof(b), 0);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ttusb_del_channel(struct ttusb *ttusb, int channel_id)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
/* DelChannel */
|
|
|
|
u8 b[] = { 0xaa, ++ttusb->c, 0x23, 1, channel_id };
|
|
|
|
|
|
|
|
err = ttusb_cmd(ttusb, b, sizeof(b), 0);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef TTUSB_HWSECTIONS
|
|
|
|
static int ttusb_set_filter(struct ttusb *ttusb, int filter_id,
|
|
|
|
int associated_chan, u8 filter[8], u8 mask[8])
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
/* SetFilter */
|
|
|
|
u8 b[] = { 0xaa, 0, 0x24, 0x1a, filter_id, associated_chan,
|
|
|
|
filter[0], filter[1], filter[2], filter[3],
|
|
|
|
filter[4], filter[5], filter[6], filter[7],
|
|
|
|
filter[8], filter[9], filter[10], filter[11],
|
|
|
|
mask[0], mask[1], mask[2], mask[3],
|
|
|
|
mask[4], mask[5], mask[6], mask[7],
|
|
|
|
mask[8], mask[9], mask[10], mask[11]
|
|
|
|
};
|
|
|
|
|
|
|
|
err = ttusb_cmd(ttusb, b, sizeof(b), 0);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ttusb_del_filter(struct ttusb *ttusb, int filter_id)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
/* DelFilter */
|
|
|
|
u8 b[] = { 0xaa, ++ttusb->c, 0x25, 1, filter_id };
|
|
|
|
|
|
|
|
err = ttusb_cmd(ttusb, b, sizeof(b), 0);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static int ttusb_init_controller(struct ttusb *ttusb)
|
|
|
|
{
|
|
|
|
u8 b0[] = { 0xaa, ++ttusb->c, 0x15, 1, 0 };
|
|
|
|
u8 b1[] = { 0xaa, ++ttusb->c, 0x15, 1, 1 };
|
|
|
|
u8 b2[] = { 0xaa, ++ttusb->c, 0x32, 1, 0 };
|
|
|
|
/* i2c write read: 5 bytes, addr 0x10, 0x02 bytes write, 1 bytes read. */
|
|
|
|
u8 b3[] =
|
|
|
|
{ 0xaa, ++ttusb->c, 0x31, 5, 0x10, 0x02, 0x01, 0x00, 0x1e };
|
|
|
|
u8 b4[] =
|
|
|
|
{ 0x55, ttusb->c, 0x31, 4, 0x10, 0x02, 0x01, 0x00, 0x1e };
|
|
|
|
|
|
|
|
u8 get_version[] = { 0xaa, ++ttusb->c, 0x17, 5, 0, 0, 0, 0, 0 };
|
|
|
|
u8 get_dsp_version[0x20] =
|
|
|
|
{ 0xaa, ++ttusb->c, 0x26, 28, 0, 0, 0, 0, 0 };
|
|
|
|
int err;
|
|
|
|
|
|
|
|
/* reset board */
|
|
|
|
if ((err = ttusb_cmd(ttusb, b0, sizeof(b0), 0)))
|
|
|
|
return err;
|
|
|
|
|
|
|
|
/* reset board (again?) */
|
|
|
|
if ((err = ttusb_cmd(ttusb, b1, sizeof(b1), 0)))
|
|
|
|
return err;
|
|
|
|
|
|
|
|
ttusb_boot_dsp(ttusb);
|
|
|
|
|
|
|
|
/* set i2c bit rate */
|
|
|
|
if ((err = ttusb_cmd(ttusb, b2, sizeof(b2), 0)))
|
|
|
|
return err;
|
|
|
|
|
|
|
|
if ((err = ttusb_cmd(ttusb, b3, sizeof(b3), 1)))
|
|
|
|
return err;
|
|
|
|
|
|
|
|
err = ttusb_result(ttusb, b4, sizeof(b4));
|
|
|
|
|
|
|
|
if ((err = ttusb_cmd(ttusb, get_version, sizeof(get_version), 1)))
|
|
|
|
return err;
|
|
|
|
|
|
|
|
if ((err = ttusb_result(ttusb, get_version, sizeof(get_version))))
|
|
|
|
return err;
|
|
|
|
|
2008-04-09 02:20:00 +00:00
|
|
|
dprintk("%s: stc-version: %c%c%c%c%c\n", __func__,
|
2005-04-16 22:20:36 +00:00
|
|
|
get_version[4], get_version[5], get_version[6],
|
|
|
|
get_version[7], get_version[8]);
|
|
|
|
|
|
|
|
if (memcmp(get_version + 4, "V 0.0", 5) &&
|
|
|
|
memcmp(get_version + 4, "V 1.1", 5) &&
|
|
|
|
memcmp(get_version + 4, "V 2.1", 5) &&
|
|
|
|
memcmp(get_version + 4, "V 2.2", 5)) {
|
|
|
|
printk
|
|
|
|
("%s: unknown STC version %c%c%c%c%c, please report!\n",
|
2008-04-09 02:20:00 +00:00
|
|
|
__func__, get_version[4], get_version[5],
|
2005-04-16 22:20:36 +00:00
|
|
|
get_version[6], get_version[7], get_version[8]);
|
|
|
|
}
|
|
|
|
|
|
|
|
ttusb->revision = ((get_version[6] - '0') << 4) |
|
|
|
|
(get_version[8] - '0');
|
|
|
|
|
|
|
|
err =
|
|
|
|
ttusb_cmd(ttusb, get_dsp_version, sizeof(get_dsp_version), 1);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
err =
|
|
|
|
ttusb_result(ttusb, get_dsp_version, sizeof(get_dsp_version));
|
|
|
|
if (err)
|
|
|
|
return err;
|
2008-04-09 02:20:00 +00:00
|
|
|
printk("%s: dsp-version: %c%c%c\n", __func__,
|
2005-04-16 22:20:36 +00:00
|
|
|
get_dsp_version[4], get_dsp_version[5], get_dsp_version[6]);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef TTUSB_DISEQC
|
|
|
|
static int ttusb_send_diseqc(struct dvb_frontend* fe,
|
|
|
|
const struct dvb_diseqc_master_cmd *cmd)
|
|
|
|
{
|
|
|
|
struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
|
|
|
|
u8 b[12] = { 0xaa, ++ttusb->c, 0x18 };
|
|
|
|
|
|
|
|
int err;
|
|
|
|
|
|
|
|
b[3] = 4 + 2 + cmd->msg_len;
|
|
|
|
b[4] = 0xFF; /* send diseqc master, not burst */
|
|
|
|
b[5] = cmd->msg_len;
|
|
|
|
|
|
|
|
memcpy(b + 5, cmd->msg, cmd->msg_len);
|
|
|
|
|
|
|
|
/* Diseqc */
|
|
|
|
if ((err = ttusb_cmd(ttusb, b, 4 + b[3], 0))) {
|
|
|
|
dprintk("%s: usb_bulk_msg() failed, return value %i!\n",
|
2008-04-09 02:20:00 +00:00
|
|
|
__func__, err);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static int ttusb_update_lnb(struct ttusb *ttusb)
|
|
|
|
{
|
|
|
|
u8 b[] = { 0xaa, ++ttusb->c, 0x16, 5, /*power: */ 1,
|
|
|
|
ttusb->voltage == SEC_VOLTAGE_18 ? 0 : 1,
|
|
|
|
ttusb->tone == SEC_TONE_ON ? 1 : 0, 1, 1
|
|
|
|
};
|
|
|
|
int err;
|
|
|
|
|
|
|
|
/* SetLNB */
|
|
|
|
if ((err = ttusb_cmd(ttusb, b, sizeof(b), 0))) {
|
|
|
|
dprintk("%s: usb_bulk_msg() failed, return value %i!\n",
|
2008-04-09 02:20:00 +00:00
|
|
|
__func__, err);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ttusb_set_voltage(struct dvb_frontend* fe, fe_sec_voltage_t voltage)
|
|
|
|
{
|
|
|
|
struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
|
|
|
|
|
|
|
|
ttusb->voltage = voltage;
|
|
|
|
return ttusb_update_lnb(ttusb);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef TTUSB_TONE
|
|
|
|
static int ttusb_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
|
|
|
|
{
|
|
|
|
struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
|
|
|
|
|
|
|
|
ttusb->tone = tone;
|
|
|
|
return ttusb_update_lnb(ttusb);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
static void ttusb_set_led_freq(struct ttusb *ttusb, u8 freq)
|
|
|
|
{
|
|
|
|
u8 b[] = { 0xaa, ++ttusb->c, 0x19, 1, freq };
|
|
|
|
int err, actual_len;
|
|
|
|
|
|
|
|
err = ttusb_cmd(ttusb, b, sizeof(b), 0);
|
|
|
|
if (err) {
|
|
|
|
dprintk("%s: usb_bulk_msg() failed, return value %i!\n",
|
2008-04-09 02:20:00 +00:00
|
|
|
__func__, err);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
|
|
|
|
#ifdef TTUSB_HWSECTIONS
|
|
|
|
static void ttusb_handle_ts_data(struct ttusb_channel *channel,
|
|
|
|
const u8 * data, int len);
|
|
|
|
static void ttusb_handle_sec_data(struct ttusb_channel *channel,
|
|
|
|
const u8 * data, int len);
|
|
|
|
#endif
|
|
|
|
|
2008-04-22 17:41:48 +00:00
|
|
|
static int numpkt, numts, numstuff, numsec, numinvalid;
|
2005-09-09 20:03:15 +00:00
|
|
|
static unsigned long lastj;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
static void ttusb_process_muxpack(struct ttusb *ttusb, const u8 * muxpack,
|
|
|
|
int len)
|
|
|
|
{
|
|
|
|
u16 csum = 0, cc;
|
|
|
|
int i;
|
2013-02-07 07:24:49 +00:00
|
|
|
|
|
|
|
if (len < 4 || len & 0x1) {
|
|
|
|
pr_warn("%s: muxpack has invalid len %d\n", __func__, len);
|
|
|
|
numinvalid++;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
for (i = 0; i < len; i += 2)
|
2008-05-21 03:31:31 +00:00
|
|
|
csum ^= le16_to_cpup((__le16 *) (muxpack + i));
|
2005-04-16 22:20:36 +00:00
|
|
|
if (csum) {
|
|
|
|
printk("%s: muxpack with incorrect checksum, ignoring\n",
|
2008-04-09 02:20:00 +00:00
|
|
|
__func__);
|
2005-04-16 22:20:36 +00:00
|
|
|
numinvalid++;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
cc = (muxpack[len - 4] << 8) | muxpack[len - 3];
|
|
|
|
cc &= 0x7FFF;
|
|
|
|
if ((cc != ttusb->cc) && (ttusb->cc != -1))
|
|
|
|
printk("%s: cc discontinuity (%d frames missing)\n",
|
2008-04-09 02:20:00 +00:00
|
|
|
__func__, (cc - ttusb->cc) & 0x7FFF);
|
2005-04-16 22:20:36 +00:00
|
|
|
ttusb->cc = (cc + 1) & 0x7FFF;
|
|
|
|
if (muxpack[0] & 0x80) {
|
|
|
|
#ifdef TTUSB_HWSECTIONS
|
|
|
|
/* section data */
|
|
|
|
int pusi = muxpack[0] & 0x40;
|
|
|
|
int channel = muxpack[0] & 0x1F;
|
|
|
|
int payload = muxpack[1];
|
|
|
|
const u8 *data = muxpack + 2;
|
|
|
|
/* check offset flag */
|
|
|
|
if (muxpack[0] & 0x20)
|
|
|
|
data++;
|
|
|
|
|
|
|
|
ttusb_handle_sec_data(ttusb->channel + channel, data,
|
|
|
|
payload);
|
|
|
|
data += payload;
|
|
|
|
|
|
|
|
if ((!!(ttusb->muxpack[0] & 0x20)) ^
|
|
|
|
!!(ttusb->muxpack[1] & 1))
|
|
|
|
data++;
|
|
|
|
#warning TODO: pusi
|
|
|
|
printk("cc: %04x\n", (data[0] << 8) | data[1]);
|
|
|
|
#endif
|
|
|
|
numsec++;
|
|
|
|
} else if (muxpack[0] == 0x47) {
|
|
|
|
#ifdef TTUSB_HWSECTIONS
|
|
|
|
/* we have TS data here! */
|
|
|
|
int pid = ((muxpack[1] & 0x0F) << 8) | muxpack[2];
|
|
|
|
int channel;
|
|
|
|
for (channel = 0; channel < TTUSB_MAXCHANNEL; ++channel)
|
|
|
|
if (ttusb->channel[channel].active
|
|
|
|
&& (pid == ttusb->channel[channel].pid))
|
|
|
|
ttusb_handle_ts_data(ttusb->channel +
|
|
|
|
channel, muxpack,
|
|
|
|
188);
|
|
|
|
#endif
|
|
|
|
numts++;
|
|
|
|
dvb_dmx_swfilter_packets(&ttusb->dvb_demux, muxpack, 1);
|
|
|
|
} else if (muxpack[0] != 0) {
|
|
|
|
numinvalid++;
|
|
|
|
printk("illegal muxpack type %02x\n", muxpack[0]);
|
|
|
|
} else
|
|
|
|
numstuff++;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ttusb_process_frame(struct ttusb *ttusb, u8 * data, int len)
|
|
|
|
{
|
|
|
|
int maxwork = 1024;
|
|
|
|
while (len) {
|
|
|
|
if (!(maxwork--)) {
|
2008-04-09 02:20:00 +00:00
|
|
|
printk("%s: too much work\n", __func__);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (ttusb->mux_state) {
|
|
|
|
case 0:
|
|
|
|
case 1:
|
|
|
|
case 2:
|
|
|
|
len--;
|
|
|
|
if (*data++ == 0xAA)
|
|
|
|
++ttusb->mux_state;
|
|
|
|
else {
|
|
|
|
ttusb->mux_state = 0;
|
|
|
|
if (ttusb->insync) {
|
2011-03-24 15:56:16 +00:00
|
|
|
dprintk("%s: %02x\n",
|
|
|
|
__func__, data[-1]);
|
|
|
|
printk(KERN_INFO "%s: lost sync.\n",
|
2008-04-09 02:20:00 +00:00
|
|
|
__func__);
|
2005-04-16 22:20:36 +00:00
|
|
|
ttusb->insync = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
ttusb->insync = 1;
|
|
|
|
len--;
|
|
|
|
ttusb->mux_npacks = *data++;
|
|
|
|
++ttusb->mux_state;
|
|
|
|
ttusb->muxpack_ptr = 0;
|
|
|
|
/* maximum bytes, until we know the length */
|
|
|
|
ttusb->muxpack_len = 2;
|
|
|
|
break;
|
|
|
|
case 4:
|
|
|
|
{
|
|
|
|
int avail;
|
|
|
|
avail = len;
|
|
|
|
if (avail >
|
|
|
|
(ttusb->muxpack_len -
|
|
|
|
ttusb->muxpack_ptr))
|
|
|
|
avail =
|
|
|
|
ttusb->muxpack_len -
|
|
|
|
ttusb->muxpack_ptr;
|
|
|
|
memcpy(ttusb->muxpack + ttusb->muxpack_ptr,
|
|
|
|
data, avail);
|
|
|
|
ttusb->muxpack_ptr += avail;
|
2006-03-13 16:17:11 +00:00
|
|
|
BUG_ON(ttusb->muxpack_ptr > 264);
|
2005-04-16 22:20:36 +00:00
|
|
|
data += avail;
|
|
|
|
len -= avail;
|
|
|
|
/* determine length */
|
|
|
|
if (ttusb->muxpack_ptr == 2) {
|
|
|
|
if (ttusb->muxpack[0] & 0x80) {
|
|
|
|
ttusb->muxpack_len =
|
|
|
|
ttusb->muxpack[1] + 2;
|
|
|
|
if (ttusb->
|
|
|
|
muxpack[0] & 0x20)
|
|
|
|
ttusb->
|
|
|
|
muxpack_len++;
|
|
|
|
if ((!!
|
|
|
|
(ttusb->
|
|
|
|
muxpack[0] & 0x20)) ^
|
|
|
|
!!(ttusb->
|
|
|
|
muxpack[1] & 1))
|
|
|
|
ttusb->
|
|
|
|
muxpack_len++;
|
|
|
|
ttusb->muxpack_len += 4;
|
|
|
|
} else if (ttusb->muxpack[0] ==
|
|
|
|
0x47)
|
|
|
|
ttusb->muxpack_len =
|
|
|
|
188 + 4;
|
|
|
|
else if (ttusb->muxpack[0] == 0x00)
|
|
|
|
ttusb->muxpack_len =
|
|
|
|
ttusb->muxpack[1] + 2 +
|
|
|
|
4;
|
|
|
|
else {
|
|
|
|
dprintk
|
|
|
|
("%s: invalid state: first byte is %x\n",
|
2008-04-09 02:20:00 +00:00
|
|
|
__func__,
|
2005-04-16 22:20:36 +00:00
|
|
|
ttusb->muxpack[0]);
|
|
|
|
ttusb->mux_state = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* if length is valid and we reached the end:
|
|
|
|
* goto next muxpack
|
|
|
|
*/
|
|
|
|
if ((ttusb->muxpack_ptr >= 2) &&
|
|
|
|
(ttusb->muxpack_ptr ==
|
|
|
|
ttusb->muxpack_len)) {
|
|
|
|
ttusb_process_muxpack(ttusb,
|
|
|
|
ttusb->
|
|
|
|
muxpack,
|
|
|
|
ttusb->
|
|
|
|
muxpack_ptr);
|
|
|
|
ttusb->muxpack_ptr = 0;
|
|
|
|
/* maximum bytes, until we know the length */
|
|
|
|
ttusb->muxpack_len = 2;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* no muxpacks left?
|
|
|
|
* return to search-sync state
|
|
|
|
*/
|
|
|
|
if (!ttusb->mux_npacks--) {
|
|
|
|
ttusb->mux_state = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
BUG();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 13:55:46 +00:00
|
|
|
static void ttusb_iso_irq(struct urb *urb)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct ttusb *ttusb = urb->context;
|
2011-03-24 15:56:16 +00:00
|
|
|
struct usb_iso_packet_descriptor *d;
|
|
|
|
u8 *data;
|
|
|
|
int len, i;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (!ttusb->iso_streaming)
|
|
|
|
return;
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
printk("%s: status %d, errcount == %d, length == %i\n",
|
2008-04-09 02:20:00 +00:00
|
|
|
__func__,
|
2005-04-16 22:20:36 +00:00
|
|
|
urb->status, urb->error_count, urb->actual_length);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (!urb->status) {
|
|
|
|
for (i = 0; i < urb->number_of_packets; ++i) {
|
|
|
|
numpkt++;
|
2005-09-09 20:03:15 +00:00
|
|
|
if (time_after_eq(jiffies, lastj + HZ)) {
|
2011-03-24 15:56:16 +00:00
|
|
|
dprintk("frames/s: %lu (ts: %d, stuff %d, "
|
|
|
|
"sec: %d, invalid: %d, all: %d)\n",
|
|
|
|
numpkt * HZ / (jiffies - lastj),
|
|
|
|
numts, numstuff, numsec, numinvalid,
|
|
|
|
numts + numstuff + numsec + numinvalid);
|
2005-04-16 22:20:36 +00:00
|
|
|
numts = numstuff = numsec = numinvalid = 0;
|
|
|
|
lastj = jiffies;
|
|
|
|
numpkt = 0;
|
|
|
|
}
|
|
|
|
d = &urb->iso_frame_desc[i];
|
|
|
|
data = urb->transfer_buffer + d->offset;
|
|
|
|
len = d->actual_length;
|
|
|
|
d->actual_length = 0;
|
|
|
|
d->status = 0;
|
|
|
|
ttusb_process_frame(ttusb, data, len);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
usb_submit_urb(urb, GFP_ATOMIC);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ttusb_free_iso_urbs(struct ttusb *ttusb)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < ISO_BUF_COUNT; i++)
|
|
|
|
if (ttusb->iso_urb[i])
|
|
|
|
usb_free_urb(ttusb->iso_urb[i]);
|
|
|
|
|
|
|
|
pci_free_consistent(NULL,
|
|
|
|
ISO_FRAME_SIZE * FRAMES_PER_ISO_BUF *
|
|
|
|
ISO_BUF_COUNT, ttusb->iso_buffer,
|
|
|
|
ttusb->iso_dma_handle);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ttusb_alloc_iso_urbs(struct ttusb *ttusb)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
ttusb->iso_buffer = pci_alloc_consistent(NULL,
|
|
|
|
ISO_FRAME_SIZE *
|
|
|
|
FRAMES_PER_ISO_BUF *
|
|
|
|
ISO_BUF_COUNT,
|
|
|
|
&ttusb->iso_dma_handle);
|
|
|
|
|
2008-11-12 02:30:49 +00:00
|
|
|
if (!ttusb->iso_buffer) {
|
|
|
|
dprintk("%s: pci_alloc_consistent - not enough memory\n",
|
|
|
|
__func__);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
memset(ttusb->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_free_iso_urbs(ttusb);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
ttusb->iso_urb[i] = urb;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ttusb_stop_iso_xfer(struct ttusb *ttusb)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < ISO_BUF_COUNT; i++)
|
|
|
|
usb_kill_urb(ttusb->iso_urb[i]);
|
|
|
|
|
|
|
|
ttusb->iso_streaming = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ttusb_start_iso_xfer(struct ttusb *ttusb)
|
|
|
|
{
|
|
|
|
int i, j, err, buffer_offset = 0;
|
|
|
|
|
|
|
|
if (ttusb->iso_streaming) {
|
2008-04-09 02:20:00 +00:00
|
|
|
printk("%s: iso xfer already running!\n", __func__);
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
ttusb->cc = -1;
|
|
|
|
ttusb->insync = 0;
|
|
|
|
ttusb->mux_state = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < ISO_BUF_COUNT; i++) {
|
|
|
|
int frame_offset = 0;
|
|
|
|
struct urb *urb = ttusb->iso_urb[i];
|
|
|
|
|
|
|
|
urb->dev = ttusb->dev;
|
|
|
|
urb->context = ttusb;
|
|
|
|
urb->complete = ttusb_iso_irq;
|
|
|
|
urb->pipe = ttusb->isoc_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 = ttusb->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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < ISO_BUF_COUNT; i++) {
|
|
|
|
if ((err = usb_submit_urb(ttusb->iso_urb[i], GFP_ATOMIC))) {
|
|
|
|
ttusb_stop_iso_xfer(ttusb);
|
|
|
|
printk
|
|
|
|
("%s: failed urb submission (%i: err = %i)!\n",
|
2008-04-09 02:20:00 +00:00
|
|
|
__func__, i, err);
|
2005-04-16 22:20:36 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ttusb->iso_streaming = 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef TTUSB_HWSECTIONS
|
|
|
|
static void ttusb_handle_ts_data(struct dvb_demux_feed *dvbdmxfeed, const u8 * data,
|
|
|
|
int len)
|
|
|
|
{
|
|
|
|
dvbdmxfeed->cb.ts(data, len, 0, 0, &dvbdmxfeed->feed.ts, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ttusb_handle_sec_data(struct dvb_demux_feed *dvbdmxfeed, const u8 * data,
|
|
|
|
int len)
|
|
|
|
{
|
|
|
|
// struct dvb_demux_feed *dvbdmxfeed = channel->dvbdmxfeed;
|
|
|
|
#error TODO: handle ugly stuff
|
|
|
|
// dvbdmxfeed->cb.sec(data, len, 0, 0, &dvbdmxfeed->feed.sec, 0);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static int ttusb_start_feed(struct dvb_demux_feed *dvbdmxfeed)
|
|
|
|
{
|
|
|
|
struct ttusb *ttusb = (struct ttusb *) dvbdmxfeed->demux;
|
|
|
|
int feed_type = 1;
|
|
|
|
|
|
|
|
dprintk("ttusb_start_feed\n");
|
|
|
|
|
|
|
|
switch (dvbdmxfeed->type) {
|
|
|
|
case DMX_TYPE_TS:
|
|
|
|
break;
|
|
|
|
case DMX_TYPE_SEC:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dvbdmxfeed->type == DMX_TYPE_TS) {
|
|
|
|
switch (dvbdmxfeed->pes_type) {
|
2013-04-04 16:25:30 +00:00
|
|
|
case DMX_PES_VIDEO:
|
|
|
|
case DMX_PES_AUDIO:
|
|
|
|
case DMX_PES_TELETEXT:
|
|
|
|
case DMX_PES_PCR:
|
|
|
|
case DMX_PES_OTHER:
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef TTUSB_HWSECTIONS
|
|
|
|
#error TODO: allocate filters
|
|
|
|
if (dvbdmxfeed->type == DMX_TYPE_TS) {
|
|
|
|
feed_type = 1;
|
|
|
|
} else if (dvbdmxfeed->type == DMX_TYPE_SEC) {
|
|
|
|
feed_type = 2;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
ttusb_set_channel(ttusb, dvbdmxfeed->index, feed_type, dvbdmxfeed->pid);
|
|
|
|
|
|
|
|
if (0 == ttusb->running_feed_count++)
|
|
|
|
ttusb_start_iso_xfer(ttusb);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ttusb_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
|
|
|
|
{
|
|
|
|
struct ttusb *ttusb = (struct ttusb *) dvbdmxfeed->demux;
|
|
|
|
|
|
|
|
ttusb_del_channel(ttusb, dvbdmxfeed->index);
|
|
|
|
|
|
|
|
if (--ttusb->running_feed_count == 0)
|
|
|
|
ttusb_stop_iso_xfer(ttusb);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ttusb_setup_interfaces(struct ttusb *ttusb)
|
|
|
|
{
|
|
|
|
usb_set_interface(ttusb->dev, 1, 1);
|
|
|
|
|
|
|
|
ttusb->bulk_out_pipe = usb_sndbulkpipe(ttusb->dev, 1);
|
|
|
|
ttusb->bulk_in_pipe = usb_rcvbulkpipe(ttusb->dev, 1);
|
|
|
|
ttusb->isoc_in_pipe = usb_rcvisocpipe(ttusb->dev, 2);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
static u8 stc_firmware[8192];
|
|
|
|
|
|
|
|
static int stc_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
struct ttusb *ttusb = file->private_data;
|
|
|
|
int addr;
|
|
|
|
|
|
|
|
for (addr = 0; addr < 8192; addr += 16) {
|
|
|
|
u8 snd_buf[2] = { addr >> 8, addr & 0xFF };
|
|
|
|
ttusb_i2c_msg(ttusb, 0x50, snd_buf, 2, stc_firmware + addr,
|
|
|
|
16);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t stc_read(struct file *file, char *buf, size_t count,
|
2008-07-04 09:33:20 +00:00
|
|
|
loff_t *offset)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-07-04 09:33:20 +00:00
|
|
|
return simple_read_from_buffer(buf, count, offset, stc_firmware, 8192);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int stc_release(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-04-22 17:42:01 +00:00
|
|
|
static const struct file_operations stc_fops = {
|
2005-04-16 22:20:36 +00:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.read = stc_read,
|
|
|
|
.open = stc_open,
|
|
|
|
.release = stc_release,
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static u32 functionality(struct i2c_adapter *adapter)
|
|
|
|
{
|
|
|
|
return I2C_FUNC_I2C;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2011-12-24 15:24:33 +00:00
|
|
|
static int alps_tdmb7_tuner_set_params(struct dvb_frontend *fe)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2011-12-23 10:15:40 +00:00
|
|
|
struct dtv_frontend_properties *p = &fe->dtv_property_cache;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
|
|
|
|
u8 data[4];
|
|
|
|
struct i2c_msg msg = {.addr=0x61, .flags=0, .buf=data, .len=sizeof(data) };
|
|
|
|
u32 div;
|
|
|
|
|
2011-12-23 10:15:40 +00:00
|
|
|
div = (p->frequency + 36166667) / 166667;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
data[0] = (div >> 8) & 0x7f;
|
|
|
|
data[1] = div & 0xff;
|
|
|
|
data[2] = ((div >> 10) & 0x60) | 0x85;
|
2011-12-23 10:15:40 +00:00
|
|
|
data[3] = p->frequency < 592000000 ? 0x40 : 0x80;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-05-14 08:01:31 +00:00
|
|
|
if (fe->ops.i2c_gate_ctrl)
|
|
|
|
fe->ops.i2c_gate_ctrl(fe, 1);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (i2c_transfer(&ttusb->i2c_adap, &msg, 1) != 1) return -EIO;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-05-17 04:54:38 +00:00
|
|
|
static struct cx22700_config alps_tdmb7_config = {
|
2005-04-16 22:20:36 +00:00
|
|
|
.demod_address = 0x43,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2006-04-18 20:47:11 +00:00
|
|
|
static int philips_tdm1316l_tuner_init(struct dvb_frontend* fe)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
|
|
|
|
static u8 td1316_init[] = { 0x0b, 0xf5, 0x85, 0xab };
|
|
|
|
static u8 disable_mc44BC374c[] = { 0x1d, 0x74, 0xa0, 0x68 };
|
|
|
|
struct i2c_msg tuner_msg = { .addr=0x60, .flags=0, .buf=td1316_init, .len=sizeof(td1316_init) };
|
|
|
|
|
|
|
|
// setup PLL configuration
|
2006-05-14 08:01:31 +00:00
|
|
|
if (fe->ops.i2c_gate_ctrl)
|
|
|
|
fe->ops.i2c_gate_ctrl(fe, 1);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1) return -EIO;
|
|
|
|
msleep(1);
|
|
|
|
|
|
|
|
// disable the mc44BC374c (do not check for errors)
|
|
|
|
tuner_msg.addr = 0x65;
|
|
|
|
tuner_msg.buf = disable_mc44BC374c;
|
|
|
|
tuner_msg.len = sizeof(disable_mc44BC374c);
|
2006-05-14 08:01:31 +00:00
|
|
|
if (fe->ops.i2c_gate_ctrl)
|
|
|
|
fe->ops.i2c_gate_ctrl(fe, 1);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1) {
|
|
|
|
i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-12-24 15:24:33 +00:00
|
|
|
static int philips_tdm1316l_tuner_set_params(struct dvb_frontend *fe)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2011-12-23 10:15:40 +00:00
|
|
|
struct dtv_frontend_properties *p = &fe->dtv_property_cache;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
|
|
|
|
u8 tuner_buf[4];
|
|
|
|
struct i2c_msg tuner_msg = {.addr=0x60, .flags=0, .buf=tuner_buf, .len=sizeof(tuner_buf) };
|
|
|
|
int tuner_frequency = 0;
|
|
|
|
u8 band, cp, filter;
|
|
|
|
|
|
|
|
// determine charge pump
|
2011-12-23 10:15:40 +00:00
|
|
|
tuner_frequency = p->frequency + 36130000;
|
2005-04-16 22:20:36 +00:00
|
|
|
if (tuner_frequency < 87000000) return -EINVAL;
|
|
|
|
else if (tuner_frequency < 130000000) cp = 3;
|
|
|
|
else if (tuner_frequency < 160000000) cp = 5;
|
|
|
|
else if (tuner_frequency < 200000000) cp = 6;
|
|
|
|
else if (tuner_frequency < 290000000) cp = 3;
|
|
|
|
else if (tuner_frequency < 420000000) cp = 5;
|
|
|
|
else if (tuner_frequency < 480000000) cp = 6;
|
|
|
|
else if (tuner_frequency < 620000000) cp = 3;
|
|
|
|
else if (tuner_frequency < 830000000) cp = 5;
|
|
|
|
else if (tuner_frequency < 895000000) cp = 7;
|
|
|
|
else return -EINVAL;
|
|
|
|
|
|
|
|
// determine band
|
2011-12-23 10:15:40 +00:00
|
|
|
if (p->frequency < 49000000)
|
|
|
|
return -EINVAL;
|
|
|
|
else if (p->frequency < 159000000)
|
|
|
|
band = 1;
|
|
|
|
else if (p->frequency < 444000000)
|
|
|
|
band = 2;
|
|
|
|
else if (p->frequency < 861000000)
|
|
|
|
band = 4;
|
2005-04-16 22:20:36 +00:00
|
|
|
else return -EINVAL;
|
|
|
|
|
|
|
|
// setup PLL filter
|
2011-12-23 10:15:40 +00:00
|
|
|
switch (p->bandwidth_hz) {
|
|
|
|
case 6000000:
|
2006-08-08 12:10:08 +00:00
|
|
|
tda1004x_writereg(fe, 0x0C, 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
filter = 0;
|
|
|
|
break;
|
|
|
|
|
2011-12-23 10:15:40 +00:00
|
|
|
case 7000000:
|
2006-08-08 12:10:08 +00:00
|
|
|
tda1004x_writereg(fe, 0x0C, 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
filter = 0;
|
|
|
|
break;
|
|
|
|
|
2011-12-23 10:15:40 +00:00
|
|
|
case 8000000:
|
2006-08-08 12:10:08 +00:00
|
|
|
tda1004x_writereg(fe, 0x0C, 0xFF);
|
2005-04-16 22:20:36 +00:00
|
|
|
filter = 1;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
// calculate divisor
|
|
|
|
// ((36130000+((1000000/6)/2)) + Finput)/(1000000/6)
|
2011-12-23 10:15:40 +00:00
|
|
|
tuner_frequency = (((p->frequency / 1000) * 6) + 217280) / 1000;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
// setup tuner buffer
|
|
|
|
tuner_buf[0] = tuner_frequency >> 8;
|
|
|
|
tuner_buf[1] = tuner_frequency & 0xff;
|
|
|
|
tuner_buf[2] = 0xca;
|
|
|
|
tuner_buf[3] = (cp << 5) | (filter << 3) | band;
|
|
|
|
|
2006-05-14 08:01:31 +00:00
|
|
|
if (fe->ops.i2c_gate_ctrl)
|
|
|
|
fe->ops.i2c_gate_ctrl(fe, 1);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1)
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
msleep(1);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int philips_tdm1316l_request_firmware(struct dvb_frontend* fe, const struct firmware **fw, char* name)
|
|
|
|
{
|
|
|
|
struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
|
|
|
|
|
|
|
|
return request_firmware(fw, name, &ttusb->dev->dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct tda1004x_config philips_tdm1316l_config = {
|
|
|
|
|
|
|
|
.demod_address = 0x8,
|
|
|
|
.invert = 1,
|
|
|
|
.invert_oclk = 0,
|
|
|
|
.request_firmware = philips_tdm1316l_request_firmware,
|
|
|
|
};
|
|
|
|
|
|
|
|
static u8 alps_bsbe1_inittab[] = {
|
2005-12-12 08:37:24 +00:00
|
|
|
0x01, 0x15,
|
|
|
|
0x02, 0x30,
|
|
|
|
0x03, 0x00,
|
|
|
|
0x04, 0x7d, /* F22FR = 0x7d, F22 = f_VCO / 128 / 0x7d = 22 kHz */
|
|
|
|
0x05, 0x35, /* I2CT = 0, SCLT = 1, SDAT = 1 */
|
|
|
|
0x06, 0x40, /* DAC not used, set to high impendance mode */
|
|
|
|
0x07, 0x00, /* DAC LSB */
|
|
|
|
0x08, 0x40, /* DiSEqC off, LNB power on OP2/LOCK pin on */
|
|
|
|
0x09, 0x00, /* FIFO */
|
|
|
|
0x0c, 0x51, /* OP1 ctl = Normal, OP1 val = 1 (LNB Power ON) */
|
|
|
|
0x0d, 0x82, /* DC offset compensation = ON, beta_agc1 = 2 */
|
|
|
|
0x0e, 0x23, /* alpha_tmg = 2, beta_tmg = 3 */
|
|
|
|
0x10, 0x3f, // AGC2 0x3d
|
|
|
|
0x11, 0x84,
|
|
|
|
0x12, 0xb9,
|
|
|
|
0x15, 0xc9, // lock detector threshold
|
|
|
|
0x16, 0x00,
|
|
|
|
0x17, 0x00,
|
|
|
|
0x18, 0x00,
|
|
|
|
0x19, 0x00,
|
|
|
|
0x1a, 0x00,
|
|
|
|
0x1f, 0x50,
|
|
|
|
0x20, 0x00,
|
|
|
|
0x21, 0x00,
|
|
|
|
0x22, 0x00,
|
|
|
|
0x23, 0x00,
|
|
|
|
0x28, 0x00, // out imp: normal out type: parallel FEC mode:0
|
|
|
|
0x29, 0x1e, // 1/2 threshold
|
|
|
|
0x2a, 0x14, // 2/3 threshold
|
|
|
|
0x2b, 0x0f, // 3/4 threshold
|
|
|
|
0x2c, 0x09, // 5/6 threshold
|
|
|
|
0x2d, 0x05, // 7/8 threshold
|
|
|
|
0x2e, 0x01,
|
|
|
|
0x31, 0x1f, // test all FECs
|
|
|
|
0x32, 0x19, // viterbi and synchro search
|
|
|
|
0x33, 0xfc, // rs control
|
|
|
|
0x34, 0x93, // error control
|
|
|
|
0x0f, 0x92,
|
|
|
|
0xff, 0xff
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static u8 alps_bsru6_inittab[] = {
|
|
|
|
0x01, 0x15,
|
|
|
|
0x02, 0x30,
|
|
|
|
0x03, 0x00,
|
|
|
|
0x04, 0x7d, /* F22FR = 0x7d, F22 = f_VCO / 128 / 0x7d = 22 kHz */
|
|
|
|
0x05, 0x35, /* I2CT = 0, SCLT = 1, SDAT = 1 */
|
|
|
|
0x06, 0x40, /* DAC not used, set to high impendance mode */
|
|
|
|
0x07, 0x00, /* DAC LSB */
|
|
|
|
0x08, 0x40, /* DiSEqC off, LNB power on OP2/LOCK pin on */
|
|
|
|
0x09, 0x00, /* FIFO */
|
|
|
|
0x0c, 0x51, /* OP1 ctl = Normal, OP1 val = 1 (LNB Power ON) */
|
|
|
|
0x0d, 0x82, /* DC offset compensation = ON, beta_agc1 = 2 */
|
|
|
|
0x0e, 0x23, /* alpha_tmg = 2, beta_tmg = 3 */
|
|
|
|
0x10, 0x3f, // AGC2 0x3d
|
|
|
|
0x11, 0x84,
|
2005-11-09 05:35:44 +00:00
|
|
|
0x12, 0xb9,
|
2005-04-16 22:20:36 +00:00
|
|
|
0x15, 0xc9, // lock detector threshold
|
|
|
|
0x16, 0x00,
|
|
|
|
0x17, 0x00,
|
|
|
|
0x18, 0x00,
|
|
|
|
0x19, 0x00,
|
|
|
|
0x1a, 0x00,
|
|
|
|
0x1f, 0x50,
|
|
|
|
0x20, 0x00,
|
|
|
|
0x21, 0x00,
|
|
|
|
0x22, 0x00,
|
|
|
|
0x23, 0x00,
|
|
|
|
0x28, 0x00, // out imp: normal out type: parallel FEC mode:0
|
|
|
|
0x29, 0x1e, // 1/2 threshold
|
|
|
|
0x2a, 0x14, // 2/3 threshold
|
|
|
|
0x2b, 0x0f, // 3/4 threshold
|
|
|
|
0x2c, 0x09, // 5/6 threshold
|
|
|
|
0x2d, 0x05, // 7/8 threshold
|
|
|
|
0x2e, 0x01,
|
|
|
|
0x31, 0x1f, // test all FECs
|
|
|
|
0x32, 0x19, // viterbi and synchro search
|
|
|
|
0x33, 0xfc, // rs control
|
|
|
|
0x34, 0x93, // error control
|
|
|
|
0x0f, 0x52,
|
|
|
|
0xff, 0xff
|
|
|
|
};
|
|
|
|
|
|
|
|
static int alps_stv0299_set_symbol_rate(struct dvb_frontend *fe, u32 srate, u32 ratio)
|
|
|
|
{
|
|
|
|
u8 aclk = 0;
|
|
|
|
u8 bclk = 0;
|
|
|
|
|
|
|
|
if (srate < 1500000) {
|
|
|
|
aclk = 0xb7;
|
|
|
|
bclk = 0x47;
|
|
|
|
} else if (srate < 3000000) {
|
|
|
|
aclk = 0xb7;
|
|
|
|
bclk = 0x4b;
|
|
|
|
} else if (srate < 7000000) {
|
|
|
|
aclk = 0xb7;
|
|
|
|
bclk = 0x4f;
|
|
|
|
} else if (srate < 14000000) {
|
|
|
|
aclk = 0xb7;
|
|
|
|
bclk = 0x53;
|
|
|
|
} else if (srate < 30000000) {
|
|
|
|
aclk = 0xb6;
|
|
|
|
bclk = 0x53;
|
|
|
|
} else if (srate < 45000000) {
|
|
|
|
aclk = 0xb4;
|
|
|
|
bclk = 0x51;
|
|
|
|
}
|
|
|
|
|
|
|
|
stv0299_writereg(fe, 0x13, aclk);
|
|
|
|
stv0299_writereg(fe, 0x14, bclk);
|
|
|
|
stv0299_writereg(fe, 0x1f, (ratio >> 16) & 0xff);
|
|
|
|
stv0299_writereg(fe, 0x20, (ratio >> 8) & 0xff);
|
|
|
|
stv0299_writereg(fe, 0x21, (ratio) & 0xf0);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-12-24 15:24:33 +00:00
|
|
|
static int philips_tsa5059_tuner_set_params(struct dvb_frontend *fe)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2011-12-23 10:15:40 +00:00
|
|
|
struct dtv_frontend_properties *p = &fe->dtv_property_cache;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
|
|
|
|
u8 buf[4];
|
|
|
|
u32 div;
|
|
|
|
struct i2c_msg msg = {.addr = 0x61,.flags = 0,.buf = buf,.len = sizeof(buf) };
|
|
|
|
|
2011-12-23 10:15:40 +00:00
|
|
|
if ((p->frequency < 950000) || (p->frequency > 2150000))
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
2011-12-23 10:15:40 +00:00
|
|
|
div = (p->frequency + (125 - 1)) / 125; /* round correctly */
|
2005-04-16 22:20:36 +00:00
|
|
|
buf[0] = (div >> 8) & 0x7f;
|
|
|
|
buf[1] = div & 0xff;
|
|
|
|
buf[2] = 0x80 | ((div & 0x18000) >> 10) | 4;
|
|
|
|
buf[3] = 0xC4;
|
|
|
|
|
2011-12-23 10:15:40 +00:00
|
|
|
if (p->frequency > 1530000)
|
2005-04-16 22:20:36 +00:00
|
|
|
buf[3] = 0xC0;
|
|
|
|
|
|
|
|
/* BSBE1 wants XCE bit set */
|
|
|
|
if (ttusb->revision == TTUSB_REV_2_2)
|
|
|
|
buf[3] |= 0x20;
|
|
|
|
|
2006-05-14 08:01:31 +00:00
|
|
|
if (fe->ops.i2c_gate_ctrl)
|
|
|
|
fe->ops.i2c_gate_ctrl(fe, 1);
|
2006-04-18 20:47:11 +00:00
|
|
|
if (i2c_transfer(&ttusb->i2c_adap, &msg, 1) != 1)
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct stv0299_config alps_stv0299_config = {
|
|
|
|
.demod_address = 0x68,
|
|
|
|
.inittab = alps_bsru6_inittab,
|
|
|
|
.mclk = 88000000UL,
|
|
|
|
.invert = 1,
|
|
|
|
.skip_reinit = 0,
|
2008-04-21 01:13:37 +00:00
|
|
|
.lock_output = STV0299_LOCKOUTPUT_1,
|
2005-04-16 22:20:36 +00:00
|
|
|
.volt13_op0_op1 = STV0299_VOLT13_OP1,
|
|
|
|
.min_delay_ms = 100,
|
|
|
|
.set_symbol_rate = alps_stv0299_set_symbol_rate,
|
|
|
|
};
|
|
|
|
|
2011-12-24 15:24:33 +00:00
|
|
|
static int ttusb_novas_grundig_29504_491_tuner_set_params(struct dvb_frontend *fe)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2011-12-23 10:15:40 +00:00
|
|
|
struct dtv_frontend_properties *p = &fe->dtv_property_cache;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct ttusb* ttusb = (struct ttusb*) fe->dvb->priv;
|
|
|
|
u8 buf[4];
|
|
|
|
u32 div;
|
|
|
|
struct i2c_msg msg = {.addr = 0x61,.flags = 0,.buf = buf,.len = sizeof(buf) };
|
|
|
|
|
2011-12-23 10:15:40 +00:00
|
|
|
div = p->frequency / 125;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
buf[0] = (div >> 8) & 0x7f;
|
|
|
|
buf[1] = div & 0xff;
|
|
|
|
buf[2] = 0x8e;
|
|
|
|
buf[3] = 0x00;
|
|
|
|
|
2006-05-14 08:01:31 +00:00
|
|
|
if (fe->ops.i2c_gate_ctrl)
|
|
|
|
fe->ops.i2c_gate_ctrl(fe, 1);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (i2c_transfer(&ttusb->i2c_adap, &msg, 1) != 1)
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct tda8083_config ttusb_novas_grundig_29504_491_config = {
|
|
|
|
|
|
|
|
.demod_address = 0x68,
|
|
|
|
};
|
|
|
|
|
2011-12-24 15:24:33 +00:00
|
|
|
static int alps_tdbe2_tuner_set_params(struct dvb_frontend *fe)
|
2005-07-08 00:58:04 +00:00
|
|
|
{
|
2011-12-23 10:15:40 +00:00
|
|
|
struct dtv_frontend_properties *p = &fe->dtv_property_cache;
|
2005-07-08 00:58:04 +00:00
|
|
|
struct ttusb* ttusb = fe->dvb->priv;
|
|
|
|
u32 div;
|
|
|
|
u8 data[4];
|
|
|
|
struct i2c_msg msg = { .addr = 0x62, .flags = 0, .buf = data, .len = sizeof(data) };
|
|
|
|
|
2011-12-23 10:15:40 +00:00
|
|
|
div = (p->frequency + 35937500 + 31250) / 62500;
|
2005-07-08 00:58:04 +00:00
|
|
|
|
|
|
|
data[0] = (div >> 8) & 0x7f;
|
|
|
|
data[1] = div & 0xff;
|
|
|
|
data[2] = 0x85 | ((div >> 10) & 0x60);
|
2011-12-23 10:15:40 +00:00
|
|
|
data[3] = (p->frequency < 174000000 ? 0x88 : p->frequency < 470000000 ? 0x84 : 0x81);
|
2005-07-08 00:58:04 +00:00
|
|
|
|
2006-05-14 08:01:31 +00:00
|
|
|
if (fe->ops.i2c_gate_ctrl)
|
|
|
|
fe->ops.i2c_gate_ctrl(fe, 1);
|
2005-07-08 00:58:04 +00:00
|
|
|
if (i2c_transfer (&ttusb->i2c_adap, &msg, 1) != 1)
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static struct ves1820_config alps_tdbe2_config = {
|
|
|
|
.demod_address = 0x09,
|
|
|
|
.xin = 57840000UL,
|
|
|
|
.invert = 1,
|
|
|
|
.selagc = VES1820_SELAGC_SIGNAMPERR,
|
|
|
|
};
|
|
|
|
|
|
|
|
static u8 read_pwm(struct ttusb* ttusb)
|
|
|
|
{
|
|
|
|
u8 b = 0xff;
|
|
|
|
u8 pwm;
|
|
|
|
struct i2c_msg msg[] = { { .addr = 0x50,.flags = 0,.buf = &b,.len = 1 },
|
|
|
|
{ .addr = 0x50,.flags = I2C_M_RD,.buf = &pwm,.len = 1} };
|
|
|
|
|
|
|
|
if ((i2c_transfer(&ttusb->i2c_adap, msg, 2) != 2) || (pwm == 0xff))
|
|
|
|
pwm = 0x48;
|
|
|
|
|
|
|
|
return pwm;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
2011-12-24 15:24:33 +00:00
|
|
|
static int dvbc_philips_tdm1316l_tuner_set_params(struct dvb_frontend *fe)
|
2006-04-28 00:45:20 +00:00
|
|
|
{
|
2011-12-23 10:15:40 +00:00
|
|
|
struct dtv_frontend_properties *p = &fe->dtv_property_cache;
|
2006-04-28 00:45:20 +00:00
|
|
|
struct ttusb *ttusb = (struct ttusb *) fe->dvb->priv;
|
|
|
|
u8 tuner_buf[5];
|
|
|
|
struct i2c_msg tuner_msg = {.addr = 0x60,
|
|
|
|
.flags = 0,
|
|
|
|
.buf = tuner_buf,
|
|
|
|
.len = sizeof(tuner_buf) };
|
|
|
|
int tuner_frequency = 0;
|
|
|
|
u8 band, cp, filter;
|
|
|
|
|
|
|
|
// determine charge pump
|
2011-12-23 10:15:40 +00:00
|
|
|
tuner_frequency = p->frequency;
|
2006-04-28 00:45:20 +00:00
|
|
|
if (tuner_frequency < 87000000) {return -EINVAL;}
|
|
|
|
else if (tuner_frequency < 130000000) {cp = 3; band = 1;}
|
|
|
|
else if (tuner_frequency < 160000000) {cp = 5; band = 1;}
|
|
|
|
else if (tuner_frequency < 200000000) {cp = 6; band = 1;}
|
|
|
|
else if (tuner_frequency < 290000000) {cp = 3; band = 2;}
|
|
|
|
else if (tuner_frequency < 420000000) {cp = 5; band = 2;}
|
|
|
|
else if (tuner_frequency < 480000000) {cp = 6; band = 2;}
|
|
|
|
else if (tuner_frequency < 620000000) {cp = 3; band = 4;}
|
|
|
|
else if (tuner_frequency < 830000000) {cp = 5; band = 4;}
|
|
|
|
else if (tuner_frequency < 895000000) {cp = 7; band = 4;}
|
|
|
|
else {return -EINVAL;}
|
|
|
|
|
|
|
|
// assume PLL filter should always be 8MHz for the moment.
|
|
|
|
filter = 1;
|
|
|
|
|
|
|
|
// calculate divisor
|
|
|
|
// (Finput + Fif)/Fref; Fif = 36125000 Hz, Fref = 62500 Hz
|
2011-12-23 10:15:40 +00:00
|
|
|
tuner_frequency = ((p->frequency + 36125000) / 62500);
|
2006-04-28 00:45:20 +00:00
|
|
|
|
|
|
|
// setup tuner buffer
|
|
|
|
tuner_buf[0] = tuner_frequency >> 8;
|
|
|
|
tuner_buf[1] = tuner_frequency & 0xff;
|
|
|
|
tuner_buf[2] = 0xc8;
|
|
|
|
tuner_buf[3] = (cp << 5) | (filter << 3) | band;
|
|
|
|
tuner_buf[4] = 0x80;
|
|
|
|
|
2006-05-14 08:01:31 +00:00
|
|
|
if (fe->ops.i2c_gate_ctrl)
|
|
|
|
fe->ops.i2c_gate_ctrl(fe, 1);
|
2006-04-28 00:45:20 +00:00
|
|
|
if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1) {
|
|
|
|
printk("dvb-ttusb-budget: dvbc_philips_tdm1316l_pll_set Error 1\n");
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
msleep(50);
|
|
|
|
|
2006-05-14 08:01:31 +00:00
|
|
|
if (fe->ops.i2c_gate_ctrl)
|
|
|
|
fe->ops.i2c_gate_ctrl(fe, 1);
|
2006-04-28 00:45:20 +00:00
|
|
|
if (i2c_transfer(&ttusb->i2c_adap, &tuner_msg, 1) != 1) {
|
|
|
|
printk("dvb-ttusb-budget: dvbc_philips_tdm1316l_pll_set Error 2\n");
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
msleep(1);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static u8 dvbc_philips_tdm1316l_inittab[] = {
|
|
|
|
0x80, 0x21,
|
|
|
|
0x80, 0x20,
|
|
|
|
0x81, 0x01,
|
|
|
|
0x81, 0x00,
|
|
|
|
0x00, 0x09,
|
|
|
|
0x01, 0x69,
|
|
|
|
0x03, 0x00,
|
|
|
|
0x04, 0x00,
|
|
|
|
0x07, 0x00,
|
|
|
|
0x08, 0x00,
|
|
|
|
0x20, 0x00,
|
|
|
|
0x21, 0x40,
|
|
|
|
0x22, 0x00,
|
|
|
|
0x23, 0x00,
|
|
|
|
0x24, 0x40,
|
|
|
|
0x25, 0x88,
|
|
|
|
0x30, 0xff,
|
|
|
|
0x31, 0x00,
|
|
|
|
0x32, 0xff,
|
|
|
|
0x33, 0x00,
|
|
|
|
0x34, 0x50,
|
|
|
|
0x35, 0x7f,
|
|
|
|
0x36, 0x00,
|
|
|
|
0x37, 0x20,
|
|
|
|
0x38, 0x00,
|
|
|
|
0x40, 0x1c,
|
|
|
|
0x41, 0xff,
|
|
|
|
0x42, 0x29,
|
|
|
|
0x43, 0x20,
|
|
|
|
0x44, 0xff,
|
|
|
|
0x45, 0x00,
|
|
|
|
0x46, 0x00,
|
|
|
|
0x49, 0x04,
|
|
|
|
0x4a, 0xff,
|
|
|
|
0x4b, 0x7f,
|
|
|
|
0x52, 0x30,
|
|
|
|
0x55, 0xae,
|
|
|
|
0x56, 0x47,
|
|
|
|
0x57, 0xe1,
|
|
|
|
0x58, 0x3a,
|
|
|
|
0x5a, 0x1e,
|
|
|
|
0x5b, 0x34,
|
|
|
|
0x60, 0x00,
|
|
|
|
0x63, 0x00,
|
|
|
|
0x64, 0x00,
|
|
|
|
0x65, 0x00,
|
|
|
|
0x66, 0x00,
|
|
|
|
0x67, 0x00,
|
|
|
|
0x68, 0x00,
|
|
|
|
0x69, 0x00,
|
|
|
|
0x6a, 0x02,
|
|
|
|
0x6b, 0x00,
|
|
|
|
0x70, 0xff,
|
|
|
|
0x71, 0x00,
|
|
|
|
0x72, 0x00,
|
|
|
|
0x73, 0x00,
|
|
|
|
0x74, 0x0c,
|
|
|
|
0x80, 0x00,
|
|
|
|
0x81, 0x00,
|
|
|
|
0x82, 0x00,
|
|
|
|
0x83, 0x00,
|
|
|
|
0x84, 0x04,
|
|
|
|
0x85, 0x80,
|
|
|
|
0x86, 0x24,
|
|
|
|
0x87, 0x78,
|
|
|
|
0x88, 0x00,
|
|
|
|
0x89, 0x00,
|
|
|
|
0x90, 0x01,
|
|
|
|
0x91, 0x01,
|
|
|
|
0xa0, 0x00,
|
|
|
|
0xa1, 0x00,
|
|
|
|
0xa2, 0x00,
|
|
|
|
0xb0, 0x91,
|
|
|
|
0xb1, 0x0b,
|
|
|
|
0xc0, 0x4b,
|
|
|
|
0xc1, 0x00,
|
|
|
|
0xc2, 0x00,
|
|
|
|
0xd0, 0x00,
|
|
|
|
0xd1, 0x00,
|
|
|
|
0xd2, 0x00,
|
|
|
|
0xd3, 0x00,
|
|
|
|
0xd4, 0x00,
|
|
|
|
0xd5, 0x00,
|
|
|
|
0xde, 0x00,
|
|
|
|
0xdf, 0x00,
|
|
|
|
0x61, 0x38,
|
|
|
|
0x62, 0x0a,
|
|
|
|
0x53, 0x13,
|
|
|
|
0x59, 0x08,
|
|
|
|
0x55, 0x00,
|
|
|
|
0x56, 0x40,
|
|
|
|
0x57, 0x08,
|
|
|
|
0x58, 0x3d,
|
|
|
|
0x88, 0x10,
|
|
|
|
0xa0, 0x00,
|
|
|
|
0xa0, 0x00,
|
|
|
|
0xa0, 0x00,
|
|
|
|
0xa0, 0x04,
|
|
|
|
0xff, 0xff,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct stv0297_config dvbc_philips_tdm1316l_config = {
|
|
|
|
.demod_address = 0x1c,
|
|
|
|
.inittab = dvbc_philips_tdm1316l_inittab,
|
|
|
|
.invert = 0,
|
|
|
|
};
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static void frontend_init(struct ttusb* ttusb)
|
|
|
|
{
|
|
|
|
switch(le16_to_cpu(ttusb->dev->descriptor.idProduct)) {
|
|
|
|
case 0x1003: // Hauppauge/TT Nova-USB-S budget (stv0299/ALPS BSRU6|BSBE1(tsa5059))
|
|
|
|
// try the stv0299 based first
|
2006-08-08 12:10:08 +00:00
|
|
|
ttusb->fe = dvb_attach(stv0299_attach, &alps_stv0299_config, &ttusb->i2c_adap);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (ttusb->fe != NULL) {
|
2006-05-14 08:01:31 +00:00
|
|
|
ttusb->fe->ops.tuner_ops.set_params = philips_tsa5059_tuner_set_params;
|
2006-04-18 20:47:11 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if(ttusb->revision == TTUSB_REV_2_2) { // ALPS BSBE1
|
|
|
|
alps_stv0299_config.inittab = alps_bsbe1_inittab;
|
2006-08-08 12:10:08 +00:00
|
|
|
dvb_attach(lnbp21_attach, ttusb->fe, &ttusb->i2c_adap, 0, 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
} else { // ALPS BSRU6
|
2006-05-14 08:01:31 +00:00
|
|
|
ttusb->fe->ops.set_voltage = ttusb_set_voltage;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Grundig 29504-491
|
2006-08-08 12:10:08 +00:00
|
|
|
ttusb->fe = dvb_attach(tda8083_attach, &ttusb_novas_grundig_29504_491_config, &ttusb->i2c_adap);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (ttusb->fe != NULL) {
|
2006-05-14 08:01:31 +00:00
|
|
|
ttusb->fe->ops.tuner_ops.set_params = ttusb_novas_grundig_29504_491_tuner_set_params;
|
|
|
|
ttusb->fe->ops.set_voltage = ttusb_set_voltage;
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2005-07-08 00:58:04 +00:00
|
|
|
case 0x1004: // Hauppauge/TT DVB-C budget (ves1820/ALPS TDBE2(sp5659))
|
2006-08-08 12:10:08 +00:00
|
|
|
ttusb->fe = dvb_attach(ves1820_attach, &alps_tdbe2_config, &ttusb->i2c_adap, read_pwm(ttusb));
|
2006-04-18 20:47:11 +00:00
|
|
|
if (ttusb->fe != NULL) {
|
2006-05-14 08:01:31 +00:00
|
|
|
ttusb->fe->ops.tuner_ops.set_params = alps_tdbe2_tuner_set_params;
|
2005-07-08 00:58:04 +00:00
|
|
|
break;
|
2006-04-18 20:47:11 +00:00
|
|
|
}
|
2006-04-28 00:45:20 +00:00
|
|
|
|
2006-08-08 12:10:08 +00:00
|
|
|
ttusb->fe = dvb_attach(stv0297_attach, &dvbc_philips_tdm1316l_config, &ttusb->i2c_adap);
|
2006-04-28 00:45:20 +00:00
|
|
|
if (ttusb->fe != NULL) {
|
2006-05-14 08:01:31 +00:00
|
|
|
ttusb->fe->ops.tuner_ops.set_params = dvbc_philips_tdm1316l_tuner_set_params;
|
2006-04-28 00:45:20 +00:00
|
|
|
break;
|
|
|
|
}
|
2005-07-08 00:58:04 +00:00
|
|
|
break;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
case 0x1005: // Hauppauge/TT Nova-USB-t budget (tda10046/Philips td1316(tda6651tt) OR cx22700/ALPS TDMB7(??))
|
|
|
|
// try the ALPS TDMB7 first
|
2006-08-08 12:10:08 +00:00
|
|
|
ttusb->fe = dvb_attach(cx22700_attach, &alps_tdmb7_config, &ttusb->i2c_adap);
|
2006-04-18 20:47:11 +00:00
|
|
|
if (ttusb->fe != NULL) {
|
2006-05-14 08:01:31 +00:00
|
|
|
ttusb->fe->ops.tuner_ops.set_params = alps_tdmb7_tuner_set_params;
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
2006-04-18 20:47:11 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
// Philips td1316
|
2006-08-08 12:10:08 +00:00
|
|
|
ttusb->fe = dvb_attach(tda10046_attach, &philips_tdm1316l_config, &ttusb->i2c_adap);
|
2006-04-18 20:47:11 +00:00
|
|
|
if (ttusb->fe != NULL) {
|
2006-05-14 08:01:31 +00:00
|
|
|
ttusb->fe->ops.tuner_ops.init = philips_tdm1316l_tuner_init;
|
|
|
|
ttusb->fe->ops.tuner_ops.set_params = philips_tdm1316l_tuner_set_params;
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
2006-04-18 20:47:11 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ttusb->fe == NULL) {
|
2008-09-04 20:24:51 +00:00
|
|
|
printk("dvb-ttusb-budget: A frontend driver was not found for device [%04x:%04x]\n",
|
2005-04-16 22:20:36 +00:00
|
|
|
le16_to_cpu(ttusb->dev->descriptor.idVendor),
|
|
|
|
le16_to_cpu(ttusb->dev->descriptor.idProduct));
|
|
|
|
} else {
|
2005-05-17 04:54:39 +00:00
|
|
|
if (dvb_register_frontend(&ttusb->adapter, ttusb->fe)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
printk("dvb-ttusb-budget: Frontend registration failed!\n");
|
2006-08-08 12:10:09 +00:00
|
|
|
dvb_frontend_detach(ttusb->fe);
|
2005-04-16 22:20:36 +00:00
|
|
|
ttusb->fe = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static struct i2c_algorithm ttusb_dec_algo = {
|
|
|
|
.master_xfer = master_xfer,
|
|
|
|
.functionality = functionality,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int ttusb_probe(struct usb_interface *intf, const struct usb_device_id *id)
|
|
|
|
{
|
|
|
|
struct usb_device *udev;
|
|
|
|
struct ttusb *ttusb;
|
|
|
|
int result;
|
|
|
|
|
2008-04-09 02:20:00 +00:00
|
|
|
dprintk("%s: TTUSB DVB connected\n", __func__);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
udev = interface_to_usbdev(intf);
|
|
|
|
|
2005-12-12 08:37:24 +00:00
|
|
|
if (intf->altsetting->desc.bInterfaceNumber != 1) return -ENODEV;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-01-11 21:40:56 +00:00
|
|
|
if (!(ttusb = kzalloc(sizeof(struct ttusb), GFP_KERNEL)))
|
2005-04-16 22:20:36 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
ttusb->dev = udev;
|
|
|
|
ttusb->c = 0;
|
|
|
|
ttusb->mux_state = 0;
|
2006-02-07 08:49:14 +00:00
|
|
|
mutex_init(&ttusb->semi2c);
|
|
|
|
|
|
|
|
mutex_lock(&ttusb->semi2c);
|
|
|
|
|
|
|
|
mutex_init(&ttusb->semusb);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
ttusb_setup_interfaces(ttusb);
|
|
|
|
|
2008-11-12 02:37:39 +00:00
|
|
|
result = ttusb_alloc_iso_urbs(ttusb);
|
|
|
|
if (result < 0) {
|
|
|
|
dprintk("%s: ttusb_alloc_iso_urbs - failed\n", __func__);
|
|
|
|
mutex_unlock(&ttusb->semi2c);
|
|
|
|
kfree(ttusb);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (ttusb_init_controller(ttusb))
|
|
|
|
printk("ttusb_init_controller: error\n");
|
|
|
|
|
2006-02-07 08:49:14 +00:00
|
|
|
mutex_unlock(&ttusb->semi2c);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-04-09 22:13:13 +00:00
|
|
|
result = dvb_register_adapter(&ttusb->adapter,
|
|
|
|
"Technotrend/Hauppauge Nova-USB",
|
|
|
|
THIS_MODULE, &udev->dev, adapter_nr);
|
|
|
|
if (result < 0) {
|
2006-04-06 20:05:46 +00:00
|
|
|
ttusb_free_iso_urbs(ttusb);
|
|
|
|
kfree(ttusb);
|
|
|
|
return result;
|
|
|
|
}
|
2005-05-17 04:54:39 +00:00
|
|
|
ttusb->adapter.priv = ttusb;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* i2c */
|
|
|
|
memset(&ttusb->i2c_adap, 0, sizeof(struct i2c_adapter));
|
|
|
|
strcpy(ttusb->i2c_adap.name, "TTUSB DEC");
|
|
|
|
|
|
|
|
i2c_set_adapdata(&ttusb->i2c_adap, ttusb);
|
|
|
|
|
|
|
|
ttusb->i2c_adap.algo = &ttusb_dec_algo;
|
|
|
|
ttusb->i2c_adap.algo_data = NULL;
|
2007-02-13 21:09:03 +00:00
|
|
|
ttusb->i2c_adap.dev.parent = &udev->dev;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
result = i2c_add_adapter(&ttusb->i2c_adap);
|
2011-12-31 11:01:56 +00:00
|
|
|
if (result)
|
|
|
|
goto err_unregister_adapter;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
memset(&ttusb->dvb_demux, 0, sizeof(ttusb->dvb_demux));
|
|
|
|
|
|
|
|
ttusb->dvb_demux.dmx.capabilities =
|
|
|
|
DMX_TS_FILTERING | DMX_SECTION_FILTERING;
|
|
|
|
ttusb->dvb_demux.priv = NULL;
|
|
|
|
#ifdef TTUSB_HWSECTIONS
|
|
|
|
ttusb->dvb_demux.filternum = TTUSB_MAXFILTER;
|
|
|
|
#else
|
|
|
|
ttusb->dvb_demux.filternum = 32;
|
|
|
|
#endif
|
|
|
|
ttusb->dvb_demux.feednum = TTUSB_MAXCHANNEL;
|
|
|
|
ttusb->dvb_demux.start_feed = ttusb_start_feed;
|
|
|
|
ttusb->dvb_demux.stop_feed = ttusb_stop_feed;
|
|
|
|
ttusb->dvb_demux.write_to_decoder = NULL;
|
|
|
|
|
2011-12-31 11:01:56 +00:00
|
|
|
result = dvb_dmx_init(&ttusb->dvb_demux);
|
|
|
|
if (result < 0) {
|
2005-04-16 22:20:36 +00:00
|
|
|
printk("ttusb_dvb: dvb_dmx_init failed (errno = %d)\n", result);
|
2011-12-31 11:01:56 +00:00
|
|
|
result = -ENODEV;
|
|
|
|
goto err_i2c_del_adapter;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
//FIXME dmxdev (nur WAS?)
|
|
|
|
ttusb->dmxdev.filternum = ttusb->dvb_demux.filternum;
|
|
|
|
ttusb->dmxdev.demux = &ttusb->dvb_demux.dmx;
|
|
|
|
ttusb->dmxdev.capabilities = 0;
|
|
|
|
|
2011-12-31 11:01:56 +00:00
|
|
|
result = dvb_dmxdev_init(&ttusb->dmxdev, &ttusb->adapter);
|
|
|
|
if (result < 0) {
|
2005-04-16 22:20:36 +00:00
|
|
|
printk("ttusb_dvb: dvb_dmxdev_init failed (errno = %d)\n",
|
|
|
|
result);
|
2011-12-31 11:01:56 +00:00
|
|
|
result = -ENODEV;
|
|
|
|
goto err_release_dmx;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2005-05-17 04:54:39 +00:00
|
|
|
if (dvb_net_init(&ttusb->adapter, &ttusb->dvbnet, &ttusb->dvb_demux.dmx)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
printk("ttusb_dvb: dvb_net_init failed!\n");
|
2011-12-31 11:01:56 +00:00
|
|
|
result = -ENODEV;
|
|
|
|
goto err_release_dmxdev;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
usb_set_intfdata(intf, (void *) ttusb);
|
|
|
|
|
|
|
|
frontend_init(ttusb);
|
|
|
|
|
|
|
|
return 0;
|
2011-12-31 11:01:56 +00:00
|
|
|
|
|
|
|
err_release_dmxdev:
|
|
|
|
dvb_dmxdev_release(&ttusb->dmxdev);
|
|
|
|
err_release_dmx:
|
|
|
|
dvb_dmx_release(&ttusb->dvb_demux);
|
|
|
|
err_i2c_del_adapter:
|
|
|
|
i2c_del_adapter(&ttusb->i2c_adap);
|
|
|
|
err_unregister_adapter:
|
|
|
|
dvb_unregister_adapter (&ttusb->adapter);
|
2013-06-10 19:00:54 +00:00
|
|
|
ttusb_free_iso_urbs(ttusb);
|
|
|
|
kfree(ttusb);
|
2011-12-31 11:01:56 +00:00
|
|
|
return result;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void ttusb_disconnect(struct usb_interface *intf)
|
|
|
|
{
|
|
|
|
struct ttusb *ttusb = usb_get_intfdata(intf);
|
|
|
|
|
|
|
|
usb_set_intfdata(intf, NULL);
|
|
|
|
|
|
|
|
ttusb->disconnecting = 1;
|
|
|
|
|
|
|
|
ttusb_stop_iso_xfer(ttusb);
|
|
|
|
|
|
|
|
ttusb->dvb_demux.dmx.close(&ttusb->dvb_demux.dmx);
|
|
|
|
dvb_net_release(&ttusb->dvbnet);
|
|
|
|
dvb_dmxdev_release(&ttusb->dmxdev);
|
|
|
|
dvb_dmx_release(&ttusb->dvb_demux);
|
2006-08-08 12:10:08 +00:00
|
|
|
if (ttusb->fe != NULL) {
|
|
|
|
dvb_unregister_frontend(ttusb->fe);
|
2006-08-08 12:10:09 +00:00
|
|
|
dvb_frontend_detach(ttusb->fe);
|
2006-08-08 12:10:08 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
i2c_del_adapter(&ttusb->i2c_adap);
|
2005-05-17 04:54:39 +00:00
|
|
|
dvb_unregister_adapter(&ttusb->adapter);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
ttusb_free_iso_urbs(ttusb);
|
|
|
|
|
|
|
|
kfree(ttusb);
|
|
|
|
|
2008-04-09 02:20:00 +00:00
|
|
|
dprintk("%s: TTUSB DVB disconnected\n", __func__);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct usb_device_id ttusb_table[] = {
|
|
|
|
{USB_DEVICE(0xb48, 0x1003)},
|
2005-07-08 00:58:04 +00:00
|
|
|
{USB_DEVICE(0xb48, 0x1004)},
|
2005-04-16 22:20:36 +00:00
|
|
|
{USB_DEVICE(0xb48, 0x1005)},
|
|
|
|
{}
|
|
|
|
};
|
|
|
|
|
|
|
|
MODULE_DEVICE_TABLE(usb, ttusb_table);
|
|
|
|
|
|
|
|
static struct usb_driver ttusb_driver = {
|
2005-07-12 20:58:39 +00:00
|
|
|
.name = "ttusb",
|
2005-04-16 22:20:36 +00:00
|
|
|
.probe = ttusb_probe,
|
|
|
|
.disconnect = ttusb_disconnect,
|
|
|
|
.id_table = ttusb_table,
|
|
|
|
};
|
|
|
|
|
2011-11-18 17:46:12 +00:00
|
|
|
module_usb_driver(ttusb_driver);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
MODULE_AUTHOR("Holger Waechtler <holger@convergence.de>");
|
|
|
|
MODULE_DESCRIPTION("TTUSB DVB Driver");
|
|
|
|
MODULE_LICENSE("GPL");
|
2008-05-29 16:50:06 +00:00
|
|
|
MODULE_FIRMWARE("ttusb-budget/dspbootcode.bin");
|