Commit | Line | Data |
---|---|---|
3c544739 JC |
1 | /* |
2 | * This program is free software; you can redistribute it and/or modify it | |
3 | * under the terms of the GNU General Public License version 2 as published | |
4 | * by the Free Software Foundation. | |
5 | * | |
6 | * Copyright (C) 2004 Liu Peng Infineon IFAP DC COM CPE | |
7 | * Copyright (C) 2010 John Crispin <blogic@openwrt.org> | |
8 | */ | |
9 | ||
10 | #include <linux/module.h> | |
11 | #include <linux/types.h> | |
12 | #include <linux/kernel.h> | |
13 | #include <linux/io.h> | |
14 | #include <linux/slab.h> | |
15 | #include <linux/init.h> | |
16 | #include <linux/mtd/mtd.h> | |
17 | #include <linux/mtd/map.h> | |
18 | #include <linux/mtd/partitions.h> | |
19 | #include <linux/mtd/cfi.h> | |
20 | #include <linux/platform_device.h> | |
21 | #include <linux/mtd/physmap.h> | |
22 | ||
23 | #include <lantiq_soc.h> | |
24 | #include <lantiq_platform.h> | |
25 | ||
26 | /* | |
27 | * The NOR flash is connected to the same external bus unit (EBU) as PCI. | |
28 | * To make PCI work we need to enable the endianness swapping for the address | |
29 | * written to the EBU. This endianness swapping works for PCI correctly but | |
30 | * fails for attached NOR devices. To workaround this we need to use a complex | |
31 | * map. The workaround involves swapping all addresses whilst probing the chip. | |
32 | * Once probing is complete we stop swapping the addresses but swizzle the | |
33 | * unlock addresses to ensure that access to the NOR device works correctly. | |
34 | */ | |
35 | ||
36 | enum { | |
37 | LTQ_NOR_PROBING, | |
38 | LTQ_NOR_NORMAL | |
39 | }; | |
40 | ||
41 | struct ltq_mtd { | |
42 | struct resource *res; | |
43 | struct mtd_info *mtd; | |
44 | struct map_info *map; | |
45 | }; | |
46 | ||
47 | static char ltq_map_name[] = "ltq_nor"; | |
bf011f2e | 48 | static const char *ltq_probe_types[] __devinitconst = { "cmdlinepart", NULL }; |
3c544739 JC |
49 | |
50 | static map_word | |
51 | ltq_read16(struct map_info *map, unsigned long adr) | |
52 | { | |
53 | unsigned long flags; | |
54 | map_word temp; | |
55 | ||
56 | if (map->map_priv_1 == LTQ_NOR_PROBING) | |
57 | adr ^= 2; | |
58 | spin_lock_irqsave(&ebu_lock, flags); | |
59 | temp.x[0] = *(u16 *)(map->virt + adr); | |
60 | spin_unlock_irqrestore(&ebu_lock, flags); | |
61 | return temp; | |
62 | } | |
63 | ||
64 | static void | |
65 | ltq_write16(struct map_info *map, map_word d, unsigned long adr) | |
66 | { | |
67 | unsigned long flags; | |
68 | ||
69 | if (map->map_priv_1 == LTQ_NOR_PROBING) | |
70 | adr ^= 2; | |
71 | spin_lock_irqsave(&ebu_lock, flags); | |
72 | *(u16 *)(map->virt + adr) = d.x[0]; | |
73 | spin_unlock_irqrestore(&ebu_lock, flags); | |
74 | } | |
75 | ||
76 | /* | |
77 | * The following 2 functions copy data between iomem and a cached memory | |
78 | * section. As memcpy() makes use of pre-fetching we cannot use it here. | |
79 | * The normal alternative of using memcpy_{to,from}io also makes use of | |
80 | * memcpy() on MIPS so it is not applicable either. We are therefore stuck | |
81 | * with having to use our own loop. | |
82 | */ | |
83 | static void | |
84 | ltq_copy_from(struct map_info *map, void *to, | |
85 | unsigned long from, ssize_t len) | |
86 | { | |
87 | unsigned char *f = (unsigned char *)map->virt + from; | |
88 | unsigned char *t = (unsigned char *)to; | |
89 | unsigned long flags; | |
90 | ||
91 | spin_lock_irqsave(&ebu_lock, flags); | |
92 | while (len--) | |
93 | *t++ = *f++; | |
94 | spin_unlock_irqrestore(&ebu_lock, flags); | |
95 | } | |
96 | ||
97 | static void | |
98 | ltq_copy_to(struct map_info *map, unsigned long to, | |
99 | const void *from, ssize_t len) | |
100 | { | |
101 | unsigned char *f = (unsigned char *)from; | |
102 | unsigned char *t = (unsigned char *)map->virt + to; | |
103 | unsigned long flags; | |
104 | ||
105 | spin_lock_irqsave(&ebu_lock, flags); | |
106 | while (len--) | |
107 | *t++ = *f++; | |
108 | spin_unlock_irqrestore(&ebu_lock, flags); | |
109 | } | |
110 | ||
3c544739 JC |
111 | static int __init |
112 | ltq_mtd_probe(struct platform_device *pdev) | |
113 | { | |
114 | struct physmap_flash_data *ltq_mtd_data = dev_get_platdata(&pdev->dev); | |
115 | struct ltq_mtd *ltq_mtd; | |
3c544739 | 116 | struct resource *res; |
3c544739 JC |
117 | struct cfi_private *cfi; |
118 | int err; | |
119 | ||
120 | ltq_mtd = kzalloc(sizeof(struct ltq_mtd), GFP_KERNEL); | |
121 | platform_set_drvdata(pdev, ltq_mtd); | |
122 | ||
123 | ltq_mtd->res = platform_get_resource(pdev, IORESOURCE_MEM, 0); | |
124 | if (!ltq_mtd->res) { | |
125 | dev_err(&pdev->dev, "failed to get memory resource"); | |
126 | err = -ENOENT; | |
127 | goto err_out; | |
128 | } | |
129 | ||
130 | res = devm_request_mem_region(&pdev->dev, ltq_mtd->res->start, | |
131 | resource_size(ltq_mtd->res), dev_name(&pdev->dev)); | |
132 | if (!ltq_mtd->res) { | |
133 | dev_err(&pdev->dev, "failed to request mem resource"); | |
134 | err = -EBUSY; | |
135 | goto err_out; | |
136 | } | |
137 | ||
138 | ltq_mtd->map = kzalloc(sizeof(struct map_info), GFP_KERNEL); | |
139 | ltq_mtd->map->phys = res->start; | |
140 | ltq_mtd->map->size = resource_size(res); | |
141 | ltq_mtd->map->virt = devm_ioremap_nocache(&pdev->dev, | |
142 | ltq_mtd->map->phys, ltq_mtd->map->size); | |
143 | if (!ltq_mtd->map->virt) { | |
144 | dev_err(&pdev->dev, "failed to ioremap!\n"); | |
145 | err = -ENOMEM; | |
146 | goto err_free; | |
147 | } | |
148 | ||
149 | ltq_mtd->map->name = ltq_map_name; | |
150 | ltq_mtd->map->bankwidth = 2; | |
151 | ltq_mtd->map->read = ltq_read16; | |
152 | ltq_mtd->map->write = ltq_write16; | |
153 | ltq_mtd->map->copy_from = ltq_copy_from; | |
154 | ltq_mtd->map->copy_to = ltq_copy_to; | |
155 | ||
156 | ltq_mtd->map->map_priv_1 = LTQ_NOR_PROBING; | |
157 | ltq_mtd->mtd = do_map_probe("cfi_probe", ltq_mtd->map); | |
158 | ltq_mtd->map->map_priv_1 = LTQ_NOR_NORMAL; | |
159 | ||
160 | if (!ltq_mtd->mtd) { | |
161 | dev_err(&pdev->dev, "probing failed\n"); | |
162 | err = -ENXIO; | |
af32b360 | 163 | goto err_free; |
3c544739 JC |
164 | } |
165 | ||
166 | ltq_mtd->mtd->owner = THIS_MODULE; | |
167 | ||
168 | cfi = ltq_mtd->map->fldrv_priv; | |
169 | cfi->addr_unlock1 ^= 1; | |
170 | cfi->addr_unlock2 ^= 1; | |
171 | ||
42d7fbe2 AB |
172 | err = mtd_device_parse_register(ltq_mtd->mtd, ltq_probe_types, NULL, |
173 | ltq_mtd_data->parts, | |
174 | ltq_mtd_data->nr_parts); | |
3c544739 JC |
175 | if (err) { |
176 | dev_err(&pdev->dev, "failed to add partitions\n"); | |
177 | goto err_destroy; | |
178 | } | |
179 | ||
180 | return 0; | |
181 | ||
182 | err_destroy: | |
183 | map_destroy(ltq_mtd->mtd); | |
3c544739 JC |
184 | err_free: |
185 | kfree(ltq_mtd->map); | |
186 | err_out: | |
187 | kfree(ltq_mtd); | |
188 | return err; | |
189 | } | |
190 | ||
191 | static int __devexit | |
192 | ltq_mtd_remove(struct platform_device *pdev) | |
193 | { | |
194 | struct ltq_mtd *ltq_mtd = platform_get_drvdata(pdev); | |
195 | ||
196 | if (ltq_mtd) { | |
197 | if (ltq_mtd->mtd) { | |
2e5db86d | 198 | mtd_device_unregister(ltq_mtd->mtd); |
3c544739 JC |
199 | map_destroy(ltq_mtd->mtd); |
200 | } | |
3c544739 JC |
201 | kfree(ltq_mtd->map); |
202 | kfree(ltq_mtd); | |
203 | } | |
204 | return 0; | |
205 | } | |
206 | ||
207 | static struct platform_driver ltq_mtd_driver = { | |
208 | .remove = __devexit_p(ltq_mtd_remove), | |
209 | .driver = { | |
210 | .name = "ltq_nor", | |
211 | .owner = THIS_MODULE, | |
212 | }, | |
213 | }; | |
214 | ||
215 | static int __init | |
216 | init_ltq_mtd(void) | |
217 | { | |
218 | int ret = platform_driver_probe(<q_mtd_driver, ltq_mtd_probe); | |
219 | ||
220 | if (ret) | |
221 | pr_err("ltq_nor: error registering platform driver"); | |
222 | return ret; | |
223 | } | |
224 | ||
225 | static void __exit | |
226 | exit_ltq_mtd(void) | |
227 | { | |
228 | platform_driver_unregister(<q_mtd_driver); | |
229 | } | |
230 | ||
231 | module_init(init_ltq_mtd); | |
232 | module_exit(exit_ltq_mtd); | |
233 | ||
234 | MODULE_LICENSE("GPL"); | |
235 | MODULE_AUTHOR("John Crispin <blogic@openwrt.org>"); | |
236 | MODULE_DESCRIPTION("Lantiq SoC NOR"); |