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 } 219