Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | * drivers/mtd/maps/ixp4xx.c |
| 3 | * |
| 4 | * MTD Map file for IXP4XX based systems. Please do not make per-board |
| 5 | * changes in here. If your board needs special setup, do it in your |
| 6 | * platform level code in arch/arm/mach-ixp4xx/board-setup.c |
| 7 | * |
| 8 | * Original Author: Intel Corporation |
| 9 | * Maintainer: Deepak Saxena <dsaxena@mvista.com> |
| 10 | * |
| 11 | * Copyright (C) 2002 Intel Corporation |
| 12 | * Copyright (C) 2003-2004 MontaVista Software, Inc. |
| 13 | * |
| 14 | */ |
| 15 | |
| 16 | #include <linux/module.h> |
| 17 | #include <linux/types.h> |
| 18 | #include <linux/init.h> |
| 19 | #include <linux/kernel.h> |
| 20 | #include <linux/string.h> |
Tim Schmielau | 4e57b68 | 2005-10-30 15:03:48 -0800 | [diff] [blame] | 21 | #include <linux/slab.h> |
| 22 | #include <linux/ioport.h> |
| 23 | #include <linux/device.h> |
Linus Torvalds | 4fd5f82 | 2005-10-31 07:32:56 -0800 | [diff] [blame] | 24 | #include <linux/platform_device.h> |
Tim Schmielau | 4e57b68 | 2005-10-30 15:03:48 -0800 | [diff] [blame] | 25 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 26 | #include <linux/mtd/mtd.h> |
| 27 | #include <linux/mtd/map.h> |
| 28 | #include <linux/mtd/partitions.h> |
Tim Schmielau | 4e57b68 | 2005-10-30 15:03:48 -0800 | [diff] [blame] | 29 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 30 | #include <asm/io.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 31 | #include <asm/mach/flash.h> |
| 32 | |
| 33 | #include <linux/reboot.h> |
| 34 | |
John Bowler | 3c77354 | 2005-11-16 16:23:25 +0000 | [diff] [blame] | 35 | /* |
| 36 | * Read/write a 16 bit word from flash address 'addr'. |
| 37 | * |
| 38 | * When the cpu is in little-endian mode it swizzles the address lines |
| 39 | * ('address coherency') so we need to undo the swizzling to ensure commands |
| 40 | * and the like end up on the correct flash address. |
| 41 | * |
| 42 | * To further complicate matters, due to the way the expansion bus controller |
| 43 | * handles 32 bit reads, the byte stream ABCD is stored on the flash as: |
| 44 | * D15 D0 |
| 45 | * +---+---+ |
| 46 | * | A | B | 0 |
| 47 | * +---+---+ |
| 48 | * | C | D | 2 |
| 49 | * +---+---+ |
| 50 | * This means that on LE systems each 16 bit word must be swapped. Note that |
| 51 | * this requires CONFIG_MTD_CFI_BE_BYTE_SWAP to be enabled to 'unswap' the CFI |
| 52 | * data and other flash commands which are always in D7-D0. |
| 53 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 54 | #ifndef __ARMEB__ |
John Bowler | 3c77354 | 2005-11-16 16:23:25 +0000 | [diff] [blame] | 55 | #ifndef CONFIG_MTD_CFI_BE_BYTE_SWAP |
| 56 | # error CONFIG_MTD_CFI_BE_BYTE_SWAP required |
| 57 | #endif |
| 58 | |
| 59 | static inline u16 flash_read16(void __iomem *addr) |
| 60 | { |
| 61 | return be16_to_cpu(__raw_readw((void __iomem *)((unsigned long)addr ^ 0x2))); |
| 62 | } |
| 63 | |
| 64 | static inline void flash_write16(u16 d, void __iomem *addr) |
| 65 | { |
| 66 | __raw_writew(cpu_to_be16(d), (void __iomem *)((unsigned long)addr ^ 0x2)); |
| 67 | } |
| 68 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 69 | #define BYTE0(h) ((h) & 0xFF) |
| 70 | #define BYTE1(h) (((h) >> 8) & 0xFF) |
John Bowler | 3c77354 | 2005-11-16 16:23:25 +0000 | [diff] [blame] | 71 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 72 | #else |
John Bowler | 3c77354 | 2005-11-16 16:23:25 +0000 | [diff] [blame] | 73 | |
| 74 | static inline u16 flash_read16(const void __iomem *addr) |
| 75 | { |
| 76 | return __raw_readw(addr); |
| 77 | } |
| 78 | |
| 79 | static inline void flash_write16(u16 d, void __iomem *addr) |
| 80 | { |
| 81 | __raw_writew(d, addr); |
| 82 | } |
| 83 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 84 | #define BYTE0(h) (((h) >> 8) & 0xFF) |
| 85 | #define BYTE1(h) ((h) & 0xFF) |
| 86 | #endif |
| 87 | |
| 88 | static map_word ixp4xx_read16(struct map_info *map, unsigned long ofs) |
| 89 | { |
| 90 | map_word val; |
John Bowler | 3c77354 | 2005-11-16 16:23:25 +0000 | [diff] [blame] | 91 | val.x[0] = flash_read16(map->virt + ofs); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 92 | return val; |
| 93 | } |
| 94 | |
| 95 | /* |
| 96 | * The IXP4xx expansion bus only allows 16-bit wide acceses |
| 97 | * when attached to a 16-bit wide device (such as the 28F128J3A), |
| 98 | * so we can't just memcpy_fromio(). |
| 99 | */ |
| 100 | static void ixp4xx_copy_from(struct map_info *map, void *to, |
| 101 | unsigned long from, ssize_t len) |
| 102 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 103 | u8 *dest = (u8 *) to; |
David Vrabel | 9090ed0 | 2005-11-01 16:46:19 +0000 | [diff] [blame] | 104 | void __iomem *src = map->virt + from; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 105 | |
John Bowler | 3c77354 | 2005-11-16 16:23:25 +0000 | [diff] [blame] | 106 | if (len <= 0) |
| 107 | return; |
| 108 | |
| 109 | if (from & 1) { |
| 110 | *dest++ = BYTE1(flash_read16(src)); |
| 111 | src++; |
| 112 | --len; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 113 | } |
| 114 | |
John Bowler | 3c77354 | 2005-11-16 16:23:25 +0000 | [diff] [blame] | 115 | while (len >= 2) { |
| 116 | u16 data = flash_read16(src); |
| 117 | *dest++ = BYTE0(data); |
| 118 | *dest++ = BYTE1(data); |
| 119 | src += 2; |
| 120 | len -= 2; |
| 121 | } |
| 122 | |
| 123 | if (len > 0) |
| 124 | *dest++ = BYTE0(flash_read16(src)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 125 | } |
| 126 | |
Thomas Gleixner | 69f34c9 | 2005-11-07 11:15:40 +0000 | [diff] [blame] | 127 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 128 | * Unaligned writes are ignored, causing the 8-bit |
| 129 | * probe to fail and proceed to the 16-bit probe (which succeeds). |
| 130 | */ |
| 131 | static void ixp4xx_probe_write16(struct map_info *map, map_word d, unsigned long adr) |
| 132 | { |
| 133 | if (!(adr & 1)) |
John Bowler | 3c77354 | 2005-11-16 16:23:25 +0000 | [diff] [blame] | 134 | flash_write16(d.x[0], map->virt + adr); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 135 | } |
| 136 | |
Thomas Gleixner | 69f34c9 | 2005-11-07 11:15:40 +0000 | [diff] [blame] | 137 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 138 | * Fast write16 function without the probing check above |
| 139 | */ |
| 140 | static void ixp4xx_write16(struct map_info *map, map_word d, unsigned long adr) |
| 141 | { |
John Bowler | 3c77354 | 2005-11-16 16:23:25 +0000 | [diff] [blame] | 142 | flash_write16(d.x[0], map->virt + adr); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 143 | } |
| 144 | |
| 145 | struct ixp4xx_flash_info { |
| 146 | struct mtd_info *mtd; |
| 147 | struct map_info map; |
| 148 | struct mtd_partition *partitions; |
| 149 | struct resource *res; |
| 150 | }; |
| 151 | |
| 152 | static const char *probes[] = { "RedBoot", "cmdlinepart", NULL }; |
| 153 | |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 154 | static int ixp4xx_flash_remove(struct platform_device *dev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 155 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 156 | struct flash_platform_data *plat = dev->dev.platform_data; |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 157 | struct ixp4xx_flash_info *info = platform_get_drvdata(dev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 158 | |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 159 | platform_set_drvdata(dev, NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 160 | |
| 161 | if(!info) |
| 162 | return 0; |
| 163 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 164 | if (info->mtd) { |
| 165 | del_mtd_partitions(info->mtd); |
| 166 | map_destroy(info->mtd); |
| 167 | } |
David Vrabel | 9090ed0 | 2005-11-01 16:46:19 +0000 | [diff] [blame] | 168 | if (info->map.virt) |
| 169 | iounmap(info->map.virt); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 170 | |
Jesper Juhl | fa67164 | 2005-11-07 01:01:27 -0800 | [diff] [blame] | 171 | kfree(info->partitions); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 172 | |
| 173 | if (info->res) { |
| 174 | release_resource(info->res); |
| 175 | kfree(info->res); |
| 176 | } |
| 177 | |
| 178 | if (plat->exit) |
| 179 | plat->exit(); |
| 180 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 181 | return 0; |
| 182 | } |
| 183 | |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 184 | static int ixp4xx_flash_probe(struct platform_device *dev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 185 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 186 | struct flash_platform_data *plat = dev->dev.platform_data; |
| 187 | struct ixp4xx_flash_info *info; |
| 188 | int err = -1; |
| 189 | |
| 190 | if (!plat) |
| 191 | return -ENODEV; |
| 192 | |
| 193 | if (plat->init) { |
| 194 | err = plat->init(); |
| 195 | if (err) |
| 196 | return err; |
| 197 | } |
| 198 | |
| 199 | info = kmalloc(sizeof(struct ixp4xx_flash_info), GFP_KERNEL); |
| 200 | if(!info) { |
| 201 | err = -ENOMEM; |
| 202 | goto Error; |
Thomas Gleixner | 69f34c9 | 2005-11-07 11:15:40 +0000 | [diff] [blame] | 203 | } |
Russell King | 59f0cb0 | 2008-10-27 11:24:09 +0000 | [diff] [blame] | 204 | memset(info, 0, sizeof(struct ixp4xx_flash_info)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 205 | |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 206 | platform_set_drvdata(dev, info); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 207 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 208 | /* |
| 209 | * Tell the MTD layer we're not 1:1 mapped so that it does |
| 210 | * not attempt to do a direct access on us. |
| 211 | */ |
| 212 | info->map.phys = NO_XIP; |
| 213 | info->map.size = dev->resource->end - dev->resource->start + 1; |
| 214 | |
| 215 | /* |
| 216 | * We only support 16-bit accesses for now. If and when |
| 217 | * any board use 8-bit access, we'll fixup the driver to |
| 218 | * handle that. |
| 219 | */ |
| 220 | info->map.bankwidth = 2; |
Kay Sievers | 475b44c | 2009-01-06 10:44:38 -0800 | [diff] [blame] | 221 | info->map.name = dev_name(&dev->dev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 222 | info->map.read = ixp4xx_read16, |
| 223 | info->map.write = ixp4xx_probe_write16, |
| 224 | info->map.copy_from = ixp4xx_copy_from, |
| 225 | |
Thomas Gleixner | 69f34c9 | 2005-11-07 11:15:40 +0000 | [diff] [blame] | 226 | info->res = request_mem_region(dev->resource->start, |
| 227 | dev->resource->end - dev->resource->start + 1, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 228 | "IXP4XXFlash"); |
| 229 | if (!info->res) { |
| 230 | printk(KERN_ERR "IXP4XXFlash: Could not reserve memory region\n"); |
| 231 | err = -ENOMEM; |
| 232 | goto Error; |
| 233 | } |
| 234 | |
David Vrabel | 9090ed0 | 2005-11-01 16:46:19 +0000 | [diff] [blame] | 235 | info->map.virt = ioremap(dev->resource->start, |
| 236 | dev->resource->end - dev->resource->start + 1); |
| 237 | if (!info->map.virt) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 238 | printk(KERN_ERR "IXP4XXFlash: Failed to ioremap region\n"); |
| 239 | err = -EIO; |
| 240 | goto Error; |
| 241 | } |
| 242 | |
| 243 | info->mtd = do_map_probe(plat->map_name, &info->map); |
| 244 | if (!info->mtd) { |
| 245 | printk(KERN_ERR "IXP4XXFlash: map_probe failed\n"); |
| 246 | err = -ENXIO; |
| 247 | goto Error; |
| 248 | } |
| 249 | info->mtd->owner = THIS_MODULE; |
Thomas Gleixner | 69f34c9 | 2005-11-07 11:15:40 +0000 | [diff] [blame] | 250 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 251 | /* Use the fast version */ |
| 252 | info->map.write = ixp4xx_write16, |
| 253 | |
Brian Walsh | f40a6f1 | 2006-09-22 10:16:16 +0100 | [diff] [blame] | 254 | err = parse_mtd_partitions(info->mtd, probes, &info->partitions, dev->resource->start); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 255 | if (err > 0) { |
| 256 | err = add_mtd_partitions(info->mtd, info->partitions, err); |
| 257 | if(err) |
| 258 | printk(KERN_ERR "Could not parse partitions\n"); |
| 259 | } |
| 260 | |
| 261 | if (err) |
| 262 | goto Error; |
| 263 | |
| 264 | return 0; |
| 265 | |
| 266 | Error: |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 267 | ixp4xx_flash_remove(dev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 268 | return err; |
| 269 | } |
| 270 | |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 271 | static struct platform_driver ixp4xx_flash_driver = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 272 | .probe = ixp4xx_flash_probe, |
| 273 | .remove = ixp4xx_flash_remove, |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 274 | .driver = { |
| 275 | .name = "IXP4XX-Flash", |
Kay Sievers | 41d867c | 2008-04-18 13:44:26 -0700 | [diff] [blame] | 276 | .owner = THIS_MODULE, |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 277 | }, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 278 | }; |
| 279 | |
| 280 | static int __init ixp4xx_flash_init(void) |
| 281 | { |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 282 | return platform_driver_register(&ixp4xx_flash_driver); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 283 | } |
| 284 | |
| 285 | static void __exit ixp4xx_flash_exit(void) |
| 286 | { |
Russell King | 3ae5eae | 2005-11-09 22:32:44 +0000 | [diff] [blame] | 287 | platform_driver_unregister(&ixp4xx_flash_driver); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 288 | } |
| 289 | |
| 290 | |
| 291 | module_init(ixp4xx_flash_init); |
| 292 | module_exit(ixp4xx_flash_exit); |
| 293 | |
| 294 | MODULE_LICENSE("GPL"); |
Deepak Saxena | 82810a9 | 2005-09-28 16:42:54 -0700 | [diff] [blame] | 295 | MODULE_DESCRIPTION("MTD map driver for Intel IXP4xx systems"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 296 | MODULE_AUTHOR("Deepak Saxena"); |
Kay Sievers | 41d867c | 2008-04-18 13:44:26 -0700 | [diff] [blame] | 297 | MODULE_ALIAS("platform:IXP4XX-Flash"); |