/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2026 Abdelkader Boudih <dragonflybsd@seuros.com>
 */

/*
 * Apple IR Remote Control Driver
 *
 * USB driver for Apple IR receivers (USB HID, vendor 0x05ac).
 * Supports Apple Remote and generic IR remotes using NEC protocol.
 *
 * The Apple Remote protocol was reverse-engineered by James McKenzie and
 * others; key codes and packet format constants are derived from that work.
 *
 * Apple Remote Protocol (proprietary):
 *   Key down:    [0x25][0x87][0xee][remote_id][key_code]
 *   Key repeat:  [0x26][0x87][0xee][remote_id][key_code]
 *   Battery low: [0x25][0x87][0xe0][remote_id][0x00]
 *   Key decode:  (byte4 >> 1) & 0x0F -> keymap[index]
 *   Two-packet:  bit 6 of key_code (0x40) set -> store index, use on next keydown
 *
 * Generic IR Protocol (NEC-style):
 *   Format:     [0x26][0x7f][0x80][code][~code]
 *   Checksum:   code + ~code = 0xFF
 *
 * NO hardware key-up events -- synthesize via 125ms callout timer.
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/bus.h>
#include <sys/callout.h>
#include <sys/lock.h>
#include <sys/malloc.h>
#include <sys/module.h>
#include <sys/sysctl.h>

#include <bus/u4b/usb.h>
#include <bus/u4b/usbdi.h>
#include <bus/u4b/usbdi_util.h>
#include <bus/u4b/usbhid.h>

#include "usbdevs.h"

#define USB_DEBUG_VAR apple_ir_debug
#include <bus/u4b/usb_debug.h>

#include <dev/misc/evdev/evdev.h>
#include <dev/misc/evdev/input.h>

#ifdef USB_DEBUG
static int apple_ir_debug = 0;

static SYSCTL_NODE(_hw_usb, OID_AUTO, apple_ir, CTLFLAG_RW, 0,
    "Apple IR Remote Control");
SYSCTL_INT(_hw_usb_apple_ir, OID_AUTO, debug, CTLFLAG_RW,
    &apple_ir_debug, 0, "Debug level");
TUNABLE_INT("hw.usb.apple_ir.debug", &apple_ir_debug);
#endif

/* Protocol constants */
#define APPLEIR_REPORT_LEN      5
#define APPLEIR_KEY_MASK        0x0F
#define APPLEIR_TWO_PKT_FLAG    0x40    /* bit 6: two-packet command */
#define APPLEIR_KEYUP_TICKS     MAX(1, hz / 8)  /* 125ms */
#define APPLEIR_TWOPKT_TICKS    MAX(1, hz / 4)  /* 250ms */
#define APPLEIR_BUFFER_MAX      8

/* Report type markers (byte 0) */
#define APPLEIR_PKT_KEYDOWN     0x25    /* key down / battery low */
#define APPLEIR_PKT_REPEAT      0x26    /* key repeat / NEC generic */

/* Apple Remote signature (bytes 1-2) */
#define APPLEIR_SIG_HI          0x87
#define APPLEIR_SIG_KEYLO       0xee    /* normal key event */
#define APPLEIR_SIG_BATTLO      0xe0    /* battery low event */

/* Generic IR NEC signature (bytes 1-2) */
#define APPLEIR_NEC_HI          0x7f
#define APPLEIR_NEC_LO          0x80
#define APPLEIR_NEC_CHECKSUM    0xFF    /* code + ~code must equal this */

/*
 * Apple IR keymap: 17 entries, index = (key_code >> 1) & 0x0F
 * Based on protocol reverse-engineering by James McKenzie and others.
 */
static const uint16_t apple_ir_keymap[] = {
        KEY_RESERVED,           /* 0x00 */
        KEY_MENU,               /* 0x01 - menu */
        KEY_PLAYPAUSE,          /* 0x02 - play/pause */
        KEY_FORWARD,            /* 0x03 - >> */
        KEY_BACK,               /* 0x04 - << */
        KEY_VOLUMEUP,           /* 0x05 - + */
        KEY_VOLUMEDOWN,         /* 0x06 - - */
        KEY_RESERVED,           /* 0x07 */
        KEY_RESERVED,           /* 0x08 */
        KEY_RESERVED,           /* 0x09 */
        KEY_RESERVED,           /* 0x0A */
        KEY_RESERVED,           /* 0x0B */
        KEY_RESERVED,           /* 0x0C */
        KEY_RESERVED,           /* 0x0D */
        KEY_ENTER,              /* 0x0E - middle button (two-packet) */
        KEY_PLAYPAUSE,          /* 0x0F - play/pause (two-packet) */
        KEY_RESERVED,           /* 0x10 - out of range guard */
};
#define APPLEIR_NKEYS   (nitems(apple_ir_keymap))

/*
 * Generic IR keymap (NEC protocol codes).
 * Maps raw NEC codes to evdev KEY_* codes.
 */
struct generic_ir_map {
        uint8_t         code;           /* NEC IR code */
        uint16_t        key;            /* evdev KEY_* */
};

static const struct generic_ir_map generic_keymap[] = {
        { 0xe1, KEY_VOLUMEUP },
        { 0xe9, KEY_VOLUMEDOWN },
        { 0xed, KEY_CHANNELUP },
        { 0xf3, KEY_CHANNELDOWN },
        { 0xf5, KEY_PLAYPAUSE },
        { 0xf9, KEY_POWER },
        { 0xfb, KEY_MUTE },
        { 0xfe, KEY_OK },
};
#define GENERIC_NKEYS   (nitems(generic_keymap))

static uint16_t
generic_ir_lookup(uint8_t code)
{
        unsigned int i;

        for (i = 0; i < GENERIC_NKEYS; i++) {
                if (generic_keymap[i].code == code)
                        return (generic_keymap[i].key);
        }
        return (KEY_RESERVED);
}

enum {
        APPLEIR_INTR_DT,
        APPLEIR_N_TRANSFER,
};

struct apple_ir_softc {
        device_t                sc_dev;
        struct usb_xfer         *sc_xfer[APPLEIR_N_TRANSFER];
        struct lock             sc_lock;
        struct evdev_dev        *sc_evdev;
        struct callout          sc_co;          /* key-up timer */
        struct callout          sc_twoco;       /* two-packet timeout */
        uint16_t                sc_current_key; /* evdev keycode (0=none) */
        int                     sc_prev_key_idx;/* two-packet state (0=none) */
        uint8_t                 sc_batt_warned;
        uint8_t                 sc_buf[APPLEIR_BUFFER_MAX];
};

/*
 * Callout: synthesize key-up event (no hardware key-up from remote).
 * Runs with sc_lock held (callout_init_lk).
 */
static void
apple_ir_keyup(void *arg)
{
        struct apple_ir_softc *sc = arg;

        KKASSERT(lockowned(&sc->sc_lock));

        if (sc->sc_current_key != 0) {
                evdev_push_key(sc->sc_evdev, sc->sc_current_key, 0);
                evdev_sync(sc->sc_evdev);
                sc->sc_current_key = 0;
                sc->sc_prev_key_idx = 0;
        }
}

static void
apple_ir_twopacket_timeout(void *arg)
{
        struct apple_ir_softc *sc = arg;

        KKASSERT(lockowned(&sc->sc_lock));
        sc->sc_prev_key_idx = 0;
}

/*
 * Process 5-byte USB interrupt report.
 */
static void
apple_ir_process_report(struct apple_ir_softc *sc, uint8_t *report, int len)
{
        int index;
        uint16_t new_key;

        if (len != APPLEIR_REPORT_LEN) {
                DPRINTFN(1, "bad report len: %d\n", len);
                return;
        }

        /* Battery low: [KEYDOWN][SIG_HI][SIG_BATTLO] -- log and ignore */
        if (report[0] == APPLEIR_PKT_KEYDOWN &&
            report[1] == APPLEIR_SIG_HI && report[2] == APPLEIR_SIG_BATTLO) {
                if (!sc->sc_batt_warned) {
                        device_printf(sc->sc_dev,
                            "remote battery may be low\n");
                        sc->sc_batt_warned = 1;
                }
                return;
        }

        /* Key down: [KEYDOWN][SIG_HI][SIG_KEYLO][remote_id][key_code] */
        if (report[0] == APPLEIR_PKT_KEYDOWN &&
            report[1] == APPLEIR_SIG_HI && report[2] == APPLEIR_SIG_KEYLO) {
                /* Release previous key if held */
                if (sc->sc_current_key != 0) {
                        evdev_push_key(sc->sc_evdev, sc->sc_current_key, 0);
                        evdev_sync(sc->sc_evdev);
                        sc->sc_current_key = 0;
                }

                if (sc->sc_prev_key_idx > 0) {
                        /* Second packet of a two-packet command */
                        index = sc->sc_prev_key_idx;
                        sc->sc_prev_key_idx = 0;
                        callout_stop(&sc->sc_twoco);
                } else if (report[4] & APPLEIR_TWO_PKT_FLAG) {
                        /* First packet -- wait for next */
                        sc->sc_prev_key_idx = (report[4] >> 1) &
                            APPLEIR_KEY_MASK;
                        callout_reset(&sc->sc_twoco, APPLEIR_TWOPKT_TICKS,
                            apple_ir_twopacket_timeout, sc);
                        return;
                } else {
                        index = (report[4] >> 1) & APPLEIR_KEY_MASK;
                }

                new_key = (index < (int)APPLEIR_NKEYS) ?
                    apple_ir_keymap[index] : KEY_RESERVED;
                if (new_key != KEY_RESERVED) {
                        sc->sc_current_key = new_key;
                        evdev_push_key(sc->sc_evdev, new_key, 1);
                        evdev_sync(sc->sc_evdev);
                        callout_reset(&sc->sc_co, APPLEIR_KEYUP_TICKS,
                            apple_ir_keyup, sc);
                }
                return;
        }

        /* Key repeat: [REPEAT][SIG_HI][SIG_KEYLO][remote_id][key_code] */
        if (report[0] == APPLEIR_PKT_REPEAT &&
            report[1] == APPLEIR_SIG_HI && report[2] == APPLEIR_SIG_KEYLO) {
                uint16_t repeat_key;
                int repeat_idx;

                if (sc->sc_prev_key_idx > 0)
                        return;
                if (report[4] & APPLEIR_TWO_PKT_FLAG)
                        return;

                repeat_idx = (report[4] >> 1) & APPLEIR_KEY_MASK;
                repeat_key = (repeat_idx < (int)APPLEIR_NKEYS) ?
                    apple_ir_keymap[repeat_idx] : KEY_RESERVED;
                if (repeat_key == KEY_RESERVED ||
                    repeat_key != sc->sc_current_key)
                        return;

                evdev_push_key(sc->sc_evdev, repeat_key, 1);
                evdev_sync(sc->sc_evdev);
                callout_reset(&sc->sc_co, APPLEIR_KEYUP_TICKS,
                    apple_ir_keyup, sc);
                return;
        }

        /* Generic IR (NEC protocol): [REPEAT][NEC_HI][NEC_LO][code][~code] */
        if (report[0] == APPLEIR_PKT_REPEAT &&
            report[1] == APPLEIR_NEC_HI && report[2] == APPLEIR_NEC_LO) {
                uint8_t code = report[3];
                uint8_t checksum = report[4];

                sc->sc_prev_key_idx = 0;
                callout_stop(&sc->sc_twoco);

                if ((uint8_t)(code + checksum) != APPLEIR_NEC_CHECKSUM) {
                        DPRINTFN(1, "generic IR: bad checksum %02x+%02x\n",
                            code, checksum);
                        return;
                }

                new_key = generic_ir_lookup(code);
                if (new_key == KEY_RESERVED)
                        return;

                if (sc->sc_current_key != new_key) {
                        if (sc->sc_current_key != 0)
                                evdev_push_key(sc->sc_evdev,
                                    sc->sc_current_key, 0);
                        sc->sc_current_key = new_key;
                        evdev_push_key(sc->sc_evdev, new_key, 1);
                        evdev_sync(sc->sc_evdev);
                } else {
                        evdev_push_key(sc->sc_evdev, new_key, 1);
                        evdev_sync(sc->sc_evdev);
                }
                callout_reset(&sc->sc_co, APPLEIR_KEYUP_TICKS,
                    apple_ir_keyup, sc);
                return;
        }

        DPRINTFN(1, "unknown report: %02x %02x %02x\n",
            report[0], report[1], report[2]);
}

static void
apple_ir_intr_callback(struct usb_xfer *xfer, usb_error_t error)
{
        struct apple_ir_softc *sc = usbd_xfer_softc(xfer);
        struct usb_page_cache *pc;
        int len;

        usbd_xfer_status(xfer, &len, NULL, NULL, NULL);

        switch (USB_GET_STATE(xfer)) {
        case USB_ST_TRANSFERRED:
                pc = usbd_xfer_get_frame(xfer, 0);
                if (len > (int)sizeof(sc->sc_buf))
                        len = sizeof(sc->sc_buf);
                usbd_copy_out(pc, 0, sc->sc_buf, len);
                apple_ir_process_report(sc, sc->sc_buf, len);
                /* FALLTHROUGH */

        case USB_ST_SETUP:
tr_setup:
                usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
                usbd_transfer_submit(xfer);
                break;

        default:        /* Error */
                if (error != USB_ERR_CANCELLED) {
                        usbd_xfer_set_stall(xfer);
                        goto tr_setup;
                }
                break;
        }
}

static const struct usb_config apple_ir_config[APPLEIR_N_TRANSFER] = {
        [APPLEIR_INTR_DT] = {
                .type = UE_INTERRUPT,
                .endpoint = UE_ADDR_ANY,
                .direction = UE_DIR_IN,
                .flags = {
                        .pipe_bof = 0,
                        .short_xfer_ok = 1,
                },
                .bufsize = APPLEIR_BUFFER_MAX,
                .callback = &apple_ir_intr_callback,
        },
};

/* Device match table */
static const struct usb_device_id apple_ir_devs[] = {
        { USB_VPI(USB_VENDOR_APPLE, USB_PRODUCT_APPLE_IR_RECV1, 0) },
        { USB_VPI(USB_VENDOR_APPLE, USB_PRODUCT_APPLE_IR_RECV2, 0) },
        { USB_VPI(USB_VENDOR_APPLE, USB_PRODUCT_APPLE_IR_RECV3, 0) },
        { USB_VPI(USB_VENDOR_APPLE, USB_PRODUCT_APPLE_IR_RECV4, 0) },
        { USB_VPI(USB_VENDOR_APPLE, USB_PRODUCT_APPLE_IR_RECV5, 0) },
};

static int
apple_ir_probe(device_t dev)
{
        struct usb_attach_arg *uaa = device_get_ivars(dev);

        if (uaa->usb_mode != USB_MODE_HOST)
                return (ENXIO);
        if (uaa->info.bInterfaceClass != UICLASS_HID)
                return (ENXIO);

        if (usbd_lookup_id_by_uaa(apple_ir_devs, sizeof(apple_ir_devs),
            uaa) == 0)
                return (-20);   /* beat uhid(4) whose class match returns 0 */
        return (ENXIO);
}

static int
apple_ir_attach(device_t dev)
{
        struct apple_ir_softc *sc = device_get_softc(dev);
        struct usb_attach_arg *uaa = device_get_ivars(dev);
        unsigned int i;
        int error;

        sc->sc_dev = dev;
        sc->sc_current_key = 0;
        sc->sc_prev_key_idx = 0;
        sc->sc_batt_warned = 0;

        device_set_usb_desc(dev);
        lockinit(&sc->sc_lock, "apple_ir", 0, LK_CANRECURSE);
        callout_init_lk(&sc->sc_co, &sc->sc_lock);
        callout_init_lk(&sc->sc_twoco, &sc->sc_lock);

        error = usbd_transfer_setup(uaa->device, &uaa->info.bIfaceIndex,
            sc->sc_xfer, apple_ir_config, APPLEIR_N_TRANSFER, sc, &sc->sc_lock);
        if (error != 0) {
                device_printf(dev, "USB transfer setup failed: %s\n",
                    usbd_errstr(error));
                goto fail;
        }

        sc->sc_evdev = evdev_alloc();
        evdev_set_name(sc->sc_evdev, "Apple IR Receiver");
        evdev_set_phys(sc->sc_evdev, device_get_nameunit(dev));
        evdev_set_id(sc->sc_evdev, BUS_USB,
            uaa->info.idVendor, uaa->info.idProduct, 0);
        evdev_support_event(sc->sc_evdev, EV_SYN);
        evdev_support_event(sc->sc_evdev, EV_KEY);
        evdev_support_event(sc->sc_evdev, EV_REP);

        for (i = 0; i < APPLEIR_NKEYS; i++) {
                if (apple_ir_keymap[i] != KEY_RESERVED)
                        evdev_support_key(sc->sc_evdev, apple_ir_keymap[i]);
        }
        for (i = 0; i < GENERIC_NKEYS; i++)
                evdev_support_key(sc->sc_evdev, generic_keymap[i].key);

        error = evdev_register_mtx(sc->sc_evdev, &sc->sc_lock);
        if (error != 0) {
                device_printf(dev, "evdev registration failed: %d\n", error);
                goto fail;
        }

        lockmgr(&sc->sc_lock, LK_EXCLUSIVE);
        usbd_transfer_start(sc->sc_xfer[APPLEIR_INTR_DT]);
        lockmgr(&sc->sc_lock, LK_RELEASE);

        return (0);

fail:
        if (sc->sc_evdev != NULL)
                evdev_free(sc->sc_evdev);
        usbd_transfer_unsetup(sc->sc_xfer, APPLEIR_N_TRANSFER);
        callout_drain(&sc->sc_co);
        callout_drain(&sc->sc_twoco);
        lockuninit(&sc->sc_lock);
        return (error);
}

static int
apple_ir_detach(device_t dev)
{
        struct apple_ir_softc *sc = device_get_softc(dev);

        lockmgr(&sc->sc_lock, LK_EXCLUSIVE);
        usbd_transfer_stop(sc->sc_xfer[APPLEIR_INTR_DT]);
        lockmgr(&sc->sc_lock, LK_RELEASE);

        usbd_transfer_unsetup(sc->sc_xfer, APPLEIR_N_TRANSFER);
        callout_drain(&sc->sc_co);
        callout_drain(&sc->sc_twoco);
        evdev_free(sc->sc_evdev);
        lockuninit(&sc->sc_lock);

        return (0);
}

static device_method_t apple_ir_methods[] = {
        DEVMETHOD(device_probe,         apple_ir_probe),
        DEVMETHOD(device_attach,        apple_ir_attach),
        DEVMETHOD(device_detach,        apple_ir_detach),
        DEVMETHOD_END
};

static driver_t apple_ir_driver = {
        .name = "apple_ir",
        .methods = apple_ir_methods,
        .size = sizeof(struct apple_ir_softc)
};

static devclass_t apple_ir_devclass;

DRIVER_MODULE(apple_ir, uhub, apple_ir_driver, apple_ir_devclass, NULL, NULL);
MODULE_DEPEND(apple_ir, usb, 1, 1, 1);
MODULE_VERSION(apple_ir, 1);