/* Riastradh Host Controller Interface */

static void
rhci_softintr(void *cookie)
{
	struct usbd_bus *bus = cookie;
	struct rhci_softc *sc = bus->ub_hcpriv;
	struct usbd_xfer *xfer;
	usbd_status status;

	KASSERT(polling || mutex_owned(&sc->sc_lock));

	while ((xfer = rhci_done_next(&status)) != NULL) {
		/*
		 * If software has completed it, either by cancellation
		 * or timeout, drop it on the floor.
		 */
		if (xfer->ux_status != USBD_IN_PROGRESS) {
			KASSERT(xfer->ux_status == USBD_CANCELLED ||
			    xfer->ux_status == USBD_TIMEOUT);
			continue;
		}

		/* Otherwise, set the status.  */
		KASSERT(status != USBD_IN_PROGRESS);
		xfer->ux_status = status;

		/*
		 * Cancel the timeout and the task, which have not yet
		 * run.  If they have already fired, at worst they are
		 * waiting for the lock.  They will see that the xfer
		 * is no longer in progress and give up.
		 */
		callout_stop(&xfer->ux_timeout);
		usb_rem_task(xfer->ux_pipe->up_dev, &xfer->ux_aborttask);

		/* Transfer is complete.  */
		usb_transfer_complete(xfer);
	}

	KASSERT(polling || mutex_owned(&sc->sc_lock));
}

static void
rhci_abort_xfer(struct usbd_xfer *xfer, usbd_status status)
{
	struct rhci_softc *sc = xfer->ux_bus->ub_hcpriv;

	KASSERTMSG((status == USBD_CANCELLED || status == USBD_TIMEOUT),
	    "invalid status for abort: %d", (int)status);
	KASSERT(mutex_owned(&sc->sc_lock));
	ASSERT_SLEEPABLE();

	if (status == USBD_CANCELLED) {
		/*
		 * We are synchronously aborting.  Try to stop the
		 * callout and task, but if we can't, wait for them to
		 * complete.
		 */
		callout_halt(&xfer->ux_callout, &sc->sc_lock);
		usb_rem_task_wait(sc->sc_dev, &xfer->ux_aborttask,
		    USB_TASKQ_HC, &sc->sc_lock);
	} else {
		/* Otherwise, we are timing out.  */
		KASSERT(status == USBD_TIMEOUT);
	}

	/*
	 * The xfer cannot have been cancelled already.  It is the
	 * responsibility of the caller of usbd_abort_pipe not to try
	 * to abort a pipe multiple times, whether concurrently or
	 * sequentially.
	 */
	KASSERT(xfer->ux_status != USBD_CANCELLED);

	/* Only the timeout, which runs only once, can time it out.  */
	KASSERT(xfer->ux_status != USBD_TIMEOUT);

	/* If anyone else beat us, we're done.  */
	if (xfer->ux_status != USBD_IN_PROGRESS)
		return;

	/* We beat everyone else.  Claim the status.  */
	xfer->ux_status = status;

	/*
	 * If we're dying, skip the hardware action and just notify the
	 * software that we're done.
	 */
	if (sc->sc_dying)
		goto out;

	/*
	 * Take whatever HCI-specific actions are necessary to notify
	 * the hardware that we're not interested any more.
	 */
	usb_syncmem(...);
	RWRITE4(...);
	usb_syncmem(...);
	...

out:
	usb_transfer_complete(xfer);
	KASSERT(mutex_owned(&sc->sc_lock));
}

static void
rhci_timeout(void *cookie)
{
	struct rhci_xfer *xfer = cookie;
	struct rhci_softc *sc = xfer->ux_bus->ub_hcpriv;

	mutex_enter(&sc->sc_lock);
	if (!sc->sc_dying && xfer->ux_status == USBD_IN_PROGRESS)
		usb_add_task(sc->sc_dev, &xfer->ux_aborttask, USB_TASKQ_HC);
	mutex_exit(&sc->sc_lock);
}

static void
rhci_timeout_task(void *cookie)
{
	struct usbd_xfer *xfer = cookie;
	struct rhci_softc *sc = xfer->ux_bus->ub_hcpriv;

	mutex_enter(&sc->sc_lock);
	rhci_abort_xfer(xfer, USBD_TIMEOUT);
	mutex_exit(&sc->sc_lock);
}