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

	char qindex;
};

/* V4L2 controls supported by the driver */
static struct ctrl sd_ctrls[] = {
};

static struct v4l2_pix_format vga_mode[] = {
	{320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
		.bytesperline = 320,
		.sizeimage = 320 * 240 * 3 / 8 + 589,
		.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},
};

/* MI Register table //elvis */
enum {
	REG_HW_MI_0,
	REG_HW_MI_1,
	REG_HW_MI_2,
	REG_HW_MI_3,
	REG_HW_MI_4,
	REG_HW_MI_5,
	REG_HW_MI_6,
	REG_HW_MI_7,
	REG_HW_MI_9 = 0x09,
	REG_HW_MI_B = 0x0B,
	REG_HW_MI_C,
	REG_HW_MI_D,
	REG_HW_MI_1E = 0x1E,
	REG_HW_MI_20 = 0x20,
	REG_HW_MI_2B = 0x2B,
	REG_HW_MI_2C,
	REG_HW_MI_2D,
	REG_HW_MI_2E,
	REG_HW_MI_35 = 0x35,
	REG_HW_MI_5F = 0x5f,
	REG_HW_MI_60,
	REG_HW_MI_61,
	REG_HW_MI_62,
	REG_HW_MI_63,
	REG_HW_MI_64,
	REG_HW_MI_F1 = 0xf1,
	ATTR_TOTAL_MI_REG = 0xf2
};

/* the bytes to write are in gspca_dev->usb_buf */
static int reg_w(struct gspca_dev *gspca_dev,
		 __u16 index, int len)
{
	int rc;

	rc = usb_control_msg(gspca_dev->dev,
			 usb_sndbulkpipe(gspca_dev->dev, 4),
			 0x12,
			 0xc8,		/* ?? */
			 0,		/* value */
			 index, gspca_dev->usb_buf, len, 500);
	if (rc < 0)
		PDEBUG(D_ERR, "reg write [%02x] error %d", index, rc);
	return rc;
}

static void bulk_w(struct gspca_dev *gspca_dev,
		   __u16 *pch,
		   __u16 Address)
{
	gspca_dev->usb_buf[0] = 0x1f;
	gspca_dev->usb_buf[1] = 0;			/* control byte */
	gspca_dev->usb_buf[2] = Address;
	gspca_dev->usb_buf[3] = *pch >> 8;		/* high byte */
	gspca_dev->usb_buf[4] = *pch;			/* low byte */

	reg_w(gspca_dev, Address, 5);
}

/* 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->epaddr = 0x01;
	cam->cam_mode = vga_mode;
	cam->nmodes = sizeof vga_mode / sizeof vga_mode[0];
	sd->qindex = 1;			/* set the quantization table */
	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)
{
	int err_code;
	__u8 *data;
	__u16 *MI_buf;
	int h_size, v_size;
	int intpipe;

	PDEBUG(D_STREAM, "camera start, iface %d, alt 8", gspca_dev->iface);
	err_code = usb_set_interface(gspca_dev->dev, gspca_dev->iface, 8);
	if (err_code < 0) {
		PDEBUG(D_ERR|D_STREAM, "Set packet size: set interface error");
		return err_code;
	}

	data = gspca_dev->usb_buf;
	data[0] = 0x01;		/* address */
	data[1] = 0x01;

	err_code = reg_w(gspca_dev, data[0], 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 */
	h_size = gspca_dev->width;
	v_size = gspca_dev->height;
	data[3] = h_size / 8;	/* h_size , reg 2 */
	data[4] = v_size / 8;	/* v_size , reg 3 */
	data[5] = 0x30;		/* reg 4, MI, PAS5101 :
				 *	0x30 for 24mhz , 0x28 for 12mhz */
	data[6] = 4;		/* reg 5, H start */
	data[7] = 0xc0;		/* reg 6, gamma 1.5 */
	data[8] = 3;		/* reg 7, V start */
/*	if (h_size == 320 ) */
/*		data[9]= 0x56;	 * reg 8, 24MHz, 2:1 scale down */
/*	else */
	data[9] = 0x52;		/* reg 8, 24MHz, no scale down */
	data[10] = 0x5d;	/* reg 9, I2C device address
				 *	[for PAS5101 (0x40)] [for MI (0x5d)] */

	err_code = reg_w(gspca_dev, data[0], 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, data[0], 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, data[0], 2);
	if (err_code < 0)
		return err_code;

	if (0) {			/* fixed dark-gain */
		data[1] = 0;		/* reg 94, Y Gain (1.75) */
		data[2] = 0;		/* reg 95, UV Gain (1.75) */
		data[3] = 0x3f;		/* reg 96, Y Gain/UV Gain/disable
					 *	auto dark-gain */
		data[4] = 0;		/* reg 97, set fixed dark level */
		data[5] = 0;		/* reg 98, don't care */
	} else {			/* auto dark-gain */
		data[1] = 0;		/* reg 94, Y Gain (auto) */
		data[2] = 0;		/* reg 95, UV Gain (1.75) */
		data[3] = 0x78;		/* reg 96, Y Gain/UV Gain/disable
					 *	auto dark-gain */
		switch (gspca_dev->width) {
/*		case 1280: */
/*			data[4] = 154;
				 * reg 97, %3 shadow point (unit: 256 pixel) */
/*			data[5] = 51;
				 * reg 98, %1 highlight point
				 *	(uint: 256 pixel) */
/*			break; */
		default:
/*		case 640: */
			data[4] = 36;	/* reg 97, %3 shadow point
					 *	(unit: 256 pixel) */
			data[5] = 12;	/* reg 98, %1 highlight point
					 *	(uint: 256 pixel) */
			break;
		case 320:
			data[4] = 9;	/* reg 97, %3 shadow point
					 *	(unit: 256 pixel) */
			data[5] = 3;	/* reg 98, %1 highlight point
					 *	(uint: 256 pixel) */
			break;
		}
	}
	/* auto dark-gain */
	data[0] = 0x5e;		/* address */

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

	data[0] = 0x67;
	data[1] = 0x13;		/* reg 103, first pixel B, disable sharpness */
	err_code = reg_w(gspca_dev, data[0], 2);
	if (err_code < 0)
		return err_code;

	/*
	 * initialize the value of MI sensor...
	 */
	MI_buf = kzalloc(ATTR_TOTAL_MI_REG * sizeof *MI_buf, GFP_KERNEL);
	MI_buf[REG_HW_MI_1] = 0x000a;
	MI_buf[REG_HW_MI_2] = 0x000c;
	MI_buf[REG_HW_MI_3] = 0x0405;
	MI_buf[REG_HW_MI_4] = 0x0507;
	/* mi_Attr_Reg_[REG_HW_MI_5]	 = 0x01ff;//13 */
	MI_buf[REG_HW_MI_5] = 0x0013;	/* 13 */
	MI_buf[REG_HW_MI_6] = 0x001f;	/* vertical blanking */
	/* mi_Attr_Reg_[REG_HW_MI_6]	 = 0x0400;  // vertical blanking */
	MI_buf[REG_HW_MI_7] = 0x0002;
	/* mi_Attr_Reg_[REG_HW_MI_9]	 = 0x015f; */
	/* mi_Attr_Reg_[REG_HW_MI_9]	 = 0x030f; */
	MI_buf[REG_HW_MI_9] = 0x0374;
	MI_buf[REG_HW_MI_B] = 0x0000;
	MI_buf[REG_HW_MI_C] = 0x0000;
	MI_buf[REG_HW_MI_D] = 0x0000;
	MI_buf[REG_HW_MI_1E] = 0x8000;
/* mi_Attr_Reg_[REG_HW_MI_20]	  = 0x1104; */
	MI_buf[REG_HW_MI_20] = 0x1104;	/* 0x111c; */
	MI_buf[REG_HW_MI_2B] = 0x0008;
/* mi_Attr_Reg_[REG_HW_MI_2C]	  = 0x000f; */
	MI_buf[REG_HW_MI_2C] = 0x001f;	/* lita suggest */
	MI_buf[REG_HW_MI_2D] = 0x0008;
	MI_buf[REG_HW_MI_2E] = 0x0008;
	MI_buf[REG_HW_MI_35] = 0x0051;
	MI_buf[REG_HW_MI_5F] = 0x0904;	/* fail to write */
	MI_buf[REG_HW_MI_60] = 0x0000;
	MI_buf[REG_HW_MI_61] = 0x0000;
	MI_buf[REG_HW_MI_62] = 0x0498;
	MI_buf[REG_HW_MI_63] = 0x0000;
	MI_buf[REG_HW_MI_64] = 0x0000;
	MI_buf[REG_HW_MI_F1] = 0x0001;
	/* changing while setting up the different value of dx/dy */

	if (gspca_dev->width != 1280) {
		MI_buf[0x01] = 0x010a;
		MI_buf[0x02] = 0x014c;
		MI_buf[0x03] = 0x01e5;
		MI_buf[0x04] = 0x0287;
	}
	MI_buf[0x20] = 0x1104;

	bulk_w(gspca_dev, MI_buf + 1, 1);
	bulk_w(gspca_dev, MI_buf + 2, 2);
	bulk_w(gspca_dev, MI_buf + 3, 3);
	bulk_w(gspca_dev, MI_buf + 4, 4);
	bulk_w(gspca_dev, MI_buf + 5, 5);
	bulk_w(gspca_dev, MI_buf + 6, 6);
	bulk_w(gspca_dev, MI_buf + 7, 7);
	bulk_w(gspca_dev, MI_buf + 9, 9);
	bulk_w(gspca_dev, MI_buf + 0x0b, 0x0b);
	bulk_w(gspca_dev, MI_buf + 0x0c, 0x0c);
	bulk_w(gspca_dev, MI_buf + 0x0d, 0x0d);
	bulk_w(gspca_dev, MI_buf + 0x1e, 0x1e);
	bulk_w(gspca_dev, MI_buf + 0x20, 0x20);
	bulk_w(gspca_dev, MI_buf + 0x2b, 0x2b);
	bulk_w(gspca_dev, MI_buf + 0x2c, 0x2c);
	bulk_w(gspca_dev, MI_buf + 0x2d, 0x2d);
	bulk_w(gspca_dev, MI_buf + 0x2e, 0x2e);
	bulk_w(gspca_dev, MI_buf + 0x35, 0x35);
	bulk_w(gspca_dev, MI_buf + 0x5f, 0x5f);
	bulk_w(gspca_dev, MI_buf + 0x60, 0x60);
	bulk_w(gspca_dev, MI_buf + 0x61, 0x61);
	bulk_w(gspca_dev, MI_buf + 0x62, 0x62);
	bulk_w(gspca_dev, MI_buf + 0x63, 0x63);
	bulk_w(gspca_dev, MI_buf + 0x64, 0x64);
	bulk_w(gspca_dev, MI_buf + 0xf1, 0xf1);
	kfree(MI_buf);

	intpipe = usb_sndintpipe(gspca_dev->dev, 0);
	err_code = usb_clear_halt(gspca_dev->dev, intpipe);

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

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, gspca_dev->usb_buf[0], 2);
	if (result < 0)
		PDEBUG(D_ERR, "Camera Stop failed");
}

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 leng: %d",
					p, len);
				frame = gspca_frame_add(gspca_dev, LAST_PACKET,
							frame, data, 0);

				/* put the JPEG header */
				jpeg_put_header(gspca_dev, frame,
						sd->qindex, 0x21);
				data += 16;
				len -= 16;
				break;
			}
		}
	}
	gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
}

/* 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,
	.pkt_scan = sd_pkt_scan,
};

/* -- 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)
{
	if (usb_register(&sd_driver) < 0)
		return -1;
	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 */
	34
	35	char qindex;
	36	};
	37
	38	/* V4L2 controls supported by the driver */
	39	static struct ctrl sd_ctrls[] = {
	40	};
	41
c2446b3e JFM	42	static struct v4l2_pix_format vga_mode[] = {
	43	{320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
	44	.bytesperline = 320,
	45	.sizeimage = 320 * 240 * 3 / 8 + 589,
	46	.colorspace = V4L2_COLORSPACE_JPEG,
	47	.priv = 2},
	48	{640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
	49	.bytesperline = 640,
	50	.sizeimage = 640 * 480 * 3 / 8 + 590,
	51	.colorspace = V4L2_COLORSPACE_JPEG,
	52	.priv = 1},
6a7eba24 JFM	53	};
	54
	55	/* MI Register table //elvis */
	56	enum {
	57	REG_HW_MI_0,
	58	REG_HW_MI_1,
	59	REG_HW_MI_2,
	60	REG_HW_MI_3,
	61	REG_HW_MI_4,
	62	REG_HW_MI_5,
	63	REG_HW_MI_6,
	64	REG_HW_MI_7,
	65	REG_HW_MI_9 = 0x09,
	66	REG_HW_MI_B = 0x0B,
	67	REG_HW_MI_C,
	68	REG_HW_MI_D,
	69	REG_HW_MI_1E = 0x1E,
	70	REG_HW_MI_20 = 0x20,
	71	REG_HW_MI_2B = 0x2B,
	72	REG_HW_MI_2C,
	73	REG_HW_MI_2D,
	74	REG_HW_MI_2E,
	75	REG_HW_MI_35 = 0x35,
	76	REG_HW_MI_5F = 0x5f,
	77	REG_HW_MI_60,
	78	REG_HW_MI_61,
	79	REG_HW_MI_62,
	80	REG_HW_MI_63,
	81	REG_HW_MI_64,
	82	REG_HW_MI_F1 = 0xf1,
739570bb	83	ATTR_TOTAL_MI_REG = 0xf2
6a7eba24 JFM	84	};
6a7eba24 JFM	85
739570bb JFM	86	/* the bytes to write are in gspca_dev->usb_buf */
	87	static int reg_w(struct gspca_dev *gspca_dev,
	88	__u16 index, int len)
6a7eba24 JFM	89	{
	90	int rc;
	91
739570bb JFM	92	rc = usb_control_msg(gspca_dev->dev,
739570bb JFM	93	usb_sndbulkpipe(gspca_dev->dev, 4),
6a7eba24	94	0x12,
739570bb	95	0xc8, /* ?? */
6a7eba24	96	0, /* value */
739570bb	97	index, gspca_dev->usb_buf, len, 500);
6a7eba24	98	if (rc < 0)
bf7f0b98	99	PDEBUG(D_ERR, "reg write [%02x] error %d", index, rc);
6a7eba24 JFM	100	return rc;
	101	}
	102
739570bb JFM	103	static void bulk_w(struct gspca_dev *gspca_dev,
	104	__u16 *pch,
	105	__u16 Address)
	106	{
	107	gspca_dev->usb_buf[0] = 0x1f;
	108	gspca_dev->usb_buf[1] = 0; /* control byte */
	109	gspca_dev->usb_buf[2] = Address;
	110	gspca_dev->usb_buf[3] = pch >> 8; / high byte */
	111	gspca_dev->usb_buf[4] = pch; / low byte */
6a7eba24	112
739570bb	113	reg_w(gspca_dev, Address, 5);
6a7eba24 JFM	114	}
	115
	116	/* this function is called at probe time */
	117	static int sd_config(struct gspca_dev *gspca_dev,
	118	const struct usb_device_id *id)
	119	{
	120	struct sd sd = (struct sd ) gspca_dev;
	121	struct cam *cam;
	122
	123	cam = &gspca_dev->cam;
6a7eba24 JFM	124	cam->epaddr = 0x01;
	125	cam->cam_mode = vga_mode;
	126	cam->nmodes = sizeof vga_mode / sizeof vga_mode[0];
	127	sd->qindex = 1; /* set the quantization table */
	128	return 0;
	129	}
	130
012d6b02 JFM	131	/* this function is called at probe and resume time */
012d6b02 JFM	132	static int sd_init(struct gspca_dev *gspca_dev)
6a7eba24 JFM	133	{
	134	return 0;
	135	}
	136
72ab97ce	137	static int sd_start(struct gspca_dev *gspca_dev)
6a7eba24	138	{
6a7eba24	139	int err_code;
739570bb JFM	140	__u8 *data;
739570bb JFM	141	__u16 *MI_buf;
6a7eba24 JFM	142	int h_size, v_size;
6a7eba24 JFM	143	int intpipe;
6a7eba24 JFM	144
6a7eba24 JFM	145	PDEBUG(D_STREAM, "camera start, iface %d, alt 8", gspca_dev->iface);
72ab97ce JFM	146	err_code = usb_set_interface(gspca_dev->dev, gspca_dev->iface, 8);
72ab97ce JFM	147	if (err_code < 0) {
6a7eba24	148	PDEBUG(D_ERR\|D_STREAM, "Set packet size: set interface error");
72ab97ce	149	return err_code;
6a7eba24 JFM	150	}
6a7eba24 JFM	151
739570bb	152	data = gspca_dev->usb_buf;
6a7eba24 JFM	153	data[0] = 0x01; /* address */
	154	data[1] = 0x01;
	155
739570bb	156	err_code = reg_w(gspca_dev, data[0], 2);
6a7eba24	157	if (err_code < 0)
72ab97ce	158	return err_code;
6a7eba24 JFM	159
	160	/*
	161	Initialize the MR97113 chip register
	162	*/
	163	data[0] = 0x00; /* address */
	164	data[1] = 0x0c \| 0x01; /* reg 0 */
	165	data[2] = 0x01; /* reg 1 */
	166	h_size = gspca_dev->width;
	167	v_size = gspca_dev->height;
	168	data[3] = h_size / 8; /* h_size , reg 2 */
	169	data[4] = v_size / 8; /* v_size , reg 3 */
	170	data[5] = 0x30; /* reg 4, MI, PAS5101 :
	171	* 0x30 for 24mhz , 0x28 for 12mhz */
	172	data[6] = 4; /* reg 5, H start */
	173	data[7] = 0xc0; /* reg 6, gamma 1.5 */
	174	data[8] = 3; /* reg 7, V start */
739570bb	175	/* if (h_size == 320 ) */
6a7eba24 JFM	176	/* data[9]= 0x56; * reg 8, 24MHz, 2:1 scale down */
	177	/* else */
	178	data[9] = 0x52; /* reg 8, 24MHz, no scale down */
	179	data[10] = 0x5d; /* reg 9, I2C device address
	180	* [for PAS5101 (0x40)] [for MI (0x5d)] */
	181
8295d99e	182	err_code = reg_w(gspca_dev, data[0], 11);
6a7eba24	183	if (err_code < 0)
72ab97ce	184	return err_code;
6a7eba24 JFM	185
	186	data[0] = 0x23; /* address */
	187	data[1] = 0x09; /* reg 35, append frame header */
	188
739570bb JFM	189	err_code = reg_w(gspca_dev, data[0], 2);
739570bb JFM	190	if (err_code < 0)
72ab97ce	191	return err_code;
6a7eba24	192
739570bb JFM	193	data[0] = 0x3c; /* address */
739570bb JFM	194	/* if (gspca_dev->width == 1280) */
6a7eba24 JFM	195	/* data[1] = 200; * reg 60, pc-cam frame size
	196	* (unit: 4KB) 800KB */
	197	/* else */
	198	data[1] = 50; /* 50 reg 60, pc-cam frame size
	199	* (unit: 4KB) 200KB */
739570bb	200	err_code = reg_w(gspca_dev, data[0], 2);
6a7eba24	201	if (err_code < 0)
72ab97ce	202	return err_code;
6a7eba24 JFM	203
	204	if (0) { /* fixed dark-gain */
	205	data[1] = 0; /* reg 94, Y Gain (1.75) */
	206	data[2] = 0; /* reg 95, UV Gain (1.75) */
956e42d2 JFM	207	data[3] = 0x3f; /* reg 96, Y Gain/UV Gain/disable
956e42d2 JFM	208	* auto dark-gain */
6a7eba24 JFM	209	data[4] = 0; /* reg 97, set fixed dark level */
	210	data[5] = 0; /* reg 98, don't care */
	211	} else { /* auto dark-gain */
	212	data[1] = 0; /* reg 94, Y Gain (auto) */
	213	data[2] = 0; /* reg 95, UV Gain (1.75) */
956e42d2 JFM	214	data[3] = 0x78; /* reg 96, Y Gain/UV Gain/disable
956e42d2 JFM	215	* auto dark-gain */
6a7eba24 JFM	216	switch (gspca_dev->width) {
	217	/* case 1280: */
	218	/* data[4] = 154;
	219	* reg 97, %3 shadow point (unit: 256 pixel) */
	220	/* data[5] = 51;
	221	* reg 98, %1 highlight point
	222	* (uint: 256 pixel) */
	223	/* break; */
	224	default:
	225	/* case 640: */
	226	data[4] = 36; /* reg 97, %3 shadow point
	227	* (unit: 256 pixel) */
	228	data[5] = 12; /* reg 98, %1 highlight point
	229	* (uint: 256 pixel) */
	230	break;
	231	case 320:
	232	data[4] = 9; /* reg 97, %3 shadow point
	233	* (unit: 256 pixel) */
	234	data[5] = 3; /* reg 98, %1 highlight point
	235	* (uint: 256 pixel) */
	236	break;
	237	}
	238	}
	239	/* auto dark-gain */
	240	data[0] = 0x5e; /* address */
	241
739570bb	242	err_code = reg_w(gspca_dev, data[0], 6);
6a7eba24	243	if (err_code < 0)
72ab97ce	244	return err_code;
6a7eba24 JFM	245
	246	data[0] = 0x67;
	247	data[1] = 0x13; /* reg 103, first pixel B, disable sharpness */
739570bb	248	err_code = reg_w(gspca_dev, data[0], 2);
6a7eba24	249	if (err_code < 0)
72ab97ce	250	return err_code;
6a7eba24 JFM	251
	252	/*
	253	* initialize the value of MI sensor...
	254	*/
739570bb	255	MI_buf = kzalloc(ATTR_TOTAL_MI_REG * sizeof *MI_buf, GFP_KERNEL);
6a7eba24 JFM	256	MI_buf[REG_HW_MI_1] = 0x000a;
	257	MI_buf[REG_HW_MI_2] = 0x000c;
	258	MI_buf[REG_HW_MI_3] = 0x0405;
	259	MI_buf[REG_HW_MI_4] = 0x0507;
	260	/* mi_Attr_Reg_[REG_HW_MI_5] = 0x01ff;//13 */
	261	MI_buf[REG_HW_MI_5] = 0x0013; /* 13 */
	262	MI_buf[REG_HW_MI_6] = 0x001f; /* vertical blanking */
	263	/* mi_Attr_Reg_[REG_HW_MI_6] = 0x0400; // vertical blanking */
	264	MI_buf[REG_HW_MI_7] = 0x0002;
	265	/* mi_Attr_Reg_[REG_HW_MI_9] = 0x015f; */
	266	/* mi_Attr_Reg_[REG_HW_MI_9] = 0x030f; */
	267	MI_buf[REG_HW_MI_9] = 0x0374;
	268	MI_buf[REG_HW_MI_B] = 0x0000;
	269	MI_buf[REG_HW_MI_C] = 0x0000;
	270	MI_buf[REG_HW_MI_D] = 0x0000;
	271	MI_buf[REG_HW_MI_1E] = 0x8000;
	272	/* mi_Attr_Reg_[REG_HW_MI_20] = 0x1104; */
	273	MI_buf[REG_HW_MI_20] = 0x1104; /* 0x111c; */
	274	MI_buf[REG_HW_MI_2B] = 0x0008;
	275	/* mi_Attr_Reg_[REG_HW_MI_2C] = 0x000f; */
	276	MI_buf[REG_HW_MI_2C] = 0x001f; /* lita suggest */
	277	MI_buf[REG_HW_MI_2D] = 0x0008;
	278	MI_buf[REG_HW_MI_2E] = 0x0008;
	279	MI_buf[REG_HW_MI_35] = 0x0051;
	280	MI_buf[REG_HW_MI_5F] = 0x0904; /* fail to write */
	281	MI_buf[REG_HW_MI_60] = 0x0000;
	282	MI_buf[REG_HW_MI_61] = 0x0000;
	283	MI_buf[REG_HW_MI_62] = 0x0498;
	284	MI_buf[REG_HW_MI_63] = 0x0000;
	285	MI_buf[REG_HW_MI_64] = 0x0000;
	286	MI_buf[REG_HW_MI_F1] = 0x0001;
	287	/* changing while setting up the different value of dx/dy */
	288
	289	if (gspca_dev->width != 1280) {
	290	MI_buf[0x01] = 0x010a;
	291	MI_buf[0x02] = 0x014c;
	292	MI_buf[0x03] = 0x01e5;
	293	MI_buf[0x04] = 0x0287;
	294	}
	295	MI_buf[0x20] = 0x1104;
	296
739570bb JFM	297	bulk_w(gspca_dev, MI_buf + 1, 1);
	298	bulk_w(gspca_dev, MI_buf + 2, 2);
	299	bulk_w(gspca_dev, MI_buf + 3, 3);
	300	bulk_w(gspca_dev, MI_buf + 4, 4);
	301	bulk_w(gspca_dev, MI_buf + 5, 5);
	302	bulk_w(gspca_dev, MI_buf + 6, 6);
	303	bulk_w(gspca_dev, MI_buf + 7, 7);
	304	bulk_w(gspca_dev, MI_buf + 9, 9);
	305	bulk_w(gspca_dev, MI_buf + 0x0b, 0x0b);
	306	bulk_w(gspca_dev, MI_buf + 0x0c, 0x0c);
	307	bulk_w(gspca_dev, MI_buf + 0x0d, 0x0d);
	308	bulk_w(gspca_dev, MI_buf + 0x1e, 0x1e);
	309	bulk_w(gspca_dev, MI_buf + 0x20, 0x20);
	310	bulk_w(gspca_dev, MI_buf + 0x2b, 0x2b);
	311	bulk_w(gspca_dev, MI_buf + 0x2c, 0x2c);
	312	bulk_w(gspca_dev, MI_buf + 0x2d, 0x2d);
	313	bulk_w(gspca_dev, MI_buf + 0x2e, 0x2e);
	314	bulk_w(gspca_dev, MI_buf + 0x35, 0x35);
	315	bulk_w(gspca_dev, MI_buf + 0x5f, 0x5f);
	316	bulk_w(gspca_dev, MI_buf + 0x60, 0x60);
	317	bulk_w(gspca_dev, MI_buf + 0x61, 0x61);
	318	bulk_w(gspca_dev, MI_buf + 0x62, 0x62);
	319	bulk_w(gspca_dev, MI_buf + 0x63, 0x63);
	320	bulk_w(gspca_dev, MI_buf + 0x64, 0x64);
	321	bulk_w(gspca_dev, MI_buf + 0xf1, 0xf1);
	322	kfree(MI_buf);
	323
	324	intpipe = usb_sndintpipe(gspca_dev->dev, 0);
	325	err_code = usb_clear_halt(gspca_dev->dev, intpipe);
6a7eba24 JFM	326
	327	data[0] = 0x00;
	328	data[1] = 0x4d; /* ISOC transfering enable... */
739570bb	329	reg_w(gspca_dev, data[0], 2);
72ab97ce	330	return err_code;
6a7eba24 JFM	331	}
	332
	333	static void sd_stopN(struct gspca_dev *gspca_dev)
	334	{
	335	int result;
6a7eba24	336
739570bb JFM	337	gspca_dev->usb_buf[0] = 1;
	338	gspca_dev->usb_buf[1] = 0;
	339	result = reg_w(gspca_dev, gspca_dev->usb_buf[0], 2);
6a7eba24 JFM	340	if (result < 0)
	341	PDEBUG(D_ERR, "Camera Stop failed");
	342	}
	343
6a7eba24 JFM	344	static void sd_pkt_scan(struct gspca_dev *gspca_dev,
6a7eba24 JFM	345	struct gspca_frame frame, / target */
a5ae2062	346	__u8 data, / isoc packet */
6a7eba24 JFM	347	int len) /* iso packet length */
	348	{
	349	struct sd sd = (struct sd ) gspca_dev;
	350	int p;
	351
	352	if (len < 6) {
	353	/* gspca_dev->last_packet_type = DISCARD_PACKET; */
	354	return;
	355	}
	356	for (p = 0; p < len - 6; p++) {
	357	if (data[0 + p] == 0xff
	358	&& data[1 + p] == 0xff
	359	&& data[2 + p] == 0x00
	360	&& data[3 + p] == 0xff
	361	&& data[4 + p] == 0x96) {
	362	if (data[5 + p] == 0x64
	363	\|\| data[5 + p] == 0x65
	364	\|\| data[5 + p] == 0x66
	365	\|\| data[5 + p] == 0x67) {
	366	PDEBUG(D_PACK, "sof offset: %d leng: %d",
	367	p, len);
	368	frame = gspca_frame_add(gspca_dev, LAST_PACKET,
	369	frame, data, 0);
	370
	371	/* put the JPEG header */
	372	jpeg_put_header(gspca_dev, frame,
	373	sd->qindex, 0x21);
	374	data += 16;
	375	len -= 16;
	376	break;
	377	}
	378	}
	379	}
	380	gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
	381	}
	382
	383	/* sub-driver description */
a5ae2062	384	static const struct sd_desc sd_desc = {
6a7eba24 JFM	385	.name = MODULE_NAME,
	386	.ctrls = sd_ctrls,
	387	.nctrls = ARRAY_SIZE(sd_ctrls),
	388	.config = sd_config,
012d6b02	389	.init = sd_init,
6a7eba24 JFM	390	.start = sd_start,
6a7eba24 JFM	391	.stopN = sd_stopN,
6a7eba24 JFM	392	.pkt_scan = sd_pkt_scan,
	393	};
	394
	395	/* -- module initialisation -- */
a5ae2062	396	static const __devinitdata struct usb_device_id device_table[] = {
9d64fdb1	397	{USB_DEVICE(0x093a, 0x050f)},
6a7eba24 JFM	398	{}
	399	};
	400	MODULE_DEVICE_TABLE(usb, device_table);
	401
	402	/* -- device connect -- */
	403	static int sd_probe(struct usb_interface *intf,
	404	const struct usb_device_id *id)
	405	{
	406	return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
	407	THIS_MODULE);
	408	}
	409
	410	static struct usb_driver sd_driver = {
	411	.name = MODULE_NAME,
	412	.id_table = device_table,
	413	.probe = sd_probe,
	414	.disconnect = gspca_disconnect,
6a709749 JFM	415	#ifdef CONFIG_PM
	416	.suspend = gspca_suspend,
	417	.resume = gspca_resume,
	418	#endif
6a7eba24 JFM	419	};
	420
	421	/* -- module insert / remove -- */
	422	static int __init sd_mod_init(void)
	423	{
	424	if (usb_register(&sd_driver) < 0)
	425	return -1;
10b0e96e	426	PDEBUG(D_PROBE, "registered");
6a7eba24 JFM	427	return 0;
	428	}
	429	static void __exit sd_mod_exit(void)
	430	{
	431	usb_deregister(&sd_driver);
	432	PDEBUG(D_PROBE, "deregistered");
	433	}
	434
	435	module_init(sd_mod_init);
	436	module_exit(sd_mod_exit);