drivers/mtd/maps/sun_uflash.c

   1 /* $Id: sun_uflash.c,v 1.7 2003/05/20 20:59:32 dwmw2 Exp $
   2  *
   3  * sun_uflash - Driver implementation for user-programmable flash
   4  * present on many Sun Microsystems SME boardsets.
   5  *
   6  * This driver does NOT provide access to the OBP-flash for
   7  * safety reasons-- use <linux>/drivers/sbus/char/flash.c instead.
   8  *
   9  * Copyright (c) 2001 Eric Brower (ebrower@usa.net)
  10  *
  11  */
  12
  13 #include <linux/kernel.h>
  14 #include <linux/module.h>
  15 #include <linux/fs.h>
  16 #include <linux/errno.h>
  17 #include <linux/init.h>
  18 #include <linux/ioport.h>
  19 #include <asm/ebus.h>
  20 #include <asm/oplib.h>
  21 #include <asm/uaccess.h>
  22 #include <asm/io.h>
  23
  24 #include <linux/mtd/mtd.h>
  25 #include <linux/mtd/map.h>
  26
  27 #define UFLASH_OBPNAME  "flashprom"
  28 #define UFLASH_DEVNAME  "userflash"
  29
  30 #define UFLASH_WINDOW_SIZE      0x200000
  31 #define UFLASH_BUSWIDTH         1                       /* EBus is 8-bit */
  32
  33 MODULE_AUTHOR
  34         ("Eric Brower <ebrower@usa.net>");
  35 MODULE_DESCRIPTION
  36         ("User-programmable flash device on Sun Microsystems boardsets");
  37 MODULE_SUPPORTED_DEVICE
  38         ("userflash");
  39 MODULE_LICENSE
  40         ("GPL");
  41
  42 static LIST_HEAD(device_list);
  43 struct uflash_dev {
  44         char *                  name;   /* device name */
  45         struct map_info         map;    /* mtd map info */
  46         struct mtd_info *       mtd;    /* mtd info */
  47         struct list_head        list;
  48 };
  49
  50
  51 struct map_info uflash_map_templ = {
  52                 .name =         "SUNW,???-????",
  53                 .size =         UFLASH_WINDOW_SIZE,
  54                 .buswidth =     UFLASH_BUSWIDTH,
  55 };
  56
  57 int uflash_devinit(struct linux_ebus_device* edev)
  58 {
  59         int iTmp, nregs;
  60         struct linux_prom_registers regs[2];
  61         struct uflash_dev *pdev;
  62
  63         iTmp = prom_getproperty(
  64                 edev->prom_node, "reg", (void *)regs, sizeof(regs));
  65         if ((iTmp % sizeof(regs[0])) != 0) {
  66                 printk("%s: Strange reg property size %d\n",
  67                         UFLASH_DEVNAME, iTmp);
  68                 return -ENODEV;
  69         }
  70
  71         nregs = iTmp / sizeof(regs[0]);
  72
  73         if (nregs != 1) {
  74                 /* Non-CFI userflash device-- once I find one we
  75                  * can work on supporting it.
  76                  */
  77                 printk("%s: unsupported device at 0x%lx (%d regs): " \
  78                         "email ebrower@usa.net\n",
  79                         UFLASH_DEVNAME, edev->resource[0].start, nregs);
  80                 return -ENODEV;
  81         }
  82
  83         if(0 == (pdev = kmalloc(sizeof(struct uflash_dev), GFP_KERNEL))) {
  84                 printk("%s: unable to kmalloc new device\n", UFLASH_DEVNAME);
  85                 return(-ENOMEM);
  86         }
  87
  88         /* copy defaults and tweak parameters */
  89         memcpy(&pdev->map, &uflash_map_templ, sizeof(uflash_map_templ));
  90         pdev->map.size = regs[0].reg_size;
  91
  92         iTmp = prom_getproplen(edev->prom_node, "model");
  93         pdev->name = kmalloc(iTmp, GFP_KERNEL);
  94         prom_getstring(edev->prom_node, "model", pdev->name, iTmp);
  95         if(0 != pdev->name && 0 < strlen(pdev->name)) {
  96                 pdev->map.name = pdev->name;
  97         }
  98         pdev->map.phys = edev->resource[0].start;
  99         pdev->map.virt =
 100                 (unsigned long)ioremap_nocache(edev->resource[0].start, pdev->map.size);
 101         if(0 == pdev->map.virt) {
 102                 printk("%s: failed to map device\n", __FUNCTION__);
 103                 kfree(pdev->name);
 104                 kfree(pdev);
 105                 return(-1);
 106         }
 107
 108         simple_map_init(&pdev->map);
 109
 110         /* MTD registration */
 111         pdev->mtd = do_map_probe("cfi_probe", &pdev->map);
 112         if(0 == pdev->mtd) {
 113                 iounmap((void *)pdev->map.virt);
 114                 kfree(pdev->name);
 115                 kfree(pdev);
 116                 return(-ENXIO);
 117         }
 118
 119         list_add(&pdev->list, &device_list);
 120
 121         pdev->mtd->owner = THIS_MODULE;
 122
 123         add_mtd_device(pdev->mtd);
 124         return(0);
 125 }
 126
 127 static int __init uflash_init(void)
 128 {
 129         struct linux_ebus *ebus = NULL;
 130         struct linux_ebus_device *edev = NULL;
 131
 132         for_each_ebus(ebus) {
 133                 for_each_ebusdev(edev, ebus) {
 134                         if (!strcmp(edev->prom_name, UFLASH_OBPNAME)) {
 135                                 if(0 > prom_getproplen(edev->prom_node, "user")) {
 136                                         DEBUG(2, "%s: ignoring device at 0x%lx\n",
 137                                                         UFLASH_DEVNAME, edev->resource[0].start);
 138                                 } else {
 139                                         uflash_devinit(edev);
 140                                 }
 141                         }
 142                 }
 143         }
 144
 145         if(list_empty(&device_list)) {
 146                 printk("%s: unable to locate device\n", UFLASH_DEVNAME);
 147                 return -ENODEV;
 148         }
 149         return(0);
 150 }
 151
 152 static void __exit uflash_cleanup(void)
 153 {
 154         struct list_head *udevlist;
 155         struct uflash_dev *udev;
 156
 157         list_for_each(udevlist, &device_list) {
 158                 udev = list_entry(udevlist, struct uflash_dev, list);
 159                 DEBUG(2, "%s: removing device %s\n",
 160                         UFLASH_DEVNAME, udev->name);
 161
 162                 if(0 != udev->mtd) {
 163                         del_mtd_device(udev->mtd);
 164                         map_destroy(udev->mtd);
 165                 }
 166                 if(0 != udev->map.virt) {
 167                         iounmap((void*)udev->map.virt);
 168                         udev->map.virt = 0;
 169                 }
 170                 if(0 != udev->name) {
 171                         kfree(udev->name);
 172                 }
 173                 kfree(udev);
 174         }
 175 }
 176
 177 module_init(uflash_init);
 178 module_exit(uflash_cleanup);