1 /* $OpenBSD: utvfu.c,v 1.22 2025/01/15 20:34:50 kirill Exp $ */ 2 /* 3 * Copyright (c) 2013 Lubomir Rintel 4 * Copyright (c) 2013 Federico Simoncelli 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions, and the following disclaimer, 12 * without modification. 13 * 2. The name of the author may not be used to endorse or promote products 14 * derived from this software without specific prior written permission. 15 * 16 * Alternatively, this software may be distributed under the terms of the 17 * GNU General Public License ("GPL"). 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 20 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 21 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 22 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 23 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 24 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 25 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 */ 31 /* 32 * Fushicai USBTV007 Audio-Video Grabber Driver 33 * 34 * Product web site: 35 * http://www.fushicai.com/products_detail/&productId=d05449ee-b690-42f9-a661-aa7353894bed.html 36 * 37 * Following LWN articles were very useful in construction of this driver: 38 * Video4Linux2 API series: http://lwn.net/Articles/203924/ 39 * videobuf2 API explanation: http://lwn.net/Articles/447435/ 40 * Thanks go to Jonathan Corbet for providing this quality documentation. 41 * He is awesome. 42 * 43 * No physical hardware was harmed running Windows during the 44 * reverse-engineering activity 45 */ 46 47 #include <sys/param.h> 48 #include <sys/systm.h> 49 #include <sys/fcntl.h> 50 #include <sys/kthread.h> 51 #include <sys/malloc.h> 52 #include <sys/device.h> 53 54 #include <uvm/uvm_extern.h> 55 56 #include <machine/bus.h> 57 58 #include <dev/usb/usb.h> 59 #include <dev/usb/usbdi.h> 60 #include <dev/usb/usbdivar.h> 61 #include <dev/usb/usb_mem.h> 62 #include <dev/usb/usbdi_util.h> 63 #include <dev/usb/usbdevs.h> 64 #include <dev/usb/utvfu.h> 65 66 #include <dev/audio_if.h> 67 #include <dev/video_if.h> 68 69 #ifdef UTVFU_DEBUG 70 int utvfu_debug = 1; 71 #define DPRINTF(l, x...) do { if ((l) <= utvfu_debug) printf(x); } while (0) 72 #else 73 #define DPRINTF(l, x...) 74 #endif 75 76 #define DEVNAME(_s) ((_s)->sc_dev.dv_xname) 77 78 struct utvfu_norm_params utvfu_norm_params[] = { 79 { 80 .norm = V4L2_STD_525_60, 81 .cap_width = 720, 82 .cap_height = 480, 83 /* 4 bytes/2 pixel YUYV/YUV 4:2:2 */ 84 .frame_len = (720 * 480 * 2), 85 }, 86 { 87 .norm = V4L2_STD_PAL, 88 .cap_width = 720, 89 .cap_height = 576, 90 /* 4 bytes/2 pixel YUYV/YUV 4:2:2 */ 91 .frame_len = (720 * 576 * 2), 92 } 93 }; 94 95 int 96 utvfu_set_regs(struct utvfu_softc *sc, const uint16_t regs[][2], int size) 97 { 98 int i; 99 usbd_status error; 100 usb_device_request_t req; 101 102 req.bmRequestType = UT_WRITE_VENDOR_DEVICE; 103 req.bRequest = UTVFU_REQUEST_REG; 104 USETW(req.wLength, 0); 105 106 for (i = 0; i < size; i++) { 107 USETW(req.wIndex, regs[i][0]); 108 USETW(req.wValue, regs[i][1]); 109 110 error = usbd_do_request(sc->sc_udev, &req, NULL); 111 if (error != USBD_NORMAL_COMPLETION) { 112 DPRINTF(1, "%s: %s: exit EINVAL\n", 113 DEVNAME(sc), __func__); 114 return (EINVAL); 115 } 116 } 117 118 return (0); 119 } 120 121 int 122 utvfu_max_frame_size(void) 123 { 124 int i, sz = 0; 125 126 for (i = 0; i < nitems(utvfu_norm_params); i++) { 127 if (sz < utvfu_norm_params[i].frame_len) 128 sz = utvfu_norm_params[i].frame_len; 129 } 130 131 return (sz); 132 } 133 134 int 135 utvfu_configure_for_norm(struct utvfu_softc *sc, v4l2_std_id norm) 136 { 137 int i, ret = EINVAL; 138 struct utvfu_norm_params *params = NULL; 139 140 for (i = 0; i < nitems(utvfu_norm_params); i++) { 141 if (utvfu_norm_params[i].norm & norm) { 142 params = &utvfu_norm_params[i]; 143 break; 144 } 145 } 146 147 if (params != NULL) { 148 sc->sc_normi = i; 149 sc->sc_nchunks = params->cap_width * params->cap_height 150 / 4 / UTVFU_CHUNK; 151 ret = 0; 152 } 153 154 return (ret); 155 } 156 157 int 158 utvfu_select_input(struct utvfu_softc *sc, int input) 159 { 160 int ret; 161 162 static const uint16_t composite[][2] = { 163 { UTVFU_BASE + 0x0105, 0x0060 }, 164 { UTVFU_BASE + 0x011f, 0x00f2 }, 165 { UTVFU_BASE + 0x0127, 0x0060 }, 166 { UTVFU_BASE + 0x00ae, 0x0010 }, 167 { UTVFU_BASE + 0x0239, 0x0060 }, 168 }; 169 170 static const uint16_t svideo[][2] = { 171 { UTVFU_BASE + 0x0105, 0x0010 }, 172 { UTVFU_BASE + 0x011f, 0x00ff }, 173 { UTVFU_BASE + 0x0127, 0x0060 }, 174 { UTVFU_BASE + 0x00ae, 0x0030 }, 175 { UTVFU_BASE + 0x0239, 0x0060 }, 176 }; 177 178 switch (input) { 179 case UTVFU_COMPOSITE_INPUT: 180 ret = utvfu_set_regs(sc, composite, nitems(composite)); 181 break; 182 case UTVFU_SVIDEO_INPUT: 183 ret = utvfu_set_regs(sc, svideo, nitems(svideo)); 184 break; 185 default: 186 ret = EINVAL; 187 } 188 189 if (ret == 0) 190 sc->sc_input = input; 191 192 return (ret); 193 } 194 195 int 196 utvfu_select_norm(struct utvfu_softc *sc, v4l2_std_id norm) 197 { 198 int ret; 199 static const uint16_t pal[][2] = { 200 { UTVFU_BASE + 0x001a, 0x0068 }, 201 { UTVFU_BASE + 0x010e, 0x0072 }, 202 { UTVFU_BASE + 0x010f, 0x00a2 }, 203 { UTVFU_BASE + 0x0112, 0x00b0 }, 204 { UTVFU_BASE + 0x0117, 0x0001 }, 205 { UTVFU_BASE + 0x0118, 0x002c }, 206 { UTVFU_BASE + 0x012d, 0x0010 }, 207 { UTVFU_BASE + 0x012f, 0x0020 }, 208 { UTVFU_BASE + 0x024f, 0x0002 }, 209 { UTVFU_BASE + 0x0254, 0x0059 }, 210 { UTVFU_BASE + 0x025a, 0x0016 }, 211 { UTVFU_BASE + 0x025b, 0x0035 }, 212 { UTVFU_BASE + 0x0263, 0x0017 }, 213 { UTVFU_BASE + 0x0266, 0x0016 }, 214 { UTVFU_BASE + 0x0267, 0x0036 } 215 }; 216 217 static const uint16_t ntsc[][2] = { 218 { UTVFU_BASE + 0x001a, 0x0079 }, 219 { UTVFU_BASE + 0x010e, 0x0068 }, 220 { UTVFU_BASE + 0x010f, 0x009c }, 221 { UTVFU_BASE + 0x0112, 0x00f0 }, 222 { UTVFU_BASE + 0x0117, 0x0000 }, 223 { UTVFU_BASE + 0x0118, 0x00fc }, 224 { UTVFU_BASE + 0x012d, 0x0004 }, 225 { UTVFU_BASE + 0x012f, 0x0008 }, 226 { UTVFU_BASE + 0x024f, 0x0001 }, 227 { UTVFU_BASE + 0x0254, 0x005f }, 228 { UTVFU_BASE + 0x025a, 0x0012 }, 229 { UTVFU_BASE + 0x025b, 0x0001 }, 230 { UTVFU_BASE + 0x0263, 0x001c }, 231 { UTVFU_BASE + 0x0266, 0x0011 }, 232 { UTVFU_BASE + 0x0267, 0x0005 } 233 }; 234 235 ret = utvfu_configure_for_norm(sc, norm); 236 237 if (ret == 0) { 238 if (norm & V4L2_STD_525_60) 239 ret = utvfu_set_regs(sc, ntsc, nitems(ntsc)); 240 else if (norm & V4L2_STD_PAL) 241 ret = utvfu_set_regs(sc, pal, nitems(pal)); 242 } 243 244 return (ret); 245 } 246 247 int 248 utvfu_setup_capture(struct utvfu_softc *sc) 249 { 250 int ret; 251 static const uint16_t setup[][2] = { 252 /* These seem to enable the device. */ 253 { UTVFU_BASE + 0x0008, 0x0001 }, 254 { UTVFU_BASE + 0x01d0, 0x00ff }, 255 { UTVFU_BASE + 0x01d9, 0x0002 }, 256 257 /* 258 * These seem to influence color parameters, such as 259 * brightness, etc. 260 */ 261 { UTVFU_BASE + 0x0239, 0x0040 }, 262 { UTVFU_BASE + 0x0240, 0x0000 }, 263 { UTVFU_BASE + 0x0241, 0x0000 }, 264 { UTVFU_BASE + 0x0242, 0x0002 }, 265 { UTVFU_BASE + 0x0243, 0x0080 }, 266 { UTVFU_BASE + 0x0244, 0x0012 }, 267 { UTVFU_BASE + 0x0245, 0x0090 }, 268 { UTVFU_BASE + 0x0246, 0x0000 }, 269 270 { UTVFU_BASE + 0x0278, 0x002d }, 271 { UTVFU_BASE + 0x0279, 0x000a }, 272 { UTVFU_BASE + 0x027a, 0x0032 }, 273 { 0xf890, 0x000c }, 274 { 0xf894, 0x0086 }, 275 276 { UTVFU_BASE + 0x00ac, 0x00c0 }, 277 { UTVFU_BASE + 0x00ad, 0x0000 }, 278 { UTVFU_BASE + 0x00a2, 0x0012 }, 279 { UTVFU_BASE + 0x00a3, 0x00e0 }, 280 { UTVFU_BASE + 0x00a4, 0x0028 }, 281 { UTVFU_BASE + 0x00a5, 0x0082 }, 282 { UTVFU_BASE + 0x00a7, 0x0080 }, 283 { UTVFU_BASE + 0x0000, 0x0014 }, 284 { UTVFU_BASE + 0x0006, 0x0003 }, 285 { UTVFU_BASE + 0x0090, 0x0099 }, 286 { UTVFU_BASE + 0x0091, 0x0090 }, 287 { UTVFU_BASE + 0x0094, 0x0068 }, 288 { UTVFU_BASE + 0x0095, 0x0070 }, 289 { UTVFU_BASE + 0x009c, 0x0030 }, 290 { UTVFU_BASE + 0x009d, 0x00c0 }, 291 { UTVFU_BASE + 0x009e, 0x00e0 }, 292 { UTVFU_BASE + 0x0019, 0x0006 }, 293 { UTVFU_BASE + 0x008c, 0x00ba }, 294 { UTVFU_BASE + 0x0101, 0x00ff }, 295 { UTVFU_BASE + 0x010c, 0x00b3 }, 296 { UTVFU_BASE + 0x01b2, 0x0080 }, 297 { UTVFU_BASE + 0x01b4, 0x00a0 }, 298 { UTVFU_BASE + 0x014c, 0x00ff }, 299 { UTVFU_BASE + 0x014d, 0x00ca }, 300 { UTVFU_BASE + 0x0113, 0x0053 }, 301 { UTVFU_BASE + 0x0119, 0x008a }, 302 { UTVFU_BASE + 0x013c, 0x0003 }, 303 { UTVFU_BASE + 0x0150, 0x009c }, 304 { UTVFU_BASE + 0x0151, 0x0071 }, 305 { UTVFU_BASE + 0x0152, 0x00c6 }, 306 { UTVFU_BASE + 0x0153, 0x0084 }, 307 { UTVFU_BASE + 0x0154, 0x00bc }, 308 { UTVFU_BASE + 0x0155, 0x00a0 }, 309 { UTVFU_BASE + 0x0156, 0x00a0 }, 310 { UTVFU_BASE + 0x0157, 0x009c }, 311 { UTVFU_BASE + 0x0158, 0x001f }, 312 { UTVFU_BASE + 0x0159, 0x0006 }, 313 { UTVFU_BASE + 0x015d, 0x0000 }, 314 315 { UTVFU_BASE + 0x0003, 0x0004 }, 316 { UTVFU_BASE + 0x0100, 0x00d3 }, 317 { UTVFU_BASE + 0x0115, 0x0015 }, 318 { UTVFU_BASE + 0x0220, 0x002e }, 319 { UTVFU_BASE + 0x0225, 0x0008 }, 320 { UTVFU_BASE + 0x024e, 0x0002 }, 321 { UTVFU_BASE + 0x024e, 0x0002 }, 322 { UTVFU_BASE + 0x024f, 0x0002 }, 323 }; 324 325 ret = utvfu_set_regs(sc, setup, nitems(setup)); 326 if (ret) 327 return (ret); 328 329 ret = utvfu_select_norm(sc, utvfu_norm_params[sc->sc_normi].norm); 330 if (ret) 331 return (ret); 332 333 ret = utvfu_select_input(sc, sc->sc_input); 334 if (ret) 335 return (ret); 336 337 return (0); 338 } 339 340 /* 341 * Copy data from chunk into a frame buffer, deinterlacing the data 342 * into every second line. Unfortunately, they don't align nicely into 343 * 720 pixel lines, as the chunk is 240 words long, which is 480 pixels. 344 * Therefore, we break down the chunk into two halves before copying, 345 * so that we can interleave a line if needed. 346 * 347 * Each "chunk" is 240 words; a word in this context equals 4 bytes. 348 * Image format is YUYV/YUV 4:2:2, consisting of Y Cr Y Cb, defining two 349 * pixels, the Cr and Cb shared between the two pixels, but each having 350 * separate Y values. Thus, the 240 words equal 480 pixels. It therefore, 351 * takes 1.5 chunks to make a 720 pixel-wide line for the frame. 352 * The image is interlaced, so there is a "scan" of odd lines, followed 353 * by "scan" of even numbered lines. 354 * 355 * Following code is writing the chunks in correct sequence, skipping 356 * the rows based on "odd" value. 357 * line 1: chunk[0][ 0..479] chunk[0][480..959] chunk[1][ 0..479] 358 * line 3: chunk[1][480..959] chunk[2][ 0..479] chunk[2][480..959] 359 * ...etc 360 */ 361 void 362 utvfu_chunk_to_vbuf(uint8_t *frame, uint8_t *src, int chunk_no, int odd) 363 { 364 uint8_t *dst; 365 int half, line, part_no, part_index; 366 #define UTVFU_STRIDE (UTVFU_CHUNK/2 * 4) 367 368 for (half = 0; half < 2; half++) { 369 part_no = chunk_no * 2 + half; 370 line = part_no / 3; 371 part_index = (line * 2 + !odd) * 3 + (part_no % 3); 372 373 dst = &frame[part_index * UTVFU_STRIDE]; 374 375 memcpy(dst, src, UTVFU_STRIDE); 376 src += UTVFU_STRIDE; 377 } 378 #undef UTVFU_STRIDE 379 } 380 381 /* 382 * Called for each 256-byte image chunk. 383 * First word identifies the chunk, followed by 240 words of image 384 * data and padding. 385 */ 386 void 387 utvfu_image_chunk(struct utvfu_softc *sc, u_char *chunk) 388 { 389 int frame_id, odd, chunk_no, frame_len; 390 uint32_t hdr; 391 392 memcpy(&hdr, chunk, sizeof(hdr)); 393 chunk += sizeof(hdr); 394 hdr = be32toh(hdr); 395 396 /* Ignore corrupted lines. */ 397 if (!UTVFU_MAGIC_OK(hdr)) { 398 DPRINTF(2, "%s: bad magic=0x%08x\n", 399 DEVNAME(sc), UTVFU_MAGIC(hdr)); 400 return; 401 } 402 403 frame_id = UTVFU_FRAME_ID(hdr); 404 odd = UTVFU_ODD(hdr); 405 chunk_no = UTVFU_CHUNK_NO(hdr); 406 if (chunk_no >= sc->sc_nchunks) { 407 DPRINTF(2, "%s: chunk_no=%d >= sc_nchunks=%d\n", 408 DEVNAME(sc), chunk_no, sc->sc_nchunks); 409 return; 410 } 411 412 /* Beginning of a frame. */ 413 if (chunk_no == 0) { 414 sc->sc_fb.fid = frame_id; 415 sc->sc_fb.chunks_done = 0; 416 } 417 else if (sc->sc_fb.fid != frame_id) { 418 DPRINTF(2, "%s: frame id mismatch expecting=%d got=%d\n", 419 DEVNAME(sc), sc->sc_fb.fid, frame_id); 420 return; 421 } 422 423 frame_len = utvfu_norm_params[sc->sc_normi].frame_len; 424 425 /* Copy the chunk data. */ 426 utvfu_chunk_to_vbuf(sc->sc_fb.buf, chunk, chunk_no, odd); 427 sc->sc_fb.chunks_done++; 428 429 /* Last chunk in a field */ 430 if (chunk_no == sc->sc_nchunks-1) { 431 /* Last chunk in a frame, signalling an end */ 432 if (odd && !sc->sc_fb.last_odd) { 433 if (sc->sc_fb.chunks_done != sc->sc_nchunks) { 434 DPRINTF(1, "%s: chunks_done=%d != nchunks=%d\n", 435 DEVNAME(sc), 436 sc->sc_fb.chunks_done, sc->sc_nchunks); 437 } 438 439 if (sc->sc_flags & UTVFU_FLAG_MMAP) { 440 utvfu_mmap_queue(sc, sc->sc_fb.buf, frame_len); 441 } 442 else { 443 utvfu_read(sc, sc->sc_fb.buf, frame_len); 444 } 445 } 446 sc->sc_fb.last_odd = odd; 447 } 448 } 449 450 int 451 utvfu_start_capture(struct utvfu_softc *sc) 452 { 453 usbd_status error; 454 int restart_au; 455 456 DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__); 457 458 restart_au = ISSET(sc->sc_flags, UTVFU_FLAG_AS_RUNNING); 459 utvfu_audio_stop(sc); 460 461 /* default video stream interface */ 462 error = usbd_set_interface(sc->sc_uifaceh, UTVFU_DFLT_IFACE_IDX); 463 if (error != USBD_NORMAL_COMPLETION) 464 return (EINVAL); 465 466 if (utvfu_setup_capture(sc) != 0) 467 return (EINVAL); 468 469 /* alt setting */ 470 error = usbd_set_interface(sc->sc_uifaceh, UTVFU_ALT_IFACE_IDX); 471 if (error != USBD_NORMAL_COMPLETION) 472 return (EINVAL); 473 474 if (restart_au) 475 utvfu_audio_start(sc); 476 477 return (0); 478 } 479 480 int 481 utvfu_querycap(void *v, struct v4l2_capability *cap) 482 { 483 struct utvfu_softc *sc = v; 484 485 memset(cap, 0, sizeof(*cap)); 486 strlcpy(cap->driver, DEVNAME(sc), sizeof(cap->driver)); 487 strlcpy(cap->card, "utvfu", sizeof(cap->card)); 488 strlcpy(cap->bus_info, "usb", sizeof(cap->bus_info)); 489 cap->device_caps = V4L2_CAP_VIDEO_CAPTURE; 490 cap->device_caps |= V4L2_CAP_READWRITE | V4L2_CAP_STREAMING; 491 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS; 492 493 return (0); 494 } 495 496 int 497 utvfu_enum_input(void *v, struct v4l2_input *i) 498 { 499 struct utvfu_softc *sc = v; 500 501 switch (i->index) { 502 case UTVFU_COMPOSITE_INPUT: 503 strlcpy(i->name, "Composite", sizeof(i->name)); 504 break; 505 case UTVFU_SVIDEO_INPUT: 506 strlcpy(i->name, "S-Video", sizeof(i->name)); 507 break; 508 default: 509 return (EINVAL); 510 } 511 512 i->type = V4L2_INPUT_TYPE_CAMERA; 513 i->std = utvfu_norm_params[sc->sc_normi].norm; 514 515 return (0); 516 } 517 518 int 519 utvfu_enum_fmt_vid_cap(void *v, struct v4l2_fmtdesc *f) 520 { 521 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE || f->index != 0) 522 return (EINVAL); 523 524 strlcpy(f->description, "16 bpp YUY2, 4:2:2, packed", 525 sizeof(f->description)); 526 f->pixelformat = V4L2_PIX_FMT_YUYV; 527 528 return (0); 529 } 530 531 int 532 utvfu_enum_fsizes(void *v, struct v4l2_frmsizeenum *fsizes) 533 { 534 struct utvfu_softc *sc = v; 535 536 if (fsizes->pixel_format != V4L2_PIX_FMT_YUYV) 537 return (EINVAL); 538 539 /* The device only supports one frame size. */ 540 if (fsizes->index >= 1) 541 return (EINVAL); 542 543 fsizes->type = V4L2_FRMSIZE_TYPE_DISCRETE; 544 fsizes->discrete.width = utvfu_norm_params[sc->sc_normi].cap_width; 545 fsizes->discrete.height = utvfu_norm_params[sc->sc_normi].cap_height; 546 547 return (0); 548 } 549 550 int 551 utvfu_g_fmt(void *v, struct v4l2_format *f) 552 { 553 struct utvfu_softc *sc = v; 554 555 f->fmt.pix.width = utvfu_norm_params[sc->sc_normi].cap_width; 556 f->fmt.pix.height = utvfu_norm_params[sc->sc_normi].cap_height; 557 f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV; 558 f->fmt.pix.field = V4L2_FIELD_INTERLACED; 559 f->fmt.pix.bytesperline = f->fmt.pix.width * 2; 560 f->fmt.pix.sizeimage = (f->fmt.pix.bytesperline * f->fmt.pix.height); 561 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 562 563 return (0); 564 } 565 566 int 567 utvfu_s_fmt(void *v, struct v4l2_format *f) 568 { 569 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV) 570 return (EINVAL); 571 572 return (0); 573 } 574 575 int 576 utvfu_g_std(void *v, v4l2_std_id *norm) 577 { 578 struct utvfu_softc *sc = v; 579 580 *norm = utvfu_norm_params[sc->sc_normi].norm; 581 582 return (0); 583 } 584 585 int 586 utvfu_s_std(void *v, v4l2_std_id norm) 587 { 588 int ret = EINVAL; 589 struct utvfu_softc *sc = v; 590 591 if ((norm & V4L2_STD_525_60) || (norm & V4L2_STD_PAL)) 592 ret = utvfu_select_norm(sc, norm); 593 594 return (ret); 595 } 596 597 int 598 utvfu_g_input(void *v, int *i) 599 { 600 struct utvfu_softc *sc = v; 601 602 *i = sc->sc_input; 603 604 return (0); 605 } 606 607 int 608 utvfu_s_input(void *v, int i) 609 { 610 return utvfu_select_input(v, i); 611 } 612 613 /* A U D I O */ 614 615 void 616 utvfu_audio_decode(struct utvfu_softc *sc, int len) 617 { 618 uint8_t *dst, *src; 619 int n, chunk, ncopied; 620 621 if (sc->sc_audio.blksize == 0) 622 return; 623 624 src = KERNADDR(&sc->sc_audio.iface.xfer->dmabuf, 0); 625 dst = sc->sc_audio.cur; 626 ncopied = sc->sc_audio.cur - sc->sc_audio.start; 627 /* b/c region start->end is a multiple blksize chunks */ 628 ncopied %= sc->sc_audio.blksize; 629 630 while (len >= UTVFU_CHUNK_SIZE) { 631 /* 632 * The header, skipped here, ranges from 0xdd000000 to 633 * 0xdd0003ff. The 0xdd seems to be the "magic" and 634 * 0x3ff masks the chunk number. 635 */ 636 src += UTVFU_AUDIO_HDRSIZE; 637 chunk = UTVFU_CHUNK; 638 while (chunk > 0) { 639 n = min(chunk, sc->sc_audio.blksize - ncopied); 640 memcpy(dst, src, n); 641 dst += n; 642 src += n; 643 chunk -= n; 644 ncopied += n; 645 if (ncopied >= sc->sc_audio.blksize) { 646 mtx_enter(&audio_lock); 647 (*sc->sc_audio.intr)(sc->sc_audio.intr_arg); 648 mtx_leave(&audio_lock); 649 ncopied -= sc->sc_audio.blksize; 650 } 651 if (dst > sc->sc_audio.end) 652 dst = sc->sc_audio.start; 653 } 654 len -= UTVFU_CHUNK_SIZE; /* _CHUNK + _AUDIO_HDRSIZE */ 655 } 656 sc->sc_audio.cur = dst; 657 } 658 659 int 660 utvfu_audio_start_chip(struct utvfu_softc *sc) 661 { 662 static const uint16_t setup[][2] = { 663 /* These seem to enable the device. */ 664 { UTVFU_BASE + 0x0008, 0x0001 }, 665 { UTVFU_BASE + 0x01d0, 0x00ff }, 666 { UTVFU_BASE + 0x01d9, 0x0002 }, 667 668 { UTVFU_BASE + 0x01da, 0x0013 }, 669 { UTVFU_BASE + 0x01db, 0x0012 }, 670 { UTVFU_BASE + 0x01e9, 0x0002 }, 671 { UTVFU_BASE + 0x01ec, 0x006c }, 672 { UTVFU_BASE + 0x0294, 0x0020 }, 673 { UTVFU_BASE + 0x0255, 0x00cf }, 674 { UTVFU_BASE + 0x0256, 0x0020 }, 675 { UTVFU_BASE + 0x01eb, 0x0030 }, 676 { UTVFU_BASE + 0x027d, 0x00a6 }, 677 { UTVFU_BASE + 0x0280, 0x0011 }, 678 { UTVFU_BASE + 0x0281, 0x0040 }, 679 { UTVFU_BASE + 0x0282, 0x0011 }, 680 { UTVFU_BASE + 0x0283, 0x0040 }, 681 { 0xf891, 0x0010 }, 682 683 /* this sets the input from composite */ 684 { UTVFU_BASE + 0x0284, 0x00aa }, 685 }; 686 687 /* starting the stream */ 688 utvfu_set_regs(sc, setup, nitems(setup)); 689 690 return (0); 691 } 692 693 int 694 utvfu_audio_stop_chip(struct utvfu_softc *sc) 695 { 696 static const uint16_t setup[][2] = { 697 /* 698 * The original windows driver sometimes sends also: 699 * { UTVFU_BASE + 0x00a2, 0x0013 } 700 * but it seems useless and its real effects are untested at 701 * the moment. 702 */ 703 { UTVFU_BASE + 0x027d, 0x0000 }, 704 { UTVFU_BASE + 0x0280, 0x0010 }, 705 { UTVFU_BASE + 0x0282, 0x0010 }, 706 }; 707 708 utvfu_set_regs(sc, setup, nitems(setup)); 709 710 return (0); 711 } 712 713 /* 714 * Copyright (c) 2008 Robert Nagy <robert@openbsd.org> 715 * Copyright (c) 2008 Marcus Glocker <mglocker@openbsd.org> 716 * Copyright (c) 2016 Patrick Keshishian <patrick@boxsoft.com> 717 * 718 * Permission to use, copy, modify, and distribute this software for any 719 * purpose with or without fee is hereby granted, provided that the above 720 * copyright notice and this permission notice appear in all copies. 721 * 722 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 723 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 724 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 725 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 726 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 727 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 728 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 729 */ 730 /* 731 * Heavily based on uvideo.c source. 732 */ 733 734 int utvfu_match(struct device *, void *, void *); 735 void utvfu_attach(struct device *, struct device *, void *); 736 int utvfu_detach(struct device *, int); 737 738 usbd_status utvfu_parse_desc(struct utvfu_softc *); 739 740 void utvfu_vs_close(struct utvfu_softc *); 741 void utvfu_vs_free_frame(struct utvfu_softc *); 742 void utvfu_vs_free_isoc(struct utvfu_softc *); 743 void utvfu_vs_start_isoc_ixfer(struct utvfu_softc *, 744 struct utvfu_isoc_xfer *); 745 void utvfu_vs_cb(struct usbd_xfer *, void *, usbd_status); 746 747 void utvfu_vs_free(struct utvfu_softc *); 748 int utvfu_vs_init(struct utvfu_softc *); 749 int utvfu_vs_alloc_frame(struct utvfu_softc *); 750 usbd_status utvfu_vs_alloc_isoc(struct utvfu_softc *); 751 752 int utvfu_open(void *, int, int *, uint8_t *, 753 void (*)(void *), void *); 754 int utvfu_close(void *); 755 int utvfu_querycap(void *, struct v4l2_capability *); 756 int utvfu_enum_fmt_vid_cap(void *, struct v4l2_fmtdesc *); 757 int utvfu_enum_fsizes(void *, struct v4l2_frmsizeenum *); 758 int utvfu_g_fmt(void *, struct v4l2_format *); 759 int utvfu_s_fmt(void *, struct v4l2_format *); 760 int utvfu_g_parm(void *, struct v4l2_streamparm *); 761 int utvfu_s_parm(void *, struct v4l2_streamparm *); 762 int utvfu_enum_input(void *, struct v4l2_input *); 763 int utvfu_s_input(void *, int); 764 int utvfu_g_input(void *, int *); 765 766 int utvfu_reqbufs(void *, struct v4l2_requestbuffers *); 767 int utvfu_querybuf(void *, struct v4l2_buffer *); 768 int utvfu_qbuf(void *, struct v4l2_buffer *); 769 int utvfu_dqbuf(void *, struct v4l2_buffer *); 770 int utvfu_streamon(void *, int); 771 int utvfu_streamoff(void *, int); 772 int utvfu_queryctrl(void *, struct v4l2_queryctrl *); 773 caddr_t utvfu_mappage(void *, off_t, int); 774 int utvfu_get_bufsize(void *); 775 int utvfu_start_read(void *); 776 777 int utvfu_as_init(struct utvfu_softc *); 778 void utvfu_as_free(struct utvfu_softc *); 779 780 usbd_status utvfu_as_open(struct utvfu_softc *); 781 int utvfu_as_alloc_bulk(struct utvfu_softc *); 782 void utvfu_as_free_bulk(struct utvfu_softc *); 783 int utvfu_as_start_bulk(struct utvfu_softc *); 784 void utvfu_as_bulk_thread(void *); 785 786 int utvfu_audio_open(void *, int); 787 void utvfu_audio_close(void *); 788 int utvfu_audio_set_params(void *, int, int, 789 struct audio_params *, struct audio_params *); 790 int utvfu_audio_halt_out(void *); 791 int utvfu_audio_halt_in(void *); 792 int utvfu_audio_mixer_set_port(void *, struct mixer_ctrl *); 793 int utvfu_audio_mixer_get_port(void *, struct mixer_ctrl *); 794 int utvfu_audio_query_devinfo(void *, struct mixer_devinfo *); 795 int utvfu_audio_trigger_output(void *, void *, void *, int, 796 void (*)(void *), void *, struct audio_params *); 797 int utvfu_audio_trigger_input(void *, void *, void *, int, 798 void (*)(void *), void *, struct audio_params *); 799 800 struct cfdriver utvfu_cd = { 801 NULL, "utvfu", DV_DULL 802 }; 803 804 const struct cfattach utvfu_ca = { 805 sizeof(struct utvfu_softc), 806 utvfu_match, 807 utvfu_attach, 808 utvfu_detach, 809 NULL 810 }; 811 812 const struct video_hw_if utvfu_vid_hw_if = { 813 utvfu_open, /* open */ 814 utvfu_close, /* close */ 815 utvfu_querycap, /* VIDIOC_QUERYCAP */ 816 utvfu_enum_fmt_vid_cap, /* VIDIOC_ENUM_FMT */ 817 utvfu_enum_fsizes, /* VIDIOC_ENUM_FRAMESIZES */ 818 NULL, /* VIDIOC_ENUM_FRAMEINTERVALS */ 819 utvfu_s_fmt, /* VIDIOC_S_FMT */ 820 utvfu_g_fmt, /* VIDIOC_G_FMT */ 821 utvfu_s_parm, /* VIDIOC_S_PARM */ 822 utvfu_g_parm, /* VIDIOC_G_PARM */ 823 utvfu_enum_input, /* VIDIOC_ENUMINPUT */ 824 utvfu_s_input, /* VIDIOC_S_INPUT */ 825 utvfu_g_input, /* VIDIOC_G_INPUT */ 826 utvfu_reqbufs, /* VIDIOC_REQBUFS */ 827 utvfu_querybuf, /* VIDIOC_QUERYBUF */ 828 utvfu_qbuf, /* VIDIOC_QBUF */ 829 utvfu_dqbuf, /* VIDIOC_DQBUF */ 830 utvfu_streamon, /* VIDIOC_STREAMON */ 831 utvfu_streamoff, /* VIDIOC_STREAMOFF */ 832 NULL, /* VIDIOC_TRY_FMT */ 833 utvfu_queryctrl, /* VIDIOC_QUERYCTRL */ 834 NULL, /* VIDIOC_G_CTRL */ 835 NULL, /* VIDIOC_S_CTRL */ 836 utvfu_mappage, /* mmap */ 837 utvfu_get_bufsize, /* read */ 838 utvfu_start_read /* start stream for read */ 839 }; 840 841 const struct audio_hw_if utvfu_au_hw_if = { 842 .open = utvfu_audio_open, 843 .close = utvfu_audio_close, 844 .set_params = utvfu_audio_set_params, 845 .halt_output = utvfu_audio_halt_out, 846 .halt_input = utvfu_audio_halt_in, 847 .set_port = utvfu_audio_mixer_set_port, 848 .get_port = utvfu_audio_mixer_get_port, 849 .query_devinfo = utvfu_audio_query_devinfo, 850 .trigger_output = utvfu_audio_trigger_output, 851 .trigger_input = utvfu_audio_trigger_input, 852 }; 853 854 int 855 utvfu_match(struct device *parent, void *match, void *aux) 856 { 857 struct usb_attach_arg *uaa = aux; 858 const struct usb_descriptor *ud; 859 struct usbd_desc_iter iter; 860 struct usb_interface_descriptor *uid = NULL; 861 const struct usb_endpoint_descriptor *ued = NULL; 862 usb_device_descriptor_t *dd; 863 int ret = UMATCH_NONE; 864 int nep, nalt; 865 uint16_t psize = 0; 866 867 if (uaa->iface == NULL) 868 return ret; 869 870 dd = usbd_get_device_descriptor(uaa->device); 871 872 if (UGETW(dd->idVendor) == USB_VENDOR_FUSHICAI && 873 UGETW(dd->idProduct) == USB_PRODUCT_FUSHICAI_USBTV007) 874 ret = UMATCH_VENDOR_PRODUCT; 875 /* 876 * This seems like a fragile check, but the original driver ensures 877 * there are two alternate settings for the interface, and alternate 878 * setting 1 has four endpoints. 879 * 880 * Comment says "Checks that the device is what we think it is." 881 * 882 * Adding check that wMaxPacketSize for the video endpoint is > 0. 883 */ 884 nep = nalt = 0; 885 usbd_desc_iter_init(uaa->device, &iter); 886 while ((ud = usbd_desc_iter_next(&iter)) != NULL) { 887 switch (ud->bDescriptorType) { 888 default: 889 break; 890 case UDESC_INTERFACE: 891 uid = (void *)ud; 892 if (uid->bInterfaceNumber == 0) 893 nalt++; 894 break; 895 case UDESC_ENDPOINT: 896 if (uid->bAlternateSetting == 1) { 897 ued = (void *)ud; 898 if (ued->bEndpointAddress == UTVFU_VIDEO_ENDP) 899 psize = UGETW(ued->wMaxPacketSize); 900 nep++; 901 } 902 break; 903 } 904 if (uid != NULL && uid->bInterfaceNumber > 0) 905 break; 906 } 907 908 if (nalt != 2 || nep != 4 || psize == 0) 909 ret = UMATCH_NONE; 910 911 return (ret); 912 } 913 914 void 915 utvfu_attach(struct device *parent, struct device *self, void *aux) 916 { 917 int i; 918 struct utvfu_softc *sc = (struct utvfu_softc *)self; 919 struct usb_attach_arg *uaa = aux; 920 921 sc->sc_udev = uaa->device; 922 for (i = 0; i < uaa->nifaces; i++) { 923 if (usbd_iface_claimed(sc->sc_udev, i)) 924 continue; 925 usbd_claim_iface(sc->sc_udev, i); 926 } 927 928 utvfu_parse_desc(sc); 929 930 /* init mmap queue */ 931 SIMPLEQ_INIT(&sc->sc_mmap_q); 932 sc->sc_mmap_count = 0; 933 934 sc->sc_max_frame_sz = utvfu_max_frame_size(); 935 936 /* calculate optimal isoc xfer size */ 937 sc->sc_nframes = (sc->sc_max_frame_sz + sc->sc_iface.psize - 1) 938 / sc->sc_iface.psize; 939 if (sc->sc_nframes > UTVFU_NFRAMES_MAX) 940 sc->sc_nframes = UTVFU_NFRAMES_MAX; 941 DPRINTF(1, "%s: nframes=%d\n", DEVNAME(sc), sc->sc_nframes); 942 943 rw_init(&sc->sc_audio.rwlock, "audiorwl"); 944 945 sc->sc_audiodev = audio_attach_mi(&utvfu_au_hw_if, sc, NULL, &sc->sc_dev); 946 sc->sc_videodev = video_attach_mi(&utvfu_vid_hw_if, sc, &sc->sc_dev); 947 } 948 949 int 950 utvfu_detach(struct device *self, int flags) 951 { 952 struct utvfu_softc *sc = (struct utvfu_softc *)self; 953 int rv = 0; 954 955 /* Wait for outstanding requests to complete */ 956 usbd_delay_ms(sc->sc_udev, UTVFU_NFRAMES_MAX); /* XXX meh? */ 957 958 if (sc->sc_videodev != NULL) 959 rv = config_detach(sc->sc_videodev, flags); 960 961 if (sc->sc_audiodev != NULL) 962 rv += config_detach(sc->sc_audiodev, flags); 963 964 utvfu_as_free(sc); 965 utvfu_vs_free(sc); 966 967 sc->sc_flags = 0; 968 969 return (rv); 970 } 971 972 usbd_status 973 utvfu_parse_desc(struct utvfu_softc *sc) 974 { 975 int nif, nep; 976 uint32_t psize; 977 struct usbd_desc_iter iter; 978 const struct usb_descriptor *ud; 979 struct usb_endpoint_descriptor *ued; 980 struct usb_interface_descriptor *uid = NULL; 981 982 nif = nep = 0; 983 usbd_desc_iter_init(sc->sc_udev, &iter); 984 while ((ud = usbd_desc_iter_next(&iter)) != NULL) { 985 if (ud->bDescriptorType != UDESC_INTERFACE) 986 continue; 987 /* looking for interface 0, alt-setting 1 */ 988 uid = (void *)ud; 989 if (uid->bInterfaceNumber > 0) 990 break; 991 if (uid->bAlternateSetting == 1) 992 break; 993 } 994 995 /* this should not fail as it was ensured during match */ 996 if (uid == NULL || uid->bInterfaceNumber != 0 || 997 uid->bAlternateSetting != 1) { 998 printf("%s: no valid alternate interface found!\n", 999 DEVNAME(sc)); 1000 return (USBD_INVAL); 1001 } 1002 1003 /* bInterfaceNumber = 0 */ 1004 sc->sc_uifaceh = &sc->sc_udev->ifaces[0]; 1005 1006 /* looking for video endpoint to on alternate setting 1 */ 1007 while ((ud = usbd_desc_iter_next(&iter)) != NULL) { 1008 if (ud->bDescriptorType != UDESC_ENDPOINT) 1009 break; 1010 1011 ued = (void *)ud; 1012 if (ued->bEndpointAddress != UTVFU_VIDEO_ENDP) 1013 continue; 1014 1015 psize = UGETW(ued->wMaxPacketSize); 1016 psize = UE_GET_SIZE(psize) * (1 + UE_GET_TRANS(psize)); 1017 sc->sc_iface.psize = psize; 1018 break; 1019 } 1020 1021 return (USBD_NORMAL_COMPLETION); 1022 } 1023 1024 int 1025 utvfu_open(void *addr, int flags, int *size, uint8_t *buffer, 1026 void (*intr)(void *), void *arg) 1027 { 1028 struct utvfu_softc *sc = addr; 1029 int rv; 1030 1031 DPRINTF(1, "%s: utvfu_open: sc=%p\n", DEVNAME(sc), sc); 1032 1033 if (usbd_is_dying(sc->sc_udev)) 1034 return (EIO); 1035 1036 if ((rv = utvfu_vs_init(sc)) != 0) 1037 return (rv); 1038 1039 /* pointers to upper video layer */ 1040 sc->sc_uplayer_arg = arg; 1041 sc->sc_uplayer_fsize = size; 1042 sc->sc_uplayer_fbuffer = buffer; 1043 sc->sc_uplayer_intr = intr; 1044 1045 sc->sc_flags &= ~UTVFU_FLAG_MMAP; 1046 1047 return (0); 1048 } 1049 1050 int 1051 utvfu_close(void *addr) 1052 { 1053 struct utvfu_softc *sc = addr; 1054 1055 DPRINTF(1, "%s: utvfu_close: sc=%p\n", DEVNAME(sc), sc); 1056 1057 /* free & clean up video stream */ 1058 utvfu_vs_free(sc); 1059 1060 return (0); 1061 } 1062 1063 usbd_status 1064 utvfu_as_open(struct utvfu_softc *sc) 1065 { 1066 usb_endpoint_descriptor_t *ed; 1067 usbd_status error; 1068 1069 DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__); 1070 1071 if (sc->sc_audio.iface.pipeh != NULL) { 1072 printf("%s: %s called while sc_audio.iface.pipeh not NULL\n", 1073 DEVNAME(sc), __func__); 1074 return (USBD_INVAL); 1075 } 1076 1077 ed = usbd_get_endpoint_descriptor(sc->sc_uifaceh, UTVFU_AUDIO_ENDP); 1078 if (ed == NULL) { 1079 printf("%s: no endpoint descriptor for AS iface\n", 1080 DEVNAME(sc)); 1081 return (USBD_INVAL); 1082 } 1083 DPRINTF(1, "%s: open pipe for ", DEVNAME(sc)); 1084 DPRINTF(1, "bEndpointAddress=0x%02x (0x%02x), wMaxPacketSize=" 1085 "0x%04x (%d)\n", 1086 UE_GET_ADDR(ed->bEndpointAddress), 1087 UTVFU_AUDIO_ENDP, 1088 UGETW(ed->wMaxPacketSize), 1089 UE_GET_SIZE(UGETW(ed->wMaxPacketSize)) 1090 * (1 + UE_GET_TRANS(UGETW(ed->wMaxPacketSize)))); 1091 1092 error = usbd_open_pipe( 1093 sc->sc_uifaceh, 1094 UTVFU_AUDIO_ENDP, 1095 USBD_EXCLUSIVE_USE, 1096 &sc->sc_audio.iface.pipeh); 1097 if (error != USBD_NORMAL_COMPLETION) { 1098 printf("%s: could not open AS pipe: %s\n", 1099 DEVNAME(sc), usbd_errstr(error)); 1100 } 1101 1102 return (error); 1103 } 1104 1105 usbd_status 1106 utvfu_vs_open(struct utvfu_softc *sc) 1107 { 1108 usb_endpoint_descriptor_t *ed; 1109 usbd_status error; 1110 1111 DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__); 1112 1113 if (sc->sc_iface.pipeh != NULL) { 1114 printf("%s: %s called while sc_iface.pipeh not NULL\n", 1115 DEVNAME(sc), __func__); 1116 return (USBD_INVAL); 1117 } 1118 1119 ed = usbd_get_endpoint_descriptor(sc->sc_uifaceh, UTVFU_VIDEO_ENDP); 1120 if (ed == NULL) { 1121 printf("%s: no endpoint descriptor for VS iface\n", 1122 DEVNAME(sc)); 1123 return (USBD_INVAL); 1124 } 1125 DPRINTF(1, "%s: open pipe for ", DEVNAME(sc)); 1126 DPRINTF(1, "bEndpointAddress=0x%02x (0x%02x), wMaxPacketSize=" 1127 "0x%04x (%d)\n", 1128 UE_GET_ADDR(ed->bEndpointAddress), 1129 UTVFU_VIDEO_ENDP, 1130 UGETW(ed->wMaxPacketSize), 1131 sc->sc_iface.psize); 1132 1133 error = usbd_open_pipe( 1134 sc->sc_uifaceh, 1135 UTVFU_VIDEO_ENDP, 1136 USBD_EXCLUSIVE_USE, 1137 &sc->sc_iface.pipeh); 1138 if (error != USBD_NORMAL_COMPLETION) { 1139 printf("%s: could not open VS pipe: %s\n", 1140 DEVNAME(sc), usbd_errstr(error)); 1141 } 1142 1143 return (error); 1144 } 1145 1146 void 1147 utvfu_as_close(struct utvfu_softc *sc) 1148 { 1149 DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__); 1150 1151 CLR(sc->sc_flags, UTVFU_FLAG_AS_RUNNING); 1152 1153 if (sc->sc_audio.iface.pipeh != NULL) { 1154 usbd_abort_pipe(sc->sc_audio.iface.pipeh); 1155 1156 usbd_ref_wait(sc->sc_udev); 1157 1158 usbd_close_pipe(sc->sc_audio.iface.pipeh); 1159 sc->sc_audio.iface.pipeh = NULL; 1160 } 1161 } 1162 1163 void 1164 utvfu_vs_close(struct utvfu_softc *sc) 1165 { 1166 if (sc->sc_iface.pipeh != NULL) { 1167 usbd_close_pipe(sc->sc_iface.pipeh); 1168 sc->sc_iface.pipeh = NULL; 1169 } 1170 1171 /* 1172 * Some devices need time to shutdown before we switch back to 1173 * the default interface (0). Not doing so can leave the device 1174 * back in a undefined condition. 1175 */ 1176 usbd_delay_ms(sc->sc_udev, 100); 1177 1178 /* switch back to default interface (turns off cam LED) */ 1179 (void)usbd_set_interface(sc->sc_uifaceh, UTVFU_DFLT_IFACE_IDX); 1180 } 1181 1182 void 1183 utvfu_read(struct utvfu_softc *sc, uint8_t *buf, int len) 1184 { 1185 /* 1186 * Copy video frame to upper layer buffer and call 1187 * upper layer interrupt. 1188 */ 1189 *sc->sc_uplayer_fsize = len; 1190 memcpy(sc->sc_uplayer_fbuffer, buf, len); 1191 (*sc->sc_uplayer_intr)(sc->sc_uplayer_arg); 1192 } 1193 1194 int 1195 utvfu_as_start_bulk(struct utvfu_softc *sc) 1196 { 1197 int error; 1198 1199 if (ISSET(sc->sc_flags, UTVFU_FLAG_AS_RUNNING)) 1200 return (0); 1201 if (sc->sc_audio.iface.pipeh == NULL) 1202 return (ENXIO); 1203 1204 SET(sc->sc_flags, UTVFU_FLAG_AS_RUNNING); 1205 error = kthread_create(utvfu_as_bulk_thread, sc, NULL, DEVNAME(sc)); 1206 if (error) { 1207 CLR(sc->sc_flags, UTVFU_FLAG_AS_RUNNING); 1208 printf("%s: can't create kernel thread!", DEVNAME(sc)); 1209 } 1210 1211 return (error); 1212 } 1213 1214 void 1215 utvfu_as_bulk_thread(void *arg) 1216 { 1217 struct utvfu_softc *sc = arg; 1218 struct utvfu_as_iface *iface; 1219 usbd_status error; 1220 uint32_t actlen; 1221 1222 DPRINTF(1, "%s %s\n", DEVNAME(sc), __func__); 1223 1224 iface = &sc->sc_audio.iface; 1225 usbd_ref_incr(sc->sc_udev); 1226 while (ISSET(sc->sc_flags, UTVFU_FLAG_AS_RUNNING)) { 1227 usbd_setup_xfer( 1228 iface->xfer, 1229 iface->pipeh, 1230 0, 1231 NULL, 1232 UTVFU_AUDIO_URBSIZE, 1233 USBD_NO_COPY | USBD_SHORT_XFER_OK | USBD_SYNCHRONOUS, 1234 0, 1235 NULL); 1236 error = usbd_transfer(iface->xfer); 1237 1238 if (error != USBD_NORMAL_COMPLETION) { 1239 DPRINTF(1, "%s: error in bulk xfer: %s!\n", 1240 DEVNAME(sc), usbd_errstr(error)); 1241 break; 1242 } 1243 1244 usbd_get_xfer_status(iface->xfer, NULL, NULL, &actlen, 1245 NULL); 1246 DPRINTF(2, "%s: *** buffer len = %d\n", DEVNAME(sc), actlen); 1247 1248 rw_enter_read(&sc->sc_audio.rwlock); 1249 utvfu_audio_decode(sc, actlen); 1250 rw_exit_read(&sc->sc_audio.rwlock); 1251 } 1252 1253 CLR(sc->sc_flags, UTVFU_FLAG_AS_RUNNING); 1254 usbd_ref_decr(sc->sc_udev); 1255 1256 DPRINTF(1, "%s %s: exiting\n", DEVNAME(sc), __func__); 1257 1258 kthread_exit(0); 1259 } 1260 1261 void 1262 utvfu_vs_start_isoc(struct utvfu_softc *sc) 1263 { 1264 int i; 1265 1266 for (i = 0; i < UTVFU_ISOC_TRANSFERS; i++) 1267 utvfu_vs_start_isoc_ixfer(sc, &sc->sc_iface.ixfer[i]); 1268 } 1269 1270 void 1271 utvfu_vs_start_isoc_ixfer(struct utvfu_softc *sc, 1272 struct utvfu_isoc_xfer *ixfer) 1273 { 1274 int i; 1275 usbd_status error; 1276 1277 DPRINTF(2, "%s: %s\n", DEVNAME(sc), __func__); 1278 1279 if (usbd_is_dying(sc->sc_udev)) 1280 return; 1281 1282 for (i = 0; i < sc->sc_nframes; i++) 1283 ixfer->size[i] = sc->sc_iface.psize; 1284 1285 usbd_setup_isoc_xfer( 1286 ixfer->xfer, 1287 sc->sc_iface.pipeh, 1288 ixfer, 1289 ixfer->size, 1290 sc->sc_nframes, 1291 USBD_NO_COPY | USBD_SHORT_XFER_OK, 1292 utvfu_vs_cb); 1293 1294 error = usbd_transfer(ixfer->xfer); 1295 if (error && error != USBD_IN_PROGRESS) { 1296 DPRINTF(1, "%s: usbd_transfer error=%s!\n", 1297 DEVNAME(sc), usbd_errstr(error)); 1298 } 1299 } 1300 1301 /* 1302 * Each packet contains a number of 256-byte chunks composing the image frame. 1303 */ 1304 void 1305 utvfu_vs_cb(struct usbd_xfer *xfer, void *priv, usbd_status status) 1306 { 1307 struct utvfu_isoc_xfer *ixfer = priv; 1308 struct utvfu_softc *sc = ixfer->sc; 1309 int i, off, frame_size; 1310 uint32_t actlen; 1311 uint8_t *frame; 1312 1313 DPRINTF(2, "%s: %s\n", DEVNAME(sc), __func__); 1314 1315 if (status != USBD_NORMAL_COMPLETION) { 1316 DPRINTF(1, "%s: %s: %s\n", DEVNAME(sc), __func__, 1317 usbd_errstr(status)); 1318 return; 1319 } 1320 usbd_get_xfer_status(xfer, NULL, NULL, &actlen, NULL); 1321 1322 DPRINTF(2, "%s: *** buffer len = %d\n", DEVNAME(sc), actlen); 1323 if (actlen == 0) 1324 goto skip; 1325 1326 frame = KERNADDR(&xfer->dmabuf, 0); 1327 for (i = 0; i < sc->sc_nframes; i++, frame += sc->sc_iface.psize) { 1328 frame_size = ixfer->size[i]; 1329 1330 if (frame_size == 0) 1331 /* frame is empty */ 1332 continue; 1333 1334 #define CHUNK_STRIDE (UTVFU_CHUNK_SIZE*4) 1335 for (off = 0; off + CHUNK_STRIDE <= frame_size; 1336 off += CHUNK_STRIDE) { 1337 utvfu_image_chunk(sc, frame + off); 1338 } 1339 #undef CHUNK_STRIDE 1340 } 1341 1342 skip: /* setup new transfer */ 1343 utvfu_vs_start_isoc_ixfer(sc, ixfer); 1344 } 1345 1346 int 1347 utvfu_find_queued(struct utvfu_softc *sc) 1348 { 1349 int i; 1350 1351 /* find a buffer which is ready for queueing */ 1352 for (i = 0; i < sc->sc_mmap_count; i++) { 1353 if (sc->sc_mmap[i].v4l2_buf.flags & V4L2_BUF_FLAG_DONE) 1354 continue; 1355 if (sc->sc_mmap[i].v4l2_buf.flags & V4L2_BUF_FLAG_QUEUED) 1356 return (i); 1357 } 1358 1359 return (-1); 1360 } 1361 1362 int 1363 utvfu_mmap_queue(struct utvfu_softc *sc, uint8_t *buf, int len) 1364 { 1365 int i; 1366 1367 if (sc->sc_mmap_count == 0 || sc->sc_mmap_buffer == NULL) 1368 panic("%s: mmap buffers not allocated", __func__); 1369 1370 /* find a buffer which is ready for queueing */ 1371 if ((i = utvfu_find_queued(sc)) == -1) { 1372 DPRINTF(2, "%s: mmap queue is full!\n", DEVNAME(sc)); 1373 return (ENOMEM); 1374 } 1375 1376 /* copy frame to mmap buffer and report length */ 1377 memcpy(sc->sc_mmap[i].buf, buf, len); 1378 sc->sc_mmap[i].v4l2_buf.bytesused = len; 1379 1380 /* timestamp it */ 1381 getmicrotime(&sc->sc_mmap[i].v4l2_buf.timestamp); 1382 1383 /* appropriately set/clear flags */ 1384 sc->sc_mmap[i].v4l2_buf.flags &= ~V4L2_BUF_FLAG_QUEUED; 1385 sc->sc_mmap[i].v4l2_buf.flags |= V4L2_BUF_FLAG_DONE; 1386 1387 /* queue it */ 1388 SIMPLEQ_INSERT_TAIL(&sc->sc_mmap_q, &sc->sc_mmap[i], q_frames); 1389 DPRINTF(2, "%s: %s: frame queued on index %d\n", 1390 DEVNAME(sc), __func__, i); 1391 1392 wakeup(sc); 1393 1394 /* 1395 * In case userland uses poll(2), signal that we have a frame 1396 * ready to dequeue. 1397 */ 1398 (*sc->sc_uplayer_intr)(sc->sc_uplayer_arg); 1399 1400 return (0); 1401 } 1402 1403 caddr_t 1404 utvfu_mappage(void *v, off_t off, int prot) 1405 { 1406 struct utvfu_softc *sc = v; 1407 caddr_t p = NULL; 1408 1409 if (off < sc->sc_mmap_bufsz) { 1410 if ((sc->sc_flags & UTVFU_FLAG_MMAP) == 0) 1411 sc->sc_flags |= UTVFU_FLAG_MMAP; 1412 1413 p = sc->sc_mmap_buffer + off; 1414 } 1415 1416 return (p); 1417 } 1418 1419 int 1420 utvfu_get_bufsize(void *v) 1421 { 1422 struct utvfu_softc *sc = v; 1423 1424 /* YUYV/YUV-422: 4 bytes/2 pixel */ 1425 return (utvfu_norm_params[sc->sc_normi].cap_width * 1426 utvfu_norm_params[sc->sc_normi].cap_height * 2); 1427 } 1428 1429 int 1430 utvfu_start_read(void *v) 1431 { 1432 struct utvfu_softc *sc = v; 1433 usbd_status error; 1434 1435 if (sc->sc_flags & UTVFU_FLAG_MMAP) 1436 sc->sc_flags &= ~UTVFU_FLAG_MMAP; 1437 1438 /* open video stream pipe */ 1439 error = utvfu_vs_open(sc); 1440 if (error != USBD_NORMAL_COMPLETION) 1441 return (EINVAL); 1442 1443 utvfu_vs_start_isoc(sc); 1444 1445 return (0); 1446 } 1447 1448 void 1449 utvfu_audio_clear_client(struct utvfu_softc *sc) 1450 { 1451 rw_enter_write(&sc->sc_audio.rwlock); 1452 1453 sc->sc_audio.intr = NULL; 1454 sc->sc_audio.intr_arg = NULL; 1455 sc->sc_audio.start = NULL; 1456 sc->sc_audio.end = NULL; 1457 sc->sc_audio.cur = NULL; 1458 sc->sc_audio.blksize = 0; 1459 1460 rw_exit_write(&sc->sc_audio.rwlock); 1461 } 1462 1463 void 1464 utvfu_as_free(struct utvfu_softc *sc) 1465 { 1466 DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__); 1467 1468 utvfu_as_close(sc); 1469 utvfu_as_free_bulk(sc); 1470 } 1471 1472 void 1473 utvfu_vs_free(struct utvfu_softc *sc) 1474 { 1475 DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__); 1476 utvfu_vs_close(sc); 1477 utvfu_vs_free_isoc(sc); 1478 utvfu_vs_free_frame(sc); 1479 } 1480 1481 int 1482 utvfu_as_init(struct utvfu_softc *sc) 1483 { 1484 DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__); 1485 1486 if (sc->sc_audio.iface.xfer != NULL) 1487 return (0); 1488 1489 /* allocate audio and video stream xfer buffer */ 1490 return utvfu_as_alloc_bulk(sc); 1491 } 1492 1493 int 1494 utvfu_vs_init(struct utvfu_softc *sc) 1495 { 1496 DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__); 1497 1498 if (utvfu_start_capture(sc) != 0) 1499 return (EINVAL); 1500 1501 if (utvfu_vs_alloc_isoc(sc) != 0 || utvfu_vs_alloc_frame(sc) != 0) 1502 return (ENOMEM); 1503 1504 return (0); 1505 } 1506 1507 int 1508 utvfu_vs_alloc_frame(struct utvfu_softc *sc) 1509 { 1510 struct utvfu_frame_buf *fb = &sc->sc_fb; 1511 1512 fb->size = sc->sc_max_frame_sz; 1513 fb->buf = malloc(fb->size, M_USBDEV, M_NOWAIT); 1514 if (fb->buf == NULL) { 1515 printf("%s: can't allocate frame buffer!\n", DEVNAME(sc)); 1516 return (ENOMEM); 1517 } 1518 1519 DPRINTF(1, "%s: %s: allocated %d bytes frame buffer\n", 1520 DEVNAME(sc), __func__, fb->size); 1521 1522 fb->chunks_done = 0; 1523 fb->fid = 0; 1524 fb->last_odd = 1; 1525 1526 return (0); 1527 } 1528 1529 void 1530 utvfu_vs_free_frame(struct utvfu_softc *sc) 1531 { 1532 struct utvfu_frame_buf *fb = &sc->sc_fb; 1533 1534 if (fb->buf != NULL) { 1535 free(fb->buf, M_USBDEV, fb->size); 1536 fb->buf = NULL; 1537 } 1538 1539 if (sc->sc_mmap_buffer != NULL) { 1540 free(sc->sc_mmap_buffer, M_USBDEV, sc->sc_mmap_bufsz); 1541 sc->sc_mmap_buffer = NULL; 1542 memset(sc->sc_mmap, 0, sizeof(sc->sc_mmap)); 1543 } 1544 1545 while (!SIMPLEQ_EMPTY(&sc->sc_mmap_q)) 1546 SIMPLEQ_REMOVE_HEAD(&sc->sc_mmap_q, q_frames); 1547 1548 sc->sc_mmap_count = 0; 1549 } 1550 1551 usbd_status 1552 utvfu_vs_alloc_isoc(struct utvfu_softc *sc) 1553 { 1554 int size, i; 1555 void *buf; 1556 1557 DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__); 1558 1559 for (i = 0; i < UTVFU_ISOC_TRANSFERS; i++) { 1560 sc->sc_iface.ixfer[i].sc = sc; 1561 sc->sc_iface.ixfer[i].xfer = usbd_alloc_xfer(sc->sc_udev); 1562 if (sc->sc_iface.ixfer[i].xfer == NULL) { 1563 printf("%s: could not allocate isoc VS xfer!\n", 1564 DEVNAME(sc)); 1565 return (USBD_NOMEM); 1566 } 1567 1568 size = sc->sc_iface.psize * sc->sc_nframes; 1569 1570 buf = usbd_alloc_buffer(sc->sc_iface.ixfer[i].xfer, size); 1571 if (buf == NULL) { 1572 printf("%s: could not allocate isoc VS buffer!\n", 1573 DEVNAME(sc)); 1574 return (USBD_NOMEM); 1575 } 1576 DPRINTF(1, "%s: allocated %d bytes isoc VS xfer buffer\n", 1577 DEVNAME(sc), size); 1578 } 1579 1580 return (USBD_NORMAL_COMPLETION); 1581 } 1582 1583 int 1584 utvfu_as_alloc_bulk(struct utvfu_softc *sc) 1585 { 1586 struct usbd_xfer *xfer; 1587 1588 xfer = usbd_alloc_xfer(sc->sc_udev); 1589 if (xfer == NULL) { 1590 printf("%s: could not allocate bulk AUDIO xfer!\n", 1591 DEVNAME(sc)); 1592 return (ENOMEM); 1593 } 1594 1595 if (usbd_alloc_buffer(xfer, UTVFU_AUDIO_URBSIZE) == NULL) { 1596 usbd_free_xfer(xfer); 1597 printf("%s: could not allocate bulk AUDIO buffer!\n", 1598 DEVNAME(sc)); 1599 return (ENOMEM); 1600 } 1601 DPRINTF(1, "%s: allocated %d bytes bulk AUDIO xfer buffer\n", 1602 DEVNAME(sc), UTVFU_AUDIO_URBSIZE); 1603 1604 sc->sc_audio.iface.xfer = xfer; 1605 1606 return (0); 1607 } 1608 1609 void 1610 utvfu_vs_free_isoc(struct utvfu_softc *sc) 1611 { 1612 int i; 1613 1614 DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__); 1615 1616 for (i = 0; i < UTVFU_ISOC_TRANSFERS; i++) { 1617 if (sc->sc_iface.ixfer[i].xfer != NULL) { 1618 usbd_free_xfer(sc->sc_iface.ixfer[i].xfer); 1619 sc->sc_iface.ixfer[i].xfer = NULL; 1620 } 1621 } 1622 } 1623 1624 void 1625 utvfu_as_free_bulk(struct utvfu_softc *sc) 1626 { 1627 DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__); 1628 1629 if (sc->sc_audio.iface.xfer != NULL) { 1630 usbd_free_xfer(sc->sc_audio.iface.xfer); 1631 sc->sc_audio.iface.xfer = NULL; 1632 } 1633 } 1634 1635 int 1636 utvfu_reqbufs(void *v, struct v4l2_requestbuffers *rb) 1637 { 1638 struct utvfu_softc *sc = v; 1639 int i; 1640 1641 DPRINTF(1, "%s: %s: count=%d\n", DEVNAME(sc), __func__, rb->count); 1642 1643 /* We do not support freeing buffers via reqbufs(0) */ 1644 if (rb->count == 0) 1645 return (EINVAL); 1646 1647 if (sc->sc_mmap_count > 0 || sc->sc_mmap_buffer != NULL) { 1648 DPRINTF(1, "%s: %s: mmap buffers already allocated\n", 1649 DEVNAME(sc), __func__); 1650 return (EINVAL); 1651 } 1652 1653 /* limit the buffers */ 1654 if (rb->count > UTVFU_MAX_BUFFERS) 1655 sc->sc_mmap_count = UTVFU_MAX_BUFFERS; 1656 else 1657 sc->sc_mmap_count = rb->count; 1658 1659 /* allocate the total mmap buffer */ 1660 sc->sc_mmap_bufsz = sc->sc_max_frame_sz; 1661 if (INT_MAX / sc->sc_mmap_count < sc->sc_max_frame_sz) /* overflow */ 1662 return (ENOMEM); 1663 sc->sc_mmap_bufsz *= sc->sc_mmap_count; 1664 sc->sc_mmap_bufsz = round_page(sc->sc_mmap_bufsz); /* page align */ 1665 sc->sc_mmap_buffer = malloc(sc->sc_mmap_bufsz, M_USBDEV, M_NOWAIT); 1666 if (sc->sc_mmap_buffer == NULL) { 1667 printf("%s: can't allocate mmap buffer!\n", DEVNAME(sc)); 1668 return (ENOMEM); 1669 } 1670 DPRINTF(1, "%s: allocated %d bytes mmap buffer\n", 1671 DEVNAME(sc), sc->sc_mmap_bufsz); 1672 1673 /* fill the v4l2_buffer structure */ 1674 for (i = 0; i < sc->sc_mmap_count; i++) { 1675 sc->sc_mmap[i].buf = sc->sc_mmap_buffer 1676 + (i * sc->sc_max_frame_sz); 1677 sc->sc_mmap[i].v4l2_buf.index = i; 1678 sc->sc_mmap[i].v4l2_buf.m.offset = i * sc->sc_max_frame_sz; 1679 sc->sc_mmap[i].v4l2_buf.length = sc->sc_max_frame_sz; 1680 sc->sc_mmap[i].v4l2_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1681 sc->sc_mmap[i].v4l2_buf.sequence = 0; 1682 sc->sc_mmap[i].v4l2_buf.field = V4L2_FIELD_NONE; 1683 sc->sc_mmap[i].v4l2_buf.memory = V4L2_MEMORY_MMAP; 1684 sc->sc_mmap[i].v4l2_buf.flags = V4L2_BUF_FLAG_MAPPED; 1685 1686 DPRINTF(1, "%s: %s: index=%d, offset=%d, length=%d\n", 1687 DEVNAME(sc), __func__, 1688 sc->sc_mmap[i].v4l2_buf.index, 1689 sc->sc_mmap[i].v4l2_buf.m.offset, 1690 sc->sc_mmap[i].v4l2_buf.length); 1691 } 1692 1693 /* tell how many buffers we have really allocated */ 1694 rb->count = sc->sc_mmap_count; 1695 1696 rb->capabilities = V4L2_BUF_CAP_SUPPORTS_MMAP; 1697 1698 return (0); 1699 } 1700 1701 int 1702 utvfu_querybuf(void *v, struct v4l2_buffer *qb) 1703 { 1704 struct utvfu_softc *sc = v; 1705 1706 if (qb->type != V4L2_BUF_TYPE_VIDEO_CAPTURE || 1707 qb->memory != V4L2_MEMORY_MMAP || 1708 qb->index >= sc->sc_mmap_count) 1709 return (EINVAL); 1710 1711 memcpy(qb, &sc->sc_mmap[qb->index].v4l2_buf, 1712 sizeof(struct v4l2_buffer)); 1713 1714 DPRINTF(1, "%s: %s: index=%d, offset=%d, length=%d\n", 1715 DEVNAME(sc), __func__, qb->index, qb->m.offset, qb->length); 1716 1717 return (0); 1718 } 1719 1720 int 1721 utvfu_qbuf(void *v, struct v4l2_buffer *qb) 1722 { 1723 struct utvfu_softc *sc = v; 1724 1725 if (qb->type != V4L2_BUF_TYPE_VIDEO_CAPTURE || 1726 qb->memory != V4L2_MEMORY_MMAP || 1727 qb->index >= sc->sc_mmap_count) 1728 return (EINVAL); 1729 1730 sc->sc_mmap[qb->index].v4l2_buf.flags &= ~V4L2_BUF_FLAG_DONE; 1731 sc->sc_mmap[qb->index].v4l2_buf.flags |= V4L2_BUF_FLAG_MAPPED; 1732 sc->sc_mmap[qb->index].v4l2_buf.flags |= V4L2_BUF_FLAG_QUEUED; 1733 1734 DPRINTF(2, "%s: %s: buffer on index %d ready for queueing\n", 1735 DEVNAME(sc), __func__, qb->index); 1736 1737 return (0); 1738 } 1739 1740 int 1741 utvfu_dqbuf(void *v, struct v4l2_buffer *dqb) 1742 { 1743 struct utvfu_softc *sc = v; 1744 struct utvfu_mmap *mmap; 1745 int error; 1746 1747 if (dqb->type != V4L2_BUF_TYPE_VIDEO_CAPTURE || 1748 dqb->memory != V4L2_MEMORY_MMAP) 1749 return (EINVAL); 1750 1751 if (SIMPLEQ_EMPTY(&sc->sc_mmap_q)) { 1752 /* mmap queue is empty, block until first frame is queued */ 1753 error = tsleep_nsec(sc, 0, "vid_mmap", SEC_TO_NSEC(10)); 1754 if (error) 1755 return (EINVAL); 1756 } 1757 1758 mmap = SIMPLEQ_FIRST(&sc->sc_mmap_q); 1759 if (mmap == NULL) 1760 panic("utvfu_dqbuf: NULL pointer!"); 1761 1762 memcpy(dqb, &mmap->v4l2_buf, sizeof(struct v4l2_buffer)); 1763 1764 mmap->v4l2_buf.flags &= ~(V4L2_BUF_FLAG_DONE|V4L2_BUF_FLAG_QUEUED); 1765 mmap->v4l2_buf.flags |= V4L2_BUF_FLAG_MAPPED; 1766 1767 DPRINTF(2, "%s: %s: frame dequeued from index %d\n", 1768 DEVNAME(sc), __func__, mmap->v4l2_buf.index); 1769 SIMPLEQ_REMOVE_HEAD(&sc->sc_mmap_q, q_frames); 1770 1771 return (0); 1772 } 1773 1774 int 1775 utvfu_streamon(void *v, int type) 1776 { 1777 struct utvfu_softc *sc = v; 1778 usbd_status error; 1779 1780 /* open video stream pipe */ 1781 error = utvfu_vs_open(sc); 1782 if (error != USBD_NORMAL_COMPLETION) 1783 return (EINVAL); 1784 1785 utvfu_vs_start_isoc(sc); 1786 1787 return (0); 1788 } 1789 1790 int 1791 utvfu_streamoff(void *v, int type) 1792 { 1793 utvfu_vs_close(v); 1794 1795 return (0); 1796 } 1797 1798 int 1799 utvfu_queryctrl(void *v, struct v4l2_queryctrl *qctrl) 1800 { 1801 qctrl->flags = V4L2_CTRL_FLAG_DISABLED; 1802 1803 return (0); 1804 } 1805 1806 int 1807 utvfu_g_parm(void *v, struct v4l2_streamparm *parm) 1808 { 1809 struct utvfu_softc *sc = v; 1810 1811 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 1812 return (EINVAL); 1813 1814 /* 1815 * XXX Unsure whether there is a way to negotiate this with the 1816 * device, but returning 0 will allow xenocara's video to run 1817 */ 1818 switch (utvfu_norm_params[sc->sc_normi].norm) { 1819 default: 1820 return (EINVAL); 1821 case V4L2_STD_525_60: 1822 parm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME; 1823 parm->parm.capture.capturemode = 0; 1824 parm->parm.capture.timeperframe.numerator = 30; 1825 parm->parm.capture.timeperframe.denominator = 1; 1826 break; 1827 case V4L2_STD_PAL: 1828 parm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME; 1829 parm->parm.capture.capturemode = 0; 1830 parm->parm.capture.timeperframe.numerator = 25; 1831 parm->parm.capture.timeperframe.denominator = 1; 1832 break; 1833 } 1834 1835 return (0); 1836 } 1837 1838 int 1839 utvfu_s_parm(void *v, struct v4l2_streamparm *parm) 1840 { 1841 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 1842 return (EINVAL); 1843 1844 return (0); 1845 } 1846 1847 /* 1848 * A U D I O O P S 1849 */ 1850 1851 int 1852 utvfu_audio_open(void *v, int flags) 1853 { 1854 struct utvfu_softc *sc = v; 1855 1856 if (usbd_is_dying(sc->sc_udev)) 1857 return (EIO); 1858 1859 if ((flags & FWRITE)) 1860 return (ENXIO); 1861 1862 if (ISSET(sc->sc_flags, UTVFU_FLAG_AS_RUNNING)) 1863 return (EBUSY); 1864 1865 return utvfu_as_init(sc); 1866 } 1867 1868 void 1869 utvfu_audio_close(void *v) 1870 { 1871 struct utvfu_softc *sc = v; 1872 1873 DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__); 1874 1875 utvfu_audio_stop(sc); 1876 utvfu_audio_clear_client(sc); 1877 } 1878 1879 int 1880 utvfu_audio_set_params(void *v, int setmode, int usemode, 1881 struct audio_params *play, struct audio_params *rec) 1882 { 1883 struct utvfu_softc *sc = v; 1884 1885 if (usbd_is_dying(sc->sc_udev)) 1886 return (EIO); 1887 1888 DPRINTF(1, "%s %s\n", DEVNAME(sc), __func__); 1889 1890 /* XXX ? */ 1891 play->sample_rate = 0; 1892 play->encoding = AUDIO_ENCODING_NONE; 1893 1894 rec->sample_rate = 48000; 1895 rec->encoding = AUDIO_ENCODING_SLINEAR_LE; 1896 rec->precision = 16; 1897 rec->bps = 2; 1898 rec->msb = 1; 1899 rec->channels = 2; 1900 1901 return (0); 1902 } 1903 1904 int 1905 utvfu_audio_halt_out(void *v) 1906 { 1907 return (EIO); 1908 } 1909 1910 int 1911 utvfu_audio_halt_in(void *v) 1912 { 1913 struct utvfu_softc *sc = v; 1914 1915 if (usbd_is_dying(sc->sc_udev)) 1916 return (EIO); 1917 1918 DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__); 1919 1920 utvfu_audio_stop(sc); 1921 utvfu_audio_clear_client(sc); 1922 1923 return (0); 1924 } 1925 1926 int 1927 utvfu_audio_mixer_set_port(void *v, struct mixer_ctrl *cp) 1928 { 1929 struct utvfu_softc *sc = v; 1930 1931 if (usbd_is_dying(sc->sc_udev)) 1932 return (EIO); 1933 1934 DPRINTF(1, "%s %s\n", DEVNAME(sc), __func__); 1935 1936 if (cp->type != AUDIO_MIXER_ENUM || 1937 cp->un.ord < 0 || cp->un.ord > 1) 1938 return (EINVAL); 1939 1940 /* XXX TODO */ 1941 1942 DPRINTF(1, "%s %s: cp->un.ord=%d\n", DEVNAME(sc), __func__, cp->un.ord); 1943 1944 return (0); 1945 } 1946 1947 int 1948 utvfu_audio_mixer_get_port(void *v, struct mixer_ctrl *cp) 1949 { 1950 struct utvfu_softc *sc = v; 1951 1952 if (usbd_is_dying(sc->sc_udev)) 1953 return (EIO); 1954 1955 DPRINTF(1, "%s %s\n", DEVNAME(sc), __func__); 1956 1957 if (cp->type != AUDIO_MIXER_ENUM || 1958 cp->un.ord < 0 || cp->un.ord > 1) 1959 return (EINVAL); 1960 1961 /* XXX TODO */ 1962 1963 DPRINTF(1, "%s %s: cp->un.ord=%d\n", DEVNAME(sc), __func__, cp->un.ord); 1964 1965 return (0); 1966 } 1967 1968 int 1969 utvfu_audio_query_devinfo(void *v, struct mixer_devinfo *mi) 1970 { 1971 struct utvfu_softc *sc = v; 1972 1973 if (usbd_is_dying(sc->sc_udev)) 1974 return (EIO); 1975 1976 DPRINTF(1, "%s %s\n", DEVNAME(sc), __func__); 1977 1978 if (mi->index != 0) 1979 return (EINVAL); 1980 1981 /* XXX SOMEONE WITH AUDIO EXPERTIZE NEEDS TO HELP HERE */ 1982 strlcpy(mi->label.name, "mix0-i0", sizeof(mi->label.name)); 1983 mi->type = AUDIO_MIXER_ENUM; 1984 mi->un.e.num_mem = 2; 1985 mi->un.e.member[0].ord = 0; 1986 strlcpy(mi->un.e.member[0].label.name, AudioNoff, 1987 sizeof(mi->un.e.member[0].label.name)); 1988 mi->un.e.member[1].ord = 1; 1989 strlcpy(mi->un.e.member[1].label.name, AudioNon, 1990 sizeof(mi->un.e.member[1].label.name)); 1991 1992 return (0); 1993 } 1994 1995 int 1996 utvfu_audio_trigger_output(void *v, void *start, void *end, int blksize, 1997 void (*intr)(void *), void *arg, struct audio_params *param) 1998 { 1999 return (EIO); 2000 } 2001 2002 int 2003 utvfu_audio_trigger_input(void *v, void *start, void *end, int blksize, 2004 void (*intr)(void *), void *arg, struct audio_params *param) 2005 { 2006 struct utvfu_softc *sc = v; 2007 2008 if (usbd_is_dying(sc->sc_udev)) 2009 return (EIO); 2010 2011 rw_enter_write(&sc->sc_audio.rwlock); 2012 2013 sc->sc_audio.intr_arg = arg; 2014 sc->sc_audio.intr = intr; 2015 sc->sc_audio.start = start; 2016 sc->sc_audio.end = end; 2017 sc->sc_audio.cur = start; 2018 sc->sc_audio.blksize = blksize; 2019 2020 rw_exit_write(&sc->sc_audio.rwlock); 2021 2022 DPRINTF(1, "%s %s: start=%p end=%p diff=%lu blksize=%d\n", 2023 DEVNAME(sc), __func__, start, end, 2024 ((u_char *)end - (u_char *)start), blksize); 2025 2026 return utvfu_audio_start(sc); 2027 } 2028 2029 int 2030 utvfu_audio_start(struct utvfu_softc *sc) 2031 { 2032 DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__); 2033 2034 if (ISSET(sc->sc_flags, UTVFU_FLAG_AS_RUNNING)) 2035 return (0); 2036 2037 utvfu_audio_start_chip(sc); 2038 2039 if (utvfu_as_init(sc) != 0) 2040 return (ENOMEM); 2041 if (sc->sc_audio.iface.pipeh == NULL) { 2042 if (utvfu_as_open(sc) != USBD_NORMAL_COMPLETION) 2043 return (ENOMEM); 2044 } 2045 2046 return utvfu_as_start_bulk(sc); 2047 } 2048 2049 int 2050 utvfu_audio_stop(struct utvfu_softc *sc) 2051 { 2052 DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__); 2053 2054 utvfu_audio_stop_chip(sc); 2055 utvfu_as_free(sc); 2056 2057 return (0); 2058 } 2059