aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/mtd/maps
diff options
context:
space:
mode:
authorDavid S. Miller <davem@davemloft.net>2008-08-29 20:41:36 -0400
committerDavid S. Miller <davem@davemloft.net>2008-08-29 20:41:36 -0400
commit0e52fe8c01e7945881aac6aeb7c96af3f59976a8 (patch)
treedfe1932dba36c5bc2ab5c803b51d8492940d74f9 /drivers/mtd/maps
parent8ab0dc333eacb2249c63d1fc7c5241299fa0493f (diff)
sun_uflash: Convert to pure OF driver.
Signed-off-by: David S. Miller <davem@davemloft.net>
Diffstat (limited to 'drivers/mtd/maps')
-rw-r--r--drivers/mtd/maps/sun_uflash.c73
1 files changed, 35 insertions, 38 deletions
diff --git a/drivers/mtd/maps/sun_uflash.c b/drivers/mtd/maps/sun_uflash.c
index 0d7c88396c88..e931f1df0af1 100644
--- a/drivers/mtd/maps/sun_uflash.c
+++ b/drivers/mtd/maps/sun_uflash.c
@@ -1,13 +1,10 @@
1/* 1/* sun_uflash.c - Driver for user-programmable flash on
2 * 2 * Sun Microsystems SME boardsets.
3 * sun_uflash - Driver implementation for user-programmable flash
4 * present on many Sun Microsystems SME boardsets.
5 * 3 *
6 * This driver does NOT provide access to the OBP-flash for 4 * This driver does NOT provide access to the OBP-flash for
7 * safety reasons-- use <linux>/drivers/sbus/char/flash.c instead. 5 * safety reasons-- use <linux>/drivers/sbus/char/flash.c instead.
8 * 6 *
9 * Copyright (c) 2001 Eric Brower (ebrower@usa.net) 7 * Copyright (c) 2001 Eric Brower (ebrower@usa.net)
10 *
11 */ 8 */
12 9
13#include <linux/kernel.h> 10#include <linux/kernel.h>
@@ -16,8 +13,8 @@
16#include <linux/errno.h> 13#include <linux/errno.h>
17#include <linux/init.h> 14#include <linux/init.h>
18#include <linux/ioport.h> 15#include <linux/ioport.h>
19#include <asm/ebus.h> 16#include <linux/of.h>
20#include <asm/oplib.h> 17#include <linux/of_device.h>
21#include <asm/prom.h> 18#include <asm/prom.h>
22#include <asm/uaccess.h> 19#include <asm/uaccess.h>
23#include <asm/io.h> 20#include <asm/io.h>
@@ -26,67 +23,65 @@
26#include <linux/mtd/map.h> 23#include <linux/mtd/map.h>
27 24
28#define UFLASH_OBPNAME "flashprom" 25#define UFLASH_OBPNAME "flashprom"
29#define UFLASH_DEVNAME "userflash" 26#define DRIVER_NAME "sun_uflash"
27#define PFX DRIVER_NAME ": "
30 28
31#define UFLASH_WINDOW_SIZE 0x200000 29#define UFLASH_WINDOW_SIZE 0x200000
32#define UFLASH_BUSWIDTH 1 /* EBus is 8-bit */ 30#define UFLASH_BUSWIDTH 1 /* EBus is 8-bit */
33 31
34MODULE_AUTHOR("Eric Brower <ebrower@usa.net>"); 32MODULE_AUTHOR("Eric Brower <ebrower@usa.net>");
35MODULE_DESCRIPTION("User-programmable flash device on Sun Microsystems boardsets"); 33MODULE_DESCRIPTION("User-programmable flash device on Sun Microsystems boardsets");
36MODULE_SUPPORTED_DEVICE("userflash"); 34MODULE_SUPPORTED_DEVICE(DRIVER_NAME);
37MODULE_LICENSE("GPL"); 35MODULE_LICENSE("GPL");
38MODULE_VERSION("2.0"); 36MODULE_VERSION("2.1");
39 37
40static LIST_HEAD(device_list);
41struct uflash_dev { 38struct uflash_dev {
42 const char *name; /* device name */ 39 const char *name; /* device name */
43 struct map_info map; /* mtd map info */ 40 struct map_info map; /* mtd map info */
44 struct mtd_info *mtd; /* mtd info */ 41 struct mtd_info *mtd; /* mtd info */
45}; 42};
46 43
47
48struct map_info uflash_map_templ = { 44struct map_info uflash_map_templ = {
49 .name = "SUNW,???-????", 45 .name = "SUNW,???-????",
50 .size = UFLASH_WINDOW_SIZE, 46 .size = UFLASH_WINDOW_SIZE,
51 .bankwidth = UFLASH_BUSWIDTH, 47 .bankwidth = UFLASH_BUSWIDTH,
52}; 48};
53 49
54int uflash_devinit(struct linux_ebus_device *edev, struct device_node *dp) 50int uflash_devinit(struct of_device *op, struct device_node *dp)
55{ 51{
56 struct uflash_dev *up; 52 struct uflash_dev *up;
57 struct resource *res;
58 53
59 res = &edev->resource[0]; 54 if (op->resource[1].flags) {
60
61 if (edev->num_addrs != 1) {
62 /* Non-CFI userflash device-- once I find one we 55 /* Non-CFI userflash device-- once I find one we
63 * can work on supporting it. 56 * can work on supporting it.
64 */ 57 */
65 printk("%s: unsupported device at 0x%llx (%d regs): " \ 58 printk(KERN_ERR PFX "Unsupported device at %s, 0x%llx\n",
66 "email ebrower@usa.net\n", 59 dp->full_name, (unsigned long long)op->resource[0].start);
67 dp->full_name, (unsigned long long)res->start,
68 edev->num_addrs);
69 60
70 return -ENODEV; 61 return -ENODEV;
71 } 62 }
72 63
73 up = kzalloc(sizeof(struct uflash_dev), GFP_KERNEL); 64 up = kzalloc(sizeof(struct uflash_dev), GFP_KERNEL);
74 if (!up) 65 if (!up) {
66 printk(KERN_ERR PFX "Cannot allocate struct uflash_dev\n");
75 return -ENOMEM; 67 return -ENOMEM;
68 }
76 69
77 /* copy defaults and tweak parameters */ 70 /* copy defaults and tweak parameters */
78 memcpy(&up->map, &uflash_map_templ, sizeof(uflash_map_templ)); 71 memcpy(&up->map, &uflash_map_templ, sizeof(uflash_map_templ));
79 up->map.size = (res->end - res->start) + 1UL; 72
73 up->map.size = resource_size(&op->resource[0]);
80 74
81 up->name = of_get_property(dp, "model", NULL); 75 up->name = of_get_property(dp, "model", NULL);
82 if (up->name && 0 < strlen(up->name)) 76 if (up->name && 0 < strlen(up->name))
83 up->map.name = (char *)up->name; 77 up->map.name = (char *)up->name;
84 78
85 up->map.phys = res->start; 79 up->map.phys = op->resource[0].start;
86 80
87 up->map.virt = ioremap_nocache(res->start, up->map.size); 81 up->map.virt = of_ioremap(&op->resource[0], 0, up->map.size,
82 DRIVER_NAME);
88 if (!up->map.virt) { 83 if (!up->map.virt) {
89 printk("%s: Failed to map device.\n", dp->full_name); 84 printk(KERN_ERR PFX "Failed to map device.\n");
90 kfree(up); 85 kfree(up);
91 86
92 return -EINVAL; 87 return -EINVAL;
@@ -97,7 +92,7 @@ int uflash_devinit(struct linux_ebus_device *edev, struct device_node *dp)
97 /* MTD registration */ 92 /* MTD registration */
98 up->mtd = do_map_probe("cfi_probe", &up->map); 93 up->mtd = do_map_probe("cfi_probe", &up->map);
99 if (!up->mtd) { 94 if (!up->mtd) {
100 iounmap(up->map.virt); 95 of_iounmap(&op->resource[0], up->map.virt, up->map.size);
101 kfree(up); 96 kfree(up);
102 97
103 return -ENXIO; 98 return -ENXIO;
@@ -107,32 +102,34 @@ int uflash_devinit(struct linux_ebus_device *edev, struct device_node *dp)
107 102
108 add_mtd_device(up->mtd); 103 add_mtd_device(up->mtd);
109 104
110 dev_set_drvdata(&edev->ofdev.dev, up); 105 dev_set_drvdata(&op->dev, up);
111 106
112 return 0; 107 return 0;
113} 108}
114 109
115static int __devinit uflash_probe(struct of_device *dev, const struct of_device_id *match) 110static int __devinit uflash_probe(struct of_device *op, const struct of_device_id *match)
116{ 111{
117 struct linux_ebus_device *edev = to_ebus_device(&dev->dev); 112 struct device_node *dp = op->node;
118 struct device_node *dp = dev->node;
119 113
120 if (of_find_property(dp, "user", NULL)) 114 /* Flashprom must have the "user" property in order to
115 * be used by this driver.
116 */
117 if (!of_find_property(dp, "user", NULL))
121 return -ENODEV; 118 return -ENODEV;
122 119
123 return uflash_devinit(edev, dp); 120 return uflash_devinit(op, dp);
124} 121}
125 122
126static int __devexit uflash_remove(struct of_device *dev) 123static int __devexit uflash_remove(struct of_device *op)
127{ 124{
128 struct uflash_dev *up = dev_get_drvdata(&dev->dev); 125 struct uflash_dev *up = dev_get_drvdata(&op->dev);
129 126
130 if (up->mtd) { 127 if (up->mtd) {
131 del_mtd_device(up->mtd); 128 del_mtd_device(up->mtd);
132 map_destroy(up->mtd); 129 map_destroy(up->mtd);
133 } 130 }
134 if (up->map.virt) { 131 if (up->map.virt) {
135 iounmap(up->map.virt); 132 of_iounmap(&op->resource[0], up->map.virt, up->map.size);
136 up->map.virt = NULL; 133 up->map.virt = NULL;
137 } 134 }
138 135
@@ -151,7 +148,7 @@ static struct of_device_id uflash_match[] = {
151MODULE_DEVICE_TABLE(of, uflash_match); 148MODULE_DEVICE_TABLE(of, uflash_match);
152 149
153static struct of_platform_driver uflash_driver = { 150static struct of_platform_driver uflash_driver = {
154 .name = UFLASH_DEVNAME, 151 .name = DRIVER_NAME,
155 .match_table = uflash_match, 152 .match_table = uflash_match,
156 .probe = uflash_probe, 153 .probe = uflash_probe,
157 .remove = __devexit_p(uflash_remove), 154 .remove = __devexit_p(uflash_remove),
@@ -159,7 +156,7 @@ static struct of_platform_driver uflash_driver = {
159 156
160static int __init uflash_init(void) 157static int __init uflash_init(void)
161{ 158{
162 return of_register_driver(&uflash_driver, &ebus_bus_type); 159 return of_register_driver(&uflash_driver, &of_bus_type);
163} 160}
164 161
165static void __exit uflash_exit(void) 162static void __exit uflash_exit(void)