system/linux
system/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux synced 2024-09-25 14:01:32 +00:00
Code Issues Packages Projects Releases Wiki Activity
linux/drivers/media/video/cafe_ccic.c
Daniel Drake ea7c681e89 [media] cafe_ccic: fix colorspace corruption on resume 
If you suspend and resume during video capture, the video colours
are corrupted on resume. This is because the sensor is being unconditionally
powered off during the resume path.

Only power down during resume if the camera is not in use, and correctly
reconfigure the sensor during resume.
Fixes http://dev.laptop.org/ticket/10190

Signed-off-by: Daniel Drake <dsd@laptop.org>
Acked-by: Jonathan Corbet <corbet@lwn.net>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>
2010-12-29 08:16:29 -02:00

2265 lines
55 KiB
C
Raw Blame History

/*
* A driver for the CMOS camera controller in the Marvell 88ALP01 "cafe"
* multifunction chip. Currently works with the Omnivision OV7670
* sensor.
*
* The data sheet for this device can be found at:
* http://www.marvell.com/products/pc_connectivity/88alp01/
*
* Copyright 2006 One Laptop Per Child Association, Inc.
* Copyright 2006-7 Jonathan Corbet <corbet@lwn.net>
*
* Written by Jonathan Corbet, corbet@lwn.net.
*
* v4l2_device/v4l2_subdev conversion by:
* Copyright (C) 2009 Hans Verkuil <hverkuil@xs4all.nl>
*
* Note: this conversion is untested! Please contact the linux-media
* mailinglist if you can test this, together with the test results.
*
* This file may be distributed under the terms of the GNU General
* Public License, version 2.
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/dmi.h>
#include <linux/mm.h>
#include <linux/pci.h>
#include <linux/i2c.h>
#include <linux/interrupt.h>
#include <linux/spinlock.h>
#include <linux/videodev2.h>
#include <linux/slab.h>
#include <media/v4l2-device.h>
#include <media/v4l2-ioctl.h>
#include <media/v4l2-chip-ident.h>
#include <linux/device.h>
#include <linux/wait.h>
#include <linux/list.h>
#include <linux/dma-mapping.h>
#include <linux/delay.h>
#include <linux/jiffies.h>
#include <linux/vmalloc.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include "ov7670.h"
#include "cafe_ccic-regs.h"
#define CAFE_VERSION 0x000002
/*
* Parameters.
*/
MODULE_AUTHOR("Jonathan Corbet <corbet@lwn.net>");
MODULE_DESCRIPTION("Marvell 88ALP01 CMOS Camera Controller driver");
MODULE_LICENSE("GPL");
MODULE_SUPPORTED_DEVICE("Video");
/*
* Internal DMA buffer management. Since the controller cannot do S/G I/O,
* we must have physically contiguous buffers to bring frames into.
* These parameters control how many buffers we use, whether we
* allocate them at load time (better chance of success, but nails down
* memory) or when somebody tries to use the camera (riskier), and,
* for load-time allocation, how big they should be.
*
* The controller can cycle through three buffers. We could use
* more by flipping pointers around, but it probably makes little
* sense.
*/
#define MAX_DMA_BUFS 3
static int alloc_bufs_at_read;
module_param(alloc_bufs_at_read, bool, 0444);
MODULE_PARM_DESC(alloc_bufs_at_read,
"Non-zero value causes DMA buffers to be allocated when the "
"video capture device is read, rather than at module load "
"time. This saves memory, but decreases the chances of "
"successfully getting those buffers.");
static int n_dma_bufs = 3;
module_param(n_dma_bufs, uint, 0644);
MODULE_PARM_DESC(n_dma_bufs,
"The number of DMA buffers to allocate. Can be either two "
"(saves memory, makes timing tighter) or three.");
static int dma_buf_size = VGA_WIDTH * VGA_HEIGHT * 2; /* Worst case */
module_param(dma_buf_size, uint, 0444);
MODULE_PARM_DESC(dma_buf_size,
"The size of the allocated DMA buffers. If actual operating "
"parameters require larger buffers, an attempt to reallocate "
"will be made.");
static int min_buffers = 1;
module_param(min_buffers, uint, 0644);
MODULE_PARM_DESC(min_buffers,
"The minimum number of streaming I/O buffers we are willing "
"to work with.");
static int max_buffers = 10;
module_param(max_buffers, uint, 0644);
MODULE_PARM_DESC(max_buffers,
"The maximum number of streaming I/O buffers an application "
"will be allowed to allocate. These buffers are big and live "
"in vmalloc space.");
static int flip;
module_param(flip, bool, 0444);
MODULE_PARM_DESC(flip,
"If set, the sensor will be instructed to flip the image "
"vertically.");
enum cafe_state {
S_NOTREADY, /* Not yet initialized */
S_IDLE, /* Just hanging around */
S_FLAKED, /* Some sort of problem */
S_SINGLEREAD, /* In read() */
S_SPECREAD, /* Speculative read (for future read()) */
S_STREAMING /* Streaming data */
};
/*
* Tracking of streaming I/O buffers.
*/
struct cafe_sio_buffer {
struct list_head list;
struct v4l2_buffer v4lbuf;
char *buffer; /* Where it lives in kernel space */
int mapcount;
struct cafe_camera *cam;
};
/*
* A description of one of our devices.
* Locking: controlled by s_mutex. Certain fields, however, require
* the dev_lock spinlock; they are marked as such by comments.
* dev_lock is also required for access to device registers.
*/
struct cafe_camera
{
struct v4l2_device v4l2_dev;
enum cafe_state state;
unsigned long flags; /* Buffer status, mainly (dev_lock) */
int users; /* How many open FDs */
struct file *owner; /* Who has data access (v4l2) */
/*
* Subsystem structures.
*/
struct pci_dev *pdev;
struct video_device vdev;
struct i2c_adapter i2c_adapter;
struct v4l2_subdev *sensor;
unsigned short sensor_addr;
unsigned char __iomem *regs;
struct list_head dev_list; /* link to other devices */
/* DMA buffers */
unsigned int nbufs; /* How many are alloc'd */
int next_buf; /* Next to consume (dev_lock) */
unsigned int dma_buf_size; /* allocated size */
void *dma_bufs[MAX_DMA_BUFS]; /* Internal buffer addresses */
dma_addr_t dma_handles[MAX_DMA_BUFS]; /* Buffer bus addresses */
unsigned int specframes; /* Unconsumed spec frames (dev_lock) */
unsigned int sequence; /* Frame sequence number */
unsigned int buf_seq[MAX_DMA_BUFS]; /* Sequence for individual buffers */
/* Streaming buffers */
unsigned int n_sbufs; /* How many we have */
struct cafe_sio_buffer *sb_bufs; /* The array of housekeeping structs */
struct list_head sb_avail; /* Available for data (we own) (dev_lock) */
struct list_head sb_full; /* With data (user space owns) (dev_lock) */
struct tasklet_struct s_tasklet;
/* Current operating parameters */
u32 sensor_type; /* Currently ov7670 only */
struct v4l2_pix_format pix_format;
enum v4l2_mbus_pixelcode mbus_code;
/* Locks */
struct mutex s_mutex; /* Access to this structure */
spinlock_t dev_lock; /* Access to device */
/* Misc */
wait_queue_head_t smbus_wait; /* Waiting on i2c events */
wait_queue_head_t iowait; /* Waiting on frame data */
};
/*
* Status flags. Always manipulated with bit operations.
*/
#define CF_BUF0_VALID 0 /* Buffers valid - first three */
#define CF_BUF1_VALID 1
#define CF_BUF2_VALID 2
#define CF_DMA_ACTIVE 3 /* A frame is incoming */
#define CF_CONFIG_NEEDED 4 /* Must configure hardware */
#define sensor_call(cam, o, f, args...) \
v4l2_subdev_call(cam->sensor, o, f, ##args)
static inline struct cafe_camera *to_cam(struct v4l2_device *dev)
{
return container_of(dev, struct cafe_camera, v4l2_dev);
}
static struct cafe_format_struct {
__u8 *desc;
__u32 pixelformat;
int bpp; /* Bytes per pixel */
enum v4l2_mbus_pixelcode mbus_code;
} cafe_formats[] = {
{
.desc = "YUYV 4:2:2",
.pixelformat = V4L2_PIX_FMT_YUYV,
.mbus_code = V4L2_MBUS_FMT_YUYV8_2X8,
.bpp = 2,
},
{
.desc = "RGB 444",
.pixelformat = V4L2_PIX_FMT_RGB444,
.mbus_code = V4L2_MBUS_FMT_RGB444_2X8_PADHI_LE,
.bpp = 2,
},
{
.desc = "RGB 565",
.pixelformat = V4L2_PIX_FMT_RGB565,
.mbus_code = V4L2_MBUS_FMT_RGB565_2X8_LE,
.bpp = 2,
},
{
.desc = "Raw RGB Bayer",
.pixelformat = V4L2_PIX_FMT_SBGGR8,
.mbus_code = V4L2_MBUS_FMT_SBGGR8_1X8,
.bpp = 1
},
};
#define N_CAFE_FMTS ARRAY_SIZE(cafe_formats)
static struct cafe_format_struct *cafe_find_format(u32 pixelformat)
{
unsigned i;
for (i = 0; i < N_CAFE_FMTS; i++)
if (cafe_formats[i].pixelformat == pixelformat)
return cafe_formats + i;
/* Not found? Then return the first format. */
return cafe_formats;
}
/*
* Start over with DMA buffers - dev_lock needed.
*/
static void cafe_reset_buffers(struct cafe_camera *cam)
{
int i;
cam->next_buf = -1;
for (i = 0; i < cam->nbufs; i++)
clear_bit(i, &cam->flags);
cam->specframes = 0;
}
static inline int cafe_needs_config(struct cafe_camera *cam)
{
return test_bit(CF_CONFIG_NEEDED, &cam->flags);
}
static void cafe_set_config_needed(struct cafe_camera *cam, int needed)
{
if (needed)
set_bit(CF_CONFIG_NEEDED, &cam->flags);
else
clear_bit(CF_CONFIG_NEEDED, &cam->flags);
}
/*
* Debugging and related.
*/
#define cam_err(cam, fmt, arg...) \
dev_err(&(cam)->pdev->dev, fmt, ##arg);
#define cam_warn(cam, fmt, arg...) \
dev_warn(&(cam)->pdev->dev, fmt, ##arg);
#define cam_dbg(cam, fmt, arg...) \
dev_dbg(&(cam)->pdev->dev, fmt, ##arg);
/* ---------------------------------------------------------------------*/
/*
* Device register I/O
*/
static inline void cafe_reg_write(struct cafe_camera *cam, unsigned int reg,
unsigned int val)
{
iowrite32(val, cam->regs + reg);
}
static inline unsigned int cafe_reg_read(struct cafe_camera *cam,
unsigned int reg)
{
return ioread32(cam->regs + reg);
}
static inline void cafe_reg_write_mask(struct cafe_camera *cam, unsigned int reg,
unsigned int val, unsigned int mask)
{
unsigned int v = cafe_reg_read(cam, reg);
v = (v & ~mask) | (val & mask);
cafe_reg_write(cam, reg, v);
}
static inline void cafe_reg_clear_bit(struct cafe_camera *cam,
unsigned int reg, unsigned int val)
{
cafe_reg_write_mask(cam, reg, 0, val);
}
static inline void cafe_reg_set_bit(struct cafe_camera *cam,
unsigned int reg, unsigned int val)
{
cafe_reg_write_mask(cam, reg, val, val);
}
/* -------------------------------------------------------------------- */
/*
* The I2C/SMBUS interface to the camera itself starts here. The
* controller handles SMBUS itself, presenting a relatively simple register
* interface; all we have to do is to tell it where to route the data.
*/
#define CAFE_SMBUS_TIMEOUT (HZ) /* generous */
static int cafe_smbus_write_done(struct cafe_camera *cam)
{
unsigned long flags;
int c1;
/*
* We must delay after the interrupt, or the controller gets confused
* and never does give us good status. Fortunately, we don't do this
* often.
*/
udelay(20);
spin_lock_irqsave(&cam->dev_lock, flags);
c1 = cafe_reg_read(cam, REG_TWSIC1);
spin_unlock_irqrestore(&cam->dev_lock, flags);
return (c1 & (TWSIC1_WSTAT|TWSIC1_ERROR)) != TWSIC1_WSTAT;
}
static int cafe_smbus_write_data(struct cafe_camera *cam,
u16 addr, u8 command, u8 value)
{
unsigned int rval;
unsigned long flags;
spin_lock_irqsave(&cam->dev_lock, flags);
rval = TWSIC0_EN | ((addr << TWSIC0_SID_SHIFT) & TWSIC0_SID);
rval |= TWSIC0_OVMAGIC; /* Make OV sensors work */
/*
* Marvell sez set clkdiv to all 1's for now.
*/
rval |= TWSIC0_CLKDIV;
cafe_reg_write(cam, REG_TWSIC0, rval);
(void) cafe_reg_read(cam, REG_TWSIC1); /* force write */
rval = value | ((command << TWSIC1_ADDR_SHIFT) & TWSIC1_ADDR);
cafe_reg_write(cam, REG_TWSIC1, rval);
spin_unlock_irqrestore(&cam->dev_lock, flags);
/* Unfortunately, reading TWSIC1 too soon after sending a command
* causes the device to die.
* Use a busy-wait because we often send a large quantity of small
* commands at-once; using msleep() would cause a lot of context
* switches which take longer than 2ms, resulting in a noticable
* boot-time and capture-start delays.
*/
mdelay(2);
/*
* Another sad fact is that sometimes, commands silently complete but
* cafe_smbus_write_done() never becomes aware of this.
* This happens at random and appears to possible occur with any
* command.
* We don't understand why this is. We work around this issue
* with the timeout in the wait below, assuming that all commands
* complete within the timeout.
*/
wait_event_timeout(cam->smbus_wait, cafe_smbus_write_done(cam),
CAFE_SMBUS_TIMEOUT);
spin_lock_irqsave(&cam->dev_lock, flags);
rval = cafe_reg_read(cam, REG_TWSIC1);
spin_unlock_irqrestore(&cam->dev_lock, flags);
if (rval & TWSIC1_WSTAT) {
cam_err(cam, "SMBUS write (%02x/%02x/%02x) timed out\n", addr,
command, value);
return -EIO;
}
if (rval & TWSIC1_ERROR) {
cam_err(cam, "SMBUS write (%02x/%02x/%02x) error\n", addr,
command, value);
return -EIO;
}
return 0;
}
static int cafe_smbus_read_done(struct cafe_camera *cam)
{
unsigned long flags;
int c1;
/*
* We must delay after the interrupt, or the controller gets confused
* and never does give us good status. Fortunately, we don't do this
* often.
*/
udelay(20);
spin_lock_irqsave(&cam->dev_lock, flags);
c1 = cafe_reg_read(cam, REG_TWSIC1);
spin_unlock_irqrestore(&cam->dev_lock, flags);
return c1 & (TWSIC1_RVALID|TWSIC1_ERROR);
}
static int cafe_smbus_read_data(struct cafe_camera *cam,
u16 addr, u8 command, u8 *value)
{
unsigned int rval;
unsigned long flags;
spin_lock_irqsave(&cam->dev_lock, flags);
rval = TWSIC0_EN | ((addr << TWSIC0_SID_SHIFT) & TWSIC0_SID);
rval |= TWSIC0_OVMAGIC; /* Make OV sensors work */
/*
* Marvel sez set clkdiv to all 1's for now.
*/
rval |= TWSIC0_CLKDIV;
cafe_reg_write(cam, REG_TWSIC0, rval);
(void) cafe_reg_read(cam, REG_TWSIC1); /* force write */
rval = TWSIC1_READ | ((command << TWSIC1_ADDR_SHIFT) & TWSIC1_ADDR);
cafe_reg_write(cam, REG_TWSIC1, rval);
spin_unlock_irqrestore(&cam->dev_lock, flags);
wait_event_timeout(cam->smbus_wait,
cafe_smbus_read_done(cam), CAFE_SMBUS_TIMEOUT);
spin_lock_irqsave(&cam->dev_lock, flags);
rval = cafe_reg_read(cam, REG_TWSIC1);
spin_unlock_irqrestore(&cam->dev_lock, flags);
if (rval & TWSIC1_ERROR) {
cam_err(cam, "SMBUS read (%02x/%02x) error\n", addr, command);
return -EIO;
}
if (! (rval & TWSIC1_RVALID)) {
cam_err(cam, "SMBUS read (%02x/%02x) timed out\n", addr,
command);
return -EIO;
}
*value = rval & 0xff;
return 0;
}
/*
* Perform a transfer over SMBUS. This thing is called under
* the i2c bus lock, so we shouldn't race with ourselves...
*/
static int cafe_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
unsigned short flags, char rw, u8 command,
int size, union i2c_smbus_data *data)
{
struct v4l2_device *v4l2_dev = i2c_get_adapdata(adapter);
struct cafe_camera *cam = to_cam(v4l2_dev);
int ret = -EINVAL;
/*
* This interface would appear to only do byte data ops. OK
* it can do word too, but the cam chip has no use for that.
*/
if (size != I2C_SMBUS_BYTE_DATA) {
cam_err(cam, "funky xfer size %d\n", size);
return -EINVAL;
}
if (rw == I2C_SMBUS_WRITE)
ret = cafe_smbus_write_data(cam, addr, command, data->byte);
else if (rw == I2C_SMBUS_READ)
ret = cafe_smbus_read_data(cam, addr, command, &data->byte);
return ret;
}
static void cafe_smbus_enable_irq(struct cafe_camera *cam)
{
unsigned long flags;
spin_lock_irqsave(&cam->dev_lock, flags);
cafe_reg_set_bit(cam, REG_IRQMASK, TWSIIRQS);
spin_unlock_irqrestore(&cam->dev_lock, flags);
}
static u32 cafe_smbus_func(struct i2c_adapter *adapter)
{
return I2C_FUNC_SMBUS_READ_BYTE_DATA |
I2C_FUNC_SMBUS_WRITE_BYTE_DATA;
}
static struct i2c_algorithm cafe_smbus_algo = {
.smbus_xfer = cafe_smbus_xfer,
.functionality = cafe_smbus_func
};
/* Somebody is on the bus */
static void cafe_ctlr_stop_dma(struct cafe_camera *cam);
static void cafe_ctlr_power_down(struct cafe_camera *cam);
static int cafe_smbus_setup(struct cafe_camera *cam)
{
struct i2c_adapter *adap = &cam->i2c_adapter;
int ret;
cafe_smbus_enable_irq(cam);
adap->owner = THIS_MODULE;
adap->algo = &cafe_smbus_algo;
strcpy(adap->name, "cafe_ccic");
adap->dev.parent = &cam->pdev->dev;
i2c_set_adapdata(adap, &cam->v4l2_dev);
ret = i2c_add_adapter(adap);
if (ret)
printk(KERN_ERR "Unable to register cafe i2c adapter\n");
return ret;
}
static void cafe_smbus_shutdown(struct cafe_camera *cam)
{
i2c_del_adapter(&cam->i2c_adapter);
}
/* ------------------------------------------------------------------- */
/*
* Deal with the controller.
*/
/*
* Do everything we think we need to have the interface operating
* according to the desired format.
*/
static void cafe_ctlr_dma(struct cafe_camera *cam)
{
/*
* Store the first two Y buffers (we aren't supporting
* planar formats for now, so no UV bufs). Then either
* set the third if it exists, or tell the controller
* to just use two.
*/
cafe_reg_write(cam, REG_Y0BAR, cam->dma_handles[0]);
cafe_reg_write(cam, REG_Y1BAR, cam->dma_handles[1]);
if (cam->nbufs > 2) {
cafe_reg_write(cam, REG_Y2BAR, cam->dma_handles[2]);
cafe_reg_clear_bit(cam, REG_CTRL1, C1_TWOBUFS);
}
else
cafe_reg_set_bit(cam, REG_CTRL1, C1_TWOBUFS);
cafe_reg_write(cam, REG_UBAR, 0); /* 32 bits only for now */
}
static void cafe_ctlr_image(struct cafe_camera *cam)
{
int imgsz;
struct v4l2_pix_format *fmt = &cam->pix_format;
imgsz = ((fmt->height << IMGSZ_V_SHIFT) & IMGSZ_V_MASK) |
(fmt->bytesperline & IMGSZ_H_MASK);
cafe_reg_write(cam, REG_IMGSIZE, imgsz);
cafe_reg_write(cam, REG_IMGOFFSET, 0);
/* YPITCH just drops the last two bits */
cafe_reg_write_mask(cam, REG_IMGPITCH, fmt->bytesperline,
IMGP_YP_MASK);
/*
* Tell the controller about the image format we are using.
*/
switch (cam->pix_format.pixelformat) {
case V4L2_PIX_FMT_YUYV:
cafe_reg_write_mask(cam, REG_CTRL0,
C0_DF_YUV|C0_YUV_PACKED|C0_YUVE_YUYV,
C0_DF_MASK);
break;
case V4L2_PIX_FMT_RGB444:
cafe_reg_write_mask(cam, REG_CTRL0,
C0_DF_RGB|C0_RGBF_444|C0_RGB4_XRGB,
C0_DF_MASK);
/* Alpha value? */
break;
case V4L2_PIX_FMT_RGB565:
cafe_reg_write_mask(cam, REG_CTRL0,
C0_DF_RGB|C0_RGBF_565|C0_RGB5_BGGR,
C0_DF_MASK);
break;
default:
cam_err(cam, "Unknown format %x\n", cam->pix_format.pixelformat);
break;
}
/*
* Make sure it knows we want to use hsync/vsync.
*/
cafe_reg_write_mask(cam, REG_CTRL0, C0_SIF_HVSYNC,
C0_SIFM_MASK);
}
/*
* Configure the controller for operation; caller holds the
* device mutex.
*/
static int cafe_ctlr_configure(struct cafe_camera *cam)
{
unsigned long flags;
spin_lock_irqsave(&cam->dev_lock, flags);
cafe_ctlr_dma(cam);
cafe_ctlr_image(cam);
cafe_set_config_needed(cam, 0);
spin_unlock_irqrestore(&cam->dev_lock, flags);
return 0;
}
static void cafe_ctlr_irq_enable(struct cafe_camera *cam)
{
/*
* Clear any pending interrupts, since we do not
* expect to have I/O active prior to enabling.
*/
cafe_reg_write(cam, REG_IRQSTAT, FRAMEIRQS);
cafe_reg_set_bit(cam, REG_IRQMASK, FRAMEIRQS);
}
static void cafe_ctlr_irq_disable(struct cafe_camera *cam)
{
cafe_reg_clear_bit(cam, REG_IRQMASK, FRAMEIRQS);
}
/*
* Make the controller start grabbing images. Everything must
* be set up before doing this.
*/
static void cafe_ctlr_start(struct cafe_camera *cam)
{
/* set_bit performs a read, so no other barrier should be
needed here */
cafe_reg_set_bit(cam, REG_CTRL0, C0_ENABLE);
}
static void cafe_ctlr_stop(struct cafe_camera *cam)
{
cafe_reg_clear_bit(cam, REG_CTRL0, C0_ENABLE);
}
static void cafe_ctlr_init(struct cafe_camera *cam)
{
unsigned long flags;
spin_lock_irqsave(&cam->dev_lock, flags);
/*
* Added magic to bring up the hardware on the B-Test board
*/
cafe_reg_write(cam, 0x3038, 0x8);
cafe_reg_write(cam, 0x315c, 0x80008);
/*
* Go through the dance needed to wake the device up.
* Note that these registers are global and shared
* with the NAND and SD devices. Interaction between the
* three still needs to be examined.
*/
cafe_reg_write(cam, REG_GL_CSR, GCSR_SRS|GCSR_MRS); /* Needed? */
cafe_reg_write(cam, REG_GL_CSR, GCSR_SRC|GCSR_MRC);
cafe_reg_write(cam, REG_GL_CSR, GCSR_SRC|GCSR_MRS);
/*
* Here we must wait a bit for the controller to come around.
*/
spin_unlock_irqrestore(&cam->dev_lock, flags);
msleep(5);
spin_lock_irqsave(&cam->dev_lock, flags);
cafe_reg_write(cam, REG_GL_CSR, GCSR_CCIC_EN|GCSR_SRC|GCSR_MRC);
cafe_reg_set_bit(cam, REG_GL_IMASK, GIMSK_CCIC_EN);
/*
* Make sure it's not powered down.
*/
cafe_reg_clear_bit(cam, REG_CTRL1, C1_PWRDWN);
/*
* Turn off the enable bit. It sure should be off anyway,
* but it's good to be sure.
*/
cafe_reg_clear_bit(cam, REG_CTRL0, C0_ENABLE);
/*
* Mask all interrupts.
*/
cafe_reg_write(cam, REG_IRQMASK, 0);
/*
* Clock the sensor appropriately. Controller clock should
* be 48MHz, sensor "typical" value is half that.
*/
cafe_reg_write_mask(cam, REG_CLKCTRL, 2, CLK_DIV_MASK);
spin_unlock_irqrestore(&cam->dev_lock, flags);
}
/*
* Stop the controller, and don't return until we're really sure that no
* further DMA is going on.
*/
static void cafe_ctlr_stop_dma(struct cafe_camera *cam)
{
unsigned long flags;
/*
* Theory: stop the camera controller (whether it is operating
* or not). Delay briefly just in case we race with the SOF
* interrupt, then wait until no DMA is active.
*/
spin_lock_irqsave(&cam->dev_lock, flags);
cafe_ctlr_stop(cam);
spin_unlock_irqrestore(&cam->dev_lock, flags);
mdelay(1);
wait_event_timeout(cam->iowait,
!test_bit(CF_DMA_ACTIVE, &cam->flags), HZ);
if (test_bit(CF_DMA_ACTIVE, &cam->flags))
cam_err(cam, "Timeout waiting for DMA to end\n");
/* This would be bad news - what now? */
spin_lock_irqsave(&cam->dev_lock, flags);
cam->state = S_IDLE;
cafe_ctlr_irq_disable(cam);
spin_unlock_irqrestore(&cam->dev_lock, flags);
}
/*
* Power up and down.
*/
static void cafe_ctlr_power_up(struct cafe_camera *cam)
{
unsigned long flags;
spin_lock_irqsave(&cam->dev_lock, flags);
cafe_reg_clear_bit(cam, REG_CTRL1, C1_PWRDWN);
/*
* Part one of the sensor dance: turn the global
* GPIO signal on.
*/
cafe_reg_write(cam, REG_GL_FCR, GFCR_GPIO_ON);
cafe_reg_write(cam, REG_GL_GPIOR, GGPIO_OUT|GGPIO_VAL);
/*
* Put the sensor into operational mode (assumes OLPC-style
* wiring). Control 0 is reset - set to 1 to operate.
* Control 1 is power down, set to 0 to operate.
*/
cafe_reg_write(cam, REG_GPR, GPR_C1EN|GPR_C0EN); /* pwr up, reset */
/* mdelay(1); */ /* Marvell says 1ms will do it */
cafe_reg_write(cam, REG_GPR, GPR_C1EN|GPR_C0EN|GPR_C0);
/* mdelay(1); */ /* Enough? */
spin_unlock_irqrestore(&cam->dev_lock, flags);
msleep(5); /* Just to be sure */
}
static void cafe_ctlr_power_down(struct cafe_camera *cam)
{
unsigned long flags;
spin_lock_irqsave(&cam->dev_lock, flags);
cafe_reg_write(cam, REG_GPR, GPR_C1EN|GPR_C0EN|GPR_C1);
cafe_reg_write(cam, REG_GL_FCR, GFCR_GPIO_ON);
cafe_reg_write(cam, REG_GL_GPIOR, GGPIO_OUT);
cafe_reg_set_bit(cam, REG_CTRL1, C1_PWRDWN);
spin_unlock_irqrestore(&cam->dev_lock, flags);
}
/* -------------------------------------------------------------------- */
/*
* Communications with the sensor.
*/
static int __cafe_cam_reset(struct cafe_camera *cam)
{
return sensor_call(cam, core, reset, 0);
}
/*
* We have found the sensor on the i2c. Let's try to have a
* conversation.
*/
static int cafe_cam_init(struct cafe_camera *cam)
{
struct v4l2_dbg_chip_ident chip;
int ret;
mutex_lock(&cam->s_mutex);
if (cam->state != S_NOTREADY)
cam_warn(cam, "Cam init with device in funky state %d",
cam->state);
ret = __cafe_cam_reset(cam);
if (ret)
goto out;
chip.ident = V4L2_IDENT_NONE;
chip.match.type = V4L2_CHIP_MATCH_I2C_ADDR;
chip.match.addr = cam->sensor_addr;
ret = sensor_call(cam, core, g_chip_ident, &chip);
if (ret)
goto out;
cam->sensor_type = chip.ident;
if (cam->sensor_type != V4L2_IDENT_OV7670) {
cam_err(cam, "Unsupported sensor type 0x%x", cam->sensor_type);
ret = -EINVAL;
goto out;
}
/* Get/set parameters? */
ret = 0;
cam->state = S_IDLE;
out:
cafe_ctlr_power_down(cam);
mutex_unlock(&cam->s_mutex);
return ret;
}
/*
* Configure the sensor to match the parameters we have. Caller should
* hold s_mutex
*/
static int cafe_cam_set_flip(struct cafe_camera *cam)
{
struct v4l2_control ctrl;
memset(&ctrl, 0, sizeof(ctrl));
ctrl.id = V4L2_CID_VFLIP;
ctrl.value = flip;
return sensor_call(cam, core, s_ctrl, &ctrl);
}
static int cafe_cam_configure(struct cafe_camera *cam)
{
struct v4l2_mbus_framefmt mbus_fmt;
int ret;
v4l2_fill_mbus_format(&mbus_fmt, &cam->pix_format, cam->mbus_code);
ret = sensor_call(cam, core, init, 0);
if (ret == 0)
ret = sensor_call(cam, video, s_mbus_fmt, &mbus_fmt);
/*
* OV7670 does weird things if flip is set *before* format...
*/
ret += cafe_cam_set_flip(cam);
return ret;
}
/* -------------------------------------------------------------------- */
/*
* DMA buffer management. These functions need s_mutex held.
*/
/* FIXME: this is inefficient as hell, since dma_alloc_coherent just
* does a get_free_pages() call, and we waste a good chunk of an orderN
* allocation. Should try to allocate the whole set in one chunk.
*/
static int cafe_alloc_dma_bufs(struct cafe_camera *cam, int loadtime)
{
int i;
cafe_set_config_needed(cam, 1);
if (loadtime)
cam->dma_buf_size = dma_buf_size;
else
cam->dma_buf_size = cam->pix_format.sizeimage;
if (n_dma_bufs > 3)
n_dma_bufs = 3;
cam->nbufs = 0;
for (i = 0; i < n_dma_bufs; i++) {
cam->dma_bufs[i] = dma_alloc_coherent(&cam->pdev->dev,
cam->dma_buf_size, cam->dma_handles + i,
GFP_KERNEL);
if (cam->dma_bufs[i] == NULL) {
cam_warn(cam, "Failed to allocate DMA buffer\n");
break;
}
/* For debug, remove eventually */
memset(cam->dma_bufs[i], 0xcc, cam->dma_buf_size);
(cam->nbufs)++;
}
switch (cam->nbufs) {
case 1:
dma_free_coherent(&cam->pdev->dev, cam->dma_buf_size,
cam->dma_bufs[0], cam->dma_handles[0]);
cam->nbufs = 0;
case 0:
cam_err(cam, "Insufficient DMA buffers, cannot operate\n");
return -ENOMEM;
case 2:
if (n_dma_bufs > 2)
cam_warn(cam, "Will limp along with only 2 buffers\n");
break;
}
return 0;
}
static void cafe_free_dma_bufs(struct cafe_camera *cam)
{
int i;
for (i = 0; i < cam->nbufs; i++) {
dma_free_coherent(&cam->pdev->dev, cam->dma_buf_size,
cam->dma_bufs[i], cam->dma_handles[i]);
cam->dma_bufs[i] = NULL;
}
cam->nbufs = 0;
}
/* ----------------------------------------------------------------------- */
/*
* Here starts the V4L2 interface code.
*/
/*
* Read an image from the device.
*/
static ssize_t cafe_deliver_buffer(struct cafe_camera *cam,
char __user *buffer, size_t len, loff_t *pos)
{
int bufno;
unsigned long flags;
spin_lock_irqsave(&cam->dev_lock, flags);
if (cam->next_buf < 0) {
cam_err(cam, "deliver_buffer: No next buffer\n");
spin_unlock_irqrestore(&cam->dev_lock, flags);
return -EIO;
}
bufno = cam->next_buf;
clear_bit(bufno, &cam->flags);
if (++(cam->next_buf) >= cam->nbufs)
cam->next_buf = 0;
if (! test_bit(cam->next_buf, &cam->flags))
cam->next_buf = -1;
cam->specframes = 0;
spin_unlock_irqrestore(&cam->dev_lock, flags);
if (len > cam->pix_format.sizeimage)
len = cam->pix_format.sizeimage;
if (copy_to_user(buffer, cam->dma_bufs[bufno], len))
return -EFAULT;
(*pos) += len;
return len;
}
/*
* Get everything ready, and start grabbing frames.
*/
static int cafe_read_setup(struct cafe_camera *cam, enum cafe_state state)
{
int ret;
unsigned long flags;
/*
* Configuration. If we still don't have DMA buffers,
* make one last, desperate attempt.
*/
if (cam->nbufs == 0)
if (cafe_alloc_dma_bufs(cam, 0))
return -ENOMEM;
if (cafe_needs_config(cam)) {
cafe_cam_configure(cam);
ret = cafe_ctlr_configure(cam);
if (ret)
return ret;
}
/*
* Turn it loose.
*/
spin_lock_irqsave(&cam->dev_lock, flags);
cafe_reset_buffers(cam);
cafe_ctlr_irq_enable(cam);
cam->state = state;
cafe_ctlr_start(cam);
spin_unlock_irqrestore(&cam->dev_lock, flags);
return 0;
}
static ssize_t cafe_v4l_read(struct file *filp,
char __user *buffer, size_t len, loff_t *pos)
{
struct cafe_camera *cam = filp->private_data;
int ret = 0;
/*
* Perhaps we're in speculative read mode and already
* have data?
*/
mutex_lock(&cam->s_mutex);
if (cam->state == S_SPECREAD) {
if (cam->next_buf >= 0) {
ret = cafe_deliver_buffer(cam, buffer, len, pos);
if (ret != 0)
goto out_unlock;
}
} else if (cam->state == S_FLAKED || cam->state == S_NOTREADY) {
ret = -EIO;
goto out_unlock;
} else if (cam->state != S_IDLE) {
ret = -EBUSY;
goto out_unlock;
}
/*
* v4l2: multiple processes can open the device, but only
* one gets to grab data from it.
*/
if (cam->owner && cam->owner != filp) {
ret = -EBUSY;
goto out_unlock;
}
cam->owner = filp;
/*
* Do setup if need be.
*/
if (cam->state != S_SPECREAD) {
ret = cafe_read_setup(cam, S_SINGLEREAD);
if (ret)
goto out_unlock;
}
/*
* Wait for something to happen. This should probably
* be interruptible (FIXME).
*/
wait_event_timeout(cam->iowait, cam->next_buf >= 0, HZ);
if (cam->next_buf < 0) {
cam_err(cam, "read() operation timed out\n");
cafe_ctlr_stop_dma(cam);
ret = -EIO;
goto out_unlock;
}
/*
* Give them their data and we should be done.
*/
ret = cafe_deliver_buffer(cam, buffer, len, pos);
out_unlock:
mutex_unlock(&cam->s_mutex);
return ret;
}
/*
* Streaming I/O support.
*/
static int cafe_vidioc_streamon(struct file *filp, void *priv,
enum v4l2_buf_type type)
{
struct cafe_camera *cam = filp->private_data;
int ret = -EINVAL;
if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
goto out;
mutex_lock(&cam->s_mutex);
if (cam->state != S_IDLE || cam->n_sbufs == 0)
goto out_unlock;
cam->sequence = 0;
ret = cafe_read_setup(cam, S_STREAMING);
out_unlock:
mutex_unlock(&cam->s_mutex);
out:
return ret;
}
static int cafe_vidioc_streamoff(struct file *filp, void *priv,
enum v4l2_buf_type type)
{
struct cafe_camera *cam = filp->private_data;
int ret = -EINVAL;
if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
goto out;
mutex_lock(&cam->s_mutex);
if (cam->state != S_STREAMING)
goto out_unlock;
cafe_ctlr_stop_dma(cam);
ret = 0;
out_unlock:
mutex_unlock(&cam->s_mutex);
out:
return ret;
}
static int cafe_setup_siobuf(struct cafe_camera *cam, int index)
{
struct cafe_sio_buffer *buf = cam->sb_bufs + index;
INIT_LIST_HEAD(&buf->list);
buf->v4lbuf.length = PAGE_ALIGN(cam->pix_format.sizeimage);
buf->buffer = vmalloc_user(buf->v4lbuf.length);
if (buf->buffer == NULL)
return -ENOMEM;
buf->mapcount = 0;
buf->cam = cam;
buf->v4lbuf.index = index;
buf->v4lbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf->v4lbuf.field = V4L2_FIELD_NONE;
buf->v4lbuf.memory = V4L2_MEMORY_MMAP;
/*
* Offset: must be 32-bit even on a 64-bit system. videobuf-dma-sg
* just uses the length times the index, but the spec warns
* against doing just that - vma merging problems. So we
* leave a gap between each pair of buffers.
*/
buf->v4lbuf.m.offset = 2*index*buf->v4lbuf.length;
return 0;
}
static int cafe_free_sio_buffers(struct cafe_camera *cam)
{
int i;
/*
* If any buffers are mapped, we cannot free them at all.
*/
for (i = 0; i < cam->n_sbufs; i++)
if (cam->sb_bufs[i].mapcount > 0)
return -EBUSY;
/*
* OK, let's do it.
*/
for (i = 0; i < cam->n_sbufs; i++)
vfree(cam->sb_bufs[i].buffer);
cam->n_sbufs = 0;
kfree(cam->sb_bufs);
cam->sb_bufs = NULL;
INIT_LIST_HEAD(&cam->sb_avail);
INIT_LIST_HEAD(&cam->sb_full);
return 0;
}
static int cafe_vidioc_reqbufs(struct file *filp, void *priv,
struct v4l2_requestbuffers *req)
{
struct cafe_camera *cam = filp->private_data;
int ret = 0; /* Silence warning */
/*
* Make sure it's something we can do. User pointers could be
* implemented without great pain, but that's not been done yet.
*/
if (req->memory != V4L2_MEMORY_MMAP)
return -EINVAL;
/*
* If they ask for zero buffers, they really want us to stop streaming
* (if it's happening) and free everything. Should we check owner?
*/
mutex_lock(&cam->s_mutex);
if (req->count == 0) {
if (cam->state == S_STREAMING)
cafe_ctlr_stop_dma(cam);
ret = cafe_free_sio_buffers (cam);
goto out;
}
/*
* Device needs to be idle and working. We *could* try to do the
* right thing in S_SPECREAD by shutting things down, but it
* probably doesn't matter.
*/
if (cam->state != S_IDLE || (cam->owner && cam->owner != filp)) {
ret = -EBUSY;
goto out;
}
cam->owner = filp;
if (req->count < min_buffers)
req->count = min_buffers;
else if (req->count > max_buffers)
req->count = max_buffers;
if (cam->n_sbufs > 0) {
ret = cafe_free_sio_buffers(cam);
if (ret)
goto out;
}
cam->sb_bufs = kzalloc(req->count*sizeof(struct cafe_sio_buffer),
GFP_KERNEL);
if (cam->sb_bufs == NULL) {
ret = -ENOMEM;
goto out;
}
for (cam->n_sbufs = 0; cam->n_sbufs < req->count; (cam->n_sbufs++)) {
ret = cafe_setup_siobuf(cam, cam->n_sbufs);
if (ret)
break;
}
if (cam->n_sbufs == 0) /* no luck at all - ret already set */
kfree(cam->sb_bufs);
req->count = cam->n_sbufs; /* In case of partial success */
out:
mutex_unlock(&cam->s_mutex);
return ret;
}
static int cafe_vidioc_querybuf(struct file *filp, void *priv,
struct v4l2_buffer *buf)
{
struct cafe_camera *cam = filp->private_data;
int ret = -EINVAL;
mutex_lock(&cam->s_mutex);
if (buf->index >= cam->n_sbufs)
goto out;
*buf = cam->sb_bufs[buf->index].v4lbuf;
ret = 0;
out:
mutex_unlock(&cam->s_mutex);
return ret;
}
static int cafe_vidioc_qbuf(struct file *filp, void *priv,
struct v4l2_buffer *buf)
{
struct cafe_camera *cam = filp->private_data;
struct cafe_sio_buffer *sbuf;
int ret = -EINVAL;
unsigned long flags;
mutex_lock(&cam->s_mutex);
if (buf->index >= cam->n_sbufs)
goto out;
sbuf = cam->sb_bufs + buf->index;
if (sbuf->v4lbuf.flags & V4L2_BUF_FLAG_QUEUED) {
ret = 0; /* Already queued?? */
goto out;
}
if (sbuf->v4lbuf.flags & V4L2_BUF_FLAG_DONE) {
/* Spec doesn't say anything, seems appropriate tho */
ret = -EBUSY;
goto out;
}
sbuf->v4lbuf.flags |= V4L2_BUF_FLAG_QUEUED;
spin_lock_irqsave(&cam->dev_lock, flags);
list_add(&sbuf->list, &cam->sb_avail);
spin_unlock_irqrestore(&cam->dev_lock, flags);
ret = 0;
out:
mutex_unlock(&cam->s_mutex);
return ret;
}
static int cafe_vidioc_dqbuf(struct file *filp, void *priv,
struct v4l2_buffer *buf)
{
struct cafe_camera *cam = filp->private_data;
struct cafe_sio_buffer *sbuf;
int ret = -EINVAL;
unsigned long flags;
mutex_lock(&cam->s_mutex);
if (cam->state != S_STREAMING)
goto out_unlock;
if (list_empty(&cam->sb_full) && filp->f_flags & O_NONBLOCK) {
ret = -EAGAIN;
goto out_unlock;
}
while (list_empty(&cam->sb_full) && cam->state == S_STREAMING) {
mutex_unlock(&cam->s_mutex);
if (wait_event_interruptible(cam->iowait,
!list_empty(&cam->sb_full))) {
ret = -ERESTARTSYS;
goto out;
}
mutex_lock(&cam->s_mutex);
}
if (cam->state != S_STREAMING)
ret = -EINTR;
else {
spin_lock_irqsave(&cam->dev_lock, flags);
/* Should probably recheck !list_empty() here */
sbuf = list_entry(cam->sb_full.next,
struct cafe_sio_buffer, list);
list_del_init(&sbuf->list);
spin_unlock_irqrestore(&cam->dev_lock, flags);
sbuf->v4lbuf.flags &= ~V4L2_BUF_FLAG_DONE;
*buf = sbuf->v4lbuf;
ret = 0;
}
out_unlock:
mutex_unlock(&cam->s_mutex);
out:
return ret;
}
static void cafe_v4l_vm_open(struct vm_area_struct *vma)
{
struct cafe_sio_buffer *sbuf = vma->vm_private_data;
/*
* Locking: done under mmap_sem, so we don't need to
* go back to the camera lock here.
*/
sbuf->mapcount++;
}
static void cafe_v4l_vm_close(struct vm_area_struct *vma)
{
struct cafe_sio_buffer *sbuf = vma->vm_private_data;
mutex_lock(&sbuf->cam->s_mutex);
sbuf->mapcount--;
/* Docs say we should stop I/O too... */
if (sbuf->mapcount == 0)
sbuf->v4lbuf.flags &= ~V4L2_BUF_FLAG_MAPPED;
mutex_unlock(&sbuf->cam->s_mutex);
}
static const struct vm_operations_struct cafe_v4l_vm_ops = {
.open = cafe_v4l_vm_open,
.close = cafe_v4l_vm_close
};
static int cafe_v4l_mmap(struct file *filp, struct vm_area_struct *vma)
{
struct cafe_camera *cam = filp->private_data;
unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
int ret = -EINVAL;
int i;
struct cafe_sio_buffer *sbuf = NULL;
if (! (vma->vm_flags & VM_WRITE) || ! (vma->vm_flags & VM_SHARED))
return -EINVAL;
/*
* Find the buffer they are looking for.
*/
mutex_lock(&cam->s_mutex);
for (i = 0; i < cam->n_sbufs; i++)
if (cam->sb_bufs[i].v4lbuf.m.offset == offset) {
sbuf = cam->sb_bufs + i;
break;
}
if (sbuf == NULL)
goto out;
ret = remap_vmalloc_range(vma, sbuf->buffer, 0);
if (ret)
goto out;
vma->vm_flags |= VM_DONTEXPAND;
vma->vm_private_data = sbuf;
vma->vm_ops = &cafe_v4l_vm_ops;
sbuf->v4lbuf.flags |= V4L2_BUF_FLAG_MAPPED;
cafe_v4l_vm_open(vma);
ret = 0;
out:
mutex_unlock(&cam->s_mutex);
return ret;
}
static int cafe_v4l_open(struct file *filp)
{
struct cafe_camera *cam = video_drvdata(filp);
filp->private_data = cam;
mutex_lock(&cam->s_mutex);
if (cam->users == 0) {
cafe_ctlr_power_up(cam);
__cafe_cam_reset(cam);
cafe_set_config_needed(cam, 1);
/* FIXME make sure this is complete */
}
(cam->users)++;
mutex_unlock(&cam->s_mutex);
return 0;
}
static int cafe_v4l_release(struct file *filp)
{
struct cafe_camera *cam = filp->private_data;
mutex_lock(&cam->s_mutex);
(cam->users)--;
if (filp == cam->owner) {
cafe_ctlr_stop_dma(cam);
cafe_free_sio_buffers(cam);
cam->owner = NULL;
}
if (cam->users == 0) {
cafe_ctlr_power_down(cam);
if (alloc_bufs_at_read)
cafe_free_dma_bufs(cam);
}
mutex_unlock(&cam->s_mutex);
return 0;
}
static unsigned int cafe_v4l_poll(struct file *filp,
struct poll_table_struct *pt)
{
struct cafe_camera *cam = filp->private_data;
poll_wait(filp, &cam->iowait, pt);
if (cam->next_buf >= 0)
return POLLIN | POLLRDNORM;
return 0;
}
static int cafe_vidioc_queryctrl(struct file *filp, void *priv,
struct v4l2_queryctrl *qc)
{
struct cafe_camera *cam = priv;
int ret;
mutex_lock(&cam->s_mutex);
ret = sensor_call(cam, core, queryctrl, qc);
mutex_unlock(&cam->s_mutex);
return ret;
}
static int cafe_vidioc_g_ctrl(struct file *filp, void *priv,
struct v4l2_control *ctrl)
{
struct cafe_camera *cam = priv;
int ret;
mutex_lock(&cam->s_mutex);
ret = sensor_call(cam, core, g_ctrl, ctrl);
mutex_unlock(&cam->s_mutex);
return ret;
}
static int cafe_vidioc_s_ctrl(struct file *filp, void *priv,
struct v4l2_control *ctrl)
{
struct cafe_camera *cam = priv;
int ret;
mutex_lock(&cam->s_mutex);
ret = sensor_call(cam, core, s_ctrl, ctrl);
mutex_unlock(&cam->s_mutex);
return ret;
}
static int cafe_vidioc_querycap(struct file *file, void *priv,
struct v4l2_capability *cap)
{
strcpy(cap->driver, "cafe_ccic");
strcpy(cap->card, "cafe_ccic");
cap->version = CAFE_VERSION;
cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
return 0;
}
/*
* The default format we use until somebody says otherwise.
*/
static const struct v4l2_pix_format cafe_def_pix_format = {
.width = VGA_WIDTH,
.height = VGA_HEIGHT,
.pixelformat = V4L2_PIX_FMT_YUYV,
.field = V4L2_FIELD_NONE,
.bytesperline = VGA_WIDTH*2,
.sizeimage = VGA_WIDTH*VGA_HEIGHT*2,
};
static const enum v4l2_mbus_pixelcode cafe_def_mbus_code =
V4L2_MBUS_FMT_YUYV8_2X8;
static int cafe_vidioc_enum_fmt_vid_cap(struct file *filp,
void *priv, struct v4l2_fmtdesc *fmt)
{
if (fmt->index >= N_CAFE_FMTS)
return -EINVAL;
strlcpy(fmt->description, cafe_formats[fmt->index].desc,
sizeof(fmt->description));
fmt->pixelformat = cafe_formats[fmt->index].pixelformat;
return 0;
}
static int cafe_vidioc_try_fmt_vid_cap(struct file *filp, void *priv,
struct v4l2_format *fmt)
{
struct cafe_camera *cam = priv;
struct cafe_format_struct *f;
struct v4l2_pix_format *pix = &fmt->fmt.pix;
struct v4l2_mbus_framefmt mbus_fmt;
int ret;
f = cafe_find_format(pix->pixelformat);
pix->pixelformat = f->pixelformat;
v4l2_fill_mbus_format(&mbus_fmt, pix, f->mbus_code);
mutex_lock(&cam->s_mutex);
ret = sensor_call(cam, video, try_mbus_fmt, &mbus_fmt);
mutex_unlock(&cam->s_mutex);
v4l2_fill_pix_format(pix, &mbus_fmt);
pix->bytesperline = pix->width * f->bpp;
pix->sizeimage = pix->height * pix->bytesperline;
return ret;
}
static int cafe_vidioc_s_fmt_vid_cap(struct file *filp, void *priv,
struct v4l2_format *fmt)
{
struct cafe_camera *cam = priv;
struct cafe_format_struct *f;
int ret;
/*
* Can't do anything if the device is not idle
* Also can't if there are streaming buffers in place.
*/
if (cam->state != S_IDLE || cam->n_sbufs > 0)
return -EBUSY;
f = cafe_find_format(fmt->fmt.pix.pixelformat);
/*
* See if the formatting works in principle.
*/
ret = cafe_vidioc_try_fmt_vid_cap(filp, priv, fmt);
if (ret)
return ret;
/*
* Now we start to change things for real, so let's do it
* under lock.
*/
mutex_lock(&cam->s_mutex);
cam->pix_format = fmt->fmt.pix;
cam->mbus_code = f->mbus_code;
/*
* Make sure we have appropriate DMA buffers.
*/
ret = -ENOMEM;
if (cam->nbufs > 0 && cam->dma_buf_size < cam->pix_format.sizeimage)
cafe_free_dma_bufs(cam);
if (cam->nbufs == 0) {
if (cafe_alloc_dma_bufs(cam, 0))
goto out;
}
/*
* It looks like this might work, so let's program the sensor.
*/
ret = cafe_cam_configure(cam);
if (! ret)
ret = cafe_ctlr_configure(cam);
out:
mutex_unlock(&cam->s_mutex);
return ret;
}
/*
* Return our stored notion of how the camera is/should be configured.
* The V4l2 spec wants us to be smarter, and actually get this from
* the camera (and not mess with it at open time). Someday.
*/
static int cafe_vidioc_g_fmt_vid_cap(struct file *filp, void *priv,
struct v4l2_format *f)
{
struct cafe_camera *cam = priv;
f->fmt.pix = cam->pix_format;
return 0;
}
/*
* We only have one input - the sensor - so minimize the nonsense here.
*/
static int cafe_vidioc_enum_input(struct file *filp, void *priv,
struct v4l2_input *input)
{
if (input->index != 0)
return -EINVAL;
input->type = V4L2_INPUT_TYPE_CAMERA;
input->std = V4L2_STD_ALL; /* Not sure what should go here */
strcpy(input->name, "Camera");
return 0;
}
static int cafe_vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
{
*i = 0;
return 0;
}
static int cafe_vidioc_s_input(struct file *filp, void *priv, unsigned int i)
{
if (i != 0)
return -EINVAL;
return 0;
}
/* from vivi.c */
static int cafe_vidioc_s_std(struct file *filp, void *priv, v4l2_std_id *a)
{
return 0;
}
/*
* G/S_PARM. Most of this is done by the sensor, but we are
* the level which controls the number of read buffers.
*/
static int cafe_vidioc_g_parm(struct file *filp, void *priv,
struct v4l2_streamparm *parms)
{
struct cafe_camera *cam = priv;
int ret;
mutex_lock(&cam->s_mutex);
ret = sensor_call(cam, video, g_parm, parms);
mutex_unlock(&cam->s_mutex);
parms->parm.capture.readbuffers = n_dma_bufs;
return ret;
}
static int cafe_vidioc_s_parm(struct file *filp, void *priv,
struct v4l2_streamparm *parms)
{
struct cafe_camera *cam = priv;
int ret;
mutex_lock(&cam->s_mutex);
ret = sensor_call(cam, video, s_parm, parms);
mutex_unlock(&cam->s_mutex);
parms->parm.capture.readbuffers = n_dma_bufs;
return ret;
}
static int cafe_vidioc_g_chip_ident(struct file *file, void *priv,
struct v4l2_dbg_chip_ident *chip)
{
struct cafe_camera *cam = priv;
chip->ident = V4L2_IDENT_NONE;
chip->revision = 0;
if (v4l2_chip_match_host(&chip->match)) {
chip->ident = V4L2_IDENT_CAFE;
return 0;
}
return sensor_call(cam, core, g_chip_ident, chip);
}
static int cafe_vidioc_enum_framesizes(struct file *filp, void *priv,
struct v4l2_frmsizeenum *sizes)
{
struct cafe_camera *cam = priv;
int ret;
mutex_lock(&cam->s_mutex);
ret = sensor_call(cam, video, enum_framesizes, sizes);
mutex_unlock(&cam->s_mutex);
return ret;
}
static int cafe_vidioc_enum_frameintervals(struct file *filp, void *priv,
struct v4l2_frmivalenum *interval)
{
struct cafe_camera *cam = priv;
int ret;
mutex_lock(&cam->s_mutex);
ret = sensor_call(cam, video, enum_frameintervals, interval);
mutex_unlock(&cam->s_mutex);
return ret;
}
#ifdef CONFIG_VIDEO_ADV_DEBUG
static int cafe_vidioc_g_register(struct file *file, void *priv,
struct v4l2_dbg_register *reg)
{
struct cafe_camera *cam = priv;
if (v4l2_chip_match_host(&reg->match)) {
reg->val = cafe_reg_read(cam, reg->reg);
reg->size = 4;
return 0;
}
return sensor_call(cam, core, g_register, reg);
}
static int cafe_vidioc_s_register(struct file *file, void *priv,
struct v4l2_dbg_register *reg)
{
struct cafe_camera *cam = priv;
if (v4l2_chip_match_host(&reg->match)) {
cafe_reg_write(cam, reg->reg, reg->val);
return 0;
}
return sensor_call(cam, core, s_register, reg);
}
#endif
/*
* This template device holds all of those v4l2 methods; we
* clone it for specific real devices.
*/
static const struct v4l2_file_operations cafe_v4l_fops = {
.owner = THIS_MODULE,
.open = cafe_v4l_open,
.release = cafe_v4l_release,
.read = cafe_v4l_read,
.poll = cafe_v4l_poll,
.mmap = cafe_v4l_mmap,
.unlocked_ioctl = video_ioctl2,
};
static const struct v4l2_ioctl_ops cafe_v4l_ioctl_ops = {
.vidioc_querycap = cafe_vidioc_querycap,
.vidioc_enum_fmt_vid_cap = cafe_vidioc_enum_fmt_vid_cap,
.vidioc_try_fmt_vid_cap = cafe_vidioc_try_fmt_vid_cap,
.vidioc_s_fmt_vid_cap = cafe_vidioc_s_fmt_vid_cap,
.vidioc_g_fmt_vid_cap = cafe_vidioc_g_fmt_vid_cap,
.vidioc_enum_input = cafe_vidioc_enum_input,
.vidioc_g_input = cafe_vidioc_g_input,
.vidioc_s_input = cafe_vidioc_s_input,
.vidioc_s_std = cafe_vidioc_s_std,
.vidioc_reqbufs = cafe_vidioc_reqbufs,
.vidioc_querybuf = cafe_vidioc_querybuf,
.vidioc_qbuf = cafe_vidioc_qbuf,
.vidioc_dqbuf = cafe_vidioc_dqbuf,
.vidioc_streamon = cafe_vidioc_streamon,
.vidioc_streamoff = cafe_vidioc_streamoff,
.vidioc_queryctrl = cafe_vidioc_queryctrl,
.vidioc_g_ctrl = cafe_vidioc_g_ctrl,
.vidioc_s_ctrl = cafe_vidioc_s_ctrl,
.vidioc_g_parm = cafe_vidioc_g_parm,
.vidioc_s_parm = cafe_vidioc_s_parm,
.vidioc_enum_framesizes = cafe_vidioc_enum_framesizes,
.vidioc_enum_frameintervals = cafe_vidioc_enum_frameintervals,
.vidioc_g_chip_ident = cafe_vidioc_g_chip_ident,
#ifdef CONFIG_VIDEO_ADV_DEBUG
.vidioc_g_register = cafe_vidioc_g_register,
.vidioc_s_register = cafe_vidioc_s_register,
#endif
};
static struct video_device cafe_v4l_template = {
.name = "cafe",
.tvnorms = V4L2_STD_NTSC_M,
.current_norm = V4L2_STD_NTSC_M, /* make mplayer happy */
.fops = &cafe_v4l_fops,
.ioctl_ops = &cafe_v4l_ioctl_ops,
.release = video_device_release_empty,
};
/* ---------------------------------------------------------------------- */
/*
* Interrupt handler stuff
*/
static void cafe_frame_tasklet(unsigned long data)
{
struct cafe_camera *cam = (struct cafe_camera *) data;
int i;
unsigned long flags;
struct cafe_sio_buffer *sbuf;
spin_lock_irqsave(&cam->dev_lock, flags);
for (i = 0; i < cam->nbufs; i++) {
int bufno = cam->next_buf;
if (bufno < 0) { /* "will never happen" */
cam_err(cam, "No valid bufs in tasklet!\n");
break;
}
if (++(cam->next_buf) >= cam->nbufs)
cam->next_buf = 0;
if (! test_bit(bufno, &cam->flags))
continue;
if (list_empty(&cam->sb_avail))
break; /* Leave it valid, hope for better later */
clear_bit(bufno, &cam->flags);
sbuf = list_entry(cam->sb_avail.next,
struct cafe_sio_buffer, list);
/*
* Drop the lock during the big copy. This *should* be safe...
*/
spin_unlock_irqrestore(&cam->dev_lock, flags);
memcpy(sbuf->buffer, cam->dma_bufs[bufno],
cam->pix_format.sizeimage);
sbuf->v4lbuf.bytesused = cam->pix_format.sizeimage;
sbuf->v4lbuf.sequence = cam->buf_seq[bufno];
sbuf->v4lbuf.flags &= ~V4L2_BUF_FLAG_QUEUED;
sbuf->v4lbuf.flags |= V4L2_BUF_FLAG_DONE;
spin_lock_irqsave(&cam->dev_lock, flags);
list_move_tail(&sbuf->list, &cam->sb_full);
}
if (! list_empty(&cam->sb_full))
wake_up(&cam->iowait);
spin_unlock_irqrestore(&cam->dev_lock, flags);
}
static void cafe_frame_complete(struct cafe_camera *cam, int frame)
{
/*
* Basic frame housekeeping.
*/
if (test_bit(frame, &cam->flags) && printk_ratelimit())
cam_err(cam, "Frame overrun on %d, frames lost\n", frame);
set_bit(frame, &cam->flags);
clear_bit(CF_DMA_ACTIVE, &cam->flags);
if (cam->next_buf < 0)
cam->next_buf = frame;
cam->buf_seq[frame] = ++(cam->sequence);
switch (cam->state) {
/*
* If in single read mode, try going speculative.
*/
case S_SINGLEREAD:
cam->state = S_SPECREAD;
cam->specframes = 0;
wake_up(&cam->iowait);
break;
/*
* If we are already doing speculative reads, and nobody is
* reading them, just stop.
*/
case S_SPECREAD:
if (++(cam->specframes) >= cam->nbufs) {
cafe_ctlr_stop(cam);
cafe_ctlr_irq_disable(cam);
cam->state = S_IDLE;
}
wake_up(&cam->iowait);
break;
/*
* For the streaming case, we defer the real work to the
* camera tasklet.
*
* FIXME: if the application is not consuming the buffers,
* we should eventually put things on hold and restart in
* vidioc_dqbuf().
*/
case S_STREAMING:
tasklet_schedule(&cam->s_tasklet);
break;
default:
cam_err(cam, "Frame interrupt in non-operational state\n");
break;
}
}
static void cafe_frame_irq(struct cafe_camera *cam, unsigned int irqs)
{
unsigned int frame;
cafe_reg_write(cam, REG_IRQSTAT, FRAMEIRQS); /* Clear'em all */
/*
* Handle any frame completions. There really should
* not be more than one of these, or we have fallen
* far behind.
*/
for (frame = 0; frame < cam->nbufs; frame++)
if (irqs & (IRQ_EOF0 << frame))
cafe_frame_complete(cam, frame);
/*
* If a frame starts, note that we have DMA active. This
* code assumes that we won't get multiple frame interrupts
* at once; may want to rethink that.
*/
if (irqs & (IRQ_SOF0 | IRQ_SOF1 | IRQ_SOF2))
set_bit(CF_DMA_ACTIVE, &cam->flags);
}
static irqreturn_t cafe_irq(int irq, void *data)
{
struct cafe_camera *cam = data;
unsigned int irqs;
spin_lock(&cam->dev_lock);
irqs = cafe_reg_read(cam, REG_IRQSTAT);
if ((irqs & ALLIRQS) == 0) {
spin_unlock(&cam->dev_lock);
return IRQ_NONE;
}
if (irqs & FRAMEIRQS)
cafe_frame_irq(cam, irqs);
if (irqs & TWSIIRQS) {
cafe_reg_write(cam, REG_IRQSTAT, TWSIIRQS);
wake_up(&cam->smbus_wait);
}
spin_unlock(&cam->dev_lock);
return IRQ_HANDLED;
}
/* -------------------------------------------------------------------------- */
/*
* PCI interface stuff.
*/
static const struct dmi_system_id olpc_xo1_dmi[] = {
{
.matches = {
DMI_MATCH(DMI_SYS_VENDOR, "OLPC"),
DMI_MATCH(DMI_PRODUCT_NAME, "XO"),
DMI_MATCH(DMI_PRODUCT_VERSION, "1"),
},
},
{ }
};
static int cafe_pci_probe(struct pci_dev *pdev,
const struct pci_device_id *id)
{
int ret;
struct cafe_camera *cam;
struct ov7670_config sensor_cfg = {
/* This controller only does SMBUS */
.use_smbus = true,
/*
* Exclude QCIF mode, because it only captures a tiny portion
* of the sensor FOV
*/
.min_width = 320,
.min_height = 240,
};
/*
* Start putting together one of our big camera structures.
*/
ret = -ENOMEM;
cam = kzalloc(sizeof(struct cafe_camera), GFP_KERNEL);
if (cam == NULL)
goto out;
ret = v4l2_device_register(&pdev->dev, &cam->v4l2_dev);
if (ret)
goto out_free;
mutex_init(&cam->s_mutex);
spin_lock_init(&cam->dev_lock);
cam->state = S_NOTREADY;
cafe_set_config_needed(cam, 1);
init_waitqueue_head(&cam->smbus_wait);
init_waitqueue_head(&cam->iowait);
cam->pdev = pdev;
cam->pix_format = cafe_def_pix_format;
cam->mbus_code = cafe_def_mbus_code;
INIT_LIST_HEAD(&cam->dev_list);
INIT_LIST_HEAD(&cam->sb_avail);
INIT_LIST_HEAD(&cam->sb_full);
tasklet_init(&cam->s_tasklet, cafe_frame_tasklet, (unsigned long) cam);
/*
* Get set up on the PCI bus.
*/
ret = pci_enable_device(pdev);
if (ret)
goto out_unreg;
pci_set_master(pdev);
ret = -EIO;
cam->regs = pci_iomap(pdev, 0, 0);
if (! cam->regs) {
printk(KERN_ERR "Unable to ioremap cafe-ccic regs\n");
goto out_unreg;
}
ret = request_irq(pdev->irq, cafe_irq, IRQF_SHARED, "cafe-ccic", cam);
if (ret)
goto out_iounmap;
/*
* Initialize the controller and leave it powered up. It will
* stay that way until the sensor driver shows up.
*/
cafe_ctlr_init(cam);
cafe_ctlr_power_up(cam);
/*
* Set up I2C/SMBUS communications. We have to drop the mutex here
* because the sensor could attach in this call chain, leading to
* unsightly deadlocks.
*/
ret = cafe_smbus_setup(cam);
if (ret)
goto out_freeirq;
/* Apply XO-1 clock speed */
if (dmi_check_system(olpc_xo1_dmi))
sensor_cfg.clock_speed = 45;
cam->sensor_addr = 0x42;
cam->sensor = v4l2_i2c_new_subdev_cfg(&cam->v4l2_dev, &cam->i2c_adapter,
"ov7670", 0, &sensor_cfg, cam->sensor_addr, NULL);
if (cam->sensor == NULL) {
ret = -ENODEV;
goto out_smbus;
}
ret = cafe_cam_init(cam);
if (ret)
goto out_smbus;
/*
* Get the v4l2 setup done.
*/
mutex_lock(&cam->s_mutex);
cam->vdev = cafe_v4l_template;
cam->vdev.debug = 0;
/* cam->vdev.debug = V4L2_DEBUG_IOCTL_ARG;*/
cam->vdev.v4l2_dev = &cam->v4l2_dev;
ret = video_register_device(&cam->vdev, VFL_TYPE_GRABBER, -1);
if (ret)
goto out_unlock;
video_set_drvdata(&cam->vdev, cam);
/*
* If so requested, try to get our DMA buffers now.
*/
if (!alloc_bufs_at_read) {
if (cafe_alloc_dma_bufs(cam, 1))
cam_warn(cam, "Unable to alloc DMA buffers at load"
" will try again later.");
}
mutex_unlock(&cam->s_mutex);
return 0;
out_unlock:
mutex_unlock(&cam->s_mutex);
out_smbus:
cafe_smbus_shutdown(cam);
out_freeirq:
cafe_ctlr_power_down(cam);
free_irq(pdev->irq, cam);
out_iounmap:
pci_iounmap(pdev, cam->regs);
out_free:
v4l2_device_unregister(&cam->v4l2_dev);
out_unreg:
kfree(cam);
out:
return ret;
}
/*
* Shut down an initialized device
*/
static void cafe_shutdown(struct cafe_camera *cam)
{
/* FIXME: Make sure we take care of everything here */
if (cam->n_sbufs > 0)
/* What if they are still mapped? Shouldn't be, but... */
cafe_free_sio_buffers(cam);
cafe_ctlr_stop_dma(cam);
cafe_ctlr_power_down(cam);
cafe_smbus_shutdown(cam);
cafe_free_dma_bufs(cam);
free_irq(cam->pdev->irq, cam);
pci_iounmap(cam->pdev, cam->regs);
video_unregister_device(&cam->vdev);
}
static void cafe_pci_remove(struct pci_dev *pdev)
{
struct v4l2_device *v4l2_dev = dev_get_drvdata(&pdev->dev);
struct cafe_camera *cam = to_cam(v4l2_dev);
if (cam == NULL) {
printk(KERN_WARNING "pci_remove on unknown pdev %p\n", pdev);
return;
}
mutex_lock(&cam->s_mutex);
if (cam->users > 0)
cam_warn(cam, "Removing a device with users!\n");
cafe_shutdown(cam);
v4l2_device_unregister(&cam->v4l2_dev);
kfree(cam);
/* No unlock - it no longer exists */
}
#ifdef CONFIG_PM
/*
* Basic power management.
*/
static int cafe_pci_suspend(struct pci_dev *pdev, pm_message_t state)
{
struct v4l2_device *v4l2_dev = dev_get_drvdata(&pdev->dev);
struct cafe_camera *cam = to_cam(v4l2_dev);
int ret;
enum cafe_state cstate;
ret = pci_save_state(pdev);
if (ret)
return ret;
cstate = cam->state; /* HACK - stop_dma sets to idle */
cafe_ctlr_stop_dma(cam);
cafe_ctlr_power_down(cam);
pci_disable_device(pdev);
cam->state = cstate;
return 0;
}
static int cafe_pci_resume(struct pci_dev *pdev)
{
struct v4l2_device *v4l2_dev = dev_get_drvdata(&pdev->dev);
struct cafe_camera *cam = to_cam(v4l2_dev);
int ret = 0;
ret = pci_restore_state(pdev);
if (ret)
return ret;
ret = pci_enable_device(pdev);
if (ret) {
cam_warn(cam, "Unable to re-enable device on resume!\n");
return ret;
}
cafe_ctlr_init(cam);
mutex_lock(&cam->s_mutex);
if (cam->users > 0) {
cafe_ctlr_power_up(cam);
__cafe_cam_reset(cam);
} else {
cafe_ctlr_power_down(cam);
}
mutex_unlock(&cam->s_mutex);
set_bit(CF_CONFIG_NEEDED, &cam->flags);
if (cam->state == S_SPECREAD)
cam->state = S_IDLE; /* Don't bother restarting */
else if (cam->state == S_SINGLEREAD || cam->state == S_STREAMING)
ret = cafe_read_setup(cam, cam->state);
return ret;
}
#endif /* CONFIG_PM */
static struct pci_device_id cafe_ids[] = {
{ PCI_DEVICE(PCI_VENDOR_ID_MARVELL,
PCI_DEVICE_ID_MARVELL_88ALP01_CCIC) },
{ 0, }
};
MODULE_DEVICE_TABLE(pci, cafe_ids);
static struct pci_driver cafe_pci_driver = {
.name = "cafe1000-ccic",
.id_table = cafe_ids,
.probe = cafe_pci_probe,
.remove = cafe_pci_remove,
#ifdef CONFIG_PM
.suspend = cafe_pci_suspend,
.resume = cafe_pci_resume,
#endif
};
static int __init cafe_init(void)
{
int ret;
printk(KERN_NOTICE "Marvell M88ALP01 'CAFE' Camera Controller version %d\n",
CAFE_VERSION);
ret = pci_register_driver(&cafe_pci_driver);
if (ret) {
printk(KERN_ERR "Unable to register cafe_ccic driver\n");
goto out;
}
ret = 0;
out:
return ret;
}
static void __exit cafe_exit(void)
{
pci_unregister_driver(&cafe_pci_driver);
}
module_init(cafe_init);
module_exit(cafe_exit);
Reference in a new issue View git blame Copy permalink