video.c revision 1.8
1 /* $NetBSD: video.c,v 1.8 2008/09/09 04:23:02 jmcneill Exp $ */ 2 3 /* 4 * Copyright (c) 2008 Patrick Mahoney <pat (at) polycrystal.org> 5 * All rights reserved. 6 * 7 * This code was written by Patrick Mahoney (pat (at) polycrystal.org) as 8 * part of Google Summer of Code 2008. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 /* 33 * This ia a Video4Linux 2 compatible /dev/video driver for NetBSD 34 * 35 * See http://v4l2spec.bytesex.org/ for Video4Linux 2 specifications 36 */ 37 38 #include <sys/cdefs.h> 39 __KERNEL_RCSID(0, "$NetBSD: video.c,v 1.8 2008/09/09 04:23:02 jmcneill Exp $"); 40 41 #include "video.h" 42 #if NVIDEO > 0 43 44 #include <sys/param.h> 45 #include <sys/ioctl.h> 46 #include <sys/fcntl.h> 47 #include <sys/vnode.h> 48 #include <sys/poll.h> 49 #include <sys/select.h> 50 #include <sys/kmem.h> 51 #include <sys/pool.h> 52 #include <sys/conf.h> 53 #include <sys/types.h> 54 #include <sys/device.h> 55 #include <sys/condvar.h> 56 #include <sys/queue.h> 57 #include <sys/videoio.h> 58 59 #include <dev/video_if.h> 60 61 /* #define VIDEO_DEBUG 1 */ 62 63 #ifdef VIDEO_DEBUG 64 #define DPRINTF(x) do { if (videodebug) printf x; } while (0) 65 #define DPRINTFN(n,x) do { if (videodebug>(n)) printf x; } while (0) 66 int videodebug = VIDEO_DEBUG; 67 #else 68 #define DPRINTF(x) 69 #define DPRINTFN(n,x) 70 #endif 71 72 #define VIDEO_DRIVER_VERSION 1 73 74 /* TODO: move to sys/intr.h */ 75 #define IPL_VIDEO IPL_VM 76 #define splvideo() splvm() 77 78 #define VIDEO_MIN_BUFS 2 79 #define VIDEO_MAX_BUFS 32 80 #define VIDEO_NUM_BUFS 4 81 82 /* Scatter Buffer - an array of fixed size (PAGE_SIZE) chunks 83 * allocated non-contiguously and functions to get data into and out 84 * of the scatter buffer. */ 85 struct scatter_buf { 86 pool_cache_t sb_pool; 87 size_t sb_size; /* size in bytes */ 88 size_t sb_npages; /* number of pages */ 89 uint8_t **sb_page_ary; /* array of page pointers */ 90 }; 91 92 struct scatter_io { 93 struct scatter_buf *sio_buf; 94 off_t sio_offset; 95 size_t sio_resid; 96 }; 97 98 static void scatter_buf_init(struct scatter_buf *); 99 static void scatter_buf_destroy(struct scatter_buf *); 100 static int scatter_buf_set_size(struct scatter_buf *, size_t); 101 static paddr_t scatter_buf_map(struct scatter_buf *, off_t); 102 103 static bool scatter_io_init(struct scatter_buf *, off_t, size_t, struct scatter_io *); 104 static bool scatter_io_next(struct scatter_io *, void **, size_t *); 105 static void scatter_io_undo(struct scatter_io *, size_t); 106 static void scatter_io_copyin(struct scatter_io *, const void *); 107 /* static void scatter_io_copyout(struct scatter_io *, void *); */ 108 static int scatter_io_uiomove(struct scatter_io *, struct uio *); 109 110 111 enum video_stream_method { 112 VIDEO_STREAM_METHOD_NONE, 113 VIDEO_STREAM_METHOD_READ, 114 VIDEO_STREAM_METHOD_MMAP, 115 VIDEO_STREAM_METHOD_USERPTR 116 }; 117 118 struct video_buffer { 119 struct v4l2_buffer *vb_buf; 120 SIMPLEQ_ENTRY(video_buffer) entries; 121 }; 122 123 SIMPLEQ_HEAD(sample_queue, video_buffer); 124 125 struct video_stream { 126 int vs_flags; /* flags given to open() */ 127 128 struct video_format vs_format; 129 130 int vs_frameno; /* toggles between 0 and 1, 131 * or -1 if new */ 132 uint32_t vs_sequence; /* absoulte frame/sample number in 133 * sequence, wraps around */ 134 bool vs_drop; /* drop payloads from current 135 * frameno? */ 136 137 enum v4l2_buf_type vs_type; 138 uint8_t vs_nbufs; 139 struct video_buffer **vs_buf; 140 141 struct scatter_buf vs_data; /* stores video data for MMAP 142 * and READ */ 143 144 /* Video samples may exist in different locations. Initially, 145 * samples are queued into the ingress queue. The driver 146 * grabs these in turn and fills them with video data. Once 147 * filled, they are moved to the egress queue. Samples are 148 * dequeued either by user with MMAP method or, with READ 149 * method, videoread() works from the fist sample in the 150 * ingress queue without dequeing. In the first case, the 151 * user re-queues the buffer when finished, and videoread() 152 * does the same when all data has been read. The sample now 153 * returns to the ingress queue. */ 154 struct sample_queue vs_ingress; /* samples under driver control */ 155 struct sample_queue vs_egress; /* samples headed for userspace */ 156 157 bool vs_streaming; 158 enum video_stream_method vs_method; /* method by which 159 * userspace will read 160 * samples */ 161 162 kmutex_t vs_lock; /* Lock to manipulate queues. 163 * Should also be held when 164 * changing number of 165 * buffers. */ 166 kcondvar_t vs_sample_cv; /* signaled on new 167 * ingress sample */ 168 struct selinfo vs_sel; 169 170 uint32_t vs_bytesread; /* bytes read() from current 171 * sample thus far */ 172 }; 173 174 struct video_softc { 175 device_t sc_dev; 176 device_t hw_dev; /* Hardware (parent) device */ 177 void * hw_softc; /* Hardware device private softc */ 178 const struct video_hw_if *hw_if; /* Hardware interface */ 179 180 u_int sc_open; 181 int sc_refcnt; 182 int sc_opencnt; 183 bool sc_dying; 184 185 struct video_stream sc_stream_in; 186 }; 187 static int video_print(void *, const char *); 188 189 static int video_match(device_t, cfdata_t, void *); 190 static void video_attach(device_t, device_t, void *); 191 static int video_detach(device_t, int); 192 static int video_activate(device_t, enum devact); 193 194 dev_type_open(videoopen); 195 dev_type_close(videoclose); 196 dev_type_read(videoread); 197 dev_type_write(videowrite); 198 dev_type_ioctl(videoioctl); 199 dev_type_poll(videopoll); 200 dev_type_mmap(videommap); 201 202 const struct cdevsw video_cdevsw = { 203 videoopen, videoclose, videoread, videowrite, videoioctl, 204 nostop, notty, videopoll, videommap, nokqfilter, D_OTHER 205 }; 206 207 #define VIDEOUNIT(n) (minor(n)) 208 209 CFATTACH_DECL_NEW(video, sizeof(struct video_softc), 210 video_match, video_attach, video_detach, video_activate); 211 212 extern struct cfdriver video_cd; 213 214 static const char * video_pixel_format_str(enum video_pixel_format); 215 216 /* convert various values from V4L2 to native values of this driver */ 217 static uint16_t v4l2id_to_control_id(uint32_t); 218 static uint32_t control_flags_to_v4l2flags(uint32_t); 219 static enum v4l2_ctrl_type control_type_to_v4l2type(enum video_control_type); 220 221 static void v4l2_format_to_video_format(const struct v4l2_format *, 222 struct video_format *); 223 static void video_format_to_v4l2_format(const struct video_format *, 224 struct v4l2_format *); 225 226 /* V4L2 api functions, typically called from videoioclt() */ 227 static int video_enum_format(struct video_softc *, struct v4l2_fmtdesc *); 228 static int video_get_format(struct video_softc *, 229 struct v4l2_format *); 230 static int video_set_format(struct video_softc *, 231 struct v4l2_format *); 232 static int video_try_format(struct video_softc *, 233 struct v4l2_format *); 234 static int video_query_control(struct video_softc *, 235 struct v4l2_queryctrl *); 236 static int video_get_control(struct video_softc *, 237 struct v4l2_control *); 238 static int video_set_control(struct video_softc *, 239 const struct v4l2_control *); 240 static int video_request_bufs(struct video_softc *, 241 struct v4l2_requestbuffers *); 242 static int video_query_buf(struct video_softc *, struct v4l2_buffer *); 243 static int video_queue_buf(struct video_softc *, struct v4l2_buffer *); 244 static int video_dequeue_buf(struct video_softc *, struct v4l2_buffer *); 245 static int video_stream_on(struct video_softc *, enum v4l2_buf_type); 246 static int video_stream_off(struct video_softc *, enum v4l2_buf_type); 247 248 static struct video_buffer * video_buffer_alloc(void); 249 static void video_buffer_free(struct video_buffer *); 250 251 252 /* functions for video_stream */ 253 static void video_stream_init(struct video_stream *); 254 static void video_stream_fini(struct video_stream *); 255 256 static int video_stream_setup_bufs(struct video_stream *, 257 enum video_stream_method, 258 uint8_t); 259 static void video_stream_teardown_bufs(struct video_stream *); 260 261 static int video_stream_realloc_bufs(struct video_stream *, uint8_t); 262 #define video_stream_free_bufs(vs) \ 263 video_stream_realloc_bufs((vs), 0) 264 265 static void video_stream_enqueue(struct video_stream *, 266 struct video_buffer *); 267 static struct video_buffer * video_stream_dequeue(struct video_stream *); 268 static void video_stream_write(struct video_stream *, 269 const struct video_payload *); 270 static void video_stream_sample_done(struct video_stream *); 271 272 #ifdef VIDEO_DEBUG 273 /* debugging */ 274 static const char * video_ioctl_str(u_long); 275 #endif 276 277 278 static int 279 video_match(device_t parent, cfdata_t match, void *aux) 280 { 281 struct video_attach_args *args; 282 283 args = aux; 284 DPRINTF(("video_match: hw=%p\n", args->hw_if)); 285 return 1; 286 } 287 288 289 static void 290 video_attach(device_t parent, device_t self, void *aux) 291 { 292 struct video_softc *sc; 293 struct video_attach_args *args; 294 295 sc = device_private(self); 296 args = aux; 297 298 sc->sc_dev = self; 299 sc->hw_dev = parent; 300 sc->hw_if = args->hw_if; 301 sc->hw_softc = device_private(parent); 302 303 sc->sc_open = 0; 304 sc->sc_refcnt = 0; 305 sc->sc_opencnt = 0; 306 sc->sc_dying = false; 307 308 video_stream_init(&sc->sc_stream_in); 309 310 aprint_naive("\n"); 311 aprint_normal(": %s\n", sc->hw_if->get_devname(sc->hw_softc)); 312 313 DPRINTF(("video_attach: sc=%p hwif=%p\n", sc, sc->hw_if)); 314 } 315 316 317 static int 318 video_activate(device_t self, enum devact act) 319 { 320 struct video_softc *sc; 321 322 sc = device_private(self); 323 DPRINTF(("video_activate: sc=%p\n", sc)); 324 switch (act) { 325 case DVACT_ACTIVATE: 326 return EOPNOTSUPP; 327 328 case DVACT_DEACTIVATE: 329 sc->sc_dying = true; 330 break; 331 } 332 return 0; 333 } 334 335 336 static int 337 video_detach(device_t self, int flags) 338 { 339 struct video_softc *sc; 340 int maj, mn; 341 342 sc = device_private(self); 343 DPRINTF(("video_detach: sc=%p flags=%d\n", sc, flags)); 344 345 sc->sc_dying = true; 346 347 maj = cdevsw_lookup_major(&video_cdevsw); 348 mn = device_unit(self); 349 /* close open instances */ 350 vdevgone(maj, mn, mn, VCHR); 351 352 video_stream_fini(&sc->sc_stream_in); 353 354 return 0; 355 } 356 357 358 static int 359 video_print(void *aux, const char *pnp) 360 { 361 struct video_attach_args *arg; 362 363 if (pnp != NULL) { 364 DPRINTF(("video_print: have pnp\n")); 365 arg = aux; 366 aprint_normal("%s at %s\n", "video", pnp); 367 } else { 368 DPRINTF(("video_print: pnp is NULL\n")); 369 } 370 return UNCONF; 371 } 372 373 374 /* 375 * Called from hardware driver. This is where the MI audio driver 376 * gets probed/attached to the hardware driver. 377 */ 378 device_t 379 video_attach_mi(const struct video_hw_if *hw_if, device_t parent) 380 { 381 struct video_attach_args args; 382 383 args.hw_if = hw_if; 384 return config_found_ia(parent, "videobus", &args, video_print); 385 } 386 387 /* video_submit_payload - called by hardware driver to submit payload data */ 388 void 389 video_submit_payload(device_t self, const struct video_payload *payload) 390 { 391 struct video_softc *sc; 392 393 sc = device_private(self); 394 395 if (sc == NULL) 396 return; 397 398 video_stream_write(&sc->sc_stream_in, payload); 399 } 400 401 static const char * 402 video_pixel_format_str(enum video_pixel_format px) 403 { 404 switch (px) { 405 case VIDEO_FORMAT_YUY2: return "YUYV"; 406 case VIDEO_FORMAT_NV12: return "NV12"; 407 case VIDEO_FORMAT_MJPEG: return "MJPEG"; 408 case VIDEO_FORMAT_DV: return "DV"; 409 case VIDEO_FORMAT_MPEG: return "MPEG"; 410 default: return "Unknown"; 411 } 412 } 413 414 /* Takes a V4L2 id and returns a "native" video driver control id. 415 * TODO: is there a better way to do this? some kind of array? */ 416 static uint16_t 417 v4l2id_to_control_id(uint32_t v4l2id) 418 { 419 /* mask includes class bits and control id bits */ 420 switch (v4l2id & 0xffffff) { 421 case V4L2_CID_BRIGHTNESS: return VIDEO_CONTROL_BRIGHTNESS; 422 case V4L2_CID_CONTRAST: return VIDEO_CONTROL_CONTRAST; 423 case V4L2_CID_SATURATION: return VIDEO_CONTROL_SATURATION; 424 case V4L2_CID_HUE: return VIDEO_CONTROL_HUE; 425 case V4L2_CID_HUE_AUTO: return VIDEO_CONTROL_HUE_AUTO; 426 case V4L2_CID_SHARPNESS: return VIDEO_CONTROL_SHARPNESS; 427 case V4L2_CID_GAMMA: return VIDEO_CONTROL_GAMMA; 428 429 /* "black level" means the same as "brightness", but V4L2 430 * defines two separate controls that are not identical. 431 * V4L2_CID_BLACK_LEVEL is deprecated however in V4L2. */ 432 case V4L2_CID_BLACK_LEVEL: return VIDEO_CONTROL_BRIGHTNESS; 433 434 case V4L2_CID_AUDIO_VOLUME: return VIDEO_CONTROL_UNDEFINED; 435 case V4L2_CID_AUDIO_BALANCE: return VIDEO_CONTROL_UNDEFINED; 436 case V4L2_CID_AUDIO_BASS: return VIDEO_CONTROL_UNDEFINED; 437 case V4L2_CID_AUDIO_TREBLE: return VIDEO_CONTROL_UNDEFINED; 438 case V4L2_CID_AUDIO_MUTE: return VIDEO_CONTROL_UNDEFINED; 439 case V4L2_CID_AUDIO_LOUDNESS: return VIDEO_CONTROL_UNDEFINED; 440 441 case V4L2_CID_AUTO_WHITE_BALANCE: 442 return VIDEO_CONTROL_WHITE_BALANCE_AUTO; 443 case V4L2_CID_DO_WHITE_BALANCE: 444 return VIDEO_CONTROL_WHITE_BALANCE_ACTION; 445 case V4L2_CID_RED_BALANCE: 446 case V4L2_CID_BLUE_BALANCE: 447 /* This might not fit in with the control_id/value_id scheme */ 448 return VIDEO_CONTROL_WHITE_BALANCE_COMPONENT; 449 case V4L2_CID_WHITE_BALANCE_TEMPERATURE: 450 return VIDEO_CONTROL_WHITE_BALANCE_TEMPERATURE; 451 case V4L2_CID_EXPOSURE: 452 return VIDEO_CONTROL_EXPOSURE_TIME_ABSOLUTE; 453 case V4L2_CID_GAIN: return VIDEO_CONTROL_GAIN; 454 case V4L2_CID_AUTOGAIN: return VIDEO_CONTROL_GAIN_AUTO; 455 case V4L2_CID_HFLIP: return VIDEO_CONTROL_HFLIP; 456 case V4L2_CID_VFLIP: return VIDEO_CONTROL_VFLIP; 457 case V4L2_CID_HCENTER_DEPRECATED: 458 case V4L2_CID_VCENTER_DEPRECATED: 459 return VIDEO_CONTROL_UNDEFINED; 460 case V4L2_CID_POWER_LINE_FREQUENCY: 461 return VIDEO_CONTROL_POWER_LINE_FREQUENCY; 462 case V4L2_CID_BACKLIGHT_COMPENSATION: 463 return VIDEO_CONTROL_BACKLIGHT_COMPENSATION; 464 default: return V4L2_CTRL_ID2CID(v4l2id); 465 } 466 } 467 468 469 static uint32_t 470 control_flags_to_v4l2flags(uint32_t flags) 471 { 472 uint32_t v4l2flags = 0; 473 474 if (flags & VIDEO_CONTROL_FLAG_DISABLED) 475 v4l2flags |= V4L2_CTRL_FLAG_INACTIVE; 476 477 if (!(flags & VIDEO_CONTROL_FLAG_WRITE)) 478 v4l2flags |= V4L2_CTRL_FLAG_READ_ONLY; 479 480 if (flags & VIDEO_CONTROL_FLAG_AUTOUPDATE) 481 v4l2flags |= V4L2_CTRL_FLAG_GRABBED; 482 483 return v4l2flags; 484 } 485 486 487 static enum v4l2_ctrl_type 488 control_type_to_v4l2type(enum video_control_type type) { 489 switch (type) { 490 case VIDEO_CONTROL_TYPE_INT: return V4L2_CTRL_TYPE_INTEGER; 491 case VIDEO_CONTROL_TYPE_BOOL: return V4L2_CTRL_TYPE_BOOLEAN; 492 case VIDEO_CONTROL_TYPE_LIST: return V4L2_CTRL_TYPE_MENU; 493 case VIDEO_CONTROL_TYPE_ACTION: return V4L2_CTRL_TYPE_BUTTON; 494 default: return V4L2_CTRL_TYPE_INTEGER; /* err? */ 495 } 496 } 497 498 499 static int 500 video_query_control(struct video_softc *sc, 501 struct v4l2_queryctrl *query) 502 { 503 const struct video_hw_if *hw; 504 struct video_control_desc_group desc_group; 505 struct video_control_desc desc; 506 int err; 507 508 hw = sc->hw_if; 509 if (hw->get_control_desc_group) { 510 desc.group_id = desc.control_id = 511 v4l2id_to_control_id(query->id); 512 513 desc_group.group_id = desc.group_id; 514 desc_group.length = 1; 515 desc_group.desc = &desc; 516 517 err = hw->get_control_desc_group(sc->hw_softc, &desc_group); 518 if (err != 0) 519 return err; 520 521 query->type = control_type_to_v4l2type(desc.type); 522 memcpy(query->name, desc.name, 32); 523 query->minimum = desc.min; 524 query->maximum = desc.max; 525 query->step = desc.step; 526 query->default_value = desc.def; 527 query->flags = control_flags_to_v4l2flags(desc.flags); 528 529 return 0; 530 } else { 531 return EINVAL; 532 } 533 } 534 535 536 /* Takes a single Video4Linux2 control and queries the driver for the 537 * current value. */ 538 static int 539 video_get_control(struct video_softc *sc, 540 struct v4l2_control *vcontrol) 541 { 542 const struct video_hw_if *hw; 543 struct video_control_group group; 544 struct video_control control; 545 int err; 546 547 hw = sc->hw_if; 548 if (hw->get_control_group) { 549 control.group_id = control.control_id = 550 v4l2id_to_control_id(vcontrol->id); 551 /* ?? if "control_id" is arbitrarily defined by the 552 * driver, then we need some way to store it... Maybe 553 * it doesn't matter for single value controls. */ 554 control.value = 0; 555 556 group.group_id = control.group_id; 557 group.length = 1; 558 group.control = &control; 559 560 err = hw->get_control_group(sc->hw_softc, &group); 561 if (err != 0) 562 return err; 563 564 vcontrol->value = control.value; 565 return 0; 566 } else { 567 return EINVAL; 568 } 569 } 570 571 static void 572 video_format_to_v4l2_format(const struct video_format *src, 573 struct v4l2_format *dest) 574 { 575 /* TODO: what about win and vbi formats? */ 576 dest->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 577 dest->fmt.pix.width = src->width; 578 dest->fmt.pix.height = src->height; 579 dest->fmt.pix.field = V4L2_FIELD_NONE; /* TODO: for now, 580 * just set to 581 * progressive */ 582 dest->fmt.pix.bytesperline = src->stride; 583 dest->fmt.pix.sizeimage = src->sample_size; 584 /* dest->colorspace = */ 585 586 switch (src->pixel_format) { 587 case VIDEO_FORMAT_YUY2: 588 dest->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV; 589 break; 590 case VIDEO_FORMAT_NV12: 591 dest->fmt.pix.pixelformat = V4L2_PIX_FMT_NV12; 592 break; 593 case VIDEO_FORMAT_MJPEG: 594 dest->fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG; 595 break; 596 case VIDEO_FORMAT_DV: 597 dest->fmt.pix.pixelformat = V4L2_PIX_FMT_DV; 598 break; 599 case VIDEO_FORMAT_MPEG: 600 dest->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG; 601 break; 602 case VIDEO_FORMAT_UNDEFINED: 603 default: 604 DPRINTF(("video_get_format: unknown pixel format %d\n", 605 src->pixel_format)); 606 dest->fmt.pix.pixelformat = 0; /* V4L2 doesn't define 607 * and "undefined" 608 * format? */ 609 break; 610 } 611 612 } 613 614 static void 615 v4l2_format_to_video_format(const struct v4l2_format *src, 616 struct video_format *dest) 617 { 618 switch (src->type) { 619 case V4L2_BUF_TYPE_VIDEO_CAPTURE: 620 dest->width = src->fmt.pix.width; 621 dest->height = src->fmt.pix.height; 622 623 dest->stride = src->fmt.pix.bytesperline; 624 dest->sample_size = src->fmt.pix.sizeimage; 625 626 switch (src->fmt.pix.pixelformat) { 627 case V4L2_PIX_FMT_YUYV: 628 dest->pixel_format = VIDEO_FORMAT_YUY2; 629 break; 630 case V4L2_PIX_FMT_NV12: 631 dest->pixel_format = VIDEO_FORMAT_NV12; 632 break; 633 case V4L2_PIX_FMT_JPEG: 634 dest->pixel_format = VIDEO_FORMAT_MJPEG; 635 break; 636 case V4L2_PIX_FMT_DV: 637 dest->pixel_format = VIDEO_FORMAT_DV; 638 break; 639 case V4L2_PIX_FMT_MPEG: 640 dest->pixel_format = VIDEO_FORMAT_MJPEG; 641 break; 642 default: 643 DPRINTF(("video: unknown v4l2 pixel format %d\n", 644 src->fmt.pix.pixelformat)); 645 dest->pixel_format = VIDEO_FORMAT_UNDEFINED; 646 break; 647 } 648 break; 649 default: 650 /* TODO: other v4l2 format types */ 651 DPRINTF(("video: unsupported v4l2 format type %d\n", 652 src->type)); 653 break; 654 } 655 } 656 657 static int 658 video_enum_format(struct video_softc *sc, struct v4l2_fmtdesc *fmtdesc) 659 { 660 const struct video_hw_if *hw; 661 struct video_format vfmt; 662 struct v4l2_format fmt; 663 int err; 664 665 hw = sc->hw_if; 666 if (hw->enum_format == NULL) 667 return ENOTTY; 668 669 err = hw->enum_format(sc->hw_softc, fmtdesc->index, &vfmt); 670 if (err != 0) 671 return err; 672 673 video_format_to_v4l2_format(&vfmt, &fmt); 674 675 fmtdesc->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; /* TODO: only one type for now */ 676 if (vfmt.pixel_format >= VIDEO_FORMAT_MJPEG) 677 fmtdesc->flags = V4L2_FMT_FLAG_COMPRESSED; 678 strlcpy(fmtdesc->description, 679 video_pixel_format_str(vfmt.pixel_format), 680 sizeof(fmtdesc->description)); 681 fmtdesc->pixelformat = fmt.fmt.pix.pixelformat; 682 683 return 0; 684 } 685 686 static int 687 video_get_format(struct video_softc *sc, 688 struct v4l2_format *format) 689 { 690 const struct video_hw_if *hw; 691 struct video_format vfmt; 692 int err; 693 694 hw = sc->hw_if; 695 if (hw->get_format == NULL) 696 return ENOTTY; 697 698 err = hw->get_format(sc->hw_softc, &vfmt); 699 if (err != 0) 700 return err; 701 702 video_format_to_v4l2_format(&vfmt, format); 703 704 return 0; 705 } 706 707 static int 708 video_set_format(struct video_softc *sc, struct v4l2_format *fmt) 709 { 710 const struct video_hw_if *hw; 711 struct video_format vfmt; 712 int err; 713 714 hw = sc->hw_if; 715 if (hw->get_format == NULL) 716 return ENOTTY; 717 718 v4l2_format_to_video_format(fmt, &vfmt); 719 720 err = hw->set_format(sc->hw_softc, &vfmt); 721 if (err != 0) 722 return err; 723 724 video_format_to_v4l2_format(&vfmt, fmt); 725 726 return 0; 727 } 728 729 730 static int 731 video_try_format(struct video_softc *sc, 732 struct v4l2_format *format) 733 { 734 const struct video_hw_if *hw; 735 struct video_format vfmt; 736 int err; 737 738 hw = sc->hw_if; 739 if (hw->try_format == NULL) 740 return ENOTTY; 741 742 v4l2_format_to_video_format(format, &vfmt); 743 744 err = hw->try_format(sc->hw_softc, &vfmt); 745 if (err != 0) 746 return err; 747 748 video_format_to_v4l2_format(&vfmt, format); 749 750 return 0; 751 } 752 753 /* Takes a single Video4Linux2 control, converts it to a struct 754 * video_control, and calls the hardware driver. */ 755 static int 756 video_set_control(struct video_softc *sc, 757 const struct v4l2_control *vcontrol) 758 { 759 const struct video_hw_if *hw; 760 struct video_control_group group; 761 struct video_control control; 762 763 hw = sc->hw_if; 764 if (hw->set_control_group) { 765 control.group_id = control.control_id = 766 v4l2id_to_control_id(vcontrol->id); 767 /* ?? if "control_id" is arbitrarily defined by the 768 * driver, then we need some way to store it... Maybe 769 * it doesn't matter for single value controls. */ 770 control.value = vcontrol->value; 771 772 group.group_id = control.group_id; 773 group.length = 1; 774 group.control = &control; 775 776 return (hw->set_control_group(sc->hw_softc, &group)); 777 } else { 778 return EINVAL; 779 } 780 } 781 782 static int 783 video_request_bufs(struct video_softc *sc, 784 struct v4l2_requestbuffers *req) 785 { 786 struct video_stream *vs = &sc->sc_stream_in; 787 struct v4l2_buffer *buf; 788 int i, err; 789 790 if (req->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 791 return EINVAL; 792 793 vs->vs_type = req->type; 794 795 switch (req->memory) { 796 case V4L2_MEMORY_MMAP: 797 if (req->count < VIDEO_MIN_BUFS) 798 req->count = VIDEO_MIN_BUFS; 799 else if (req->count > VIDEO_MAX_BUFS) 800 req->count = VIDEO_MAX_BUFS; 801 802 err = video_stream_setup_bufs(vs, 803 VIDEO_STREAM_METHOD_MMAP, 804 req->count); 805 if (err != 0) 806 return err; 807 808 for (i = 0; i < req->count; ++i) { 809 buf = vs->vs_buf[i]->vb_buf; 810 buf->memory = V4L2_MEMORY_MMAP; 811 buf->flags |= V4L2_BUF_FLAG_MAPPED; 812 } 813 break; 814 case V4L2_MEMORY_USERPTR: 815 default: 816 return EINVAL; 817 } 818 819 return 0; 820 } 821 822 static int 823 video_query_buf(struct video_softc *sc, 824 struct v4l2_buffer *buf) 825 { 826 struct video_stream *vs = &sc->sc_stream_in; 827 828 if (buf->type != vs->vs_type) 829 return EINVAL; 830 if (buf->index >= vs->vs_nbufs) 831 return EINVAL; 832 833 memcpy(buf, vs->vs_buf[buf->index]->vb_buf, sizeof(*buf)); 834 835 return 0; 836 } 837 838 /* Accept a buffer descriptor from userspace and return the indicated 839 * buffer to the driver's queue. */ 840 static int 841 video_queue_buf(struct video_softc *sc, struct v4l2_buffer *userbuf) 842 { 843 struct video_stream *vs = &sc->sc_stream_in; 844 struct video_buffer *vb; 845 struct v4l2_buffer *driverbuf; 846 847 if (userbuf->type != vs->vs_type) { 848 DPRINTF(("video_queue_buf: expected type=%d got type=%d\n", 849 userbuf->type, vs->vs_type)); 850 return EINVAL; 851 } 852 if (userbuf->index >= vs->vs_nbufs) { 853 DPRINTF(("video_queue_buf: invalid index %d >= %d\n", 854 userbuf->index, vs->vs_nbufs)); 855 return EINVAL; 856 } 857 858 switch (vs->vs_method) { 859 case VIDEO_STREAM_METHOD_MMAP: 860 if (userbuf->memory != V4L2_MEMORY_MMAP) { 861 DPRINTF(("video_queue_buf: invalid memory=%d\n", 862 userbuf->memory)); 863 return EINVAL; 864 } 865 866 mutex_enter(&vs->vs_lock); 867 868 vb = vs->vs_buf[userbuf->index]; 869 driverbuf = vb->vb_buf; 870 if (driverbuf->flags & V4L2_BUF_FLAG_QUEUED) { 871 DPRINTF(("video_queue_buf: buf already queued; " 872 "flags=0x%x\n", driverbuf->flags)); 873 mutex_exit(&vs->vs_lock); 874 return EINVAL; 875 } 876 video_stream_enqueue(vs, vb); 877 memcpy(userbuf, driverbuf, sizeof(*driverbuf)); 878 879 mutex_exit(&vs->vs_lock); 880 break; 881 default: 882 return EINVAL; 883 } 884 885 return 0; 886 } 887 888 /* Dequeue the described buffer from the driver queue, making it 889 * available for reading via mmap. */ 890 static int 891 video_dequeue_buf(struct video_softc *sc, struct v4l2_buffer *buf) 892 { 893 struct video_stream *vs = &sc->sc_stream_in; 894 struct video_buffer *vb; 895 int err; 896 897 if (buf->type != vs->vs_type) 898 return EINVAL; 899 900 switch (vs->vs_method) { 901 case VIDEO_STREAM_METHOD_MMAP: 902 if (buf->memory != V4L2_MEMORY_MMAP) 903 return EINVAL; 904 905 mutex_enter(&vs->vs_lock); 906 907 if (vs->vs_flags & O_NONBLOCK) { 908 vb = video_stream_dequeue(vs); 909 if (vb == NULL) { 910 mutex_exit(&vs->vs_lock); 911 return EAGAIN; 912 } 913 } else { 914 /* Block until we have sample */ 915 while ((vb = video_stream_dequeue(vs)) == NULL) { 916 err = cv_wait_sig(&vs->vs_sample_cv, 917 &vs->vs_lock); 918 if (err != 0) { 919 mutex_exit(&vs->vs_lock); 920 return EINTR; 921 } 922 } 923 } 924 925 memcpy(buf, vb->vb_buf, sizeof(*buf)); 926 927 mutex_exit(&vs->vs_lock); 928 break; 929 default: 930 return EINVAL; 931 } 932 933 return 0; 934 } 935 936 static int 937 video_stream_on(struct video_softc *sc, enum v4l2_buf_type type) 938 { 939 int err; 940 struct video_stream *vs = &sc->sc_stream_in; 941 const struct video_hw_if *hw; 942 943 if (vs->vs_streaming) 944 return 0; 945 if (type != vs->vs_type) 946 return EINVAL; 947 948 hw = sc->hw_if; 949 if (hw == NULL) 950 return ENXIO; 951 952 953 err = hw->start_transfer(sc->hw_softc); 954 if (err != 0) 955 return err; 956 957 vs->vs_streaming = true; 958 return 0; 959 } 960 961 static int 962 video_stream_off(struct video_softc *sc, enum v4l2_buf_type type) 963 { 964 int err; 965 struct video_stream *vs = &sc->sc_stream_in; 966 const struct video_hw_if *hw; 967 968 if (!vs->vs_streaming) 969 return 0; 970 if (type != vs->vs_type) 971 return EINVAL; 972 973 hw = sc->hw_if; 974 if (hw == NULL) 975 return ENXIO; 976 977 err = hw->stop_transfer(sc->hw_softc); 978 if (err != 0) 979 return err; 980 981 vs->vs_frameno = -1; 982 vs->vs_sequence = 0; 983 vs->vs_streaming = false; 984 985 return 0; 986 } 987 988 int 989 videoopen(dev_t dev, int flags, int ifmt, struct lwp *l) 990 { 991 struct video_softc *sc; 992 const struct video_hw_if *hw; 993 struct video_stream *vs; 994 int err; 995 996 DPRINTF(("videoopen\n")); 997 998 sc = device_private(device_lookup(&video_cd, VIDEOUNIT(dev))); 999 if (sc == NULL) { 1000 DPRINTF(("videoopen: failed to get softc\n")); 1001 return ENXIO; 1002 } 1003 1004 if (sc->sc_dying) { 1005 DPRINTF(("videoopen: dying\n")); 1006 return EIO; 1007 } 1008 1009 sc->sc_stream_in.vs_flags = flags; 1010 1011 DPRINTF(("videoopen: flags=0x%x sc=%p parent=%p\n", 1012 flags, sc, sc->hw_dev)); 1013 1014 hw = sc->hw_if; 1015 if (hw == NULL) 1016 return ENXIO; 1017 1018 device_active(sc->sc_dev, DVA_SYSTEM); 1019 1020 sc->sc_opencnt++; 1021 1022 if (hw->open != NULL) { 1023 err = hw->open(sc->hw_softc, flags); 1024 if (err) 1025 return err; 1026 } 1027 1028 /* set up input stream. TODO: check flags to determine if 1029 * "read" is desired? */ 1030 vs = &sc->sc_stream_in; 1031 1032 if (hw->set_format != NULL) { 1033 err = hw->set_format(sc->hw_softc, &vs->vs_format); 1034 if (err != 0) 1035 return err; 1036 } 1037 return 0; 1038 } 1039 1040 1041 int 1042 videoclose(dev_t dev, int flags, int ifmt, struct lwp *l) 1043 { 1044 struct video_softc *sc; 1045 const struct video_hw_if *hw; 1046 1047 sc = device_private(device_lookup(&video_cd, VIDEOUNIT(dev))); 1048 if (sc == NULL) 1049 return ENXIO; 1050 1051 DPRINTF(("videoclose: sc=%p\n", sc)); 1052 1053 hw = sc->hw_if; 1054 if (hw == NULL) 1055 return ENXIO; 1056 1057 device_active(sc->sc_dev, DVA_SYSTEM); 1058 1059 video_stream_off(sc, sc->sc_stream_in.vs_type); 1060 1061 /* ignore error */ 1062 if (hw->close != NULL) 1063 hw->close(sc->hw_softc); 1064 1065 video_stream_teardown_bufs(&sc->sc_stream_in); 1066 1067 sc->sc_open = 0; 1068 sc->sc_opencnt--; 1069 1070 return 0; 1071 } 1072 1073 1074 int 1075 videoread(dev_t dev, struct uio *uio, int ioflag) 1076 { 1077 struct video_softc *sc; 1078 struct video_stream *vs; 1079 struct video_buffer *vb; 1080 struct scatter_io sio; 1081 int err; 1082 size_t len; 1083 off_t offset; 1084 1085 sc = device_private(device_lookup(&video_cd, VIDEOUNIT(dev))); 1086 if (sc == NULL) 1087 return ENXIO; 1088 1089 if (sc->sc_dying) 1090 return EIO; 1091 1092 vs = &sc->sc_stream_in; 1093 1094 /* userspace has chosen read() method */ 1095 if (vs->vs_method == VIDEO_STREAM_METHOD_NONE) { 1096 err = video_stream_setup_bufs(vs, 1097 VIDEO_STREAM_METHOD_READ, 1098 VIDEO_NUM_BUFS); 1099 if (err != 0) 1100 return err; 1101 1102 err = video_stream_on(sc, vs->vs_type); 1103 if (err != 0) 1104 return err; 1105 } else if (vs->vs_method != VIDEO_STREAM_METHOD_READ) { 1106 return EBUSY; 1107 } 1108 1109 mutex_enter(&vs->vs_lock); 1110 1111 retry: 1112 if (SIMPLEQ_EMPTY(&vs->vs_egress)) { 1113 if (vs->vs_flags & O_NONBLOCK) { 1114 mutex_exit(&vs->vs_lock); 1115 return EAGAIN; 1116 } 1117 1118 /* Block until we have a sample */ 1119 while (SIMPLEQ_EMPTY(&vs->vs_egress)) { 1120 err = cv_wait_sig(&vs->vs_sample_cv, 1121 &vs->vs_lock); 1122 if (err != 0) { 1123 mutex_exit(&vs->vs_lock); 1124 return EINTR; 1125 } 1126 } 1127 1128 vb = SIMPLEQ_FIRST(&vs->vs_egress); 1129 } else { 1130 vb = SIMPLEQ_FIRST(&vs->vs_egress); 1131 } 1132 1133 /* Oops, empty sample buffer. */ 1134 if (vb->vb_buf->bytesused == 0) { 1135 vb = video_stream_dequeue(vs); 1136 video_stream_enqueue(vs, vb); 1137 vs->vs_bytesread = 0; 1138 goto retry; 1139 } 1140 1141 mutex_exit(&vs->vs_lock); 1142 1143 len = min(uio->uio_resid, vb->vb_buf->bytesused - vs->vs_bytesread); 1144 offset = vb->vb_buf->m.offset + vs->vs_bytesread; 1145 1146 if (scatter_io_init(&vs->vs_data, offset, len, &sio)) { 1147 err = scatter_io_uiomove(&sio, uio); 1148 if (err == EFAULT) 1149 return EFAULT; 1150 vs->vs_bytesread += (len - sio.sio_resid); 1151 } else { 1152 DPRINTF(("video: invalid read\n")); 1153 } 1154 1155 /* Move the sample to the ingress queue if everything has 1156 * been read */ 1157 if (vs->vs_bytesread >= vb->vb_buf->bytesused) { 1158 mutex_enter(&vs->vs_lock); 1159 vb = video_stream_dequeue(vs); 1160 video_stream_enqueue(vs, vb); 1161 mutex_exit(&vs->vs_lock); 1162 1163 vs->vs_bytesread = 0; 1164 } 1165 1166 return 0; 1167 } 1168 1169 1170 int 1171 videowrite(dev_t dev, struct uio *uio, int ioflag) 1172 { 1173 return ENXIO; 1174 } 1175 1176 1177 int 1178 videoioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l) 1179 { 1180 struct video_softc *sc; 1181 const struct video_hw_if *hw; 1182 struct v4l2_capability *cap; 1183 struct v4l2_fmtdesc *fmtdesc; 1184 struct v4l2_format *fmt; 1185 struct v4l2_standard *std; 1186 struct v4l2_input *input; 1187 struct v4l2_control *control; 1188 struct v4l2_queryctrl *query; 1189 struct v4l2_requestbuffers *reqbufs; 1190 struct v4l2_buffer *buf; 1191 v4l2_std_id *stdid; 1192 enum v4l2_buf_type *typep; 1193 int *ip; 1194 1195 sc = device_private(device_lookup(&video_cd, VIDEOUNIT(dev))); 1196 1197 if (sc->sc_dying) 1198 return EIO; 1199 1200 hw = sc->hw_if; 1201 if (hw == NULL) 1202 return ENXIO; 1203 1204 switch (cmd) { 1205 case VIDIOC_QUERYCAP: 1206 cap = data; 1207 memset(cap, 0, sizeof(*cap)); 1208 strlcpy(cap->driver, device_xname(sc->hw_softc), 1209 sizeof(cap->driver)); 1210 strlcpy(cap->card, hw->get_devname(sc->hw_softc), 1211 sizeof(cap->card)); 1212 /* FIXME: bus_info is wrongly hardcoded to USB */ 1213 strlcpy(cap->bus_info, "USB", sizeof(cap->bus_info)); 1214 cap->version = VIDEO_DRIVER_VERSION; 1215 cap->capabilities = 0; 1216 if (hw->start_transfer != NULL && hw->stop_transfer != NULL) 1217 cap->capabilities |= V4L2_CAP_VIDEO_CAPTURE | 1218 V4L2_CAP_READWRITE | V4L2_CAP_STREAMING; 1219 return 0; 1220 case VIDIOC_ENUM_FMT: 1221 /* TODO: for now, just enumerate one default format */ 1222 fmtdesc = data; 1223 if (fmtdesc->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 1224 return EINVAL; 1225 if (fmtdesc->index != 0) 1226 return EINVAL; 1227 fmtdesc->index = fmtdesc->flags = 0; 1228 fmtdesc->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1229 return video_enum_format(sc, fmtdesc); 1230 case VIDIOC_G_FMT: 1231 fmt = data; 1232 return (video_get_format(sc, fmt)); 1233 case VIDIOC_S_FMT: 1234 fmt = data; 1235 if ((flag & FWRITE) == 0) 1236 return EPERM; 1237 return video_set_format(sc, fmt); 1238 case VIDIOC_TRY_FMT: 1239 fmt = data; 1240 return (video_try_format(sc, fmt)); 1241 case VIDIOC_ENUMSTD: 1242 /* TODO: implement properly */ 1243 std = data; 1244 if (std->index != 0) 1245 return EINVAL; 1246 std->id = V4L2_STD_UNKNOWN; 1247 strlcpy(std->name, "webcam", sizeof(std->name)); 1248 return 0; 1249 case VIDIOC_G_STD: 1250 /* TODO: implement properly */ 1251 stdid = data; 1252 *stdid = V4L2_STD_UNKNOWN; 1253 return 0; 1254 case VIDIOC_S_STD: 1255 /* TODO: implement properly */ 1256 stdid = data; 1257 if (*stdid != V4L2_STD_UNKNOWN) 1258 return EINVAL; 1259 return 0; 1260 case VIDIOC_ENUMINPUT: 1261 /* TODO: implement properly */ 1262 input = data; 1263 if (input->index != 0) 1264 return EINVAL; 1265 memset(input, 0, sizeof(*input)); 1266 input->index = 0; 1267 strlcpy(input->name, "Camera", sizeof(input->name)); 1268 input->type = V4L2_INPUT_TYPE_CAMERA; 1269 return 0; 1270 case VIDIOC_G_INPUT: 1271 /* TODO: implement properly */ 1272 ip = data; 1273 *ip = 0; 1274 return 0; 1275 case VIDIOC_S_INPUT: 1276 /* TODO: implement properly */ 1277 ip = data; 1278 if (*ip != 0) 1279 return EINVAL; 1280 return 0; 1281 case VIDIOC_QUERYCTRL: 1282 query = data; 1283 return (video_query_control(sc, query)); 1284 case VIDIOC_G_CTRL: 1285 control = data; 1286 return (video_get_control(sc, control)); 1287 case VIDIOC_S_CTRL: 1288 control = data; 1289 if ((flag & FWRITE) == 0) 1290 return EPERM; 1291 return (video_set_control(sc, control)); 1292 case VIDIOC_REQBUFS: 1293 reqbufs = data; 1294 return (video_request_bufs(sc, reqbufs)); 1295 case VIDIOC_QUERYBUF: 1296 buf = data; 1297 return video_query_buf(sc, buf); 1298 case VIDIOC_QBUF: 1299 buf = data; 1300 return video_queue_buf(sc, buf); 1301 break; 1302 case VIDIOC_DQBUF: 1303 buf = data; 1304 return video_dequeue_buf(sc, buf); 1305 break; 1306 case VIDIOC_STREAMON: 1307 typep = data; 1308 return video_stream_on(sc, *typep); 1309 case VIDIOC_STREAMOFF: 1310 typep = data; 1311 return video_stream_off(sc, *typep); 1312 default: 1313 DPRINTF(("videoioctl: invalid cmd %s (%lx)\n", 1314 video_ioctl_str(cmd), cmd)); 1315 return EINVAL; 1316 } 1317 } 1318 1319 #ifdef VIDEO_DEBUG 1320 static const char * 1321 video_ioctl_str(u_long cmd) 1322 { 1323 const char *str; 1324 1325 switch (cmd) { 1326 case VIDIOC_QUERYCAP: 1327 str = "VIDIOC_QUERYCAP"; 1328 break; 1329 case VIDIOC_RESERVED: 1330 str = "VIDIOC_RESERVED"; 1331 break; 1332 case VIDIOC_ENUM_FMT: 1333 str = "VIDIOC_ENUM_FMT"; 1334 break; 1335 case VIDIOC_G_FMT: 1336 str = "VIDIOC_G_FMT"; 1337 break; 1338 case VIDIOC_S_FMT: 1339 str = "VIDIOC_S_FMT"; 1340 break; 1341 /* 6 and 7 are VIDIOC_[SG]_COMP, which are unsupported */ 1342 case VIDIOC_REQBUFS: 1343 str = "VIDIOC_REQBUFS"; 1344 break; 1345 case VIDIOC_QUERYBUF: 1346 str = "VIDIOC_QUERYBUF"; 1347 break; 1348 case VIDIOC_G_FBUF: 1349 str = "VIDIOC_G_FBUF"; 1350 break; 1351 case VIDIOC_S_FBUF: 1352 str = "VIDIOC_S_FBUF"; 1353 break; 1354 case VIDIOC_OVERLAY: 1355 str = "VIDIOC_OVERLAY"; 1356 break; 1357 case VIDIOC_QBUF: 1358 str = "VIDIOC_QBUF"; 1359 break; 1360 case VIDIOC_DQBUF: 1361 str = "VIDIOC_DQBUF"; 1362 break; 1363 case VIDIOC_STREAMON: 1364 str = "VIDIOC_STREAMON"; 1365 break; 1366 case VIDIOC_STREAMOFF: 1367 str = "VIDIOC_STREAMOFF"; 1368 break; 1369 case VIDIOC_G_PARM: 1370 str = "VIDIOC_G_PARAM"; 1371 break; 1372 case VIDIOC_S_PARM: 1373 str = "VIDIOC_S_PARAM"; 1374 break; 1375 case VIDIOC_G_STD: 1376 str = "VIDIOC_G_STD"; 1377 break; 1378 case VIDIOC_S_STD: 1379 str = "VIDIOC_S_STD"; 1380 break; 1381 case VIDIOC_ENUMSTD: 1382 str = "VIDIOC_ENUMSTD"; 1383 break; 1384 case VIDIOC_ENUMINPUT: 1385 str = "VIDIOC_ENUMINPUT"; 1386 break; 1387 case VIDIOC_G_CTRL: 1388 str = "VIDIOC_G_CTRL"; 1389 break; 1390 case VIDIOC_S_CTRL: 1391 str = "VIDIOC_S_CTRL"; 1392 break; 1393 case VIDIOC_G_TUNER: 1394 str = "VIDIOC_G_TUNER"; 1395 break; 1396 case VIDIOC_S_TUNER: 1397 str = "VIDIOC_S_TUNER"; 1398 break; 1399 case VIDIOC_G_AUDIO: 1400 str = "VIDIOC_G_AUDIO"; 1401 break; 1402 case VIDIOC_S_AUDIO: 1403 str = "VIDIOC_S_AUDIO"; 1404 break; 1405 case VIDIOC_QUERYCTRL: 1406 str = "VIDIOC_QUERYCTRL"; 1407 break; 1408 case VIDIOC_QUERYMENU: 1409 str = "VIDIOC_QUERYMENU"; 1410 break; 1411 case VIDIOC_G_INPUT: 1412 str = "VIDIOC_G_INPUT"; 1413 break; 1414 case VIDIOC_S_INPUT: 1415 str = "VIDIOC_S_INPUT"; 1416 break; 1417 case VIDIOC_G_OUTPUT: 1418 str = "VIDIOC_G_OUTPUT"; 1419 break; 1420 case VIDIOC_S_OUTPUT: 1421 str = "VIDIOC_S_OUTPUT"; 1422 break; 1423 case VIDIOC_ENUMOUTPUT: 1424 str = "VIDIOC_ENUMOUTPUT"; 1425 break; 1426 case VIDIOC_G_AUDOUT: 1427 str = "VIDIOC_G_AUDOUT"; 1428 break; 1429 case VIDIOC_S_AUDOUT: 1430 str = "VIDIOC_S_AUDOUT"; 1431 break; 1432 case VIDIOC_G_MODULATOR: 1433 str = "VIDIOC_G_MODULATOR"; 1434 break; 1435 case VIDIOC_S_MODULATOR: 1436 str = "VIDIOC_S_MODULATOR"; 1437 break; 1438 case VIDIOC_G_FREQUENCY: 1439 str = "VIDIOC_G_FREQUENCY"; 1440 break; 1441 case VIDIOC_S_FREQUENCY: 1442 str = "VIDIOC_S_FREQUENCY"; 1443 break; 1444 case VIDIOC_CROPCAP: 1445 str = "VIDIOC_CROPCAP"; 1446 break; 1447 case VIDIOC_G_CROP: 1448 str = "VIDIOC_G_CROP"; 1449 break; 1450 case VIDIOC_S_CROP: 1451 str = "VIDIOC_S_CROP"; 1452 break; 1453 case VIDIOC_G_JPEGCOMP: 1454 str = "VIDIOC_G_JPEGCOMP"; 1455 break; 1456 case VIDIOC_S_JPEGCOMP: 1457 str = "VIDIOC_S_JPEGCOMP"; 1458 break; 1459 case VIDIOC_QUERYSTD: 1460 str = "VIDIOC_QUERYSTD"; 1461 break; 1462 case VIDIOC_TRY_FMT: 1463 str = "VIDIOC_TRY_FMT"; 1464 break; 1465 case VIDIOC_ENUMAUDIO: 1466 str = "VIDIOC_ENUMAUDIO"; 1467 break; 1468 case VIDIOC_ENUMAUDOUT: 1469 str = "VIDIOC_ENUMAUDOUT"; 1470 break; 1471 case VIDIOC_G_PRIORITY: 1472 str = "VIDIOC_G_PRIORITY"; 1473 break; 1474 case VIDIOC_S_PRIORITY: 1475 str = "VIDIOC_S_PRIORITY"; 1476 break; 1477 default: 1478 str = "unknown"; 1479 break; 1480 } 1481 return str; 1482 } 1483 #endif 1484 1485 1486 int 1487 videopoll(dev_t dev, int events, struct lwp *l) 1488 { 1489 struct video_softc *sc; 1490 struct video_stream *vs; 1491 int err, revents = 0; 1492 1493 sc = device_private(device_lookup(&video_cd, VIDEOUNIT(dev))); 1494 vs = &sc->sc_stream_in; 1495 1496 if (sc->sc_dying) 1497 return (POLLHUP); 1498 1499 /* userspace has chosen read() method */ 1500 if (vs->vs_method == VIDEO_STREAM_METHOD_NONE) { 1501 err = video_stream_setup_bufs(vs, 1502 VIDEO_STREAM_METHOD_READ, 1503 VIDEO_NUM_BUFS); 1504 if (err != 0) 1505 return POLLERR; 1506 1507 err = video_stream_on(sc, vs->vs_type); 1508 if (err != 0) 1509 return POLLERR; 1510 } 1511 1512 if (!SIMPLEQ_EMPTY(&sc->sc_stream_in.vs_egress)) 1513 revents |= events & (POLLIN | POLLRDNORM); 1514 else 1515 selrecord(l, &vs->vs_sel); 1516 1517 return (revents); 1518 } 1519 1520 1521 paddr_t 1522 videommap(dev_t dev, off_t off, int prot) 1523 { 1524 struct video_softc *sc; 1525 struct video_stream *vs; 1526 /* paddr_t pa; */ 1527 1528 sc = device_lookup_private(&video_cd, VIDEOUNIT(dev)); 1529 if (sc->sc_dying) 1530 return -1; 1531 1532 vs = &sc->sc_stream_in; 1533 1534 return scatter_buf_map(&vs->vs_data, off); 1535 } 1536 1537 1538 /* Allocates buffers and initizlizes some fields. The format field 1539 * must already have been initialized. */ 1540 void 1541 video_stream_init(struct video_stream *vs) 1542 { 1543 vs->vs_method = VIDEO_STREAM_METHOD_NONE; 1544 vs->vs_flags = 0; 1545 vs->vs_frameno = -1; 1546 vs->vs_sequence = 0; 1547 vs->vs_type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1548 vs->vs_nbufs = 0; 1549 vs->vs_buf = NULL; 1550 vs->vs_streaming = false; 1551 1552 memset(&vs->vs_format, 0, sizeof(vs->vs_format)); 1553 1554 SIMPLEQ_INIT(&vs->vs_ingress); 1555 SIMPLEQ_INIT(&vs->vs_egress); 1556 1557 mutex_init(&vs->vs_lock, MUTEX_DEFAULT, IPL_NONE); 1558 cv_init(&vs->vs_sample_cv, "video"); 1559 selinit(&vs->vs_sel); 1560 1561 scatter_buf_init(&vs->vs_data); 1562 } 1563 1564 void 1565 video_stream_fini(struct video_stream *vs) 1566 { 1567 /* Sample data in queues has already been freed */ 1568 /* while (SIMPLEQ_FIRST(&vs->vs_ingress) != NULL) 1569 SIMPLEQ_REMOVE_HEAD(&vs->vs_ingress, entries); 1570 while (SIMPLEQ_FIRST(&vs->vs_egress) != NULL) 1571 SIMPLEQ_REMOVE_HEAD(&vs->vs_egress, entries); */ 1572 1573 mutex_destroy(&vs->vs_lock); 1574 cv_destroy(&vs->vs_sample_cv); 1575 seldestroy(&vs->vs_sel); 1576 1577 scatter_buf_destroy(&vs->vs_data); 1578 } 1579 1580 static int 1581 video_stream_setup_bufs(struct video_stream *vs, 1582 enum video_stream_method method, 1583 uint8_t nbufs) 1584 { 1585 int i, err; 1586 1587 mutex_enter(&vs->vs_lock); 1588 1589 /* Ensure that all allocated buffers are queued and not under 1590 * userspace control. */ 1591 for (i = 0; i < vs->vs_nbufs; ++i) { 1592 if (!(vs->vs_buf[i]->vb_buf->flags | V4L2_BUF_FLAG_QUEUED)) { 1593 mutex_exit(&vs->vs_lock); 1594 return EBUSY; 1595 } 1596 } 1597 1598 /* Allocate the buffers */ 1599 err = video_stream_realloc_bufs(vs, nbufs); 1600 if (err != 0) { 1601 mutex_exit(&vs->vs_lock); 1602 return err; 1603 } 1604 1605 /* Queue up buffers for read method. Other methods are queued 1606 * by VIDIOC_QBUF ioctl. */ 1607 if (method == VIDEO_STREAM_METHOD_READ) { 1608 for (i = 0; i < nbufs; ++i) 1609 if (!(vs->vs_buf[i]->vb_buf->flags & V4L2_BUF_FLAG_QUEUED)) 1610 video_stream_enqueue(vs, vs->vs_buf[i]); 1611 } 1612 1613 vs->vs_method = method; 1614 mutex_exit(&vs->vs_lock); 1615 1616 return 0; 1617 } 1618 1619 /* Free all buffer memory in preparation for close(). This should 1620 * free buffers regardless of errors. Use video_stream_setup_bufs if 1621 * you need to check for errors. Streaming should be off before 1622 * calling this function. */ 1623 static void 1624 video_stream_teardown_bufs(struct video_stream *vs) 1625 { 1626 int err; 1627 1628 mutex_enter(&vs->vs_lock); 1629 1630 if (vs->vs_streaming) { 1631 DPRINTF(("video_stream_teardown_bufs: " 1632 "tearing down bufs while streaming\n")); 1633 } 1634 1635 /* dequeue all buffers */ 1636 while (SIMPLEQ_FIRST(&vs->vs_ingress) != NULL) 1637 SIMPLEQ_REMOVE_HEAD(&vs->vs_ingress, entries); 1638 while (SIMPLEQ_FIRST(&vs->vs_egress) != NULL) 1639 SIMPLEQ_REMOVE_HEAD(&vs->vs_egress, entries); 1640 1641 err = video_stream_free_bufs(vs); 1642 if (err != 0) { 1643 DPRINTF(("video_stream_teardown_bufs: " 1644 "error releasing buffers: %d\n", 1645 err)); 1646 } 1647 vs->vs_method = VIDEO_STREAM_METHOD_NONE; 1648 1649 mutex_exit(&vs->vs_lock); 1650 } 1651 1652 static struct video_buffer * 1653 video_buffer_alloc(void) 1654 { 1655 struct video_buffer *vb; 1656 1657 vb = kmem_alloc(sizeof(*vb), KM_SLEEP); 1658 if (vb == NULL) 1659 return NULL; 1660 1661 vb->vb_buf = kmem_alloc(sizeof(*vb->vb_buf), KM_SLEEP); 1662 if (vb->vb_buf == NULL) { 1663 kmem_free(vb, sizeof(*vb)); 1664 return NULL; 1665 } 1666 1667 return vb; 1668 } 1669 1670 static void 1671 video_buffer_free(struct video_buffer *vb) 1672 { 1673 kmem_free(vb->vb_buf, sizeof(*vb->vb_buf)); 1674 vb->vb_buf = NULL; 1675 kmem_free(vb, sizeof(*vb)); 1676 } 1677 1678 /* TODO: for userptr method 1679 struct video_buffer * 1680 video_buf_alloc_with_ubuf(struct v4l2_buffer *buf) 1681 { 1682 } 1683 1684 void 1685 video_buffer_free_with_ubuf(struct video_buffer *vb) 1686 { 1687 } 1688 */ 1689 1690 static int 1691 video_stream_realloc_bufs(struct video_stream *vs, uint8_t nbufs) 1692 { 1693 int i, err; 1694 uint8_t minnbufs, oldnbufs; 1695 size_t size; 1696 off_t offset; 1697 struct video_buffer **oldbuf; 1698 struct v4l2_buffer *buf; 1699 1700 size = vs->vs_format.sample_size * nbufs; 1701 err = scatter_buf_set_size(&vs->vs_data, size); 1702 if (err != 0) 1703 return err; 1704 1705 oldnbufs = vs->vs_nbufs; 1706 oldbuf = vs->vs_buf; 1707 1708 vs->vs_nbufs = nbufs; 1709 if (nbufs > 0) { 1710 vs->vs_buf = 1711 kmem_alloc(sizeof(struct video_buffer *) * nbufs, KM_SLEEP); 1712 if (vs->vs_buf == NULL) { 1713 vs->vs_nbufs = oldnbufs; 1714 vs->vs_buf = oldbuf; 1715 1716 return ENOMEM; 1717 } 1718 } else { 1719 vs->vs_buf = NULL; 1720 } 1721 1722 minnbufs = min(vs->vs_nbufs, oldnbufs); 1723 /* copy any bufs that will be reused */ 1724 for (i = 0; i < minnbufs; ++i) 1725 vs->vs_buf[i] = oldbuf[i]; 1726 /* allocate any necessary new bufs */ 1727 for (; i < vs->vs_nbufs; ++i) 1728 vs->vs_buf[i] = video_buffer_alloc(); 1729 /* free any bufs no longer used */ 1730 for (; i < oldnbufs; ++i) { 1731 video_buffer_free(oldbuf[i]); 1732 oldbuf[i] = NULL; 1733 } 1734 1735 /* Free old buffer metadata */ 1736 if (oldbuf != NULL) 1737 kmem_free(oldbuf, sizeof(struct video_buffer *) * oldnbufs); 1738 1739 /* initialize bufs */ 1740 offset = 0; 1741 for (i = 0; i < vs->vs_nbufs; ++i) { 1742 buf = vs->vs_buf[i]->vb_buf; 1743 buf->index = i; 1744 buf->type = vs->vs_type; 1745 buf->bytesused = 0; 1746 buf->flags = 0; 1747 buf->field = 0; 1748 buf->sequence = 0; 1749 buf->memory = V4L2_MEMORY_MMAP; 1750 buf->m.offset = offset; 1751 buf->length = vs->vs_format.sample_size; 1752 buf->input = 0; 1753 buf->reserved = 0; 1754 1755 offset += buf->length; 1756 } 1757 1758 return 0; 1759 } 1760 1761 /* Accepts a video_sample into the ingress queue. Caller must hold 1762 * the stream lock. */ 1763 void 1764 video_stream_enqueue(struct video_stream *vs, struct video_buffer *vb) 1765 { 1766 if (vb->vb_buf->flags & V4L2_BUF_FLAG_QUEUED) { 1767 DPRINTF(("video_stream_enqueue: sample already queued\n")); 1768 return; 1769 } 1770 1771 vb->vb_buf->flags |= V4L2_BUF_FLAG_QUEUED; 1772 vb->vb_buf->flags &= ~V4L2_BUF_FLAG_DONE; 1773 1774 vb->vb_buf->bytesused = 0; 1775 1776 SIMPLEQ_INSERT_TAIL(&vs->vs_ingress, vb, entries); 1777 } 1778 1779 1780 /* Removes the head of the egress queue for use by userspace. Caller 1781 * must hold the stream lock. */ 1782 struct video_buffer * 1783 video_stream_dequeue(struct video_stream *vs) 1784 { 1785 struct video_buffer *vb; 1786 1787 if (!SIMPLEQ_EMPTY(&vs->vs_egress)) { 1788 vb = SIMPLEQ_FIRST(&vs->vs_egress); 1789 SIMPLEQ_REMOVE_HEAD(&vs->vs_egress, entries); 1790 vb->vb_buf->flags &= ~V4L2_BUF_FLAG_QUEUED; 1791 vb->vb_buf->flags |= V4L2_BUF_FLAG_DONE; 1792 return vb; 1793 } else { 1794 return NULL; 1795 } 1796 } 1797 1798 1799 /* 1800 * write payload data to the appropriate video sample, possibly moving 1801 * the sample from ingress to egress queues 1802 */ 1803 void 1804 video_stream_write(struct video_stream *vs, 1805 const struct video_payload *payload) 1806 { 1807 struct video_buffer *vb; 1808 struct v4l2_buffer *buf; 1809 struct scatter_io sio; 1810 1811 mutex_enter(&vs->vs_lock); 1812 1813 /* change of frameno implies end of current frame */ 1814 if (vs->vs_frameno > 0 && vs->vs_frameno != payload->frameno) 1815 video_stream_sample_done(vs); 1816 1817 if (vs->vs_drop || SIMPLEQ_EMPTY(&vs->vs_ingress)) { 1818 /* DPRINTF(("video_stream_write: dropping sample %d\n", 1819 vs->vs_sequence)); */ 1820 vs->vs_drop = true; 1821 } else { 1822 vb = SIMPLEQ_FIRST(&vs->vs_ingress); 1823 buf = vb->vb_buf; 1824 if (payload->size > buf->length - buf->bytesused) { 1825 DPRINTF(("video_stream_write: " 1826 "payload would overflow\n")); 1827 } else if (scatter_io_init(&vs->vs_data, 1828 buf->m.offset + buf->bytesused, 1829 payload->size, 1830 &sio)) 1831 { 1832 scatter_io_copyin(&sio, payload->data); 1833 buf->bytesused += (payload->size - sio.sio_resid); 1834 } else { 1835 DPRINTF(("video_stream_write: failed to init scatter io " 1836 "vb=%p buf=%p " 1837 "buf->m.offset=%d buf->bytesused=%zu " 1838 "payload->size=%zu\n", 1839 vb, buf, 1840 buf->m.offset, buf->bytesused, payload->size)); 1841 } 1842 } 1843 1844 /* if the payload marks it, we can do sample_done() early */ 1845 if (payload->end_of_frame) 1846 video_stream_sample_done(vs); 1847 1848 mutex_exit(&vs->vs_lock); 1849 } 1850 1851 1852 /* Moves the head of the ingress queue to the tail of the egress 1853 * queue, or resets drop status if we were dropping this sample. 1854 * Caller should hold the stream queue lock. */ 1855 void 1856 video_stream_sample_done(struct video_stream *vs) 1857 { 1858 struct video_buffer *vb; 1859 1860 if (vs->vs_drop) { 1861 vs->vs_drop = false; 1862 } else if (!SIMPLEQ_EMPTY(&vs->vs_ingress)) { 1863 vb = SIMPLEQ_FIRST(&vs->vs_ingress); 1864 vb->vb_buf->sequence = vs->vs_sequence; 1865 SIMPLEQ_REMOVE_HEAD(&vs->vs_ingress, entries); 1866 1867 SIMPLEQ_INSERT_TAIL(&vs->vs_egress, vb, entries); 1868 cv_signal(&vs->vs_sample_cv); 1869 selnotify(&vs->vs_sel, 0, 0); 1870 } else { 1871 DPRINTF(("video_stream_sample_done: no sample\n")); 1872 } 1873 1874 vs->vs_frameno ^= 1; 1875 vs->vs_sequence++; 1876 } 1877 1878 /* Check if all buffers are queued, i.e. none are under control of 1879 * userspace. */ 1880 /* 1881 static bool 1882 video_stream_all_queued(struct video_stream *vs) 1883 { 1884 } 1885 */ 1886 1887 1888 static void 1889 scatter_buf_init(struct scatter_buf *sb) 1890 { 1891 sb->sb_pool = pool_cache_init(PAGE_SIZE, 0, 0, 0, 1892 "video", NULL, IPL_VIDEO, 1893 NULL, NULL, NULL); 1894 sb->sb_size = 0; 1895 sb->sb_npages = 0; 1896 sb->sb_page_ary = NULL; 1897 } 1898 1899 static void 1900 scatter_buf_destroy(struct scatter_buf *sb) 1901 { 1902 /* Do we need to return everything to the pool first? */ 1903 scatter_buf_set_size(sb, 0); 1904 pool_cache_destroy(sb->sb_pool); 1905 sb->sb_pool = 0; 1906 sb->sb_npages = 0; 1907 sb->sb_page_ary = NULL; 1908 } 1909 1910 /* Increase or decrease the size of the buffer */ 1911 static int 1912 scatter_buf_set_size(struct scatter_buf *sb, size_t sz) 1913 { 1914 int i; 1915 size_t npages, minpages, oldnpages; 1916 uint8_t **old_ary; 1917 1918 npages = (sz >> PAGE_SHIFT) + ((sz & PAGE_MASK) > 0); 1919 1920 if (sb->sb_npages == npages) { 1921 return 0; 1922 } 1923 1924 oldnpages = sb->sb_npages; 1925 old_ary = sb->sb_page_ary; 1926 1927 sb->sb_npages = npages; 1928 if (npages > 0) { 1929 sb->sb_page_ary = 1930 kmem_alloc(sizeof(uint8_t *) * npages, KM_SLEEP); 1931 if (sb->sb_page_ary == NULL) { 1932 sb->sb_npages = oldnpages; 1933 sb->sb_page_ary = old_ary; 1934 return ENOMEM; 1935 } 1936 } else { 1937 sb->sb_page_ary = NULL; 1938 } 1939 1940 minpages = min(npages, oldnpages); 1941 /* copy any pages that will be reused */ 1942 for (i = 0; i < minpages; ++i) 1943 sb->sb_page_ary[i] = old_ary[i]; 1944 /* allocate any new pages */ 1945 for (; i < npages; ++i) { 1946 sb->sb_page_ary[i] = pool_cache_get(sb->sb_pool, 0); 1947 /* TODO: does pool_cache_get return NULL on 1948 * ENOMEM? If so, we need to release or note 1949 * the pages with did allocate 1950 * successfully. */ 1951 if (sb->sb_page_ary[i] == NULL) { 1952 DPRINTF(("video: pool_cache_get ENOMEM\n")); 1953 return ENOMEM; 1954 } 1955 } 1956 /* return any pages no longer needed */ 1957 for (; i < oldnpages; ++i) 1958 pool_cache_put(sb->sb_pool, old_ary[i]); 1959 1960 if (old_ary != NULL) 1961 kmem_free(old_ary, sizeof(uint8_t *) * oldnpages); 1962 1963 sb->sb_size = sb->sb_npages << PAGE_SHIFT; 1964 1965 return 0; 1966 } 1967 1968 1969 static paddr_t 1970 scatter_buf_map(struct scatter_buf *sb, off_t off) 1971 { 1972 size_t pg; 1973 paddr_t pa; 1974 1975 pg = off >> PAGE_SHIFT; 1976 1977 if (pg >= sb->sb_npages) 1978 return -1; 1979 else if (!pmap_extract(pmap_kernel(), (vaddr_t)sb->sb_page_ary[pg], &pa)) 1980 return -1; 1981 1982 return atop(pa); 1983 } 1984 1985 /* Initialize data for an io operation on a scatter buffer. Returns 1986 * true if the transfer is valid, or false if out of range. */ 1987 static bool 1988 scatter_io_init(struct scatter_buf *sb, 1989 off_t off, size_t len, 1990 struct scatter_io *sio) 1991 { 1992 if ((off + len) > sb->sb_size) { 1993 DPRINTF(("video: scatter_io_init failed: off=%" PRId64 1994 " len=%zu sb->sb_size=%zu\n", 1995 off, len, sb->sb_size)); 1996 return false; 1997 } 1998 1999 sio->sio_buf = sb; 2000 sio->sio_offset = off; 2001 sio->sio_resid = len; 2002 2003 return true; 2004 } 2005 2006 /* Store the pointer and size of the next contiguous segment. Returns 2007 * true if the segment is valid, or false if all has been transfered. 2008 * Does not check for overflow. */ 2009 static bool 2010 scatter_io_next(struct scatter_io *sio, void **p, size_t *sz) 2011 { 2012 size_t pg, pgo; 2013 2014 if (sio->sio_resid == 0) 2015 return false; 2016 2017 pg = sio->sio_offset >> PAGE_SHIFT; 2018 pgo = sio->sio_offset & PAGE_MASK; 2019 2020 *sz = min(PAGE_SIZE - pgo, sio->sio_resid); 2021 *p = sio->sio_buf->sb_page_ary[pg] + pgo; 2022 2023 sio->sio_offset += *sz; 2024 sio->sio_resid -= *sz; 2025 2026 return true; 2027 } 2028 2029 /* Semi-undo of a failed segment copy. Updates the scatter_io 2030 * struct to the previous values prior to a failed segment copy. */ 2031 static void 2032 scatter_io_undo(struct scatter_io *sio, size_t sz) 2033 { 2034 sio->sio_offset -= sz; 2035 sio->sio_resid += sz; 2036 } 2037 2038 /* Copy data from src into the scatter_buf as described by io. */ 2039 static void 2040 scatter_io_copyin(struct scatter_io *sio, const void *p) 2041 { 2042 void *dst; 2043 const uint8_t *src = p; 2044 size_t sz; 2045 2046 while(scatter_io_next(sio, &dst, &sz)) { 2047 memcpy(dst, src, sz); 2048 src += sz; 2049 } 2050 } 2051 2052 /* --not used; commented to avoid compiler warnings-- 2053 static void 2054 scatter_io_copyout(struct scatter_io *sio, void *p) 2055 { 2056 void *src; 2057 uint8_t *dst = p; 2058 size_t sz; 2059 2060 while(scatter_io_next(sio, &src, &sz)) { 2061 memcpy(dst, src, sz); 2062 dst += sz; 2063 } 2064 } 2065 */ 2066 2067 /* Performat a series of uiomove calls on a scatter buf. Returns 2068 * EFAULT if uiomove EFAULTs on the first segment. Otherwise, returns 2069 * an incomplete transfer but with no error. */ 2070 static int 2071 scatter_io_uiomove(struct scatter_io *sio, struct uio *uio) 2072 { 2073 void *p; 2074 size_t sz; 2075 bool first = true; 2076 int err; 2077 2078 while(scatter_io_next(sio, &p, &sz)) { 2079 err = uiomove(p, sz, uio); 2080 if (err == EFAULT) { 2081 scatter_io_undo(sio, sz); 2082 if (first) 2083 return EFAULT; 2084 else 2085 return 0; 2086 } 2087 first = false; 2088 } 2089 2090 return 0; 2091 } 2092 2093 #endif /* NVIDEO > 0 */ 2094
Indexes created Tue Sep 23 02:09:52 GMT 2025