UsbHw.hpp

//------------------------------------------------------------------------------
//This file is part of embKernel. 
//See license.txt for the full license governing this code.
//------------------------------------------------------------------------------

#ifndef USB_HW_HPP_
#define USB_HW_HPP_

#include "UsbDefs.hpp"
#include "UsbCfg.hpp"
#include "RtosInterrupt.hpp"

class UsbHw {
    friend class UsbDevice;
    friend class RtosInterrupt;
private:
    static UsbHw* sInstance;

    struct USB_REGISTERS {
        struct {
            union {
                struct {
                    volatile uint16_t ea :4;
                    volatile uint16_t statTx :2;
                    volatile uint16_t dtogTx :1;
                    volatile uint16_t ctrTx :1;
                    volatile uint16_t epKind :1;
                    volatile uint16_t epType :2;
                    volatile uint16_t setup :1;
                    volatile uint16_t statRx :2;
                    volatile uint16_t dtogRx :1;
                    volatile uint16_t ctrRx :1;
                } bits;
                volatile uint16_t value;
            };
            volatile uint16_t reserved;
        } EPnR[8];
        uint32_t reserver1[8];
        volatile uint16_t CNTR;
        uint16_t reserver2;
        volatile uint16_t ISTR;
        uint16_t reserved3;
        volatile uint16_t FNR;
        uint16_t reserved4;
        volatile uint16_t DADDR;
        uint16_t reserved5;
        volatile uint16_t BTABLE;
        uint16_t reserved6;
    }__attribute__((packed)) *USB_DEVICE = (USB_REGISTERS*) 0x40005C00;

    const static uint16_t REG_CNTR_FRES = ((uint16_t) 0x0001); //Force USB Reset
    const static uint16_t REG_CNTR_PDWN = ((uint16_t) 0x0002); //Power down
    const static uint16_t REG_CNTR_LP_MODE = ((uint16_t) 0x0004); //Low-power mode
    const static uint16_t REG_CNTR_FSUSP = ((uint16_t) 0x0008); //Force suspend
    const static uint16_t REG_CNTR_RESUME = ((uint16_t) 0x0010); //Resume request
    const static uint16_t REG_CNTR_ESOFM = ((uint16_t) 0x0100); //Expected Start Of Frame Interrupt Mask
    const static uint16_t REG_CNTR_SOFM = ((uint16_t) 0x0200); //Start Of Frame Interrupt Mask
    const static uint16_t REG_CNTR_RESETM = ((uint16_t) 0x0400); //RESET Interrupt Mask
    const static uint16_t REG_CNTR_SUSPM = ((uint16_t) 0x0800); //Suspend mode Interrupt Mask
    const static uint16_t REG_CNTR_WKUPM = ((uint16_t) 0x1000); //Wakeup Interrupt Mask
    const static uint16_t REG_CNTR_ERRM = ((uint16_t) 0x2000); //Error Interrupt Mask
    const static uint16_t REG_CNTR_PMAOVRM = ((uint16_t) 0x4000); //Packet Memory Area Over / Underrun Interrupt Mask
    const static uint16_t REG_CNTR_CTRM = ((uint16_t) 0x8000); //Correct Transfer Interrupt Mask

    const static uint16_t REG_ISTR_EP_ID = ((uint16_t) 0x000F); //Endpoint Identifier
    const static uint16_t REG_ISTR_DIR = ((uint16_t) 0x0010); //Direction of transaction
    const static uint16_t REG_ISTR_ESOF = ((uint16_t) 0x0100); //Expected Start Of Frame
    const static uint16_t REG_ISTR_SOF = ((uint16_t) 0x0200); //Start Of Frame
    const static uint16_t REG_ISTR_RESET = ((uint16_t) 0x0400); //USB RESET request */
    const static uint16_t REG_ISTR_SUSP = ((uint16_t) 0x0800); //Suspend mode request
    const static uint16_t REG_ISTR_WKUP = ((uint16_t) 0x1000); //Wake up
    const static uint16_t REG_ISTR_ERR = ((uint16_t) 0x2000); //Error
    const static uint16_t REG_ISTR_PMAOVR = ((uint16_t) 0x4000); //Packet Memory Area Over / Underrun
    const static uint16_t REG_ISTR_CTR = ((uint16_t) 0x8000); //Correct Transfer

    const static uint16_t REG_DADDR_ADD = ((uint8_t) 0x7F); // ADD[6:0] bits (Device Address)
    const static uint16_t REG_DADDR_EF = ((uint8_t) 0x80); // Enable Function

    const static uint16_t REG_EPXR_EA = ((uint16_t) 0x000F); //Endpoint Address

    const static uint16_t REG_EPXR_STAT_TX = ((uint16_t) 0x0030); //STAT_TX[1:0] bits (Status bits, for transmission transfers)
    const static uint16_t REG_EPXR_STAT_TX_0 = ((uint16_t) 0x0010); //Bit 0
    const static uint16_t REG_EPXR_STAT_TX_1 = ((uint16_t) 0x0020); //Bit 1

    const static uint16_t REG_EPXR_DTOG_TX = ((uint16_t) 0x0040); //Data Toggle, for transmission transfers
    const static uint16_t REG_EPXR_CTR_TX = ((uint16_t) 0x0080); //Correct Transfer for transmission
    const static uint16_t REG_EPXR_EP_KIND = ((uint16_t) 0x0100); //Endpoint Kind

    const static uint16_t REG_EPXR_EP_TYPE = ((uint16_t) 0x0600); //EP_TYPE[1:0] bits (Endpoint type)
    const static uint16_t REG_EPXR_EP_TYPE_0 = ((uint16_t) 0x0200); //Bit 0
    const static uint16_t REG_EPXR_EP_TYPE_1 = ((uint16_t) 0x0400); //Bit 1

    const static uint16_t REG_EPXR_SETUP = ((uint16_t) 0x0800); //Setup transaction completed

    const static uint16_t REG_EPXR_STAT_RX = ((uint16_t) 0x3000); //STAT_RX[1:0] bits (Status bits, for reception transfers)
    const static uint16_t REG_EPXR_STAT_RX_0 = ((uint16_t) 0x1000); //Bit 0
    const static uint16_t REG_EPXR_STAT_RX_1 = ((uint16_t) 0x2000); //Bit 1

    const static uint16_t REG_EPXR_DTOG_RX = ((uint16_t) 0x4000); //Data Toggle, for reception transfers
    const static uint16_t REG_EPXR_CTR_RX = ((uint16_t) 0x8000); //Correct Transfer for reception

    const static uint16_t EP_TYPE_BULK = 0;
    const static uint16_t EP_TYPE_CONTROL = REG_EPXR_EP_TYPE_0;
    const static uint16_t EP_TYPE_ISO = REG_EPXR_EP_TYPE_1;
    const static uint16_t EP_TYPE_INTERRUPT = REG_EPXR_EP_TYPE_1 | REG_EPXR_EP_TYPE_0;

    const static uint16_t EP_STAT_RX_DISABLED = 0;
    const static uint16_t EP_STAT_RX_STALL = REG_EPXR_STAT_RX_0;
    const static uint16_t EP_STAT_RX_NAK = REG_EPXR_STAT_RX_1;
    const static uint16_t EP_STAT_RX_VALID = REG_EPXR_STAT_RX_1 | REG_EPXR_STAT_RX_0;

    const static uint16_t EP_STAT_TX_DISABLED = 0;
    const static uint16_t EP_STAT_TX_STALL = REG_EPXR_STAT_TX_0;
    const static uint16_t EP_STAT_TX_NAK = REG_EPXR_STAT_TX_1;
    const static uint16_t EP_STAT_TX_VALID = REG_EPXR_STAT_TX_1 | REG_EPXR_STAT_TX_0;

    const static uint32_t PACKET_MEM_BASE = 0x40006000;
    const static size_t PACKET_MEM_SIZE = 0x200;
    uint32_t mPacketMemPosition;
    uint16_t mMaxInPktSize[USB_CFG_MAX_EPN];

    struct USB_TABLE_LOCATION {
        struct {
            volatile uint16_t ADDR_TX;
            uint16_t reserved1;
            volatile uint16_t COUNT_TX;
            uint16_t reserved2;
            volatile uint16_t ADDR_RX;
            uint16_t reserved3;
            volatile struct {
                uint16_t countRx :10;
                uint16_t numBlock :5;
                uint16_t blSize :1;
            } COUNT_RX;
            uint16_t reserved4;
        } EP[8];
    }__attribute__((packed)) *USB_TABLE = (USB_TABLE_LOCATION*) PACKET_MEM_BASE;

    void init();
    void reset();
    void setAddress(int address);
    void processEvents();
    uint16_t readEp(uint8_t ep, uint8_t* dst, uint16_t len);
    uint16_t writeEp(uint8_t ep, const uint8_t* src, uint16_t len);
    uint16_t getEpInFree(uint8_t ep);

    void epResetAll();
    void epConfig(const UsbDefs::USB_DESC_EP* epDesc);
    void setEpRxStatus(uint8_t ep, uint16_t status);
    void setEpTxStatus(uint8_t ep, uint16_t status);
    void enableInterrupts();
    void disableInterrupts();
    void writePktMem(const uint8_t *src, uint16_t dstAddr, uint16_t len);
    void readPktMem(uint8_t *dst, uint16_t addr, uint16_t len);
    inline void onEvent();
};

#endif /* USB_HW_HPP_ */