[deliverable/linux.git] / drivers / media / video / gspca / stk014.c

/*
 * Syntek DV4000 (STK014) subdriver
 *
 * Copyright (C) 2008 Jean-Francois Moine (http://moinejf.free.fr)
 *
 * 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 pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#define MODULE_NAME "stk014"

#include "gspca.h"
#include "jpeg.h"

MODULE_AUTHOR("Jean-Francois Moine <http://moinejf.free.fr>");
MODULE_DESCRIPTION("Syntek DV4000 (STK014) USB Camera Driver");
MODULE_LICENSE("GPL");

/* controls */
enum e_ctrl {
	BRIGHTNESS,
	CONTRAST,
	COLORS,
	LIGHTFREQ,
	NCTRLS		/* number of controls */
};

/* specific webcam descriptor */
struct sd {
	struct gspca_dev gspca_dev;	/* !! must be the first item */

	struct gspca_ctrl ctrls[NCTRLS];

	u8 quality;
#define QUALITY_MIN 70
#define QUALITY_MAX 95
#define QUALITY_DEF 88

	u8 jpeg_hdr[JPEG_HDR_SZ];
};

/* V4L2 controls supported by the driver */
static void setbrightness(struct gspca_dev *gspca_dev);
static void setcontrast(struct gspca_dev *gspca_dev);
static void setcolors(struct gspca_dev *gspca_dev);
static void setlightfreq(struct gspca_dev *gspca_dev);

static const struct ctrl sd_ctrls[NCTRLS] = {
[BRIGHTNESS] = {
	    {
		.id      = V4L2_CID_BRIGHTNESS,
		.type    = V4L2_CTRL_TYPE_INTEGER,
		.name    = "Brightness",
		.minimum = 0,
		.maximum = 255,
		.step    = 1,
		.default_value = 127,
	    },
	    .set_control = setbrightness
	},
[CONTRAST] = {
	    {
		.id      = V4L2_CID_CONTRAST,
		.type    = V4L2_CTRL_TYPE_INTEGER,
		.name    = "Contrast",
		.minimum = 0,
		.maximum = 255,
		.step    = 1,
		.default_value = 127,
	    },
	    .set_control = setcontrast
	},
[COLORS] = {
	    {
		.id      = V4L2_CID_SATURATION,
		.type    = V4L2_CTRL_TYPE_INTEGER,
		.name    = "Color",
		.minimum = 0,
		.maximum = 255,
		.step    = 1,
		.default_value = 127,
	    },
	    .set_control = setcolors
	},
[LIGHTFREQ] = {
	    {
		.id	 = V4L2_CID_POWER_LINE_FREQUENCY,
		.type    = V4L2_CTRL_TYPE_MENU,
		.name    = "Light frequency filter",
		.minimum = 1,
		.maximum = 2,	/* 0: 0, 1: 50Hz, 2:60Hz */
		.step    = 1,
		.default_value = 1,
	    },
	    .set_control = setlightfreq
	},
};

static const struct v4l2_pix_format vga_mode[] = {
	{320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
		.bytesperline = 320,
		.sizeimage = 320 * 240 * 3 / 8 + 590,
		.colorspace = V4L2_COLORSPACE_JPEG,
		.priv = 1},
	{640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
		.bytesperline = 640,
		.sizeimage = 640 * 480 * 3 / 8 + 590,
		.colorspace = V4L2_COLORSPACE_JPEG,
		.priv = 0},
};

/* -- read a register -- */
static u8 reg_r(struct gspca_dev *gspca_dev,
			__u16 index)
{
	struct usb_device *dev = gspca_dev->dev;
	int ret;

	if (gspca_dev->usb_err < 0)
		return 0;
	ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
			0x00,
			USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
			0x00,
			index,
			gspca_dev->usb_buf, 1,
			500);
	if (ret < 0) {
		pr_err("reg_r err %d\n", ret);
		gspca_dev->usb_err = ret;
		return 0;
	}
	return gspca_dev->usb_buf[0];
}

/* -- write a register -- */
static void reg_w(struct gspca_dev *gspca_dev,
			__u16 index, __u16 value)
{
	struct usb_device *dev = gspca_dev->dev;
	int ret;

	if (gspca_dev->usb_err < 0)
		return;
	ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
			0x01,
			USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
			value,
			index,
			NULL,
			0,
			500);
	if (ret < 0) {
		pr_err("reg_w err %d\n", ret);
		gspca_dev->usb_err = ret;
	}
}

/* -- get a bulk value (4 bytes) -- */
static void rcv_val(struct gspca_dev *gspca_dev,
			int ads)
{
	struct usb_device *dev = gspca_dev->dev;
	int alen, ret;

	reg_w(gspca_dev, 0x634, (ads >> 16) & 0xff);
	reg_w(gspca_dev, 0x635, (ads >> 8) & 0xff);
	reg_w(gspca_dev, 0x636, ads & 0xff);
	reg_w(gspca_dev, 0x637, 0);
	reg_w(gspca_dev, 0x638, 4);	/* len & 0xff */
	reg_w(gspca_dev, 0x639, 0);	/* len >> 8 */
	reg_w(gspca_dev, 0x63a, 0);
	reg_w(gspca_dev, 0x63b, 0);
	reg_w(gspca_dev, 0x630, 5);
	if (gspca_dev->usb_err < 0)
		return;
	ret = usb_bulk_msg(dev,
			usb_rcvbulkpipe(dev, 0x05),
			gspca_dev->usb_buf,
			4,		/* length */
			&alen,
			500);		/* timeout in milliseconds */
	if (ret < 0) {
		pr_err("rcv_val err %d\n", ret);
		gspca_dev->usb_err = ret;
	}
}

/* -- send a bulk value -- */
static void snd_val(struct gspca_dev *gspca_dev,
			int ads,
			unsigned int val)
{
	struct usb_device *dev = gspca_dev->dev;
	int alen, ret;
	__u8 seq = 0;

	if (ads == 0x003f08) {
		reg_r(gspca_dev, 0x0704);
		seq = reg_r(gspca_dev, 0x0705);
		reg_r(gspca_dev, 0x0650);
		reg_w(gspca_dev, 0x654, seq);
	} else {
		reg_w(gspca_dev, 0x654, (ads >> 16) & 0xff);
	}
	reg_w(gspca_dev, 0x655, (ads >> 8) & 0xff);
	reg_w(gspca_dev, 0x656, ads & 0xff);
	reg_w(gspca_dev, 0x657, 0);
	reg_w(gspca_dev, 0x658, 0x04);	/* size */
	reg_w(gspca_dev, 0x659, 0);
	reg_w(gspca_dev, 0x65a, 0);
	reg_w(gspca_dev, 0x65b, 0);
	reg_w(gspca_dev, 0x650, 5);
	if (gspca_dev->usb_err < 0)
		return;
	gspca_dev->usb_buf[0] = val >> 24;
	gspca_dev->usb_buf[1] = val >> 16;
	gspca_dev->usb_buf[2] = val >> 8;
	gspca_dev->usb_buf[3] = val;
	ret = usb_bulk_msg(dev,
			usb_sndbulkpipe(dev, 6),
			gspca_dev->usb_buf,
			4,
			&alen,
			500);	/* timeout in milliseconds */
	if (ret < 0) {
		pr_err("snd_val err %d\n", ret);
		gspca_dev->usb_err = ret;
	} else {
		if (ads == 0x003f08) {
			seq += 4;
			seq &= 0x3f;
			reg_w(gspca_dev, 0x705, seq);
		}
	}
}

/* set a camera parameter */
static void set_par(struct gspca_dev *gspca_dev,
		   int parval)
{
	snd_val(gspca_dev, 0x003f08, parval);
}

static void setbrightness(struct gspca_dev *gspca_dev)
{
	struct sd *sd = (struct sd *) gspca_dev;
	int parval;

	parval = 0x06000000		/* whiteness */
		+ (sd->ctrls[BRIGHTNESS].val << 16);
	set_par(gspca_dev, parval);
}

static void setcontrast(struct gspca_dev *gspca_dev)
{
	struct sd *sd = (struct sd *) gspca_dev;
	int parval;

	parval = 0x07000000		/* contrast */
		+ (sd->ctrls[CONTRAST].val << 16);
	set_par(gspca_dev, parval);
}

static void setcolors(struct gspca_dev *gspca_dev)
{
	struct sd *sd = (struct sd *) gspca_dev;
	int parval;

	parval = 0x08000000		/* saturation */
		+ (sd->ctrls[COLORS].val << 16);
	set_par(gspca_dev, parval);
}

static void setlightfreq(struct gspca_dev *gspca_dev)
{
	struct sd *sd = (struct sd *) gspca_dev;

	set_par(gspca_dev, sd->ctrls[LIGHTFREQ].val == 1
			? 0x33640000		/* 50 Hz */
			: 0x33780000);		/* 60 Hz */
}

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

	gspca_dev->cam.cam_mode = vga_mode;
	gspca_dev->cam.nmodes = ARRAY_SIZE(vga_mode);
	gspca_dev->cam.ctrls = sd->ctrls;
	sd->quality = QUALITY_DEF;
	return 0;
}

/* this function is called at probe and resume time */
static int sd_init(struct gspca_dev *gspca_dev)
{
	u8 ret;

	/* check if the device responds */
	usb_set_interface(gspca_dev->dev, gspca_dev->iface, 1);
	ret = reg_r(gspca_dev, 0x0740);
	if (gspca_dev->usb_err >= 0) {
		if (ret != 0xff) {
			pr_err("init reg: 0x%02x\n", ret);
			gspca_dev->usb_err = -EIO;
		}
	}
	return gspca_dev->usb_err;
}

/* -- start the camera -- */
static int sd_start(struct gspca_dev *gspca_dev)
{
	struct sd *sd = (struct sd *) gspca_dev;
	int ret, value;

	/* create the JPEG header */
	jpeg_define(sd->jpeg_hdr, gspca_dev->height, gspca_dev->width,
			0x22);		/* JPEG 411 */
	jpeg_set_qual(sd->jpeg_hdr, sd->quality);

	/* work on alternate 1 */
	usb_set_interface(gspca_dev->dev, gspca_dev->iface, 1);

	set_par(gspca_dev, 0x10000000);
	set_par(gspca_dev, 0x00000000);
	set_par(gspca_dev, 0x8002e001);
	set_par(gspca_dev, 0x14000000);
	if (gspca_dev->width > 320)
		value = 0x8002e001;		/* 640x480 */
	else
		value = 0x4001f000;		/* 320x240 */
	set_par(gspca_dev, value);
	ret = usb_set_interface(gspca_dev->dev,
					gspca_dev->iface,
					gspca_dev->alt);
	if (ret < 0) {
		pr_err("set intf %d %d failed\n",
		       gspca_dev->iface, gspca_dev->alt);
		gspca_dev->usb_err = ret;
		goto out;
	}
	 reg_r(gspca_dev, 0x0630);
	rcv_val(gspca_dev, 0x000020);	/* << (value ff ff ff ff) */
	reg_r(gspca_dev, 0x0650);
	snd_val(gspca_dev, 0x000020, 0xffffffff);
	reg_w(gspca_dev, 0x0620, 0);
	reg_w(gspca_dev, 0x0630, 0);
	reg_w(gspca_dev, 0x0640, 0);
	reg_w(gspca_dev, 0x0650, 0);
	reg_w(gspca_dev, 0x0660, 0);
	setbrightness(gspca_dev);		/* whiteness */
	setcontrast(gspca_dev);			/* contrast */
	setcolors(gspca_dev);			/* saturation */
	set_par(gspca_dev, 0x09800000);		/* Red ? */
	set_par(gspca_dev, 0x0a800000);		/* Green ? */
	set_par(gspca_dev, 0x0b800000);		/* Blue ? */
	set_par(gspca_dev, 0x0d030000);		/* Gamma ? */
	setlightfreq(gspca_dev);

	/* start the video flow */
	set_par(gspca_dev, 0x01000000);
	set_par(gspca_dev, 0x01000000);
	if (gspca_dev->usb_err >= 0)
		PDEBUG(D_STREAM, "camera started alt: 0x%02x",
				gspca_dev->alt);
out:
	return gspca_dev->usb_err;
}

static void sd_stopN(struct gspca_dev *gspca_dev)
{
	struct usb_device *dev = gspca_dev->dev;

	set_par(gspca_dev, 0x02000000);
	set_par(gspca_dev, 0x02000000);
	usb_set_interface(dev, gspca_dev->iface, 1);
	reg_r(gspca_dev, 0x0630);
	rcv_val(gspca_dev, 0x000020);	/* << (value ff ff ff ff) */
	reg_r(gspca_dev, 0x0650);
	snd_val(gspca_dev, 0x000020, 0xffffffff);
	reg_w(gspca_dev, 0x0620, 0);
	reg_w(gspca_dev, 0x0630, 0);
	reg_w(gspca_dev, 0x0640, 0);
	reg_w(gspca_dev, 0x0650, 0);
	reg_w(gspca_dev, 0x0660, 0);
	PDEBUG(D_STREAM, "camera stopped");
}

static void sd_pkt_scan(struct gspca_dev *gspca_dev,
			u8 *data,			/* isoc packet */
			int len)			/* iso packet length */
{
	struct sd *sd = (struct sd *) gspca_dev;
	static unsigned char ffd9[] = {0xff, 0xd9};

	/* a frame starts with:
	 *	- 0xff 0xfe
	 *	- 0x08 0x00	- length (little endian ?!)
	 *	- 4 bytes = size of whole frame (BE - including header)
	 *	- 0x00 0x0c
	 *	- 0xff 0xd8
	 *	- ..	JPEG image with escape sequences (ff 00)
	 *		(without ending - ff d9)
	 */
	if (data[0] == 0xff && data[1] == 0xfe) {
		gspca_frame_add(gspca_dev, LAST_PACKET,
				ffd9, 2);

		/* put the JPEG 411 header */
		gspca_frame_add(gspca_dev, FIRST_PACKET,
			sd->jpeg_hdr, JPEG_HDR_SZ);

		/* beginning of the frame */
#define STKHDRSZ 12
		data += STKHDRSZ;
		len -= STKHDRSZ;
	}
	gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
}

static int sd_querymenu(struct gspca_dev *gspca_dev,
			struct v4l2_querymenu *menu)
{
	static const char *freq_nm[3] = {"NoFliker", "50 Hz", "60 Hz"};

	switch (menu->id) {
	case V4L2_CID_POWER_LINE_FREQUENCY:
		if ((unsigned) menu->index >= ARRAY_SIZE(freq_nm))
			break;
		strcpy((char *) menu->name, freq_nm[menu->index]);
		return 0;
	}
	return -EINVAL;
}

static int sd_set_jcomp(struct gspca_dev *gspca_dev,
			struct v4l2_jpegcompression *jcomp)
{
	struct sd *sd = (struct sd *) gspca_dev;

	if (jcomp->quality < QUALITY_MIN)
		sd->quality = QUALITY_MIN;
	else if (jcomp->quality > QUALITY_MAX)
		sd->quality = QUALITY_MAX;
	else
		sd->quality = jcomp->quality;
	if (gspca_dev->streaming)
		jpeg_set_qual(sd->jpeg_hdr, sd->quality);
	return gspca_dev->usb_err;
}

static int sd_get_jcomp(struct gspca_dev *gspca_dev,
			struct v4l2_jpegcompression *jcomp)
{
	struct sd *sd = (struct sd *) gspca_dev;

	memset(jcomp, 0, sizeof *jcomp);
	jcomp->quality = sd->quality;
	jcomp->jpeg_markers = V4L2_JPEG_MARKER_DHT
			| V4L2_JPEG_MARKER_DQT;
	return 0;
}

/* sub-driver description */
static const struct sd_desc sd_desc = {
	.name = MODULE_NAME,
	.ctrls = sd_ctrls,
	.nctrls = NCTRLS,
	.config = sd_config,
	.init = sd_init,
	.start = sd_start,
	.stopN = sd_stopN,
	.pkt_scan = sd_pkt_scan,
	.querymenu = sd_querymenu,
	.get_jcomp = sd_get_jcomp,
	.set_jcomp = sd_set_jcomp,
};

/* -- module initialisation -- */
static const struct usb_device_id device_table[] = {
	{USB_DEVICE(0x05e1, 0x0893)},
	{}
};
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_usb_driver(sd_driver);
Commit	Line	Data
63eb9546 JFM	1	/*
	2	* Syntek DV4000 (STK014) subdriver
	3	*
d43fa32f	4	* Copyright (C) 2008 Jean-Francois Moine (http://moinejf.free.fr)
63eb9546 JFM	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, write to the Free Software
	18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
63eb9546 JFM	19	*/
63eb9546 JFM	20
133a9fe9 JP	21	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
133a9fe9 JP	22
63eb9546 JFM	23	#define MODULE_NAME "stk014"
	24
	25	#include "gspca.h"
	26	#include "jpeg.h"
	27
63eb9546 JFM	28	MODULE_AUTHOR("Jean-Francois Moine <http://moinejf.free.fr>");
	29	MODULE_DESCRIPTION("Syntek DV4000 (STK014) USB Camera Driver");
	30	MODULE_LICENSE("GPL");
	31
016f2362 JFM	32	/* controls */
	33	enum e_ctrl {
	34	BRIGHTNESS,
	35	CONTRAST,
	36	COLORS,
	37	LIGHTFREQ,
	38	NCTRLS /* number of controls */
	39	};
	40
63eb9546 JFM	41	/* specific webcam descriptor */
	42	struct sd {
	43	struct gspca_dev gspca_dev; /* !! must be the first item */
	44
016f2362 JFM	45	struct gspca_ctrl ctrls[NCTRLS];
016f2362 JFM	46
71cb2764	47	u8 quality;
bf48cc41	48	#define QUALITY_MIN 70
77ac0baf	49	#define QUALITY_MAX 95
bf48cc41	50	#define QUALITY_DEF 88
71cb2764	51
9a731a32	52	u8 jpeg_hdr[JPEG_HDR_SZ];
63eb9546 JFM	53	};
63eb9546 JFM	54
63eb9546	55	/* V4L2 controls supported by the driver */
016f2362 JFM	56	static void setbrightness(struct gspca_dev *gspca_dev);
	57	static void setcontrast(struct gspca_dev *gspca_dev);
	58	static void setcolors(struct gspca_dev *gspca_dev);
	59	static void setlightfreq(struct gspca_dev *gspca_dev);
	60
	61	static const struct ctrl sd_ctrls[NCTRLS] = {
	62	[BRIGHTNESS] = {
63eb9546 JFM	63	{
	64	.id = V4L2_CID_BRIGHTNESS,
	65	.type = V4L2_CTRL_TYPE_INTEGER,
	66	.name = "Brightness",
	67	.minimum = 0,
	68	.maximum = 255,
	69	.step = 1,
016f2362	70	.default_value = 127,
63eb9546	71	},
016f2362	72	.set_control = setbrightness
63eb9546	73	},
016f2362	74	[CONTRAST] = {
63eb9546 JFM	75	{
	76	.id = V4L2_CID_CONTRAST,
	77	.type = V4L2_CTRL_TYPE_INTEGER,
	78	.name = "Contrast",
	79	.minimum = 0,
	80	.maximum = 255,
	81	.step = 1,
016f2362	82	.default_value = 127,
63eb9546	83	},
016f2362	84	.set_control = setcontrast
63eb9546	85	},
016f2362	86	[COLORS] = {
63eb9546 JFM	87	{
	88	.id = V4L2_CID_SATURATION,
	89	.type = V4L2_CTRL_TYPE_INTEGER,
a5ae2062	90	.name = "Color",
63eb9546 JFM	91	.minimum = 0,
	92	.maximum = 255,
	93	.step = 1,
016f2362	94	.default_value = 127,
63eb9546	95	},
016f2362	96	.set_control = setcolors
63eb9546	97	},
016f2362	98	[LIGHTFREQ] = {
6a7eba24 JFM	99	{
	100	.id = V4L2_CID_POWER_LINE_FREQUENCY,
	101	.type = V4L2_CTRL_TYPE_MENU,
	102	.name = "Light frequency filter",
	103	.minimum = 1,
	104	.maximum = 2, /* 0: 0, 1: 50Hz, 2:60Hz */
	105	.step = 1,
016f2362	106	.default_value = 1,
6a7eba24	107	},
016f2362	108	.set_control = setlightfreq
6a7eba24	109	},
63eb9546 JFM	110	};
63eb9546 JFM	111
cc611b8a	112	static const struct v4l2_pix_format vga_mode[] = {
c2446b3e JFM	113	{320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
	114	.bytesperline = 320,
	115	.sizeimage = 320 * 240 * 3 / 8 + 590,
	116	.colorspace = V4L2_COLORSPACE_JPEG,
	117	.priv = 1},
	118	{640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
	119	.bytesperline = 640,
	120	.sizeimage = 640 * 480 * 3 / 8 + 590,
	121	.colorspace = V4L2_COLORSPACE_JPEG,
	122	.priv = 0},
63eb9546 JFM	123	};
	124
	125	/* -- read a register -- */
ecb77686	126	static u8 reg_r(struct gspca_dev *gspca_dev,
739570bb	127	__u16 index)
63eb9546	128	{
63eb9546	129	struct usb_device *dev = gspca_dev->dev;
6a7eba24	130	int ret;
63eb9546	131
ecb77686 JFM	132	if (gspca_dev->usb_err < 0)
ecb77686 JFM	133	return 0;
63eb9546 JFM	134	ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
	135	0x00,
	136	USB_DIR_IN \| USB_TYPE_VENDOR \| USB_RECIP_DEVICE,
	137	0x00,
	138	index,
739570bb	139	gspca_dev->usb_buf, 1,
63eb9546	140	500);
739570bb	141	if (ret < 0) {
133a9fe9	142	pr_err("reg_r err %d\n", ret);
ecb77686 JFM	143	gspca_dev->usb_err = ret;
ecb77686 JFM	144	return 0;
739570bb JFM	145	}
739570bb JFM	146	return gspca_dev->usb_buf[0];
63eb9546 JFM	147	}
	148
	149	/* -- write a register -- */
ecb77686	150	static void reg_w(struct gspca_dev *gspca_dev,
63eb9546 JFM	151	__u16 index, __u16 value)
	152	{
	153	struct usb_device *dev = gspca_dev->dev;
	154	int ret;
	155
ecb77686 JFM	156	if (gspca_dev->usb_err < 0)
ecb77686 JFM	157	return;
63eb9546 JFM	158	ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
	159	0x01,
	160	USB_DIR_OUT \| USB_TYPE_VENDOR \| USB_RECIP_DEVICE,
	161	value,
	162	index,
	163	NULL,
	164	0,
	165	500);
ecb77686	166	if (ret < 0) {
133a9fe9	167	pr_err("reg_w err %d\n", ret);
ecb77686 JFM	168	gspca_dev->usb_err = ret;
ecb77686 JFM	169	}
63eb9546 JFM	170	}
63eb9546 JFM	171
739570bb	172	/* -- get a bulk value (4 bytes) -- */
ecb77686	173	static void rcv_val(struct gspca_dev *gspca_dev,
739570bb	174	int ads)
63eb9546 JFM	175	{
	176	struct usb_device *dev = gspca_dev->dev;
	177	int alen, ret;
63eb9546	178
6a7eba24 JFM	179	reg_w(gspca_dev, 0x634, (ads >> 16) & 0xff);
	180	reg_w(gspca_dev, 0x635, (ads >> 8) & 0xff);
	181	reg_w(gspca_dev, 0x636, ads & 0xff);
	182	reg_w(gspca_dev, 0x637, 0);
739570bb JFM	183	reg_w(gspca_dev, 0x638, 4); /* len & 0xff */
739570bb JFM	184	reg_w(gspca_dev, 0x639, 0); /* len >> 8 */
6a7eba24 JFM	185	reg_w(gspca_dev, 0x63a, 0);
	186	reg_w(gspca_dev, 0x63b, 0);
	187	reg_w(gspca_dev, 0x630, 5);
ecb77686 JFM	188	if (gspca_dev->usb_err < 0)
ecb77686 JFM	189	return;
63eb9546	190	ret = usb_bulk_msg(dev,
50e06dee	191	usb_rcvbulkpipe(dev, 0x05),
739570bb JFM	192	gspca_dev->usb_buf,
739570bb JFM	193	4, /* length */
63eb9546	194	&alen,
739570bb	195	500); /* timeout in milliseconds */
ecb77686	196	if (ret < 0) {
133a9fe9	197	pr_err("rcv_val err %d\n", ret);
ecb77686 JFM	198	gspca_dev->usb_err = ret;
ecb77686 JFM	199	}
63eb9546 JFM	200	}
63eb9546 JFM	201
739570bb	202	/* -- send a bulk value -- */
ecb77686	203	static void snd_val(struct gspca_dev *gspca_dev,
63eb9546 JFM	204	int ads,
	205	unsigned int val)
	206	{
	207	struct usb_device *dev = gspca_dev->dev;
	208	int alen, ret;
739570bb	209	__u8 seq = 0;
63eb9546 JFM	210
63eb9546 JFM	211	if (ads == 0x003f08) {
ecb77686 JFM	212	reg_r(gspca_dev, 0x0704);
	213	seq = reg_r(gspca_dev, 0x0705);
	214	reg_r(gspca_dev, 0x0650);
6a7eba24	215	reg_w(gspca_dev, 0x654, seq);
739570bb	216	} else {
6a7eba24	217	reg_w(gspca_dev, 0x654, (ads >> 16) & 0xff);
739570bb	218	}
6a7eba24 JFM	219	reg_w(gspca_dev, 0x655, (ads >> 8) & 0xff);
	220	reg_w(gspca_dev, 0x656, ads & 0xff);
	221	reg_w(gspca_dev, 0x657, 0);
	222	reg_w(gspca_dev, 0x658, 0x04); /* size */
	223	reg_w(gspca_dev, 0x659, 0);
	224	reg_w(gspca_dev, 0x65a, 0);
	225	reg_w(gspca_dev, 0x65b, 0);
	226	reg_w(gspca_dev, 0x650, 5);
ecb77686 JFM	227	if (gspca_dev->usb_err < 0)
ecb77686 JFM	228	return;
739570bb JFM	229	gspca_dev->usb_buf[0] = val >> 24;
	230	gspca_dev->usb_buf[1] = val >> 16;
	231	gspca_dev->usb_buf[2] = val >> 8;
	232	gspca_dev->usb_buf[3] = val;
63eb9546 JFM	233	ret = usb_bulk_msg(dev,
63eb9546 JFM	234	usb_sndbulkpipe(dev, 6),
739570bb	235	gspca_dev->usb_buf,
63eb9546 JFM	236	4,
	237	&alen,
	238	500); /* timeout in milliseconds */
ecb77686	239	if (ret < 0) {
133a9fe9	240	pr_err("snd_val err %d\n", ret);
ecb77686 JFM	241	gspca_dev->usb_err = ret;
	242	} else {
	243	if (ads == 0x003f08) {
	244	seq += 4;
	245	seq &= 0x3f;
	246	reg_w(gspca_dev, 0x705, seq);
	247	}
63eb9546	248	}
63eb9546 JFM	249	}
	250
	251	/* set a camera parameter */
ecb77686	252	static void set_par(struct gspca_dev *gspca_dev,
63eb9546 JFM	253	int parval)
63eb9546 JFM	254	{
ecb77686	255	snd_val(gspca_dev, 0x003f08, parval);
63eb9546 JFM	256	}
	257
	258	static void setbrightness(struct gspca_dev *gspca_dev)
	259	{
	260	struct sd sd = (struct sd ) gspca_dev;
	261	int parval;
	262
63eb9546	263	parval = 0x06000000 /* whiteness */
016f2362	264	+ (sd->ctrls[BRIGHTNESS].val << 16);
63eb9546 JFM	265	set_par(gspca_dev, parval);
	266	}
	267
	268	static void setcontrast(struct gspca_dev *gspca_dev)
	269	{
	270	struct sd sd = (struct sd ) gspca_dev;
	271	int parval;
	272
63eb9546	273	parval = 0x07000000 /* contrast */
016f2362	274	+ (sd->ctrls[CONTRAST].val << 16);
63eb9546 JFM	275	set_par(gspca_dev, parval);
	276	}
	277
	278	static void setcolors(struct gspca_dev *gspca_dev)
	279	{
	280	struct sd sd = (struct sd ) gspca_dev;
	281	int parval;
	282
63eb9546	283	parval = 0x08000000 /* saturation */
016f2362	284	+ (sd->ctrls[COLORS].val << 16);
63eb9546 JFM	285	set_par(gspca_dev, parval);
	286	}
	287
016f2362	288	static void setlightfreq(struct gspca_dev *gspca_dev)
6a7eba24 JFM	289	{
	290	struct sd sd = (struct sd ) gspca_dev;
	291
016f2362	292	set_par(gspca_dev, sd->ctrls[LIGHTFREQ].val == 1
6a7eba24 JFM	293	? 0x33640000 /* 50 Hz */
	294	: 0x33780000); /* 60 Hz */
	295	}
	296
63eb9546 JFM	297	/* this function is called at probe time */
	298	static int sd_config(struct gspca_dev *gspca_dev,
	299	const struct usb_device_id *id)
	300	{
	301	struct sd sd = (struct sd ) gspca_dev;
63eb9546	302
63eb9546	303	gspca_dev->cam.cam_mode = vga_mode;
739570bb	304	gspca_dev->cam.nmodes = ARRAY_SIZE(vga_mode);
016f2362	305	gspca_dev->cam.ctrls = sd->ctrls;
77ac0baf	306	sd->quality = QUALITY_DEF;
63eb9546 JFM	307	return 0;
	308	}
	309
012d6b02 JFM	310	/* this function is called at probe and resume time */
012d6b02 JFM	311	static int sd_init(struct gspca_dev *gspca_dev)
63eb9546	312	{
ecb77686	313	u8 ret;
63eb9546 JFM	314
	315	/* check if the device responds */
	316	usb_set_interface(gspca_dev->dev, gspca_dev->iface, 1);
739570bb	317	ret = reg_r(gspca_dev, 0x0740);
ecb77686 JFM	318	if (gspca_dev->usb_err >= 0) {
ecb77686 JFM	319	if (ret != 0xff) {
133a9fe9	320	pr_err("init reg: 0x%02x\n", ret);
ecb77686 JFM	321	gspca_dev->usb_err = -EIO;
ecb77686 JFM	322	}
63eb9546	323	}
ecb77686	324	return gspca_dev->usb_err;
63eb9546 JFM	325	}
	326
	327	/* -- start the camera -- */
72ab97ce	328	static int sd_start(struct gspca_dev *gspca_dev)
63eb9546	329	{
71cb2764	330	struct sd sd = (struct sd ) gspca_dev;
63eb9546 JFM	331	int ret, value;
63eb9546 JFM	332
71cb2764	333	/* create the JPEG header */
71cb2764 JFM	334	jpeg_define(sd->jpeg_hdr, gspca_dev->height, gspca_dev->width,
	335	0x22); /* JPEG 411 */
	336	jpeg_set_qual(sd->jpeg_hdr, sd->quality);
	337
63eb9546 JFM	338	/* work on alternate 1 */
	339	usb_set_interface(gspca_dev->dev, gspca_dev->iface, 1);
	340
	341	set_par(gspca_dev, 0x10000000);
	342	set_par(gspca_dev, 0x00000000);
	343	set_par(gspca_dev, 0x8002e001);
	344	set_par(gspca_dev, 0x14000000);
	345	if (gspca_dev->width > 320)
	346	value = 0x8002e001; /* 640x480 */
	347	else
	348	value = 0x4001f000; /* 320x240 */
	349	set_par(gspca_dev, value);
	350	ret = usb_set_interface(gspca_dev->dev,
	351	gspca_dev->iface,
	352	gspca_dev->alt);
6a7eba24	353	if (ret < 0) {
133a9fe9 JP	354	pr_err("set intf %d %d failed\n",
133a9fe9 JP	355	gspca_dev->iface, gspca_dev->alt);
ecb77686	356	gspca_dev->usb_err = ret;
63eb9546	357	goto out;
6a7eba24	358	}
ecb77686	359	reg_r(gspca_dev, 0x0630);
739570bb	360	rcv_val(gspca_dev, 0x000020); /* << (value ff ff ff ff) */
ecb77686	361	reg_r(gspca_dev, 0x0650);
63eb9546	362	snd_val(gspca_dev, 0x000020, 0xffffffff);
6a7eba24 JFM	363	reg_w(gspca_dev, 0x0620, 0);
	364	reg_w(gspca_dev, 0x0630, 0);
	365	reg_w(gspca_dev, 0x0640, 0);
	366	reg_w(gspca_dev, 0x0650, 0);
	367	reg_w(gspca_dev, 0x0660, 0);
63eb9546 JFM	368	setbrightness(gspca_dev); /* whiteness */
	369	setcontrast(gspca_dev); /* contrast */
	370	setcolors(gspca_dev); /* saturation */
	371	set_par(gspca_dev, 0x09800000); /* Red ? */
	372	set_par(gspca_dev, 0x0a800000); /* Green ? */
	373	set_par(gspca_dev, 0x0b800000); /* Blue ? */
	374	set_par(gspca_dev, 0x0d030000); /* Gamma ? */
016f2362	375	setlightfreq(gspca_dev);
63eb9546 JFM	376
	377	/* start the video flow */
	378	set_par(gspca_dev, 0x01000000);
	379	set_par(gspca_dev, 0x01000000);
ecb77686 JFM	380	if (gspca_dev->usb_err >= 0)
	381	PDEBUG(D_STREAM, "camera started alt: 0x%02x",
	382	gspca_dev->alt);
63eb9546	383	out:
ecb77686	384	return gspca_dev->usb_err;
63eb9546 JFM	385	}
	386
	387	static void sd_stopN(struct gspca_dev *gspca_dev)
	388	{
	389	struct usb_device *dev = gspca_dev->dev;
63eb9546 JFM	390
	391	set_par(gspca_dev, 0x02000000);
	392	set_par(gspca_dev, 0x02000000);
	393	usb_set_interface(dev, gspca_dev->iface, 1);
739570bb JFM	394	reg_r(gspca_dev, 0x0630);
	395	rcv_val(gspca_dev, 0x000020); /* << (value ff ff ff ff) */
	396	reg_r(gspca_dev, 0x0650);
63eb9546	397	snd_val(gspca_dev, 0x000020, 0xffffffff);
6a7eba24 JFM	398	reg_w(gspca_dev, 0x0620, 0);
	399	reg_w(gspca_dev, 0x0630, 0);
	400	reg_w(gspca_dev, 0x0640, 0);
	401	reg_w(gspca_dev, 0x0650, 0);
	402	reg_w(gspca_dev, 0x0660, 0);
63eb9546 JFM	403	PDEBUG(D_STREAM, "camera stopped");
	404	}
	405
63eb9546	406	static void sd_pkt_scan(struct gspca_dev *gspca_dev,
76dd272b	407	u8 data, / isoc packet */
63eb9546 JFM	408	int len) /* iso packet length */
63eb9546 JFM	409	{
71cb2764	410	struct sd sd = (struct sd ) gspca_dev;
4aa0d037	411	static unsigned char ffd9[] = {0xff, 0xd9};
63eb9546 JFM	412
	413	/* a frame starts with:
	414	* - 0xff 0xfe
d43fa32f JFM	415	* - 0x08 0x00 - length (little endian ?!)
d43fa32f JFM	416	* - 4 bytes = size of whole frame (BE - including header)
63eb9546 JFM	417	* - 0x00 0x0c
	418	* - 0xff 0xd8
	419	* - .. JPEG image with escape sequences (ff 00)
d43fa32f	420	* (without ending - ff d9)
63eb9546 JFM	421	*/
63eb9546 JFM	422	if (data[0] == 0xff && data[1] == 0xfe) {
76dd272b JFM	423	gspca_frame_add(gspca_dev, LAST_PACKET,
76dd272b JFM	424	ffd9, 2);
63eb9546	425
d43fa32f	426	/* put the JPEG 411 header */
76dd272b	427	gspca_frame_add(gspca_dev, FIRST_PACKET,
71cb2764	428	sd->jpeg_hdr, JPEG_HDR_SZ);
63eb9546 JFM	429
	430	/* beginning of the frame */
	431	#define STKHDRSZ 12
8843765e JFM	432	data += STKHDRSZ;
8843765e JFM	433	len -= STKHDRSZ;
63eb9546	434	}
76dd272b	435	gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
63eb9546 JFM	436	}
63eb9546 JFM	437
6a7eba24 JFM	438	static int sd_querymenu(struct gspca_dev *gspca_dev,
	439	struct v4l2_querymenu *menu)
	440	{
bff6069d JFM	441	static const char *freq_nm[3] = {"NoFliker", "50 Hz", "60 Hz"};
bff6069d JFM	442
6a7eba24 JFM	443	switch (menu->id) {
6a7eba24 JFM	444	case V4L2_CID_POWER_LINE_FREQUENCY:
bff6069d JFM	445	if ((unsigned) menu->index >= ARRAY_SIZE(freq_nm))
	446	break;
	447	strcpy((char *) menu->name, freq_nm[menu->index]);
	448	return 0;
6a7eba24 JFM	449	}
	450	return -EINVAL;
	451	}
	452
77ac0baf JFM	453	static int sd_set_jcomp(struct gspca_dev *gspca_dev,
	454	struct v4l2_jpegcompression *jcomp)
	455	{
	456	struct sd sd = (struct sd ) gspca_dev;
	457
	458	if (jcomp->quality < QUALITY_MIN)
	459	sd->quality = QUALITY_MIN;
	460	else if (jcomp->quality > QUALITY_MAX)
	461	sd->quality = QUALITY_MAX;
	462	else
	463	sd->quality = jcomp->quality;
	464	if (gspca_dev->streaming)
	465	jpeg_set_qual(sd->jpeg_hdr, sd->quality);
ecb77686	466	return gspca_dev->usb_err;
77ac0baf JFM	467	}
	468
	469	static int sd_get_jcomp(struct gspca_dev *gspca_dev,
	470	struct v4l2_jpegcompression *jcomp)
	471	{
	472	struct sd sd = (struct sd ) gspca_dev;
	473
	474	memset(jcomp, 0, sizeof *jcomp);
	475	jcomp->quality = sd->quality;
	476	jcomp->jpeg_markers = V4L2_JPEG_MARKER_DHT
	477	\| V4L2_JPEG_MARKER_DQT;
	478	return 0;
	479	}
	480
63eb9546	481	/* sub-driver description */
739570bb	482	static const struct sd_desc sd_desc = {
63eb9546 JFM	483	.name = MODULE_NAME,
63eb9546 JFM	484	.ctrls = sd_ctrls,
016f2362	485	.nctrls = NCTRLS,
63eb9546	486	.config = sd_config,
012d6b02	487	.init = sd_init,
63eb9546 JFM	488	.start = sd_start,
63eb9546 JFM	489	.stopN = sd_stopN,
63eb9546	490	.pkt_scan = sd_pkt_scan,
6a7eba24	491	.querymenu = sd_querymenu,
77ac0baf JFM	492	.get_jcomp = sd_get_jcomp,
77ac0baf JFM	493	.set_jcomp = sd_set_jcomp,
63eb9546 JFM	494	};
	495
	496	/* -- module initialisation -- */
95c967c1	497	static const struct usb_device_id device_table[] = {
9d64fdb1	498	{USB_DEVICE(0x05e1, 0x0893)},
63eb9546 JFM	499	{}
	500	};
	501	MODULE_DEVICE_TABLE(usb, device_table);
	502
	503	/* -- device connect -- */
	504	static int sd_probe(struct usb_interface *intf,
	505	const struct usb_device_id *id)
	506	{
d43fa32f JFM	507	return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
d43fa32f JFM	508	THIS_MODULE);
63eb9546 JFM	509	}
	510
	511	static struct usb_driver sd_driver = {
	512	.name = MODULE_NAME,
	513	.id_table = device_table,
	514	.probe = sd_probe,
	515	.disconnect = gspca_disconnect,
6a709749 JFM	516	#ifdef CONFIG_PM
	517	.suspend = gspca_suspend,
	518	.resume = gspca_resume,
	519	#endif
63eb9546 JFM	520	};
63eb9546 JFM	521
ecb3b2b3	522	module_usb_driver(sd_driver);