diff options
author | Dmitry Eremin-Solenikov <dbaryshkov@gmail.com> | 2011-06-02 07:54:08 -0400 |
---|---|---|
committer | Artem Bityutskiy <artem.bityutskiy@intel.com> | 2011-09-11 08:01:57 -0400 |
commit | 06947494bea31e536eba1d5c7d95791a9d2b5a99 (patch) | |
tree | 8d176137488aedb5173d6f0e941749285cbe0a11 /drivers/mtd | |
parent | d3f2ed520b51f06d4f3c8c96bd4ba6e7e57643a3 (diff) |
mtd: drop ceiva map driver
It's a Ceiva/Polaroid PhotoMax Digital Picture Frame. Support for it was
commited before 2.6.12-rc2, current git contains no functional changes
since it's start. Driver containing MTD support for that board was
broken for some time already.
Signed-off-by: Dmitry Eremin-Solenikov <dbaryshkov@gmail.com>
Signed-off-by: Artem Bityutskiy <Artem.Bityutskiy@nokia.com>
Diffstat (limited to 'drivers/mtd')
-rw-r--r-- | drivers/mtd/maps/Kconfig | 8 | ||||
-rw-r--r-- | drivers/mtd/maps/Makefile | 1 | ||||
-rw-r--r-- | drivers/mtd/maps/ceiva.c | 341 |
3 files changed, 0 insertions, 350 deletions
diff --git a/drivers/mtd/maps/Kconfig b/drivers/mtd/maps/Kconfig index c0c328c5b133..11cc2307c2ca 100644 --- a/drivers/mtd/maps/Kconfig +++ b/drivers/mtd/maps/Kconfig | |||
@@ -412,14 +412,6 @@ config MTD_IMPA7 | |||
412 | This enables access to the NOR Flash on the impA7 board of | 412 | This enables access to the NOR Flash on the impA7 board of |
413 | implementa GmbH. If you have such a board, say 'Y' here. | 413 | implementa GmbH. If you have such a board, say 'Y' here. |
414 | 414 | ||
415 | config MTD_CEIVA | ||
416 | tristate "JEDEC Flash device mapped on Ceiva/Polaroid PhotoMax Digital Picture Frame" | ||
417 | depends on MTD_JEDECPROBE && ARCH_CEIVA | ||
418 | help | ||
419 | This enables access to the flash chips on the Ceiva/Polaroid | ||
420 | PhotoMax Digital Picture Frame. | ||
421 | If you have such a device, say 'Y'. | ||
422 | |||
423 | config MTD_H720X | 415 | config MTD_H720X |
424 | tristate "Hynix evaluation board mappings" | 416 | tristate "Hynix evaluation board mappings" |
425 | depends on MTD_CFI && ( ARCH_H7201 || ARCH_H7202 ) | 417 | depends on MTD_CFI && ( ARCH_H7201 || ARCH_H7202 ) |
diff --git a/drivers/mtd/maps/Makefile b/drivers/mtd/maps/Makefile index cb48b11affff..d6379fea42b8 100644 --- a/drivers/mtd/maps/Makefile +++ b/drivers/mtd/maps/Makefile | |||
@@ -19,7 +19,6 @@ obj-$(CONFIG_MTD_CK804XROM) += ck804xrom.o | |||
19 | obj-$(CONFIG_MTD_TSUNAMI) += tsunami_flash.o | 19 | obj-$(CONFIG_MTD_TSUNAMI) += tsunami_flash.o |
20 | obj-$(CONFIG_MTD_PXA2XX) += pxa2xx-flash.o | 20 | obj-$(CONFIG_MTD_PXA2XX) += pxa2xx-flash.o |
21 | obj-$(CONFIG_MTD_MBX860) += mbx860.o | 21 | obj-$(CONFIG_MTD_MBX860) += mbx860.o |
22 | obj-$(CONFIG_MTD_CEIVA) += ceiva.o | ||
23 | obj-$(CONFIG_MTD_OCTAGON) += octagon-5066.o | 22 | obj-$(CONFIG_MTD_OCTAGON) += octagon-5066.o |
24 | obj-$(CONFIG_MTD_PHYSMAP) += physmap.o | 23 | obj-$(CONFIG_MTD_PHYSMAP) += physmap.o |
25 | obj-$(CONFIG_MTD_PHYSMAP_OF) += physmap_of.o | 24 | obj-$(CONFIG_MTD_PHYSMAP_OF) += physmap_of.o |
diff --git a/drivers/mtd/maps/ceiva.c b/drivers/mtd/maps/ceiva.c deleted file mode 100644 index 06f9c9815720..000000000000 --- a/drivers/mtd/maps/ceiva.c +++ /dev/null | |||
@@ -1,341 +0,0 @@ | |||
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@fluxnic.net> | ||
13 | * | ||
14 | */ | ||
15 | |||
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> | ||
21 | #include <linux/slab.h> | ||
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 | |||
28 | #include <mach/hardware.h> | ||
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 accommodated. | ||
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 remaining 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 | */ | ||
124 | maps = kzalloc(sizeof(struct map_info) * nr, GFP_KERNEL); | ||
125 | if (!maps) | ||
126 | return -ENOMEM; | ||
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 | *rmtd = mtd_concat_create(subdev, found, | ||
198 | "clps flash"); | ||
199 | if (*rmtd == NULL) | ||
200 | ret = -ENXIO; | ||
201 | } | ||
202 | } | ||
203 | |||
204 | /* | ||
205 | * If we failed, clean up. | ||
206 | */ | ||
207 | if (ret) { | ||
208 | do { | ||
209 | if (clps[i].mtd) | ||
210 | map_destroy(clps[i].mtd); | ||
211 | if (clps[i].vbase) | ||
212 | iounmap(clps[i].vbase); | ||
213 | if (clps[i].res) | ||
214 | release_resource(clps[i].res); | ||
215 | } while (i--); | ||
216 | |||
217 | kfree(maps); | ||
218 | } | ||
219 | |||
220 | return ret; | ||
221 | } | ||
222 | |||
223 | static void __exit clps_destroy_mtd(struct clps_info *clps, struct mtd_info *mtd) | ||
224 | { | ||
225 | int i; | ||
226 | |||
227 | mtd_device_unregister(mtd); | ||
228 | |||
229 | if (mtd != clps[0].mtd) | ||
230 | mtd_concat_destroy(mtd); | ||
231 | |||
232 | for (i = NR_SUBMTD; i >= 0; i--) { | ||
233 | if (clps[i].mtd) | ||
234 | map_destroy(clps[i].mtd); | ||
235 | if (clps[i].vbase) | ||
236 | iounmap(clps[i].vbase); | ||
237 | if (clps[i].res) | ||
238 | release_resource(clps[i].res); | ||
239 | } | ||
240 | kfree(clps[0].map); | ||
241 | } | ||
242 | |||
243 | /* | ||
244 | * We define the memory space, size, and width for the flash memory | ||
245 | * space here. | ||
246 | */ | ||
247 | |||
248 | static int __init clps_setup_flash(void) | ||
249 | { | ||
250 | int nr = 0; | ||
251 | |||
252 | #ifdef CONFIG_ARCH_CEIVA | ||
253 | if (machine_is_ceiva()) { | ||
254 | info[0].base = CS0_PHYS_BASE; | ||
255 | info[0].size = SZ_32M; | ||
256 | info[0].width = CEIVA_FLASH_WIDTH; | ||
257 | info[1].base = CS1_PHYS_BASE; | ||
258 | info[1].size = SZ_32M; | ||
259 | info[1].width = CEIVA_FLASH_WIDTH; | ||
260 | nr = 2; | ||
261 | } | ||
262 | #endif | ||
263 | return nr; | ||
264 | } | ||
265 | |||
266 | static struct mtd_partition *parsed_parts; | ||
267 | static const char *probes[] = { "cmdlinepart", "RedBoot", NULL }; | ||
268 | |||
269 | static void __init clps_locate_partitions(struct mtd_info *mtd) | ||
270 | { | ||
271 | const char *part_type = NULL; | ||
272 | int nr_parts = 0; | ||
273 | do { | ||
274 | /* | ||
275 | * Partition selection stuff. | ||
276 | */ | ||
277 | nr_parts = parse_mtd_partitions(mtd, probes, &parsed_parts, 0); | ||
278 | if (nr_parts > 0) { | ||
279 | part_type = "command line"; | ||
280 | break; | ||
281 | } | ||
282 | #ifdef CONFIG_MTD_CEIVA_STATICMAP | ||
283 | nr_parts = clps_static_partitions(&parsed_parts); | ||
284 | if (nr_parts > 0) { | ||
285 | part_type = "static"; | ||
286 | break; | ||
287 | } | ||
288 | printk("found: %d partitions\n", nr_parts); | ||
289 | #endif | ||
290 | } while (0); | ||
291 | |||
292 | if (nr_parts == 0) { | ||
293 | printk(KERN_NOTICE "clps flash: no partition info " | ||
294 | "available, registering whole flash\n"); | ||
295 | mtd_device_register(mtd, NULL, 0); | ||
296 | } else { | ||
297 | printk(KERN_NOTICE "clps flash: using %s partition " | ||
298 | "definition\n", part_type); | ||
299 | mtd_device_register(mtd, parsed_parts, nr_parts); | ||
300 | } | ||
301 | |||
302 | /* Always succeeds. */ | ||
303 | } | ||
304 | |||
305 | static void __exit clps_destroy_partitions(void) | ||
306 | { | ||
307 | kfree(parsed_parts); | ||
308 | } | ||
309 | |||
310 | static struct mtd_info *mymtd; | ||
311 | |||
312 | static int __init clps_mtd_init(void) | ||
313 | { | ||
314 | int ret; | ||
315 | int nr; | ||
316 | |||
317 | nr = clps_setup_flash(); | ||
318 | if (nr < 0) | ||
319 | return nr; | ||
320 | |||
321 | ret = clps_setup_mtd(info, nr, &mymtd); | ||
322 | if (ret) | ||
323 | return ret; | ||
324 | |||
325 | clps_locate_partitions(mymtd); | ||
326 | |||
327 | return 0; | ||
328 | } | ||
329 | |||
330 | static void __exit clps_mtd_cleanup(void) | ||
331 | { | ||
332 | clps_destroy_mtd(info, mymtd); | ||
333 | clps_destroy_partitions(); | ||
334 | } | ||
335 | |||
336 | module_init(clps_mtd_init); | ||
337 | module_exit(clps_mtd_cleanup); | ||
338 | |||
339 | MODULE_AUTHOR("Rob Scott"); | ||
340 | MODULE_DESCRIPTION("Cirrus Logic JEDEC map driver"); | ||
341 | MODULE_LICENSE("GPL"); | ||