HCI.hh

Go to the documentation of this file.

#ifndef COSA_CC3000_HCI_HH
#define COSA_CC3000_HCI_HH

#include "Cosa/SPI.hh"
#include "Cosa/ExternalInterrupt.hh"

class HCI : public SPI::Driver {
public:

  class Event {
  public:
    class Handler {
    public:
      virtual void on_event(uint16_t event, void* args, size_t len) = 0;
    };
  };

  static const uint16_t DEFAULT_TIMEOUT = 3000;

  HCI(Board::DigitalPin cs,
      Board::ExternalInterruptPin irq,
      SPI::Clock rate = SPI::DEFAULT_CLOCK) :
    SPI::Driver(cs, SPI::ACTIVE_LOW, rate, 1, SPI::MSB_ORDER, &m_irq),
    m_irq(irq, this),
    m_available(false),
    m_timeout(DEFAULT_TIMEOUT),
    m_event_handler(NULL)
  {
  }

  int read(uint16_t &op, void* args, uint8_t len);

  int write(uint8_t type, uint16_t op, const void* args, uint8_t len)
  {
    return (write(type, op, args, len, false));
  }

  int write_P(uint8_t type, uint16_t op, const void* args, uint8_t len)
  {
    return (write(type, op, args, len, true));
  }

  int write(uint8_t type, uint16_t op, const void* args, uint8_t len,
            bool progmem);

  int issue(uint16_t op, const void* args = NULL, uint8_t len = 0)
  {
    return (write(HCI_TYPE_CMND, op, args, len, false));
  }

  int issue_P(uint16_t op, const void* args, uint8_t len)
  {
    return (write(HCI_TYPE_CMND, op, args, len, true));
  }

  int await(uint16_t op, void* args = NULL, uint8_t len = 0);

  int write_data(uint8_t op, const void* args, uint8_t args_len,
                 const void* data, uint16_t data_len)
  {
    return (write_data(op, args, args_len, data, data_len, false));
  }

  int write_data_P(uint8_t op, const void* args, uint8_t args_len,
                   const void* data, uint16_t data_len)
  {
    return (write_data(op, args, args_len, data, data_len, true));
  }

  int write_data(uint8_t op, const void* args, uint8_t args_len,
                 const void* data, uint16_t data_len, bool progmem);

  int read_data(uint8_t op, void* args, uint8_t args_len,
                void* data, uint16_t data_len);

  void enable()
  {
    m_irq.enable();
  }

  void disable()
  {
    m_irq.disable();
  }

  bool is_available()
  {
    return (m_available);
  }

  void event_handler(Event::Handler* handler)
  {
    m_event_handler = handler;
  }

protected:
  class IRQPin : public ExternalInterrupt {
    friend class HCI;
  public:
    IRQPin(Board::ExternalInterruptPin pin, HCI* hci) :
      ExternalInterrupt(pin, ExternalInterrupt::ON_FALLING_MODE, true),
      m_hci(hci)
    {}

    virtual void on_interrupt(uint16_t arg)
    {
      UNUSED(arg);
      m_hci->m_available = true;
    }

  private:
    HCI* m_hci;                 
  };

  enum {
    SPI_OP_WRITE = 0x01,        
    SPI_OP_REPLY = 0x02,        
    SPI_OP_READ = 0x03          
  };

  struct cmnd_header_t {
    uint8_t type;               
    uint16_t cmnd;              
    uint8_t len;                
  };

  struct data_header_t {
    uint8_t type;               
    uint8_t cmnd;               
    uint8_t args_len;           
    uint16_t payload_len;       
  };

  enum {
    HCI_TYPE_CMND = 0x01,       
    HCI_TYPE_DATA = 0x02,       
    HCI_TYPE_PATCH = 0x03,      
    HCI_TYPE_EVNT = 0x04        
  };

  IRQPin m_irq;

  volatile bool m_available;

  uint16_t m_timeout;

  Event::Handler* m_event_handler;

  static const uint8_t EVNT_MAX = 64;

  uint8_t m_evnt[EVNT_MAX];
};
#endif