Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

Linux/drivers/spi/spi-nuc900.c

  1 /*
  2  * Copyright (c) 2009 Nuvoton technology.
  3  * Wan ZongShun <mcuos.com@gmail.com>
  4  *
  5  * This program is free software; you can redistribute it and/or modify
  6  * it under the terms of the GNU General Public License version 2 as
  7  * published by the Free Software Foundation.
  8  *
  9  */
 10 
 11 #include <linux/module.h>
 12 #include <linux/spinlock.h>
 13 #include <linux/workqueue.h>
 14 #include <linux/interrupt.h>
 15 #include <linux/delay.h>
 16 #include <linux/errno.h>
 17 #include <linux/err.h>
 18 #include <linux/clk.h>
 19 #include <linux/device.h>
 20 #include <linux/platform_device.h>
 21 #include <linux/gpio.h>
 22 #include <linux/io.h>
 23 #include <linux/slab.h>
 24 
 25 #include <linux/spi/spi.h>
 26 #include <linux/spi/spi_bitbang.h>
 27 
 28 #include <linux/platform_data/spi-nuc900.h>
 29 
 30 /* usi registers offset */
 31 #define USI_CNT         0x00
 32 #define USI_DIV         0x04
 33 #define USI_SSR         0x08
 34 #define USI_RX0         0x10
 35 #define USI_TX0         0x10
 36 
 37 /* usi register bit */
 38 #define ENINT           (0x01 << 17)
 39 #define ENFLG           (0x01 << 16)
 40 #define SLEEP           (0x0f << 12)
 41 #define TXNUM           (0x03 << 8)
 42 #define TXBITLEN        (0x1f << 3)
 43 #define TXNEG           (0x01 << 2)
 44 #define RXNEG           (0x01 << 1)
 45 #define LSB             (0x01 << 10)
 46 #define SELECTLEV       (0x01 << 2)
 47 #define SELECTPOL       (0x01 << 31)
 48 #define SELECTSLAVE     0x01
 49 #define GOBUSY          0x01
 50 
 51 struct nuc900_spi {
 52         struct spi_bitbang       bitbang;
 53         struct completion        done;
 54         void __iomem            *regs;
 55         int                      irq;
 56         int                      len;
 57         int                      count;
 58         const unsigned char     *tx;
 59         unsigned char           *rx;
 60         struct clk              *clk;
 61         struct spi_master       *master;
 62         struct nuc900_spi_info *pdata;
 63         spinlock_t              lock;
 64 };
 65 
 66 static inline struct nuc900_spi *to_hw(struct spi_device *sdev)
 67 {
 68         return spi_master_get_devdata(sdev->master);
 69 }
 70 
 71 static void nuc900_slave_select(struct spi_device *spi, unsigned int ssr)
 72 {
 73         struct nuc900_spi *hw = to_hw(spi);
 74         unsigned int val;
 75         unsigned int cs = spi->mode & SPI_CS_HIGH ? 1 : 0;
 76         unsigned int cpol = spi->mode & SPI_CPOL ? 1 : 0;
 77         unsigned long flags;
 78 
 79         spin_lock_irqsave(&hw->lock, flags);
 80 
 81         val = __raw_readl(hw->regs + USI_SSR);
 82 
 83         if (!cs)
 84                 val &= ~SELECTLEV;
 85         else
 86                 val |= SELECTLEV;
 87 
 88         if (!ssr)
 89                 val &= ~SELECTSLAVE;
 90         else
 91                 val |= SELECTSLAVE;
 92 
 93         __raw_writel(val, hw->regs + USI_SSR);
 94 
 95         val = __raw_readl(hw->regs + USI_CNT);
 96 
 97         if (!cpol)
 98                 val &= ~SELECTPOL;
 99         else
100                 val |= SELECTPOL;
101 
102         __raw_writel(val, hw->regs + USI_CNT);
103 
104         spin_unlock_irqrestore(&hw->lock, flags);
105 }
106 
107 static void nuc900_spi_chipsel(struct spi_device *spi, int value)
108 {
109         switch (value) {
110         case BITBANG_CS_INACTIVE:
111                 nuc900_slave_select(spi, 0);
112                 break;
113 
114         case BITBANG_CS_ACTIVE:
115                 nuc900_slave_select(spi, 1);
116                 break;
117         }
118 }
119 
120 static void nuc900_spi_setup_txnum(struct nuc900_spi *hw, unsigned int txnum)
121 {
122         unsigned int val;
123         unsigned long flags;
124 
125         spin_lock_irqsave(&hw->lock, flags);
126 
127         val = __raw_readl(hw->regs + USI_CNT) & ~TXNUM;
128 
129         if (txnum)
130                 val |= txnum << 0x08;
131 
132         __raw_writel(val, hw->regs + USI_CNT);
133 
134         spin_unlock_irqrestore(&hw->lock, flags);
135 
136 }
137 
138 static void nuc900_spi_setup_txbitlen(struct nuc900_spi *hw,
139                                                         unsigned int txbitlen)
140 {
141         unsigned int val;
142         unsigned long flags;
143 
144         spin_lock_irqsave(&hw->lock, flags);
145 
146         val = __raw_readl(hw->regs + USI_CNT) & ~TXBITLEN;
147 
148         val |= (txbitlen << 0x03);
149 
150         __raw_writel(val, hw->regs + USI_CNT);
151 
152         spin_unlock_irqrestore(&hw->lock, flags);
153 }
154 
155 static void nuc900_spi_gobusy(struct nuc900_spi *hw)
156 {
157         unsigned int val;
158         unsigned long flags;
159 
160         spin_lock_irqsave(&hw->lock, flags);
161 
162         val = __raw_readl(hw->regs + USI_CNT);
163 
164         val |= GOBUSY;
165 
166         __raw_writel(val, hw->regs + USI_CNT);
167 
168         spin_unlock_irqrestore(&hw->lock, flags);
169 }
170 
171 static inline unsigned int hw_txbyte(struct nuc900_spi *hw, int count)
172 {
173         return hw->tx ? hw->tx[count] : 0;
174 }
175 
176 static int nuc900_spi_txrx(struct spi_device *spi, struct spi_transfer *t)
177 {
178         struct nuc900_spi *hw = to_hw(spi);
179 
180         hw->tx = t->tx_buf;
181         hw->rx = t->rx_buf;
182         hw->len = t->len;
183         hw->count = 0;
184 
185         __raw_writel(hw_txbyte(hw, 0x0), hw->regs + USI_TX0);
186 
187         nuc900_spi_gobusy(hw);
188 
189         wait_for_completion(&hw->done);
190 
191         return hw->count;
192 }
193 
194 static irqreturn_t nuc900_spi_irq(int irq, void *dev)
195 {
196         struct nuc900_spi *hw = dev;
197         unsigned int status;
198         unsigned int count = hw->count;
199 
200         status = __raw_readl(hw->regs + USI_CNT);
201         __raw_writel(status, hw->regs + USI_CNT);
202 
203         if (status & ENFLG) {
204                 hw->count++;
205 
206                 if (hw->rx)
207                         hw->rx[count] = __raw_readl(hw->regs + USI_RX0);
208                 count++;
209 
210                 if (count < hw->len) {
211                         __raw_writel(hw_txbyte(hw, count), hw->regs + USI_TX0);
212                         nuc900_spi_gobusy(hw);
213                 } else {
214                         complete(&hw->done);
215                 }
216 
217                 return IRQ_HANDLED;
218         }
219 
220         complete(&hw->done);
221         return IRQ_HANDLED;
222 }
223 
224 static void nuc900_tx_edge(struct nuc900_spi *hw, unsigned int edge)
225 {
226         unsigned int val;
227         unsigned long flags;
228 
229         spin_lock_irqsave(&hw->lock, flags);
230 
231         val = __raw_readl(hw->regs + USI_CNT);
232 
233         if (edge)
234                 val |= TXNEG;
235         else
236                 val &= ~TXNEG;
237         __raw_writel(val, hw->regs + USI_CNT);
238 
239         spin_unlock_irqrestore(&hw->lock, flags);
240 }
241 
242 static void nuc900_rx_edge(struct nuc900_spi *hw, unsigned int edge)
243 {
244         unsigned int val;
245         unsigned long flags;
246 
247         spin_lock_irqsave(&hw->lock, flags);
248 
249         val = __raw_readl(hw->regs + USI_CNT);
250 
251         if (edge)
252                 val |= RXNEG;
253         else
254                 val &= ~RXNEG;
255         __raw_writel(val, hw->regs + USI_CNT);
256 
257         spin_unlock_irqrestore(&hw->lock, flags);
258 }
259 
260 static void nuc900_send_first(struct nuc900_spi *hw, unsigned int lsb)
261 {
262         unsigned int val;
263         unsigned long flags;
264 
265         spin_lock_irqsave(&hw->lock, flags);
266 
267         val = __raw_readl(hw->regs + USI_CNT);
268 
269         if (lsb)
270                 val |= LSB;
271         else
272                 val &= ~LSB;
273         __raw_writel(val, hw->regs + USI_CNT);
274 
275         spin_unlock_irqrestore(&hw->lock, flags);
276 }
277 
278 static void nuc900_set_sleep(struct nuc900_spi *hw, unsigned int sleep)
279 {
280         unsigned int val;
281         unsigned long flags;
282 
283         spin_lock_irqsave(&hw->lock, flags);
284 
285         val = __raw_readl(hw->regs + USI_CNT) & ~SLEEP;
286 
287         if (sleep)
288                 val |= (sleep << 12);
289 
290         __raw_writel(val, hw->regs + USI_CNT);
291 
292         spin_unlock_irqrestore(&hw->lock, flags);
293 }
294 
295 static void nuc900_enable_int(struct nuc900_spi *hw)
296 {
297         unsigned int val;
298         unsigned long flags;
299 
300         spin_lock_irqsave(&hw->lock, flags);
301 
302         val = __raw_readl(hw->regs + USI_CNT);
303 
304         val |= ENINT;
305 
306         __raw_writel(val, hw->regs + USI_CNT);
307 
308         spin_unlock_irqrestore(&hw->lock, flags);
309 }
310 
311 static void nuc900_set_divider(struct nuc900_spi *hw)
312 {
313         __raw_writel(hw->pdata->divider, hw->regs + USI_DIV);
314 }
315 
316 static void nuc900_init_spi(struct nuc900_spi *hw)
317 {
318         clk_enable(hw->clk);
319         spin_lock_init(&hw->lock);
320 
321         nuc900_tx_edge(hw, hw->pdata->txneg);
322         nuc900_rx_edge(hw, hw->pdata->rxneg);
323         nuc900_send_first(hw, hw->pdata->lsb);
324         nuc900_set_sleep(hw, hw->pdata->sleep);
325         nuc900_spi_setup_txbitlen(hw, hw->pdata->txbitlen);
326         nuc900_spi_setup_txnum(hw, hw->pdata->txnum);
327         nuc900_set_divider(hw);
328         nuc900_enable_int(hw);
329 }
330 
331 static int nuc900_spi_probe(struct platform_device *pdev)
332 {
333         struct nuc900_spi *hw;
334         struct spi_master *master;
335         struct resource *res;
336         int err = 0;
337 
338         master = spi_alloc_master(&pdev->dev, sizeof(struct nuc900_spi));
339         if (master == NULL) {
340                 dev_err(&pdev->dev, "No memory for spi_master\n");
341                 return -ENOMEM;
342         }
343 
344         hw = spi_master_get_devdata(master);
345         hw->master = master;
346         hw->pdata  = dev_get_platdata(&pdev->dev);
347 
348         if (hw->pdata == NULL) {
349                 dev_err(&pdev->dev, "No platform data supplied\n");
350                 err = -ENOENT;
351                 goto err_pdata;
352         }
353 
354         platform_set_drvdata(pdev, hw);
355         init_completion(&hw->done);
356 
357         master->mode_bits          = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH;
358         if (hw->pdata->lsb)
359                 master->mode_bits |= SPI_LSB_FIRST;
360         master->num_chipselect     = hw->pdata->num_cs;
361         master->bus_num            = hw->pdata->bus_num;
362         hw->bitbang.master         = hw->master;
363         hw->bitbang.chipselect     = nuc900_spi_chipsel;
364         hw->bitbang.txrx_bufs      = nuc900_spi_txrx;
365 
366         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
367         hw->regs = devm_ioremap_resource(&pdev->dev, res);
368         if (IS_ERR(hw->regs)) {
369                 err = PTR_ERR(hw->regs);
370                 goto err_pdata;
371         }
372 
373         hw->irq = platform_get_irq(pdev, 0);
374         if (hw->irq < 0) {
375                 dev_err(&pdev->dev, "No IRQ specified\n");
376                 err = -ENOENT;
377                 goto err_pdata;
378         }
379 
380         err = devm_request_irq(&pdev->dev, hw->irq, nuc900_spi_irq, 0,
381                                 pdev->name, hw);
382         if (err) {
383                 dev_err(&pdev->dev, "Cannot claim IRQ\n");
384                 goto err_pdata;
385         }
386 
387         hw->clk = devm_clk_get(&pdev->dev, "spi");
388         if (IS_ERR(hw->clk)) {
389                 dev_err(&pdev->dev, "No clock for device\n");
390                 err = PTR_ERR(hw->clk);
391                 goto err_pdata;
392         }
393 
394         mfp_set_groupg(&pdev->dev, NULL);
395         nuc900_init_spi(hw);
396 
397         err = spi_bitbang_start(&hw->bitbang);
398         if (err) {
399                 dev_err(&pdev->dev, "Failed to register SPI master\n");
400                 goto err_register;
401         }
402 
403         return 0;
404 
405 err_register:
406         clk_disable(hw->clk);
407 err_pdata:
408         spi_master_put(hw->master);
409         return err;
410 }
411 
412 static int nuc900_spi_remove(struct platform_device *dev)
413 {
414         struct nuc900_spi *hw = platform_get_drvdata(dev);
415 
416         spi_bitbang_stop(&hw->bitbang);
417         clk_disable(hw->clk);
418         spi_master_put(hw->master);
419         return 0;
420 }
421 
422 static struct platform_driver nuc900_spi_driver = {
423         .probe          = nuc900_spi_probe,
424         .remove         = nuc900_spi_remove,
425         .driver         = {
426                 .name   = "nuc900-spi",
427                 .owner  = THIS_MODULE,
428         },
429 };
430 module_platform_driver(nuc900_spi_driver);
431 
432 MODULE_AUTHOR("Wan ZongShun <mcuos.com@gmail.com>");
433 MODULE_DESCRIPTION("nuc900 spi driver!");
434 MODULE_LICENSE("GPL");
435 MODULE_ALIAS("platform:nuc900-spi");
436 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us