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

/*
 * Fujifilm Finepix subdriver
 *
 * Copyright (C) 2008 Frank Zago
 *
 * 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 "finepix"

#include "gspca.h"

MODULE_AUTHOR("Frank Zago <frank@zago.net>");
MODULE_DESCRIPTION("Fujifilm FinePix USB V4L2 driver");
MODULE_LICENSE("GPL");

/* Default timeout, in ms */
#define FPIX_TIMEOUT (HZ / 10)

/* Maximum transfer size to use. The windows driver reads by chunks of
 * 0x2000 bytes, so do the same. Note: reading more seems to work
 * too. */
#define FPIX_MAX_TRANSFER 0x2000

/* Structure to hold all of our device specific stuff */
struct usb_fpix {
	struct gspca_dev gspca_dev;	/* !! must be the first item */

	/*
	 * USB stuff
	 */
	struct usb_ctrlrequest ctrlreq;
	struct urb *control_urb;
	struct timer_list bulk_timer;

	enum {
		FPIX_NOP,	/* inactive, else streaming */
		FPIX_RESET,	/* must reset */
		FPIX_REQ_FRAME,	/* requesting a frame */
		FPIX_READ_FRAME,	/* reading frame */
	} state;

	/*
	 * Driver stuff
	 */
	struct delayed_work wqe;
	struct completion can_close;
	int streaming;
};

/* Delay after which claim the next frame. If the delay is too small,
 * the camera will return old frames. On the 4800Z, 20ms is bad, 25ms
 * will fail every 4 or 5 frames, but 30ms is perfect. */
#define NEXT_FRAME_DELAY  (((HZ * 30) + 999) / 1000)

#define dev_new_state(new_state) {				\
		PDEBUG(D_STREAM, "new state from %d to %d at %s:%d",	\
			dev->state, new_state, __func__, __LINE__);	\
		dev->state = new_state;					\
}

/* These cameras only support 320x200. */
static struct v4l2_pix_format fpix_mode[1] = {
	{ 320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
		.bytesperline = 320,
		.sizeimage = 320 * 240 * 3 / 8 + 590,
		.colorspace = V4L2_COLORSPACE_SRGB,
		.priv = 0}
};

/* Reads part of a frame */
static void read_frame_part(struct usb_fpix *dev)
{
	int ret;

	PDEBUG(D_STREAM, "read_frame_part");

	/* Reads part of a frame */
	ret = usb_submit_urb(dev->gspca_dev.urb[0], GFP_ATOMIC);
	if (ret) {
		dev_new_state(FPIX_RESET);
		schedule_delayed_work(&dev->wqe, 1);
		PDEBUG(D_STREAM, "usb_submit_urb failed with %d",
			ret);
	} else {
		/* Sometimes we never get a callback, so use a timer.
		 * Is this masking a bug somewhere else? */
		dev->bulk_timer.expires = jiffies + msecs_to_jiffies(150);
		add_timer(&dev->bulk_timer);
	}
}

/* Callback for URBs. */
static void urb_callback(struct urb *urb)
{
	struct gspca_dev *gspca_dev = urb->context;
	struct usb_fpix *dev = (struct usb_fpix *) gspca_dev;

	PDEBUG(D_PACK,
		"enter urb_callback - status=%d, length=%d",
		urb->status, urb->actual_length);

	if (dev->state == FPIX_READ_FRAME)
		del_timer(&dev->bulk_timer);

	if (urb->status != 0) {
		/* We kill a stuck urb every 50 frames on average, so don't
		 * display a log message for that. */
		if (urb->status != -ECONNRESET)
			PDEBUG(D_STREAM, "bad URB status %d", urb->status);
		dev_new_state(FPIX_RESET);
		schedule_delayed_work(&dev->wqe, 1);
	}

	switch (dev->state) {
	case FPIX_REQ_FRAME:
		dev_new_state(FPIX_READ_FRAME);
		read_frame_part(dev);
		break;

	case FPIX_READ_FRAME: {
		unsigned char *data = urb->transfer_buffer;
		struct gspca_frame *frame;

		frame = gspca_get_i_frame(&dev->gspca_dev);
		if (frame == NULL)
			gspca_dev->last_packet_type = DISCARD_PACKET;
		if (urb->actual_length < FPIX_MAX_TRANSFER ||
			(data[urb->actual_length-2] == 0xff &&
				data[urb->actual_length-1] == 0xd9)) {

			/* If the result is less than what was asked
			 * for, then it's the end of the
			 * frame. Sometime the jpeg is not complete,
			 * but there's nothing we can do. We also end
			 * here if the the jpeg ends right at the end
			 * of the frame. */
			if (frame)
				gspca_frame_add(gspca_dev, LAST_PACKET,
						frame,
						data, urb->actual_length);
			dev_new_state(FPIX_REQ_FRAME);
			schedule_delayed_work(&dev->wqe, NEXT_FRAME_DELAY);
		} else {

			/* got a partial image */
			if (frame)
				gspca_frame_add(gspca_dev,
						gspca_dev->last_packet_type
								== LAST_PACKET
						? FIRST_PACKET : INTER_PACKET,
						frame,
					data, urb->actual_length);
			read_frame_part(dev);
		}
		break;
	    }

	case FPIX_NOP:
	case FPIX_RESET:
		PDEBUG(D_STREAM, "invalid state %d", dev->state);
		break;
	}
}

/* Request a new frame */
static void request_frame(struct usb_fpix *dev)
{
	int ret;
	struct gspca_dev *gspca_dev = &dev->gspca_dev;

	/* Setup command packet */
	memset(gspca_dev->usb_buf, 0, 12);
	gspca_dev->usb_buf[0] = 0xd3;
	gspca_dev->usb_buf[7] = 0x01;

	/* Request a frame */
	dev->ctrlreq.bRequestType =
		USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE;
	dev->ctrlreq.bRequest = USB_REQ_GET_STATUS;
	dev->ctrlreq.wValue = 0;
	dev->ctrlreq.wIndex = 0;
	dev->ctrlreq.wLength = cpu_to_le16(12);

	usb_fill_control_urb(dev->control_urb,
			     gspca_dev->dev,
			     usb_sndctrlpipe(gspca_dev->dev, 0),
			     (unsigned char *) &dev->ctrlreq,
			     gspca_dev->usb_buf,
			     12, urb_callback, gspca_dev);

	ret = usb_submit_urb(dev->control_urb, GFP_ATOMIC);
	if (ret) {
		dev_new_state(FPIX_RESET);
		schedule_delayed_work(&dev->wqe, 1);
		PDEBUG(D_STREAM, "usb_submit_urb failed with %d", ret);
	}
}

/*--------------------------------------------------------------------------*/

/* State machine. */
static void fpix_sm(struct work_struct *work)
{
	struct usb_fpix *dev = container_of(work, struct usb_fpix, wqe.work);

	PDEBUG(D_STREAM, "fpix_sm state %d", dev->state);

	/* verify that the device wasn't unplugged */
	if (!dev->gspca_dev.present) {
		PDEBUG(D_STREAM, "device is gone");
		dev_new_state(FPIX_NOP);
		complete(&dev->can_close);
		return;
	}

	if (!dev->streaming) {
		PDEBUG(D_STREAM, "stopping state machine");
		dev_new_state(FPIX_NOP);
		complete(&dev->can_close);
		return;
	}

	switch (dev->state) {
	case FPIX_RESET:
		dev_new_state(FPIX_REQ_FRAME);
		schedule_delayed_work(&dev->wqe, HZ / 10);
		break;

	case FPIX_REQ_FRAME:
		/* get an image */
		request_frame(dev);
		break;

	case FPIX_NOP:
	case FPIX_READ_FRAME:
		PDEBUG(D_STREAM, "invalid state %d", dev->state);
		break;
	}
}

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

	cam->cam_mode = fpix_mode;
	cam->nmodes = 1;
	cam->epaddr = 0x01;	/* todo: correct for all cams? */
	cam->bulk_size = FPIX_MAX_TRANSFER;

/*	gspca_dev->nbalt = 1;	 * use bulk transfer */
	return 0;
}

/* Stop streaming and free the ressources allocated by sd_start. */
static void sd_stopN(struct gspca_dev *gspca_dev)
{
	struct usb_fpix *dev = (struct usb_fpix *) gspca_dev;

	dev->streaming = 0;

	/* Stop the state machine */
	if (dev->state != FPIX_NOP)
		wait_for_completion(&dev->can_close);

	usb_free_urb(dev->control_urb);
	dev->control_urb = NULL;
}

/* Kill an URB that hasn't completed. */
static void timeout_kill(unsigned long data)
{
	struct urb *urb = (struct urb *) data;

	usb_unlink_urb(urb);
}

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

	INIT_DELAYED_WORK(&dev->wqe, fpix_sm);

	init_timer(&dev->bulk_timer);
	dev->bulk_timer.function = timeout_kill;

	return 0;
}

static int sd_start(struct gspca_dev *gspca_dev)
{
	struct usb_fpix *dev = (struct usb_fpix *) gspca_dev;
	int ret;
	int size_ret;

	/* Reset bulk in endpoint */
	usb_clear_halt(gspca_dev->dev, gspca_dev->cam.epaddr);

	/* Init the device */
	memset(gspca_dev->usb_buf, 0, 12);
	gspca_dev->usb_buf[0] = 0xc6;
	gspca_dev->usb_buf[8] = 0x20;

	ret = usb_control_msg(gspca_dev->dev,
			usb_sndctrlpipe(gspca_dev->dev, 0),
			USB_REQ_GET_STATUS,
			USB_DIR_OUT | USB_TYPE_CLASS |
			USB_RECIP_INTERFACE, 0, 0, gspca_dev->usb_buf,
			12, FPIX_TIMEOUT);

	if (ret != 12) {
		PDEBUG(D_STREAM, "usb_control_msg failed (%d)", ret);
		ret = -EIO;
		goto error;
	}

	/* Read the result of the command. Ignore the result, for it
	 * varies with the device. */
	ret = usb_bulk_msg(gspca_dev->dev,
			usb_rcvbulkpipe(gspca_dev->dev,
					gspca_dev->cam.epaddr),
			gspca_dev->usb_buf, FPIX_MAX_TRANSFER, &size_ret,
			FPIX_TIMEOUT);
	if (ret != 0) {
		PDEBUG(D_STREAM, "usb_bulk_msg failed (%d)", ret);
		ret = -EIO;
		goto error;
	}

	/* Request a frame, but don't read it */
	memset(gspca_dev->usb_buf, 0, 12);
	gspca_dev->usb_buf[0] = 0xd3;
	gspca_dev->usb_buf[7] = 0x01;

	ret = usb_control_msg(gspca_dev->dev,
			usb_sndctrlpipe(gspca_dev->dev, 0),
			USB_REQ_GET_STATUS,
			USB_DIR_OUT | USB_TYPE_CLASS |
			USB_RECIP_INTERFACE, 0, 0, gspca_dev->usb_buf,
			12, FPIX_TIMEOUT);
	if (ret != 12) {
		PDEBUG(D_STREAM, "usb_control_msg failed (%d)", ret);
		ret = -EIO;
		goto error;
	}

	/* Again, reset bulk in endpoint */
	usb_clear_halt(gspca_dev->dev, gspca_dev->cam.epaddr);

	/* Allocate a control URB */
	dev->control_urb = usb_alloc_urb(0, GFP_KERNEL);
	if (!dev->control_urb) {
		PDEBUG(D_STREAM, "No free urbs available");
		ret = -EIO;
		goto error;
	}

	/* Various initializations. */
	init_completion(&dev->can_close);
	dev->bulk_timer.data = (unsigned long)dev->gspca_dev.urb[0];
	dev->gspca_dev.urb[0]->complete = urb_callback;
	dev->streaming = 1;

	/* Schedule a frame request. */
	dev_new_state(FPIX_REQ_FRAME);
	schedule_delayed_work(&dev->wqe, 1);

	return 0;

error:
	/* Free the ressources */
	sd_stopN(gspca_dev);
	return ret;
}

/* Table of supported USB devices */
static const __devinitdata struct usb_device_id device_table[] = {
	{USB_DEVICE(0x04cb, 0x0104)},
	{USB_DEVICE(0x04cb, 0x0109)},
	{USB_DEVICE(0x04cb, 0x010b)},
	{USB_DEVICE(0x04cb, 0x010f)},
	{USB_DEVICE(0x04cb, 0x0111)},
	{USB_DEVICE(0x04cb, 0x0113)},
	{USB_DEVICE(0x04cb, 0x0115)},
	{USB_DEVICE(0x04cb, 0x0117)},
	{USB_DEVICE(0x04cb, 0x0119)},
	{USB_DEVICE(0x04cb, 0x011b)},
	{USB_DEVICE(0x04cb, 0x011d)},
	{USB_DEVICE(0x04cb, 0x0121)},
	{USB_DEVICE(0x04cb, 0x0123)},
	{USB_DEVICE(0x04cb, 0x0125)},
	{USB_DEVICE(0x04cb, 0x0127)},
	{USB_DEVICE(0x04cb, 0x0129)},
	{USB_DEVICE(0x04cb, 0x012b)},
	{USB_DEVICE(0x04cb, 0x012d)},
	{USB_DEVICE(0x04cb, 0x012f)},
	{USB_DEVICE(0x04cb, 0x0131)},
	{USB_DEVICE(0x04cb, 0x013b)},
	{USB_DEVICE(0x04cb, 0x013d)},
	{USB_DEVICE(0x04cb, 0x013f)},
	{}
};

MODULE_DEVICE_TABLE(usb, device_table);

/* sub-driver description */
static const struct sd_desc sd_desc = {
	.name = MODULE_NAME,
	.config = sd_config,
	.init = sd_init,
	.start = sd_start,
	.stopN = sd_stopN,
};

/* -- 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 usb_fpix),
			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
97076859 FZ	1	/*
	2	* Fujifilm Finepix subdriver
	3	*
	4	* Copyright (C) 2008 Frank Zago
	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
	19	*/
	20
	21	#define MODULE_NAME "finepix"
	22
	23	#include "gspca.h"
	24
	25	MODULE_AUTHOR("Frank Zago <frank@zago.net>");
	26	MODULE_DESCRIPTION("Fujifilm FinePix USB V4L2 driver");
	27	MODULE_LICENSE("GPL");
	28
	29	/* Default timeout, in ms */
	30	#define FPIX_TIMEOUT (HZ / 10)
	31
	32	/* Maximum transfer size to use. The windows driver reads by chunks of
	33	* 0x2000 bytes, so do the same. Note: reading more seems to work
	34	* too. */
	35	#define FPIX_MAX_TRANSFER 0x2000
	36
	37	/* Structure to hold all of our device specific stuff */
	38	struct usb_fpix {
	39	struct gspca_dev gspca_dev; /* !! must be the first item */
	40
	41	/*
	42	* USB stuff
	43	*/
	44	struct usb_ctrlrequest ctrlreq;
	45	struct urb *control_urb;
	46	struct timer_list bulk_timer;
	47
	48	enum {
	49	FPIX_NOP, /* inactive, else streaming */
	50	FPIX_RESET, /* must reset */
	51	FPIX_REQ_FRAME, /* requesting a frame */
	52	FPIX_READ_FRAME, /* reading frame */
	53	} state;
	54
	55	/*
	56	* Driver stuff
	57	*/
	58	struct delayed_work wqe;
	59	struct completion can_close;
	60	int streaming;
	61	};
	62
	63	/* Delay after which claim the next frame. If the delay is too small,
	64	* the camera will return old frames. On the 4800Z, 20ms is bad, 25ms
65	* will fail every 4 or 5 frames, but 30ms is perfect. */
66	#define NEXT_FRAME_DELAY (((HZ * 30) + 999) / 1000)
67
68	#define dev_new_state(new_state) { \
69	PDEBUG(D_STREAM, "new state from %d to %d at %s:%d", \
70	dev->state, new_state, __func__, __LINE__); \
71	dev->state = new_state; \
72	}
73
74	/* These cameras only support 320x200. */
75	static struct v4l2_pix_format fpix_mode[1] = {
76	{ 320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
77	.bytesperline = 320,
78	.sizeimage = 320 * 240 * 3 / 8 + 590,
79	.colorspace = V4L2_COLORSPACE_SRGB,
80	.priv = 0}
81	};
82
83	/* Reads part of a frame */
84	static void read_frame_part(struct usb_fpix *dev)
85	{
86	int ret;
87
88	PDEBUG(D_STREAM, "read_frame_part");
89
90	/* Reads part of a frame */
91	ret = usb_submit_urb(dev->gspca_dev.urb[0], GFP_ATOMIC);
92	if (ret) {
93	dev_new_state(FPIX_RESET);
94	schedule_delayed_work(&dev->wqe, 1);
95	PDEBUG(D_STREAM, "usb_submit_urb failed with %d",
96	ret);
97	} else {
98	/* Sometimes we never get a callback, so use a timer.
99	* Is this masking a bug somewhere else? */
100	dev->bulk_timer.expires = jiffies + msecs_to_jiffies(150);
101	add_timer(&dev->bulk_timer);
102	}
103	}
104
105	/* Callback for URBs. */
106	static void urb_callback(struct urb *urb)
107	{
108	struct gspca_dev *gspca_dev = urb->context;
109	struct usb_fpix dev = (struct usb_fpix ) gspca_dev;
110
111	PDEBUG(D_PACK,
112	"enter urb_callback - status=%d, length=%d",
113	urb->status, urb->actual_length);
114
115	if (dev->state == FPIX_READ_FRAME)
116	del_timer(&dev->bulk_timer);
117
118	if (urb->status != 0) {
119	/* We kill a stuck urb every 50 frames on average, so don't
120	* display a log message for that. */
121	if (urb->status != -ECONNRESET)
122	PDEBUG(D_STREAM, "bad URB status %d", urb->status);
123	dev_new_state(FPIX_RESET);
124	schedule_delayed_work(&dev->wqe, 1);
125	}
126
127	switch (dev->state) {
128	case FPIX_REQ_FRAME:
129	dev_new_state(FPIX_READ_FRAME);
130	read_frame_part(dev);
131	break;
132
133	case FPIX_READ_FRAME: {
134	unsigned char *data = urb->transfer_buffer;
135	struct gspca_frame *frame;
136
137	frame = gspca_get_i_frame(&dev->gspca_dev);
a3a58467	138	if (frame == NULL)
97076859	139	gspca_dev->last_packet_type = DISCARD_PACKET;
97076859 FZ	140	if (urb->actual_length < FPIX_MAX_TRANSFER \|\|
	141	(data[urb->actual_length-2] == 0xff &&
	142	data[urb->actual_length-1] == 0xd9)) {
	143
	144	/* If the result is less than what was asked
	145	* for, then it's the end of the
	146	* frame. Sometime the jpeg is not complete,
	147	* but there's nothing we can do. We also end
	148	* here if the the jpeg ends right at the end
	149	* of the frame. */
a3a58467 FZ	150	if (frame)
	151	gspca_frame_add(gspca_dev, LAST_PACKET,
	152	frame,
	153	data, urb->actual_length);
97076859 FZ	154	dev_new_state(FPIX_REQ_FRAME);
	155	schedule_delayed_work(&dev->wqe, NEXT_FRAME_DELAY);
	156	} else {
	157
	158	/* got a partial image */
a3a58467 FZ	159	if (frame)
	160	gspca_frame_add(gspca_dev,
	161	gspca_dev->last_packet_type
	162	== LAST_PACKET
	163	? FIRST_PACKET : INTER_PACKET,
	164	frame,
97076859 FZ	165	data, urb->actual_length);
	166	read_frame_part(dev);
	167	}
	168	break;
	169	}
	170
	171	case FPIX_NOP:
	172	case FPIX_RESET:
	173	PDEBUG(D_STREAM, "invalid state %d", dev->state);
	174	break;
	175	}
	176	}
	177
	178	/* Request a new frame */
	179	static void request_frame(struct usb_fpix *dev)
	180	{
	181	int ret;
	182	struct gspca_dev *gspca_dev = &dev->gspca_dev;
	183
	184	/* Setup command packet */
	185	memset(gspca_dev->usb_buf, 0, 12);
	186	gspca_dev->usb_buf[0] = 0xd3;
	187	gspca_dev->usb_buf[7] = 0x01;
	188
	189	/* Request a frame */
	190	dev->ctrlreq.bRequestType =
	191	USB_DIR_OUT \| USB_TYPE_CLASS \| USB_RECIP_INTERFACE;
	192	dev->ctrlreq.bRequest = USB_REQ_GET_STATUS;
	193	dev->ctrlreq.wValue = 0;
	194	dev->ctrlreq.wIndex = 0;
	195	dev->ctrlreq.wLength = cpu_to_le16(12);
	196
	197	usb_fill_control_urb(dev->control_urb,
	198	gspca_dev->dev,
	199	usb_sndctrlpipe(gspca_dev->dev, 0),
	200	(unsigned char *) &dev->ctrlreq,
	201	gspca_dev->usb_buf,
	202	12, urb_callback, gspca_dev);
	203
	204	ret = usb_submit_urb(dev->control_urb, GFP_ATOMIC);
	205	if (ret) {
	206	dev_new_state(FPIX_RESET);
	207	schedule_delayed_work(&dev->wqe, 1);
	208	PDEBUG(D_STREAM, "usb_submit_urb failed with %d", ret);
	209	}
	210	}
	211
	212	/--------------------------------------------------------------------------/
	213
	214	/* State machine. */
	215	static void fpix_sm(struct work_struct *work)
	216	{
	217	struct usb_fpix *dev = container_of(work, struct usb_fpix, wqe.work);
	218
	219	PDEBUG(D_STREAM, "fpix_sm state %d", dev->state);
	220
	221	/* verify that the device wasn't unplugged */
	222	if (!dev->gspca_dev.present) {
	223	PDEBUG(D_STREAM, "device is gone");
	224	dev_new_state(FPIX_NOP);
	225	complete(&dev->can_close);
	226	return;
	227	}
	228
229	if (!dev->streaming) {
230	PDEBUG(D_STREAM, "stopping state machine");
231	dev_new_state(FPIX_NOP);
232	complete(&dev->can_close);
233	return;
234	}
235
236	switch (dev->state) {
237	case FPIX_RESET:
238	dev_new_state(FPIX_REQ_FRAME);
239	schedule_delayed_work(&dev->wqe, HZ / 10);
240	break;
241
242	case FPIX_REQ_FRAME:
243	/* get an image */
244	request_frame(dev);
245	break;
246
247	case FPIX_NOP:
248	case FPIX_READ_FRAME:
249	PDEBUG(D_STREAM, "invalid state %d", dev->state);
250	break;
251	}
252	}
253
254	/* this function is called at probe time */
255	static int sd_config(struct gspca_dev *gspca_dev,
256	const struct usb_device_id *id)
257	{
258	struct cam *cam = &gspca_dev->cam;
259
260	cam->cam_mode = fpix_mode;
261	cam->nmodes = 1;
262	cam->epaddr = 0x01; /* todo: correct for all cams? */
263	cam->bulk_size = FPIX_MAX_TRANSFER;
264
265	/* gspca_dev->nbalt = 1; * use bulk transfer */
266	return 0;
267	}
268
269	/* Stop streaming and free the ressources allocated by sd_start. */
270	static void sd_stopN(struct gspca_dev *gspca_dev)
271	{
272	struct usb_fpix dev = (struct usb_fpix ) gspca_dev;
273
274	dev->streaming = 0;
275
276	/* Stop the state machine */
277	if (dev->state != FPIX_NOP)
278	wait_for_completion(&dev->can_close);
279
280	usb_free_urb(dev->control_urb);
281	dev->control_urb = NULL;
282	}
283
284	/* Kill an URB that hasn't completed. */
285	static void timeout_kill(unsigned long data)
286	{
287	struct urb urb = (struct urb ) data;
288
289	usb_unlink_urb(urb);
290	}
291
292	/* this function is called at probe and resume time */
293	static int sd_init(struct gspca_dev *gspca_dev)
294	{
295	struct usb_fpix dev = (struct usb_fpix ) gspca_dev;
296
297	INIT_DELAYED_WORK(&dev->wqe, fpix_sm);
298
299	init_timer(&dev->bulk_timer);
300	dev->bulk_timer.function = timeout_kill;
301
302	return 0;
303	}
304
305	static int sd_start(struct gspca_dev *gspca_dev)
306	{
307	struct usb_fpix dev = (struct usb_fpix ) gspca_dev;
308	int ret;
309	int size_ret;
310
311	/* Reset bulk in endpoint */
312	usb_clear_halt(gspca_dev->dev, gspca_dev->cam.epaddr);
313
314	/* Init the device */
315	memset(gspca_dev->usb_buf, 0, 12);
316	gspca_dev->usb_buf[0] = 0xc6;
317	gspca_dev->usb_buf[8] = 0x20;
318
319	ret = usb_control_msg(gspca_dev->dev,
320	usb_sndctrlpipe(gspca_dev->dev, 0),
321	USB_REQ_GET_STATUS,
322	USB_DIR_OUT \| USB_TYPE_CLASS \|
323	USB_RECIP_INTERFACE, 0, 0, gspca_dev->usb_buf,
324	12, FPIX_TIMEOUT);
325
326	if (ret != 12) {
327	PDEBUG(D_STREAM, "usb_control_msg failed (%d)", ret);
328	ret = -EIO;
329	goto error;
330	}
331
332	/* Read the result of the command. Ignore the result, for it
333	* varies with the device. */
334	ret = usb_bulk_msg(gspca_dev->dev,
335	usb_rcvbulkpipe(gspca_dev->dev,
336	gspca_dev->cam.epaddr),
337	gspca_dev->usb_buf, FPIX_MAX_TRANSFER, &size_ret,
338	FPIX_TIMEOUT);
339	if (ret != 0) {
340	PDEBUG(D_STREAM, "usb_bulk_msg failed (%d)", ret);
341	ret = -EIO;
342	goto error;
343	}
344
345	/* Request a frame, but don't read it */
346	memset(gspca_dev->usb_buf, 0, 12);
347	gspca_dev->usb_buf[0] = 0xd3;
348	gspca_dev->usb_buf[7] = 0x01;
349
350	ret = usb_control_msg(gspca_dev->dev,
351	usb_sndctrlpipe(gspca_dev->dev, 0),
352	USB_REQ_GET_STATUS,
353	USB_DIR_OUT \| USB_TYPE_CLASS \|
354	USB_RECIP_INTERFACE, 0, 0, gspca_dev->usb_buf,
355	12, FPIX_TIMEOUT);
356	if (ret != 12) {
357	PDEBUG(D_STREAM, "usb_control_msg failed (%d)", ret);
358	ret = -EIO;
359	goto error;
360	}
361
362	/* Again, reset bulk in endpoint */
363	usb_clear_halt(gspca_dev->dev, gspca_dev->cam.epaddr);
364
365	/* Allocate a control URB */
366	dev->control_urb = usb_alloc_urb(0, GFP_KERNEL);
367	if (!dev->control_urb) {
368	PDEBUG(D_STREAM, "No free urbs available");
369	ret = -EIO;
370	goto error;
371	}
372
373	/* Various initializations. */
374	init_completion(&dev->can_close);
375	dev->bulk_timer.data = (unsigned long)dev->gspca_dev.urb[0];
376	dev->gspca_dev.urb[0]->complete = urb_callback;
377	dev->streaming = 1;
378
379	/* Schedule a frame request. */
380	dev_new_state(FPIX_REQ_FRAME);
381	schedule_delayed_work(&dev->wqe, 1);
382
383	return 0;
384
385	error:
386	/* Free the ressources */
387	sd_stopN(gspca_dev);
388	return ret;
389	}
390
391	/* Table of supported USB devices */
392	static const __devinitdata struct usb_device_id device_table[] = {
393	{USB_DEVICE(0x04cb, 0x0104)},
394	{USB_DEVICE(0x04cb, 0x0109)},
395	{USB_DEVICE(0x04cb, 0x010b)},
396	{USB_DEVICE(0x04cb, 0x010f)},
397	{USB_DEVICE(0x04cb, 0x0111)},
398	{USB_DEVICE(0x04cb, 0x0113)},
399	{USB_DEVICE(0x04cb, 0x0115)},
400	{USB_DEVICE(0x04cb, 0x0117)},
401	{USB_DEVICE(0x04cb, 0x0119)},
402	{USB_DEVICE(0x04cb, 0x011b)},
403	{USB_DEVICE(0x04cb, 0x011d)},
404	{USB_DEVICE(0x04cb, 0x0121)},
405	{USB_DEVICE(0x04cb, 0x0123)},
406	{USB_DEVICE(0x04cb, 0x0125)},
407	{USB_DEVICE(0x04cb, 0x0127)},
408	{USB_DEVICE(0x04cb, 0x0129)},
409	{USB_DEVICE(0x04cb, 0x012b)},
410	{USB_DEVICE(0x04cb, 0x012d)},
411	{USB_DEVICE(0x04cb, 0x012f)},
412	{USB_DEVICE(0x04cb, 0x0131)},
413	{USB_DEVICE(0x04cb, 0x013b)},
414	{USB_DEVICE(0x04cb, 0x013d)},
415	{USB_DEVICE(0x04cb, 0x013f)},
416	{}
417	};
418
419	MODULE_DEVICE_TABLE(usb, device_table);
420
421	/* sub-driver description */
422	static const struct sd_desc sd_desc = {
423	.name = MODULE_NAME,
424	.config = sd_config,
425	.init = sd_init,
426	.start = sd_start,
427	.stopN = sd_stopN,
428	};
429
430	/* -- device connect -- */
431	static int sd_probe(struct usb_interface *intf,
432	const struct usb_device_id *id)
433	{
434	return gspca_dev_probe(intf, id,
435	&sd_desc,
436	sizeof(struct usb_fpix),
437	THIS_MODULE);
438	}
439
440	static struct usb_driver sd_driver = {
441	.name = MODULE_NAME,
442	.id_table = device_table,
443	.probe = sd_probe,
444	.disconnect = gspca_disconnect,
445	#ifdef CONFIG_PM
446	.suspend = gspca_suspend,
447	.resume = gspca_resume,
448	#endif
449	};
450
451	/* -- module insert / remove -- */
452	static int __init sd_mod_init(void)
453	{
454	if (usb_register(&sd_driver) < 0)
455	return -1;
456	PDEBUG(D_PROBE, "registered");
457	return 0;
458	}
459	static void __exit sd_mod_exit(void)
460	{
461	usb_deregister(&sd_driver);
462	PDEBUG(D_PROBE, "deregistered");
463	}
464
465	module_init(sd_mod_init);
466	module_exit(sd_mod_exit);