From: Yusuf Caglar Akyuz <cag...@bilkon-kontrol.com.tr>
This commit fixes build errors for V4l2 driver previously ported from
2.6.10 tree.
Signed-off-by: Yusuf Caglar Akyuz <cag...@bilkon-kontrol.com.tr>
---
drivers/media/video/davinci/davinci_display.c | 90 +++++++++++++------------
include/media/davinci/davinci_display.h | 3 +-
2 files changed, 49 insertions(+), 44 deletions(-)
diff --git a/drivers/media/video/davinci/davinci_display.c
b/drivers/media/video/davinci/davinci_display.c
index 64b6970..3a7a074 100644
--- a/drivers/media/video/davinci/davinci_display.c
+++ b/drivers/media/video/davinci/davinci_display.c
@@ -17,7 +17,7 @@
*/
/* davinci_display.c */
-/*#define DEBUG */
+#define DEBUG
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
@@ -27,12 +27,16 @@
#include <linux/string.h>
#include <linux/videodev.h>
#include <linux/videodev2.h>
+#include <media/v4l2-ioctl.h>
#include <linux/wait.h>
#include <linux/time.h>
#include <linux/device.h>
-#include <asm/irq.h>
-#include <asm/page.h>
-#include <asm/arch/cpu.h>
+#include <linux/irq.h>
+#include <linux/mm.h>
+#include <linux/platform_device.h>
+#include <linux/mutex.h>
+#include <asm/pgtable.h>
+#include <mach/cputype.h>
#include <media/davinci/davinci_enc.h>
#include <media/davinci/davinci_display.h>
@@ -112,7 +116,8 @@ static inline unsigned long davinci_alloc_buffer(unsigned
int buf_size)
if (mem) {
unsigned long adr = (unsigned long)mem;
while (size > 0) {
- SetPageReserved(virt_to_page(adr));
+ /* FIXME: SetPageReserved alternative ??? */
+ //SetPageReserved(virt_to_page(adr));
adr += PAGE_SIZE;
size -= PAGE_SIZE;
}
@@ -133,7 +138,8 @@ static inline void davinci_free_buffer(unsigned long addr,
adr = addr;
size = PAGE_SIZE << (get_order(buf_size));
while (size > 0) {
- ClearPageReserved(virt_to_page(adr));
+ /* FIXME: ClearPageReserved alternative ??? */
+ //ClearPageReserved(virt_to_page(adr));
adr += PAGE_SIZE;
size -= PAGE_SIZE;
}
@@ -185,13 +191,13 @@ static int davinci_buffer_prepare(struct videobuf_queue
*q,
dev_dbg(davinci_display_dev, "<davinci_buffer_prepare>\n");
/* If buffer is not initialized, initialize it */
- if (STATE_NEEDS_INIT == vb->state) {
+ if (VIDEOBUF_NEEDS_INIT == vb->state) {
vb->width = davinci_dm.mode_info.xres;
vb->height = davinci_dm.mode_info.yres;
vb->size = vb->width * vb->height;
vb->field = field;
}
- vb->state = STATE_PREPARED;
+ vb->state = VIDEOBUF_PREPARED;
/* if user pointer memory mechanism is used, get the physical
* address of the buffer
*/
@@ -281,7 +287,7 @@ static void davinci_buffer_queue(struct videobuf_queue *q,
/* add the buffer to the DMA queue */
list_add_tail(&vb->queue, &layer->dma_queue);
/* Change state of the buffer */
- vb->state = STATE_QUEUED;
+ vb->state = VIDEOBUF_QUEUED;
dev_dbg(davinci_display_dev, "</davinci_buffer_queue>\n");
}
@@ -313,7 +319,7 @@ static void davinci_buffer_release(struct videobuf_queue *q,
davinci_free_buffer(layer->fbuffers[vb->i], buf_size);
layer->fbuffers[vb->i] = 0;
}
- vb->state = STATE_NEEDS_INIT;
+ vb->state = VIDEOBUF_NEEDS_INIT;
dev_dbg(davinci_display_dev, "</davinci_buffer_release>\n");
}
@@ -322,7 +328,7 @@ static struct videobuf_queue_ops video_qops = {
.buf_prepare = davinci_buffer_prepare,
.buf_queue = davinci_buffer_queue,
.buf_release = davinci_buffer_release,
- .buf_config = davinci_buffer_config,
+ //.buf_config = davinci_buffer_config,
};
static u8 layer_first_int = 1;
@@ -359,7 +365,7 @@ static void davinci_display_isr(unsigned int event, void
*dispObj)
/* Mark status of the curFrm to
* done and unlock semaphore on it */
layer->curFrm->ts = timevalue;
- layer->curFrm->state = STATE_DONE;
+ layer->curFrm->state = VIDEOBUF_DONE;
wake_up_interruptible(&layer->curFrm->done);
/* Make curFrm pointing to nextFrm */
layer->curFrm = layer->nextFrm;
@@ -371,7 +377,7 @@ static void davinci_display_isr(unsigned int event, void
*dispObj)
/* Remove that buffer from the buffer queue */
list_del(&layer->nextFrm->queue);
/* Mark status of the buffer as active */
- layer->nextFrm->state = STATE_ACTIVE;
+ layer->nextFrm->state = VIDEOBUF_ACTIVE;
/* Set top and bottom field addresses in
VPIF registers */
addr = layer->curFrm->boff;
@@ -419,7 +425,7 @@ static void davinci_display_isr(unsigned int event, void
*dispObj)
/* Change status of the curFrm */
dev_dbg(davinci_display_dev,
"Done with this video buffer\n");
- layer->curFrm->state = STATE_DONE;
+ layer->curFrm->state = VIDEOBUF_DONE;
/* unlock semaphore on curFrm */
wake_up_interruptible(&layer->curFrm->done);
/* Make curFrm pointing to
@@ -448,7 +454,7 @@ static void davinci_display_isr(unsigned int event, void
*dispObj)
/* Mark state of the frame
to active */
- layer->nextFrm->state = STATE_ACTIVE;
+ layer->nextFrm->state = VIDEOBUF_ACTIVE;
addr = layer->nextFrm->boff;
davinci_disp_start_layer(layer->layer_info.id,
addr);
@@ -675,7 +681,7 @@ static int davinci_disp_check_window_params(struct
v4l2_rect *c)
* This function will provide different V4L2 commands.This function can be
* used to configure driver or get status of driver as per command passed
* by application */
-static int davinci_doioctl(struct inode *inode, struct file *file,
+static int davinci_doioctl(struct file *file,
unsigned int cmd, unsigned long arg)
{
int ret = 0;
@@ -1071,15 +1077,15 @@ static int davinci_doioctl(struct inode *inode, struct
file *file,
}
/* Initialize videobuf queue as per the
buffer type */
- videobuf_queue_init(&layer->buffer_queue,
+ videobuf_queue_dma_contig_init(&layer->buffer_queue,
&video_qops, NULL,
&layer->irqlock,
V4L2_BUF_TYPE_VIDEO_OUTPUT,
layer->pix_fmt.field,
sizeof(struct videobuf_buffer), fh);
/* Set buffer to Linear buffer */
- videobuf_set_buftype(&layer->buffer_queue,
- VIDEOBUF_BUF_LINEAR);
+ /*videobuf_set_buftype(&layer->buffer_queue,
+ VIDEOBUF_BUF_LINEAR);*/
/* Set io allowed member of file handle to
* TRUE */
fh->io_allowed = 1;
@@ -1124,18 +1130,18 @@ static int davinci_doioctl(struct inode *inode, struct
file *file,
}
/* bufferqueue is empty store buffer address
* in VPBE registers */
- down(&layer->buffer_queue.lock);
+ mutex_lock(&layer->buffer_queue.vb_lock);
tbuf = *(struct v4l2_buffer *)arg;
buf1 = layer->buffer_queue.bufs[tbuf.index];
if (buf1->memory != tbuf.memory) {
dev_err(davinci_display_dev,
"invalid buffer type\n");
- up(&layer->buffer_queue.lock);
+ mutex_unlock(&layer->buffer_queue.vb_lock);
return -EINVAL;
}
- if ((buf1->state == STATE_QUEUED) ||
- (buf1->state == STATE_ACTIVE)) {
- up(&layer->buffer_queue.lock);
+ if ((buf1->state == VIDEOBUF_QUEUED) ||
+ (buf1->state == VIDEOBUF_ACTIVE)) {
+ mutex_unlock(&layer->buffer_queue.vb_lock);
dev_err(davinci_display_dev, "invalid state\n");
return -EINVAL;
}
@@ -1143,7 +1149,7 @@ static int davinci_doioctl(struct inode *inode, struct
file *file,
switch (buf1->memory) {
case V4L2_MEMORY_MMAP:
if (buf1->baddr == 0) {
- up(&layer->buffer_queue.lock);
+
mutex_unlock(&layer->buffer_queue.vb_lock);
dev_err(davinci_display_dev,
"No Buffer address\n");
return -EINVAL;
@@ -1151,12 +1157,12 @@ static int davinci_doioctl(struct inode *inode, struct
file *file,
break;
case V4L2_MEMORY_USERPTR:
if (tbuf.length < buf1->bsize) {
- up(&layer->buffer_queue.lock);
+
mutex_unlock(&layer->buffer_queue.vb_lock);
dev_err(davinci_display_dev,
"No Buffer address\n");
return -EINVAL;
}
- if ((STATE_NEEDS_INIT != buf1->state)
+ if ((VIDEOBUF_NEEDS_INIT != buf1->state)
&& (buf1->baddr != tbuf.m.userptr))
davinci_buffer_release(&layer->
buffer_queue,
@@ -1164,7 +1170,7 @@ static int davinci_doioctl(struct inode *inode, struct
file *file,
buf1->baddr = tbuf.m.userptr;
break;
default:
- up(&layer->buffer_queue.lock);
+ mutex_unlock(&layer->buffer_queue.vb_lock);
dev_err(davinci_display_dev,
"Unknow Buffer type \n");
return -EINVAL;
@@ -1174,7 +1180,7 @@ static int davinci_doioctl(struct inode *inode, struct
file *file,
davinci_buffer_prepare(&layer->buffer_queue,
buf1,
layer->buffer_queue.field);
- buf1->state = STATE_ACTIVE;
+ buf1->state = VIDEOBUF_ACTIVE;
addr = buf1->boff;
layer->nextFrm = buf1;
@@ -1182,7 +1188,7 @@ static int davinci_doioctl(struct inode *inode, struct
file *file,
local_irq_restore(flags);
list_add_tail(&buf1->stream,
&(layer->buffer_queue.stream));
- up(&layer->buffer_queue.lock);
+ mutex_unlock(&layer->buffer_queue.vb_lock);
break;
}
@@ -1278,7 +1284,7 @@ static int davinci_doioctl(struct inode *inode, struct
file *file,
/* Remove buffer from the buffer queue */
list_del(&layer->curFrm->queue);
/* Mark state of the current frame to active */
- layer->curFrm->state = STATE_ACTIVE;
+ layer->curFrm->state = VIDEOBUF_ACTIVE;
/* Initialize field_id and started member */
layer->field_id = 0;
@@ -1338,14 +1344,14 @@ static int davinci_doioctl(struct inode *inode, struct
file *file,
/*
* ======== davinci_ioctl ========*/
/* Calls davinci_doioctl function */
-static int davinci_ioctl(struct inode *inode, struct file *file,
+static long davinci_ioctl(struct file *file,
unsigned int cmd, unsigned long arg)
{
int ret;
dev_dbg(davinci_display_dev, "Start of davinci ioctl\n");
- ret = video_usercopy(inode, file, cmd, arg, (void *)davinci_doioctl);
+ ret = video_usercopy(file, cmd, arg, (void *)davinci_doioctl);
if ((ret >= 0) && (VIDIOC_S_FMT == cmd || VIDIOC_TRY_FMT == cmd)) {
- ret = video_usercopy(inode, file, VIDIOC_G_FMT,
+ ret = video_usercopy(file, VIDIOC_G_FMT,
arg, (void *)davinci_doioctl);
}
dev_dbg(davinci_display_dev, "</davinci_ioctl>\n");
@@ -1425,9 +1431,9 @@ static int davinci_config_layer(enum
davinci_display_device_id id)
*=====davinci_open===== */
/* It creates object of file handle structure and stores it in private_data
* member of filepointer */
-static int davinci_open(struct inode *inode, struct file *filep)
+static int davinci_open(struct file *filep)
{
- int minor = iminor(inode);
+ int minor = iminor(filep->f_path.dentry->d_inode);
int found = -1;
int i = 0;
struct display_obj *layer;
@@ -1487,7 +1493,7 @@ static int davinci_open(struct inode *inode, struct file
*filep)
*=====davinci_release=====*/
/* This function deletes buffer queue, frees the buffers and the davinci
display file * handle */
-static int davinci_release(struct inode *inode, struct file *filep)
+static int davinci_release(struct file *filep)
{
/* Get the layer object and file handle object */
struct davinci_fh *fh = filep->private_data;
@@ -1539,19 +1545,17 @@ static void davinci_platform_release(struct device
/* This is called when the reference count goes to zero */
}
-static struct file_operations davinci_fops = {
+static struct v4l2_file_operations davinci_fops = {
.owner = THIS_MODULE,
.open = davinci_open,
.release = davinci_release,
.ioctl = davinci_ioctl,
- .mmap = davinci_mmap
+ .mmap = davinci_mmap,
};
static struct video_device davinci_video_template = {
.name = "davinci",
- .type = VID_TYPE_CAPTURE,
- .hardware = 0,
.fops = &davinci_fops,
- .minor = -1
+ .minor = -1,
};
/*
@@ -1591,7 +1595,7 @@ static __init int davinci_probe(struct device *device)
/* Initialize field of video device */
*vbd = davinci_video_template;
- vbd->dev = device;
+ vbd->dev = *device;
vbd->release = video_device_release;
snprintf(vbd->name, sizeof(vbd->name),
"DaVinci_VPBEDisplay_DRIVER_V%d.%d.%d",
diff --git a/include/media/davinci/davinci_display.h
b/include/media/davinci/davinci_display.h
index 8d9a95d..710eef2 100644
--- a/include/media/davinci/davinci_display.h
+++ b/include/media/davinci/davinci_display.h
@@ -25,7 +25,8 @@
/* Header files */
#include <linux/videodev.h>
#include <linux/videodev2.h>
-#include <media/video-buf.h>
+#include <media/videobuf-dma-contig.h>
+#include <media/v4l2-common.h>
#include <video/davinci_osd.h>
#include <media/davinci/vid_encoder_types.h>
--
1.5.6
_______________________________________________
Davinci-linux-open-source mailing list
Davinci-linux-open-source@linux.davincidsp.com
http://linux.davincidsp.com/mailman/listinfo/davinci-linux-open-source
