git.gag.com Git - fw/altos/blob - src/cc1111/ao_spi.c

   1 /*
   2  * Copyright © 2010 Keith Packard <keithp@keithp.com>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; version 2 of the License.
   7  *
   8  * This program is distributed in the hope that it will be useful, but
   9  * WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along
  14  * with this program; if not, write to the Free Software Foundation, Inc.,
  15  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  16  */
  17
  18 #include "ao.h"
  19
  20 /* Shared mutex to protect SPI bus, must cover the entire
  21  * operation, from CS low to CS high. This means that any SPI
  22  * user must protect the SPI bus with this mutex
  23  */
  24 __xdata uint8_t ao_spi_mutex;
  25 __xdata uint8_t ao_spi_dma_in_done;
  26 __xdata uint8_t ao_spi_dma_out_done;
  27
  28 uint8_t ao_spi_dma_out_id;
  29 uint8_t ao_spi_dma_in_id;
  30
  31 static __xdata uint8_t ao_spi_const;
  32
  33 /* Send bytes over SPI.
  34  *
  35  * This sets up two DMA engines, one writing the data and another reading
  36  * bytes coming back.  We use the bytes coming back to tell when the transfer
  37  * is complete, as the transmit register is double buffered and hence signals
  38  * completion one byte before the transfer is actually complete
  39  */
  40 void
  41 ao_spi_send_bus(void __xdata *block, uint16_t len) __reentrant
  42 {
  43         ao_dma_set_transfer(ao_spi_dma_in_id,
  44                             &U0DBUFXADDR,
  45                             &ao_spi_const,
  46                             len,
  47                             DMA_CFG0_WORDSIZE_8 |
  48                             DMA_CFG0_TMODE_SINGLE |
  49                             DMA_CFG0_TRIGGER_URX0,
  50                             DMA_CFG1_SRCINC_0 |
  51                             DMA_CFG1_DESTINC_0 |
  52                             DMA_CFG1_PRIORITY_NORMAL);
  53
  54         ao_dma_set_transfer(ao_spi_dma_out_id,
  55                             block,
  56                             &U0DBUFXADDR,
  57                             len,
  58                             DMA_CFG0_WORDSIZE_8 |
  59                             DMA_CFG0_TMODE_SINGLE |
  60                             DMA_CFG0_TRIGGER_UTX0,
  61                             DMA_CFG1_SRCINC_1 |
  62                             DMA_CFG1_DESTINC_0 |
  63                             DMA_CFG1_PRIORITY_NORMAL);
  64
  65         ao_dma_start(ao_spi_dma_in_id);
  66         ao_dma_start(ao_spi_dma_out_id);
  67         ao_dma_trigger(ao_spi_dma_out_id);
  68         __critical while (!ao_spi_dma_in_done)
  69                 ao_sleep(&ao_spi_dma_in_done);
  70 }
  71
  72 /* Receive bytes over SPI.
  73  *
  74  * This sets up tow DMA engines, one reading the data and another
  75  * writing constant values to the SPI transmitter as that is what
  76  * clocks the data coming in.
  77  */
  78 void
  79 ao_spi_recv_bus(void __xdata *block, uint16_t len) __reentrant
  80 {
  81         ao_dma_set_transfer(ao_spi_dma_in_id,
  82                             &U0DBUFXADDR,
  83                             block,
  84                             len,
  85                             DMA_CFG0_WORDSIZE_8 |
  86                             DMA_CFG0_TMODE_SINGLE |
  87                             DMA_CFG0_TRIGGER_URX0,
  88                             DMA_CFG1_SRCINC_0 |
  89                             DMA_CFG1_DESTINC_1 |
  90                             DMA_CFG1_PRIORITY_NORMAL);
  91
  92         ao_spi_const = 0xff;
  93
  94         ao_dma_set_transfer(ao_spi_dma_out_id,
  95                             &ao_spi_const,
  96                             &U0DBUFXADDR,
  97                             len,
  98                             DMA_CFG0_WORDSIZE_8 |
  99                             DMA_CFG0_TMODE_SINGLE |
 100                             DMA_CFG0_TRIGGER_UTX0,
 101                             DMA_CFG1_SRCINC_0 |
 102                             DMA_CFG1_DESTINC_0 |
 103                             DMA_CFG1_PRIORITY_NORMAL);
 104
 105         ao_dma_start(ao_spi_dma_in_id);
 106         ao_dma_start(ao_spi_dma_out_id);
 107         ao_dma_trigger(ao_spi_dma_out_id);
 108         __critical while (!ao_spi_dma_in_done)
 109                 ao_sleep(&ao_spi_dma_in_done);
 110 }
 111
 112 /*
 113  * Initialize USART0 for SPI using config alt 2
 114  *
 115  *      MO      P1_5
 116  *      MI      P1_4
 117  *      CLK     P1_3
 118  *
 119  * Chip select is the responsibility of the caller
 120  */
 121
 122 void
 123 ao_spi_init(void)
 124 {
 125         /* Set up the USART pin assignment */
 126         PERCFG = (PERCFG & ~PERCFG_U0CFG_ALT_MASK) | PERCFG_U0CFG_ALT_2;
 127
 128         /* Ensure that USART0 takes precidence over USART1 for pins that
 129          * they share
 130          */
 131         P2SEL = (P2SEL & ~P2SEL_PRI3P1_MASK) | P2SEL_PRI3P1_USART0;
 132
 133         /* Make the SPI pins be controlled by the USART peripheral */
 134         P1SEL |= ((1 << 5) | (1 << 4) | (1 << 3));
 135
 136         /* Set up OUT DMA */
 137         ao_spi_dma_out_id = ao_dma_alloc(&ao_spi_dma_out_done);
 138
 139         /* Set up IN DMA */
 140         ao_spi_dma_in_id = ao_dma_alloc(&ao_spi_dma_in_done);
 141
 142         /* Set up the USART.
 143          *
 144          * SPI master mode
 145          */
 146         U0CSR = (UxCSR_MODE_SPI | UxCSR_RE | UxCSR_MASTER);
 147
 148         /* Set the baud rate and signal parameters
 149          *
 150          * The cc1111 is limited to a 24/8 MHz SPI clock.
 151          * Every peripheral I've ever seen goes faster than that,
 152          * so set the clock to 3MHz (BAUD_E 17, BAUD_M 0)
 153          */
 154         U0BAUD = 0;
 155         U0GCR = (UxGCR_CPOL_NEGATIVE |
 156                  UxGCR_CPHA_FIRST_EDGE |
 157                  UxGCR_ORDER_MSB |
 158                  (17 << UxGCR_BAUD_E_SHIFT));
 159 }