Skip to content

K
Kernel

openeuler / Kernel
1 年多 前同步成功

通知 8
Star 0
Fork 0
K
Kernel
提交 e15d1c12 编写于 作者: H Hans Verkuil 提交者： Mauro Carvalho Chehab
浏览文件
操作

[media] tw68: refactor and cleanup the tw68 driver 

Refactor and clean up the tw68 driver. It's now using the proper
V4L2 core frameworks.

Tested with my Techwell tw6805a and tw6816 grabber boards.
Signed-off-by: NHans Verkuil <hans.verkuil@cisco.com>
Signed-off-by: NMauro Carvalho Chehab <m.chehab@samsung.com>
上级 5740f4e7
展开全部 隐藏空白更改
内联 并排
Showing with 566 addition and 3412 deletion
drivers/media/pci/Kconfig
浏览文件 @ e15d1c12
......@@ -20,6 +20,7 @@ source "drivers/media/pci/ivtv/Kconfig"
source "drivers/media/pci/zoran/Kconfig"
source "drivers/media/pci/saa7146/Kconfig"
source "drivers/media/pci/solo6x10/Kconfig"
source "drivers/media/pci/tw68/Kconfig"
endif
if MEDIA_ANALOG_TV_SUPPORT || MEDIA_DIGITAL_TV_SUPPORT
......
drivers/media/pci/Makefile
浏览文件 @ e15d1c12
......@@ -21,6 +21,7 @@ obj-$(CONFIG_VIDEO_CX88) += cx88/
obj-$(CONFIG_VIDEO_BT848) += bt8xx/
obj-$(CONFIG_VIDEO_SAA7134) += saa7134/
obj-$(CONFIG_VIDEO_SAA7164) += saa7164/
obj-$(CONFIG_VIDEO_TW68) += tw68/
obj-$(CONFIG_VIDEO_MEYE) += meye/
obj-$(CONFIG_STA2X11_VIP) += sta2x11/
obj-$(CONFIG_VIDEO_SOLO6X10) += solo6x10/
drivers/media/pci/tw68/Kconfig 0 → 100644
浏览文件 @ e15d1c12
config VIDEO_TW68
tristate "Techwell tw68x Video For Linux"
depends on VIDEO_DEV && PCI && VIDEO_V4L2
select I2C_ALGOBIT
select VIDEOBUF2_DMA_SG
---help---
Support for Techwell tw68xx based frame grabber boards.
To compile this driver as a module, choose M here: the
module will be called tw68.
drivers/media/pci/tw68/Makefile 0 → 100644
浏览文件 @ e15d1c12
tw68-objs := tw68-core.o tw68-video.o tw68-risc.o
obj-$(CONFIG_VIDEO_TW68) += tw68.o
drivers/media/pci/tw68/tw68-cards.c 已删除 100644 → 0
浏览文件 @ 5740f4e7
/*
* device driver for Techwell 68xx based cards
*
* Much of this code is derived from the cx88 and sa7134 drivers, which
* were in turn derived from the bt87x driver. The original work was by
* Gerd Knorr; more recently the code was enhanced by Mauro Carvalho Chehab,
* Hans Verkuil, Andy Walls and many others. Their work is gratefully
* acknowledged. Full credit goes to them - any problems within this code
* are mine.
*
* Copyright (C) 2009 William M. Brack <wbrack@mmm.com.hk>
*
* 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.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <linux/init.h>
#include <linux/module.h>
#include <linux/i2c.h> /* must appear before i2c-algo-bit.h */
#include <linux/i2c-algo-bit.h>
#include <media/v4l2-common.h>
#include <media/tveeprom.h>
#include "tw68.h"
#include "tw68-reg.h"
/* commly used strings */
#if 0
static char name_mute[] = "mute";
static char name_radio[] = "Radio";
static char name_tv[] = "Television";
static char name_tv_mono[] = "TV (mono only)";
static char name_svideo[] = "S-Video";
static char name_comp[] = "Composite";
#endif
static char name_comp1[] = "Composite1";
static char name_comp2[] = "Composite2";
static char name_comp3[] = "Composite3";
static char name_comp4[] = "Composite4";
/* ------------------------------------------------------------------ */
/* board config info */
/* If radio_type !=UNSET, radio_addr should be specified
*/
struct tw68_board tw68_boards[] = {
[TW68_BOARD_UNKNOWN] = {
.name = "GENERIC",
.tuner_type = TUNER_ABSENT,
.radio_type = UNSET,
.tuner_addr = ADDR_UNSET,
.radio_addr = ADDR_UNSET,
.inputs = {
{
.name = name_comp1,
.vmux = 0,
}, {
.name = name_comp2,
.vmux = 1,
}, {
.name = name_comp3,
.vmux = 2,
}, {
.name = name_comp4,
.vmux = 3,
}, { /* Must have a NULL entry at end of list */
.name = NULL,
.vmux = 0,
}
},
},
};
const unsigned int tw68_bcount = ARRAY_SIZE(tw68_boards);
/*
* Please add any new PCI IDs to: http://pci-ids.ucw.cz. This keeps
* the PCI ID database up to date. Note that the entries must be
* added under vendor 0x1797 (Techwell Inc.) as subsystem IDs.
*/
struct pci_device_id tw68_pci_tbl[] = {
{
.vendor = PCI_VENDOR_ID_TECHWELL,
.device = PCI_DEVICE_ID_6800,
.subvendor = PCI_ANY_ID,
.subdevice = PCI_ANY_ID,
.driver_data = TW68_BOARD_UNKNOWN,
}, {
.vendor = PCI_VENDOR_ID_TECHWELL,
.device = PCI_DEVICE_ID_6801,
.subvendor = PCI_ANY_ID,
.subdevice = PCI_ANY_ID,
.driver_data = TW68_BOARD_UNKNOWN,
}, {
.vendor = PCI_VENDOR_ID_TECHWELL,
.device = PCI_DEVICE_ID_6804,
.subvendor = PCI_ANY_ID,
.subdevice = PCI_ANY_ID,
.driver_data = TW68_BOARD_UNKNOWN,
}, {
.vendor = PCI_VENDOR_ID_TECHWELL,
.device = PCI_DEVICE_ID_6816_1,
.subvendor = PCI_ANY_ID,
.subdevice = PCI_ANY_ID,
.driver_data = TW68_BOARD_UNKNOWN,
}, {
.vendor = PCI_VENDOR_ID_TECHWELL,
.device = PCI_DEVICE_ID_6816_2,
.subvendor = PCI_ANY_ID,
.subdevice = PCI_ANY_ID,
.driver_data = TW68_BOARD_UNKNOWN,
}, {
.vendor = PCI_VENDOR_ID_TECHWELL,
.device = PCI_DEVICE_ID_6816_3,
.subvendor = PCI_ANY_ID,
.subdevice = PCI_ANY_ID,
.driver_data = TW68_BOARD_UNKNOWN,
}, {
.vendor = PCI_VENDOR_ID_TECHWELL,
.device = PCI_DEVICE_ID_6816_4,
.subvendor = PCI_ANY_ID,
.subdevice = PCI_ANY_ID,
.driver_data = TW68_BOARD_UNKNOWN,
}, {
/* end of list */
}
};
MODULE_DEVICE_TABLE(pci, tw68_pci_tbl);
/* ------------------------------------------------------------ */
/* stuff done before i2c enabled */
int tw68_board_init1(struct tw68_dev *dev)
{
/* Clear GPIO outputs */
tw_writel(TW68_GPOE, 0);
/* Remainder of setup according to board ID */
switch (dev->board) {
case TW68_BOARD_UNKNOWN:
printk(KERN_INFO "%s: Unable to determine board type, "
"using generic values\n", dev->name);
break;
}
dev->input = dev->hw_input = &card_in(dev,0);
return 0;
}
int tw68_tuner_setup(struct tw68_dev *dev)
{
return 0;
}
/* stuff which needs working i2c */
int tw68_board_init2(struct tw68_dev *dev)
{
return 0;
}
drivers/media/pci/tw68/tw68-core.c
浏览文件 @ e15d1c12
此差异已折叠。
drivers/media/pci/tw68/tw68-i2c.c 已删除 100644 → 0
浏览文件 @ 5740f4e7
/*
* tw68 code to handle the i2c interface.
*
* Much of this code is derived from the bt87x driver. The original
* work was by Gerd Knorr; more recently the code was enhanced by Mauro
* Carvalho Chehab. Their work is gratefully acknowledged. Full credit
* goes to them - any problems within this code are mine.
*
* Copyright (C) 2009 William M. Brack <wbrack@mmm.com.hk>
*
* 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.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <linux/init.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include "tw68.h"
#include <media/v4l2-common.h>
#include <linux/i2c-algo-bit.h>
/*----------------------------------------------------------------*/
static unsigned int i2c_debug;
module_param(i2c_debug, int, 0644);
MODULE_PARM_DESC(i2c_debug, "enable debug messages [i2c]");
#if 0
static unsigned int i2c_scan;
module_param(i2c_scan, int, 0444);
MODULE_PARM_DESC(i2c_scan, "scan i2c bus at insmod time");
#endif
#define d1printk if (1 == i2c_debug) printk
#define I2C_CLOCK 0xa6 /* 99.4 kHz */
/*----------------------------------------------------------------------*/
/* Although the TW68xx i2c controller has a "hardware" mode, where all of
* the low-level i2c/smbbus is handled by the chip, it appears that mode
* is not suitable for linux i2c handling routines because extended "bursts"
* of data (sequences of bytes without intervening START/STOP bits) are
* not possible. Instead, we put the chip into "software" mode, and handle
* the i2c bus at a low level. To accomplish this, we use the routines
* from the i2c modules.
*
* Because the particular boards which I had for testing did not have any
* devices attached to the i2c bus, I have been unable to test these
* routines.
*/
/*----------------------------------------------------------------------*/
/* I2C functions - "bit-banging" adapter (software i2c) */
/* tw68_bit_setcl
* Handles "toggling" the i2c clock bit
*/
static void tw68_bit_setscl(void *data, int state)
{
struct tw68_dev *dev = data;
tw_andorb(TW68_SBUSC, (state ? 1 : 0) << TW68_SSCLK, TW68_SSCLK_B);
}
/* tw68_bit_setsda
* Handles "toggling" the i2c data bit
*/
static void tw68_bit_setsda(void *data, int state)
{
struct tw68_dev *dev = data;
tw_andorb(TW68_SBUSC, (state ? 1 : 0) << TW68_SSDAT, TW68_SSDAT_B);
}
/* tw68_bit_getscl
*
* Returns the current state of the clock bit
*/
static int tw68_bit_getscl(void *data)
{
struct tw68_dev *dev = data;
return (tw_readb(TW68_SBUSC) & TW68_SSCLK_B) ? 1 : 0;
}
/* tw68_bit_getsda
*
* Returns the current state of the data bit
*/
static int tw68_bit_getsda(void *data)
{
struct tw68_dev *dev = data;
return (tw_readb(TW68_SBUSC) & TW68_SSDAT_B) ? 1 : 0;
}
static struct i2c_algo_bit_data __devinitdata tw68_i2c_algo_bit_template = {
.setsda = tw68_bit_setsda,
.setscl = tw68_bit_setscl,
.getsda = tw68_bit_getsda,
.getscl = tw68_bit_getscl,
.udelay = 16,
.timeout = 200,
};
static struct i2c_client tw68_client_template = {
.name = "tw68 internal",
};
/*----------------------------------------------------------------*/
static int attach_inform(struct i2c_client *client)
{
/* struct tw68_dev *dev = client->adapter->algo_data; */
d1printk("%s i2c attach [addr=0x%x,client=%s]\n",
client->driver->driver.name, client->addr, client->name);
switch (client->addr) {
/* No info yet on what addresses to expect */
}
return 0;
}
static struct i2c_adapter tw68_adap_sw_template = {
.owner = THIS_MODULE,
.name = "tw68_sw",
.client_register = attach_inform,
};
static int tw68_i2c_eeprom(struct tw68_dev *dev, unsigned char *eedata,
int len)
{
unsigned char buf;
int i, err;
dev->i2c_client.addr = 0xa0 >> 1;
buf = 256 - len;
err = i2c_master_send(&dev->i2c_client, &buf, 1);
if (1 != err) {
printk(KERN_INFO "%s: Huh, no eeprom present (err = %d)?\n",
dev->name, err);
return -1;
}
err = i2c_master_recv(&dev->i2c_client, eedata, len);
if (len != err) {
printk(KERN_WARNING "%s: i2c eeprom read error (err=%d)\n",
dev->name, err);
return -1;
}
for (i = 0; i < len; i++) {
if (0 == (i % 16))
printk(KERN_INFO "%s: i2c eeprom %02x:",
dev->name, i);
printk(KERN_INFO " %02x", eedata[i]);
if (15 == (i % 16))
printk("\n");
}
return 0;
}
#if 0
static char *i2c_devs[128] = {
[0xa0 >> 1] = "eeprom",
};
static void do_i2c_scan(char *name, struct i2c_client *c)
{
unsigned char buf;
int i, rc;
for (i = 0; i < ARRAY_SIZE(i2c_devs); i++) {
c->addr = i;
rc = i2c_master_recv(c, &buf, 1);
if (rc < 0)
continue;
printk(KERN_INFO "%s: i2c scan: found device "
"@ 0x%x [%s]\n", name, i << 1,
i2c_devs[i] ? i2c_devs[i] : "???");
}
}
#endif
int __devinit tw68_i2c_register(struct tw68_dev *dev)
{
int rc;
printk(KERN_DEBUG "%s: Registering i2c module\n", __func__);
tw_writeb(TW68_I2C_RST, 1); /* reset the i2c module */
memcpy(&dev->i2c_client, &tw68_client_template,
sizeof(tw68_client_template));
memcpy(&dev->i2c_adap, &tw68_adap_sw_template,
sizeof(tw68_adap_sw_template));
dev->i2c_adap.algo_data = &dev->i2c_algo;
dev->i2c_adap.dev.parent = &dev->pci->dev;
memcpy(&dev->i2c_algo, &tw68_i2c_algo_bit_template,
sizeof(tw68_i2c_algo_bit_template));
dev->i2c_algo.data = dev;
/* TODO - may want to set better name (see bttv code) */
i2c_set_adapdata(&dev->i2c_adap, &dev->v4l2_dev);
dev->i2c_client.adapter = &dev->i2c_adap;
/* Assure chip is in "software" mode */
tw_writel(TW68_SBUSC, TW68_SSDAT | TW68_SSCLK);
tw68_bit_setscl(dev, 1);
tw68_bit_setsda(dev, 1);
rc = i2c_bit_add_bus(&dev->i2c_adap);
tw68_i2c_eeprom(dev, dev->eedata, sizeof(dev->eedata));
#if 0
if (i2c_scan)
do_i2c_scan(dev->name, &dev->i2c_client);
#endif
return rc;
}
int tw68_i2c_unregister(struct tw68_dev *dev)
{
i2c_del_adapter(&dev->i2c_adap);
return 0;
}
drivers/media/pci/tw68/tw68-reg.h
浏览文件 @ e15d1c12
......@@ -8,7 +8,11 @@
* acknowledged. Full credit goes to them - any problems within this code
* are mine.
*
* Copyright (C) William M. Brack <wbrack@mmm.com.hk>
* Copyright (C) William M. Brack
*
* Refactored and updated to the latest v4l core frameworks:
*
* Copyright (C) 2014 Hans Verkuil <hverkuil@xs4all.nl>
*
* 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
......@@ -19,10 +23,6 @@
* 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.
*/
#ifndef _TW68_REG_H_
......
drivers/media/pci/tw68/tw68-risc.c
浏览文件 @ e15d1c12
......@@ -9,7 +9,11 @@
* acknowledged. Full credit goes to them - any problems within this code
* are mine.
*
* Copyright (C) 2009 William M. Brack <wbrack@mmm.com.hk>
* Copyright (C) 2009 William M. Brack
*
* Refactored and updated to the latest v4l core frameworks:
*
* Copyright (C) 2014 Hans Verkuil <hverkuil@xs4all.nl>
*
* 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
......@@ -20,16 +24,10 @@
* 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.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "tw68.h"
#define NO_SYNC_LINE (-1U)
/**
* @rp pointer to current risc program position
* @sglist pointer to "scatter-gather list" of buffer pointers
......@@ -38,32 +36,35 @@
* @bpl number of bytes per scan line
* @padding number of bytes of padding to add
* @lines number of lines in field
* @lpi lines per IRQ, or 0 to not generate irqs
* Note: IRQ to be generated _after_ lpi lines are transferred
* @jump insert a jump at the start
*/
static __le32 *tw68_risc_field(__le32 *rp, struct scatterlist *sglist,
unsigned int offset, u32 sync_line,
unsigned int bpl, unsigned int padding,
unsigned int lines, unsigned int lpi)
unsigned int lines, bool jump)
{
struct scatterlist *sg;
unsigned int line, todo, done;
/* sync instruction */
if (sync_line != NO_SYNC_LINE) {
if (sync_line == 1)
*(rp++) = cpu_to_le32(RISC_SYNCO);
else
*(rp++) = cpu_to_le32(RISC_SYNCE);
if (jump) {
*(rp++) = cpu_to_le32(RISC_JUMP);
*(rp++) = 0;
}
/* sync instruction */
if (sync_line == 1)
*(rp++) = cpu_to_le32(RISC_SYNCO);
else
*(rp++) = cpu_to_le32(RISC_SYNCE);
*(rp++) = 0;
/* scan lines */
sg = sglist;
for (line = 0; line < lines; line++) {
/* calculate next starting position */
while (offset && offset >= sg_dma_len(sg)) {
offset -= sg_dma_len(sg);
sg++;
sg = sg_next(sg);
}
if (bpl <= sg_dma_len(sg) - offset) {
/* fits into current chunk */
......@@ -86,7 +87,7 @@ static __le32 *tw68_risc_field(__le32 *rp, struct scatterlist *sglist,
done);
*(rp++) = cpu_to_le32(sg_dma_address(sg) + offset);
todo -= done;
sg++;
sg = sg_next(sg);
/* succeeding fragments have no offset */
while (todo > sg_dma_len(sg)) {
*(rp++) = cpu_to_le32(RISC_INLINE |
......@@ -94,7 +95,7 @@ static __le32 *tw68_risc_field(__le32 *rp, struct scatterlist *sglist,
sg_dma_len(sg));
*(rp++) = cpu_to_le32(sg_dma_address(sg));
todo -= sg_dma_len(sg);
sg++;
sg = sg_next(sg);
done += sg_dma_len(sg);
}
if (todo) {
......@@ -107,9 +108,6 @@ static __le32 *tw68_risc_field(__le32 *rp, struct scatterlist *sglist,
offset = todo;
}
offset += padding;
/* If this line needs an interrupt, put it in */
if (lpi && line > 0 && !(line % lpi))
*(rp-2) |= RISC_INT_BIT;
}
return rp;
......@@ -118,25 +116,25 @@ static __le32 *tw68_risc_field(__le32 *rp, struct scatterlist *sglist,
/**
* tw68_risc_buffer
*
* This routine is called by tw68-video. It allocates
* memory for the dma controller "program" and then fills in that
* memory with the appropriate "instructions".
* This routine is called by tw68-video. It allocates
* memory for the dma controller "program" and then fills in that
* memory with the appropriate "instructions".
*
* @pci_dev structure with info about the pci
* slot which our device is in.
* @risc structure with info about the memory
* used for our controller program.
* @sglist scatter-gather list entry
* @top_offset offset within the risc program area for the
* first odd frame line
* @bottom_offset offset within the risc program area for the
* first even frame line
* @bpl number of data bytes per scan line
* @padding number of extra bytes to add at end of line
* @lines number of scan lines
* @pci_dev structure with info about the pci
* slot which our device is in.
* @risc structure with info about the memory
* used for our controller program.
* @sglist scatter-gather list entry
* @top_offset offset within the risc program area for the
* first odd frame line
* @bottom_offset offset within the risc program area for the
* first even frame line
* @bpl number of data bytes per scan line
* @padding number of extra bytes to add at end of line
* @lines number of scan lines
*/
int tw68_risc_buffer(struct pci_dev *pci,
struct btcx_riscmem *risc,
struct tw68_buf *buf,
struct scatterlist *sglist,
unsigned int top_offset,
unsigned int bottom_offset,
......@@ -146,7 +144,6 @@ int tw68_risc_buffer(struct pci_dev *pci,
{
u32 instructions, fields;
__le32 *rp;
int rc;
fields = 0;
if (UNSET != top_offset)
......@@ -155,29 +152,31 @@ int tw68_risc_buffer(struct pci_dev *pci,
fields++;
/*
* estimate risc mem: worst case is one write per page border +
* one write per scan line + syncs + jump (all 2 dwords).
* one write per scan line + syncs + 2 jumps (all 2 dwords).
* Padding can cause next bpl to start close to a page border.
* First DMA region may be smaller than PAGE_SIZE
*/
instructions = fields * (1 + (((bpl + padding) * lines) /
PAGE_SIZE) + lines) + 2;
rc = btcx_riscmem_alloc(pci, risc, instructions * 8);
if (rc < 0)
return rc;
PAGE_SIZE) + lines) + 4;
buf->size = instructions * 8;
buf->cpu = pci_alloc_consistent(pci, buf->size, &buf->dma);
if (buf->cpu == NULL)
return -ENOMEM;
/* write risc instructions */
rp = risc->cpu;
rp = buf->cpu;
if (UNSET != top_offset) /* generates SYNCO */
rp = tw68_risc_field(rp, sglist, top_offset, 1,
bpl, padding, lines, 0);
bpl, padding, lines, true);
if (UNSET != bottom_offset) /* generates SYNCE */
rp = tw68_risc_field(rp, sglist, bottom_offset, 2,
bpl, padding, lines, 0);
bpl, padding, lines, top_offset == UNSET);
/* save pointer to jmp instruction address */
risc->jmp = rp;
buf->jmp = rp;
buf->cpu[1] = cpu_to_le32(buf->dma + 8);
/* assure risc buffer hasn't overflowed */
BUG_ON((risc->jmp - risc->cpu + 2) * sizeof(*risc->cpu) > risc->size);
BUG_ON((buf->jmp - buf->cpu + 2) * sizeof(buf->cpu[0]) > buf->size);
return 0;
}
......@@ -204,65 +203,28 @@ static void tw68_risc_decode(u32 risc, u32 addr)
p = RISC_OP(risc);
if (!(risc & 0x80000000) || !instr[p].name) {
printk(KERN_DEBUG "0x%08x [ INVALID ]\n", risc);
pr_debug("0x%08x [ INVALID ]\n", risc);
return;
}
printk(KERN_DEBUG "0x%08x %-9s IRQ=%d",
pr_debug("0x%08x %-9s IRQ=%d",
risc, instr[p].name, (risc >> 27) & 1);
if (instr[p].has_data_type)
printk(KERN_DEBUG " Type=%d", (risc >> 24) & 7);
pr_debug(" Type=%d", (risc >> 24) & 7);
if (instr[p].has_byte_info)
printk(KERN_DEBUG " Start=0x%03x Count=%03u",
pr_debug(" Start=0x%03x Count=%03u",
(risc >> 12) & 0xfff, risc & 0xfff);
if (instr[p].has_addr)
printk(KERN_DEBUG " StartAddr=0x%08x", addr);
printk(KERN_DEBUG "\n");
pr_debug(" StartAddr=0x%08x", addr);
pr_debug("\n");
}
void tw68_risc_program_dump(struct tw68_core *core,
struct btcx_riscmem *risc)
void tw68_risc_program_dump(struct tw68_core *core, struct tw68_buf *buf)
{
__le32 *addr;
const __le32 *addr;
printk(KERN_DEBUG "%s: risc_program_dump: risc=%p, "
"risc->cpu=0x%p, risc->jmp=0x%p\n",
core->name, risc, risc->cpu, risc->jmp);
for (addr = risc->cpu; addr <= risc->jmp; addr += 2)
pr_debug("%s: risc_program_dump: risc=%p, buf->cpu=0x%p, buf->jmp=0x%p\n",
core->name, buf, buf->cpu, buf->jmp);
for (addr = buf->cpu; addr <= buf->jmp; addr += 2)
tw68_risc_decode(*addr, *(addr+1));
}
EXPORT_SYMBOL_GPL(tw68_risc_program_dump);
#endif
/*
* tw68_risc_stopper
* Normally, the risc code generated for a buffer ends with a
* JUMP instruction to direct the DMAP processor to the code for
* the next buffer. However, when there is no additional buffer
* currently available, the code instead jumps to this routine.
*
* My first try for a "stopper" program was just a simple
* "jump to self" instruction. Unfortunately, this caused the
* video FIFO to overflow. My next attempt was to just disable
* the DMAP processor. Unfortunately, this caused the video
* decoder to lose its synchronization. The solution to this was to
* add a "Sync-Odd" instruction, which "eats" all the video data
* until the start of the next odd field.
*/
int tw68_risc_stopper(struct pci_dev *pci, struct btcx_riscmem *risc)
{
__le32 *rp;
int rc;
rc = btcx_riscmem_alloc(pci, risc, 8*4);
if (rc < 0)
return rc;
/* write risc inststructions */
rp = risc->cpu;
*(rp++) = cpu_to_le32(RISC_SYNCO);
*(rp++) = 0;
*(rp++) = cpu_to_le32(RISC_JUMP);
*(rp++) = cpu_to_le32(risc->dma);
risc->jmp = risc->cpu;
return 0;
}
drivers/media/pci/tw68/tw68-ts.c 已删除 100644 → 0
浏览文件 @ 5740f4e7
/*
* tw68_ts.c
* Part of the device driver for Techwell 68xx based cards
*
* Much of this code is derived from the cx88 and sa7134 drivers, which
* were in turn derived from the bt87x driver. The original work was by
* Gerd Knorr; more recently the code was enhanced by Mauro Carvalho Chehab,
* Hans Verkuil, Andy Walls and many others. Their work is gratefully
* acknowledged. Full credit goes to them - any problems within this code
* are mine.
*
* Copyright (C) 2009 William M. Brack <wbrack@mmm.com.hk>
*
* 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.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "tw68.h"
int tw68_ts_init1(struct tw68_dev *dev)
{
return 0;
}
int tw68_ts_ini(struct tw68_dev *dev)
{
return 0;
}
int tw68_ts_fini(struct tw68_dev *dev)
{
return 0;
}
void tw68_irq_ts_done(struct tw68_dev *dev, unsigned long status)
{
return;
}
int tw68_ts_register(struct tw68_mpeg_ops *ops)
{
return 0;
}
void tw68_ts_unregister(struct tw68_mpeg_ops *ops)
{
return;
}
int tw68_ts_init_hw(struct tw68_dev *dev)
{
return 0;
}
drivers/media/pci/tw68/tw68-tvaudio.c 已删除 100644 → 0
浏览文件 @ 5740f4e7
/*
* tw68_controls.c
* Part of the device driver for Techwell 68xx based cards
*
* Much of this code is derived from the cx88 and sa7134 drivers, which
* were in turn derived from the bt87x driver. The original work was by
* Gerd Knorr; more recently the code was enhanced by Mauro Carvalho Chehab,
* Hans Verkuil, Andy Walls and many others. Their work is gratefully
* acknowledged. Full credit goes to them - any problems within this code
* are mine.
*
* Copyright (C) 2009 William M. Brack <wbrack@mmm.com.hk>
*
* 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.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "tw68.h"
int tw68_tvaudio_rx2mode(u32 rx)
{
return 0;
}
void tw68_tvaudio_setmute(struct tw68_dev *dev)
{
return;
}
void tw68_tvaudio_setinput(struct tw68_dev *dev, struct tw68_input *in)
{
return;
}
void tw68_tvaudio_setvolume(struct tw68_dev *dev, int level)
{
return;
}
int tw68_tvaudio_getstereo(struct tw68_dev *dev)
{
return 0;
}
void tw68_tvaudio_init(struct tw68_dev *dev)
{
return;
}
int tw68_tvaudio_init2(struct tw68_dev *dev)
{
return 0;
}
int tw68_tvaudio_fini(struct tw68_dev *dev)
{
return 0;
}
int tw68_tvaudio_do_scan(struct tw68_dev *dev)
{
return 0;
}
void tw68_enable_i2s(struct tw68_dev *dev)
{
return;
}
drivers/media/pci/tw68/tw68-vbi.c 已删除 100644 → 0
浏览文件 @ 5740f4e7
/*
* tw68_controls.c
* Part of the device driver for Techwell 68xx based cards
*
* Much of this code is derived from the cx88 and sa7134 drivers, which
* were in turn derived from the bt87x driver. The original work was by
* Gerd Knorr; more recently the code was enhanced by Mauro Carvalho Chehab,
* Hans Verkuil, Andy Walls and many others. Their work is gratefully
* acknowledged. Full credit goes to them - any problems within this code
* are mine.
*
* Copyright (C) 2009 William M. Brack <wbrack@mmm.com.hk>
*
* 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.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "tw68.h"
static int buffer_setup(struct videobuf_queue *q, unsigned int *count,
unsigned int *size) {
printk(KERN_INFO "%s: shouldn't be here!\n", __func__);
return 0;
}
static int buffer_prepare(struct videobuf_queue *q,
struct videobuf_buffer *vb,
enum v4l2_field field)
{
printk(KERN_INFO "%s: shouldn't be here!\n", __func__);
return 0;
}
static void buffer_queue(struct videobuf_queue *q,
struct videobuf_buffer *vb)
{
printk(KERN_INFO "%s: shouldn't be here!\n", __func__);
}
static void buffer_release(struct videobuf_queue *q,
struct videobuf_buffer *vb)
{
printk(KERN_INFO "%s: shouldn't be here!\n", __func__);
}
struct videobuf_queue_ops tw68_vbi_qops = {
.buf_setup = buffer_setup,
.buf_prepare = buffer_prepare,
.buf_queue = buffer_queue,
.buf_release = buffer_release,
};
/* ------------------------------------------------------------------ */
int tw68_vbi_init1(struct tw68_dev *dev)
{
return 0;
}
int tw68_vbi_fini(struct tw68_dev *dev)
{
return 0;
}
void tw68_irq_vbi_done(struct tw68_dev *dev, unsigned long status)
{
return;
}
drivers/media/pci/tw68/tw68-video.c
浏览文件 @ e15d1c12
此差异已折叠。
drivers/media/pci/tw68/tw68.h
浏览文件 @ e15d1c12
......@@ -8,7 +8,11 @@
* acknowledged. Full credit goes to them - any problems within this code
* are mine.
*
* Copyright (C) 2009 William M. Brack <wbrack@mmm.com.hk>
* Copyright (C) 2009 William M. Brack
*
* Refactored and updated to the latest v4l core frameworks:
*
* Copyright (C) 2014 Hans Verkuil <hverkuil@xs4all.nl>
*
* 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
......@@ -19,54 +23,26 @@
* 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., 59 Temple Place, Suite 330, Boston, MA
* 02111-1307 USA
*/
#include <linux/version.h>
#define TW68_VERSION_CODE KERNEL_VERSION(0, 0, 8)
#include <linux/pci.h>
#include <linux/i2c.h>
#include <linux/i2c-algo-bit.h>
#include <linux/videodev2.h>
#include <linux/kdev_t.h>
#include <linux/input.h>
#include <linux/notifier.h>
#include <linux/delay.h>
#include <linux/mutex.h>
#include <asm/io.h>
#include <linux/io.h>
#include <media/v4l2-common.h>
#include <media/v4l2-ioctl.h>
#include <media/v4l2-ctrls.h>
#include <media/v4l2-device.h>
#include <media/videobuf2-dma-sg.h>
#include <media/tuner.h>
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,38)
# include <media/ir-common.h>
#endif
#include <media/ir-kbd-i2c.h>
#include <media/videobuf-dma-sg.h>
#include "btcx-risc.h"
#include "tw68-reg.h"
#define UNSET (-1U)
/*
* dprintk statement within the code use a 'level' argument. For
* our purposes, we use the following levels:
*/
#define DBG_UNEXPECTED (1 << 0)
#define DBG_UNUSUAL (1 << 1)
#define DBG_TESTING (1 << 2)
#define DBG_BUFF (1 << 3)
#define DBG_FLOW (1 << 15)
/* system vendor and device ID's */
#define PCI_VENDOR_ID_TECHWELL 0x1797
#define PCI_DEVICE_ID_6800 0x6800
......@@ -83,15 +59,9 @@
#define PCI_DEVICE_ID_6816_3 0x6812
#define PCI_DEVICE_ID_6816_4 0x6813
/* subsystem vendor ID's */
#define TW68_PCI_ID_TECHWELL 0x1797
#define TW68_NORMS (\
V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM | \
V4L2_STD_PAL_BG | V4L2_STD_PAL_DK | V4L2_STD_PAL_I | \
V4L2_STD_PAL_M | V4L2_STD_PAL_Nc | V4L2_STD_PAL_60 | \
V4L2_STD_525_60 | V4L2_STD_625_50 | \
V4L2_STD_SECAM_L| V4L2_STD_SECAM_LC | V4L2_STD_SECAM_DK)
#define TW68_NORMS ( \
V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM | \
V4L2_STD_PAL_M | V4L2_STD_PAL_Nc | V4L2_STD_PAL_60)
#define TW68_VID_INTS (TW68_FFERR | TW68_PABORT | TW68_DMAPERR | \
TW68_FFOF | TW68_DMAPI)
......@@ -101,12 +71,13 @@
#define TW68_I2C_INTS (TW68_SBERR | TW68_SBDONE | TW68_SBERR2 | \
TW68_SBDONE2)
typedef enum {
enum tw68_decoder_type {
TW6800,
TW6801,
TW6804,
TWXXXX,
} TW68_DECODER_TYPE;
};
/* ----------------------------------------------------------- */
/* static data */
......@@ -153,164 +124,24 @@ struct tw68_format {
#define TW68_BOARD_GENERIC_6802 1
#define TW68_MAXBOARDS 16
#define TW68_INPUT_MAX 8
/* ----------------------------------------------------------- */
/* enums */
enum tw68_mpeg_type {
TW68_MPEG_UNUSED,
TW68_MPEG_EMPRESS,
TW68_MPEG_DVB,
};
enum tw68_audio_in {
TV = 1,
LINE1 = 2,
LINE2 = 3,
LINE2_LEFT,
};
enum tw68_video_out {
CCIR656 = 1,
};
/* Structs for card definition */
struct tw68_input {
char *name; /* text description */
unsigned int vmux; /* mux value */
enum tw68_audio_in mux;
unsigned int gpio;
unsigned int tv:1;
};
struct tw68_board {
char *name;
unsigned int audio_clock;
/* input switching */
unsigned int gpiomask;
struct tw68_input inputs[TW68_INPUT_MAX];
struct tw68_input radio;
struct tw68_input mute;
/* i2c chip info */
unsigned int tuner_type;
unsigned int radio_type;
unsigned char tuner_addr;
unsigned char radio_addr;
unsigned int tda9887_conf;
unsigned int tuner_config;
enum tw68_video_out video_out;
enum tw68_mpeg_type mpeg;
unsigned int vid_port_opts;
};
#define card_has_radio(dev) (NULL != tw68_boards[dev->board].radio.name)
#define card_has_mpeg(dev) (TW68_MPEG_UNUSED != \
tw68_boards[dev->board].mpeg)
#define card_in(dev, n) (tw68_boards[dev->board].inputs[n])
#define card(dev) (tw68_boards[dev->board])
#define TW68_INPUT_MAX 4
/* ----------------------------------------------------------- */
/* device / file handle status */
#define RESOURCE_VIDEO 1
#define RESOURCE_VBI 2
#define INTERLACE_AUTO 0
#define INTERLACE_ON 1
#define INTERLACE_OFF 2
#define BUFFER_TIMEOUT msecs_to_jiffies(500) /* 0.5 seconds */
struct tw68_dev; /* forward delclaration */
/* tvaudio thread status */
struct tw68_thread {
struct task_struct *thread;
unsigned int scan1;
unsigned int scan2;
unsigned int mode;
unsigned int stopped;
};
/* buffer for one video/vbi/ts frame */
struct tw68_buf {
/* common v4l buffer stuff -- must be first */
struct videobuf_buffer vb;
/* tw68 specific */
struct tw68_format *fmt;
struct tw68_input *input;
unsigned int top_seen;
int (*activate)(struct tw68_dev *dev,
struct tw68_buf *buf,
struct tw68_buf *next);
struct btcx_riscmem risc;
unsigned int bpl;
};
struct vb2_buffer vb;
struct list_head list;
struct tw68_dmaqueue {
struct tw68_dev *dev;
struct list_head active;
struct list_head queued;
struct timer_list timeout;
struct btcx_riscmem stopper;
int (*buf_compat)(struct tw68_buf *prev,
struct tw68_buf *buf);
int (*start_dma)(struct tw68_dev *dev,
struct tw68_dmaqueue *q,
struct tw68_buf *buf);
};
/* video filehandle status */
struct tw68_fh {
struct tw68_dev *dev;
unsigned int radio;
enum v4l2_buf_type type;
unsigned int resources;
enum v4l2_priority prio;
/* video capture */
struct tw68_format *fmt;
unsigned int width, height;
struct videobuf_queue cap; /* also used for overlay */
/* vbi capture */
struct videobuf_queue vbi;
};
/* dmasound dsp status */
struct tw68_dmasound {
struct mutex lock;
int minor_mixer;
int minor_dsp;
unsigned int users_dsp;
/* mixer */
enum tw68_audio_in input;
unsigned int count;
unsigned int line1;
unsigned int line2;
/* dsp */
unsigned int afmt;
unsigned int rate;
unsigned int channels;
unsigned int recording_on;
unsigned int dma_running;
unsigned int blocks;
unsigned int blksize;
unsigned int bufsize;
struct videobuf_dmabuf dma;
unsigned int dma_blk;
unsigned int read_offset;
unsigned int read_count;
void *priv_data;
struct snd_pcm_substream *substream;
unsigned int size;
__le32 *cpu;
__le32 *jmp;
dma_addr_t dma;
};
struct tw68_fmt {
......@@ -321,58 +152,20 @@ struct tw68_fmt {
u32 twformat;
};
/* ts/mpeg status */
struct tw68_ts {
/* TS capture */
int nr_packets;
int nr_bufs;
};
/* ts/mpeg ops */
struct tw68_mpeg_ops {
enum tw68_mpeg_type type;
struct list_head next;
int (*init)(struct tw68_dev *dev);
int (*fini)(struct tw68_dev *dev);
void (*signal_change)(struct tw68_dev *dev);
};
enum tw68_ts_status {
TW68_TS_STOPPED,
TW68_TS_BUFF_DONE,
TW68_TS_STARTED,
};
/* global device status */
struct tw68_dev {
struct list_head devlist;
struct mutex lock;
spinlock_t slock;
struct v4l2_prio_state prio;
u16 instance;
struct v4l2_device v4l2_dev;
/* workstruct for loading modules */
struct work_struct request_module_wk;
/* insmod option/autodetected */
int autodetected;
/* various device info */
TW68_DECODER_TYPE vdecoder;
unsigned int resources;
struct video_device *video_dev;
struct video_device *radio_dev;
struct video_device *vbi_dev;
struct tw68_dmasound dmasound;
#if LINUX_VERSION_CODE < KERNEL_VERSION(3,0,0)
/* infrared remote */
int has_remote;
struct card_ir *remote;
#endif
enum tw68_decoder_type vdecoder;
struct video_device vdev;
struct v4l2_ctrl_handler hdl;
/* pci i/o */
char name[32];
int nr;
char *name;
struct pci_dev *pci;
unsigned char pci_rev, pci_lat;
u32 __iomem *lmmio;
......@@ -381,75 +174,18 @@ struct tw68_dev {
/* The irq mask to be used will depend upon the chip type */
u32 board_virqmask;
/* config info */
unsigned int board;
unsigned int tuner_type;
unsigned int radio_type;
unsigned char tuner_addr;
unsigned char radio_addr;
unsigned int tda9887_conf;
unsigned int gpio_value;
/* i2c i/o */
struct i2c_algo_bit_data i2c_algo;
struct i2c_adapter i2c_adap;
struct i2c_client i2c_client;
u32 i2c_state;
u32 i2c_done;
wait_queue_head_t i2c_queue;
int i2c_rc;
unsigned char eedata[256];
/* video+ts+vbi capture */
struct tw68_dmaqueue video_q;
struct tw68_dmaqueue vbi_q;
unsigned int video_fieldcount;
unsigned int vbi_fieldcount;
/* video capture */
const struct tw68_format *fmt;
unsigned width, height;
unsigned seqnr;
unsigned field;
struct vb2_queue vidq;
struct list_head active;
/* various v4l controls */
struct tw68_tvnorm *tvnorm; /* video */
struct tw68_tvaudio *tvaudio;
#if 0
unsigned int ctl_input;
int ctl_bright;
int ctl_contrast;
int ctl_hue;
int ctl_saturation;
int ctl_freq;
int ctl_mute; /* audio */
int ctl_volume;
int ctl_invert; /* private */
int ctl_mirror;
int ctl_y_odd;
int ctl_y_even;
int ctl_automute;
#endif
/* crop */
struct v4l2_rect crop_bounds;
struct v4l2_rect crop_defrect;
struct v4l2_rect crop_current;
/* other global state info */
unsigned int automute;
struct tw68_thread thread;
/* input is latest requested by app, hw_input is current hw setting */
struct tw68_input *input;
struct tw68_input *hw_input;
unsigned int hw_mute;
int last_carrier;
int nosignal;
unsigned int insuspend;
/* TW68_MPEG_* */
struct tw68_ts ts;
struct tw68_dmaqueue ts_q;
enum tw68_ts_status ts_state;
unsigned int buff_cnt;
struct tw68_mpeg_ops *mops;
void (*gate_ctrl)(struct tw68_dev *dev, int open);
const struct tw68_tvnorm *tvnorm; /* video */
int input;
};
/* ----------------------------------------------------------- */
......@@ -473,116 +209,23 @@ struct tw68_dev {
#define tw_clearb(reg, bit) \
writeb((readb(dev->bmmio+(reg)) & ~(bit)), \
dev->bmmio + (reg))
#define tw_call_all(dev, o, f, args...) do { \
if (dev->gate_ctrl) \
dev->gate_ctrl(dev, 1); \
v4l2_device_call_all(&(dev)->v4l2_dev, 0, o, f , ##args); \
if (dev->gate_ctrl) \
dev->gate_ctrl(dev, 0); \
} while (0)
#define tw_wait(us) { udelay(us); }
static inline struct tw68_dev *to_tw68_dev(struct v4l2_device *v4l2_dev)
{
return container_of(v4l2_dev, struct tw68_dev, v4l2_dev);
}
/* ----------------------------------------------------------- */
/* tw68-core.c */
extern struct list_head tw68_devlist;
extern struct mutex tw68_devlist_lock;
extern unsigned int irq_debug;
int tw68_buffer_count(unsigned int size, unsigned int count);
void tw68_buffer_queue(struct tw68_dev *dev, struct tw68_dmaqueue *q,
struct tw68_buf *buf);
void tw68_buffer_timeout(unsigned long data);
int tw68_set_dmabits(struct tw68_dev *dev);
void tw68_dma_free(struct videobuf_queue *q, struct tw68_buf *buf);
void tw68_wakeup(struct tw68_dmaqueue *q, unsigned int *field_count);
int tw68_buffer_requeue(struct tw68_dev *dev, struct tw68_dmaqueue *q);
/* ----------------------------------------------------------- */
/* tw68-cards.c */
extern struct tw68_board tw68_boards[];
extern const unsigned int tw68_bcount;
extern struct pci_device_id __devinitdata tw68_pci_tbl[];
int tw68_board_init1(struct tw68_dev *dev);
int tw68_board_init2(struct tw68_dev *dev);
int tw68_tuner_callback(void *priv, int component, int command, int arg);
/* ----------------------------------------------------------- */
/* tw68-i2c.c */
int tw68_i2c_register(struct tw68_dev *dev);
int tw68_i2c_unregister(struct tw68_dev *dev);
void tw68_irq_i2c(struct tw68_dev *dev, int status);
/* ----------------------------------------------------------- */
/* tw68-video.c */
extern unsigned int video_debug;
extern struct video_device tw68_video_template;
extern struct video_device tw68_radio_template;
int tw68_videoport_init(struct tw68_dev *dev);
void tw68_set_tvnorm_hw(struct tw68_dev *dev);
int tw68_video_init1(struct tw68_dev *dev);
int tw68_video_init2(struct tw68_dev *dev);
void tw68_irq_video_signalchange(struct tw68_dev *dev);
int tw68_video_init2(struct tw68_dev *dev, int video_nr);
void tw68_irq_video_done(struct tw68_dev *dev, unsigned long status);
/* ----------------------------------------------------------- */
/* tw68-ts.c */
int tw68_ts_init1(struct tw68_dev *dev);
int tw68_ts_fini(struct tw68_dev *dev);
void tw68_irq_ts_done(struct tw68_dev *dev, unsigned long status);
int tw68_ts_register(struct tw68_mpeg_ops *ops);
void tw68_ts_unregister(struct tw68_mpeg_ops *ops);
int tw68_ts_init_hw(struct tw68_dev *dev);
/* ----------------------------------------------------------- */
/* tw68-vbi.c */
extern struct videobuf_queue_ops tw68_vbi_qops;
extern struct video_device tw68_vbi_template;
int tw68_vbi_init1(struct tw68_dev *dev);
int tw68_vbi_fini(struct tw68_dev *dev);
void tw68_irq_vbi_done(struct tw68_dev *dev, unsigned long status);
/* ----------------------------------------------------------- */
/* tw68-tvaudio.c */
int tw68_tvaudio_rx2mode(u32 rx);
void tw68_tvaudio_setmute(struct tw68_dev *dev);
void tw68_tvaudio_setinput(struct tw68_dev *dev,
struct tw68_input *in);
void tw68_tvaudio_setvolume(struct tw68_dev *dev, int level);
int tw68_tvaudio_getstereo(struct tw68_dev *dev);
void tw68_tvaudio_init(struct tw68_dev *dev);
int tw68_tvaudio_init2(struct tw68_dev *dev);
int tw68_tvaudio_fini(struct tw68_dev *dev);
int tw68_tvaudio_do_scan(struct tw68_dev *dev);
int tw_dsp_writel(struct tw68_dev *dev, int reg, u32 value);
void tw68_enable_i2s(struct tw68_dev *dev);
int tw68_video_start_dma(struct tw68_dev *dev, struct tw68_buf *buf);
/* ----------------------------------------------------------- */
/* tw68-risc.c */
int tw68_risc_buffer(struct pci_dev *pci, struct btcx_riscmem *risc,
int tw68_risc_buffer(struct pci_dev *pci, struct tw68_buf *buf,
struct scatterlist *sglist, unsigned int top_offset,
unsigned int bottom_offset, unsigned int bpl,
unsigned int padding, unsigned int lines);
int tw68_risc_stopper(struct pci_dev *pci, struct btcx_riscmem *risc);
int tw68_risc_overlay(struct tw68_fh *fh, struct btcx_riscmem *risc,
int field_type);
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或