4 * Copyright (C) 2008, 2009 Adam Baker and Theodore Kilgore
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
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.
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
22 * History and Acknowledgments
24 * The original Linux driver for SQ905 based cameras was written by
25 * Marcell Lengyel and furter developed by many other contributers
26 * and is available from http://sourceforge.net/projects/sqcam/
28 * This driver takes advantage of the reverse engineering work done for
29 * that driver and for libgphoto2 but shares no code with them.
31 * This driver has used as a base the finepix driver and other gspca
32 * based drivers and may still contain code fragments taken from those
36 #define MODULE_NAME "sq905"
38 #include <linux/workqueue.h>
41 MODULE_AUTHOR("Adam Baker <linux@baker-net.org.uk>, "
42 "Theodore Kilgore <kilgota@auburn.edu>");
43 MODULE_DESCRIPTION("GSPCA/SQ905 USB Camera Driver");
44 MODULE_LICENSE("GPL");
46 /* Default timeouts, in ms */
47 #define SQ905_CMD_TIMEOUT 500
48 #define SQ905_DATA_TIMEOUT 1000
50 /* Maximum transfer size to use. */
51 #define SQ905_MAX_TRANSFER 0x8000
52 #define FRAME_HEADER_LEN 64
54 /* The known modes, or registers. These go in the "value" slot. */
56 /* 00 is "none" obviously */
58 #define SQ905_BULK_READ 0x03 /* precedes any bulk read */
59 #define SQ905_COMMAND 0x06 /* precedes the command codes below */
60 #define SQ905_PING 0x07 /* when reading an "idling" command */
61 #define SQ905_READ_DONE 0xc0 /* ack bulk read completed */
63 /* Any non-zero value in the bottom 2 bits of the 2nd byte of
64 * the ID appears to indicate the camera can do 640*480. If the
65 * LSB of that byte is set the image is just upside down, otherwise
66 * it is rotated 180 degrees. */
67 #define SQ905_HIRES_MASK 0x00000300
68 #define SQ905_ORIENTATION_MASK 0x00000100
70 /* Some command codes. These go in the "index" slot. */
72 #define SQ905_ID 0xf0 /* asks for model string */
73 #define SQ905_CONFIG 0x20 /* gets photo alloc. table, not used here */
74 #define SQ905_DATA 0x30 /* accesses photo data, not used here */
75 #define SQ905_CLEAR 0xa0 /* clear everything */
76 #define SQ905_CAPTURE_LOW 0x60 /* Starts capture at 160x120 */
77 #define SQ905_CAPTURE_MED 0x61 /* Starts capture at 320x240 */
78 #define SQ905_CAPTURE_HIGH 0x62 /* Starts capture at 640x480 (some cams only) */
79 /* note that the capture command also controls the output dimensions */
81 /* Structure to hold all of our device specific stuff */
83 struct gspca_dev gspca_dev; /* !! must be the first item */
85 const struct v4l2_pix_format *cap_mode;
90 struct work_struct work_struct;
91 struct workqueue_struct *work_thread;
94 static struct v4l2_pix_format sq905_mode[] = {
95 { 160, 120, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
97 .sizeimage = 160 * 120,
98 .colorspace = V4L2_COLORSPACE_SRGB,
100 { 320, 240, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
102 .sizeimage = 320 * 240,
103 .colorspace = V4L2_COLORSPACE_SRGB,
105 { 640, 480, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
107 .sizeimage = 640 * 480,
108 .colorspace = V4L2_COLORSPACE_SRGB,
113 * Send a command to the camera.
115 static int sq905_command(struct gspca_dev *gspca_dev, u16 index)
119 gspca_dev->usb_buf[0] = '\0';
120 ret = usb_control_msg(gspca_dev->dev,
121 usb_sndctrlpipe(gspca_dev->dev, 0),
122 USB_REQ_SYNCH_FRAME, /* request */
123 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
124 SQ905_COMMAND, index, gspca_dev->usb_buf, 1,
127 PDEBUG(D_ERR, "%s: usb_control_msg failed (%d)",
132 ret = usb_control_msg(gspca_dev->dev,
133 usb_sndctrlpipe(gspca_dev->dev, 0),
134 USB_REQ_SYNCH_FRAME, /* request */
135 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
136 SQ905_PING, 0, gspca_dev->usb_buf, 1,
139 PDEBUG(D_ERR, "%s: usb_control_msg failed 2 (%d)",
148 * Acknowledge the end of a frame - see warning on sq905_command.
150 static int sq905_ack_frame(struct gspca_dev *gspca_dev)
154 gspca_dev->usb_buf[0] = '\0';
155 ret = usb_control_msg(gspca_dev->dev,
156 usb_sndctrlpipe(gspca_dev->dev, 0),
157 USB_REQ_SYNCH_FRAME, /* request */
158 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
159 SQ905_READ_DONE, 0, gspca_dev->usb_buf, 1,
162 PDEBUG(D_ERR, "%s: usb_control_msg failed (%d)", __func__, ret);
170 * request and read a block of data - see warning on sq905_command.
173 sq905_read_data(struct gspca_dev *gspca_dev, u8 *data, int size)
178 gspca_dev->usb_buf[0] = '\0';
179 ret = usb_control_msg(gspca_dev->dev,
180 usb_sndctrlpipe(gspca_dev->dev, 0),
181 USB_REQ_SYNCH_FRAME, /* request */
182 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
183 SQ905_BULK_READ, size, gspca_dev->usb_buf,
184 1, SQ905_CMD_TIMEOUT);
186 PDEBUG(D_ERR, "%s: usb_control_msg failed (%d)", __func__, ret);
189 ret = usb_bulk_msg(gspca_dev->dev,
190 usb_rcvbulkpipe(gspca_dev->dev, 0x81),
191 data, size, &act_len, SQ905_DATA_TIMEOUT);
193 /* successful, it returns 0, otherwise negative */
194 if (ret < 0 || act_len != size) {
195 PDEBUG(D_ERR, "bulk read fail (%d) len %d/%d",
202 /* This function is called as a workqueue function and runs whenever the camera
203 * is streaming data. Because it is a workqueue function it is allowed to sleep
204 * so we can use synchronous USB calls. To avoid possible collisions with other
205 * threads attempting to use the camera's USB interface we take the gspca
206 * usb_lock when performing USB operations. In practice the only thing we need
207 * to protect against is the usb_set_interface call that gspca makes during
208 * stream_off as the camera doesn't provide any controls that the user could try
211 static void sq905_dostream(struct work_struct *work)
213 struct sd *dev = container_of(work, struct sd, work_struct);
214 struct gspca_dev *gspca_dev = &dev->gspca_dev;
215 struct gspca_frame *frame;
216 int bytes_left; /* bytes remaining in current frame. */
217 int data_len; /* size to use for the next read. */
218 int header_read; /* true if we have already read the frame header. */
219 int discarding; /* true if we failed to get space for frame. */
225 buffer = kmalloc(SQ905_MAX_TRANSFER, GFP_KERNEL | GFP_DMA);
226 mutex_lock(&gspca_dev->usb_lock);
228 PDEBUG(D_ERR, "Couldn't allocate USB buffer");
232 while (gspca_dev->present && gspca_dev->streaming) {
233 /* Need a short delay to ensure streaming flag was set by
234 * gspca and to make sure gspca can grab the mutex. */
235 mutex_unlock(&gspca_dev->usb_lock);
238 /* request some data and then read it until we have
239 * a complete frame. */
240 bytes_left = dev->cap_mode->sizeimage + FRAME_HEADER_LEN;
244 while (bytes_left > 0) {
245 data_len = bytes_left > SQ905_MAX_TRANSFER ?
246 SQ905_MAX_TRANSFER : bytes_left;
247 mutex_lock(&gspca_dev->usb_lock);
248 if (!gspca_dev->present)
250 ret = sq905_read_data(gspca_dev, buffer, data_len);
253 mutex_unlock(&gspca_dev->usb_lock);
255 "Got %d bytes out of %d for frame",
256 data_len, bytes_left);
257 bytes_left -= data_len;
260 packet_type = FIRST_PACKET;
261 /* The first 64 bytes of each frame are
262 * a header full of FF 00 bytes */
263 data += FRAME_HEADER_LEN;
264 data_len -= FRAME_HEADER_LEN;
266 } else if (bytes_left == 0) {
267 packet_type = LAST_PACKET;
269 packet_type = INTER_PACKET;
271 frame = gspca_get_i_frame(gspca_dev);
272 if (frame && !discarding) {
273 gspca_frame_add(gspca_dev, packet_type,
274 frame, data, data_len);
275 /* If entire frame fits in one packet we still
276 need to add a LAST_PACKET */
277 if ((packet_type == FIRST_PACKET) &&
279 gspca_frame_add(gspca_dev, LAST_PACKET,
285 /* acknowledge the frame */
286 mutex_lock(&gspca_dev->usb_lock);
287 if (!gspca_dev->present)
289 ret = sq905_ack_frame(gspca_dev);
294 /* the usb_lock is already acquired */
295 if (gspca_dev->present)
296 sq905_command(gspca_dev, SQ905_CLEAR);
297 mutex_unlock(&gspca_dev->usb_lock);
301 /* This function is called at probe time just before sd_init */
302 static int sd_config(struct gspca_dev *gspca_dev,
303 const struct usb_device_id *id)
305 struct cam *cam = &gspca_dev->cam;
306 struct sd *dev = (struct sd *) gspca_dev;
308 /* We don't use the buffer gspca allocates so make it small. */
311 INIT_WORK(&dev->work_struct, sq905_dostream);
316 /* called on streamoff with alt==0 and on disconnect */
317 /* the usb_lock is held at entry - restore on exit */
318 static void sd_stop0(struct gspca_dev *gspca_dev)
320 struct sd *dev = (struct sd *) gspca_dev;
322 /* wait for the work queue to terminate */
323 mutex_unlock(&gspca_dev->usb_lock);
324 /* This waits for sq905_dostream to finish */
325 destroy_workqueue(dev->work_thread);
326 dev->work_thread = NULL;
327 mutex_lock(&gspca_dev->usb_lock);
330 /* this function is called at probe and resume time */
331 static int sd_init(struct gspca_dev *gspca_dev)
336 /* connect to the camera and read
337 * the model ID and process that and put it away.
339 ret = sq905_command(gspca_dev, SQ905_CLEAR);
342 ret = sq905_command(gspca_dev, SQ905_ID);
345 ret = sq905_read_data(gspca_dev, gspca_dev->usb_buf, 4);
348 /* usb_buf is allocated with kmalloc so is aligned.
349 * Camera model number is the right way round if we assume this
350 * reverse engineered ID is supposed to be big endian. */
351 ident = be32_to_cpup((__be32 *)gspca_dev->usb_buf);
352 ret = sq905_command(gspca_dev, SQ905_CLEAR);
355 PDEBUG(D_CONF, "SQ905 camera ID %08x detected", ident);
356 gspca_dev->cam.cam_mode = sq905_mode;
357 gspca_dev->cam.nmodes = ARRAY_SIZE(sq905_mode);
358 if (!(ident & SQ905_HIRES_MASK))
359 gspca_dev->cam.nmodes--;
363 /* Set up for getting frames. */
364 static int sd_start(struct gspca_dev *gspca_dev)
366 struct sd *dev = (struct sd *) gspca_dev;
369 /* Set capture mode based on selected resolution. */
370 dev->cap_mode = gspca_dev->cam.cam_mode;
371 /* "Open the shutter" and set size, to start capture */
372 switch (gspca_dev->width) {
374 PDEBUG(D_STREAM, "Start streaming at high resolution");
376 ret = sq905_command(&dev->gspca_dev, SQ905_CAPTURE_HIGH);
379 PDEBUG(D_STREAM, "Start streaming at medium resolution");
381 ret = sq905_command(&dev->gspca_dev, SQ905_CAPTURE_MED);
384 PDEBUG(D_STREAM, "Start streaming at low resolution");
385 ret = sq905_command(&dev->gspca_dev, SQ905_CAPTURE_LOW);
389 PDEBUG(D_ERR, "Start streaming command failed");
392 /* Start the workqueue function to do the streaming */
393 dev->work_thread = create_singlethread_workqueue(MODULE_NAME);
394 queue_work(dev->work_thread, &dev->work_struct);
399 /* Table of supported USB devices */
400 static const __devinitdata struct usb_device_id device_table[] = {
401 {USB_DEVICE(0x2770, 0x9120)},
405 MODULE_DEVICE_TABLE(usb, device_table);
407 /* sub-driver description */
408 static const struct sd_desc sd_desc = {
416 /* -- device connect -- */
417 static int sd_probe(struct usb_interface *intf,
418 const struct usb_device_id *id)
420 return gspca_dev_probe(intf, id,
426 static struct usb_driver sd_driver = {
428 .id_table = device_table,
430 .disconnect = gspca_disconnect,
432 .suspend = gspca_suspend,
433 .resume = gspca_resume,
437 /* -- module insert / remove -- */
438 static int __init sd_mod_init(void)
442 ret = usb_register(&sd_driver);
445 PDEBUG(D_PROBE, "registered");
449 static void __exit sd_mod_exit(void)
451 usb_deregister(&sd_driver);
452 PDEBUG(D_PROBE, "deregistered");
455 module_init(sd_mod_init);
456 module_exit(sd_mod_exit);