projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
V4L/DVB (13554a): v4l: Use the video_drvdata function in drivers
[linux-2.6-block.git] / drivers / media / video / s2255drv.c
CommitLineData
38f993ad
DA		 1/*
2 * s2255drv.c - a driver for the Sensoray 2255 USB video capture device
3 *
4 * Copyright (C) 2007-2008 by Sensoray Company Inc.
5 * Dean Anderson
6 *
7 * Some video buffer code based on vivi driver:
8 *
9 * Sensoray 2255 device supports 4 simultaneous channels.
10 * The channels are not "crossbar" inputs, they are physically
11 * attached to separate video decoders.
12 *
13 * Because of USB2.0 bandwidth limitations. There is only a
14 * certain amount of data which may be transferred at one time.
15 *
16 * Example maximum bandwidth utilization:
17 *
18 * -full size, color mode YUYV or YUV422P: 2 channels at once
19 *
20 * -full or half size Grey scale: all 4 channels at once
21 *
22 * -half size, color mode YUYV or YUV422P: all 4 channels at once
23 *
24 * -full size, color mode YUYV or YUV422P 1/2 frame rate: all 4 channels
25 * at once.
26 * (TODO: Incorporate videodev2 frame rate(FR) enumeration,
27 * which is currently experimental.)
28 *
29 * This program is free software; you can redistribute it and/or modify
30 * it under the terms of the GNU General Public License as published by
31 * the Free Software Foundation; either version 2 of the License, or
32 * (at your option) any later version.
33 *
34 * This program is distributed in the hope that it will be useful,
35 * but WITHOUT ANY WARRANTY; without even the implied warranty of
36 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
37 * GNU General Public License for more details.
38 *
39 * You should have received a copy of the GNU General Public License
40 * along with this program; if not, write to the Free Software
41 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
42 */
43
44#include <linux/module.h>
45#include <linux/firmware.h>
46#include <linux/kernel.h>
47#include <linux/mutex.h>
48#include <linux/videodev2.h>
49#include <linux/version.h>
feb75f07 50#include <linux/mm.h>
405f5571 51#include <linux/smp_lock.h>
38f993ad
DA		 52#include <media/videobuf-vmalloc.h>
53#include <media/v4l2-common.h>
35ea11ff 54#include <media/v4l2-ioctl.h>
38f993ad
DA		 55#include <linux/vmalloc.h>
56#include <linux/usb.h>
57
58#define FIRMWARE_FILE_NAME "f2255usb.bin"
59
60
61
22b88d48
DA		 62/* default JPEG quality */
63#define S2255_DEF_JPEG_QUAL 50
38f993ad
DA		 64/* vendor request in */
65#define S2255_VR_IN 0
66/* vendor request out */
67#define S2255_VR_OUT 1
68/* firmware query */
69#define S2255_VR_FW 0x30
70/* USB endpoint number for configuring the device */
71#define S2255_CONFIG_EP 2
72/* maximum time for DSP to start responding after last FW word loaded(ms) */
14d96260 73#define S2255_DSP_BOOTTIME 800
38f993ad 74/* maximum time to wait for firmware to load (ms) */
3f8d6f73 75#define S2255_LOAD_TIMEOUT (5000 + S2255_DSP_BOOTTIME)
38f993ad 76#define S2255_DEF_BUFS 16
14d96260 77#define S2255_SETMODE_TIMEOUT 500
38f993ad 78#define MAX_CHANNELS 4
14d96260
DA		 79#define S2255_MARKER_FRAME 0x2255DA4AL
80#define S2255_MARKER_RESPONSE 0x2255ACACL
abce21f4
DA		 81#define S2255_RESPONSE_SETMODE 0x01
82#define S2255_RESPONSE_FW 0x10
14d96260 83#define S2255_USB_XFER_SIZE (16 * 1024)
38f993ad
DA		 84#define MAX_CHANNELS 4
85#define MAX_PIPE_BUFFERS 1
86#define SYS_FRAMES 4
87/* maximum size is PAL full size plus room for the marker header(s) */
14d96260
DA		 88#define SYS_FRAMES_MAXSIZE (720*288*2*2 + 4096)
89#define DEF_USB_BLOCK S2255_USB_XFER_SIZE
38f993ad
DA		 90#define LINE_SZ_4CIFS_NTSC 640
91#define LINE_SZ_2CIFS_NTSC 640
92#define LINE_SZ_1CIFS_NTSC 320
93#define LINE_SZ_4CIFS_PAL 704
94#define LINE_SZ_2CIFS_PAL 704
95#define LINE_SZ_1CIFS_PAL 352
96#define NUM_LINES_4CIFS_NTSC 240
97#define NUM_LINES_2CIFS_NTSC 240
98#define NUM_LINES_1CIFS_NTSC 240
99#define NUM_LINES_4CIFS_PAL 288
100#define NUM_LINES_2CIFS_PAL 288
101#define NUM_LINES_1CIFS_PAL 288
102#define LINE_SZ_DEF 640
103#define NUM_LINES_DEF 240
104
105
106/* predefined settings */
107#define FORMAT_NTSC 1
108#define FORMAT_PAL 2
109
110#define SCALE_4CIFS 1 /* 640x480(NTSC) or 704x576(PAL) */
111#define SCALE_2CIFS 2 /* 640x240(NTSC) or 704x288(PAL) */
112#define SCALE_1CIFS 3 /* 320x240(NTSC) or 352x288(PAL) */
7d853532
DA		 113/* SCALE_4CIFSI is the 2 fields interpolated into one */
114#define SCALE_4CIFSI 4 /* 640x480(NTSC) or 704x576(PAL) high quality */
38f993ad
DA		 115
116#define COLOR_YUVPL 1 /* YUV planar */
117#define COLOR_YUVPK 2 /* YUV packed */
118#define COLOR_Y8 4 /* monochrome */
14d96260
DA		 119#define COLOR_JPG 5 /* JPEG */
120#define MASK_COLOR 0xff
121#define MASK_JPG_QUALITY 0xff00
38f993ad
DA		 122
123/* frame decimation. Not implemented by V4L yet(experimental in V4L) */
124#define FDEC_1 1 /* capture every frame. default */
125#define FDEC_2 2 /* capture every 2nd frame */
126#define FDEC_3 3 /* capture every 3rd frame */
127#define FDEC_5 5 /* capture every 5th frame */
128
129/*-------------------------------------------------------
130 * Default mode parameters.
131 *-------------------------------------------------------*/
132#define DEF_SCALE SCALE_4CIFS
133#define DEF_COLOR COLOR_YUVPL
134#define DEF_FDEC FDEC_1
135#define DEF_BRIGHT 0
136#define DEF_CONTRAST 0x5c
137#define DEF_SATURATION 0x80
138#define DEF_HUE 0
139
140/* usb config commands */
141#define IN_DATA_TOKEN 0x2255c0de
142#define CMD_2255 0xc2255000
143#define CMD_SET_MODE (CMD_2255 | 0x10)
144#define CMD_START (CMD_2255 | 0x20)
145#define CMD_STOP (CMD_2255 | 0x30)
146#define CMD_STATUS (CMD_2255 | 0x40)
147
148struct s2255_mode {
149 u32 format; /* input video format (NTSC, PAL) */
150 u32 scale; /* output video scale */
151 u32 color; /* output video color format */
152 u32 fdec; /* frame decimation */
153 u32 bright; /* brightness */
154 u32 contrast; /* contrast */
155 u32 saturation; /* saturation */
156 u32 hue; /* hue (NTSC only)*/
157 u32 single; /* capture 1 frame at a time (!=0), continuously (==0)*/
158 u32 usb_block; /* block size. should be 4096 of DEF_USB_BLOCK */
159 u32 restart; /* if DSP requires restart */
160};
161
38f993ad 162
14d96260
DA		 163#define S2255_READ_IDLE 0
164#define S2255_READ_FRAME 1
38f993ad 165
14d96260 166/* frame structure */
38f993ad
DA		 167struct s2255_framei {
168 unsigned long size;
14d96260 169 unsigned long ulState; /* ulState:S2255_READ_IDLE, S2255_READ_FRAME*/
38f993ad
DA		 170 void *lpvbits; /* image data */
171 unsigned long cur_size; /* current data copied to it */
172};
173
174/* image buffer structure */
175struct s2255_bufferi {
176 unsigned long dwFrames; /* number of frames in buffer */
177 struct s2255_framei frame[SYS_FRAMES]; /* array of FRAME structures */
178};
179
180#define DEF_MODEI_NTSC_CONT {FORMAT_NTSC, DEF_SCALE, DEF_COLOR, \
181 DEF_FDEC, DEF_BRIGHT, DEF_CONTRAST, DEF_SATURATION, \
3f8d6f73 182 DEF_HUE, 0, DEF_USB_BLOCK, 0}
38f993ad
DA		 183
184struct s2255_dmaqueue {
185 struct list_head active;
38f993ad
DA		 186 struct s2255_dev *dev;
187 int channel;
188};
189
190/* for firmware loading, fw_state */
191#define S2255_FW_NOTLOADED 0
192#define S2255_FW_LOADED_DSPWAIT 1
193#define S2255_FW_SUCCESS 2
194#define S2255_FW_FAILED 3
f78d92c9 195#define S2255_FW_DISCONNECTING 4
38f993ad 196
deaf53e3 197#define S2255_FW_MARKER cpu_to_le32(0x22552f2f)
14d96260
DA		 198/* 2255 read states */
199#define S2255_READ_IDLE 0
200#define S2255_READ_FRAME 1
38f993ad
DA		 201struct s2255_fw {
202 int fw_loaded;
203 int fw_size;
204 struct urb *fw_urb;
205 atomic_t fw_state;
206 void *pfw_data;
207 wait_queue_head_t wait_fw;
38f993ad
DA		 208 const struct firmware *fw;
209};
210
211struct s2255_pipeinfo {
212 u32 max_transfer_size;
213 u32 cur_transfer_size;
214 u8 *transfer_buffer;
38f993ad 215 u32 state;
38f993ad
DA		 216 void *stream_urb;
217 void *dev; /* back pointer to s2255_dev struct*/
218 u32 err_count;
38f993ad 219 u32 idx;
38f993ad
DA		 220};
221
222struct s2255_fmt; /*forward declaration */
223
224struct s2255_dev {
225 int frames;
226 int users[MAX_CHANNELS];
227 struct mutex lock;
228 struct mutex open_lock;
229 int resources[MAX_CHANNELS];
230 struct usb_device *udev;
231 struct usb_interface *interface;
232 u8 read_endpoint;
233
234 struct s2255_dmaqueue vidq[MAX_CHANNELS];
235 struct video_device *vdev[MAX_CHANNELS];
38f993ad
DA		 236 struct timer_list timer;
237 struct s2255_fw *fw_data;
38f993ad
DA		 238 struct s2255_pipeinfo pipes[MAX_PIPE_BUFFERS];
239 struct s2255_bufferi buffer[MAX_CHANNELS];
240 struct s2255_mode mode[MAX_CHANNELS];
22b88d48
DA		 241 /* jpeg compression */
242 struct v4l2_jpegcompression jc[MAX_CHANNELS];
7d853532
DA		 243 /* capture parameters (for high quality mode full size) */
244 struct v4l2_captureparm cap_parm[MAX_CHANNELS];
38f993ad
DA		 245 const struct s2255_fmt *cur_fmt[MAX_CHANNELS];
246 int cur_frame[MAX_CHANNELS];
247 int last_frame[MAX_CHANNELS];
248 u32 cc; /* current channel */
249 int b_acquire[MAX_CHANNELS];
14d96260 250 /* allocated image size */
38f993ad 251 unsigned long req_image_size[MAX_CHANNELS];
14d96260
DA		 252 /* received packet size */
253 unsigned long pkt_size[MAX_CHANNELS];
38f993ad
DA		 254 int bad_payload[MAX_CHANNELS];
255 unsigned long frame_count[MAX_CHANNELS];
256 int frame_ready;
14d96260
DA		 257 /* if JPEG image */
258 int jpg_size[MAX_CHANNELS];
259 /* if channel configured to default state */
260 int chn_configured[MAX_CHANNELS];
261 wait_queue_head_t wait_setmode[MAX_CHANNELS];
262 int setmode_ready[MAX_CHANNELS];
263 int chn_ready;
38f993ad
DA		 264 struct kref kref;
265 spinlock_t slock;
266};
267#define to_s2255_dev(d) container_of(d, struct s2255_dev, kref)
268
269struct s2255_fmt {
270 char *name;
271 u32 fourcc;
272 int depth;
273};
274
275/* buffer for one video frame */
276struct s2255_buffer {
277 /* common v4l buffer stuff -- must be first */
278 struct videobuf_buffer vb;
279 const struct s2255_fmt *fmt;
280};
281
282struct s2255_fh {
283 struct s2255_dev *dev;
38f993ad
DA		 284 const struct s2255_fmt *fmt;
285 unsigned int width;
286 unsigned int height;
287 struct videobuf_queue vb_vidq;
288 enum v4l2_buf_type type;
289 int channel;
290 /* mode below is the desired mode.
291 mode in s2255_dev is the current mode that was last set */
292 struct s2255_mode mode;
f78d92c9 293 int resources[MAX_CHANNELS];
38f993ad
DA		 294};
295
abce21f4
DA		 296/* current cypress EEPROM firmware version */
297#define S2255_CUR_USB_FWVER ((3 << 8) | 6)
38f993ad 298#define S2255_MAJOR_VERSION 1
abce21f4 299#define S2255_MINOR_VERSION 14
38f993ad
DA		 300#define S2255_RELEASE 0
301#define S2255_VERSION KERNEL_VERSION(S2255_MAJOR_VERSION, \
302 S2255_MINOR_VERSION, \
303 S2255_RELEASE)
304
305/* vendor ids */
306#define USB_S2255_VENDOR_ID 0x1943
307#define USB_S2255_PRODUCT_ID 0x2255
308#define S2255_NORMS (V4L2_STD_PAL | V4L2_STD_NTSC)
309/* frame prefix size (sent once every frame) */
310#define PREFIX_SIZE 512
311
312/* Channels on box are in reverse order */
3f8d6f73 313static unsigned long G_chnmap[MAX_CHANNELS] = {3, 2, 1, 0};
38f993ad 314
38f993ad
DA		 315static int debug;
316static int *s2255_debug = &debug;
317
318static int s2255_start_readpipe(struct s2255_dev *dev);
319static void s2255_stop_readpipe(struct s2255_dev *dev);
320static int s2255_start_acquire(struct s2255_dev *dev, unsigned long chn);
321static int s2255_stop_acquire(struct s2255_dev *dev, unsigned long chn);
322static void s2255_fillbuff(struct s2255_dev *dev, struct s2255_buffer *buf,
14d96260 323 int chn, int jpgsize);
38f993ad
DA		 324static int s2255_set_mode(struct s2255_dev *dev, unsigned long chn,
325 struct s2255_mode *mode);
326static int s2255_board_shutdown(struct s2255_dev *dev);
327static void s2255_exit_v4l(struct s2255_dev *dev);
14d96260
DA		 328static void s2255_fwload_start(struct s2255_dev *dev, int reset);
329static void s2255_destroy(struct kref *kref);
330static long s2255_vendor_req(struct s2255_dev *dev, unsigned char req,
331 u16 index, u16 value, void *buf,
332 s32 buf_len, int bOut);
38f993ad 333
be9ed511
MCC		 334/* dev_err macro with driver name */
335#define S2255_DRIVER_NAME "s2255"
336#define s2255_dev_err(dev, fmt, arg...) \
337 dev_err(dev, S2255_DRIVER_NAME " - " fmt, ##arg)
338
38f993ad
DA		 339#define dprintk(level, fmt, arg...) \
340 do { \
341 if (*s2255_debug >= (level)) { \
be9ed511
MCC		 342 printk(KERN_DEBUG S2255_DRIVER_NAME \
343 ": " fmt, ##arg); \
38f993ad
DA		 344 } \
345 } while (0)
346
38f993ad
DA		 347static struct usb_driver s2255_driver;
348
349
350/* Declare static vars that will be used as parameters */
351static unsigned int vid_limit = 16; /* Video memory limit, in Mb */
352
353/* start video number */
354static int video_nr = -1; /* /dev/videoN, -1 for autodetect */
355
3f8d6f73 356module_param(debug, int, 0644);
38f993ad 357MODULE_PARM_DESC(debug, "Debug level(0-100) default 0");
3f8d6f73 358module_param(vid_limit, int, 0644);
38f993ad 359MODULE_PARM_DESC(vid_limit, "video memory limit(Mb)");
3f8d6f73 360module_param(video_nr, int, 0644);
38f993ad
DA		 361MODULE_PARM_DESC(video_nr, "start video minor(-1 default autodetect)");
362
363/* USB device table */
364static struct usb_device_id s2255_table[] = {
365 {USB_DEVICE(USB_S2255_VENDOR_ID, USB_S2255_PRODUCT_ID)},
366 { } /* Terminating entry */
367};
368MODULE_DEVICE_TABLE(usb, s2255_table);
369
370
371#define BUFFER_TIMEOUT msecs_to_jiffies(400)
372
373/* supported controls */
374static struct v4l2_queryctrl s2255_qctrl[] = {
375 {
376 .id = V4L2_CID_BRIGHTNESS,
377 .type = V4L2_CTRL_TYPE_INTEGER,
378 .name = "Brightness",
379 .minimum = -127,
380 .maximum = 128,
381 .step = 1,
382 .default_value = 0,
383 .flags = 0,
384 }, {
385 .id = V4L2_CID_CONTRAST,
386 .type = V4L2_CTRL_TYPE_INTEGER,
387 .name = "Contrast",
388 .minimum = 0,
389 .maximum = 255,
390 .step = 0x1,
391 .default_value = DEF_CONTRAST,
392 .flags = 0,
393 }, {
394 .id = V4L2_CID_SATURATION,
395 .type = V4L2_CTRL_TYPE_INTEGER,
396 .name = "Saturation",
397 .minimum = 0,
398 .maximum = 255,
399 .step = 0x1,
400 .default_value = DEF_SATURATION,
401 .flags = 0,
402 }, {
403 .id = V4L2_CID_HUE,
404 .type = V4L2_CTRL_TYPE_INTEGER,
405 .name = "Hue",
406 .minimum = 0,
407 .maximum = 255,
408 .step = 0x1,
409 .default_value = DEF_HUE,
410 .flags = 0,
411 }
412};
413
414static int qctl_regs[ARRAY_SIZE(s2255_qctrl)];
415
416/* image formats. */
417static const struct s2255_fmt formats[] = {
418 {
419 .name = "4:2:2, planar, YUV422P",
420 .fourcc = V4L2_PIX_FMT_YUV422P,
421 .depth = 16
422
423 }, {
424 .name = "4:2:2, packed, YUYV",
425 .fourcc = V4L2_PIX_FMT_YUYV,
426 .depth = 16
427
428 }, {
429 .name = "4:2:2, packed, UYVY",
430 .fourcc = V4L2_PIX_FMT_UYVY,
431 .depth = 16
14d96260
DA		 432 }, {
433 .name = "JPG",
434 .fourcc = V4L2_PIX_FMT_JPEG,
435 .depth = 24
38f993ad
DA		 436 }, {
437 .name = "8bpp GREY",
438 .fourcc = V4L2_PIX_FMT_GREY,
439 .depth = 8
440 }
441};
442
443static int norm_maxw(struct video_device *vdev)
444{
445 return (vdev->current_norm & V4L2_STD_NTSC) ?
446 LINE_SZ_4CIFS_NTSC : LINE_SZ_4CIFS_PAL;
447}
448
449static int norm_maxh(struct video_device *vdev)
450{
451 return (vdev->current_norm & V4L2_STD_NTSC) ?
452 (NUM_LINES_1CIFS_NTSC * 2) : (NUM_LINES_1CIFS_PAL * 2);
453}
454
455static int norm_minw(struct video_device *vdev)
456{
457 return (vdev->current_norm & V4L2_STD_NTSC) ?
458 LINE_SZ_1CIFS_NTSC : LINE_SZ_1CIFS_PAL;
459}
460
461static int norm_minh(struct video_device *vdev)
462{
463 return (vdev->current_norm & V4L2_STD_NTSC) ?
464 (NUM_LINES_1CIFS_NTSC) : (NUM_LINES_1CIFS_PAL);
465}
466
467
3f8d6f73
DA		 468/*
469 * TODO: fixme: move YUV reordering to hardware
470 * converts 2255 planar format to yuyv or uyvy
471 */
38f993ad
DA		 472static void planar422p_to_yuv_packed(const unsigned char *in,
473 unsigned char *out,
474 int width, int height,
475 int fmt)
476{
477 unsigned char *pY;
478 unsigned char *pCb;
479 unsigned char *pCr;
480 unsigned long size = height * width;
481 unsigned int i;
482 pY = (unsigned char *)in;
483 pCr = (unsigned char *)in + height * width;
484 pCb = (unsigned char *)in + height * width + (height * width / 2);
485 for (i = 0; i < size * 2; i += 4) {
486 out[i] = (fmt == V4L2_PIX_FMT_YUYV) ? *pY++ : *pCr++;
487 out[i + 1] = (fmt == V4L2_PIX_FMT_YUYV) ? *pCr++ : *pY++;
488 out[i + 2] = (fmt == V4L2_PIX_FMT_YUYV) ? *pY++ : *pCb++;
489 out[i + 3] = (fmt == V4L2_PIX_FMT_YUYV) ? *pCb++ : *pY++;
490 }
491 return;
492}
493
d45b9b8a 494static void s2255_reset_dsppower(struct s2255_dev *dev)
14d96260
DA		 495{
496 s2255_vendor_req(dev, 0x40, 0x0b0b, 0x0b0b, NULL, 0, 1);
497 msleep(10);
498 s2255_vendor_req(dev, 0x50, 0x0000, 0x0000, NULL, 0, 1);
499 return;
500}
38f993ad
DA		 501
502/* kickstarts the firmware loading. from probe
503 */
504static void s2255_timer(unsigned long user_data)
505{
506 struct s2255_fw *data = (struct s2255_fw *)user_data;
507 dprintk(100, "s2255 timer\n");
508 if (usb_submit_urb(data->fw_urb, GFP_ATOMIC) < 0) {
509 printk(KERN_ERR "s2255: can't submit urb\n");
f78d92c9
DA		 510 atomic_set(&data->fw_state, S2255_FW_FAILED);
511 /* wake up anything waiting for the firmware */
512 wake_up(&data->wait_fw);
38f993ad
DA		 513 return;
514 }
515}
516
38f993ad
DA		 517
518/* this loads the firmware asynchronously.
519 Originally this was done synchroously in probe.
520 But it is better to load it asynchronously here than block
521 inside the probe function. Blocking inside probe affects boot time.
522 FW loading is triggered by the timer in the probe function
523*/
524static void s2255_fwchunk_complete(struct urb *urb)
525{
526 struct s2255_fw *data = urb->context;
527 struct usb_device *udev = urb->dev;
528 int len;
529 dprintk(100, "udev %p urb %p", udev, urb);
38f993ad 530 if (urb->status) {
be9ed511 531 dev_err(&udev->dev, "URB failed with status %d\n", urb->status);
f78d92c9
DA		 532 atomic_set(&data->fw_state, S2255_FW_FAILED);
533 /* wake up anything waiting for the firmware */
534 wake_up(&data->wait_fw);
38f993ad
DA		 535 return;
536 }
537 if (data->fw_urb == NULL) {
be9ed511 538 s2255_dev_err(&udev->dev, "disconnected\n");
f78d92c9
DA		 539 atomic_set(&data->fw_state, S2255_FW_FAILED);
540 /* wake up anything waiting for the firmware */
541 wake_up(&data->wait_fw);
38f993ad
DA		 542 return;
543 }
544#define CHUNK_SIZE 512
545 /* all USB transfers must be done with continuous kernel memory.
546 can't allocate more than 128k in current linux kernel, so
547 upload the firmware in chunks
548 */
549 if (data->fw_loaded < data->fw_size) {
550 len = (data->fw_loaded + CHUNK_SIZE) > data->fw_size ?
551 data->fw_size % CHUNK_SIZE : CHUNK_SIZE;
552
553 if (len < CHUNK_SIZE)
554 memset(data->pfw_data, 0, CHUNK_SIZE);
555
556 dprintk(100, "completed len %d, loaded %d \n", len,
557 data->fw_loaded);
558
559 memcpy(data->pfw_data,
560 (char *) data->fw->data + data->fw_loaded, len);
561
562 usb_fill_bulk_urb(data->fw_urb, udev, usb_sndbulkpipe(udev, 2),
563 data->pfw_data, CHUNK_SIZE,
564 s2255_fwchunk_complete, data);
565 if (usb_submit_urb(data->fw_urb, GFP_ATOMIC) < 0) {
566 dev_err(&udev->dev, "failed submit URB\n");
567 atomic_set(&data->fw_state, S2255_FW_FAILED);
568 /* wake up anything waiting for the firmware */
569 wake_up(&data->wait_fw);
570 return;
571 }
572 data->fw_loaded += len;
573 } else {
38f993ad 574 atomic_set(&data->fw_state, S2255_FW_LOADED_DSPWAIT);
38f993ad
DA		 575 }
576 dprintk(100, "2255 complete done\n");
577 return;
578
579}
580
14d96260 581static int s2255_got_frame(struct s2255_dev *dev, int chn, int jpgsize)
38f993ad
DA		 582{
583 struct s2255_dmaqueue *dma_q = &dev->vidq[chn];
584 struct s2255_buffer *buf;
585 unsigned long flags = 0;
586 int rc = 0;
587 dprintk(2, "wakeup: %p channel: %d\n", &dma_q, chn);
588 spin_lock_irqsave(&dev->slock, flags);
589
590 if (list_empty(&dma_q->active)) {
591 dprintk(1, "No active queue to serve\n");
592 rc = -1;
593 goto unlock;
594 }
595 buf = list_entry(dma_q->active.next,
596 struct s2255_buffer, vb.queue);
597
38f993ad
DA		 598 list_del(&buf->vb.queue);
599 do_gettimeofday(&buf->vb.ts);
600 dprintk(100, "[%p/%d] wakeup\n", buf, buf->vb.i);
14d96260 601 s2255_fillbuff(dev, buf, dma_q->channel, jpgsize);
38f993ad
DA		 602 wake_up(&buf->vb.done);
603 dprintk(2, "wakeup [buf/i] [%p/%d]\n", buf, buf->vb.i);
604unlock:
605 spin_unlock_irqrestore(&dev->slock, flags);
606 return 0;
607}
608
609
610static const struct s2255_fmt *format_by_fourcc(int fourcc)
611{
612 unsigned int i;
613
614 for (i = 0; i < ARRAY_SIZE(formats); i++) {
615 if (-1 == formats[i].fourcc)
616 continue;
617 if (formats[i].fourcc == fourcc)
618 return formats + i;
619 }
620 return NULL;
621}
622
623
624
625
626/* video buffer vmalloc implementation based partly on VIVI driver which is
627 * Copyright (c) 2006 by
628 * Mauro Carvalho Chehab <mchehab--a.t--infradead.org>
629 * Ted Walther <ted--a.t--enumera.com>
630 * John Sokol <sokol--a.t--videotechnology.com>
631 * http://v4l.videotechnology.com/
632 *
633 */
634static void s2255_fillbuff(struct s2255_dev *dev, struct s2255_buffer *buf,
14d96260 635 int chn, int jpgsize)
38f993ad
DA		 636{
637 int pos = 0;
638 struct timeval ts;
639 const char *tmpbuf;
640 char *vbuf = videobuf_to_vmalloc(&buf->vb);
641 unsigned long last_frame;
642 struct s2255_framei *frm;
643
644 if (!vbuf)
645 return;
646
647 last_frame = dev->last_frame[chn];
648 if (last_frame != -1) {
649 frm = &dev->buffer[chn].frame[last_frame];
650 tmpbuf =
651 (const char *)dev->buffer[chn].frame[last_frame].lpvbits;
652 switch (buf->fmt->fourcc) {
653 case V4L2_PIX_FMT_YUYV:
654 case V4L2_PIX_FMT_UYVY:
655 planar422p_to_yuv_packed((const unsigned char *)tmpbuf,
656 vbuf, buf->vb.width,
657 buf->vb.height,
658 buf->fmt->fourcc);
659 break;
660 case V4L2_PIX_FMT_GREY:
661 memcpy(vbuf, tmpbuf, buf->vb.width * buf->vb.height);
662 break;
14d96260
DA		 663 case V4L2_PIX_FMT_JPEG:
664 buf->vb.size = jpgsize;
665 memcpy(vbuf, tmpbuf, buf->vb.size);
666 break;
38f993ad
DA		 667 case V4L2_PIX_FMT_YUV422P:
668 memcpy(vbuf, tmpbuf,
669 buf->vb.width * buf->vb.height * 2);
670 break;
671 default:
672 printk(KERN_DEBUG "s2255: unknown format?\n");
673 }
674 dev->last_frame[chn] = -1;
38f993ad
DA		 675 } else {
676 printk(KERN_ERR "s2255: =======no frame\n");
677 return;
678
679 }
680 dprintk(2, "s2255fill at : Buffer 0x%08lx size= %d\n",
681 (unsigned long)vbuf, pos);
682 /* tell v4l buffer was filled */
683
a1c4530e 684 buf->vb.field_count = dev->frame_count[chn] * 2;
38f993ad
DA		 685 do_gettimeofday(&ts);
686 buf->vb.ts = ts;
687 buf->vb.state = VIDEOBUF_DONE;
688}
689
690
691/* ------------------------------------------------------------------
692 Videobuf operations
693 ------------------------------------------------------------------*/
694
695static int buffer_setup(struct videobuf_queue *vq, unsigned int *count,
696 unsigned int *size)
697{
698 struct s2255_fh *fh = vq->priv_data;
699
700 *size = fh->width * fh->height * (fh->fmt->depth >> 3);
701
702 if (0 == *count)
703 *count = S2255_DEF_BUFS;
704
3f8d6f73 705 while (*size * (*count) > vid_limit * 1024 * 1024)
38f993ad
DA		 706 (*count)--;
707
708 return 0;
709}
710
711static void free_buffer(struct videobuf_queue *vq, struct s2255_buffer *buf)
712{
713 dprintk(4, "%s\n", __func__);
714
38f993ad
DA		 715 videobuf_vmalloc_free(&buf->vb);
716 buf->vb.state = VIDEOBUF_NEEDS_INIT;
717}
718
719static int buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
720 enum v4l2_field field)
721{
722 struct s2255_fh *fh = vq->priv_data;
723 struct s2255_buffer *buf = container_of(vb, struct s2255_buffer, vb);
724 int rc;
725 dprintk(4, "%s, field=%d\n", __func__, field);
726 if (fh->fmt == NULL)
727 return -EINVAL;
728
729 if ((fh->width < norm_minw(fh->dev->vdev[fh->channel])) ||
730 (fh->width > norm_maxw(fh->dev->vdev[fh->channel])) ||
731 (fh->height < norm_minh(fh->dev->vdev[fh->channel])) ||
732 (fh->height > norm_maxh(fh->dev->vdev[fh->channel]))) {
733 dprintk(4, "invalid buffer prepare\n");
734 return -EINVAL;
735 }
736
737 buf->vb.size = fh->width * fh->height * (fh->fmt->depth >> 3);
738
739 if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size) {
740 dprintk(4, "invalid buffer prepare\n");
741 return -EINVAL;
742 }
743
744 buf->fmt = fh->fmt;
745 buf->vb.width = fh->width;
746 buf->vb.height = fh->height;
747 buf->vb.field = field;
748
749
750 if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
751 rc = videobuf_iolock(vq, &buf->vb, NULL);
752 if (rc < 0)
753 goto fail;
754 }
755
756 buf->vb.state = VIDEOBUF_PREPARED;
757 return 0;
758fail:
759 free_buffer(vq, buf);
760 return rc;
761}
762
763static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
764{
765 struct s2255_buffer *buf = container_of(vb, struct s2255_buffer, vb);
766 struct s2255_fh *fh = vq->priv_data;
767 struct s2255_dev *dev = fh->dev;
768 struct s2255_dmaqueue *vidq = &dev->vidq[fh->channel];
769
770 dprintk(1, "%s\n", __func__);
771
772 buf->vb.state = VIDEOBUF_QUEUED;
773 list_add_tail(&buf->vb.queue, &vidq->active);
774}
775
776static void buffer_release(struct videobuf_queue *vq,
777 struct videobuf_buffer *vb)
778{
779 struct s2255_buffer *buf = container_of(vb, struct s2255_buffer, vb);
780 struct s2255_fh *fh = vq->priv_data;
781 dprintk(4, "%s %d\n", __func__, fh->channel);
782 free_buffer(vq, buf);
783}
784
785static struct videobuf_queue_ops s2255_video_qops = {
786 .buf_setup = buffer_setup,
787 .buf_prepare = buffer_prepare,
788 .buf_queue = buffer_queue,
789 .buf_release = buffer_release,
790};
791
792
793static int res_get(struct s2255_dev *dev, struct s2255_fh *fh)
794{
795 /* is it free? */
796 mutex_lock(&dev->lock);
797 if (dev->resources[fh->channel]) {
798 /* no, someone else uses it */
799 mutex_unlock(&dev->lock);
800 return 0;
801 }
802 /* it's free, grab it */
803 dev->resources[fh->channel] = 1;
f78d92c9
DA		 804 fh->resources[fh->channel] = 1;
805 dprintk(1, "s2255: res: get\n");
38f993ad
DA		 806 mutex_unlock(&dev->lock);
807 return 1;
808}
809
810static int res_locked(struct s2255_dev *dev, struct s2255_fh *fh)
811{
3f8d6f73 812 return dev->resources[fh->channel];
38f993ad
DA		 813}
814
f78d92c9
DA		 815static int res_check(struct s2255_fh *fh)
816{
817 return fh->resources[fh->channel];
818}
819
820
38f993ad
DA		 821static void res_free(struct s2255_dev *dev, struct s2255_fh *fh)
822{
f78d92c9 823 mutex_lock(&dev->lock);
38f993ad 824 dev->resources[fh->channel] = 0;
f78d92c9
DA		 825 fh->resources[fh->channel] = 0;
826 mutex_unlock(&dev->lock);
38f993ad
DA		 827 dprintk(1, "res: put\n");
828}
829
830
831static int vidioc_querycap(struct file *file, void *priv,
832 struct v4l2_capability *cap)
833{
834 struct s2255_fh *fh = file->private_data;
835 struct s2255_dev *dev = fh->dev;
836 strlcpy(cap->driver, "s2255", sizeof(cap->driver));
837 strlcpy(cap->card, "s2255", sizeof(cap->card));
e22ed887 838 usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
38f993ad
DA		 839 cap->version = S2255_VERSION;
840 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
841 return 0;
842}
843
844static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
845 struct v4l2_fmtdesc *f)
846{
847 int index = 0;
848 if (f)
849 index = f->index;
850
851 if (index >= ARRAY_SIZE(formats))
852 return -EINVAL;
853
854 dprintk(4, "name %s\n", formats[index].name);
855 strlcpy(f->description, formats[index].name, sizeof(f->description));
856 f->pixelformat = formats[index].fourcc;
857 return 0;
858}
859
860static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
861 struct v4l2_format *f)
862{
863 struct s2255_fh *fh = priv;
864
865 f->fmt.pix.width = fh->width;
866 f->fmt.pix.height = fh->height;
867 f->fmt.pix.field = fh->vb_vidq.field;
868 f->fmt.pix.pixelformat = fh->fmt->fourcc;
869 f->fmt.pix.bytesperline = f->fmt.pix.width * (fh->fmt->depth >> 3);
870 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
3f8d6f73 871 return 0;
38f993ad
DA		 872}
873
874static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
875 struct v4l2_format *f)
876{
877 const struct s2255_fmt *fmt;
878 enum v4l2_field field;
879 int b_any_field = 0;
880 struct s2255_fh *fh = priv;
881 struct s2255_dev *dev = fh->dev;
882 int is_ntsc;
883
884 is_ntsc =
885 (dev->vdev[fh->channel]->current_norm & V4L2_STD_NTSC) ? 1 : 0;
886
887 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
888
889 if (fmt == NULL)
890 return -EINVAL;
891
892 field = f->fmt.pix.field;
893 if (field == V4L2_FIELD_ANY)
894 b_any_field = 1;
895
896 dprintk(4, "try format %d \n", is_ntsc);
897 /* supports 3 sizes. see s2255drv.h */
898 dprintk(50, "width test %d, height %d\n",
899 f->fmt.pix.width, f->fmt.pix.height);
900 if (is_ntsc) {
901 /* NTSC */
902 if (f->fmt.pix.height >= NUM_LINES_1CIFS_NTSC * 2) {
903 f->fmt.pix.height = NUM_LINES_1CIFS_NTSC * 2;
904 if (b_any_field) {
905 field = V4L2_FIELD_SEQ_TB;
906 } else if (!((field == V4L2_FIELD_INTERLACED) ||
907 (field == V4L2_FIELD_SEQ_TB) ||
908 (field == V4L2_FIELD_INTERLACED_TB))) {
909 dprintk(1, "unsupported field setting\n");
910 return -EINVAL;
911 }
912 } else {
913 f->fmt.pix.height = NUM_LINES_1CIFS_NTSC;
914 if (b_any_field) {
915 field = V4L2_FIELD_TOP;
916 } else if (!((field == V4L2_FIELD_TOP) ||
917 (field == V4L2_FIELD_BOTTOM))) {
918 dprintk(1, "unsupported field setting\n");
919 return -EINVAL;
920 }
921
922 }
923 if (f->fmt.pix.width >= LINE_SZ_4CIFS_NTSC)
924 f->fmt.pix.width = LINE_SZ_4CIFS_NTSC;
925 else if (f->fmt.pix.width >= LINE_SZ_2CIFS_NTSC)
926 f->fmt.pix.width = LINE_SZ_2CIFS_NTSC;
927 else if (f->fmt.pix.width >= LINE_SZ_1CIFS_NTSC)
928 f->fmt.pix.width = LINE_SZ_1CIFS_NTSC;
929 else
930 f->fmt.pix.width = LINE_SZ_1CIFS_NTSC;
931 } else {
932 /* PAL */
933 if (f->fmt.pix.height >= NUM_LINES_1CIFS_PAL * 2) {
934 f->fmt.pix.height = NUM_LINES_1CIFS_PAL * 2;
935 if (b_any_field) {
936 field = V4L2_FIELD_SEQ_TB;
937 } else if (!((field == V4L2_FIELD_INTERLACED) ||
938 (field == V4L2_FIELD_SEQ_TB) ||
939 (field == V4L2_FIELD_INTERLACED_TB))) {
940 dprintk(1, "unsupported field setting\n");
941 return -EINVAL;
942 }
943 } else {
944 f->fmt.pix.height = NUM_LINES_1CIFS_PAL;
945 if (b_any_field) {
946 field = V4L2_FIELD_TOP;
947 } else if (!((field == V4L2_FIELD_TOP) ||
948 (field == V4L2_FIELD_BOTTOM))) {
949 dprintk(1, "unsupported field setting\n");
950 return -EINVAL;
951 }
952 }
953 if (f->fmt.pix.width >= LINE_SZ_4CIFS_PAL) {
954 dprintk(50, "pal 704\n");
955 f->fmt.pix.width = LINE_SZ_4CIFS_PAL;
956 field = V4L2_FIELD_SEQ_TB;
957 } else if (f->fmt.pix.width >= LINE_SZ_2CIFS_PAL) {
958 dprintk(50, "pal 352A\n");
959 f->fmt.pix.width = LINE_SZ_2CIFS_PAL;
960 field = V4L2_FIELD_TOP;
961 } else if (f->fmt.pix.width >= LINE_SZ_1CIFS_PAL) {
962 dprintk(50, "pal 352B\n");
963 f->fmt.pix.width = LINE_SZ_1CIFS_PAL;
964 field = V4L2_FIELD_TOP;
965 } else {
966 dprintk(50, "pal 352C\n");
967 f->fmt.pix.width = LINE_SZ_1CIFS_PAL;
968 field = V4L2_FIELD_TOP;
969 }
970 }
971
972 dprintk(50, "width %d height %d field %d \n", f->fmt.pix.width,
973 f->fmt.pix.height, f->fmt.pix.field);
974 f->fmt.pix.field = field;
975 f->fmt.pix.bytesperline = (f->fmt.pix.width * fmt->depth) >> 3;
976 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
977 return 0;
978}
979
980static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
981 struct v4l2_format *f)
982{
983 struct s2255_fh *fh = priv;
984 const struct s2255_fmt *fmt;
985 struct videobuf_queue *q = &fh->vb_vidq;
986 int ret;
987 int norm;
988
989 ret = vidioc_try_fmt_vid_cap(file, fh, f);
990
991 if (ret < 0)
3f8d6f73 992 return ret;
38f993ad
DA		 993
994 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
995
996 if (fmt == NULL)
997 return -EINVAL;
998
999 mutex_lock(&q->vb_lock);
1000
1001 if (videobuf_queue_is_busy(&fh->vb_vidq)) {
1002 dprintk(1, "queue busy\n");
1003 ret = -EBUSY;
1004 goto out_s_fmt;
1005 }
1006
1007 if (res_locked(fh->dev, fh)) {
1008 dprintk(1, "can't change format after started\n");
1009 ret = -EBUSY;
1010 goto out_s_fmt;
1011 }
1012
1013 fh->fmt = fmt;
1014 fh->width = f->fmt.pix.width;
1015 fh->height = f->fmt.pix.height;
1016 fh->vb_vidq.field = f->fmt.pix.field;
1017 fh->type = f->type;
1018 norm = norm_minw(fh->dev->vdev[fh->channel]);
1019 if (fh->width > norm_minw(fh->dev->vdev[fh->channel])) {
7d853532
DA		 1020 if (fh->height > norm_minh(fh->dev->vdev[fh->channel])) {
1021 if (fh->dev->cap_parm[fh->channel].capturemode &
1022 V4L2_MODE_HIGHQUALITY) {
1023 fh->mode.scale = SCALE_4CIFSI;
1024 dprintk(2, "scale 4CIFSI\n");
1025 } else {
1026 fh->mode.scale = SCALE_4CIFS;
1027 dprintk(2, "scale 4CIFS\n");
1028 }
1029 } else
38f993ad
DA		 1030 fh->mode.scale = SCALE_2CIFS;
1031
1032 } else {
1033 fh->mode.scale = SCALE_1CIFS;
1034 }
1035
1036 /* color mode */
1037 switch (fh->fmt->fourcc) {
1038 case V4L2_PIX_FMT_GREY:
1039 fh->mode.color = COLOR_Y8;
1040 break;
14d96260 1041 case V4L2_PIX_FMT_JPEG:
22b88d48
DA		 1042 fh->mode.color = COLOR_JPG |
1043 (fh->dev->jc[fh->channel].quality << 8);
14d96260 1044 break;
38f993ad
DA		 1045 case V4L2_PIX_FMT_YUV422P:
1046 fh->mode.color = COLOR_YUVPL;
1047 break;
1048 case V4L2_PIX_FMT_YUYV:
1049 case V4L2_PIX_FMT_UYVY:
1050 default:
1051 fh->mode.color = COLOR_YUVPK;
1052 break;
1053 }
1054 ret = 0;
1055out_s_fmt:
1056 mutex_unlock(&q->vb_lock);
1057 return ret;
1058}
1059
1060static int vidioc_reqbufs(struct file *file, void *priv,
1061 struct v4l2_requestbuffers *p)
1062{
1063 int rc;
1064 struct s2255_fh *fh = priv;
1065 rc = videobuf_reqbufs(&fh->vb_vidq, p);
1066 return rc;
1067}
1068
1069static int vidioc_querybuf(struct file *file, void *priv, struct v4l2_buffer *p)
1070{
1071 int rc;
1072 struct s2255_fh *fh = priv;
1073 rc = videobuf_querybuf(&fh->vb_vidq, p);
1074 return rc;
1075}
1076
1077static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
1078{
1079 int rc;
1080 struct s2255_fh *fh = priv;
1081 rc = videobuf_qbuf(&fh->vb_vidq, p);
1082 return rc;
1083}
1084
1085static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
1086{
1087 int rc;
1088 struct s2255_fh *fh = priv;
1089 rc = videobuf_dqbuf(&fh->vb_vidq, p, file->f_flags & O_NONBLOCK);
1090 return rc;
1091}
1092
1093#ifdef CONFIG_VIDEO_V4L1_COMPAT
1094static int vidioc_cgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
1095{
1096 struct s2255_fh *fh = priv;
1097
1098 return videobuf_cgmbuf(&fh->vb_vidq, mbuf, 8);
1099}
1100#endif
1101
1102/* write to the configuration pipe, synchronously */
1103static int s2255_write_config(struct usb_device *udev, unsigned char *pbuf,
1104 int size)
1105{
1106 int pipe;
1107 int done;
1108 long retval = -1;
1109 if (udev) {
1110 pipe = usb_sndbulkpipe(udev, S2255_CONFIG_EP);
1111 retval = usb_bulk_msg(udev, pipe, pbuf, size, &done, 500);
1112 }
1113 return retval;
1114}
1115
1116static u32 get_transfer_size(struct s2255_mode *mode)
1117{
1118 int linesPerFrame = LINE_SZ_DEF;
1119 int pixelsPerLine = NUM_LINES_DEF;
1120 u32 outImageSize;
1121 u32 usbInSize;
1122 unsigned int mask_mult;
1123
1124 if (mode == NULL)
1125 return 0;
1126
1127 if (mode->format == FORMAT_NTSC) {
1128 switch (mode->scale) {
1129 case SCALE_4CIFS:
7d853532 1130 case SCALE_4CIFSI:
38f993ad
DA		 1131 linesPerFrame = NUM_LINES_4CIFS_NTSC * 2;
1132 pixelsPerLine = LINE_SZ_4CIFS_NTSC;
1133 break;
1134 case SCALE_2CIFS:
1135 linesPerFrame = NUM_LINES_2CIFS_NTSC;
1136 pixelsPerLine = LINE_SZ_2CIFS_NTSC;
1137 break;
1138 case SCALE_1CIFS:
1139 linesPerFrame = NUM_LINES_1CIFS_NTSC;
1140 pixelsPerLine = LINE_SZ_1CIFS_NTSC;
1141 break;
1142 default:
1143 break;
1144 }
1145 } else if (mode->format == FORMAT_PAL) {
1146 switch (mode->scale) {
1147 case SCALE_4CIFS:
7d853532 1148 case SCALE_4CIFSI:
38f993ad
DA		 1149 linesPerFrame = NUM_LINES_4CIFS_PAL * 2;
1150 pixelsPerLine = LINE_SZ_4CIFS_PAL;
1151 break;
1152 case SCALE_2CIFS:
1153 linesPerFrame = NUM_LINES_2CIFS_PAL;
1154 pixelsPerLine = LINE_SZ_2CIFS_PAL;
1155 break;
1156 case SCALE_1CIFS:
1157 linesPerFrame = NUM_LINES_1CIFS_PAL;
1158 pixelsPerLine = LINE_SZ_1CIFS_PAL;
1159 break;
1160 default:
1161 break;
1162 }
1163 }
1164 outImageSize = linesPerFrame * pixelsPerLine;
14d96260 1165 if ((mode->color & MASK_COLOR) != COLOR_Y8) {
38f993ad
DA		 1166 /* 2 bytes/pixel if not monochrome */
1167 outImageSize *= 2;
1168 }
1169
1170 /* total bytes to send including prefix and 4K padding;
1171 must be a multiple of USB_READ_SIZE */
1172 usbInSize = outImageSize + PREFIX_SIZE; /* always send prefix */
1173 mask_mult = 0xffffffffUL - DEF_USB_BLOCK + 1;
1174 /* if size not a multiple of USB_READ_SIZE */
1175 if (usbInSize & ~mask_mult)
1176 usbInSize = (usbInSize & mask_mult) + (DEF_USB_BLOCK);
1177 return usbInSize;
1178}
1179
1180static void dump_verify_mode(struct s2255_dev *sdev, struct s2255_mode *mode)
1181{
1182 struct device *dev = &sdev->udev->dev;
1183 dev_info(dev, "------------------------------------------------\n");
1184 dev_info(dev, "verify mode\n");
1185 dev_info(dev, "format: %d\n", mode->format);
1186 dev_info(dev, "scale: %d\n", mode->scale);
1187 dev_info(dev, "fdec: %d\n", mode->fdec);
1188 dev_info(dev, "color: %d\n", mode->color);
1189 dev_info(dev, "bright: 0x%x\n", mode->bright);
1190 dev_info(dev, "restart: 0x%x\n", mode->restart);
1191 dev_info(dev, "usb_block: 0x%x\n", mode->usb_block);
1192 dev_info(dev, "single: 0x%x\n", mode->single);
1193 dev_info(dev, "------------------------------------------------\n");
1194}
1195
1196/*
1197 * set mode is the function which controls the DSP.
1198 * the restart parameter in struct s2255_mode should be set whenever
1199 * the image size could change via color format, video system or image
1200 * size.
1201 * When the restart parameter is set, we sleep for ONE frame to allow the
1202 * DSP time to get the new frame
1203 */
1204static int s2255_set_mode(struct s2255_dev *dev, unsigned long chn,
1205 struct s2255_mode *mode)
1206{
1207 int res;
1208 u32 *buffer;
1209 unsigned long chn_rev;
1210
14d96260 1211 mutex_lock(&dev->lock);
38f993ad
DA		 1212 chn_rev = G_chnmap[chn];
1213 dprintk(3, "mode scale [%ld] %p %d\n", chn, mode, mode->scale);
1214 dprintk(3, "mode scale [%ld] %p %d\n", chn, &dev->mode[chn],
1215 dev->mode[chn].scale);
1216 dprintk(2, "mode contrast %x\n", mode->contrast);
1217
22b88d48
DA		 1218 /* if JPEG, set the quality */
1219 if ((mode->color & MASK_COLOR) == COLOR_JPG)
1220 mode->color = (dev->jc[chn].quality << 8) | COLOR_JPG;
1221
38f993ad
DA		 1222 /* save the mode */
1223 dev->mode[chn] = *mode;
1224 dev->req_image_size[chn] = get_transfer_size(mode);
1225 dprintk(1, "transfer size %ld\n", dev->req_image_size[chn]);
1226
1227 buffer = kzalloc(512, GFP_KERNEL);
1228 if (buffer == NULL) {
1229 dev_err(&dev->udev->dev, "out of mem\n");
14d96260 1230 mutex_unlock(&dev->lock);
38f993ad
DA		 1231 return -ENOMEM;
1232 }
1233
1234 /* set the mode */
1235 buffer[0] = IN_DATA_TOKEN;
1236 buffer[1] = (u32) chn_rev;
1237 buffer[2] = CMD_SET_MODE;
1238 memcpy(&buffer[3], &dev->mode[chn], sizeof(struct s2255_mode));
9d63cec1 1239 dev->setmode_ready[chn] = 0;
38f993ad
DA		 1240 res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
1241 if (debug)
1242 dump_verify_mode(dev, mode);
1243 kfree(buffer);
1244 dprintk(1, "set mode done chn %lu, %d\n", chn, res);
1245
1246 /* wait at least 3 frames before continuing */
14d96260 1247 if (mode->restart) {
14d96260
DA		 1248 wait_event_timeout(dev->wait_setmode[chn],
1249 (dev->setmode_ready[chn] != 0),
1250 msecs_to_jiffies(S2255_SETMODE_TIMEOUT));
1251 if (dev->setmode_ready[chn] != 1) {
1252 printk(KERN_DEBUG "s2255: no set mode response\n");
1253 res = -EFAULT;
1254 }
1255 }
38f993ad
DA		 1256
1257 /* clear the restart flag */
1258 dev->mode[chn].restart = 0;
14d96260 1259 mutex_unlock(&dev->lock);
38f993ad
DA		 1260 return res;
1261}
1262
1263static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
1264{
1265 int res;
1266 struct s2255_fh *fh = priv;
1267 struct s2255_dev *dev = fh->dev;
1268 struct s2255_mode *new_mode;
1269 struct s2255_mode *old_mode;
1270 int chn;
1271 int j;
1272 dprintk(4, "%s\n", __func__);
1273 if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1274 dev_err(&dev->udev->dev, "invalid fh type0\n");
1275 return -EINVAL;
1276 }
1277 if (i != fh->type) {
1278 dev_err(&dev->udev->dev, "invalid fh type1\n");
1279 return -EINVAL;
1280 }
1281
1282 if (!res_get(dev, fh)) {
be9ed511 1283 s2255_dev_err(&dev->udev->dev, "stream busy\n");
38f993ad
DA		 1284 return -EBUSY;
1285 }
1286
1287 /* send a set mode command everytime with restart.
1288 in case we switch resolutions or other parameters */
1289 chn = fh->channel;
1290 new_mode = &fh->mode;
1291 old_mode = &fh->dev->mode[chn];
1292
1293 if (new_mode->color != old_mode->color)
1294 new_mode->restart = 1;
1295 else if (new_mode->scale != old_mode->scale)
1296 new_mode->restart = 1;
1297 else if (new_mode->format != old_mode->format)
1298 new_mode->restart = 1;
1299
1300 s2255_set_mode(dev, chn, new_mode);
1301 new_mode->restart = 0;
1302 *old_mode = *new_mode;
1303 dev->cur_fmt[chn] = fh->fmt;
1304 dprintk(1, "%s[%d]\n", __func__, chn);
1305 dev->last_frame[chn] = -1;
1306 dev->bad_payload[chn] = 0;
1307 dev->cur_frame[chn] = 0;
a1c4530e 1308 dev->frame_count[chn] = 0;
38f993ad 1309 for (j = 0; j < SYS_FRAMES; j++) {
14d96260 1310 dev->buffer[chn].frame[j].ulState = S2255_READ_IDLE;
38f993ad
DA		 1311 dev->buffer[chn].frame[j].cur_size = 0;
1312 }
1313 res = videobuf_streamon(&fh->vb_vidq);
1314 if (res == 0) {
1315 s2255_start_acquire(dev, chn);
1316 dev->b_acquire[chn] = 1;
1317 } else {
1318 res_free(dev, fh);
1319 }
1320 return res;
1321}
1322
1323static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
1324{
38f993ad
DA		 1325 struct s2255_fh *fh = priv;
1326 struct s2255_dev *dev = fh->dev;
1327
1328 dprintk(4, "%s\n, channel: %d", __func__, fh->channel);
1329 if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1330 printk(KERN_ERR "invalid fh type0\n");
1331 return -EINVAL;
1332 }
1333 if (i != fh->type) {
1334 printk(KERN_ERR "invalid type i\n");
1335 return -EINVAL;
1336 }
1337 s2255_stop_acquire(dev, fh->channel);
b7732a32 1338 videobuf_streamoff(&fh->vb_vidq);
38f993ad 1339 res_free(dev, fh);
f78d92c9 1340 return 0;
38f993ad
DA		 1341}
1342
1343static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *i)
1344{
1345 struct s2255_fh *fh = priv;
1346 struct s2255_mode *mode;
1347 struct videobuf_queue *q = &fh->vb_vidq;
1348 int ret = 0;
1349
1350 mutex_lock(&q->vb_lock);
1351 if (videobuf_queue_is_busy(q)) {
1352 dprintk(1, "queue busy\n");
1353 ret = -EBUSY;
1354 goto out_s_std;
1355 }
1356
1357 if (res_locked(fh->dev, fh)) {
1358 dprintk(1, "can't change standard after started\n");
1359 ret = -EBUSY;
1360 goto out_s_std;
1361 }
1362 mode = &fh->mode;
1363
1364 if (*i & V4L2_STD_NTSC) {
1365 dprintk(4, "vidioc_s_std NTSC\n");
1366 mode->format = FORMAT_NTSC;
1367 } else if (*i & V4L2_STD_PAL) {
1368 dprintk(4, "vidioc_s_std PAL\n");
1369 mode->format = FORMAT_PAL;
1370 } else {
1371 ret = -EINVAL;
1372 }
1373out_s_std:
1374 mutex_unlock(&q->vb_lock);
1375 return ret;
1376}
1377
1378/* Sensoray 2255 is a multiple channel capture device.
1379 It does not have a "crossbar" of inputs.
1380 We use one V4L device per channel. The user must
1381 be aware that certain combinations are not allowed.
1382 For instance, you cannot do full FPS on more than 2 channels(2 videodevs)
1383 at once in color(you can do full fps on 4 channels with greyscale.
1384*/
1385static int vidioc_enum_input(struct file *file, void *priv,
1386 struct v4l2_input *inp)
1387{
1388 if (inp->index != 0)
1389 return -EINVAL;
1390
1391 inp->type = V4L2_INPUT_TYPE_CAMERA;
1392 inp->std = S2255_NORMS;
1393 strlcpy(inp->name, "Camera", sizeof(inp->name));
3f8d6f73 1394 return 0;
38f993ad
DA		 1395}
1396
1397static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1398{
1399 *i = 0;
1400 return 0;
1401}
1402static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1403{
1404 if (i > 0)
1405 return -EINVAL;
1406 return 0;
1407}
1408
1409/* --- controls ---------------------------------------------- */
1410static int vidioc_queryctrl(struct file *file, void *priv,
1411 struct v4l2_queryctrl *qc)
1412{
1413 int i;
1414
1415 for (i = 0; i < ARRAY_SIZE(s2255_qctrl); i++)
1416 if (qc->id && qc->id == s2255_qctrl[i].id) {
1417 memcpy(qc, &(s2255_qctrl[i]), sizeof(*qc));
3f8d6f73 1418 return 0;
38f993ad
DA		 1419 }
1420
1421 dprintk(4, "query_ctrl -EINVAL %d\n", qc->id);
1422 return -EINVAL;
1423}
1424
1425static int vidioc_g_ctrl(struct file *file, void *priv,
1426 struct v4l2_control *ctrl)
1427{
1428 int i;
1429
1430 for (i = 0; i < ARRAY_SIZE(s2255_qctrl); i++)
1431 if (ctrl->id == s2255_qctrl[i].id) {
1432 ctrl->value = qctl_regs[i];
3f8d6f73 1433 return 0;
38f993ad
DA		 1434 }
1435 dprintk(4, "g_ctrl -EINVAL\n");
1436
1437 return -EINVAL;
1438}
1439
1440static int vidioc_s_ctrl(struct file *file, void *priv,
1441 struct v4l2_control *ctrl)
1442{
1443 int i;
1444 struct s2255_fh *fh = priv;
1445 struct s2255_dev *dev = fh->dev;
1446 struct s2255_mode *mode;
1447 mode = &fh->mode;
1448 dprintk(4, "vidioc_s_ctrl\n");
1449 for (i = 0; i < ARRAY_SIZE(s2255_qctrl); i++) {
1450 if (ctrl->id == s2255_qctrl[i].id) {
1451 if (ctrl->value < s2255_qctrl[i].minimum ||
1452 ctrl->value > s2255_qctrl[i].maximum)
3f8d6f73 1453 return -ERANGE;
38f993ad
DA		 1454
1455 qctl_regs[i] = ctrl->value;
1456 /* update the mode to the corresponding value */
1457 switch (ctrl->id) {
1458 case V4L2_CID_BRIGHTNESS:
1459 mode->bright = ctrl->value;
1460 break;
1461 case V4L2_CID_CONTRAST:
1462 mode->contrast = ctrl->value;
1463 break;
1464 case V4L2_CID_HUE:
1465 mode->hue = ctrl->value;
1466 break;
1467 case V4L2_CID_SATURATION:
1468 mode->saturation = ctrl->value;
1469 break;
1470 }
1471 mode->restart = 0;
1472 /* set mode here. Note: stream does not need restarted.
1473 some V4L programs restart stream unnecessarily
1474 after a s_crtl.
1475 */
1476 s2255_set_mode(dev, fh->channel, mode);
1477 return 0;
1478 }
1479 }
1480 return -EINVAL;
1481}
1482
22b88d48
DA		 1483static int vidioc_g_jpegcomp(struct file *file, void *priv,
1484 struct v4l2_jpegcompression *jc)
1485{
1486 struct s2255_fh *fh = priv;
1487 struct s2255_dev *dev = fh->dev;
1488 *jc = dev->jc[fh->channel];
1489 dprintk(2, "getting jpegcompression, quality %d\n", jc->quality);
1490 return 0;
1491}
1492
1493static int vidioc_s_jpegcomp(struct file *file, void *priv,
1494 struct v4l2_jpegcompression *jc)
1495{
1496 struct s2255_fh *fh = priv;
1497 struct s2255_dev *dev = fh->dev;
1498 if (jc->quality < 0 || jc->quality > 100)
1499 return -EINVAL;
1500 dev->jc[fh->channel].quality = jc->quality;
1501 dprintk(2, "setting jpeg quality %d\n", jc->quality);
1502 return 0;
1503}
7d853532
DA		 1504
1505static int vidioc_g_parm(struct file *file, void *priv,
1506 struct v4l2_streamparm *sp)
1507{
1508 struct s2255_fh *fh = priv;
1509 struct s2255_dev *dev = fh->dev;
1510 if (sp->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1511 return -EINVAL;
1512 sp->parm.capture.capturemode = dev->cap_parm[fh->channel].capturemode;
1513 dprintk(2, "getting parm %d\n", sp->parm.capture.capturemode);
1514 return 0;
1515}
1516
1517static int vidioc_s_parm(struct file *file, void *priv,
1518 struct v4l2_streamparm *sp)
1519{
1520 struct s2255_fh *fh = priv;
1521 struct s2255_dev *dev = fh->dev;
1522
1523 if (sp->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1524 return -EINVAL;
1525
1526 dev->cap_parm[fh->channel].capturemode = sp->parm.capture.capturemode;
1527 dprintk(2, "setting param capture mode %d\n",
1528 sp->parm.capture.capturemode);
1529 return 0;
1530}
bec43661 1531static int s2255_open(struct file *file)
38f993ad 1532{
bec43661 1533 int minor = video_devdata(file)->minor;
63b0d5ad
LP		 1534 struct video_device *vdev = video_devdata(file);
1535 struct s2255_dev *dev = video_drvdata(file);
38f993ad 1536 struct s2255_fh *fh;
63b0d5ad 1537 enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
38f993ad
DA		 1538 int i = 0;
1539 int cur_channel = -1;
14d96260 1540 int state;
38f993ad
DA		 1541 dprintk(1, "s2255: open called (minor=%d)\n", minor);
1542
d56dc612 1543 lock_kernel();
38f993ad 1544
63b0d5ad
LP		 1545 for (i = 0; i < MAX_CHANNELS; i++) {
1546 if (dev->vdev[i] == vdev) {
1547 cur_channel = i;
1548 break;
1549 }
38f993ad
DA		 1550 }
1551
14d96260
DA		 1552 if (atomic_read(&dev->fw_data->fw_state) == S2255_FW_DISCONNECTING) {
1553 unlock_kernel();
1554 printk(KERN_INFO "disconnecting\n");
1555 return -ENODEV;
1556 }
1557 kref_get(&dev->kref);
38f993ad
DA		 1558 mutex_lock(&dev->open_lock);
1559
1560 dev->users[cur_channel]++;
f78d92c9 1561 dprintk(4, "s2255: open_handles %d\n", dev->users[cur_channel]);
38f993ad 1562
14d96260
DA		 1563 switch (atomic_read(&dev->fw_data->fw_state)) {
1564 case S2255_FW_FAILED:
be9ed511
MCC		 1565 s2255_dev_err(&dev->udev->dev,
1566 "firmware load failed. retrying.\n");
14d96260 1567 s2255_fwload_start(dev, 1);
38f993ad 1568 wait_event_timeout(dev->fw_data->wait_fw,
14d96260
DA		 1569 ((atomic_read(&dev->fw_data->fw_state)
1570 == S2255_FW_SUCCESS) ||
1571 (atomic_read(&dev->fw_data->fw_state)
1572 == S2255_FW_DISCONNECTING)),
38f993ad 1573 msecs_to_jiffies(S2255_LOAD_TIMEOUT));
14d96260
DA		 1574 break;
1575 case S2255_FW_NOTLOADED:
1576 case S2255_FW_LOADED_DSPWAIT:
38f993ad
DA		 1577 /* give S2255_LOAD_TIMEOUT time for firmware to load in case
1578 driver loaded and then device immediately opened */
1579 printk(KERN_INFO "%s waiting for firmware load\n", __func__);
1580 wait_event_timeout(dev->fw_data->wait_fw,
14d96260
DA		 1581 ((atomic_read(&dev->fw_data->fw_state)
1582 == S2255_FW_SUCCESS) ||
1583 (atomic_read(&dev->fw_data->fw_state)
1584 == S2255_FW_DISCONNECTING)),
1585 msecs_to_jiffies(S2255_LOAD_TIMEOUT));
1586 break;
1587 case S2255_FW_SUCCESS:
1588 default:
1589 break;
1590 }
1591 state = atomic_read(&dev->fw_data->fw_state);
1592 if (state != S2255_FW_SUCCESS) {
1593 int rc;
1594 switch (state) {
1595 case S2255_FW_FAILED:
1596 printk(KERN_INFO "2255 FW load failed. %d\n", state);
1597 rc = -ENODEV;
1598 break;
1599 case S2255_FW_DISCONNECTING:
1600 printk(KERN_INFO "%s: disconnecting\n", __func__);
1601 rc = -ENODEV;
1602 break;
1603 case S2255_FW_LOADED_DSPWAIT:
1604 case S2255_FW_NOTLOADED:
1605 printk(KERN_INFO "%s: firmware not loaded yet"
1606 "please try again later\n",
1607 __func__);
1608 rc = -EAGAIN;
1609 break;
1610 default:
1611 printk(KERN_INFO "%s: unknown state\n", __func__);
1612 rc = -EFAULT;
1613 break;
38f993ad 1614 }
14d96260
DA		 1615 dev->users[cur_channel]--;
1616 mutex_unlock(&dev->open_lock);
1617 kref_put(&dev->kref, s2255_destroy);
1618 unlock_kernel();
1619 return rc;
38f993ad
DA		 1620 }
1621
1622 /* allocate + initialize per filehandle data */
1623 fh = kzalloc(sizeof(*fh), GFP_KERNEL);
1624 if (NULL == fh) {
f78d92c9 1625 dev->users[cur_channel]--;
38f993ad 1626 mutex_unlock(&dev->open_lock);
14d96260 1627 kref_put(&dev->kref, s2255_destroy);
d56dc612 1628 unlock_kernel();
38f993ad
DA		 1629 return -ENOMEM;
1630 }
1631
1632 file->private_data = fh;
1633 fh->dev = dev;
1634 fh->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1635 fh->mode = dev->mode[cur_channel];
1636 fh->fmt = dev->cur_fmt[cur_channel];
1637 /* default 4CIF NTSC */
1638 fh->width = LINE_SZ_4CIFS_NTSC;
1639 fh->height = NUM_LINES_4CIFS_NTSC * 2;
1640 fh->channel = cur_channel;
1641
14d96260
DA		 1642 /* configure channel to default state */
1643 if (!dev->chn_configured[cur_channel]) {
1644 s2255_set_mode(dev, cur_channel, &fh->mode);
1645 dev->chn_configured[cur_channel] = 1;
1646 }
1647
1648
38f993ad
DA		 1649 /* Put all controls at a sane state */
1650 for (i = 0; i < ARRAY_SIZE(s2255_qctrl); i++)
1651 qctl_regs[i] = s2255_qctrl[i].default_value;
1652
1653 dprintk(1, "s2255drv: open minor=%d type=%s users=%d\n",
1654 minor, v4l2_type_names[type], dev->users[cur_channel]);
1655 dprintk(2, "s2255drv: open: fh=0x%08lx, dev=0x%08lx, vidq=0x%08lx\n",
1656 (unsigned long)fh, (unsigned long)dev,
1657 (unsigned long)&dev->vidq[cur_channel]);
1658 dprintk(4, "s2255drv: open: list_empty active=%d\n",
1659 list_empty(&dev->vidq[cur_channel].active));
1660
1661 videobuf_queue_vmalloc_init(&fh->vb_vidq, &s2255_video_qops,
1662 NULL, &dev->slock,
1663 fh->type,
1664 V4L2_FIELD_INTERLACED,
1665 sizeof(struct s2255_buffer), fh);
1666
38f993ad 1667 mutex_unlock(&dev->open_lock);
d56dc612 1668 unlock_kernel();
38f993ad
DA		 1669 return 0;
1670}
1671
1672
1673static unsigned int s2255_poll(struct file *file,
1674 struct poll_table_struct *wait)
1675{
1676 struct s2255_fh *fh = file->private_data;
1677 int rc;
1678 dprintk(100, "%s\n", __func__);
1679
1680 if (V4L2_BUF_TYPE_VIDEO_CAPTURE != fh->type)
1681 return POLLERR;
1682
1683 rc = videobuf_poll_stream(file, &fh->vb_vidq, wait);
1684 return rc;
1685}
1686
1687static void s2255_destroy(struct kref *kref)
1688{
1689 struct s2255_dev *dev = to_s2255_dev(kref);
14d96260 1690 int i;
38f993ad
DA		 1691 if (!dev) {
1692 printk(KERN_ERR "s2255drv: kref problem\n");
1693 return;
1694 }
f78d92c9
DA		 1695 atomic_set(&dev->fw_data->fw_state, S2255_FW_DISCONNECTING);
1696 wake_up(&dev->fw_data->wait_fw);
14d96260
DA		 1697 for (i = 0; i < MAX_CHANNELS; i++) {
1698 dev->setmode_ready[i] = 1;
1699 wake_up(&dev->wait_setmode[i]);
1700 }
38f993ad 1701 mutex_lock(&dev->open_lock);
14d96260
DA		 1702 /* reset the DSP so firmware can be reload next time */
1703 s2255_reset_dsppower(dev);
38f993ad 1704 s2255_exit_v4l(dev);
38f993ad
DA		 1705 /* board shutdown stops the read pipe if it is running */
1706 s2255_board_shutdown(dev);
38f993ad 1707 /* make sure firmware still not trying to load */
f78d92c9
DA		 1708 del_timer(&dev->timer); /* only started in .probe and .open */
1709
38f993ad
DA		 1710 if (dev->fw_data->fw_urb) {
1711 dprintk(2, "kill fw_urb\n");
1712 usb_kill_urb(dev->fw_data->fw_urb);
1713 usb_free_urb(dev->fw_data->fw_urb);
1714 dev->fw_data->fw_urb = NULL;
1715 }
f78d92c9
DA		 1716 if (dev->fw_data->fw)
1717 release_firmware(dev->fw_data->fw);
1718 kfree(dev->fw_data->pfw_data);
1719 kfree(dev->fw_data);
38f993ad
DA		 1720 usb_put_dev(dev->udev);
1721 dprintk(1, "%s", __func__);
14d96260 1722
14d96260 1723 mutex_unlock(&dev->open_lock);
b7732a32 1724 kfree(dev);
38f993ad
DA		 1725}
1726
bec43661 1727static int s2255_close(struct file *file)
38f993ad
DA		 1728{
1729 struct s2255_fh *fh = file->private_data;
1730 struct s2255_dev *dev = fh->dev;
bec43661 1731 int minor = video_devdata(file)->minor;
38f993ad
DA		 1732 if (!dev)
1733 return -ENODEV;
1734
1735 mutex_lock(&dev->open_lock);
1736
f78d92c9
DA		 1737 /* turn off stream */
1738 if (res_check(fh)) {
1739 if (dev->b_acquire[fh->channel])
1740 s2255_stop_acquire(dev, fh->channel);
1741 videobuf_streamoff(&fh->vb_vidq);
1742 res_free(dev, fh);
1743 }
1744
38f993ad 1745 videobuf_mmap_free(&fh->vb_vidq);
38f993ad 1746 dev->users[fh->channel]--;
f78d92c9 1747
38f993ad
DA		 1748 mutex_unlock(&dev->open_lock);
1749
1750 kref_put(&dev->kref, s2255_destroy);
1751 dprintk(1, "s2255: close called (minor=%d, users=%d)\n",
1752 minor, dev->users[fh->channel]);
f78d92c9 1753 kfree(fh);
38f993ad
DA		 1754 return 0;
1755}
1756
1757static int s2255_mmap_v4l(struct file *file, struct vm_area_struct *vma)
1758{
1759 struct s2255_fh *fh = file->private_data;
1760 int ret;
1761
1762 if (!fh)
1763 return -ENODEV;
1764 dprintk(4, "mmap called, vma=0x%08lx\n", (unsigned long)vma);
1765
1766 ret = videobuf_mmap_mapper(&fh->vb_vidq, vma);
1767
1768 dprintk(4, "vma start=0x%08lx, size=%ld, ret=%d\n",
1769 (unsigned long)vma->vm_start,
1770 (unsigned long)vma->vm_end - (unsigned long)vma->vm_start, ret);
1771
1772 return ret;
1773}
1774
bec43661 1775static const struct v4l2_file_operations s2255_fops_v4l = {
38f993ad
DA		 1776 .owner = THIS_MODULE,
1777 .open = s2255_open,
1778 .release = s2255_close,
1779 .poll = s2255_poll,
1780 .ioctl = video_ioctl2, /* V4L2 ioctl handler */
38f993ad 1781 .mmap = s2255_mmap_v4l,
38f993ad
DA		 1782};
1783
a399810c 1784static const struct v4l2_ioctl_ops s2255_ioctl_ops = {
38f993ad
DA		 1785 .vidioc_querycap = vidioc_querycap,
1786 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1787 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1788 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1789 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1790 .vidioc_reqbufs = vidioc_reqbufs,
1791 .vidioc_querybuf = vidioc_querybuf,
1792 .vidioc_qbuf = vidioc_qbuf,
1793 .vidioc_dqbuf = vidioc_dqbuf,
1794 .vidioc_s_std = vidioc_s_std,
1795 .vidioc_enum_input = vidioc_enum_input,
1796 .vidioc_g_input = vidioc_g_input,
1797 .vidioc_s_input = vidioc_s_input,
1798 .vidioc_queryctrl = vidioc_queryctrl,
1799 .vidioc_g_ctrl = vidioc_g_ctrl,
1800 .vidioc_s_ctrl = vidioc_s_ctrl,
1801 .vidioc_streamon = vidioc_streamon,
1802 .vidioc_streamoff = vidioc_streamoff,
1803#ifdef CONFIG_VIDEO_V4L1_COMPAT
1804 .vidiocgmbuf = vidioc_cgmbuf,
1805#endif
22b88d48
DA		 1806 .vidioc_s_jpegcomp = vidioc_s_jpegcomp,
1807 .vidioc_g_jpegcomp = vidioc_g_jpegcomp,
7d853532
DA		 1808 .vidioc_s_parm = vidioc_s_parm,
1809 .vidioc_g_parm = vidioc_g_parm,
a399810c
HV		 1810};
1811
1812static struct video_device template = {
1813 .name = "s2255v",
a399810c
HV		 1814 .fops = &s2255_fops_v4l,
1815 .ioctl_ops = &s2255_ioctl_ops,
1816 .minor = -1,
1817 .release = video_device_release,
38f993ad
DA		 1818 .tvnorms = S2255_NORMS,
1819 .current_norm = V4L2_STD_NTSC_M,
1820};
1821
1822static int s2255_probe_v4l(struct s2255_dev *dev)
1823{
1824 int ret;
1825 int i;
1826 int cur_nr = video_nr;
1827
1828 /* initialize all video 4 linux */
38f993ad
DA		 1829 /* register 4 video devices */
1830 for (i = 0; i < MAX_CHANNELS; i++) {
1831 INIT_LIST_HEAD(&dev->vidq[i].active);
1832 dev->vidq[i].dev = dev;
1833 dev->vidq[i].channel = i;
38f993ad
DA		 1834 /* register 4 video devices */
1835 dev->vdev[i] = video_device_alloc();
1836 memcpy(dev->vdev[i], &template, sizeof(struct video_device));
5e85e732 1837 dev->vdev[i]->parent = &dev->interface->dev;
63b0d5ad 1838 video_set_drvdata(dev->vdev[i], dev);
38f993ad
DA		 1839 if (video_nr == -1)
1840 ret = video_register_device(dev->vdev[i],
1841 VFL_TYPE_GRABBER,
1842 video_nr);
1843 else
1844 ret = video_register_device(dev->vdev[i],
1845 VFL_TYPE_GRABBER,
1846 cur_nr + i);
601e9444 1847 video_set_drvdata(dev->vdev[i], dev);
38f993ad
DA		 1848
1849 if (ret != 0) {
1850 dev_err(&dev->udev->dev,
1851 "failed to register video device!\n");
1852 return ret;
1853 }
1854 }
abce21f4
DA		 1855 printk(KERN_INFO "Sensoray 2255 V4L driver Revision: %d.%d\n",
1856 S2255_MAJOR_VERSION,
1857 S2255_MINOR_VERSION);
38f993ad
DA		 1858 return ret;
1859}
1860
1861static void s2255_exit_v4l(struct s2255_dev *dev)
1862{
14d96260 1863
38f993ad 1864 int i;
38f993ad 1865 for (i = 0; i < MAX_CHANNELS; i++) {
f0813b4c 1866 if (video_is_registered(dev->vdev[i])) {
38f993ad 1867 video_unregister_device(dev->vdev[i]);
14d96260
DA		 1868 printk(KERN_INFO "s2255 unregistered\n");
1869 } else {
38f993ad 1870 video_device_release(dev->vdev[i]);
14d96260
DA		 1871 printk(KERN_INFO "s2255 released\n");
1872 }
38f993ad
DA		 1873 }
1874}
1875
1876/* this function moves the usb stream read pipe data
1877 * into the system buffers.
1878 * returns 0 on success, EAGAIN if more data to process( call this
1879 * function again).
1880 *
1881 * Received frame structure:
14d96260 1882 * bytes 0-3: marker : 0x2255DA4AL (S2255_MARKER_FRAME)
38f993ad
DA		 1883 * bytes 4-7: channel: 0-3
1884 * bytes 8-11: payload size: size of the frame
1885 * bytes 12-payloadsize+12: frame data
1886 */
1887static int save_frame(struct s2255_dev *dev, struct s2255_pipeinfo *pipe_info)
1888{
38f993ad
DA		 1889 char *pdest;
1890 u32 offset = 0;
14d96260 1891 int bframe = 0;
38f993ad
DA		 1892 char *psrc;
1893 unsigned long copy_size;
1894 unsigned long size;
1895 s32 idx = -1;
1896 struct s2255_framei *frm;
1897 unsigned char *pdata;
14d96260 1898
38f993ad
DA		 1899 dprintk(100, "buffer to user\n");
1900
1901 idx = dev->cur_frame[dev->cc];
14d96260 1902 frm = &dev->buffer[dev->cc].frame[idx];
38f993ad 1903
14d96260
DA		 1904 if (frm->ulState == S2255_READ_IDLE) {
1905 int jj;
1906 unsigned int cc;
1907 s32 *pdword;
1908 int payload;
1909 /* search for marker codes */
1910 pdata = (unsigned char *)pipe_info->transfer_buffer;
1911 for (jj = 0; jj < (pipe_info->cur_transfer_size - 12); jj++) {
1912 switch (*(s32 *) pdata) {
1913 case S2255_MARKER_FRAME:
1914 pdword = (s32 *)pdata;
1915 dprintk(4, "found frame marker at offset:"
1916 " %d [%x %x]\n", jj, pdata[0],
1917 pdata[1]);
1918 offset = jj + PREFIX_SIZE;
1919 bframe = 1;
1920 cc = pdword[1];
1921 if (cc >= MAX_CHANNELS) {
1922 printk(KERN_ERR
1923 "bad channel\n");
1924 return -EINVAL;
1925 }
1926 /* reverse it */
1927 dev->cc = G_chnmap[cc];
1928 payload = pdword[3];
1929 if (payload > dev->req_image_size[dev->cc]) {
1930 dev->bad_payload[dev->cc]++;
1931 /* discard the bad frame */
1932 return -EINVAL;
1933 }
1934 dev->pkt_size[dev->cc] = payload;
1935 dev->jpg_size[dev->cc] = pdword[4];
1936 break;
1937 case S2255_MARKER_RESPONSE:
1938 pdword = (s32 *)pdata;
1939 pdata += DEF_USB_BLOCK;
1940 jj += DEF_USB_BLOCK;
1941 if (pdword[1] >= MAX_CHANNELS)
1942 break;
1943 cc = G_chnmap[pdword[1]];
f14a2972 1944 if (cc >= MAX_CHANNELS)
14d96260
DA		 1945 break;
1946 switch (pdword[2]) {
abce21f4 1947 case S2255_RESPONSE_SETMODE:
14d96260
DA		 1948 /* check if channel valid */
1949 /* set mode ready */
1950 dev->setmode_ready[cc] = 1;
1951 wake_up(&dev->wait_setmode[cc]);
1952 dprintk(5, "setmode ready %d\n", cc);
38f993ad 1953 break;
abce21f4 1954 case S2255_RESPONSE_FW:
14d96260
DA		 1955
1956 dev->chn_ready |= (1 << cc);
1957 if ((dev->chn_ready & 0x0f) != 0x0f)
1958 break;
1959 /* all channels ready */
1960 printk(KERN_INFO "s2255: fw loaded\n");
1961 atomic_set(&dev->fw_data->fw_state,
1962 S2255_FW_SUCCESS);
1963 wake_up(&dev->fw_data->wait_fw);
1964 break;
1965 default:
af901ca1 1966 printk(KERN_INFO "s2255 unknown resp\n");
38f993ad 1967 }
14d96260 1968 default:
38f993ad 1969 pdata++;
14d96260 1970 break;
38f993ad 1971 }
14d96260
DA		 1972 if (bframe)
1973 break;
1974 } /* for */
1975 if (!bframe)
1976 return -EINVAL;
38f993ad
DA		 1977 }
1978
14d96260 1979
38f993ad
DA		 1980 idx = dev->cur_frame[dev->cc];
1981 frm = &dev->buffer[dev->cc].frame[idx];
1982
14d96260
DA		 1983 /* search done. now find out if should be acquiring on this channel */
1984 if (!dev->b_acquire[dev->cc]) {
1985 /* we found a frame, but this channel is turned off */
1986 frm->ulState = S2255_READ_IDLE;
1987 return -EINVAL;
38f993ad
DA		 1988 }
1989
14d96260
DA		 1990 if (frm->ulState == S2255_READ_IDLE) {
1991 frm->ulState = S2255_READ_FRAME;
1992 frm->cur_size = 0;
38f993ad
DA		 1993 }
1994
14d96260
DA		 1995 /* skip the marker 512 bytes (and offset if out of sync) */
1996 psrc = (u8 *)pipe_info->transfer_buffer + offset;
1997
1998
38f993ad
DA		 1999 if (frm->lpvbits == NULL) {
2000 dprintk(1, "s2255 frame buffer == NULL.%p %p %d %d",
2001 frm, dev, dev->cc, idx);
2002 return -ENOMEM;
2003 }
2004
2005 pdest = frm->lpvbits + frm->cur_size;
2006
14d96260 2007 copy_size = (pipe_info->cur_transfer_size - offset);
38f993ad 2008
14d96260 2009 size = dev->pkt_size[dev->cc] - PREFIX_SIZE;
38f993ad 2010
14d96260
DA		 2011 /* sanity check on pdest */
2012 if ((copy_size + frm->cur_size) < dev->req_image_size[dev->cc])
2013 memcpy(pdest, psrc, copy_size);
38f993ad 2014
38f993ad 2015 frm->cur_size += copy_size;
14d96260
DA		 2016 dprintk(4, "cur_size size %lu size %lu \n", frm->cur_size, size);
2017
2018 if (frm->cur_size >= size) {
38f993ad 2019
38f993ad 2020 u32 cc = dev->cc;
38f993ad
DA		 2021 dprintk(2, "****************[%d]Buffer[%d]full*************\n",
2022 cc, idx);
2023 dev->last_frame[cc] = dev->cur_frame[cc];
2024 dev->cur_frame[cc]++;
2025 /* end of system frame ring buffer, start at zero */
2026 if ((dev->cur_frame[cc] == SYS_FRAMES) ||
2027 (dev->cur_frame[cc] == dev->buffer[cc].dwFrames))
2028 dev->cur_frame[cc] = 0;
14d96260 2029 /* frame ready */
38f993ad 2030 if (dev->b_acquire[cc])
14d96260 2031 s2255_got_frame(dev, cc, dev->jpg_size[cc]);
38f993ad 2032 dev->frame_count[cc]++;
14d96260
DA		 2033 frm->ulState = S2255_READ_IDLE;
2034 frm->cur_size = 0;
2035
38f993ad
DA		 2036 }
2037 /* done successfully */
2038 return 0;
2039}
2040
2041static void s2255_read_video_callback(struct s2255_dev *dev,
2042 struct s2255_pipeinfo *pipe_info)
2043{
2044 int res;
2045 dprintk(50, "callback read video \n");
2046
2047 if (dev->cc >= MAX_CHANNELS) {
2048 dev->cc = 0;
2049 dev_err(&dev->udev->dev, "invalid channel\n");
2050 return;
2051 }
2052 /* otherwise copy to the system buffers */
2053 res = save_frame(dev, pipe_info);
14d96260
DA		 2054 if (res != 0)
2055 dprintk(4, "s2255: read callback failed\n");
38f993ad
DA		 2056
2057 dprintk(50, "callback read video done\n");
2058 return;
2059}
2060
2061static long s2255_vendor_req(struct s2255_dev *dev, unsigned char Request,
2062 u16 Index, u16 Value, void *TransferBuffer,
2063 s32 TransferBufferLength, int bOut)
2064{
2065 int r;
2066 if (!bOut) {
2067 r = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
2068 Request,
2069 USB_TYPE_VENDOR | USB_RECIP_DEVICE |
2070 USB_DIR_IN,
2071 Value, Index, TransferBuffer,
2072 TransferBufferLength, HZ * 5);
2073 } else {
2074 r = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
2075 Request, USB_TYPE_VENDOR | USB_RECIP_DEVICE,
2076 Value, Index, TransferBuffer,
2077 TransferBufferLength, HZ * 5);
2078 }
2079 return r;
2080}
2081
2082/*
2083 * retrieve FX2 firmware version. future use.
2084 * @param dev pointer to device extension
2085 * @return -1 for fail, else returns firmware version as an int(16 bits)
2086 */
2087static int s2255_get_fx2fw(struct s2255_dev *dev)
2088{
2089 int fw;
2090 int ret;
2091 unsigned char transBuffer[64];
2092 ret = s2255_vendor_req(dev, S2255_VR_FW, 0, 0, transBuffer, 2,
2093 S2255_VR_IN);
2094 if (ret < 0)
2095 dprintk(2, "get fw error: %x\n", ret);
2096 fw = transBuffer[0] + (transBuffer[1] << 8);
2097 dprintk(2, "Get FW %x %x\n", transBuffer[0], transBuffer[1]);
2098 return fw;
2099}
2100
2101/*
2102 * Create the system ring buffer to copy frames into from the
2103 * usb read pipe.
2104 */
2105static int s2255_create_sys_buffers(struct s2255_dev *dev, unsigned long chn)
2106{
2107 unsigned long i;
2108 unsigned long reqsize;
2109 dprintk(1, "create sys buffers\n");
2110 if (chn >= MAX_CHANNELS)
2111 return -1;
2112
2113 dev->buffer[chn].dwFrames = SYS_FRAMES;
2114
2115 /* always allocate maximum size(PAL) for system buffers */
2116 reqsize = SYS_FRAMES_MAXSIZE;
2117
2118 if (reqsize > SYS_FRAMES_MAXSIZE)
2119 reqsize = SYS_FRAMES_MAXSIZE;
2120
2121 for (i = 0; i < SYS_FRAMES; i++) {
2122 /* allocate the frames */
2123 dev->buffer[chn].frame[i].lpvbits = vmalloc(reqsize);
2124
2125 dprintk(1, "valloc %p chan %lu, idx %lu, pdata %p\n",
2126 &dev->buffer[chn].frame[i], chn, i,
2127 dev->buffer[chn].frame[i].lpvbits);
2128 dev->buffer[chn].frame[i].size = reqsize;
2129 if (dev->buffer[chn].frame[i].lpvbits == NULL) {
2130 printk(KERN_INFO "out of memory. using less frames\n");
2131 dev->buffer[chn].dwFrames = i;
2132 break;
2133 }
2134 }
2135
2136 /* make sure internal states are set */
2137 for (i = 0; i < SYS_FRAMES; i++) {
2138 dev->buffer[chn].frame[i].ulState = 0;
2139 dev->buffer[chn].frame[i].cur_size = 0;
2140 }
2141
2142 dev->cur_frame[chn] = 0;
2143 dev->last_frame[chn] = -1;
2144 return 0;
2145}
2146
2147static int s2255_release_sys_buffers(struct s2255_dev *dev,
2148 unsigned long channel)
2149{
2150 unsigned long i;
2151 dprintk(1, "release sys buffers\n");
2152 for (i = 0; i < SYS_FRAMES; i++) {
2153 if (dev->buffer[channel].frame[i].lpvbits) {
2154 dprintk(1, "vfree %p\n",
2155 dev->buffer[channel].frame[i].lpvbits);
2156 vfree(dev->buffer[channel].frame[i].lpvbits);
2157 }
2158 dev->buffer[channel].frame[i].lpvbits = NULL;
2159 }
2160 return 0;
2161}
2162
2163static int s2255_board_init(struct s2255_dev *dev)
2164{
2165 int j;
2166 struct s2255_mode mode_def = DEF_MODEI_NTSC_CONT;
2167 int fw_ver;
2168 dprintk(4, "board init: %p", dev);
2169
2170 for (j = 0; j < MAX_PIPE_BUFFERS; j++) {
2171 struct s2255_pipeinfo *pipe = &dev->pipes[j];
2172
2173 memset(pipe, 0, sizeof(*pipe));
2174 pipe->dev = dev;
14d96260
DA		 2175 pipe->cur_transfer_size = S2255_USB_XFER_SIZE;
2176 pipe->max_transfer_size = S2255_USB_XFER_SIZE;
38f993ad 2177
38f993ad
DA		 2178 pipe->transfer_buffer = kzalloc(pipe->max_transfer_size,
2179 GFP_KERNEL);
2180 if (pipe->transfer_buffer == NULL) {
2181 dprintk(1, "out of memory!\n");
2182 return -ENOMEM;
2183 }
2184
2185 }
2186
2187 /* query the firmware */
2188 fw_ver = s2255_get_fx2fw(dev);
2189
abce21f4
DA		 2190 printk(KERN_INFO "2255 usb firmware version %d.%d\n",
2191 (fw_ver >> 8) & 0xff,
2192 fw_ver & 0xff);
2193
2194 if (fw_ver < S2255_CUR_USB_FWVER)
be9ed511 2195 dev_err(&dev->udev->dev,
abce21f4
DA		 2196 "usb firmware not up to date %d.%d\n",
2197 (fw_ver >> 8) & 0xff,
2198 fw_ver & 0xff);
38f993ad
DA		 2199
2200 for (j = 0; j < MAX_CHANNELS; j++) {
2201 dev->b_acquire[j] = 0;
2202 dev->mode[j] = mode_def;
22b88d48 2203 dev->jc[j].quality = S2255_DEF_JPEG_QUAL;
38f993ad
DA		 2204 dev->cur_fmt[j] = &formats[0];
2205 dev->mode[j].restart = 1;
2206 dev->req_image_size[j] = get_transfer_size(&mode_def);
2207 dev->frame_count[j] = 0;
2208 /* create the system buffers */
2209 s2255_create_sys_buffers(dev, j);
2210 }
2211 /* start read pipe */
2212 s2255_start_readpipe(dev);
2213
2214 dprintk(1, "S2255: board initialized\n");
2215 return 0;
2216}
2217
2218static int s2255_board_shutdown(struct s2255_dev *dev)
2219{
2220 u32 i;
2221
2222 dprintk(1, "S2255: board shutdown: %p", dev);
2223
2224 for (i = 0; i < MAX_CHANNELS; i++) {
2225 if (dev->b_acquire[i])
2226 s2255_stop_acquire(dev, i);
2227 }
2228
2229 s2255_stop_readpipe(dev);
2230
2231 for (i = 0; i < MAX_CHANNELS; i++)
2232 s2255_release_sys_buffers(dev, i);
2233
2234 /* release transfer buffers */
2235 for (i = 0; i < MAX_PIPE_BUFFERS; i++) {
2236 struct s2255_pipeinfo *pipe = &dev->pipes[i];
2237 kfree(pipe->transfer_buffer);
2238 }
2239 return 0;
2240}
2241
2242static void read_pipe_completion(struct urb *purb)
2243{
2244 struct s2255_pipeinfo *pipe_info;
2245 struct s2255_dev *dev;
2246 int status;
2247 int pipe;
2248
2249 pipe_info = purb->context;
2250 dprintk(100, "read pipe completion %p, status %d\n", purb,
2251 purb->status);
2252 if (pipe_info == NULL) {
be9ed511 2253 dev_err(&purb->dev->dev, "no context!\n");
38f993ad
DA		 2254 return;
2255 }
2256
2257 dev = pipe_info->dev;
2258 if (dev == NULL) {
be9ed511 2259 dev_err(&purb->dev->dev, "no context!\n");
38f993ad
DA		 2260 return;
2261 }
2262 status = purb->status;
b02064ca
DA		 2263 /* if shutting down, do not resubmit, exit immediately */
2264 if (status == -ESHUTDOWN) {
2265 dprintk(2, "read_pipe_completion: err shutdown\n");
2266 pipe_info->err_count++;
38f993ad
DA		 2267 return;
2268 }
2269
2270 if (pipe_info->state == 0) {
2271 dprintk(2, "exiting USB pipe");
2272 return;
2273 }
2274
b02064ca
DA		 2275 if (status == 0)
2276 s2255_read_video_callback(dev, pipe_info);
2277 else {
2278 pipe_info->err_count++;
2279 dprintk(1, "s2255drv: failed URB %d\n", status);
2280 }
38f993ad 2281
38f993ad
DA		 2282 pipe = usb_rcvbulkpipe(dev->udev, dev->read_endpoint);
2283 /* reuse urb */
2284 usb_fill_bulk_urb(pipe_info->stream_urb, dev->udev,
2285 pipe,
2286 pipe_info->transfer_buffer,
2287 pipe_info->cur_transfer_size,
2288 read_pipe_completion, pipe_info);
2289
2290 if (pipe_info->state != 0) {
2291 if (usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL)) {
2292 dev_err(&dev->udev->dev, "error submitting urb\n");
38f993ad
DA		 2293 }
2294 } else {
2295 dprintk(2, "read pipe complete state 0\n");
2296 }
2297 return;
2298}
2299
2300static int s2255_start_readpipe(struct s2255_dev *dev)
2301{
2302 int pipe;
2303 int retval;
2304 int i;
2305 struct s2255_pipeinfo *pipe_info = dev->pipes;
2306 pipe = usb_rcvbulkpipe(dev->udev, dev->read_endpoint);
2307 dprintk(2, "start pipe IN %d\n", dev->read_endpoint);
2308
2309 for (i = 0; i < MAX_PIPE_BUFFERS; i++) {
2310 pipe_info->state = 1;
abce21f4 2311 pipe_info->err_count = 0;
38f993ad
DA		 2312 pipe_info->stream_urb = usb_alloc_urb(0, GFP_KERNEL);
2313 if (!pipe_info->stream_urb) {
2314 dev_err(&dev->udev->dev,
be9ed511 2315 "ReadStream: Unable to alloc URB\n");
38f993ad
DA		 2316 return -ENOMEM;
2317 }
2318 /* transfer buffer allocated in board_init */
2319 usb_fill_bulk_urb(pipe_info->stream_urb, dev->udev,
2320 pipe,
2321 pipe_info->transfer_buffer,
2322 pipe_info->cur_transfer_size,
2323 read_pipe_completion, pipe_info);
2324
38f993ad
DA		 2325 dprintk(4, "submitting URB %p\n", pipe_info->stream_urb);
2326 retval = usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL);
2327 if (retval) {
2328 printk(KERN_ERR "s2255: start read pipe failed\n");
2329 return retval;
2330 }
2331 }
2332
2333 return 0;
2334}
2335
2336/* starts acquisition process */
2337static int s2255_start_acquire(struct s2255_dev *dev, unsigned long chn)
2338{
2339 unsigned char *buffer;
2340 int res;
2341 unsigned long chn_rev;
2342 int j;
2343 if (chn >= MAX_CHANNELS) {
2344 dprintk(2, "start acquire failed, bad channel %lu\n", chn);
2345 return -1;
2346 }
2347
2348 chn_rev = G_chnmap[chn];
2349 dprintk(1, "S2255: start acquire %lu \n", chn);
2350
2351 buffer = kzalloc(512, GFP_KERNEL);
2352 if (buffer == NULL) {
2353 dev_err(&dev->udev->dev, "out of mem\n");
2354 return -ENOMEM;
2355 }
2356
2357 dev->last_frame[chn] = -1;
2358 dev->bad_payload[chn] = 0;
2359 dev->cur_frame[chn] = 0;
2360 for (j = 0; j < SYS_FRAMES; j++) {
2361 dev->buffer[chn].frame[j].ulState = 0;
2362 dev->buffer[chn].frame[j].cur_size = 0;
2363 }
2364
2365 /* send the start command */
2366 *(u32 *) buffer = IN_DATA_TOKEN;
2367 *((u32 *) buffer + 1) = (u32) chn_rev;
2368 *((u32 *) buffer + 2) = (u32) CMD_START;
2369 res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
2370 if (res != 0)
2371 dev_err(&dev->udev->dev, "CMD_START error\n");
2372
2373 dprintk(2, "start acquire exit[%lu] %d \n", chn, res);
2374 kfree(buffer);
2375 return 0;
2376}
2377
2378static int s2255_stop_acquire(struct s2255_dev *dev, unsigned long chn)
2379{
2380 unsigned char *buffer;
2381 int res;
2382 unsigned long chn_rev;
2383
2384 if (chn >= MAX_CHANNELS) {
2385 dprintk(2, "stop acquire failed, bad channel %lu\n", chn);
2386 return -1;
2387 }
2388 chn_rev = G_chnmap[chn];
2389
2390 buffer = kzalloc(512, GFP_KERNEL);
2391 if (buffer == NULL) {
2392 dev_err(&dev->udev->dev, "out of mem\n");
2393 return -ENOMEM;
2394 }
2395
2396 /* send the stop command */
2397 dprintk(4, "stop acquire %lu\n", chn);
2398 *(u32 *) buffer = IN_DATA_TOKEN;
2399 *((u32 *) buffer + 1) = (u32) chn_rev;
2400 *((u32 *) buffer + 2) = CMD_STOP;
2401 res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
2402
2403 if (res != 0)
2404 dev_err(&dev->udev->dev, "CMD_STOP error\n");
2405
2406 dprintk(4, "stop acquire: releasing states \n");
2407
2408 kfree(buffer);
2409 dev->b_acquire[chn] = 0;
2410
14d96260 2411 return res;
38f993ad
DA		 2412}
2413
2414static void s2255_stop_readpipe(struct s2255_dev *dev)
2415{
2416 int j;
2417
2418 if (dev == NULL) {
be9ed511 2419 s2255_dev_err(&dev->udev->dev, "invalid device\n");
38f993ad
DA		 2420 return;
2421 }
2422 dprintk(4, "stop read pipe\n");
2423 for (j = 0; j < MAX_PIPE_BUFFERS; j++) {
2424 struct s2255_pipeinfo *pipe_info = &dev->pipes[j];
2425 if (pipe_info) {
2426 if (pipe_info->state == 0)
2427 continue;
2428 pipe_info->state = 0;
38f993ad
DA		 2429 }
2430 }
2431
2432 for (j = 0; j < MAX_PIPE_BUFFERS; j++) {
2433 struct s2255_pipeinfo *pipe_info = &dev->pipes[j];
2434 if (pipe_info->stream_urb) {
2435 /* cancel urb */
2436 usb_kill_urb(pipe_info->stream_urb);
2437 usb_free_urb(pipe_info->stream_urb);
2438 pipe_info->stream_urb = NULL;
2439 }
2440 }
2441 dprintk(2, "s2255 stop read pipe: %d\n", j);
2442 return;
2443}
2444
14d96260 2445static void s2255_fwload_start(struct s2255_dev *dev, int reset)
38f993ad 2446{
14d96260
DA		 2447 if (reset)
2448 s2255_reset_dsppower(dev);
38f993ad
DA		 2449 dev->fw_data->fw_size = dev->fw_data->fw->size;
2450 atomic_set(&dev->fw_data->fw_state, S2255_FW_NOTLOADED);
2451 memcpy(dev->fw_data->pfw_data,
2452 dev->fw_data->fw->data, CHUNK_SIZE);
2453 dev->fw_data->fw_loaded = CHUNK_SIZE;
2454 usb_fill_bulk_urb(dev->fw_data->fw_urb, dev->udev,
2455 usb_sndbulkpipe(dev->udev, 2),
2456 dev->fw_data->pfw_data,
2457 CHUNK_SIZE, s2255_fwchunk_complete,
2458 dev->fw_data);
2459 mod_timer(&dev->timer, jiffies + HZ);
2460}
2461
2462/* standard usb probe function */
2463static int s2255_probe(struct usb_interface *interface,
2464 const struct usb_device_id *id)
2465{
2466 struct s2255_dev *dev = NULL;
2467 struct usb_host_interface *iface_desc;
2468 struct usb_endpoint_descriptor *endpoint;
2469 int i;
2470 int retval = -ENOMEM;
14d96260
DA		 2471 __le32 *pdata;
2472 int fw_size;
38f993ad
DA		 2473
2474 dprintk(2, "s2255: probe\n");
2475
2476 /* allocate memory for our device state and initialize it to zero */
2477 dev = kzalloc(sizeof(struct s2255_dev), GFP_KERNEL);
2478 if (dev == NULL) {
be9ed511 2479 s2255_dev_err(&interface->dev, "out of memory\n");
38f993ad
DA		 2480 goto error;
2481 }
2482
2483 dev->fw_data = kzalloc(sizeof(struct s2255_fw), GFP_KERNEL);
2484 if (!dev->fw_data)
2485 goto error;
2486
2487 mutex_init(&dev->lock);
2488 mutex_init(&dev->open_lock);
2489
2490 /* grab usb_device and save it */
2491 dev->udev = usb_get_dev(interface_to_usbdev(interface));
2492 if (dev->udev == NULL) {
2493 dev_err(&interface->dev, "null usb device\n");
2494 retval = -ENODEV;
2495 goto error;
2496 }
2497 kref_init(&dev->kref);
2498 dprintk(1, "dev: %p, kref: %p udev %p interface %p\n", dev, &dev->kref,
2499 dev->udev, interface);
2500 dev->interface = interface;
2501 /* set up the endpoint information */
2502 iface_desc = interface->cur_altsetting;
2503 dprintk(1, "num endpoints %d\n", iface_desc->desc.bNumEndpoints);
2504 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
2505 endpoint = &iface_desc->endpoint[i].desc;
2506 if (!dev->read_endpoint && usb_endpoint_is_bulk_in(endpoint)) {
2507 /* we found the bulk in endpoint */
2508 dev->read_endpoint = endpoint->bEndpointAddress;
2509 }
2510 }
2511
2512 if (!dev->read_endpoint) {
be9ed511 2513 dev_err(&interface->dev, "Could not find bulk-in endpoint\n");
38f993ad
DA		 2514 goto error;
2515 }
2516
2517 /* set intfdata */
2518 usb_set_intfdata(interface, dev);
2519
2520 dprintk(100, "after intfdata %p\n", dev);
2521
2522 init_timer(&dev->timer);
2523 dev->timer.function = s2255_timer;
2524 dev->timer.data = (unsigned long)dev->fw_data;
2525
2526 init_waitqueue_head(&dev->fw_data->wait_fw);
14d96260
DA		 2527 for (i = 0; i < MAX_CHANNELS; i++)
2528 init_waitqueue_head(&dev->wait_setmode[i]);
38f993ad
DA		 2529
2530
2531 dev->fw_data->fw_urb = usb_alloc_urb(0, GFP_KERNEL);
2532
2533 if (!dev->fw_data->fw_urb) {
2534 dev_err(&interface->dev, "out of memory!\n");
2535 goto error;
2536 }
2537 dev->fw_data->pfw_data = kzalloc(CHUNK_SIZE, GFP_KERNEL);
2538 if (!dev->fw_data->pfw_data) {
2539 dev_err(&interface->dev, "out of memory!\n");
2540 goto error;
2541 }
2542 /* load the first chunk */
2543 if (request_firmware(&dev->fw_data->fw,
2544 FIRMWARE_FILE_NAME, &dev->udev->dev)) {
2545 printk(KERN_ERR "sensoray 2255 failed to get firmware\n");
2546 goto error;
2547 }
14d96260
DA		 2548 /* check the firmware is valid */
2549 fw_size = dev->fw_data->fw->size;
2550 pdata = (__le32 *) &dev->fw_data->fw->data[fw_size - 8];
38f993ad 2551
14d96260
DA		 2552 if (*pdata != S2255_FW_MARKER) {
2553 printk(KERN_INFO "Firmware invalid.\n");
2554 retval = -ENODEV;
2555 goto error;
2556 } else {
2557 /* make sure firmware is the latest */
2558 __le32 *pRel;
2559 pRel = (__le32 *) &dev->fw_data->fw->data[fw_size - 4];
2560 printk(KERN_INFO "s2255 dsp fw version %x\n", *pRel);
2561 }
38f993ad
DA		 2562 /* loads v4l specific */
2563 s2255_probe_v4l(dev);
14d96260 2564 usb_reset_device(dev->udev);
38f993ad 2565 /* load 2255 board specific */
abce21f4
DA		 2566 retval = s2255_board_init(dev);
2567 if (retval)
2568 goto error;
38f993ad
DA		 2569
2570 dprintk(4, "before probe done %p\n", dev);
2571 spin_lock_init(&dev->slock);
2572
14d96260 2573 s2255_fwload_start(dev, 0);
38f993ad
DA		 2574 dev_info(&interface->dev, "Sensoray 2255 detected\n");
2575 return 0;
2576error:
2577 return retval;
2578}
2579
2580/* disconnect routine. when board is removed physically or with rmmod */
2581static void s2255_disconnect(struct usb_interface *interface)
2582{
2583 struct s2255_dev *dev = NULL;
14d96260 2584 int i;
38f993ad
DA		 2585 dprintk(1, "s2255: disconnect interface %p\n", interface);
2586 dev = usb_get_intfdata(interface);
14d96260
DA		 2587
2588 /*
2589 * wake up any of the timers to allow open_lock to be
2590 * acquired sooner
2591 */
2592 atomic_set(&dev->fw_data->fw_state, S2255_FW_DISCONNECTING);
2593 wake_up(&dev->fw_data->wait_fw);
2594 for (i = 0; i < MAX_CHANNELS; i++) {
2595 dev->setmode_ready[i] = 1;
2596 wake_up(&dev->wait_setmode[i]);
2597 }
2598
2599 mutex_lock(&dev->open_lock);
2600 usb_set_intfdata(interface, NULL);
2601 mutex_unlock(&dev->open_lock);
2602
38f993ad
DA		 2603 if (dev) {
2604 kref_put(&dev->kref, s2255_destroy);
2605 dprintk(1, "s2255drv: disconnect\n");
2606 dev_info(&interface->dev, "s2255usb now disconnected\n");
2607 }
38f993ad
DA		 2608}
2609
2610static struct usb_driver s2255_driver = {
be9ed511 2611 .name = S2255_DRIVER_NAME,
38f993ad
DA		 2612 .probe = s2255_probe,
2613 .disconnect = s2255_disconnect,
2614 .id_table = s2255_table,
2615};
2616
2617static int __init usb_s2255_init(void)
2618{
2619 int result;
2620
2621 /* register this driver with the USB subsystem */
2622 result = usb_register(&s2255_driver);
2623
2624 if (result)
be9ed511
MCC		 2625 pr_err(KBUILD_MODNAME
2626 ": usb_register failed. Error number %d\n", result);
38f993ad
DA		 2627
2628 dprintk(2, "s2255_init: done\n");
2629 return result;
2630}
2631
2632static void __exit usb_s2255_exit(void)
2633{
2634 usb_deregister(&s2255_driver);
2635}
2636
2637module_init(usb_s2255_init);
2638module_exit(usb_s2255_exit);
2639
2640MODULE_DESCRIPTION("Sensoray 2255 Video for Linux driver");
2641MODULE_AUTHOR("Dean Anderson (Sensoray Company Inc.)");
2642MODULE_LICENSE("GPL");
Linux 6.x block layer and io_uring tree(s)