2 * Copyright 2004-2007 Freescale Semiconductor, Inc. All Rights Reserved.
3 * Copyright (C) 2008 Juergen Beisert
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License
7 * as published by the Free Software Foundation; either version 2
8 * of the License, or (at your option) any later version.
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.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the
16 * Free Software Foundation
17 * 51 Franklin Street, Fifth Floor
18 * Boston, MA 02110-1301, USA.
21 #include <linux/clk.h>
22 #include <linux/completion.h>
23 #include <linux/delay.h>
24 #include <linux/err.h>
25 #include <linux/gpio.h>
26 #include <linux/init.h>
27 #include <linux/interrupt.h>
29 #include <linux/irq.h>
30 #include <linux/kernel.h>
31 #include <linux/module.h>
32 #include <linux/platform_device.h>
33 #include <linux/slab.h>
34 #include <linux/spi/spi.h>
35 #include <linux/spi/spi_bitbang.h>
36 #include <linux/types.h>
40 #define DRIVER_NAME "spi_imx"
42 #define MXC_CSPIRXDATA 0x00
43 #define MXC_CSPITXDATA 0x04
44 #define MXC_CSPICTRL 0x08
45 #define MXC_CSPIINT 0x0c
46 #define MXC_RESET 0x1c
48 #define MX3_CSPISTAT 0x14
49 #define MX3_CSPISTAT_RR (1 << 3)
51 /* generic defines to abstract from the different register layouts */
52 #define MXC_INT_RR (1 << 0) /* Receive data ready interrupt */
53 #define MXC_INT_TE (1 << 1) /* Transmit FIFO empty interrupt */
55 struct spi_imx_config {
56 unsigned int speed_hz;
62 enum spi_imx_devtype {
68 SPI_IMX_VER_AUTODETECT,
73 struct spi_imx_devtype_data {
74 void (*intctrl)(struct spi_imx_data *, int);
75 int (*config)(struct spi_imx_data *, struct spi_imx_config *);
76 void (*trigger)(struct spi_imx_data *);
77 int (*rx_available)(struct spi_imx_data *);
78 void (*reset)(struct spi_imx_data *);
82 struct spi_bitbang bitbang;
84 struct completion xfer_done;
88 unsigned long spi_clk;
92 void (*tx)(struct spi_imx_data *);
93 void (*rx)(struct spi_imx_data *);
96 unsigned int txfifo; /* number of words pushed in tx FIFO */
98 struct spi_imx_devtype_data devtype_data;
101 #define MXC_SPI_BUF_RX(type) \
102 static void spi_imx_buf_rx_##type(struct spi_imx_data *spi_imx) \
104 unsigned int val = readl(spi_imx->base + MXC_CSPIRXDATA); \
106 if (spi_imx->rx_buf) { \
107 *(type *)spi_imx->rx_buf = val; \
108 spi_imx->rx_buf += sizeof(type); \
112 #define MXC_SPI_BUF_TX(type) \
113 static void spi_imx_buf_tx_##type(struct spi_imx_data *spi_imx) \
117 if (spi_imx->tx_buf) { \
118 val = *(type *)spi_imx->tx_buf; \
119 spi_imx->tx_buf += sizeof(type); \
122 spi_imx->count -= sizeof(type); \
124 writel(val, spi_imx->base + MXC_CSPITXDATA); \
134 /* First entry is reserved, second entry is valid only if SDHC_SPIEN is set
135 * (which is currently not the case in this driver)
137 static int mxc_clkdivs[] = {0, 3, 4, 6, 8, 12, 16, 24, 32, 48, 64, 96, 128, 192,
138 256, 384, 512, 768, 1024};
141 static unsigned int spi_imx_clkdiv_1(unsigned int fin,
151 for (i = 2; i < max; i++)
152 if (fspi * mxc_clkdivs[i] >= fin)
158 /* MX1, MX31, MX35 */
159 static unsigned int spi_imx_clkdiv_2(unsigned int fin,
164 for (i = 0; i < 7; i++) {
165 if (fspi * div >= fin)
173 #define MX31_INTREG_TEEN (1 << 0)
174 #define MX31_INTREG_RREN (1 << 3)
176 #define MX31_CSPICTRL_ENABLE (1 << 0)
177 #define MX31_CSPICTRL_MASTER (1 << 1)
178 #define MX31_CSPICTRL_XCH (1 << 2)
179 #define MX31_CSPICTRL_POL (1 << 4)
180 #define MX31_CSPICTRL_PHA (1 << 5)
181 #define MX31_CSPICTRL_SSCTL (1 << 6)
182 #define MX31_CSPICTRL_SSPOL (1 << 7)
183 #define MX31_CSPICTRL_BC_SHIFT 8
184 #define MX35_CSPICTRL_BL_SHIFT 20
185 #define MX31_CSPICTRL_CS_SHIFT 24
186 #define MX35_CSPICTRL_CS_SHIFT 12
187 #define MX31_CSPICTRL_DR_SHIFT 16
189 #define MX31_CSPISTATUS 0x14
190 #define MX31_STATUS_RR (1 << 3)
192 /* These functions also work for the i.MX35, but be aware that
193 * the i.MX35 has a slightly different register layout for bits
194 * we do not use here.
196 static void __maybe_unused mx31_intctrl(struct spi_imx_data *spi_imx, int enable)
198 unsigned int val = 0;
200 if (enable & MXC_INT_TE)
201 val |= MX31_INTREG_TEEN;
202 if (enable & MXC_INT_RR)
203 val |= MX31_INTREG_RREN;
205 writel(val, spi_imx->base + MXC_CSPIINT);
208 static void __maybe_unused mx31_trigger(struct spi_imx_data *spi_imx)
212 reg = readl(spi_imx->base + MXC_CSPICTRL);
213 reg |= MX31_CSPICTRL_XCH;
214 writel(reg, spi_imx->base + MXC_CSPICTRL);
217 static int __maybe_unused spi_imx0_4_config(struct spi_imx_data *spi_imx,
218 struct spi_imx_config *config)
220 unsigned int reg = MX31_CSPICTRL_ENABLE | MX31_CSPICTRL_MASTER;
221 int cs = spi_imx->chipselect[config->cs];
223 reg |= spi_imx_clkdiv_2(spi_imx->spi_clk, config->speed_hz) <<
224 MX31_CSPICTRL_DR_SHIFT;
226 reg |= (config->bpw - 1) << MX31_CSPICTRL_BC_SHIFT;
228 if (config->mode & SPI_CPHA)
229 reg |= MX31_CSPICTRL_PHA;
230 if (config->mode & SPI_CPOL)
231 reg |= MX31_CSPICTRL_POL;
232 if (config->mode & SPI_CS_HIGH)
233 reg |= MX31_CSPICTRL_SSPOL;
235 reg |= (cs + 32) << MX31_CSPICTRL_CS_SHIFT;
237 writel(reg, spi_imx->base + MXC_CSPICTRL);
242 static int __maybe_unused spi_imx0_7_config(struct spi_imx_data *spi_imx,
243 struct spi_imx_config *config)
245 unsigned int reg = MX31_CSPICTRL_ENABLE | MX31_CSPICTRL_MASTER;
246 int cs = spi_imx->chipselect[config->cs];
248 reg |= spi_imx_clkdiv_2(spi_imx->spi_clk, config->speed_hz) <<
249 MX31_CSPICTRL_DR_SHIFT;
251 reg |= (config->bpw - 1) << MX35_CSPICTRL_BL_SHIFT;
252 reg |= MX31_CSPICTRL_SSCTL;
254 if (config->mode & SPI_CPHA)
255 reg |= MX31_CSPICTRL_PHA;
256 if (config->mode & SPI_CPOL)
257 reg |= MX31_CSPICTRL_POL;
258 if (config->mode & SPI_CS_HIGH)
259 reg |= MX31_CSPICTRL_SSPOL;
261 reg |= (cs + 32) << MX35_CSPICTRL_CS_SHIFT;
263 writel(reg, spi_imx->base + MXC_CSPICTRL);
268 static int __maybe_unused mx31_rx_available(struct spi_imx_data *spi_imx)
270 return readl(spi_imx->base + MX31_CSPISTATUS) & MX31_STATUS_RR;
273 static void __maybe_unused spi_imx0_4_reset(struct spi_imx_data *spi_imx)
275 /* drain receive buffer */
276 while (readl(spi_imx->base + MX3_CSPISTAT) & MX3_CSPISTAT_RR)
277 readl(spi_imx->base + MXC_CSPIRXDATA);
280 #define MX27_INTREG_RR (1 << 4)
281 #define MX27_INTREG_TEEN (1 << 9)
282 #define MX27_INTREG_RREN (1 << 13)
284 #define MX27_CSPICTRL_POL (1 << 5)
285 #define MX27_CSPICTRL_PHA (1 << 6)
286 #define MX27_CSPICTRL_SSPOL (1 << 8)
287 #define MX27_CSPICTRL_XCH (1 << 9)
288 #define MX27_CSPICTRL_ENABLE (1 << 10)
289 #define MX27_CSPICTRL_MASTER (1 << 11)
290 #define MX27_CSPICTRL_DR_SHIFT 14
291 #define MX27_CSPICTRL_CS_SHIFT 19
293 static void __maybe_unused mx27_intctrl(struct spi_imx_data *spi_imx, int enable)
295 unsigned int val = 0;
297 if (enable & MXC_INT_TE)
298 val |= MX27_INTREG_TEEN;
299 if (enable & MXC_INT_RR)
300 val |= MX27_INTREG_RREN;
302 writel(val, spi_imx->base + MXC_CSPIINT);
305 static void __maybe_unused mx27_trigger(struct spi_imx_data *spi_imx)
309 reg = readl(spi_imx->base + MXC_CSPICTRL);
310 reg |= MX27_CSPICTRL_XCH;
311 writel(reg, spi_imx->base + MXC_CSPICTRL);
314 static int __maybe_unused mx27_config(struct spi_imx_data *spi_imx,
315 struct spi_imx_config *config)
317 unsigned int reg = MX27_CSPICTRL_ENABLE | MX27_CSPICTRL_MASTER;
318 int cs = spi_imx->chipselect[config->cs];
320 reg |= spi_imx_clkdiv_1(spi_imx->spi_clk, config->speed_hz) <<
321 MX27_CSPICTRL_DR_SHIFT;
322 reg |= config->bpw - 1;
324 if (config->mode & SPI_CPHA)
325 reg |= MX27_CSPICTRL_PHA;
326 if (config->mode & SPI_CPOL)
327 reg |= MX27_CSPICTRL_POL;
328 if (config->mode & SPI_CS_HIGH)
329 reg |= MX27_CSPICTRL_SSPOL;
331 reg |= (cs + 32) << MX27_CSPICTRL_CS_SHIFT;
333 writel(reg, spi_imx->base + MXC_CSPICTRL);
338 static int __maybe_unused mx27_rx_available(struct spi_imx_data *spi_imx)
340 return readl(spi_imx->base + MXC_CSPIINT) & MX27_INTREG_RR;
343 static void __maybe_unused spi_imx0_0_reset(struct spi_imx_data *spi_imx)
345 writel(1, spi_imx->base + MXC_RESET);
348 #define MX1_INTREG_RR (1 << 3)
349 #define MX1_INTREG_TEEN (1 << 8)
350 #define MX1_INTREG_RREN (1 << 11)
352 #define MX1_CSPICTRL_POL (1 << 4)
353 #define MX1_CSPICTRL_PHA (1 << 5)
354 #define MX1_CSPICTRL_XCH (1 << 8)
355 #define MX1_CSPICTRL_ENABLE (1 << 9)
356 #define MX1_CSPICTRL_MASTER (1 << 10)
357 #define MX1_CSPICTRL_DR_SHIFT 13
359 static void __maybe_unused mx1_intctrl(struct spi_imx_data *spi_imx, int enable)
361 unsigned int val = 0;
363 if (enable & MXC_INT_TE)
364 val |= MX1_INTREG_TEEN;
365 if (enable & MXC_INT_RR)
366 val |= MX1_INTREG_RREN;
368 writel(val, spi_imx->base + MXC_CSPIINT);
371 static void __maybe_unused mx1_trigger(struct spi_imx_data *spi_imx)
375 reg = readl(spi_imx->base + MXC_CSPICTRL);
376 reg |= MX1_CSPICTRL_XCH;
377 writel(reg, spi_imx->base + MXC_CSPICTRL);
380 static int __maybe_unused mx1_config(struct spi_imx_data *spi_imx,
381 struct spi_imx_config *config)
383 unsigned int reg = MX1_CSPICTRL_ENABLE | MX1_CSPICTRL_MASTER;
385 reg |= spi_imx_clkdiv_2(spi_imx->spi_clk, config->speed_hz) <<
386 MX1_CSPICTRL_DR_SHIFT;
387 reg |= config->bpw - 1;
389 if (config->mode & SPI_CPHA)
390 reg |= MX1_CSPICTRL_PHA;
391 if (config->mode & SPI_CPOL)
392 reg |= MX1_CSPICTRL_POL;
394 writel(reg, spi_imx->base + MXC_CSPICTRL);
399 static int __maybe_unused mx1_rx_available(struct spi_imx_data *spi_imx)
401 return readl(spi_imx->base + MXC_CSPIINT) & MX1_INTREG_RR;
404 static void __maybe_unused mx1_reset(struct spi_imx_data *spi_imx)
406 writel(1, spi_imx->base + MXC_RESET);
410 * These version numbers are taken from the Freescale driver. Unfortunately it
411 * doesn't support i.MX1, so this entry doesn't match the scheme. :-(
413 static struct spi_imx_devtype_data spi_imx_devtype_data[] __devinitdata = {
414 #ifdef CONFIG_SPI_IMX_VER_IMX1
415 [SPI_IMX_VER_IMX1] = {
416 .intctrl = mx1_intctrl,
417 .config = mx1_config,
418 .trigger = mx1_trigger,
419 .rx_available = mx1_rx_available,
423 #ifdef CONFIG_SPI_IMX_VER_0_0
424 [SPI_IMX_VER_0_0] = {
425 .intctrl = mx27_intctrl,
426 .config = mx27_config,
427 .trigger = mx27_trigger,
428 .rx_available = mx27_rx_available,
429 .reset = spi_imx0_0_reset,
432 #ifdef CONFIG_SPI_IMX_VER_0_4
433 [SPI_IMX_VER_0_4] = {
434 .intctrl = mx31_intctrl,
435 .config = spi_imx0_4_config,
436 .trigger = mx31_trigger,
437 .rx_available = mx31_rx_available,
438 .reset = spi_imx0_4_reset,
441 #ifdef CONFIG_SPI_IMX_VER_0_7
442 [SPI_IMX_VER_0_7] = {
443 .intctrl = mx31_intctrl,
444 .config = spi_imx0_7_config,
445 .trigger = mx31_trigger,
446 .rx_available = mx31_rx_available,
447 .reset = spi_imx0_4_reset,
452 static void spi_imx_chipselect(struct spi_device *spi, int is_active)
454 struct spi_imx_data *spi_imx = spi_master_get_devdata(spi->master);
455 int gpio = spi_imx->chipselect[spi->chip_select];
456 int active = is_active != BITBANG_CS_INACTIVE;
457 int dev_is_lowactive = !(spi->mode & SPI_CS_HIGH);
462 gpio_set_value(gpio, dev_is_lowactive ^ active);
465 static void spi_imx_push(struct spi_imx_data *spi_imx)
467 while (spi_imx->txfifo < 8) {
470 spi_imx->tx(spi_imx);
474 spi_imx->devtype_data.trigger(spi_imx);
477 static irqreturn_t spi_imx_isr(int irq, void *dev_id)
479 struct spi_imx_data *spi_imx = dev_id;
481 while (spi_imx->devtype_data.rx_available(spi_imx)) {
482 spi_imx->rx(spi_imx);
486 if (spi_imx->count) {
487 spi_imx_push(spi_imx);
491 if (spi_imx->txfifo) {
492 /* No data left to push, but still waiting for rx data,
493 * enable receive data available interrupt.
495 spi_imx->devtype_data.intctrl(
496 spi_imx, MXC_INT_RR);
500 spi_imx->devtype_data.intctrl(spi_imx, 0);
501 complete(&spi_imx->xfer_done);
506 static int spi_imx_setupxfer(struct spi_device *spi,
507 struct spi_transfer *t)
509 struct spi_imx_data *spi_imx = spi_master_get_devdata(spi->master);
510 struct spi_imx_config config;
512 config.bpw = t ? t->bits_per_word : spi->bits_per_word;
513 config.speed_hz = t ? t->speed_hz : spi->max_speed_hz;
514 config.mode = spi->mode;
515 config.cs = spi->chip_select;
517 if (!config.speed_hz)
518 config.speed_hz = spi->max_speed_hz;
520 config.bpw = spi->bits_per_word;
521 if (!config.speed_hz)
522 config.speed_hz = spi->max_speed_hz;
524 /* Initialize the functions for transfer */
525 if (config.bpw <= 8) {
526 spi_imx->rx = spi_imx_buf_rx_u8;
527 spi_imx->tx = spi_imx_buf_tx_u8;
528 } else if (config.bpw <= 16) {
529 spi_imx->rx = spi_imx_buf_rx_u16;
530 spi_imx->tx = spi_imx_buf_tx_u16;
531 } else if (config.bpw <= 32) {
532 spi_imx->rx = spi_imx_buf_rx_u32;
533 spi_imx->tx = spi_imx_buf_tx_u32;
537 spi_imx->devtype_data.config(spi_imx, &config);
542 static int spi_imx_transfer(struct spi_device *spi,
543 struct spi_transfer *transfer)
545 struct spi_imx_data *spi_imx = spi_master_get_devdata(spi->master);
547 spi_imx->tx_buf = transfer->tx_buf;
548 spi_imx->rx_buf = transfer->rx_buf;
549 spi_imx->count = transfer->len;
552 init_completion(&spi_imx->xfer_done);
554 spi_imx_push(spi_imx);
556 spi_imx->devtype_data.intctrl(spi_imx, MXC_INT_TE);
558 wait_for_completion(&spi_imx->xfer_done);
560 return transfer->len;
563 static int spi_imx_setup(struct spi_device *spi)
565 struct spi_imx_data *spi_imx = spi_master_get_devdata(spi->master);
566 int gpio = spi_imx->chipselect[spi->chip_select];
568 dev_dbg(&spi->dev, "%s: mode %d, %u bpw, %d hz\n", __func__,
569 spi->mode, spi->bits_per_word, spi->max_speed_hz);
572 gpio_direction_output(gpio, spi->mode & SPI_CS_HIGH ? 0 : 1);
574 spi_imx_chipselect(spi, BITBANG_CS_INACTIVE);
579 static void spi_imx_cleanup(struct spi_device *spi)
583 static struct platform_device_id spi_imx_devtype[] = {
586 .driver_data = SPI_IMX_VER_AUTODETECT,
589 .driver_data = SPI_IMX_VER_IMX1,
591 .name = "imx21-cspi",
592 .driver_data = SPI_IMX_VER_0_0,
594 .name = "imx25-cspi",
595 .driver_data = SPI_IMX_VER_0_7,
597 .name = "imx27-cspi",
598 .driver_data = SPI_IMX_VER_0_0,
600 .name = "imx31-cspi",
601 .driver_data = SPI_IMX_VER_0_4,
603 .name = "imx35-cspi",
604 .driver_data = SPI_IMX_VER_0_7,
610 static int __devinit spi_imx_probe(struct platform_device *pdev)
612 struct spi_imx_master *mxc_platform_info;
613 struct spi_master *master;
614 struct spi_imx_data *spi_imx;
615 struct resource *res;
618 mxc_platform_info = dev_get_platdata(&pdev->dev);
619 if (!mxc_platform_info) {
620 dev_err(&pdev->dev, "can't get the platform data\n");
624 master = spi_alloc_master(&pdev->dev, sizeof(struct spi_imx_data));
628 platform_set_drvdata(pdev, master);
630 master->bus_num = pdev->id;
631 master->num_chipselect = mxc_platform_info->num_chipselect;
633 spi_imx = spi_master_get_devdata(master);
634 spi_imx->bitbang.master = spi_master_get(master);
635 spi_imx->chipselect = mxc_platform_info->chipselect;
637 for (i = 0; i < master->num_chipselect; i++) {
638 if (spi_imx->chipselect[i] < 0)
640 ret = gpio_request(spi_imx->chipselect[i], DRIVER_NAME);
644 if (spi_imx->chipselect[i] >= 0)
645 gpio_free(spi_imx->chipselect[i]);
647 dev_err(&pdev->dev, "can't get cs gpios\n");
652 spi_imx->bitbang.chipselect = spi_imx_chipselect;
653 spi_imx->bitbang.setup_transfer = spi_imx_setupxfer;
654 spi_imx->bitbang.txrx_bufs = spi_imx_transfer;
655 spi_imx->bitbang.master->setup = spi_imx_setup;
656 spi_imx->bitbang.master->cleanup = spi_imx_cleanup;
657 spi_imx->bitbang.master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH;
659 init_completion(&spi_imx->xfer_done);
661 if (pdev->id_entry->driver_data == SPI_IMX_VER_AUTODETECT) {
662 if (cpu_is_mx25() || cpu_is_mx35())
663 spi_imx->devtype_data =
664 spi_imx_devtype_data[SPI_IMX_VER_0_7];
665 else if (cpu_is_mx25() || cpu_is_mx31() || cpu_is_mx35())
666 spi_imx->devtype_data =
667 spi_imx_devtype_data[SPI_IMX_VER_0_4];
668 else if (cpu_is_mx27() || cpu_is_mx21())
669 spi_imx->devtype_data =
670 spi_imx_devtype_data[SPI_IMX_VER_0_0];
671 else if (cpu_is_mx1())
672 spi_imx->devtype_data =
673 spi_imx_devtype_data[SPI_IMX_VER_IMX1];
677 spi_imx->devtype_data =
678 spi_imx_devtype_data[pdev->id_entry->driver_data];
680 if (!spi_imx->devtype_data.intctrl) {
681 dev_err(&pdev->dev, "no support for this device compiled in\n");
686 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
688 dev_err(&pdev->dev, "can't get platform resource\n");
693 if (!request_mem_region(res->start, resource_size(res), pdev->name)) {
694 dev_err(&pdev->dev, "request_mem_region failed\n");
699 spi_imx->base = ioremap(res->start, resource_size(res));
700 if (!spi_imx->base) {
702 goto out_release_mem;
705 spi_imx->irq = platform_get_irq(pdev, 0);
706 if (spi_imx->irq <= 0) {
711 ret = request_irq(spi_imx->irq, spi_imx_isr, 0, DRIVER_NAME, spi_imx);
713 dev_err(&pdev->dev, "can't get irq%d: %d\n", spi_imx->irq, ret);
717 spi_imx->clk = clk_get(&pdev->dev, NULL);
718 if (IS_ERR(spi_imx->clk)) {
719 dev_err(&pdev->dev, "unable to get clock\n");
720 ret = PTR_ERR(spi_imx->clk);
724 clk_enable(spi_imx->clk);
725 spi_imx->spi_clk = clk_get_rate(spi_imx->clk);
727 spi_imx->devtype_data.reset(spi_imx);
729 spi_imx->devtype_data.intctrl(spi_imx, 0);
731 ret = spi_bitbang_start(&spi_imx->bitbang);
733 dev_err(&pdev->dev, "bitbang start failed with %d\n", ret);
737 dev_info(&pdev->dev, "probed\n");
742 clk_disable(spi_imx->clk);
743 clk_put(spi_imx->clk);
745 free_irq(spi_imx->irq, spi_imx);
747 iounmap(spi_imx->base);
749 release_mem_region(res->start, resource_size(res));
751 for (i = 0; i < master->num_chipselect; i++)
752 if (spi_imx->chipselect[i] >= 0)
753 gpio_free(spi_imx->chipselect[i]);
755 spi_master_put(master);
757 platform_set_drvdata(pdev, NULL);
761 static int __devexit spi_imx_remove(struct platform_device *pdev)
763 struct spi_master *master = platform_get_drvdata(pdev);
764 struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
765 struct spi_imx_data *spi_imx = spi_master_get_devdata(master);
768 spi_bitbang_stop(&spi_imx->bitbang);
770 writel(0, spi_imx->base + MXC_CSPICTRL);
771 clk_disable(spi_imx->clk);
772 clk_put(spi_imx->clk);
773 free_irq(spi_imx->irq, spi_imx);
774 iounmap(spi_imx->base);
776 for (i = 0; i < master->num_chipselect; i++)
777 if (spi_imx->chipselect[i] >= 0)
778 gpio_free(spi_imx->chipselect[i]);
780 spi_master_put(master);
782 release_mem_region(res->start, resource_size(res));
784 platform_set_drvdata(pdev, NULL);
789 static struct platform_driver spi_imx_driver = {
792 .owner = THIS_MODULE,
794 .id_table = spi_imx_devtype,
795 .probe = spi_imx_probe,
796 .remove = __devexit_p(spi_imx_remove),
799 static int __init spi_imx_init(void)
801 return platform_driver_register(&spi_imx_driver);
804 static void __exit spi_imx_exit(void)
806 platform_driver_unregister(&spi_imx_driver);
809 module_init(spi_imx_init);
810 module_exit(spi_imx_exit);
812 MODULE_DESCRIPTION("SPI Master Controller driver");
813 MODULE_AUTHOR("Sascha Hauer, Pengutronix");
814 MODULE_LICENSE("GPL");