[PATCH] v4l: 886: renamed common structures to em28xx
- Renamed common structures to em28xx Signed-off-by: Mauro Carvalho Chehab <mchehab@brturbo.com.br> Signed-off-by: Andrew Morton <akpm@osdl.org> Signed-off-by: Linus Torvalds <torvalds@osdl.org>
This commit is contained in:
Mauro Carvalho Chehab
Linus Torvalds
parent
e0ec29b7e5
commit
3acf280950
|
|
@ -34,7 +34,7 @@
|
|||
|
||||
#include "em28xx.h"
|
||||
|
||||
struct em2820_board em2820_boards[] = {
|
||||
struct em28xx_board em28xx_boards[] = {
|
||||
[EM2800_BOARD_UNKNOWN] = {
|
||||
.name = "Unknown EM2800 video grabber",
|
||||
.is_em2800 = 1,
|
||||
|
|
@ -42,13 +42,13 @@ struct em2820_board em2820_boards[] = {
|
|||
.norm = VIDEO_MODE_PAL,
|
||||
.tda9887_conf = TDA9887_PRESENT,
|
||||
.has_tuner = 1,
|
||||
.decoder = EM2820_SAA7113,
|
||||
.decoder = EM28XX_SAA7113,
|
||||
.input = {{
|
||||
.type = EM2820_VMUX_COMPOSITE1,
|
||||
.type = EM28XX_VMUX_COMPOSITE1,
|
||||
.vmux = 0,
|
||||
.amux = 1,
|
||||
},{
|
||||
.type = EM2820_VMUX_SVIDEO,
|
||||
.type = EM28XX_VMUX_SVIDEO,
|
||||
.vmux = 9,
|
||||
.amux = 1,
|
||||
}},
|
||||
|
|
@ -60,13 +60,13 @@ struct em2820_board em2820_boards[] = {
|
|||
.norm = VIDEO_MODE_PAL,
|
||||
.tda9887_conf = TDA9887_PRESENT,
|
||||
.has_tuner = 1,
|
||||
.decoder = EM2820_SAA7113,
|
||||
.decoder = EM28XX_SAA7113,
|
||||
.input = {{
|
||||
.type = EM2820_VMUX_COMPOSITE1,
|
||||
.type = EM28XX_VMUX_COMPOSITE1,
|
||||
.vmux = 0,
|
||||
.amux = 1,
|
||||
},{
|
||||
.type = EM2820_VMUX_SVIDEO,
|
||||
.type = EM28XX_VMUX_SVIDEO,
|
||||
.vmux = 9,
|
||||
.amux = 1,
|
||||
}},
|
||||
|
|
@ -78,17 +78,17 @@ struct em2820_board em2820_boards[] = {
|
|||
.tuner_type = TUNER_LG_PAL_NEW_TAPC,
|
||||
.tda9887_conf = TDA9887_PRESENT,
|
||||
.has_tuner = 1,
|
||||
.decoder = EM2820_SAA7113,
|
||||
.decoder = EM28XX_SAA7113,
|
||||
.input = {{
|
||||
.type = EM2820_VMUX_TELEVISION,
|
||||
.type = EM28XX_VMUX_TELEVISION,
|
||||
.vmux = 2,
|
||||
.amux = 0,
|
||||
},{
|
||||
.type = EM2820_VMUX_COMPOSITE1,
|
||||
.type = EM28XX_VMUX_COMPOSITE1,
|
||||
.vmux = 0,
|
||||
.amux = 1,
|
||||
},{
|
||||
.type = EM2820_VMUX_SVIDEO,
|
||||
.type = EM28XX_VMUX_SVIDEO,
|
||||
.vmux = 9,
|
||||
.amux = 1,
|
||||
}},
|
||||
|
|
@ -100,17 +100,17 @@ struct em2820_board em2820_boards[] = {
|
|||
.tuner_type = TUNER_LG_PAL_NEW_TAPC,
|
||||
.tda9887_conf = TDA9887_PRESENT,
|
||||
.has_tuner = 1,
|
||||
.decoder = EM2820_SAA7113,
|
||||
.decoder = EM28XX_SAA7113,
|
||||
.input = {{
|
||||
.type = EM2820_VMUX_TELEVISION,
|
||||
.type = EM28XX_VMUX_TELEVISION,
|
||||
.vmux = 2,
|
||||
.amux = 0,
|
||||
},{
|
||||
.type = EM2820_VMUX_COMPOSITE1,
|
||||
.type = EM28XX_VMUX_COMPOSITE1,
|
||||
.vmux = 0,
|
||||
.amux = 1,
|
||||
},{
|
||||
.type = EM2820_VMUX_SVIDEO,
|
||||
.type = EM28XX_VMUX_SVIDEO,
|
||||
.vmux = 9,
|
||||
.amux = 1,
|
||||
}},
|
||||
|
|
@ -122,15 +122,15 @@ struct em2820_board em2820_boards[] = {
|
|||
.tuner_type = TUNER_PHILIPS_FM1236_MK3,
|
||||
.tda9887_conf = TDA9887_PRESENT|TDA9887_PORT1_ACTIVE|TDA9887_PORT2_ACTIVE,
|
||||
.has_tuner = 1,
|
||||
.decoder = EM2820_TVP5150,
|
||||
.decoder = EM28XX_TVP5150,
|
||||
.has_msp34xx = 1,
|
||||
/*FIXME: S-Video not tested */
|
||||
.input = {{
|
||||
.type = EM2820_VMUX_TELEVISION,
|
||||
.type = EM28XX_VMUX_TELEVISION,
|
||||
.vmux = 0,
|
||||
.amux = 0,
|
||||
},{
|
||||
.type = EM2820_VMUX_SVIDEO,
|
||||
.type = EM28XX_VMUX_SVIDEO,
|
||||
.vmux = 2,
|
||||
.amux = 1,
|
||||
}},
|
||||
|
|
@ -142,17 +142,17 @@ struct em2820_board em2820_boards[] = {
|
|||
.tuner_type = TUNER_LG_PAL_NEW_TAPC,
|
||||
.tda9887_conf = TDA9887_PRESENT|TDA9887_PORT1_ACTIVE|TDA9887_PORT2_ACTIVE,
|
||||
.has_tuner = 1,
|
||||
.decoder = EM2820_SAA7114,
|
||||
.decoder = EM28XX_SAA7114,
|
||||
.input = {{
|
||||
.type = EM2820_VMUX_TELEVISION,
|
||||
.type = EM28XX_VMUX_TELEVISION,
|
||||
.vmux = 4,
|
||||
.amux = 0,
|
||||
},{
|
||||
.type = EM2820_VMUX_COMPOSITE1,
|
||||
.type = EM28XX_VMUX_COMPOSITE1,
|
||||
.vmux = 0,
|
||||
.amux = 1,
|
||||
},{
|
||||
.type = EM2820_VMUX_SVIDEO,
|
||||
.type = EM28XX_VMUX_SVIDEO,
|
||||
.vmux = 9,
|
||||
.amux = 1,
|
||||
}},
|
||||
|
|
@ -165,17 +165,17 @@ struct em2820_board em2820_boards[] = {
|
|||
.tuner_type = TUNER_LG_PAL_NEW_TAPC,
|
||||
.tda9887_conf = TDA9887_PRESENT,
|
||||
.has_tuner = 1,
|
||||
.decoder = EM2820_SAA7113,
|
||||
.decoder = EM28XX_SAA7113,
|
||||
.input = {{
|
||||
.type = EM2820_VMUX_TELEVISION,
|
||||
.type = EM28XX_VMUX_TELEVISION,
|
||||
.vmux = 2,
|
||||
.amux = 0,
|
||||
},{
|
||||
.type = EM2820_VMUX_COMPOSITE1,
|
||||
.type = EM28XX_VMUX_COMPOSITE1,
|
||||
.vmux = 0,
|
||||
.amux = 1,
|
||||
},{
|
||||
.type = EM2820_VMUX_SVIDEO,
|
||||
.type = EM28XX_VMUX_SVIDEO,
|
||||
.vmux = 9,
|
||||
.amux = 1,
|
||||
}},
|
||||
|
|
@ -188,17 +188,17 @@ struct em2820_board em2820_boards[] = {
|
|||
.tuner_type = TUNER_LG_PAL_NEW_TAPC,
|
||||
.tda9887_conf = TDA9887_PRESENT,
|
||||
.has_tuner = 1,
|
||||
.decoder = EM2820_SAA7113,
|
||||
.decoder = EM28XX_SAA7113,
|
||||
.input = {{
|
||||
.type = EM2820_VMUX_TELEVISION,
|
||||
.type = EM28XX_VMUX_TELEVISION,
|
||||
.vmux = 2,
|
||||
.amux = 0,
|
||||
},{
|
||||
.type = EM2820_VMUX_COMPOSITE1,
|
||||
.type = EM28XX_VMUX_COMPOSITE1,
|
||||
.vmux = 0,
|
||||
.amux = 1,
|
||||
},{
|
||||
.type = EM2820_VMUX_SVIDEO,
|
||||
.type = EM28XX_VMUX_SVIDEO,
|
||||
.vmux = 9,
|
||||
.amux = 1,
|
||||
}},
|
||||
|
|
@ -211,17 +211,17 @@ struct em2820_board em2820_boards[] = {
|
|||
.tuner_type = TUNER_PHILIPS_ATSC,
|
||||
.tda9887_conf = TDA9887_PRESENT,
|
||||
.has_tuner = 1,
|
||||
.decoder = EM2820_SAA7113,
|
||||
.decoder = EM28XX_SAA7113,
|
||||
.input = {{
|
||||
.type = EM2820_VMUX_TELEVISION,
|
||||
.type = EM28XX_VMUX_TELEVISION,
|
||||
.vmux = 2,
|
||||
.amux = 0,
|
||||
},{
|
||||
.type = EM2820_VMUX_COMPOSITE1,
|
||||
.type = EM28XX_VMUX_COMPOSITE1,
|
||||
.vmux = 0,
|
||||
.amux = 1,
|
||||
},{
|
||||
.type = EM2820_VMUX_SVIDEO,
|
||||
.type = EM28XX_VMUX_SVIDEO,
|
||||
.vmux = 9,
|
||||
.amux = 1,
|
||||
}},
|
||||
|
|
@ -231,22 +231,22 @@ struct em2820_board em2820_boards[] = {
|
|||
.vchannels = 3,
|
||||
.norm = VIDEO_MODE_PAL,
|
||||
.has_tuner = 0,
|
||||
.decoder = EM2820_SAA7113,
|
||||
.decoder = EM28XX_SAA7113,
|
||||
.input = {{
|
||||
.type = EM2820_VMUX_COMPOSITE1,
|
||||
.type = EM28XX_VMUX_COMPOSITE1,
|
||||
.vmux = 0,
|
||||
.amux = 1,
|
||||
},{
|
||||
.type = EM2820_VMUX_SVIDEO,
|
||||
.type = EM28XX_VMUX_SVIDEO,
|
||||
.vmux = 9,
|
||||
.amux = 1,
|
||||
}},
|
||||
},
|
||||
};
|
||||
const unsigned int em2820_bcount = ARRAY_SIZE(em2820_boards);
|
||||
const unsigned int em28xx_bcount = ARRAY_SIZE(em28xx_boards);
|
||||
|
||||
/* table of devices that work with this driver */
|
||||
struct usb_device_id em2820_id_table [] = {
|
||||
struct usb_device_id em28xx_id_table [] = {
|
||||
{ USB_DEVICE(0xeb1a, 0x2800), .driver_info = EM2800_BOARD_UNKNOWN },
|
||||
{ USB_DEVICE(0xeb1a, 0x2820), .driver_info = EM2820_BOARD_MSI_VOX_USB_2 },
|
||||
{ USB_DEVICE(0x0ccd, 0x0036), .driver_info = EM2820_BOARD_TERRATEC_CINERGY_250 },
|
||||
|
|
@ -256,7 +256,7 @@ struct usb_device_id em2820_id_table [] = {
|
|||
{ },
|
||||
};
|
||||
|
||||
void em2820_card_setup(struct em2820 *dev)
|
||||
void em28xx_card_setup(struct em28xx *dev)
|
||||
{
|
||||
/* request some modules */
|
||||
if (dev->model == EM2820_BOARD_HAUPPAUGE_WINTV_USB_2) {
|
||||
|
|
@ -274,14 +274,14 @@ void em2820_card_setup(struct em2820 *dev)
|
|||
if (tv.audio_processor == AUDIO_CHIP_MSP34XX) {
|
||||
dev->has_msp34xx=1;
|
||||
} else dev->has_msp34xx=0;
|
||||
em2820_write_regs_req(dev,0x06,0x00,"\x40",1);// Serial Bus Frequency Select Register
|
||||
em2820_write_regs_req(dev,0x0f,0x00,"\x87",1);// XCLK Frequency Select Register
|
||||
em2820_write_regs_req(dev,0x88,0x0d,"\xd0",1);
|
||||
em28xx_write_regs_req(dev,0x06,0x00,"\x40",1);// Serial Bus Frequency Select Register
|
||||
em28xx_write_regs_req(dev,0x0f,0x00,"\x87",1);// XCLK Frequency Select Register
|
||||
em28xx_write_regs_req(dev,0x88,0x0d,"\xd0",1);
|
||||
}
|
||||
}
|
||||
|
||||
EXPORT_SYMBOL(em2820_boards);
|
||||
EXPORT_SYMBOL(em2820_bcount);
|
||||
EXPORT_SYMBOL(em2820_id_table);
|
||||
EXPORT_SYMBOL(em28xx_boards);
|
||||
EXPORT_SYMBOL(em28xx_bcount);
|
||||
EXPORT_SYMBOL(em28xx_id_table);
|
||||
|
||||
MODULE_DEVICE_TABLE (usb, em2820_id_table);
|
||||
MODULE_DEVICE_TABLE (usb, em28xx_id_table);
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
em2820-core.c - driver for Empia EM2800/EM2820/2840 USB video capture devices
|
||||
em28xx-core.c - driver for Empia EM2800/EM2820/2840 USB video capture devices
|
||||
|
||||
Copyright (C) 2005 Ludovico Cavedon <cavedon@sssup.it>
|
||||
Markus Rechberger <mrechberger@gmail.com>
|
||||
|
|
@ -36,7 +36,7 @@ unsigned int core_debug;
|
|||
module_param(core_debug,int,0644);
|
||||
MODULE_PARM_DESC(core_debug,"enable debug messages [core]");
|
||||
|
||||
#define em2820_coredbg(fmt, arg...) do {\
|
||||
#define em28xx_coredbg(fmt, arg...) do {\
|
||||
if (core_debug) \
|
||||
printk(KERN_INFO "%s %s :"fmt, \
|
||||
dev->name, __FUNCTION__ , ##arg); } while (0)
|
||||
|
|
@ -45,7 +45,7 @@ unsigned int reg_debug;
|
|||
module_param(reg_debug,int,0644);
|
||||
MODULE_PARM_DESC(reg_debug,"enable debug messages [URB reg]");
|
||||
|
||||
#define em2820_regdbg(fmt, arg...) do {\
|
||||
#define em28xx_regdbg(fmt, arg...) do {\
|
||||
if (reg_debug) \
|
||||
printk(KERN_INFO "%s %s :"fmt, \
|
||||
dev->name, __FUNCTION__ , ##arg); } while (0)
|
||||
|
|
@ -54,12 +54,12 @@ unsigned int isoc_debug;
|
|||
module_param(isoc_debug,int,0644);
|
||||
MODULE_PARM_DESC(isoc_debug,"enable debug messages [isoc transfers]");
|
||||
|
||||
#define em2820_isocdbg(fmt, arg...) do {\
|
||||
#define em28xx_isocdbg(fmt, arg...) do {\
|
||||
if (isoc_debug) \
|
||||
printk(KERN_INFO "%s %s :"fmt, \
|
||||
dev->name, __FUNCTION__ , ##arg); } while (0)
|
||||
|
||||
static int alt = EM2820_PINOUT;
|
||||
static int alt = EM28XX_PINOUT;
|
||||
module_param(alt, int, 0644);
|
||||
MODULE_PARM_DESC(alt, "alternate setting to use for video endpoint");
|
||||
|
||||
|
|
@ -88,7 +88,7 @@ static const char *v4l2_ioctls[] = {
|
|||
};
|
||||
#define V4L2_IOCTLS ARRAY_SIZE(v4l2_ioctls)
|
||||
|
||||
void em2820_print_ioctl(char *name, unsigned int cmd)
|
||||
void em28xx_print_ioctl(char *name, unsigned int cmd)
|
||||
{
|
||||
char *dir;
|
||||
|
||||
|
|
@ -159,17 +159,17 @@ static void rvfree(void *mem, size_t size)
|
|||
}
|
||||
|
||||
/*
|
||||
* em2820_request_buffers()
|
||||
* em28xx_request_buffers()
|
||||
* allocate a number of buffers
|
||||
*/
|
||||
u32 em2820_request_buffers(struct em2820 *dev, u32 count)
|
||||
u32 em28xx_request_buffers(struct em28xx *dev, u32 count)
|
||||
{
|
||||
const size_t imagesize = PAGE_ALIGN(dev->frame_size); /*needs to be page aligned cause the buffers can be mapped individually! */
|
||||
void *buff = NULL;
|
||||
u32 i;
|
||||
em2820_coredbg("requested %i buffers with size %i", count, imagesize);
|
||||
if (count > EM2820_NUM_FRAMES)
|
||||
count = EM2820_NUM_FRAMES;
|
||||
em28xx_coredbg("requested %i buffers with size %i", count, imagesize);
|
||||
if (count > EM28XX_NUM_FRAMES)
|
||||
count = EM28XX_NUM_FRAMES;
|
||||
|
||||
dev->num_frames = count;
|
||||
while (dev->num_frames > 0) {
|
||||
|
|
@ -193,10 +193,10 @@ u32 em2820_request_buffers(struct em2820 *dev, u32 count)
|
|||
}
|
||||
|
||||
/*
|
||||
* em2820_queue_unusedframes()
|
||||
* em28xx_queue_unusedframes()
|
||||
* add all frames that are not currently in use to the inbuffer queue
|
||||
*/
|
||||
void em2820_queue_unusedframes(struct em2820 *dev)
|
||||
void em28xx_queue_unusedframes(struct em28xx *dev)
|
||||
{
|
||||
unsigned long lock_flags;
|
||||
u32 i;
|
||||
|
|
@ -211,10 +211,10 @@ void em2820_queue_unusedframes(struct em2820 *dev)
|
|||
}
|
||||
|
||||
/*
|
||||
* em2820_release_buffers()
|
||||
* em28xx_release_buffers()
|
||||
* free frame buffers
|
||||
*/
|
||||
void em2820_release_buffers(struct em2820 *dev)
|
||||
void em28xx_release_buffers(struct em28xx *dev)
|
||||
{
|
||||
if (dev->num_frames) {
|
||||
rvfree(dev->frame[0].bufmem,
|
||||
|
|
@ -224,15 +224,15 @@ void em2820_release_buffers(struct em2820 *dev)
|
|||
}
|
||||
|
||||
/*
|
||||
* em2820_read_reg_req()
|
||||
* em28xx_read_reg_req()
|
||||
* reads data from the usb device specifying bRequest
|
||||
*/
|
||||
int em2820_read_reg_req_len(struct em2820 *dev, u8 req, u16 reg,
|
||||
int em28xx_read_reg_req_len(struct em28xx *dev, u8 req, u16 reg,
|
||||
char *buf, int len)
|
||||
{
|
||||
int ret, byte;
|
||||
|
||||
em2820_regdbg("req=%02x, reg=%02x ", req, reg);
|
||||
em28xx_regdbg("req=%02x, reg=%02x ", req, reg);
|
||||
|
||||
ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0), req,
|
||||
USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
|
||||
|
|
@ -250,15 +250,15 @@ int em2820_read_reg_req_len(struct em2820 *dev, u8 req, u16 reg,
|
|||
}
|
||||
|
||||
/*
|
||||
* em2820_read_reg_req()
|
||||
* em28xx_read_reg_req()
|
||||
* reads data from the usb device specifying bRequest
|
||||
*/
|
||||
int em2820_read_reg_req(struct em2820 *dev, u8 req, u16 reg)
|
||||
int em28xx_read_reg_req(struct em28xx *dev, u8 req, u16 reg)
|
||||
{
|
||||
u8 val;
|
||||
int ret;
|
||||
|
||||
em2820_regdbg("req=%02x, reg=%02x:", req, reg);
|
||||
em28xx_regdbg("req=%02x, reg=%02x:", req, reg);
|
||||
|
||||
ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0), req,
|
||||
USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
|
||||
|
|
@ -273,16 +273,16 @@ int em2820_read_reg_req(struct em2820 *dev, u8 req, u16 reg)
|
|||
return val;
|
||||
}
|
||||
|
||||
int em2820_read_reg(struct em2820 *dev, u16 reg)
|
||||
int em28xx_read_reg(struct em28xx *dev, u16 reg)
|
||||
{
|
||||
return em2820_read_reg_req(dev, USB_REQ_GET_STATUS, reg);
|
||||
return em28xx_read_reg_req(dev, USB_REQ_GET_STATUS, reg);
|
||||
}
|
||||
|
||||
/*
|
||||
* em2820_write_regs_req()
|
||||
* em28xx_write_regs_req()
|
||||
* sends data to the usb device, specifying bRequest
|
||||
*/
|
||||
int em2820_write_regs_req(struct em2820 *dev, u8 req, u16 reg, char *buf,
|
||||
int em28xx_write_regs_req(struct em28xx *dev, u8 req, u16 reg, char *buf,
|
||||
int len)
|
||||
{
|
||||
int ret;
|
||||
|
|
@ -290,7 +290,7 @@ int em2820_write_regs_req(struct em2820 *dev, u8 req, u16 reg, char *buf,
|
|||
/*usb_control_msg seems to expect a kmalloced buffer */
|
||||
unsigned char *bufs = kmalloc(len, GFP_KERNEL);
|
||||
|
||||
em2820_regdbg("req=%02x reg=%02x:", req, reg);
|
||||
em28xx_regdbg("req=%02x reg=%02x:", req, reg);
|
||||
|
||||
if (reg_debug) {
|
||||
int i;
|
||||
|
|
@ -310,124 +310,124 @@ int em2820_write_regs_req(struct em2820 *dev, u8 req, u16 reg, char *buf,
|
|||
return ret;
|
||||
}
|
||||
|
||||
int em2820_write_regs(struct em2820 *dev, u16 reg, char *buf, int len)
|
||||
int em28xx_write_regs(struct em28xx *dev, u16 reg, char *buf, int len)
|
||||
{
|
||||
return em2820_write_regs_req(dev, USB_REQ_GET_STATUS, reg, buf, len);
|
||||
return em28xx_write_regs_req(dev, USB_REQ_GET_STATUS, reg, buf, len);
|
||||
}
|
||||
|
||||
/*
|
||||
* em2820_write_reg_bits()
|
||||
* em28xx_write_reg_bits()
|
||||
* sets only some bits (specified by bitmask) of a register, by first reading
|
||||
* the actual value
|
||||
*/
|
||||
int em2820_write_reg_bits(struct em2820 *dev, u16 reg, u8 val,
|
||||
int em28xx_write_reg_bits(struct em28xx *dev, u16 reg, u8 val,
|
||||
u8 bitmask)
|
||||
{
|
||||
int oldval;
|
||||
u8 newval;
|
||||
if ((oldval = em2820_read_reg(dev, reg)) < 0)
|
||||
if ((oldval = em28xx_read_reg(dev, reg)) < 0)
|
||||
return oldval;
|
||||
newval = (((u8) oldval) & ~bitmask) | (val & bitmask);
|
||||
return em2820_write_regs(dev, reg, &newval, 1);
|
||||
return em28xx_write_regs(dev, reg, &newval, 1);
|
||||
}
|
||||
|
||||
/*
|
||||
* em2820_write_ac97()
|
||||
* em28xx_write_ac97()
|
||||
* write a 16 bit value to the specified AC97 address (LSB first!)
|
||||
*/
|
||||
int em2820_write_ac97(struct em2820 *dev, u8 reg, u8 * val)
|
||||
int em28xx_write_ac97(struct em28xx *dev, u8 reg, u8 * val)
|
||||
{
|
||||
int ret;
|
||||
u8 addr = reg & 0x7f;
|
||||
if ((ret = em2820_write_regs(dev, AC97LSB_REG, val, 2)) < 0)
|
||||
if ((ret = em28xx_write_regs(dev, AC97LSB_REG, val, 2)) < 0)
|
||||
return ret;
|
||||
if ((ret = em2820_write_regs(dev, AC97ADDR_REG, &addr, 1)) < 0)
|
||||
if ((ret = em28xx_write_regs(dev, AC97ADDR_REG, &addr, 1)) < 0)
|
||||
return ret;
|
||||
if ((ret = em2820_read_reg(dev, AC97BUSY_REG)) < 0)
|
||||
if ((ret = em28xx_read_reg(dev, AC97BUSY_REG)) < 0)
|
||||
return ret;
|
||||
else if (((u8) ret) & 0x01) {
|
||||
em2820_warn ("AC97 command still being exectuted: not handled properly!\n");
|
||||
em28xx_warn ("AC97 command still being exectuted: not handled properly!\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int em2820_audio_analog_set(struct em2820 *dev)
|
||||
int em28xx_audio_analog_set(struct em28xx *dev)
|
||||
{
|
||||
char s[2] = { 0x00, 0x00 };
|
||||
s[0] |= 0x1f - dev->volume;
|
||||
s[1] |= 0x1f - dev->volume;
|
||||
if (dev->mute)
|
||||
s[1] |= 0x80;
|
||||
return em2820_write_ac97(dev, MASTER_AC97, s);
|
||||
return em28xx_write_ac97(dev, MASTER_AC97, s);
|
||||
}
|
||||
|
||||
|
||||
int em2820_colorlevels_set_default(struct em2820 *dev)
|
||||
int em28xx_colorlevels_set_default(struct em28xx *dev)
|
||||
{
|
||||
em2820_write_regs(dev, YGAIN_REG, "\x10", 1); /* contrast */
|
||||
em2820_write_regs(dev, YOFFSET_REG, "\x00", 1); /* brightness */
|
||||
em2820_write_regs(dev, UVGAIN_REG, "\x10", 1); /* saturation */
|
||||
em2820_write_regs(dev, UOFFSET_REG, "\x00", 1);
|
||||
em2820_write_regs(dev, VOFFSET_REG, "\x00", 1);
|
||||
em2820_write_regs(dev, SHARPNESS_REG, "\x00", 1);
|
||||
em28xx_write_regs(dev, YGAIN_REG, "\x10", 1); /* contrast */
|
||||
em28xx_write_regs(dev, YOFFSET_REG, "\x00", 1); /* brightness */
|
||||
em28xx_write_regs(dev, UVGAIN_REG, "\x10", 1); /* saturation */
|
||||
em28xx_write_regs(dev, UOFFSET_REG, "\x00", 1);
|
||||
em28xx_write_regs(dev, VOFFSET_REG, "\x00", 1);
|
||||
em28xx_write_regs(dev, SHARPNESS_REG, "\x00", 1);
|
||||
|
||||
em2820_write_regs(dev, GAMMA_REG, "\x20", 1);
|
||||
em2820_write_regs(dev, RGAIN_REG, "\x20", 1);
|
||||
em2820_write_regs(dev, GGAIN_REG, "\x20", 1);
|
||||
em2820_write_regs(dev, BGAIN_REG, "\x20", 1);
|
||||
em2820_write_regs(dev, ROFFSET_REG, "\x00", 1);
|
||||
em2820_write_regs(dev, GOFFSET_REG, "\x00", 1);
|
||||
return em2820_write_regs(dev, BOFFSET_REG, "\x00", 1);
|
||||
em28xx_write_regs(dev, GAMMA_REG, "\x20", 1);
|
||||
em28xx_write_regs(dev, RGAIN_REG, "\x20", 1);
|
||||
em28xx_write_regs(dev, GGAIN_REG, "\x20", 1);
|
||||
em28xx_write_regs(dev, BGAIN_REG, "\x20", 1);
|
||||
em28xx_write_regs(dev, ROFFSET_REG, "\x00", 1);
|
||||
em28xx_write_regs(dev, GOFFSET_REG, "\x00", 1);
|
||||
return em28xx_write_regs(dev, BOFFSET_REG, "\x00", 1);
|
||||
}
|
||||
|
||||
int em2820_capture_start(struct em2820 *dev, int start)
|
||||
int em28xx_capture_start(struct em28xx *dev, int start)
|
||||
{
|
||||
int ret;
|
||||
/* FIXME: which is the best order? */
|
||||
/* video registers are sampled by VREF */
|
||||
if ((ret = em2820_write_reg_bits(dev, USBSUSP_REG, start ? 0x10 : 0x00,
|
||||
if ((ret = em28xx_write_reg_bits(dev, USBSUSP_REG, start ? 0x10 : 0x00,
|
||||
0x10)) < 0)
|
||||
return ret;
|
||||
/* enable video capture */
|
||||
return em2820_write_regs(dev, VINENABLE_REG, start ? "\x67" : "\x27", 1);
|
||||
return em28xx_write_regs(dev, VINENABLE_REG, start ? "\x67" : "\x27", 1);
|
||||
}
|
||||
|
||||
int em2820_outfmt_set_yuv422(struct em2820 *dev)
|
||||
int em28xx_outfmt_set_yuv422(struct em28xx *dev)
|
||||
{
|
||||
em2820_write_regs(dev, OUTFMT_REG, "\x34", 1);
|
||||
em2820_write_regs(dev, VINMODE_REG, "\x10", 1);
|
||||
return em2820_write_regs(dev, VINCTRL_REG, "\x11", 1);
|
||||
em28xx_write_regs(dev, OUTFMT_REG, "\x34", 1);
|
||||
em28xx_write_regs(dev, VINMODE_REG, "\x10", 1);
|
||||
return em28xx_write_regs(dev, VINCTRL_REG, "\x11", 1);
|
||||
}
|
||||
|
||||
int em2820_accumulator_set(struct em2820 *dev, u8 xmin, u8 xmax, u8 ymin,
|
||||
int em28xx_accumulator_set(struct em28xx *dev, u8 xmin, u8 xmax, u8 ymin,
|
||||
u8 ymax)
|
||||
{
|
||||
em2820_coredbg("em2820 Scale: (%d,%d)-(%d,%d)\n", xmin, ymin, xmax, ymax);
|
||||
em28xx_coredbg("em28xx Scale: (%d,%d)-(%d,%d)\n", xmin, ymin, xmax, ymax);
|
||||
|
||||
em2820_write_regs(dev, XMIN_REG, &xmin, 1);
|
||||
em2820_write_regs(dev, XMAX_REG, &xmax, 1);
|
||||
em2820_write_regs(dev, YMIN_REG, &ymin, 1);
|
||||
return em2820_write_regs(dev, YMAX_REG, &ymax, 1);
|
||||
em28xx_write_regs(dev, XMIN_REG, &xmin, 1);
|
||||
em28xx_write_regs(dev, XMAX_REG, &xmax, 1);
|
||||
em28xx_write_regs(dev, YMIN_REG, &ymin, 1);
|
||||
return em28xx_write_regs(dev, YMAX_REG, &ymax, 1);
|
||||
}
|
||||
|
||||
int em2820_capture_area_set(struct em2820 *dev, u8 hstart, u8 vstart,
|
||||
int em28xx_capture_area_set(struct em28xx *dev, u8 hstart, u8 vstart,
|
||||
u16 width, u16 height)
|
||||
{
|
||||
u8 cwidth = width;
|
||||
u8 cheight = height;
|
||||
u8 overflow = (height >> 7 & 0x02) | (width >> 8 & 0x01);
|
||||
|
||||
em2820_coredbg("em2820 Area Set: (%d,%d)\n", (width | (overflow & 2) << 7),
|
||||
em28xx_coredbg("em28xx Area Set: (%d,%d)\n", (width | (overflow & 2) << 7),
|
||||
(height | (overflow & 1) << 8));
|
||||
|
||||
em2820_write_regs(dev, HSTART_REG, &hstart, 1);
|
||||
em2820_write_regs(dev, VSTART_REG, &vstart, 1);
|
||||
em2820_write_regs(dev, CWIDTH_REG, &cwidth, 1);
|
||||
em2820_write_regs(dev, CHEIGHT_REG, &cheight, 1);
|
||||
return em2820_write_regs(dev, OFLOW_REG, &overflow, 1);
|
||||
em28xx_write_regs(dev, HSTART_REG, &hstart, 1);
|
||||
em28xx_write_regs(dev, VSTART_REG, &vstart, 1);
|
||||
em28xx_write_regs(dev, CWIDTH_REG, &cwidth, 1);
|
||||
em28xx_write_regs(dev, CHEIGHT_REG, &cheight, 1);
|
||||
return em28xx_write_regs(dev, OFLOW_REG, &overflow, 1);
|
||||
}
|
||||
|
||||
int em2820_scaler_set(struct em2820 *dev, u16 h, u16 v)
|
||||
int em28xx_scaler_set(struct em28xx *dev, u16 h, u16 v)
|
||||
{
|
||||
u8 mode;
|
||||
/* the em2800 scaler only supports scaling down to 50% */
|
||||
|
|
@ -437,34 +437,34 @@ int em2820_scaler_set(struct em2820 *dev, u16 h, u16 v)
|
|||
u8 buf[2];
|
||||
buf[0] = h;
|
||||
buf[1] = h >> 8;
|
||||
em2820_write_regs(dev, HSCALELOW_REG, (char *)buf, 2);
|
||||
em28xx_write_regs(dev, HSCALELOW_REG, (char *)buf, 2);
|
||||
buf[0] = v;
|
||||
buf[1] = v >> 8;
|
||||
em2820_write_regs(dev, VSCALELOW_REG, (char *)buf, 2);
|
||||
em28xx_write_regs(dev, VSCALELOW_REG, (char *)buf, 2);
|
||||
/* it seems that both H and V scalers must be active to work correctly */
|
||||
mode = (h || v)? 0x30: 0x00;
|
||||
}
|
||||
return em2820_write_reg_bits(dev, COMPR_REG, mode, 0x30);
|
||||
return em28xx_write_reg_bits(dev, COMPR_REG, mode, 0x30);
|
||||
}
|
||||
|
||||
/* FIXME: this only function read values from dev */
|
||||
int em2820_resolution_set(struct em2820 *dev)
|
||||
int em28xx_resolution_set(struct em28xx *dev)
|
||||
{
|
||||
int width, height;
|
||||
width = norm_maxw(dev);
|
||||
height = norm_maxh(dev) >> 1;
|
||||
|
||||
em2820_outfmt_set_yuv422(dev);
|
||||
em2820_accumulator_set(dev, 1, (width - 4) >> 2, 1, (height - 4) >> 2);
|
||||
em2820_capture_area_set(dev, 0, 0, width >> 2, height >> 2);
|
||||
return em2820_scaler_set(dev, dev->hscale, dev->vscale);
|
||||
em28xx_outfmt_set_yuv422(dev);
|
||||
em28xx_accumulator_set(dev, 1, (width - 4) >> 2, 1, (height - 4) >> 2);
|
||||
em28xx_capture_area_set(dev, 0, 0, width >> 2, height >> 2);
|
||||
return em28xx_scaler_set(dev, dev->hscale, dev->vscale);
|
||||
}
|
||||
|
||||
|
||||
/******************* isoc transfer handling ****************************/
|
||||
|
||||
#ifdef ENABLE_DEBUG_ISOC_FRAMES
|
||||
static void em2820_isoc_dump(struct urb *urb, struct pt_regs *regs)
|
||||
static void em28xx_isoc_dump(struct urb *urb, struct pt_regs *regs)
|
||||
{
|
||||
int len = 0;
|
||||
int ntrans = 0;
|
||||
|
|
@ -503,7 +503,7 @@ static void em2820_isoc_dump(struct urb *urb, struct pt_regs *regs)
|
|||
}
|
||||
#endif
|
||||
|
||||
static inline int em2820_isoc_video(struct em2820 *dev,struct em2820_frame_t **f,
|
||||
static inline int em28xx_isoc_video(struct em28xx *dev,struct em28xx_frame_t **f,
|
||||
unsigned long *lock_flags, unsigned char buf)
|
||||
{
|
||||
if (!(buf & 0x01)) {
|
||||
|
|
@ -511,7 +511,7 @@ static inline int em2820_isoc_video(struct em2820 *dev,struct em2820_frame_t **f
|
|||
/*previous frame is incomplete */
|
||||
if ((*f)->fieldbytesused < dev->field_size) {
|
||||
(*f)->state = F_ERROR;
|
||||
em2820_isocdbg ("dropping incomplete bottom field (%i missing bytes)",
|
||||
em28xx_isocdbg ("dropping incomplete bottom field (%i missing bytes)",
|
||||
dev->field_size-(*f)->fieldbytesused);
|
||||
} else {
|
||||
(*f)->state = F_DONE;
|
||||
|
|
@ -524,13 +524,13 @@ static inline int em2820_isoc_video(struct em2820 *dev,struct em2820_frame_t **f
|
|||
list_move_tail(&(*f)->frame, &dev->outqueue);
|
||||
if (!list_empty(&dev->inqueue))
|
||||
(*f) = list_entry(dev-> inqueue.next,
|
||||
struct em2820_frame_t,frame);
|
||||
struct em28xx_frame_t,frame);
|
||||
else
|
||||
(*f) = NULL;
|
||||
spin_unlock_irqrestore(&dev->queue_lock,*lock_flags);
|
||||
}
|
||||
if (!(*f)) {
|
||||
em2820_isocdbg ("new frame but no buffer is free");
|
||||
em28xx_isocdbg ("new frame but no buffer is free");
|
||||
return -1;
|
||||
}
|
||||
do_gettimeofday(&(*f)->buf.timestamp);
|
||||
|
|
@ -545,10 +545,10 @@ static inline int em2820_isoc_video(struct em2820 *dev,struct em2820_frame_t **f
|
|||
if ((*f)->state == F_GRABBING) {
|
||||
if (!(*f)->top_field) {
|
||||
(*f)->state = F_ERROR;
|
||||
em2820_isocdbg ("unexpected begin of bottom field; discarding it");
|
||||
em28xx_isocdbg ("unexpected begin of bottom field; discarding it");
|
||||
} else if ((*f)-> fieldbytesused < dev->field_size - 172) {
|
||||
(*f)->state = F_ERROR;
|
||||
em2820_isocdbg ("dropping incomplete top field (%i missing bytes)",
|
||||
em28xx_isocdbg ("dropping incomplete top field (%i missing bytes)",
|
||||
dev->field_size-(*f)->fieldbytesused);
|
||||
} else {
|
||||
(*f)->top_field = 0;
|
||||
|
|
@ -559,14 +559,14 @@ static inline int em2820_isoc_video(struct em2820 *dev,struct em2820_frame_t **f
|
|||
return (0);
|
||||
}
|
||||
|
||||
static inline void em2820_isoc_video_copy(struct em2820 *dev,
|
||||
struct em2820_frame_t **f, unsigned char *buf, int len)
|
||||
static inline void em28xx_isoc_video_copy(struct em28xx *dev,
|
||||
struct em28xx_frame_t **f, unsigned char *buf, int len)
|
||||
{
|
||||
void *fieldstart, *startwrite, *startread;
|
||||
int linesdone, currlinedone, offset, lencopy,remain;
|
||||
|
||||
if(dev->frame_size != (*f)->buf.length){
|
||||
em2820_err("frame_size %i and buf.length %i are different!!!\n",dev->frame_size,(*f)->buf.length);
|
||||
em28xx_err("frame_size %i and buf.length %i are different!!!\n",dev->frame_size,(*f)->buf.length);
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -574,7 +574,7 @@ static inline void em2820_isoc_video_copy(struct em2820 *dev,
|
|||
len =dev->field_size - (*f)->fieldbytesused;
|
||||
|
||||
if (buf[0] != 0x88 && buf[0] != 0x22) {
|
||||
em2820_isocdbg("frame is not complete\n");
|
||||
em28xx_isocdbg("frame is not complete\n");
|
||||
startread = buf;
|
||||
len+=4;
|
||||
} else
|
||||
|
|
@ -613,21 +613,21 @@ static inline void em2820_isoc_video_copy(struct em2820 *dev,
|
|||
}
|
||||
|
||||
/*
|
||||
* em2820_isoIrq()
|
||||
* em28xx_isoIrq()
|
||||
* handles the incoming isoc urbs and fills the frames from our inqueue
|
||||
*/
|
||||
void em2820_isocIrq(struct urb *urb, struct pt_regs *regs)
|
||||
void em28xx_isocIrq(struct urb *urb, struct pt_regs *regs)
|
||||
{
|
||||
struct em2820 *dev = urb->context;
|
||||
struct em28xx *dev = urb->context;
|
||||
int i, status;
|
||||
struct em2820_frame_t **f;
|
||||
struct em28xx_frame_t **f;
|
||||
unsigned long lock_flags;
|
||||
|
||||
if (!dev)
|
||||
return;
|
||||
#ifdef ENABLE_DEBUG_ISOC_FRAMES
|
||||
if (isoc_debug>1)
|
||||
em2820_isoc_dump(urb, regs);
|
||||
em28xx_isoc_dump(urb, regs);
|
||||
#endif
|
||||
|
||||
if (urb->status == -ENOENT)
|
||||
|
|
@ -639,7 +639,7 @@ void em2820_isocIrq(struct urb *urb, struct pt_regs *regs)
|
|||
dev->stream = STREAM_OFF;
|
||||
if ((*f))
|
||||
(*f)->state = F_QUEUED;
|
||||
em2820_isocdbg("stream interrupted");
|
||||
em28xx_isocdbg("stream interrupted");
|
||||
wake_up_interruptible(&dev->wait_stream);
|
||||
}
|
||||
|
||||
|
|
@ -649,7 +649,7 @@ void em2820_isocIrq(struct urb *urb, struct pt_regs *regs)
|
|||
if (dev->stream == STREAM_ON && !list_empty(&dev->inqueue)) {
|
||||
if (!(*f))
|
||||
(*f) = list_entry(dev->inqueue.next,
|
||||
struct em2820_frame_t, frame);
|
||||
struct em28xx_frame_t, frame);
|
||||
|
||||
for (i = 0; i < urb->number_of_packets; i++) {
|
||||
unsigned char *buf = urb->transfer_buffer +
|
||||
|
|
@ -657,34 +657,34 @@ void em2820_isocIrq(struct urb *urb, struct pt_regs *regs)
|
|||
int len = urb->iso_frame_desc[i].actual_length - 4;
|
||||
|
||||
if (urb->iso_frame_desc[i].status) {
|
||||
em2820_isocdbg("data error: [%d] len=%d, status=%d", i,
|
||||
em28xx_isocdbg("data error: [%d] len=%d, status=%d", i,
|
||||
urb->iso_frame_desc[i].actual_length,
|
||||
urb->iso_frame_desc[i].status);
|
||||
if (urb->iso_frame_desc[i].status != -EPROTO)
|
||||
continue;
|
||||
}
|
||||
if (urb->iso_frame_desc[i].actual_length <= 0) {
|
||||
em2820_isocdbg("packet %d is empty",i);
|
||||
em28xx_isocdbg("packet %d is empty",i);
|
||||
continue;
|
||||
}
|
||||
if (urb->iso_frame_desc[i].actual_length >
|
||||
dev->max_pkt_size) {
|
||||
em2820_isocdbg("packet bigger than packet size");
|
||||
em28xx_isocdbg("packet bigger than packet size");
|
||||
continue;
|
||||
}
|
||||
/*new frame */
|
||||
if (buf[0] == 0x22 && buf[1] == 0x5a) {
|
||||
em2820_isocdbg("Video frame, length=%i!",len);
|
||||
em28xx_isocdbg("Video frame, length=%i!",len);
|
||||
|
||||
if (em2820_isoc_video(dev,f,&lock_flags,buf[2]))
|
||||
if (em28xx_isoc_video(dev,f,&lock_flags,buf[2]))
|
||||
break;
|
||||
} else if (buf[0]==0x33 && buf[1]==0x95 && buf[2]==0x00) {
|
||||
em2820_isocdbg("VBI HEADER!!!");
|
||||
em28xx_isocdbg("VBI HEADER!!!");
|
||||
}
|
||||
|
||||
/* actual copying */
|
||||
if ((*f)->state == F_GRABBING) {
|
||||
em2820_isoc_video_copy(dev,f,buf, len);
|
||||
em28xx_isoc_video_copy(dev,f,buf, len);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -696,7 +696,7 @@ void em2820_isocIrq(struct urb *urb, struct pt_regs *regs)
|
|||
|
||||
urb->status = 0;
|
||||
if ((status = usb_submit_urb(urb, GFP_ATOMIC))) {
|
||||
em2820_errdev("resubmit of urb failed (error=%i)\n", status);
|
||||
em28xx_errdev("resubmit of urb failed (error=%i)\n", status);
|
||||
dev->state |= DEV_MISCONFIGURED;
|
||||
}
|
||||
wake_up_interruptible(&dev->wait_frame);
|
||||
|
|
@ -704,58 +704,58 @@ void em2820_isocIrq(struct urb *urb, struct pt_regs *regs)
|
|||
}
|
||||
|
||||
/*
|
||||
* em2820_uninit_isoc()
|
||||
* deallocates the buffers and urbs allocated during em2820_init_iosc()
|
||||
* em28xx_uninit_isoc()
|
||||
* deallocates the buffers and urbs allocated during em28xx_init_iosc()
|
||||
*/
|
||||
void em2820_uninit_isoc(struct em2820 *dev)
|
||||
void em28xx_uninit_isoc(struct em28xx *dev)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < EM2820_NUM_BUFS; i++) {
|
||||
for (i = 0; i < EM28XX_NUM_BUFS; i++) {
|
||||
if (dev->urb[i]) {
|
||||
usb_kill_urb(dev->urb[i]);
|
||||
if (dev->transfer_buffer[i]){
|
||||
usb_buffer_free(dev->udev,(EM2820_NUM_PACKETS*dev->max_pkt_size),dev->transfer_buffer[i],dev->urb[i]->transfer_dma);
|
||||
usb_buffer_free(dev->udev,(EM28XX_NUM_PACKETS*dev->max_pkt_size),dev->transfer_buffer[i],dev->urb[i]->transfer_dma);
|
||||
}
|
||||
usb_free_urb(dev->urb[i]);
|
||||
}
|
||||
dev->urb[i] = NULL;
|
||||
dev->transfer_buffer[i] = NULL;
|
||||
}
|
||||
em2820_capture_start(dev, 0);
|
||||
em28xx_capture_start(dev, 0);
|
||||
}
|
||||
|
||||
/*
|
||||
* em2820_init_isoc()
|
||||
* em28xx_init_isoc()
|
||||
* allocates transfer buffers and submits the urbs for isoc transfer
|
||||
*/
|
||||
int em2820_init_isoc(struct em2820 *dev)
|
||||
int em28xx_init_isoc(struct em28xx *dev)
|
||||
{
|
||||
/* change interface to 3 which allowes the biggest packet sizes */
|
||||
int i, errCode;
|
||||
const int sb_size = EM2820_NUM_PACKETS * dev->max_pkt_size;
|
||||
const int sb_size = EM28XX_NUM_PACKETS * dev->max_pkt_size;
|
||||
|
||||
/* reset streaming vars */
|
||||
dev->frame_current = NULL;
|
||||
dev->frame_count = 0;
|
||||
|
||||
/* allocate urbs */
|
||||
for (i = 0; i < EM2820_NUM_BUFS; i++) {
|
||||
for (i = 0; i < EM28XX_NUM_BUFS; i++) {
|
||||
struct urb *urb;
|
||||
int j, k;
|
||||
/* allocate transfer buffer */
|
||||
urb = usb_alloc_urb(EM2820_NUM_PACKETS, GFP_KERNEL);
|
||||
urb = usb_alloc_urb(EM28XX_NUM_PACKETS, GFP_KERNEL);
|
||||
if (!urb){
|
||||
em2820_errdev("cannot alloc urb %i\n", i);
|
||||
em2820_uninit_isoc(dev);
|
||||
em28xx_errdev("cannot alloc urb %i\n", i);
|
||||
em28xx_uninit_isoc(dev);
|
||||
return -ENOMEM;
|
||||
}
|
||||
dev->transfer_buffer[i] = usb_buffer_alloc(dev->udev, sb_size, GFP_KERNEL,&urb->transfer_dma);
|
||||
if (!dev->transfer_buffer[i]) {
|
||||
em2820_errdev
|
||||
em28xx_errdev
|
||||
("unable to allocate %i bytes for transfer buffer %i\n",
|
||||
sb_size, i);
|
||||
em2820_uninit_isoc(dev);
|
||||
em28xx_uninit_isoc(dev);
|
||||
return -ENOMEM;
|
||||
}
|
||||
memset(dev->transfer_buffer[i], 0, sb_size);
|
||||
|
|
@ -765,10 +765,10 @@ int em2820_init_isoc(struct em2820 *dev)
|
|||
urb->transfer_flags = URB_ISO_ASAP;
|
||||
urb->interval = 1;
|
||||
urb->transfer_buffer = dev->transfer_buffer[i];
|
||||
urb->complete = em2820_isocIrq;
|
||||
urb->number_of_packets = EM2820_NUM_PACKETS;
|
||||
urb->complete = em28xx_isocIrq;
|
||||
urb->number_of_packets = EM28XX_NUM_PACKETS;
|
||||
urb->transfer_buffer_length = sb_size;
|
||||
for (j = k = 0; j < EM2820_NUM_PACKETS;
|
||||
for (j = k = 0; j < EM28XX_NUM_PACKETS;
|
||||
j++, k += dev->max_pkt_size) {
|
||||
urb->iso_frame_desc[j].offset = k;
|
||||
urb->iso_frame_desc[j].length =
|
||||
|
|
@ -778,12 +778,12 @@ int em2820_init_isoc(struct em2820 *dev)
|
|||
}
|
||||
|
||||
/* submit urbs */
|
||||
for (i = 0; i < EM2820_NUM_BUFS; i++) {
|
||||
for (i = 0; i < EM28XX_NUM_BUFS; i++) {
|
||||
errCode = usb_submit_urb(dev->urb[i], GFP_KERNEL);
|
||||
if (errCode) {
|
||||
em2820_errdev("submit of urb %i failed (error=%i)\n", i,
|
||||
em28xx_errdev("submit of urb %i failed (error=%i)\n", i,
|
||||
errCode);
|
||||
em2820_uninit_isoc(dev);
|
||||
em28xx_uninit_isoc(dev);
|
||||
return errCode;
|
||||
}
|
||||
}
|
||||
|
|
@ -791,21 +791,21 @@ int em2820_init_isoc(struct em2820 *dev)
|
|||
return 0;
|
||||
}
|
||||
|
||||
int em2820_set_alternate(struct em2820 *dev)
|
||||
int em28xx_set_alternate(struct em28xx *dev)
|
||||
{
|
||||
int errCode, prev_alt = dev->alt;
|
||||
dev->alt = alt;
|
||||
if (dev->alt == 0) {
|
||||
int i;
|
||||
if(dev->is_em2800){ /* always use the max packet size for em2800 based devices */
|
||||
for(i=0;i< EM2820_MAX_ALT; i++)
|
||||
for(i=0;i< EM28XX_MAX_ALT; i++)
|
||||
if(dev->alt_max_pkt_size[i]>dev->alt_max_pkt_size[dev->alt])
|
||||
dev->alt=i;
|
||||
}else{
|
||||
unsigned int min_pkt_size = dev->field_size / 137; /* FIXME: empiric magic number */
|
||||
em2820_coredbg("minimum isoc packet size: %u", min_pkt_size);
|
||||
em28xx_coredbg("minimum isoc packet size: %u", min_pkt_size);
|
||||
dev->alt = 7;
|
||||
for (i = 1; i < EM2820_MAX_ALT; i += 2) /* FIXME: skip even alternate: why do they not work? */
|
||||
for (i = 1; i < EM28XX_MAX_ALT; i += 2) /* FIXME: skip even alternate: why do they not work? */
|
||||
if (dev->alt_max_pkt_size[i] >= min_pkt_size) {
|
||||
dev->alt = i;
|
||||
break;
|
||||
|
|
@ -815,11 +815,11 @@ int em2820_set_alternate(struct em2820 *dev)
|
|||
|
||||
if (dev->alt != prev_alt) {
|
||||
dev->max_pkt_size = dev->alt_max_pkt_size[dev->alt];
|
||||
em2820_coredbg("setting alternate %d with wMaxPacketSize=%u", dev->alt,
|
||||
em28xx_coredbg("setting alternate %d with wMaxPacketSize=%u", dev->alt,
|
||||
dev->max_pkt_size);
|
||||
errCode = usb_set_interface(dev->udev, 0, dev->alt);
|
||||
if (errCode < 0) {
|
||||
em2820_errdev
|
||||
em28xx_errdev
|
||||
("cannot change alternate number to %d (error=%i)\n",
|
||||
dev->alt, errCode);
|
||||
return errCode;
|
||||
|
|
|
|||
|
|
@ -50,7 +50,7 @@ MODULE_PARM_DESC(i2c_debug, "enable debug messages [i2c]");
|
|||
* em2800_i2c_send_max4()
|
||||
* send up to 4 bytes to the i2c device
|
||||
*/
|
||||
static int em2800_i2c_send_max4(struct em2820 *dev, unsigned char addr,
|
||||
static int em2800_i2c_send_max4(struct em28xx *dev, unsigned char addr,
|
||||
char *buf, int len)
|
||||
{
|
||||
int ret;
|
||||
|
|
@ -67,19 +67,19 @@ static int em2800_i2c_send_max4(struct em2820 *dev, unsigned char addr,
|
|||
if (len > 3)
|
||||
b2[0] = buf[3];
|
||||
|
||||
ret = dev->em2820_write_regs(dev, 4 - len, &b2[4 - len], 2 + len);
|
||||
ret = dev->em28xx_write_regs(dev, 4 - len, &b2[4 - len], 2 + len);
|
||||
if (ret != 2 + len) {
|
||||
em2820_warn("writting to i2c device failed (error=%i)\n", ret);
|
||||
em28xx_warn("writting to i2c device failed (error=%i)\n", ret);
|
||||
return -EIO;
|
||||
}
|
||||
for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0;
|
||||
write_timeout -= 5) {
|
||||
ret = dev->em2820_read_reg(dev, 0x05);
|
||||
ret = dev->em28xx_read_reg(dev, 0x05);
|
||||
if (ret == 0x80 + len - 1)
|
||||
return len;
|
||||
mdelay(5);
|
||||
}
|
||||
em2820_warn("i2c write timed out\n");
|
||||
em28xx_warn("i2c write timed out\n");
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
|
|
@ -94,7 +94,7 @@ static int em2800_i2c_send_bytes(void *data, unsigned char addr, char *buf,
|
|||
int wrcount = 0;
|
||||
int count;
|
||||
int maxLen = 4;
|
||||
struct em2820 *dev = (struct em2820 *)data;
|
||||
struct em28xx *dev = (struct em28xx *)data;
|
||||
while (len > 0) {
|
||||
count = (len > maxLen) ? maxLen : len;
|
||||
ret = em2800_i2c_send_max4(dev, addr, bufPtr, count);
|
||||
|
|
@ -112,27 +112,27 @@ static int em2800_i2c_send_bytes(void *data, unsigned char addr, char *buf,
|
|||
* em2800_i2c_check_for_device()
|
||||
* check if there is a i2c_device at the supplied address
|
||||
*/
|
||||
static int em2800_i2c_check_for_device(struct em2820 *dev, unsigned char addr)
|
||||
static int em2800_i2c_check_for_device(struct em28xx *dev, unsigned char addr)
|
||||
{
|
||||
char msg;
|
||||
int ret;
|
||||
int write_timeout;
|
||||
msg = addr;
|
||||
ret = dev->em2820_write_regs(dev, 0x04, &msg, 1);
|
||||
ret = dev->em28xx_write_regs(dev, 0x04, &msg, 1);
|
||||
if (ret < 0) {
|
||||
em2820_warn("setting i2c device address failed (error=%i)\n",
|
||||
em28xx_warn("setting i2c device address failed (error=%i)\n",
|
||||
ret);
|
||||
return ret;
|
||||
}
|
||||
msg = 0x84;
|
||||
ret = dev->em2820_write_regs(dev, 0x05, &msg, 1);
|
||||
ret = dev->em28xx_write_regs(dev, 0x05, &msg, 1);
|
||||
if (ret < 0) {
|
||||
em2820_warn("preparing i2c read failed (error=%i)\n", ret);
|
||||
em28xx_warn("preparing i2c read failed (error=%i)\n", ret);
|
||||
return ret;
|
||||
}
|
||||
for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0;
|
||||
write_timeout -= 5) {
|
||||
unsigned msg = dev->em2820_read_reg(dev, 0x5);
|
||||
unsigned msg = dev->em28xx_read_reg(dev, 0x5);
|
||||
if (msg == 0x94)
|
||||
return -ENODEV;
|
||||
else if (msg == 0x84)
|
||||
|
|
@ -146,21 +146,21 @@ static int em2800_i2c_check_for_device(struct em2820 *dev, unsigned char addr)
|
|||
* em2800_i2c_recv_bytes()
|
||||
* read from the i2c device
|
||||
*/
|
||||
static int em2800_i2c_recv_bytes(struct em2820 *dev, unsigned char addr,
|
||||
static int em2800_i2c_recv_bytes(struct em28xx *dev, unsigned char addr,
|
||||
char *buf, int len)
|
||||
{
|
||||
int ret;
|
||||
/* check for the device and set i2c read address */
|
||||
ret = em2800_i2c_check_for_device(dev, addr);
|
||||
if (ret) {
|
||||
em2820_warn
|
||||
em28xx_warn
|
||||
("preparing read at i2c address 0x%x failed (error=%i)\n",
|
||||
addr, ret);
|
||||
return ret;
|
||||
}
|
||||
ret = dev->em2820_read_reg_req_len(dev, 0x0, 0x3, buf, len);
|
||||
ret = dev->em28xx_read_reg_req_len(dev, 0x0, 0x3, buf, len);
|
||||
if (ret < 0) {
|
||||
em2820_warn("reading from i2c device at 0x%x failed (error=%i)",
|
||||
em28xx_warn("reading from i2c device at 0x%x failed (error=%i)",
|
||||
addr, ret);
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -168,66 +168,66 @@ static int em2800_i2c_recv_bytes(struct em2820 *dev, unsigned char addr,
|
|||
}
|
||||
|
||||
/*
|
||||
* em2820_i2c_send_bytes()
|
||||
* em28xx_i2c_send_bytes()
|
||||
* untested for more than 4 bytes
|
||||
*/
|
||||
static int em2820_i2c_send_bytes(void *data, unsigned char addr, char *buf,
|
||||
static int em28xx_i2c_send_bytes(void *data, unsigned char addr, char *buf,
|
||||
short len, int stop)
|
||||
{
|
||||
int wrcount = 0;
|
||||
struct em2820 *dev = (struct em2820 *)data;
|
||||
struct em28xx *dev = (struct em28xx *)data;
|
||||
|
||||
wrcount = dev->em2820_write_regs_req(dev, stop ? 2 : 3, addr, buf, len);
|
||||
wrcount = dev->em28xx_write_regs_req(dev, stop ? 2 : 3, addr, buf, len);
|
||||
|
||||
return wrcount;
|
||||
}
|
||||
|
||||
/*
|
||||
* em2820_i2c_recv_bytes()
|
||||
* em28xx_i2c_recv_bytes()
|
||||
* read a byte from the i2c device
|
||||
*/
|
||||
static int em2820_i2c_recv_bytes(struct em2820 *dev, unsigned char addr,
|
||||
static int em28xx_i2c_recv_bytes(struct em28xx *dev, unsigned char addr,
|
||||
char *buf, int len)
|
||||
{
|
||||
int ret;
|
||||
ret = dev->em2820_read_reg_req_len(dev, 2, addr, buf, len);
|
||||
ret = dev->em28xx_read_reg_req_len(dev, 2, addr, buf, len);
|
||||
if (ret < 0) {
|
||||
em2820_warn("reading i2c device failed (error=%i)\n", ret);
|
||||
em28xx_warn("reading i2c device failed (error=%i)\n", ret);
|
||||
return ret;
|
||||
}
|
||||
if (dev->em2820_read_reg(dev, 0x5) != 0)
|
||||
if (dev->em28xx_read_reg(dev, 0x5) != 0)
|
||||
return -ENODEV;
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*
|
||||
* em2820_i2c_check_for_device()
|
||||
* em28xx_i2c_check_for_device()
|
||||
* check if there is a i2c_device at the supplied address
|
||||
*/
|
||||
static int em2820_i2c_check_for_device(struct em2820 *dev, unsigned char addr)
|
||||
static int em28xx_i2c_check_for_device(struct em28xx *dev, unsigned char addr)
|
||||
{
|
||||
char msg;
|
||||
int ret;
|
||||
msg = addr;
|
||||
|
||||
ret = dev->em2820_read_reg_req(dev, 2, addr);
|
||||
ret = dev->em28xx_read_reg_req(dev, 2, addr);
|
||||
if (ret < 0) {
|
||||
em2820_warn("reading from i2c device failed (error=%i)\n", ret);
|
||||
em28xx_warn("reading from i2c device failed (error=%i)\n", ret);
|
||||
return ret;
|
||||
}
|
||||
if (dev->em2820_read_reg(dev, 0x5) != 0)
|
||||
if (dev->em28xx_read_reg(dev, 0x5) != 0)
|
||||
return -ENODEV;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* em2820_i2c_xfer()
|
||||
* em28xx_i2c_xfer()
|
||||
* the main i2c transfer function
|
||||
*/
|
||||
static int em2820_i2c_xfer(struct i2c_adapter *i2c_adap,
|
||||
static int em28xx_i2c_xfer(struct i2c_adapter *i2c_adap,
|
||||
struct i2c_msg msgs[], int num)
|
||||
{
|
||||
struct em2820 *dev = i2c_adap->algo_data;
|
||||
struct em28xx *dev = i2c_adap->algo_data;
|
||||
int addr, rc, i, byte;
|
||||
|
||||
if (num <= 0)
|
||||
|
|
@ -241,7 +241,7 @@ static int em2820_i2c_xfer(struct i2c_adapter *i2c_adap,
|
|||
if (dev->is_em2800)
|
||||
rc = em2800_i2c_check_for_device(dev, addr);
|
||||
else
|
||||
rc = em2820_i2c_check_for_device(dev, addr);
|
||||
rc = em28xx_i2c_check_for_device(dev, addr);
|
||||
if (rc < 0) {
|
||||
dprintk2(2," no device\n");
|
||||
return rc;
|
||||
|
|
@ -254,7 +254,7 @@ static int em2820_i2c_xfer(struct i2c_adapter *i2c_adap,
|
|||
msgs[i].buf,
|
||||
msgs[i].len);
|
||||
else
|
||||
rc = em2820_i2c_recv_bytes(dev, addr,
|
||||
rc = em28xx_i2c_recv_bytes(dev, addr,
|
||||
msgs[i].buf,
|
||||
msgs[i].len);
|
||||
if (i2c_debug>=2) {
|
||||
|
|
@ -273,7 +273,7 @@ static int em2820_i2c_xfer(struct i2c_adapter *i2c_adap,
|
|||
msgs[i].buf,
|
||||
msgs[i].len);
|
||||
else
|
||||
rc = em2820_i2c_send_bytes(dev, addr,
|
||||
rc = em28xx_i2c_send_bytes(dev, addr,
|
||||
msgs[i].buf,
|
||||
msgs[i].len,
|
||||
i == num - 1);
|
||||
|
|
@ -290,10 +290,10 @@ static int em2820_i2c_xfer(struct i2c_adapter *i2c_adap,
|
|||
return rc;
|
||||
}
|
||||
|
||||
static int em2820_i2c_eeprom(struct em2820 *dev, unsigned char *eedata, int len)
|
||||
static int em28xx_i2c_eeprom(struct em28xx *dev, unsigned char *eedata, int len)
|
||||
{
|
||||
unsigned char buf, *p = eedata;
|
||||
struct em2820_eeprom *em_eeprom = (void *)eedata;
|
||||
struct em28xx_eeprom *em_eeprom = (void *)eedata;
|
||||
int i, err, size = len, block;
|
||||
|
||||
dev->i2c_client.addr = 0xa0 >> 1;
|
||||
|
|
@ -410,9 +410,9 @@ static void dec_use(struct i2c_adapter *adap)
|
|||
}
|
||||
#endif
|
||||
|
||||
static int em2820_set_tuner(int check_eeprom, struct i2c_client *client)
|
||||
static int em28xx_set_tuner(int check_eeprom, struct i2c_client *client)
|
||||
{
|
||||
struct em2820 *dev = client->adapter->algo_data;
|
||||
struct em28xx *dev = client->adapter->algo_data;
|
||||
struct tuner_setup tun_setup;
|
||||
|
||||
if (dev->has_tuner) {
|
||||
|
|
@ -420,7 +420,7 @@ static int em2820_set_tuner(int check_eeprom, struct i2c_client *client)
|
|||
tun_setup.type = dev->tuner_type;
|
||||
tun_setup.addr = dev->tuner_addr;
|
||||
|
||||
em2820_i2c_call_clients(dev, TUNER_SET_TYPE_ADDR, &tun_setup);
|
||||
em28xx_i2c_call_clients(dev, TUNER_SET_TYPE_ADDR, &tun_setup);
|
||||
}
|
||||
|
||||
return (0);
|
||||
|
|
@ -433,11 +433,11 @@ static int em2820_set_tuner(int check_eeprom, struct i2c_client *client)
|
|||
*/
|
||||
static int attach_inform(struct i2c_client *client)
|
||||
{
|
||||
struct em2820 *dev = client->adapter->algo_data;
|
||||
struct em28xx *dev = client->adapter->algo_data;
|
||||
|
||||
switch (client->addr << 1) {
|
||||
case 0x86:
|
||||
em2820_i2c_call_clients(dev, TDA9887_SET_CONFIG, &dev->tda9887_conf);
|
||||
em28xx_i2c_call_clients(dev, TDA9887_SET_CONFIG, &dev->tda9887_conf);
|
||||
break;
|
||||
case 0x42:
|
||||
dprintk1(1,"attach_inform: saa7114 detected.\n");
|
||||
|
|
@ -453,7 +453,7 @@ static int attach_inform(struct i2c_client *client)
|
|||
{
|
||||
struct IR_i2c *ir = i2c_get_clientdata(client);
|
||||
dprintk1(1,"attach_inform: IR detected (%s).\n",ir->phys);
|
||||
em2820_set_ir(dev,ir);
|
||||
em28xx_set_ir(dev,ir);
|
||||
break;
|
||||
}
|
||||
case 0x80:
|
||||
|
|
@ -467,19 +467,19 @@ static int attach_inform(struct i2c_client *client)
|
|||
default:
|
||||
dprintk1(1,"attach inform: detected I2C address %x\n", client->addr << 1);
|
||||
dev->tuner_addr = client->addr;
|
||||
em2820_set_tuner(-1, client);
|
||||
em28xx_set_tuner(-1, client);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct i2c_algorithm em2820_algo = {
|
||||
.master_xfer = em2820_i2c_xfer,
|
||||
static struct i2c_algorithm em28xx_algo = {
|
||||
.master_xfer = em28xx_i2c_xfer,
|
||||
.algo_control = algo_control,
|
||||
.functionality = functionality,
|
||||
};
|
||||
|
||||
static struct i2c_adapter em2820_adap_template = {
|
||||
static struct i2c_adapter em28xx_adap_template = {
|
||||
#ifdef I2C_PEC
|
||||
.owner = THIS_MODULE,
|
||||
#else
|
||||
|
|
@ -489,14 +489,14 @@ static struct i2c_adapter em2820_adap_template = {
|
|||
#ifdef I2C_CLASS_TV_ANALOG
|
||||
.class = I2C_CLASS_TV_ANALOG,
|
||||
#endif
|
||||
.name = "em2820",
|
||||
.id = I2C_HW_B_EM2820,
|
||||
.algo = &em2820_algo,
|
||||
.name = "em28xx",
|
||||
.id = I2C_HW_B_EM28XX,
|
||||
.algo = &em28xx_algo,
|
||||
.client_register = attach_inform,
|
||||
};
|
||||
|
||||
static struct i2c_client em2820_client_template = {
|
||||
.name = "em2820 internal",
|
||||
static struct i2c_client em28xx_client_template = {
|
||||
.name = "em28xx internal",
|
||||
.flags = I2C_CLIENT_ALLOW_USE,
|
||||
};
|
||||
|
||||
|
|
@ -542,33 +542,33 @@ static void do_i2c_scan(char *name, struct i2c_client *c)
|
|||
}
|
||||
|
||||
/*
|
||||
* em2820_i2c_call_clients()
|
||||
* em28xx_i2c_call_clients()
|
||||
* send commands to all attached i2c devices
|
||||
*/
|
||||
void em2820_i2c_call_clients(struct em2820 *dev, unsigned int cmd, void *arg)
|
||||
void em28xx_i2c_call_clients(struct em28xx *dev, unsigned int cmd, void *arg)
|
||||
{
|
||||
BUG_ON(NULL == dev->i2c_adap.algo_data);
|
||||
i2c_clients_command(&dev->i2c_adap, cmd, arg);
|
||||
}
|
||||
|
||||
/*
|
||||
* em2820_i2c_register()
|
||||
* em28xx_i2c_register()
|
||||
* register i2c bus
|
||||
*/
|
||||
int em2820_i2c_register(struct em2820 *dev)
|
||||
int em28xx_i2c_register(struct em28xx *dev)
|
||||
{
|
||||
BUG_ON(!dev->em2820_write_regs || !dev->em2820_read_reg);
|
||||
BUG_ON(!dev->em2820_write_regs_req || !dev->em2820_read_reg_req);
|
||||
dev->i2c_adap = em2820_adap_template;
|
||||
BUG_ON(!dev->em28xx_write_regs || !dev->em28xx_read_reg);
|
||||
BUG_ON(!dev->em28xx_write_regs_req || !dev->em28xx_read_reg_req);
|
||||
dev->i2c_adap = em28xx_adap_template;
|
||||
dev->i2c_adap.dev.parent = &dev->udev->dev;
|
||||
strcpy(dev->i2c_adap.name, dev->name);
|
||||
dev->i2c_adap.algo_data = dev;
|
||||
i2c_add_adapter(&dev->i2c_adap);
|
||||
|
||||
dev->i2c_client = em2820_client_template;
|
||||
dev->i2c_client = em28xx_client_template;
|
||||
dev->i2c_client.adapter = &dev->i2c_adap;
|
||||
|
||||
em2820_i2c_eeprom(dev, dev->eedata, sizeof(dev->eedata));
|
||||
em28xx_i2c_eeprom(dev, dev->eedata, sizeof(dev->eedata));
|
||||
|
||||
if (i2c_scan)
|
||||
do_i2c_scan(dev->name, &dev->i2c_client);
|
||||
|
|
@ -576,10 +576,10 @@ int em2820_i2c_register(struct em2820 *dev)
|
|||
}
|
||||
|
||||
/*
|
||||
* em2820_i2c_unregister()
|
||||
* em28xx_i2c_unregister()
|
||||
* unregister i2c_bus
|
||||
*/
|
||||
int em2820_i2c_unregister(struct em2820 *dev)
|
||||
int em28xx_i2c_unregister(struct em28xx *dev)
|
||||
{
|
||||
i2c_del_adapter(&dev->i2c_adap);
|
||||
return 0;
|
||||
|
|
|
|||
|
|
@ -142,7 +142,7 @@ static int get_key_em_haup(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
|
|||
}
|
||||
|
||||
/* ----------------------------------------------------------------------- */
|
||||
void em2820_set_ir(struct em2820 * dev,struct IR_i2c *ir)
|
||||
void em28xx_set_ir(struct em28xx * dev,struct IR_i2c *ir)
|
||||
{
|
||||
if (disable_ir) {
|
||||
ir->get_key=NULL;
|
||||
|
|
@ -159,7 +159,7 @@ void em2820_set_ir(struct em2820 * dev,struct IR_i2c *ir)
|
|||
case (EM2820_BOARD_TERRATEC_CINERGY_250):
|
||||
ir->ir_codes = ir_codes_em_terratec;
|
||||
ir->get_key = get_key_terratec;
|
||||
snprintf(ir->c.name, sizeof(ir->c.name), "i2c IR (EM2820 Terratec)");
|
||||
snprintf(ir->c.name, sizeof(ir->c.name), "i2c IR (EM28XX Terratec)");
|
||||
break;
|
||||
case (EM2820_BOARD_PINNACLE_USB_2):
|
||||
break;
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
em2820-cards.c - driver for Empia EM2800/EM2820/2840 USB video capture devices
|
||||
em28xx-cards.c - driver for Empia EM2800/EM2820/2840 USB video capture devices
|
||||
|
||||
Copyright (C) 2005 Markus Rechberger <mrechberger@gmail.com>
|
||||
Ludovico Cavedon <cavedon@sssup.it>
|
||||
|
|
@ -22,8 +22,8 @@
|
|||
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#ifndef _EM2820_H
|
||||
#define _EM2820_H
|
||||
#ifndef _EM28XX_H
|
||||
#define _EM28XX_H
|
||||
|
||||
#include <linux/videodev.h>
|
||||
#include <linux/i2c.h>
|
||||
|
|
@ -45,27 +45,27 @@
|
|||
#define UNSET -1
|
||||
|
||||
/* maximum number of em28xx boards */
|
||||
#define EM2820_MAXBOARDS 1 /*FIXME: should be bigger */
|
||||
#define EM28XX_MAXBOARDS 1 /*FIXME: should be bigger */
|
||||
|
||||
/* maximum number of frames that can be queued */
|
||||
#define EM2820_NUM_FRAMES 5
|
||||
#define EM28XX_NUM_FRAMES 5
|
||||
/* number of frames that get used for v4l2_read() */
|
||||
#define EM2820_NUM_READ_FRAMES 2
|
||||
#define EM28XX_NUM_READ_FRAMES 2
|
||||
|
||||
/* number of buffers for isoc transfers */
|
||||
#define EM2820_NUM_BUFS 5
|
||||
#define EM28XX_NUM_BUFS 5
|
||||
|
||||
/* number of packets for each buffer
|
||||
windows requests only 40 packets .. so we better do the same
|
||||
this is what I found out for all alternate numbers there!
|
||||
*/
|
||||
#define EM2820_NUM_PACKETS 40
|
||||
#define EM28XX_NUM_PACKETS 40
|
||||
|
||||
/* default alternate; 0 means choose the best */
|
||||
#define EM2820_PINOUT 0
|
||||
#define EM2820_MAX_ALT 7
|
||||
#define EM28XX_PINOUT 0
|
||||
#define EM28XX_MAX_ALT 7
|
||||
|
||||
#define EM2820_INTERLACED_DEFAULT 1
|
||||
#define EM28XX_INTERLACED_DEFAULT 1
|
||||
|
||||
/*
|
||||
#define (use usbview if you want to get the other alternate number infos)
|
||||
|
|
@ -89,13 +89,13 @@
|
|||
*/
|
||||
|
||||
/* time to wait when stopping the isoc transfer */
|
||||
#define EM2820_URB_TIMEOUT msecs_to_jiffies(EM2820_NUM_BUFS * EM2820_NUM_PACKETS)
|
||||
#define EM28XX_URB_TIMEOUT msecs_to_jiffies(EM28XX_NUM_BUFS * EM28XX_NUM_PACKETS)
|
||||
|
||||
/* time in msecs to wait for i2c writes to finish */
|
||||
#define EM2800_I2C_WRITE_TIMEOUT 20
|
||||
|
||||
/* the various frame states */
|
||||
enum em2820_frame_state {
|
||||
enum em28xx_frame_state {
|
||||
F_UNUSED = 0,
|
||||
F_QUEUED,
|
||||
F_GRABBING,
|
||||
|
|
@ -104,17 +104,17 @@ enum em2820_frame_state {
|
|||
};
|
||||
|
||||
/* stream states */
|
||||
enum em2820_stream_state {
|
||||
enum em28xx_stream_state {
|
||||
STREAM_OFF,
|
||||
STREAM_INTERRUPT,
|
||||
STREAM_ON,
|
||||
};
|
||||
|
||||
/* frames */
|
||||
struct em2820_frame_t {
|
||||
struct em28xx_frame_t {
|
||||
void *bufmem;
|
||||
struct v4l2_buffer buf;
|
||||
enum em2820_frame_state state;
|
||||
enum em28xx_frame_state state;
|
||||
struct list_head frame;
|
||||
unsigned long vma_use_count;
|
||||
int top_field;
|
||||
|
|
@ -122,7 +122,7 @@ struct em2820_frame_t {
|
|||
};
|
||||
|
||||
/* io methods */
|
||||
enum em2820_io_method {
|
||||
enum em28xx_io_method {
|
||||
IO_NONE,
|
||||
IO_READ,
|
||||
IO_MMAP,
|
||||
|
|
@ -130,35 +130,35 @@ enum em2820_io_method {
|
|||
|
||||
/* inputs */
|
||||
|
||||
#define MAX_EM2820_INPUT 4
|
||||
enum enum2820_itype {
|
||||
EM2820_VMUX_COMPOSITE1 = 1,
|
||||
EM2820_VMUX_COMPOSITE2,
|
||||
EM2820_VMUX_COMPOSITE3,
|
||||
EM2820_VMUX_COMPOSITE4,
|
||||
EM2820_VMUX_SVIDEO,
|
||||
EM2820_VMUX_TELEVISION,
|
||||
EM2820_VMUX_CABLE,
|
||||
EM2820_VMUX_DVB,
|
||||
EM2820_VMUX_DEBUG,
|
||||
EM2820_RADIO,
|
||||
#define MAX_EM28XX_INPUT 4
|
||||
enum enum28xx_itype {
|
||||
EM28XX_VMUX_COMPOSITE1 = 1,
|
||||
EM28XX_VMUX_COMPOSITE2,
|
||||
EM28XX_VMUX_COMPOSITE3,
|
||||
EM28XX_VMUX_COMPOSITE4,
|
||||
EM28XX_VMUX_SVIDEO,
|
||||
EM28XX_VMUX_TELEVISION,
|
||||
EM28XX_VMUX_CABLE,
|
||||
EM28XX_VMUX_DVB,
|
||||
EM28XX_VMUX_DEBUG,
|
||||
EM28XX_RADIO,
|
||||
};
|
||||
|
||||
struct em2820_input {
|
||||
enum enum2820_itype type;
|
||||
struct em28xx_input {
|
||||
enum enum28xx_itype type;
|
||||
unsigned int vmux;
|
||||
unsigned int amux;
|
||||
};
|
||||
|
||||
#define INPUT(nr) (&em2820_boards[dev->model].input[nr])
|
||||
#define INPUT(nr) (&em28xx_boards[dev->model].input[nr])
|
||||
|
||||
enum em2820_decoder {
|
||||
EM2820_TVP5150,
|
||||
EM2820_SAA7113,
|
||||
EM2820_SAA7114
|
||||
enum em28xx_decoder {
|
||||
EM28XX_TVP5150,
|
||||
EM28XX_SAA7113,
|
||||
EM28XX_SAA7114
|
||||
};
|
||||
|
||||
struct em2820_board {
|
||||
struct em28xx_board {
|
||||
char *name;
|
||||
int vchannels;
|
||||
int norm;
|
||||
|
|
@ -171,12 +171,12 @@ struct em2820_board {
|
|||
unsigned int has_tuner:1;
|
||||
unsigned int has_msp34xx:1;
|
||||
|
||||
enum em2820_decoder decoder;
|
||||
enum em28xx_decoder decoder;
|
||||
|
||||
struct em2820_input input[MAX_EM2820_INPUT];
|
||||
struct em28xx_input input[MAX_EM28XX_INPUT];
|
||||
};
|
||||
|
||||
struct em2820_eeprom {
|
||||
struct em28xx_eeprom {
|
||||
u32 id; /* 0x9567eb1a */
|
||||
u16 vendor_ID;
|
||||
u16 product_ID;
|
||||
|
|
@ -191,14 +191,14 @@ struct em2820_eeprom {
|
|||
};
|
||||
|
||||
/* device states */
|
||||
enum em2820_dev_state {
|
||||
enum em28xx_dev_state {
|
||||
DEV_INITIALIZED = 0x01,
|
||||
DEV_DISCONNECTED = 0x02,
|
||||
DEV_MISCONFIGURED = 0x04,
|
||||
};
|
||||
|
||||
/* tvnorms */
|
||||
struct em2820_tvnorm {
|
||||
struct em28xx_tvnorm {
|
||||
char *name;
|
||||
v4l2_std_id id;
|
||||
/* mode for saa7113h */
|
||||
|
|
@ -206,7 +206,7 @@ struct em2820_tvnorm {
|
|||
};
|
||||
|
||||
/* main device struct */
|
||||
struct em2820 {
|
||||
struct em28xx {
|
||||
/* generic device properties */
|
||||
char name[30]; /* name (including minor) of the device */
|
||||
int model; /* index in the device_data struct */
|
||||
|
|
@ -217,7 +217,7 @@ struct em2820 {
|
|||
unsigned int has_msp34xx:1;
|
||||
unsigned int has_tda9887:1;
|
||||
|
||||
enum em2820_decoder decoder;
|
||||
enum em28xx_decoder decoder;
|
||||
|
||||
int tuner_type; /* type of the tuner */
|
||||
int tuner_addr; /* tuner address */
|
||||
|
|
@ -229,17 +229,17 @@ struct em2820 {
|
|||
int users; /* user count for exclusive use */
|
||||
struct video_device *vdev; /* video for linux device struct */
|
||||
struct video_picture vpic; /* picture settings only used to init saa7113h */
|
||||
struct em2820_tvnorm *tvnorm; /* selected tv norm */
|
||||
struct em28xx_tvnorm *tvnorm; /* selected tv norm */
|
||||
int ctl_freq; /* selected frequency */
|
||||
unsigned int ctl_input; /* selected input */
|
||||
unsigned int ctl_ainput; /* slected audio input */
|
||||
int mute;
|
||||
int volume;
|
||||
/* frame properties */
|
||||
struct em2820_frame_t frame[EM2820_NUM_FRAMES]; /* list of frames */
|
||||
struct em28xx_frame_t frame[EM28XX_NUM_FRAMES]; /* list of frames */
|
||||
int num_frames; /* number of frames currently in use */
|
||||
unsigned int frame_count; /* total number of transfered frames */
|
||||
struct em2820_frame_t *frame_current; /* the frame that is being filled */
|
||||
struct em28xx_frame_t *frame_current; /* the frame that is being filled */
|
||||
int width; /* current frame width */
|
||||
int height; /* current frame height */
|
||||
int frame_size; /* current frame size */
|
||||
|
|
@ -251,9 +251,9 @@ struct em2820 {
|
|||
int type;
|
||||
|
||||
/* states */
|
||||
enum em2820_dev_state state;
|
||||
enum em2820_stream_state stream;
|
||||
enum em2820_io_method io;
|
||||
enum em28xx_dev_state state;
|
||||
enum em28xx_stream_state stream;
|
||||
enum em28xx_io_method io;
|
||||
/* locks */
|
||||
struct semaphore lock, fileop_lock;
|
||||
spinlock_t queue_lock;
|
||||
|
|
@ -267,71 +267,71 @@ struct em2820 {
|
|||
struct usb_device *udev; /* the usb device */
|
||||
int alt; /* alternate */
|
||||
int max_pkt_size; /* max packet size of isoc transaction */
|
||||
unsigned int alt_max_pkt_size[EM2820_MAX_ALT + 1]; /* array of wMaxPacketSize */
|
||||
struct urb *urb[EM2820_NUM_BUFS]; /* urb for isoc transfers */
|
||||
char *transfer_buffer[EM2820_NUM_BUFS]; /* transfer buffers for isoc transfer */
|
||||
unsigned int alt_max_pkt_size[EM28XX_MAX_ALT + 1]; /* array of wMaxPacketSize */
|
||||
struct urb *urb[EM28XX_NUM_BUFS]; /* urb for isoc transfers */
|
||||
char *transfer_buffer[EM28XX_NUM_BUFS]; /* transfer buffers for isoc transfer */
|
||||
/* helper funcs that call usb_control_msg */
|
||||
int (*em2820_write_regs) (struct em2820 * dev, u16 reg, char *buf,
|
||||
int (*em28xx_write_regs) (struct em28xx * dev, u16 reg, char *buf,
|
||||
int len);
|
||||
int (*em2820_read_reg) (struct em2820 * dev, u16 reg);
|
||||
int (*em2820_read_reg_req_len) (struct em2820 * dev, u8 req, u16 reg,
|
||||
int (*em28xx_read_reg) (struct em28xx * dev, u16 reg);
|
||||
int (*em28xx_read_reg_req_len) (struct em28xx * dev, u8 req, u16 reg,
|
||||
char *buf, int len);
|
||||
int (*em2820_write_regs_req) (struct em2820 * dev, u8 req, u16 reg,
|
||||
int (*em28xx_write_regs_req) (struct em28xx * dev, u8 req, u16 reg,
|
||||
char *buf, int len);
|
||||
int (*em2820_read_reg_req) (struct em2820 * dev, u8 req, u16 reg);
|
||||
int (*em28xx_read_reg_req) (struct em28xx * dev, u8 req, u16 reg);
|
||||
};
|
||||
|
||||
/* Provided by em2820-i2c.c */
|
||||
/* Provided by em28xx-i2c.c */
|
||||
|
||||
void em2820_i2c_call_clients(struct em2820 *dev, unsigned int cmd, void *arg);
|
||||
int em2820_i2c_register(struct em2820 *dev);
|
||||
int em2820_i2c_unregister(struct em2820 *dev);
|
||||
void em28xx_i2c_call_clients(struct em28xx *dev, unsigned int cmd, void *arg);
|
||||
int em28xx_i2c_register(struct em28xx *dev);
|
||||
int em28xx_i2c_unregister(struct em28xx *dev);
|
||||
|
||||
/* Provided by em2820-input.c */
|
||||
/* Provided by em28xx-input.c */
|
||||
|
||||
void em2820_set_ir(struct em2820 * dev,struct IR_i2c *ir);
|
||||
void em28xx_set_ir(struct em28xx * dev,struct IR_i2c *ir);
|
||||
|
||||
/* Provided by em2820-core.c */
|
||||
/* Provided by em28xx-core.c */
|
||||
|
||||
void em2820_print_ioctl(char *name, unsigned int cmd);
|
||||
void em28xx_print_ioctl(char *name, unsigned int cmd);
|
||||
|
||||
u32 em2820_request_buffers(struct em2820 *dev, u32 count);
|
||||
void em2820_queue_unusedframes(struct em2820 *dev);
|
||||
void em2820_release_buffers(struct em2820 *dev);
|
||||
u32 em28xx_request_buffers(struct em28xx *dev, u32 count);
|
||||
void em28xx_queue_unusedframes(struct em28xx *dev);
|
||||
void em28xx_release_buffers(struct em28xx *dev);
|
||||
|
||||
int em2820_read_reg_req_len(struct em2820 *dev, u8 req, u16 reg,
|
||||
int em28xx_read_reg_req_len(struct em28xx *dev, u8 req, u16 reg,
|
||||
char *buf, int len);
|
||||
int em2820_read_reg_req(struct em2820 *dev, u8 req, u16 reg);
|
||||
int em2820_read_reg(struct em2820 *dev, u16 reg);
|
||||
int em2820_write_regs_req(struct em2820 *dev, u8 req, u16 reg, char *buf,
|
||||
int em28xx_read_reg_req(struct em28xx *dev, u8 req, u16 reg);
|
||||
int em28xx_read_reg(struct em28xx *dev, u16 reg);
|
||||
int em28xx_write_regs_req(struct em28xx *dev, u8 req, u16 reg, char *buf,
|
||||
int len);
|
||||
int em2820_write_regs(struct em2820 *dev, u16 reg, char *buf, int len);
|
||||
int em2820_write_reg_bits(struct em2820 *dev, u16 reg, u8 val,
|
||||
int em28xx_write_regs(struct em28xx *dev, u16 reg, char *buf, int len);
|
||||
int em28xx_write_reg_bits(struct em28xx *dev, u16 reg, u8 val,
|
||||
u8 bitmask);
|
||||
int em2820_write_ac97(struct em2820 *dev, u8 reg, u8 * val);
|
||||
int em2820_audio_analog_set(struct em2820 *dev);
|
||||
int em2820_colorlevels_set_default(struct em2820 *dev);
|
||||
int em2820_capture_start(struct em2820 *dev, int start);
|
||||
int em2820_outfmt_set_yuv422(struct em2820 *dev);
|
||||
int em2820_accumulator_set(struct em2820 *dev, u8 xmin, u8 xmax, u8 ymin,
|
||||
int em28xx_write_ac97(struct em28xx *dev, u8 reg, u8 * val);
|
||||
int em28xx_audio_analog_set(struct em28xx *dev);
|
||||
int em28xx_colorlevels_set_default(struct em28xx *dev);
|
||||
int em28xx_capture_start(struct em28xx *dev, int start);
|
||||
int em28xx_outfmt_set_yuv422(struct em28xx *dev);
|
||||
int em28xx_accumulator_set(struct em28xx *dev, u8 xmin, u8 xmax, u8 ymin,
|
||||
u8 ymax);
|
||||
int em2820_capture_area_set(struct em2820 *dev, u8 hstart, u8 vstart,
|
||||
int em28xx_capture_area_set(struct em28xx *dev, u8 hstart, u8 vstart,
|
||||
u16 width, u16 height);
|
||||
int em2820_scaler_set(struct em2820 *dev, u16 h, u16 v);
|
||||
int em2820_resolution_set(struct em2820 *dev);
|
||||
void em2820_isocIrq(struct urb *urb, struct pt_regs *regs);
|
||||
int em2820_init_isoc(struct em2820 *dev);
|
||||
void em2820_uninit_isoc(struct em2820 *dev);
|
||||
int em2820_set_alternate(struct em2820 *dev);
|
||||
int em28xx_scaler_set(struct em28xx *dev, u16 h, u16 v);
|
||||
int em28xx_resolution_set(struct em28xx *dev);
|
||||
void em28xx_isocIrq(struct urb *urb, struct pt_regs *regs);
|
||||
int em28xx_init_isoc(struct em28xx *dev);
|
||||
void em28xx_uninit_isoc(struct em28xx *dev);
|
||||
int em28xx_set_alternate(struct em28xx *dev);
|
||||
|
||||
/* Provided by em2820-cards.c */
|
||||
/* Provided by em28xx-cards.c */
|
||||
extern int em2800_variant_detect(struct usb_device* udev,int model);
|
||||
extern void em2820_card_setup(struct em2820 *dev);
|
||||
extern struct em2820_board em2820_boards[];
|
||||
extern struct usb_device_id em2820_id_table[];
|
||||
extern const unsigned int em2820_bcount;
|
||||
extern void em28xx_card_setup(struct em28xx *dev);
|
||||
extern struct em28xx_board em28xx_boards[];
|
||||
extern struct usb_device_id em28xx_id_table[];
|
||||
extern const unsigned int em28xx_bcount;
|
||||
|
||||
/* em2820 registers */
|
||||
/* em28xx registers */
|
||||
#define CHIPID_REG 0x0a
|
||||
#define USBSUSP_REG 0x0c /* */
|
||||
|
||||
|
|
@ -386,115 +386,115 @@ extern const unsigned int em2820_bcount;
|
|||
#define VIDEO_AC97 0x14
|
||||
|
||||
/* register settings */
|
||||
#define EM2820_AUDIO_SRC_TUNER 0xc0
|
||||
#define EM2820_AUDIO_SRC_LINE 0x80
|
||||
#define EM28XX_AUDIO_SRC_TUNER 0xc0
|
||||
#define EM28XX_AUDIO_SRC_LINE 0x80
|
||||
|
||||
/* printk macros */
|
||||
|
||||
#define em2820_err(fmt, arg...) do {\
|
||||
#define em28xx_err(fmt, arg...) do {\
|
||||
printk(KERN_ERR fmt , ##arg); } while (0)
|
||||
|
||||
#define em2820_errdev(fmt, arg...) do {\
|
||||
#define em28xx_errdev(fmt, arg...) do {\
|
||||
printk(KERN_ERR "%s: "fmt,\
|
||||
dev->name , ##arg); } while (0)
|
||||
|
||||
#define em2820_info(fmt, arg...) do {\
|
||||
#define em28xx_info(fmt, arg...) do {\
|
||||
printk(KERN_INFO "%s: "fmt,\
|
||||
dev->name , ##arg); } while (0)
|
||||
#define em2820_warn(fmt, arg...) do {\
|
||||
#define em28xx_warn(fmt, arg...) do {\
|
||||
printk(KERN_WARNING "%s: "fmt,\
|
||||
dev->name , ##arg); } while (0)
|
||||
|
||||
inline static int em2820_audio_source(struct em2820 *dev, int input)
|
||||
inline static int em28xx_audio_source(struct em28xx *dev, int input)
|
||||
{
|
||||
return em2820_write_reg_bits(dev, AUDIOSRC_REG, input, 0xc0);
|
||||
return em28xx_write_reg_bits(dev, AUDIOSRC_REG, input, 0xc0);
|
||||
}
|
||||
|
||||
inline static int em2820_audio_usb_mute(struct em2820 *dev, int mute)
|
||||
inline static int em28xx_audio_usb_mute(struct em28xx *dev, int mute)
|
||||
{
|
||||
return em2820_write_reg_bits(dev, XCLK_REG, mute ? 0x00 : 0x80, 0x80);
|
||||
return em28xx_write_reg_bits(dev, XCLK_REG, mute ? 0x00 : 0x80, 0x80);
|
||||
}
|
||||
|
||||
inline static int em2820_audio_analog_setup(struct em2820 *dev)
|
||||
inline static int em28xx_audio_analog_setup(struct em28xx *dev)
|
||||
{
|
||||
/* unmute video mixer with default volume level */
|
||||
return em2820_write_ac97(dev, VIDEO_AC97, "\x08\x08");
|
||||
return em28xx_write_ac97(dev, VIDEO_AC97, "\x08\x08");
|
||||
}
|
||||
|
||||
inline static int em2820_compression_disable(struct em2820 *dev)
|
||||
inline static int em28xx_compression_disable(struct em28xx *dev)
|
||||
{
|
||||
/* side effect of disabling scaler and mixer */
|
||||
return em2820_write_regs(dev, COMPR_REG, "\x00", 1);
|
||||
return em28xx_write_regs(dev, COMPR_REG, "\x00", 1);
|
||||
}
|
||||
|
||||
inline static int em2820_contrast_get(struct em2820 *dev)
|
||||
inline static int em28xx_contrast_get(struct em28xx *dev)
|
||||
{
|
||||
return em2820_read_reg(dev, YGAIN_REG) & 0x1f;
|
||||
return em28xx_read_reg(dev, YGAIN_REG) & 0x1f;
|
||||
}
|
||||
|
||||
inline static int em2820_brightness_get(struct em2820 *dev)
|
||||
inline static int em28xx_brightness_get(struct em28xx *dev)
|
||||
{
|
||||
return em2820_read_reg(dev, YOFFSET_REG);
|
||||
return em28xx_read_reg(dev, YOFFSET_REG);
|
||||
}
|
||||
|
||||
inline static int em2820_saturation_get(struct em2820 *dev)
|
||||
inline static int em28xx_saturation_get(struct em28xx *dev)
|
||||
{
|
||||
return em2820_read_reg(dev, UVGAIN_REG) & 0x1f;
|
||||
return em28xx_read_reg(dev, UVGAIN_REG) & 0x1f;
|
||||
}
|
||||
|
||||
inline static int em2820_u_balance_get(struct em2820 *dev)
|
||||
inline static int em28xx_u_balance_get(struct em28xx *dev)
|
||||
{
|
||||
return em2820_read_reg(dev, UOFFSET_REG);
|
||||
return em28xx_read_reg(dev, UOFFSET_REG);
|
||||
}
|
||||
|
||||
inline static int em2820_v_balance_get(struct em2820 *dev)
|
||||
inline static int em28xx_v_balance_get(struct em28xx *dev)
|
||||
{
|
||||
return em2820_read_reg(dev, VOFFSET_REG);
|
||||
return em28xx_read_reg(dev, VOFFSET_REG);
|
||||
}
|
||||
|
||||
inline static int em2820_gamma_get(struct em2820 *dev)
|
||||
inline static int em28xx_gamma_get(struct em28xx *dev)
|
||||
{
|
||||
return em2820_read_reg(dev, GAMMA_REG) & 0x3f;
|
||||
return em28xx_read_reg(dev, GAMMA_REG) & 0x3f;
|
||||
}
|
||||
|
||||
inline static int em2820_contrast_set(struct em2820 *dev, s32 val)
|
||||
inline static int em28xx_contrast_set(struct em28xx *dev, s32 val)
|
||||
{
|
||||
u8 tmp = (u8) val;
|
||||
return em2820_write_regs(dev, YGAIN_REG, &tmp, 1);
|
||||
return em28xx_write_regs(dev, YGAIN_REG, &tmp, 1);
|
||||
}
|
||||
|
||||
inline static int em2820_brightness_set(struct em2820 *dev, s32 val)
|
||||
inline static int em28xx_brightness_set(struct em28xx *dev, s32 val)
|
||||
{
|
||||
u8 tmp = (u8) val;
|
||||
return em2820_write_regs(dev, YOFFSET_REG, &tmp, 1);
|
||||
return em28xx_write_regs(dev, YOFFSET_REG, &tmp, 1);
|
||||
}
|
||||
|
||||
inline static int em2820_saturation_set(struct em2820 *dev, s32 val)
|
||||
inline static int em28xx_saturation_set(struct em28xx *dev, s32 val)
|
||||
{
|
||||
u8 tmp = (u8) val;
|
||||
return em2820_write_regs(dev, UVGAIN_REG, &tmp, 1);
|
||||
return em28xx_write_regs(dev, UVGAIN_REG, &tmp, 1);
|
||||
}
|
||||
|
||||
inline static int em2820_u_balance_set(struct em2820 *dev, s32 val)
|
||||
inline static int em28xx_u_balance_set(struct em28xx *dev, s32 val)
|
||||
{
|
||||
u8 tmp = (u8) val;
|
||||
return em2820_write_regs(dev, UOFFSET_REG, &tmp, 1);
|
||||
return em28xx_write_regs(dev, UOFFSET_REG, &tmp, 1);
|
||||
}
|
||||
|
||||
inline static int em2820_v_balance_set(struct em2820 *dev, s32 val)
|
||||
inline static int em28xx_v_balance_set(struct em28xx *dev, s32 val)
|
||||
{
|
||||
u8 tmp = (u8) val;
|
||||
return em2820_write_regs(dev, VOFFSET_REG, &tmp, 1);
|
||||
return em28xx_write_regs(dev, VOFFSET_REG, &tmp, 1);
|
||||
}
|
||||
|
||||
inline static int em2820_gamma_set(struct em2820 *dev, s32 val)
|
||||
inline static int em28xx_gamma_set(struct em28xx *dev, s32 val)
|
||||
{
|
||||
u8 tmp = (u8) val;
|
||||
return em2820_write_regs(dev, GAMMA_REG, &tmp, 1);
|
||||
return em28xx_write_regs(dev, GAMMA_REG, &tmp, 1);
|
||||
}
|
||||
|
||||
/*FIXME: maxw should be dependent of alt mode */
|
||||
inline static unsigned int norm_maxw(struct em2820 *dev)
|
||||
inline static unsigned int norm_maxw(struct em28xx *dev)
|
||||
{
|
||||
switch(dev->model){
|
||||
case (EM2820_BOARD_MSI_VOX_USB_2): return(640);
|
||||
|
|
@ -502,7 +502,7 @@ inline static unsigned int norm_maxw(struct em2820 *dev)
|
|||
}
|
||||
}
|
||||
|
||||
inline static unsigned int norm_maxh(struct em2820 *dev)
|
||||
inline static unsigned int norm_maxh(struct em28xx *dev)
|
||||
{
|
||||
switch(dev->model){
|
||||
case (EM2820_BOARD_MSI_VOX_USB_2): return(480);
|
||||
|
|
|
|||
Loading…
Reference in New Issue