/*
 * Copyright 2005-2020, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Stephan Aßmus <superstippi@gmx.de>
 *
 * Portions of this code are based on Be Sample Code released under the
 * Be Sample Code license. (USB sound device driver sample code IIRC.)
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <Drivers.h>
#include <KernelExport.h>
#include <OS.h>
#include <USB3.h>

#include <kernel.h>
#include <wacom_driver.h>

int32 api_version = B_CUR_DRIVER_API_VERSION;

#define DEBUG_DRIVER 0

#if DEBUG_DRIVER
#       define DPRINTF_INFO(x) dprintf x;
#       define DPRINTF_ERR(x) dprintf x;
#else
#       define DPRINTF_INFO(x)
#       define DPRINTF_ERR(x) dprintf x;
#endif

typedef struct wacom_device wacom_device;

struct wacom_device {
        wacom_device*           next;

        int                                     open;
        int                                     number;

        usb_device                      dev;

        usb_pipe                        pipe;
        char*                           data;
        size_t                          max_packet_size;
        size_t                          length;

        uint16                          vendor;
        uint16                          product;

        sem_id                          notify_lock;
        uint32                          status;
};

// handy strings for referring to ourself
#define ID "wacom: "
static const char* kDriverName = "wacom";
static const char* kBasePublishPath = "input/wacom/usb/";

// list of device instances and names for publishing
static wacom_device* sDeviceList = NULL;
static sem_id sDeviceListLock = -1;
static int sDeviceCount = 0;

static char** sDeviceNames = NULL;

// handle for the USB bus manager
static usb_module_info* usb;

// These rather inelegant routines are used to assign numbers to
// device instances so that they have unique names in devfs.

static uint32 sDeviceNumbers = 0;

// get_number
static int
get_number()
{
        int num;

        for (num = 0; num < 32; num++) {
                if (!(sDeviceNumbers & (1 << num))) {
                        sDeviceNumbers |= (1 << num);
                        return num;
                }
        }

        return -1;
}

// put_number
static void
put_number(int num)
{
        sDeviceNumbers &= ~(1 << num);
}

// #pragma mark - Device addition and removal
//
// add_device() and remove_device() are used to create and tear down
// device instances.  They are used from the callbacks device_added()
// and device_removed() which are invoked by the USB bus manager.

// add_device
static wacom_device*
add_device(usb_device dev)
{
        wacom_device *device = NULL;
        int num;
        size_t ifc, alt;
        const usb_interface_info *ii;
        status_t st;
        const usb_device_descriptor* udd;
        const usb_configuration_info *conf;

        // we need these four for a Wacom tablet
        size_t controlTransferLength;
        int tryCount;
        char repData[2] = { 0x02, 0x02 };
        char retData[2] = { 0x00, 0x00 };

        conf = usb->get_configuration(dev);
        DPRINTF_INFO((ID "add_device(%ld, %p)\n", dev, conf));

        if ((num = get_number()) < 0)
                return NULL;

        udd = usb->get_device_descriptor(dev);
        // only pick up wacom tablets
        if (udd && udd->vendor_id == 0x056a) {

                DPRINTF_ERR((ID "add_device() - wacom detected\n"));

                // see if the device has been configured already
                if (!conf) {
                        conf = usb->get_nth_configuration(dev, 0);
                }

                if (!conf)
                        goto fail;

                for (ifc = 0; ifc < conf->interface_count; ifc++) {
                        DPRINTF_INFO((ID "add_device() - examining interface: %d\n", ifc));
                        for (alt = 0; alt < conf->interface[ifc].alt_count; alt++) {
                                ii = &conf->interface[ifc].alt[alt];
                                DPRINTF_INFO((ID "add_device() - examining alt interface: "
                                        "%d\n", alt));


                                // does it have the correct type of interface?
                                if (ii->descr->interface_class != 3) continue;
                                if (ii->descr->interface_subclass != 1) continue;
                                if (ii->endpoint_count != 1) continue;

                                // only accept input endpoints
                                if (ii->endpoint[0].descr->endpoint_address & 0x80) {
                                        DPRINTF_INFO((ID "add_device() - found input endpoint\n"));
                                        goto got_one;
                                }
                        }
                }
        } else
                goto fail;

fail:
        put_number(num);
        if (device) {
                free(device->data);
                free(device);
        }
        return NULL;

got_one:
        if ((device = (wacom_device *) malloc(sizeof(wacom_device))) == NULL)
                goto fail;

        device->dev = dev;
        device->number = num;
        device->open = 1;
        device->notify_lock = -1;
        device->data = NULL;

        DPRINTF_INFO((ID "add_device() - setting configuration...\n"));
        if ((st = usb->set_configuration(dev, conf)) != B_OK) {
                dprintf(ID "add_device() -> "
                        "set_configuration() returns %" B_PRId32 "\n", st);
                goto fail;
        } else
                DPRINTF_ERR((ID " ... success!\n"));

        if (conf->interface[ifc].active != ii) {
                // the interface we found is not the active one and has to be set
                DPRINTF_INFO((ID "add_device() - setting interface: %p...\n", ii));
                if ((st = usb->set_alt_interface(dev, ii)) != B_OK) {
                        dprintf(ID "add_device() -> "
                                "set_alt_interface() returns %" B_PRId32 "\n", st);
                        goto fail;
                } else
                        DPRINTF_ERR((ID " ... success!\n"));
        }
        // see if the device is a Wacom tablet and needs some special treatment
        // let's hope Wacom doesn't produce normal mice any time soon, or this
        // check will have to be more specific about product_id...hehe
        if (udd->vendor_id == 0x056a) {
                // do the control transfers to set up absolute mode (default is HID
                // mode)

                // see 'Device Class Definition for HID 1.11' (HID1_11.pdf),
                // par. 7.2 (available at www.usb.org/developers/hidpage)

                // set protocol mode to 'report' (instead of 'boot')
                controlTransferLength = 0;
                // HID Class-Specific Request, Host to device (=0x21):
                // SET_PROTOCOL (=0x0b) to Report Protocol (=1)
                // of Interface #0 (=0)
                st = usb->send_request(dev, 0x21, 0x0b, 1, 0, 0, 0,
                        &controlTransferLength);

                if (st < B_OK) {
                        dprintf(ID "add_device() - "
                                "control transfer 1 failed: %" B_PRId32 "\n", st);
                }

                // try up to five times to set the tablet to 'Wacom'-mode (enabling
                // absolute mode, pressure data, etc.)
                controlTransferLength = 2;

                for (tryCount = 0; tryCount < 5; tryCount++) {
                        // HID Class-Specific Request, Host to device (=0x21):
                        // SET_REPORT (=0x09) type Feature (=3) with ID 2 (=2) of
                        // Interface #0 (=0) to repData (== { 0x02, 0x02 })
                        st = usb->send_request(dev, 0x21, 0x09, (3 << 8) + 2, 0, 2,
                                repData, &controlTransferLength);

                        if (st < B_OK) {
                                dprintf(ID "add_device() - "
                                        "control transfer 2 failed: %" B_PRId32 "\n", st);
                        }

                        // check if registers are set correctly

                        // HID Class-Specific Request, Device to host (=0xA1):
                        // GET_REPORT (=0x01) type Feature (=3) with ID 2 (=2) of
                        // Interface #0 (=0) to retData
                        st = usb->send_request(dev, 0xA1, 0x01, (3 << 8) + 2, 0, 2,
                                retData, &controlTransferLength);

                        if (st < B_OK) {
                                dprintf(ID "add_device() - "
                                        "control transfer 3 failed: %" B_PRId32 "\n", st);
                        }

                        DPRINTF_INFO((ID "add_device() - retData: %u - %u\n",
                                retData[0], retData[1]));

                        if (retData[0] == repData[0] && retData[1] == repData[1]) {
                                DPRINTF_INFO((ID "add_device() - successfully set "
                                        "'Wacom'-mode\n"));
                                break;
                        }
                }

                DPRINTF_INFO((ID "add_device() - number of tries: %u\n",
                        tryCount + 1));

                if (tryCount > 4) {
                        dprintf(ID "add_device() - set 'Wacom'-mode failed\n");
                }
        }

        // configure the rest of the wacom_device
        device->pipe = ii->endpoint[0].handle;
//DPRINTF_INFO((ID "add_device() - pipe id = %ld\n", device->pipe));
        device->length = 0;
        device->max_packet_size = ii->endpoint[0].descr->max_packet_size;
        device->data = (char*)malloc(device->max_packet_size);
        if (device->data == NULL)
                goto fail;
//DPRINTF_INFO((ID "add_device() - max packet length = %ld\n",
//      device->max_packet_size));
        device->status = 0;//B_USB_STATUS_SUCCESS;
        device->vendor = udd->vendor_id;
        device->product = udd->product_id;

        DPRINTF_INFO((ID "add_device() - added %p (/dev/%s%d)\n", device,
                kBasePublishPath, num));

        // add it to the list of devices so it will be published, etc
        acquire_sem(sDeviceListLock);
        device->next = sDeviceList;
        sDeviceList = device;
        sDeviceCount++;
        release_sem(sDeviceListLock);

        return device;
}

// remove_device
static void
remove_device(wacom_device *device)
{
        put_number(device->number);

        usb->cancel_queued_transfers(device->pipe);

        delete_sem(device->notify_lock);
        if (device->data)
                free(device->data);
        free(device);
}

// device_added
static status_t
device_added(usb_device dev, void** cookie)
{
        wacom_device* device;

        DPRINTF_INFO((ID "device_added(%ld,...)\n", dev));

        // first see, if this device is already added
        acquire_sem(sDeviceListLock);
        for (device = sDeviceList; device; device = device->next) {
                DPRINTF_ERR((ID "device_added() - old device: %" B_PRIu32 "\n",
                        device->dev));
                if (device->dev == dev) {
                        DPRINTF_ERR((ID "device_added() - already added - done!\n"));
                        *cookie = (void*)device;
                        release_sem(sDeviceListLock);
                        return B_OK;
                }
        }
        release_sem(sDeviceListLock);

        if ((device = add_device(dev)) != NULL) {
                *cookie = (void*)device;
                DPRINTF_INFO((ID "device_added() - done!\n"));
                return B_OK;
        } else
                DPRINTF_INFO((ID "device_added() - failed to add device!\n"));

        return B_ERROR;
}

// device_removed
static status_t
device_removed(void *cookie)
{
        wacom_device *device = (wacom_device *) cookie;

        DPRINTF_INFO((ID "device_removed(%p)\n", device));

        if (device) {

                acquire_sem(sDeviceListLock);

                // remove it from the list of devices
                if (device == sDeviceList) {
                        sDeviceList = device->next;
                } else {
                        wacom_device *n;
                        for (n = sDeviceList; n; n = n->next) {
                                if (n->next == device) {
                                        n->next = device->next;
                                        break;
                                }
                        }
                }
                sDeviceCount--;

                // tear it down if it's not open --
                // otherwise the last device_free() will handle it

                device->open--;

                DPRINTF_ERR((ID "device_removed() open: %d\n", device->open));

                if (device->open == 0) {
                        remove_device(device);
                } else {
                        dprintf(ID "device /dev/%s%d still open -- marked for removal\n",
                                kBasePublishPath, device->number);
                }

                release_sem(sDeviceListLock);
        }

        return B_OK;
}

// #pragma mark - Device Hooks
//
// Here we implement the posixy driver hooks (open/close/read/write/ioctl)

// device_open
static status_t
device_open(const char *dname, uint32 flags, void** cookie)
{
        wacom_device *device;
        int n;
        status_t ret = B_ERROR;

        n = atoi(dname + strlen(kBasePublishPath));

        DPRINTF_INFO((ID "device_open(\"%s\",%d,...)\n", dname, flags));

        acquire_sem(sDeviceListLock);
        for (device = sDeviceList; device; device = device->next) {
                if (device->number == n) {
//                      if (device->open <= 1) {
                                device->open++;
                                *cookie = device;
                                DPRINTF_ERR((ID "device_open() open: %d\n", device->open));

                                if (device->notify_lock < 0) {
                                        device->notify_lock = create_sem(0, "notify_lock");
                                        if (device->notify_lock < 0) {
                                                ret = device->notify_lock;
                                                device->open--;
                                                *cookie = NULL;
                                                dprintf(ID "device_open() -> "
                                                        "create_sem() returns %" B_PRId32 "\n", ret);
                                        } else {
                                                ret = B_OK;
                                        }
                                }
                                release_sem(sDeviceListLock);
                                return ret;
//                      } else {
//                              dprintf(ID "device_open() -> device is already open %ld\n",
//                                      ret);
//                              release_sem(sDeviceListLock);
//                              return B_ERROR;
//                      }
                }
        }
        release_sem(sDeviceListLock);
        return ret;
}

// device_close
static status_t
device_close (void *cookie)
{
#if DEBUG_DRIVER
        wacom_device *device = (wacom_device*) cookie;
        DPRINTF_ERR((ID "device_close() name = \"%s%d\"\n", kBasePublishPath,
                device->number));
#endif
        return B_OK;
}

// device_free
static status_t
device_free(void *cookie)
{
        wacom_device *device = (wacom_device *)cookie;

        DPRINTF_INFO((ID "device_free() name = \"%s%d\"\n", kBasePublishPath,
                device->number));

        acquire_sem(sDeviceListLock);

        device->open--;

        DPRINTF_INFO((ID "device_free() open: %ld\n", device->open));

        if (device->open == 0) {
                remove_device(device);
        }
        release_sem(sDeviceListLock);

        return B_OK;
}

// device_interrupt_callback
static void
device_interrupt_callback(void* cookie, status_t status, void* data,
        size_t actualLength)
{
        wacom_device* device = (wacom_device*)cookie;
        size_t length = min_c(actualLength, device->max_packet_size);

        DPRINTF_INFO((ID "device_interrupt_callback(%p) name = \"%s%d\" -> "
                "status: %ld, length: %zu\n", cookie, kBasePublishPath, device->number,
                status, actualLength));

        device->status = status;
        if (device->notify_lock >= 0) {
                if (status == B_OK) {
                        memcpy(device->data, data, length);
                        device->length = length;
                } else {
                        device->length = 0;
                }
                release_sem(device->notify_lock);
        }

        DPRINTF_INFO((ID "device_interrupt_callback() - done\n"));
}

// read_header
static status_t
read_header(const wacom_device* device, void* buffer)
{
        wacom_device_header device_header;
        device_header.vendor_id = device->vendor;
        device_header.product_id = device->product;
        device_header.max_packet_size = device->max_packet_size;

        if (!IS_USER_ADDRESS(buffer)) {
                memcpy(buffer, &device_header, sizeof(wacom_device_header));
                return B_OK;
        }

        return user_memcpy(buffer, &device_header, sizeof(wacom_device_header));
}

// device_read
static status_t
device_read(void* cookie, off_t pos, void* buf, size_t* count)
{
        wacom_device* device = (wacom_device*) cookie;
        status_t ret = B_BAD_VALUE;
        uint8* buffer = (uint8*)buf;
        uint32 dataLength;

        if (!device)
                return ret;

        ret = device->notify_lock;

        DPRINTF_INFO((ID "device_read(%p,%lld,0x%x,%d) name = \"%s%d\"\n",
                         cookie, pos, buf, *count, kBasePublishPath, device->number));

        if (ret >= B_OK) {
                // what the client "reads" is decided depending on how much bytes are
                // provided. "sizeof(wacom_device_header)" bytes are needed to "read"
                // vendor id, product id and max packet size in case the client wants to
                // read more than "sizeof(wacom_device_header)" bytes, a usb interupt
                // transfer is scheduled, and an error report is returned as appropriate
                if (*count > sizeof(wacom_device_header)) {
                        // queue the interrupt transfer
                        ret = usb->queue_interrupt(device->pipe, device->data,
                                device->max_packet_size, device_interrupt_callback, device);
                        if (ret >= B_OK) {
                                // we will block here until the interrupt transfer has been done
                                ret = acquire_sem_etc(device->notify_lock, 1,
                                        B_RELATIVE_TIMEOUT, 500 * 1000);
                                // handle time out
                                if (ret < B_OK) {
                                        usb->cancel_queued_transfers(device->pipe);
                                        acquire_sem(device->notify_lock);
                                                // collect the sem released by the cancel

                                        if (ret == B_TIMED_OUT) {
                                                // a time_out is ok, since it only means that the device
                                                // had nothing to report (ie mouse/pen was not moved)
                                                // within the given time interval
                                                DPRINTF_INFO((ID "device_read(%p) name = \"%s%d\" -> "
                                                        "B_TIMED_OUT\n", cookie, kBasePublishPath,
                                                        device->number));
                                                *count = sizeof(wacom_device_header);
                                                ret = read_header(device, buffer);
                                        } else {
                                                // any other error trying to acquire the semaphore
                                                *count = 0;
                                        }
                                } else {
                                        if (device->status == 0/*B_USBD_SUCCESS*/) {
                                                DPRINTF_INFO((ID "interrupt transfer - success\n"));
                                                // copy the data from the buffer
                                                dataLength = min_c(device->length,
                                                        *count - sizeof(wacom_device_header));
                                                *count = dataLength + sizeof(wacom_device_header);
                                                ret = read_header(device, buffer);
                                                if (ret == B_OK) {
                                                        if (IS_USER_ADDRESS(buffer))
                                                                ret = user_memcpy(
                                                                        buffer + sizeof(wacom_device_header),
                                                                        device->data, dataLength);
                                                        else
                                                                memcpy(buffer + sizeof(wacom_device_header),
                                                                        device->data, dataLength);
                                                }
                                        } else {
                                                // an error happened during the interrupt transfer
                                                *count = 0;
                                                dprintf(ID "interrupt transfer - "
                                                        "failure: %" B_PRIu32 "\n", device->status);
                                                ret = B_ERROR;
                                        }
                                }
                        } else {
                                *count = 0;
                                dprintf(ID "device_read(%p) name = \"%s%d\" -> error queuing "
                                        "interrupt: %" B_PRId32 "\n", cookie, kBasePublishPath,
                                        device->number, ret);
                        }
                } else if (*count == sizeof(wacom_device_header)) {
                        ret = read_header(device, buffer);
                } else {
                        dprintf(ID "device_read(%p) name = \"%s%d\" -> buffer size must be "
                                "at least the size of the wacom_device_header struct!\n",
                                cookie, kBasePublishPath, device->number);
                        *count = 0;
                        ret = B_BAD_VALUE;
                }
        }

        return ret;
}

// device_write
static status_t
device_write(void *cookie, off_t pos, const void *buf, size_t *count)
{
        return B_ERROR;
}

// device_control
static status_t
device_control (void *cookie, uint32 msg, void *arg1, size_t len)
{
        return B_ERROR;
}

// #pragma mark - Driver Hooks
//
// These functions provide the glue used by DevFS to load/unload
// the driver and also handle registering with the USB bus manager
// to receive device added and removed events

static usb_notify_hooks notify_hooks =
{
        &device_added,
        &device_removed
};

static const usb_support_descriptor kSupportedDevices[] =
{
        { 3, 1, 2, 0, 0 }
};

// init_hardware
status_t
init_hardware(void)
{
        return B_OK;
}

// init_driver
status_t
init_driver(void)
{
        DPRINTF_INFO((ID "init_driver(), built %s %s\n", __DATE__, __TIME__));

#if DEBUG_DRIVER && !defined(__HAIKU__)
        if (load_driver_symbols(kDriverName) == B_OK) {
                DPRINTF_INFO((ID "loaded symbols\n"));
        } else {
                DPRINTF_ERR((ID "no driver symbols loaded!\n"));
        }
#endif

        if (get_module(B_USB_MODULE_NAME, (module_info**) &usb) != B_OK) {
                DPRINTF_ERR((ID "cannot get module \"%s\"\n", B_USB_MODULE_NAME));
                return B_ERROR;
        }

        if ((sDeviceListLock = create_sem(1,"sDeviceListLock")) < 0) {
                put_module(B_USB_MODULE_NAME);
                return sDeviceListLock;
        }

        usb->register_driver(kDriverName, kSupportedDevices, 1, NULL);
        usb->install_notify(kDriverName, &notify_hooks);

        return B_OK;
}

// uninit_driver
void
uninit_driver(void)
{
        int i;

        DPRINTF_INFO((ID "uninit_driver()\n"));

        usb->uninstall_notify(kDriverName);

        delete_sem(sDeviceListLock);

        put_module(B_USB_MODULE_NAME);

        if (sDeviceNames) {
                for (i = 0; sDeviceNames[i]; i++)
                        free(sDeviceNames[i]);
                free(sDeviceNames);
        }

        DPRINTF_INFO((ID "uninit_driver() done\n"));
}

// publish_devices
const char**
publish_devices()
{
        wacom_device *device;
        int i;

        DPRINTF_INFO((ID "publish_devices()\n"));

        if (sDeviceNames) {
                for (i = 0; sDeviceNames[i]; i++)
                        free((char *) sDeviceNames[i]);
                free(sDeviceNames);
        }

        acquire_sem(sDeviceListLock);
        sDeviceNames = (char**)malloc(sizeof(char*) * (sDeviceCount + 2));
        if (sDeviceNames) {
                for (i = 0, device = sDeviceList; device; device = device->next) {
                        sDeviceNames[i] = (char*)malloc(strlen(kBasePublishPath) + 4);
                        if (sDeviceNames[i]) {
                                sprintf(sDeviceNames[i],"%s%d",kBasePublishPath,device->number);
                                DPRINTF_INFO((ID "publishing: \"/dev/%s\"\n",sDeviceNames[i]));
                                i++;
                        }
                }
                sDeviceNames[i] = NULL;
        }

        release_sem(sDeviceListLock);

        return (const char**)sDeviceNames;
}

static device_hooks sDeviceHooks = {
        device_open,
        device_close,
        device_free,
        device_control,
        device_read,
        device_write
};

// find_device
device_hooks*
find_device(const char* name)
{
        return &sDeviceHooks;
}