Nyaaori/rockbox
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
rockbox/firmware/usbstack/usb_hid.c
Frank Gevaerts c61a75173b Reorganise USB stack defines. Now config.h decides which class drivers get enabled instead of usb_core.h 
Also enable HID, and use that as the dummy class instead of charging-only for controllers that have working interrupt transfers.


git-svn-id: svn://svn.rockbox.org/rockbox/trunk@21053 a1c6a512-1295-4272-9138-f99709370657
2009-05-23 14:30:20 +00:00

392 lines
11 KiB
C
Raw Blame History

/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2009 by Tomer Shalev
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include "string.h"
#include "system.h"
#include "usb_core.h"
#include "usb_drv.h"
#include "kernel.h"
#include "usb_hid.h"
#include "usb_class_driver.h"
//#define LOGF_ENABLE
#include "logf.h"
#define CONCAT(low, high) ((high << 8) | low)
#define PACK_VAL1(dest, val) *(dest)++ = (val) & 0xff
#define PACK_VAL2(dest, val) PACK_VAL1((dest), (val)); \
PACK_VAL1((dest), (val >> 8))
/* Documents avaiable here: http://www.usb.org/developers/devclass_docs/ */
#define HID_VER 0x0110 /* 1.1 */
/* Subclass Codes (HID1_11.pdf, page 18) */
#define SUBCLASS_BOOT_INTERFACE 1
/* Protocol Codes (HID1_11.pdf, page 19) */
#define PROTOCOL_CODE_MOUSE 2
/* HID main items (HID1_11.pdf, page 38) */
#define INPUT 0x80
#define COLLECTION 0xa0
#define COLLECTION_APPLICATION 0x01
#define END_COLLECTION 0xc0
/* Parts (HID1_11.pdf, page 40) */
#define PREFERERD (1 << 5)
#define NULL_STATE (1 << 6)
/* HID global items (HID1_11.pdf, page 45) */
#define USAGE_PAGE 0x04
#define LOGICAL_MINIMUM 0x14
#define LOGICAL_MAXIMUM 0x24
#define REPORT_SIZE 0x74
#define REPORT_ID 0x84
#define REPORT_COUNT 0x94
/* HID local items (HID1_11.pdf, page 50) */
#define USAGE_MINIMUM 0x18
#define USAGE_MAXIMUM 0x28
/* Types of class descriptors (HID1_11.pdf, page 59) */
#define USB_DT_HID 0x21
#define USB_DT_REPORT 0x22
/* (Hut1_12.pdf, Table 1, page 14) */
#define USAGE_PAGE_CONSUMER 0x0c
#define CONSUMER_USAGE 0x09
/* HID-only class specific requests */
#define USB_HID_GET_REPORT 0x01
#define USB_HID_GET_IDLE 0x02
#define USB_HID_GET_PROTOCOL 0x03
#define USB_HID_SET_REPORT 0x09
#define USB_HID_SET_IDLE 0x0a
#define USB_HID_SET_PROTOCOL 0x0b
#define HID_BUF_SIZE_MSG 16
#define HID_BUF_SIZE_CMD 5
#define HID_BUG_SIZE_REPORT 32
#define HID_NUM_BUFFERS 5
#define HID_BUF_INC(i) do { (i) = ((i) + 1) % HID_NUM_BUFFERS; } while (0)
/* hid interface */
static struct usb_interface_descriptor __attribute__((aligned(2)))
interface_descriptor =
{
.bLength = sizeof(struct usb_interface_descriptor),
.bDescriptorType = USB_DT_INTERFACE,
.bInterfaceNumber = 0,
.bAlternateSetting = 0,
.bNumEndpoints = 1,
.bInterfaceClass = USB_CLASS_HID,
.bInterfaceSubClass = SUBCLASS_BOOT_INTERFACE,
.bInterfaceProtocol = PROTOCOL_CODE_MOUSE,
.iInterface = 0
};
struct usb_hid_descriptor {
uint8_t bLength;
uint8_t bDescriptorType;
uint16_t wBcdHID;
uint8_t bCountryCode;
uint8_t bNumDescriptors;
uint8_t bDescriptorType0;
uint16_t wDescriptorLength0;
} __attribute__ ((packed));
static struct usb_hid_descriptor __attribute__((aligned(2))) hid_descriptor =
{
.bLength = sizeof(struct usb_hid_descriptor),
.bDescriptorType = USB_DT_HID,
.wBcdHID = HID_VER,
.bCountryCode = 0,
.bNumDescriptors = 1,
.bDescriptorType0 = USB_DT_REPORT,
.wDescriptorLength0 = 0
};
static struct usb_endpoint_descriptor __attribute__((aligned(2)))
endpoint_descriptor =
{
.bLength = sizeof(struct usb_endpoint_descriptor),
.bDescriptorType = USB_DT_ENDPOINT,
.bEndpointAddress = 0,
.bmAttributes = USB_ENDPOINT_XFER_INT,
.wMaxPacketSize = 0,
.bInterval = 0
};
static unsigned char report_descriptor[HID_BUG_SIZE_REPORT]
USB_DEVBSS_ATTR __attribute__((aligned(32)));
static unsigned char send_buffer[HID_NUM_BUFFERS][HID_BUF_SIZE_MSG]
USB_DEVBSS_ATTR __attribute__((aligned(32)));
size_t send_buffer_len[HID_NUM_BUFFERS];
static int cur_buf_prepare;
static int cur_buf_send;
static uint16_t report_descriptor_len;
static bool active = false;
static int ep_in;
static int usb_interface;
static uint32_t report_id;
static void usb_hid_try_send_drv(void);
static void pack_parameter(unsigned char **dest, uint8_t parameter,
uint32_t value)
{
uint8_t size_value = 1; /* # of bytes */
uint32_t v = value;
while (v >>= 8)
size_value++;
**dest = parameter | size_value;
(*dest)++;
while (size_value--)
{
**dest = value & 0xff;
(*dest)++;
value >>= 8;
}
}
int usb_hid_request_endpoints(struct usb_class_driver *drv)
{
ep_in = usb_core_request_endpoint(USB_ENDPOINT_XFER_INT, USB_DIR_IN, drv);
if (ep_in < 0)
return -1;
return 0;
}
int usb_hid_set_first_interface(int interface)
{
usb_interface = interface;
return interface + 1;
}
int usb_hid_get_config_descriptor(unsigned char *dest,int max_packet_size)
{
unsigned char *report, *orig_dest = dest;
logf("hid: config desc.");
/* Ignore given max_packet_size */
(void)max_packet_size;
/* TODO: Increment report_id for each report, and send command with
* appropriate report id */
report_id = 2;
/* Initialize report descriptor */
report = report_descriptor;
pack_parameter(&report, USAGE_PAGE, USAGE_PAGE_CONSUMER);
PACK_VAL2(report, CONCAT(CONSUMER_USAGE, CONSUMER_CONTROL));
pack_parameter(&report, COLLECTION, COLLECTION_APPLICATION);
pack_parameter(&report, REPORT_ID, report_id);
pack_parameter(&report, REPORT_SIZE, 16);
pack_parameter(&report, REPORT_COUNT, 2);
pack_parameter(&report, LOGICAL_MINIMUM, 1);
pack_parameter(&report, LOGICAL_MAXIMUM, 652);
pack_parameter(&report, USAGE_MINIMUM, CONSUMER_CONTROL);
pack_parameter(&report, USAGE_MAXIMUM, AC_SEND);
pack_parameter(&report, INPUT, PREFERERD | NULL_STATE);
PACK_VAL1(report, END_COLLECTION);
report_descriptor_len = (uint16_t)((uint32_t)report -
(uint32_t)report_descriptor);
interface_descriptor.bInterfaceNumber = usb_interface;
PACK_DATA(dest, interface_descriptor);
hid_descriptor.wDescriptorLength0 = report_descriptor_len;
PACK_DATA(dest, hid_descriptor);
endpoint_descriptor.wMaxPacketSize = 8;
endpoint_descriptor.bInterval = 8;
endpoint_descriptor.bEndpointAddress = ep_in;
PACK_DATA(dest, endpoint_descriptor);
return (dest - orig_dest);
}
void usb_hid_init_connection(void)
{
logf("hid: init connection");
active = true;
}
/* called by usb_core_init() */
void usb_hid_init(void)
{
int i;
logf("hid: init");
for (i = 0; i < HID_NUM_BUFFERS; i++)
send_buffer_len[i] = 0;
cur_buf_prepare = 0;
cur_buf_send = 0;
active = true;
}
void usb_hid_disconnect(void)
{
logf("hid: disconnect");
active = false;
}
/* called by usb_core_transfer_complete() */
void usb_hid_transfer_complete(int ep, int dir, int status, int length)
{
(void)ep;
(void)dir;
(void)status;
(void)length;
switch (dir) {
case USB_DIR_OUT:
break;
case USB_DIR_IN: {
if (status)
break;
send_buffer_len[cur_buf_send] = 0;
HID_BUF_INC(cur_buf_send);
usb_hid_try_send_drv();
break;
}
}
}
/* called by usb_core_control_request() */
bool usb_hid_control_request(struct usb_ctrlrequest* req, unsigned char* dest)
{
bool handled = false;
switch(req->bRequestType & USB_TYPE_MASK) {
case USB_TYPE_STANDARD: {
unsigned char *orig_dest = dest;
switch(req->wValue>>8) { /* type */
case USB_DT_HID: {
logf("hid: type hid");
hid_descriptor.wDescriptorLength0 = report_descriptor_len;
PACK_DATA(dest, hid_descriptor);
break;
}
case USB_DT_REPORT: {
logf("hid: type report");
memcpy(dest, &report_descriptor, report_descriptor_len);
dest += report_descriptor_len;
break;
}
default:
logf("hid: unsup. std. req");
break;
}
if (dest != orig_dest &&
!usb_drv_send(EP_CONTROL, orig_dest, dest - orig_dest)) {
usb_core_ack_control(req);
handled = true;
}
break;
}
case USB_TYPE_CLASS: {
switch (req->bRequest) {
case USB_HID_SET_IDLE:
logf("hid: set idle");
usb_core_ack_control(req);
handled = true;
break;
default:
logf("%d: unsup. cls. req", req->bRequest);
break;
}
break;
}
case USB_TYPE_VENDOR:
logf("hid: unsup. ven. req");
break;
}
return handled;
}
static void usb_hid_try_send_drv(void)
{
int rc;
int length = send_buffer_len[cur_buf_send];
if (!length)
return;
rc = usb_drv_send_nonblocking(ep_in, send_buffer[cur_buf_send], length);
if (rc)
{
send_buffer_len[cur_buf_send] = 0;
return;
}
}
static void usb_hid_queue(unsigned char *data, int length)
{
if (!active || length <= 0)
return;
/* Buffer overflow - item still in use */
if (send_buffer_len[cur_buf_prepare])
return;
/* Prepare buffer for sending */
if (length > HID_BUF_SIZE_MSG)
length = HID_BUF_SIZE_MSG;
memcpy(send_buffer[cur_buf_prepare], data, length);
send_buffer_len[cur_buf_prepare] = length;
HID_BUF_INC(cur_buf_prepare);
}
void usb_hid_send_consumer_usage(consumer_usage_page_t id)
{
static unsigned char buf[HID_BUF_SIZE_CMD] USB_DEVBSS_ATTR
__attribute__((aligned(32)));
unsigned char *dest = buf;
memset(buf, 0, sizeof(buf));
logf("HID: Sending 0x%x", id);
pack_parameter(&dest, 0, id);
buf[0] = report_id;
/* Key pressed */
usb_hid_queue(buf, HID_BUF_SIZE_CMD);
/* Key released */
memset(buf, 0, sizeof(buf));
buf[0] = report_id;
usb_hid_queue(buf, HID_BUF_SIZE_CMD);
usb_hid_try_send_drv();
}
Reference in a new issue View git blame Copy permalink