Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
spi-oc-tiny.c
Go to the documentation of this file.
1 /*
2  * OpenCores tiny SPI master driver
3  *
4  * http://opencores.org/project,tiny_spi
5  *
6  * Copyright (C) 2011 Thomas Chou <[email protected]>
7  *
8  * Based on spi_s3c24xx.c, which is:
9  * Copyright (c) 2006 Ben Dooks
10  * Copyright (c) 2006 Simtec Electronics
11  * Ben Dooks <[email protected]>
12  *
13  * This program is free software; you can redistribute it and/or modify
14  * it under the terms of the GNU General Public License version 2 as
15  * published by the Free Software Foundation.
16  */
17 
18 #include <linux/init.h>
19 #include <linux/interrupt.h>
20 #include <linux/errno.h>
21 #include <linux/module.h>
22 #include <linux/platform_device.h>
23 #include <linux/spi/spi.h>
24 #include <linux/spi/spi_bitbang.h>
25 #include <linux/spi/spi_oc_tiny.h>
26 #include <linux/io.h>
27 #include <linux/gpio.h>
28 #include <linux/of.h>
29 
30 #define DRV_NAME "spi_oc_tiny"
31 
32 #define TINY_SPI_RXDATA 0
33 #define TINY_SPI_TXDATA 4
34 #define TINY_SPI_STATUS 8
35 #define TINY_SPI_CONTROL 12
36 #define TINY_SPI_BAUD 16
37 
38 #define TINY_SPI_STATUS_TXE 0x1
39 #define TINY_SPI_STATUS_TXR 0x2
40 
41 struct tiny_spi {
42  /* bitbang has to be first */
43  struct spi_bitbang bitbang;
44  struct completion done;
45 
46  void __iomem *base;
47  int irq;
48  unsigned int freq;
49  unsigned int baudwidth;
50  unsigned int baud;
51  unsigned int speed_hz;
52  unsigned int mode;
53  unsigned int len;
54  unsigned int txc, rxc;
55  const u8 *txp;
56  u8 *rxp;
57  unsigned int gpio_cs_count;
58  int *gpio_cs;
59 };
60 
61 static inline struct tiny_spi *tiny_spi_to_hw(struct spi_device *sdev)
62 {
63  return spi_master_get_devdata(sdev->master);
64 }
65 
66 static unsigned int tiny_spi_baud(struct spi_device *spi, unsigned int hz)
67 {
68  struct tiny_spi *hw = tiny_spi_to_hw(spi);
69 
70  return min(DIV_ROUND_UP(hw->freq, hz * 2), (1U << hw->baudwidth)) - 1;
71 }
72 
73 static void tiny_spi_chipselect(struct spi_device *spi, int is_active)
74 {
75  struct tiny_spi *hw = tiny_spi_to_hw(spi);
76 
77  if (hw->gpio_cs_count) {
78  gpio_set_value(hw->gpio_cs[spi->chip_select],
79  (spi->mode & SPI_CS_HIGH) ? is_active : !is_active);
80  }
81 }
82 
83 static int tiny_spi_setup_transfer(struct spi_device *spi,
84  struct spi_transfer *t)
85 {
86  struct tiny_spi *hw = tiny_spi_to_hw(spi);
87  unsigned int baud = hw->baud;
88 
89  if (t) {
90  if (t->speed_hz && t->speed_hz != hw->speed_hz)
91  baud = tiny_spi_baud(spi, t->speed_hz);
92  }
93  writel(baud, hw->base + TINY_SPI_BAUD);
94  writel(hw->mode, hw->base + TINY_SPI_CONTROL);
95  return 0;
96 }
97 
98 static int tiny_spi_setup(struct spi_device *spi)
99 {
100  struct tiny_spi *hw = tiny_spi_to_hw(spi);
101 
102  if (spi->max_speed_hz != hw->speed_hz) {
103  hw->speed_hz = spi->max_speed_hz;
104  hw->baud = tiny_spi_baud(spi, hw->speed_hz);
105  }
106  hw->mode = spi->mode & (SPI_CPOL | SPI_CPHA);
107  return 0;
108 }
109 
110 static inline void tiny_spi_wait_txr(struct tiny_spi *hw)
111 {
112  while (!(readb(hw->base + TINY_SPI_STATUS) &
113  TINY_SPI_STATUS_TXR))
114  cpu_relax();
115 }
116 
117 static inline void tiny_spi_wait_txe(struct tiny_spi *hw)
118 {
119  while (!(readb(hw->base + TINY_SPI_STATUS) &
120  TINY_SPI_STATUS_TXE))
121  cpu_relax();
122 }
123 
124 static int tiny_spi_txrx_bufs(struct spi_device *spi, struct spi_transfer *t)
125 {
126  struct tiny_spi *hw = tiny_spi_to_hw(spi);
127  const u8 *txp = t->tx_buf;
128  u8 *rxp = t->rx_buf;
129  unsigned int i;
130 
131  if (hw->irq >= 0) {
132  /* use interrupt driven data transfer */
133  hw->len = t->len;
134  hw->txp = t->tx_buf;
135  hw->rxp = t->rx_buf;
136  hw->txc = 0;
137  hw->rxc = 0;
138 
139  /* send the first byte */
140  if (t->len > 1) {
141  writeb(hw->txp ? *hw->txp++ : 0,
142  hw->base + TINY_SPI_TXDATA);
143  hw->txc++;
144  writeb(hw->txp ? *hw->txp++ : 0,
145  hw->base + TINY_SPI_TXDATA);
146  hw->txc++;
147  writeb(TINY_SPI_STATUS_TXR, hw->base + TINY_SPI_STATUS);
148  } else {
149  writeb(hw->txp ? *hw->txp++ : 0,
150  hw->base + TINY_SPI_TXDATA);
151  hw->txc++;
152  writeb(TINY_SPI_STATUS_TXE, hw->base + TINY_SPI_STATUS);
153  }
154 
155  wait_for_completion(&hw->done);
156  } else if (txp && rxp) {
157  /* we need to tighten the transfer loop */
158  writeb(*txp++, hw->base + TINY_SPI_TXDATA);
159  if (t->len > 1) {
160  writeb(*txp++, hw->base + TINY_SPI_TXDATA);
161  for (i = 2; i < t->len; i++) {
162  u8 rx, tx = *txp++;
163  tiny_spi_wait_txr(hw);
164  rx = readb(hw->base + TINY_SPI_TXDATA);
165  writeb(tx, hw->base + TINY_SPI_TXDATA);
166  *rxp++ = rx;
167  }
168  tiny_spi_wait_txr(hw);
169  *rxp++ = readb(hw->base + TINY_SPI_TXDATA);
170  }
171  tiny_spi_wait_txe(hw);
172  *rxp++ = readb(hw->base + TINY_SPI_RXDATA);
173  } else if (rxp) {
174  writeb(0, hw->base + TINY_SPI_TXDATA);
175  if (t->len > 1) {
176  writeb(0,
177  hw->base + TINY_SPI_TXDATA);
178  for (i = 2; i < t->len; i++) {
179  u8 rx;
180  tiny_spi_wait_txr(hw);
181  rx = readb(hw->base + TINY_SPI_TXDATA);
182  writeb(0, hw->base + TINY_SPI_TXDATA);
183  *rxp++ = rx;
184  }
185  tiny_spi_wait_txr(hw);
186  *rxp++ = readb(hw->base + TINY_SPI_TXDATA);
187  }
188  tiny_spi_wait_txe(hw);
189  *rxp++ = readb(hw->base + TINY_SPI_RXDATA);
190  } else if (txp) {
191  writeb(*txp++, hw->base + TINY_SPI_TXDATA);
192  if (t->len > 1) {
193  writeb(*txp++, hw->base + TINY_SPI_TXDATA);
194  for (i = 2; i < t->len; i++) {
195  u8 tx = *txp++;
196  tiny_spi_wait_txr(hw);
197  writeb(tx, hw->base + TINY_SPI_TXDATA);
198  }
199  }
200  tiny_spi_wait_txe(hw);
201  } else {
202  writeb(0, hw->base + TINY_SPI_TXDATA);
203  if (t->len > 1) {
204  writeb(0, hw->base + TINY_SPI_TXDATA);
205  for (i = 2; i < t->len; i++) {
206  tiny_spi_wait_txr(hw);
207  writeb(0, hw->base + TINY_SPI_TXDATA);
208  }
209  }
210  tiny_spi_wait_txe(hw);
211  }
212  return t->len;
213 }
214 
215 static irqreturn_t tiny_spi_irq(int irq, void *dev)
216 {
217  struct tiny_spi *hw = dev;
218 
219  writeb(0, hw->base + TINY_SPI_STATUS);
220  if (hw->rxc + 1 == hw->len) {
221  if (hw->rxp)
222  *hw->rxp++ = readb(hw->base + TINY_SPI_RXDATA);
223  hw->rxc++;
224  complete(&hw->done);
225  } else {
226  if (hw->rxp)
227  *hw->rxp++ = readb(hw->base + TINY_SPI_TXDATA);
228  hw->rxc++;
229  if (hw->txc < hw->len) {
230  writeb(hw->txp ? *hw->txp++ : 0,
231  hw->base + TINY_SPI_TXDATA);
232  hw->txc++;
233  writeb(TINY_SPI_STATUS_TXR,
234  hw->base + TINY_SPI_STATUS);
235  } else {
236  writeb(TINY_SPI_STATUS_TXE,
237  hw->base + TINY_SPI_STATUS);
238  }
239  }
240  return IRQ_HANDLED;
241 }
242 
243 #ifdef CONFIG_OF
244 #include <linux/of_gpio.h>
245 
246 static int __devinit tiny_spi_of_probe(struct platform_device *pdev)
247 {
248  struct tiny_spi *hw = platform_get_drvdata(pdev);
249  struct device_node *np = pdev->dev.of_node;
250  unsigned int i;
251  const __be32 *val;
252  int len;
253 
254  if (!np)
255  return 0;
256  hw->gpio_cs_count = of_gpio_count(np);
257  if (hw->gpio_cs_count) {
258  hw->gpio_cs = devm_kzalloc(&pdev->dev,
259  hw->gpio_cs_count * sizeof(unsigned int),
260  GFP_KERNEL);
261  if (!hw->gpio_cs)
262  return -ENOMEM;
263  }
264  for (i = 0; i < hw->gpio_cs_count; i++) {
265  hw->gpio_cs[i] = of_get_gpio_flags(np, i, NULL);
266  if (hw->gpio_cs[i] < 0)
267  return -ENODEV;
268  }
269  hw->bitbang.master->dev.of_node = pdev->dev.of_node;
270  val = of_get_property(pdev->dev.of_node,
271  "clock-frequency", &len);
272  if (val && len >= sizeof(__be32))
273  hw->freq = be32_to_cpup(val);
274  val = of_get_property(pdev->dev.of_node, "baud-width", &len);
275  if (val && len >= sizeof(__be32))
276  hw->baudwidth = be32_to_cpup(val);
277  return 0;
278 }
279 #else /* !CONFIG_OF */
280 static int __devinit tiny_spi_of_probe(struct platform_device *pdev)
281 {
282  return 0;
283 }
284 #endif /* CONFIG_OF */
285 
286 static int __devinit tiny_spi_probe(struct platform_device *pdev)
287 {
288  struct tiny_spi_platform_data *platp = pdev->dev.platform_data;
289  struct tiny_spi *hw;
290  struct spi_master *master;
291  struct resource *res;
292  unsigned int i;
293  int err = -ENODEV;
294 
295  master = spi_alloc_master(&pdev->dev, sizeof(struct tiny_spi));
296  if (!master)
297  return err;
298 
299  /* setup the master state. */
300  master->bus_num = pdev->id;
301  master->num_chipselect = 255;
302  master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH;
303  master->setup = tiny_spi_setup;
304 
305  hw = spi_master_get_devdata(master);
306  platform_set_drvdata(pdev, hw);
307 
308  /* setup the state for the bitbang driver */
309  hw->bitbang.master = spi_master_get(master);
310  if (!hw->bitbang.master)
311  return err;
312  hw->bitbang.setup_transfer = tiny_spi_setup_transfer;
313  hw->bitbang.chipselect = tiny_spi_chipselect;
314  hw->bitbang.txrx_bufs = tiny_spi_txrx_bufs;
315 
316  /* find and map our resources */
317  res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
318  if (!res)
319  goto exit_busy;
320  if (!devm_request_mem_region(&pdev->dev, res->start, resource_size(res),
321  pdev->name))
322  goto exit_busy;
323  hw->base = devm_ioremap_nocache(&pdev->dev, res->start,
324  resource_size(res));
325  if (!hw->base)
326  goto exit_busy;
327  /* irq is optional */
328  hw->irq = platform_get_irq(pdev, 0);
329  if (hw->irq >= 0) {
330  init_completion(&hw->done);
331  err = devm_request_irq(&pdev->dev, hw->irq, tiny_spi_irq, 0,
332  pdev->name, hw);
333  if (err)
334  goto exit;
335  }
336  /* find platform data */
337  if (platp) {
338  hw->gpio_cs_count = platp->gpio_cs_count;
339  hw->gpio_cs = platp->gpio_cs;
340  if (platp->gpio_cs_count && !platp->gpio_cs)
341  goto exit_busy;
342  hw->freq = platp->freq;
343  hw->baudwidth = platp->baudwidth;
344  } else {
345  err = tiny_spi_of_probe(pdev);
346  if (err)
347  goto exit;
348  }
349  for (i = 0; i < hw->gpio_cs_count; i++) {
350  err = gpio_request(hw->gpio_cs[i], dev_name(&pdev->dev));
351  if (err)
352  goto exit_gpio;
353  gpio_direction_output(hw->gpio_cs[i], 1);
354  }
355  hw->bitbang.master->num_chipselect = max(1U, hw->gpio_cs_count);
356 
357  /* register our spi controller */
358  err = spi_bitbang_start(&hw->bitbang);
359  if (err)
360  goto exit;
361  dev_info(&pdev->dev, "base %p, irq %d\n", hw->base, hw->irq);
362 
363  return 0;
364 
365 exit_gpio:
366  while (i-- > 0)
367  gpio_free(hw->gpio_cs[i]);
368 exit_busy:
369  err = -EBUSY;
370 exit:
371  platform_set_drvdata(pdev, NULL);
372  spi_master_put(master);
373  return err;
374 }
375 
376 static int __devexit tiny_spi_remove(struct platform_device *pdev)
377 {
378  struct tiny_spi *hw = platform_get_drvdata(pdev);
379  struct spi_master *master = hw->bitbang.master;
380  unsigned int i;
381 
382  spi_bitbang_stop(&hw->bitbang);
383  for (i = 0; i < hw->gpio_cs_count; i++)
384  gpio_free(hw->gpio_cs[i]);
385  platform_set_drvdata(pdev, NULL);
386  spi_master_put(master);
387  return 0;
388 }
389 
390 #ifdef CONFIG_OF
391 static const struct of_device_id tiny_spi_match[] = {
392  { .compatible = "opencores,tiny-spi-rtlsvn2", },
393  {},
394 };
395 MODULE_DEVICE_TABLE(of, tiny_spi_match);
396 #else /* CONFIG_OF */
397 #define tiny_spi_match NULL
398 #endif /* CONFIG_OF */
399 
400 static struct platform_driver tiny_spi_driver = {
401  .probe = tiny_spi_probe,
402  .remove = __devexit_p(tiny_spi_remove),
403  .driver = {
404  .name = DRV_NAME,
405  .owner = THIS_MODULE,
406  .pm = NULL,
407  .of_match_table = tiny_spi_match,
408  },
409 };
410 module_platform_driver(tiny_spi_driver);
411 
412 MODULE_DESCRIPTION("OpenCores tiny SPI driver");
413 MODULE_AUTHOR("Thomas Chou <[email protected]>");
414 MODULE_LICENSE("GPL");
415 MODULE_ALIAS("platform:" DRV_NAME);
Generated on Thu Jan 10 2013 14:25:37 for Linux Kernel by   doxygen 1.8.2