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