Home | History | Annotate | Line # | Download | only in dev
video.c revision 1.32.18.1
      1  1.32.18.1  pgoyette /* $NetBSD: video.c,v 1.32.18.1 2017/04/27 05:36:35 pgoyette Exp $ */
      2        1.1  jmcneill 
      3        1.1  jmcneill /*
      4        1.1  jmcneill  * Copyright (c) 2008 Patrick Mahoney <pat (at) polycrystal.org>
      5        1.1  jmcneill  * All rights reserved.
      6        1.1  jmcneill  *
      7        1.1  jmcneill  * This code was written by Patrick Mahoney (pat (at) polycrystal.org) as
      8        1.1  jmcneill  * part of Google Summer of Code 2008.
      9        1.1  jmcneill  *
     10        1.1  jmcneill  * Redistribution and use in source and binary forms, with or without
     11        1.1  jmcneill  * modification, are permitted provided that the following conditions
     12        1.1  jmcneill  * are met:
     13        1.1  jmcneill  * 1. Redistributions of source code must retain the above copyright
     14        1.1  jmcneill  *    notice, this list of conditions and the following disclaimer.
     15        1.1  jmcneill  * 2. Redistributions in binary form must reproduce the above copyright
     16        1.1  jmcneill  *    notice, this list of conditions and the following disclaimer in the
     17        1.1  jmcneill  *    documentation and/or other materials provided with the distribution.
     18        1.1  jmcneill  *
     19        1.1  jmcneill  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     20        1.1  jmcneill  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     21        1.1  jmcneill  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     22        1.1  jmcneill  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     23        1.1  jmcneill  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     24        1.1  jmcneill  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     25        1.1  jmcneill  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     26        1.1  jmcneill  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     27        1.1  jmcneill  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     28        1.1  jmcneill  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     29        1.1  jmcneill  * POSSIBILITY OF SUCH DAMAGE.
     30        1.1  jmcneill  */
     31        1.1  jmcneill 
     32        1.1  jmcneill /*
     33        1.1  jmcneill  * This ia a Video4Linux 2 compatible /dev/video driver for NetBSD
     34        1.1  jmcneill  *
     35        1.1  jmcneill  * See http://v4l2spec.bytesex.org/ for Video4Linux 2 specifications
     36        1.1  jmcneill  */
     37        1.1  jmcneill 
     38        1.1  jmcneill #include <sys/cdefs.h>
     39  1.32.18.1  pgoyette __KERNEL_RCSID(0, "$NetBSD: video.c,v 1.32.18.1 2017/04/27 05:36:35 pgoyette Exp $");
     40        1.1  jmcneill 
     41        1.1  jmcneill #include "video.h"
     42        1.1  jmcneill #if NVIDEO > 0
     43        1.1  jmcneill 
     44        1.1  jmcneill #include <sys/param.h>
     45        1.1  jmcneill #include <sys/ioctl.h>
     46        1.1  jmcneill #include <sys/fcntl.h>
     47        1.1  jmcneill #include <sys/vnode.h>
     48        1.1  jmcneill #include <sys/poll.h>
     49        1.7  jmcneill #include <sys/select.h>
     50        1.1  jmcneill #include <sys/kmem.h>
     51        1.1  jmcneill #include <sys/pool.h>
     52        1.1  jmcneill #include <sys/conf.h>
     53        1.1  jmcneill #include <sys/types.h>
     54        1.1  jmcneill #include <sys/device.h>
     55        1.1  jmcneill #include <sys/condvar.h>
     56        1.1  jmcneill #include <sys/queue.h>
     57        1.1  jmcneill #include <sys/videoio.h>
     58        1.1  jmcneill 
     59        1.1  jmcneill #include <dev/video_if.h>
     60        1.1  jmcneill 
     61        1.1  jmcneill /* #define VIDEO_DEBUG 1 */
     62        1.1  jmcneill 
     63        1.1  jmcneill #ifdef VIDEO_DEBUG
     64        1.1  jmcneill #define	DPRINTF(x)	do { if (videodebug) printf x; } while (0)
     65        1.1  jmcneill #define	DPRINTFN(n,x)	do { if (videodebug>(n)) printf x; } while (0)
     66        1.1  jmcneill int	videodebug = VIDEO_DEBUG;
     67        1.1  jmcneill #else
     68        1.1  jmcneill #define DPRINTF(x)
     69        1.1  jmcneill #define DPRINTFN(n,x)
     70        1.1  jmcneill #endif
     71        1.1  jmcneill 
     72       1.22  christos #define PAGE_ALIGN(a)		(((a) + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1))
     73       1.22  christos 
     74       1.25  jmcneill #define VIDEO_DRIVER_VERSION				\
     75       1.25  jmcneill 	(((__NetBSD_Version__ / 100000000) << 16) |	\
     76       1.25  jmcneill 	 ((__NetBSD_Version__ / 1000000 % 100) << 8) |	\
     77       1.25  jmcneill 	 (__NetBSD_Version__ / 100 % 100))
     78        1.1  jmcneill 
     79        1.1  jmcneill /* TODO: move to sys/intr.h */
     80        1.1  jmcneill #define IPL_VIDEO	IPL_VM
     81        1.1  jmcneill #define splvideo()	splvm()
     82        1.1  jmcneill 
     83        1.1  jmcneill #define VIDEO_MIN_BUFS 2
     84        1.6  jmcneill #define VIDEO_MAX_BUFS 32
     85        1.1  jmcneill #define VIDEO_NUM_BUFS 4
     86        1.1  jmcneill 
     87        1.1  jmcneill /* Scatter Buffer - an array of fixed size (PAGE_SIZE) chunks
     88        1.1  jmcneill  * allocated non-contiguously and functions to get data into and out
     89        1.1  jmcneill  * of the scatter buffer. */
     90        1.1  jmcneill struct scatter_buf {
     91        1.1  jmcneill 	pool_cache_t	sb_pool;
     92        1.1  jmcneill 	size_t		sb_size;    /* size in bytes */
     93        1.1  jmcneill 	size_t		sb_npages;  /* number of pages */
     94        1.1  jmcneill 	uint8_t		**sb_page_ary; /* array of page pointers */
     95        1.1  jmcneill };
     96        1.1  jmcneill 
     97        1.1  jmcneill struct scatter_io {
     98        1.1  jmcneill 	struct scatter_buf *sio_buf;
     99        1.1  jmcneill 	off_t		sio_offset;
    100        1.1  jmcneill 	size_t		sio_resid;
    101        1.1  jmcneill };
    102        1.1  jmcneill 
    103        1.1  jmcneill static void	scatter_buf_init(struct scatter_buf *);
    104        1.1  jmcneill static void	scatter_buf_destroy(struct scatter_buf *);
    105        1.1  jmcneill static int	scatter_buf_set_size(struct scatter_buf *, size_t);
    106        1.1  jmcneill static paddr_t	scatter_buf_map(struct scatter_buf *, off_t);
    107        1.1  jmcneill 
    108        1.1  jmcneill static bool	scatter_io_init(struct scatter_buf *, off_t, size_t, struct scatter_io *);
    109        1.1  jmcneill static bool	scatter_io_next(struct scatter_io *, void **, size_t *);
    110        1.1  jmcneill static void	scatter_io_undo(struct scatter_io *, size_t);
    111        1.1  jmcneill static void	scatter_io_copyin(struct scatter_io *, const void *);
    112        1.1  jmcneill /* static void	scatter_io_copyout(struct scatter_io *, void *); */
    113        1.1  jmcneill static int	scatter_io_uiomove(struct scatter_io *, struct uio *);
    114        1.1  jmcneill 
    115        1.1  jmcneill 
    116        1.1  jmcneill enum video_stream_method {
    117        1.1  jmcneill 	VIDEO_STREAM_METHOD_NONE,
    118        1.1  jmcneill 	VIDEO_STREAM_METHOD_READ,
    119        1.1  jmcneill 	VIDEO_STREAM_METHOD_MMAP,
    120        1.1  jmcneill 	VIDEO_STREAM_METHOD_USERPTR
    121        1.1  jmcneill };
    122        1.1  jmcneill 
    123        1.1  jmcneill struct video_buffer {
    124        1.1  jmcneill 	struct v4l2_buffer		*vb_buf;
    125        1.1  jmcneill 	SIMPLEQ_ENTRY(video_buffer)	entries;
    126        1.1  jmcneill };
    127        1.1  jmcneill 
    128        1.1  jmcneill SIMPLEQ_HEAD(sample_queue, video_buffer);
    129        1.1  jmcneill 
    130        1.1  jmcneill struct video_stream {
    131        1.1  jmcneill 	int			vs_flags; /* flags given to open() */
    132        1.1  jmcneill 
    133        1.1  jmcneill 	struct video_format	vs_format;
    134        1.1  jmcneill 
    135        1.1  jmcneill 	int			vs_frameno; /* toggles between 0 and 1,
    136        1.1  jmcneill 					     * or -1 if new */
    137        1.1  jmcneill 	uint32_t		vs_sequence; /* absoulte frame/sample number in
    138        1.1  jmcneill 					      * sequence, wraps around */
    139        1.1  jmcneill 	bool			vs_drop; /* drop payloads from current
    140        1.1  jmcneill 					  * frameno? */
    141        1.1  jmcneill 
    142        1.1  jmcneill 	enum v4l2_buf_type	vs_type;
    143        1.1  jmcneill 	uint8_t			vs_nbufs;
    144        1.1  jmcneill 	struct video_buffer	**vs_buf;
    145        1.1  jmcneill 
    146        1.1  jmcneill 	struct scatter_buf	vs_data; /* stores video data for MMAP
    147        1.1  jmcneill 					  * and READ */
    148        1.1  jmcneill 
    149        1.1  jmcneill 	/* Video samples may exist in different locations.  Initially,
    150        1.1  jmcneill 	 * samples are queued into the ingress queue.  The driver
    151        1.1  jmcneill 	 * grabs these in turn and fills them with video data.  Once
    152        1.1  jmcneill 	 * filled, they are moved to the egress queue.  Samples are
    153        1.1  jmcneill 	 * dequeued either by user with MMAP method or, with READ
    154        1.1  jmcneill 	 * method, videoread() works from the fist sample in the
    155        1.1  jmcneill 	 * ingress queue without dequeing.  In the first case, the
    156        1.1  jmcneill 	 * user re-queues the buffer when finished, and videoread()
    157        1.1  jmcneill 	 * does the same when all data has been read.  The sample now
    158        1.1  jmcneill 	 * returns to the ingress queue. */
    159        1.1  jmcneill 	struct sample_queue	vs_ingress; /* samples under driver control */
    160        1.1  jmcneill 	struct sample_queue	vs_egress; /* samples headed for userspace */
    161        1.1  jmcneill 
    162        1.1  jmcneill 	bool			vs_streaming;
    163        1.1  jmcneill 	enum video_stream_method vs_method; /* method by which
    164        1.1  jmcneill 					     * userspace will read
    165        1.1  jmcneill 					     * samples */
    166        1.1  jmcneill 
    167        1.1  jmcneill 	kmutex_t		vs_lock; /* Lock to manipulate queues.
    168        1.1  jmcneill 					  * Should also be held when
    169        1.1  jmcneill 					  * changing number of
    170        1.1  jmcneill 					  * buffers. */
    171        1.1  jmcneill 	kcondvar_t		vs_sample_cv; /* signaled on new
    172        1.1  jmcneill 					       * ingress sample */
    173        1.7  jmcneill 	struct selinfo		vs_sel;
    174        1.1  jmcneill 
    175        1.1  jmcneill 	uint32_t		vs_bytesread; /* bytes read() from current
    176        1.1  jmcneill 					       * sample thus far */
    177        1.1  jmcneill };
    178        1.1  jmcneill 
    179        1.1  jmcneill struct video_softc {
    180        1.1  jmcneill 	device_t	sc_dev;
    181        1.1  jmcneill 	device_t	hw_dev;	  	 /* Hardware (parent) device */
    182        1.1  jmcneill 	void *		hw_softc;	 /* Hardware device private softc */
    183        1.1  jmcneill 	const struct video_hw_if *hw_if; /* Hardware interface */
    184        1.1  jmcneill 
    185        1.1  jmcneill 	u_int		sc_open;
    186        1.1  jmcneill 	int		sc_refcnt;
    187        1.1  jmcneill 	int		sc_opencnt;
    188        1.1  jmcneill 	bool		sc_dying;
    189        1.1  jmcneill 
    190        1.1  jmcneill 	struct video_stream sc_stream_in;
    191        1.1  jmcneill };
    192        1.1  jmcneill static int	video_print(void *, const char *);
    193        1.1  jmcneill 
    194        1.1  jmcneill static int	video_match(device_t, cfdata_t, void *);
    195        1.1  jmcneill static void	video_attach(device_t, device_t, void *);
    196        1.1  jmcneill static int	video_detach(device_t, int);
    197        1.1  jmcneill static int	video_activate(device_t, enum devact);
    198        1.1  jmcneill 
    199        1.1  jmcneill dev_type_open(videoopen);
    200        1.1  jmcneill dev_type_close(videoclose);
    201        1.1  jmcneill dev_type_read(videoread);
    202        1.1  jmcneill dev_type_write(videowrite);
    203        1.1  jmcneill dev_type_ioctl(videoioctl);
    204        1.1  jmcneill dev_type_poll(videopoll);
    205        1.1  jmcneill dev_type_mmap(videommap);
    206        1.1  jmcneill 
    207        1.1  jmcneill const struct cdevsw video_cdevsw = {
    208       1.31  dholland 	.d_open = videoopen,
    209       1.31  dholland 	.d_close = videoclose,
    210       1.31  dholland 	.d_read = videoread,
    211       1.31  dholland 	.d_write = videowrite,
    212       1.31  dholland 	.d_ioctl = videoioctl,
    213       1.31  dholland 	.d_stop = nostop,
    214       1.31  dholland 	.d_tty = notty,
    215       1.31  dholland 	.d_poll = videopoll,
    216       1.31  dholland 	.d_mmap = videommap,
    217       1.31  dholland 	.d_kqfilter = nokqfilter,
    218       1.32  dholland 	.d_discard = nodiscard,
    219       1.31  dholland 	.d_flag = D_OTHER
    220        1.1  jmcneill };
    221        1.1  jmcneill 
    222        1.1  jmcneill #define VIDEOUNIT(n)	(minor(n))
    223        1.1  jmcneill 
    224        1.1  jmcneill CFATTACH_DECL_NEW(video, sizeof(struct video_softc),
    225        1.1  jmcneill 		  video_match, video_attach, video_detach, video_activate);
    226        1.1  jmcneill 
    227        1.1  jmcneill extern struct cfdriver video_cd;
    228        1.1  jmcneill 
    229        1.1  jmcneill static const char *	video_pixel_format_str(enum video_pixel_format);
    230        1.1  jmcneill 
    231        1.1  jmcneill /* convert various values from V4L2 to native values of this driver */
    232        1.1  jmcneill static uint16_t	v4l2id_to_control_id(uint32_t);
    233        1.1  jmcneill static uint32_t control_flags_to_v4l2flags(uint32_t);
    234        1.1  jmcneill static enum v4l2_ctrl_type control_type_to_v4l2type(enum video_control_type);
    235        1.1  jmcneill 
    236        1.1  jmcneill static void	v4l2_format_to_video_format(const struct v4l2_format *,
    237        1.1  jmcneill 					    struct video_format *);
    238        1.1  jmcneill static void	video_format_to_v4l2_format(const struct video_format *,
    239        1.1  jmcneill 					    struct v4l2_format *);
    240       1.24  jmcneill static void	v4l2_standard_to_video_standard(v4l2_std_id,
    241       1.24  jmcneill 						enum video_standard *);
    242       1.24  jmcneill static void	video_standard_to_v4l2_standard(enum video_standard,
    243       1.24  jmcneill 						struct v4l2_standard *);
    244       1.24  jmcneill static void	v4l2_input_to_video_input(const struct v4l2_input *,
    245       1.24  jmcneill 					  struct video_input *);
    246       1.24  jmcneill static void	video_input_to_v4l2_input(const struct video_input *,
    247       1.24  jmcneill 					  struct v4l2_input *);
    248       1.24  jmcneill static void	v4l2_audio_to_video_audio(const struct v4l2_audio *,
    249       1.24  jmcneill 					  struct video_audio *);
    250       1.24  jmcneill static void	video_audio_to_v4l2_audio(const struct video_audio *,
    251       1.24  jmcneill 					  struct v4l2_audio *);
    252       1.24  jmcneill static void	v4l2_tuner_to_video_tuner(const struct v4l2_tuner *,
    253       1.24  jmcneill 					  struct video_tuner *);
    254       1.24  jmcneill static void	video_tuner_to_v4l2_tuner(const struct video_tuner *,
    255       1.24  jmcneill 					  struct v4l2_tuner *);
    256        1.1  jmcneill 
    257       1.24  jmcneill /* V4L2 api functions, typically called from videoioctl() */
    258        1.1  jmcneill static int	video_enum_format(struct video_softc *, struct v4l2_fmtdesc *);
    259        1.1  jmcneill static int	video_get_format(struct video_softc *,
    260        1.1  jmcneill 				 struct v4l2_format *);
    261        1.1  jmcneill static int	video_set_format(struct video_softc *,
    262        1.1  jmcneill 				 struct v4l2_format *);
    263        1.1  jmcneill static int	video_try_format(struct video_softc *,
    264        1.1  jmcneill 				 struct v4l2_format *);
    265       1.24  jmcneill static int	video_enum_standard(struct video_softc *,
    266       1.24  jmcneill 				    struct v4l2_standard *);
    267       1.24  jmcneill static int	video_get_standard(struct video_softc *, v4l2_std_id *);
    268       1.24  jmcneill static int	video_set_standard(struct video_softc *, v4l2_std_id);
    269       1.24  jmcneill static int	video_enum_input(struct video_softc *, struct v4l2_input *);
    270       1.24  jmcneill static int	video_get_input(struct video_softc *, int *);
    271       1.24  jmcneill static int	video_set_input(struct video_softc *, int);
    272       1.24  jmcneill static int	video_enum_audio(struct video_softc *, struct v4l2_audio *);
    273       1.24  jmcneill static int	video_get_audio(struct video_softc *, struct v4l2_audio *);
    274       1.24  jmcneill static int	video_set_audio(struct video_softc *, struct v4l2_audio *);
    275       1.24  jmcneill static int	video_get_tuner(struct video_softc *, struct v4l2_tuner *);
    276       1.24  jmcneill static int	video_set_tuner(struct video_softc *, struct v4l2_tuner *);
    277       1.24  jmcneill static int	video_get_frequency(struct video_softc *,
    278       1.24  jmcneill 				    struct v4l2_frequency *);
    279       1.24  jmcneill static int	video_set_frequency(struct video_softc *,
    280       1.24  jmcneill 				    struct v4l2_frequency *);
    281        1.1  jmcneill static int	video_query_control(struct video_softc *,
    282        1.1  jmcneill 				    struct v4l2_queryctrl *);
    283        1.1  jmcneill static int	video_get_control(struct video_softc *,
    284        1.1  jmcneill 				  struct v4l2_control *);
    285        1.1  jmcneill static int	video_set_control(struct video_softc *,
    286        1.1  jmcneill 				  const struct v4l2_control *);
    287        1.1  jmcneill static int	video_request_bufs(struct video_softc *,
    288        1.1  jmcneill 				   struct v4l2_requestbuffers *);
    289        1.1  jmcneill static int	video_query_buf(struct video_softc *, struct v4l2_buffer *);
    290        1.1  jmcneill static int	video_queue_buf(struct video_softc *, struct v4l2_buffer *);
    291        1.1  jmcneill static int	video_dequeue_buf(struct video_softc *, struct v4l2_buffer *);
    292        1.1  jmcneill static int	video_stream_on(struct video_softc *, enum v4l2_buf_type);
    293        1.1  jmcneill static int	video_stream_off(struct video_softc *, enum v4l2_buf_type);
    294        1.1  jmcneill 
    295        1.1  jmcneill static struct video_buffer *	video_buffer_alloc(void);
    296        1.1  jmcneill static void			video_buffer_free(struct video_buffer *);
    297        1.1  jmcneill 
    298        1.1  jmcneill 
    299        1.1  jmcneill /* functions for video_stream */
    300        1.1  jmcneill static void	video_stream_init(struct video_stream *);
    301        1.1  jmcneill static void	video_stream_fini(struct video_stream *);
    302        1.1  jmcneill 
    303        1.1  jmcneill static int	video_stream_setup_bufs(struct video_stream *,
    304        1.1  jmcneill 					enum video_stream_method,
    305        1.1  jmcneill 					uint8_t);
    306        1.1  jmcneill static void	video_stream_teardown_bufs(struct video_stream *);
    307        1.1  jmcneill 
    308        1.1  jmcneill static int	video_stream_realloc_bufs(struct video_stream *, uint8_t);
    309        1.1  jmcneill #define		video_stream_free_bufs(vs) \
    310        1.1  jmcneill 	video_stream_realloc_bufs((vs), 0)
    311        1.1  jmcneill 
    312        1.1  jmcneill static void	video_stream_enqueue(struct video_stream *,
    313        1.1  jmcneill 				     struct video_buffer *);
    314        1.1  jmcneill static struct video_buffer * video_stream_dequeue(struct video_stream *);
    315        1.1  jmcneill static void	video_stream_write(struct video_stream *,
    316        1.1  jmcneill 				   const struct video_payload *);
    317        1.1  jmcneill static void	video_stream_sample_done(struct video_stream *);
    318        1.1  jmcneill 
    319        1.1  jmcneill #ifdef VIDEO_DEBUG
    320        1.1  jmcneill /* debugging */
    321        1.1  jmcneill static const char *	video_ioctl_str(u_long);
    322        1.1  jmcneill #endif
    323        1.1  jmcneill 
    324        1.1  jmcneill 
    325        1.1  jmcneill static int
    326        1.1  jmcneill video_match(device_t parent, cfdata_t match, void *aux)
    327        1.1  jmcneill {
    328       1.30  christos #ifdef VIDEO_DEBUG
    329        1.1  jmcneill 	struct video_attach_args *args;
    330        1.1  jmcneill 
    331        1.1  jmcneill 	args = aux;
    332        1.1  jmcneill 	DPRINTF(("video_match: hw=%p\n", args->hw_if));
    333       1.30  christos #endif
    334        1.1  jmcneill 	return 1;
    335        1.1  jmcneill }
    336        1.1  jmcneill 
    337        1.1  jmcneill 
    338        1.1  jmcneill static void
    339        1.1  jmcneill video_attach(device_t parent, device_t self, void *aux)
    340        1.1  jmcneill {
    341        1.1  jmcneill 	struct video_softc *sc;
    342        1.1  jmcneill 	struct video_attach_args *args;
    343        1.1  jmcneill 
    344        1.1  jmcneill 	sc = device_private(self);
    345        1.1  jmcneill 	args = aux;
    346        1.1  jmcneill 
    347        1.1  jmcneill 	sc->sc_dev = self;
    348        1.1  jmcneill 	sc->hw_dev = parent;
    349        1.1  jmcneill 	sc->hw_if = args->hw_if;
    350        1.1  jmcneill 	sc->hw_softc = device_private(parent);
    351        1.1  jmcneill 
    352        1.1  jmcneill 	sc->sc_open = 0;
    353        1.1  jmcneill 	sc->sc_refcnt = 0;
    354        1.1  jmcneill 	sc->sc_opencnt = 0;
    355        1.1  jmcneill 	sc->sc_dying = false;
    356        1.1  jmcneill 
    357        1.1  jmcneill 	video_stream_init(&sc->sc_stream_in);
    358        1.1  jmcneill 
    359        1.5  jmcneill 	aprint_naive("\n");
    360        1.5  jmcneill 	aprint_normal(": %s\n", sc->hw_if->get_devname(sc->hw_softc));
    361        1.5  jmcneill 
    362        1.1  jmcneill 	DPRINTF(("video_attach: sc=%p hwif=%p\n", sc, sc->hw_if));
    363       1.17  jmcneill 
    364       1.17  jmcneill 	if (!pmf_device_register(self, NULL, NULL))
    365       1.17  jmcneill 		aprint_error_dev(self, "couldn't establish power handler\n");
    366        1.1  jmcneill }
    367        1.1  jmcneill 
    368        1.1  jmcneill 
    369        1.1  jmcneill static int
    370        1.1  jmcneill video_activate(device_t self, enum devact act)
    371        1.1  jmcneill {
    372       1.23    dyoung 	struct video_softc *sc = device_private(self);
    373        1.1  jmcneill 
    374        1.1  jmcneill 	DPRINTF(("video_activate: sc=%p\n", sc));
    375        1.1  jmcneill 	switch (act) {
    376        1.1  jmcneill 	case DVACT_DEACTIVATE:
    377        1.1  jmcneill 		sc->sc_dying = true;
    378       1.23    dyoung 		return 0;
    379       1.23    dyoung 	default:
    380       1.23    dyoung 		return EOPNOTSUPP;
    381        1.1  jmcneill 	}
    382        1.1  jmcneill }
    383        1.1  jmcneill 
    384        1.1  jmcneill 
    385        1.1  jmcneill static int
    386        1.1  jmcneill video_detach(device_t self, int flags)
    387        1.1  jmcneill {
    388        1.1  jmcneill 	struct video_softc *sc;
    389        1.1  jmcneill 	int maj, mn;
    390        1.1  jmcneill 
    391        1.1  jmcneill 	sc = device_private(self);
    392        1.1  jmcneill 	DPRINTF(("video_detach: sc=%p flags=%d\n", sc, flags));
    393        1.1  jmcneill 
    394        1.1  jmcneill 	sc->sc_dying = true;
    395       1.17  jmcneill 
    396       1.17  jmcneill 	pmf_device_deregister(self);
    397        1.1  jmcneill 
    398        1.1  jmcneill 	maj = cdevsw_lookup_major(&video_cdevsw);
    399        1.1  jmcneill 	mn = device_unit(self);
    400        1.1  jmcneill 	/* close open instances */
    401        1.1  jmcneill 	vdevgone(maj, mn, mn, VCHR);
    402        1.1  jmcneill 
    403        1.1  jmcneill 	video_stream_fini(&sc->sc_stream_in);
    404        1.1  jmcneill 
    405        1.1  jmcneill 	return 0;
    406        1.1  jmcneill }
    407        1.1  jmcneill 
    408        1.1  jmcneill 
    409        1.1  jmcneill static int
    410        1.1  jmcneill video_print(void *aux, const char *pnp)
    411        1.1  jmcneill {
    412        1.1  jmcneill 	if (pnp != NULL) {
    413        1.1  jmcneill 		DPRINTF(("video_print: have pnp\n"));
    414        1.1  jmcneill 		aprint_normal("%s at %s\n", "video", pnp);
    415        1.1  jmcneill 	} else {
    416        1.1  jmcneill 		DPRINTF(("video_print: pnp is NULL\n"));
    417        1.1  jmcneill 	}
    418        1.1  jmcneill 	return UNCONF;
    419        1.1  jmcneill }
    420        1.1  jmcneill 
    421        1.1  jmcneill 
    422        1.1  jmcneill /*
    423        1.1  jmcneill  * Called from hardware driver.  This is where the MI audio driver
    424        1.1  jmcneill  * gets probed/attached to the hardware driver.
    425        1.1  jmcneill  */
    426        1.1  jmcneill device_t
    427        1.1  jmcneill video_attach_mi(const struct video_hw_if *hw_if, device_t parent)
    428        1.1  jmcneill {
    429        1.1  jmcneill 	struct video_attach_args args;
    430        1.1  jmcneill 
    431        1.1  jmcneill 	args.hw_if = hw_if;
    432        1.1  jmcneill 	return config_found_ia(parent, "videobus", &args, video_print);
    433        1.1  jmcneill }
    434        1.1  jmcneill 
    435        1.1  jmcneill /* video_submit_payload - called by hardware driver to submit payload data */
    436        1.1  jmcneill void
    437        1.1  jmcneill video_submit_payload(device_t self, const struct video_payload *payload)
    438        1.1  jmcneill {
    439        1.1  jmcneill 	struct video_softc *sc;
    440        1.1  jmcneill 
    441        1.1  jmcneill 	sc = device_private(self);
    442        1.1  jmcneill 
    443        1.1  jmcneill 	if (sc == NULL)
    444        1.1  jmcneill 		return;
    445        1.1  jmcneill 
    446        1.1  jmcneill 	video_stream_write(&sc->sc_stream_in, payload);
    447        1.1  jmcneill }
    448        1.1  jmcneill 
    449        1.1  jmcneill static const char *
    450        1.1  jmcneill video_pixel_format_str(enum video_pixel_format px)
    451        1.1  jmcneill {
    452        1.1  jmcneill 	switch (px) {
    453       1.16  jmcneill 	case VIDEO_FORMAT_UYVY:		return "UYVY";
    454       1.14  jmcneill 	case VIDEO_FORMAT_YUV420:	return "YUV420";
    455        1.1  jmcneill 	case VIDEO_FORMAT_YUY2: 	return "YUYV";
    456        1.1  jmcneill 	case VIDEO_FORMAT_NV12:		return "NV12";
    457       1.11  jmcneill 	case VIDEO_FORMAT_RGB24:	return "RGB24";
    458       1.16  jmcneill 	case VIDEO_FORMAT_RGB555:	return "RGB555";
    459       1.16  jmcneill 	case VIDEO_FORMAT_RGB565:	return "RGB565";
    460       1.15  jmcneill 	case VIDEO_FORMAT_SBGGR8:	return "SBGGR8";
    461        1.1  jmcneill 	case VIDEO_FORMAT_MJPEG:	return "MJPEG";
    462        1.1  jmcneill 	case VIDEO_FORMAT_DV:		return "DV";
    463        1.1  jmcneill 	case VIDEO_FORMAT_MPEG:		return "MPEG";
    464        1.1  jmcneill 	default:			return "Unknown";
    465        1.1  jmcneill 	}
    466        1.1  jmcneill }
    467        1.1  jmcneill 
    468        1.1  jmcneill /* Takes a V4L2 id and returns a "native" video driver control id.
    469        1.1  jmcneill  * TODO: is there a better way to do this?  some kind of array? */
    470        1.1  jmcneill static uint16_t
    471        1.1  jmcneill v4l2id_to_control_id(uint32_t v4l2id)
    472        1.1  jmcneill {
    473        1.1  jmcneill 	/* mask includes class bits and control id bits */
    474        1.1  jmcneill 	switch (v4l2id & 0xffffff) {
    475        1.1  jmcneill 	case V4L2_CID_BRIGHTNESS:	return VIDEO_CONTROL_BRIGHTNESS;
    476        1.1  jmcneill 	case V4L2_CID_CONTRAST:		return VIDEO_CONTROL_CONTRAST;
    477        1.1  jmcneill 	case V4L2_CID_SATURATION:	return VIDEO_CONTROL_SATURATION;
    478        1.1  jmcneill 	case V4L2_CID_HUE:		return VIDEO_CONTROL_HUE;
    479        1.1  jmcneill 	case V4L2_CID_HUE_AUTO:		return VIDEO_CONTROL_HUE_AUTO;
    480        1.1  jmcneill 	case V4L2_CID_SHARPNESS:	return VIDEO_CONTROL_SHARPNESS;
    481        1.1  jmcneill 	case V4L2_CID_GAMMA:		return VIDEO_CONTROL_GAMMA;
    482        1.1  jmcneill 
    483        1.1  jmcneill 	/* "black level" means the same as "brightness", but V4L2
    484        1.1  jmcneill 	 * defines two separate controls that are not identical.
    485        1.1  jmcneill 	 * V4L2_CID_BLACK_LEVEL is deprecated however in V4L2. */
    486        1.1  jmcneill 	case V4L2_CID_BLACK_LEVEL:	return VIDEO_CONTROL_BRIGHTNESS;
    487        1.1  jmcneill 
    488        1.1  jmcneill 	case V4L2_CID_AUDIO_VOLUME:	return VIDEO_CONTROL_UNDEFINED;
    489        1.1  jmcneill 	case V4L2_CID_AUDIO_BALANCE:	return VIDEO_CONTROL_UNDEFINED;
    490        1.1  jmcneill 	case V4L2_CID_AUDIO_BASS:	return VIDEO_CONTROL_UNDEFINED;
    491        1.1  jmcneill 	case V4L2_CID_AUDIO_TREBLE:	return VIDEO_CONTROL_UNDEFINED;
    492        1.1  jmcneill 	case V4L2_CID_AUDIO_MUTE:	return VIDEO_CONTROL_UNDEFINED;
    493        1.1  jmcneill 	case V4L2_CID_AUDIO_LOUDNESS:	return VIDEO_CONTROL_UNDEFINED;
    494        1.1  jmcneill 
    495        1.1  jmcneill 	case V4L2_CID_AUTO_WHITE_BALANCE:
    496        1.1  jmcneill 		return VIDEO_CONTROL_WHITE_BALANCE_AUTO;
    497        1.1  jmcneill 	case V4L2_CID_DO_WHITE_BALANCE:
    498        1.1  jmcneill 		return VIDEO_CONTROL_WHITE_BALANCE_ACTION;
    499        1.1  jmcneill 	case V4L2_CID_RED_BALANCE:
    500        1.1  jmcneill 	case V4L2_CID_BLUE_BALANCE:
    501        1.1  jmcneill 		/* This might not fit in with the control_id/value_id scheme */
    502        1.1  jmcneill 		return VIDEO_CONTROL_WHITE_BALANCE_COMPONENT;
    503        1.1  jmcneill 	case V4L2_CID_WHITE_BALANCE_TEMPERATURE:
    504        1.1  jmcneill 		return VIDEO_CONTROL_WHITE_BALANCE_TEMPERATURE;
    505        1.1  jmcneill 	case V4L2_CID_EXPOSURE:
    506        1.1  jmcneill 		return VIDEO_CONTROL_EXPOSURE_TIME_ABSOLUTE;
    507        1.1  jmcneill 	case V4L2_CID_GAIN:		return VIDEO_CONTROL_GAIN;
    508        1.1  jmcneill 	case V4L2_CID_AUTOGAIN:		return VIDEO_CONTROL_GAIN_AUTO;
    509        1.1  jmcneill 	case V4L2_CID_HFLIP:		return VIDEO_CONTROL_HFLIP;
    510        1.1  jmcneill 	case V4L2_CID_VFLIP:		return VIDEO_CONTROL_VFLIP;
    511        1.1  jmcneill 	case V4L2_CID_HCENTER_DEPRECATED:
    512        1.1  jmcneill 	case V4L2_CID_VCENTER_DEPRECATED:
    513        1.1  jmcneill 		return VIDEO_CONTROL_UNDEFINED;
    514        1.1  jmcneill 	case V4L2_CID_POWER_LINE_FREQUENCY:
    515        1.1  jmcneill 		return VIDEO_CONTROL_POWER_LINE_FREQUENCY;
    516        1.1  jmcneill 	case V4L2_CID_BACKLIGHT_COMPENSATION:
    517        1.1  jmcneill 		return VIDEO_CONTROL_BACKLIGHT_COMPENSATION;
    518        1.1  jmcneill 	default:			return V4L2_CTRL_ID2CID(v4l2id);
    519        1.1  jmcneill 	}
    520        1.1  jmcneill }
    521        1.1  jmcneill 
    522        1.1  jmcneill 
    523        1.1  jmcneill static uint32_t
    524        1.1  jmcneill control_flags_to_v4l2flags(uint32_t flags)
    525        1.1  jmcneill {
    526        1.1  jmcneill 	uint32_t v4l2flags = 0;
    527        1.1  jmcneill 
    528        1.1  jmcneill 	if (flags & VIDEO_CONTROL_FLAG_DISABLED)
    529        1.1  jmcneill 		v4l2flags |= V4L2_CTRL_FLAG_INACTIVE;
    530        1.1  jmcneill 
    531        1.1  jmcneill 	if (!(flags & VIDEO_CONTROL_FLAG_WRITE))
    532        1.1  jmcneill 		v4l2flags |= V4L2_CTRL_FLAG_READ_ONLY;
    533        1.1  jmcneill 
    534        1.1  jmcneill 	if (flags & VIDEO_CONTROL_FLAG_AUTOUPDATE)
    535        1.1  jmcneill 		v4l2flags |= V4L2_CTRL_FLAG_GRABBED;
    536        1.1  jmcneill 
    537        1.1  jmcneill 	return v4l2flags;
    538        1.1  jmcneill }
    539        1.1  jmcneill 
    540        1.1  jmcneill 
    541        1.1  jmcneill static enum v4l2_ctrl_type
    542        1.1  jmcneill control_type_to_v4l2type(enum video_control_type type) {
    543        1.1  jmcneill 	switch (type) {
    544        1.1  jmcneill 	case VIDEO_CONTROL_TYPE_INT:	return V4L2_CTRL_TYPE_INTEGER;
    545        1.1  jmcneill 	case VIDEO_CONTROL_TYPE_BOOL:	return V4L2_CTRL_TYPE_BOOLEAN;
    546        1.1  jmcneill 	case VIDEO_CONTROL_TYPE_LIST:	return V4L2_CTRL_TYPE_MENU;
    547        1.1  jmcneill 	case VIDEO_CONTROL_TYPE_ACTION:	return V4L2_CTRL_TYPE_BUTTON;
    548        1.1  jmcneill 	default:			return V4L2_CTRL_TYPE_INTEGER; /* err? */
    549        1.1  jmcneill 	}
    550        1.1  jmcneill }
    551        1.1  jmcneill 
    552        1.1  jmcneill 
    553        1.1  jmcneill static int
    554        1.1  jmcneill video_query_control(struct video_softc *sc,
    555        1.1  jmcneill 		    struct v4l2_queryctrl *query)
    556        1.1  jmcneill {
    557        1.1  jmcneill 	const struct video_hw_if *hw;
    558        1.1  jmcneill 	struct video_control_desc_group desc_group;
    559        1.1  jmcneill 	struct video_control_desc desc;
    560        1.1  jmcneill 	int err;
    561        1.1  jmcneill 
    562        1.1  jmcneill 	hw = sc->hw_if;
    563        1.1  jmcneill 	if (hw->get_control_desc_group) {
    564        1.1  jmcneill 		desc.group_id = desc.control_id =
    565        1.1  jmcneill 		    v4l2id_to_control_id(query->id);
    566        1.1  jmcneill 
    567        1.1  jmcneill 		desc_group.group_id = desc.group_id;
    568        1.1  jmcneill 		desc_group.length = 1;
    569        1.1  jmcneill 		desc_group.desc = &desc;
    570        1.1  jmcneill 
    571        1.1  jmcneill 		err = hw->get_control_desc_group(sc->hw_softc, &desc_group);
    572        1.1  jmcneill 		if (err != 0)
    573        1.1  jmcneill 			return err;
    574        1.1  jmcneill 
    575        1.1  jmcneill 		query->type = control_type_to_v4l2type(desc.type);
    576        1.1  jmcneill 		memcpy(query->name, desc.name, 32);
    577        1.1  jmcneill 		query->minimum = desc.min;
    578        1.1  jmcneill 		query->maximum = desc.max;
    579        1.1  jmcneill 		query->step = desc.step;
    580        1.1  jmcneill 		query->default_value = desc.def;
    581        1.1  jmcneill 		query->flags = control_flags_to_v4l2flags(desc.flags);
    582        1.1  jmcneill 
    583        1.1  jmcneill 		return 0;
    584        1.1  jmcneill 	} else {
    585        1.1  jmcneill 		return EINVAL;
    586        1.1  jmcneill 	}
    587        1.1  jmcneill }
    588        1.1  jmcneill 
    589        1.1  jmcneill 
    590        1.1  jmcneill /* Takes a single Video4Linux2 control and queries the driver for the
    591        1.1  jmcneill  * current value. */
    592        1.1  jmcneill static int
    593        1.1  jmcneill video_get_control(struct video_softc *sc,
    594        1.1  jmcneill 		  struct v4l2_control *vcontrol)
    595        1.1  jmcneill {
    596        1.1  jmcneill 	const struct video_hw_if *hw;
    597        1.1  jmcneill 	struct video_control_group group;
    598        1.1  jmcneill 	struct video_control control;
    599        1.1  jmcneill 	int err;
    600        1.1  jmcneill 
    601        1.1  jmcneill 	hw = sc->hw_if;
    602        1.1  jmcneill 	if (hw->get_control_group) {
    603        1.1  jmcneill 		control.group_id = control.control_id =
    604        1.1  jmcneill 		    v4l2id_to_control_id(vcontrol->id);
    605        1.1  jmcneill 		/* ?? if "control_id" is arbitrarily defined by the
    606        1.1  jmcneill 		 * driver, then we need some way to store it...  Maybe
    607        1.1  jmcneill 		 * it doesn't matter for single value controls. */
    608        1.1  jmcneill 		control.value = 0;
    609        1.1  jmcneill 
    610        1.1  jmcneill 		group.group_id = control.group_id;
    611        1.1  jmcneill 		group.length = 1;
    612        1.1  jmcneill 		group.control = &control;
    613        1.1  jmcneill 
    614        1.1  jmcneill 		err = hw->get_control_group(sc->hw_softc, &group);
    615        1.1  jmcneill 		if (err != 0)
    616        1.1  jmcneill 			return err;
    617        1.1  jmcneill 
    618        1.1  jmcneill 		vcontrol->value = control.value;
    619        1.1  jmcneill 		return 0;
    620        1.1  jmcneill 	} else {
    621        1.1  jmcneill 		return EINVAL;
    622        1.1  jmcneill 	}
    623        1.1  jmcneill }
    624        1.1  jmcneill 
    625        1.1  jmcneill static void
    626        1.1  jmcneill video_format_to_v4l2_format(const struct video_format *src,
    627        1.1  jmcneill 			    struct v4l2_format *dest)
    628        1.1  jmcneill {
    629        1.1  jmcneill 	/* TODO: what about win and vbi formats? */
    630        1.1  jmcneill 	dest->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    631        1.1  jmcneill 	dest->fmt.pix.width = src->width;
    632        1.1  jmcneill 	dest->fmt.pix.height = src->height;
    633       1.24  jmcneill 	if (VIDEO_INTERLACED(src->interlace_flags))
    634       1.24  jmcneill 		dest->fmt.pix.field = V4L2_FIELD_INTERLACED;
    635       1.24  jmcneill 	else
    636       1.24  jmcneill 		dest->fmt.pix.field = V4L2_FIELD_NONE;
    637        1.1  jmcneill 	dest->fmt.pix.bytesperline = src->stride;
    638        1.1  jmcneill 	dest->fmt.pix.sizeimage = src->sample_size;
    639       1.15  jmcneill 	dest->fmt.pix.priv = src->priv;
    640        1.1  jmcneill 
    641       1.24  jmcneill 	switch (src->color.primaries) {
    642       1.24  jmcneill 	case VIDEO_COLOR_PRIMARIES_SMPTE_170M:
    643       1.24  jmcneill 		dest->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
    644       1.24  jmcneill 		break;
    645       1.24  jmcneill 	/* XXX */
    646       1.24  jmcneill 	case VIDEO_COLOR_PRIMARIES_UNSPECIFIED:
    647       1.24  jmcneill 	default:
    648       1.24  jmcneill 		dest->fmt.pix.colorspace = 0;
    649       1.24  jmcneill 		break;
    650       1.24  jmcneill 	}
    651       1.24  jmcneill 
    652        1.1  jmcneill 	switch (src->pixel_format) {
    653       1.16  jmcneill 	case VIDEO_FORMAT_UYVY:
    654       1.16  jmcneill 		dest->fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY;
    655       1.16  jmcneill 		break;
    656       1.14  jmcneill 	case VIDEO_FORMAT_YUV420:
    657       1.14  jmcneill 		dest->fmt.pix.pixelformat = V4L2_PIX_FMT_YUV420;
    658       1.14  jmcneill 		break;
    659        1.1  jmcneill 	case VIDEO_FORMAT_YUY2:
    660        1.1  jmcneill 		dest->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
    661        1.1  jmcneill 		break;
    662        1.1  jmcneill 	case VIDEO_FORMAT_NV12:
    663        1.1  jmcneill 		dest->fmt.pix.pixelformat = V4L2_PIX_FMT_NV12;
    664        1.1  jmcneill 		break;
    665       1.11  jmcneill 	case VIDEO_FORMAT_RGB24:
    666       1.11  jmcneill 		dest->fmt.pix.pixelformat = V4L2_PIX_FMT_RGB24;
    667       1.11  jmcneill 		break;
    668       1.16  jmcneill 	case VIDEO_FORMAT_RGB555:
    669       1.16  jmcneill 		dest->fmt.pix.pixelformat = V4L2_PIX_FMT_RGB555;
    670       1.16  jmcneill 		break;
    671       1.16  jmcneill 	case VIDEO_FORMAT_RGB565:
    672       1.16  jmcneill 		dest->fmt.pix.pixelformat = V4L2_PIX_FMT_RGB565;
    673       1.16  jmcneill 		break;
    674       1.15  jmcneill 	case VIDEO_FORMAT_SBGGR8:
    675       1.15  jmcneill 		dest->fmt.pix.pixelformat = V4L2_PIX_FMT_SBGGR8;
    676       1.15  jmcneill 		break;
    677        1.1  jmcneill 	case VIDEO_FORMAT_MJPEG:
    678        1.8  jmcneill 		dest->fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;
    679        1.1  jmcneill 		break;
    680        1.1  jmcneill 	case VIDEO_FORMAT_DV:
    681        1.1  jmcneill 		dest->fmt.pix.pixelformat = V4L2_PIX_FMT_DV;
    682        1.1  jmcneill 		break;
    683        1.1  jmcneill 	case VIDEO_FORMAT_MPEG:
    684        1.1  jmcneill 		dest->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG;
    685        1.1  jmcneill 		break;
    686        1.1  jmcneill 	case VIDEO_FORMAT_UNDEFINED:
    687        1.1  jmcneill 	default:
    688        1.1  jmcneill 		DPRINTF(("video_get_format: unknown pixel format %d\n",
    689        1.1  jmcneill 			 src->pixel_format));
    690        1.1  jmcneill 		dest->fmt.pix.pixelformat = 0; /* V4L2 doesn't define
    691        1.1  jmcneill 					       * and "undefined"
    692        1.1  jmcneill 					       * format? */
    693        1.1  jmcneill 		break;
    694        1.1  jmcneill 	}
    695        1.1  jmcneill 
    696        1.1  jmcneill }
    697        1.1  jmcneill 
    698        1.1  jmcneill static void
    699        1.1  jmcneill v4l2_format_to_video_format(const struct v4l2_format *src,
    700        1.1  jmcneill 			    struct video_format *dest)
    701        1.1  jmcneill {
    702        1.1  jmcneill 	switch (src->type) {
    703        1.1  jmcneill 	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
    704        1.1  jmcneill 		dest->width = src->fmt.pix.width;
    705        1.1  jmcneill 		dest->height = src->fmt.pix.height;
    706        1.1  jmcneill 
    707        1.1  jmcneill 		dest->stride = src->fmt.pix.bytesperline;
    708        1.1  jmcneill 		dest->sample_size = src->fmt.pix.sizeimage;
    709        1.1  jmcneill 
    710       1.24  jmcneill 		if (src->fmt.pix.field == V4L2_FIELD_INTERLACED)
    711       1.24  jmcneill 			dest->interlace_flags = VIDEO_INTERLACE_ON;
    712       1.24  jmcneill 		else
    713       1.24  jmcneill 			dest->interlace_flags = VIDEO_INTERLACE_OFF;
    714       1.24  jmcneill 
    715       1.24  jmcneill 		switch (src->fmt.pix.colorspace) {
    716       1.24  jmcneill 		case V4L2_COLORSPACE_SMPTE170M:
    717       1.24  jmcneill 			dest->color.primaries =
    718       1.24  jmcneill 			    VIDEO_COLOR_PRIMARIES_SMPTE_170M;
    719       1.24  jmcneill 			break;
    720       1.24  jmcneill 		/* XXX */
    721       1.24  jmcneill 		default:
    722       1.24  jmcneill 			dest->color.primaries =
    723       1.24  jmcneill 			    VIDEO_COLOR_PRIMARIES_UNSPECIFIED;
    724       1.24  jmcneill 			break;
    725       1.24  jmcneill 		}
    726       1.24  jmcneill 
    727        1.1  jmcneill 		switch (src->fmt.pix.pixelformat) {
    728       1.16  jmcneill 		case V4L2_PIX_FMT_UYVY:
    729       1.16  jmcneill 			dest->pixel_format = VIDEO_FORMAT_UYVY;
    730       1.16  jmcneill 			break;
    731       1.14  jmcneill 		case V4L2_PIX_FMT_YUV420:
    732       1.14  jmcneill 			dest->pixel_format = VIDEO_FORMAT_YUV420;
    733       1.14  jmcneill 			break;
    734        1.1  jmcneill 		case V4L2_PIX_FMT_YUYV:
    735        1.1  jmcneill 			dest->pixel_format = VIDEO_FORMAT_YUY2;
    736        1.1  jmcneill 			break;
    737        1.1  jmcneill 		case V4L2_PIX_FMT_NV12:
    738        1.1  jmcneill 			dest->pixel_format = VIDEO_FORMAT_NV12;
    739        1.1  jmcneill 			break;
    740       1.11  jmcneill 		case V4L2_PIX_FMT_RGB24:
    741       1.11  jmcneill 			dest->pixel_format = VIDEO_FORMAT_RGB24;
    742       1.11  jmcneill 			break;
    743       1.16  jmcneill 		case V4L2_PIX_FMT_RGB555:
    744       1.16  jmcneill 			dest->pixel_format = VIDEO_FORMAT_RGB555;
    745       1.16  jmcneill 			break;
    746       1.16  jmcneill 		case V4L2_PIX_FMT_RGB565:
    747       1.16  jmcneill 			dest->pixel_format = VIDEO_FORMAT_RGB565;
    748       1.16  jmcneill 			break;
    749       1.15  jmcneill 		case V4L2_PIX_FMT_SBGGR8:
    750       1.15  jmcneill 			dest->pixel_format = VIDEO_FORMAT_SBGGR8;
    751       1.15  jmcneill 			break;
    752        1.9  jmcneill 		case V4L2_PIX_FMT_MJPEG:
    753        1.1  jmcneill 			dest->pixel_format = VIDEO_FORMAT_MJPEG;
    754        1.1  jmcneill 			break;
    755        1.1  jmcneill 		case V4L2_PIX_FMT_DV:
    756        1.1  jmcneill 			dest->pixel_format = VIDEO_FORMAT_DV;
    757        1.1  jmcneill 			break;
    758        1.1  jmcneill 		case V4L2_PIX_FMT_MPEG:
    759        1.9  jmcneill 			dest->pixel_format = VIDEO_FORMAT_MPEG;
    760        1.1  jmcneill 			break;
    761        1.1  jmcneill 		default:
    762        1.1  jmcneill 			DPRINTF(("video: unknown v4l2 pixel format %d\n",
    763        1.1  jmcneill 				 src->fmt.pix.pixelformat));
    764        1.1  jmcneill 			dest->pixel_format = VIDEO_FORMAT_UNDEFINED;
    765        1.1  jmcneill 			break;
    766        1.1  jmcneill 		}
    767        1.1  jmcneill 		break;
    768        1.1  jmcneill 	default:
    769        1.1  jmcneill 		/* TODO: other v4l2 format types */
    770        1.1  jmcneill 		DPRINTF(("video: unsupported v4l2 format type %d\n",
    771        1.1  jmcneill 			 src->type));
    772        1.1  jmcneill 		break;
    773        1.1  jmcneill 	}
    774        1.1  jmcneill }
    775        1.1  jmcneill 
    776        1.1  jmcneill static int
    777        1.1  jmcneill video_enum_format(struct video_softc *sc, struct v4l2_fmtdesc *fmtdesc)
    778        1.1  jmcneill {
    779        1.1  jmcneill 	const struct video_hw_if *hw;
    780        1.1  jmcneill 	struct video_format vfmt;
    781        1.1  jmcneill 	struct v4l2_format fmt;
    782        1.1  jmcneill 	int err;
    783        1.1  jmcneill 
    784        1.1  jmcneill 	hw = sc->hw_if;
    785        1.1  jmcneill 	if (hw->enum_format == NULL)
    786        1.3  jmcneill 		return ENOTTY;
    787        1.1  jmcneill 
    788        1.1  jmcneill 	err = hw->enum_format(sc->hw_softc, fmtdesc->index, &vfmt);
    789        1.1  jmcneill 	if (err != 0)
    790        1.1  jmcneill 		return err;
    791        1.1  jmcneill 
    792        1.1  jmcneill 	video_format_to_v4l2_format(&vfmt, &fmt);
    793        1.1  jmcneill 
    794        1.1  jmcneill 	fmtdesc->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; /* TODO: only one type for now */
    795       1.24  jmcneill 	fmtdesc->flags = 0;
    796        1.1  jmcneill 	if (vfmt.pixel_format >= VIDEO_FORMAT_MJPEG)
    797        1.1  jmcneill 		fmtdesc->flags = V4L2_FMT_FLAG_COMPRESSED;
    798        1.1  jmcneill 	strlcpy(fmtdesc->description,
    799        1.1  jmcneill 		video_pixel_format_str(vfmt.pixel_format),
    800        1.1  jmcneill 		sizeof(fmtdesc->description));
    801        1.1  jmcneill 	fmtdesc->pixelformat = fmt.fmt.pix.pixelformat;
    802        1.1  jmcneill 
    803        1.1  jmcneill 	return 0;
    804        1.1  jmcneill }
    805        1.1  jmcneill 
    806        1.1  jmcneill static int
    807        1.1  jmcneill video_get_format(struct video_softc *sc,
    808        1.1  jmcneill 		      struct v4l2_format *format)
    809        1.1  jmcneill {
    810        1.1  jmcneill 	const struct video_hw_if *hw;
    811        1.1  jmcneill 	struct video_format vfmt;
    812        1.1  jmcneill 	int err;
    813        1.1  jmcneill 
    814        1.1  jmcneill 	hw = sc->hw_if;
    815        1.1  jmcneill 	if (hw->get_format == NULL)
    816        1.3  jmcneill 		return ENOTTY;
    817        1.1  jmcneill 
    818        1.1  jmcneill 	err = hw->get_format(sc->hw_softc, &vfmt);
    819        1.1  jmcneill 	if (err != 0)
    820        1.1  jmcneill 		return err;
    821        1.1  jmcneill 
    822        1.1  jmcneill 	video_format_to_v4l2_format(&vfmt, format);
    823        1.1  jmcneill 
    824        1.1  jmcneill 	return 0;
    825        1.1  jmcneill }
    826        1.1  jmcneill 
    827        1.1  jmcneill static int
    828        1.1  jmcneill video_set_format(struct video_softc *sc, struct v4l2_format *fmt)
    829        1.1  jmcneill {
    830        1.1  jmcneill 	const struct video_hw_if *hw;
    831        1.1  jmcneill 	struct video_format vfmt;
    832        1.1  jmcneill 	int err;
    833        1.1  jmcneill 
    834        1.1  jmcneill 	hw = sc->hw_if;
    835       1.20  jmcneill 	if (hw->set_format == NULL)
    836        1.3  jmcneill 		return ENOTTY;
    837        1.1  jmcneill 
    838        1.1  jmcneill 	v4l2_format_to_video_format(fmt, &vfmt);
    839        1.1  jmcneill 
    840        1.1  jmcneill 	err = hw->set_format(sc->hw_softc, &vfmt);
    841        1.1  jmcneill 	if (err != 0)
    842        1.1  jmcneill 		return err;
    843        1.1  jmcneill 
    844        1.1  jmcneill 	video_format_to_v4l2_format(&vfmt, fmt);
    845       1.18    jmorse 	sc->sc_stream_in.vs_format = vfmt;
    846        1.1  jmcneill 
    847        1.1  jmcneill 	return 0;
    848        1.1  jmcneill }
    849        1.1  jmcneill 
    850        1.1  jmcneill 
    851        1.1  jmcneill static int
    852        1.1  jmcneill video_try_format(struct video_softc *sc,
    853        1.1  jmcneill 		      struct v4l2_format *format)
    854        1.1  jmcneill {
    855        1.1  jmcneill 	const struct video_hw_if *hw;
    856        1.1  jmcneill 	struct video_format vfmt;
    857        1.1  jmcneill 	int err;
    858        1.1  jmcneill 
    859        1.1  jmcneill 	hw = sc->hw_if;
    860        1.1  jmcneill 	if (hw->try_format == NULL)
    861        1.3  jmcneill 		return ENOTTY;
    862        1.1  jmcneill 
    863        1.1  jmcneill 	v4l2_format_to_video_format(format, &vfmt);
    864        1.1  jmcneill 
    865        1.1  jmcneill 	err = hw->try_format(sc->hw_softc, &vfmt);
    866        1.1  jmcneill 	if (err != 0)
    867        1.1  jmcneill 		return err;
    868        1.1  jmcneill 
    869        1.1  jmcneill 	video_format_to_v4l2_format(&vfmt, format);
    870        1.1  jmcneill 
    871        1.1  jmcneill 	return 0;
    872        1.1  jmcneill }
    873        1.1  jmcneill 
    874       1.24  jmcneill static void
    875       1.24  jmcneill v4l2_standard_to_video_standard(v4l2_std_id stdid,
    876       1.24  jmcneill     enum video_standard *vstd)
    877       1.24  jmcneill {
    878       1.24  jmcneill #define VSTD(id, vid)	case (id):	*vstd = (vid); break;
    879       1.24  jmcneill 	switch (stdid) {
    880       1.24  jmcneill 	VSTD(V4L2_STD_NTSC_M, VIDEO_STANDARD_NTSC_M)
    881       1.24  jmcneill 	default:
    882       1.24  jmcneill 		*vstd = VIDEO_STANDARD_UNKNOWN;
    883       1.24  jmcneill 		break;
    884       1.24  jmcneill 	}
    885       1.24  jmcneill #undef VSTD
    886       1.24  jmcneill }
    887       1.24  jmcneill 
    888       1.24  jmcneill static void
    889       1.24  jmcneill video_standard_to_v4l2_standard(enum video_standard vstd,
    890       1.24  jmcneill     struct v4l2_standard *std)
    891       1.24  jmcneill {
    892       1.24  jmcneill 	switch (vstd) {
    893       1.24  jmcneill 	case VIDEO_STANDARD_NTSC_M:
    894       1.24  jmcneill 		std->id = V4L2_STD_NTSC_M;
    895       1.24  jmcneill 		strlcpy(std->name, "NTSC-M", sizeof(std->name));
    896       1.24  jmcneill 		std->frameperiod.numerator = 1001;
    897       1.24  jmcneill 		std->frameperiod.denominator = 30000;
    898       1.24  jmcneill 		std->framelines = 525;
    899       1.24  jmcneill 		break;
    900       1.24  jmcneill 	default:
    901       1.24  jmcneill 		std->id = V4L2_STD_UNKNOWN;
    902       1.24  jmcneill 		strlcpy(std->name, "Unknown", sizeof(std->name));
    903       1.24  jmcneill 		break;
    904       1.24  jmcneill 	}
    905       1.24  jmcneill }
    906       1.24  jmcneill 
    907       1.24  jmcneill static int
    908       1.24  jmcneill video_enum_standard(struct video_softc *sc, struct v4l2_standard *std)
    909       1.24  jmcneill {
    910       1.24  jmcneill 	const struct video_hw_if *hw = sc->hw_if;
    911       1.24  jmcneill 	enum video_standard vstd;
    912       1.24  jmcneill 	int err;
    913       1.24  jmcneill 
    914       1.24  jmcneill 	/* simple webcam drivers don't need to implement this callback */
    915       1.24  jmcneill 	if (hw->enum_standard == NULL) {
    916       1.24  jmcneill 		if (std->index != 0)
    917       1.24  jmcneill 			return EINVAL;
    918       1.24  jmcneill 		std->id = V4L2_STD_UNKNOWN;
    919       1.24  jmcneill 		strlcpy(std->name, "webcam", sizeof(std->name));
    920       1.24  jmcneill 		return 0;
    921       1.24  jmcneill 	}
    922       1.24  jmcneill 
    923       1.24  jmcneill 	v4l2_standard_to_video_standard(std->id, &vstd);
    924       1.24  jmcneill 
    925       1.24  jmcneill 	err = hw->enum_standard(sc->hw_softc, std->index, &vstd);
    926       1.24  jmcneill 	if (err != 0)
    927       1.24  jmcneill 		return err;
    928       1.24  jmcneill 
    929       1.24  jmcneill 	video_standard_to_v4l2_standard(vstd, std);
    930       1.24  jmcneill 
    931       1.24  jmcneill 	return 0;
    932       1.24  jmcneill }
    933       1.24  jmcneill 
    934       1.24  jmcneill static int
    935       1.24  jmcneill video_get_standard(struct video_softc *sc, v4l2_std_id *stdid)
    936       1.24  jmcneill {
    937       1.24  jmcneill 	const struct video_hw_if *hw = sc->hw_if;
    938       1.24  jmcneill 	struct v4l2_standard std;
    939       1.24  jmcneill 	enum video_standard vstd;
    940       1.24  jmcneill 	int err;
    941       1.24  jmcneill 
    942       1.24  jmcneill 	/* simple webcam drivers don't need to implement this callback */
    943       1.24  jmcneill 	if (hw->get_standard == NULL) {
    944       1.24  jmcneill 		*stdid = V4L2_STD_UNKNOWN;
    945       1.24  jmcneill 		return 0;
    946       1.24  jmcneill 	}
    947       1.24  jmcneill 
    948       1.24  jmcneill 	err = hw->get_standard(sc->hw_softc, &vstd);
    949       1.24  jmcneill 	if (err != 0)
    950       1.24  jmcneill 		return err;
    951       1.24  jmcneill 
    952       1.24  jmcneill 	video_standard_to_v4l2_standard(vstd, &std);
    953       1.24  jmcneill 	*stdid = std.id;
    954       1.24  jmcneill 
    955       1.24  jmcneill 	return 0;
    956       1.24  jmcneill }
    957       1.24  jmcneill 
    958       1.24  jmcneill static int
    959       1.24  jmcneill video_set_standard(struct video_softc *sc, v4l2_std_id stdid)
    960       1.24  jmcneill {
    961       1.24  jmcneill 	const struct video_hw_if *hw = sc->hw_if;
    962       1.24  jmcneill 	enum video_standard vstd;
    963       1.24  jmcneill 
    964       1.24  jmcneill 	/* simple webcam drivers don't need to implement this callback */
    965       1.24  jmcneill 	if (hw->set_standard == NULL) {
    966       1.24  jmcneill 		if (stdid != V4L2_STD_UNKNOWN)
    967       1.24  jmcneill 			return EINVAL;
    968       1.24  jmcneill 		return 0;
    969       1.24  jmcneill 	}
    970       1.24  jmcneill 
    971       1.24  jmcneill 	v4l2_standard_to_video_standard(stdid, &vstd);
    972       1.24  jmcneill 
    973       1.24  jmcneill 	return hw->set_standard(sc->hw_softc, vstd);
    974       1.24  jmcneill }
    975       1.24  jmcneill 
    976       1.24  jmcneill static void
    977       1.24  jmcneill v4l2_input_to_video_input(const struct v4l2_input *input,
    978       1.24  jmcneill     struct video_input *vi)
    979       1.24  jmcneill {
    980       1.24  jmcneill 	vi->index = input->index;
    981       1.24  jmcneill 	strlcpy(vi->name, input->name, sizeof(vi->name));
    982       1.24  jmcneill 	switch (input->type) {
    983       1.24  jmcneill 	case V4L2_INPUT_TYPE_TUNER:
    984       1.24  jmcneill 		vi->type = VIDEO_INPUT_TYPE_TUNER;
    985       1.24  jmcneill 		break;
    986       1.24  jmcneill 	case V4L2_INPUT_TYPE_CAMERA:
    987       1.24  jmcneill 		vi->type = VIDEO_INPUT_TYPE_CAMERA;
    988       1.24  jmcneill 		break;
    989       1.24  jmcneill 	}
    990       1.24  jmcneill 	vi->audiomask = input->audioset;
    991       1.24  jmcneill 	vi->tuner_index = input->tuner;
    992       1.24  jmcneill 	vi->standards = input->std;	/* ... values are the same */
    993       1.24  jmcneill 	vi->status = 0;
    994       1.24  jmcneill 	if (input->status & V4L2_IN_ST_NO_POWER)
    995       1.24  jmcneill 		vi->status |= VIDEO_STATUS_NO_POWER;
    996       1.24  jmcneill 	if (input->status & V4L2_IN_ST_NO_SIGNAL)
    997       1.24  jmcneill 		vi->status |= VIDEO_STATUS_NO_SIGNAL;
    998       1.24  jmcneill 	if (input->status & V4L2_IN_ST_NO_COLOR)
    999       1.24  jmcneill 		vi->status |= VIDEO_STATUS_NO_COLOR;
   1000       1.24  jmcneill 	if (input->status & V4L2_IN_ST_NO_H_LOCK)
   1001       1.24  jmcneill 		vi->status |= VIDEO_STATUS_NO_HLOCK;
   1002       1.24  jmcneill 	if (input->status & V4L2_IN_ST_MACROVISION)
   1003       1.24  jmcneill 		vi->status |= VIDEO_STATUS_MACROVISION;
   1004       1.24  jmcneill }
   1005       1.24  jmcneill 
   1006       1.24  jmcneill static void
   1007       1.24  jmcneill video_input_to_v4l2_input(const struct video_input *vi,
   1008       1.24  jmcneill     struct v4l2_input *input)
   1009       1.24  jmcneill {
   1010       1.24  jmcneill 	input->index = vi->index;
   1011       1.24  jmcneill 	strlcpy(input->name, vi->name, sizeof(input->name));
   1012       1.24  jmcneill 	switch (vi->type) {
   1013       1.24  jmcneill 	case VIDEO_INPUT_TYPE_TUNER:
   1014       1.24  jmcneill 		input->type = V4L2_INPUT_TYPE_TUNER;
   1015       1.24  jmcneill 		break;
   1016       1.24  jmcneill 	case VIDEO_INPUT_TYPE_CAMERA:
   1017       1.24  jmcneill 		input->type = V4L2_INPUT_TYPE_CAMERA;
   1018       1.24  jmcneill 		break;
   1019       1.24  jmcneill 	}
   1020       1.24  jmcneill 	input->audioset = vi->audiomask;
   1021       1.24  jmcneill 	input->tuner = vi->tuner_index;
   1022       1.24  jmcneill 	input->std = vi->standards;	/* ... values are the same */
   1023       1.24  jmcneill 	input->status = 0;
   1024       1.24  jmcneill 	if (vi->status & VIDEO_STATUS_NO_POWER)
   1025       1.24  jmcneill 		input->status |= V4L2_IN_ST_NO_POWER;
   1026       1.24  jmcneill 	if (vi->status & VIDEO_STATUS_NO_SIGNAL)
   1027       1.24  jmcneill 		input->status |= V4L2_IN_ST_NO_SIGNAL;
   1028       1.24  jmcneill 	if (vi->status & VIDEO_STATUS_NO_COLOR)
   1029       1.24  jmcneill 		input->status |= V4L2_IN_ST_NO_COLOR;
   1030       1.24  jmcneill 	if (vi->status & VIDEO_STATUS_NO_HLOCK)
   1031       1.24  jmcneill 		input->status |= V4L2_IN_ST_NO_H_LOCK;
   1032       1.24  jmcneill 	if (vi->status & VIDEO_STATUS_MACROVISION)
   1033       1.24  jmcneill 		input->status |= V4L2_IN_ST_MACROVISION;
   1034       1.24  jmcneill }
   1035       1.24  jmcneill 
   1036       1.24  jmcneill static int
   1037       1.24  jmcneill video_enum_input(struct video_softc *sc, struct v4l2_input *input)
   1038       1.24  jmcneill {
   1039       1.24  jmcneill 	const struct video_hw_if *hw = sc->hw_if;
   1040       1.24  jmcneill 	struct video_input vi;
   1041       1.24  jmcneill 	int err;
   1042       1.24  jmcneill 
   1043       1.24  jmcneill 	/* simple webcam drivers don't need to implement this callback */
   1044       1.24  jmcneill 	if (hw->enum_input == NULL) {
   1045       1.24  jmcneill 		if (input->index != 0)
   1046       1.24  jmcneill 			return EINVAL;
   1047       1.24  jmcneill 		memset(input, 0, sizeof(*input));
   1048       1.24  jmcneill 		input->index = 0;
   1049       1.24  jmcneill 		strlcpy(input->name, "Camera", sizeof(input->name));
   1050       1.24  jmcneill 		input->type = V4L2_INPUT_TYPE_CAMERA;
   1051       1.24  jmcneill 		return 0;
   1052       1.24  jmcneill 	}
   1053       1.24  jmcneill 
   1054       1.24  jmcneill 	v4l2_input_to_video_input(input, &vi);
   1055       1.24  jmcneill 
   1056       1.24  jmcneill 	err = hw->enum_input(sc->hw_softc, input->index, &vi);
   1057       1.24  jmcneill 	if (err != 0)
   1058       1.24  jmcneill 		return err;
   1059       1.24  jmcneill 
   1060       1.24  jmcneill 	video_input_to_v4l2_input(&vi, input);
   1061       1.24  jmcneill 
   1062       1.24  jmcneill 	return 0;
   1063       1.24  jmcneill }
   1064       1.24  jmcneill 
   1065       1.24  jmcneill static int
   1066       1.24  jmcneill video_get_input(struct video_softc *sc, int *index)
   1067       1.24  jmcneill {
   1068       1.24  jmcneill 	const struct video_hw_if *hw = sc->hw_if;
   1069       1.24  jmcneill 	struct video_input vi;
   1070       1.24  jmcneill 	struct v4l2_input input;
   1071       1.24  jmcneill 	int err;
   1072       1.24  jmcneill 
   1073       1.24  jmcneill 	/* simple webcam drivers don't need to implement this callback */
   1074       1.24  jmcneill 	if (hw->get_input == NULL) {
   1075       1.24  jmcneill 		*index = 0;
   1076       1.24  jmcneill 		return 0;
   1077       1.24  jmcneill 	}
   1078       1.24  jmcneill 
   1079       1.24  jmcneill 	input.index = *index;
   1080       1.24  jmcneill 	v4l2_input_to_video_input(&input, &vi);
   1081       1.24  jmcneill 
   1082       1.24  jmcneill 	err = hw->get_input(sc->hw_softc, &vi);
   1083       1.24  jmcneill 	if (err != 0)
   1084       1.24  jmcneill 		return err;
   1085       1.24  jmcneill 
   1086       1.24  jmcneill 	video_input_to_v4l2_input(&vi, &input);
   1087       1.24  jmcneill 	*index = input.index;
   1088       1.24  jmcneill 
   1089       1.24  jmcneill 	return 0;
   1090       1.24  jmcneill }
   1091       1.24  jmcneill 
   1092       1.24  jmcneill static int
   1093       1.24  jmcneill video_set_input(struct video_softc *sc, int index)
   1094       1.24  jmcneill {
   1095       1.24  jmcneill 	const struct video_hw_if *hw = sc->hw_if;
   1096       1.24  jmcneill 	struct video_input vi;
   1097       1.24  jmcneill 	struct v4l2_input input;
   1098       1.24  jmcneill 
   1099       1.24  jmcneill 	/* simple webcam drivers don't need to implement this callback */
   1100       1.24  jmcneill 	if (hw->set_input == NULL) {
   1101       1.24  jmcneill 		if (index != 0)
   1102       1.24  jmcneill 			return EINVAL;
   1103       1.24  jmcneill 		return 0;
   1104       1.24  jmcneill 	}
   1105       1.24  jmcneill 
   1106       1.24  jmcneill 	input.index = index;
   1107       1.24  jmcneill 	v4l2_input_to_video_input(&input, &vi);
   1108       1.24  jmcneill 
   1109       1.24  jmcneill 	return hw->set_input(sc->hw_softc, &vi);
   1110       1.24  jmcneill }
   1111       1.24  jmcneill 
   1112       1.24  jmcneill static void
   1113       1.24  jmcneill v4l2_audio_to_video_audio(const struct v4l2_audio *audio,
   1114       1.24  jmcneill     struct video_audio *va)
   1115       1.24  jmcneill {
   1116       1.24  jmcneill 	va->index = audio->index;
   1117       1.24  jmcneill 	strlcpy(va->name, audio->name, sizeof(va->name));
   1118       1.24  jmcneill 	va->caps = va->mode = 0;
   1119       1.24  jmcneill 	if (audio->capability & V4L2_AUDCAP_STEREO)
   1120       1.24  jmcneill 		va->caps |= VIDEO_AUDIO_F_STEREO;
   1121       1.24  jmcneill 	if (audio->capability & V4L2_AUDCAP_AVL)
   1122       1.24  jmcneill 		va->caps |= VIDEO_AUDIO_F_AVL;
   1123       1.24  jmcneill 	if (audio->mode & V4L2_AUDMODE_AVL)
   1124       1.24  jmcneill 		va->mode |= VIDEO_AUDIO_F_AVL;
   1125       1.24  jmcneill }
   1126       1.24  jmcneill 
   1127       1.24  jmcneill static void
   1128       1.24  jmcneill video_audio_to_v4l2_audio(const struct video_audio *va,
   1129       1.24  jmcneill     struct v4l2_audio *audio)
   1130       1.24  jmcneill {
   1131       1.24  jmcneill 	audio->index = va->index;
   1132       1.24  jmcneill 	strlcpy(audio->name, va->name, sizeof(audio->name));
   1133       1.24  jmcneill 	audio->capability = audio->mode = 0;
   1134       1.24  jmcneill 	if (va->caps & VIDEO_AUDIO_F_STEREO)
   1135       1.24  jmcneill 		audio->capability |= V4L2_AUDCAP_STEREO;
   1136       1.24  jmcneill 	if (va->caps & VIDEO_AUDIO_F_AVL)
   1137       1.24  jmcneill 		audio->capability |= V4L2_AUDCAP_AVL;
   1138       1.24  jmcneill 	if (va->mode & VIDEO_AUDIO_F_AVL)
   1139       1.24  jmcneill 		audio->mode |= V4L2_AUDMODE_AVL;
   1140       1.24  jmcneill }
   1141       1.24  jmcneill 
   1142       1.24  jmcneill static int
   1143       1.24  jmcneill video_enum_audio(struct video_softc *sc, struct v4l2_audio *audio)
   1144       1.24  jmcneill {
   1145       1.24  jmcneill 	const struct video_hw_if *hw = sc->hw_if;
   1146       1.24  jmcneill 	struct video_audio va;
   1147       1.24  jmcneill 	int err;
   1148       1.24  jmcneill 
   1149       1.24  jmcneill 	if (hw->enum_audio == NULL)
   1150       1.24  jmcneill 		return ENOTTY;
   1151       1.24  jmcneill 
   1152       1.24  jmcneill 	v4l2_audio_to_video_audio(audio, &va);
   1153       1.24  jmcneill 
   1154       1.24  jmcneill 	err = hw->enum_audio(sc->hw_softc, audio->index, &va);
   1155       1.24  jmcneill 	if (err != 0)
   1156       1.24  jmcneill 		return err;
   1157       1.24  jmcneill 
   1158       1.24  jmcneill 	video_audio_to_v4l2_audio(&va, audio);
   1159       1.24  jmcneill 
   1160       1.24  jmcneill 	return 0;
   1161       1.24  jmcneill }
   1162       1.24  jmcneill 
   1163       1.24  jmcneill static int
   1164       1.24  jmcneill video_get_audio(struct video_softc *sc, struct v4l2_audio *audio)
   1165       1.24  jmcneill {
   1166       1.24  jmcneill 	const struct video_hw_if *hw = sc->hw_if;
   1167       1.24  jmcneill 	struct video_audio va;
   1168       1.24  jmcneill 	int err;
   1169       1.24  jmcneill 
   1170       1.24  jmcneill 	if (hw->get_audio == NULL)
   1171       1.24  jmcneill 		return ENOTTY;
   1172       1.24  jmcneill 
   1173       1.24  jmcneill 	v4l2_audio_to_video_audio(audio, &va);
   1174       1.24  jmcneill 
   1175       1.24  jmcneill 	err = hw->get_audio(sc->hw_softc, &va);
   1176       1.24  jmcneill 	if (err != 0)
   1177       1.24  jmcneill 		return err;
   1178       1.24  jmcneill 
   1179       1.24  jmcneill 	video_audio_to_v4l2_audio(&va, audio);
   1180       1.24  jmcneill 
   1181       1.24  jmcneill 	return 0;
   1182       1.24  jmcneill }
   1183       1.24  jmcneill 
   1184       1.24  jmcneill static int
   1185       1.24  jmcneill video_set_audio(struct video_softc *sc, struct v4l2_audio *audio)
   1186       1.24  jmcneill {
   1187       1.24  jmcneill 	const struct video_hw_if *hw = sc->hw_if;
   1188       1.24  jmcneill 	struct video_audio va;
   1189       1.24  jmcneill 
   1190       1.24  jmcneill 	if (hw->set_audio == NULL)
   1191       1.24  jmcneill 		return ENOTTY;
   1192       1.24  jmcneill 
   1193       1.24  jmcneill 	v4l2_audio_to_video_audio(audio, &va);
   1194       1.24  jmcneill 
   1195       1.24  jmcneill 	return hw->set_audio(sc->hw_softc, &va);
   1196       1.24  jmcneill }
   1197       1.24  jmcneill 
   1198       1.24  jmcneill static void
   1199       1.24  jmcneill v4l2_tuner_to_video_tuner(const struct v4l2_tuner *tuner,
   1200       1.24  jmcneill     struct video_tuner *vt)
   1201       1.24  jmcneill {
   1202       1.24  jmcneill 	vt->index = tuner->index;
   1203       1.24  jmcneill 	strlcpy(vt->name, tuner->name, sizeof(vt->name));
   1204       1.24  jmcneill 	vt->freq_lo = tuner->rangelow;
   1205       1.24  jmcneill 	vt->freq_hi = tuner->rangehigh;
   1206       1.24  jmcneill 	vt->signal = tuner->signal;
   1207       1.24  jmcneill 	vt->afc = tuner->afc;
   1208       1.24  jmcneill 	vt->caps = 0;
   1209       1.24  jmcneill 	if (tuner->capability & V4L2_TUNER_CAP_STEREO)
   1210       1.24  jmcneill 		vt->caps |= VIDEO_TUNER_F_STEREO;
   1211       1.24  jmcneill 	if (tuner->capability & V4L2_TUNER_CAP_LANG1)
   1212       1.24  jmcneill 		vt->caps |= VIDEO_TUNER_F_LANG1;
   1213       1.24  jmcneill 	if (tuner->capability & V4L2_TUNER_CAP_LANG2)
   1214       1.24  jmcneill 		vt->caps |= VIDEO_TUNER_F_LANG2;
   1215       1.24  jmcneill 	switch (tuner->audmode) {
   1216       1.24  jmcneill 	case V4L2_TUNER_MODE_MONO:
   1217       1.24  jmcneill 		vt->mode = VIDEO_TUNER_F_MONO;
   1218       1.24  jmcneill 		break;
   1219       1.24  jmcneill 	case V4L2_TUNER_MODE_STEREO:
   1220       1.24  jmcneill 		vt->mode = VIDEO_TUNER_F_STEREO;
   1221       1.24  jmcneill 		break;
   1222       1.24  jmcneill 	case V4L2_TUNER_MODE_LANG1:
   1223       1.24  jmcneill 		vt->mode = VIDEO_TUNER_F_LANG1;
   1224       1.24  jmcneill 		break;
   1225       1.24  jmcneill 	case V4L2_TUNER_MODE_LANG2:
   1226       1.24  jmcneill 		vt->mode = VIDEO_TUNER_F_LANG2;
   1227       1.24  jmcneill 		break;
   1228       1.24  jmcneill 	case V4L2_TUNER_MODE_LANG1_LANG2:
   1229       1.24  jmcneill 		vt->mode = VIDEO_TUNER_F_LANG1 | VIDEO_TUNER_F_LANG2;
   1230       1.24  jmcneill 		break;
   1231       1.24  jmcneill 	}
   1232       1.24  jmcneill }
   1233       1.24  jmcneill 
   1234       1.24  jmcneill static void
   1235       1.24  jmcneill video_tuner_to_v4l2_tuner(const struct video_tuner *vt,
   1236       1.24  jmcneill     struct v4l2_tuner *tuner)
   1237       1.24  jmcneill {
   1238       1.24  jmcneill 	tuner->index = vt->index;
   1239       1.24  jmcneill 	strlcpy(tuner->name, vt->name, sizeof(tuner->name));
   1240       1.24  jmcneill 	tuner->rangelow = vt->freq_lo;
   1241       1.24  jmcneill 	tuner->rangehigh = vt->freq_hi;
   1242       1.24  jmcneill 	tuner->signal = vt->signal;
   1243       1.24  jmcneill 	tuner->afc = vt->afc;
   1244       1.24  jmcneill 	tuner->capability = 0;
   1245       1.24  jmcneill 	if (vt->caps & VIDEO_TUNER_F_STEREO)
   1246       1.24  jmcneill 		tuner->capability |= V4L2_TUNER_CAP_STEREO;
   1247       1.24  jmcneill 	if (vt->caps & VIDEO_TUNER_F_LANG1)
   1248       1.24  jmcneill 		tuner->capability |= V4L2_TUNER_CAP_LANG1;
   1249       1.24  jmcneill 	if (vt->caps & VIDEO_TUNER_F_LANG2)
   1250       1.24  jmcneill 		tuner->capability |= V4L2_TUNER_CAP_LANG2;
   1251       1.24  jmcneill 	switch (vt->mode) {
   1252       1.24  jmcneill 	case VIDEO_TUNER_F_MONO:
   1253       1.24  jmcneill 		tuner->audmode = V4L2_TUNER_MODE_MONO;
   1254       1.24  jmcneill 		break;
   1255       1.24  jmcneill 	case VIDEO_TUNER_F_STEREO:
   1256       1.24  jmcneill 		tuner->audmode = V4L2_TUNER_MODE_STEREO;
   1257       1.24  jmcneill 		break;
   1258       1.24  jmcneill 	case VIDEO_TUNER_F_LANG1:
   1259       1.24  jmcneill 		tuner->audmode = V4L2_TUNER_MODE_LANG1;
   1260       1.24  jmcneill 		break;
   1261       1.24  jmcneill 	case VIDEO_TUNER_F_LANG2:
   1262       1.24  jmcneill 		tuner->audmode = V4L2_TUNER_MODE_LANG2;
   1263       1.24  jmcneill 		break;
   1264       1.24  jmcneill 	case VIDEO_TUNER_F_LANG1|VIDEO_TUNER_F_LANG2:
   1265       1.24  jmcneill 		tuner->audmode = V4L2_TUNER_MODE_LANG1_LANG2;
   1266       1.24  jmcneill 		break;
   1267       1.24  jmcneill 	}
   1268       1.24  jmcneill }
   1269       1.24  jmcneill 
   1270       1.24  jmcneill static int
   1271       1.24  jmcneill video_get_tuner(struct video_softc *sc, struct v4l2_tuner *tuner)
   1272       1.24  jmcneill {
   1273       1.24  jmcneill 	const struct video_hw_if *hw = sc->hw_if;
   1274       1.24  jmcneill 	struct video_tuner vt;
   1275       1.24  jmcneill 	int err;
   1276       1.24  jmcneill 
   1277       1.24  jmcneill 	if (hw->get_tuner == NULL)
   1278       1.24  jmcneill 		return ENOTTY;
   1279       1.24  jmcneill 
   1280       1.24  jmcneill 	v4l2_tuner_to_video_tuner(tuner, &vt);
   1281       1.24  jmcneill 
   1282       1.24  jmcneill 	err = hw->get_tuner(sc->hw_softc, &vt);
   1283       1.24  jmcneill 	if (err != 0)
   1284       1.24  jmcneill 		return err;
   1285       1.24  jmcneill 
   1286       1.24  jmcneill 	video_tuner_to_v4l2_tuner(&vt, tuner);
   1287       1.24  jmcneill 
   1288       1.24  jmcneill 	return 0;
   1289       1.24  jmcneill }
   1290       1.24  jmcneill 
   1291       1.24  jmcneill static int
   1292       1.24  jmcneill video_set_tuner(struct video_softc *sc, struct v4l2_tuner *tuner)
   1293       1.24  jmcneill {
   1294       1.24  jmcneill 	const struct video_hw_if *hw = sc->hw_if;
   1295       1.24  jmcneill 	struct video_tuner vt;
   1296       1.24  jmcneill 
   1297       1.24  jmcneill 	if (hw->set_tuner == NULL)
   1298       1.24  jmcneill 		return ENOTTY;
   1299       1.24  jmcneill 
   1300       1.24  jmcneill 	v4l2_tuner_to_video_tuner(tuner, &vt);
   1301       1.24  jmcneill 
   1302       1.24  jmcneill 	return hw->set_tuner(sc->hw_softc, &vt);
   1303       1.24  jmcneill }
   1304       1.24  jmcneill 
   1305       1.24  jmcneill static int
   1306       1.24  jmcneill video_get_frequency(struct video_softc *sc, struct v4l2_frequency *freq)
   1307       1.24  jmcneill {
   1308       1.24  jmcneill 	const struct video_hw_if *hw = sc->hw_if;
   1309       1.24  jmcneill 	struct video_frequency vfreq;
   1310       1.24  jmcneill 	int err;
   1311       1.24  jmcneill 
   1312       1.24  jmcneill 	if (hw->get_frequency == NULL)
   1313       1.24  jmcneill 		return ENOTTY;
   1314       1.24  jmcneill 
   1315       1.24  jmcneill 	err = hw->get_frequency(sc->hw_softc, &vfreq);
   1316       1.24  jmcneill 	if (err)
   1317       1.24  jmcneill 		return err;
   1318       1.24  jmcneill 
   1319       1.24  jmcneill 	freq->tuner = vfreq.tuner_index;
   1320       1.24  jmcneill 	freq->type = V4L2_TUNER_ANALOG_TV;
   1321       1.24  jmcneill 	freq->frequency = vfreq.frequency;
   1322       1.24  jmcneill 
   1323       1.24  jmcneill 	return 0;
   1324       1.24  jmcneill }
   1325       1.24  jmcneill 
   1326       1.24  jmcneill static int
   1327       1.24  jmcneill video_set_frequency(struct video_softc *sc, struct v4l2_frequency *freq)
   1328       1.24  jmcneill {
   1329       1.24  jmcneill 	const struct video_hw_if *hw = sc->hw_if;
   1330       1.24  jmcneill 	struct video_frequency vfreq;
   1331       1.26  jmcneill 	struct video_tuner vt;
   1332       1.26  jmcneill 	int error;
   1333       1.24  jmcneill 
   1334       1.26  jmcneill 	if (hw->set_frequency == NULL || hw->get_tuner == NULL)
   1335       1.24  jmcneill 		return ENOTTY;
   1336       1.24  jmcneill 	if (freq->type != V4L2_TUNER_ANALOG_TV)
   1337       1.24  jmcneill 		return EINVAL;
   1338       1.24  jmcneill 
   1339       1.26  jmcneill 	vt.index = freq->tuner;
   1340       1.26  jmcneill 	error = hw->get_tuner(sc->hw_softc, &vt);
   1341       1.26  jmcneill 	if (error)
   1342       1.26  jmcneill 		return error;
   1343       1.26  jmcneill 
   1344       1.26  jmcneill 	if (freq->frequency < vt.freq_lo)
   1345       1.26  jmcneill 		freq->frequency = vt.freq_lo;
   1346       1.26  jmcneill 	else if (freq->frequency > vt.freq_hi)
   1347       1.26  jmcneill 		freq->frequency = vt.freq_hi;
   1348       1.26  jmcneill 
   1349       1.24  jmcneill 	vfreq.tuner_index = freq->tuner;
   1350       1.24  jmcneill 	vfreq.frequency = freq->frequency;
   1351       1.24  jmcneill 
   1352       1.24  jmcneill 	return hw->set_frequency(sc->hw_softc, &vfreq);
   1353       1.24  jmcneill }
   1354       1.24  jmcneill 
   1355        1.1  jmcneill /* Takes a single Video4Linux2 control, converts it to a struct
   1356        1.1  jmcneill  * video_control, and calls the hardware driver. */
   1357        1.1  jmcneill static int
   1358        1.1  jmcneill video_set_control(struct video_softc *sc,
   1359        1.1  jmcneill 		       const struct v4l2_control *vcontrol)
   1360        1.1  jmcneill {
   1361        1.1  jmcneill 	const struct video_hw_if *hw;
   1362        1.1  jmcneill 	struct video_control_group group;
   1363        1.1  jmcneill 	struct video_control control;
   1364        1.1  jmcneill 
   1365        1.1  jmcneill 	hw = sc->hw_if;
   1366        1.1  jmcneill 	if (hw->set_control_group) {
   1367        1.1  jmcneill 		control.group_id = control.control_id =
   1368        1.1  jmcneill 		    v4l2id_to_control_id(vcontrol->id);
   1369        1.1  jmcneill 		/* ?? if "control_id" is arbitrarily defined by the
   1370        1.1  jmcneill 		 * driver, then we need some way to store it...  Maybe
   1371        1.1  jmcneill 		 * it doesn't matter for single value controls. */
   1372        1.1  jmcneill 		control.value = vcontrol->value;
   1373        1.1  jmcneill 
   1374        1.1  jmcneill 		group.group_id = control.group_id;
   1375        1.1  jmcneill 		group.length = 1;
   1376        1.1  jmcneill 		group.control = &control;
   1377        1.1  jmcneill 
   1378        1.1  jmcneill 		return (hw->set_control_group(sc->hw_softc, &group));
   1379        1.1  jmcneill 	} else {
   1380        1.1  jmcneill 		return EINVAL;
   1381        1.1  jmcneill 	}
   1382        1.1  jmcneill }
   1383        1.1  jmcneill 
   1384        1.1  jmcneill static int
   1385        1.1  jmcneill video_request_bufs(struct video_softc *sc,
   1386        1.1  jmcneill 		   struct v4l2_requestbuffers *req)
   1387        1.1  jmcneill {
   1388        1.1  jmcneill 	struct video_stream *vs = &sc->sc_stream_in;
   1389        1.1  jmcneill 	struct v4l2_buffer *buf;
   1390        1.1  jmcneill 	int i, err;
   1391        1.1  jmcneill 
   1392        1.1  jmcneill 	if (req->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
   1393        1.1  jmcneill 		return EINVAL;
   1394        1.1  jmcneill 
   1395        1.1  jmcneill 	vs->vs_type = req->type;
   1396        1.1  jmcneill 
   1397        1.1  jmcneill 	switch (req->memory) {
   1398        1.1  jmcneill 	case V4L2_MEMORY_MMAP:
   1399        1.1  jmcneill 		if (req->count < VIDEO_MIN_BUFS)
   1400        1.1  jmcneill 			req->count = VIDEO_MIN_BUFS;
   1401        1.1  jmcneill 		else if (req->count > VIDEO_MAX_BUFS)
   1402        1.1  jmcneill 			req->count = VIDEO_MAX_BUFS;
   1403        1.1  jmcneill 
   1404        1.1  jmcneill 		err = video_stream_setup_bufs(vs,
   1405        1.1  jmcneill 					      VIDEO_STREAM_METHOD_MMAP,
   1406        1.1  jmcneill 					      req->count);
   1407        1.1  jmcneill 		if (err != 0)
   1408        1.1  jmcneill 			return err;
   1409        1.1  jmcneill 
   1410        1.1  jmcneill 		for (i = 0; i < req->count; ++i) {
   1411        1.1  jmcneill 			buf = vs->vs_buf[i]->vb_buf;
   1412        1.1  jmcneill 			buf->memory = V4L2_MEMORY_MMAP;
   1413        1.1  jmcneill 			buf->flags |= V4L2_BUF_FLAG_MAPPED;
   1414        1.1  jmcneill 		}
   1415        1.1  jmcneill 		break;
   1416        1.1  jmcneill 	case V4L2_MEMORY_USERPTR:
   1417        1.1  jmcneill 	default:
   1418        1.1  jmcneill 		return EINVAL;
   1419        1.1  jmcneill 	}
   1420        1.1  jmcneill 
   1421        1.1  jmcneill 	return 0;
   1422        1.1  jmcneill }
   1423        1.1  jmcneill 
   1424        1.1  jmcneill static int
   1425        1.1  jmcneill video_query_buf(struct video_softc *sc,
   1426        1.1  jmcneill 		struct v4l2_buffer *buf)
   1427        1.1  jmcneill {
   1428        1.1  jmcneill 	struct video_stream *vs = &sc->sc_stream_in;
   1429        1.1  jmcneill 
   1430        1.1  jmcneill 	if (buf->type != vs->vs_type)
   1431        1.1  jmcneill 		return EINVAL;
   1432        1.1  jmcneill 	if (buf->index >= vs->vs_nbufs)
   1433        1.1  jmcneill 		return EINVAL;
   1434        1.1  jmcneill 
   1435        1.1  jmcneill 	memcpy(buf, vs->vs_buf[buf->index]->vb_buf, sizeof(*buf));
   1436        1.1  jmcneill 
   1437        1.1  jmcneill 	return 0;
   1438        1.1  jmcneill }
   1439        1.1  jmcneill 
   1440        1.1  jmcneill /* Accept a buffer descriptor from userspace and return the indicated
   1441        1.1  jmcneill  * buffer to the driver's queue. */
   1442        1.1  jmcneill static int
   1443        1.1  jmcneill video_queue_buf(struct video_softc *sc, struct v4l2_buffer *userbuf)
   1444        1.1  jmcneill {
   1445        1.1  jmcneill 	struct video_stream *vs = &sc->sc_stream_in;
   1446        1.1  jmcneill 	struct video_buffer *vb;
   1447        1.1  jmcneill 	struct v4l2_buffer *driverbuf;
   1448        1.1  jmcneill 
   1449        1.1  jmcneill 	if (userbuf->type != vs->vs_type) {
   1450        1.1  jmcneill 		DPRINTF(("video_queue_buf: expected type=%d got type=%d\n",
   1451        1.1  jmcneill 			 userbuf->type, vs->vs_type));
   1452        1.1  jmcneill 		return EINVAL;
   1453        1.1  jmcneill 	}
   1454        1.1  jmcneill 	if (userbuf->index >= vs->vs_nbufs) {
   1455        1.1  jmcneill 		DPRINTF(("video_queue_buf: invalid index %d >= %d\n",
   1456        1.1  jmcneill 			 userbuf->index, vs->vs_nbufs));
   1457        1.1  jmcneill 		return EINVAL;
   1458        1.1  jmcneill 	}
   1459        1.1  jmcneill 
   1460        1.1  jmcneill 	switch (vs->vs_method) {
   1461        1.1  jmcneill 	case VIDEO_STREAM_METHOD_MMAP:
   1462        1.1  jmcneill 		if (userbuf->memory != V4L2_MEMORY_MMAP) {
   1463        1.1  jmcneill 			DPRINTF(("video_queue_buf: invalid memory=%d\n",
   1464        1.1  jmcneill 				 userbuf->memory));
   1465        1.1  jmcneill 			return EINVAL;
   1466        1.1  jmcneill 		}
   1467        1.1  jmcneill 
   1468        1.1  jmcneill 		mutex_enter(&vs->vs_lock);
   1469        1.1  jmcneill 
   1470        1.1  jmcneill 		vb = vs->vs_buf[userbuf->index];
   1471        1.1  jmcneill 		driverbuf = vb->vb_buf;
   1472        1.1  jmcneill 		if (driverbuf->flags & V4L2_BUF_FLAG_QUEUED) {
   1473        1.1  jmcneill 			DPRINTF(("video_queue_buf: buf already queued; "
   1474        1.1  jmcneill 				 "flags=0x%x\n", driverbuf->flags));
   1475        1.1  jmcneill 			mutex_exit(&vs->vs_lock);
   1476        1.1  jmcneill 			return EINVAL;
   1477        1.1  jmcneill 		}
   1478        1.1  jmcneill 		video_stream_enqueue(vs, vb);
   1479        1.1  jmcneill 		memcpy(userbuf, driverbuf, sizeof(*driverbuf));
   1480        1.1  jmcneill 
   1481        1.1  jmcneill 		mutex_exit(&vs->vs_lock);
   1482        1.1  jmcneill 		break;
   1483        1.1  jmcneill 	default:
   1484        1.1  jmcneill 		return EINVAL;
   1485        1.1  jmcneill 	}
   1486        1.1  jmcneill 
   1487        1.1  jmcneill 	return 0;
   1488        1.1  jmcneill }
   1489        1.1  jmcneill 
   1490        1.1  jmcneill /* Dequeue the described buffer from the driver queue, making it
   1491        1.1  jmcneill  * available for reading via mmap. */
   1492        1.1  jmcneill static int
   1493        1.1  jmcneill video_dequeue_buf(struct video_softc *sc, struct v4l2_buffer *buf)
   1494        1.1  jmcneill {
   1495        1.1  jmcneill 	struct video_stream *vs = &sc->sc_stream_in;
   1496        1.1  jmcneill 	struct video_buffer *vb;
   1497        1.1  jmcneill 	int err;
   1498        1.1  jmcneill 
   1499       1.15  jmcneill 	if (buf->type != vs->vs_type) {
   1500       1.15  jmcneill 		aprint_debug_dev(sc->sc_dev,
   1501       1.15  jmcneill 		    "requested type %d (expected %d)\n",
   1502       1.15  jmcneill 		    buf->type, vs->vs_type);
   1503        1.1  jmcneill 		return EINVAL;
   1504       1.15  jmcneill 	}
   1505        1.1  jmcneill 
   1506        1.1  jmcneill 	switch (vs->vs_method) {
   1507        1.1  jmcneill 	case VIDEO_STREAM_METHOD_MMAP:
   1508       1.15  jmcneill 		if (buf->memory != V4L2_MEMORY_MMAP) {
   1509       1.15  jmcneill 			aprint_debug_dev(sc->sc_dev,
   1510       1.15  jmcneill 			    "requested memory %d (expected %d)\n",
   1511       1.15  jmcneill 			    buf->memory, V4L2_MEMORY_MMAP);
   1512        1.1  jmcneill 			return EINVAL;
   1513       1.15  jmcneill 		}
   1514        1.1  jmcneill 
   1515        1.1  jmcneill 		mutex_enter(&vs->vs_lock);
   1516        1.1  jmcneill 
   1517        1.1  jmcneill 		if (vs->vs_flags & O_NONBLOCK) {
   1518        1.1  jmcneill 			vb = video_stream_dequeue(vs);
   1519        1.1  jmcneill 			if (vb == NULL) {
   1520        1.1  jmcneill 				mutex_exit(&vs->vs_lock);
   1521        1.1  jmcneill 				return EAGAIN;
   1522        1.1  jmcneill 			}
   1523        1.1  jmcneill 		} else {
   1524        1.1  jmcneill 			/* Block until we have sample */
   1525        1.1  jmcneill 			while ((vb = video_stream_dequeue(vs)) == NULL) {
   1526       1.19  drochner 				if (!vs->vs_streaming) {
   1527       1.19  drochner 					mutex_exit(&vs->vs_lock);
   1528       1.19  drochner 					return EINVAL;
   1529       1.19  drochner 				}
   1530        1.1  jmcneill 				err = cv_wait_sig(&vs->vs_sample_cv,
   1531        1.1  jmcneill 						  &vs->vs_lock);
   1532        1.1  jmcneill 				if (err != 0) {
   1533        1.1  jmcneill 					mutex_exit(&vs->vs_lock);
   1534        1.1  jmcneill 					return EINTR;
   1535        1.1  jmcneill 				}
   1536        1.1  jmcneill 			}
   1537        1.1  jmcneill 		}
   1538        1.1  jmcneill 
   1539        1.1  jmcneill 		memcpy(buf, vb->vb_buf, sizeof(*buf));
   1540        1.1  jmcneill 
   1541        1.1  jmcneill 		mutex_exit(&vs->vs_lock);
   1542        1.1  jmcneill 		break;
   1543        1.1  jmcneill 	default:
   1544       1.15  jmcneill 		aprint_debug_dev(sc->sc_dev, "unknown vs_method %d\n",
   1545       1.15  jmcneill 		    vs->vs_method);
   1546        1.1  jmcneill 		return EINVAL;
   1547        1.1  jmcneill 	}
   1548        1.1  jmcneill 
   1549        1.1  jmcneill 	return 0;
   1550        1.1  jmcneill }
   1551        1.1  jmcneill 
   1552        1.1  jmcneill static int
   1553        1.1  jmcneill video_stream_on(struct video_softc *sc, enum v4l2_buf_type type)
   1554        1.1  jmcneill {
   1555        1.1  jmcneill 	int err;
   1556        1.1  jmcneill 	struct video_stream *vs = &sc->sc_stream_in;
   1557        1.1  jmcneill 	const struct video_hw_if *hw;
   1558        1.1  jmcneill 
   1559        1.1  jmcneill 	if (vs->vs_streaming)
   1560        1.1  jmcneill 		return 0;
   1561        1.1  jmcneill 	if (type != vs->vs_type)
   1562        1.1  jmcneill 		return EINVAL;
   1563        1.1  jmcneill 
   1564        1.1  jmcneill 	hw = sc->hw_if;
   1565        1.1  jmcneill 	if (hw == NULL)
   1566        1.1  jmcneill 		return ENXIO;
   1567        1.1  jmcneill 
   1568        1.1  jmcneill 
   1569        1.1  jmcneill 	err = hw->start_transfer(sc->hw_softc);
   1570        1.1  jmcneill 	if (err != 0)
   1571        1.1  jmcneill 		return err;
   1572        1.1  jmcneill 
   1573        1.1  jmcneill 	vs->vs_streaming = true;
   1574        1.1  jmcneill 	return 0;
   1575        1.1  jmcneill }
   1576        1.1  jmcneill 
   1577        1.1  jmcneill static int
   1578        1.1  jmcneill video_stream_off(struct video_softc *sc, enum v4l2_buf_type type)
   1579        1.1  jmcneill {
   1580        1.1  jmcneill 	int err;
   1581        1.1  jmcneill 	struct video_stream *vs = &sc->sc_stream_in;
   1582        1.1  jmcneill 	const struct video_hw_if *hw;
   1583        1.1  jmcneill 
   1584        1.1  jmcneill 	if (!vs->vs_streaming)
   1585        1.1  jmcneill 		return 0;
   1586        1.1  jmcneill 	if (type != vs->vs_type)
   1587        1.1  jmcneill 		return EINVAL;
   1588        1.1  jmcneill 
   1589        1.1  jmcneill 	hw = sc->hw_if;
   1590        1.1  jmcneill 	if (hw == NULL)
   1591        1.1  jmcneill 		return ENXIO;
   1592        1.1  jmcneill 
   1593        1.1  jmcneill 	err = hw->stop_transfer(sc->hw_softc);
   1594        1.1  jmcneill 	if (err != 0)
   1595        1.1  jmcneill 		return err;
   1596        1.1  jmcneill 
   1597        1.1  jmcneill 	vs->vs_frameno = -1;
   1598        1.1  jmcneill 	vs->vs_sequence = 0;
   1599        1.1  jmcneill 	vs->vs_streaming = false;
   1600        1.1  jmcneill 
   1601        1.1  jmcneill 	return 0;
   1602        1.1  jmcneill }
   1603        1.1  jmcneill 
   1604        1.1  jmcneill int
   1605        1.1  jmcneill videoopen(dev_t dev, int flags, int ifmt, struct lwp *l)
   1606        1.1  jmcneill {
   1607        1.1  jmcneill 	struct video_softc *sc;
   1608        1.1  jmcneill 	const struct video_hw_if *hw;
   1609        1.1  jmcneill 	struct video_stream *vs;
   1610        1.1  jmcneill 	int err;
   1611        1.1  jmcneill 
   1612        1.1  jmcneill 	DPRINTF(("videoopen\n"));
   1613        1.1  jmcneill 
   1614  1.32.18.1  pgoyette 	sc = device_private(device_lookup_acquire(&video_cd, VIDEOUNIT(dev)));
   1615        1.1  jmcneill 	if (sc == NULL) {
   1616       1.29     prlw1 		DPRINTF(("videoopen: failed to get softc for unit %d\n",
   1617       1.29     prlw1 			VIDEOUNIT(dev)));
   1618        1.1  jmcneill 		return ENXIO;
   1619        1.1  jmcneill 	}
   1620        1.1  jmcneill 
   1621        1.1  jmcneill 	if (sc->sc_dying) {
   1622        1.1  jmcneill 		DPRINTF(("videoopen: dying\n"));
   1623  1.32.18.1  pgoyette 		device_release(sc->sc_dev);
   1624        1.1  jmcneill 		return EIO;
   1625        1.1  jmcneill 	}
   1626        1.1  jmcneill 
   1627        1.1  jmcneill 	sc->sc_stream_in.vs_flags = flags;
   1628        1.1  jmcneill 
   1629        1.1  jmcneill 	DPRINTF(("videoopen: flags=0x%x sc=%p parent=%p\n",
   1630        1.1  jmcneill 		 flags, sc, sc->hw_dev));
   1631        1.1  jmcneill 
   1632        1.1  jmcneill 	hw = sc->hw_if;
   1633  1.32.18.1  pgoyette 	if (hw == NULL) {
   1634  1.32.18.1  pgoyette 		device_release(sc->sc_dev);
   1635        1.1  jmcneill 		return ENXIO;
   1636  1.32.18.1  pgoyette 	}
   1637        1.1  jmcneill 
   1638        1.1  jmcneill 	device_active(sc->sc_dev, DVA_SYSTEM);
   1639        1.1  jmcneill 
   1640        1.1  jmcneill 	sc->sc_opencnt++;
   1641        1.1  jmcneill 
   1642        1.1  jmcneill 	if (hw->open != NULL) {
   1643        1.1  jmcneill 		err = hw->open(sc->hw_softc, flags);
   1644  1.32.18.1  pgoyette 		if (err) {
   1645  1.32.18.1  pgoyette 			device_release(sc->sc_dev);
   1646        1.1  jmcneill 			return err;
   1647  1.32.18.1  pgoyette 		}
   1648        1.1  jmcneill 	}
   1649        1.1  jmcneill 
   1650        1.1  jmcneill 	/* set up input stream.  TODO: check flags to determine if
   1651        1.1  jmcneill 	 * "read" is desired? */
   1652        1.1  jmcneill 	vs = &sc->sc_stream_in;
   1653        1.1  jmcneill 
   1654       1.15  jmcneill 	if (hw->get_format != NULL) {
   1655       1.15  jmcneill 		err = hw->get_format(sc->hw_softc, &vs->vs_format);
   1656  1.32.18.1  pgoyette 		if (err != 0) {
   1657  1.32.18.1  pgoyette 			device_release(sc->sc_dev);
   1658        1.1  jmcneill 			return err;
   1659  1.32.18.1  pgoyette 		}
   1660        1.1  jmcneill 	}
   1661  1.32.18.1  pgoyette 	device_release(sc->sc_dev);
   1662        1.1  jmcneill 	return 0;
   1663        1.1  jmcneill }
   1664        1.1  jmcneill 
   1665        1.1  jmcneill 
   1666        1.1  jmcneill int
   1667        1.1  jmcneill videoclose(dev_t dev, int flags, int ifmt, struct lwp *l)
   1668        1.1  jmcneill {
   1669        1.1  jmcneill 	struct video_softc *sc;
   1670        1.1  jmcneill 	const struct video_hw_if *hw;
   1671        1.1  jmcneill 
   1672  1.32.18.1  pgoyette 	sc = device_private(device_lookup_acquire(&video_cd, VIDEOUNIT(dev)));
   1673        1.1  jmcneill 	if (sc == NULL)
   1674        1.1  jmcneill 		return ENXIO;
   1675        1.1  jmcneill 
   1676        1.1  jmcneill 	DPRINTF(("videoclose: sc=%p\n", sc));
   1677        1.1  jmcneill 
   1678        1.1  jmcneill 	hw = sc->hw_if;
   1679  1.32.18.1  pgoyette 	if (hw == NULL) {
   1680  1.32.18.1  pgoyette 		device_release(sc->sc_dev);
   1681        1.1  jmcneill 		return ENXIO;
   1682  1.32.18.1  pgoyette 	}
   1683        1.1  jmcneill 
   1684        1.1  jmcneill 	device_active(sc->sc_dev, DVA_SYSTEM);
   1685        1.1  jmcneill 
   1686        1.1  jmcneill 	video_stream_off(sc, sc->sc_stream_in.vs_type);
   1687        1.1  jmcneill 
   1688        1.1  jmcneill 	/* ignore error */
   1689        1.1  jmcneill 	if (hw->close != NULL)
   1690        1.1  jmcneill 		hw->close(sc->hw_softc);
   1691        1.1  jmcneill 
   1692        1.1  jmcneill 	video_stream_teardown_bufs(&sc->sc_stream_in);
   1693        1.1  jmcneill 
   1694        1.1  jmcneill 	sc->sc_open = 0;
   1695        1.1  jmcneill 	sc->sc_opencnt--;
   1696        1.1  jmcneill 
   1697  1.32.18.1  pgoyette 	device_release(sc->sc_dev);
   1698        1.1  jmcneill 	return 0;
   1699        1.1  jmcneill }
   1700        1.1  jmcneill 
   1701        1.1  jmcneill 
   1702        1.1  jmcneill int
   1703        1.1  jmcneill videoread(dev_t dev, struct uio *uio, int ioflag)
   1704        1.1  jmcneill {
   1705        1.1  jmcneill 	struct video_softc *sc;
   1706        1.1  jmcneill 	struct video_stream *vs;
   1707        1.1  jmcneill 	struct video_buffer *vb;
   1708        1.1  jmcneill 	struct scatter_io sio;
   1709        1.1  jmcneill 	int err;
   1710        1.1  jmcneill 	size_t len;
   1711        1.1  jmcneill 	off_t offset;
   1712        1.1  jmcneill 
   1713  1.32.18.1  pgoyette 	sc = device_private(device_lookup_acquire(&video_cd, VIDEOUNIT(dev)));
   1714        1.1  jmcneill 	if (sc == NULL)
   1715        1.1  jmcneill 		return ENXIO;
   1716        1.1  jmcneill 
   1717  1.32.18.1  pgoyette 	if (sc->sc_dying) {
   1718  1.32.18.1  pgoyette 		device_release(sc->sc_dev);
   1719        1.1  jmcneill 		return EIO;
   1720  1.32.18.1  pgoyette 	}
   1721        1.1  jmcneill 
   1722        1.1  jmcneill 	vs = &sc->sc_stream_in;
   1723        1.1  jmcneill 
   1724        1.1  jmcneill 	/* userspace has chosen read() method */
   1725        1.1  jmcneill 	if (vs->vs_method == VIDEO_STREAM_METHOD_NONE) {
   1726        1.1  jmcneill 		err = video_stream_setup_bufs(vs,
   1727        1.1  jmcneill 					      VIDEO_STREAM_METHOD_READ,
   1728        1.1  jmcneill 					      VIDEO_NUM_BUFS);
   1729  1.32.18.1  pgoyette 		if (err == 0)
   1730  1.32.18.1  pgoyette 			err = video_stream_on(sc, vs->vs_type);
   1731  1.32.18.1  pgoyette 
   1732  1.32.18.1  pgoyette 		if (err != 0) {
   1733  1.32.18.1  pgoyette 			device_release(sc->sc_dev);
   1734        1.1  jmcneill 			return err;
   1735  1.32.18.1  pgoyette 		}
   1736        1.1  jmcneill 
   1737        1.1  jmcneill 			return err;
   1738        1.1  jmcneill 	} else if (vs->vs_method != VIDEO_STREAM_METHOD_READ) {
   1739  1.32.18.1  pgoyette 		device_release(sc->sc_dev);
   1740        1.1  jmcneill 		return EBUSY;
   1741        1.1  jmcneill 	}
   1742        1.1  jmcneill 
   1743        1.1  jmcneill 	mutex_enter(&vs->vs_lock);
   1744        1.1  jmcneill 
   1745        1.1  jmcneill retry:
   1746        1.1  jmcneill 	if (SIMPLEQ_EMPTY(&vs->vs_egress)) {
   1747        1.1  jmcneill 		if (vs->vs_flags & O_NONBLOCK) {
   1748        1.1  jmcneill 			mutex_exit(&vs->vs_lock);
   1749  1.32.18.1  pgoyette 			device_release(sc->sc_dev);
   1750        1.1  jmcneill 			return EAGAIN;
   1751        1.1  jmcneill 		}
   1752        1.1  jmcneill 
   1753        1.1  jmcneill 		/* Block until we have a sample */
   1754        1.1  jmcneill 		while (SIMPLEQ_EMPTY(&vs->vs_egress)) {
   1755        1.1  jmcneill 			err = cv_wait_sig(&vs->vs_sample_cv,
   1756        1.1  jmcneill 					  &vs->vs_lock);
   1757        1.1  jmcneill 			if (err != 0) {
   1758        1.1  jmcneill 				mutex_exit(&vs->vs_lock);
   1759  1.32.18.1  pgoyette 				device_release(sc->sc_dev);
   1760        1.1  jmcneill 				return EINTR;
   1761        1.1  jmcneill 			}
   1762        1.1  jmcneill 		}
   1763        1.1  jmcneill 
   1764        1.1  jmcneill 		vb = SIMPLEQ_FIRST(&vs->vs_egress);
   1765        1.1  jmcneill 	} else {
   1766        1.1  jmcneill 	        vb = SIMPLEQ_FIRST(&vs->vs_egress);
   1767        1.1  jmcneill 	}
   1768        1.1  jmcneill 
   1769        1.1  jmcneill 	/* Oops, empty sample buffer. */
   1770        1.1  jmcneill 	if (vb->vb_buf->bytesused == 0) {
   1771        1.1  jmcneill 		vb = video_stream_dequeue(vs);
   1772        1.1  jmcneill 		video_stream_enqueue(vs, vb);
   1773        1.1  jmcneill 		vs->vs_bytesread = 0;
   1774        1.1  jmcneill 		goto retry;
   1775        1.1  jmcneill 	}
   1776        1.1  jmcneill 
   1777        1.1  jmcneill 	mutex_exit(&vs->vs_lock);
   1778        1.1  jmcneill 
   1779        1.1  jmcneill 	len = min(uio->uio_resid, vb->vb_buf->bytesused - vs->vs_bytesread);
   1780        1.1  jmcneill 	offset = vb->vb_buf->m.offset + vs->vs_bytesread;
   1781        1.1  jmcneill 
   1782        1.1  jmcneill 	if (scatter_io_init(&vs->vs_data, offset, len, &sio)) {
   1783        1.1  jmcneill 		err = scatter_io_uiomove(&sio, uio);
   1784  1.32.18.1  pgoyette 		if (err == EFAULT) {
   1785  1.32.18.1  pgoyette 			device_release(sc->sc_dev);
   1786        1.1  jmcneill 			return EFAULT;
   1787  1.32.18.1  pgoyette 		}
   1788        1.1  jmcneill 		vs->vs_bytesread += (len - sio.sio_resid);
   1789        1.1  jmcneill 	} else {
   1790        1.1  jmcneill 		DPRINTF(("video: invalid read\n"));
   1791        1.1  jmcneill 	}
   1792        1.1  jmcneill 
   1793        1.1  jmcneill 	/* Move the sample to the ingress queue if everything has
   1794        1.1  jmcneill 	 * been read */
   1795        1.1  jmcneill 	if (vs->vs_bytesread >= vb->vb_buf->bytesused) {
   1796        1.1  jmcneill 		mutex_enter(&vs->vs_lock);
   1797        1.1  jmcneill 		vb = video_stream_dequeue(vs);
   1798        1.1  jmcneill 		video_stream_enqueue(vs, vb);
   1799        1.1  jmcneill 		mutex_exit(&vs->vs_lock);
   1800        1.1  jmcneill 
   1801        1.1  jmcneill 		vs->vs_bytesread = 0;
   1802        1.1  jmcneill 	}
   1803        1.1  jmcneill 
   1804  1.32.18.1  pgoyette 	device_release(sc->sc_dev);
   1805        1.1  jmcneill 	return 0;
   1806        1.1  jmcneill }
   1807        1.1  jmcneill 
   1808        1.1  jmcneill 
   1809        1.1  jmcneill int
   1810        1.1  jmcneill videowrite(dev_t dev, struct uio *uio, int ioflag)
   1811        1.1  jmcneill {
   1812        1.1  jmcneill 	return ENXIO;
   1813        1.1  jmcneill }
   1814        1.1  jmcneill 
   1815        1.1  jmcneill 
   1816       1.27  jakllsch /*
   1817       1.27  jakllsch  * Before 64-bit time_t, timeval's tv_sec was 'long'.  Thus on LP64 ports
   1818       1.27  jakllsch  * v4l2_buffer is the same size and layout as before.  However it did change
   1819       1.27  jakllsch  * on LP32 ports, and we thus handle this difference here for "COMPAT_50".
   1820       1.27  jakllsch  */
   1821       1.27  jakllsch 
   1822       1.27  jakllsch #ifndef _LP64
   1823       1.22  christos static void
   1824       1.27  jakllsch buf50tobuf(const void *data, struct v4l2_buffer *buf)
   1825       1.22  christos {
   1826       1.27  jakllsch 	const struct v4l2_buffer50 *b50 = data;
   1827       1.22  christos 
   1828       1.27  jakllsch 	buf->index = b50->index;
   1829       1.27  jakllsch 	buf->type = b50->type;
   1830       1.27  jakllsch 	buf->bytesused = b50->bytesused;
   1831       1.27  jakllsch 	buf->flags = b50->flags;
   1832       1.27  jakllsch 	buf->field = b50->field;
   1833       1.27  jakllsch 	timeval50_to_timeval(&b50->timestamp, &buf->timestamp);
   1834       1.27  jakllsch 	buf->timecode = b50->timecode;
   1835       1.27  jakllsch 	buf->sequence = b50->sequence;
   1836       1.27  jakllsch 	buf->memory = b50->memory;
   1837       1.27  jakllsch 	buf->m.offset = b50->m.offset;
   1838       1.22  christos 	/* XXX: Handle userptr */
   1839       1.27  jakllsch 	buf->length = b50->length;
   1840       1.27  jakllsch 	buf->input = b50->input;
   1841       1.27  jakllsch 	buf->reserved = b50->reserved;
   1842       1.22  christos }
   1843       1.22  christos 
   1844       1.22  christos static void
   1845       1.27  jakllsch buftobuf50(void *data, const struct v4l2_buffer *buf)
   1846       1.22  christos {
   1847       1.27  jakllsch 	struct v4l2_buffer50 *b50 = data;
   1848       1.22  christos 
   1849       1.27  jakllsch 	b50->index = buf->index;
   1850       1.27  jakllsch 	b50->type = buf->type;
   1851       1.27  jakllsch 	b50->bytesused = buf->bytesused;
   1852       1.27  jakllsch 	b50->flags = buf->flags;
   1853       1.27  jakllsch 	b50->field = buf->field;
   1854       1.27  jakllsch 	timeval_to_timeval50(&buf->timestamp, &b50->timestamp);
   1855       1.27  jakllsch 	b50->timecode = buf->timecode;
   1856       1.27  jakllsch 	b50->sequence = buf->sequence;
   1857       1.27  jakllsch 	b50->memory = buf->memory;
   1858       1.27  jakllsch 	b50->m.offset = buf->m.offset;
   1859       1.22  christos 	/* XXX: Handle userptr */
   1860       1.27  jakllsch 	b50->length = buf->length;
   1861       1.27  jakllsch 	b50->input = buf->input;
   1862       1.27  jakllsch 	b50->reserved = buf->reserved;
   1863       1.22  christos }
   1864       1.27  jakllsch #endif
   1865       1.22  christos 
   1866        1.1  jmcneill int
   1867        1.1  jmcneill videoioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
   1868        1.1  jmcneill {
   1869        1.1  jmcneill 	struct video_softc *sc;
   1870        1.1  jmcneill 	const struct video_hw_if *hw;
   1871        1.1  jmcneill 	struct v4l2_capability *cap;
   1872        1.1  jmcneill 	struct v4l2_fmtdesc *fmtdesc;
   1873        1.1  jmcneill 	struct v4l2_format *fmt;
   1874        1.1  jmcneill 	struct v4l2_standard *std;
   1875        1.1  jmcneill 	struct v4l2_input *input;
   1876       1.24  jmcneill 	struct v4l2_audio *audio;
   1877       1.24  jmcneill 	struct v4l2_tuner *tuner;
   1878       1.24  jmcneill 	struct v4l2_frequency *freq;
   1879        1.1  jmcneill 	struct v4l2_control *control;
   1880        1.1  jmcneill 	struct v4l2_queryctrl *query;
   1881        1.1  jmcneill 	struct v4l2_requestbuffers *reqbufs;
   1882       1.27  jakllsch 	struct v4l2_buffer *buf;
   1883        1.1  jmcneill 	v4l2_std_id *stdid;
   1884        1.1  jmcneill 	enum v4l2_buf_type *typep;
   1885       1.27  jakllsch 	int *ip;
   1886  1.32.18.1  pgoyette 	int error;
   1887       1.27  jakllsch #ifndef _LP64
   1888       1.27  jakllsch 	struct v4l2_buffer bufspace;
   1889       1.27  jakllsch #endif
   1890        1.1  jmcneill 
   1891  1.32.18.1  pgoyette 	sc = device_private(device_lookup_acquire(&video_cd, VIDEOUNIT(dev)));
   1892        1.1  jmcneill 
   1893  1.32.18.1  pgoyette 	if (sc->sc_dying) {
   1894  1.32.18.1  pgoyette 		device_release(sc->sc_dev);
   1895        1.1  jmcneill 		return EIO;
   1896  1.32.18.1  pgoyette 	}
   1897        1.1  jmcneill 
   1898        1.1  jmcneill 	hw = sc->hw_if;
   1899  1.32.18.1  pgoyette 	if (hw == NULL) {
   1900  1.32.18.1  pgoyette 		device_release(sc->sc_dev);
   1901        1.1  jmcneill 		return ENXIO;
   1902  1.32.18.1  pgoyette 	}
   1903        1.1  jmcneill 
   1904        1.1  jmcneill 	switch (cmd) {
   1905        1.1  jmcneill 	case VIDIOC_QUERYCAP:
   1906        1.1  jmcneill 		cap = data;
   1907        1.1  jmcneill 		memset(cap, 0, sizeof(*cap));
   1908       1.25  jmcneill 		strlcpy(cap->driver,
   1909       1.25  jmcneill 			device_cfdriver(sc->hw_dev)->cd_name,
   1910        1.1  jmcneill 			sizeof(cap->driver));
   1911        1.1  jmcneill 		strlcpy(cap->card, hw->get_devname(sc->hw_softc),
   1912        1.1  jmcneill 			sizeof(cap->card));
   1913       1.25  jmcneill 		strlcpy(cap->bus_info, hw->get_businfo(sc->hw_softc),
   1914       1.25  jmcneill 			sizeof(cap->bus_info));
   1915        1.1  jmcneill 		cap->version = VIDEO_DRIVER_VERSION;
   1916        1.1  jmcneill 		cap->capabilities = 0;
   1917        1.1  jmcneill 		if (hw->start_transfer != NULL && hw->stop_transfer != NULL)
   1918        1.1  jmcneill 			cap->capabilities |= V4L2_CAP_VIDEO_CAPTURE |
   1919        1.1  jmcneill 			    V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
   1920       1.24  jmcneill 		if (hw->set_tuner != NULL && hw->get_tuner != NULL)
   1921       1.24  jmcneill 			cap->capabilities |= V4L2_CAP_TUNER;
   1922       1.24  jmcneill 		if (hw->set_audio != NULL && hw->get_audio != NULL &&
   1923       1.24  jmcneill 		    hw->enum_audio != NULL)
   1924       1.24  jmcneill 			cap->capabilities |= V4L2_CAP_AUDIO;
   1925  1.32.18.1  pgoyette 		break;
   1926        1.1  jmcneill 	case VIDIOC_ENUM_FMT:
   1927        1.1  jmcneill 		/* TODO: for now, just enumerate one default format */
   1928        1.1  jmcneill 		fmtdesc = data;
   1929        1.1  jmcneill 		if (fmtdesc->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
   1930  1.32.18.1  pgoyette 			error = EINVAL;
   1931  1.32.18.1  pgoyette 		else
   1932  1.32.18.1  pgoyette 			error = video_enum_format(sc, fmtdesc);
   1933  1.32.18.1  pgoyette 		break;
   1934        1.1  jmcneill 	case VIDIOC_G_FMT:
   1935        1.1  jmcneill 		fmt = data;
   1936  1.32.18.1  pgoyette 		error = video_get_format(sc, fmt);
   1937  1.32.18.1  pgoyette 		break;
   1938        1.1  jmcneill 	case VIDIOC_S_FMT:
   1939        1.1  jmcneill 		fmt = data;
   1940        1.1  jmcneill 		if ((flag & FWRITE) == 0)
   1941  1.32.18.1  pgoyette 			error = EPERM;
   1942  1.32.18.1  pgoyette 		else
   1943  1.32.18.1  pgoyette 			error = video_set_format(sc, fmt);
   1944  1.32.18.1  pgoyette 		break;
   1945        1.1  jmcneill 	case VIDIOC_TRY_FMT:
   1946        1.1  jmcneill 		fmt = data;
   1947  1.32.18.1  pgoyette 		error = video_try_format(sc, fmt);
   1948  1.32.18.1  pgoyette 		break;
   1949        1.1  jmcneill 	case VIDIOC_ENUMSTD:
   1950        1.1  jmcneill 		std = data;
   1951  1.32.18.1  pgoyette 		error = video_enum_standard(sc, std);
   1952  1.32.18.1  pgoyette 		break;
   1953        1.1  jmcneill 	case VIDIOC_G_STD:
   1954        1.1  jmcneill 		stdid = data;
   1955  1.32.18.1  pgoyette 		error = video_get_standard(sc, stdid);
   1956  1.32.18.1  pgoyette 		break;
   1957        1.1  jmcneill 	case VIDIOC_S_STD:
   1958        1.1  jmcneill 		stdid = data;
   1959       1.24  jmcneill 		if ((flag & FWRITE) == 0)
   1960  1.32.18.1  pgoyette 			error = EPERM;
   1961  1.32.18.1  pgoyette 		else
   1962  1.32.18.1  pgoyette 			error = video_set_standard(sc, *stdid);
   1963  1.32.18.1  pgoyette 		break;
   1964        1.1  jmcneill 	case VIDIOC_ENUMINPUT:
   1965        1.1  jmcneill 		input = data;
   1966  1.32.18.1  pgoyette 		error = video_enum_input(sc, input);
   1967  1.32.18.1  pgoyette 		break;
   1968        1.1  jmcneill 	case VIDIOC_G_INPUT:
   1969        1.1  jmcneill 		ip = data;
   1970  1.32.18.1  pgoyette 		error = video_get_input(sc, ip);
   1971  1.32.18.1  pgoyette 		break;
   1972        1.1  jmcneill 	case VIDIOC_S_INPUT:
   1973        1.1  jmcneill 		ip = data;
   1974       1.24  jmcneill 		if ((flag & FWRITE) == 0)
   1975  1.32.18.1  pgoyette 			error = EPERM;
   1976  1.32.18.1  pgoyette 		else
   1977  1.32.18.1  pgoyette 			error = video_set_input(sc, *ip);
   1978  1.32.18.1  pgoyette 		break;
   1979       1.24  jmcneill 	case VIDIOC_ENUMAUDIO:
   1980       1.24  jmcneill 		audio = data;
   1981  1.32.18.1  pgoyette 		error = video_enum_audio(sc, audio);
   1982  1.32.18.1  pgoyette 		break;
   1983       1.24  jmcneill 	case VIDIOC_G_AUDIO:
   1984       1.24  jmcneill 		audio = data;
   1985  1.32.18.1  pgoyette 		error = video_get_audio(sc, audio);
   1986  1.32.18.1  pgoyette 		break;
   1987       1.24  jmcneill 	case VIDIOC_S_AUDIO:
   1988       1.24  jmcneill 		audio = data;
   1989       1.24  jmcneill 		if ((flag & FWRITE) == 0)
   1990  1.32.18.1  pgoyette 			error = EPERM;
   1991  1.32.18.1  pgoyette 		else
   1992  1.32.18.1  pgoyette 			error = video_set_audio(sc, audio);
   1993  1.32.18.1  pgoyette 		break;
   1994       1.24  jmcneill 	case VIDIOC_G_TUNER:
   1995       1.24  jmcneill 		tuner = data;
   1996  1.32.18.1  pgoyette 		error = video_get_tuner(sc, tuner);
   1997  1.32.18.1  pgoyette 		break;
   1998       1.24  jmcneill 	case VIDIOC_S_TUNER:
   1999       1.24  jmcneill 		tuner = data;
   2000       1.24  jmcneill 		if ((flag & FWRITE) == 0)
   2001  1.32.18.1  pgoyette 			error = EPERM;
   2002  1.32.18.1  pgoyette 		else
   2003  1.32.18.1  pgoyette 			error = video_set_tuner(sc, tuner);
   2004  1.32.18.1  pgoyette 		break;
   2005       1.24  jmcneill 	case VIDIOC_G_FREQUENCY:
   2006       1.24  jmcneill 		freq = data;
   2007  1.32.18.1  pgoyette 		error = video_get_frequency(sc, freq);
   2008  1.32.18.1  pgoyette 		break;
   2009       1.24  jmcneill 	case VIDIOC_S_FREQUENCY:
   2010       1.24  jmcneill 		freq = data;
   2011       1.24  jmcneill 		if ((flag & FWRITE) == 0)
   2012  1.32.18.1  pgoyette 			error = EPERM;
   2013  1.32.18.1  pgoyette 		else
   2014  1.32.18.1  pgoyette 			error = video_set_frequency(sc, freq);
   2015  1.32.18.1  pgoyette 		break;
   2016        1.1  jmcneill 	case VIDIOC_QUERYCTRL:
   2017        1.1  jmcneill 		query = data;
   2018  1.32.18.1  pgoyette 		error = (video_query_control(sc, query));
   2019  1.32.18.1  pgoyette 		break;
   2020        1.1  jmcneill 	case VIDIOC_G_CTRL:
   2021        1.1  jmcneill 		control = data;
   2022  1.32.18.1  pgoyette 		error = (video_get_control(sc, control));
   2023  1.32.18.1  pgoyette 		break;
   2024        1.1  jmcneill 	case VIDIOC_S_CTRL:
   2025        1.1  jmcneill 		control = data;
   2026        1.1  jmcneill 		if ((flag & FWRITE) == 0)
   2027  1.32.18.1  pgoyette 			error = EPERM;
   2028  1.32.18.1  pgoyette 		else
   2029  1.32.18.1  pgoyette 			error = (video_set_control(sc, control));
   2030  1.32.18.1  pgoyette 		break;
   2031        1.1  jmcneill 	case VIDIOC_REQBUFS:
   2032        1.1  jmcneill 		reqbufs = data;
   2033  1.32.18.1  pgoyette 		error = (video_request_bufs(sc, reqbufs));
   2034  1.32.18.1  pgoyette 		break;
   2035        1.1  jmcneill 	case VIDIOC_QUERYBUF:
   2036        1.1  jmcneill 		buf = data;
   2037  1.32.18.1  pgoyette 		error = video_query_buf(sc, buf);
   2038  1.32.18.1  pgoyette 		break;
   2039       1.27  jakllsch #ifndef _LP64
   2040       1.27  jakllsch 	case VIDIOC_QUERYBUF50:
   2041       1.27  jakllsch 		buf50tobuf(data, buf = &bufspace);
   2042  1.32.18.1  pgoyette 		if ((error = video_query_buf(sc, buf)) == 0)
   2043  1.32.18.1  pgoyette 			buftobuf50(data, buf);
   2044  1.32.18.1  pgoyette 		break;
   2045       1.27  jakllsch #endif
   2046        1.1  jmcneill 	case VIDIOC_QBUF:
   2047        1.1  jmcneill 		buf = data;
   2048  1.32.18.1  pgoyette 		error = video_queue_buf(sc, buf);
   2049  1.32.18.1  pgoyette 		break;
   2050       1.27  jakllsch #ifndef _LP64
   2051       1.27  jakllsch 	case VIDIOC_QBUF50:
   2052       1.27  jakllsch 		buf50tobuf(data, buf = &bufspace);
   2053  1.32.18.1  pgoyette 		error = video_queue_buf(sc, buf);
   2054  1.32.18.1  pgoyette 		break;
   2055       1.27  jakllsch #endif
   2056        1.1  jmcneill 	case VIDIOC_DQBUF:
   2057        1.1  jmcneill 		buf = data;
   2058  1.32.18.1  pgoyette 		error = video_dequeue_buf(sc, buf);
   2059  1.32.18.1  pgoyette 		break;
   2060       1.27  jakllsch #ifndef _LP64
   2061       1.27  jakllsch 	case VIDIOC_DQBUF50:
   2062       1.27  jakllsch 		buf50tobuf(data, buf = &bufspace);
   2063  1.32.18.1  pgoyette 		if ((error = video_dequeue_buf(sc, buf)) == 0)
   2064  1.32.18.1  pgoyette 			buftobuf50(data, buf);
   2065  1.32.18.1  pgoyette 		break;
   2066       1.27  jakllsch #endif
   2067        1.1  jmcneill 	case VIDIOC_STREAMON:
   2068        1.1  jmcneill 		typep = data;
   2069  1.32.18.1  pgoyette 		error = video_stream_on(sc, *typep);
   2070  1.32.18.1  pgoyette 		break;
   2071        1.1  jmcneill 	case VIDIOC_STREAMOFF:
   2072        1.1  jmcneill 		typep = data;
   2073  1.32.18.1  pgoyette 		error = video_stream_off(sc, *typep);
   2074  1.32.18.1  pgoyette 		break;
   2075        1.1  jmcneill 	default:
   2076        1.1  jmcneill 		DPRINTF(("videoioctl: invalid cmd %s (%lx)\n",
   2077        1.1  jmcneill 			 video_ioctl_str(cmd), cmd));
   2078  1.32.18.1  pgoyette 		error = EINVAL;
   2079  1.32.18.1  pgoyette 		break;
   2080        1.1  jmcneill 	}
   2081  1.32.18.1  pgoyette 	device_release(sc->sc_dev);
   2082  1.32.18.1  pgoyette 	return error;
   2083        1.1  jmcneill }
   2084        1.1  jmcneill 
   2085        1.1  jmcneill #ifdef VIDEO_DEBUG
   2086        1.1  jmcneill static const char *
   2087        1.1  jmcneill video_ioctl_str(u_long cmd)
   2088        1.1  jmcneill {
   2089        1.1  jmcneill 	const char *str;
   2090        1.1  jmcneill 
   2091        1.1  jmcneill 	switch (cmd) {
   2092        1.1  jmcneill 	case VIDIOC_QUERYCAP:
   2093        1.1  jmcneill 		str = "VIDIOC_QUERYCAP";
   2094        1.1  jmcneill 		break;
   2095        1.1  jmcneill 	case VIDIOC_RESERVED:
   2096        1.1  jmcneill 		str = "VIDIOC_RESERVED";
   2097        1.1  jmcneill 		break;
   2098        1.1  jmcneill 	case VIDIOC_ENUM_FMT:
   2099        1.1  jmcneill 		str = "VIDIOC_ENUM_FMT";
   2100        1.1  jmcneill 		break;
   2101        1.1  jmcneill 	case VIDIOC_G_FMT:
   2102        1.1  jmcneill 		str = "VIDIOC_G_FMT";
   2103        1.1  jmcneill 		break;
   2104        1.1  jmcneill 	case VIDIOC_S_FMT:
   2105        1.1  jmcneill 		str = "VIDIOC_S_FMT";
   2106        1.1  jmcneill 		break;
   2107        1.1  jmcneill /* 6 and 7 are VIDIOC_[SG]_COMP, which are unsupported */
   2108        1.1  jmcneill 	case VIDIOC_REQBUFS:
   2109        1.1  jmcneill 		str = "VIDIOC_REQBUFS";
   2110        1.1  jmcneill 		break;
   2111        1.1  jmcneill 	case VIDIOC_QUERYBUF:
   2112        1.1  jmcneill 		str = "VIDIOC_QUERYBUF";
   2113        1.1  jmcneill 		break;
   2114       1.27  jakllsch #ifndef _LP64
   2115       1.27  jakllsch 	case VIDIOC_QUERYBUF50:
   2116       1.27  jakllsch 		str = "VIDIOC_QUERYBUF50";
   2117       1.22  christos 		break;
   2118       1.27  jakllsch #endif
   2119        1.1  jmcneill 	case VIDIOC_G_FBUF:
   2120        1.1  jmcneill 		str = "VIDIOC_G_FBUF";
   2121        1.1  jmcneill 		break;
   2122        1.1  jmcneill 	case VIDIOC_S_FBUF:
   2123        1.1  jmcneill 		str = "VIDIOC_S_FBUF";
   2124        1.1  jmcneill 		break;
   2125        1.1  jmcneill 	case VIDIOC_OVERLAY:
   2126        1.1  jmcneill 		str = "VIDIOC_OVERLAY";
   2127        1.1  jmcneill 		break;
   2128        1.1  jmcneill 	case VIDIOC_QBUF:
   2129        1.1  jmcneill 		str = "VIDIOC_QBUF";
   2130        1.1  jmcneill 		break;
   2131       1.27  jakllsch #ifndef _LP64
   2132       1.27  jakllsch 	case VIDIOC_QBUF50:
   2133       1.27  jakllsch 		str = "VIDIOC_QBUF50";
   2134       1.22  christos 		break;
   2135       1.27  jakllsch #endif
   2136        1.1  jmcneill 	case VIDIOC_DQBUF:
   2137        1.1  jmcneill 		str = "VIDIOC_DQBUF";
   2138        1.1  jmcneill 		break;
   2139       1.27  jakllsch #ifndef _LP64
   2140       1.27  jakllsch 	case VIDIOC_DQBUF50:
   2141       1.27  jakllsch 		str = "VIDIOC_DQBUF50";
   2142       1.22  christos 		break;
   2143       1.27  jakllsch #endif
   2144        1.1  jmcneill 	case VIDIOC_STREAMON:
   2145        1.1  jmcneill 		str = "VIDIOC_STREAMON";
   2146        1.1  jmcneill 		break;
   2147        1.1  jmcneill 	case VIDIOC_STREAMOFF:
   2148        1.1  jmcneill 		str = "VIDIOC_STREAMOFF";
   2149        1.1  jmcneill 		break;
   2150        1.1  jmcneill 	case VIDIOC_G_PARM:
   2151        1.1  jmcneill 		str = "VIDIOC_G_PARAM";
   2152        1.1  jmcneill 		break;
   2153        1.1  jmcneill 	case VIDIOC_S_PARM:
   2154        1.1  jmcneill 		str = "VIDIOC_S_PARAM";
   2155        1.1  jmcneill 		break;
   2156        1.1  jmcneill 	case VIDIOC_G_STD:
   2157        1.1  jmcneill 		str = "VIDIOC_G_STD";
   2158        1.1  jmcneill 		break;
   2159        1.1  jmcneill 	case VIDIOC_S_STD:
   2160        1.1  jmcneill 		str = "VIDIOC_S_STD";
   2161        1.1  jmcneill 		break;
   2162        1.1  jmcneill 	case VIDIOC_ENUMSTD:
   2163        1.1  jmcneill 		str = "VIDIOC_ENUMSTD";
   2164        1.1  jmcneill 		break;
   2165        1.1  jmcneill 	case VIDIOC_ENUMINPUT:
   2166        1.1  jmcneill 		str = "VIDIOC_ENUMINPUT";
   2167        1.1  jmcneill 		break;
   2168        1.1  jmcneill 	case VIDIOC_G_CTRL:
   2169        1.1  jmcneill 		str = "VIDIOC_G_CTRL";
   2170        1.1  jmcneill 		break;
   2171        1.1  jmcneill 	case VIDIOC_S_CTRL:
   2172        1.1  jmcneill 		str = "VIDIOC_S_CTRL";
   2173        1.1  jmcneill 		break;
   2174        1.1  jmcneill 	case VIDIOC_G_TUNER:
   2175        1.1  jmcneill 		str = "VIDIOC_G_TUNER";
   2176        1.1  jmcneill 		break;
   2177        1.1  jmcneill 	case VIDIOC_S_TUNER:
   2178        1.1  jmcneill 		str = "VIDIOC_S_TUNER";
   2179        1.1  jmcneill 		break;
   2180        1.1  jmcneill 	case VIDIOC_G_AUDIO:
   2181        1.1  jmcneill 		str = "VIDIOC_G_AUDIO";
   2182        1.1  jmcneill 		break;
   2183        1.1  jmcneill 	case VIDIOC_S_AUDIO:
   2184        1.1  jmcneill 		str = "VIDIOC_S_AUDIO";
   2185        1.1  jmcneill 		break;
   2186        1.1  jmcneill 	case VIDIOC_QUERYCTRL:
   2187        1.1  jmcneill 		str = "VIDIOC_QUERYCTRL";
   2188        1.1  jmcneill 		break;
   2189        1.1  jmcneill 	case VIDIOC_QUERYMENU:
   2190        1.1  jmcneill 		str = "VIDIOC_QUERYMENU";
   2191        1.1  jmcneill 		break;
   2192        1.1  jmcneill 	case VIDIOC_G_INPUT:
   2193        1.1  jmcneill 		str = "VIDIOC_G_INPUT";
   2194        1.1  jmcneill 		break;
   2195        1.1  jmcneill 	case VIDIOC_S_INPUT:
   2196        1.1  jmcneill 		str = "VIDIOC_S_INPUT";
   2197        1.1  jmcneill 		break;
   2198        1.1  jmcneill 	case VIDIOC_G_OUTPUT:
   2199        1.1  jmcneill 		str = "VIDIOC_G_OUTPUT";
   2200        1.1  jmcneill 		break;
   2201        1.1  jmcneill 	case VIDIOC_S_OUTPUT:
   2202        1.1  jmcneill 		str = "VIDIOC_S_OUTPUT";
   2203        1.1  jmcneill 		break;
   2204        1.1  jmcneill 	case VIDIOC_ENUMOUTPUT:
   2205        1.1  jmcneill 		str = "VIDIOC_ENUMOUTPUT";
   2206        1.1  jmcneill 		break;
   2207        1.1  jmcneill 	case VIDIOC_G_AUDOUT:
   2208        1.1  jmcneill 		str = "VIDIOC_G_AUDOUT";
   2209        1.1  jmcneill 		break;
   2210        1.1  jmcneill 	case VIDIOC_S_AUDOUT:
   2211        1.1  jmcneill 		str = "VIDIOC_S_AUDOUT";
   2212        1.1  jmcneill 		break;
   2213        1.1  jmcneill 	case VIDIOC_G_MODULATOR:
   2214        1.1  jmcneill 		str = "VIDIOC_G_MODULATOR";
   2215        1.1  jmcneill 		break;
   2216        1.1  jmcneill 	case VIDIOC_S_MODULATOR:
   2217        1.1  jmcneill 		str = "VIDIOC_S_MODULATOR";
   2218        1.1  jmcneill 		break;
   2219        1.1  jmcneill 	case VIDIOC_G_FREQUENCY:
   2220        1.1  jmcneill 		str = "VIDIOC_G_FREQUENCY";
   2221        1.1  jmcneill 		break;
   2222        1.1  jmcneill 	case VIDIOC_S_FREQUENCY:
   2223        1.1  jmcneill 		str = "VIDIOC_S_FREQUENCY";
   2224        1.1  jmcneill 		break;
   2225        1.1  jmcneill 	case VIDIOC_CROPCAP:
   2226        1.1  jmcneill 		str = "VIDIOC_CROPCAP";
   2227        1.1  jmcneill 		break;
   2228        1.1  jmcneill 	case VIDIOC_G_CROP:
   2229        1.1  jmcneill 		str = "VIDIOC_G_CROP";
   2230        1.1  jmcneill 		break;
   2231        1.1  jmcneill 	case VIDIOC_S_CROP:
   2232        1.1  jmcneill 		str = "VIDIOC_S_CROP";
   2233        1.1  jmcneill 		break;
   2234        1.1  jmcneill 	case VIDIOC_G_JPEGCOMP:
   2235        1.1  jmcneill 		str = "VIDIOC_G_JPEGCOMP";
   2236        1.1  jmcneill 		break;
   2237        1.1  jmcneill 	case VIDIOC_S_JPEGCOMP:
   2238        1.1  jmcneill 		str = "VIDIOC_S_JPEGCOMP";
   2239        1.1  jmcneill 		break;
   2240        1.1  jmcneill 	case VIDIOC_QUERYSTD:
   2241        1.1  jmcneill 		str = "VIDIOC_QUERYSTD";
   2242        1.1  jmcneill 		break;
   2243        1.1  jmcneill 	case VIDIOC_TRY_FMT:
   2244        1.1  jmcneill 		str = "VIDIOC_TRY_FMT";
   2245        1.1  jmcneill 		break;
   2246        1.1  jmcneill 	case VIDIOC_ENUMAUDIO:
   2247        1.1  jmcneill 		str = "VIDIOC_ENUMAUDIO";
   2248        1.1  jmcneill 		break;
   2249        1.1  jmcneill 	case VIDIOC_ENUMAUDOUT:
   2250        1.1  jmcneill 		str = "VIDIOC_ENUMAUDOUT";
   2251        1.1  jmcneill 		break;
   2252        1.1  jmcneill 	case VIDIOC_G_PRIORITY:
   2253        1.1  jmcneill 		str = "VIDIOC_G_PRIORITY";
   2254        1.1  jmcneill 		break;
   2255        1.1  jmcneill 	case VIDIOC_S_PRIORITY:
   2256        1.1  jmcneill 		str = "VIDIOC_S_PRIORITY";
   2257        1.1  jmcneill 		break;
   2258        1.1  jmcneill 	default:
   2259        1.1  jmcneill 		str = "unknown";
   2260        1.1  jmcneill 		break;
   2261        1.1  jmcneill 	}
   2262        1.1  jmcneill 	return str;
   2263        1.1  jmcneill }
   2264        1.1  jmcneill #endif
   2265        1.1  jmcneill 
   2266        1.1  jmcneill 
   2267        1.1  jmcneill int
   2268        1.1  jmcneill videopoll(dev_t dev, int events, struct lwp *l)
   2269        1.1  jmcneill {
   2270        1.1  jmcneill 	struct video_softc *sc;
   2271        1.1  jmcneill 	struct video_stream *vs;
   2272        1.1  jmcneill 	int err, revents = 0;
   2273        1.1  jmcneill 
   2274  1.32.18.1  pgoyette 	sc = device_private(device_lookup_acquire(&video_cd, VIDEOUNIT(dev)));
   2275        1.1  jmcneill 	vs = &sc->sc_stream_in;
   2276        1.1  jmcneill 
   2277  1.32.18.1  pgoyette 	if (sc->sc_dying) {
   2278  1.32.18.1  pgoyette 		device_release(sc->sc_dev);
   2279        1.1  jmcneill 		return (POLLHUP);
   2280  1.32.18.1  pgoyette 	}
   2281        1.1  jmcneill 
   2282        1.1  jmcneill 	/* userspace has chosen read() method */
   2283        1.1  jmcneill 	if (vs->vs_method == VIDEO_STREAM_METHOD_NONE) {
   2284        1.1  jmcneill 		err = video_stream_setup_bufs(vs,
   2285        1.1  jmcneill 					      VIDEO_STREAM_METHOD_READ,
   2286        1.1  jmcneill 					      VIDEO_NUM_BUFS);
   2287  1.32.18.1  pgoyette 		if (err != 0) {
   2288  1.32.18.1  pgoyette 			device_release(sc->sc_dev);
   2289        1.1  jmcneill 			return POLLERR;
   2290  1.32.18.1  pgoyette 		}
   2291        1.1  jmcneill 		err = video_stream_on(sc, vs->vs_type);
   2292  1.32.18.1  pgoyette 		if (err != 0) {
   2293  1.32.18.1  pgoyette 			device_release(sc->sc_dev);
   2294        1.1  jmcneill 			return POLLERR;
   2295  1.32.18.1  pgoyette 		}
   2296        1.1  jmcneill 	}
   2297        1.1  jmcneill 
   2298       1.19  drochner 	mutex_enter(&vs->vs_lock);
   2299        1.1  jmcneill 	if (!SIMPLEQ_EMPTY(&sc->sc_stream_in.vs_egress))
   2300        1.1  jmcneill 		revents |= events & (POLLIN | POLLRDNORM);
   2301        1.7  jmcneill 	else
   2302        1.7  jmcneill 		selrecord(l, &vs->vs_sel);
   2303       1.19  drochner 	mutex_exit(&vs->vs_lock);
   2304        1.1  jmcneill 
   2305  1.32.18.1  pgoyette 	device_release(sc->sc_dev);
   2306        1.1  jmcneill 	return (revents);
   2307        1.1  jmcneill }
   2308        1.1  jmcneill 
   2309        1.1  jmcneill 
   2310        1.1  jmcneill paddr_t
   2311        1.1  jmcneill videommap(dev_t dev, off_t off, int prot)
   2312        1.1  jmcneill {
   2313        1.1  jmcneill 	struct video_softc *sc;
   2314        1.1  jmcneill 	struct video_stream *vs;
   2315  1.32.18.1  pgoyette 	paddr_t pa;
   2316        1.1  jmcneill 
   2317  1.32.18.1  pgoyette 	sc = device_private(device_lookup_acquire(&video_cd, VIDEOUNIT(dev)));
   2318  1.32.18.1  pgoyette 	if (sc->sc_dying) {
   2319  1.32.18.1  pgoyette 		device_release(sc->sc_dev);
   2320        1.1  jmcneill 		return -1;
   2321  1.32.18.1  pgoyette 	}
   2322        1.1  jmcneill 
   2323        1.1  jmcneill 	vs = &sc->sc_stream_in;
   2324        1.1  jmcneill 
   2325  1.32.18.1  pgoyette 	pa = scatter_buf_map(&vs->vs_data, off);
   2326  1.32.18.1  pgoyette 	device_release(sc->sc_dev);
   2327  1.32.18.1  pgoyette 	return pa;
   2328        1.1  jmcneill }
   2329        1.1  jmcneill 
   2330        1.1  jmcneill 
   2331        1.1  jmcneill /* Allocates buffers and initizlizes some fields.  The format field
   2332        1.1  jmcneill  * must already have been initialized. */
   2333        1.1  jmcneill void
   2334        1.1  jmcneill video_stream_init(struct video_stream *vs)
   2335        1.1  jmcneill {
   2336        1.1  jmcneill 	vs->vs_method = VIDEO_STREAM_METHOD_NONE;
   2337        1.1  jmcneill 	vs->vs_flags = 0;
   2338        1.1  jmcneill 	vs->vs_frameno = -1;
   2339        1.1  jmcneill 	vs->vs_sequence = 0;
   2340        1.1  jmcneill 	vs->vs_type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
   2341        1.1  jmcneill 	vs->vs_nbufs = 0;
   2342        1.1  jmcneill 	vs->vs_buf = NULL;
   2343        1.1  jmcneill 	vs->vs_streaming = false;
   2344        1.1  jmcneill 
   2345        1.1  jmcneill 	memset(&vs->vs_format, 0, sizeof(vs->vs_format));
   2346        1.1  jmcneill 
   2347        1.1  jmcneill 	SIMPLEQ_INIT(&vs->vs_ingress);
   2348        1.1  jmcneill 	SIMPLEQ_INIT(&vs->vs_egress);
   2349        1.1  jmcneill 
   2350        1.1  jmcneill 	mutex_init(&vs->vs_lock, MUTEX_DEFAULT, IPL_NONE);
   2351        1.1  jmcneill 	cv_init(&vs->vs_sample_cv, "video");
   2352        1.7  jmcneill 	selinit(&vs->vs_sel);
   2353        1.1  jmcneill 
   2354        1.1  jmcneill 	scatter_buf_init(&vs->vs_data);
   2355        1.1  jmcneill }
   2356        1.1  jmcneill 
   2357        1.1  jmcneill void
   2358        1.1  jmcneill video_stream_fini(struct video_stream *vs)
   2359        1.1  jmcneill {
   2360        1.1  jmcneill 	/* Sample data in queues has already been freed */
   2361        1.1  jmcneill 	/* while (SIMPLEQ_FIRST(&vs->vs_ingress) != NULL)
   2362        1.1  jmcneill 		SIMPLEQ_REMOVE_HEAD(&vs->vs_ingress, entries);
   2363        1.1  jmcneill 	while (SIMPLEQ_FIRST(&vs->vs_egress) != NULL)
   2364        1.1  jmcneill 	SIMPLEQ_REMOVE_HEAD(&vs->vs_egress, entries); */
   2365        1.1  jmcneill 
   2366        1.1  jmcneill 	mutex_destroy(&vs->vs_lock);
   2367        1.1  jmcneill 	cv_destroy(&vs->vs_sample_cv);
   2368        1.7  jmcneill 	seldestroy(&vs->vs_sel);
   2369        1.1  jmcneill 
   2370        1.1  jmcneill 	scatter_buf_destroy(&vs->vs_data);
   2371        1.1  jmcneill }
   2372        1.1  jmcneill 
   2373        1.1  jmcneill static int
   2374        1.1  jmcneill video_stream_setup_bufs(struct video_stream *vs,
   2375        1.1  jmcneill 			enum video_stream_method method,
   2376        1.1  jmcneill 			uint8_t nbufs)
   2377        1.1  jmcneill {
   2378        1.1  jmcneill 	int i, err;
   2379        1.1  jmcneill 
   2380        1.1  jmcneill 	mutex_enter(&vs->vs_lock);
   2381        1.1  jmcneill 
   2382        1.1  jmcneill 	/* Ensure that all allocated buffers are queued and not under
   2383        1.1  jmcneill 	 * userspace control. */
   2384        1.1  jmcneill 	for (i = 0; i < vs->vs_nbufs; ++i) {
   2385       1.19  drochner 		if (!(vs->vs_buf[i]->vb_buf->flags & V4L2_BUF_FLAG_QUEUED)) {
   2386        1.1  jmcneill 			mutex_exit(&vs->vs_lock);
   2387        1.1  jmcneill 			return EBUSY;
   2388        1.1  jmcneill 		}
   2389        1.1  jmcneill 	}
   2390        1.1  jmcneill 
   2391        1.1  jmcneill 	/* Allocate the buffers */
   2392        1.1  jmcneill 	err = video_stream_realloc_bufs(vs, nbufs);
   2393        1.1  jmcneill 	if (err != 0) {
   2394        1.1  jmcneill 		mutex_exit(&vs->vs_lock);
   2395        1.1  jmcneill 		return err;
   2396        1.1  jmcneill 	}
   2397        1.1  jmcneill 
   2398        1.1  jmcneill 	/* Queue up buffers for read method.  Other methods are queued
   2399        1.1  jmcneill 	 * by VIDIOC_QBUF ioctl. */
   2400        1.1  jmcneill 	if (method == VIDEO_STREAM_METHOD_READ) {
   2401        1.1  jmcneill 		for (i = 0; i < nbufs; ++i)
   2402        1.1  jmcneill 			if (!(vs->vs_buf[i]->vb_buf->flags & V4L2_BUF_FLAG_QUEUED))
   2403        1.1  jmcneill 				video_stream_enqueue(vs, vs->vs_buf[i]);
   2404        1.1  jmcneill 	}
   2405        1.1  jmcneill 
   2406        1.1  jmcneill 	vs->vs_method = method;
   2407        1.1  jmcneill 	mutex_exit(&vs->vs_lock);
   2408        1.1  jmcneill 
   2409        1.1  jmcneill 	return 0;
   2410        1.1  jmcneill }
   2411        1.1  jmcneill 
   2412        1.1  jmcneill /* Free all buffer memory in preparation for close().  This should
   2413        1.1  jmcneill  * free buffers regardless of errors.  Use video_stream_setup_bufs if
   2414        1.1  jmcneill  * you need to check for errors. Streaming should be off before
   2415        1.1  jmcneill  * calling this function. */
   2416        1.1  jmcneill static void
   2417        1.1  jmcneill video_stream_teardown_bufs(struct video_stream *vs)
   2418        1.1  jmcneill {
   2419        1.1  jmcneill 	int err;
   2420        1.1  jmcneill 
   2421        1.1  jmcneill 	mutex_enter(&vs->vs_lock);
   2422        1.1  jmcneill 
   2423        1.2     rmind 	if (vs->vs_streaming) {
   2424        1.1  jmcneill 		DPRINTF(("video_stream_teardown_bufs: "
   2425        1.1  jmcneill 			 "tearing down bufs while streaming\n"));
   2426        1.2     rmind 	}
   2427        1.1  jmcneill 
   2428        1.1  jmcneill 	/* dequeue all buffers */
   2429        1.1  jmcneill 	while (SIMPLEQ_FIRST(&vs->vs_ingress) != NULL)
   2430        1.1  jmcneill 		SIMPLEQ_REMOVE_HEAD(&vs->vs_ingress, entries);
   2431        1.1  jmcneill 	while (SIMPLEQ_FIRST(&vs->vs_egress) != NULL)
   2432        1.1  jmcneill 		SIMPLEQ_REMOVE_HEAD(&vs->vs_egress, entries);
   2433        1.1  jmcneill 
   2434        1.1  jmcneill 	err = video_stream_free_bufs(vs);
   2435        1.2     rmind 	if (err != 0) {
   2436        1.1  jmcneill 		DPRINTF(("video_stream_teardown_bufs: "
   2437        1.1  jmcneill 			 "error releasing buffers: %d\n",
   2438        1.1  jmcneill 			 err));
   2439        1.2     rmind 	}
   2440        1.1  jmcneill 	vs->vs_method = VIDEO_STREAM_METHOD_NONE;
   2441        1.1  jmcneill 
   2442        1.1  jmcneill 	mutex_exit(&vs->vs_lock);
   2443        1.1  jmcneill }
   2444        1.1  jmcneill 
   2445        1.1  jmcneill static struct video_buffer *
   2446        1.1  jmcneill video_buffer_alloc(void)
   2447        1.1  jmcneill {
   2448        1.1  jmcneill 	struct video_buffer *vb;
   2449        1.1  jmcneill 
   2450        1.1  jmcneill 	vb = kmem_alloc(sizeof(*vb), KM_SLEEP);
   2451        1.1  jmcneill 	if (vb == NULL)
   2452        1.1  jmcneill 		return NULL;
   2453        1.1  jmcneill 
   2454        1.1  jmcneill 	vb->vb_buf = kmem_alloc(sizeof(*vb->vb_buf), KM_SLEEP);
   2455        1.1  jmcneill 	if (vb->vb_buf == NULL) {
   2456        1.1  jmcneill 		kmem_free(vb, sizeof(*vb));
   2457        1.1  jmcneill 		return NULL;
   2458        1.1  jmcneill 	}
   2459        1.1  jmcneill 
   2460        1.1  jmcneill 	return vb;
   2461        1.1  jmcneill }
   2462        1.1  jmcneill 
   2463        1.1  jmcneill static void
   2464        1.1  jmcneill video_buffer_free(struct video_buffer *vb)
   2465        1.1  jmcneill {
   2466        1.1  jmcneill 	kmem_free(vb->vb_buf, sizeof(*vb->vb_buf));
   2467        1.1  jmcneill 	vb->vb_buf = NULL;
   2468        1.1  jmcneill 	kmem_free(vb, sizeof(*vb));
   2469        1.1  jmcneill }
   2470        1.1  jmcneill 
   2471        1.1  jmcneill /* TODO: for userptr method
   2472        1.1  jmcneill struct video_buffer *
   2473        1.1  jmcneill video_buf_alloc_with_ubuf(struct v4l2_buffer *buf)
   2474        1.1  jmcneill {
   2475        1.1  jmcneill }
   2476        1.1  jmcneill 
   2477        1.1  jmcneill void
   2478        1.1  jmcneill video_buffer_free_with_ubuf(struct video_buffer *vb)
   2479        1.1  jmcneill {
   2480        1.1  jmcneill }
   2481        1.1  jmcneill */
   2482        1.1  jmcneill 
   2483        1.1  jmcneill static int
   2484        1.1  jmcneill video_stream_realloc_bufs(struct video_stream *vs, uint8_t nbufs)
   2485        1.1  jmcneill {
   2486        1.1  jmcneill 	int i, err;
   2487        1.1  jmcneill 	uint8_t minnbufs, oldnbufs;
   2488        1.1  jmcneill 	size_t size;
   2489        1.1  jmcneill 	off_t offset;
   2490        1.1  jmcneill 	struct video_buffer **oldbuf;
   2491        1.1  jmcneill 	struct v4l2_buffer *buf;
   2492        1.1  jmcneill 
   2493       1.22  christos 	size = PAGE_ALIGN(vs->vs_format.sample_size) * nbufs;
   2494        1.1  jmcneill 	err = scatter_buf_set_size(&vs->vs_data, size);
   2495        1.1  jmcneill 	if (err != 0)
   2496        1.1  jmcneill 		return err;
   2497        1.1  jmcneill 
   2498        1.1  jmcneill 	oldnbufs = vs->vs_nbufs;
   2499        1.1  jmcneill 	oldbuf = vs->vs_buf;
   2500        1.1  jmcneill 
   2501        1.1  jmcneill 	vs->vs_nbufs = nbufs;
   2502        1.1  jmcneill 	if (nbufs > 0) {
   2503        1.1  jmcneill 		vs->vs_buf =
   2504        1.1  jmcneill 		    kmem_alloc(sizeof(struct video_buffer *) * nbufs, KM_SLEEP);
   2505        1.1  jmcneill 		if (vs->vs_buf == NULL) {
   2506        1.1  jmcneill 			vs->vs_nbufs = oldnbufs;
   2507        1.1  jmcneill 			vs->vs_buf = oldbuf;
   2508        1.1  jmcneill 
   2509        1.1  jmcneill 			return ENOMEM;
   2510        1.1  jmcneill 		}
   2511        1.1  jmcneill 	} else {
   2512        1.1  jmcneill 		vs->vs_buf = NULL;
   2513        1.1  jmcneill 	}
   2514        1.1  jmcneill 
   2515        1.1  jmcneill 	minnbufs = min(vs->vs_nbufs, oldnbufs);
   2516        1.1  jmcneill 	/* copy any bufs that will be reused */
   2517        1.1  jmcneill 	for (i = 0; i < minnbufs; ++i)
   2518        1.1  jmcneill 		vs->vs_buf[i] = oldbuf[i];
   2519        1.1  jmcneill 	/* allocate any necessary new bufs */
   2520        1.1  jmcneill 	for (; i < vs->vs_nbufs; ++i)
   2521        1.1  jmcneill 		vs->vs_buf[i] = video_buffer_alloc();
   2522        1.1  jmcneill 	/* free any bufs no longer used */
   2523        1.1  jmcneill 	for (; i < oldnbufs; ++i) {
   2524        1.1  jmcneill 		video_buffer_free(oldbuf[i]);
   2525        1.1  jmcneill 		oldbuf[i] = NULL;
   2526        1.1  jmcneill 	}
   2527        1.1  jmcneill 
   2528        1.1  jmcneill 	/* Free old buffer metadata */
   2529        1.1  jmcneill 	if (oldbuf != NULL)
   2530        1.1  jmcneill 		kmem_free(oldbuf, sizeof(struct video_buffer *) * oldnbufs);
   2531        1.1  jmcneill 
   2532        1.1  jmcneill 	/* initialize bufs */
   2533        1.1  jmcneill 	offset = 0;
   2534        1.1  jmcneill 	for (i = 0; i < vs->vs_nbufs; ++i) {
   2535        1.1  jmcneill 		buf = vs->vs_buf[i]->vb_buf;
   2536        1.1  jmcneill 		buf->index = i;
   2537        1.1  jmcneill 		buf->type = vs->vs_type;
   2538        1.1  jmcneill 		buf->bytesused = 0;
   2539        1.1  jmcneill 		buf->flags = 0;
   2540        1.1  jmcneill 		buf->field = 0;
   2541        1.1  jmcneill 		buf->sequence = 0;
   2542        1.1  jmcneill 		buf->memory = V4L2_MEMORY_MMAP;
   2543        1.1  jmcneill 		buf->m.offset = offset;
   2544       1.22  christos 		buf->length = PAGE_ALIGN(vs->vs_format.sample_size);
   2545        1.1  jmcneill 		buf->input = 0;
   2546        1.1  jmcneill 		buf->reserved = 0;
   2547        1.1  jmcneill 
   2548        1.1  jmcneill 		offset += buf->length;
   2549        1.1  jmcneill 	}
   2550        1.1  jmcneill 
   2551        1.1  jmcneill 	return 0;
   2552        1.1  jmcneill }
   2553        1.1  jmcneill 
   2554        1.1  jmcneill /* Accepts a video_sample into the ingress queue.  Caller must hold
   2555        1.1  jmcneill  * the stream lock. */
   2556        1.1  jmcneill void
   2557        1.1  jmcneill video_stream_enqueue(struct video_stream *vs, struct video_buffer *vb)
   2558        1.1  jmcneill {
   2559        1.1  jmcneill 	if (vb->vb_buf->flags & V4L2_BUF_FLAG_QUEUED) {
   2560        1.1  jmcneill 		DPRINTF(("video_stream_enqueue: sample already queued\n"));
   2561        1.1  jmcneill 		return;
   2562        1.1  jmcneill 	}
   2563        1.1  jmcneill 
   2564        1.1  jmcneill 	vb->vb_buf->flags |= V4L2_BUF_FLAG_QUEUED;
   2565        1.1  jmcneill 	vb->vb_buf->flags &= ~V4L2_BUF_FLAG_DONE;
   2566        1.1  jmcneill 
   2567        1.1  jmcneill 	vb->vb_buf->bytesused = 0;
   2568        1.1  jmcneill 
   2569        1.1  jmcneill 	SIMPLEQ_INSERT_TAIL(&vs->vs_ingress, vb, entries);
   2570        1.1  jmcneill }
   2571        1.1  jmcneill 
   2572        1.1  jmcneill 
   2573        1.1  jmcneill /* Removes the head of the egress queue for use by userspace.  Caller
   2574        1.1  jmcneill  * must hold the stream lock. */
   2575        1.1  jmcneill struct video_buffer *
   2576        1.1  jmcneill video_stream_dequeue(struct video_stream *vs)
   2577        1.1  jmcneill {
   2578        1.1  jmcneill 	struct video_buffer *vb;
   2579        1.1  jmcneill 
   2580        1.1  jmcneill 	if (!SIMPLEQ_EMPTY(&vs->vs_egress)) {
   2581        1.1  jmcneill 		vb = SIMPLEQ_FIRST(&vs->vs_egress);
   2582        1.1  jmcneill 		SIMPLEQ_REMOVE_HEAD(&vs->vs_egress, entries);
   2583        1.1  jmcneill 		vb->vb_buf->flags &= ~V4L2_BUF_FLAG_QUEUED;
   2584        1.1  jmcneill 		vb->vb_buf->flags |= V4L2_BUF_FLAG_DONE;
   2585        1.1  jmcneill 		return vb;
   2586        1.1  jmcneill 	} else {
   2587        1.1  jmcneill 		return NULL;
   2588        1.1  jmcneill 	}
   2589        1.1  jmcneill }
   2590        1.1  jmcneill 
   2591       1.28  drochner static void
   2592       1.28  drochner v4l2buf_set_timestamp(struct v4l2_buffer *buf)
   2593       1.28  drochner {
   2594       1.28  drochner 
   2595       1.28  drochner 	getmicrotime(&buf->timestamp);
   2596       1.28  drochner }
   2597        1.1  jmcneill 
   2598        1.1  jmcneill /*
   2599        1.1  jmcneill  * write payload data to the appropriate video sample, possibly moving
   2600        1.1  jmcneill  * the sample from ingress to egress queues
   2601        1.1  jmcneill  */
   2602        1.1  jmcneill void
   2603        1.1  jmcneill video_stream_write(struct video_stream *vs,
   2604        1.1  jmcneill 		   const struct video_payload *payload)
   2605        1.1  jmcneill {
   2606        1.1  jmcneill 	struct video_buffer *vb;
   2607        1.1  jmcneill 	struct v4l2_buffer *buf;
   2608        1.1  jmcneill 	struct scatter_io sio;
   2609        1.1  jmcneill 
   2610        1.1  jmcneill 	mutex_enter(&vs->vs_lock);
   2611        1.1  jmcneill 
   2612        1.1  jmcneill 	/* change of frameno implies end of current frame */
   2613       1.24  jmcneill 	if (vs->vs_frameno >= 0 && vs->vs_frameno != payload->frameno)
   2614        1.1  jmcneill 		video_stream_sample_done(vs);
   2615       1.24  jmcneill 
   2616       1.24  jmcneill 	vs->vs_frameno = payload->frameno;
   2617        1.1  jmcneill 
   2618        1.1  jmcneill 	if (vs->vs_drop || SIMPLEQ_EMPTY(&vs->vs_ingress)) {
   2619        1.1  jmcneill 		/* DPRINTF(("video_stream_write: dropping sample %d\n",
   2620        1.1  jmcneill 		   vs->vs_sequence)); */
   2621        1.1  jmcneill 		vs->vs_drop = true;
   2622       1.15  jmcneill 	} else if (payload->size > 0) {
   2623        1.1  jmcneill 		vb = SIMPLEQ_FIRST(&vs->vs_ingress);
   2624        1.1  jmcneill 		buf = vb->vb_buf;
   2625       1.28  drochner 		if (!buf->bytesused)
   2626       1.28  drochner 			v4l2buf_set_timestamp(buf);
   2627        1.1  jmcneill 		if (payload->size > buf->length - buf->bytesused) {
   2628        1.1  jmcneill 			DPRINTF(("video_stream_write: "
   2629        1.1  jmcneill 				 "payload would overflow\n"));
   2630        1.1  jmcneill 		} else if (scatter_io_init(&vs->vs_data,
   2631        1.1  jmcneill 					   buf->m.offset + buf->bytesused,
   2632        1.1  jmcneill 					   payload->size,
   2633        1.1  jmcneill 					   &sio))
   2634        1.1  jmcneill 		{
   2635        1.1  jmcneill 			scatter_io_copyin(&sio, payload->data);
   2636        1.1  jmcneill 			buf->bytesused += (payload->size - sio.sio_resid);
   2637        1.1  jmcneill 		} else {
   2638        1.1  jmcneill 			DPRINTF(("video_stream_write: failed to init scatter io "
   2639        1.1  jmcneill 				 "vb=%p buf=%p "
   2640       1.21     njoly 				 "buf->m.offset=%d buf->bytesused=%u "
   2641        1.1  jmcneill 				 "payload->size=%zu\n",
   2642        1.1  jmcneill 				 vb, buf,
   2643        1.1  jmcneill 				 buf->m.offset, buf->bytesused, payload->size));
   2644        1.1  jmcneill 		}
   2645        1.1  jmcneill 	}
   2646        1.1  jmcneill 
   2647        1.1  jmcneill 	/* if the payload marks it, we can do sample_done() early */
   2648        1.1  jmcneill 	if (payload->end_of_frame)
   2649        1.1  jmcneill 		video_stream_sample_done(vs);
   2650        1.1  jmcneill 
   2651        1.1  jmcneill 	mutex_exit(&vs->vs_lock);
   2652        1.1  jmcneill }
   2653        1.1  jmcneill 
   2654        1.1  jmcneill 
   2655        1.1  jmcneill /* Moves the head of the ingress queue to the tail of the egress
   2656        1.1  jmcneill  * queue, or resets drop status if we were dropping this sample.
   2657        1.1  jmcneill  * Caller should hold the stream queue lock. */
   2658        1.1  jmcneill void
   2659        1.1  jmcneill video_stream_sample_done(struct video_stream *vs)
   2660        1.1  jmcneill {
   2661        1.1  jmcneill 	struct video_buffer *vb;
   2662        1.1  jmcneill 
   2663        1.1  jmcneill 	if (vs->vs_drop) {
   2664        1.1  jmcneill 		vs->vs_drop = false;
   2665        1.1  jmcneill 	} else if (!SIMPLEQ_EMPTY(&vs->vs_ingress)) {
   2666        1.1  jmcneill 		vb = SIMPLEQ_FIRST(&vs->vs_ingress);
   2667        1.1  jmcneill 		vb->vb_buf->sequence = vs->vs_sequence;
   2668        1.1  jmcneill 		SIMPLEQ_REMOVE_HEAD(&vs->vs_ingress, entries);
   2669        1.1  jmcneill 
   2670        1.1  jmcneill 		SIMPLEQ_INSERT_TAIL(&vs->vs_egress, vb, entries);
   2671        1.1  jmcneill 		cv_signal(&vs->vs_sample_cv);
   2672        1.7  jmcneill 		selnotify(&vs->vs_sel, 0, 0);
   2673        1.1  jmcneill 	} else {
   2674        1.1  jmcneill 		DPRINTF(("video_stream_sample_done: no sample\n"));
   2675        1.1  jmcneill 	}
   2676        1.1  jmcneill 
   2677        1.1  jmcneill 	vs->vs_frameno ^= 1;
   2678        1.1  jmcneill 	vs->vs_sequence++;
   2679        1.1  jmcneill }
   2680        1.1  jmcneill 
   2681        1.1  jmcneill /* Check if all buffers are queued, i.e. none are under control of
   2682        1.1  jmcneill  * userspace. */
   2683        1.1  jmcneill /*
   2684        1.1  jmcneill static bool
   2685        1.1  jmcneill video_stream_all_queued(struct video_stream *vs)
   2686        1.1  jmcneill {
   2687        1.1  jmcneill }
   2688        1.1  jmcneill */
   2689        1.1  jmcneill 
   2690        1.1  jmcneill 
   2691        1.1  jmcneill static void
   2692        1.1  jmcneill scatter_buf_init(struct scatter_buf *sb)
   2693        1.1  jmcneill {
   2694        1.1  jmcneill 	sb->sb_pool = pool_cache_init(PAGE_SIZE, 0, 0, 0,
   2695        1.1  jmcneill 				      "video", NULL, IPL_VIDEO,
   2696        1.1  jmcneill 				      NULL, NULL, NULL);
   2697        1.1  jmcneill 	sb->sb_size = 0;
   2698        1.1  jmcneill 	sb->sb_npages = 0;
   2699        1.1  jmcneill 	sb->sb_page_ary = NULL;
   2700        1.1  jmcneill }
   2701        1.1  jmcneill 
   2702        1.1  jmcneill static void
   2703        1.1  jmcneill scatter_buf_destroy(struct scatter_buf *sb)
   2704        1.1  jmcneill {
   2705        1.1  jmcneill 	/* Do we need to return everything to the pool first? */
   2706        1.1  jmcneill 	scatter_buf_set_size(sb, 0);
   2707        1.1  jmcneill 	pool_cache_destroy(sb->sb_pool);
   2708        1.1  jmcneill 	sb->sb_pool = 0;
   2709        1.1  jmcneill 	sb->sb_npages = 0;
   2710        1.1  jmcneill 	sb->sb_page_ary = NULL;
   2711        1.1  jmcneill }
   2712        1.1  jmcneill 
   2713        1.1  jmcneill /* Increase or decrease the size of the buffer */
   2714        1.1  jmcneill static int
   2715        1.1  jmcneill scatter_buf_set_size(struct scatter_buf *sb, size_t sz)
   2716        1.1  jmcneill {
   2717        1.1  jmcneill 	int i;
   2718        1.1  jmcneill 	size_t npages, minpages, oldnpages;
   2719        1.1  jmcneill 	uint8_t **old_ary;
   2720        1.1  jmcneill 
   2721        1.1  jmcneill 	npages = (sz >> PAGE_SHIFT) + ((sz & PAGE_MASK) > 0);
   2722        1.1  jmcneill 
   2723        1.1  jmcneill 	if (sb->sb_npages == npages) {
   2724        1.1  jmcneill 		return 0;
   2725        1.1  jmcneill 	}
   2726        1.1  jmcneill 
   2727        1.1  jmcneill 	oldnpages = sb->sb_npages;
   2728        1.1  jmcneill 	old_ary = sb->sb_page_ary;
   2729        1.1  jmcneill 
   2730        1.1  jmcneill 	sb->sb_npages = npages;
   2731        1.1  jmcneill 	if (npages > 0) {
   2732        1.1  jmcneill 		sb->sb_page_ary =
   2733        1.1  jmcneill 		    kmem_alloc(sizeof(uint8_t *) * npages, KM_SLEEP);
   2734        1.1  jmcneill 		if (sb->sb_page_ary == NULL) {
   2735        1.1  jmcneill 			sb->sb_npages = oldnpages;
   2736        1.1  jmcneill 			sb->sb_page_ary = old_ary;
   2737        1.1  jmcneill 			return ENOMEM;
   2738        1.1  jmcneill 		}
   2739        1.1  jmcneill 	} else {
   2740        1.1  jmcneill 		sb->sb_page_ary = NULL;
   2741        1.1  jmcneill 	}
   2742        1.1  jmcneill 
   2743        1.1  jmcneill 	minpages = min(npages, oldnpages);
   2744        1.1  jmcneill 	/* copy any pages that will be reused */
   2745        1.1  jmcneill 	for (i = 0; i < minpages; ++i)
   2746        1.1  jmcneill 		sb->sb_page_ary[i] = old_ary[i];
   2747        1.1  jmcneill 	/* allocate any new pages */
   2748        1.1  jmcneill 	for (; i < npages; ++i) {
   2749        1.1  jmcneill 		sb->sb_page_ary[i] = pool_cache_get(sb->sb_pool, 0);
   2750        1.1  jmcneill 		/* TODO: does pool_cache_get return NULL on
   2751        1.1  jmcneill 		 * ENOMEM?  If so, we need to release or note
   2752        1.1  jmcneill 		 * the pages with did allocate
   2753        1.1  jmcneill 		 * successfully. */
   2754        1.1  jmcneill 		if (sb->sb_page_ary[i] == NULL) {
   2755        1.1  jmcneill 			DPRINTF(("video: pool_cache_get ENOMEM\n"));
   2756        1.1  jmcneill 			return ENOMEM;
   2757        1.1  jmcneill 		}
   2758        1.1  jmcneill 	}
   2759        1.1  jmcneill 	/* return any pages no longer needed */
   2760        1.1  jmcneill 	for (; i < oldnpages; ++i)
   2761        1.1  jmcneill 		pool_cache_put(sb->sb_pool, old_ary[i]);
   2762        1.1  jmcneill 
   2763        1.1  jmcneill 	if (old_ary != NULL)
   2764        1.1  jmcneill 		kmem_free(old_ary, sizeof(uint8_t *) * oldnpages);
   2765        1.1  jmcneill 
   2766        1.1  jmcneill 	sb->sb_size = sb->sb_npages << PAGE_SHIFT;
   2767        1.1  jmcneill 
   2768        1.1  jmcneill 	return 0;
   2769        1.1  jmcneill }
   2770        1.1  jmcneill 
   2771        1.1  jmcneill 
   2772        1.1  jmcneill static paddr_t
   2773        1.1  jmcneill scatter_buf_map(struct scatter_buf *sb, off_t off)
   2774        1.1  jmcneill {
   2775        1.1  jmcneill 	size_t pg;
   2776        1.1  jmcneill 	paddr_t pa;
   2777        1.1  jmcneill 
   2778        1.1  jmcneill 	pg = off >> PAGE_SHIFT;
   2779        1.1  jmcneill 
   2780        1.1  jmcneill 	if (pg >= sb->sb_npages)
   2781        1.1  jmcneill 		return -1;
   2782        1.1  jmcneill 	else if (!pmap_extract(pmap_kernel(), (vaddr_t)sb->sb_page_ary[pg], &pa))
   2783        1.1  jmcneill 		return -1;
   2784        1.1  jmcneill 
   2785        1.1  jmcneill 	return atop(pa);
   2786        1.1  jmcneill }
   2787        1.1  jmcneill 
   2788        1.1  jmcneill /* Initialize data for an io operation on a scatter buffer. Returns
   2789        1.1  jmcneill  * true if the transfer is valid, or false if out of range. */
   2790        1.1  jmcneill static bool
   2791        1.1  jmcneill scatter_io_init(struct scatter_buf *sb,
   2792        1.1  jmcneill 		    off_t off, size_t len,
   2793        1.1  jmcneill 		    struct scatter_io *sio)
   2794        1.1  jmcneill {
   2795        1.1  jmcneill 	if ((off + len) > sb->sb_size) {
   2796        1.1  jmcneill 		DPRINTF(("video: scatter_io_init failed: off=%" PRId64
   2797        1.1  jmcneill 			 " len=%zu sb->sb_size=%zu\n",
   2798        1.1  jmcneill 			 off, len, sb->sb_size));
   2799        1.1  jmcneill 		return false;
   2800        1.1  jmcneill 	}
   2801        1.1  jmcneill 
   2802        1.1  jmcneill 	sio->sio_buf = sb;
   2803        1.1  jmcneill 	sio->sio_offset = off;
   2804        1.1  jmcneill 	sio->sio_resid = len;
   2805        1.1  jmcneill 
   2806        1.1  jmcneill 	return true;
   2807        1.1  jmcneill }
   2808        1.1  jmcneill 
   2809        1.1  jmcneill /* Store the pointer and size of the next contiguous segment.  Returns
   2810        1.1  jmcneill  * true if the segment is valid, or false if all has been transfered.
   2811        1.1  jmcneill  * Does not check for overflow. */
   2812        1.1  jmcneill static bool
   2813        1.1  jmcneill scatter_io_next(struct scatter_io *sio, void **p, size_t *sz)
   2814        1.1  jmcneill {
   2815        1.1  jmcneill 	size_t pg, pgo;
   2816        1.1  jmcneill 
   2817        1.1  jmcneill 	if (sio->sio_resid == 0)
   2818        1.1  jmcneill 		return false;
   2819        1.1  jmcneill 
   2820        1.1  jmcneill 	pg = sio->sio_offset >> PAGE_SHIFT;
   2821        1.1  jmcneill 	pgo = sio->sio_offset & PAGE_MASK;
   2822        1.1  jmcneill 
   2823        1.1  jmcneill 	*sz = min(PAGE_SIZE - pgo, sio->sio_resid);
   2824        1.1  jmcneill 	*p = sio->sio_buf->sb_page_ary[pg] + pgo;
   2825        1.1  jmcneill 
   2826        1.1  jmcneill 	sio->sio_offset += *sz;
   2827        1.1  jmcneill 	sio->sio_resid -= *sz;
   2828        1.1  jmcneill 
   2829        1.1  jmcneill 	return true;
   2830        1.1  jmcneill }
   2831        1.1  jmcneill 
   2832        1.1  jmcneill /* Semi-undo of a failed segment copy.  Updates the scatter_io
   2833        1.1  jmcneill  * struct to the previous values prior to a failed segment copy. */
   2834        1.1  jmcneill static void
   2835        1.1  jmcneill scatter_io_undo(struct scatter_io *sio, size_t sz)
   2836        1.1  jmcneill {
   2837        1.1  jmcneill 	sio->sio_offset -= sz;
   2838        1.1  jmcneill 	sio->sio_resid += sz;
   2839        1.1  jmcneill }
   2840        1.1  jmcneill 
   2841        1.1  jmcneill /* Copy data from src into the scatter_buf as described by io. */
   2842        1.1  jmcneill static void
   2843        1.1  jmcneill scatter_io_copyin(struct scatter_io *sio, const void *p)
   2844        1.1  jmcneill {
   2845        1.1  jmcneill 	void *dst;
   2846        1.1  jmcneill 	const uint8_t *src = p;
   2847        1.1  jmcneill 	size_t sz;
   2848        1.1  jmcneill 
   2849        1.1  jmcneill 	while(scatter_io_next(sio, &dst, &sz)) {
   2850        1.1  jmcneill 		memcpy(dst, src, sz);
   2851        1.1  jmcneill 		src += sz;
   2852        1.1  jmcneill 	}
   2853        1.1  jmcneill }
   2854        1.1  jmcneill 
   2855        1.1  jmcneill /* --not used; commented to avoid compiler warnings--
   2856        1.1  jmcneill static void
   2857        1.1  jmcneill scatter_io_copyout(struct scatter_io *sio, void *p)
   2858        1.1  jmcneill {
   2859        1.1  jmcneill 	void *src;
   2860        1.1  jmcneill 	uint8_t *dst = p;
   2861        1.1  jmcneill 	size_t sz;
   2862        1.1  jmcneill 
   2863        1.1  jmcneill 	while(scatter_io_next(sio, &src, &sz)) {
   2864        1.1  jmcneill 		memcpy(dst, src, sz);
   2865        1.1  jmcneill 		dst += sz;
   2866        1.1  jmcneill 	}
   2867        1.1  jmcneill }
   2868        1.1  jmcneill */
   2869        1.1  jmcneill 
   2870        1.1  jmcneill /* Performat a series of uiomove calls on a scatter buf.  Returns
   2871        1.1  jmcneill  * EFAULT if uiomove EFAULTs on the first segment.  Otherwise, returns
   2872        1.1  jmcneill  * an incomplete transfer but with no error. */
   2873        1.1  jmcneill static int
   2874        1.1  jmcneill scatter_io_uiomove(struct scatter_io *sio, struct uio *uio)
   2875        1.1  jmcneill {
   2876        1.1  jmcneill 	void *p;
   2877        1.1  jmcneill 	size_t sz;
   2878        1.1  jmcneill 	bool first = true;
   2879        1.1  jmcneill 	int err;
   2880        1.1  jmcneill 
   2881        1.1  jmcneill 	while(scatter_io_next(sio, &p, &sz)) {
   2882        1.1  jmcneill 		err = uiomove(p, sz, uio);
   2883        1.1  jmcneill 		if (err == EFAULT) {
   2884        1.1  jmcneill 			scatter_io_undo(sio, sz);
   2885        1.1  jmcneill 			if (first)
   2886        1.1  jmcneill 				return EFAULT;
   2887        1.1  jmcneill 			else
   2888        1.1  jmcneill 				return 0;
   2889        1.1  jmcneill 		}
   2890        1.1  jmcneill 		first = false;
   2891        1.1  jmcneill 	}
   2892        1.1  jmcneill 
   2893        1.1  jmcneill 	return 0;
   2894        1.1  jmcneill }
   2895        1.1  jmcneill 
   2896        1.1  jmcneill #endif /* NVIDEO > 0 */
   2897