blob: c492846c1c5a33770c6488cbfd8095f7c91757db [file] [log] [blame]
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001/*
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03002 * Zoran 364xx based USB webcam module version 0.73
Antoine Jacquetb7eee612007-04-27 12:30:59 -03003 *
4 * Allows you to use your USB webcam with V4L2 applications
5 * This is still in heavy developpement !
6 *
7 * Copyright (C) 2004 Antoine Jacquet <royale@zerezo.com>
8 * http://royale.zerezo.com/zr364xx/
9 *
10 * Heavily inspired by usb-skeleton.c, vicam.c, cpia.c and spca50x.c drivers
11 * V4L2 version inspired by meye.c driver
12 *
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -030013 * Some video buffer code by Lamarque based on s2255drv.c and vivi.c drivers.
14 *
Antoine Jacquetb7eee612007-04-27 12:30:59 -030015 * This program is free software; you can redistribute it and/or modify
16 * it under the terms of the GNU General Public License as published by
17 * the Free Software Foundation; either version 2 of the License, or
18 * (at your option) any later version.
19 *
20 * This program is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 * GNU General Public License for more details.
24 *
25 * You should have received a copy of the GNU General Public License
26 * along with this program; if not, write to the Free Software
27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 */
29
30
Antoine Jacquetb7eee612007-04-27 12:30:59 -030031#include <linux/module.h>
32#include <linux/init.h>
33#include <linux/usb.h>
34#include <linux/vmalloc.h>
35#include <linux/slab.h>
36#include <linux/proc_fs.h>
Antoine Jacquet2575f842007-03-05 06:32:29 -030037#include <linux/highmem.h>
Antoine Jacquetb7eee612007-04-27 12:30:59 -030038#include <media/v4l2-common.h>
Hans Verkuil35ea11f2008-07-20 08:12:02 -030039#include <media/v4l2-ioctl.h>
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -030040#include <media/videobuf-vmalloc.h>
Antoine Jacquetb7eee612007-04-27 12:30:59 -030041
42
43/* Version Information */
Mauro Carvalho Chehab1990d502011-06-24 14:45:49 -030044#define DRIVER_VERSION "0.7.4"
Antoine Jacquetb7eee612007-04-27 12:30:59 -030045#define DRIVER_AUTHOR "Antoine Jacquet, http://royale.zerezo.com/"
46#define DRIVER_DESC "Zoran 364xx"
47
48
49/* Camera */
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -030050#define FRAMES 1
Lamarque Vieira Souza8c5f32a2009-07-20 20:46:42 -030051#define MAX_FRAME_SIZE 200000
Antoine Jacquetb7eee612007-04-27 12:30:59 -030052#define BUFFER_SIZE 0x1000
53#define CTRL_TIMEOUT 500
54
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -030055#define ZR364XX_DEF_BUFS 4
56#define ZR364XX_READ_IDLE 0
57#define ZR364XX_READ_FRAME 1
Antoine Jacquetb7eee612007-04-27 12:30:59 -030058
59/* Debug macro */
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -030060#define DBG(fmt, args...) \
61 do { \
62 if (debug) { \
63 printk(KERN_INFO KBUILD_MODNAME " " fmt, ##args); \
64 } \
65 } while (0)
Antoine Jacquetb7eee612007-04-27 12:30:59 -030066
Lamarque Vieira Souza76594c52009-07-22 16:54:51 -030067/*#define FULL_DEBUG 1*/
68#ifdef FULL_DEBUG
69#define _DBG DBG
70#else
71#define _DBG(fmt, args...)
72#endif
73
Antoine Jacquetb7eee612007-04-27 12:30:59 -030074/* Init methods, need to find nicer names for these
75 * the exact names of the chipsets would be the best if someone finds it */
76#define METHOD0 0
77#define METHOD1 1
78#define METHOD2 2
Antoine Jacquet08135ba2009-12-27 18:22:05 -030079#define METHOD3 3
Antoine Jacquetb7eee612007-04-27 12:30:59 -030080
81
82/* Module parameters */
Douglas Schilling Landgrafff699e62008-04-22 14:41:48 -030083static int debug;
84static int mode;
Antoine Jacquetb7eee612007-04-27 12:30:59 -030085
86
87/* Module parameters interface */
88module_param(debug, int, 0644);
89MODULE_PARM_DESC(debug, "Debug level");
90module_param(mode, int, 0644);
91MODULE_PARM_DESC(mode, "0 = 320x240, 1 = 160x120, 2 = 640x480");
92
93
94/* Devices supported by this driver
95 * .driver_info contains the init method used by the camera */
96static struct usb_device_id device_table[] = {
97 {USB_DEVICE(0x08ca, 0x0109), .driver_info = METHOD0 },
98 {USB_DEVICE(0x041e, 0x4024), .driver_info = METHOD0 },
99 {USB_DEVICE(0x0d64, 0x0108), .driver_info = METHOD0 },
100 {USB_DEVICE(0x0546, 0x3187), .driver_info = METHOD0 },
101 {USB_DEVICE(0x0d64, 0x3108), .driver_info = METHOD0 },
102 {USB_DEVICE(0x0595, 0x4343), .driver_info = METHOD0 },
103 {USB_DEVICE(0x0bb0, 0x500d), .driver_info = METHOD0 },
104 {USB_DEVICE(0x0feb, 0x2004), .driver_info = METHOD0 },
105 {USB_DEVICE(0x055f, 0xb500), .driver_info = METHOD0 },
106 {USB_DEVICE(0x08ca, 0x2062), .driver_info = METHOD2 },
107 {USB_DEVICE(0x052b, 0x1a18), .driver_info = METHOD1 },
108 {USB_DEVICE(0x04c8, 0x0729), .driver_info = METHOD0 },
109 {USB_DEVICE(0x04f2, 0xa208), .driver_info = METHOD0 },
110 {USB_DEVICE(0x0784, 0x0040), .driver_info = METHOD1 },
111 {USB_DEVICE(0x06d6, 0x0034), .driver_info = METHOD0 },
112 {USB_DEVICE(0x0a17, 0x0062), .driver_info = METHOD2 },
Antoine Jacquetbebeaea2007-06-25 16:00:34 -0300113 {USB_DEVICE(0x06d6, 0x003b), .driver_info = METHOD0 },
Antoine Jacquet71c04472008-01-25 22:01:53 -0300114 {USB_DEVICE(0x0a17, 0x004e), .driver_info = METHOD2 },
Antoine Jacquetc0e0aff2008-01-25 22:03:10 -0300115 {USB_DEVICE(0x041e, 0x405d), .driver_info = METHOD2 },
Antoine Jacquet08135ba2009-12-27 18:22:05 -0300116 {USB_DEVICE(0x08ca, 0x2102), .driver_info = METHOD3 },
Antoine Jacquet9018f6c2009-11-19 22:35:38 -0300117 {USB_DEVICE(0x06d6, 0x003d), .driver_info = METHOD0 },
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300118 {} /* Terminating entry */
119};
120
121MODULE_DEVICE_TABLE(usb, device_table);
122
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300123struct zr364xx_mode {
124 u32 color; /* output video color format */
125 u32 brightness; /* brightness */
126};
127
128/* frame structure */
129struct zr364xx_framei {
130 unsigned long ulState; /* ulState:ZR364XX_READ_IDLE,
131 ZR364XX_READ_FRAME */
132 void *lpvbits; /* image data */
133 unsigned long cur_size; /* current data copied to it */
134};
135
136/* image buffer structure */
137struct zr364xx_bufferi {
138 unsigned long dwFrames; /* number of frames in buffer */
139 struct zr364xx_framei frame[FRAMES]; /* array of FRAME structures */
140};
141
142struct zr364xx_dmaqueue {
143 struct list_head active;
144 struct zr364xx_camera *cam;
145};
146
147struct zr364xx_pipeinfo {
148 u32 transfer_size;
149 u8 *transfer_buffer;
150 u32 state;
151 void *stream_urb;
152 void *cam; /* back pointer to zr364xx_camera struct */
153 u32 err_count;
154 u32 idx;
155};
156
157struct zr364xx_fmt {
158 char *name;
159 u32 fourcc;
160 int depth;
161};
162
163/* image formats. */
164static const struct zr364xx_fmt formats[] = {
165 {
166 .name = "JPG",
167 .fourcc = V4L2_PIX_FMT_JPEG,
168 .depth = 24
169 }
170};
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300171
172/* Camera stuff */
173struct zr364xx_camera {
174 struct usb_device *udev; /* save off the usb device pointer */
175 struct usb_interface *interface;/* the interface for this device */
176 struct video_device *vdev; /* v4l video device */
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300177 int nb;
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300178 struct zr364xx_bufferi buffer;
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300179 int skip;
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300180 int width;
181 int height;
182 int method;
183 struct mutex lock;
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300184 struct mutex open_lock;
Antoine Jacquet33d27a42008-08-18 17:14:30 -0300185 int users;
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300186
187 spinlock_t slock;
188 struct zr364xx_dmaqueue vidq;
189 int resources;
190 int last_frame;
191 int cur_frame;
192 unsigned long frame_count;
193 int b_acquire;
194 struct zr364xx_pipeinfo pipe[1];
195
196 u8 read_endpoint;
197
198 const struct zr364xx_fmt *fmt;
199 struct videobuf_queue vb_vidq;
200 enum v4l2_buf_type type;
201 struct zr364xx_mode mode;
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300202};
203
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300204/* buffer for one video frame */
205struct zr364xx_buffer {
206 /* common v4l buffer stuff -- must be first */
207 struct videobuf_buffer vb;
208 const struct zr364xx_fmt *fmt;
209};
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300210
211/* function used to send initialisation commands to the camera */
212static int send_control_msg(struct usb_device *udev, u8 request, u16 value,
213 u16 index, unsigned char *cp, u16 size)
214{
215 int status;
216
217 unsigned char *transfer_buffer = kmalloc(size, GFP_KERNEL);
218 if (!transfer_buffer) {
Greg Kroah-Hartmana482f322008-10-10 05:08:23 -0300219 dev_err(&udev->dev, "kmalloc(%d) failed\n", size);
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300220 return -ENOMEM;
221 }
222
223 memcpy(transfer_buffer, cp, size);
224
225 status = usb_control_msg(udev,
226 usb_sndctrlpipe(udev, 0),
227 request,
228 USB_DIR_OUT | USB_TYPE_VENDOR |
229 USB_RECIP_DEVICE, value, index,
230 transfer_buffer, size, CTRL_TIMEOUT);
231
232 kfree(transfer_buffer);
233
234 if (status < 0)
Greg Kroah-Hartmana482f322008-10-10 05:08:23 -0300235 dev_err(&udev->dev,
236 "Failed sending control message, error %d.\n", status);
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300237
238 return status;
239}
240
241
242/* Control messages sent to the camera to initialize it
243 * and launch the capture */
244typedef struct {
245 unsigned int value;
246 unsigned int size;
247 unsigned char *bytes;
248} message;
249
250/* method 0 */
251static unsigned char m0d1[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
252static unsigned char m0d2[] = { 0, 0, 0, 0, 0, 0 };
253static unsigned char m0d3[] = { 0, 0 };
254static message m0[] = {
255 {0x1f30, 0, NULL},
256 {0xd000, 0, NULL},
257 {0x3370, sizeof(m0d1), m0d1},
258 {0x2000, 0, NULL},
259 {0x2f0f, 0, NULL},
260 {0x2610, sizeof(m0d2), m0d2},
261 {0xe107, 0, NULL},
262 {0x2502, 0, NULL},
263 {0x1f70, 0, NULL},
264 {0xd000, 0, NULL},
265 {0x9a01, sizeof(m0d3), m0d3},
266 {-1, -1, NULL}
267};
268
269/* method 1 */
270static unsigned char m1d1[] = { 0xff, 0xff };
271static unsigned char m1d2[] = { 0x00, 0x00 };
272static message m1[] = {
273 {0x1f30, 0, NULL},
274 {0xd000, 0, NULL},
275 {0xf000, 0, NULL},
276 {0x2000, 0, NULL},
277 {0x2f0f, 0, NULL},
278 {0x2650, 0, NULL},
279 {0xe107, 0, NULL},
280 {0x2502, sizeof(m1d1), m1d1},
281 {0x1f70, 0, NULL},
282 {0xd000, 0, NULL},
283 {0xd000, 0, NULL},
284 {0xd000, 0, NULL},
285 {0x9a01, sizeof(m1d2), m1d2},
286 {-1, -1, NULL}
287};
288
289/* method 2 */
290static unsigned char m2d1[] = { 0xff, 0xff };
291static message m2[] = {
292 {0x1f30, 0, NULL},
293 {0xf000, 0, NULL},
294 {0x2000, 0, NULL},
295 {0x2f0f, 0, NULL},
296 {0x2650, 0, NULL},
297 {0xe107, 0, NULL},
298 {0x2502, sizeof(m2d1), m2d1},
299 {0x1f70, 0, NULL},
300 {-1, -1, NULL}
301};
302
303/* init table */
Antoine Jacquet08135ba2009-12-27 18:22:05 -0300304static message *init[4] = { m0, m1, m2, m2 };
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300305
306
307/* JPEG static data in header (Huffman table, etc) */
308static unsigned char header1[] = {
309 0xFF, 0xD8,
310 /*
311 0xFF, 0xE0, 0x00, 0x10, 'J', 'F', 'I', 'F',
312 0x00, 0x01, 0x01, 0x00, 0x33, 0x8A, 0x00, 0x00, 0x33, 0x88,
313 */
314 0xFF, 0xDB, 0x00, 0x84
315};
316static unsigned char header2[] = {
317 0xFF, 0xC4, 0x00, 0x1F, 0x00, 0x00, 0x01, 0x05, 0x01, 0x01, 0x01,
318 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
319 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
320 0xFF, 0xC4, 0x00, 0xB5, 0x10, 0x00, 0x02, 0x01, 0x03, 0x03, 0x02,
321 0x04, 0x03, 0x05, 0x05, 0x04, 0x04, 0x00, 0x00, 0x01, 0x7D, 0x01,
322 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06,
323 0x13, 0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xA1,
324 0x08, 0x23, 0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1, 0xF0, 0x24, 0x33,
325 0x62, 0x72, 0x82, 0x09, 0x0A, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x25,
326 0x26, 0x27, 0x28, 0x29, 0x2A, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
327 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54,
328 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67,
329 0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A,
330 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94,
331 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6,
332 0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8,
333 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA,
334 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE1, 0xE2,
335 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF1, 0xF2, 0xF3,
336 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFF, 0xC4, 0x00, 0x1F,
337 0x01, 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
338 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04,
339 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0xFF, 0xC4, 0x00, 0xB5,
340 0x11, 0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, 0x07, 0x05,
341 0x04, 0x04, 0x00, 0x01, 0x02, 0x77, 0x00, 0x01, 0x02, 0x03, 0x11,
342 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
343 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xA1, 0xB1, 0xC1,
344 0x09, 0x23, 0x33, 0x52, 0xF0, 0x15, 0x62, 0x72, 0xD1, 0x0A, 0x16,
345 0x24, 0x34, 0xE1, 0x25, 0xF1, 0x17, 0x18, 0x19, 0x1A, 0x26, 0x27,
346 0x28, 0x29, 0x2A, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44,
347 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57,
348 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A,
349 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x82, 0x83, 0x84,
350 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96,
351 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8,
352 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA,
353 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3,
354 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE2, 0xE3, 0xE4, 0xE5,
355 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
356 0xF8, 0xF9, 0xFA, 0xFF, 0xC0, 0x00, 0x11, 0x08, 0x00, 0xF0, 0x01,
357 0x40, 0x03, 0x01, 0x21, 0x00, 0x02, 0x11, 0x01, 0x03, 0x11, 0x01,
358 0xFF, 0xDA, 0x00, 0x0C, 0x03, 0x01, 0x00, 0x02, 0x11, 0x03, 0x11,
359 0x00, 0x3F, 0x00
360};
361static unsigned char header3;
362
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300363/* ------------------------------------------------------------------
364 Videobuf operations
365 ------------------------------------------------------------------*/
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300366
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300367static int buffer_setup(struct videobuf_queue *vq, unsigned int *count,
368 unsigned int *size)
369{
370 struct zr364xx_camera *cam = vq->priv_data;
371
372 *size = cam->width * cam->height * (cam->fmt->depth >> 3);
373
374 if (*count == 0)
375 *count = ZR364XX_DEF_BUFS;
376
Andreas Bombedab7e312010-03-21 16:02:45 -0300377 if (*size * *count > ZR364XX_DEF_BUFS * 1024 * 1024)
378 *count = (ZR364XX_DEF_BUFS * 1024 * 1024) / *size;
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300379
380 return 0;
381}
382
383static void free_buffer(struct videobuf_queue *vq, struct zr364xx_buffer *buf)
384{
Lamarque Vieira Souza76594c52009-07-22 16:54:51 -0300385 _DBG("%s\n", __func__);
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300386
387 if (in_interrupt())
388 BUG();
389
390 videobuf_vmalloc_free(&buf->vb);
391 buf->vb.state = VIDEOBUF_NEEDS_INIT;
392}
393
394static int buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
395 enum v4l2_field field)
396{
397 struct zr364xx_camera *cam = vq->priv_data;
398 struct zr364xx_buffer *buf = container_of(vb, struct zr364xx_buffer,
399 vb);
400 int rc;
401
402 DBG("%s, field=%d, fmt name = %s\n", __func__, field, cam->fmt != NULL ?
403 cam->fmt->name : "");
404 if (cam->fmt == NULL)
405 return -EINVAL;
406
407 buf->vb.size = cam->width * cam->height * (cam->fmt->depth >> 3);
408
409 if (buf->vb.baddr != 0 && buf->vb.bsize < buf->vb.size) {
410 DBG("invalid buffer prepare\n");
411 return -EINVAL;
412 }
413
414 buf->fmt = cam->fmt;
415 buf->vb.width = cam->width;
416 buf->vb.height = cam->height;
417 buf->vb.field = field;
418
419 if (buf->vb.state == VIDEOBUF_NEEDS_INIT) {
420 rc = videobuf_iolock(vq, &buf->vb, NULL);
421 if (rc < 0)
422 goto fail;
423 }
424
425 buf->vb.state = VIDEOBUF_PREPARED;
426 return 0;
427fail:
428 free_buffer(vq, buf);
429 return rc;
430}
431
432static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
433{
434 struct zr364xx_buffer *buf = container_of(vb, struct zr364xx_buffer,
435 vb);
436 struct zr364xx_camera *cam = vq->priv_data;
437
Lamarque Vieira Souza76594c52009-07-22 16:54:51 -0300438 _DBG("%s\n", __func__);
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300439
440 buf->vb.state = VIDEOBUF_QUEUED;
441 list_add_tail(&buf->vb.queue, &cam->vidq.active);
442}
443
444static void buffer_release(struct videobuf_queue *vq,
445 struct videobuf_buffer *vb)
446{
447 struct zr364xx_buffer *buf = container_of(vb, struct zr364xx_buffer,
448 vb);
449
Lamarque Vieira Souza76594c52009-07-22 16:54:51 -0300450 _DBG("%s\n", __func__);
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300451 free_buffer(vq, buf);
452}
453
454static struct videobuf_queue_ops zr364xx_video_qops = {
455 .buf_setup = buffer_setup,
456 .buf_prepare = buffer_prepare,
457 .buf_queue = buffer_queue,
458 .buf_release = buffer_release,
459};
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300460
461/********************/
462/* V4L2 integration */
463/********************/
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300464static int zr364xx_vidioc_streamon(struct file *file, void *priv,
465 enum v4l2_buf_type type);
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300466
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300467static ssize_t zr364xx_read(struct file *file, char __user *buf, size_t count,
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300468 loff_t * ppos)
469{
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300470 struct zr364xx_camera *cam = video_drvdata(file);
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300471
Lamarque Vieira Souza76594c52009-07-22 16:54:51 -0300472 _DBG("%s\n", __func__);
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300473
474 if (!buf)
475 return -EINVAL;
476
477 if (!count)
478 return -EINVAL;
479
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300480 if (cam->type == V4L2_BUF_TYPE_VIDEO_CAPTURE &&
481 zr364xx_vidioc_streamon(file, cam, cam->type) == 0) {
482 DBG("%s: reading %d bytes at pos %d.\n", __func__, (int) count,
483 (int) *ppos);
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300484
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300485 /* NoMan Sux ! */
486 return videobuf_read_one(&cam->vb_vidq, buf, count, ppos,
487 file->f_flags & O_NONBLOCK);
488 }
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300489
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300490 return 0;
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300491}
492
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300493/* video buffer vmalloc implementation based partly on VIVI driver which is
494 * Copyright (c) 2006 by
495 * Mauro Carvalho Chehab <mchehab--a.t--infradead.org>
496 * Ted Walther <ted--a.t--enumera.com>
497 * John Sokol <sokol--a.t--videotechnology.com>
498 * http://v4l.videotechnology.com/
499 *
500 */
501static void zr364xx_fillbuff(struct zr364xx_camera *cam,
502 struct zr364xx_buffer *buf,
503 int jpgsize)
504{
505 int pos = 0;
506 struct timeval ts;
507 const char *tmpbuf;
508 char *vbuf = videobuf_to_vmalloc(&buf->vb);
509 unsigned long last_frame;
510 struct zr364xx_framei *frm;
511
512 if (!vbuf)
513 return;
514
515 last_frame = cam->last_frame;
516 if (last_frame != -1) {
517 frm = &cam->buffer.frame[last_frame];
518 tmpbuf = (const char *)cam->buffer.frame[last_frame].lpvbits;
519 switch (buf->fmt->fourcc) {
520 case V4L2_PIX_FMT_JPEG:
521 buf->vb.size = jpgsize;
522 memcpy(vbuf, tmpbuf, buf->vb.size);
523 break;
524 default:
525 printk(KERN_DEBUG KBUILD_MODNAME ": unknown format?\n");
526 }
527 cam->last_frame = -1;
528 } else {
529 printk(KERN_ERR KBUILD_MODNAME ": =======no frame\n");
530 return;
531 }
532 DBG("%s: Buffer 0x%08lx size= %d\n", __func__,
533 (unsigned long)vbuf, pos);
534 /* tell v4l buffer was filled */
535
536 buf->vb.field_count = cam->frame_count * 2;
537 do_gettimeofday(&ts);
538 buf->vb.ts = ts;
539 buf->vb.state = VIDEOBUF_DONE;
540}
541
542static int zr364xx_got_frame(struct zr364xx_camera *cam, int jpgsize)
543{
544 struct zr364xx_dmaqueue *dma_q = &cam->vidq;
545 struct zr364xx_buffer *buf;
546 unsigned long flags = 0;
547 int rc = 0;
548
549 DBG("wakeup: %p\n", &dma_q);
550 spin_lock_irqsave(&cam->slock, flags);
551
552 if (list_empty(&dma_q->active)) {
553 DBG("No active queue to serve\n");
554 rc = -1;
555 goto unlock;
556 }
557 buf = list_entry(dma_q->active.next,
558 struct zr364xx_buffer, vb.queue);
559
560 if (!waitqueue_active(&buf->vb.done)) {
561 /* no one active */
562 rc = -1;
563 goto unlock;
564 }
565 list_del(&buf->vb.queue);
566 do_gettimeofday(&buf->vb.ts);
567 DBG("[%p/%d] wakeup\n", buf, buf->vb.i);
568 zr364xx_fillbuff(cam, buf, jpgsize);
569 wake_up(&buf->vb.done);
570 DBG("wakeup [buf/i] [%p/%d]\n", buf, buf->vb.i);
571unlock:
572 spin_unlock_irqrestore(&cam->slock, flags);
Julia Lawall30538142010-08-16 13:27:47 -0300573 return rc;
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300574}
575
576/* this function moves the usb stream read pipe data
577 * into the system buffers.
578 * returns 0 on success, EAGAIN if more data to process (call this
579 * function again).
580 */
581static int zr364xx_read_video_callback(struct zr364xx_camera *cam,
582 struct zr364xx_pipeinfo *pipe_info,
583 struct urb *purb)
584{
585 unsigned char *pdest;
586 unsigned char *psrc;
587 s32 idx = -1;
588 struct zr364xx_framei *frm;
589 int i = 0;
590 unsigned char *ptr = NULL;
591
Lamarque Vieira Souza76594c52009-07-22 16:54:51 -0300592 _DBG("buffer to user\n");
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300593 idx = cam->cur_frame;
594 frm = &cam->buffer.frame[idx];
595
596 /* swap bytes if camera needs it */
597 if (cam->method == METHOD0) {
598 u16 *buf = (u16 *)pipe_info->transfer_buffer;
599 for (i = 0; i < purb->actual_length/2; i++)
600 swab16s(buf + i);
601 }
602
603 /* search done. now find out if should be acquiring */
604 if (!cam->b_acquire) {
605 /* we found a frame, but this channel is turned off */
606 frm->ulState = ZR364XX_READ_IDLE;
607 return -EINVAL;
608 }
609
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300610 psrc = (u8 *)pipe_info->transfer_buffer;
611 ptr = pdest = frm->lpvbits;
612
613 if (frm->ulState == ZR364XX_READ_IDLE) {
614 frm->ulState = ZR364XX_READ_FRAME;
615 frm->cur_size = 0;
616
Lamarque Vieira Souza76594c52009-07-22 16:54:51 -0300617 _DBG("jpeg header, ");
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300618 memcpy(ptr, header1, sizeof(header1));
619 ptr += sizeof(header1);
620 header3 = 0;
621 memcpy(ptr, &header3, 1);
622 ptr++;
623 memcpy(ptr, psrc, 64);
624 ptr += 64;
625 header3 = 1;
626 memcpy(ptr, &header3, 1);
627 ptr++;
628 memcpy(ptr, psrc + 64, 64);
629 ptr += 64;
630 memcpy(ptr, header2, sizeof(header2));
631 ptr += sizeof(header2);
632 memcpy(ptr, psrc + 128,
633 purb->actual_length - 128);
634 ptr += purb->actual_length - 128;
Lamarque Vieira Souza76594c52009-07-22 16:54:51 -0300635 _DBG("header : %d %d %d %d %d %d %d %d %d\n",
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300636 psrc[0], psrc[1], psrc[2],
637 psrc[3], psrc[4], psrc[5],
638 psrc[6], psrc[7], psrc[8]);
639 frm->cur_size = ptr - pdest;
640 } else {
Lamarque Vieira Souza76594c52009-07-22 16:54:51 -0300641 if (frm->cur_size + purb->actual_length > MAX_FRAME_SIZE) {
642 dev_info(&cam->udev->dev,
643 "%s: buffer (%d bytes) too small to hold "
644 "frame data. Discarding frame data.\n",
645 __func__, MAX_FRAME_SIZE);
646 } else {
647 pdest += frm->cur_size;
648 memcpy(pdest, psrc, purb->actual_length);
649 frm->cur_size += purb->actual_length;
650 }
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300651 }
Lamarque Vieira Souza76594c52009-07-22 16:54:51 -0300652 /*_DBG("cur_size %lu urb size %d\n", frm->cur_size,
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300653 purb->actual_length);*/
654
655 if (purb->actual_length < pipe_info->transfer_size) {
Lamarque Vieira Souza76594c52009-07-22 16:54:51 -0300656 _DBG("****************Buffer[%d]full*************\n", idx);
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300657 cam->last_frame = cam->cur_frame;
658 cam->cur_frame++;
659 /* end of system frame ring buffer, start at zero */
660 if (cam->cur_frame == cam->buffer.dwFrames)
661 cam->cur_frame = 0;
662
663 /* frame ready */
664 /* go back to find the JPEG EOI marker */
665 ptr = pdest = frm->lpvbits;
666 ptr += frm->cur_size - 2;
667 while (ptr > pdest) {
668 if (*ptr == 0xFF && *(ptr + 1) == 0xD9
669 && *(ptr + 2) == 0xFF)
670 break;
671 ptr--;
672 }
673 if (ptr == pdest)
674 DBG("No EOI marker\n");
675
676 /* Sometimes there is junk data in the middle of the picture,
677 * we want to skip this bogus frames */
678 while (ptr > pdest) {
679 if (*ptr == 0xFF && *(ptr + 1) == 0xFF
680 && *(ptr + 2) == 0xFF)
681 break;
682 ptr--;
683 }
684 if (ptr != pdest) {
685 DBG("Bogus frame ? %d\n", ++(cam->nb));
686 } else if (cam->b_acquire) {
687 /* we skip the 2 first frames which are usually buggy */
688 if (cam->skip)
689 cam->skip--;
690 else {
Lamarque Vieira Souza76594c52009-07-22 16:54:51 -0300691 _DBG("jpeg(%lu): %d %d %d %d %d %d %d %d\n",
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300692 frm->cur_size,
693 pdest[0], pdest[1], pdest[2], pdest[3],
694 pdest[4], pdest[5], pdest[6], pdest[7]);
695
696 zr364xx_got_frame(cam, frm->cur_size);
697 }
698 }
699 cam->frame_count++;
700 frm->ulState = ZR364XX_READ_IDLE;
701 frm->cur_size = 0;
702 }
703 /* done successfully */
704 return 0;
705}
706
707static int res_get(struct zr364xx_camera *cam)
708{
709 /* is it free? */
710 mutex_lock(&cam->lock);
711 if (cam->resources) {
712 /* no, someone else uses it */
713 mutex_unlock(&cam->lock);
714 return 0;
715 }
716 /* it's free, grab it */
717 cam->resources = 1;
Lamarque Vieira Souza76594c52009-07-22 16:54:51 -0300718 _DBG("res: get\n");
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300719 mutex_unlock(&cam->lock);
720 return 1;
721}
722
723static inline int res_check(struct zr364xx_camera *cam)
724{
725 return cam->resources;
726}
727
728static void res_free(struct zr364xx_camera *cam)
729{
730 mutex_lock(&cam->lock);
731 cam->resources = 0;
732 mutex_unlock(&cam->lock);
Lamarque Vieira Souza76594c52009-07-22 16:54:51 -0300733 _DBG("res: put\n");
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300734}
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300735
736static int zr364xx_vidioc_querycap(struct file *file, void *priv,
737 struct v4l2_capability *cap)
738{
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300739 struct zr364xx_camera *cam = video_drvdata(file);
740
741 strlcpy(cap->driver, DRIVER_DESC, sizeof(cap->driver));
742 strlcpy(cap->card, cam->udev->product, sizeof(cap->card));
743 strlcpy(cap->bus_info, dev_name(&cam->udev->dev),
744 sizeof(cap->bus_info));
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300745 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
746 V4L2_CAP_READWRITE |
747 V4L2_CAP_STREAMING;
748
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300749 return 0;
750}
751
752static int zr364xx_vidioc_enum_input(struct file *file, void *priv,
753 struct v4l2_input *i)
754{
755 if (i->index != 0)
756 return -EINVAL;
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300757 strcpy(i->name, DRIVER_DESC " Camera");
758 i->type = V4L2_INPUT_TYPE_CAMERA;
759 return 0;
760}
761
762static int zr364xx_vidioc_g_input(struct file *file, void *priv,
763 unsigned int *i)
764{
765 *i = 0;
766 return 0;
767}
768
769static int zr364xx_vidioc_s_input(struct file *file, void *priv,
770 unsigned int i)
771{
772 if (i != 0)
773 return -EINVAL;
774 return 0;
775}
776
777static int zr364xx_vidioc_queryctrl(struct file *file, void *priv,
778 struct v4l2_queryctrl *c)
779{
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300780 struct zr364xx_camera *cam;
781
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300782 if (file == NULL)
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300783 return -ENODEV;
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300784 cam = video_drvdata(file);
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300785
786 switch (c->id) {
787 case V4L2_CID_BRIGHTNESS:
788 c->type = V4L2_CTRL_TYPE_INTEGER;
789 strcpy(c->name, "Brightness");
790 c->minimum = 0;
791 c->maximum = 127;
792 c->step = 1;
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300793 c->default_value = cam->mode.brightness;
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300794 c->flags = 0;
795 break;
796 default:
797 return -EINVAL;
798 }
799 return 0;
800}
801
802static int zr364xx_vidioc_s_ctrl(struct file *file, void *priv,
803 struct v4l2_control *c)
804{
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300805 struct zr364xx_camera *cam;
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300806 int temp;
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300807
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300808 if (file == NULL)
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300809 return -ENODEV;
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300810 cam = video_drvdata(file);
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300811
812 switch (c->id) {
813 case V4L2_CID_BRIGHTNESS:
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300814 cam->mode.brightness = c->value;
815 /* hardware brightness */
816 mutex_lock(&cam->lock);
817 send_control_msg(cam->udev, 1, 0x2001, 0, NULL, 0);
818 temp = (0x60 << 8) + 127 - cam->mode.brightness;
819 send_control_msg(cam->udev, 1, temp, 0, NULL, 0);
820 mutex_unlock(&cam->lock);
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300821 break;
822 default:
823 return -EINVAL;
824 }
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300825
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300826 return 0;
827}
828
829static int zr364xx_vidioc_g_ctrl(struct file *file, void *priv,
830 struct v4l2_control *c)
831{
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300832 struct zr364xx_camera *cam;
833
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300834 if (file == NULL)
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300835 return -ENODEV;
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300836 cam = video_drvdata(file);
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300837
838 switch (c->id) {
839 case V4L2_CID_BRIGHTNESS:
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300840 c->value = cam->mode.brightness;
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300841 break;
842 default:
843 return -EINVAL;
844 }
845 return 0;
846}
847
Hans Verkuil78b526a2008-05-28 12:16:41 -0300848static int zr364xx_vidioc_enum_fmt_vid_cap(struct file *file,
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300849 void *priv, struct v4l2_fmtdesc *f)
850{
851 if (f->index > 0)
852 return -EINVAL;
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300853 f->flags = V4L2_FMT_FLAG_COMPRESSED;
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300854 strcpy(f->description, formats[0].name);
855 f->pixelformat = formats[0].fourcc;
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300856 return 0;
857}
858
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300859static char *decode_fourcc(__u32 pixelformat, char *buf)
860{
861 buf[0] = pixelformat & 0xff;
862 buf[1] = (pixelformat >> 8) & 0xff;
863 buf[2] = (pixelformat >> 16) & 0xff;
864 buf[3] = (pixelformat >> 24) & 0xff;
865 buf[4] = '\0';
866 return buf;
867}
868
Hans Verkuil78b526a2008-05-28 12:16:41 -0300869static int zr364xx_vidioc_try_fmt_vid_cap(struct file *file, void *priv,
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300870 struct v4l2_format *f)
871{
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300872 struct zr364xx_camera *cam = video_drvdata(file);
873 char pixelformat_name[5];
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300874
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300875 if (cam == NULL)
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300876 return -ENODEV;
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300877
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300878 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_JPEG) {
879 DBG("%s: unsupported pixelformat V4L2_PIX_FMT_%s\n", __func__,
880 decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name));
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300881 return -EINVAL;
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300882 }
883
Lamarque Vieira Souza8c5f32a2009-07-20 20:46:42 -0300884 if (!(f->fmt.pix.width == 160 && f->fmt.pix.height == 120) &&
885 !(f->fmt.pix.width == 640 && f->fmt.pix.height == 480)) {
886 f->fmt.pix.width = 320;
887 f->fmt.pix.height = 240;
888 }
889
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300890 f->fmt.pix.field = V4L2_FIELD_NONE;
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300891 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
892 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
893 f->fmt.pix.colorspace = 0;
894 f->fmt.pix.priv = 0;
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300895 DBG("%s: V4L2_PIX_FMT_%s (%d) ok!\n", __func__,
896 decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name),
897 f->fmt.pix.field);
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300898 return 0;
899}
900
Hans Verkuil78b526a2008-05-28 12:16:41 -0300901static int zr364xx_vidioc_g_fmt_vid_cap(struct file *file, void *priv,
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300902 struct v4l2_format *f)
903{
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300904 struct zr364xx_camera *cam;
905
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300906 if (file == NULL)
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300907 return -ENODEV;
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300908 cam = video_drvdata(file);
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300909
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300910 f->fmt.pix.pixelformat = formats[0].fourcc;
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300911 f->fmt.pix.field = V4L2_FIELD_NONE;
912 f->fmt.pix.width = cam->width;
913 f->fmt.pix.height = cam->height;
914 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
915 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
916 f->fmt.pix.colorspace = 0;
917 f->fmt.pix.priv = 0;
918 return 0;
919}
920
Hans Verkuil78b526a2008-05-28 12:16:41 -0300921static int zr364xx_vidioc_s_fmt_vid_cap(struct file *file, void *priv,
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300922 struct v4l2_format *f)
923{
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300924 struct zr364xx_camera *cam = video_drvdata(file);
925 struct videobuf_queue *q = &cam->vb_vidq;
926 char pixelformat_name[5];
927 int ret = zr364xx_vidioc_try_fmt_vid_cap(file, cam, f);
Lamarque Vieira Souza8c5f32a2009-07-20 20:46:42 -0300928 int i;
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300929
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300930 if (ret < 0)
931 return ret;
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300932
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300933 mutex_lock(&q->vb_lock);
934
935 if (videobuf_queue_is_busy(&cam->vb_vidq)) {
936 DBG("%s queue busy\n", __func__);
937 ret = -EBUSY;
938 goto out;
939 }
940
Lamarque Vieira Souza8c5f32a2009-07-20 20:46:42 -0300941 if (res_check(cam)) {
942 DBG("%s can't change format after started\n", __func__);
943 ret = -EBUSY;
944 goto out;
945 }
946
947 cam->width = f->fmt.pix.width;
948 cam->height = f->fmt.pix.height;
949 dev_info(&cam->udev->dev, "%s: %dx%d mode selected\n", __func__,
950 cam->width, cam->height);
Antoine Jacquetb7eee612007-04-27 12:30:59 -0300951 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
952 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
953 f->fmt.pix.colorspace = 0;
954 f->fmt.pix.priv = 0;
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -0300955 cam->vb_vidq.field = f->fmt.pix.field;
956 cam->mode.color = V4L2_PIX_FMT_JPEG;
Lamarque Vieira Souza8c5f32a2009-07-20 20:46:42 -0300957
958 if (f->fmt.pix.width == 160 && f->fmt.pix.height == 120)
959 mode = 1;
960 else if (f->fmt.pix.width == 640 && f->fmt.pix.height == 480)
961 mode = 2;
962 else
963 mode = 0;
964
965 m0d1[0] = mode;
966 m1[2].value = 0xf000 + mode;
967 m2[1].value = 0xf000 + mode;
Antoine Jacquet08135ba2009-12-27 18:22:05 -0300968
969 /* special case for METHOD3, the modes are different */
970 if (cam->method == METHOD3) {
971 switch (mode) {
972 case 1:
973 m2[1].value = 0xf000 + 4;
974 break;
975 case 2:
976 m2[1].value = 0xf000 + 0;
977 break;
978 default:
979 m2[1].value = 0xf000 + 1;
980 break;
981 }
982 }
983
Lamarque Vieira Souza8c5f32a2009-07-20 20:46:42 -0300984 header2[437] = cam->height / 256;
985 header2[438] = cam->height % 256;
986 header2[439] = cam->width / 256;
987 header2[440] = cam->width % 256;
988
989 for (i = 0; init[cam->method][i].size != -1; i++) {
990 ret =
991 send_control_msg(cam->udev, 1, init[cam->method][i].value,
992 0, init[cam->method][i].bytes,
993 init[cam->method][i].size);
994 if (ret < 0) {
995 dev_err(&cam->udev->dev,
996 "error during resolution change sequence: %d\n", i);
997 goto out;
998 }
999 }
1000
1001 /* Added some delay here, since opening/closing the camera quickly,
1002 * like Ekiga does during its startup, can crash the webcam
1003 */
1004 mdelay(100);
1005 cam->skip = 2;
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001006 ret = 0;
1007
1008out:
1009 mutex_unlock(&q->vb_lock);
1010
1011 DBG("%s: V4L2_PIX_FMT_%s (%d) ok!\n", __func__,
1012 decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name),
1013 f->fmt.pix.field);
1014 return ret;
1015}
1016
1017static int zr364xx_vidioc_reqbufs(struct file *file, void *priv,
1018 struct v4l2_requestbuffers *p)
1019{
1020 int rc;
1021 struct zr364xx_camera *cam = video_drvdata(file);
1022 rc = videobuf_reqbufs(&cam->vb_vidq, p);
1023 return rc;
1024}
1025
1026static int zr364xx_vidioc_querybuf(struct file *file,
1027 void *priv,
1028 struct v4l2_buffer *p)
1029{
1030 int rc;
1031 struct zr364xx_camera *cam = video_drvdata(file);
1032 rc = videobuf_querybuf(&cam->vb_vidq, p);
1033 return rc;
1034}
1035
1036static int zr364xx_vidioc_qbuf(struct file *file,
1037 void *priv,
1038 struct v4l2_buffer *p)
1039{
1040 int rc;
1041 struct zr364xx_camera *cam = video_drvdata(file);
Lamarque Vieira Souza76594c52009-07-22 16:54:51 -03001042 _DBG("%s\n", __func__);
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001043 rc = videobuf_qbuf(&cam->vb_vidq, p);
1044 return rc;
1045}
1046
1047static int zr364xx_vidioc_dqbuf(struct file *file,
1048 void *priv,
1049 struct v4l2_buffer *p)
1050{
1051 int rc;
1052 struct zr364xx_camera *cam = video_drvdata(file);
Lamarque Vieira Souza76594c52009-07-22 16:54:51 -03001053 _DBG("%s\n", __func__);
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001054 rc = videobuf_dqbuf(&cam->vb_vidq, p, file->f_flags & O_NONBLOCK);
1055 return rc;
1056}
1057
1058static void read_pipe_completion(struct urb *purb)
1059{
1060 struct zr364xx_pipeinfo *pipe_info;
1061 struct zr364xx_camera *cam;
1062 int pipe;
1063
1064 pipe_info = purb->context;
Lamarque Vieira Souza76594c52009-07-22 16:54:51 -03001065 _DBG("%s %p, status %d\n", __func__, purb, purb->status);
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001066 if (pipe_info == NULL) {
1067 printk(KERN_ERR KBUILD_MODNAME ": no context!\n");
1068 return;
1069 }
1070
1071 cam = pipe_info->cam;
1072 if (cam == NULL) {
1073 printk(KERN_ERR KBUILD_MODNAME ": no context!\n");
1074 return;
1075 }
1076
1077 /* if shutting down, do not resubmit, exit immediately */
1078 if (purb->status == -ESHUTDOWN) {
1079 DBG("%s, err shutdown\n", __func__);
1080 pipe_info->err_count++;
1081 return;
1082 }
1083
1084 if (pipe_info->state == 0) {
1085 DBG("exiting USB pipe\n");
1086 return;
1087 }
1088
1089 if (purb->actual_length < 0 ||
1090 purb->actual_length > pipe_info->transfer_size) {
1091 dev_err(&cam->udev->dev, "wrong number of bytes\n");
1092 return;
1093 }
1094
1095 if (purb->status == 0)
1096 zr364xx_read_video_callback(cam, pipe_info, purb);
1097 else {
1098 pipe_info->err_count++;
1099 DBG("%s: failed URB %d\n", __func__, purb->status);
1100 }
1101
1102 pipe = usb_rcvbulkpipe(cam->udev, cam->read_endpoint);
1103
1104 /* reuse urb */
1105 usb_fill_bulk_urb(pipe_info->stream_urb, cam->udev,
1106 pipe,
1107 pipe_info->transfer_buffer,
1108 pipe_info->transfer_size,
1109 read_pipe_completion, pipe_info);
1110
1111 if (pipe_info->state != 0) {
1112 purb->status = usb_submit_urb(pipe_info->stream_urb,
1113 GFP_ATOMIC);
1114
1115 if (purb->status)
1116 dev_err(&cam->udev->dev,
1117 "error submitting urb (error=%i)\n",
1118 purb->status);
1119 } else
1120 DBG("read pipe complete state 0\n");
1121}
1122
1123static int zr364xx_start_readpipe(struct zr364xx_camera *cam)
1124{
1125 int pipe;
1126 int retval;
1127 struct zr364xx_pipeinfo *pipe_info = cam->pipe;
1128 pipe = usb_rcvbulkpipe(cam->udev, cam->read_endpoint);
1129 DBG("%s: start pipe IN x%x\n", __func__, cam->read_endpoint);
1130
1131 pipe_info->state = 1;
1132 pipe_info->err_count = 0;
1133 pipe_info->stream_urb = usb_alloc_urb(0, GFP_KERNEL);
1134 if (!pipe_info->stream_urb) {
1135 dev_err(&cam->udev->dev, "ReadStream: Unable to alloc URB\n");
1136 return -ENOMEM;
1137 }
1138 /* transfer buffer allocated in board_init */
1139 usb_fill_bulk_urb(pipe_info->stream_urb, cam->udev,
1140 pipe,
1141 pipe_info->transfer_buffer,
1142 pipe_info->transfer_size,
1143 read_pipe_completion, pipe_info);
1144
1145 DBG("submitting URB %p\n", pipe_info->stream_urb);
1146 retval = usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL);
1147 if (retval) {
1148 printk(KERN_ERR KBUILD_MODNAME ": start read pipe failed\n");
1149 return retval;
1150 }
1151
1152 return 0;
1153}
1154
1155static void zr364xx_stop_readpipe(struct zr364xx_camera *cam)
1156{
1157 struct zr364xx_pipeinfo *pipe_info;
1158
1159 if (cam == NULL) {
1160 printk(KERN_ERR KBUILD_MODNAME ": invalid device\n");
1161 return;
1162 }
1163 DBG("stop read pipe\n");
1164 pipe_info = cam->pipe;
1165 if (pipe_info) {
1166 if (pipe_info->state != 0)
1167 pipe_info->state = 0;
1168
1169 if (pipe_info->stream_urb) {
1170 /* cancel urb */
1171 usb_kill_urb(pipe_info->stream_urb);
1172 usb_free_urb(pipe_info->stream_urb);
1173 pipe_info->stream_urb = NULL;
1174 }
1175 }
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001176 return;
1177}
1178
1179/* starts acquisition process */
1180static int zr364xx_start_acquire(struct zr364xx_camera *cam)
1181{
1182 int j;
1183
1184 DBG("start acquire\n");
1185
1186 cam->last_frame = -1;
1187 cam->cur_frame = 0;
1188 for (j = 0; j < FRAMES; j++) {
1189 cam->buffer.frame[j].ulState = ZR364XX_READ_IDLE;
1190 cam->buffer.frame[j].cur_size = 0;
1191 }
Lamarque Vieira Souza8c5f32a2009-07-20 20:46:42 -03001192 cam->b_acquire = 1;
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001193 return 0;
1194}
1195
1196static inline int zr364xx_stop_acquire(struct zr364xx_camera *cam)
1197{
1198 cam->b_acquire = 0;
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001199 return 0;
1200}
1201
1202static int zr364xx_vidioc_streamon(struct file *file, void *priv,
1203 enum v4l2_buf_type type)
1204{
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001205 struct zr364xx_camera *cam = video_drvdata(file);
1206 int j;
1207 int res;
1208
1209 DBG("%s\n", __func__);
1210
1211 if (cam->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1212 dev_err(&cam->udev->dev, "invalid fh type0\n");
1213 return -EINVAL;
1214 }
1215 if (cam->type != type) {
1216 dev_err(&cam->udev->dev, "invalid fh type1\n");
1217 return -EINVAL;
1218 }
1219
1220 if (!res_get(cam)) {
1221 dev_err(&cam->udev->dev, "stream busy\n");
1222 return -EBUSY;
1223 }
1224
1225 cam->last_frame = -1;
1226 cam->cur_frame = 0;
1227 cam->frame_count = 0;
1228 for (j = 0; j < FRAMES; j++) {
1229 cam->buffer.frame[j].ulState = ZR364XX_READ_IDLE;
1230 cam->buffer.frame[j].cur_size = 0;
1231 }
1232 res = videobuf_streamon(&cam->vb_vidq);
1233 if (res == 0) {
1234 zr364xx_start_acquire(cam);
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001235 } else {
1236 res_free(cam);
1237 }
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001238 return res;
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001239}
1240
1241static int zr364xx_vidioc_streamoff(struct file *file, void *priv,
1242 enum v4l2_buf_type type)
1243{
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001244 int res;
1245 struct zr364xx_camera *cam = video_drvdata(file);
1246
1247 DBG("%s\n", __func__);
1248 if (cam->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1249 dev_err(&cam->udev->dev, "invalid fh type0\n");
1250 return -EINVAL;
1251 }
1252 if (cam->type != type) {
1253 dev_err(&cam->udev->dev, "invalid fh type1\n");
1254 return -EINVAL;
1255 }
1256 zr364xx_stop_acquire(cam);
1257 res = videobuf_streamoff(&cam->vb_vidq);
1258 if (res < 0)
1259 return res;
1260 res_free(cam);
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001261 return 0;
1262}
1263
1264
1265/* open the camera */
Hans Verkuilbec43662008-12-30 06:58:20 -03001266static int zr364xx_open(struct file *file)
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001267{
1268 struct video_device *vdev = video_devdata(file);
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001269 struct zr364xx_camera *cam = video_drvdata(file);
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001270 struct usb_device *udev = cam->udev;
1271 int i, err;
1272
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001273 DBG("%s\n", __func__);
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001274
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001275 mutex_lock(&cam->open_lock);
Antoine Jacquet69025c92008-08-18 17:09:53 -03001276
Antoine Jacquet33d27a42008-08-18 17:14:30 -03001277 if (cam->users) {
1278 err = -EBUSY;
Antoine Jacquet69025c92008-08-18 17:09:53 -03001279 goto out;
Antoine Jacquet33d27a42008-08-18 17:14:30 -03001280 }
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001281
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001282 for (i = 0; init[cam->method][i].size != -1; i++) {
1283 err =
1284 send_control_msg(udev, 1, init[cam->method][i].value,
1285 0, init[cam->method][i].bytes,
1286 init[cam->method][i].size);
1287 if (err < 0) {
Greg Kroah-Hartmana482f322008-10-10 05:08:23 -03001288 dev_err(&cam->udev->dev,
1289 "error during open sequence: %d\n", i);
Antoine Jacquet69025c92008-08-18 17:09:53 -03001290 goto out;
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001291 }
1292 }
1293
Antoine Jacquet33d27a42008-08-18 17:14:30 -03001294 cam->skip = 2;
1295 cam->users++;
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001296 file->private_data = vdev;
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001297 cam->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1298 cam->fmt = formats;
1299
1300 videobuf_queue_vmalloc_init(&cam->vb_vidq, &zr364xx_video_qops,
1301 NULL, &cam->slock,
1302 cam->type,
1303 V4L2_FIELD_NONE,
Hans Verkuil08bff032010-09-20 17:39:46 -03001304 sizeof(struct zr364xx_buffer), cam, NULL);
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001305
1306 /* Added some delay here, since opening/closing the camera quickly,
1307 * like Ekiga does during its startup, can crash the webcam
1308 */
1309 mdelay(100);
Antoine Jacquet69025c92008-08-18 17:09:53 -03001310 err = 0;
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001311
Antoine Jacquet69025c92008-08-18 17:09:53 -03001312out:
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001313 mutex_unlock(&cam->open_lock);
1314 DBG("%s: %d\n", __func__, err);
Antoine Jacquet69025c92008-08-18 17:09:53 -03001315 return err;
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001316}
1317
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001318static void zr364xx_destroy(struct zr364xx_camera *cam)
1319{
1320 unsigned long i;
1321
1322 if (!cam) {
1323 printk(KERN_ERR KBUILD_MODNAME ", %s: no device\n", __func__);
1324 return;
1325 }
1326 mutex_lock(&cam->open_lock);
1327 if (cam->vdev)
1328 video_unregister_device(cam->vdev);
1329 cam->vdev = NULL;
1330
1331 /* stops the read pipe if it is running */
1332 if (cam->b_acquire)
1333 zr364xx_stop_acquire(cam);
1334
1335 zr364xx_stop_readpipe(cam);
1336
1337 /* release sys buffers */
1338 for (i = 0; i < FRAMES; i++) {
1339 if (cam->buffer.frame[i].lpvbits) {
1340 DBG("vfree %p\n", cam->buffer.frame[i].lpvbits);
1341 vfree(cam->buffer.frame[i].lpvbits);
1342 }
1343 cam->buffer.frame[i].lpvbits = NULL;
1344 }
1345
1346 /* release transfer buffer */
1347 kfree(cam->pipe->transfer_buffer);
1348 cam->pipe->transfer_buffer = NULL;
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001349 mutex_unlock(&cam->open_lock);
1350 kfree(cam);
1351 cam = NULL;
1352}
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001353
1354/* release the camera */
Hans Verkuilbec43662008-12-30 06:58:20 -03001355static int zr364xx_release(struct file *file)
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001356{
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001357 struct zr364xx_camera *cam;
1358 struct usb_device *udev;
1359 int i, err;
1360
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001361 DBG("%s\n", __func__);
1362 cam = video_drvdata(file);
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001363
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001364 if (!cam)
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001365 return -ENODEV;
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001366
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001367 mutex_lock(&cam->open_lock);
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001368 udev = cam->udev;
1369
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001370 /* turn off stream */
1371 if (res_check(cam)) {
1372 if (cam->b_acquire)
1373 zr364xx_stop_acquire(cam);
1374 videobuf_streamoff(&cam->vb_vidq);
1375 res_free(cam);
1376 }
Antoine Jacquet33d27a42008-08-18 17:14:30 -03001377
1378 cam->users--;
1379 file->private_data = NULL;
1380
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001381 for (i = 0; i < 2; i++) {
1382 err =
1383 send_control_msg(udev, 1, init[cam->method][i].value,
Roel Kluin7b808922009-08-11 08:10:25 -03001384 0, init[cam->method][i].bytes,
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001385 init[cam->method][i].size);
1386 if (err < 0) {
Greg Kroah-Hartmana482f322008-10-10 05:08:23 -03001387 dev_err(&udev->dev, "error during release sequence\n");
Antoine Jacquet33d27a42008-08-18 17:14:30 -03001388 goto out;
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001389 }
1390 }
1391
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001392 /* Added some delay here, since opening/closing the camera quickly,
1393 * like Ekiga does during its startup, can crash the webcam
1394 */
1395 mdelay(100);
Antoine Jacquet33d27a42008-08-18 17:14:30 -03001396 err = 0;
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001397
Antoine Jacquet33d27a42008-08-18 17:14:30 -03001398out:
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001399 mutex_unlock(&cam->open_lock);
1400
Antoine Jacquet33d27a42008-08-18 17:14:30 -03001401 return err;
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001402}
1403
1404
1405static int zr364xx_mmap(struct file *file, struct vm_area_struct *vma)
1406{
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001407 struct zr364xx_camera *cam = video_drvdata(file);
1408 int ret;
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001409
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001410 if (cam == NULL) {
1411 DBG("%s: cam == NULL\n", __func__);
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001412 return -ENODEV;
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001413 }
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001414 DBG("mmap called, vma=0x%08lx\n", (unsigned long)vma);
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001415
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001416 ret = videobuf_mmap_mapper(&cam->vb_vidq, vma);
1417
1418 DBG("vma start=0x%08lx, size=%ld, ret=%d\n",
1419 (unsigned long)vma->vm_start,
1420 (unsigned long)vma->vm_end - (unsigned long)vma->vm_start, ret);
1421 return ret;
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001422}
1423
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001424static unsigned int zr364xx_poll(struct file *file,
1425 struct poll_table_struct *wait)
1426{
1427 struct zr364xx_camera *cam = video_drvdata(file);
1428 struct videobuf_queue *q = &cam->vb_vidq;
Lamarque Vieira Souza76594c52009-07-22 16:54:51 -03001429 _DBG("%s\n", __func__);
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001430
1431 if (cam->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1432 return POLLERR;
1433
1434 return videobuf_poll_stream(file, q, wait);
1435}
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001436
Hans Verkuilbec43662008-12-30 06:58:20 -03001437static const struct v4l2_file_operations zr364xx_fops = {
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001438 .owner = THIS_MODULE,
1439 .open = zr364xx_open,
1440 .release = zr364xx_release,
1441 .read = zr364xx_read,
1442 .mmap = zr364xx_mmap,
1443 .ioctl = video_ioctl2,
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001444 .poll = zr364xx_poll,
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001445};
1446
Hans Verkuila3998102008-07-21 02:57:38 -03001447static const struct v4l2_ioctl_ops zr364xx_ioctl_ops = {
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001448 .vidioc_querycap = zr364xx_vidioc_querycap,
Hans Verkuil78b526a2008-05-28 12:16:41 -03001449 .vidioc_enum_fmt_vid_cap = zr364xx_vidioc_enum_fmt_vid_cap,
1450 .vidioc_try_fmt_vid_cap = zr364xx_vidioc_try_fmt_vid_cap,
1451 .vidioc_s_fmt_vid_cap = zr364xx_vidioc_s_fmt_vid_cap,
1452 .vidioc_g_fmt_vid_cap = zr364xx_vidioc_g_fmt_vid_cap,
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001453 .vidioc_enum_input = zr364xx_vidioc_enum_input,
1454 .vidioc_g_input = zr364xx_vidioc_g_input,
1455 .vidioc_s_input = zr364xx_vidioc_s_input,
1456 .vidioc_streamon = zr364xx_vidioc_streamon,
1457 .vidioc_streamoff = zr364xx_vidioc_streamoff,
1458 .vidioc_queryctrl = zr364xx_vidioc_queryctrl,
1459 .vidioc_g_ctrl = zr364xx_vidioc_g_ctrl,
1460 .vidioc_s_ctrl = zr364xx_vidioc_s_ctrl,
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001461 .vidioc_reqbufs = zr364xx_vidioc_reqbufs,
1462 .vidioc_querybuf = zr364xx_vidioc_querybuf,
1463 .vidioc_qbuf = zr364xx_vidioc_qbuf,
1464 .vidioc_dqbuf = zr364xx_vidioc_dqbuf,
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001465};
1466
Hans Verkuila3998102008-07-21 02:57:38 -03001467static struct video_device zr364xx_template = {
Hans Verkuila3998102008-07-21 02:57:38 -03001468 .name = DRIVER_DESC,
Hans Verkuila3998102008-07-21 02:57:38 -03001469 .fops = &zr364xx_fops,
1470 .ioctl_ops = &zr364xx_ioctl_ops,
1471 .release = video_device_release,
Hans Verkuila3998102008-07-21 02:57:38 -03001472};
1473
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001474
1475
1476/*******************/
1477/* USB integration */
1478/*******************/
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001479static int zr364xx_board_init(struct zr364xx_camera *cam)
1480{
1481 struct zr364xx_pipeinfo *pipe = cam->pipe;
1482 unsigned long i;
1483
1484 DBG("board init: %p\n", cam);
1485 memset(pipe, 0, sizeof(*pipe));
1486 pipe->cam = cam;
1487 pipe->transfer_size = BUFFER_SIZE;
1488
1489 pipe->transfer_buffer = kzalloc(pipe->transfer_size,
1490 GFP_KERNEL);
1491 if (pipe->transfer_buffer == NULL) {
1492 DBG("out of memory!\n");
1493 return -ENOMEM;
1494 }
1495
1496 cam->b_acquire = 0;
1497 cam->frame_count = 0;
1498
1499 /*** start create system buffers ***/
1500 for (i = 0; i < FRAMES; i++) {
1501 /* always allocate maximum size for system buffers */
1502 cam->buffer.frame[i].lpvbits = vmalloc(MAX_FRAME_SIZE);
1503
1504 DBG("valloc %p, idx %lu, pdata %p\n",
1505 &cam->buffer.frame[i], i,
1506 cam->buffer.frame[i].lpvbits);
1507 if (cam->buffer.frame[i].lpvbits == NULL) {
1508 printk(KERN_INFO KBUILD_MODNAME ": out of memory. "
1509 "Using less frames\n");
1510 break;
1511 }
1512 }
1513
1514 if (i == 0) {
1515 printk(KERN_INFO KBUILD_MODNAME ": out of memory. Aborting\n");
1516 kfree(cam->pipe->transfer_buffer);
1517 cam->pipe->transfer_buffer = NULL;
1518 return -ENOMEM;
1519 } else
1520 cam->buffer.dwFrames = i;
1521
1522 /* make sure internal states are set */
1523 for (i = 0; i < FRAMES; i++) {
1524 cam->buffer.frame[i].ulState = ZR364XX_READ_IDLE;
1525 cam->buffer.frame[i].cur_size = 0;
1526 }
1527
1528 cam->cur_frame = 0;
1529 cam->last_frame = -1;
1530 /*** end create system buffers ***/
1531
1532 /* start read pipe */
1533 zr364xx_start_readpipe(cam);
1534 DBG(": board initialized\n");
1535 return 0;
1536}
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001537
1538static int zr364xx_probe(struct usb_interface *intf,
1539 const struct usb_device_id *id)
1540{
1541 struct usb_device *udev = interface_to_usbdev(intf);
1542 struct zr364xx_camera *cam = NULL;
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001543 struct usb_host_interface *iface_desc;
1544 struct usb_endpoint_descriptor *endpoint;
Akinobu Mita783aa8f2007-05-20 09:12:10 -03001545 int err;
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001546 int i;
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001547
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001548 DBG("probing...\n");
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001549
Greg Kroah-Hartmana482f322008-10-10 05:08:23 -03001550 dev_info(&intf->dev, DRIVER_DESC " compatible webcam plugged\n");
1551 dev_info(&intf->dev, "model %04x:%04x detected\n",
1552 le16_to_cpu(udev->descriptor.idVendor),
1553 le16_to_cpu(udev->descriptor.idProduct));
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001554
Akinobu Mita783aa8f2007-05-20 09:12:10 -03001555 cam = kzalloc(sizeof(struct zr364xx_camera), GFP_KERNEL);
1556 if (cam == NULL) {
Greg Kroah-Hartmana482f322008-10-10 05:08:23 -03001557 dev_err(&udev->dev, "cam: out of memory !\n");
Akinobu Mita783aa8f2007-05-20 09:12:10 -03001558 return -ENOMEM;
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001559 }
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001560 /* save the init method used by this camera */
1561 cam->method = id->driver_info;
1562
1563 cam->vdev = video_device_alloc();
1564 if (cam->vdev == NULL) {
Greg Kroah-Hartmana482f322008-10-10 05:08:23 -03001565 dev_err(&udev->dev, "cam->vdev: out of memory !\n");
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001566 kfree(cam);
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001567 cam = NULL;
Akinobu Mita783aa8f2007-05-20 09:12:10 -03001568 return -ENOMEM;
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001569 }
1570 memcpy(cam->vdev, &zr364xx_template, sizeof(zr364xx_template));
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001571 cam->vdev->parent = &intf->dev;
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001572 video_set_drvdata(cam->vdev, cam);
1573 if (debug)
1574 cam->vdev->debug = V4L2_DEBUG_IOCTL | V4L2_DEBUG_IOCTL_ARG;
1575
1576 cam->udev = udev;
1577
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001578 switch (mode) {
1579 case 1:
Greg Kroah-Hartmana482f322008-10-10 05:08:23 -03001580 dev_info(&udev->dev, "160x120 mode selected\n");
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001581 cam->width = 160;
1582 cam->height = 120;
1583 break;
1584 case 2:
Greg Kroah-Hartmana482f322008-10-10 05:08:23 -03001585 dev_info(&udev->dev, "640x480 mode selected\n");
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001586 cam->width = 640;
1587 cam->height = 480;
1588 break;
1589 default:
Greg Kroah-Hartmana482f322008-10-10 05:08:23 -03001590 dev_info(&udev->dev, "320x240 mode selected\n");
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001591 cam->width = 320;
1592 cam->height = 240;
1593 break;
1594 }
1595
1596 m0d1[0] = mode;
1597 m1[2].value = 0xf000 + mode;
1598 m2[1].value = 0xf000 + mode;
Antoine Jacquet08135ba2009-12-27 18:22:05 -03001599
1600 /* special case for METHOD3, the modes are different */
1601 if (cam->method == METHOD3) {
1602 switch (mode) {
1603 case 1:
1604 m2[1].value = 0xf000 + 4;
1605 break;
1606 case 2:
1607 m2[1].value = 0xf000 + 0;
1608 break;
1609 default:
1610 m2[1].value = 0xf000 + 1;
1611 break;
1612 }
1613 }
1614
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001615 header2[437] = cam->height / 256;
1616 header2[438] = cam->height % 256;
1617 header2[439] = cam->width / 256;
1618 header2[440] = cam->width % 256;
1619
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001620 cam->users = 0;
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001621 cam->nb = 0;
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001622 cam->mode.brightness = 64;
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001623 mutex_init(&cam->lock);
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001624 mutex_init(&cam->open_lock);
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001625
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001626 DBG("dev: %p, udev %p interface %p\n", cam, cam->udev, intf);
1627
1628 /* set up the endpoint information */
1629 iface_desc = intf->cur_altsetting;
1630 DBG("num endpoints %d\n", iface_desc->desc.bNumEndpoints);
1631 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1632 endpoint = &iface_desc->endpoint[i].desc;
1633 if (!cam->read_endpoint && usb_endpoint_is_bulk_in(endpoint)) {
1634 /* we found the bulk in endpoint */
1635 cam->read_endpoint = endpoint->bEndpointAddress;
1636 }
1637 }
1638
1639 if (!cam->read_endpoint) {
1640 dev_err(&intf->dev, "Could not find bulk-in endpoint\n");
1641 return -ENOMEM;
1642 }
1643
1644 /* v4l */
1645 INIT_LIST_HEAD(&cam->vidq.active);
1646 cam->vidq.cam = cam;
Akinobu Mita783aa8f2007-05-20 09:12:10 -03001647 err = video_register_device(cam->vdev, VFL_TYPE_GRABBER, -1);
1648 if (err) {
Greg Kroah-Hartmana482f322008-10-10 05:08:23 -03001649 dev_err(&udev->dev, "video_register_device failed\n");
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001650 video_device_release(cam->vdev);
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001651 kfree(cam);
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001652 cam = NULL;
Akinobu Mita783aa8f2007-05-20 09:12:10 -03001653 return err;
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001654 }
1655
1656 usb_set_intfdata(intf, cam);
1657
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001658 /* load zr364xx board specific */
1659 err = zr364xx_board_init(cam);
1660 if (err) {
1661 spin_lock_init(&cam->slock);
1662 return err;
1663 }
1664
1665 spin_lock_init(&cam->slock);
1666
Laurent Pinchart38c7c032009-11-27 13:57:15 -03001667 dev_info(&udev->dev, DRIVER_DESC " controlling device %s\n",
1668 video_device_node_name(cam->vdev));
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001669 return 0;
1670}
1671
1672
1673static void zr364xx_disconnect(struct usb_interface *intf)
1674{
1675 struct zr364xx_camera *cam = usb_get_intfdata(intf);
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001676 videobuf_mmap_free(&cam->vb_vidq);
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001677 usb_set_intfdata(intf, NULL);
Greg Kroah-Hartmana482f322008-10-10 05:08:23 -03001678 dev_info(&intf->dev, DRIVER_DESC " webcam unplugged\n");
Lamarque Vieira Souzaccbf0352009-07-15 20:54:55 -03001679 zr364xx_destroy(cam);
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001680}
1681
1682
1683
1684/**********************/
1685/* Module integration */
1686/**********************/
1687
1688static struct usb_driver zr364xx_driver = {
1689 .name = "zr364xx",
1690 .probe = zr364xx_probe,
1691 .disconnect = zr364xx_disconnect,
1692 .id_table = device_table
1693};
1694
1695
1696static int __init zr364xx_init(void)
1697{
1698 int retval;
Akinobu Mita783aa8f2007-05-20 09:12:10 -03001699 retval = usb_register(&zr364xx_driver);
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001700 if (retval)
Greg Kroah-Hartmana482f322008-10-10 05:08:23 -03001701 printk(KERN_ERR KBUILD_MODNAME ": usb_register failed!\n");
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001702 else
Greg Kroah-Hartmana482f322008-10-10 05:08:23 -03001703 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001704 return retval;
1705}
1706
1707
1708static void __exit zr364xx_exit(void)
1709{
Greg Kroah-Hartmana482f322008-10-10 05:08:23 -03001710 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC " module unloaded\n");
Antoine Jacquetb7eee612007-04-27 12:30:59 -03001711 usb_deregister(&zr364xx_driver);
1712}
1713
1714
1715module_init(zr364xx_init);
1716module_exit(zr364xx_exit);
1717
1718MODULE_AUTHOR(DRIVER_AUTHOR);
1719MODULE_DESCRIPTION(DRIVER_DESC);
1720MODULE_LICENSE("GPL");
Mauro Carvalho Chehab1990d502011-06-24 14:45:49 -03001721MODULE_VERSION(DRIVER_VERSION);