libusbdrivers/src/drivers/hid.c

/*
 * Copyright 2017, Data61
 * Commonwealth Scientific and Industrial Research Organisation (CSIRO)
 * ABN 41 687 119 230.
 *
 * This software may be distributed and modified according to the terms of
 * the BSD 2-Clause license. Note that NO WARRANTY is provided.
 * See "LICENSE_BSD2.txt" for details.
 *
 * @TAG(DATA61_BSD)
 */

/**
 * @brief USB HID subclass driver
 * @see USB HID subclass specification
 */
#include <stdio.h>
#include <string.h>

#include "../services.h"
#include "hid.h"
#include "usbkbd.h"

static inline struct usbreq
__set_protocol_req(enum hid_protocol p, int iface) {
    struct usbreq r = {
        .bmRequestType = (USB_DIR_OUT | USB_TYPE_CLS | USB_RCPT_INTERFACE),
        .bRequest      = SET_PROTOCOL,
        .wValue        = p,
        .wIndex        = iface,
        .wLength       = 0
    };
    return r;
}

static inline struct usbreq
__get_protocol_req(int iface) {
    struct usbreq r = {
        .bmRequestType = (USB_DIR_IN | USB_TYPE_CLS | USB_RCPT_INTERFACE),
        .bRequest      = GET_PROTOCOL,
        .wValue        = 0,
        .wIndex        = iface,
        .wLength       = 1
    };
    return r;
}

static inline struct usbreq
__set_idle_req(int idle_ms, int id, int iface) {
    struct usbreq r = {
        .bmRequestType = (USB_DIR_OUT | USB_TYPE_CLS | USB_RCPT_INTERFACE),
        .bRequest      = SET_IDLE,
        .wValue        = idle_ms << 8 | id,
        .wIndex        = iface,
        .wLength       = 0
    };
    return r;
}


static inline struct usbreq
__get_report_req(enum hid_report_type type, int id, int iface, int len) {
    struct usbreq r = {
        .bmRequestType = (USB_DIR_IN | USB_TYPE_CLS | USB_RCPT_INTERFACE),
        .bRequest      = GET_REPORT,
        .wValue        = type << 8 | id,
        .wIndex        = iface,
        .wLength       = len
    };
    return r;
}

static inline struct usbreq
__set_report_req(enum hid_report_type type, int id, int iface, int len) {
    struct usbreq r = {
        .bmRequestType = (USB_DIR_OUT | USB_TYPE_CLS | USB_RCPT_INTERFACE),
        .bRequest      = SET_REPORT,
        .wValue        = type << 8 | id,
        .wIndex        = iface,
        .wLength       = len
    };
    return r;
}

static int
usb_hid_config_cb(void *token, int cfg, int iface, struct anon_desc *desc)
{
	struct usb_hid_device *hid;
	struct config_desc *cdesc;
	struct iface_desc *idesc;
	struct hid_desc *hdesc;

	if (!desc) {
		return 0;
	}

	hid = (struct usb_hid_device *)token;

	switch (desc->bDescriptorType) {
	case CONFIGURATION:
		cdesc = (struct config_desc*)desc;
		hid->config = cdesc->bConfigurationValue;
		break;
	case INTERFACE:
		idesc = (struct iface_desc *)desc;
		if (idesc->bInterfaceSubClass == 1) {
			hid->subclass = idesc->bInterfaceSubClass;
			hid->protocol = idesc->bInterfaceProtocol;
			hid->iface = idesc->bInterfaceNumber;
		}
		break;
	case HID:
		hdesc = (struct hid_desc *)desc;
		if (!hid->subclass) {
			if (hdesc->bReportDescriptorType== HID_REPORT) {
				hid->report_size = hdesc->wReportDescriptorLength;
			} else {
				ZF_LOGD("Descriptor %u not supported!\n",
					hdesc->bReportDescriptorType);
			}
		}
		break;
	default:
		break;
	}

	return 0;
}

struct usb_hid_device *usb_hid_alloc(struct usb_dev *udev)
{
	int err;
	struct usb_hid_device *hid;
	struct xact xact;
	struct usbreq *req;
	int class;

	if (!udev) {
		ZF_LOGF("Invalid device\n");
	}

	hid = usb_malloc(sizeof(struct usb_hid_device));
	if (!hid) {
		ZF_LOGD("Not enough memory!\n");
		return NULL;
	}

	hid->udev = udev;
	hid->subclass = 0xFF;

	/* Parse the descriptors */
	err = usbdev_parse_config(udev, usb_hid_config_cb, hid);
	if (err) {
		ZF_LOGF("Invalid descriptors\n");
	}

	class = usbdev_get_class(udev);
	if (class != USB_CLASS_HID) {
		ZF_LOGD("Not a HID device(%d)\n", class);
		usb_free(hid);
		return NULL;
	}

	/* Activate configuration */
	xact.len = sizeof(struct usbreq);
	err = usb_alloc_xact(udev->dman, &xact, 1);
	if (err) {
		ZF_LOGF("Out of DMA memory\n");
	}

	/* Fill in the request */
	xact.type = PID_SETUP;
	req = xact_get_vaddr(&xact);
	*req = __set_configuration_req(hid->config);

	/* Send the request to the host */
	err = usbdev_schedule_xact(udev, udev->ep_ctrl, &xact, 1, NULL, NULL);
	if (err) {
		ZF_LOGF("Transaction error\n");
	}

	usb_destroy_xact(udev->dman, &xact, 1);

	return hid;
}

void usb_hid_free(struct usb_hid_device *hid)
{
	usb_free(hid);
}

int usb_hid_set_idle(struct usb_hid_device *hid, int idle_ms)
{
	int err;
	struct usbreq *req;
	struct xact xact;

	xact.type = PID_SETUP;
	xact.len = sizeof(struct usbreq);

	err = usb_alloc_xact(hid->udev->dman, &xact, 1);
	if (err) {
		ZF_LOGF("Out of DMA memory\n");
	}

	req = xact_get_vaddr(&xact);
	*req = __set_idle_req(idle_ms, 0, hid->iface);

	err = usbdev_schedule_xact(hid->udev, hid->udev->ep_ctrl, &xact, 1, NULL, NULL);
	if (err) {
		ZF_LOGF("Transaction error\n");
	}

	usb_destroy_xact(hid->udev->dman, &xact, 1);

	return err;
}

int usb_hid_get_idle(struct usb_hid_device *hid)
{
	return 0;
}

int usb_hid_get_report(struct usb_hid_device *hid, enum hid_report_type type, void *buf)
{
	return 0;
}

int usb_hid_set_report(struct usb_hid_device *hid, enum hid_report_type type,
		void *buf, int size)
{
	int err;
	struct usbreq *req;
	struct xact xact[2];

	xact[0].type = PID_SETUP;
	xact[0].len = sizeof(struct usbreq);
	xact[1].type = PID_OUT;
	xact[1].len = size;

	err = usb_alloc_xact(hid->udev->dman, xact, 2);
	if (err) {
		ZF_LOGF("Out of DMA memory\n");
	}

	req = xact_get_vaddr(&xact[0]);
	*req = __set_report_req(REPORT_OUTPUT, 0, hid->iface, size);

	memcpy(xact_get_vaddr(&xact[1]), buf, size);

	err = usbdev_schedule_xact(hid->udev, hid->udev->ep_ctrl, xact, 2, NULL, NULL);
	if (err) {
		ZF_LOGF("Transaction error\n");
	}

	usb_destroy_xact(hid->udev->dman, xact, 2);

	return err;
}

int usb_hid_get_protocol(struct usb_hid_device *hid)
{
	return 0;
}

int usb_hid_set_protocol(struct usb_hid_device *hid)
{
	return 0;
}