Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * Ceiva flash memory driver. | |
3 | * Copyright (C) 2002 Rob Scott <rscott@mtrob.fdns.net> | |
4 | * | |
5 | * Note: this driver supports jedec compatible devices. Modification | |
6 | * for CFI compatible devices should be straight forward: change | |
7 | * jedec_probe to cfi_probe. | |
8 | * | |
9 | * Based on: sa1100-flash.c, which has the following copyright: | |
10 | * Flash memory access on SA11x0 based devices | |
11 | * | |
12 | * (C) 2000 Nicolas Pitre <nico@cam.org> | |
13 | * | |
1da177e4 LT |
14 | */ |
15 | ||
1da177e4 LT |
16 | #include <linux/module.h> |
17 | #include <linux/types.h> | |
18 | #include <linux/ioport.h> | |
19 | #include <linux/kernel.h> | |
20 | #include <linux/init.h> | |
4e57b681 | 21 | #include <linux/slab.h> |
1da177e4 LT |
22 | |
23 | #include <linux/mtd/mtd.h> | |
24 | #include <linux/mtd/map.h> | |
25 | #include <linux/mtd/partitions.h> | |
26 | #include <linux/mtd/concat.h> | |
27 | ||
a09e64fb | 28 | #include <mach/hardware.h> |
1da177e4 LT |
29 | #include <asm/mach-types.h> |
30 | #include <asm/io.h> | |
31 | #include <asm/sizes.h> | |
32 | ||
33 | /* | |
34 | * This isn't complete yet, so... | |
35 | */ | |
36 | #define CONFIG_MTD_CEIVA_STATICMAP | |
37 | ||
38 | #ifdef CONFIG_MTD_CEIVA_STATICMAP | |
39 | /* | |
40 | * See include/linux/mtd/partitions.h for definition of the mtd_partition | |
41 | * structure. | |
42 | * | |
43 | * Please note: | |
44 | * 1. The flash size given should be the largest flash size that can | |
45 | * be accomodated. | |
46 | * | |
47 | * 2. The bus width must defined in clps_setup_flash. | |
48 | * | |
49 | * The MTD layer will detect flash chip aliasing and reduce the size of | |
50 | * the map accordingly. | |
51 | * | |
52 | */ | |
53 | ||
54 | #ifdef CONFIG_ARCH_CEIVA | |
55 | /* Flash / Partition sizing */ | |
56 | /* For the 28F8003, we use the block mapping to calcuate the sizes */ | |
57 | #define MAX_SIZE_KiB (16 + 8 + 8 + 96 + (7*128)) | |
58 | #define BOOT_PARTITION_SIZE_KiB (16) | |
59 | #define PARAMS_PARTITION_SIZE_KiB (8) | |
60 | #define KERNEL_PARTITION_SIZE_KiB (4*128) | |
61 | /* Use both remaing portion of first flash, and all of second flash */ | |
62 | #define ROOT_PARTITION_SIZE_KiB (3*128) + (8*128) | |
63 | ||
64 | static struct mtd_partition ceiva_partitions[] = { | |
65 | { | |
66 | .name = "Ceiva BOOT partition", | |
67 | .size = BOOT_PARTITION_SIZE_KiB*1024, | |
68 | .offset = 0, | |
69 | ||
70 | },{ | |
71 | .name = "Ceiva parameters partition", | |
72 | .size = PARAMS_PARTITION_SIZE_KiB*1024, | |
73 | .offset = (16 + 8) * 1024, | |
74 | },{ | |
75 | .name = "Ceiva kernel partition", | |
76 | .size = (KERNEL_PARTITION_SIZE_KiB)*1024, | |
77 | .offset = 0x20000, | |
78 | ||
79 | },{ | |
80 | .name = "Ceiva root filesystem partition", | |
81 | .offset = MTDPART_OFS_APPEND, | |
82 | .size = (ROOT_PARTITION_SIZE_KiB)*1024, | |
83 | } | |
84 | }; | |
85 | #endif | |
86 | ||
87 | static int __init clps_static_partitions(struct mtd_partition **parts) | |
88 | { | |
89 | int nb_parts = 0; | |
90 | ||
91 | #ifdef CONFIG_ARCH_CEIVA | |
92 | if (machine_is_ceiva()) { | |
93 | *parts = ceiva_partitions; | |
94 | nb_parts = ARRAY_SIZE(ceiva_partitions); | |
95 | } | |
96 | #endif | |
97 | return nb_parts; | |
98 | } | |
99 | #endif | |
100 | ||
101 | struct clps_info { | |
102 | unsigned long base; | |
103 | unsigned long size; | |
104 | int width; | |
105 | void *vbase; | |
106 | struct map_info *map; | |
107 | struct mtd_info *mtd; | |
108 | struct resource *res; | |
109 | }; | |
110 | ||
111 | #define NR_SUBMTD 4 | |
112 | ||
113 | static struct clps_info info[NR_SUBMTD]; | |
114 | ||
115 | static int __init clps_setup_mtd(struct clps_info *clps, int nr, struct mtd_info **rmtd) | |
116 | { | |
117 | struct mtd_info *subdev[nr]; | |
118 | struct map_info *maps; | |
119 | int i, found = 0, ret = 0; | |
120 | ||
121 | /* | |
122 | * Allocate the map_info structs in one go. | |
123 | */ | |
95b93a0c | 124 | maps = kzalloc(sizeof(struct map_info) * nr, GFP_KERNEL); |
1da177e4 LT |
125 | if (!maps) |
126 | return -ENOMEM; | |
1da177e4 LT |
127 | /* |
128 | * Claim and then map the memory regions. | |
129 | */ | |
130 | for (i = 0; i < nr; i++) { | |
131 | if (clps[i].base == (unsigned long)-1) | |
132 | break; | |
133 | ||
134 | clps[i].res = request_mem_region(clps[i].base, clps[i].size, "clps flash"); | |
135 | if (!clps[i].res) { | |
136 | ret = -EBUSY; | |
137 | break; | |
138 | } | |
139 | ||
140 | clps[i].map = maps + i; | |
141 | ||
142 | clps[i].map->name = "clps flash"; | |
143 | clps[i].map->phys = clps[i].base; | |
144 | ||
145 | clps[i].vbase = ioremap(clps[i].base, clps[i].size); | |
146 | if (!clps[i].vbase) { | |
147 | ret = -ENOMEM; | |
148 | break; | |
149 | } | |
150 | ||
151 | clps[i].map->virt = (void __iomem *)clps[i].vbase; | |
152 | clps[i].map->bankwidth = clps[i].width; | |
153 | clps[i].map->size = clps[i].size; | |
154 | ||
155 | simple_map_init(&clps[i].map); | |
156 | ||
157 | clps[i].mtd = do_map_probe("jedec_probe", clps[i].map); | |
158 | if (clps[i].mtd == NULL) { | |
159 | ret = -ENXIO; | |
160 | break; | |
161 | } | |
162 | clps[i].mtd->owner = THIS_MODULE; | |
163 | subdev[i] = clps[i].mtd; | |
164 | ||
165 | printk(KERN_INFO "clps flash: JEDEC device at 0x%08lx, %dMiB, " | |
166 | "%d-bit\n", clps[i].base, clps[i].mtd->size >> 20, | |
167 | clps[i].width * 8); | |
168 | found += 1; | |
169 | } | |
170 | ||
171 | /* | |
172 | * ENXIO is special. It means we didn't find a chip when | |
173 | * we probed. We need to tear down the mapping, free the | |
174 | * resource and mark it as such. | |
175 | */ | |
176 | if (ret == -ENXIO) { | |
177 | iounmap(clps[i].vbase); | |
178 | clps[i].vbase = NULL; | |
179 | release_resource(clps[i].res); | |
180 | clps[i].res = NULL; | |
181 | } | |
182 | ||
183 | /* | |
184 | * If we found one device, don't bother with concat support. | |
185 | * If we found multiple devices, use concat if we have it | |
186 | * available, otherwise fail. | |
187 | */ | |
188 | if (ret == 0 || ret == -ENXIO) { | |
189 | if (found == 1) { | |
190 | *rmtd = subdev[0]; | |
191 | ret = 0; | |
192 | } else if (found > 1) { | |
193 | /* | |
194 | * We detected multiple devices. Concatenate | |
195 | * them together. | |
196 | */ | |
197 | #ifdef CONFIG_MTD_CONCAT | |
198 | *rmtd = mtd_concat_create(subdev, found, | |
199 | "clps flash"); | |
200 | if (*rmtd == NULL) | |
201 | ret = -ENXIO; | |
202 | #else | |
203 | printk(KERN_ERR "clps flash: multiple devices " | |
204 | "found but MTD concat support disabled.\n"); | |
205 | ret = -ENXIO; | |
206 | #endif | |
207 | } | |
208 | } | |
209 | ||
210 | /* | |
211 | * If we failed, clean up. | |
212 | */ | |
213 | if (ret) { | |
214 | do { | |
215 | if (clps[i].mtd) | |
216 | map_destroy(clps[i].mtd); | |
217 | if (clps[i].vbase) | |
218 | iounmap(clps[i].vbase); | |
219 | if (clps[i].res) | |
220 | release_resource(clps[i].res); | |
221 | } while (i--); | |
222 | ||
223 | kfree(maps); | |
224 | } | |
225 | ||
226 | return ret; | |
227 | } | |
228 | ||
229 | static void __exit clps_destroy_mtd(struct clps_info *clps, struct mtd_info *mtd) | |
230 | { | |
231 | int i; | |
232 | ||
233 | del_mtd_partitions(mtd); | |
234 | ||
235 | if (mtd != clps[0].mtd) | |
236 | mtd_concat_destroy(mtd); | |
237 | ||
238 | for (i = NR_SUBMTD; i >= 0; i--) { | |
239 | if (clps[i].mtd) | |
240 | map_destroy(clps[i].mtd); | |
241 | if (clps[i].vbase) | |
242 | iounmap(clps[i].vbase); | |
243 | if (clps[i].res) | |
244 | release_resource(clps[i].res); | |
245 | } | |
246 | kfree(clps[0].map); | |
247 | } | |
248 | ||
249 | /* | |
250 | * We define the memory space, size, and width for the flash memory | |
251 | * space here. | |
252 | */ | |
253 | ||
254 | static int __init clps_setup_flash(void) | |
255 | { | |
256 | int nr; | |
257 | ||
258 | #ifdef CONFIG_ARCH_CEIVA | |
259 | if (machine_is_ceiva()) { | |
260 | info[0].base = CS0_PHYS_BASE; | |
261 | info[0].size = SZ_32M; | |
262 | info[0].width = CEIVA_FLASH_WIDTH; | |
263 | info[1].base = CS1_PHYS_BASE; | |
264 | info[1].size = SZ_32M; | |
265 | info[1].width = CEIVA_FLASH_WIDTH; | |
266 | nr = 2; | |
267 | } | |
268 | #endif | |
269 | return nr; | |
270 | } | |
271 | ||
272 | static struct mtd_partition *parsed_parts; | |
273 | static const char *probes[] = { "cmdlinepart", "RedBoot", NULL }; | |
274 | ||
275 | static void __init clps_locate_partitions(struct mtd_info *mtd) | |
276 | { | |
277 | const char *part_type = NULL; | |
278 | int nr_parts = 0; | |
279 | do { | |
280 | /* | |
281 | * Partition selection stuff. | |
282 | */ | |
283 | nr_parts = parse_mtd_partitions(mtd, probes, &parsed_parts, 0); | |
284 | if (nr_parts > 0) { | |
285 | part_type = "command line"; | |
286 | break; | |
287 | } | |
288 | #ifdef CONFIG_MTD_CEIVA_STATICMAP | |
289 | nr_parts = clps_static_partitions(&parsed_parts); | |
290 | if (nr_parts > 0) { | |
291 | part_type = "static"; | |
292 | break; | |
293 | } | |
294 | printk("found: %d partitions\n", nr_parts); | |
295 | #endif | |
296 | } while (0); | |
297 | ||
298 | if (nr_parts == 0) { | |
299 | printk(KERN_NOTICE "clps flash: no partition info " | |
300 | "available, registering whole flash\n"); | |
301 | add_mtd_device(mtd); | |
302 | } else { | |
303 | printk(KERN_NOTICE "clps flash: using %s partition " | |
304 | "definition\n", part_type); | |
305 | add_mtd_partitions(mtd, parsed_parts, nr_parts); | |
306 | } | |
307 | ||
308 | /* Always succeeds. */ | |
309 | } | |
310 | ||
311 | static void __exit clps_destroy_partitions(void) | |
312 | { | |
fa671646 | 313 | kfree(parsed_parts); |
1da177e4 LT |
314 | } |
315 | ||
316 | static struct mtd_info *mymtd; | |
317 | ||
318 | static int __init clps_mtd_init(void) | |
319 | { | |
320 | int ret; | |
321 | int nr; | |
322 | ||
323 | nr = clps_setup_flash(); | |
324 | if (nr < 0) | |
325 | return nr; | |
326 | ||
327 | ret = clps_setup_mtd(info, nr, &mymtd); | |
328 | if (ret) | |
329 | return ret; | |
330 | ||
331 | clps_locate_partitions(mymtd); | |
332 | ||
333 | return 0; | |
334 | } | |
335 | ||
336 | static void __exit clps_mtd_cleanup(void) | |
337 | { | |
338 | clps_destroy_mtd(info, mymtd); | |
339 | clps_destroy_partitions(); | |
340 | } | |
341 | ||
342 | module_init(clps_mtd_init); | |
343 | module_exit(clps_mtd_cleanup); | |
344 | ||
345 | MODULE_AUTHOR("Rob Scott"); | |
346 | MODULE_DESCRIPTION("Cirrus Logic JEDEC map driver"); | |
347 | MODULE_LICENSE("GPL"); |