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