?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
KVM: PPC: Book3S HV: Flush link stack on guest exit to host kernel
[linux/fpc-iii.git] / drivers / media / usb / cx231xx / cx231xx-video.c
blob9b51f07a729e4e949b309082912600e3ec6ecf40
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 cx231xx-video.c - driver for Conexant Cx23100/101/102
4 USB video capture devices
5
6 Copyright (C) 2008 <srinivasa.deevi at conexant dot com>
7 Based on em28xx driver
8 Based on cx23885 driver
9 Based on cx88 driver
10
11 */
12
13 #include "cx231xx.h"
14 #include <linux/init.h>
15 #include <linux/list.h>
16 #include <linux/module.h>
17 #include <linux/kernel.h>
18 #include <linux/bitmap.h>
19 #include <linux/i2c.h>
20 #include <linux/mm.h>
21 #include <linux/mutex.h>
22 #include <linux/slab.h>
23
24 #include <media/v4l2-common.h>
25 #include <media/v4l2-ioctl.h>
26 #include <media/v4l2-event.h>
27 #include <media/drv-intf/msp3400.h>
28 #include <media/tuner.h>
29
30 #include <media/dvb_frontend.h>
31
32 #include "cx231xx-vbi.h"
33
34 #define CX231XX_VERSION "0.0.3"
35
36 #define DRIVER_AUTHOR "Srinivasa Deevi <srinivasa.deevi@conexant.com>"
37 #define DRIVER_DESC "Conexant cx231xx based USB video device driver"
38
39 #define cx231xx_videodbg(fmt, arg...) do {\
40 if (video_debug) \
41 printk(KERN_INFO "%s %s :"fmt, \
42 dev->name, __func__ , ##arg); } while (0)
43
44 static unsigned int isoc_debug;
45 module_param(isoc_debug, int, 0644);
46 MODULE_PARM_DESC(isoc_debug, "enable debug messages [isoc transfers]");
47
48 #define cx231xx_isocdbg(fmt, arg...) \
49 do {\
50 if (isoc_debug) { \
51 printk(KERN_INFO "%s %s :"fmt, \
52 dev->name, __func__ , ##arg); \
53 } \
54 } while (0)
55
56 MODULE_AUTHOR(DRIVER_AUTHOR);
57 MODULE_DESCRIPTION(DRIVER_DESC);
58 MODULE_LICENSE("GPL");
59 MODULE_VERSION(CX231XX_VERSION);
60
61 static unsigned int card[] = {[0 ... (CX231XX_MAXBOARDS - 1)] = UNSET };
62 static unsigned int video_nr[] = {[0 ... (CX231XX_MAXBOARDS - 1)] = UNSET };
63 static unsigned int vbi_nr[] = {[0 ... (CX231XX_MAXBOARDS - 1)] = UNSET };
64 static unsigned int radio_nr[] = {[0 ... (CX231XX_MAXBOARDS - 1)] = UNSET };
65
66 module_param_array(card, int, NULL, 0444);
67 module_param_array(video_nr, int, NULL, 0444);
68 module_param_array(vbi_nr, int, NULL, 0444);
69 module_param_array(radio_nr, int, NULL, 0444);
70
71 MODULE_PARM_DESC(card, "card type");
72 MODULE_PARM_DESC(video_nr, "video device numbers");
73 MODULE_PARM_DESC(vbi_nr, "vbi device numbers");
74 MODULE_PARM_DESC(radio_nr, "radio device numbers");
75
76 static unsigned int video_debug;
77 module_param(video_debug, int, 0644);
78 MODULE_PARM_DESC(video_debug, "enable debug messages [video]");
79
80 /* supported video standards */
81 static struct cx231xx_fmt format[] = {
82 {
83 .fourcc = V4L2_PIX_FMT_YUYV,
84 .depth = 16,
85 .reg = 0,
86 },
87 };
88
89
90 static int cx231xx_enable_analog_tuner(struct cx231xx *dev)
91 {
92 #ifdef CONFIG_MEDIA_CONTROLLER
93 struct media_device *mdev = dev->media_dev;
94 struct media_entity *entity, *decoder = NULL, *source;
95 struct media_link *link, *found_link = NULL;
96 int ret, active_links = 0;
97
98 if (!mdev)
99 return 0;
100
101 /*
102 * This will find the tuner that is connected into the decoder.
103 * Technically, this is not 100% correct, as the device may be
104 * using an analog input instead of the tuner. However, as we can't
105 * do DVB streaming while the DMA engine is being used for V4L2,
106 * this should be enough for the actual needs.
107 */
108 media_device_for_each_entity(entity, mdev) {
109 if (entity->function == MEDIA_ENT_F_ATV_DECODER) {
110 decoder = entity;
111 break;
112 }
113 }
114 if (!decoder)
115 return 0;
116
117 list_for_each_entry(link, &decoder->links, list) {
118 if (link->sink->entity == decoder) {
119 found_link = link;
120 if (link->flags & MEDIA_LNK_FL_ENABLED)
121 active_links++;
122 break;
123 }
124 }
125
126 if (active_links == 1 || !found_link)
127 return 0;
128
129 source = found_link->source->entity;
130 list_for_each_entry(link, &source->links, list) {
131 struct media_entity *sink;
132 int flags = 0;
133
134 sink = link->sink->entity;
135
136 if (sink == entity)
137 flags = MEDIA_LNK_FL_ENABLED;
138
139 ret = media_entity_setup_link(link, flags);
140 if (ret) {
141 dev_err(dev->dev,
142 "Couldn't change link %s->%s to %s. Error %d\n",
143 source->name, sink->name,
144 flags ? "enabled" : "disabled",
145 ret);
146 return ret;
147 } else
148 dev_dbg(dev->dev,
149 "link %s->%s was %s\n",
150 source->name, sink->name,
151 flags ? "ENABLED" : "disabled");
152 }
153 #endif
154 return 0;
155 }
156
157 /* ------------------------------------------------------------------
158 Video buffer and parser functions
159 ------------------------------------------------------------------*/
160
161 /*
162 * Announces that a buffer were filled and request the next
163 */
164 static inline void buffer_filled(struct cx231xx *dev,
165 struct cx231xx_dmaqueue *dma_q,
166 struct cx231xx_buffer *buf)
167 {
168 /* Advice that buffer was filled */
169 cx231xx_isocdbg("[%p/%d] wakeup\n", buf, buf->vb.i);
170 buf->vb.state = VIDEOBUF_DONE;
171 buf->vb.field_count++;
172 buf->vb.ts = ktime_get_ns();
173
174 if (dev->USE_ISO)
175 dev->video_mode.isoc_ctl.buf = NULL;
176 else
177 dev->video_mode.bulk_ctl.buf = NULL;
178
179 list_del(&buf->vb.queue);
180 wake_up(&buf->vb.done);
181 }
182
183 static inline void print_err_status(struct cx231xx *dev, int packet, int status)
184 {
185 char *errmsg = "Unknown";
186
187 switch (status) {
188 case -ENOENT:
189 errmsg = "unlinked synchronously";
190 break;
191 case -ECONNRESET:
192 errmsg = "unlinked asynchronously";
193 break;
194 case -ENOSR:
195 errmsg = "Buffer error (overrun)";
196 break;
197 case -EPIPE:
198 errmsg = "Stalled (device not responding)";
199 break;
200 case -EOVERFLOW:
201 errmsg = "Babble (bad cable?)";
202 break;
203 case -EPROTO:
204 errmsg = "Bit-stuff error (bad cable?)";
205 break;
206 case -EILSEQ:
207 errmsg = "CRC/Timeout (could be anything)";
208 break;
209 case -ETIME:
210 errmsg = "Device does not respond";
211 break;
212 }
213 if (packet < 0) {
214 cx231xx_isocdbg("URB status %d [%s].\n", status, errmsg);
215 } else {
216 cx231xx_isocdbg("URB packet %d, status %d [%s].\n",
217 packet, status, errmsg);
218 }
219 }
220
221 /*
222 * video-buf generic routine to get the next available buffer
223 */
224 static inline void get_next_buf(struct cx231xx_dmaqueue *dma_q,
225 struct cx231xx_buffer **buf)
226 {
227 struct cx231xx_video_mode *vmode =
228 container_of(dma_q, struct cx231xx_video_mode, vidq);
229 struct cx231xx *dev = container_of(vmode, struct cx231xx, video_mode);
230
231 char *outp;
232
233 if (list_empty(&dma_q->active)) {
234 cx231xx_isocdbg("No active queue to serve\n");
235 if (dev->USE_ISO)
236 dev->video_mode.isoc_ctl.buf = NULL;
237 else
238 dev->video_mode.bulk_ctl.buf = NULL;
239 *buf = NULL;
240 return;
241 }
242
243 /* Get the next buffer */
244 *buf = list_entry(dma_q->active.next, struct cx231xx_buffer, vb.queue);
245
246 /* Cleans up buffer - Useful for testing for frame/URB loss */
247 outp = videobuf_to_vmalloc(&(*buf)->vb);
248 memset(outp, 0, (*buf)->vb.size);
249
250 if (dev->USE_ISO)
251 dev->video_mode.isoc_ctl.buf = *buf;
252 else
253 dev->video_mode.bulk_ctl.buf = *buf;
254
255 return;
256 }
257
258 /*
259 * Controls the isoc copy of each urb packet
260 */
261 static inline int cx231xx_isoc_copy(struct cx231xx *dev, struct urb *urb)
262 {
263 struct cx231xx_dmaqueue *dma_q = urb->context;
264 int i;
265 unsigned char *p_buffer;
266 u32 bytes_parsed = 0, buffer_size = 0;
267 u8 sav_eav = 0;
268
269 if (!dev)
270 return 0;
271
272 if (dev->state & DEV_DISCONNECTED)
273 return 0;
274
275 if (urb->status < 0) {
276 print_err_status(dev, -1, urb->status);
277 if (urb->status == -ENOENT)
278 return 0;
279 }
280
281 for (i = 0; i < urb->number_of_packets; i++) {
282 int status = urb->iso_frame_desc[i].status;
283
284 if (status < 0) {
285 print_err_status(dev, i, status);
286 if (urb->iso_frame_desc[i].status != -EPROTO)
287 continue;
288 }
289
290 if (urb->iso_frame_desc[i].actual_length <= 0) {
291 /* cx231xx_isocdbg("packet %d is empty",i); - spammy */
292 continue;
293 }
294 if (urb->iso_frame_desc[i].actual_length >
295 dev->video_mode.max_pkt_size) {
296 cx231xx_isocdbg("packet bigger than packet size");
297 continue;
298 }
299
300 /* get buffer pointer and length */
301 p_buffer = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
302 buffer_size = urb->iso_frame_desc[i].actual_length;
303 bytes_parsed = 0;
304
305 if (dma_q->is_partial_line) {
306 /* Handle the case of a partial line */
307 sav_eav = dma_q->last_sav;
308 } else {
309 /* Check for a SAV/EAV overlapping
310 the buffer boundary */
311 sav_eav =
312 cx231xx_find_boundary_SAV_EAV(p_buffer,
313 dma_q->partial_buf,
314 &bytes_parsed);
315 }
316
317 sav_eav &= 0xF0;
318 /* Get the first line if we have some portion of an SAV/EAV from
319 the last buffer or a partial line */
320 if (sav_eav) {
321 bytes_parsed += cx231xx_get_video_line(dev, dma_q,
322 sav_eav, /* SAV/EAV */
323 p_buffer + bytes_parsed, /* p_buffer */
324 buffer_size - bytes_parsed);/* buf size */
325 }
326
327 /* Now parse data that is completely in this buffer */
328 /* dma_q->is_partial_line = 0; */
329
330 while (bytes_parsed < buffer_size) {
331 u32 bytes_used = 0;
332
333 sav_eav = cx231xx_find_next_SAV_EAV(
334 p_buffer + bytes_parsed, /* p_buffer */
335 buffer_size - bytes_parsed, /* buf size */
336 &bytes_used);/* bytes used to get SAV/EAV */
337
338 bytes_parsed += bytes_used;
339
340 sav_eav &= 0xF0;
341 if (sav_eav && (bytes_parsed < buffer_size)) {
342 bytes_parsed += cx231xx_get_video_line(dev,
343 dma_q, sav_eav, /* SAV/EAV */
344 p_buffer + bytes_parsed,/* p_buffer */
345 buffer_size - bytes_parsed);/*buf size*/
346 }
347 }
348
349 /* Save the last four bytes of the buffer so we can check the
350 buffer boundary condition next time */
351 memcpy(dma_q->partial_buf, p_buffer + buffer_size - 4, 4);
352 bytes_parsed = 0;
353
354 }
355 return 1;
356 }
357
358 static inline int cx231xx_bulk_copy(struct cx231xx *dev, struct urb *urb)
359 {
360 struct cx231xx_dmaqueue *dma_q = urb->context;
361 unsigned char *p_buffer;
362 u32 bytes_parsed = 0, buffer_size = 0;
363 u8 sav_eav = 0;
364
365 if (!dev)
366 return 0;
367
368 if (dev->state & DEV_DISCONNECTED)
369 return 0;
370
371 if (urb->status < 0) {
372 print_err_status(dev, -1, urb->status);
373 if (urb->status == -ENOENT)
374 return 0;
375 }
376
377 if (1) {
378
379 /* get buffer pointer and length */
380 p_buffer = urb->transfer_buffer;
381 buffer_size = urb->actual_length;
382 bytes_parsed = 0;
383
384 if (dma_q->is_partial_line) {
385 /* Handle the case of a partial line */
386 sav_eav = dma_q->last_sav;
387 } else {
388 /* Check for a SAV/EAV overlapping
389 the buffer boundary */
390 sav_eav =
391 cx231xx_find_boundary_SAV_EAV(p_buffer,
392 dma_q->partial_buf,
393 &bytes_parsed);
394 }
395
396 sav_eav &= 0xF0;
397 /* Get the first line if we have some portion of an SAV/EAV from
398 the last buffer or a partial line */
399 if (sav_eav) {
400 bytes_parsed += cx231xx_get_video_line(dev, dma_q,
401 sav_eav, /* SAV/EAV */
402 p_buffer + bytes_parsed, /* p_buffer */
403 buffer_size - bytes_parsed);/* buf size */
404 }
405
406 /* Now parse data that is completely in this buffer */
407 /* dma_q->is_partial_line = 0; */
408
409 while (bytes_parsed < buffer_size) {
410 u32 bytes_used = 0;
411
412 sav_eav = cx231xx_find_next_SAV_EAV(
413 p_buffer + bytes_parsed, /* p_buffer */
414 buffer_size - bytes_parsed, /* buf size */
415 &bytes_used);/* bytes used to get SAV/EAV */
416
417 bytes_parsed += bytes_used;
418
419 sav_eav &= 0xF0;
420 if (sav_eav && (bytes_parsed < buffer_size)) {
421 bytes_parsed += cx231xx_get_video_line(dev,
422 dma_q, sav_eav, /* SAV/EAV */
423 p_buffer + bytes_parsed,/* p_buffer */
424 buffer_size - bytes_parsed);/*buf size*/
425 }
426 }
427
428 /* Save the last four bytes of the buffer so we can check the
429 buffer boundary condition next time */
430 memcpy(dma_q->partial_buf, p_buffer + buffer_size - 4, 4);
431 bytes_parsed = 0;
432
433 }
434 return 1;
435 }
436
437
438 u8 cx231xx_find_boundary_SAV_EAV(u8 *p_buffer, u8 *partial_buf,
439 u32 *p_bytes_used)
440 {
441 u32 bytes_used;
442 u8 boundary_bytes[8];
443 u8 sav_eav = 0;
444
445 *p_bytes_used = 0;
446
447 /* Create an array of the last 4 bytes of the last buffer and the first
448 4 bytes of the current buffer. */
449
450 memcpy(boundary_bytes, partial_buf, 4);
451 memcpy(boundary_bytes + 4, p_buffer, 4);
452
453 /* Check for the SAV/EAV in the boundary buffer */
454 sav_eav = cx231xx_find_next_SAV_EAV((u8 *)&boundary_bytes, 8,
455 &bytes_used);
456
457 if (sav_eav) {
458 /* found a boundary SAV/EAV. Updates the bytes used to reflect
459 only those used in the new buffer */
460 *p_bytes_used = bytes_used - 4;
461 }
462
463 return sav_eav;
464 }
465
466 u8 cx231xx_find_next_SAV_EAV(u8 *p_buffer, u32 buffer_size, u32 *p_bytes_used)
467 {
468 u32 i;
469 u8 sav_eav = 0;
470
471 /*
472 * Don't search if the buffer size is less than 4. It causes a page
473 * fault since buffer_size - 4 evaluates to a large number in that
474 * case.
475 */
476 if (buffer_size < 4) {
477 *p_bytes_used = buffer_size;
478 return 0;
479 }
480
481 for (i = 0; i < (buffer_size - 3); i++) {
482
483 if ((p_buffer[i] == 0xFF) &&
484 (p_buffer[i + 1] == 0x00) && (p_buffer[i + 2] == 0x00)) {
485
486 *p_bytes_used = i + 4;
487 sav_eav = p_buffer[i + 3];
488 return sav_eav;
489 }
490 }
491
492 *p_bytes_used = buffer_size;
493 return 0;
494 }
495
496 u32 cx231xx_get_video_line(struct cx231xx *dev,
497 struct cx231xx_dmaqueue *dma_q, u8 sav_eav,
498 u8 *p_buffer, u32 buffer_size)
499 {
500 u32 bytes_copied = 0;
501 int current_field = -1;
502
503 switch (sav_eav) {
504 case SAV_ACTIVE_VIDEO_FIELD1:
505 /* looking for skipped line which occurred in PAL 720x480 mode.
506 In this case, there will be no active data contained
507 between the SAV and EAV */
508 if ((buffer_size > 3) && (p_buffer[0] == 0xFF) &&
509 (p_buffer[1] == 0x00) && (p_buffer[2] == 0x00) &&
510 ((p_buffer[3] == EAV_ACTIVE_VIDEO_FIELD1) ||
511 (p_buffer[3] == EAV_ACTIVE_VIDEO_FIELD2) ||
512 (p_buffer[3] == EAV_VBLANK_FIELD1) ||
513 (p_buffer[3] == EAV_VBLANK_FIELD2)))
514 return bytes_copied;
515 current_field = 1;
516 break;
517
518 case SAV_ACTIVE_VIDEO_FIELD2:
519 /* looking for skipped line which occurred in PAL 720x480 mode.
520 In this case, there will be no active data contained between
521 the SAV and EAV */
522 if ((buffer_size > 3) && (p_buffer[0] == 0xFF) &&
523 (p_buffer[1] == 0x00) && (p_buffer[2] == 0x00) &&
524 ((p_buffer[3] == EAV_ACTIVE_VIDEO_FIELD1) ||
525 (p_buffer[3] == EAV_ACTIVE_VIDEO_FIELD2) ||
526 (p_buffer[3] == EAV_VBLANK_FIELD1) ||
527 (p_buffer[3] == EAV_VBLANK_FIELD2)))
528 return bytes_copied;
529 current_field = 2;
530 break;
531 }
532
533 dma_q->last_sav = sav_eav;
534
535 bytes_copied = cx231xx_copy_video_line(dev, dma_q, p_buffer,
536 buffer_size, current_field);
537
538 return bytes_copied;
539 }
540
541 u32 cx231xx_copy_video_line(struct cx231xx *dev,
542 struct cx231xx_dmaqueue *dma_q, u8 *p_line,
543 u32 length, int field_number)
544 {
545 u32 bytes_to_copy;
546 struct cx231xx_buffer *buf;
547 u32 _line_size = dev->width * 2;
548
549 if (dma_q->current_field != field_number)
550 cx231xx_reset_video_buffer(dev, dma_q);
551
552 /* get the buffer pointer */
553 if (dev->USE_ISO)
554 buf = dev->video_mode.isoc_ctl.buf;
555 else
556 buf = dev->video_mode.bulk_ctl.buf;
557
558 /* Remember the field number for next time */
559 dma_q->current_field = field_number;
560
561 bytes_to_copy = dma_q->bytes_left_in_line;
562 if (bytes_to_copy > length)
563 bytes_to_copy = length;
564
565 if (dma_q->lines_completed >= dma_q->lines_per_field) {
566 dma_q->bytes_left_in_line -= bytes_to_copy;
567 dma_q->is_partial_line = (dma_q->bytes_left_in_line == 0) ?
568 0 : 1;
569 return 0;
570 }
571
572 dma_q->is_partial_line = 1;
573
574 /* If we don't have a buffer, just return the number of bytes we would
575 have copied if we had a buffer. */
576 if (!buf) {
577 dma_q->bytes_left_in_line -= bytes_to_copy;
578 dma_q->is_partial_line = (dma_q->bytes_left_in_line == 0)
579 ? 0 : 1;
580 return bytes_to_copy;
581 }
582
583 /* copy the data to video buffer */
584 cx231xx_do_copy(dev, dma_q, p_line, bytes_to_copy);
585
586 dma_q->pos += bytes_to_copy;
587 dma_q->bytes_left_in_line -= bytes_to_copy;
588
589 if (dma_q->bytes_left_in_line == 0) {
590 dma_q->bytes_left_in_line = _line_size;
591 dma_q->lines_completed++;
592 dma_q->is_partial_line = 0;
593
594 if (cx231xx_is_buffer_done(dev, dma_q) && buf) {
595 buffer_filled(dev, dma_q, buf);
596
597 dma_q->pos = 0;
598 buf = NULL;
599 dma_q->lines_completed = 0;
600 }
601 }
602
603 return bytes_to_copy;
604 }
605
606 void cx231xx_reset_video_buffer(struct cx231xx *dev,
607 struct cx231xx_dmaqueue *dma_q)
608 {
609 struct cx231xx_buffer *buf;
610
611 /* handle the switch from field 1 to field 2 */
612 if (dma_q->current_field == 1) {
613 if (dma_q->lines_completed >= dma_q->lines_per_field)
614 dma_q->field1_done = 1;
615 else
616 dma_q->field1_done = 0;
617 }
618
619 if (dev->USE_ISO)
620 buf = dev->video_mode.isoc_ctl.buf;
621 else
622 buf = dev->video_mode.bulk_ctl.buf;
623
624 if (buf == NULL) {
625 /* first try to get the buffer */
626 get_next_buf(dma_q, &buf);
627
628 dma_q->pos = 0;
629 dma_q->field1_done = 0;
630 dma_q->current_field = -1;
631 }
632
633 /* reset the counters */
634 dma_q->bytes_left_in_line = dev->width << 1;
635 dma_q->lines_completed = 0;
636 }
637
638 int cx231xx_do_copy(struct cx231xx *dev, struct cx231xx_dmaqueue *dma_q,
639 u8 *p_buffer, u32 bytes_to_copy)
640 {
641 u8 *p_out_buffer = NULL;
642 u32 current_line_bytes_copied = 0;
643 struct cx231xx_buffer *buf;
644 u32 _line_size = dev->width << 1;
645 void *startwrite;
646 int offset, lencopy;
647
648 if (dev->USE_ISO)
649 buf = dev->video_mode.isoc_ctl.buf;
650 else
651 buf = dev->video_mode.bulk_ctl.buf;
652
653 if (buf == NULL)
654 return -1;
655
656 p_out_buffer = videobuf_to_vmalloc(&buf->vb);
657
658 current_line_bytes_copied = _line_size - dma_q->bytes_left_in_line;
659
660 /* Offset field 2 one line from the top of the buffer */
661 offset = (dma_q->current_field == 1) ? 0 : _line_size;
662
663 /* Offset for field 2 */
664 startwrite = p_out_buffer + offset;
665
666 /* lines already completed in the current field */
667 startwrite += (dma_q->lines_completed * _line_size * 2);
668
669 /* bytes already completed in the current line */
670 startwrite += current_line_bytes_copied;
671
672 lencopy = dma_q->bytes_left_in_line > bytes_to_copy ?
673 bytes_to_copy : dma_q->bytes_left_in_line;
674
675 if ((u8 *)(startwrite + lencopy) > (u8 *)(p_out_buffer + buf->vb.size))
676 return 0;
677
678 /* The below copies the UYVY data straight into video buffer */
679 cx231xx_swab((u16 *) p_buffer, (u16 *) startwrite, (u16) lencopy);
680
681 return 0;
682 }
683
684 void cx231xx_swab(u16 *from, u16 *to, u16 len)
685 {
686 u16 i;
687
688 if (len <= 0)
689 return;
690
691 for (i = 0; i < len / 2; i++)
692 to[i] = (from[i] << 8) | (from[i] >> 8);
693 }
694
695 u8 cx231xx_is_buffer_done(struct cx231xx *dev, struct cx231xx_dmaqueue *dma_q)
696 {
697 u8 buffer_complete = 0;
698
699 /* Dual field stream */
700 buffer_complete = ((dma_q->current_field == 2) &&
701 (dma_q->lines_completed >= dma_q->lines_per_field) &&
702 dma_q->field1_done);
703
704 return buffer_complete;
705 }
706
707 /* ------------------------------------------------------------------
708 Videobuf operations
709 ------------------------------------------------------------------*/
710
711 static int
712 buffer_setup(struct videobuf_queue *vq, unsigned int *count, unsigned int *size)
713 {
714 struct cx231xx_fh *fh = vq->priv_data;
715 struct cx231xx *dev = fh->dev;
716
717 *size = (fh->dev->width * fh->dev->height * dev->format->depth + 7)>>3;
718 if (0 == *count)
719 *count = CX231XX_DEF_BUF;
720
721 if (*count < CX231XX_MIN_BUF)
722 *count = CX231XX_MIN_BUF;
723
724
725 cx231xx_enable_analog_tuner(dev);
726
727 return 0;
728 }
729
730 /* This is called *without* dev->slock held; please keep it that way */
731 static void free_buffer(struct videobuf_queue *vq, struct cx231xx_buffer *buf)
732 {
733 struct cx231xx_fh *fh = vq->priv_data;
734 struct cx231xx *dev = fh->dev;
735 unsigned long flags = 0;
736
737 BUG_ON(in_interrupt());
738
739 /* We used to wait for the buffer to finish here, but this didn't work
740 because, as we were keeping the state as VIDEOBUF_QUEUED,
741 videobuf_queue_cancel marked it as finished for us.
742 (Also, it could wedge forever if the hardware was misconfigured.)
743
744 This should be safe; by the time we get here, the buffer isn't
745 queued anymore. If we ever start marking the buffers as
746 VIDEOBUF_ACTIVE, it won't be, though.
747 */
748 spin_lock_irqsave(&dev->video_mode.slock, flags);
749 if (dev->USE_ISO) {
750 if (dev->video_mode.isoc_ctl.buf == buf)
751 dev->video_mode.isoc_ctl.buf = NULL;
752 } else {
753 if (dev->video_mode.bulk_ctl.buf == buf)
754 dev->video_mode.bulk_ctl.buf = NULL;
755 }
756 spin_unlock_irqrestore(&dev->video_mode.slock, flags);
757
758 videobuf_vmalloc_free(&buf->vb);
759 buf->vb.state = VIDEOBUF_NEEDS_INIT;
760 }
761
762 static int
763 buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
764 enum v4l2_field field)
765 {
766 struct cx231xx_fh *fh = vq->priv_data;
767 struct cx231xx_buffer *buf =
768 container_of(vb, struct cx231xx_buffer, vb);
769 struct cx231xx *dev = fh->dev;
770 int rc = 0, urb_init = 0;
771
772 /* The only currently supported format is 16 bits/pixel */
773 buf->vb.size = (fh->dev->width * fh->dev->height * dev->format->depth
774 + 7) >> 3;
775 if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size)
776 return -EINVAL;
777
778 buf->vb.width = dev->width;
779 buf->vb.height = dev->height;
780 buf->vb.field = field;
781
782 if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
783 rc = videobuf_iolock(vq, &buf->vb, NULL);
784 if (rc < 0)
785 goto fail;
786 }
787
788 if (dev->USE_ISO) {
789 if (!dev->video_mode.isoc_ctl.num_bufs)
790 urb_init = 1;
791 } else {
792 if (!dev->video_mode.bulk_ctl.num_bufs)
793 urb_init = 1;
794 }
795 dev_dbg(dev->dev,
796 "urb_init=%d dev->video_mode.max_pkt_size=%d\n",
797 urb_init, dev->video_mode.max_pkt_size);
798 if (urb_init) {
799 dev->mode_tv = 0;
800 if (dev->USE_ISO)
801 rc = cx231xx_init_isoc(dev, CX231XX_NUM_PACKETS,
802 CX231XX_NUM_BUFS,
803 dev->video_mode.max_pkt_size,
804 cx231xx_isoc_copy);
805 else
806 rc = cx231xx_init_bulk(dev, CX231XX_NUM_PACKETS,
807 CX231XX_NUM_BUFS,
808 dev->video_mode.max_pkt_size,
809 cx231xx_bulk_copy);
810 if (rc < 0)
811 goto fail;
812 }
813
814 buf->vb.state = VIDEOBUF_PREPARED;
815
816 return 0;
817
818 fail:
819 free_buffer(vq, buf);
820 return rc;
821 }
822
823 static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
824 {
825 struct cx231xx_buffer *buf =
826 container_of(vb, struct cx231xx_buffer, vb);
827 struct cx231xx_fh *fh = vq->priv_data;
828 struct cx231xx *dev = fh->dev;
829 struct cx231xx_dmaqueue *vidq = &dev->video_mode.vidq;
830
831 buf->vb.state = VIDEOBUF_QUEUED;
832 list_add_tail(&buf->vb.queue, &vidq->active);
833
834 }
835
836 static void buffer_release(struct videobuf_queue *vq,
837 struct videobuf_buffer *vb)
838 {
839 struct cx231xx_buffer *buf =
840 container_of(vb, struct cx231xx_buffer, vb);
841 struct cx231xx_fh *fh = vq->priv_data;
842 struct cx231xx *dev = (struct cx231xx *)fh->dev;
843
844 cx231xx_isocdbg("cx231xx: called buffer_release\n");
845
846 free_buffer(vq, buf);
847 }
848
849 static const struct videobuf_queue_ops cx231xx_video_qops = {
850 .buf_setup = buffer_setup,
851 .buf_prepare = buffer_prepare,
852 .buf_queue = buffer_queue,
853 .buf_release = buffer_release,
854 };
855
856 /********************* v4l2 interface **************************************/
857
858 void video_mux(struct cx231xx *dev, int index)
859 {
860 dev->video_input = index;
861 dev->ctl_ainput = INPUT(index)->amux;
862
863 cx231xx_set_video_input_mux(dev, index);
864
865 cx25840_call(dev, video, s_routing, INPUT(index)->vmux, 0, 0);
866
867 cx231xx_set_audio_input(dev, dev->ctl_ainput);
868
869 dev_dbg(dev->dev, "video_mux : %d\n", index);
870
871 /* do mode control overrides if required */
872 cx231xx_do_mode_ctrl_overrides(dev);
873 }
874
875 /* Usage lock check functions */
876 static int res_get(struct cx231xx_fh *fh)
877 {
878 struct cx231xx *dev = fh->dev;
879 int rc = 0;
880
881 /* This instance already has stream_on */
882 if (fh->stream_on)
883 return rc;
884
885 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
886 if (dev->stream_on)
887 return -EBUSY;
888 dev->stream_on = 1;
889 } else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
890 if (dev->vbi_stream_on)
891 return -EBUSY;
892 dev->vbi_stream_on = 1;
893 } else
894 return -EINVAL;
895
896 fh->stream_on = 1;
897
898 return rc;
899 }
900
901 static int res_check(struct cx231xx_fh *fh)
902 {
903 return fh->stream_on;
904 }
905
906 static void res_free(struct cx231xx_fh *fh)
907 {
908 struct cx231xx *dev = fh->dev;
909
910 fh->stream_on = 0;
911
912 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
913 dev->stream_on = 0;
914 if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
915 dev->vbi_stream_on = 0;
916 }
917
918 static int check_dev(struct cx231xx *dev)
919 {
920 if (dev->state & DEV_DISCONNECTED) {
921 dev_err(dev->dev, "v4l2 ioctl: device not present\n");
922 return -ENODEV;
923 }
924 return 0;
925 }
926
927 /* ------------------------------------------------------------------
928 IOCTL vidioc handling
929 ------------------------------------------------------------------*/
930
931 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
932 struct v4l2_format *f)
933 {
934 struct cx231xx_fh *fh = priv;
935 struct cx231xx *dev = fh->dev;
936
937 f->fmt.pix.width = dev->width;
938 f->fmt.pix.height = dev->height;
939 f->fmt.pix.pixelformat = dev->format->fourcc;
940 f->fmt.pix.bytesperline = (dev->width * dev->format->depth + 7) >> 3;
941 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * dev->height;
942 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
943
944 f->fmt.pix.field = V4L2_FIELD_INTERLACED;
945
946 return 0;
947 }
948
949 static struct cx231xx_fmt *format_by_fourcc(unsigned int fourcc)
950 {
951 unsigned int i;
952
953 for (i = 0; i < ARRAY_SIZE(format); i++)
954 if (format[i].fourcc == fourcc)
955 return &format[i];
956
957 return NULL;
958 }
959
960 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
961 struct v4l2_format *f)
962 {
963 struct cx231xx_fh *fh = priv;
964 struct cx231xx *dev = fh->dev;
965 unsigned int width = f->fmt.pix.width;
966 unsigned int height = f->fmt.pix.height;
967 unsigned int maxw = norm_maxw(dev);
968 unsigned int maxh = norm_maxh(dev);
969 struct cx231xx_fmt *fmt;
970
971 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
972 if (!fmt) {
973 cx231xx_videodbg("Fourcc format (%08x) invalid.\n",
974 f->fmt.pix.pixelformat);
975 return -EINVAL;
976 }
977
978 /* width must even because of the YUYV format
979 height must be even because of interlacing */
980 v4l_bound_align_image(&width, 48, maxw, 1, &height, 32, maxh, 1, 0);
981
982 f->fmt.pix.width = width;
983 f->fmt.pix.height = height;
984 f->fmt.pix.pixelformat = fmt->fourcc;
985 f->fmt.pix.bytesperline = (width * fmt->depth + 7) >> 3;
986 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * height;
987 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
988 f->fmt.pix.field = V4L2_FIELD_INTERLACED;
989
990 return 0;
991 }
992
993 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
994 struct v4l2_format *f)
995 {
996 struct cx231xx_fh *fh = priv;
997 struct cx231xx *dev = fh->dev;
998 int rc;
999 struct cx231xx_fmt *fmt;
1000 struct v4l2_subdev_format format = {
1001 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
1002 };
1003
1004 rc = check_dev(dev);
1005 if (rc < 0)
1006 return rc;
1007
1008 vidioc_try_fmt_vid_cap(file, priv, f);
1009
1010 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
1011 if (!fmt)
1012 return -EINVAL;
1013
1014 if (videobuf_queue_is_busy(&fh->vb_vidq)) {
1015 dev_err(dev->dev, "%s: queue busy\n", __func__);
1016 return -EBUSY;
1017 }
1018
1019 if (dev->stream_on && !fh->stream_on) {
1020 dev_err(dev->dev,
1021 "%s: device in use by another fh\n", __func__);
1022 return -EBUSY;
1023 }
1024
1025 /* set new image size */
1026 dev->width = f->fmt.pix.width;
1027 dev->height = f->fmt.pix.height;
1028 dev->format = fmt;
1029
1030 v4l2_fill_mbus_format(&format.format, &f->fmt.pix, MEDIA_BUS_FMT_FIXED);
1031 call_all(dev, pad, set_fmt, NULL, &format);
1032 v4l2_fill_pix_format(&f->fmt.pix, &format.format);
1033
1034 return rc;
1035 }
1036
1037 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *id)
1038 {
1039 struct cx231xx_fh *fh = priv;
1040 struct cx231xx *dev = fh->dev;
1041
1042 *id = dev->norm;
1043 return 0;
1044 }
1045
1046 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id norm)
1047 {
1048 struct cx231xx_fh *fh = priv;
1049 struct cx231xx *dev = fh->dev;
1050 struct v4l2_subdev_format format = {
1051 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
1052 };
1053 int rc;
1054
1055 rc = check_dev(dev);
1056 if (rc < 0)
1057 return rc;
1058
1059 if (dev->norm == norm)
1060 return 0;
1061
1062 if (videobuf_queue_is_busy(&fh->vb_vidq))
1063 return -EBUSY;
1064
1065 dev->norm = norm;
1066
1067 /* Adjusts width/height, if needed */
1068 dev->width = 720;
1069 dev->height = (dev->norm & V4L2_STD_625_50) ? 576 : 480;
1070
1071 call_all(dev, video, s_std, dev->norm);
1072
1073 /* We need to reset basic properties in the decoder related to
1074 resolution (since a standard change effects things like the number
1075 of lines in VACT, etc) */
1076 format.format.code = MEDIA_BUS_FMT_FIXED;
1077 format.format.width = dev->width;
1078 format.format.height = dev->height;
1079 call_all(dev, pad, set_fmt, NULL, &format);
1080
1081 /* do mode control overrides */
1082 cx231xx_do_mode_ctrl_overrides(dev);
1083
1084 return 0;
1085 }
1086
1087 static const char *iname[] = {
1088 [CX231XX_VMUX_COMPOSITE1] = "Composite1",
1089 [CX231XX_VMUX_SVIDEO] = "S-Video",
1090 [CX231XX_VMUX_TELEVISION] = "Television",
1091 [CX231XX_VMUX_CABLE] = "Cable TV",
1092 [CX231XX_VMUX_DVB] = "DVB",
1093 };
1094
1095 void cx231xx_v4l2_create_entities(struct cx231xx *dev)
1096 {
1097 #if defined(CONFIG_MEDIA_CONTROLLER)
1098 int ret, i;
1099
1100 /* Create entities for each input connector */
1101 for (i = 0; i < MAX_CX231XX_INPUT; i++) {
1102 struct media_entity *ent = &dev->input_ent[i];
1103
1104 if (!INPUT(i)->type)
1105 break;
1106
1107 ent->name = iname[INPUT(i)->type];
1108 ent->flags = MEDIA_ENT_FL_CONNECTOR;
1109 dev->input_pad[i].flags = MEDIA_PAD_FL_SOURCE;
1110
1111 switch (INPUT(i)->type) {
1112 case CX231XX_VMUX_COMPOSITE1:
1113 ent->function = MEDIA_ENT_F_CONN_COMPOSITE;
1114 break;
1115 case CX231XX_VMUX_SVIDEO:
1116 ent->function = MEDIA_ENT_F_CONN_SVIDEO;
1117 break;
1118 case CX231XX_VMUX_TELEVISION:
1119 case CX231XX_VMUX_CABLE:
1120 case CX231XX_VMUX_DVB:
1121 /* The DVB core will handle it */
1122 if (dev->tuner_type == TUNER_ABSENT)
1123 continue;
1124 /* fall through */
1125 default: /* just to shut up a gcc warning */
1126 ent->function = MEDIA_ENT_F_CONN_RF;
1127 break;
1128 }
1129
1130 ret = media_entity_pads_init(ent, 1, &dev->input_pad[i]);
1131 if (ret < 0)
1132 pr_err("failed to initialize input pad[%d]!\n", i);
1133
1134 ret = media_device_register_entity(dev->media_dev, ent);
1135 if (ret < 0)
1136 pr_err("failed to register input entity %d!\n", i);
1137 }
1138 #endif
1139 }
1140
1141 int cx231xx_enum_input(struct file *file, void *priv,
1142 struct v4l2_input *i)
1143 {
1144 struct cx231xx_fh *fh = priv;
1145 struct cx231xx *dev = fh->dev;
1146 u32 gen_stat;
1147 unsigned int n;
1148 int ret;
1149
1150 n = i->index;
1151 if (n >= MAX_CX231XX_INPUT)
1152 return -EINVAL;
1153 if (0 == INPUT(n)->type)
1154 return -EINVAL;
1155
1156 i->index = n;
1157 i->type = V4L2_INPUT_TYPE_CAMERA;
1158
1159 strscpy(i->name, iname[INPUT(n)->type], sizeof(i->name));
1160
1161 if ((CX231XX_VMUX_TELEVISION == INPUT(n)->type) ||
1162 (CX231XX_VMUX_CABLE == INPUT(n)->type))
1163 i->type = V4L2_INPUT_TYPE_TUNER;
1164
1165 i->std = dev->vdev.tvnorms;
1166
1167 /* If they are asking about the active input, read signal status */
1168 if (n == dev->video_input) {
1169 ret = cx231xx_read_i2c_data(dev, VID_BLK_I2C_ADDRESS,
1170 GEN_STAT, 2, &gen_stat, 4);
1171 if (ret > 0) {
1172 if ((gen_stat & FLD_VPRES) == 0x00)
1173 i->status |= V4L2_IN_ST_NO_SIGNAL;
1174 if ((gen_stat & FLD_HLOCK) == 0x00)
1175 i->status |= V4L2_IN_ST_NO_H_LOCK;
1176 }
1177 }
1178
1179 return 0;
1180 }
1181
1182 int cx231xx_g_input(struct file *file, void *priv, unsigned int *i)
1183 {
1184 struct cx231xx_fh *fh = priv;
1185 struct cx231xx *dev = fh->dev;
1186
1187 *i = dev->video_input;
1188
1189 return 0;
1190 }
1191
1192 int cx231xx_s_input(struct file *file, void *priv, unsigned int i)
1193 {
1194 struct cx231xx_fh *fh = priv;
1195 struct cx231xx *dev = fh->dev;
1196 int rc;
1197
1198 dev->mode_tv = 0;
1199 rc = check_dev(dev);
1200 if (rc < 0)
1201 return rc;
1202
1203 if (i >= MAX_CX231XX_INPUT)
1204 return -EINVAL;
1205 if (0 == INPUT(i)->type)
1206 return -EINVAL;
1207
1208 video_mux(dev, i);
1209
1210 if (INPUT(i)->type == CX231XX_VMUX_TELEVISION ||
1211 INPUT(i)->type == CX231XX_VMUX_CABLE) {
1212 /* There's a tuner, so reset the standard and put it on the
1213 last known frequency (since it was probably powered down
1214 until now */
1215 call_all(dev, video, s_std, dev->norm);
1216 }
1217
1218 return 0;
1219 }
1220
1221 int cx231xx_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
1222 {
1223 struct cx231xx_fh *fh = priv;
1224 struct cx231xx *dev = fh->dev;
1225 int rc;
1226
1227 rc = check_dev(dev);
1228 if (rc < 0)
1229 return rc;
1230
1231 if (0 != t->index)
1232 return -EINVAL;
1233
1234 strscpy(t->name, "Tuner", sizeof(t->name));
1235
1236 t->type = V4L2_TUNER_ANALOG_TV;
1237 t->capability = V4L2_TUNER_CAP_NORM;
1238 t->rangehigh = 0xffffffffUL;
1239 t->signal = 0xffff; /* LOCKED */
1240 call_all(dev, tuner, g_tuner, t);
1241
1242 return 0;
1243 }
1244
1245 int cx231xx_s_tuner(struct file *file, void *priv, const struct v4l2_tuner *t)
1246 {
1247 struct cx231xx_fh *fh = priv;
1248 struct cx231xx *dev = fh->dev;
1249 int rc;
1250
1251 rc = check_dev(dev);
1252 if (rc < 0)
1253 return rc;
1254
1255 if (0 != t->index)
1256 return -EINVAL;
1257 #if 0
1258 call_all(dev, tuner, s_tuner, t);
1259 #endif
1260 return 0;
1261 }
1262
1263 int cx231xx_g_frequency(struct file *file, void *priv,
1264 struct v4l2_frequency *f)
1265 {
1266 struct cx231xx_fh *fh = priv;
1267 struct cx231xx *dev = fh->dev;
1268
1269 if (f->tuner)
1270 return -EINVAL;
1271
1272 f->frequency = dev->ctl_freq;
1273
1274 return 0;
1275 }
1276
1277 int cx231xx_s_frequency(struct file *file, void *priv,
1278 const struct v4l2_frequency *f)
1279 {
1280 struct cx231xx_fh *fh = priv;
1281 struct cx231xx *dev = fh->dev;
1282 struct v4l2_frequency new_freq = *f;
1283 int rc;
1284 u32 if_frequency = 5400000;
1285
1286 dev_dbg(dev->dev,
1287 "Enter vidioc_s_frequency()f->frequency=%d;f->type=%d\n",
1288 f->frequency, f->type);
1289
1290 rc = check_dev(dev);
1291 if (rc < 0)
1292 return rc;
1293
1294 if (0 != f->tuner)
1295 return -EINVAL;
1296
1297 /* set pre channel change settings in DIF first */
1298 rc = cx231xx_tuner_pre_channel_change(dev);
1299
1300 call_all(dev, tuner, s_frequency, f);
1301 call_all(dev, tuner, g_frequency, &new_freq);
1302 dev->ctl_freq = new_freq.frequency;
1303
1304 /* set post channel change settings in DIF first */
1305 rc = cx231xx_tuner_post_channel_change(dev);
1306
1307 if (dev->tuner_type == TUNER_NXP_TDA18271) {
1308 if (dev->norm & (V4L2_STD_MN | V4L2_STD_NTSC_443))
1309 if_frequency = 5400000; /*5.4MHz */
1310 else if (dev->norm & V4L2_STD_B)
1311 if_frequency = 6000000; /*6.0MHz */
1312 else if (dev->norm & (V4L2_STD_PAL_DK | V4L2_STD_SECAM_DK))
1313 if_frequency = 6900000; /*6.9MHz */
1314 else if (dev->norm & V4L2_STD_GH)
1315 if_frequency = 7100000; /*7.1MHz */
1316 else if (dev->norm & V4L2_STD_PAL_I)
1317 if_frequency = 7250000; /*7.25MHz */
1318 else if (dev->norm & V4L2_STD_SECAM_L)
1319 if_frequency = 6900000; /*6.9MHz */
1320 else if (dev->norm & V4L2_STD_SECAM_LC)
1321 if_frequency = 1250000; /*1.25MHz */
1322
1323 dev_dbg(dev->dev,
1324 "if_frequency is set to %d\n", if_frequency);
1325 cx231xx_set_Colibri_For_LowIF(dev, if_frequency, 1, 1);
1326
1327 update_HH_register_after_set_DIF(dev);
1328 }
1329
1330 dev_dbg(dev->dev, "Set New FREQUENCY to %d\n", f->frequency);
1331
1332 return rc;
1333 }
1334
1335 #ifdef CONFIG_VIDEO_ADV_DEBUG
1336
1337 int cx231xx_g_chip_info(struct file *file, void *fh,
1338 struct v4l2_dbg_chip_info *chip)
1339 {
1340 switch (chip->match.addr) {
1341 case 0: /* Cx231xx - internal registers */
1342 return 0;
1343 case 1: /* AFE - read byte */
1344 strscpy(chip->name, "AFE (byte)", sizeof(chip->name));
1345 return 0;
1346 case 2: /* Video Block - read byte */
1347 strscpy(chip->name, "Video (byte)", sizeof(chip->name));
1348 return 0;
1349 case 3: /* I2S block - read byte */
1350 strscpy(chip->name, "I2S (byte)", sizeof(chip->name));
1351 return 0;
1352 case 4: /* AFE - read dword */
1353 strscpy(chip->name, "AFE (dword)", sizeof(chip->name));
1354 return 0;
1355 case 5: /* Video Block - read dword */
1356 strscpy(chip->name, "Video (dword)", sizeof(chip->name));
1357 return 0;
1358 case 6: /* I2S Block - read dword */
1359 strscpy(chip->name, "I2S (dword)", sizeof(chip->name));
1360 return 0;
1361 }
1362 return -EINVAL;
1363 }
1364
1365 int cx231xx_g_register(struct file *file, void *priv,
1366 struct v4l2_dbg_register *reg)
1367 {
1368 struct cx231xx_fh *fh = priv;
1369 struct cx231xx *dev = fh->dev;
1370 int ret;
1371 u8 value[4] = { 0, 0, 0, 0 };
1372 u32 data = 0;
1373
1374 switch (reg->match.addr) {
1375 case 0: /* Cx231xx - internal registers */
1376 ret = cx231xx_read_ctrl_reg(dev, VRT_GET_REGISTER,
1377 (u16)reg->reg, value, 4);
1378 reg->val = value[0] | value[1] << 8 |
1379 value[2] << 16 | (u32)value[3] << 24;
1380 reg->size = 4;
1381 break;
1382 case 1: /* AFE - read byte */
1383 ret = cx231xx_read_i2c_data(dev, AFE_DEVICE_ADDRESS,
1384 (u16)reg->reg, 2, &data, 1);
1385 reg->val = data;
1386 reg->size = 1;
1387 break;
1388 case 2: /* Video Block - read byte */
1389 ret = cx231xx_read_i2c_data(dev, VID_BLK_I2C_ADDRESS,
1390 (u16)reg->reg, 2, &data, 1);
1391 reg->val = data;
1392 reg->size = 1;
1393 break;
1394 case 3: /* I2S block - read byte */
1395 ret = cx231xx_read_i2c_data(dev, I2S_BLK_DEVICE_ADDRESS,
1396 (u16)reg->reg, 1, &data, 1);
1397 reg->val = data;
1398 reg->size = 1;
1399 break;
1400 case 4: /* AFE - read dword */
1401 ret = cx231xx_read_i2c_data(dev, AFE_DEVICE_ADDRESS,
1402 (u16)reg->reg, 2, &data, 4);
1403 reg->val = data;
1404 reg->size = 4;
1405 break;
1406 case 5: /* Video Block - read dword */
1407 ret = cx231xx_read_i2c_data(dev, VID_BLK_I2C_ADDRESS,
1408 (u16)reg->reg, 2, &data, 4);
1409 reg->val = data;
1410 reg->size = 4;
1411 break;
1412 case 6: /* I2S Block - read dword */
1413 ret = cx231xx_read_i2c_data(dev, I2S_BLK_DEVICE_ADDRESS,
1414 (u16)reg->reg, 1, &data, 4);
1415 reg->val = data;
1416 reg->size = 4;
1417 break;
1418 default:
1419 return -EINVAL;
1420 }
1421 return ret < 0 ? ret : 0;
1422 }
1423
1424 int cx231xx_s_register(struct file *file, void *priv,
1425 const struct v4l2_dbg_register *reg)
1426 {
1427 struct cx231xx_fh *fh = priv;
1428 struct cx231xx *dev = fh->dev;
1429 int ret;
1430 u8 data[4] = { 0, 0, 0, 0 };
1431
1432 switch (reg->match.addr) {
1433 case 0: /* cx231xx internal registers */
1434 data[0] = (u8) reg->val;
1435 data[1] = (u8) (reg->val >> 8);
1436 data[2] = (u8) (reg->val >> 16);
1437 data[3] = (u8) (reg->val >> 24);
1438 ret = cx231xx_write_ctrl_reg(dev, VRT_SET_REGISTER,
1439 (u16)reg->reg, data, 4);
1440 break;
1441 case 1: /* AFE - write byte */
1442 ret = cx231xx_write_i2c_data(dev, AFE_DEVICE_ADDRESS,
1443 (u16)reg->reg, 2, reg->val, 1);
1444 break;
1445 case 2: /* Video Block - write byte */
1446 ret = cx231xx_write_i2c_data(dev, VID_BLK_I2C_ADDRESS,
1447 (u16)reg->reg, 2, reg->val, 1);
1448 break;
1449 case 3: /* I2S block - write byte */
1450 ret = cx231xx_write_i2c_data(dev, I2S_BLK_DEVICE_ADDRESS,
1451 (u16)reg->reg, 1, reg->val, 1);
1452 break;
1453 case 4: /* AFE - write dword */
1454 ret = cx231xx_write_i2c_data(dev, AFE_DEVICE_ADDRESS,
1455 (u16)reg->reg, 2, reg->val, 4);
1456 break;
1457 case 5: /* Video Block - write dword */
1458 ret = cx231xx_write_i2c_data(dev, VID_BLK_I2C_ADDRESS,
1459 (u16)reg->reg, 2, reg->val, 4);
1460 break;
1461 case 6: /* I2S block - write dword */
1462 ret = cx231xx_write_i2c_data(dev, I2S_BLK_DEVICE_ADDRESS,
1463 (u16)reg->reg, 1, reg->val, 4);
1464 break;
1465 default:
1466 return -EINVAL;
1467 }
1468 return ret < 0 ? ret : 0;
1469 }
1470 #endif
1471
1472 static int vidioc_g_pixelaspect(struct file *file, void *priv,
1473 int type, struct v4l2_fract *f)
1474 {
1475 struct cx231xx_fh *fh = priv;
1476 struct cx231xx *dev = fh->dev;
1477 bool is_50hz = dev->norm & V4L2_STD_625_50;
1478
1479 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1480 return -EINVAL;
1481
1482 f->numerator = is_50hz ? 54 : 11;
1483 f->denominator = is_50hz ? 59 : 10;
1484
1485 return 0;
1486 }
1487
1488 static int vidioc_g_selection(struct file *file, void *priv,
1489 struct v4l2_selection *s)
1490 {
1491 struct cx231xx_fh *fh = priv;
1492 struct cx231xx *dev = fh->dev;
1493
1494 if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1495 return -EINVAL;
1496
1497 switch (s->target) {
1498 case V4L2_SEL_TGT_CROP_BOUNDS:
1499 case V4L2_SEL_TGT_CROP_DEFAULT:
1500 s->r.left = 0;
1501 s->r.top = 0;
1502 s->r.width = dev->width;
1503 s->r.height = dev->height;
1504 break;
1505 default:
1506 return -EINVAL;
1507 }
1508 return 0;
1509 }
1510
1511 static int vidioc_streamon(struct file *file, void *priv,
1512 enum v4l2_buf_type type)
1513 {
1514 struct cx231xx_fh *fh = priv;
1515 struct cx231xx *dev = fh->dev;
1516 int rc;
1517
1518 rc = check_dev(dev);
1519 if (rc < 0)
1520 return rc;
1521
1522 rc = res_get(fh);
1523
1524 if (likely(rc >= 0))
1525 rc = videobuf_streamon(&fh->vb_vidq);
1526
1527 call_all(dev, video, s_stream, 1);
1528
1529 return rc;
1530 }
1531
1532 static int vidioc_streamoff(struct file *file, void *priv,
1533 enum v4l2_buf_type type)
1534 {
1535 struct cx231xx_fh *fh = priv;
1536 struct cx231xx *dev = fh->dev;
1537 int rc;
1538
1539 rc = check_dev(dev);
1540 if (rc < 0)
1541 return rc;
1542
1543 if (type != fh->type)
1544 return -EINVAL;
1545
1546 cx25840_call(dev, video, s_stream, 0);
1547
1548 videobuf_streamoff(&fh->vb_vidq);
1549 res_free(fh);
1550
1551 return 0;
1552 }
1553
1554 int cx231xx_querycap(struct file *file, void *priv,
1555 struct v4l2_capability *cap)
1556 {
1557 struct cx231xx_fh *fh = priv;
1558 struct cx231xx *dev = fh->dev;
1559
1560 strscpy(cap->driver, "cx231xx", sizeof(cap->driver));
1561 strscpy(cap->card, cx231xx_boards[dev->model].name, sizeof(cap->card));
1562 usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
1563 cap->capabilities = V4L2_CAP_READWRITE |
1564 V4L2_CAP_VBI_CAPTURE | V4L2_CAP_VIDEO_CAPTURE |
1565 V4L2_CAP_STREAMING | V4L2_CAP_DEVICE_CAPS;
1566 if (video_is_registered(&dev->radio_dev))
1567 cap->capabilities |= V4L2_CAP_RADIO;
1568 if (dev->tuner_type != TUNER_ABSENT)
1569 cap->capabilities |= V4L2_CAP_TUNER;
1570
1571 return 0;
1572 }
1573
1574 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
1575 struct v4l2_fmtdesc *f)
1576 {
1577 if (unlikely(f->index >= ARRAY_SIZE(format)))
1578 return -EINVAL;
1579
1580 f->pixelformat = format[f->index].fourcc;
1581
1582 return 0;
1583 }
1584
1585 /* RAW VBI ioctls */
1586
1587 static int vidioc_g_fmt_vbi_cap(struct file *file, void *priv,
1588 struct v4l2_format *f)
1589 {
1590 struct cx231xx_fh *fh = priv;
1591 struct cx231xx *dev = fh->dev;
1592
1593 f->fmt.vbi.sampling_rate = 6750000 * 4;
1594 f->fmt.vbi.samples_per_line = VBI_LINE_LENGTH;
1595 f->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
1596 f->fmt.vbi.offset = 0;
1597 f->fmt.vbi.start[0] = (dev->norm & V4L2_STD_625_50) ?
1598 PAL_VBI_START_LINE : NTSC_VBI_START_LINE;
1599 f->fmt.vbi.count[0] = (dev->norm & V4L2_STD_625_50) ?
1600 PAL_VBI_LINES : NTSC_VBI_LINES;
1601 f->fmt.vbi.start[1] = (dev->norm & V4L2_STD_625_50) ?
1602 PAL_VBI_START_LINE + 312 : NTSC_VBI_START_LINE + 263;
1603 f->fmt.vbi.count[1] = f->fmt.vbi.count[0];
1604 memset(f->fmt.vbi.reserved, 0, sizeof(f->fmt.vbi.reserved));
1605
1606 return 0;
1607
1608 }
1609
1610 static int vidioc_try_fmt_vbi_cap(struct file *file, void *priv,
1611 struct v4l2_format *f)
1612 {
1613 struct cx231xx_fh *fh = priv;
1614 struct cx231xx *dev = fh->dev;
1615
1616 f->fmt.vbi.sampling_rate = 6750000 * 4;
1617 f->fmt.vbi.samples_per_line = VBI_LINE_LENGTH;
1618 f->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
1619 f->fmt.vbi.offset = 0;
1620 f->fmt.vbi.flags = 0;
1621 f->fmt.vbi.start[0] = (dev->norm & V4L2_STD_625_50) ?
1622 PAL_VBI_START_LINE : NTSC_VBI_START_LINE;
1623 f->fmt.vbi.count[0] = (dev->norm & V4L2_STD_625_50) ?
1624 PAL_VBI_LINES : NTSC_VBI_LINES;
1625 f->fmt.vbi.start[1] = (dev->norm & V4L2_STD_625_50) ?
1626 PAL_VBI_START_LINE + 312 : NTSC_VBI_START_LINE + 263;
1627 f->fmt.vbi.count[1] = f->fmt.vbi.count[0];
1628 memset(f->fmt.vbi.reserved, 0, sizeof(f->fmt.vbi.reserved));
1629
1630 return 0;
1631
1632 }
1633
1634 static int vidioc_s_fmt_vbi_cap(struct file *file, void *priv,
1635 struct v4l2_format *f)
1636 {
1637 struct cx231xx_fh *fh = priv;
1638 struct cx231xx *dev = fh->dev;
1639
1640 if (dev->vbi_stream_on && !fh->stream_on) {
1641 dev_err(dev->dev,
1642 "%s device in use by another fh\n", __func__);
1643 return -EBUSY;
1644 }
1645 return vidioc_try_fmt_vbi_cap(file, priv, f);
1646 }
1647
1648 static int vidioc_reqbufs(struct file *file, void *priv,
1649 struct v4l2_requestbuffers *rb)
1650 {
1651 struct cx231xx_fh *fh = priv;
1652 struct cx231xx *dev = fh->dev;
1653 int rc;
1654
1655 rc = check_dev(dev);
1656 if (rc < 0)
1657 return rc;
1658
1659 return videobuf_reqbufs(&fh->vb_vidq, rb);
1660 }
1661
1662 static int vidioc_querybuf(struct file *file, void *priv, struct v4l2_buffer *b)
1663 {
1664 struct cx231xx_fh *fh = priv;
1665 struct cx231xx *dev = fh->dev;
1666 int rc;
1667
1668 rc = check_dev(dev);
1669 if (rc < 0)
1670 return rc;
1671
1672 return videobuf_querybuf(&fh->vb_vidq, b);
1673 }
1674
1675 static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
1676 {
1677 struct cx231xx_fh *fh = priv;
1678 struct cx231xx *dev = fh->dev;
1679 int rc;
1680
1681 rc = check_dev(dev);
1682 if (rc < 0)
1683 return rc;
1684
1685 return videobuf_qbuf(&fh->vb_vidq, b);
1686 }
1687
1688 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
1689 {
1690 struct cx231xx_fh *fh = priv;
1691 struct cx231xx *dev = fh->dev;
1692 int rc;
1693
1694 rc = check_dev(dev);
1695 if (rc < 0)
1696 return rc;
1697
1698 return videobuf_dqbuf(&fh->vb_vidq, b, file->f_flags & O_NONBLOCK);
1699 }
1700
1701 /* ----------------------------------------------------------- */
1702 /* RADIO ESPECIFIC IOCTLS */
1703 /* ----------------------------------------------------------- */
1704
1705 static int radio_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
1706 {
1707 struct cx231xx *dev = ((struct cx231xx_fh *)priv)->dev;
1708
1709 if (t->index)
1710 return -EINVAL;
1711
1712 strscpy(t->name, "Radio", sizeof(t->name));
1713
1714 call_all(dev, tuner, g_tuner, t);
1715
1716 return 0;
1717 }
1718 static int radio_s_tuner(struct file *file, void *priv, const struct v4l2_tuner *t)
1719 {
1720 struct cx231xx *dev = ((struct cx231xx_fh *)priv)->dev;
1721
1722 if (t->index)
1723 return -EINVAL;
1724
1725 call_all(dev, tuner, s_tuner, t);
1726
1727 return 0;
1728 }
1729
1730 /*
1731 * cx231xx_v4l2_open()
1732 * inits the device and starts isoc transfer
1733 */
1734 static int cx231xx_v4l2_open(struct file *filp)
1735 {
1736 int radio = 0;
1737 struct video_device *vdev = video_devdata(filp);
1738 struct cx231xx *dev = video_drvdata(filp);
1739 struct cx231xx_fh *fh;
1740 enum v4l2_buf_type fh_type = 0;
1741
1742 switch (vdev->vfl_type) {
1743 case VFL_TYPE_GRABBER:
1744 fh_type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1745 break;
1746 case VFL_TYPE_VBI:
1747 fh_type = V4L2_BUF_TYPE_VBI_CAPTURE;
1748 break;
1749 case VFL_TYPE_RADIO:
1750 radio = 1;
1751 break;
1752 default:
1753 return -EINVAL;
1754 }
1755
1756 cx231xx_videodbg("open dev=%s type=%s users=%d\n",
1757 video_device_node_name(vdev), v4l2_type_names[fh_type],
1758 dev->users);
1759
1760 #if 0
1761 errCode = cx231xx_set_mode(dev, CX231XX_ANALOG_MODE);
1762 if (errCode < 0) {
1763 dev_err(dev->dev,
1764 "Device locked on digital mode. Can't open analog\n");
1765 return -EBUSY;
1766 }
1767 #endif
1768
1769 fh = kzalloc(sizeof(struct cx231xx_fh), GFP_KERNEL);
1770 if (!fh)
1771 return -ENOMEM;
1772 if (mutex_lock_interruptible(&dev->lock)) {
1773 kfree(fh);
1774 return -ERESTARTSYS;
1775 }
1776 fh->dev = dev;
1777 fh->type = fh_type;
1778 filp->private_data = fh;
1779 v4l2_fh_init(&fh->fh, vdev);
1780
1781 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE && dev->users == 0) {
1782 /* Power up in Analog TV mode */
1783 if (dev->board.external_av)
1784 cx231xx_set_power_mode(dev,
1785 POLARIS_AVMODE_ENXTERNAL_AV);
1786 else
1787 cx231xx_set_power_mode(dev, POLARIS_AVMODE_ANALOGT_TV);
1788
1789 #if 0
1790 cx231xx_set_mode(dev, CX231XX_ANALOG_MODE);
1791 #endif
1792
1793 /* set video alternate setting */
1794 cx231xx_set_video_alternate(dev);
1795
1796 /* Needed, since GPIO might have disabled power of
1797 some i2c device */
1798 cx231xx_config_i2c(dev);
1799
1800 /* device needs to be initialized before isoc transfer */
1801 dev->video_input = dev->video_input > 2 ? 2 : dev->video_input;
1802
1803 }
1804 if (radio) {
1805 cx231xx_videodbg("video_open: setting radio device\n");
1806
1807 /* cx231xx_start_radio(dev); */
1808
1809 call_all(dev, tuner, s_radio);
1810 }
1811
1812 dev->users++;
1813
1814 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1815 videobuf_queue_vmalloc_init(&fh->vb_vidq, &cx231xx_video_qops,
1816 NULL, &dev->video_mode.slock,
1817 fh->type, V4L2_FIELD_INTERLACED,
1818 sizeof(struct cx231xx_buffer),
1819 fh, &dev->lock);
1820 if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
1821 /* Set the required alternate setting VBI interface works in
1822 Bulk mode only */
1823 cx231xx_set_alt_setting(dev, INDEX_VANC, 0);
1824
1825 videobuf_queue_vmalloc_init(&fh->vb_vidq, &cx231xx_vbi_qops,
1826 NULL, &dev->vbi_mode.slock,
1827 fh->type, V4L2_FIELD_SEQ_TB,
1828 sizeof(struct cx231xx_buffer),
1829 fh, &dev->lock);
1830 }
1831 mutex_unlock(&dev->lock);
1832 v4l2_fh_add(&fh->fh);
1833
1834 return 0;
1835 }
1836
1837 /*
1838 * cx231xx_realease_resources()
1839 * unregisters the v4l2,i2c and usb devices
1840 * called when the device gets disconnected or at module unload
1841 */
1842 void cx231xx_release_analog_resources(struct cx231xx *dev)
1843 {
1844
1845 /*FIXME: I2C IR should be disconnected */
1846
1847 if (video_is_registered(&dev->radio_dev))
1848 video_unregister_device(&dev->radio_dev);
1849 if (video_is_registered(&dev->vbi_dev)) {
1850 dev_info(dev->dev, "V4L2 device %s deregistered\n",
1851 video_device_node_name(&dev->vbi_dev));
1852 video_unregister_device(&dev->vbi_dev);
1853 }
1854 if (video_is_registered(&dev->vdev)) {
1855 dev_info(dev->dev, "V4L2 device %s deregistered\n",
1856 video_device_node_name(&dev->vdev));
1857
1858 if (dev->board.has_417)
1859 cx231xx_417_unregister(dev);
1860
1861 video_unregister_device(&dev->vdev);
1862 }
1863 v4l2_ctrl_handler_free(&dev->ctrl_handler);
1864 v4l2_ctrl_handler_free(&dev->radio_ctrl_handler);
1865 }
1866
1867 /*
1868 * cx231xx_close()
1869 * stops streaming and deallocates all resources allocated by the v4l2
1870 * calls and ioctls
1871 */
1872 static int cx231xx_close(struct file *filp)
1873 {
1874 struct cx231xx_fh *fh = filp->private_data;
1875 struct cx231xx *dev = fh->dev;
1876
1877 cx231xx_videodbg("users=%d\n", dev->users);
1878
1879 cx231xx_videodbg("users=%d\n", dev->users);
1880 if (res_check(fh))
1881 res_free(fh);
1882
1883 /*
1884 * To workaround error number=-71 on EP0 for VideoGrabber,
1885 * need exclude following.
1886 * FIXME: It is probably safe to remove most of these, as we're
1887 * now avoiding the alternate setting for INDEX_VANC
1888 */
1889 if (!dev->board.no_alt_vanc)
1890 if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
1891 videobuf_stop(&fh->vb_vidq);
1892 videobuf_mmap_free(&fh->vb_vidq);
1893
1894 /* the device is already disconnect,
1895 free the remaining resources */
1896 if (dev->state & DEV_DISCONNECTED) {
1897 if (atomic_read(&dev->devlist_count) > 0) {
1898 cx231xx_release_resources(dev);
1899 fh->dev = NULL;
1900 return 0;
1901 }
1902 return 0;
1903 }
1904
1905 /* do this before setting alternate! */
1906 cx231xx_uninit_vbi_isoc(dev);
1907
1908 /* set alternate 0 */
1909 if (!dev->vbi_or_sliced_cc_mode)
1910 cx231xx_set_alt_setting(dev, INDEX_VANC, 0);
1911 else
1912 cx231xx_set_alt_setting(dev, INDEX_HANC, 0);
1913
1914 v4l2_fh_del(&fh->fh);
1915 v4l2_fh_exit(&fh->fh);
1916 kfree(fh);
1917 dev->users--;
1918 wake_up_interruptible(&dev->open);
1919 return 0;
1920 }
1921
1922 v4l2_fh_del(&fh->fh);
1923 dev->users--;
1924 if (!dev->users) {
1925 videobuf_stop(&fh->vb_vidq);
1926 videobuf_mmap_free(&fh->vb_vidq);
1927
1928 /* the device is already disconnect,
1929 free the remaining resources */
1930 if (dev->state & DEV_DISCONNECTED) {
1931 cx231xx_release_resources(dev);
1932 fh->dev = NULL;
1933 return 0;
1934 }
1935
1936 /* Save some power by putting tuner to sleep */
1937 call_all(dev, tuner, standby);
1938
1939 /* do this before setting alternate! */
1940 if (dev->USE_ISO)
1941 cx231xx_uninit_isoc(dev);
1942 else
1943 cx231xx_uninit_bulk(dev);
1944 cx231xx_set_mode(dev, CX231XX_SUSPEND);
1945
1946 /* set alternate 0 */
1947 cx231xx_set_alt_setting(dev, INDEX_VIDEO, 0);
1948 }
1949 v4l2_fh_exit(&fh->fh);
1950 kfree(fh);
1951 wake_up_interruptible(&dev->open);
1952 return 0;
1953 }
1954
1955 static int cx231xx_v4l2_close(struct file *filp)
1956 {
1957 struct cx231xx_fh *fh = filp->private_data;
1958 struct cx231xx *dev = fh->dev;
1959 int rc;
1960
1961 mutex_lock(&dev->lock);
1962 rc = cx231xx_close(filp);
1963 mutex_unlock(&dev->lock);
1964 return rc;
1965 }
1966
1967 /*
1968 * cx231xx_v4l2_read()
1969 * will allocate buffers when called for the first time
1970 */
1971 static ssize_t
1972 cx231xx_v4l2_read(struct file *filp, char __user *buf, size_t count,
1973 loff_t *pos)
1974 {
1975 struct cx231xx_fh *fh = filp->private_data;
1976 struct cx231xx *dev = fh->dev;
1977 int rc;
1978
1979 rc = check_dev(dev);
1980 if (rc < 0)
1981 return rc;
1982
1983 if ((fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) ||
1984 (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)) {
1985 rc = res_get(fh);
1986
1987 if (unlikely(rc < 0))
1988 return rc;
1989
1990 if (mutex_lock_interruptible(&dev->lock))
1991 return -ERESTARTSYS;
1992 rc = videobuf_read_stream(&fh->vb_vidq, buf, count, pos, 0,
1993 filp->f_flags & O_NONBLOCK);
1994 mutex_unlock(&dev->lock);
1995 return rc;
1996 }
1997 return 0;
1998 }
1999
2000 /*
2001 * cx231xx_v4l2_poll()
2002 * will allocate buffers when called for the first time
2003 */
2004 static __poll_t cx231xx_v4l2_poll(struct file *filp, poll_table *wait)
2005 {
2006 __poll_t req_events = poll_requested_events(wait);
2007 struct cx231xx_fh *fh = filp->private_data;
2008 struct cx231xx *dev = fh->dev;
2009 __poll_t res = 0;
2010 int rc;
2011
2012 rc = check_dev(dev);
2013 if (rc < 0)
2014 return EPOLLERR;
2015
2016 rc = res_get(fh);
2017
2018 if (unlikely(rc < 0))
2019 return EPOLLERR;
2020
2021 if (v4l2_event_pending(&fh->fh))
2022 res |= EPOLLPRI;
2023 else
2024 poll_wait(filp, &fh->fh.wait, wait);
2025
2026 if (!(req_events & (EPOLLIN | EPOLLRDNORM)))
2027 return res;
2028
2029 if ((V4L2_BUF_TYPE_VIDEO_CAPTURE == fh->type) ||
2030 (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type)) {
2031 mutex_lock(&dev->lock);
2032 res |= videobuf_poll_stream(filp, &fh->vb_vidq, wait);
2033 mutex_unlock(&dev->lock);
2034 return res;
2035 }
2036 return res | EPOLLERR;
2037 }
2038
2039 /*
2040 * cx231xx_v4l2_mmap()
2041 */
2042 static int cx231xx_v4l2_mmap(struct file *filp, struct vm_area_struct *vma)
2043 {
2044 struct cx231xx_fh *fh = filp->private_data;
2045 struct cx231xx *dev = fh->dev;
2046 int rc;
2047
2048 rc = check_dev(dev);
2049 if (rc < 0)
2050 return rc;
2051
2052 rc = res_get(fh);
2053
2054 if (unlikely(rc < 0))
2055 return rc;
2056
2057 if (mutex_lock_interruptible(&dev->lock))
2058 return -ERESTARTSYS;
2059 rc = videobuf_mmap_mapper(&fh->vb_vidq, vma);
2060 mutex_unlock(&dev->lock);
2061
2062 cx231xx_videodbg("vma start=0x%08lx, size=%ld, ret=%d\n",
2063 (unsigned long)vma->vm_start,
2064 (unsigned long)vma->vm_end -
2065 (unsigned long)vma->vm_start, rc);
2066
2067 return rc;
2068 }
2069
2070 static const struct v4l2_file_operations cx231xx_v4l_fops = {
2071 .owner = THIS_MODULE,
2072 .open = cx231xx_v4l2_open,
2073 .release = cx231xx_v4l2_close,
2074 .read = cx231xx_v4l2_read,
2075 .poll = cx231xx_v4l2_poll,
2076 .mmap = cx231xx_v4l2_mmap,
2077 .unlocked_ioctl = video_ioctl2,
2078 };
2079
2080 static const struct v4l2_ioctl_ops video_ioctl_ops = {
2081 .vidioc_querycap = cx231xx_querycap,
2082 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
2083 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
2084 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
2085 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
2086 .vidioc_g_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
2087 .vidioc_try_fmt_vbi_cap = vidioc_try_fmt_vbi_cap,
2088 .vidioc_s_fmt_vbi_cap = vidioc_s_fmt_vbi_cap,
2089 .vidioc_g_pixelaspect = vidioc_g_pixelaspect,
2090 .vidioc_g_selection = vidioc_g_selection,
2091 .vidioc_reqbufs = vidioc_reqbufs,
2092 .vidioc_querybuf = vidioc_querybuf,
2093 .vidioc_qbuf = vidioc_qbuf,
2094 .vidioc_dqbuf = vidioc_dqbuf,
2095 .vidioc_s_std = vidioc_s_std,
2096 .vidioc_g_std = vidioc_g_std,
2097 .vidioc_enum_input = cx231xx_enum_input,
2098 .vidioc_g_input = cx231xx_g_input,
2099 .vidioc_s_input = cx231xx_s_input,
2100 .vidioc_streamon = vidioc_streamon,
2101 .vidioc_streamoff = vidioc_streamoff,
2102 .vidioc_g_tuner = cx231xx_g_tuner,
2103 .vidioc_s_tuner = cx231xx_s_tuner,
2104 .vidioc_g_frequency = cx231xx_g_frequency,
2105 .vidioc_s_frequency = cx231xx_s_frequency,
2106 #ifdef CONFIG_VIDEO_ADV_DEBUG
2107 .vidioc_g_chip_info = cx231xx_g_chip_info,
2108 .vidioc_g_register = cx231xx_g_register,
2109 .vidioc_s_register = cx231xx_s_register,
2110 #endif
2111 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
2112 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
2113 };
2114
2115 static struct video_device cx231xx_vbi_template;
2116
2117 static const struct video_device cx231xx_video_template = {
2118 .fops = &cx231xx_v4l_fops,
2119 .release = video_device_release_empty,
2120 .ioctl_ops = &video_ioctl_ops,
2121 .tvnorms = V4L2_STD_ALL,
2122 };
2123
2124 static const struct v4l2_file_operations radio_fops = {
2125 .owner = THIS_MODULE,
2126 .open = cx231xx_v4l2_open,
2127 .release = cx231xx_v4l2_close,
2128 .poll = v4l2_ctrl_poll,
2129 .unlocked_ioctl = video_ioctl2,
2130 };
2131
2132 static const struct v4l2_ioctl_ops radio_ioctl_ops = {
2133 .vidioc_querycap = cx231xx_querycap,
2134 .vidioc_g_tuner = radio_g_tuner,
2135 .vidioc_s_tuner = radio_s_tuner,
2136 .vidioc_g_frequency = cx231xx_g_frequency,
2137 .vidioc_s_frequency = cx231xx_s_frequency,
2138 #ifdef CONFIG_VIDEO_ADV_DEBUG
2139 .vidioc_g_chip_info = cx231xx_g_chip_info,
2140 .vidioc_g_register = cx231xx_g_register,
2141 .vidioc_s_register = cx231xx_s_register,
2142 #endif
2143 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
2144 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
2145 };
2146
2147 static struct video_device cx231xx_radio_template = {
2148 .name = "cx231xx-radio",
2149 .fops = &radio_fops,
2150 .ioctl_ops = &radio_ioctl_ops,
2151 };
2152
2153 /******************************** usb interface ******************************/
2154
2155 static void cx231xx_vdev_init(struct cx231xx *dev,
2156 struct video_device *vfd,
2157 const struct video_device *template,
2158 const char *type_name)
2159 {
2160 *vfd = *template;
2161 vfd->v4l2_dev = &dev->v4l2_dev;
2162 vfd->release = video_device_release_empty;
2163 vfd->lock = &dev->lock;
2164
2165 snprintf(vfd->name, sizeof(vfd->name), "%s %s", dev->name, type_name);
2166
2167 video_set_drvdata(vfd, dev);
2168 if (dev->tuner_type == TUNER_ABSENT) {
2169 v4l2_disable_ioctl(vfd, VIDIOC_G_FREQUENCY);
2170 v4l2_disable_ioctl(vfd, VIDIOC_S_FREQUENCY);
2171 v4l2_disable_ioctl(vfd, VIDIOC_G_TUNER);
2172 v4l2_disable_ioctl(vfd, VIDIOC_S_TUNER);
2173 }
2174 }
2175
2176 int cx231xx_register_analog_devices(struct cx231xx *dev)
2177 {
2178 int ret;
2179
2180 dev_info(dev->dev, "v4l2 driver version %s\n", CX231XX_VERSION);
2181
2182 /* set default norm */
2183 dev->norm = V4L2_STD_PAL;
2184 dev->width = norm_maxw(dev);
2185 dev->height = norm_maxh(dev);
2186 dev->interlaced = 0;
2187
2188 /* Analog specific initialization */
2189 dev->format = &format[0];
2190
2191 /* Set the initial input */
2192 video_mux(dev, dev->video_input);
2193
2194 call_all(dev, video, s_std, dev->norm);
2195
2196 v4l2_ctrl_handler_init(&dev->ctrl_handler, 10);
2197 v4l2_ctrl_handler_init(&dev->radio_ctrl_handler, 5);
2198
2199 if (dev->sd_cx25840) {
2200 v4l2_ctrl_add_handler(&dev->ctrl_handler,
2201 dev->sd_cx25840->ctrl_handler, NULL, true);
2202 v4l2_ctrl_add_handler(&dev->radio_ctrl_handler,
2203 dev->sd_cx25840->ctrl_handler,
2204 v4l2_ctrl_radio_filter, true);
2205 }
2206
2207 if (dev->ctrl_handler.error)
2208 return dev->ctrl_handler.error;
2209 if (dev->radio_ctrl_handler.error)
2210 return dev->radio_ctrl_handler.error;
2211
2212 /* enable vbi capturing */
2213 /* write code here... */
2214
2215 /* allocate and fill video video_device struct */
2216 cx231xx_vdev_init(dev, &dev->vdev, &cx231xx_video_template, "video");
2217 #if defined(CONFIG_MEDIA_CONTROLLER)
2218 dev->video_pad.flags = MEDIA_PAD_FL_SINK;
2219 ret = media_entity_pads_init(&dev->vdev.entity, 1, &dev->video_pad);
2220 if (ret < 0)
2221 dev_err(dev->dev, "failed to initialize video media entity!\n");
2222 #endif
2223 dev->vdev.ctrl_handler = &dev->ctrl_handler;
2224 dev->vdev.device_caps = V4L2_CAP_READWRITE | V4L2_CAP_STREAMING |
2225 V4L2_CAP_VIDEO_CAPTURE;
2226 if (dev->tuner_type != TUNER_ABSENT)
2227 dev->vdev.device_caps |= V4L2_CAP_TUNER;
2228
2229 /* register v4l2 video video_device */
2230 ret = video_register_device(&dev->vdev, VFL_TYPE_GRABBER,
2231 video_nr[dev->devno]);
2232 if (ret) {
2233 dev_err(dev->dev,
2234 "unable to register video device (error=%i).\n",
2235 ret);
2236 return ret;
2237 }
2238
2239 dev_info(dev->dev, "Registered video device %s [v4l2]\n",
2240 video_device_node_name(&dev->vdev));
2241
2242 /* Initialize VBI template */
2243 cx231xx_vbi_template = cx231xx_video_template;
2244 strscpy(cx231xx_vbi_template.name, "cx231xx-vbi",
2245 sizeof(cx231xx_vbi_template.name));
2246
2247 /* Allocate and fill vbi video_device struct */
2248 cx231xx_vdev_init(dev, &dev->vbi_dev, &cx231xx_vbi_template, "vbi");
2249
2250 #if defined(CONFIG_MEDIA_CONTROLLER)
2251 dev->vbi_pad.flags = MEDIA_PAD_FL_SINK;
2252 ret = media_entity_pads_init(&dev->vbi_dev.entity, 1, &dev->vbi_pad);
2253 if (ret < 0)
2254 dev_err(dev->dev, "failed to initialize vbi media entity!\n");
2255 #endif
2256 dev->vbi_dev.ctrl_handler = &dev->ctrl_handler;
2257 dev->vbi_dev.device_caps = V4L2_CAP_READWRITE | V4L2_CAP_STREAMING |
2258 V4L2_CAP_VBI_CAPTURE;
2259 if (dev->tuner_type != TUNER_ABSENT)
2260 dev->vbi_dev.device_caps |= V4L2_CAP_TUNER;
2261
2262 /* register v4l2 vbi video_device */
2263 ret = video_register_device(&dev->vbi_dev, VFL_TYPE_VBI,
2264 vbi_nr[dev->devno]);
2265 if (ret < 0) {
2266 dev_err(dev->dev, "unable to register vbi device\n");
2267 return ret;
2268 }
2269
2270 dev_info(dev->dev, "Registered VBI device %s\n",
2271 video_device_node_name(&dev->vbi_dev));
2272
2273 if (cx231xx_boards[dev->model].radio.type == CX231XX_RADIO) {
2274 cx231xx_vdev_init(dev, &dev->radio_dev,
2275 &cx231xx_radio_template, "radio");
2276 dev->radio_dev.ctrl_handler = &dev->radio_ctrl_handler;
2277 dev->radio_dev.device_caps = V4L2_CAP_RADIO | V4L2_CAP_TUNER;
2278 ret = video_register_device(&dev->radio_dev, VFL_TYPE_RADIO,
2279 radio_nr[dev->devno]);
2280 if (ret < 0) {
2281 dev_err(dev->dev,
2282 "can't register radio device\n");
2283 return ret;
2284 }
2285 dev_info(dev->dev, "Registered radio device as %s\n",
2286 video_device_node_name(&dev->radio_dev));
2287 }
2288
2289 return 0;
2290 }
Linux with added FPC-III support