Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us