/* $NetBSD: pseye.c,v 1.29 2022/03/03 06:23:25 riastradh Exp $ */

/*-
 * Copyright (c) 2008 Jared D. McNeill <jmcneill@invisible.ca>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

/*
 * Sony PlayStation Eye Driver
 *
 * The only documentation we have for this part is based on a series
 * of forum postings by Jim Paris on ps2dev.org. Many thanks for
 * figuring this one out.
 *
 * URL: http://forums.ps2dev.org/viewtopic.php?t=9238
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: pseye.c,v 1.29 2022/03/03 06:23:25 riastradh Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <sys/fcntl.h>
#include <sys/conf.h>
#include <sys/poll.h>
#include <sys/bus.h>
#include <sys/mutex.h>
#include <sys/kthread.h>
#include <sys/condvar.h>
#include <sys/module.h>

#include <dev/usb/usb.h>
#include <dev/usb/usbdi.h>
#include <dev/usb/usbdivar.h>
#include <dev/usb/usbdi_util.h>
#include <dev/usb/usbdevs.h>
#include <dev/usb/uvideoreg.h>

#include <dev/video_if.h>

#define PRI_PSEYE	PRI_BIO

/* Bulk-in buffer length -- make room for payload + UVC headers */
#define PSEYE_BULKIN_BUFLEN	((640 * 480 * 2) + 4096)
#define PSEYE_BULKIN_BLKLEN	2048

/* SCCB/sensor interface */
#define PSEYE_SCCB_ADDRESS	0xf1
#define PSEYE_SCCB_SUBADDR	0xf2
#define PSEYE_SCCB_WRITE	0xf3
#define PSEYE_SCCB_READ		0xf4
#define PSEYE_SCCB_OPERATION	0xf5
#define PSEYE_SCCB_STATUS	0xf6

#define PSEYE_SCCB_OP_WRITE_3	0x37
#define PSEYE_SCCB_OP_WRITE_2	0x33
#define PSEYE_SCCB_OP_READ_2	0xf9

struct pseye_softc {
	device_t		sc_dev;

	struct usbd_device *	sc_udev;
	struct usbd_interface *	sc_iface;

	device_t		sc_videodev;
	char			sc_running;

	kcondvar_t		sc_cv;
	kmutex_t		sc_mtx;

	struct usbd_pipe *	sc_bulkin_pipe;
	struct usbd_xfer *	sc_bulkin_xfer;
	int			sc_bulkin;
	uint8_t			*sc_bulkin_buffer;
	int			sc_bulkin_bufferlen;

	char			sc_dying;

	char			sc_businfo[32];
};

static int	pseye_match(device_t, cfdata_t, void *);
static void	pseye_attach(device_t, device_t, void *);
static int	pseye_detach(device_t, int);
static void	pseye_childdet(device_t, device_t);
static int	pseye_activate(device_t, enum devact);

static void	pseye_init(struct pseye_softc *);
static void	pseye_sccb_init(struct pseye_softc *);
static void	pseye_stop(struct pseye_softc *);
static void	pseye_start(struct pseye_softc *);
static void	pseye_led(struct pseye_softc *, bool);
static uint8_t	pseye_getreg(struct pseye_softc *, uint16_t);
static void	pseye_setreg(struct pseye_softc *, uint16_t, uint8_t);
static void	pseye_setregv(struct pseye_softc *, uint16_t, uint8_t);
static void	pseye_sccb_setreg(struct pseye_softc *, uint8_t, uint8_t);
static bool	pseye_sccb_status(struct pseye_softc *);

static int	pseye_init_pipes(struct pseye_softc *);
static int	pseye_close_pipes(struct pseye_softc *);

static usbd_status	pseye_get_frame(struct pseye_softc *, uint32_t *);
static void	pseye_submit_payload(struct pseye_softc *, uint32_t);

/* video(9) API */
static int		pseye_open(void *, int);
static void		pseye_close(void *);
static const char *	pseye_get_devname(void *);
static const char *	pseye_get_businfo(void *);
static int		pseye_enum_format(void *, uint32_t,
					  struct video_format *);
static int		pseye_get_format(void *, struct video_format *);
static int		pseye_set_format(void *, struct video_format *);
static int		pseye_try_format(void *, struct video_format *);
static int		pseye_get_framerate(void *, struct video_fract *);
static int		pseye_set_framerate(void *, struct video_fract *);
static int		pseye_start_transfer(void *);
static int		pseye_stop_transfer(void *);

CFATTACH_DECL2_NEW(pseye, sizeof(struct pseye_softc),
    pseye_match, pseye_attach, pseye_detach, pseye_activate,
    NULL, pseye_childdet);

static const struct video_hw_if pseye_hw_if = {
	.open = pseye_open,
	.close = pseye_close,
	.get_devname = pseye_get_devname,
	.get_businfo = pseye_get_businfo,
	.enum_format = pseye_enum_format,
	.get_format = pseye_get_format,
	.set_format = pseye_set_format,
	.try_format = pseye_try_format,
	.get_framerate = pseye_get_framerate,
	.set_framerate = pseye_set_framerate,
	.start_transfer = pseye_start_transfer,
	.stop_transfer = pseye_stop_transfer,
	.control_iter_init = NULL,
	.control_iter_next = NULL,
	.get_control_desc_group = NULL,
	.get_control_group = NULL,
	.set_control_group = NULL,
};

static int
pseye_match(device_t parent, cfdata_t match, void *opaque)
{
	struct usbif_attach_arg *uiaa = opaque;

	if (uiaa->uiaa_class != UICLASS_VENDOR)
		return UMATCH_NONE;

	if (uiaa->uiaa_vendor == USB_VENDOR_OMNIVISION2) {
		switch (uiaa->uiaa_product) {
		case USB_PRODUCT_OMNIVISION2_PSEYE:
			if (uiaa->uiaa_ifaceno != 0)
				return UMATCH_NONE;
			return UMATCH_VENDOR_PRODUCT;
		}
	}

	return UMATCH_NONE;
}

static void
pseye_attach(device_t parent, device_t self, void *opaque)
{
	struct pseye_softc *sc = device_private(self);
	struct usbif_attach_arg *uiaa = opaque;
	struct usbd_device *dev = uiaa->uiaa_device;
	usb_interface_descriptor_t *id = NULL;
	usb_endpoint_descriptor_t *ed = NULL, *ed_bulkin = NULL;
	char *devinfop;
	int i;

	aprint_naive("\n");
	aprint_normal("\n");

	devinfop = usbd_devinfo_alloc(dev, 0);
	aprint_normal_dev(self, "%s\n", devinfop);
	usbd_devinfo_free(devinfop);

	sc->sc_dev = self;
	sc->sc_udev = dev;
	sc->sc_iface = uiaa->uiaa_iface;
	snprintf(sc->sc_businfo, sizeof(sc->sc_businfo), "usb:%08x",
	    sc->sc_udev->ud_cookie.cookie);
	sc->sc_bulkin_bufferlen = PSEYE_BULKIN_BUFLEN;

	sc->sc_dying = sc->sc_running = 0;
	cv_init(&sc->sc_cv, device_xname(self));
	mutex_init(&sc->sc_mtx, MUTEX_DEFAULT, IPL_NONE);

	id = usbd_get_interface_descriptor(sc->sc_iface);
	if (id == NULL) {
		aprint_error_dev(self, "failed to get interface descriptor\n");
		sc->sc_dying = 1;
		return;
	}

	for (i = 0; i < id->bNumEndpoints; i++) {
		ed = usbd_interface2endpoint_descriptor(sc->sc_iface, i);
		if (ed == NULL) {
			aprint_error_dev(self, "couldn't get ep %d\n", i);
			sc->sc_dying = 1;
			return;
		}

		if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
		    UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
			ed_bulkin = ed;
			break;
		}
	}

	if (ed_bulkin == NULL) {
		aprint_error_dev(self, "no bulk-in endpoint found\n");
		sc->sc_dying = 1;
		return;
	}

	sc->sc_bulkin = ed_bulkin->bEndpointAddress;

	int error = pseye_init_pipes(sc);
	if (error) {
		aprint_error_dev(self, "couldn't open pipes\n");
		return;
	}

	error = usbd_create_xfer(sc->sc_bulkin_pipe, sc->sc_bulkin_bufferlen,
	    0, 0, &sc->sc_bulkin_xfer);
	if (error) {
		aprint_error_dev(self, "couldn't create transfer\n");
		pseye_close_pipes(sc);
		return;
	}

	sc->sc_bulkin_buffer = usbd_get_buffer(sc->sc_bulkin_xfer);

	pseye_init(sc);

	if (!pmf_device_register(self, NULL, NULL))
		aprint_error_dev(self, "couldn't establish power handler\n");

	sc->sc_videodev = video_attach_mi(&pseye_hw_if, self, sc);
	if (sc->sc_videodev == NULL) {
		aprint_error_dev(self, "couldn't attach video layer\n");
		sc->sc_dying = 1;
		return;
	}

	usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev, self);

}

static int
pseye_detach(device_t self, int flags)
{
	struct pseye_softc *sc = device_private(self);

	sc->sc_dying = 1;

	pmf_device_deregister(self);

	if (sc->sc_videodev != NULL) {
		config_detach(sc->sc_videodev, flags);
		sc->sc_videodev = NULL;
	}

	if (sc->sc_bulkin_pipe != NULL) {
		usbd_abort_pipe(sc->sc_bulkin_pipe);
	}

	if (sc->sc_bulkin_xfer != NULL) {
		usbd_destroy_xfer(sc->sc_bulkin_xfer);
		sc->sc_bulkin_xfer = NULL;
	}

	if (sc->sc_bulkin_pipe != NULL) {
		usbd_close_pipe(sc->sc_bulkin_pipe);
		sc->sc_bulkin_pipe = NULL;
	}

	mutex_enter(&sc->sc_mtx);
	if (sc->sc_running) {
		sc->sc_running = 0;
		cv_wait_sig(&sc->sc_cv, &sc->sc_mtx);
	}
	mutex_exit(&sc->sc_mtx);

	cv_destroy(&sc->sc_cv);
	mutex_destroy(&sc->sc_mtx);

	usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, sc->sc_dev);

	return 0;
}

int
pseye_activate(device_t self, enum devact act)
{
	struct pseye_softc *sc = device_private(self);

	switch (act) {
	case DVACT_DEACTIVATE:
		sc->sc_dying = 1;
		return 0;
	default:
		return EOPNOTSUPP;
	}
}

static void
pseye_childdet(device_t self, device_t child)
{
	struct pseye_softc *sc = device_private(self);

	if (sc->sc_videodev) {
		KASSERT(sc->sc_videodev == child);
		sc->sc_videodev = NULL;
	}
}

/*
 * Device access
 */

static void
pseye_init(struct pseye_softc *sc)
{
	pseye_sccb_init(sc);

	pseye_setregv(sc, 0xc2, 0x0c);
	pseye_setregv(sc, 0x88, 0xf8);
	pseye_setregv(sc, 0xc3, 0x69);
	pseye_setregv(sc, 0x89, 0xff);
	pseye_setregv(sc, 0x76, 0x03);
	pseye_setregv(sc, 0x92, 0x01);
	pseye_setregv(sc, 0x93, 0x18);
	pseye_setregv(sc, 0x94, 0x10);
	pseye_setregv(sc, 0x95, 0x10);
	pseye_setregv(sc, 0xe2, 0x00);
	pseye_setregv(sc, 0xe7, 0x3e);

	pseye_setregv(sc, 0x96, 0x00);

	pseye_setreg(sc, 0x97, 0x20);
	pseye_setreg(sc, 0x97, 0x20);
	pseye_setreg(sc, 0x97, 0x20);
	pseye_setreg(sc, 0x97, 0x0a);
	pseye_setreg(sc, 0x97, 0x3f);
	pseye_setreg(sc, 0x97, 0x4a);
	pseye_setreg(sc, 0x97, 0x20);
	pseye_setreg(sc, 0x97, 0x15);
	pseye_setreg(sc, 0x97, 0x0b);

	pseye_setregv(sc, 0x8e, 0x40);
	pseye_setregv(sc, 0x1f, 0x81);
	pseye_setregv(sc, 0x34, 0x05);
	pseye_setregv(sc, 0xe3, 0x04);
	pseye_setregv(sc, 0x88, 0x00);
	pseye_setregv(sc, 0x89, 0x00);
	pseye_setregv(sc, 0x76, 0x00);
	pseye_setregv(sc, 0xe7, 0x2e);
	pseye_setregv(sc, 0x31, 0xf9);
	pseye_setregv(sc, 0x25, 0x42);
	pseye_setregv(sc, 0x21, 0xf0);

	pseye_setreg(sc, 0x1c, 0x00);
	pseye_setreg(sc, 0x1d, 0x40);
	pseye_setreg(sc, 0x1d, 0x02);	/* payload size 0x0200 * 4 == 2048 */
	pseye_setreg(sc, 0x1d, 0x00);
	pseye_setreg(sc, 0x1d, 0x02);	/* frame size 0x025800 * 4 == 614400 */
	pseye_setreg(sc, 0x1d, 0x58);
	pseye_setreg(sc, 0x1d, 0x00);

	pseye_setreg(sc, 0x1c, 0x0a);
	pseye_setreg(sc, 0x1d, 0x08);	/* enable UVC header */
	pseye_setreg(sc, 0x1d, 0x0e);

	pseye_setregv(sc, 0x8d, 0x1c);
	pseye_setregv(sc, 0x8e, 0x80);
	pseye_setregv(sc, 0xe5, 0x04);

	pseye_sccb_setreg(sc, 0x12, 0x80);
	pseye_sccb_setreg(sc, 0x11, 0x01);
	pseye_sccb_setreg(sc, 0x11, 0x01);
	pseye_sccb_setreg(sc, 0x11, 0x01);
	pseye_sccb_setreg(sc, 0x11, 0x01);
	pseye_sccb_setreg(sc, 0x11, 0x01);
	pseye_sccb_setreg(sc, 0x11, 0x01);
	pseye_sccb_setreg(sc, 0x11, 0x01);
	pseye_sccb_setreg(sc, 0x11, 0x01);
	pseye_sccb_setreg(sc, 0x11, 0x01);
	pseye_sccb_setreg(sc, 0x11, 0x01);
	pseye_sccb_setreg(sc, 0x11, 0x01);

	pseye_sccb_setreg(sc, 0x3d, 0x03);
	pseye_sccb_setreg(sc, 0x17, 0x26);
	pseye_sccb_setreg(sc, 0x18, 0xa0);
	pseye_sccb_setreg(sc, 0x19, 0x07);
	pseye_sccb_setreg(sc, 0x1a, 0xf0);
	pseye_sccb_setreg(sc, 0x32, 0x00);
	pseye_sccb_setreg(sc, 0x29, 0xa0);
	pseye_sccb_setreg(sc, 0x2c, 0xf0);
	pseye_sccb_setreg(sc, 0x65, 0x20);
	pseye_sccb_setreg(sc, 0x11, 0x01);
	pseye_sccb_setreg(sc, 0x42, 0x7f);
	pseye_sccb_setreg(sc, 0x63, 0xe0);
	pseye_sccb_setreg(sc, 0x64, 0xff);
	pseye_sccb_setreg(sc, 0x66, 0x00);
	pseye_sccb_setreg(sc, 0x13, 0xf0);
	pseye_sccb_setreg(sc, 0x0d, 0x41);
	pseye_sccb_setreg(sc, 0x0f, 0xc5);
	pseye_sccb_setreg(sc, 0x14, 0x11);

	pseye_sccb_setreg(sc, 0x22, 0x7f);
	pseye_sccb_setreg(sc, 0x23, 0x03);
	pseye_sccb_setreg(sc, 0x24, 0x40);
	pseye_sccb_setreg(sc, 0x25, 0x30);
	pseye_sccb_setreg(sc, 0x26, 0xa1);
	pseye_sccb_setreg(sc, 0x2a, 0x00);
	pseye_sccb_setreg(sc, 0x2b, 0x00);
	pseye_sccb_setreg(sc, 0x6b, 0xaa);
	pseye_sccb_setreg(sc, 0x13, 0xff);

	pseye_sccb_setreg(sc, 0x90, 0x05);
	pseye_sccb_setreg(sc, 0x91, 0x01);
	pseye_sccb_setreg(sc, 0x92, 0x03);
	pseye_sccb_setreg(sc, 0x93, 0x00);
	pseye_sccb_setreg(sc, 0x94, 0x60);
	pseye_sccb_setreg(sc, 0x95, 0x3c);
	pseye_sccb_setreg(sc, 0x96, 0x24);
	pseye_sccb_setreg(sc, 0x97, 0x1e);
	pseye_sccb_setreg(sc, 0x98, 0x62);
	pseye_sccb_setreg(sc, 0x99, 0x80);
	pseye_sccb_setreg(sc, 0x9a, 0x1e);
	pseye_sccb_setreg(sc, 0x9b, 0x08);
	pseye_sccb_setreg(sc, 0x9c, 0x20);
	pseye_sccb_setreg(sc, 0x9e, 0x81);

	pseye_sccb_setreg(sc, 0xa6, 0x04);
	pseye_sccb_setreg(sc, 0x7e, 0x0c);
	pseye_sccb_setreg(sc, 0x7f, 0x16);

	pseye_sccb_setreg(sc, 0x80, 0x2a);
	pseye_sccb_setreg(sc, 0x81, 0x4e);
	pseye_sccb_setreg(sc, 0x82, 0x61);
	pseye_sccb_setreg(sc, 0x83, 0x6f);
	pseye_sccb_setreg(sc, 0x84, 0x7b);
	pseye_sccb_setreg(sc, 0x85, 0x86);
	pseye_sccb_setreg(sc, 0x86, 0x8e);
	pseye_sccb_setreg(sc, 0x87, 0x97);
	pseye_sccb_setreg(sc, 0x88, 0xa4);
	pseye_sccb_setreg(sc, 0x89, 0xaf);
	pseye_sccb_setreg(sc, 0x8a, 0xc5);
	pseye_sccb_setreg(sc, 0x8b, 0xd7);
	pseye_sccb_setreg(sc, 0x8c, 0xe8);
	pseye_sccb_setreg(sc, 0x8d, 0x20);

	pseye_sccb_setreg(sc, 0x0c, 0x90);

	pseye_setregv(sc, 0xc0, 0x50);
	pseye_setregv(sc, 0xc1, 0x3c);
	pseye_setregv(sc, 0xc2, 0x0c);

	pseye_sccb_setreg(sc, 0x2b, 0x00);
	pseye_sccb_setreg(sc, 0x22, 0x7f);
	pseye_sccb_setreg(sc, 0x23, 0x03);
	pseye_sccb_setreg(sc, 0x11, 0x01);
	pseye_sccb_setreg(sc, 0x0c, 0xd0);
	pseye_sccb_setreg(sc, 0x64, 0xff);
	pseye_sccb_setreg(sc, 0x0d, 0x41);

	pseye_sccb_setreg(sc, 0x14, 0x41);
	pseye_sccb_setreg(sc, 0x0e, 0xcd);
	pseye_sccb_setreg(sc, 0xac, 0xbf);
	pseye_sccb_setreg(sc, 0x8e, 0x00);
	pseye_sccb_setreg(sc, 0x0c, 0xd0);

	pseye_stop(sc);
}

static void
pseye_sccb_init(struct pseye_softc *sc)
{
	pseye_setregv(sc, 0xe7, 0x3a);
	pseye_setreg(sc, PSEYE_SCCB_ADDRESS, 0x60);
	pseye_setreg(sc, PSEYE_SCCB_ADDRESS, 0x60);
	pseye_setreg(sc, PSEYE_SCCB_ADDRESS, 0x60);
	pseye_setreg(sc, PSEYE_SCCB_ADDRESS, 0x42);
}

static void
pseye_stop(struct pseye_softc *sc)
{
	pseye_led(sc, false);
	pseye_setreg(sc, 0xe0, 0x09);
}

static void
pseye_start(struct pseye_softc *sc)
{
	pseye_led(sc, true);
	pseye_setreg(sc, 0xe0, 0x00);
}

static void
pseye_led(struct pseye_softc *sc, bool enabled)
{
	uint8_t val;

	val = pseye_getreg(sc, 0x21);
	pseye_setreg(sc, 0x21, val | 0x80);

	val = pseye_getreg(sc, 0x23);
	if (enabled == true)
		val |= 0x80;
	else
		val &= ~0x80;
	pseye_setreg(sc, 0x23, val);
}

static uint8_t
pseye_getreg(struct pseye_softc *sc, uint16_t reg)
{
	usb_device_request_t req;
	usbd_status err;
	uint8_t buf;

	req.bmRequestType = UT_READ_VENDOR_DEVICE;
	req.bRequest = 1;
	USETW(req.wValue, 0x0000);
	USETW(req.wIndex, reg);
	USETW(req.wLength, 1);

	err = usbd_do_request(sc->sc_udev, &req, &buf);
	if (err) {
		aprint_error_dev(sc->sc_dev, "couldn't read reg 0x%04x: %s\n",
		    reg, usbd_errstr(err));
		return 0xff;
	}

	return buf;
}

static void
pseye_setreg(struct pseye_softc *sc, uint16_t reg, uint8_t val)
{
	usb_device_request_t req;
	usbd_status err;

	req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
	req.bRequest = 1;
	USETW(req.wValue, 0x0000);
	USETW(req.wIndex, reg);
	USETW(req.wLength, 1);

	err = usbd_do_request(sc->sc_udev, &req, &val);
	if (err)
		aprint_error_dev(sc->sc_dev, "couldn't write reg 0x%04x: %s\n",
		    reg, usbd_errstr(err));
}

static void
pseye_setregv(struct pseye_softc *sc, uint16_t reg, uint8_t val)
{
	pseye_setreg(sc, reg, val);
	if (pseye_getreg(sc, reg) != val)
		aprint_error_dev(sc->sc_dev, "couldn't verify reg 0x%04x\n",
		    reg);
}

static void
pseye_sccb_setreg(struct pseye_softc *sc, uint8_t reg, uint8_t val)
{
	pseye_setreg(sc, PSEYE_SCCB_SUBADDR, reg);
	pseye_setreg(sc, PSEYE_SCCB_WRITE, val);
	pseye_setreg(sc, PSEYE_SCCB_OPERATION, PSEYE_SCCB_OP_WRITE_3);

	if (pseye_sccb_status(sc) == false)
		aprint_error_dev(sc->sc_dev, "couldn't write sccb reg 0x%04x\n",
		    reg);
}

static bool
pseye_sccb_status(struct pseye_softc *sc)
{
	int retry = 5;
	uint8_t reg;

	while (retry-- >= 0) {
		reg = pseye_getreg(sc, PSEYE_SCCB_STATUS);
		if (reg == 0x00)
			return true;
		else if (reg == 0x04)
			return false;
	}

	aprint_error_dev(sc->sc_dev, "timeout reading sccb status\n");
	return false;
}

static usbd_status
pseye_get_frame(struct pseye_softc *sc, uint32_t *plen)
{
	if (sc->sc_dying)
		return USBD_IOERROR;

	return usbd_bulk_transfer(sc->sc_bulkin_xfer, sc->sc_bulkin_pipe,
	    USBD_SHORT_XFER_OK, 1000, sc->sc_bulkin_buffer, plen);
}

static int
pseye_init_pipes(struct pseye_softc *sc)
{
	usbd_status err;

	if (sc->sc_dying)
		return EIO;

	err = usbd_open_pipe(sc->sc_iface, sc->sc_bulkin, 0,
	    &sc->sc_bulkin_pipe);
	if (err) {
		aprint_error_dev(sc->sc_dev, "couldn't open bulk-in pipe: %s\n",
		    usbd_errstr(err));
		return ENOMEM;
	}

	return 0;
}

int
pseye_close_pipes(struct pseye_softc *sc)
{
	if (sc->sc_bulkin_pipe != NULL) {
		usbd_abort_pipe(sc->sc_bulkin_pipe);
		usbd_close_pipe(sc->sc_bulkin_pipe);
		sc->sc_bulkin_pipe = NULL;
	}

	return 0;
}

static void
pseye_submit_payload(struct pseye_softc *sc, uint32_t tlen)
{
	struct video_payload payload;
	uvideo_payload_header_t *uvchdr;
	uint8_t *buf = sc->sc_bulkin_buffer;
	uint32_t len;
	uint32_t brem = (640*480*2);

	while (brem > 0 && tlen > 0) {
		len = uimin(tlen, PSEYE_BULKIN_BLKLEN);
		if (len < UVIDEO_PAYLOAD_HEADER_SIZE) {
			printf("pseye_submit_payload: len=%u\n", len);
			return;
		}

		uvchdr = (uvideo_payload_header_t *)buf;
		if (uvchdr->bHeaderLength != UVIDEO_PAYLOAD_HEADER_SIZE)
			goto next;
		if (uvchdr->bHeaderLength == len &&
		    !(uvchdr->bmHeaderInfo & UV_END_OF_FRAME))
			goto next;
		if (uvchdr->bmHeaderInfo & UV_ERROR)
			return;
		if ((uvchdr->bmHeaderInfo & UV_PRES_TIME) == 0)
			goto next;

		payload.data = buf + uvchdr->bHeaderLength;
		payload.size = uimin(brem, len - uvchdr->bHeaderLength);
		payload.frameno = UGETDW(&buf[2]);
		payload.end_of_frame = uvchdr->bmHeaderInfo & UV_END_OF_FRAME;
		video_submit_payload(sc->sc_videodev, &payload);

next:
		tlen -= len;
		buf += len;
		brem -= payload.size;
	}
}

static void
pseye_transfer_thread(void *opaque)
{
	struct pseye_softc *sc = opaque;
	uint32_t len;
	int error;

	while (sc->sc_running) {
		len = sc->sc_bulkin_bufferlen;
		error = pseye_get_frame(sc, &len);
		if (error == USBD_NORMAL_COMPLETION)
			pseye_submit_payload(sc, len);
	}

	mutex_enter(&sc->sc_mtx);
	cv_broadcast(&sc->sc_cv);
	mutex_exit(&sc->sc_mtx);

	kthread_exit(0);
}

/* video(9) API implementations */
static int
pseye_open(void *opaque, int flags)
{
	struct pseye_softc *sc = opaque;

	if (sc->sc_dying)
		return EIO;

	pseye_start(sc);

	return 0;
}

static void
pseye_close(void *opaque)
{
	struct pseye_softc *sc = opaque;

	pseye_stop(sc);
}

static const char *
pseye_get_devname(void *opaque)
{
	return "PlayStation Eye";
}

static const char *
pseye_get_businfo(void *opaque)
{
	struct pseye_softc *sc = opaque;

	return sc->sc_businfo;
}

static int
pseye_enum_format(void *opaque, uint32_t index, struct video_format *format)
{
	if (index != 0)
		return EINVAL;
	return pseye_get_format(opaque, format);
}

static int
pseye_get_format(void *opaque, struct video_format *format)
{
	format->pixel_format = VIDEO_FORMAT_YUY2; /* XXX actually YUYV */
	format->width = 640;
	format->height = 480;
	format->aspect_x = 4;
	format->aspect_y = 3;
	format->sample_size = format->width * format->height * 2;
	format->stride = format->width * 2;
	format->color.primaries = VIDEO_COLOR_PRIMARIES_UNSPECIFIED;
	format->color.gamma_function = VIDEO_GAMMA_FUNCTION_UNSPECIFIED;
	format->color.matrix_coeff = VIDEO_MATRIX_COEFF_UNSPECIFIED;
	format->interlace_flags = VIDEO_INTERLACE_ON;
	format->priv = 0;

	return 0;
}

static int
pseye_set_format(void *opaque, struct video_format *format)
{
#if notyet
	if (format->pixel_format != VIDEO_FORMAT_YUYV)
		return EINVAL;
	if (format->width != 640 || format->height != 480)
		return EINVAL;
#endif
	/* XXX */
	return pseye_get_format(opaque, format);
}

static int
pseye_try_format(void *opaque, struct video_format *format)
{
	return pseye_get_format(opaque, format);
}

static int
pseye_get_framerate(void *opaque, struct video_fract *fract)
{
	/* Driver only supports 60fps */
	fract->numerator = 1;
	fract->denominator = 60;

	return 0;
}

static int
pseye_set_framerate(void *opaque, struct video_fract *fract)
{
	/* Driver only supports one framerate. Return actual rate. */
	return pseye_get_framerate(opaque, fract);
}

static int
pseye_start_transfer(void *opaque)
{
	struct pseye_softc *sc = opaque;
	int err = 0;

	mutex_enter(&sc->sc_mtx);
	if (sc->sc_running == 0) {
		sc->sc_running = 1;
		err = kthread_create(PRI_PSEYE, 0, NULL, pseye_transfer_thread,
		    opaque, NULL, "%s", device_xname(sc->sc_dev));
	} else
		aprint_error_dev(sc->sc_dev, "transfer already in progress\n");
	mutex_exit(&sc->sc_mtx);

	return err;
}

static int
pseye_stop_transfer(void *opaque)
{
	struct pseye_softc *sc = opaque;

	mutex_enter(&sc->sc_mtx);
	if (sc->sc_running) {
		sc->sc_running = 0;
		cv_wait_sig(&sc->sc_cv, &sc->sc_mtx);
	}
	mutex_exit(&sc->sc_mtx);

	return 0;
}

MODULE(MODULE_CLASS_DRIVER, pseye, NULL);

#ifdef _MODULE
#include "ioconf.c"
#endif

static int
pseye_modcmd(modcmd_t cmd, void *opaque)
{
	switch (cmd) {
	case MODULE_CMD_INIT:
#ifdef _MODULE
		return config_init_component(cfdriver_ioconf_pseye,
		    cfattach_ioconf_pseye, cfdata_ioconf_pseye);
#else
		return 0;
#endif
	case MODULE_CMD_FINI:
#ifdef _MODULE
		return config_fini_component(cfdriver_ioconf_pseye,
		    cfattach_ioconf_pseye, cfdata_ioconf_pseye);
#else
		return 0;
#endif
	default:
		return ENOTTY;
	}
}