drivers/mtd/maps/db1x00-flash.c

   1 /*
   2  * Flash memory access on Alchemy Db1xxx boards
   3  *
   4  * $Id: db1x00-flash.c,v 1.6 2004/11/04 13:24:14 gleixner Exp $
   5  *
   6  * (C) 2003 Pete Popov <ppopov@embeddedalley.com>
   7  *
   8  */
   9
  10 #include <linux/config.h>
  11 #include <linux/module.h>
  12 #include <linux/types.h>
  13 #include <linux/init.h>
  14 #include <linux/kernel.h>
  15
  16 #include <linux/mtd/mtd.h>
  17 #include <linux/mtd/map.h>
  18 #include <linux/mtd/partitions.h>
  19
  20 #include <asm/io.h>
  21
  22 #ifdef  DEBUG_RW
  23 #define DBG(x...)       printk(x)
  24 #else
  25 #define DBG(x...)
  26 #endif
  27
  28 /* MTD CONFIG OPTIONS */
  29 #if defined(CONFIG_MTD_DB1X00_BOOT) && defined(CONFIG_MTD_DB1X00_USER)
  30 #define DB1X00_BOTH_BANKS
  31 #elif defined(CONFIG_MTD_DB1X00_BOOT) && !defined(CONFIG_MTD_DB1X00_USER)
  32 #define DB1X00_BOOT_ONLY
  33 #elif !defined(CONFIG_MTD_DB1X00_BOOT) && defined(CONFIG_MTD_DB1X00_USER)
  34 #define DB1X00_USER_ONLY
  35 #endif
  36
  37 static unsigned long window_addr;
  38 static unsigned long window_size;
  39 static unsigned long flash_size;
  40
  41 static unsigned short *bcsr = (unsigned short *)0xAE000000;
  42 static unsigned char flash_bankwidth = 4;
  43
  44 /*
  45  * The Db1x boards support different flash densities. We setup
  46  * the mtd_partition structures below for default of 64Mbit
  47  * flash densities, and override the partitions sizes, if
  48  * necessary, after we check the board status register.
  49  */
  50
  51 #ifdef DB1X00_BOTH_BANKS
  52 /* both banks will be used. Combine the first bank and the first
  53  * part of the second bank together into a single jffs/jffs2
  54  * partition.
  55  */
  56 static struct mtd_partition db1x00_partitions[] = {
  57         {
  58                 .name         =  "User FS",
  59                 .size         =  0x1c00000,
  60                 .offset       =  0x0000000
  61         },{
  62                 .name         =  "yamon",
  63                 .size         =  0x0100000,
  64                 .offset       =  MTDPART_OFS_APPEND,
  65                 .mask_flags   =  MTD_WRITEABLE
  66         },{
  67                 .name         =  "raw kernel",
  68                 .size         =  (0x300000-0x40000), /* last 256KB is env */
  69                 .offset       =  MTDPART_OFS_APPEND,
  70         }
  71 };
  72 #elif defined(DB1X00_BOOT_ONLY)
  73 static struct mtd_partition db1x00_partitions[] = {
  74         {
  75                 .name         =  "User FS",
  76                 .size         =  0x00c00000,
  77                 .offset       =  0x0000000
  78         },{
  79                 .name         =  "yamon",
  80                 .size         =  0x0100000,
  81                 .offset       =  MTDPART_OFS_APPEND,
  82                 .mask_flags   =  MTD_WRITEABLE
  83         },{
  84                 .name         =  "raw kernel",
  85                 .size         =  (0x300000-0x40000), /* last 256KB is env */
  86                 .offset       =  MTDPART_OFS_APPEND,
  87         }
  88 };
  89 #elif defined(DB1X00_USER_ONLY)
  90 static struct mtd_partition db1x00_partitions[] = {
  91         {
  92                 .name         =  "User FS",
  93                 .size         =  0x0e00000,
  94                 .offset       =  0x0000000
  95         },{
  96                 .name         =  "raw kernel",
  97                 .size         =  MTDPART_SIZ_FULL,
  98                 .offset       =  MTDPART_OFS_APPEND,
  99         }
 100 };
 101 #else
 102 #error MTD_DB1X00 define combo error /* should never happen */
 103 #endif
 104 #define NB_OF(x)  (sizeof(x)/sizeof(x[0]))
 105
 106 #define NAME            "Db1x00 Linux Flash"
 107
 108 static struct map_info db1xxx_mtd_map = {
 109         .name           = NAME,
 110 };
 111
 112 static struct mtd_partition *parsed_parts;
 113 static struct mtd_info *db1xxx_mtd;
 114
 115 /*
 116  * Probe the flash density and setup window address and size
 117  * based on user CONFIG options. There are times when we don't
 118  * want the MTD driver to be probing the boot or user flash,
 119  * so having the option to enable only one bank is important.
 120  */
 121 int setup_flash_params(void)
 122 {
 123         switch ((bcsr[2] >> 14) & 0x3) {
 124                 case 0: /* 64Mbit devices */
 125                         flash_size = 0x800000; /* 8MB per part */
 126 #if defined(DB1X00_BOTH_BANKS)
 127                         window_addr = 0x1E000000;
 128                         window_size = 0x2000000;
 129 #elif defined(DB1X00_BOOT_ONLY)
 130                         window_addr = 0x1F000000;
 131                         window_size = 0x1000000;
 132 #else /* USER ONLY */
 133                         window_addr = 0x1E000000;
 134                         window_size = 0x1000000;
 135 #endif
 136                         break;
 137                 case 1:
 138                         /* 128 Mbit devices */
 139                         flash_size = 0x1000000; /* 16MB per part */
 140 #if defined(DB1X00_BOTH_BANKS)
 141                         window_addr = 0x1C000000;
 142                         window_size = 0x4000000;
 143                         /* USERFS from 0x1C00 0000 to 0x1FC0 0000 */
 144                         db1x00_partitions[0].size = 0x3C00000;
 145 #elif defined(DB1X00_BOOT_ONLY)
 146                         window_addr = 0x1E000000;
 147                         window_size = 0x2000000;
 148                         /* USERFS from 0x1E00 0000 to 0x1FC0 0000 */
 149                         db1x00_partitions[0].size = 0x1C00000;
 150 #else /* USER ONLY */
 151                         window_addr = 0x1C000000;
 152                         window_size = 0x2000000;
 153                         /* USERFS from 0x1C00 0000 to 0x1DE00000 */
 154                         db1x00_partitions[0].size = 0x1DE0000;
 155 #endif
 156                         break;
 157                 case 2:
 158                         /* 256 Mbit devices */
 159                         flash_size = 0x4000000; /* 64MB per part */
 160 #if defined(DB1X00_BOTH_BANKS)
 161                         return 1;
 162 #elif defined(DB1X00_BOOT_ONLY)
 163                         /* Boot ROM flash bank only; no user bank */
 164                         window_addr = 0x1C000000;
 165                         window_size = 0x4000000;
 166                         /* USERFS from 0x1C00 0000 to 0x1FC00000 */
 167                         db1x00_partitions[0].size = 0x3C00000;
 168 #else /* USER ONLY */
 169                         return 1;
 170 #endif
 171                         break;
 172                 default:
 173                         return 1;
 174         }
 175         db1xxx_mtd_map.size = window_size;
 176         db1xxx_mtd_map.bankwidth = flash_bankwidth;
 177         db1xxx_mtd_map.phys = window_addr;
 178         db1xxx_mtd_map.bankwidth = flash_bankwidth;
 179         return 0;
 180 }
 181
 182 int __init db1x00_mtd_init(void)
 183 {
 184         struct mtd_partition *parts;
 185         int nb_parts = 0;
 186
 187         if (setup_flash_params())
 188                 return -ENXIO;
 189
 190         /*
 191          * Static partition definition selection
 192          */
 193         parts = db1x00_partitions;
 194         nb_parts = NB_OF(db1x00_partitions);
 195
 196         /*
 197          * Now let's probe for the actual flash.  Do it here since
 198          * specific machine settings might have been set above.
 199          */
 200         printk(KERN_NOTICE "Db1xxx flash: probing %d-bit flash bus\n",
 201                         db1xxx_mtd_map.bankwidth*8);
 202         db1xxx_mtd_map.virt = ioremap(window_addr, window_size);
 203         db1xxx_mtd = do_map_probe("cfi_probe", &db1xxx_mtd_map);
 204         if (!db1xxx_mtd) return -ENXIO;
 205         db1xxx_mtd->owner = THIS_MODULE;
 206
 207         add_mtd_partitions(db1xxx_mtd, parts, nb_parts);
 208         return 0;
 209 }
 210
 211 static void __exit db1x00_mtd_cleanup(void)
 212 {
 213         if (db1xxx_mtd) {
 214                 del_mtd_partitions(db1xxx_mtd);
 215                 map_destroy(db1xxx_mtd);
 216                 if (parsed_parts)
 217                         kfree(parsed_parts);
 218         }
 219 }
 220
 221 module_init(db1x00_mtd_init);
 222 module_exit(db1x00_mtd_cleanup);
 223
 224 MODULE_AUTHOR("Pete Popov");
 225 MODULE_DESCRIPTION("Db1x00 mtd map driver");
 226 MODULE_LICENSE("GPL");