Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/shaggy...
[linux-2.6] / drivers / mtd / maps / ipaq-flash.c
1 /*
2  * Flash memory access on iPAQ Handhelds (either SA1100 or PXA250 based)
3  *
4  * (C) 2000 Nicolas Pitre <nico@cam.org>
5  * (C) 2002 Hewlett-Packard Company <jamey.hicks@hp.com>
6  * (C) 2003 Christian Pellegrin <chri@ascensit.com>, <chri@infis.univ.ts.it>: concatenation of multiple flashes
7  *
8  * $Id: ipaq-flash.c,v 1.5 2005/11/07 11:14:27 gleixner Exp $
9  */
10
11 #include <linux/module.h>
12 #include <linux/types.h>
13 #include <linux/kernel.h>
14 #include <linux/spinlock.h>
15 #include <linux/init.h>
16 #include <linux/slab.h>
17 #include <asm/page.h>
18 #include <asm/mach-types.h>
19 #include <asm/system.h>
20 #include <asm/errno.h>
21
22 #include <linux/mtd/mtd.h>
23 #include <linux/mtd/map.h>
24 #include <linux/mtd/partitions.h>
25 #ifdef CONFIG_MTD_CONCAT
26 #include <linux/mtd/concat.h>
27 #endif
28
29 #include <asm/hardware.h>
30 #include <asm/arch-sa1100/h3600.h>
31 #include <asm/io.h>
32
33
34 #ifndef CONFIG_IPAQ_HANDHELD
35 #error This is for iPAQ Handhelds only
36 #endif
37 #ifdef CONFIG_SA1100_JORNADA56X
38
39 static void jornada56x_set_vpp(struct map_info *map, int vpp)
40 {
41         if (vpp)
42                 GPSR = GPIO_GPIO26;
43         else
44                 GPCR = GPIO_GPIO26;
45         GPDR |= GPIO_GPIO26;
46 }
47
48 #endif
49
50 #ifdef CONFIG_SA1100_JORNADA720
51
52 static void jornada720_set_vpp(struct map_info *map, int vpp)
53 {
54         if (vpp)
55                 PPSR |= 0x80;
56         else
57                 PPSR &= ~0x80;
58         PPDR |= 0x80;
59 }
60
61 #endif
62
63 #define MAX_IPAQ_CS 2           /* Number of CS we are going to test */
64
65 #define IPAQ_MAP_INIT(X) \
66         { \
67                 name:           "IPAQ flash " X, \
68         }
69
70
71 static struct map_info ipaq_map[MAX_IPAQ_CS] = {
72         IPAQ_MAP_INIT("bank 1"),
73         IPAQ_MAP_INIT("bank 2")
74 };
75
76 static struct mtd_info *my_sub_mtd[MAX_IPAQ_CS] = {
77         NULL,
78         NULL
79 };
80
81 /*
82  * Here are partition information for all known IPAQ-based devices.
83  * See include/linux/mtd/partitions.h for definition of the mtd_partition
84  * structure.
85  *
86  * The *_max_flash_size is the maximum possible mapped flash size which
87  * is not necessarily the actual flash size.  It must be no more than
88  * the value specified in the "struct map_desc *_io_desc" mapping
89  * definition for the corresponding machine.
90  *
91  * Please keep these in alphabetical order, and formatted as per existing
92  * entries.  Thanks.
93  */
94
95 #ifdef CONFIG_IPAQ_HANDHELD
96 static unsigned long h3xxx_max_flash_size = 0x04000000;
97 static struct mtd_partition h3xxx_partitions[] = {
98         {
99                 name:           "H3XXX boot firmware",
100 #ifndef CONFIG_LAB
101                 size:           0x00040000,
102 #else
103                 size:           0x00080000,
104 #endif
105                 offset:         0,
106 #ifndef CONFIG_LAB
107                 mask_flags:     MTD_WRITEABLE,  /* force read-only */
108 #endif
109         },
110         {
111                 name:           "H3XXX root jffs2",
112 #ifndef CONFIG_LAB
113                 size:           0x2000000 - 2*0x40000, /* Warning, this is fixed later */
114                 offset:         0x00040000,
115 #else
116                 size:           0x2000000 - 0x40000 - 0x80000, /* Warning, this is fixed later */
117                 offset:         0x00080000,
118 #endif
119         },
120         {
121                 name:           "asset",
122                 size:           0x40000,
123                 offset:         0x2000000 - 0x40000, /* Warning, this is fixed later */
124                 mask_flags:     MTD_WRITEABLE,  /* force read-only */
125         }
126 };
127
128 #ifndef CONFIG_MTD_CONCAT
129 static struct mtd_partition h3xxx_partitions_bank2[] = {
130         /* this is used only on 2 CS machines when concat is not present */
131         {
132                 name:           "second H3XXX root jffs2",
133                 size:           0x1000000 - 0x40000, /* Warning, this is fixed later */
134                 offset:         0x00000000,
135         },
136         {
137                 name:           "second asset",
138                 size:           0x40000,
139                 offset:         0x1000000 - 0x40000, /* Warning, this is fixed later */
140                 mask_flags:     MTD_WRITEABLE,  /* force read-only */
141         }
142 };
143 #endif
144
145 static DEFINE_SPINLOCK(ipaq_vpp_lock);
146
147 static void h3xxx_set_vpp(struct map_info *map, int vpp)
148 {
149         static int nest = 0;
150
151         spin_lock(&ipaq_vpp_lock);
152         if (vpp)
153                 nest++;
154         else
155                 nest--;
156         if (nest)
157                 assign_h3600_egpio(IPAQ_EGPIO_VPP_ON, 1);
158         else
159                 assign_h3600_egpio(IPAQ_EGPIO_VPP_ON, 0);
160         spin_unlock(&ipaq_vpp_lock);
161 }
162
163 #endif
164
165 #if defined(CONFIG_SA1100_JORNADA56X) || defined(CONFIG_SA1100_JORNADA720)
166 static unsigned long jornada_max_flash_size = 0x02000000;
167 static struct mtd_partition jornada_partitions[] = {
168         {
169                 name:           "Jornada boot firmware",
170                 size:           0x00040000,
171                 offset:         0,
172                 mask_flags:     MTD_WRITEABLE,  /* force read-only */
173         }, {
174                 name:           "Jornada root jffs2",
175                 size:           MTDPART_SIZ_FULL,
176                 offset:         0x00040000,
177         }
178 };
179 #endif
180
181
182 static struct mtd_partition *parsed_parts;
183 static struct mtd_info *mymtd;
184
185 static unsigned long cs_phys[] = {
186 #ifdef CONFIG_ARCH_SA1100
187         SA1100_CS0_PHYS,
188         SA1100_CS1_PHYS,
189         SA1100_CS2_PHYS,
190         SA1100_CS3_PHYS,
191         SA1100_CS4_PHYS,
192         SA1100_CS5_PHYS,
193 #else
194         PXA_CS0_PHYS,
195         PXA_CS1_PHYS,
196         PXA_CS2_PHYS,
197         PXA_CS3_PHYS,
198         PXA_CS4_PHYS,
199         PXA_CS5_PHYS,
200 #endif
201 };
202
203 static const char *part_probes[] = { "cmdlinepart", "RedBoot", NULL };
204
205 static int __init h1900_special_case(void);
206
207 int __init ipaq_mtd_init(void)
208 {
209         struct mtd_partition *parts = NULL;
210         int nb_parts = 0;
211         int parsed_nr_parts = 0;
212         const char *part_type;
213         int i; /* used when we have >1 flash chips */
214         unsigned long tot_flashsize = 0; /* used when we have >1 flash chips */
215
216         /* Default flash bankwidth */
217         // ipaq_map.bankwidth = (MSC0 & MSC_RBW) ? 2 : 4;
218
219         if (machine_is_h1900())
220         {
221                 /* For our intents, the h1900 is not a real iPAQ, so we special-case it. */
222                 return h1900_special_case();
223         }
224
225         if (machine_is_h3100() || machine_is_h1900())
226                 for(i=0; i<MAX_IPAQ_CS; i++)
227                         ipaq_map[i].bankwidth = 2;
228         else
229                 for(i=0; i<MAX_IPAQ_CS; i++)
230                         ipaq_map[i].bankwidth = 4;
231
232         /*
233          * Static partition definition selection
234          */
235         part_type = "static";
236
237         simple_map_init(&ipaq_map[0]);
238         simple_map_init(&ipaq_map[1]);
239
240 #ifdef CONFIG_IPAQ_HANDHELD
241         if (machine_is_ipaq()) {
242                 parts = h3xxx_partitions;
243                 nb_parts = ARRAY_SIZE(h3xxx_partitions);
244                 for(i=0; i<MAX_IPAQ_CS; i++) {
245                         ipaq_map[i].size = h3xxx_max_flash_size;
246                         ipaq_map[i].set_vpp = h3xxx_set_vpp;
247                         ipaq_map[i].phys = cs_phys[i];
248                         ipaq_map[i].virt = ioremap(cs_phys[i], 0x04000000);
249                         if (machine_is_h3100 () || machine_is_h1900())
250                                 ipaq_map[i].bankwidth = 2;
251                 }
252                 if (machine_is_h3600()) {
253                         /* No asset partition here */
254                         h3xxx_partitions[1].size += 0x40000;
255                         nb_parts--;
256                 }
257         }
258 #endif
259 #ifdef CONFIG_ARCH_H5400
260         if (machine_is_h5400()) {
261                 ipaq_map[0].size = 0x02000000;
262                 ipaq_map[1].size = 0x02000000;
263                 ipaq_map[1].phys = 0x02000000;
264                 ipaq_map[1].virt = ipaq_map[0].virt + 0x02000000;
265         }
266 #endif
267 #ifdef CONFIG_ARCH_H1900
268         if (machine_is_h1900()) {
269                 ipaq_map[0].size = 0x00400000;
270                 ipaq_map[1].size = 0x02000000;
271                 ipaq_map[1].phys = 0x00080000;
272                 ipaq_map[1].virt = ipaq_map[0].virt + 0x00080000;
273         }
274 #endif
275
276 #ifdef CONFIG_SA1100_JORNADA56X
277         if (machine_is_jornada56x()) {
278                 parts = jornada_partitions;
279                 nb_parts = ARRAY_SIZE(jornada_partitions);
280                 ipaq_map[0].size = jornada_max_flash_size;
281                 ipaq_map[0].set_vpp = jornada56x_set_vpp;
282                 ipaq_map[0].virt = (__u32)ioremap(0x0, 0x04000000);
283         }
284 #endif
285 #ifdef CONFIG_SA1100_JORNADA720
286         if (machine_is_jornada720()) {
287                 parts = jornada_partitions;
288                 nb_parts = ARRAY_SIZE(jornada_partitions);
289                 ipaq_map[0].size = jornada_max_flash_size;
290                 ipaq_map[0].set_vpp = jornada720_set_vpp;
291         }
292 #endif
293
294
295         if (machine_is_ipaq()) { /* for iPAQs only */
296                 for(i=0; i<MAX_IPAQ_CS; i++) {
297                         printk(KERN_NOTICE "iPAQ flash: probing %d-bit flash bus, window=%lx with CFI.\n", ipaq_map[i].bankwidth*8, ipaq_map[i].virt);
298                         my_sub_mtd[i] = do_map_probe("cfi_probe", &ipaq_map[i]);
299                         if (!my_sub_mtd[i]) {
300                                 printk(KERN_NOTICE "iPAQ flash: probing %d-bit flash bus, window=%lx with JEDEC.\n", ipaq_map[i].bankwidth*8, ipaq_map[i].virt);
301                                 my_sub_mtd[i] = do_map_probe("jedec_probe", &ipaq_map[i]);
302                         }
303                         if (!my_sub_mtd[i]) {
304                                 printk(KERN_NOTICE "iPAQ flash: failed to find flash.\n");
305                                 if (i)
306                                         break;
307                                 else
308                                         return -ENXIO;
309                         } else
310                                 printk(KERN_NOTICE "iPAQ flash: found %d bytes\n", my_sub_mtd[i]->size);
311
312                         /* do we really need this debugging? --joshua 20030703 */
313                         // printk("my_sub_mtd[%d]=%p\n", i, my_sub_mtd[i]);
314                         my_sub_mtd[i]->owner = THIS_MODULE;
315                         tot_flashsize += my_sub_mtd[i]->size;
316                 }
317 #ifdef CONFIG_MTD_CONCAT
318                 /* fix the asset location */
319 #       ifdef CONFIG_LAB
320                 h3xxx_partitions[1].size = tot_flashsize - 0x40000 - 0x80000 /* extra big boot block */;
321 #       else
322                 h3xxx_partitions[1].size = tot_flashsize - 2 * 0x40000;
323 #       endif
324                 h3xxx_partitions[2].offset = tot_flashsize - 0x40000;
325                 /* and concat the devices */
326                 mymtd = mtd_concat_create(&my_sub_mtd[0], i,
327                                           "ipaq");
328                 if (!mymtd) {
329                         printk("Cannot create iPAQ concat device\n");
330                         return -ENXIO;
331                 }
332 #else
333                 mymtd = my_sub_mtd[0];
334
335                 /*
336                  *In the very near future, command line partition parsing
337                  * will use the device name as 'mtd-id' instead of a value
338                  * passed to the parse_cmdline_partitions() routine. Since
339                  * the bootldr says 'ipaq', make sure it continues to work.
340                  */
341                 mymtd->name = "ipaq";
342
343                 if ((machine_is_h3600())) {
344 #       ifdef CONFIG_LAB
345                         h3xxx_partitions[1].size = my_sub_mtd[0]->size - 0x80000;
346 #       else
347                         h3xxx_partitions[1].size = my_sub_mtd[0]->size - 0x40000;
348 #       endif
349                         nb_parts = 2;
350                 } else {
351 #       ifdef CONFIG_LAB
352                         h3xxx_partitions[1].size = my_sub_mtd[0]->size - 0x40000 - 0x80000; /* extra big boot block */
353 #       else
354                         h3xxx_partitions[1].size = my_sub_mtd[0]->size - 2*0x40000;
355 #       endif
356                         h3xxx_partitions[2].offset = my_sub_mtd[0]->size - 0x40000;
357                 }
358
359                 if (my_sub_mtd[1]) {
360 #       ifdef CONFIG_LAB
361                         h3xxx_partitions_bank2[0].size = my_sub_mtd[1]->size - 0x80000;
362 #       else
363                         h3xxx_partitions_bank2[0].size = my_sub_mtd[1]->size - 0x40000;
364 #       endif
365                         h3xxx_partitions_bank2[1].offset = my_sub_mtd[1]->size - 0x40000;
366                 }
367 #endif
368         }
369         else {
370                 /*
371                  * Now let's probe for the actual flash.  Do it here since
372                  * specific machine settings might have been set above.
373                  */
374                 printk(KERN_NOTICE "IPAQ flash: probing %d-bit flash bus, window=%lx\n", ipaq_map[0].bankwidth*8, ipaq_map[0].virt);
375                 mymtd = do_map_probe("cfi_probe", &ipaq_map[0]);
376                 if (!mymtd)
377                         return -ENXIO;
378                 mymtd->owner = THIS_MODULE;
379         }
380
381
382         /*
383          * Dynamic partition selection stuff (might override the static ones)
384          */
385
386          i = parse_mtd_partitions(mymtd, part_probes, &parsed_parts, 0);
387
388          if (i > 0) {
389                  nb_parts = parsed_nr_parts = i;
390                  parts = parsed_parts;
391                  part_type = "dynamic";
392          }
393
394          if (!parts) {
395                  printk(KERN_NOTICE "IPAQ flash: no partition info available, registering whole flash at once\n");
396                  add_mtd_device(mymtd);
397 #ifndef CONFIG_MTD_CONCAT
398                  if (my_sub_mtd[1])
399                          add_mtd_device(my_sub_mtd[1]);
400 #endif
401          } else {
402                  printk(KERN_NOTICE "Using %s partition definition\n", part_type);
403                  add_mtd_partitions(mymtd, parts, nb_parts);
404 #ifndef CONFIG_MTD_CONCAT
405                  if (my_sub_mtd[1])
406                          add_mtd_partitions(my_sub_mtd[1], h3xxx_partitions_bank2, ARRAY_SIZE(h3xxx_partitions_bank2));
407 #endif
408          }
409
410          return 0;
411 }
412
413 static void __exit ipaq_mtd_cleanup(void)
414 {
415         int i;
416
417         if (mymtd) {
418                 del_mtd_partitions(mymtd);
419 #ifndef CONFIG_MTD_CONCAT
420                 if (my_sub_mtd[1])
421                         del_mtd_partitions(my_sub_mtd[1]);
422 #endif
423                 map_destroy(mymtd);
424 #ifdef CONFIG_MTD_CONCAT
425                 for(i=0; i<MAX_IPAQ_CS; i++)
426 #else
427                         for(i=1; i<MAX_IPAQ_CS; i++)
428 #endif
429                         {
430                                 if (my_sub_mtd[i])
431                                         map_destroy(my_sub_mtd[i]);
432                         }
433                 kfree(parsed_parts);
434         }
435 }
436
437 static int __init h1900_special_case(void)
438 {
439         /* The iPAQ h1900 is a special case - it has weird ROM. */
440         simple_map_init(&ipaq_map[0]);
441         ipaq_map[0].size = 0x80000;
442         ipaq_map[0].set_vpp = h3xxx_set_vpp;
443         ipaq_map[0].phys = 0x0;
444         ipaq_map[0].virt = ioremap(0x0, 0x04000000);
445         ipaq_map[0].bankwidth = 2;
446
447         printk(KERN_NOTICE "iPAQ flash: probing %d-bit flash bus, window=%lx with JEDEC.\n", ipaq_map[0].bankwidth*8, ipaq_map[0].virt);
448         mymtd = do_map_probe("jedec_probe", &ipaq_map[0]);
449         if (!mymtd)
450                 return -ENODEV;
451         add_mtd_device(mymtd);
452         printk(KERN_NOTICE "iPAQ flash: registered h1910 flash\n");
453
454         return 0;
455 }
456
457 module_init(ipaq_mtd_init);
458 module_exit(ipaq_mtd_cleanup);
459
460 MODULE_AUTHOR("Jamey Hicks");
461 MODULE_DESCRIPTION("IPAQ CFI map driver");
462 MODULE_LICENSE("MIT");