Thomas Chou | 0b78253 | 2011-02-14 10:10:43 +0800 | [diff] [blame] | 1 | /* |
| 2 | * Altera SPI driver |
| 3 | * |
| 4 | * Copyright (C) 2008 Thomas Chou <thomas@wytron.com.tw> |
| 5 | * |
| 6 | * Based on spi_s3c24xx.c, which is: |
| 7 | * Copyright (c) 2006 Ben Dooks |
| 8 | * Copyright (c) 2006 Simtec Electronics |
| 9 | * Ben Dooks <ben@simtec.co.uk> |
| 10 | * |
| 11 | * This program is free software; you can redistribute it and/or modify |
| 12 | * it under the terms of the GNU General Public License version 2 as |
| 13 | * published by the Free Software Foundation. |
| 14 | */ |
| 15 | |
| 16 | #include <linux/init.h> |
| 17 | #include <linux/interrupt.h> |
| 18 | #include <linux/errno.h> |
Paul Gortmaker | d7614de | 2011-07-03 15:44:29 -0400 | [diff] [blame] | 19 | #include <linux/module.h> |
Thomas Chou | 0b78253 | 2011-02-14 10:10:43 +0800 | [diff] [blame] | 20 | #include <linux/platform_device.h> |
| 21 | #include <linux/spi/spi.h> |
| 22 | #include <linux/spi/spi_bitbang.h> |
| 23 | #include <linux/io.h> |
| 24 | #include <linux/of.h> |
| 25 | |
| 26 | #define DRV_NAME "spi_altera" |
| 27 | |
| 28 | #define ALTERA_SPI_RXDATA 0 |
| 29 | #define ALTERA_SPI_TXDATA 4 |
| 30 | #define ALTERA_SPI_STATUS 8 |
| 31 | #define ALTERA_SPI_CONTROL 12 |
| 32 | #define ALTERA_SPI_SLAVE_SEL 20 |
| 33 | |
| 34 | #define ALTERA_SPI_STATUS_ROE_MSK 0x8 |
| 35 | #define ALTERA_SPI_STATUS_TOE_MSK 0x10 |
| 36 | #define ALTERA_SPI_STATUS_TMT_MSK 0x20 |
| 37 | #define ALTERA_SPI_STATUS_TRDY_MSK 0x40 |
| 38 | #define ALTERA_SPI_STATUS_RRDY_MSK 0x80 |
| 39 | #define ALTERA_SPI_STATUS_E_MSK 0x100 |
| 40 | |
| 41 | #define ALTERA_SPI_CONTROL_IROE_MSK 0x8 |
| 42 | #define ALTERA_SPI_CONTROL_ITOE_MSK 0x10 |
| 43 | #define ALTERA_SPI_CONTROL_ITRDY_MSK 0x40 |
| 44 | #define ALTERA_SPI_CONTROL_IRRDY_MSK 0x80 |
| 45 | #define ALTERA_SPI_CONTROL_IE_MSK 0x100 |
| 46 | #define ALTERA_SPI_CONTROL_SSO_MSK 0x400 |
| 47 | |
| 48 | struct altera_spi { |
| 49 | /* bitbang has to be first */ |
| 50 | struct spi_bitbang bitbang; |
| 51 | struct completion done; |
| 52 | |
| 53 | void __iomem *base; |
| 54 | int irq; |
| 55 | int len; |
| 56 | int count; |
| 57 | int bytes_per_word; |
| 58 | unsigned long imr; |
| 59 | |
| 60 | /* data buffers */ |
| 61 | const unsigned char *tx; |
| 62 | unsigned char *rx; |
| 63 | }; |
| 64 | |
| 65 | static inline struct altera_spi *altera_spi_to_hw(struct spi_device *sdev) |
| 66 | { |
| 67 | return spi_master_get_devdata(sdev->master); |
| 68 | } |
| 69 | |
| 70 | static void altera_spi_chipsel(struct spi_device *spi, int value) |
| 71 | { |
| 72 | struct altera_spi *hw = altera_spi_to_hw(spi); |
| 73 | |
| 74 | if (spi->mode & SPI_CS_HIGH) { |
| 75 | switch (value) { |
| 76 | case BITBANG_CS_INACTIVE: |
| 77 | writel(1 << spi->chip_select, |
| 78 | hw->base + ALTERA_SPI_SLAVE_SEL); |
| 79 | hw->imr |= ALTERA_SPI_CONTROL_SSO_MSK; |
| 80 | writel(hw->imr, hw->base + ALTERA_SPI_CONTROL); |
| 81 | break; |
| 82 | |
| 83 | case BITBANG_CS_ACTIVE: |
| 84 | hw->imr &= ~ALTERA_SPI_CONTROL_SSO_MSK; |
| 85 | writel(hw->imr, hw->base + ALTERA_SPI_CONTROL); |
| 86 | writel(0, hw->base + ALTERA_SPI_SLAVE_SEL); |
| 87 | break; |
| 88 | } |
| 89 | } else { |
| 90 | switch (value) { |
| 91 | case BITBANG_CS_INACTIVE: |
| 92 | hw->imr &= ~ALTERA_SPI_CONTROL_SSO_MSK; |
| 93 | writel(hw->imr, hw->base + ALTERA_SPI_CONTROL); |
| 94 | break; |
| 95 | |
| 96 | case BITBANG_CS_ACTIVE: |
| 97 | writel(1 << spi->chip_select, |
| 98 | hw->base + ALTERA_SPI_SLAVE_SEL); |
| 99 | hw->imr |= ALTERA_SPI_CONTROL_SSO_MSK; |
| 100 | writel(hw->imr, hw->base + ALTERA_SPI_CONTROL); |
| 101 | break; |
| 102 | } |
| 103 | } |
| 104 | } |
| 105 | |
Thomas Chou | 0b78253 | 2011-02-14 10:10:43 +0800 | [diff] [blame] | 106 | static inline unsigned int hw_txbyte(struct altera_spi *hw, int count) |
| 107 | { |
| 108 | if (hw->tx) { |
| 109 | switch (hw->bytes_per_word) { |
| 110 | case 1: |
| 111 | return hw->tx[count]; |
| 112 | case 2: |
| 113 | return (hw->tx[count * 2] |
| 114 | | (hw->tx[count * 2 + 1] << 8)); |
| 115 | } |
| 116 | } |
| 117 | return 0; |
| 118 | } |
| 119 | |
| 120 | static int altera_spi_txrx(struct spi_device *spi, struct spi_transfer *t) |
| 121 | { |
| 122 | struct altera_spi *hw = altera_spi_to_hw(spi); |
| 123 | |
| 124 | hw->tx = t->tx_buf; |
| 125 | hw->rx = t->rx_buf; |
| 126 | hw->count = 0; |
Axel Lin | f073d37 | 2013-08-29 23:41:20 +0800 | [diff] [blame] | 127 | hw->bytes_per_word = DIV_ROUND_UP(t->bits_per_word, 8); |
Thomas Chou | 0b78253 | 2011-02-14 10:10:43 +0800 | [diff] [blame] | 128 | hw->len = t->len / hw->bytes_per_word; |
| 129 | |
| 130 | if (hw->irq >= 0) { |
| 131 | /* enable receive interrupt */ |
| 132 | hw->imr |= ALTERA_SPI_CONTROL_IRRDY_MSK; |
| 133 | writel(hw->imr, hw->base + ALTERA_SPI_CONTROL); |
| 134 | |
| 135 | /* send the first byte */ |
| 136 | writel(hw_txbyte(hw, 0), hw->base + ALTERA_SPI_TXDATA); |
| 137 | |
| 138 | wait_for_completion(&hw->done); |
| 139 | /* disable receive interrupt */ |
| 140 | hw->imr &= ~ALTERA_SPI_CONTROL_IRRDY_MSK; |
| 141 | writel(hw->imr, hw->base + ALTERA_SPI_CONTROL); |
| 142 | } else { |
Axel Lin | 72be0ee | 2013-08-15 14:18:46 +0800 | [diff] [blame] | 143 | while (hw->count < hw->len) { |
Thomas Chou | 0b78253 | 2011-02-14 10:10:43 +0800 | [diff] [blame] | 144 | unsigned int rxd; |
| 145 | |
Axel Lin | 72be0ee | 2013-08-15 14:18:46 +0800 | [diff] [blame] | 146 | writel(hw_txbyte(hw, hw->count), |
| 147 | hw->base + ALTERA_SPI_TXDATA); |
| 148 | |
Thomas Chou | 0b78253 | 2011-02-14 10:10:43 +0800 | [diff] [blame] | 149 | while (!(readl(hw->base + ALTERA_SPI_STATUS) & |
| 150 | ALTERA_SPI_STATUS_RRDY_MSK)) |
| 151 | cpu_relax(); |
| 152 | |
| 153 | rxd = readl(hw->base + ALTERA_SPI_RXDATA); |
| 154 | if (hw->rx) { |
| 155 | switch (hw->bytes_per_word) { |
| 156 | case 1: |
| 157 | hw->rx[hw->count] = rxd; |
| 158 | break; |
| 159 | case 2: |
| 160 | hw->rx[hw->count * 2] = rxd; |
| 161 | hw->rx[hw->count * 2 + 1] = rxd >> 8; |
| 162 | break; |
| 163 | } |
| 164 | } |
| 165 | |
| 166 | hw->count++; |
Thomas Chou | 0b78253 | 2011-02-14 10:10:43 +0800 | [diff] [blame] | 167 | } |
Thomas Chou | 0b78253 | 2011-02-14 10:10:43 +0800 | [diff] [blame] | 168 | } |
| 169 | |
| 170 | return hw->count * hw->bytes_per_word; |
| 171 | } |
| 172 | |
| 173 | static irqreturn_t altera_spi_irq(int irq, void *dev) |
| 174 | { |
| 175 | struct altera_spi *hw = dev; |
| 176 | unsigned int rxd; |
| 177 | |
| 178 | rxd = readl(hw->base + ALTERA_SPI_RXDATA); |
| 179 | if (hw->rx) { |
| 180 | switch (hw->bytes_per_word) { |
| 181 | case 1: |
| 182 | hw->rx[hw->count] = rxd; |
| 183 | break; |
| 184 | case 2: |
| 185 | hw->rx[hw->count * 2] = rxd; |
| 186 | hw->rx[hw->count * 2 + 1] = rxd >> 8; |
| 187 | break; |
| 188 | } |
| 189 | } |
| 190 | |
| 191 | hw->count++; |
| 192 | |
| 193 | if (hw->count < hw->len) |
| 194 | writel(hw_txbyte(hw, hw->count), hw->base + ALTERA_SPI_TXDATA); |
| 195 | else |
| 196 | complete(&hw->done); |
| 197 | |
| 198 | return IRQ_HANDLED; |
| 199 | } |
| 200 | |
Grant Likely | fd4a319 | 2012-12-07 16:57:14 +0000 | [diff] [blame] | 201 | static int altera_spi_probe(struct platform_device *pdev) |
Thomas Chou | 0b78253 | 2011-02-14 10:10:43 +0800 | [diff] [blame] | 202 | { |
Jingoo Han | 8074cf0 | 2013-07-30 16:58:59 +0900 | [diff] [blame] | 203 | struct altera_spi_platform_data *platp = dev_get_platdata(&pdev->dev); |
Thomas Chou | 0b78253 | 2011-02-14 10:10:43 +0800 | [diff] [blame] | 204 | struct altera_spi *hw; |
| 205 | struct spi_master *master; |
| 206 | struct resource *res; |
| 207 | int err = -ENODEV; |
| 208 | |
| 209 | master = spi_alloc_master(&pdev->dev, sizeof(struct altera_spi)); |
| 210 | if (!master) |
| 211 | return err; |
| 212 | |
| 213 | /* setup the master state. */ |
| 214 | master->bus_num = pdev->id; |
| 215 | master->num_chipselect = 16; |
| 216 | master->mode_bits = SPI_CS_HIGH; |
Thomas Chou | 0b78253 | 2011-02-14 10:10:43 +0800 | [diff] [blame] | 217 | |
| 218 | hw = spi_master_get_devdata(master); |
| 219 | platform_set_drvdata(pdev, hw); |
| 220 | |
| 221 | /* setup the state for the bitbang driver */ |
Axel Lin | 94c69f7 | 2013-09-10 15:43:41 +0800 | [diff] [blame] | 222 | hw->bitbang.master = master; |
Thomas Chou | 0b78253 | 2011-02-14 10:10:43 +0800 | [diff] [blame] | 223 | hw->bitbang.chipselect = altera_spi_chipsel; |
| 224 | hw->bitbang.txrx_bufs = altera_spi_txrx; |
| 225 | |
| 226 | /* find and map our resources */ |
| 227 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
Julia Lawall | b3136f8 | 2013-08-24 19:13:15 +0200 | [diff] [blame] | 228 | hw->base = devm_ioremap_resource(&pdev->dev, res); |
| 229 | if (IS_ERR(hw->base)) { |
| 230 | err = PTR_ERR(hw->base); |
| 231 | goto exit; |
| 232 | } |
Thomas Chou | 0b78253 | 2011-02-14 10:10:43 +0800 | [diff] [blame] | 233 | /* program defaults into the registers */ |
| 234 | hw->imr = 0; /* disable spi interrupts */ |
| 235 | writel(hw->imr, hw->base + ALTERA_SPI_CONTROL); |
| 236 | writel(0, hw->base + ALTERA_SPI_STATUS); /* clear status reg */ |
| 237 | if (readl(hw->base + ALTERA_SPI_STATUS) & ALTERA_SPI_STATUS_RRDY_MSK) |
| 238 | readl(hw->base + ALTERA_SPI_RXDATA); /* flush rxdata */ |
| 239 | /* irq is optional */ |
| 240 | hw->irq = platform_get_irq(pdev, 0); |
| 241 | if (hw->irq >= 0) { |
| 242 | init_completion(&hw->done); |
| 243 | err = devm_request_irq(&pdev->dev, hw->irq, altera_spi_irq, 0, |
| 244 | pdev->name, hw); |
| 245 | if (err) |
| 246 | goto exit; |
| 247 | } |
| 248 | /* find platform data */ |
| 249 | if (!platp) |
| 250 | hw->bitbang.master->dev.of_node = pdev->dev.of_node; |
| 251 | |
| 252 | /* register our spi controller */ |
| 253 | err = spi_bitbang_start(&hw->bitbang); |
| 254 | if (err) |
| 255 | goto exit; |
| 256 | dev_info(&pdev->dev, "base %p, irq %d\n", hw->base, hw->irq); |
| 257 | |
| 258 | return 0; |
Thomas Chou | 0b78253 | 2011-02-14 10:10:43 +0800 | [diff] [blame] | 259 | exit: |
Thomas Chou | 0b78253 | 2011-02-14 10:10:43 +0800 | [diff] [blame] | 260 | spi_master_put(master); |
| 261 | return err; |
| 262 | } |
| 263 | |
Grant Likely | fd4a319 | 2012-12-07 16:57:14 +0000 | [diff] [blame] | 264 | static int altera_spi_remove(struct platform_device *dev) |
Thomas Chou | 0b78253 | 2011-02-14 10:10:43 +0800 | [diff] [blame] | 265 | { |
| 266 | struct altera_spi *hw = platform_get_drvdata(dev); |
| 267 | struct spi_master *master = hw->bitbang.master; |
| 268 | |
| 269 | spi_bitbang_stop(&hw->bitbang); |
Thomas Chou | 0b78253 | 2011-02-14 10:10:43 +0800 | [diff] [blame] | 270 | spi_master_put(master); |
| 271 | return 0; |
| 272 | } |
| 273 | |
| 274 | #ifdef CONFIG_OF |
| 275 | static const struct of_device_id altera_spi_match[] = { |
| 276 | { .compatible = "ALTR,spi-1.0", }, |
Dinh Nguyen | 13960b4 | 2013-08-14 15:25:19 -0500 | [diff] [blame] | 277 | { .compatible = "altr,spi-1.0", }, |
Thomas Chou | 0b78253 | 2011-02-14 10:10:43 +0800 | [diff] [blame] | 278 | {}, |
| 279 | }; |
| 280 | MODULE_DEVICE_TABLE(of, altera_spi_match); |
Thomas Chou | 0b78253 | 2011-02-14 10:10:43 +0800 | [diff] [blame] | 281 | #endif /* CONFIG_OF */ |
| 282 | |
| 283 | static struct platform_driver altera_spi_driver = { |
| 284 | .probe = altera_spi_probe, |
Grant Likely | fd4a319 | 2012-12-07 16:57:14 +0000 | [diff] [blame] | 285 | .remove = altera_spi_remove, |
Thomas Chou | 0b78253 | 2011-02-14 10:10:43 +0800 | [diff] [blame] | 286 | .driver = { |
| 287 | .name = DRV_NAME, |
| 288 | .owner = THIS_MODULE, |
| 289 | .pm = NULL, |
Tobias Klauser | 89f98dc | 2012-08-15 09:30:28 +0200 | [diff] [blame] | 290 | .of_match_table = of_match_ptr(altera_spi_match), |
Thomas Chou | 0b78253 | 2011-02-14 10:10:43 +0800 | [diff] [blame] | 291 | }, |
| 292 | }; |
Grant Likely | 940ab88 | 2011-10-05 11:29:49 -0600 | [diff] [blame] | 293 | module_platform_driver(altera_spi_driver); |
Thomas Chou | 0b78253 | 2011-02-14 10:10:43 +0800 | [diff] [blame] | 294 | |
| 295 | MODULE_DESCRIPTION("Altera SPI driver"); |
| 296 | MODULE_AUTHOR("Thomas Chou <thomas@wytron.com.tw>"); |
| 297 | MODULE_LICENSE("GPL"); |
| 298 | MODULE_ALIAS("platform:" DRV_NAME); |