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;

        //cli();

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

    /* 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;

        usb_puts("spi_send: start\n");

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

        if (spi_mode == MASTER ){

                PORTB &= ~SS;        //Select slave

        }

    SPDR = *data;

        usb_puts("spi_send: end\n");

        //sei();

        return 1;

}

void spi_master_recv_on() {

        spi_status = SPI_VOID;

        PORTB &= ~SS;

}

void spi_master_recv_off() {

        spi_status = SPI_VOID;

        PORTB |= SS;

}

ISR(SIG_SPI) {

    usb_puts("ISR: start\n\r");

        char c;

        //usb_putc('['); usb_puti(c);usb_putc(',');usb_puti(spi_status);usb_puts("]\n\r");

        switch(spi_status){

                case SPI_SENDING:

                        if(!RING_BUFFER_EMPTY(spi_send_buff)) {

                                RING_BUFFER_REMOVE(spi_send_buff, c);

                                //usb_puts("SPDR=["); usb_puti(c);usb_putc(',');usb_puti(spi_status);usb_puts("]\n\r");

                                SPDR = c;

                                //c = SPDR;

                                //usb_puts("c=["); usb_puti(c);usb_putc(',');usb_puti(spi_status);usb_puts("]\n");

                        } else {

                                if (spi_mode == MASTER)

                                        PORTB |= SS;                //Turn off Slave select

                                spi_status = SPI_VOID;

                        }

                        break;

                case SPI_VOID:

                        spi_recv_function(SPDR);

                        break;

        }

        usb_puts("ISR: end\n");

}