[linux-2.6-block.git] / drivers / media / video / gspca / m5602 / m5602_po1030.c

/*
 * Driver for the po1030 sensor
 *
 * Copyright (c) 2008 Erik Andrén
 * Copyright (c) 2007 Ilyes Gouta. Based on the m5603x Linux Driver Project.
 * Copyright (c) 2005 m5603x Linux Driver Project <m5602@x3ng.com.br>
 *
 * Portions of code to USB interface and ALi driver software,
 * Copyright (c) 2006 Willem Duinker
 * v4l2 interface modeled after the V4L2 driver
 * for SN9C10x PC Camera Controllers
 *
 * 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, version 2.
 *
 */

#include "m5602_po1030.h"

static struct v4l2_pix_format po1030_modes[] = {
	{
		640,
		480,
		V4L2_PIX_FMT_SBGGR8,
		V4L2_FIELD_NONE,
		.sizeimage = 640 * 480,
		.bytesperline = 640,
		.colorspace = V4L2_COLORSPACE_SRGB,
		.priv = 0
	}
};

const static struct ctrl po1030_ctrls[] = {
#define GAIN_IDX 0
	{
		{
			.id 		= V4L2_CID_GAIN,
			.type 		= V4L2_CTRL_TYPE_INTEGER,
			.name 		= "gain",
			.minimum 	= 0x00,
			.maximum 	= 0x4f,
			.step 		= 0x1,
			.default_value 	= PO1030_GLOBAL_GAIN_DEFAULT,
			.flags         	= V4L2_CTRL_FLAG_SLIDER
		},
		.set = po1030_set_gain,
		.get = po1030_get_gain
	},
#define EXPOSURE_IDX 1
	{
		{
			.id 		= V4L2_CID_EXPOSURE,
			.type 		= V4L2_CTRL_TYPE_INTEGER,
			.name 		= "exposure",
			.minimum 	= 0x00,
			.maximum 	= 0x02ff,
			.step 		= 0x1,
			.default_value 	= PO1030_EXPOSURE_DEFAULT,
			.flags         	= V4L2_CTRL_FLAG_SLIDER
		},
		.set = po1030_set_exposure,
		.get = po1030_get_exposure
	},
#define RED_BALANCE_IDX 2
	{
		{
			.id 		= V4L2_CID_RED_BALANCE,
			.type 		= V4L2_CTRL_TYPE_INTEGER,
			.name 		= "red balance",
			.minimum 	= 0x00,
			.maximum 	= 0xff,
			.step 		= 0x1,
			.default_value 	= PO1030_RED_GAIN_DEFAULT,
			.flags         	= V4L2_CTRL_FLAG_SLIDER
		},
		.set = po1030_set_red_balance,
		.get = po1030_get_red_balance
	},
#define BLUE_BALANCE_IDX 3
	{
		{
			.id 		= V4L2_CID_BLUE_BALANCE,
			.type 		= V4L2_CTRL_TYPE_INTEGER,
			.name 		= "blue balance",
			.minimum 	= 0x00,
			.maximum 	= 0xff,
			.step 		= 0x1,
			.default_value 	= PO1030_BLUE_GAIN_DEFAULT,
			.flags         	= V4L2_CTRL_FLAG_SLIDER
		},
		.set = po1030_set_blue_balance,
		.get = po1030_get_blue_balance
	},
#define HFLIP_IDX 4
	{
		{
			.id 		= V4L2_CID_HFLIP,
			.type 		= V4L2_CTRL_TYPE_BOOLEAN,
			.name 		= "horizontal flip",
			.minimum 	= 0,
			.maximum 	= 1,
			.step 		= 1,
			.default_value 	= 0,
		},
		.set = po1030_set_hflip,
		.get = po1030_get_hflip
	},
#define VFLIP_IDX 5
	{
		{
			.id 		= V4L2_CID_VFLIP,
			.type 		= V4L2_CTRL_TYPE_BOOLEAN,
			.name 		= "vertical flip",
			.minimum 	= 0,
			.maximum 	= 1,
			.step 		= 1,
			.default_value 	= 0,
		},
		.set = po1030_set_vflip,
		.get = po1030_get_vflip
	}
};

static void po1030_dump_registers(struct sd *sd);

int po1030_probe(struct sd *sd)
{
	u8 prod_id = 0, ver_id = 0, i;
	s32 *sensor_settings = sd->sensor_priv;

	if (force_sensor) {
		if (force_sensor == PO1030_SENSOR) {
			info("Forcing a %s sensor", po1030.name);
			goto sensor_found;
		}
		/* If we want to force another sensor, don't try to probe this
		 * one */
		return -ENODEV;
	}

	info("Probing for a po1030 sensor");

	/* Run the pre-init to actually probe the unit */
	for (i = 0; i < ARRAY_SIZE(preinit_po1030); i++) {
		u8 data = preinit_po1030[i][2];
		if (preinit_po1030[i][0] == SENSOR)
			m5602_write_sensor(sd,
				preinit_po1030[i][1], &data, 1);
		else
			m5602_write_bridge(sd, preinit_po1030[i][1], data);
	}

	if (m5602_read_sensor(sd, 0x3, &prod_id, 1))
		return -ENODEV;

	if (m5602_read_sensor(sd, 0x4, &ver_id, 1))
		return -ENODEV;

	if ((prod_id == 0x02) && (ver_id == 0xef)) {
		info("Detected a po1030 sensor");
		goto sensor_found;
	}
	return -ENODEV;

sensor_found:
	sensor_settings = kmalloc(
		ARRAY_SIZE(po1030_ctrls) * sizeof(s32), GFP_KERNEL);
	if (!sensor_settings)
		return -ENOMEM;

	sd->gspca_dev.cam.cam_mode = po1030_modes;
	sd->gspca_dev.cam.nmodes = ARRAY_SIZE(po1030_modes);
	sd->desc->ctrls = po1030_ctrls;
	sd->desc->nctrls = ARRAY_SIZE(po1030_ctrls);

	for (i = 0; i < ARRAY_SIZE(po1030_ctrls); i++)
		sensor_settings[i] = po1030_ctrls[i].qctrl.default_value;
	sd->sensor_priv = sensor_settings;
	return 0;
}

int po1030_init(struct sd *sd)
{
	int i, err = 0;

	/* Init the sensor */
	for (i = 0; i < ARRAY_SIZE(init_po1030) && !err; i++) {
		u8 data[2] = {0x00, 0x00};

		switch (init_po1030[i][0]) {
		case BRIDGE:
			err = m5602_write_bridge(sd,
				init_po1030[i][1],
				init_po1030[i][2]);
			break;

		case SENSOR:
			data[0] = init_po1030[i][2];
			err = m5602_write_sensor(sd,
				init_po1030[i][1], data, 1);
			break;

		default:
			info("Invalid stream command, exiting init");
			return -EINVAL;
		}
	}

	if (dump_sensor)
		po1030_dump_registers(sd);

	return err;
}

int po1030_get_exposure(struct gspca_dev *gspca_dev, __s32 *val)
{
	struct sd *sd = (struct sd *) gspca_dev;
	s32 *sensor_settings = sd->sensor_priv;

	*val = sensor_settings[EXPOSURE_IDX];
	PDEBUG(D_V4L2, "Exposure read as %d", *val);
	return 0;
}

int po1030_set_exposure(struct gspca_dev *gspca_dev, __s32 val)
{
	struct sd *sd = (struct sd *) gspca_dev;
	s32 *sensor_settings = sd->sensor_priv;
	u8 i2c_data;
	int err;

	sensor_settings[EXPOSURE_IDX] = val;
	PDEBUG(D_V4L2, "Set exposure to %d", val & 0xffff);

	i2c_data = ((val & 0xff00) >> 8);
	PDEBUG(D_V4L2, "Set exposure to high byte to 0x%x",
	       i2c_data);

	err = m5602_write_sensor(sd, PO1030_INTEGLINES_H,
				  &i2c_data, 1);
	if (err < 0)
		return err;

	i2c_data = (val & 0xff);
	PDEBUG(D_V4L2, "Set exposure to low byte to 0x%x",
	       i2c_data);
	err = m5602_write_sensor(sd, PO1030_INTEGLINES_M,
				  &i2c_data, 1);

	return err;
}

int po1030_get_gain(struct gspca_dev *gspca_dev, __s32 *val)
{
	struct sd *sd = (struct sd *) gspca_dev;
	s32 *sensor_settings = sd->sensor_priv;

	*val = sensor_settings[GAIN_IDX];
	PDEBUG(D_V4L2, "Read global gain %d", *val);
	return 0;
}

int po1030_set_gain(struct gspca_dev *gspca_dev, __s32 val)
{
	struct sd *sd = (struct sd *) gspca_dev;
	s32 *sensor_settings = sd->sensor_priv;
	u8 i2c_data;
	int err;

	sensor_settings[GAIN_IDX] = val;

	i2c_data = val & 0xff;
	PDEBUG(D_V4L2, "Set global gain to %d", i2c_data);
	err = m5602_write_sensor(sd, PO1030_GLOBALGAIN,
				 &i2c_data, 1);
	return err;
}

int po1030_get_hflip(struct gspca_dev *gspca_dev, __s32 *val)
{
	struct sd *sd = (struct sd *) gspca_dev;
	s32 *sensor_settings = sd->sensor_priv;

	*val = sensor_settings[HFLIP_IDX];
	PDEBUG(D_V4L2, "Read hflip %d", *val);

	return 0;
}

int po1030_set_hflip(struct gspca_dev *gspca_dev, __s32 val)
{
	struct sd *sd = (struct sd *) gspca_dev;
	s32 *sensor_settings = sd->sensor_priv;
	u8 i2c_data;
	int err;

	sensor_settings[HFLIP_IDX] = val;

	PDEBUG(D_V4L2, "Set hflip %d", val);
	err = m5602_read_sensor(sd, PO1030_CONTROL2, &i2c_data, 1);
	if (err < 0)
		return err;

	i2c_data = (0x7f & i2c_data) | ((val & 0x01) << 7);

	err = m5602_write_sensor(sd, PO1030_CONTROL2,
				 &i2c_data, 1);

	return err;
}

int po1030_get_vflip(struct gspca_dev *gspca_dev, __s32 *val)
{
	struct sd *sd = (struct sd *) gspca_dev;
	s32 *sensor_settings = sd->sensor_priv;

	*val= sensor_settings[VFLIP_IDX];
	PDEBUG(D_V4L2, "Read vflip %d", *val);

	return 0;
}

int po1030_set_vflip(struct gspca_dev *gspca_dev, __s32 val)
{
	struct sd *sd = (struct sd *) gspca_dev;
	s32 *sensor_settings = sd->sensor_priv;
	u8 i2c_data;
	int err;

	sensor_settings[VFLIP_IDX] = val;

	PDEBUG(D_V4L2, "Set vflip %d", val);
	err = m5602_read_sensor(sd, PO1030_CONTROL2, &i2c_data, 1);
	if (err < 0)
		return err;

	i2c_data = (i2c_data & 0xbf) | ((val & 0x01) << 6);

	err = m5602_write_sensor(sd, PO1030_CONTROL2,
				 &i2c_data, 1);

	return err;
}

int po1030_get_red_balance(struct gspca_dev *gspca_dev, __s32 *val)
{
	struct sd *sd = (struct sd *) gspca_dev;
	s32 *sensor_settings = sd->sensor_priv;

	*val = sensor_settings[RED_BALANCE_IDX];
	PDEBUG(D_V4L2, "Read red gain %d", *val);
	return 0;
}

int po1030_set_red_balance(struct gspca_dev *gspca_dev, __s32 val)
{
	struct sd *sd = (struct sd *) gspca_dev;
	s32 *sensor_settings = sd->sensor_priv;
	u8 i2c_data;
	int err;

	sensor_settings[RED_BALANCE_IDX] = val;

	i2c_data = val & 0xff;
	PDEBUG(D_V4L2, "Set red gain to %d", i2c_data);
	err = m5602_write_sensor(sd, PO1030_RED_GAIN,
				  &i2c_data, 1);
	return err;
}

int po1030_get_blue_balance(struct gspca_dev *gspca_dev, __s32 *val)
{
	struct sd *sd = (struct sd *) gspca_dev;
	s32 *sensor_settings = sd->sensor_priv;

	*val = sensor_settings[BLUE_BALANCE_IDX];
	PDEBUG(D_V4L2, "Read blue gain %d", *val);

	return 0;
}

int po1030_set_blue_balance(struct gspca_dev *gspca_dev, __s32 val)
{
	struct sd *sd = (struct sd *) gspca_dev;
	s32 *sensor_settings = sd->sensor_priv;
	u8 i2c_data;
	int err;

	sensor_settings[BLUE_BALANCE_IDX] = val;

	i2c_data = val & 0xff;
	PDEBUG(D_V4L2, "Set blue gain to %d", i2c_data);
	err = m5602_write_sensor(sd, PO1030_BLUE_GAIN,
				  &i2c_data, 1);

	return err;
}

void po1030_disconnect(struct sd *sd)
{
	sd->sensor = NULL;
	kfree(sd->sensor_priv);
}

static void po1030_dump_registers(struct sd *sd)
{
	int address;
	u8 value = 0;

	info("Dumping the po1030 sensor core registers");
	for (address = 0; address < 0x7f; address++) {
		m5602_read_sensor(sd, address, &value, 1);
		info("register 0x%x contains 0x%x",
		     address, value);
	}

	info("po1030 register state dump complete");

	info("Probing for which registers that are read/write");
	for (address = 0; address < 0xff; address++) {
		u8 old_value, ctrl_value;
		u8 test_value[2] = {0xff, 0xff};

		m5602_read_sensor(sd, address, &old_value, 1);
		m5602_write_sensor(sd, address, test_value, 1);
		m5602_read_sensor(sd, address, &ctrl_value, 1);

		if (ctrl_value == test_value[0])
			info("register 0x%x is writeable", address);
		else
			info("register 0x%x is read only", address);

		/* Restore original value */
		m5602_write_sensor(sd, address, &old_value, 1);
	}
}
Commit	Line	Data
c109f816 EA	1	/*
	2	* Driver for the po1030 sensor
	3	*
0c505e68	4	* Copyright (c) 2008 Erik Andrén
c109f816 EA	5	* Copyright (c) 2007 Ilyes Gouta. Based on the m5603x Linux Driver Project.
	6	* Copyright (c) 2005 m5603x Linux Driver Project <m5602@x3ng.com.br>
	7	*
	8	* Portions of code to USB interface and ALi driver software,
	9	* Copyright (c) 2006 Willem Duinker
	10	* v4l2 interface modeled after the V4L2 driver
	11	* for SN9C10x PC Camera Controllers
	12	*
	13	* This program is free software; you can redistribute it and/or
	14	* modify it under the terms of the GNU General Public License as
	15	* published by the Free Software Foundation, version 2.
	16	*
	17	*/
	18
	19	#include "m5602_po1030.h"
	20
74cadfe1 EA	21	static struct v4l2_pix_format po1030_modes[] = {
	22	{
	23	640,
	24	480,
	25	V4L2_PIX_FMT_SBGGR8,
	26	V4L2_FIELD_NONE,
	27	.sizeimage = 640 * 480,
	28	.bytesperline = 640,
	29	.colorspace = V4L2_COLORSPACE_SRGB,
	30	.priv = 0
	31	}
	32	};
	33
e17cc08c	34	const static struct ctrl po1030_ctrls[] = {
05d7d9ce	35	#define GAIN_IDX 0
e17cc08c EA	36	{
	37	{
	38	.id = V4L2_CID_GAIN,
	39	.type = V4L2_CTRL_TYPE_INTEGER,
	40	.name = "gain",
	41	.minimum = 0x00,
	42	.maximum = 0x4f,
	43	.step = 0x1,
	44	.default_value = PO1030_GLOBAL_GAIN_DEFAULT,
	45	.flags = V4L2_CTRL_FLAG_SLIDER
	46	},
	47	.set = po1030_set_gain,
	48	.get = po1030_get_gain
05d7d9ce EA	49	},
	50	#define EXPOSURE_IDX 1
	51	{
e17cc08c EA	52	{
	53	.id = V4L2_CID_EXPOSURE,
	54	.type = V4L2_CTRL_TYPE_INTEGER,
	55	.name = "exposure",
	56	.minimum = 0x00,
	57	.maximum = 0x02ff,
	58	.step = 0x1,
	59	.default_value = PO1030_EXPOSURE_DEFAULT,
	60	.flags = V4L2_CTRL_FLAG_SLIDER
	61	},
	62	.set = po1030_set_exposure,
	63	.get = po1030_get_exposure
05d7d9ce EA	64	},
	65	#define RED_BALANCE_IDX 2
	66	{
e17cc08c EA	67	{
	68	.id = V4L2_CID_RED_BALANCE,
	69	.type = V4L2_CTRL_TYPE_INTEGER,
	70	.name = "red balance",
	71	.minimum = 0x00,
	72	.maximum = 0xff,
	73	.step = 0x1,
	74	.default_value = PO1030_RED_GAIN_DEFAULT,
	75	.flags = V4L2_CTRL_FLAG_SLIDER
	76	},
	77	.set = po1030_set_red_balance,
	78	.get = po1030_get_red_balance
05d7d9ce EA	79	},
	80	#define BLUE_BALANCE_IDX 3
	81	{
e17cc08c EA	82	{
	83	.id = V4L2_CID_BLUE_BALANCE,
	84	.type = V4L2_CTRL_TYPE_INTEGER,
	85	.name = "blue balance",
	86	.minimum = 0x00,
	87	.maximum = 0xff,
	88	.step = 0x1,
	89	.default_value = PO1030_BLUE_GAIN_DEFAULT,
	90	.flags = V4L2_CTRL_FLAG_SLIDER
	91	},
	92	.set = po1030_set_blue_balance,
	93	.get = po1030_get_blue_balance
05d7d9ce EA	94	},
	95	#define HFLIP_IDX 4
	96	{
e17cc08c EA	97	{
	98	.id = V4L2_CID_HFLIP,
	99	.type = V4L2_CTRL_TYPE_BOOLEAN,
	100	.name = "horizontal flip",
	101	.minimum = 0,
	102	.maximum = 1,
	103	.step = 1,
	104	.default_value = 0,
	105	},
	106	.set = po1030_set_hflip,
	107	.get = po1030_get_hflip
05d7d9ce EA	108	},
	109	#define VFLIP_IDX 5
	110	{
e17cc08c EA	111	{
	112	.id = V4L2_CID_VFLIP,
	113	.type = V4L2_CTRL_TYPE_BOOLEAN,
	114	.name = "vertical flip",
	115	.minimum = 0,
	116	.maximum = 1,
	117	.step = 1,
	118	.default_value = 0,
	119	},
	120	.set = po1030_set_vflip,
	121	.get = po1030_get_vflip
	122	}
	123	};
	124
658efb63 EA	125	static void po1030_dump_registers(struct sd *sd);
658efb63 EA	126
c109f816 EA	127	int po1030_probe(struct sd *sd)
	128	{
	129	u8 prod_id = 0, ver_id = 0, i;
05d7d9ce	130	s32 *sensor_settings = sd->sensor_priv;
c109f816 EA	131
	132	if (force_sensor) {
	133	if (force_sensor == PO1030_SENSOR) {
	134	info("Forcing a %s sensor", po1030.name);
	135	goto sensor_found;
	136	}
	137	/* If we want to force another sensor, don't try to probe this
	138	* one */
	139	return -ENODEV;
	140	}
	141
	142	info("Probing for a po1030 sensor");
	143
	144	/* Run the pre-init to actually probe the unit */
	145	for (i = 0; i < ARRAY_SIZE(preinit_po1030); i++) {
	146	u8 data = preinit_po1030[i][2];
	147	if (preinit_po1030[i][0] == SENSOR)
6dc4cff0	148	m5602_write_sensor(sd,
c109f816 EA	149	preinit_po1030[i][1], &data, 1);
	150	else
	151	m5602_write_bridge(sd, preinit_po1030[i][1], data);
	152	}
	153
c061c97e	154	if (m5602_read_sensor(sd, 0x3, &prod_id, 1))
c109f816 EA	155	return -ENODEV;
c109f816 EA	156
c061c97e	157	if (m5602_read_sensor(sd, 0x4, &ver_id, 1))
c109f816 EA	158	return -ENODEV;
	159
	160	if ((prod_id == 0x02) && (ver_id == 0xef)) {
	161	info("Detected a po1030 sensor");
	162	goto sensor_found;
	163	}
	164	return -ENODEV;
	165
	166	sensor_found:
05d7d9ce EA	167	sensor_settings = kmalloc(
	168	ARRAY_SIZE(po1030_ctrls) * sizeof(s32), GFP_KERNEL);
	169	if (!sensor_settings)
	170	return -ENOMEM;
	171
74cadfe1 EA	172	sd->gspca_dev.cam.cam_mode = po1030_modes;
74cadfe1 EA	173	sd->gspca_dev.cam.nmodes = ARRAY_SIZE(po1030_modes);
e17cc08c	174	sd->desc->ctrls = po1030_ctrls;
e4cc4fcc	175	sd->desc->nctrls = ARRAY_SIZE(po1030_ctrls);
05d7d9ce EA	176
	177	for (i = 0; i < ARRAY_SIZE(po1030_ctrls); i++)
	178	sensor_settings[i] = po1030_ctrls[i].qctrl.default_value;
	179	sd->sensor_priv = sensor_settings;
c109f816 EA	180	return 0;
	181	}
	182
c109f816 EA	183	int po1030_init(struct sd *sd)
	184	{
	185	int i, err = 0;
	186
	187	/* Init the sensor */
7b9f2467	188	for (i = 0; i < ARRAY_SIZE(init_po1030) && !err; i++) {
c109f816 EA	189	u8 data[2] = {0x00, 0x00};
	190
	191	switch (init_po1030[i][0]) {
	192	case BRIDGE:
	193	err = m5602_write_bridge(sd,
	194	init_po1030[i][1],
	195	init_po1030[i][2]);
	196	break;
	197
	198	case SENSOR:
	199	data[0] = init_po1030[i][2];
6dc4cff0	200	err = m5602_write_sensor(sd,
c109f816 EA	201	init_po1030[i][1], data, 1);
	202	break;
	203
c109f816 EA	204	default:
	205	info("Invalid stream command, exiting init");
	206	return -EINVAL;
	207	}
	208	}
	209
	210	if (dump_sensor)
	211	po1030_dump_registers(sd);
	212
7b9f2467	213	return err;
c109f816 EA	214	}
	215
	216	int po1030_get_exposure(struct gspca_dev gspca_dev, __s32 val)
	217	{
	218	struct sd sd = (struct sd ) gspca_dev;
05d7d9ce	219	s32 *sensor_settings = sd->sensor_priv;
c109f816	220
05d7d9ce	221	*val = sensor_settings[EXPOSURE_IDX];
17ea88ae	222	PDEBUG(D_V4L2, "Exposure read as %d", *val);
05d7d9ce	223	return 0;
c109f816 EA	224	}
	225
	226	int po1030_set_exposure(struct gspca_dev *gspca_dev, __s32 val)
	227	{
	228	struct sd sd = (struct sd ) gspca_dev;
05d7d9ce	229	s32 *sensor_settings = sd->sensor_priv;
c109f816 EA	230	u8 i2c_data;
	231	int err;
	232
05d7d9ce	233	sensor_settings[EXPOSURE_IDX] = val;
17ea88ae	234	PDEBUG(D_V4L2, "Set exposure to %d", val & 0xffff);
c109f816 EA	235
c109f816 EA	236	i2c_data = ((val & 0xff00) >> 8);
17ea88ae	237	PDEBUG(D_V4L2, "Set exposure to high byte to 0x%x",
c109f816 EA	238	i2c_data);
c109f816 EA	239
bb9460eb	240	err = m5602_write_sensor(sd, PO1030_INTEGLINES_H,
c109f816 EA	241	&i2c_data, 1);
c109f816 EA	242	if (err < 0)
051781b3	243	return err;
c109f816 EA	244
c109f816 EA	245	i2c_data = (val & 0xff);
17ea88ae	246	PDEBUG(D_V4L2, "Set exposure to low byte to 0x%x",
c109f816	247	i2c_data);
bb9460eb	248	err = m5602_write_sensor(sd, PO1030_INTEGLINES_M,
c109f816 EA	249	&i2c_data, 1);
c109f816 EA	250
7b9f2467	251	return err;
c109f816 EA	252	}
	253
	254	int po1030_get_gain(struct gspca_dev gspca_dev, __s32 val)
	255	{
	256	struct sd sd = (struct sd ) gspca_dev;
05d7d9ce	257	s32 *sensor_settings = sd->sensor_priv;
c109f816	258
05d7d9ce	259	*val = sensor_settings[GAIN_IDX];
17ea88ae	260	PDEBUG(D_V4L2, "Read global gain %d", *val);
05d7d9ce	261	return 0;
c109f816 EA	262	}
c109f816 EA	263
05d7d9ce	264	int po1030_set_gain(struct gspca_dev *gspca_dev, __s32 val)
e2c97491 EA	265	{
e2c97491 EA	266	struct sd sd = (struct sd ) gspca_dev;
05d7d9ce	267	s32 *sensor_settings = sd->sensor_priv;
e2c97491 EA	268	u8 i2c_data;
	269	int err;
	270
05d7d9ce EA	271	sensor_settings[GAIN_IDX] = val;
	272
	273	i2c_data = val & 0xff;
	274	PDEBUG(D_V4L2, "Set global gain to %d", i2c_data);
bb9460eb	275	err = m5602_write_sensor(sd, PO1030_GLOBALGAIN,
e2c97491	276	&i2c_data, 1);
05d7d9ce EA	277	return err;
05d7d9ce EA	278	}
e2c97491	279
05d7d9ce EA	280	int po1030_get_hflip(struct gspca_dev gspca_dev, __s32 val)
	281	{
	282	struct sd sd = (struct sd ) gspca_dev;
	283	s32 *sensor_settings = sd->sensor_priv;
e2c97491	284
05d7d9ce	285	*val = sensor_settings[HFLIP_IDX];
e2c97491 EA	286	PDEBUG(D_V4L2, "Read hflip %d", *val);
e2c97491 EA	287
05d7d9ce	288	return 0;
e2c97491 EA	289	}
	290
	291	int po1030_set_hflip(struct gspca_dev *gspca_dev, __s32 val)
	292	{
	293	struct sd sd = (struct sd ) gspca_dev;
05d7d9ce	294	s32 *sensor_settings = sd->sensor_priv;
e2c97491 EA	295	u8 i2c_data;
	296	int err;
	297
05d7d9ce EA	298	sensor_settings[HFLIP_IDX] = val;
05d7d9ce EA	299
e2c97491	300	PDEBUG(D_V4L2, "Set hflip %d", val);
bb9460eb	301	err = m5602_read_sensor(sd, PO1030_CONTROL2, &i2c_data, 1);
1d07b6f1	302	if (err < 0)
051781b3	303	return err;
e2c97491	304
1d07b6f1	305	i2c_data = (0x7f & i2c_data) \| ((val & 0x01) << 7);
e2c97491	306
bb9460eb	307	err = m5602_write_sensor(sd, PO1030_CONTROL2,
1d07b6f1	308	&i2c_data, 1);
e2c97491	309
7b9f2467	310	return err;
e2c97491 EA	311	}
	312
	313	int po1030_get_vflip(struct gspca_dev gspca_dev, __s32 val)
	314	{
	315	struct sd sd = (struct sd ) gspca_dev;
05d7d9ce	316	s32 *sensor_settings = sd->sensor_priv;
e2c97491	317
05d7d9ce	318	*val= sensor_settings[VFLIP_IDX];
e2c97491 EA	319	PDEBUG(D_V4L2, "Read vflip %d", *val);
e2c97491 EA	320
05d7d9ce	321	return 0;
e2c97491 EA	322	}
	323
	324	int po1030_set_vflip(struct gspca_dev *gspca_dev, __s32 val)
	325	{
	326	struct sd sd = (struct sd ) gspca_dev;
05d7d9ce	327	s32 *sensor_settings = sd->sensor_priv;
e2c97491 EA	328	u8 i2c_data;
	329	int err;
	330
05d7d9ce EA	331	sensor_settings[VFLIP_IDX] = val;
05d7d9ce EA	332
e2c97491	333	PDEBUG(D_V4L2, "Set vflip %d", val);
bb9460eb	334	err = m5602_read_sensor(sd, PO1030_CONTROL2, &i2c_data, 1);
1d07b6f1	335	if (err < 0)
051781b3	336	return err;
e2c97491	337
1d07b6f1	338	i2c_data = (i2c_data & 0xbf) \| ((val & 0x01) << 6);
e2c97491	339
bb9460eb	340	err = m5602_write_sensor(sd, PO1030_CONTROL2,
1d07b6f1	341	&i2c_data, 1);
e2c97491	342
7b9f2467	343	return err;
e2c97491 EA	344	}
e2c97491 EA	345
c109f816 EA	346	int po1030_get_red_balance(struct gspca_dev gspca_dev, __s32 val)
	347	{
	348	struct sd sd = (struct sd ) gspca_dev;
05d7d9ce	349	s32 *sensor_settings = sd->sensor_priv;
c109f816	350
05d7d9ce	351	*val = sensor_settings[RED_BALANCE_IDX];
17ea88ae	352	PDEBUG(D_V4L2, "Read red gain %d", *val);
05d7d9ce	353	return 0;
c109f816 EA	354	}
	355
	356	int po1030_set_red_balance(struct gspca_dev *gspca_dev, __s32 val)
	357	{
	358	struct sd sd = (struct sd ) gspca_dev;
05d7d9ce	359	s32 *sensor_settings = sd->sensor_priv;
c109f816 EA	360	u8 i2c_data;
	361	int err;
	362
05d7d9ce EA	363	sensor_settings[RED_BALANCE_IDX] = val;
05d7d9ce EA	364
c109f816	365	i2c_data = val & 0xff;
17ea88ae	366	PDEBUG(D_V4L2, "Set red gain to %d", i2c_data);
bb9460eb	367	err = m5602_write_sensor(sd, PO1030_RED_GAIN,
c109f816	368	&i2c_data, 1);
7b9f2467	369	return err;
c109f816 EA	370	}
	371
	372	int po1030_get_blue_balance(struct gspca_dev gspca_dev, __s32 val)
	373	{
	374	struct sd sd = (struct sd ) gspca_dev;
05d7d9ce	375	s32 *sensor_settings = sd->sensor_priv;
c109f816	376
05d7d9ce	377	*val = sensor_settings[BLUE_BALANCE_IDX];
17ea88ae	378	PDEBUG(D_V4L2, "Read blue gain %d", *val);
c109f816	379
05d7d9ce	380	return 0;
c109f816 EA	381	}
	382
	383	int po1030_set_blue_balance(struct gspca_dev *gspca_dev, __s32 val)
	384	{
	385	struct sd sd = (struct sd ) gspca_dev;
05d7d9ce	386	s32 *sensor_settings = sd->sensor_priv;
c109f816 EA	387	u8 i2c_data;
c109f816 EA	388	int err;
05d7d9ce EA	389
	390	sensor_settings[BLUE_BALANCE_IDX] = val;
	391
c109f816	392	i2c_data = val & 0xff;
17ea88ae	393	PDEBUG(D_V4L2, "Set blue gain to %d", i2c_data);
bb9460eb	394	err = m5602_write_sensor(sd, PO1030_BLUE_GAIN,
c109f816 EA	395	&i2c_data, 1);
c109f816 EA	396
7b9f2467	397	return err;
c109f816 EA	398	}
c109f816 EA	399
05d7d9ce EA	400	void po1030_disconnect(struct sd *sd)
	401	{
	402	sd->sensor = NULL;
	403	kfree(sd->sensor_priv);
	404	}
	405
658efb63	406	static void po1030_dump_registers(struct sd *sd)
c109f816 EA	407	{
	408	int address;
	409	u8 value = 0;
	410
	411	info("Dumping the po1030 sensor core registers");
	412	for (address = 0; address < 0x7f; address++) {
c061c97e	413	m5602_read_sensor(sd, address, &value, 1);
c109f816 EA	414	info("register 0x%x contains 0x%x",
	415	address, value);
	416	}
	417
	418	info("po1030 register state dump complete");
	419
	420	info("Probing for which registers that are read/write");
	421	for (address = 0; address < 0xff; address++) {
	422	u8 old_value, ctrl_value;
	423	u8 test_value[2] = {0xff, 0xff};
	424
c061c97e	425	m5602_read_sensor(sd, address, &old_value, 1);
6dc4cff0	426	m5602_write_sensor(sd, address, test_value, 1);
c061c97e	427	m5602_read_sensor(sd, address, &ctrl_value, 1);
c109f816 EA	428
	429	if (ctrl_value == test_value[0])
	430	info("register 0x%x is writeable", address);
	431	else
	432	info("register 0x%x is read only", address);
	433
	434	/* Restore original value */
6dc4cff0	435	m5602_write_sensor(sd, address, &old_value, 1);
c109f816 EA	436	}
c109f816 EA	437	}