Ben Dooks | 99f2a8a | 2005-01-24 00:37:04 +0000 | [diff] [blame] | 1 | /* drivers/mtd/maps/plat-ram.c |
| 2 | * |
| 3 | * (c) 2004-2005 Simtec Electronics |
| 4 | * http://www.simtec.co.uk/products/SWLINUX/ |
| 5 | * Ben Dooks <ben@simtec.co.uk> |
| 6 | * |
| 7 | * Generic platfrom device based RAM map |
| 8 | * |
Thomas Gleixner | 69f34c9 | 2005-11-07 11:15:40 +0000 | [diff] [blame] | 9 | * $Id: plat-ram.c,v 1.7 2005/11/07 11:14:28 gleixner Exp $ |
Ben Dooks | 99f2a8a | 2005-01-24 00:37:04 +0000 | [diff] [blame] | 10 | * |
| 11 | * This program is free software; you can redistribute it and/or modify |
| 12 | * it under the terms of the GNU General Public License as published by |
| 13 | * the Free Software Foundation; either version 2 of the License, or |
| 14 | * (at your option) any later version. |
| 15 | * |
| 16 | * This program is distributed in the hope that it will be useful, |
| 17 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 19 | * GNU General Public License for more details. |
| 20 | * |
| 21 | * You should have received a copy of the GNU General Public License |
| 22 | * along with this program; if not, write to the Free Software |
| 23 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| 24 | */ |
| 25 | |
Ben Dooks | 99f2a8a | 2005-01-24 00:37:04 +0000 | [diff] [blame] | 26 | #include <linux/module.h> |
| 27 | #include <linux/types.h> |
| 28 | #include <linux/init.h> |
| 29 | #include <linux/kernel.h> |
| 30 | #include <linux/string.h> |
| 31 | #include <linux/ioport.h> |
| 32 | #include <linux/device.h> |
Tim Schmielau | 4e57b68 | 2005-10-30 15:03:48 -0800 | [diff] [blame] | 33 | #include <linux/slab.h> |
Russell King | d052d1b | 2005-10-29 19:07:23 +0100 | [diff] [blame] | 34 | #include <linux/platform_device.h> |
Ben Dooks | 99f2a8a | 2005-01-24 00:37:04 +0000 | [diff] [blame] | 35 | |
| 36 | #include <linux/mtd/mtd.h> |
| 37 | #include <linux/mtd/map.h> |
| 38 | #include <linux/mtd/partitions.h> |
| 39 | #include <linux/mtd/plat-ram.h> |
| 40 | |
| 41 | #include <asm/io.h> |
| 42 | |
| 43 | /* private structure for each mtd platform ram device created */ |
| 44 | |
| 45 | struct platram_info { |
| 46 | struct device *dev; |
| 47 | struct mtd_info *mtd; |
| 48 | struct map_info map; |
| 49 | struct mtd_partition *partitions; |
| 50 | struct resource *area; |
| 51 | struct platdata_mtd_ram *pdata; |
| 52 | }; |
| 53 | |
| 54 | /* to_platram_info() |
| 55 | * |
| 56 | * device private data to struct platram_info conversion |
| 57 | */ |
| 58 | |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 59 | static inline struct platram_info *to_platram_info(struct platform_device *dev) |
Ben Dooks | 99f2a8a | 2005-01-24 00:37:04 +0000 | [diff] [blame] | 60 | { |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 61 | return (struct platram_info *)platform_get_drvdata(dev); |
Ben Dooks | 99f2a8a | 2005-01-24 00:37:04 +0000 | [diff] [blame] | 62 | } |
| 63 | |
| 64 | /* platram_setrw |
| 65 | * |
| 66 | * call the platform device's set rw/ro control |
| 67 | * |
| 68 | * to = 0 => read-only |
| 69 | * = 1 => read-write |
| 70 | */ |
| 71 | |
| 72 | static inline void platram_setrw(struct platram_info *info, int to) |
| 73 | { |
| 74 | if (info->pdata == NULL) |
| 75 | return; |
| 76 | |
| 77 | if (info->pdata->set_rw != NULL) |
| 78 | (info->pdata->set_rw)(info->dev, to); |
| 79 | } |
| 80 | |
| 81 | /* platram_remove |
| 82 | * |
| 83 | * called to remove the device from the driver's control |
| 84 | */ |
| 85 | |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 86 | static int platram_remove(struct platform_device *pdev) |
Ben Dooks | 99f2a8a | 2005-01-24 00:37:04 +0000 | [diff] [blame] | 87 | { |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 88 | struct platram_info *info = to_platram_info(pdev); |
Ben Dooks | 99f2a8a | 2005-01-24 00:37:04 +0000 | [diff] [blame] | 89 | |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 90 | platform_set_drvdata(pdev, NULL); |
Ben Dooks | 99f2a8a | 2005-01-24 00:37:04 +0000 | [diff] [blame] | 91 | |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 92 | dev_dbg(&pdev->dev, "removing device\n"); |
Ben Dooks | 99f2a8a | 2005-01-24 00:37:04 +0000 | [diff] [blame] | 93 | |
Thomas Gleixner | 69f34c9 | 2005-11-07 11:15:40 +0000 | [diff] [blame] | 94 | if (info == NULL) |
Ben Dooks | 99f2a8a | 2005-01-24 00:37:04 +0000 | [diff] [blame] | 95 | return 0; |
| 96 | |
| 97 | if (info->mtd) { |
| 98 | #ifdef CONFIG_MTD_PARTITIONS |
| 99 | if (info->partitions) { |
| 100 | del_mtd_partitions(info->mtd); |
| 101 | kfree(info->partitions); |
| 102 | } |
| 103 | #endif |
| 104 | del_mtd_device(info->mtd); |
| 105 | map_destroy(info->mtd); |
| 106 | } |
| 107 | |
| 108 | /* ensure ram is left read-only */ |
| 109 | |
| 110 | platram_setrw(info, PLATRAM_RO); |
| 111 | |
| 112 | /* release resources */ |
| 113 | |
| 114 | if (info->area) { |
| 115 | release_resource(info->area); |
| 116 | kfree(info->area); |
| 117 | } |
| 118 | |
| 119 | if (info->map.virt != NULL) |
| 120 | iounmap(info->map.virt); |
Thomas Gleixner | 69f34c9 | 2005-11-07 11:15:40 +0000 | [diff] [blame] | 121 | |
Ben Dooks | 99f2a8a | 2005-01-24 00:37:04 +0000 | [diff] [blame] | 122 | kfree(info); |
| 123 | |
| 124 | return 0; |
| 125 | } |
| 126 | |
| 127 | /* platram_probe |
| 128 | * |
| 129 | * called from device drive system when a device matching our |
| 130 | * driver is found. |
| 131 | */ |
| 132 | |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 133 | static int platram_probe(struct platform_device *pdev) |
Ben Dooks | 99f2a8a | 2005-01-24 00:37:04 +0000 | [diff] [blame] | 134 | { |
Ben Dooks | 99f2a8a | 2005-01-24 00:37:04 +0000 | [diff] [blame] | 135 | struct platdata_mtd_ram *pdata; |
| 136 | struct platram_info *info; |
| 137 | struct resource *res; |
| 138 | int err = 0; |
| 139 | |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 140 | dev_dbg(&pdev->dev, "probe entered\n"); |
Thomas Gleixner | 69f34c9 | 2005-11-07 11:15:40 +0000 | [diff] [blame] | 141 | |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 142 | if (pdev->dev.platform_data == NULL) { |
| 143 | dev_err(&pdev->dev, "no platform data supplied\n"); |
Ben Dooks | 99f2a8a | 2005-01-24 00:37:04 +0000 | [diff] [blame] | 144 | err = -ENOENT; |
| 145 | goto exit_error; |
| 146 | } |
| 147 | |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 148 | pdata = pdev->dev.platform_data; |
Ben Dooks | 99f2a8a | 2005-01-24 00:37:04 +0000 | [diff] [blame] | 149 | |
| 150 | info = kmalloc(sizeof(*info), GFP_KERNEL); |
| 151 | if (info == NULL) { |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 152 | dev_err(&pdev->dev, "no memory for flash info\n"); |
Ben Dooks | 99f2a8a | 2005-01-24 00:37:04 +0000 | [diff] [blame] | 153 | err = -ENOMEM; |
| 154 | goto exit_error; |
| 155 | } |
| 156 | |
Thomas Gleixner | a921e28 | 2005-03-19 22:41:30 +0000 | [diff] [blame] | 157 | memset(info, 0, sizeof(*info)); |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 158 | platform_set_drvdata(pdev, info); |
Ben Dooks | 99f2a8a | 2005-01-24 00:37:04 +0000 | [diff] [blame] | 159 | |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 160 | info->dev = &pdev->dev; |
Ben Dooks | 99f2a8a | 2005-01-24 00:37:04 +0000 | [diff] [blame] | 161 | info->pdata = pdata; |
| 162 | |
| 163 | /* get the resource for the memory mapping */ |
| 164 | |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 165 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
Ben Dooks | 99f2a8a | 2005-01-24 00:37:04 +0000 | [diff] [blame] | 166 | |
| 167 | if (res == NULL) { |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 168 | dev_err(&pdev->dev, "no memory resource specified\n"); |
Ben Dooks | 99f2a8a | 2005-01-24 00:37:04 +0000 | [diff] [blame] | 169 | err = -ENOENT; |
| 170 | goto exit_free; |
| 171 | } |
| 172 | |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 173 | dev_dbg(&pdev->dev, "got platform resource %p (0x%lx)\n", res, res->start); |
Ben Dooks | 99f2a8a | 2005-01-24 00:37:04 +0000 | [diff] [blame] | 174 | |
| 175 | /* setup map parameters */ |
| 176 | |
| 177 | info->map.phys = res->start; |
| 178 | info->map.size = (res->end - res->start) + 1; |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 179 | info->map.name = pdata->mapname != NULL ? pdata->mapname : (char *)pdev->name; |
Ben Dooks | 99f2a8a | 2005-01-24 00:37:04 +0000 | [diff] [blame] | 180 | info->map.bankwidth = pdata->bankwidth; |
| 181 | |
| 182 | /* register our usage of the memory area */ |
| 183 | |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 184 | info->area = request_mem_region(res->start, info->map.size, pdev->name); |
Ben Dooks | 99f2a8a | 2005-01-24 00:37:04 +0000 | [diff] [blame] | 185 | if (info->area == NULL) { |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 186 | dev_err(&pdev->dev, "failed to request memory region\n"); |
Ben Dooks | 99f2a8a | 2005-01-24 00:37:04 +0000 | [diff] [blame] | 187 | err = -EIO; |
| 188 | goto exit_free; |
| 189 | } |
| 190 | |
| 191 | /* remap the memory area */ |
| 192 | |
| 193 | info->map.virt = ioremap(res->start, info->map.size); |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 194 | dev_dbg(&pdev->dev, "virt %p, %lu bytes\n", info->map.virt, info->map.size); |
Ben Dooks | 99f2a8a | 2005-01-24 00:37:04 +0000 | [diff] [blame] | 195 | |
| 196 | if (info->map.virt == NULL) { |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 197 | dev_err(&pdev->dev, "failed to ioremap() region\n"); |
Ben Dooks | 99f2a8a | 2005-01-24 00:37:04 +0000 | [diff] [blame] | 198 | err = -EIO; |
| 199 | goto exit_free; |
| 200 | } |
| 201 | |
Ben Dooks | 99f2a8a | 2005-01-24 00:37:04 +0000 | [diff] [blame] | 202 | simple_map_init(&info->map); |
| 203 | |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 204 | dev_dbg(&pdev->dev, "initialised map, probing for mtd\n"); |
Ben Dooks | 99f2a8a | 2005-01-24 00:37:04 +0000 | [diff] [blame] | 205 | |
| 206 | /* probe for the right mtd map driver */ |
| 207 | |
| 208 | info->mtd = do_map_probe("map_ram" , &info->map); |
| 209 | if (info->mtd == NULL) { |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 210 | dev_err(&pdev->dev, "failed to probe for map_ram\n"); |
Ben Dooks | 99f2a8a | 2005-01-24 00:37:04 +0000 | [diff] [blame] | 211 | err = -ENOMEM; |
| 212 | goto exit_free; |
| 213 | } |
| 214 | |
| 215 | info->mtd->owner = THIS_MODULE; |
| 216 | |
| 217 | platram_setrw(info, PLATRAM_RW); |
| 218 | |
| 219 | /* check to see if there are any available partitions, or wether |
| 220 | * to add this device whole */ |
| 221 | |
| 222 | #ifdef CONFIG_MTD_PARTITIONS |
| 223 | if (pdata->nr_partitions > 0) { |
| 224 | const char **probes = { NULL }; |
| 225 | |
| 226 | if (pdata->probes) |
| 227 | probes = (const char **)pdata->probes; |
| 228 | |
| 229 | err = parse_mtd_partitions(info->mtd, probes, |
| 230 | &info->partitions, 0); |
| 231 | if (err > 0) { |
| 232 | err = add_mtd_partitions(info->mtd, info->partitions, |
| 233 | err); |
| 234 | } |
| 235 | } |
| 236 | #endif /* CONFIG_MTD_PARTITIONS */ |
| 237 | |
| 238 | if (add_mtd_device(info->mtd)) { |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 239 | dev_err(&pdev->dev, "add_mtd_device() failed\n"); |
Ben Dooks | 99f2a8a | 2005-01-24 00:37:04 +0000 | [diff] [blame] | 240 | err = -ENOMEM; |
| 241 | } |
Thomas Gleixner | 69f34c9 | 2005-11-07 11:15:40 +0000 | [diff] [blame] | 242 | |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 243 | dev_info(&pdev->dev, "registered mtd device\n"); |
Ben Dooks | 99f2a8a | 2005-01-24 00:37:04 +0000 | [diff] [blame] | 244 | return err; |
| 245 | |
| 246 | exit_free: |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 247 | platram_remove(pdev); |
Ben Dooks | 99f2a8a | 2005-01-24 00:37:04 +0000 | [diff] [blame] | 248 | exit_error: |
| 249 | return err; |
| 250 | } |
| 251 | |
| 252 | /* device driver info */ |
| 253 | |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 254 | static struct platform_driver platram_driver = { |
Ben Dooks | 99f2a8a | 2005-01-24 00:37:04 +0000 | [diff] [blame] | 255 | .probe = platram_probe, |
| 256 | .remove = platram_remove, |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 257 | .driver = { |
| 258 | .name = "mtd-ram", |
| 259 | .owner = THIS_MODULE, |
| 260 | }, |
Ben Dooks | 99f2a8a | 2005-01-24 00:37:04 +0000 | [diff] [blame] | 261 | }; |
| 262 | |
| 263 | /* module init/exit */ |
| 264 | |
| 265 | static int __init platram_init(void) |
| 266 | { |
| 267 | printk("Generic platform RAM MTD, (c) 2004 Simtec Electronics\n"); |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 268 | return platform_driver_register(&platram_driver); |
Ben Dooks | 99f2a8a | 2005-01-24 00:37:04 +0000 | [diff] [blame] | 269 | } |
| 270 | |
| 271 | static void __exit platram_exit(void) |
| 272 | { |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 273 | platform_driver_unregister(&platram_driver); |
Ben Dooks | 99f2a8a | 2005-01-24 00:37:04 +0000 | [diff] [blame] | 274 | } |
| 275 | |
| 276 | module_init(platram_init); |
| 277 | module_exit(platram_exit); |
| 278 | |
| 279 | MODULE_LICENSE("GPL"); |
| 280 | MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>"); |
| 281 | MODULE_DESCRIPTION("MTD platform RAM map driver"); |