Merge commit '85082fd7cbe3173198aac0eb5e85ab1edcc6352c' into test-build
[linux-2.6] / arch / powerpc / sysdev / bestcomm / sram.c
1 /*
2  * Simple memory allocator for on-board SRAM
3  *
4  *
5  * Maintainer : Sylvain Munaut <tnt@246tNt.com>
6  *
7  * Copyright (C) 2005 Sylvain Munaut <tnt@246tNt.com>
8  *
9  * This file is licensed under the terms of the GNU General Public License
10  * version 2. This program is licensed "as is" without any warranty of any
11  * kind, whether express or implied.
12  */
13
14 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/slab.h>
17 #include <linux/spinlock.h>
18 #include <linux/string.h>
19 #include <linux/ioport.h>
20 #include <linux/of.h>
21
22 #include <asm/io.h>
23 #include <asm/mmu.h>
24
25 #include "sram.h"
26
27
28 /* Struct keeping our 'state' */
29 struct bcom_sram *bcom_sram = NULL;
30 EXPORT_SYMBOL_GPL(bcom_sram);   /* needed for inline functions */
31
32
33 /* ======================================================================== */
34 /* Public API                                                               */
35 /* ======================================================================== */
36 /* DO NOT USE in interrupts, if needed in irq handler, we should use the
37    _irqsave version of the spin_locks */
38
39 int bcom_sram_init(struct device_node *sram_node, char *owner)
40 {
41         int rv;
42         const u32 *regaddr_p;
43         u64 regaddr64, size64;
44         unsigned int psize;
45
46         /* Create our state struct */
47         if (bcom_sram) {
48                 printk(KERN_ERR "%s: bcom_sram_init: "
49                         "Already initialized !\n", owner);
50                 return -EBUSY;
51         }
52
53         bcom_sram = kmalloc(sizeof(struct bcom_sram), GFP_KERNEL);
54         if (!bcom_sram) {
55                 printk(KERN_ERR "%s: bcom_sram_init: "
56                         "Couldn't allocate internal state !\n", owner);
57                 return -ENOMEM;
58         }
59
60         /* Get address and size of the sram */
61         regaddr_p = of_get_address(sram_node, 0, &size64, NULL);
62         if (!regaddr_p) {
63                 printk(KERN_ERR "%s: bcom_sram_init: "
64                         "Invalid device node !\n", owner);
65                 rv = -EINVAL;
66                 goto error_free;
67         }
68
69         regaddr64 = of_translate_address(sram_node, regaddr_p);
70
71         bcom_sram->base_phys = (phys_addr_t) regaddr64;
72         bcom_sram->size = (unsigned int) size64;
73
74         /* Request region */
75         if (!request_mem_region(bcom_sram->base_phys, bcom_sram->size, owner)) {
76                 printk(KERN_ERR "%s: bcom_sram_init: "
77                         "Couldn't request region !\n", owner);
78                 rv = -EBUSY;
79                 goto error_free;
80         }
81
82         /* Map SRAM */
83                 /* sram is not really __iomem */
84         bcom_sram->base_virt = (void*) ioremap(bcom_sram->base_phys, bcom_sram->size);
85
86         if (!bcom_sram->base_virt) {
87                 printk(KERN_ERR "%s: bcom_sram_init: "
88                         "Map error SRAM zone 0x%08lx (0x%0x)!\n",
89                         owner, (long)bcom_sram->base_phys, bcom_sram->size );
90                 rv = -ENOMEM;
91                 goto error_release;
92         }
93
94         /* Create an rheap (defaults to 32 bits word alignment) */
95         bcom_sram->rh = rh_create(4);
96
97         /* Attach the free zones */
98 #if 0
99         /* Currently disabled ... for future use only */
100         reg_addr_p = of_get_property(sram_node, "available", &psize);
101 #else
102         regaddr_p = NULL;
103         psize = 0;
104 #endif
105
106         if (!regaddr_p || !psize) {
107                 /* Attach the whole zone */
108                 rh_attach_region(bcom_sram->rh, 0, bcom_sram->size);
109         } else {
110                 /* Attach each zone independently */
111                 while (psize >= 2 * sizeof(u32)) {
112                         phys_addr_t zbase = of_translate_address(sram_node, regaddr_p);
113                         rh_attach_region(bcom_sram->rh, zbase - bcom_sram->base_phys, regaddr_p[1]);
114                         regaddr_p += 2;
115                         psize -= 2 * sizeof(u32);
116                 }
117         }
118
119         /* Init our spinlock */
120         spin_lock_init(&bcom_sram->lock);
121
122         return 0;
123
124 error_release:
125         release_mem_region(bcom_sram->base_phys, bcom_sram->size);
126 error_free:
127         kfree(bcom_sram);
128         bcom_sram = NULL;
129
130         return rv;
131 }
132 EXPORT_SYMBOL_GPL(bcom_sram_init);
133
134 void bcom_sram_cleanup(void)
135 {
136         /* Free resources */
137         if (bcom_sram) {
138                 rh_destroy(bcom_sram->rh);
139                 iounmap((void __iomem *)bcom_sram->base_virt);
140                 release_mem_region(bcom_sram->base_phys, bcom_sram->size);
141                 kfree(bcom_sram);
142                 bcom_sram = NULL;
143         }
144 }
145 EXPORT_SYMBOL_GPL(bcom_sram_cleanup);
146
147 void* bcom_sram_alloc(int size, int align, phys_addr_t *phys)
148 {
149         unsigned long offset;
150
151         spin_lock(&bcom_sram->lock);
152         offset = rh_alloc_align(bcom_sram->rh, size, align, NULL);
153         spin_unlock(&bcom_sram->lock);
154
155         if (IS_ERR_VALUE(offset))
156                 return NULL;
157
158         *phys = bcom_sram->base_phys + offset;
159         return bcom_sram->base_virt + offset;
160 }
161 EXPORT_SYMBOL_GPL(bcom_sram_alloc);
162
163 void bcom_sram_free(void *ptr)
164 {
165         unsigned long offset;
166
167         if (!ptr)
168                 return;
169
170         offset = ptr - bcom_sram->base_virt;
171
172         spin_lock(&bcom_sram->lock);
173         rh_free(bcom_sram->rh, offset);
174         spin_unlock(&bcom_sram->lock);
175 }
176 EXPORT_SYMBOL_GPL(bcom_sram_free);
177