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