projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[media] tm6000-video.c: warning fix
[deliverable/linux.git] / drivers / media / usb / tm6000 / tm6000-video.c
1 /*
2 * tm6000-video.c - driver for TM5600/TM6000/TM6010 USB video capture devices
3 *
4 * Copyright (C) 2006-2007 Mauro Carvalho Chehab <mchehab@infradead.org>
5 *
6 * Copyright (C) 2007 Michel Ludwig <michel.ludwig@gmail.com>
7 * - Fixed module load/unload
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation version 2
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 */
22
23 #include <linux/module.h>
24 #include <linux/delay.h>
25 #include <linux/errno.h>
26 #include <linux/fs.h>
27 #include <linux/kernel.h>
28 #include <linux/slab.h>
29 #include <linux/mm.h>
30 #include <linux/ioport.h>
31 #include <linux/init.h>
32 #include <linux/sched.h>
33 #include <linux/random.h>
34 #include <linux/usb.h>
35 #include <linux/videodev2.h>
36 #include <media/v4l2-ioctl.h>
37 #include <media/tuner.h>
38 #include <linux/interrupt.h>
39 #include <linux/kthread.h>
40 #include <linux/highmem.h>
41 #include <linux/freezer.h>
42
43 #include "tm6000-regs.h"
44 #include "tm6000.h"
45
46 #define BUFFER_TIMEOUT msecs_to_jiffies(2000) /* 2 seconds */
47
48 /* Limits minimum and default number of buffers */
49 #define TM6000_MIN_BUF 4
50 #define TM6000_DEF_BUF 8
51
52 #define TM6000_NUM_URB_BUF 8
53
54 #define TM6000_MAX_ISO_PACKETS 46 /* Max number of ISO packets */
55
56 /* Declare static vars that will be used as parameters */
57 static unsigned int vid_limit = 16; /* Video memory limit, in Mb */
58 static int video_nr = -1; /* /dev/videoN, -1 for autodetect */
59 static int radio_nr = -1; /* /dev/radioN, -1 for autodetect */
60 static bool keep_urb; /* keep urb buffers allocated */
61
62 /* Debug level */
63 int tm6000_debug;
64 EXPORT_SYMBOL_GPL(tm6000_debug);
65
66 static const struct v4l2_queryctrl no_ctrl = {
67 .name = "42",
68 .flags = V4L2_CTRL_FLAG_DISABLED,
69 };
70
71 /* supported controls */
72 static struct v4l2_queryctrl tm6000_qctrl[] = {
73 {
74 .id = V4L2_CID_BRIGHTNESS,
75 .type = V4L2_CTRL_TYPE_INTEGER,
76 .name = "Brightness",
77 .minimum = 0,
78 .maximum = 255,
79 .step = 1,
80 .default_value = 54,
81 .flags = 0,
82 }, {
83 .id = V4L2_CID_CONTRAST,
84 .type = V4L2_CTRL_TYPE_INTEGER,
85 .name = "Contrast",
86 .minimum = 0,
87 .maximum = 255,
88 .step = 0x1,
89 .default_value = 119,
90 .flags = 0,
91 }, {
92 .id = V4L2_CID_SATURATION,
93 .type = V4L2_CTRL_TYPE_INTEGER,
94 .name = "Saturation",
95 .minimum = 0,
96 .maximum = 255,
97 .step = 0x1,
98 .default_value = 112,
99 .flags = 0,
100 }, {
101 .id = V4L2_CID_HUE,
102 .type = V4L2_CTRL_TYPE_INTEGER,
103 .name = "Hue",
104 .minimum = -128,
105 .maximum = 127,
106 .step = 0x1,
107 .default_value = 0,
108 .flags = 0,
109 },
110 /* --- audio --- */
111 {
112 .id = V4L2_CID_AUDIO_MUTE,
113 .name = "Mute",
114 .minimum = 0,
115 .maximum = 1,
116 .type = V4L2_CTRL_TYPE_BOOLEAN,
117 }, {
118 .id = V4L2_CID_AUDIO_VOLUME,
119 .name = "Volume",
120 .minimum = -15,
121 .maximum = 15,
122 .step = 1,
123 .default_value = 0,
124 .type = V4L2_CTRL_TYPE_INTEGER,
125 }
126 };
127
128 static const unsigned int CTRLS = ARRAY_SIZE(tm6000_qctrl);
129 static int qctl_regs[ARRAY_SIZE(tm6000_qctrl)];
130
131 static struct tm6000_fmt format[] = {
132 {
133 .name = "4:2:2, packed, YVY2",
134 .fourcc = V4L2_PIX_FMT_YUYV,
135 .depth = 16,
136 }, {
137 .name = "4:2:2, packed, UYVY",
138 .fourcc = V4L2_PIX_FMT_UYVY,
139 .depth = 16,
140 }, {
141 .name = "A/V + VBI mux packet",
142 .fourcc = V4L2_PIX_FMT_TM6000,
143 .depth = 16,
144 }
145 };
146
147 static const struct v4l2_queryctrl *ctrl_by_id(unsigned int id)
148 {
149 unsigned int i;
150
151 for (i = 0; i < CTRLS; i++)
152 if (tm6000_qctrl[i].id == id)
153 return tm6000_qctrl+i;
154 return NULL;
155 }
156
157 /* ------------------------------------------------------------------
158 * DMA and thread functions
159 * ------------------------------------------------------------------
160 */
161
162 #define norm_maxw(a) 720
163 #define norm_maxh(a) 576
164
165 #define norm_minw(a) norm_maxw(a)
166 #define norm_minh(a) norm_maxh(a)
167
168 /*
169 * video-buf generic routine to get the next available buffer
170 */
171 static inline void get_next_buf(struct tm6000_dmaqueue *dma_q,
172 struct tm6000_buffer **buf)
173 {
174 struct tm6000_core *dev = container_of(dma_q, struct tm6000_core, vidq);
175
176 if (list_empty(&dma_q->active)) {
177 dprintk(dev, V4L2_DEBUG_QUEUE, "No active queue to serve\n");
178 *buf = NULL;
179 return;
180 }
181
182 *buf = list_entry(dma_q->active.next,
183 struct tm6000_buffer, vb.queue);
184 }
185
186 /*
187 * Announces that a buffer were filled and request the next
188 */
189 static inline void buffer_filled(struct tm6000_core *dev,
190 struct tm6000_dmaqueue *dma_q,
191 struct tm6000_buffer *buf)
192 {
193 /* Advice that buffer was filled */
194 dprintk(dev, V4L2_DEBUG_ISOC, "[%p/%d] wakeup\n", buf, buf->vb.i);
195 buf->vb.state = VIDEOBUF_DONE;
196 buf->vb.field_count++;
197 do_gettimeofday(&buf->vb.ts);
198
199 list_del(&buf->vb.queue);
200 wake_up(&buf->vb.done);
201 }
202
203 /*
204 * Identify the tm5600/6000 buffer header type and properly handles
205 */
206 static int copy_streams(u8 *data, unsigned long len,
207 struct urb *urb)
208 {
209 struct tm6000_dmaqueue *dma_q = urb->context;
210 struct tm6000_core *dev = container_of(dma_q, struct tm6000_core, vidq);
211 u8 *ptr = data, *endp = data+len;
212 unsigned long header = 0;
213 int rc = 0;
214 unsigned int cmd, cpysize, pktsize, size, field, block, line, pos = 0;
215 struct tm6000_buffer *vbuf = NULL;
216 char *voutp = NULL;
217 unsigned int linewidth;
218
219 if (!dev->radio) {
220 /* get video buffer */
221 get_next_buf(dma_q, &vbuf);
222
223 if (!vbuf)
224 return rc;
225 voutp = videobuf_to_vmalloc(&vbuf->vb);
226
227 if (!voutp)
228 return 0;
229 }
230
231 for (ptr = data; ptr < endp;) {
232 if (!dev->isoc_ctl.cmd) {
233 /* Header */
234 if (dev->isoc_ctl.tmp_buf_len > 0) {
235 /* from last urb or packet */
236 header = dev->isoc_ctl.tmp_buf;
237 if (4 - dev->isoc_ctl.tmp_buf_len > 0) {
238 memcpy((u8 *)&header +
239 dev->isoc_ctl.tmp_buf_len,
240 ptr,
241 4 - dev->isoc_ctl.tmp_buf_len);
242 ptr += 4 - dev->isoc_ctl.tmp_buf_len;
243 }
244 dev->isoc_ctl.tmp_buf_len = 0;
245 } else {
246 if (ptr + 3 >= endp) {
247 /* have incomplete header */
248 dev->isoc_ctl.tmp_buf_len = endp - ptr;
249 memcpy(&dev->isoc_ctl.tmp_buf, ptr,
250 dev->isoc_ctl.tmp_buf_len);
251 return rc;
252 }
253 /* Seek for sync */
254 for (; ptr < endp - 3; ptr++) {
255 if (*(ptr + 3) == 0x47)
256 break;
257 }
258 /* Get message header */
259 header = *(unsigned long *)ptr;
260 ptr += 4;
261 }
262
263 /* split the header fields */
264 size = ((header & 0x7e) << 1);
265 if (size > 0)
266 size -= 4;
267 block = (header >> 7) & 0xf;
268 field = (header >> 11) & 0x1;
269 line = (header >> 12) & 0x1ff;
270 cmd = (header >> 21) & 0x7;
271 /* Validates haeder fields */
272 if (size > TM6000_URB_MSG_LEN)
273 size = TM6000_URB_MSG_LEN;
274 pktsize = TM6000_URB_MSG_LEN;
275 /*
276 * calculate position in buffer and change the buffer
277 */
278 switch (cmd) {
279 case TM6000_URB_MSG_VIDEO:
280 if (!dev->radio) {
281 if ((dev->isoc_ctl.vfield != field) &&
282 (field == 1)) {
283 /*
284 * Announces that a new buffer
285 * were filled
286 */
287 buffer_filled(dev, dma_q, vbuf);
288 dprintk(dev, V4L2_DEBUG_ISOC,
289 "new buffer filled\n");
290 get_next_buf(dma_q, &vbuf);
291 if (!vbuf)
292 return rc;
293 voutp = videobuf_to_vmalloc(&vbuf->vb);
294 if (!voutp)
295 return rc;
296 memset(voutp, 0, vbuf->vb.size);
297 }
298 linewidth = vbuf->vb.width << 1;
299 pos = ((line << 1) - field - 1) *
300 linewidth + block * TM6000_URB_MSG_LEN;
301 /* Don't allow to write out of the buffer */
302 if (pos + size > vbuf->vb.size)
303 cmd = TM6000_URB_MSG_ERR;
304 dev->isoc_ctl.vfield = field;
305 }
306 break;
307 case TM6000_URB_MSG_VBI:
308 break;
309 case TM6000_URB_MSG_AUDIO:
310 case TM6000_URB_MSG_PTS:
311 size = pktsize; /* Size is always 180 bytes */
312 break;
313 }
314 } else {
315 /* Continue the last copy */
316 cmd = dev->isoc_ctl.cmd;
317 size = dev->isoc_ctl.size;
318 pos = dev->isoc_ctl.pos;
319 pktsize = dev->isoc_ctl.pktsize;
320 field = dev->isoc_ctl.field;
321 }
322 cpysize = (endp - ptr > size) ? size : endp - ptr;
323 if (cpysize) {
324 /* copy data in different buffers */
325 switch (cmd) {
326 case TM6000_URB_MSG_VIDEO:
327 /* Fills video buffer */
328 if (vbuf)
329 memcpy(&voutp[pos], ptr, cpysize);
330 break;
331 case TM6000_URB_MSG_AUDIO: {
332 int i;
333 for (i = 0; i < cpysize; i += 2)
334 swab16s((u16 *)(ptr + i));
335
336 tm6000_call_fillbuf(dev, TM6000_AUDIO, ptr, cpysize);
337 break;
338 }
339 case TM6000_URB_MSG_VBI:
340 /* Need some code to copy vbi buffer */
341 break;
342 case TM6000_URB_MSG_PTS: {
343 /* Need some code to copy pts */
344 u32 pts;
345 pts = *(u32 *)ptr;
346 dprintk(dev, V4L2_DEBUG_ISOC, "field %d, PTS %x",
347 field, pts);
348 break;
349 }
350 }
351 }
352 if (ptr + pktsize > endp) {
353 /*
354 * End of URB packet, but cmd processing is not
355 * complete. Preserve the state for a next packet
356 */
357 dev->isoc_ctl.pos = pos + cpysize;
358 dev->isoc_ctl.size = size - cpysize;
359 dev->isoc_ctl.cmd = cmd;
360 dev->isoc_ctl.field = field;
361 dev->isoc_ctl.pktsize = pktsize - (endp - ptr);
362 ptr += endp - ptr;
363 } else {
364 dev->isoc_ctl.cmd = 0;
365 ptr += pktsize;
366 }
367 }
368 return 0;
369 }
370
371 /*
372 * Identify the tm5600/6000 buffer header type and properly handles
373 */
374 static int copy_multiplexed(u8 *ptr, unsigned long len,
375 struct urb *urb)
376 {
377 struct tm6000_dmaqueue *dma_q = urb->context;
378 struct tm6000_core *dev = container_of(dma_q, struct tm6000_core, vidq);
379 unsigned int pos = dev->isoc_ctl.pos, cpysize;
380 int rc = 1;
381 struct tm6000_buffer *buf;
382 char *outp = NULL;
383
384 get_next_buf(dma_q, &buf);
385 if (buf)
386 outp = videobuf_to_vmalloc(&buf->vb);
387
388 if (!outp)
389 return 0;
390
391 while (len > 0) {
392 cpysize = min(len, buf->vb.size-pos);
393 memcpy(&outp[pos], ptr, cpysize);
394 pos += cpysize;
395 ptr += cpysize;
396 len -= cpysize;
397 if (pos >= buf->vb.size) {
398 pos = 0;
399 /* Announces that a new buffer were filled */
400 buffer_filled(dev, dma_q, buf);
401 dprintk(dev, V4L2_DEBUG_ISOC, "new buffer filled\n");
402 get_next_buf(dma_q, &buf);
403 if (!buf)
404 break;
405 outp = videobuf_to_vmalloc(&(buf->vb));
406 if (!outp)
407 return rc;
408 pos = 0;
409 }
410 }
411
412 dev->isoc_ctl.pos = pos;
413 return rc;
414 }
415
416 static inline void print_err_status(struct tm6000_core *dev,
417 int packet, int status)
418 {
419 char *errmsg = "Unknown";
420
421 switch (status) {
422 case -ENOENT:
423 errmsg = "unlinked synchronuously";
424 break;
425 case -ECONNRESET:
426 errmsg = "unlinked asynchronuously";
427 break;
428 case -ENOSR:
429 errmsg = "Buffer error (overrun)";
430 break;
431 case -EPIPE:
432 errmsg = "Stalled (device not responding)";
433 break;
434 case -EOVERFLOW:
435 errmsg = "Babble (bad cable?)";
436 break;
437 case -EPROTO:
438 errmsg = "Bit-stuff error (bad cable?)";
439 break;
440 case -EILSEQ:
441 errmsg = "CRC/Timeout (could be anything)";
442 break;
443 case -ETIME:
444 errmsg = "Device does not respond";
445 break;
446 }
447 if (packet < 0) {
448 dprintk(dev, V4L2_DEBUG_QUEUE, "URB status %d [%s].\n",
449 status, errmsg);
450 } else {
451 dprintk(dev, V4L2_DEBUG_QUEUE, "URB packet %d, status %d [%s].\n",
452 packet, status, errmsg);
453 }
454 }
455
456
457 /*
458 * Controls the isoc copy of each urb packet
459 */
460 static inline int tm6000_isoc_copy(struct urb *urb)
461 {
462 struct tm6000_dmaqueue *dma_q = urb->context;
463 struct tm6000_core *dev = container_of(dma_q, struct tm6000_core, vidq);
464 int i, len = 0, rc = 1, status;
465 char *p;
466
467 if (urb->status < 0) {
468 print_err_status(dev, -1, urb->status);
469 return 0;
470 }
471
472 for (i = 0; i < urb->number_of_packets; i++) {
473 status = urb->iso_frame_desc[i].status;
474
475 if (status < 0) {
476 print_err_status(dev, i, status);
477 continue;
478 }
479
480 len = urb->iso_frame_desc[i].actual_length;
481
482 if (len > 0) {
483 p = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
484 if (!urb->iso_frame_desc[i].status) {
485 if ((dev->fourcc) == V4L2_PIX_FMT_TM6000) {
486 rc = copy_multiplexed(p, len, urb);
487 if (rc <= 0)
488 return rc;
489 } else {
490 copy_streams(p, len, urb);
491 }
492 }
493 }
494 }
495 return rc;
496 }
497
498 /* ------------------------------------------------------------------
499 * URB control
500 * ------------------------------------------------------------------
501 */
502
503 /*
504 * IRQ callback, called by URB callback
505 */
506 static void tm6000_irq_callback(struct urb *urb)
507 {
508 struct tm6000_dmaqueue *dma_q = urb->context;
509 struct tm6000_core *dev = container_of(dma_q, struct tm6000_core, vidq);
510 int i;
511
512 switch (urb->status) {
513 case 0:
514 case -ETIMEDOUT:
515 break;
516
517 case -ECONNRESET:
518 case -ENOENT:
519 case -ESHUTDOWN:
520 return;
521
522 default:
523 tm6000_err("urb completion error %d.\n", urb->status);
524 break;
525 }
526
527 spin_lock(&dev->slock);
528 tm6000_isoc_copy(urb);
529 spin_unlock(&dev->slock);
530
531 /* Reset urb buffers */
532 for (i = 0; i < urb->number_of_packets; i++) {
533 urb->iso_frame_desc[i].status = 0;
534 urb->iso_frame_desc[i].actual_length = 0;
535 }
536
537 urb->status = usb_submit_urb(urb, GFP_ATOMIC);
538 if (urb->status)
539 tm6000_err("urb resubmit failed (error=%i)\n",
540 urb->status);
541 }
542
543 /*
544 * Allocate URB buffers
545 */
546 static int tm6000_alloc_urb_buffers(struct tm6000_core *dev)
547 {
548 int num_bufs = TM6000_NUM_URB_BUF;
549 int i;
550
551 if (dev->urb_buffer != NULL)
552 return 0;
553
554 dev->urb_buffer = kmalloc(sizeof(void *)*num_bufs, GFP_KERNEL);
555 if (!dev->urb_buffer) {
556 tm6000_err("cannot allocate memory for urb buffers\n");
557 return -ENOMEM;
558 }
559
560 dev->urb_dma = kmalloc(sizeof(dma_addr_t *)*num_bufs, GFP_KERNEL);
561 if (!dev->urb_dma) {
562 tm6000_err("cannot allocate memory for urb dma pointers\n");
563 return -ENOMEM;
564 }
565
566 for (i = 0; i < num_bufs; i++) {
567 dev->urb_buffer[i] = usb_alloc_coherent(
568 dev->udev, dev->urb_size,
569 GFP_KERNEL, &dev->urb_dma[i]);
570 if (!dev->urb_buffer[i]) {
571 tm6000_err("unable to allocate %i bytes for transfer buffer %i\n",
572 dev->urb_size, i);
573 return -ENOMEM;
574 }
575 memset(dev->urb_buffer[i], 0, dev->urb_size);
576 }
577
578 return 0;
579 }
580
581 /*
582 * Free URB buffers
583 */
584 static int tm6000_free_urb_buffers(struct tm6000_core *dev)
585 {
586 int i;
587
588 if (dev->urb_buffer == NULL)
589 return 0;
590
591 for (i = 0; i < TM6000_NUM_URB_BUF; i++) {
592 if (dev->urb_buffer[i]) {
593 usb_free_coherent(dev->udev,
594 dev->urb_size,
595 dev->urb_buffer[i],
596 dev->urb_dma[i]);
597 dev->urb_buffer[i] = NULL;
598 }
599 }
600 kfree(dev->urb_buffer);
601 kfree(dev->urb_dma);
602 dev->urb_buffer = NULL;
603 dev->urb_dma = NULL;
604
605 return 0;
606 }
607
608 /*
609 * Stop and Deallocate URBs
610 */
611 static void tm6000_uninit_isoc(struct tm6000_core *dev)
612 {
613 struct urb *urb;
614 int i;
615
616 dev->isoc_ctl.buf = NULL;
617 for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
618 urb = dev->isoc_ctl.urb[i];
619 if (urb) {
620 usb_kill_urb(urb);
621 usb_unlink_urb(urb);
622 usb_free_urb(urb);
623 dev->isoc_ctl.urb[i] = NULL;
624 }
625 dev->isoc_ctl.transfer_buffer[i] = NULL;
626 }
627
628 if (!keep_urb)
629 tm6000_free_urb_buffers(dev);
630
631 kfree(dev->isoc_ctl.urb);
632 kfree(dev->isoc_ctl.transfer_buffer);
633
634 dev->isoc_ctl.urb = NULL;
635 dev->isoc_ctl.transfer_buffer = NULL;
636 dev->isoc_ctl.num_bufs = 0;
637 }
638
639 /*
640 * Assign URBs and start IRQ
641 */
642 static int tm6000_prepare_isoc(struct tm6000_core *dev)
643 {
644 struct tm6000_dmaqueue *dma_q = &dev->vidq;
645 int i, j, sb_size, pipe, size, max_packets;
646 int num_bufs = TM6000_NUM_URB_BUF;
647 struct urb *urb;
648
649 /* De-allocates all pending stuff */
650 tm6000_uninit_isoc(dev);
651 /* Stop interrupt USB pipe */
652 tm6000_ir_int_stop(dev);
653
654 usb_set_interface(dev->udev,
655 dev->isoc_in.bInterfaceNumber,
656 dev->isoc_in.bAlternateSetting);
657
658 /* Start interrupt USB pipe */
659 tm6000_ir_int_start(dev);
660
661 pipe = usb_rcvisocpipe(dev->udev,
662 dev->isoc_in.endp->desc.bEndpointAddress &
663 USB_ENDPOINT_NUMBER_MASK);
664
665 size = usb_maxpacket(dev->udev, pipe, usb_pipeout(pipe));
666
667 if (size > dev->isoc_in.maxsize)
668 size = dev->isoc_in.maxsize;
669
670 dev->isoc_ctl.max_pkt_size = size;
671
672 max_packets = TM6000_MAX_ISO_PACKETS;
673 sb_size = max_packets * size;
674 dev->urb_size = sb_size;
675
676 dev->isoc_ctl.num_bufs = num_bufs;
677
678 dev->isoc_ctl.urb = kmalloc(sizeof(void *)*num_bufs, GFP_KERNEL);
679 if (!dev->isoc_ctl.urb) {
680 tm6000_err("cannot alloc memory for usb buffers\n");
681 return -ENOMEM;
682 }
683
684 dev->isoc_ctl.transfer_buffer = kmalloc(sizeof(void *)*num_bufs,
685 GFP_KERNEL);
686 if (!dev->isoc_ctl.transfer_buffer) {
687 tm6000_err("cannot allocate memory for usbtransfer\n");
688 kfree(dev->isoc_ctl.urb);
689 return -ENOMEM;
690 }
691
692 dprintk(dev, V4L2_DEBUG_QUEUE, "Allocating %d x %d packets"
693 " (%d bytes) of %d bytes each to handle %u size\n",
694 max_packets, num_bufs, sb_size,
695 dev->isoc_in.maxsize, size);
696
697
698 if (!dev->urb_buffer && tm6000_alloc_urb_buffers(dev) < 0) {
699 tm6000_err("cannot allocate memory for urb buffers\n");
700
701 /* call free, as some buffers might have been allocated */
702 tm6000_free_urb_buffers(dev);
703 kfree(dev->isoc_ctl.urb);
704 kfree(dev->isoc_ctl.transfer_buffer);
705 return -ENOMEM;
706 }
707
708 /* allocate urbs and transfer buffers */
709 for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
710 urb = usb_alloc_urb(max_packets, GFP_KERNEL);
711 if (!urb) {
712 tm6000_err("cannot alloc isoc_ctl.urb %i\n", i);
713 tm6000_uninit_isoc(dev);
714 usb_free_urb(urb);
715 return -ENOMEM;
716 }
717 dev->isoc_ctl.urb[i] = urb;
718
719 urb->transfer_dma = dev->urb_dma[i];
720 dev->isoc_ctl.transfer_buffer[i] = dev->urb_buffer[i];
721
722 usb_fill_bulk_urb(urb, dev->udev, pipe,
723 dev->isoc_ctl.transfer_buffer[i], sb_size,
724 tm6000_irq_callback, dma_q);
725 urb->interval = dev->isoc_in.endp->desc.bInterval;
726 urb->number_of_packets = max_packets;
727 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
728
729 for (j = 0; j < max_packets; j++) {
730 urb->iso_frame_desc[j].offset = size * j;
731 urb->iso_frame_desc[j].length = size;
732 }
733 }
734
735 return 0;
736 }
737
738 static int tm6000_start_thread(struct tm6000_core *dev)
739 {
740 struct tm6000_dmaqueue *dma_q = &dev->vidq;
741 int i;
742
743 dma_q->frame = 0;
744 dma_q->ini_jiffies = jiffies;
745
746 init_waitqueue_head(&dma_q->wq);
747
748 /* submit urbs and enables IRQ */
749 for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
750 int rc = usb_submit_urb(dev->isoc_ctl.urb[i], GFP_ATOMIC);
751 if (rc) {
752 tm6000_err("submit of urb %i failed (error=%i)\n", i,
753 rc);
754 tm6000_uninit_isoc(dev);
755 return rc;
756 }
757 }
758
759 return 0;
760 }
761
762 /* ------------------------------------------------------------------
763 * Videobuf operations
764 * ------------------------------------------------------------------
765 */
766
767 static int
768 buffer_setup(struct videobuf_queue *vq, unsigned int *count, unsigned int *size)
769 {
770 struct tm6000_fh *fh = vq->priv_data;
771
772 *size = fh->fmt->depth * fh->width * fh->height >> 3;
773 if (0 == *count)
774 *count = TM6000_DEF_BUF;
775
776 if (*count < TM6000_MIN_BUF)
777 *count = TM6000_MIN_BUF;
778
779 while (*size * *count > vid_limit * 1024 * 1024)
780 (*count)--;
781
782 return 0;
783 }
784
785 static void free_buffer(struct videobuf_queue *vq, struct tm6000_buffer *buf)
786 {
787 struct tm6000_fh *fh = vq->priv_data;
788 struct tm6000_core *dev = fh->dev;
789 unsigned long flags;
790
791 if (in_interrupt())
792 BUG();
793
794 /* We used to wait for the buffer to finish here, but this didn't work
795 because, as we were keeping the state as VIDEOBUF_QUEUED,
796 videobuf_queue_cancel marked it as finished for us.
797 (Also, it could wedge forever if the hardware was misconfigured.)
798
799 This should be safe; by the time we get here, the buffer isn't
800 queued anymore. If we ever start marking the buffers as
801 VIDEOBUF_ACTIVE, it won't be, though.
802 */
803 spin_lock_irqsave(&dev->slock, flags);
804 if (dev->isoc_ctl.buf == buf)
805 dev->isoc_ctl.buf = NULL;
806 spin_unlock_irqrestore(&dev->slock, flags);
807
808 videobuf_vmalloc_free(&buf->vb);
809 buf->vb.state = VIDEOBUF_NEEDS_INIT;
810 }
811
812 static int
813 buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
814 enum v4l2_field field)
815 {
816 struct tm6000_fh *fh = vq->priv_data;
817 struct tm6000_buffer *buf = container_of(vb, struct tm6000_buffer, vb);
818 struct tm6000_core *dev = fh->dev;
819 int rc = 0;
820
821 BUG_ON(NULL == fh->fmt);
822
823
824 /* FIXME: It assumes depth=2 */
825 /* The only currently supported format is 16 bits/pixel */
826 buf->vb.size = fh->fmt->depth*fh->width*fh->height >> 3;
827 if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size)
828 return -EINVAL;
829
830 if (buf->fmt != fh->fmt ||
831 buf->vb.width != fh->width ||
832 buf->vb.height != fh->height ||
833 buf->vb.field != field) {
834 buf->fmt = fh->fmt;
835 buf->vb.width = fh->width;
836 buf->vb.height = fh->height;
837 buf->vb.field = field;
838 buf->vb.state = VIDEOBUF_NEEDS_INIT;
839 }
840
841 if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
842 rc = videobuf_iolock(vq, &buf->vb, NULL);
843 if (rc != 0)
844 goto fail;
845 }
846
847 if (!dev->isoc_ctl.num_bufs) {
848 rc = tm6000_prepare_isoc(dev);
849 if (rc < 0)
850 goto fail;
851
852 rc = tm6000_start_thread(dev);
853 if (rc < 0)
854 goto fail;
855
856 }
857
858 buf->vb.state = VIDEOBUF_PREPARED;
859 return 0;
860
861 fail:
862 free_buffer(vq, buf);
863 return rc;
864 }
865
866 static void
867 buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
868 {
869 struct tm6000_buffer *buf = container_of(vb, struct tm6000_buffer, vb);
870 struct tm6000_fh *fh = vq->priv_data;
871 struct tm6000_core *dev = fh->dev;
872 struct tm6000_dmaqueue *vidq = &dev->vidq;
873
874 buf->vb.state = VIDEOBUF_QUEUED;
875 list_add_tail(&buf->vb.queue, &vidq->active);
876 }
877
878 static void buffer_release(struct videobuf_queue *vq, struct videobuf_buffer *vb)
879 {
880 struct tm6000_buffer *buf = container_of(vb, struct tm6000_buffer, vb);
881
882 free_buffer(vq, buf);
883 }
884
885 static struct videobuf_queue_ops tm6000_video_qops = {
886 .buf_setup = buffer_setup,
887 .buf_prepare = buffer_prepare,
888 .buf_queue = buffer_queue,
889 .buf_release = buffer_release,
890 };
891
892 /* ------------------------------------------------------------------
893 * IOCTL handling
894 * ------------------------------------------------------------------
895 */
896
897 static bool is_res_read(struct tm6000_core *dev, struct tm6000_fh *fh)
898 {
899 /* Is the current fh handling it? if so, that's OK */
900 if (dev->resources == fh && dev->is_res_read)
901 return true;
902
903 return false;
904 }
905
906 static bool is_res_streaming(struct tm6000_core *dev, struct tm6000_fh *fh)
907 {
908 /* Is the current fh handling it? if so, that's OK */
909 if (dev->resources == fh)
910 return true;
911
912 return false;
913 }
914
915 static bool res_get(struct tm6000_core *dev, struct tm6000_fh *fh,
916 bool is_res_read)
917 {
918 /* Is the current fh handling it? if so, that's OK */
919 if (dev->resources == fh && dev->is_res_read == is_res_read)
920 return true;
921
922 /* is it free? */
923 if (dev->resources)
924 return false;
925
926 /* grab it */
927 dev->resources = fh;
928 dev->is_res_read = is_res_read;
929 dprintk(dev, V4L2_DEBUG_RES_LOCK, "res: get\n");
930 return true;
931 }
932
933 static void res_free(struct tm6000_core *dev, struct tm6000_fh *fh)
934 {
935 /* Is the current fh handling it? if so, that's OK */
936 if (dev->resources != fh)
937 return;
938
939 dev->resources = NULL;
940 dprintk(dev, V4L2_DEBUG_RES_LOCK, "res: put\n");
941 }
942
943 /* ------------------------------------------------------------------
944 * IOCTL vidioc handling
945 * ------------------------------------------------------------------
946 */
947 static int vidioc_querycap(struct file *file, void *priv,
948 struct v4l2_capability *cap)
949 {
950 struct tm6000_core *dev = ((struct tm6000_fh *)priv)->dev;
951
952 strlcpy(cap->driver, "tm6000", sizeof(cap->driver));
953 strlcpy(cap->card, "Trident TVMaster TM5600/6000/6010", sizeof(cap->card));
954 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
955 V4L2_CAP_STREAMING |
956 V4L2_CAP_AUDIO |
957 V4L2_CAP_READWRITE;
958
959 if (dev->tuner_type != TUNER_ABSENT)
960 cap->capabilities |= V4L2_CAP_TUNER;
961
962 return 0;
963 }
964
965 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
966 struct v4l2_fmtdesc *f)
967 {
968 if (unlikely(f->index >= ARRAY_SIZE(format)))
969 return -EINVAL;
970
971 strlcpy(f->description, format[f->index].name, sizeof(f->description));
972 f->pixelformat = format[f->index].fourcc;
973 return 0;
974 }
975
976 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
977 struct v4l2_format *f)
978 {
979 struct tm6000_fh *fh = priv;
980
981 f->fmt.pix.width = fh->width;
982 f->fmt.pix.height = fh->height;
983 f->fmt.pix.field = fh->vb_vidq.field;
984 f->fmt.pix.pixelformat = fh->fmt->fourcc;
985 f->fmt.pix.bytesperline =
986 (f->fmt.pix.width * fh->fmt->depth) >> 3;
987 f->fmt.pix.sizeimage =
988 f->fmt.pix.height * f->fmt.pix.bytesperline;
989
990 return 0;
991 }
992
993 static struct tm6000_fmt *format_by_fourcc(unsigned int fourcc)
994 {
995 unsigned int i;
996
997 for (i = 0; i < ARRAY_SIZE(format); i++)
998 if (format[i].fourcc == fourcc)
999 return format+i;
1000 return NULL;
1001 }
1002
1003 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
1004 struct v4l2_format *f)
1005 {
1006 struct tm6000_core *dev = ((struct tm6000_fh *)priv)->dev;
1007 struct tm6000_fmt *fmt;
1008 enum v4l2_field field;
1009
1010 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
1011 if (NULL == fmt) {
1012 dprintk(dev, V4L2_DEBUG_IOCTL_ARG, "Fourcc format (0x%08x)"
1013 " invalid.\n", f->fmt.pix.pixelformat);
1014 return -EINVAL;
1015 }
1016
1017 field = f->fmt.pix.field;
1018
1019 if (field == V4L2_FIELD_ANY)
1020 field = V4L2_FIELD_SEQ_TB;
1021 else if (V4L2_FIELD_INTERLACED != field) {
1022 dprintk(dev, V4L2_DEBUG_IOCTL_ARG, "Field type invalid.\n");
1023 return -EINVAL;
1024 }
1025
1026 tm6000_get_std_res(dev);
1027
1028 f->fmt.pix.width = dev->width;
1029 f->fmt.pix.height = dev->height;
1030
1031 f->fmt.pix.width &= ~0x01;
1032
1033 f->fmt.pix.field = field;
1034
1035 f->fmt.pix.bytesperline =
1036 (f->fmt.pix.width * fmt->depth) >> 3;
1037 f->fmt.pix.sizeimage =
1038 f->fmt.pix.height * f->fmt.pix.bytesperline;
1039
1040 return 0;
1041 }
1042
1043 /*FIXME: This seems to be generic enough to be at videodev2 */
1044 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
1045 struct v4l2_format *f)
1046 {
1047 struct tm6000_fh *fh = priv;
1048 struct tm6000_core *dev = fh->dev;
1049 int ret = vidioc_try_fmt_vid_cap(file, fh, f);
1050 if (ret < 0)
1051 return ret;
1052
1053 fh->fmt = format_by_fourcc(f->fmt.pix.pixelformat);
1054 fh->width = f->fmt.pix.width;
1055 fh->height = f->fmt.pix.height;
1056 fh->vb_vidq.field = f->fmt.pix.field;
1057 fh->type = f->type;
1058
1059 dev->fourcc = f->fmt.pix.pixelformat;
1060
1061 tm6000_set_fourcc_format(dev);
1062
1063 return 0;
1064 }
1065
1066 static int vidioc_reqbufs(struct file *file, void *priv,
1067 struct v4l2_requestbuffers *p)
1068 {
1069 struct tm6000_fh *fh = priv;
1070
1071 return videobuf_reqbufs(&fh->vb_vidq, p);
1072 }
1073
1074 static int vidioc_querybuf(struct file *file, void *priv,
1075 struct v4l2_buffer *p)
1076 {
1077 struct tm6000_fh *fh = priv;
1078
1079 return videobuf_querybuf(&fh->vb_vidq, p);
1080 }
1081
1082 static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
1083 {
1084 struct tm6000_fh *fh = priv;
1085
1086 return videobuf_qbuf(&fh->vb_vidq, p);
1087 }
1088
1089 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
1090 {
1091 struct tm6000_fh *fh = priv;
1092
1093 return videobuf_dqbuf(&fh->vb_vidq, p,
1094 file->f_flags & O_NONBLOCK);
1095 }
1096
1097 static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
1098 {
1099 struct tm6000_fh *fh = priv;
1100 struct tm6000_core *dev = fh->dev;
1101
1102 if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1103 return -EINVAL;
1104 if (i != fh->type)
1105 return -EINVAL;
1106
1107 if (!res_get(dev, fh, false))
1108 return -EBUSY;
1109 return videobuf_streamon(&fh->vb_vidq);
1110 }
1111
1112 static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
1113 {
1114 struct tm6000_fh *fh = priv;
1115 struct tm6000_core *dev = fh->dev;
1116
1117 if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1118 return -EINVAL;
1119
1120 if (i != fh->type)
1121 return -EINVAL;
1122
1123 videobuf_streamoff(&fh->vb_vidq);
1124 res_free(dev, fh);
1125
1126 return 0;
1127 }
1128
1129 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *norm)
1130 {
1131 int rc = 0;
1132 struct tm6000_fh *fh = priv;
1133 struct tm6000_core *dev = fh->dev;
1134
1135 dev->norm = *norm;
1136 rc = tm6000_init_analog_mode(dev);
1137
1138 fh->width = dev->width;
1139 fh->height = dev->height;
1140
1141 if (rc < 0)
1142 return rc;
1143
1144 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_std, dev->norm);
1145
1146 return 0;
1147 }
1148
1149 static const char *iname[] = {
1150 [TM6000_INPUT_TV] = "Television",
1151 [TM6000_INPUT_COMPOSITE1] = "Composite 1",
1152 [TM6000_INPUT_COMPOSITE2] = "Composite 2",
1153 [TM6000_INPUT_SVIDEO] = "S-Video",
1154 };
1155
1156 static int vidioc_enum_input(struct file *file, void *priv,
1157 struct v4l2_input *i)
1158 {
1159 struct tm6000_fh *fh = priv;
1160 struct tm6000_core *dev = fh->dev;
1161 unsigned int n;
1162
1163 n = i->index;
1164 if (n >= 3)
1165 return -EINVAL;
1166
1167 if (!dev->vinput[n].type)
1168 return -EINVAL;
1169
1170 i->index = n;
1171
1172 if (dev->vinput[n].type == TM6000_INPUT_TV)
1173 i->type = V4L2_INPUT_TYPE_TUNER;
1174 else
1175 i->type = V4L2_INPUT_TYPE_CAMERA;
1176
1177 strcpy(i->name, iname[dev->vinput[n].type]);
1178
1179 i->std = TM6000_STD;
1180
1181 return 0;
1182 }
1183
1184 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1185 {
1186 struct tm6000_fh *fh = priv;
1187 struct tm6000_core *dev = fh->dev;
1188
1189 *i = dev->input;
1190
1191 return 0;
1192 }
1193
1194 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1195 {
1196 struct tm6000_fh *fh = priv;
1197 struct tm6000_core *dev = fh->dev;
1198 int rc = 0;
1199
1200 if (i >= 3)
1201 return -EINVAL;
1202 if (!dev->vinput[i].type)
1203 return -EINVAL;
1204
1205 dev->input = i;
1206
1207 rc = vidioc_s_std(file, priv, &dev->vfd->current_norm);
1208
1209 return rc;
1210 }
1211
1212 /* --- controls ---------------------------------------------- */
1213 static int vidioc_queryctrl(struct file *file, void *priv,
1214 struct v4l2_queryctrl *qc)
1215 {
1216 int i;
1217
1218 for (i = 0; i < ARRAY_SIZE(tm6000_qctrl); i++)
1219 if (qc->id && qc->id == tm6000_qctrl[i].id) {
1220 memcpy(qc, &(tm6000_qctrl[i]),
1221 sizeof(*qc));
1222 return 0;
1223 }
1224
1225 return -EINVAL;
1226 }
1227
1228 static int vidioc_g_ctrl(struct file *file, void *priv,
1229 struct v4l2_control *ctrl)
1230 {
1231 struct tm6000_fh *fh = priv;
1232 struct tm6000_core *dev = fh->dev;
1233 int val;
1234
1235 /* FIXME: Probably, those won't work! Maybe we need shadow regs */
1236 switch (ctrl->id) {
1237 case V4L2_CID_CONTRAST:
1238 val = tm6000_get_reg(dev, TM6010_REQ07_R08_LUMA_CONTRAST_ADJ, 0);
1239 break;
1240 case V4L2_CID_BRIGHTNESS:
1241 val = tm6000_get_reg(dev, TM6010_REQ07_R09_LUMA_BRIGHTNESS_ADJ, 0);
1242 return 0;
1243 case V4L2_CID_SATURATION:
1244 val = tm6000_get_reg(dev, TM6010_REQ07_R0A_CHROMA_SATURATION_ADJ, 0);
1245 return 0;
1246 case V4L2_CID_HUE:
1247 val = tm6000_get_reg(dev, TM6010_REQ07_R0B_CHROMA_HUE_PHASE_ADJ, 0);
1248 return 0;
1249 case V4L2_CID_AUDIO_MUTE:
1250 val = dev->ctl_mute;
1251 return 0;
1252 case V4L2_CID_AUDIO_VOLUME:
1253 val = dev->ctl_volume;
1254 return 0;
1255 default:
1256 return -EINVAL;
1257 }
1258
1259 if (val < 0)
1260 return val;
1261
1262 ctrl->value = val;
1263
1264 return 0;
1265 }
1266 static int vidioc_s_ctrl(struct file *file, void *priv,
1267 struct v4l2_control *ctrl)
1268 {
1269 struct tm6000_fh *fh = priv;
1270 struct tm6000_core *dev = fh->dev;
1271 u8 val = ctrl->value;
1272
1273 switch (ctrl->id) {
1274 case V4L2_CID_CONTRAST:
1275 tm6000_set_reg(dev, TM6010_REQ07_R08_LUMA_CONTRAST_ADJ, val);
1276 return 0;
1277 case V4L2_CID_BRIGHTNESS:
1278 tm6000_set_reg(dev, TM6010_REQ07_R09_LUMA_BRIGHTNESS_ADJ, val);
1279 return 0;
1280 case V4L2_CID_SATURATION:
1281 tm6000_set_reg(dev, TM6010_REQ07_R0A_CHROMA_SATURATION_ADJ, val);
1282 return 0;
1283 case V4L2_CID_HUE:
1284 tm6000_set_reg(dev, TM6010_REQ07_R0B_CHROMA_HUE_PHASE_ADJ, val);
1285 return 0;
1286 case V4L2_CID_AUDIO_MUTE:
1287 dev->ctl_mute = val;
1288 tm6000_tvaudio_set_mute(dev, val);
1289 return 0;
1290 case V4L2_CID_AUDIO_VOLUME:
1291 dev->ctl_volume = val;
1292 tm6000_set_volume(dev, val);
1293 return 0;
1294 }
1295 return -EINVAL;
1296 }
1297
1298 static int vidioc_g_tuner(struct file *file, void *priv,
1299 struct v4l2_tuner *t)
1300 {
1301 struct tm6000_fh *fh = priv;
1302 struct tm6000_core *dev = fh->dev;
1303
1304 if (unlikely(UNSET == dev->tuner_type))
1305 return -EINVAL;
1306 if (0 != t->index)
1307 return -EINVAL;
1308
1309 strcpy(t->name, "Television");
1310 t->type = V4L2_TUNER_ANALOG_TV;
1311 t->capability = V4L2_TUNER_CAP_NORM;
1312 t->rangehigh = 0xffffffffUL;
1313 t->rxsubchans = V4L2_TUNER_SUB_STEREO;
1314
1315 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_tuner, t);
1316
1317 t->audmode = dev->amode;
1318
1319 return 0;
1320 }
1321
1322 static int vidioc_s_tuner(struct file *file, void *priv,
1323 struct v4l2_tuner *t)
1324 {
1325 struct tm6000_fh *fh = priv;
1326 struct tm6000_core *dev = fh->dev;
1327
1328 if (UNSET == dev->tuner_type)
1329 return -EINVAL;
1330 if (0 != t->index)
1331 return -EINVAL;
1332
1333 dev->amode = t->audmode;
1334 dprintk(dev, 3, "audio mode: %x\n", t->audmode);
1335
1336 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_tuner, t);
1337
1338 return 0;
1339 }
1340
1341 static int vidioc_g_frequency(struct file *file, void *priv,
1342 struct v4l2_frequency *f)
1343 {
1344 struct tm6000_fh *fh = priv;
1345 struct tm6000_core *dev = fh->dev;
1346
1347 if (unlikely(UNSET == dev->tuner_type))
1348 return -EINVAL;
1349
1350 f->type = fh->radio ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
1351 f->frequency = dev->freq;
1352
1353 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_frequency, f);
1354
1355 return 0;
1356 }
1357
1358 static int vidioc_s_frequency(struct file *file, void *priv,
1359 struct v4l2_frequency *f)
1360 {
1361 struct tm6000_fh *fh = priv;
1362 struct tm6000_core *dev = fh->dev;
1363
1364 if (unlikely(UNSET == dev->tuner_type))
1365 return -EINVAL;
1366 if (unlikely(f->tuner != 0))
1367 return -EINVAL;
1368 if (0 == fh->radio && V4L2_TUNER_ANALOG_TV != f->type)
1369 return -EINVAL;
1370 if (1 == fh->radio && V4L2_TUNER_RADIO != f->type)
1371 return -EINVAL;
1372
1373 dev->freq = f->frequency;
1374 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_frequency, f);
1375
1376 return 0;
1377 }
1378
1379 static int radio_querycap(struct file *file, void *priv,
1380 struct v4l2_capability *cap)
1381 {
1382 struct tm6000_fh *fh = file->private_data;
1383 struct tm6000_core *dev = fh->dev;
1384
1385 strcpy(cap->driver, "tm6000");
1386 strlcpy(cap->card, dev->name, sizeof(dev->name));
1387 sprintf(cap->bus_info, "USB%04x:%04x",
1388 le16_to_cpu(dev->udev->descriptor.idVendor),
1389 le16_to_cpu(dev->udev->descriptor.idProduct));
1390 cap->version = dev->dev_type;
1391 cap->capabilities = V4L2_CAP_TUNER |
1392 V4L2_CAP_AUDIO |
1393 V4L2_CAP_RADIO |
1394 V4L2_CAP_READWRITE |
1395 V4L2_CAP_STREAMING;
1396
1397 return 0;
1398 }
1399
1400 static int radio_g_tuner(struct file *file, void *priv,
1401 struct v4l2_tuner *t)
1402 {
1403 struct tm6000_fh *fh = file->private_data;
1404 struct tm6000_core *dev = fh->dev;
1405
1406 if (0 != t->index)
1407 return -EINVAL;
1408
1409 memset(t, 0, sizeof(*t));
1410 strcpy(t->name, "Radio");
1411 t->type = V4L2_TUNER_RADIO;
1412 t->rxsubchans = V4L2_TUNER_SUB_STEREO;
1413
1414 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_tuner, t);
1415
1416 return 0;
1417 }
1418
1419 static int radio_s_tuner(struct file *file, void *priv,
1420 struct v4l2_tuner *t)
1421 {
1422 struct tm6000_fh *fh = file->private_data;
1423 struct tm6000_core *dev = fh->dev;
1424
1425 if (0 != t->index)
1426 return -EINVAL;
1427
1428 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_tuner, t);
1429
1430 return 0;
1431 }
1432
1433 static int radio_enum_input(struct file *file, void *priv,
1434 struct v4l2_input *i)
1435 {
1436 struct tm6000_fh *fh = priv;
1437 struct tm6000_core *dev = fh->dev;
1438
1439 if (i->index != 0)
1440 return -EINVAL;
1441
1442 if (!dev->rinput.type)
1443 return -EINVAL;
1444
1445 strcpy(i->name, "Radio");
1446 i->type = V4L2_INPUT_TYPE_TUNER;
1447
1448 return 0;
1449 }
1450
1451 static int radio_g_input(struct file *filp, void *priv, unsigned int *i)
1452 {
1453 struct tm6000_fh *fh = priv;
1454 struct tm6000_core *dev = fh->dev;
1455
1456 if (dev->input != 5)
1457 return -EINVAL;
1458
1459 *i = dev->input - 5;
1460
1461 return 0;
1462 }
1463
1464 static int radio_g_audio(struct file *file, void *priv,
1465 struct v4l2_audio *a)
1466 {
1467 memset(a, 0, sizeof(*a));
1468 strcpy(a->name, "Radio");
1469 return 0;
1470 }
1471
1472 static int radio_s_audio(struct file *file, void *priv,
1473 const struct v4l2_audio *a)
1474 {
1475 return 0;
1476 }
1477
1478 static int radio_s_input(struct file *filp, void *priv, unsigned int i)
1479 {
1480 struct tm6000_fh *fh = priv;
1481 struct tm6000_core *dev = fh->dev;
1482
1483 if (i)
1484 return -EINVAL;
1485
1486 if (!dev->rinput.type)
1487 return -EINVAL;
1488
1489 dev->input = i + 5;
1490
1491 return 0;
1492 }
1493
1494 static int radio_s_std(struct file *file, void *fh, v4l2_std_id *norm)
1495 {
1496 return 0;
1497 }
1498
1499 static int radio_queryctrl(struct file *file, void *priv,
1500 struct v4l2_queryctrl *c)
1501 {
1502 const struct v4l2_queryctrl *ctrl;
1503
1504 if (c->id < V4L2_CID_BASE ||
1505 c->id >= V4L2_CID_LASTP1)
1506 return -EINVAL;
1507 if (c->id == V4L2_CID_AUDIO_MUTE) {
1508 ctrl = ctrl_by_id(c->id);
1509 *c = *ctrl;
1510 } else
1511 *c = no_ctrl;
1512
1513 return 0;
1514 }
1515
1516 /* ------------------------------------------------------------------
1517 File operations for the device
1518 ------------------------------------------------------------------*/
1519
1520 static int __tm6000_open(struct file *file)
1521 {
1522 struct video_device *vdev = video_devdata(file);
1523 struct tm6000_core *dev = video_drvdata(file);
1524 struct tm6000_fh *fh;
1525 enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1526 int i, rc;
1527 int radio = 0;
1528
1529 dprintk(dev, V4L2_DEBUG_OPEN, "tm6000: open called (dev=%s)\n",
1530 video_device_node_name(vdev));
1531
1532 switch (vdev->vfl_type) {
1533 case VFL_TYPE_GRABBER:
1534 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1535 break;
1536 case VFL_TYPE_VBI:
1537 type = V4L2_BUF_TYPE_VBI_CAPTURE;
1538 break;
1539 case VFL_TYPE_RADIO:
1540 radio = 1;
1541 break;
1542 }
1543
1544 /* If more than one user, mutex should be added */
1545 dev->users++;
1546
1547 dprintk(dev, V4L2_DEBUG_OPEN, "open dev=%s type=%s users=%d\n",
1548 video_device_node_name(vdev), v4l2_type_names[type],
1549 dev->users);
1550
1551 /* allocate + initialize per filehandle data */
1552 fh = kzalloc(sizeof(*fh), GFP_KERNEL);
1553 if (NULL == fh) {
1554 dev->users--;
1555 return -ENOMEM;
1556 }
1557
1558 file->private_data = fh;
1559 fh->dev = dev;
1560 fh->radio = radio;
1561 dev->radio = radio;
1562 fh->type = type;
1563 dev->fourcc = format[0].fourcc;
1564
1565 fh->fmt = format_by_fourcc(dev->fourcc);
1566
1567 tm6000_get_std_res(dev);
1568
1569 fh->width = dev->width;
1570 fh->height = dev->height;
1571
1572 dprintk(dev, V4L2_DEBUG_OPEN, "Open: fh=0x%08lx, dev=0x%08lx, "
1573 "dev->vidq=0x%08lx\n",
1574 (unsigned long)fh, (unsigned long)dev,
1575 (unsigned long)&dev->vidq);
1576 dprintk(dev, V4L2_DEBUG_OPEN, "Open: list_empty "
1577 "queued=%d\n", list_empty(&dev->vidq.queued));
1578 dprintk(dev, V4L2_DEBUG_OPEN, "Open: list_empty "
1579 "active=%d\n", list_empty(&dev->vidq.active));
1580
1581 /* initialize hardware on analog mode */
1582 rc = tm6000_init_analog_mode(dev);
1583 if (rc < 0)
1584 return rc;
1585
1586 if (dev->mode != TM6000_MODE_ANALOG) {
1587 /* Put all controls at a sane state */
1588 for (i = 0; i < ARRAY_SIZE(tm6000_qctrl); i++)
1589 qctl_regs[i] = tm6000_qctrl[i].default_value;
1590
1591 dev->mode = TM6000_MODE_ANALOG;
1592 }
1593
1594 if (!fh->radio) {
1595 videobuf_queue_vmalloc_init(&fh->vb_vidq, &tm6000_video_qops,
1596 NULL, &dev->slock,
1597 fh->type,
1598 V4L2_FIELD_INTERLACED,
1599 sizeof(struct tm6000_buffer), fh, &dev->lock);
1600 } else {
1601 dprintk(dev, V4L2_DEBUG_OPEN, "video_open: setting radio device\n");
1602 dev->input = 5;
1603 tm6000_set_audio_rinput(dev);
1604 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_radio);
1605 tm6000_prepare_isoc(dev);
1606 tm6000_start_thread(dev);
1607 }
1608
1609 return 0;
1610 }
1611
1612 static int tm6000_open(struct file *file)
1613 {
1614 struct video_device *vdev = video_devdata(file);
1615 int res;
1616
1617 mutex_lock(vdev->lock);
1618 res = __tm6000_open(file);
1619 mutex_unlock(vdev->lock);
1620 return res;
1621 }
1622
1623 static ssize_t
1624 tm6000_read(struct file *file, char __user *data, size_t count, loff_t *pos)
1625 {
1626 struct tm6000_fh *fh = file->private_data;
1627 struct tm6000_core *dev = fh->dev;
1628
1629 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1630 int res;
1631
1632 if (!res_get(fh->dev, fh, true))
1633 return -EBUSY;
1634
1635 if (mutex_lock_interruptible(&dev->lock))
1636 return -ERESTARTSYS;
1637 res = videobuf_read_stream(&fh->vb_vidq, data, count, pos, 0,
1638 file->f_flags & O_NONBLOCK);
1639 mutex_unlock(&dev->lock);
1640 return res;
1641 }
1642 return 0;
1643 }
1644
1645 static unsigned int
1646 __tm6000_poll(struct file *file, struct poll_table_struct *wait)
1647 {
1648 struct tm6000_fh *fh = file->private_data;
1649 struct tm6000_buffer *buf;
1650
1651 if (V4L2_BUF_TYPE_VIDEO_CAPTURE != fh->type)
1652 return POLLERR;
1653
1654 if (!!is_res_streaming(fh->dev, fh))
1655 return POLLERR;
1656
1657 if (!is_res_read(fh->dev, fh)) {
1658 /* streaming capture */
1659 if (list_empty(&fh->vb_vidq.stream))
1660 return POLLERR;
1661 buf = list_entry(fh->vb_vidq.stream.next, struct tm6000_buffer, vb.stream);
1662 } else {
1663 /* read() capture */
1664 return videobuf_poll_stream(file, &fh->vb_vidq, wait);
1665 }
1666 poll_wait(file, &buf->vb.done, wait);
1667 if (buf->vb.state == VIDEOBUF_DONE ||
1668 buf->vb.state == VIDEOBUF_ERROR)
1669 return POLLIN | POLLRDNORM;
1670 return 0;
1671 }
1672
1673 static unsigned int tm6000_poll(struct file *file, struct poll_table_struct *wait)
1674 {
1675 struct tm6000_fh *fh = file->private_data;
1676 struct tm6000_core *dev = fh->dev;
1677 unsigned int res;
1678
1679 mutex_lock(&dev->lock);
1680 res = __tm6000_poll(file, wait);
1681 mutex_unlock(&dev->lock);
1682 return res;
1683 }
1684
1685 static int tm6000_release(struct file *file)
1686 {
1687 struct tm6000_fh *fh = file->private_data;
1688 struct tm6000_core *dev = fh->dev;
1689 struct video_device *vdev = video_devdata(file);
1690
1691 dprintk(dev, V4L2_DEBUG_OPEN, "tm6000: close called (dev=%s, users=%d)\n",
1692 video_device_node_name(vdev), dev->users);
1693
1694 mutex_lock(&dev->lock);
1695 dev->users--;
1696
1697 res_free(dev, fh);
1698
1699 if (!dev->users) {
1700 tm6000_uninit_isoc(dev);
1701
1702 /* Stop interrupt USB pipe */
1703 tm6000_ir_int_stop(dev);
1704
1705 usb_reset_configuration(dev->udev);
1706
1707 if (dev->int_in.endp)
1708 usb_set_interface(dev->udev,
1709 dev->isoc_in.bInterfaceNumber, 2);
1710 else
1711 usb_set_interface(dev->udev,
1712 dev->isoc_in.bInterfaceNumber, 0);
1713
1714 /* Start interrupt USB pipe */
1715 tm6000_ir_int_start(dev);
1716
1717 if (!fh->radio)
1718 videobuf_mmap_free(&fh->vb_vidq);
1719 }
1720
1721 kfree(fh);
1722 mutex_unlock(&dev->lock);
1723
1724 return 0;
1725 }
1726
1727 static int tm6000_mmap(struct file *file, struct vm_area_struct * vma)
1728 {
1729 struct tm6000_fh *fh = file->private_data;
1730 struct tm6000_core *dev = fh->dev;
1731 int res;
1732
1733 if (mutex_lock_interruptible(&dev->lock))
1734 return -ERESTARTSYS;
1735 res = videobuf_mmap_mapper(&fh->vb_vidq, vma);
1736 mutex_unlock(&dev->lock);
1737 return res;
1738 }
1739
1740 static struct v4l2_file_operations tm6000_fops = {
1741 .owner = THIS_MODULE,
1742 .open = tm6000_open,
1743 .release = tm6000_release,
1744 .unlocked_ioctl = video_ioctl2, /* V4L2 ioctl handler */
1745 .read = tm6000_read,
1746 .poll = tm6000_poll,
1747 .mmap = tm6000_mmap,
1748 };
1749
1750 static const struct v4l2_ioctl_ops video_ioctl_ops = {
1751 .vidioc_querycap = vidioc_querycap,
1752 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1753 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1754 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1755 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1756 .vidioc_s_std = vidioc_s_std,
1757 .vidioc_enum_input = vidioc_enum_input,
1758 .vidioc_g_input = vidioc_g_input,
1759 .vidioc_s_input = vidioc_s_input,
1760 .vidioc_queryctrl = vidioc_queryctrl,
1761 .vidioc_g_ctrl = vidioc_g_ctrl,
1762 .vidioc_s_ctrl = vidioc_s_ctrl,
1763 .vidioc_g_tuner = vidioc_g_tuner,
1764 .vidioc_s_tuner = vidioc_s_tuner,
1765 .vidioc_g_frequency = vidioc_g_frequency,
1766 .vidioc_s_frequency = vidioc_s_frequency,
1767 .vidioc_streamon = vidioc_streamon,
1768 .vidioc_streamoff = vidioc_streamoff,
1769 .vidioc_reqbufs = vidioc_reqbufs,
1770 .vidioc_querybuf = vidioc_querybuf,
1771 .vidioc_qbuf = vidioc_qbuf,
1772 .vidioc_dqbuf = vidioc_dqbuf,
1773 };
1774
1775 static struct video_device tm6000_template = {
1776 .name = "tm6000",
1777 .fops = &tm6000_fops,
1778 .ioctl_ops = &video_ioctl_ops,
1779 .release = video_device_release,
1780 .tvnorms = TM6000_STD,
1781 .current_norm = V4L2_STD_NTSC_M,
1782 };
1783
1784 static const struct v4l2_file_operations radio_fops = {
1785 .owner = THIS_MODULE,
1786 .open = tm6000_open,
1787 .release = tm6000_release,
1788 .unlocked_ioctl = video_ioctl2,
1789 };
1790
1791 static const struct v4l2_ioctl_ops radio_ioctl_ops = {
1792 .vidioc_querycap = radio_querycap,
1793 .vidioc_g_tuner = radio_g_tuner,
1794 .vidioc_enum_input = radio_enum_input,
1795 .vidioc_g_audio = radio_g_audio,
1796 .vidioc_s_tuner = radio_s_tuner,
1797 .vidioc_s_audio = radio_s_audio,
1798 .vidioc_s_input = radio_s_input,
1799 .vidioc_s_std = radio_s_std,
1800 .vidioc_queryctrl = radio_queryctrl,
1801 .vidioc_g_input = radio_g_input,
1802 .vidioc_g_ctrl = vidioc_g_ctrl,
1803 .vidioc_s_ctrl = vidioc_s_ctrl,
1804 .vidioc_g_frequency = vidioc_g_frequency,
1805 .vidioc_s_frequency = vidioc_s_frequency,
1806 };
1807
1808 static struct video_device tm6000_radio_template = {
1809 .name = "tm6000",
1810 .fops = &radio_fops,
1811 .ioctl_ops = &radio_ioctl_ops,
1812 };
1813
1814 /* -----------------------------------------------------------------
1815 * Initialization and module stuff
1816 * ------------------------------------------------------------------
1817 */
1818
1819 static struct video_device *vdev_init(struct tm6000_core *dev,
1820 const struct video_device
1821 *template, const char *type_name)
1822 {
1823 struct video_device *vfd;
1824
1825 vfd = video_device_alloc();
1826 if (NULL == vfd)
1827 return NULL;
1828
1829 *vfd = *template;
1830 vfd->v4l2_dev = &dev->v4l2_dev;
1831 vfd->release = video_device_release;
1832 vfd->debug = tm6000_debug;
1833 vfd->lock = &dev->lock;
1834
1835 snprintf(vfd->name, sizeof(vfd->name), "%s %s", dev->name, type_name);
1836
1837 video_set_drvdata(vfd, dev);
1838 return vfd;
1839 }
1840
1841 int tm6000_v4l2_register(struct tm6000_core *dev)
1842 {
1843 int ret = -1;
1844
1845 dev->vfd = vdev_init(dev, &tm6000_template, "video");
1846
1847 if (!dev->vfd) {
1848 printk(KERN_INFO "%s: can't register video device\n",
1849 dev->name);
1850 return -ENOMEM;
1851 }
1852
1853 /* init video dma queues */
1854 INIT_LIST_HEAD(&dev->vidq.active);
1855 INIT_LIST_HEAD(&dev->vidq.queued);
1856
1857 ret = video_register_device(dev->vfd, VFL_TYPE_GRABBER, video_nr);
1858
1859 if (ret < 0) {
1860 printk(KERN_INFO "%s: can't register video device\n",
1861 dev->name);
1862 return ret;
1863 }
1864
1865 printk(KERN_INFO "%s: registered device %s\n",
1866 dev->name, video_device_node_name(dev->vfd));
1867
1868 if (dev->caps.has_radio) {
1869 dev->radio_dev = vdev_init(dev, &tm6000_radio_template,
1870 "radio");
1871 if (!dev->radio_dev) {
1872 printk(KERN_INFO "%s: can't register radio device\n",
1873 dev->name);
1874 ret = -ENXIO;
1875 return ret; /* FIXME release resource */
1876 }
1877
1878 ret = video_register_device(dev->radio_dev, VFL_TYPE_RADIO,
1879 radio_nr);
1880 if (ret < 0) {
1881 printk(KERN_INFO "%s: can't register radio device\n",
1882 dev->name);
1883 return ret; /* FIXME release resource */
1884 }
1885
1886 printk(KERN_INFO "%s: registered device %s\n",
1887 dev->name, video_device_node_name(dev->radio_dev));
1888 }
1889
1890 printk(KERN_INFO "Trident TVMaster TM5600/TM6000/TM6010 USB2 board (Load status: %d)\n", ret);
1891 return ret;
1892 }
1893
1894 int tm6000_v4l2_unregister(struct tm6000_core *dev)
1895 {
1896 video_unregister_device(dev->vfd);
1897
1898 /* if URB buffers are still allocated free them now */
1899 tm6000_free_urb_buffers(dev);
1900
1901 if (dev->radio_dev) {
1902 if (video_is_registered(dev->radio_dev))
1903 video_unregister_device(dev->radio_dev);
1904 else
1905 video_device_release(dev->radio_dev);
1906 dev->radio_dev = NULL;
1907 }
1908
1909 return 0;
1910 }
1911
1912 int tm6000_v4l2_exit(void)
1913 {
1914 return 0;
1915 }
1916
1917 module_param(video_nr, int, 0);
1918 MODULE_PARM_DESC(video_nr, "Allow changing video device number");
1919
1920 module_param_named(debug, tm6000_debug, int, 0444);
1921 MODULE_PARM_DESC(debug, "activates debug info");
1922
1923 module_param(vid_limit, int, 0644);
1924 MODULE_PARM_DESC(vid_limit, "capture memory limit in megabytes");
1925
1926 module_param(keep_urb, bool, 0);
1927 MODULE_PARM_DESC(keep_urb, "Keep urb buffers allocated even when the device is closed by the user");
Linux kernel - Deliverables
This page took 0.084402 seconds and 6 git commands to generate.