1/* $NetBSD: auvitek_video.c,v 1.7 2016/04/23 10:15:31 skrll Exp $ */
2
3/*-
4 * Copyright (c) 2010 Jared D. McNeill <jmcneill@invisible.ca>
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 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
17 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
18 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26 * POSSIBILITY OF SUCH DAMAGE.
27 */
28
29/*
30 * Auvitek AU0828 USB controller
31 */
32
33#include <sys/cdefs.h>
34__KERNEL_RCSID(0, "$NetBSD: auvitek_video.c,v 1.7 2016/04/23 10:15:31 skrll Exp $");
35
36#include <sys/param.h>
37#include <sys/systm.h>
38#include <sys/device.h>
39#include <sys/conf.h>
40#include <sys/kmem.h>
41#include <sys/bus.h>
42
43#include <dev/usb/usb.h>
44#include <dev/usb/usbdi.h>
45#include <dev/usb/usbdivar.h>
46#include <dev/usb/usbdi_util.h>
47#include <dev/usb/usbdevs.h>
48
49#include <dev/video_if.h>
50
51#include <dev/usb/auvitekreg.h>
52#include <dev/usb/auvitekvar.h>
53
54#define AUVITEK_FORMAT_DEFAULT 0
55#define AUVITEK_STANDARD_NTSC_M 0
56#define AUVITEK_TUNER_DEFAULT 0
57#define AUVITEK_AUDIO_TELEVISION 0
58#define AUVITEK_AUDIO_LINEIN 1
59#define AUVITEK_INPUT_COMPOSITE 0
60#define AUVITEK_INPUT_SVIDEO 1
61#define AUVITEK_INPUT_TELEVISION 2
62#define AUVITEK_INPUT_CABLE 3
63
64static int auvitek_open(void *, int);
65static void auvitek_close(void *);
66static const char * auvitek_get_devname(void *);
67static const char * auvitek_get_businfo(void *);
68static int auvitek_enum_format(void *, uint32_t,
69 struct video_format *);
70static int auvitek_get_format(void *, struct video_format *);
71static int auvitek_set_format(void *, struct video_format *);
72static int auvitek_try_format(void *, struct video_format *);
73static int auvitek_enum_standard(void *, uint32_t,
74 enum video_standard *);
75static int auvitek_get_standard(void *, enum video_standard *);
76static int auvitek_set_standard(void *, enum video_standard);
77static int auvitek_start_transfer(void *);
78static int auvitek_stop_transfer(void *);
79static int auvitek_get_tuner(void *, struct video_tuner *);
80static int auvitek_set_tuner(void *, struct video_tuner *);
81static int auvitek_enum_audio(void *, uint32_t,
82 struct video_audio *);
83static int auvitek_get_audio(void *, struct video_audio *);
84static int auvitek_set_audio(void *, struct video_audio *);
85static int auvitek_enum_input(void *, uint32_t,
86 struct video_input *);
87static int auvitek_get_input(void *, struct video_input *);
88static int auvitek_set_input(void *, struct video_input *);
89static int auvitek_get_frequency(void *, struct video_frequency *);
90static int auvitek_set_frequency(void *, struct video_frequency *);
91
92static int auvitek_start_xfer(struct auvitek_softc *);
93static int auvitek_stop_xfer(struct auvitek_softc *);
94static int auvitek_isoc_start(struct auvitek_softc *);
95static int auvitek_isoc_start1(struct auvitek_isoc *);
96static void auvitek_isoc_intr(struct usbd_xfer *, void *,
97 usbd_status);
98static int auvitek_isoc_process(struct auvitek_softc *,
99 uint8_t *, uint32_t);
100static void auvitek_videobuf_weave(struct auvitek_softc *,
101 uint8_t *, uint32_t);
102
103static const struct video_hw_if auvitek_video_if = {
104 .open = auvitek_open,
105 .close = auvitek_close,
106 .get_devname = auvitek_get_devname,
107 .get_businfo = auvitek_get_businfo,
108 .enum_format = auvitek_enum_format,
109 .get_format = auvitek_get_format,
110 .set_format = auvitek_set_format,
111 .try_format = auvitek_try_format,
112 .enum_standard = auvitek_enum_standard,
113 .get_standard = auvitek_get_standard,
114 .set_standard = auvitek_set_standard,
115 .start_transfer = auvitek_start_transfer,
116 .stop_transfer = auvitek_stop_transfer,
117 .get_tuner = auvitek_get_tuner,
118 .set_tuner = auvitek_set_tuner,
119 .enum_audio = auvitek_enum_audio,
120 .get_audio = auvitek_get_audio,
121 .set_audio = auvitek_set_audio,
122 .enum_input = auvitek_enum_input,
123 .get_input = auvitek_get_input,
124 .set_input = auvitek_set_input,
125 .get_frequency = auvitek_get_frequency,
126 .set_frequency = auvitek_set_frequency,
127};
128
129int
130auvitek_video_attach(struct auvitek_softc *sc)
131{
132 snprintf(sc->sc_businfo, sizeof(sc->sc_businfo), "usb:%08x",
133 sc->sc_udev->ud_cookie.cookie);
134
135 auvitek_video_rescan(sc, NULL, NULL);
136
137 return (sc->sc_videodev != NULL);
138}
139
140int
141auvitek_video_detach(struct auvitek_softc *sc, int flags)
142{
143 if (sc->sc_videodev != NULL) {
144 config_detach(sc->sc_videodev, flags);
145 sc->sc_videodev = NULL;
146 }
147
148 return 0;
149}
150
151void
152auvitek_video_rescan(struct auvitek_softc *sc, const char *ifattr,
153 const int *locs)
154{
155 if (ifattr_match(ifattr, "videobus") && sc->sc_videodev == NULL)
156 sc->sc_videodev = video_attach_mi(&auvitek_video_if,
157 sc->sc_dev);
158}
159
160void
161auvitek_video_childdet(struct auvitek_softc *sc, device_t child)
162{
163 if (sc->sc_videodev == child)
164 sc->sc_videodev = NULL;
165}
166
167static int
168auvitek_open(void *opaque, int flags)
169{
170 struct auvitek_softc *sc = opaque;
171
172 if (sc->sc_dying)
173 return EIO;
174
175 auvitek_attach_tuner(sc->sc_dev);
176
177 if (sc->sc_xc5k == NULL)
178 return ENXIO;
179
180 return 0;
181}
182
183static void
184auvitek_close(void *opaque)
185{
186}
187
188static const char *
189auvitek_get_devname(void *opaque)
190{
191 struct auvitek_softc *sc = opaque;
192
193 return sc->sc_descr;
194}
195
196static const char *
197auvitek_get_businfo(void *opaque)
198{
199 struct auvitek_softc *sc = opaque;
200
201 return sc->sc_businfo;
202}
203
204static int
205auvitek_enum_format(void *opaque, uint32_t index, struct video_format *format)
206{
207 if (index != AUVITEK_FORMAT_DEFAULT)
208 return EINVAL;
209
210 format->pixel_format = VIDEO_FORMAT_UYVY;
211
212 return 0;
213}
214
215static int
216auvitek_get_format(void *opaque, struct video_format *format)
217{
218
219 format->pixel_format = VIDEO_FORMAT_UYVY;
220 format->width = 720;
221 format->height = 480;
222 format->stride = format->width * 2;
223 format->sample_size = format->stride * format->height;
224 format->aspect_x = 4;
225 format->aspect_y = 3;
226 format->color.primaries = VIDEO_COLOR_PRIMARIES_SMPTE_170M;
227 format->color.gamma_function = VIDEO_GAMMA_FUNCTION_UNSPECIFIED;
228 format->color.matrix_coeff = VIDEO_MATRIX_COEFF_UNSPECIFIED;
229 format->interlace_flags = VIDEO_INTERLACE_ON;
230 format->priv = 0;
231
232 return 0;
233}
234
235static int
236auvitek_set_format(void *opaque, struct video_format *format)
237{
238 if (format->pixel_format != VIDEO_FORMAT_UYVY)
239 return EINVAL;
240
241 return auvitek_get_format(opaque, format);
242}
243
244static int
245auvitek_try_format(void *opaque, struct video_format *format)
246{
247 return auvitek_get_format(opaque, format);
248}
249
250static int
251auvitek_enum_standard(void *opaque, uint32_t index, enum video_standard *vstd)
252{
253 switch (index) {
254 case AUVITEK_STANDARD_NTSC_M:
255 *vstd = VIDEO_STANDARD_NTSC_M;
256 return 0;
257 default:
258 return EINVAL;
259 }
260}
261
262static int
263auvitek_get_standard(void *opaque, enum video_standard *vstd)
264{
265 *vstd = VIDEO_STANDARD_NTSC_M;
266 return 0;
267}
268
269static int
270auvitek_set_standard(void *opaque, enum video_standard vstd)
271{
272 switch (vstd) {
273 case VIDEO_STANDARD_NTSC_M:
274 return 0;
275 default:
276 return EINVAL;
277 }
278}
279
280static int
281auvitek_start_transfer(void *opaque)
282{
283 struct auvitek_softc *sc = opaque;
284 int error, s;
285 uint16_t vpos = 0, hpos = 0;
286 uint16_t hres = 720 * 2;
287 uint16_t vres = 484 / 2;
288
289 auvitek_write_1(sc, AU0828_REG_SENSORVBI_CTL, 0x00);
290
291 /* program video position and size */
292 auvitek_write_1(sc, AU0828_REG_HPOS_LO, hpos & 0xff);
293 auvitek_write_1(sc, AU0828_REG_HPOS_HI, hpos >> 8);
294 auvitek_write_1(sc, AU0828_REG_VPOS_LO, vpos & 0xff);
295 auvitek_write_1(sc, AU0828_REG_VPOS_HI, vpos >> 8);
296 auvitek_write_1(sc, AU0828_REG_HRES_LO, hres & 0xff);
297 auvitek_write_1(sc, AU0828_REG_HRES_HI, hres >> 8);
298 auvitek_write_1(sc, AU0828_REG_VRES_LO, vres & 0xff);
299 auvitek_write_1(sc, AU0828_REG_VRES_HI, vres >> 8);
300
301 auvitek_write_1(sc, AU0828_REG_SENSOR_CTL, 0xb3);
302
303 auvitek_write_1(sc, AU0828_REG_AUDIOCTL, 0x01);
304
305 s = splusb();
306 error = auvitek_start_xfer(sc);
307 splx(s);
308
309 if (error)
310 auvitek_stop_transfer(sc);
311
312 return error;
313}
314
315static int
316auvitek_stop_transfer(void *opaque)
317{
318 struct auvitek_softc *sc = opaque;
319 int error, s;
320
321 auvitek_write_1(sc, AU0828_REG_SENSOR_CTL, 0x00);
322
323 s = splusb();
324 error = auvitek_stop_xfer(sc);
325 splx(s);
326
327 return error;
328}
329
330static int
331auvitek_get_tuner(void *opaque, struct video_tuner *vt)
332{
333 struct auvitek_softc *sc = opaque;
334
335 switch (vt->index) {
336 case AUVITEK_TUNER_DEFAULT:
337 strlcpy(vt->name, "XC5000", sizeof(vt->name));
338 vt->freq_lo = 44000000 / 62500;
339 vt->freq_hi = 958000000 / 62500;
340 vt->caps = VIDEO_TUNER_F_STEREO;
341 vt->mode = VIDEO_TUNER_F_STEREO;
342 if (sc->sc_au8522)
343 vt->signal = au8522_get_signal(sc->sc_au8522);
344 else
345 vt->signal = 0;
346 break;
347 default:
348 return EINVAL;
349 }
350
351 return 0;
352}
353
354static int
355auvitek_set_tuner(void *opaque, struct video_tuner *vt)
356{
357 if (vt->index != AUVITEK_TUNER_DEFAULT)
358 return EINVAL;
359 return 0;
360}
361
362static int
363auvitek_enum_audio(void *opaque, uint32_t index, struct video_audio *va)
364{
365 switch (index) {
366 case AUVITEK_AUDIO_TELEVISION:
367 strlcpy(va->name, "Television", sizeof(va->name));
368 va->caps = VIDEO_AUDIO_F_STEREO;
369 break;
370 case AUVITEK_AUDIO_LINEIN:
371 strlcpy(va->name, "Line In", sizeof(va->name));
372 va->caps = VIDEO_AUDIO_F_STEREO;
373 break;
374 default:
375 return EINVAL;
376 }
377
378 return 0;
379}
380
381static int
382auvitek_get_audio(void *opaque, struct video_audio *va)
383{
384 struct auvitek_softc *sc = opaque;
385
386 return auvitek_enum_audio(opaque, sc->sc_ainput, va);
387}
388
389static int
390auvitek_set_audio(void *opaque, struct video_audio *va)
391{
392 struct auvitek_softc *sc = opaque;
393
394 if (va->index == sc->sc_ainput)
395 return 0;
396
397 return EINVAL;
398}
399
400static int
401auvitek_enum_input(void *opaque, uint32_t index, struct video_input *vi)
402{
403 switch (index) {
404 case AUVITEK_INPUT_COMPOSITE:
405 strlcpy(vi->name, "Composite", sizeof(vi->name));
406 vi->type = VIDEO_INPUT_TYPE_BASEBAND;
407 vi->standards = VIDEO_STANDARD_NTSC_M;
408 break;
409 case AUVITEK_INPUT_SVIDEO:
410 strlcpy(vi->name, "S-Video", sizeof(vi->name));
411 vi->type = VIDEO_INPUT_TYPE_BASEBAND;
412 vi->standards = VIDEO_STANDARD_NTSC_M;
413 break;
414 case AUVITEK_INPUT_TELEVISION:
415 strlcpy(vi->name, "Television", sizeof(vi->name));
416 vi->type = VIDEO_INPUT_TYPE_TUNER;
417 vi->standards = VIDEO_STANDARD_NTSC_M;
418 break;
419 case AUVITEK_INPUT_CABLE:
420 strlcpy(vi->name, "Cable TV", sizeof(vi->name));
421 vi->type = VIDEO_INPUT_TYPE_TUNER;
422 vi->standards = VIDEO_STANDARD_NTSC_M;
423 break;
424 default:
425 return EINVAL;
426 }
427
428 vi->index = index;
429 vi->tuner_index = AUVITEK_TUNER_DEFAULT;
430
431 return 0;
432}
433
434static int
435auvitek_get_input(void *opaque, struct video_input *vi)
436{
437 struct auvitek_softc *sc = opaque;
438
439 return auvitek_enum_input(opaque, sc->sc_vinput, vi);
440}
441
442static int
443auvitek_set_input(void *opaque, struct video_input *vi)
444{
445 struct auvitek_softc *sc = opaque;
446 struct video_frequency vf;
447 au8522_vinput_t vinput = AU8522_VINPUT_UNCONF;
448 au8522_ainput_t ainput = AU8522_AINPUT_UNCONF;
449 uint8_t r;
450
451 switch (vi->index) {
452 case AUVITEK_INPUT_COMPOSITE:
453 vinput = AU8522_VINPUT_CVBS;
454 ainput = AU8522_AINPUT_NONE;
455 sc->sc_ainput = AUVITEK_AUDIO_LINEIN;
456 break;
457 case AUVITEK_INPUT_SVIDEO:
458 vinput = AU8522_VINPUT_SVIDEO;
459 ainput = AU8522_AINPUT_NONE;
460 sc->sc_ainput = AUVITEK_AUDIO_LINEIN;
461 break;
462 case AUVITEK_INPUT_TELEVISION:
463 case AUVITEK_INPUT_CABLE:
464 vinput = AU8522_VINPUT_CVBS_TUNER;
465 ainput = AU8522_AINPUT_SIF;
466 sc->sc_ainput = AUVITEK_AUDIO_TELEVISION;
467 break;
468 default:
469 return EINVAL;
470 }
471
472 sc->sc_vinput = vi->index;
473
474 au8522_set_input(sc->sc_au8522, vinput, ainput);
475
476 /* XXX HVR-850/950Q specific */
477 r = auvitek_read_1(sc, AU0828_REG_GPIO1_OUTEN);
478 if (ainput == AU8522_AINPUT_NONE)
479 r |= 0x10;
480 else
481 r &= ~0x10;
482 auvitek_write_1(sc, AU0828_REG_GPIO1_OUTEN, r);
483
484 if (vinput == AU8522_VINPUT_CVBS_TUNER && sc->sc_curfreq > 0) {
485 vf.tuner_index = AUVITEK_TUNER_DEFAULT;
486 vf.frequency = sc->sc_curfreq;
487 auvitek_set_frequency(sc, &vf);
488 }
489
490 return 0;
491}
492
493static int
494auvitek_get_frequency(void *opaque, struct video_frequency *vf)
495{
496 struct auvitek_softc *sc = opaque;
497
498 if (sc->sc_vinput != AUVITEK_INPUT_TELEVISION &&
499 sc->sc_vinput != AUVITEK_INPUT_CABLE)
500 return EINVAL;
501
502 vf->tuner_index = AUVITEK_TUNER_DEFAULT;
503 vf->frequency = sc->sc_curfreq;
504
505 return 0;
506}
507
508static int
509auvitek_set_frequency(void *opaque, struct video_frequency *vf)
510{
511 struct auvitek_softc *sc = opaque;
512 struct xc5k_params params;
513 int error;
514
515 if (sc->sc_vinput != AUVITEK_INPUT_TELEVISION &&
516 sc->sc_vinput != AUVITEK_INPUT_CABLE)
517 return EINVAL;
518 if (vf->tuner_index != AUVITEK_TUNER_DEFAULT)
519 return EINVAL;
520 if (sc->sc_xc5k == NULL)
521 return ENODEV;
522
523 params.standard = VIDEO_STANDARD_NTSC_M;
524 if (sc->sc_vinput == AUVITEK_INPUT_TELEVISION)
525 params.signal_source = XC5K_SIGNAL_SOURCE_AIR;
526 else
527 params.signal_source = XC5K_SIGNAL_SOURCE_CABLE;
528 params.frequency = vf->frequency;
529 if (sc->sc_au8522)
530 au8522_set_audio(sc->sc_au8522, false);
531 error = xc5k_tune_video(sc->sc_xc5k, &params);
532 if (sc->sc_au8522)
533 au8522_set_audio(sc->sc_au8522, true);
534 if (error)
535 return error;
536
537 sc->sc_curfreq = vf->frequency;
538
539 auvitek_write_1(sc, AU0828_REG_SENSOR_CTL, 0x00);
540 delay(30000);
541 auvitek_write_1(sc, AU0828_REG_SENSOR_CTL, 0xb3);
542
543 return 0;
544}
545
546static int
547auvitek_start_xfer(struct auvitek_softc *sc)
548{
549 struct auvitek_xfer *ax = &sc->sc_ax;
550 uint32_t vframe_len, uframe_len, nframes;
551 usbd_status err;
552 int i;
553
554 err = usbd_set_interface(sc->sc_isoc_iface, AUVITEK_XFER_ALTNO);
555 if (err != USBD_NORMAL_COMPLETION) {
556 aprint_error_dev(sc->sc_dev, "couldn't set altno %d: %s\n",
557 AUVITEK_XFER_ALTNO, usbd_errstr(err));
558 return EIO;
559 }
560
561 vframe_len = 720 * 480 * 2;
562 uframe_len = ax->ax_maxpktlen;
563 nframes = (vframe_len + uframe_len - 1) / uframe_len;
564 nframes = (nframes + 7) & ~7;
565
566 ax->ax_nframes = nframes;
567 ax->ax_uframe_len = uframe_len;
568 for (i = 0; i < AUVITEK_NISOC_XFERS; i++) {
569 struct auvitek_isoc *isoc = &ax->ax_i[i];
570 isoc->i_ax = ax;
571 isoc->i_frlengths =
572 kmem_alloc(sizeof(isoc->i_frlengths[0]) * nframes,
573 KM_SLEEP);
574 }
575
576 err = usbd_open_pipe(sc->sc_isoc_iface, ax->ax_endpt,
577 USBD_EXCLUSIVE_USE, &ax->ax_pipe);
578 if (err != USBD_NORMAL_COMPLETION) {
579 aprint_error_dev(sc->sc_dev, "couldn't open pipe: %s\n",
580 usbd_errstr(err));
581 return EIO;
582 }
583
584 for (i = 0; i < AUVITEK_NISOC_XFERS; i++) {
585 struct auvitek_isoc *isoc = &ax->ax_i[i];
586
587 int error = usbd_create_xfer(ax->ax_pipe,
588 nframes * uframe_len, 0, ax->ax_nframes, &isoc->i_xfer);
589 if (error) {
590 aprint_error_dev(sc->sc_dev,
591 "couldn't create usb xfer\n");
592 return error;
593 }
594
595 isoc->i_buf = usbd_get_buffer(isoc->i_xfer);
596 }
597
598 return auvitek_isoc_start(sc);
599}
600
601static int
602auvitek_stop_xfer(struct auvitek_softc *sc)
603{
604 struct auvitek_xfer *ax = &sc->sc_ax;
605 usbd_status err;
606 int i;
607
608 if (ax->ax_pipe != NULL) {
609 usbd_abort_pipe(ax->ax_pipe);
610 }
611 for (i = 0; i < AUVITEK_NISOC_XFERS; i++) {
612 struct auvitek_isoc *isoc = &ax->ax_i[i];
613 if (isoc->i_xfer != NULL) {
614 usbd_destroy_xfer(isoc->i_xfer);
615 isoc->i_xfer = NULL;
616 }
617 if (isoc->i_frlengths != NULL) {
618 kmem_free(isoc->i_frlengths,
619 sizeof(isoc->i_frlengths[0]) * ax->ax_nframes);
620 isoc->i_frlengths = NULL;
621 }
622 }
623 if (ax->ax_pipe != NULL) {
624 usbd_close_pipe(ax->ax_pipe);
625 ax->ax_pipe = NULL;
626 }
627
628 usbd_delay_ms(sc->sc_udev, 1000);
629 err = usbd_set_interface(sc->sc_isoc_iface, 0);
630 if (err != USBD_NORMAL_COMPLETION) {
631 aprint_error_dev(sc->sc_dev,
632 "couldn't set zero bw interface: %s\n",
633 usbd_errstr(err));
634 return EIO;
635 }
636
637 return 0;
638}
639
640static int
641auvitek_isoc_start(struct auvitek_softc *sc)
642{
643 struct auvitek_xfer *ax = &sc->sc_ax;
644 int i, error;
645
646 ax->ax_av.av_el = ax->ax_av.av_ol = 0;
647 ax->ax_av.av_eb = ax->ax_av.av_ob = 0;
648 ax->ax_av.av_stride = 720 * 2;
649
650 for (i = 0; i < AUVITEK_NISOC_XFERS; i++) {
651 error = auvitek_isoc_start1(&ax->ax_i[i]);
652 if (error)
653 return error;
654 }
655
656 return 0;
657}
658
659static int
660auvitek_isoc_start1(struct auvitek_isoc *isoc)
661{
662 struct auvitek_xfer *ax = isoc->i_ax;
663 struct auvitek_softc *sc = ax->ax_sc;
664 usbd_status err;
665 unsigned int i;
666
667 ax = isoc->i_ax;
668
669 for (i = 0; i < ax->ax_nframes; i++)
670 isoc->i_frlengths[i] = ax->ax_uframe_len;
671
672 usbd_setup_isoc_xfer(isoc->i_xfer,
673 isoc,
674 isoc->i_frlengths,
675 ax->ax_nframes,
676 USBD_SHORT_XFER_OK,
677 auvitek_isoc_intr);
678
679 err = usbd_transfer(isoc->i_xfer);
680 if (err != USBD_IN_PROGRESS) {
681 aprint_error_dev(sc->sc_dev, "couldn't start isoc xfer: %s\n",
682 usbd_errstr(err));
683 return ENODEV;
684 }
685
686 return 0;
687}
688
689static void
690auvitek_isoc_intr(struct usbd_xfer *xfer, void * priv,
691 usbd_status status)
692{
693 struct auvitek_isoc *isoc = priv;
694 struct auvitek_xfer *ax = isoc->i_ax;
695 struct auvitek_softc *sc = ax->ax_sc;
696 uint32_t count;
697 uint8_t *buf;
698 unsigned int i;
699
700 if (sc->sc_dying)
701 return;
702
703 if (status != USBD_NORMAL_COMPLETION) {
704 if (status == USBD_STALLED) {
705 usbd_clear_endpoint_stall_async(ax->ax_pipe);
706 goto next;
707 }
708 return;
709 }
710
711 usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL);
712
713 if (count == 0)
714 goto next;
715
716 for (i = 0, buf = isoc->i_buf;
717 i < ax->ax_nframes;
718 ++i, buf += ax->ax_uframe_len) {
719 status = auvitek_isoc_process(sc, buf, isoc->i_frlengths[i]);
720 if (status == USBD_IOERROR)
721 break;
722 }
723
724next:
725 auvitek_isoc_start1(isoc);
726}
727
728static int
729auvitek_isoc_process(struct auvitek_softc *sc, uint8_t *buf, uint32_t len)
730{
731 struct video_payload payload;
732 bool submit = false;
733
734 if (buf[0] & 0x80) {
735 sc->sc_ax.ax_frinfo = buf[0];
736 if (sc->sc_ax.ax_frinfo & 0x40) {
737 sc->sc_ax.ax_frno = !sc->sc_ax.ax_frno;
738 submit = true;
739 }
740 buf += 4;
741 len -= 4;
742 }
743 buf += 4;
744 len -= 4;
745
746 auvitek_videobuf_weave(sc, buf, len);
747
748 if (submit) {
749 payload.end_of_frame = 1;
750 payload.data = sc->sc_ax.ax_av.av_buf;
751 payload.size = sizeof(sc->sc_ax.ax_av.av_buf);
752 payload.frameno = -1;
753
754 video_submit_payload(sc->sc_videodev, &payload);
755
756 sc->sc_ax.ax_av.av_el = sc->sc_ax.ax_av.av_ol = 0;
757 sc->sc_ax.ax_av.av_eb = sc->sc_ax.ax_av.av_ob = 0;
758 }
759
760 return USBD_NORMAL_COMPLETION;
761}
762
763static void
764auvitek_videobuf_weave(struct auvitek_softc *sc, uint8_t *buf, uint32_t len)
765{
766 struct auvitek_videobuf *av = &sc->sc_ax.ax_av;
767 uint32_t resid, wlen;
768 uint32_t *l, *b;
769 uint8_t *vp;
770
771 if (sc->sc_ax.ax_frinfo & 0x40) {
772 l = &av->av_ol;
773 b = &av->av_ob;
774 vp = av->av_buf;
775 } else {
776 l = &av->av_el;
777 b = &av->av_eb;
778 vp = av->av_buf + av->av_stride;
779 }
780
781 resid = len;
782 while (resid > 0) {
783 if (*b == av->av_stride) {
784 *l = *l + 1;
785 *b = 0;
786 }
787 if (*l >= 240) {
788 break;
789 }
790 wlen = min(resid, av->av_stride - *b);
791 memcpy(vp + (av->av_stride * 2 * *l) + *b, buf, wlen);
792 *b += wlen;
793 buf += wlen;
794 resid -= wlen;
795 }
796}
797