Root/target/linux/adm5120/files/drivers/mtd/maps/adm5120-flash.c

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

Archive Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl



interactive