HidReport.h

/*
 * 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.
 */
 
#ifndef HIDREPORT_H
#define HIDREPORT_H
 
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/Vector.h"
#include "pedigree/kernel/utilities/new"
 
#include "modules/drivers/common/hid/HidUtils.h"
 
class EXPORTED_PUBLIC HidReport {
 public:
  HidReport();
  virtual ~HidReport();
 
  void parseDescriptor(uint8_t* pDescriptor, size_t nDescriptorLength);
  bool valid() const {
    return m_Valid;
  }
 
  void feedInput(uint8_t* pBuffer, uint8_t* pOldBuffer, size_t nBufferSize);
 
 private:
  enum ItemType { MainItem = 0, GlobalItem = 1, LocalItem = 2 };
 
  enum ItemTag {
    // Main items tags
    InputItem = 0x8,
    OutputItem = 0x9,
    FeatureItem = 0xb,
    CollectionItem = 0xa,
    EndCollectionItem = 0xc,
 
    // Global items tags
    UsagePageItem = 0x0,
    LogMinItem = 0x1,
    LogMaxItem = 0x2,
    PhysMinItem = 0x3,
    PhysMaxItem = 0x4,
    UnitExpItem = 0x5,
    UnitItem = 0x6,
    ReportSizeItem = 0x7,
    ReportIDItem = 0x8,
    ReportCountItem = 0x9,
    PushItem = 0xa,
    PopItem = 0xb,
 
    // Local items tags
    UsageItem = 0x0,
    UsageMinItem = 0x1,
    UsageMaxItem = 0x2
  };
 
  enum InputItemFlags { InputConstant = 1, InputVariable = 2, InputRelative = 4 };
 
  struct LocalState {
    LocalState();
    virtual ~LocalState();
 
    // Global values
    int64_t nUsagePage;
    int64_t nLogMin;
    int64_t nLogMax;
    int64_t nPhysMin;
    int64_t nPhysMax;
    int64_t nReportSize;
    int64_t nReportID;
    int64_t nReportCount;
 
    // Local values
    Vector<size_t>* pUsages;
    int64_t nUsageMin;
    int64_t nUsageMax;
 
    void resetLocalValues();
 
    uint16_t getUsageByIndex(uint16_t nUsageIndex);
 
    LocalState& operator=(LocalState& s);
    void copyGlobals(const LocalState& s);
  };
 
  struct InputBlock {
    void feedInput(uint8_t* pBuffer, uint8_t* pOldBuffer, size_t nBufferSize, size_t& nBitOffset,
                   HidDeviceType deviceType, uint8_t reportId, HidUtils::InputState& inputState);
 
    enum { Constant, Absolute, Relative, Array } type;
 
    LocalState state;
  };
 
  struct Collection {
    ~Collection();
    // Trickery to allow putting different type childs in the same vector
    enum ChildType { CollectionChild, InputBlockChild };
    struct Child {
      inline Child(Collection* pC) : type(CollectionChild), pCollection(pC) {}
      inline Child(InputBlock* pIB) : type(InputBlockChild), pInputBlock(pIB) {}
 
      ChildType type;
      union {
        Collection* pCollection;
        InputBlock* pInputBlock;
      };
    };
 
    void feedInput(uint8_t* pBuffer, uint8_t* pOldBuffer, size_t nBufferSize, size_t& nBitOffset,
                   uint8_t reportId, HidUtils::InputState& inputState);
 
    HidDeviceType guessInputDevice();
 
    Vector<Child*> childs;
 
    Collection* pParent;
 
    LocalState state;
  };
 
  Collection* m_pRootCollection;
  size_t m_ReportBits[256];
  uint8_t* m_OldReports[256];
  HidUtils::InputState* m_InputStates[256];
  bool m_HasReportIds;
  bool m_Valid;
};
 
#endif