spi.h

Go to the documentation of this file.

/*
 * Copyright (C) 2005-2012 The Paparazzi Team
 *
 * This file is part of paparazzi.
 *
 * paparazzi is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
 * paparazzi is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with paparazzi; see the file COPYING.  If not, write to
 * the Free Software Foundation, 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 *
 */
 
#ifndef SPI_H
#define SPI_H
 
#include "std.h"
 
#include "mcu_periph/spi_arch.h"
#include "mcu_periph/sys_time.h"
 
#ifndef SPI_BLOCKING_TIMEOUT
#define SPI_BLOCKING_TIMEOUT 1.f
#endif
 
 
// FIXME how to use this properly ?
enum SPIMode {
  SPIMaster,
  SPISlave
};
 
enum SPISlaveSelect {
  SPISelectUnselect, 
  SPISelect,         
  SPIUnselect,       
  SPINoSelect        
};
 
enum SPIClockPhase {
  SPICphaEdge1,  
  SPICphaEdge2   
};
 
enum SPIClockPolarity {
  SPICpolIdleLow,  
  SPICpolIdleHigh  
};
 
enum SPIDataSizeSelect {
  SPIDss8bit,
  SPIDss16bit
};
 
enum SPITransactionStatus {
  SPITransPending,
  SPITransRunning,
  SPITransSuccess,
  SPITransFailed,
  SPITransDone
};
 
enum SPIStatus {
  SPIIdle,
  SPIRunning
};
 
enum SPIBitOrder {
  SPIMSBFirst,
  SPILSBFirst
};
 
enum SPIClockDiv {
  SPIDiv2,
  SPIDiv4,
  SPIDiv8,
  SPIDiv16,
  SPIDiv32,
  SPIDiv64,
  SPIDiv128,
  SPIDiv256
};
 
struct spi_transaction;
 
typedef void (*SPICallback)(struct spi_transaction *trans);
 
struct spi_transaction {
  volatile uint8_t *input_buf;  
  volatile uint8_t *output_buf; 
  uint16_t input_length;        
  uint16_t output_length;       
  uint8_t slave_idx;            
  enum SPISlaveSelect select;   
  enum SPIClockPolarity cpol;   
  enum SPIClockPhase cpha;      
  enum SPIDataSizeSelect dss;   
  enum SPIBitOrder bitorder;    
  enum SPIClockDiv cdiv;        
  SPICallback before_cb;        
  SPICallback after_cb;         
  volatile enum SPITransactionStatus status;
};
 
#ifndef SPI_TRANSACTION_QUEUE_LEN
#define SPI_TRANSACTION_QUEUE_LEN 8
#endif
 
struct spi_periph {
  struct spi_transaction *trans[SPI_TRANSACTION_QUEUE_LEN];
  uint8_t trans_insert_idx;
  uint8_t trans_extract_idx;
  volatile enum SPIStatus status;
  volatile uint8_t tx_idx_buf;
  volatile uint8_t rx_idx_buf;
  void *reg_addr;
  void *init_struct;
  enum SPIMode mode;
  volatile uint8_t suspend;
};
 
#if SPI_MASTER
 
#define SPI_SLAVE0 0
#define SPI_SLAVE1 1
#define SPI_SLAVE2 2
#define SPI_SLAVE3 3
#define SPI_SLAVE4 4
#define SPI_SLAVE5 5
#define SPI_SLAVE6 6
#define SPI_SLAVE7 7
#define SPI_SLAVE8 8
 
//extern uint8_t spi_nb_ovrn;
 
#if USE_SPI0
 
extern struct spi_periph spi0;
extern void spi0_init(void);
 
extern void spi0_arch_init(void);
 
#endif // USE_SPI0
 
#if USE_SPI1
 
extern struct spi_periph spi1;
extern void spi1_init(void);
 
extern void spi1_arch_init(void);
 
#endif // USE_SPI1
 
#if USE_SPI2
 
extern struct spi_periph spi2;
extern void spi2_init(void);
 
extern void spi2_arch_init(void);
 
#endif // USE_SPI2
 
#if USE_SPI3
 
extern struct spi_periph spi3;
extern void spi3_init(void);
 
extern void spi3_arch_init(void);
 
#endif // USE_SPI3
 
#if USE_SPI4
 
extern struct spi_periph spi4;
extern void spi4_init(void);
 
extern void spi4_arch_init(void);
 
#endif // USE_SPI4
 
#if USE_SPI6
 
extern struct spi_periph spi6;
extern void spi6_init(void);
 
extern void spi6_arch_init(void);
 
#endif // USE_SPI6
 
extern void spi_init(struct spi_periph *p);
 
extern void spi_init_slaves(void);
 
extern bool spi_submit(struct spi_periph *p, struct spi_transaction *t);
 
static inline bool spi_blocking_transceive(struct spi_periph *p, struct spi_transaction *t) {
  if (!spi_submit(p, t)) {
    return false;
  }
  // Wait for transaction to complete
  float start_t = get_sys_time_float();
  while (t->status == SPITransPending || t->status == SPITransRunning) {
    if (get_sys_time_float() - start_t > SPI_BLOCKING_TIMEOUT) {
      break;
    }
  }
  return true;
}
 
extern void spi_slave_select(uint8_t slave);
 
extern void spi_slave_unselect(uint8_t slave);
 
extern bool spi_lock(struct spi_periph *p, uint8_t slave);
 
extern bool spi_resume(struct spi_periph *p, uint8_t slave);
 
#endif /* SPI_MASTER */
 
#if SPI_SLAVE
 
#if USE_SPI0_SLAVE
 
extern struct spi_periph spi0;
extern void spi0_slave_init(void);
 
extern void spi0_slave_arch_init(void);
 
#endif
 
#if USE_SPI1_SLAVE
 
extern struct spi_periph spi1;
extern void spi1_slave_init(void);
 
extern void spi1_slave_arch_init(void);
 
#endif
 
#if USE_SPI2_SLAVE
 
extern struct spi_periph spi2;
extern void spi2_slave_init(void);
 
extern void spi2_slave_arch_init(void);
 
#endif
 
#if USE_SPI3_SLAVE
 
extern struct spi_periph spi3;
extern void spi3_slave_init(void);
 
extern void spi3_slave_arch_init(void);
 
#endif
 
extern void spi_slave_init(struct spi_periph *p);
 
extern bool spi_slave_register(struct spi_periph *p, struct spi_transaction *t);
 
extern bool spi_slave_wait(struct spi_periph *p);
 
#endif /* SPI_SLAVE */
 
#if SPI_SLAVE_HS
#include "mcu_periph/spi_slave_hs_arch.h"
extern void spi_slave_hs_init(void);
#endif
 
#endif /* SPI_H */