forked from Minki/linux
V4L/DVB (5863): TCM825x: Add driver.
Add a driver for Toshiba TCM825x VGA camera sensor. This sensor is used e.g. in Nokia N800 internet tablet. This driver uses the new V4L2 internal ioctl interface. Signed-off-by: Sakari Ailus <sakari.ailus@nokia.com> Signed-off-by: Mauro Carvalho Chehab <mchehab@infradead.org>
This commit is contained in:
Sakari Ailus
Mauro Carvalho Chehab
parent
9b5d0f1e6d
commit
a5e9086211
@ -197,6 +197,13 @@ config VIDEO_OV7670
|
||||
OV7670 VGA camera. It currently only works with the M88ALP01
|
||||
controller.
|
||||
|
||||
config VIDEO_TCM825X
|
||||
tristate "TCM825x camera sensor support"
|
||||
depends on I2C && VIDEO_V4L2
|
||||
---help---
|
||||
This is a driver for the Toshiba TCM825x VGA camera sensor.
|
||||
It is used for example in Nokia N800.
|
||||
|
||||
config VIDEO_SAA7110
|
||||
tristate "Philips SAA7110 video decoder"
|
||||
depends on VIDEO_V4L1 && I2C
|
||||
|
||||
@ -98,6 +98,8 @@ obj-$(CONFIG_VIDEO_CX2341X) += cx2341x.o
|
||||
obj-$(CONFIG_VIDEO_CAFE_CCIC) += cafe_ccic.o
|
||||
obj-$(CONFIG_VIDEO_OV7670) += ov7670.o
|
||||
|
||||
obj-$(CONFIG_VIDEO_TCM825X) += tcm825x.o
|
||||
|
||||
obj-$(CONFIG_USB_DABUSB) += dabusb.o
|
||||
obj-$(CONFIG_USB_OV511) += ov511.o
|
||||
obj-$(CONFIG_USB_SE401) += se401.o
|
||||
|
||||
942
drivers/media/video/tcm825x.c
Normal file
942
drivers/media/video/tcm825x.c
Normal file
@ -0,0 +1,942 @@
|
||||
/*
|
||||
* drivers/media/video/tcm825x.c
|
||||
*
|
||||
* TCM825X camera sensor driver.
|
||||
*
|
||||
* Copyright (C) 2007 Nokia Corporation.
|
||||
*
|
||||
* Contact: Sakari Ailus <sakari.ailus@nokia.com>
|
||||
*
|
||||
* Based on code from David Cohen <david.cohen@indt.org.br>
|
||||
*
|
||||
* This driver was based on ov9640 sensor driver from MontaVista
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* version 2 as published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful, but
|
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
|
||||
* 02110-1301 USA
|
||||
*/
|
||||
|
||||
#include <linux/i2c.h>
|
||||
#include <media/v4l2-int-device.h>
|
||||
|
||||
#include "tcm825x.h"
|
||||
|
||||
/*
|
||||
* The sensor has two fps modes: the lower one just gives half the fps
|
||||
* at the same xclk than the high one.
|
||||
*/
|
||||
#define MAX_FPS 30
|
||||
#define MIN_FPS 8
|
||||
#define MAX_HALF_FPS (MAX_FPS / 2)
|
||||
#define HIGH_FPS_MODE_LOWER_LIMIT 14
|
||||
#define DEFAULT_FPS MAX_HALF_FPS
|
||||
|
||||
struct tcm825x_sensor {
|
||||
const struct tcm825x_platform_data *platform_data;
|
||||
struct v4l2_int_device *v4l2_int_device;
|
||||
struct i2c_client *i2c_client;
|
||||
struct v4l2_pix_format pix;
|
||||
struct v4l2_fract timeperframe;
|
||||
};
|
||||
|
||||
/* list of image formats supported by TCM825X sensor */
|
||||
const static struct v4l2_fmtdesc tcm825x_formats[] = {
|
||||
{
|
||||
.description = "YUYV (YUV 4:2:2), packed",
|
||||
.pixelformat = V4L2_PIX_FMT_UYVY,
|
||||
}, {
|
||||
/* Note: V4L2 defines RGB565 as:
|
||||
*
|
||||
* Byte 0 Byte 1
|
||||
* g2 g1 g0 r4 r3 r2 r1 r0 b4 b3 b2 b1 b0 g5 g4 g3
|
||||
*
|
||||
* We interpret RGB565 as:
|
||||
*
|
||||
* Byte 0 Byte 1
|
||||
* g2 g1 g0 b4 b3 b2 b1 b0 r4 r3 r2 r1 r0 g5 g4 g3
|
||||
*/
|
||||
.description = "RGB565, le",
|
||||
.pixelformat = V4L2_PIX_FMT_RGB565,
|
||||
},
|
||||
};
|
||||
|
||||
#define TCM825X_NUM_CAPTURE_FORMATS ARRAY_SIZE(tcm825x_formats)
|
||||
|
||||
/*
|
||||
* TCM825X register configuration for all combinations of pixel format and
|
||||
* image size
|
||||
*/
|
||||
const static struct tcm825x_reg subqcif = { 0x20, TCM825X_PICSIZ };
|
||||
const static struct tcm825x_reg qcif = { 0x18, TCM825X_PICSIZ };
|
||||
const static struct tcm825x_reg cif = { 0x14, TCM825X_PICSIZ };
|
||||
const static struct tcm825x_reg qqvga = { 0x0c, TCM825X_PICSIZ };
|
||||
const static struct tcm825x_reg qvga = { 0x04, TCM825X_PICSIZ };
|
||||
const static struct tcm825x_reg vga = { 0x00, TCM825X_PICSIZ };
|
||||
|
||||
const static struct tcm825x_reg yuv422 = { 0x00, TCM825X_PICFMT };
|
||||
const static struct tcm825x_reg rgb565 = { 0x02, TCM825X_PICFMT };
|
||||
|
||||
/* Our own specific controls */
|
||||
#define V4L2_CID_ALC V4L2_CID_PRIVATE_BASE
|
||||
#define V4L2_CID_H_EDGE_EN V4L2_CID_PRIVATE_BASE + 1
|
||||
#define V4L2_CID_V_EDGE_EN V4L2_CID_PRIVATE_BASE + 2
|
||||
#define V4L2_CID_LENS V4L2_CID_PRIVATE_BASE + 3
|
||||
#define V4L2_CID_MAX_EXPOSURE_TIME V4L2_CID_PRIVATE_BASE + 4
|
||||
#define V4L2_CID_LAST_PRIV V4L2_CID_MAX_EXPOSURE_TIME
|
||||
|
||||
/* Video controls */
|
||||
static struct vcontrol {
|
||||
struct v4l2_queryctrl qc;
|
||||
u16 reg;
|
||||
u16 start_bit;
|
||||
} video_control[] = {
|
||||
{
|
||||
{
|
||||
.id = V4L2_CID_GAIN,
|
||||
.type = V4L2_CTRL_TYPE_INTEGER,
|
||||
.name = "Gain",
|
||||
.minimum = 0,
|
||||
.maximum = 63,
|
||||
.step = 1,
|
||||
},
|
||||
.reg = TCM825X_AG,
|
||||
.start_bit = 0,
|
||||
},
|
||||
{
|
||||
{
|
||||
.id = V4L2_CID_RED_BALANCE,
|
||||
.type = V4L2_CTRL_TYPE_INTEGER,
|
||||
.name = "Red Balance",
|
||||
.minimum = 0,
|
||||
.maximum = 255,
|
||||
.step = 1,
|
||||
},
|
||||
.reg = TCM825X_MRG,
|
||||
.start_bit = 0,
|
||||
},
|
||||
{
|
||||
{
|
||||
.id = V4L2_CID_BLUE_BALANCE,
|
||||
.type = V4L2_CTRL_TYPE_INTEGER,
|
||||
.name = "Blue Balance",
|
||||
.minimum = 0,
|
||||
.maximum = 255,
|
||||
.step = 1,
|
||||
},
|
||||
.reg = TCM825X_MBG,
|
||||
.start_bit = 0,
|
||||
},
|
||||
{
|
||||
{
|
||||
.id = V4L2_CID_AUTO_WHITE_BALANCE,
|
||||
.type = V4L2_CTRL_TYPE_BOOLEAN,
|
||||
.name = "Auto White Balance",
|
||||
.minimum = 0,
|
||||
.maximum = 1,
|
||||
.step = 0,
|
||||
},
|
||||
.reg = TCM825X_AWBSW,
|
||||
.start_bit = 7,
|
||||
},
|
||||
{
|
||||
{
|
||||
.id = V4L2_CID_EXPOSURE,
|
||||
.type = V4L2_CTRL_TYPE_INTEGER,
|
||||
.name = "Exposure Time",
|
||||
.minimum = 0,
|
||||
.maximum = 0x1fff,
|
||||
.step = 1,
|
||||
},
|
||||
.reg = TCM825X_ESRSPD_U,
|
||||
.start_bit = 0,
|
||||
},
|
||||
{
|
||||
{
|
||||
.id = V4L2_CID_HFLIP,
|
||||
.type = V4L2_CTRL_TYPE_BOOLEAN,
|
||||
.name = "Mirror Image",
|
||||
.minimum = 0,
|
||||
.maximum = 1,
|
||||
.step = 0,
|
||||
},
|
||||
.reg = TCM825X_H_INV,
|
||||
.start_bit = 6,
|
||||
},
|
||||
{
|
||||
{
|
||||
.id = V4L2_CID_VFLIP,
|
||||
.type = V4L2_CTRL_TYPE_BOOLEAN,
|
||||
.name = "Vertical Flip",
|
||||
.minimum = 0,
|
||||
.maximum = 1,
|
||||
.step = 0,
|
||||
},
|
||||
.reg = TCM825X_V_INV,
|
||||
.start_bit = 7,
|
||||
},
|
||||
/* Private controls */
|
||||
{
|
||||
{
|
||||
.id = V4L2_CID_ALC,
|
||||
.type = V4L2_CTRL_TYPE_BOOLEAN,
|
||||
.name = "Auto Luminance Control",
|
||||
.minimum = 0,
|
||||
.maximum = 1,
|
||||
.step = 0,
|
||||
},
|
||||
.reg = TCM825X_ALCSW,
|
||||
.start_bit = 7,
|
||||
},
|
||||
{
|
||||
{
|
||||
.id = V4L2_CID_H_EDGE_EN,
|
||||
.type = V4L2_CTRL_TYPE_INTEGER,
|
||||
.name = "Horizontal Edge Enhancement",
|
||||
.minimum = 0,
|
||||
.maximum = 0xff,
|
||||
.step = 1,
|
||||
},
|
||||
.reg = TCM825X_HDTG,
|
||||
.start_bit = 0,
|
||||
},
|
||||
{
|
||||
{
|
||||
.id = V4L2_CID_V_EDGE_EN,
|
||||
.type = V4L2_CTRL_TYPE_INTEGER,
|
||||
.name = "Vertical Edge Enhancement",
|
||||
.minimum = 0,
|
||||
.maximum = 0xff,
|
||||
.step = 1,
|
||||
},
|
||||
.reg = TCM825X_VDTG,
|
||||
.start_bit = 0,
|
||||
},
|
||||
{
|
||||
{
|
||||
.id = V4L2_CID_LENS,
|
||||
.type = V4L2_CTRL_TYPE_INTEGER,
|
||||
.name = "Lens Shading Compensation",
|
||||
.minimum = 0,
|
||||
.maximum = 0x3f,
|
||||
.step = 1,
|
||||
},
|
||||
.reg = TCM825X_LENS,
|
||||
.start_bit = 0,
|
||||
},
|
||||
{
|
||||
{
|
||||
.id = V4L2_CID_MAX_EXPOSURE_TIME,
|
||||
.type = V4L2_CTRL_TYPE_INTEGER,
|
||||
.name = "Maximum Exposure Time",
|
||||
.minimum = 0,
|
||||
.maximum = 0x3,
|
||||
.step = 1,
|
||||
},
|
||||
.reg = TCM825X_ESRLIM,
|
||||
.start_bit = 5,
|
||||
},
|
||||
};
|
||||
|
||||
|
||||
const static struct tcm825x_reg *tcm825x_siz_reg[NUM_IMAGE_SIZES] =
|
||||
{ &subqcif, &qqvga, &qcif, &qvga, &cif, &vga };
|
||||
|
||||
const static struct tcm825x_reg *tcm825x_fmt_reg[NUM_PIXEL_FORMATS] =
|
||||
{ &yuv422, &rgb565 };
|
||||
|
||||
/*
|
||||
* Read a value from a register in an TCM825X sensor device. The value is
|
||||
* returned in 'val'.
|
||||
* Returns zero if successful, or non-zero otherwise.
|
||||
*/
|
||||
static int tcm825x_read_reg(struct i2c_client *client, int reg)
|
||||
{
|
||||
int err;
|
||||
struct i2c_msg msg[2];
|
||||
u8 reg_buf, data_buf = 0;
|
||||
|
||||
if (!client->adapter)
|
||||
return -ENODEV;
|
||||
|
||||
msg[0].addr = client->addr;
|
||||
msg[0].flags = 0;
|
||||
msg[0].len = 1;
|
||||
msg[0].buf = ®_buf;
|
||||
msg[1].addr = client->addr;
|
||||
msg[1].flags = I2C_M_RD;
|
||||
msg[1].len = 1;
|
||||
msg[1].buf = &data_buf;
|
||||
|
||||
reg_buf = reg;
|
||||
|
||||
err = i2c_transfer(client->adapter, msg, 2);
|
||||
if (err < 0)
|
||||
return err;
|
||||
return data_buf;
|
||||
}
|
||||
|
||||
/*
|
||||
* Write a value to a register in an TCM825X sensor device.
|
||||
* Returns zero if successful, or non-zero otherwise.
|
||||
*/
|
||||
static int tcm825x_write_reg(struct i2c_client *client, u8 reg, u8 val)
|
||||
{
|
||||
int err;
|
||||
struct i2c_msg msg[1];
|
||||
unsigned char data[2];
|
||||
|
||||
if (!client->adapter)
|
||||
return -ENODEV;
|
||||
|
||||
msg->addr = client->addr;
|
||||
msg->flags = 0;
|
||||
msg->len = 2;
|
||||
msg->buf = data;
|
||||
data[0] = reg;
|
||||
data[1] = val;
|
||||
err = i2c_transfer(client->adapter, msg, 1);
|
||||
if (err >= 0)
|
||||
return 0;
|
||||
return err;
|
||||
}
|
||||
|
||||
static int __tcm825x_write_reg_mask(struct i2c_client *client,
|
||||
u8 reg, u8 val, u8 mask)
|
||||
{
|
||||
int rc;
|
||||
|
||||
/* need to do read - modify - write */
|
||||
rc = tcm825x_read_reg(client, reg);
|
||||
if (rc < 0)
|
||||
return rc;
|
||||
|
||||
rc &= (~mask); /* Clear the masked bits */
|
||||
val &= mask; /* Enforce mask on value */
|
||||
val |= rc;
|
||||
|
||||
/* write the new value to the register */
|
||||
rc = tcm825x_write_reg(client, reg, val);
|
||||
if (rc)
|
||||
return rc;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#define tcm825x_write_reg_mask(client, regmask, val) \
|
||||
__tcm825x_write_reg_mask(client, TCM825X_ADDR((regmask)), val, \
|
||||
TCM825X_MASK((regmask)))
|
||||
|
||||
|
||||
/*
|
||||
* Initialize a list of TCM825X registers.
|
||||
* The list of registers is terminated by the pair of values
|
||||
* { TCM825X_REG_TERM, TCM825X_VAL_TERM }.
|
||||
* Returns zero if successful, or non-zero otherwise.
|
||||
*/
|
||||
static int tcm825x_write_default_regs(struct i2c_client *client,
|
||||
const struct tcm825x_reg *reglist)
|
||||
{
|
||||
int err;
|
||||
const struct tcm825x_reg *next = reglist;
|
||||
|
||||
while (!((next->reg == TCM825X_REG_TERM)
|
||||
&& (next->val == TCM825X_VAL_TERM))) {
|
||||
err = tcm825x_write_reg(client, next->reg, next->val);
|
||||
if (err) {
|
||||
dev_err(&client->dev, "register writing failed\n");
|
||||
return err;
|
||||
}
|
||||
next++;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct vcontrol *find_vctrl(int id)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (id < V4L2_CID_BASE)
|
||||
return NULL;
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(video_control); i++)
|
||||
if (video_control[i].qc.id == id)
|
||||
return &video_control[i];
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* Find the best match for a requested image capture size. The best match
|
||||
* is chosen as the nearest match that has the same number or fewer pixels
|
||||
* as the requested size, or the smallest image size if the requested size
|
||||
* has fewer pixels than the smallest image.
|
||||
*/
|
||||
static enum image_size tcm825x_find_size(struct v4l2_int_device *s,
|
||||
unsigned int width,
|
||||
unsigned int height)
|
||||
{
|
||||
enum image_size isize;
|
||||
unsigned long pixels = width * height;
|
||||
struct tcm825x_sensor *sensor = s->priv;
|
||||
|
||||
for (isize = subQCIF; isize < VGA; isize++) {
|
||||
if (tcm825x_sizes[isize + 1].height
|
||||
* tcm825x_sizes[isize + 1].width > pixels) {
|
||||
dev_dbg(&sensor->i2c_client->dev, "size %d\n", isize);
|
||||
|
||||
return isize;
|
||||
}
|
||||
}
|
||||
|
||||
dev_dbg(&sensor->i2c_client->dev, "format default VGA\n");
|
||||
|
||||
return VGA;
|
||||
}
|
||||
|
||||
/*
|
||||
* Configure the TCM825X for current image size, pixel format, and
|
||||
* frame period. fper is the frame period (in seconds) expressed as a
|
||||
* fraction. Returns zero if successful, or non-zero otherwise. The
|
||||
* actual frame period is returned in fper.
|
||||
*/
|
||||
static int tcm825x_configure(struct v4l2_int_device *s)
|
||||
{
|
||||
struct tcm825x_sensor *sensor = s->priv;
|
||||
struct v4l2_pix_format *pix = &sensor->pix;
|
||||
enum image_size isize = tcm825x_find_size(s, pix->width, pix->height);
|
||||
struct v4l2_fract *fper = &sensor->timeperframe;
|
||||
enum pixel_format pfmt;
|
||||
int err;
|
||||
u32 tgt_fps;
|
||||
u8 val;
|
||||
|
||||
/* common register initialization */
|
||||
err = tcm825x_write_default_regs(
|
||||
sensor->i2c_client, sensor->platform_data->default_regs());
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
/* configure image size */
|
||||
val = tcm825x_siz_reg[isize]->val;
|
||||
dev_dbg(&sensor->i2c_client->dev,
|
||||
"configuring image size %d\n", isize);
|
||||
err = tcm825x_write_reg_mask(sensor->i2c_client,
|
||||
tcm825x_siz_reg[isize]->reg, val);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
/* configure pixel format */
|
||||
switch (pix->pixelformat) {
|
||||
default:
|
||||
case V4L2_PIX_FMT_RGB565:
|
||||
pfmt = RGB565;
|
||||
break;
|
||||
case V4L2_PIX_FMT_UYVY:
|
||||
pfmt = YUV422;
|
||||
break;
|
||||
}
|
||||
|
||||
dev_dbg(&sensor->i2c_client->dev,
|
||||
"configuring pixel format %d\n", pfmt);
|
||||
val = tcm825x_fmt_reg[pfmt]->val;
|
||||
|
||||
err = tcm825x_write_reg_mask(sensor->i2c_client,
|
||||
tcm825x_fmt_reg[pfmt]->reg, val);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
/*
|
||||
* For frame rate < 15, the FPS reg (addr 0x02, bit 7) must be
|
||||
* set. Frame rate will be halved from the normal.
|
||||
*/
|
||||
tgt_fps = fper->denominator / fper->numerator;
|
||||
if (tgt_fps <= HIGH_FPS_MODE_LOWER_LIMIT) {
|
||||
val = tcm825x_read_reg(sensor->i2c_client, 0x02);
|
||||
val |= 0x80;
|
||||
tcm825x_write_reg(sensor->i2c_client, 0x02, val);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Given the image capture format in pix, the nominal frame period in
|
||||
* timeperframe, calculate the required xclk frequency.
|
||||
*
|
||||
* TCM825X input frequency characteristics are:
|
||||
* Minimum 11.9 MHz, Typical 24.57 MHz and maximum 25/27 MHz
|
||||
*/
|
||||
#define XCLK_MIN 11900000
|
||||
#define XCLK_MAX 25000000
|
||||
|
||||
static int ioctl_g_ext_clk(struct v4l2_int_device *s, u32 *xclk)
|
||||
{
|
||||
struct tcm825x_sensor *sensor = s->priv;
|
||||
struct v4l2_fract *timeperframe = &sensor->timeperframe;
|
||||
u32 tgt_xclk; /* target xclk */
|
||||
u32 tgt_fps; /* target frames per secound */
|
||||
|
||||
tgt_fps = timeperframe->denominator / timeperframe->numerator;
|
||||
|
||||
tgt_xclk = (tgt_fps <= HIGH_FPS_MODE_LOWER_LIMIT) ?
|
||||
(2457 * tgt_fps) / MAX_HALF_FPS :
|
||||
(2457 * tgt_fps) / MAX_FPS;
|
||||
tgt_xclk *= 10000;
|
||||
|
||||
tgt_xclk = min(tgt_xclk, (u32)XCLK_MAX);
|
||||
tgt_xclk = max(tgt_xclk, (u32)XCLK_MIN);
|
||||
|
||||
*xclk = tgt_xclk;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ioctl_s_ext_clk(struct v4l2_int_device *s, u32 xclk)
|
||||
{
|
||||
if (xclk > XCLK_MAX || xclk < XCLK_MIN)
|
||||
return -EINVAL;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ioctl_queryctrl(struct v4l2_int_device *s,
|
||||
struct v4l2_queryctrl *qc)
|
||||
{
|
||||
struct vcontrol *control;
|
||||
|
||||
control = find_vctrl(qc->id);
|
||||
|
||||
if (control == NULL)
|
||||
return -EINVAL;
|
||||
|
||||
*qc = control->qc;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ioctl_g_ctrl(struct v4l2_int_device *s,
|
||||
struct v4l2_control *vc)
|
||||
{
|
||||
struct tcm825x_sensor *sensor = s->priv;
|
||||
struct i2c_client *client = sensor->i2c_client;
|
||||
int val, r;
|
||||
struct vcontrol *lvc;
|
||||
|
||||
/* exposure time is special, spread accross 2 registers */
|
||||
if (vc->id == V4L2_CID_EXPOSURE) {
|
||||
int val_lower, val_upper;
|
||||
|
||||
val_upper = tcm825x_read_reg(client,
|
||||
TCM825X_ADDR(TCM825X_ESRSPD_U));
|
||||
if (val_upper < 0)
|
||||
return val_upper;
|
||||
val_lower = tcm825x_read_reg(client,
|
||||
TCM825X_ADDR(TCM825X_ESRSPD_L));
|
||||
if (val_lower < 0)
|
||||
return val_lower;
|
||||
|
||||
vc->value = ((val_upper & 0x1f) << 8) | (val_lower);
|
||||
return 0;
|
||||
}
|
||||
|
||||
lvc = find_vctrl(vc->id);
|
||||
if (lvc == NULL)
|
||||
return -EINVAL;
|
||||
|
||||
r = tcm825x_read_reg(client, TCM825X_ADDR(lvc->reg));
|
||||
if (r < 0)
|
||||
return r;
|
||||
val = r & TCM825X_MASK(lvc->reg);
|
||||
val >>= lvc->start_bit;
|
||||
|
||||
if (val < 0)
|
||||
return val;
|
||||
|
||||
vc->value = val;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ioctl_s_ctrl(struct v4l2_int_device *s,
|
||||
struct v4l2_control *vc)
|
||||
{
|
||||
struct tcm825x_sensor *sensor = s->priv;
|
||||
struct i2c_client *client = sensor->i2c_client;
|
||||
struct vcontrol *lvc;
|
||||
int val = vc->value;
|
||||
|
||||
/* exposure time is special, spread accross 2 registers */
|
||||
if (vc->id == V4L2_CID_EXPOSURE) {
|
||||
int val_lower, val_upper;
|
||||
val_lower = val & TCM825X_MASK(TCM825X_ESRSPD_L);
|
||||
val_upper = (val >> 8) & TCM825X_MASK(TCM825X_ESRSPD_U);
|
||||
|
||||
if (tcm825x_write_reg_mask(client,
|
||||
TCM825X_ESRSPD_U, val_upper))
|
||||
return -EIO;
|
||||
|
||||
if (tcm825x_write_reg_mask(client,
|
||||
TCM825X_ESRSPD_L, val_lower))
|
||||
return -EIO;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
lvc = find_vctrl(vc->id);
|
||||
if (lvc == NULL)
|
||||
return -EINVAL;
|
||||
|
||||
val = val << lvc->start_bit;
|
||||
if (tcm825x_write_reg_mask(client, lvc->reg, val))
|
||||
return -EIO;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ioctl_enum_fmt_cap(struct v4l2_int_device *s,
|
||||
struct v4l2_fmtdesc *fmt)
|
||||
{
|
||||
int index = fmt->index;
|
||||
|
||||
switch (fmt->type) {
|
||||
case V4L2_BUF_TYPE_VIDEO_CAPTURE:
|
||||
if (index >= TCM825X_NUM_CAPTURE_FORMATS)
|
||||
return -EINVAL;
|
||||
break;
|
||||
|
||||
default:
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
fmt->flags = tcm825x_formats[index].flags;
|
||||
strlcpy(fmt->description, tcm825x_formats[index].description,
|
||||
sizeof(fmt->description));
|
||||
fmt->pixelformat = tcm825x_formats[index].pixelformat;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ioctl_try_fmt_cap(struct v4l2_int_device *s,
|
||||
struct v4l2_format *f)
|
||||
{
|
||||
struct tcm825x_sensor *sensor = s->priv;
|
||||
enum image_size isize;
|
||||
int ifmt;
|
||||
struct v4l2_pix_format *pix = &f->fmt.pix;
|
||||
|
||||
isize = tcm825x_find_size(s, pix->width, pix->height);
|
||||
dev_dbg(&sensor->i2c_client->dev, "isize = %d num_capture = %d\n",
|
||||
isize, TCM825X_NUM_CAPTURE_FORMATS);
|
||||
|
||||
pix->width = tcm825x_sizes[isize].width;
|
||||
pix->height = tcm825x_sizes[isize].height;
|
||||
|
||||
for (ifmt = 0; ifmt < TCM825X_NUM_CAPTURE_FORMATS; ifmt++)
|
||||
if (pix->pixelformat == tcm825x_formats[ifmt].pixelformat)
|
||||
break;
|
||||
|
||||
if (ifmt == TCM825X_NUM_CAPTURE_FORMATS)
|
||||
ifmt = 0; /* Default = YUV 4:2:2 */
|
||||
|
||||
pix->pixelformat = tcm825x_formats[ifmt].pixelformat;
|
||||
pix->field = V4L2_FIELD_NONE;
|
||||
pix->bytesperline = pix->width * TCM825X_BYTES_PER_PIXEL;
|
||||
pix->sizeimage = pix->bytesperline * pix->height;
|
||||
pix->priv = 0;
|
||||
dev_dbg(&sensor->i2c_client->dev, "format = 0x%08x\n",
|
||||
pix->pixelformat);
|
||||
|
||||
switch (pix->pixelformat) {
|
||||
case V4L2_PIX_FMT_UYVY:
|
||||
default:
|
||||
pix->colorspace = V4L2_COLORSPACE_JPEG;
|
||||
break;
|
||||
case V4L2_PIX_FMT_RGB565:
|
||||
pix->colorspace = V4L2_COLORSPACE_SRGB;
|
||||
break;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ioctl_s_fmt_cap(struct v4l2_int_device *s,
|
||||
struct v4l2_format *f)
|
||||
{
|
||||
struct tcm825x_sensor *sensor = s->priv;
|
||||
struct v4l2_pix_format *pix = &f->fmt.pix;
|
||||
int rval;
|
||||
|
||||
rval = ioctl_try_fmt_cap(s, f);
|
||||
if (rval)
|
||||
return rval;
|
||||
|
||||
rval = tcm825x_configure(s);
|
||||
|
||||
sensor->pix = *pix;
|
||||
|
||||
return rval;
|
||||
}
|
||||
|
||||
static int ioctl_g_fmt_cap(struct v4l2_int_device *s,
|
||||
struct v4l2_format *f)
|
||||
{
|
||||
struct tcm825x_sensor *sensor = s->priv;
|
||||
|
||||
f->fmt.pix = sensor->pix;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ioctl_g_parm(struct v4l2_int_device *s,
|
||||
struct v4l2_streamparm *a)
|
||||
{
|
||||
struct tcm825x_sensor *sensor = s->priv;
|
||||
struct v4l2_captureparm *cparm = &a->parm.capture;
|
||||
|
||||
if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
|
||||
return -EINVAL;
|
||||
|
||||
memset(a, 0, sizeof(*a));
|
||||
a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
|
||||
|
||||
cparm->capability = V4L2_CAP_TIMEPERFRAME;
|
||||
cparm->timeperframe = sensor->timeperframe;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ioctl_s_parm(struct v4l2_int_device *s,
|
||||
struct v4l2_streamparm *a)
|
||||
{
|
||||
struct tcm825x_sensor *sensor = s->priv;
|
||||
struct v4l2_fract *timeperframe = &a->parm.capture.timeperframe;
|
||||
u32 tgt_fps; /* target frames per secound */
|
||||
int rval;
|
||||
|
||||
if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
|
||||
return -EINVAL;
|
||||
|
||||
if ((timeperframe->numerator == 0)
|
||||
|| (timeperframe->denominator == 0)) {
|
||||
timeperframe->denominator = DEFAULT_FPS;
|
||||
timeperframe->numerator = 1;
|
||||
}
|
||||
|
||||
tgt_fps = timeperframe->denominator / timeperframe->numerator;
|
||||
|
||||
if (tgt_fps > MAX_FPS) {
|
||||
timeperframe->denominator = MAX_FPS;
|
||||
timeperframe->numerator = 1;
|
||||
} else if (tgt_fps < MIN_FPS) {
|
||||
timeperframe->denominator = MIN_FPS;
|
||||
timeperframe->numerator = 1;
|
||||
}
|
||||
|
||||
sensor->timeperframe = *timeperframe;
|
||||
|
||||
rval = tcm825x_configure(s);
|
||||
|
||||
return rval;
|
||||
}
|
||||
|
||||
static int ioctl_s_power(struct v4l2_int_device *s, int on)
|
||||
{
|
||||
struct tcm825x_sensor *sensor = s->priv;
|
||||
|
||||
return sensor->platform_data->power_set(on);
|
||||
}
|
||||
|
||||
static int ioctl_g_needs_reset(struct v4l2_int_device *s, void *buf)
|
||||
{
|
||||
struct tcm825x_sensor *sensor = s->priv;
|
||||
|
||||
return sensor->platform_data->needs_reset(s, buf, &sensor->pix);
|
||||
}
|
||||
|
||||
static int ioctl_reset(struct v4l2_int_device *s)
|
||||
{
|
||||
return -EBUSY;
|
||||
}
|
||||
|
||||
static int ioctl_init(struct v4l2_int_device *s)
|
||||
{
|
||||
return tcm825x_configure(s);
|
||||
}
|
||||
|
||||
static int ioctl_dev_exit(struct v4l2_int_device *s)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ioctl_dev_init(struct v4l2_int_device *s)
|
||||
{
|
||||
struct tcm825x_sensor *sensor = s->priv;
|
||||
int r;
|
||||
|
||||
r = tcm825x_read_reg(sensor->i2c_client, 0x01);
|
||||
if (r < 0)
|
||||
return r;
|
||||
if (r == 0) {
|
||||
dev_err(&sensor->i2c_client->dev, "device not detected\n");
|
||||
return -EIO;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
#define NUM_IOCTLS 17
|
||||
|
||||
static struct v4l2_int_ioctl_desc tcm825x_ioctl_desc[NUM_IOCTLS] = {
|
||||
{ vidioc_int_dev_init_num,
|
||||
(v4l2_int_ioctl_func *)&ioctl_dev_init },
|
||||
{ vidioc_int_dev_exit_num,
|
||||
(v4l2_int_ioctl_func *)&ioctl_dev_exit },
|
||||
{ vidioc_int_s_power_num,
|
||||
(v4l2_int_ioctl_func *)&ioctl_s_power },
|
||||
{ vidioc_int_g_ext_clk_num,
|
||||
(v4l2_int_ioctl_func *)&ioctl_g_ext_clk },
|
||||
{ vidioc_int_s_ext_clk_num,
|
||||
(v4l2_int_ioctl_func *)&ioctl_s_ext_clk },
|
||||
{ vidioc_int_g_needs_reset_num,
|
||||
(v4l2_int_ioctl_func *)&ioctl_g_needs_reset },
|
||||
{ vidioc_int_reset_num,
|
||||
(v4l2_int_ioctl_func *)&ioctl_reset },
|
||||
{ vidioc_int_init_num,
|
||||
(v4l2_int_ioctl_func *)&ioctl_init },
|
||||
{ vidioc_int_enum_fmt_cap_num,
|
||||
(v4l2_int_ioctl_func *)&ioctl_enum_fmt_cap },
|
||||
{ vidioc_int_try_fmt_cap_num,
|
||||
(v4l2_int_ioctl_func *)&ioctl_try_fmt_cap },
|
||||
{ vidioc_int_g_fmt_cap_num,
|
||||
(v4l2_int_ioctl_func *)&ioctl_g_fmt_cap },
|
||||
{ vidioc_int_s_fmt_cap_num,
|
||||
(v4l2_int_ioctl_func *)&ioctl_s_fmt_cap },
|
||||
{ vidioc_int_g_parm_num,
|
||||
(v4l2_int_ioctl_func *)&ioctl_g_parm },
|
||||
{ vidioc_int_s_parm_num,
|
||||
(v4l2_int_ioctl_func *)&ioctl_s_parm },
|
||||
{ vidioc_int_queryctrl_num,
|
||||
(v4l2_int_ioctl_func *)&ioctl_queryctrl },
|
||||
{ vidioc_int_g_ctrl_num,
|
||||
(v4l2_int_ioctl_func *)&ioctl_g_ctrl },
|
||||
{ vidioc_int_s_ctrl_num,
|
||||
(v4l2_int_ioctl_func *)&ioctl_s_ctrl },
|
||||
};
|
||||
|
||||
static struct v4l2_int_slave tcm825x_slave = {
|
||||
.ioctls = tcm825x_ioctl_desc,
|
||||
.num_ioctls = ARRAY_SIZE(tcm825x_ioctl_desc),
|
||||
};
|
||||
|
||||
static struct tcm825x_sensor tcm825x;
|
||||
|
||||
static struct v4l2_int_device tcm825x_int_device = {
|
||||
.module = THIS_MODULE,
|
||||
.name = TCM825X_NAME,
|
||||
.priv = &tcm825x,
|
||||
.type = v4l2_int_type_slave,
|
||||
.u = {
|
||||
.slave = &tcm825x_slave,
|
||||
},
|
||||
};
|
||||
|
||||
static int tcm825x_probe(struct i2c_client *client)
|
||||
{
|
||||
struct tcm825x_sensor *sensor = &tcm825x;
|
||||
int rval;
|
||||
|
||||
if (i2c_get_clientdata(client))
|
||||
return -EBUSY;
|
||||
|
||||
sensor->platform_data = client->dev.platform_data;
|
||||
|
||||
if (sensor->platform_data == NULL
|
||||
&& !sensor->platform_data->is_okay())
|
||||
return -ENODEV;
|
||||
|
||||
sensor->v4l2_int_device = &tcm825x_int_device;
|
||||
|
||||
sensor->i2c_client = client;
|
||||
i2c_set_clientdata(client, sensor);
|
||||
|
||||
/* Make the default capture format QVGA RGB565 */
|
||||
sensor->pix.width = tcm825x_sizes[QVGA].width;
|
||||
sensor->pix.height = tcm825x_sizes[QVGA].height;
|
||||
sensor->pix.pixelformat = V4L2_PIX_FMT_RGB565;
|
||||
|
||||
rval = v4l2_int_device_register(sensor->v4l2_int_device);
|
||||
if (rval)
|
||||
i2c_set_clientdata(client, NULL);
|
||||
|
||||
return rval;
|
||||
}
|
||||
|
||||
static int __exit tcm825x_remove(struct i2c_client *client)
|
||||
{
|
||||
struct tcm825x_sensor *sensor = i2c_get_clientdata(client);
|
||||
|
||||
if (!client->adapter)
|
||||
return -ENODEV; /* our client isn't attached */
|
||||
|
||||
v4l2_int_device_unregister(sensor->v4l2_int_device);
|
||||
i2c_set_clientdata(client, NULL);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct i2c_driver tcm825x_i2c_driver = {
|
||||
.driver = {
|
||||
.name = TCM825X_NAME,
|
||||
},
|
||||
.probe = &tcm825x_probe,
|
||||
.remove = __exit_p(&tcm825x_remove),
|
||||
};
|
||||
|
||||
static struct tcm825x_sensor tcm825x = {
|
||||
.timeperframe = {
|
||||
.numerator = 1,
|
||||
.denominator = DEFAULT_FPS,
|
||||
},
|
||||
};
|
||||
|
||||
static int __init tcm825x_init(void)
|
||||
{
|
||||
int rval;
|
||||
int i = 0;
|
||||
|
||||
/* Just an experiment --- don't use *_cb functions yet. */
|
||||
tcm825x_ioctl_desc[i++] = vidioc_int_dev_init_cb(&ioctl_dev_init);
|
||||
BUG_ON(i >= NUM_IOCTLS);
|
||||
|
||||
rval = i2c_add_driver(&tcm825x_i2c_driver);
|
||||
if (rval)
|
||||
printk(KERN_INFO "%s: failed registering " TCM825X_NAME "\n",
|
||||
__FUNCTION__);
|
||||
|
||||
return rval;
|
||||
}
|
||||
|
||||
static void __exit tcm825x_exit(void)
|
||||
{
|
||||
i2c_del_driver(&tcm825x_i2c_driver);
|
||||
}
|
||||
|
||||
/*
|
||||
* FIXME: Menelaus isn't ready (?) at module_init stage, so use
|
||||
* late_initcall for now.
|
||||
*/
|
||||
late_initcall(tcm825x_init);
|
||||
module_exit(tcm825x_exit);
|
||||
|
||||
MODULE_AUTHOR("Sakari Ailus <sakari.ailus@nokia.com>");
|
||||
MODULE_DESCRIPTION("TCM825x camera sensor driver");
|
||||
MODULE_LICENSE("GPL");
|
||||
195
drivers/media/video/tcm825x.h
Normal file
195
drivers/media/video/tcm825x.h
Normal file
@ -0,0 +1,195 @@
|
||||
/*
|
||||
* drivers/media/video/tcm825x.h
|
||||
*
|
||||
* Register definitions for the TCM825X CameraChip.
|
||||
*
|
||||
* Author: David Cohen (david.cohen@indt.org.br)
|
||||
*
|
||||
* This file is licensed under the terms of the GNU General Public License
|
||||
* version 2. This program is licensed "as is" without any warranty of any
|
||||
* kind, whether express or implied.
|
||||
*
|
||||
* This file was based on ov9640.h from MontaVista
|
||||
*/
|
||||
|
||||
#ifndef TCM825X_H
|
||||
#define TCM825X_H
|
||||
|
||||
#include <linux/videodev2.h>
|
||||
|
||||
#include <media/v4l2-int-device.h>
|
||||
|
||||
#define TCM825X_NAME "tcm825x"
|
||||
|
||||
#define TCM825X_MASK(x) x & 0x00ff
|
||||
#define TCM825X_ADDR(x) (x & 0xff00) >> 8
|
||||
|
||||
/* The TCM825X I2C sensor chip has a fixed slave address of 0x3d. */
|
||||
#define TCM825X_I2C_ADDR 0x3d
|
||||
|
||||
/*
|
||||
* define register offsets for the TCM825X sensor chip
|
||||
* OFFSET(8 bits) + MASK(8 bits)
|
||||
* MASK bit 4 and 3 are used when the register uses more than one address
|
||||
*/
|
||||
#define TCM825X_FPS 0x0280
|
||||
#define TCM825X_ACF 0x0240
|
||||
#define TCM825X_DOUTBUF 0x020C
|
||||
#define TCM825X_DCLKP 0x0202
|
||||
#define TCM825X_ACFDET 0x0201
|
||||
#define TCM825X_DOUTSW 0x0380
|
||||
#define TCM825X_DATAHZ 0x0340
|
||||
#define TCM825X_PICSIZ 0x033c
|
||||
#define TCM825X_PICFMT 0x0302
|
||||
#define TCM825X_V_INV 0x0480
|
||||
#define TCM825X_H_INV 0x0440
|
||||
#define TCM825X_ESRLSW 0x0430
|
||||
#define TCM825X_V_LENGTH 0x040F
|
||||
#define TCM825X_ALCSW 0x0580
|
||||
#define TCM825X_ESRLIM 0x0560
|
||||
#define TCM825X_ESRSPD_U 0x051F
|
||||
#define TCM825X_ESRSPD_L 0x06FF
|
||||
#define TCM825X_AG 0x07FF
|
||||
#define TCM825X_ESRSPD2 0x06FF
|
||||
#define TCM825X_ALCMODE 0x0830
|
||||
#define TCM825X_ALCH 0x080F
|
||||
#define TCM825X_ALCL 0x09FF
|
||||
#define TCM825X_AWBSW 0x0A80
|
||||
#define TCM825X_MRG 0x0BFF
|
||||
#define TCM825X_MBG 0x0CFF
|
||||
#define TCM825X_GAMSW 0x0D80
|
||||
#define TCM825X_HDTG 0x0EFF
|
||||
#define TCM825X_VDTG 0x0FFF
|
||||
#define TCM825X_HDTCORE 0x10F0
|
||||
#define TCM825X_VDTCORE 0x100F
|
||||
#define TCM825X_CONT 0x11FF
|
||||
#define TCM825X_BRIGHT 0x12FF
|
||||
#define TCM825X_VHUE 0x137F
|
||||
#define TCM825X_UHUE 0x147F
|
||||
#define TCM825X_VGAIN 0x153F
|
||||
#define TCM825X_UGAIN 0x163F
|
||||
#define TCM825X_UVCORE 0x170F
|
||||
#define TCM825X_SATU 0x187F
|
||||
#define TCM825X_MHMODE 0x1980
|
||||
#define TCM825X_MHLPFSEL 0x1940
|
||||
#define TCM825X_YMODE 0x1930
|
||||
#define TCM825X_MIXHG 0x1907
|
||||
#define TCM825X_LENS 0x1A3F
|
||||
#define TCM825X_AGLIM 0x1BE0
|
||||
#define TCM825X_LENSRPOL 0x1B10
|
||||
#define TCM825X_LENSRGAIN 0x1B0F
|
||||
#define TCM825X_ES100S 0x1CFF
|
||||
#define TCM825X_ES120S 0x1DFF
|
||||
#define TCM825X_DMASK 0x1EC0
|
||||
#define TCM825X_CODESW 0x1E20
|
||||
#define TCM825X_CODESEL 0x1E10
|
||||
#define TCM825X_TESPIC 0x1E04
|
||||
#define TCM825X_PICSEL 0x1E03
|
||||
#define TCM825X_HNUM 0x20FF
|
||||
#define TCM825X_VOUTPH 0x287F
|
||||
#define TCM825X_ESROUT 0x327F
|
||||
#define TCM825X_ESROUT2 0x33FF
|
||||
#define TCM825X_AGOUT 0x34FF
|
||||
#define TCM825X_DGOUT 0x353F
|
||||
#define TCM825X_AGSLOW1 0x39C0
|
||||
#define TCM825X_FLLSMODE 0x3930
|
||||
#define TCM825X_FLLSLIM 0x390F
|
||||
#define TCM825X_DETSEL 0x3AF0
|
||||
#define TCM825X_ACDETNC 0x3A0F
|
||||
#define TCM825X_AGSLOW2 0x3BC0
|
||||
#define TCM825X_DG 0x3B3F
|
||||
#define TCM825X_REJHLEV 0x3CFF
|
||||
#define TCM825X_ALCLOCK 0x3D80
|
||||
#define TCM825X_FPSLNKSW 0x3D40
|
||||
#define TCM825X_ALCSPD 0x3D30
|
||||
#define TCM825X_REJH 0x3D03
|
||||
#define TCM825X_SHESRSW 0x3E80
|
||||
#define TCM825X_ESLIMSEL 0x3E40
|
||||
#define TCM825X_SHESRSPD 0x3E30
|
||||
#define TCM825X_ELSTEP 0x3E0C
|
||||
#define TCM825X_ELSTART 0x3E03
|
||||
#define TCM825X_AGMIN 0x3FFF
|
||||
#define TCM825X_PREGRG 0x423F
|
||||
#define TCM825X_PREGBG 0x433F
|
||||
#define TCM825X_PRERG 0x443F
|
||||
#define TCM825X_PREBG 0x453F
|
||||
#define TCM825X_MSKBR 0x477F
|
||||
#define TCM825X_MSKGR 0x487F
|
||||
#define TCM825X_MSKRB 0x497F
|
||||
#define TCM825X_MSKGB 0x4A7F
|
||||
#define TCM825X_MSKRG 0x4B7F
|
||||
#define TCM825X_MSKBG 0x4C7F
|
||||
#define TCM825X_HDTCSW 0x4D80
|
||||
#define TCM825X_VDTCSW 0x4D40
|
||||
#define TCM825X_DTCYL 0x4D3F
|
||||
#define TCM825X_HDTPSW 0x4E80
|
||||
#define TCM825X_VDTPSW 0x4E40
|
||||
#define TCM825X_DTCGAIN 0x4E3F
|
||||
#define TCM825X_DTLLIMSW 0x4F10
|
||||
#define TCM825X_DTLYLIM 0x4F0F
|
||||
#define TCM825X_YLCUTLMSK 0x5080
|
||||
#define TCM825X_YLCUTL 0x503F
|
||||
#define TCM825X_YLCUTHMSK 0x5180
|
||||
#define TCM825X_YLCUTH 0x513F
|
||||
#define TCM825X_UVSKNC 0x527F
|
||||
#define TCM825X_UVLJ 0x537F
|
||||
#define TCM825X_WBGMIN 0x54FF
|
||||
#define TCM825X_WBGMAX 0x55FF
|
||||
#define TCM825X_WBSPDUP 0x5603
|
||||
#define TCM825X_ALLAREA 0x5820
|
||||
#define TCM825X_WBLOCK 0x5810
|
||||
#define TCM825X_WB2SP 0x580F
|
||||
#define TCM825X_KIZUSW 0x5920
|
||||
#define TCM825X_PBRSW 0x5910
|
||||
#define TCM825X_ABCSW 0x5903
|
||||
#define TCM825X_PBDLV 0x5AFF
|
||||
#define TCM825X_PBC1LV 0x5BFF
|
||||
|
||||
#define TCM825X_NUM_REGS (TCM825X_ADDR(TCM825X_PBC1LV) + 1)
|
||||
|
||||
#define TCM825X_BYTES_PER_PIXEL 2
|
||||
|
||||
#define TCM825X_REG_TERM 0xff /* terminating list entry for reg */
|
||||
#define TCM825X_VAL_TERM 0xff /* terminating list entry for val */
|
||||
|
||||
/* define a structure for tcm825x register initialization values */
|
||||
struct tcm825x_reg {
|
||||
u8 val;
|
||||
u16 reg;
|
||||
};
|
||||
|
||||
enum image_size { subQCIF = 0, QQVGA, QCIF, QVGA, CIF, VGA };
|
||||
enum pixel_format { YUV422 = 0, RGB565 };
|
||||
#define NUM_IMAGE_SIZES 6
|
||||
#define NUM_PIXEL_FORMATS 2
|
||||
|
||||
struct capture_size {
|
||||
unsigned long width;
|
||||
unsigned long height;
|
||||
};
|
||||
|
||||
struct tcm825x_platform_data {
|
||||
/* Is the sensor usable? Doesn't yet mean it's there, but you
|
||||
* can try! */
|
||||
int (*is_okay)(void);
|
||||
/* Set power state, zero is off, non-zero is on. */
|
||||
int (*power_set)(int power);
|
||||
/* Default registers written after power-on or reset. */
|
||||
const struct tcm825x_reg *(*default_regs)(void);
|
||||
int (*needs_reset)(struct v4l2_int_device *s, void *buf,
|
||||
struct v4l2_pix_format *fmt);
|
||||
};
|
||||
|
||||
/* Array of image sizes supported by TCM825X. These must be ordered from
|
||||
* smallest image size to largest.
|
||||
*/
|
||||
const static struct capture_size tcm825x_sizes[] = {
|
||||
{ 128, 96 }, /* subQCIF */
|
||||
{ 160, 120 }, /* QQVGA */
|
||||
{ 176, 144 }, /* QCIF */
|
||||
{ 320, 240 }, /* QVGA */
|
||||
{ 352, 288 }, /* CIF */
|
||||
{ 640, 480 }, /* VGA */
|
||||
};
|
||||
|
||||
#endif /* ifndef TCM825X_H */
|
||||
Loading…
Reference in New Issue
Block a user