?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Staging: strip: delete the driver
[linux/fpc-iii.git] / drivers / spi / pxa2xx_spi.c
blob36828358a4d8602a1fdbbc56f5aeb588e3467d1a
1 /*
2 * Copyright (C) 2005 Stephen Street / StreetFire Sound Labs
3 *
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.
8 *
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.
13 *
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., 675 Mass Ave, Cambridge, MA 02139, USA.
17 */
18
19 #include <linux/init.h>
20 #include <linux/module.h>
21 #include <linux/device.h>
22 #include <linux/ioport.h>
23 #include <linux/errno.h>
24 #include <linux/interrupt.h>
25 #include <linux/platform_device.h>
26 #include <linux/dma-mapping.h>
27 #include <linux/spi/spi.h>
28 #include <linux/workqueue.h>
29 #include <linux/delay.h>
30 #include <linux/clk.h>
31 #include <linux/gpio.h>
32 #include <linux/slab.h>
33
34 #include <asm/io.h>
35 #include <asm/irq.h>
36 #include <asm/delay.h>
37
38 #include <mach/dma.h>
39 #include <mach/regs-ssp.h>
40 #include <mach/ssp.h>
41 #include <mach/pxa2xx_spi.h>
42
43 MODULE_AUTHOR("Stephen Street");
44 MODULE_DESCRIPTION("PXA2xx SSP SPI Controller");
45 MODULE_LICENSE("GPL");
46 MODULE_ALIAS("platform:pxa2xx-spi");
47
48 #define MAX_BUSES 3
49
50 #define RX_THRESH_DFLT 8
51 #define TX_THRESH_DFLT 8
52 #define TIMOUT_DFLT 1000
53
54 #define DMA_INT_MASK (DCSR_ENDINTR | DCSR_STARTINTR | DCSR_BUSERR)
55 #define RESET_DMA_CHANNEL (DCSR_NODESC | DMA_INT_MASK)
56 #define IS_DMA_ALIGNED(x) ((((u32)(x)) & 0x07) == 0)
57 #define MAX_DMA_LEN 8191
58 #define DMA_ALIGNMENT 8
59
60 /*
61 * for testing SSCR1 changes that require SSP restart, basically
62 * everything except the service and interrupt enables, the pxa270 developer
63 * manual says only SSCR1_SCFR, SSCR1_SPH, SSCR1_SPO need to be in this
64 * list, but the PXA255 dev man says all bits without really meaning the
65 * service and interrupt enables
66 */
67 #define SSCR1_CHANGE_MASK (SSCR1_TTELP | SSCR1_TTE | SSCR1_SCFR \
68 | SSCR1_ECRA | SSCR1_ECRB | SSCR1_SCLKDIR \
69 | SSCR1_SFRMDIR | SSCR1_RWOT | SSCR1_TRAIL \
70 | SSCR1_IFS | SSCR1_STRF | SSCR1_EFWR \
71 | SSCR1_RFT | SSCR1_TFT | SSCR1_MWDS \
72 | SSCR1_SPH | SSCR1_SPO | SSCR1_LBM)
73
74 #define DEFINE_SSP_REG(reg, off) \
75 static inline u32 read_##reg(void const __iomem *p) \
76 { return __raw_readl(p + (off)); } \
77 \
78 static inline void write_##reg(u32 v, void __iomem *p) \
79 { __raw_writel(v, p + (off)); }
80
81 DEFINE_SSP_REG(SSCR0, 0x00)
82 DEFINE_SSP_REG(SSCR1, 0x04)
83 DEFINE_SSP_REG(SSSR, 0x08)
84 DEFINE_SSP_REG(SSITR, 0x0c)
85 DEFINE_SSP_REG(SSDR, 0x10)
86 DEFINE_SSP_REG(SSTO, 0x28)
87 DEFINE_SSP_REG(SSPSP, 0x2c)
88
89 #define START_STATE ((void*)0)
90 #define RUNNING_STATE ((void*)1)
91 #define DONE_STATE ((void*)2)
92 #define ERROR_STATE ((void*)-1)
93
94 #define QUEUE_RUNNING 0
95 #define QUEUE_STOPPED 1
96
97 struct driver_data {
98 /* Driver model hookup */
99 struct platform_device *pdev;
100
101 /* SSP Info */
102 struct ssp_device *ssp;
103
104 /* SPI framework hookup */
105 enum pxa_ssp_type ssp_type;
106 struct spi_master *master;
107
108 /* PXA hookup */
109 struct pxa2xx_spi_master *master_info;
110
111 /* DMA setup stuff */
112 int rx_channel;
113 int tx_channel;
114 u32 *null_dma_buf;
115
116 /* SSP register addresses */
117 void __iomem *ioaddr;
118 u32 ssdr_physical;
119
120 /* SSP masks*/
121 u32 dma_cr1;
122 u32 int_cr1;
123 u32 clear_sr;
124 u32 mask_sr;
125
126 /* Driver message queue */
127 struct workqueue_struct *workqueue;
128 struct work_struct pump_messages;
129 spinlock_t lock;
130 struct list_head queue;
131 int busy;
132 int run;
133
134 /* Message Transfer pump */
135 struct tasklet_struct pump_transfers;
136
137 /* Current message transfer state info */
138 struct spi_message* cur_msg;
139 struct spi_transfer* cur_transfer;
140 struct chip_data *cur_chip;
141 size_t len;
142 void *tx;
143 void *tx_end;
144 void *rx;
145 void *rx_end;
146 int dma_mapped;
147 dma_addr_t rx_dma;
148 dma_addr_t tx_dma;
149 size_t rx_map_len;
150 size_t tx_map_len;
151 u8 n_bytes;
152 u32 dma_width;
153 int (*write)(struct driver_data *drv_data);
154 int (*read)(struct driver_data *drv_data);
155 irqreturn_t (*transfer_handler)(struct driver_data *drv_data);
156 void (*cs_control)(u32 command);
157 };
158
159 struct chip_data {
160 u32 cr0;
161 u32 cr1;
162 u32 psp;
163 u32 timeout;
164 u8 n_bytes;
165 u32 dma_width;
166 u32 dma_burst_size;
167 u32 threshold;
168 u32 dma_threshold;
169 u8 enable_dma;
170 u8 bits_per_word;
171 u32 speed_hz;
172 int gpio_cs;
173 int gpio_cs_inverted;
174 int (*write)(struct driver_data *drv_data);
175 int (*read)(struct driver_data *drv_data);
176 void (*cs_control)(u32 command);
177 };
178
179 static void pump_messages(struct work_struct *work);
180
181 static void cs_assert(struct driver_data *drv_data)
182 {
183 struct chip_data *chip = drv_data->cur_chip;
184
185 if (chip->cs_control) {
186 chip->cs_control(PXA2XX_CS_ASSERT);
187 return;
188 }
189
190 if (gpio_is_valid(chip->gpio_cs))
191 gpio_set_value(chip->gpio_cs, chip->gpio_cs_inverted);
192 }
193
194 static void cs_deassert(struct driver_data *drv_data)
195 {
196 struct chip_data *chip = drv_data->cur_chip;
197
198 if (chip->cs_control) {
199 chip->cs_control(PXA2XX_CS_DEASSERT);
200 return;
201 }
202
203 if (gpio_is_valid(chip->gpio_cs))
204 gpio_set_value(chip->gpio_cs, !chip->gpio_cs_inverted);
205 }
206
207 static int flush(struct driver_data *drv_data)
208 {
209 unsigned long limit = loops_per_jiffy << 1;
210
211 void __iomem *reg = drv_data->ioaddr;
212
213 do {
214 while (read_SSSR(reg) & SSSR_RNE) {
215 read_SSDR(reg);
216 }
217 } while ((read_SSSR(reg) & SSSR_BSY) && --limit);
218 write_SSSR(SSSR_ROR, reg);
219
220 return limit;
221 }
222
223 static int null_writer(struct driver_data *drv_data)
224 {
225 void __iomem *reg = drv_data->ioaddr;
226 u8 n_bytes = drv_data->n_bytes;
227
228 if (((read_SSSR(reg) & 0x00000f00) == 0x00000f00)
229 || (drv_data->tx == drv_data->tx_end))
230 return 0;
231
232 write_SSDR(0, reg);
233 drv_data->tx += n_bytes;
234
235 return 1;
236 }
237
238 static int null_reader(struct driver_data *drv_data)
239 {
240 void __iomem *reg = drv_data->ioaddr;
241 u8 n_bytes = drv_data->n_bytes;
242
243 while ((read_SSSR(reg) & SSSR_RNE)
244 && (drv_data->rx < drv_data->rx_end)) {
245 read_SSDR(reg);
246 drv_data->rx += n_bytes;
247 }
248
249 return drv_data->rx == drv_data->rx_end;
250 }
251
252 static int u8_writer(struct driver_data *drv_data)
253 {
254 void __iomem *reg = drv_data->ioaddr;
255
256 if (((read_SSSR(reg) & 0x00000f00) == 0x00000f00)
257 || (drv_data->tx == drv_data->tx_end))
258 return 0;
259
260 write_SSDR(*(u8 *)(drv_data->tx), reg);
261 ++drv_data->tx;
262
263 return 1;
264 }
265
266 static int u8_reader(struct driver_data *drv_data)
267 {
268 void __iomem *reg = drv_data->ioaddr;
269
270 while ((read_SSSR(reg) & SSSR_RNE)
271 && (drv_data->rx < drv_data->rx_end)) {
272 *(u8 *)(drv_data->rx) = read_SSDR(reg);
273 ++drv_data->rx;
274 }
275
276 return drv_data->rx == drv_data->rx_end;
277 }
278
279 static int u16_writer(struct driver_data *drv_data)
280 {
281 void __iomem *reg = drv_data->ioaddr;
282
283 if (((read_SSSR(reg) & 0x00000f00) == 0x00000f00)
284 || (drv_data->tx == drv_data->tx_end))
285 return 0;
286
287 write_SSDR(*(u16 *)(drv_data->tx), reg);
288 drv_data->tx += 2;
289
290 return 1;
291 }
292
293 static int u16_reader(struct driver_data *drv_data)
294 {
295 void __iomem *reg = drv_data->ioaddr;
296
297 while ((read_SSSR(reg) & SSSR_RNE)
298 && (drv_data->rx < drv_data->rx_end)) {
299 *(u16 *)(drv_data->rx) = read_SSDR(reg);
300 drv_data->rx += 2;
301 }
302
303 return drv_data->rx == drv_data->rx_end;
304 }
305
306 static int u32_writer(struct driver_data *drv_data)
307 {
308 void __iomem *reg = drv_data->ioaddr;
309
310 if (((read_SSSR(reg) & 0x00000f00) == 0x00000f00)
311 || (drv_data->tx == drv_data->tx_end))
312 return 0;
313
314 write_SSDR(*(u32 *)(drv_data->tx), reg);
315 drv_data->tx += 4;
316
317 return 1;
318 }
319
320 static int u32_reader(struct driver_data *drv_data)
321 {
322 void __iomem *reg = drv_data->ioaddr;
323
324 while ((read_SSSR(reg) & SSSR_RNE)
325 && (drv_data->rx < drv_data->rx_end)) {
326 *(u32 *)(drv_data->rx) = read_SSDR(reg);
327 drv_data->rx += 4;
328 }
329
330 return drv_data->rx == drv_data->rx_end;
331 }
332
333 static void *next_transfer(struct driver_data *drv_data)
334 {
335 struct spi_message *msg = drv_data->cur_msg;
336 struct spi_transfer *trans = drv_data->cur_transfer;
337
338 /* Move to next transfer */
339 if (trans->transfer_list.next != &msg->transfers) {
340 drv_data->cur_transfer =
341 list_entry(trans->transfer_list.next,
342 struct spi_transfer,
343 transfer_list);
344 return RUNNING_STATE;
345 } else
346 return DONE_STATE;
347 }
348
349 static int map_dma_buffers(struct driver_data *drv_data)
350 {
351 struct spi_message *msg = drv_data->cur_msg;
352 struct device *dev = &msg->spi->dev;
353
354 if (!drv_data->cur_chip->enable_dma)
355 return 0;
356
357 if (msg->is_dma_mapped)
358 return drv_data->rx_dma && drv_data->tx_dma;
359
360 if (!IS_DMA_ALIGNED(drv_data->rx) || !IS_DMA_ALIGNED(drv_data->tx))
361 return 0;
362
363 /* Modify setup if rx buffer is null */
364 if (drv_data->rx == NULL) {
365 *drv_data->null_dma_buf = 0;
366 drv_data->rx = drv_data->null_dma_buf;
367 drv_data->rx_map_len = 4;
368 } else
369 drv_data->rx_map_len = drv_data->len;
370
371
372 /* Modify setup if tx buffer is null */
373 if (drv_data->tx == NULL) {
374 *drv_data->null_dma_buf = 0;
375 drv_data->tx = drv_data->null_dma_buf;
376 drv_data->tx_map_len = 4;
377 } else
378 drv_data->tx_map_len = drv_data->len;
379
380 /* Stream map the tx buffer. Always do DMA_TO_DEVICE first
381 * so we flush the cache *before* invalidating it, in case
382 * the tx and rx buffers overlap.
383 */
384 drv_data->tx_dma = dma_map_single(dev, drv_data->tx,
385 drv_data->tx_map_len, DMA_TO_DEVICE);
386 if (dma_mapping_error(dev, drv_data->tx_dma))
387 return 0;
388
389 /* Stream map the rx buffer */
390 drv_data->rx_dma = dma_map_single(dev, drv_data->rx,
391 drv_data->rx_map_len, DMA_FROM_DEVICE);
392 if (dma_mapping_error(dev, drv_data->rx_dma)) {
393 dma_unmap_single(dev, drv_data->tx_dma,
394 drv_data->tx_map_len, DMA_TO_DEVICE);
395 return 0;
396 }
397
398 return 1;
399 }
400
401 static void unmap_dma_buffers(struct driver_data *drv_data)
402 {
403 struct device *dev;
404
405 if (!drv_data->dma_mapped)
406 return;
407
408 if (!drv_data->cur_msg->is_dma_mapped) {
409 dev = &drv_data->cur_msg->spi->dev;
410 dma_unmap_single(dev, drv_data->rx_dma,
411 drv_data->rx_map_len, DMA_FROM_DEVICE);
412 dma_unmap_single(dev, drv_data->tx_dma,
413 drv_data->tx_map_len, DMA_TO_DEVICE);
414 }
415
416 drv_data->dma_mapped = 0;
417 }
418
419 /* caller already set message->status; dma and pio irqs are blocked */
420 static void giveback(struct driver_data *drv_data)
421 {
422 struct spi_transfer* last_transfer;
423 unsigned long flags;
424 struct spi_message *msg;
425
426 spin_lock_irqsave(&drv_data->lock, flags);
427 msg = drv_data->cur_msg;
428 drv_data->cur_msg = NULL;
429 drv_data->cur_transfer = NULL;
430 queue_work(drv_data->workqueue, &drv_data->pump_messages);
431 spin_unlock_irqrestore(&drv_data->lock, flags);
432
433 last_transfer = list_entry(msg->transfers.prev,
434 struct spi_transfer,
435 transfer_list);
436
437 /* Delay if requested before any change in chip select */
438 if (last_transfer->delay_usecs)
439 udelay(last_transfer->delay_usecs);
440
441 /* Drop chip select UNLESS cs_change is true or we are returning
442 * a message with an error, or next message is for another chip
443 */
444 if (!last_transfer->cs_change)
445 cs_deassert(drv_data);
446 else {
447 struct spi_message *next_msg;
448
449 /* Holding of cs was hinted, but we need to make sure
450 * the next message is for the same chip. Don't waste
451 * time with the following tests unless this was hinted.
452 *
453 * We cannot postpone this until pump_messages, because
454 * after calling msg->complete (below) the driver that
455 * sent the current message could be unloaded, which
456 * could invalidate the cs_control() callback...
457 */
458
459 /* get a pointer to the next message, if any */
460 spin_lock_irqsave(&drv_data->lock, flags);
461 if (list_empty(&drv_data->queue))
462 next_msg = NULL;
463 else
464 next_msg = list_entry(drv_data->queue.next,
465 struct spi_message, queue);
466 spin_unlock_irqrestore(&drv_data->lock, flags);
467
468 /* see if the next and current messages point
469 * to the same chip
470 */
471 if (next_msg && next_msg->spi != msg->spi)
472 next_msg = NULL;
473 if (!next_msg || msg->state == ERROR_STATE)
474 cs_deassert(drv_data);
475 }
476
477 msg->state = NULL;
478 if (msg->complete)
479 msg->complete(msg->context);
480
481 drv_data->cur_chip = NULL;
482 }
483
484 static int wait_ssp_rx_stall(void const __iomem *ioaddr)
485 {
486 unsigned long limit = loops_per_jiffy << 1;
487
488 while ((read_SSSR(ioaddr) & SSSR_BSY) && --limit)
489 cpu_relax();
490
491 return limit;
492 }
493
494 static int wait_dma_channel_stop(int channel)
495 {
496 unsigned long limit = loops_per_jiffy << 1;
497
498 while (!(DCSR(channel) & DCSR_STOPSTATE) && --limit)
499 cpu_relax();
500
501 return limit;
502 }
503
504 static void dma_error_stop(struct driver_data *drv_data, const char *msg)
505 {
506 void __iomem *reg = drv_data->ioaddr;
507
508 /* Stop and reset */
509 DCSR(drv_data->rx_channel) = RESET_DMA_CHANNEL;
510 DCSR(drv_data->tx_channel) = RESET_DMA_CHANNEL;
511 write_SSSR(drv_data->clear_sr, reg);
512 write_SSCR1(read_SSCR1(reg) & ~drv_data->dma_cr1, reg);
513 if (drv_data->ssp_type != PXA25x_SSP)
514 write_SSTO(0, reg);
515 flush(drv_data);
516 write_SSCR0(read_SSCR0(reg) & ~SSCR0_SSE, reg);
517
518 unmap_dma_buffers(drv_data);
519
520 dev_err(&drv_data->pdev->dev, "%s\n", msg);
521
522 drv_data->cur_msg->state = ERROR_STATE;
523 tasklet_schedule(&drv_data->pump_transfers);
524 }
525
526 static void dma_transfer_complete(struct driver_data *drv_data)
527 {
528 void __iomem *reg = drv_data->ioaddr;
529 struct spi_message *msg = drv_data->cur_msg;
530
531 /* Clear and disable interrupts on SSP and DMA channels*/
532 write_SSCR1(read_SSCR1(reg) & ~drv_data->dma_cr1, reg);
533 write_SSSR(drv_data->clear_sr, reg);
534 DCSR(drv_data->tx_channel) = RESET_DMA_CHANNEL;
535 DCSR(drv_data->rx_channel) = RESET_DMA_CHANNEL;
536
537 if (wait_dma_channel_stop(drv_data->rx_channel) == 0)
538 dev_err(&drv_data->pdev->dev,
539 "dma_handler: dma rx channel stop failed\n");
540
541 if (wait_ssp_rx_stall(drv_data->ioaddr) == 0)
542 dev_err(&drv_data->pdev->dev,
543 "dma_transfer: ssp rx stall failed\n");
544
545 unmap_dma_buffers(drv_data);
546
547 /* update the buffer pointer for the amount completed in dma */
548 drv_data->rx += drv_data->len -
549 (DCMD(drv_data->rx_channel) & DCMD_LENGTH);
550
551 /* read trailing data from fifo, it does not matter how many
552 * bytes are in the fifo just read until buffer is full
553 * or fifo is empty, which ever occurs first */
554 drv_data->read(drv_data);
555
556 /* return count of what was actually read */
557 msg->actual_length += drv_data->len -
558 (drv_data->rx_end - drv_data->rx);
559
560 /* Transfer delays and chip select release are
561 * handled in pump_transfers or giveback
562 */
563
564 /* Move to next transfer */
565 msg->state = next_transfer(drv_data);
566
567 /* Schedule transfer tasklet */
568 tasklet_schedule(&drv_data->pump_transfers);
569 }
570
571 static void dma_handler(int channel, void *data)
572 {
573 struct driver_data *drv_data = data;
574 u32 irq_status = DCSR(channel) & DMA_INT_MASK;
575
576 if (irq_status & DCSR_BUSERR) {
577
578 if (channel == drv_data->tx_channel)
579 dma_error_stop(drv_data,
580 "dma_handler: "
581 "bad bus address on tx channel");
582 else
583 dma_error_stop(drv_data,
584 "dma_handler: "
585 "bad bus address on rx channel");
586 return;
587 }
588
589 /* PXA255x_SSP has no timeout interrupt, wait for tailing bytes */
590 if ((channel == drv_data->tx_channel)
591 && (irq_status & DCSR_ENDINTR)
592 && (drv_data->ssp_type == PXA25x_SSP)) {
593
594 /* Wait for rx to stall */
595 if (wait_ssp_rx_stall(drv_data->ioaddr) == 0)
596 dev_err(&drv_data->pdev->dev,
597 "dma_handler: ssp rx stall failed\n");
598
599 /* finish this transfer, start the next */
600 dma_transfer_complete(drv_data);
601 }
602 }
603
604 static irqreturn_t dma_transfer(struct driver_data *drv_data)
605 {
606 u32 irq_status;
607 void __iomem *reg = drv_data->ioaddr;
608
609 irq_status = read_SSSR(reg) & drv_data->mask_sr;
610 if (irq_status & SSSR_ROR) {
611 dma_error_stop(drv_data, "dma_transfer: fifo overrun");
612 return IRQ_HANDLED;
613 }
614
615 /* Check for false positive timeout */
616 if ((irq_status & SSSR_TINT)
617 && (DCSR(drv_data->tx_channel) & DCSR_RUN)) {
618 write_SSSR(SSSR_TINT, reg);
619 return IRQ_HANDLED;
620 }
621
622 if (irq_status & SSSR_TINT || drv_data->rx == drv_data->rx_end) {
623
624 /* Clear and disable timeout interrupt, do the rest in
625 * dma_transfer_complete */
626 if (drv_data->ssp_type != PXA25x_SSP)
627 write_SSTO(0, reg);
628
629 /* finish this transfer, start the next */
630 dma_transfer_complete(drv_data);
631
632 return IRQ_HANDLED;
633 }
634
635 /* Opps problem detected */
636 return IRQ_NONE;
637 }
638
639 static void int_error_stop(struct driver_data *drv_data, const char* msg)
640 {
641 void __iomem *reg = drv_data->ioaddr;
642
643 /* Stop and reset SSP */
644 write_SSSR(drv_data->clear_sr, reg);
645 write_SSCR1(read_SSCR1(reg) & ~drv_data->int_cr1, reg);
646 if (drv_data->ssp_type != PXA25x_SSP)
647 write_SSTO(0, reg);
648 flush(drv_data);
649 write_SSCR0(read_SSCR0(reg) & ~SSCR0_SSE, reg);
650
651 dev_err(&drv_data->pdev->dev, "%s\n", msg);
652
653 drv_data->cur_msg->state = ERROR_STATE;
654 tasklet_schedule(&drv_data->pump_transfers);
655 }
656
657 static void int_transfer_complete(struct driver_data *drv_data)
658 {
659 void __iomem *reg = drv_data->ioaddr;
660
661 /* Stop SSP */
662 write_SSSR(drv_data->clear_sr, reg);
663 write_SSCR1(read_SSCR1(reg) & ~drv_data->int_cr1, reg);
664 if (drv_data->ssp_type != PXA25x_SSP)
665 write_SSTO(0, reg);
666
667 /* Update total byte transfered return count actual bytes read */
668 drv_data->cur_msg->actual_length += drv_data->len -
669 (drv_data->rx_end - drv_data->rx);
670
671 /* Transfer delays and chip select release are
672 * handled in pump_transfers or giveback
673 */
674
675 /* Move to next transfer */
676 drv_data->cur_msg->state = next_transfer(drv_data);
677
678 /* Schedule transfer tasklet */
679 tasklet_schedule(&drv_data->pump_transfers);
680 }
681
682 static irqreturn_t interrupt_transfer(struct driver_data *drv_data)
683 {
684 void __iomem *reg = drv_data->ioaddr;
685
686 u32 irq_mask = (read_SSCR1(reg) & SSCR1_TIE) ?
687 drv_data->mask_sr : drv_data->mask_sr & ~SSSR_TFS;
688
689 u32 irq_status = read_SSSR(reg) & irq_mask;
690
691 if (irq_status & SSSR_ROR) {
692 int_error_stop(drv_data, "interrupt_transfer: fifo overrun");
693 return IRQ_HANDLED;
694 }
695
696 if (irq_status & SSSR_TINT) {
697 write_SSSR(SSSR_TINT, reg);
698 if (drv_data->read(drv_data)) {
699 int_transfer_complete(drv_data);
700 return IRQ_HANDLED;
701 }
702 }
703
704 /* Drain rx fifo, Fill tx fifo and prevent overruns */
705 do {
706 if (drv_data->read(drv_data)) {
707 int_transfer_complete(drv_data);
708 return IRQ_HANDLED;
709 }
710 } while (drv_data->write(drv_data));
711
712 if (drv_data->read(drv_data)) {
713 int_transfer_complete(drv_data);
714 return IRQ_HANDLED;
715 }
716
717 if (drv_data->tx == drv_data->tx_end) {
718 write_SSCR1(read_SSCR1(reg) & ~SSCR1_TIE, reg);
719 /* PXA25x_SSP has no timeout, read trailing bytes */
720 if (drv_data->ssp_type == PXA25x_SSP) {
721 if (!wait_ssp_rx_stall(reg))
722 {
723 int_error_stop(drv_data, "interrupt_transfer: "
724 "rx stall failed");
725 return IRQ_HANDLED;
726 }
727 if (!drv_data->read(drv_data))
728 {
729 int_error_stop(drv_data,
730 "interrupt_transfer: "
731 "trailing byte read failed");
732 return IRQ_HANDLED;
733 }
734 int_transfer_complete(drv_data);
735 }
736 }
737
738 /* We did something */
739 return IRQ_HANDLED;
740 }
741
742 static irqreturn_t ssp_int(int irq, void *dev_id)
743 {
744 struct driver_data *drv_data = dev_id;
745 void __iomem *reg = drv_data->ioaddr;
746
747 if (!drv_data->cur_msg) {
748
749 write_SSCR0(read_SSCR0(reg) & ~SSCR0_SSE, reg);
750 write_SSCR1(read_SSCR1(reg) & ~drv_data->int_cr1, reg);
751 if (drv_data->ssp_type != PXA25x_SSP)
752 write_SSTO(0, reg);
753 write_SSSR(drv_data->clear_sr, reg);
754
755 dev_err(&drv_data->pdev->dev, "bad message state "
756 "in interrupt handler\n");
757
758 /* Never fail */
759 return IRQ_HANDLED;
760 }
761
762 return drv_data->transfer_handler(drv_data);
763 }
764
765 static int set_dma_burst_and_threshold(struct chip_data *chip,
766 struct spi_device *spi,
767 u8 bits_per_word, u32 *burst_code,
768 u32 *threshold)
769 {
770 struct pxa2xx_spi_chip *chip_info =
771 (struct pxa2xx_spi_chip *)spi->controller_data;
772 int bytes_per_word;
773 int burst_bytes;
774 int thresh_words;
775 int req_burst_size;
776 int retval = 0;
777
778 /* Set the threshold (in registers) to equal the same amount of data
779 * as represented by burst size (in bytes). The computation below
780 * is (burst_size rounded up to nearest 8 byte, word or long word)
781 * divided by (bytes/register); the tx threshold is the inverse of
782 * the rx, so that there will always be enough data in the rx fifo
783 * to satisfy a burst, and there will always be enough space in the
784 * tx fifo to accept a burst (a tx burst will overwrite the fifo if
785 * there is not enough space), there must always remain enough empty
786 * space in the rx fifo for any data loaded to the tx fifo.
787 * Whenever burst_size (in bytes) equals bits/word, the fifo threshold
788 * will be 8, or half the fifo;
789 * The threshold can only be set to 2, 4 or 8, but not 16, because
790 * to burst 16 to the tx fifo, the fifo would have to be empty;
791 * however, the minimum fifo trigger level is 1, and the tx will
792 * request service when the fifo is at this level, with only 15 spaces.
793 */
794
795 /* find bytes/word */
796 if (bits_per_word <= 8)
797 bytes_per_word = 1;
798 else if (bits_per_word <= 16)
799 bytes_per_word = 2;
800 else
801 bytes_per_word = 4;
802
803 /* use struct pxa2xx_spi_chip->dma_burst_size if available */
804 if (chip_info)
805 req_burst_size = chip_info->dma_burst_size;
806 else {
807 switch (chip->dma_burst_size) {
808 default:
809 /* if the default burst size is not set,
810 * do it now */
811 chip->dma_burst_size = DCMD_BURST8;
812 case DCMD_BURST8:
813 req_burst_size = 8;
814 break;
815 case DCMD_BURST16:
816 req_burst_size = 16;
817 break;
818 case DCMD_BURST32:
819 req_burst_size = 32;
820 break;
821 }
822 }
823 if (req_burst_size <= 8) {
824 *burst_code = DCMD_BURST8;
825 burst_bytes = 8;
826 } else if (req_burst_size <= 16) {
827 if (bytes_per_word == 1) {
828 /* don't burst more than 1/2 the fifo */
829 *burst_code = DCMD_BURST8;
830 burst_bytes = 8;
831 retval = 1;
832 } else {
833 *burst_code = DCMD_BURST16;
834 burst_bytes = 16;
835 }
836 } else {
837 if (bytes_per_word == 1) {
838 /* don't burst more than 1/2 the fifo */
839 *burst_code = DCMD_BURST8;
840 burst_bytes = 8;
841 retval = 1;
842 } else if (bytes_per_word == 2) {
843 /* don't burst more than 1/2 the fifo */
844 *burst_code = DCMD_BURST16;
845 burst_bytes = 16;
846 retval = 1;
847 } else {
848 *burst_code = DCMD_BURST32;
849 burst_bytes = 32;
850 }
851 }
852
853 thresh_words = burst_bytes / bytes_per_word;
854
855 /* thresh_words will be between 2 and 8 */
856 *threshold = (SSCR1_RxTresh(thresh_words) & SSCR1_RFT)
857 | (SSCR1_TxTresh(16-thresh_words) & SSCR1_TFT);
858
859 return retval;
860 }
861
862 static unsigned int ssp_get_clk_div(struct ssp_device *ssp, int rate)
863 {
864 unsigned long ssp_clk = clk_get_rate(ssp->clk);
865
866 if (ssp->type == PXA25x_SSP)
867 return ((ssp_clk / (2 * rate) - 1) & 0xff) << 8;
868 else
869 return ((ssp_clk / rate - 1) & 0xfff) << 8;
870 }
871
872 static void pump_transfers(unsigned long data)
873 {
874 struct driver_data *drv_data = (struct driver_data *)data;
875 struct spi_message *message = NULL;
876 struct spi_transfer *transfer = NULL;
877 struct spi_transfer *previous = NULL;
878 struct chip_data *chip = NULL;
879 struct ssp_device *ssp = drv_data->ssp;
880 void __iomem *reg = drv_data->ioaddr;
881 u32 clk_div = 0;
882 u8 bits = 0;
883 u32 speed = 0;
884 u32 cr0;
885 u32 cr1;
886 u32 dma_thresh = drv_data->cur_chip->dma_threshold;
887 u32 dma_burst = drv_data->cur_chip->dma_burst_size;
888
889 /* Get current state information */
890 message = drv_data->cur_msg;
891 transfer = drv_data->cur_transfer;
892 chip = drv_data->cur_chip;
893
894 /* Handle for abort */
895 if (message->state == ERROR_STATE) {
896 message->status = -EIO;
897 giveback(drv_data);
898 return;
899 }
900
901 /* Handle end of message */
902 if (message->state == DONE_STATE) {
903 message->status = 0;
904 giveback(drv_data);
905 return;
906 }
907
908 /* Delay if requested at end of transfer before CS change */
909 if (message->state == RUNNING_STATE) {
910 previous = list_entry(transfer->transfer_list.prev,
911 struct spi_transfer,
912 transfer_list);
913 if (previous->delay_usecs)
914 udelay(previous->delay_usecs);
915
916 /* Drop chip select only if cs_change is requested */
917 if (previous->cs_change)
918 cs_deassert(drv_data);
919 }
920
921 /* Check for transfers that need multiple DMA segments */
922 if (transfer->len > MAX_DMA_LEN && chip->enable_dma) {
923
924 /* reject already-mapped transfers; PIO won't always work */
925 if (message->is_dma_mapped
926 || transfer->rx_dma || transfer->tx_dma) {
927 dev_err(&drv_data->pdev->dev,
928 "pump_transfers: mapped transfer length "
929 "of %u is greater than %d\n",
930 transfer->len, MAX_DMA_LEN);
931 message->status = -EINVAL;
932 giveback(drv_data);
933 return;
934 }
935
936 /* warn ... we force this to PIO mode */
937 if (printk_ratelimit())
938 dev_warn(&message->spi->dev, "pump_transfers: "
939 "DMA disabled for transfer length %ld "
940 "greater than %d\n",
941 (long)drv_data->len, MAX_DMA_LEN);
942 }
943
944 /* Setup the transfer state based on the type of transfer */
945 if (flush(drv_data) == 0) {
946 dev_err(&drv_data->pdev->dev, "pump_transfers: flush failed\n");
947 message->status = -EIO;
948 giveback(drv_data);
949 return;
950 }
951 drv_data->n_bytes = chip->n_bytes;
952 drv_data->dma_width = chip->dma_width;
953 drv_data->tx = (void *)transfer->tx_buf;
954 drv_data->tx_end = drv_data->tx + transfer->len;
955 drv_data->rx = transfer->rx_buf;
956 drv_data->rx_end = drv_data->rx + transfer->len;
957 drv_data->rx_dma = transfer->rx_dma;
958 drv_data->tx_dma = transfer->tx_dma;
959 drv_data->len = transfer->len & DCMD_LENGTH;
960 drv_data->write = drv_data->tx ? chip->write : null_writer;
961 drv_data->read = drv_data->rx ? chip->read : null_reader;
962
963 /* Change speed and bit per word on a per transfer */
964 cr0 = chip->cr0;
965 if (transfer->speed_hz || transfer->bits_per_word) {
966
967 bits = chip->bits_per_word;
968 speed = chip->speed_hz;
969
970 if (transfer->speed_hz)
971 speed = transfer->speed_hz;
972
973 if (transfer->bits_per_word)
974 bits = transfer->bits_per_word;
975
976 clk_div = ssp_get_clk_div(ssp, speed);
977
978 if (bits <= 8) {
979 drv_data->n_bytes = 1;
980 drv_data->dma_width = DCMD_WIDTH1;
981 drv_data->read = drv_data->read != null_reader ?
982 u8_reader : null_reader;
983 drv_data->write = drv_data->write != null_writer ?
984 u8_writer : null_writer;
985 } else if (bits <= 16) {
986 drv_data->n_bytes = 2;
987 drv_data->dma_width = DCMD_WIDTH2;
988 drv_data->read = drv_data->read != null_reader ?
989 u16_reader : null_reader;
990 drv_data->write = drv_data->write != null_writer ?
991 u16_writer : null_writer;
992 } else if (bits <= 32) {
993 drv_data->n_bytes = 4;
994 drv_data->dma_width = DCMD_WIDTH4;
995 drv_data->read = drv_data->read != null_reader ?
996 u32_reader : null_reader;
997 drv_data->write = drv_data->write != null_writer ?
998 u32_writer : null_writer;
999 }
1000 /* if bits/word is changed in dma mode, then must check the
1001 * thresholds and burst also */
1002 if (chip->enable_dma) {
1003 if (set_dma_burst_and_threshold(chip, message->spi,
1004 bits, &dma_burst,
1005 &dma_thresh))
1006 if (printk_ratelimit())
1007 dev_warn(&message->spi->dev,
1008 "pump_transfers: "
1009 "DMA burst size reduced to "
1010 "match bits_per_word\n");
1011 }
1012
1013 cr0 = clk_div
1014 | SSCR0_Motorola
1015 | SSCR0_DataSize(bits > 16 ? bits - 16 : bits)
1016 | SSCR0_SSE
1017 | (bits > 16 ? SSCR0_EDSS : 0);
1018 }
1019
1020 message->state = RUNNING_STATE;
1021
1022 /* Try to map dma buffer and do a dma transfer if successful, but
1023 * only if the length is non-zero and less than MAX_DMA_LEN.
1024 *
1025 * Zero-length non-descriptor DMA is illegal on PXA2xx; force use
1026 * of PIO instead. Care is needed above because the transfer may
1027 * have have been passed with buffers that are already dma mapped.
1028 * A zero-length transfer in PIO mode will not try to write/read
1029 * to/from the buffers
1030 *
1031 * REVISIT large transfers are exactly where we most want to be
1032 * using DMA. If this happens much, split those transfers into
1033 * multiple DMA segments rather than forcing PIO.
1034 */
1035 drv_data->dma_mapped = 0;
1036 if (drv_data->len > 0 && drv_data->len <= MAX_DMA_LEN)
1037 drv_data->dma_mapped = map_dma_buffers(drv_data);
1038 if (drv_data->dma_mapped) {
1039
1040 /* Ensure we have the correct interrupt handler */
1041 drv_data->transfer_handler = dma_transfer;
1042
1043 /* Setup rx DMA Channel */
1044 DCSR(drv_data->rx_channel) = RESET_DMA_CHANNEL;
1045 DSADR(drv_data->rx_channel) = drv_data->ssdr_physical;
1046 DTADR(drv_data->rx_channel) = drv_data->rx_dma;
1047 if (drv_data->rx == drv_data->null_dma_buf)
1048 /* No target address increment */
1049 DCMD(drv_data->rx_channel) = DCMD_FLOWSRC
1050 | drv_data->dma_width
1051 | dma_burst
1052 | drv_data->len;
1053 else
1054 DCMD(drv_data->rx_channel) = DCMD_INCTRGADDR
1055 | DCMD_FLOWSRC
1056 | drv_data->dma_width
1057 | dma_burst
1058 | drv_data->len;
1059
1060 /* Setup tx DMA Channel */
1061 DCSR(drv_data->tx_channel) = RESET_DMA_CHANNEL;
1062 DSADR(drv_data->tx_channel) = drv_data->tx_dma;
1063 DTADR(drv_data->tx_channel) = drv_data->ssdr_physical;
1064 if (drv_data->tx == drv_data->null_dma_buf)
1065 /* No source address increment */
1066 DCMD(drv_data->tx_channel) = DCMD_FLOWTRG
1067 | drv_data->dma_width
1068 | dma_burst
1069 | drv_data->len;
1070 else
1071 DCMD(drv_data->tx_channel) = DCMD_INCSRCADDR
1072 | DCMD_FLOWTRG
1073 | drv_data->dma_width
1074 | dma_burst
1075 | drv_data->len;
1076
1077 /* Enable dma end irqs on SSP to detect end of transfer */
1078 if (drv_data->ssp_type == PXA25x_SSP)
1079 DCMD(drv_data->tx_channel) |= DCMD_ENDIRQEN;
1080
1081 /* Clear status and start DMA engine */
1082 cr1 = chip->cr1 | dma_thresh | drv_data->dma_cr1;
1083 write_SSSR(drv_data->clear_sr, reg);
1084 DCSR(drv_data->rx_channel) |= DCSR_RUN;
1085 DCSR(drv_data->tx_channel) |= DCSR_RUN;
1086 } else {
1087 /* Ensure we have the correct interrupt handler */
1088 drv_data->transfer_handler = interrupt_transfer;
1089
1090 /* Clear status */
1091 cr1 = chip->cr1 | chip->threshold | drv_data->int_cr1;
1092 write_SSSR(drv_data->clear_sr, reg);
1093 }
1094
1095 /* see if we need to reload the config registers */
1096 if ((read_SSCR0(reg) != cr0)
1097 || (read_SSCR1(reg) & SSCR1_CHANGE_MASK) !=
1098 (cr1 & SSCR1_CHANGE_MASK)) {
1099
1100 /* stop the SSP, and update the other bits */
1101 write_SSCR0(cr0 & ~SSCR0_SSE, reg);
1102 if (drv_data->ssp_type != PXA25x_SSP)
1103 write_SSTO(chip->timeout, reg);
1104 /* first set CR1 without interrupt and service enables */
1105 write_SSCR1(cr1 & SSCR1_CHANGE_MASK, reg);
1106 /* restart the SSP */
1107 write_SSCR0(cr0, reg);
1108
1109 } else {
1110 if (drv_data->ssp_type != PXA25x_SSP)
1111 write_SSTO(chip->timeout, reg);
1112 }
1113
1114 cs_assert(drv_data);
1115
1116 /* after chip select, release the data by enabling service
1117 * requests and interrupts, without changing any mode bits */
1118 write_SSCR1(cr1, reg);
1119 }
1120
1121 static void pump_messages(struct work_struct *work)
1122 {
1123 struct driver_data *drv_data =
1124 container_of(work, struct driver_data, pump_messages);
1125 unsigned long flags;
1126
1127 /* Lock queue and check for queue work */
1128 spin_lock_irqsave(&drv_data->lock, flags);
1129 if (list_empty(&drv_data->queue) || drv_data->run == QUEUE_STOPPED) {
1130 drv_data->busy = 0;
1131 spin_unlock_irqrestore(&drv_data->lock, flags);
1132 return;
1133 }
1134
1135 /* Make sure we are not already running a message */
1136 if (drv_data->cur_msg) {
1137 spin_unlock_irqrestore(&drv_data->lock, flags);
1138 return;
1139 }
1140
1141 /* Extract head of queue */
1142 drv_data->cur_msg = list_entry(drv_data->queue.next,
1143 struct spi_message, queue);
1144 list_del_init(&drv_data->cur_msg->queue);
1145
1146 /* Initial message state*/
1147 drv_data->cur_msg->state = START_STATE;
1148 drv_data->cur_transfer = list_entry(drv_data->cur_msg->transfers.next,
1149 struct spi_transfer,
1150 transfer_list);
1151
1152 /* prepare to setup the SSP, in pump_transfers, using the per
1153 * chip configuration */
1154 drv_data->cur_chip = spi_get_ctldata(drv_data->cur_msg->spi);
1155
1156 /* Mark as busy and launch transfers */
1157 tasklet_schedule(&drv_data->pump_transfers);
1158
1159 drv_data->busy = 1;
1160 spin_unlock_irqrestore(&drv_data->lock, flags);
1161 }
1162
1163 static int transfer(struct spi_device *spi, struct spi_message *msg)
1164 {
1165 struct driver_data *drv_data = spi_master_get_devdata(spi->master);
1166 unsigned long flags;
1167
1168 spin_lock_irqsave(&drv_data->lock, flags);
1169
1170 if (drv_data->run == QUEUE_STOPPED) {
1171 spin_unlock_irqrestore(&drv_data->lock, flags);
1172 return -ESHUTDOWN;
1173 }
1174
1175 msg->actual_length = 0;
1176 msg->status = -EINPROGRESS;
1177 msg->state = START_STATE;
1178
1179 list_add_tail(&msg->queue, &drv_data->queue);
1180
1181 if (drv_data->run == QUEUE_RUNNING && !drv_data->busy)
1182 queue_work(drv_data->workqueue, &drv_data->pump_messages);
1183
1184 spin_unlock_irqrestore(&drv_data->lock, flags);
1185
1186 return 0;
1187 }
1188
1189 static int setup_cs(struct spi_device *spi, struct chip_data *chip,
1190 struct pxa2xx_spi_chip *chip_info)
1191 {
1192 int err = 0;
1193
1194 if (chip == NULL || chip_info == NULL)
1195 return 0;
1196
1197 /* NOTE: setup() can be called multiple times, possibly with
1198 * different chip_info, release previously requested GPIO
1199 */
1200 if (gpio_is_valid(chip->gpio_cs))
1201 gpio_free(chip->gpio_cs);
1202
1203 /* If (*cs_control) is provided, ignore GPIO chip select */
1204 if (chip_info->cs_control) {
1205 chip->cs_control = chip_info->cs_control;
1206 return 0;
1207 }
1208
1209 if (gpio_is_valid(chip_info->gpio_cs)) {
1210 err = gpio_request(chip_info->gpio_cs, "SPI_CS");
1211 if (err) {
1212 dev_err(&spi->dev, "failed to request chip select "
1213 "GPIO%d\n", chip_info->gpio_cs);
1214 return err;
1215 }
1216
1217 chip->gpio_cs = chip_info->gpio_cs;
1218 chip->gpio_cs_inverted = spi->mode & SPI_CS_HIGH;
1219
1220 err = gpio_direction_output(chip->gpio_cs,
1221 !chip->gpio_cs_inverted);
1222 }
1223
1224 return err;
1225 }
1226
1227 static int setup(struct spi_device *spi)
1228 {
1229 struct pxa2xx_spi_chip *chip_info = NULL;
1230 struct chip_data *chip;
1231 struct driver_data *drv_data = spi_master_get_devdata(spi->master);
1232 struct ssp_device *ssp = drv_data->ssp;
1233 unsigned int clk_div;
1234 uint tx_thres = TX_THRESH_DFLT;
1235 uint rx_thres = RX_THRESH_DFLT;
1236
1237 if (drv_data->ssp_type != PXA25x_SSP
1238 && (spi->bits_per_word < 4 || spi->bits_per_word > 32)) {
1239 dev_err(&spi->dev, "failed setup: ssp_type=%d, bits/wrd=%d "
1240 "b/w not 4-32 for type non-PXA25x_SSP\n",
1241 drv_data->ssp_type, spi->bits_per_word);
1242 return -EINVAL;
1243 }
1244 else if (drv_data->ssp_type == PXA25x_SSP
1245 && (spi->bits_per_word < 4
1246 || spi->bits_per_word > 16)) {
1247 dev_err(&spi->dev, "failed setup: ssp_type=%d, bits/wrd=%d "
1248 "b/w not 4-16 for type PXA25x_SSP\n",
1249 drv_data->ssp_type, spi->bits_per_word);
1250 return -EINVAL;
1251 }
1252
1253 /* Only alloc on first setup */
1254 chip = spi_get_ctldata(spi);
1255 if (!chip) {
1256 chip = kzalloc(sizeof(struct chip_data), GFP_KERNEL);
1257 if (!chip) {
1258 dev_err(&spi->dev,
1259 "failed setup: can't allocate chip data\n");
1260 return -ENOMEM;
1261 }
1262
1263 chip->gpio_cs = -1;
1264 chip->enable_dma = 0;
1265 chip->timeout = TIMOUT_DFLT;
1266 chip->dma_burst_size = drv_data->master_info->enable_dma ?
1267 DCMD_BURST8 : 0;
1268 }
1269
1270 /* protocol drivers may change the chip settings, so...
1271 * if chip_info exists, use it */
1272 chip_info = spi->controller_data;
1273
1274 /* chip_info isn't always needed */
1275 chip->cr1 = 0;
1276 if (chip_info) {
1277 if (chip_info->timeout)
1278 chip->timeout = chip_info->timeout;
1279 if (chip_info->tx_threshold)
1280 tx_thres = chip_info->tx_threshold;
1281 if (chip_info->rx_threshold)
1282 rx_thres = chip_info->rx_threshold;
1283 chip->enable_dma = drv_data->master_info->enable_dma;
1284 chip->dma_threshold = 0;
1285 if (chip_info->enable_loopback)
1286 chip->cr1 = SSCR1_LBM;
1287 }
1288
1289 chip->threshold = (SSCR1_RxTresh(rx_thres) & SSCR1_RFT) |
1290 (SSCR1_TxTresh(tx_thres) & SSCR1_TFT);
1291
1292 /* set dma burst and threshold outside of chip_info path so that if
1293 * chip_info goes away after setting chip->enable_dma, the
1294 * burst and threshold can still respond to changes in bits_per_word */
1295 if (chip->enable_dma) {
1296 /* set up legal burst and threshold for dma */
1297 if (set_dma_burst_and_threshold(chip, spi, spi->bits_per_word,
1298 &chip->dma_burst_size,
1299 &chip->dma_threshold)) {
1300 dev_warn(&spi->dev, "in setup: DMA burst size reduced "
1301 "to match bits_per_word\n");
1302 }
1303 }
1304
1305 clk_div = ssp_get_clk_div(ssp, spi->max_speed_hz);
1306 chip->speed_hz = spi->max_speed_hz;
1307
1308 chip->cr0 = clk_div
1309 | SSCR0_Motorola
1310 | SSCR0_DataSize(spi->bits_per_word > 16 ?
1311 spi->bits_per_word - 16 : spi->bits_per_word)
1312 | SSCR0_SSE
1313 | (spi->bits_per_word > 16 ? SSCR0_EDSS : 0);
1314 chip->cr1 &= ~(SSCR1_SPO | SSCR1_SPH);
1315 chip->cr1 |= (((spi->mode & SPI_CPHA) != 0) ? SSCR1_SPH : 0)
1316 | (((spi->mode & SPI_CPOL) != 0) ? SSCR1_SPO : 0);
1317
1318 /* NOTE: PXA25x_SSP _could_ use external clocking ... */
1319 if (drv_data->ssp_type != PXA25x_SSP)
1320 dev_dbg(&spi->dev, "%ld Hz actual, %s\n",
1321 clk_get_rate(ssp->clk)
1322 / (1 + ((chip->cr0 & SSCR0_SCR) >> 8)),
1323 chip->enable_dma ? "DMA" : "PIO");
1324 else
1325 dev_dbg(&spi->dev, "%ld Hz actual, %s\n",
1326 clk_get_rate(ssp->clk) / 2
1327 / (1 + ((chip->cr0 & SSCR0_SCR) >> 8)),
1328 chip->enable_dma ? "DMA" : "PIO");
1329
1330 if (spi->bits_per_word <= 8) {
1331 chip->n_bytes = 1;
1332 chip->dma_width = DCMD_WIDTH1;
1333 chip->read = u8_reader;
1334 chip->write = u8_writer;
1335 } else if (spi->bits_per_word <= 16) {
1336 chip->n_bytes = 2;
1337 chip->dma_width = DCMD_WIDTH2;
1338 chip->read = u16_reader;
1339 chip->write = u16_writer;
1340 } else if (spi->bits_per_word <= 32) {
1341 chip->cr0 |= SSCR0_EDSS;
1342 chip->n_bytes = 4;
1343 chip->dma_width = DCMD_WIDTH4;
1344 chip->read = u32_reader;
1345 chip->write = u32_writer;
1346 } else {
1347 dev_err(&spi->dev, "invalid wordsize\n");
1348 return -ENODEV;
1349 }
1350 chip->bits_per_word = spi->bits_per_word;
1351
1352 spi_set_ctldata(spi, chip);
1353
1354 return setup_cs(spi, chip, chip_info);
1355 }
1356
1357 static void cleanup(struct spi_device *spi)
1358 {
1359 struct chip_data *chip = spi_get_ctldata(spi);
1360
1361 if (!chip)
1362 return;
1363
1364 if (gpio_is_valid(chip->gpio_cs))
1365 gpio_free(chip->gpio_cs);
1366
1367 kfree(chip);
1368 }
1369
1370 static int __init init_queue(struct driver_data *drv_data)
1371 {
1372 INIT_LIST_HEAD(&drv_data->queue);
1373 spin_lock_init(&drv_data->lock);
1374
1375 drv_data->run = QUEUE_STOPPED;
1376 drv_data->busy = 0;
1377
1378 tasklet_init(&drv_data->pump_transfers,
1379 pump_transfers, (unsigned long)drv_data);
1380
1381 INIT_WORK(&drv_data->pump_messages, pump_messages);
1382 drv_data->workqueue = create_singlethread_workqueue(
1383 dev_name(drv_data->master->dev.parent));
1384 if (drv_data->workqueue == NULL)
1385 return -EBUSY;
1386
1387 return 0;
1388 }
1389
1390 static int start_queue(struct driver_data *drv_data)
1391 {
1392 unsigned long flags;
1393
1394 spin_lock_irqsave(&drv_data->lock, flags);
1395
1396 if (drv_data->run == QUEUE_RUNNING || drv_data->busy) {
1397 spin_unlock_irqrestore(&drv_data->lock, flags);
1398 return -EBUSY;
1399 }
1400
1401 drv_data->run = QUEUE_RUNNING;
1402 drv_data->cur_msg = NULL;
1403 drv_data->cur_transfer = NULL;
1404 drv_data->cur_chip = NULL;
1405 spin_unlock_irqrestore(&drv_data->lock, flags);
1406
1407 queue_work(drv_data->workqueue, &drv_data->pump_messages);
1408
1409 return 0;
1410 }
1411
1412 static int stop_queue(struct driver_data *drv_data)
1413 {
1414 unsigned long flags;
1415 unsigned limit = 500;
1416 int status = 0;
1417
1418 spin_lock_irqsave(&drv_data->lock, flags);
1419
1420 /* This is a bit lame, but is optimized for the common execution path.
1421 * A wait_queue on the drv_data->busy could be used, but then the common
1422 * execution path (pump_messages) would be required to call wake_up or
1423 * friends on every SPI message. Do this instead */
1424 drv_data->run = QUEUE_STOPPED;
1425 while (!list_empty(&drv_data->queue) && drv_data->busy && limit--) {
1426 spin_unlock_irqrestore(&drv_data->lock, flags);
1427 msleep(10);
1428 spin_lock_irqsave(&drv_data->lock, flags);
1429 }
1430
1431 if (!list_empty(&drv_data->queue) || drv_data->busy)
1432 status = -EBUSY;
1433
1434 spin_unlock_irqrestore(&drv_data->lock, flags);
1435
1436 return status;
1437 }
1438
1439 static int destroy_queue(struct driver_data *drv_data)
1440 {
1441 int status;
1442
1443 status = stop_queue(drv_data);
1444 /* we are unloading the module or failing to load (only two calls
1445 * to this routine), and neither call can handle a return value.
1446 * However, destroy_workqueue calls flush_workqueue, and that will
1447 * block until all work is done. If the reason that stop_queue
1448 * timed out is that the work will never finish, then it does no
1449 * good to call destroy_workqueue, so return anyway. */
1450 if (status != 0)
1451 return status;
1452
1453 destroy_workqueue(drv_data->workqueue);
1454
1455 return 0;
1456 }
1457
1458 static int __init pxa2xx_spi_probe(struct platform_device *pdev)
1459 {
1460 struct device *dev = &pdev->dev;
1461 struct pxa2xx_spi_master *platform_info;
1462 struct spi_master *master;
1463 struct driver_data *drv_data;
1464 struct ssp_device *ssp;
1465 int status;
1466
1467 platform_info = dev->platform_data;
1468
1469 ssp = ssp_request(pdev->id, pdev->name);
1470 if (ssp == NULL) {
1471 dev_err(&pdev->dev, "failed to request SSP%d\n", pdev->id);
1472 return -ENODEV;
1473 }
1474
1475 /* Allocate master with space for drv_data and null dma buffer */
1476 master = spi_alloc_master(dev, sizeof(struct driver_data) + 16);
1477 if (!master) {
1478 dev_err(&pdev->dev, "cannot alloc spi_master\n");
1479 ssp_free(ssp);
1480 return -ENOMEM;
1481 }
1482 drv_data = spi_master_get_devdata(master);
1483 drv_data->master = master;
1484 drv_data->master_info = platform_info;
1485 drv_data->pdev = pdev;
1486 drv_data->ssp = ssp;
1487
1488 /* the spi->mode bits understood by this driver: */
1489 master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH;
1490
1491 master->bus_num = pdev->id;
1492 master->num_chipselect = platform_info->num_chipselect;
1493 master->dma_alignment = DMA_ALIGNMENT;
1494 master->cleanup = cleanup;
1495 master->setup = setup;
1496 master->transfer = transfer;
1497
1498 drv_data->ssp_type = ssp->type;
1499 drv_data->null_dma_buf = (u32 *)ALIGN((u32)(drv_data +
1500 sizeof(struct driver_data)), 8);
1501
1502 drv_data->ioaddr = ssp->mmio_base;
1503 drv_data->ssdr_physical = ssp->phys_base + SSDR;
1504 if (ssp->type == PXA25x_SSP) {
1505 drv_data->int_cr1 = SSCR1_TIE | SSCR1_RIE;
1506 drv_data->dma_cr1 = 0;
1507 drv_data->clear_sr = SSSR_ROR;
1508 drv_data->mask_sr = SSSR_RFS | SSSR_TFS | SSSR_ROR;
1509 } else {
1510 drv_data->int_cr1 = SSCR1_TIE | SSCR1_RIE | SSCR1_TINTE;
1511 drv_data->dma_cr1 = SSCR1_TSRE | SSCR1_RSRE | SSCR1_TINTE;
1512 drv_data->clear_sr = SSSR_ROR | SSSR_TINT;
1513 drv_data->mask_sr = SSSR_TINT | SSSR_RFS | SSSR_TFS | SSSR_ROR;
1514 }
1515
1516 status = request_irq(ssp->irq, ssp_int, 0, dev_name(dev), drv_data);
1517 if (status < 0) {
1518 dev_err(&pdev->dev, "cannot get IRQ %d\n", ssp->irq);
1519 goto out_error_master_alloc;
1520 }
1521
1522 /* Setup DMA if requested */
1523 drv_data->tx_channel = -1;
1524 drv_data->rx_channel = -1;
1525 if (platform_info->enable_dma) {
1526
1527 /* Get two DMA channels (rx and tx) */
1528 drv_data->rx_channel = pxa_request_dma("pxa2xx_spi_ssp_rx",
1529 DMA_PRIO_HIGH,
1530 dma_handler,
1531 drv_data);
1532 if (drv_data->rx_channel < 0) {
1533 dev_err(dev, "problem (%d) requesting rx channel\n",
1534 drv_data->rx_channel);
1535 status = -ENODEV;
1536 goto out_error_irq_alloc;
1537 }
1538 drv_data->tx_channel = pxa_request_dma("pxa2xx_spi_ssp_tx",
1539 DMA_PRIO_MEDIUM,
1540 dma_handler,
1541 drv_data);
1542 if (drv_data->tx_channel < 0) {
1543 dev_err(dev, "problem (%d) requesting tx channel\n",
1544 drv_data->tx_channel);
1545 status = -ENODEV;
1546 goto out_error_dma_alloc;
1547 }
1548
1549 DRCMR(ssp->drcmr_rx) = DRCMR_MAPVLD | drv_data->rx_channel;
1550 DRCMR(ssp->drcmr_tx) = DRCMR_MAPVLD | drv_data->tx_channel;
1551 }
1552
1553 /* Enable SOC clock */
1554 clk_enable(ssp->clk);
1555
1556 /* Load default SSP configuration */
1557 write_SSCR0(0, drv_data->ioaddr);
1558 write_SSCR1(SSCR1_RxTresh(RX_THRESH_DFLT) |
1559 SSCR1_TxTresh(TX_THRESH_DFLT),
1560 drv_data->ioaddr);
1561 write_SSCR0(SSCR0_SerClkDiv(2)
1562 | SSCR0_Motorola
1563 | SSCR0_DataSize(8),
1564 drv_data->ioaddr);
1565 if (drv_data->ssp_type != PXA25x_SSP)
1566 write_SSTO(0, drv_data->ioaddr);
1567 write_SSPSP(0, drv_data->ioaddr);
1568
1569 /* Initial and start queue */
1570 status = init_queue(drv_data);
1571 if (status != 0) {
1572 dev_err(&pdev->dev, "problem initializing queue\n");
1573 goto out_error_clock_enabled;
1574 }
1575 status = start_queue(drv_data);
1576 if (status != 0) {
1577 dev_err(&pdev->dev, "problem starting queue\n");
1578 goto out_error_clock_enabled;
1579 }
1580
1581 /* Register with the SPI framework */
1582 platform_set_drvdata(pdev, drv_data);
1583 status = spi_register_master(master);
1584 if (status != 0) {
1585 dev_err(&pdev->dev, "problem registering spi master\n");
1586 goto out_error_queue_alloc;
1587 }
1588
1589 return status;
1590
1591 out_error_queue_alloc:
1592 destroy_queue(drv_data);
1593
1594 out_error_clock_enabled:
1595 clk_disable(ssp->clk);
1596
1597 out_error_dma_alloc:
1598 if (drv_data->tx_channel != -1)
1599 pxa_free_dma(drv_data->tx_channel);
1600 if (drv_data->rx_channel != -1)
1601 pxa_free_dma(drv_data->rx_channel);
1602
1603 out_error_irq_alloc:
1604 free_irq(ssp->irq, drv_data);
1605
1606 out_error_master_alloc:
1607 spi_master_put(master);
1608 ssp_free(ssp);
1609 return status;
1610 }
1611
1612 static int pxa2xx_spi_remove(struct platform_device *pdev)
1613 {
1614 struct driver_data *drv_data = platform_get_drvdata(pdev);
1615 struct ssp_device *ssp;
1616 int status = 0;
1617
1618 if (!drv_data)
1619 return 0;
1620 ssp = drv_data->ssp;
1621
1622 /* Remove the queue */
1623 status = destroy_queue(drv_data);
1624 if (status != 0)
1625 /* the kernel does not check the return status of this
1626 * this routine (mod->exit, within the kernel). Therefore
1627 * nothing is gained by returning from here, the module is
1628 * going away regardless, and we should not leave any more
1629 * resources allocated than necessary. We cannot free the
1630 * message memory in drv_data->queue, but we can release the
1631 * resources below. I think the kernel should honor -EBUSY
1632 * returns but... */
1633 dev_err(&pdev->dev, "pxa2xx_spi_remove: workqueue will not "
1634 "complete, message memory not freed\n");
1635
1636 /* Disable the SSP at the peripheral and SOC level */
1637 write_SSCR0(0, drv_data->ioaddr);
1638 clk_disable(ssp->clk);
1639
1640 /* Release DMA */
1641 if (drv_data->master_info->enable_dma) {
1642 DRCMR(ssp->drcmr_rx) = 0;
1643 DRCMR(ssp->drcmr_tx) = 0;
1644 pxa_free_dma(drv_data->tx_channel);
1645 pxa_free_dma(drv_data->rx_channel);
1646 }
1647
1648 /* Release IRQ */
1649 free_irq(ssp->irq, drv_data);
1650
1651 /* Release SSP */
1652 ssp_free(ssp);
1653
1654 /* Disconnect from the SPI framework */
1655 spi_unregister_master(drv_data->master);
1656
1657 /* Prevent double remove */
1658 platform_set_drvdata(pdev, NULL);
1659
1660 return 0;
1661 }
1662
1663 static void pxa2xx_spi_shutdown(struct platform_device *pdev)
1664 {
1665 int status = 0;
1666
1667 if ((status = pxa2xx_spi_remove(pdev)) != 0)
1668 dev_err(&pdev->dev, "shutdown failed with %d\n", status);
1669 }
1670
1671 #ifdef CONFIG_PM
1672 static int pxa2xx_spi_suspend(struct device *dev)
1673 {
1674 struct driver_data *drv_data = dev_get_drvdata(dev);
1675 struct ssp_device *ssp = drv_data->ssp;
1676 int status = 0;
1677
1678 status = stop_queue(drv_data);
1679 if (status != 0)
1680 return status;
1681 write_SSCR0(0, drv_data->ioaddr);
1682 clk_disable(ssp->clk);
1683
1684 return 0;
1685 }
1686
1687 static int pxa2xx_spi_resume(struct device *dev)
1688 {
1689 struct driver_data *drv_data = dev_get_drvdata(dev);
1690 struct ssp_device *ssp = drv_data->ssp;
1691 int status = 0;
1692
1693 if (drv_data->rx_channel != -1)
1694 DRCMR(drv_data->ssp->drcmr_rx) =
1695 DRCMR_MAPVLD | drv_data->rx_channel;
1696 if (drv_data->tx_channel != -1)
1697 DRCMR(drv_data->ssp->drcmr_tx) =
1698 DRCMR_MAPVLD | drv_data->tx_channel;
1699
1700 /* Enable the SSP clock */
1701 clk_enable(ssp->clk);
1702
1703 /* Start the queue running */
1704 status = start_queue(drv_data);
1705 if (status != 0) {
1706 dev_err(dev, "problem starting queue (%d)\n", status);
1707 return status;
1708 }
1709
1710 return 0;
1711 }
1712
1713 static const struct dev_pm_ops pxa2xx_spi_pm_ops = {
1714 .suspend = pxa2xx_spi_suspend,
1715 .resume = pxa2xx_spi_resume,
1716 };
1717 #endif
1718
1719 static struct platform_driver driver = {
1720 .driver = {
1721 .name = "pxa2xx-spi",
1722 .owner = THIS_MODULE,
1723 #ifdef CONFIG_PM
1724 .pm = &pxa2xx_spi_pm_ops,
1725 #endif
1726 },
1727 .remove = pxa2xx_spi_remove,
1728 .shutdown = pxa2xx_spi_shutdown,
1729 };
1730
1731 static int __init pxa2xx_spi_init(void)
1732 {
1733 return platform_driver_probe(&driver, pxa2xx_spi_probe);
1734 }
1735 subsys_initcall(pxa2xx_spi_init);
1736
1737 static void __exit pxa2xx_spi_exit(void)
1738 {
1739 platform_driver_unregister(&driver);
1740 }
1741 module_exit(pxa2xx_spi_exit);
Linux with added FPC-III support