W5200.hh

Go to the documentation of this file.

#ifndef COSA_W5200_HH
#define COSA_W5200_HH

#include "Cosa/Types.h"

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

class W5200 : private SPI::Driver {
public:
  W5200(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];            
    uint8_t reserved1[2];       
    uint8_t IR;                 
    uint8_t IMR;                
    uint16_t RTR;               
    uint8_t RCR;                
    uint8_t reserved2[2];       
    uint8_t PATR[2];            
    uint8_t PPPALGO;            
    uint8_t VERSIONR;           
    uint8_t reserved3[8];       
    uint8_t PTIMER;             
    uint8_t PMAGIC;             
    uint8_t reserved4[6];       
    uint8_t INTLEVEL[2];        
    uint8_t reserved5[2];       
    uint8_t IR2;                
    uint8_t PSTATUS;            
    uint8_t IMR2;               
  };

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

  enum {
    IR_CONFLICT = 0x80,         
    IR_PPPoE = 0x20,            
  } __attribute__((packed));

  enum {
    IMR_CONFLICT = 0x80,        
    IMR_PPPoE = 0x20,           
  } __attribute__((packed));

  enum {
    IR2_S7_INT = 0x80,          
    IR2_S6_INT = 0x40,          
    IR2_S5_INT = 0x20,          
    IR2_S4_INT = 0x10,          
    IR2_S3_INT = 0x08,          
    IR2_S2_INT = 0x04,          
    IR2_S1_INT = 0x02,          
    IR2_S0_INT = 0x01           
  } __attribute__((packed));

  enum {
    IMR2_S7_INT = 0x80,         
    IMR2_S6_INT = 0x40,         
    IMR2_S5_INT = 0x20,         
    IMR2_S4_INT = 0x10,         
    IMR2_S3_INT = 0x08,         
    IMR2_S2_INT = 0x04,         
    IMR2_S1_INT = 0x02,         
    IMR2_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));

  static const uint16_t COMMON_REGISTER_BASE = 0x0000;
  static const uint16_t COMMON_REGISTER_SIZE = sizeof(CommonRegister);

  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 reserved2[208];     
  };

  enum {
    MR_FLAG_MASK = 0xe0,        
    MR_MULTI = 0x80,            
    MR_MF = 0x40,               
    MR_ND = 0x20,               
    MR_MC = 0x20,               
    MR_PROTO_MASK = 0x0f,       
    MR_PROTO_CLOSED = 0x00,     
    MR_PROTO_TCP = 0x01,        
    MR_PROTO_UDP = 0x02,        
    MR_PROTO_IPRAW = 0x03,      
    MR_PROTO_MACRAW = 0x04,     
    MR_PROTO_PPPoE = 0x05       
  } __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,             
#if 0
    CR_PCON = 0x23,             
    CR_PDISCON = 0x24,          
    CR_PCR = 0x25,              
    CR_PCN = 0x26,              
    CR_PCJ = 0x27               
#endif
  } __attribute__((packed));

  enum {
#if 0
    IR_PRECV = 0x80,            
    IR_PFAIL = 0x40,            
    IR_PNEXT = 0x20,            
#endif
    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));

  static const uint16_t SOCKET_REGISTER_BASE = 0x4000;
  static const uint16_t SOCKET_REGISTER_SIZE = sizeof(SocketRegister);

  static const uint16_t TX_MEMORY_BASE = 0x8000;
  static const uint16_t TX_MEMORY_MAX = 0x4000;

  static const uint16_t RX_MEMORY_BASE = 0xC000;
  static const uint16_t RX_MEMORY_MAX = 0x4000;

  static const size_t BUF_MAX = 2048;
  static const uint16_t BUF_MASK = 0x07ff;

  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 W5200;
  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;

    W5200* m_dev;

    uint16_t m_tx_buf;

    uint16_t m_tx_offset;

    uint16_t m_tx_len;

    uint16_t m_rx_buf;

    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];

  enum {
    OP_WRITE = 0x80,
    OP_READ = 0x00
  } __attribute__((packed));

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

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

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

  uint8_t read(uint16_t addr);

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

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

#endif
#endif