Commit 89f0863c authored by Theodore Kilgore's avatar Theodore Kilgore Committed by Mauro Carvalho Chehab
Browse files

V4L/DVB (12618): gspca: mr97310a add support for CIF and more VGA camera's 



This patch adds supports for mr97310a camera's with CIF sensors (2 different
types) and for VGA mr97310a camera with a different sensor then supported
until now.

This patch also add support for controls for one of the 2 CIF sensors, this
was written by Thomas Kaiser <thomas@kaiser-linux.li>

Signed-off-by: default avatarTheodore Kilgore <kilgota@auburn.edu>
Signed-off-by: default avatarThomas Kaiser <thomas@kaiser-linux.li>
Signed-off-by: default avatarHans de Goede <hdgoede@redhat.com>
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab@redhat.com>
parent 0e4a9099

drivers/media/video/gspca/mr97310a.c

+682 −115
Original line number Diff line number Diff line
@@ -3,6 +3,21 @@ 
 *

 * 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
@@ -22,7 +37,23 @@ 


#include "gspca.h"



MODULE_AUTHOR("Kyle Guinn <elyk03@gmail.com>");

#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");
@@ -30,10 +61,75 @@ MODULE_LICENSE("GPL"); 
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;

	u8 regs[15];



	int brightness;

	u16 exposure;

	u8 autogain;

	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);



/* V4L2 controls supported by the driver */

static struct ctrl sd_ctrls[] = {

	{

		{

			.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,

	},

	{

		{

			.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,

	},

	{

		{

			.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[] = {
@@ -65,7 +161,7 @@ static const struct v4l2_pix_format vga_mode[] = { 
};



/* the bytes to write are in gspca_dev->usb_buf */

static int reg_w(struct gspca_dev *gspca_dev, int len)

static int mr_write(struct gspca_dev *gspca_dev, int len)

{

	int rc;
@@ -78,15 +174,200 @@ static int reg_w(struct gspca_dev *gspca_dev, int len) 
	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)

{

	u8 buf;

	int rc;



	buf = data;

	rc = sensor_write_reg(gspca_dev, reg, 0x01, &buf, 1);

	if (rc < 0)

		return rc;



	buf = 0x01;

	rc = sensor_write_reg(gspca_dev, 0x13, 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;

	}

	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;

	}

	PDEBUG(D_ERR, "Read 16 bytes from camera");



	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_ERR, "Read 16 bytes from camera");

	PDEBUG(D_ERR, "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;



	cam = &gspca_dev->cam;

	cam->cam_mode = vga_mode;

	cam->nmodes = ARRAY_SIZE(vga_mode);

	sd->cam_type = CAM_TYPE_VGA;

	PDEBUG(D_PROBE,

		"MR97310A camera detected"

		" (vid/pid 0x%04X:0x%04X)", id->idVendor, id->idProduct);

	if (id->idProduct == 0x010e) {

		cam->nmodes--;

		sd->cam_type = CAM_TYPE_CIF;

	}

	return 0;

}
@@ -96,184 +377,469 @@ static int sd_init(struct gspca_dev *gspca_dev) 
	return 0;

}



static int sd_start(struct gspca_dev *gspca_dev)

static int adjust_cif_sensor(struct gspca_dev *gspca_dev)

{

	/*

	 * FIXME: The following sequence resets brightness, contrast, and

	 * related  settings. Some of the values are adjustable, presumably

	 * based upon what is detected in the frames. Here, only some

	 * vaules are used which are compromises. When more is known about

	 * what is done here, this needs to be moved out to presently

	 * nonexistent functions which do controls. The same control messages

	 * do work for all of the CIF cameras.

	 */



	const struct sensor_w_data  cif_sensor1_adjust_data[] = {

		{0x02, 0x01, {0x10, 0x12, 0x0a}, 3},

		/* Last or possibly two last bytes adjustable, above. */

		{0x13, 0x04, {0x01}, 1}, /* seems to mean "write" */

		{0x05, 0x01, {0x22, 0x00, 0x81, 0x06}, 4},

		/* Last or possibly two last bytes adjustable, above. */

		{0x13, 0x04, {0x01}, 1},

		{0x09, 0x02, {0x05, 0x00, 0x00, 0x05, 0x07, 0x16}, 6},

		/* Last or possibly two last bytes adjustable, above. */

		{0x13, 0x04, {0x01}, 1},

		{0, 0, {0}, 0}

	};



	return sensor_write_regs(gspca_dev, cif_sensor1_adjust_data,

				 ARRAY_SIZE(cif_sensor1_adjust_data));

}



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

	};



	sd->sof_read = 0;



	/* Note:  register descriptions guessed from MR97113A driver */



	/* Note: Some of the above descriptions guessed from MR97113A driver */

	sd->sensor_type = 0;

	data[0] = 0x01;

	data[1] = 0x01;

	err_code = reg_w(gspca_dev, 2);

	err_code = mr_write(gspca_dev, 2);

	if (err_code < 0)

		return err_code;



	data[0] = 0x00;

	data[1] = 0x0d;

	data[2] = 0x01;

	data[5] = 0x2b;

	data[7] = 0x00;

	data[9] = 0x50;  /* reg 8, no scale down */

	data[10] = 0xc0;

	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		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)

		sd->sensor_type = 1;



	PDEBUG(D_ERR, "Sensor type is %01x", sd->sensor_type);

	memcpy(data, startup_string, 11);

	if (sd->sensor_type)

		data[5] = 0xbb;



	switch (gspca_dev->width) {

	case 160:

		data[9] |= 0x0c;  /* reg 8, 4:1 scale down */

		data[9] |= 0x04;  /* reg 8, 2:1 scale down from 320 */

		/* 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 */

		data[4] = 0x78;  /* reg 3, V size */

		data[6] = 0x04;  /* reg 5, H start */

		data[8] = 0x03;  /* reg 7, V start */

		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 */

		data[9] |= 0x04;  /* reg 8, 2:1 scale down from 352 */

		/* 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 */

		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 = reg_w(gspca_dev, 11);

	err_code = mr_write(gspca_dev, 11);

	if (err_code < 0)

		return err_code;



	data[0] = 0x0a;

	data[1] = 0x80;

	err_code = reg_w(gspca_dev, 2);

	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[] = {

			{0x02, 0x00, {0x10}, 1},

			{0x03, 0x01, {0x12}, 1},

			{0x04, 0x01, {0x05}, 1},

			{0x05, 0x01, {0x65}, 1},

			{0x06, 0x01, {0x32}, 1},

			{0x07, 0x01, {0x00}, 1},

			{0x08, 0x02, {0x06}, 1},

			{0x09, 0x02, {0x0e}, 1},

			{0x0a, 0x02, {0x05}, 1},

			{0x0b, 0x02, {0x05}, 1},

			{0x0c, 0x02, {0x0f}, 1},

			{0x0d, 0x02, {0x00}, 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;



	data[0] = 0x14;

	data[1] = 0x0a;

	err_code = reg_w(gspca_dev, 2);

	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;



	data[0] = 0x1b;

	data[1] = 0x00;

	err_code = reg_w(gspca_dev, 2);

	msleep(200);

	err_code = adjust_cif_sensor(gspca_dev);

	if (err_code < 0)

		return err_code;



	data[0] = 0x15;

	data[1] = 0x16;

	err_code = reg_w(gspca_dev, 2);

	if (err_code < 0)

		return err_code;

	msleep(200);

	return 0;

}



	data[0] = 0x16;

	data[1] = 0x10;

	err_code = reg_w(gspca_dev, 2);

	if (err_code < 0)

		return err_code;

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};



	data[0] = 0x17;

	data[1] = 0x3a;

	err_code = reg_w(gspca_dev, 2);

	if (err_code < 0)

		return err_code;

	/* What some of these mean is explained in start_cif_cam(), above */

	sd->sof_read = 0;



	data[0] = 0x18;

	data[1] = 0x68;

	err_code = reg_w(gspca_dev, 2);

	/*

	 * 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;



	data[0] = 0x1f;

	data[1] = 0x00;

	data[2] = 0x02;

	data[3] = 0x06;

	data[4] = 0x59;

	data[5] = 0x0c;

	data[6] = 0x16;

	data[7] = 0x00;

	data[8] = 0x07;

	data[9] = 0x00;

	data[10] = 0x01;

	err_code = reg_w(gspca_dev, 11);

	err_code = mr_read(gspca_dev, 16);

	if (err_code < 0)

		return err_code;



	data[0] = 0x1f;

	data[1] = 0x04;

	data[2] = 0x11;

	data[3] = 0x01;

	err_code = reg_w(gspca_dev, 4);

	if (err_code < 0)

		return err_code;

	PDEBUG(D_ERR, "Read 16 bytes from camera");

	PDEBUG(D_ERR, "Byte reported is %02x", data[0]);



	data[0] = 0x1f;

	data[1] = 0x00;

	data[2] = 0x0a;

	data[3] = 0x00;

	data[4] = 0x01;

	data[5] = 0x00;

	data[6] = 0x00;

	data[7] = 0x01;

	data[8] = 0x00;

	data[9] = 0x0a;

	err_code = reg_w(gspca_dev, 10);

	if (err_code < 0)

		return err_code;

	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] = 0x1f;

	data[1] = 0x04;

	data[2] = 0x11;

	data[3] = 0x01;

	err_code = reg_w(gspca_dev, 4);



	data[0] = 0x01;

	data[1] = 0x01;

	err_code = mr_write(gspca_dev, 2);

	if (err_code < 0)

		return err_code;



	data[0] = 0x1f;

	data[1] = 0x00;

	data[2] = 0x12;

	data[3] = 0x00;

	data[4] = 0x63;

	/*

	 * 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_ERR, "sensor_type corrected to 1");

		}

		msleep(200);

	}



	/*

	 * 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[6] = 0x70;

	data[7] = 0x00;

	data[8] = 0x00;

	err_code = reg_w(gspca_dev, 9);

		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;



	data[0] = 0x1f;

	data[1] = 0x04;

	data[2] = 0x11;

	data[3] = 0x01;

	err_code = reg_w(gspca_dev, 4);

	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 = reg_w(gspca_dev, 2);

	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;



	/* TEST TEST */

	int i;

	for (i = 2; i <= 14; i++)

		sd->regs[i] = sd_ctrls[i - 2].qctrl.default_value;



	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) {

		PDEBUG(D_ERR, "CIF camera");

		err_code = start_cif_cam(gspca_dev);

	} else {

		PDEBUG(D_ERR, "VGA camera");

		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 = reg_w(gspca_dev, 2);

	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 (sd->brightness > 0) {

		sensor_write1(gspca_dev, 7, 0);

		val = sd->brightness;

	} else {

		sensor_write1(gspca_dev, 7, 1);

		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;



	val = sd->exposure >> 4;

	sensor_write1(gspca_dev, 3, val);

	val = sd->exposure & 0xf;

	sensor_write1(gspca_dev, 4, val);

}



static void setgain(struct gspca_dev *gspca_dev)

{

	struct sd *sd = (struct sd *) gspca_dev;



	sensor_write1(gspca_dev, 3, 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"
@@ -320,8 +886,9 @@ static const struct sd_desc sd_desc = { 


/* -- module initialisation -- */

static const __devinitdata struct usb_device_id device_table[] = {

	{USB_DEVICE(0x08ca, 0x0111)},

	{USB_DEVICE(0x093a, 0x010f)},

	{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);

CRA Git | Maintained and supported by SUSTech CRA and CCSE