25193a2f0220490be0a9b34ff2c8ec4b6dc3ad7b
[openwrt/svn-archive/archive.git] / target / linux / adm5120-2.6 / files / drivers / mtd / maps / adm5120-flash.c
1 /*
2 * $Id$
3 *
4 * Platform driver for NOR flash devices on ADM5120 based boards
5 *
6 * Copyright (C) 2007 OpenWrt.org
7 * Copyright (C) 2007 Gabor Juhos <juhosg@freemail.hu>
8 *
9 * This file was derived from: drivers/mtd/map/physmap.c
10 * Copyright (C) 2003 MontaVista Software Inc.
11 * Author: Jun Sun, jsun@mvista.com or jsun@junsun.net
12 *
13 * This program is free software; you can redistribute it and/or
14 * modify it under the terms of the GNU General Public License
15 * as published by the Free Software Foundation; either version 2
16 * of the License, or (at your option) any later version.
17 *
18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public License
24 * along with this program; if not, write to the
25 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
26 * Boston, MA 02110-1301, USA.
27 *
28 */
29
30 #include <linux/module.h>
31 #include <linux/types.h>
32 #include <linux/kernel.h>
33 #include <linux/init.h>
34 #include <linux/slab.h>
35 #include <linux/device.h>
36
37 #include <linux/platform_device.h>
38 #include <linux/mtd/mtd.h>
39 #include <linux/mtd/map.h>
40 #include <linux/mtd/partitions.h>
41
42 #include <asm/io.h>
43
44 #include <asm/mach-adm5120/adm5120_defs.h>
45 #include <asm/mach-adm5120/adm5120_switch.h>
46 #include <asm/mach-adm5120/adm5120_mpmc.h>
47 #include <asm/mach-adm5120/adm5120_platform.h>
48
49 #define DRV_NAME "adm5120-flash"
50 #define DRV_DESC "ADM5120 flash MAP driver"
51 #define MAX_PARSED_PARTS 8
52
53 #ifdef ADM5120_FLASH_DEBUG
54 #define MAP_DBG(m, f, a...) printk(KERN_INFO "%s: " f, (m->name) , ## a)
55 #else
56 #define MAP_DBG(m, f, a...) do {} while (0)
57 #endif
58 #define MAP_ERR(m, f, a...) printk(KERN_ERR "%s: " f, (m->name) , ## a)
59 #define MAP_INFO(m, f, a...) printk(KERN_INFO "%s: " f, (m->name) , ## a)
60
61 struct adm5120_map_info {
62 struct map_info map;
63 void (*switch_bank)(unsigned);
64 unsigned long chip_size;
65 };
66
67 struct adm5120_flash_info {
68 struct mtd_info *mtd;
69 struct resource *res;
70 struct platform_device *dev;
71 struct adm5120_map_info amap;
72 #ifdef CONFIG_MTD_PARTITIONS
73 int nr_parts;
74 struct mtd_partition *parts[MAX_PARSED_PARTS];
75 #endif
76 };
77
78 struct flash_desc {
79 u32 phys;
80 u32 srs_shift;
81 u32 mpmc_reg;
82 };
83
84 /*
85 * Globals
86 */
87 static DEFINE_SPINLOCK(adm5120_flash_spin);
88 #define FLASH_LOCK() spin_lock(&adm5120_flash_spin)
89 #define FLASH_UNLOCK() spin_unlock(&adm5120_flash_spin)
90
91 static u32 flash_bankwidths[4] = { 1, 2, 4, 0 };
92
93 static u32 flash_sizes[8] = {
94 0, 512*1024, 1024*1024, 2*1024*1024,
95 4*1024*1024, 0, 0, 0
96 };
97
98 static struct flash_desc flash_descs[2] = {
99 {
100 .phys = ADM5120_SRAM0_BASE,
101 .mpmc_reg = MPMC_REG_SC1,
102 .srs_shift = MEMCTRL_SRS0_SHIFT,
103 }, {
104 .phys = ADM5120_SRAM1_BASE,
105 .mpmc_reg = MPMC_REG_SC0,
106 .srs_shift = MEMCTRL_SRS1_SHIFT,
107 }
108 };
109
110 static const char *probe_types[] = {
111 "cfi_probe",
112 "jedec_probe",
113 "map_rom",
114 NULL
115 };
116
117 #ifdef CONFIG_MTD_PARTITIONS
118 static const char *parse_types[] = {
119 "cmdlinepart",
120 #ifdef CONFIG_MTD_REDBOOT_PARTS
121 "RedBoot",
122 #endif
123 #ifdef CONFIG_MTD_MYLOADER_PARTS
124 "MyLoader",
125 #endif
126 };
127 #endif
128
129 #define BANK_SIZE (2<<20)
130 #define BANK_SIZE_MAX (4<<20)
131 #define BANK_OFFS_MASK (BANK_SIZE-1)
132 #define BANK_START_MASK (~BANK_OFFS_MASK)
133
134 static inline struct adm5120_map_info *map_to_amap(struct map_info *map)
135 {
136 return (struct adm5120_map_info *)map;
137 }
138
139 static void adm5120_flash_switchbank(struct map_info *map,
140 unsigned long ofs)
141 {
142 struct adm5120_map_info *amap = map_to_amap(map);
143 unsigned bank;
144
145 if (amap->switch_bank == NULL)
146 return;
147
148 bank = (ofs & BANK_START_MASK) >> 21;
149 if (bank > 1)
150 BUG();
151
152 MAP_DBG(map, "switching to bank %u, ofs=%lX\n", bank, ofs);
153 amap->switch_bank(bank);
154 }
155
156 static map_word adm5120_flash_read(struct map_info *map, unsigned long ofs)
157 {
158 struct adm5120_map_info *amap = map_to_amap(map);
159 map_word ret;
160
161 MAP_DBG(map, "reading from ofs %lu\n", ofs);
162
163 if (ofs >= amap->chip_size)
164 return map_word_ff(map);
165
166 FLASH_LOCK();
167 adm5120_flash_switchbank(map, ofs);
168 ret = inline_map_read(map, (ofs & BANK_OFFS_MASK));
169 FLASH_UNLOCK();
170
171 return ret;
172 }
173
174 static void adm5120_flash_write(struct map_info *map, const map_word datum,
175 unsigned long ofs)
176 {
177 struct adm5120_map_info *amap = map_to_amap(map);
178
179 MAP_DBG(map,"writing to ofs %lu\n", ofs);
180
181 if (ofs > amap->chip_size)
182 return;
183
184 FLASH_LOCK();
185 adm5120_flash_switchbank(map, ofs);
186 inline_map_write(map, datum, (ofs & BANK_OFFS_MASK));
187 FLASH_UNLOCK();
188 }
189
190 static void adm5120_flash_copy_from(struct map_info *map, void *to,
191 unsigned long from, ssize_t len)
192 {
193 struct adm5120_map_info *amap = map_to_amap(map);
194 char *p;
195 ssize_t t;
196
197 MAP_DBG(map, "copy_from, to=%lX, from=%lX, len=%lX\n",
198 (unsigned long)to, from, (unsigned long)len);
199
200 if (from > amap->chip_size)
201 return;
202
203 p = (char *)to;
204 while (len > 0) {
205 t = len;
206 if (from < BANK_SIZE && from+len > BANK_SIZE)
207 t = BANK_SIZE-from;
208
209 FLASH_LOCK();
210 MAP_DBG(map, "copying %lu byte(s) from %lX to %lX\n",
211 (unsigned long)t, (from & BANK_OFFS_MASK),
212 (unsigned long)p);
213 adm5120_flash_switchbank(map, from);
214 inline_map_copy_from(map, p, (from & BANK_OFFS_MASK), t);
215 FLASH_UNLOCK();
216 p += t;
217 from += t;
218 len -= t;
219 }
220 }
221
222 static int adm5120_flash_initres(struct adm5120_flash_info *info)
223 {
224 struct map_info *map = &info->amap.map;
225 int err = 0;
226
227 info->res = request_mem_region(map->phys, map->size, map->name);
228 if (info->res == NULL) {
229 MAP_ERR(map, "could not reserve memory region\n");
230 err = -ENOMEM;
231 goto out;
232 }
233
234 map->virt = ioremap_nocache(map->phys, map->size);
235 if (map->virt == NULL) {
236 MAP_ERR(map, "failed to ioremap flash region\n");
237 err = -ENOMEM;
238 goto out;
239 }
240
241 out:
242 return err;
243 }
244
245 #define SWITCH_READ(r) *(u32 *)(KSEG1ADDR(ADM5120_SWITCH_BASE)+(r))
246 #define SWITCH_WRITE(r,v) *(u32 *)(KSEG1ADDR(ADM5120_SWITCH_BASE)+(r))=(v)
247 #define MPMC_READ(r) *(u32 *)(KSEG1ADDR(ADM5120_MPMC_BASE)+(r))
248 #define MPMC_WRITE(r,v) *(u32 *)(KSEG1ADDR(ADM5120_MPMC_BASE)+(r))=(v)
249
250 static int adm5120_flash_initinfo(struct adm5120_flash_info *info,
251 struct platform_device *dev)
252 {
253 struct map_info *map = &info->amap.map;
254 struct adm5120_flash_platform_data *pdata = dev->dev.platform_data;
255 struct flash_desc *fdesc;
256 u32 t;
257
258 map->name = dev->dev.bus_id;
259
260 if (dev->id > 1) {
261 MAP_ERR(map, "invalid flash id\n");
262 goto err_out;
263 }
264
265 fdesc = &flash_descs[dev->id];
266
267 /* get memory window size */
268 t = SWITCH_READ(SWITCH_REG_MEMCTRL) >> fdesc->srs_shift;
269 t &= MEMCTRL_SRS_MASK;
270 info->amap.chip_size = flash_sizes[t];
271 if (info->amap.chip_size == 0) {
272 MAP_ERR(map, "invalid flash size detected\n");
273 goto err_out;
274 }
275
276 /* get flash bus width */
277 t = MPMC_READ(fdesc->mpmc_reg) & SC_MW_MASK;
278 map->bankwidth = flash_bankwidths[t];
279 if (map->bankwidth == 0) {
280 MAP_ERR(map, "invalid bus width detected\n");
281 goto err_out;
282 }
283
284 map->phys = fdesc->phys;
285 map->size = BANK_SIZE_MAX;
286
287 simple_map_init(map);
288 map->read = adm5120_flash_read;
289 map->write = adm5120_flash_write;
290 map->copy_from = adm5120_flash_copy_from;
291
292 if (pdata) {
293 map->set_vpp = pdata->set_vpp;
294 info->amap.switch_bank = pdata->switch_bank;
295 }
296
297 info->dev = dev;
298
299 MAP_INFO(map, "probing at 0x%lX, size:%ldKiB, width:%d bits\n",
300 (unsigned long)map->phys,
301 (unsigned long)info->amap.chip_size >> 10,
302 map->bankwidth*8);
303
304 return 0;
305
306 err_out:
307 return -ENODEV;
308 }
309
310 static void adm5120_flash_initbanks(struct adm5120_flash_info *info)
311 {
312 struct map_info *map = &info->amap.map;
313
314 if (info->mtd->size <= BANK_SIZE)
315 /* no bank switching needed */
316 return;
317
318 if (info->amap.switch_bank) {
319 info->amap.chip_size = info->mtd->size;
320 return;
321 }
322
323 MAP_ERR(map, "reduce visibility from %ldKiB to %ldKiB\n",
324 (unsigned long)map->size >> 10,
325 (unsigned long)info->mtd->size >> 10);
326
327 info->mtd->size = info->amap.chip_size;
328 }
329
330 #ifdef CONFIG_MTD_PARTITIONS
331 static int adm5120_flash_initparts(struct adm5120_flash_info *info)
332 {
333 struct adm5120_flash_platform_data *pdata = info->dev->dev.platform_data;
334 struct map_info *map = &info->amap.map;
335 int num_parsers;
336 const char *parser[2];
337 int err = 0;
338 int nr_parts;
339 int i;
340
341 info->nr_parts = 0;
342
343 if (pdata == NULL)
344 goto out;
345
346 if (pdata->nr_parts) {
347 MAP_INFO(map, "adding static partitions\n");
348 err = add_mtd_partitions(info->mtd, pdata->parts,
349 pdata->nr_parts);
350 if (err == 0) {
351 info->nr_parts += pdata->nr_parts;
352 goto out;
353 }
354 }
355
356 num_parsers = ARRAY_SIZE(parse_types);
357 if (num_parsers > MAX_PARSED_PARTS)
358 num_parsers = MAX_PARSED_PARTS;
359
360 parser[1] = NULL;
361 for (i=0; i<num_parsers; i++) {
362 parser[0] = parse_types[i];
363
364 MAP_INFO(map, "parsing \"%s\" partitions\n",
365 parser[0]);
366 nr_parts = parse_mtd_partitions(info->mtd, parser,
367 &info->parts[i], 0);
368
369 if (nr_parts <= 0)
370 continue;
371
372 MAP_INFO(map, "adding \"%s\" partitions\n",
373 parser[0]);
374
375 err = add_mtd_partitions(info->mtd, info->parts[i], nr_parts);
376 if (err)
377 break;
378
379 info->nr_parts += nr_parts;
380 }
381 out:
382 return err;
383 }
384 #else
385 static int adm5120_flash_initparts(struct adm5120_flash_info *info)
386 {
387 return 0;
388 }
389 #endif /* CONFIG_MTD_PARTITIONS */
390
391 #ifdef CONFIG_MTD_PARTITIONS
392 static void adm5120_flash_remove_mtd(struct adm5120_flash_info *info)
393 {
394 int i;
395
396 if (info->nr_parts) {
397 del_mtd_partitions(info->mtd);
398 for (i=0; i<MAX_PARSED_PARTS; i++)
399 if (info->parts[i] != NULL)
400 kfree(info->parts[i]);
401 } else {
402 del_mtd_device(info->mtd);
403 }
404 }
405 #else
406 static void adm5120_flash_remove_mtd(struct adm5120_flash_info *info)
407 {
408 del_mtd_device(info->mtd);
409 }
410 #endif
411
412 static int adm5120_flash_remove(struct platform_device *dev)
413 {
414 struct adm5120_flash_info *info;
415
416 info = platform_get_drvdata(dev);
417 if (info == NULL)
418 return 0;
419
420 platform_set_drvdata(dev, NULL);
421
422 if (info->mtd != NULL) {
423 adm5120_flash_remove_mtd(info);
424 map_destroy(info->mtd);
425 }
426
427 if (info->amap.map.virt != NULL)
428 iounmap(info->amap.map.virt);
429
430 if (info->res != NULL) {
431 release_resource(info->res);
432 kfree(info->res);
433 }
434
435 return 0;
436 }
437
438 static int adm5120_flash_probe(struct platform_device *dev)
439 {
440 struct adm5120_flash_info *info;
441 struct map_info *map;
442 const char **probe_type;
443 int err;
444
445 info = kzalloc(sizeof(*info), GFP_KERNEL);
446 if (info == NULL) {
447 err = -ENOMEM;
448 goto err_out;
449 }
450
451 platform_set_drvdata(dev, info);
452
453 err = adm5120_flash_initinfo(info, dev);
454 if (err)
455 goto err_out;
456
457 err = adm5120_flash_initres(info);
458 if (err)
459 goto err_out;
460
461 map = &info->amap.map;
462 for (probe_type = probe_types; info->mtd == NULL && *probe_type != NULL;
463 probe_type++)
464 info->mtd = do_map_probe(*probe_type, map);
465
466 if (info->mtd == NULL) {
467 MAP_ERR(map, "map_probe failed\n");
468 err = -ENXIO;
469 goto err_out;
470 }
471
472 adm5120_flash_initbanks(info);
473
474 if (info->mtd->size < info->amap.chip_size) {
475 /* readjust resources */
476 iounmap(map->virt);
477 release_resource(info->res);
478 kfree(info->res);
479
480 info->amap.chip_size = info->mtd->size;
481 map->size = info->mtd->size;
482 MAP_INFO(map, "reducing map size to %ldKiB\n",
483 (unsigned long)map->size >> 10);
484 err = adm5120_flash_initres(info);
485 if (err)
486 goto err_out;
487 }
488
489 MAP_INFO(map, "found at 0x%lX, size:%ldKiB, width:%d bits\n",
490 (unsigned long)map->phys, (unsigned long)info->mtd->size >> 10,
491 map->bankwidth*8);
492
493 info->mtd->owner = THIS_MODULE;
494
495 err = adm5120_flash_initparts(info);
496 if (err)
497 goto err_out;
498
499 if (info->nr_parts == 0) {
500 MAP_INFO(map, "no partitions available, registering whole flash\n");
501 add_mtd_device(info->mtd);
502 }
503
504 return 0;
505
506 err_out:
507 adm5120_flash_remove(dev);
508 return err;
509 }
510
511 #ifdef CONFIG_PM
512 static int adm5120_flash_suspend(struct platform_device *dev, pm_message_t state)
513 {
514 struct adm5120_flash_info *info = platform_get_drvdata(dev);
515 int ret = 0;
516
517 if (info)
518 ret = info->mtd->suspend(info->mtd);
519
520 return ret;
521 }
522
523 static int adm5120_flash_resume(struct platform_device *dev)
524 {
525 struct adm5120_flash_info *info = platform_get_drvdata(dev);
526
527 if (info)
528 info->mtd->resume(info->mtd);
529
530 return 0;
531 }
532
533 static void adm5120_flash_shutdown(struct platform_device *dev)
534 {
535 struct adm5120_flash_info *info = platform_get_drvdata(dev);
536
537 if (info && info->mtd->suspend(info->mtd) == 0)
538 info->mtd->resume(info->mtd);
539 }
540 #endif
541
542 static struct platform_driver adm5120_flash_driver = {
543 .probe = adm5120_flash_probe,
544 .remove = adm5120_flash_remove,
545 #ifdef CONFIG_PM
546 .suspend = adm5120_flash_suspend,
547 .resume = adm5120_flash_resume,
548 .shutdown = adm5120_flash_shutdown,
549 #endif
550 .driver = {
551 .name = DRV_NAME,
552 },
553 };
554
555 static int __init adm5120_flash_init(void)
556 {
557 int err;
558
559 err = platform_driver_register(&adm5120_flash_driver);
560
561 return err;
562 }
563
564 static void __exit adm5120_flash_exit(void)
565 {
566 platform_driver_unregister(&adm5120_flash_driver);
567 }
568
569 module_init(adm5120_flash_init);
570 module_exit(adm5120_flash_exit);
571
572 MODULE_LICENSE("GPL");
573 MODULE_AUTHOR("Gabor Juhos <juhosg@freemail.hu>");
574 MODULE_DESCRIPTION(DRV_DESC);