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

/*
 *		Mars-Semi MR97311A library
 *		Copyright (C) 2005 <bradlch@hotmail.com>
 *
 * V4L2 by 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 "mars"

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

MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
MODULE_DESCRIPTION("GSPCA/Mars USB Camera Driver");
MODULE_LICENSE("GPL");

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

	u8 brightness;
	u8 colors;
	u8 gamma;
	u8 sharpness;
	u8 quality;
#define QUALITY_MIN 40
#define QUALITY_MAX 70
#define QUALITY_DEF 50

	u8 *jpeg_hdr;
};

/* V4L2 controls supported by the driver */
static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val);
static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val);
static int sd_setgamma(struct gspca_dev *gspca_dev, __s32 val);
static int sd_getgamma(struct gspca_dev *gspca_dev, __s32 *val);
static int sd_setsharpness(struct gspca_dev *gspca_dev, __s32 val);
static int sd_getsharpness(struct gspca_dev *gspca_dev, __s32 *val);

static struct ctrl sd_ctrls[] = {
	{
	    {
		.id      = V4L2_CID_BRIGHTNESS,
		.type    = V4L2_CTRL_TYPE_INTEGER,
		.name    = "Brightness",
		.minimum = 0,
		.maximum = 30,
		.step    = 1,
#define BRIGHTNESS_DEF 15
		.default_value = BRIGHTNESS_DEF,
	    },
	    .set = sd_setbrightness,
	    .get = sd_getbrightness,
	},
	{
	    {
		.id      = V4L2_CID_SATURATION,
		.type    = V4L2_CTRL_TYPE_INTEGER,
		.name    = "Color",
		.minimum = 1,
		.maximum = 255,
		.step    = 1,
#define COLOR_DEF 200
		.default_value = COLOR_DEF,
	    },
	    .set = sd_setcolors,
	    .get = sd_getcolors,
	},
	{
	    {
		.id      = V4L2_CID_GAMMA,
		.type    = V4L2_CTRL_TYPE_INTEGER,
		.name    = "Gamma",
		.minimum = 0,
		.maximum = 3,
		.step    = 1,
#define GAMMA_DEF 1
		.default_value = GAMMA_DEF,
	    },
	    .set = sd_setgamma,
	    .get = sd_getgamma,
	},
	{
	    {
		.id	 = V4L2_CID_SHARPNESS,
		.type    = V4L2_CTRL_TYPE_INTEGER,
		.name    = "Sharpness",
		.minimum = 0,
		.maximum = 2,
		.step    = 1,
#define SHARPNESS_DEF 1
		.default_value = SHARPNESS_DEF,
	    },
	    .set = sd_setsharpness,
	    .get = sd_getsharpness,
	},
};

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 = 2},
	{640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
		.bytesperline = 640,
		.sizeimage = 640 * 480 * 3 / 8 + 590,
		.colorspace = V4L2_COLORSPACE_JPEG,
		.priv = 1},
};

static const __u8 mi_data[0x20] = {
/*	 01    02   03     04    05    06    07    08 */
	0x48, 0x22, 0x01, 0x47, 0x10, 0x00, 0x00, 0x00,
/*	 09    0a   0b     0c    0d    0e    0f    10 */
	0x00, 0x01, 0x30, 0x01, 0x30, 0x01, 0x30, 0x01,
/*	 11    12   13     14    15    16    17    18 */
	0x30, 0x00, 0x04, 0x00, 0x06, 0x01, 0xe2, 0x02,
/*	 19    1a   1b     1c    1d    1e    1f    20 */
	0x82, 0x00, 0x20, 0x17, 0x80, 0x08, 0x0c, 0x00
};

/* write <len> bytes from gspca_dev->usb_buf */
static int reg_w(struct gspca_dev *gspca_dev,
		 int len)
{
	int alen, ret;

	ret = usb_bulk_msg(gspca_dev->dev,
			usb_sndbulkpipe(gspca_dev->dev, 4),
			gspca_dev->usb_buf,
			len,
			&alen,
			500);	/* timeout in milliseconds */
	if (ret < 0)
		PDEBUG(D_ERR, "reg write [%02x] error %d",
			gspca_dev->usb_buf[0], ret);
	return ret;
}

static void mi_w(struct gspca_dev *gspca_dev,
		 u8 addr,
		 u8 value)
{
	gspca_dev->usb_buf[0] = 0x1f;
	gspca_dev->usb_buf[1] = 0;			/* control byte */
	gspca_dev->usb_buf[2] = addr;
	gspca_dev->usb_buf[3] = value;

	reg_w(gspca_dev, 4);
}

/* this function is called at probe time */
static int sd_config(struct gspca_dev *gspca_dev,
			const struct usb_device_id *id)
{
	struct sd *sd = (struct sd *) gspca_dev;
	struct cam *cam;

	cam = &gspca_dev->cam;
	cam->cam_mode = vga_mode;
	cam->nmodes = ARRAY_SIZE(vga_mode);
	sd->brightness = BRIGHTNESS_DEF;
	sd->colors = COLOR_DEF;
	sd->gamma = GAMMA_DEF;
	sd->sharpness = SHARPNESS_DEF;
	sd->quality = QUALITY_DEF;
	gspca_dev->nbalt = 9;		/* use the altsetting 08 */
	return 0;
}

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

static int sd_start(struct gspca_dev *gspca_dev)
{
	struct sd *sd = (struct sd *) gspca_dev;
	int err_code;
	u8 *data;
	int i;

	/* create the JPEG header */
	sd->jpeg_hdr = kmalloc(JPEG_HDR_SZ, GFP_KERNEL);
	jpeg_define(sd->jpeg_hdr, gspca_dev->height, gspca_dev->width,
			0x21);		/* JPEG 422 */
	jpeg_set_qual(sd->jpeg_hdr, sd->quality);

	data = gspca_dev->usb_buf;

	data[0] = 0x01;		/* address */
	data[1] = 0x01;
	err_code = reg_w(gspca_dev, 2);
	if (err_code < 0)
		return err_code;

	/*
	   Initialize the MR97113 chip register
	 */
	data[0] = 0x00;		/* address */
	data[1] = 0x0c | 0x01;	/* reg 0 */
	data[2] = 0x01;		/* reg 1 */
	data[3] = gspca_dev->width / 8;		/* h_size , reg 2 */
	data[4] = gspca_dev->height / 8;	/* v_size , reg 3 */
	data[5] = 0x30;		/* reg 4, MI, PAS5101 :
				 *	0x30 for 24mhz , 0x28 for 12mhz */
	data[6] = 0x02;		/* reg 5, H start - was 0x04 */
	data[7] = sd->gamma * 0x40;	/* reg 0x06: gamma */
	data[8] = 0x01;		/* reg 7, V start - was 0x03 */
/*	if (h_size == 320 ) */
/*		data[9]= 0x56;	 * reg 8, 24MHz, 2:1 scale down */
/*	else */
	data[9] = 0x52;		/* reg 8, 24MHz, no scale down */
/*jfm: from win trace*/
	data[10] = 0x18;

	err_code = reg_w(gspca_dev, 11);
	if (err_code < 0)
		return err_code;

	data[0] = 0x23;		/* address */
	data[1] = 0x09;		/* reg 35, append frame header */

	err_code = reg_w(gspca_dev, 2);
	if (err_code < 0)
		return err_code;

	data[0] = 0x3c;		/* address */
/*	if (gspca_dev->width == 1280) */
/*		data[1] = 200;	 * reg 60, pc-cam frame size
				 *	(unit: 4KB) 800KB */
/*	else */
	data[1] = 50;		/* 50 reg 60, pc-cam frame size
				 *	(unit: 4KB) 200KB */
	err_code = reg_w(gspca_dev, 2);
	if (err_code < 0)
		return err_code;

	/* auto dark-gain */
	data[0] = 0x5e;		/* address */
	data[1] = 0;		/* reg 94, Y Gain (auto) */
/*jfm: from win trace*/
				/* reg 0x5f/0x60 (LE) = saturation */
				/* h (60): xxxx x100
				 * l (5f): xxxx x000 */
	data[2] = sd->colors << 3;
	data[3] = ((sd->colors >> 2) & 0xf8) | 0x04;
	data[4] = sd->brightness; /* reg 0x61 = brightness */
	data[5] = 0x00;

	err_code = reg_w(gspca_dev, 6);
	if (err_code < 0)
		return err_code;

	data[0] = 0x67;
/*jfm: from win trace*/
	data[1] = sd->sharpness * 4 + 3;
	data[2] = 0x14;
	err_code = reg_w(gspca_dev, 3);
	if (err_code < 0)
		return err_code;

	data[0] = 0x69;
	data[1] = 0x2f;
	data[2] = 0x28;
	data[3] = 0x42;
	err_code = reg_w(gspca_dev, 4);
	if (err_code < 0)
		return err_code;

	data[0] = 0x63;
	data[1] = 0x07;
	err_code = reg_w(gspca_dev, 2);
/*jfm: win trace - many writes here to reg 0x64*/
	if (err_code < 0)
		return err_code;

	/* initialize the MI sensor */
	for (i = 0; i < sizeof mi_data; i++)
		mi_w(gspca_dev, i + 1, mi_data[i]);

	data[0] = 0x00;
	data[1] = 0x4d;		/* ISOC transfering enable... */
	reg_w(gspca_dev, 2);
	return 0;
}

static void sd_stopN(struct gspca_dev *gspca_dev)
{
	int result;

	gspca_dev->usb_buf[0] = 1;
	gspca_dev->usb_buf[1] = 0;
	result = reg_w(gspca_dev, 2);
	if (result < 0)
		PDEBUG(D_ERR, "Camera Stop failed");
}

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

	kfree(sd->jpeg_hdr);
}

static void sd_pkt_scan(struct gspca_dev *gspca_dev,
			struct gspca_frame *frame,	/* target */
			__u8 *data,			/* isoc packet */
			int len)			/* iso packet length */
{
	struct sd *sd = (struct sd *) gspca_dev;
	int p;

	if (len < 6) {
/*		gspca_dev->last_packet_type = DISCARD_PACKET; */
		return;
	}
	for (p = 0; p < len - 6; p++) {
		if (data[0 + p] == 0xff
		    && data[1 + p] == 0xff
		    && data[2 + p] == 0x00
		    && data[3 + p] == 0xff
		    && data[4 + p] == 0x96) {
			if (data[5 + p] == 0x64
			    || data[5 + p] == 0x65
			    || data[5 + p] == 0x66
			    || data[5 + p] == 0x67) {
				PDEBUG(D_PACK, "sof offset: %d len: %d",
					p, len);
				frame = gspca_frame_add(gspca_dev, LAST_PACKET,
							frame, data, p);

				/* put the JPEG header */
				gspca_frame_add(gspca_dev, FIRST_PACKET, frame,
					sd->jpeg_hdr, JPEG_HDR_SZ);
				data += p + 16;
				len -= p + 16;
				break;
			}
		}
	}
	gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
}

static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
{
	struct sd *sd = (struct sd *) gspca_dev;

	sd->brightness = val;
	if (gspca_dev->streaming) {
		gspca_dev->usb_buf[0] = 0x61;
		gspca_dev->usb_buf[1] = val;
		reg_w(gspca_dev, 2);
	}
	return 0;
}

static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
{
	struct sd *sd = (struct sd *) gspca_dev;

	*val = sd->brightness;
	return 0;
}

static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val)
{
	struct sd *sd = (struct sd *) gspca_dev;

	sd->colors = val;
	if (gspca_dev->streaming) {

		/* see sd_start */
		gspca_dev->usb_buf[0] = 0x5f;
		gspca_dev->usb_buf[1] = sd->colors << 3;
		gspca_dev->usb_buf[2] = ((sd->colors >> 2) & 0xf8) | 0x04;
		reg_w(gspca_dev, 3);
	}
	return 0;
}

static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val)
{
	struct sd *sd = (struct sd *) gspca_dev;

	*val = sd->colors;
	return 0;
}

static int sd_setgamma(struct gspca_dev *gspca_dev, __s32 val)
{
	struct sd *sd = (struct sd *) gspca_dev;

	sd->gamma = val;
	if (gspca_dev->streaming) {
		gspca_dev->usb_buf[0] = 0x06;
		gspca_dev->usb_buf[1] = val * 0x40;
		reg_w(gspca_dev, 2);
	}
	return 0;
}

static int sd_getgamma(struct gspca_dev *gspca_dev, __s32 *val)
{
	struct sd *sd = (struct sd *) gspca_dev;

	*val = sd->gamma;
	return 0;
}

static int sd_setsharpness(struct gspca_dev *gspca_dev, __s32 val)
{
	struct sd *sd = (struct sd *) gspca_dev;

	sd->sharpness = val;
	if (gspca_dev->streaming) {
		gspca_dev->usb_buf[0] = 0x67;
		gspca_dev->usb_buf[1] = val * 4 + 3;
		reg_w(gspca_dev, 2);
	}
	return 0;
}

static int sd_getsharpness(struct gspca_dev *gspca_dev, __s32 *val)
{
	struct sd *sd = (struct sd *) gspca_dev;

	*val = sd->sharpness;
	return 0;
}

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

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 = ARRAY_SIZE(sd_ctrls),
	.config = sd_config,
	.init = sd_init,
	.start = sd_start,
	.stopN = sd_stopN,
	.stop0 = sd_stop0,
	.pkt_scan = sd_pkt_scan,
	.get_jcomp = sd_get_jcomp,
	.set_jcomp = sd_set_jcomp,
};

/* -- module initialisation -- */
static const __devinitdata struct usb_device_id device_table[] = {
	{USB_DEVICE(0x093a, 0x050f)},
	{}
};
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)
{
	int ret;

	ret = usb_register(&sd_driver);
	if (ret < 0)
		return ret;
	PDEBUG(D_PROBE, "registered");
	return 0;
}
static void __exit sd_mod_exit(void)
{
	usb_deregister(&sd_driver);
	PDEBUG(D_PROBE, "deregistered");
}

module_init(sd_mod_init);
module_exit(sd_mod_exit);
Commit	Line	Data
6a7eba24 JFM	1	/*
	2	* Mars-Semi MR97311A library
	3	* Copyright (C) 2005 <bradlch@hotmail.com>
	4	*
	5	* V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation; either version 2 of the License, or
	10	* any later version.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program; if not, write to the Free Software
	19	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	20	*/
	21
	22	#define MODULE_NAME "mars"
	23
	24	#include "gspca.h"
	25	#include "jpeg.h"
	26
6a7eba24 JFM	27	MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
	28	MODULE_DESCRIPTION("GSPCA/Mars USB Camera Driver");
	29	MODULE_LICENSE("GPL");
	30
	31	/* specific webcam descriptor */
	32	struct sd {
	33	struct gspca_dev gspca_dev; /* !! must be the first item */
a0306bfa JFM	34
	35	u8 brightness;
	36	u8 colors;
	37	u8 gamma;
	38	u8 sharpness;
71cb2764	39	u8 quality;
77ac0baf JFM	40	#define QUALITY_MIN 40
	41	#define QUALITY_MAX 70
	42	#define QUALITY_DEF 50
71cb2764 JFM	43
71cb2764 JFM	44	u8 *jpeg_hdr;
6a7eba24 JFM	45	};
	46
	47	/* V4L2 controls supported by the driver */
a0306bfa JFM	48	static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
	49	static int sd_getbrightness(struct gspca_dev gspca_dev, __s32 val);
	50	static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val);
	51	static int sd_getcolors(struct gspca_dev gspca_dev, __s32 val);
	52	static int sd_setgamma(struct gspca_dev *gspca_dev, __s32 val);
	53	static int sd_getgamma(struct gspca_dev gspca_dev, __s32 val);
	54	static int sd_setsharpness(struct gspca_dev *gspca_dev, __s32 val);
	55	static int sd_getsharpness(struct gspca_dev gspca_dev, __s32 val);
	56
6a7eba24	57	static struct ctrl sd_ctrls[] = {
a0306bfa JFM	58	{
	59	{
	60	.id = V4L2_CID_BRIGHTNESS,
	61	.type = V4L2_CTRL_TYPE_INTEGER,
	62	.name = "Brightness",
	63	.minimum = 0,
	64	.maximum = 30,
	65	.step = 1,
	66	#define BRIGHTNESS_DEF 15
	67	.default_value = BRIGHTNESS_DEF,
	68	},
	69	.set = sd_setbrightness,
	70	.get = sd_getbrightness,
	71	},
	72	{
	73	{
	74	.id = V4L2_CID_SATURATION,
	75	.type = V4L2_CTRL_TYPE_INTEGER,
	76	.name = "Color",
253bae57 JFM	77	.minimum = 1,
253bae57 JFM	78	.maximum = 255,
a0306bfa	79	.step = 1,
253bae57	80	#define COLOR_DEF 200
a0306bfa JFM	81	.default_value = COLOR_DEF,
	82	},
	83	.set = sd_setcolors,
	84	.get = sd_getcolors,
	85	},
	86	{
	87	{
	88	.id = V4L2_CID_GAMMA,
	89	.type = V4L2_CTRL_TYPE_INTEGER,
	90	.name = "Gamma",
	91	.minimum = 0,
	92	.maximum = 3,
	93	.step = 1,
	94	#define GAMMA_DEF 1
	95	.default_value = GAMMA_DEF,
	96	},
	97	.set = sd_setgamma,
	98	.get = sd_getgamma,
	99	},
	100	{
	101	{
	102	.id = V4L2_CID_SHARPNESS,
	103	.type = V4L2_CTRL_TYPE_INTEGER,
	104	.name = "Sharpness",
	105	.minimum = 0,
	106	.maximum = 2,
	107	.step = 1,
	108	#define SHARPNESS_DEF 1
	109	.default_value = SHARPNESS_DEF,
	110	},
	111	.set = sd_setsharpness,
	112	.get = sd_getsharpness,
	113	},
6a7eba24 JFM	114	};
6a7eba24 JFM	115
cc611b8a	116	static const struct v4l2_pix_format vga_mode[] = {
c2446b3e JFM	117	{320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
c2446b3e JFM	118	.bytesperline = 320,
a0306bfa	119	.sizeimage = 320 * 240 * 3 / 8 + 590,
c2446b3e JFM	120	.colorspace = V4L2_COLORSPACE_JPEG,
	121	.priv = 2},
	122	{640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
	123	.bytesperline = 640,
	124	.sizeimage = 640 * 480 * 3 / 8 + 590,
	125	.colorspace = V4L2_COLORSPACE_JPEG,
	126	.priv = 1},
6a7eba24 JFM	127	};
6a7eba24 JFM	128
a0306bfa JFM	129	static const __u8 mi_data[0x20] = {
	130	/* 01 02 03 04 05 06 07 08 */
	131	0x48, 0x22, 0x01, 0x47, 0x10, 0x00, 0x00, 0x00,
	132	/* 09 0a 0b 0c 0d 0e 0f 10 */
	133	0x00, 0x01, 0x30, 0x01, 0x30, 0x01, 0x30, 0x01,
	134	/* 11 12 13 14 15 16 17 18 */
	135	0x30, 0x00, 0x04, 0x00, 0x06, 0x01, 0xe2, 0x02,
	136	/* 19 1a 1b 1c 1d 1e 1f 20 */
	137	0x82, 0x00, 0x20, 0x17, 0x80, 0x08, 0x0c, 0x00
6a7eba24 JFM	138	};
6a7eba24 JFM	139
a0306bfa	140	/* write <len> bytes from gspca_dev->usb_buf */
739570bb	141	static int reg_w(struct gspca_dev *gspca_dev,
a0306bfa	142	int len)
6a7eba24	143	{
a0306bfa JFM	144	int alen, ret;
	145
	146	ret = usb_bulk_msg(gspca_dev->dev,
	147	usb_sndbulkpipe(gspca_dev->dev, 4),
	148	gspca_dev->usb_buf,
	149	len,
	150	&alen,
	151	500); /* timeout in milliseconds */
	152	if (ret < 0)
	153	PDEBUG(D_ERR, "reg write [%02x] error %d",
	154	gspca_dev->usb_buf[0], ret);
	155	return ret;
6a7eba24 JFM	156	}
6a7eba24 JFM	157
a0306bfa JFM	158	static void mi_w(struct gspca_dev *gspca_dev,
	159	u8 addr,
	160	u8 value)
739570bb JFM	161	{
	162	gspca_dev->usb_buf[0] = 0x1f;
	163	gspca_dev->usb_buf[1] = 0; /* control byte */
a0306bfa JFM	164	gspca_dev->usb_buf[2] = addr;
a0306bfa JFM	165	gspca_dev->usb_buf[3] = value;
6a7eba24	166
a0306bfa	167	reg_w(gspca_dev, 4);
6a7eba24 JFM	168	}
	169
	170	/* this function is called at probe time */
	171	static int sd_config(struct gspca_dev *gspca_dev,
	172	const struct usb_device_id *id)
	173	{
a0306bfa	174	struct sd sd = (struct sd ) gspca_dev;
6a7eba24 JFM	175	struct cam *cam;
	176
	177	cam = &gspca_dev->cam;
6a7eba24	178	cam->cam_mode = vga_mode;
80297125	179	cam->nmodes = ARRAY_SIZE(vga_mode);
a0306bfa JFM	180	sd->brightness = BRIGHTNESS_DEF;
	181	sd->colors = COLOR_DEF;
	182	sd->gamma = GAMMA_DEF;
	183	sd->sharpness = SHARPNESS_DEF;
77ac0baf	184	sd->quality = QUALITY_DEF;
625deb3d	185	gspca_dev->nbalt = 9; /* use the altsetting 08 */
6a7eba24 JFM	186	return 0;
	187	}
	188
012d6b02 JFM	189	/* this function is called at probe and resume time */
012d6b02 JFM	190	static int sd_init(struct gspca_dev *gspca_dev)
6a7eba24 JFM	191	{
	192	return 0;
	193	}
	194
72ab97ce	195	static int sd_start(struct gspca_dev *gspca_dev)
6a7eba24	196	{
a0306bfa	197	struct sd sd = (struct sd ) gspca_dev;
6a7eba24	198	int err_code;
a0306bfa	199	u8 *data;
253bae57	200	int i;
6a7eba24	201
71cb2764 JFM	202	/* create the JPEG header */
	203	sd->jpeg_hdr = kmalloc(JPEG_HDR_SZ, GFP_KERNEL);
	204	jpeg_define(sd->jpeg_hdr, gspca_dev->height, gspca_dev->width,
	205	0x21); /* JPEG 422 */
	206	jpeg_set_qual(sd->jpeg_hdr, sd->quality);
	207
739570bb	208	data = gspca_dev->usb_buf;
a0306bfa	209
6a7eba24 JFM	210	data[0] = 0x01; /* address */
6a7eba24 JFM	211	data[1] = 0x01;
a0306bfa	212	err_code = reg_w(gspca_dev, 2);
6a7eba24	213	if (err_code < 0)
72ab97ce	214	return err_code;
6a7eba24 JFM	215
	216	/*
	217	Initialize the MR97113 chip register
	218	*/
	219	data[0] = 0x00; /* address */
	220	data[1] = 0x0c \| 0x01; /* reg 0 */
	221	data[2] = 0x01; /* reg 1 */
a0306bfa JFM	222	data[3] = gspca_dev->width / 8; /* h_size , reg 2 */
a0306bfa JFM	223	data[4] = gspca_dev->height / 8; /* v_size , reg 3 */
6a7eba24 JFM	224	data[5] = 0x30; /* reg 4, MI, PAS5101 :
6a7eba24 JFM	225	* 0x30 for 24mhz , 0x28 for 12mhz */
a0306bfa JFM	226	data[6] = 0x02; /* reg 5, H start - was 0x04 */
	227	data[7] = sd->gamma * 0x40; /* reg 0x06: gamma */
	228	data[8] = 0x01; /* reg 7, V start - was 0x03 */
739570bb	229	/* if (h_size == 320 ) */
6a7eba24 JFM	230	/* data[9]= 0x56; * reg 8, 24MHz, 2:1 scale down */
	231	/* else */
	232	data[9] = 0x52; /* reg 8, 24MHz, no scale down */
a0306bfa JFM	233	/jfm: from win trace/
a0306bfa JFM	234	data[10] = 0x18;
6a7eba24	235
a0306bfa	236	err_code = reg_w(gspca_dev, 11);
6a7eba24	237	if (err_code < 0)
72ab97ce	238	return err_code;
6a7eba24 JFM	239
	240	data[0] = 0x23; /* address */
	241	data[1] = 0x09; /* reg 35, append frame header */
	242
a0306bfa	243	err_code = reg_w(gspca_dev, 2);
739570bb	244	if (err_code < 0)
72ab97ce	245	return err_code;
6a7eba24	246
739570bb JFM	247	data[0] = 0x3c; /* address */
739570bb JFM	248	/* if (gspca_dev->width == 1280) */
6a7eba24 JFM	249	/* data[1] = 200; * reg 60, pc-cam frame size
	250	* (unit: 4KB) 800KB */
	251	/* else */
	252	data[1] = 50; /* 50 reg 60, pc-cam frame size
	253	* (unit: 4KB) 200KB */
a0306bfa	254	err_code = reg_w(gspca_dev, 2);
6a7eba24	255	if (err_code < 0)
72ab97ce	256	return err_code;
6a7eba24	257
6a7eba24 JFM	258	/* auto dark-gain */
6a7eba24 JFM	259	data[0] = 0x5e; /* address */
a0306bfa JFM	260	data[1] = 0; /* reg 94, Y Gain (auto) */
a0306bfa JFM	261	/jfm: from win trace/
253bae57 JFM	262	/* reg 0x5f/0x60 (LE) = saturation */
	263	/* h (60): xxxx x100
	264	* l (5f): xxxx x000 */
	265	data[2] = sd->colors << 3;
	266	data[3] = ((sd->colors >> 2) & 0xf8) \| 0x04;
a0306bfa JFM	267	data[4] = sd->brightness; /* reg 0x61 = brightness */
	268	data[5] = 0x00;
	269
	270	err_code = reg_w(gspca_dev, 6);
6a7eba24	271	if (err_code < 0)
72ab97ce	272	return err_code;
6a7eba24 JFM	273
6a7eba24 JFM	274	data[0] = 0x67;
a0306bfa JFM	275	/jfm: from win trace/
	276	data[1] = sd->sharpness * 4 + 3;
	277	data[2] = 0x14;
	278	err_code = reg_w(gspca_dev, 3);
6a7eba24	279	if (err_code < 0)
72ab97ce	280	return err_code;
6a7eba24	281
a0306bfa JFM	282	data[0] = 0x69;
	283	data[1] = 0x2f;
	284	data[2] = 0x28;
	285	data[3] = 0x42;
	286	err_code = reg_w(gspca_dev, 4);
	287	if (err_code < 0)
	288	return err_code;
	289
	290	data[0] = 0x63;
	291	data[1] = 0x07;
	292	err_code = reg_w(gspca_dev, 2);
	293	/jfm: win trace - many writes here to reg 0x64/
	294	if (err_code < 0)
	295	return err_code;
	296
	297	/* initialize the MI sensor */
	298	for (i = 0; i < sizeof mi_data; i++)
	299	mi_w(gspca_dev, i + 1, mi_data[i]);
6a7eba24 JFM	300
	301	data[0] = 0x00;
	302	data[1] = 0x4d; /* ISOC transfering enable... */
a0306bfa JFM	303	reg_w(gspca_dev, 2);
a0306bfa JFM	304	return 0;
6a7eba24 JFM	305	}
	306
	307	static void sd_stopN(struct gspca_dev *gspca_dev)
	308	{
	309	int result;
6a7eba24	310
739570bb JFM	311	gspca_dev->usb_buf[0] = 1;
739570bb JFM	312	gspca_dev->usb_buf[1] = 0;
a0306bfa	313	result = reg_w(gspca_dev, 2);
6a7eba24 JFM	314	if (result < 0)
	315	PDEBUG(D_ERR, "Camera Stop failed");
	316	}
	317
71cb2764 JFM	318	static void sd_stop0(struct gspca_dev *gspca_dev)
	319	{
	320	struct sd sd = (struct sd ) gspca_dev;
	321
	322	kfree(sd->jpeg_hdr);
	323	}
	324
6a7eba24 JFM	325	static void sd_pkt_scan(struct gspca_dev *gspca_dev,
6a7eba24 JFM	326	struct gspca_frame frame, / target */
a5ae2062	327	__u8 data, / isoc packet */
6a7eba24 JFM	328	int len) /* iso packet length */
6a7eba24 JFM	329	{
71cb2764	330	struct sd sd = (struct sd ) gspca_dev;
6a7eba24 JFM	331	int p;
	332
	333	if (len < 6) {
	334	/* gspca_dev->last_packet_type = DISCARD_PACKET; */
	335	return;
	336	}
	337	for (p = 0; p < len - 6; p++) {
	338	if (data[0 + p] == 0xff
	339	&& data[1 + p] == 0xff
	340	&& data[2 + p] == 0x00
	341	&& data[3 + p] == 0xff
	342	&& data[4 + p] == 0x96) {
	343	if (data[5 + p] == 0x64
	344	\|\| data[5 + p] == 0x65
	345	\|\| data[5 + p] == 0x66
	346	\|\| data[5 + p] == 0x67) {
a0306bfa	347	PDEBUG(D_PACK, "sof offset: %d len: %d",
6a7eba24 JFM	348	p, len);
6a7eba24 JFM	349	frame = gspca_frame_add(gspca_dev, LAST_PACKET,
0a32ef3f	350	frame, data, p);
6a7eba24 JFM	351
6a7eba24 JFM	352	/* put the JPEG header */
71cb2764 JFM	353	gspca_frame_add(gspca_dev, FIRST_PACKET, frame,
71cb2764 JFM	354	sd->jpeg_hdr, JPEG_HDR_SZ);
0a32ef3f JFM	355	data += p + 16;
0a32ef3f JFM	356	len -= p + 16;
6a7eba24 JFM	357	break;
	358	}
	359	}
	360	}
	361	gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
	362	}
	363
a0306bfa JFM	364	static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
	365	{
	366	struct sd sd = (struct sd ) gspca_dev;
	367
	368	sd->brightness = val;
	369	if (gspca_dev->streaming) {
	370	gspca_dev->usb_buf[0] = 0x61;
	371	gspca_dev->usb_buf[1] = val;
	372	reg_w(gspca_dev, 2);
	373	}
	374	return 0;
	375	}
	376
	377	static int sd_getbrightness(struct gspca_dev gspca_dev, __s32 val)
	378	{
	379	struct sd sd = (struct sd ) gspca_dev;
	380
	381	*val = sd->brightness;
	382	return 0;
	383	}
	384
	385	static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val)
	386	{
	387	struct sd sd = (struct sd ) gspca_dev;
	388
	389	sd->colors = val;
	390	if (gspca_dev->streaming) {
253bae57 JFM	391
253bae57 JFM	392	/* see sd_start */
a0306bfa	393	gspca_dev->usb_buf[0] = 0x5f;
253bae57 JFM	394	gspca_dev->usb_buf[1] = sd->colors << 3;
253bae57 JFM	395	gspca_dev->usb_buf[2] = ((sd->colors >> 2) & 0xf8) \| 0x04;
a0306bfa JFM	396	reg_w(gspca_dev, 3);
	397	}
	398	return 0;
	399	}
	400
	401	static int sd_getcolors(struct gspca_dev gspca_dev, __s32 val)
	402	{
	403	struct sd sd = (struct sd ) gspca_dev;
	404
	405	*val = sd->colors;
	406	return 0;
	407	}
	408
	409	static int sd_setgamma(struct gspca_dev *gspca_dev, __s32 val)
	410	{
	411	struct sd sd = (struct sd ) gspca_dev;
	412
	413	sd->gamma = val;
	414	if (gspca_dev->streaming) {
	415	gspca_dev->usb_buf[0] = 0x06;
	416	gspca_dev->usb_buf[1] = val * 0x40;
	417	reg_w(gspca_dev, 2);
	418	}
	419	return 0;
	420	}
	421
	422	static int sd_getgamma(struct gspca_dev gspca_dev, __s32 val)
	423	{
	424	struct sd sd = (struct sd ) gspca_dev;
	425
	426	*val = sd->gamma;
	427	return 0;
	428	}
	429
	430	static int sd_setsharpness(struct gspca_dev *gspca_dev, __s32 val)
	431	{
	432	struct sd sd = (struct sd ) gspca_dev;
	433
	434	sd->sharpness = val;
	435	if (gspca_dev->streaming) {
	436	gspca_dev->usb_buf[0] = 0x67;
	437	gspca_dev->usb_buf[1] = val * 4 + 3;
	438	reg_w(gspca_dev, 2);
	439	}
	440	return 0;
	441	}
	442
	443	static int sd_getsharpness(struct gspca_dev gspca_dev, __s32 val)
	444	{
	445	struct sd sd = (struct sd ) gspca_dev;
	446
	447	*val = sd->sharpness;
	448	return 0;
	449	}
	450
77ac0baf JFM	451	static int sd_set_jcomp(struct gspca_dev *gspca_dev,
	452	struct v4l2_jpegcompression *jcomp)
	453	{
	454	struct sd sd = (struct sd ) gspca_dev;
	455
	456	if (jcomp->quality < QUALITY_MIN)
	457	sd->quality = QUALITY_MIN;
	458	else if (jcomp->quality > QUALITY_MAX)
	459	sd->quality = QUALITY_MAX;
	460	else
	461	sd->quality = jcomp->quality;
	462	if (gspca_dev->streaming)
	463	jpeg_set_qual(sd->jpeg_hdr, sd->quality);
	464	return 0;
	465	}
	466
	467	static int sd_get_jcomp(struct gspca_dev *gspca_dev,
	468	struct v4l2_jpegcompression *jcomp)
	469	{
	470	struct sd sd = (struct sd ) gspca_dev;
	471
	472	memset(jcomp, 0, sizeof *jcomp);
	473	jcomp->quality = sd->quality;
	474	jcomp->jpeg_markers = V4L2_JPEG_MARKER_DHT
	475	\| V4L2_JPEG_MARKER_DQT;
	476	return 0;
	477	}
	478
6a7eba24	479	/* sub-driver description */
a5ae2062	480	static const struct sd_desc sd_desc = {
6a7eba24 JFM	481	.name = MODULE_NAME,
	482	.ctrls = sd_ctrls,
	483	.nctrls = ARRAY_SIZE(sd_ctrls),
	484	.config = sd_config,
012d6b02	485	.init = sd_init,
6a7eba24 JFM	486	.start = sd_start,
6a7eba24 JFM	487	.stopN = sd_stopN,
71cb2764	488	.stop0 = sd_stop0,
6a7eba24	489	.pkt_scan = sd_pkt_scan,
77ac0baf JFM	490	.get_jcomp = sd_get_jcomp,
77ac0baf JFM	491	.set_jcomp = sd_set_jcomp,
6a7eba24 JFM	492	};
	493
	494	/* -- module initialisation -- */
a5ae2062	495	static const __devinitdata struct usb_device_id device_table[] = {
9d64fdb1	496	{USB_DEVICE(0x093a, 0x050f)},
6a7eba24 JFM	497	{}
	498	};
	499	MODULE_DEVICE_TABLE(usb, device_table);
	500
	501	/* -- device connect -- */
	502	static int sd_probe(struct usb_interface *intf,
	503	const struct usb_device_id *id)
	504	{
	505	return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
	506	THIS_MODULE);
	507	}
	508
	509	static struct usb_driver sd_driver = {
	510	.name = MODULE_NAME,
	511	.id_table = device_table,
	512	.probe = sd_probe,
	513	.disconnect = gspca_disconnect,
6a709749 JFM	514	#ifdef CONFIG_PM
	515	.suspend = gspca_suspend,
	516	.resume = gspca_resume,
	517	#endif
6a7eba24 JFM	518	};
	519
	520	/* -- module insert / remove -- */
	521	static int __init sd_mod_init(void)
	522	{
f69e9529	523	int ret;
a0306bfa	524
f69e9529 AK	525	ret = usb_register(&sd_driver);
f69e9529 AK	526	if (ret < 0)
e6b14849	527	return ret;
10b0e96e	528	PDEBUG(D_PROBE, "registered");
6a7eba24 JFM	529	return 0;
	530	}
	531	static void __exit sd_mod_exit(void)
	532	{
	533	usb_deregister(&sd_driver);
	534	PDEBUG(D_PROBE, "deregistered");
	535	}
	536
	537	module_init(sd_mod_init);
	538	module_exit(sd_mod_exit);