2 * This is a V4L2 PCI Skeleton Driver. It gives an initial skeleton source
3 * for use with other PCI drivers.
5 * This skeleton PCI driver assumes that the card has an S-Video connector as
6 * input 0 and an HDMI connector as input 1.
8 * Copyright 2014 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
10 * This program is free software; you may redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; version 2 of the License.
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
15 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
16 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
17 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
18 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
19 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
20 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
24 #include <linux/types.h>
25 #include <linux/kernel.h>
26 #include <linux/module.h>
27 #include <linux/init.h>
28 #include <linux/kmod.h>
29 #include <linux/mutex.h>
30 #include <linux/pci.h>
31 #include <linux/interrupt.h>
32 #include <linux/videodev2.h>
33 #include <linux/v4l2-dv-timings.h>
34 #include <media/v4l2-device.h>
35 #include <media/v4l2-dev.h>
36 #include <media/v4l2-ioctl.h>
37 #include <media/v4l2-dv-timings.h>
38 #include <media/v4l2-ctrls.h>
39 #include <media/v4l2-event.h>
40 #include <media/videobuf2-v4l2.h>
41 #include <media/videobuf2-dma-contig.h>
43 MODULE_DESCRIPTION("V4L2 PCI Skeleton Driver");
44 MODULE_AUTHOR("Hans Verkuil");
45 MODULE_LICENSE("GPL v2");
48 * struct skeleton - All internal data for one instance of device
50 * @v4l2_dev: top-level v4l2 device struct
51 * @vdev: video node structure
52 * @ctrl_handler: control handler structure
53 * @lock: ioctl serialization mutex
54 * @std: current SDTV standard
55 * @timings: current HDTV timings
56 * @format: current pix format
57 * @input: current video input (0 = SDTV, 1 = HDTV)
58 * @queue: vb2 video capture queue
59 * @qlock: spinlock controlling access to buf_list and sequence
60 * @buf_list: list of buffers queued for DMA
61 * @sequence: frame sequence counter
65 struct v4l2_device v4l2_dev
;
66 struct video_device vdev
;
67 struct v4l2_ctrl_handler ctrl_handler
;
70 struct v4l2_dv_timings timings
;
71 struct v4l2_pix_format format
;
74 struct vb2_queue queue
;
77 struct list_head buf_list
;
84 struct list_head list
;
87 static inline struct skel_buffer
*to_skel_buffer(struct vb2_buffer
*vb2
)
89 return container_of(vb2
, struct skel_buffer
, vb
);
92 static const struct pci_device_id skeleton_pci_tbl
[] = {
93 /* { PCI_DEVICE(PCI_VENDOR_ID_, PCI_DEVICE_ID_) }, */
96 MODULE_DEVICE_TABLE(pci
, skeleton_pci_tbl
);
99 * HDTV: this structure has the capabilities of the HDTV receiver.
100 * It is used to constrain the huge list of possible formats based
101 * upon the hardware capabilities.
103 static const struct v4l2_dv_timings_cap skel_timings_cap
= {
104 .type
= V4L2_DV_BT_656_1120
,
105 /* keep this initialization for compatibility with GCC < 4.4.6 */
107 V4L2_INIT_BT_TIMINGS(
108 720, 1920, /* min/max width */
109 480, 1080, /* min/max height */
110 27000000, 74250000, /* min/max pixelclock*/
111 V4L2_DV_BT_STD_CEA861
, /* Supported standards */
113 V4L2_DV_BT_CAP_INTERLACED
| V4L2_DV_BT_CAP_PROGRESSIVE
118 * Supported SDTV standards. This does the same job as skel_timings_cap, but
119 * for standard TV formats.
121 #define SKEL_TVNORMS V4L2_STD_ALL
124 * Interrupt handler: typically interrupts happen after a new frame has been
125 * captured. It is the job of the handler to remove the new frame from the
126 * internal list and give it back to the vb2 framework, updating the sequence
127 * counter, field and timestamp at the same time.
129 static irqreturn_t
skeleton_irq(int irq
, void *dev_id
)
132 struct skeleton
*skel
= dev_id
;
134 /* handle interrupt */
136 /* Once a new frame has been captured, mark it as done like this: */
137 if (captured_new_frame
) {
139 spin_lock(&skel
->qlock
);
140 list_del(&new_buf
->list
);
141 spin_unlock(&skel
->qlock
);
142 v4l2_get_timestamp(&new_buf
->vb
.v4l2_buf
.timestamp
);
143 new_buf
->vb
.v4l2_buf
.sequence
= skel
->sequence
++;
144 new_buf
->vb
.v4l2_buf
.field
= skel
->field
;
145 if (skel
->format
.field
== V4L2_FIELD_ALTERNATE
) {
146 if (skel
->field
== V4L2_FIELD_BOTTOM
)
147 skel
->field
= V4L2_FIELD_TOP
;
148 else if (skel
->field
== V4L2_FIELD_TOP
)
149 skel
->field
= V4L2_FIELD_BOTTOM
;
151 vb2_buffer_done(&new_buf
->vb
, VB2_BUF_STATE_DONE
);
158 * Setup the constraints of the queue: besides setting the number of planes
159 * per buffer and the size and allocation context of each plane, it also
160 * checks if sufficient buffers have been allocated. Usually 3 is a good
161 * minimum number: many DMA engines need a minimum of 2 buffers in the
162 * queue and you need to have another available for userspace processing.
164 static int queue_setup(struct vb2_queue
*vq
,
165 unsigned int *nbuffers
, unsigned int *nplanes
,
166 unsigned int sizes
[], struct device
*alloc_devs
[])
168 struct skeleton
*skel
= vb2_get_drv_priv(vq
);
170 skel
->field
= skel
->format
.field
;
171 if (skel
->field
== V4L2_FIELD_ALTERNATE
) {
173 * You cannot use read() with FIELD_ALTERNATE since the field
174 * information (TOP/BOTTOM) cannot be passed back to the user.
176 if (vb2_fileio_is_active(vq
))
178 skel
->field
= V4L2_FIELD_TOP
;
181 if (vq
->num_buffers
+ *nbuffers
< 3)
182 *nbuffers
= 3 - vq
->num_buffers
;
185 return sizes
[0] < skel
->format
.sizeimage
? -EINVAL
: 0;
187 sizes
[0] = skel
->format
.sizeimage
;
192 * Prepare the buffer for queueing to the DMA engine: check and set the
195 static int buffer_prepare(struct vb2_buffer
*vb
)
197 struct skeleton
*skel
= vb2_get_drv_priv(vb
->vb2_queue
);
198 unsigned long size
= skel
->format
.sizeimage
;
200 if (vb2_plane_size(vb
, 0) < size
) {
201 dev_err(&skel
->pdev
->dev
, "buffer too small (%lu < %lu)\n",
202 vb2_plane_size(vb
, 0), size
);
206 vb2_set_plane_payload(vb
, 0, size
);
211 * Queue this buffer to the DMA engine.
213 static void buffer_queue(struct vb2_buffer
*vb
)
215 struct skeleton
*skel
= vb2_get_drv_priv(vb
->vb2_queue
);
216 struct skel_buffer
*buf
= to_skel_buffer(vb
);
219 spin_lock_irqsave(&skel
->qlock
, flags
);
220 list_add_tail(&buf
->list
, &skel
->buf_list
);
222 /* TODO: Update any DMA pointers if necessary */
224 spin_unlock_irqrestore(&skel
->qlock
, flags
);
227 static void return_all_buffers(struct skeleton
*skel
,
228 enum vb2_buffer_state state
)
230 struct skel_buffer
*buf
, *node
;
233 spin_lock_irqsave(&skel
->qlock
, flags
);
234 list_for_each_entry_safe(buf
, node
, &skel
->buf_list
, list
) {
235 vb2_buffer_done(&buf
->vb
, state
);
236 list_del(&buf
->list
);
238 spin_unlock_irqrestore(&skel
->qlock
, flags
);
242 * Start streaming. First check if the minimum number of buffers have been
243 * queued. If not, then return -ENOBUFS and the vb2 framework will call
244 * this function again the next time a buffer has been queued until enough
245 * buffers are available to actually start the DMA engine.
247 static int start_streaming(struct vb2_queue
*vq
, unsigned int count
)
249 struct skeleton
*skel
= vb2_get_drv_priv(vq
);
254 /* TODO: start DMA */
258 * In case of an error, return all active buffers to the
261 return_all_buffers(skel
, VB2_BUF_STATE_QUEUED
);
267 * Stop the DMA engine. Any remaining buffers in the DMA queue are dequeued
268 * and passed on to the vb2 framework marked as STATE_ERROR.
270 static void stop_streaming(struct vb2_queue
*vq
)
272 struct skeleton
*skel
= vb2_get_drv_priv(vq
);
276 /* Release all active buffers */
277 return_all_buffers(skel
, VB2_BUF_STATE_ERROR
);
281 * The vb2 queue ops. Note that since q->lock is set we can use the standard
282 * vb2_ops_wait_prepare/finish helper functions. If q->lock would be NULL,
283 * then this driver would have to provide these ops.
285 static const struct vb2_ops skel_qops
= {
286 .queue_setup
= queue_setup
,
287 .buf_prepare
= buffer_prepare
,
288 .buf_queue
= buffer_queue
,
289 .start_streaming
= start_streaming
,
290 .stop_streaming
= stop_streaming
,
291 .wait_prepare
= vb2_ops_wait_prepare
,
292 .wait_finish
= vb2_ops_wait_finish
,
296 * Required ioctl querycap. Note that the version field is prefilled with
297 * the version of the kernel.
299 static int skeleton_querycap(struct file
*file
, void *priv
,
300 struct v4l2_capability
*cap
)
302 struct skeleton
*skel
= video_drvdata(file
);
304 strlcpy(cap
->driver
, KBUILD_MODNAME
, sizeof(cap
->driver
));
305 strlcpy(cap
->card
, "V4L2 PCI Skeleton", sizeof(cap
->card
));
306 snprintf(cap
->bus_info
, sizeof(cap
->bus_info
), "PCI:%s",
307 pci_name(skel
->pdev
));
312 * Helper function to check and correct struct v4l2_pix_format. It's used
313 * not only in VIDIOC_TRY/S_FMT, but also elsewhere if changes to the SDTV
314 * standard, HDTV timings or the video input would require updating the
317 static void skeleton_fill_pix_format(struct skeleton
*skel
,
318 struct v4l2_pix_format
*pix
)
320 pix
->pixelformat
= V4L2_PIX_FMT_YUYV
;
321 if (skel
->input
== 0) {
324 pix
->height
= (skel
->std
& V4L2_STD_525_60
) ? 480 : 576;
325 pix
->field
= V4L2_FIELD_INTERLACED
;
326 pix
->colorspace
= V4L2_COLORSPACE_SMPTE170M
;
329 pix
->width
= skel
->timings
.bt
.width
;
330 pix
->height
= skel
->timings
.bt
.height
;
331 if (skel
->timings
.bt
.interlaced
) {
332 pix
->field
= V4L2_FIELD_ALTERNATE
;
335 pix
->field
= V4L2_FIELD_NONE
;
337 pix
->colorspace
= V4L2_COLORSPACE_REC709
;
341 * The YUYV format is four bytes for every two pixels, so bytesperline
344 pix
->bytesperline
= pix
->width
* 2;
345 pix
->sizeimage
= pix
->bytesperline
* pix
->height
;
349 static int skeleton_try_fmt_vid_cap(struct file
*file
, void *priv
,
350 struct v4l2_format
*f
)
352 struct skeleton
*skel
= video_drvdata(file
);
353 struct v4l2_pix_format
*pix
= &f
->fmt
.pix
;
356 * Due to historical reasons providing try_fmt with an unsupported
357 * pixelformat will return -EINVAL for video receivers. Webcam drivers,
358 * however, will silently correct the pixelformat. Some video capture
359 * applications rely on this behavior...
361 if (pix
->pixelformat
!= V4L2_PIX_FMT_YUYV
)
363 skeleton_fill_pix_format(skel
, pix
);
367 static int skeleton_s_fmt_vid_cap(struct file
*file
, void *priv
,
368 struct v4l2_format
*f
)
370 struct skeleton
*skel
= video_drvdata(file
);
373 ret
= skeleton_try_fmt_vid_cap(file
, priv
, f
);
378 * It is not allowed to change the format while buffers for use with
379 * streaming have already been allocated.
381 if (vb2_is_busy(&skel
->queue
))
384 /* TODO: change format */
385 skel
->format
= f
->fmt
.pix
;
389 static int skeleton_g_fmt_vid_cap(struct file
*file
, void *priv
,
390 struct v4l2_format
*f
)
392 struct skeleton
*skel
= video_drvdata(file
);
394 f
->fmt
.pix
= skel
->format
;
398 static int skeleton_enum_fmt_vid_cap(struct file
*file
, void *priv
,
399 struct v4l2_fmtdesc
*f
)
404 f
->pixelformat
= V4L2_PIX_FMT_YUYV
;
408 static int skeleton_s_std(struct file
*file
, void *priv
, v4l2_std_id std
)
410 struct skeleton
*skel
= video_drvdata(file
);
412 /* S_STD is not supported on the HDMI input */
417 * No change, so just return. Some applications call S_STD again after
418 * the buffers for streaming have been set up, so we have to allow for
421 if (std
== skel
->std
)
425 * Changing the standard implies a format change, which is not allowed
426 * while buffers for use with streaming have already been allocated.
428 if (vb2_is_busy(&skel
->queue
))
431 /* TODO: handle changing std */
435 /* Update the internal format */
436 skeleton_fill_pix_format(skel
, &skel
->format
);
440 static int skeleton_g_std(struct file
*file
, void *priv
, v4l2_std_id
*std
)
442 struct skeleton
*skel
= video_drvdata(file
);
444 /* G_STD is not supported on the HDMI input */
453 * Query the current standard as seen by the hardware. This function shall
454 * never actually change the standard, it just detects and reports.
455 * The framework will initially set *std to tvnorms (i.e. the set of
456 * supported standards by this input), and this function should just AND
457 * this value. If there is no signal, then *std should be set to 0.
459 static int skeleton_querystd(struct file
*file
, void *priv
, v4l2_std_id
*std
)
461 struct skeleton
*skel
= video_drvdata(file
);
463 /* QUERY_STD is not supported on the HDMI input */
469 * Query currently seen standard. Initial value of *std is
470 * V4L2_STD_ALL. This function should look something like this:
477 /* Use signal information to reduce the number of possible standards */
478 if (signal_has_525_lines
)
479 *std
&= V4L2_STD_525_60
;
481 *std
&= V4L2_STD_625_50
;
486 static int skeleton_s_dv_timings(struct file
*file
, void *_fh
,
487 struct v4l2_dv_timings
*timings
)
489 struct skeleton
*skel
= video_drvdata(file
);
491 /* S_DV_TIMINGS is not supported on the S-Video input */
492 if (skel
->input
== 0)
495 /* Quick sanity check */
496 if (!v4l2_valid_dv_timings(timings
, &skel_timings_cap
, NULL
, NULL
))
499 /* Check if the timings are part of the CEA-861 timings. */
500 if (!v4l2_find_dv_timings_cap(timings
, &skel_timings_cap
,
504 /* Return 0 if the new timings are the same as the current timings. */
505 if (v4l2_match_dv_timings(timings
, &skel
->timings
, 0, false))
509 * Changing the timings implies a format change, which is not allowed
510 * while buffers for use with streaming have already been allocated.
512 if (vb2_is_busy(&skel
->queue
))
515 /* TODO: Configure new timings */
518 skel
->timings
= *timings
;
520 /* Update the internal format */
521 skeleton_fill_pix_format(skel
, &skel
->format
);
525 static int skeleton_g_dv_timings(struct file
*file
, void *_fh
,
526 struct v4l2_dv_timings
*timings
)
528 struct skeleton
*skel
= video_drvdata(file
);
530 /* G_DV_TIMINGS is not supported on the S-Video input */
531 if (skel
->input
== 0)
534 *timings
= skel
->timings
;
538 static int skeleton_enum_dv_timings(struct file
*file
, void *_fh
,
539 struct v4l2_enum_dv_timings
*timings
)
541 struct skeleton
*skel
= video_drvdata(file
);
543 /* ENUM_DV_TIMINGS is not supported on the S-Video input */
544 if (skel
->input
== 0)
547 return v4l2_enum_dv_timings_cap(timings
, &skel_timings_cap
,
552 * Query the current timings as seen by the hardware. This function shall
553 * never actually change the timings, it just detects and reports.
554 * If no signal is detected, then return -ENOLINK. If the hardware cannot
555 * lock to the signal, then return -ENOLCK. If the signal is out of range
556 * of the capabilities of the system (e.g., it is possible that the receiver
557 * can lock but that the DMA engine it is connected to cannot handle
558 * pixelclocks above a certain frequency), then -ERANGE is returned.
560 static int skeleton_query_dv_timings(struct file
*file
, void *_fh
,
561 struct v4l2_dv_timings
*timings
)
563 struct skeleton
*skel
= video_drvdata(file
);
565 /* QUERY_DV_TIMINGS is not supported on the S-Video input */
566 if (skel
->input
== 0)
571 * Query currently seen timings. This function should look
572 * something like this:
577 if (cannot_lock_to_signal
)
579 if (signal_out_of_range_of_capabilities
)
582 /* Useful for debugging */
583 v4l2_print_dv_timings(skel
->v4l2_dev
.name
, "query_dv_timings:",
589 static int skeleton_dv_timings_cap(struct file
*file
, void *fh
,
590 struct v4l2_dv_timings_cap
*cap
)
592 struct skeleton
*skel
= video_drvdata(file
);
594 /* DV_TIMINGS_CAP is not supported on the S-Video input */
595 if (skel
->input
== 0)
597 *cap
= skel_timings_cap
;
601 static int skeleton_enum_input(struct file
*file
, void *priv
,
602 struct v4l2_input
*i
)
607 i
->type
= V4L2_INPUT_TYPE_CAMERA
;
609 i
->std
= SKEL_TVNORMS
;
610 strlcpy(i
->name
, "S-Video", sizeof(i
->name
));
611 i
->capabilities
= V4L2_IN_CAP_STD
;
614 strlcpy(i
->name
, "HDMI", sizeof(i
->name
));
615 i
->capabilities
= V4L2_IN_CAP_DV_TIMINGS
;
620 static int skeleton_s_input(struct file
*file
, void *priv
, unsigned int i
)
622 struct skeleton
*skel
= video_drvdata(file
);
628 * Changing the input implies a format change, which is not allowed
629 * while buffers for use with streaming have already been allocated.
631 if (vb2_is_busy(&skel
->queue
))
636 * Update tvnorms. The tvnorms value is used by the core to implement
637 * VIDIOC_ENUMSTD so it has to be correct. If tvnorms == 0, then
638 * ENUMSTD will return -ENODATA.
640 skel
->vdev
.tvnorms
= i
? 0 : SKEL_TVNORMS
;
642 /* Update the internal format */
643 skeleton_fill_pix_format(skel
, &skel
->format
);
647 static int skeleton_g_input(struct file
*file
, void *priv
, unsigned int *i
)
649 struct skeleton
*skel
= video_drvdata(file
);
655 /* The control handler. */
656 static int skeleton_s_ctrl(struct v4l2_ctrl
*ctrl
)
658 /*struct skeleton *skel =
659 container_of(ctrl->handler, struct skeleton, ctrl_handler);*/
662 case V4L2_CID_BRIGHTNESS
:
663 /* TODO: set brightness to ctrl->val */
665 case V4L2_CID_CONTRAST
:
666 /* TODO: set contrast to ctrl->val */
668 case V4L2_CID_SATURATION
:
669 /* TODO: set saturation to ctrl->val */
672 /* TODO: set hue to ctrl->val */
680 /* ------------------------------------------------------------------
681 File operations for the device
682 ------------------------------------------------------------------*/
684 static const struct v4l2_ctrl_ops skel_ctrl_ops
= {
685 .s_ctrl
= skeleton_s_ctrl
,
689 * The set of all supported ioctls. Note that all the streaming ioctls
690 * use the vb2 helper functions that take care of all the locking and
691 * that also do ownership tracking (i.e. only the filehandle that requested
692 * the buffers can call the streaming ioctls, all other filehandles will
693 * receive -EBUSY if they attempt to call the same streaming ioctls).
695 * The last three ioctls also use standard helper functions: these implement
696 * standard behavior for drivers with controls.
698 static const struct v4l2_ioctl_ops skel_ioctl_ops
= {
699 .vidioc_querycap
= skeleton_querycap
,
700 .vidioc_try_fmt_vid_cap
= skeleton_try_fmt_vid_cap
,
701 .vidioc_s_fmt_vid_cap
= skeleton_s_fmt_vid_cap
,
702 .vidioc_g_fmt_vid_cap
= skeleton_g_fmt_vid_cap
,
703 .vidioc_enum_fmt_vid_cap
= skeleton_enum_fmt_vid_cap
,
705 .vidioc_g_std
= skeleton_g_std
,
706 .vidioc_s_std
= skeleton_s_std
,
707 .vidioc_querystd
= skeleton_querystd
,
709 .vidioc_s_dv_timings
= skeleton_s_dv_timings
,
710 .vidioc_g_dv_timings
= skeleton_g_dv_timings
,
711 .vidioc_enum_dv_timings
= skeleton_enum_dv_timings
,
712 .vidioc_query_dv_timings
= skeleton_query_dv_timings
,
713 .vidioc_dv_timings_cap
= skeleton_dv_timings_cap
,
715 .vidioc_enum_input
= skeleton_enum_input
,
716 .vidioc_g_input
= skeleton_g_input
,
717 .vidioc_s_input
= skeleton_s_input
,
719 .vidioc_reqbufs
= vb2_ioctl_reqbufs
,
720 .vidioc_create_bufs
= vb2_ioctl_create_bufs
,
721 .vidioc_querybuf
= vb2_ioctl_querybuf
,
722 .vidioc_qbuf
= vb2_ioctl_qbuf
,
723 .vidioc_dqbuf
= vb2_ioctl_dqbuf
,
724 .vidioc_expbuf
= vb2_ioctl_expbuf
,
725 .vidioc_streamon
= vb2_ioctl_streamon
,
726 .vidioc_streamoff
= vb2_ioctl_streamoff
,
728 .vidioc_log_status
= v4l2_ctrl_log_status
,
729 .vidioc_subscribe_event
= v4l2_ctrl_subscribe_event
,
730 .vidioc_unsubscribe_event
= v4l2_event_unsubscribe
,
734 * The set of file operations. Note that all these ops are standard core
737 static const struct v4l2_file_operations skel_fops
= {
738 .owner
= THIS_MODULE
,
739 .open
= v4l2_fh_open
,
740 .release
= vb2_fop_release
,
741 .unlocked_ioctl
= video_ioctl2
,
742 .read
= vb2_fop_read
,
743 .mmap
= vb2_fop_mmap
,
744 .poll
= vb2_fop_poll
,
748 * The initial setup of this device instance. Note that the initial state of
749 * the driver should be complete. So the initial format, standard, timings
750 * and video input should all be initialized to some reasonable value.
752 static int skeleton_probe(struct pci_dev
*pdev
, const struct pci_device_id
*ent
)
754 /* The initial timings are chosen to be 720p60. */
755 static const struct v4l2_dv_timings timings_def
=
756 V4L2_DV_BT_CEA_1280X720P60
;
757 struct skeleton
*skel
;
758 struct video_device
*vdev
;
759 struct v4l2_ctrl_handler
*hdl
;
764 ret
= pci_enable_device(pdev
);
767 ret
= pci_set_dma_mask(pdev
, DMA_BIT_MASK(32));
769 dev_err(&pdev
->dev
, "no suitable DMA available.\n");
773 /* Allocate a new instance */
774 skel
= devm_kzalloc(&pdev
->dev
, sizeof(struct skeleton
), GFP_KERNEL
);
778 /* Allocate the interrupt */
779 ret
= devm_request_irq(&pdev
->dev
, pdev
->irq
,
780 skeleton_irq
, 0, KBUILD_MODNAME
, skel
);
782 dev_err(&pdev
->dev
, "request_irq failed\n");
787 /* Fill in the initial format-related settings */
788 skel
->timings
= timings_def
;
789 skel
->std
= V4L2_STD_625_50
;
790 skeleton_fill_pix_format(skel
, &skel
->format
);
792 /* Initialize the top-level structure */
793 ret
= v4l2_device_register(&pdev
->dev
, &skel
->v4l2_dev
);
797 mutex_init(&skel
->lock
);
799 /* Add the controls */
800 hdl
= &skel
->ctrl_handler
;
801 v4l2_ctrl_handler_init(hdl
, 4);
802 v4l2_ctrl_new_std(hdl
, &skel_ctrl_ops
,
803 V4L2_CID_BRIGHTNESS
, 0, 255, 1, 127);
804 v4l2_ctrl_new_std(hdl
, &skel_ctrl_ops
,
805 V4L2_CID_CONTRAST
, 0, 255, 1, 16);
806 v4l2_ctrl_new_std(hdl
, &skel_ctrl_ops
,
807 V4L2_CID_SATURATION
, 0, 255, 1, 127);
808 v4l2_ctrl_new_std(hdl
, &skel_ctrl_ops
,
809 V4L2_CID_HUE
, -128, 127, 1, 0);
814 skel
->v4l2_dev
.ctrl_handler
= hdl
;
816 /* Initialize the vb2 queue */
818 q
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
819 q
->io_modes
= VB2_MMAP
| VB2_DMABUF
| VB2_READ
;
822 q
->buf_struct_size
= sizeof(struct skel_buffer
);
824 q
->mem_ops
= &vb2_dma_contig_memops
;
825 q
->timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC
;
827 * Assume that this DMA engine needs to have at least two buffers
828 * available before it can be started. The start_streaming() op
829 * won't be called until at least this many buffers are queued up.
831 q
->min_buffers_needed
= 2;
833 * The serialization lock for the streaming ioctls. This is the same
834 * as the main serialization lock, but if some of the non-streaming
835 * ioctls could take a long time to execute, then you might want to
836 * have a different lock here to prevent VIDIOC_DQBUF from being
837 * blocked while waiting for another action to finish. This is
838 * generally not needed for PCI devices, but USB devices usually do
839 * want a separate lock here.
841 q
->lock
= &skel
->lock
;
843 * Since this driver can only do 32-bit DMA we must make sure that
844 * the vb2 core will allocate the buffers in 32-bit DMA memory.
846 q
->gfp_flags
= GFP_DMA32
;
847 ret
= vb2_queue_init(q
);
851 INIT_LIST_HEAD(&skel
->buf_list
);
852 spin_lock_init(&skel
->qlock
);
854 /* Initialize the video_device structure */
856 strlcpy(vdev
->name
, KBUILD_MODNAME
, sizeof(vdev
->name
));
858 * There is nothing to clean up, so release is set to an empty release
859 * function. The release callback must be non-NULL.
861 vdev
->release
= video_device_release_empty
;
862 vdev
->fops
= &skel_fops
,
863 vdev
->ioctl_ops
= &skel_ioctl_ops
,
864 vdev
->device_caps
= V4L2_CAP_VIDEO_CAPTURE
| V4L2_CAP_READWRITE
|
867 * The main serialization lock. All ioctls are serialized by this
868 * lock. Exception: if q->lock is set, then the streaming ioctls
869 * are serialized by that separate lock.
871 vdev
->lock
= &skel
->lock
;
873 vdev
->v4l2_dev
= &skel
->v4l2_dev
;
874 /* Supported SDTV standards, if any */
875 vdev
->tvnorms
= SKEL_TVNORMS
;
876 video_set_drvdata(vdev
, skel
);
878 ret
= video_register_device(vdev
, VFL_TYPE_GRABBER
, -1);
882 dev_info(&pdev
->dev
, "V4L2 PCI Skeleton Driver loaded\n");
886 v4l2_ctrl_handler_free(&skel
->ctrl_handler
);
887 v4l2_device_unregister(&skel
->v4l2_dev
);
889 pci_disable_device(pdev
);
893 static void skeleton_remove(struct pci_dev
*pdev
)
895 struct v4l2_device
*v4l2_dev
= pci_get_drvdata(pdev
);
896 struct skeleton
*skel
= container_of(v4l2_dev
, struct skeleton
, v4l2_dev
);
898 video_unregister_device(&skel
->vdev
);
899 v4l2_ctrl_handler_free(&skel
->ctrl_handler
);
900 v4l2_device_unregister(&skel
->v4l2_dev
);
901 pci_disable_device(skel
->pdev
);
904 static struct pci_driver skeleton_driver
= {
905 .name
= KBUILD_MODNAME
,
906 .probe
= skeleton_probe
,
907 .remove
= skeleton_remove
,
908 .id_table
= skeleton_pci_tbl
,
911 module_pci_driver(skeleton_driver
);