?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[IPSEC]: Ensure that state inner family is set
[firewire-audio.git] / drivers / media / video / zr364xx.c
blob6f1892585cbbac304eae05df4324fb6931c7f58b
1 /*
2 * Zoran 364xx based USB webcam module version 0.72
3 *
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 *
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2 of the License, or
16 * (at your option) any later version.
17 *
18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public License
24 * along with this program; if not, write to the Free Software
25 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 */
27
28
29 #include <linux/version.h>
30 #include <linux/module.h>
31 #include <linux/init.h>
32 #include <linux/usb.h>
33 #include <linux/vmalloc.h>
34 #include <linux/slab.h>
35 #include <linux/proc_fs.h>
36 #include <linux/highmem.h>
37 #include <media/v4l2-common.h>
38
39
40 /* Version Information */
41 #define DRIVER_VERSION "v0.72"
42 #define DRIVER_AUTHOR "Antoine Jacquet, http://royale.zerezo.com/"
43 #define DRIVER_DESC "Zoran 364xx"
44
45
46 /* Camera */
47 #define FRAMES 2
48 #define MAX_FRAME_SIZE 100000
49 #define BUFFER_SIZE 0x1000
50 #define CTRL_TIMEOUT 500
51
52
53 /* Debug macro */
54 #define DBG(x...) if (debug) info(x)
55
56
57 /* Init methods, need to find nicer names for these
58 * the exact names of the chipsets would be the best if someone finds it */
59 #define METHOD0 0
60 #define METHOD1 1
61 #define METHOD2 2
62
63
64 /* Module parameters */
65 static int debug = 0;
66 static int mode = 0;
67
68
69 /* Module parameters interface */
70 module_param(debug, int, 0644);
71 MODULE_PARM_DESC(debug, "Debug level");
72 module_param(mode, int, 0644);
73 MODULE_PARM_DESC(mode, "0 = 320x240, 1 = 160x120, 2 = 640x480");
74
75
76 /* Devices supported by this driver
77 * .driver_info contains the init method used by the camera */
78 static struct usb_device_id device_table[] = {
79 {USB_DEVICE(0x08ca, 0x0109), .driver_info = METHOD0 },
80 {USB_DEVICE(0x041e, 0x4024), .driver_info = METHOD0 },
81 {USB_DEVICE(0x0d64, 0x0108), .driver_info = METHOD0 },
82 {USB_DEVICE(0x0546, 0x3187), .driver_info = METHOD0 },
83 {USB_DEVICE(0x0d64, 0x3108), .driver_info = METHOD0 },
84 {USB_DEVICE(0x0595, 0x4343), .driver_info = METHOD0 },
85 {USB_DEVICE(0x0bb0, 0x500d), .driver_info = METHOD0 },
86 {USB_DEVICE(0x0feb, 0x2004), .driver_info = METHOD0 },
87 {USB_DEVICE(0x055f, 0xb500), .driver_info = METHOD0 },
88 {USB_DEVICE(0x08ca, 0x2062), .driver_info = METHOD2 },
89 {USB_DEVICE(0x052b, 0x1a18), .driver_info = METHOD1 },
90 {USB_DEVICE(0x04c8, 0x0729), .driver_info = METHOD0 },
91 {USB_DEVICE(0x04f2, 0xa208), .driver_info = METHOD0 },
92 {USB_DEVICE(0x0784, 0x0040), .driver_info = METHOD1 },
93 {USB_DEVICE(0x06d6, 0x0034), .driver_info = METHOD0 },
94 {USB_DEVICE(0x0a17, 0x0062), .driver_info = METHOD2 },
95 {USB_DEVICE(0x06d6, 0x003b), .driver_info = METHOD0 },
96 {} /* Terminating entry */
97 };
98
99 MODULE_DEVICE_TABLE(usb, device_table);
100
101
102 /* Camera stuff */
103 struct zr364xx_camera {
104 struct usb_device *udev; /* save off the usb device pointer */
105 struct usb_interface *interface;/* the interface for this device */
106 struct video_device *vdev; /* v4l video device */
107 u8 *framebuf;
108 int nb;
109 unsigned char *buffer;
110 int skip;
111 int brightness;
112 int width;
113 int height;
114 int method;
115 struct mutex lock;
116 };
117
118
119 /* function used to send initialisation commands to the camera */
120 static int send_control_msg(struct usb_device *udev, u8 request, u16 value,
121 u16 index, unsigned char *cp, u16 size)
122 {
123 int status;
124
125 unsigned char *transfer_buffer = kmalloc(size, GFP_KERNEL);
126 if (!transfer_buffer) {
127 info("kmalloc(%d) failed", size);
128 return -ENOMEM;
129 }
130
131 memcpy(transfer_buffer, cp, size);
132
133 status = usb_control_msg(udev,
134 usb_sndctrlpipe(udev, 0),
135 request,
136 USB_DIR_OUT | USB_TYPE_VENDOR |
137 USB_RECIP_DEVICE, value, index,
138 transfer_buffer, size, CTRL_TIMEOUT);
139
140 kfree(transfer_buffer);
141
142 if (status < 0)
143 info("Failed sending control message, error %d.", status);
144
145 return status;
146 }
147
148
149 /* Control messages sent to the camera to initialize it
150 * and launch the capture */
151 typedef struct {
152 unsigned int value;
153 unsigned int size;
154 unsigned char *bytes;
155 } message;
156
157 /* method 0 */
158 static unsigned char m0d1[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
159 static unsigned char m0d2[] = { 0, 0, 0, 0, 0, 0 };
160 static unsigned char m0d3[] = { 0, 0 };
161 static message m0[] = {
162 {0x1f30, 0, NULL},
163 {0xd000, 0, NULL},
164 {0x3370, sizeof(m0d1), m0d1},
165 {0x2000, 0, NULL},
166 {0x2f0f, 0, NULL},
167 {0x2610, sizeof(m0d2), m0d2},
168 {0xe107, 0, NULL},
169 {0x2502, 0, NULL},
170 {0x1f70, 0, NULL},
171 {0xd000, 0, NULL},
172 {0x9a01, sizeof(m0d3), m0d3},
173 {-1, -1, NULL}
174 };
175
176 /* method 1 */
177 static unsigned char m1d1[] = { 0xff, 0xff };
178 static unsigned char m1d2[] = { 0x00, 0x00 };
179 static message m1[] = {
180 {0x1f30, 0, NULL},
181 {0xd000, 0, NULL},
182 {0xf000, 0, NULL},
183 {0x2000, 0, NULL},
184 {0x2f0f, 0, NULL},
185 {0x2650, 0, NULL},
186 {0xe107, 0, NULL},
187 {0x2502, sizeof(m1d1), m1d1},
188 {0x1f70, 0, NULL},
189 {0xd000, 0, NULL},
190 {0xd000, 0, NULL},
191 {0xd000, 0, NULL},
192 {0x9a01, sizeof(m1d2), m1d2},
193 {-1, -1, NULL}
194 };
195
196 /* method 2 */
197 static unsigned char m2d1[] = { 0xff, 0xff };
198 static message m2[] = {
199 {0x1f30, 0, NULL},
200 {0xf000, 0, NULL},
201 {0x2000, 0, NULL},
202 {0x2f0f, 0, NULL},
203 {0x2650, 0, NULL},
204 {0xe107, 0, NULL},
205 {0x2502, sizeof(m2d1), m2d1},
206 {0x1f70, 0, NULL},
207 {-1, -1, NULL}
208 };
209
210 /* init table */
211 static message *init[3] = { m0, m1, m2 };
212
213
214 /* JPEG static data in header (Huffman table, etc) */
215 static unsigned char header1[] = {
216 0xFF, 0xD8,
217 /*
218 0xFF, 0xE0, 0x00, 0x10, 'J', 'F', 'I', 'F',
219 0x00, 0x01, 0x01, 0x00, 0x33, 0x8A, 0x00, 0x00, 0x33, 0x88,
220 */
221 0xFF, 0xDB, 0x00, 0x84
222 };
223 static unsigned char header2[] = {
224 0xFF, 0xC4, 0x00, 0x1F, 0x00, 0x00, 0x01, 0x05, 0x01, 0x01, 0x01,
225 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
226 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
227 0xFF, 0xC4, 0x00, 0xB5, 0x10, 0x00, 0x02, 0x01, 0x03, 0x03, 0x02,
228 0x04, 0x03, 0x05, 0x05, 0x04, 0x04, 0x00, 0x00, 0x01, 0x7D, 0x01,
229 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06,
230 0x13, 0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xA1,
231 0x08, 0x23, 0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1, 0xF0, 0x24, 0x33,
232 0x62, 0x72, 0x82, 0x09, 0x0A, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x25,
233 0x26, 0x27, 0x28, 0x29, 0x2A, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
234 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54,
235 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67,
236 0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A,
237 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94,
238 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6,
239 0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8,
240 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA,
241 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE1, 0xE2,
242 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF1, 0xF2, 0xF3,
243 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFF, 0xC4, 0x00, 0x1F,
244 0x01, 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
245 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04,
246 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0xFF, 0xC4, 0x00, 0xB5,
247 0x11, 0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, 0x07, 0x05,
248 0x04, 0x04, 0x00, 0x01, 0x02, 0x77, 0x00, 0x01, 0x02, 0x03, 0x11,
249 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
250 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xA1, 0xB1, 0xC1,
251 0x09, 0x23, 0x33, 0x52, 0xF0, 0x15, 0x62, 0x72, 0xD1, 0x0A, 0x16,
252 0x24, 0x34, 0xE1, 0x25, 0xF1, 0x17, 0x18, 0x19, 0x1A, 0x26, 0x27,
253 0x28, 0x29, 0x2A, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44,
254 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57,
255 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A,
256 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x82, 0x83, 0x84,
257 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96,
258 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8,
259 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA,
260 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3,
261 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE2, 0xE3, 0xE4, 0xE5,
262 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
263 0xF8, 0xF9, 0xFA, 0xFF, 0xC0, 0x00, 0x11, 0x08, 0x00, 0xF0, 0x01,
264 0x40, 0x03, 0x01, 0x21, 0x00, 0x02, 0x11, 0x01, 0x03, 0x11, 0x01,
265 0xFF, 0xDA, 0x00, 0x0C, 0x03, 0x01, 0x00, 0x02, 0x11, 0x03, 0x11,
266 0x00, 0x3F, 0x00
267 };
268 static unsigned char header3;
269
270
271
272 /********************/
273 /* V4L2 integration */
274 /********************/
275
276 /* this function reads a full JPEG picture synchronously
277 * TODO: do it asynchronously... */
278 static int read_frame(struct zr364xx_camera *cam, int framenum)
279 {
280 int i, n, temp, head, size, actual_length;
281 unsigned char *ptr = NULL, *jpeg;
282
283 redo:
284 /* hardware brightness */
285 n = send_control_msg(cam->udev, 1, 0x2001, 0, NULL, 0);
286 temp = (0x60 << 8) + 127 - cam->brightness;
287 n = send_control_msg(cam->udev, 1, temp, 0, NULL, 0);
288
289 /* during the first loop we are going to insert JPEG header */
290 head = 0;
291 /* this is the place in memory where we are going to build
292 * the JPEG image */
293 jpeg = cam->framebuf + framenum * MAX_FRAME_SIZE;
294 /* read data... */
295 do {
296 n = usb_bulk_msg(cam->udev,
297 usb_rcvbulkpipe(cam->udev, 0x81),
298 cam->buffer, BUFFER_SIZE, &actual_length,
299 CTRL_TIMEOUT);
300 DBG("buffer : %d %d", cam->buffer[0], cam->buffer[1]);
301 DBG("bulk : n=%d size=%d", n, actual_length);
302 if (n < 0) {
303 info("error reading bulk msg");
304 return 0;
305 }
306 if (actual_length < 0 || actual_length > BUFFER_SIZE) {
307 info("wrong number of bytes");
308 return 0;
309 }
310
311 /* swap bytes if camera needs it */
312 if (cam->method == METHOD0) {
313 u16 *buf = (u16*)cam->buffer;
314 for (i = 0; i < BUFFER_SIZE/2; i++)
315 swab16s(buf + i);
316 }
317
318 /* write the JPEG header */
319 if (!head) {
320 DBG("jpeg header");
321 ptr = jpeg;
322 memcpy(ptr, header1, sizeof(header1));
323 ptr += sizeof(header1);
324 header3 = 0;
325 memcpy(ptr, &header3, 1);
326 ptr++;
327 memcpy(ptr, cam->buffer, 64);
328 ptr += 64;
329 header3 = 1;
330 memcpy(ptr, &header3, 1);
331 ptr++;
332 memcpy(ptr, cam->buffer + 64, 64);
333 ptr += 64;
334 memcpy(ptr, header2, sizeof(header2));
335 ptr += sizeof(header2);
336 memcpy(ptr, cam->buffer + 128,
337 actual_length - 128);
338 ptr += actual_length - 128;
339 head = 1;
340 DBG("header : %d %d %d %d %d %d %d %d %d",
341 cam->buffer[0], cam->buffer[1], cam->buffer[2],
342 cam->buffer[3], cam->buffer[4], cam->buffer[5],
343 cam->buffer[6], cam->buffer[7], cam->buffer[8]);
344 } else {
345 memcpy(ptr, cam->buffer, actual_length);
346 ptr += actual_length;
347 }
348 }
349 /* ... until there is no more */
350 while (actual_length == BUFFER_SIZE);
351
352 /* we skip the 2 first frames which are usually buggy */
353 if (cam->skip) {
354 cam->skip--;
355 goto redo;
356 }
357
358 /* go back to find the JPEG EOI marker */
359 size = ptr - jpeg;
360 ptr -= 2;
361 while (ptr > jpeg) {
362 if (*ptr == 0xFF && *(ptr + 1) == 0xD9
363 && *(ptr + 2) == 0xFF)
364 break;
365 ptr--;
366 }
367 if (ptr == jpeg)
368 DBG("No EOI marker");
369
370 /* Sometimes there is junk data in the middle of the picture,
371 * we want to skip this bogus frames */
372 while (ptr > jpeg) {
373 if (*ptr == 0xFF && *(ptr + 1) == 0xFF
374 && *(ptr + 2) == 0xFF)
375 break;
376 ptr--;
377 }
378 if (ptr != jpeg) {
379 DBG("Bogus frame ? %d", cam->nb);
380 goto redo;
381 }
382
383 DBG("jpeg : %d %d %d %d %d %d %d %d",
384 jpeg[0], jpeg[1], jpeg[2], jpeg[3],
385 jpeg[4], jpeg[5], jpeg[6], jpeg[7]);
386
387 return size;
388 }
389
390
391 static ssize_t zr364xx_read(struct file *file, char *buf, size_t cnt,
392 loff_t * ppos)
393 {
394 unsigned long count = cnt;
395 struct video_device *vdev = video_devdata(file);
396 struct zr364xx_camera *cam;
397
398 DBG("zr364xx_read: read %d bytes.", (int) count);
399
400 if (vdev == NULL)
401 return -ENODEV;
402 cam = video_get_drvdata(vdev);
403
404 if (!buf)
405 return -EINVAL;
406
407 if (!count)
408 return -EINVAL;
409
410 /* NoMan Sux ! */
411 count = read_frame(cam, 0);
412
413 if (copy_to_user(buf, cam->framebuf, count))
414 return -EFAULT;
415
416 return count;
417 }
418
419
420 static int zr364xx_vidioc_querycap(struct file *file, void *priv,
421 struct v4l2_capability *cap)
422 {
423 memset(cap, 0, sizeof(*cap));
424 strcpy(cap->driver, DRIVER_DESC);
425 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE;
426 return 0;
427 }
428
429 static int zr364xx_vidioc_enum_input(struct file *file, void *priv,
430 struct v4l2_input *i)
431 {
432 if (i->index != 0)
433 return -EINVAL;
434 memset(i, 0, sizeof(*i));
435 i->index = 0;
436 strcpy(i->name, DRIVER_DESC " Camera");
437 i->type = V4L2_INPUT_TYPE_CAMERA;
438 return 0;
439 }
440
441 static int zr364xx_vidioc_g_input(struct file *file, void *priv,
442 unsigned int *i)
443 {
444 *i = 0;
445 return 0;
446 }
447
448 static int zr364xx_vidioc_s_input(struct file *file, void *priv,
449 unsigned int i)
450 {
451 if (i != 0)
452 return -EINVAL;
453 return 0;
454 }
455
456 static int zr364xx_vidioc_queryctrl(struct file *file, void *priv,
457 struct v4l2_queryctrl *c)
458 {
459 struct video_device *vdev = video_devdata(file);
460 struct zr364xx_camera *cam;
461
462 if (vdev == NULL)
463 return -ENODEV;
464 cam = video_get_drvdata(vdev);
465
466 switch (c->id) {
467 case V4L2_CID_BRIGHTNESS:
468 c->type = V4L2_CTRL_TYPE_INTEGER;
469 strcpy(c->name, "Brightness");
470 c->minimum = 0;
471 c->maximum = 127;
472 c->step = 1;
473 c->default_value = cam->brightness;
474 c->flags = 0;
475 break;
476 default:
477 return -EINVAL;
478 }
479 return 0;
480 }
481
482 static int zr364xx_vidioc_s_ctrl(struct file *file, void *priv,
483 struct v4l2_control *c)
484 {
485 struct video_device *vdev = video_devdata(file);
486 struct zr364xx_camera *cam;
487
488 if (vdev == NULL)
489 return -ENODEV;
490 cam = video_get_drvdata(vdev);
491
492 switch (c->id) {
493 case V4L2_CID_BRIGHTNESS:
494 cam->brightness = c->value;
495 break;
496 default:
497 return -EINVAL;
498 }
499 return 0;
500 }
501
502 static int zr364xx_vidioc_g_ctrl(struct file *file, void *priv,
503 struct v4l2_control *c)
504 {
505 struct video_device *vdev = video_devdata(file);
506 struct zr364xx_camera *cam;
507
508 if (vdev == NULL)
509 return -ENODEV;
510 cam = video_get_drvdata(vdev);
511
512 switch (c->id) {
513 case V4L2_CID_BRIGHTNESS:
514 c->value = cam->brightness;
515 break;
516 default:
517 return -EINVAL;
518 }
519 return 0;
520 }
521
522 static int zr364xx_vidioc_enum_fmt_cap(struct file *file,
523 void *priv, struct v4l2_fmtdesc *f)
524 {
525 if (f->index > 0)
526 return -EINVAL;
527 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
528 return -EINVAL;
529 memset(f, 0, sizeof(*f));
530 f->index = 0;
531 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
532 f->flags = V4L2_FMT_FLAG_COMPRESSED;
533 strcpy(f->description, "JPEG");
534 f->pixelformat = V4L2_PIX_FMT_JPEG;
535 return 0;
536 }
537
538 static int zr364xx_vidioc_try_fmt_cap(struct file *file, void *priv,
539 struct v4l2_format *f)
540 {
541 struct video_device *vdev = video_devdata(file);
542 struct zr364xx_camera *cam;
543
544 if (vdev == NULL)
545 return -ENODEV;
546 cam = video_get_drvdata(vdev);
547
548 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
549 return -EINVAL;
550 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_JPEG)
551 return -EINVAL;
552 if (f->fmt.pix.field != V4L2_FIELD_ANY &&
553 f->fmt.pix.field != V4L2_FIELD_NONE)
554 return -EINVAL;
555 f->fmt.pix.field = V4L2_FIELD_NONE;
556 f->fmt.pix.width = cam->width;
557 f->fmt.pix.height = cam->height;
558 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
559 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
560 f->fmt.pix.colorspace = 0;
561 f->fmt.pix.priv = 0;
562 return 0;
563 }
564
565 static int zr364xx_vidioc_g_fmt_cap(struct file *file, void *priv,
566 struct v4l2_format *f)
567 {
568 struct video_device *vdev = video_devdata(file);
569 struct zr364xx_camera *cam;
570
571 if (vdev == NULL)
572 return -ENODEV;
573 cam = video_get_drvdata(vdev);
574
575 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
576 return -EINVAL;
577 memset(&f->fmt.pix, 0, sizeof(struct v4l2_pix_format));
578 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
579 f->fmt.pix.pixelformat = V4L2_PIX_FMT_JPEG;
580 f->fmt.pix.field = V4L2_FIELD_NONE;
581 f->fmt.pix.width = cam->width;
582 f->fmt.pix.height = cam->height;
583 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
584 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
585 f->fmt.pix.colorspace = 0;
586 f->fmt.pix.priv = 0;
587 return 0;
588 }
589
590 static int zr364xx_vidioc_s_fmt_cap(struct file *file, void *priv,
591 struct v4l2_format *f)
592 {
593 struct video_device *vdev = video_devdata(file);
594 struct zr364xx_camera *cam;
595
596 if (vdev == NULL)
597 return -ENODEV;
598 cam = video_get_drvdata(vdev);
599
600 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
601 return -EINVAL;
602 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_JPEG)
603 return -EINVAL;
604 if (f->fmt.pix.field != V4L2_FIELD_ANY &&
605 f->fmt.pix.field != V4L2_FIELD_NONE)
606 return -EINVAL;
607 f->fmt.pix.field = V4L2_FIELD_NONE;
608 f->fmt.pix.width = cam->width;
609 f->fmt.pix.height = cam->height;
610 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
611 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
612 f->fmt.pix.colorspace = 0;
613 f->fmt.pix.priv = 0;
614 DBG("ok!");
615 return 0;
616 }
617
618 static int zr364xx_vidioc_streamon(struct file *file, void *priv,
619 enum v4l2_buf_type type)
620 {
621 return 0;
622 }
623
624 static int zr364xx_vidioc_streamoff(struct file *file, void *priv,
625 enum v4l2_buf_type type)
626 {
627 return 0;
628 }
629
630
631 /* open the camera */
632 static int zr364xx_open(struct inode *inode, struct file *file)
633 {
634 struct video_device *vdev = video_devdata(file);
635 struct zr364xx_camera *cam = video_get_drvdata(vdev);
636 struct usb_device *udev = cam->udev;
637 int i, err;
638
639 DBG("zr364xx_open");
640
641 cam->skip = 2;
642
643 err = video_exclusive_open(inode, file);
644 if (err < 0)
645 return err;
646
647 if (!cam->framebuf) {
648 cam->framebuf = vmalloc_32(MAX_FRAME_SIZE * FRAMES);
649 if (!cam->framebuf) {
650 info("vmalloc_32 failed!");
651 return -ENOMEM;
652 }
653 }
654
655 mutex_lock(&cam->lock);
656 for (i = 0; init[cam->method][i].size != -1; i++) {
657 err =
658 send_control_msg(udev, 1, init[cam->method][i].value,
659 0, init[cam->method][i].bytes,
660 init[cam->method][i].size);
661 if (err < 0) {
662 info("error during open sequence: %d", i);
663 mutex_unlock(&cam->lock);
664 return err;
665 }
666 }
667
668 file->private_data = vdev;
669
670 /* Added some delay here, since opening/closing the camera quickly,
671 * like Ekiga does during its startup, can crash the webcam
672 */
673 mdelay(100);
674
675 mutex_unlock(&cam->lock);
676 return 0;
677 }
678
679
680 /* release the camera */
681 static int zr364xx_release(struct inode *inode, struct file *file)
682 {
683 struct video_device *vdev = video_devdata(file);
684 struct zr364xx_camera *cam;
685 struct usb_device *udev;
686 int i, err;
687
688 DBG("zr364xx_release");
689
690 if (vdev == NULL)
691 return -ENODEV;
692 cam = video_get_drvdata(vdev);
693
694 udev = cam->udev;
695
696 mutex_lock(&cam->lock);
697 for (i = 0; i < 2; i++) {
698 err =
699 send_control_msg(udev, 1, init[cam->method][i].value,
700 0, init[i][cam->method].bytes,
701 init[cam->method][i].size);
702 if (err < 0) {
703 info("error during release sequence");
704 mutex_unlock(&cam->lock);
705 return err;
706 }
707 }
708
709 file->private_data = NULL;
710 video_exclusive_release(inode, file);
711
712 /* Added some delay here, since opening/closing the camera quickly,
713 * like Ekiga does during its startup, can crash the webcam
714 */
715 mdelay(100);
716
717 mutex_unlock(&cam->lock);
718 return 0;
719 }
720
721
722 static int zr364xx_mmap(struct file *file, struct vm_area_struct *vma)
723 {
724 void *pos;
725 unsigned long start = vma->vm_start;
726 unsigned long size = vma->vm_end - vma->vm_start;
727 struct video_device *vdev = video_devdata(file);
728 struct zr364xx_camera *cam;
729
730 DBG("zr364xx_mmap: %ld\n", size);
731
732 if (vdev == NULL)
733 return -ENODEV;
734 cam = video_get_drvdata(vdev);
735
736 pos = cam->framebuf;
737 while (size > 0) {
738 if (vm_insert_page(vma, start, vmalloc_to_page(pos)))
739 return -EAGAIN;
740 start += PAGE_SIZE;
741 pos += PAGE_SIZE;
742 if (size > PAGE_SIZE)
743 size -= PAGE_SIZE;
744 else
745 size = 0;
746 }
747
748 return 0;
749 }
750
751
752 static struct file_operations zr364xx_fops = {
753 .owner = THIS_MODULE,
754 .open = zr364xx_open,
755 .release = zr364xx_release,
756 .read = zr364xx_read,
757 .mmap = zr364xx_mmap,
758 .ioctl = video_ioctl2,
759 .llseek = no_llseek,
760 };
761
762 static struct video_device zr364xx_template = {
763 .owner = THIS_MODULE,
764 .name = DRIVER_DESC,
765 .type = VID_TYPE_CAPTURE,
766 .fops = &zr364xx_fops,
767 .release = video_device_release,
768 .minor = -1,
769
770 .vidioc_querycap = zr364xx_vidioc_querycap,
771 .vidioc_enum_fmt_cap = zr364xx_vidioc_enum_fmt_cap,
772 .vidioc_try_fmt_cap = zr364xx_vidioc_try_fmt_cap,
773 .vidioc_s_fmt_cap = zr364xx_vidioc_s_fmt_cap,
774 .vidioc_g_fmt_cap = zr364xx_vidioc_g_fmt_cap,
775 .vidioc_enum_input = zr364xx_vidioc_enum_input,
776 .vidioc_g_input = zr364xx_vidioc_g_input,
777 .vidioc_s_input = zr364xx_vidioc_s_input,
778 .vidioc_streamon = zr364xx_vidioc_streamon,
779 .vidioc_streamoff = zr364xx_vidioc_streamoff,
780 .vidioc_queryctrl = zr364xx_vidioc_queryctrl,
781 .vidioc_g_ctrl = zr364xx_vidioc_g_ctrl,
782 .vidioc_s_ctrl = zr364xx_vidioc_s_ctrl,
783 };
784
785
786
787 /*******************/
788 /* USB integration */
789 /*******************/
790
791 static int zr364xx_probe(struct usb_interface *intf,
792 const struct usb_device_id *id)
793 {
794 struct usb_device *udev = interface_to_usbdev(intf);
795 struct zr364xx_camera *cam = NULL;
796 int err;
797
798 DBG("probing...");
799
800 info(DRIVER_DESC " compatible webcam plugged");
801 info("model %04x:%04x detected", udev->descriptor.idVendor,
802 udev->descriptor.idProduct);
803
804 cam = kzalloc(sizeof(struct zr364xx_camera), GFP_KERNEL);
805 if (cam == NULL) {
806 info("cam: out of memory !");
807 return -ENOMEM;
808 }
809 /* save the init method used by this camera */
810 cam->method = id->driver_info;
811
812 cam->vdev = video_device_alloc();
813 if (cam->vdev == NULL) {
814 info("cam->vdev: out of memory !");
815 kfree(cam);
816 return -ENOMEM;
817 }
818 memcpy(cam->vdev, &zr364xx_template, sizeof(zr364xx_template));
819 video_set_drvdata(cam->vdev, cam);
820 if (debug)
821 cam->vdev->debug = V4L2_DEBUG_IOCTL | V4L2_DEBUG_IOCTL_ARG;
822
823 cam->udev = udev;
824
825 if ((cam->buffer = kmalloc(BUFFER_SIZE, GFP_KERNEL)) == NULL) {
826 info("cam->buffer: out of memory !");
827 video_device_release(cam->vdev);
828 kfree(cam);
829 return -ENODEV;
830 }
831
832 switch (mode) {
833 case 1:
834 info("160x120 mode selected");
835 cam->width = 160;
836 cam->height = 120;
837 break;
838 case 2:
839 info("640x480 mode selected");
840 cam->width = 640;
841 cam->height = 480;
842 break;
843 default:
844 info("320x240 mode selected");
845 cam->width = 320;
846 cam->height = 240;
847 break;
848 }
849
850 m0d1[0] = mode;
851 m1[2].value = 0xf000 + mode;
852 m2[1].value = 0xf000 + mode;
853 header2[437] = cam->height / 256;
854 header2[438] = cam->height % 256;
855 header2[439] = cam->width / 256;
856 header2[440] = cam->width % 256;
857
858 cam->nb = 0;
859 cam->brightness = 64;
860 mutex_init(&cam->lock);
861
862 err = video_register_device(cam->vdev, VFL_TYPE_GRABBER, -1);
863 if (err) {
864 info("video_register_device failed");
865 video_device_release(cam->vdev);
866 kfree(cam->buffer);
867 kfree(cam);
868 return err;
869 }
870
871 usb_set_intfdata(intf, cam);
872
873 info(DRIVER_DESC " controlling video device %d", cam->vdev->minor);
874 return 0;
875 }
876
877
878 static void zr364xx_disconnect(struct usb_interface *intf)
879 {
880 struct zr364xx_camera *cam = usb_get_intfdata(intf);
881 usb_set_intfdata(intf, NULL);
882 dev_set_drvdata(&intf->dev, NULL);
883 info(DRIVER_DESC " webcam unplugged");
884 if (cam->vdev)
885 video_unregister_device(cam->vdev);
886 cam->vdev = NULL;
887 kfree(cam->buffer);
888 if (cam->framebuf)
889 vfree(cam->framebuf);
890 kfree(cam);
891 }
892
893
894
895 /**********************/
896 /* Module integration */
897 /**********************/
898
899 static struct usb_driver zr364xx_driver = {
900 .name = "zr364xx",
901 .probe = zr364xx_probe,
902 .disconnect = zr364xx_disconnect,
903 .id_table = device_table
904 };
905
906
907 static int __init zr364xx_init(void)
908 {
909 int retval;
910 retval = usb_register(&zr364xx_driver);
911 if (retval)
912 info("usb_register failed!");
913 else
914 info(DRIVER_DESC " module loaded");
915 return retval;
916 }
917
918
919 static void __exit zr364xx_exit(void)
920 {
921 info(DRIVER_DESC " module unloaded");
922 usb_deregister(&zr364xx_driver);
923 }
924
925
926 module_init(zr364xx_init);
927 module_exit(zr364xx_exit);
928
929 MODULE_AUTHOR(DRIVER_AUTHOR);
930 MODULE_DESCRIPTION(DRIVER_DESC);
931 MODULE_LICENSE("GPL");
AMDTP streaming driver for the Linux FireWire stack (Juju)