#include <linux/sched.h>
#include <linux/list.h>
#include <linux/slab.h>
-#define __NO_VERSION__ /* Temporary: usbvideo is not a module yet */
#include <linux/module.h>
#include <linux/mm.h>
#include <linux/smp_lock.h>
unsigned long count, void *data);
#endif
+static void usbvideo_Disconnect(struct usb_device *dev, void *ptr);
+static void usbvideo_CameraRelease(uvd_t *uvd);
+
+static int usbvideo_v4l_ioctl(struct inode *inode, struct file *file,
+ unsigned int cmd, unsigned long arg);
+static int usbvideo_v4l_mmap(struct file *file, struct vm_area_struct *vma);
+static int usbvideo_v4l_open(struct inode *inode, struct file *file);
+static int usbvideo_v4l_read(struct file *file, char *buf,
+ size_t count, loff_t *ppos);
+static int usbvideo_v4l_close(struct inode *inode, struct file *file);
+
+static int usbvideo_StartDataPump(uvd_t *uvd);
+static void usbvideo_StopDataPump(uvd_t *uvd);
+static int usbvideo_GetFrame(uvd_t *uvd, int frameNum);
+static int usbvideo_NewFrame(uvd_t *uvd, int framenum);
+static void usbvideo_SoftwareContrastAdjustment(uvd_t *uvd,
+ usbvideo_frame_t *frame);
+
/*******************************/
/* Memory management functions */
/*******************************/
return ret;
}
-void *usbvideo_rvmalloc(unsigned long size)
+static void *usbvideo_rvmalloc(unsigned long size)
{
void *mem;
unsigned long adr;
return mem;
}
-void usbvideo_rvfree(void *mem, unsigned long size)
+static void usbvideo_rvfree(void *mem, unsigned long size)
{
unsigned long adr;
vfree(mem);
}
-void RingQueue_Initialize(RingQueue_t *rq)
+static void RingQueue_Initialize(RingQueue_t *rq)
{
assert(rq != NULL);
init_waitqueue_head(&rq->wqh);
}
-void RingQueue_Allocate(RingQueue_t *rq, int rqLen)
+static void RingQueue_Allocate(RingQueue_t *rq, int rqLen)
{
assert(rq != NULL);
assert(rqLen > 0);
assert(rq->queue != NULL);
}
-int RingQueue_IsAllocated(const RingQueue_t *rq)
+static int RingQueue_IsAllocated(const RingQueue_t *rq)
{
if (rq == NULL)
return 0;
return (rq->queue != NULL) && (rq->length > 0);
}
-void RingQueue_Free(RingQueue_t *rq)
+static void RingQueue_Free(RingQueue_t *rq)
{
assert(rq != NULL);
if (RingQueue_IsAllocated(rq)) {
return len;
}
+EXPORT_SYMBOL(RingQueue_Dequeue);
+
int RingQueue_Enqueue(RingQueue_t *rq, const unsigned char *cdata, int n)
{
int enqueued = 0;
return enqueued;
}
+EXPORT_SYMBOL(RingQueue_Enqueue);
+
int RingQueue_GetLength(const RingQueue_t *rq)
{
int ri, wi;
return wi + (rq->length - ri);
}
-void RingQueue_InterruptibleSleepOn(RingQueue_t *rq)
+EXPORT_SYMBOL(RingQueue_GetLength);
+
+static void RingQueue_InterruptibleSleepOn(RingQueue_t *rq)
{
assert(rq != NULL);
interruptible_sleep_on(&rq->wqh);
wake_up_interruptible(&rq->wqh);
}
+EXPORT_SYMBOL(RingQueue_WakeUpInterruptible);
+
/*
* usbvideo_VideosizeToString()
*
* 07-Aug-2000 Created.
* 19-Oct-2000 Reworked for usbvideo module.
*/
-void usbvideo_VideosizeToString(char *buf, int bufLen, videosize_t vs)
+static void usbvideo_VideosizeToString(char *buf, int bufLen, videosize_t vs)
{
char tmp[40];
int n;
* History:
* 01-Feb-2000 Created.
*/
-void usbvideo_OverlayChar(uvd_t *uvd, usbvideo_frame_t *frame,
- int x, int y, int ch)
+static void usbvideo_OverlayChar(uvd_t *uvd, usbvideo_frame_t *frame,
+ int x, int y, int ch)
{
static const unsigned short digits[16] = {
0xF6DE, /* 0 */
* History:
* 01-Feb-2000 Created.
*/
-void usbvideo_OverlayString(uvd_t *uvd, usbvideo_frame_t *frame,
- int x, int y, const char *str)
+static void usbvideo_OverlayString(uvd_t *uvd, usbvideo_frame_t *frame,
+ int x, int y, const char *str)
{
while (*str) {
usbvideo_OverlayChar(uvd, frame, x, y, *str);
* History:
* 01-Feb-2000 Created.
*/
-void usbvideo_OverlayStats(uvd_t *uvd, usbvideo_frame_t *frame)
+static void usbvideo_OverlayStats(uvd_t *uvd, usbvideo_frame_t *frame)
{
const int y_diff = 8;
char tmp[16];
* History:
* 14-Jan-2000 Corrected default multiplier.
*/
-void usbvideo_ReportStatistics(const uvd_t *uvd)
+static void usbvideo_ReportStatistics(const uvd_t *uvd)
{
if ((uvd != NULL) && (uvd->stats.urb_count > 0)) {
unsigned long allPackets, badPackets, goodPackets, percent;
}
}
+EXPORT_SYMBOL(usbvideo_DrawLine);
+
/*
* usbvideo_TestPattern()
*
usbvideo_OverlayStats(uvd, frame);
}
+EXPORT_SYMBOL(usbvideo_TestPattern);
+
/*
* usbvideo_HexDump()
*
printk("%s\n", tmp);
}
+EXPORT_SYMBOL(usbvideo_HexDump);
+
/* Debugging aid */
void usbvideo_SayAndWait(const char *what)
{
interruptible_sleep_on_timeout (&wq, HZ*3); /* Timeout */
}
+EXPORT_SYMBOL(usbvideo_SayAndWait);
+
/* ******************************************************************** */
static void usbvideo_ClientIncModCount(uvd_t *uvd)
return 0;
}
+EXPORT_SYMBOL(usbvideo_register);
+
/*
* usbvideo_Deregister()
*
*pCams = NULL;
}
+EXPORT_SYMBOL(usbvideo_Deregister);
+
/*
* usbvideo_Disconnect()
*
* 24-May-2000 Corrected to prevent race condition (MOD_xxx_USE_COUNT).
* 19-Oct-2000 Moved to usbvideo module.
*/
-void usbvideo_Disconnect(struct usb_device *dev, void *ptr)
+static void usbvideo_Disconnect(struct usb_device *dev, void *ptr)
{
static const char proc[] = "usbvideo_Disconnect";
uvd_t *uvd = (uvd_t *) ptr;
* History:
* 27-Jan-2000 Created.
*/
-void usbvideo_CameraRelease(uvd_t *uvd)
+static void usbvideo_CameraRelease(uvd_t *uvd)
{
static const char proc[] = "usbvideo_CameraRelease";
if (uvd == NULL) {
return uvd;
}
+EXPORT_SYMBOL(usbvideo_AllocateDevice);
+
int usbvideo_RegisterVideoDevice(uvd_t *uvd)
{
static const char proc[] = "usbvideo_RegisterVideoDevice";
return 0;
}
+EXPORT_SYMBOL(usbvideo_RegisterVideoDevice);
+
/* ******************************************************************** */
-int usbvideo_v4l_mmap(struct file *file, struct vm_area_struct *vma)
+static int usbvideo_v4l_mmap(struct file *file, struct vm_area_struct *vma)
{
uvd_t *uvd = file->private_data;
unsigned long start = vma->vm_start;
* 27-Jan-2000 Used USBVIDEO_NUMSBUF as number of URB buffers.
* 24-May-2000 Corrected to prevent race condition (MOD_xxx_USE_COUNT).
*/
-int usbvideo_v4l_open(struct inode *inode, struct file *file)
+static int usbvideo_v4l_open(struct inode *inode, struct file *file)
{
static const char proc[] = "usbvideo_v4l_open";
struct video_device *dev = video_devdata(file);
* 27-Jan-2000 Used USBVIDEO_NUMSBUF as number of URB buffers.
* 24-May-2000 Moved MOD_DEC_USE_COUNT outside of code that can sleep.
*/
-int usbvideo_v4l_close(struct inode *inode, struct file *file)
+static int usbvideo_v4l_close(struct inode *inode, struct file *file)
{
static const char proc[] = "usbvideo_v4l_close";
struct video_device *dev = file->private_data;
return 0;
}
-int usbvideo_v4l_ioctl(struct inode *inode, struct file *file,
+static int usbvideo_v4l_ioctl(struct inode *inode, struct file *file,
unsigned int cmd, unsigned long arg)
{
return video_usercopy(inode, file, cmd, arg, usbvideo_v4l_do_ioctl);
* 20-Oct-2000 Created.
* 01-Nov-2000 Added mutex (uvd->lock).
*/
-int usbvideo_v4l_read(struct file *file, char *buf,
+static int usbvideo_v4l_read(struct file *file, char *buf,
size_t count, loff_t *ppos)
{
static const char proc[] = "usbvideo_v4l_read";
* of hardcoded values. Simplified by using for loop,
* allowed any number of URBs.
*/
-int usbvideo_StartDataPump(uvd_t *uvd)
+static int usbvideo_StartDataPump(uvd_t *uvd)
{
static const char proc[] = "usbvideo_StartDataPump";
struct usb_device *dev = uvd->dev;
* 22-Jan-2000 Corrected order of actions to work after surprise removal.
* 27-Jan-2000 Used uvd->iface, uvd->ifaceAltInactive instead of hardcoded values.
*/
-void usbvideo_StopDataPump(uvd_t *uvd)
+static void usbvideo_StopDataPump(uvd_t *uvd)
{
static const char proc[] = "usbvideo_StopDataPump";
int i, j;
* 29-Mar-00 Added copying of previous frame into the current one.
* 6-Aug-00 Added model 3 video sizes, removed redundant width, height.
*/
-int usbvideo_NewFrame(uvd_t *uvd, int framenum)
+static int usbvideo_NewFrame(uvd_t *uvd, int framenum)
{
usbvideo_frame_t *frame;
int n;
* FLAGS_NO_DECODING set. Therefore, any regular build of any driver
* based on usbvideo can use this feature at any time.
*/
-void usbvideo_CollectRawData(uvd_t *uvd, usbvideo_frame_t *frame)
+static void usbvideo_CollectRawData(uvd_t *uvd, usbvideo_frame_t *frame)
{
int n;
}
}
-int usbvideo_GetFrame(uvd_t *uvd, int frameNum)
+static int usbvideo_GetFrame(uvd_t *uvd, int frameNum)
{
static const char proc[] = "usbvideo_GetFrame";
usbvideo_frame_t *frame = &uvd->frame[frameNum];
usbvideo_OverlayStats(uvd, frame);
}
+EXPORT_SYMBOL(usbvideo_DeinterlaceFrame);
+
/*
* usbvideo_SoftwareContrastAdjustment()
*
* History:
* 09-Feb-2001 Created.
*/
-void usbvideo_SoftwareContrastAdjustment(uvd_t *uvd, usbvideo_frame_t *frame)
+static void usbvideo_SoftwareContrastAdjustment(uvd_t *uvd,
+ usbvideo_frame_t *frame)
{
static const char proc[] = "usbvideo_SoftwareContrastAdjustment";
int i, j, v4l_linesize;
#define VALID_CALLBACK(uvd,cbName) ((((uvd) != NULL) && \
((uvd)->handle != NULL)) ? GET_CALLBACK(uvd,cbName) : NULL)
-void RingQueue_Initialize(RingQueue_t *rq);
-void RingQueue_Allocate(RingQueue_t *rq, int rqLen);
-int RingQueue_IsAllocated(const RingQueue_t *rq);
-void RingQueue_Free(RingQueue_t *rq);
int RingQueue_Dequeue(RingQueue_t *rq, unsigned char *dst, int len);
int RingQueue_Enqueue(RingQueue_t *rq, const unsigned char *cdata, int n);
int RingQueue_GetLength(const RingQueue_t *rq);
-void RingQueue_InterruptibleSleepOn(RingQueue_t *rq);
void RingQueue_WakeUpInterruptible(RingQueue_t *rq);
-void usbvideo_CollectRawData(uvd_t *uvd, usbvideo_frame_t *frame);
void usbvideo_DrawLine(
usbvideo_frame_t *frame,
int x1, int y1,
int x2, int y2,
unsigned char cr, unsigned char cg, unsigned char cb);
void usbvideo_HexDump(const unsigned char *data, int len);
-void usbvideo_OverlayChar(uvd_t *uvd, usbvideo_frame_t *frame, int x, int y, int ch);
-void usbvideo_OverlayString(uvd_t *uvd, usbvideo_frame_t *frame, int x, int y, const char *str);
-void usbvideo_OverlayStats(uvd_t *uvd, usbvideo_frame_t *frame);
-void usbvideo_ReportStatistics(const uvd_t *uvd);
void usbvideo_SayAndWait(const char *what);
void usbvideo_TestPattern(uvd_t *uvd, int fullframe, int pmode);
-void usbvideo_VideosizeToString(char *buf, int bufLen, videosize_t vs);
/* Memory allocation routines */
unsigned long usbvideo_kvirt_to_pa(unsigned long adr);
-void *usbvideo_rvmalloc(unsigned long size);
-void usbvideo_rvfree(void *mem, unsigned long size);
int usbvideo_register(
usbvideo_t **pCams,
uvd_t *usbvideo_AllocateDevice(usbvideo_t *cams);
int usbvideo_RegisterVideoDevice(uvd_t *uvd);
void usbvideo_Deregister(usbvideo_t **uvt);
-void usbvideo_Disconnect(struct usb_device *dev, void *ptr);
-void usbvideo_CameraRelease(uvd_t *uvd);
-int usbvideo_v4l_close(struct inode *inode, struct file *file);
int usbvideo_v4l_initialize(struct video_device *dev);
-int usbvideo_v4l_ioctl(struct inode *inode, struct file *file,
- unsigned int cmd, unsigned long arg);
-int usbvideo_v4l_mmap(struct file *file, struct vm_area_struct *vma);
-int usbvideo_v4l_open(struct inode *inode, struct file *file);
-int usbvideo_v4l_read(struct file *file, char *buf,
- size_t count, loff_t *ppos);
-
-int usbvideo_GetFrame(uvd_t *uvd, int frameNum);
-int usbvideo_NewFrame(uvd_t *uvd, int framenum);
-int usbvideo_StartDataPump(uvd_t *uvd);
-void usbvideo_StopDataPump(uvd_t *uvd);
+
void usbvideo_DeinterlaceFrame(uvd_t *uvd, usbvideo_frame_t *frame);
-void usbvideo_SoftwareContrastAdjustment(uvd_t *uvd, usbvideo_frame_t *frame);
/*
* This code performs bounds checking - use it when working with
projects / linux / commitdiff