* Problem installing driver
@ 2009-11-20 19:28 Mr Momcilo Medic
2009-11-20 20:52 ` Santiago Nunez-Corrales
0 siblings, 1 reply; 2+ messages in thread
From: Mr Momcilo Medic @ 2009-11-20 19:28 UTC (permalink / raw)
To: linux-media
[-- Attachment #1: Type: text/plain, Size: 387 bytes --]
Hello,
I am Momcilo Medic from Serbia, and I was advised to write you mail with my problem. I am trying to install simple driver and it returns an error. In attachment is error message as well as driver I am trying to install.
I am pretty much a newbie for Linux, so if I left something out please do tell and I will send as many info as you need.
Thanks in advance,
Momcilo.
[-- Attachment #2: smartcam.c --]
[-- Type: application/octet-stream, Size: 18719 bytes --]
/*
* SmartCam Video Capture driver - This code emulates a real video device with v4l2 api
*
* Copyright (C) 2008 Ionut Dediu <deionut@yahoo.com>
*
* Licensed under the GNU General Public License Version 2
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/*
* Authors:
* Ionut Dediu <deionut@yahoo.com> : main author
* Tomas Janousek <tomi@nomi.cz> : implement YUYV pixel format, fix poll and nonblock
*/
//#include <linux/module.h>
//#include <linux/errno.h>
//#include <linux/kernel.h>
//#include <linux/vmalloc.h>
#include <linux/vmalloc.h>
#include <linux/mm.h>
#include <media/v4l2-ioctl.h>
#include <media/v4l2-dev.h>
#include <linux/version.h>
#include <linux/videodev2.h>
#ifdef CONFIG_VIDEO_V4L1_COMPAT
/* Include V4L1 specific functions. Should be removed soon */
#include <linux/videodev.h>
#endif
//#include <linux/interrupt.h>
//#include <media/v4l2-common.h>
#define SMARTCAM_MAJOR_VERSION 0
#define SMARTCAM_MINOR_VERSION 1
#define SMARTCAM_RELEASE 0
#define SMARTCAM_VERSION KERNEL_VERSION(SMARTCAM_MAJOR_VERSION, SMARTCAM_MINOR_VERSION, SMARTCAM_RELEASE)
#define SMARTCAM_FRAME_WIDTH 320
#define SMARTCAM_FRAME_HEIGHT 240
#define SMARTCAM_YUYV_FRAME_SIZE SMARTCAM_FRAME_WIDTH * SMARTCAM_FRAME_HEIGHT * 2
#define SMARTCAM_RGB_FRAME_SIZE SMARTCAM_FRAME_WIDTH * SMARTCAM_FRAME_HEIGHT * 3
#define SMARTCAM_BUFFER_SIZE ((SMARTCAM_RGB_FRAME_SIZE + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1))
#define MAX_STREAMING_BUFFERS 7
#define SMARTCAM_NFORMATS 2
//#define SMARTCAM_DEBUG
#undef SCAM_MSG /* undef it, just in case */
#ifdef SMARTCAM_DEBUG
# define SCAM_MSG(fmt, args...) printk(KERN_ALERT "smartcam:" fmt, ## args)
# else
# define SCAM_MSG(fmt, args...) /* not debugging: nothing */
#endif
/* ------------------------------------------------------------------
Basic structures
------------------------------------------------------------------*/
struct smartcam_private_data {
};
static struct v4l2_pix_format formats[] = {
{
.width = SMARTCAM_FRAME_WIDTH,
.height = SMARTCAM_FRAME_HEIGHT,
.pixelformat = V4L2_PIX_FMT_YUYV,
.field = V4L2_FIELD_NONE,
.bytesperline = SMARTCAM_YUYV_FRAME_SIZE / SMARTCAM_FRAME_HEIGHT,
.sizeimage = SMARTCAM_YUYV_FRAME_SIZE,
.colorspace = V4L2_COLORSPACE_SMPTE170M,
.priv = 0,
}, {
.width = SMARTCAM_FRAME_WIDTH,
.height = SMARTCAM_FRAME_HEIGHT,
.pixelformat = V4L2_PIX_FMT_RGB24,
.field = V4L2_FIELD_NONE,
.bytesperline = SMARTCAM_RGB_FRAME_SIZE / SMARTCAM_FRAME_HEIGHT,
.sizeimage = SMARTCAM_RGB_FRAME_SIZE,
.colorspace = V4L2_COLORSPACE_SRGB,
.priv = 0,
} };
static const char fmtdesc[2][5] = { "YUYV", "RGB3" };
static DECLARE_WAIT_QUEUE_HEAD(wq);
static char* frame_data = NULL;
static __u32 frame_sequence = 0;
static __u32 last_read_frame = 0;
static __u32 format = 0;
static struct timeval frame_timestamp;
/* ------------------------------------------------------------------
IOCTL vidioc handling
------------------------------------------------------------------*/
static int vidioc_querycap(struct file *file, void *priv, struct v4l2_capability *cap)
{
strcpy(cap->driver, "smartcam");
strcpy(cap->card, "smartcam");
cap->version = SMARTCAM_VERSION;
cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
V4L2_CAP_STREAMING |
V4L2_CAP_READWRITE;
SCAM_MSG("(%s) %s called\n", current->comm, __FUNCTION__);
return 0;
}
static int vidioc_enum_fmt_cap(struct file *file, void *priv, struct v4l2_fmtdesc *f)
{
SCAM_MSG("(%s) %s called, index=%d\n", current->comm, __FUNCTION__, f->index);
if(f->index >= SMARTCAM_NFORMATS)
return -EINVAL;
strlcpy(f->description, fmtdesc[f->index], sizeof(f->description));
f->pixelformat = formats[f->index].pixelformat;
return 0;
}
static int vidioc_g_fmt_cap(struct file *file, void *priv, struct v4l2_format *f)
{
f->fmt.pix = formats[format];
SCAM_MSG("(%s) %s called\n", current->comm, __FUNCTION__);
return 0;
}
static int vidioc_try_fmt_cap(struct file *file, void *priv, struct v4l2_format *f)
{
int i;
SCAM_MSG("(%s) %s called\n", current->comm, __FUNCTION__);
for (i = 0; i < SMARTCAM_NFORMATS; i++) {
if (f->fmt.pix.pixelformat == formats[i].pixelformat) {
f->fmt.pix = formats[format];
return 0;
}
}
return -EINVAL;
}
static int vidioc_s_fmt_cap(struct file *file, void *priv, struct v4l2_format *f)
{
int i;
SCAM_MSG("%s called\n", __FUNCTION__);
for (i = 0; i < SMARTCAM_NFORMATS; i++) {
if ((f->fmt.pix.width == formats[i].width) &&
(f->fmt.pix.height == formats[i].height) &&
(f->fmt.pix.pixelformat == formats[i].pixelformat)) {
format = i;
f->fmt.pix = formats[format];
return 0;
}
}
printk(KERN_ALERT "smartcam (%s): vidioc_s_fmt_cap called\n\t\twidth=%d; \
height=%d; pixelformat=%s\n\t\tfield=%d; bytesperline=%d; sizeimage=%d; colspace = %d; return EINVAL\n",
current->comm, f->fmt.pix.width, f->fmt.pix.height, (char*)&f->fmt.pix.pixelformat,
f->fmt.pix.field, f->fmt.pix.bytesperline, f->fmt.pix.sizeimage, f->fmt.pix.colorspace);
return -EINVAL;
}
/************************ STREAMING IO / MMAP ***************************/
static int smartcam_mmap(struct file *file, struct vm_area_struct *vma)
{
int ret;
long length = vma->vm_end - vma->vm_start;
unsigned long start = vma->vm_start;
char *vmalloc_area_ptr = frame_data;
unsigned long pfn;
SCAM_MSG("(%s) %s called\n", current->comm, __FUNCTION__);
if (length > SMARTCAM_BUFFER_SIZE)
return -EIO;
/* loop over all pages, map each page individually */
while (length > 0)
{
pfn = vmalloc_to_pfn (vmalloc_area_ptr);
ret = remap_pfn_range(vma, start, pfn, PAGE_SIZE, PAGE_SHARED);
if(ret < 0)
{
return ret;
}
start += PAGE_SIZE;
vmalloc_area_ptr += PAGE_SIZE;
length -= PAGE_SIZE;
}
return 0;
}
static int vidioc_reqbufs(struct file *file, void *priv, struct v4l2_requestbuffers *reqbuf)
{
SCAM_MSG("(%s) %s called\n", current->comm, __FUNCTION__);
if(reqbuf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
{
return -EINVAL;
}
if(reqbuf->memory != V4L2_MEMORY_MMAP)
{
return -EINVAL;
}
if(reqbuf->count < 1)
reqbuf->count = 1;
if(reqbuf->count > MAX_STREAMING_BUFFERS)
reqbuf->count = MAX_STREAMING_BUFFERS;
return 0;
}
static int vidioc_querybuf(struct file *file, void *priv, struct v4l2_buffer *vidbuf)
{
SCAM_MSG("(%s) %s called\n", current->comm, __FUNCTION__);
if(vidbuf->index < 0 || vidbuf->index >= MAX_STREAMING_BUFFERS)
{
SCAM_MSG("vidioc_querybuf called - invalid buf index\n");
return -EINVAL;
}
if(vidbuf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
{
SCAM_MSG("vidioc_querybuf called - invalid buf type\n");
return -EINVAL;
}
if(vidbuf->memory != V4L2_MEMORY_MMAP)
{
SCAM_MSG("vidioc_querybuf called - invalid memory type\n");
return -EINVAL;
}
vidbuf->length = SMARTCAM_BUFFER_SIZE;
vidbuf->bytesused = formats[format].sizeimage;
vidbuf->flags = V4L2_BUF_FLAG_MAPPED;
vidbuf->m.offset = 2 * vidbuf->index * vidbuf->length;
vidbuf->reserved = 0;
return 0;
}
static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *vidbuf)
{
SCAM_MSG("(%s) %s called\n", current->comm, __FUNCTION__);
if(vidbuf->index < 0 || vidbuf->index >= MAX_STREAMING_BUFFERS)
{
return -EINVAL;
}
if(vidbuf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
{
return -EINVAL;
}
if(vidbuf->memory != V4L2_MEMORY_MMAP)
{
return -EINVAL;
}
vidbuf->length = SMARTCAM_BUFFER_SIZE;
vidbuf->bytesused = formats[format].sizeimage;
vidbuf->flags = V4L2_BUF_FLAG_MAPPED;
return 0;
}
static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *vidbuf)
{
if(file->f_flags & O_NONBLOCK)
SCAM_MSG("(%s) %s called (non-blocking)\n", current->comm, __FUNCTION__);
else
SCAM_MSG("(%s) %s called (blocking)\n", current->comm, __FUNCTION__);
if(vidbuf->index < 0 || vidbuf->index >= MAX_STREAMING_BUFFERS)
{
return -EINVAL;
}
if(vidbuf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
{
return -EINVAL;
}
if(vidbuf->memory != V4L2_MEMORY_MMAP)
{
return -EINVAL;
}
if(!(file->f_flags & O_NONBLOCK))
interruptible_sleep_on_timeout(&wq, HZ); /* wait max 1 second */
vidbuf->length = SMARTCAM_BUFFER_SIZE;
vidbuf->bytesused = formats[format].sizeimage;
vidbuf->flags = V4L2_BUF_FLAG_MAPPED;
vidbuf->timestamp = frame_timestamp;
vidbuf->sequence = frame_sequence;
last_read_frame = frame_sequence;
return 0;
}
#ifdef CONFIG_VIDEO_V4L1_COMPAT
static int vidiocgmbuf (struct file *file, void *priv, struct video_mbuf *mbuf)
{
SCAM_MSG("(%s) %s called\n", current->comm, __FUNCTION__);
return 0;
}
#endif
static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
{
SCAM_MSG("(%s) %s called\n", current->comm, __FUNCTION__);
return 0;
}
static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
{
SCAM_MSG("(%s) %s called\n", current->comm, __FUNCTION__);
return 0;
}
static int vidioc_s_std (struct file *file, void *priv, v4l2_std_id *i)
{
SCAM_MSG("(%s) %s called\n", current->comm, __FUNCTION__);
return 0;
}
/* only one input */
static int vidioc_enum_input(struct file *file, void *priv, struct v4l2_input *inp)
{
if(inp->index != 0)
{
SCAM_MSG("(%s) %s called - return EINVAL\n", current->comm, __FUNCTION__);
return -EINVAL;
}
else
{
SCAM_MSG("(%s) %s called - return 0\n", current->comm, __FUNCTION__);
}
inp->type = V4L2_INPUT_TYPE_CAMERA;
inp->std = V4L2_STD_NTSC_M;
strcpy(inp->name, "smartcam input");
return 0;
}
static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
{
*i = 0;
SCAM_MSG("(%s) %s called\n", current->comm, __FUNCTION__);
return 0;
}
static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
{
SCAM_MSG("(%s) %s called, input = %d\n", current->comm, __FUNCTION__, i);
if(i > 0)
return -EINVAL;
return 0;
}
/* --- controls ---------------------------------------------- */
static int vidioc_queryctrl(struct file *file, void *priv, struct v4l2_queryctrl *qc)
{
SCAM_MSG("(%s) %s called\n", current->comm, __FUNCTION__);
return -EINVAL;
}
static int vidioc_g_ctrl(struct file *file, void *priv, struct v4l2_control *ctrl)
{
SCAM_MSG("(%s) %s called - return EINVAL\n", current->comm, __FUNCTION__);
return -EINVAL;
}
static int vidioc_s_ctrl(struct file *file, void *priv, struct v4l2_control *ctrl)
{
SCAM_MSG("(%s) %s called - return EINVAL\n", current->comm, __FUNCTION__);
return -EINVAL;
}
static int vidioc_cropcap(struct file *file, void *priv, struct v4l2_cropcap *cropcap)
{
struct v4l2_rect defrect;
SCAM_MSG("(%s) %s called - return 0\n", current->comm, __FUNCTION__);
defrect.left = defrect.top = 0;
defrect.width = SMARTCAM_FRAME_WIDTH;
defrect.height = SMARTCAM_FRAME_HEIGHT;
cropcap->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
cropcap->bounds = cropcap->defrect = defrect;
return 0;
}
static int vidioc_g_crop(struct file *file, void *priv, struct v4l2_crop *crop)
{
SCAM_MSG("%s called - return EINVAL\n", __FUNCTION__);
return -EINVAL;
}
static int vidioc_s_crop(struct file *file, void *priv, struct v4l2_crop *crop)
{
SCAM_MSG("(%s) %s called - return EINVAL\n", current->comm, __FUNCTION__);
//return -EINVAL;
return 0;
}
static int vidioc_g_parm(struct file *file, void *priv, struct v4l2_streamparm *streamparm)
{
SCAM_MSG("(%s) %s called - return 0\n", current->comm, __FUNCTION__);
memset(streamparm, 0, sizeof(*streamparm));
streamparm->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
streamparm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
streamparm->parm.capture.capturemode = 0;
streamparm->parm.capture.timeperframe.numerator = 1;
streamparm->parm.capture.timeperframe.denominator = 10;
streamparm->parm.capture.extendedmode = 0;
streamparm->parm.capture.readbuffers = 3;
return 0;
}
static int vidioc_s_parm(struct file *file, void *priv, struct v4l2_streamparm *streamparm)
{
if(streamparm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
{
SCAM_MSG("(%s) %s called; numerator=%d, denominator=%d - return EINVAL\n", current->comm, __FUNCTION__,
streamparm->parm.capture.timeperframe.numerator, streamparm->parm.capture.timeperframe.denominator);
return -EINVAL;
}
SCAM_MSG("(%s) %s called; numerator=%d, denominator=%d, readbuffers=%d - return 0\n", current->comm, __FUNCTION__,
streamparm->parm.capture.timeperframe.numerator,
streamparm->parm.capture.timeperframe.denominator,
streamparm->parm.capture.readbuffers);
return 0;
}
/* ------------------------------------------------------------------
File operations for the device
------------------------------------------------------------------*/
static int smartcam_open(struct inode *inode, struct file *file)
{
int minor = 0;
minor = iminor(inode);
SCAM_MSG("(%s) %s called (minor=%d)\n", current->comm, __FUNCTION__, minor);
return 0;
}
static ssize_t smartcam_read(struct file *file, char __user *data, size_t count, loff_t *f_pos)
{
SCAM_MSG("(%s) %s called (count=%d, f_pos = %d)\n", current->comm, __FUNCTION__, count, (int) *f_pos);
if(*f_pos >= formats[format].sizeimage)
return 0;
if (!(file->f_flags & O_NONBLOCK))
interruptible_sleep_on_timeout(&wq, HZ/10); /* wait max 1 second */
last_read_frame = frame_sequence;
if(*f_pos + count > formats[format].sizeimage)
count = formats[format].sizeimage - *f_pos;
if(copy_to_user(data, frame_data + *f_pos, count))
{
return -EFAULT;
}
return 0;
}
static int Clamp (int x)
{
int r = x; /* round to nearest */
if (r < 0) return 0;
else if (r > 255) return 255;
else return r;
}
static void rgb_to_yuyv(void)
{
unsigned char *rp = frame_data, *wp = frame_data;
for (; rp < (unsigned char *)(frame_data + SMARTCAM_RGB_FRAME_SIZE);
rp += 6, wp += 4) {
unsigned char r1 = rp[0], g1 = rp[1], b1 = rp[2];
unsigned char r2 = rp[3], g2 = rp[4], b2 = rp[5];
unsigned char y1 = Clamp((299 * r1 + 587 * g1 + 114 * b1) / 1000);
unsigned char u1 = Clamp((-169 * r1 - 331 * g1 + 500 * b1) / 1000 + 128);
unsigned char v1 = Clamp((500 * r1 - 419 * g1 - 81 * b1) / 1000 + 128);
unsigned char y2 = Clamp((299 * r2 + 587 * g2 + 114 * b2) / 1000);
/*unsigned char u2 = Clamp((-169 * r2 - 331 * g2 + 500 * b2) / 1000 + 128);
unsigned char v2 = Clamp((500 * r2 - 419 * g2 - 81 * b2) / 1000 + 128);*/
wp[0] = y1;
wp[1] = u1;
wp[2] = y2;
wp[3] = v1;
}
}
static ssize_t smartcam_write(struct file *file, const char __user *data, size_t count, loff_t *f_pos)
{
SCAM_MSG("(%s) %s called (count=%d, f_pos = %d)\n", current->comm, __FUNCTION__, count, (int) *f_pos);
if (count >= SMARTCAM_RGB_FRAME_SIZE)
count = SMARTCAM_RGB_FRAME_SIZE;
if(copy_from_user(frame_data, data, count))
{
return -EFAULT;
}
++ frame_sequence;
if (formats[format].pixelformat == V4L2_PIX_FMT_YUYV)
rgb_to_yuyv();
do_gettimeofday(&frame_timestamp);
wake_up_interruptible_all(&wq);
return count;
}
static unsigned int smartcam_poll(struct file *file, struct poll_table_struct *wait)
{
int mask = (POLLOUT | POLLWRNORM); /* writable */
if (last_read_frame != frame_sequence)
mask |= (POLLIN | POLLRDNORM) /* readable */
SCAM_MSG("(%s) %s called\n", current->comm, __FUNCTION__);
poll_wait(file, &wq, wait);
return mask;
}
static int smartcam_release(struct inode *inode, struct file *file)
{
SCAM_MSG("(%s) %s called\n", current->comm, __FUNCTION__);
return 0;
}
static const struct file_operations smartcam_fops = {
.owner = THIS_MODULE,
.open = smartcam_open,
.release = smartcam_release,
.read = smartcam_read,
.write = smartcam_write,
.poll = smartcam_poll,
.ioctl = video_ioctl2, /* V4L2 ioctl handler */
.mmap = smartcam_mmap,
.llseek = no_llseek,
};
static const struct v4l2_ioctl_ops smartcam_ioctl_ops = {
.vidioc_querycap = vidioc_querycap,
.vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_cap,
.vidioc_g_fmt_vid_cap = vidioc_g_fmt_cap,
.vidioc_try_fmt_vid_cap = vidioc_try_fmt_cap,
.vidioc_s_fmt_vid_cap = vidioc_s_fmt_cap,
.vidioc_reqbufs = vidioc_reqbufs,
.vidioc_querybuf = vidioc_querybuf,
.vidioc_qbuf = vidioc_qbuf,
.vidioc_dqbuf = vidioc_dqbuf,
.vidioc_s_std = vidioc_s_std,
.vidioc_enum_input = vidioc_enum_input,
.vidioc_g_input = vidioc_g_input,
.vidioc_s_input = vidioc_s_input,
.vidioc_queryctrl = vidioc_queryctrl,
.vidioc_g_ctrl = vidioc_g_ctrl,
.vidioc_s_ctrl = vidioc_s_ctrl,
.vidioc_cropcap = vidioc_cropcap,
.vidioc_g_crop = vidioc_g_crop,
.vidioc_s_crop = vidioc_s_crop,
.vidioc_g_parm = vidioc_g_parm,
.vidioc_s_parm = vidioc_s_parm,
.vidioc_streamon = vidioc_streamon,
.vidioc_streamoff = vidioc_streamoff,
#ifdef CONFIG_VIDEO_V4L1_COMPAT
.vidiocgmbuf = vidiocgmbuf,
#endif
};
static struct video_device smartcam_vid = {
.name = "smartcam",
.vfl_type = VID_TYPE_CAPTURE,
//.hardware = 0,
.fops = &smartcam_fops,
.minor = -1,
.release = video_device_release_empty,
.tvnorms = V4L2_STD_NTSC_M,
.current_norm = V4L2_STD_NTSC_M,
.ioctl_ops = &smartcam_ioctl_ops,
};
/* -----------------------------------------------------------------
Initialization and module stuff
------------------------------------------------------------------*/
static int __init smartcam_init(void)
{
int ret = 0;
frame_data = (char*) vmalloc(SMARTCAM_BUFFER_SIZE);
if(!frame_data)
{
return -ENOMEM;
}
frame_sequence = last_read_frame = 0;
ret = video_register_device(&smartcam_vid, VFL_TYPE_GRABBER, -1);
SCAM_MSG("(%s) load status: %d\n", current->comm, ret);
return ret;
}
static void __exit smartcam_exit(void)
{
SCAM_MSG("(%s) %s called\n", current->comm, __FUNCTION__);
frame_sequence = 0;
vfree(frame_data);
video_unregister_device(&smartcam_vid);
}
module_init(smartcam_init);
module_exit(smartcam_exit);
MODULE_DESCRIPTION("Smartphone Webcam");
MODULE_AUTHOR("Ionut Dediu");
MODULE_LICENSE("Dual BSD/GPL");
[-- Attachment #3: Error.txt --]
[-- Type: text/plain, Size: 796 bytes --]
[root@Devourer driver_src]# make -C /lib/modules/2.6.30.9-96.fc11.x86_64/build/ M=`pwd`
make: Entering directory `/usr/src/kernels/2.6.30.9-96.fc11.x86_64'
LD /usr/src/smartcam-1.4.0/driver_src/built-in.o
CC [M] /usr/src/smartcam-1.4.0/driver_src/smartcam.o
/usr/src/smartcam-1.4.0/driver_src/smartcam.c:563: warning: initialization from incompatible pointer type
/usr/src/smartcam-1.4.0/driver_src/smartcam.c:599: error: ‘VID_TYPE_CAPTURE’ undeclared here (not in a function)
/usr/src/smartcam-1.4.0/driver_src/smartcam.c:601: warning: initialization from incompatible pointer type
make[1]: *** [/usr/src/smartcam-1.4.0/driver_src/smartcam.o] Error 1
make: *** [_module_/usr/src/smartcam-1.4.0/driver_src] Error 2
make: Leaving directory `/usr/src/kernels/2.6.30.9-96.fc11.x86_64'
^ permalink raw reply [flat|nested] 2+ messages in thread* Re: Problem installing driver
2009-11-20 19:28 Problem installing driver Mr Momcilo Medic
@ 2009-11-20 20:52 ` Santiago Nunez-Corrales
0 siblings, 0 replies; 2+ messages in thread
From: Santiago Nunez-Corrales @ 2009-11-20 20:52 UTC (permalink / raw)
To: Mr Momcilo Medic; +Cc: linux-media
Hi Momcilo,
That error means the code is unable to find the kernel sources
containing all the definitions from v4l2. Within the driver directory,
look for a file named Makefile or Rules.make or Makefile.rules. In one
of those, there should be a variable pointing to the kernel sources in
your Linux distribution (usually in /usr/src/linux, consult the
particular documentation in case you need to install the package or
download from www.kernel.org). Set the variable to your particular
kernel and recompile.
Regards,
Mr Momcilo Medic wrote:
> Hello,
>
> I am Momcilo Medic from Serbia, and I was advised to write you mail with my problem. I am trying to install simple driver and it returns an error. In attachment is error message as well as driver I am trying to install.
>
> I am pretty much a newbie for Linux, so if I left something out please do tell and I will send as many info as you need.
>
> Thanks in advance,
> Momcilo.
>
>
>
--
Santiago Nunez-Corrales, Eng.
RidgeRun Engineering, LLC
Guayabos, Curridabat
San Jose, Costa Rica
+(506) 2271 1487
+(506) 8313 0536
http://www.ridgerun.com
^ permalink raw reply [flat|nested] 2+ messages in thread
end of thread, other threads:[~2009-11-20 20:51 UTC | newest]
Thread overview: 2+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2009-11-20 19:28 Problem installing driver Mr Momcilo Medic
2009-11-20 20:52 ` Santiago Nunez-Corrales
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox