drivers/spi/atmel_spi.c

   1 /*
   2  * Copyright (C) 2007 Atmel Corporation
   3  *
   4  * See file CREDITS for list of people who contributed to this
   5  * project.
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License as
   9  * published by the Free Software Foundation; either version 2 of
  10  * the License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  20  * MA 02111-1307 USA
  21  */
  22 #include <common.h>
  23 #include <spi.h>
  24 #include <malloc.h>
  25
  26 #include <asm/io.h>
  27
  28 #include <asm/arch/clk.h>
  29 #include <asm/arch/hardware.h>
  30
  31 #include "atmel_spi.h"
  32
  33 void spi_init()
  34 {
  35
  36 }
  37
  38 struct spi_slave *spi_setup_slave(unsigned int bus, unsigned int cs,
  39                         unsigned int max_hz, unsigned int mode)
  40 {
  41         struct atmel_spi_slave  *as;
  42         unsigned int            scbr;
  43         u32                     csrx;
  44         void                    *regs;
  45
  46         if (!spi_cs_is_valid(bus, cs))
  47                 return NULL;
  48
  49         switch (bus) {
  50         case 0:
  51                 regs = (void *)ATMEL_BASE_SPI0;
  52                 break;
  53 #ifdef ATMEL_BASE_SPI1
  54         case 1:
  55                 regs = (void *)ATMEL_BASE_SPI1;
  56                 break;
  57 #endif
  58 #ifdef ATMEL_BASE_SPI2
  59         case 2:
  60                 regs = (void *)ATMEL_BASE_SPI2;
  61                 break;
  62 #endif
  63 #ifdef ATMEL_BASE_SPI3
  64         case 3:
  65                 regs = (void *)ATMEL_BASE_SPI3;
  66                 break;
  67 #endif
  68         default:
  69                 return NULL;
  70         }
  71
  72
  73         scbr = (get_spi_clk_rate(bus) + max_hz - 1) / max_hz;
  74         if (scbr > ATMEL_SPI_CSRx_SCBR_MAX)
  75                 /* Too low max SCK rate */
  76                 return NULL;
  77         if (scbr < 1)
  78                 scbr = 1;
  79
  80         csrx = ATMEL_SPI_CSRx_SCBR(scbr);
  81         csrx |= ATMEL_SPI_CSRx_BITS(ATMEL_SPI_BITS_8);
  82         if (!(mode & SPI_CPHA))
  83                 csrx |= ATMEL_SPI_CSRx_NCPHA;
  84         if (mode & SPI_CPOL)
  85                 csrx |= ATMEL_SPI_CSRx_CPOL;
  86
  87         as = spi_alloc_slave(struct atmel_spi_slave, bus, cs);
  88         if (!as)
  89                 return NULL;
  90
  91         as->regs = regs;
  92         as->mr = ATMEL_SPI_MR_MSTR | ATMEL_SPI_MR_MODFDIS
  93 #if defined(CONFIG_AT91SAM9X5) || defined(CONFIG_AT91SAM9M10G45)
  94                         | ATMEL_SPI_MR_WDRBT
  95 #endif
  96                         | ATMEL_SPI_MR_PCS(~(1 << cs) & 0xf);
  97         spi_writel(as, CSR(cs), csrx);
  98
  99         return &as->slave;
 100 }
 101
 102 void spi_free_slave(struct spi_slave *slave)
 103 {
 104         struct atmel_spi_slave *as = to_atmel_spi(slave);
 105
 106         free(as);
 107 }
 108
 109 int spi_claim_bus(struct spi_slave *slave)
 110 {
 111         struct atmel_spi_slave *as = to_atmel_spi(slave);
 112
 113         /* Enable the SPI hardware */
 114         spi_writel(as, CR, ATMEL_SPI_CR_SPIEN);
 115
 116         /*
 117          * Select the slave. This should set SCK to the correct
 118          * initial state, etc.
 119          */
 120         spi_writel(as, MR, as->mr);
 121
 122         return 0;
 123 }
 124
 125 void spi_release_bus(struct spi_slave *slave)
 126 {
 127         struct atmel_spi_slave *as = to_atmel_spi(slave);
 128
 129         /* Disable the SPI hardware */
 130         spi_writel(as, CR, ATMEL_SPI_CR_SPIDIS);
 131 }
 132
 133 int spi_xfer(struct spi_slave *slave, unsigned int bitlen,
 134                 const void *dout, void *din, unsigned long flags)
 135 {
 136         struct atmel_spi_slave *as = to_atmel_spi(slave);
 137         unsigned int    len_tx;
 138         unsigned int    len_rx;
 139         unsigned int    len;
 140         u32             status;
 141         const u8        *txp = dout;
 142         u8              *rxp = din;
 143         u8              value;
 144
 145         if (bitlen == 0)
 146                 /* Finish any previously submitted transfers */
 147                 goto out;
 148
 149         /*
 150          * TODO: The controller can do non-multiple-of-8 bit
 151          * transfers, but this driver currently doesn't support it.
 152          *
 153          * It's also not clear how such transfers are supposed to be
 154          * represented as a stream of bytes...this is a limitation of
 155          * the current SPI interface.
 156          */
 157         if (bitlen % 8) {
 158                 /* Errors always terminate an ongoing transfer */
 159                 flags |= SPI_XFER_END;
 160                 goto out;
 161         }
 162
 163         len = bitlen / 8;
 164
 165         /*
 166          * The controller can do automatic CS control, but it is
 167          * somewhat quirky, and it doesn't really buy us much anyway
 168          * in the context of U-Boot.
 169          */
 170         if (flags & SPI_XFER_BEGIN) {
 171                 spi_cs_activate(slave);
 172                 /*
 173                  * sometimes the RDR is not empty when we get here,
 174                  * in theory that should not happen, but it DOES happen.
 175                  * Read it here to be on the safe side.
 176                  * That also clears the OVRES flag. Required if the
 177                  * following loop exits due to OVRES!
 178                  */
 179                 spi_readl(as, RDR);
 180         }
 181
 182         for (len_tx = 0, len_rx = 0; len_rx < len; ) {
 183                 status = spi_readl(as, SR);
 184
 185                 if (status & ATMEL_SPI_SR_OVRES)
 186                         return -1;
 187
 188                 if (len_tx < len && (status & ATMEL_SPI_SR_TDRE)) {
 189                         if (txp)
 190                                 value = *txp++;
 191                         else
 192                                 value = 0;
 193                         spi_writel(as, TDR, value);
 194                         len_tx++;
 195                 }
 196                 if (status & ATMEL_SPI_SR_RDRF) {
 197                         value = spi_readl(as, RDR);
 198                         if (rxp)
 199                                 *rxp++ = value;
 200                         len_rx++;
 201                 }
 202         }
 203
 204 out:
 205         if (flags & SPI_XFER_END) {
 206                 /*
 207                  * Wait until the transfer is completely done before
 208                  * we deactivate CS.
 209                  */
 210                 do {
 211                         status = spi_readl(as, SR);
 212                 } while (!(status & ATMEL_SPI_SR_TXEMPTY));
 213
 214                 spi_cs_deactivate(slave);
 215         }
 216
 217         return 0;
 218 }