Merge branch 'core-iommu-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[linux-2.6.git] / drivers / mtd / maps / lantiq-flash.c
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";
48
49 static map_word
50 ltq_read16(struct map_info *map, unsigned long adr)
51 {
52         unsigned long flags;
53         map_word temp;
54
55         if (map->map_priv_1 == LTQ_NOR_PROBING)
56                 adr ^= 2;
57         spin_lock_irqsave(&ebu_lock, flags);
58         temp.x[0] = *(u16 *)(map->virt + adr);
59         spin_unlock_irqrestore(&ebu_lock, flags);
60         return temp;
61 }
62
63 static void
64 ltq_write16(struct map_info *map, map_word d, unsigned long adr)
65 {
66         unsigned long flags;
67
68         if (map->map_priv_1 == LTQ_NOR_PROBING)
69                 adr ^= 2;
70         spin_lock_irqsave(&ebu_lock, flags);
71         *(u16 *)(map->virt + adr) = d.x[0];
72         spin_unlock_irqrestore(&ebu_lock, flags);
73 }
74
75 /*
76  * The following 2 functions copy data between iomem and a cached memory
77  * section. As memcpy() makes use of pre-fetching we cannot use it here.
78  * The normal alternative of using memcpy_{to,from}io also makes use of
79  * memcpy() on MIPS so it is not applicable either. We are therefore stuck
80  * with having to use our own loop.
81  */
82 static void
83 ltq_copy_from(struct map_info *map, void *to,
84         unsigned long from, ssize_t len)
85 {
86         unsigned char *f = (unsigned char *)map->virt + from;
87         unsigned char *t = (unsigned char *)to;
88         unsigned long flags;
89
90         spin_lock_irqsave(&ebu_lock, flags);
91         while (len--)
92                 *t++ = *f++;
93         spin_unlock_irqrestore(&ebu_lock, flags);
94 }
95
96 static void
97 ltq_copy_to(struct map_info *map, unsigned long to,
98         const void *from, ssize_t len)
99 {
100         unsigned char *f = (unsigned char *)from;
101         unsigned char *t = (unsigned char *)map->virt + to;
102         unsigned long flags;
103
104         spin_lock_irqsave(&ebu_lock, flags);
105         while (len--)
106                 *t++ = *f++;
107         spin_unlock_irqrestore(&ebu_lock, flags);
108 }
109
110 static const char const *part_probe_types[] = { "cmdlinepart", NULL };
111
112 static int __init
113 ltq_mtd_probe(struct platform_device *pdev)
114 {
115         struct physmap_flash_data *ltq_mtd_data = dev_get_platdata(&pdev->dev);
116         struct ltq_mtd *ltq_mtd;
117         struct mtd_partition *parts;
118         struct resource *res;
119         int nr_parts = 0;
120         struct cfi_private *cfi;
121         int err;
122
123         ltq_mtd = kzalloc(sizeof(struct ltq_mtd), GFP_KERNEL);
124         platform_set_drvdata(pdev, ltq_mtd);
125
126         ltq_mtd->res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
127         if (!ltq_mtd->res) {
128                 dev_err(&pdev->dev, "failed to get memory resource");
129                 err = -ENOENT;
130                 goto err_out;
131         }
132
133         res = devm_request_mem_region(&pdev->dev, ltq_mtd->res->start,
134                 resource_size(ltq_mtd->res), dev_name(&pdev->dev));
135         if (!ltq_mtd->res) {
136                 dev_err(&pdev->dev, "failed to request mem resource");
137                 err = -EBUSY;
138                 goto err_out;
139         }
140
141         ltq_mtd->map = kzalloc(sizeof(struct map_info), GFP_KERNEL);
142         ltq_mtd->map->phys = res->start;
143         ltq_mtd->map->size = resource_size(res);
144         ltq_mtd->map->virt = devm_ioremap_nocache(&pdev->dev,
145                                 ltq_mtd->map->phys, ltq_mtd->map->size);
146         if (!ltq_mtd->map->virt) {
147                 dev_err(&pdev->dev, "failed to ioremap!\n");
148                 err = -ENOMEM;
149                 goto err_free;
150         }
151
152         ltq_mtd->map->name = ltq_map_name;
153         ltq_mtd->map->bankwidth = 2;
154         ltq_mtd->map->read = ltq_read16;
155         ltq_mtd->map->write = ltq_write16;
156         ltq_mtd->map->copy_from = ltq_copy_from;
157         ltq_mtd->map->copy_to = ltq_copy_to;
158
159         ltq_mtd->map->map_priv_1 = LTQ_NOR_PROBING;
160         ltq_mtd->mtd = do_map_probe("cfi_probe", ltq_mtd->map);
161         ltq_mtd->map->map_priv_1 = LTQ_NOR_NORMAL;
162
163         if (!ltq_mtd->mtd) {
164                 dev_err(&pdev->dev, "probing failed\n");
165                 err = -ENXIO;
166                 goto err_unmap;
167         }
168
169         ltq_mtd->mtd->owner = THIS_MODULE;
170
171         cfi = ltq_mtd->map->fldrv_priv;
172         cfi->addr_unlock1 ^= 1;
173         cfi->addr_unlock2 ^= 1;
174
175         nr_parts = parse_mtd_partitions(ltq_mtd->mtd,
176                                 part_probe_types, &parts, 0);
177         if (nr_parts > 0) {
178                 dev_info(&pdev->dev,
179                         "using %d partitions from cmdline", nr_parts);
180         } else {
181                 nr_parts = ltq_mtd_data->nr_parts;
182                 parts = ltq_mtd_data->parts;
183         }
184
185         err = add_mtd_partitions(ltq_mtd->mtd, parts, nr_parts);
186         if (err) {
187                 dev_err(&pdev->dev, "failed to add partitions\n");
188                 goto err_destroy;
189         }
190
191         return 0;
192
193 err_destroy:
194         map_destroy(ltq_mtd->mtd);
195 err_unmap:
196         iounmap(ltq_mtd->map->virt);
197 err_free:
198         kfree(ltq_mtd->map);
199 err_out:
200         kfree(ltq_mtd);
201         return err;
202 }
203
204 static int __devexit
205 ltq_mtd_remove(struct platform_device *pdev)
206 {
207         struct ltq_mtd *ltq_mtd = platform_get_drvdata(pdev);
208
209         if (ltq_mtd) {
210                 if (ltq_mtd->mtd) {
211                         del_mtd_partitions(ltq_mtd->mtd);
212                         map_destroy(ltq_mtd->mtd);
213                 }
214                 if (ltq_mtd->map->virt)
215                         iounmap(ltq_mtd->map->virt);
216                 kfree(ltq_mtd->map);
217                 kfree(ltq_mtd);
218         }
219         return 0;
220 }
221
222 static struct platform_driver ltq_mtd_driver = {
223         .remove = __devexit_p(ltq_mtd_remove),
224         .driver = {
225                 .name = "ltq_nor",
226                 .owner = THIS_MODULE,
227         },
228 };
229
230 static int __init
231 init_ltq_mtd(void)
232 {
233         int ret = platform_driver_probe(&ltq_mtd_driver, ltq_mtd_probe);
234
235         if (ret)
236                 pr_err("ltq_nor: error registering platform driver");
237         return ret;
238 }
239
240 static void __exit
241 exit_ltq_mtd(void)
242 {
243         platform_driver_unregister(&ltq_mtd_driver);
244 }
245
246 module_init(init_ltq_mtd);
247 module_exit(exit_ltq_mtd);
248
249 MODULE_LICENSE("GPL");
250 MODULE_AUTHOR("John Crispin <blogic@openwrt.org>");
251 MODULE_DESCRIPTION("Lantiq SoC NOR");