blob: 29091d10030a091651c935f6126221d1de92ff8e [file] [log] [blame]
/* $Id: sun_uflash.c,v 1.11 2004/11/04 13:24:15 gleixner Exp $
*
* sun_uflash - Driver implementation for user-programmable flash
* present on many Sun Microsystems SME boardsets.
*
* This driver does NOT provide access to the OBP-flash for
* safety reasons-- use <linux>/drivers/sbus/char/flash.c instead.
*
* Copyright (c) 2001 Eric Brower (ebrower@usa.net)
*
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/ioport.h>
#include <asm/ebus.h>
#include <asm/oplib.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <linux/mtd/mtd.h>
#include <linux/mtd/map.h>
#define UFLASH_OBPNAME "flashprom"
#define UFLASH_DEVNAME "userflash"
#define UFLASH_WINDOW_SIZE 0x200000
#define UFLASH_BUSWIDTH 1 /* EBus is 8-bit */
MODULE_AUTHOR
("Eric Brower <ebrower@usa.net>");
MODULE_DESCRIPTION
("User-programmable flash device on Sun Microsystems boardsets");
MODULE_SUPPORTED_DEVICE
("userflash");
MODULE_LICENSE
("GPL");
static LIST_HEAD(device_list);
struct uflash_dev {
char * name; /* device name */
struct map_info map; /* mtd map info */
struct mtd_info * mtd; /* mtd info */
struct list_head list;
};
struct map_info uflash_map_templ = {
.name = "SUNW,???-????",
.size = UFLASH_WINDOW_SIZE,
.bankwidth = UFLASH_BUSWIDTH,
};
int uflash_devinit(struct linux_ebus_device* edev)
{
int iTmp, nregs;
struct linux_prom_registers regs[2];
struct uflash_dev *pdev;
iTmp = prom_getproperty(
edev->prom_node, "reg", (void *)regs, sizeof(regs));
if ((iTmp % sizeof(regs[0])) != 0) {
printk("%s: Strange reg property size %d\n",
UFLASH_DEVNAME, iTmp);
return -ENODEV;
}
nregs = iTmp / sizeof(regs[0]);
if (nregs != 1) {
/* Non-CFI userflash device-- once I find one we
* can work on supporting it.
*/
printk("%s: unsupported device at 0x%lx (%d regs): " \
"email ebrower@usa.net\n",
UFLASH_DEVNAME, edev->resource[0].start, nregs);
return -ENODEV;
}
if(0 == (pdev = kmalloc(sizeof(struct uflash_dev), GFP_KERNEL))) {
printk("%s: unable to kmalloc new device\n", UFLASH_DEVNAME);
return(-ENOMEM);
}
/* copy defaults and tweak parameters */
memcpy(&pdev->map, &uflash_map_templ, sizeof(uflash_map_templ));
pdev->map.size = regs[0].reg_size;
iTmp = prom_getproplen(edev->prom_node, "model");
pdev->name = kmalloc(iTmp, GFP_KERNEL);
prom_getstring(edev->prom_node, "model", pdev->name, iTmp);
if(0 != pdev->name && 0 < strlen(pdev->name)) {
pdev->map.name = pdev->name;
}
pdev->map.phys = edev->resource[0].start;
pdev->map.virt = ioremap_nocache(edev->resource[0].start, pdev->map.size);
if(0 == pdev->map.virt) {
printk("%s: failed to map device\n", __FUNCTION__);
kfree(pdev->name);
kfree(pdev);
return(-1);
}
simple_map_init(&pdev->map);
/* MTD registration */
pdev->mtd = do_map_probe("cfi_probe", &pdev->map);
if(0 == pdev->mtd) {
iounmap(pdev->map.virt);
kfree(pdev->name);
kfree(pdev);
return(-ENXIO);
}
list_add(&pdev->list, &device_list);
pdev->mtd->owner = THIS_MODULE;
add_mtd_device(pdev->mtd);
return(0);
}
static int __init uflash_init(void)
{
struct linux_ebus *ebus = NULL;
struct linux_ebus_device *edev = NULL;
for_each_ebus(ebus) {
for_each_ebusdev(edev, ebus) {
if (!strcmp(edev->prom_name, UFLASH_OBPNAME)) {
if(0 > prom_getproplen(edev->prom_node, "user")) {
DEBUG(2, "%s: ignoring device at 0x%lx\n",
UFLASH_DEVNAME, edev->resource[0].start);
} else {
uflash_devinit(edev);
}
}
}
}
if(list_empty(&device_list)) {
printk("%s: unable to locate device\n", UFLASH_DEVNAME);
return -ENODEV;
}
return(0);
}
static void __exit uflash_cleanup(void)
{
struct list_head *udevlist;
struct uflash_dev *udev;
list_for_each(udevlist, &device_list) {
udev = list_entry(udevlist, struct uflash_dev, list);
DEBUG(2, "%s: removing device %s\n",
UFLASH_DEVNAME, udev->name);
if(0 != udev->mtd) {
del_mtd_device(udev->mtd);
map_destroy(udev->mtd);
}
if(0 != udev->map.virt) {
iounmap(udev->map.virt);
udev->map.virt = NULL;
}
if(0 != udev->name) {
kfree(udev->name);
}
kfree(udev);
}
}
module_init(uflash_init);
module_exit(uflash_cleanup);