[mirror_ubuntu-artful-kernel.git] / drivers / media / usb / gspca / stv06xx / stv06xx_hdcs.c

/*
 * Copyright (c) 2001 Jean-Fredric Clere, Nikolas Zimmermann, Georg Acher
 *		      Mark Cave-Ayland, Carlo E Prelz, Dick Streefland
 * Copyright (c) 2002, 2003 Tuukka Toivonen
 * Copyright (c) 2008 Erik Andrén
 * Copyright (c) 2008 Chia-I Wu
 *
 * 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
 * (at your option) 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.
 *
 * P/N 861037:      Sensor HDCS1000        ASIC STV0600
 * P/N 861050-0010: Sensor HDCS1000        ASIC STV0600
 * P/N 861050-0020: Sensor Photobit PB100  ASIC STV0600-1 - QuickCam Express
 * P/N 861055:      Sensor ST VV6410       ASIC STV0610   - LEGO cam
 * P/N 861075-0040: Sensor HDCS1000        ASIC
 * P/N 961179-0700: Sensor ST VV6410       ASIC STV0602   - Dexxa WebCam USB
 * P/N 861040-0000: Sensor ST VV6410       ASIC STV0610   - QuickCam Web
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include "stv06xx_hdcs.h"

static struct v4l2_pix_format hdcs1x00_mode[] = {
	{
		HDCS_1X00_DEF_WIDTH,
		HDCS_1X00_DEF_HEIGHT,
		V4L2_PIX_FMT_SGRBG8,
		V4L2_FIELD_NONE,
		.sizeimage =
			HDCS_1X00_DEF_WIDTH * HDCS_1X00_DEF_HEIGHT,
		.bytesperline = HDCS_1X00_DEF_WIDTH,
		.colorspace = V4L2_COLORSPACE_SRGB,
		.priv = 1
	}
};

static struct v4l2_pix_format hdcs1020_mode[] = {
	{
		HDCS_1020_DEF_WIDTH,
		HDCS_1020_DEF_HEIGHT,
		V4L2_PIX_FMT_SGRBG8,
		V4L2_FIELD_NONE,
		.sizeimage =
			HDCS_1020_DEF_WIDTH * HDCS_1020_DEF_HEIGHT,
		.bytesperline = HDCS_1020_DEF_WIDTH,
		.colorspace = V4L2_COLORSPACE_SRGB,
		.priv = 1
	}
};

enum hdcs_power_state {
	HDCS_STATE_SLEEP,
	HDCS_STATE_IDLE,
	HDCS_STATE_RUN
};

/* no lock? */
struct hdcs {
	enum hdcs_power_state state;
	int w, h;

	/* visible area of the sensor array */
	struct {
		int left, top;
		int width, height;
		int border;
	} array;

	struct {
		/* Column timing overhead */
		u8 cto;
		/* Column processing overhead */
		u8 cpo;
		/* Row sample period constant */
		u16 rs;
		/* Exposure reset duration */
		u16 er;
	} exp;

	int psmp;
};

static int hdcs_reg_write_seq(struct sd *sd, u8 reg, u8 *vals, u8 len)
{
	u8 regs[I2C_MAX_BYTES * 2];
	int i;

	if (unlikely((len <= 0) || (len >= I2C_MAX_BYTES) ||
		     (reg + len > 0xff)))
		return -EINVAL;

	for (i = 0; i < len; i++) {
		regs[2 * i] = reg;
		regs[2 * i + 1] = vals[i];
		/* All addresses are shifted left one bit
		 * as bit 0 toggles r/w */
		reg += 2;
	}

	return stv06xx_write_sensor_bytes(sd, regs, len);
}

static int hdcs_set_state(struct sd *sd, enum hdcs_power_state state)
{
	struct hdcs *hdcs = sd->sensor_priv;
	u8 val;
	int ret;

	if (hdcs->state == state)
		return 0;

	/* we need to go idle before running or sleeping */
	if (hdcs->state != HDCS_STATE_IDLE) {
		ret = stv06xx_write_sensor(sd, HDCS_REG_CONTROL(sd), 0);
		if (ret)
			return ret;
	}

	hdcs->state = HDCS_STATE_IDLE;

	if (state == HDCS_STATE_IDLE)
		return 0;

	switch (state) {
	case HDCS_STATE_SLEEP:
		val = HDCS_SLEEP_MODE;
		break;

	case HDCS_STATE_RUN:
		val = HDCS_RUN_ENABLE;
		break;

	default:
		return -EINVAL;
	}

	ret = stv06xx_write_sensor(sd, HDCS_REG_CONTROL(sd), val);

	/* Update the state if the write succeeded */
	if (!ret)
		hdcs->state = state;

	return ret;
}

static int hdcs_reset(struct sd *sd)
{
	struct hdcs *hdcs = sd->sensor_priv;
	int err;

	err = stv06xx_write_sensor(sd, HDCS_REG_CONTROL(sd), 1);
	if (err < 0)
		return err;

	err = stv06xx_write_sensor(sd, HDCS_REG_CONTROL(sd), 0);
	if (err < 0)
		hdcs->state = HDCS_STATE_IDLE;

	return err;
}

static int hdcs_set_exposure(struct gspca_dev *gspca_dev, __s32 val)
{
	struct sd *sd = (struct sd *) gspca_dev;
	struct hdcs *hdcs = sd->sensor_priv;
	int rowexp, srowexp;
	int max_srowexp;
	/* Column time period */
	int ct;
	/* Column processing period */
	int cp;
	/* Row processing period */
	int rp;
	/* Minimum number of column timing periods
	   within the column processing period */
	int mnct;
	int cycles, err;
	u8 exp[14];

	cycles = val * HDCS_CLK_FREQ_MHZ * 257;

	ct = hdcs->exp.cto + hdcs->psmp + (HDCS_ADC_START_SIG_DUR + 2);
	cp = hdcs->exp.cto + (hdcs->w * ct / 2);

	/* the cycles one row takes */
	rp = hdcs->exp.rs + cp;

	rowexp = cycles / rp;

	/* the remaining cycles */
	cycles -= rowexp * rp;

	/* calculate sub-row exposure */
	if (IS_1020(sd)) {
		/* see HDCS-1020 datasheet 3.5.6.4, p. 63 */
		srowexp = hdcs->w - (cycles + hdcs->exp.er + 13) / ct;

		mnct = (hdcs->exp.er + 12 + ct - 1) / ct;
		max_srowexp = hdcs->w - mnct;
	} else {
		/* see HDCS-1000 datasheet 3.4.5.5, p. 61 */
		srowexp = cp - hdcs->exp.er - 6 - cycles;

		mnct = (hdcs->exp.er + 5 + ct - 1) / ct;
		max_srowexp = cp - mnct * ct - 1;
	}

	if (srowexp < 0)
		srowexp = 0;
	else if (srowexp > max_srowexp)
		srowexp = max_srowexp;

	if (IS_1020(sd)) {
		exp[0] = HDCS20_CONTROL;
		exp[1] = 0x00;		/* Stop streaming */
		exp[2] = HDCS_ROWEXPL;
		exp[3] = rowexp & 0xff;
		exp[4] = HDCS_ROWEXPH;
		exp[5] = rowexp >> 8;
		exp[6] = HDCS20_SROWEXP;
		exp[7] = (srowexp >> 2) & 0xff;
		exp[8] = HDCS20_ERROR;
		exp[9] = 0x10;		/* Clear exposure error flag*/
		exp[10] = HDCS20_CONTROL;
		exp[11] = 0x04;		/* Restart streaming */
		err = stv06xx_write_sensor_bytes(sd, exp, 6);
	} else {
		exp[0] = HDCS00_CONTROL;
		exp[1] = 0x00;         /* Stop streaming */
		exp[2] = HDCS_ROWEXPL;
		exp[3] = rowexp & 0xff;
		exp[4] = HDCS_ROWEXPH;
		exp[5] = rowexp >> 8;
		exp[6] = HDCS00_SROWEXPL;
		exp[7] = srowexp & 0xff;
		exp[8] = HDCS00_SROWEXPH;
		exp[9] = srowexp >> 8;
		exp[10] = HDCS_STATUS;
		exp[11] = 0x10;         /* Clear exposure error flag*/
		exp[12] = HDCS00_CONTROL;
		exp[13] = 0x04;         /* Restart streaming */
		err = stv06xx_write_sensor_bytes(sd, exp, 7);
		if (err < 0)
			return err;
	}
	PDEBUG(D_CONF, "Writing exposure %d, rowexp %d, srowexp %d",
	       val, rowexp, srowexp);
	return err;
}

static int hdcs_set_gains(struct sd *sd, u8 g)
{
	int err;
	u8 gains[4];

	/* the voltage gain Av = (1 + 19 * val / 127) * (1 + bit7) */
	if (g > 127)
		g = 0x80 | (g / 2);

	gains[0] = g;
	gains[1] = g;
	gains[2] = g;
	gains[3] = g;

	err = hdcs_reg_write_seq(sd, HDCS_ERECPGA, gains, 4);
	return err;
}

static int hdcs_set_gain(struct gspca_dev *gspca_dev, __s32 val)
{
	PDEBUG(D_CONF, "Writing gain %d", val);
	return hdcs_set_gains((struct sd *) gspca_dev,
			       val & 0xff);
}

static int hdcs_set_size(struct sd *sd,
		unsigned int width, unsigned int height)
{
	struct hdcs *hdcs = sd->sensor_priv;
	u8 win[4];
	unsigned int x, y;
	int err;

	/* must be multiple of 4 */
	width = (width + 3) & ~0x3;
	height = (height + 3) & ~0x3;

	if (width > hdcs->array.width)
		width = hdcs->array.width;

	if (IS_1020(sd)) {
		/* the borders are also invalid */
		if (height + 2 * hdcs->array.border + HDCS_1020_BOTTOM_Y_SKIP
				  > hdcs->array.height)
			height = hdcs->array.height - 2 * hdcs->array.border -
				HDCS_1020_BOTTOM_Y_SKIP;

		y = (hdcs->array.height - HDCS_1020_BOTTOM_Y_SKIP - height) / 2
				+ hdcs->array.top;
	} else {
		if (height > hdcs->array.height)
			height = hdcs->array.height;

		y = hdcs->array.top + (hdcs->array.height - height) / 2;
	}

	x = hdcs->array.left + (hdcs->array.width - width) / 2;

	win[0] = y / 4;
	win[1] = x / 4;
	win[2] = (y + height) / 4 - 1;
	win[3] = (x + width) / 4 - 1;

	err = hdcs_reg_write_seq(sd, HDCS_FWROW, win, 4);
	if (err < 0)
		return err;

	/* Update the current width and height */
	hdcs->w = width;
	hdcs->h = height;
	return err;
}

static int hdcs_s_ctrl(struct v4l2_ctrl *ctrl)
{
	struct gspca_dev *gspca_dev =
		container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
	int err = -EINVAL;

	switch (ctrl->id) {
	case V4L2_CID_GAIN:
		err = hdcs_set_gain(gspca_dev, ctrl->val);
		break;
	case V4L2_CID_EXPOSURE:
		err = hdcs_set_exposure(gspca_dev, ctrl->val);
		break;
	}
	return err;
}

static const struct v4l2_ctrl_ops hdcs_ctrl_ops = {
	.s_ctrl = hdcs_s_ctrl,
};

static int hdcs_init_controls(struct sd *sd)
{
	struct v4l2_ctrl_handler *hdl = &sd->gspca_dev.ctrl_handler;

	v4l2_ctrl_handler_init(hdl, 2);
	v4l2_ctrl_new_std(hdl, &hdcs_ctrl_ops,
			V4L2_CID_EXPOSURE, 0, 0xff, 1, HDCS_DEFAULT_EXPOSURE);
	v4l2_ctrl_new_std(hdl, &hdcs_ctrl_ops,
			V4L2_CID_GAIN, 0, 0xff, 1, HDCS_DEFAULT_GAIN);
	return hdl->error;
}

static int hdcs_probe_1x00(struct sd *sd)
{
	struct hdcs *hdcs;
	u16 sensor;
	int ret;

	ret = stv06xx_read_sensor(sd, HDCS_IDENT, &sensor);
	if (ret < 0 || sensor != 0x08)
		return -ENODEV;

	pr_info("HDCS-1000/1100 sensor detected\n");

	sd->gspca_dev.cam.cam_mode = hdcs1x00_mode;
	sd->gspca_dev.cam.nmodes = ARRAY_SIZE(hdcs1x00_mode);

	hdcs = kmalloc(sizeof(struct hdcs), GFP_KERNEL);
	if (!hdcs)
		return -ENOMEM;

	hdcs->array.left = 8;
	hdcs->array.top = 8;
	hdcs->array.width = HDCS_1X00_DEF_WIDTH;
	hdcs->array.height = HDCS_1X00_DEF_HEIGHT;
	hdcs->array.border = 4;

	hdcs->exp.cto = 4;
	hdcs->exp.cpo = 2;
	hdcs->exp.rs = 186;
	hdcs->exp.er = 100;

	/*
	 * Frame rate on HDCS-1000 with STV600 depends on PSMP:
	 *  4 = doesn't work at all
	 *  5 = 7.8 fps,
	 *  6 = 6.9 fps,
	 *  8 = 6.3 fps,
	 * 10 = 5.5 fps,
	 * 15 = 4.4 fps,
	 * 31 = 2.8 fps
	 *
	 * Frame rate on HDCS-1000 with STV602 depends on PSMP:
	 * 15 = doesn't work at all
	 * 18 = doesn't work at all
	 * 19 = 7.3 fps
	 * 20 = 7.4 fps
	 * 21 = 7.4 fps
	 * 22 = 7.4 fps
	 * 24 = 6.3 fps
	 * 30 = 5.4 fps
	 */
	hdcs->psmp = (sd->bridge == BRIDGE_STV602) ? 20 : 5;

	sd->sensor_priv = hdcs;

	return 0;
}

static int hdcs_probe_1020(struct sd *sd)
{
	struct hdcs *hdcs;
	u16 sensor;
	int ret;

	ret = stv06xx_read_sensor(sd, HDCS_IDENT, &sensor);
	if (ret < 0 || sensor != 0x10)
		return -ENODEV;

	pr_info("HDCS-1020 sensor detected\n");

	sd->gspca_dev.cam.cam_mode = hdcs1020_mode;
	sd->gspca_dev.cam.nmodes = ARRAY_SIZE(hdcs1020_mode);

	hdcs = kmalloc(sizeof(struct hdcs), GFP_KERNEL);
	if (!hdcs)
		return -ENOMEM;

	/*
	 * From Andrey's test image: looks like HDCS-1020 upper-left
	 * visible pixel is at 24,8 (y maybe even smaller?) and lower-right
	 * visible pixel at 375,299 (x maybe even larger?)
	 */
	hdcs->array.left = 24;
	hdcs->array.top  = 4;
	hdcs->array.width = HDCS_1020_DEF_WIDTH;
	hdcs->array.height = 304;
	hdcs->array.border = 4;

	hdcs->psmp = 6;

	hdcs->exp.cto = 3;
	hdcs->exp.cpo = 3;
	hdcs->exp.rs = 155;
	hdcs->exp.er = 96;

	sd->sensor_priv = hdcs;

	return 0;
}

static int hdcs_start(struct sd *sd)
{
	struct gspca_dev *gspca_dev = (struct gspca_dev *)sd;

	PDEBUG(D_STREAM, "Starting stream");

	return hdcs_set_state(sd, HDCS_STATE_RUN);
}

static int hdcs_stop(struct sd *sd)
{
	struct gspca_dev *gspca_dev = (struct gspca_dev *)sd;

	PDEBUG(D_STREAM, "Halting stream");

	return hdcs_set_state(sd, HDCS_STATE_SLEEP);
}

static int hdcs_init(struct sd *sd)
{
	struct hdcs *hdcs = sd->sensor_priv;
	int i, err = 0;

	/* Set the STV0602AA in STV0600 emulation mode */
	if (sd->bridge == BRIDGE_STV602)
		stv06xx_write_bridge(sd, STV_STV0600_EMULATION, 1);

	/* Execute the bridge init */
	for (i = 0; i < ARRAY_SIZE(stv_bridge_init) && !err; i++) {
		err = stv06xx_write_bridge(sd, stv_bridge_init[i][0],
					   stv_bridge_init[i][1]);
	}
	if (err < 0)
		return err;

	/* sensor soft reset */
	hdcs_reset(sd);

	/* Execute the sensor init */
	for (i = 0; i < ARRAY_SIZE(stv_sensor_init) && !err; i++) {
		err = stv06xx_write_sensor(sd, stv_sensor_init[i][0],
					     stv_sensor_init[i][1]);
	}
	if (err < 0)
		return err;

	/* Enable continuous frame capture, bit 2: stop when frame complete */
	err = stv06xx_write_sensor(sd, HDCS_REG_CONFIG(sd), BIT(3));
	if (err < 0)
		return err;

	/* Set PGA sample duration
	(was 0x7E for the STV602, but caused slow framerate with HDCS-1020) */
	if (IS_1020(sd))
		err = stv06xx_write_sensor(sd, HDCS_TCTRL,
				(HDCS_ADC_START_SIG_DUR << 6) | hdcs->psmp);
	else
		err = stv06xx_write_sensor(sd, HDCS_TCTRL,
				(HDCS_ADC_START_SIG_DUR << 5) | hdcs->psmp);
	if (err < 0)
		return err;

	return hdcs_set_size(sd, hdcs->array.width, hdcs->array.height);
}

static int hdcs_dump(struct sd *sd)
{
	u16 reg, val;

	pr_info("Dumping sensor registers:\n");

	for (reg = HDCS_IDENT; reg <= HDCS_ROWEXPH; reg++) {
		stv06xx_read_sensor(sd, reg, &val);
		pr_info("reg 0x%02x = 0x%02x\n", reg, val);
	}
	return 0;
}
Commit	Line	Data
4c98834a EA	1	/*
	2	* Copyright (c) 2001 Jean-Fredric Clere, Nikolas Zimmermann, Georg Acher
	3	* Mark Cave-Ayland, Carlo E Prelz, Dick Streefland
	4	* Copyright (c) 2002, 2003 Tuukka Toivonen
	5	* Copyright (c) 2008 Erik Andrén
	6	* Copyright (c) 2008 Chia-I Wu
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation; either version 2 of the License, or
	11	* (at your option) any later version.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*
4c98834a EA	18	* P/N 861037: Sensor HDCS1000 ASIC STV0600
	19	* P/N 861050-0010: Sensor HDCS1000 ASIC STV0600
	20	* P/N 861050-0020: Sensor Photobit PB100 ASIC STV0600-1 - QuickCam Express
	21	* P/N 861055: Sensor ST VV6410 ASIC STV0610 - LEGO cam
	22	* P/N 861075-0040: Sensor HDCS1000 ASIC
	23	* P/N 961179-0700: Sensor ST VV6410 ASIC STV0602 - Dexxa WebCam USB
	24	* P/N 861040-0000: Sensor ST VV6410 ASIC STV0610 - QuickCam Web
	25	*/
	26
133a9fe9 JP	27	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
133a9fe9 JP	28
4c98834a EA	29	#include "stv06xx_hdcs.h"
4c98834a EA	30
766231ab EA	31	static struct v4l2_pix_format hdcs1x00_mode[] = {
	32	{
	33	HDCS_1X00_DEF_WIDTH,
	34	HDCS_1X00_DEF_HEIGHT,
c0ea8f5b	35	V4L2_PIX_FMT_SGRBG8,
766231ab EA	36	V4L2_FIELD_NONE,
	37	.sizeimage =
	38	HDCS_1X00_DEF_WIDTH * HDCS_1X00_DEF_HEIGHT,
	39	.bytesperline = HDCS_1X00_DEF_WIDTH,
	40	.colorspace = V4L2_COLORSPACE_SRGB,
	41	.priv = 1
	42	}
	43	};
	44
766231ab EA	45	static struct v4l2_pix_format hdcs1020_mode[] = {
	46	{
	47	HDCS_1020_DEF_WIDTH,
	48	HDCS_1020_DEF_HEIGHT,
c0ea8f5b	49	V4L2_PIX_FMT_SGRBG8,
766231ab EA	50	V4L2_FIELD_NONE,
	51	.sizeimage =
	52	HDCS_1020_DEF_WIDTH * HDCS_1020_DEF_HEIGHT,
	53	.bytesperline = HDCS_1020_DEF_WIDTH,
	54	.colorspace = V4L2_COLORSPACE_SRGB,
	55	.priv = 1
	56	}
	57	};
	58
4c98834a EA	59	enum hdcs_power_state {
	60	HDCS_STATE_SLEEP,
	61	HDCS_STATE_IDLE,
	62	HDCS_STATE_RUN
	63	};
	64
	65	/* no lock? */
	66	struct hdcs {
	67	enum hdcs_power_state state;
	68	int w, h;
	69
	70	/* visible area of the sensor array */
	71	struct {
	72	int left, top;
	73	int width, height;
	74	int border;
	75	} array;
	76
	77	struct {
	78	/* Column timing overhead */
	79	u8 cto;
	80	/* Column processing overhead */
	81	u8 cpo;
	82	/* Row sample period constant */
	83	u16 rs;
	84	/* Exposure reset duration */
	85	u16 er;
	86	} exp;
	87
	88	int psmp;
	89	};
	90
	91	static int hdcs_reg_write_seq(struct sd sd, u8 reg, u8 vals, u8 len)
	92	{
	93	u8 regs[I2C_MAX_BYTES * 2];
	94	int i;
	95
	96	if (unlikely((len <= 0) \|\| (len >= I2C_MAX_BYTES) \|\|
	97	(reg + len > 0xff)))
	98	return -EINVAL;
	99
ac51295c EA	100	for (i = 0; i < len; i++) {
	101	regs[2 * i] = reg;
	102	regs[2 * i + 1] = vals[i];
780e3121 JFM	103	/* All addresses are shifted left one bit
780e3121 JFM	104	* as bit 0 toggles r/w */
ac51295c	105	reg += 2;
4c98834a EA	106	}
	107
	108	return stv06xx_write_sensor_bytes(sd, regs, len);
	109	}
	110
	111	static int hdcs_set_state(struct sd *sd, enum hdcs_power_state state)
	112	{
	113	struct hdcs *hdcs = sd->sensor_priv;
	114	u8 val;
	115	int ret;
	116
	117	if (hdcs->state == state)
	118	return 0;
	119
	120	/* we need to go idle before running or sleeping */
	121	if (hdcs->state != HDCS_STATE_IDLE) {
	122	ret = stv06xx_write_sensor(sd, HDCS_REG_CONTROL(sd), 0);
	123	if (ret)
	124	return ret;
	125	}
	126
	127	hdcs->state = HDCS_STATE_IDLE;
	128
	129	if (state == HDCS_STATE_IDLE)
	130	return 0;
	131
	132	switch (state) {
	133	case HDCS_STATE_SLEEP:
	134	val = HDCS_SLEEP_MODE;
	135	break;
	136
	137	case HDCS_STATE_RUN:
	138	val = HDCS_RUN_ENABLE;
	139	break;
	140
	141	default:
	142	return -EINVAL;
	143	}
	144
	145	ret = stv06xx_write_sensor(sd, HDCS_REG_CONTROL(sd), val);
36a516d9 EA	146
	147	/* Update the state if the write succeeded */
	148	if (!ret)
4c98834a EA	149	hdcs->state = state;
	150
	151	return ret;
	152	}
	153
	154	static int hdcs_reset(struct sd *sd)
	155	{
	156	struct hdcs *hdcs = sd->sensor_priv;
	157	int err;
	158
	159	err = stv06xx_write_sensor(sd, HDCS_REG_CONTROL(sd), 1);
	160	if (err < 0)
	161	return err;
	162
	163	err = stv06xx_write_sensor(sd, HDCS_REG_CONTROL(sd), 0);
	164	if (err < 0)
	165	hdcs->state = HDCS_STATE_IDLE;
	166
	167	return err;
	168	}
	169
4c98834a EA	170	static int hdcs_set_exposure(struct gspca_dev *gspca_dev, __s32 val)
	171	{
	172	struct sd sd = (struct sd ) gspca_dev;
	173	struct hdcs *hdcs = sd->sensor_priv;
	174	int rowexp, srowexp;
	175	int max_srowexp;
	176	/* Column time period */
	177	int ct;
	178	/* Column processing period */
	179	int cp;
	180	/* Row processing period */
	181	int rp;
	182	/* Minimum number of column timing periods
	183	within the column processing period */
	184	int mnct;
	185	int cycles, err;
4711ca82	186	u8 exp[14];
4c98834a	187
35ccf8f8	188	cycles = val * HDCS_CLK_FREQ_MHZ * 257;
4c98834a EA	189
	190	ct = hdcs->exp.cto + hdcs->psmp + (HDCS_ADC_START_SIG_DUR + 2);
	191	cp = hdcs->exp.cto + (hdcs->w * ct / 2);
	192
	193	/* the cycles one row takes */
	194	rp = hdcs->exp.rs + cp;
	195
	196	rowexp = cycles / rp;
	197
	198	/* the remaining cycles */
	199	cycles -= rowexp * rp;
	200
	201	/* calculate sub-row exposure */
	202	if (IS_1020(sd)) {
	203	/* see HDCS-1020 datasheet 3.5.6.4, p. 63 */
	204	srowexp = hdcs->w - (cycles + hdcs->exp.er + 13) / ct;
	205
	206	mnct = (hdcs->exp.er + 12 + ct - 1) / ct;
	207	max_srowexp = hdcs->w - mnct;
	208	} else {
	209	/* see HDCS-1000 datasheet 3.4.5.5, p. 61 */
	210	srowexp = cp - hdcs->exp.er - 6 - cycles;
	211
	212	mnct = (hdcs->exp.er + 5 + ct - 1) / ct;
	213	max_srowexp = cp - mnct * ct - 1;
	214	}
	215
	216	if (srowexp < 0)
	217	srowexp = 0;
	218	else if (srowexp > max_srowexp)
	219	srowexp = max_srowexp;
	220
	221	if (IS_1020(sd)) {
4711ca82 JB	222	exp[0] = HDCS20_CONTROL;
	223	exp[1] = 0x00; /* Stop streaming */
	224	exp[2] = HDCS_ROWEXPL;
	225	exp[3] = rowexp & 0xff;
	226	exp[4] = HDCS_ROWEXPH;
	227	exp[5] = rowexp >> 8;
	228	exp[6] = HDCS20_SROWEXP;
	229	exp[7] = (srowexp >> 2) & 0xff;
	230	exp[8] = HDCS20_ERROR;
	231	exp[9] = 0x10; /* Clear exposure error flag*/
	232	exp[10] = HDCS20_CONTROL;
	233	exp[11] = 0x04; /* Restart streaming */
	234	err = stv06xx_write_sensor_bytes(sd, exp, 6);
4c98834a	235	} else {
4711ca82 JB	236	exp[0] = HDCS00_CONTROL;
	237	exp[1] = 0x00; /* Stop streaming */
	238	exp[2] = HDCS_ROWEXPL;
	239	exp[3] = rowexp & 0xff;
	240	exp[4] = HDCS_ROWEXPH;
	241	exp[5] = rowexp >> 8;
	242	exp[6] = HDCS00_SROWEXPL;
	243	exp[7] = srowexp & 0xff;
	244	exp[8] = HDCS00_SROWEXPH;
	245	exp[9] = srowexp >> 8;
	246	exp[10] = HDCS_STATUS;
	247	exp[11] = 0x10; /* Clear exposure error flag*/
	248	exp[12] = HDCS00_CONTROL;
	249	exp[13] = 0x04; /* Restart streaming */
	250	err = stv06xx_write_sensor_bytes(sd, exp, 7);
4c98834a EA	251	if (err < 0)
4c98834a EA	252	return err;
4c98834a	253	}
c93396e1	254	PDEBUG(D_CONF, "Writing exposure %d, rowexp %d, srowexp %d",
4c98834a EA	255	val, rowexp, srowexp);
	256	return err;
	257	}
	258
35ccf8f8	259	static int hdcs_set_gains(struct sd *sd, u8 g)
4c98834a	260	{
35ccf8f8	261	int err;
4c98834a EA	262	u8 gains[4];
	263
	264	/* the voltage gain Av = (1 + 19 * val / 127) * (1 + bit7) */
4c98834a EA	265	if (g > 127)
4c98834a EA	266	g = 0x80 \| (g / 2);
4c98834a EA	267
4c98834a EA	268	gains[0] = g;
35ccf8f8 JB	269	gains[1] = g;
35ccf8f8 JB	270	gains[2] = g;
4c98834a EA	271	gains[3] = g;
4c98834a EA	272
35ccf8f8	273	err = hdcs_reg_write_seq(sd, HDCS_ERECPGA, gains, 4);
dec9c514	274	return err;
4c98834a EA	275	}
	276
	277	static int hdcs_set_gain(struct gspca_dev *gspca_dev, __s32 val)
	278	{
c93396e1	279	PDEBUG(D_CONF, "Writing gain %d", val);
4c98834a	280	return hdcs_set_gains((struct sd *) gspca_dev,
35ccf8f8	281	val & 0xff);
4c98834a EA	282	}
	283
	284	static int hdcs_set_size(struct sd *sd,
	285	unsigned int width, unsigned int height)
	286	{
	287	struct hdcs *hdcs = sd->sensor_priv;
	288	u8 win[4];
	289	unsigned int x, y;
	290	int err;
	291
	292	/* must be multiple of 4 */
	293	width = (width + 3) & ~0x3;
	294	height = (height + 3) & ~0x3;
	295
	296	if (width > hdcs->array.width)
	297	width = hdcs->array.width;
	298
	299	if (IS_1020(sd)) {
	300	/* the borders are also invalid */
	301	if (height + 2 * hdcs->array.border + HDCS_1020_BOTTOM_Y_SKIP
	302	> hdcs->array.height)
	303	height = hdcs->array.height - 2 * hdcs->array.border -
	304	HDCS_1020_BOTTOM_Y_SKIP;
	305
	306	y = (hdcs->array.height - HDCS_1020_BOTTOM_Y_SKIP - height) / 2
	307	+ hdcs->array.top;
1970f14f EA	308	} else {
	309	if (height > hdcs->array.height)
	310	height = hdcs->array.height;
	311
4c98834a EA	312	y = hdcs->array.top + (hdcs->array.height - height) / 2;
	313	}
	314
	315	x = hdcs->array.left + (hdcs->array.width - width) / 2;
	316
	317	win[0] = y / 4;
	318	win[1] = x / 4;
	319	win[2] = (y + height) / 4 - 1;
	320	win[3] = (x + width) / 4 - 1;
	321
	322	err = hdcs_reg_write_seq(sd, HDCS_FWROW, win, 4);
	323	if (err < 0)
	324	return err;
	325
	326	/* Update the current width and height */
	327	hdcs->w = width;
	328	hdcs->h = height;
	329	return err;
	330	}
	331
dec9c514 HV	332	static int hdcs_s_ctrl(struct v4l2_ctrl *ctrl)
dec9c514 HV	333	{
a8a47860 HG	334	struct gspca_dev *gspca_dev =
a8a47860 HG	335	container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
dec9c514 HV	336	int err = -EINVAL;
	337
	338	switch (ctrl->id) {
	339	case V4L2_CID_GAIN:
a8a47860	340	err = hdcs_set_gain(gspca_dev, ctrl->val);
dec9c514 HV	341	break;
dec9c514 HV	342	case V4L2_CID_EXPOSURE:
a8a47860	343	err = hdcs_set_exposure(gspca_dev, ctrl->val);
dec9c514 HV	344	break;
	345	}
	346	return err;
	347	}
	348
	349	static const struct v4l2_ctrl_ops hdcs_ctrl_ops = {
	350	.s_ctrl = hdcs_s_ctrl,
	351	};
	352
	353	static int hdcs_init_controls(struct sd *sd)
	354	{
a8a47860	355	struct v4l2_ctrl_handler *hdl = &sd->gspca_dev.ctrl_handler;
dec9c514 HV	356
	357	v4l2_ctrl_handler_init(hdl, 2);
	358	v4l2_ctrl_new_std(hdl, &hdcs_ctrl_ops,
	359	V4L2_CID_EXPOSURE, 0, 0xff, 1, HDCS_DEFAULT_EXPOSURE);
	360	v4l2_ctrl_new_std(hdl, &hdcs_ctrl_ops,
	361	V4L2_CID_GAIN, 0, 0xff, 1, HDCS_DEFAULT_GAIN);
	362	return hdl->error;
	363	}
	364
4c98834a EA	365	static int hdcs_probe_1x00(struct sd *sd)
	366	{
	367	struct hdcs *hdcs;
	368	u16 sensor;
	369	int ret;
	370
	371	ret = stv06xx_read_sensor(sd, HDCS_IDENT, &sensor);
	372	if (ret < 0 \|\| sensor != 0x08)
	373	return -ENODEV;
	374
133a9fe9	375	pr_info("HDCS-1000/1100 sensor detected\n");
4c98834a	376
766231ab EA	377	sd->gspca_dev.cam.cam_mode = hdcs1x00_mode;
766231ab EA	378	sd->gspca_dev.cam.nmodes = ARRAY_SIZE(hdcs1x00_mode);
4c98834a EA	379
	380	hdcs = kmalloc(sizeof(struct hdcs), GFP_KERNEL);
	381	if (!hdcs)
	382	return -ENOMEM;
	383
	384	hdcs->array.left = 8;
	385	hdcs->array.top = 8;
	386	hdcs->array.width = HDCS_1X00_DEF_WIDTH;
	387	hdcs->array.height = HDCS_1X00_DEF_HEIGHT;
	388	hdcs->array.border = 4;
	389
	390	hdcs->exp.cto = 4;
	391	hdcs->exp.cpo = 2;
	392	hdcs->exp.rs = 186;
	393	hdcs->exp.er = 100;
	394
	395	/*
8668d504	396	* Frame rate on HDCS-1000 with STV600 depends on PSMP:
4c98834a EA	397	* 4 = doesn't work at all
	398	* 5 = 7.8 fps,
	399	* 6 = 6.9 fps,
	400	* 8 = 6.3 fps,
	401	* 10 = 5.5 fps,
	402	* 15 = 4.4 fps,
	403	* 31 = 2.8 fps
	404	*
8668d504	405	* Frame rate on HDCS-1000 with STV602 depends on PSMP:
4c98834a EA	406	* 15 = doesn't work at all
	407	* 18 = doesn't work at all
	408	* 19 = 7.3 fps
	409	* 20 = 7.4 fps
	410	* 21 = 7.4 fps
	411	* 22 = 7.4 fps
	412	* 24 = 6.3 fps
	413	* 30 = 5.4 fps
	414	*/
8668d504	415	hdcs->psmp = (sd->bridge == BRIDGE_STV602) ? 20 : 5;
4c98834a EA	416
	417	sd->sensor_priv = hdcs;
	418
	419	return 0;
	420	}
	421
	422	static int hdcs_probe_1020(struct sd *sd)
	423	{
	424	struct hdcs *hdcs;
	425	u16 sensor;
	426	int ret;
	427
	428	ret = stv06xx_read_sensor(sd, HDCS_IDENT, &sensor);
	429	if (ret < 0 \|\| sensor != 0x10)
	430	return -ENODEV;
	431
133a9fe9	432	pr_info("HDCS-1020 sensor detected\n");
4c98834a	433
766231ab EA	434	sd->gspca_dev.cam.cam_mode = hdcs1020_mode;
766231ab EA	435	sd->gspca_dev.cam.nmodes = ARRAY_SIZE(hdcs1020_mode);
4c98834a EA	436
	437	hdcs = kmalloc(sizeof(struct hdcs), GFP_KERNEL);
	438	if (!hdcs)
	439	return -ENOMEM;
	440
	441	/*
	442	* From Andrey's test image: looks like HDCS-1020 upper-left
	443	* visible pixel is at 24,8 (y maybe even smaller?) and lower-right
	444	* visible pixel at 375,299 (x maybe even larger?)
	445	*/
	446	hdcs->array.left = 24;
	447	hdcs->array.top = 4;
	448	hdcs->array.width = HDCS_1020_DEF_WIDTH;
	449	hdcs->array.height = 304;
	450	hdcs->array.border = 4;
	451
	452	hdcs->psmp = 6;
	453
	454	hdcs->exp.cto = 3;
	455	hdcs->exp.cpo = 3;
	456	hdcs->exp.rs = 155;
	457	hdcs->exp.er = 96;
	458
	459	sd->sensor_priv = hdcs;
	460
	461	return 0;
	462	}
	463
	464	static int hdcs_start(struct sd *sd)
	465	{
c93396e1 TK	466	struct gspca_dev gspca_dev = (struct gspca_dev )sd;
c93396e1 TK	467
4c98834a EA	468	PDEBUG(D_STREAM, "Starting stream");
	469
	470	return hdcs_set_state(sd, HDCS_STATE_RUN);
	471	}
	472
	473	static int hdcs_stop(struct sd *sd)
	474	{
c93396e1 TK	475	struct gspca_dev gspca_dev = (struct gspca_dev )sd;
c93396e1 TK	476
4c98834a EA	477	PDEBUG(D_STREAM, "Halting stream");
	478
	479	return hdcs_set_state(sd, HDCS_STATE_SLEEP);
	480	}
	481
4c98834a EA	482	static int hdcs_init(struct sd *sd)
	483	{
	484	struct hdcs *hdcs = sd->sensor_priv;
	485	int i, err = 0;
	486
	487	/* Set the STV0602AA in STV0600 emulation mode */
8668d504	488	if (sd->bridge == BRIDGE_STV602)
4c98834a EA	489	stv06xx_write_bridge(sd, STV_STV0600_EMULATION, 1);
	490
	491	/* Execute the bridge init */
	492	for (i = 0; i < ARRAY_SIZE(stv_bridge_init) && !err; i++) {
	493	err = stv06xx_write_bridge(sd, stv_bridge_init[i][0],
	494	stv_bridge_init[i][1]);
	495	}
	496	if (err < 0)
	497	return err;
	498
	499	/* sensor soft reset */
	500	hdcs_reset(sd);
	501
	502	/* Execute the sensor init */
	503	for (i = 0; i < ARRAY_SIZE(stv_sensor_init) && !err; i++) {
	504	err = stv06xx_write_sensor(sd, stv_sensor_init[i][0],
	505	stv_sensor_init[i][1]);
	506	}
	507	if (err < 0)
	508	return err;
	509
25985edc	510	/* Enable continuous frame capture, bit 2: stop when frame complete */
4c98834a EA	511	err = stv06xx_write_sensor(sd, HDCS_REG_CONFIG(sd), BIT(3));
	512	if (err < 0)
	513	return err;
	514
	515	/* Set PGA sample duration
8668d504	516	(was 0x7E for the STV602, but caused slow framerate with HDCS-1020) */
4c98834a EA	517	if (IS_1020(sd))
	518	err = stv06xx_write_sensor(sd, HDCS_TCTRL,
	519	(HDCS_ADC_START_SIG_DUR << 6) \| hdcs->psmp);
	520	else
	521	err = stv06xx_write_sensor(sd, HDCS_TCTRL,
	522	(HDCS_ADC_START_SIG_DUR << 5) \| hdcs->psmp);
	523	if (err < 0)
	524	return err;
	525
dec9c514	526	return hdcs_set_size(sd, hdcs->array.width, hdcs->array.height);
4c98834a EA	527	}
	528
	529	static int hdcs_dump(struct sd *sd)
	530	{
	531	u16 reg, val;
	532
133a9fe9	533	pr_info("Dumping sensor registers:\n");
4c98834a EA	534
	535	for (reg = HDCS_IDENT; reg <= HDCS_ROWEXPH; reg++) {
	536	stv06xx_read_sensor(sd, reg, &val);
133a9fe9	537	pr_info("reg 0x%02x = 0x%02x\n", reg, val);
4c98834a EA	538	}
	539	return 0;
	540	}