hid_core.c

Go to the documentation of this file.

/**************************************************************************/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
#include "M4521.h"
#include "usbh_core.h"
 
#include "usbh_hid.h"
 
 
 
#define USB_TIMEOUT             100000
 
extern HID_DEV_T *find_hid_deivce_by_urb(URB_T *urb);
extern int  find_hid_device(HID_DEV_T *hdev);
extern EP_INFO_T *hid_get_ep_info(USB_DEV_T *dev, int ifnum, uint16_t dir);
 
 
static int usb_snd_control_msg(HID_DEV_T *hdev, int requesttype, int request,
                               int value, int index, char *bytes, int size, int timeout)
{
    USB_DEV_T       *udev = hdev->udev;
 
    return USBH_SendCtrlMsg(udev, usb_sndctrlpipe(udev, 0),
                            request, requesttype, value, index, bytes, size, timeout);
}
 
int usb_rcv_control_msg(HID_DEV_T *hdev, int requesttype, int request,
                        int value, int index, char *bytes, int size, int timeout)
{
    USB_DEV_T       *udev = hdev->udev;
 
    return USBH_SendCtrlMsg(udev, usb_rcvctrlpipe(udev, 0),
                            request, requesttype, value, index, bytes, size, timeout);
}
 
 
 
int32_t  HID_HidGetReportDescriptor(HID_DEV_T *hdev, uint8_t *desc_buf, int buf_max_len)
{
    int  len;
 
    if (buf_max_len < 9)
        return HID_RET_INVALID_PARAMETER;
 
    len = usb_rcv_control_msg(hdev,
                              USB_DIR_IN+1,
                              USB_REQ_GET_DESCRIPTOR,
                              (USB_DT_HID << 8) + 0, hdev->ifnum,
                              (char*)desc_buf, buf_max_len,
                              USB_TIMEOUT);
 
    if (len < 0)
    {
        HID_DBGMSG("failed to get HID descriptor.\n");
        return HID_RET_IO_ERR;
    }
 
    len = desc_buf[7] | (desc_buf[8] << 8);
 
    HID_DBGMSG("Report descriptor size is %d\n", len);
 
    if (buf_max_len < len)
        return HID_RET_INVALID_PARAMETER;
 
    len = usb_rcv_control_msg(hdev,
                              USB_DIR_IN+1,
                              USB_REQ_GET_DESCRIPTOR,
                              (USB_DT_REPORT << 8) + 0, hdev->ifnum,
                              (char*)desc_buf, len,
                              USB_TIMEOUT);
 
    if (len < 0)
    {
        HID_DBGMSG("failed to get HID descriptor.\n");
        return HID_RET_IO_ERR;
    }
 
    HID_DBGMSG("successfully initialised HID descriptor %d bytes.\n", len);
 
    return len;
}
 
 
int32_t  HID_HidGetReport(HID_DEV_T *hdev, int rtp_typ, int rtp_id,
                          uint8_t *data, int len)
{
    len = usb_rcv_control_msg(hdev,
                              USB_DIR_IN + USB_TYPE_CLASS + USB_RECIP_INTERFACE,
                              HID_REPORT_GET,
                              rtp_id + (rtp_typ << 8),
                              hdev->ifnum,
                              (char *)data, len, USB_TIMEOUT);
 
    if (len < 0)
    {
        HID_DBGMSG("failed to get report!\n");
        return HID_RET_IO_ERR;
    }
    return len;
}
 
 
int32_t  HID_HidSetReport(HID_DEV_T *hdev, int rtp_typ, int rtp_id,
                          uint8_t *data, int len)
{
    len = usb_snd_control_msg(hdev,
                              USB_DIR_OUT + USB_TYPE_CLASS + USB_RECIP_INTERFACE,
                              HID_REPORT_SET,
                              rtp_id + (rtp_typ << 8),
                              hdev->ifnum,
                              (char *)data, len, USB_TIMEOUT);
 
    if (len < 0)
    {
        HID_DBGMSG("failed to set report!\n");
        return HID_RET_IO_ERR;
    }
    return len;
}
 
 
int32_t  HID_HidGetIdle(HID_DEV_T *hdev, int rtp_id, uint8_t *idle_rate)
{
    int   len;
 
    len = usb_rcv_control_msg(hdev,
                              USB_DIR_IN + USB_TYPE_CLASS + USB_RECIP_INTERFACE,
                              HID_GET_IDLE,
                              rtp_id,
                              hdev->ifnum,
                              (char *)idle_rate, 1, USB_TIMEOUT);
 
    if (len != 1)
    {
        HID_DBGMSG("failed to get idle rate! %d\n", len);
        return HID_RET_IO_ERR;
    }
    return HID_RET_OK;
}
 
 
int32_t  HID_HidSetIdle(HID_DEV_T *hdev, int rtp_id, uint8_t idle_rate)
{
    int       ret;
    uint16_t  wValue = idle_rate;
 
    ret = usb_snd_control_msg(hdev,
                              USB_DIR_OUT + USB_TYPE_CLASS + USB_RECIP_INTERFACE,
                              HID_SET_IDLE,
                              rtp_id + (wValue << 8),
                              hdev->ifnum,
                              NULL, 0, USB_TIMEOUT);
 
    if (ret < 0)
    {
        HID_DBGMSG("failed to set idle rate! %d\n", ret);
        return HID_RET_IO_ERR;
    }
    return HID_RET_OK;
}
 
 
int32_t  HID_HidGetProtocol(HID_DEV_T *hdev, uint8_t *protocol)
{
    int   len;
 
    len = usb_rcv_control_msg(hdev,
                              USB_DIR_IN + USB_TYPE_CLASS + USB_RECIP_INTERFACE,
                              HID_GET_PROTOCOL,
                              0,
                              hdev->ifnum,
                              (char *)protocol, 1, USB_TIMEOUT);
 
    if (len != 1)
    {
        HID_DBGMSG("failed to get protocol! %d\n", len);
        return HID_RET_IO_ERR;
    }
    return HID_RET_OK;
}
 
int32_t  HID_HidSetProtocol(HID_DEV_T *hdev, uint8_t protocol)
{
    int     ret;
 
    ret = usb_snd_control_msg(hdev,
                              USB_DIR_OUT + USB_TYPE_CLASS + USB_RECIP_INTERFACE,
                              HID_SET_PROTOCOL,
                              protocol,
                              hdev->ifnum,
                              NULL, 0, USB_TIMEOUT);
 
    if (ret < 0)
    {
        HID_DBGMSG("failed to set protocol! %d\n", ret);
        return HID_RET_IO_ERR;
    }
    return HID_RET_OK;
}
 
 
/*
 * HID INT-in complete function
 */
static void  hid_read_irq(URB_T *urb)
{
    HID_DEV_T   *hdev;
 
    //HID_DBGMSG("hid_read_irq. %d\n", urb->actual_length);
 
    hdev = find_hid_deivce_by_urb(urb);
    if (hdev == NULL)
        return;
 
    if (urb->status)
    {
        HID_DBGMSG("hid_read_irq - has error: 0x%x\n", urb->status);
        return;
    }
 
    if (hdev->read_func && urb->actual_length)
        hdev->read_func(hdev, urb->transfer_buffer, urb->actual_length);
}
 
/*
 * HID INT-out complete function
 */
static void  hid_write_irq(URB_T *urb)
{
    HID_DEV_T     *hdev;
 
    //HID_DBGMSG("hid_write_irq. %d\n", urb->actual_length);
 
    hdev = find_hid_deivce_by_urb(urb);
    if (hdev == NULL)
        return;
 
    if (urb->status)
    {
        HID_DBGMSG("hid_write_irq - has error: 0x%x\n", urb->status);
        return;
    }
 
    if (hdev->write_func)
        hdev->write_func(hdev, (uint8_t **)&urb->transfer_buffer, &urb->transfer_buffer_length);
}
 
 
 
int32_t USBH_HidStartIntReadPipe(HID_DEV_T *hdev, HID_IR_FUNC *func)
{
    EP_INFO_T   *ep_info;
    URB_T       *urb;
    uint32_t    pipe;
    USB_DEV_T   *udev;
    int         maxp, ret;
 
    if (!func)
        return HID_RET_INVALID_PARAMETER;
 
    udev = hdev->udev;
 
    if (hdev->urbin)
        return HID_RET_OUT_OF_MEMORY;
 
    ep_info = hid_get_ep_info(udev, hdev->ifnum, USB_DIR_IN);
    if (ep_info == NULL)
    {
        HID_DBGMSG("Interrupt-in endpoint not found in this device!\n");
        return HID_RET_NOT_SUPPORTED;
    }
 
    urb = USBH_AllocUrb();
    if (urb == NULL)
    {
        HID_DBGMSG("Failed to allocated URB!\n");
        return HID_RET_OUT_OF_MEMORY;
    }
 
    pipe = usb_rcvintpipe(udev, ep_info->bEndpointAddress);
    maxp = usb_maxpacket(udev, pipe, usb_pipeout(pipe));
 
    HID_DBGMSG("Endpoint 0x%x maximum packet size is %d.\n", ep_info->bEndpointAddress, maxp);
 
    FILL_INT_URB(urb, udev, pipe, &hdev->inbuf[0], maxp, hid_read_irq,
                 hdev, ep_info->bInterval);
 
    hdev->urbin = urb;
    hdev->read_func = func;
 
    ret = USBH_SubmitUrb(urb);
    if (ret)
    {
        HID_DBGMSG("Error - failed to submit interrupt read request (%d)", ret);
        USBH_FreeUrb(urb);
        hdev->urbin = NULL;
        return HID_RET_IO_ERR;
    }
 
    return HID_RET_OK;
}
 
int32_t USBH_HidStartIntWritePipe(HID_DEV_T *hdev, HID_IW_FUNC *func)
{
    EP_INFO_T   *ep_info;
    URB_T       *urb;
    uint32_t    pipe;
    USB_DEV_T   *udev;
    int         maxp, ret;
 
    if (!func)
        return HID_RET_INVALID_PARAMETER;
 
    udev = hdev->udev;
 
    if (hdev->urbout)
        return HID_RET_OUT_OF_MEMORY;
 
    ep_info = hid_get_ep_info(hdev->udev, hdev->ifnum, USB_DIR_OUT);
    if (ep_info == NULL)
    {
        HID_DBGMSG("Assigned endpoint address 0x%x not found in this device!\n", ep_info->bEndpointAddress);
        return HID_RET_INVALID_PARAMETER;
    }
 
    urb = USBH_AllocUrb();
    if (urb == NULL)
    {
        HID_DBGMSG("Failed to allocated URB!\n");
        return HID_RET_OUT_OF_MEMORY;
    }
 
    pipe = usb_sndintpipe(udev, ep_info->bEndpointAddress);
    maxp = usb_maxpacket(udev, pipe, usb_pipeout(pipe));
 
    HID_DBGMSG("Endpoint 0x%x maximum packet size is %d.\n", ep_info->bEndpointAddress, maxp);
 
    FILL_INT_URB(urb, udev, pipe, NULL, maxp, hid_write_irq,
                 hdev, ep_info->bInterval);
 
    func(hdev, (uint8_t **)&urb->transfer_buffer, &urb->transfer_buffer_length);
 
    hdev->urbout = urb;
    hdev->write_func = func;
 
    ret = USBH_SubmitUrb(urb);
    if (ret)
    {
        HID_DBGMSG("Error - failed to submit interrupt read request (%d)", ret);
        USBH_FreeUrb(urb);
        hdev->urbout = NULL;
        return HID_RET_IO_ERR;
    }
 
    return HID_RET_OK;
}
 
 /* end of group USBH_HID_EXPORTED_FUNCTIONS */
 /* end of group USBH_HID_Driver */
 /* end of group USB_Host_Driver */
 /* end of group Component_Library */