2 * spi_bitbang.c - polling/bitbanging SPI master controller driver utilities
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 #include <linux/config.h>
20 #include <linux/init.h>
21 #include <linux/spinlock.h>
22 #include <linux/workqueue.h>
23 #include <linux/interrupt.h>
24 #include <linux/delay.h>
25 #include <linux/errno.h>
26 #include <linux/platform_device.h>
28 #include <linux/spi/spi.h>
29 #include <linux/spi/spi_bitbang.h>
32 /*----------------------------------------------------------------------*/
35 * FIRST PART (OPTIONAL): word-at-a-time spi_transfer support.
36 * Use this for GPIO or shift-register level hardware APIs.
38 * spi_bitbang_cs is in spi_device->controller_state, which is unavailable
39 * to glue code. These bitbang setup() and cleanup() routines are always
40 * used, though maybe they're called from controller-aware code.
42 * chipselect() and friends may use use spi_device->controller_data and
43 * controller registers as appropriate.
46 * NOTE: SPI controller pins can often be used as GPIO pins instead,
47 * which means you could use a bitbang driver either to get hardware
48 * working quickly, or testing for differences that aren't speed related.
51 struct spi_bitbang_cs
{
52 unsigned nsecs
; /* (clock cycle time)/2 */
53 u32 (*txrx_word
)(struct spi_device
*spi
, unsigned nsecs
,
55 unsigned (*txrx_bufs
)(struct spi_device
*,
57 struct spi_device
*spi
,
60 unsigned, struct spi_transfer
*);
63 static unsigned bitbang_txrx_8(
64 struct spi_device
*spi
,
65 u32 (*txrx_word
)(struct spi_device
*spi
,
69 struct spi_transfer
*t
71 unsigned bits
= spi
->bits_per_word
;
72 unsigned count
= t
->len
;
73 const u8
*tx
= t
->tx_buf
;
76 while (likely(count
> 0)) {
81 word
= txrx_word(spi
, ns
, word
, bits
);
86 return t
->len
- count
;
89 static unsigned bitbang_txrx_16(
90 struct spi_device
*spi
,
91 u32 (*txrx_word
)(struct spi_device
*spi
,
95 struct spi_transfer
*t
97 unsigned bits
= spi
->bits_per_word
;
98 unsigned count
= t
->len
;
99 const u16
*tx
= t
->tx_buf
;
102 while (likely(count
> 1)) {
107 word
= txrx_word(spi
, ns
, word
, bits
);
112 return t
->len
- count
;
115 static unsigned bitbang_txrx_32(
116 struct spi_device
*spi
,
117 u32 (*txrx_word
)(struct spi_device
*spi
,
121 struct spi_transfer
*t
123 unsigned bits
= spi
->bits_per_word
;
124 unsigned count
= t
->len
;
125 const u32
*tx
= t
->tx_buf
;
128 while (likely(count
> 3)) {
133 word
= txrx_word(spi
, ns
, word
, bits
);
138 return t
->len
- count
;
142 * spi_bitbang_setup - default setup for per-word I/O loops
144 int spi_bitbang_setup(struct spi_device
*spi
)
146 struct spi_bitbang_cs
*cs
= spi
->controller_state
;
147 struct spi_bitbang
*bitbang
;
150 cs
= kzalloc(sizeof *cs
, SLAB_KERNEL
);
153 spi
->controller_state
= cs
;
155 bitbang
= spi_master_get_devdata(spi
->master
);
157 if (!spi
->bits_per_word
)
158 spi
->bits_per_word
= 8;
160 /* spi_transfer level calls that work per-word */
161 if (spi
->bits_per_word
<= 8)
162 cs
->txrx_bufs
= bitbang_txrx_8
;
163 else if (spi
->bits_per_word
<= 16)
164 cs
->txrx_bufs
= bitbang_txrx_16
;
165 else if (spi
->bits_per_word
<= 32)
166 cs
->txrx_bufs
= bitbang_txrx_32
;
170 /* per-word shift register access, in hardware or bitbanging */
171 cs
->txrx_word
= bitbang
->txrx_word
[spi
->mode
& (SPI_CPOL
|SPI_CPHA
)];
175 if (!spi
->max_speed_hz
)
176 spi
->max_speed_hz
= 500 * 1000;
178 /* nsecs = max(50, (clock period)/2), be optimistic */
179 cs
->nsecs
= (1000000000/2) / (spi
->max_speed_hz
);
182 if (cs
->nsecs
> MAX_UDELAY_MS
* 1000)
185 dev_dbg(&spi
->dev
, "%s, mode %d, %u bits/w, %u nsec\n",
186 __FUNCTION__
, spi
->mode
& (SPI_CPOL
| SPI_CPHA
),
187 spi
->bits_per_word
, 2 * cs
->nsecs
);
189 /* NOTE we _need_ to call chipselect() early, ideally with adapter
190 * setup, unless the hardware defaults cooperate to avoid confusion
191 * between normal (active low) and inverted chipselects.
194 /* deselect chip (low or high) */
195 spin_lock(&bitbang
->lock
);
196 if (!bitbang
->busy
) {
197 bitbang
->chipselect(spi
, 0);
200 spin_unlock(&bitbang
->lock
);
204 EXPORT_SYMBOL_GPL(spi_bitbang_setup
);
207 * spi_bitbang_cleanup - default cleanup for per-word I/O loops
209 void spi_bitbang_cleanup(const struct spi_device
*spi
)
211 kfree(spi
->controller_state
);
213 EXPORT_SYMBOL_GPL(spi_bitbang_cleanup
);
215 static int spi_bitbang_bufs(struct spi_device
*spi
, struct spi_transfer
*t
)
217 struct spi_bitbang_cs
*cs
= spi
->controller_state
;
218 unsigned nsecs
= cs
->nsecs
;
220 return cs
->txrx_bufs(spi
, cs
->txrx_word
, nsecs
, t
);
223 /*----------------------------------------------------------------------*/
226 * SECOND PART ... simple transfer queue runner.
228 * This costs a task context per controller, running the queue by
229 * performing each transfer in sequence. Smarter hardware can queue
230 * several DMA transfers at once, and process several controller queues
231 * in parallel; this driver doesn't match such hardware very well.
233 * Drivers can provide word-at-a-time i/o primitives, or provide
234 * transfer-at-a-time ones to leverage dma or fifo hardware.
236 static void bitbang_work(void *_bitbang
)
238 struct spi_bitbang
*bitbang
= _bitbang
;
241 spin_lock_irqsave(&bitbang
->lock
, flags
);
243 while (!list_empty(&bitbang
->queue
)) {
244 struct spi_message
*m
;
245 struct spi_device
*spi
;
247 struct spi_transfer
*t
;
252 m
= container_of(bitbang
->queue
.next
, struct spi_message
,
254 list_del_init(&m
->queue
);
255 spin_unlock_irqrestore(&bitbang
->lock
, flags
);
257 // FIXME this is made-up
267 if (bitbang
->shutdown
) {
272 /* set up default clock polarity, and activate chip */
274 bitbang
->chipselect(spi
, 1);
277 if (!t
->tx_buf
&& !t
->rx_buf
&& t
->len
) {
284 /* FIXME if bitbang->use_dma, dma_map_single()
285 * before the transfer, and dma_unmap_single()
286 * afterwards, for either or both buffers...
288 status
= bitbang
->txrx_bufs(spi
, t
);
290 if (status
!= t
->len
) {
295 m
->actual_length
+= status
;
298 /* protocol tweaks before next transfer */
300 udelay(t
->delay_usecs
);
303 if (tmp
>= m
->n_transfer
)
306 chipselect
= !t
->cs_change
;
310 bitbang
->chipselect(spi
, 0);
312 /* REVISIT do we want the udelay here instead? */
316 tmp
= m
->n_transfer
- 1;
317 tmp
= m
->transfers
[tmp
].cs_change
;
320 m
->complete(m
->context
);
323 bitbang
->chipselect(spi
, status
== 0 && tmp
);
326 spin_lock_irqsave(&bitbang
->lock
, flags
);
329 spin_unlock_irqrestore(&bitbang
->lock
, flags
);
333 * spi_bitbang_transfer - default submit to transfer queue
335 int spi_bitbang_transfer(struct spi_device
*spi
, struct spi_message
*m
)
337 struct spi_bitbang
*bitbang
;
340 m
->actual_length
= 0;
341 m
->status
= -EINPROGRESS
;
343 bitbang
= spi_master_get_devdata(spi
->master
);
344 if (bitbang
->shutdown
)
347 spin_lock_irqsave(&bitbang
->lock
, flags
);
348 list_add_tail(&m
->queue
, &bitbang
->queue
);
349 queue_work(bitbang
->workqueue
, &bitbang
->work
);
350 spin_unlock_irqrestore(&bitbang
->lock
, flags
);
354 EXPORT_SYMBOL_GPL(spi_bitbang_transfer
);
356 /*----------------------------------------------------------------------*/
359 * spi_bitbang_start - start up a polled/bitbanging SPI master driver
360 * @bitbang: driver handle
362 * Caller should have zero-initialized all parts of the structure, and then
363 * provided callbacks for chip selection and I/O loops. If the master has
364 * a transfer method, its final step should call spi_bitbang_transfer; or,
365 * that's the default if the transfer routine is not initialized. It should
366 * also set up the bus number and number of chipselects.
368 * For i/o loops, provide callbacks either per-word (for bitbanging, or for
369 * hardware that basically exposes a shift register) or per-spi_transfer
370 * (which takes better advantage of hardware like fifos or DMA engines).
372 * Drivers using per-word I/O loops should use (or call) spi_bitbang_setup and
373 * spi_bitbang_cleanup to handle those spi master methods. Those methods are
374 * the defaults if the bitbang->txrx_bufs routine isn't initialized.
376 * This routine registers the spi_master, which will process requests in a
377 * dedicated task, keeping IRQs unblocked most of the time. To stop
378 * processing those requests, call spi_bitbang_stop().
380 int spi_bitbang_start(struct spi_bitbang
*bitbang
)
384 if (!bitbang
->master
|| !bitbang
->chipselect
)
387 INIT_WORK(&bitbang
->work
, bitbang_work
, bitbang
);
388 spin_lock_init(&bitbang
->lock
);
389 INIT_LIST_HEAD(&bitbang
->queue
);
391 if (!bitbang
->master
->transfer
)
392 bitbang
->master
->transfer
= spi_bitbang_transfer
;
393 if (!bitbang
->txrx_bufs
) {
394 bitbang
->use_dma
= 0;
395 bitbang
->txrx_bufs
= spi_bitbang_bufs
;
396 if (!bitbang
->master
->setup
) {
397 bitbang
->master
->setup
= spi_bitbang_setup
;
398 bitbang
->master
->cleanup
= spi_bitbang_cleanup
;
400 } else if (!bitbang
->master
->setup
)
403 /* this task is the only thing to touch the SPI bits */
405 bitbang
->workqueue
= create_singlethread_workqueue(
406 bitbang
->master
->cdev
.dev
->bus_id
);
407 if (bitbang
->workqueue
== NULL
) {
412 /* driver may get busy before register() returns, especially
413 * if someone registered boardinfo for devices
415 status
= spi_register_master(bitbang
->master
);
422 destroy_workqueue(bitbang
->workqueue
);
426 EXPORT_SYMBOL_GPL(spi_bitbang_start
);
429 * spi_bitbang_stop - stops the task providing spi communication
431 int spi_bitbang_stop(struct spi_bitbang
*bitbang
)
433 unsigned limit
= 500;
435 spin_lock_irq(&bitbang
->lock
);
436 bitbang
->shutdown
= 0;
437 while (!list_empty(&bitbang
->queue
) && limit
--) {
438 spin_unlock_irq(&bitbang
->lock
);
440 dev_dbg(bitbang
->master
->cdev
.dev
, "wait for queue\n");
443 spin_lock_irq(&bitbang
->lock
);
445 spin_unlock_irq(&bitbang
->lock
);
446 if (!list_empty(&bitbang
->queue
)) {
447 dev_err(bitbang
->master
->cdev
.dev
, "queue didn't empty\n");
451 destroy_workqueue(bitbang
->workqueue
);
453 spi_unregister_master(bitbang
->master
);
457 EXPORT_SYMBOL_GPL(spi_bitbang_stop
);
459 MODULE_LICENSE("GPL");
This page took 0.041799 seconds and 6 git commands to generate.