This source file includes following definitions.
- bitbang_txrx_8
- bitbang_txrx_16
- bitbang_txrx_32
- spi_bitbang_setup_transfer
- spi_bitbang_setup
- spi_bitbang_cleanup
- spi_bitbang_bufs
- spi_bitbang_prepare_hardware
- spi_bitbang_transfer_one
- spi_bitbang_unprepare_hardware
- spi_bitbang_set_cs
- spi_bitbang_init
- spi_bitbang_start
- spi_bitbang_stop
1
2
3
4
5
6 #include <linux/spinlock.h>
7 #include <linux/workqueue.h>
8 #include <linux/interrupt.h>
9 #include <linux/module.h>
10 #include <linux/delay.h>
11 #include <linux/errno.h>
12 #include <linux/platform_device.h>
13 #include <linux/slab.h>
14
15 #include <linux/spi/spi.h>
16 #include <linux/spi/spi_bitbang.h>
17
18 #define SPI_BITBANG_CS_DELAY 100
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40 struct spi_bitbang_cs {
41 unsigned nsecs;
42 u32 (*txrx_word)(struct spi_device *spi, unsigned nsecs,
43 u32 word, u8 bits, unsigned flags);
44 unsigned (*txrx_bufs)(struct spi_device *,
45 u32 (*txrx_word)(
46 struct spi_device *spi,
47 unsigned nsecs,
48 u32 word, u8 bits,
49 unsigned flags),
50 unsigned, struct spi_transfer *,
51 unsigned);
52 };
53
54 static unsigned bitbang_txrx_8(
55 struct spi_device *spi,
56 u32 (*txrx_word)(struct spi_device *spi,
57 unsigned nsecs,
58 u32 word, u8 bits,
59 unsigned flags),
60 unsigned ns,
61 struct spi_transfer *t,
62 unsigned flags
63 ) {
64 unsigned bits = t->bits_per_word;
65 unsigned count = t->len;
66 const u8 *tx = t->tx_buf;
67 u8 *rx = t->rx_buf;
68
69 while (likely(count > 0)) {
70 u8 word = 0;
71
72 if (tx)
73 word = *tx++;
74 word = txrx_word(spi, ns, word, bits, flags);
75 if (rx)
76 *rx++ = word;
77 count -= 1;
78 }
79 return t->len - count;
80 }
81
82 static unsigned bitbang_txrx_16(
83 struct spi_device *spi,
84 u32 (*txrx_word)(struct spi_device *spi,
85 unsigned nsecs,
86 u32 word, u8 bits,
87 unsigned flags),
88 unsigned ns,
89 struct spi_transfer *t,
90 unsigned flags
91 ) {
92 unsigned bits = t->bits_per_word;
93 unsigned count = t->len;
94 const u16 *tx = t->tx_buf;
95 u16 *rx = t->rx_buf;
96
97 while (likely(count > 1)) {
98 u16 word = 0;
99
100 if (tx)
101 word = *tx++;
102 word = txrx_word(spi, ns, word, bits, flags);
103 if (rx)
104 *rx++ = word;
105 count -= 2;
106 }
107 return t->len - count;
108 }
109
110 static unsigned bitbang_txrx_32(
111 struct spi_device *spi,
112 u32 (*txrx_word)(struct spi_device *spi,
113 unsigned nsecs,
114 u32 word, u8 bits,
115 unsigned flags),
116 unsigned ns,
117 struct spi_transfer *t,
118 unsigned flags
119 ) {
120 unsigned bits = t->bits_per_word;
121 unsigned count = t->len;
122 const u32 *tx = t->tx_buf;
123 u32 *rx = t->rx_buf;
124
125 while (likely(count > 3)) {
126 u32 word = 0;
127
128 if (tx)
129 word = *tx++;
130 word = txrx_word(spi, ns, word, bits, flags);
131 if (rx)
132 *rx++ = word;
133 count -= 4;
134 }
135 return t->len - count;
136 }
137
138 int spi_bitbang_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
139 {
140 struct spi_bitbang_cs *cs = spi->controller_state;
141 u8 bits_per_word;
142 u32 hz;
143
144 if (t) {
145 bits_per_word = t->bits_per_word;
146 hz = t->speed_hz;
147 } else {
148 bits_per_word = 0;
149 hz = 0;
150 }
151
152
153 if (!bits_per_word)
154 bits_per_word = spi->bits_per_word;
155 if (bits_per_word <= 8)
156 cs->txrx_bufs = bitbang_txrx_8;
157 else if (bits_per_word <= 16)
158 cs->txrx_bufs = bitbang_txrx_16;
159 else if (bits_per_word <= 32)
160 cs->txrx_bufs = bitbang_txrx_32;
161 else
162 return -EINVAL;
163
164
165 if (!hz)
166 hz = spi->max_speed_hz;
167 if (hz) {
168 cs->nsecs = (1000000000/2) / hz;
169 if (cs->nsecs > (MAX_UDELAY_MS * 1000 * 1000))
170 return -EINVAL;
171 }
172
173 return 0;
174 }
175 EXPORT_SYMBOL_GPL(spi_bitbang_setup_transfer);
176
177
178
179
180 int spi_bitbang_setup(struct spi_device *spi)
181 {
182 struct spi_bitbang_cs *cs = spi->controller_state;
183 struct spi_bitbang *bitbang;
184
185 bitbang = spi_master_get_devdata(spi->master);
186
187 if (!cs) {
188 cs = kzalloc(sizeof(*cs), GFP_KERNEL);
189 if (!cs)
190 return -ENOMEM;
191 spi->controller_state = cs;
192 }
193
194
195 cs->txrx_word = bitbang->txrx_word[spi->mode & (SPI_CPOL|SPI_CPHA)];
196 if (!cs->txrx_word)
197 return -EINVAL;
198
199 if (bitbang->setup_transfer) {
200 int retval = bitbang->setup_transfer(spi, NULL);
201 if (retval < 0)
202 return retval;
203 }
204
205 dev_dbg(&spi->dev, "%s, %u nsec/bit\n", __func__, 2 * cs->nsecs);
206
207 return 0;
208 }
209 EXPORT_SYMBOL_GPL(spi_bitbang_setup);
210
211
212
213
214 void spi_bitbang_cleanup(struct spi_device *spi)
215 {
216 kfree(spi->controller_state);
217 }
218 EXPORT_SYMBOL_GPL(spi_bitbang_cleanup);
219
220 static int spi_bitbang_bufs(struct spi_device *spi, struct spi_transfer *t)
221 {
222 struct spi_bitbang_cs *cs = spi->controller_state;
223 unsigned nsecs = cs->nsecs;
224 struct spi_bitbang *bitbang;
225
226 bitbang = spi_master_get_devdata(spi->master);
227 if (bitbang->set_line_direction) {
228 int err;
229
230 err = bitbang->set_line_direction(spi, !!(t->tx_buf));
231 if (err < 0)
232 return err;
233 }
234
235 if (spi->mode & SPI_3WIRE) {
236 unsigned flags;
237
238 flags = t->tx_buf ? SPI_MASTER_NO_RX : SPI_MASTER_NO_TX;
239 return cs->txrx_bufs(spi, cs->txrx_word, nsecs, t, flags);
240 }
241 return cs->txrx_bufs(spi, cs->txrx_word, nsecs, t, 0);
242 }
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258 static int spi_bitbang_prepare_hardware(struct spi_master *spi)
259 {
260 struct spi_bitbang *bitbang;
261
262 bitbang = spi_master_get_devdata(spi);
263
264 mutex_lock(&bitbang->lock);
265 bitbang->busy = 1;
266 mutex_unlock(&bitbang->lock);
267
268 return 0;
269 }
270
271 static int spi_bitbang_transfer_one(struct spi_master *master,
272 struct spi_device *spi,
273 struct spi_transfer *transfer)
274 {
275 struct spi_bitbang *bitbang = spi_master_get_devdata(master);
276 int status = 0;
277
278 if (bitbang->setup_transfer) {
279 status = bitbang->setup_transfer(spi, transfer);
280 if (status < 0)
281 goto out;
282 }
283
284 if (transfer->len)
285 status = bitbang->txrx_bufs(spi, transfer);
286
287 if (status == transfer->len)
288 status = 0;
289 else if (status >= 0)
290 status = -EREMOTEIO;
291
292 out:
293 spi_finalize_current_transfer(master);
294
295 return status;
296 }
297
298 static int spi_bitbang_unprepare_hardware(struct spi_master *spi)
299 {
300 struct spi_bitbang *bitbang;
301
302 bitbang = spi_master_get_devdata(spi);
303
304 mutex_lock(&bitbang->lock);
305 bitbang->busy = 0;
306 mutex_unlock(&bitbang->lock);
307
308 return 0;
309 }
310
311 static void spi_bitbang_set_cs(struct spi_device *spi, bool enable)
312 {
313 struct spi_bitbang *bitbang = spi_master_get_devdata(spi->master);
314
315
316
317
318
319 enable = (!!(spi->mode & SPI_CS_HIGH) == enable);
320
321 ndelay(SPI_BITBANG_CS_DELAY);
322 bitbang->chipselect(spi, enable ? BITBANG_CS_ACTIVE :
323 BITBANG_CS_INACTIVE);
324 ndelay(SPI_BITBANG_CS_DELAY);
325 }
326
327
328
329 int spi_bitbang_init(struct spi_bitbang *bitbang)
330 {
331 struct spi_master *master = bitbang->master;
332
333 if (!master || !bitbang->chipselect)
334 return -EINVAL;
335
336 mutex_init(&bitbang->lock);
337
338 if (!master->mode_bits)
339 master->mode_bits = SPI_CPOL | SPI_CPHA | bitbang->flags;
340
341 if (master->transfer || master->transfer_one_message)
342 return -EINVAL;
343
344 master->prepare_transfer_hardware = spi_bitbang_prepare_hardware;
345 master->unprepare_transfer_hardware = spi_bitbang_unprepare_hardware;
346 master->transfer_one = spi_bitbang_transfer_one;
347 master->set_cs = spi_bitbang_set_cs;
348
349 if (!bitbang->txrx_bufs) {
350 bitbang->use_dma = 0;
351 bitbang->txrx_bufs = spi_bitbang_bufs;
352 if (!master->setup) {
353 if (!bitbang->setup_transfer)
354 bitbang->setup_transfer =
355 spi_bitbang_setup_transfer;
356 master->setup = spi_bitbang_setup;
357 master->cleanup = spi_bitbang_cleanup;
358 }
359 }
360
361 return 0;
362 }
363 EXPORT_SYMBOL_GPL(spi_bitbang_init);
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393 int spi_bitbang_start(struct spi_bitbang *bitbang)
394 {
395 struct spi_master *master = bitbang->master;
396 int ret;
397
398 ret = spi_bitbang_init(bitbang);
399 if (ret)
400 return ret;
401
402
403
404
405 ret = spi_register_master(spi_master_get(master));
406 if (ret)
407 spi_master_put(master);
408
409 return ret;
410 }
411 EXPORT_SYMBOL_GPL(spi_bitbang_start);
412
413
414
415
416 void spi_bitbang_stop(struct spi_bitbang *bitbang)
417 {
418 spi_unregister_master(bitbang->master);
419 }
420 EXPORT_SYMBOL_GPL(spi_bitbang_stop);
421
422 MODULE_LICENSE("GPL");
423