[mirror_ubuntu-artful-kernel.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 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) {
		err("reg_r err %d", 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) {
		err("reg_w err %d", 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) {
		err("rcv_val err %d", 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) {
		err("snd_val err %d", 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) {
			err("init reg: 0x%02x", 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) {
		err("set intf %d %d failed",
			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)
{
	switch (menu->id) {
	case V4L2_CID_POWER_LINE_FREQUENCY:
		switch (menu->index) {
		case 1:		/* V4L2_CID_POWER_LINE_FREQUENCY_50HZ */
			strcpy((char *) menu->name, "50 Hz");
			return 0;
		case 2:		/* V4L2_CID_POWER_LINE_FREQUENCY_60HZ */
			strcpy((char *) menu->name, "60 Hz");
			return 0;
		}
		break;
	}
	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 __devinitdata 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 insert / remove -- */
static int __init sd_mod_init(void)
{
	return usb_register(&sd_driver);
}
static void __exit sd_mod_exit(void)
{
	usb_deregister(&sd_driver);
}

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