[rdc] add preliminary support for the bifferboard, patch from bifferos
[openwrt.git] / target / linux / rdc / files / drivers / mtd / maps / bifferboard-flash.c
1 /* Flash mapping for Bifferboard, (c) bifferos@yahoo.co.uk
2 * Works with 1, 4 and 8MB flash versions
3 */
4
5 #include <linux/delay.h>
6 #include <linux/mtd/mtd.h>
7 #include <linux/mtd/map.h>
8 #include <linux/mtd/partitions.h>
9
10 #define DRV "bifferboard-flash: "
11
12 static struct mtd_info *bb_mtd = NULL;
13
14 #define SIZE_BIFFBOOT 0x10000
15 #define SIZE_SECTOR 0x10000
16 #define SIZE_CONFIG 0x02000
17 #define SIZE_1MB 0x00100000
18 #define SIZE_4MB 0x00400000
19 #define SIZE_8MB 0x00800000
20
21 #define BASE_1MB 0xfff00000
22 #define BASE_4MB 0xffc00000
23 #define BASE_8MB 0xff800000
24
25 #define OFFS_KERNEL 0x6000
26 #define OFFS_CONFIG 0x4000
27
28 /*
29 * Flash detection code. This is needed because the cfi_probe doesn't probe
30 * for the size correctly. You actually have to know the flash size before you
31 * call it, or so it seems. It does work correctly if you map the entire flash
32 * chip, but unsure of the implications for mapping more mem than exists.
33 */
34
35 static unsigned char ReadFlash(void* base, u32 addr)
36 {
37 unsigned char val = *(volatile unsigned char *)(base+addr);
38 udelay(1);
39 return val;
40 }
41
42 static void WriteFlash(void* base, u32 addr, unsigned short data)
43 {
44 *(volatile unsigned short *)(base+addr) = data;
45 }
46
47 static DEFINE_SPINLOCK(flash_lock);
48
49 static u32 bb_detect(void)
50 {
51 u32 ret = 0;
52 ulong flags;
53
54 /* for detection, map in just the 1MB device, 1st 64k is enough */
55 void* base = ioremap_nocache(BASE_1MB, 0x10000);
56
57 if (!base)
58 {
59 pr_err(DRV "Failed to map flash for probing\n");
60 return 0;
61 }
62
63 spin_lock_irqsave(&flash_lock, flags);
64
65 /* put flash in auto-detect mode */
66 WriteFlash(base, 0xaaaa, 0xaaaa);
67 WriteFlash(base, 0x5554, 0x5555);
68 WriteFlash(base, 0xaaaa, 0x9090);
69
70 /* Read the auto-config data - 4 values in total */
71 ret = ReadFlash(base, 0x0000); ret <<= 8;
72 ret |= ReadFlash(base, 0x0200); ret <<= 8;
73 ret |= ReadFlash(base, 0x0003); ret <<= 8;
74 ret |= ReadFlash(base, 0x0002);
75
76 /* exit the autodetect state */
77 WriteFlash(base, 0x0000, 0xf0f0);
78
79 spin_unlock_irqrestore(&flash_lock, flags);
80
81 /* unmap it, it'll be re-mapped based on the detection */
82 iounmap(base);
83
84 return ret;
85 }
86
87
88 static struct map_info bb_map;
89
90 /* Update the map, using the detected flash signature. */
91 static int bb_adjust_map(unsigned long sig, struct map_info* m)
92 {
93 m->bankwidth = 2;
94 switch (sig)
95 {
96 case 0x7f1c225b :
97 m->name = "ENLV800B";
98 m->phys = BASE_1MB;
99 m->size = SIZE_1MB;
100 break;
101 case 0x7f1c22f9 :
102 m->name = "ENLV320B";
103 m->phys = BASE_4MB;
104 m->size = SIZE_4MB;
105 break;
106 case 0x7f1c22cb :
107 m->name = "ENLV640B";
108 m->phys = BASE_8MB;
109 m->size = SIZE_8MB;
110 break;
111 default:
112 return -ENXIO;
113 }
114 return 0;
115 }
116
117
118 /* adjust partition sizes, prior to adding the partition
119 * Values not specified by defines here are subject to replacement based on
120 * the real flash size. (0x00000000 being the exception, of course) */
121
122 static struct mtd_partition bb_parts[] =
123 {
124 /* 0 */ { name: "kernel", offset: 0x00000000, size: 0x000fa000 },
125 /* 1 */ { name: "rootfs", offset: MTDPART_OFS_APPEND, size: 0x002F0000 },
126 /* 2 */ { name: "biffboot", offset: MTDPART_OFS_APPEND, size: MTDPART_SIZ_FULL, mask_flags: MTD_WRITEABLE },
127 };
128
129
130 /* returns the count of partitions to be used */
131 static ulong bb_adjust_partitions(struct map_info* m)
132 {
133 /* Read the kernel offset value, 1036 bytes into the config block. */
134 u16 km_units = *((u16*)(m->virt + OFFS_CONFIG + 1036));
135 u32 kernelmax = 0x200000; /* Biffboot 2.7 or earlier default */
136
137 /* special-case 1MB devices, because there are fewer partitions */
138 if (m->size == SIZE_1MB)
139 {
140 bb_parts[0].size = SIZE_1MB - SIZE_BIFFBOOT; /* kernel */
141 bb_parts[1].name = "biffboot"; /* biffboot */
142 bb_parts[1].offset = MTDPART_OFS_APPEND; /* biffboot */
143 bb_parts[1].size = MTDPART_SIZ_FULL; /* biffboot */
144 bb_parts[1].mask_flags = MTD_WRITEABLE;
145 return 2; /* because there's no rootfs now */
146 }
147
148 /* sanity check */
149 if (km_units > ((m->size-SIZE_BIFFBOOT)/SIZE_SECTOR))
150 {
151 pr_err(DRV "config block has invalid kernelmax\n");
152 return 0;
153 }
154
155 kernelmax = km_units * SIZE_SECTOR;
156
157 /* Kernel */
158 bb_parts[0].size = kernelmax;
159
160 /* rootfs */
161 bb_parts[1].size = m->size - kernelmax - SIZE_BIFFBOOT;
162
163 return 3; /* 3 partitions */
164 }
165
166
167 static int __init init_bb_map(void)
168 {
169 int ret;
170 ulong signature = bb_detect();
171 ulong part_len;
172
173 if (!signature)
174 {
175 pr_err(DRV "Undetected flash chip");
176 return -ENXIO;
177 }
178
179 ret = bb_adjust_map(signature, &bb_map);
180
181 if (ret)
182 {
183 pr_err(DRV "Unrecognised flash chip (signature: 0x%lx)\n", signature);
184 return ret;
185 }
186
187 bb_map.virt = ioremap_nocache(bb_map.phys, bb_map.size);
188 if (!bb_map.virt)
189 {
190 pr_err(DRV "ioremap\n");
191 return -EIO;
192 }
193
194 bb_mtd = do_map_probe("cfi_probe", &bb_map);
195 if (!bb_mtd)
196 {
197 /* cfi_probe fails here for 1MB devices */
198 pr_err(DRV "cfi_probe\n");
199 ret = -ENXIO;
200 goto err;
201 }
202
203 part_len = bb_adjust_partitions(&bb_map);
204 if (!part_len)
205 {
206 pr_err(DRV "no partitions established");
207 ret = -ENXIO;
208 goto err2;
209 }
210
211 bb_mtd->owner = THIS_MODULE;
212 ret = add_mtd_partitions(bb_mtd, bb_parts, part_len);
213 if (ret)
214 {
215 pr_err(DRV "add_mtd_partitions\n");
216 ret = -ENXIO;
217 goto err2;
218 }
219
220 return 0;
221
222 err2:
223 map_destroy(bb_mtd);
224 err:
225 iounmap(bb_map.virt);
226
227 return ret;
228 }
229
230 static void __exit exit_bb_map(void)
231 {
232 del_mtd_partitions(bb_mtd);
233 map_destroy(bb_mtd);
234 iounmap(bb_map.virt);
235 }
236
237 module_init(init_bb_map);
238 module_exit(exit_bb_map);
239
240 MODULE_LICENSE("GPL");
241 MODULE_AUTHOR("Bifferos <bifferos@yahoo.co.uk>");
242 MODULE_DESCRIPTION("MTD map driver for Bifferboard");
243
This page took 0.070166 seconds and 5 git commands to generate.