Version:  2.0.40 2.2.26 2.4.37 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 3.16

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

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