W5500.hh

Go to the documentation of this file.

#ifndef COSA_W5500_HH
#define COSA_W5500_HH

#include "Cosa/Types.h"

#if !defined(BOARD_ATTINY)
#include "Cosa/SPI.hh"
#include "Cosa/Socket.hh"

class W5500 : private SPI::Driver {
public:
  W5500(const uint8_t* mac = NULL, Board::DigitalPin csn = Board::D10);

  void addr(uint8_t ip[4], uint8_t subnet[4]);

  void dns_addr(uint8_t ip[4]) { memcpy(ip, m_dns, sizeof(m_dns)); }

  bool begin_P(const char* hostname, uint16_t timeout = 500);
  bool begin_P(str_P hostname, uint16_t timeout = 500)
  {
    return (begin_P((const char*) hostname, timeout));
  }

  bool begin(uint8_t ip[4] = NULL, uint8_t subnet[4] = NULL,
             uint16_t timeout = 500);

  int bind(uint8_t ip[4], uint8_t subnet[4], uint8_t gateway[4] = NULL);

  Socket* socket(Socket::Protocol proto, uint16_t port = 0, uint8_t flag = 0);

  bool end();

protected:
  struct CommonRegister {
    uint8_t MR;                 
    uint8_t GAR[4];             
    uint8_t SUBR[4];            
    uint8_t SHAR[6];            
    uint8_t SIPR[4];            
    uint16_t INTLEVEL;          
    uint8_t IR;                 
    uint8_t IMR;                
    uint8_t SIR;                
    uint8_t SIMR;               
    uint16_t RTR;               
    uint8_t RCR;                
    uint8_t PTIMER;             
    uint8_t PMAGIC;             
    uint8_t PHAR[6];            
    uint16_t PSID;              
    uint16_t PMRU;              
    uint8_t UIPR[4];            
    uint16_t UPORTR;            
    uint8_t PHYCFGR;            
    uint8_t reserved[10];       
    uint8_t VERSIONR;           
  };

  enum {
    MR_RST = 0x80,              
    MR_WOL = 0x20,              
    MR_PB = 0x10,               
    MR_PPPoE = 0x08,            
    MR_FARP = 0x02              
  } __attribute__((packed));

  enum {
    IR_CONFLICT = 0x80,         
    IR_UNREACH = 0x40,          
    IR_PPPoE = 0x20,            
    IR_MP = 0x10                
  } __attribute__((packed));

  /*
   * Interrupt Mask Register bitfields, pp. 37.
   */
  enum {
    IMR_CONFLICT = 0x80,        //<! IP Conflict.
    IMR_UNREACH = 0x40,         
    IMR_PPPoE = 0x20,           
    IMR_MP = 0x10               
  } __attribute__((packed));
 
  enum {
    SIR_S7_INT = 0x80,          
    SIR_S6_INT = 0x40,          
    SIR_S5_INT = 0x20,          
    SIR_S4_INT = 0x10,          
    SIR_S3_INT = 0x08,          
    SIR_S2_INT = 0x04,          
    SIR_S1_INT = 0x02,          
    SIR_S0_INT = 0x01           
  } __attribute__((packed));

  enum {
    SIMR_S7_INT = 0x80,         
    SIMR_S6_INT = 0x40,         
    SIMR_S5_INT = 0x20,         
    SIMR_S4_INT = 0x10,         
    SIMR_S3_INT = 0x08,         
    SIMR_S2_INT = 0x04,         
    SIMR_S1_INT = 0x02,         
    SIMR_S0_INT = 0x01          
  } __attribute__((packed));

  enum {
    MEM_SIZE_00K = 0x00,        
    MEM_SIZE_01K = 0x01,        
    MEM_SIZE_02K = 0x02,        
    MEM_SIZE_04K = 0x04,        
    MEM_SIZE_08K = 0x08,        
    MEM_SIZE_16K = 0x10,        
  } __attribute__((packed));

  struct SocketRegister {
    uint8_t MR;                 
    uint8_t CR;                 
    uint8_t IR;                 
    uint8_t SR;                 
    uint16_t PORT;              
    uint8_t DHAR[6];            
    uint8_t DIPR[4];            
    uint16_t DPORT;             
    uint16_t MSSR;              
    uint8_t PROTO;              
    uint8_t TOS;                
    uint8_t TTL;                
    uint8_t reserved1[7];       
    uint8_t RXMEM_SIZE;         
    uint8_t TXMEM_SIZE;         
    uint16_t TX_FSR;            
    uint16_t TX_RD;             
    uint16_t TX_WR;             
    uint16_t RX_RSR;            
    uint16_t RX_RD;             
    uint16_t RX_WR;             
    uint8_t IMR;                
    uint16_t FRAG;              
    uint8_t KPALVTR;            
  };

  enum {
    MR_FLAG_MASK = 0xe0,        
    MR_MULTIMF = 0x80,          
    MR_BCASTB = 0x40,           
    MR_NDMCMMB = 0x20,          
    MR_UCASTB = 0x10,           
    MR_PROTO_MASK = 0x0f,       
    MR_PROTO_CLOSED = 0x00,     
    MR_PROTO_TCP = 0x01,        
    MR_PROTO_UDP = 0x02,        
    MR_PROTO_IPRAW = 0x03,      
    MR_PROTO_MACRAW = 0x04,     
  } __attribute__((packed));

  enum {
    CR_OPEN = 0x01,             
    CR_LISTEN = 0x02,           
    CR_CONNECT = 0x04,          
    CR_DISCON = 0x08,           
    CR_CLOSE = 0x10,            
    CR_SEND = 0x20,             
    CR_SEND_MAC = 0x21,         
    CR_SEND_KEEP = 0x22,        
    CR_RECV = 0x40              
  } __attribute__((packed));

  enum {
    IR_SEND_OK = 0x10,          
    IR_TIMEOUT = 0x08,          
    IR_RECV = 0x04,             
    IR_DISCON = 0x02,           
    IR_CON = 0x01               
  } __attribute__((packed));

  enum {
    SR_CLOSED = 0x00,
    SR_ARP = 0x01,              
    SR_INIT = 0x13,
    SR_LISTEN = 0x14,
    SR_SYNSENT = 0x15,
    SR_SYNRECV = 0x16,
    SR_ESTABLISHED = 0x17,
    SR_FIN_WAIT = 0x18,
    SR_CLOSING = 0x1A,
    SR_TIME_WAIT = 0x1B,
    SR_CLOSE_WAIT = 0x1C,
    SR_LAST_ACK = 0x1D,
    SR_UDP = 0x22,
    SR_IPRAW = 0x32,
    SR_MACRAW = 0x42,
    SR_PPPoE = 0x5F             
  } __attribute__((packed));

  enum {
    SPI_CP_BSB_CR = 0x00,       
    SPI_CP_BSB_SR = 0x08,       
    SPI_CP_BSB_TX = 0x10,       
    SPI_CP_BSB_RX = 0x18,       
    SPI_CP_RWB_RS = 0x00,       
    SPI_CP_RWB_WS = 0x04,       
    SPI_CP_OM_VDM = 0x00,       
    SPI_CP_OM_FD1 = 0x01,       
    SPI_CP_OM_FD2 = 0x02,       
    SPI_CP_OM_FD4 = 0x03,       
  } __attribute__((packed));

  static const size_t BUF_MAX = 2048;  // this is initial, max is really 16KB

  static const size_t MSG_MAX = BUF_MAX / 2;

  static const uint8_t SOCK_MAX = 8;

  static const uint8_t DNS_RETRY_MAX = 4;

public:
  class Driver : public Socket {
    friend class W5500;
  public:
    Driver() : Socket() {}

    virtual int available();

    virtual int room();

    using IOStream::Device::write;

    using IOStream::Device::read;

    virtual int read(void* buf, size_t size);

    virtual int flush();

    virtual int open(Protocol proto, uint16_t port, uint8_t flag);

    virtual int close();

    virtual int listen();

    virtual int accept();

    virtual int connect(uint8_t addr[4], uint16_t port);

    virtual int connect(const char* hostname, uint16_t port);

    virtual int is_connected();

    virtual int disconnect();

    virtual int datagram(uint8_t addr[4], uint16_t port);

    virtual int recv(void* buf, size_t len);

    virtual int recv(void* buf, size_t len,
                     uint8_t src[4], uint16_t& port);

  protected:
    SocketRegister* m_sreg;

    W5500* m_dev;

    uint8_t m_snum;

    uint16_t m_tx_offset;

    uint16_t m_tx_len;

    int dev_read(void* buf, size_t len);

    int dev_write(const void* buf, size_t len, bool progmem);

    void dev_flush();

    void dev_setup();

    virtual int write(const void* buf, size_t size, bool progmem);

    virtual int send(const void* buf, size_t len, bool progmem);

    virtual int send(const void* buf, size_t len,
                     uint8_t dest[4], uint16_t port,
                     bool progmem);
  };

  static const uint8_t MAC[6] PROGMEM;

protected:
  Driver m_sock[SOCK_MAX];

  CommonRegister* m_creg;

  uint16_t m_local;

  const uint8_t* m_mac;

  uint8_t m_dns[4];

  void write(uint16_t addr, uint8_t ctl, uint8_t data)
  {
    write(addr, ctl, &data, 1);
  }

  void write(uint16_t addr, uint8_t ctl, const void* buf, size_t len, bool progmem = false);

  void write_P(uint16_t addr, uint8_t ctl, const void* buf, size_t len)
  {
    write(addr, ctl, buf, len, true);
  }

  uint8_t read(uint16_t addr, uint8_t ctl);

  void read(uint16_t addr, uint8_t ctl, void* buf, size_t len);

  void issue(uint16_t addr, uint8_t ctl, uint8_t cmd);
};

#endif
#endif