29ea5a9137f917f7d7c4e1f38e1c62014f081090
[linux-2.6.git] / arch / arm / mach-tegra / spi_tegra_slave.c
1 /*
2  * arch/arm/mach-tegra/tegra_spi_slave.c
3  *
4  * Tegra slave spi driver for NVIDIA Tegra SoCs
5  *
6  * Copyright (c) 2010, NVIDIA Corporation.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful, but WITHOUT
14  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
16  * more details.
17  *
18  * You should have received a copy of the GNU General Public License along
19  * with this program; if not, write to the Free Software Foundation, Inc.,
20  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21  */
22
23
24 #include <linux/kernel.h>
25 #include <linux/init.h>
26 #include <linux/err.h>
27 #include <linux/platform_device.h>
28 #include <linux/io.h>
29 #include <linux/dma-mapping.h>
30 #include <linux/dmapool.h>
31 #include <linux/clk.h>
32 #include <linux/interrupt.h>
33 #include <linux/delay.h>
34
35 #include <linux/spi/spi.h>
36
37 #include <mach/dma.h>
38 #ifdef CONFIG_DEBUG_FS
39 #include <linux/debugfs.h>
40 #endif
41 #include <mach/spi.h>
42 #include <mach/clk.h>
43
44 #define SLINK_COMMAND           0x000
45 #define   SLINK_BIT_LENGTH(x)           (((x) & 0x1f) << 0)
46 #define   SLINK_WORD_SIZE(x)            (((x) & 0x1f) << 5)
47 #define   SLINK_BOTH_EN                 (1 << 10)
48 #define   SLINK_CS_SW                   (1 << 11)
49 #define   SLINK_CS_VALUE                (1 << 12)
50 #define   SLINK_CS_POLARITY             (1 << 13)
51 #define   SLINK_IDLE_SDA_DRIVE_LOW      (0 << 16)
52 #define   SLINK_IDLE_SDA_DRIVE_HIGH     (1 << 16)
53 #define   SLINK_IDLE_SDA_PULL_LOW       (2 << 16)
54 #define   SLINK_IDLE_SDA_PULL_HIGH      (3 << 16)
55 #define   SLINK_IDLE_SDA_MASK           (3 << 16)
56 #define   SLINK_CS_POLARITY1            (1 << 20)
57 #define   SLINK_CK_SDA                  (1 << 21)
58 #define   SLINK_CS_POLARITY2            (1 << 22)
59 #define   SLINK_CS_POLARITY3            (1 << 23)
60 #define   SLINK_IDLE_SCLK_DRIVE_LOW     (0 << 24)
61 #define   SLINK_IDLE_SCLK_DRIVE_HIGH    (1 << 24)
62 #define   SLINK_IDLE_SCLK_PULL_LOW      (2 << 24)
63 #define   SLINK_IDLE_SCLK_PULL_HIGH     (3 << 24)
64 #define   SLINK_IDLE_SCLK_MASK          (3 << 24)
65 #define   SLINK_M_S                     (1 << 28)
66 #define   SLINK_WAIT                    (1 << 29)
67 #define   SLINK_GO                      (1 << 30)
68 #define   SLINK_ENB                     (1 << 31)
69
70 #define SLINK_COMMAND2          0x004
71 #define   SLINK_LSBFE                   (1 << 0)
72 #define   SLINK_SSOE                    (1 << 1)
73 #define   SLINK_SPIE                    (1 << 4)
74 #define   SLINK_BIDIROE                 (1 << 6)
75 #define   SLINK_MODFEN                  (1 << 7)
76 #define   SLINK_INT_SIZE(x)             (((x) & 0x1f) << 8)
77 #define   SLINK_CS_ACTIVE_BETWEEN       (1 << 17)
78 #define   SLINK_SS_EN_CS(x)             (((x) & 0x3) << 18)
79 #define   SLINK_SS_SETUP(x)             (((x) & 0x3) << 20)
80 #define   SLINK_FIFO_REFILLS_0          (0 << 22)
81 #define   SLINK_FIFO_REFILLS_1          (1 << 22)
82 #define   SLINK_FIFO_REFILLS_2          (2 << 22)
83 #define   SLINK_FIFO_REFILLS_3          (3 << 22)
84 #define   SLINK_FIFO_REFILLS_MASK       (3 << 22)
85 #define   SLINK_WAIT_PACK_INT(x)        (((x) & 0x7) << 26)
86 #define   SLINK_SPC0                    (1 << 29)
87 #define   SLINK_TXEN                    (1 << 30)
88 #define   SLINK_RXEN                    (1 << 31)
89
90 #define SLINK_STATUS            0x008
91 #define   SLINK_COUNT(val)              (((val) >> 0) & 0x1f)
92 #define   SLINK_WORD(val)               (((val) >> 5) & 0x1f)
93 #define   SLINK_BLK_CNT(val)            (((val) >> 0) & 0xffff)
94 #define   SLINK_MODF                    (1 << 16)
95 #define   SLINK_RX_UNF                  (1 << 18)
96 #define   SLINK_TX_OVF                  (1 << 19)
97 #define   SLINK_TX_FULL                 (1 << 20)
98 #define   SLINK_TX_EMPTY                (1 << 21)
99 #define   SLINK_RX_FULL                 (1 << 22)
100 #define   SLINK_RX_EMPTY                (1 << 23)
101 #define   SLINK_TX_UNF                  (1 << 24)
102 #define   SLINK_RX_OVF                  (1 << 25)
103 #define   SLINK_TX_FLUSH                (1 << 26)
104 #define   SLINK_RX_FLUSH                (1 << 27)
105 #define   SLINK_SCLK                    (1 << 28)
106 #define   SLINK_ERR                     (1 << 29)
107 #define   SLINK_RDY                     (1 << 30)
108 #define   SLINK_BSY                     (1 << 31)
109
110 #define SLINK_MAS_DATA          0x010
111 #define SLINK_SLAVE_DATA        0x014
112
113 #define SLINK_DMA_CTL           0x018
114 #define   SLINK_DMA_BLOCK_SIZE(x)       (((x) & 0xffff) << 0)
115 #define   SLINK_TX_TRIG_1               (0 << 16)
116 #define   SLINK_TX_TRIG_4               (1 << 16)
117 #define   SLINK_TX_TRIG_8               (2 << 16)
118 #define   SLINK_TX_TRIG_16              (3 << 16)
119 #define   SLINK_TX_TRIG_MASK            (3 << 16)
120 #define   SLINK_RX_TRIG_1               (0 << 18)
121 #define   SLINK_RX_TRIG_4               (1 << 18)
122 #define   SLINK_RX_TRIG_8               (2 << 18)
123 #define   SLINK_RX_TRIG_16              (3 << 18)
124 #define   SLINK_RX_TRIG_MASK            (3 << 18)
125 #define   SLINK_PACKED                  (1 << 20)
126 #define   SLINK_PACK_SIZE_4             (0 << 21)
127 #define   SLINK_PACK_SIZE_8             (1 << 21)
128 #define   SLINK_PACK_SIZE_16            (2 << 21)
129 #define   SLINK_PACK_SIZE_32            (3 << 21)
130 #define   SLINK_PACK_SIZE_MASK          (3 << 21)
131 #define   SLINK_IE_TXC                  (1 << 26)
132 #define   SLINK_IE_RXC                  (1 << 27)
133 #define   SLINK_DMA_EN                  (1 << 31)
134
135 #define SLINK_STATUS2           0x01c
136 #define   SLINK_TX_FIFO_EMPTY_COUNT(val)        (((val) & 0x3f) >> 0)
137 #define   SLINK_RX_FIFO_FULL_COUNT(val)         (((val) & 0x3f) >> 16)
138
139 #define SLINK_TX_FIFO           0x100
140 #define SLINK_RX_FIFO           0x180
141 #define SLINK_FIFO_DEPTH        0x20
142
143 static const unsigned long spi_tegra_req_sels[] = {
144         TEGRA_DMA_REQ_SEL_SL2B1,
145         TEGRA_DMA_REQ_SEL_SL2B2,
146         TEGRA_DMA_REQ_SEL_SL2B3,
147         TEGRA_DMA_REQ_SEL_SL2B4,
148 #ifdef CONFIG_ARCH_TEGRA_3x_SOC
149         TEGRA_DMA_REQ_SEL_SL2B5,
150         TEGRA_DMA_REQ_SEL_SL2B6,
151 #endif
152 };
153
154 #define BB_LEN                  (16384)
155 #define TX_FIFO_EMPTY_COUNT_MAX         SLINK_TX_FIFO_EMPTY_COUNT(0x20)
156 #define RX_FIFO_FULL_COUNT_ZERO         SLINK_RX_FIFO_FULL_COUNT(0)
157
158 #define SLINK_STATUS2_RESET \
159         (TX_FIFO_EMPTY_COUNT_MAX | \
160         RX_FIFO_FULL_COUNT_ZERO << 16)
161
162 struct spi_tegra_data {
163         struct spi_master       *master;
164         struct platform_device  *pdev;
165         spinlock_t              lock;
166
167         struct clk              *clk;
168         void __iomem            *base;
169         unsigned long           phys;
170
171         u32                     cur_speed;
172
173         struct list_head        queue;
174         struct spi_transfer     *cur;
175         unsigned                cur_pos;
176         unsigned                cur_len;
177         unsigned                cur_bytes_per_word;
178
179         /* The tegra spi controller has a bug which causes the first word
180          * in PIO transactions to be garbage.  Since packed DMA transactions
181          * require transfers to be 4 byte aligned we need a bounce buffer
182          * for the generic case.
183          */
184         struct tegra_dma_req    rx_dma_req;
185         struct tegra_dma_channel *rx_dma;
186         u32                     *rx_bb;
187         dma_addr_t              rx_bb_phys;
188
189         struct tegra_dma_req    tx_dma_req;
190         struct tegra_dma_channel *tx_dma;
191         u32                     *tx_bb;
192         dma_addr_t              tx_bb_phys;
193
194         bool                    is_suspended;
195         unsigned long           save_slink_cmd;
196         callback client_funct;
197         void *client_data;
198
199         u32 rx_complete;
200         u32 tx_complete;
201         bool abort_happen;
202
203         u8 g_bits_per_word;
204         struct dentry *debugfs;
205 };
206
207 static inline unsigned long spi_tegra_readl(struct spi_tegra_data *tspi,
208                                         unsigned long reg)
209 {
210         return readl(tspi->base + reg);
211 }
212
213 static inline void spi_tegra_writel(struct spi_tegra_data *tspi,
214                                         unsigned long val,
215                                         unsigned long reg)
216 {
217         writel(val, tspi->base + reg);
218 }
219
220 static void spi_tegra_clear_status(struct spi_tegra_data *tspi)
221 {
222         unsigned long val;
223         unsigned long val_write = 0;
224
225         val = spi_tegra_readl(tspi, SLINK_STATUS);
226         if (val & SLINK_BSY)
227                 val_write |= SLINK_BSY;
228
229         if (val & SLINK_ERR) {
230                 val_write |= SLINK_ERR;
231                 pr_err("%s ERROR bit set 0x%lx\n", __func__, val);
232                 if (val & SLINK_TX_OVF)
233                         val_write |= SLINK_TX_OVF;
234                 if (val & SLINK_RX_OVF)
235                         val_write |= SLINK_RX_OVF;
236                 if (val & SLINK_RX_UNF)
237                         val_write |= SLINK_RX_UNF;
238                 if (val & SLINK_TX_UNF)
239                         val_write |= SLINK_TX_UNF;
240                 if (!(val & SLINK_TX_EMPTY))
241                         val_write |= SLINK_TX_FLUSH;
242                 if (!(val & SLINK_RX_EMPTY))
243                         val_write |= SLINK_RX_FLUSH;
244         }
245         spi_tegra_writel(tspi, val_write, SLINK_STATUS);
246 }
247
248 static void spi_tegra_go(struct spi_tegra_data *tspi)
249 {
250         unsigned long val;
251         unsigned long test_val;
252         unsigned unused_fifo_size;
253
254         wmb();
255
256         val = spi_tegra_readl(tspi, SLINK_DMA_CTL);
257         val &= ~SLINK_DMA_BLOCK_SIZE(~0) & ~SLINK_DMA_EN;
258         val |= SLINK_DMA_BLOCK_SIZE(tspi->rx_dma_req.size / 4 - 1);
259         spi_tegra_writel(tspi, val, SLINK_DMA_CTL);
260         tegra_dma_enqueue_req(tspi->tx_dma, &tspi->tx_dma_req);
261         tegra_dma_enqueue_req(tspi->rx_dma, &tspi->rx_dma_req);
262
263         val |= SLINK_DMA_EN;
264         val &= ~SLINK_TX_TRIG_MASK & ~SLINK_RX_TRIG_MASK;
265
266         if (tspi->rx_dma_req.size & 0xF)
267                 val |= SLINK_TX_TRIG_1 | SLINK_RX_TRIG_1;
268         else if (((tspi->rx_dma_req.size) >> 4) & 0x1)
269                 val |= SLINK_TX_TRIG_4 | SLINK_RX_TRIG_4;
270         else
271                 val |= SLINK_TX_TRIG_8 | SLINK_RX_TRIG_8;
272
273         /*
274          * TRM 24.1.1.7 wait for the FIFO to be full
275          */
276         test_val = spi_tegra_readl(tspi, SLINK_STATUS2);
277         unused_fifo_size = (tspi->tx_dma_req.size/4) >= SLINK_FIFO_DEPTH ?
278                                 0 :
279                                 SLINK_FIFO_DEPTH - (tspi->tx_dma_req.size/4);
280         while (SLINK_TX_FIFO_EMPTY_COUNT(test_val) != (unused_fifo_size))
281                 test_val = spi_tegra_readl(tspi, SLINK_STATUS2);
282
283         spi_tegra_writel(tspi, val, SLINK_DMA_CTL);
284 }
285
286 static unsigned spi_tegra_fill_tx_fifo(struct spi_tegra_data *tspi,
287                                 struct spi_transfer *t)
288 {
289         unsigned len = min(t->len - tspi->cur_pos, BB_LEN *
290                                 tspi->cur_bytes_per_word);
291         u8 *tx_buf = (u8 *)t->tx_buf + tspi->cur_pos;
292         int i, j;
293         unsigned long val;
294
295         val = spi_tegra_readl(tspi, SLINK_COMMAND);
296         val &= ~SLINK_WORD_SIZE(~0);
297         val |= SLINK_WORD_SIZE(len / tspi->cur_bytes_per_word - 1);
298         spi_tegra_writel(tspi, val, SLINK_COMMAND);
299
300         if (tspi->g_bits_per_word == 32) {
301                 memcpy(tspi->tx_bb, (void *)tx_buf, len);
302         } else {
303                 for (i = 0; i < len; i += tspi->cur_bytes_per_word) {
304                         val = 0;
305                         for (j = 0; j < tspi->cur_bytes_per_word; j++)
306                                 val |=
307                                         tx_buf[i + j] << (tspi->cur_bytes_per_word - j - 1) * 8;
308
309                         tspi->tx_bb[i / tspi->cur_bytes_per_word] = val;
310                 }
311         }
312
313         tspi->tx_dma_req.size = len / tspi->cur_bytes_per_word * 4;
314
315         return len;
316 }
317
318 static unsigned spi_tegra_drain_rx_fifo(struct spi_tegra_data *tspi,
319                                 struct spi_transfer *t)
320 {
321         unsigned len = tspi->cur_len;
322         int i, j;
323         u8 *rx_buf = (u8 *)t->rx_buf + tspi->cur_pos;
324         unsigned long val;
325
326         if (tspi->g_bits_per_word == 32) {
327                 memcpy(rx_buf, (void *)tspi->rx_bb, len);
328         } else {
329                 for (i = 0; i < len; i += tspi->cur_bytes_per_word) {
330                         val = tspi->rx_bb[i / tspi->cur_bytes_per_word];
331                         for (j = 0; j < tspi->cur_bytes_per_word; j++)
332                                 rx_buf[i + j] =
333                                         (val >> (tspi->cur_bytes_per_word - j - 1) * 8) & 0xff;
334                 }
335         }
336
337         return len;
338 }
339
340 int spi_tegra_register_callback(struct spi_device *spi, callback func,
341                                         void *client_data)
342 {
343         struct spi_tegra_data *tspi = spi_master_get_devdata(spi->master);
344
345         if (!tspi || !func)
346                 return -EINVAL;
347         tspi->client_funct = func;
348         tspi->client_data = client_data;
349         return 0;
350 }
351 EXPORT_SYMBOL(spi_tegra_register_callback);
352
353 static void spi_tegra_start_transfer(struct spi_device *spi,
354                                         struct spi_transfer *t)
355 {
356         struct spi_tegra_data *tspi = spi_master_get_devdata(spi->master);
357         unsigned long cs_bit;
358         u32 speed;
359         u8 bits_per_word;
360         unsigned long val;
361
362         speed = t->speed_hz ? t->speed_hz : spi->max_speed_hz;
363         bits_per_word = t->bits_per_word ? t->bits_per_word  :
364                 spi->bits_per_word;
365         tspi->g_bits_per_word = bits_per_word;
366
367         tspi->cur_bytes_per_word = (bits_per_word - 1) / 8 + 1;
368
369         if (speed != tspi->cur_speed)
370                 clk_set_rate(tspi->clk, speed);
371
372         if (tspi->cur_speed == 0)
373                 clk_enable(tspi->clk);
374
375         tspi->cur_speed = speed;
376
377         spi_tegra_clear_status(tspi);
378         val = spi_tegra_readl(tspi, SLINK_COMMAND2);
379         val &= ~(SLINK_SS_EN_CS(~0) | SLINK_RXEN | SLINK_TXEN);
380         if (t->rx_buf)
381                 val |= SLINK_RXEN;
382         if (t->tx_buf)
383                 val |= SLINK_TXEN;
384         val |= SLINK_SS_EN_CS(spi->chip_select);
385         val |= SLINK_SPIE;
386         spi_tegra_writel(tspi, val, SLINK_COMMAND2);
387
388         val = spi_tegra_readl(tspi, SLINK_COMMAND);
389         switch (spi->chip_select) {
390         case 0:
391                 cs_bit = SLINK_CS_POLARITY;
392                 break;
393
394         case 1:
395                 cs_bit = SLINK_CS_POLARITY1;
396                 break;
397
398         case 2:
399                 cs_bit = SLINK_CS_POLARITY2;
400                 break;
401
402         case 4:
403                 cs_bit = SLINK_CS_POLARITY3;
404                 break;
405
406         default:
407                 return;
408         }
409         if (spi->mode & SPI_CS_HIGH)
410                 val |= cs_bit;
411         else
412                 val &= ~cs_bit;
413
414         val &= ~SLINK_BIT_LENGTH(~0);
415         val |= SLINK_BIT_LENGTH(bits_per_word - 1);
416
417         /* FIXME: should probably control CS manually so that we can be sure
418          * it does not go low between transfer and to support delay_usecs
419          * correctly.
420          */
421         val &= ~SLINK_IDLE_SCLK_MASK & ~SLINK_CK_SDA & ~SLINK_CS_SW;
422
423         if (spi->mode & SPI_CPHA)
424                 val |= SLINK_CK_SDA;
425         if (spi->mode & SPI_CPOL)
426                 val |= SLINK_IDLE_SCLK_DRIVE_HIGH;
427         else
428                 val |= SLINK_IDLE_SCLK_DRIVE_LOW;
429
430         val &= ~(SLINK_M_S); /* set slave mode */
431
432         spi_tegra_writel(tspi, val, SLINK_COMMAND);
433         spi_tegra_writel(tspi, SLINK_RX_FLUSH | SLINK_TX_FLUSH, SLINK_STATUS);
434         tspi->cur = t;
435         tspi->cur_pos = 0;
436         tspi->cur_len = spi_tegra_fill_tx_fifo(tspi, t);
437         tspi->rx_dma_req.size = tspi->tx_dma_req.size;
438         tspi->rx_complete = 0;
439         tspi->tx_complete = 0;
440         tspi->abort_happen = false;
441
442         spi_tegra_go(tspi);
443         /* notify client that we're ready for transfer */
444         if (tspi->client_funct)
445                 tspi->client_funct(tspi->client_data);
446 }
447
448 static void spi_tegra_start_message(struct spi_device *spi,
449                                         struct spi_message *m)
450 {
451         struct spi_transfer *t;
452
453         m->actual_length = 0;
454         m->status = 0;
455
456         t = list_first_entry(&m->transfers, struct spi_transfer, transfer_list);
457         spi_tegra_start_transfer(spi, t);
458 }
459
460 static void complete_operation(struct tegra_dma_req *req)
461 {
462         struct spi_tegra_data *tspi = req->dev;
463         unsigned long val;
464         struct spi_message *m;
465         struct spi_device *spi;
466         u32 timeout = 0;
467         u32 temp = 0;
468
469         if (tspi->abort_happen == true) {
470                 unsigned long val_write = 0;
471                 val_write = spi_tegra_readl(tspi, SLINK_STATUS);
472                 val_write = val_write | SLINK_TX_FLUSH | SLINK_RX_FLUSH ;
473
474                 spi_tegra_writel(tspi, val_write, SLINK_STATUS);
475
476                 /*In order to make sure Tx fifo fluch is completed.*/
477                 while (spi_tegra_readl(tspi, SLINK_STATUS)&SLINK_TX_FLUSH)
478                         ;
479                 /*In order to make sure Rx fifo fluch is completed.*/
480                 while (spi_tegra_readl(tspi, SLINK_STATUS)&SLINK_RX_FLUSH)
481                         ;
482                 /*
483                  * rx disable and tx disable
484                  */
485                 val_write = spi_tegra_readl(tspi, SLINK_COMMAND2);
486                 val_write &= ~SLINK_RXEN;
487                 val_write &= ~SLINK_TXEN;
488                 spi_tegra_writel(tspi, val_write, SLINK_COMMAND2);
489
490                 /*
491                  * reset the slink controller
492                  * */
493                 tegra_periph_reset_assert(tspi->clk);
494                 udelay(50);
495                 tegra_periph_reset_deassert(tspi->clk);
496                 udelay(50);
497         }
498
499         /* the SPI controller may come back with both the BSY and RDY bits
500         * set.  In this case we need to wait for the BSY bit to clear so
501         * that we are sure the DMA is finished.  1000 reads was empirically
502         * determined to be long enough.
503         */
504
505         while ((spi_tegra_readl(tspi, SLINK_STATUS) & SLINK_BSY)) {
506                 if (timeout++ > 1000)
507                         break;
508         }
509
510         while ((spi_tegra_readl(tspi, SLINK_STATUS2)) != SLINK_STATUS2_RESET) {
511                 if (temp++ > 50000)
512                         break;
513         }
514
515         spi_tegra_clear_status(tspi);
516
517         val = spi_tegra_readl(tspi, SLINK_STATUS);
518         val |= SLINK_RDY;
519         spi_tegra_writel(tspi, val, SLINK_STATUS);
520
521         m = list_first_entry(&tspi->queue, struct spi_message, queue);
522
523         if ((timeout >= 1000) || (temp >= 50000))
524                 m->status = -EIO;
525
526         spi = m->state;
527
528         tspi->cur_pos += spi_tegra_drain_rx_fifo(tspi, tspi->cur);
529         m->actual_length += tspi->cur_pos;
530
531         if (!list_is_last(&tspi->cur->transfer_list, &m->transfers)) {
532                 tspi->cur = list_first_entry(&tspi->cur->transfer_list,
533                         struct spi_transfer, transfer_list);
534                 spi_tegra_start_transfer(spi, tspi->cur);
535         } else {
536                 list_del(&m->queue);
537
538                 m->complete(m->context);
539
540                 if (!list_empty(&tspi->queue)) {
541                         m = list_first_entry(&tspi->queue, struct spi_message,
542                                 queue);
543                         spi = m->state;
544                         spi_tegra_start_message(spi, m);
545                 } else {
546                         clk_disable(tspi->clk);
547                         tspi->cur_speed = 0;
548                 }
549         }
550 }
551
552 static void tegra_spi_tx_dma_complete(struct tegra_dma_req *req)
553 {
554         struct spi_tegra_data *tspi = req->dev;
555         unsigned long flags;
556
557         spin_lock_irqsave(&tspi->lock, flags);
558
559         (tspi->tx_complete)++;
560
561         if (((tspi->rx_complete) == 1) && ((tspi->tx_complete) == 1))
562                 complete_operation(req);
563
564         spin_unlock_irqrestore(&tspi->lock, flags);
565
566 }
567
568 static void tegra_spi_rx_dma_complete(struct tegra_dma_req *req)
569 {
570         struct spi_tegra_data *tspi = req->dev;
571         unsigned long flags;
572
573         spin_lock_irqsave(&tspi->lock, flags);
574
575         (tspi->rx_complete)++;
576
577         if (((tspi->rx_complete) == 1) && ((tspi->tx_complete) == 1))
578                 complete_operation(req);
579
580         spin_unlock_irqrestore(&tspi->lock, flags);
581 }
582
583 static int spi_tegra_setup(struct spi_device *spi)
584 {
585         dev_dbg(&spi->dev, "setup %d bpw, %scpol, %scpha, %dHz\n",
586                 spi->bits_per_word,
587                 spi->mode & SPI_CPOL ? "" : "~",
588                 spi->mode & SPI_CPHA ? "" : "~",
589                 spi->max_speed_hz);
590
591         return 0;
592 }
593
594 static int spi_tegra_transfer(struct spi_device *spi, struct spi_message *m)
595 {
596         struct spi_tegra_data *tspi = spi_master_get_devdata(spi->master);
597         struct spi_transfer *t;
598         unsigned long flags;
599         int was_empty;
600
601         if (list_empty(&m->transfers) || !m->complete)
602                 return -EINVAL;
603
604         list_for_each_entry(t, &m->transfers, transfer_list) {
605                 if (t->bits_per_word < 0 || t->bits_per_word > 32)
606                         return -EINVAL;
607
608                 if (t->len == 0)
609                         return -EINVAL;
610
611                 if (!t->rx_buf && !t->tx_buf)
612                         return -EINVAL;
613         }
614
615         spin_lock_irqsave(&tspi->lock, flags);
616
617         if (WARN_ON(tspi->is_suspended)) {
618                 spin_unlock_irqrestore(&tspi->lock, flags);
619                 return -EBUSY;
620         }
621
622         m->state = spi;
623
624         was_empty = list_empty(&tspi->queue);
625         list_add_tail(&m->queue, &tspi->queue);
626
627         if (was_empty)
628                 spi_tegra_start_message(spi, m);
629
630         spin_unlock_irqrestore(&tspi->lock, flags);
631
632         return 0;
633 }
634
635 #ifdef CONFIG_DEBUG_FS
636 static int spi_show_regs_open(struct inode *inode, struct file *file)
637 {
638         file->private_data = inode->i_private;
639         return 0;
640 }
641
642 #define SPI_TEGRA_BUFSIZE       512
643 static ssize_t  spi_show_regs(struct file *file, char __user *user_buf,
644                                 size_t count, loff_t *ppos)
645 {
646         struct spi_tegra_data *tspi;
647         char *buf;
648         u32 len = 0;
649         ssize_t ret;
650         unsigned long flags;
651
652         tspi = file->private_data;
653         buf = kzalloc(SPI_TEGRA_BUFSIZE, GFP_KERNEL);
654         if (!buf)
655                 return 0;
656
657         spin_lock_irqsave(&tspi->lock, flags);
658         len += snprintf(buf + len, SPI_TEGRA_BUFSIZE - len,
659                 "SPI registers:\n");
660         len += snprintf(buf + len, SPI_TEGRA_BUFSIZE - len,
661                 "SLINK_STATUS 0x%lx\n", spi_tegra_readl(tspi, SLINK_STATUS));
662         len += snprintf(buf + len, SPI_TEGRA_BUFSIZE - len,
663                 "SLINK_STATUS2 0x%lx\n", spi_tegra_readl(tspi, SLINK_STATUS2));
664         len += snprintf(buf + len, SPI_TEGRA_BUFSIZE - len,
665                 "SLINK_COMMAND 0x%lx\n", spi_tegra_readl(tspi, SLINK_COMMAND));
666         len += snprintf(buf + len, SPI_TEGRA_BUFSIZE - len,
667                 "SLINK_COMMAND2 0x%lx\n", spi_tegra_readl(tspi, SLINK_COMMAND2));
668         len += snprintf(buf + len, SPI_TEGRA_BUFSIZE - len,
669                 "SLINK_DMA_CTL 0x%lx\n", spi_tegra_readl(tspi, SLINK_DMA_CTL));
670         spin_unlock_irqrestore(&tspi->lock, flags);
671         ret =  simple_read_from_buffer(user_buf, count, ppos, buf, len);
672         kfree(buf);
673         return ret;
674 }
675
676 static const struct file_operations tegra_spi_regs_ops = {
677         .owner          = THIS_MODULE,
678         .open           = spi_show_regs_open,
679         .read           = spi_show_regs,
680 };
681
682 static int tegra_spi_debugfs_init(struct spi_tegra_data *tspi)
683 {
684         char name[20] = {0};
685
686         sprintf(name, "%s.%d", tspi->pdev->name, tspi->pdev->id);
687         tspi->debugfs = debugfs_create_dir(name, NULL);
688         if (!tspi->debugfs)
689                 return -ENOMEM;
690         debugfs_create_file("registers", S_IFREG | S_IRUGO,
691                 tspi->debugfs, (void *)tspi, &tegra_spi_regs_ops);
692         return 0;
693 }
694
695 static void tegra_spi_debugfs_remove(struct spi_tegra_data *tspi)
696 {
697         if (tspi->debugfs)
698                 debugfs_remove_recursive(tspi->debugfs);
699 }
700 #endif
701
702 static int __init spi_tegra_probe(struct platform_device *pdev)
703 {
704         struct spi_master       *master;
705         struct spi_tegra_data   *tspi;
706         struct resource         *r;
707         int ret;
708
709         master = spi_alloc_master(&pdev->dev, sizeof *tspi);
710         if (master == NULL) {
711                 dev_err(&pdev->dev, "master allocation failed\n");
712                 return -ENOMEM;
713         }
714
715         /* the spi->mode bits understood by this driver: */
716         master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH;
717
718         if (pdev->id != -1)
719                 master->bus_num = pdev->id;
720
721         master->setup = spi_tegra_setup;
722         master->transfer = spi_tegra_transfer;
723         master->num_chipselect = 4;
724
725         dev_set_drvdata(&pdev->dev, master);
726         tspi = spi_master_get_devdata(master);
727         tspi->master = master;
728         tspi->pdev = pdev;
729         spin_lock_init(&tspi->lock);
730
731         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
732         if (r == NULL) {
733                 ret = -ENODEV;
734                 goto err0;
735         }
736
737         if (!request_mem_region(r->start, (r->end - r->start) + 1,
738                                 dev_name(&pdev->dev))) {
739                 ret = -EBUSY;
740                 goto err0;
741         }
742
743         tspi->phys = r->start;
744         tspi->base = ioremap(r->start, r->end - r->start + 1);
745         if (!tspi->base) {
746                 dev_err(&pdev->dev, "can't ioremap iomem\n");
747                 ret = -ENOMEM;
748                 goto err1;
749         }
750
751         tspi->clk = clk_get(&pdev->dev, NULL);
752         if (IS_ERR_OR_NULL(tspi->clk)) {
753                 dev_err(&pdev->dev, "can not get clock\n");
754                 ret = PTR_ERR(tspi->clk);
755                 goto err2;
756         }
757
758         INIT_LIST_HEAD(&tspi->queue);
759
760         tspi->rx_dma = tegra_dma_allocate_channel(TEGRA_DMA_MODE_ONESHOT);
761         if (!tspi->rx_dma) {
762                 dev_err(&pdev->dev, "can not allocate rx dma channel\n");
763                 ret = -ENODEV;
764                 goto err3;
765         }
766
767         tspi->rx_bb = dma_alloc_coherent(&pdev->dev, sizeof(u32) * BB_LEN,
768                                          &tspi->rx_bb_phys, GFP_KERNEL);
769         if (!tspi->rx_bb) {
770                 dev_err(&pdev->dev, "can not allocate rx bounce buffer\n");
771                 ret = -ENOMEM;
772                 goto err4;
773         }
774
775         memset(&tspi->rx_dma_req, 0, sizeof(struct tegra_dma_req)) ;
776         tspi->rx_dma_req.complete = tegra_spi_rx_dma_complete;
777         tspi->rx_dma_req.to_memory = 1;
778         tspi->rx_dma_req.dest_addr = tspi->rx_bb_phys;
779         tspi->rx_dma_req.virt_addr = tspi->rx_bb ;
780         tspi->rx_dma_req.dest_bus_width = 32;
781         tspi->rx_dma_req.source_addr = tspi->phys + SLINK_RX_FIFO;
782         tspi->rx_dma_req.source_bus_width = 32;
783         tspi->rx_dma_req.source_wrap = 4;
784         tspi->rx_dma_req.dest_wrap = 0 ;
785         tspi->rx_dma_req.req_sel = spi_tegra_req_sels[pdev->id];
786         tspi->rx_dma_req.dev = tspi;
787
788         tspi->tx_dma = tegra_dma_allocate_channel(TEGRA_DMA_MODE_ONESHOT);
789         if (IS_ERR(tspi->tx_dma)) {
790                 dev_err(&pdev->dev, "can not allocate tx dma channel\n");
791                 ret = PTR_ERR(tspi->tx_dma);
792                 goto err5;
793         }
794
795         tspi->tx_bb = dma_alloc_coherent(&pdev->dev, sizeof(u32) * BB_LEN,
796                                          &tspi->tx_bb_phys, GFP_KERNEL);
797         if (!tspi->tx_bb) {
798                 dev_err(&pdev->dev, "can not allocate tx bounce buffer\n");
799                 ret = -ENOMEM;
800                 goto err6;
801         }
802
803         memset(&tspi->tx_dma_req, 0, sizeof(struct tegra_dma_req)) ;
804         tspi->tx_dma_req.complete = tegra_spi_tx_dma_complete;
805         tspi->tx_dma_req.to_memory = 0;
806         tspi->tx_dma_req.dest_addr = tspi->phys + SLINK_TX_FIFO;
807         tspi->tx_dma_req.virt_addr = tspi->tx_bb ;
808         tspi->tx_dma_req.dest_bus_width = 32;
809         tspi->tx_dma_req.dest_wrap = 4;
810         tspi->tx_dma_req.source_wrap = 0 ;
811         tspi->tx_dma_req.source_addr = tspi->tx_bb_phys;
812         tspi->tx_dma_req.source_bus_width = 32;
813         tspi->tx_dma_req.req_sel = spi_tegra_req_sels[pdev->id];
814         tspi->tx_dma_req.dev = tspi;
815
816         ret = spi_register_master(master);
817 #ifdef CONFIG_DEBUG_FS
818         tegra_spi_debugfs_init(tspi);
819 #endif
820         if (ret < 0)
821                 goto err7;
822
823         return ret;
824
825 err7:
826         dma_free_coherent(&pdev->dev, sizeof(u32) * BB_LEN,
827                                 tspi->tx_bb, tspi->tx_bb_phys);
828 err6:
829         tegra_dma_free_channel(tspi->tx_dma);
830 err5:
831         dma_free_coherent(&pdev->dev, sizeof(u32) * BB_LEN,
832                                 tspi->rx_bb, tspi->rx_bb_phys);
833 err4:
834         tegra_dma_free_channel(tspi->rx_dma);
835 err3:
836         clk_put(tspi->clk);
837 err2:
838         iounmap(tspi->base);
839 err1:
840         release_mem_region(r->start, (r->end - r->start) + 1);
841 err0:
842         spi_master_put(master);
843         return ret;
844 }
845
846 static int __devexit spi_tegra_remove(struct platform_device *pdev)
847 {
848         struct spi_master       *master;
849         struct spi_tegra_data   *tspi;
850         struct resource         *r;
851
852         master = dev_get_drvdata(&pdev->dev);
853         tspi = spi_master_get_devdata(master);
854 #ifdef CONFIG_DEBUG_FS
855         tegra_spi_debugfs_remove(tspi);
856 #endif
857         tegra_dma_free_channel(tspi->rx_dma);
858
859         dma_free_coherent(&pdev->dev, sizeof(u32) * BB_LEN,
860                           tspi->rx_bb, tspi->rx_bb_phys);
861
862         clk_put(tspi->clk);
863         iounmap(tspi->base);
864
865         spi_master_put(master);
866         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
867         release_mem_region(r->start, (r->end - r->start) + 1);
868
869         return 0;
870 }
871
872 void spi_tegra_abort_transfer(struct spi_device *spi)
873 {
874         struct spi_tegra_data *tspi = spi_master_get_devdata(spi->master);
875         struct spi_message *m;
876         unsigned long flags;
877
878         spin_lock_irqsave(&tspi->lock, flags);
879         if (((tspi->rx_complete) != 0) || ((tspi->tx_complete) != 0))
880                 spin_unlock_irqrestore(&tspi->lock, flags);
881
882         tspi->abort_happen = true;
883         spin_unlock_irqrestore(&tspi->lock, flags);
884
885         m = list_first_entry(&tspi->queue, struct spi_message, queue);
886         m->status = -EIO;
887
888         tegra_dma_dequeue(tspi->tx_dma);
889         tegra_dma_dequeue(tspi->rx_dma);
890 }
891 EXPORT_SYMBOL(spi_tegra_abort_transfer);
892
893 #ifdef CONFIG_PM
894 static int spi_tegra_suspend(struct platform_device *pdev, pm_message_t state)
895 {
896         struct spi_master       *master;
897         struct spi_tegra_data   *tspi;
898         unsigned long           flags;
899         unsigned                limit = 50;
900
901         master = dev_get_drvdata(&pdev->dev);
902         tspi = spi_master_get_devdata(master);
903         spin_lock_irqsave(&tspi->lock, flags);
904         tspi->is_suspended = true;
905         WARN_ON(!list_empty(&tspi->queue));
906
907         while (!list_empty(&tspi->queue) && limit--) {
908                 spin_unlock_irqrestore(&tspi->lock, flags);
909                 msleep(10);
910                 spin_lock_irqsave(&tspi->lock, flags);
911         }
912
913         tspi->save_slink_cmd = spi_tegra_readl(tspi, SLINK_COMMAND);
914         spin_unlock_irqrestore(&tspi->lock, flags);
915         return 0;
916 }
917
918 static int spi_tegra_resume(struct platform_device *pdev)
919 {
920         struct spi_master       *master;
921         struct spi_tegra_data   *tspi;
922         unsigned long           flags;
923
924         master = dev_get_drvdata(&pdev->dev);
925         tspi = spi_master_get_devdata(master);
926         spin_lock_irqsave(&tspi->lock, flags);
927         clk_enable(tspi->clk);
928         spi_tegra_writel(tspi, tspi->save_slink_cmd, SLINK_COMMAND);
929         clk_disable(tspi->clk);
930         tspi->cur_speed = 0;
931         tspi->is_suspended = false;
932         spin_unlock_irqrestore(&tspi->lock, flags);
933         return 0;
934 }
935 #endif
936
937 MODULE_ALIAS("platform:spi_slave_tegra");
938
939 static struct platform_driver spi_tegra_driver = {
940         .driver = {
941                 .name =         "spi_slave_tegra",
942                 .owner =        THIS_MODULE,
943         },
944         .remove =       __devexit_p(spi_tegra_remove),
945 #ifdef CONFIG_PM
946         .suspend =      spi_tegra_suspend,
947         .resume  =      spi_tegra_resume,
948 #endif
949 };
950
951 static int __init spi_tegra_init(void)
952 {
953         return platform_driver_probe(&spi_tegra_driver, spi_tegra_probe);
954 }
955 module_init(spi_tegra_init);
956
957 static void __exit spi_tegra_exit(void)
958 {
959         platform_driver_unregister(&spi_tegra_driver);
960 }
961 module_exit(spi_tegra_exit);
962
963 MODULE_LICENSE("GPL");