Merge branch 'linux-next' of git://git.infradead.org/~dedekind/ubi-2.6
[linux-3.10.git] / drivers / mtd / maps / pci.c
1 /*
2  *  linux/drivers/mtd/maps/pci.c
3  *
4  *  Copyright (C) 2001 Russell King, All rights reserved.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 as
8  * published by the Free Software Foundation.
9  *
10  * Generic PCI memory map driver.  We support the following boards:
11  *  - Intel IQ80310 ATU.
12  *  - Intel EBSA285 (blank rom programming mode). Tested working 27/09/2001
13  */
14 #include <linux/module.h>
15 #include <linux/kernel.h>
16 #include <linux/pci.h>
17 #include <linux/init.h>
18 #include <linux/slab.h>
19
20 #include <linux/mtd/mtd.h>
21 #include <linux/mtd/map.h>
22 #include <linux/mtd/partitions.h>
23
24 struct map_pci_info;
25
26 struct mtd_pci_info {
27         int  (*init)(struct pci_dev *dev, struct map_pci_info *map);
28         void (*exit)(struct pci_dev *dev, struct map_pci_info *map);
29         unsigned long (*translate)(struct map_pci_info *map, unsigned long ofs);
30         const char *map_name;
31 };
32
33 struct map_pci_info {
34         struct map_info map;
35         void __iomem *base;
36         void (*exit)(struct pci_dev *dev, struct map_pci_info *map);
37         unsigned long (*translate)(struct map_pci_info *map, unsigned long ofs);
38         struct pci_dev *dev;
39 };
40
41 static map_word mtd_pci_read8(struct map_info *_map, unsigned long ofs)
42 {
43         struct map_pci_info *map = (struct map_pci_info *)_map;
44         map_word val;
45         val.x[0]= readb(map->base + map->translate(map, ofs));
46 //      printk("read8 : %08lx => %02x\n", ofs, val.x[0]);
47         return val;
48 }
49
50 #if 0
51 static map_word mtd_pci_read16(struct map_info *_map, unsigned long ofs)
52 {
53         struct map_pci_info *map = (struct map_pci_info *)_map;
54         map_word val;
55         val.x[0] = readw(map->base + map->translate(map, ofs));
56 //      printk("read16: %08lx => %04x\n", ofs, val.x[0]);
57         return val;
58 }
59 #endif
60 static map_word mtd_pci_read32(struct map_info *_map, unsigned long ofs)
61 {
62         struct map_pci_info *map = (struct map_pci_info *)_map;
63         map_word val;
64         val.x[0] = readl(map->base + map->translate(map, ofs));
65 //      printk("read32: %08lx => %08x\n", ofs, val.x[0]);
66         return val;
67 }
68
69 static void mtd_pci_copyfrom(struct map_info *_map, void *to, unsigned long from, ssize_t len)
70 {
71         struct map_pci_info *map = (struct map_pci_info *)_map;
72         memcpy_fromio(to, map->base + map->translate(map, from), len);
73 }
74
75 static void mtd_pci_write8(struct map_info *_map, map_word val, unsigned long ofs)
76 {
77         struct map_pci_info *map = (struct map_pci_info *)_map;
78 //      printk("write8 : %08lx <= %02x\n", ofs, val.x[0]);
79         writeb(val.x[0], map->base + map->translate(map, ofs));
80 }
81
82 #if 0
83 static void mtd_pci_write16(struct map_info *_map, map_word val, unsigned long ofs)
84 {
85         struct map_pci_info *map = (struct map_pci_info *)_map;
86 //      printk("write16: %08lx <= %04x\n", ofs, val.x[0]);
87         writew(val.x[0], map->base + map->translate(map, ofs));
88 }
89 #endif
90 static void mtd_pci_write32(struct map_info *_map, map_word val, unsigned long ofs)
91 {
92         struct map_pci_info *map = (struct map_pci_info *)_map;
93 //      printk("write32: %08lx <= %08x\n", ofs, val.x[0]);
94         writel(val.x[0], map->base + map->translate(map, ofs));
95 }
96
97 static void mtd_pci_copyto(struct map_info *_map, unsigned long to, const void *from, ssize_t len)
98 {
99         struct map_pci_info *map = (struct map_pci_info *)_map;
100         memcpy_toio(map->base + map->translate(map, to), from, len);
101 }
102
103 static const struct map_info mtd_pci_map = {
104         .phys =         NO_XIP,
105         .copy_from =    mtd_pci_copyfrom,
106         .copy_to =      mtd_pci_copyto,
107 };
108
109 /*
110  * Intel IOP80310 Flash driver
111  */
112
113 static int
114 intel_iq80310_init(struct pci_dev *dev, struct map_pci_info *map)
115 {
116         u32 win_base;
117
118         map->map.bankwidth = 1;
119         map->map.read = mtd_pci_read8,
120         map->map.write = mtd_pci_write8,
121
122         map->map.size     = 0x00800000;
123         map->base         = ioremap_nocache(pci_resource_start(dev, 0),
124                                             pci_resource_len(dev, 0));
125
126         if (!map->base)
127                 return -ENOMEM;
128
129         /*
130          * We want to base the memory window at Xscale
131          * bus address 0, not 0x1000.
132          */
133         pci_read_config_dword(dev, 0x44, &win_base);
134         pci_write_config_dword(dev, 0x44, 0);
135
136         map->map.map_priv_2 = win_base;
137
138         return 0;
139 }
140
141 static void
142 intel_iq80310_exit(struct pci_dev *dev, struct map_pci_info *map)
143 {
144         if (map->base)
145                 iounmap(map->base);
146         pci_write_config_dword(dev, 0x44, map->map.map_priv_2);
147 }
148
149 static unsigned long
150 intel_iq80310_translate(struct map_pci_info *map, unsigned long ofs)
151 {
152         unsigned long page_addr = ofs & 0x00400000;
153
154         /*
155          * This mundges the flash location so we avoid
156          * the first 80 bytes (they appear to read nonsense).
157          */
158         if (page_addr) {
159                 writel(0x00000008, map->base + 0x1558);
160                 writel(0x00000000, map->base + 0x1550);
161         } else {
162                 writel(0x00000007, map->base + 0x1558);
163                 writel(0x00800000, map->base + 0x1550);
164                 ofs += 0x00800000;
165         }
166
167         return ofs;
168 }
169
170 static struct mtd_pci_info intel_iq80310_info = {
171         .init =         intel_iq80310_init,
172         .exit =         intel_iq80310_exit,
173         .translate =    intel_iq80310_translate,
174         .map_name =     "cfi_probe",
175 };
176
177 /*
178  * Intel DC21285 driver
179  */
180
181 static int
182 intel_dc21285_init(struct pci_dev *dev, struct map_pci_info *map)
183 {
184         unsigned long base, len;
185
186         base = pci_resource_start(dev, PCI_ROM_RESOURCE);
187         len  = pci_resource_len(dev, PCI_ROM_RESOURCE);
188
189         if (!len || !base) {
190                 /*
191                  * No ROM resource
192                  */
193                 base = pci_resource_start(dev, 2);
194                 len  = pci_resource_len(dev, 2);
195
196                 /*
197                  * We need to re-allocate PCI BAR2 address range to the
198                  * PCI ROM BAR, and disable PCI BAR2.
199                  */
200         } else {
201                 /*
202                  * Hmm, if an address was allocated to the ROM resource, but
203                  * not enabled, should we be allocating a new resource for it
204                  * or simply enabling it?
205                  */
206                 if (!(pci_resource_flags(dev, PCI_ROM_RESOURCE) &
207                                     IORESOURCE_ROM_ENABLE)) {
208                         u32 val;
209                         pci_resource_flags(dev, PCI_ROM_RESOURCE) |= IORESOURCE_ROM_ENABLE;
210                         pci_read_config_dword(dev, PCI_ROM_ADDRESS, &val);
211                         val |= PCI_ROM_ADDRESS_ENABLE;
212                         pci_write_config_dword(dev, PCI_ROM_ADDRESS, val);
213                         printk("%s: enabling expansion ROM\n", pci_name(dev));
214                 }
215         }
216
217         if (!len || !base)
218                 return -ENXIO;
219
220         map->map.bankwidth = 4;
221         map->map.read = mtd_pci_read32,
222         map->map.write = mtd_pci_write32,
223         map->map.size     = len;
224         map->base         = ioremap_nocache(base, len);
225
226         if (!map->base)
227                 return -ENOMEM;
228
229         return 0;
230 }
231
232 static void
233 intel_dc21285_exit(struct pci_dev *dev, struct map_pci_info *map)
234 {
235         u32 val;
236
237         if (map->base)
238                 iounmap(map->base);
239
240         /*
241          * We need to undo the PCI BAR2/PCI ROM BAR address alteration.
242          */
243         pci_resource_flags(dev, PCI_ROM_RESOURCE) &= ~IORESOURCE_ROM_ENABLE;
244         pci_read_config_dword(dev, PCI_ROM_ADDRESS, &val);
245         val &= ~PCI_ROM_ADDRESS_ENABLE;
246         pci_write_config_dword(dev, PCI_ROM_ADDRESS, val);
247 }
248
249 static unsigned long
250 intel_dc21285_translate(struct map_pci_info *map, unsigned long ofs)
251 {
252         return ofs & 0x00ffffc0 ? ofs : (ofs ^ (1 << 5));
253 }
254
255 static struct mtd_pci_info intel_dc21285_info = {
256         .init =         intel_dc21285_init,
257         .exit =         intel_dc21285_exit,
258         .translate =    intel_dc21285_translate,
259         .map_name =     "jedec_probe",
260 };
261
262 /*
263  * PCI device ID table
264  */
265
266 static struct pci_device_id mtd_pci_ids[] = {
267         {
268                 .vendor =       PCI_VENDOR_ID_INTEL,
269                 .device =       0x530d,
270                 .subvendor =    PCI_ANY_ID,
271                 .subdevice =    PCI_ANY_ID,
272                 .class =        PCI_CLASS_MEMORY_OTHER << 8,
273                 .class_mask =   0xffff00,
274                 .driver_data =  (unsigned long)&intel_iq80310_info,
275         },
276         {
277                 .vendor =       PCI_VENDOR_ID_DEC,
278                 .device =       PCI_DEVICE_ID_DEC_21285,
279                 .subvendor =    0,      /* DC21285 defaults to 0 on reset */
280                 .subdevice =    0,      /* DC21285 defaults to 0 on reset */
281                 .driver_data =  (unsigned long)&intel_dc21285_info,
282         },
283         { 0, }
284 };
285
286 /*
287  * Generic code follows.
288  */
289
290 static int __devinit
291 mtd_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
292 {
293         struct mtd_pci_info *info = (struct mtd_pci_info *)id->driver_data;
294         struct map_pci_info *map = NULL;
295         struct mtd_info *mtd = NULL;
296         int err;
297
298         err = pci_enable_device(dev);
299         if (err)
300                 goto out;
301
302         err = pci_request_regions(dev, "pci mtd");
303         if (err)
304                 goto out;
305
306         map = kmalloc(sizeof(*map), GFP_KERNEL);
307         err = -ENOMEM;
308         if (!map)
309                 goto release;
310
311         map->map       = mtd_pci_map;
312         map->map.name  = pci_name(dev);
313         map->dev       = dev;
314         map->exit      = info->exit;
315         map->translate = info->translate;
316
317         err = info->init(dev, map);
318         if (err)
319                 goto release;
320
321         /* tsk - do_map_probe should take const char * */
322         mtd = do_map_probe((char *)info->map_name, &map->map);
323         err = -ENODEV;
324         if (!mtd)
325                 goto release;
326
327         mtd->owner = THIS_MODULE;
328         add_mtd_device(mtd);
329
330         pci_set_drvdata(dev, mtd);
331
332         return 0;
333
334 release:
335         if (map) {
336                 map->exit(dev, map);
337                 kfree(map);
338         }
339
340         pci_release_regions(dev);
341 out:
342         return err;
343 }
344
345 static void __devexit
346 mtd_pci_remove(struct pci_dev *dev)
347 {
348         struct mtd_info *mtd = pci_get_drvdata(dev);
349         struct map_pci_info *map = mtd->priv;
350
351         del_mtd_device(mtd);
352         map_destroy(mtd);
353         map->exit(dev, map);
354         kfree(map);
355
356         pci_set_drvdata(dev, NULL);
357         pci_release_regions(dev);
358 }
359
360 static struct pci_driver mtd_pci_driver = {
361         .name =         "MTD PCI",
362         .probe =        mtd_pci_probe,
363         .remove =       __devexit_p(mtd_pci_remove),
364         .id_table =     mtd_pci_ids,
365 };
366
367 static int __init mtd_pci_maps_init(void)
368 {
369         return pci_register_driver(&mtd_pci_driver);
370 }
371
372 static void __exit mtd_pci_maps_exit(void)
373 {
374         pci_unregister_driver(&mtd_pci_driver);
375 }
376
377 module_init(mtd_pci_maps_init);
378 module_exit(mtd_pci_maps_exit);
379
380 MODULE_LICENSE("GPL");
381 MODULE_AUTHOR("Russell King <rmk@arm.linux.org.uk>");
382 MODULE_DESCRIPTION("Generic PCI map driver");
383 MODULE_DEVICE_TABLE(pci, mtd_pci_ids);
384