?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
microblaze: entry.S: Macro optimization
[linux-2.6.git] / drivers / spi / davinci_spi.c
blobb85090caf7cf57df0a596f131944a13d64588d70
1 /*
2 * Copyright (C) 2009 Texas Instruments.
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 */
18
19 #include <linux/interrupt.h>
20 #include <linux/io.h>
21 #include <linux/gpio.h>
22 #include <linux/module.h>
23 #include <linux/delay.h>
24 #include <linux/platform_device.h>
25 #include <linux/err.h>
26 #include <linux/clk.h>
27 #include <linux/dma-mapping.h>
28 #include <linux/spi/spi.h>
29 #include <linux/spi/spi_bitbang.h>
30 #include <linux/slab.h>
31
32 #include <mach/spi.h>
33 #include <mach/edma.h>
34
35 #define SPI_NO_RESOURCE ((resource_size_t)-1)
36
37 #define SPI_MAX_CHIPSELECT 2
38
39 #define CS_DEFAULT 0xFF
40
41 #define SPI_BUFSIZ (SMP_CACHE_BYTES + 1)
42 #define DAVINCI_DMA_DATA_TYPE_S8 0x01
43 #define DAVINCI_DMA_DATA_TYPE_S16 0x02
44 #define DAVINCI_DMA_DATA_TYPE_S32 0x04
45
46 #define SPIFMT_PHASE_MASK BIT(16)
47 #define SPIFMT_POLARITY_MASK BIT(17)
48 #define SPIFMT_DISTIMER_MASK BIT(18)
49 #define SPIFMT_SHIFTDIR_MASK BIT(20)
50 #define SPIFMT_WAITENA_MASK BIT(21)
51 #define SPIFMT_PARITYENA_MASK BIT(22)
52 #define SPIFMT_ODD_PARITY_MASK BIT(23)
53 #define SPIFMT_WDELAY_MASK 0x3f000000u
54 #define SPIFMT_WDELAY_SHIFT 24
55 #define SPIFMT_CHARLEN_MASK 0x0000001Fu
56
57 /* SPIGCR1 */
58 #define SPIGCR1_SPIENA_MASK 0x01000000u
59
60 /* SPIPC0 */
61 #define SPIPC0_DIFUN_MASK BIT(11) /* MISO */
62 #define SPIPC0_DOFUN_MASK BIT(10) /* MOSI */
63 #define SPIPC0_CLKFUN_MASK BIT(9) /* CLK */
64 #define SPIPC0_SPIENA_MASK BIT(8) /* nREADY */
65 #define SPIPC0_EN1FUN_MASK BIT(1)
66 #define SPIPC0_EN0FUN_MASK BIT(0)
67
68 #define SPIINT_MASKALL 0x0101035F
69 #define SPI_INTLVL_1 0x000001FFu
70 #define SPI_INTLVL_0 0x00000000u
71
72 /* SPIDAT1 */
73 #define SPIDAT1_CSHOLD_SHIFT 28
74 #define SPIDAT1_CSNR_SHIFT 16
75 #define SPIGCR1_CLKMOD_MASK BIT(1)
76 #define SPIGCR1_MASTER_MASK BIT(0)
77 #define SPIGCR1_LOOPBACK_MASK BIT(16)
78
79 /* SPIBUF */
80 #define SPIBUF_TXFULL_MASK BIT(29)
81 #define SPIBUF_RXEMPTY_MASK BIT(31)
82
83 /* Error Masks */
84 #define SPIFLG_DLEN_ERR_MASK BIT(0)
85 #define SPIFLG_TIMEOUT_MASK BIT(1)
86 #define SPIFLG_PARERR_MASK BIT(2)
87 #define SPIFLG_DESYNC_MASK BIT(3)
88 #define SPIFLG_BITERR_MASK BIT(4)
89 #define SPIFLG_OVRRUN_MASK BIT(6)
90 #define SPIFLG_RX_INTR_MASK BIT(8)
91 #define SPIFLG_TX_INTR_MASK BIT(9)
92 #define SPIFLG_BUF_INIT_ACTIVE_MASK BIT(24)
93 #define SPIFLG_MASK (SPIFLG_DLEN_ERR_MASK \
94 | SPIFLG_TIMEOUT_MASK | SPIFLG_PARERR_MASK \
95 | SPIFLG_DESYNC_MASK | SPIFLG_BITERR_MASK \
96 | SPIFLG_OVRRUN_MASK | SPIFLG_RX_INTR_MASK \
97 | SPIFLG_TX_INTR_MASK \
98 | SPIFLG_BUF_INIT_ACTIVE_MASK)
99
100 #define SPIINT_DLEN_ERR_INTR BIT(0)
101 #define SPIINT_TIMEOUT_INTR BIT(1)
102 #define SPIINT_PARERR_INTR BIT(2)
103 #define SPIINT_DESYNC_INTR BIT(3)
104 #define SPIINT_BITERR_INTR BIT(4)
105 #define SPIINT_OVRRUN_INTR BIT(6)
106 #define SPIINT_RX_INTR BIT(8)
107 #define SPIINT_TX_INTR BIT(9)
108 #define SPIINT_DMA_REQ_EN BIT(16)
109 #define SPIINT_ENABLE_HIGHZ BIT(24)
110
111 #define SPI_T2CDELAY_SHIFT 16
112 #define SPI_C2TDELAY_SHIFT 24
113
114 /* SPI Controller registers */
115 #define SPIGCR0 0x00
116 #define SPIGCR1 0x04
117 #define SPIINT 0x08
118 #define SPILVL 0x0c
119 #define SPIFLG 0x10
120 #define SPIPC0 0x14
121 #define SPIPC1 0x18
122 #define SPIPC2 0x1c
123 #define SPIPC3 0x20
124 #define SPIPC4 0x24
125 #define SPIPC5 0x28
126 #define SPIPC6 0x2c
127 #define SPIPC7 0x30
128 #define SPIPC8 0x34
129 #define SPIDAT0 0x38
130 #define SPIDAT1 0x3c
131 #define SPIBUF 0x40
132 #define SPIEMU 0x44
133 #define SPIDELAY 0x48
134 #define SPIDEF 0x4c
135 #define SPIFMT0 0x50
136 #define SPIFMT1 0x54
137 #define SPIFMT2 0x58
138 #define SPIFMT3 0x5c
139 #define TGINTVEC0 0x60
140 #define TGINTVEC1 0x64
141
142 struct davinci_spi_slave {
143 u32 cmd_to_write;
144 u32 clk_ctrl_to_write;
145 u32 bytes_per_word;
146 u8 active_cs;
147 };
148
149 /* We have 2 DMA channels per CS, one for RX and one for TX */
150 struct davinci_spi_dma {
151 int dma_tx_channel;
152 int dma_rx_channel;
153 int dma_tx_sync_dev;
154 int dma_rx_sync_dev;
155 enum dma_event_q eventq;
156
157 struct completion dma_tx_completion;
158 struct completion dma_rx_completion;
159 };
160
161 /* SPI Controller driver's private data. */
162 struct davinci_spi {
163 struct spi_bitbang bitbang;
164 struct clk *clk;
165
166 u8 version;
167 resource_size_t pbase;
168 void __iomem *base;
169 size_t region_size;
170 u32 irq;
171 struct completion done;
172
173 const void *tx;
174 void *rx;
175 u8 *tmp_buf;
176 int count;
177 struct davinci_spi_dma *dma_channels;
178 struct davinci_spi_platform_data *pdata;
179
180 void (*get_rx)(u32 rx_data, struct davinci_spi *);
181 u32 (*get_tx)(struct davinci_spi *);
182
183 struct davinci_spi_slave slave[SPI_MAX_CHIPSELECT];
184 };
185
186 static unsigned use_dma;
187
188 static void davinci_spi_rx_buf_u8(u32 data, struct davinci_spi *davinci_spi)
189 {
190 u8 *rx = davinci_spi->rx;
191
192 *rx++ = (u8)data;
193 davinci_spi->rx = rx;
194 }
195
196 static void davinci_spi_rx_buf_u16(u32 data, struct davinci_spi *davinci_spi)
197 {
198 u16 *rx = davinci_spi->rx;
199
200 *rx++ = (u16)data;
201 davinci_spi->rx = rx;
202 }
203
204 static u32 davinci_spi_tx_buf_u8(struct davinci_spi *davinci_spi)
205 {
206 u32 data;
207 const u8 *tx = davinci_spi->tx;
208
209 data = *tx++;
210 davinci_spi->tx = tx;
211 return data;
212 }
213
214 static u32 davinci_spi_tx_buf_u16(struct davinci_spi *davinci_spi)
215 {
216 u32 data;
217 const u16 *tx = davinci_spi->tx;
218
219 data = *tx++;
220 davinci_spi->tx = tx;
221 return data;
222 }
223
224 static inline void set_io_bits(void __iomem *addr, u32 bits)
225 {
226 u32 v = ioread32(addr);
227
228 v |= bits;
229 iowrite32(v, addr);
230 }
231
232 static inline void clear_io_bits(void __iomem *addr, u32 bits)
233 {
234 u32 v = ioread32(addr);
235
236 v &= ~bits;
237 iowrite32(v, addr);
238 }
239
240 static inline void set_fmt_bits(void __iomem *addr, u32 bits, int cs_num)
241 {
242 set_io_bits(addr + SPIFMT0 + (0x4 * cs_num), bits);
243 }
244
245 static inline void clear_fmt_bits(void __iomem *addr, u32 bits, int cs_num)
246 {
247 clear_io_bits(addr + SPIFMT0 + (0x4 * cs_num), bits);
248 }
249
250 static void davinci_spi_set_dma_req(const struct spi_device *spi, int enable)
251 {
252 struct davinci_spi *davinci_spi = spi_master_get_devdata(spi->master);
253
254 if (enable)
255 set_io_bits(davinci_spi->base + SPIINT, SPIINT_DMA_REQ_EN);
256 else
257 clear_io_bits(davinci_spi->base + SPIINT, SPIINT_DMA_REQ_EN);
258 }
259
260 /*
261 * Interface to control the chip select signal
262 */
263 static void davinci_spi_chipselect(struct spi_device *spi, int value)
264 {
265 struct davinci_spi *davinci_spi;
266 struct davinci_spi_platform_data *pdata;
267 u32 data1_reg_val = 0;
268
269 davinci_spi = spi_master_get_devdata(spi->master);
270 pdata = davinci_spi->pdata;
271
272 /*
273 * Board specific chip select logic decides the polarity and cs
274 * line for the controller
275 */
276 if (value == BITBANG_CS_INACTIVE) {
277 set_io_bits(davinci_spi->base + SPIDEF, CS_DEFAULT);
278
279 data1_reg_val |= CS_DEFAULT << SPIDAT1_CSNR_SHIFT;
280 iowrite32(data1_reg_val, davinci_spi->base + SPIDAT1);
281
282 while ((ioread32(davinci_spi->base + SPIBUF)
283 & SPIBUF_RXEMPTY_MASK) == 0)
284 cpu_relax();
285 }
286 }
287
288 /**
289 * davinci_spi_setup_transfer - This functions will determine transfer method
290 * @spi: spi device on which data transfer to be done
291 * @t: spi transfer in which transfer info is filled
292 *
293 * This function determines data transfer method (8/16/32 bit transfer).
294 * It will also set the SPI Clock Control register according to
295 * SPI slave device freq.
296 */
297 static int davinci_spi_setup_transfer(struct spi_device *spi,
298 struct spi_transfer *t)
299 {
300
301 struct davinci_spi *davinci_spi;
302 struct davinci_spi_platform_data *pdata;
303 u8 bits_per_word = 0;
304 u32 hz = 0, prescale = 0, clkspeed;
305
306 davinci_spi = spi_master_get_devdata(spi->master);
307 pdata = davinci_spi->pdata;
308
309 if (t) {
310 bits_per_word = t->bits_per_word;
311 hz = t->speed_hz;
312 }
313
314 /* if bits_per_word is not set then set it default */
315 if (!bits_per_word)
316 bits_per_word = spi->bits_per_word;
317
318 /*
319 * Assign function pointer to appropriate transfer method
320 * 8bit, 16bit or 32bit transfer
321 */
322 if (bits_per_word <= 8 && bits_per_word >= 2) {
323 davinci_spi->get_rx = davinci_spi_rx_buf_u8;
324 davinci_spi->get_tx = davinci_spi_tx_buf_u8;
325 davinci_spi->slave[spi->chip_select].bytes_per_word = 1;
326 } else if (bits_per_word <= 16 && bits_per_word >= 2) {
327 davinci_spi->get_rx = davinci_spi_rx_buf_u16;
328 davinci_spi->get_tx = davinci_spi_tx_buf_u16;
329 davinci_spi->slave[spi->chip_select].bytes_per_word = 2;
330 } else
331 return -EINVAL;
332
333 if (!hz)
334 hz = spi->max_speed_hz;
335
336 clear_fmt_bits(davinci_spi->base, SPIFMT_CHARLEN_MASK,
337 spi->chip_select);
338 set_fmt_bits(davinci_spi->base, bits_per_word & 0x1f,
339 spi->chip_select);
340
341 clkspeed = clk_get_rate(davinci_spi->clk);
342 if (hz > clkspeed / 2)
343 prescale = 1 << 8;
344 if (hz < clkspeed / 256)
345 prescale = 255 << 8;
346 if (!prescale)
347 prescale = ((clkspeed / hz - 1) << 8) & 0x0000ff00;
348
349 clear_fmt_bits(davinci_spi->base, 0x0000ff00, spi->chip_select);
350 set_fmt_bits(davinci_spi->base, prescale, spi->chip_select);
351
352 return 0;
353 }
354
355 static void davinci_spi_dma_rx_callback(unsigned lch, u16 ch_status, void *data)
356 {
357 struct spi_device *spi = (struct spi_device *)data;
358 struct davinci_spi *davinci_spi;
359 struct davinci_spi_dma *davinci_spi_dma;
360 struct davinci_spi_platform_data *pdata;
361
362 davinci_spi = spi_master_get_devdata(spi->master);
363 davinci_spi_dma = &(davinci_spi->dma_channels[spi->chip_select]);
364 pdata = davinci_spi->pdata;
365
366 if (ch_status == DMA_COMPLETE)
367 edma_stop(davinci_spi_dma->dma_rx_channel);
368 else
369 edma_clean_channel(davinci_spi_dma->dma_rx_channel);
370
371 complete(&davinci_spi_dma->dma_rx_completion);
372 /* We must disable the DMA RX request */
373 davinci_spi_set_dma_req(spi, 0);
374 }
375
376 static void davinci_spi_dma_tx_callback(unsigned lch, u16 ch_status, void *data)
377 {
378 struct spi_device *spi = (struct spi_device *)data;
379 struct davinci_spi *davinci_spi;
380 struct davinci_spi_dma *davinci_spi_dma;
381 struct davinci_spi_platform_data *pdata;
382
383 davinci_spi = spi_master_get_devdata(spi->master);
384 davinci_spi_dma = &(davinci_spi->dma_channels[spi->chip_select]);
385 pdata = davinci_spi->pdata;
386
387 if (ch_status == DMA_COMPLETE)
388 edma_stop(davinci_spi_dma->dma_tx_channel);
389 else
390 edma_clean_channel(davinci_spi_dma->dma_tx_channel);
391
392 complete(&davinci_spi_dma->dma_tx_completion);
393 /* We must disable the DMA TX request */
394 davinci_spi_set_dma_req(spi, 0);
395 }
396
397 static int davinci_spi_request_dma(struct spi_device *spi)
398 {
399 struct davinci_spi *davinci_spi;
400 struct davinci_spi_dma *davinci_spi_dma;
401 struct davinci_spi_platform_data *pdata;
402 struct device *sdev;
403 int r;
404
405 davinci_spi = spi_master_get_devdata(spi->master);
406 davinci_spi_dma = &davinci_spi->dma_channels[spi->chip_select];
407 pdata = davinci_spi->pdata;
408 sdev = davinci_spi->bitbang.master->dev.parent;
409
410 r = edma_alloc_channel(davinci_spi_dma->dma_rx_sync_dev,
411 davinci_spi_dma_rx_callback, spi,
412 davinci_spi_dma->eventq);
413 if (r < 0) {
414 dev_dbg(sdev, "Unable to request DMA channel for SPI RX\n");
415 return -EAGAIN;
416 }
417 davinci_spi_dma->dma_rx_channel = r;
418 r = edma_alloc_channel(davinci_spi_dma->dma_tx_sync_dev,
419 davinci_spi_dma_tx_callback, spi,
420 davinci_spi_dma->eventq);
421 if (r < 0) {
422 edma_free_channel(davinci_spi_dma->dma_rx_channel);
423 davinci_spi_dma->dma_rx_channel = -1;
424 dev_dbg(sdev, "Unable to request DMA channel for SPI TX\n");
425 return -EAGAIN;
426 }
427 davinci_spi_dma->dma_tx_channel = r;
428
429 return 0;
430 }
431
432 /**
433 * davinci_spi_setup - This functions will set default transfer method
434 * @spi: spi device on which data transfer to be done
435 *
436 * This functions sets the default transfer method.
437 */
438
439 static int davinci_spi_setup(struct spi_device *spi)
440 {
441 int retval;
442 struct davinci_spi *davinci_spi;
443 struct davinci_spi_dma *davinci_spi_dma;
444 struct device *sdev;
445
446 davinci_spi = spi_master_get_devdata(spi->master);
447 sdev = davinci_spi->bitbang.master->dev.parent;
448
449 /* if bits per word length is zero then set it default 8 */
450 if (!spi->bits_per_word)
451 spi->bits_per_word = 8;
452
453 davinci_spi->slave[spi->chip_select].cmd_to_write = 0;
454
455 if (use_dma && davinci_spi->dma_channels) {
456 davinci_spi_dma = &davinci_spi->dma_channels[spi->chip_select];
457
458 if ((davinci_spi_dma->dma_rx_channel == -1)
459 || (davinci_spi_dma->dma_tx_channel == -1)) {
460 retval = davinci_spi_request_dma(spi);
461 if (retval < 0)
462 return retval;
463 }
464 }
465
466 /*
467 * SPI in DaVinci and DA8xx operate between
468 * 600 KHz and 50 MHz
469 */
470 if (spi->max_speed_hz < 600000 || spi->max_speed_hz > 50000000) {
471 dev_dbg(sdev, "Operating frequency is not in acceptable "
472 "range\n");
473 return -EINVAL;
474 }
475
476 /*
477 * Set up SPIFMTn register, unique to this chipselect.
478 *
479 * NOTE: we could do all of these with one write. Also, some
480 * of the "version 2" features are found in chips that don't
481 * support all of them...
482 */
483 if (spi->mode & SPI_LSB_FIRST)
484 set_fmt_bits(davinci_spi->base, SPIFMT_SHIFTDIR_MASK,
485 spi->chip_select);
486 else
487 clear_fmt_bits(davinci_spi->base, SPIFMT_SHIFTDIR_MASK,
488 spi->chip_select);
489
490 if (spi->mode & SPI_CPOL)
491 set_fmt_bits(davinci_spi->base, SPIFMT_POLARITY_MASK,
492 spi->chip_select);
493 else
494 clear_fmt_bits(davinci_spi->base, SPIFMT_POLARITY_MASK,
495 spi->chip_select);
496
497 if (!(spi->mode & SPI_CPHA))
498 set_fmt_bits(davinci_spi->base, SPIFMT_PHASE_MASK,
499 spi->chip_select);
500 else
501 clear_fmt_bits(davinci_spi->base, SPIFMT_PHASE_MASK,
502 spi->chip_select);
503
504 /*
505 * Version 1 hardware supports two basic SPI modes:
506 * - Standard SPI mode uses 4 pins, with chipselect
507 * - 3 pin SPI is a 4 pin variant without CS (SPI_NO_CS)
508 * (distinct from SPI_3WIRE, with just one data wire;
509 * or similar variants without MOSI or without MISO)
510 *
511 * Version 2 hardware supports an optional handshaking signal,
512 * so it can support two more modes:
513 * - 5 pin SPI variant is standard SPI plus SPI_READY
514 * - 4 pin with enable is (SPI_READY | SPI_NO_CS)
515 */
516
517 if (davinci_spi->version == SPI_VERSION_2) {
518 clear_fmt_bits(davinci_spi->base, SPIFMT_WDELAY_MASK,
519 spi->chip_select);
520 set_fmt_bits(davinci_spi->base,
521 (davinci_spi->pdata->wdelay
522 << SPIFMT_WDELAY_SHIFT)
523 & SPIFMT_WDELAY_MASK,
524 spi->chip_select);
525
526 if (davinci_spi->pdata->odd_parity)
527 set_fmt_bits(davinci_spi->base,
528 SPIFMT_ODD_PARITY_MASK,
529 spi->chip_select);
530 else
531 clear_fmt_bits(davinci_spi->base,
532 SPIFMT_ODD_PARITY_MASK,
533 spi->chip_select);
534
535 if (davinci_spi->pdata->parity_enable)
536 set_fmt_bits(davinci_spi->base,
537 SPIFMT_PARITYENA_MASK,
538 spi->chip_select);
539 else
540 clear_fmt_bits(davinci_spi->base,
541 SPIFMT_PARITYENA_MASK,
542 spi->chip_select);
543
544 if (davinci_spi->pdata->wait_enable)
545 set_fmt_bits(davinci_spi->base,
546 SPIFMT_WAITENA_MASK,
547 spi->chip_select);
548 else
549 clear_fmt_bits(davinci_spi->base,
550 SPIFMT_WAITENA_MASK,
551 spi->chip_select);
552
553 if (davinci_spi->pdata->timer_disable)
554 set_fmt_bits(davinci_spi->base,
555 SPIFMT_DISTIMER_MASK,
556 spi->chip_select);
557 else
558 clear_fmt_bits(davinci_spi->base,
559 SPIFMT_DISTIMER_MASK,
560 spi->chip_select);
561 }
562
563 retval = davinci_spi_setup_transfer(spi, NULL);
564
565 return retval;
566 }
567
568 static void davinci_spi_cleanup(struct spi_device *spi)
569 {
570 struct davinci_spi *davinci_spi = spi_master_get_devdata(spi->master);
571 struct davinci_spi_dma *davinci_spi_dma;
572
573 davinci_spi_dma = &davinci_spi->dma_channels[spi->chip_select];
574
575 if (use_dma && davinci_spi->dma_channels) {
576 davinci_spi_dma = &davinci_spi->dma_channels[spi->chip_select];
577
578 if ((davinci_spi_dma->dma_rx_channel != -1)
579 && (davinci_spi_dma->dma_tx_channel != -1)) {
580 edma_free_channel(davinci_spi_dma->dma_tx_channel);
581 edma_free_channel(davinci_spi_dma->dma_rx_channel);
582 }
583 }
584 }
585
586 static int davinci_spi_bufs_prep(struct spi_device *spi,
587 struct davinci_spi *davinci_spi)
588 {
589 int op_mode = 0;
590
591 /*
592 * REVISIT unless devices disagree about SPI_LOOP or
593 * SPI_READY (SPI_NO_CS only allows one device!), this
594 * should not need to be done before each message...
595 * optimize for both flags staying cleared.
596 */
597
598 op_mode = SPIPC0_DIFUN_MASK
599 | SPIPC0_DOFUN_MASK
600 | SPIPC0_CLKFUN_MASK;
601 if (!(spi->mode & SPI_NO_CS))
602 op_mode |= 1 << spi->chip_select;
603 if (spi->mode & SPI_READY)
604 op_mode |= SPIPC0_SPIENA_MASK;
605
606 iowrite32(op_mode, davinci_spi->base + SPIPC0);
607
608 if (spi->mode & SPI_LOOP)
609 set_io_bits(davinci_spi->base + SPIGCR1,
610 SPIGCR1_LOOPBACK_MASK);
611 else
612 clear_io_bits(davinci_spi->base + SPIGCR1,
613 SPIGCR1_LOOPBACK_MASK);
614
615 return 0;
616 }
617
618 static int davinci_spi_check_error(struct davinci_spi *davinci_spi,
619 int int_status)
620 {
621 struct device *sdev = davinci_spi->bitbang.master->dev.parent;
622
623 if (int_status & SPIFLG_TIMEOUT_MASK) {
624 dev_dbg(sdev, "SPI Time-out Error\n");
625 return -ETIMEDOUT;
626 }
627 if (int_status & SPIFLG_DESYNC_MASK) {
628 dev_dbg(sdev, "SPI Desynchronization Error\n");
629 return -EIO;
630 }
631 if (int_status & SPIFLG_BITERR_MASK) {
632 dev_dbg(sdev, "SPI Bit error\n");
633 return -EIO;
634 }
635
636 if (davinci_spi->version == SPI_VERSION_2) {
637 if (int_status & SPIFLG_DLEN_ERR_MASK) {
638 dev_dbg(sdev, "SPI Data Length Error\n");
639 return -EIO;
640 }
641 if (int_status & SPIFLG_PARERR_MASK) {
642 dev_dbg(sdev, "SPI Parity Error\n");
643 return -EIO;
644 }
645 if (int_status & SPIFLG_OVRRUN_MASK) {
646 dev_dbg(sdev, "SPI Data Overrun error\n");
647 return -EIO;
648 }
649 if (int_status & SPIFLG_TX_INTR_MASK) {
650 dev_dbg(sdev, "SPI TX intr bit set\n");
651 return -EIO;
652 }
653 if (int_status & SPIFLG_BUF_INIT_ACTIVE_MASK) {
654 dev_dbg(sdev, "SPI Buffer Init Active\n");
655 return -EBUSY;
656 }
657 }
658
659 return 0;
660 }
661
662 /**
663 * davinci_spi_bufs - functions which will handle transfer data
664 * @spi: spi device on which data transfer to be done
665 * @t: spi transfer in which transfer info is filled
666 *
667 * This function will put data to be transferred into data register
668 * of SPI controller and then wait until the completion will be marked
669 * by the IRQ Handler.
670 */
671 static int davinci_spi_bufs_pio(struct spi_device *spi, struct spi_transfer *t)
672 {
673 struct davinci_spi *davinci_spi;
674 int int_status, count, ret;
675 u8 conv, tmp;
676 u32 tx_data, data1_reg_val;
677 u32 buf_val, flg_val;
678 struct davinci_spi_platform_data *pdata;
679
680 davinci_spi = spi_master_get_devdata(spi->master);
681 pdata = davinci_spi->pdata;
682
683 davinci_spi->tx = t->tx_buf;
684 davinci_spi->rx = t->rx_buf;
685
686 /* convert len to words based on bits_per_word */
687 conv = davinci_spi->slave[spi->chip_select].bytes_per_word;
688 davinci_spi->count = t->len / conv;
689
690 INIT_COMPLETION(davinci_spi->done);
691
692 ret = davinci_spi_bufs_prep(spi, davinci_spi);
693 if (ret)
694 return ret;
695
696 /* Enable SPI */
697 set_io_bits(davinci_spi->base + SPIGCR1, SPIGCR1_SPIENA_MASK);
698
699 iowrite32(0 | (pdata->c2tdelay << SPI_C2TDELAY_SHIFT) |
700 (pdata->t2cdelay << SPI_T2CDELAY_SHIFT),
701 davinci_spi->base + SPIDELAY);
702
703 count = davinci_spi->count;
704 data1_reg_val = pdata->cs_hold << SPIDAT1_CSHOLD_SHIFT;
705 tmp = ~(0x1 << spi->chip_select);
706
707 clear_io_bits(davinci_spi->base + SPIDEF, ~tmp);
708
709 data1_reg_val |= tmp << SPIDAT1_CSNR_SHIFT;
710
711 while ((ioread32(davinci_spi->base + SPIBUF)
712 & SPIBUF_RXEMPTY_MASK) == 0)
713 cpu_relax();
714
715 /* Determine the command to execute READ or WRITE */
716 if (t->tx_buf) {
717 clear_io_bits(davinci_spi->base + SPIINT, SPIINT_MASKALL);
718
719 while (1) {
720 tx_data = davinci_spi->get_tx(davinci_spi);
721
722 data1_reg_val &= ~(0xFFFF);
723 data1_reg_val |= (0xFFFF & tx_data);
724
725 buf_val = ioread32(davinci_spi->base + SPIBUF);
726 if ((buf_val & SPIBUF_TXFULL_MASK) == 0) {
727 iowrite32(data1_reg_val,
728 davinci_spi->base + SPIDAT1);
729
730 count--;
731 }
732 while (ioread32(davinci_spi->base + SPIBUF)
733 & SPIBUF_RXEMPTY_MASK)
734 cpu_relax();
735
736 /* getting the returned byte */
737 if (t->rx_buf) {
738 buf_val = ioread32(davinci_spi->base + SPIBUF);
739 davinci_spi->get_rx(buf_val, davinci_spi);
740 }
741 if (count <= 0)
742 break;
743 }
744 } else {
745 if (pdata->poll_mode) {
746 while (1) {
747 /* keeps the serial clock going */
748 if ((ioread32(davinci_spi->base + SPIBUF)
749 & SPIBUF_TXFULL_MASK) == 0)
750 iowrite32(data1_reg_val,
751 davinci_spi->base + SPIDAT1);
752
753 while (ioread32(davinci_spi->base + SPIBUF) &
754 SPIBUF_RXEMPTY_MASK)
755 cpu_relax();
756
757 flg_val = ioread32(davinci_spi->base + SPIFLG);
758 buf_val = ioread32(davinci_spi->base + SPIBUF);
759
760 davinci_spi->get_rx(buf_val, davinci_spi);
761
762 count--;
763 if (count <= 0)
764 break;
765 }
766 } else { /* Receive in Interrupt mode */
767 int i;
768
769 for (i = 0; i < davinci_spi->count; i++) {
770 set_io_bits(davinci_spi->base + SPIINT,
771 SPIINT_BITERR_INTR
772 | SPIINT_OVRRUN_INTR
773 | SPIINT_RX_INTR);
774
775 iowrite32(data1_reg_val,
776 davinci_spi->base + SPIDAT1);
777
778 while (ioread32(davinci_spi->base + SPIINT) &
779 SPIINT_RX_INTR)
780 cpu_relax();
781 }
782 iowrite32((data1_reg_val & 0x0ffcffff),
783 davinci_spi->base + SPIDAT1);
784 }
785 }
786
787 /*
788 * Check for bit error, desync error,parity error,timeout error and
789 * receive overflow errors
790 */
791 int_status = ioread32(davinci_spi->base + SPIFLG);
792
793 ret = davinci_spi_check_error(davinci_spi, int_status);
794 if (ret != 0)
795 return ret;
796
797 /* SPI Framework maintains the count only in bytes so convert back */
798 davinci_spi->count *= conv;
799
800 return t->len;
801 }
802
803 #define DAVINCI_DMA_DATA_TYPE_S8 0x01
804 #define DAVINCI_DMA_DATA_TYPE_S16 0x02
805 #define DAVINCI_DMA_DATA_TYPE_S32 0x04
806
807 static int davinci_spi_bufs_dma(struct spi_device *spi, struct spi_transfer *t)
808 {
809 struct davinci_spi *davinci_spi;
810 int int_status = 0;
811 int count, temp_count;
812 u8 conv = 1;
813 u8 tmp;
814 u32 data1_reg_val;
815 struct davinci_spi_dma *davinci_spi_dma;
816 int word_len, data_type, ret;
817 unsigned long tx_reg, rx_reg;
818 struct davinci_spi_platform_data *pdata;
819 struct device *sdev;
820
821 davinci_spi = spi_master_get_devdata(spi->master);
822 pdata = davinci_spi->pdata;
823 sdev = davinci_spi->bitbang.master->dev.parent;
824
825 davinci_spi_dma = &davinci_spi->dma_channels[spi->chip_select];
826
827 tx_reg = (unsigned long)davinci_spi->pbase + SPIDAT1;
828 rx_reg = (unsigned long)davinci_spi->pbase + SPIBUF;
829
830 davinci_spi->tx = t->tx_buf;
831 davinci_spi->rx = t->rx_buf;
832
833 /* convert len to words based on bits_per_word */
834 conv = davinci_spi->slave[spi->chip_select].bytes_per_word;
835 davinci_spi->count = t->len / conv;
836
837 INIT_COMPLETION(davinci_spi->done);
838
839 init_completion(&davinci_spi_dma->dma_rx_completion);
840 init_completion(&davinci_spi_dma->dma_tx_completion);
841
842 word_len = conv * 8;
843
844 if (word_len <= 8)
845 data_type = DAVINCI_DMA_DATA_TYPE_S8;
846 else if (word_len <= 16)
847 data_type = DAVINCI_DMA_DATA_TYPE_S16;
848 else if (word_len <= 32)
849 data_type = DAVINCI_DMA_DATA_TYPE_S32;
850 else
851 return -EINVAL;
852
853 ret = davinci_spi_bufs_prep(spi, davinci_spi);
854 if (ret)
855 return ret;
856
857 /* Put delay val if required */
858 iowrite32(0 | (pdata->c2tdelay << SPI_C2TDELAY_SHIFT) |
859 (pdata->t2cdelay << SPI_T2CDELAY_SHIFT),
860 davinci_spi->base + SPIDELAY);
861
862 count = davinci_spi->count; /* the number of elements */
863 data1_reg_val = pdata->cs_hold << SPIDAT1_CSHOLD_SHIFT;
864
865 /* CS default = 0xFF */
866 tmp = ~(0x1 << spi->chip_select);
867
868 clear_io_bits(davinci_spi->base + SPIDEF, ~tmp);
869
870 data1_reg_val |= tmp << SPIDAT1_CSNR_SHIFT;
871
872 /* disable all interrupts for dma transfers */
873 clear_io_bits(davinci_spi->base + SPIINT, SPIINT_MASKALL);
874 /* Disable SPI to write configuration bits in SPIDAT */
875 clear_io_bits(davinci_spi->base + SPIGCR1, SPIGCR1_SPIENA_MASK);
876 iowrite32(data1_reg_val, davinci_spi->base + SPIDAT1);
877 /* Enable SPI */
878 set_io_bits(davinci_spi->base + SPIGCR1, SPIGCR1_SPIENA_MASK);
879
880 while ((ioread32(davinci_spi->base + SPIBUF)
881 & SPIBUF_RXEMPTY_MASK) == 0)
882 cpu_relax();
883
884
885 if (t->tx_buf) {
886 t->tx_dma = dma_map_single(&spi->dev, (void *)t->tx_buf, count,
887 DMA_TO_DEVICE);
888 if (dma_mapping_error(&spi->dev, t->tx_dma)) {
889 dev_dbg(sdev, "Unable to DMA map a %d bytes"
890 " TX buffer\n", count);
891 return -ENOMEM;
892 }
893 temp_count = count;
894 } else {
895 /* We need TX clocking for RX transaction */
896 t->tx_dma = dma_map_single(&spi->dev,
897 (void *)davinci_spi->tmp_buf, count + 1,
898 DMA_TO_DEVICE);
899 if (dma_mapping_error(&spi->dev, t->tx_dma)) {
900 dev_dbg(sdev, "Unable to DMA map a %d bytes"
901 " TX tmp buffer\n", count);
902 return -ENOMEM;
903 }
904 temp_count = count + 1;
905 }
906
907 edma_set_transfer_params(davinci_spi_dma->dma_tx_channel,
908 data_type, temp_count, 1, 0, ASYNC);
909 edma_set_dest(davinci_spi_dma->dma_tx_channel, tx_reg, INCR, W8BIT);
910 edma_set_src(davinci_spi_dma->dma_tx_channel, t->tx_dma, INCR, W8BIT);
911 edma_set_src_index(davinci_spi_dma->dma_tx_channel, data_type, 0);
912 edma_set_dest_index(davinci_spi_dma->dma_tx_channel, 0, 0);
913
914 if (t->rx_buf) {
915 /* initiate transaction */
916 iowrite32(data1_reg_val, davinci_spi->base + SPIDAT1);
917
918 t->rx_dma = dma_map_single(&spi->dev, (void *)t->rx_buf, count,
919 DMA_FROM_DEVICE);
920 if (dma_mapping_error(&spi->dev, t->rx_dma)) {
921 dev_dbg(sdev, "Couldn't DMA map a %d bytes RX buffer\n",
922 count);
923 if (t->tx_buf != NULL)
924 dma_unmap_single(NULL, t->tx_dma,
925 count, DMA_TO_DEVICE);
926 return -ENOMEM;
927 }
928 edma_set_transfer_params(davinci_spi_dma->dma_rx_channel,
929 data_type, count, 1, 0, ASYNC);
930 edma_set_src(davinci_spi_dma->dma_rx_channel,
931 rx_reg, INCR, W8BIT);
932 edma_set_dest(davinci_spi_dma->dma_rx_channel,
933 t->rx_dma, INCR, W8BIT);
934 edma_set_src_index(davinci_spi_dma->dma_rx_channel, 0, 0);
935 edma_set_dest_index(davinci_spi_dma->dma_rx_channel,
936 data_type, 0);
937 }
938
939 if ((t->tx_buf) || (t->rx_buf))
940 edma_start(davinci_spi_dma->dma_tx_channel);
941
942 if (t->rx_buf)
943 edma_start(davinci_spi_dma->dma_rx_channel);
944
945 if ((t->rx_buf) || (t->tx_buf))
946 davinci_spi_set_dma_req(spi, 1);
947
948 if (t->tx_buf)
949 wait_for_completion_interruptible(
950 &davinci_spi_dma->dma_tx_completion);
951
952 if (t->rx_buf)
953 wait_for_completion_interruptible(
954 &davinci_spi_dma->dma_rx_completion);
955
956 dma_unmap_single(NULL, t->tx_dma, temp_count, DMA_TO_DEVICE);
957
958 if (t->rx_buf)
959 dma_unmap_single(NULL, t->rx_dma, count, DMA_FROM_DEVICE);
960
961 /*
962 * Check for bit error, desync error,parity error,timeout error and
963 * receive overflow errors
964 */
965 int_status = ioread32(davinci_spi->base + SPIFLG);
966
967 ret = davinci_spi_check_error(davinci_spi, int_status);
968 if (ret != 0)
969 return ret;
970
971 /* SPI Framework maintains the count only in bytes so convert back */
972 davinci_spi->count *= conv;
973
974 return t->len;
975 }
976
977 /**
978 * davinci_spi_irq - IRQ handler for DaVinci SPI
979 * @irq: IRQ number for this SPI Master
980 * @context_data: structure for SPI Master controller davinci_spi
981 */
982 static irqreturn_t davinci_spi_irq(s32 irq, void *context_data)
983 {
984 struct davinci_spi *davinci_spi = context_data;
985 u32 int_status, rx_data = 0;
986 irqreturn_t ret = IRQ_NONE;
987
988 int_status = ioread32(davinci_spi->base + SPIFLG);
989
990 while ((int_status & SPIFLG_RX_INTR_MASK)) {
991 if (likely(int_status & SPIFLG_RX_INTR_MASK)) {
992 ret = IRQ_HANDLED;
993
994 rx_data = ioread32(davinci_spi->base + SPIBUF);
995 davinci_spi->get_rx(rx_data, davinci_spi);
996
997 /* Disable Receive Interrupt */
998 iowrite32(~(SPIINT_RX_INTR | SPIINT_TX_INTR),
999 davinci_spi->base + SPIINT);
1000 } else
1001 (void)davinci_spi_check_error(davinci_spi, int_status);
1002
1003 int_status = ioread32(davinci_spi->base + SPIFLG);
1004 }
1005
1006 return ret;
1007 }
1008
1009 /**
1010 * davinci_spi_probe - probe function for SPI Master Controller
1011 * @pdev: platform_device structure which contains plateform specific data
1012 */
1013 static int davinci_spi_probe(struct platform_device *pdev)
1014 {
1015 struct spi_master *master;
1016 struct davinci_spi *davinci_spi;
1017 struct davinci_spi_platform_data *pdata;
1018 struct resource *r, *mem;
1019 resource_size_t dma_rx_chan = SPI_NO_RESOURCE;
1020 resource_size_t dma_tx_chan = SPI_NO_RESOURCE;
1021 resource_size_t dma_eventq = SPI_NO_RESOURCE;
1022 int i = 0, ret = 0;
1023
1024 pdata = pdev->dev.platform_data;
1025 if (pdata == NULL) {
1026 ret = -ENODEV;
1027 goto err;
1028 }
1029
1030 master = spi_alloc_master(&pdev->dev, sizeof(struct davinci_spi));
1031 if (master == NULL) {
1032 ret = -ENOMEM;
1033 goto err;
1034 }
1035
1036 dev_set_drvdata(&pdev->dev, master);
1037
1038 davinci_spi = spi_master_get_devdata(master);
1039 if (davinci_spi == NULL) {
1040 ret = -ENOENT;
1041 goto free_master;
1042 }
1043
1044 r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1045 if (r == NULL) {
1046 ret = -ENOENT;
1047 goto free_master;
1048 }
1049
1050 davinci_spi->pbase = r->start;
1051 davinci_spi->region_size = resource_size(r);
1052 davinci_spi->pdata = pdata;
1053
1054 mem = request_mem_region(r->start, davinci_spi->region_size,
1055 pdev->name);
1056 if (mem == NULL) {
1057 ret = -EBUSY;
1058 goto free_master;
1059 }
1060
1061 davinci_spi->base = (struct davinci_spi_reg __iomem *)
1062 ioremap(r->start, davinci_spi->region_size);
1063 if (davinci_spi->base == NULL) {
1064 ret = -ENOMEM;
1065 goto release_region;
1066 }
1067
1068 davinci_spi->irq = platform_get_irq(pdev, 0);
1069 if (davinci_spi->irq <= 0) {
1070 ret = -EINVAL;
1071 goto unmap_io;
1072 }
1073
1074 ret = request_irq(davinci_spi->irq, davinci_spi_irq, IRQF_DISABLED,
1075 dev_name(&pdev->dev), davinci_spi);
1076 if (ret)
1077 goto unmap_io;
1078
1079 /* Allocate tmp_buf for tx_buf */
1080 davinci_spi->tmp_buf = kzalloc(SPI_BUFSIZ, GFP_KERNEL);
1081 if (davinci_spi->tmp_buf == NULL) {
1082 ret = -ENOMEM;
1083 goto irq_free;
1084 }
1085
1086 davinci_spi->bitbang.master = spi_master_get(master);
1087 if (davinci_spi->bitbang.master == NULL) {
1088 ret = -ENODEV;
1089 goto free_tmp_buf;
1090 }
1091
1092 davinci_spi->clk = clk_get(&pdev->dev, NULL);
1093 if (IS_ERR(davinci_spi->clk)) {
1094 ret = -ENODEV;
1095 goto put_master;
1096 }
1097 clk_enable(davinci_spi->clk);
1098
1099
1100 master->bus_num = pdev->id;
1101 master->num_chipselect = pdata->num_chipselect;
1102 master->setup = davinci_spi_setup;
1103 master->cleanup = davinci_spi_cleanup;
1104
1105 davinci_spi->bitbang.chipselect = davinci_spi_chipselect;
1106 davinci_spi->bitbang.setup_transfer = davinci_spi_setup_transfer;
1107
1108 davinci_spi->version = pdata->version;
1109 use_dma = pdata->use_dma;
1110
1111 davinci_spi->bitbang.flags = SPI_NO_CS | SPI_LSB_FIRST | SPI_LOOP;
1112 if (davinci_spi->version == SPI_VERSION_2)
1113 davinci_spi->bitbang.flags |= SPI_READY;
1114
1115 if (use_dma) {
1116 r = platform_get_resource(pdev, IORESOURCE_DMA, 0);
1117 if (r)
1118 dma_rx_chan = r->start;
1119 r = platform_get_resource(pdev, IORESOURCE_DMA, 1);
1120 if (r)
1121 dma_tx_chan = r->start;
1122 r = platform_get_resource(pdev, IORESOURCE_DMA, 2);
1123 if (r)
1124 dma_eventq = r->start;
1125 }
1126
1127 if (!use_dma ||
1128 dma_rx_chan == SPI_NO_RESOURCE ||
1129 dma_tx_chan == SPI_NO_RESOURCE ||
1130 dma_eventq == SPI_NO_RESOURCE) {
1131 davinci_spi->bitbang.txrx_bufs = davinci_spi_bufs_pio;
1132 use_dma = 0;
1133 } else {
1134 davinci_spi->bitbang.txrx_bufs = davinci_spi_bufs_dma;
1135 davinci_spi->dma_channels = kzalloc(master->num_chipselect
1136 * sizeof(struct davinci_spi_dma), GFP_KERNEL);
1137 if (davinci_spi->dma_channels == NULL) {
1138 ret = -ENOMEM;
1139 goto free_clk;
1140 }
1141
1142 for (i = 0; i < master->num_chipselect; i++) {
1143 davinci_spi->dma_channels[i].dma_rx_channel = -1;
1144 davinci_spi->dma_channels[i].dma_rx_sync_dev =
1145 dma_rx_chan;
1146 davinci_spi->dma_channels[i].dma_tx_channel = -1;
1147 davinci_spi->dma_channels[i].dma_tx_sync_dev =
1148 dma_tx_chan;
1149 davinci_spi->dma_channels[i].eventq = dma_eventq;
1150 }
1151 dev_info(&pdev->dev, "DaVinci SPI driver in EDMA mode\n"
1152 "Using RX channel = %d , TX channel = %d and "
1153 "event queue = %d", dma_rx_chan, dma_tx_chan,
1154 dma_eventq);
1155 }
1156
1157 davinci_spi->get_rx = davinci_spi_rx_buf_u8;
1158 davinci_spi->get_tx = davinci_spi_tx_buf_u8;
1159
1160 init_completion(&davinci_spi->done);
1161
1162 /* Reset In/OUT SPI module */
1163 iowrite32(0, davinci_spi->base + SPIGCR0);
1164 udelay(100);
1165 iowrite32(1, davinci_spi->base + SPIGCR0);
1166
1167 /* Clock internal */
1168 if (davinci_spi->pdata->clk_internal)
1169 set_io_bits(davinci_spi->base + SPIGCR1,
1170 SPIGCR1_CLKMOD_MASK);
1171 else
1172 clear_io_bits(davinci_spi->base + SPIGCR1,
1173 SPIGCR1_CLKMOD_MASK);
1174
1175 /* master mode default */
1176 set_io_bits(davinci_spi->base + SPIGCR1, SPIGCR1_MASTER_MASK);
1177
1178 if (davinci_spi->pdata->intr_level)
1179 iowrite32(SPI_INTLVL_1, davinci_spi->base + SPILVL);
1180 else
1181 iowrite32(SPI_INTLVL_0, davinci_spi->base + SPILVL);
1182
1183 ret = spi_bitbang_start(&davinci_spi->bitbang);
1184 if (ret)
1185 goto free_clk;
1186
1187 dev_info(&pdev->dev, "Controller at 0x%p \n", davinci_spi->base);
1188
1189 if (!pdata->poll_mode)
1190 dev_info(&pdev->dev, "Operating in interrupt mode"
1191 " using IRQ %d\n", davinci_spi->irq);
1192
1193 return ret;
1194
1195 free_clk:
1196 clk_disable(davinci_spi->clk);
1197 clk_put(davinci_spi->clk);
1198 put_master:
1199 spi_master_put(master);
1200 free_tmp_buf:
1201 kfree(davinci_spi->tmp_buf);
1202 irq_free:
1203 free_irq(davinci_spi->irq, davinci_spi);
1204 unmap_io:
1205 iounmap(davinci_spi->base);
1206 release_region:
1207 release_mem_region(davinci_spi->pbase, davinci_spi->region_size);
1208 free_master:
1209 kfree(master);
1210 err:
1211 return ret;
1212 }
1213
1214 /**
1215 * davinci_spi_remove - remove function for SPI Master Controller
1216 * @pdev: platform_device structure which contains plateform specific data
1217 *
1218 * This function will do the reverse action of davinci_spi_probe function
1219 * It will free the IRQ and SPI controller's memory region.
1220 * It will also call spi_bitbang_stop to destroy the work queue which was
1221 * created by spi_bitbang_start.
1222 */
1223 static int __exit davinci_spi_remove(struct platform_device *pdev)
1224 {
1225 struct davinci_spi *davinci_spi;
1226 struct spi_master *master;
1227
1228 master = dev_get_drvdata(&pdev->dev);
1229 davinci_spi = spi_master_get_devdata(master);
1230
1231 spi_bitbang_stop(&davinci_spi->bitbang);
1232
1233 clk_disable(davinci_spi->clk);
1234 clk_put(davinci_spi->clk);
1235 spi_master_put(master);
1236 kfree(davinci_spi->tmp_buf);
1237 free_irq(davinci_spi->irq, davinci_spi);
1238 iounmap(davinci_spi->base);
1239 release_mem_region(davinci_spi->pbase, davinci_spi->region_size);
1240
1241 return 0;
1242 }
1243
1244 static struct platform_driver davinci_spi_driver = {
1245 .driver.name = "spi_davinci",
1246 .remove = __exit_p(davinci_spi_remove),
1247 };
1248
1249 static int __init davinci_spi_init(void)
1250 {
1251 return platform_driver_probe(&davinci_spi_driver, davinci_spi_probe);
1252 }
1253 module_init(davinci_spi_init);
1254
1255 static void __exit davinci_spi_exit(void)
1256 {
1257 platform_driver_unregister(&davinci_spi_driver);
1258 }
1259 module_exit(davinci_spi_exit);
1260
1261 MODULE_DESCRIPTION("TI DaVinci SPI Master Controller Driver");
1262 MODULE_LICENSE("GPL");
Linus' kernel tree