Loading...
1/*
2 * SPI bus via the Blackfin SPORT peripheral
3 *
4 * Enter bugs at http://blackfin.uclinux.org/
5 *
6 * Copyright 2009-2011 Analog Devices Inc.
7 *
8 * Licensed under the GPL-2 or later.
9 */
10
11#include <linux/module.h>
12#include <linux/delay.h>
13#include <linux/device.h>
14#include <linux/gpio.h>
15#include <linux/io.h>
16#include <linux/ioport.h>
17#include <linux/irq.h>
18#include <linux/errno.h>
19#include <linux/interrupt.h>
20#include <linux/platform_device.h>
21#include <linux/spi/spi.h>
22#include <linux/workqueue.h>
23
24#include <asm/portmux.h>
25#include <asm/bfin5xx_spi.h>
26#include <asm/blackfin.h>
27#include <asm/bfin_sport.h>
28#include <asm/cacheflush.h>
29
30#define DRV_NAME "bfin-sport-spi"
31#define DRV_DESC "SPI bus via the Blackfin SPORT"
32
33MODULE_AUTHOR("Cliff Cai");
34MODULE_DESCRIPTION(DRV_DESC);
35MODULE_LICENSE("GPL");
36MODULE_ALIAS("platform:bfin-sport-spi");
37
38enum bfin_sport_spi_state {
39 START_STATE,
40 RUNNING_STATE,
41 DONE_STATE,
42 ERROR_STATE,
43};
44
45struct bfin_sport_spi_master_data;
46
47struct bfin_sport_transfer_ops {
48 void (*write) (struct bfin_sport_spi_master_data *);
49 void (*read) (struct bfin_sport_spi_master_data *);
50 void (*duplex) (struct bfin_sport_spi_master_data *);
51};
52
53struct bfin_sport_spi_master_data {
54 /* Driver model hookup */
55 struct device *dev;
56
57 /* SPI framework hookup */
58 struct spi_master *master;
59
60 /* Regs base of SPI controller */
61 struct sport_register __iomem *regs;
62 int err_irq;
63
64 /* Pin request list */
65 u16 *pin_req;
66
67 /* Driver message queue */
68 struct workqueue_struct *workqueue;
69 struct work_struct pump_messages;
70 spinlock_t lock;
71 struct list_head queue;
72 int busy;
73 bool run;
74
75 /* Message Transfer pump */
76 struct tasklet_struct pump_transfers;
77
78 /* Current message transfer state info */
79 enum bfin_sport_spi_state state;
80 struct spi_message *cur_msg;
81 struct spi_transfer *cur_transfer;
82 struct bfin_sport_spi_slave_data *cur_chip;
83 union {
84 void *tx;
85 u8 *tx8;
86 u16 *tx16;
87 };
88 void *tx_end;
89 union {
90 void *rx;
91 u8 *rx8;
92 u16 *rx16;
93 };
94 void *rx_end;
95
96 int cs_change;
97 struct bfin_sport_transfer_ops *ops;
98};
99
100struct bfin_sport_spi_slave_data {
101 u16 ctl_reg;
102 u16 baud;
103 u16 cs_chg_udelay; /* Some devices require > 255usec delay */
104 u32 cs_gpio;
105 u16 idle_tx_val;
106 struct bfin_sport_transfer_ops *ops;
107};
108
109static void
110bfin_sport_spi_enable(struct bfin_sport_spi_master_data *drv_data)
111{
112 bfin_write_or(&drv_data->regs->tcr1, TSPEN);
113 bfin_write_or(&drv_data->regs->rcr1, TSPEN);
114 SSYNC();
115}
116
117static void
118bfin_sport_spi_disable(struct bfin_sport_spi_master_data *drv_data)
119{
120 bfin_write_and(&drv_data->regs->tcr1, ~TSPEN);
121 bfin_write_and(&drv_data->regs->rcr1, ~TSPEN);
122 SSYNC();
123}
124
125/* Caculate the SPI_BAUD register value based on input HZ */
126static u16
127bfin_sport_hz_to_spi_baud(u32 speed_hz)
128{
129 u_long clk, sclk = get_sclk();
130 int div = (sclk / (2 * speed_hz)) - 1;
131
132 if (div < 0)
133 div = 0;
134
135 clk = sclk / (2 * (div + 1));
136
137 if (clk > speed_hz)
138 div++;
139
140 return div;
141}
142
143/* Chip select operation functions for cs_change flag */
144static void
145bfin_sport_spi_cs_active(struct bfin_sport_spi_slave_data *chip)
146{
147 gpio_direction_output(chip->cs_gpio, 0);
148}
149
150static void
151bfin_sport_spi_cs_deactive(struct bfin_sport_spi_slave_data *chip)
152{
153 gpio_direction_output(chip->cs_gpio, 1);
154 /* Move delay here for consistency */
155 if (chip->cs_chg_udelay)
156 udelay(chip->cs_chg_udelay);
157}
158
159static void
160bfin_sport_spi_stat_poll_complete(struct bfin_sport_spi_master_data *drv_data)
161{
162 unsigned long timeout = jiffies + HZ;
163 while (!(bfin_read(&drv_data->regs->stat) & RXNE)) {
164 if (!time_before(jiffies, timeout))
165 break;
166 }
167}
168
169static void
170bfin_sport_spi_u8_writer(struct bfin_sport_spi_master_data *drv_data)
171{
172 u16 dummy;
173
174 while (drv_data->tx < drv_data->tx_end) {
175 bfin_write(&drv_data->regs->tx16, *drv_data->tx8++);
176 bfin_sport_spi_stat_poll_complete(drv_data);
177 dummy = bfin_read(&drv_data->regs->rx16);
178 }
179}
180
181static void
182bfin_sport_spi_u8_reader(struct bfin_sport_spi_master_data *drv_data)
183{
184 u16 tx_val = drv_data->cur_chip->idle_tx_val;
185
186 while (drv_data->rx < drv_data->rx_end) {
187 bfin_write(&drv_data->regs->tx16, tx_val);
188 bfin_sport_spi_stat_poll_complete(drv_data);
189 *drv_data->rx8++ = bfin_read(&drv_data->regs->rx16);
190 }
191}
192
193static void
194bfin_sport_spi_u8_duplex(struct bfin_sport_spi_master_data *drv_data)
195{
196 while (drv_data->rx < drv_data->rx_end) {
197 bfin_write(&drv_data->regs->tx16, *drv_data->tx8++);
198 bfin_sport_spi_stat_poll_complete(drv_data);
199 *drv_data->rx8++ = bfin_read(&drv_data->regs->rx16);
200 }
201}
202
203static struct bfin_sport_transfer_ops bfin_sport_transfer_ops_u8 = {
204 .write = bfin_sport_spi_u8_writer,
205 .read = bfin_sport_spi_u8_reader,
206 .duplex = bfin_sport_spi_u8_duplex,
207};
208
209static void
210bfin_sport_spi_u16_writer(struct bfin_sport_spi_master_data *drv_data)
211{
212 u16 dummy;
213
214 while (drv_data->tx < drv_data->tx_end) {
215 bfin_write(&drv_data->regs->tx16, *drv_data->tx16++);
216 bfin_sport_spi_stat_poll_complete(drv_data);
217 dummy = bfin_read(&drv_data->regs->rx16);
218 }
219}
220
221static void
222bfin_sport_spi_u16_reader(struct bfin_sport_spi_master_data *drv_data)
223{
224 u16 tx_val = drv_data->cur_chip->idle_tx_val;
225
226 while (drv_data->rx < drv_data->rx_end) {
227 bfin_write(&drv_data->regs->tx16, tx_val);
228 bfin_sport_spi_stat_poll_complete(drv_data);
229 *drv_data->rx16++ = bfin_read(&drv_data->regs->rx16);
230 }
231}
232
233static void
234bfin_sport_spi_u16_duplex(struct bfin_sport_spi_master_data *drv_data)
235{
236 while (drv_data->rx < drv_data->rx_end) {
237 bfin_write(&drv_data->regs->tx16, *drv_data->tx16++);
238 bfin_sport_spi_stat_poll_complete(drv_data);
239 *drv_data->rx16++ = bfin_read(&drv_data->regs->rx16);
240 }
241}
242
243static struct bfin_sport_transfer_ops bfin_sport_transfer_ops_u16 = {
244 .write = bfin_sport_spi_u16_writer,
245 .read = bfin_sport_spi_u16_reader,
246 .duplex = bfin_sport_spi_u16_duplex,
247};
248
249/* stop controller and re-config current chip */
250static void
251bfin_sport_spi_restore_state(struct bfin_sport_spi_master_data *drv_data)
252{
253 struct bfin_sport_spi_slave_data *chip = drv_data->cur_chip;
254
255 bfin_sport_spi_disable(drv_data);
256 dev_dbg(drv_data->dev, "restoring spi ctl state\n");
257
258 bfin_write(&drv_data->regs->tcr1, chip->ctl_reg);
259 bfin_write(&drv_data->regs->tclkdiv, chip->baud);
260 SSYNC();
261
262 bfin_write(&drv_data->regs->rcr1, chip->ctl_reg & ~(ITCLK | ITFS));
263 SSYNC();
264
265 bfin_sport_spi_cs_active(chip);
266}
267
268/* test if there is more transfer to be done */
269static enum bfin_sport_spi_state
270bfin_sport_spi_next_transfer(struct bfin_sport_spi_master_data *drv_data)
271{
272 struct spi_message *msg = drv_data->cur_msg;
273 struct spi_transfer *trans = drv_data->cur_transfer;
274
275 /* Move to next transfer */
276 if (trans->transfer_list.next != &msg->transfers) {
277 drv_data->cur_transfer =
278 list_entry(trans->transfer_list.next,
279 struct spi_transfer, transfer_list);
280 return RUNNING_STATE;
281 }
282
283 return DONE_STATE;
284}
285
286/*
287 * caller already set message->status;
288 * dma and pio irqs are blocked give finished message back
289 */
290static void
291bfin_sport_spi_giveback(struct bfin_sport_spi_master_data *drv_data)
292{
293 struct bfin_sport_spi_slave_data *chip = drv_data->cur_chip;
294 unsigned long flags;
295 struct spi_message *msg;
296
297 spin_lock_irqsave(&drv_data->lock, flags);
298 msg = drv_data->cur_msg;
299 drv_data->state = START_STATE;
300 drv_data->cur_msg = NULL;
301 drv_data->cur_transfer = NULL;
302 drv_data->cur_chip = NULL;
303 queue_work(drv_data->workqueue, &drv_data->pump_messages);
304 spin_unlock_irqrestore(&drv_data->lock, flags);
305
306 if (!drv_data->cs_change)
307 bfin_sport_spi_cs_deactive(chip);
308
309 if (msg->complete)
310 msg->complete(msg->context);
311}
312
313static irqreturn_t
314sport_err_handler(int irq, void *dev_id)
315{
316 struct bfin_sport_spi_master_data *drv_data = dev_id;
317 u16 status;
318
319 dev_dbg(drv_data->dev, "%s enter\n", __func__);
320 status = bfin_read(&drv_data->regs->stat) & (TOVF | TUVF | ROVF | RUVF);
321
322 if (status) {
323 bfin_write(&drv_data->regs->stat, status);
324 SSYNC();
325
326 bfin_sport_spi_disable(drv_data);
327 dev_err(drv_data->dev, "status error:%s%s%s%s\n",
328 status & TOVF ? " TOVF" : "",
329 status & TUVF ? " TUVF" : "",
330 status & ROVF ? " ROVF" : "",
331 status & RUVF ? " RUVF" : "");
332 }
333
334 return IRQ_HANDLED;
335}
336
337static void
338bfin_sport_spi_pump_transfers(unsigned long data)
339{
340 struct bfin_sport_spi_master_data *drv_data = (void *)data;
341 struct spi_message *message = NULL;
342 struct spi_transfer *transfer = NULL;
343 struct spi_transfer *previous = NULL;
344 struct bfin_sport_spi_slave_data *chip = NULL;
345 unsigned int bits_per_word;
346 u32 tranf_success = 1;
347 u32 transfer_speed;
348 u8 full_duplex = 0;
349
350 /* Get current state information */
351 message = drv_data->cur_msg;
352 transfer = drv_data->cur_transfer;
353 chip = drv_data->cur_chip;
354
355 transfer_speed = bfin_sport_hz_to_spi_baud(transfer->speed_hz);
356 bfin_write(&drv_data->regs->tclkdiv, transfer_speed);
357 SSYNC();
358
359 /*
360 * if msg is error or done, report it back using complete() callback
361 */
362
363 /* Handle for abort */
364 if (drv_data->state == ERROR_STATE) {
365 dev_dbg(drv_data->dev, "transfer: we've hit an error\n");
366 message->status = -EIO;
367 bfin_sport_spi_giveback(drv_data);
368 return;
369 }
370
371 /* Handle end of message */
372 if (drv_data->state == DONE_STATE) {
373 dev_dbg(drv_data->dev, "transfer: all done!\n");
374 message->status = 0;
375 bfin_sport_spi_giveback(drv_data);
376 return;
377 }
378
379 /* Delay if requested at end of transfer */
380 if (drv_data->state == RUNNING_STATE) {
381 dev_dbg(drv_data->dev, "transfer: still running ...\n");
382 previous = list_entry(transfer->transfer_list.prev,
383 struct spi_transfer, transfer_list);
384 if (previous->delay_usecs)
385 udelay(previous->delay_usecs);
386 }
387
388 if (transfer->len == 0) {
389 /* Move to next transfer of this msg */
390 drv_data->state = bfin_sport_spi_next_transfer(drv_data);
391 /* Schedule next transfer tasklet */
392 tasklet_schedule(&drv_data->pump_transfers);
393 }
394
395 if (transfer->tx_buf != NULL) {
396 drv_data->tx = (void *)transfer->tx_buf;
397 drv_data->tx_end = drv_data->tx + transfer->len;
398 dev_dbg(drv_data->dev, "tx_buf is %p, tx_end is %p\n",
399 transfer->tx_buf, drv_data->tx_end);
400 } else
401 drv_data->tx = NULL;
402
403 if (transfer->rx_buf != NULL) {
404 full_duplex = transfer->tx_buf != NULL;
405 drv_data->rx = transfer->rx_buf;
406 drv_data->rx_end = drv_data->rx + transfer->len;
407 dev_dbg(drv_data->dev, "rx_buf is %p, rx_end is %p\n",
408 transfer->rx_buf, drv_data->rx_end);
409 } else
410 drv_data->rx = NULL;
411
412 drv_data->cs_change = transfer->cs_change;
413
414 /* Bits per word setup */
415 bits_per_word = transfer->bits_per_word;
416 if (bits_per_word == 16)
417 drv_data->ops = &bfin_sport_transfer_ops_u16;
418 else
419 drv_data->ops = &bfin_sport_transfer_ops_u8;
420 bfin_write(&drv_data->regs->tcr2, bits_per_word - 1);
421 bfin_write(&drv_data->regs->tfsdiv, bits_per_word - 1);
422 bfin_write(&drv_data->regs->rcr2, bits_per_word - 1);
423
424 drv_data->state = RUNNING_STATE;
425
426 if (drv_data->cs_change)
427 bfin_sport_spi_cs_active(chip);
428
429 dev_dbg(drv_data->dev,
430 "now pumping a transfer: width is %d, len is %d\n",
431 bits_per_word, transfer->len);
432
433 /* PIO mode write then read */
434 dev_dbg(drv_data->dev, "doing IO transfer\n");
435
436 bfin_sport_spi_enable(drv_data);
437 if (full_duplex) {
438 /* full duplex mode */
439 BUG_ON((drv_data->tx_end - drv_data->tx) !=
440 (drv_data->rx_end - drv_data->rx));
441 drv_data->ops->duplex(drv_data);
442
443 if (drv_data->tx != drv_data->tx_end)
444 tranf_success = 0;
445 } else if (drv_data->tx != NULL) {
446 /* write only half duplex */
447
448 drv_data->ops->write(drv_data);
449
450 if (drv_data->tx != drv_data->tx_end)
451 tranf_success = 0;
452 } else if (drv_data->rx != NULL) {
453 /* read only half duplex */
454
455 drv_data->ops->read(drv_data);
456 if (drv_data->rx != drv_data->rx_end)
457 tranf_success = 0;
458 }
459 bfin_sport_spi_disable(drv_data);
460
461 if (!tranf_success) {
462 dev_dbg(drv_data->dev, "IO write error!\n");
463 drv_data->state = ERROR_STATE;
464 } else {
465 /* Update total byte transferred */
466 message->actual_length += transfer->len;
467 /* Move to next transfer of this msg */
468 drv_data->state = bfin_sport_spi_next_transfer(drv_data);
469 if (drv_data->cs_change)
470 bfin_sport_spi_cs_deactive(chip);
471 }
472
473 /* Schedule next transfer tasklet */
474 tasklet_schedule(&drv_data->pump_transfers);
475}
476
477/* pop a msg from queue and kick off real transfer */
478static void
479bfin_sport_spi_pump_messages(struct work_struct *work)
480{
481 struct bfin_sport_spi_master_data *drv_data;
482 unsigned long flags;
483 struct spi_message *next_msg;
484
485 drv_data = container_of(work, struct bfin_sport_spi_master_data, pump_messages);
486
487 /* Lock queue and check for queue work */
488 spin_lock_irqsave(&drv_data->lock, flags);
489 if (list_empty(&drv_data->queue) || !drv_data->run) {
490 /* pumper kicked off but no work to do */
491 drv_data->busy = 0;
492 spin_unlock_irqrestore(&drv_data->lock, flags);
493 return;
494 }
495
496 /* Make sure we are not already running a message */
497 if (drv_data->cur_msg) {
498 spin_unlock_irqrestore(&drv_data->lock, flags);
499 return;
500 }
501
502 /* Extract head of queue */
503 next_msg = list_entry(drv_data->queue.next,
504 struct spi_message, queue);
505
506 drv_data->cur_msg = next_msg;
507
508 /* Setup the SSP using the per chip configuration */
509 drv_data->cur_chip = spi_get_ctldata(drv_data->cur_msg->spi);
510
511 list_del_init(&drv_data->cur_msg->queue);
512
513 /* Initialize message state */
514 drv_data->cur_msg->state = START_STATE;
515 drv_data->cur_transfer = list_entry(drv_data->cur_msg->transfers.next,
516 struct spi_transfer, transfer_list);
517 bfin_sport_spi_restore_state(drv_data);
518 dev_dbg(drv_data->dev, "got a message to pump, "
519 "state is set to: baud %d, cs_gpio %i, ctl 0x%x\n",
520 drv_data->cur_chip->baud, drv_data->cur_chip->cs_gpio,
521 drv_data->cur_chip->ctl_reg);
522
523 dev_dbg(drv_data->dev,
524 "the first transfer len is %d\n",
525 drv_data->cur_transfer->len);
526
527 /* Mark as busy and launch transfers */
528 tasklet_schedule(&drv_data->pump_transfers);
529
530 drv_data->busy = 1;
531 spin_unlock_irqrestore(&drv_data->lock, flags);
532}
533
534/*
535 * got a msg to transfer, queue it in drv_data->queue.
536 * And kick off message pumper
537 */
538static int
539bfin_sport_spi_transfer(struct spi_device *spi, struct spi_message *msg)
540{
541 struct bfin_sport_spi_master_data *drv_data = spi_master_get_devdata(spi->master);
542 unsigned long flags;
543
544 spin_lock_irqsave(&drv_data->lock, flags);
545
546 if (!drv_data->run) {
547 spin_unlock_irqrestore(&drv_data->lock, flags);
548 return -ESHUTDOWN;
549 }
550
551 msg->actual_length = 0;
552 msg->status = -EINPROGRESS;
553 msg->state = START_STATE;
554
555 dev_dbg(&spi->dev, "adding an msg in transfer()\n");
556 list_add_tail(&msg->queue, &drv_data->queue);
557
558 if (drv_data->run && !drv_data->busy)
559 queue_work(drv_data->workqueue, &drv_data->pump_messages);
560
561 spin_unlock_irqrestore(&drv_data->lock, flags);
562
563 return 0;
564}
565
566/* Called every time common spi devices change state */
567static int
568bfin_sport_spi_setup(struct spi_device *spi)
569{
570 struct bfin_sport_spi_slave_data *chip, *first = NULL;
571 int ret;
572
573 /* Only alloc (or use chip_info) on first setup */
574 chip = spi_get_ctldata(spi);
575 if (chip == NULL) {
576 struct bfin5xx_spi_chip *chip_info;
577
578 chip = first = kzalloc(sizeof(*chip), GFP_KERNEL);
579 if (!chip)
580 return -ENOMEM;
581
582 /* platform chip_info isn't required */
583 chip_info = spi->controller_data;
584 if (chip_info) {
585 /*
586 * DITFS and TDTYPE are only thing we don't set, but
587 * they probably shouldn't be changed by people.
588 */
589 if (chip_info->ctl_reg || chip_info->enable_dma) {
590 ret = -EINVAL;
591 dev_err(&spi->dev, "don't set ctl_reg/enable_dma fields\n");
592 goto error;
593 }
594 chip->cs_chg_udelay = chip_info->cs_chg_udelay;
595 chip->idle_tx_val = chip_info->idle_tx_val;
596 }
597 }
598
599 /* translate common spi framework into our register
600 * following configure contents are same for tx and rx.
601 */
602
603 if (spi->mode & SPI_CPHA)
604 chip->ctl_reg &= ~TCKFE;
605 else
606 chip->ctl_reg |= TCKFE;
607
608 if (spi->mode & SPI_LSB_FIRST)
609 chip->ctl_reg |= TLSBIT;
610 else
611 chip->ctl_reg &= ~TLSBIT;
612
613 /* Sport in master mode */
614 chip->ctl_reg |= ITCLK | ITFS | TFSR | LATFS | LTFS;
615
616 chip->baud = bfin_sport_hz_to_spi_baud(spi->max_speed_hz);
617
618 chip->cs_gpio = spi->chip_select;
619 ret = gpio_request(chip->cs_gpio, spi->modalias);
620 if (ret)
621 goto error;
622
623 dev_dbg(&spi->dev, "setup spi chip %s, width is %d\n",
624 spi->modalias, spi->bits_per_word);
625 dev_dbg(&spi->dev, "ctl_reg is 0x%x, GPIO is %i\n",
626 chip->ctl_reg, spi->chip_select);
627
628 spi_set_ctldata(spi, chip);
629
630 bfin_sport_spi_cs_deactive(chip);
631
632 return ret;
633
634 error:
635 kfree(first);
636 return ret;
637}
638
639/*
640 * callback for spi framework.
641 * clean driver specific data
642 */
643static void
644bfin_sport_spi_cleanup(struct spi_device *spi)
645{
646 struct bfin_sport_spi_slave_data *chip = spi_get_ctldata(spi);
647
648 if (!chip)
649 return;
650
651 gpio_free(chip->cs_gpio);
652
653 kfree(chip);
654}
655
656static int
657bfin_sport_spi_init_queue(struct bfin_sport_spi_master_data *drv_data)
658{
659 INIT_LIST_HEAD(&drv_data->queue);
660 spin_lock_init(&drv_data->lock);
661
662 drv_data->run = false;
663 drv_data->busy = 0;
664
665 /* init transfer tasklet */
666 tasklet_init(&drv_data->pump_transfers,
667 bfin_sport_spi_pump_transfers, (unsigned long)drv_data);
668
669 /* init messages workqueue */
670 INIT_WORK(&drv_data->pump_messages, bfin_sport_spi_pump_messages);
671 drv_data->workqueue =
672 create_singlethread_workqueue(dev_name(drv_data->master->dev.parent));
673 if (drv_data->workqueue == NULL)
674 return -EBUSY;
675
676 return 0;
677}
678
679static int
680bfin_sport_spi_start_queue(struct bfin_sport_spi_master_data *drv_data)
681{
682 unsigned long flags;
683
684 spin_lock_irqsave(&drv_data->lock, flags);
685
686 if (drv_data->run || drv_data->busy) {
687 spin_unlock_irqrestore(&drv_data->lock, flags);
688 return -EBUSY;
689 }
690
691 drv_data->run = true;
692 drv_data->cur_msg = NULL;
693 drv_data->cur_transfer = NULL;
694 drv_data->cur_chip = NULL;
695 spin_unlock_irqrestore(&drv_data->lock, flags);
696
697 queue_work(drv_data->workqueue, &drv_data->pump_messages);
698
699 return 0;
700}
701
702static inline int
703bfin_sport_spi_stop_queue(struct bfin_sport_spi_master_data *drv_data)
704{
705 unsigned long flags;
706 unsigned limit = 500;
707 int status = 0;
708
709 spin_lock_irqsave(&drv_data->lock, flags);
710
711 /*
712 * This is a bit lame, but is optimized for the common execution path.
713 * A wait_queue on the drv_data->busy could be used, but then the common
714 * execution path (pump_messages) would be required to call wake_up or
715 * friends on every SPI message. Do this instead
716 */
717 drv_data->run = false;
718 while (!list_empty(&drv_data->queue) && drv_data->busy && limit--) {
719 spin_unlock_irqrestore(&drv_data->lock, flags);
720 msleep(10);
721 spin_lock_irqsave(&drv_data->lock, flags);
722 }
723
724 if (!list_empty(&drv_data->queue) || drv_data->busy)
725 status = -EBUSY;
726
727 spin_unlock_irqrestore(&drv_data->lock, flags);
728
729 return status;
730}
731
732static inline int
733bfin_sport_spi_destroy_queue(struct bfin_sport_spi_master_data *drv_data)
734{
735 int status;
736
737 status = bfin_sport_spi_stop_queue(drv_data);
738 if (status)
739 return status;
740
741 destroy_workqueue(drv_data->workqueue);
742
743 return 0;
744}
745
746static int bfin_sport_spi_probe(struct platform_device *pdev)
747{
748 struct device *dev = &pdev->dev;
749 struct bfin5xx_spi_master *platform_info;
750 struct spi_master *master;
751 struct resource *res, *ires;
752 struct bfin_sport_spi_master_data *drv_data;
753 int status;
754
755 platform_info = dev_get_platdata(dev);
756
757 /* Allocate master with space for drv_data */
758 master = spi_alloc_master(dev, sizeof(*master) + 16);
759 if (!master) {
760 dev_err(dev, "cannot alloc spi_master\n");
761 return -ENOMEM;
762 }
763
764 drv_data = spi_master_get_devdata(master);
765 drv_data->master = master;
766 drv_data->dev = dev;
767 drv_data->pin_req = platform_info->pin_req;
768
769 master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_LSB_FIRST;
770 master->bits_per_word_mask = SPI_BPW_MASK(8) | SPI_BPW_MASK(16);
771 master->bus_num = pdev->id;
772 master->num_chipselect = platform_info->num_chipselect;
773 master->cleanup = bfin_sport_spi_cleanup;
774 master->setup = bfin_sport_spi_setup;
775 master->transfer = bfin_sport_spi_transfer;
776
777 /* Find and map our resources */
778 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
779 if (res == NULL) {
780 dev_err(dev, "cannot get IORESOURCE_MEM\n");
781 status = -ENOENT;
782 goto out_error_get_res;
783 }
784
785 drv_data->regs = ioremap(res->start, resource_size(res));
786 if (drv_data->regs == NULL) {
787 dev_err(dev, "cannot map registers\n");
788 status = -ENXIO;
789 goto out_error_ioremap;
790 }
791
792 ires = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
793 if (!ires) {
794 dev_err(dev, "cannot get IORESOURCE_IRQ\n");
795 status = -ENODEV;
796 goto out_error_get_ires;
797 }
798 drv_data->err_irq = ires->start;
799
800 /* Initial and start queue */
801 status = bfin_sport_spi_init_queue(drv_data);
802 if (status) {
803 dev_err(dev, "problem initializing queue\n");
804 goto out_error_queue_alloc;
805 }
806
807 status = bfin_sport_spi_start_queue(drv_data);
808 if (status) {
809 dev_err(dev, "problem starting queue\n");
810 goto out_error_queue_alloc;
811 }
812
813 status = request_irq(drv_data->err_irq, sport_err_handler,
814 0, "sport_spi_err", drv_data);
815 if (status) {
816 dev_err(dev, "unable to request sport err irq\n");
817 goto out_error_irq;
818 }
819
820 status = peripheral_request_list(drv_data->pin_req, DRV_NAME);
821 if (status) {
822 dev_err(dev, "requesting peripherals failed\n");
823 goto out_error_peripheral;
824 }
825
826 /* Register with the SPI framework */
827 platform_set_drvdata(pdev, drv_data);
828 status = spi_register_master(master);
829 if (status) {
830 dev_err(dev, "problem registering spi master\n");
831 goto out_error_master;
832 }
833
834 dev_info(dev, "%s, regs_base@%p\n", DRV_DESC, drv_data->regs);
835 return 0;
836
837 out_error_master:
838 peripheral_free_list(drv_data->pin_req);
839 out_error_peripheral:
840 free_irq(drv_data->err_irq, drv_data);
841 out_error_irq:
842 out_error_queue_alloc:
843 bfin_sport_spi_destroy_queue(drv_data);
844 out_error_get_ires:
845 iounmap(drv_data->regs);
846 out_error_ioremap:
847 out_error_get_res:
848 spi_master_put(master);
849
850 return status;
851}
852
853/* stop hardware and remove the driver */
854static int bfin_sport_spi_remove(struct platform_device *pdev)
855{
856 struct bfin_sport_spi_master_data *drv_data = platform_get_drvdata(pdev);
857 int status = 0;
858
859 if (!drv_data)
860 return 0;
861
862 /* Remove the queue */
863 status = bfin_sport_spi_destroy_queue(drv_data);
864 if (status)
865 return status;
866
867 /* Disable the SSP at the peripheral and SOC level */
868 bfin_sport_spi_disable(drv_data);
869
870 /* Disconnect from the SPI framework */
871 spi_unregister_master(drv_data->master);
872
873 peripheral_free_list(drv_data->pin_req);
874
875 return 0;
876}
877
878#ifdef CONFIG_PM_SLEEP
879static int bfin_sport_spi_suspend(struct device *dev)
880{
881 struct bfin_sport_spi_master_data *drv_data = dev_get_drvdata(dev);
882 int status;
883
884 status = bfin_sport_spi_stop_queue(drv_data);
885 if (status)
886 return status;
887
888 /* stop hardware */
889 bfin_sport_spi_disable(drv_data);
890
891 return status;
892}
893
894static int bfin_sport_spi_resume(struct device *dev)
895{
896 struct bfin_sport_spi_master_data *drv_data = dev_get_drvdata(dev);
897 int status;
898
899 /* Enable the SPI interface */
900 bfin_sport_spi_enable(drv_data);
901
902 /* Start the queue running */
903 status = bfin_sport_spi_start_queue(drv_data);
904 if (status)
905 dev_err(drv_data->dev, "problem resuming queue\n");
906
907 return status;
908}
909
910static SIMPLE_DEV_PM_OPS(bfin_sport_spi_pm_ops, bfin_sport_spi_suspend,
911 bfin_sport_spi_resume);
912
913#define BFIN_SPORT_SPI_PM_OPS (&bfin_sport_spi_pm_ops)
914#else
915#define BFIN_SPORT_SPI_PM_OPS NULL
916#endif
917
918static struct platform_driver bfin_sport_spi_driver = {
919 .driver = {
920 .name = DRV_NAME,
921 .pm = BFIN_SPORT_SPI_PM_OPS,
922 },
923 .probe = bfin_sport_spi_probe,
924 .remove = bfin_sport_spi_remove,
925};
926module_platform_driver(bfin_sport_spi_driver);
1/*
2 * SPI bus via the Blackfin SPORT peripheral
3 *
4 * Enter bugs at http://blackfin.uclinux.org/
5 *
6 * Copyright 2009-2011 Analog Devices Inc.
7 *
8 * Licensed under the GPL-2 or later.
9 */
10
11#include <linux/module.h>
12#include <linux/delay.h>
13#include <linux/device.h>
14#include <linux/gpio.h>
15#include <linux/io.h>
16#include <linux/ioport.h>
17#include <linux/irq.h>
18#include <linux/errno.h>
19#include <linux/interrupt.h>
20#include <linux/platform_device.h>
21#include <linux/spi/spi.h>
22#include <linux/workqueue.h>
23
24#include <asm/portmux.h>
25#include <asm/bfin5xx_spi.h>
26#include <asm/blackfin.h>
27#include <asm/bfin_sport.h>
28#include <asm/cacheflush.h>
29
30#define DRV_NAME "bfin-sport-spi"
31#define DRV_DESC "SPI bus via the Blackfin SPORT"
32
33MODULE_AUTHOR("Cliff Cai");
34MODULE_DESCRIPTION(DRV_DESC);
35MODULE_LICENSE("GPL");
36MODULE_ALIAS("platform:bfin-sport-spi");
37
38enum bfin_sport_spi_state {
39 START_STATE,
40 RUNNING_STATE,
41 DONE_STATE,
42 ERROR_STATE,
43};
44
45struct bfin_sport_spi_master_data;
46
47struct bfin_sport_transfer_ops {
48 void (*write) (struct bfin_sport_spi_master_data *);
49 void (*read) (struct bfin_sport_spi_master_data *);
50 void (*duplex) (struct bfin_sport_spi_master_data *);
51};
52
53struct bfin_sport_spi_master_data {
54 /* Driver model hookup */
55 struct device *dev;
56
57 /* SPI framework hookup */
58 struct spi_master *master;
59
60 /* Regs base of SPI controller */
61 struct sport_register __iomem *regs;
62 int err_irq;
63
64 /* Pin request list */
65 u16 *pin_req;
66
67 struct work_struct pump_messages;
68 spinlock_t lock;
69 struct list_head queue;
70 int busy;
71 bool run;
72
73 /* Message Transfer pump */
74 struct tasklet_struct pump_transfers;
75
76 /* Current message transfer state info */
77 enum bfin_sport_spi_state state;
78 struct spi_message *cur_msg;
79 struct spi_transfer *cur_transfer;
80 struct bfin_sport_spi_slave_data *cur_chip;
81 union {
82 void *tx;
83 u8 *tx8;
84 u16 *tx16;
85 };
86 void *tx_end;
87 union {
88 void *rx;
89 u8 *rx8;
90 u16 *rx16;
91 };
92 void *rx_end;
93
94 int cs_change;
95 struct bfin_sport_transfer_ops *ops;
96};
97
98struct bfin_sport_spi_slave_data {
99 u16 ctl_reg;
100 u16 baud;
101 u16 cs_chg_udelay; /* Some devices require > 255usec delay */
102 u32 cs_gpio;
103 u16 idle_tx_val;
104 struct bfin_sport_transfer_ops *ops;
105};
106
107static void
108bfin_sport_spi_enable(struct bfin_sport_spi_master_data *drv_data)
109{
110 bfin_write_or(&drv_data->regs->tcr1, TSPEN);
111 bfin_write_or(&drv_data->regs->rcr1, TSPEN);
112 SSYNC();
113}
114
115static void
116bfin_sport_spi_disable(struct bfin_sport_spi_master_data *drv_data)
117{
118 bfin_write_and(&drv_data->regs->tcr1, ~TSPEN);
119 bfin_write_and(&drv_data->regs->rcr1, ~TSPEN);
120 SSYNC();
121}
122
123/* Caculate the SPI_BAUD register value based on input HZ */
124static u16
125bfin_sport_hz_to_spi_baud(u32 speed_hz)
126{
127 u_long clk, sclk = get_sclk();
128 int div = (sclk / (2 * speed_hz)) - 1;
129
130 if (div < 0)
131 div = 0;
132
133 clk = sclk / (2 * (div + 1));
134
135 if (clk > speed_hz)
136 div++;
137
138 return div;
139}
140
141/* Chip select operation functions for cs_change flag */
142static void
143bfin_sport_spi_cs_active(struct bfin_sport_spi_slave_data *chip)
144{
145 gpio_direction_output(chip->cs_gpio, 0);
146}
147
148static void
149bfin_sport_spi_cs_deactive(struct bfin_sport_spi_slave_data *chip)
150{
151 gpio_direction_output(chip->cs_gpio, 1);
152 /* Move delay here for consistency */
153 if (chip->cs_chg_udelay)
154 udelay(chip->cs_chg_udelay);
155}
156
157static void
158bfin_sport_spi_stat_poll_complete(struct bfin_sport_spi_master_data *drv_data)
159{
160 unsigned long timeout = jiffies + HZ;
161 while (!(bfin_read(&drv_data->regs->stat) & RXNE)) {
162 if (!time_before(jiffies, timeout))
163 break;
164 }
165}
166
167static void
168bfin_sport_spi_u8_writer(struct bfin_sport_spi_master_data *drv_data)
169{
170 u16 dummy;
171
172 while (drv_data->tx < drv_data->tx_end) {
173 bfin_write(&drv_data->regs->tx16, *drv_data->tx8++);
174 bfin_sport_spi_stat_poll_complete(drv_data);
175 dummy = bfin_read(&drv_data->regs->rx16);
176 }
177}
178
179static void
180bfin_sport_spi_u8_reader(struct bfin_sport_spi_master_data *drv_data)
181{
182 u16 tx_val = drv_data->cur_chip->idle_tx_val;
183
184 while (drv_data->rx < drv_data->rx_end) {
185 bfin_write(&drv_data->regs->tx16, tx_val);
186 bfin_sport_spi_stat_poll_complete(drv_data);
187 *drv_data->rx8++ = bfin_read(&drv_data->regs->rx16);
188 }
189}
190
191static void
192bfin_sport_spi_u8_duplex(struct bfin_sport_spi_master_data *drv_data)
193{
194 while (drv_data->rx < drv_data->rx_end) {
195 bfin_write(&drv_data->regs->tx16, *drv_data->tx8++);
196 bfin_sport_spi_stat_poll_complete(drv_data);
197 *drv_data->rx8++ = bfin_read(&drv_data->regs->rx16);
198 }
199}
200
201static struct bfin_sport_transfer_ops bfin_sport_transfer_ops_u8 = {
202 .write = bfin_sport_spi_u8_writer,
203 .read = bfin_sport_spi_u8_reader,
204 .duplex = bfin_sport_spi_u8_duplex,
205};
206
207static void
208bfin_sport_spi_u16_writer(struct bfin_sport_spi_master_data *drv_data)
209{
210 u16 dummy;
211
212 while (drv_data->tx < drv_data->tx_end) {
213 bfin_write(&drv_data->regs->tx16, *drv_data->tx16++);
214 bfin_sport_spi_stat_poll_complete(drv_data);
215 dummy = bfin_read(&drv_data->regs->rx16);
216 }
217}
218
219static void
220bfin_sport_spi_u16_reader(struct bfin_sport_spi_master_data *drv_data)
221{
222 u16 tx_val = drv_data->cur_chip->idle_tx_val;
223
224 while (drv_data->rx < drv_data->rx_end) {
225 bfin_write(&drv_data->regs->tx16, tx_val);
226 bfin_sport_spi_stat_poll_complete(drv_data);
227 *drv_data->rx16++ = bfin_read(&drv_data->regs->rx16);
228 }
229}
230
231static void
232bfin_sport_spi_u16_duplex(struct bfin_sport_spi_master_data *drv_data)
233{
234 while (drv_data->rx < drv_data->rx_end) {
235 bfin_write(&drv_data->regs->tx16, *drv_data->tx16++);
236 bfin_sport_spi_stat_poll_complete(drv_data);
237 *drv_data->rx16++ = bfin_read(&drv_data->regs->rx16);
238 }
239}
240
241static struct bfin_sport_transfer_ops bfin_sport_transfer_ops_u16 = {
242 .write = bfin_sport_spi_u16_writer,
243 .read = bfin_sport_spi_u16_reader,
244 .duplex = bfin_sport_spi_u16_duplex,
245};
246
247/* stop controller and re-config current chip */
248static void
249bfin_sport_spi_restore_state(struct bfin_sport_spi_master_data *drv_data)
250{
251 struct bfin_sport_spi_slave_data *chip = drv_data->cur_chip;
252
253 bfin_sport_spi_disable(drv_data);
254 dev_dbg(drv_data->dev, "restoring spi ctl state\n");
255
256 bfin_write(&drv_data->regs->tcr1, chip->ctl_reg);
257 bfin_write(&drv_data->regs->tclkdiv, chip->baud);
258 SSYNC();
259
260 bfin_write(&drv_data->regs->rcr1, chip->ctl_reg & ~(ITCLK | ITFS));
261 SSYNC();
262
263 bfin_sport_spi_cs_active(chip);
264}
265
266/* test if there is more transfer to be done */
267static enum bfin_sport_spi_state
268bfin_sport_spi_next_transfer(struct bfin_sport_spi_master_data *drv_data)
269{
270 struct spi_message *msg = drv_data->cur_msg;
271 struct spi_transfer *trans = drv_data->cur_transfer;
272
273 /* Move to next transfer */
274 if (trans->transfer_list.next != &msg->transfers) {
275 drv_data->cur_transfer =
276 list_entry(trans->transfer_list.next,
277 struct spi_transfer, transfer_list);
278 return RUNNING_STATE;
279 }
280
281 return DONE_STATE;
282}
283
284/*
285 * caller already set message->status;
286 * dma and pio irqs are blocked give finished message back
287 */
288static void
289bfin_sport_spi_giveback(struct bfin_sport_spi_master_data *drv_data)
290{
291 struct bfin_sport_spi_slave_data *chip = drv_data->cur_chip;
292 unsigned long flags;
293 struct spi_message *msg;
294
295 spin_lock_irqsave(&drv_data->lock, flags);
296 msg = drv_data->cur_msg;
297 drv_data->state = START_STATE;
298 drv_data->cur_msg = NULL;
299 drv_data->cur_transfer = NULL;
300 drv_data->cur_chip = NULL;
301 schedule_work(&drv_data->pump_messages);
302 spin_unlock_irqrestore(&drv_data->lock, flags);
303
304 if (!drv_data->cs_change)
305 bfin_sport_spi_cs_deactive(chip);
306
307 if (msg->complete)
308 msg->complete(msg->context);
309}
310
311static irqreturn_t
312sport_err_handler(int irq, void *dev_id)
313{
314 struct bfin_sport_spi_master_data *drv_data = dev_id;
315 u16 status;
316
317 dev_dbg(drv_data->dev, "%s enter\n", __func__);
318 status = bfin_read(&drv_data->regs->stat) & (TOVF | TUVF | ROVF | RUVF);
319
320 if (status) {
321 bfin_write(&drv_data->regs->stat, status);
322 SSYNC();
323
324 bfin_sport_spi_disable(drv_data);
325 dev_err(drv_data->dev, "status error:%s%s%s%s\n",
326 status & TOVF ? " TOVF" : "",
327 status & TUVF ? " TUVF" : "",
328 status & ROVF ? " ROVF" : "",
329 status & RUVF ? " RUVF" : "");
330 }
331
332 return IRQ_HANDLED;
333}
334
335static void
336bfin_sport_spi_pump_transfers(unsigned long data)
337{
338 struct bfin_sport_spi_master_data *drv_data = (void *)data;
339 struct spi_message *message = NULL;
340 struct spi_transfer *transfer = NULL;
341 struct spi_transfer *previous = NULL;
342 struct bfin_sport_spi_slave_data *chip = NULL;
343 unsigned int bits_per_word;
344 u32 tranf_success = 1;
345 u32 transfer_speed;
346 u8 full_duplex = 0;
347
348 /* Get current state information */
349 message = drv_data->cur_msg;
350 transfer = drv_data->cur_transfer;
351 chip = drv_data->cur_chip;
352
353 transfer_speed = bfin_sport_hz_to_spi_baud(transfer->speed_hz);
354 bfin_write(&drv_data->regs->tclkdiv, transfer_speed);
355 SSYNC();
356
357 /*
358 * if msg is error or done, report it back using complete() callback
359 */
360
361 /* Handle for abort */
362 if (drv_data->state == ERROR_STATE) {
363 dev_dbg(drv_data->dev, "transfer: we've hit an error\n");
364 message->status = -EIO;
365 bfin_sport_spi_giveback(drv_data);
366 return;
367 }
368
369 /* Handle end of message */
370 if (drv_data->state == DONE_STATE) {
371 dev_dbg(drv_data->dev, "transfer: all done!\n");
372 message->status = 0;
373 bfin_sport_spi_giveback(drv_data);
374 return;
375 }
376
377 /* Delay if requested at end of transfer */
378 if (drv_data->state == RUNNING_STATE) {
379 dev_dbg(drv_data->dev, "transfer: still running ...\n");
380 previous = list_entry(transfer->transfer_list.prev,
381 struct spi_transfer, transfer_list);
382 if (previous->delay_usecs)
383 udelay(previous->delay_usecs);
384 }
385
386 if (transfer->len == 0) {
387 /* Move to next transfer of this msg */
388 drv_data->state = bfin_sport_spi_next_transfer(drv_data);
389 /* Schedule next transfer tasklet */
390 tasklet_schedule(&drv_data->pump_transfers);
391 }
392
393 if (transfer->tx_buf != NULL) {
394 drv_data->tx = (void *)transfer->tx_buf;
395 drv_data->tx_end = drv_data->tx + transfer->len;
396 dev_dbg(drv_data->dev, "tx_buf is %p, tx_end is %p\n",
397 transfer->tx_buf, drv_data->tx_end);
398 } else
399 drv_data->tx = NULL;
400
401 if (transfer->rx_buf != NULL) {
402 full_duplex = transfer->tx_buf != NULL;
403 drv_data->rx = transfer->rx_buf;
404 drv_data->rx_end = drv_data->rx + transfer->len;
405 dev_dbg(drv_data->dev, "rx_buf is %p, rx_end is %p\n",
406 transfer->rx_buf, drv_data->rx_end);
407 } else
408 drv_data->rx = NULL;
409
410 drv_data->cs_change = transfer->cs_change;
411
412 /* Bits per word setup */
413 bits_per_word = transfer->bits_per_word;
414 if (bits_per_word == 16)
415 drv_data->ops = &bfin_sport_transfer_ops_u16;
416 else
417 drv_data->ops = &bfin_sport_transfer_ops_u8;
418 bfin_write(&drv_data->regs->tcr2, bits_per_word - 1);
419 bfin_write(&drv_data->regs->tfsdiv, bits_per_word - 1);
420 bfin_write(&drv_data->regs->rcr2, bits_per_word - 1);
421
422 drv_data->state = RUNNING_STATE;
423
424 if (drv_data->cs_change)
425 bfin_sport_spi_cs_active(chip);
426
427 dev_dbg(drv_data->dev,
428 "now pumping a transfer: width is %d, len is %d\n",
429 bits_per_word, transfer->len);
430
431 /* PIO mode write then read */
432 dev_dbg(drv_data->dev, "doing IO transfer\n");
433
434 bfin_sport_spi_enable(drv_data);
435 if (full_duplex) {
436 /* full duplex mode */
437 BUG_ON((drv_data->tx_end - drv_data->tx) !=
438 (drv_data->rx_end - drv_data->rx));
439 drv_data->ops->duplex(drv_data);
440
441 if (drv_data->tx != drv_data->tx_end)
442 tranf_success = 0;
443 } else if (drv_data->tx != NULL) {
444 /* write only half duplex */
445
446 drv_data->ops->write(drv_data);
447
448 if (drv_data->tx != drv_data->tx_end)
449 tranf_success = 0;
450 } else if (drv_data->rx != NULL) {
451 /* read only half duplex */
452
453 drv_data->ops->read(drv_data);
454 if (drv_data->rx != drv_data->rx_end)
455 tranf_success = 0;
456 }
457 bfin_sport_spi_disable(drv_data);
458
459 if (!tranf_success) {
460 dev_dbg(drv_data->dev, "IO write error!\n");
461 drv_data->state = ERROR_STATE;
462 } else {
463 /* Update total byte transferred */
464 message->actual_length += transfer->len;
465 /* Move to next transfer of this msg */
466 drv_data->state = bfin_sport_spi_next_transfer(drv_data);
467 if (drv_data->cs_change)
468 bfin_sport_spi_cs_deactive(chip);
469 }
470
471 /* Schedule next transfer tasklet */
472 tasklet_schedule(&drv_data->pump_transfers);
473}
474
475/* pop a msg from queue and kick off real transfer */
476static void
477bfin_sport_spi_pump_messages(struct work_struct *work)
478{
479 struct bfin_sport_spi_master_data *drv_data;
480 unsigned long flags;
481 struct spi_message *next_msg;
482
483 drv_data = container_of(work, struct bfin_sport_spi_master_data, pump_messages);
484
485 /* Lock queue and check for queue work */
486 spin_lock_irqsave(&drv_data->lock, flags);
487 if (list_empty(&drv_data->queue) || !drv_data->run) {
488 /* pumper kicked off but no work to do */
489 drv_data->busy = 0;
490 spin_unlock_irqrestore(&drv_data->lock, flags);
491 return;
492 }
493
494 /* Make sure we are not already running a message */
495 if (drv_data->cur_msg) {
496 spin_unlock_irqrestore(&drv_data->lock, flags);
497 return;
498 }
499
500 /* Extract head of queue */
501 next_msg = list_entry(drv_data->queue.next,
502 struct spi_message, queue);
503
504 drv_data->cur_msg = next_msg;
505
506 /* Setup the SSP using the per chip configuration */
507 drv_data->cur_chip = spi_get_ctldata(drv_data->cur_msg->spi);
508
509 list_del_init(&drv_data->cur_msg->queue);
510
511 /* Initialize message state */
512 drv_data->cur_msg->state = START_STATE;
513 drv_data->cur_transfer = list_entry(drv_data->cur_msg->transfers.next,
514 struct spi_transfer, transfer_list);
515 bfin_sport_spi_restore_state(drv_data);
516 dev_dbg(drv_data->dev, "got a message to pump, "
517 "state is set to: baud %d, cs_gpio %i, ctl 0x%x\n",
518 drv_data->cur_chip->baud, drv_data->cur_chip->cs_gpio,
519 drv_data->cur_chip->ctl_reg);
520
521 dev_dbg(drv_data->dev,
522 "the first transfer len is %d\n",
523 drv_data->cur_transfer->len);
524
525 /* Mark as busy and launch transfers */
526 tasklet_schedule(&drv_data->pump_transfers);
527
528 drv_data->busy = 1;
529 spin_unlock_irqrestore(&drv_data->lock, flags);
530}
531
532/*
533 * got a msg to transfer, queue it in drv_data->queue.
534 * And kick off message pumper
535 */
536static int
537bfin_sport_spi_transfer(struct spi_device *spi, struct spi_message *msg)
538{
539 struct bfin_sport_spi_master_data *drv_data = spi_master_get_devdata(spi->master);
540 unsigned long flags;
541
542 spin_lock_irqsave(&drv_data->lock, flags);
543
544 if (!drv_data->run) {
545 spin_unlock_irqrestore(&drv_data->lock, flags);
546 return -ESHUTDOWN;
547 }
548
549 msg->actual_length = 0;
550 msg->status = -EINPROGRESS;
551 msg->state = START_STATE;
552
553 dev_dbg(&spi->dev, "adding an msg in transfer()\n");
554 list_add_tail(&msg->queue, &drv_data->queue);
555
556 if (drv_data->run && !drv_data->busy)
557 schedule_work(&drv_data->pump_messages);
558
559 spin_unlock_irqrestore(&drv_data->lock, flags);
560
561 return 0;
562}
563
564/* Called every time common spi devices change state */
565static int
566bfin_sport_spi_setup(struct spi_device *spi)
567{
568 struct bfin_sport_spi_slave_data *chip, *first = NULL;
569 int ret;
570
571 /* Only alloc (or use chip_info) on first setup */
572 chip = spi_get_ctldata(spi);
573 if (chip == NULL) {
574 struct bfin5xx_spi_chip *chip_info;
575
576 chip = first = kzalloc(sizeof(*chip), GFP_KERNEL);
577 if (!chip)
578 return -ENOMEM;
579
580 /* platform chip_info isn't required */
581 chip_info = spi->controller_data;
582 if (chip_info) {
583 /*
584 * DITFS and TDTYPE are only thing we don't set, but
585 * they probably shouldn't be changed by people.
586 */
587 if (chip_info->ctl_reg || chip_info->enable_dma) {
588 ret = -EINVAL;
589 dev_err(&spi->dev, "don't set ctl_reg/enable_dma fields\n");
590 goto error;
591 }
592 chip->cs_chg_udelay = chip_info->cs_chg_udelay;
593 chip->idle_tx_val = chip_info->idle_tx_val;
594 }
595 }
596
597 /* translate common spi framework into our register
598 * following configure contents are same for tx and rx.
599 */
600
601 if (spi->mode & SPI_CPHA)
602 chip->ctl_reg &= ~TCKFE;
603 else
604 chip->ctl_reg |= TCKFE;
605
606 if (spi->mode & SPI_LSB_FIRST)
607 chip->ctl_reg |= TLSBIT;
608 else
609 chip->ctl_reg &= ~TLSBIT;
610
611 /* Sport in master mode */
612 chip->ctl_reg |= ITCLK | ITFS | TFSR | LATFS | LTFS;
613
614 chip->baud = bfin_sport_hz_to_spi_baud(spi->max_speed_hz);
615
616 chip->cs_gpio = spi->chip_select;
617 ret = gpio_request(chip->cs_gpio, spi->modalias);
618 if (ret)
619 goto error;
620
621 dev_dbg(&spi->dev, "setup spi chip %s, width is %d\n",
622 spi->modalias, spi->bits_per_word);
623 dev_dbg(&spi->dev, "ctl_reg is 0x%x, GPIO is %i\n",
624 chip->ctl_reg, spi->chip_select);
625
626 spi_set_ctldata(spi, chip);
627
628 bfin_sport_spi_cs_deactive(chip);
629
630 return ret;
631
632 error:
633 kfree(first);
634 return ret;
635}
636
637/*
638 * callback for spi framework.
639 * clean driver specific data
640 */
641static void
642bfin_sport_spi_cleanup(struct spi_device *spi)
643{
644 struct bfin_sport_spi_slave_data *chip = spi_get_ctldata(spi);
645
646 if (!chip)
647 return;
648
649 gpio_free(chip->cs_gpio);
650
651 kfree(chip);
652}
653
654static int
655bfin_sport_spi_init_queue(struct bfin_sport_spi_master_data *drv_data)
656{
657 INIT_LIST_HEAD(&drv_data->queue);
658 spin_lock_init(&drv_data->lock);
659
660 drv_data->run = false;
661 drv_data->busy = 0;
662
663 /* init transfer tasklet */
664 tasklet_init(&drv_data->pump_transfers,
665 bfin_sport_spi_pump_transfers, (unsigned long)drv_data);
666
667 INIT_WORK(&drv_data->pump_messages, bfin_sport_spi_pump_messages);
668
669 return 0;
670}
671
672static int
673bfin_sport_spi_start_queue(struct bfin_sport_spi_master_data *drv_data)
674{
675 unsigned long flags;
676
677 spin_lock_irqsave(&drv_data->lock, flags);
678
679 if (drv_data->run || drv_data->busy) {
680 spin_unlock_irqrestore(&drv_data->lock, flags);
681 return -EBUSY;
682 }
683
684 drv_data->run = true;
685 drv_data->cur_msg = NULL;
686 drv_data->cur_transfer = NULL;
687 drv_data->cur_chip = NULL;
688 spin_unlock_irqrestore(&drv_data->lock, flags);
689
690 schedule_work(&drv_data->pump_messages);
691
692 return 0;
693}
694
695static inline int
696bfin_sport_spi_stop_queue(struct bfin_sport_spi_master_data *drv_data)
697{
698 unsigned long flags;
699 unsigned limit = 500;
700 int status = 0;
701
702 spin_lock_irqsave(&drv_data->lock, flags);
703
704 /*
705 * This is a bit lame, but is optimized for the common execution path.
706 * A wait_queue on the drv_data->busy could be used, but then the common
707 * execution path (pump_messages) would be required to call wake_up or
708 * friends on every SPI message. Do this instead
709 */
710 drv_data->run = false;
711 while (!list_empty(&drv_data->queue) && drv_data->busy && limit--) {
712 spin_unlock_irqrestore(&drv_data->lock, flags);
713 msleep(10);
714 spin_lock_irqsave(&drv_data->lock, flags);
715 }
716
717 if (!list_empty(&drv_data->queue) || drv_data->busy)
718 status = -EBUSY;
719
720 spin_unlock_irqrestore(&drv_data->lock, flags);
721
722 return status;
723}
724
725static inline int
726bfin_sport_spi_destroy_queue(struct bfin_sport_spi_master_data *drv_data)
727{
728 int status;
729
730 status = bfin_sport_spi_stop_queue(drv_data);
731 if (status)
732 return status;
733
734 flush_work(&drv_data->pump_messages);
735
736 return 0;
737}
738
739static int bfin_sport_spi_probe(struct platform_device *pdev)
740{
741 struct device *dev = &pdev->dev;
742 struct bfin5xx_spi_master *platform_info;
743 struct spi_master *master;
744 struct resource *res, *ires;
745 struct bfin_sport_spi_master_data *drv_data;
746 int status;
747
748 platform_info = dev_get_platdata(dev);
749
750 /* Allocate master with space for drv_data */
751 master = spi_alloc_master(dev, sizeof(*master) + 16);
752 if (!master) {
753 dev_err(dev, "cannot alloc spi_master\n");
754 return -ENOMEM;
755 }
756
757 drv_data = spi_master_get_devdata(master);
758 drv_data->master = master;
759 drv_data->dev = dev;
760 drv_data->pin_req = platform_info->pin_req;
761
762 master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_LSB_FIRST;
763 master->bits_per_word_mask = SPI_BPW_MASK(8) | SPI_BPW_MASK(16);
764 master->bus_num = pdev->id;
765 master->num_chipselect = platform_info->num_chipselect;
766 master->cleanup = bfin_sport_spi_cleanup;
767 master->setup = bfin_sport_spi_setup;
768 master->transfer = bfin_sport_spi_transfer;
769
770 /* Find and map our resources */
771 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
772 if (res == NULL) {
773 dev_err(dev, "cannot get IORESOURCE_MEM\n");
774 status = -ENOENT;
775 goto out_error_get_res;
776 }
777
778 drv_data->regs = ioremap(res->start, resource_size(res));
779 if (drv_data->regs == NULL) {
780 dev_err(dev, "cannot map registers\n");
781 status = -ENXIO;
782 goto out_error_ioremap;
783 }
784
785 ires = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
786 if (!ires) {
787 dev_err(dev, "cannot get IORESOURCE_IRQ\n");
788 status = -ENODEV;
789 goto out_error_get_ires;
790 }
791 drv_data->err_irq = ires->start;
792
793 /* Initial and start queue */
794 status = bfin_sport_spi_init_queue(drv_data);
795 if (status) {
796 dev_err(dev, "problem initializing queue\n");
797 goto out_error_queue_alloc;
798 }
799
800 status = bfin_sport_spi_start_queue(drv_data);
801 if (status) {
802 dev_err(dev, "problem starting queue\n");
803 goto out_error_queue_alloc;
804 }
805
806 status = request_irq(drv_data->err_irq, sport_err_handler,
807 0, "sport_spi_err", drv_data);
808 if (status) {
809 dev_err(dev, "unable to request sport err irq\n");
810 goto out_error_irq;
811 }
812
813 status = peripheral_request_list(drv_data->pin_req, DRV_NAME);
814 if (status) {
815 dev_err(dev, "requesting peripherals failed\n");
816 goto out_error_peripheral;
817 }
818
819 /* Register with the SPI framework */
820 platform_set_drvdata(pdev, drv_data);
821 status = spi_register_master(master);
822 if (status) {
823 dev_err(dev, "problem registering spi master\n");
824 goto out_error_master;
825 }
826
827 dev_info(dev, "%s, regs_base@%p\n", DRV_DESC, drv_data->regs);
828 return 0;
829
830 out_error_master:
831 peripheral_free_list(drv_data->pin_req);
832 out_error_peripheral:
833 free_irq(drv_data->err_irq, drv_data);
834 out_error_irq:
835 out_error_queue_alloc:
836 bfin_sport_spi_destroy_queue(drv_data);
837 out_error_get_ires:
838 iounmap(drv_data->regs);
839 out_error_ioremap:
840 out_error_get_res:
841 spi_master_put(master);
842
843 return status;
844}
845
846/* stop hardware and remove the driver */
847static int bfin_sport_spi_remove(struct platform_device *pdev)
848{
849 struct bfin_sport_spi_master_data *drv_data = platform_get_drvdata(pdev);
850 int status = 0;
851
852 if (!drv_data)
853 return 0;
854
855 /* Remove the queue */
856 status = bfin_sport_spi_destroy_queue(drv_data);
857 if (status)
858 return status;
859
860 /* Disable the SSP at the peripheral and SOC level */
861 bfin_sport_spi_disable(drv_data);
862
863 /* Disconnect from the SPI framework */
864 spi_unregister_master(drv_data->master);
865
866 peripheral_free_list(drv_data->pin_req);
867
868 return 0;
869}
870
871#ifdef CONFIG_PM_SLEEP
872static int bfin_sport_spi_suspend(struct device *dev)
873{
874 struct bfin_sport_spi_master_data *drv_data = dev_get_drvdata(dev);
875 int status;
876
877 status = bfin_sport_spi_stop_queue(drv_data);
878 if (status)
879 return status;
880
881 /* stop hardware */
882 bfin_sport_spi_disable(drv_data);
883
884 return status;
885}
886
887static int bfin_sport_spi_resume(struct device *dev)
888{
889 struct bfin_sport_spi_master_data *drv_data = dev_get_drvdata(dev);
890 int status;
891
892 /* Enable the SPI interface */
893 bfin_sport_spi_enable(drv_data);
894
895 /* Start the queue running */
896 status = bfin_sport_spi_start_queue(drv_data);
897 if (status)
898 dev_err(drv_data->dev, "problem resuming queue\n");
899
900 return status;
901}
902
903static SIMPLE_DEV_PM_OPS(bfin_sport_spi_pm_ops, bfin_sport_spi_suspend,
904 bfin_sport_spi_resume);
905
906#define BFIN_SPORT_SPI_PM_OPS (&bfin_sport_spi_pm_ops)
907#else
908#define BFIN_SPORT_SPI_PM_OPS NULL
909#endif
910
911static struct platform_driver bfin_sport_spi_driver = {
912 .driver = {
913 .name = DRV_NAME,
914 .pm = BFIN_SPORT_SPI_PM_OPS,
915 },
916 .probe = bfin_sport_spi_probe,
917 .remove = bfin_sport_spi_remove,
918};
919module_platform_driver(bfin_sport_spi_driver);