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