leandrof/linux
1
0
Fork 0
forked from Minki/linux
Code Issues Pull Requests Packages Projects Releases Wiki Activity
4fc8b64823
linux/drivers/media/video/gspca/mr97310a.c
Theodore Kilgore 32345b0596 V4L/DVB (13264): gspca_mr97310a: Change vstart for CIF sensor type 1 cams 
gspca_mr97310a: Change vstart for CIF sensor type 1 cams

This fixes the distortion at the end of the frame, and avoids the bad frame
dropping done because of this distortion, trippling the framerate!

Signed-off-by: Theodore Kilgore <kilgota@banach.math.auburn.edu>
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>
2009-11-07 12:55:12 -02:00

986 lines
24 KiB
C
Raw Blame History

/*
* Mars MR97310A library
*
* Copyright (C) 2009 Kyle Guinn <elyk03@gmail.com>
*
* Support for the MR97310A cameras in addition to the Aiptek Pencam VGA+
* and for the routines for detecting and classifying these various cameras,
*
* Copyright (C) 2009 Theodore Kilgore <kilgota@auburn.edu>
*
* Acknowledgements:
*
* The MR97311A support in gspca/mars.c has been helpful in understanding some
* of the registers in these cameras.
*
* Hans de Goede <hdgoede@redhat.com> and
* Thomas Kaiser <thomas@kaiser-linux.li>
* have assisted with their experience. Each of them has also helped by
* testing a previously unsupported camera.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#define MODULE_NAME "mr97310a"
#include "gspca.h"
#define CAM_TYPE_CIF 0
#define CAM_TYPE_VGA 1
#define MR97310A_BRIGHTNESS_MIN -254
#define MR97310A_BRIGHTNESS_MAX 255
#define MR97310A_BRIGHTNESS_DEFAULT 0
#define MR97310A_EXPOSURE_MIN 300
#define MR97310A_EXPOSURE_MAX 4095
#define MR97310A_EXPOSURE_DEFAULT 1000
#define MR97310A_GAIN_MIN 0
#define MR97310A_GAIN_MAX 31
#define MR97310A_GAIN_DEFAULT 25
MODULE_AUTHOR("Kyle Guinn <elyk03@gmail.com>,"
"Theodore Kilgore <kilgota@auburn.edu>");
MODULE_DESCRIPTION("GSPCA/Mars-Semi MR97310A USB Camera Driver");
MODULE_LICENSE("GPL");
/* global parameters */
int force_sensor_type = -1;
module_param(force_sensor_type, int, 0644);
MODULE_PARM_DESC(force_sensor_type, "Force sensor type (-1 (auto), 0 or 1)");
/* specific webcam descriptor */
struct sd {
struct gspca_dev gspca_dev; /* !! must be the first item */
u8 sof_read;
u8 cam_type; /* 0 is CIF and 1 is VGA */
u8 sensor_type; /* We use 0 and 1 here, too. */
u8 do_lcd_stop;
int brightness;
u16 exposure;
u8 gain;
};
struct sensor_w_data {
u8 reg;
u8 flags;
u8 data[16];
int len;
};
static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val);
static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val);
static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val);
static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val);
static void setbrightness(struct gspca_dev *gspca_dev);
static void setexposure(struct gspca_dev *gspca_dev);
static void setgain(struct gspca_dev *gspca_dev);
/* V4L2 controls supported by the driver */
static struct ctrl sd_ctrls[] = {
{
#define BRIGHTNESS_IDX 0
{
.id = V4L2_CID_BRIGHTNESS,
.type = V4L2_CTRL_TYPE_INTEGER,
.name = "Brightness",
.minimum = MR97310A_BRIGHTNESS_MIN,
.maximum = MR97310A_BRIGHTNESS_MAX,
.step = 1,
.default_value = MR97310A_BRIGHTNESS_DEFAULT,
.flags = 0,
},
.set = sd_setbrightness,
.get = sd_getbrightness,
},
{
#define EXPOSURE_IDX 1
{
.id = V4L2_CID_EXPOSURE,
.type = V4L2_CTRL_TYPE_INTEGER,
.name = "Exposure",
.minimum = MR97310A_EXPOSURE_MIN,
.maximum = MR97310A_EXPOSURE_MAX,
.step = 1,
.default_value = MR97310A_EXPOSURE_DEFAULT,
.flags = 0,
},
.set = sd_setexposure,
.get = sd_getexposure,
},
{
#define GAIN_IDX 2
{
.id = V4L2_CID_GAIN,
.type = V4L2_CTRL_TYPE_INTEGER,
.name = "Gain",
.minimum = MR97310A_GAIN_MIN,
.maximum = MR97310A_GAIN_MAX,
.step = 1,
.default_value = MR97310A_GAIN_DEFAULT,
.flags = 0,
},
.set = sd_setgain,
.get = sd_getgain,
},
};
static const struct v4l2_pix_format vga_mode[] = {
{160, 120, V4L2_PIX_FMT_MR97310A, V4L2_FIELD_NONE,
.bytesperline = 160,
.sizeimage = 160 * 120,
.colorspace = V4L2_COLORSPACE_SRGB,
.priv = 4},
{176, 144, V4L2_PIX_FMT_MR97310A, V4L2_FIELD_NONE,
.bytesperline = 176,
.sizeimage = 176 * 144,
.colorspace = V4L2_COLORSPACE_SRGB,
.priv = 3},
{320, 240, V4L2_PIX_FMT_MR97310A, V4L2_FIELD_NONE,
.bytesperline = 320,
.sizeimage = 320 * 240,
.colorspace = V4L2_COLORSPACE_SRGB,
.priv = 2},
{352, 288, V4L2_PIX_FMT_MR97310A, V4L2_FIELD_NONE,
.bytesperline = 352,
.sizeimage = 352 * 288,
.colorspace = V4L2_COLORSPACE_SRGB,
.priv = 1},
{640, 480, V4L2_PIX_FMT_MR97310A, V4L2_FIELD_NONE,
.bytesperline = 640,
.sizeimage = 640 * 480,
.colorspace = V4L2_COLORSPACE_SRGB,
.priv = 0},
};
/* the bytes to write are in gspca_dev->usb_buf */
static int mr_write(struct gspca_dev *gspca_dev, int len)
{
int rc;
rc = usb_bulk_msg(gspca_dev->dev,
usb_sndbulkpipe(gspca_dev->dev, 4),
gspca_dev->usb_buf, len, NULL, 500);
if (rc < 0)
PDEBUG(D_ERR, "reg write [%02x] error %d",
gspca_dev->usb_buf[0], rc);
return rc;
}
/* the bytes are read into gspca_dev->usb_buf */
static int mr_read(struct gspca_dev *gspca_dev, int len)
{
int rc;
rc = usb_bulk_msg(gspca_dev->dev,
usb_rcvbulkpipe(gspca_dev->dev, 3),
gspca_dev->usb_buf, len, NULL, 500);
if (rc < 0)
PDEBUG(D_ERR, "reg read [%02x] error %d",
gspca_dev->usb_buf[0], rc);
return rc;
}
static int sensor_write_reg(struct gspca_dev *gspca_dev, u8 reg, u8 flags,
const u8 *data, int len)
{
gspca_dev->usb_buf[0] = 0x1f;
gspca_dev->usb_buf[1] = flags;
gspca_dev->usb_buf[2] = reg;
memcpy(gspca_dev->usb_buf + 3, data, len);
return mr_write(gspca_dev, len + 3);
}
static int sensor_write_regs(struct gspca_dev *gspca_dev,
const struct sensor_w_data *data, int len)
{
int i, rc;
for (i = 0; i < len; i++) {
rc = sensor_write_reg(gspca_dev, data[i].reg, data[i].flags,
data[i].data, data[i].len);
if (rc < 0)
return rc;
}
return 0;
}
static int sensor_write1(struct gspca_dev *gspca_dev, u8 reg, u8 data)
{
struct sd *sd = (struct sd *) gspca_dev;
u8 buf, confirm_reg;
int rc;
buf = data;
rc = sensor_write_reg(gspca_dev, reg, 0x01, &buf, 1);
if (rc < 0)
return rc;
buf = 0x01;
confirm_reg = sd->sensor_type ? 0x13 : 0x11;
rc = sensor_write_reg(gspca_dev, confirm_reg, 0x00, &buf, 1);
if (rc < 0)
return rc;
return 0;
}
static int cam_get_response16(struct gspca_dev *gspca_dev)
{
__u8 *data = gspca_dev->usb_buf;
int err_code;
data[0] = 0x21;
err_code = mr_write(gspca_dev, 1);
if (err_code < 0)
return err_code;
err_code = mr_read(gspca_dev, 16);
return err_code;
}
static int zero_the_pointer(struct gspca_dev *gspca_dev)
{
__u8 *data = gspca_dev->usb_buf;
int err_code;
u8 status = 0;
int tries = 0;
err_code = cam_get_response16(gspca_dev);
if (err_code < 0)
return err_code;
err_code = mr_write(gspca_dev, 1);
data[0] = 0x19;
data[1] = 0x51;
err_code = mr_write(gspca_dev, 2);
if (err_code < 0)
return err_code;
err_code = cam_get_response16(gspca_dev);
if (err_code < 0)
return err_code;
data[0] = 0x19;
data[1] = 0xba;
err_code = mr_write(gspca_dev, 2);
if (err_code < 0)
return err_code;
err_code = cam_get_response16(gspca_dev);
if (err_code < 0)
return err_code;
data[0] = 0x19;
data[1] = 0x00;
err_code = mr_write(gspca_dev, 2);
if (err_code < 0)
return err_code;
err_code = cam_get_response16(gspca_dev);
if (err_code < 0)
return err_code;
data[0] = 0x19;
data[1] = 0x00;
err_code = mr_write(gspca_dev, 2);
if (err_code < 0)
return err_code;
while (status != 0x0a && tries < 256) {
err_code = cam_get_response16(gspca_dev);
status = data[0];
tries++;
if (err_code < 0)
return err_code;
}
if (status != 0x0a)
PDEBUG(D_ERR, "status is %02x", status);
tries = 0;
while (tries < 4) {
data[0] = 0x19;
data[1] = 0x00;
err_code = mr_write(gspca_dev, 2);
if (err_code < 0)
return err_code;
err_code = cam_get_response16(gspca_dev);
status = data[0];
tries++;
if (err_code < 0)
return err_code;
}
data[0] = 0x19;
err_code = mr_write(gspca_dev, 1);
if (err_code < 0)
return err_code;
err_code = mr_read(gspca_dev, 16);
if (err_code < 0)
return err_code;
return 0;
}
static u8 get_sensor_id(struct gspca_dev *gspca_dev)
{
int err_code;
gspca_dev->usb_buf[0] = 0x1e;
err_code = mr_write(gspca_dev, 1);
if (err_code < 0)
return err_code;
err_code = mr_read(gspca_dev, 16);
if (err_code < 0)
return err_code;
PDEBUG(D_PROBE, "Byte zero reported is %01x", gspca_dev->usb_buf[0]);
return gspca_dev->usb_buf[0];
}
/* this function is called at probe time */
static int sd_config(struct gspca_dev *gspca_dev,
const struct usb_device_id *id)
{
struct sd *sd = (struct sd *) gspca_dev;
struct cam *cam;
__u8 *data = gspca_dev->usb_buf;
int err_code;
cam = &gspca_dev->cam;
cam->cam_mode = vga_mode;
cam->nmodes = ARRAY_SIZE(vga_mode);
if (id->idProduct == 0x010e) {
sd->cam_type = CAM_TYPE_CIF;
cam->nmodes--;
data[0] = 0x01;
data[1] = 0x01;
err_code = mr_write(gspca_dev, 2);
if (err_code < 0)
return err_code;
msleep(200);
data[0] = get_sensor_id(gspca_dev);
/*
* Known CIF cameras. If you have another to report, please do
*
* Name byte just read sd->sensor_type
* reported by
* Sakar Spy-shot 0x28 T. Kilgore 0
* Innovage 0xf5 (unstable) T. Kilgore 0
* Vivitar Mini 0x53 H. De Goede 0
* Vivitar Mini 0x04 / 0x24 E. Rodriguez 0
* Vivitar Mini 0x08 T. Kilgore 1
* Elta-Media 8212dc 0x23 T. Kaiser 1
* Philips dig. keych. 0x37 T. Kilgore 1
*/
if ((data[0] & 0x78) == 8 ||
((data[0] & 0x2) == 0x2 && data[0] != 0x53))
sd->sensor_type = 1;
else
sd->sensor_type = 0;
PDEBUG(D_PROBE, "MR97310A CIF camera detected, sensor: %d",
sd->sensor_type);
if (force_sensor_type != -1) {
sd->sensor_type = !! force_sensor_type;
PDEBUG(D_PROBE, "Forcing sensor type to: %d",
sd->sensor_type);
}
if (sd->sensor_type == 0)
gspca_dev->ctrl_dis = (1 << BRIGHTNESS_IDX);
} else {
sd->cam_type = CAM_TYPE_VGA;
PDEBUG(D_PROBE, "MR97310A VGA camera detected");
gspca_dev->ctrl_dis = (1 << BRIGHTNESS_IDX) |
(1 << EXPOSURE_IDX) | (1 << GAIN_IDX);
}
sd->brightness = MR97310A_BRIGHTNESS_DEFAULT;
sd->exposure = MR97310A_EXPOSURE_DEFAULT;
sd->gain = MR97310A_GAIN_DEFAULT;
return 0;
}
/* this function is called at probe and resume time */
static int sd_init(struct gspca_dev *gspca_dev)
{
return 0;
}
static int start_cif_cam(struct gspca_dev *gspca_dev)
{
struct sd *sd = (struct sd *) gspca_dev;
__u8 *data = gspca_dev->usb_buf;
int err_code;
const __u8 startup_string[] = {
0x00,
0x0d,
0x01,
0x00, /* Hsize/8 for 352 or 320 */
0x00, /* Vsize/4 for 288 or 240 */
0x13, /* or 0xbb, depends on sensor */
0x00, /* Hstart, depends on res. */
0x00, /* reserved ? */
0x00, /* Vstart, depends on res. and sensor */
0x50, /* 0x54 to get 176 or 160 */
0xc0
};
/* Note: Some of the above descriptions guessed from MR97113A driver */
data[0] = 0x01;
data[1] = 0x01;
err_code = mr_write(gspca_dev, 2);
if (err_code < 0)
return err_code;
memcpy(data, startup_string, 11);
if (sd->sensor_type)
data[5] = 0xbb;
switch (gspca_dev->width) {
case 160:
data[9] |= 0x04; /* reg 8, 2:1 scale down from 320 */
/* fall thru */
case 320:
default:
data[3] = 0x28; /* reg 2, H size/8 */
data[4] = 0x3c; /* reg 3, V size/4 */
data[6] = 0x14; /* reg 5, H start */
data[8] = 0x1a + sd->sensor_type; /* reg 7, V start */
break;
case 176:
data[9] |= 0x04; /* reg 8, 2:1 scale down from 352 */
/* fall thru */
case 352:
data[3] = 0x2c; /* reg 2, H size/8 */
data[4] = 0x48; /* reg 3, V size/4 */
data[6] = 0x06; /* reg 5, H start */
data[8] = 0x06 - sd->sensor_type; /* reg 7, V start */
break;
}
err_code = mr_write(gspca_dev, 11);
if (err_code < 0)
return err_code;
if (!sd->sensor_type) {
const struct sensor_w_data cif_sensor0_init_data[] = {
{0x02, 0x00, {0x03, 0x5a, 0xb5, 0x01,
0x0f, 0x14, 0x0f, 0x10}, 8},
{0x0c, 0x00, {0x04, 0x01, 0x01, 0x00, 0x1f}, 5},
{0x12, 0x00, {0x07}, 1},
{0x1f, 0x00, {0x06}, 1},
{0x27, 0x00, {0x04}, 1},
{0x29, 0x00, {0x0c}, 1},
{0x40, 0x00, {0x40, 0x00, 0x04}, 3},
{0x50, 0x00, {0x60}, 1},
{0x60, 0x00, {0x06}, 1},
{0x6b, 0x00, {0x85, 0x85, 0xc8, 0xc8, 0xc8, 0xc8}, 6},
{0x72, 0x00, {0x1e, 0x56}, 2},
{0x75, 0x00, {0x58, 0x40, 0xa2, 0x02, 0x31, 0x02,
0x31, 0x80, 0x00}, 9},
{0x11, 0x00, {0x01}, 1},
{0, 0, {0}, 0}
};
err_code = sensor_write_regs(gspca_dev, cif_sensor0_init_data,
ARRAY_SIZE(cif_sensor0_init_data));
} else { /* sd->sensor_type = 1 */
const struct sensor_w_data cif_sensor1_init_data[] = {
/* Reg 3,4, 7,8 get set by the controls */
{0x02, 0x00, {0x10}, 1},
{0x05, 0x01, {0x22}, 1}, /* 5/6 also seen as 65h/32h */
{0x06, 0x01, {0x00}, 1},
{0x09, 0x02, {0x0e}, 1},
{0x0a, 0x02, {0x05}, 1},
{0x0b, 0x02, {0x05}, 1},
{0x0c, 0x02, {0x0f}, 1},
{0x0d, 0x02, {0x07}, 1},
{0x0e, 0x02, {0x0c}, 1},
{0x0f, 0x00, {0x00}, 1},
{0x10, 0x00, {0x06}, 1},
{0x11, 0x00, {0x07}, 1},
{0x12, 0x00, {0x00}, 1},
{0x13, 0x00, {0x01}, 1},
{0, 0, {0}, 0}
};
err_code = sensor_write_regs(gspca_dev, cif_sensor1_init_data,
ARRAY_SIZE(cif_sensor1_init_data));
}
if (err_code < 0)
return err_code;
setbrightness(gspca_dev);
setexposure(gspca_dev);
setgain(gspca_dev);
msleep(200);
data[0] = 0x00;
data[1] = 0x4d; /* ISOC transfering enable... */
err_code = mr_write(gspca_dev, 2);
if (err_code < 0)
return err_code;
return 0;
}
static int start_vga_cam(struct gspca_dev *gspca_dev)
{
struct sd *sd = (struct sd *) gspca_dev;
__u8 *data = gspca_dev->usb_buf;
int err_code;
const __u8 startup_string[] = {0x00, 0x0d, 0x01, 0x00, 0x00, 0x2b,
0x00, 0x00, 0x00, 0x50, 0xc0};
/* What some of these mean is explained in start_cif_cam(), above */
sd->sof_read = 0;
/*
* We have to know which camera we have, because the register writes
* depend upon the camera. This test, run before we actually enter
* the initialization routine, distinguishes most of the cameras, If
* needed, another routine is done later, too.
*/
memset(data, 0, 16);
data[0] = 0x20;
err_code = mr_write(gspca_dev, 1);
if (err_code < 0)
return err_code;
err_code = mr_read(gspca_dev, 16);
if (err_code < 0)
return err_code;
PDEBUG(D_PROBE, "Byte reported is %02x", data[0]);
msleep(200);
/*
* Known VGA cameras. If you have another to report, please do
*
* Name byte just read sd->sensor_type
* sd->do_lcd_stop
* Aiptek Pencam VGA+ 0x31 0 1
* ION digital 0x31 0 1
* Argus DC-1620 0x30 1 0
* Argus QuickClix 0x30 1 1 (not caught here)
*/
sd->sensor_type = data[0] & 1;
sd->do_lcd_stop = (~data[0]) & 1;
/* Streaming setup begins here. */
data[0] = 0x01;
data[1] = 0x01;
err_code = mr_write(gspca_dev, 2);
if (err_code < 0)
return err_code;
/*
* A second test can now resolve any remaining ambiguity in the
* identification of the camera type,
*/
if (!sd->sensor_type) {
data[0] = get_sensor_id(gspca_dev);
if (data[0] == 0x7f) {
sd->sensor_type = 1;
PDEBUG(D_PROBE, "sensor_type corrected to 1");
}
msleep(200);
}
if (force_sensor_type != -1) {
sd->sensor_type = !! force_sensor_type;
PDEBUG(D_PROBE, "Forcing sensor type to: %d",
sd->sensor_type);
}
/*
* Known VGA cameras.
* This test is only run if the previous test returned 0x30, but
* here is the information for all others, too, just for reference.
*
* Name byte just read sd->sensor_type
*
* Aiptek Pencam VGA+ 0xfb (this test not run) 1
* ION digital 0xbd (this test not run) 1
* Argus DC-1620 0xe5 (no change) 0
* Argus QuickClix 0x7f (reclassified) 1
*/
memcpy(data, startup_string, 11);
if (!sd->sensor_type) {
data[5] = 0x00;
data[10] = 0x91;
}
switch (gspca_dev->width) {
case 160:
data[9] |= 0x0c; /* reg 8, 4:1 scale down */
/* fall thru */
case 320:
data[9] |= 0x04; /* reg 8, 2:1 scale down */
/* fall thru */
case 640:
default:
data[3] = 0x50; /* reg 2, H size/8 */
data[4] = 0x78; /* reg 3, V size/4 */
data[6] = 0x04; /* reg 5, H start */
data[8] = 0x03; /* reg 7, V start */
if (sd->do_lcd_stop)
data[8] = 0x04; /* Bayer tile shifted */
break;
case 176:
data[9] |= 0x04; /* reg 8, 2:1 scale down */
/* fall thru */
case 352:
data[3] = 0x2c; /* reg 2, H size */
data[4] = 0x48; /* reg 3, V size */
data[6] = 0x94; /* reg 5, H start */
data[8] = 0x63; /* reg 7, V start */
if (sd->do_lcd_stop)
data[8] = 0x64; /* Bayer tile shifted */
break;
}
err_code = mr_write(gspca_dev, 11);
if (err_code < 0)
return err_code;
if (!sd->sensor_type) {
/* The only known sensor_type 0 cam is the Argus DC-1620 */
const struct sensor_w_data vga_sensor0_init_data[] = {
{0x01, 0x00, {0x0c, 0x00, 0x04}, 3},
{0x14, 0x00, {0x01, 0xe4, 0x02, 0x84}, 4},
{0x20, 0x00, {0x00, 0x80, 0x00, 0x08}, 4},
{0x25, 0x00, {0x03, 0xa9, 0x80}, 3},
{0x30, 0x00, {0x30, 0x18, 0x10, 0x18}, 4},
{0, 0, {0}, 0}
};
err_code = sensor_write_regs(gspca_dev, vga_sensor0_init_data,
ARRAY_SIZE(vga_sensor0_init_data));
} else { /* sd->sensor_type = 1 */
const struct sensor_w_data vga_sensor1_init_data[] = {
{0x02, 0x00, {0x06, 0x59, 0x0c, 0x16, 0x00,
0x07, 0x00, 0x01}, 8},
{0x11, 0x04, {0x01}, 1},
/*{0x0a, 0x00, {0x00, 0x01, 0x00, 0x00, 0x01, */
{0x0a, 0x00, {0x01, 0x06, 0x00, 0x00, 0x01,
0x00, 0x0a}, 7},
{0x11, 0x04, {0x01}, 1},
{0x12, 0x00, {0x00, 0x63, 0x00, 0x70, 0x00, 0x00}, 6},
{0x11, 0x04, {0x01}, 1},
{0, 0, {0}, 0}
};
err_code = sensor_write_regs(gspca_dev, vga_sensor1_init_data,
ARRAY_SIZE(vga_sensor1_init_data));
}
if (err_code < 0)
return err_code;
msleep(200);
data[0] = 0x00;
data[1] = 0x4d; /* ISOC transfering enable... */
err_code = mr_write(gspca_dev, 2);
return err_code;
}
static int sd_start(struct gspca_dev *gspca_dev)
{
struct sd *sd = (struct sd *) gspca_dev;
int err_code;
struct cam *cam;
cam = &gspca_dev->cam;
sd->sof_read = 0;
/*
* Some of the supported cameras require the memory pointer to be
* set to 0, or else they will not stream.
*/
zero_the_pointer(gspca_dev);
msleep(200);
if (sd->cam_type == CAM_TYPE_CIF) {
err_code = start_cif_cam(gspca_dev);
} else {
err_code = start_vga_cam(gspca_dev);
}
return err_code;
}
static void sd_stopN(struct gspca_dev *gspca_dev)
{
struct sd *sd = (struct sd *) gspca_dev;
int result;
gspca_dev->usb_buf[0] = 1;
gspca_dev->usb_buf[1] = 0;
result = mr_write(gspca_dev, 2);
if (result < 0)
PDEBUG(D_ERR, "Camera Stop failed");
/* Not all the cams need this, but even if not, probably a good idea */
zero_the_pointer(gspca_dev);
if (sd->do_lcd_stop) {
gspca_dev->usb_buf[0] = 0x19;
gspca_dev->usb_buf[1] = 0x54;
result = mr_write(gspca_dev, 2);
if (result < 0)
PDEBUG(D_ERR, "Camera Stop failed");
}
}
static void setbrightness(struct gspca_dev *gspca_dev)
{
struct sd *sd = (struct sd *) gspca_dev;
u8 val;
if (gspca_dev->ctrl_dis & (1 << BRIGHTNESS_IDX))
return;
/* Note register 7 is also seen as 0x8x or 0xCx in dumps */
if (sd->brightness > 0) {
sensor_write1(gspca_dev, 7, 0x00);
val = sd->brightness;
} else {
sensor_write1(gspca_dev, 7, 0x01);
val = 257 - sd->brightness;
}
sensor_write1(gspca_dev, 8, val);
}
static void setexposure(struct gspca_dev *gspca_dev)
{
struct sd *sd = (struct sd *) gspca_dev;
u8 val;
if (gspca_dev->ctrl_dis & (1 << EXPOSURE_IDX))
return;
if (sd->sensor_type) {
val = sd->exposure >> 4;
sensor_write1(gspca_dev, 3, val);
val = sd->exposure & 0xf;
sensor_write1(gspca_dev, 4, val);
} else {
u8 clockdiv;
int exposure;
/* We have both a clock divider and an exposure register.
We first calculate the clock divider, as that determines
the maximum exposure and then we calculayte the exposure
register setting (which goes from 0 - 511).
Note our 0 - 4095 exposure is mapped to 0 - 511
milliseconds exposure time */
clockdiv = (60 * sd->exposure + 7999) / 8000;
/* Limit framerate to not exceed usb bandwidth */
if (clockdiv < 3 && gspca_dev->width >= 320)
clockdiv = 3;
else if (clockdiv < 2)
clockdiv = 2;
/* Frame exposure time in ms = 1000 * clockdiv / 60 ->
exposure = (sd->exposure / 8) * 511 / (1000 * clockdiv / 60) */
exposure = (60 * 511 * sd->exposure) / (8000 * clockdiv);
if (exposure > 511)
exposure = 511;
/* exposure register value is reversed! */
exposure = 511 - exposure;
sensor_write1(gspca_dev, 0x02, clockdiv);
sensor_write1(gspca_dev, 0x0e, exposure & 0xff);
sensor_write1(gspca_dev, 0x0f, exposure >> 8);
}
}
static void setgain(struct gspca_dev *gspca_dev)
{
struct sd *sd = (struct sd *) gspca_dev;
if (gspca_dev->ctrl_dis & (1 << GAIN_IDX))
return;
if (sd->sensor_type) {
sensor_write1(gspca_dev, 0x0e, sd->gain);
} else {
sensor_write1(gspca_dev, 0x10, sd->gain);
}
}
static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
{
struct sd *sd = (struct sd *) gspca_dev;
sd->brightness = val;
if (gspca_dev->streaming)
setbrightness(gspca_dev);
return 0;
}
static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
{
struct sd *sd = (struct sd *) gspca_dev;
*val = sd->brightness;
return 0;
}
static int sd_setexposure(struct gspca_dev *gspca_dev, __s32 val)
{
struct sd *sd = (struct sd *) gspca_dev;
sd->exposure = val;
if (gspca_dev->streaming)
setexposure(gspca_dev);
return 0;
}
static int sd_getexposure(struct gspca_dev *gspca_dev, __s32 *val)
{
struct sd *sd = (struct sd *) gspca_dev;
*val = sd->exposure;
return 0;
}
static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val)
{
struct sd *sd = (struct sd *) gspca_dev;
sd->gain = val;
if (gspca_dev->streaming)
setgain(gspca_dev);
return 0;
}
static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val)
{
struct sd *sd = (struct sd *) gspca_dev;
*val = sd->gain;
return 0;
}
/* Include pac common sof detection functions */
#include "pac_common.h"
static void sd_pkt_scan(struct gspca_dev *gspca_dev,
struct gspca_frame *frame, /* target */
__u8 *data, /* isoc packet */
int len) /* iso packet length */
{
unsigned char *sof;
sof = pac_find_sof(gspca_dev, data, len);
if (sof) {
int n;
/* finish decoding current frame */
n = sof - data;
if (n > sizeof pac_sof_marker)
n -= sizeof pac_sof_marker;
else
n = 0;
frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame,
data, n);
/* Start next frame. */
gspca_frame_add(gspca_dev, FIRST_PACKET, frame,
pac_sof_marker, sizeof pac_sof_marker);
len -= sof - data;
data = sof;
}
gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
}
/* sub-driver description */
static const struct sd_desc sd_desc = {
.name = MODULE_NAME,
.ctrls = sd_ctrls,
.nctrls = ARRAY_SIZE(sd_ctrls),
.config = sd_config,
.init = sd_init,
.start = sd_start,
.stopN = sd_stopN,
.pkt_scan = sd_pkt_scan,
};
/* -- module initialisation -- */
static const __devinitdata struct usb_device_id device_table[] = {
{USB_DEVICE(0x08ca, 0x0111)}, /* Aiptek Pencam VGA+ */
{USB_DEVICE(0x093a, 0x010f)}, /* All other known MR97310A VGA cams */
{USB_DEVICE(0x093a, 0x010e)}, /* All known MR97310A CIF cams */
{}
};
MODULE_DEVICE_TABLE(usb, device_table);
/* -- device connect -- */
static int sd_probe(struct usb_interface *intf,
const struct usb_device_id *id)
{
return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
THIS_MODULE);
}
static struct usb_driver sd_driver = {
.name = MODULE_NAME,
.id_table = device_table,
.probe = sd_probe,
.disconnect = gspca_disconnect,
#ifdef CONFIG_PM
.suspend = gspca_suspend,
.resume = gspca_resume,
#endif
};
/* -- module insert / remove -- */
static int __init sd_mod_init(void)
{
int ret;
ret = usb_register(&sd_driver);
if (ret < 0)
return ret;
PDEBUG(D_PROBE, "registered");
return 0;
}
static void __exit sd_mod_exit(void)
{
usb_deregister(&sd_driver);
PDEBUG(D_PROBE, "deregistered");
}
module_init(sd_mod_init);
module_exit(sd_mod_exit);
Reference in New Issue View Git Blame Copy Permalink