Linux kernel & device driver programming

Cross-Referenced Linux and Device Driver Code

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ]
Version: [ 2.6.11.8 ] [ 2.6.25 ] [ 2.6.25.8 ] [ 2.6.31.13 ] Architecture: [ i386 ]
  1 /*
  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");
166 
  This page was automatically generated by the LXR engine.