Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jbarnes...
[linux-2.6] / drivers / spi / spi_imx.c
1 /*
2  * drivers/spi/spi_imx.c
3  *
4  * Copyright (C) 2006 SWAPP
5  *      Andrea Paterniani <a.paterniani@swapp-eng.it>
6  *
7  * Initial version inspired by:
8  *      linux-2.6.17-rc3-mm1/drivers/spi/pxa2xx_spi.c
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  */
20
21 #include <linux/init.h>
22 #include <linux/module.h>
23 #include <linux/device.h>
24 #include <linux/ioport.h>
25 #include <linux/errno.h>
26 #include <linux/interrupt.h>
27 #include <linux/platform_device.h>
28 #include <linux/dma-mapping.h>
29 #include <linux/spi/spi.h>
30 #include <linux/workqueue.h>
31 #include <linux/delay.h>
32
33 #include <asm/io.h>
34 #include <asm/irq.h>
35 #include <asm/hardware.h>
36 #include <asm/delay.h>
37
38 #include <asm/arch/hardware.h>
39 #include <asm/arch/imx-dma.h>
40 #include <asm/arch/spi_imx.h>
41
42 /*-------------------------------------------------------------------------*/
43 /* SPI Registers offsets from peripheral base address */
44 #define SPI_RXDATA              (0x00)
45 #define SPI_TXDATA              (0x04)
46 #define SPI_CONTROL             (0x08)
47 #define SPI_INT_STATUS          (0x0C)
48 #define SPI_TEST                (0x10)
49 #define SPI_PERIOD              (0x14)
50 #define SPI_DMA                 (0x18)
51 #define SPI_RESET               (0x1C)
52
53 /* SPI Control Register Bit Fields & Masks */
54 #define SPI_CONTROL_BITCOUNT_MASK       (0xF)           /* Bit Count Mask */
55 #define SPI_CONTROL_BITCOUNT(n)         (((n) - 1) & SPI_CONTROL_BITCOUNT_MASK)
56 #define SPI_CONTROL_POL                 (0x1 << 4)      /* Clock Polarity Mask */
57 #define SPI_CONTROL_POL_ACT_HIGH        (0x0 << 4)      /* Active high pol. (0=idle) */
58 #define SPI_CONTROL_POL_ACT_LOW         (0x1 << 4)      /* Active low pol. (1=idle) */
59 #define SPI_CONTROL_PHA                 (0x1 << 5)      /* Clock Phase Mask */
60 #define SPI_CONTROL_PHA_0               (0x0 << 5)      /* Clock Phase 0 */
61 #define SPI_CONTROL_PHA_1               (0x1 << 5)      /* Clock Phase 1 */
62 #define SPI_CONTROL_SSCTL               (0x1 << 6)      /* /SS Waveform Select Mask */
63 #define SPI_CONTROL_SSCTL_0             (0x0 << 6)      /* Master: /SS stays low between SPI burst
64                                                            Slave: RXFIFO advanced by BIT_COUNT */
65 #define SPI_CONTROL_SSCTL_1             (0x1 << 6)      /* Master: /SS insert pulse between SPI burst
66                                                            Slave: RXFIFO advanced by /SS rising edge */
67 #define SPI_CONTROL_SSPOL               (0x1 << 7)      /* /SS Polarity Select Mask */
68 #define SPI_CONTROL_SSPOL_ACT_LOW       (0x0 << 7)      /* /SS Active low */
69 #define SPI_CONTROL_SSPOL_ACT_HIGH      (0x1 << 7)      /* /SS Active high */
70 #define SPI_CONTROL_XCH                 (0x1 << 8)      /* Exchange */
71 #define SPI_CONTROL_SPIEN               (0x1 << 9)      /* SPI Module Enable */
72 #define SPI_CONTROL_MODE                (0x1 << 10)     /* SPI Mode Select Mask */
73 #define SPI_CONTROL_MODE_SLAVE          (0x0 << 10)     /* SPI Mode Slave */
74 #define SPI_CONTROL_MODE_MASTER         (0x1 << 10)     /* SPI Mode Master */
75 #define SPI_CONTROL_DRCTL               (0x3 << 11)     /* /SPI_RDY Control Mask */
76 #define SPI_CONTROL_DRCTL_0             (0x0 << 11)     /* Ignore /SPI_RDY */
77 #define SPI_CONTROL_DRCTL_1             (0x1 << 11)     /* /SPI_RDY falling edge triggers input */
78 #define SPI_CONTROL_DRCTL_2             (0x2 << 11)     /* /SPI_RDY active low level triggers input */
79 #define SPI_CONTROL_DATARATE            (0x7 << 13)     /* Data Rate Mask */
80 #define SPI_PERCLK2_DIV_MIN             (0)             /* PERCLK2:4 */
81 #define SPI_PERCLK2_DIV_MAX             (7)             /* PERCLK2:512 */
82 #define SPI_CONTROL_DATARATE_MIN        (SPI_PERCLK2_DIV_MAX << 13)
83 #define SPI_CONTROL_DATARATE_MAX        (SPI_PERCLK2_DIV_MIN << 13)
84 #define SPI_CONTROL_DATARATE_BAD        (SPI_CONTROL_DATARATE_MIN + 1)
85
86 /* SPI Interrupt/Status Register Bit Fields & Masks */
87 #define SPI_STATUS_TE   (0x1 << 0)      /* TXFIFO Empty Status */
88 #define SPI_STATUS_TH   (0x1 << 1)      /* TXFIFO Half Status */
89 #define SPI_STATUS_TF   (0x1 << 2)      /* TXFIFO Full Status */
90 #define SPI_STATUS_RR   (0x1 << 3)      /* RXFIFO Data Ready Status */
91 #define SPI_STATUS_RH   (0x1 << 4)      /* RXFIFO Half Status */
92 #define SPI_STATUS_RF   (0x1 << 5)      /* RXFIFO Full Status */
93 #define SPI_STATUS_RO   (0x1 << 6)      /* RXFIFO Overflow */
94 #define SPI_STATUS_BO   (0x1 << 7)      /* Bit Count Overflow */
95 #define SPI_STATUS      (0xFF)          /* SPI Status Mask */
96 #define SPI_INTEN_TE    (0x1 << 8)      /* TXFIFO Empty Interrupt Enable */
97 #define SPI_INTEN_TH    (0x1 << 9)      /* TXFIFO Half Interrupt Enable */
98 #define SPI_INTEN_TF    (0x1 << 10)     /* TXFIFO Full Interrupt Enable */
99 #define SPI_INTEN_RE    (0x1 << 11)     /* RXFIFO Data Ready Interrupt Enable */
100 #define SPI_INTEN_RH    (0x1 << 12)     /* RXFIFO Half Interrupt Enable */
101 #define SPI_INTEN_RF    (0x1 << 13)     /* RXFIFO Full Interrupt Enable */
102 #define SPI_INTEN_RO    (0x1 << 14)     /* RXFIFO Overflow Interrupt Enable */
103 #define SPI_INTEN_BO    (0x1 << 15)     /* Bit Count Overflow Interrupt Enable */
104 #define SPI_INTEN       (0xFF << 8)     /* SPI Interrupt Enable Mask */
105
106 /* SPI Test Register Bit Fields & Masks */
107 #define SPI_TEST_TXCNT          (0xF << 0)      /* TXFIFO Counter */
108 #define SPI_TEST_RXCNT_LSB      (4)             /* RXFIFO Counter LSB */
109 #define SPI_TEST_RXCNT          (0xF << 4)      /* RXFIFO Counter */
110 #define SPI_TEST_SSTATUS        (0xF << 8)      /* State Machine Status */
111 #define SPI_TEST_LBC            (0x1 << 14)     /* Loop Back Control */
112
113 /* SPI Period Register Bit Fields & Masks */
114 #define SPI_PERIOD_WAIT         (0x7FFF << 0)   /* Wait Between Transactions */
115 #define SPI_PERIOD_MAX_WAIT     (0x7FFF)        /* Max Wait Between
116                                                         Transactions */
117 #define SPI_PERIOD_CSRC         (0x1 << 15)     /* Period Clock Source Mask */
118 #define SPI_PERIOD_CSRC_BCLK    (0x0 << 15)     /* Period Clock Source is
119                                                         Bit Clock */
120 #define SPI_PERIOD_CSRC_32768   (0x1 << 15)     /* Period Clock Source is
121                                                         32.768 KHz Clock */
122
123 /* SPI DMA Register Bit Fields & Masks */
124 #define SPI_DMA_RHDMA   (0x1 << 4)      /* RXFIFO Half Status */
125 #define SPI_DMA_RFDMA   (0x1 << 5)      /* RXFIFO Full Status */
126 #define SPI_DMA_TEDMA   (0x1 << 6)      /* TXFIFO Empty Status */
127 #define SPI_DMA_THDMA   (0x1 << 7)      /* TXFIFO Half Status */
128 #define SPI_DMA_RHDEN   (0x1 << 12)     /* RXFIFO Half DMA Request Enable */
129 #define SPI_DMA_RFDEN   (0x1 << 13)     /* RXFIFO Full DMA Request Enable */
130 #define SPI_DMA_TEDEN   (0x1 << 14)     /* TXFIFO Empty DMA Request Enable */
131 #define SPI_DMA_THDEN   (0x1 << 15)     /* TXFIFO Half DMA Request Enable */
132
133 /* SPI Soft Reset Register Bit Fields & Masks */
134 #define SPI_RESET_START (0x1)           /* Start */
135
136 /* Default SPI configuration values */
137 #define SPI_DEFAULT_CONTROL             \
138 (                                       \
139         SPI_CONTROL_BITCOUNT(16) |      \
140         SPI_CONTROL_POL_ACT_HIGH |      \
141         SPI_CONTROL_PHA_0 |             \
142         SPI_CONTROL_SPIEN |             \
143         SPI_CONTROL_SSCTL_1 |           \
144         SPI_CONTROL_MODE_MASTER |       \
145         SPI_CONTROL_DRCTL_0 |           \
146         SPI_CONTROL_DATARATE_MIN        \
147 )
148 #define SPI_DEFAULT_ENABLE_LOOPBACK     (0)
149 #define SPI_DEFAULT_ENABLE_DMA          (0)
150 #define SPI_DEFAULT_PERIOD_WAIT         (8)
151 /*-------------------------------------------------------------------------*/
152
153
154 /*-------------------------------------------------------------------------*/
155 /* TX/RX SPI FIFO size */
156 #define SPI_FIFO_DEPTH                  (8)
157 #define SPI_FIFO_BYTE_WIDTH             (2)
158 #define SPI_FIFO_OVERFLOW_MARGIN        (2)
159
160 /* DMA burst length for half full/empty request trigger */
161 #define SPI_DMA_BLR                     (SPI_FIFO_DEPTH * SPI_FIFO_BYTE_WIDTH / 2)
162
163 /* Dummy char output to achieve reads.
164    Choosing something different from all zeroes may help pattern recogition
165    for oscilloscope analysis, but may break some drivers. */
166 #define SPI_DUMMY_u8                    0
167 #define SPI_DUMMY_u16                   ((SPI_DUMMY_u8 << 8) | SPI_DUMMY_u8)
168 #define SPI_DUMMY_u32                   ((SPI_DUMMY_u16 << 16) | SPI_DUMMY_u16)
169
170 /**
171  * Macro to change a u32 field:
172  * @r : register to edit
173  * @m : bit mask
174  * @v : new value for the field correctly bit-alligned
175 */
176 #define u32_EDIT(r, m, v)               r = (r & ~(m)) | (v)
177
178 /* Message state */
179 #define START_STATE                     ((void*)0)
180 #define RUNNING_STATE                   ((void*)1)
181 #define DONE_STATE                      ((void*)2)
182 #define ERROR_STATE                     ((void*)-1)
183
184 /* Queue state */
185 #define QUEUE_RUNNING                   (0)
186 #define QUEUE_STOPPED                   (1)
187
188 #define IS_DMA_ALIGNED(x)               (((u32)(x) & 0x03) == 0)
189 /*-------------------------------------------------------------------------*/
190
191
192 /*-------------------------------------------------------------------------*/
193 /* Driver data structs */
194
195 /* Context */
196 struct driver_data {
197         /* Driver model hookup */
198         struct platform_device *pdev;
199
200         /* SPI framework hookup */
201         struct spi_master *master;
202
203         /* IMX hookup */
204         struct spi_imx_master *master_info;
205
206         /* Memory resources and SPI regs virtual address */
207         struct resource *ioarea;
208         void __iomem *regs;
209
210         /* SPI RX_DATA physical address */
211         dma_addr_t rd_data_phys;
212
213         /* Driver message queue */
214         struct workqueue_struct *workqueue;
215         struct work_struct work;
216         spinlock_t lock;
217         struct list_head queue;
218         int busy;
219         int run;
220
221         /* Message Transfer pump */
222         struct tasklet_struct pump_transfers;
223
224         /* Current message, transfer and state */
225         struct spi_message *cur_msg;
226         struct spi_transfer *cur_transfer;
227         struct chip_data *cur_chip;
228
229         /* Rd / Wr buffers pointers */
230         size_t len;
231         void *tx;
232         void *tx_end;
233         void *rx;
234         void *rx_end;
235
236         u8 rd_only;
237         u8 n_bytes;
238         int cs_change;
239
240         /* Function pointers */
241         irqreturn_t (*transfer_handler)(struct driver_data *drv_data);
242         void (*cs_control)(u32 command);
243
244         /* DMA setup */
245         int rx_channel;
246         int tx_channel;
247         dma_addr_t rx_dma;
248         dma_addr_t tx_dma;
249         int rx_dma_needs_unmap;
250         int tx_dma_needs_unmap;
251         size_t tx_map_len;
252         u32 dummy_dma_buf ____cacheline_aligned;
253 };
254
255 /* Runtime state */
256 struct chip_data {
257         u32 control;
258         u32 period;
259         u32 test;
260
261         u8 enable_dma:1;
262         u8 bits_per_word;
263         u8 n_bytes;
264         u32 max_speed_hz;
265
266         void (*cs_control)(u32 command);
267 };
268 /*-------------------------------------------------------------------------*/
269
270
271 static void pump_messages(struct work_struct *work);
272
273 static void flush(struct driver_data *drv_data)
274 {
275         void __iomem *regs = drv_data->regs;
276         u32 control;
277
278         dev_dbg(&drv_data->pdev->dev, "flush\n");
279
280         /* Wait for end of transaction */
281         do {
282                 control = readl(regs + SPI_CONTROL);
283         } while (control & SPI_CONTROL_XCH);
284
285         /* Release chip select if requested, transfer delays are
286            handled in pump_transfers */
287         if (drv_data->cs_change)
288                 drv_data->cs_control(SPI_CS_DEASSERT);
289
290         /* Disable SPI to flush FIFOs */
291         writel(control & ~SPI_CONTROL_SPIEN, regs + SPI_CONTROL);
292         writel(control, regs + SPI_CONTROL);
293 }
294
295 static void restore_state(struct driver_data *drv_data)
296 {
297         void __iomem *regs = drv_data->regs;
298         struct chip_data *chip = drv_data->cur_chip;
299
300         /* Load chip registers */
301         dev_dbg(&drv_data->pdev->dev,
302                 "restore_state\n"
303                 "    test    = 0x%08X\n"
304                 "    control = 0x%08X\n",
305                 chip->test,
306                 chip->control);
307         writel(chip->test, regs + SPI_TEST);
308         writel(chip->period, regs + SPI_PERIOD);
309         writel(0, regs + SPI_INT_STATUS);
310         writel(chip->control, regs + SPI_CONTROL);
311 }
312
313 static void null_cs_control(u32 command)
314 {
315 }
316
317 static inline u32 data_to_write(struct driver_data *drv_data)
318 {
319         return ((u32)(drv_data->tx_end - drv_data->tx)) / drv_data->n_bytes;
320 }
321
322 static inline u32 data_to_read(struct driver_data *drv_data)
323 {
324         return ((u32)(drv_data->rx_end - drv_data->rx)) / drv_data->n_bytes;
325 }
326
327 static int write(struct driver_data *drv_data)
328 {
329         void __iomem *regs = drv_data->regs;
330         void *tx = drv_data->tx;
331         void *tx_end = drv_data->tx_end;
332         u8 n_bytes = drv_data->n_bytes;
333         u32 remaining_writes;
334         u32 fifo_avail_space;
335         u32 n;
336         u16 d;
337
338         /* Compute how many fifo writes to do */
339         remaining_writes = (u32)(tx_end - tx) / n_bytes;
340         fifo_avail_space = SPI_FIFO_DEPTH -
341                                 (readl(regs + SPI_TEST) & SPI_TEST_TXCNT);
342         if (drv_data->rx && (fifo_avail_space > SPI_FIFO_OVERFLOW_MARGIN))
343                 /* Fix misunderstood receive overflow */
344                 fifo_avail_space -= SPI_FIFO_OVERFLOW_MARGIN;
345         n = min(remaining_writes, fifo_avail_space);
346
347         dev_dbg(&drv_data->pdev->dev,
348                 "write type %s\n"
349                 "    remaining writes = %d\n"
350                 "    fifo avail space = %d\n"
351                 "    fifo writes      = %d\n",
352                 (n_bytes == 1) ? "u8" : "u16",
353                 remaining_writes,
354                 fifo_avail_space,
355                 n);
356
357         if (n > 0) {
358                 /* Fill SPI TXFIFO */
359                 if (drv_data->rd_only) {
360                         tx += n * n_bytes;
361                         while (n--)
362                                 writel(SPI_DUMMY_u16, regs + SPI_TXDATA);
363                 } else {
364                         if (n_bytes == 1) {
365                                 while (n--) {
366                                         d = *(u8*)tx;
367                                         writel(d, regs + SPI_TXDATA);
368                                         tx += 1;
369                                 }
370                         } else {
371                                 while (n--) {
372                                         d = *(u16*)tx;
373                                         writel(d, regs + SPI_TXDATA);
374                                         tx += 2;
375                                 }
376                         }
377                 }
378
379                 /* Trigger transfer */
380                 writel(readl(regs + SPI_CONTROL) | SPI_CONTROL_XCH,
381                         regs + SPI_CONTROL);
382
383                 /* Update tx pointer */
384                 drv_data->tx = tx;
385         }
386
387         return (tx >= tx_end);
388 }
389
390 static int read(struct driver_data *drv_data)
391 {
392         void __iomem *regs = drv_data->regs;
393         void *rx = drv_data->rx;
394         void *rx_end = drv_data->rx_end;
395         u8 n_bytes = drv_data->n_bytes;
396         u32 remaining_reads;
397         u32 fifo_rxcnt;
398         u32 n;
399         u16 d;
400
401         /* Compute how many fifo reads to do */
402         remaining_reads = (u32)(rx_end - rx) / n_bytes;
403         fifo_rxcnt = (readl(regs + SPI_TEST) & SPI_TEST_RXCNT) >>
404                         SPI_TEST_RXCNT_LSB;
405         n = min(remaining_reads, fifo_rxcnt);
406
407         dev_dbg(&drv_data->pdev->dev,
408                 "read type %s\n"
409                 "    remaining reads = %d\n"
410                 "    fifo rx count   = %d\n"
411                 "    fifo reads      = %d\n",
412                 (n_bytes == 1) ? "u8" : "u16",
413                 remaining_reads,
414                 fifo_rxcnt,
415                 n);
416
417         if (n > 0) {
418                 /* Read SPI RXFIFO */
419                 if (n_bytes == 1) {
420                         while (n--) {
421                                 d = readl(regs + SPI_RXDATA);
422                                 *((u8*)rx) = d;
423                                 rx += 1;
424                         }
425                 } else {
426                         while (n--) {
427                                 d = readl(regs + SPI_RXDATA);
428                                 *((u16*)rx) = d;
429                                 rx += 2;
430                         }
431                 }
432
433                 /* Update rx pointer */
434                 drv_data->rx = rx;
435         }
436
437         return (rx >= rx_end);
438 }
439
440 static void *next_transfer(struct driver_data *drv_data)
441 {
442         struct spi_message *msg = drv_data->cur_msg;
443         struct spi_transfer *trans = drv_data->cur_transfer;
444
445         /* Move to next transfer */
446         if (trans->transfer_list.next != &msg->transfers) {
447                 drv_data->cur_transfer =
448                         list_entry(trans->transfer_list.next,
449                                         struct spi_transfer,
450                                         transfer_list);
451                 return RUNNING_STATE;
452         }
453
454         return DONE_STATE;
455 }
456
457 static int map_dma_buffers(struct driver_data *drv_data)
458 {
459         struct spi_message *msg;
460         struct device *dev;
461         void *buf;
462
463         drv_data->rx_dma_needs_unmap = 0;
464         drv_data->tx_dma_needs_unmap = 0;
465
466         if (!drv_data->master_info->enable_dma ||
467                 !drv_data->cur_chip->enable_dma)
468                         return -1;
469
470         msg = drv_data->cur_msg;
471         dev = &msg->spi->dev;
472         if (msg->is_dma_mapped) {
473                 if (drv_data->tx_dma)
474                         /* The caller provided at least dma and cpu virtual
475                            address for write; pump_transfers() will consider the
476                            transfer as write only if cpu rx virtual address is
477                            NULL */
478                         return 0;
479
480                 if (drv_data->rx_dma) {
481                         /* The caller provided dma and cpu virtual address to
482                            performe read only transfer -->
483                            use drv_data->dummy_dma_buf for dummy writes to
484                            achive reads */
485                         buf = &drv_data->dummy_dma_buf;
486                         drv_data->tx_map_len = sizeof(drv_data->dummy_dma_buf);
487                         drv_data->tx_dma = dma_map_single(dev,
488                                                         buf,
489                                                         drv_data->tx_map_len,
490                                                         DMA_TO_DEVICE);
491                         if (dma_mapping_error(drv_data->tx_dma))
492                                 return -1;
493
494                         drv_data->tx_dma_needs_unmap = 1;
495
496                         /* Flags transfer as rd_only for pump_transfers() DMA
497                            regs programming (should be redundant) */
498                         drv_data->tx = NULL;
499
500                         return 0;
501                 }
502         }
503
504         if (!IS_DMA_ALIGNED(drv_data->rx) || !IS_DMA_ALIGNED(drv_data->tx))
505                 return -1;
506
507         /* NULL rx means write-only transfer and no map needed
508            since rx DMA will not be used */
509         if (drv_data->rx) {
510                 buf = drv_data->rx;
511                 drv_data->rx_dma = dma_map_single(
512                                         dev,
513                                         buf,
514                                         drv_data->len,
515                                         DMA_FROM_DEVICE);
516                 if (dma_mapping_error(drv_data->rx_dma))
517                         return -1;
518                 drv_data->rx_dma_needs_unmap = 1;
519         }
520
521         if (drv_data->tx == NULL) {
522                 /* Read only message --> use drv_data->dummy_dma_buf for dummy
523                    writes to achive reads */
524                 buf = &drv_data->dummy_dma_buf;
525                 drv_data->tx_map_len = sizeof(drv_data->dummy_dma_buf);
526         } else {
527                 buf = drv_data->tx;
528                 drv_data->tx_map_len = drv_data->len;
529         }
530         drv_data->tx_dma = dma_map_single(dev,
531                                         buf,
532                                         drv_data->tx_map_len,
533                                         DMA_TO_DEVICE);
534         if (dma_mapping_error(drv_data->tx_dma)) {
535                 if (drv_data->rx_dma) {
536                         dma_unmap_single(dev,
537                                         drv_data->rx_dma,
538                                         drv_data->len,
539                                         DMA_FROM_DEVICE);
540                         drv_data->rx_dma_needs_unmap = 0;
541                 }
542                 return -1;
543         }
544         drv_data->tx_dma_needs_unmap = 1;
545
546         return 0;
547 }
548
549 static void unmap_dma_buffers(struct driver_data *drv_data)
550 {
551         struct spi_message *msg = drv_data->cur_msg;
552         struct device *dev = &msg->spi->dev;
553
554         if (drv_data->rx_dma_needs_unmap) {
555                 dma_unmap_single(dev,
556                                 drv_data->rx_dma,
557                                 drv_data->len,
558                                 DMA_FROM_DEVICE);
559                 drv_data->rx_dma_needs_unmap = 0;
560         }
561         if (drv_data->tx_dma_needs_unmap) {
562                 dma_unmap_single(dev,
563                                 drv_data->tx_dma,
564                                 drv_data->tx_map_len,
565                                 DMA_TO_DEVICE);
566                 drv_data->tx_dma_needs_unmap = 0;
567         }
568 }
569
570 /* Caller already set message->status (dma is already blocked) */
571 static void giveback(struct spi_message *message, struct driver_data *drv_data)
572 {
573         void __iomem *regs = drv_data->regs;
574
575         /* Bring SPI to sleep; restore_state() and pump_transfer()
576            will do new setup */
577         writel(0, regs + SPI_INT_STATUS);
578         writel(0, regs + SPI_DMA);
579
580         /* Unconditioned deselct */
581         drv_data->cs_control(SPI_CS_DEASSERT);
582
583         message->state = NULL;
584         if (message->complete)
585                 message->complete(message->context);
586
587         drv_data->cur_msg = NULL;
588         drv_data->cur_transfer = NULL;
589         drv_data->cur_chip = NULL;
590         queue_work(drv_data->workqueue, &drv_data->work);
591 }
592
593 static void dma_err_handler(int channel, void *data, int errcode)
594 {
595         struct driver_data *drv_data = data;
596         struct spi_message *msg = drv_data->cur_msg;
597
598         dev_dbg(&drv_data->pdev->dev, "dma_err_handler\n");
599
600         /* Disable both rx and tx dma channels */
601         imx_dma_disable(drv_data->rx_channel);
602         imx_dma_disable(drv_data->tx_channel);
603         unmap_dma_buffers(drv_data);
604
605         flush(drv_data);
606
607         msg->state = ERROR_STATE;
608         tasklet_schedule(&drv_data->pump_transfers);
609 }
610
611 static void dma_tx_handler(int channel, void *data)
612 {
613         struct driver_data *drv_data = data;
614
615         dev_dbg(&drv_data->pdev->dev, "dma_tx_handler\n");
616
617         imx_dma_disable(channel);
618
619         /* Now waits for TX FIFO empty */
620         writel(SPI_INTEN_TE, drv_data->regs + SPI_INT_STATUS);
621 }
622
623 static irqreturn_t dma_transfer(struct driver_data *drv_data)
624 {
625         u32 status;
626         struct spi_message *msg = drv_data->cur_msg;
627         void __iomem *regs = drv_data->regs;
628
629         status = readl(regs + SPI_INT_STATUS);
630
631         if ((status & (SPI_INTEN_RO | SPI_STATUS_RO))
632                         == (SPI_INTEN_RO | SPI_STATUS_RO)) {
633                 writel(status & ~SPI_INTEN, regs + SPI_INT_STATUS);
634
635                 imx_dma_disable(drv_data->tx_channel);
636                 imx_dma_disable(drv_data->rx_channel);
637                 unmap_dma_buffers(drv_data);
638
639                 flush(drv_data);
640
641                 dev_warn(&drv_data->pdev->dev,
642                                 "dma_transfer - fifo overun\n");
643
644                 msg->state = ERROR_STATE;
645                 tasklet_schedule(&drv_data->pump_transfers);
646
647                 return IRQ_HANDLED;
648         }
649
650         if (status & SPI_STATUS_TE) {
651                 writel(status & ~SPI_INTEN_TE, regs + SPI_INT_STATUS);
652
653                 if (drv_data->rx) {
654                         /* Wait end of transfer before read trailing data */
655                         while (readl(regs + SPI_CONTROL) & SPI_CONTROL_XCH)
656                                 cpu_relax();
657
658                         imx_dma_disable(drv_data->rx_channel);
659                         unmap_dma_buffers(drv_data);
660
661                         /* Release chip select if requested, transfer delays are
662                            handled in pump_transfers() */
663                         if (drv_data->cs_change)
664                                 drv_data->cs_control(SPI_CS_DEASSERT);
665
666                         /* Calculate number of trailing data and read them */
667                         dev_dbg(&drv_data->pdev->dev,
668                                 "dma_transfer - test = 0x%08X\n",
669                                 readl(regs + SPI_TEST));
670                         drv_data->rx = drv_data->rx_end -
671                                         ((readl(regs + SPI_TEST) &
672                                         SPI_TEST_RXCNT) >>
673                                         SPI_TEST_RXCNT_LSB)*drv_data->n_bytes;
674                         read(drv_data);
675                 } else {
676                         /* Write only transfer */
677                         unmap_dma_buffers(drv_data);
678
679                         flush(drv_data);
680                 }
681
682                 /* End of transfer, update total byte transfered */
683                 msg->actual_length += drv_data->len;
684
685                 /* Move to next transfer */
686                 msg->state = next_transfer(drv_data);
687
688                 /* Schedule transfer tasklet */
689                 tasklet_schedule(&drv_data->pump_transfers);
690
691                 return IRQ_HANDLED;
692         }
693
694         /* Opps problem detected */
695         return IRQ_NONE;
696 }
697
698 static irqreturn_t interrupt_wronly_transfer(struct driver_data *drv_data)
699 {
700         struct spi_message *msg = drv_data->cur_msg;
701         void __iomem *regs = drv_data->regs;
702         u32 status;
703         irqreturn_t handled = IRQ_NONE;
704
705         status = readl(regs + SPI_INT_STATUS);
706
707         if (status & SPI_INTEN_TE) {
708                 /* TXFIFO Empty Interrupt on the last transfered word */
709                 writel(status & ~SPI_INTEN, regs + SPI_INT_STATUS);
710                 dev_dbg(&drv_data->pdev->dev,
711                         "interrupt_wronly_transfer - end of tx\n");
712
713                 flush(drv_data);
714
715                 /* Update total byte transfered */
716                 msg->actual_length += drv_data->len;
717
718                 /* Move to next transfer */
719                 msg->state = next_transfer(drv_data);
720
721                 /* Schedule transfer tasklet */
722                 tasklet_schedule(&drv_data->pump_transfers);
723
724                 return IRQ_HANDLED;
725         } else {
726                 while (status & SPI_STATUS_TH) {
727                         dev_dbg(&drv_data->pdev->dev,
728                                 "interrupt_wronly_transfer - status = 0x%08X\n",
729                                 status);
730
731                         /* Pump data */
732                         if (write(drv_data)) {
733                                 /* End of TXFIFO writes,
734                                    now wait until TXFIFO is empty */
735                                 writel(SPI_INTEN_TE, regs + SPI_INT_STATUS);
736                                 return IRQ_HANDLED;
737                         }
738
739                         status = readl(regs + SPI_INT_STATUS);
740
741                         /* We did something */
742                         handled = IRQ_HANDLED;
743                 }
744         }
745
746         return handled;
747 }
748
749 static irqreturn_t interrupt_transfer(struct driver_data *drv_data)
750 {
751         struct spi_message *msg = drv_data->cur_msg;
752         void __iomem *regs = drv_data->regs;
753         u32 status, control;
754         irqreturn_t handled = IRQ_NONE;
755         unsigned long limit;
756
757         status = readl(regs + SPI_INT_STATUS);
758
759         if (status & SPI_INTEN_TE) {
760                 /* TXFIFO Empty Interrupt on the last transfered word */
761                 writel(status & ~SPI_INTEN, regs + SPI_INT_STATUS);
762                 dev_dbg(&drv_data->pdev->dev,
763                         "interrupt_transfer - end of tx\n");
764
765                 if (msg->state == ERROR_STATE) {
766                         /* RXFIFO overrun was detected and message aborted */
767                         flush(drv_data);
768                 } else {
769                         /* Wait for end of transaction */
770                         do {
771                                 control = readl(regs + SPI_CONTROL);
772                         } while (control & SPI_CONTROL_XCH);
773
774                         /* Release chip select if requested, transfer delays are
775                            handled in pump_transfers */
776                         if (drv_data->cs_change)
777                                 drv_data->cs_control(SPI_CS_DEASSERT);
778
779                         /* Read trailing bytes */
780                         limit = loops_per_jiffy << 1;
781                         while ((read(drv_data) == 0) && limit--);
782
783                         if (limit == 0)
784                                 dev_err(&drv_data->pdev->dev,
785                                         "interrupt_transfer - "
786                                         "trailing byte read failed\n");
787                         else
788                                 dev_dbg(&drv_data->pdev->dev,
789                                         "interrupt_transfer - end of rx\n");
790
791                         /* Update total byte transfered */
792                         msg->actual_length += drv_data->len;
793
794                         /* Move to next transfer */
795                         msg->state = next_transfer(drv_data);
796                 }
797
798                 /* Schedule transfer tasklet */
799                 tasklet_schedule(&drv_data->pump_transfers);
800
801                 return IRQ_HANDLED;
802         } else {
803                 while (status & (SPI_STATUS_TH | SPI_STATUS_RO)) {
804                         dev_dbg(&drv_data->pdev->dev,
805                                 "interrupt_transfer - status = 0x%08X\n",
806                                 status);
807
808                         if (status & SPI_STATUS_RO) {
809                                 /* RXFIFO overrun, abort message end wait
810                                    until TXFIFO is empty */
811                                 writel(SPI_INTEN_TE, regs + SPI_INT_STATUS);
812
813                                 dev_warn(&drv_data->pdev->dev,
814                                         "interrupt_transfer - fifo overun\n"
815                                         "    data not yet written = %d\n"
816                                         "    data not yet read    = %d\n",
817                                         data_to_write(drv_data),
818                                         data_to_read(drv_data));
819
820                                 msg->state = ERROR_STATE;
821
822                                 return IRQ_HANDLED;
823                         }
824
825                         /* Pump data */
826                         read(drv_data);
827                         if (write(drv_data)) {
828                                 /* End of TXFIFO writes,
829                                    now wait until TXFIFO is empty */
830                                 writel(SPI_INTEN_TE, regs + SPI_INT_STATUS);
831                                 return IRQ_HANDLED;
832                         }
833
834                         status = readl(regs + SPI_INT_STATUS);
835
836                         /* We did something */
837                         handled = IRQ_HANDLED;
838                 }
839         }
840
841         return handled;
842 }
843
844 static irqreturn_t spi_int(int irq, void *dev_id)
845 {
846         struct driver_data *drv_data = (struct driver_data *)dev_id;
847
848         if (!drv_data->cur_msg) {
849                 dev_err(&drv_data->pdev->dev,
850                         "spi_int - bad message state\n");
851                 /* Never fail */
852                 return IRQ_HANDLED;
853         }
854
855         return drv_data->transfer_handler(drv_data);
856 }
857
858 static inline u32 spi_speed_hz(u32 data_rate)
859 {
860         return imx_get_perclk2() / (4 << ((data_rate) >> 13));
861 }
862
863 static u32 spi_data_rate(u32 speed_hz)
864 {
865         u32 div;
866         u32 quantized_hz = imx_get_perclk2() >> 2;
867
868         for (div = SPI_PERCLK2_DIV_MIN;
869                 div <= SPI_PERCLK2_DIV_MAX;
870                 div++, quantized_hz >>= 1) {
871                         if (quantized_hz <= speed_hz)
872                                 /* Max available speed LEQ required speed */
873                                 return div << 13;
874         }
875         return SPI_CONTROL_DATARATE_BAD;
876 }
877
878 static void pump_transfers(unsigned long data)
879 {
880         struct driver_data *drv_data = (struct driver_data *)data;
881         struct spi_message *message;
882         struct spi_transfer *transfer, *previous;
883         struct chip_data *chip;
884         void __iomem *regs;
885         u32 tmp, control;
886
887         dev_dbg(&drv_data->pdev->dev, "pump_transfer\n");
888
889         message = drv_data->cur_msg;
890
891         /* Handle for abort */
892         if (message->state == ERROR_STATE) {
893                 message->status = -EIO;
894                 giveback(message, drv_data);
895                 return;
896         }
897
898         /* Handle end of message */
899         if (message->state == DONE_STATE) {
900                 message->status = 0;
901                 giveback(message, drv_data);
902                 return;
903         }
904
905         chip = drv_data->cur_chip;
906
907         /* Delay if requested at end of transfer*/
908         transfer = drv_data->cur_transfer;
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         } else {
916                 /* START_STATE */
917                 message->state = RUNNING_STATE;
918                 drv_data->cs_control = chip->cs_control;
919         }
920
921         transfer = drv_data->cur_transfer;
922         drv_data->tx = (void *)transfer->tx_buf;
923         drv_data->tx_end = drv_data->tx + transfer->len;
924         drv_data->rx = transfer->rx_buf;
925         drv_data->rx_end = drv_data->rx + transfer->len;
926         drv_data->rx_dma = transfer->rx_dma;
927         drv_data->tx_dma = transfer->tx_dma;
928         drv_data->len = transfer->len;
929         drv_data->cs_change = transfer->cs_change;
930         drv_data->rd_only = (drv_data->tx == NULL);
931
932         regs = drv_data->regs;
933         control = readl(regs + SPI_CONTROL);
934
935         /* Bits per word setup */
936         tmp = transfer->bits_per_word;
937         if (tmp == 0) {
938                 /* Use device setup */
939                 tmp = chip->bits_per_word;
940                 drv_data->n_bytes = chip->n_bytes;
941         } else
942                 /* Use per-transfer setup */
943                 drv_data->n_bytes = (tmp <= 8) ? 1 : 2;
944         u32_EDIT(control, SPI_CONTROL_BITCOUNT_MASK, tmp - 1);
945
946         /* Speed setup (surely valid because already checked) */
947         tmp = transfer->speed_hz;
948         if (tmp == 0)
949                 tmp = chip->max_speed_hz;
950         tmp = spi_data_rate(tmp);
951         u32_EDIT(control, SPI_CONTROL_DATARATE, tmp);
952
953         writel(control, regs + SPI_CONTROL);
954
955         /* Assert device chip-select */
956         drv_data->cs_control(SPI_CS_ASSERT);
957
958         /* DMA cannot read/write SPI FIFOs other than 16 bits at a time; hence
959            if bits_per_word is less or equal 8 PIO transfers are performed.
960            Moreover DMA is convinient for transfer length bigger than FIFOs
961            byte size. */
962         if ((drv_data->n_bytes == 2) &&
963                 (drv_data->len > SPI_FIFO_DEPTH*SPI_FIFO_BYTE_WIDTH) &&
964                 (map_dma_buffers(drv_data) == 0)) {
965                 dev_dbg(&drv_data->pdev->dev,
966                         "pump dma transfer\n"
967                         "    tx      = %p\n"
968                         "    tx_dma  = %08X\n"
969                         "    rx      = %p\n"
970                         "    rx_dma  = %08X\n"
971                         "    len     = %d\n",
972                         drv_data->tx,
973                         (unsigned int)drv_data->tx_dma,
974                         drv_data->rx,
975                         (unsigned int)drv_data->rx_dma,
976                         drv_data->len);
977
978                 /* Ensure we have the correct interrupt handler */
979                 drv_data->transfer_handler = dma_transfer;
980
981                 /* Trigger transfer */
982                 writel(readl(regs + SPI_CONTROL) | SPI_CONTROL_XCH,
983                         regs + SPI_CONTROL);
984
985                 /* Setup tx DMA */
986                 if (drv_data->tx)
987                         /* Linear source address */
988                         CCR(drv_data->tx_channel) =
989                                 CCR_DMOD_FIFO |
990                                 CCR_SMOD_LINEAR |
991                                 CCR_SSIZ_32 | CCR_DSIZ_16 |
992                                 CCR_REN;
993                 else
994                         /* Read only transfer -> fixed source address for
995                            dummy write to achive read */
996                         CCR(drv_data->tx_channel) =
997                                 CCR_DMOD_FIFO |
998                                 CCR_SMOD_FIFO |
999                                 CCR_SSIZ_32 | CCR_DSIZ_16 |
1000                                 CCR_REN;
1001
1002                 imx_dma_setup_single(
1003                         drv_data->tx_channel,
1004                         drv_data->tx_dma,
1005                         drv_data->len,
1006                         drv_data->rd_data_phys + 4,
1007                         DMA_MODE_WRITE);
1008
1009                 if (drv_data->rx) {
1010                         /* Setup rx DMA for linear destination address */
1011                         CCR(drv_data->rx_channel) =
1012                                 CCR_DMOD_LINEAR |
1013                                 CCR_SMOD_FIFO |
1014                                 CCR_DSIZ_32 | CCR_SSIZ_16 |
1015                                 CCR_REN;
1016                         imx_dma_setup_single(
1017                                 drv_data->rx_channel,
1018                                 drv_data->rx_dma,
1019                                 drv_data->len,
1020                                 drv_data->rd_data_phys,
1021                                 DMA_MODE_READ);
1022                         imx_dma_enable(drv_data->rx_channel);
1023
1024                         /* Enable SPI interrupt */
1025                         writel(SPI_INTEN_RO, regs + SPI_INT_STATUS);
1026
1027                         /* Set SPI to request DMA service on both
1028                            Rx and Tx half fifo watermark */
1029                         writel(SPI_DMA_RHDEN | SPI_DMA_THDEN, regs + SPI_DMA);
1030                 } else
1031                         /* Write only access -> set SPI to request DMA
1032                            service on Tx half fifo watermark */
1033                         writel(SPI_DMA_THDEN, regs + SPI_DMA);
1034
1035                 imx_dma_enable(drv_data->tx_channel);
1036         } else {
1037                 dev_dbg(&drv_data->pdev->dev,
1038                         "pump pio transfer\n"
1039                         "    tx      = %p\n"
1040                         "    rx      = %p\n"
1041                         "    len     = %d\n",
1042                         drv_data->tx,
1043                         drv_data->rx,
1044                         drv_data->len);
1045
1046                 /* Ensure we have the correct interrupt handler */
1047                 if (drv_data->rx)
1048                         drv_data->transfer_handler = interrupt_transfer;
1049                 else
1050                         drv_data->transfer_handler = interrupt_wronly_transfer;
1051
1052                 /* Enable SPI interrupt */
1053                 if (drv_data->rx)
1054                         writel(SPI_INTEN_TH | SPI_INTEN_RO,
1055                                 regs + SPI_INT_STATUS);
1056                 else
1057                         writel(SPI_INTEN_TH, regs + SPI_INT_STATUS);
1058         }
1059 }
1060
1061 static void pump_messages(struct work_struct *work)
1062 {
1063         struct driver_data *drv_data =
1064                                 container_of(work, struct driver_data, work);
1065         unsigned long flags;
1066
1067         /* Lock queue and check for queue work */
1068         spin_lock_irqsave(&drv_data->lock, flags);
1069         if (list_empty(&drv_data->queue) || drv_data->run == QUEUE_STOPPED) {
1070                 drv_data->busy = 0;
1071                 spin_unlock_irqrestore(&drv_data->lock, flags);
1072                 return;
1073         }
1074
1075         /* Make sure we are not already running a message */
1076         if (drv_data->cur_msg) {
1077                 spin_unlock_irqrestore(&drv_data->lock, flags);
1078                 return;
1079         }
1080
1081         /* Extract head of queue */
1082         drv_data->cur_msg = list_entry(drv_data->queue.next,
1083                                         struct spi_message, queue);
1084         list_del_init(&drv_data->cur_msg->queue);
1085         drv_data->busy = 1;
1086         spin_unlock_irqrestore(&drv_data->lock, flags);
1087
1088         /* Initial message state */
1089         drv_data->cur_msg->state = START_STATE;
1090         drv_data->cur_transfer = list_entry(drv_data->cur_msg->transfers.next,
1091                                                 struct spi_transfer,
1092                                                 transfer_list);
1093
1094         /* Setup the SPI using the per chip configuration */
1095         drv_data->cur_chip = spi_get_ctldata(drv_data->cur_msg->spi);
1096         restore_state(drv_data);
1097
1098         /* Mark as busy and launch transfers */
1099         tasklet_schedule(&drv_data->pump_transfers);
1100 }
1101
1102 static int transfer(struct spi_device *spi, struct spi_message *msg)
1103 {
1104         struct driver_data *drv_data = spi_master_get_devdata(spi->master);
1105         u32 min_speed_hz, max_speed_hz, tmp;
1106         struct spi_transfer *trans;
1107         unsigned long flags;
1108
1109         msg->actual_length = 0;
1110
1111         /* Per transfer setup check */
1112         min_speed_hz = spi_speed_hz(SPI_CONTROL_DATARATE_MIN);
1113         max_speed_hz = spi->max_speed_hz;
1114         list_for_each_entry(trans, &msg->transfers, transfer_list) {
1115                 tmp = trans->bits_per_word;
1116                 if (tmp > 16) {
1117                         dev_err(&drv_data->pdev->dev,
1118                                 "message rejected : "
1119                                 "invalid transfer bits_per_word (%d bits)\n",
1120                                 tmp);
1121                         goto msg_rejected;
1122                 }
1123                 tmp = trans->speed_hz;
1124                 if (tmp) {
1125                         if (tmp < min_speed_hz) {
1126                                 dev_err(&drv_data->pdev->dev,
1127                                         "message rejected : "
1128                                         "device min speed (%d Hz) exceeds "
1129                                         "required transfer speed (%d Hz)\n",
1130                                         min_speed_hz,
1131                                         tmp);
1132                                 goto msg_rejected;
1133                         } else if (tmp > max_speed_hz) {
1134                                 dev_err(&drv_data->pdev->dev,
1135                                         "message rejected : "
1136                                         "transfer speed (%d Hz) exceeds "
1137                                         "device max speed (%d Hz)\n",
1138                                         tmp,
1139                                         max_speed_hz);
1140                                 goto msg_rejected;
1141                         }
1142                 }
1143         }
1144
1145         /* Message accepted */
1146         msg->status = -EINPROGRESS;
1147         msg->state = START_STATE;
1148
1149         spin_lock_irqsave(&drv_data->lock, flags);
1150         if (drv_data->run == QUEUE_STOPPED) {
1151                 spin_unlock_irqrestore(&drv_data->lock, flags);
1152                 return -ESHUTDOWN;
1153         }
1154
1155         list_add_tail(&msg->queue, &drv_data->queue);
1156         if (drv_data->run == QUEUE_RUNNING && !drv_data->busy)
1157                 queue_work(drv_data->workqueue, &drv_data->work);
1158
1159         spin_unlock_irqrestore(&drv_data->lock, flags);
1160         return 0;
1161
1162 msg_rejected:
1163         /* Message rejected and not queued */
1164         msg->status = -EINVAL;
1165         msg->state = ERROR_STATE;
1166         if (msg->complete)
1167                 msg->complete(msg->context);
1168         return -EINVAL;
1169 }
1170
1171 /* the spi->mode bits understood by this driver: */
1172 #define MODEBITS (SPI_CPOL | SPI_CPHA | SPI_CS_HIGH)
1173
1174 /* On first setup bad values must free chip_data memory since will cause
1175    spi_new_device to fail. Bad value setup from protocol driver are simply not
1176    applied and notified to the calling driver. */
1177 static int setup(struct spi_device *spi)
1178 {
1179         struct spi_imx_chip *chip_info;
1180         struct chip_data *chip;
1181         int first_setup = 0;
1182         u32 tmp;
1183         int status = 0;
1184
1185         if (spi->mode & ~MODEBITS) {
1186                 dev_dbg(&spi->dev, "setup: unsupported mode bits %x\n",
1187                         spi->mode & ~MODEBITS);
1188                 return -EINVAL;
1189         }
1190
1191         /* Get controller data */
1192         chip_info = spi->controller_data;
1193
1194         /* Get controller_state */
1195         chip = spi_get_ctldata(spi);
1196         if (chip == NULL) {
1197                 first_setup = 1;
1198
1199                 chip = kzalloc(sizeof(struct chip_data), GFP_KERNEL);
1200                 if (!chip) {
1201                         dev_err(&spi->dev,
1202                                 "setup - cannot allocate controller state\n");
1203                         return -ENOMEM;
1204                 }
1205                 chip->control = SPI_DEFAULT_CONTROL;
1206
1207                 if (chip_info == NULL) {
1208                         /* spi_board_info.controller_data not is supplied */
1209                         chip_info = kzalloc(sizeof(struct spi_imx_chip),
1210                                                 GFP_KERNEL);
1211                         if (!chip_info) {
1212                                 dev_err(&spi->dev,
1213                                         "setup - "
1214                                         "cannot allocate controller data\n");
1215                                 status = -ENOMEM;
1216                                 goto err_first_setup;
1217                         }
1218                         /* Set controller data default value */
1219                         chip_info->enable_loopback =
1220                                                 SPI_DEFAULT_ENABLE_LOOPBACK;
1221                         chip_info->enable_dma = SPI_DEFAULT_ENABLE_DMA;
1222                         chip_info->ins_ss_pulse = 1;
1223                         chip_info->bclk_wait = SPI_DEFAULT_PERIOD_WAIT;
1224                         chip_info->cs_control = null_cs_control;
1225                 }
1226         }
1227
1228         /* Now set controller state based on controller data */
1229
1230         if (first_setup) {
1231                 /* SPI loopback */
1232                 if (chip_info->enable_loopback)
1233                         chip->test = SPI_TEST_LBC;
1234                 else
1235                         chip->test = 0;
1236
1237                 /* SPI dma driven */
1238                 chip->enable_dma = chip_info->enable_dma;
1239
1240                 /* SPI /SS pulse between spi burst */
1241                 if (chip_info->ins_ss_pulse)
1242                         u32_EDIT(chip->control,
1243                                 SPI_CONTROL_SSCTL, SPI_CONTROL_SSCTL_1);
1244                 else
1245                         u32_EDIT(chip->control,
1246                                 SPI_CONTROL_SSCTL, SPI_CONTROL_SSCTL_0);
1247
1248                 /* SPI bclk waits between each bits_per_word spi burst */
1249                 if (chip_info->bclk_wait > SPI_PERIOD_MAX_WAIT) {
1250                         dev_err(&spi->dev,
1251                                 "setup - "
1252                                 "bclk_wait exceeds max allowed (%d)\n",
1253                                 SPI_PERIOD_MAX_WAIT);
1254                         goto err_first_setup;
1255                 }
1256                 chip->period = SPI_PERIOD_CSRC_BCLK |
1257                                 (chip_info->bclk_wait & SPI_PERIOD_WAIT);
1258         }
1259
1260         /* SPI mode */
1261         tmp = spi->mode;
1262         if (tmp & SPI_CS_HIGH) {
1263                 u32_EDIT(chip->control,
1264                                 SPI_CONTROL_SSPOL, SPI_CONTROL_SSPOL_ACT_HIGH);
1265         }
1266         switch (tmp & SPI_MODE_3) {
1267         case SPI_MODE_0:
1268                 tmp = 0;
1269                 break;
1270         case SPI_MODE_1:
1271                 tmp = SPI_CONTROL_PHA_1;
1272                 break;
1273         case SPI_MODE_2:
1274                 tmp = SPI_CONTROL_POL_ACT_LOW;
1275                 break;
1276         default:
1277                 /* SPI_MODE_3 */
1278                 tmp = SPI_CONTROL_PHA_1 | SPI_CONTROL_POL_ACT_LOW;
1279                 break;
1280         }
1281         u32_EDIT(chip->control, SPI_CONTROL_POL | SPI_CONTROL_PHA, tmp);
1282
1283         /* SPI word width */
1284         tmp = spi->bits_per_word;
1285         if (tmp == 0) {
1286                 tmp = 8;
1287                 spi->bits_per_word = 8;
1288         } else if (tmp > 16) {
1289                 status = -EINVAL;
1290                 dev_err(&spi->dev,
1291                         "setup - "
1292                         "invalid bits_per_word (%d)\n",
1293                         tmp);
1294                 if (first_setup)
1295                         goto err_first_setup;
1296                 else {
1297                         /* Undo setup using chip as backup copy */
1298                         tmp = chip->bits_per_word;
1299                         spi->bits_per_word = tmp;
1300                 }
1301         }
1302         chip->bits_per_word = tmp;
1303         u32_EDIT(chip->control, SPI_CONTROL_BITCOUNT_MASK, tmp - 1);
1304         chip->n_bytes = (tmp <= 8) ? 1 : 2;
1305
1306         /* SPI datarate */
1307         tmp = spi_data_rate(spi->max_speed_hz);
1308         if (tmp == SPI_CONTROL_DATARATE_BAD) {
1309                 status = -EINVAL;
1310                 dev_err(&spi->dev,
1311                         "setup - "
1312                         "HW min speed (%d Hz) exceeds required "
1313                         "max speed (%d Hz)\n",
1314                         spi_speed_hz(SPI_CONTROL_DATARATE_MIN),
1315                         spi->max_speed_hz);
1316                 if (first_setup)
1317                         goto err_first_setup;
1318                 else
1319                         /* Undo setup using chip as backup copy */
1320                         spi->max_speed_hz = chip->max_speed_hz;
1321         } else {
1322                 u32_EDIT(chip->control, SPI_CONTROL_DATARATE, tmp);
1323                 /* Actual rounded max_speed_hz */
1324                 tmp = spi_speed_hz(tmp);
1325                 spi->max_speed_hz = tmp;
1326                 chip->max_speed_hz = tmp;
1327         }
1328
1329         /* SPI chip-select management */
1330         if (chip_info->cs_control)
1331                 chip->cs_control = chip_info->cs_control;
1332         else
1333                 chip->cs_control = null_cs_control;
1334
1335         /* Save controller_state */
1336         spi_set_ctldata(spi, chip);
1337
1338         /* Summary */
1339         dev_dbg(&spi->dev,
1340                 "setup succeded\n"
1341                 "    loopback enable   = %s\n"
1342                 "    dma enable        = %s\n"
1343                 "    insert /ss pulse  = %s\n"
1344                 "    period wait       = %d\n"
1345                 "    mode              = %d\n"
1346                 "    bits per word     = %d\n"
1347                 "    min speed         = %d Hz\n"
1348                 "    rounded max speed = %d Hz\n",
1349                 chip->test & SPI_TEST_LBC ? "Yes" : "No",
1350                 chip->enable_dma ? "Yes" : "No",
1351                 chip->control & SPI_CONTROL_SSCTL ? "Yes" : "No",
1352                 chip->period & SPI_PERIOD_WAIT,
1353                 spi->mode,
1354                 spi->bits_per_word,
1355                 spi_speed_hz(SPI_CONTROL_DATARATE_MIN),
1356                 spi->max_speed_hz);
1357         return status;
1358
1359 err_first_setup:
1360         kfree(chip);
1361         return status;
1362 }
1363
1364 static void cleanup(struct spi_device *spi)
1365 {
1366         kfree(spi_get_ctldata(spi));
1367 }
1368
1369 static int __init init_queue(struct driver_data *drv_data)
1370 {
1371         INIT_LIST_HEAD(&drv_data->queue);
1372         spin_lock_init(&drv_data->lock);
1373
1374         drv_data->run = QUEUE_STOPPED;
1375         drv_data->busy = 0;
1376
1377         tasklet_init(&drv_data->pump_transfers,
1378                         pump_transfers, (unsigned long)drv_data);
1379
1380         INIT_WORK(&drv_data->work, pump_messages);
1381         drv_data->workqueue = create_singlethread_workqueue(
1382                                         drv_data->master->dev.parent->bus_id);
1383         if (drv_data->workqueue == NULL)
1384                 return -EBUSY;
1385
1386         return 0;
1387 }
1388
1389 static int start_queue(struct driver_data *drv_data)
1390 {
1391         unsigned long flags;
1392
1393         spin_lock_irqsave(&drv_data->lock, flags);
1394
1395         if (drv_data->run == QUEUE_RUNNING || drv_data->busy) {
1396                 spin_unlock_irqrestore(&drv_data->lock, flags);
1397                 return -EBUSY;
1398         }
1399
1400         drv_data->run = QUEUE_RUNNING;
1401         drv_data->cur_msg = NULL;
1402         drv_data->cur_transfer = NULL;
1403         drv_data->cur_chip = NULL;
1404         spin_unlock_irqrestore(&drv_data->lock, flags);
1405
1406         queue_work(drv_data->workqueue, &drv_data->work);
1407
1408         return 0;
1409 }
1410
1411 static int stop_queue(struct driver_data *drv_data)
1412 {
1413         unsigned long flags;
1414         unsigned limit = 500;
1415         int status = 0;
1416
1417         spin_lock_irqsave(&drv_data->lock, flags);
1418
1419         /* This is a bit lame, but is optimized for the common execution path.
1420          * A wait_queue on the drv_data->busy could be used, but then the common
1421          * execution path (pump_messages) would be required to call wake_up or
1422          * friends on every SPI message. Do this instead */
1423         drv_data->run = QUEUE_STOPPED;
1424         while (!list_empty(&drv_data->queue) && drv_data->busy && limit--) {
1425                 spin_unlock_irqrestore(&drv_data->lock, flags);
1426                 msleep(10);
1427                 spin_lock_irqsave(&drv_data->lock, flags);
1428         }
1429
1430         if (!list_empty(&drv_data->queue) || drv_data->busy)
1431                 status = -EBUSY;
1432
1433         spin_unlock_irqrestore(&drv_data->lock, flags);
1434
1435         return status;
1436 }
1437
1438 static int destroy_queue(struct driver_data *drv_data)
1439 {
1440         int status;
1441
1442         status = stop_queue(drv_data);
1443         if (status != 0)
1444                 return status;
1445
1446         if (drv_data->workqueue)
1447                 destroy_workqueue(drv_data->workqueue);
1448
1449         return 0;
1450 }
1451
1452 static int __init spi_imx_probe(struct platform_device *pdev)
1453 {
1454         struct device *dev = &pdev->dev;
1455         struct spi_imx_master *platform_info;
1456         struct spi_master *master;
1457         struct driver_data *drv_data = NULL;
1458         struct resource *res;
1459         int irq, status = 0;
1460
1461         platform_info = dev->platform_data;
1462         if (platform_info == NULL) {
1463                 dev_err(&pdev->dev, "probe - no platform data supplied\n");
1464                 status = -ENODEV;
1465                 goto err_no_pdata;
1466         }
1467
1468         /* Allocate master with space for drv_data */
1469         master = spi_alloc_master(dev, sizeof(struct driver_data));
1470         if (!master) {
1471                 dev_err(&pdev->dev, "probe - cannot alloc spi_master\n");
1472                 status = -ENOMEM;
1473                 goto err_no_mem;
1474         }
1475         drv_data = spi_master_get_devdata(master);
1476         drv_data->master = master;
1477         drv_data->master_info = platform_info;
1478         drv_data->pdev = pdev;
1479
1480         master->bus_num = pdev->id;
1481         master->num_chipselect = platform_info->num_chipselect;
1482         master->cleanup = cleanup;
1483         master->setup = setup;
1484         master->transfer = transfer;
1485
1486         drv_data->dummy_dma_buf = SPI_DUMMY_u32;
1487
1488         /* Find and map resources */
1489         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1490         if (!res) {
1491                 dev_err(&pdev->dev, "probe - MEM resources not defined\n");
1492                 status = -ENODEV;
1493                 goto err_no_iores;
1494         }
1495         drv_data->ioarea = request_mem_region(res->start,
1496                                                 res->end - res->start + 1,
1497                                                 pdev->name);
1498         if (drv_data->ioarea == NULL) {
1499                 dev_err(&pdev->dev, "probe - cannot reserve region\n");
1500                 status = -ENXIO;
1501                 goto err_no_iores;
1502         }
1503         drv_data->regs = ioremap(res->start, res->end - res->start + 1);
1504         if (drv_data->regs == NULL) {
1505                 dev_err(&pdev->dev, "probe - cannot map IO\n");
1506                 status = -ENXIO;
1507                 goto err_no_iomap;
1508         }
1509         drv_data->rd_data_phys = (dma_addr_t)res->start;
1510
1511         /* Attach to IRQ */
1512         irq = platform_get_irq(pdev, 0);
1513         if (irq < 0) {
1514                 dev_err(&pdev->dev, "probe - IRQ resource not defined\n");
1515                 status = -ENODEV;
1516                 goto err_no_irqres;
1517         }
1518         status = request_irq(irq, spi_int, IRQF_DISABLED, dev->bus_id, drv_data);
1519         if (status < 0) {
1520                 dev_err(&pdev->dev, "probe - cannot get IRQ (%d)\n", status);
1521                 goto err_no_irqres;
1522         }
1523
1524         /* Setup DMA if requested */
1525         drv_data->tx_channel = -1;
1526         drv_data->rx_channel = -1;
1527         if (platform_info->enable_dma) {
1528                 /* Get rx DMA channel */
1529                 status = imx_dma_request_by_prio(&drv_data->rx_channel,
1530                         "spi_imx_rx", DMA_PRIO_HIGH);
1531                 if (status < 0) {
1532                         dev_err(dev,
1533                                 "probe - problem (%d) requesting rx channel\n",
1534                                 status);
1535                         goto err_no_rxdma;
1536                 } else
1537                         imx_dma_setup_handlers(drv_data->rx_channel, NULL,
1538                                                 dma_err_handler, drv_data);
1539
1540                 /* Get tx DMA channel */
1541                 status = imx_dma_request_by_prio(&drv_data->tx_channel,
1542                                                 "spi_imx_tx", DMA_PRIO_MEDIUM);
1543                 if (status < 0) {
1544                         dev_err(dev,
1545                                 "probe - problem (%d) requesting tx channel\n",
1546                                 status);
1547                         imx_dma_free(drv_data->rx_channel);
1548                         goto err_no_txdma;
1549                 } else
1550                         imx_dma_setup_handlers(drv_data->tx_channel,
1551                                                 dma_tx_handler, dma_err_handler,
1552                                                 drv_data);
1553
1554                 /* Set request source and burst length for allocated channels */
1555                 switch (drv_data->pdev->id) {
1556                 case 1:
1557                         /* Using SPI1 */
1558                         RSSR(drv_data->rx_channel) = DMA_REQ_SPI1_R;
1559                         RSSR(drv_data->tx_channel) = DMA_REQ_SPI1_T;
1560                         break;
1561                 case 2:
1562                         /* Using SPI2 */
1563                         RSSR(drv_data->rx_channel) = DMA_REQ_SPI2_R;
1564                         RSSR(drv_data->tx_channel) = DMA_REQ_SPI2_T;
1565                         break;
1566                 default:
1567                         dev_err(dev, "probe - bad SPI Id\n");
1568                         imx_dma_free(drv_data->rx_channel);
1569                         imx_dma_free(drv_data->tx_channel);
1570                         status = -ENODEV;
1571                         goto err_no_devid;
1572                 }
1573                 BLR(drv_data->rx_channel) = SPI_DMA_BLR;
1574                 BLR(drv_data->tx_channel) = SPI_DMA_BLR;
1575         }
1576
1577         /* Load default SPI configuration */
1578         writel(SPI_RESET_START, drv_data->regs + SPI_RESET);
1579         writel(0, drv_data->regs + SPI_RESET);
1580         writel(SPI_DEFAULT_CONTROL, drv_data->regs + SPI_CONTROL);
1581
1582         /* Initial and start queue */
1583         status = init_queue(drv_data);
1584         if (status != 0) {
1585                 dev_err(&pdev->dev, "probe - problem initializing queue\n");
1586                 goto err_init_queue;
1587         }
1588         status = start_queue(drv_data);
1589         if (status != 0) {
1590                 dev_err(&pdev->dev, "probe - problem starting queue\n");
1591                 goto err_start_queue;
1592         }
1593
1594         /* Register with the SPI framework */
1595         platform_set_drvdata(pdev, drv_data);
1596         status = spi_register_master(master);
1597         if (status != 0) {
1598                 dev_err(&pdev->dev, "probe - problem registering spi master\n");
1599                 goto err_spi_register;
1600         }
1601
1602         dev_dbg(dev, "probe succeded\n");
1603         return 0;
1604
1605 err_init_queue:
1606 err_start_queue:
1607 err_spi_register:
1608         destroy_queue(drv_data);
1609
1610 err_no_rxdma:
1611 err_no_txdma:
1612 err_no_devid:
1613         free_irq(irq, drv_data);
1614
1615 err_no_irqres:
1616         iounmap(drv_data->regs);
1617
1618 err_no_iomap:
1619         release_resource(drv_data->ioarea);
1620         kfree(drv_data->ioarea);
1621
1622 err_no_iores:
1623         spi_master_put(master);
1624
1625 err_no_pdata:
1626 err_no_mem:
1627         return status;
1628 }
1629
1630 static int __exit spi_imx_remove(struct platform_device *pdev)
1631 {
1632         struct driver_data *drv_data = platform_get_drvdata(pdev);
1633         int irq;
1634         int status = 0;
1635
1636         if (!drv_data)
1637                 return 0;
1638
1639         tasklet_kill(&drv_data->pump_transfers);
1640
1641         /* Remove the queue */
1642         status = destroy_queue(drv_data);
1643         if (status != 0) {
1644                 dev_err(&pdev->dev, "queue remove failed (%d)\n", status);
1645                 return status;
1646         }
1647
1648         /* Reset SPI */
1649         writel(SPI_RESET_START, drv_data->regs + SPI_RESET);
1650         writel(0, drv_data->regs + SPI_RESET);
1651
1652         /* Release DMA */
1653         if (drv_data->master_info->enable_dma) {
1654                 RSSR(drv_data->rx_channel) = 0;
1655                 RSSR(drv_data->tx_channel) = 0;
1656                 imx_dma_free(drv_data->tx_channel);
1657                 imx_dma_free(drv_data->rx_channel);
1658         }
1659
1660         /* Release IRQ */
1661         irq = platform_get_irq(pdev, 0);
1662         if (irq >= 0)
1663                 free_irq(irq, drv_data);
1664
1665         /* Release map resources */
1666         iounmap(drv_data->regs);
1667         release_resource(drv_data->ioarea);
1668         kfree(drv_data->ioarea);
1669
1670         /* Disconnect from the SPI framework */
1671         spi_unregister_master(drv_data->master);
1672         spi_master_put(drv_data->master);
1673
1674         /* Prevent double remove */
1675         platform_set_drvdata(pdev, NULL);
1676
1677         dev_dbg(&pdev->dev, "remove succeded\n");
1678
1679         return 0;
1680 }
1681
1682 static void spi_imx_shutdown(struct platform_device *pdev)
1683 {
1684         struct driver_data *drv_data = platform_get_drvdata(pdev);
1685
1686         /* Reset SPI */
1687         writel(SPI_RESET_START, drv_data->regs + SPI_RESET);
1688         writel(0, drv_data->regs + SPI_RESET);
1689
1690         dev_dbg(&pdev->dev, "shutdown succeded\n");
1691 }
1692
1693 #ifdef CONFIG_PM
1694
1695 static int spi_imx_suspend(struct platform_device *pdev, pm_message_t state)
1696 {
1697         struct driver_data *drv_data = platform_get_drvdata(pdev);
1698         int status = 0;
1699
1700         status = stop_queue(drv_data);
1701         if (status != 0) {
1702                 dev_warn(&pdev->dev, "suspend cannot stop queue\n");
1703                 return status;
1704         }
1705
1706         dev_dbg(&pdev->dev, "suspended\n");
1707
1708         return 0;
1709 }
1710
1711 static int spi_imx_resume(struct platform_device *pdev)
1712 {
1713         struct driver_data *drv_data = platform_get_drvdata(pdev);
1714         int status = 0;
1715
1716         /* Start the queue running */
1717         status = start_queue(drv_data);
1718         if (status != 0)
1719                 dev_err(&pdev->dev, "problem starting queue (%d)\n", status);
1720         else
1721                 dev_dbg(&pdev->dev, "resumed\n");
1722
1723         return status;
1724 }
1725 #else
1726 #define spi_imx_suspend NULL
1727 #define spi_imx_resume NULL
1728 #endif /* CONFIG_PM */
1729
1730 /* work with hotplug and coldplug */
1731 MODULE_ALIAS("platform:spi_imx");
1732
1733 static struct platform_driver driver = {
1734         .driver = {
1735                 .name = "spi_imx",
1736                 .owner = THIS_MODULE,
1737         },
1738         .remove = __exit_p(spi_imx_remove),
1739         .shutdown = spi_imx_shutdown,
1740         .suspend = spi_imx_suspend,
1741         .resume = spi_imx_resume,
1742 };
1743
1744 static int __init spi_imx_init(void)
1745 {
1746         return platform_driver_probe(&driver, spi_imx_probe);
1747 }
1748 module_init(spi_imx_init);
1749
1750 static void __exit spi_imx_exit(void)
1751 {
1752         platform_driver_unregister(&driver);
1753 }
1754 module_exit(spi_imx_exit);
1755
1756 MODULE_AUTHOR("Andrea Paterniani, <a.paterniani@swapp-eng.it>");
1757 MODULE_DESCRIPTION("iMX SPI Controller Driver");
1758 MODULE_LICENSE("GPL");