ueue/src/usbd_cdc_ncm.h

 
#ifndef __USBD_CDC_NCM_H
#define __USBD_CDC_NCM_H
 
#ifdef SOMRT1061
#include <usb.h>
#include <nettypes.h>
#include <buffers.h>
#include <nbrtos.h>
#include "ncm_protocol.h"
 
// Forward declaration
class InterfaceBlock;
class NcmInterfaceBlock;
 
/*******************************************************************************
 * USB Endpoint Configuration
 ******************************************************************************/
#define NCM_BULK_EP_NUM             (1)     // Bulk IN/OUT endpoint number
#define NCM_INT_EP_NUM              (2)     // Interrupt IN endpoint number
#define NCM_BULK_MAX_PACKET_HS      (512)   // High-speed bulk packet size
#define NCM_BULK_MAX_PACKET_FS      (64)    // Full-speed bulk packet size
#define NCM_INT_MAX_PACKET          (16)    // Interrupt packet size
 
/*******************************************************************************
 * CDC Class Requests
 ******************************************************************************/
#define CDC_SEND_ENCAPSULATED_CMD   (0x00)
#define CDC_GET_ENCAPSULATED_RESP   (0x01)
 
/*******************************************************************************
 * USB String Descriptor Indices
 ******************************************************************************/
#define NCM_STRING_IDX_MANUFACTURER (1)
#define NCM_STRING_IDX_PRODUCT      (2)
#define NCM_STRING_IDX_SERIAL       (3)
#define NCM_STRING_IDX_MAC          (4)
 
class dCDC_NCM : public nbrtos::USB::Device {
protected:
    // NCM state
    ncm_state_t ncmState;
    uint8_t currentAltSetting;
 
    // Device identity
    MACADR macAddress;
    uint32_t linkSpeed;  // in bps (100 Mbps = 100000000)
 
    // NTB configuration
    uint32_t ntbInMaxSize;      // Max NTB size device will accept
    uint32_t ntbOutMaxSize;     // Max NTB size device will send
 
    // Statistics
    uint32_t txFramesOk;
    uint32_t rxFramesOk;
    uint32_t txFramesError;
    uint32_t rxFramesError;
    uint32_t rxNoBuffer;
    uint32_t txQueueOverflow;   // Frames dropped due to full queue
 
    // USB buffers (aligned for DMA)
    uint8_t ntbRxBuf[NCM_MAX_NTB_SIZE] __attribute__((aligned(64)));
    uint8_t ntbTxBuf[NCM_MAX_NTB_SIZE] __attribute__((aligned(64)));
 
    // TX state
    ncm_tx_state_t txState;
    uint16_t txSequence;
    PoolPtr txPendingFrame;
 
    // TX queue for buffering frames when busy
    static const int TX_QUEUE_SIZE = 16;
    PoolPtr txQueue[TX_QUEUE_SIZE];
    volatile int txQueueHead;       // Next slot to write
    volatile int txQueueTail;       // Next slot to read
    volatile int txQueueCount;      // Number of frames in queue
 
    // RX state
    ncm_rx_state_t rxState;
    uint32_t rxBufLen;
 
    // Device state
    uint32_t devState;
    int baseEP;
 
    // Synchronization
    OS_CRIT ncm_crit;
 
    // Network interface pointer and number
    NcmInterfaceBlock *pInterface;
    int ifNumber;
 
    // Friend for network interface callbacks
    friend class NcmInterfaceBlock;
    friend void UserMain(void *pd);
 
protected:
    int QueueRx();
 
    bool TxQueueEnqueue(PoolPtr pp);
 
    PoolPtr TxQueueDequeue();
 
    bool TxQueueEmpty() const { return txQueueCount == 0; }
 
    bool TxQueueFull() const { return txQueueCount >= TX_QUEUE_SIZE; }
 
    void TxStartNextFrame();
 
    int ParseNtb16(uint8_t *ntb, uint32_t length);
 
    int BuildNtb16(uint8_t *destBuf, uint8_t *frameData, uint32_t frameLen);
 
    int SendNetworkConnectionNotification(bool connected);
 
    int SendSpeedChangeNotification();
 
public:
    dCDC_NCM(nbrtos::USB::Ctlr *parent, const usb_dev_t *desc,
             const usb_cfg_t *cfg, const nbrtos::USB::StrDescTbl *strTbl);
 
    void SetMACAddress(const MACADR &mac);
 
    void SetLinkSpeed(uint32_t speedMbps);
 
    ncm_state_t GetNcmState() const { return ncmState; }
 
    bool IsDataReady() const { return ncmState == NCM_STATE_CONNECTED; }
 
    uint32_t GetTxFramesOk() const { return txFramesOk; }
 
    uint32_t GetRxFramesOk() const { return rxFramesOk; }
 
    uint32_t GetTxFramesError() const { return txFramesError; }
 
    uint32_t GetRxFramesError() const { return rxFramesError; }
 
    uint32_t GetRxNoBuffer() const { return rxNoBuffer; }
 
    uint32_t GetTxQueueOverflow() const { return txQueueOverflow; }
 
    int GetTxQueueDepth() const { return txQueueCount; }
 
    uint32_t GetNtbMaxSize() const { return ntbInMaxSize; }
 
    // USB Device overrides
    virtual void Event_BusReset() override;
    virtual void Event_Suspend() override;
    virtual void Event_Resume() override;
    virtual int  Event_ControlMsg(nbrtos::USB::bufPtr_t ctlMsg, uint8_t bufLen) override;
    virtual int  SetConfiguration(uint16_t wValue) override;
    virtual int  SetAltSetting(uint16_t wIndex, uint16_t wValue) override;
    virtual int  ProcessBuffer(uint8_t epnum, PoolPtr pp, uint16_t bufLen) override;
    virtual int  ProcessSetupPkt(uint8_t epnum, usb_setup_pkt_t msg) override;
    virtual uint16_t GetMaxPktSize(uint8_t epnum, eDir_t dir) override;
    virtual uint16_t GetStatus(eReqTarget_t target, uint16_t wIndex, int *err) override;
    virtual uint8_t  GetActiveConfig(int *err) override;
    virtual uint8_t  GetAltSetting(uint8_t intfNum, int *err) override;
 
    nbrtos::USB::eBusState_t GetUSBState();
    void SetUSBState(nbrtos::USB::eBusState_t newState);
 
    // NCM protocol handlers
    int HandleGetNtbParameters(uint8_t epnum, uint16_t wLength);
    int HandleSetNtbInputSize(uint8_t *data, uint16_t length);
    int HandleGetNtbInputSize(uint8_t epnum, uint16_t wLength);
    int HandleSetEthernetPacketFilter(uint16_t wValue);
 
    // Data transfer
    int TransmitEthernetFrame(PoolPtr pp);
    void DeliverToNetworkStack(uint8_t *data, uint16_t len);
 
    // State machine processing
    void ProcessTxStateMachine();
    void ProcessRxStateMachine();
 
    // Network interface registration
    void SetNetworkInterface(NcmInterfaceBlock *pIntf, int interfaceNum) {
        pInterface = pIntf;
        ifNumber = interfaceNum;
    }
    NcmInterfaceBlock *GetNetworkInterface() { return pInterface; }
    int GetInterfaceNumber() { return ifNumber; }
};
 
int InitializeUSBNCM(dCDC_NCM *pNcm);
 
// Global NCM device instances (USB1 and USB2)
extern dCDC_NCM usb_ncm1;
extern dCDC_NCM usb_ncm2;
 
#endif /* SOMRT1061 */
#endif /* __USBD_CDC_NCM_H */