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