]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blame - drivers/media/video/zr364xx.c
projects / mirror_ubuntu-jammy-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/btrfs...
[mirror_ubuntu-jammy-kernel.git] / drivers / media / video / zr364xx.c
CommitLineData
b7eee616 1/*
ccbf035a 2 * Zoran 364xx based USB webcam module version 0.73
b7eee616
AJ		 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 *
ccbf035a
LVS		 13 * Some video buffer code by Lamarque based on s2255drv.c and vivi.c drivers.
14 *
b7eee616
AJ		 15 * 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
b7eee616 31#include <linux/module.h>
ccbf035a 32#include <linux/version.h>
b7eee616
AJ		 33#include <linux/init.h>
34#include <linux/usb.h>
35#include <linux/vmalloc.h>
36#include <linux/slab.h>
37#include <linux/proc_fs.h>
2575f84a 38#include <linux/highmem.h>
b7eee616 39#include <media/v4l2-common.h>
35ea11ff 40#include <media/v4l2-ioctl.h>
ccbf035a 41#include <media/videobuf-vmalloc.h>
b7eee616
AJ		 42
43
44/* Version Information */
ccbf035a 45#define DRIVER_VERSION "v0.73"
8c5f32ac 46#define ZR364XX_VERSION_CODE KERNEL_VERSION(0, 7, 3)
b7eee616
AJ		 47#define DRIVER_AUTHOR "Antoine Jacquet, http://royale.zerezo.com/"
48#define DRIVER_DESC "Zoran 364xx"
49
50
51/* Camera */
ccbf035a 52#define FRAMES 1
8c5f32ac 53#define MAX_FRAME_SIZE 200000
b7eee616
AJ		 54#define BUFFER_SIZE 0x1000
55#define CTRL_TIMEOUT 500
56
ccbf035a
LVS		 57#define ZR364XX_DEF_BUFS 4
58#define ZR364XX_READ_IDLE 0
59#define ZR364XX_READ_FRAME 1
b7eee616
AJ		 60
61/* Debug macro */
ccbf035a
LVS		 62#define DBG(fmt, args...) \
63 do { \
64 if (debug) { \
65 printk(KERN_INFO KBUILD_MODNAME " " fmt, ##args); \
66 } \
67 } while (0)
b7eee616 68
76594c53
LVS		 69/*#define FULL_DEBUG 1*/
70#ifdef FULL_DEBUG
71#define _DBG DBG
72#else
73#define _DBG(fmt, args...)
74#endif
75
b7eee616
AJ		 76/* Init methods, need to find nicer names for these
77 * the exact names of the chipsets would be the best if someone finds it */
78#define METHOD0 0
79#define METHOD1 1
80#define METHOD2 2
81
82
83/* Module parameters */
ff699e6b
DSL		 84static int debug;
85static int mode;
b7eee616
AJ		 86
87
88/* Module parameters interface */
89module_param(debug, int, 0644);
90MODULE_PARM_DESC(debug, "Debug level");
91module_param(mode, int, 0644);
92MODULE_PARM_DESC(mode, "0 = 320x240, 1 = 160x120, 2 = 640x480");
93
94
95/* Devices supported by this driver
96 * .driver_info contains the init method used by the camera */
97static struct usb_device_id device_table[] = {
98 {USB_DEVICE(0x08ca, 0x0109), .driver_info = METHOD0 },
99 {USB_DEVICE(0x041e, 0x4024), .driver_info = METHOD0 },
100 {USB_DEVICE(0x0d64, 0x0108), .driver_info = METHOD0 },
101 {USB_DEVICE(0x0546, 0x3187), .driver_info = METHOD0 },
102 {USB_DEVICE(0x0d64, 0x3108), .driver_info = METHOD0 },
103 {USB_DEVICE(0x0595, 0x4343), .driver_info = METHOD0 },
104 {USB_DEVICE(0x0bb0, 0x500d), .driver_info = METHOD0 },
105 {USB_DEVICE(0x0feb, 0x2004), .driver_info = METHOD0 },
106 {USB_DEVICE(0x055f, 0xb500), .driver_info = METHOD0 },
107 {USB_DEVICE(0x08ca, 0x2062), .driver_info = METHOD2 },
108 {USB_DEVICE(0x052b, 0x1a18), .driver_info = METHOD1 },
109 {USB_DEVICE(0x04c8, 0x0729), .driver_info = METHOD0 },
110 {USB_DEVICE(0x04f2, 0xa208), .driver_info = METHOD0 },
111 {USB_DEVICE(0x0784, 0x0040), .driver_info = METHOD1 },
112 {USB_DEVICE(0x06d6, 0x0034), .driver_info = METHOD0 },
113 {USB_DEVICE(0x0a17, 0x0062), .driver_info = METHOD2 },
bebeaea0 114 {USB_DEVICE(0x06d6, 0x003b), .driver_info = METHOD0 },
71c04475 115 {USB_DEVICE(0x0a17, 0x004e), .driver_info = METHOD2 },
c0e0aff9 116 {USB_DEVICE(0x041e, 0x405d), .driver_info = METHOD2 },
c76b638c 117 {USB_DEVICE(0x08ca, 0x2102), .driver_info = METHOD2 },
b7eee616
AJ		 118 {} /* Terminating entry */
119};
120
121MODULE_DEVICE_TABLE(usb, device_table);
122
ccbf035a
LVS		 123struct 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};
b7eee616
AJ		 171
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 */
b7eee616 177 int nb;
ccbf035a 178 struct zr364xx_bufferi buffer;
b7eee616 179 int skip;
b7eee616
AJ		 180 int width;
181 int height;
182 int method;
183 struct mutex lock;
ccbf035a 184 struct mutex open_lock;
33d27a45 185 int users;
ccbf035a
LVS		 186
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;
b7eee616
AJ		 202};
203
ccbf035a
LVS		 204/* 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};
b7eee616
AJ		 210
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) {
a482f327 219 dev_err(&udev->dev, "kmalloc(%d) failed\n", size);
b7eee616
AJ		 220 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)
a482f327
GKH		 235 dev_err(&udev->dev,
236 "Failed sending control message, error %d.\n", status);
b7eee616
AJ		 237
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 */
304static message *init[3] = { m0, m1, m2 };
305
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
ccbf035a
LVS		 363/* ------------------------------------------------------------------
364 Videobuf operations
365 ------------------------------------------------------------------*/
b7eee616 366
ccbf035a
LVS		 367static int buffer_setup(struct videobuf_queue *vq, unsigned int *count,
368 unsigned int *size)
369{
370 struct zr364xx_camera *cam = vq->priv_data;
b7eee616 371
ccbf035a 372 *size = cam->width * cam->height * (cam->fmt->depth >> 3);
b7eee616 373
ccbf035a
LVS		 374 if (*count == 0)
375 *count = ZR364XX_DEF_BUFS;
b7eee616 376
ccbf035a
LVS		 377 while (*size * (*count) > ZR364XX_DEF_BUFS * 1024 * 1024)
378 (*count)--;
b7eee616 379
ccbf035a
LVS		 380 return 0;
381}
b7eee616 382
ccbf035a
LVS		 383static void free_buffer(struct videobuf_queue *vq, struct zr364xx_buffer *buf)
384{
76594c53 385 _DBG("%s\n", __func__);
b7eee616 386
ccbf035a
LVS		 387 if (in_interrupt())
388 BUG();
b7eee616 389
ccbf035a
LVS		 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;
b7eee616 412 }
ccbf035a
LVS		 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;
b7eee616
AJ		 423 }
424
ccbf035a
LVS		 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
76594c53 438 _DBG("%s\n", __func__);
b7eee616 439
ccbf035a
LVS		 440 buf->vb.state = VIDEOBUF_QUEUED;
441 list_add_tail(&buf->vb.queue, &cam->vidq.active);
b7eee616
AJ		 442}
443
ccbf035a
LVS		 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
76594c53 450 _DBG("%s\n", __func__);
ccbf035a
LVS		 451 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};
460
461/********************/
462/* V4L2 integration */
463/********************/
464static int zr364xx_vidioc_streamon(struct file *file, void *priv,
465 enum v4l2_buf_type type);
b7eee616 466
ccbf035a 467static ssize_t zr364xx_read(struct file *file, char __user *buf, size_t count,
b7eee616
AJ		 468 loff_t * ppos)
469{
ccbf035a 470 struct zr364xx_camera *cam = video_drvdata(file);
b7eee616 471
76594c53 472 _DBG("%s\n", __func__);
b7eee616
AJ		 473
474 if (!buf)
475 return -EINVAL;
476
477 if (!count)
478 return -EINVAL;
479
ccbf035a
LVS		 480 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);
484
485 /* NoMan Sux ! */
486 return videobuf_read_one(&cam->vb_vidq, buf, count, ppos,
487 file->f_flags & O_NONBLOCK);
488 }
489
490 return 0;
491}
492
493/* 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);
573 return 0;
574}
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
76594c53 592 _DBG("buffer to user\n");
ccbf035a
LVS		 593 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
ccbf035a
LVS		 610 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
76594c53 617 _DBG("jpeg header, ");
ccbf035a
LVS		 618 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;
76594c53 635 _DBG("header : %d %d %d %d %d %d %d %d %d\n",
ccbf035a
LVS		 636 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 {
76594c53
LVS		 641 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 }
ccbf035a 651 }
76594c53 652 /*_DBG("cur_size %lu urb size %d\n", frm->cur_size,
ccbf035a
LVS		 653 purb->actual_length);*/
654
655 if (purb->actual_length < pipe_info->transfer_size) {
76594c53 656 _DBG("****************Buffer[%d]full*************\n", idx);
ccbf035a
LVS		 657 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 {
76594c53 691 _DBG("jpeg(%lu): %d %d %d %d %d %d %d %d\n",
ccbf035a
LVS		 692 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;
76594c53 718 _DBG("res: get\n");
ccbf035a
LVS		 719 mutex_unlock(&cam->lock);
720 return 1;
721}
b7eee616 722
ccbf035a
LVS		 723static inline int res_check(struct zr364xx_camera *cam)
724{
725 return cam->resources;
b7eee616
AJ		 726}
727
ccbf035a
LVS		 728static void res_free(struct zr364xx_camera *cam)
729{
730 mutex_lock(&cam->lock);
731 cam->resources = 0;
732 mutex_unlock(&cam->lock);
76594c53 733 _DBG("res: put\n");
ccbf035a 734}
b7eee616
AJ		 735
736static int zr364xx_vidioc_querycap(struct file *file, void *priv,
737 struct v4l2_capability *cap)
738{
ccbf035a
LVS		 739 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));
8c5f32ac 745 cap->version = ZR364XX_VERSION_CODE;
ccbf035a
LVS		 746 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
747 V4L2_CAP_READWRITE |
748 V4L2_CAP_STREAMING;
749
b7eee616
AJ		 750 return 0;
751}
752
753static int zr364xx_vidioc_enum_input(struct file *file, void *priv,
754 struct v4l2_input *i)
755{
756 if (i->index != 0)
757 return -EINVAL;
b7eee616
AJ		 758 strcpy(i->name, DRIVER_DESC " Camera");
759 i->type = V4L2_INPUT_TYPE_CAMERA;
760 return 0;
761}
762
763static int zr364xx_vidioc_g_input(struct file *file, void *priv,
764 unsigned int *i)
765{
766 *i = 0;
767 return 0;
768}
769
770static int zr364xx_vidioc_s_input(struct file *file, void *priv,
771 unsigned int i)
772{
773 if (i != 0)
774 return -EINVAL;
775 return 0;
776}
777
778static int zr364xx_vidioc_queryctrl(struct file *file, void *priv,
779 struct v4l2_queryctrl *c)
780{
b7eee616
AJ		 781 struct zr364xx_camera *cam;
782
ccbf035a 783 if (file == NULL)
b7eee616 784 return -ENODEV;
ccbf035a 785 cam = video_drvdata(file);
b7eee616
AJ		 786
787 switch (c->id) {
788 case V4L2_CID_BRIGHTNESS:
789 c->type = V4L2_CTRL_TYPE_INTEGER;
790 strcpy(c->name, "Brightness");
791 c->minimum = 0;
792 c->maximum = 127;
793 c->step = 1;
ccbf035a 794 c->default_value = cam->mode.brightness;
b7eee616
AJ		 795 c->flags = 0;
796 break;
797 default:
798 return -EINVAL;
799 }
800 return 0;
801}
802
803static int zr364xx_vidioc_s_ctrl(struct file *file, void *priv,
804 struct v4l2_control *c)
805{
b7eee616 806 struct zr364xx_camera *cam;
ccbf035a 807 int temp;
b7eee616 808
ccbf035a 809 if (file == NULL)
b7eee616 810 return -ENODEV;
ccbf035a 811 cam = video_drvdata(file);
b7eee616
AJ		 812
813 switch (c->id) {
814 case V4L2_CID_BRIGHTNESS:
ccbf035a
LVS		 815 cam->mode.brightness = c->value;
816 /* hardware brightness */
817 mutex_lock(&cam->lock);
818 send_control_msg(cam->udev, 1, 0x2001, 0, NULL, 0);
819 temp = (0x60 << 8) + 127 - cam->mode.brightness;
820 send_control_msg(cam->udev, 1, temp, 0, NULL, 0);
821 mutex_unlock(&cam->lock);
b7eee616
AJ		 822 break;
823 default:
824 return -EINVAL;
825 }
ccbf035a 826
b7eee616
AJ		 827 return 0;
828}
829
830static int zr364xx_vidioc_g_ctrl(struct file *file, void *priv,
831 struct v4l2_control *c)
832{
b7eee616
AJ		 833 struct zr364xx_camera *cam;
834
ccbf035a 835 if (file == NULL)
b7eee616 836 return -ENODEV;
ccbf035a 837 cam = video_drvdata(file);
b7eee616
AJ		 838
839 switch (c->id) {
840 case V4L2_CID_BRIGHTNESS:
ccbf035a 841 c->value = cam->mode.brightness;
b7eee616
AJ		 842 break;
843 default:
844 return -EINVAL;
845 }
846 return 0;
847}
848
78b526a4 849static int zr364xx_vidioc_enum_fmt_vid_cap(struct file *file,
b7eee616
AJ		 850 void *priv, struct v4l2_fmtdesc *f)
851{
852 if (f->index > 0)
853 return -EINVAL;
b7eee616 854 f->flags = V4L2_FMT_FLAG_COMPRESSED;
ccbf035a
LVS		 855 strcpy(f->description, formats[0].name);
856 f->pixelformat = formats[0].fourcc;
b7eee616
AJ		 857 return 0;
858}
859
ccbf035a
LVS		 860static char *decode_fourcc(__u32 pixelformat, char *buf)
861{
862 buf[0] = pixelformat & 0xff;
863 buf[1] = (pixelformat >> 8) & 0xff;
864 buf[2] = (pixelformat >> 16) & 0xff;
865 buf[3] = (pixelformat >> 24) & 0xff;
866 buf[4] = '\0';
867 return buf;
868}
869
78b526a4 870static int zr364xx_vidioc_try_fmt_vid_cap(struct file *file, void *priv,
b7eee616
AJ		 871 struct v4l2_format *f)
872{
ccbf035a
LVS		 873 struct zr364xx_camera *cam = video_drvdata(file);
874 char pixelformat_name[5];
b7eee616 875
ccbf035a 876 if (cam == NULL)
b7eee616 877 return -ENODEV;
b7eee616 878
ccbf035a
LVS		 879 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_JPEG) {
880 DBG("%s: unsupported pixelformat V4L2_PIX_FMT_%s\n", __func__,
881 decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name));
b7eee616 882 return -EINVAL;
ccbf035a
LVS		 883 }
884
8c5f32ac
LVS		 885 if (!(f->fmt.pix.width == 160 && f->fmt.pix.height == 120) &&
886 !(f->fmt.pix.width == 640 && f->fmt.pix.height == 480)) {
887 f->fmt.pix.width = 320;
888 f->fmt.pix.height = 240;
889 }
890
b7eee616 891 f->fmt.pix.field = V4L2_FIELD_NONE;
b7eee616
AJ		 892 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
893 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
894 f->fmt.pix.colorspace = 0;
895 f->fmt.pix.priv = 0;
ccbf035a
LVS		 896 DBG("%s: V4L2_PIX_FMT_%s (%d) ok!\n", __func__,
897 decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name),
898 f->fmt.pix.field);
b7eee616
AJ		 899 return 0;
900}
901
78b526a4 902static int zr364xx_vidioc_g_fmt_vid_cap(struct file *file, void *priv,
b7eee616
AJ		 903 struct v4l2_format *f)
904{
b7eee616
AJ		 905 struct zr364xx_camera *cam;
906
ccbf035a 907 if (file == NULL)
b7eee616 908 return -ENODEV;
ccbf035a 909 cam = video_drvdata(file);
b7eee616 910
ccbf035a 911 f->fmt.pix.pixelformat = formats[0].fourcc;
b7eee616
AJ		 912 f->fmt.pix.field = V4L2_FIELD_NONE;
913 f->fmt.pix.width = cam->width;
914 f->fmt.pix.height = cam->height;
915 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
916 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
917 f->fmt.pix.colorspace = 0;
918 f->fmt.pix.priv = 0;
919 return 0;
920}
921
78b526a4 922static int zr364xx_vidioc_s_fmt_vid_cap(struct file *file, void *priv,
b7eee616
AJ		 923 struct v4l2_format *f)
924{
ccbf035a
LVS		 925 struct zr364xx_camera *cam = video_drvdata(file);
926 struct videobuf_queue *q = &cam->vb_vidq;
927 char pixelformat_name[5];
928 int ret = zr364xx_vidioc_try_fmt_vid_cap(file, cam, f);
8c5f32ac 929 int i;
b7eee616 930
ccbf035a
LVS		 931 if (ret < 0)
932 return ret;
933
934 mutex_lock(&q->vb_lock);
935
936 if (videobuf_queue_is_busy(&cam->vb_vidq)) {
937 DBG("%s queue busy\n", __func__);
938 ret = -EBUSY;
939 goto out;
940 }
b7eee616 941
8c5f32ac
LVS		 942 if (res_check(cam)) {
943 DBG("%s can't change format after started\n", __func__);
944 ret = -EBUSY;
945 goto out;
946 }
947
948 cam->width = f->fmt.pix.width;
949 cam->height = f->fmt.pix.height;
950 dev_info(&cam->udev->dev, "%s: %dx%d mode selected\n", __func__,
951 cam->width, cam->height);
b7eee616
AJ		 952 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
953 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
954 f->fmt.pix.colorspace = 0;
955 f->fmt.pix.priv = 0;
ccbf035a
LVS		 956 cam->vb_vidq.field = f->fmt.pix.field;
957 cam->mode.color = V4L2_PIX_FMT_JPEG;
8c5f32ac
LVS		 958
959 if (f->fmt.pix.width == 160 && f->fmt.pix.height == 120)
960 mode = 1;
961 else if (f->fmt.pix.width == 640 && f->fmt.pix.height == 480)
962 mode = 2;
963 else
964 mode = 0;
965
966 m0d1[0] = mode;
967 m1[2].value = 0xf000 + mode;
968 m2[1].value = 0xf000 + mode;
969 header2[437] = cam->height / 256;
970 header2[438] = cam->height % 256;
971 header2[439] = cam->width / 256;
972 header2[440] = cam->width % 256;
973
974 for (i = 0; init[cam->method][i].size != -1; i++) {
975 ret =
976 send_control_msg(cam->udev, 1, init[cam->method][i].value,
977 0, init[cam->method][i].bytes,
978 init[cam->method][i].size);
979 if (ret < 0) {
980 dev_err(&cam->udev->dev,
981 "error during resolution change sequence: %d\n", i);
982 goto out;
983 }
984 }
985
986 /* Added some delay here, since opening/closing the camera quickly,
987 * like Ekiga does during its startup, can crash the webcam
988 */
989 mdelay(100);
990 cam->skip = 2;
ccbf035a
LVS		 991 ret = 0;
992
993out:
994 mutex_unlock(&q->vb_lock);
995
996 DBG("%s: V4L2_PIX_FMT_%s (%d) ok!\n", __func__,
997 decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name),
998 f->fmt.pix.field);
999 return ret;
1000}
1001
1002static int zr364xx_vidioc_reqbufs(struct file *file, void *priv,
1003 struct v4l2_requestbuffers *p)
1004{
1005 int rc;
1006 struct zr364xx_camera *cam = video_drvdata(file);
1007 rc = videobuf_reqbufs(&cam->vb_vidq, p);
1008 return rc;
1009}
1010
1011static int zr364xx_vidioc_querybuf(struct file *file,
1012 void *priv,
1013 struct v4l2_buffer *p)
1014{
1015 int rc;
1016 struct zr364xx_camera *cam = video_drvdata(file);
1017 rc = videobuf_querybuf(&cam->vb_vidq, p);
1018 return rc;
1019}
1020
1021static int zr364xx_vidioc_qbuf(struct file *file,
1022 void *priv,
1023 struct v4l2_buffer *p)
1024{
1025 int rc;
1026 struct zr364xx_camera *cam = video_drvdata(file);
76594c53 1027 _DBG("%s\n", __func__);
ccbf035a
LVS		 1028 rc = videobuf_qbuf(&cam->vb_vidq, p);
1029 return rc;
1030}
1031
1032static int zr364xx_vidioc_dqbuf(struct file *file,
1033 void *priv,
1034 struct v4l2_buffer *p)
1035{
1036 int rc;
1037 struct zr364xx_camera *cam = video_drvdata(file);
76594c53 1038 _DBG("%s\n", __func__);
ccbf035a
LVS		 1039 rc = videobuf_dqbuf(&cam->vb_vidq, p, file->f_flags & O_NONBLOCK);
1040 return rc;
1041}
1042
1043static void read_pipe_completion(struct urb *purb)
1044{
1045 struct zr364xx_pipeinfo *pipe_info;
1046 struct zr364xx_camera *cam;
1047 int pipe;
1048
1049 pipe_info = purb->context;
76594c53 1050 _DBG("%s %p, status %d\n", __func__, purb, purb->status);
ccbf035a
LVS		 1051 if (pipe_info == NULL) {
1052 printk(KERN_ERR KBUILD_MODNAME ": no context!\n");
1053 return;
1054 }
1055
1056 cam = pipe_info->cam;
1057 if (cam == NULL) {
1058 printk(KERN_ERR KBUILD_MODNAME ": no context!\n");
1059 return;
1060 }
1061
1062 /* if shutting down, do not resubmit, exit immediately */
1063 if (purb->status == -ESHUTDOWN) {
1064 DBG("%s, err shutdown\n", __func__);
1065 pipe_info->err_count++;
1066 return;
1067 }
1068
1069 if (pipe_info->state == 0) {
1070 DBG("exiting USB pipe\n");
1071 return;
1072 }
1073
1074 if (purb->actual_length < 0 ||
1075 purb->actual_length > pipe_info->transfer_size) {
1076 dev_err(&cam->udev->dev, "wrong number of bytes\n");
1077 return;
1078 }
1079
1080 if (purb->status == 0)
1081 zr364xx_read_video_callback(cam, pipe_info, purb);
1082 else {
1083 pipe_info->err_count++;
1084 DBG("%s: failed URB %d\n", __func__, purb->status);
1085 }
1086
1087 pipe = usb_rcvbulkpipe(cam->udev, cam->read_endpoint);
1088
1089 /* reuse urb */
1090 usb_fill_bulk_urb(pipe_info->stream_urb, cam->udev,
1091 pipe,
1092 pipe_info->transfer_buffer,
1093 pipe_info->transfer_size,
1094 read_pipe_completion, pipe_info);
1095
1096 if (pipe_info->state != 0) {
1097 purb->status = usb_submit_urb(pipe_info->stream_urb,
1098 GFP_ATOMIC);
1099
1100 if (purb->status)
1101 dev_err(&cam->udev->dev,
1102 "error submitting urb (error=%i)\n",
1103 purb->status);
1104 } else
1105 DBG("read pipe complete state 0\n");
1106}
1107
1108static int zr364xx_start_readpipe(struct zr364xx_camera *cam)
1109{
1110 int pipe;
1111 int retval;
1112 struct zr364xx_pipeinfo *pipe_info = cam->pipe;
1113 pipe = usb_rcvbulkpipe(cam->udev, cam->read_endpoint);
1114 DBG("%s: start pipe IN x%x\n", __func__, cam->read_endpoint);
1115
1116 pipe_info->state = 1;
1117 pipe_info->err_count = 0;
1118 pipe_info->stream_urb = usb_alloc_urb(0, GFP_KERNEL);
1119 if (!pipe_info->stream_urb) {
1120 dev_err(&cam->udev->dev, "ReadStream: Unable to alloc URB\n");
1121 return -ENOMEM;
1122 }
1123 /* transfer buffer allocated in board_init */
1124 usb_fill_bulk_urb(pipe_info->stream_urb, cam->udev,
1125 pipe,
1126 pipe_info->transfer_buffer,
1127 pipe_info->transfer_size,
1128 read_pipe_completion, pipe_info);
1129
1130 DBG("submitting URB %p\n", pipe_info->stream_urb);
1131 retval = usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL);
1132 if (retval) {
1133 printk(KERN_ERR KBUILD_MODNAME ": start read pipe failed\n");
1134 return retval;
1135 }
1136
1137 return 0;
1138}
1139
1140static void zr364xx_stop_readpipe(struct zr364xx_camera *cam)
1141{
1142 struct zr364xx_pipeinfo *pipe_info;
1143
1144 if (cam == NULL) {
1145 printk(KERN_ERR KBUILD_MODNAME ": invalid device\n");
1146 return;
1147 }
1148 DBG("stop read pipe\n");
1149 pipe_info = cam->pipe;
1150 if (pipe_info) {
1151 if (pipe_info->state != 0)
1152 pipe_info->state = 0;
1153
1154 if (pipe_info->stream_urb) {
1155 /* cancel urb */
1156 usb_kill_urb(pipe_info->stream_urb);
1157 usb_free_urb(pipe_info->stream_urb);
1158 pipe_info->stream_urb = NULL;
1159 }
1160 }
ccbf035a
LVS		 1161 return;
1162}
1163
1164/* starts acquisition process */
1165static int zr364xx_start_acquire(struct zr364xx_camera *cam)
1166{
1167 int j;
1168
1169 DBG("start acquire\n");
1170
1171 cam->last_frame = -1;
1172 cam->cur_frame = 0;
1173 for (j = 0; j < FRAMES; j++) {
1174 cam->buffer.frame[j].ulState = ZR364XX_READ_IDLE;
1175 cam->buffer.frame[j].cur_size = 0;
1176 }
8c5f32ac 1177 cam->b_acquire = 1;
ccbf035a
LVS		 1178 return 0;
1179}
1180
1181static inline int zr364xx_stop_acquire(struct zr364xx_camera *cam)
1182{
1183 cam->b_acquire = 0;
b7eee616
AJ		 1184 return 0;
1185}
1186
1187static int zr364xx_vidioc_streamon(struct file *file, void *priv,
1188 enum v4l2_buf_type type)
1189{
ccbf035a
LVS		 1190 struct zr364xx_camera *cam = video_drvdata(file);
1191 int j;
1192 int res;
1193
1194 DBG("%s\n", __func__);
1195
1196 if (cam->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1197 dev_err(&cam->udev->dev, "invalid fh type0\n");
1198 return -EINVAL;
1199 }
1200 if (cam->type != type) {
1201 dev_err(&cam->udev->dev, "invalid fh type1\n");
1202 return -EINVAL;
1203 }
1204
1205 if (!res_get(cam)) {
1206 dev_err(&cam->udev->dev, "stream busy\n");
1207 return -EBUSY;
1208 }
1209
1210 cam->last_frame = -1;
1211 cam->cur_frame = 0;
1212 cam->frame_count = 0;
1213 for (j = 0; j < FRAMES; j++) {
1214 cam->buffer.frame[j].ulState = ZR364XX_READ_IDLE;
1215 cam->buffer.frame[j].cur_size = 0;
1216 }
1217 res = videobuf_streamon(&cam->vb_vidq);
1218 if (res == 0) {
1219 zr364xx_start_acquire(cam);
ccbf035a
LVS		 1220 } else {
1221 res_free(cam);
1222 }
ccbf035a 1223 return res;
b7eee616
AJ		 1224}
1225
1226static int zr364xx_vidioc_streamoff(struct file *file, void *priv,
1227 enum v4l2_buf_type type)
1228{
ccbf035a
LVS		 1229 int res;
1230 struct zr364xx_camera *cam = video_drvdata(file);
1231
1232 DBG("%s\n", __func__);
1233 if (cam->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1234 dev_err(&cam->udev->dev, "invalid fh type0\n");
1235 return -EINVAL;
1236 }
1237 if (cam->type != type) {
1238 dev_err(&cam->udev->dev, "invalid fh type1\n");
1239 return -EINVAL;
1240 }
1241 zr364xx_stop_acquire(cam);
1242 res = videobuf_streamoff(&cam->vb_vidq);
1243 if (res < 0)
1244 return res;
1245 res_free(cam);
b7eee616
AJ		 1246 return 0;
1247}
1248
1249
1250/* open the camera */
bec43661 1251static int zr364xx_open(struct file *file)
b7eee616
AJ		 1252{
1253 struct video_device *vdev = video_devdata(file);
ccbf035a 1254 struct zr364xx_camera *cam = video_drvdata(file);
b7eee616
AJ		 1255 struct usb_device *udev = cam->udev;
1256 int i, err;
1257
ccbf035a 1258 DBG("%s\n", __func__);
b7eee616 1259
ccbf035a 1260 mutex_lock(&cam->open_lock);
69025c93 1261
33d27a45
AJ		 1262 if (cam->users) {
1263 err = -EBUSY;
69025c93 1264 goto out;
33d27a45 1265 }
b7eee616 1266
b7eee616
AJ		 1267 for (i = 0; init[cam->method][i].size != -1; i++) {
1268 err =
1269 send_control_msg(udev, 1, init[cam->method][i].value,
1270 0, init[cam->method][i].bytes,
1271 init[cam->method][i].size);
1272 if (err < 0) {
a482f327
GKH		 1273 dev_err(&cam->udev->dev,
1274 "error during open sequence: %d\n", i);
69025c93 1275 goto out;
b7eee616
AJ		 1276 }
1277 }
1278
33d27a45
AJ		 1279 cam->skip = 2;
1280 cam->users++;
b7eee616 1281 file->private_data = vdev;
ccbf035a
LVS		 1282 cam->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1283 cam->fmt = formats;
1284
1285 videobuf_queue_vmalloc_init(&cam->vb_vidq, &zr364xx_video_qops,
1286 NULL, &cam->slock,
1287 cam->type,
1288 V4L2_FIELD_NONE,
1289 sizeof(struct zr364xx_buffer), cam);
b7eee616
AJ		 1290
1291 /* Added some delay here, since opening/closing the camera quickly,
1292 * like Ekiga does during its startup, can crash the webcam
1293 */
1294 mdelay(100);
69025c93 1295 err = 0;
b7eee616 1296
69025c93 1297out:
ccbf035a
LVS		 1298 mutex_unlock(&cam->open_lock);
1299 DBG("%s: %d\n", __func__, err);
69025c93 1300 return err;
b7eee616
AJ		 1301}
1302
ccbf035a
LVS		 1303static void zr364xx_destroy(struct zr364xx_camera *cam)
1304{
1305 unsigned long i;
1306
1307 if (!cam) {
1308 printk(KERN_ERR KBUILD_MODNAME ", %s: no device\n", __func__);
1309 return;
1310 }
1311 mutex_lock(&cam->open_lock);
1312 if (cam->vdev)
1313 video_unregister_device(cam->vdev);
1314 cam->vdev = NULL;
1315
1316 /* stops the read pipe if it is running */
1317 if (cam->b_acquire)
1318 zr364xx_stop_acquire(cam);
1319
1320 zr364xx_stop_readpipe(cam);
1321
1322 /* release sys buffers */
1323 for (i = 0; i < FRAMES; i++) {
1324 if (cam->buffer.frame[i].lpvbits) {
1325 DBG("vfree %p\n", cam->buffer.frame[i].lpvbits);
1326 vfree(cam->buffer.frame[i].lpvbits);
1327 }
1328 cam->buffer.frame[i].lpvbits = NULL;
1329 }
1330
1331 /* release transfer buffer */
1332 kfree(cam->pipe->transfer_buffer);
1333 cam->pipe->transfer_buffer = NULL;
ccbf035a
LVS		 1334 mutex_unlock(&cam->open_lock);
1335 kfree(cam);
1336 cam = NULL;
1337}
b7eee616
AJ		 1338
1339/* release the camera */
bec43661 1340static int zr364xx_release(struct file *file)
b7eee616 1341{
b7eee616
AJ		 1342 struct zr364xx_camera *cam;
1343 struct usb_device *udev;
1344 int i, err;
1345
ccbf035a
LVS		 1346 DBG("%s\n", __func__);
1347 cam = video_drvdata(file);
b7eee616 1348
ccbf035a 1349 if (!cam)
b7eee616 1350 return -ENODEV;
b7eee616 1351
ccbf035a 1352 mutex_lock(&cam->open_lock);
b7eee616
AJ		 1353 udev = cam->udev;
1354
ccbf035a
LVS		 1355 /* turn off stream */
1356 if (res_check(cam)) {
1357 if (cam->b_acquire)
1358 zr364xx_stop_acquire(cam);
1359 videobuf_streamoff(&cam->vb_vidq);
1360 res_free(cam);
1361 }
33d27a45
AJ		 1362
1363 cam->users--;
1364 file->private_data = NULL;
1365
b7eee616
AJ		 1366 for (i = 0; i < 2; i++) {
1367 err =
1368 send_control_msg(udev, 1, init[cam->method][i].value,
7b808924 1369 0, init[cam->method][i].bytes,
b7eee616
AJ		 1370 init[cam->method][i].size);
1371 if (err < 0) {
a482f327 1372 dev_err(&udev->dev, "error during release sequence\n");
33d27a45 1373 goto out;
b7eee616
AJ		 1374 }
1375 }
1376
b7eee616
AJ		 1377 /* Added some delay here, since opening/closing the camera quickly,
1378 * like Ekiga does during its startup, can crash the webcam
1379 */
1380 mdelay(100);
33d27a45 1381 err = 0;
b7eee616 1382
33d27a45 1383out:
ccbf035a
LVS		 1384 mutex_unlock(&cam->open_lock);
1385
33d27a45 1386 return err;
b7eee616
AJ		 1387}
1388
1389
1390static int zr364xx_mmap(struct file *file, struct vm_area_struct *vma)
1391{
ccbf035a
LVS		 1392 struct zr364xx_camera *cam = video_drvdata(file);
1393 int ret;
b7eee616 1394
ccbf035a
LVS		 1395 if (cam == NULL) {
1396 DBG("%s: cam == NULL\n", __func__);
b7eee616 1397 return -ENODEV;
b7eee616 1398 }
ccbf035a 1399 DBG("mmap called, vma=0x%08lx\n", (unsigned long)vma);
b7eee616 1400
ccbf035a
LVS		 1401 ret = videobuf_mmap_mapper(&cam->vb_vidq, vma);
1402
1403 DBG("vma start=0x%08lx, size=%ld, ret=%d\n",
1404 (unsigned long)vma->vm_start,
1405 (unsigned long)vma->vm_end - (unsigned long)vma->vm_start, ret);
1406 return ret;
b7eee616
AJ		 1407}
1408
ccbf035a
LVS		 1409static unsigned int zr364xx_poll(struct file *file,
1410 struct poll_table_struct *wait)
1411{
1412 struct zr364xx_camera *cam = video_drvdata(file);
1413 struct videobuf_queue *q = &cam->vb_vidq;
76594c53 1414 _DBG("%s\n", __func__);
ccbf035a
LVS		 1415
1416 if (cam->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1417 return POLLERR;
1418
1419 return videobuf_poll_stream(file, q, wait);
1420}
b7eee616 1421
bec43661 1422static const struct v4l2_file_operations zr364xx_fops = {
b7eee616
AJ		 1423 .owner = THIS_MODULE,
1424 .open = zr364xx_open,
1425 .release = zr364xx_release,
1426 .read = zr364xx_read,
1427 .mmap = zr364xx_mmap,
1428 .ioctl = video_ioctl2,
ccbf035a 1429 .poll = zr364xx_poll,
b7eee616
AJ		 1430};
1431
a399810c 1432static const struct v4l2_ioctl_ops zr364xx_ioctl_ops = {
b7eee616 1433 .vidioc_querycap = zr364xx_vidioc_querycap,
78b526a4
HV		 1434 .vidioc_enum_fmt_vid_cap = zr364xx_vidioc_enum_fmt_vid_cap,
1435 .vidioc_try_fmt_vid_cap = zr364xx_vidioc_try_fmt_vid_cap,
1436 .vidioc_s_fmt_vid_cap = zr364xx_vidioc_s_fmt_vid_cap,
1437 .vidioc_g_fmt_vid_cap = zr364xx_vidioc_g_fmt_vid_cap,
b7eee616
AJ		 1438 .vidioc_enum_input = zr364xx_vidioc_enum_input,
1439 .vidioc_g_input = zr364xx_vidioc_g_input,
1440 .vidioc_s_input = zr364xx_vidioc_s_input,
1441 .vidioc_streamon = zr364xx_vidioc_streamon,
1442 .vidioc_streamoff = zr364xx_vidioc_streamoff,
1443 .vidioc_queryctrl = zr364xx_vidioc_queryctrl,
1444 .vidioc_g_ctrl = zr364xx_vidioc_g_ctrl,
1445 .vidioc_s_ctrl = zr364xx_vidioc_s_ctrl,
ccbf035a
LVS		 1446 .vidioc_reqbufs = zr364xx_vidioc_reqbufs,
1447 .vidioc_querybuf = zr364xx_vidioc_querybuf,
1448 .vidioc_qbuf = zr364xx_vidioc_qbuf,
1449 .vidioc_dqbuf = zr364xx_vidioc_dqbuf,
b7eee616
AJ		 1450};
1451
a399810c 1452static struct video_device zr364xx_template = {
a399810c 1453 .name = DRIVER_DESC,
a399810c
HV		 1454 .fops = &zr364xx_fops,
1455 .ioctl_ops = &zr364xx_ioctl_ops,
1456 .release = video_device_release,
1457 .minor = -1,
1458};
1459
b7eee616
AJ		 1460
1461
1462/*******************/
1463/* USB integration */
1464/*******************/
ccbf035a
LVS		 1465static int zr364xx_board_init(struct zr364xx_camera *cam)
1466{
1467 struct zr364xx_pipeinfo *pipe = cam->pipe;
1468 unsigned long i;
1469
1470 DBG("board init: %p\n", cam);
1471 memset(pipe, 0, sizeof(*pipe));
1472 pipe->cam = cam;
1473 pipe->transfer_size = BUFFER_SIZE;
1474
1475 pipe->transfer_buffer = kzalloc(pipe->transfer_size,
1476 GFP_KERNEL);
1477 if (pipe->transfer_buffer == NULL) {
1478 DBG("out of memory!\n");
1479 return -ENOMEM;
1480 }
1481
1482 cam->b_acquire = 0;
1483 cam->frame_count = 0;
1484
1485 /*** start create system buffers ***/
1486 for (i = 0; i < FRAMES; i++) {
1487 /* always allocate maximum size for system buffers */
1488 cam->buffer.frame[i].lpvbits = vmalloc(MAX_FRAME_SIZE);
1489
1490 DBG("valloc %p, idx %lu, pdata %p\n",
1491 &cam->buffer.frame[i], i,
1492 cam->buffer.frame[i].lpvbits);
1493 if (cam->buffer.frame[i].lpvbits == NULL) {
1494 printk(KERN_INFO KBUILD_MODNAME ": out of memory. "
1495 "Using less frames\n");
1496 break;
1497 }
1498 }
1499
1500 if (i == 0) {
1501 printk(KERN_INFO KBUILD_MODNAME ": out of memory. Aborting\n");
1502 kfree(cam->pipe->transfer_buffer);
1503 cam->pipe->transfer_buffer = NULL;
1504 return -ENOMEM;
1505 } else
1506 cam->buffer.dwFrames = i;
1507
1508 /* make sure internal states are set */
1509 for (i = 0; i < FRAMES; i++) {
1510 cam->buffer.frame[i].ulState = ZR364XX_READ_IDLE;
1511 cam->buffer.frame[i].cur_size = 0;
1512 }
1513
1514 cam->cur_frame = 0;
1515 cam->last_frame = -1;
1516 /*** end create system buffers ***/
1517
1518 /* start read pipe */
1519 zr364xx_start_readpipe(cam);
1520 DBG(": board initialized\n");
1521 return 0;
1522}
b7eee616
AJ		 1523
1524static int zr364xx_probe(struct usb_interface *intf,
1525 const struct usb_device_id *id)
1526{
1527 struct usb_device *udev = interface_to_usbdev(intf);
1528 struct zr364xx_camera *cam = NULL;
ccbf035a
LVS		 1529 struct usb_host_interface *iface_desc;
1530 struct usb_endpoint_descriptor *endpoint;
783aa8fa 1531 int err;
ccbf035a 1532 int i;
b7eee616 1533
ccbf035a 1534 DBG("probing...\n");
b7eee616 1535
a482f327
GKH		 1536 dev_info(&intf->dev, DRIVER_DESC " compatible webcam plugged\n");
1537 dev_info(&intf->dev, "model %04x:%04x detected\n",
1538 le16_to_cpu(udev->descriptor.idVendor),
1539 le16_to_cpu(udev->descriptor.idProduct));
b7eee616 1540
783aa8fa
AM		 1541 cam = kzalloc(sizeof(struct zr364xx_camera), GFP_KERNEL);
1542 if (cam == NULL) {
a482f327 1543 dev_err(&udev->dev, "cam: out of memory !\n");
783aa8fa 1544 return -ENOMEM;
b7eee616 1545 }
b7eee616
AJ		 1546 /* save the init method used by this camera */
1547 cam->method = id->driver_info;
1548
1549 cam->vdev = video_device_alloc();
1550 if (cam->vdev == NULL) {
a482f327 1551 dev_err(&udev->dev, "cam->vdev: out of memory !\n");
b7eee616 1552 kfree(cam);
ccbf035a 1553 cam = NULL;
783aa8fa 1554 return -ENOMEM;
b7eee616
AJ		 1555 }
1556 memcpy(cam->vdev, &zr364xx_template, sizeof(zr364xx_template));
ccbf035a 1557 cam->vdev->parent = &intf->dev;
b7eee616
AJ		 1558 video_set_drvdata(cam->vdev, cam);
1559 if (debug)
1560 cam->vdev->debug = V4L2_DEBUG_IOCTL | V4L2_DEBUG_IOCTL_ARG;
1561
1562 cam->udev = udev;
1563
b7eee616
AJ		 1564 switch (mode) {
1565 case 1:
a482f327 1566 dev_info(&udev->dev, "160x120 mode selected\n");
b7eee616
AJ		 1567 cam->width = 160;
1568 cam->height = 120;
1569 break;
1570 case 2:
a482f327 1571 dev_info(&udev->dev, "640x480 mode selected\n");
b7eee616
AJ		 1572 cam->width = 640;
1573 cam->height = 480;
1574 break;
1575 default:
a482f327 1576 dev_info(&udev->dev, "320x240 mode selected\n");
b7eee616
AJ		 1577 cam->width = 320;
1578 cam->height = 240;
1579 break;
1580 }
1581
1582 m0d1[0] = mode;
1583 m1[2].value = 0xf000 + mode;
1584 m2[1].value = 0xf000 + mode;
1585 header2[437] = cam->height / 256;
1586 header2[438] = cam->height % 256;
1587 header2[439] = cam->width / 256;
1588 header2[440] = cam->width % 256;
1589
ccbf035a 1590 cam->users = 0;
b7eee616 1591 cam->nb = 0;
ccbf035a 1592 cam->mode.brightness = 64;
b7eee616 1593 mutex_init(&cam->lock);
ccbf035a
LVS		 1594 mutex_init(&cam->open_lock);
1595
1596 DBG("dev: %p, udev %p interface %p\n", cam, cam->udev, intf);
1597
1598 /* set up the endpoint information */
1599 iface_desc = intf->cur_altsetting;
1600 DBG("num endpoints %d\n", iface_desc->desc.bNumEndpoints);
1601 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1602 endpoint = &iface_desc->endpoint[i].desc;
1603 if (!cam->read_endpoint && usb_endpoint_is_bulk_in(endpoint)) {
1604 /* we found the bulk in endpoint */
1605 cam->read_endpoint = endpoint->bEndpointAddress;
1606 }
1607 }
b7eee616 1608
ccbf035a
LVS		 1609 if (!cam->read_endpoint) {
1610 dev_err(&intf->dev, "Could not find bulk-in endpoint\n");
1611 return -ENOMEM;
1612 }
1613
1614 /* v4l */
1615 INIT_LIST_HEAD(&cam->vidq.active);
1616 cam->vidq.cam = cam;
783aa8fa
AM		 1617 err = video_register_device(cam->vdev, VFL_TYPE_GRABBER, -1);
1618 if (err) {
a482f327 1619 dev_err(&udev->dev, "video_register_device failed\n");
b7eee616 1620 video_device_release(cam->vdev);
b7eee616 1621 kfree(cam);
ccbf035a 1622 cam = NULL;
783aa8fa 1623 return err;
b7eee616
AJ		 1624 }
1625
1626 usb_set_intfdata(intf, cam);
1627
ccbf035a
LVS		 1628 /* load zr364xx board specific */
1629 err = zr364xx_board_init(cam);
1630 if (err) {
1631 spin_lock_init(&cam->slock);
1632 return err;
1633 }
1634
1635 spin_lock_init(&cam->slock);
1636
a482f327 1637 dev_info(&udev->dev, DRIVER_DESC " controlling video device %d\n",
c6330fb8 1638 cam->vdev->num);
b7eee616
AJ		 1639 return 0;
1640}
1641
1642
1643static void zr364xx_disconnect(struct usb_interface *intf)
1644{
1645 struct zr364xx_camera *cam = usb_get_intfdata(intf);
ccbf035a 1646 videobuf_mmap_free(&cam->vb_vidq);
b7eee616 1647 usb_set_intfdata(intf, NULL);
a482f327 1648 dev_info(&intf->dev, DRIVER_DESC " webcam unplugged\n");
ccbf035a 1649 zr364xx_destroy(cam);
b7eee616
AJ		 1650}
1651
1652
1653
1654/**********************/
1655/* Module integration */
1656/**********************/
1657
1658static struct usb_driver zr364xx_driver = {
1659 .name = "zr364xx",
1660 .probe = zr364xx_probe,
1661 .disconnect = zr364xx_disconnect,
1662 .id_table = device_table
1663};
1664
1665
1666static int __init zr364xx_init(void)
1667{
1668 int retval;
783aa8fa 1669 retval = usb_register(&zr364xx_driver);
b7eee616 1670 if (retval)
a482f327 1671 printk(KERN_ERR KBUILD_MODNAME ": usb_register failed!\n");
b7eee616 1672 else
a482f327 1673 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
b7eee616
AJ		 1674 return retval;
1675}
1676
1677
1678static void __exit zr364xx_exit(void)
1679{
a482f327 1680 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC " module unloaded\n");
b7eee616
AJ		 1681 usb_deregister(&zr364xx_driver);
1682}
1683
1684
1685module_init(zr364xx_init);
1686module_exit(zr364xx_exit);
1687
1688MODULE_AUTHOR(DRIVER_AUTHOR);
1689MODULE_DESCRIPTION(DRIVER_DESC);
1690MODULE_LICENSE("GPL");
Ubuntu Jammy Linux kernel mirror