dect/linux-2.6
Archived
14
0
Fork 0
Code Releases Activity
This repository has been archived on 2022-02-17. You can view files and clone it, but cannot push or open issues or pull requests.
linux-2.6/drivers/media/video/vino.c
Arjan van de Ven fa027c2a0a [PATCH] mark struct file_operations const 4 
Many struct file_operations in the kernel can be "const".  Marking them const
moves these to the .rodata section, which avoids false sharing with potential
dirty data.  In addition it'll catch accidental writes at compile time to
these shared resources.

[akpm@sdl.org: dvb fix]
Signed-off-by: Arjan van de Ven <arjan@linux.intel.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-02-12 09:48:45 -08:00

4680 lines
105 KiB
C
Raw Blame History

/*
* Driver for the VINO (Video In No Out) system found in SGI Indys.
*
* This file is subject to the terms and conditions of the GNU General Public
* License version 2 as published by the Free Software Foundation.
*
* Copyright (C) 2004,2005 Mikael Nousiainen <tmnousia@cc.hut.fi>
*
* Based on the previous version of the driver for 2.4 kernels by:
* Copyright (C) 2003 Ladislav Michl <ladis@linux-mips.org>
*/
/*
* TODO:
* - remove "mark pages reserved-hacks" from memory allocation code
* and implement nopage()
* - check decimation, calculating and reporting image size when
* using decimation
* - implement read(), user mode buffers and overlay (?)
*/
#include <linux/init.h>
#include <linux/module.h>
#include <linux/delay.h>
#include <linux/dma-mapping.h>
#include <linux/errno.h>
#include <linux/fs.h>
#include <linux/interrupt.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/moduleparam.h>
#include <linux/time.h>
#include <linux/version.h>
#ifdef CONFIG_KMOD
#include <linux/kmod.h>
#endif
#include <linux/i2c.h>
#include <linux/i2c-algo-sgi.h>
#include <linux/videodev.h>
#include <media/v4l2-common.h>
#include <linux/video_decoder.h>
#include <linux/mutex.h>
#include <asm/paccess.h>
#include <asm/io.h>
#include <asm/sgi/ip22.h>
#include <asm/sgi/mc.h>
#include "vino.h"
#include "saa7191.h"
#include "indycam.h"
/* Uncomment the following line to get lots and lots of (mostly useless)
* debug info.
* Note that the debug output also slows down the driver significantly */
// #define VINO_DEBUG
// #define VINO_DEBUG_INT
#define VINO_MODULE_VERSION "0.0.5"
#define VINO_VERSION_CODE KERNEL_VERSION(0, 0, 5)
MODULE_DESCRIPTION("SGI VINO Video4Linux2 driver");
MODULE_VERSION(VINO_MODULE_VERSION);
MODULE_AUTHOR("Mikael Nousiainen <tmnousia@cc.hut.fi>");
MODULE_LICENSE("GPL");
#ifdef VINO_DEBUG
#define dprintk(x...) printk("VINO: " x);
#else
#define dprintk(x...)
#endif
#define VINO_NO_CHANNEL 0
#define VINO_CHANNEL_A 1
#define VINO_CHANNEL_B 2
#define VINO_PAL_WIDTH 768
#define VINO_PAL_HEIGHT 576
#define VINO_NTSC_WIDTH 640
#define VINO_NTSC_HEIGHT 480
#define VINO_MIN_WIDTH 32
#define VINO_MIN_HEIGHT 32
#define VINO_CLIPPING_START_ODD_D1 1
#define VINO_CLIPPING_START_ODD_PAL 15
#define VINO_CLIPPING_START_ODD_NTSC 12
#define VINO_CLIPPING_START_EVEN_D1 2
#define VINO_CLIPPING_START_EVEN_PAL 15
#define VINO_CLIPPING_START_EVEN_NTSC 12
#define VINO_INPUT_CHANNEL_COUNT 3
/* the number is the index for vino_inputs */
#define VINO_INPUT_NONE -1
#define VINO_INPUT_COMPOSITE 0
#define VINO_INPUT_SVIDEO 1
#define VINO_INPUT_D1 2
#define VINO_PAGE_RATIO (PAGE_SIZE / VINO_PAGE_SIZE)
#define VINO_FIFO_THRESHOLD_DEFAULT 16
#define VINO_FRAMEBUFFER_SIZE ((VINO_PAL_WIDTH \
* VINO_PAL_HEIGHT * 4 \
+ 3 * PAGE_SIZE) & ~(PAGE_SIZE - 1))
#define VINO_FRAMEBUFFER_COUNT_MAX 8
#define VINO_FRAMEBUFFER_UNUSED 0
#define VINO_FRAMEBUFFER_IN_USE 1
#define VINO_FRAMEBUFFER_READY 2
#define VINO_QUEUE_ERROR -1
#define VINO_QUEUE_MAGIC 0x20050125
#define VINO_MEMORY_NONE 0
#define VINO_MEMORY_MMAP 1
#define VINO_MEMORY_USERPTR 2
#define VINO_DUMMY_DESC_COUNT 4
#define VINO_DESC_FETCH_DELAY 5 /* microseconds */
#define VINO_MAX_FRAME_SKIP_COUNT 128
/* the number is the index for vino_data_formats */
#define VINO_DATA_FMT_NONE -1
#define VINO_DATA_FMT_GREY 0
#define VINO_DATA_FMT_RGB332 1
#define VINO_DATA_FMT_RGB32 2
#define VINO_DATA_FMT_YUV 3
#define VINO_DATA_FMT_COUNT 4
/* the number is the index for vino_data_norms */
#define VINO_DATA_NORM_NONE -1
#define VINO_DATA_NORM_NTSC 0
#define VINO_DATA_NORM_PAL 1
#define VINO_DATA_NORM_SECAM 2
#define VINO_DATA_NORM_D1 3
/* The following are special entries that can be used to
* autodetect the norm. */
#define VINO_DATA_NORM_AUTO 0xfe
#define VINO_DATA_NORM_AUTO_EXT 0xff
#define VINO_DATA_NORM_COUNT 4
/* Internal data structure definitions */
struct vino_input {
char *name;
v4l2_std_id std;
};
struct vino_clipping {
unsigned int left, right, top, bottom;
};
struct vino_data_format {
/* the description */
char *description;
/* bytes per pixel */
unsigned int bpp;
/* V4L2 fourcc code */
__u32 pixelformat;
/* V4L2 colorspace (duh!) */
enum v4l2_colorspace colorspace;
};
struct vino_data_norm {
char *description;
unsigned int width, height;
struct vino_clipping odd;
struct vino_clipping even;
v4l2_std_id std;
unsigned int fps_min, fps_max;
__u32 framelines;
};
struct vino_descriptor_table {
/* the number of PAGE_SIZE sized pages in the buffer */
unsigned int page_count;
/* virtual (kmalloc'd) pointers to the actual data
* (in PAGE_SIZE chunks, used with mmap streaming) */
unsigned long *virtual;
/* cpu address for the VINO descriptor table
* (contains DMA addresses, VINO_PAGE_SIZE chunks) */
unsigned long *dma_cpu;
/* dma address for the VINO descriptor table
* (contains DMA addresses, VINO_PAGE_SIZE chunks) */
dma_addr_t dma;
};
struct vino_framebuffer {
/* identifier nubmer */
unsigned int id;
/* the length of the whole buffer */
unsigned int size;
/* the length of actual data in buffer */
unsigned int data_size;
/* the data format */
unsigned int data_format;
/* the state of buffer data */
unsigned int state;
/* is the buffer mapped in user space? */
unsigned int map_count;
/* memory offset for mmap() */
unsigned int offset;
/* frame counter */
unsigned int frame_counter;
/* timestamp (written when image capture finishes) */
struct timeval timestamp;
struct vino_descriptor_table desc_table;
spinlock_t state_lock;
};
struct vino_framebuffer_fifo {
unsigned int length;
unsigned int used;
unsigned int head;
unsigned int tail;
unsigned int data[VINO_FRAMEBUFFER_COUNT_MAX];
};
struct vino_framebuffer_queue {
unsigned int magic;
/* VINO_MEMORY_NONE, VINO_MEMORY_MMAP or VINO_MEMORY_USERPTR */
unsigned int type;
unsigned int length;
/* data field of in and out contain index numbers for buffer */
struct vino_framebuffer_fifo in;
struct vino_framebuffer_fifo out;
struct vino_framebuffer *buffer[VINO_FRAMEBUFFER_COUNT_MAX];
spinlock_t queue_lock;
struct mutex queue_mutex;
wait_queue_head_t frame_wait_queue;
};
struct vino_interrupt_data {
struct timeval timestamp;
unsigned int frame_counter;
unsigned int skip_count;
unsigned int skip;
};
struct vino_channel_settings {
unsigned int channel;
int input;
unsigned int data_format;
unsigned int data_norm;
struct vino_clipping clipping;
unsigned int decimation;
unsigned int line_size;
unsigned int alpha;
unsigned int fps;
unsigned int framert_reg;
unsigned int fifo_threshold;
struct vino_framebuffer_queue fb_queue;
/* number of the current field */
unsigned int field;
/* read in progress */
int reading;
/* streaming is active */
int streaming;
/* the driver is currently processing the queue */
int capturing;
struct mutex mutex;
spinlock_t capture_lock;
unsigned int users;
struct vino_interrupt_data int_data;
/* V4L support */
struct video_device *v4l_device;
};
struct vino_client {
/* the channel which owns this client:
* VINO_NO_CHANNEL, VINO_CHANNEL_A or VINO_CHANNEL_B */
unsigned int owner;
struct i2c_client *driver;
};
struct vino_settings {
struct vino_channel_settings a;
struct vino_channel_settings b;
struct vino_client decoder;
struct vino_client camera;
/* a lock for vino register access */
spinlock_t vino_lock;
/* a lock for channel input changes */
spinlock_t input_lock;
unsigned long dummy_page;
struct vino_descriptor_table dummy_desc_table;
};
/* Module parameters */
/*
* Using vino_pixel_conversion the ABGR32-format pixels supplied
* by the VINO chip can be converted to more common formats
* like RGBA32 (or probably RGB24 in the future). This way we
* can give out data that can be specified correctly with
* the V4L2-definitions.
*
* The pixel format is specified as RGBA32 when no conversion
* is used.
*
* Note that this only affects the 32-bit bit depth.
*
* Use non-zero value to enable conversion.
*/
static int vino_pixel_conversion = 0;
module_param_named(pixelconv, vino_pixel_conversion, int, 0);
MODULE_PARM_DESC(pixelconv,
"enable pixel conversion (non-zero value enables)");
/* Internal data structures */
static struct sgi_vino *vino;
static struct vino_settings *vino_drvdata;
static const char *vino_driver_name = "vino";
static const char *vino_driver_description = "SGI VINO";
static const char *vino_bus_name = "GIO64 bus";
static const char *vino_v4l_device_name_a = "SGI VINO Channel A";
static const char *vino_v4l_device_name_b = "SGI VINO Channel B";
static void vino_capture_tasklet(unsigned long channel);
DECLARE_TASKLET(vino_tasklet_a, vino_capture_tasklet, VINO_CHANNEL_A);
DECLARE_TASKLET(vino_tasklet_b, vino_capture_tasklet, VINO_CHANNEL_B);
static const struct vino_input vino_inputs[] = {
{
.name = "Composite",
.std = V4L2_STD_NTSC | V4L2_STD_PAL
| V4L2_STD_SECAM,
},{
.name = "S-Video",
.std = V4L2_STD_NTSC | V4L2_STD_PAL
| V4L2_STD_SECAM,
},{
.name = "D1/IndyCam",
.std = V4L2_STD_NTSC,
}
};
static const struct vino_data_format vino_data_formats[] = {
{
.description = "8-bit greyscale",
.bpp = 1,
.pixelformat = V4L2_PIX_FMT_GREY,
.colorspace = V4L2_COLORSPACE_SMPTE170M,
},{
.description = "8-bit dithered RGB 3-3-2",
.bpp = 1,
.pixelformat = V4L2_PIX_FMT_RGB332,
.colorspace = V4L2_COLORSPACE_SRGB,
},{
.description = "32-bit RGB",
.bpp = 4,
.pixelformat = V4L2_PIX_FMT_RGB32,
.colorspace = V4L2_COLORSPACE_SRGB,
},{
.description = "YUV 4:2:2",
.bpp = 2,
.pixelformat = V4L2_PIX_FMT_YUYV, // XXX: swapped?
.colorspace = V4L2_COLORSPACE_SMPTE170M,
}
};
static const struct vino_data_norm vino_data_norms[] = {
{
.description = "NTSC",
.std = V4L2_STD_NTSC,
.fps_min = 6,
.fps_max = 30,
.framelines = 525,
.width = VINO_NTSC_WIDTH,
.height = VINO_NTSC_HEIGHT,
.odd = {
.top = VINO_CLIPPING_START_ODD_NTSC,
.left = 0,
.bottom = VINO_CLIPPING_START_ODD_NTSC
+ VINO_NTSC_HEIGHT / 2 - 1,
.right = VINO_NTSC_WIDTH,
},
.even = {
.top = VINO_CLIPPING_START_EVEN_NTSC,
.left = 0,
.bottom = VINO_CLIPPING_START_EVEN_NTSC
+ VINO_NTSC_HEIGHT / 2 - 1,
.right = VINO_NTSC_WIDTH,
},
},{
.description = "PAL",
.std = V4L2_STD_PAL,
.fps_min = 5,
.fps_max = 25,
.framelines = 625,
.width = VINO_PAL_WIDTH,
.height = VINO_PAL_HEIGHT,
.odd = {
.top = VINO_CLIPPING_START_ODD_PAL,
.left = 0,
.bottom = VINO_CLIPPING_START_ODD_PAL
+ VINO_PAL_HEIGHT / 2 - 1,
.right = VINO_PAL_WIDTH,
},
.even = {
.top = VINO_CLIPPING_START_EVEN_PAL,
.left = 0,
.bottom = VINO_CLIPPING_START_EVEN_PAL
+ VINO_PAL_HEIGHT / 2 - 1,
.right = VINO_PAL_WIDTH,
},
},{
.description = "SECAM",
.std = V4L2_STD_SECAM,
.fps_min = 5,
.fps_max = 25,
.framelines = 625,
.width = VINO_PAL_WIDTH,
.height = VINO_PAL_HEIGHT,
.odd = {
.top = VINO_CLIPPING_START_ODD_PAL,
.left = 0,
.bottom = VINO_CLIPPING_START_ODD_PAL
+ VINO_PAL_HEIGHT / 2 - 1,
.right = VINO_PAL_WIDTH,
},
.even = {
.top = VINO_CLIPPING_START_EVEN_PAL,
.left = 0,
.bottom = VINO_CLIPPING_START_EVEN_PAL
+ VINO_PAL_HEIGHT / 2 - 1,
.right = VINO_PAL_WIDTH,
},
},{
.description = "NTSC/D1",
.std = V4L2_STD_NTSC,
.fps_min = 6,
.fps_max = 30,
.framelines = 525,
.width = VINO_NTSC_WIDTH,
.height = VINO_NTSC_HEIGHT,
.odd = {
.top = VINO_CLIPPING_START_ODD_D1,
.left = 0,
.bottom = VINO_CLIPPING_START_ODD_D1
+ VINO_NTSC_HEIGHT / 2 - 1,
.right = VINO_NTSC_WIDTH,
},
.even = {
.top = VINO_CLIPPING_START_EVEN_D1,
.left = 0,
.bottom = VINO_CLIPPING_START_EVEN_D1
+ VINO_NTSC_HEIGHT / 2 - 1,
.right = VINO_NTSC_WIDTH,
},
}
};
#define VINO_INDYCAM_V4L2_CONTROL_COUNT 9
struct v4l2_queryctrl vino_indycam_v4l2_controls[] = {
{
.id = V4L2_CID_AUTOGAIN,
.type = V4L2_CTRL_TYPE_BOOLEAN,
.name = "Automatic Gain Control",
.minimum = 0,
.maximum = 1,
.step = 1,
.default_value = INDYCAM_AGC_DEFAULT,
.flags = 0,
.reserved = { INDYCAM_CONTROL_AGC, 0 },
},{
.id = V4L2_CID_AUTO_WHITE_BALANCE,
.type = V4L2_CTRL_TYPE_BOOLEAN,
.name = "Automatic White Balance",
.minimum = 0,
.maximum = 1,
.step = 1,
.default_value = INDYCAM_AWB_DEFAULT,
.flags = 0,
.reserved = { INDYCAM_CONTROL_AWB, 0 },
},{
.id = V4L2_CID_GAIN,
.type = V4L2_CTRL_TYPE_INTEGER,
.name = "Gain",
.minimum = INDYCAM_GAIN_MIN,
.maximum = INDYCAM_GAIN_MAX,
.step = 1,
.default_value = INDYCAM_GAIN_DEFAULT,
.flags = 0,
.reserved = { INDYCAM_CONTROL_GAIN, 0 },
},{
.id = V4L2_CID_PRIVATE_BASE,
.type = V4L2_CTRL_TYPE_INTEGER,
.name = "Red Saturation",
.minimum = INDYCAM_RED_SATURATION_MIN,
.maximum = INDYCAM_RED_SATURATION_MAX,
.step = 1,
.default_value = INDYCAM_RED_SATURATION_DEFAULT,
.flags = 0,
.reserved = { INDYCAM_CONTROL_RED_SATURATION, 0 },
},{
.id = V4L2_CID_PRIVATE_BASE + 1,
.type = V4L2_CTRL_TYPE_INTEGER,
.name = "Blue Saturation",
.minimum = INDYCAM_BLUE_SATURATION_MIN,
.maximum = INDYCAM_BLUE_SATURATION_MAX,
.step = 1,
.default_value = INDYCAM_BLUE_SATURATION_DEFAULT,
.flags = 0,
.reserved = { INDYCAM_CONTROL_BLUE_SATURATION, 0 },
},{
.id = V4L2_CID_RED_BALANCE,
.type = V4L2_CTRL_TYPE_INTEGER,
.name = "Red Balance",
.minimum = INDYCAM_RED_BALANCE_MIN,
.maximum = INDYCAM_RED_BALANCE_MAX,
.step = 1,
.default_value = INDYCAM_RED_BALANCE_DEFAULT,
.flags = 0,
.reserved = { INDYCAM_CONTROL_RED_BALANCE, 0 },
},{
.id = V4L2_CID_BLUE_BALANCE,
.type = V4L2_CTRL_TYPE_INTEGER,
.name = "Blue Balance",
.minimum = INDYCAM_BLUE_BALANCE_MIN,
.maximum = INDYCAM_BLUE_BALANCE_MAX,
.step = 1,
.default_value = INDYCAM_BLUE_BALANCE_DEFAULT,
.flags = 0,
.reserved = { INDYCAM_CONTROL_BLUE_BALANCE, 0 },
},{
.id = V4L2_CID_EXPOSURE,
.type = V4L2_CTRL_TYPE_INTEGER,
.name = "Shutter Control",
.minimum = INDYCAM_SHUTTER_MIN,
.maximum = INDYCAM_SHUTTER_MAX,
.step = 1,
.default_value = INDYCAM_SHUTTER_DEFAULT,
.flags = 0,
.reserved = { INDYCAM_CONTROL_SHUTTER, 0 },
},{
.id = V4L2_CID_GAMMA,
.type = V4L2_CTRL_TYPE_INTEGER,
.name = "Gamma",
.minimum = INDYCAM_GAMMA_MIN,
.maximum = INDYCAM_GAMMA_MAX,
.step = 1,
.default_value = INDYCAM_GAMMA_DEFAULT,
.flags = 0,
.reserved = { INDYCAM_CONTROL_GAMMA, 0 },
}
};
#define VINO_SAA7191_V4L2_CONTROL_COUNT 9
struct v4l2_queryctrl vino_saa7191_v4l2_controls[] = {
{
.id = V4L2_CID_HUE,
.type = V4L2_CTRL_TYPE_INTEGER,
.name = "Hue",
.minimum = SAA7191_HUE_MIN,
.maximum = SAA7191_HUE_MAX,
.step = 1,
.default_value = SAA7191_HUE_DEFAULT,
.flags = 0,
.reserved = { SAA7191_CONTROL_HUE, 0 },
},{
.id = V4L2_CID_PRIVATE_BASE,
.type = V4L2_CTRL_TYPE_INTEGER,
.name = "Luminance Bandpass",
.minimum = SAA7191_BANDPASS_MIN,
.maximum = SAA7191_BANDPASS_MAX,
.step = 1,
.default_value = SAA7191_BANDPASS_DEFAULT,
.flags = 0,
.reserved = { SAA7191_CONTROL_BANDPASS, 0 },
},{
.id = V4L2_CID_PRIVATE_BASE + 1,
.type = V4L2_CTRL_TYPE_INTEGER,
.name = "Luminance Bandpass Weight",
.minimum = SAA7191_BANDPASS_WEIGHT_MIN,
.maximum = SAA7191_BANDPASS_WEIGHT_MAX,
.step = 1,
.default_value = SAA7191_BANDPASS_WEIGHT_DEFAULT,
.flags = 0,
.reserved = { SAA7191_CONTROL_BANDPASS_WEIGHT, 0 },
},{
.id = V4L2_CID_PRIVATE_BASE + 2,
.type = V4L2_CTRL_TYPE_INTEGER,
.name = "HF Luminance Coring",
.minimum = SAA7191_CORING_MIN,
.maximum = SAA7191_CORING_MAX,
.step = 1,
.default_value = SAA7191_CORING_DEFAULT,
.flags = 0,
.reserved = { SAA7191_CONTROL_CORING, 0 },
},{
.id = V4L2_CID_PRIVATE_BASE + 3,
.type = V4L2_CTRL_TYPE_BOOLEAN,
.name = "Force Colour",
.minimum = SAA7191_FORCE_COLOUR_MIN,
.maximum = SAA7191_FORCE_COLOUR_MAX,
.step = 1,
.default_value = SAA7191_FORCE_COLOUR_DEFAULT,
.flags = 0,
.reserved = { SAA7191_CONTROL_FORCE_COLOUR, 0 },
},{
.id = V4L2_CID_PRIVATE_BASE + 4,
.type = V4L2_CTRL_TYPE_INTEGER,
.name = "Chrominance Gain Control",
.minimum = SAA7191_CHROMA_GAIN_MIN,
.maximum = SAA7191_CHROMA_GAIN_MAX,
.step = 1,
.default_value = SAA7191_CHROMA_GAIN_DEFAULT,
.flags = 0,
.reserved = { SAA7191_CONTROL_CHROMA_GAIN, 0 },
},{
.id = V4L2_CID_PRIVATE_BASE + 5,
.type = V4L2_CTRL_TYPE_BOOLEAN,
.name = "VTR Time Constant",
.minimum = SAA7191_VTRC_MIN,
.maximum = SAA7191_VTRC_MAX,
.step = 1,
.default_value = SAA7191_VTRC_DEFAULT,
.flags = 0,
.reserved = { SAA7191_CONTROL_VTRC, 0 },
},{
.id = V4L2_CID_PRIVATE_BASE + 6,
.type = V4L2_CTRL_TYPE_INTEGER,
.name = "Luminance Delay Compensation",
.minimum = SAA7191_LUMA_DELAY_MIN,
.maximum = SAA7191_LUMA_DELAY_MAX,
.step = 1,
.default_value = SAA7191_LUMA_DELAY_DEFAULT,
.flags = 0,
.reserved = { SAA7191_CONTROL_LUMA_DELAY, 0 },
},{
.id = V4L2_CID_PRIVATE_BASE + 7,
.type = V4L2_CTRL_TYPE_INTEGER,
.name = "Vertical Noise Reduction",
.minimum = SAA7191_VNR_MIN,
.maximum = SAA7191_VNR_MAX,
.step = 1,
.default_value = SAA7191_VNR_DEFAULT,
.flags = 0,
.reserved = { SAA7191_CONTROL_VNR, 0 },
}
};
/* VINO I2C bus functions */
unsigned i2c_vino_getctrl(void *data)
{
return vino->i2c_control;
}
void i2c_vino_setctrl(void *data, unsigned val)
{
vino->i2c_control = val;
}
unsigned i2c_vino_rdata(void *data)
{
return vino->i2c_data;
}
void i2c_vino_wdata(void *data, unsigned val)
{
vino->i2c_data = val;
}
static struct i2c_algo_sgi_data i2c_sgi_vino_data =
{
.getctrl = &i2c_vino_getctrl,
.setctrl = &i2c_vino_setctrl,
.rdata = &i2c_vino_rdata,
.wdata = &i2c_vino_wdata,
.xfer_timeout = 200,
.ack_timeout = 1000,
};
/*
* There are two possible clients on VINO I2C bus, so we limit usage only
* to them.
*/
static int i2c_vino_client_reg(struct i2c_client *client)
{
unsigned long flags;
int ret = 0;
spin_lock_irqsave(&vino_drvdata->input_lock, flags);
switch (client->driver->id) {
case I2C_DRIVERID_SAA7191:
if (vino_drvdata->decoder.driver)
ret = -EBUSY;
else
vino_drvdata->decoder.driver = client;
break;
case I2C_DRIVERID_INDYCAM:
if (vino_drvdata->camera.driver)
ret = -EBUSY;
else
vino_drvdata->camera.driver = client;
break;
default:
ret = -ENODEV;
}
spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
return ret;
}
static int i2c_vino_client_unreg(struct i2c_client *client)
{
unsigned long flags;
int ret = 0;
spin_lock_irqsave(&vino_drvdata->input_lock, flags);
if (client == vino_drvdata->decoder.driver) {
if (vino_drvdata->decoder.owner != VINO_NO_CHANNEL)
ret = -EBUSY;
else
vino_drvdata->decoder.driver = NULL;
} else if (client == vino_drvdata->camera.driver) {
if (vino_drvdata->camera.owner != VINO_NO_CHANNEL)
ret = -EBUSY;
else
vino_drvdata->camera.driver = NULL;
}
spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
return ret;
}
static struct i2c_adapter vino_i2c_adapter =
{
.name = "VINO I2C bus",
.id = I2C_HW_SGI_VINO,
.algo_data = &i2c_sgi_vino_data,
.client_register = &i2c_vino_client_reg,
.client_unregister = &i2c_vino_client_unreg,
};
static int vino_i2c_add_bus(void)
{
return i2c_sgi_add_bus(&vino_i2c_adapter);
}
static int vino_i2c_del_bus(void)
{
return i2c_del_adapter(&vino_i2c_adapter);
}
static int i2c_camera_command(unsigned int cmd, void *arg)
{
return vino_drvdata->camera.driver->
driver->command(vino_drvdata->camera.driver,
cmd, arg);
}
static int i2c_decoder_command(unsigned int cmd, void *arg)
{
return vino_drvdata->decoder.driver->
driver->command(vino_drvdata->decoder.driver,
cmd, arg);
}
/* VINO framebuffer/DMA descriptor management */
static void vino_free_buffer_with_count(struct vino_framebuffer *fb,
unsigned int count)
{
unsigned int i;
dprintk("vino_free_buffer_with_count(): count = %d\n", count);
for (i = 0; i < count; i++) {
ClearPageReserved(virt_to_page(fb->desc_table.virtual[i]));
dma_unmap_single(NULL,
fb->desc_table.dma_cpu[VINO_PAGE_RATIO * i],
PAGE_SIZE, DMA_FROM_DEVICE);
free_page(fb->desc_table.virtual[i]);
}
dma_free_coherent(NULL,
VINO_PAGE_RATIO * (fb->desc_table.page_count + 4) *
sizeof(dma_addr_t), (void *)fb->desc_table.dma_cpu,
fb->desc_table.dma);
kfree(fb->desc_table.virtual);
memset(fb, 0, sizeof(struct vino_framebuffer));
}
static void vino_free_buffer(struct vino_framebuffer *fb)
{
vino_free_buffer_with_count(fb, fb->desc_table.page_count);
}
static int vino_allocate_buffer(struct vino_framebuffer *fb,
unsigned int size)
{
unsigned int count, i, j;
int ret = 0;
dprintk("vino_allocate_buffer():\n");
if (size < 1)
return -EINVAL;
memset(fb, 0, sizeof(struct vino_framebuffer));
count = ((size / PAGE_SIZE) + 4) & ~3;
dprintk("vino_allocate_buffer(): size = %d, count = %d\n",
size, count);
/* allocate memory for table with virtual (page) addresses */
fb->desc_table.virtual = (unsigned long *)
kmalloc(count * sizeof(unsigned long), GFP_KERNEL);
if (!fb->desc_table.virtual)
return -ENOMEM;
/* allocate memory for table with dma addresses
* (has space for four extra descriptors) */
fb->desc_table.dma_cpu =
dma_alloc_coherent(NULL, VINO_PAGE_RATIO * (count + 4) *
sizeof(dma_addr_t), &fb->desc_table.dma,
GFP_KERNEL | GFP_DMA);
if (!fb->desc_table.dma_cpu) {
ret = -ENOMEM;
goto out_free_virtual;
}
/* allocate pages for the buffer and acquire the according
* dma addresses */
for (i = 0; i < count; i++) {
dma_addr_t dma_data_addr;
fb->desc_table.virtual[i] =
get_zeroed_page(GFP_KERNEL | GFP_DMA);
if (!fb->desc_table.virtual[i]) {
ret = -ENOBUFS;
break;
}
dma_data_addr =
dma_map_single(NULL,
(void *)fb->desc_table.virtual[i],
PAGE_SIZE, DMA_FROM_DEVICE);
for (j = 0; j < VINO_PAGE_RATIO; j++) {
fb->desc_table.dma_cpu[VINO_PAGE_RATIO * i + j] =
dma_data_addr + VINO_PAGE_SIZE * j;
}
SetPageReserved(virt_to_page(fb->desc_table.virtual[i]));
}
/* page_count needs to be set anyway, because the descriptor table has
* been allocated according to this number */
fb->desc_table.page_count = count;
if (ret) {
/* the descriptor with index i doesn't contain
* a valid address yet */
vino_free_buffer_with_count(fb, i);
return ret;
}
//fb->size = size;
fb->size = count * PAGE_SIZE;
fb->data_format = VINO_DATA_FMT_NONE;
/* set the dma stop-bit for the last (count+1)th descriptor */
fb->desc_table.dma_cpu[VINO_PAGE_RATIO * count] = VINO_DESC_STOP;
return 0;
out_free_virtual:
kfree(fb->desc_table.virtual);
return ret;
}
#if 0
/* user buffers not fully implemented yet */
static int vino_prepare_user_buffer(struct vino_framebuffer *fb,
void *user,
unsigned int size)
{
unsigned int count, i, j;
int ret = 0;
dprintk("vino_prepare_user_buffer():\n");
if (size < 1)
return -EINVAL;
memset(fb, 0, sizeof(struct vino_framebuffer));
count = ((size / PAGE_SIZE)) & ~3;
dprintk("vino_prepare_user_buffer(): size = %d, count = %d\n",
size, count);
/* allocate memory for table with virtual (page) addresses */
fb->desc_table.virtual = (unsigned long *)
kmalloc(count * sizeof(unsigned long), GFP_KERNEL);
if (!fb->desc_table.virtual)
return -ENOMEM;
/* allocate memory for table with dma addresses
* (has space for four extra descriptors) */
fb->desc_table.dma_cpu =
dma_alloc_coherent(NULL, VINO_PAGE_RATIO * (count + 4) *
sizeof(dma_addr_t), &fb->desc_table.dma,
GFP_KERNEL | GFP_DMA);
if (!fb->desc_table.dma_cpu) {
ret = -ENOMEM;
goto out_free_virtual;
}
/* allocate pages for the buffer and acquire the according
* dma addresses */
for (i = 0; i < count; i++) {
dma_addr_t dma_data_addr;
fb->desc_table.virtual[i] =
get_zeroed_page(GFP_KERNEL | GFP_DMA);
if (!fb->desc_table.virtual[i]) {
ret = -ENOBUFS;
break;
}
dma_data_addr =
dma_map_single(NULL,
(void *)fb->desc_table.virtual[i],
PAGE_SIZE, DMA_FROM_DEVICE);
for (j = 0; j < VINO_PAGE_RATIO; j++) {
fb->desc_table.dma_cpu[VINO_PAGE_RATIO * i + j] =
dma_data_addr + VINO_PAGE_SIZE * j;
}
SetPageReserved(virt_to_page(fb->desc_table.virtual[i]));
}
/* page_count needs to be set anyway, because the descriptor table has
* been allocated according to this number */
fb->desc_table.page_count = count;
if (ret) {
/* the descriptor with index i doesn't contain
* a valid address yet */
vino_free_buffer_with_count(fb, i);
return ret;
}
//fb->size = size;
fb->size = count * PAGE_SIZE;
/* set the dma stop-bit for the last (count+1)th descriptor */
fb->desc_table.dma_cpu[VINO_PAGE_RATIO * count] = VINO_DESC_STOP;
return 0;
out_free_virtual:
kfree(fb->desc_table.virtual);
return ret;
}
#endif
static void vino_sync_buffer(struct vino_framebuffer *fb)
{
int i;
dprintk("vino_sync_buffer():\n");
for (i = 0; i < fb->desc_table.page_count; i++)
dma_sync_single(NULL,
fb->desc_table.dma_cpu[VINO_PAGE_RATIO * i],
PAGE_SIZE, DMA_FROM_DEVICE);
}
/* Framebuffer fifo functions (need to be locked externally) */
static inline void vino_fifo_init(struct vino_framebuffer_fifo *f,
unsigned int length)
{
f->length = 0;
f->used = 0;
f->head = 0;
f->tail = 0;
if (length > VINO_FRAMEBUFFER_COUNT_MAX)
length = VINO_FRAMEBUFFER_COUNT_MAX;
f->length = length;
}
/* returns true/false */
static inline int vino_fifo_has_id(struct vino_framebuffer_fifo *f,
unsigned int id)
{
unsigned int i;
for (i = f->head; i == (f->tail - 1); i = (i + 1) % f->length) {
if (f->data[i] == id)
return 1;
}
return 0;
}
#if 0
/* returns true/false */
static inline int vino_fifo_full(struct vino_framebuffer_fifo *f)
{
return (f->used == f->length);
}
#endif
static inline unsigned int vino_fifo_get_used(struct vino_framebuffer_fifo *f)
{
return f->used;
}
static int vino_fifo_enqueue(struct vino_framebuffer_fifo *f, unsigned int id)
{
if (id >= f->length) {
return VINO_QUEUE_ERROR;
}
if (vino_fifo_has_id(f, id)) {
return VINO_QUEUE_ERROR;
}
if (f->used < f->length) {
f->data[f->tail] = id;
f->tail = (f->tail + 1) % f->length;
f->used++;
} else {
return VINO_QUEUE_ERROR;
}
return 0;
}
static int vino_fifo_peek(struct vino_framebuffer_fifo *f, unsigned int *id)
{
if (f->used > 0) {
*id = f->data[f->head];
} else {
return VINO_QUEUE_ERROR;
}
return 0;
}
static int vino_fifo_dequeue(struct vino_framebuffer_fifo *f, unsigned int *id)
{
if (f->used > 0) {
*id = f->data[f->head];
f->head = (f->head + 1) % f->length;
f->used--;
} else {
return VINO_QUEUE_ERROR;
}
return 0;
}
/* Framebuffer queue functions */
/* execute with queue_lock locked */
static void vino_queue_free_with_count(struct vino_framebuffer_queue *q,
unsigned int length)
{
unsigned int i;
q->length = 0;
memset(&q->in, 0, sizeof(struct vino_framebuffer_fifo));
memset(&q->out, 0, sizeof(struct vino_framebuffer_fifo));
for (i = 0; i < length; i++) {
dprintk("vino_queue_free_with_count(): freeing buffer %d\n",
i);
vino_free_buffer(q->buffer[i]);
kfree(q->buffer[i]);
}
q->type = VINO_MEMORY_NONE;
q->magic = 0;
}
static void vino_queue_free(struct vino_framebuffer_queue *q)
{
dprintk("vino_queue_free():\n");
if (q->magic != VINO_QUEUE_MAGIC)
return;
if (q->type != VINO_MEMORY_MMAP)
return;
mutex_lock(&q->queue_mutex);
vino_queue_free_with_count(q, q->length);
mutex_unlock(&q->queue_mutex);
}
static int vino_queue_init(struct vino_framebuffer_queue *q,
unsigned int *length)
{
unsigned int i;
int ret = 0;
dprintk("vino_queue_init(): length = %d\n", *length);
if (q->magic == VINO_QUEUE_MAGIC) {
dprintk("vino_queue_init(): queue already initialized!\n");
return -EINVAL;
}
if (q->type != VINO_MEMORY_NONE) {
dprintk("vino_queue_init(): queue already initialized!\n");
return -EINVAL;
}
if (*length < 1)
return -EINVAL;
mutex_lock(&q->queue_mutex);
if (*length > VINO_FRAMEBUFFER_COUNT_MAX)
*length = VINO_FRAMEBUFFER_COUNT_MAX;
q->length = 0;
for (i = 0; i < *length; i++) {
dprintk("vino_queue_init(): allocating buffer %d\n", i);
q->buffer[i] = kmalloc(sizeof(struct vino_framebuffer),
GFP_KERNEL);
if (!q->buffer[i]) {
dprintk("vino_queue_init(): kmalloc() failed\n");
ret = -ENOMEM;
break;
}
ret = vino_allocate_buffer(q->buffer[i],
VINO_FRAMEBUFFER_SIZE);
if (ret) {
kfree(q->buffer[i]);
dprintk("vino_queue_init(): "
"vino_allocate_buffer() failed\n");
break;
}
q->buffer[i]->id = i;
if (i > 0) {
q->buffer[i]->offset = q->buffer[i - 1]->offset +
q->buffer[i - 1]->size;
} else {
q->buffer[i]->offset = 0;
}
spin_lock_init(&q->buffer[i]->state_lock);
dprintk("vino_queue_init(): buffer = %d, offset = %d, "
"size = %d\n", i, q->buffer[i]->offset,
q->buffer[i]->size);
}
if (ret) {
vino_queue_free_with_count(q, i);
*length = 0;
} else {
q->length = *length;
vino_fifo_init(&q->in, q->length);
vino_fifo_init(&q->out, q->length);
q->type = VINO_MEMORY_MMAP;
q->magic = VINO_QUEUE_MAGIC;
}
mutex_unlock(&q->queue_mutex);
return ret;
}
static struct vino_framebuffer *vino_queue_add(struct
vino_framebuffer_queue *q,
unsigned int id)
{
struct vino_framebuffer *ret = NULL;
unsigned int total;
unsigned long flags;
dprintk("vino_queue_add(): id = %d\n", id);
if (q->magic != VINO_QUEUE_MAGIC) {
return ret;
}
spin_lock_irqsave(&q->queue_lock, flags);
if (q->length == 0)
goto out;
if (id >= q->length)
goto out;
/* not needed?: if (vino_fifo_full(&q->out)) {
goto out;
}*/
/* check that outgoing queue isn't already full
* (or that it won't become full) */
total = vino_fifo_get_used(&q->in) +
vino_fifo_get_used(&q->out);
if (total >= q->length)
goto out;
if (vino_fifo_enqueue(&q->in, id))
goto out;
ret = q->buffer[id];
out:
spin_unlock_irqrestore(&q->queue_lock, flags);
return ret;
}
static struct vino_framebuffer *vino_queue_transfer(struct
vino_framebuffer_queue *q)
{
struct vino_framebuffer *ret = NULL;
struct vino_framebuffer *fb;
int id;
unsigned long flags;
dprintk("vino_queue_transfer():\n");
if (q->magic != VINO_QUEUE_MAGIC) {
return ret;
}
spin_lock_irqsave(&q->queue_lock, flags);
if (q->length == 0)
goto out;
// now this actually removes an entry from the incoming queue
if (vino_fifo_dequeue(&q->in, &id)) {
goto out;
}
dprintk("vino_queue_transfer(): id = %d\n", id);
fb = q->buffer[id];
// we have already checked that the outgoing queue is not full, but...
if (vino_fifo_enqueue(&q->out, id)) {
printk(KERN_ERR "vino_queue_transfer(): "
"outgoing queue is full, this shouldn't happen!\n");
goto out;
}
ret = fb;
out:
spin_unlock_irqrestore(&q->queue_lock, flags);
return ret;
}
/* returns true/false */
static int vino_queue_incoming_contains(struct vino_framebuffer_queue *q,
unsigned int id)
{
int ret = 0;
unsigned long flags;
if (q->magic != VINO_QUEUE_MAGIC) {
return ret;
}
spin_lock_irqsave(&q->queue_lock, flags);
if (q->length == 0)
goto out;
ret = vino_fifo_has_id(&q->in, id);
out:
spin_unlock_irqrestore(&q->queue_lock, flags);
return ret;
}
/* returns true/false */
static int vino_queue_outgoing_contains(struct vino_framebuffer_queue *q,
unsigned int id)
{
int ret = 0;
unsigned long flags;
if (q->magic != VINO_QUEUE_MAGIC) {
return ret;
}
spin_lock_irqsave(&q->queue_lock, flags);
if (q->length == 0)
goto out;
ret = vino_fifo_has_id(&q->out, id);
out:
spin_unlock_irqrestore(&q->queue_lock, flags);
return ret;
}
static int vino_queue_get_incoming(struct vino_framebuffer_queue *q,
unsigned int *used)
{
int ret = 0;
unsigned long flags;
if (q->magic != VINO_QUEUE_MAGIC) {
return VINO_QUEUE_ERROR;
}
spin_lock_irqsave(&q->queue_lock, flags);
if (q->length == 0) {
ret = VINO_QUEUE_ERROR;
goto out;
}
*used = vino_fifo_get_used(&q->in);
out:
spin_unlock_irqrestore(&q->queue_lock, flags);
return ret;
}
static int vino_queue_get_outgoing(struct vino_framebuffer_queue *q,
unsigned int *used)
{
int ret = 0;
unsigned long flags;
if (q->magic != VINO_QUEUE_MAGIC) {
return VINO_QUEUE_ERROR;
}
spin_lock_irqsave(&q->queue_lock, flags);
if (q->length == 0) {
ret = VINO_QUEUE_ERROR;
goto out;
}
*used = vino_fifo_get_used(&q->out);
out:
spin_unlock_irqrestore(&q->queue_lock, flags);
return ret;
}
#if 0
static int vino_queue_get_total(struct vino_framebuffer_queue *q,
unsigned int *total)
{
int ret = 0;
unsigned long flags;
if (q->magic != VINO_QUEUE_MAGIC) {
return VINO_QUEUE_ERROR;
}
spin_lock_irqsave(&q->queue_lock, flags);
if (q->length == 0) {
ret = VINO_QUEUE_ERROR;
goto out;
}
*total = vino_fifo_get_used(&q->in) +
vino_fifo_get_used(&q->out);
out:
spin_unlock_irqrestore(&q->queue_lock, flags);
return ret;
}
#endif
static struct vino_framebuffer *vino_queue_peek(struct
vino_framebuffer_queue *q,
unsigned int *id)
{
struct vino_framebuffer *ret = NULL;
unsigned long flags;
if (q->magic != VINO_QUEUE_MAGIC) {
return ret;
}
spin_lock_irqsave(&q->queue_lock, flags);
if (q->length == 0)
goto out;
if (vino_fifo_peek(&q->in, id)) {
goto out;
}
ret = q->buffer[*id];
out:
spin_unlock_irqrestore(&q->queue_lock, flags);
return ret;
}
static struct vino_framebuffer *vino_queue_remove(struct
vino_framebuffer_queue *q,
unsigned int *id)
{
struct vino_framebuffer *ret = NULL;
unsigned long flags;
dprintk("vino_queue_remove():\n");
if (q->magic != VINO_QUEUE_MAGIC) {
return ret;
}
spin_lock_irqsave(&q->queue_lock, flags);
if (q->length == 0)
goto out;
if (vino_fifo_dequeue(&q->out, id)) {
goto out;
}
dprintk("vino_queue_remove(): id = %d\n", *id);
ret = q->buffer[*id];
out:
spin_unlock_irqrestore(&q->queue_lock, flags);
return ret;
}
static struct
vino_framebuffer *vino_queue_get_buffer(struct vino_framebuffer_queue *q,
unsigned int id)
{
struct vino_framebuffer *ret = NULL;
unsigned long flags;
if (q->magic != VINO_QUEUE_MAGIC) {
return ret;
}
spin_lock_irqsave(&q->queue_lock, flags);
if (q->length == 0)
goto out;
if (id >= q->length)
goto out;
ret = q->buffer[id];
out:
spin_unlock_irqrestore(&q->queue_lock, flags);
return ret;
}
static unsigned int vino_queue_get_length(struct vino_framebuffer_queue *q)
{
unsigned int length = 0;
unsigned long flags;
if (q->magic != VINO_QUEUE_MAGIC) {
return length;
}
spin_lock_irqsave(&q->queue_lock, flags);
length = q->length;
spin_unlock_irqrestore(&q->queue_lock, flags);
return length;
}
static int vino_queue_has_mapped_buffers(struct vino_framebuffer_queue *q)
{
unsigned int i;
int ret = 0;
unsigned long flags;
if (q->magic != VINO_QUEUE_MAGIC) {
return ret;
}
spin_lock_irqsave(&q->queue_lock, flags);
for (i = 0; i < q->length; i++) {
if (q->buffer[i]->map_count > 0) {
ret = 1;
break;
}
}
spin_unlock_irqrestore(&q->queue_lock, flags);
return ret;
}
/* VINO functions */
/* execute with input_lock locked */
static void vino_update_line_size(struct vino_channel_settings *vcs)
{
unsigned int w = vcs->clipping.right - vcs->clipping.left;
unsigned int d = vcs->decimation;
unsigned int bpp = vino_data_formats[vcs->data_format].bpp;
unsigned int lsize;
dprintk("update_line_size(): before: w = %d, d = %d, "
"line_size = %d\n", w, d, vcs->line_size);
/* line size must be multiple of 8 bytes */
lsize = (bpp * (w / d)) & ~7;
w = (lsize / bpp) * d;
vcs->clipping.right = vcs->clipping.left + w;
vcs->line_size = lsize;
dprintk("update_line_size(): after: w = %d, d = %d, "
"line_size = %d\n", w, d, vcs->line_size);
}
/* execute with input_lock locked */
static void vino_set_clipping(struct vino_channel_settings *vcs,
unsigned int x, unsigned int y,
unsigned int w, unsigned int h)
{
unsigned int maxwidth, maxheight;
unsigned int d;
maxwidth = vino_data_norms[vcs->data_norm].width;
maxheight = vino_data_norms[vcs->data_norm].height;
d = vcs->decimation;
y &= ~1; /* odd/even fields */
if (x > maxwidth) {
x = 0;
}
if (y > maxheight) {
y = 0;
}
if (((w / d) < VINO_MIN_WIDTH)
|| ((h / d) < VINO_MIN_HEIGHT)) {
w = VINO_MIN_WIDTH * d;
h = VINO_MIN_HEIGHT * d;
}
if ((x + w) > maxwidth) {
w = maxwidth - x;
if ((w / d) < VINO_MIN_WIDTH)
x = maxwidth - VINO_MIN_WIDTH * d;
}
if ((y + h) > maxheight) {
h = maxheight - y;
if ((h / d) < VINO_MIN_HEIGHT)
y = maxheight - VINO_MIN_HEIGHT * d;
}
vcs->clipping.left = x;
vcs->clipping.top = y;
vcs->clipping.right = x + w;
vcs->clipping.bottom = y + h;
vino_update_line_size(vcs);
dprintk("clipping %d, %d, %d, %d / %d - %d\n",
vcs->clipping.left, vcs->clipping.top, vcs->clipping.right,
vcs->clipping.bottom, vcs->decimation, vcs->line_size);
}
/* execute with input_lock locked */
static inline void vino_set_default_clipping(struct vino_channel_settings *vcs)
{
vino_set_clipping(vcs, 0, 0, vino_data_norms[vcs->data_norm].width,
vino_data_norms[vcs->data_norm].height);
}
/* execute with input_lock locked */
static void vino_set_scaling(struct vino_channel_settings *vcs,
unsigned int w, unsigned int h)
{
unsigned int x, y, curw, curh, d;
x = vcs->clipping.left;
y = vcs->clipping.top;
curw = vcs->clipping.right - vcs->clipping.left;
curh = vcs->clipping.bottom - vcs->clipping.top;
d = max(curw / w, curh / h);
dprintk("scaling w: %d, h: %d, curw: %d, curh: %d, d: %d\n",
w, h, curw, curh, d);
if (d < 1) {
d = 1;
} else if (d > 8) {
d = 8;
}
vcs->decimation = d;
vino_set_clipping(vcs, x, y, w * d, h * d);
dprintk("scaling %d, %d, %d, %d / %d - %d\n", vcs->clipping.left,
vcs->clipping.top, vcs->clipping.right, vcs->clipping.bottom,
vcs->decimation, vcs->line_size);
}
/* execute with input_lock locked */
static inline void vino_set_default_scaling(struct vino_channel_settings *vcs)
{
vino_set_scaling(vcs, vcs->clipping.right - vcs->clipping.left,
vcs->clipping.bottom - vcs->clipping.top);
}
/* execute with input_lock locked */
static void vino_set_framerate(struct vino_channel_settings *vcs,
unsigned int fps)
{
unsigned int mask;
switch (vcs->data_norm) {
case VINO_DATA_NORM_NTSC:
case VINO_DATA_NORM_D1:
fps = (unsigned int)(fps / 6) * 6; // FIXME: round!
if (fps < vino_data_norms[vcs->data_norm].fps_min)
fps = vino_data_norms[vcs->data_norm].fps_min;
if (fps > vino_data_norms[vcs->data_norm].fps_max)
fps = vino_data_norms[vcs->data_norm].fps_max;
switch (fps) {
case 6:
mask = 0x003;
break;
case 12:
mask = 0x0c3;
break;
case 18:
mask = 0x333;
break;
case 24:
mask = 0x3ff;
break;
case 30:
mask = 0xfff;
break;
default:
mask = VINO_FRAMERT_FULL;
}
vcs->framert_reg = VINO_FRAMERT_RT(mask);
break;
case VINO_DATA_NORM_PAL:
case VINO_DATA_NORM_SECAM:
fps = (unsigned int)(fps / 5) * 5; // FIXME: round!
if (fps < vino_data_norms[vcs->data_norm].fps_min)
fps = vino_data_norms[vcs->data_norm].fps_min;
if (fps > vino_data_norms[vcs->data_norm].fps_max)
fps = vino_data_norms[vcs->data_norm].fps_max;
switch (fps) {
case 5:
mask = 0x003;
break;
case 10:
mask = 0x0c3;
break;
case 15:
mask = 0x333;
break;
case 20:
mask = 0x0ff;
break;
case 25:
mask = 0x3ff;
break;
default:
mask = VINO_FRAMERT_FULL;
}
vcs->framert_reg = VINO_FRAMERT_RT(mask) | VINO_FRAMERT_PAL;
break;
}
vcs->fps = fps;
}
/* execute with input_lock locked */
static inline void vino_set_default_framerate(struct
vino_channel_settings *vcs)
{
vino_set_framerate(vcs, vino_data_norms[vcs->data_norm].fps_max);
}
/*
* Prepare VINO for DMA transfer...
* (execute only with vino_lock and input_lock locked)
*/
static int vino_dma_setup(struct vino_channel_settings *vcs,
struct vino_framebuffer *fb)
{
u32 ctrl, intr;
struct sgi_vino_channel *ch;
const struct vino_data_norm *norm;
dprintk("vino_dma_setup():\n");
vcs->field = 0;
fb->frame_counter = 0;
ch = (vcs->channel == VINO_CHANNEL_A) ? &vino->a : &vino->b;
norm = &vino_data_norms[vcs->data_norm];
ch->page_index = 0;
ch->line_count = 0;
/* VINO line size register is set 8 bytes less than actual */
ch->line_size = vcs->line_size - 8;
/* let VINO know where to transfer data */
ch->start_desc_tbl = fb->desc_table.dma;
ch->next_4_desc = fb->desc_table.dma;
/* give vino time to fetch the first four descriptors, 5 usec
* should be more than enough time */
udelay(VINO_DESC_FETCH_DELAY);
dprintk("vino_dma_setup(): start desc = %08x, next 4 desc = %08x\n",
ch->start_desc_tbl, ch->next_4_desc);
/* set the alpha register */
ch->alpha = vcs->alpha;
/* set clipping registers */
ch->clip_start = VINO_CLIP_ODD(norm->odd.top + vcs->clipping.top / 2) |
VINO_CLIP_EVEN(norm->even.top +
vcs->clipping.top / 2) |
VINO_CLIP_X(vcs->clipping.left);
ch->clip_end = VINO_CLIP_ODD(norm->odd.top +
vcs->clipping.bottom / 2 - 1) |
VINO_CLIP_EVEN(norm->even.top +
vcs->clipping.bottom / 2 - 1) |
VINO_CLIP_X(vcs->clipping.right);
/* set the size of actual content in the buffer (DECIMATION !) */
fb->data_size = ((vcs->clipping.right - vcs->clipping.left) /
vcs->decimation) *
((vcs->clipping.bottom - vcs->clipping.top) /
vcs->decimation) *
vino_data_formats[vcs->data_format].bpp;
ch->frame_rate = vcs->framert_reg;
ctrl = vino->control;
intr = vino->intr_status;
if (vcs->channel == VINO_CHANNEL_A) {
/* All interrupt conditions for this channel was cleared
* so clear the interrupt status register and enable
* interrupts */
intr &= ~VINO_INTSTAT_A;
ctrl |= VINO_CTRL_A_INT;
/* enable synchronization */
ctrl |= VINO_CTRL_A_SYNC_ENBL;
/* enable frame assembly */
ctrl |= VINO_CTRL_A_INTERLEAVE_ENBL;
/* set decimation used */
if (vcs->decimation < 2)
ctrl &= ~VINO_CTRL_A_DEC_ENBL;
else {
ctrl |= VINO_CTRL_A_DEC_ENBL;
ctrl &= ~VINO_CTRL_A_DEC_SCALE_MASK;
ctrl |= (vcs->decimation - 1) <<
VINO_CTRL_A_DEC_SCALE_SHIFT;
}
/* select input interface */
if (vcs->input == VINO_INPUT_D1)
ctrl |= VINO_CTRL_A_SELECT;
else
ctrl &= ~VINO_CTRL_A_SELECT;
/* palette */
ctrl &= ~(VINO_CTRL_A_LUMA_ONLY | VINO_CTRL_A_RGB |
VINO_CTRL_A_DITHER);
} else {
intr &= ~VINO_INTSTAT_B;
ctrl |= VINO_CTRL_B_INT;
ctrl |= VINO_CTRL_B_SYNC_ENBL;
ctrl |= VINO_CTRL_B_INTERLEAVE_ENBL;
if (vcs->decimation < 2)
ctrl &= ~VINO_CTRL_B_DEC_ENBL;
else {
ctrl |= VINO_CTRL_B_DEC_ENBL;
ctrl &= ~VINO_CTRL_B_DEC_SCALE_MASK;
ctrl |= (vcs->decimation - 1) <<
VINO_CTRL_B_DEC_SCALE_SHIFT;
}
if (vcs->input == VINO_INPUT_D1)
ctrl |= VINO_CTRL_B_SELECT;
else
ctrl &= ~VINO_CTRL_B_SELECT;
ctrl &= ~(VINO_CTRL_B_LUMA_ONLY | VINO_CTRL_B_RGB |
VINO_CTRL_B_DITHER);
}
/* set palette */
fb->data_format = vcs->data_format;
switch (vcs->data_format) {
case VINO_DATA_FMT_GREY:
ctrl |= (vcs->channel == VINO_CHANNEL_A) ?
VINO_CTRL_A_LUMA_ONLY : VINO_CTRL_B_LUMA_ONLY;
break;
case VINO_DATA_FMT_RGB32:
ctrl |= (vcs->channel == VINO_CHANNEL_A) ?
VINO_CTRL_A_RGB : VINO_CTRL_B_RGB;
break;
case VINO_DATA_FMT_YUV:
/* nothing needs to be done */
break;
case VINO_DATA_FMT_RGB332:
ctrl |= (vcs->channel == VINO_CHANNEL_A) ?
VINO_CTRL_A_RGB | VINO_CTRL_A_DITHER :
VINO_CTRL_B_RGB | VINO_CTRL_B_DITHER;
break;
}
vino->intr_status = intr;
vino->control = ctrl;
return 0;
}
/* (execute only with vino_lock locked) */
static inline void vino_dma_start(struct vino_channel_settings *vcs)
{
u32 ctrl = vino->control;
dprintk("vino_dma_start():\n");
ctrl |= (vcs->channel == VINO_CHANNEL_A) ?
VINO_CTRL_A_DMA_ENBL : VINO_CTRL_B_DMA_ENBL;
vino->control = ctrl;
}
/* (execute only with vino_lock locked) */
static inline void vino_dma_stop(struct vino_channel_settings *vcs)
{
u32 ctrl = vino->control;
ctrl &= (vcs->channel == VINO_CHANNEL_A) ?
~VINO_CTRL_A_DMA_ENBL : ~VINO_CTRL_B_DMA_ENBL;
ctrl &= (vcs->channel == VINO_CHANNEL_A) ?
~VINO_CTRL_A_INT : ~VINO_CTRL_B_INT;
vino->control = ctrl;
dprintk("vino_dma_stop():\n");
}
/*
* Load dummy page to descriptor registers. This prevents generating of
* spurious interrupts. (execute only with vino_lock locked)
*/
static void vino_clear_interrupt(struct vino_channel_settings *vcs)
{
struct sgi_vino_channel *ch;
ch = (vcs->channel == VINO_CHANNEL_A) ? &vino->a : &vino->b;
ch->page_index = 0;
ch->line_count = 0;
ch->start_desc_tbl = vino_drvdata->dummy_desc_table.dma;
ch->next_4_desc = vino_drvdata->dummy_desc_table.dma;
udelay(VINO_DESC_FETCH_DELAY);
dprintk("channel %c clear interrupt condition\n",
(vcs->channel == VINO_CHANNEL_A) ? 'A':'B');
}
static int vino_capture(struct vino_channel_settings *vcs,
struct vino_framebuffer *fb)
{
int err = 0;
unsigned long flags, flags2;
spin_lock_irqsave(&fb->state_lock, flags);
if (fb->state == VINO_FRAMEBUFFER_IN_USE)
err = -EBUSY;
fb->state = VINO_FRAMEBUFFER_IN_USE;
spin_unlock_irqrestore(&fb->state_lock, flags);
if (err)
return err;
spin_lock_irqsave(&vino_drvdata->vino_lock, flags);
spin_lock_irqsave(&vino_drvdata->input_lock, flags2);
vino_dma_setup(vcs, fb);
vino_dma_start(vcs);
spin_unlock_irqrestore(&vino_drvdata->input_lock, flags2);
spin_unlock_irqrestore(&vino_drvdata->vino_lock, flags);
return err;
}
static
struct vino_framebuffer *vino_capture_enqueue(struct
vino_channel_settings *vcs,
unsigned int index)
{
struct vino_framebuffer *fb;
unsigned long flags;
dprintk("vino_capture_enqueue():\n");
spin_lock_irqsave(&vcs->capture_lock, flags);
fb = vino_queue_add(&vcs->fb_queue, index);
if (fb == NULL) {
dprintk("vino_capture_enqueue(): vino_queue_add() failed, "
"queue full?\n");
goto out;
}
out:
spin_unlock_irqrestore(&vcs->capture_lock, flags);
return fb;
}
static int vino_capture_next(struct vino_channel_settings *vcs, int start)
{
struct vino_framebuffer *fb;
unsigned int incoming, id;
int err = 0;
unsigned long flags;
dprintk("vino_capture_next():\n");
spin_lock_irqsave(&vcs->capture_lock, flags);
if (start) {
/* start capture only if capture isn't in progress already */
if (vcs->capturing) {
spin_unlock_irqrestore(&vcs->capture_lock, flags);
return 0;
}
} else {
/* capture next frame:
* stop capture if capturing is not set */
if (!vcs->capturing) {
spin_unlock_irqrestore(&vcs->capture_lock, flags);
return 0;
}
}
err = vino_queue_get_incoming(&vcs->fb_queue, &incoming);
if (err) {
dprintk("vino_capture_next(): vino_queue_get_incoming() "
"failed\n");
err = -EINVAL;
goto out;
}
if (incoming == 0) {
dprintk("vino_capture_next(): no buffers available\n");
goto out;
}
fb = vino_queue_peek(&vcs->fb_queue, &id);
if (fb == NULL) {
dprintk("vino_capture_next(): vino_queue_peek() failed\n");
err = -EINVAL;
goto out;
}
if (start) {
vcs->capturing = 1;
}
spin_unlock_irqrestore(&vcs->capture_lock, flags);
err = vino_capture(vcs, fb);
return err;
out:
vcs->capturing = 0;
spin_unlock_irqrestore(&vcs->capture_lock, flags);
return err;
}
static inline int vino_is_capturing(struct vino_channel_settings *vcs)
{
int ret;
unsigned long flags;
spin_lock_irqsave(&vcs->capture_lock, flags);
ret = vcs->capturing;
spin_unlock_irqrestore(&vcs->capture_lock, flags);
return ret;
}
/* waits until a frame is captured */
static int vino_wait_for_frame(struct vino_channel_settings *vcs)
{
wait_queue_t wait;
int err = 0;
dprintk("vino_wait_for_frame():\n");
init_waitqueue_entry(&wait, current);
/* add ourselves into wait queue */
add_wait_queue(&vcs->fb_queue.frame_wait_queue, &wait);
/* and set current state */
set_current_state(TASK_INTERRUPTIBLE);
/* to ensure that schedule_timeout will return immediately
* if VINO interrupt was triggred meanwhile */
schedule_timeout(HZ / 10);
if (signal_pending(current))
err = -EINTR;
remove_wait_queue(&vcs->fb_queue.frame_wait_queue, &wait);
dprintk("vino_wait_for_frame(): waiting for frame %s\n",
err ? "failed" : "ok");
return err;
}
/* the function assumes that PAGE_SIZE % 4 == 0 */
static void vino_convert_to_rgba(struct vino_framebuffer *fb) {
unsigned char *pageptr;
unsigned int page, i;
unsigned char a;
for (page = 0; page < fb->desc_table.page_count; page++) {
pageptr = (unsigned char *)fb->desc_table.virtual[page];
for (i = 0; i < PAGE_SIZE; i += 4) {
a = pageptr[0];
pageptr[0] = pageptr[3];
pageptr[1] = pageptr[2];
pageptr[2] = pageptr[1];
pageptr[3] = a;
pageptr += 4;
}
}
}
/* checks if the buffer is in correct state and syncs data */
static int vino_check_buffer(struct vino_channel_settings *vcs,
struct vino_framebuffer *fb)
{
int err = 0;
unsigned long flags;
dprintk("vino_check_buffer():\n");
spin_lock_irqsave(&fb->state_lock, flags);
switch (fb->state) {
case VINO_FRAMEBUFFER_IN_USE:
err = -EIO;
break;
case VINO_FRAMEBUFFER_READY:
vino_sync_buffer(fb);
fb->state = VINO_FRAMEBUFFER_UNUSED;
break;
default:
err = -EINVAL;
}
spin_unlock_irqrestore(&fb->state_lock, flags);
if (!err) {
if (vino_pixel_conversion
&& (fb->data_format == VINO_DATA_FMT_RGB32)) {
vino_convert_to_rgba(fb);
}
} else if (err && (err != -EINVAL)) {
dprintk("vino_check_buffer(): buffer not ready\n");
spin_lock_irqsave(&vino_drvdata->vino_lock, flags);
vino_dma_stop(vcs);
vino_clear_interrupt(vcs);
spin_unlock_irqrestore(&vino_drvdata->vino_lock, flags);
}
return err;
}
/* forcefully terminates capture */
static void vino_capture_stop(struct vino_channel_settings *vcs)
{
unsigned int incoming = 0, outgoing = 0, id;
unsigned long flags, flags2;
dprintk("vino_capture_stop():\n");
spin_lock_irqsave(&vcs->capture_lock, flags);
/* unset capturing to stop queue processing */
vcs->capturing = 0;
spin_lock_irqsave(&vino_drvdata->vino_lock, flags2);
vino_dma_stop(vcs);
vino_clear_interrupt(vcs);
spin_unlock_irqrestore(&vino_drvdata->vino_lock, flags2);
/* remove all items from the queue */
if (vino_queue_get_incoming(&vcs->fb_queue, &incoming)) {
dprintk("vino_capture_stop(): "
"vino_queue_get_incoming() failed\n");
goto out;
}
while (incoming > 0) {
vino_queue_transfer(&vcs->fb_queue);
if (vino_queue_get_incoming(&vcs->fb_queue, &incoming)) {
dprintk("vino_capture_stop(): "
"vino_queue_get_incoming() failed\n");
goto out;
}
}
if (vino_queue_get_outgoing(&vcs->fb_queue, &outgoing)) {
dprintk("vino_capture_stop(): "
"vino_queue_get_outgoing() failed\n");
goto out;
}
while (outgoing > 0) {
vino_queue_remove(&vcs->fb_queue, &id);
if (vino_queue_get_outgoing(&vcs->fb_queue, &outgoing)) {
dprintk("vino_capture_stop(): "
"vino_queue_get_outgoing() failed\n");
goto out;
}
}
out:
spin_unlock_irqrestore(&vcs->capture_lock, flags);
}
#if 0
static int vino_capture_failed(struct vino_channel_settings *vcs)
{
struct vino_framebuffer *fb;
unsigned long flags;
unsigned int i;
int ret;
dprintk("vino_capture_failed():\n");
spin_lock_irqsave(&vino_drvdata->vino_lock, flags);
vino_dma_stop(vcs);
vino_clear_interrupt(vcs);
spin_unlock_irqrestore(&vino_drvdata->vino_lock, flags);
ret = vino_queue_get_incoming(&vcs->fb_queue, &i);
if (ret == VINO_QUEUE_ERROR) {
dprintk("vino_queue_get_incoming() failed\n");
return -EINVAL;
}
if (i == 0) {
/* no buffers to process */
return 0;
}
fb = vino_queue_peek(&vcs->fb_queue, &i);
if (fb == NULL) {
dprintk("vino_queue_peek() failed\n");
return -EINVAL;
}
spin_lock_irqsave(&fb->state_lock, flags);
if (fb->state == VINO_FRAMEBUFFER_IN_USE) {
fb->state = VINO_FRAMEBUFFER_UNUSED;
vino_queue_transfer(&vcs->fb_queue);
vino_queue_remove(&vcs->fb_queue, &i);
/* we should actually discard the newest frame,
* but who cares ... */
}
spin_unlock_irqrestore(&fb->state_lock, flags);
return 0;
}
#endif
static void vino_skip_frame(struct vino_channel_settings *vcs)
{
struct vino_framebuffer *fb;
unsigned long flags;
unsigned int id;
spin_lock_irqsave(&vcs->capture_lock, flags);
fb = vino_queue_peek(&vcs->fb_queue, &id);
if (!fb) {
spin_unlock_irqrestore(&vcs->capture_lock, flags);
dprintk("vino_skip_frame(): vino_queue_peek() failed!\n");
return;
}
spin_unlock_irqrestore(&vcs->capture_lock, flags);
spin_lock_irqsave(&fb->state_lock, flags);
fb->state = VINO_FRAMEBUFFER_UNUSED;
spin_unlock_irqrestore(&fb->state_lock, flags);
vino_capture_next(vcs, 0);
}
static void vino_frame_done(struct vino_channel_settings *vcs)
{
struct vino_framebuffer *fb;
unsigned long flags;
spin_lock_irqsave(&vcs->capture_lock, flags);
fb = vino_queue_transfer(&vcs->fb_queue);
if (!fb) {
spin_unlock_irqrestore(&vcs->capture_lock, flags);
dprintk("vino_frame_done(): vino_queue_transfer() failed!\n");
return;
}
spin_unlock_irqrestore(&vcs->capture_lock, flags);
fb->frame_counter = vcs->int_data.frame_counter;
memcpy(&fb->timestamp, &vcs->int_data.timestamp,
sizeof(struct timeval));
spin_lock_irqsave(&fb->state_lock, flags);
if (fb->state == VINO_FRAMEBUFFER_IN_USE)
fb->state = VINO_FRAMEBUFFER_READY;
spin_unlock_irqrestore(&fb->state_lock, flags);
wake_up(&vcs->fb_queue.frame_wait_queue);
vino_capture_next(vcs, 0);
}
static void vino_capture_tasklet(unsigned long channel) {
struct vino_channel_settings *vcs;
vcs = (channel == VINO_CHANNEL_A)
? &vino_drvdata->a : &vino_drvdata->b;
if (vcs->int_data.skip)
vcs->int_data.skip_count++;
if (vcs->int_data.skip && (vcs->int_data.skip_count
<= VINO_MAX_FRAME_SKIP_COUNT)) {
vino_skip_frame(vcs);
} else {
vcs->int_data.skip_count = 0;
vino_frame_done(vcs);
}
}
static irqreturn_t vino_interrupt(int irq, void *dev_id)
{
u32 ctrl, intr;
unsigned int fc_a, fc_b;
int handled_a = 0, skip_a = 0, done_a = 0;
int handled_b = 0, skip_b = 0, done_b = 0;
#ifdef VINO_DEBUG_INT
int loop = 0;
unsigned int line_count = vino->a.line_count,
page_index = vino->a.page_index,
field_counter = vino->a.field_counter,
start_desc_tbl = vino->a.start_desc_tbl,
next_4_desc = vino->a.next_4_desc;
unsigned int line_count_2,
page_index_2,
field_counter_2,
start_desc_tbl_2,
next_4_desc_2;
#endif
spin_lock(&vino_drvdata->vino_lock);
while ((intr = vino->intr_status)) {
fc_a = vino->a.field_counter >> 1;
fc_b = vino->b.field_counter >> 1;
/* handle error-interrupts in some special way ?
* --> skips frames */
if (intr & VINO_INTSTAT_A) {
if (intr & VINO_INTSTAT_A_EOF) {
vino_drvdata->a.field++;
if (vino_drvdata->a.field > 1) {
vino_dma_stop(&vino_drvdata->a);
vino_clear_interrupt(&vino_drvdata->a);
vino_drvdata->a.field = 0;
done_a = 1;
} else {
if (vino->a.page_index
!= vino_drvdata->a.line_size) {
vino->a.line_count = 0;
vino->a.page_index =
vino_drvdata->
a.line_size;
vino->a.next_4_desc =
vino->a.start_desc_tbl;
}
}
dprintk("channel A end-of-field "
"interrupt: %04x\n", intr);
} else {
vino_dma_stop(&vino_drvdata->a);
vino_clear_interrupt(&vino_drvdata->a);
vino_drvdata->a.field = 0;
skip_a = 1;
dprintk("channel A error interrupt: %04x\n",
intr);
}
#ifdef VINO_DEBUG_INT
line_count_2 = vino->a.line_count;
page_index_2 = vino->a.page_index;
field_counter_2 = vino->a.field_counter;
start_desc_tbl_2 = vino->a.start_desc_tbl;
next_4_desc_2 = vino->a.next_4_desc;
printk("intr = %04x, loop = %d, field = %d\n",
intr, loop, vino_drvdata->a.field);
printk("1- line count = %04d, page index = %04d, "
"start = %08x, next = %08x\n"
" fieldc = %d, framec = %d\n",
line_count, page_index, start_desc_tbl,
next_4_desc, field_counter, fc_a);
printk("12-line count = %04d, page index = %04d, "
" start = %08x, next = %08x\n",
line_count_2, page_index_2, start_desc_tbl_2,
next_4_desc_2);
if (done_a)
printk("\n");
#endif
}
if (intr & VINO_INTSTAT_B) {
if (intr & VINO_INTSTAT_B_EOF) {
vino_drvdata->b.field++;
if (vino_drvdata->b.field > 1) {
vino_dma_stop(&vino_drvdata->b);
vino_clear_interrupt(&vino_drvdata->b);
vino_drvdata->b.field = 0;
done_b = 1;
}
dprintk("channel B end-of-field "
"interrupt: %04x\n", intr);
} else {
vino_dma_stop(&vino_drvdata->b);
vino_clear_interrupt(&vino_drvdata->b);
vino_drvdata->b.field = 0;
skip_b = 1;
dprintk("channel B error interrupt: %04x\n",
intr);
}
}
/* Always remember to clear interrupt status.
* Disable VINO interrupts while we do this. */
ctrl = vino->control;
vino->control = ctrl & ~(VINO_CTRL_A_INT | VINO_CTRL_B_INT);
vino->intr_status = ~intr;
vino->control = ctrl;
spin_unlock(&vino_drvdata->vino_lock);
if ((!handled_a) && (done_a || skip_a)) {
if (!skip_a) {
do_gettimeofday(&vino_drvdata->
a.int_data.timestamp);
vino_drvdata->a.int_data.frame_counter = fc_a;
}
vino_drvdata->a.int_data.skip = skip_a;
dprintk("channel A %s, interrupt: %d\n",
skip_a ? "skipping frame" : "frame done",
intr);
tasklet_hi_schedule(&vino_tasklet_a);
handled_a = 1;
}
if ((!handled_b) && (done_b || skip_b)) {
if (!skip_b) {
do_gettimeofday(&vino_drvdata->
b.int_data.timestamp);
vino_drvdata->b.int_data.frame_counter = fc_b;
}
vino_drvdata->b.int_data.skip = skip_b;
dprintk("channel B %s, interrupt: %d\n",
skip_b ? "skipping frame" : "frame done",
intr);
tasklet_hi_schedule(&vino_tasklet_b);
handled_b = 1;
}
#ifdef VINO_DEBUG_INT
loop++;
#endif
spin_lock(&vino_drvdata->vino_lock);
}
spin_unlock(&vino_drvdata->vino_lock);
return IRQ_HANDLED;
}
/* VINO video input management */
static int vino_get_saa7191_input(int input)
{
switch (input) {
case VINO_INPUT_COMPOSITE:
return SAA7191_INPUT_COMPOSITE;
case VINO_INPUT_SVIDEO:
return SAA7191_INPUT_SVIDEO;
default:
printk(KERN_ERR "VINO: vino_get_saa7191_input(): "
"invalid input!\n");
return -1;
}
}
static int vino_get_saa7191_norm(unsigned int data_norm)
{
switch (data_norm) {
case VINO_DATA_NORM_AUTO:
return SAA7191_NORM_AUTO;
case VINO_DATA_NORM_AUTO_EXT:
return SAA7191_NORM_AUTO_EXT;
case VINO_DATA_NORM_PAL:
return SAA7191_NORM_PAL;
case VINO_DATA_NORM_NTSC:
return SAA7191_NORM_NTSC;
case VINO_DATA_NORM_SECAM:
return SAA7191_NORM_SECAM;
default:
printk(KERN_ERR "VINO: vino_get_saa7191_norm(): "
"invalid norm!\n");
return -1;
}
}
static int vino_get_from_saa7191_norm(int saa7191_norm)
{
switch (saa7191_norm) {
case SAA7191_NORM_PAL:
return VINO_DATA_NORM_PAL;
case SAA7191_NORM_NTSC:
return VINO_DATA_NORM_NTSC;
case SAA7191_NORM_SECAM:
return VINO_DATA_NORM_SECAM;
default:
printk(KERN_ERR "VINO: vino_get_from_saa7191_norm(): "
"invalid norm!\n");
return VINO_DATA_NORM_NONE;
}
}
static int vino_saa7191_set_norm(unsigned int *data_norm)
{
int saa7191_norm, new_data_norm;
int err = 0;
saa7191_norm = vino_get_saa7191_norm(*data_norm);
err = i2c_decoder_command(DECODER_SAA7191_SET_NORM,
&saa7191_norm);
if (err)
goto out;
if ((*data_norm == VINO_DATA_NORM_AUTO)
|| (*data_norm == VINO_DATA_NORM_AUTO_EXT)) {
struct saa7191_status status;
err = i2c_decoder_command(DECODER_SAA7191_GET_STATUS,
&status);
if (err)
goto out;
new_data_norm =
vino_get_from_saa7191_norm(status.norm);
if (new_data_norm == VINO_DATA_NORM_NONE) {
err = -EINVAL;
goto out;
}
*data_norm = (unsigned int)new_data_norm;
}
out:
return err;
}
/* execute with input_lock locked */
static int vino_is_input_owner(struct vino_channel_settings *vcs)
{
switch(vcs->input) {
case VINO_INPUT_COMPOSITE:
case VINO_INPUT_SVIDEO:
return (vino_drvdata->decoder.owner == vcs->channel);
case VINO_INPUT_D1:
return (vino_drvdata->camera.owner == vcs->channel);
default:
return 0;
}
}
static int vino_acquire_input(struct vino_channel_settings *vcs)
{
unsigned long flags;
int ret = 0;
dprintk("vino_acquire_input():\n");
spin_lock_irqsave(&vino_drvdata->input_lock, flags);
/* First try D1 and then SAA7191 */
if (vino_drvdata->camera.driver
&& (vino_drvdata->camera.owner == VINO_NO_CHANNEL)) {
if (i2c_use_client(vino_drvdata->camera.driver)) {
ret = -ENODEV;
goto out;
}
vino_drvdata->camera.owner = vcs->channel;
vcs->input = VINO_INPUT_D1;
vcs->data_norm = VINO_DATA_NORM_D1;
} else if (vino_drvdata->decoder.driver
&& (vino_drvdata->decoder.owner == VINO_NO_CHANNEL)) {
int input, data_norm;
int saa7191_input;
if (i2c_use_client(vino_drvdata->decoder.driver)) {
ret = -ENODEV;
goto out;
}
input = VINO_INPUT_COMPOSITE;
saa7191_input = vino_get_saa7191_input(input);
ret = i2c_decoder_command(DECODER_SET_INPUT,
&saa7191_input);
if (ret) {
ret = -EINVAL;
goto out;
}
spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
/* Don't hold spinlocks while auto-detecting norm
* as it may take a while... */
data_norm = VINO_DATA_NORM_AUTO_EXT;
ret = vino_saa7191_set_norm(&data_norm);
if ((ret == -EBUSY) || (ret == -EAGAIN)) {
data_norm = VINO_DATA_NORM_PAL;
ret = vino_saa7191_set_norm(&data_norm);
}
spin_lock_irqsave(&vino_drvdata->input_lock, flags);
if (ret) {
ret = -EINVAL;
goto out;
}
vino_drvdata->decoder.owner = vcs->channel;
vcs->input = input;
vcs->data_norm = data_norm;
} else {
vcs->input = (vcs->channel == VINO_CHANNEL_A) ?
vino_drvdata->b.input : vino_drvdata->a.input;
vcs->data_norm = (vcs->channel == VINO_CHANNEL_A) ?
vino_drvdata->b.data_norm : vino_drvdata->a.data_norm;
}
if (vcs->input == VINO_INPUT_NONE) {
ret = -ENODEV;
goto out;
}
vino_set_default_clipping(vcs);
vino_set_default_scaling(vcs);
vino_set_default_framerate(vcs);
dprintk("vino_acquire_input(): %s\n", vino_inputs[vcs->input].name);
out:
spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
return ret;
}
static int vino_set_input(struct vino_channel_settings *vcs, int input)
{
struct vino_channel_settings *vcs2 = (vcs->channel == VINO_CHANNEL_A) ?
&vino_drvdata->b : &vino_drvdata->a;
unsigned long flags;
int ret = 0;
dprintk("vino_set_input():\n");
spin_lock_irqsave(&vino_drvdata->input_lock, flags);
if (vcs->input == input)
goto out;
switch (input) {
case VINO_INPUT_COMPOSITE:
case VINO_INPUT_SVIDEO:
if (!vino_drvdata->decoder.driver) {
ret = -EINVAL;
goto out;
}
if (vino_drvdata->decoder.owner == VINO_NO_CHANNEL) {
if (i2c_use_client(vino_drvdata->decoder.driver)) {
ret = -ENODEV;
goto out;
}
vino_drvdata->decoder.owner = vcs->channel;
}
if (vino_drvdata->decoder.owner == vcs->channel) {
int data_norm;
int saa7191_input;
saa7191_input = vino_get_saa7191_input(input);
ret = i2c_decoder_command(DECODER_SET_INPUT,
&saa7191_input);
if (ret) {
vino_drvdata->decoder.owner = VINO_NO_CHANNEL;
ret = -EINVAL;
goto out;
}
spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
/* Don't hold spinlocks while auto-detecting norm
* as it may take a while... */
data_norm = VINO_DATA_NORM_AUTO_EXT;
ret = vino_saa7191_set_norm(&data_norm);
if ((ret == -EBUSY) || (ret == -EAGAIN)) {
data_norm = VINO_DATA_NORM_PAL;
ret = vino_saa7191_set_norm(&data_norm);
}
spin_lock_irqsave(&vino_drvdata->input_lock, flags);
if (ret) {
vino_drvdata->decoder.owner = VINO_NO_CHANNEL;
ret = -EINVAL;
goto out;
}
vcs->input = input;
vcs->data_norm = data_norm;
} else {
if (input != vcs2->input) {
ret = -EBUSY;
goto out;
}
vcs->input = input;
vcs->data_norm = vcs2->data_norm;
}
if (vino_drvdata->camera.owner == vcs->channel) {
/* Transfer the ownership or release the input */
if (vcs2->input == VINO_INPUT_D1) {
vino_drvdata->camera.owner = vcs2->channel;
} else {
i2c_release_client(vino_drvdata->
camera.driver);
vino_drvdata->camera.owner = VINO_NO_CHANNEL;
}
}
break;
case VINO_INPUT_D1:
if (!vino_drvdata->camera.driver) {
ret = -EINVAL;
goto out;
}
if (vino_drvdata->camera.owner == VINO_NO_CHANNEL) {
if (i2c_use_client(vino_drvdata->camera.driver)) {
ret = -ENODEV;
goto out;
}
vino_drvdata->camera.owner = vcs->channel;
}
if (vino_drvdata->decoder.owner == vcs->channel) {
/* Transfer the ownership or release the input */
if ((vcs2->input == VINO_INPUT_COMPOSITE) ||
(vcs2->input == VINO_INPUT_SVIDEO)) {
vino_drvdata->decoder.owner = vcs2->channel;
} else {
i2c_release_client(vino_drvdata->
decoder.driver);
vino_drvdata->decoder.owner = VINO_NO_CHANNEL;
}
}
vcs->input = input;
vcs->data_norm = VINO_DATA_NORM_D1;
break;
default:
ret = -EINVAL;
goto out;
}
vino_set_default_clipping(vcs);
vino_set_default_scaling(vcs);
vino_set_default_framerate(vcs);
dprintk("vino_set_input(): %s\n", vino_inputs[vcs->input].name);
out:
spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
return ret;
}
static void vino_release_input(struct vino_channel_settings *vcs)
{
struct vino_channel_settings *vcs2 = (vcs->channel == VINO_CHANNEL_A) ?
&vino_drvdata->b : &vino_drvdata->a;
unsigned long flags;
dprintk("vino_release_input():\n");
spin_lock_irqsave(&vino_drvdata->input_lock, flags);
/* Release ownership of the channel
* and if the other channel takes input from
* the same source, transfer the ownership */
if (vino_drvdata->camera.owner == vcs->channel) {
if (vcs2->input == VINO_INPUT_D1) {
vino_drvdata->camera.owner = vcs2->channel;
} else {
i2c_release_client(vino_drvdata->camera.driver);
vino_drvdata->camera.owner = VINO_NO_CHANNEL;
}
} else if (vino_drvdata->decoder.owner == vcs->channel) {
if ((vcs2->input == VINO_INPUT_COMPOSITE) ||
(vcs2->input == VINO_INPUT_SVIDEO)) {
vino_drvdata->decoder.owner = vcs2->channel;
} else {
i2c_release_client(vino_drvdata->decoder.driver);
vino_drvdata->decoder.owner = VINO_NO_CHANNEL;
}
}
vcs->input = VINO_INPUT_NONE;
spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
}
/* execute with input_lock locked */
static int vino_set_data_norm(struct vino_channel_settings *vcs,
unsigned int data_norm,
unsigned long *flags)
{
int err = 0;
if (data_norm == vcs->data_norm)
return 0;
switch (vcs->input) {
case VINO_INPUT_D1:
/* only one "norm" supported */
if ((data_norm != VINO_DATA_NORM_D1)
&& (data_norm != VINO_DATA_NORM_AUTO)
&& (data_norm != VINO_DATA_NORM_AUTO_EXT))
return -EINVAL;
break;
case VINO_INPUT_COMPOSITE:
case VINO_INPUT_SVIDEO: {
if ((data_norm != VINO_DATA_NORM_PAL)
&& (data_norm != VINO_DATA_NORM_NTSC)
&& (data_norm != VINO_DATA_NORM_SECAM)
&& (data_norm != VINO_DATA_NORM_AUTO)
&& (data_norm != VINO_DATA_NORM_AUTO_EXT))
return -EINVAL;
spin_unlock_irqrestore(&vino_drvdata->input_lock, *flags);
/* Don't hold spinlocks while setting norm
* as it may take a while... */
err = vino_saa7191_set_norm(&data_norm);
spin_lock_irqsave(&vino_drvdata->input_lock, *flags);
if (err)
goto out;
vcs->data_norm = data_norm;
vino_set_default_clipping(vcs);
vino_set_default_scaling(vcs);
vino_set_default_framerate(vcs);
break;
}
default:
return -EINVAL;
}
out:
return err;
}
/* V4L2 helper functions */
static int vino_find_data_format(__u32 pixelformat)
{
int i;
for (i = 0; i < VINO_DATA_FMT_COUNT; i++) {
if (vino_data_formats[i].pixelformat == pixelformat)
return i;
}
return VINO_DATA_FMT_NONE;
}
static int vino_enum_data_norm(struct vino_channel_settings *vcs, __u32 index)
{
int data_norm = VINO_DATA_NORM_NONE;
unsigned long flags;
spin_lock_irqsave(&vino_drvdata->input_lock, flags);
switch(vcs->input) {
case VINO_INPUT_COMPOSITE:
case VINO_INPUT_SVIDEO:
if (index == 0) {
data_norm = VINO_DATA_NORM_PAL;
} else if (index == 1) {
data_norm = VINO_DATA_NORM_NTSC;
} else if (index == 2) {
data_norm = VINO_DATA_NORM_SECAM;
}
break;
case VINO_INPUT_D1:
if (index == 0) {
data_norm = VINO_DATA_NORM_D1;
}
break;
}
spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
return data_norm;
}
static int vino_enum_input(struct vino_channel_settings *vcs, __u32 index)
{
int input = VINO_INPUT_NONE;
unsigned long flags;
spin_lock_irqsave(&vino_drvdata->input_lock, flags);
if (vino_drvdata->decoder.driver && vino_drvdata->camera.driver) {
switch (index) {
case 0:
input = VINO_INPUT_COMPOSITE;
break;
case 1:
input = VINO_INPUT_SVIDEO;
break;
case 2:
input = VINO_INPUT_D1;
break;
}
} else if (vino_drvdata->decoder.driver) {
switch (index) {
case 0:
input = VINO_INPUT_COMPOSITE;
break;
case 1:
input = VINO_INPUT_SVIDEO;
break;
}
} else if (vino_drvdata->camera.driver) {
switch (index) {
case 0:
input = VINO_INPUT_D1;
break;
}
}
spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
return input;
}
/* execute with input_lock locked */
static __u32 vino_find_input_index(struct vino_channel_settings *vcs)
{
__u32 index = 0;
// FIXME: detect when no inputs available
if (vino_drvdata->decoder.driver && vino_drvdata->camera.driver) {
switch (vcs->input) {
case VINO_INPUT_COMPOSITE:
index = 0;
break;
case VINO_INPUT_SVIDEO:
index = 1;
break;
case VINO_INPUT_D1:
index = 2;
break;
}
} else if (vino_drvdata->decoder.driver) {
switch (vcs->input) {
case VINO_INPUT_COMPOSITE:
index = 0;
break;
case VINO_INPUT_SVIDEO:
index = 1;
break;
}
} else if (vino_drvdata->camera.driver) {
switch (vcs->input) {
case VINO_INPUT_D1:
index = 0;
break;
}
}
return index;
}
/* V4L2 ioctls */
static void vino_v4l2_querycap(struct v4l2_capability *cap)
{
memset(cap, 0, sizeof(struct v4l2_capability));
strcpy(cap->driver, vino_driver_name);
strcpy(cap->card, vino_driver_description);
strcpy(cap->bus_info, vino_bus_name);
cap->version = VINO_VERSION_CODE;
cap->capabilities =
V4L2_CAP_VIDEO_CAPTURE |
V4L2_CAP_STREAMING;
// V4L2_CAP_OVERLAY, V4L2_CAP_READWRITE
}
static int vino_v4l2_enuminput(struct vino_channel_settings *vcs,
struct v4l2_input *i)
{
__u32 index = i->index;
int input;
dprintk("requested index = %d\n", index);
input = vino_enum_input(vcs, index);
if (input == VINO_INPUT_NONE)
return -EINVAL;
memset(i, 0, sizeof(struct v4l2_input));
i->index = index;
i->type = V4L2_INPUT_TYPE_CAMERA;
i->std = vino_inputs[input].std;
strcpy(i->name, vino_inputs[input].name);
if ((input == VINO_INPUT_COMPOSITE)
|| (input == VINO_INPUT_SVIDEO)) {
struct saa7191_status status;
i2c_decoder_command(DECODER_SAA7191_GET_STATUS, &status);
i->status |= status.signal ? 0 : V4L2_IN_ST_NO_SIGNAL;
i->status |= status.color ? 0 : V4L2_IN_ST_NO_COLOR;
}
return 0;
}
static int vino_v4l2_g_input(struct vino_channel_settings *vcs,
unsigned int *i)
{
__u32 index;
int input;
unsigned long flags;
spin_lock_irqsave(&vino_drvdata->input_lock, flags);
input = vcs->input;
index = vino_find_input_index(vcs);
spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
dprintk("input = %d\n", input);
if (input == VINO_INPUT_NONE) {
return -EINVAL;
}
*i = index;
return 0;
}
static int vino_v4l2_s_input(struct vino_channel_settings *vcs,
unsigned int *i)
{
int input;
dprintk("requested input = %d\n", *i);
input = vino_enum_input(vcs, *i);
if (input == VINO_INPUT_NONE)
return -EINVAL;
return vino_set_input(vcs, input);
}
static int vino_v4l2_enumstd(struct vino_channel_settings *vcs,
struct v4l2_standard *s)
{
int index = s->index;
int data_norm;
data_norm = vino_enum_data_norm(vcs, index);
dprintk("standard index = %d\n", index);
if (data_norm == VINO_DATA_NORM_NONE)
return -EINVAL;
dprintk("standard name = %s\n",
vino_data_norms[data_norm].description);
memset(s, 0, sizeof(struct v4l2_standard));
s->index = index;
s->id = vino_data_norms[data_norm].std;
s->frameperiod.numerator = 1;
s->frameperiod.denominator =
vino_data_norms[data_norm].fps_max;
s->framelines =
vino_data_norms[data_norm].framelines;
strcpy(s->name,
vino_data_norms[data_norm].description);
return 0;
}
static int vino_v4l2_querystd(struct vino_channel_settings *vcs,
v4l2_std_id *std)
{
unsigned long flags;
int err = 0;
spin_lock_irqsave(&vino_drvdata->input_lock, flags);
switch (vcs->input) {
case VINO_INPUT_D1:
*std = vino_inputs[vcs->input].std;
break;
case VINO_INPUT_COMPOSITE:
case VINO_INPUT_SVIDEO: {
struct saa7191_status status;
i2c_decoder_command(DECODER_SAA7191_GET_STATUS, &status);
if (status.signal) {
if (status.signal_60hz) {
*std = V4L2_STD_NTSC;
} else {
*std = V4L2_STD_PAL | V4L2_STD_SECAM;
}
} else {
*std = vino_inputs[vcs->input].std;
}
break;
}
default:
err = -EINVAL;
}
spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
return err;
}
static int vino_v4l2_g_std(struct vino_channel_settings *vcs,
v4l2_std_id *std)
{
unsigned long flags;
spin_lock_irqsave(&vino_drvdata->input_lock, flags);
*std = vino_data_norms[vcs->data_norm].std;
dprintk("current standard = %d\n", vcs->data_norm);
spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
return 0;
}
static int vino_v4l2_s_std(struct vino_channel_settings *vcs,
v4l2_std_id *std)
{
unsigned long flags;
int ret = 0;
spin_lock_irqsave(&vino_drvdata->input_lock, flags);
if (!vino_is_input_owner(vcs)) {
ret = -EBUSY;
goto out;
}
/* check if the standard is valid for the current input */
if ((*std) & vino_inputs[vcs->input].std) {
dprintk("standard accepted\n");
/* change the video norm for SAA7191
* and accept NTSC for D1 (do nothing) */
if (vcs->input == VINO_INPUT_D1)
goto out;
if (((*std) & V4L2_STD_PAL)
&& ((*std) & V4L2_STD_NTSC)
&& ((*std) & V4L2_STD_SECAM)) {
ret = vino_set_data_norm(vcs, VINO_DATA_NORM_AUTO_EXT,
&flags);
} else if ((*std) & V4L2_STD_PAL) {
ret = vino_set_data_norm(vcs, VINO_DATA_NORM_PAL,
&flags);
} else if ((*std) & V4L2_STD_NTSC) {
ret = vino_set_data_norm(vcs, VINO_DATA_NORM_NTSC,
&flags);
} else if ((*std) & V4L2_STD_SECAM) {
ret = vino_set_data_norm(vcs, VINO_DATA_NORM_SECAM,
&flags);
} else {
ret = -EINVAL;
}
if (ret) {
ret = -EINVAL;
}
} else {
ret = -EINVAL;
}
out:
spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
return ret;
}
static int vino_v4l2_enum_fmt(struct vino_channel_settings *vcs,
struct v4l2_fmtdesc *fd)
{
enum v4l2_buf_type type = fd->type;
int index = fd->index;
dprintk("format index = %d\n", index);
switch (fd->type) {
case V4L2_BUF_TYPE_VIDEO_CAPTURE:
if ((fd->index < 0) ||
(fd->index >= VINO_DATA_FMT_COUNT))
return -EINVAL;
dprintk("format name = %s\n",
vino_data_formats[index].description);
memset(fd, 0, sizeof(struct v4l2_fmtdesc));
fd->index = index;
fd->type = type;
fd->pixelformat = vino_data_formats[index].pixelformat;
strcpy(fd->description, vino_data_formats[index].description);
break;
case V4L2_BUF_TYPE_VIDEO_OVERLAY:
default:
return -EINVAL;
}
return 0;
}
static int vino_v4l2_try_fmt(struct vino_channel_settings *vcs,
struct v4l2_format *f)
{
struct vino_channel_settings tempvcs;
unsigned long flags;
switch (f->type) {
case V4L2_BUF_TYPE_VIDEO_CAPTURE: {
struct v4l2_pix_format *pf = &f->fmt.pix;
dprintk("requested: w = %d, h = %d\n",
pf->width, pf->height);
spin_lock_irqsave(&vino_drvdata->input_lock, flags);
memcpy(&tempvcs, vcs, sizeof(struct vino_channel_settings));
spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
tempvcs.data_format = vino_find_data_format(pf->pixelformat);
if (tempvcs.data_format == VINO_DATA_FMT_NONE) {
tempvcs.data_format = VINO_DATA_FMT_GREY;
pf->pixelformat =
vino_data_formats[tempvcs.data_format].
pixelformat;
}
/* data format must be set before clipping/scaling */
vino_set_scaling(&tempvcs, pf->width, pf->height);
dprintk("data format = %s\n",
vino_data_formats[tempvcs.data_format].description);
pf->width = (tempvcs.clipping.right - tempvcs.clipping.left) /
tempvcs.decimation;
pf->height = (tempvcs.clipping.bottom - tempvcs.clipping.top) /
tempvcs.decimation;
pf->field = V4L2_FIELD_INTERLACED;
pf->bytesperline = tempvcs.line_size;
pf->sizeimage = tempvcs.line_size *
(tempvcs.clipping.bottom - tempvcs.clipping.top) /
tempvcs.decimation;
pf->colorspace =
vino_data_formats[tempvcs.data_format].colorspace;
pf->priv = 0;
break;
}
case V4L2_BUF_TYPE_VIDEO_OVERLAY:
default:
return -EINVAL;
}
return 0;
}
static int vino_v4l2_g_fmt(struct vino_channel_settings *vcs,
struct v4l2_format *f)
{
unsigned long flags;
switch (f->type) {
case V4L2_BUF_TYPE_VIDEO_CAPTURE: {
struct v4l2_pix_format *pf = &f->fmt.pix;
spin_lock_irqsave(&vino_drvdata->input_lock, flags);
pf->width = (vcs->clipping.right - vcs->clipping.left) /
vcs->decimation;
pf->height = (vcs->clipping.bottom - vcs->clipping.top) /
vcs->decimation;
pf->pixelformat =
vino_data_formats[vcs->data_format].pixelformat;
pf->field = V4L2_FIELD_INTERLACED;
pf->bytesperline = vcs->line_size;
pf->sizeimage = vcs->line_size *
(vcs->clipping.bottom - vcs->clipping.top) /
vcs->decimation;
pf->colorspace =
vino_data_formats[vcs->data_format].colorspace;
pf->priv = 0;
spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
break;
}
case V4L2_BUF_TYPE_VIDEO_OVERLAY:
default:
return -EINVAL;
}
return 0;
}
static int vino_v4l2_s_fmt(struct vino_channel_settings *vcs,
struct v4l2_format *f)
{
int data_format;
unsigned long flags;
switch (f->type) {
case V4L2_BUF_TYPE_VIDEO_CAPTURE: {
struct v4l2_pix_format *pf = &f->fmt.pix;
spin_lock_irqsave(&vino_drvdata->input_lock, flags);
data_format = vino_find_data_format(pf->pixelformat);
if (data_format == VINO_DATA_FMT_NONE) {
vcs->data_format = VINO_DATA_FMT_GREY;
pf->pixelformat =
vino_data_formats[vcs->data_format].
pixelformat;
} else {
vcs->data_format = data_format;
}
/* data format must be set before clipping/scaling */
vino_set_scaling(vcs, pf->width, pf->height);
dprintk("data format = %s\n",
vino_data_formats[vcs->data_format].description);
pf->width = vcs->clipping.right - vcs->clipping.left;
pf->height = vcs->clipping.bottom - vcs->clipping.top;
pf->field = V4L2_FIELD_INTERLACED;
pf->bytesperline = vcs->line_size;
pf->sizeimage = vcs->line_size *
(vcs->clipping.bottom - vcs->clipping.top) /
vcs->decimation;
pf->colorspace =
vino_data_formats[vcs->data_format].colorspace;
pf->priv = 0;
spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
break;
}
case V4L2_BUF_TYPE_VIDEO_OVERLAY:
default:
return -EINVAL;
}
return 0;
}
static int vino_v4l2_cropcap(struct vino_channel_settings *vcs,
struct v4l2_cropcap *ccap)
{
const struct vino_data_norm *norm;
unsigned long flags;
switch (ccap->type) {
case V4L2_BUF_TYPE_VIDEO_CAPTURE:
spin_lock_irqsave(&vino_drvdata->input_lock, flags);
norm = &vino_data_norms[vcs->data_norm];
spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
ccap->bounds.left = 0;
ccap->bounds.top = 0;
ccap->bounds.width = norm->width;
ccap->bounds.height = norm->height;
memcpy(&ccap->defrect, &ccap->bounds,
sizeof(struct v4l2_rect));
ccap->pixelaspect.numerator = 1;
ccap->pixelaspect.denominator = 1;
break;
case V4L2_BUF_TYPE_VIDEO_OVERLAY:
default:
return -EINVAL;
}
return 0;
}
static int vino_v4l2_g_crop(struct vino_channel_settings *vcs,
struct v4l2_crop *c)
{
unsigned long flags;
switch (c->type) {
case V4L2_BUF_TYPE_VIDEO_CAPTURE:
spin_lock_irqsave(&vino_drvdata->input_lock, flags);
c->c.left = vcs->clipping.left;
c->c.top = vcs->clipping.top;
c->c.width = vcs->clipping.right - vcs->clipping.left;
c->c.height = vcs->clipping.bottom - vcs->clipping.top;
spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
break;
case V4L2_BUF_TYPE_VIDEO_OVERLAY:
default:
return -EINVAL;
}
return 0;
}
static int vino_v4l2_s_crop(struct vino_channel_settings *vcs,
struct v4l2_crop *c)
{
unsigned long flags;
switch (c->type) {
case V4L2_BUF_TYPE_VIDEO_CAPTURE:
spin_lock_irqsave(&vino_drvdata->input_lock, flags);
vino_set_clipping(vcs, c->c.left, c->c.top,
c->c.width, c->c.height);
spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
break;
case V4L2_BUF_TYPE_VIDEO_OVERLAY:
default:
return -EINVAL;
}
return 0;
}
static int vino_v4l2_g_parm(struct vino_channel_settings *vcs,
struct v4l2_streamparm *sp)
{
unsigned long flags;
switch (sp->type) {
case V4L2_BUF_TYPE_VIDEO_CAPTURE: {
struct v4l2_captureparm *cp = &sp->parm.capture;
memset(cp, 0, sizeof(struct v4l2_captureparm));
cp->capability = V4L2_CAP_TIMEPERFRAME;
cp->timeperframe.numerator = 1;
spin_lock_irqsave(&vino_drvdata->input_lock, flags);
cp->timeperframe.denominator = vcs->fps;
spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
// TODO: cp->readbuffers = xxx;
break;
}
case V4L2_BUF_TYPE_VIDEO_OVERLAY:
default:
return -EINVAL;
}
return 0;
}
static int vino_v4l2_s_parm(struct vino_channel_settings *vcs,
struct v4l2_streamparm *sp)
{
unsigned long flags;
switch (sp->type) {
case V4L2_BUF_TYPE_VIDEO_CAPTURE: {
struct v4l2_captureparm *cp = &sp->parm.capture;
spin_lock_irqsave(&vino_drvdata->input_lock, flags);
if ((cp->timeperframe.numerator == 0) ||
(cp->timeperframe.denominator == 0)) {
/* reset framerate */
vino_set_default_framerate(vcs);
} else {
vino_set_framerate(vcs, cp->timeperframe.denominator /
cp->timeperframe.numerator);
}
spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
// TODO: set buffers according to cp->readbuffers
break;
}
case V4L2_BUF_TYPE_VIDEO_OVERLAY:
default:
return -EINVAL;
}
return 0;
}
static int vino_v4l2_reqbufs(struct vino_channel_settings *vcs,
struct v4l2_requestbuffers *rb)
{
if (vcs->reading)
return -EBUSY;
switch (rb->type) {
case V4L2_BUF_TYPE_VIDEO_CAPTURE: {
// TODO: check queue type
if (rb->memory != V4L2_MEMORY_MMAP) {
dprintk("type not mmap\n");
return -EINVAL;
}
dprintk("count = %d\n", rb->count);
if (rb->count > 0) {
if (vino_is_capturing(vcs)) {
dprintk("busy, capturing\n");
return -EBUSY;
}
if (vino_queue_has_mapped_buffers(&vcs->fb_queue)) {
dprintk("busy, buffers still mapped\n");
return -EBUSY;
} else {
vcs->streaming = 0;
vino_queue_free(&vcs->fb_queue);
vino_queue_init(&vcs->fb_queue, &rb->count);
}
} else {
vcs->streaming = 0;
vino_capture_stop(vcs);
vino_queue_free(&vcs->fb_queue);
}
break;
}
case V4L2_BUF_TYPE_VIDEO_OVERLAY:
default:
return -EINVAL;
}
return 0;
}
static void vino_v4l2_get_buffer_status(struct vino_channel_settings *vcs,
struct vino_framebuffer *fb,
struct v4l2_buffer *b)
{
if (vino_queue_outgoing_contains(&vcs->fb_queue,
fb->id)) {
b->flags &= ~V4L2_BUF_FLAG_QUEUED;
b->flags |= V4L2_BUF_FLAG_DONE;
} else if (vino_queue_incoming_contains(&vcs->fb_queue,
fb->id)) {
b->flags &= ~V4L2_BUF_FLAG_DONE;
b->flags |= V4L2_BUF_FLAG_QUEUED;
} else {
b->flags &= ~(V4L2_BUF_FLAG_DONE |
V4L2_BUF_FLAG_QUEUED);
}
b->flags &= ~(V4L2_BUF_FLAG_TIMECODE);
if (fb->map_count > 0)
b->flags |= V4L2_BUF_FLAG_MAPPED;
b->index = fb->id;
b->memory = (vcs->fb_queue.type == VINO_MEMORY_MMAP) ?
V4L2_MEMORY_MMAP : V4L2_MEMORY_USERPTR;
b->m.offset = fb->offset;
b->bytesused = fb->data_size;
b->length = fb->size;
b->field = V4L2_FIELD_INTERLACED;
b->sequence = fb->frame_counter;
memcpy(&b->timestamp, &fb->timestamp,
sizeof(struct timeval));
// b->input ?
dprintk("buffer %d: length = %d, bytesused = %d, offset = %d\n",
fb->id, fb->size, fb->data_size, fb->offset);
}
static int vino_v4l2_querybuf(struct vino_channel_settings *vcs,
struct v4l2_buffer *b)
{
if (vcs->reading)
return -EBUSY;
switch (b->type) {
case V4L2_BUF_TYPE_VIDEO_CAPTURE: {
struct vino_framebuffer *fb;
// TODO: check queue type
if (b->index >= vino_queue_get_length(&vcs->fb_queue)) {
dprintk("invalid index = %d\n",
b->index);
return -EINVAL;
}
fb = vino_queue_get_buffer(&vcs->fb_queue,
b->index);
if (fb == NULL) {
dprintk("vino_queue_get_buffer() failed");
return -EINVAL;
}
vino_v4l2_get_buffer_status(vcs, fb, b);
break;
}
case V4L2_BUF_TYPE_VIDEO_OVERLAY:
default:
return -EINVAL;
}
return 0;
}
static int vino_v4l2_qbuf(struct vino_channel_settings *vcs,
struct v4l2_buffer *b)
{
if (vcs->reading)
return -EBUSY;
switch (b->type) {
case V4L2_BUF_TYPE_VIDEO_CAPTURE: {
struct vino_framebuffer *fb;
int ret;
// TODO: check queue type
if (b->memory != V4L2_MEMORY_MMAP) {
dprintk("type not mmap\n");
return -EINVAL;
}
fb = vino_capture_enqueue(vcs, b->index);
if (fb == NULL)
return -EINVAL;
vino_v4l2_get_buffer_status(vcs, fb, b);
if (vcs->streaming) {
ret = vino_capture_next(vcs, 1);
if (ret)
return ret;
}
break;
}
case V4L2_BUF_TYPE_VIDEO_OVERLAY:
default:
return -EINVAL;
}
return 0;
}
static int vino_v4l2_dqbuf(struct vino_channel_settings *vcs,
struct v4l2_buffer *b,
unsigned int nonblocking)
{
if (vcs->reading)
return -EBUSY;
switch (b->type) {
case V4L2_BUF_TYPE_VIDEO_CAPTURE: {
struct vino_framebuffer *fb;
unsigned int incoming, outgoing;
int err;
// TODO: check queue type
err = vino_queue_get_incoming(&vcs->fb_queue, &incoming);
if (err) {
dprintk("vino_queue_get_incoming() failed\n");
return -EINVAL;
}
err = vino_queue_get_outgoing(&vcs->fb_queue, &outgoing);
if (err) {
dprintk("vino_queue_get_outgoing() failed\n");
return -EINVAL;
}
dprintk("incoming = %d, outgoing = %d\n", incoming, outgoing);
if (outgoing == 0) {
if (incoming == 0) {
dprintk("no incoming or outgoing buffers\n");
return -EINVAL;
}
if (nonblocking) {
dprintk("non-blocking I/O was selected and "
"there are no buffers to dequeue\n");
return -EAGAIN;
}
err = vino_wait_for_frame(vcs);
if (err) {
err = vino_wait_for_frame(vcs);
if (err) {
/* interrupted or
* no frames captured because
* of frame skipping */
// vino_capture_failed(vcs);
return -EIO;
}
}
}
fb = vino_queue_remove(&vcs->fb_queue, &b->index);
if (fb == NULL) {
dprintk("vino_queue_remove() failed\n");
return -EINVAL;
}
err = vino_check_buffer(vcs, fb);
vino_v4l2_get_buffer_status(vcs, fb, b);
if (err)
return -EIO;
break;
}
case V4L2_BUF_TYPE_VIDEO_OVERLAY:
default:
return -EINVAL;
}
return 0;
}
static int vino_v4l2_streamon(struct vino_channel_settings *vcs)
{
unsigned int incoming;
int ret;
if (vcs->reading)
return -EBUSY;
if (vcs->streaming)
return 0;
// TODO: check queue type
if (vino_queue_get_length(&vcs->fb_queue) < 1) {
dprintk("no buffers allocated\n");
return -EINVAL;
}
ret = vino_queue_get_incoming(&vcs->fb_queue, &incoming);
if (ret) {
dprintk("vino_queue_get_incoming() failed\n");
return -EINVAL;
}
vcs->streaming = 1;
if (incoming > 0) {
ret = vino_capture_next(vcs, 1);
if (ret) {
vcs->streaming = 0;
dprintk("couldn't start capture\n");
return -EINVAL;
}
}
return 0;
}
static int vino_v4l2_streamoff(struct vino_channel_settings *vcs)
{
if (vcs->reading)
return -EBUSY;
if (!vcs->streaming)
return 0;
vcs->streaming = 0;
vino_capture_stop(vcs);
return 0;
}
static int vino_v4l2_queryctrl(struct vino_channel_settings *vcs,
struct v4l2_queryctrl *queryctrl)
{
unsigned long flags;
int i;
int err = 0;
spin_lock_irqsave(&vino_drvdata->input_lock, flags);
switch (vcs->input) {
case VINO_INPUT_D1:
for (i = 0; i < VINO_INDYCAM_V4L2_CONTROL_COUNT; i++) {
if (vino_indycam_v4l2_controls[i].id ==
queryctrl->id) {
memcpy(queryctrl,
&vino_indycam_v4l2_controls[i],
sizeof(struct v4l2_queryctrl));
queryctrl->reserved[0] = 0;
goto found;
}
}
err = -EINVAL;
break;
case VINO_INPUT_COMPOSITE:
case VINO_INPUT_SVIDEO:
for (i = 0; i < VINO_SAA7191_V4L2_CONTROL_COUNT; i++) {
if (vino_saa7191_v4l2_controls[i].id ==
queryctrl->id) {
memcpy(queryctrl,
&vino_saa7191_v4l2_controls[i],
sizeof(struct v4l2_queryctrl));
queryctrl->reserved[0] = 0;
goto found;
}
}
err = -EINVAL;
break;
default:
err = -EINVAL;
}
found:
spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
return err;
}
static int vino_v4l2_g_ctrl(struct vino_channel_settings *vcs,
struct v4l2_control *control)
{
unsigned long flags;
int i;
int err = 0;
spin_lock_irqsave(&vino_drvdata->input_lock, flags);
switch (vcs->input) {
case VINO_INPUT_D1: {
struct indycam_control indycam_ctrl;
for (i = 0; i < VINO_INDYCAM_V4L2_CONTROL_COUNT; i++) {
if (vino_indycam_v4l2_controls[i].id ==
control->id) {
goto found1;
}
}
err = -EINVAL;
goto out;
found1:
indycam_ctrl.type = vino_indycam_v4l2_controls[i].reserved[0];
err = i2c_camera_command(DECODER_INDYCAM_GET_CONTROL,
&indycam_ctrl);
if (err) {
err = -EINVAL;
goto out;
}
control->value = indycam_ctrl.value;
break;
}
case VINO_INPUT_COMPOSITE:
case VINO_INPUT_SVIDEO: {
struct saa7191_control saa7191_ctrl;
for (i = 0; i < VINO_SAA7191_V4L2_CONTROL_COUNT; i++) {
if (vino_saa7191_v4l2_controls[i].id ==
control->id) {
goto found2;
}
}
err = -EINVAL;
goto out;
found2:
saa7191_ctrl.type = vino_saa7191_v4l2_controls[i].reserved[0];
err = i2c_decoder_command(DECODER_SAA7191_GET_CONTROL,
&saa7191_ctrl);
if (err) {
err = -EINVAL;
goto out;
}
control->value = saa7191_ctrl.value;
break;
}
default:
err = -EINVAL;
}
out:
spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
return err;
}
static int vino_v4l2_s_ctrl(struct vino_channel_settings *vcs,
struct v4l2_control *control)
{
unsigned long flags;
int i;
int err = 0;
spin_lock_irqsave(&vino_drvdata->input_lock, flags);
if (!vino_is_input_owner(vcs)) {
err = -EBUSY;
goto out;
}
switch (vcs->input) {
case VINO_INPUT_D1: {
struct indycam_control indycam_ctrl;
for (i = 0; i < VINO_INDYCAM_V4L2_CONTROL_COUNT; i++) {
if (vino_indycam_v4l2_controls[i].id ==
control->id) {
if ((control->value >=
vino_indycam_v4l2_controls[i].minimum)
&& (control->value <=
vino_indycam_v4l2_controls[i].
maximum)) {
goto found1;
} else {
err = -ERANGE;
goto out;
}
}
}
err = -EINVAL;
goto out;
found1:
indycam_ctrl.type = vino_indycam_v4l2_controls[i].reserved[0];
indycam_ctrl.value = control->value;
err = i2c_camera_command(DECODER_INDYCAM_SET_CONTROL,
&indycam_ctrl);
if (err)
err = -EINVAL;
break;
}
case VINO_INPUT_COMPOSITE:
case VINO_INPUT_SVIDEO: {
struct saa7191_control saa7191_ctrl;
for (i = 0; i < VINO_SAA7191_V4L2_CONTROL_COUNT; i++) {
if (vino_saa7191_v4l2_controls[i].id ==
control->id) {
if ((control->value >=
vino_saa7191_v4l2_controls[i].minimum)
&& (control->value <=
vino_saa7191_v4l2_controls[i].
maximum)) {
goto found2;
} else {
err = -ERANGE;
goto out;
}
}
}
err = -EINVAL;
goto out;
found2:
saa7191_ctrl.type = vino_saa7191_v4l2_controls[i].reserved[0];
saa7191_ctrl.value = control->value;
err = i2c_decoder_command(DECODER_SAA7191_SET_CONTROL,
&saa7191_ctrl);
if (err)
err = -EINVAL;
break;
}
default:
err = -EINVAL;
}
out:
spin_unlock_irqrestore(&vino_drvdata->input_lock, flags);
return err;
}
/* File operations */
static int vino_open(struct inode *inode, struct file *file)
{
struct video_device *dev = video_devdata(file);
struct vino_channel_settings *vcs = video_get_drvdata(dev);
int ret = 0;
dprintk("open(): channel = %c\n",
(vcs->channel == VINO_CHANNEL_A) ? 'A' : 'B');
mutex_lock(&vcs->mutex);
if (vcs->users) {
dprintk("open(): driver busy\n");
ret = -EBUSY;
goto out;
}
ret = vino_acquire_input(vcs);
if (ret) {
dprintk("open(): vino_acquire_input() failed\n");
goto out;
}
vcs->users++;
out:
mutex_unlock(&vcs->mutex);
dprintk("open(): %s!\n", ret ? "failed" : "complete");
return ret;
}
static int vino_close(struct inode *inode, struct file *file)
{
struct video_device *dev = video_devdata(file);
struct vino_channel_settings *vcs = video_get_drvdata(dev);
dprintk("close():\n");
mutex_lock(&vcs->mutex);
vcs->users--;
if (!vcs->users) {
vino_release_input(vcs);
/* stop DMA and free buffers */
vino_capture_stop(vcs);
vino_queue_free(&vcs->fb_queue);
}
mutex_unlock(&vcs->mutex);
return 0;
}
static void vino_vm_open(struct vm_area_struct *vma)
{
struct vino_framebuffer *fb = vma->vm_private_data;
fb->map_count++;
dprintk("vino_vm_open(): count = %d\n", fb->map_count);
}
static void vino_vm_close(struct vm_area_struct *vma)
{
struct vino_framebuffer *fb = vma->vm_private_data;
fb->map_count--;
dprintk("vino_vm_close(): count = %d\n", fb->map_count);
}
static struct vm_operations_struct vino_vm_ops = {
.open = vino_vm_open,
.close = vino_vm_close,
};
static int vino_mmap(struct file *file, struct vm_area_struct *vma)
{
struct video_device *dev = video_devdata(file);
struct vino_channel_settings *vcs = video_get_drvdata(dev);
unsigned long start = vma->vm_start;
unsigned long size = vma->vm_end - vma->vm_start;
unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
struct vino_framebuffer *fb = NULL;
unsigned int i, length;
int ret = 0;
dprintk("mmap():\n");
// TODO: reject mmap if already mapped
if (mutex_lock_interruptible(&vcs->mutex))
return -EINTR;
if (vcs->reading) {
ret = -EBUSY;
goto out;
}
// TODO: check queue type
if (!(vma->vm_flags & VM_WRITE)) {
dprintk("mmap(): app bug: PROT_WRITE please\n");
ret = -EINVAL;
goto out;
}
if (!(vma->vm_flags & VM_SHARED)) {
dprintk("mmap(): app bug: MAP_SHARED please\n");
ret = -EINVAL;
goto out;
}
/* find the correct buffer using offset */
length = vino_queue_get_length(&vcs->fb_queue);
if (length == 0) {
dprintk("mmap(): queue not initialized\n");
ret = -EINVAL;
goto out;
}
for (i = 0; i < length; i++) {
fb = vino_queue_get_buffer(&vcs->fb_queue, i);
if (fb == NULL) {
dprintk("mmap(): vino_queue_get_buffer() failed\n");
ret = -EINVAL;
goto out;
}
if (fb->offset == offset)
goto found;
}
dprintk("mmap(): invalid offset = %lu\n", offset);
ret = -EINVAL;
goto out;
found:
dprintk("mmap(): buffer = %d\n", i);
if (size > (fb->desc_table.page_count * PAGE_SIZE)) {
dprintk("mmap(): failed: size = %lu > %lu\n",
size, fb->desc_table.page_count * PAGE_SIZE);
ret = -EINVAL;
goto out;
}
for (i = 0; i < fb->desc_table.page_count; i++) {
unsigned long pfn =
virt_to_phys((void *)fb->desc_table.virtual[i]) >>
PAGE_SHIFT;
if (size < PAGE_SIZE)
break;
// protection was: PAGE_READONLY
if (remap_pfn_range(vma, start, pfn, PAGE_SIZE,
vma->vm_page_prot)) {
dprintk("mmap(): remap_pfn_range() failed\n");
ret = -EAGAIN;
goto out;
}
start += PAGE_SIZE;
size -= PAGE_SIZE;
}
fb->map_count = 1;
vma->vm_flags |= VM_DONTEXPAND | VM_RESERVED;
vma->vm_flags &= ~VM_IO;
vma->vm_private_data = fb;
vma->vm_file = file;
vma->vm_ops = &vino_vm_ops;
out:
mutex_unlock(&vcs->mutex);
return ret;
}
static unsigned int vino_poll(struct file *file, poll_table *pt)
{
struct video_device *dev = video_devdata(file);
struct vino_channel_settings *vcs = video_get_drvdata(dev);
unsigned int outgoing;
unsigned int ret = 0;
// lock mutex (?)
// TODO: this has to be corrected for different read modes
dprintk("poll():\n");
if (vino_queue_get_outgoing(&vcs->fb_queue, &outgoing)) {
dprintk("poll(): vino_queue_get_outgoing() failed\n");
ret = POLLERR;
goto error;
}
if (outgoing > 0)
goto over;
poll_wait(file, &vcs->fb_queue.frame_wait_queue, pt);
if (vino_queue_get_outgoing(&vcs->fb_queue, &outgoing)) {
dprintk("poll(): vino_queue_get_outgoing() failed\n");
ret = POLLERR;
goto error;
}
over:
dprintk("poll(): data %savailable\n",
(outgoing > 0) ? "" : "not ");
if (outgoing > 0)
ret = POLLIN | POLLRDNORM;
error:
return ret;
}
static int vino_do_ioctl(struct inode *inode, struct file *file,
unsigned int cmd, void *arg)
{
struct video_device *dev = video_devdata(file);
struct vino_channel_settings *vcs = video_get_drvdata(dev);
#ifdef VINO_DEBUG
switch (_IOC_TYPE(cmd)) {
case 'v':
dprintk("ioctl(): V4L1 unsupported (0x%08x)\n", cmd);
break;
case 'V':
dprintk("ioctl(): V4L2 %s (0x%08x)\n",
v4l2_ioctl_names[_IOC_NR(cmd)], cmd);
break;
default:
dprintk("ioctl(): unsupported command 0x%08x\n", cmd);
}
#endif
switch (cmd) {
/* V4L2 interface */
case VIDIOC_QUERYCAP: {
vino_v4l2_querycap(arg);
break;
}
case VIDIOC_ENUMINPUT: {
return vino_v4l2_enuminput(vcs, arg);
}
case VIDIOC_G_INPUT: {
return vino_v4l2_g_input(vcs, arg);
}
case VIDIOC_S_INPUT: {
return vino_v4l2_s_input(vcs, arg);
}
case VIDIOC_ENUMSTD: {
return vino_v4l2_enumstd(vcs, arg);
}
case VIDIOC_QUERYSTD: {
return vino_v4l2_querystd(vcs, arg);
}
case VIDIOC_G_STD: {
return vino_v4l2_g_std(vcs, arg);
}
case VIDIOC_S_STD: {
return vino_v4l2_s_std(vcs, arg);
}
case VIDIOC_ENUM_FMT: {
return vino_v4l2_enum_fmt(vcs, arg);
}
case VIDIOC_TRY_FMT: {
return vino_v4l2_try_fmt(vcs, arg);
}
case VIDIOC_G_FMT: {
return vino_v4l2_g_fmt(vcs, arg);
}
case VIDIOC_S_FMT: {
return vino_v4l2_s_fmt(vcs, arg);
}
case VIDIOC_CROPCAP: {
return vino_v4l2_cropcap(vcs, arg);
}
case VIDIOC_G_CROP: {
return vino_v4l2_g_crop(vcs, arg);
}
case VIDIOC_S_CROP: {
return vino_v4l2_s_crop(vcs, arg);
}
case VIDIOC_G_PARM: {
return vino_v4l2_g_parm(vcs, arg);
}
case VIDIOC_S_PARM: {
return vino_v4l2_s_parm(vcs, arg);
}
case VIDIOC_REQBUFS: {
return vino_v4l2_reqbufs(vcs, arg);
}
case VIDIOC_QUERYBUF: {
return vino_v4l2_querybuf(vcs, arg);
}
case VIDIOC_QBUF: {
return vino_v4l2_qbuf(vcs, arg);
}
case VIDIOC_DQBUF: {
return vino_v4l2_dqbuf(vcs, arg, file->f_flags & O_NONBLOCK);
}
case VIDIOC_STREAMON: {
return vino_v4l2_streamon(vcs);
}
case VIDIOC_STREAMOFF: {
return vino_v4l2_streamoff(vcs);
}
case VIDIOC_QUERYCTRL: {
return vino_v4l2_queryctrl(vcs, arg);
}
case VIDIOC_G_CTRL: {
return vino_v4l2_g_ctrl(vcs, arg);
}
case VIDIOC_S_CTRL: {
return vino_v4l2_s_ctrl(vcs, arg);
}
default:
return -ENOIOCTLCMD;
}
return 0;
}
static int vino_ioctl(struct inode *inode, struct file *file,
unsigned int cmd, unsigned long arg)
{
struct video_device *dev = video_devdata(file);
struct vino_channel_settings *vcs = video_get_drvdata(dev);
int ret;
if (mutex_lock_interruptible(&vcs->mutex))
return -EINTR;
ret = video_usercopy(inode, file, cmd, arg, vino_do_ioctl);
mutex_unlock(&vcs->mutex);
return ret;
}
/* Initialization and cleanup */
// __initdata
static int vino_init_stage = 0;
static const struct file_operations vino_fops = {
.owner = THIS_MODULE,
.open = vino_open,
.release = vino_close,
.ioctl = vino_ioctl,
.mmap = vino_mmap,
.poll = vino_poll,
.llseek = no_llseek,
};
static struct video_device v4l_device_template = {
.name = "NOT SET",
//.type = VID_TYPE_CAPTURE | VID_TYPE_SUBCAPTURE |
// VID_TYPE_CLIPPING | VID_TYPE_SCALES, VID_TYPE_OVERLAY
.fops = &vino_fops,
.minor = -1,
};
static void vino_module_cleanup(int stage)
{
switch(stage) {
case 10:
video_unregister_device(vino_drvdata->b.v4l_device);
vino_drvdata->b.v4l_device = NULL;
case 9:
video_unregister_device(vino_drvdata->a.v4l_device);
vino_drvdata->a.v4l_device = NULL;
case 8:
vino_i2c_del_bus();
case 7:
free_irq(SGI_VINO_IRQ, NULL);
case 6:
if (vino_drvdata->b.v4l_device) {
video_device_release(vino_drvdata->b.v4l_device);
vino_drvdata->b.v4l_device = NULL;
}
case 5:
if (vino_drvdata->a.v4l_device) {
video_device_release(vino_drvdata->a.v4l_device);
vino_drvdata->a.v4l_device = NULL;
}
case 4:
/* all entries in dma_cpu dummy table have the same address */
dma_unmap_single(NULL,
vino_drvdata->dummy_desc_table.dma_cpu[0],
PAGE_SIZE, DMA_FROM_DEVICE);
dma_free_coherent(NULL, VINO_DUMMY_DESC_COUNT
* sizeof(dma_addr_t),
(void *)vino_drvdata->
dummy_desc_table.dma_cpu,
vino_drvdata->dummy_desc_table.dma);
case 3:
free_page(vino_drvdata->dummy_page);
case 2:
kfree(vino_drvdata);
case 1:
iounmap(vino);
case 0:
break;
default:
dprintk("vino_module_cleanup(): invalid cleanup stage = %d\n",
stage);
}
}
static int vino_probe(void)
{
unsigned long rev_id;
if (ip22_is_fullhouse()) {
printk(KERN_ERR "VINO doesn't exist in IP22 Fullhouse\n");
return -ENODEV;
}
if (!(sgimc->systemid & SGIMC_SYSID_EPRESENT)) {
printk(KERN_ERR "VINO is not found (EISA BUS not present)\n");
return -ENODEV;
}
vino = (struct sgi_vino *)ioremap(VINO_BASE, sizeof(struct sgi_vino));
if (!vino) {
printk(KERN_ERR "VINO: ioremap() failed\n");
return -EIO;
}
vino_init_stage++;
if (get_dbe(rev_id, &(vino->rev_id))) {
printk(KERN_ERR "Failed to read VINO revision register\n");
vino_module_cleanup(vino_init_stage);
return -ENODEV;
}
if (VINO_ID_VALUE(rev_id) != VINO_CHIP_ID) {
printk(KERN_ERR "Unknown VINO chip ID (Rev/ID: 0x%02lx)\n",
rev_id);
vino_module_cleanup(vino_init_stage);
return -ENODEV;
}
printk(KERN_INFO "VINO revision %ld found\n", VINO_REV_NUM(rev_id));
return 0;
}
static int vino_init(void)
{
dma_addr_t dma_dummy_address;
int i;
vino_drvdata = kzalloc(sizeof(struct vino_settings), GFP_KERNEL);
if (!vino_drvdata) {
vino_module_cleanup(vino_init_stage);
return -ENOMEM;
}
vino_init_stage++;
/* create a dummy dma descriptor */
vino_drvdata->dummy_page = get_zeroed_page(GFP_KERNEL | GFP_DMA);
if (!vino_drvdata->dummy_page) {
vino_module_cleanup(vino_init_stage);
return -ENOMEM;
}
vino_init_stage++;
// TODO: use page_count in dummy_desc_table
vino_drvdata->dummy_desc_table.dma_cpu =
dma_alloc_coherent(NULL,
VINO_DUMMY_DESC_COUNT * sizeof(dma_addr_t),
&vino_drvdata->dummy_desc_table.dma,
GFP_KERNEL | GFP_DMA);
if (!vino_drvdata->dummy_desc_table.dma_cpu) {
vino_module_cleanup(vino_init_stage);
return -ENOMEM;
}
vino_init_stage++;
dma_dummy_address = dma_map_single(NULL,
(void *)vino_drvdata->dummy_page,
PAGE_SIZE, DMA_FROM_DEVICE);
for (i = 0; i < VINO_DUMMY_DESC_COUNT; i++) {
vino_drvdata->dummy_desc_table.dma_cpu[i] = dma_dummy_address;
}
/* initialize VINO */
vino->control = 0;
vino->a.next_4_desc = vino_drvdata->dummy_desc_table.dma;
vino->b.next_4_desc = vino_drvdata->dummy_desc_table.dma;
udelay(VINO_DESC_FETCH_DELAY);
vino->intr_status = 0;
vino->a.fifo_thres = VINO_FIFO_THRESHOLD_DEFAULT;
vino->b.fifo_thres = VINO_FIFO_THRESHOLD_DEFAULT;
return 0;
}
static int vino_init_channel_settings(struct vino_channel_settings *vcs,
unsigned int channel, const char *name)
{
vcs->channel = channel;
vcs->input = VINO_INPUT_NONE;
vcs->alpha = 0;
vcs->users = 0;
vcs->data_format = VINO_DATA_FMT_GREY;
vcs->data_norm = VINO_DATA_NORM_NTSC;
vcs->decimation = 1;
vino_set_default_clipping(vcs);
vino_set_default_framerate(vcs);
vcs->capturing = 0;
mutex_init(&vcs->mutex);
spin_lock_init(&vcs->capture_lock);
mutex_init(&vcs->fb_queue.queue_mutex);
spin_lock_init(&vcs->fb_queue.queue_lock);
init_waitqueue_head(&vcs->fb_queue.frame_wait_queue);
vcs->v4l_device = video_device_alloc();
if (!vcs->v4l_device) {
vino_module_cleanup(vino_init_stage);
return -ENOMEM;
}
vino_init_stage++;
memcpy(vcs->v4l_device, &v4l_device_template,
sizeof(struct video_device));
strcpy(vcs->v4l_device->name, name);
vcs->v4l_device->release = video_device_release;
video_set_drvdata(vcs->v4l_device, vcs);
return 0;
}
static int __init vino_module_init(void)
{
int ret;
printk(KERN_INFO "SGI VINO driver version %s\n",
VINO_MODULE_VERSION);
ret = vino_probe();
if (ret)
return ret;
ret = vino_init();
if (ret)
return ret;
/* initialize data structures */
spin_lock_init(&vino_drvdata->vino_lock);
spin_lock_init(&vino_drvdata->input_lock);
ret = vino_init_channel_settings(&vino_drvdata->a, VINO_CHANNEL_A,
vino_v4l_device_name_a);
if (ret)
return ret;
ret = vino_init_channel_settings(&vino_drvdata->b, VINO_CHANNEL_B,
vino_v4l_device_name_b);
if (ret)
return ret;
/* initialize hardware and register V4L devices */
ret = request_irq(SGI_VINO_IRQ, vino_interrupt, 0,
vino_driver_description, NULL);
if (ret) {
printk(KERN_ERR "VINO: requesting IRQ %02d failed\n",
SGI_VINO_IRQ);
vino_module_cleanup(vino_init_stage);
return -EAGAIN;
}
vino_init_stage++;
ret = vino_i2c_add_bus();
if (ret) {
printk(KERN_ERR "VINO I2C bus registration failed\n");
vino_module_cleanup(vino_init_stage);
return ret;
}
vino_init_stage++;
ret = video_register_device(vino_drvdata->a.v4l_device,
VFL_TYPE_GRABBER, -1);
if (ret < 0) {
printk(KERN_ERR "VINO channel A Video4Linux-device "
"registration failed\n");
vino_module_cleanup(vino_init_stage);
return -EINVAL;
}
vino_init_stage++;
ret = video_register_device(vino_drvdata->b.v4l_device,
VFL_TYPE_GRABBER, -1);
if (ret < 0) {
printk(KERN_ERR "VINO channel B Video4Linux-device "
"registration failed\n");
vino_module_cleanup(vino_init_stage);
return -EINVAL;
}
vino_init_stage++;
#if defined(CONFIG_KMOD) && defined(MODULE)
request_module("saa7191");
request_module("indycam");
#endif
dprintk("init complete!\n");
return 0;
}
static void __exit vino_module_exit(void)
{
dprintk("exiting, stage = %d ...\n", vino_init_stage);
vino_module_cleanup(vino_init_stage);
dprintk("cleanup complete, exit!\n");
}
module_init(vino_module_init);
module_exit(vino_module_exit);
View git blame Copy permalink