Colony

/* @file spi.c

 * @brief

 * SPI module

 * @bug broken

 */

#include <avr/interrupt.h>

#include "ring_buffer.h"

#include "spi.h"

#include <dragonfly_lib.h>

/*

SS = PB0

SCK = PB1

MOSI = PB2

MISO = PB3

*/

/* Controls clock freq. see Table 72 of specs*/

#define DOUBLE_SCK 1

#define SPR0_BIT 1

#define SPR1_BIT 0

#define LSB 1

#define MSB 0

RING_BUFFER_NEW(spi_buffer, 16, char, spi_send_buff, spi_rec_buff);

volatile char spi_status;

char spi_mode;

static spi_fun_recv_t  spi_recv_function;

//static spi_fun_send_t  spi_send_function;

void spi_init(char mode, spi_fun_recv_t recv_func) {

    usb_puts("spi_init: start\n");

        spi_mode = mode;

        RING_BUFFER_CLEAR(spi_send_buff);

        RING_BUFFER_CLEAR(spi_rec_buff);

        spi_recv_function = recv_func;

        //spi_send_function = send_func;

    /* Enables the SPI module

     * Enable Interrupt, Enable SPI Module, LSB First, Master Mode, Clock div = 64

     */

    SPCR = 0x00;

        SPCR = _BV(SPIE) | _BV(SPE) | _BV(DORD) | _BV(MSTR)| _BV(SPR1) | _BV(SPR0);

    SPSR = 0x00;

        SPSR = _BV(SPI2X);

        spi_status = SPI_RECV;

    /* Set SCLK, SS, MOSI as outputs. MISO as input */

        if(mode == MASTER) {

            DDRB |= MOSI | SCLK | SS;

            DDRB &= ~MISO;

                PORTB |= SS;        //Keep SS High until transmit

        /* Set SCLK, SS, MOSI as inputs. MISO as output */

        } else {

            DDRB &= ~MOSI & ~SCLK & ~SS;

            DDRB |= MISO;

    }

        //sei();

        usb_puts("spi_init: end\n");

}

int spi_send(char *data, size_t bytes) {

        int i;

    if(bytes == 0)

        return -1; /* ...needed?*/

    //Prevent race condition on the buffer

    cli();

    for(i = 1; i < bytes; i++) {

        // Fail if the buffer is full

            if(RING_BUFFER_FULL(spi_send_buff)) {

                sei();

                return -1;

            }

            RING_BUFFER_ADD(spi_send_buff, data[i]);

    }

    sei();

    spi_status |= SPI_SEND;

        if (spi_mode == MASTER ){

                PORTB &= ~SS;        //Select slave

        }

    SPDR = *data;

        if(spi_mode)

                usb_puts("MASTER");

        else

                usb_puts("SLAVE");

        usb_puts(": sending [");usb_putc(*data);usb_puts("]\n\r");

        //sei();

        return 1;

}

void spi_read_one(void)

{

        PORTB &= ~SS;

        SPDR = 'x';

}

ISR(SIG_SPI) {

        char c;

        if(!RING_BUFFER_EMPTY(spi_send_buff)) {//cheap way to test if SPI_SEND

                RING_BUFFER_REMOVE(spi_send_buff, c);

                SPDR = c;

                if(spi_mode)

                        usb_puts("MASTER");

                else

                        usb_puts("SLAVE");

                usb_puts(": sending [");usb_putc(c);usb_puts("]\n\r");

        } else if(spi_status & SPI_SEND) {

                spi_status ^= SPI_SEND;

                PORTB |= SS; //Sleep slave

        }

        if(spi_status & SPI_RECV){

                spi_recv_function(SPDR);

                if(spi_mode == MASTER)

                        PORTB |= SS;

        }

}