]>
Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /* |
69f34c98 | 2 | * $Id: ixp4xx.c,v 1.12 2005/11/07 11:14:27 gleixner Exp $ |
1da177e4 LT |
3 | * |
4 | * drivers/mtd/maps/ixp4xx.c | |
5 | * | |
6 | * MTD Map file for IXP4XX based systems. Please do not make per-board | |
7 | * changes in here. If your board needs special setup, do it in your | |
8 | * platform level code in arch/arm/mach-ixp4xx/board-setup.c | |
9 | * | |
10 | * Original Author: Intel Corporation | |
11 | * Maintainer: Deepak Saxena <dsaxena@mvista.com> | |
12 | * | |
13 | * Copyright (C) 2002 Intel Corporation | |
14 | * Copyright (C) 2003-2004 MontaVista Software, Inc. | |
15 | * | |
16 | */ | |
17 | ||
18 | #include <linux/module.h> | |
19 | #include <linux/types.h> | |
20 | #include <linux/init.h> | |
21 | #include <linux/kernel.h> | |
22 | #include <linux/string.h> | |
4e57b681 TS |
23 | #include <linux/slab.h> |
24 | #include <linux/ioport.h> | |
25 | #include <linux/device.h> | |
4fd5f826 | 26 | #include <linux/platform_device.h> |
4e57b681 | 27 | |
1da177e4 LT |
28 | #include <linux/mtd/mtd.h> |
29 | #include <linux/mtd/map.h> | |
30 | #include <linux/mtd/partitions.h> | |
4e57b681 | 31 | |
1da177e4 | 32 | #include <asm/io.h> |
1da177e4 LT |
33 | #include <asm/mach/flash.h> |
34 | ||
35 | #include <linux/reboot.h> | |
36 | ||
37 | #ifndef __ARMEB__ | |
38 | #define BYTE0(h) ((h) & 0xFF) | |
39 | #define BYTE1(h) (((h) >> 8) & 0xFF) | |
40 | #else | |
41 | #define BYTE0(h) (((h) >> 8) & 0xFF) | |
42 | #define BYTE1(h) ((h) & 0xFF) | |
43 | #endif | |
44 | ||
45 | static map_word ixp4xx_read16(struct map_info *map, unsigned long ofs) | |
46 | { | |
47 | map_word val; | |
9090ed0b | 48 | val.x[0] = le16_to_cpu(readw(map->virt + ofs)); |
1da177e4 LT |
49 | return val; |
50 | } | |
51 | ||
52 | /* | |
53 | * The IXP4xx expansion bus only allows 16-bit wide acceses | |
54 | * when attached to a 16-bit wide device (such as the 28F128J3A), | |
55 | * so we can't just memcpy_fromio(). | |
56 | */ | |
57 | static void ixp4xx_copy_from(struct map_info *map, void *to, | |
58 | unsigned long from, ssize_t len) | |
59 | { | |
60 | int i; | |
61 | u8 *dest = (u8 *) to; | |
9090ed0b | 62 | void __iomem *src = map->virt + from; |
1da177e4 LT |
63 | u16 data; |
64 | ||
65 | for (i = 0; i < (len / 2); i++) { | |
9090ed0b | 66 | data = le16_to_cpu(readw(src + 2*i)); |
1da177e4 LT |
67 | dest[i * 2] = BYTE0(data); |
68 | dest[i * 2 + 1] = BYTE1(data); | |
69 | } | |
70 | ||
71 | if (len & 1) | |
9090ed0b | 72 | dest[len - 1] = BYTE0(le16_to_cpu(readw(src + 2*i))); |
1da177e4 LT |
73 | } |
74 | ||
69f34c98 | 75 | /* |
1da177e4 LT |
76 | * Unaligned writes are ignored, causing the 8-bit |
77 | * probe to fail and proceed to the 16-bit probe (which succeeds). | |
78 | */ | |
79 | static void ixp4xx_probe_write16(struct map_info *map, map_word d, unsigned long adr) | |
80 | { | |
81 | if (!(adr & 1)) | |
9090ed0b | 82 | writew(cpu_to_le16(d.x[0]), map->virt + adr); |
1da177e4 LT |
83 | } |
84 | ||
69f34c98 | 85 | /* |
1da177e4 LT |
86 | * Fast write16 function without the probing check above |
87 | */ | |
88 | static void ixp4xx_write16(struct map_info *map, map_word d, unsigned long adr) | |
89 | { | |
9090ed0b | 90 | writew(cpu_to_le16(d.x[0]), map->virt + adr); |
1da177e4 LT |
91 | } |
92 | ||
93 | struct ixp4xx_flash_info { | |
94 | struct mtd_info *mtd; | |
95 | struct map_info map; | |
96 | struct mtd_partition *partitions; | |
97 | struct resource *res; | |
98 | }; | |
99 | ||
100 | static const char *probes[] = { "RedBoot", "cmdlinepart", NULL }; | |
101 | ||
3ae5eaec | 102 | static int ixp4xx_flash_remove(struct platform_device *dev) |
1da177e4 | 103 | { |
1da177e4 | 104 | struct flash_platform_data *plat = dev->dev.platform_data; |
3ae5eaec | 105 | struct ixp4xx_flash_info *info = platform_get_drvdata(dev); |
1da177e4 | 106 | |
3ae5eaec | 107 | platform_set_drvdata(dev, NULL); |
1da177e4 LT |
108 | |
109 | if(!info) | |
110 | return 0; | |
111 | ||
1da177e4 LT |
112 | if (info->mtd) { |
113 | del_mtd_partitions(info->mtd); | |
114 | map_destroy(info->mtd); | |
115 | } | |
9090ed0b DV |
116 | if (info->map.virt) |
117 | iounmap(info->map.virt); | |
1da177e4 | 118 | |
fa671646 | 119 | kfree(info->partitions); |
1da177e4 LT |
120 | |
121 | if (info->res) { | |
122 | release_resource(info->res); | |
123 | kfree(info->res); | |
124 | } | |
125 | ||
126 | if (plat->exit) | |
127 | plat->exit(); | |
128 | ||
1da177e4 LT |
129 | return 0; |
130 | } | |
131 | ||
3ae5eaec | 132 | static int ixp4xx_flash_probe(struct platform_device *dev) |
1da177e4 | 133 | { |
1da177e4 LT |
134 | struct flash_platform_data *plat = dev->dev.platform_data; |
135 | struct ixp4xx_flash_info *info; | |
136 | int err = -1; | |
137 | ||
138 | if (!plat) | |
139 | return -ENODEV; | |
140 | ||
141 | if (plat->init) { | |
142 | err = plat->init(); | |
143 | if (err) | |
144 | return err; | |
145 | } | |
146 | ||
147 | info = kmalloc(sizeof(struct ixp4xx_flash_info), GFP_KERNEL); | |
148 | if(!info) { | |
149 | err = -ENOMEM; | |
150 | goto Error; | |
69f34c98 | 151 | } |
1da177e4 LT |
152 | memzero(info, sizeof(struct ixp4xx_flash_info)); |
153 | ||
3ae5eaec | 154 | platform_set_drvdata(dev, info); |
1da177e4 | 155 | |
1da177e4 LT |
156 | /* |
157 | * Tell the MTD layer we're not 1:1 mapped so that it does | |
158 | * not attempt to do a direct access on us. | |
159 | */ | |
160 | info->map.phys = NO_XIP; | |
161 | info->map.size = dev->resource->end - dev->resource->start + 1; | |
162 | ||
163 | /* | |
164 | * We only support 16-bit accesses for now. If and when | |
165 | * any board use 8-bit access, we'll fixup the driver to | |
166 | * handle that. | |
167 | */ | |
168 | info->map.bankwidth = 2; | |
169 | info->map.name = dev->dev.bus_id; | |
170 | info->map.read = ixp4xx_read16, | |
171 | info->map.write = ixp4xx_probe_write16, | |
172 | info->map.copy_from = ixp4xx_copy_from, | |
173 | ||
69f34c98 TG |
174 | info->res = request_mem_region(dev->resource->start, |
175 | dev->resource->end - dev->resource->start + 1, | |
1da177e4 LT |
176 | "IXP4XXFlash"); |
177 | if (!info->res) { | |
178 | printk(KERN_ERR "IXP4XXFlash: Could not reserve memory region\n"); | |
179 | err = -ENOMEM; | |
180 | goto Error; | |
181 | } | |
182 | ||
9090ed0b DV |
183 | info->map.virt = ioremap(dev->resource->start, |
184 | dev->resource->end - dev->resource->start + 1); | |
185 | if (!info->map.virt) { | |
1da177e4 LT |
186 | printk(KERN_ERR "IXP4XXFlash: Failed to ioremap region\n"); |
187 | err = -EIO; | |
188 | goto Error; | |
189 | } | |
190 | ||
191 | info->mtd = do_map_probe(plat->map_name, &info->map); | |
192 | if (!info->mtd) { | |
193 | printk(KERN_ERR "IXP4XXFlash: map_probe failed\n"); | |
194 | err = -ENXIO; | |
195 | goto Error; | |
196 | } | |
197 | info->mtd->owner = THIS_MODULE; | |
69f34c98 | 198 | |
1da177e4 LT |
199 | /* Use the fast version */ |
200 | info->map.write = ixp4xx_write16, | |
201 | ||
202 | err = parse_mtd_partitions(info->mtd, probes, &info->partitions, 0); | |
203 | if (err > 0) { | |
204 | err = add_mtd_partitions(info->mtd, info->partitions, err); | |
205 | if(err) | |
206 | printk(KERN_ERR "Could not parse partitions\n"); | |
207 | } | |
208 | ||
209 | if (err) | |
210 | goto Error; | |
211 | ||
212 | return 0; | |
213 | ||
214 | Error: | |
3ae5eaec | 215 | ixp4xx_flash_remove(dev); |
1da177e4 LT |
216 | return err; |
217 | } | |
218 | ||
3ae5eaec | 219 | static struct platform_driver ixp4xx_flash_driver = { |
1da177e4 LT |
220 | .probe = ixp4xx_flash_probe, |
221 | .remove = ixp4xx_flash_remove, | |
3ae5eaec RK |
222 | .driver = { |
223 | .name = "IXP4XX-Flash", | |
224 | }, | |
1da177e4 LT |
225 | }; |
226 | ||
227 | static int __init ixp4xx_flash_init(void) | |
228 | { | |
3ae5eaec | 229 | return platform_driver_register(&ixp4xx_flash_driver); |
1da177e4 LT |
230 | } |
231 | ||
232 | static void __exit ixp4xx_flash_exit(void) | |
233 | { | |
3ae5eaec | 234 | platform_driver_unregister(&ixp4xx_flash_driver); |
1da177e4 LT |
235 | } |
236 | ||
237 | ||
238 | module_init(ixp4xx_flash_init); | |
239 | module_exit(ixp4xx_flash_exit); | |
240 | ||
241 | MODULE_LICENSE("GPL"); | |
82810a90 | 242 | MODULE_DESCRIPTION("MTD map driver for Intel IXP4xx systems"); |
1da177e4 | 243 | MODULE_AUTHOR("Deepak Saxena"); |