[ARM] cdb89712,clps7500,h720x: avoid namespace clash for FLASH_* constants
[linux-3.10.git] / drivers / mtd / maps / cdb89712.c
1 /*
2  * Flash on Cirrus CDB89712
3  *
4  */
5
6 #include <linux/module.h>
7 #include <linux/types.h>
8 #include <linux/kernel.h>
9 #include <linux/ioport.h>
10 #include <linux/init.h>
11 #include <asm/io.h>
12 #include <mach/hardware.h>
13 #include <linux/mtd/mtd.h>
14 #include <linux/mtd/map.h>
15 #include <linux/mtd/partitions.h>
16
17
18 #define FLASH_START      0x00000000
19 #define FLASH_SIZE       0x800000
20 #define FLASH_WIDTH      4
21
22 static struct mtd_info *flash_mtd;
23
24 struct map_info cdb89712_flash_map = {
25         .name = "flash",
26         .size = FLASH_SIZE,
27         .bankwidth = FLASH_WIDTH,
28         .phys = FLASH_START,
29 };
30
31 struct resource cdb89712_flash_resource = {
32         .name =   "Flash",
33         .start =  FLASH_START,
34         .end =    FLASH_START + FLASH_SIZE - 1,
35         .flags =  IORESOURCE_IO | IORESOURCE_BUSY,
36 };
37
38 static int __init init_cdb89712_flash (void)
39 {
40         int err;
41
42         if (request_resource (&ioport_resource, &cdb89712_flash_resource)) {
43                 printk(KERN_NOTICE "Failed to reserve Cdb89712 FLASH space\n");
44                 err = -EBUSY;
45                 goto out;
46         }
47
48         cdb89712_flash_map.virt = ioremap(FLASH_START, FLASH_SIZE);
49         if (!cdb89712_flash_map.virt) {
50                 printk(KERN_NOTICE "Failed to ioremap Cdb89712 FLASH space\n");
51                 err = -EIO;
52                 goto out_resource;
53         }
54         simple_map_init(&cdb89712_flash_map);
55         flash_mtd = do_map_probe("cfi_probe", &cdb89712_flash_map);
56         if (!flash_mtd) {
57                 flash_mtd = do_map_probe("map_rom", &cdb89712_flash_map);
58                 if (flash_mtd)
59                         flash_mtd->erasesize = 0x10000;
60         }
61         if (!flash_mtd) {
62                 printk("FLASH probe failed\n");
63                 err = -ENXIO;
64                 goto out_ioremap;
65         }
66
67         flash_mtd->owner = THIS_MODULE;
68
69         if (add_mtd_device(flash_mtd)) {
70                 printk("FLASH device addition failed\n");
71                 err = -ENOMEM;
72                 goto out_probe;
73         }
74
75         return 0;
76
77 out_probe:
78         map_destroy(flash_mtd);
79         flash_mtd = 0;
80 out_ioremap:
81         iounmap((void *)cdb89712_flash_map.virt);
82 out_resource:
83         release_resource (&cdb89712_flash_resource);
84 out:
85         return err;
86 }
87
88
89
90
91
92 static struct mtd_info *sram_mtd;
93
94 struct map_info cdb89712_sram_map = {
95         .name = "SRAM",
96         .size = SRAM_SIZE,
97         .bankwidth = SRAM_WIDTH,
98         .phys = SRAM_START,
99 };
100
101 struct resource cdb89712_sram_resource = {
102         .name =   "SRAM",
103         .start =  SRAM_START,
104         .end =    SRAM_START + SRAM_SIZE - 1,
105         .flags =  IORESOURCE_IO | IORESOURCE_BUSY,
106 };
107
108 static int __init init_cdb89712_sram (void)
109 {
110         int err;
111
112         if (request_resource (&ioport_resource, &cdb89712_sram_resource)) {
113                 printk(KERN_NOTICE "Failed to reserve Cdb89712 SRAM space\n");
114                 err = -EBUSY;
115                 goto out;
116         }
117
118         cdb89712_sram_map.virt = ioremap(SRAM_START, SRAM_SIZE);
119         if (!cdb89712_sram_map.virt) {
120                 printk(KERN_NOTICE "Failed to ioremap Cdb89712 SRAM space\n");
121                 err = -EIO;
122                 goto out_resource;
123         }
124         simple_map_init(&cdb89712_sram_map);
125         sram_mtd = do_map_probe("map_ram", &cdb89712_sram_map);
126         if (!sram_mtd) {
127                 printk("SRAM probe failed\n");
128                 err = -ENXIO;
129                 goto out_ioremap;
130         }
131
132         sram_mtd->owner = THIS_MODULE;
133         sram_mtd->erasesize = 16;
134
135         if (add_mtd_device(sram_mtd)) {
136                 printk("SRAM device addition failed\n");
137                 err = -ENOMEM;
138                 goto out_probe;
139         }
140
141         return 0;
142
143 out_probe:
144         map_destroy(sram_mtd);
145         sram_mtd = 0;
146 out_ioremap:
147         iounmap((void *)cdb89712_sram_map.virt);
148 out_resource:
149         release_resource (&cdb89712_sram_resource);
150 out:
151         return err;
152 }
153
154
155
156
157
158
159
160 static struct mtd_info *bootrom_mtd;
161
162 struct map_info cdb89712_bootrom_map = {
163         .name = "BootROM",
164         .size = BOOTROM_SIZE,
165         .bankwidth = BOOTROM_WIDTH,
166         .phys = BOOTROM_START,
167 };
168
169 struct resource cdb89712_bootrom_resource = {
170         .name =   "BootROM",
171         .start =  BOOTROM_START,
172         .end =    BOOTROM_START + BOOTROM_SIZE - 1,
173         .flags =  IORESOURCE_IO | IORESOURCE_BUSY,
174 };
175
176 static int __init init_cdb89712_bootrom (void)
177 {
178         int err;
179
180         if (request_resource (&ioport_resource, &cdb89712_bootrom_resource)) {
181                 printk(KERN_NOTICE "Failed to reserve Cdb89712 BOOTROM space\n");
182                 err = -EBUSY;
183                 goto out;
184         }
185
186         cdb89712_bootrom_map.virt = ioremap(BOOTROM_START, BOOTROM_SIZE);
187         if (!cdb89712_bootrom_map.virt) {
188                 printk(KERN_NOTICE "Failed to ioremap Cdb89712 BootROM space\n");
189                 err = -EIO;
190                 goto out_resource;
191         }
192         simple_map_init(&cdb89712_bootrom_map);
193         bootrom_mtd = do_map_probe("map_rom", &cdb89712_bootrom_map);
194         if (!bootrom_mtd) {
195                 printk("BootROM probe failed\n");
196                 err = -ENXIO;
197                 goto out_ioremap;
198         }
199
200         bootrom_mtd->owner = THIS_MODULE;
201         bootrom_mtd->erasesize = 0x10000;
202
203         if (add_mtd_device(bootrom_mtd)) {
204                 printk("BootROM device addition failed\n");
205                 err = -ENOMEM;
206                 goto out_probe;
207         }
208
209         return 0;
210
211 out_probe:
212         map_destroy(bootrom_mtd);
213         bootrom_mtd = 0;
214 out_ioremap:
215         iounmap((void *)cdb89712_bootrom_map.virt);
216 out_resource:
217         release_resource (&cdb89712_bootrom_resource);
218 out:
219         return err;
220 }
221
222
223
224
225
226 static int __init init_cdb89712_maps(void)
227 {
228
229         printk(KERN_INFO "Cirrus CDB89712 MTD mappings:\n  Flash 0x%x at 0x%x\n  SRAM 0x%x at 0x%x\n  BootROM 0x%x at 0x%x\n",
230                FLASH_SIZE, FLASH_START, SRAM_SIZE, SRAM_START, BOOTROM_SIZE, BOOTROM_START);
231
232         init_cdb89712_flash();
233         init_cdb89712_sram();
234         init_cdb89712_bootrom();
235
236         return 0;
237 }
238
239
240 static void __exit cleanup_cdb89712_maps(void)
241 {
242         if (sram_mtd) {
243                 del_mtd_device(sram_mtd);
244                 map_destroy(sram_mtd);
245                 iounmap((void *)cdb89712_sram_map.virt);
246                 release_resource (&cdb89712_sram_resource);
247         }
248
249         if (flash_mtd) {
250                 del_mtd_device(flash_mtd);
251                 map_destroy(flash_mtd);
252                 iounmap((void *)cdb89712_flash_map.virt);
253                 release_resource (&cdb89712_flash_resource);
254         }
255
256         if (bootrom_mtd) {
257                 del_mtd_device(bootrom_mtd);
258                 map_destroy(bootrom_mtd);
259                 iounmap((void *)cdb89712_bootrom_map.virt);
260                 release_resource (&cdb89712_bootrom_resource);
261         }
262 }
263
264 module_init(init_cdb89712_maps);
265 module_exit(cleanup_cdb89712_maps);
266
267 MODULE_AUTHOR("Ray L");
268 MODULE_DESCRIPTION("ARM CDB89712 map driver");
269 MODULE_LICENSE("GPL");