patch-2.4.20 linux-2.4.20/drivers/usb/ov511.c
Next file: linux-2.4.20/drivers/usb/ov511.h
Previous file: linux-2.4.20/drivers/usb/microtek.c
Back to the patch index
Back to the overall index
- Lines: 5378
- Date:
Thu Nov 28 15:53:14 2002
- Orig file:
linux-2.4.19/drivers/usb/ov511.c
- Orig date:
Fri Aug 2 17:39:45 2002
diff -urN linux-2.4.19/drivers/usb/ov511.c linux-2.4.20/drivers/usb/ov511.c
@@ -9,7 +9,8 @@
* OV7620 fixes by Charl P. Botha <cpbotha@ieee.org>
* Changes by Claudio Matsuoka <claudio@conectiva.com>
* Original SAA7111A code by Dave Perks <dperks@ibm.net>
- * Kernel I2C interface adapted from nt1003 driver
+ * URB error messages from pwc driver by Nemosoft
+ * generic_ioctl() code from videodev.c by Gerd Knorr and Alan Cox
*
* Based on the Linux CPiA driver written by Peter Pregler,
* Scott J. Bertin and Johannes Erdfelt.
@@ -57,19 +58,22 @@
/*
* Version Information
*/
-#define DRIVER_VERSION "v1.50 for Linux 2.4"
-#define EMAIL "mmcclell@bigfoot.com"
+#define DRIVER_VERSION "v1.61 for Linux 2.4"
+#define EMAIL "mark@alpha.dyndns.org"
#define DRIVER_AUTHOR "Mark McClelland <mmcclell@bigfoot.com> & Bret Wallach \
& Orion Sky Lawlor <olawlor@acm.org> & Kevin Moore & Charl P. Botha \
<cpbotha@ieee.org> & Claudio Matsuoka <claudio@conectiva.com>"
-#define DRIVER_DESC "OV511 USB Camera Driver"
+#define DRIVER_DESC "ov511 USB Camera Driver"
#define OV511_I2C_RETRIES 3
#define ENABLE_Y_QUANTABLE 1
#define ENABLE_UV_QUANTABLE 1
+#define OV511_MAX_UNIT_VIDEO 16
+
/* Pixel count * 3 bytes for RGB */
#define MAX_FRAME_SIZE(w, h) ((w) * (h) * 3)
+
#define MAX_DATA_SIZE(w, h) (MAX_FRAME_SIZE(w, h) + sizeof(struct timeval))
/* Max size * bytes per YUV420 pixel (1.5) + one extra isoc frame for safety */
@@ -77,128 +81,47 @@
#define FATAL_ERROR(rc) ((rc) < 0 && (rc) != -EPERM)
-/* PARAMETER VARIABLES: */
-/* (See ov511.txt for detailed descriptions of these.) */
-
-/* Sensor automatically changes brightness */
-static int autobright = 1;
-
-/* Sensor automatically changes gain */
-static int autogain = 1;
-
-/* Sensor automatically changes exposure */
-static int autoexp = 1;
-
-/* 0=no debug messages
- * 1=init/detection/unload and other significant messages,
- * 2=some warning messages
- * 3=config/control function calls
- * 4=most function calls and data parsing messages
- * 5=highly repetitive mesgs
- * NOTE: This should be changed to 0, 1, or 2 for production kernels
- */
-static int debug; /* = 0 */
-
-/* Fix vertical misalignment of red and blue at 640x480 */
-static int fix_rgb_offset; /* = 0 */
-
-/* Snapshot mode enabled flag */
-static int snapshot; /* = 0 */
-
-/* Force image to be read in RGB instead of BGR. This option allow
- * programs that expect RGB data (e.g. gqcam) to work with this driver. */
-static int force_rgb; /* = 0 */
-
-/* Number of seconds before inactive buffers are deallocated */
-static int buf_timeout = 5;
-
-/* Number of cameras to stream from simultaneously */
-static int cams = 1;
-
-/* Enable compression. Needs a fast (>300 MHz) CPU. */
-static int compress; /* = 0 */
-
-/* Display test pattern - doesn't work yet either */
-static int testpat; /* = 0 */
-
-/* Setting this to 1 will make the sensor output GBR422 instead of YUV420. Only
- * affects RGB24 mode. */
-static int sensor_gbr; /* = 0 */
-
-/* Dump raw pixel data. */
-static int dumppix; /* = 0 */
-
-/* LED policy. Only works on some OV511+ cameras. 0=off, 1=on (default), 2=auto
- * (on when open) */
-static int led = 1;
-
-/* Set this to 1 to dump the bridge register contents after initialization */
-static int dump_bridge; /* = 0 */
-
-/* Set this to 1 to dump the sensor register contents after initialization */
-static int dump_sensor; /* = 0 */
-
-/* Temporary option for debugging "works, but no image" problem. Prints the
- * first 12 bytes of data (potentially a packet header) in each isochronous
- * data frame. */
-static int printph; /* = 0 */
-
-/* Compression parameters - I'm not exactly sure what these do yet */
-static int phy = 0x1f;
-static int phuv = 0x05;
-static int pvy = 0x06;
-static int pvuv = 0x06;
-static int qhy = 0x14;
-static int qhuv = 0x03;
-static int qvy = 0x04;
-static int qvuv = 0x04;
-
-/* Light frequency. Set to 50 or 60 (Hz), or zero for default settings */
-static int lightfreq; /* = 0 */
-
-/* Set this to 1 to enable banding filter by default. Compensates for
- * alternating horizontal light/dark bands caused by (usually fluorescent)
- * lights */
-static int bandingfilter; /* = 0 */
-
-/* Pixel clock divisor */
-static int clockdiv = -1;
-
-/* Isoc packet size */
-static int packetsize = -1;
-
-/* Frame drop register (16h) */
-static int framedrop = -1;
-
-/* Allows picture settings (brightness, hue, etc...) to take effect immediately,
- * even in the middle of a frame. This reduces the time to change settings, but
- * can ruin frames during the change. Only affects OmniVision sensors. */
-static int fastset; /* = 0 */
-
-/* Forces the palette to a specific value. If an application requests a
- * different palette, it will be rejected. */
-static int force_palette; /* = 0 */
-
-/* Set tuner type, if not autodetected */
-static int tuner = -1;
-
-/* Allows proper exposure of objects that are illuminated from behind. Only
- * affects OmniVision sensors. */
-static int backlight; /* = 0 */
-
-/* If you change this, you must also change the MODULE_PARM definition */
-#define OV511_MAX_UNIT_VIDEO 16
+/**********************************************************************
+ * Module Parameters
+ * (See ov511.txt for detailed descriptions of these)
+ **********************************************************************/
-/* Allows specified minor numbers to be forced. They will be assigned in the
- * order that devices are detected. Note that you cannot specify 0 as a minor
- * number. If you do not specify any, the next available one will be used. This
- * requires kernel 2.4.5 or later. */
+/* These variables (and all static globals) default to zero */
+static int autobright = 1;
+static int autogain = 1;
+static int autoexp = 1;
+static int debug;
+static int snapshot;
+static int fix_rgb_offset;
+static int force_rgb;
+static int cams = 1;
+static int compress;
+static int testpat;
+static int sensor_gbr;
+static int dumppix;
+static int led = 1;
+static int dump_bridge;
+static int dump_sensor;
+static int printph;
+static int phy = 0x1f;
+static int phuv = 0x05;
+static int pvy = 0x06;
+static int pvuv = 0x06;
+static int qhy = 0x14;
+static int qhuv = 0x03;
+static int qvy = 0x04;
+static int qvuv = 0x04;
+static int lightfreq;
+static int bandingfilter;
+static int clockdiv = -1;
+static int packetsize = -1;
+static int framedrop = -1;
+static int fastset;
+static int force_palette;
+static int backlight;
static int unit_video[OV511_MAX_UNIT_VIDEO];
-
-/* Remove zero-padding from uncompressed incoming data. This will compensate for
- * the blocks of corruption that appear when the camera cannot keep up with the
- * speed of the USB bus (eg. at low frame resolutions) */
-static int remove_zeros; /* = 0 */
+static int remove_zeros;
+static int mirror;
MODULE_PARM(autobright, "i");
MODULE_PARM_DESC(autobright, "Sensor automatically changes brightness");
@@ -209,15 +132,13 @@
MODULE_PARM(debug, "i");
MODULE_PARM_DESC(debug,
"Debug level: 0=none, 1=inits, 2=warning, 3=config, 4=functions, 5=max");
+MODULE_PARM(snapshot, "i");
+MODULE_PARM_DESC(snapshot, "Enable snapshot mode");
MODULE_PARM(fix_rgb_offset, "i");
MODULE_PARM_DESC(fix_rgb_offset,
"Fix vertical misalignment of red and blue at 640x480");
-MODULE_PARM(snapshot, "i");
-MODULE_PARM_DESC(snapshot, "Enable snapshot mode");
MODULE_PARM(force_rgb, "i");
MODULE_PARM_DESC(force_rgb, "Read RGB instead of BGR");
-MODULE_PARM(buf_timeout, "i");
-MODULE_PARM_DESC(buf_timeout, "Number of seconds before buffer deallocation");
MODULE_PARM(cams, "i");
MODULE_PARM_DESC(cams, "Number of simultaneous cameras");
MODULE_PARM(compress, "i");
@@ -225,11 +146,6 @@
MODULE_PARM(testpat, "i");
MODULE_PARM_DESC(testpat,
"Replace image with vertical bar testpattern (only partially working)");
-
-// Temporarily removed (needs to be rewritten for new format conversion code)
-// MODULE_PARM(sensor_gbr, "i");
-// MODULE_PARM_DESC(sensor_gbr, "Make sensor output GBR422 rather than YUV420");
-
MODULE_PARM(dumppix, "i");
MODULE_PARM_DESC(dumppix, "Dump raw pixel data");
MODULE_PARM(led, "i");
@@ -273,21 +189,25 @@
MODULE_PARM_DESC(fastset, "Allows picture settings to take effect immediately");
MODULE_PARM(force_palette, "i");
MODULE_PARM_DESC(force_palette, "Force the palette to a specific value");
-MODULE_PARM(tuner, "i");
-MODULE_PARM_DESC(tuner, "Set tuner type, if not autodetected");
MODULE_PARM(backlight, "i");
MODULE_PARM_DESC(backlight, "For objects that are lit from behind");
-MODULE_PARM(unit_video, "0-16i");
+MODULE_PARM(unit_video, "1-" __MODULE_STRING(OV511_MAX_UNIT_VIDEO) "i");
MODULE_PARM_DESC(unit_video,
"Force use of specific minor number(s). 0 is not allowed.");
MODULE_PARM(remove_zeros, "i");
MODULE_PARM_DESC(remove_zeros,
"Remove zero-padding from uncompressed incoming data");
+MODULE_PARM(mirror, "i");
+MODULE_PARM_DESC(mirror, "Reverse image horizontally");
MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE("GPL");
+/**********************************************************************
+ * Miscellaneous Globals
+ **********************************************************************/
+
static struct usb_driver ov511_driver;
static struct ov51x_decomp_ops *ov511_decomp_ops;
@@ -302,20 +222,28 @@
/* MMX support is present in kernel and CPU. Checked upon decomp module load. */
static int ov51x_mmx_available;
-/* Function prototypes */
-static void ov51x_clear_snapshot(struct usb_ov511 *);
-static int ov51x_check_snapshot(struct usb_ov511 *);
-static inline int sensor_get_picture(struct usb_ov511 *,
- struct video_picture *);
-static int sensor_get_exposure(struct usb_ov511 *, unsigned char *);
-static int ov51x_control_ioctl(struct inode *, struct file *, unsigned int,
- unsigned long);
+static __devinitdata struct usb_device_id device_table [] = {
+ { USB_DEVICE(VEND_OMNIVISION, PROD_OV511) },
+ { USB_DEVICE(VEND_OMNIVISION, PROD_OV511PLUS) },
+ { USB_DEVICE(VEND_OMNIVISION, PROD_OV518) },
+ { USB_DEVICE(VEND_OMNIVISION, PROD_OV518PLUS) },
+ { USB_DEVICE(VEND_MATTEL, PROD_ME2CAM) },
+ { } /* Terminating entry */
+};
+
+MODULE_DEVICE_TABLE (usb, device_table);
+
+static unsigned char yQuanTable511[] = OV511_YQUANTABLE;
+static unsigned char uvQuanTable511[] = OV511_UVQUANTABLE;
+static unsigned char yQuanTable518[] = OV518_YQUANTABLE;
+static unsigned char uvQuanTable518[] = OV518_UVQUANTABLE;
/**********************************************************************
- * List of known OV511-based cameras
+ * Symbolic Names
**********************************************************************/
-static struct cam_list clist[] = {
+/* Known OV511-based cameras */
+static struct symbolic_list camlist[] = {
{ 0, "Generic Camera (no ID)" },
{ 1, "Mustek WCam 3X" },
{ 3, "D-Link DSB-C300" },
@@ -323,11 +251,13 @@
{ 5, "Puretek PT-6007" },
{ 6, "Lifeview USB Life TV (NTSC)" },
{ 21, "Creative Labs WebCam 3" },
+ { 22, "Lifeview USB Life TV (PAL D/K+B/G)" },
{ 36, "Koala-Cam" },
- { 38, "Lifeview USB Life TV" },
+ { 38, "Lifeview USB Life TV (PAL)" },
{ 41, "Samsung Anycam MPC-M10" },
{ 43, "Mtekvision Zeca MV402" },
{ 46, "Suma eON" },
+ { 70, "Lifeview USB Life TV (PAL/SECAM)" },
{ 100, "Lifeview RoboCam" },
{ 102, "AverMedia InterCam Elite" },
{ 112, "MediaForte MV300" }, /* or OV7110 evaluation kit */
@@ -335,97 +265,90 @@
{ -1, NULL }
};
-static __devinitdata struct usb_device_id device_table [] = {
- { USB_DEVICE(VEND_OMNIVISION, PROD_OV511) },
- { USB_DEVICE(VEND_OMNIVISION, PROD_OV511PLUS) },
- { USB_DEVICE(VEND_OMNIVISION, PROD_OV518) },
- { USB_DEVICE(VEND_OMNIVISION, PROD_OV518PLUS) },
- { USB_DEVICE(VEND_MATTEL, PROD_ME2CAM) },
- { } /* Terminating entry */
-};
-
-MODULE_DEVICE_TABLE (usb, device_table);
-
-#if defined(CONFIG_PROC_FS) && defined(CONFIG_VIDEO_PROC_FS)
-static struct palette_list plist[] = {
+/* Video4Linux1 Palettes */
+static struct symbolic_list v4l1_plist[] = {
{ VIDEO_PALETTE_GREY, "GREY" },
- { VIDEO_PALETTE_HI240, "HI240" },
- { VIDEO_PALETTE_RGB565, "RGB565" },
+ { VIDEO_PALETTE_HI240, "HI240" },
+ { VIDEO_PALETTE_RGB565, "RGB565" },
{ VIDEO_PALETTE_RGB24, "RGB24" },
{ VIDEO_PALETTE_RGB32, "RGB32" },
- { VIDEO_PALETTE_RGB555, "RGB555" },
- { VIDEO_PALETTE_YUV422, "YUV422" },
- { VIDEO_PALETTE_YUYV, "YUYV" },
- { VIDEO_PALETTE_UYVY, "UYVY" },
- { VIDEO_PALETTE_YUV420, "YUV420" },
- { VIDEO_PALETTE_YUV411, "YUV411" },
- { VIDEO_PALETTE_RAW, "RAW" },
+ { VIDEO_PALETTE_RGB555, "RGB555" },
+ { VIDEO_PALETTE_YUV422, "YUV422" },
+ { VIDEO_PALETTE_YUYV, "YUYV" },
+ { VIDEO_PALETTE_UYVY, "UYVY" },
+ { VIDEO_PALETTE_YUV420, "YUV420" },
+ { VIDEO_PALETTE_YUV411, "YUV411" },
+ { VIDEO_PALETTE_RAW, "RAW" },
{ VIDEO_PALETTE_YUV422P,"YUV422P" },
{ VIDEO_PALETTE_YUV411P,"YUV411P" },
{ VIDEO_PALETTE_YUV420P,"YUV420P" },
{ VIDEO_PALETTE_YUV410P,"YUV410P" },
{ -1, NULL }
};
-#endif
-static unsigned char yQuanTable511[] = OV511_YQUANTABLE;
-static unsigned char uvQuanTable511[] = OV511_UVQUANTABLE;
-static unsigned char yQuanTable518[] = OV518_YQUANTABLE;
-static unsigned char uvQuanTable518[] = OV518_UVQUANTABLE;
+static struct symbolic_list brglist[] = {
+ { BRG_OV511, "OV511" },
+ { BRG_OV511PLUS, "OV511+" },
+ { BRG_OV518, "OV518" },
+ { BRG_OV518PLUS, "OV518+" },
+ { -1, NULL }
+};
+
+static struct symbolic_list senlist[] = {
+ { SEN_OV76BE, "OV76BE" },
+ { SEN_OV7610, "OV7610" },
+ { SEN_OV7620, "OV7620" },
+ { SEN_OV7620AE, "OV7620AE" },
+ { SEN_OV6620, "OV6620" },
+ { SEN_OV6630, "OV6630" },
+ { SEN_OV6630AE, "OV6630AE" },
+ { SEN_OV6630AF, "OV6630AF" },
+ { SEN_OV8600, "OV8600" },
+ { SEN_KS0127, "KS0127" },
+ { SEN_KS0127B, "KS0127B" },
+ { SEN_SAA7111A, "SAA7111A" },
+ { -1, NULL }
+};
+
+/* URB error codes: */
+static struct symbolic_list urb_errlist[] = {
+ { -ENOSR, "Buffer error (overrun)" },
+ { -EPIPE, "Stalled (device not responding)" },
+ { -EOVERFLOW, "Babble (bad cable?)" },
+ { -EPROTO, "Bit-stuff error (bad cable?)" },
+ { -EILSEQ, "CRC/Timeout" },
+ { -ETIMEDOUT, "NAK (device does not respond)" },
+ { -1, NULL }
+};
/**********************************************************************
- *
- * Memory management
- *
- * This is a shameless copy from the USB-cpia driver (linux kernel
- * version 2.3.29 or so, I have no idea what this code actually does ;).
- * Actually it seems to be a copy of a shameless copy of the bttv-driver.
- * Or that is a copy of a shameless copy of ... (To the powers: is there
- * no generic kernel-function to do this sort of stuff?)
- *
- * Yes, it was a shameless copy from the bttv-driver. IIRC, Alan says
- * there will be one, but apparentely not yet -jerdfelt
- *
- * So I copied it again for the OV511 driver -claudio
+ * Prototypes
**********************************************************************/
-/* Given PGD from the address space's page table, return the kernel
- * virtual mapping of the physical memory mapped at ADR.
- */
-static inline unsigned long
-uvirt_to_kva(pgd_t *pgd, unsigned long adr)
-{
- unsigned long ret = 0UL;
- pmd_t *pmd;
- pte_t *ptep, pte;
-
- if (!pgd_none(*pgd)) {
- pmd = pmd_offset(pgd, adr);
- if (!pmd_none(*pmd)) {
- ptep = pte_offset(pmd, adr);
- pte = *ptep;
- if (pte_present(pte)) {
- ret = (unsigned long)
- page_address(pte_page(pte));
- ret |= (adr & (PAGE_SIZE - 1));
- }
- }
- }
+static void ov51x_clear_snapshot(struct usb_ov511 *);
+static inline int sensor_get_picture(struct usb_ov511 *,
+ struct video_picture *);
+#if defined(CONFIG_PROC_FS) && defined(CONFIG_VIDEO_PROC_FS)
+static int sensor_get_exposure(struct usb_ov511 *, unsigned char *);
+static int ov51x_control_ioctl(struct inode *, struct file *, unsigned int,
+ unsigned long);
+static int ov51x_check_snapshot(struct usb_ov511 *);
+#endif
- return ret;
-}
+/**********************************************************************
+ * Memory management
+ **********************************************************************/
/* Here we want the physical address of the memory.
- * This is used when initializing the contents of the
- * area and marking the pages as reserved.
+ * This is used when initializing the contents of the area.
*/
-static inline unsigned long
+static inline unsigned long
kvirt_to_pa(unsigned long adr)
{
- unsigned long va, kva, ret;
+ unsigned long kva, ret;
- va = VMALLOC_VMADDR(adr);
- kva = uvirt_to_kva(pgd_offset_k(va), va);
+ kva = (unsigned long) page_address(vmalloc_to_page((void *)adr));
+ kva |= adr & (PAGE_SIZE-1); /* restore the offset */
ret = __pa(kva);
return ret;
}
@@ -434,12 +357,9 @@
rvmalloc(unsigned long size)
{
void *mem;
- unsigned long adr, page;
-
- /* Round it off to PAGE_SIZE */
- size += (PAGE_SIZE - 1);
- size &= ~(PAGE_SIZE - 1);
+ unsigned long adr;
+ size = PAGE_ALIGN(size);
mem = vmalloc_32(size);
if (!mem)
return NULL;
@@ -447,38 +367,27 @@
memset(mem, 0, size); /* Clear the ram out, no junk to the user */
adr = (unsigned long) mem;
while (size > 0) {
- page = kvirt_to_pa(adr);
- mem_map_reserve(virt_to_page(__va(page)));
+ mem_map_reserve(vmalloc_to_page((void *)adr));
adr += PAGE_SIZE;
- if (size > PAGE_SIZE)
- size -= PAGE_SIZE;
- else
- size = 0;
+ size -= PAGE_SIZE;
}
return mem;
}
-static void
+static void
rvfree(void *mem, unsigned long size)
{
- unsigned long adr, page;
+ unsigned long adr;
if (!mem)
return;
- size += (PAGE_SIZE - 1);
- size &= ~(PAGE_SIZE - 1);
-
- adr=(unsigned long) mem;
- while (size > 0) {
- page = kvirt_to_pa(adr);
- mem_map_unreserve(virt_to_page(__va(page)));
+ adr = (unsigned long) mem;
+ while ((long) size > 0) {
+ mem_map_unreserve(vmalloc_to_page((void *)adr));
adr += PAGE_SIZE;
- if (size > PAGE_SIZE)
- size -= PAGE_SIZE;
- else
- size = 0;
+ size -= PAGE_SIZE;
}
vfree(mem);
}
@@ -500,12 +409,12 @@
#define YES_NO(x) ((x) ? "yes" : "no")
/* /proc/video/ov511/<minor#>/info */
-static int
+static int
ov511_read_proc_info(char *page, char **start, off_t off, int count, int *eof,
void *data)
{
char *out = page;
- int i, j, len;
+ int i, len;
struct usb_ov511 *ov = data;
struct video_picture p;
unsigned char exp;
@@ -521,8 +430,7 @@
out += sprintf(out, "driver_version : %s\n", DRIVER_VERSION);
out += sprintf(out, "custom_id : %d\n", ov->customid);
- out += sprintf(out, "model : %s\n", ov->desc ?
- clist[ov->desc].description : "unknown");
+ out += sprintf(out, "model : %s\n", ov->desc);
out += sprintf(out, "streaming : %s\n", YES_NO(ov->streaming));
out += sprintf(out, "grabbing : %s\n", YES_NO(ov->grabbing));
out += sprintf(out, "compress : %s\n", YES_NO(ov->compress));
@@ -543,36 +451,16 @@
ov->frame[i].depth);
out += sprintf(out, " size : %d %d\n",
ov->frame[i].width, ov->frame[i].height);
- out += sprintf(out, " format : ");
- for (j = 0; plist[j].num >= 0; j++) {
- if (plist[j].num == ov->frame[i].format) {
- out += sprintf(out, "%s\n", plist[j].name);
- break;
- }
- }
- if (plist[j].num < 0)
- out += sprintf(out, "unknown\n");
+ out += sprintf(out, " format : %s\n",
+ symbolic(v4l1_plist, ov->frame[i].format));
out += sprintf(out, " data_buffer : 0x%p\n",
ov->frame[i].data);
}
out += sprintf(out, "snap_enabled : %s\n", YES_NO(ov->snap_enabled));
out += sprintf(out, "bridge : %s\n",
- ov->bridge == BRG_OV511 ? "OV511" :
- ov->bridge == BRG_OV511PLUS ? "OV511+" :
- ov->bridge == BRG_OV518 ? "OV518" :
- ov->bridge == BRG_OV518PLUS ? "OV518+" :
- "unknown");
+ symbolic(brglist, ov->bridge));
out += sprintf(out, "sensor : %s\n",
- ov->sensor == SEN_OV6620 ? "OV6620" :
- ov->sensor == SEN_OV6630 ? "OV6630" :
- ov->sensor == SEN_OV7610 ? "OV7610" :
- ov->sensor == SEN_OV7620 ? "OV7620" :
- ov->sensor == SEN_OV7620AE ? "OV7620AE" :
- ov->sensor == SEN_OV8600 ? "OV8600" :
- ov->sensor == SEN_KS0127 ? "KS0127" :
- ov->sensor == SEN_KS0127B ? "KS0127B" :
- ov->sensor == SEN_SAA7111A ? "SAA7111A" :
- "unknown");
+ symbolic(senlist, ov->sensor));
out += sprintf(out, "packet_size : %d\n", ov->packet_size);
out += sprintf(out, "framebuffer : 0x%p\n", ov->fbuf);
@@ -595,13 +483,13 @@
* When the camera's button is pressed, the output of this will change from a
* 0 to a 1 (ASCII). It will retain this value until it is read, after which
* it will reset to zero.
- *
+ *
* SECURITY NOTE: Since reading this file can change the state of the snapshot
* status, it is important for applications that open it to keep it locked
* against access by other processes, using flock() or a similar mechanism. No
* locking is provided by this driver.
*/
-static int
+static int
ov511_read_proc_button(char *page, char **start, off_t off, int count, int *eof,
void *data)
{
@@ -633,97 +521,95 @@
return len;
}
-static void
-create_proc_ov511_cam(struct usb_ov511 *ov511)
+static void
+create_proc_ov511_cam(struct usb_ov511 *ov)
{
char dirname[10];
- if (!ov511_proc_entry || !ov511)
+ if (!ov511_proc_entry || !ov)
return;
/* Create per-device directory */
- snprintf(dirname, 10, "%d", ov511->vdev.minor);
+ snprintf(dirname, 10, "%d", ov->vdev.minor);
PDEBUG(4, "creating /proc/video/ov511/%s/", dirname);
- ov511->proc_devdir = create_proc_entry(dirname, S_IFDIR,
- ov511_proc_entry);
- if (!ov511->proc_devdir)
+ ov->proc_devdir = create_proc_entry(dirname, S_IFDIR, ov511_proc_entry);
+ if (!ov->proc_devdir)
return;
- ov511->proc_devdir->owner = THIS_MODULE;
+ ov->proc_devdir->owner = THIS_MODULE;
/* Create "info" entry (human readable device information) */
PDEBUG(4, "creating /proc/video/ov511/%s/info", dirname);
- ov511->proc_info = create_proc_read_entry("info",
- S_IFREG|S_IRUGO|S_IWUSR, ov511->proc_devdir,
- ov511_read_proc_info, ov511);
- if (!ov511->proc_info)
+ ov->proc_info = create_proc_read_entry("info", S_IFREG|S_IRUGO|S_IWUSR,
+ ov->proc_devdir, ov511_read_proc_info, ov);
+ if (!ov->proc_info)
return;
- ov511->proc_info->owner = THIS_MODULE;
+ ov->proc_info->owner = THIS_MODULE;
/* Don't create it if old snapshot mode on (would cause race cond.) */
if (!snapshot) {
/* Create "button" entry (snapshot button status) */
PDEBUG(4, "creating /proc/video/ov511/%s/button", dirname);
- ov511->proc_button = create_proc_read_entry("button",
- S_IFREG|S_IRUGO|S_IWUSR, ov511->proc_devdir,
- ov511_read_proc_button, ov511);
- if (!ov511->proc_button)
+ ov->proc_button = create_proc_read_entry("button",
+ S_IFREG|S_IRUGO|S_IWUSR, ov->proc_devdir,
+ ov511_read_proc_button, ov);
+ if (!ov->proc_button)
return;
}
- ov511->proc_button->owner = THIS_MODULE;
+ ov->proc_button->owner = THIS_MODULE;
/* Create "control" entry (ioctl() interface) */
PDEBUG(4, "creating /proc/video/ov511/%s/control", dirname);
lock_kernel();
- ov511->proc_control = create_proc_entry("control",
- S_IFREG|S_IRUGO|S_IWUSR, ov511->proc_devdir);
- if (!ov511->proc_control) {
+ ov->proc_control = create_proc_entry("control", S_IFREG|S_IRUGO|S_IWUSR,
+ ov->proc_devdir);
+ if (!ov->proc_control) {
unlock_kernel();
return;
}
- ov511->proc_control->owner = THIS_MODULE;
- ov511->proc_control->data = ov511;
- ov511->proc_control->proc_fops = &ov511_control_fops;
+ ov->proc_control->owner = THIS_MODULE;
+ ov->proc_control->data = ov;
+ ov->proc_control->proc_fops = &ov511_control_fops;
unlock_kernel();
}
-static void
-destroy_proc_ov511_cam(struct usb_ov511 *ov511)
+static void
+destroy_proc_ov511_cam(struct usb_ov511 *ov)
{
char dirname[10];
-
- if (!ov511 || !ov511->proc_devdir)
+
+ if (!ov || !ov->proc_devdir)
return;
- snprintf(dirname, 10, "%d", ov511->vdev.minor);
+ snprintf(dirname, 10, "%d", ov->vdev.minor);
/* Destroy "control" entry */
- if (ov511->proc_control) {
+ if (ov->proc_control) {
PDEBUG(4, "destroying /proc/video/ov511/%s/control", dirname);
- remove_proc_entry("control", ov511->proc_devdir);
- ov511->proc_control = NULL;
+ remove_proc_entry("control", ov->proc_devdir);
+ ov->proc_control = NULL;
}
/* Destroy "button" entry */
- if (ov511->proc_button) {
+ if (ov->proc_button) {
PDEBUG(4, "destroying /proc/video/ov511/%s/button", dirname);
- remove_proc_entry("button", ov511->proc_devdir);
- ov511->proc_button = NULL;
+ remove_proc_entry("button", ov->proc_devdir);
+ ov->proc_button = NULL;
}
/* Destroy "info" entry */
- if (ov511->proc_info) {
+ if (ov->proc_info) {
PDEBUG(4, "destroying /proc/video/ov511/%s/info", dirname);
- remove_proc_entry("info", ov511->proc_devdir);
- ov511->proc_info = NULL;
+ remove_proc_entry("info", ov->proc_devdir);
+ ov->proc_info = NULL;
}
/* Destroy per-device directory */
PDEBUG(4, "destroying /proc/video/ov511/%s/", dirname);
remove_proc_entry(dirname, ov511_proc_entry);
- ov511->proc_devdir = NULL;
+ ov->proc_devdir = NULL;
}
-static void
+static void
proc_ov511_create(void)
{
/* No current standard here. Alan prefers /proc/video/ as it keeps
@@ -744,7 +630,7 @@
err("Unable to create /proc/video/ov511");
}
-static void
+static void
proc_ov511_destroy(void)
{
PDEBUG(3, "removing /proc/video/ov511");
@@ -763,7 +649,7 @@
**********************************************************************/
/* Write an OV51x register */
-static int
+static int
reg_w(struct usb_ov511 *ov, unsigned char reg, unsigned char value)
{
int rc;
@@ -774,20 +660,20 @@
ov->cbuf[0] = value;
rc = usb_control_msg(ov->dev,
usb_sndctrlpipe(ov->dev, 0),
- 2 /* REG_IO */,
- USB_TYPE_CLASS | USB_RECIP_DEVICE,
- 0, (__u16)reg, &ov->cbuf[0], 1, HZ);
+ (ov->bclass == BCL_OV518)?1:2 /* REG_IO */,
+ USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+ 0, (__u16)reg, &ov->cbuf[0], 1, HZ);
up(&ov->cbuf_lock);
if (rc < 0)
- err("reg write: error %d", rc);
+ err("reg write: error %d: %s", rc, symbolic(urb_errlist, rc));
return rc;
}
/* Read from an OV51x register */
/* returns: negative is error, pos or zero is data */
-static int
+static int
reg_r(struct usb_ov511 *ov, unsigned char reg)
{
int rc;
@@ -795,16 +681,16 @@
down(&ov->cbuf_lock);
rc = usb_control_msg(ov->dev,
usb_rcvctrlpipe(ov->dev, 0),
- 2 /* REG_IO */,
- USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_DEVICE,
+ (ov->bclass == BCL_OV518)?1:3 /* REG_IO */,
+ USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
0, (__u16)reg, &ov->cbuf[0], 1, HZ);
-
- PDEBUG(5, "0x%02X:0x%02X", reg, ov->cbuf[0]);
-
- if (rc < 0)
- err("reg read: error %d", rc);
- else
- rc = ov->cbuf[0];
+
+ if (rc < 0) {
+ err("reg read: error %d: %s", rc, symbolic(urb_errlist, rc));
+ } else {
+ rc = ov->cbuf[0];
+ PDEBUG(5, "0x%02X:0x%02X", reg, ov->cbuf[0]);
+ }
up(&ov->cbuf_lock);
@@ -814,10 +700,10 @@
/*
* Writes bits at positions specified by mask to an OV51x reg. Bits that are in
* the same position as 1's in "mask" are cleared and set to "value". Bits
- * that are in the same position as 0's in "mask" are preserved, regardless
+ * that are in the same position as 0's in "mask" are preserved, regardless
* of their respective state in "value".
*/
-static int
+static int
reg_w_mask(struct usb_ov511 *ov,
unsigned char reg,
unsigned char value,
@@ -842,7 +728,7 @@
* Writes multiple (n) byte value to a single register. Only valid with certain
* registers (0x30 and 0xc4 - 0xce).
*/
-static int
+static int
ov518_reg_w32(struct usb_ov511 *ov, unsigned char reg, u32 val, int n)
{
int rc;
@@ -855,18 +741,19 @@
rc = usb_control_msg(ov->dev,
usb_sndctrlpipe(ov->dev, 0),
- 2 /* REG_IO */,
- USB_TYPE_CLASS | USB_RECIP_DEVICE,
+ 1 /* REG_IO */,
+ USB_TYPE_VENDOR | USB_RECIP_DEVICE,
0, (__u16)reg, ov->cbuf, n, HZ);
up(&ov->cbuf_lock);
if (rc < 0)
- err("reg write multiple: error %d", rc);
+ err("reg write multiple: error %d: %s", rc,
+ symbolic(urb_errlist, rc));
return rc;
}
-static int
+static int
ov511_upload_quan_tables(struct usb_ov511 *ov)
{
unsigned char *pYTable = yQuanTable511;
@@ -876,10 +763,8 @@
PDEBUG(4, "Uploading quantization tables");
- for (i = 0; i < OV511_QUANTABLESIZE / 2; i++)
- {
- if (ENABLE_Y_QUANTABLE)
- {
+ for (i = 0; i < OV511_QUANTABLESIZE / 2; i++) {
+ if (ENABLE_Y_QUANTABLE) {
val0 = *pYTable++;
val1 = *pYTable++;
val0 &= 0x0f;
@@ -890,8 +775,7 @@
return rc;
}
- if (ENABLE_UV_QUANTABLE)
- {
+ if (ENABLE_UV_QUANTABLE) {
val0 = *pUVTable++;
val1 = *pUVTable++;
val0 &= 0x0f;
@@ -909,7 +793,7 @@
}
/* OV518 quantization tables are 8x4 (instead of 8x8) */
-static int
+static int
ov518_upload_quan_tables(struct usb_ov511 *ov)
{
unsigned char *pYTable = yQuanTable518;
@@ -919,10 +803,8 @@
PDEBUG(4, "Uploading quantization tables");
- for (i = 0; i < OV518_QUANTABLESIZE / 2; i++)
- {
- if (ENABLE_Y_QUANTABLE)
- {
+ for (i = 0; i < OV518_QUANTABLESIZE / 2; i++) {
+ if (ENABLE_Y_QUANTABLE) {
val0 = *pYTable++;
val1 = *pYTable++;
val0 &= 0x0f;
@@ -933,8 +815,7 @@
return rc;
}
- if (ENABLE_UV_QUANTABLE)
- {
+ if (ENABLE_UV_QUANTABLE) {
val0 = *pUVTable++;
val1 = *pUVTable++;
val0 &= 0x0f;
@@ -951,16 +832,16 @@
return 0;
}
-static int
+static int
ov51x_reset(struct usb_ov511 *ov, unsigned char reset_type)
{
int rc;
-
+
/* Setting bit 0 not allowed on 518/518Plus */
if (ov->bclass == BCL_OV518)
reset_type &= 0xfe;
- PDEBUG(4, "Reset: type=0x%X", reset_type);
+ PDEBUG(4, "Reset: type=0x%02X", reset_type);
rc = reg_w(ov, R51x_SYS_RESET, reset_type);
rc = reg_w(ov, R51x_SYS_RESET, 0);
@@ -973,7 +854,7 @@
/**********************************************************************
*
- * I2C (sensor) I/O
+ * Low-level I2C I/O functions
*
**********************************************************************/
@@ -982,7 +863,7 @@
* This is normally only called from i2c_w(). Note that this function
* always succeeds regardless of whether the sensor is present and working.
*/
-static int
+static int
ov518_i2c_write_internal(struct usb_ov511 *ov,
unsigned char reg,
unsigned char value)
@@ -993,25 +874,21 @@
/* Select camera register */
rc = reg_w(ov, R51x_I2C_SADDR_3, reg);
- if (rc < 0) goto error;
+ if (rc < 0) return rc;
/* Write "value" to I2C data port of OV511 */
rc = reg_w(ov, R51x_I2C_DATA, value);
- if (rc < 0) goto error;
+ if (rc < 0) return rc;
/* Initiate 3-byte write cycle */
rc = reg_w(ov, R518_I2C_CTL, 0x01);
- if (rc < 0) goto error;
+ if (rc < 0) return rc;
return 0;
-
-error:
- err("ov518 i2c write: error %d", rc);
- return rc;
}
/* NOTE: Do not call this function directly! */
-static int
+static int
ov511_i2c_write_internal(struct usb_ov511 *ov,
unsigned char reg,
unsigned char value)
@@ -1024,38 +901,33 @@
for (retries = OV511_I2C_RETRIES; ; ) {
/* Select camera register */
rc = reg_w(ov, R51x_I2C_SADDR_3, reg);
- if (rc < 0) goto error;
+ if (rc < 0) return rc;
/* Write "value" to I2C data port of OV511 */
- rc = reg_w(ov, R51x_I2C_DATA, value);
- if (rc < 0) goto error;
+ rc = reg_w(ov, R51x_I2C_DATA, value);
+ if (rc < 0) return rc;
/* Initiate 3-byte write cycle */
rc = reg_w(ov, R511_I2C_CTL, 0x01);
- if (rc < 0) goto error;
+ if (rc < 0) return rc;
do rc = reg_r(ov, R511_I2C_CTL);
while (rc > 0 && ((rc&1) == 0)); /* Retry until idle */
- if (rc < 0) goto error;
+ if (rc < 0) return rc;
if ((rc&2) == 0) /* Ack? */
break;
#if 0
- /* I2C abort */
+ /* I2C abort */
reg_w(ov, R511_I2C_CTL, 0x10);
#endif
if (--retries < 0) {
err("i2c write retries exhausted");
- rc = -1;
- goto error;
+ return -1;
}
}
return 0;
-
-error:
- err("i2c write: error %d", rc);
- return rc;
}
/* NOTE: Do not call this function directly!
@@ -1063,37 +935,33 @@
* This is normally only called from i2c_r(). Note that this function
* always succeeds regardless of whether the sensor is present and working.
*/
-static int
+static int
ov518_i2c_read_internal(struct usb_ov511 *ov, unsigned char reg)
{
int rc, value;
/* Select camera register */
rc = reg_w(ov, R51x_I2C_SADDR_2, reg);
- if (rc < 0) goto error;
+ if (rc < 0) return rc;
/* Initiate 2-byte write cycle */
rc = reg_w(ov, R518_I2C_CTL, 0x03);
- if (rc < 0) goto error;
+ if (rc < 0) return rc;
/* Initiate 2-byte read cycle */
rc = reg_w(ov, R518_I2C_CTL, 0x05);
- if (rc < 0) goto error;
+ if (rc < 0) return rc;
value = reg_r(ov, R51x_I2C_DATA);
PDEBUG(5, "0x%02X:0x%02X", reg, value);
return value;
-
-error:
- err("ov518 i2c read: error %d", rc);
- return rc;
}
/* NOTE: Do not call this function directly!
* returns: negative is error, pos or zero is data */
-static int
+static int
ov511_i2c_read_internal(struct usb_ov511 *ov, unsigned char reg)
{
int rc, value, retries;
@@ -1102,26 +970,25 @@
for (retries = OV511_I2C_RETRIES; ; ) {
/* Select camera register */
rc = reg_w(ov, R51x_I2C_SADDR_2, reg);
- if (rc < 0) goto error;
+ if (rc < 0) return rc;
/* Initiate 2-byte write cycle */
rc = reg_w(ov, R511_I2C_CTL, 0x03);
- if (rc < 0) goto error;
+ if (rc < 0) return rc;
do rc = reg_r(ov, R511_I2C_CTL);
while (rc > 0 && ((rc&1) == 0)); /* Retry until idle */
- if (rc < 0) goto error;
+ if (rc < 0) return rc;
if ((rc&2) == 0) /* Ack? */
break;
- /* I2C abort */
+ /* I2C abort */
reg_w(ov, R511_I2C_CTL, 0x10);
if (--retries < 0) {
err("i2c write retries exhausted");
- rc = -1;
- goto error;
+ return -1;
}
}
@@ -1129,44 +996,39 @@
for (retries = OV511_I2C_RETRIES; ; ) {
/* Initiate 2-byte read cycle */
rc = reg_w(ov, R511_I2C_CTL, 0x05);
- if (rc < 0) goto error;
+ if (rc < 0) return rc;
do rc = reg_r(ov, R511_I2C_CTL);
while (rc > 0 && ((rc&1) == 0)); /* Retry until idle */
- if (rc < 0) goto error;
+ if (rc < 0) return rc;
if ((rc&2) == 0) /* Ack? */
break;
- /* I2C abort */
+ /* I2C abort */
rc = reg_w(ov, R511_I2C_CTL, 0x10);
- if (rc < 0) goto error;
+ if (rc < 0) return rc;
if (--retries < 0) {
err("i2c read retries exhausted");
- rc = -1;
- goto error;
+ return -1;
}
}
value = reg_r(ov, R51x_I2C_DATA);
PDEBUG(5, "0x%02X:0x%02X", reg, value);
-
+
/* This is needed to make i2c_w() work */
rc = reg_w(ov, R511_I2C_CTL, 0x05);
if (rc < 0)
- goto error;
-
- return value;
+ return rc;
-error:
- err("i2c read: error %d", rc);
- return rc;
+ return value;
}
/* returns: negative is error, pos or zero is data */
-static int
+static int
i2c_r(struct usb_ov511 *ov, unsigned char reg)
{
int rc;
@@ -1183,7 +1045,7 @@
return rc;
}
-static int
+static int
i2c_w(struct usb_ov511 *ov, unsigned char reg, unsigned char value)
{
int rc;
@@ -1201,7 +1063,7 @@
}
/* Do not call this function directly! */
-static int
+static int
ov51x_i2c_write_mask_internal(struct usb_ov511 *ov,
unsigned char reg,
unsigned char value,
@@ -1234,10 +1096,10 @@
/* Writes bits at positions specified by mask to an I2C reg. Bits that are in
* the same position as 1's in "mask" are cleared and set to "value". Bits
- * that are in the same position as 0's in "mask" are preserved, regardless
+ * that are in the same position as 0's in "mask" are preserved, regardless
* of their respective state in "value".
*/
-static int
+static int
i2c_w_mask(struct usb_ov511 *ov,
unsigned char reg,
unsigned char value,
@@ -1252,8 +1114,29 @@
return rc;
}
+/* Set the read and write slave IDs. The "slave" argument is the write slave,
+ * and the read slave will be set to (slave + 1). ov->i2c_lock should be held
+ * when calling this. This should not be called from outside the i2c I/O
+ * functions.
+ */
+static inline int
+i2c_set_slave_internal(struct usb_ov511 *ov, unsigned char slave)
+{
+ int rc;
+
+ rc = reg_w(ov, R51x_I2C_W_SID, slave);
+ if (rc < 0) return rc;
+
+ rc = reg_w(ov, R51x_I2C_R_SID, slave + 1);
+ if (rc < 0) return rc;
+
+ return 0;
+}
+
+#if defined(CONFIG_PROC_FS) && defined(CONFIG_VIDEO_PROC_FS)
+
/* Write to a specific I2C slave ID and register, using the specified mask */
-static int
+static int
i2c_w_slave(struct usb_ov511 *ov,
unsigned char slave,
unsigned char reg,
@@ -1265,38 +1148,22 @@
down(&ov->i2c_lock);
/* Set new slave IDs */
- if (reg_w(ov, R51x_I2C_W_SID, slave) < 0) {
- rc = -EIO;
- goto out;
- }
-
- if (reg_w(ov, R51x_I2C_R_SID, slave + 1) < 0) {
- rc = -EIO;
- goto out;
- }
+ rc = i2c_set_slave_internal(ov, slave);
+ if (rc < 0) goto out;
rc = ov51x_i2c_write_mask_internal(ov, reg, value, mask);
- /* Don't bail out yet if error; IDs must be restored */
+out:
/* Restore primary IDs */
- slave = ov->primary_i2c_slave;
- if (reg_w(ov, R51x_I2C_W_SID, slave) < 0) {
- rc = -EIO;
- goto out;
- }
-
- if (reg_w(ov, R51x_I2C_R_SID, slave + 1) < 0) {
- rc = -EIO;
- goto out;
- }
+ if (i2c_set_slave_internal(ov, ov->primary_i2c_slave) < 0)
+ err("Couldn't restore primary I2C slave");
-out:
up(&ov->i2c_lock);
return rc;
}
/* Read from a specific I2C slave ID and register */
-static int
+static int
i2c_r_slave(struct usb_ov511 *ov,
unsigned char slave,
unsigned char reg)
@@ -1306,60 +1173,46 @@
down(&ov->i2c_lock);
/* Set new slave IDs */
- if (reg_w(ov, R51x_I2C_W_SID, slave) < 0) {
- rc = -EIO;
- goto out;
- }
-
- if (reg_w(ov, R51x_I2C_R_SID, slave + 1) < 0) {
- rc = -EIO;
- goto out;
- }
+ rc = i2c_set_slave_internal(ov, slave);
+ if (rc < 0) goto out;
if (ov->bclass == BCL_OV518)
rc = ov518_i2c_read_internal(ov, reg);
else
rc = ov511_i2c_read_internal(ov, reg);
- /* Don't bail out yet if error; IDs must be restored */
+out:
/* Restore primary IDs */
- slave = ov->primary_i2c_slave;
- if (reg_w(ov, R51x_I2C_W_SID, slave) < 0) {
- rc = -EIO;
- goto out;
- }
-
- if (reg_w(ov, R51x_I2C_R_SID, slave + 1) < 0) {
- rc = -EIO;
- goto out;
- }
+ if (i2c_set_slave_internal(ov, ov->primary_i2c_slave) < 0)
+ err("Couldn't restore primary I2C slave");
-out:
up(&ov->i2c_lock);
return rc;
}
+#endif /* defined(CONFIG_PROC_FS) && defined(CONFIG_VIDEO_PROC_FS) */
+
/* Sets I2C read and write slave IDs. Returns <0 for error */
-static int
+static int
ov51x_set_slave_ids(struct usb_ov511 *ov, unsigned char sid)
{
+ int rc;
+
down(&ov->i2c_lock);
- if (reg_w(ov, R51x_I2C_W_SID, sid) < 0)
- return -EIO;
+ rc = i2c_set_slave_internal(ov, sid);
+ if (rc < 0) goto out;
- if (reg_w(ov, R51x_I2C_R_SID, sid + 1) < 0)
- return -EIO;
-
- if (ov51x_reset(ov, OV511_RESET_NOREGS) < 0)
- return -EIO;
+ // FIXME: Is this actually necessary?
+ rc = ov51x_reset(ov, OV511_RESET_NOREGS);
+ if (rc < 0) goto out;
+out:
up(&ov->i2c_lock);
-
- return 0;
+ return rc;
}
-static int
+static int
write_regvals(struct usb_ov511 *ov, struct ov511_regvals * pRegvals)
{
int rc;
@@ -1367,26 +1220,21 @@
while (pRegvals->bus != OV511_DONE_BUS) {
if (pRegvals->bus == OV511_REG_BUS) {
if ((rc = reg_w(ov, pRegvals->reg, pRegvals->val)) < 0)
- goto error;
+ return rc;
} else if (pRegvals->bus == OV511_I2C_BUS) {
if ((rc = i2c_w(ov, pRegvals->reg, pRegvals->val)) < 0)
- goto error;
+ return rc;
} else {
err("Bad regval array");
- rc = -1;
- goto error;
+ return -1;
}
pRegvals++;
}
return 0;
-
-error:
- err("write regvals: error %d", rc);
- return rc;
}
-#ifdef OV511_DEBUG
-static void
+#ifdef OV511_DEBUG
+static void
dump_i2c_range(struct usb_ov511 *ov, int reg1, int regn)
{
int i;
@@ -1394,18 +1242,18 @@
for (i = reg1; i <= regn; i++) {
rc = i2c_r(ov, i);
- info("OV7610[0x%X] = 0x%X", i, rc);
+ info("Sensor[0x%02X] = 0x%02X", i, rc);
}
}
-static void
+static void
dump_i2c_regs(struct usb_ov511 *ov)
{
info("I2C REGS");
dump_i2c_range(ov, 0x00, 0x7C);
}
-static void
+static void
dump_reg_range(struct usb_ov511 *ov, int reg1, int regn)
{
int i;
@@ -1413,12 +1261,12 @@
for (i = reg1; i <= regn; i++) {
rc = reg_r(ov, i);
- info("OV511[0x%X] = 0x%X", i, rc);
+ info("OV511[0x%02X] = 0x%02X", i, rc);
}
}
/* FIXME: Should there be an OV518 version of this? */
-static void
+static void
ov511_dump_regs(struct usb_ov511 *ov)
{
info("CAMERA INTERFACE REGS");
@@ -1445,43 +1293,29 @@
}
#endif
-/**********************************************************************
- *
- * Kernel I2C Interface
- *
- **********************************************************************/
-
-/* For as-yet unimplemented I2C interface */
-static void
-call_i2c_clients(struct usb_ov511 *ov, unsigned int cmd,
- void *arg)
-{
- /* Do nothing */
-}
-
/*****************************************************************************/
/* Temporarily stops OV511 from functioning. Must do this before changing
* registers while the camera is streaming */
-static inline int
+static inline int
ov51x_stop(struct usb_ov511 *ov)
{
PDEBUG(4, "stopping");
- ov->stopped = 1;
+ ov->stopped = 1;
if (ov->bclass == BCL_OV518)
- return (reg_w(ov, R51x_SYS_RESET, 0x3a));
+ return (reg_w_mask(ov, R51x_SYS_RESET, 0x3a, 0x3a));
else
return (reg_w(ov, R51x_SYS_RESET, 0x3d));
}
/* Restarts OV511 after ov511_stop() is called. Has no effect if it is not
* actually stopped (for performance). */
-static inline int
+static inline int
ov51x_restart(struct usb_ov511 *ov)
{
if (ov->stopped) {
PDEBUG(4, "restarting");
- ov->stopped = 0;
+ ov->stopped = 0;
/* Reinitialize the stream */
if (ov->bclass == BCL_OV518)
@@ -1494,7 +1328,7 @@
}
/* Resets the hardware snapshot button */
-static void
+static void
ov51x_clear_snapshot(struct usb_ov511 *ov)
{
if (ov->bclass == BCL_OV511) {
@@ -1506,12 +1340,12 @@
} else {
err("clear snap: invalid bridge type");
}
-
}
+#if defined(CONFIG_PROC_FS) && defined(CONFIG_VIDEO_PROC_FS)
/* Checks the status of the snapshot button. Returns 1 if it was pressed since
* it was last cleared, and zero in all other cases (including errors) */
-static int
+static int
ov51x_check_snapshot(struct usb_ov511 *ov)
{
int ret, status = 0;
@@ -1531,19 +1365,20 @@
return status;
}
+#endif
/* This does an initial reset of an OmniVision sensor and ensures that I2C
* is synchronized. Returns <0 for failure.
*/
-static int
+static int
init_ov_sensor(struct usb_ov511 *ov)
{
int i, success;
- /* Reset the sensor */
+ /* Reset the sensor */
if (i2c_w(ov, 0x12, 0x80) < 0) return -EIO;
- /* Wait for it to initialize */
+ /* Wait for it to initialize */
schedule_timeout (1 + 150 * HZ / 1000);
for (i = 0, success = 0; i < i2c_detect_tries && !success; i++) {
@@ -1553,9 +1388,9 @@
continue;
}
- /* Reset the sensor */
+ /* Reset the sensor */
if (i2c_w(ov, 0x12, 0x80) < 0) return -EIO;
- /* Wait for it to initialize */
+ /* Wait for it to initialize */
schedule_timeout(1 + 150 * HZ / 1000);
/* Dummy read to sync I2C */
if (i2c_r(ov, 0x00) < 0) return -EIO;
@@ -1563,14 +1398,14 @@
if (!success)
return -EIO;
-
+
PDEBUG(1, "I2C synced in %d attempt(s)", i);
return 0;
}
-static int
-ov51x_set_packet_size(struct usb_ov511 *ov, int size)
+static int
+ov511_set_packet_size(struct usb_ov511 *ov, int size)
{
int alt, mult;
@@ -1602,7 +1437,44 @@
err("Set packet size: invalid size (%d)", size);
return -EINVAL;
}
- } else if (ov->bclass == BCL_OV518) {
+ } else {
+ err("Set packet size: Invalid bridge type");
+ return -EINVAL;
+ }
+
+ PDEBUG(3, "%d, mult=%d, alt=%d", size, mult, alt);
+
+ if (reg_w(ov, R51x_FIFO_PSIZE, mult) < 0)
+ return -EIO;
+
+ if (usb_set_interface(ov->dev, ov->iface, alt) < 0) {
+ err("Set packet size: set interface error");
+ return -EBUSY;
+ }
+
+ if (ov51x_reset(ov, OV511_RESET_NOREGS) < 0)
+ return -EIO;
+
+ ov->packet_size = size;
+
+ if (ov51x_restart(ov) < 0)
+ return -EIO;
+
+ return 0;
+}
+
+/* Note: Unlike the OV511/OV511+, the size argument does NOT include the
+ * optional packet number byte. The actual size *is* stored in ov->packet_size,
+ * though. */
+static int
+ov518_set_packet_size(struct usb_ov511 *ov, int size)
+{
+ int alt;
+
+ if (ov51x_stop(ov) < 0)
+ return -EIO;
+
+ if (ov->bclass == BCL_OV518) {
if (size == 0) alt = OV518_ALT_SIZE_0;
else if (size == 128) alt = OV518_ALT_SIZE_128;
else if (size == 256) alt = OV518_ALT_SIZE_256;
@@ -1620,35 +1492,32 @@
return -EINVAL;
}
- PDEBUG(3, "set packet size: %d, mult=%d, alt=%d", size, mult, alt);
+ PDEBUG(3, "%d, alt=%d", size, alt);
- // FIXME: Don't know how to do this on OV518 yet
- if (ov->bclass == BCL_OV511) {
- if (reg_w(ov, R51x_FIFO_PSIZE,
- mult) < 0) {
- return -EIO;
- }
+ ov->packet_size = size;
+ if (size > 0) {
+ /* Program ISO FIFO size reg (packet number isn't included) */
+ ov518_reg_w32(ov, 0x30, size, 2);
+
+ if (ov->packet_numbering)
+ ++ov->packet_size;
}
-
+
if (usb_set_interface(ov->dev, ov->iface, alt) < 0) {
err("Set packet size: set interface error");
return -EBUSY;
}
/* Initialize the stream */
- if (ov->bclass == BCL_OV518)
- if (reg_w(ov, 0x2f, 0x80) < 0)
- return -EIO;
-
- // FIXME - Should we only reset the FIFO?
- if (ov51x_reset(ov, OV511_RESET_NOREGS) < 0)
+ if (reg_w(ov, 0x2f, 0x80) < 0)
return -EIO;
- ov->packet_size = size;
-
if (ov51x_restart(ov) < 0)
return -EIO;
+ if (ov51x_reset(ov, OV511_RESET_NOREGS) < 0)
+ return -EIO;
+
return 0;
}
@@ -1659,7 +1528,6 @@
int rc = 0;
if (!ov->compress_inited) {
-
reg_w(ov, 0x70, phy);
reg_w(ov, 0x71, phuv);
reg_w(ov, 0x72, pvy);
@@ -1677,7 +1545,7 @@
}
ov->compress_inited = 1;
-out:
+out:
return rc;
}
@@ -1688,7 +1556,6 @@
int rc = 0;
if (!ov->compress_inited) {
-
if (ov518_upload_quan_tables(ov) < 0) {
err("Error uploading quantization tables");
rc = -EIO;
@@ -1697,7 +1564,7 @@
}
ov->compress_inited = 1;
-out:
+out:
return rc;
}
@@ -1718,13 +1585,19 @@
switch (ov->sensor) {
case SEN_OV7610:
case SEN_OV6620:
- case SEN_OV6630:
{
rc = i2c_w(ov, OV7610_REG_CNT, val >> 8);
if (rc < 0)
goto out;
break;
}
+ case SEN_OV6630:
+ {
+ rc = i2c_w_mask(ov, OV7610_REG_CNT, val >> 12, 0x0f);
+ if (rc < 0)
+ goto out;
+ break;
+ }
case SEN_OV7620:
{
unsigned char ctab[] = {
@@ -1771,13 +1644,19 @@
switch (ov->sensor) {
case SEN_OV7610:
case SEN_OV6620:
- case SEN_OV6630:
rc = i2c_r(ov, OV7610_REG_CNT);
if (rc < 0)
return rc;
else
*val = rc << 8;
break;
+ case SEN_OV6630:
+ rc = i2c_r(ov, OV7610_REG_CNT);
+ if (rc < 0)
+ return rc;
+ else
+ *val = rc << 12;
+ break;
case SEN_OV7620:
/* Use Y gamma reg instead. Bit 0 is the enable bit. */
rc = i2c_r(ov, 0x64);
@@ -1816,7 +1695,7 @@
switch (ov->sensor) {
case SEN_OV7610:
- case SEN_OV7620AE:
+ case SEN_OV76BE:
case SEN_OV6620:
case SEN_OV6630:
rc = i2c_w(ov, OV7610_REG_BRT, val >> 8);
@@ -1859,7 +1738,7 @@
switch (ov->sensor) {
case SEN_OV7610:
- case SEN_OV7620AE:
+ case SEN_OV76BE:
case SEN_OV7620:
case SEN_OV6620:
case SEN_OV6630:
@@ -1899,7 +1778,7 @@
switch (ov->sensor) {
case SEN_OV7610:
- case SEN_OV7620AE:
+ case SEN_OV76BE:
case SEN_OV6620:
case SEN_OV6630:
rc = i2c_w(ov, OV7610_REG_SAT, val >> 8);
@@ -1943,7 +1822,7 @@
switch (ov->sensor) {
case SEN_OV7610:
- case SEN_OV7620AE:
+ case SEN_OV76BE:
case SEN_OV6620:
case SEN_OV6630:
rc = i2c_r(ov, OV7610_REG_SAT);
@@ -2142,6 +2021,7 @@
return 0;
}
+#if defined(CONFIG_PROC_FS) && defined(CONFIG_VIDEO_PROC_FS)
// FIXME: Exposure range is only 0x00-0x7f in interlace mode
/* Sets current exposure for sensor. This only has an effect if auto-exposure
* is off */
@@ -2161,7 +2041,7 @@
case SEN_OV6630:
case SEN_OV7610:
case SEN_OV7620:
- case SEN_OV7620AE:
+ case SEN_OV76BE:
case SEN_OV8600:
rc = i2c_w(ov, 0x10, val);
if (rc < 0)
@@ -2199,7 +2079,7 @@
case SEN_OV6620:
case SEN_OV6630:
case SEN_OV7620:
- case SEN_OV7620AE:
+ case SEN_OV76BE:
case SEN_OV8600:
rc = i2c_r(ov, 0x10);
if (rc < 0)
@@ -2223,9 +2103,10 @@
return 0;
}
+#endif /* CONFIG_PROC_FS && CONFIG_VIDEO_PROC_FS */
/* Turns on or off the LED. Only has an effect with OV511+/OV518(+) */
-static inline void
+static inline void
ov51x_led_control(struct usb_ov511 *ov, int enable)
{
PDEBUG(4, " (%s)", enable ? "turn on" : "turn off");
@@ -2243,7 +2124,7 @@
* 50 - 50Hz, for European and Asian lighting
* 60 - 60Hz, for American lighting
*
- * Tested with: OV7610, OV7620, OV7620AE, OV6620
+ * Tested with: OV7610, OV7620, OV76BE, OV6620
* Unsupported: KS0127, KS0127B, SAA7111A
* Returns: 0 for success
*/
@@ -2271,12 +2152,12 @@
i2c_w_mask(ov, 0x13, 0x00, 0x10);
break;
case SEN_OV7620:
- case SEN_OV7620AE:
+ case SEN_OV76BE:
case SEN_OV8600:
i2c_w_mask(ov, 0x2a, sixty?0x00:0x80, 0x80);
i2c_w(ov, 0x2b, sixty?0x00:0xac);
i2c_w_mask(ov, 0x76, 0x01, 0x01);
- break;
+ break;
case SEN_OV6620:
case SEN_OV6630:
i2c_w(ov, 0x2b, sixty?0xa8:0x28);
@@ -2302,7 +2183,7 @@
* caused by some (usually fluorescent) lighting. The light frequency must be
* set either before or after enabling it with ov51x_set_light_freq().
*
- * Tested with: OV7610, OV7620, OV7620AE, OV6620.
+ * Tested with: OV7610, OV7620, OV76BE, OV6620.
* Unsupported: KS0127, KS0127B, SAA7111A
* Returns: 0 for success
*/
@@ -2364,7 +2245,7 @@
*/
static inline int
sensor_set_auto_exposure(struct usb_ov511 *ov, int enable)
-{
+{
PDEBUG(4, " (%s)", enable ? "turn on" : "turn off");
switch (ov->sensor) {
@@ -2373,10 +2254,10 @@
break;
case SEN_OV6620:
case SEN_OV7620:
- case SEN_OV7620AE:
+ case SEN_OV76BE:
case SEN_OV8600:
i2c_w_mask(ov, 0x13, enable?0x01:0x00, 0x01);
- break;
+ break;
case SEN_OV6630:
i2c_w_mask(ov, 0x28, enable?0x00:0x10, 0x10);
break;
@@ -2399,13 +2280,12 @@
* that are illuminated from behind.
*
* Tested with: OV6620, OV7620
- * Unsupported: OV7610, OV7620AE, KS0127, KS0127B, SAA7111A
+ * Unsupported: OV7610, OV76BE, KS0127, KS0127B, SAA7111A
* Returns: 0 for success
*/
static int
sensor_set_backlight(struct usb_ov511 *ov, int enable)
{
-
PDEBUG(4, " (%s)", enable ? "turn on" : "turn off");
switch (ov->sensor) {
@@ -2414,7 +2294,7 @@
i2c_w_mask(ov, 0x68, enable?0xe0:0xc0, 0xe0);
i2c_w_mask(ov, 0x29, enable?0x08:0x00, 0x08);
i2c_w_mask(ov, 0x28, enable?0x02:0x00, 0x02);
- break;
+ break;
case SEN_OV6620:
i2c_w_mask(ov, 0x4e, enable?0xe0:0xc0, 0xe0);
i2c_w_mask(ov, 0x29, enable?0x08:0x00, 0x08);
@@ -2426,7 +2306,7 @@
i2c_w_mask(ov, 0x28, enable?0x02:0x00, 0x02);
break;
case SEN_OV7610:
- case SEN_OV7620AE:
+ case SEN_OV76BE:
case SEN_KS0127:
case SEN_KS0127B:
case SEN_SAA7111A:
@@ -2442,27 +2322,56 @@
return 0;
}
+static inline int
+sensor_set_mirror(struct usb_ov511 *ov, int enable)
+{
+ PDEBUG(4, " (%s)", enable ? "turn on" : "turn off");
+
+ switch (ov->sensor) {
+ case SEN_OV6620:
+ case SEN_OV6630:
+ case SEN_OV7610:
+ case SEN_OV7620:
+ case SEN_OV76BE:
+ case SEN_OV8600:
+ i2c_w_mask(ov, 0x12, enable?0x40:0x00, 0x40);
+ break;
+ case SEN_KS0127:
+ case SEN_KS0127B:
+ case SEN_SAA7111A:
+ PDEBUG(5, "Unsupported with this sensor");
+ return -EPERM;
+ default:
+ err("Sensor not supported for set_mirror");
+ return -EINVAL;
+ }
+
+ ov->mirror = enable;
+
+ return 0;
+}
+
/* Returns number of bits per pixel (regardless of where they are located;
* planar or not), or zero for unsupported format.
*/
-static inline int
+static inline int
get_depth(int palette)
{
switch (palette) {
case VIDEO_PALETTE_GREY: return 8;
+ case VIDEO_PALETTE_YUV420: return 12;
+ case VIDEO_PALETTE_YUV420P: return 12; /* Planar */
case VIDEO_PALETTE_RGB565: return 16;
- case VIDEO_PALETTE_RGB24: return 24;
+ case VIDEO_PALETTE_RGB24: return 24;
case VIDEO_PALETTE_YUV422: return 16;
case VIDEO_PALETTE_YUYV: return 16;
- case VIDEO_PALETTE_YUV420: return 12;
case VIDEO_PALETTE_YUV422P: return 16; /* Planar */
- case VIDEO_PALETTE_YUV420P: return 12; /* Planar */
default: return 0; /* Invalid format */
}
}
/* Bytes per frame. Used by read(). Return of 0 indicates error */
-static inline long int
+static inline long int
get_frame_length(struct ov511_frame *frame)
{
if (!frame)
@@ -2502,7 +2411,7 @@
i2c_w_mask(ov, 0x67, qvga?0xf0:0x90, 0xf0);
i2c_w_mask(ov, 0x74, qvga?0x20:0x00, 0x20);
break;
- case SEN_OV7620AE:
+ case SEN_OV76BE:
// i2c_w(ov, 0x2b, 0x00);
i2c_w(ov, 0x14, qvga?0xa4:0x84);
// FIXME: Enable this once 7620AE uses 7620 initial settings
@@ -2528,13 +2437,13 @@
/******** Palette-specific regs ********/
if (mode == VIDEO_PALETTE_GREY) {
- if (ov->sensor == SEN_OV7610 || ov->sensor == SEN_OV7620AE) {
+ if (ov->sensor == SEN_OV7610 || ov->sensor == SEN_OV76BE) {
/* these aren't valid on the OV6620/OV7620/6630? */
i2c_w_mask(ov, 0x0e, 0x40, 0x40);
}
i2c_w_mask(ov, 0x13, 0x20, 0x20);
} else {
- if (ov->sensor == SEN_OV7610 || ov->sensor == SEN_OV7620AE) {
+ if (ov->sensor == SEN_OV7610 || ov->sensor == SEN_OV76BE) {
/* not valid on the OV6620/OV7620/6630? */
i2c_w_mask(ov, 0x0e, 0x00, 0x40);
}
@@ -2596,8 +2505,7 @@
if (framedrop >= 0)
i2c_w(ov, 0x16, framedrop);
- /* We only have code to convert GBR -> RGB24 */
- if ((mode == VIDEO_PALETTE_RGB24) && sensor_gbr)
+ if (sensor_gbr)
i2c_w_mask(ov, 0x12, 0x08, 0x08);
else
i2c_w_mask(ov, 0x12, 0x00, 0x08);
@@ -2614,7 +2522,7 @@
// This will go away as soon as ov51x_mode_init_sensor_regs()
// is fully tested.
/* 7620/6620/6630? don't have register 0x35, so play it safe */
- if (ov->sensor == SEN_OV7610 || ov->sensor == SEN_OV7620AE) {
+ if (ov->sensor == SEN_OV7610 || ov->sensor == SEN_OV76BE) {
if (width == 640 && height == 480)
i2c_w(ov, 0x35, 0x9e);
else
@@ -2636,13 +2544,13 @@
* IF YOU SET IT WRONG, YOU WILL GET ALL ZERO ISOC DATA FROM OV51x!!! */
switch (ov->sensor) {
case SEN_OV7610:
- case SEN_OV7620AE:
+ case SEN_OV76BE:
hwsbase = 0x38;
hwebase = 0x3a;
vwsbase = vwebase = 0x05;
break;
case SEN_OV6620:
- case SEN_OV6630: // FIXME: Is this right?
+ case SEN_OV6630:
hwsbase = 0x38;
hwebase = 0x3a;
vwsbase = 0x05;
@@ -2659,7 +2567,9 @@
}
if (ov->sensor == SEN_OV6620 || ov->sensor == SEN_OV6630) {
- if (width > 176 && height > 144) { /* CIF */
+ /* Note: OV518(+) does downsample on its own) */
+ if ((width > 176 && height > 144)
+ || ov->bclass == BCL_OV518) { /* CIF */
ret = mode_init_ov_sensor_regs(ov, width, height,
mode, sub_flag, 0);
if (ret < 0)
@@ -2736,7 +2646,7 @@
ov511_mode_init_regs(struct usb_ov511 *ov,
int width, int height, int mode, int sub_flag)
{
- int lncnt, pxcnt, rc = 0;
+ int hsegs, vsegs;
if (sub_flag) {
width = ov->subw;
@@ -2752,11 +2662,11 @@
if (width == 320 && height == 240) {
/* No need to do anything special */
} else if (width == 640 && height == 480) {
- /* Set the OV511 up as 320x480, but keep the V4L
- * resolution as 640x480 */
+ /* Set the OV511 up as 320x480, but keep the
+ * V4L resolution as 640x480 */
width = 320;
} else {
- err("SAA7111A only supports 320x240 or 640x480");
+ err("SAA7111A only allows 320x240 or 640x480");
return -EINVAL;
}
}
@@ -2788,11 +2698,11 @@
/* Here I'm assuming that snapshot size == image size.
* I hope that's always true. --claudio
*/
- pxcnt = (width >> 3) - 1;
- lncnt = (height >> 3) - 1;
+ hsegs = (width >> 3) - 1;
+ vsegs = (height >> 3) - 1;
- reg_w(ov, R511_CAM_PXCNT, pxcnt);
- reg_w(ov, R511_CAM_LNCNT, lncnt);
+ reg_w(ov, R511_CAM_PXCNT, hsegs);
+ reg_w(ov, R511_CAM_LNCNT, vsegs);
reg_w(ov, R511_CAM_PXDIV, 0x00);
reg_w(ov, R511_CAM_LNDIV, 0x00);
@@ -2800,8 +2710,8 @@
reg_w(ov, R511_CAM_OPTS, 0x03);
/* Snapshot additions */
- reg_w(ov, R511_SNAP_PXCNT, pxcnt);
- reg_w(ov, R511_SNAP_LNCNT, lncnt);
+ reg_w(ov, R511_SNAP_PXCNT, hsegs);
+ reg_w(ov, R511_SNAP_LNCNT, vsegs);
reg_w(ov, R511_SNAP_PXDIV, 0x00);
reg_w(ov, R511_SNAP_LNDIV, 0x00);
@@ -2811,27 +2721,17 @@
reg_w(ov, R511_COMP_LUT_EN, 0x03);
ov51x_reset(ov, OV511_RESET_OMNICE);
}
-//out:
+
if (ov51x_restart(ov) < 0)
return -EIO;
- return rc;
+ return 0;
}
-static struct mode_list_518 mlist518[] = {
- /* W H reg28 reg29 reg2a reg2c reg2e reg24 reg25 */
- { 352, 288, 0x00, 0x16, 0x48, 0x00, 0x00, 0x9f, 0x90 },
- { 320, 240, 0x00, 0x14, 0x3c, 0x10, 0x18, 0x9f, 0x90 },
- { 176, 144, 0x05, 0x0b, 0x24, 0x00, 0x00, 0xff, 0xf0 },
- { 160, 120, 0x05, 0x0a, 0x1e, 0x08, 0x0c, 0xff, 0xf0 },
- { 0, 0 }
-};
-
/* Sets up the OV518/OV518+ with the given image parameters
*
* OV518 needs a completely different approach, until we can figure out what
- * the individual registers do. Many register ops are commented out until we
- * can find out if they are still valid. Also, only 15 FPS is supported now.
+ * the individual registers do. Also, only 15 FPS is supported now.
*
* Do not put any sensor-specific code in here (including I2C I/O functions)
*/
@@ -2839,112 +2739,110 @@
ov518_mode_init_regs(struct usb_ov511 *ov,
int width, int height, int mode, int sub_flag)
{
- int i;
+ int hsegs, vsegs, hi_res;
+
+ if (sub_flag) {
+ width = ov->subw;
+ height = ov->subh;
+ }
PDEBUG(3, "width:%d, height:%d, mode:%d, sub:%d",
width, height, mode, sub_flag);
+ if (width % 16 || height % 8) {
+ err("Invalid size (%d, %d)", width, height);
+ return -EINVAL;
+ }
+
+ if (width < ov->minwidth || height < ov->minheight) {
+ err("Requested dimensions are too small");
+ return -EINVAL;
+ }
+
+ if (width >= 320 && height >= 240) {
+ hi_res = 1;
+ } else if (width >= 320 || height >= 240) {
+ err("Invalid width/height combination (%d, %d)", width, height);
+ return -EINVAL;
+ } else {
+ hi_res = 0;
+ }
+
if (ov51x_stop(ov) < 0)
return -EIO;
- for (i = 0; mlist518[i].width; i++) {
-// int lncnt, pxcnt;
+ /******** Set the mode ********/
- if (width != mlist518[i].width || height != mlist518[i].height)
- continue;
+ reg_w(ov, 0x2b, 0);
+ reg_w(ov, 0x2c, 0);
+ reg_w(ov, 0x2d, 0);
+ reg_w(ov, 0x2e, 0);
+ reg_w(ov, 0x3b, 0);
+ reg_w(ov, 0x3c, 0);
+ reg_w(ov, 0x3d, 0);
+ reg_w(ov, 0x3e, 0);
-// FIXME: Subcapture won't be possible until we know what the registers do
-// FIXME: We can't handle anything but YUV420 so far
+ reg_w(ov, 0x28, (mode == VIDEO_PALETTE_GREY) ? 0x00:0x80);
+ reg_w(ov, 0x38, (mode == VIDEO_PALETTE_GREY) ? 0x00:0x80);
-// /* Here I'm assuming that snapshot size == image size.
-// * I hope that's always true. --claudio
-// */
-// pxcnt = sub_flag ? (ov511->subw >> 3) - 1 : mlist[i].pxcnt;
-// lncnt = sub_flag ? (ov511->subh >> 3) - 1 : mlist[i].lncnt;
-//
-// reg_w(ov511, 0x12, pxcnt);
-// reg_w(ov511, 0x13, lncnt);
-
- /******** Set the mode ********/
-
- /* Mode independent regs */
- reg_w(ov, 0x2b, 0x00);
- reg_w(ov, 0x2d, 0x00);
- reg_w(ov, 0x3b, 0x00);
- reg_w(ov, 0x3d, 0x00);
-
- /* Mode dependent regs. Regs 38 - 3e are always the same as
- * regs 28 - 2e */
- reg_w_mask(ov, 0x28, mlist518[i].reg28
- | (mode == VIDEO_PALETTE_GREY) ? 0x80:0x00, 0x8f);
- reg_w(ov, 0x29, mlist518[i].reg29);
- reg_w(ov, 0x2a, mlist518[i].reg2a);
- reg_w(ov, 0x2c, mlist518[i].reg2c);
- reg_w(ov, 0x2e, mlist518[i].reg2e);
- reg_w_mask(ov, 0x38, mlist518[i].reg28
- | (mode == VIDEO_PALETTE_GREY) ? 0x80:0x00, 0x8f);
- reg_w(ov, 0x39, mlist518[i].reg29);
- reg_w(ov, 0x3a, mlist518[i].reg2a);
- reg_w(ov, 0x3c, mlist518[i].reg2c);
- reg_w(ov, 0x3e, mlist518[i].reg2e);
- reg_w(ov, 0x24, mlist518[i].reg24);
- reg_w(ov, 0x25, mlist518[i].reg25);
-
- /* Windows driver does this here; who knows why */
- reg_w(ov, 0x2f, 0x80);
-
- /******** Set the framerate (to 15 FPS) ********/
-
- /* Mode independent, but framerate dependent, regs */
- /* These are for 15 FPS only */
- reg_w(ov, 0x51, 0x08);
- reg_w(ov, 0x22, 0x18);
- reg_w(ov, 0x23, 0xff);
- reg_w(ov, 0x71, 0x19); /* Compression-related? */
-
- // FIXME: Sensor-specific
- /* Bit 5 is what matters here. Of course, it is "reserved" */
- i2c_w(ov, 0x54, 0x23);
-
- reg_w(ov, 0x2f, 0x80);
-
- /* Mode dependent regs */
- if ((width == 352 && height == 288) ||
- (width == 320 && height == 240)) {
- /* 640 (280h) byte iso packets */
- ov518_reg_w32(ov, 0x30, 640, 2); /* 280h */
- ov518_reg_w32(ov, 0xc4, 400, 2); /* 190h */
- ov518_reg_w32(ov, 0xc6, 500, 2); /* 1f4h */
- ov518_reg_w32(ov, 0xc7, 500, 2); /* 1f4h */
- ov518_reg_w32(ov, 0xc8, 142, 2); /* 8eh */
- ov518_reg_w32(ov, 0xca, 131098, 3); /* 2001ah */
- ov518_reg_w32(ov, 0xcb, 532, 2); /* 214h */
- ov518_reg_w32(ov, 0xcc, 2000, 2); /* 7d0h */
- ov518_reg_w32(ov, 0xcd, 32, 2); /* 20h */
- ov518_reg_w32(ov, 0xce, 608, 2); /* 260h */
- } else if ((width == 176 && height == 144) ||
- (width == 160 && height == 120)) {
- /* 384 (180h) byte iso packets */
- ov518_reg_w32(ov, 0x30, 384, 2); /* 180h */
- ov518_reg_w32(ov, 0xc4, 200, 2); /* c8h */
- ov518_reg_w32(ov, 0xc6, 320, 2); /* 140h */
- ov518_reg_w32(ov, 0xc7, 320, 2); /* 140h */
- ov518_reg_w32(ov, 0xc8, 96, 2); /* 60h */
- ov518_reg_w32(ov, 0xca, 78607, 3); /* 1330fh */
- ov518_reg_w32(ov, 0xcb, 320, 2); /* 140h */
- ov518_reg_w32(ov, 0xcc, 1260, 2); /* 4ech */
- ov518_reg_w32(ov, 0xcd, 19, 2); /* 13h */
- ov518_reg_w32(ov, 0xce, 365, 2); /* 16dh */
- } else {
- /* Can't happen, since we already handled this case */
- err("ov518_mode_init_regs(): **** logic error ****");
- }
+ hsegs = width / 16;
+ vsegs = height / 4;
- reg_w(ov, 0x2f, 0x80);
+ reg_w(ov, 0x29, hsegs);
+ reg_w(ov, 0x2a, vsegs);
- break;
+ reg_w(ov, 0x39, hsegs);
+ reg_w(ov, 0x3a, vsegs);
+
+ /* Windows driver does this here; who knows why */
+ reg_w(ov, 0x2f, 0x80);
+
+ /******** Set the framerate (to 15 FPS) ********/
+
+ /* Mode independent, but framerate dependent, regs */
+ reg_w(ov, 0x51, 0x02); /* Clock divider; lower==faster */
+ reg_w(ov, 0x22, 0x18);
+ reg_w(ov, 0x23, 0xff);
+
+ if (ov->bridge == BRG_OV518PLUS)
+ reg_w(ov, 0x21, 0x19);
+ else
+ reg_w(ov, 0x71, 0x19); /* Compression-related? */
+
+ // FIXME: Sensor-specific
+ /* Bit 5 is what matters here. Of course, it is "reserved" */
+ i2c_w(ov, 0x54, 0x23);
+
+ reg_w(ov, 0x2f, 0x80);
+
+ if (ov->bridge == BRG_OV518PLUS) {
+ reg_w(ov, 0x24, 0x94);
+ reg_w(ov, 0x25, 0x90);
+ ov518_reg_w32(ov, 0xc4, 400, 2); /* 190h */
+ ov518_reg_w32(ov, 0xc6, 540, 2); /* 21ch */
+ ov518_reg_w32(ov, 0xc7, 540, 2); /* 21ch */
+ ov518_reg_w32(ov, 0xc8, 108, 2); /* 6ch */
+ ov518_reg_w32(ov, 0xca, 131098, 3); /* 2001ah */
+ ov518_reg_w32(ov, 0xcb, 532, 2); /* 214h */
+ ov518_reg_w32(ov, 0xcc, 2400, 2); /* 960h */
+ ov518_reg_w32(ov, 0xcd, 32, 2); /* 20h */
+ ov518_reg_w32(ov, 0xce, 608, 2); /* 260h */
+ } else {
+ reg_w(ov, 0x24, 0x9f);
+ reg_w(ov, 0x25, 0x90);
+ ov518_reg_w32(ov, 0xc4, 400, 2); /* 190h */
+ ov518_reg_w32(ov, 0xc6, 500, 2); /* 1f4h */
+ ov518_reg_w32(ov, 0xc7, 500, 2); /* 1f4h */
+ ov518_reg_w32(ov, 0xc8, 142, 2); /* 8eh */
+ ov518_reg_w32(ov, 0xca, 131098, 3); /* 2001ah */
+ ov518_reg_w32(ov, 0xcb, 532, 2); /* 214h */
+ ov518_reg_w32(ov, 0xcc, 2000, 2); /* 7d0h */
+ ov518_reg_w32(ov, 0xcd, 32, 2); /* 20h */
+ ov518_reg_w32(ov, 0xce, 608, 2); /* 260h */
}
+ reg_w(ov, 0x2f, 0x80);
+
if (ov51x_restart(ov) < 0)
return -EIO;
@@ -2952,11 +2850,6 @@
if (ov51x_reset(ov, OV511_RESET_NOREGS) < 0)
return -EIO;
- if (mlist518[i].width == 0) {
- err("Unknown mode (%d, %d): %d", width, height, mode);
- return -EINVAL;
- }
-
return 0;
}
@@ -2982,7 +2875,7 @@
switch (ov->sensor) {
case SEN_OV7610:
case SEN_OV7620:
- case SEN_OV7620AE:
+ case SEN_OV76BE:
case SEN_OV8600:
case SEN_OV6620:
case SEN_OV6630:
@@ -2994,10 +2887,10 @@
rc = -EINVAL;
break;
case SEN_SAA7111A:
-// rc = mode_init_saa_sensor_regs(ov, width, height, mode,
+// rc = mode_init_saa_sensor_regs(ov, width, height, mode,
// sub_flag);
- PDEBUG(1, "SAA status = 0X%x", i2c_r(ov, 0x1f));
+ PDEBUG(1, "SAA status = 0x%02X", i2c_r(ov, 0x1f));
break;
default:
err("Unknown sensor");
@@ -3030,19 +2923,21 @@
if (FATAL_ERROR(rc))
return rc;
+ rc = sensor_set_mirror(ov, ov->mirror);
+ if (FATAL_ERROR(rc))
+ return rc;
+
return 0;
}
-/* This sets the default image parameters (Size = max, RGB24). This is
- * useful for apps that use read() and do not set these.
+/* This sets the default image parameters. This is useful for apps that use
+ * read() and do not set these.
*/
-static int
+static int
ov51x_set_default_params(struct usb_ov511 *ov)
{
int i;
- PDEBUG(3, "%dx%d, RGB24", ov->maxwidth, ov->maxheight);
-
/* Set default sizes in case IOCTL (VIDIOCMCAPTURE) is not used
* (using read() instead). */
for (i = 0; i < OV511_NUMFRAMES; i++) {
@@ -3053,10 +2948,14 @@
ov->frame[i].format = force_palette;
else
ov->frame[i].format = VIDEO_PALETTE_RGB24;
+
ov->frame[i].depth = get_depth(ov->frame[i].format);
}
- /* Initialize to max width/height, RGB24 */
+ PDEBUG(3, "%dx%d, %s", ov->maxwidth, ov->maxheight,
+ symbolic(v4l1_plist, ov->frame[0].format));
+
+ /* Initialize to max width/height, YUV420 or RGB24 (if supported) */
if (mode_init_regs(ov, ov->maxwidth, ov->maxheight,
ov->frame[0].format, 0) < 0)
return -EINVAL;
@@ -3071,7 +2970,7 @@
**********************************************************************/
/* Set analog input port of decoder */
-static int
+static int
decoder_set_input(struct usb_ov511 *ov, int input)
{
PDEBUG(4, "port %d", input);
@@ -3093,7 +2992,7 @@
}
/* Get ASCII name of video input */
-static int
+static int
decoder_get_input_name(struct usb_ov511 *ov, int input, char *name)
{
switch (ov->sensor) {
@@ -3105,7 +3004,6 @@
sprintf(name, "CVBS-%d", input);
else // if (input < 8)
sprintf(name, "S-Video-%d", input - 4);
-
break;
}
default:
@@ -3116,7 +3014,7 @@
}
/* Set norm (NTSC, PAL, SECAM, AUTO) */
-static int
+static int
decoder_set_norm(struct usb_ov511 *ov, int norm)
{
PDEBUG(4, "%d", norm);
@@ -3131,7 +3029,7 @@
reg_e = 0x00; /* NTSC M / PAL BGHI */
} else if (norm == VIDEO_MODE_PAL) {
reg_8 = 0x00; /* 50 Hz */
- reg_e = 0x00; /* NTSC M / PAL BGHI */
+ reg_e = 0x00; /* NTSC M / PAL BGHI */
} else if (norm == VIDEO_MODE_AUTO) {
reg_8 = 0x80; /* Auto field detect */
reg_e = 0x00; /* NTSC M / PAL BGHI */
@@ -3153,7 +3051,6 @@
return 0;
}
-
/**********************************************************************
*
* Color correction functions
@@ -3176,21 +3073,21 @@
* coefficients are scaled into 16.16 fixed-point integers.
* They were determined as follows:
*
- * double brightness = 1.0; (0->black; 1->full scale)
+ * double brightness = 1.0; (0->black; 1->full scale)
* double saturation = 1.0; (0->greyscale; 1->full color)
* double fixScale = brightness * 256 * 256;
* int rvScale = (int)(1.402 * saturation * fixScale);
* int guScale = (int)(-0.344136 * saturation * fixScale);
* int gvScale = (int)(-0.714136 * saturation * fixScale);
* int buScale = (int)(1.772 * saturation * fixScale);
- * int yScale = (int)(fixScale);
+ * int yScale = (int)(fixScale);
*/
/* LIMIT: convert a 16.16 fixed-point value to a byte, with clipping. */
#define LIMIT(x) ((x)>0xffffff?0xff: ((x)<=0xffff?0:((x)>>16)))
static inline void
-move_420_block(int yTL, int yTR, int yBL, int yBR, int u, int v,
+move_420_block(int yTL, int yTR, int yBL, int yBR, int u, int v,
int rowPixels, unsigned char * rgb, int bits)
{
const int rvScale = 91881;
@@ -3229,14 +3126,14 @@
rgb[5] = LIMIT(r+yBR);
} else if (bits == 16) {
/* Write out top two pixels */
- rgb[0] = ((LIMIT(b+yTL) >> 3) & 0x1F)
+ rgb[0] = ((LIMIT(b+yTL) >> 3) & 0x1F)
| ((LIMIT(g+yTL) << 3) & 0xE0);
rgb[1] = ((LIMIT(g+yTL) >> 5) & 0x07)
| (LIMIT(r+yTL) & 0xF8);
- rgb[2] = ((LIMIT(b+yTR) >> 3) & 0x1F)
+ rgb[2] = ((LIMIT(b+yTR) >> 3) & 0x1F)
| ((LIMIT(g+yTR) << 3) & 0xE0);
- rgb[3] = ((LIMIT(g+yTR) >> 5) & 0x07)
+ rgb[3] = ((LIMIT(g+yTR) >> 5) & 0x07)
| (LIMIT(r+yTR) & 0xF8);
/* Skip down to next line to write out bottom two pixels */
@@ -3263,7 +3160,7 @@
/* Copies a 64-byte segment at pIn to an 8x8 block at pOut. The width of the
* image at pOut is specified by w.
*/
-static inline void
+static inline void
make_8x8(unsigned char *pIn, unsigned char *pOut, int w)
{
unsigned char *pOut1 = pOut;
@@ -3276,7 +3173,6 @@
}
pOut += w;
}
-
}
/*
@@ -3394,7 +3290,7 @@
* low, and the blue channel about 1 pixel high. After YUV->RGB
* conversion, we can correct this easily. OSL 2/24/2000.
*/
-static void
+static void
fixFrameRGBoffset(struct ov511_frame *frame)
{
int x, y;
@@ -3403,7 +3299,7 @@
const int shift = 1; /* Distance to shift pixels by, vertically */
/* Don't bother with little images */
- if (frame->width < 400)
+ if (frame->width < 400)
return;
/* This only works with RGB24 */
@@ -3437,7 +3333,7 @@
* accordingly. Returns -ENXIO if decompressor is not available, otherwise
* returns 0 if no other error.
*/
-static int
+static int
request_decompressor(struct usb_ov511 *ov)
{
if (!ov)
@@ -3476,24 +3372,24 @@
}
if (ov->decomp_ops) {
- if (!ov->decomp_ops->decomp_lock) {
+ if (!ov->decomp_ops->owner) {
ov->decomp_ops = NULL;
unlock_kernel();
return -ENOSYS;
}
- ov->decomp_ops->decomp_lock();
+ __MOD_INC_USE_COUNT(ov->decomp_ops->owner);
unlock_kernel();
return 0;
} else {
unlock_kernel();
- return -ENXIO;
+ return -ENOSYS;
}
}
/* Unlocks decompression module and nulls ov->decomp_ops. Safe to call even
* if ov->decomp_ops is NULL.
*/
-static void
+static void
release_decompressor(struct usb_ov511 *ov)
{
int released = 0; /* Did we actually do anything? */
@@ -3503,20 +3399,20 @@
lock_kernel();
- if (ov->decomp_ops && ov->decomp_ops->decomp_unlock) {
- ov->decomp_ops->decomp_unlock();
+ if (ov->decomp_ops && ov->decomp_ops->owner) {
+ __MOD_DEC_USE_COUNT(ov->decomp_ops->owner);
released = 1;
}
ov->decomp_ops = NULL;
-
+
unlock_kernel();
if (released)
PDEBUG(3, "Decompressor released");
}
-static void
+static void
decompress(struct usb_ov511 *ov, struct ov511_frame *frame,
unsigned char *pIn0, unsigned char *pOut0)
{
@@ -3526,19 +3422,22 @@
PDEBUG(4, "Decompressing %d bytes", frame->bytes_recvd);
- if (frame->format == VIDEO_PALETTE_GREY
+ if (frame->format == VIDEO_PALETTE_GREY
&& ov->decomp_ops->decomp_400) {
int ret = ov->decomp_ops->decomp_400(
pIn0,
pOut0,
+ frame->compbuf,
frame->rawwidth,
frame->rawheight,
frame->bytes_recvd);
PDEBUG(4, "DEBUG: decomp_400 returned %d", ret);
- } else if (ov->decomp_ops->decomp_420) {
+ } else if (frame->format != VIDEO_PALETTE_GREY
+ && ov->decomp_ops->decomp_420) {
int ret = ov->decomp_ops->decomp_420(
pIn0,
pOut0,
+ frame->compbuf,
frame->rawwidth,
frame->rawheight,
frame->bytes_recvd);
@@ -3555,7 +3454,7 @@
**********************************************************************/
/* Converts from planar YUV420 to RGB24. */
-static void
+static void
yuv420p_to_rgb(struct ov511_frame *frame,
unsigned char *pIn0, unsigned char *pOut0, int bits)
{
@@ -3578,10 +3477,9 @@
move_420_block(y00, y01, y10, y11, u, v,
frame->width, pOut, bits);
-
+
pY += 2;
pOut += 2 * bytes;
-
}
pY += frame->width;
pOut += frame->width * bytes;
@@ -3610,7 +3508,7 @@
for (i = 0; i <= frame->width - 2; i += 2) {
int u = *pU++;
int v = *pV++;
-
+
*pOut = u;
*(pOut+2) = v;
*(pOut+frame->width*2) = u;
@@ -3725,27 +3623,11 @@
}
}
-/* Post-processes the specified frame. This consists of:
- * 1. Decompress frame, if necessary
- * 2. Deinterlace frame and scale to proper size, if necessary
- * 3. Convert from YUV planar to destination format, if necessary
- * 4. Fix the RGB offset, if necessary
- */
-static void
-ov51x_postprocess(struct usb_ov511 *ov, struct ov511_frame *frame)
+static void
+ov51x_postprocess_grey(struct usb_ov511 *ov, struct ov511_frame *frame)
{
- if (dumppix) {
- memset(frame->data, 0,
- MAX_DATA_SIZE(ov->maxwidth, ov->maxheight));
- PDEBUG(4, "Dumping %d bytes", frame->bytes_recvd);
- memmove(frame->data, frame->rawdata, frame->bytes_recvd);
- return;
- }
-
- /* YUV400 must be handled separately */
- if (frame->format == VIDEO_PALETTE_GREY) {
/* Deinterlace frame, if necessary */
- if (ov->sensor == SEN_SAA7111A && frame->rawheight == 480) {
+ if (ov->sensor == SEN_SAA7111A && frame->rawheight >= 480) {
if (frame->compressed)
decompress(ov, frame, frame->rawdata,
frame->tempdata);
@@ -3763,19 +3645,23 @@
yuv400raw_to_yuv400p(frame, frame->rawdata,
frame->data);
}
+}
- return;
- }
-
- /* Process frame->data to frame->rawdata */
+/* Process raw YUV420 data into the format requested by the app. Conversion
+ * between V4L formats is allowed.
+ */
+static void
+ov51x_postprocess_yuv420(struct usb_ov511 *ov, struct ov511_frame *frame)
+{
+ /* Process frame->rawdata to frame->tempdata */
if (frame->compressed)
decompress(ov, frame, frame->rawdata, frame->tempdata);
else
yuv420raw_to_yuv420p(frame, frame->rawdata, frame->tempdata);
/* Deinterlace frame, if necessary */
- if (ov->sensor == SEN_SAA7111A && frame->rawheight == 480) {
- memmove(frame->rawdata, frame->tempdata,
+ if (ov->sensor == SEN_SAA7111A && frame->rawheight >= 480) {
+ memcpy(frame->rawdata, frame->tempdata,
MAX_RAW_DATA_SIZE(frame->width, frame->height));
deinterlace(frame, RAWFMT_YUV420, frame->rawdata,
frame->tempdata);
@@ -3784,11 +3670,6 @@
/* Frame should be (width x height) and not (rawwidth x rawheight) at
* this point. */
-#if 0
- /* Clear output buffer for testing purposes */
- memset(frame->data, 0, MAX_DATA_SIZE(frame->width, frame->height));
-#endif
-
/* Process frame->tempdata to frame->data */
switch (frame->format) {
case VIDEO_PALETTE_RGB565:
@@ -3803,348 +3684,124 @@
break;
case VIDEO_PALETTE_YUV420:
case VIDEO_PALETTE_YUV420P:
- memmove(frame->data, frame->tempdata,
+ memcpy(frame->data, frame->tempdata,
MAX_RAW_DATA_SIZE(frame->width, frame->height));
break;
case VIDEO_PALETTE_YUV422P:
/* Data is converted in place, so copy it in advance */
- memmove(frame->data, frame->tempdata,
+ memcpy(frame->data, frame->tempdata,
MAX_RAW_DATA_SIZE(frame->width, frame->height));
yuv420p_to_yuv422p(frame, frame->data);
break;
default:
- err("Cannot convert data to this format");
+ err("Cannot convert YUV420 to %s",
+ symbolic(v4l1_plist, frame->format));
}
if (fix_rgb_offset)
fixFrameRGBoffset(frame);
}
-/**********************************************************************
- *
- * OV51x data transfer, IRQ handler
- *
- **********************************************************************/
-
-static int
-ov511_move_data(struct usb_ov511 *ov, struct urb *urb)
+/* Post-processes the specified frame. This consists of:
+ * 1. Decompress frame, if necessary
+ * 2. Deinterlace frame and scale to proper size, if necessary
+ * 3. Convert from YUV planar to destination format, if necessary
+ * 4. Fix the RGB offset, if necessary
+ */
+static void
+ov51x_postprocess(struct usb_ov511 *ov, struct ov511_frame *frame)
{
- unsigned char *cdata;
- int data_size, num, offset, i, totlen = 0;
- int aPackNum[FRAMES_PER_DESC];
- struct ov511_frame *frame;
- struct timeval *ts;
-
- PDEBUG(5, "Moving %d packets", urb->number_of_packets);
-
- data_size = ov->packet_size - 1;
-
- for (i = 0; i < urb->number_of_packets; i++) {
- int n = urb->iso_frame_desc[i].actual_length;
- int st = urb->iso_frame_desc[i].status;
-
- urb->iso_frame_desc[i].actual_length = 0;
- urb->iso_frame_desc[i].status = 0;
-
- cdata = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
-
- aPackNum[i] = n ? cdata[ov->packet_size - 1] : -1;
-
- if (!n || ov->curframe == -1)
- continue;
-
- if (st)
- PDEBUG(2, "data error: [%d] len=%d, status=%d", i, n, st);
-
- frame = &ov->frame[ov->curframe];
-
- /* SOF/EOF packets have 1st to 8th bytes zeroed and the 9th
- * byte non-zero. The EOF packet has image width/height in the
- * 10th and 11th bytes. The 9th byte is given as follows:
- *
- * bit 7: EOF
- * 6: compression enabled
- * 5: 422/420/400 modes
- * 4: 422/420/400 modes
- * 3: 1
- * 2: snapshot button on
- * 1: snapshot frame
- * 0: even/odd field
- */
-
- if (printph) {
- info("packet header (%3d): %2x %2x %2x %2x %2x %2x %2x %2x %2x %2x %2x %2x",
- cdata[ov->packet_size - 1],
- cdata[0], cdata[1], cdata[2], cdata[3], cdata[4], cdata[5],
- cdata[6], cdata[7], cdata[8], cdata[9], cdata[10], cdata[11]);
- }
-
- /* Check for SOF/EOF packet */
- if ((cdata[0] | cdata[1] | cdata[2] | cdata[3] |
- cdata[4] | cdata[5] | cdata[6] | cdata[7]) ||
- (~cdata[8] & 0x08))
- goto check_middle;
-
- /* Frame end */
- if (cdata[8] & 0x80) {
- ts = (struct timeval *)(frame->data
- + MAX_FRAME_SIZE(ov->maxwidth, ov->maxheight));
- do_gettimeofday(ts);
-
- /* Get the actual frame size from the EOF header */
- frame->rawwidth = ((int)(cdata[9]) + 1) * 8;
- frame->rawheight = ((int)(cdata[10]) + 1) * 8;
-
- PDEBUG(4, "Frame end, curframe = %d, packnum=%d, hw=%d, vw=%d, recvd=%d",
- ov->curframe,
- (int)(cdata[ov->packet_size - 1]),
- frame->rawwidth,
- frame->rawheight,
- frame->bytes_recvd);
-
- /* Validate the header data */
- RESTRICT_TO_RANGE(frame->rawwidth, ov->minwidth, ov->maxwidth);
- RESTRICT_TO_RANGE(frame->rawheight, ov->minheight, ov->maxheight);
-
- /* Don't allow byte count to exceed buffer size */
- RESTRICT_TO_RANGE(frame->bytes_recvd,
- 8,
- MAX_RAW_DATA_SIZE(ov->maxwidth,
- ov->maxheight));
-
- if (frame->scanstate == STATE_LINES) {
- int iFrameNext;
-
- frame->grabstate = FRAME_DONE; // FIXME: Is this right?
-
- if (waitqueue_active(&frame->wq)) {
- frame->grabstate = FRAME_DONE;
- wake_up_interruptible(&frame->wq);
- }
-
- /* If next frame is ready or grabbing,
- * point to it */
- iFrameNext = (ov->curframe + 1) % OV511_NUMFRAMES;
- if (ov->frame[iFrameNext].grabstate == FRAME_READY
- || ov->frame[iFrameNext].grabstate == FRAME_GRABBING) {
- ov->curframe = iFrameNext;
- ov->frame[iFrameNext].scanstate = STATE_SCANNING;
- } else {
- if (frame->grabstate == FRAME_DONE) {
- PDEBUG(4, "Frame done! congratulations");
- } else {
- PDEBUG(4, "Frame not ready? state = %d",
- ov->frame[iFrameNext].grabstate);
- }
-
- ov->curframe = -1;
- }
- } else {
- PDEBUG(5, "Frame done, but not scanning");
- }
- /* Image corruption caused by misplaced frame->segment = 0
- * fixed by carlosf@conectiva.com.br
- */
- } else {
- /* Frame start */
- PDEBUG(4, "Frame start, framenum = %d", ov->curframe);
-
- /* Check to see if it's a snapshot frame */
- /* FIXME?? Should the snapshot reset go here? Performance? */
- if (cdata[8] & 0x02) {
- frame->snapshot = 1;
- PDEBUG(3, "snapshot detected");
- }
-
- frame->scanstate = STATE_LINES;
- frame->bytes_recvd = 0;
- frame->compressed = cdata[8] & 0x40;
- }
-
-check_middle:
- /* Are we in a frame? */
- if (frame->scanstate != STATE_LINES) {
- PDEBUG(5, "Not in a frame; packet skipped");
- continue;
- }
-
-#if 0
- /* Skip packet if first 9 bytes are zero. These are common, so
- * we use a less expensive test here instead of later */
- if (frame->compressed) {
- int b, skip = 1;
-
- for (b = 0; b < 9; b++) {
- if (cdata[b])
- skip=0;
- }
-
- if (skip) {
- PDEBUG(5, "Skipping packet (all zero)");
- continue;
- }
- }
-#endif
- /* If frame start, skip header */
- if (frame->bytes_recvd == 0)
- offset = 9;
- else
- offset = 0;
-
- num = n - offset - 1;
-
- /* Dump all data exactly as received */
- if (dumppix == 2) {
- frame->bytes_recvd += n - 1;
- if (frame->bytes_recvd <= MAX_RAW_DATA_SIZE(ov->maxwidth, ov->maxheight))
- memmove(frame->rawdata + frame->bytes_recvd - (n - 1),
- &cdata[0], n - 1);
- else
- PDEBUG(3, "Raw data buffer overrun!! (%d)",
- frame->bytes_recvd
- - MAX_RAW_DATA_SIZE(ov->maxwidth,
- ov->maxheight));
- } else if (!frame->compressed && !remove_zeros) {
- frame->bytes_recvd += num;
- if (frame->bytes_recvd <= MAX_RAW_DATA_SIZE(ov->maxwidth, ov->maxheight))
- memmove(frame->rawdata + frame->bytes_recvd - num,
- &cdata[offset], num);
- else
- PDEBUG(3, "Raw data buffer overrun!! (%d)",
- frame->bytes_recvd
- - MAX_RAW_DATA_SIZE(ov->maxwidth,
- ov->maxheight));
- } else { /* Remove all-zero FIFO lines (aligned 32-byte blocks) */
- int b, in = 0, allzero, copied=0;
- if (offset) {
- frame->bytes_recvd += 32 - offset; // Bytes out
- memmove(frame->rawdata,
- &cdata[offset], 32 - offset);
- in += 32;
- }
-
- while (in < n - 1) {
- allzero = 1;
- for (b = 0; b < 32; b++) {
- if (cdata[in + b]) {
- allzero = 0;
- break;
- }
- }
-
- if (allzero) {
- /* Don't copy it */
- } else {
- if (frame->bytes_recvd + copied + 32
- <= MAX_RAW_DATA_SIZE(ov->maxwidth, ov->maxheight)) {
- memmove(frame->rawdata + frame->bytes_recvd + copied,
- &cdata[in], 32);
- copied += 32;
- } else {
- PDEBUG(3, "Raw data buffer overrun!!");
- }
- }
- in += 32;
- }
-
- frame->bytes_recvd += copied;
+ if (dumppix) {
+ memset(frame->data, 0,
+ MAX_DATA_SIZE(ov->maxwidth, ov->maxheight));
+ PDEBUG(4, "Dumping %d bytes", frame->bytes_recvd);
+ memcpy(frame->data, frame->rawdata, frame->bytes_recvd);
+ } else {
+ switch (frame->format) {
+ case VIDEO_PALETTE_GREY:
+ ov51x_postprocess_grey(ov, frame);
+ break;
+ case VIDEO_PALETTE_YUV420:
+ case VIDEO_PALETTE_YUV420P:
+ case VIDEO_PALETTE_RGB565:
+ case VIDEO_PALETTE_RGB24:
+ case VIDEO_PALETTE_YUV422:
+ case VIDEO_PALETTE_YUYV:
+ case VIDEO_PALETTE_YUV422P:
+ ov51x_postprocess_yuv420(ov, frame);
+ break;
+ default:
+ err("Cannot convert data to %s",
+ symbolic(v4l1_plist, frame->format));
}
-
}
-
- PDEBUG(5, "pn: %d %d %d %d %d %d %d %d %d %d",
- aPackNum[0], aPackNum[1], aPackNum[2], aPackNum[3], aPackNum[4],
- aPackNum[5],aPackNum[6], aPackNum[7], aPackNum[8], aPackNum[9]);
-
- return totlen;
}
-static int
-ov518_move_data(struct usb_ov511 *ov, struct urb *urb)
+/**********************************************************************
+ *
+ * OV51x data transfer, IRQ handler
+ *
+ **********************************************************************/
+
+static inline void
+ov511_move_data(struct usb_ov511 *ov, unsigned char *in, int n)
{
- unsigned char *cdata;
- int i, data_size, totlen = 0;
- struct ov511_frame *frame;
+ int num, offset;
+ int pnum = in[ov->packet_size - 1]; /* Get packet number */
+ int max_raw = MAX_RAW_DATA_SIZE(ov->maxwidth, ov->maxheight);
+ struct ov511_frame *frame = &ov->frame[ov->curframe];
struct timeval *ts;
- PDEBUG(5, "Moving %d packets", urb->number_of_packets);
-
- /* OV518(+) has no packet numbering */
- data_size = ov->packet_size;
-
- for (i = 0; i < urb->number_of_packets; i++) {
- int n = urb->iso_frame_desc[i].actual_length;
- int st = urb->iso_frame_desc[i].status;
-
- urb->iso_frame_desc[i].actual_length = 0;
- urb->iso_frame_desc[i].status = 0;
-
- cdata = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
-
- if (!n) {
- PDEBUG(4, "Zero-length packet");
- continue;
- }
-
- if (ov->curframe == -1) {
- PDEBUG(4, "No frame currently active");
- continue;
- }
+ /* SOF/EOF packets have 1st to 8th bytes zeroed and the 9th
+ * byte non-zero. The EOF packet has image width/height in the
+ * 10th and 11th bytes. The 9th byte is given as follows:
+ *
+ * bit 7: EOF
+ * 6: compression enabled
+ * 5: 422/420/400 modes
+ * 4: 422/420/400 modes
+ * 3: 1
+ * 2: snapshot button on
+ * 1: snapshot frame
+ * 0: even/odd field
+ */
- if (st)
- PDEBUG(2, "data error: [%d] len=%d, status=%d", i, n, st);
+ if (printph) {
+ info("ph(%3d): %2x %2x %2x %2x %2x %2x %2x %2x %2x %2x %2x %2x",
+ pnum, in[0], in[1], in[2], in[3], in[4], in[5], in[6],
+ in[7], in[8], in[9], in[10], in[11]);
+ }
- frame = &ov->frame[ov->curframe];
+ /* Check for SOF/EOF packet */
+ if ((in[0] | in[1] | in[2] | in[3] | in[4] | in[5] | in[6] | in[7]) ||
+ (~in[8] & 0x08))
+ goto check_middle;
- if (printph) {
- info("packet header: %2x %2x %2x %2x %2x %2x %2x %2x %2x %2x %2x %2x",
- cdata[0], cdata[1], cdata[2], cdata[3], cdata[4], cdata[5],
- cdata[6], cdata[7], cdata[8], cdata[9], cdata[10], cdata[11]);
- }
-
- /* A false positive here is likely, until OVT gives me
- * the definitive SOF/EOF format */
- if ((!(cdata[0] | cdata[1] | cdata[2] | cdata[3] |
- cdata[5])) && cdata[6]) {
-
- if (frame->scanstate == STATE_LINES) {
- PDEBUG(4, "Detected frame end/start");
- goto eof;
- } else { //scanstate == STATE_SCANNING
- /* Frame start */
- PDEBUG(4, "Frame start, framenum = %d", ov->curframe);
- goto sof;
- }
- } else {
- goto check_middle;
- }
-
-eof:
+ /* Frame end */
+ if (in[8] & 0x80) {
ts = (struct timeval *)(frame->data
+ MAX_FRAME_SIZE(ov->maxwidth, ov->maxheight));
do_gettimeofday(ts);
- PDEBUG(4, "Frame end, curframe = %d, hw=%d, vw=%d, recvd=%d",
- ov->curframe,
- (int)(cdata[9]), (int)(cdata[10]), frame->bytes_recvd);
-
- // FIXME: Since we don't know the header formats yet,
- // there is no way to know what the actual image size is
- frame->rawwidth = frame->width;
- frame->rawheight = frame->height;
+ /* Get the actual frame size from the EOF header */
+ frame->rawwidth = ((int)(in[9]) + 1) * 8;
+ frame->rawheight = ((int)(in[10]) + 1) * 8;
+
+ PDEBUG(4, "Frame end, frame=%d, pnum=%d, w=%d, h=%d, recvd=%d",
+ ov->curframe, pnum, frame->rawwidth, frame->rawheight,
+ frame->bytes_recvd);
/* Validate the header data */
RESTRICT_TO_RANGE(frame->rawwidth, ov->minwidth, ov->maxwidth);
- RESTRICT_TO_RANGE(frame->rawheight, ov->minheight, ov->maxheight);
+ RESTRICT_TO_RANGE(frame->rawheight, ov->minheight,
+ ov->maxheight);
/* Don't allow byte count to exceed buffer size */
- RESTRICT_TO_RANGE(frame->bytes_recvd,
- 8,
- MAX_RAW_DATA_SIZE(ov->maxwidth, ov->maxheight));
+ RESTRICT_TO_RANGE(frame->bytes_recvd, 8, max_raw);
if (frame->scanstate == STATE_LINES) {
- int iFrameNext;
+ int nextf;
frame->grabstate = FRAME_DONE; // FIXME: Is this right?
@@ -4155,115 +3812,280 @@
/* If next frame is ready or grabbing,
* point to it */
- iFrameNext = (ov->curframe + 1) % OV511_NUMFRAMES;
- if (ov->frame[iFrameNext].grabstate == FRAME_READY
- || ov->frame[iFrameNext].grabstate == FRAME_GRABBING) {
- ov->curframe = iFrameNext;
- ov->frame[iFrameNext].scanstate = STATE_SCANNING;
- frame = &ov->frame[iFrameNext];
+ nextf = (ov->curframe + 1) % OV511_NUMFRAMES;
+ if (ov->frame[nextf].grabstate == FRAME_READY
+ || ov->frame[nextf].grabstate == FRAME_GRABBING) {
+ ov->curframe = nextf;
+ ov->frame[nextf].scanstate = STATE_SCANNING;
} else {
if (frame->grabstate == FRAME_DONE) {
- PDEBUG(4, "Frame done! congratulations");
+ PDEBUG(4, "** Frame done **");
} else {
PDEBUG(4, "Frame not ready? state = %d",
- ov->frame[iFrameNext].grabstate);
+ ov->frame[nextf].grabstate);
}
ov->curframe = -1;
- PDEBUG(4, "SOF dropped (no active frame)");
- continue; /* Nowhere to store this frame */
}
+ } else {
+ PDEBUG(5, "Frame done, but not scanning");
}
/* Image corruption caused by misplaced frame->segment = 0
* fixed by carlosf@conectiva.com.br
*/
-sof:
- PDEBUG(4, "Starting capture on frame %d", frame->framenum);
-// Snapshot not reverse-engineered yet.
-#if 0
+ } else {
+ /* Frame start */
+ PDEBUG(4, "Frame start, framenum = %d", ov->curframe);
+
/* Check to see if it's a snapshot frame */
/* FIXME?? Should the snapshot reset go here? Performance? */
- if (cdata[8] & 0x02) {
+ if (in[8] & 0x02) {
frame->snapshot = 1;
PDEBUG(3, "snapshot detected");
}
-#endif
+
frame->scanstate = STATE_LINES;
frame->bytes_recvd = 0;
-// frame->compressed = 1;
+ frame->compressed = in[8] & 0x40;
+ }
check_middle:
- /* Are we in a frame? */
- if (frame->scanstate != STATE_LINES) {
- PDEBUG(4, "scanstate: no SOF yet");
- continue;
- }
+ /* Are we in a frame? */
+ if (frame->scanstate != STATE_LINES) {
+ PDEBUG(5, "Not in a frame; packet skipped");
+ return;
+ }
- /* Dump all data exactly as received */
- if (dumppix == 2) {
- frame->bytes_recvd += n;
- if (frame->bytes_recvd <= MAX_RAW_DATA_SIZE(ov->maxwidth, ov->maxheight))
- memmove(frame->rawdata + frame->bytes_recvd - n,
- &cdata[0], n);
- else
- PDEBUG(3, "Raw data buffer overrun!! (%d)",
- frame->bytes_recvd
- - MAX_RAW_DATA_SIZE(ov->maxwidth,
- ov->maxheight));
- } else {
- /* All incoming data are divided into 8-byte segments. If the
- * segment contains all zero bytes, it must be skipped. These
- * zero-segments allow the OV518 to mainain a constant data rate
- * regardless of the effectiveness of the compression. Segments
- * are aligned relative to the beginning of each isochronous
- * packet. The first segment is a header (the decompressor
- * skips it later).
- */
-
- int b, in = 0, allzero, copied=0;
-
- while (in < n) {
- allzero = 1;
- for (b = 0; b < 8; b++) {
- if (cdata[in + b]) {
- allzero = 0;
- break;
- }
+ /* If frame start, skip header */
+ if (frame->bytes_recvd == 0)
+ offset = 9;
+ else
+ offset = 0;
+
+ num = n - offset - 1;
+
+ /* Dump all data exactly as received */
+ if (dumppix == 2) {
+ frame->bytes_recvd += n - 1;
+ if (frame->bytes_recvd <= max_raw)
+ memcpy(frame->rawdata + frame->bytes_recvd - (n - 1),
+ in, n - 1);
+ else
+ PDEBUG(3, "Raw data buffer overrun!! (%d)",
+ frame->bytes_recvd - max_raw);
+ } else if (!frame->compressed && !remove_zeros) {
+ frame->bytes_recvd += num;
+ if (frame->bytes_recvd <= max_raw)
+ memcpy(frame->rawdata + frame->bytes_recvd - num,
+ in + offset, num);
+ else
+ PDEBUG(3, "Raw data buffer overrun!! (%d)",
+ frame->bytes_recvd - max_raw);
+ } else { /* Remove all-zero FIFO lines (aligned 32-byte blocks) */
+ int b, read = 0, allzero, copied = 0;
+ if (offset) {
+ frame->bytes_recvd += 32 - offset; // Bytes out
+ memcpy(frame->rawdata, in + offset, 32 - offset);
+ read += 32;
+ }
+
+ while (read < n - 1) {
+ allzero = 1;
+ for (b = 0; b < 32; b++) {
+ if (in[read + b]) {
+ allzero = 0;
+ break;
}
+ }
- if (allzero) {
+ if (allzero) {
/* Don't copy it */
+ } else {
+ if (frame->bytes_recvd + copied + 32 <= max_raw)
+ {
+ memcpy(frame->rawdata
+ + frame->bytes_recvd + copied,
+ in + read, 32);
+ copied += 32;
} else {
- if (frame->bytes_recvd + copied + 8
- <= MAX_RAW_DATA_SIZE(ov->maxwidth, ov->maxheight)) {
- memmove(frame->rawdata + frame->bytes_recvd + copied,
- &cdata[in], 8);
- copied += 8;
- } else {
- PDEBUG(3, "Raw data buffer overrun!!");
- }
+ PDEBUG(3, "Raw data buffer overrun!!");
}
- in += 8;
}
- frame->bytes_recvd += copied;
+ read += 32;
}
+
+ frame->bytes_recvd += copied;
}
+}
- return totlen;
+static inline void
+ov518_move_data(struct usb_ov511 *ov, unsigned char *in, int n)
+{
+ int max_raw = MAX_RAW_DATA_SIZE(ov->maxwidth, ov->maxheight);
+ struct ov511_frame *frame = &ov->frame[ov->curframe];
+ struct timeval *ts;
+
+ /* Don't copy the packet number byte */
+ if (ov->packet_numbering)
+ --n;
+
+ /* A false positive here is likely, until OVT gives me
+ * the definitive SOF/EOF format */
+ if ((!(in[0] | in[1] | in[2] | in[3] | in[5])) && in[6]) {
+ if (printph) {
+ info("ph: %2x %2x %2x %2x %2x %2x %2x %2x", in[0],
+ in[1], in[2], in[3], in[4], in[5], in[6], in[7]);
+ }
+
+ if (frame->scanstate == STATE_LINES) {
+ PDEBUG(4, "Detected frame end/start");
+ goto eof;
+ } else { //scanstate == STATE_SCANNING
+ /* Frame start */
+ PDEBUG(4, "Frame start, framenum = %d", ov->curframe);
+ goto sof;
+ }
+ } else {
+ goto check_middle;
+ }
+
+eof:
+ ts = (struct timeval *)(frame->data
+ + MAX_FRAME_SIZE(ov->maxwidth, ov->maxheight));
+ do_gettimeofday(ts);
+
+ PDEBUG(4, "Frame end, curframe = %d, hw=%d, vw=%d, recvd=%d",
+ ov->curframe,
+ (int)(in[9]), (int)(in[10]), frame->bytes_recvd);
+
+ // FIXME: Since we don't know the header formats yet,
+ // there is no way to know what the actual image size is
+ frame->rawwidth = frame->width;
+ frame->rawheight = frame->height;
+
+ /* Validate the header data */
+ RESTRICT_TO_RANGE(frame->rawwidth, ov->minwidth, ov->maxwidth);
+ RESTRICT_TO_RANGE(frame->rawheight, ov->minheight, ov->maxheight);
+
+ /* Don't allow byte count to exceed buffer size */
+ RESTRICT_TO_RANGE(frame->bytes_recvd, 8, max_raw);
+
+ if (frame->scanstate == STATE_LINES) {
+ int nextf;
+
+ frame->grabstate = FRAME_DONE; // FIXME: Is this right?
+
+ if (waitqueue_active(&frame->wq)) {
+ frame->grabstate = FRAME_DONE;
+ wake_up_interruptible(&frame->wq);
+ }
+
+ /* If next frame is ready or grabbing,
+ * point to it */
+ nextf = (ov->curframe + 1) % OV511_NUMFRAMES;
+ if (ov->frame[nextf].grabstate == FRAME_READY
+ || ov->frame[nextf].grabstate == FRAME_GRABBING) {
+ ov->curframe = nextf;
+ ov->frame[nextf].scanstate = STATE_SCANNING;
+ frame = &ov->frame[nextf];
+ } else {
+ if (frame->grabstate == FRAME_DONE) {
+ PDEBUG(4, "** Frame done **");
+ } else {
+ PDEBUG(4, "Frame not ready? state = %d",
+ ov->frame[nextf].grabstate);
+ }
+
+ ov->curframe = -1;
+ PDEBUG(4, "SOF dropped (no active frame)");
+ return; /* Nowhere to store this frame */
+ }
+ }
+sof:
+ PDEBUG(4, "Starting capture on frame %d", frame->framenum);
+
+// Snapshot not reverse-engineered yet.
+#if 0
+ /* Check to see if it's a snapshot frame */
+ /* FIXME?? Should the snapshot reset go here? Performance? */
+ if (in[8] & 0x02) {
+ frame->snapshot = 1;
+ PDEBUG(3, "snapshot detected");
+ }
+#endif
+ frame->scanstate = STATE_LINES;
+ frame->bytes_recvd = 0;
+ frame->compressed = 1;
+
+check_middle:
+ /* Are we in a frame? */
+ if (frame->scanstate != STATE_LINES) {
+ PDEBUG(4, "scanstate: no SOF yet");
+ return;
+ }
+
+ /* Dump all data exactly as received */
+ if (dumppix == 2) {
+ frame->bytes_recvd += n;
+ if (frame->bytes_recvd <= max_raw)
+ memcpy(frame->rawdata + frame->bytes_recvd - n, in, n);
+ else
+ PDEBUG(3, "Raw data buffer overrun!! (%d)",
+ frame->bytes_recvd - max_raw);
+ } else {
+ /* All incoming data are divided into 8-byte segments. If the
+ * segment contains all zero bytes, it must be skipped. These
+ * zero-segments allow the OV518 to mainain a constant data rate
+ * regardless of the effectiveness of the compression. Segments
+ * are aligned relative to the beginning of each isochronous
+ * packet. The first segment in each image is a header (the
+ * decompressor skips it later).
+ */
+
+ int b, read = 0, allzero, copied = 0;
+
+ while (read < n) {
+ allzero = 1;
+ for (b = 0; b < 8; b++) {
+ if (in[read + b]) {
+ allzero = 0;
+ break;
+ }
+ }
+
+ if (allzero) {
+ /* Don't copy it */
+ } else {
+ if (frame->bytes_recvd + copied + 8 <= max_raw)
+ {
+ memcpy(frame->rawdata
+ + frame->bytes_recvd + copied,
+ in + read, 8);
+ copied += 8;
+ } else {
+ PDEBUG(3, "Raw data buffer overrun!!");
+ }
+ }
+ read += 8;
+ }
+ frame->bytes_recvd += copied;
+ }
}
-static void
+static void
ov51x_isoc_irq(struct urb *urb)
{
- int len;
+ int i;
struct usb_ov511 *ov;
+ struct ov511_sbuf *sbuf;
if (!urb->context) {
PDEBUG(4, "no context");
return;
}
- ov = (struct usb_ov511 *) urb->context;
+ sbuf = urb->context;
+ ov = sbuf->ov;
if (!ov || !ov->dev || !ov->user) {
PDEBUG(4, "no device, or not open");
@@ -4275,16 +4097,51 @@
return;
}
+ if (urb->status == -ENOENT || urb->status == -ECONNRESET) {
+ PDEBUG(4, "URB unlinked");
+ return;
+ }
+
+ if (urb->status != -EINPROGRESS && urb->status != 0) {
+ err("ERROR: urb->status=%d: %s", urb->status,
+ symbolic(urb_errlist, urb->status));
+ }
+
/* Copy the data received into our frame buffer */
- if (ov->curframe >= 0) {
- if (ov->bclass == BCL_OV511)
- len = ov511_move_data(ov, urb);
- else if (ov->bclass == BCL_OV518)
- len = ov518_move_data(ov, urb);
- else
- err("Unknown bridge device (%d)", ov->bridge);
- } else if (waitqueue_active(&ov->wq)) {
- wake_up_interruptible(&ov->wq);
+ PDEBUG(5, "sbuf[%d]: Moving %d packets", sbuf->n,
+ urb->number_of_packets);
+ for (i = 0; i < urb->number_of_packets; i++) {
+ /* Warning: Don't call *_move_data() if no frame active! */
+ if (ov->curframe >= 0) {
+ int n = urb->iso_frame_desc[i].actual_length;
+ int st = urb->iso_frame_desc[i].status;
+ unsigned char *cdata;
+
+ urb->iso_frame_desc[i].actual_length = 0;
+ urb->iso_frame_desc[i].status = 0;
+
+ cdata = urb->transfer_buffer
+ + urb->iso_frame_desc[i].offset;
+
+ if (!n) {
+ PDEBUG(4, "Zero-length packet");
+ continue;
+ }
+
+ if (st)
+ PDEBUG(2, "data error: [%d] len=%d, status=%d",
+ i, n, st);
+
+ if (ov->bclass == BCL_OV511)
+ ov511_move_data(ov, cdata, n);
+ else if (ov->bclass == BCL_OV518)
+ ov518_move_data(ov, cdata, n);
+ else
+ err("Unknown bridge device (%d)", ov->bridge);
+
+ } else if (waitqueue_active(&ov->wq)) {
+ wake_up_interruptible(&ov->wq);
+ }
}
urb->dev = ov->dev;
@@ -4298,7 +4155,7 @@
*
***************************************************************************/
-static int
+static int
ov51x_init_isoc(struct usb_ov511 *ov)
{
struct urb *urb;
@@ -4340,27 +4197,32 @@
return -1;
}
- if (packetsize == -1) {
- // FIXME: OV518 is hardcoded to 15 FPS (alternate 5) for now
- if (ov->bclass == BCL_OV518)
- ov51x_set_packet_size(ov, 640);
- else
- ov51x_set_packet_size(ov, size);
+ // FIXME: OV518 is hardcoded to 15 FPS (alternate 5) for now
+ if (ov->bclass == BCL_OV518) {
+ if (packetsize == -1) {
+ ov518_set_packet_size(ov, 640);
+ } else {
+ info("Forcing packet size to %d", packetsize);
+ ov518_set_packet_size(ov, packetsize);
+ }
} else {
+ if (packetsize == -1) {
+ ov511_set_packet_size(ov, size);
+ } else {
info("Forcing packet size to %d", packetsize);
- ov51x_set_packet_size(ov, packetsize);
+ ov511_set_packet_size(ov, packetsize);
+ }
}
for (n = 0; n < OV511_NUMSBUF; n++) {
urb = usb_alloc_urb(FRAMES_PER_DESC);
-
if (!urb) {
err("init isoc: usb_alloc_urb ret. NULL");
return -ENOMEM;
}
ov->sbuf[n].urb = urb;
urb->dev = ov->dev;
- urb->context = ov;
+ urb->context = &ov->sbuf[n];
urb->pipe = usb_rcvisocpipe(ov->dev, OV511_ENDPOINT_ADDRESS);
urb->transfer_flags = USB_ISO_ASAP;
urb->transfer_buffer = ov->sbuf[n].data;
@@ -4382,31 +4244,23 @@
for (n = 0; n < OV511_NUMSBUF; n++) {
ov->sbuf[n].urb->dev = ov->dev;
err = usb_submit_urb(ov->sbuf[n].urb);
- if (err)
+ if (err) {
err("init isoc: usb_submit_urb(%d) ret %d", n, err);
+ return err;
+ }
}
return 0;
}
-static void
-ov51x_stop_isoc(struct usb_ov511 *ov)
+static void
+ov51x_unlink_isoc(struct usb_ov511 *ov)
{
int n;
- if (!ov->streaming || !ov->dev)
- return;
-
- PDEBUG(3, "*** Stopping capture ***");
-
- ov51x_set_packet_size(ov, 0);
-
- ov->streaming = 0;
-
/* Unschedule all of the iso td's */
for (n = OV511_NUMSBUF - 1; n >= 0; n--) {
if (ov->sbuf[n].urb) {
- ov->sbuf[n].urb->next = NULL;
usb_unlink_urb(ov->sbuf[n].urb);
usb_free_urb(ov->sbuf[n].urb);
ov->sbuf[n].urb = NULL;
@@ -4414,7 +4268,25 @@
}
}
-static int
+static void
+ov51x_stop_isoc(struct usb_ov511 *ov)
+{
+ if (!ov->streaming || !ov->dev)
+ return;
+
+ PDEBUG(3, "*** Stopping capture ***");
+
+ if (ov->bclass == BCL_OV518)
+ ov518_set_packet_size(ov, 0);
+ else
+ ov511_set_packet_size(ov, 0);
+
+ ov->streaming = 0;
+
+ ov51x_unlink_isoc(ov);
+}
+
+static int
ov51x_new_frame(struct usb_ov511 *ov, int framenum)
{
struct ov511_frame *frame;
@@ -4436,7 +4308,7 @@
frame = &ov->frame[framenum];
- PDEBUG(4, "framenum = %d, width = %d, height = %d", framenum,
+ PDEBUG(4, "framenum = %d, width = %d, height = %d", framenum,
frame->width, frame->height);
frame->grabstate = FRAME_GRABBING;
@@ -4465,172 +4337,133 @@
*
***************************************************************************/
-static int
-ov51x_alloc(struct usb_ov511 *ov)
+/*
+ * - You must acquire buf_lock before entering this function.
+ * - Because this code will free any non-null pointer, you must be sure to null
+ * them if you explicitly free them somewhere else!
+ */
+static void
+ov51x_do_dealloc(struct usb_ov511 *ov)
{
int i;
- const int w = ov->maxwidth;
- const int h = ov->maxheight;
- const int data_bufsize = OV511_NUMFRAMES * MAX_DATA_SIZE(w, h);
- const int raw_bufsize = OV511_NUMFRAMES * MAX_RAW_DATA_SIZE(w, h);
-
PDEBUG(4, "entered");
- down(&ov->buf_lock);
-
- if (ov->buf_state == BUF_PEND_DEALLOC) {
- ov->buf_state = BUF_ALLOCATED;
- del_timer(&ov->buf_timer);
- }
-
- if (ov->buf_state == BUF_ALLOCATED)
- goto out;
- ov->fbuf = rvmalloc(data_bufsize);
- if (!ov->fbuf)
- goto error;
-
- ov->rawfbuf = vmalloc(raw_bufsize);
- if (!ov->rawfbuf) {
- rvfree(ov->fbuf, data_bufsize);
+ if (ov->fbuf) {
+ rvfree(ov->fbuf, OV511_NUMFRAMES
+ * MAX_DATA_SIZE(ov->maxwidth, ov->maxheight));
ov->fbuf = NULL;
- goto error;
}
- memset(ov->rawfbuf, 0, raw_bufsize);
- ov->tempfbuf = vmalloc(raw_bufsize);
- if (!ov->tempfbuf) {
+ if (ov->rawfbuf) {
vfree(ov->rawfbuf);
ov->rawfbuf = NULL;
- rvfree(ov->fbuf, data_bufsize);
- ov->fbuf = NULL;
- goto error;
}
- memset(ov->tempfbuf, 0, raw_bufsize);
- for (i = 0; i < OV511_NUMSBUF; i++) {
- ov->sbuf[i].data = kmalloc(FRAMES_PER_DESC *
- MAX_FRAME_SIZE_PER_DESC, GFP_KERNEL);
- if (!ov->sbuf[i].data) {
- while (--i) {
- kfree(ov->sbuf[i].data);
- ov->sbuf[i].data = NULL;
- }
- vfree(ov->tempfbuf);
- ov->tempfbuf = NULL;
- vfree(ov->rawfbuf);
- ov->rawfbuf = NULL;
- rvfree(ov->fbuf, data_bufsize);
- ov->fbuf = NULL;
+ if (ov->tempfbuf) {
+ vfree(ov->tempfbuf);
+ ov->tempfbuf = NULL;
+ }
- goto error;
+ for (i = 0; i < OV511_NUMSBUF; i++) {
+ if (ov->sbuf[i].data) {
+ kfree(ov->sbuf[i].data);
+ ov->sbuf[i].data = NULL;
}
- PDEBUG(4, "sbuf[%d] @ %p", i, ov->sbuf[i].data);
}
for (i = 0; i < OV511_NUMFRAMES; i++) {
- ov->frame[i].data = ov->fbuf + i * MAX_DATA_SIZE(w, h);
- ov->frame[i].rawdata = ov->rawfbuf
- + i * MAX_RAW_DATA_SIZE(w, h);
- ov->frame[i].tempdata = ov->tempfbuf
- + i * MAX_RAW_DATA_SIZE(w, h);
- PDEBUG(4, "frame[%d] @ %p", i, ov->frame[i].data);
+ ov->frame[i].data = NULL;
+ ov->frame[i].rawdata = NULL;
+ ov->frame[i].tempdata = NULL;
+ if (ov->frame[i].compbuf) {
+ free_page((unsigned long) ov->frame[i].compbuf);
+ ov->frame[i].compbuf = NULL;
+ }
}
- ov->buf_state = BUF_ALLOCATED;
-out:
- up(&ov->buf_lock);
- PDEBUG(4, "leaving");
- return 0;
-error:
+ PDEBUG(4, "buffer memory deallocated");
ov->buf_state = BUF_NOT_ALLOCATED;
- up(&ov->buf_lock);
- PDEBUG(4, "errored");
- return -ENOMEM;
+ PDEBUG(4, "leaving");
}
-/*
- * - You must acquire buf_lock before entering this function.
- * - Because this code will free any non-null pointer, you must be sure to null
- * them if you explicitly free them somewhere else!
- */
-static void
-ov51x_do_dealloc(struct usb_ov511 *ov)
+static int
+ov51x_alloc(struct usb_ov511 *ov)
{
int i;
+ const int w = ov->maxwidth;
+ const int h = ov->maxheight;
+ const int data_bufsize = OV511_NUMFRAMES * MAX_DATA_SIZE(w, h);
+ const int raw_bufsize = OV511_NUMFRAMES * MAX_RAW_DATA_SIZE(w, h);
+
PDEBUG(4, "entered");
+ down(&ov->buf_lock);
- if (ov->fbuf) {
- rvfree(ov->fbuf, OV511_NUMFRAMES
- * MAX_DATA_SIZE(ov->maxwidth, ov->maxheight));
- ov->fbuf = NULL;
+ if (ov->buf_state == BUF_PEND_DEALLOC) {
+ ov->buf_state = BUF_ALLOCATED;
+ del_timer(&ov->buf_timer);
}
- if (ov->rawfbuf) {
- vfree(ov->rawfbuf);
- ov->rawfbuf = NULL;
- }
+ if (ov->buf_state == BUF_ALLOCATED)
+ goto out;
+
+ ov->fbuf = rvmalloc(data_bufsize);
+ if (!ov->fbuf)
+ goto error;
+
+ ov->rawfbuf = vmalloc(raw_bufsize);
+ if (!ov->rawfbuf)
+ goto error;
+
+ memset(ov->rawfbuf, 0, raw_bufsize);
- if (ov->tempfbuf) {
- vfree(ov->tempfbuf);
- ov->tempfbuf = NULL;
- }
+ ov->tempfbuf = vmalloc(raw_bufsize);
+ if (!ov->tempfbuf)
+ goto error;
+
+ memset(ov->tempfbuf, 0, raw_bufsize);
for (i = 0; i < OV511_NUMSBUF; i++) {
- if (ov->sbuf[i].data) {
- kfree(ov->sbuf[i].data);
- ov->sbuf[i].data = NULL;
- }
- }
+ ov->sbuf[i].data = kmalloc(FRAMES_PER_DESC *
+ MAX_FRAME_SIZE_PER_DESC, GFP_KERNEL);
+ if (!ov->sbuf[i].data)
+ goto error;
- for (i = 0; i < OV511_NUMFRAMES; i++) {
- ov->frame[i].data = NULL;
- ov->frame[i].rawdata = NULL;
- ov->frame[i].tempdata = NULL;
+ PDEBUG(4, "sbuf[%d] @ %p", i, ov->sbuf[i].data);
}
- PDEBUG(4, "buffer memory deallocated");
- ov->buf_state = BUF_NOT_ALLOCATED;
- PDEBUG(4, "leaving");
-}
+ for (i = 0; i < OV511_NUMFRAMES; i++) {
+ ov->frame[i].data = ov->fbuf + i * MAX_DATA_SIZE(w, h);
+ ov->frame[i].rawdata = ov->rawfbuf
+ + i * MAX_RAW_DATA_SIZE(w, h);
+ ov->frame[i].tempdata = ov->tempfbuf
+ + i * MAX_RAW_DATA_SIZE(w, h);
-static void
-ov51x_buf_callback(unsigned long data)
-{
- struct usb_ov511 *ov = (struct usb_ov511 *)data;
- PDEBUG(4, "entered");
- down(&ov->buf_lock);
+ ov->frame[i].compbuf =
+ (unsigned char *) __get_free_page(GFP_KERNEL);
+ if (!ov->frame[i].compbuf)
+ goto error;
- if (ov->buf_state == BUF_PEND_DEALLOC)
- ov51x_do_dealloc(ov);
+ PDEBUG(4, "frame[%d] @ %p", i, ov->frame[i].data);
+ }
+ ov->buf_state = BUF_ALLOCATED;
+out:
up(&ov->buf_lock);
PDEBUG(4, "leaving");
+ return 0;
+error:
+ ov51x_do_dealloc(ov);
+ up(&ov->buf_lock);
+ PDEBUG(4, "errored");
+ return -ENOMEM;
}
-static void
+static void
ov51x_dealloc(struct usb_ov511 *ov, int now)
{
- struct timer_list *bt = &(ov->buf_timer);
PDEBUG(4, "entered");
down(&ov->buf_lock);
-
- PDEBUG(4, "deallocating buffer memory %s", now ? "now" : "later");
-
- if (ov->buf_state == BUF_PEND_DEALLOC) {
- ov->buf_state = BUF_ALLOCATED;
- del_timer(bt);
- }
-
- if (now)
- ov51x_do_dealloc(ov);
- else {
- ov->buf_state = BUF_PEND_DEALLOC;
- init_timer(bt);
- bt->function = ov51x_buf_callback;
- bt->data = (unsigned long)ov;
- bt->expires = jiffies + buf_timeout * HZ;
- add_timer(bt);
- }
+ ov51x_do_dealloc(ov);
up(&ov->buf_lock);
PDEBUG(4, "leaving");
}
@@ -4641,7 +4474,7 @@
*
***************************************************************************/
-static int
+static int
ov51x_v4l1_open(struct video_device *vdev, int flags)
{
struct usb_ov511 *ov = vdev->priv;
@@ -4652,17 +4485,18 @@
down(&ov->lock);
err = -EBUSY;
- if (ov->user)
+ if (ov->user)
goto out;
- err = -ENOMEM;
- if (ov51x_alloc(ov))
+ err = ov51x_alloc(ov);
+ if (err < 0)
goto out;
ov->sub_flag = 0;
/* In case app doesn't set them... */
- if (ov51x_set_default_params(ov) < 0)
+ err = ov51x_set_default_params(ov);
+ if (err < 0)
goto out;
/* Make sure frames are reset */
@@ -4671,7 +4505,7 @@
ov->frame[i].bytes_read = 0;
}
- /* If compression is on, make sure now that a
+ /* If compression is on, make sure now that a
* decompressor can be loaded */
if (ov->compress && !ov->decomp_ops) {
err = request_decompressor(ov);
@@ -4686,23 +4520,22 @@
}
ov->user++;
-
+
if (ov->led_policy == LED_AUTO)
ov51x_led_control(ov, 1);
out:
up(&ov->lock);
-
return err;
}
-static void
+static void
ov51x_v4l1_close(struct video_device *vdev)
{
struct usb_ov511 *ov = vdev->priv;
PDEBUG(4, "ov511_close");
-
+
down(&ov->lock);
ov->user--;
@@ -4731,129 +4564,93 @@
kfree(ov);
ov = NULL;
}
-}
-
-static int
-ov51x_v4l1_init_done(struct video_device *vdev)
-{
-#if defined(CONFIG_PROC_FS) && defined(CONFIG_VIDEO_PROC_FS)
- create_proc_ov511_cam(vdev->priv);
-#endif
-
- return 0;
-}
-static long
-ov51x_v4l1_write(struct video_device *vdev, const char *buf,
- unsigned long count, int noblock)
-{
- return -EINVAL;
+ return;
}
/* Do not call this function directly! */
-static int
-ov51x_v4l1_ioctl_internal(struct video_device *vdev, unsigned int cmd,
+static int
+ov51x_v4l1_ioctl_internal(struct usb_ov511 *ov, unsigned int cmd,
void *arg)
{
- struct usb_ov511 *ov = vdev->priv;
-
PDEBUG(5, "IOCtl: 0x%X", cmd);
if (!ov->dev)
- return -EIO;
+ return -EIO;
switch (cmd) {
case VIDIOCGCAP:
{
- struct video_capability b;
+ struct video_capability *b = arg;
PDEBUG(4, "VIDIOCGCAP");
- memset(&b, 0, sizeof(b));
- sprintf(b.name, "%s USB Camera",
- ov->bridge == BRG_OV511 ? "OV511" :
- ov->bridge == BRG_OV511PLUS ? "OV511+" :
- ov->bridge == BRG_OV518 ? "OV518" :
- ov->bridge == BRG_OV518PLUS ? "OV518+" :
- "unknown");
- b.type = VID_TYPE_CAPTURE | VID_TYPE_SUBCAPTURE;
- if (ov->has_tuner)
- b.type |= VID_TYPE_TUNER;
- b.channels = ov->num_inputs;
- b.audios = ov->has_audio_proc ? 1:0;
- b.maxwidth = ov->maxwidth;
- b.maxheight = ov->maxheight;
- b.minwidth = ov->minwidth;
- b.minheight = ov->minheight;
+ memset(b, 0, sizeof(struct video_capability));
+ sprintf(b->name, "%s USB Camera",
+ symbolic(brglist, ov->bridge));
+ b->type = VID_TYPE_CAPTURE | VID_TYPE_SUBCAPTURE;
+ b->channels = ov->num_inputs;
+ b->audios = 0;
+ b->maxwidth = ov->maxwidth;
+ b->maxheight = ov->maxheight;
+ b->minwidth = ov->minwidth;
+ b->minheight = ov->minheight;
- if (copy_to_user(arg, &b, sizeof(b)))
- return -EFAULT;
-
return 0;
}
case VIDIOCGCHAN:
{
- struct video_channel v;
+ struct video_channel *v = arg;
PDEBUG(4, "VIDIOCGCHAN");
- if (copy_from_user(&v, arg, sizeof(v)))
- return -EFAULT;
-
- if ((unsigned)(v.channel) >= ov->num_inputs) {
- err("Invalid channel (%d)", v.channel);
+ if ((unsigned)(v->channel) >= ov->num_inputs) {
+ err("Invalid channel (%d)", v->channel);
return -EINVAL;
}
- v.norm = ov->norm;
- v.type = (ov->has_tuner) ? VIDEO_TYPE_TV : VIDEO_TYPE_CAMERA;
- v.flags = (ov->has_tuner) ? VIDEO_VC_TUNER : 0;
- v.flags |= (ov->has_audio_proc) ? VIDEO_VC_AUDIO : 0;
-// v.flags |= (ov->has_decoder) ? VIDEO_VC_NORM : 0;
- v.tuners = (ov->has_tuner) ? 1:0;
- decoder_get_input_name(ov, v.channel, v.name);
+ v->norm = ov->norm;
+ v->type = VIDEO_TYPE_CAMERA;
+ v->flags = 0;
+// v->flags |= (ov->has_decoder) ? VIDEO_VC_NORM : 0;
+ v->tuners = 0;
+ decoder_get_input_name(ov, v->channel, v->name);
- if (copy_to_user(arg, &v, sizeof(v)))
- return -EFAULT;
-
return 0;
}
case VIDIOCSCHAN:
{
- struct video_channel v;
+ struct video_channel *v = arg;
int err;
PDEBUG(4, "VIDIOCSCHAN");
- if (copy_from_user(&v, arg, sizeof(v)))
- return -EFAULT;
-
/* Make sure it's not a camera */
if (!ov->has_decoder) {
- if (v.channel == 0)
+ if (v->channel == 0)
return 0;
else
return -EINVAL;
}
- if (v.norm != VIDEO_MODE_PAL &&
- v.norm != VIDEO_MODE_NTSC &&
- v.norm != VIDEO_MODE_SECAM &&
- v.norm != VIDEO_MODE_AUTO) {
- err("Invalid norm (%d)", v.norm);
+ if (v->norm != VIDEO_MODE_PAL &&
+ v->norm != VIDEO_MODE_NTSC &&
+ v->norm != VIDEO_MODE_SECAM &&
+ v->norm != VIDEO_MODE_AUTO) {
+ err("Invalid norm (%d)", v->norm);
return -EINVAL;
}
- if ((unsigned)(v.channel) >= ov->num_inputs) {
- err("Invalid channel (%d)", v.channel);
+ if ((unsigned)(v->channel) >= ov->num_inputs) {
+ err("Invalid channel (%d)", v->channel);
return -EINVAL;
}
- err = decoder_set_input(ov, v.channel);
+ err = decoder_set_input(ov, v->channel);
if (err)
return err;
- err = decoder_set_norm(ov, v.norm);
+ err = decoder_set_norm(ov, v->norm);
if (err)
return err;
@@ -4861,43 +4658,37 @@
}
case VIDIOCGPICT:
{
- struct video_picture p;
+ struct video_picture *p = arg;
PDEBUG(4, "VIDIOCGPICT");
- memset(&p, 0, sizeof(p));
-
- if (sensor_get_picture(ov, &p))
+ memset(p, 0, sizeof(struct video_picture));
+ if (sensor_get_picture(ov, p))
return -EIO;
- if (copy_to_user(arg, &p, sizeof(p)))
- return -EFAULT;
-
return 0;
}
case VIDIOCSPICT:
{
- struct video_picture p;
+ struct video_picture *p = arg;
int i;
PDEBUG(4, "VIDIOCSPICT");
- if (copy_from_user(&p, arg, sizeof(p)))
- return -EFAULT;
-
- if (!get_depth(p.palette))
+ if (!get_depth(p->palette))
return -EINVAL;
- if (sensor_set_picture(ov, &p))
+ if (sensor_set_picture(ov, p))
return -EIO;
- if (force_palette && p.palette != force_palette) {
- info("Palette rejected (%d)", p.palette);
+ if (force_palette && p->palette != force_palette) {
+ info("Palette rejected (%s)",
+ symbolic(v4l1_plist, p->palette));
return -EINVAL;
}
// FIXME: Format should be independent of frames
- if (p.palette != ov->frame[0].format) {
+ if (p->palette != ov->frame[0].format) {
PDEBUG(4, "Detected format change");
/* If we're collecting previous frame wait
@@ -4906,79 +4697,73 @@
if (signal_pending(current)) return -EINTR;
mode_init_regs(ov, ov->frame[0].width,
- ov->frame[0].height, p.palette, ov->sub_flag);
+ ov->frame[0].height, p->palette, ov->sub_flag);
}
- PDEBUG(4, "Setting depth=%d, palette=%d", p.depth, p.palette);
+ PDEBUG(4, "Setting depth=%d, palette=%s",
+ p->depth, symbolic(v4l1_plist, p->palette));
+
for (i = 0; i < OV511_NUMFRAMES; i++) {
- ov->frame[i].depth = p.depth;
- ov->frame[i].format = p.palette;
+ ov->frame[i].depth = p->depth;
+ ov->frame[i].format = p->palette;
}
return 0;
}
case VIDIOCGCAPTURE:
{
- int vf;
+ int *vf = arg;
PDEBUG(4, "VIDIOCGCAPTURE");
- if (copy_from_user(&vf, arg, sizeof(vf)))
- return -EFAULT;
- ov->sub_flag = vf;
+ ov->sub_flag = *vf;
return 0;
}
case VIDIOCSCAPTURE:
{
- struct video_capture vc;
+ struct video_capture *vc = arg;
PDEBUG(4, "VIDIOCSCAPTURE");
- if (copy_from_user(&vc, arg, sizeof(vc)))
- return -EFAULT;
- if (vc.flags)
+ if (vc->flags)
return -EINVAL;
- if (vc.decimation)
+ if (vc->decimation)
return -EINVAL;
- vc.x &= ~3L;
- vc.y &= ~1L;
- vc.y &= ~31L;
-
- if (vc.width == 0)
- vc.width = 32;
-
- vc.height /= 16;
- vc.height *= 16;
- if (vc.height == 0)
- vc.height = 16;
-
- ov->subx = vc.x;
- ov->suby = vc.y;
- ov->subw = vc.width;
- ov->subh = vc.height;
+ vc->x &= ~3L;
+ vc->y &= ~1L;
+ vc->y &= ~31L;
+
+ if (vc->width == 0)
+ vc->width = 32;
+
+ vc->height /= 16;
+ vc->height *= 16;
+ if (vc->height == 0)
+ vc->height = 16;
+
+ ov->subx = vc->x;
+ ov->suby = vc->y;
+ ov->subw = vc->width;
+ ov->subh = vc->height;
return 0;
}
case VIDIOCSWIN:
{
- struct video_window vw;
+ struct video_window *vw = arg;
int i, result;
- if (copy_from_user(&vw, arg, sizeof(vw)))
- return -EFAULT;
-
- PDEBUG(4, "VIDIOCSWIN: width=%d, height=%d",
- vw.width, vw.height);
+ PDEBUG(4, "VIDIOCSWIN: %dx%d", vw->width, vw->height);
#if 0
- if (vw.flags)
+ if (vw->flags)
return -EINVAL;
- if (vw.clipcount)
+ if (vw->clipcount)
return -EINVAL;
- if (vw.height != ov->maxheight)
+ if (vw->height != ov->maxheight)
return -EINVAL;
- if (vw.width != ov->maxwidth)
+ if (vw->width != ov->maxwidth)
return -EINVAL;
#endif
@@ -4987,140 +4772,131 @@
interruptible_sleep_on(&ov->wq);
if (signal_pending(current)) return -EINTR;
- result = mode_init_regs(ov, vw.width, vw.height,
+ result = mode_init_regs(ov, vw->width, vw->height,
ov->frame[0].format, ov->sub_flag);
if (result < 0)
return result;
for (i = 0; i < OV511_NUMFRAMES; i++) {
- ov->frame[i].width = vw.width;
- ov->frame[i].height = vw.height;
+ ov->frame[i].width = vw->width;
+ ov->frame[i].height = vw->height;
}
return 0;
}
case VIDIOCGWIN:
{
- struct video_window vw;
-
- memset(&vw, 0, sizeof(vw));
- vw.x = 0; /* FIXME */
- vw.y = 0;
- vw.width = ov->frame[0].width;
- vw.height = ov->frame[0].height;
- vw.flags = 30;
+ struct video_window *vw = arg;
- PDEBUG(4, "VIDIOCGWIN: %dx%d", vw.width, vw.height);
+ memset(vw, 0, sizeof(struct video_window));
+ vw->x = 0; /* FIXME */
+ vw->y = 0;
+ vw->width = ov->frame[0].width;
+ vw->height = ov->frame[0].height;
+ vw->flags = 30;
- if (copy_to_user(arg, &vw, sizeof(vw)))
- return -EFAULT;
+ PDEBUG(4, "VIDIOCGWIN: %dx%d", vw->width, vw->height);
return 0;
}
case VIDIOCGMBUF:
{
- struct video_mbuf vm;
+ struct video_mbuf *vm = arg;
int i;
PDEBUG(4, "VIDIOCGMBUF");
- memset(&vm, 0, sizeof(vm));
- vm.size = OV511_NUMFRAMES
- * MAX_DATA_SIZE(ov->maxwidth, ov->maxheight);
- vm.frames = OV511_NUMFRAMES;
+ memset(vm, 0, sizeof(struct video_mbuf));
+ vm->size = OV511_NUMFRAMES
+ * MAX_DATA_SIZE(ov->maxwidth, ov->maxheight);
+ vm->frames = OV511_NUMFRAMES;
- vm.offsets[0] = 0;
+ vm->offsets[0] = 0;
for (i = 1; i < OV511_NUMFRAMES; i++) {
- vm.offsets[i] = vm.offsets[i-1]
+ vm->offsets[i] = vm->offsets[i-1]
+ MAX_DATA_SIZE(ov->maxwidth, ov->maxheight);
}
- if (copy_to_user((void *)arg, (void *)&vm, sizeof(vm)))
- return -EFAULT;
-
return 0;
}
case VIDIOCMCAPTURE:
{
- struct video_mmap vm;
+ struct video_mmap *vm = arg;
int ret, depth;
+ unsigned int f = vm->frame;
- if (copy_from_user((void *)&vm, (void *)arg, sizeof(vm)))
- return -EFAULT;
-
- PDEBUG(4, "CMCAPTURE");
- PDEBUG(4, "frame: %d, size: %dx%d, format: %d",
- vm.frame, vm.width, vm.height, vm.format);
+ PDEBUG(4, "VIDIOCMCAPTURE: frame: %d, %dx%d, %s", f, vm->width,
+ vm->height, symbolic(v4l1_plist, vm->format));
- depth = get_depth(vm.format);
+ depth = get_depth(vm->format);
if (!depth) {
- err("VIDIOCMCAPTURE: invalid format (%d)", vm.format);
+ err("VIDIOCMCAPTURE: invalid format (%s)",
+ symbolic(v4l1_plist, vm->format));
return -EINVAL;
}
- if ((unsigned)vm.frame >= OV511_NUMFRAMES) {
- err("VIDIOCMCAPTURE: invalid frame (%d)", vm.frame);
+ if (f >= OV511_NUMFRAMES) {
+ err("VIDIOCMCAPTURE: invalid frame (%d)", f);
return -EINVAL;
}
- if (vm.width > ov->maxwidth
- || vm.height > ov->maxheight) {
+ if (vm->width > ov->maxwidth
+ || vm->height > ov->maxheight) {
err("VIDIOCMCAPTURE: requested dimensions too big");
return -EINVAL;
}
- if (ov->frame[vm.frame].grabstate == FRAME_GRABBING) {
+ if (ov->frame[f].grabstate == FRAME_GRABBING) {
PDEBUG(4, "VIDIOCMCAPTURE: already grabbing");
return -EBUSY;
}
- if (force_palette && vm.format != force_palette) {
- info("palette rejected (%d)", vm.format);
+ if (force_palette && (vm->format != force_palette)) {
+ info("palette rejected (%s)",
+ symbolic(v4l1_plist, vm->format));
return -EINVAL;
}
- if ((ov->frame[vm.frame].width != vm.width) ||
- (ov->frame[vm.frame].height != vm.height) ||
- (ov->frame[vm.frame].format != vm.format) ||
- (ov->frame[vm.frame].sub_flag != ov->sub_flag) ||
- (ov->frame[vm.frame].depth != depth)) {
+ if ((ov->frame[f].width != vm->width) ||
+ (ov->frame[f].height != vm->height) ||
+ (ov->frame[f].format != vm->format) ||
+ (ov->frame[f].sub_flag != ov->sub_flag) ||
+ (ov->frame[f].depth != depth)) {
PDEBUG(4, "VIDIOCMCAPTURE: change in image parameters");
/* If we're collecting previous frame wait
before changing modes */
interruptible_sleep_on(&ov->wq);
if (signal_pending(current)) return -EINTR;
- ret = mode_init_regs(ov, vm.width, vm.height,
- vm.format, ov->sub_flag);
+ ret = mode_init_regs(ov, vm->width, vm->height,
+ vm->format, ov->sub_flag);
#if 0
if (ret < 0) {
PDEBUG(1, "Got error while initializing regs ");
return ret;
}
#endif
- ov->frame[vm.frame].width = vm.width;
- ov->frame[vm.frame].height = vm.height;
- ov->frame[vm.frame].format = vm.format;
- ov->frame[vm.frame].sub_flag = ov->sub_flag;
- ov->frame[vm.frame].depth = depth;
+ ov->frame[f].width = vm->width;
+ ov->frame[f].height = vm->height;
+ ov->frame[f].format = vm->format;
+ ov->frame[f].sub_flag = ov->sub_flag;
+ ov->frame[f].depth = depth;
}
/* Mark it as ready */
- ov->frame[vm.frame].grabstate = FRAME_READY;
+ ov->frame[f].grabstate = FRAME_READY;
- PDEBUG(4, "VIDIOCMCAPTURE: renewing frame %d", vm.frame);
+ PDEBUG(4, "VIDIOCMCAPTURE: renewing frame %d", f);
- return ov51x_new_frame(ov, vm.frame);
+ return ov51x_new_frame(ov, f);
}
case VIDIOCSYNC:
{
- int fnum, rc;
+ unsigned int fnum = *((unsigned int *) arg);
struct ov511_frame *frame;
+ int rc;
- if (copy_from_user((void *)&fnum, arg, sizeof(int)))
- return -EFAULT;
-
- if ((unsigned)fnum >= OV511_NUMFRAMES) {
+ if (fnum >= OV511_NUMFRAMES) {
err("VIDIOCSYNC: invalid frame (%d)", fnum);
return -EINVAL;
}
@@ -5154,7 +4930,7 @@
return ret;
goto redo;
}
- /* Fall through */
+ /* Fall through */
case FRAME_DONE:
if (ov->snap_enabled && !frame->snapshot) {
int ret;
@@ -5182,159 +4958,109 @@
}
case VIDIOCGFBUF:
{
- struct video_buffer vb;
-
- PDEBUG(4, "VIDIOCSCHAN");
+ struct video_buffer *vb = arg;
- memset(&vb, 0, sizeof(vb));
- vb.base = NULL; /* frame buffer not supported, not used */
+ PDEBUG(4, "VIDIOCGFBUF");
- if (copy_to_user((void *)arg, (void *)&vb, sizeof(vb)))
- return -EFAULT;
+ memset(vb, 0, sizeof(struct video_buffer));
return 0;
}
case VIDIOCGUNIT:
{
- struct video_unit vu;
+ struct video_unit *vu = arg;
PDEBUG(4, "VIDIOCGUNIT");
- memset(&vu, 0, sizeof(vu));
-
- vu.video = ov->vdev.minor; /* Video minor */
- vu.vbi = VIDEO_NO_UNIT; /* VBI minor */
- vu.radio = VIDEO_NO_UNIT; /* Radio minor */
- vu.audio = VIDEO_NO_UNIT; /* Audio minor */
- vu.teletext = VIDEO_NO_UNIT; /* Teletext minor */
-
- if (copy_to_user((void *)arg, (void *)&vu, sizeof(vu)))
- return -EFAULT;
-
- return 0;
- }
- case VIDIOCGTUNER:
- {
- struct video_tuner v;
-
- PDEBUG(4, "VIDIOCGTUNER");
-
- if (copy_from_user(&v, arg, sizeof(v)))
- return -EFAULT;
-
- if (!ov->has_tuner || v.tuner) // Only tuner 0
- return -EINVAL;
-
- strcpy(v.name, "Television");
-
- // FIXME: Need a way to get the real values
- v.rangelow = 0;
- v.rangehigh = ~0;
-
- v.flags = VIDEO_TUNER_PAL | VIDEO_TUNER_NTSC |
- VIDEO_TUNER_SECAM;
- v.mode = 0; /* FIXME: Not sure what this is yet */
- v.signal = 0xFFFF; /* unknown */
-
- call_i2c_clients(ov, cmd, &v);
-
- if (copy_to_user(arg, &v, sizeof(v)))
- return -EFAULT;
-
- return 0;
- }
- case VIDIOCSTUNER:
- {
- struct video_tuner v;
- int err;
-
- PDEBUG(4, "VIDIOCSTUNER");
-
- if (copy_from_user(&v, arg, sizeof(v)))
- return -EFAULT;
-
- /* Only no or one tuner for now */
- if (!ov->has_tuner || v.tuner)
- return -EINVAL;
-
- /* and it only has certain valid modes */
- if (v.mode != VIDEO_MODE_PAL &&
- v.mode != VIDEO_MODE_NTSC &&
- v.mode != VIDEO_MODE_SECAM) return -EOPNOTSUPP;
-
- /* Is this right/necessary? */
- err = decoder_set_norm(ov, v.mode);
- if (err)
- return err;
+ memset(vu, 0, sizeof(struct video_unit));
- call_i2c_clients(ov, cmd, &v);
+ vu->video = ov->vdev.minor;
+ vu->vbi = VIDEO_NO_UNIT;
+ vu->radio = VIDEO_NO_UNIT;
+ vu->audio = VIDEO_NO_UNIT;
+ vu->teletext = VIDEO_NO_UNIT;
return 0;
}
- case VIDIOCGFREQ:
- {
- unsigned long v = ov->freq;
+ default:
+ PDEBUG(3, "Unsupported IOCtl: 0x%X", cmd);
+ return -ENOIOCTLCMD;
+ } /* end switch */
- PDEBUG(4, "VIDIOCGFREQ");
+ return 0;
+}
- if (!ov->has_tuner)
- return -EINVAL;
-#if 0
- /* FIXME: this is necessary for testing */
- v = 46*16;
-#endif
- if (copy_to_user(arg, &v, sizeof(v)))
- return -EFAULT;
+/* This is implemented as video_generic_ioctl() in the new V4L's videodev.c */
+static int
+ov51x_v4l1_generic_ioctl(struct video_device *vdev, unsigned int cmd, void *arg)
+{
+ char sbuf[128];
+ void *mbuf = NULL;
+ void *parg = NULL;
+ int err = -EINVAL;
+
+ /* Copy arguments into temp kernel buffer */
+ switch (_IOC_DIR(cmd)) {
+ case _IOC_NONE:
+ parg = arg;
+ break;
+ case _IOC_READ: /* some v4l ioctls are marked wrong ... */
+ case _IOC_WRITE:
+ case (_IOC_WRITE | _IOC_READ):
+ if (_IOC_SIZE(cmd) <= sizeof(sbuf)) {
+ parg = sbuf;
+ } else {
+ /* too big to allocate from stack */
+ mbuf = kmalloc(_IOC_SIZE(cmd), GFP_KERNEL);
+ if (NULL == mbuf)
+ return -ENOMEM;
+ parg = mbuf;
+ }
- return 0;
+ err = -EFAULT;
+ if (copy_from_user(parg, arg, _IOC_SIZE(cmd)))
+ goto out;
+ break;
}
- case VIDIOCSFREQ:
- {
- unsigned long v;
-
- if (!ov->has_tuner)
- return -EINVAL;
-
- if (copy_from_user(&v, arg, sizeof(v)))
- return -EFAULT;
-
- PDEBUG(4, "VIDIOCSFREQ: %lx", v);
- ov->freq = v;
- call_i2c_clients(ov, cmd, &v);
+ err = ov51x_v4l1_ioctl_internal(vdev->priv, cmd, parg);
+ if (err == -ENOIOCTLCMD)
+ err = -EINVAL;
+ if (err < 0)
+ goto out;
- return 0;
- }
- case VIDIOCGAUDIO:
- case VIDIOCSAUDIO:
+ /* Copy results into user buffer */
+ switch (_IOC_DIR(cmd))
{
- /* FIXME: Implement this... */
- return 0;
+ case _IOC_READ:
+ case (_IOC_WRITE | _IOC_READ):
+ if (copy_to_user(arg, parg, _IOC_SIZE(cmd)))
+ err = -EFAULT;
+ break;
}
- default:
- PDEBUG(3, "Unsupported IOCtl: 0x%X", cmd);
- return -ENOIOCTLCMD;
- } /* end switch */
- return 0;
+out:
+ if (mbuf)
+ kfree(mbuf);
+ return err;
}
-static int
+static int
ov51x_v4l1_ioctl(struct video_device *vdev, unsigned int cmd, void *arg)
{
- int rc;
struct usb_ov511 *ov = vdev->priv;
+ int rc;
if (down_interruptible(&ov->lock))
return -EINTR;
- rc = ov51x_v4l1_ioctl_internal(vdev, cmd, arg);
+ rc = ov51x_v4l1_generic_ioctl(vdev, cmd, arg);
up(&ov->lock);
return rc;
}
-static inline long
+static inline long
ov51x_v4l1_read(struct video_device *vdev, char *buf, unsigned long count,
int noblock)
{
@@ -5397,7 +5123,7 @@
/* Wait while we're grabbing the image */
PDEBUG(4, "Waiting image grabbing");
- rc = wait_event_interruptible(frame->wq,
+ rc = wait_event_interruptible(frame->wq,
(frame->grabstate == FRAME_DONE)
|| (frame->grabstate == FRAME_ERROR));
@@ -5444,7 +5170,7 @@
get_frame_length(frame));
/* copy bytes to user space; we allow for partials reads */
-// if ((count + frame->bytes_read)
+// if ((count + frame->bytes_read)
// > get_frame_length((struct ov511_frame *)frame))
// count = frame->scanlength - frame->bytes_read;
@@ -5486,11 +5212,11 @@
return rc;
}
-static int
+static int
ov51x_v4l1_mmap(struct video_device *vdev, const char *adr, unsigned long size)
{
- struct usb_ov511 *ov = vdev->priv;
unsigned long start = (unsigned long)adr;
+ struct usb_ov511 *ov = vdev->priv;
unsigned long page, pos;
if (ov->dev == NULL)
@@ -5533,14 +5259,12 @@
open: ov51x_v4l1_open,
close: ov51x_v4l1_close,
read: ov51x_v4l1_read,
- write: ov51x_v4l1_write,
ioctl: ov51x_v4l1_ioctl,
mmap: ov51x_v4l1_mmap,
- initialize: ov51x_v4l1_init_done,
};
#if defined(CONFIG_PROC_FS) && defined(CONFIG_VIDEO_PROC_FS)
-static int
+static int
ov51x_control_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
unsigned long ularg)
{
@@ -5761,10 +5485,10 @@
*
***************************************************************************/
-/* This initializes the OV7610, OV7620, or OV7620AE sensor. The OV7620AE uses
+/* This initializes the OV7610, OV7620, or OV76BE sensor. The OV76BE uses
* the same register settings as the OV7610, since they are very similar.
*/
-static int
+static int
ov7xx0_configure(struct usb_ov511 *ov)
{
int i, success;
@@ -5915,7 +5639,7 @@
err("this to " EMAIL);
err("This is only a warning. You can attempt to use");
err("your camera anyway");
-// Only issue a warning for now
+// Only issue a warning for now
// return -1;
} else {
PDEBUG(1, "OV7xx0 initialized (method 2, %dx)", i+1);
@@ -5932,20 +5656,23 @@
info("Sensor is an OV7610");
ov->sensor = SEN_OV7610;
} else if ((rc & 3) == 1) {
- /* I don't know what's different about the 76BE yet */
- if (i2c_r(ov, 0x15) & 1)
+ /* I don't know what's different about the 76BE yet. */
+ if (i2c_r(ov, 0x15) & 1) {
info("Sensor is an OV7620AE");
- else
+ info("PLEASE REPORT THE EXISTENCE OF THIS SENSOR TO");
+ info("THE DRIVER AUTHOR");
+ } else {
info("Sensor is an OV76BE");
+ }
/* OV511+ will return all zero isoc data unless we
* configure the sensor as a 7620. Someone needs to
* find the exact reg. setting that causes this. */
if (ov->bridge == BRG_OV511PLUS) {
- info("Enabling 511+/7620AE workaround");
+ info("Enabling 511+/76BE workaround");
ov->sensor = SEN_OV7620;
} else {
- ov->sensor = SEN_OV7620AE;
+ ov->sensor = SEN_OV76BE;
}
} else if ((rc & 3) == 0) {
info("Sensor is an OV7620");
@@ -5981,7 +5708,7 @@
}
/* This initializes the OV6620, OV6630, OV6630AE, or OV6630AF sensor. */
-static int
+static int
ov6xx0_configure(struct usb_ov511 *ov)
{
int rc;
@@ -5995,6 +5722,8 @@
/* The ratio of 0x0c and 0x0d controls the white point */
{ OV511_I2C_BUS, 0x0c, 0x24 },
{ OV511_I2C_BUS, 0x0d, 0x24 },
+ { OV511_I2C_BUS, 0x0f, 0x15 }, /* COMS */
+ { OV511_I2C_BUS, 0x10, 0x75 }, /* AEC Exposure time */
{ OV511_I2C_BUS, 0x12, 0x24 }, /* Enable AGC */
{ OV511_I2C_BUS, 0x14, 0x04 },
/* 0x16: 0x06 helps frame stability with moving objects */
@@ -6006,10 +5735,11 @@
{ OV511_I2C_BUS, 0x2a, 0x04 }, /* Disable framerate adjust */
// { OV511_I2C_BUS, 0x2b, 0xac }, /* Framerate; Set 2a[7] first */
{ OV511_I2C_BUS, 0x2d, 0x99 },
+ { OV511_I2C_BUS, 0x33, 0xa0 }, /* Color Procesing Parameter */
{ OV511_I2C_BUS, 0x34, 0xd2 }, /* Max A/D range */
{ OV511_I2C_BUS, 0x38, 0x8b },
{ OV511_I2C_BUS, 0x39, 0x40 },
-
+
{ OV511_I2C_BUS, 0x3c, 0x39 }, /* Enable AEC mode changing */
{ OV511_I2C_BUS, 0x3c, 0x3c }, /* Change AEC mode */
{ OV511_I2C_BUS, 0x3c, 0x24 }, /* Disable AEC mode changing */
@@ -6089,7 +5819,7 @@
* control the color balance */
// /*OK?*/ { OV511_I2C_BUS, 0x4a, 0x80 }, // Check these
// /*OK?*/ { OV511_I2C_BUS, 0x4b, 0x80 },
-// /*U*/ { OV511_I2C_BUS, 0x4c, 0xd0 },
+// /*U*/ { OV511_I2C_BUS, 0x4c, 0xd0 },
/*d2?*/ { OV511_I2C_BUS, 0x4d, 0x10 }, /* This reduces noise a bit */
/*c1?*/ { OV511_I2C_BUS, 0x4e, 0x40 },
/*04?*/ { OV511_I2C_BUS, 0x4f, 0x07 },
@@ -6107,7 +5837,7 @@
};
PDEBUG(4, "starting sensor configuration");
-
+
if (init_ov_sensor(ov) < 0) {
err("Failed to read sensor ID. You might not have an OV6xx0,");
err("or it may be not responding. Report this to " EMAIL);
@@ -6122,19 +5852,18 @@
if (rc < 0) {
err("Error detecting sensor type");
return -1;
- } else if ((rc & 3) == 0) {
- info("Sensor is an OV6630");
+ }
+
+ if ((rc & 3) == 0)
ov->sensor = SEN_OV6630;
- } else if ((rc & 3) == 1) {
- info("Sensor is an OV6620");
+ else if ((rc & 3) == 1)
ov->sensor = SEN_OV6620;
- } else if ((rc & 3) == 2) {
- info("Sensor is an OV6630AE");
+ else if ((rc & 3) == 2)
ov->sensor = SEN_OV6630;
- } else if ((rc & 3) == 3) {
- info("Sensor is an OV6630AF");
+ else if ((rc & 3) == 3)
ov->sensor = SEN_OV6630;
- }
+
+ info("Sensor is an %s", symbolic(senlist, ov->sensor));
/* Set sensor-specific vars */
ov->maxwidth = 352;
@@ -6157,7 +5886,7 @@
if (write_regvals(ov, aRegvalsNorm6x30))
return -1;
}
-
+
return 0;
}
@@ -6219,8 +5948,8 @@
}
/* This initializes the SAA7111A video decoder. */
-static int
-saa7111a_configure(struct usb_ov511 *ov511)
+static int
+saa7111a_configure(struct usb_ov511 *ov)
{
int rc;
@@ -6264,45 +5993,51 @@
}
#endif
- /* Set sensor-specific vars */
- ov511->maxwidth = 640;
- ov511->maxheight = 480; /* Even/Odd fields */
- ov511->minwidth = 320;
- ov511->minheight = 240; /* Even field only */
-
- ov511->has_decoder = 1;
- ov511->num_inputs = 8;
- ov511->norm = VIDEO_MODE_AUTO;
- ov511->stop_during_set = 0; /* Decoder guarantees stable image */
+ /* 640x480 not supported with PAL */
+ if (ov->pal) {
+ ov->maxwidth = 320;
+ ov->maxheight = 240; /* Even field only */
+ } else {
+ ov->maxwidth = 640;
+ ov->maxheight = 480; /* Even/Odd fields */
+ }
+
+ ov->minwidth = 320;
+ ov->minheight = 240; /* Even field only */
+
+ ov->has_decoder = 1;
+ ov->num_inputs = 8;
+ ov->norm = VIDEO_MODE_AUTO;
+ ov->stop_during_set = 0; /* Decoder guarantees stable image */
/* Decoder doesn't change these values, so we use these instead of
* acutally reading the registers (which doesn't work) */
- ov511->brightness = 0x80 << 8;
- ov511->contrast = 0x40 << 9;
- ov511->colour = 0x40 << 9;
- ov511->hue = 32768;
+ ov->brightness = 0x80 << 8;
+ ov->contrast = 0x40 << 9;
+ ov->colour = 0x40 << 9;
+ ov->hue = 32768;
PDEBUG(4, "Writing SAA7111A registers");
- if (write_regvals(ov511, aRegvalsNormSAA7111A))
+ if (write_regvals(ov, aRegvalsNormSAA7111A))
return -1;
/* Detect version of decoder. This must be done after writing the
* initial regs or the decoder will lock up. */
- rc = i2c_r(ov511, 0x00);
+ rc = i2c_r(ov, 0x00);
if (rc < 0) {
err("Error detecting sensor version");
return -1;
} else {
info("Sensor is an SAA7111A (version 0x%x)", rc);
- ov511->sensor = SEN_SAA7111A;
+ ov->sensor = SEN_SAA7111A;
}
// FIXME: Fix this for OV518(+)
/* Latch to negative edge of clock. Otherwise, we get incorrect
* colors and jitter in the digital signal. */
- if (ov511->bclass == BCL_OV511)
- reg_w(ov511, 0x11, 0x00);
+ if (ov->bclass == BCL_OV511)
+ reg_w(ov, 0x11, 0x00);
else
warn("SAA7111A not yet supported with OV518/OV518+");
@@ -6313,8 +6048,6 @@
static int
ov511_configure(struct usb_ov511 *ov)
{
- int i;
-
static struct ov511_regvals aRegvalsInit511[] = {
{ OV511_REG_BUS, R51x_SYS_RESET, 0x7f },
{ OV511_REG_BUS, R51x_SYS_INIT, 0x01 },
@@ -6356,26 +6089,19 @@
goto error;
}
- ov->desc = -1;
PDEBUG (1, "CustomID = %d", ov->customid);
- for (i = 0; clist[i].id >= 0; i++) {
- if (ov->customid == clist[i].id) {
- info("model: %s", clist[i].description);
- ov->desc = i;
- break;
- }
- }
+ ov->desc = symbolic(camlist, ov->customid);
+ info("model: %s", ov->desc);
- if (clist[i].id == -1) {
+ if (0 == strcmp(ov->desc, NOT_DEFINED_STR)) {
err("Camera type (%d) not recognized", ov->customid);
err("Please notify " EMAIL " of the name,");
err("manufacturer, model, and this number of your camera.");
err("Also include the output of the detection process.");
}
- if (clist[i].id == 6) { /* USB Life TV (NTSC) */
- ov->tuner_type = 8; /* Temic 4036FY5 3X 1981 */
- }
+ if (ov->customid == 70) /* USB Life TV (PAL/SECAM) */
+ ov->pal = 1;
if (write_regvals(ov, aRegvalsInit511)) goto error;
@@ -6394,9 +6120,10 @@
if (ov511_init_compression(ov)) goto error;
- ov51x_set_packet_size(ov, 0);
+ ov->packet_numbering = 1;
+ ov511_set_packet_size(ov, 0);
- ov->snap_enabled = snapshot;
+ ov->snap_enabled = snapshot;
/* Test for 7xx0 */
PDEBUG(3, "Testing for 0V7xx0");
@@ -6415,21 +6142,21 @@
/* Test for 8xx0 */
PDEBUG(3, "Testing for 0V8xx0");
ov->primary_i2c_slave = OV8xx0_SID;
- if (ov51x_set_slave_ids(ov, OV8xx0_SID))
+ if (ov51x_set_slave_ids(ov, OV8xx0_SID) < 0)
goto error;
if (i2c_w(ov, 0x12, 0x80) < 0) {
/* Test for SAA7111A */
PDEBUG(3, "Testing for SAA7111A");
ov->primary_i2c_slave = SAA7111A_SID;
- if (ov51x_set_slave_ids(ov, SAA7111A_SID))
+ if (ov51x_set_slave_ids(ov, SAA7111A_SID) < 0)
goto error;
if (i2c_w(ov, 0x0d, 0x00) < 0) {
/* Test for KS0127 */
PDEBUG(3, "Testing for KS0127");
ov->primary_i2c_slave = KS0127_SID;
- if (ov51x_set_slave_ids(ov, KS0127_SID))
+ if (ov51x_set_slave_ids(ov, KS0127_SID) < 0)
goto error;
if (i2c_w(ov, 0x10, 0x00) < 0) {
@@ -6473,9 +6200,10 @@
}
/* This initializes the OV518/OV518+ and the sensor */
-static int
+static int
ov518_configure(struct usb_ov511 *ov)
{
+ /* For 518 and 518+ */
static struct ov511_regvals aRegvalsInit518[] = {
{ OV511_REG_BUS, R51x_SYS_RESET, 0x40 },
{ OV511_REG_BUS, R51x_SYS_INIT, 0xe1 },
@@ -6488,8 +6216,6 @@
{ OV511_DONE_BUS, 0x0, 0x00},
};
- /* New values, based on Windows driver. Since what they do is not
- * known yet, this may be incorrect. */
static struct ov511_regvals aRegvalsNorm518[] = {
{ OV511_REG_BUS, R51x_SYS_SNAP, 0x02 }, /* Reset */
{ OV511_REG_BUS, R51x_SYS_SNAP, 0x01 }, /* Enable */
@@ -6503,11 +6229,33 @@
{ OV511_DONE_BUS, 0x0, 0x00 },
};
+ static struct ov511_regvals aRegvalsNorm518Plus[] = {
+ { OV511_REG_BUS, R51x_SYS_SNAP, 0x02 }, /* Reset */
+ { OV511_REG_BUS, R51x_SYS_SNAP, 0x01 }, /* Enable */
+ { OV511_REG_BUS, 0x31, 0x0f },
+ { OV511_REG_BUS, 0x5d, 0x03 },
+ { OV511_REG_BUS, 0x24, 0x9f },
+ { OV511_REG_BUS, 0x25, 0x90 },
+ { OV511_REG_BUS, 0x20, 0x60 }, /* Was 0x08 */
+ { OV511_REG_BUS, 0x51, 0x02 },
+ { OV511_REG_BUS, 0x71, 0x19 },
+ { OV511_REG_BUS, 0x40, 0xff },
+ { OV511_REG_BUS, 0x41, 0x42 },
+ { OV511_REG_BUS, 0x46, 0x00 },
+ { OV511_REG_BUS, 0x33, 0x04 },
+ { OV511_REG_BUS, 0x21, 0x19 },
+ { OV511_REG_BUS, 0x3f, 0x10 },
+ { OV511_DONE_BUS, 0x0, 0x00 },
+ };
+
PDEBUG(4, "");
/* First 5 bits of custom ID reg are a revision ID on OV518 */
info("Device revision %d", 0x1F & reg_r(ov, R511_SYS_CUST_ID));
+ /* Give it the default description */
+ ov->desc = symbolic(camlist, 0);
+
if (write_regvals(ov, aRegvalsInit518)) goto error;
/* Set LED GPIO pin to output mode */
@@ -6526,13 +6274,25 @@
warn("Compression required with OV518...enabling");
}
- if (write_regvals(ov, aRegvalsNorm518)) goto error;
+ if (ov->bridge == BRG_OV518) {
+ if (write_regvals(ov, aRegvalsNorm518)) goto error;
+ } else if (ov->bridge == BRG_OV518PLUS) {
+ if (write_regvals(ov, aRegvalsNorm518Plus)) goto error;
+ } else {
+ err("Invalid bridge");
+ }
if (reg_w(ov, 0x2f, 0x80) < 0) goto error;
if (ov518_init_compression(ov)) goto error;
- ov51x_set_packet_size(ov, 0);
+ /* OV518+ has packet numbering turned on by default */
+ if (ov->bridge == BRG_OV518)
+ ov->packet_numbering = 0;
+ else
+ ov->packet_numbering = 1;
+
+ ov518_set_packet_size(ov, 0);
ov->snap_enabled = snapshot;
@@ -6577,9 +6337,8 @@
}
}
- // FIXME: Sizes > 320x240 are not working yet
- ov->maxwidth = 320;
- ov->maxheight = 240;
+ ov->maxwidth = 352;
+ ov->maxheight = 288;
// The OV518 cannot go as low as the sensor can
ov->minwidth = 160;
@@ -6640,46 +6399,42 @@
ov->lightfreq = lightfreq;
ov->num_inputs = 1; /* Video decoder init functs. change this */
ov->stop_during_set = !fastset;
- ov->tuner_type = tuner;
ov->backlight = backlight;
-
+ ov->mirror = mirror;
ov->auto_brt = autobright;
ov->auto_gain = autogain;
ov->auto_exp = autoexp;
switch (dev->descriptor.idProduct) {
case PROD_OV511:
- info("USB OV511 camera found");
ov->bridge = BRG_OV511;
ov->bclass = BCL_OV511;
break;
case PROD_OV511PLUS:
- info("USB OV511+ camera found");
ov->bridge = BRG_OV511PLUS;
ov->bclass = BCL_OV511;
break;
case PROD_OV518:
- info("USB OV518 camera found");
ov->bridge = BRG_OV518;
ov->bclass = BCL_OV518;
break;
case PROD_OV518PLUS:
- info("USB OV518+ camera found");
ov->bridge = BRG_OV518PLUS;
ov->bclass = BCL_OV518;
break;
case PROD_ME2CAM:
if (dev->descriptor.idVendor != VEND_MATTEL)
goto error;
- info("Intel Play Me2Cam (OV511+) found");
ov->bridge = BRG_OV511PLUS;
ov->bclass = BCL_OV511;
break;
default:
- err("Unknown product ID 0x%x", dev->descriptor.idProduct);
+ err("Unknown product ID 0x%04x", dev->descriptor.idProduct);
goto error_dealloc;
}
+ info("USB %s video device found", symbolic(brglist, ov->bridge));
+
/* Workaround for some applications that want data in RGB
* instead of BGR. */
if (force_rgb)
@@ -6713,6 +6468,12 @@
init_waitqueue_head(&ov->frame[i].wq);
}
+ for (i = 0; i < OV511_NUMSBUF; i++) {
+ ov->sbuf[i].ov = ov;
+ spin_lock_init(&ov->sbuf[i].lock);
+ ov->sbuf[i].n = i;
+ }
+
/* Unnecessary? (This is done on open(). Need to make sure variables
* are properly initialized without this before removing it, though). */
if (ov51x_set_default_params(ov) < 0)
@@ -6747,12 +6508,14 @@
info("Device registered on minor %d", ov->vdev.minor);
+#if defined(CONFIG_PROC_FS) && defined(CONFIG_VIDEO_PROC_FS)
+ create_proc_ov511_cam(ov);
+#endif
+
MOD_DEC_USE_COUNT;
return ov;
error:
- err("Camera initialization failed");
-
#if defined(CONFIG_PROC_FS) && defined(CONFIG_VIDEO_PROC_FS)
/* Safe to call even if entry doesn't exist */
destroy_proc_ov511_cam(ov);
@@ -6765,9 +6528,6 @@
up(&ov->cbuf_lock);
}
- usb_driver_release_interface(&ov511_driver,
- &dev->actconfig->interface[ov->iface]);
-
error_dealloc:
if (ov) {
kfree(ov);
@@ -6776,6 +6536,7 @@
error_out:
MOD_DEC_USE_COUNT;
+ err("Camera initialization failed");
return NULL;
}
@@ -6810,22 +6571,12 @@
ov->streaming = 0;
- /* Unschedule all of the iso td's */
- for (n = OV511_NUMSBUF - 1; n >= 0; n--) {
- if (ov->sbuf[n].urb) {
- ov->sbuf[n].urb->next = NULL;
- usb_unlink_urb(ov->sbuf[n].urb);
- usb_free_urb(ov->sbuf[n].urb);
- ov->sbuf[n].urb = NULL;
- }
- }
+ ov51x_unlink_isoc(ov);
#if defined(CONFIG_PROC_FS) && defined(CONFIG_VIDEO_PROC_FS)
destroy_proc_ov511_cam(ov);
#endif
- usb_driver_release_interface(&ov511_driver,
- &ov->dev->actconfig->interface[ov->iface]);
ov->dev = NULL;
/* Free the memory */
@@ -6858,7 +6609,7 @@
***************************************************************************/
/* Returns 0 for success */
-int
+int
ov511_register_decomp_module(int ver, struct ov51x_decomp_ops *ops, int ov518,
int mmx)
{
@@ -6915,7 +6666,7 @@
return -EBUSY;
}
-void
+void
ov511_deregister_decomp_module(int ov518, int mmx)
{
lock_kernel();
@@ -6931,13 +6682,13 @@
else
ov511_decomp_ops = NULL;
}
-
+
MOD_DEC_USE_COUNT;
unlock_kernel();
}
-static int __init
+static int __init
usb_ov511_init(void)
{
#if defined(CONFIG_PROC_FS) && defined(CONFIG_VIDEO_PROC_FS)
@@ -6947,11 +6698,8 @@
if (usb_register(&ov511_driver) < 0)
return -1;
- // FIXME: Don't know how to determine this yet
- ov51x_mmx_available = 0;
-
#if defined (__i386__)
- if (test_bit(X86_FEATURE_MMX, &boot_cpu_data.x86_capability))
+ if (test_bit(X86_FEATURE_MMX, boot_cpu_data.x86_capability))
ov51x_mmx_available = 1;
#endif
@@ -6960,7 +6708,7 @@
return 0;
}
-static void __exit
+static void __exit
usb_ov511_exit(void)
{
usb_deregister(&ov511_driver);
@@ -6974,6 +6722,5 @@
module_init(usb_ov511_init);
module_exit(usb_ov511_exit);
-/* No version, for compatibility with binary-only modules */
-EXPORT_SYMBOL_NOVERS(ov511_register_decomp_module);
-EXPORT_SYMBOL_NOVERS(ov511_deregister_decomp_module);
+EXPORT_SYMBOL(ov511_register_decomp_module);
+EXPORT_SYMBOL(ov511_deregister_decomp_module);
FUNET's LINUX-ADM group, linux-adm@nic.funet.fi
TCL-scripts by Sam Shen (who was at: slshen@lbl.gov)