]> bbs.cooldavid.org Git - net-next-2.6.git/blame - drivers/media/video/em28xx/em28xx-video.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
V4L/DVB (7541): em28xx: Some fixes to videobuf
[net-next-2.6.git] / drivers / media / video / em28xx / em28xx-video.c
CommitLineData
a6c2ba28 1/*
f7abcd38 2 em28xx-video.c - driver for Empia EM2800/EM2820/2840 USB video capture devices
a6c2ba28 3
f7abcd38
MCC		 4 Copyright (C) 2005 Ludovico Cavedon <cavedon@sssup.it>
5 Markus Rechberger <mrechberger@gmail.com>
2e7c6dc3 6 Mauro Carvalho Chehab <mchehab@infradead.org>
f7abcd38 7 Sascha Sommer <saschasommer@freenet.de>
a6c2ba28 8
439090d7
MCC		 9 Some parts based on SN9C10x PC Camera Controllers GPL driver made
10 by Luca Risolia <luca.risolia@studio.unibo.it>
11
a6c2ba28
AM		 12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 2 of the License, or
15 (at your option) any later version.
16
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
21
22 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 */
26
27#include <linux/init.h>
28#include <linux/list.h>
29#include <linux/module.h>
30#include <linux/kernel.h>
e5589bef 31#include <linux/bitmap.h>
a6c2ba28 32#include <linux/usb.h>
a6c2ba28 33#include <linux/i2c.h>
b296fc60 34#include <linux/version.h>
6d35c8f6 35#include <linux/mm.h>
1e4baed3 36#include <linux/mutex.h>
a6c2ba28 37
f7abcd38 38#include "em28xx.h"
c0477ad9 39#include <media/v4l2-common.h>
2474ed44 40#include <media/msp3400.h>
ed086314 41#include <media/tuner.h>
a6c2ba28 42
f7abcd38
MCC		 43#define DRIVER_AUTHOR "Ludovico Cavedon <cavedon@sssup.it>, " \
44 "Markus Rechberger <mrechberger@gmail.com>, " \
2e7c6dc3 45 "Mauro Carvalho Chehab <mchehab@infradead.org>, " \
f7abcd38 46 "Sascha Sommer <saschasommer@freenet.de>"
a6c2ba28 47
f7abcd38
MCC		 48#define DRIVER_NAME "em28xx"
49#define DRIVER_DESC "Empia em28xx based USB video device driver"
195a4ef6 50#define EM28XX_VERSION_CODE KERNEL_VERSION(0, 1, 0)
a6c2ba28 51
3acf2809 52#define em28xx_videodbg(fmt, arg...) do {\
4ac97914
MCC		 53 if (video_debug) \
54 printk(KERN_INFO "%s %s :"fmt, \
d80e134d 55 dev->name, __func__ , ##arg); } while (0)
a6c2ba28 56
ad0ebb96
MCC		 57static unsigned int isoc_debug;
58module_param(isoc_debug,int,0644);
59MODULE_PARM_DESC(isoc_debug,"enable debug messages [isoc transfers]");
60
61#define em28xx_isocdbg(fmt, arg...) do {\
62 if (isoc_debug) \
63 printk(KERN_INFO "%s %s :"fmt, \
64 dev->name, __FUNCTION__ , ##arg); } while (0)
65
66#define BUFFER_TIMEOUT msecs_to_jiffies(2000) /* 2 seconds */
67
68/* Limits minimum and default number of buffers */
69#define EM28XX_MIN_BUF 4
70#define EM28XX_DEF_BUF 8
71
a6c2ba28
AM		 72MODULE_AUTHOR(DRIVER_AUTHOR);
73MODULE_DESCRIPTION(DRIVER_DESC);
74MODULE_LICENSE("GPL");
75
3acf2809 76static LIST_HEAD(em28xx_devlist);
9c75541f 77
9d4d9c05 78static unsigned int card[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = UNSET };
e5589bef 79static unsigned int video_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = UNSET };
0be43754
MCC		 80static unsigned int vbi_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = UNSET };
81static unsigned int radio_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = UNSET };
82
596d92d5 83module_param_array(card, int, NULL, 0444);
e5589bef
MCC		 84module_param_array(video_nr, int, NULL, 0444);
85module_param_array(vbi_nr, int, NULL, 0444);
0be43754
MCC		 86module_param_array(radio_nr, int, NULL, 0444);
87MODULE_PARM_DESC(card, "card type");
88MODULE_PARM_DESC(video_nr, "video device numbers");
89MODULE_PARM_DESC(vbi_nr, "vbi device numbers");
90MODULE_PARM_DESC(radio_nr, "radio device numbers");
596d92d5 91
ff699e6b 92static unsigned int video_debug;
a6c2ba28
AM		 93module_param(video_debug,int,0644);
94MODULE_PARM_DESC(video_debug,"enable debug messages [video]");
95
e5589bef
MCC		 96/* Bitmask marking allocated devices from 0 to EM28XX_MAXBOARDS */
97static unsigned long em28xx_devused;
98
a6c2ba28 99/* supported controls */
c0477ad9 100/* Common to all boards */
3acf2809 101static struct v4l2_queryctrl em28xx_qctrl[] = {
c0477ad9
MCC		 102 {
103 .id = V4L2_CID_AUDIO_VOLUME,
104 .type = V4L2_CTRL_TYPE_INTEGER,
105 .name = "Volume",
106 .minimum = 0x0,
107 .maximum = 0x1f,
108 .step = 0x1,
109 .default_value = 0x1f,
110 .flags = 0,
111 },{
112 .id = V4L2_CID_AUDIO_MUTE,
113 .type = V4L2_CTRL_TYPE_BOOLEAN,
114 .name = "Mute",
115 .minimum = 0,
116 .maximum = 1,
117 .step = 1,
118 .default_value = 1,
119 .flags = 0,
120 }
121};
122
3acf2809 123static struct usb_driver em28xx_usb_driver;
a6c2ba28 124
ad0ebb96
MCC		 125/* ------------------------------------------------------------------
126 DMA and thread functions
127 ------------------------------------------------------------------*/
128
129/*
130 * Announces that a buffer were filled and request the next
131 */
132static void inline buffer_filled (struct em28xx *dev,
133 struct em28xx_dmaqueue *dma_q,
134 struct em28xx_buffer *buf)
135{
d7aa8020
AT		 136 mod_timer(&dma_q->timeout, jiffies+BUFFER_TIMEOUT);
137
ad0ebb96
MCC		 138 /* Nobody is waiting something to be done, just return */
139 if (!waitqueue_active(&buf->vb.done)) {
ad0ebb96
MCC		 140 printk(KERN_ERR "em28xx: buffer underrun at %ld\n",
141 jiffies);
142
143 return;
144 }
145
146 /* Advice that buffer was filled */
147 em28xx_isocdbg("[%p/%d] wakeup\n", buf, buf->vb.i);
148 buf->vb.state = VIDEOBUF_DONE;
149 buf->vb.field_count++;
150 do_gettimeofday(&buf->vb.ts);
151
152 list_del(&buf->vb.queue);
153 wake_up(&buf->vb.done);
154}
155
156/*
157 * Identify the buffer header type and properly handles
158 */
159static void em28xx_copy_video(struct em28xx *dev,
160 struct em28xx_dmaqueue *dma_q,
161 struct em28xx_buffer *buf,
162 unsigned char *p,
163 unsigned char *outp, unsigned long len)
164{
165 void *fieldstart, *startwrite, *startread;
166 int linesdone, currlinedone, offset, lencopy,remain;
167
168 if(dev->frame_size != buf->vb.size){
169 em28xx_errdev("size %i and buf.length %lu are different!\n",
170 dev->frame_size, buf->vb.size);
171 return;
172 }
173
174 if (dma_q->pos + len > buf->vb.size)
175 len = buf->vb.size - dma_q->pos;
176
d7aa8020 177 if (p[0] != 0x88 && p[0] != 0x22) {
ad0ebb96
MCC		 178 em28xx_isocdbg("frame is not complete\n");
179 len += 4;
180 } else
181 p +=4;
182
183 startread = p;
184 remain = len;
185
186 /* Interlaces frame */
187 if (buf->top_field)
188 fieldstart = outp;
189 else
190 fieldstart = outp + dev->bytesperline;
191
192 linesdone = dma_q->pos / dev->bytesperline;
193 currlinedone = dma_q->pos % dev->bytesperline;
194 offset = linesdone * dev->bytesperline * 2 + currlinedone;
195 startwrite = fieldstart + offset;
196 lencopy = dev->bytesperline - currlinedone;
197 lencopy = lencopy > remain ? remain : lencopy;
198
d7aa8020
AT		 199 if((char*)startwrite + lencopy > (char*)outp + buf->vb.size) {
200 em28xx_isocdbg("Overflow of %i bytes past buffer end (1)\n",
201 ((char*)startwrite + lencopy) - ((char*)outp + buf->vb.size));
202 lencopy = remain = (char*)outp + buf->vb.size - (char*)startwrite;
203 }
204 BUG_ON(lencopy <= 0);
205 memcpy(startwrite, startread, lencopy);
ad0ebb96
MCC		 206
207 remain -= lencopy;
208
209 while (remain > 0) {
210 startwrite += lencopy + dev->bytesperline;
211 startread += lencopy;
212 if (dev->bytesperline > remain)
213 lencopy = remain;
214 else
215 lencopy = dev->bytesperline;
216
d7aa8020
AT		 217 BUG_ON(lencopy <= 0);
218
219 if((char*)startwrite + lencopy > (char*)outp + buf->vb.size) {
220 em28xx_isocdbg("Overflow of %i bytes past buffer end (2)\n",
221 ((char*)startwrite + lencopy) - ((char*)outp + buf->vb.size));
222 lencopy = remain = (char*)outp + buf->vb.size - (char*)startwrite;
223 }
224 if(lencopy <= 0) break;
225
226 memcpy(startwrite, startread, lencopy);
ad0ebb96
MCC		 227
228 remain -= lencopy;
229 }
230
231 dma_q->pos += len;
232}
233
234static void inline print_err_status (struct em28xx *dev,
235 int packet, int status)
236{
237 char *errmsg = "Unknown";
238
239 switch(status) {
240 case -ENOENT:
241 errmsg = "unlinked synchronuously";
242 break;
243 case -ECONNRESET:
244 errmsg = "unlinked asynchronuously";
245 break;
246 case -ENOSR:
247 errmsg = "Buffer error (overrun)";
248 break;
249 case -EPIPE:
250 errmsg = "Stalled (device not responding)";
251 break;
252 case -EOVERFLOW:
253 errmsg = "Babble (bad cable?)";
254 break;
255 case -EPROTO:
256 errmsg = "Bit-stuff error (bad cable?)";
257 break;
258 case -EILSEQ:
259 errmsg = "CRC/Timeout (could be anything)";
260 break;
261 case -ETIME:
262 errmsg = "Device does not respond";
263 break;
264 }
265 if (packet<0) {
266 em28xx_isocdbg("URB status %d [%s].\n", status, errmsg);
267 } else {
268 em28xx_isocdbg("URB packet %d, status %d [%s].\n",
269 packet, status, errmsg);
270 }
271}
272
273/*
274 * video-buf generic routine to get the next available buffer
275 */
276static int inline get_next_buf (struct em28xx_dmaqueue *dma_q,
277 struct em28xx_buffer **buf)
278{
279 struct em28xx *dev = container_of(dma_q, struct em28xx, vidq);
280
281 if (list_empty(&dma_q->active)) {
282 em28xx_isocdbg("No active queue to serve\n");
283 return 0;
284 }
285
286 *buf = list_entry(dma_q->active.next, struct em28xx_buffer, vb.queue);
287
288 return 1;
289}
290
291/*
292 * Controls the isoc copy of each urb packet
293 */
d7aa8020 294static inline int em28xx_isoc_copy(struct urb *urb)
ad0ebb96 295{
d7aa8020 296 struct em28xx_buffer *buf;
ad0ebb96
MCC		 297 struct em28xx_dmaqueue *dma_q = urb->context;
298 struct em28xx *dev = container_of(dma_q, struct em28xx, vidq);
d7aa8020 299 unsigned char *outp;
ad0ebb96 300 int i, len = 0, rc = 1;
d7aa8020 301 unsigned char *p;
ad0ebb96
MCC		 302
303 if (!dev)
304 return 0;
305
306 if ((dev->state & DEV_DISCONNECTED) || (dev->state & DEV_MISCONFIGURED))
307 return 0;
308
309 if (urb->status<0) {
310 print_err_status (dev,-1,urb->status);
311 if (urb->status == -ENOENT)
312 return 0;
313 }
314
d7aa8020
AT		 315 buf=dev->isoc_ctl.buf;
316
317 if (!buf) {
318 rc=get_next_buf (dma_q, &buf);
319 if (rc<=0)
320 return rc;
321 }
322
323 outp = videobuf_to_vmalloc (&buf->vb);
324
325
ad0ebb96
MCC		 326 for (i = 0; i < urb->number_of_packets; i++) {
327 int status = urb->iso_frame_desc[i].status;
328
329 if (status<0) {
330 print_err_status (dev,i,status);
331 if (urb->iso_frame_desc[i].status != -EPROTO)
332 continue;
333 }
334
335 len=urb->iso_frame_desc[i].actual_length - 4;
336
337 if (urb->iso_frame_desc[i].actual_length <= 0) {
d7aa8020 338 /* em28xx_isocdbg("packet %d is empty",i); - spammy */
ad0ebb96
MCC		 339 continue;
340 }
341 if (urb->iso_frame_desc[i].actual_length >
342 dev->max_pkt_size) {
343 em28xx_isocdbg("packet bigger than packet size");
344 continue;
345 }
346
347 p = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
ad0ebb96
MCC		 348
349 /* FIXME: incomplete buffer checks where removed to make
350 logic simpler. Impacts of those changes should be evaluated
351 */
d7aa8020
AT		 352 if (p[0] == 0x22 && p[1] == 0x5a) {
353 /* FIXME - are the fields the right way around? */
354 em28xx_isocdbg("Video frame, length=%i, %s\n", len,
355 (p[2] & 1)? "top" : "bottom");
356 em28xx_isocdbg("Current buffer is: outp = 0x%p, len = %i\n", outp, (int)buf->vb.size);
357
358 if (p[2] & 1) {
359 if (buf->receiving) {
360 buffer_filled (dev, dma_q, buf);
361 rc=get_next_buf (dma_q, &buf);
362 if (rc<=0)
363 return rc;
364
365 outp = videobuf_to_vmalloc (&buf->vb);
366 }
ad0ebb96 367
d7aa8020 368 buf->top_field = 1;
ad0ebb96 369 } else {
d7aa8020 370 buf->top_field = 0;
ad0ebb96 371 }
d7aa8020 372 buf->receiving = 1;
ad0ebb96 373 dma_q->pos = 0;
d7aa8020
AT		 374 } else if (p[0]==0x33 && p[1]==0x95 && p[2]==0x00) {
375 em28xx_isocdbg("VBI HEADER!!!\n");
ad0ebb96
MCC		 376 }
377
d7aa8020 378 em28xx_copy_video(dev, dma_q, buf, p, outp, len);
ad0ebb96
MCC		 379
380 /* FIXME: Should add vbi copy */
381 }
382 return rc;
383}
384
385/* ------------------------------------------------------------------
386 URB control
387 ------------------------------------------------------------------*/
388
389/*
390 * IRQ callback, called by URB callback
391 */
392static void em28xx_irq_callback(struct urb *urb)
393{
ad0ebb96
MCC		 394 struct em28xx_dmaqueue *dma_q = urb->context;
395 struct em28xx *dev = container_of(dma_q, struct em28xx, vidq);
396 int rc,i;
397 unsigned long flags;
398
399 spin_lock_irqsave(&dev->slock,flags);
400
ad0ebb96 401 /* Copy data from URB */
d7aa8020 402 rc=em28xx_isoc_copy(urb);
ad0ebb96 403
ad0ebb96
MCC		 404 /* Reset urb buffers */
405 for (i = 0; i < urb->number_of_packets; i++) {
406 urb->iso_frame_desc[i].status = 0;
407 urb->iso_frame_desc[i].actual_length = 0;
408 }
409 urb->status = 0;
410
411 if ((urb->status = usb_submit_urb(urb, GFP_ATOMIC))) {
412 em28xx_err("urb resubmit failed (error=%i)\n",
413 urb->status);
414 }
415
d7aa8020
AT		 416#if 0 /* Bad idea. There are problems that cause a load of valid, but
417 empty, data packets. Don't reset the timeout unless we've actually
418 got a frame. I've had xawtv hang in free_buffer due to this! */
ad0ebb96
MCC		 419 if (rc >= 0)
420 mod_timer(&dma_q->timeout, jiffies+BUFFER_TIMEOUT);
d7aa8020 421#endif
ad0ebb96
MCC		 422 spin_unlock_irqrestore(&dev->slock,flags);
423}
424
425/*
426 * Stop and Deallocate URBs
427 */
428static void em28xx_uninit_isoc(struct em28xx *dev)
429{
430 struct urb *urb;
431 int i;
432
d7aa8020
AT		 433 em28xx_isocdbg("em28xx: called em28xx_uninit_isoc\n");
434
ad0ebb96
MCC		 435 dev->isoc_ctl.nfields=-1;
436 dev->isoc_ctl.buf=NULL;
437 for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
438 urb=dev->isoc_ctl.urb[i];
439 if (urb) {
440 usb_kill_urb(urb);
441 usb_unlink_urb(urb);
442 if (dev->isoc_ctl.transfer_buffer[i]) {
443 usb_buffer_free(dev->udev,
444 urb->transfer_buffer_length,
445 dev->isoc_ctl.transfer_buffer[i],
446 urb->transfer_dma);
447 }
448 usb_free_urb(urb);
449 dev->isoc_ctl.urb[i] = NULL;
450 }
451 dev->isoc_ctl.transfer_buffer[i] = NULL;
452 }
453
454 kfree (dev->isoc_ctl.urb);
455 kfree (dev->isoc_ctl.transfer_buffer);
456 dev->isoc_ctl.urb=NULL;
457 dev->isoc_ctl.transfer_buffer=NULL;
458
459 dev->isoc_ctl.num_bufs=0;
460
d7aa8020 461 // em28xx_capture_start(dev, 0); - FIXME - how could I restart it?
ad0ebb96
MCC		 462}
463
ad0ebb96
MCC		 464
465/*
466 * Allocate URBs and start IRQ
467 */
468static int em28xx_prepare_isoc(struct em28xx *dev, int max_packets,
469 int num_bufs)
470{
471 struct em28xx_dmaqueue *dma_q = &dev->vidq;
472 int i;
473 int sb_size, pipe;
474 struct urb *urb;
475 int j, k;
476
d7aa8020
AT		 477 em28xx_isocdbg("em28xx: called em28xx_prepare_isoc\n");
478
ad0ebb96
MCC		 479 /* De-allocates all pending stuff */
480 em28xx_uninit_isoc(dev);
481
482 dev->isoc_ctl.num_bufs = num_bufs;
483
d7aa8020 484 dev->isoc_ctl.urb = kzalloc(sizeof(void *)*num_bufs, GFP_KERNEL);
ad0ebb96
MCC		 485 if (!dev->isoc_ctl.urb) {
486 em28xx_errdev("cannot alloc memory for usb buffers\n");
487 return -ENOMEM;
488 }
489
d7aa8020 490 dev->isoc_ctl.transfer_buffer = kzalloc(sizeof(void *)*num_bufs,
ad0ebb96
MCC		 491 GFP_KERNEL);
492 if (!dev->isoc_ctl.urb) {
493 em28xx_errdev("cannot allocate memory for usbtransfer\n");
494 kfree(dev->isoc_ctl.urb);
495 return -ENOMEM;
496 }
497
498 dev->isoc_ctl.max_pkt_size = dev->max_pkt_size;
499
500 sb_size = max_packets * dev->isoc_ctl.max_pkt_size;
501
502 /* allocate urbs and transfer buffers */
503 for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
504 urb = usb_alloc_urb(max_packets, GFP_KERNEL);
505 if (!urb) {
506 em28xx_err("cannot alloc isoc_ctl.urb %i\n", i);
507 em28xx_uninit_isoc(dev);
ad0ebb96
MCC		 508 return -ENOMEM;
509 }
510 dev->isoc_ctl.urb[i] = urb;
511
512 dev->isoc_ctl.transfer_buffer[i] = usb_buffer_alloc(dev->udev,
513 sb_size, GFP_KERNEL, &urb->transfer_dma);
514 if (!dev->isoc_ctl.transfer_buffer[i]) {
515 em28xx_err ("unable to allocate %i bytes for transfer"
516 " buffer %i%s\n",
517 sb_size, i,
518 in_interrupt()?" while in int":"");
519 em28xx_uninit_isoc(dev);
520 return -ENOMEM;
521 }
522 memset(dev->isoc_ctl.transfer_buffer[i], 0, sb_size);
523
524 /* FIXME: this is a hack - should be
525 'desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK'
526 should also be using 'desc.bInterval'
527 */
528 pipe=usb_rcvisocpipe(dev->udev, 0x82);
529 usb_fill_int_urb(urb, dev->udev, pipe,
530 dev->isoc_ctl.transfer_buffer[i], sb_size,
531 em28xx_irq_callback, dma_q, 1);
532
533 urb->number_of_packets = max_packets;
534 urb->transfer_flags = URB_ISO_ASAP;
535
536 k = 0;
537 for (j = 0; j < max_packets; j++) {
538 urb->iso_frame_desc[j].offset = k;
539 urb->iso_frame_desc[j].length =
540 dev->isoc_ctl.max_pkt_size;
541 k += dev->isoc_ctl.max_pkt_size;
542 }
543 }
544
545 return 0;
546}
547
d7aa8020 548static int em28xx_start_thread( struct em28xx_dmaqueue *dma_q)
ad0ebb96
MCC		 549{
550 struct em28xx *dev = container_of(dma_q, struct em28xx, vidq);
d7aa8020 551 int i,rc = 0;
ad0ebb96 552
d7aa8020 553 em28xx_videodbg("Called em28xx_start_thread\n");
ad0ebb96 554
d7aa8020 555 init_waitqueue_head(&dma_q->wq);
ad0ebb96
MCC		 556
557 /* submit urbs and enables IRQ */
558 for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
559 rc = usb_submit_urb(dev->isoc_ctl.urb[i], GFP_ATOMIC);
560 if (rc) {
561 em28xx_err("submit of urb %i failed (error=%i)\n", i,
562 rc);
563 em28xx_uninit_isoc(dev);
564 return rc;
565 }
566 }
567
568 if (rc<0)
569 return rc;
570
571 return 0;
572}
573
ad0ebb96
MCC		 574
575static void em28xx_vid_timeout(unsigned long data)
576{
577 struct em28xx *dev = (struct em28xx*)data;
578 struct em28xx_dmaqueue *vidq = &dev->vidq;
579 struct em28xx_buffer *buf;
580 unsigned long flags;
581
582 spin_lock_irqsave(&dev->slock,flags);
583 while (!list_empty(&vidq->active)) {
584 buf = list_entry(vidq->active.next, struct em28xx_buffer,
585 vb.queue);
586 list_del(&buf->vb.queue);
587 buf->vb.state = VIDEOBUF_ERROR;
588 wake_up(&buf->vb.done);
589 em28xx_videodbg("em28xx/0: [%p/%d] timeout\n",
590 buf, buf->vb.i);
591 }
592
d7aa8020 593 /* restart_video_queue(vidq); */
ad0ebb96
MCC		 594 spin_unlock_irqrestore(&dev->slock,flags);
595}
596
597/* ------------------------------------------------------------------
598 Videobuf operations
599 ------------------------------------------------------------------*/
600
601static int
602buffer_setup(struct videobuf_queue *vq, unsigned int *count, unsigned int *size)
603{
604 struct em28xx_fh *fh = vq->priv_data;
605
d7aa8020 606 *size = 16 * fh->dev->width * fh->dev->height >> 3;
ad0ebb96
MCC		 607 if (0 == *count)
608 *count = EM28XX_DEF_BUF;
609
610 if (*count < EM28XX_MIN_BUF) {
611 *count=EM28XX_MIN_BUF;
612 }
613
614 return 0;
615}
616
617static void free_buffer(struct videobuf_queue *vq, struct em28xx_buffer *buf)
618{
619 if (in_interrupt())
620 BUG();
621
622 videobuf_waiton(&buf->vb, 0, 0);
623 videobuf_vmalloc_free(&buf->vb);
624 buf->vb.state = VIDEOBUF_NEEDS_INIT;
625}
626
627static int
628buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
629 enum v4l2_field field)
630{
631 struct em28xx_fh *fh = vq->priv_data;
632 struct em28xx_buffer *buf = container_of(vb,struct em28xx_buffer,vb);
633 struct em28xx *dev = fh->dev;
d7aa8020 634 struct em28xx_dmaqueue *vidq = &dev->vidq;
ad0ebb96 635 int rc = 0, urb_init = 0;
ad0ebb96 636
d7aa8020 637 /* BUG_ON(NULL == fh->fmt); */
ad0ebb96
MCC		 638
639 /* FIXME: It assumes depth = 16 */
640 /* The only currently supported format is 16 bits/pixel */
d7aa8020 641 buf->vb.size = 16 * dev->width * dev->height >> 3;
ad0ebb96
MCC		 642
643 if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size)
644 return -EINVAL;
645
646 if (buf->fmt != fh->fmt ||
d7aa8020
AT		 647 buf->vb.width != dev->width ||
648 buf->vb.height != dev->height ||
ad0ebb96
MCC		 649 buf->vb.field != field) {
650 buf->fmt = fh->fmt;
d7aa8020
AT		 651 buf->vb.width = dev->width;
652 buf->vb.height = dev->height;
ad0ebb96
MCC		 653 buf->vb.field = field;
654 buf->vb.state = VIDEOBUF_NEEDS_INIT;
655 }
656
657 if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
d7aa8020
AT		 658 rc = videobuf_iolock(vq, &buf->vb, NULL);
659 if (rc < 0)
ad0ebb96 660 goto fail;
ad0ebb96
MCC		 661 }
662
ad0ebb96
MCC		 663 if (!dev->isoc_ctl.num_bufs)
664 urb_init=1;
665
666 if (urb_init) {
d7aa8020
AT		 667 rc = em28xx_prepare_isoc(dev, EM28XX_NUM_PACKETS, EM28XX_NUM_BUFS);
668 if (rc<0)
669 goto fail;
670
671 /* FIXME - should probably be done in response to STREAMON */
672 rc = em28xx_start_thread(vidq);
ad0ebb96
MCC		 673 if (rc<0)
674 goto fail;
675 }
676
677 buf->vb.state = VIDEOBUF_PREPARED;
678 return 0;
679
680fail:
681 free_buffer(vq,buf);
682 return rc;
683}
684
685static void
686buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
687{
688 struct em28xx_buffer *buf = container_of(vb, struct em28xx_buffer, vb);
689 struct em28xx_fh *fh = vq->priv_data;
690 struct em28xx *dev = fh->dev;
691 struct em28xx_dmaqueue *vidq = &dev->vidq;
ad0ebb96 692
d7aa8020
AT		 693 buf->vb.state = VIDEOBUF_QUEUED;
694 list_add_tail(&buf->vb.queue, &vidq->active);
695
ad0ebb96
MCC		 696}
697
698static void buffer_release(struct videobuf_queue *vq, struct videobuf_buffer *vb)
699{
700 struct em28xx_buffer *buf = container_of(vb,struct em28xx_buffer,vb);
701 struct em28xx_fh *fh = vq->priv_data;
702 struct em28xx *dev = (struct em28xx*)fh->dev;
ad0ebb96 703
d7aa8020 704 em28xx_isocdbg("em28xx: called buffer_release\n");
ad0ebb96
MCC		 705
706 free_buffer(vq,buf);
707}
708
709static struct videobuf_queue_ops em28xx_video_qops = {
710 .buf_setup = buffer_setup,
711 .buf_prepare = buffer_prepare,
712 .buf_queue = buffer_queue,
713 .buf_release = buffer_release,
714};
a6c2ba28
AM		 715
716/********************* v4l2 interface ******************************************/
717
a6c2ba28 718/*
3acf2809 719 * em28xx_config()
a6c2ba28
AM		 720 * inits registers with sane defaults
721 */
3acf2809 722static int em28xx_config(struct em28xx *dev)
a6c2ba28
AM		 723{
724
725 /* Sets I2C speed to 100 KHz */
2b2c93ac
SS		 726 if (!dev->is_em2800)
727 em28xx_write_regs_req(dev, 0x00, 0x06, "\x40", 1);
a6c2ba28
AM		 728
729 /* enable vbi capturing */
e5589bef 730
9475fb1c
MR		 731/* em28xx_write_regs_req(dev,0x00,0x0e,"\xC0",1); audio register */
732/* em28xx_write_regs_req(dev,0x00,0x0f,"\x80",1); clk register */
e5589bef
MCC		 733 em28xx_write_regs_req(dev,0x00,0x11,"\x51",1);
734
a6c2ba28
AM		 735 dev->mute = 1; /* maybe not the right place... */
736 dev->volume = 0x1f;
539c96d0 737
3acf2809
MCC		 738 em28xx_outfmt_set_yuv422(dev);
739 em28xx_colorlevels_set_default(dev);
740 em28xx_compression_disable(dev);
a6c2ba28
AM		 741
742 return 0;
743}
744
745/*
3acf2809 746 * em28xx_config_i2c()
a6c2ba28
AM		 747 * configure i2c attached devices
748 */
943a4902 749static void em28xx_config_i2c(struct em28xx *dev)
a6c2ba28 750{
c7c0b34c
HV		 751 struct v4l2_routing route;
752
753 route.input = INPUT(dev->ctl_input)->vmux;
754 route.output = 0;
663d1ba2 755 em28xx_i2c_call_clients(dev, VIDIOC_INT_RESET, NULL);
c7c0b34c 756 em28xx_i2c_call_clients(dev, VIDIOC_INT_S_VIDEO_ROUTING, &route);
f5762e44 757 em28xx_i2c_call_clients(dev, VIDIOC_STREAMON, NULL);
a6c2ba28
AM		 758}
759
eac94356
MCC		 760static void video_mux(struct em28xx *dev, int index)
761{
c7c0b34c 762 struct v4l2_routing route;
eac94356 763
c7c0b34c
HV		 764 route.input = INPUT(index)->vmux;
765 route.output = 0;
eac94356
MCC		 766 dev->ctl_input = index;
767 dev->ctl_ainput = INPUT(index)->amux;
768
c7c0b34c 769 em28xx_i2c_call_clients(dev, VIDIOC_INT_S_VIDEO_ROUTING, &route);
eac94356 770
eac94356 771 if (dev->has_msp34xx) {
9bb13a6d
MCC		 772 if (dev->i2s_speed)
773 em28xx_i2c_call_clients(dev, VIDIOC_INT_I2S_CLOCK_FREQ, &dev->i2s_speed);
2474ed44 774 route.input = dev->ctl_ainput;
07151724 775 route.output = MSP_OUTPUT(MSP_SC_IN_DSP_SCART1);
2474ed44
HV		 776 /* Note: this is msp3400 specific */
777 em28xx_i2c_call_clients(dev, VIDIOC_INT_S_AUDIO_ROUTING, &route);
eac94356 778 }
539c96d0 779
00b8730f 780 em28xx_audio_analog_set(dev);
eac94356
MCC		 781}
782
a225452e
MCC		 783/* Usage lock check functions */
784static int res_get(struct em28xx_fh *fh)
785{
786 struct em28xx *dev = fh->dev;
787 int rc = 0;
788
789 /* This instance already has stream_on */
790 if (fh->stream_on)
791 return rc;
792
793 mutex_lock(&dev->lock);
794
795 if (dev->stream_on)
796 rc = -EINVAL;
797 else {
798 dev->stream_on = 1;
799 fh->stream_on = 1;
800 }
801
802 mutex_unlock(&dev->lock);
803 return rc;
804}
805
806static int res_check(struct em28xx_fh *fh)
807{
808 return (fh->stream_on);
809}
810
811static void res_free(struct em28xx_fh *fh)
812{
813 struct em28xx *dev = fh->dev;
814
815 mutex_lock(&dev->lock);
816 fh->stream_on = 0;
817 dev->stream_on = 0;
818 mutex_unlock(&dev->lock);
819}
820
195a4ef6
MCC		 821/*
822 * em28xx_get_ctrl()
823 * return the current saturation, brightness or contrast, mute state
824 */
825static int em28xx_get_ctrl(struct em28xx *dev, struct v4l2_control *ctrl)
826{
827 switch (ctrl->id) {
828 case V4L2_CID_AUDIO_MUTE:
829 ctrl->value = dev->mute;
830 return 0;
831 case V4L2_CID_AUDIO_VOLUME:
832 ctrl->value = dev->volume;
833 return 0;
834 default:
835 return -EINVAL;
a6c2ba28 836 }
195a4ef6 837}
a6c2ba28 838
195a4ef6
MCC		 839/*
840 * em28xx_set_ctrl()
841 * mute or set new saturation, brightness or contrast
842 */
843static int em28xx_set_ctrl(struct em28xx *dev, const struct v4l2_control *ctrl)
844{
845 switch (ctrl->id) {
846 case V4L2_CID_AUDIO_MUTE:
847 if (ctrl->value != dev->mute) {
848 dev->mute = ctrl->value;
195a4ef6
MCC		 849 return em28xx_audio_analog_set(dev);
850 }
851 return 0;
852 case V4L2_CID_AUDIO_VOLUME:
853 dev->volume = ctrl->value;
854 return em28xx_audio_analog_set(dev);
855 default:
856 return -EINVAL;
857 }
858}
a6c2ba28 859
195a4ef6
MCC		 860static int check_dev(struct em28xx *dev)
861{
862 if (dev->state & DEV_DISCONNECTED) {
863 em28xx_errdev("v4l2 ioctl: device not present\n");
864 return -ENODEV;
e5589bef 865 }
a6c2ba28 866
195a4ef6
MCC		 867 if (dev->state & DEV_MISCONFIGURED) {
868 em28xx_errdev("v4l2 ioctl: device is misconfigured; "
869 "close and open it again\n");
870 return -EIO;
871 }
872 return 0;
873}
a6c2ba28 874
195a4ef6
MCC		 875static void get_scale(struct em28xx *dev,
876 unsigned int width, unsigned int height,
877 unsigned int *hscale, unsigned int *vscale)
878{
879 unsigned int maxw = norm_maxw(dev);
880 unsigned int maxh = norm_maxh(dev);
881
882 *hscale = (((unsigned long)maxw) << 12) / width - 4096L;
883 if (*hscale >= 0x4000)
884 *hscale = 0x3fff;
885
886 *vscale = (((unsigned long)maxh) << 12) / height - 4096L;
887 if (*vscale >= 0x4000)
888 *vscale = 0x3fff;
a6c2ba28
AM		 889}
890
195a4ef6
MCC		 891/* ------------------------------------------------------------------
892 IOCTL vidioc handling
893 ------------------------------------------------------------------*/
894
895static int vidioc_g_fmt_cap(struct file *file, void *priv,
896 struct v4l2_format *f)
a6c2ba28 897{
195a4ef6
MCC		 898 struct em28xx_fh *fh = priv;
899 struct em28xx *dev = fh->dev;
a6c2ba28 900
195a4ef6 901 mutex_lock(&dev->lock);
e5589bef 902
195a4ef6
MCC		 903 f->fmt.pix.width = dev->width;
904 f->fmt.pix.height = dev->height;
905 f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
906 f->fmt.pix.bytesperline = dev->bytesperline;
907 f->fmt.pix.sizeimage = dev->frame_size;
908 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
e5589bef 909
195a4ef6
MCC		 910 /* FIXME: TOP? NONE? BOTTOM? ALTENATE? */
911 f->fmt.pix.field = dev->interlaced ?
912 V4L2_FIELD_INTERLACED : V4L2_FIELD_TOP;
e5589bef 913
195a4ef6
MCC		 914 mutex_unlock(&dev->lock);
915 return 0;
a6c2ba28
AM		 916}
917
195a4ef6
MCC		 918static int vidioc_try_fmt_cap(struct file *file, void *priv,
919 struct v4l2_format *f)
a6c2ba28 920{
195a4ef6
MCC		 921 struct em28xx_fh *fh = priv;
922 struct em28xx *dev = fh->dev;
923 int width = f->fmt.pix.width;
924 int height = f->fmt.pix.height;
925 unsigned int maxw = norm_maxw(dev);
926 unsigned int maxh = norm_maxh(dev);
927 unsigned int hscale, vscale;
928
929 /* width must even because of the YUYV format
930 height must be even because of interlacing */
931 height &= 0xfffe;
932 width &= 0xfffe;
a6c2ba28 933
195a4ef6
MCC		 934 if (height < 32)
935 height = 32;
936 if (height > maxh)
937 height = maxh;
938 if (width < 48)
939 width = 48;
940 if (width > maxw)
941 width = maxw;
a6c2ba28 942
195a4ef6 943 mutex_lock(&dev->lock);
a225452e 944
195a4ef6
MCC		 945 if (dev->is_em2800) {
946 /* the em2800 can only scale down to 50% */
947 if (height % (maxh / 2))
948 height = maxh;
949 if (width % (maxw / 2))
950 width = maxw;
951 /* according to empiatech support */
952 /* the MaxPacketSize is to small to support */
953 /* framesizes larger than 640x480 @ 30 fps */
954 /* or 640x576 @ 25 fps. As this would cut */
955 /* of a part of the image we prefer */
956 /* 360x576 or 360x480 for now */
957 if (width == maxw && height == maxh)
958 width /= 2;
959 }
a225452e 960
195a4ef6 961 get_scale(dev, width, height, &hscale, &vscale);
a6c2ba28 962
195a4ef6
MCC		 963 width = (((unsigned long)maxw) << 12) / (hscale + 4096L);
964 height = (((unsigned long)maxh) << 12) / (vscale + 4096L);
a6c2ba28 965
195a4ef6
MCC		 966 f->fmt.pix.width = width;
967 f->fmt.pix.height = height;
968 f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
969 f->fmt.pix.bytesperline = width * 2;
970 f->fmt.pix.sizeimage = width * 2 * height;
971 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
972 f->fmt.pix.field = V4L2_FIELD_INTERLACED;
a6c2ba28 973
3593cab5 974 mutex_unlock(&dev->lock);
a6c2ba28
AM		 975 return 0;
976}
977
195a4ef6
MCC		 978static int vidioc_s_fmt_cap(struct file *file, void *priv,
979 struct v4l2_format *f)
a6c2ba28 980{
195a4ef6
MCC		 981 struct em28xx_fh *fh = priv;
982 struct em28xx *dev = fh->dev;
ad0ebb96 983 int rc;
a6c2ba28 984
195a4ef6
MCC		 985 rc = check_dev(dev);
986 if (rc < 0)
987 return rc;
a225452e 988
195a4ef6 989 vidioc_try_fmt_cap(file, priv, f);
a225452e 990
5a80415b
SS		 991 mutex_lock(&dev->lock);
992
195a4ef6
MCC		 993 /* set new image size */
994 dev->width = f->fmt.pix.width;
995 dev->height = f->fmt.pix.height;
996 dev->frame_size = dev->width * dev->height * 2;
997 dev->field_size = dev->frame_size >> 1;
998 dev->bytesperline = dev->width * 2;
999 get_scale(dev, dev->width, dev->height, &dev->hscale, &dev->vscale);
a6c2ba28 1000
195a4ef6 1001 em28xx_set_alternate(dev);
d7aa8020 1002 em28xx_capture_start(dev, 1); /* ??? */
195a4ef6 1003 em28xx_resolution_set(dev);
195a4ef6 1004
195a4ef6 1005 mutex_unlock(&dev->lock);
ad0ebb96 1006 return 0;
195a4ef6
MCC		 1007}
1008
1009static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *norm)
1010{
1011 struct em28xx_fh *fh = priv;
1012 struct em28xx *dev = fh->dev;
1013 struct v4l2_format f;
195a4ef6
MCC		 1014 int rc;
1015
1016 rc = check_dev(dev);
1017 if (rc < 0)
1018 return rc;
1019
195a4ef6 1020 mutex_lock(&dev->lock);
7d497f8a 1021 dev->norm = *norm;
195a4ef6 1022 mutex_unlock(&dev->lock);
a6c2ba28 1023
195a4ef6
MCC		 1024 /* Adjusts width/height, if needed */
1025 f.fmt.pix.width = dev->width;
1026 f.fmt.pix.height = dev->height;
1027 vidioc_try_fmt_cap(file, priv, &f);
a6c2ba28 1028
195a4ef6 1029 mutex_lock(&dev->lock);
a6c2ba28 1030
195a4ef6
MCC		 1031 /* set new image size */
1032 dev->width = f.fmt.pix.width;
1033 dev->height = f.fmt.pix.height;
1034 dev->frame_size = dev->width * dev->height * 2;
1035 dev->field_size = dev->frame_size >> 1;
1036 dev->bytesperline = dev->width * 2;
1037 get_scale(dev, dev->width, dev->height, &dev->hscale, &dev->vscale);
a6c2ba28 1038
195a4ef6 1039 em28xx_resolution_set(dev);
7d497f8a 1040 em28xx_i2c_call_clients(dev, VIDIOC_S_STD, &dev->norm);
a6c2ba28 1041
195a4ef6
MCC		 1042 mutex_unlock(&dev->lock);
1043 return 0;
1044}
9e31ced8 1045
195a4ef6
MCC		 1046static const char *iname[] = {
1047 [EM28XX_VMUX_COMPOSITE1] = "Composite1",
1048 [EM28XX_VMUX_COMPOSITE2] = "Composite2",
1049 [EM28XX_VMUX_COMPOSITE3] = "Composite3",
1050 [EM28XX_VMUX_COMPOSITE4] = "Composite4",
1051 [EM28XX_VMUX_SVIDEO] = "S-Video",
1052 [EM28XX_VMUX_TELEVISION] = "Television",
1053 [EM28XX_VMUX_CABLE] = "Cable TV",
1054 [EM28XX_VMUX_DVB] = "DVB",
1055 [EM28XX_VMUX_DEBUG] = "for debug only",
1056};
9e31ced8 1057
195a4ef6
MCC		 1058static int vidioc_enum_input(struct file *file, void *priv,
1059 struct v4l2_input *i)
1060{
1061 struct em28xx_fh *fh = priv;
1062 struct em28xx *dev = fh->dev;
1063 unsigned int n;
9e31ced8 1064
195a4ef6
MCC		 1065 n = i->index;
1066 if (n >= MAX_EM28XX_INPUT)
1067 return -EINVAL;
1068 if (0 == INPUT(n)->type)
1069 return -EINVAL;
9e31ced8 1070
195a4ef6
MCC		 1071 i->index = n;
1072 i->type = V4L2_INPUT_TYPE_CAMERA;
a6c2ba28 1073
195a4ef6 1074 strcpy(i->name, iname[INPUT(n)->type]);
a6c2ba28 1075
195a4ef6
MCC		 1076 if ((EM28XX_VMUX_TELEVISION == INPUT(n)->type) ||
1077 (EM28XX_VMUX_CABLE == INPUT(n)->type))
1078 i->type = V4L2_INPUT_TYPE_TUNER;
1079
7d497f8a 1080 i->std = dev->vdev->tvnorms;
195a4ef6
MCC		 1081
1082 return 0;
a6c2ba28
AM		 1083}
1084
195a4ef6 1085static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
a6c2ba28 1086{
195a4ef6
MCC		 1087 struct em28xx_fh *fh = priv;
1088 struct em28xx *dev = fh->dev;
a6c2ba28 1089
195a4ef6
MCC		 1090 *i = dev->ctl_input;
1091
1092 return 0;
1093}
1094
1095static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1096{
1097 struct em28xx_fh *fh = priv;
1098 struct em28xx *dev = fh->dev;
1099 int rc;
1100
1101 rc = check_dev(dev);
1102 if (rc < 0)
1103 return rc;
1104
1105 if (i >= MAX_EM28XX_INPUT)
1106 return -EINVAL;
1107 if (0 == INPUT(i)->type)
1108 return -EINVAL;
a225452e 1109
5a80415b 1110 mutex_lock(&dev->lock);
a6c2ba28 1111
195a4ef6
MCC		 1112 video_mux(dev, i);
1113
1114 mutex_unlock(&dev->lock);
1115 return 0;
1116}
1117
1118static int vidioc_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
1119{
1120 struct em28xx_fh *fh = priv;
1121 struct em28xx *dev = fh->dev;
1122 unsigned int index = a->index;
1123
1124 if (a->index > 1)
1125 return -EINVAL;
1126
1127 index = dev->ctl_ainput;
1128
1129 if (index == 0) {
1130 strcpy(a->name, "Television");
a6c2ba28 1131 } else {
195a4ef6
MCC		 1132 strcpy(a->name, "Line In");
1133 }
1134 a->capability = V4L2_AUDCAP_STEREO;
1135 a->index = index;
1136
1137 return 0;
1138}
1139
1140static int vidioc_s_audio(struct file *file, void *priv, struct v4l2_audio *a)
1141{
1142 struct em28xx_fh *fh = priv;
1143 struct em28xx *dev = fh->dev;
1144
1145 if (a->index != dev->ctl_ainput)
1146 return -EINVAL;
1147
1148 return 0;
1149}
1150
1151static int vidioc_queryctrl(struct file *file, void *priv,
1152 struct v4l2_queryctrl *qc)
1153{
1154 struct em28xx_fh *fh = priv;
1155 struct em28xx *dev = fh->dev;
1156 int id = qc->id;
1157 int i;
1158 int rc;
1159
1160 rc = check_dev(dev);
1161 if (rc < 0)
1162 return rc;
1163
1164 memset(qc, 0, sizeof(*qc));
1165
1166 qc->id = id;
1167
1168 if (!dev->has_msp34xx) {
1169 for (i = 0; i < ARRAY_SIZE(em28xx_qctrl); i++) {
1170 if (qc->id && qc->id == em28xx_qctrl[i].id) {
1171 memcpy(qc, &(em28xx_qctrl[i]), sizeof(*qc));
1172 return 0;
a6c2ba28
AM		 1173 }
1174 }
195a4ef6
MCC		 1175 }
1176 mutex_lock(&dev->lock);
1177 em28xx_i2c_call_clients(dev, VIDIOC_QUERYCTRL, qc);
1178 mutex_unlock(&dev->lock);
a6c2ba28 1179
195a4ef6
MCC		 1180 if (qc->type)
1181 return 0;
1182 else
1183 return -EINVAL;
1184}
a6c2ba28 1185
195a4ef6
MCC		 1186static int vidioc_g_ctrl(struct file *file, void *priv,
1187 struct v4l2_control *ctrl)
1188{
1189 struct em28xx_fh *fh = priv;
1190 struct em28xx *dev = fh->dev;
1191 int rc;
a6c2ba28 1192
195a4ef6
MCC		 1193 rc = check_dev(dev);
1194 if (rc < 0)
1195 return rc;
1196 mutex_lock(&dev->lock);
a6c2ba28 1197
195a4ef6
MCC		 1198 if (!dev->has_msp34xx)
1199 rc = em28xx_get_ctrl(dev, ctrl);
1200 else
1201 rc = -EINVAL;
1202
1203 if (rc == -EINVAL) {
1204 em28xx_i2c_call_clients(dev, VIDIOC_G_CTRL, ctrl);
1205 rc = 0;
1206 }
1207
1208 mutex_unlock(&dev->lock);
1209 return rc;
1210}
1211
1212static int vidioc_s_ctrl(struct file *file, void *priv,
1213 struct v4l2_control *ctrl)
1214{
1215 struct em28xx_fh *fh = priv;
1216 struct em28xx *dev = fh->dev;
1217 u8 i;
1218 int rc;
1219
1220 rc = check_dev(dev);
1221 if (rc < 0)
1222 return rc;
1223
1224 mutex_lock(&dev->lock);
1225
1226 if (dev->has_msp34xx)
1227 em28xx_i2c_call_clients(dev, VIDIOC_S_CTRL, ctrl);
1228 else {
1229 rc = 1;
1230 for (i = 0; i < ARRAY_SIZE(em28xx_qctrl); i++) {
1231 if (ctrl->id == em28xx_qctrl[i].id) {
1232 if (ctrl->value < em28xx_qctrl[i].minimum ||
1233 ctrl->value > em28xx_qctrl[i].maximum) {
1234 rc = -ERANGE;
1235 break;
1236 }
1237
1238 rc = em28xx_set_ctrl(dev, ctrl);
1239 break;
1240 }
a6c2ba28
AM		 1241 }
1242 }
1243
195a4ef6
MCC		 1244 /* Control not found - try to send it to the attached devices */
1245 if (rc == 1) {
1246 em28xx_i2c_call_clients(dev, VIDIOC_S_CTRL, ctrl);
1247 rc = 0;
1248 }
1249
5a80415b 1250 mutex_unlock(&dev->lock);
195a4ef6 1251 return rc;
a6c2ba28
AM		 1252}
1253
195a4ef6
MCC		 1254static int vidioc_g_tuner(struct file *file, void *priv,
1255 struct v4l2_tuner *t)
a6c2ba28 1256{
195a4ef6
MCC		 1257 struct em28xx_fh *fh = priv;
1258 struct em28xx *dev = fh->dev;
1259 int rc;
1260
1261 rc = check_dev(dev);
1262 if (rc < 0)
1263 return rc;
1264
1265 if (0 != t->index)
1266 return -EINVAL;
1267
1268 strcpy(t->name, "Tuner");
1269
1270 mutex_lock(&dev->lock);
1271
1272 em28xx_i2c_call_clients(dev, VIDIOC_G_TUNER, t);
1273
1274 mutex_unlock(&dev->lock);
1275 return 0;
a6c2ba28
AM		 1276}
1277
195a4ef6
MCC		 1278static int vidioc_s_tuner(struct file *file, void *priv,
1279 struct v4l2_tuner *t)
a6c2ba28 1280{
195a4ef6
MCC		 1281 struct em28xx_fh *fh = priv;
1282 struct em28xx *dev = fh->dev;
1283 int rc;
63337dd3 1284
195a4ef6
MCC		 1285 rc = check_dev(dev);
1286 if (rc < 0)
1287 return rc;
1288
1289 if (0 != t->index)
1290 return -EINVAL;
1291
1292 mutex_lock(&dev->lock);
1293
1294 em28xx_i2c_call_clients(dev, VIDIOC_S_TUNER, t);
1295
1296 mutex_unlock(&dev->lock);
1297 return 0;
a6c2ba28
AM		 1298}
1299
195a4ef6
MCC		 1300static int vidioc_g_frequency(struct file *file, void *priv,
1301 struct v4l2_frequency *f)
1302{
1303 struct em28xx_fh *fh = priv;
1304 struct em28xx *dev = fh->dev;
a6c2ba28 1305
0be43754 1306 f->type = fh->radio ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
195a4ef6
MCC		 1307 f->frequency = dev->ctl_freq;
1308
1309 return 0;
1310}
1311
1312static int vidioc_s_frequency(struct file *file, void *priv,
1313 struct v4l2_frequency *f)
a6c2ba28 1314{
195a4ef6
MCC		 1315 struct em28xx_fh *fh = priv;
1316 struct em28xx *dev = fh->dev;
1317 int rc;
9c75541f 1318
195a4ef6
MCC		 1319 rc = check_dev(dev);
1320 if (rc < 0)
1321 return rc;
1322
1323 if (0 != f->tuner)
1324 return -EINVAL;
1325
0be43754
MCC		 1326 if (unlikely(0 == fh->radio && f->type != V4L2_TUNER_ANALOG_TV))
1327 return -EINVAL;
1328 if (unlikely(1 == fh->radio && f->type != V4L2_TUNER_RADIO))
195a4ef6 1329 return -EINVAL;
a225452e
MCC		 1330
1331 mutex_lock(&dev->lock);
a3a048ce 1332
195a4ef6
MCC		 1333 dev->ctl_freq = f->frequency;
1334 em28xx_i2c_call_clients(dev, VIDIOC_S_FREQUENCY, f);
a6c2ba28 1335
195a4ef6
MCC		 1336 mutex_unlock(&dev->lock);
1337 return 0;
1338}
a6c2ba28 1339
1e7ad56f
MCC		 1340#ifdef CONFIG_VIDEO_ADV_DEBUG
1341static int em28xx_reg_len(int reg)
1342{
1343 switch (reg) {
1344 case AC97LSB_REG:
1345 case HSCALELOW_REG:
1346 case VSCALELOW_REG:
1e7ad56f
MCC		 1347 return 2;
1348 default:
1349 return 1;
1350 }
1351}
1352
1353static int vidioc_g_register(struct file *file, void *priv,
1354 struct v4l2_register *reg)
1355{
1356 struct em28xx_fh *fh = priv;
1357 struct em28xx *dev = fh->dev;
1358 int ret;
1359
1360 if (!v4l2_chip_match_host(reg->match_type, reg->match_chip))
1361 return -EINVAL;
1362
1363 if (em28xx_reg_len(reg->reg) == 1) {
1364 ret = em28xx_read_reg(dev, reg->reg);
1365 if (ret < 0)
1366 return ret;
1367
1368 reg->val = ret;
1369 } else {
0df8130f 1370 u64 val = 0;
1e7ad56f
MCC		 1371 ret = em28xx_read_reg_req_len(dev, USB_REQ_GET_STATUS,
1372 reg->reg, (char *)&val, 2);
1373 if (ret < 0)
1374 return ret;
1375
0df8130f 1376 reg->val = cpu_to_le64((__u64)val);
1e7ad56f
MCC		 1377 }
1378
1379 return 0;
1380}
1381
1382static int vidioc_s_register(struct file *file, void *priv,
1383 struct v4l2_register *reg)
1384{
1385 struct em28xx_fh *fh = priv;
1386 struct em28xx *dev = fh->dev;
0df8130f 1387 u64 buf;
1e7ad56f 1388
0df8130f 1389 buf = le64_to_cpu((__u64)reg->val);
1e7ad56f
MCC		 1390
1391 return em28xx_write_regs(dev, reg->reg, (char *)&buf,
1392 em28xx_reg_len(reg->reg));
1393}
1394#endif
1395
1396
195a4ef6
MCC		 1397static int vidioc_cropcap(struct file *file, void *priv,
1398 struct v4l2_cropcap *cc)
1399{
1400 struct em28xx_fh *fh = priv;
1401 struct em28xx *dev = fh->dev;
1402
1403 if (cc->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
a6c2ba28 1404 return -EINVAL;
a6c2ba28 1405
195a4ef6
MCC		 1406 cc->bounds.left = 0;
1407 cc->bounds.top = 0;
1408 cc->bounds.width = dev->width;
1409 cc->bounds.height = dev->height;
1410 cc->defrect = cc->bounds;
1411 cc->pixelaspect.numerator = 54; /* 4:3 FIXME: remove magic numbers */
1412 cc->pixelaspect.denominator = 59;
1413
1414 return 0;
1415}
1416
1417static int vidioc_streamon(struct file *file, void *priv,
1418 enum v4l2_buf_type type)
1419{
1420 struct em28xx_fh *fh = priv;
1421 struct em28xx *dev = fh->dev;
1422 int rc;
1423
1424 rc = check_dev(dev);
1425 if (rc < 0)
1426 return rc;
1427
195a4ef6 1428
ad0ebb96 1429 if (unlikely(res_get(fh) < 0))
195a4ef6 1430 return -EBUSY;
a6c2ba28 1431
d7aa8020
AT		 1432 /* We can't do this from buffer_queue or anything called from
1433 there, since it's called with IRQs disabled and the spinlock held,
1434 and this uses USB functions that may sleep
1435
1436 FIXME FIXME FIXME - putting this here means it may not always
1437 be called when it needs to be */
1438 em28xx_capture_start(dev, 1);
1439
ad0ebb96 1440 return (videobuf_streamon(&fh->vb_vidq));
195a4ef6
MCC		 1441}
1442
1443static int vidioc_streamoff(struct file *file, void *priv,
1444 enum v4l2_buf_type type)
1445{
1446 struct em28xx_fh *fh = priv;
1447 struct em28xx *dev = fh->dev;
1448 int rc;
1449
1450 rc = check_dev(dev);
1451 if (rc < 0)
1452 return rc;
1453
ad0ebb96
MCC		 1454 if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1455 return -EINVAL;
1456 if (type != fh->type)
195a4ef6
MCC		 1457 return -EINVAL;
1458
ad0ebb96
MCC		 1459 videobuf_streamoff(&fh->vb_vidq);
1460 res_free(fh);
a6c2ba28 1461
a6c2ba28
AM		 1462 return 0;
1463}
1464
195a4ef6
MCC		 1465static int vidioc_querycap(struct file *file, void *priv,
1466 struct v4l2_capability *cap)
a6c2ba28 1467{
195a4ef6
MCC		 1468 struct em28xx_fh *fh = priv;
1469 struct em28xx *dev = fh->dev;
1470
1471 strlcpy(cap->driver, "em28xx", sizeof(cap->driver));
1472 strlcpy(cap->card, em28xx_boards[dev->model].name, sizeof(cap->card));
1473 strlcpy(cap->bus_info, dev->udev->dev.bus_id, sizeof(cap->bus_info));
1474
1475 cap->version = EM28XX_VERSION_CODE;
1476
1477 cap->capabilities =
1478 V4L2_CAP_SLICED_VBI_CAPTURE |
1479 V4L2_CAP_VIDEO_CAPTURE |
1480 V4L2_CAP_AUDIO |
1481 V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
1482
ed086314 1483 if (dev->tuner_type != TUNER_ABSENT)
195a4ef6
MCC		 1484 cap->capabilities |= V4L2_CAP_TUNER;
1485
1486 return 0;
c0477ad9
MCC		 1487}
1488
195a4ef6
MCC		 1489static int vidioc_enum_fmt_cap(struct file *file, void *priv,
1490 struct v4l2_fmtdesc *fmtd)
a6c2ba28 1491{
195a4ef6 1492 if (fmtd->index != 0)
c0477ad9 1493 return -EINVAL;
195a4ef6
MCC		 1494
1495 fmtd->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1496 strcpy(fmtd->description, "Packed YUY2");
1497 fmtd->pixelformat = V4L2_PIX_FMT_YUYV;
1498 memset(fmtd->reserved, 0, sizeof(fmtd->reserved));
1499
1500 return 0;
c0477ad9
MCC		 1501}
1502
195a4ef6
MCC		 1503/* Sliced VBI ioctls */
1504static int vidioc_g_fmt_vbi_capture(struct file *file, void *priv,
1505 struct v4l2_format *f)
a6c2ba28 1506{
195a4ef6
MCC		 1507 struct em28xx_fh *fh = priv;
1508 struct em28xx *dev = fh->dev;
1509 int rc;
a6c2ba28 1510
195a4ef6
MCC		 1511 rc = check_dev(dev);
1512 if (rc < 0)
1513 return rc;
a6c2ba28 1514
195a4ef6
MCC		 1515 mutex_lock(&dev->lock);
1516
1517 f->fmt.sliced.service_set = 0;
1518
1519 em28xx_i2c_call_clients(dev, VIDIOC_G_FMT, f);
1520
1521 if (f->fmt.sliced.service_set == 0)
1522 rc = -EINVAL;
1523
1524 mutex_unlock(&dev->lock);
1525 return rc;
1526}
1527
1528static int vidioc_try_set_vbi_capture(struct file *file, void *priv,
1529 struct v4l2_format *f)
1530{
1531 struct em28xx_fh *fh = priv;
1532 struct em28xx *dev = fh->dev;
1533 int rc;
1534
1535 rc = check_dev(dev);
1536 if (rc < 0)
1537 return rc;
1538
1539 mutex_lock(&dev->lock);
1540 em28xx_i2c_call_clients(dev, VIDIOC_G_FMT, f);
1541 mutex_unlock(&dev->lock);
1542
1543 if (f->fmt.sliced.service_set == 0)
1544 return -EINVAL;
a6c2ba28
AM		 1545
1546 return 0;
1547}
1548
195a4ef6
MCC		 1549
1550static int vidioc_reqbufs(struct file *file, void *priv,
1551 struct v4l2_requestbuffers *rb)
a6c2ba28 1552{
195a4ef6
MCC		 1553 struct em28xx_fh *fh = priv;
1554 struct em28xx *dev = fh->dev;
195a4ef6 1555 int rc;
a6c2ba28 1556
195a4ef6
MCC		 1557 rc = check_dev(dev);
1558 if (rc < 0)
1559 return rc;
a6c2ba28 1560
ad0ebb96 1561 return (videobuf_reqbufs(&fh->vb_vidq, rb));
a6c2ba28
AM		 1562}
1563
195a4ef6
MCC		 1564static int vidioc_querybuf(struct file *file, void *priv,
1565 struct v4l2_buffer *b)
e5589bef 1566{
195a4ef6
MCC		 1567 struct em28xx_fh *fh = priv;
1568 struct em28xx *dev = fh->dev;
1569 int rc;
e5589bef 1570
195a4ef6
MCC		 1571 rc = check_dev(dev);
1572 if (rc < 0)
1573 return rc;
2d50f847 1574
ad0ebb96 1575 return (videobuf_querybuf(&fh->vb_vidq, b));
195a4ef6
MCC		 1576}
1577
1578static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
1579{
1580 struct em28xx_fh *fh = priv;
1581 struct em28xx *dev = fh->dev;
195a4ef6
MCC		 1582 int rc;
1583
1584 rc = check_dev(dev);
1585 if (rc < 0)
1586 return rc;
1587
ad0ebb96 1588 return (videobuf_qbuf(&fh->vb_vidq, b));
e5589bef
MCC		 1589}
1590
195a4ef6 1591static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
2d50f847 1592{
195a4ef6
MCC		 1593 struct em28xx_fh *fh = priv;
1594 struct em28xx *dev = fh->dev;
1595 int rc;
195a4ef6
MCC		 1596
1597 rc = check_dev(dev);
1598 if (rc < 0)
1599 return rc;
2d50f847 1600
ad0ebb96
MCC		 1601 return (videobuf_dqbuf(&fh->vb_vidq, b,
1602 file->f_flags & O_NONBLOCK));
1603}
2d50f847 1604
ad0ebb96
MCC		 1605#ifdef CONFIG_VIDEO_V4L1_COMPAT
1606static int vidiocgmbuf (struct file *file, void *priv, struct video_mbuf *mbuf)
1607{
1608 struct em28xx_fh *fh=priv;
2d50f847 1609
ad0ebb96 1610 return videobuf_cgmbuf (&fh->vb_vidq, mbuf, 8);
195a4ef6 1611}
ad0ebb96
MCC		 1612#endif
1613
2d50f847 1614
0be43754
MCC		 1615/* ----------------------------------------------------------- */
1616/* RADIO ESPECIFIC IOCTLS */
1617/* ----------------------------------------------------------- */
1618
1619static int radio_querycap(struct file *file, void *priv,
1620 struct v4l2_capability *cap)
1621{
1622 struct em28xx *dev = ((struct em28xx_fh *)priv)->dev;
1623
1624 strlcpy(cap->driver, "em28xx", sizeof(cap->driver));
1625 strlcpy(cap->card, em28xx_boards[dev->model].name, sizeof(cap->card));
1626 strlcpy(cap->bus_info, dev->udev->dev.bus_id, sizeof(cap->bus_info));
1627
1628 cap->version = EM28XX_VERSION_CODE;
1629 cap->capabilities = V4L2_CAP_TUNER;
1630 return 0;
1631}
1632
1633static int radio_g_tuner(struct file *file, void *priv,
1634 struct v4l2_tuner *t)
1635{
1636 struct em28xx *dev = ((struct em28xx_fh *)priv)->dev;
1637
1638 if (unlikely(t->index > 0))
1639 return -EINVAL;
1640
1641 strcpy(t->name, "Radio");
1642 t->type = V4L2_TUNER_RADIO;
1643
1644 em28xx_i2c_call_clients(dev, VIDIOC_G_TUNER, t);
1645 return 0;
1646}
1647
1648static int radio_enum_input(struct file *file, void *priv,
1649 struct v4l2_input *i)
1650{
1651 if (i->index != 0)
1652 return -EINVAL;
1653 strcpy(i->name, "Radio");
1654 i->type = V4L2_INPUT_TYPE_TUNER;
1655
1656 return 0;
1657}
1658
1659static int radio_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
1660{
1661 if (unlikely(a->index))
1662 return -EINVAL;
1663
1664 strcpy(a->name, "Radio");
1665 return 0;
1666}
1667
1668static int radio_s_tuner(struct file *file, void *priv,
1669 struct v4l2_tuner *t)
1670{
1671 struct em28xx *dev = ((struct em28xx_fh *)priv)->dev;
1672
1673 if (0 != t->index)
1674 return -EINVAL;
1675
1676 em28xx_i2c_call_clients(dev, VIDIOC_S_TUNER, t);
1677
1678 return 0;
1679}
1680
1681static int radio_s_audio(struct file *file, void *fh,
1682 struct v4l2_audio *a)
1683{
1684 return 0;
1685}
1686
1687static int radio_s_input(struct file *file, void *fh, unsigned int i)
1688{
1689 return 0;
1690}
1691
1692static int radio_queryctrl(struct file *file, void *priv,
1693 struct v4l2_queryctrl *qc)
1694{
1695 int i;
1696
1697 if (qc->id < V4L2_CID_BASE ||
1698 qc->id >= V4L2_CID_LASTP1)
1699 return -EINVAL;
1700
1701 for (i = 0; i < ARRAY_SIZE(em28xx_qctrl); i++) {
1702 if (qc->id && qc->id == em28xx_qctrl[i].id) {
1703 memcpy(qc, &(em28xx_qctrl[i]), sizeof(*qc));
1704 return 0;
1705 }
1706 }
1707
1708 return -EINVAL;
1709}
1710
195a4ef6
MCC		 1711/*
1712 * em28xx_v4l2_open()
1713 * inits the device and starts isoc transfer
1714 */
1715static int em28xx_v4l2_open(struct inode *inode, struct file *filp)
1716{
1717 int minor = iminor(inode);
0be43754 1718 int errCode = 0, radio = 0;
195a4ef6
MCC		 1719 struct em28xx *h,*dev = NULL;
1720 struct em28xx_fh *fh;
d7aa8020 1721 enum v4l2_buf_type fh_type = 0;
2d50f847 1722
195a4ef6
MCC		 1723 list_for_each_entry(h, &em28xx_devlist, devlist) {
1724 if (h->vdev->minor == minor) {
1725 dev = h;
d7aa8020 1726 fh_type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
195a4ef6
MCC		 1727 }
1728 if (h->vbi_dev->minor == minor) {
1729 dev = h;
d7aa8020 1730 fh_type = V4L2_BUF_TYPE_VBI_CAPTURE;
195a4ef6 1731 }
0be43754
MCC		 1732 if (h->radio_dev &&
1733 h->radio_dev->minor == minor) {
1734 radio = 1;
1735 dev = h;
1736 }
2d50f847 1737 }
195a4ef6
MCC		 1738 if (NULL == dev)
1739 return -ENODEV;
2d50f847 1740
195a4ef6 1741 em28xx_videodbg("open minor=%d type=%s users=%d\n",
d7aa8020 1742 minor, v4l2_type_names[fh_type], dev->users);
2d50f847 1743
195a4ef6 1744 fh = kzalloc(sizeof(struct em28xx_fh), GFP_KERNEL);
9aeb4b05 1745
195a4ef6
MCC		 1746 if (!fh) {
1747 em28xx_errdev("em28xx-video.c: Out of memory?!\n");
1748 return -ENOMEM;
1749 }
1750 mutex_lock(&dev->lock);
1751 fh->dev = dev;
0be43754 1752 fh->radio = radio;
d7aa8020 1753 fh->type = fh_type;
195a4ef6 1754 filp->private_data = fh;
9aeb4b05 1755
d7aa8020 1756 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE && dev->users == 0) {
195a4ef6
MCC		 1757 dev->width = norm_maxw(dev);
1758 dev->height = norm_maxh(dev);
1759 dev->frame_size = dev->width * dev->height * 2;
1760 dev->field_size = dev->frame_size >> 1; /*both_fileds ? dev->frame_size>>1 : dev->frame_size; */
1761 dev->bytesperline = dev->width * 2;
1762 dev->hscale = 0;
1763 dev->vscale = 0;
2d50f847 1764
3687e1e6 1765 em28xx_set_alternate(dev);
195a4ef6 1766 em28xx_resolution_set(dev);
2d50f847 1767
2d50f847 1768 }
0be43754
MCC		 1769 if (fh->radio) {
1770 em28xx_videodbg("video_open: setting radio device\n");
1771 em28xx_i2c_call_clients(dev, AUDC_SET_RADIO, NULL);
1772 }
2d50f847 1773
195a4ef6 1774 dev->users++;
2d50f847 1775
ad0ebb96
MCC		 1776 videobuf_queue_vmalloc_init(&fh->vb_vidq, &em28xx_video_qops,
1777 NULL, &dev->slock, fh->type, V4L2_FIELD_INTERLACED,
1778 sizeof(struct em28xx_buffer), fh);
1779
195a4ef6
MCC		 1780 mutex_unlock(&dev->lock);
1781 return errCode;
2d50f847 1782}
e5589bef 1783
a6c2ba28 1784/*
195a4ef6
MCC		 1785 * em28xx_realease_resources()
1786 * unregisters the v4l2,i2c and usb devices
1787 * called when the device gets disconected or at module unload
1788*/
1789static void em28xx_release_resources(struct em28xx *dev)
a6c2ba28 1790{
a6c2ba28 1791
195a4ef6 1792 /*FIXME: I2C IR should be disconnected */
a6c2ba28 1793
195a4ef6
MCC		 1794 em28xx_info("V4L2 devices /dev/video%d and /dev/vbi%d deregistered\n",
1795 dev->vdev->minor-MINOR_VFL_TYPE_GRABBER_MIN,
1796 dev->vbi_dev->minor-MINOR_VFL_TYPE_VBI_MIN);
1797 list_del(&dev->devlist);
0be43754
MCC		 1798 if (dev->radio_dev) {
1799 if (-1 != dev->radio_dev->minor)
1800 video_unregister_device(dev->radio_dev);
1801 else
1802 video_device_release(dev->radio_dev);
1803 dev->radio_dev = NULL;
1804 }
1805 if (dev->vbi_dev) {
1806 if (-1 != dev->vbi_dev->minor)
1807 video_unregister_device(dev->vbi_dev);
1808 else
1809 video_device_release(dev->vbi_dev);
1810 dev->vbi_dev = NULL;
1811 }
1812 if (dev->vdev) {
1813 if (-1 != dev->vdev->minor)
1814 video_unregister_device(dev->vdev);
1815 else
1816 video_device_release(dev->vdev);
1817 dev->vdev = NULL;
1818 }
195a4ef6
MCC		 1819 em28xx_i2c_unregister(dev);
1820 usb_put_dev(dev->udev);
a6c2ba28 1821
195a4ef6
MCC		 1822 /* Mark device as unused */
1823 em28xx_devused&=~(1<<dev->devno);
1824}
a6c2ba28 1825
195a4ef6
MCC		 1826/*
1827 * em28xx_v4l2_close()
1828 * stops streaming and deallocates all resources allocated by the v4l2 calls and ioctls
1829 */
1830static int em28xx_v4l2_close(struct inode *inode, struct file *filp)
1831{
1832 struct em28xx_fh *fh = filp->private_data;
1833 struct em28xx *dev = fh->dev;
1834 int errCode;
a6c2ba28 1835
195a4ef6 1836 em28xx_videodbg("users=%d\n", dev->users);
a6c2ba28 1837
a6c2ba28 1838
195a4ef6
MCC		 1839 if (res_check(fh))
1840 res_free(fh);
a6c2ba28 1841
195a4ef6 1842 mutex_lock(&dev->lock);
a6c2ba28 1843
195a4ef6 1844 if (dev->users == 1) {
ad0ebb96
MCC		 1845 videobuf_stop(&fh->vb_vidq);
1846 videobuf_mmap_free(&fh->vb_vidq);
a6c2ba28 1847
195a4ef6
MCC		 1848 /* the device is already disconnect,
1849 free the remaining resources */
1850 if (dev->state & DEV_DISCONNECTED) {
1851 em28xx_release_resources(dev);
1852 mutex_unlock(&dev->lock);
1853 kfree(dev);
1854 return 0;
1855 }
a6c2ba28 1856
d7aa8020
AT		 1857 /* do this before setting alternate! */
1858 em28xx_uninit_isoc(dev);
1859
195a4ef6
MCC		 1860 /* set alternate 0 */
1861 dev->alt = 0;
1862 em28xx_videodbg("setting alternate 0\n");
1863 errCode = usb_set_interface(dev->udev, 0, 0);
1864 if (errCode < 0) {
1865 em28xx_errdev("cannot change alternate number to "
1866 "0 (error=%i)\n", errCode);
1867 }
9aeb4b05 1868 }
195a4ef6
MCC		 1869 kfree(fh);
1870 dev->users--;
1871 wake_up_interruptible_nr(&dev->open, 1);
1872 mutex_unlock(&dev->lock);
1873 return 0;
1874}
a6c2ba28 1875
195a4ef6
MCC		 1876/*
1877 * em28xx_v4l2_read()
1878 * will allocate buffers when called for the first time
1879 */
1880static ssize_t
1881em28xx_v4l2_read(struct file *filp, char __user * buf, size_t count,
ad0ebb96 1882 loff_t * pos)
195a4ef6 1883{
195a4ef6
MCC		 1884 struct em28xx_fh *fh = filp->private_data;
1885 struct em28xx *dev = fh->dev;
ad0ebb96
MCC		 1886 int rc;
1887
1888 rc = check_dev(dev);
1889 if (rc < 0)
1890 return rc;
a6c2ba28 1891
195a4ef6
MCC		 1892 /* FIXME: read() is not prepared to allow changing the video
1893 resolution while streaming. Seems a bug at em28xx_set_fmt
1894 */
a6c2ba28 1895
ad0ebb96
MCC		 1896 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1897 if (unlikely(res_get(fh)))
1898 return -EBUSY;
195a4ef6 1899
ad0ebb96
MCC		 1900 return videobuf_read_stream(&fh->vb_vidq, buf, count, pos, 0,
1901 filp->f_flags & O_NONBLOCK);
195a4ef6 1902 }
ad0ebb96 1903 return 0;
a6c2ba28
AM		 1904}
1905
1906/*
195a4ef6
MCC		 1907 * em28xx_v4l2_poll()
1908 * will allocate buffers when called for the first time
a6c2ba28 1909 */
195a4ef6 1910static unsigned int em28xx_v4l2_poll(struct file *filp, poll_table * wait)
a6c2ba28 1911{
a3a048ce 1912 struct em28xx_fh *fh = filp->private_data;
195a4ef6 1913 struct em28xx *dev = fh->dev;
ad0ebb96
MCC		 1914 int rc;
1915
1916 rc = check_dev(dev);
1917 if (rc < 0)
1918 return rc;
a6c2ba28 1919
195a4ef6
MCC		 1920 if (unlikely(res_get(fh) < 0))
1921 return POLLERR;
a6c2ba28 1922
ad0ebb96
MCC		 1923 if (V4L2_BUF_TYPE_VIDEO_CAPTURE != fh->type)
1924 return POLLERR;
a6c2ba28 1925
ad0ebb96 1926 return videobuf_poll_stream(filp, &fh->vb_vidq, wait);
195a4ef6 1927}
a6c2ba28 1928
195a4ef6
MCC		 1929/*
1930 * em28xx_v4l2_mmap()
1931 */
1932static int em28xx_v4l2_mmap(struct file *filp, struct vm_area_struct *vma)
1933{
1934 struct em28xx_fh *fh = filp->private_data;
1935 struct em28xx *dev = fh->dev;
ad0ebb96 1936 int rc;
a6c2ba28 1937
195a4ef6
MCC		 1938 if (unlikely(res_get(fh) < 0))
1939 return -EBUSY;
a6c2ba28 1940
ad0ebb96
MCC		 1941 rc = check_dev(dev);
1942 if (rc < 0)
1943 return rc;
a6c2ba28 1944
ad0ebb96 1945 rc = videobuf_mmap_mapper(&fh->vb_vidq, vma);
a6c2ba28 1946
ad0ebb96
MCC		 1947 em28xx_videodbg("vma start=0x%08lx, size=%ld, ret=%d\n",
1948 (unsigned long)vma->vm_start,
1949 (unsigned long)vma->vm_end-(unsigned long)vma->vm_start,
1950 rc);
a6c2ba28 1951
ad0ebb96 1952 return rc;
a6c2ba28
AM		 1953}
1954
fa027c2a 1955static const struct file_operations em28xx_v4l_fops = {
195a4ef6
MCC		 1956 .owner = THIS_MODULE,
1957 .open = em28xx_v4l2_open,
1958 .release = em28xx_v4l2_close,
1959 .read = em28xx_v4l2_read,
1960 .poll = em28xx_v4l2_poll,
1961 .mmap = em28xx_v4l2_mmap,
1962 .ioctl = video_ioctl2,
1963 .llseek = no_llseek,
1964 .compat_ioctl = v4l_compat_ioctl32,
1965};
17cbe2e5 1966
0be43754
MCC		 1967static const struct file_operations radio_fops = {
1968 .owner = THIS_MODULE,
1969 .open = em28xx_v4l2_open,
1970 .release = em28xx_v4l2_close,
1971 .ioctl = video_ioctl2,
1972 .compat_ioctl = v4l_compat_ioctl32,
1973 .llseek = no_llseek,
1974};
1975
195a4ef6
MCC		 1976static const struct video_device em28xx_video_template = {
1977 .fops = &em28xx_v4l_fops,
1978 .release = video_device_release,
1979
1980 .minor = -1,
1981 .vidioc_querycap = vidioc_querycap,
1982 .vidioc_enum_fmt_cap = vidioc_enum_fmt_cap,
1983 .vidioc_g_fmt_cap = vidioc_g_fmt_cap,
1984 .vidioc_try_fmt_cap = vidioc_try_fmt_cap,
1985 .vidioc_s_fmt_cap = vidioc_s_fmt_cap,
1986 .vidioc_g_audio = vidioc_g_audio,
1987 .vidioc_s_audio = vidioc_s_audio,
1988 .vidioc_cropcap = vidioc_cropcap,
1989
1990 .vidioc_g_fmt_vbi_capture = vidioc_g_fmt_vbi_capture,
1991 .vidioc_try_fmt_vbi_capture = vidioc_try_set_vbi_capture,
1992 .vidioc_s_fmt_vbi_capture = vidioc_try_set_vbi_capture,
1993
1994 .vidioc_reqbufs = vidioc_reqbufs,
1995 .vidioc_querybuf = vidioc_querybuf,
1996 .vidioc_qbuf = vidioc_qbuf,
1997 .vidioc_dqbuf = vidioc_dqbuf,
1998 .vidioc_s_std = vidioc_s_std,
1999 .vidioc_enum_input = vidioc_enum_input,
2000 .vidioc_g_input = vidioc_g_input,
2001 .vidioc_s_input = vidioc_s_input,
2002 .vidioc_queryctrl = vidioc_queryctrl,
2003 .vidioc_g_ctrl = vidioc_g_ctrl,
2004 .vidioc_s_ctrl = vidioc_s_ctrl,
2005 .vidioc_streamon = vidioc_streamon,
2006 .vidioc_streamoff = vidioc_streamoff,
2007 .vidioc_g_tuner = vidioc_g_tuner,
2008 .vidioc_s_tuner = vidioc_s_tuner,
2009 .vidioc_g_frequency = vidioc_g_frequency,
2010 .vidioc_s_frequency = vidioc_s_frequency,
1e7ad56f
MCC		 2011#ifdef CONFIG_VIDEO_ADV_DEBUG
2012 .vidioc_g_register = vidioc_g_register,
2013 .vidioc_s_register = vidioc_s_register,
2014#endif
ad0ebb96
MCC		 2015#ifdef CONFIG_VIDEO_V4L1_COMPAT
2016 .vidiocgmbuf = vidiocgmbuf,
2017#endif
195a4ef6
MCC		 2018
2019 .tvnorms = V4L2_STD_ALL,
7d497f8a 2020 .current_norm = V4L2_STD_PAL,
a6c2ba28
AM		 2021};
2022
0be43754
MCC		 2023static struct video_device em28xx_radio_template = {
2024 .name = "em28xx-radio",
2025 .type = VID_TYPE_TUNER,
2026 .fops = &radio_fops,
2027 .minor = -1,
2028 .vidioc_querycap = radio_querycap,
2029 .vidioc_g_tuner = radio_g_tuner,
2030 .vidioc_enum_input = radio_enum_input,
2031 .vidioc_g_audio = radio_g_audio,
2032 .vidioc_s_tuner = radio_s_tuner,
2033 .vidioc_s_audio = radio_s_audio,
2034 .vidioc_s_input = radio_s_input,
2035 .vidioc_queryctrl = radio_queryctrl,
2036 .vidioc_g_ctrl = vidioc_g_ctrl,
2037 .vidioc_s_ctrl = vidioc_s_ctrl,
2038 .vidioc_g_frequency = vidioc_g_frequency,
2039 .vidioc_s_frequency = vidioc_s_frequency,
1e7ad56f
MCC		 2040#ifdef CONFIG_VIDEO_ADV_DEBUG
2041 .vidioc_g_register = vidioc_g_register,
2042 .vidioc_s_register = vidioc_s_register,
2043#endif
0be43754
MCC		 2044};
2045
a6c2ba28
AM		 2046/******************************** usb interface *****************************************/
2047
6d79468d
MCC		 2048
2049static LIST_HEAD(em28xx_extension_devlist);
2050static DEFINE_MUTEX(em28xx_extension_devlist_lock);
2051
2052int em28xx_register_extension(struct em28xx_ops *ops)
2053{
2054 struct em28xx *h, *dev = NULL;
2055
2056 list_for_each_entry(h, &em28xx_devlist, devlist)
2057 dev = h;
2058
2059 mutex_lock(&em28xx_extension_devlist_lock);
2060 list_add_tail(&ops->next, &em28xx_extension_devlist);
2061 if (dev)
2062 ops->init(dev);
2063
2064 printk(KERN_INFO "Em28xx: Initialized (%s) extension\n", ops->name);
2065 mutex_unlock(&em28xx_extension_devlist_lock);
2066
2067 return 0;
2068}
2069EXPORT_SYMBOL(em28xx_register_extension);
2070
2071void em28xx_unregister_extension(struct em28xx_ops *ops)
2072{
2073 struct em28xx *h, *dev = NULL;
2074
2075 list_for_each_entry(h, &em28xx_devlist, devlist)
2076 dev = h;
2077
2078 if (dev)
2079 ops->fini(dev);
2080
2081 mutex_lock(&em28xx_extension_devlist_lock);
2082 printk(KERN_INFO "Em28xx: Removed (%s) extension\n", ops->name);
2083 list_del(&ops->next);
2084 mutex_unlock(&em28xx_extension_devlist_lock);
2085}
2086EXPORT_SYMBOL(em28xx_unregister_extension);
2087
532fe652
AB		 2088static struct video_device *em28xx_vdev_init(struct em28xx *dev,
2089 const struct video_device *template,
2090 const int type,
2091 const char *type_name)
0be43754
MCC		 2092{
2093 struct video_device *vfd;
2094
2095 vfd = video_device_alloc();
2096 if (NULL == vfd)
2097 return NULL;
2098 *vfd = *template;
2099 vfd->minor = -1;
2100 vfd->dev = &dev->udev->dev;
2101 vfd->release = video_device_release;
2102 vfd->type = type;
2103
2104 snprintf(vfd->name, sizeof(vfd->name), "%s %s",
2105 dev->name, type_name);
2106
2107 return vfd;
2108}
2109
2110
a6c2ba28 2111/*
3acf2809 2112 * em28xx_init_dev()
a6c2ba28
AM		 2113 * allocates and inits the device structs, registers i2c bus and v4l device
2114 */
3acf2809 2115static int em28xx_init_dev(struct em28xx **devhandle, struct usb_device *udev,
03910cc3 2116 int minor)
a6c2ba28 2117{
6d79468d 2118 struct em28xx_ops *ops = NULL;
3acf2809 2119 struct em28xx *dev = *devhandle;
a6c2ba28 2120 int retval = -ENOMEM;
7d497f8a 2121 int errCode;
a6c2ba28 2122 unsigned int maxh, maxw;
a6c2ba28 2123
a6c2ba28 2124 dev->udev = udev;
3593cab5 2125 mutex_init(&dev->lock);
d7aa8020 2126 spin_lock_init(&dev->slock);
a6c2ba28 2127 init_waitqueue_head(&dev->open);
a3a048ce
MCC		 2128 init_waitqueue_head(&dev->wait_frame);
2129 init_waitqueue_head(&dev->wait_stream);
a6c2ba28 2130
3acf2809
MCC		 2131 dev->em28xx_write_regs = em28xx_write_regs;
2132 dev->em28xx_read_reg = em28xx_read_reg;
2133 dev->em28xx_read_reg_req_len = em28xx_read_reg_req_len;
2134 dev->em28xx_write_regs_req = em28xx_write_regs_req;
2135 dev->em28xx_read_reg_req = em28xx_read_reg_req;
fad7b958 2136 dev->is_em2800 = em28xx_boards[dev->model].is_em2800;
a6c2ba28 2137
d7448a8d
MCC		 2138 errCode = em28xx_read_reg(dev, CHIPID_REG);
2139 if (errCode >= 0)
2140 em28xx_info("em28xx chip ID = %d\n", errCode);
2141
a94e95b4 2142 em28xx_pre_card_setup(dev);
03910cc3 2143
3acf2809 2144 errCode = em28xx_config(dev);
a6c2ba28 2145 if (errCode) {
3acf2809 2146 em28xx_errdev("error configuring device\n");
03910cc3 2147 em28xx_devused &= ~(1<<dev->devno);
7c908fbb 2148 kfree(dev);
a6c2ba28
AM		 2149 return -ENOMEM;
2150 }
2151
a6c2ba28 2152 /* register i2c bus */
3acf2809 2153 em28xx_i2c_register(dev);
a6c2ba28
AM		 2154
2155 /* Do board specific init and eeprom reading */
3acf2809 2156 em28xx_card_setup(dev);
a6c2ba28 2157
3abee53e
MCC		 2158 /* Configure audio */
2159 em28xx_audio_analog_set(dev);
2160
a6c2ba28 2161 /* configure the device */
3acf2809 2162 em28xx_config_i2c(dev);
a6c2ba28 2163
7d497f8a
MCC		 2164 /* set default norm */
2165 dev->norm = em28xx_video_template.current_norm;
03910cc3
MCC		 2166
2167 maxw = norm_maxw(dev);
2168 maxh = norm_maxh(dev);
2169
2170 /* set default image size */
2171 dev->width = maxw;
2172 dev->height = maxh;
2173 dev->interlaced = EM28XX_INTERLACED_DEFAULT;
2174 dev->field_size = dev->width * dev->height;
2175 dev->frame_size =
2176 dev->interlaced ? dev->field_size << 1 : dev->field_size;
2177 dev->bytesperline = dev->width * 2;
2178 dev->hscale = 0;
2179 dev->vscale = 0;
2180 dev->ctl_input = 2;
2181
3acf2809 2182 errCode = em28xx_config(dev);
a6c2ba28 2183
0be43754
MCC		 2184 list_add_tail(&dev->devlist, &em28xx_devlist);
2185
195a4ef6 2186 /* allocate and fill video video_device struct */
0be43754
MCC		 2187 dev->vdev = em28xx_vdev_init(dev, &em28xx_video_template,
2188 VID_TYPE_CAPTURE, "video");
a6c2ba28 2189 if (NULL == dev->vdev) {
3acf2809 2190 em28xx_errdev("cannot allocate video_device.\n");
0be43754 2191 goto fail_unreg;
e5589bef 2192 }
ed086314 2193 if (dev->tuner_type != TUNER_ABSENT)
195a4ef6 2194 dev->vdev->type |= VID_TYPE_TUNER;
0be43754
MCC		 2195
2196 /* register v4l2 video video_device */
2197 retval = video_register_device(dev->vdev, VFL_TYPE_GRABBER,
2198 video_nr[dev->devno]);
2199 if (retval) {
2200 em28xx_errdev("unable to register video device (error=%i).\n",
2201 retval);
2202 goto fail_unreg;
2203 }
e5589bef 2204
195a4ef6 2205 /* Allocate and fill vbi video_device struct */
0be43754
MCC		 2206 dev->vbi_dev = em28xx_vdev_init(dev, &em28xx_video_template,
2207 VFL_TYPE_VBI, "vbi");
2208 /* register v4l2 vbi video_device */
2209 if (video_register_device(dev->vbi_dev, VFL_TYPE_VBI,
2210 vbi_nr[dev->devno]) < 0) {
2211 em28xx_errdev("unable to register vbi device\n");
2212 retval = -ENODEV;
2213 goto fail_unreg;
2214 }
2215
2216 if (em28xx_boards[dev->model].radio.type == EM28XX_RADIO) {
2217 dev->radio_dev = em28xx_vdev_init(dev, &em28xx_radio_template,
2218 VFL_TYPE_RADIO, "radio");
2219 if (NULL == dev->radio_dev) {
2220 em28xx_errdev("cannot allocate video_device.\n");
2221 goto fail_unreg;
2222 }
2223 retval = video_register_device(dev->radio_dev, VFL_TYPE_RADIO,
2224 radio_nr[dev->devno]);
2225 if (retval < 0) {
2226 em28xx_errdev("can't register radio device\n");
2227 goto fail_unreg;
2228 }
2229 em28xx_info("Registered radio device as /dev/radio%d\n",
2230 dev->radio_dev->minor & 0x1f);
a6c2ba28 2231 }
e5589bef 2232
ad0ebb96
MCC		 2233 /* init video dma queues */
2234 INIT_LIST_HEAD(&dev->vidq.active);
2235 INIT_LIST_HEAD(&dev->vidq.queued);
2236
2237 dev->vidq.timeout.function = em28xx_vid_timeout;
2238 dev->vidq.timeout.data = (unsigned long)dev;
2239 init_timer(&dev->vidq.timeout);
2240
a6c2ba28 2241
5a80415b
SS		 2242 if (dev->has_msp34xx) {
2243 /* Send a reset to other chips via gpio */
2244 em28xx_write_regs_req(dev, 0x00, 0x08, "\xf7", 1);
2245 msleep(3);
2246 em28xx_write_regs_req(dev, 0x00, 0x08, "\xff", 1);
2247 msleep(3);
5a80415b 2248 }
195a4ef6 2249
5a80415b
SS		 2250 video_mux(dev, 0);
2251
e5589bef
MCC		 2252 em28xx_info("V4L2 device registered as /dev/video%d and /dev/vbi%d\n",
2253 dev->vdev->minor-MINOR_VFL_TYPE_GRABBER_MIN,
2254 dev->vbi_dev->minor-MINOR_VFL_TYPE_VBI_MIN);
a6c2ba28 2255
6d79468d
MCC		 2256 mutex_lock(&em28xx_extension_devlist_lock);
2257 if (!list_empty(&em28xx_extension_devlist)) {
2258 list_for_each_entry(ops, &em28xx_extension_devlist, next) {
2259 if (ops->id)
2260 ops->init(dev);
2261 }
2262 }
2263 mutex_unlock(&em28xx_extension_devlist_lock);
2264
a6c2ba28 2265 return 0;
0be43754
MCC		 2266
2267fail_unreg:
2268 em28xx_release_resources(dev);
2269 mutex_unlock(&dev->lock);
2270 kfree(dev);
2271 return retval;
a6c2ba28
AM		 2272}
2273
d7448a8d
MCC		 2274#if defined(CONFIG_MODULES) && defined(MODULE)
2275static void request_module_async(struct work_struct *work)
2276{
2277 struct em28xx *dev = container_of(work,
2278 struct em28xx, request_module_wk);
2279
3f4dfe2a
MCC		 2280 if (dev->has_audio_class)
2281 request_module("snd-usb-audio");
2282 else
d7448a8d
MCC		 2283 request_module("em28xx-alsa");
2284}
2285
2286static void request_modules(struct em28xx *dev)
2287{
2288 INIT_WORK(&dev->request_module_wk, request_module_async);
2289 schedule_work(&dev->request_module_wk);
2290}
2291#else
2292#define request_modules(dev)
2293#endif /* CONFIG_MODULES */
2294
a6c2ba28 2295/*
3acf2809 2296 * em28xx_usb_probe()
a6c2ba28
AM		 2297 * checks for supported devices
2298 */
3acf2809 2299static int em28xx_usb_probe(struct usb_interface *interface,
a6c2ba28
AM		 2300 const struct usb_device_id *id)
2301{
2302 const struct usb_endpoint_descriptor *endpoint;
2303 struct usb_device *udev;
9d4d9c05 2304 struct usb_interface *uif;
3acf2809 2305 struct em28xx *dev = NULL;
a6c2ba28 2306 int retval = -ENODEV;
03910cc3 2307 int i, nr, ifnum;
a6c2ba28
AM		 2308
2309 udev = usb_get_dev(interface_to_usbdev(interface));
d5e52653
MCC		 2310 ifnum = interface->altsetting[0].desc.bInterfaceNumber;
2311
e5589bef
MCC		 2312 /* Check to see next free device and mark as used */
2313 nr=find_first_zero_bit(&em28xx_devused,EM28XX_MAXBOARDS);
2314 em28xx_devused|=1<<nr;
a6c2ba28 2315
596d92d5 2316 /* Don't register audio interfaces */
91cad0f2 2317 if (interface->altsetting[0].desc.bInterfaceClass == USB_CLASS_AUDIO) {
3acf2809 2318 em28xx_err(DRIVER_NAME " audio device (%04x:%04x): interface %i, class %i\n",
91cad0f2
MCC		 2319 udev->descriptor.idVendor,udev->descriptor.idProduct,
2320 ifnum,
2321 interface->altsetting[0].desc.bInterfaceClass);
e5589bef
MCC		 2322
2323 em28xx_devused&=~(1<<nr);
596d92d5 2324 return -ENODEV;
91cad0f2
MCC		 2325 }
2326
3acf2809 2327 em28xx_err(DRIVER_NAME " new video device (%04x:%04x): interface %i, class %i\n",
91cad0f2
MCC		 2328 udev->descriptor.idVendor,udev->descriptor.idProduct,
2329 ifnum,
2330 interface->altsetting[0].desc.bInterfaceClass);
596d92d5 2331
d5e52653
MCC		 2332 endpoint = &interface->cur_altsetting->endpoint[1].desc;
2333
59c51591 2334 /* check if the device has the iso in endpoint at the correct place */
a6c2ba28
AM		 2335 if ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) !=
2336 USB_ENDPOINT_XFER_ISOC) {
3acf2809 2337 em28xx_err(DRIVER_NAME " probing error: endpoint is non-ISO endpoint!\n");
e5589bef 2338 em28xx_devused&=~(1<<nr);
a6c2ba28
AM		 2339 return -ENODEV;
2340 }
2341 if ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_OUT) {
3acf2809 2342 em28xx_err(DRIVER_NAME " probing error: endpoint is ISO OUT endpoint!\n");
e5589bef 2343 em28xx_devused&=~(1<<nr);
a6c2ba28
AM		 2344 return -ENODEV;
2345 }
2346
19478843 2347 if (nr >= EM28XX_MAXBOARDS) {
9d4d9c05 2348 printk (DRIVER_NAME ": Supports only %i em28xx boards.\n",EM28XX_MAXBOARDS);
e5589bef 2349 em28xx_devused&=~(1<<nr);
596d92d5
MCC		 2350 return -ENOMEM;
2351 }
2352
2353 /* allocate memory for our device state and initialize it */
7408187d 2354 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
596d92d5 2355 if (dev == NULL) {
3acf2809 2356 em28xx_err(DRIVER_NAME ": out of memory!\n");
e5589bef 2357 em28xx_devused&=~(1<<nr);
596d92d5
MCC		 2358 return -ENOMEM;
2359 }
596d92d5 2360
e5589bef 2361 snprintf(dev->name, 29, "em28xx #%d", nr);
03910cc3
MCC		 2362 dev->devno = nr;
2363 dev->model = id->driver_info;
3687e1e6 2364 dev->alt = -1;
e5589bef 2365
d7448a8d
MCC		 2366 /* Checks if audio is provided by some interface */
2367 for (i = 0; i < udev->config->desc.bNumInterfaces; i++) {
2368 uif = udev->config->interface[i];
2369 if (uif->altsetting[0].desc.bInterfaceClass == USB_CLASS_AUDIO) {
2370 dev->has_audio_class = 1;
2371 break;
2372 }
2373 }
2374
2375 printk(KERN_INFO DRIVER_NAME " %s usb audio class\n",
2376 dev->has_audio_class ? "Has" : "Doesn't have");
2377
9d4d9c05
MCC		 2378 /* compute alternate max packet sizes */
2379 uif = udev->actconfig->interface[0];
2380
2381 dev->num_alt=uif->num_altsetting;
e5589bef 2382 em28xx_info("Alternate settings: %i\n",dev->num_alt);
9d4d9c05
MCC		 2383// dev->alt_max_pkt_size = kmalloc(sizeof(*dev->alt_max_pkt_size)*
2384 dev->alt_max_pkt_size = kmalloc(32*
2385 dev->num_alt,GFP_KERNEL);
2386 if (dev->alt_max_pkt_size == NULL) {
e5589bef
MCC		 2387 em28xx_errdev("out of memory!\n");
2388 em28xx_devused&=~(1<<nr);
1207cf84 2389 kfree(dev);
9d4d9c05
MCC		 2390 return -ENOMEM;
2391 }
2392
2393 for (i = 0; i < dev->num_alt ; i++) {
2394 u16 tmp = le16_to_cpu(uif->altsetting[i].endpoint[1].desc.
2395 wMaxPacketSize);
2396 dev->alt_max_pkt_size[i] =
2397 (tmp & 0x07ff) * (((tmp & 0x1800) >> 11) + 1);
e5589bef 2398 em28xx_info("Alternate setting %i, max size= %i\n",i,
9d4d9c05
MCC		 2399 dev->alt_max_pkt_size[i]);
2400 }
2401
3acf2809 2402 if ((card[nr]>=0)&&(card[nr]<em28xx_bcount))
03910cc3 2403 dev->model = card[nr];
596d92d5 2404
a6c2ba28 2405 /* allocate device struct */
03910cc3 2406 retval = em28xx_init_dev(&dev, udev, nr);
a6c2ba28
AM		 2407 if (retval)
2408 return retval;
2409
03910cc3 2410 em28xx_info("Found %s\n", em28xx_boards[dev->model].name);
a6c2ba28
AM		 2411
2412 /* save our data pointer in this interface device */
2413 usb_set_intfdata(interface, dev);
d7448a8d
MCC		 2414
2415 request_modules(dev);
2416
a6c2ba28
AM		 2417 return 0;
2418}
2419
2420/*
3acf2809 2421 * em28xx_usb_disconnect()
a6c2ba28
AM		 2422 * called when the device gets diconencted
2423 * video device will be unregistered on v4l2_close in case it is still open
2424 */
3acf2809 2425static void em28xx_usb_disconnect(struct usb_interface *interface)
a6c2ba28 2426{
5a80415b 2427 struct em28xx *dev;
6d79468d 2428 struct em28xx_ops *ops = NULL;
5a80415b
SS		 2429
2430 dev = usb_get_intfdata(interface);
a6c2ba28
AM		 2431 usb_set_intfdata(interface, NULL);
2432
2433 if (!dev)
2434 return;
2435
5a80415b 2436 em28xx_info("disconnecting %s\n", dev->vdev->name);
a6c2ba28 2437
5a80415b 2438 /* wait until all current v4l2 io is finished then deallocate resources */
3593cab5 2439 mutex_lock(&dev->lock);
a6c2ba28 2440
a6c2ba28
AM		 2441 wake_up_interruptible_all(&dev->open);
2442
2443 if (dev->users) {
3acf2809 2444 em28xx_warn
a6c2ba28 2445 ("device /dev/video%d is open! Deregistration and memory "
e5589bef
MCC		 2446 "deallocation are deferred on close.\n",
2447 dev->vdev->minor-MINOR_VFL_TYPE_GRABBER_MIN);
2448
a6c2ba28 2449 dev->state |= DEV_MISCONFIGURED;
3acf2809 2450 em28xx_uninit_isoc(dev);
a6c2ba28
AM		 2451 dev->state |= DEV_DISCONNECTED;
2452 wake_up_interruptible(&dev->wait_frame);
2453 wake_up_interruptible(&dev->wait_stream);
2454 } else {
2455 dev->state |= DEV_DISCONNECTED;
3acf2809 2456 em28xx_release_resources(dev);
a6c2ba28 2457 }
3593cab5 2458 mutex_unlock(&dev->lock);
a6c2ba28 2459
6d79468d
MCC		 2460 mutex_lock(&em28xx_extension_devlist_lock);
2461 if (!list_empty(&em28xx_extension_devlist)) {
2462 list_for_each_entry(ops, &em28xx_extension_devlist, next) {
2463 ops->fini(dev);
2464 }
2465 }
2466 mutex_unlock(&em28xx_extension_devlist_lock);
2467
9d4d9c05
MCC		 2468 if (!dev->users) {
2469 kfree(dev->alt_max_pkt_size);
a6c2ba28 2470 kfree(dev);
9d4d9c05 2471 }
a6c2ba28
AM		 2472}
2473
3acf2809 2474static struct usb_driver em28xx_usb_driver = {
3acf2809
MCC		 2475 .name = "em28xx",
2476 .probe = em28xx_usb_probe,
2477 .disconnect = em28xx_usb_disconnect,
2478 .id_table = em28xx_id_table,
a6c2ba28
AM		 2479};
2480
3acf2809 2481static int __init em28xx_module_init(void)
a6c2ba28
AM		 2482{
2483 int result;
2484
2485 printk(KERN_INFO DRIVER_NAME " v4l2 driver version %d.%d.%d loaded\n",
3acf2809
MCC		 2486 (EM28XX_VERSION_CODE >> 16) & 0xff,
2487 (EM28XX_VERSION_CODE >> 8) & 0xff, EM28XX_VERSION_CODE & 0xff);
a6c2ba28
AM		 2488#ifdef SNAPSHOT
2489 printk(KERN_INFO DRIVER_NAME " snapshot date %04d-%02d-%02d\n",
2490 SNAPSHOT / 10000, (SNAPSHOT / 100) % 100, SNAPSHOT % 100);
2491#endif
2492
2493 /* register this driver with the USB subsystem */
3acf2809 2494 result = usb_register(&em28xx_usb_driver);
a6c2ba28 2495 if (result)
3acf2809 2496 em28xx_err(DRIVER_NAME
a6c2ba28
AM		 2497 " usb_register failed. Error number %d.\n", result);
2498
2499 return result;
2500}
2501
3acf2809 2502static void __exit em28xx_module_exit(void)
a6c2ba28
AM		 2503{
2504 /* deregister this driver with the USB subsystem */
3acf2809 2505 usb_deregister(&em28xx_usb_driver);
a6c2ba28
AM		 2506}
2507
3acf2809
MCC		 2508module_init(em28xx_module_init);
2509module_exit(em28xx_module_exit);
Clone of davem's net-next-2.6 tree