drivers/mtd/nora.c

   1 /*
   2  * $Id: nora.c,v 1.11 2000/07/04 16:42:50 dwmw2 Exp $
   3  *
   4  * This is so simple I love it.
   5  */
   6
   7 #include <linux/module.h>
   8 #include <linux/types.h>
   9 #include <linux/kernel.h>
  10
  11 #include <linux/mtd/mtd.h>
  12 #include <linux/mtd/map.h>
  13
  14
  15 #define WINDOW_ADDR 0xd0000000
  16 #define WINDOW_SIZE 0x04000000
  17
  18 static struct mtd_info *mymtd;
  19
  20 __u8 nora_read8(struct map_info *map, unsigned long ofs)
  21 {
  22   return *(__u8 *)(WINDOW_ADDR + ofs);
  23 }
  24
  25 __u16 nora_read16(struct map_info *map, unsigned long ofs)
  26 {
  27   return *(__u16 *)(WINDOW_ADDR + ofs);
  28 }
  29
  30 __u32 nora_read32(struct map_info *map, unsigned long ofs)
  31 {
  32   return *(__u32 *)(WINDOW_ADDR + ofs);
  33 }
  34
  35 void nora_copy_from(struct map_info *map, void *to, unsigned long from, ssize_t len)
  36 {
  37   memcpy(to, (void *)(WINDOW_ADDR + from), len);
  38 }
  39
  40 void nora_write8(struct map_info *map, __u8 d, unsigned long adr)
  41 {
  42   *(__u8 *)(WINDOW_ADDR + adr) = d;
  43 }
  44
  45 void nora_write16(struct map_info *map, __u16 d, unsigned long adr)
  46 {
  47   *(__u16 *)(WINDOW_ADDR + adr) = d;
  48 }
  49
  50 void nora_write32(struct map_info *map, __u32 d, unsigned long adr)
  51 {
  52   *(__u32 *)(WINDOW_ADDR + adr) = d;
  53 }
  54
  55 void nora_copy_to(struct map_info *map, unsigned long to, const void *from, ssize_t len)
  56 {
  57   memcpy((void *)(WINDOW_ADDR + to), from, len);
  58 }
  59
  60 struct map_info nora_map = {
  61   "NORA",
  62   WINDOW_SIZE,
  63   2,
  64   nora_read8,
  65   nora_read16,
  66   nora_read32,
  67   nora_copy_from,
  68   nora_write8,
  69   nora_write16,
  70   nora_write32,
  71   nora_copy_to,
  72   0,
  73   0
  74 };
  75
  76
  77 static int nora_mtd_read (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf)
  78 {
  79         return mymtd->read(mymtd, from + (unsigned long)mtd->priv, len, retlen, buf);
  80 }
  81
  82 static int nora_mtd_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const u_char *buf)
  83 {
  84         return mymtd->write(mymtd, to + (unsigned long)mtd->priv, len, retlen, buf);
  85 }
  86
  87 static int nora_mtd_erase (struct mtd_info *mtd, struct erase_info *instr)
  88 {
  89         instr->addr += (unsigned long)mtd->priv;
  90         return mymtd->erase(mymtd, instr);
  91 }
  92
  93 static void nora_mtd_sync (struct mtd_info *mtd)
  94 {
  95         mymtd->sync(mymtd);
  96 }
  97
  98 static int nora_mtd_suspend (struct mtd_info *mtd)
  99 {
 100         return mymtd->suspend(mymtd);
 101 }
 102
 103 static void nora_mtd_resume (struct mtd_info *mtd)
 104 {
 105         mymtd->resume(mymtd);
 106 }
 107
 108
 109 static struct mtd_info nora_mtds[4] = {  /* boot, kernel, ramdisk, fs */
 110         {
 111                 type: MTD_NORFLASH,
 112                 flags: MTD_CAP_NORFLASH,
 113                 size: 0x60000,
 114                 erasesize: 0x20000,
 115                 name: "NORA boot firmware",
 116                 module: THIS_MODULE,
 117                 erase: nora_mtd_erase,
 118                 read: nora_mtd_read,
 119                 write: nora_mtd_write,
 120                 suspend: nora_mtd_suspend,
 121                 resume: nora_mtd_resume,
 122                 sync: nora_mtd_sync,
 123                 priv: (void *)0
 124         },
 125         {
 126                 type: MTD_NORFLASH,
 127                 flags: MTD_CAP_NORFLASH,
 128                 size: 0x1a0000,
 129                 erasesize: 0x20000,
 130                 name: "NORA kernel",
 131                 module: THIS_MODULE,
 132                 erase: nora_mtd_erase,
 133                 read: nora_mtd_read,
 134                 write: nora_mtd_write,
 135                 suspend: nora_mtd_suspend,
 136                 resume: nora_mtd_resume,
 137                 sync: nora_mtd_sync,
 138                 priv: (void *)0x60000
 139         },
 140         {
 141                 type: MTD_NORFLASH,
 142                 flags: MTD_CAP_NORFLASH,
 143                 size: 0xe00000,
 144                 erasesize: 0x20000,
 145                 name: "NORA ramdisk",
 146                 module: THIS_MODULE,
 147                 erase: nora_mtd_erase,
 148                 read: nora_mtd_read,
 149                 write: nora_mtd_write,
 150                 suspend: nora_mtd_suspend,
 151                 resume: nora_mtd_resume,
 152                 sync: nora_mtd_sync,
 153                 priv: (void *)0x200000
 154         },
 155         {
 156                 type: MTD_NORFLASH,
 157                 flags: MTD_CAP_NORFLASH,
 158                 size: 0x1000000,
 159                 erasesize: 0x20000,
 160                 name: "NORA filesystem",
 161                 module: THIS_MODULE,
 162                 erase: nora_mtd_erase,
 163                 read: nora_mtd_read,
 164                 write: nora_mtd_write,
 165                 suspend: nora_mtd_suspend,
 166                 resume: nora_mtd_resume,
 167                 sync: nora_mtd_sync,
 168                 priv: (void *)0x1000000
 169         }
 170 };
 171
 172 #if LINUX_VERSION_CODE < 0x20300
 173 #ifdef MODULE
 174 #define init_nora init_module
 175 #define cleanup_nora cleanup_module
 176 #endif
 177 #endif
 178
 179 int __init init_nora(void)
 180 {
 181         printk(KERN_NOTICE "nora flash device: %x at %x\n", WINDOW_SIZE, WINDOW_ADDR);
 182
 183         mymtd = do_cfi_probe(&nora_map);
 184         if (mymtd) {
 185 #ifdef MODULE
 186                 mymtd->module = &__this_module;
 187 #endif
 188
 189                 add_mtd_device(&nora_mtds[3]);
 190                 add_mtd_device(&nora_mtds[0]);
 191                 add_mtd_device(&nora_mtds[1]);
 192                 add_mtd_device(&nora_mtds[2]);
 193                 return 0;
 194         }
 195
 196         return -ENXIO;
 197 }
 198
 199 static void __exit cleanup_nora(void)
 200 {
 201         if (mymtd) {
 202                 del_mtd_device(&nora_mtds[2]);
 203                 del_mtd_device(&nora_mtds[1]);
 204                 del_mtd_device(&nora_mtds[0]);
 205                 del_mtd_device(&nora_mtds[3]);
 206                 map_destroy(mymtd);
 207         }
 208 }