URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [mtd/] [maps/] [ebony.c] - Blame information for rev 62

Details | Compare with Previous | View Log


/*
 * $Id: ebony.c,v 1.16 2005/11/07 11:14:26 gleixner Exp $
 *
 * Mapping for Ebony user flash
 *
 * Matt Porter <mporter@kernel.crashing.org>
 *
 * Copyright 2002-2004 MontaVista Software Inc.
 *
 * This program is free software; you can redistribute  it and/or modify it
 * under  the terms of  the GNU General  Public License as published by the
 * Free Software Foundation;  either version 2 of the  License, or (at your
 * option) any later version.
 */
 
#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/mtd/mtd.h>
#include <linux/mtd/map.h>
#include <linux/mtd/partitions.h>
#include <asm/io.h>
#include <asm/ibm44x.h>
#include <platforms/4xx/ebony.h>
 
static struct mtd_info *flash;
 
static struct map_info ebony_small_map = {
        .name =         "Ebony small flash",
        .size =         EBONY_SMALL_FLASH_SIZE,
        .bankwidth =    1,
};
 
static struct map_info ebony_large_map = {
        .name =         "Ebony large flash",
        .size =         EBONY_LARGE_FLASH_SIZE,
        .bankwidth =    1,
};
 
static struct mtd_partition ebony_small_partitions[] = {
        {
                .name =   "OpenBIOS",
                .offset = 0x0,
                .size =   0x80000,
        }
};
 
static struct mtd_partition ebony_large_partitions[] = {
        {
                .name =   "fs",
                .offset = 0,
                .size =   0x380000,
        },
        {
                .name =   "firmware",
                .offset = 0x380000,
                .size =   0x80000,
        }
};
 
int __init init_ebony(void)
{
        u8 fpga0_reg;
        u8 __iomem *fpga0_adr;
        unsigned long long small_flash_base, large_flash_base;
 
        fpga0_adr = ioremap64(EBONY_FPGA_ADDR, 16);
        if (!fpga0_adr)
                return -ENOMEM;
 
        fpga0_reg = readb(fpga0_adr);
        iounmap(fpga0_adr);
 
        if (EBONY_BOOT_SMALL_FLASH(fpga0_reg) &&
                        !EBONY_FLASH_SEL(fpga0_reg))
                small_flash_base = EBONY_SMALL_FLASH_HIGH2;
        else if (EBONY_BOOT_SMALL_FLASH(fpga0_reg) &&
                        EBONY_FLASH_SEL(fpga0_reg))
                small_flash_base = EBONY_SMALL_FLASH_HIGH1;
        else if (!EBONY_BOOT_SMALL_FLASH(fpga0_reg) &&
                        !EBONY_FLASH_SEL(fpga0_reg))
                small_flash_base = EBONY_SMALL_FLASH_LOW2;
        else
                small_flash_base = EBONY_SMALL_FLASH_LOW1;
 
        if (EBONY_BOOT_SMALL_FLASH(fpga0_reg) &&
                        !EBONY_ONBRD_FLASH_EN(fpga0_reg))
                large_flash_base = EBONY_LARGE_FLASH_LOW;
        else
                large_flash_base = EBONY_LARGE_FLASH_HIGH;
 
        ebony_small_map.phys = small_flash_base;
        ebony_small_map.virt = ioremap64(small_flash_base,
                                         ebony_small_map.size);
 
        if (!ebony_small_map.virt) {
                printk("Failed to ioremap flash\n");
                return -EIO;
        }
 
        simple_map_init(&ebony_small_map);
 
        flash = do_map_probe("jedec_probe", &ebony_small_map);
        if (flash) {
                flash->owner = THIS_MODULE;
                add_mtd_partitions(flash, ebony_small_partitions,
                                        ARRAY_SIZE(ebony_small_partitions));
        } else {
                printk("map probe failed for flash\n");
                iounmap(ebony_small_map.virt);
                return -ENXIO;
        }
 
        ebony_large_map.phys = large_flash_base;
        ebony_large_map.virt = ioremap64(large_flash_base,
                                         ebony_large_map.size);
 
        if (!ebony_large_map.virt) {
                printk("Failed to ioremap flash\n");
                iounmap(ebony_small_map.virt);
                return -EIO;
        }
 
        simple_map_init(&ebony_large_map);
 
        flash = do_map_probe("jedec_probe", &ebony_large_map);
        if (flash) {
                flash->owner = THIS_MODULE;
                add_mtd_partitions(flash, ebony_large_partitions,
                                        ARRAY_SIZE(ebony_large_partitions));
        } else {
                printk("map probe failed for flash\n");
                iounmap(ebony_small_map.virt);
                iounmap(ebony_large_map.virt);
                return -ENXIO;
        }
 
        return 0;
}
 
static void __exit cleanup_ebony(void)
{
        if (flash) {
                del_mtd_partitions(flash);
                map_destroy(flash);
        }
 
        if (ebony_small_map.virt) {
                iounmap(ebony_small_map.virt);
                ebony_small_map.virt = NULL;
        }
 
        if (ebony_large_map.virt) {
                iounmap(ebony_large_map.virt);
                ebony_large_map.virt = NULL;
        }
}
 
module_init(init_ebony);
module_exit(cleanup_ebony);
 
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Matt Porter <mporter@kernel.crashing.org>");
MODULE_DESCRIPTION("MTD map and partitions for IBM 440GP Ebony boards");

Line No.	Rev	Author	Line
1	62	marcus.erl	`/*`
2			`* $Id: ebony.c,v 1.16 2005/11/07 11:14:26 gleixner Exp $`
3			`*`
4			`* Mapping for Ebony user flash`
5			`*`
6			`* Matt Porter <mporter@kernel.crashing.org>`
7			`*`
8			`* Copyright 2002-2004 MontaVista Software Inc.`
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 as published by the`
12			`* Free Software Foundation; either version 2 of the License, or (at your`
13			`* option) any later version.`
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/mtd/mtd.h>`
21			`#include <linux/mtd/map.h>`
22			`#include <linux/mtd/partitions.h>`
23			`#include <asm/io.h>`
24			`#include <asm/ibm44x.h>`
25			`#include <platforms/4xx/ebony.h>`
26
27			`static struct mtd_info *flash;`
28
29			`static struct map_info ebony_small_map = {`
30			`.name = "Ebony small flash",`
31			`.size = EBONY_SMALL_FLASH_SIZE,`
32			`.bankwidth = 1,`
33			`};`
34
35			`static struct map_info ebony_large_map = {`
36			`.name = "Ebony large flash",`
37			`.size = EBONY_LARGE_FLASH_SIZE,`
38			`.bankwidth = 1,`
39			`};`
40
41			`static struct mtd_partition ebony_small_partitions[] = {`
42			`{`
43			`.name = "OpenBIOS",`
44			`.offset = 0x0,`
45			`.size = 0x80000,`
46			`}`
47			`};`
48
49			`static struct mtd_partition ebony_large_partitions[] = {`
50			`{`
51			`.name = "fs",`
52			`.offset = 0,`
53			`.size = 0x380000,`
54			`},`
55			`{`
56			`.name = "firmware",`
57			`.offset = 0x380000,`
58			`.size = 0x80000,`
59			`}`
60			`};`
61
62			`int __init init_ebony(void)`
63			`{`
64			`u8 fpga0_reg;`
65			`u8 __iomem *fpga0_adr;`
66			`unsigned long long small_flash_base, large_flash_base;`
67
68			`fpga0_adr = ioremap64(EBONY_FPGA_ADDR, 16);`
69			`if (!fpga0_adr)`
70			`return -ENOMEM;`
71
72			`fpga0_reg = readb(fpga0_adr);`
73			`iounmap(fpga0_adr);`
74
75			`if (EBONY_BOOT_SMALL_FLASH(fpga0_reg) &&`
76			`!EBONY_FLASH_SEL(fpga0_reg))`
77			`small_flash_base = EBONY_SMALL_FLASH_HIGH2;`
78			`else if (EBONY_BOOT_SMALL_FLASH(fpga0_reg) &&`
79			`EBONY_FLASH_SEL(fpga0_reg))`
80			`small_flash_base = EBONY_SMALL_FLASH_HIGH1;`
81			`else if (!EBONY_BOOT_SMALL_FLASH(fpga0_reg) &&`
82			`!EBONY_FLASH_SEL(fpga0_reg))`
83			`small_flash_base = EBONY_SMALL_FLASH_LOW2;`
84			`else`
85			`small_flash_base = EBONY_SMALL_FLASH_LOW1;`
86
87			`if (EBONY_BOOT_SMALL_FLASH(fpga0_reg) &&`
88			`!EBONY_ONBRD_FLASH_EN(fpga0_reg))`
89			`large_flash_base = EBONY_LARGE_FLASH_LOW;`
90			`else`
91			`large_flash_base = EBONY_LARGE_FLASH_HIGH;`
92
93			`ebony_small_map.phys = small_flash_base;`
94			`ebony_small_map.virt = ioremap64(small_flash_base,`
95			`ebony_small_map.size);`
96
97			`if (!ebony_small_map.virt) {`
98			`printk("Failed to ioremap flash\n");`
99			`return -EIO;`
100			`}`
101
102			`simple_map_init(&ebony_small_map);`
103
104			`flash = do_map_probe("jedec_probe", &ebony_small_map);`
105			`if (flash) {`
106			`flash->owner = THIS_MODULE;`
107			`add_mtd_partitions(flash, ebony_small_partitions,`
108			`ARRAY_SIZE(ebony_small_partitions));`
109			`} else {`
110			`printk("map probe failed for flash\n");`
111			`iounmap(ebony_small_map.virt);`
112			`return -ENXIO;`
113			`}`
114
115			`ebony_large_map.phys = large_flash_base;`
116			`ebony_large_map.virt = ioremap64(large_flash_base,`
117			`ebony_large_map.size);`
118
119			`if (!ebony_large_map.virt) {`
120			`printk("Failed to ioremap flash\n");`
121			`iounmap(ebony_small_map.virt);`
122			`return -EIO;`
123			`}`
124
125			`simple_map_init(&ebony_large_map);`
126
127			`flash = do_map_probe("jedec_probe", &ebony_large_map);`
128			`if (flash) {`
129			`flash->owner = THIS_MODULE;`
130			`add_mtd_partitions(flash, ebony_large_partitions,`
131			`ARRAY_SIZE(ebony_large_partitions));`
132			`} else {`
133			`printk("map probe failed for flash\n");`
134			`iounmap(ebony_small_map.virt);`
135			`iounmap(ebony_large_map.virt);`
136			`return -ENXIO;`
137			`}`
138
139			`return 0;`
140			`}`
141
142			`static void __exit cleanup_ebony(void)`
143			`{`
144			`if (flash) {`
145			`del_mtd_partitions(flash);`
146			`map_destroy(flash);`
147			`}`
148
149			`if (ebony_small_map.virt) {`
150			`iounmap(ebony_small_map.virt);`
151			`ebony_small_map.virt = NULL;`
152			`}`
153
154			`if (ebony_large_map.virt) {`
155			`iounmap(ebony_large_map.virt);`
156			`ebony_large_map.virt = NULL;`
157			`}`
158			`}`
159
160			`module_init(init_ebony);`
161			`module_exit(cleanup_ebony);`
162
163			`MODULE_LICENSE("GPL");`
164			`MODULE_AUTHOR("Matt Porter <mporter@kernel.crashing.org>");`
165			`MODULE_DESCRIPTION("MTD map and partitions for IBM 440GP Ebony boards");`

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [mtd/] [maps/] [ebony.c] - Blame information for rev 62