/*      $NetBSD: umcpmio_transport.c,v 1.1 2025/11/29 18:39:14 brad Exp $       */

/*
 * Copyright (c) 2024, 2025 Brad Spencer <brad@anduin.eldar.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: umcpmio_transport.c,v 1.1 2025/11/29 18:39:14 brad Exp $");

#ifdef _KERNEL_OPT
#include "opt_usb.h"
#endif

#include <sys/param.h>
#include <sys/types.h>

#include <dev/hid/hid.h>

#include <dev/usb/uhidev.h>
#include <dev/usb/usb.h>
#include <dev/usb/usbdevs.h>
#include <dev/usb/usbdi.h>
#include <dev/usb/usbdi_util.h>
#include <dev/usb/usbhid.h>

#include <dev/usb/umcpmio.h>
#include <dev/usb/umcpmio_hid_reports.h>
#include <dev/usb/umcpmio_transport.h>
#include <dev/usb/umcpmio_io.h>
#include <dev/usb/umcpmio_subr.h>

#define UMCPMIO_DEBUG 1
#ifdef UMCPMIO_DEBUG
#define DPRINTF(x)      do { if (umcpmiodebug) printf x; } while (0)
#define DPRINTFN(n, x)  do { if (umcpmiodebug > (n)) printf x; } while (0)
extern int umcpmiodebug;
#else
#define DPRINTF(x)      __nothing
#define DPRINTFN(n, x)  __nothing
#endif


/* Stuff to communicate with the MCP2210 and MCP2221 / MCP2221A */


/*
 * Communication with the HID function requires sending a HID report
 * request and then waiting for a response.
 *
 * The panic that occurs when trying to use the interrupt... i.e.
 * attaching though this driver seems to be related to the fact that
 * a spin lock is held and the USB stack wants to wait.
 *
 * The USB stack *IS* going to have to wait for the response from
 * the device, somehow...
 *
 * It didn't seem possible to defer the uhidev_write to a thread.
 * Attempts to yield() while spinning hard also did not work and
 * not yield()ing didn't allow anything else to run.
 *
 */

/*
 * This is the panic you will get:
 *
 * panic: kernel diagnostic assertion "ci->ci_mtx_count == -1" failed: file "../../../../kern/kern_synch.c", line 762 mi_switch: cpu0: ci_mtx_count (-2) != -1 (block with spin-mutex held)
 */

static void
umcpmio_uhidev_intr(void *cookie, void *ibuf, u_int len)
{
        struct umcpmio_softc *sc = cookie;

        if (sc->sc_dying)
                return;

        DPRINTFN(30, ("umcpmio_uhidev_intr: len=%d\n", len));

        mutex_enter(&sc->sc_res_mutex);
        switch (len) {
        case MCP2221_RES_BUFFER_SIZE:
                if (sc->sc_res_buffer != NULL) {
                        memcpy(sc->sc_res_buffer, ibuf,
                            MCP2221_RES_BUFFER_SIZE);
                        sc->sc_res_ready = true;
                        cv_signal(&sc->sc_res_cv);
                } else {
                        int d = umcpmiodebug;
                        device_printf(sc->sc_dev,
                            "umcpmio_uhidev_intr: NULL sc_res_buffer:"
                            " len=%d\n",
                            len);
                        umcpmiodebug = 20;
                        umcpmio_dump_buffer(true, (uint8_t *) ibuf, len,
                            "umcpmio_uhidev_intr: ibuf");
                        umcpmiodebug = d;
                }

                break;
        default:
                device_printf(sc->sc_dev,
                    "umcpmio_uhidev_intr: Unknown interrupt length: %d",
                    len);
                break;
        }
        mutex_exit(&sc->sc_res_mutex);
}

/* Send a HID report.  This needs to be called with the action mutex held */

int
umcpmio_send_report(struct umcpmio_softc *sc, uint8_t *sendbuf,
    size_t sendlen, uint8_t *resbuf, int timeout)
{
        int err = 0;
        int err_count = 0;

        if (sc->sc_dying)
                return EIO;

        KASSERT(mutex_owned(&sc->sc_action_mutex));

        /* If this happens, it may be because the device was pulled from the
         * USB slot, or sometimes when SIGINTR occurs.  Just consider this a
         * EIO. */
        if (sc->sc_res_buffer != NULL) {
                sc->sc_res_buffer = NULL;
                sc->sc_res_ready = false;
                err = EIO;
                goto out;
        }
        sc->sc_res_buffer = resbuf;
        sc->sc_res_ready = false;

        err = uhidev_write(sc->sc_hdev, sendbuf, sendlen);

        if (err) {
                DPRINTF(("umcpmio_send_report: uhidev_write errored with:"
                    " err=%d\n", err));
                goto out;
        }
        DPRINTFN(30, ("umcpmio_send_report: about to wait on cv.  err=%d\n",
            err));

        mutex_enter(&sc->sc_res_mutex);
        while (!sc->sc_res_ready) {
                DPRINTFN(20, ("umcpmio_send_report: LOOP for response."
                    "  sc_res_ready=%d, err_count=%d, timeout=%d\n",
                    sc->sc_res_ready, err_count, mstohz(timeout)));

                err = cv_timedwait_sig(&sc->sc_res_cv, &sc->sc_res_mutex,
                    mstohz(timeout));

                /* We are only going to allow this to loop on an error, any
                 * error at all, so many times. */
                if (err) {
                        DPRINTF(("umcpmio_send_report:"
                            " cv_timedwait_sig reported an error:"
                            " err=%d, sc->sc_res_ready=%d\n",
                            err, sc->sc_res_ready));
                        err_count++;
                }

                /* The CV was interrupted, but the buffer is ready so, clear
                 * the error and break out. */
                if ((err == ERESTART) && (sc->sc_res_ready)) {
                        DPRINTF(("umcpmio_send_report:"
                            " ERESTART and buffer is ready\n"));
                        err = 0;
                        break;
                }

                /* Too many times though the loop, just break out.  Turn a
                 * ERESTART (interruption) into a I/O error at this point. */
                if (err_count > sc->sc_response_errcnt) {
                        DPRINTF(("umcpmio_send_report: err_count exceeded:"
                            " err=%d\n", err));
                        if (err == ERESTART)
                                err = EIO;
                        break;
                }

                /* This is a normal timeout, without interruption, try again */
                if (err == EWOULDBLOCK) {
                        DPRINTF(("umcpmio_send_report: EWOULDBLOCK:"
                            " err_count=%d\n", err_count));
                        continue;
                }

                /* The CV was interrupted and the buffer wasn't filled in, so
                 * try again */
                if ((err == ERESTART) && (!sc->sc_res_ready)) {
                        DPRINTF(("umcpmio_send_report:"
                            " ERESTART and buffer is NOT ready."
                            "  err_count=%d\n", err_count));
                        continue;
                }
        }

        sc->sc_res_buffer = NULL;
        sc->sc_res_ready = false;
        mutex_exit(&sc->sc_res_mutex);

        /* Turn most errors into an I/O error */
        if (err &&
            err != ERESTART)
                err = EIO;

out:
        return err;
}

int
umcpmio_hid_open(struct umcpmio_softc *sc)
{
        int err;

        err = uhidev_open(sc->sc_hdev, &umcpmio_uhidev_intr, sc);
        if (err) {
                aprint_error_dev(sc->sc_dev, "umcpmio_hid_open: "
                    " uhidev_open: err=%d\n", err);
        }

        /* It is not clear that this should be needed, but it was noted that
         * the MCP2221 / MCP2221A would sometimes not be ready if this delay
         * was not present.  In fact, the attempts to set stuff a little
         * later would sometimes fail.
         */

        if (!err)
                delay(1000);

        return err;
}