UsbHumanInterfaceDevice.cc

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
#include "UsbHumanInterfaceDevice.h"
#include "pedigree/kernel/Log.h"
#include "pedigree/kernel/panic.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/PointerGuard.h"
#include "pedigree/kernel/utilities/Vector.h"
#include "pedigree/kernel/utilities/utility.h"
 
#include "modules/drivers/common/hid/HidReport.h"
#include "modules/system/usb/UsbConstants.h"
#include "modules/system/usb/UsbDevice.h"
 
UsbHumanInterfaceDevice::UsbHumanInterfaceDevice(UsbDevice* pDev)
    : UsbDevice(pDev),
      m_pInEndpoint(nullptr),
      m_pReport(nullptr),
      m_InterruptIn(),
      m_pInReportBuffer(nullptr),
      m_pOldInReportBuffer(nullptr),
      m_ReceivedInput(false) {}
 
UsbHumanInterfaceDevice::~UsbHumanInterfaceDevice() {
  if (!m_InterruptIn.reset()) {
    panic("USB HID destroyed from its running interrupt callback");
  }
  // Release held input only after the controller has drained report callbacks.
  delete m_pReport;
  delete[] m_pInReportBuffer;
  delete[] m_pOldInReportBuffer;
}
 
void UsbHumanInterfaceDevice::initialiseDriver() {
  // Get the HID descriptor
  HidDescriptor* pHidDescriptor = 0;
  for (size_t i = 0; i < m_pInterface->otherDescriptorList.count(); i++) {
    UnknownDescriptor* pDescriptor = m_pInterface->otherDescriptorList[i];
    if (pDescriptor->nType == 0x21 && pDescriptor->nLength >= sizeof(HidDescriptor::Descriptor)) {
      pHidDescriptor = new HidDescriptor(pDescriptor);
      break;
    }
  }
  if (!pHidDescriptor) {
    ERROR("USB: HID: No HID descriptor");
    return;
  }
  PointerGuard<HidDescriptor> guard(pHidDescriptor);
 
  // Set Idle Rate to 0
  controlRequest(static_cast<uint8_t>(static_cast<uint8_t>(UsbRequestType::Class) |
                                      static_cast<uint8_t>(UsbRequestRecipient::Interface)),
                 0x0a, 0, m_pInterface->nInterface);
 
  // Get the report descriptor
  uint16_t nReportDescriptorSize = pHidDescriptor->nDescriptorLength;
  uint8_t* pReportDescriptor = static_cast<uint8_t*>(
      getDescriptor(0x22, 0, nReportDescriptorSize, UsbRequestRecipient::Interface));
  PointerGuard<uint8_t> guard2(pReportDescriptor, true);
  if (!pReportDescriptor) {
    ERROR("USB: HID: Could not read report descriptor");
    return;
  }
 
  // Create a new report instance and use it to parse the report descriptor
  m_pReport = new HidReport();
  m_pReport->parseDescriptor(pReportDescriptor, nReportDescriptorSize);
  if (!m_pReport->valid()) {
    WARNING("USB: HID: invalid or unsupported report descriptor");
    return;
  }
 
  // Search for an interrupt IN endpoint
  for (size_t i = 0; i < m_pInterface->endpointList.count(); i++) {
    Endpoint* pEndpoint = m_pInterface->endpointList[i];
    if (pEndpoint->nTransferType == Endpoint::Interrupt && pEndpoint->bIn) {
      m_pInEndpoint = pEndpoint;
      break;
    }
  }
 
  // Did we end up with no interrupt IN endpoint?
  if (!m_pInEndpoint) {
    ERROR("USB: HID: No Interrupt IN endpoint");
    return;
  }
 
  // Allocate the input report buffers and zero them
  m_pInReportBuffer = new uint8_t[m_pInEndpoint->nMaxPacketSize];
  m_pOldInReportBuffer = new uint8_t[m_pInEndpoint->nMaxPacketSize];
  ByteSet(m_pInReportBuffer, 0, m_pInEndpoint->nMaxPacketSize);
  ByteSet(m_pOldInReportBuffer, 0, m_pInEndpoint->nMaxPacketSize);
 
  // Add the input handler
  if (!addInterruptInHandler(m_pInEndpoint, reinterpret_cast<uintptr_t>(m_pInReportBuffer),
                             m_pInEndpoint->nMaxPacketSize, callback, m_InterruptIn,
                             reinterpret_cast<uintptr_t>(this))) {
    ERROR("USB: HID: recurring interrupt-IN submission failed");
    return;
  }
 
  m_UsbState = HasDriver;
  NOTICE("USB: HID: ready, device " << m_pDescriptor->nVendorId << ":" << m_pDescriptor->nProductId
                                    << ", address " << Dec << m_nAddress << ", interface "
                                    << m_pInterface->nInterface << ", protocol "
                                    << m_pInterface->nProtocol << Hex);
}
 
void UsbHumanInterfaceDevice::callback(uintptr_t pParam, ssize_t ret) {
  UsbHumanInterfaceDevice* pHid = reinterpret_cast<UsbHumanInterfaceDevice*>(pParam);
  if (ret > 0 && static_cast<size_t>(ret) <= pHid->m_pInEndpoint->nMaxPacketSize)
    pHid->inputHandler(ret);
}
 
void UsbHumanInterfaceDevice::inputHandler(size_t bytes) {
  // Do we have a report instance?
  if (!m_pReport)
    return;
 
  if (!m_ReceivedInput) {
    m_ReceivedInput = true;
    NOTICE("USB: HID: first input report, device "
           << m_pDescriptor->nVendorId << ":" << m_pDescriptor->nProductId << ", address " << Dec
           << m_nAddress << ", interface " << m_pInterface->nInterface << ", bytes " << bytes
           << Hex);
  }
 
  // Feed the report instance with the input we just got
  m_pReport->feedInput(m_pInReportBuffer, m_pOldInReportBuffer, bytes);
}