xref: /openbmc/u-boot/drivers/spi/atmel_spi.c (revision 3408a348)
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