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