Merge branch 'linux-next' of git://git.infradead.org/ubifs-2.6
[linux-2.6] / arch / arm / mach-ixp4xx / ixp4xx_qmgr.c
1 /*
2  * Intel IXP4xx Queue Manager driver for Linux
3  *
4  * Copyright (C) 2007 Krzysztof Halasa <khc@pm.waw.pl>
5  *
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms of version 2 of the GNU General Public License
8  * as published by the Free Software Foundation.
9  */
10
11 #include <linux/ioport.h>
12 #include <linux/interrupt.h>
13 #include <linux/kernel.h>
14 #include <linux/module.h>
15 #include <mach/qmgr.h>
16
17 struct qmgr_regs __iomem *qmgr_regs;
18 static struct resource *mem_res;
19 static spinlock_t qmgr_lock;
20 static u32 used_sram_bitmap[4]; /* 128 16-dword pages */
21 static void (*irq_handlers[HALF_QUEUES])(void *pdev);
22 static void *irq_pdevs[HALF_QUEUES];
23
24 #if DEBUG_QMGR
25 char qmgr_queue_descs[QUEUES][32];
26 #endif
27
28 void qmgr_set_irq(unsigned int queue, int src,
29                   void (*handler)(void *pdev), void *pdev)
30 {
31         u32 __iomem *reg = &qmgr_regs->irqsrc[queue / 8]; /* 8 queues / u32 */
32         int bit = (queue % 8) * 4; /* 3 bits + 1 reserved bit per queue */
33         unsigned long flags;
34
35         src &= 7;
36         spin_lock_irqsave(&qmgr_lock, flags);
37         __raw_writel((__raw_readl(reg) & ~(7 << bit)) | (src << bit), reg);
38         irq_handlers[queue] = handler;
39         irq_pdevs[queue] = pdev;
40         spin_unlock_irqrestore(&qmgr_lock, flags);
41 }
42
43
44 static irqreturn_t qmgr_irq1(int irq, void *pdev)
45 {
46         int i;
47         u32 val = __raw_readl(&qmgr_regs->irqstat[0]);
48         __raw_writel(val, &qmgr_regs->irqstat[0]); /* ACK */
49
50         for (i = 0; i < HALF_QUEUES; i++)
51                 if (val & (1 << i))
52                         irq_handlers[i](irq_pdevs[i]);
53
54         return val ? IRQ_HANDLED : 0;
55 }
56
57
58 void qmgr_enable_irq(unsigned int queue)
59 {
60         unsigned long flags;
61
62         spin_lock_irqsave(&qmgr_lock, flags);
63         __raw_writel(__raw_readl(&qmgr_regs->irqen[0]) | (1 << queue),
64                      &qmgr_regs->irqen[0]);
65         spin_unlock_irqrestore(&qmgr_lock, flags);
66 }
67
68 void qmgr_disable_irq(unsigned int queue)
69 {
70         unsigned long flags;
71
72         spin_lock_irqsave(&qmgr_lock, flags);
73         __raw_writel(__raw_readl(&qmgr_regs->irqen[0]) & ~(1 << queue),
74                      &qmgr_regs->irqen[0]);
75         __raw_writel(1 << queue, &qmgr_regs->irqstat[0]); /* clear */
76         spin_unlock_irqrestore(&qmgr_lock, flags);
77 }
78
79 static inline void shift_mask(u32 *mask)
80 {
81         mask[3] = mask[3] << 1 | mask[2] >> 31;
82         mask[2] = mask[2] << 1 | mask[1] >> 31;
83         mask[1] = mask[1] << 1 | mask[0] >> 31;
84         mask[0] <<= 1;
85 }
86
87 #if DEBUG_QMGR
88 int qmgr_request_queue(unsigned int queue, unsigned int len /* dwords */,
89                        unsigned int nearly_empty_watermark,
90                        unsigned int nearly_full_watermark,
91                        const char *desc_format, const char* name)
92 #else
93 int __qmgr_request_queue(unsigned int queue, unsigned int len /* dwords */,
94                          unsigned int nearly_empty_watermark,
95                          unsigned int nearly_full_watermark)
96 #endif
97 {
98         u32 cfg, addr = 0, mask[4]; /* in 16-dwords */
99         int err;
100
101         if (queue >= HALF_QUEUES)
102                 return -ERANGE;
103
104         if ((nearly_empty_watermark | nearly_full_watermark) & ~7)
105                 return -EINVAL;
106
107         switch (len) {
108         case  16:
109                 cfg = 0 << 24;
110                 mask[0] = 0x1;
111                 break;
112         case  32:
113                 cfg = 1 << 24;
114                 mask[0] = 0x3;
115                 break;
116         case  64:
117                 cfg = 2 << 24;
118                 mask[0] = 0xF;
119                 break;
120         case 128:
121                 cfg = 3 << 24;
122                 mask[0] = 0xFF;
123                 break;
124         default:
125                 return -EINVAL;
126         }
127
128         cfg |= nearly_empty_watermark << 26;
129         cfg |= nearly_full_watermark << 29;
130         len /= 16;              /* in 16-dwords: 1, 2, 4 or 8 */
131         mask[1] = mask[2] = mask[3] = 0;
132
133         if (!try_module_get(THIS_MODULE))
134                 return -ENODEV;
135
136         spin_lock_irq(&qmgr_lock);
137         if (__raw_readl(&qmgr_regs->sram[queue])) {
138                 err = -EBUSY;
139                 goto err;
140         }
141
142         while (1) {
143                 if (!(used_sram_bitmap[0] & mask[0]) &&
144                     !(used_sram_bitmap[1] & mask[1]) &&
145                     !(used_sram_bitmap[2] & mask[2]) &&
146                     !(used_sram_bitmap[3] & mask[3]))
147                         break; /* found free space */
148
149                 addr++;
150                 shift_mask(mask);
151                 if (addr + len > ARRAY_SIZE(qmgr_regs->sram)) {
152                         printk(KERN_ERR "qmgr: no free SRAM space for"
153                                " queue %i\n", queue);
154                         err = -ENOMEM;
155                         goto err;
156                 }
157         }
158
159         used_sram_bitmap[0] |= mask[0];
160         used_sram_bitmap[1] |= mask[1];
161         used_sram_bitmap[2] |= mask[2];
162         used_sram_bitmap[3] |= mask[3];
163         __raw_writel(cfg | (addr << 14), &qmgr_regs->sram[queue]);
164 #if DEBUG_QMGR
165         snprintf(qmgr_queue_descs[queue], sizeof(qmgr_queue_descs[0]),
166                  desc_format, name);
167         printk(KERN_DEBUG "qmgr: requested queue %s(%i) addr = 0x%02X\n",
168                qmgr_queue_descs[queue], queue, addr);
169 #endif
170         spin_unlock_irq(&qmgr_lock);
171         return 0;
172
173 err:
174         spin_unlock_irq(&qmgr_lock);
175         module_put(THIS_MODULE);
176         return err;
177 }
178
179 void qmgr_release_queue(unsigned int queue)
180 {
181         u32 cfg, addr, mask[4];
182
183         BUG_ON(queue >= HALF_QUEUES); /* not in valid range */
184
185         spin_lock_irq(&qmgr_lock);
186         cfg = __raw_readl(&qmgr_regs->sram[queue]);
187         addr = (cfg >> 14) & 0xFF;
188
189         BUG_ON(!addr);          /* not requested */
190
191         switch ((cfg >> 24) & 3) {
192         case 0: mask[0] = 0x1; break;
193         case 1: mask[0] = 0x3; break;
194         case 2: mask[0] = 0xF; break;
195         case 3: mask[0] = 0xFF; break;
196         }
197
198         mask[1] = mask[2] = mask[3] = 0;
199
200         while (addr--)
201                 shift_mask(mask);
202
203 #if DEBUG_QMGR
204         printk(KERN_DEBUG "qmgr: releasing queue %s(%i)\n",
205                qmgr_queue_descs[queue], queue);
206         qmgr_queue_descs[queue][0] = '\x0';
207 #endif
208         __raw_writel(0, &qmgr_regs->sram[queue]);
209
210         used_sram_bitmap[0] &= ~mask[0];
211         used_sram_bitmap[1] &= ~mask[1];
212         used_sram_bitmap[2] &= ~mask[2];
213         used_sram_bitmap[3] &= ~mask[3];
214         irq_handlers[queue] = NULL; /* catch IRQ bugs */
215         spin_unlock_irq(&qmgr_lock);
216
217         module_put(THIS_MODULE);
218
219         while ((addr = qmgr_get_entry(queue)))
220                 printk(KERN_ERR "qmgr: released queue %i not empty: 0x%08X\n",
221                        queue, addr);
222 }
223
224 static int qmgr_init(void)
225 {
226         int i, err;
227         mem_res = request_mem_region(IXP4XX_QMGR_BASE_PHYS,
228                                      IXP4XX_QMGR_REGION_SIZE,
229                                      "IXP4xx Queue Manager");
230         if (mem_res == NULL)
231                 return -EBUSY;
232
233         qmgr_regs = ioremap(IXP4XX_QMGR_BASE_PHYS, IXP4XX_QMGR_REGION_SIZE);
234         if (qmgr_regs == NULL) {
235                 err = -ENOMEM;
236                 goto error_map;
237         }
238
239         /* reset qmgr registers */
240         for (i = 0; i < 4; i++) {
241                 __raw_writel(0x33333333, &qmgr_regs->stat1[i]);
242                 __raw_writel(0, &qmgr_regs->irqsrc[i]);
243         }
244         for (i = 0; i < 2; i++) {
245                 __raw_writel(0, &qmgr_regs->stat2[i]);
246                 __raw_writel(0xFFFFFFFF, &qmgr_regs->irqstat[i]); /* clear */
247                 __raw_writel(0, &qmgr_regs->irqen[i]);
248         }
249
250         for (i = 0; i < QUEUES; i++)
251                 __raw_writel(0, &qmgr_regs->sram[i]);
252
253         err = request_irq(IRQ_IXP4XX_QM1, qmgr_irq1, 0,
254                           "IXP4xx Queue Manager", NULL);
255         if (err) {
256                 printk(KERN_ERR "qmgr: failed to request IRQ%i\n",
257                        IRQ_IXP4XX_QM1);
258                 goto error_irq;
259         }
260
261         used_sram_bitmap[0] = 0xF; /* 4 first pages reserved for config */
262         spin_lock_init(&qmgr_lock);
263
264         printk(KERN_INFO "IXP4xx Queue Manager initialized.\n");
265         return 0;
266
267 error_irq:
268         iounmap(qmgr_regs);
269 error_map:
270         release_mem_region(IXP4XX_QMGR_BASE_PHYS, IXP4XX_QMGR_REGION_SIZE);
271         return err;
272 }
273
274 static void qmgr_remove(void)
275 {
276         free_irq(IRQ_IXP4XX_QM1, NULL);
277         synchronize_irq(IRQ_IXP4XX_QM1);
278         iounmap(qmgr_regs);
279         release_mem_region(IXP4XX_QMGR_BASE_PHYS, IXP4XX_QMGR_REGION_SIZE);
280 }
281
282 module_init(qmgr_init);
283 module_exit(qmgr_remove);
284
285 MODULE_LICENSE("GPL v2");
286 MODULE_AUTHOR("Krzysztof Halasa");
287
288 EXPORT_SYMBOL(qmgr_regs);
289 EXPORT_SYMBOL(qmgr_set_irq);
290 EXPORT_SYMBOL(qmgr_enable_irq);
291 EXPORT_SYMBOL(qmgr_disable_irq);
292 #if DEBUG_QMGR
293 EXPORT_SYMBOL(qmgr_queue_descs);
294 EXPORT_SYMBOL(qmgr_request_queue);
295 #else
296 EXPORT_SYMBOL(__qmgr_request_queue);
297 #endif
298 EXPORT_SYMBOL(qmgr_release_queue);