]>
Commit | Line | Data |
---|---|---|
e3093091 WD |
1 | /* |
2 | * (C) Copyright 2002 | |
3 | * Gerald Van Baren, Custom IDEAS, vanbaren@cideas.com. | |
4 | * | |
5 | * Influenced by code from: | |
6 | * Wolfgang Denk, DENX Software Engineering, wd@denx.de. | |
7 | * | |
1a459660 | 8 | * SPDX-License-Identifier: GPL-2.0+ |
e3093091 WD |
9 | */ |
10 | ||
11 | #include <common.h> | |
12 | #include <spi.h> | |
13 | ||
d255bb0e HS |
14 | #include <malloc.h> |
15 | ||
e3093091 WD |
16 | /*----------------------------------------------------------------------- |
17 | * Definitions | |
18 | */ | |
19 | ||
20 | #ifdef DEBUG_SPI | |
21 | #define PRINTD(fmt,args...) printf (fmt ,##args) | |
22 | #else | |
23 | #define PRINTD(fmt,args...) | |
24 | #endif | |
25 | ||
d255bb0e HS |
26 | struct soft_spi_slave { |
27 | struct spi_slave slave; | |
28 | unsigned int mode; | |
29 | }; | |
30 | ||
31 | static inline struct soft_spi_slave *to_soft_spi(struct spi_slave *slave) | |
32 | { | |
33 | return container_of(slave, struct soft_spi_slave, slave); | |
34 | } | |
e3093091 | 35 | |
e3093091 WD |
36 | /*=====================================================================*/ |
37 | /* Public Functions */ | |
38 | /*=====================================================================*/ | |
39 | ||
40 | /*----------------------------------------------------------------------- | |
41 | * Initialization | |
42 | */ | |
43 | void spi_init (void) | |
44 | { | |
45 | #ifdef SPI_INIT | |
6d0f6bcf | 46 | volatile immap_t *immr = (immap_t *)CONFIG_SYS_IMMR; |
e3093091 WD |
47 | |
48 | SPI_INIT; | |
49 | #endif | |
50 | } | |
51 | ||
d255bb0e HS |
52 | struct spi_slave *spi_setup_slave(unsigned int bus, unsigned int cs, |
53 | unsigned int max_hz, unsigned int mode) | |
54 | { | |
55 | struct soft_spi_slave *ss; | |
56 | ||
57 | if (!spi_cs_is_valid(bus, cs)) | |
58 | return NULL; | |
59 | ||
d3504fee | 60 | ss = spi_alloc_slave(struct soft_spi_slave, bus, cs); |
d255bb0e HS |
61 | if (!ss) |
62 | return NULL; | |
63 | ||
d255bb0e HS |
64 | ss->mode = mode; |
65 | ||
66 | /* TODO: Use max_hz to limit the SCK rate */ | |
67 | ||
68 | return &ss->slave; | |
69 | } | |
70 | ||
71 | void spi_free_slave(struct spi_slave *slave) | |
72 | { | |
73 | struct soft_spi_slave *ss = to_soft_spi(slave); | |
74 | ||
75 | free(ss); | |
76 | } | |
77 | ||
78 | int spi_claim_bus(struct spi_slave *slave) | |
79 | { | |
6d0f6bcf JCPV |
80 | #ifdef CONFIG_SYS_IMMR |
81 | volatile immap_t *immr = (immap_t *)CONFIG_SYS_IMMR; | |
d255bb0e HS |
82 | #endif |
83 | struct soft_spi_slave *ss = to_soft_spi(slave); | |
84 | ||
85 | /* | |
86 | * Make sure the SPI clock is in idle state as defined for | |
87 | * this slave. | |
88 | */ | |
89 | if (ss->mode & SPI_CPOL) | |
90 | SPI_SCL(1); | |
91 | else | |
92 | SPI_SCL(0); | |
93 | ||
94 | return 0; | |
95 | } | |
96 | ||
97 | void spi_release_bus(struct spi_slave *slave) | |
98 | { | |
99 | /* Nothing to do */ | |
100 | } | |
e3093091 WD |
101 | |
102 | /*----------------------------------------------------------------------- | |
103 | * SPI transfer | |
104 | * | |
105 | * This writes "bitlen" bits out the SPI MOSI port and simultaneously clocks | |
106 | * "bitlen" bits in the SPI MISO port. That's just the way SPI works. | |
107 | * | |
108 | * The source of the outgoing bits is the "dout" parameter and the | |
109 | * destination of the input bits is the "din" parameter. Note that "dout" | |
110 | * and "din" can point to the same memory location, in which case the | |
111 | * input data overwrites the output data (since both are buffered by | |
112 | * temporary variables, this is OK). | |
e3093091 | 113 | */ |
d255bb0e HS |
114 | int spi_xfer(struct spi_slave *slave, unsigned int bitlen, |
115 | const void *dout, void *din, unsigned long flags) | |
e3093091 | 116 | { |
6d0f6bcf JCPV |
117 | #ifdef CONFIG_SYS_IMMR |
118 | volatile immap_t *immr = (immap_t *)CONFIG_SYS_IMMR; | |
d4024bb7 | 119 | #endif |
d255bb0e HS |
120 | struct soft_spi_slave *ss = to_soft_spi(slave); |
121 | uchar tmpdin = 0; | |
122 | uchar tmpdout = 0; | |
123 | const u8 *txd = dout; | |
124 | u8 *rxd = din; | |
125 | int cpol = ss->mode & SPI_CPOL; | |
126 | int cpha = ss->mode & SPI_CPHA; | |
127 | unsigned int j; | |
e3093091 | 128 | |
d255bb0e HS |
129 | PRINTD("spi_xfer: slave %u:%u dout %08X din %08X bitlen %u\n", |
130 | slave->bus, slave->cs, *(uint *)txd, *(uint *)rxd, bitlen); | |
e3093091 | 131 | |
d255bb0e HS |
132 | if (flags & SPI_XFER_BEGIN) |
133 | spi_cs_activate(slave); | |
e3093091 WD |
134 | |
135 | for(j = 0; j < bitlen; j++) { | |
136 | /* | |
137 | * Check if it is time to work on a new byte. | |
138 | */ | |
139 | if((j % 8) == 0) { | |
d255bb0e | 140 | tmpdout = *txd++; |
e3093091 | 141 | if(j != 0) { |
d255bb0e | 142 | *rxd++ = tmpdin; |
e3093091 WD |
143 | } |
144 | tmpdin = 0; | |
145 | } | |
d255bb0e HS |
146 | |
147 | if (!cpha) | |
148 | SPI_SCL(!cpol); | |
e3093091 WD |
149 | SPI_SDA(tmpdout & 0x80); |
150 | SPI_DELAY; | |
d255bb0e HS |
151 | if (cpha) |
152 | SPI_SCL(!cpol); | |
153 | else | |
154 | SPI_SCL(cpol); | |
155 | tmpdin <<= 1; | |
156 | tmpdin |= SPI_READ; | |
157 | tmpdout <<= 1; | |
e3093091 | 158 | SPI_DELAY; |
d255bb0e HS |
159 | if (cpha) |
160 | SPI_SCL(cpol); | |
e3093091 WD |
161 | } |
162 | /* | |
163 | * If the number of bits isn't a multiple of 8, shift the last | |
164 | * bits over to left-justify them. Then store the last byte | |
165 | * read in. | |
166 | */ | |
167 | if((bitlen % 8) != 0) | |
168 | tmpdin <<= 8 - (bitlen % 8); | |
d255bb0e | 169 | *rxd++ = tmpdin; |
e3093091 | 170 | |
d255bb0e HS |
171 | if (flags & SPI_XFER_END) |
172 | spi_cs_deactivate(slave); | |
e3093091 WD |
173 | |
174 | return(0); | |
175 | } |