W5100.hh

Go to the documentation of this file.

#ifndef COSA_W5100_HH
#define COSA_W5100_HH

#include "Cosa/Types.h"

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

class W5100 : private SPI::Driver {
public:
  W5100(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 RMSR;               
    uint8_t TMSR;               
    uint8_t PATR[2];            
    uint8_t reserved2[10];      
    uint8_t PTIMER;             
    uint8_t PMAGIC;             
    uint8_t UIPR[4];            
    uint16_t UPORT;             
  };

  enum {
    MR_RST = 0x80,              
    MR_PB = 0x10,               
    MR_PPPoE = 0x08,            
    MR_AI = 0x02,               
    MR_IND = 0x01               
  } __attribute__((packed));

  enum {
    IR_CONFLICT = 0x80,         
    IR_UNREACH = 0x40,          
    IR_PPPoE = 0x20,            
    IR_S3_INT = 0x08,           
    IR_S2_INT = 0x04,           
    IR_S1_INT = 0x02,           
    IR_S0_INT = 0x01            
  } __attribute__((packed));

  enum {
    IMR_CONFLICT = 0x80,        
    IMR_UNREACH = 0x40,         
    IMR_PPPoE = 0x20,           
    IMR_S3_INT = 0x08,          
    IMR_S2_INT = 0x04,          
    IMR_S1_INT = 0x02,          
    IMR_S0_INT = 0x01           
  } __attribute__((packed));

  enum {
    RMSR_S3_POS = 6,            
    RMSR_S2_POS = 4,            
    RMSR_S1_POS = 2,            
    RMSR_S0_POS = 0,            
  } __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[9];       
    uint16_t TX_FSR;            
    uint16_t TX_RD;             
    uint16_t TX_WR;             
    uint16_t RX_RSR;            
    uint16_t RX_RD;             
    uint8_t reserved2[2];       
    uint8_t reserved3[212];     
  };

  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              
  } __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));

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

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

  static const uint16_t RX_MEMORY_BASE = 0x6000;
  static const uint16_t RX_MEMORY_MAX = 0x2000;

  static const size_t BUF_MAX = 2048;
  static const uint16_t BUF_MASK = 0x07ff;
  static const uint8_t TX_MEMORY_SIZE = 0x55;
  static const uint8_t RX_MEMORY_SIZE = 0x55;

  static const size_t MSG_MAX = BUF_MAX / 2;

  static const uint8_t SOCK_MAX = 4;

  static const uint8_t DNS_RETRY_MAX = 4;

public:
  class Driver : public Socket {
    friend class W5100;
  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;

    W5100* 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 = 0xf0,
    OP_READ = 0x0f
  } __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