vsprintf: Update %pI6c to not compress a single 0
[linux-2.6.git] / lib / devres.c
1 #include <linux/pci.h>
2 #include <linux/io.h>
3 #include <linux/gfp.h>
4 #include <linux/module.h>
5
6 void devm_ioremap_release(struct device *dev, void *res)
7 {
8         iounmap(*(void __iomem **)res);
9 }
10
11 static int devm_ioremap_match(struct device *dev, void *res, void *match_data)
12 {
13         return *(void **)res == match_data;
14 }
15
16 /**
17  * devm_ioremap - Managed ioremap()
18  * @dev: Generic device to remap IO address for
19  * @offset: BUS offset to map
20  * @size: Size of map
21  *
22  * Managed ioremap().  Map is automatically unmapped on driver detach.
23  */
24 void __iomem *devm_ioremap(struct device *dev, resource_size_t offset,
25                            unsigned long size)
26 {
27         void __iomem **ptr, *addr;
28
29         ptr = devres_alloc(devm_ioremap_release, sizeof(*ptr), GFP_KERNEL);
30         if (!ptr)
31                 return NULL;
32
33         addr = ioremap(offset, size);
34         if (addr) {
35                 *ptr = addr;
36                 devres_add(dev, ptr);
37         } else
38                 devres_free(ptr);
39
40         return addr;
41 }
42 EXPORT_SYMBOL(devm_ioremap);
43
44 /**
45  * devm_ioremap_nocache - Managed ioremap_nocache()
46  * @dev: Generic device to remap IO address for
47  * @offset: BUS offset to map
48  * @size: Size of map
49  *
50  * Managed ioremap_nocache().  Map is automatically unmapped on driver
51  * detach.
52  */
53 void __iomem *devm_ioremap_nocache(struct device *dev, resource_size_t offset,
54                                    unsigned long size)
55 {
56         void __iomem **ptr, *addr;
57
58         ptr = devres_alloc(devm_ioremap_release, sizeof(*ptr), GFP_KERNEL);
59         if (!ptr)
60                 return NULL;
61
62         addr = ioremap_nocache(offset, size);
63         if (addr) {
64                 *ptr = addr;
65                 devres_add(dev, ptr);
66         } else
67                 devres_free(ptr);
68
69         return addr;
70 }
71 EXPORT_SYMBOL(devm_ioremap_nocache);
72
73 /**
74  * devm_iounmap - Managed iounmap()
75  * @dev: Generic device to unmap for
76  * @addr: Address to unmap
77  *
78  * Managed iounmap().  @addr must have been mapped using devm_ioremap*().
79  */
80 void devm_iounmap(struct device *dev, void __iomem *addr)
81 {
82         iounmap(addr);
83         WARN_ON(devres_destroy(dev, devm_ioremap_release, devm_ioremap_match,
84                                (void *)addr));
85 }
86 EXPORT_SYMBOL(devm_iounmap);
87
88 #ifdef CONFIG_HAS_IOPORT
89 /*
90  * Generic iomap devres
91  */
92 static void devm_ioport_map_release(struct device *dev, void *res)
93 {
94         ioport_unmap(*(void __iomem **)res);
95 }
96
97 static int devm_ioport_map_match(struct device *dev, void *res,
98                                  void *match_data)
99 {
100         return *(void **)res == match_data;
101 }
102
103 /**
104  * devm_ioport_map - Managed ioport_map()
105  * @dev: Generic device to map ioport for
106  * @port: Port to map
107  * @nr: Number of ports to map
108  *
109  * Managed ioport_map().  Map is automatically unmapped on driver
110  * detach.
111  */
112 void __iomem * devm_ioport_map(struct device *dev, unsigned long port,
113                                unsigned int nr)
114 {
115         void __iomem **ptr, *addr;
116
117         ptr = devres_alloc(devm_ioport_map_release, sizeof(*ptr), GFP_KERNEL);
118         if (!ptr)
119                 return NULL;
120
121         addr = ioport_map(port, nr);
122         if (addr) {
123                 *ptr = addr;
124                 devres_add(dev, ptr);
125         } else
126                 devres_free(ptr);
127
128         return addr;
129 }
130 EXPORT_SYMBOL(devm_ioport_map);
131
132 /**
133  * devm_ioport_unmap - Managed ioport_unmap()
134  * @dev: Generic device to unmap for
135  * @addr: Address to unmap
136  *
137  * Managed ioport_unmap().  @addr must have been mapped using
138  * devm_ioport_map().
139  */
140 void devm_ioport_unmap(struct device *dev, void __iomem *addr)
141 {
142         ioport_unmap(addr);
143         WARN_ON(devres_destroy(dev, devm_ioport_map_release,
144                                devm_ioport_map_match, (void *)addr));
145 }
146 EXPORT_SYMBOL(devm_ioport_unmap);
147
148 #ifdef CONFIG_PCI
149 /*
150  * PCI iomap devres
151  */
152 #define PCIM_IOMAP_MAX  PCI_ROM_RESOURCE
153
154 struct pcim_iomap_devres {
155         void __iomem *table[PCIM_IOMAP_MAX];
156 };
157
158 static void pcim_iomap_release(struct device *gendev, void *res)
159 {
160         struct pci_dev *dev = container_of(gendev, struct pci_dev, dev);
161         struct pcim_iomap_devres *this = res;
162         int i;
163
164         for (i = 0; i < PCIM_IOMAP_MAX; i++)
165                 if (this->table[i])
166                         pci_iounmap(dev, this->table[i]);
167 }
168
169 /**
170  * pcim_iomap_table - access iomap allocation table
171  * @pdev: PCI device to access iomap table for
172  *
173  * Access iomap allocation table for @dev.  If iomap table doesn't
174  * exist and @pdev is managed, it will be allocated.  All iomaps
175  * recorded in the iomap table are automatically unmapped on driver
176  * detach.
177  *
178  * This function might sleep when the table is first allocated but can
179  * be safely called without context and guaranteed to succed once
180  * allocated.
181  */
182 void __iomem * const * pcim_iomap_table(struct pci_dev *pdev)
183 {
184         struct pcim_iomap_devres *dr, *new_dr;
185
186         dr = devres_find(&pdev->dev, pcim_iomap_release, NULL, NULL);
187         if (dr)
188                 return dr->table;
189
190         new_dr = devres_alloc(pcim_iomap_release, sizeof(*new_dr), GFP_KERNEL);
191         if (!new_dr)
192                 return NULL;
193         dr = devres_get(&pdev->dev, new_dr, NULL, NULL);
194         return dr->table;
195 }
196 EXPORT_SYMBOL(pcim_iomap_table);
197
198 /**
199  * pcim_iomap - Managed pcim_iomap()
200  * @pdev: PCI device to iomap for
201  * @bar: BAR to iomap
202  * @maxlen: Maximum length of iomap
203  *
204  * Managed pci_iomap().  Map is automatically unmapped on driver
205  * detach.
206  */
207 void __iomem * pcim_iomap(struct pci_dev *pdev, int bar, unsigned long maxlen)
208 {
209         void __iomem **tbl;
210
211         BUG_ON(bar >= PCIM_IOMAP_MAX);
212
213         tbl = (void __iomem **)pcim_iomap_table(pdev);
214         if (!tbl || tbl[bar])   /* duplicate mappings not allowed */
215                 return NULL;
216
217         tbl[bar] = pci_iomap(pdev, bar, maxlen);
218         return tbl[bar];
219 }
220 EXPORT_SYMBOL(pcim_iomap);
221
222 /**
223  * pcim_iounmap - Managed pci_iounmap()
224  * @pdev: PCI device to iounmap for
225  * @addr: Address to unmap
226  *
227  * Managed pci_iounmap().  @addr must have been mapped using pcim_iomap().
228  */
229 void pcim_iounmap(struct pci_dev *pdev, void __iomem *addr)
230 {
231         void __iomem **tbl;
232         int i;
233
234         pci_iounmap(pdev, addr);
235
236         tbl = (void __iomem **)pcim_iomap_table(pdev);
237         BUG_ON(!tbl);
238
239         for (i = 0; i < PCIM_IOMAP_MAX; i++)
240                 if (tbl[i] == addr) {
241                         tbl[i] = NULL;
242                         return;
243                 }
244         WARN_ON(1);
245 }
246 EXPORT_SYMBOL(pcim_iounmap);
247
248 /**
249  * pcim_iomap_regions - Request and iomap PCI BARs
250  * @pdev: PCI device to map IO resources for
251  * @mask: Mask of BARs to request and iomap
252  * @name: Name used when requesting regions
253  *
254  * Request and iomap regions specified by @mask.
255  */
256 int pcim_iomap_regions(struct pci_dev *pdev, u16 mask, const char *name)
257 {
258         void __iomem * const *iomap;
259         int i, rc;
260
261         iomap = pcim_iomap_table(pdev);
262         if (!iomap)
263                 return -ENOMEM;
264
265         for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
266                 unsigned long len;
267
268                 if (!(mask & (1 << i)))
269                         continue;
270
271                 rc = -EINVAL;
272                 len = pci_resource_len(pdev, i);
273                 if (!len)
274                         goto err_inval;
275
276                 rc = pci_request_region(pdev, i, name);
277                 if (rc)
278                         goto err_inval;
279
280                 rc = -ENOMEM;
281                 if (!pcim_iomap(pdev, i, 0))
282                         goto err_region;
283         }
284
285         return 0;
286
287  err_region:
288         pci_release_region(pdev, i);
289  err_inval:
290         while (--i >= 0) {
291                 if (!(mask & (1 << i)))
292                         continue;
293                 pcim_iounmap(pdev, iomap[i]);
294                 pci_release_region(pdev, i);
295         }
296
297         return rc;
298 }
299 EXPORT_SYMBOL(pcim_iomap_regions);
300
301 /**
302  * pcim_iomap_regions_request_all - Request all BARs and iomap specified ones
303  * @pdev: PCI device to map IO resources for
304  * @mask: Mask of BARs to iomap
305  * @name: Name used when requesting regions
306  *
307  * Request all PCI BARs and iomap regions specified by @mask.
308  */
309 int pcim_iomap_regions_request_all(struct pci_dev *pdev, u16 mask,
310                                    const char *name)
311 {
312         int request_mask = ((1 << 6) - 1) & ~mask;
313         int rc;
314
315         rc = pci_request_selected_regions(pdev, request_mask, name);
316         if (rc)
317                 return rc;
318
319         rc = pcim_iomap_regions(pdev, mask, name);
320         if (rc)
321                 pci_release_selected_regions(pdev, request_mask);
322         return rc;
323 }
324 EXPORT_SYMBOL(pcim_iomap_regions_request_all);
325
326 /**
327  * pcim_iounmap_regions - Unmap and release PCI BARs
328  * @pdev: PCI device to map IO resources for
329  * @mask: Mask of BARs to unmap and release
330  *
331  * Unmap and release regions specified by @mask.
332  */
333 void pcim_iounmap_regions(struct pci_dev *pdev, u16 mask)
334 {
335         void __iomem * const *iomap;
336         int i;
337
338         iomap = pcim_iomap_table(pdev);
339         if (!iomap)
340                 return;
341
342         for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
343                 if (!(mask & (1 << i)))
344                         continue;
345
346                 pcim_iounmap(pdev, iomap[i]);
347                 pci_release_region(pdev, i);
348         }
349 }
350 EXPORT_SYMBOL(pcim_iounmap_regions);
351 #endif
352 #endif