]>
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 | |
40bc941d | 7 | * Copyright (C) 2010 John Crispin <john@phrozen.org> |
3c544739 JC |
8 | */ |
9 | ||
b0de774c | 10 | #include <linux/err.h> |
3c544739 JC |
11 | #include <linux/module.h> |
12 | #include <linux/types.h> | |
13 | #include <linux/kernel.h> | |
14 | #include <linux/io.h> | |
15 | #include <linux/slab.h> | |
3c544739 JC |
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> | |
fa09eded | 22 | #include <linux/of.h> |
3c544739 JC |
23 | |
24 | #include <lantiq_soc.h> | |
3c544739 JC |
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 | ||
02fa961f | 47 | static const char ltq_map_name[] = "ltq_nor"; |
3c544739 JC |
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 | ||
06f25510 | 110 | static int |
3c544739 JC |
111 | ltq_mtd_probe(struct platform_device *pdev) |
112 | { | |
3c544739 | 113 | struct ltq_mtd *ltq_mtd; |
3c544739 JC |
114 | struct cfi_private *cfi; |
115 | int err; | |
116 | ||
436bf63b JH |
117 | ltq_mtd = devm_kzalloc(&pdev->dev, sizeof(struct ltq_mtd), GFP_KERNEL); |
118 | if (!ltq_mtd) | |
119 | return -ENOMEM; | |
120 | ||
3c544739 JC |
121 | platform_set_drvdata(pdev, ltq_mtd); |
122 | ||
123 | ltq_mtd->res = platform_get_resource(pdev, IORESOURCE_MEM, 0); | |
124 | if (!ltq_mtd->res) { | |
02fa961f | 125 | dev_err(&pdev->dev, "failed to get memory resource\n"); |
436bf63b | 126 | return -ENOENT; |
3c544739 JC |
127 | } |
128 | ||
436bf63b JH |
129 | ltq_mtd->map = devm_kzalloc(&pdev->dev, sizeof(struct map_info), |
130 | GFP_KERNEL); | |
131 | if (!ltq_mtd->map) | |
132 | return -ENOMEM; | |
133 | ||
02fa961f JC |
134 | ltq_mtd->map->phys = ltq_mtd->res->start; |
135 | ltq_mtd->map->size = resource_size(ltq_mtd->res); | |
b0de774c | 136 | ltq_mtd->map->virt = devm_ioremap_resource(&pdev->dev, ltq_mtd->res); |
436bf63b JH |
137 | if (IS_ERR(ltq_mtd->map->virt)) |
138 | return PTR_ERR(ltq_mtd->map->virt); | |
3c544739 JC |
139 | |
140 | ltq_mtd->map->name = ltq_map_name; | |
141 | ltq_mtd->map->bankwidth = 2; | |
142 | ltq_mtd->map->read = ltq_read16; | |
143 | ltq_mtd->map->write = ltq_write16; | |
144 | ltq_mtd->map->copy_from = ltq_copy_from; | |
145 | ltq_mtd->map->copy_to = ltq_copy_to; | |
146 | ||
147 | ltq_mtd->map->map_priv_1 = LTQ_NOR_PROBING; | |
148 | ltq_mtd->mtd = do_map_probe("cfi_probe", ltq_mtd->map); | |
149 | ltq_mtd->map->map_priv_1 = LTQ_NOR_NORMAL; | |
150 | ||
151 | if (!ltq_mtd->mtd) { | |
152 | dev_err(&pdev->dev, "probing failed\n"); | |
436bf63b | 153 | return -ENXIO; |
3c544739 JC |
154 | } |
155 | ||
c54c2fb7 | 156 | ltq_mtd->mtd->dev.parent = &pdev->dev; |
004b5e60 | 157 | mtd_set_of_node(ltq_mtd->mtd, pdev->dev.of_node); |
3c544739 JC |
158 | |
159 | cfi = ltq_mtd->map->fldrv_priv; | |
160 | cfi->addr_unlock1 ^= 1; | |
161 | cfi->addr_unlock2 ^= 1; | |
162 | ||
004b5e60 | 163 | err = mtd_device_register(ltq_mtd->mtd, NULL, 0); |
3c544739 JC |
164 | if (err) { |
165 | dev_err(&pdev->dev, "failed to add partitions\n"); | |
166 | goto err_destroy; | |
167 | } | |
168 | ||
169 | return 0; | |
170 | ||
171 | err_destroy: | |
172 | map_destroy(ltq_mtd->mtd); | |
3c544739 JC |
173 | return err; |
174 | } | |
175 | ||
810b7e06 | 176 | static int |
3c544739 JC |
177 | ltq_mtd_remove(struct platform_device *pdev) |
178 | { | |
179 | struct ltq_mtd *ltq_mtd = platform_get_drvdata(pdev); | |
180 | ||
436bf63b JH |
181 | if (ltq_mtd && ltq_mtd->mtd) { |
182 | mtd_device_unregister(ltq_mtd->mtd); | |
183 | map_destroy(ltq_mtd->mtd); | |
3c544739 JC |
184 | } |
185 | return 0; | |
186 | } | |
187 | ||
02fa961f JC |
188 | static const struct of_device_id ltq_mtd_match[] = { |
189 | { .compatible = "lantiq,nor" }, | |
190 | {}, | |
191 | }; | |
192 | MODULE_DEVICE_TABLE(of, ltq_mtd_match); | |
193 | ||
3c544739 | 194 | static struct platform_driver ltq_mtd_driver = { |
02fa961f | 195 | .probe = ltq_mtd_probe, |
5153b88c | 196 | .remove = ltq_mtd_remove, |
3c544739 | 197 | .driver = { |
02fa961f | 198 | .name = "ltq-nor", |
02fa961f | 199 | .of_match_table = ltq_mtd_match, |
3c544739 JC |
200 | }, |
201 | }; | |
202 | ||
02fa961f | 203 | module_platform_driver(ltq_mtd_driver); |
3c544739 JC |
204 | |
205 | MODULE_LICENSE("GPL"); | |
40bc941d | 206 | MODULE_AUTHOR("John Crispin <john@phrozen.org>"); |
3c544739 | 207 | MODULE_DESCRIPTION("Lantiq SoC NOR"); |