lk/linux-kernel-test
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[media] usbvision: coding style

Browse Source 
Signed-off-by: Hans Verkuil <hverkuil@xs4all.nl>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>
This commit is contained in:
Hans Verkuil
2010-12-29 13:53:21 -03:00
committed by Mauro Carvalho Chehab
parent 52cb0bf275
commit 6d6a48e51f
5 changed files with 557 additions and 686 deletions
Download Patch File Download Diff File Expand all files Collapse all files

132
drivers/media/video/usbvision/usbvision-cards.c
View File

@@ -1026,78 +1026,78 @@ struct usbvision_device_data_st usbvision_device_data[] = {
.model_string = "Hauppauge WinTv-USB", .model_string = "Hauppauge WinTv-USB",
}, },
}; };
const int usbvision_device_data_size=ARRAY_SIZE(usbvision_device_data); const int usbvision_device_data_size = ARRAY_SIZE(usbvision_device_data);
/* Supported Devices */ /* Supported Devices */
struct usb_device_id usbvision_table [] = { struct usb_device_id usbvision_table[] = {
{ USB_DEVICE(0x0a6f, 0x0400), .driver_info=XANBOO }, { USB_DEVICE(0x0a6f, 0x0400), .driver_info = XANBOO },
{ USB_DEVICE(0x050d, 0x0106), .driver_info=BELKIN_VIDEOBUS_II }, { USB_DEVICE(0x050d, 0x0106), .driver_info = BELKIN_VIDEOBUS_II },
{ USB_DEVICE(0x050d, 0x0207), .driver_info=BELKIN_VIDEOBUS }, { USB_DEVICE(0x050d, 0x0207), .driver_info = BELKIN_VIDEOBUS },
{ USB_DEVICE(0x050d, 0x0208), .driver_info=BELKIN_USB_VIDEOBUS_II }, { USB_DEVICE(0x050d, 0x0208), .driver_info = BELKIN_USB_VIDEOBUS_II },
{ USB_DEVICE(0x0571, 0x0002), .driver_info=ECHOFX_INTERVIEW_LITE }, { USB_DEVICE(0x0571, 0x0002), .driver_info = ECHOFX_INTERVIEW_LITE },
{ USB_DEVICE(0x0573, 0x0003), .driver_info=USBGEAR_USBG_V1 }, { USB_DEVICE(0x0573, 0x0003), .driver_info = USBGEAR_USBG_V1 },
{ USB_DEVICE(0x0573, 0x0400), .driver_info=D_LINK_V100 }, { USB_DEVICE(0x0573, 0x0400), .driver_info = D_LINK_V100 },
{ USB_DEVICE(0x0573, 0x2000), .driver_info=X10_USB_CAMERA }, { USB_DEVICE(0x0573, 0x2000), .driver_info = X10_USB_CAMERA },
{ USB_DEVICE(0x0573, 0x2d00), .driver_info=HPG_WINTV_LIVE_PAL_BG }, { USB_DEVICE(0x0573, 0x2d00), .driver_info = HPG_WINTV_LIVE_PAL_BG },
{ USB_DEVICE(0x0573, 0x2d01), .driver_info=HPG_WINTV_LIVE_PRO_NTSC_MN }, { USB_DEVICE(0x0573, 0x2d01), .driver_info = HPG_WINTV_LIVE_PRO_NTSC_MN },
{ USB_DEVICE(0x0573, 0x2101), .driver_info=ZORAN_PMD_NOGATECH }, { USB_DEVICE(0x0573, 0x2101), .driver_info = ZORAN_PMD_NOGATECH },
{ USB_DEVICE(0x0573, 0x4100), .driver_info=NOGATECH_USB_TV_NTSC_FM }, { USB_DEVICE(0x0573, 0x4100), .driver_info = NOGATECH_USB_TV_NTSC_FM },
{ USB_DEVICE(0x0573, 0x4110), .driver_info=PNY_USB_TV_NTSC_FM }, { USB_DEVICE(0x0573, 0x4110), .driver_info = PNY_USB_TV_NTSC_FM },
{ USB_DEVICE(0x0573, 0x4450), .driver_info=PV_PLAYTV_USB_PRO_PAL_FM }, { USB_DEVICE(0x0573, 0x4450), .driver_info = PV_PLAYTV_USB_PRO_PAL_FM },
{ USB_DEVICE(0x0573, 0x4550), .driver_info=ZT_721 }, { USB_DEVICE(0x0573, 0x4550), .driver_info = ZT_721 },
{ USB_DEVICE(0x0573, 0x4d00), .driver_info=HPG_WINTV_NTSC_MN }, { USB_DEVICE(0x0573, 0x4d00), .driver_info = HPG_WINTV_NTSC_MN },
{ USB_DEVICE(0x0573, 0x4d01), .driver_info=HPG_WINTV_PAL_BG }, { USB_DEVICE(0x0573, 0x4d01), .driver_info = HPG_WINTV_PAL_BG },
{ USB_DEVICE(0x0573, 0x4d02), .driver_info=HPG_WINTV_PAL_I }, { USB_DEVICE(0x0573, 0x4d02), .driver_info = HPG_WINTV_PAL_I },
{ USB_DEVICE(0x0573, 0x4d03), .driver_info=HPG_WINTV_PAL_SECAM_L }, { USB_DEVICE(0x0573, 0x4d03), .driver_info = HPG_WINTV_PAL_SECAM_L },
{ USB_DEVICE(0x0573, 0x4d04), .driver_info=HPG_WINTV_PAL_D_K }, { USB_DEVICE(0x0573, 0x4d04), .driver_info = HPG_WINTV_PAL_D_K },
{ USB_DEVICE(0x0573, 0x4d10), .driver_info=HPG_WINTV_NTSC_FM }, { USB_DEVICE(0x0573, 0x4d10), .driver_info = HPG_WINTV_NTSC_FM },
{ USB_DEVICE(0x0573, 0x4d11), .driver_info=HPG_WINTV_PAL_BG_FM }, { USB_DEVICE(0x0573, 0x4d11), .driver_info = HPG_WINTV_PAL_BG_FM },
{ USB_DEVICE(0x0573, 0x4d12), .driver_info=HPG_WINTV_PAL_I_FM }, { USB_DEVICE(0x0573, 0x4d12), .driver_info = HPG_WINTV_PAL_I_FM },
{ USB_DEVICE(0x0573, 0x4d14), .driver_info=HPG_WINTV_PAL_D_K_FM }, { USB_DEVICE(0x0573, 0x4d14), .driver_info = HPG_WINTV_PAL_D_K_FM },
{ USB_DEVICE(0x0573, 0x4d2a), .driver_info=HPG_WINTV_PRO_NTSC_MN }, { USB_DEVICE(0x0573, 0x4d2a), .driver_info = HPG_WINTV_PRO_NTSC_MN },
{ USB_DEVICE(0x0573, 0x4d2b), .driver_info=HPG_WINTV_PRO_NTSC_MN_V2 }, { USB_DEVICE(0x0573, 0x4d2b), .driver_info = HPG_WINTV_PRO_NTSC_MN_V2 },
{ USB_DEVICE(0x0573, 0x4d2c), .driver_info=HPG_WINTV_PRO_PAL }, { USB_DEVICE(0x0573, 0x4d2c), .driver_info = HPG_WINTV_PRO_PAL },
{ USB_DEVICE(0x0573, 0x4d20), .driver_info = HPG_WINTV_PRO_NTSC_MN_V3 }, { USB_DEVICE(0x0573, 0x4d20), .driver_info = HPG_WINTV_PRO_NTSC_MN_V3 },
{ USB_DEVICE(0x0573, 0x4d21), .driver_info=HPG_WINTV_PRO_PAL_BG }, { USB_DEVICE(0x0573, 0x4d21), .driver_info = HPG_WINTV_PRO_PAL_BG },
{ USB_DEVICE(0x0573, 0x4d22), .driver_info=HPG_WINTV_PRO_PAL_I }, { USB_DEVICE(0x0573, 0x4d22), .driver_info = HPG_WINTV_PRO_PAL_I },
{ USB_DEVICE(0x0573, 0x4d23), .driver_info=HPG_WINTV_PRO_PAL_SECAM_L }, { USB_DEVICE(0x0573, 0x4d23), .driver_info = HPG_WINTV_PRO_PAL_SECAM_L },
{ USB_DEVICE(0x0573, 0x4d24), .driver_info=HPG_WINTV_PRO_PAL_D_K }, { USB_DEVICE(0x0573, 0x4d24), .driver_info = HPG_WINTV_PRO_PAL_D_K },
{ USB_DEVICE(0x0573, 0x4d25), .driver_info=HPG_WINTV_PRO_PAL_SECAM }, { USB_DEVICE(0x0573, 0x4d25), .driver_info = HPG_WINTV_PRO_PAL_SECAM },
{ USB_DEVICE(0x0573, 0x4d26), .driver_info=HPG_WINTV_PRO_PAL_SECAM_V2 }, { USB_DEVICE(0x0573, 0x4d26), .driver_info = HPG_WINTV_PRO_PAL_SECAM_V2 },
{ USB_DEVICE(0x0573, 0x4d27), .driver_info=HPG_WINTV_PRO_PAL_BG_V2 }, { USB_DEVICE(0x0573, 0x4d27), .driver_info = HPG_WINTV_PRO_PAL_BG_V2 },
{ USB_DEVICE(0x0573, 0x4d28), .driver_info=HPG_WINTV_PRO_PAL_BG_D_K }, { USB_DEVICE(0x0573, 0x4d28), .driver_info = HPG_WINTV_PRO_PAL_BG_D_K },
{ USB_DEVICE(0x0573, 0x4d29), .driver_info=HPG_WINTV_PRO_PAL_I_D_K }, { USB_DEVICE(0x0573, 0x4d29), .driver_info = HPG_WINTV_PRO_PAL_I_D_K },
{ USB_DEVICE(0x0573, 0x4d30), .driver_info=HPG_WINTV_PRO_NTSC_MN_FM }, { USB_DEVICE(0x0573, 0x4d30), .driver_info = HPG_WINTV_PRO_NTSC_MN_FM },
{ USB_DEVICE(0x0573, 0x4d31), .driver_info=HPG_WINTV_PRO_PAL_BG_FM }, { USB_DEVICE(0x0573, 0x4d31), .driver_info = HPG_WINTV_PRO_PAL_BG_FM },
{ USB_DEVICE(0x0573, 0x4d32), .driver_info=HPG_WINTV_PRO_PAL_I_FM }, { USB_DEVICE(0x0573, 0x4d32), .driver_info = HPG_WINTV_PRO_PAL_I_FM },
{ USB_DEVICE(0x0573, 0x4d34), .driver_info=HPG_WINTV_PRO_PAL_D_K_FM }, { USB_DEVICE(0x0573, 0x4d34), .driver_info = HPG_WINTV_PRO_PAL_D_K_FM },
{ USB_DEVICE(0x0573, 0x4d35), .driver_info=HPG_WINTV_PRO_TEMIC_PAL_FM }, { USB_DEVICE(0x0573, 0x4d35), .driver_info = HPG_WINTV_PRO_TEMIC_PAL_FM },
{ USB_DEVICE(0x0573, 0x4d36), .driver_info=HPG_WINTV_PRO_TEMIC_PAL_BG_FM }, { USB_DEVICE(0x0573, 0x4d36), .driver_info = HPG_WINTV_PRO_TEMIC_PAL_BG_FM },
{ USB_DEVICE(0x0573, 0x4d37), .driver_info=HPG_WINTV_PRO_PAL_FM }, { USB_DEVICE(0x0573, 0x4d37), .driver_info = HPG_WINTV_PRO_PAL_FM },
{ USB_DEVICE(0x0573, 0x4d38), .driver_info=HPG_WINTV_PRO_NTSC_MN_FM_V2 }, { USB_DEVICE(0x0573, 0x4d38), .driver_info = HPG_WINTV_PRO_NTSC_MN_FM_V2 },
{ USB_DEVICE(0x0768, 0x0006), .driver_info=CAMTEL_TVB330 }, { USB_DEVICE(0x0768, 0x0006), .driver_info = CAMTEL_TVB330 },
{ USB_DEVICE(0x07d0, 0x0001), .driver_info=DIGITAL_VIDEO_CREATOR_I }, { USB_DEVICE(0x07d0, 0x0001), .driver_info = DIGITAL_VIDEO_CREATOR_I },
{ USB_DEVICE(0x07d0, 0x0002), .driver_info=GLOBAL_VILLAGE_GV_007_NTSC }, { USB_DEVICE(0x07d0, 0x0002), .driver_info = GLOBAL_VILLAGE_GV_007_NTSC },
{ USB_DEVICE(0x07d0, 0x0003), .driver_info=DAZZLE_DVC_50_REV_1_NTSC }, { USB_DEVICE(0x07d0, 0x0003), .driver_info = DAZZLE_DVC_50_REV_1_NTSC },
{ USB_DEVICE(0x07d0, 0x0004), .driver_info=DAZZLE_DVC_80_REV_1_PAL }, { USB_DEVICE(0x07d0, 0x0004), .driver_info = DAZZLE_DVC_80_REV_1_PAL },
{ USB_DEVICE(0x07d0, 0x0005), .driver_info=DAZZLE_DVC_90_REV_1_SECAM }, { USB_DEVICE(0x07d0, 0x0005), .driver_info = DAZZLE_DVC_90_REV_1_SECAM },
{ USB_DEVICE(0x07f8, 0x9104), .driver_info=ESKAPE_LABS_MYTV2GO }, { USB_DEVICE(0x07f8, 0x9104), .driver_info = ESKAPE_LABS_MYTV2GO },
{ USB_DEVICE(0x2304, 0x010d), .driver_info=PINNA_PCTV_USB_PAL }, { USB_DEVICE(0x2304, 0x010d), .driver_info = PINNA_PCTV_USB_PAL },
{ USB_DEVICE(0x2304, 0x0109), .driver_info=PINNA_PCTV_USB_SECAM }, { USB_DEVICE(0x2304, 0x0109), .driver_info = PINNA_PCTV_USB_SECAM },
{ USB_DEVICE(0x2304, 0x0110), .driver_info=PINNA_PCTV_USB_PAL_FM }, { USB_DEVICE(0x2304, 0x0110), .driver_info = PINNA_PCTV_USB_PAL_FM },
{ USB_DEVICE(0x2304, 0x0111), .driver_info=MIRO_PCTV_USB }, { USB_DEVICE(0x2304, 0x0111), .driver_info = MIRO_PCTV_USB },
{ USB_DEVICE(0x2304, 0x0112), .driver_info=PINNA_PCTV_USB_NTSC_FM }, { USB_DEVICE(0x2304, 0x0112), .driver_info = PINNA_PCTV_USB_NTSC_FM },
{ USB_DEVICE(0x2304, 0x0113), { USB_DEVICE(0x2304, 0x0113),
.driver_info = PINNA_PCTV_USB_NTSC_FM_V3 }, .driver_info = PINNA_PCTV_USB_NTSC_FM_V3 },
{ USB_DEVICE(0x2304, 0x0210), .driver_info=PINNA_PCTV_USB_PAL_FM_V2 }, { USB_DEVICE(0x2304, 0x0210), .driver_info = PINNA_PCTV_USB_PAL_FM_V2 },
{ USB_DEVICE(0x2304, 0x0212), .driver_info=PINNA_PCTV_USB_NTSC_FM_V2 }, { USB_DEVICE(0x2304, 0x0212), .driver_info = PINNA_PCTV_USB_NTSC_FM_V2 },
{ USB_DEVICE(0x2304, 0x0214), .driver_info=PINNA_PCTV_USB_PAL_FM_V3 }, { USB_DEVICE(0x2304, 0x0214), .driver_info = PINNA_PCTV_USB_PAL_FM_V3 },
{ USB_DEVICE(0x2304, 0x0300), .driver_info=PINNA_LINX_VD_IN_CAB_NTSC }, { USB_DEVICE(0x2304, 0x0300), .driver_info = PINNA_LINX_VD_IN_CAB_NTSC },
{ USB_DEVICE(0x2304, 0x0301), .driver_info=PINNA_LINX_VD_IN_CAB_PAL }, { USB_DEVICE(0x2304, 0x0301), .driver_info = PINNA_LINX_VD_IN_CAB_PAL },
{ USB_DEVICE(0x2304, 0x0419), .driver_info=PINNA_PCTV_BUNGEE_PAL_FM }, { USB_DEVICE(0x2304, 0x0419), .driver_info = PINNA_PCTV_BUNGEE_PAL_FM },
{ USB_DEVICE(0x2400, 0x4200), .driver_info=HPG_WINTV }, { USB_DEVICE(0x2400, 0x4200), .driver_info = HPG_WINTV },
{ }, /* terminate list */ { }, /* terminate list */
}; };
MODULE_DEVICE_TABLE (usb, usbvision_table); MODULE_DEVICE_TABLE(usb, usbvision_table);

695
drivers/media/video/usbvision/usbvision-core.c
View File

File diff suppressed because it is too large Load Diff

41
drivers/media/video/usbvision/usbvision-i2c.c
View File

@@ -28,18 +28,18 @@
#include <linux/module.h> #include <linux/module.h>
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/init.h> #include <linux/init.h>
#include <asm/uaccess.h> #include <linux/uaccess.h>
#include <linux/ioport.h> #include <linux/ioport.h>
#include <linux/errno.h> #include <linux/errno.h>
#include <linux/usb.h> #include <linux/usb.h>
#include <linux/i2c.h> #include <linux/i2c.h>
#include "usbvision.h" #include "usbvision.h"
#define DBG_I2C 1<<0 #define DBG_I2C (1 << 0)
static int i2c_debug; static int i2c_debug;
module_param (i2c_debug, int, 0644); /* debug_i2c_usb mode of the device driver */ module_param(i2c_debug, int, 0644); /* debug_i2c_usb mode of the device driver */
MODULE_PARM_DESC(i2c_debug, "enable debug messages [i2c]"); MODULE_PARM_DESC(i2c_debug, "enable debug messages [i2c]");
#define PDEBUG(level, fmt, args...) { \ #define PDEBUG(level, fmt, args...) { \
@@ -72,8 +72,8 @@ static inline int try_write_address(struct i2c_adapter *i2c_adap,
udelay(10); udelay(10);
} }
if (i) { if (i) {
PDEBUG(DBG_I2C,"Needed %d retries for address %#2x", i, addr); PDEBUG(DBG_I2C, "Needed %d retries for address %#2x", i, addr);
PDEBUG(DBG_I2C,"Maybe there's no device at this address"); PDEBUG(DBG_I2C, "Maybe there's no device at this address");
} }
return ret; return ret;
} }
@@ -96,8 +96,8 @@ static inline int try_read_address(struct i2c_adapter *i2c_adap,
udelay(10); udelay(10);
} }
if (i) { if (i) {
PDEBUG(DBG_I2C,"Needed %d retries for address %#2x", i, addr); PDEBUG(DBG_I2C, "Needed %d retries for address %#2x", i, addr);
PDEBUG(DBG_I2C,"Maybe there's no device at this address"); PDEBUG(DBG_I2C, "Maybe there's no device at this address");
} }
return ret; return ret;
} }
@@ -143,9 +143,8 @@ static inline int usb_find_address(struct i2c_adapter *i2c_adap,
else else
ret = try_write_address(i2c_adap, addr, retries); ret = try_write_address(i2c_adap, addr, retries);
if (ret != 1) { if (ret != 1)
return -EREMOTEIO; return -EREMOTEIO;
}
} }
return 0; return 0;
} }
@@ -164,22 +163,20 @@ usbvision_i2c_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg msgs[], int num)
pmsg = &msgs[i]; pmsg = &msgs[i];
ret = usb_find_address(i2c_adap, pmsg, i2c_adap->retries, &addr); ret = usb_find_address(i2c_adap, pmsg, i2c_adap->retries, &addr);
if (ret != 0) { if (ret != 0) {
PDEBUG(DBG_I2C,"got NAK from device, message #%d", i); PDEBUG(DBG_I2C, "got NAK from device, message #%d", i);
return (ret < 0) ? ret : -EREMOTEIO; return (ret < 0) ? ret : -EREMOTEIO;
} }
if (pmsg->flags & I2C_M_RD) { if (pmsg->flags & I2C_M_RD) {
/* read bytes into buffer */ /* read bytes into buffer */
ret = (usbvision_i2c_read(usbvision, addr, pmsg->buf, pmsg->len)); ret = (usbvision_i2c_read(usbvision, addr, pmsg->buf, pmsg->len));
if (ret < pmsg->len) { if (ret < pmsg->len)
return (ret < 0) ? ret : -EREMOTEIO; return (ret < 0) ? ret : -EREMOTEIO;
}
} else { } else {
/* write bytes from buffer */ /* write bytes from buffer */
ret = (usbvision_i2c_write(usbvision, addr, pmsg->buf, pmsg->len)); ret = (usbvision_i2c_write(usbvision, addr, pmsg->buf, pmsg->len));
if (ret < pmsg->len) { if (ret < pmsg->len)
return (ret < 0) ? ret : -EREMOTEIO; return (ret < 0) ? ret : -EREMOTEIO;
}
} }
} }
return num; return num;
@@ -219,7 +216,7 @@ int usbvision_i2c_register(struct usb_usbvision *usbvision)
sprintf(usbvision->i2c_adap.name, "%s-%d-%s", i2c_adap_template.name, sprintf(usbvision->i2c_adap.name, "%s-%d-%s", i2c_adap_template.name,
usbvision->dev->bus->busnum, usbvision->dev->devpath); usbvision->dev->bus->busnum, usbvision->dev->devpath);
PDEBUG(DBG_I2C,"Adaptername: %s", usbvision->i2c_adap.name); PDEBUG(DBG_I2C, "Adaptername: %s", usbvision->i2c_adap.name);
usbvision->i2c_adap.dev.parent = &usbvision->dev->dev; usbvision->i2c_adap.dev.parent = &usbvision->dev->dev;
i2c_set_adapdata(&usbvision->i2c_adap, &usbvision->v4l2_dev); i2c_set_adapdata(&usbvision->i2c_adap, &usbvision->v4l2_dev);
@@ -293,7 +290,7 @@ int usbvision_i2c_unregister(struct usb_usbvision *usbvision)
i2c_del_adapter(&(usbvision->i2c_adap)); i2c_del_adapter(&(usbvision->i2c_adap));
usbvision->registered_i2c = 0; usbvision->registered_i2c = 0;
PDEBUG(DBG_I2C,"i2c bus for %s unregistered", usbvision->i2c_adap.name); PDEBUG(DBG_I2C, "i2c bus for %s unregistered", usbvision->i2c_adap.name);
return 0; return 0;
} }
@@ -355,9 +352,9 @@ usbvision_i2c_read_max4(struct usb_usbvision *usbvision, unsigned char addr,
if (i2c_debug & DBG_I2C) { if (i2c_debug & DBG_I2C) {
int idx; int idx;
for (idx = 0; idx < len; idx++) {
PDEBUG(DBG_I2C,"read %x from address %x", (unsigned char)buf[idx], addr); for (idx = 0; idx < len; idx++)
} PDEBUG(DBG_I2C, "read %x from address %x", (unsigned char)buf[idx], addr);
} }
return len; return len;
} }
@@ -416,9 +413,9 @@ static int usbvision_i2c_write_max4(struct usb_usbvision *usbvision,
if (i2c_debug & DBG_I2C) { if (i2c_debug & DBG_I2C) {
int idx; int idx;
for (idx = 0; idx < len; idx++) {
PDEBUG(DBG_I2C,"wrote %x at address %x", (unsigned char)buf[idx], addr); for (idx = 0; idx < len; idx++)
} PDEBUG(DBG_I2C, "wrote %x at address %x", (unsigned char)buf[idx], addr);
} }
return len; return len;
} }

328
drivers/media/video/usbvision/usbvision-video.c
View File

@@ -56,7 +56,7 @@
#include <linux/module.h> #include <linux/module.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/spinlock.h> #include <linux/spinlock.h>
#include <asm/io.h> #include <linux/io.h>
#include <linux/videodev2.h> #include <linux/videodev2.h>
#include <linux/i2c.h> #include <linux/i2c.h>
@@ -70,8 +70,8 @@
#include "usbvision.h" #include "usbvision.h"
#include "usbvision-cards.h" #include "usbvision-cards.h"
#define DRIVER_AUTHOR "Joerg Heckenbach <joerg@heckenbach-aw.de>,\ #define DRIVER_AUTHOR "Joerg Heckenbach <joerg@heckenbach-aw.de>, \
Dwaine Garden <DwaineGarden@rogers.com>" Dwaine Garden <DwaineGarden@rogers.com>"
#define DRIVER_NAME "usbvision" #define DRIVER_NAME "usbvision"
#define DRIVER_ALIAS "USBVision" #define DRIVER_ALIAS "USBVision"
#define DRIVER_DESC "USBVision USB Video Device Driver for Linux" #define DRIVER_DESC "USBVision USB Video Device Driver for Linux"
@@ -82,9 +82,9 @@
#define USBVISION_DRIVER_VERSION KERNEL_VERSION(USBVISION_DRIVER_VERSION_MAJOR,\ #define USBVISION_DRIVER_VERSION KERNEL_VERSION(USBVISION_DRIVER_VERSION_MAJOR,\
USBVISION_DRIVER_VERSION_MINOR,\ USBVISION_DRIVER_VERSION_MINOR,\
USBVISION_DRIVER_VERSION_PATCHLEVEL) USBVISION_DRIVER_VERSION_PATCHLEVEL)
#define USBVISION_VERSION_STRING __stringify(USBVISION_DRIVER_VERSION_MAJOR)\ #define USBVISION_VERSION_STRING __stringify(USBVISION_DRIVER_VERSION_MAJOR) \
"." __stringify(USBVISION_DRIVER_VERSION_MINOR)\ "." __stringify(USBVISION_DRIVER_VERSION_MINOR) \
"." __stringify(USBVISION_DRIVER_VERSION_PATCHLEVEL) "." __stringify(USBVISION_DRIVER_VERSION_PATCHLEVEL)
#define ENABLE_HEXDUMP 0 /* Enable if you need it */ #define ENABLE_HEXDUMP 0 /* Enable if you need it */
@@ -96,16 +96,16 @@ USBVISION_DRIVER_VERSION_PATCHLEVEL)
__func__, __LINE__ , ## args); \ __func__, __LINE__ , ## args); \
} }
#else #else
#define PDEBUG(level, fmt, args...) do {} while(0) #define PDEBUG(level, fmt, args...) do {} while (0)
#endif #endif
#define DBG_IO 1<<1 #define DBG_IO (1 << 1)
#define DBG_PROBE 1<<2 #define DBG_PROBE (1 << 2)
#define DBG_MMAP 1<<3 #define DBG_MMAP (1 << 3)
/* String operations */ /* String operations */
#define rmspace(str) while(*str==' ') str++; #define rmspace(str) while (*str == ' ') str++;
#define goto2next(str) while(*str!=' ') str++; while(*str==' ') str++; #define goto2next(str) while (*str != ' ') str++; while (*str == ' ') str++;
/* sequential number of usbvision device */ /* sequential number of usbvision device */
@@ -205,7 +205,7 @@ static ssize_t show_hue(struct device *cd,
struct v4l2_control ctrl; struct v4l2_control ctrl;
ctrl.id = V4L2_CID_HUE; ctrl.id = V4L2_CID_HUE;
ctrl.value = 0; ctrl.value = 0;
if(usbvision->user) if (usbvision->user)
call_all(usbvision, core, g_ctrl, &ctrl); call_all(usbvision, core, g_ctrl, &ctrl);
return sprintf(buf, "%d\n", ctrl.value); return sprintf(buf, "%d\n", ctrl.value);
} }
@@ -220,7 +220,7 @@ static ssize_t show_contrast(struct device *cd,
struct v4l2_control ctrl; struct v4l2_control ctrl;
ctrl.id = V4L2_CID_CONTRAST; ctrl.id = V4L2_CID_CONTRAST;
ctrl.value = 0; ctrl.value = 0;
if(usbvision->user) if (usbvision->user)
call_all(usbvision, core, g_ctrl, &ctrl); call_all(usbvision, core, g_ctrl, &ctrl);
return sprintf(buf, "%d\n", ctrl.value); return sprintf(buf, "%d\n", ctrl.value);
} }
@@ -235,7 +235,7 @@ static ssize_t show_brightness(struct device *cd,
struct v4l2_control ctrl; struct v4l2_control ctrl;
ctrl.id = V4L2_CID_BRIGHTNESS; ctrl.id = V4L2_CID_BRIGHTNESS;
ctrl.value = 0; ctrl.value = 0;
if(usbvision->user) if (usbvision->user)
call_all(usbvision, core, g_ctrl, &ctrl); call_all(usbvision, core, g_ctrl, &ctrl);
return sprintf(buf, "%d\n", ctrl.value); return sprintf(buf, "%d\n", ctrl.value);
} }
@@ -250,7 +250,7 @@ static ssize_t show_saturation(struct device *cd,
struct v4l2_control ctrl; struct v4l2_control ctrl;
ctrl.id = V4L2_CID_SATURATION; ctrl.id = V4L2_CID_SATURATION;
ctrl.value = 0; ctrl.value = 0;
if(usbvision->user) if (usbvision->user)
call_all(usbvision, core, g_ctrl, &ctrl); call_all(usbvision, core, g_ctrl, &ctrl);
return sprintf(buf, "%d\n", ctrl.value); return sprintf(buf, "%d\n", ctrl.value);
} }
@@ -263,7 +263,7 @@ static ssize_t show_streaming(struct device *cd,
container_of(cd, struct video_device, dev); container_of(cd, struct video_device, dev);
struct usb_usbvision *usbvision = video_get_drvdata(vdev); struct usb_usbvision *usbvision = video_get_drvdata(vdev);
return sprintf(buf, "%s\n", return sprintf(buf, "%s\n",
YES_NO(usbvision->streaming==stream_on?1:0)); YES_NO(usbvision->streaming == stream_on ? 1 : 0));
} }
static DEVICE_ATTR(streaming, S_IRUGO, show_streaming, NULL); static DEVICE_ATTR(streaming, S_IRUGO, show_streaming, NULL);
@@ -274,7 +274,7 @@ static ssize_t show_compression(struct device *cd,
container_of(cd, struct video_device, dev); container_of(cd, struct video_device, dev);
struct usb_usbvision *usbvision = video_get_drvdata(vdev); struct usb_usbvision *usbvision = video_get_drvdata(vdev);
return sprintf(buf, "%s\n", return sprintf(buf, "%s\n",
YES_NO(usbvision->isoc_mode==ISOC_MODE_COMPRESS)); YES_NO(usbvision->isoc_mode == ISOC_MODE_COMPRESS));
} }
static DEVICE_ATTR(compression, S_IRUGO, show_compression, NULL); static DEVICE_ATTR(compression, S_IRUGO, show_compression, NULL);
@@ -291,35 +291,36 @@ static DEVICE_ATTR(bridge, S_IRUGO, show_device_bridge, NULL);
static void usbvision_create_sysfs(struct video_device *vdev) static void usbvision_create_sysfs(struct video_device *vdev)
{ {
int res; int res;
if (!vdev) if (!vdev)
return; return;
do { do {
res = device_create_file(&vdev->dev, &dev_attr_version); res = device_create_file(&vdev->dev, &dev_attr_version);
if (res<0) if (res < 0)
break; break;
res = device_create_file(&vdev->dev, &dev_attr_model); res = device_create_file(&vdev->dev, &dev_attr_model);
if (res<0) if (res < 0)
break; break;
res = device_create_file(&vdev->dev, &dev_attr_hue); res = device_create_file(&vdev->dev, &dev_attr_hue);
if (res<0) if (res < 0)
break; break;
res = device_create_file(&vdev->dev, &dev_attr_contrast); res = device_create_file(&vdev->dev, &dev_attr_contrast);
if (res<0) if (res < 0)
break; break;
res = device_create_file(&vdev->dev, &dev_attr_brightness); res = device_create_file(&vdev->dev, &dev_attr_brightness);
if (res<0) if (res < 0)
break; break;
res = device_create_file(&vdev->dev, &dev_attr_saturation); res = device_create_file(&vdev->dev, &dev_attr_saturation);
if (res<0) if (res < 0)
break; break;
res = device_create_file(&vdev->dev, &dev_attr_streaming); res = device_create_file(&vdev->dev, &dev_attr_streaming);
if (res<0) if (res < 0)
break; break;
res = device_create_file(&vdev->dev, &dev_attr_compression); res = device_create_file(&vdev->dev, &dev_attr_compression);
if (res<0) if (res < 0)
break; break;
res = device_create_file(&vdev->dev, &dev_attr_bridge); res = device_create_file(&vdev->dev, &dev_attr_bridge);
if (res>=0) if (res >= 0)
return; return;
} while (0); } while (0);
@@ -363,7 +364,7 @@ static int usbvision_v4l2_open(struct file *file)
else { else {
/* Allocate memory for the scratch ring buffer */ /* Allocate memory for the scratch ring buffer */
err_code = usbvision_scratch_alloc(usbvision); err_code = usbvision_scratch_alloc(usbvision);
if (isoc_mode==ISOC_MODE_COMPRESS) { if (isoc_mode == ISOC_MODE_COMPRESS) {
/* Allocate intermediate decompression buffers /* Allocate intermediate decompression buffers
only if needed */ only if needed */
err_code = usbvision_decompress_alloc(usbvision); err_code = usbvision_decompress_alloc(usbvision);
@@ -385,7 +386,7 @@ static int usbvision_v4l2_open(struct file *file)
/* Send init sequence only once, it's large! */ /* Send init sequence only once, it's large! */
if (!usbvision->initialized) { if (!usbvision->initialized) {
int setup_ok = 0; int setup_ok = 0;
setup_ok = usbvision_setup(usbvision,isoc_mode); setup_ok = usbvision_setup(usbvision, isoc_mode);
if (setup_ok) if (setup_ok)
usbvision->initialized = 1; usbvision->initialized = 1;
else else
@@ -396,7 +397,7 @@ static int usbvision_v4l2_open(struct file *file)
usbvision_begin_streaming(usbvision); usbvision_begin_streaming(usbvision);
err_code = usbvision_init_isoc(usbvision); err_code = usbvision_init_isoc(usbvision);
/* device must be initialized before isoc transfer */ /* device must be initialized before isoc transfer */
usbvision_muxsel(usbvision,0); usbvision_muxsel(usbvision, 0);
usbvision->user++; usbvision->user++;
} else { } else {
if (power_on_at_open) { if (power_on_at_open) {
@@ -463,7 +464,7 @@ static int usbvision_v4l2_close(struct file *file)
* *
*/ */
#ifdef CONFIG_VIDEO_ADV_DEBUG #ifdef CONFIG_VIDEO_ADV_DEBUG
static int vidioc_g_register (struct file *file, void *priv, static int vidioc_g_register(struct file *file, void *priv,
struct v4l2_dbg_register *reg) struct v4l2_dbg_register *reg)
{ {
struct usb_usbvision *usbvision = video_drvdata(file); struct usb_usbvision *usbvision = video_drvdata(file);
@@ -484,7 +485,7 @@ static int vidioc_g_register (struct file *file, void *priv,
return 0; return 0;
} }
static int vidioc_s_register (struct file *file, void *priv, static int vidioc_s_register(struct file *file, void *priv,
struct v4l2_dbg_register *reg) struct v4l2_dbg_register *reg)
{ {
struct usb_usbvision *usbvision = video_drvdata(file); struct usb_usbvision *usbvision = video_drvdata(file);
@@ -493,7 +494,7 @@ static int vidioc_s_register (struct file *file, void *priv,
if (!v4l2_chip_match_host(&reg->match)) if (!v4l2_chip_match_host(&reg->match))
return -EINVAL; return -EINVAL;
/* NT100x has a 8-bit register space */ /* NT100x has a 8-bit register space */
err_code = usbvision_write_reg(usbvision, reg->reg&0xff, reg->val); err_code = usbvision_write_reg(usbvision, reg->reg & 0xff, reg->val);
if (err_code < 0) { if (err_code < 0) {
dev_err(&usbvision->vdev->dev, dev_err(&usbvision->vdev->dev,
"%s: VIDIOC_DBG_S_REGISTER failed: error %d\n", "%s: VIDIOC_DBG_S_REGISTER failed: error %d\n",
@@ -504,7 +505,7 @@ static int vidioc_s_register (struct file *file, void *priv,
} }
#endif #endif
static int vidioc_querycap (struct file *file, void *priv, static int vidioc_querycap(struct file *file, void *priv,
struct v4l2_capability *vc) struct v4l2_capability *vc)
{ {
struct usb_usbvision *usbvision = video_drvdata(file); struct usb_usbvision *usbvision = video_drvdata(file);
@@ -523,7 +524,7 @@ static int vidioc_querycap (struct file *file, void *priv,
return 0; return 0;
} }
static int vidioc_enum_input (struct file *file, void *priv, static int vidioc_enum_input(struct file *file, void *priv,
struct v4l2_input *vi) struct v4l2_input *vi)
{ {
struct usb_usbvision *usbvision = video_drvdata(file); struct usb_usbvision *usbvision = video_drvdata(file);
@@ -531,14 +532,14 @@ static int vidioc_enum_input (struct file *file, void *priv,
if (vi->index >= usbvision->video_inputs) if (vi->index >= usbvision->video_inputs)
return -EINVAL; return -EINVAL;
if (usbvision->have_tuner) { if (usbvision->have_tuner)
chan = vi->index; chan = vi->index;
} else { else
chan = vi->index + 1; /* skip Television string*/ chan = vi->index + 1; /* skip Television string*/
}
/* Determine the requested input characteristics /* Determine the requested input characteristics
specific for each usbvision card model */ specific for each usbvision card model */
switch(chan) { switch (chan) {
case 0: case 0:
if (usbvision_device_data[usbvision->dev_model].video_channels == 4) { if (usbvision_device_data[usbvision->dev_model].video_channels == 4) {
strcpy(vi->name, "White Video Input"); strcpy(vi->name, "White Video Input");
@@ -552,20 +553,18 @@ static int vidioc_enum_input (struct file *file, void *priv,
break; break;
case 1: case 1:
vi->type = V4L2_INPUT_TYPE_CAMERA; vi->type = V4L2_INPUT_TYPE_CAMERA;
if (usbvision_device_data[usbvision->dev_model].video_channels == 4) { if (usbvision_device_data[usbvision->dev_model].video_channels == 4)
strcpy(vi->name, "Green Video Input"); strcpy(vi->name, "Green Video Input");
} else { else
strcpy(vi->name, "Composite Video Input"); strcpy(vi->name, "Composite Video Input");
}
vi->std = V4L2_STD_PAL; vi->std = V4L2_STD_PAL;
break; break;
case 2: case 2:
vi->type = V4L2_INPUT_TYPE_CAMERA; vi->type = V4L2_INPUT_TYPE_CAMERA;
if (usbvision_device_data[usbvision->dev_model].video_channels == 4) { if (usbvision_device_data[usbvision->dev_model].video_channels == 4)
strcpy(vi->name, "Yellow Video Input"); strcpy(vi->name, "Yellow Video Input");
} else { else
strcpy(vi->name, "S-Video Input"); strcpy(vi->name, "S-Video Input");
}
vi->std = V4L2_STD_PAL; vi->std = V4L2_STD_PAL;
break; break;
case 3: case 3:
@@ -577,7 +576,7 @@ static int vidioc_enum_input (struct file *file, void *priv,
return 0; return 0;
} }
static int vidioc_g_input (struct file *file, void *priv, unsigned int *input) static int vidioc_g_input(struct file *file, void *priv, unsigned int *input)
{ {
struct usb_usbvision *usbvision = video_drvdata(file); struct usb_usbvision *usbvision = video_drvdata(file);
@@ -585,7 +584,7 @@ static int vidioc_g_input (struct file *file, void *priv, unsigned int *input)
return 0; return 0;
} }
static int vidioc_s_input (struct file *file, void *priv, unsigned int input) static int vidioc_s_input(struct file *file, void *priv, unsigned int input)
{ {
struct usb_usbvision *usbvision = video_drvdata(file); struct usb_usbvision *usbvision = video_drvdata(file);
@@ -600,11 +599,11 @@ static int vidioc_s_input (struct file *file, void *priv, unsigned int input)
return 0; return 0;
} }
static int vidioc_s_std (struct file *file, void *priv, v4l2_std_id *id) static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *id)
{ {
struct usb_usbvision *usbvision = video_drvdata(file); struct usb_usbvision *usbvision = video_drvdata(file);
usbvision->tvnorm_id=*id; usbvision->tvnorm_id = *id;
call_all(usbvision, core, s_std, usbvision->tvnorm_id); call_all(usbvision, core, s_std, usbvision->tvnorm_id);
/* propagate the change to the decoder */ /* propagate the change to the decoder */
@@ -613,14 +612,14 @@ static int vidioc_s_std (struct file *file, void *priv, v4l2_std_id *id)
return 0; return 0;
} }
static int vidioc_g_tuner (struct file *file, void *priv, static int vidioc_g_tuner(struct file *file, void *priv,
struct v4l2_tuner *vt) struct v4l2_tuner *vt)
{ {
struct usb_usbvision *usbvision = video_drvdata(file); struct usb_usbvision *usbvision = video_drvdata(file);
if (!usbvision->have_tuner || vt->index) /* Only tuner 0 */ if (!usbvision->have_tuner || vt->index) /* Only tuner 0 */
return -EINVAL; return -EINVAL;
if(usbvision->radio) { if (usbvision->radio) {
strcpy(vt->name, "Radio"); strcpy(vt->name, "Radio");
vt->type = V4L2_TUNER_RADIO; vt->type = V4L2_TUNER_RADIO;
} else { } else {
@@ -632,7 +631,7 @@ static int vidioc_g_tuner (struct file *file, void *priv,
return 0; return 0;
} }
static int vidioc_s_tuner (struct file *file, void *priv, static int vidioc_s_tuner(struct file *file, void *priv,
struct v4l2_tuner *vt) struct v4l2_tuner *vt)
{ {
struct usb_usbvision *usbvision = video_drvdata(file); struct usb_usbvision *usbvision = video_drvdata(file);
@@ -646,23 +645,22 @@ static int vidioc_s_tuner (struct file *file, void *priv,
return 0; return 0;
} }
static int vidioc_g_frequency (struct file *file, void *priv, static int vidioc_g_frequency(struct file *file, void *priv,
struct v4l2_frequency *freq) struct v4l2_frequency *freq)
{ {
struct usb_usbvision *usbvision = video_drvdata(file); struct usb_usbvision *usbvision = video_drvdata(file);
freq->tuner = 0; /* Only one tuner */ freq->tuner = 0; /* Only one tuner */
if(usbvision->radio) { if (usbvision->radio)
freq->type = V4L2_TUNER_RADIO; freq->type = V4L2_TUNER_RADIO;
} else { else
freq->type = V4L2_TUNER_ANALOG_TV; freq->type = V4L2_TUNER_ANALOG_TV;
}
freq->frequency = usbvision->freq; freq->frequency = usbvision->freq;
return 0; return 0;
} }
static int vidioc_s_frequency (struct file *file, void *priv, static int vidioc_s_frequency(struct file *file, void *priv,
struct v4l2_frequency *freq) struct v4l2_frequency *freq)
{ {
struct usb_usbvision *usbvision = video_drvdata(file); struct usb_usbvision *usbvision = video_drvdata(file);
@@ -677,30 +675,27 @@ static int vidioc_s_frequency (struct file *file, void *priv,
return 0; return 0;
} }
static int vidioc_g_audio (struct file *file, void *priv, struct v4l2_audio *a) static int vidioc_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
{ {
struct usb_usbvision *usbvision = video_drvdata(file); struct usb_usbvision *usbvision = video_drvdata(file);
if(usbvision->radio) { if (usbvision->radio)
strcpy(a->name,"Radio"); strcpy(a->name, "Radio");
} else { else
strcpy(a->name, "TV"); strcpy(a->name, "TV");
}
return 0; return 0;
} }
static int vidioc_s_audio (struct file *file, void *fh, static int vidioc_s_audio(struct file *file, void *fh,
struct v4l2_audio *a) struct v4l2_audio *a)
{ {
if(a->index) { if (a->index)
return -EINVAL; return -EINVAL;
}
return 0; return 0;
} }
static int vidioc_queryctrl (struct file *file, void *priv, static int vidioc_queryctrl(struct file *file, void *priv,
struct v4l2_queryctrl *ctrl) struct v4l2_queryctrl *ctrl)
{ {
struct usb_usbvision *usbvision = video_drvdata(file); struct usb_usbvision *usbvision = video_drvdata(file);
@@ -713,52 +708,53 @@ static int vidioc_queryctrl (struct file *file, void *priv,
return 0; return 0;
} }
static int vidioc_g_ctrl (struct file *file, void *priv, static int vidioc_g_ctrl(struct file *file, void *priv,
struct v4l2_control *ctrl) struct v4l2_control *ctrl)
{ {
struct usb_usbvision *usbvision = video_drvdata(file); struct usb_usbvision *usbvision = video_drvdata(file);
call_all(usbvision, core, g_ctrl, ctrl); call_all(usbvision, core, g_ctrl, ctrl);
return 0; return 0;
} }
static int vidioc_s_ctrl (struct file *file, void *priv, static int vidioc_s_ctrl(struct file *file, void *priv,
struct v4l2_control *ctrl) struct v4l2_control *ctrl)
{ {
struct usb_usbvision *usbvision = video_drvdata(file); struct usb_usbvision *usbvision = video_drvdata(file);
call_all(usbvision, core, s_ctrl, ctrl);
call_all(usbvision, core, s_ctrl, ctrl);
return 0; return 0;
} }
static int vidioc_reqbufs (struct file *file, static int vidioc_reqbufs(struct file *file,
void *priv, struct v4l2_requestbuffers *vr) void *priv, struct v4l2_requestbuffers *vr)
{ {
struct usb_usbvision *usbvision = video_drvdata(file); struct usb_usbvision *usbvision = video_drvdata(file);
int ret; int ret;
RESTRICT_TO_RANGE(vr->count,1,USBVISION_NUMFRAMES); RESTRICT_TO_RANGE(vr->count, 1, USBVISION_NUMFRAMES);
/* Check input validity: /* Check input validity:
the user must do a VIDEO CAPTURE and MMAP method. */ the user must do a VIDEO CAPTURE and MMAP method. */
if (vr->memory != V4L2_MEMORY_MMAP) if (vr->memory != V4L2_MEMORY_MMAP)
return -EINVAL; return -EINVAL;
if(usbvision->streaming == stream_on) { if (usbvision->streaming == stream_on) {
if ((ret = usbvision_stream_interrupt(usbvision))) ret = usbvision_stream_interrupt(usbvision);
if (ret)
return ret; return ret;
} }
usbvision_frames_free(usbvision); usbvision_frames_free(usbvision);
usbvision_empty_framequeues(usbvision); usbvision_empty_framequeues(usbvision);
vr->count = usbvision_frames_alloc(usbvision,vr->count); vr->count = usbvision_frames_alloc(usbvision, vr->count);
usbvision->cur_frame = NULL; usbvision->cur_frame = NULL;
return 0; return 0;
} }
static int vidioc_querybuf (struct file *file, static int vidioc_querybuf(struct file *file,
void *priv, struct v4l2_buffer *vb) void *priv, struct v4l2_buffer *vb)
{ {
struct usb_usbvision *usbvision = video_drvdata(file); struct usb_usbvision *usbvision = video_drvdata(file);
@@ -766,48 +762,45 @@ static int vidioc_querybuf (struct file *file,
/* FIXME : must control /* FIXME : must control
that buffers are mapped (VIDIOC_REQBUFS has been called) */ that buffers are mapped (VIDIOC_REQBUFS has been called) */
if(vb->index>=usbvision->num_frames) { if (vb->index >= usbvision->num_frames)
return -EINVAL; return -EINVAL;
}
/* Updating the corresponding frame state */ /* Updating the corresponding frame state */
vb->flags = 0; vb->flags = 0;
frame = &usbvision->frame[vb->index]; frame = &usbvision->frame[vb->index];
if(frame->grabstate >= frame_state_ready) if (frame->grabstate >= frame_state_ready)
vb->flags |= V4L2_BUF_FLAG_QUEUED; vb->flags |= V4L2_BUF_FLAG_QUEUED;
if(frame->grabstate >= frame_state_done) if (frame->grabstate >= frame_state_done)
vb->flags |= V4L2_BUF_FLAG_DONE; vb->flags |= V4L2_BUF_FLAG_DONE;
if(frame->grabstate == frame_state_unused) if (frame->grabstate == frame_state_unused)
vb->flags |= V4L2_BUF_FLAG_MAPPED; vb->flags |= V4L2_BUF_FLAG_MAPPED;
vb->memory = V4L2_MEMORY_MMAP; vb->memory = V4L2_MEMORY_MMAP;
vb->m.offset = vb->index*PAGE_ALIGN(usbvision->max_frame_size); vb->m.offset = vb->index * PAGE_ALIGN(usbvision->max_frame_size);
vb->memory = V4L2_MEMORY_MMAP; vb->memory = V4L2_MEMORY_MMAP;
vb->field = V4L2_FIELD_NONE; vb->field = V4L2_FIELD_NONE;
vb->length = usbvision->curwidth* vb->length = usbvision->curwidth *
usbvision->curheight* usbvision->curheight *
usbvision->palette.bytes_per_pixel; usbvision->palette.bytes_per_pixel;
vb->timestamp = usbvision->frame[vb->index].timestamp; vb->timestamp = usbvision->frame[vb->index].timestamp;
vb->sequence = usbvision->frame[vb->index].sequence; vb->sequence = usbvision->frame[vb->index].sequence;
return 0; return 0;
} }
static int vidioc_qbuf (struct file *file, void *priv, struct v4l2_buffer *vb) static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *vb)
{ {
struct usb_usbvision *usbvision = video_drvdata(file); struct usb_usbvision *usbvision = video_drvdata(file);
struct usbvision_frame *frame; struct usbvision_frame *frame;
unsigned long lock_flags; unsigned long lock_flags;
/* FIXME : works only on VIDEO_CAPTURE MODE, MMAP. */ /* FIXME : works only on VIDEO_CAPTURE MODE, MMAP. */
if(vb->index>=usbvision->num_frames) { if (vb->index >= usbvision->num_frames)
return -EINVAL; return -EINVAL;
}
frame = &usbvision->frame[vb->index]; frame = &usbvision->frame[vb->index];
if (frame->grabstate != frame_state_unused) { if (frame->grabstate != frame_state_unused)
return -EAGAIN; return -EAGAIN;
}
/* Mark it as ready and enqueue frame */ /* Mark it as ready and enqueue frame */
frame->grabstate = frame_state_ready; frame->grabstate = frame_state_ready;
@@ -826,7 +819,7 @@ static int vidioc_qbuf (struct file *file, void *priv, struct v4l2_buffer *vb)
return 0; return 0;
} }
static int vidioc_dqbuf (struct file *file, void *priv, struct v4l2_buffer *vb) static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *vb)
{ {
struct usb_usbvision *usbvision = video_drvdata(file); struct usb_usbvision *usbvision = video_drvdata(file);
int ret; int ret;
@@ -882,7 +875,7 @@ static int vidioc_streamoff(struct file *file,
if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE) if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
return -EINVAL; return -EINVAL;
if(usbvision->streaming == stream_on) { if (usbvision->streaming == stream_on) {
usbvision_stream_interrupt(usbvision); usbvision_stream_interrupt(usbvision);
/* Stop all video streamings */ /* Stop all video streamings */
call_all(usbvision, video, s_stream, 0); call_all(usbvision, video, s_stream, 0);
@@ -892,18 +885,17 @@ static int vidioc_streamoff(struct file *file,
return 0; return 0;
} }
static int vidioc_enum_fmt_vid_cap (struct file *file, void *priv, static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
struct v4l2_fmtdesc *vfd) struct v4l2_fmtdesc *vfd)
{ {
if(vfd->index>=USBVISION_SUPPORTED_PALETTES-1) { if (vfd->index >= USBVISION_SUPPORTED_PALETTES - 1)
return -EINVAL; return -EINVAL;
} strcpy(vfd->description, usbvision_v4l2_format[vfd->index].desc);
strcpy(vfd->description,usbvision_v4l2_format[vfd->index].desc);
vfd->pixelformat = usbvision_v4l2_format[vfd->index].format; vfd->pixelformat = usbvision_v4l2_format[vfd->index].format;
return 0; return 0;
} }
static int vidioc_g_fmt_vid_cap (struct file *file, void *priv, static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
struct v4l2_format *vf) struct v4l2_format *vf)
{ {
struct usb_usbvision *usbvision = video_drvdata(file); struct usb_usbvision *usbvision = video_drvdata(file);
@@ -911,32 +903,31 @@ static int vidioc_g_fmt_vid_cap (struct file *file, void *priv,
vf->fmt.pix.height = usbvision->curheight; vf->fmt.pix.height = usbvision->curheight;
vf->fmt.pix.pixelformat = usbvision->palette.format; vf->fmt.pix.pixelformat = usbvision->palette.format;
vf->fmt.pix.bytesperline = vf->fmt.pix.bytesperline =
usbvision->curwidth*usbvision->palette.bytes_per_pixel; usbvision->curwidth * usbvision->palette.bytes_per_pixel;
vf->fmt.pix.sizeimage = vf->fmt.pix.bytesperline*usbvision->curheight; vf->fmt.pix.sizeimage = vf->fmt.pix.bytesperline * usbvision->curheight;
vf->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; vf->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
vf->fmt.pix.field = V4L2_FIELD_NONE; /* Always progressive image */ vf->fmt.pix.field = V4L2_FIELD_NONE; /* Always progressive image */
return 0; return 0;
} }
static int vidioc_try_fmt_vid_cap (struct file *file, void *priv, static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
struct v4l2_format *vf) struct v4l2_format *vf)
{ {
struct usb_usbvision *usbvision = video_drvdata(file); struct usb_usbvision *usbvision = video_drvdata(file);
int format_idx; int format_idx;
/* Find requested format in available ones */ /* Find requested format in available ones */
for(format_idx=0;format_idx<USBVISION_SUPPORTED_PALETTES;format_idx++) { for (format_idx = 0; format_idx < USBVISION_SUPPORTED_PALETTES; format_idx++) {
if(vf->fmt.pix.pixelformat == if (vf->fmt.pix.pixelformat ==
usbvision_v4l2_format[format_idx].format) { usbvision_v4l2_format[format_idx].format) {
usbvision->palette = usbvision_v4l2_format[format_idx]; usbvision->palette = usbvision_v4l2_format[format_idx];
break; break;
} }
} }
/* robustness */ /* robustness */
if(format_idx == USBVISION_SUPPORTED_PALETTES) { if (format_idx == USBVISION_SUPPORTED_PALETTES)
return -EINVAL; return -EINVAL;
}
RESTRICT_TO_RANGE(vf->fmt.pix.width, MIN_FRAME_WIDTH, MAX_FRAME_WIDTH); RESTRICT_TO_RANGE(vf->fmt.pix.width, MIN_FRAME_WIDTH, MAX_FRAME_WIDTH);
RESTRICT_TO_RANGE(vf->fmt.pix.height, MIN_FRAME_HEIGHT, MAX_FRAME_HEIGHT); RESTRICT_TO_RANGE(vf->fmt.pix.height, MIN_FRAME_HEIGHT, MAX_FRAME_HEIGHT);
@@ -953,13 +944,14 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
struct usb_usbvision *usbvision = video_drvdata(file); struct usb_usbvision *usbvision = video_drvdata(file);
int ret; int ret;
if( 0 != (ret=vidioc_try_fmt_vid_cap (file, priv, vf)) ) { ret = vidioc_try_fmt_vid_cap(file, priv, vf);
if (ret)
return ret; return ret;
}
/* stop io in case it is already in progress */ /* stop io in case it is already in progress */
if(usbvision->streaming == stream_on) { if (usbvision->streaming == stream_on) {
if ((ret = usbvision_stream_interrupt(usbvision))) ret = usbvision_stream_interrupt(usbvision);
if (ret)
return ret; return ret;
} }
usbvision_frames_free(usbvision); usbvision_frames_free(usbvision);
@@ -979,8 +971,7 @@ static ssize_t usbvision_v4l2_read(struct file *file, char __user *buf,
struct usb_usbvision *usbvision = video_drvdata(file); struct usb_usbvision *usbvision = video_drvdata(file);
int noblock = file->f_flags & O_NONBLOCK; int noblock = file->f_flags & O_NONBLOCK;
unsigned long lock_flags; unsigned long lock_flags;
int ret, i;
int ret,i;
struct usbvision_frame *frame; struct usbvision_frame *frame;
PDEBUG(DBG_IO, "%s: %ld bytes, noblock=%d", __func__, PDEBUG(DBG_IO, "%s: %ld bytes, noblock=%d", __func__,
@@ -992,15 +983,15 @@ static ssize_t usbvision_v4l2_read(struct file *file, char __user *buf,
/* This entry point is compatible with the mmap routines /* This entry point is compatible with the mmap routines
so that a user can do either VIDIOC_QBUF/VIDIOC_DQBUF so that a user can do either VIDIOC_QBUF/VIDIOC_DQBUF
to get frames or call read on the device. */ to get frames or call read on the device. */
if(!usbvision->num_frames) { if (!usbvision->num_frames) {
/* First, allocate some frames to work with /* First, allocate some frames to work with
if this has not been done with VIDIOC_REQBUF */ if this has not been done with VIDIOC_REQBUF */
usbvision_frames_free(usbvision); usbvision_frames_free(usbvision);
usbvision_empty_framequeues(usbvision); usbvision_empty_framequeues(usbvision);
usbvision_frames_alloc(usbvision,USBVISION_NUMFRAMES); usbvision_frames_alloc(usbvision, USBVISION_NUMFRAMES);
} }
if(usbvision->streaming != stream_on) { if (usbvision->streaming != stream_on) {
/* no stream is running, make it running ! */ /* no stream is running, make it running ! */
usbvision->streaming = stream_on; usbvision->streaming = stream_on;
call_all(usbvision, video, s_stream, 1); call_all(usbvision, video, s_stream, 1);
@@ -1008,9 +999,9 @@ static ssize_t usbvision_v4l2_read(struct file *file, char __user *buf,
/* Then, enqueue as many frames as possible /* Then, enqueue as many frames as possible
(like a user of VIDIOC_QBUF would do) */ (like a user of VIDIOC_QBUF would do) */
for(i=0;i<usbvision->num_frames;i++) { for (i = 0; i < usbvision->num_frames; i++) {
frame = &usbvision->frame[i]; frame = &usbvision->frame[i];
if(frame->grabstate == frame_state_unused) { if (frame->grabstate == frame_state_unused) {
/* Mark it as ready and enqueue frame */ /* Mark it as ready and enqueue frame */
frame->grabstate = frame_state_ready; frame->grabstate = frame_state_ready;
frame->scanstate = scan_state_scanning; frame->scanstate = scan_state_scanning;
@@ -1029,7 +1020,7 @@ static ssize_t usbvision_v4l2_read(struct file *file, char __user *buf,
/* Then try to steal a frame (like a VIDIOC_DQBUF would do) */ /* Then try to steal a frame (like a VIDIOC_DQBUF would do) */
if (list_empty(&(usbvision->outqueue))) { if (list_empty(&(usbvision->outqueue))) {
if(noblock) if (noblock)
return -EAGAIN; return -EAGAIN;
ret = wait_event_interruptible ret = wait_event_interruptible
@@ -1059,9 +1050,8 @@ static ssize_t usbvision_v4l2_read(struct file *file, char __user *buf,
if ((count + frame->bytes_read) > (unsigned long)frame->scanlength) if ((count + frame->bytes_read) > (unsigned long)frame->scanlength)
count = frame->scanlength - frame->bytes_read; count = frame->scanlength - frame->bytes_read;
if (copy_to_user(buf, frame->data + frame->bytes_read, count)) { if (copy_to_user(buf, frame->data + frame->bytes_read, count))
return -EFAULT; return -EFAULT;
}
frame->bytes_read += count; frame->bytes_read += count;
PDEBUG(DBG_IO, "%s: {copy} count used=%ld, new bytes_read=%ld", PDEBUG(DBG_IO, "%s: {copy} count used=%ld, new bytes_read=%ld",
@@ -1069,12 +1059,12 @@ static ssize_t usbvision_v4l2_read(struct file *file, char __user *buf,
(unsigned long)count, frame->bytes_read); (unsigned long)count, frame->bytes_read);
/* For now, forget the frame if it has not been read in one shot. */ /* For now, forget the frame if it has not been read in one shot. */
/* if (frame->bytes_read >= frame->scanlength) {*/ /* All data has been read */ /* if (frame->bytes_read >= frame->scanlength) {*/ /* All data has been read */
frame->bytes_read = 0; frame->bytes_read = 0;
/* Mark it as available to be used again. */ /* Mark it as available to be used again. */
frame->grabstate = frame_state_unused; frame->grabstate = frame_state_unused;
/* } */ /* } */
return count; return count;
} }
@@ -1089,9 +1079,8 @@ static int usbvision_v4l2_mmap(struct file *file, struct vm_area_struct *vma)
PDEBUG(DBG_MMAP, "mmap"); PDEBUG(DBG_MMAP, "mmap");
if (!USBVISION_IS_OPERATIONAL(usbvision)) { if (!USBVISION_IS_OPERATIONAL(usbvision))
return -EFAULT; return -EFAULT;
}
if (!(vma->vm_flags & VM_WRITE) || if (!(vma->vm_flags & VM_WRITE) ||
size != PAGE_ALIGN(usbvision->max_frame_size)) { size != PAGE_ALIGN(usbvision->max_frame_size)) {
@@ -1115,7 +1104,6 @@ static int usbvision_v4l2_mmap(struct file *file, struct vm_area_struct *vma)
pos = usbvision->frame[i].data; pos = usbvision->frame[i].data;
while (size > 0) { while (size > 0) {
if (vm_insert_page(vma, start, vmalloc_to_page(pos))) { if (vm_insert_page(vma, start, vmalloc_to_page(pos))) {
PDEBUG(DBG_MMAP, "mmap: vm_insert_page failed"); PDEBUG(DBG_MMAP, "mmap: vm_insert_page failed");
return -EAGAIN; return -EAGAIN;
@@ -1145,9 +1133,8 @@ static int usbvision_radio_open(struct file *file)
"%s: Someone tried to open an already opened USBVision Radio!\n", "%s: Someone tried to open an already opened USBVision Radio!\n",
__func__); __func__);
err_code = -EBUSY; err_code = -EBUSY;
} } else {
else { if (power_on_at_open) {
if(power_on_at_open) {
usbvision_reset_power_off_timer(usbvision); usbvision_reset_power_off_timer(usbvision);
if (usbvision->power == 0) { if (usbvision->power == 0) {
usbvision_power_on(usbvision); usbvision_power_on(usbvision);
@@ -1190,12 +1177,12 @@ static int usbvision_radio_close(struct file *file)
PDEBUG(DBG_IO, ""); PDEBUG(DBG_IO, "");
/* Set packet size to 0 */ /* Set packet size to 0 */
usbvision->iface_alt=0; usbvision->iface_alt = 0;
err_code = usb_set_interface(usbvision->dev, usbvision->iface, err_code = usb_set_interface(usbvision->dev, usbvision->iface,
usbvision->iface_alt); usbvision->iface_alt);
usbvision_audio_off(usbvision); usbvision_audio_off(usbvision);
usbvision->radio=0; usbvision->radio = 0;
usbvision->user--; usbvision->user--;
if (power_on_at_open) { if (power_on_at_open) {
@@ -1222,7 +1209,7 @@ static const struct v4l2_file_operations usbvision_fops = {
.read = usbvision_v4l2_read, .read = usbvision_v4l2_read,
.mmap = usbvision_v4l2_mmap, .mmap = usbvision_v4l2_mmap,
.unlocked_ioctl = video_ioctl2, .unlocked_ioctl = video_ioctl2,
/* .poll = video_poll, */ /* .poll = video_poll, */
}; };
static const struct v4l2_ioctl_ops usbvision_ioctl_ops = { static const struct v4l2_ioctl_ops usbvision_ioctl_ops = {
@@ -1258,11 +1245,11 @@ static const struct v4l2_ioctl_ops usbvision_ioctl_ops = {
static struct video_device usbvision_video_template = { static struct video_device usbvision_video_template = {
.fops = &usbvision_fops, .fops = &usbvision_fops,
.ioctl_ops = &usbvision_ioctl_ops, .ioctl_ops = &usbvision_ioctl_ops,
.name = "usbvision-video", .name = "usbvision-video",
.release = video_device_release, .release = video_device_release,
.tvnorms = USBVISION_NORMS, .tvnorms = USBVISION_NORMS,
.current_norm = V4L2_STD_PAL .current_norm = V4L2_STD_PAL
}; };
@@ -1292,9 +1279,9 @@ static const struct v4l2_ioctl_ops usbvision_radio_ioctl_ops = {
static struct video_device usbvision_radio_template = { static struct video_device usbvision_radio_template = {
.fops = &usbvision_radio_fops, .fops = &usbvision_radio_fops,
.name = "usbvision-radio", .name = "usbvision-radio",
.release = video_device_release, .release = video_device_release,
.ioctl_ops = &usbvision_radio_ioctl_ops, .ioctl_ops = &usbvision_radio_ioctl_ops,
.tvnorms = USBVISION_NORMS, .tvnorms = USBVISION_NORMS,
.current_norm = V4L2_STD_PAL .current_norm = V4L2_STD_PAL
@@ -1315,9 +1302,8 @@ static struct video_device *usbvision_vdev_init(struct usb_usbvision *usbvision,
} }
vdev = video_device_alloc(); vdev = video_device_alloc();
if (NULL == vdev) { if (NULL == vdev)
return NULL; return NULL;
}
*vdev = *vdev_template; *vdev = *vdev_template;
vdev->lock = &usbvision->v4l2_lock; vdev->lock = &usbvision->v4l2_lock;
vdev->v4l2_dev = &usbvision->v4l2_dev; vdev->v4l2_dev = &usbvision->v4l2_dev;
@@ -1333,11 +1319,10 @@ static void usbvision_unregister_video(struct usb_usbvision *usbvision)
if (usbvision->rdev) { if (usbvision->rdev) {
PDEBUG(DBG_PROBE, "unregister %s [v4l2]", PDEBUG(DBG_PROBE, "unregister %s [v4l2]",
video_device_node_name(usbvision->rdev)); video_device_node_name(usbvision->rdev));
if (video_is_registered(usbvision->rdev)) { if (video_is_registered(usbvision->rdev))
video_unregister_device(usbvision->rdev); video_unregister_device(usbvision->rdev);
} else { else
video_device_release(usbvision->rdev); video_device_release(usbvision->rdev);
}
usbvision->rdev = NULL; usbvision->rdev = NULL;
} }
@@ -1345,11 +1330,10 @@ static void usbvision_unregister_video(struct usb_usbvision *usbvision)
if (usbvision->vdev) { if (usbvision->vdev) {
PDEBUG(DBG_PROBE, "unregister %s [v4l2]", PDEBUG(DBG_PROBE, "unregister %s [v4l2]",
video_device_node_name(usbvision->vdev)); video_device_node_name(usbvision->vdev));
if (video_is_registered(usbvision->vdev)) { if (video_is_registered(usbvision->vdev))
video_unregister_device(usbvision->vdev); video_unregister_device(usbvision->vdev);
} else { else
video_device_release(usbvision->vdev); video_device_release(usbvision->vdev);
}
usbvision->vdev = NULL; usbvision->vdev = NULL;
} }
} }
@@ -1361,14 +1345,10 @@ static int __devinit usbvision_register_video(struct usb_usbvision *usbvision)
usbvision->vdev = usbvision_vdev_init(usbvision, usbvision->vdev = usbvision_vdev_init(usbvision,
&usbvision_video_template, &usbvision_video_template,
"USBVision Video"); "USBVision Video");
if (usbvision->vdev == NULL) { if (usbvision->vdev == NULL)
goto err_exit; goto err_exit;
} if (video_register_device(usbvision->vdev, VFL_TYPE_GRABBER, video_nr) < 0)
if (video_register_device(usbvision->vdev,
VFL_TYPE_GRABBER,
video_nr)<0) {
goto err_exit; goto err_exit;
}
printk(KERN_INFO "USBVision[%d]: registered USBVision Video device %s [v4l2]\n", printk(KERN_INFO "USBVision[%d]: registered USBVision Video device %s [v4l2]\n",
usbvision->nr, video_device_node_name(usbvision->vdev)); usbvision->nr, video_device_node_name(usbvision->vdev));
@@ -1378,14 +1358,10 @@ static int __devinit usbvision_register_video(struct usb_usbvision *usbvision)
usbvision->rdev = usbvision_vdev_init(usbvision, usbvision->rdev = usbvision_vdev_init(usbvision,
&usbvision_radio_template, &usbvision_radio_template,
"USBVision Radio"); "USBVision Radio");
if (usbvision->rdev == NULL) { if (usbvision->rdev == NULL)
goto err_exit; goto err_exit;
} if (video_register_device(usbvision->rdev, VFL_TYPE_RADIO, radio_nr) < 0)
if (video_register_device(usbvision->rdev,
VFL_TYPE_RADIO,
radio_nr)<0) {
goto err_exit; goto err_exit;
}
printk(KERN_INFO "USBVision[%d]: registered USBVision Radio device %s [v4l2]\n", printk(KERN_INFO "USBVision[%d]: registered USBVision Radio device %s [v4l2]\n",
usbvision->nr, video_device_node_name(usbvision->rdev)); usbvision->nr, video_device_node_name(usbvision->rdev));
} }
@@ -1459,9 +1435,7 @@ static void usbvision_release(struct usb_usbvision *usbvision)
usbvision_remove_sysfs(usbvision->vdev); usbvision_remove_sysfs(usbvision->vdev);
usbvision_unregister_video(usbvision); usbvision_unregister_video(usbvision);
if (usbvision->ctrl_urb) { usb_free_urb(usbvision->ctrl_urb);
usb_free_urb(usbvision->ctrl_urb);
}
v4l2_device_unregister(&usbvision->v4l2_dev); v4l2_device_unregister(&usbvision->v4l2_dev);
kfree(usbvision); kfree(usbvision);
@@ -1520,25 +1494,24 @@ static int __devinit usbvision_probe(struct usb_interface *intf,
const struct usb_host_interface *interface; const struct usb_host_interface *interface;
struct usb_usbvision *usbvision = NULL; struct usb_usbvision *usbvision = NULL;
const struct usb_endpoint_descriptor *endpoint; const struct usb_endpoint_descriptor *endpoint;
int model,i; int model, i;
PDEBUG(DBG_PROBE, "VID=%#04x, PID=%#04x, ifnum=%u", PDEBUG(DBG_PROBE, "VID=%#04x, PID=%#04x, ifnum=%u",
dev->descriptor.idVendor, dev->descriptor.idVendor,
dev->descriptor.idProduct, ifnum); dev->descriptor.idProduct, ifnum);
model = devid->driver_info; model = devid->driver_info;
if ( (model<0) || (model>=usbvision_device_data_size) ) { if (model < 0 || model >= usbvision_device_data_size) {
PDEBUG(DBG_PROBE, "model out of bounds %d",model); PDEBUG(DBG_PROBE, "model out of bounds %d", model);
return -ENODEV; return -ENODEV;
} }
printk(KERN_INFO "%s: %s found\n", __func__, printk(KERN_INFO "%s: %s found\n", __func__,
usbvision_device_data[model].model_string); usbvision_device_data[model].model_string);
if (usbvision_device_data[model].interface >= 0) { if (usbvision_device_data[model].interface >= 0)
interface = &dev->actconfig->interface[usbvision_device_data[model].interface]->altsetting[0]; interface = &dev->actconfig->interface[usbvision_device_data[model].interface]->altsetting[0];
} else { else
interface = &dev->actconfig->interface[ifnum]->altsetting[0]; interface = &dev->actconfig->interface[ifnum]->altsetting[0];
}
endpoint = &interface->endpoint[1].desc; endpoint = &interface->endpoint[1].desc;
if (!usb_endpoint_xfer_isoc(endpoint)) { if (!usb_endpoint_xfer_isoc(endpoint)) {
dev_err(&intf->dev, "%s: interface %d. has non-ISO endpoint!\n", dev_err(&intf->dev, "%s: interface %d. has non-ISO endpoint!\n",
@@ -1559,33 +1532,31 @@ static int __devinit usbvision_probe(struct usb_interface *intf,
return -ENOMEM; return -ENOMEM;
} }
if (dev->descriptor.bNumConfigurations > 1) { if (dev->descriptor.bNumConfigurations > 1)
usbvision->bridge_type = BRIDGE_NT1004; usbvision->bridge_type = BRIDGE_NT1004;
} else if (model == DAZZLE_DVC_90_REV_1_SECAM) { else if (model == DAZZLE_DVC_90_REV_1_SECAM)
usbvision->bridge_type = BRIDGE_NT1005; usbvision->bridge_type = BRIDGE_NT1005;
} else { else
usbvision->bridge_type = BRIDGE_NT1003; usbvision->bridge_type = BRIDGE_NT1003;
}
PDEBUG(DBG_PROBE, "bridge_type %d", usbvision->bridge_type); PDEBUG(DBG_PROBE, "bridge_type %d", usbvision->bridge_type);
/* compute alternate max packet sizes */ /* compute alternate max packet sizes */
uif = dev->actconfig->interface[0]; uif = dev->actconfig->interface[0];
usbvision->num_alt=uif->num_altsetting; usbvision->num_alt = uif->num_altsetting;
PDEBUG(DBG_PROBE, "Alternate settings: %i",usbvision->num_alt); PDEBUG(DBG_PROBE, "Alternate settings: %i", usbvision->num_alt);
usbvision->alt_max_pkt_size = kmalloc(32* usbvision->alt_max_pkt_size = kmalloc(32 * usbvision->num_alt, GFP_KERNEL);
usbvision->num_alt,GFP_KERNEL);
if (usbvision->alt_max_pkt_size == NULL) { if (usbvision->alt_max_pkt_size == NULL) {
dev_err(&intf->dev, "usbvision: out of memory!\n"); dev_err(&intf->dev, "usbvision: out of memory!\n");
return -ENOMEM; return -ENOMEM;
} }
for (i = 0; i < usbvision->num_alt ; i++) { for (i = 0; i < usbvision->num_alt; i++) {
u16 tmp = le16_to_cpu(uif->altsetting[i].endpoint[1].desc. u16 tmp = le16_to_cpu(uif->altsetting[i].endpoint[1].desc.
wMaxPacketSize); wMaxPacketSize);
usbvision->alt_max_pkt_size[i] = usbvision->alt_max_pkt_size[i] =
(tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1); (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
PDEBUG(DBG_PROBE, "Alternate setting %i, max size= %i",i, PDEBUG(DBG_PROBE, "Alternate setting %i, max size= %i", i,
usbvision->alt_max_pkt_size[i]); usbvision->alt_max_pkt_size[i]);
} }
@@ -1593,9 +1564,8 @@ static int __devinit usbvision_probe(struct usb_interface *intf,
usbvision->nr = usbvision_nr++; usbvision->nr = usbvision_nr++;
usbvision->have_tuner = usbvision_device_data[model].tuner; usbvision->have_tuner = usbvision_device_data[model].tuner;
if (usbvision->have_tuner) { if (usbvision->have_tuner)
usbvision->tuner_type = usbvision_device_data[model].tuner_type; usbvision->tuner_type = usbvision_device_data[model].tuner_type;
}
usbvision->dev_model = model; usbvision->dev_model = model;
usbvision->remove_pending = 0; usbvision->remove_pending = 0;
@@ -1689,7 +1659,7 @@ static int __init usbvision_init(void)
PDEBUG(DBG_MMAP, "MMAP debugging is enabled [video]"); PDEBUG(DBG_MMAP, "MMAP debugging is enabled [video]");
/* disable planar mode support unless compression enabled */ /* disable planar mode support unless compression enabled */
if (isoc_mode != ISOC_MODE_COMPRESS ) { if (isoc_mode != ISOC_MODE_COMPRESS) {
/* FIXME : not the right way to set supported flag */ /* FIXME : not the right way to set supported flag */
usbvision_v4l2_format[6].supported = 0; /* V4L2_PIX_FMT_YVU420 */ usbvision_v4l2_format[6].supported = 0; /* V4L2_PIX_FMT_YVU420 */
usbvision_v4l2_format[7].supported = 0; /* V4L2_PIX_FMT_YUV422P */ usbvision_v4l2_format[7].supported = 0; /* V4L2_PIX_FMT_YUV422P */
@@ -1706,10 +1676,10 @@ static int __init usbvision_init(void)
static void __exit usbvision_exit(void) static void __exit usbvision_exit(void)
{ {
PDEBUG(DBG_PROBE, ""); PDEBUG(DBG_PROBE, "");
usb_deregister(&usbvision_driver); usb_deregister(&usbvision_driver);
PDEBUG(DBG_PROBE, "success"); PDEBUG(DBG_PROBE, "success");
} }
module_init(usbvision_init); module_init(usbvision_init);

47
drivers/media/video/usbvision/usbvision.h
View File

@@ -139,7 +139,7 @@
#define MAX_USB_HEIGHT 240 /* 288 */ #define MAX_USB_HEIGHT 240 /* 288 */
#define MAX_FRAME_HEIGHT 240 /* 288 */ /* Streching sometimes causes crashes*/ #define MAX_FRAME_HEIGHT 240 /* 288 */ /* Streching sometimes causes crashes*/
#define MAX_FRAME_SIZE (MAX_FRAME_WIDTH * MAX_FRAME_HEIGHT * MAX_BYTES_PER_PIXEL) #define MAX_FRAME_SIZE (MAX_FRAME_WIDTH * MAX_FRAME_HEIGHT * MAX_BYTES_PER_PIXEL)
#define USBVISION_CLIPMASK_SIZE (MAX_FRAME_WIDTH * MAX_FRAME_HEIGHT / 8) /* bytesize of clipmask */ #define USBVISION_CLIPMASK_SIZE (MAX_FRAME_WIDTH * MAX_FRAME_HEIGHT / 8) /* bytesize of clipmask */
#define USBVISION_URB_FRAMES 32 #define USBVISION_URB_FRAMES 32
@@ -148,7 +148,7 @@
#define USBVISION_NUMFRAMES 3 /* Maximum number of frames an application can get */ #define USBVISION_NUMFRAMES 3 /* Maximum number of frames an application can get */
#define USBVISION_NUMSBUF 2 /* Dimensioning the USB S buffering */ #define USBVISION_NUMSBUF 2 /* Dimensioning the USB S buffering */
#define USBVISION_POWEROFF_TIME 3 * (HZ) /* 3 seconds */ #define USBVISION_POWEROFF_TIME (3 * HZ) /* 3 seconds */
#define FRAMERATE_MIN 0 #define FRAMERATE_MIN 0
@@ -161,7 +161,8 @@ enum {
}; };
/* This macro restricts an int variable to an inclusive range */ /* This macro restricts an int variable to an inclusive range */
#define RESTRICT_TO_RANGE(v,mi,ma) { if ((v) < (mi)) (v) = (mi); else if ((v) > (ma)) (v) = (ma); } #define RESTRICT_TO_RANGE(v, mi, ma) \
{ if ((v) < (mi)) (v) = (mi); else if ((v) > (ma)) (v) = (ma); }
/* /*
* We use macros to do YUV -> RGB conversion because this is * We use macros to do YUV -> RGB conversion because this is
@@ -183,18 +184,18 @@ enum {
* Make sure the output values are within [0..255] range. * Make sure the output values are within [0..255] range.
*/ */
#define LIMIT_RGB(x) (((x) < 0) ? 0 : (((x) > 255) ? 255 : (x))) #define LIMIT_RGB(x) (((x) < 0) ? 0 : (((x) > 255) ? 255 : (x)))
#define YUV_TO_RGB_BY_THE_BOOK(my,mu,mv,mr,mg,mb) { \ #define YUV_TO_RGB_BY_THE_BOOK(my, mu, mv, mr, mg, mb) { \
int mm_y, mm_yc, mm_u, mm_v, mm_r, mm_g, mm_b; \ int mm_y, mm_yc, mm_u, mm_v, mm_r, mm_g, mm_b; \
mm_y = (my) - 16; \ mm_y = (my) - 16; \
mm_u = (mu) - 128; \ mm_u = (mu) - 128; \
mm_v = (mv) - 128; \ mm_v = (mv) - 128; \
mm_yc= mm_y * 76284; \ mm_yc = mm_y * 76284; \
mm_b = (mm_yc + 132252*mm_v ) >> 16; \ mm_b = (mm_yc + 132252 * mm_v) >> 16; \
mm_g = (mm_yc - 53281*mm_u - 25625*mm_v ) >> 16; \ mm_g = (mm_yc - 53281 * mm_u - 25625 * mm_v) >> 16; \
mm_r = (mm_yc + 104595*mm_u ) >> 16; \ mm_r = (mm_yc + 104595 * mm_u) >> 16; \
mb = LIMIT_RGB(mm_b); \ mb = LIMIT_RGB(mm_b); \
mg = LIMIT_RGB(mm_g); \ mg = LIMIT_RGB(mm_g); \
mr = LIMIT_RGB(mm_r); \ mr = LIMIT_RGB(mm_r); \
} }
/* Debugging aid */ /* Debugging aid */
@@ -202,7 +203,7 @@ enum {
wait_queue_head_t wq; \ wait_queue_head_t wq; \
init_waitqueue_head(&wq); \ init_waitqueue_head(&wq); \
printk(KERN_INFO "Say: %s\n", what); \ printk(KERN_INFO "Say: %s\n", what); \
interruptible_sleep_on_timeout (&wq, HZ*3); \ interruptible_sleep_on_timeout(&wq, HZ * 3); \
} }
/* /*
@@ -265,8 +266,8 @@ struct usbvision_sbuf {
struct urb *urb; struct urb *urb;
}; };
#define USBVISION_MAGIC_1 0x55 #define USBVISION_MAGIC_1 0x55
#define USBVISION_MAGIC_2 0xAA #define USBVISION_MAGIC_2 0xAA
#define USBVISION_HEADER_LENGTH 0x0c #define USBVISION_HEADER_LENGTH 0x0c
#define USBVISION_SAA7111_ADDR 0x48 #define USBVISION_SAA7111_ADDR 0x48
#define USBVISION_SAA7113_ADDR 0x4a #define USBVISION_SAA7113_ADDR 0x4a
@@ -358,8 +359,8 @@ extern struct usb_device_id usbvision_table[];
struct usb_usbvision { struct usb_usbvision {
struct v4l2_device v4l2_dev; struct v4l2_device v4l2_dev;
struct video_device *vdev; /* Video Device */ struct video_device *vdev; /* Video Device */
struct video_device *rdev; /* Radio Device */ struct video_device *rdev; /* Radio Device */
/* i2c Declaration Section*/ /* i2c Declaration Section*/
struct i2c_adapter i2c_adap; struct i2c_adapter i2c_adap;
@@ -401,7 +402,7 @@ struct usb_usbvision {
enum stream_state streaming; /* Are we streaming Isochronous? */ enum stream_state streaming; /* Are we streaming Isochronous? */
int last_error; /* What calamity struck us? */ int last_error; /* What calamity struck us? */
int curwidth; /* width of the frame the device is currently set to*/ int curwidth; /* width of the frame the device is currently set to*/
int curheight; /* height of the frame the device is currently set to*/ int curheight; /* height of the frame the device is currently set to*/
int stretch_width; /* stretch-factor for frame width (from usb to screen)*/ int stretch_width; /* stretch-factor for frame width (from usb to screen)*/
int stretch_height; /* stretch-factor for frame height (from usb to screen)*/ int stretch_height; /* stretch-factor for frame height (from usb to screen)*/
char *fbuf; /* Videodev buffer area for mmap*/ char *fbuf; /* Videodev buffer area for mmap*/
@@ -434,7 +435,7 @@ struct usb_usbvision {
/* Decompression stuff: */ /* Decompression stuff: */
unsigned char *intra_frame_buffer; /* Buffer for reference frame */ unsigned char *intra_frame_buffer; /* Buffer for reference frame */
int block_pos; /* for test only */ int block_pos; /* for test only */
int request_intra; /* 0 = normal; 1 = intra frame is requested; */ int request_intra; /* 0 = normal; 1 = intra frame is requested; */
int last_isoc_frame_num; /* check for lost isoc frames */ int last_isoc_frame_num; /* check for lost isoc frames */
int isoc_packet_size; /* need to calculate used_bandwidth */ int isoc_packet_size; /* need to calculate used_bandwidth */
@@ -494,7 +495,7 @@ void usbvision_scratch_free(struct usb_usbvision *usbvision);
int usbvision_decompress_alloc(struct usb_usbvision *usbvision); int usbvision_decompress_alloc(struct usb_usbvision *usbvision);
void usbvision_decompress_free(struct usb_usbvision *usbvision); void usbvision_decompress_free(struct usb_usbvision *usbvision);
int usbvision_setup(struct usb_usbvision *usbvision,int format); int usbvision_setup(struct usb_usbvision *usbvision, int format);
int usbvision_init_isoc(struct usb_usbvision *usbvision); int usbvision_init_isoc(struct usb_usbvision *usbvision);
int usbvision_restart_isoc(struct usb_usbvision *usbvision); int usbvision_restart_isoc(struct usb_usbvision *usbvision);
void usbvision_stop_isoc(struct usb_usbvision *usbvision); void usbvision_stop_isoc(struct usb_usbvision *usbvision);