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