Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/lib/devres.c

  1 #include <linux/err.h>
  2 #include <linux/pci.h>
  3 #include <linux/io.h>
  4 #include <linux/gfp.h>
  5 #include <linux/export.h>
  6 
  7 void devm_ioremap_release(struct device *dev, void *res)
  8 {
  9         iounmap(*(void __iomem **)res);
 10 }
 11 
 12 static int devm_ioremap_match(struct device *dev, void *res, void *match_data)
 13 {
 14         return *(void **)res == match_data;
 15 }
 16 
 17 /**
 18  * devm_ioremap - Managed ioremap()
 19  * @dev: Generic device to remap IO address for
 20  * @offset: BUS offset to map
 21  * @size: Size of map
 22  *
 23  * Managed ioremap().  Map is automatically unmapped on driver detach.
 24  */
 25 void __iomem *devm_ioremap(struct device *dev, resource_size_t offset,
 26                            resource_size_t size)
 27 {
 28         void __iomem **ptr, *addr;
 29 
 30         ptr = devres_alloc(devm_ioremap_release, sizeof(*ptr), GFP_KERNEL);
 31         if (!ptr)
 32                 return NULL;
 33 
 34         addr = ioremap(offset, size);
 35         if (addr) {
 36                 *ptr = addr;
 37                 devres_add(dev, ptr);
 38         } else
 39                 devres_free(ptr);
 40 
 41         return addr;
 42 }
 43 EXPORT_SYMBOL(devm_ioremap);
 44 
 45 /**
 46  * devm_ioremap_nocache - Managed ioremap_nocache()
 47  * @dev: Generic device to remap IO address for
 48  * @offset: BUS offset to map
 49  * @size: Size of map
 50  *
 51  * Managed ioremap_nocache().  Map is automatically unmapped on driver
 52  * detach.
 53  */
 54 void __iomem *devm_ioremap_nocache(struct device *dev, resource_size_t offset,
 55                                    resource_size_t size)
 56 {
 57         void __iomem **ptr, *addr;
 58 
 59         ptr = devres_alloc(devm_ioremap_release, sizeof(*ptr), GFP_KERNEL);
 60         if (!ptr)
 61                 return NULL;
 62 
 63         addr = ioremap_nocache(offset, size);
 64         if (addr) {
 65                 *ptr = addr;
 66                 devres_add(dev, ptr);
 67         } else
 68                 devres_free(ptr);
 69 
 70         return addr;
 71 }
 72 EXPORT_SYMBOL(devm_ioremap_nocache);
 73 
 74 /**
 75  * devm_ioremap_wc - Managed ioremap_wc()
 76  * @dev: Generic device to remap IO address for
 77  * @offset: BUS offset to map
 78  * @size: Size of map
 79  *
 80  * Managed ioremap_wc().  Map is automatically unmapped on driver detach.
 81  */
 82 void __iomem *devm_ioremap_wc(struct device *dev, resource_size_t offset,
 83                               resource_size_t size)
 84 {
 85         void __iomem **ptr, *addr;
 86 
 87         ptr = devres_alloc(devm_ioremap_release, sizeof(*ptr), GFP_KERNEL);
 88         if (!ptr)
 89                 return NULL;
 90 
 91         addr = ioremap_wc(offset, size);
 92         if (addr) {
 93                 *ptr = addr;
 94                 devres_add(dev, ptr);
 95         } else
 96                 devres_free(ptr);
 97 
 98         return addr;
 99 }
100 EXPORT_SYMBOL(devm_ioremap_wc);
101 
102 /**
103  * devm_iounmap - Managed iounmap()
104  * @dev: Generic device to unmap for
105  * @addr: Address to unmap
106  *
107  * Managed iounmap().  @addr must have been mapped using devm_ioremap*().
108  */
109 void devm_iounmap(struct device *dev, void __iomem *addr)
110 {
111         WARN_ON(devres_destroy(dev, devm_ioremap_release, devm_ioremap_match,
112                                (__force void *)addr));
113         iounmap(addr);
114 }
115 EXPORT_SYMBOL(devm_iounmap);
116 
117 /**
118  * devm_ioremap_resource() - check, request region, and ioremap resource
119  * @dev: generic device to handle the resource for
120  * @res: resource to be handled
121  *
122  * Checks that a resource is a valid memory region, requests the memory
123  * region and ioremaps it. All operations are managed and will be undone
124  * on driver detach.
125  *
126  * Returns a pointer to the remapped memory or an ERR_PTR() encoded error code
127  * on failure. Usage example:
128  *
129  *      res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
130  *      base = devm_ioremap_resource(&pdev->dev, res);
131  *      if (IS_ERR(base))
132  *              return PTR_ERR(base);
133  */
134 void __iomem *devm_ioremap_resource(struct device *dev, struct resource *res)
135 {
136         resource_size_t size;
137         const char *name;
138         void __iomem *dest_ptr;
139 
140         BUG_ON(!dev);
141 
142         if (!res || resource_type(res) != IORESOURCE_MEM) {
143                 dev_err(dev, "invalid resource\n");
144                 return IOMEM_ERR_PTR(-EINVAL);
145         }
146 
147         size = resource_size(res);
148         name = res->name ?: dev_name(dev);
149 
150         if (!devm_request_mem_region(dev, res->start, size, name)) {
151                 dev_err(dev, "can't request region for resource %pR\n", res);
152                 return IOMEM_ERR_PTR(-EBUSY);
153         }
154 
155         dest_ptr = devm_ioremap(dev, res->start, size);
156         if (!dest_ptr) {
157                 dev_err(dev, "ioremap failed for resource %pR\n", res);
158                 devm_release_mem_region(dev, res->start, size);
159                 dest_ptr = IOMEM_ERR_PTR(-ENOMEM);
160         }
161 
162         return dest_ptr;
163 }
164 EXPORT_SYMBOL(devm_ioremap_resource);
165 
166 #ifdef CONFIG_HAS_IOPORT_MAP
167 /*
168  * Generic iomap devres
169  */
170 static void devm_ioport_map_release(struct device *dev, void *res)
171 {
172         ioport_unmap(*(void __iomem **)res);
173 }
174 
175 static int devm_ioport_map_match(struct device *dev, void *res,
176                                  void *match_data)
177 {
178         return *(void **)res == match_data;
179 }
180 
181 /**
182  * devm_ioport_map - Managed ioport_map()
183  * @dev: Generic device to map ioport for
184  * @port: Port to map
185  * @nr: Number of ports to map
186  *
187  * Managed ioport_map().  Map is automatically unmapped on driver
188  * detach.
189  */
190 void __iomem *devm_ioport_map(struct device *dev, unsigned long port,
191                                unsigned int nr)
192 {
193         void __iomem **ptr, *addr;
194 
195         ptr = devres_alloc(devm_ioport_map_release, sizeof(*ptr), GFP_KERNEL);
196         if (!ptr)
197                 return NULL;
198 
199         addr = ioport_map(port, nr);
200         if (addr) {
201                 *ptr = addr;
202                 devres_add(dev, ptr);
203         } else
204                 devres_free(ptr);
205 
206         return addr;
207 }
208 EXPORT_SYMBOL(devm_ioport_map);
209 
210 /**
211  * devm_ioport_unmap - Managed ioport_unmap()
212  * @dev: Generic device to unmap for
213  * @addr: Address to unmap
214  *
215  * Managed ioport_unmap().  @addr must have been mapped using
216  * devm_ioport_map().
217  */
218 void devm_ioport_unmap(struct device *dev, void __iomem *addr)
219 {
220         ioport_unmap(addr);
221         WARN_ON(devres_destroy(dev, devm_ioport_map_release,
222                                devm_ioport_map_match, (__force void *)addr));
223 }
224 EXPORT_SYMBOL(devm_ioport_unmap);
225 #endif /* CONFIG_HAS_IOPORT_MAP */
226 
227 #ifdef CONFIG_PCI
228 /*
229  * PCI iomap devres
230  */
231 #define PCIM_IOMAP_MAX  PCI_ROM_RESOURCE
232 
233 struct pcim_iomap_devres {
234         void __iomem *table[PCIM_IOMAP_MAX];
235 };
236 
237 static void pcim_iomap_release(struct device *gendev, void *res)
238 {
239         struct pci_dev *dev = to_pci_dev(gendev);
240         struct pcim_iomap_devres *this = res;
241         int i;
242 
243         for (i = 0; i < PCIM_IOMAP_MAX; i++)
244                 if (this->table[i])
245                         pci_iounmap(dev, this->table[i]);
246 }
247 
248 /**
249  * pcim_iomap_table - access iomap allocation table
250  * @pdev: PCI device to access iomap table for
251  *
252  * Access iomap allocation table for @dev.  If iomap table doesn't
253  * exist and @pdev is managed, it will be allocated.  All iomaps
254  * recorded in the iomap table are automatically unmapped on driver
255  * detach.
256  *
257  * This function might sleep when the table is first allocated but can
258  * be safely called without context and guaranteed to succed once
259  * allocated.
260  */
261 void __iomem * const *pcim_iomap_table(struct pci_dev *pdev)
262 {
263         struct pcim_iomap_devres *dr, *new_dr;
264 
265         dr = devres_find(&pdev->dev, pcim_iomap_release, NULL, NULL);
266         if (dr)
267                 return dr->table;
268 
269         new_dr = devres_alloc(pcim_iomap_release, sizeof(*new_dr), GFP_KERNEL);
270         if (!new_dr)
271                 return NULL;
272         dr = devres_get(&pdev->dev, new_dr, NULL, NULL);
273         return dr->table;
274 }
275 EXPORT_SYMBOL(pcim_iomap_table);
276 
277 /**
278  * pcim_iomap - Managed pcim_iomap()
279  * @pdev: PCI device to iomap for
280  * @bar: BAR to iomap
281  * @maxlen: Maximum length of iomap
282  *
283  * Managed pci_iomap().  Map is automatically unmapped on driver
284  * detach.
285  */
286 void __iomem *pcim_iomap(struct pci_dev *pdev, int bar, unsigned long maxlen)
287 {
288         void __iomem **tbl;
289 
290         BUG_ON(bar >= PCIM_IOMAP_MAX);
291 
292         tbl = (void __iomem **)pcim_iomap_table(pdev);
293         if (!tbl || tbl[bar])   /* duplicate mappings not allowed */
294                 return NULL;
295 
296         tbl[bar] = pci_iomap(pdev, bar, maxlen);
297         return tbl[bar];
298 }
299 EXPORT_SYMBOL(pcim_iomap);
300 
301 /**
302  * pcim_iounmap - Managed pci_iounmap()
303  * @pdev: PCI device to iounmap for
304  * @addr: Address to unmap
305  *
306  * Managed pci_iounmap().  @addr must have been mapped using pcim_iomap().
307  */
308 void pcim_iounmap(struct pci_dev *pdev, void __iomem *addr)
309 {
310         void __iomem **tbl;
311         int i;
312 
313         pci_iounmap(pdev, addr);
314 
315         tbl = (void __iomem **)pcim_iomap_table(pdev);
316         BUG_ON(!tbl);
317 
318         for (i = 0; i < PCIM_IOMAP_MAX; i++)
319                 if (tbl[i] == addr) {
320                         tbl[i] = NULL;
321                         return;
322                 }
323         WARN_ON(1);
324 }
325 EXPORT_SYMBOL(pcim_iounmap);
326 
327 /**
328  * pcim_iomap_regions - Request and iomap PCI BARs
329  * @pdev: PCI device to map IO resources for
330  * @mask: Mask of BARs to request and iomap
331  * @name: Name used when requesting regions
332  *
333  * Request and iomap regions specified by @mask.
334  */
335 int pcim_iomap_regions(struct pci_dev *pdev, int mask, const char *name)
336 {
337         void __iomem * const *iomap;
338         int i, rc;
339 
340         iomap = pcim_iomap_table(pdev);
341         if (!iomap)
342                 return -ENOMEM;
343 
344         for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
345                 unsigned long len;
346 
347                 if (!(mask & (1 << i)))
348                         continue;
349 
350                 rc = -EINVAL;
351                 len = pci_resource_len(pdev, i);
352                 if (!len)
353                         goto err_inval;
354 
355                 rc = pci_request_region(pdev, i, name);
356                 if (rc)
357                         goto err_inval;
358 
359                 rc = -ENOMEM;
360                 if (!pcim_iomap(pdev, i, 0))
361                         goto err_region;
362         }
363 
364         return 0;
365 
366  err_region:
367         pci_release_region(pdev, i);
368  err_inval:
369         while (--i >= 0) {
370                 if (!(mask & (1 << i)))
371                         continue;
372                 pcim_iounmap(pdev, iomap[i]);
373                 pci_release_region(pdev, i);
374         }
375 
376         return rc;
377 }
378 EXPORT_SYMBOL(pcim_iomap_regions);
379 
380 /**
381  * pcim_iomap_regions_request_all - Request all BARs and iomap specified ones
382  * @pdev: PCI device to map IO resources for
383  * @mask: Mask of BARs to iomap
384  * @name: Name used when requesting regions
385  *
386  * Request all PCI BARs and iomap regions specified by @mask.
387  */
388 int pcim_iomap_regions_request_all(struct pci_dev *pdev, int mask,
389                                    const char *name)
390 {
391         int request_mask = ((1 << 6) - 1) & ~mask;
392         int rc;
393 
394         rc = pci_request_selected_regions(pdev, request_mask, name);
395         if (rc)
396                 return rc;
397 
398         rc = pcim_iomap_regions(pdev, mask, name);
399         if (rc)
400                 pci_release_selected_regions(pdev, request_mask);
401         return rc;
402 }
403 EXPORT_SYMBOL(pcim_iomap_regions_request_all);
404 
405 /**
406  * pcim_iounmap_regions - Unmap and release PCI BARs
407  * @pdev: PCI device to map IO resources for
408  * @mask: Mask of BARs to unmap and release
409  *
410  * Unmap and release regions specified by @mask.
411  */
412 void pcim_iounmap_regions(struct pci_dev *pdev, int mask)
413 {
414         void __iomem * const *iomap;
415         int i;
416 
417         iomap = pcim_iomap_table(pdev);
418         if (!iomap)
419                 return;
420 
421         for (i = 0; i < PCIM_IOMAP_MAX; i++) {
422                 if (!(mask & (1 << i)))
423                         continue;
424 
425                 pcim_iounmap(pdev, iomap[i]);
426                 pci_release_region(pdev, i);
427         }
428 }
429 EXPORT_SYMBOL(pcim_iounmap_regions);
430 #endif /* CONFIG_PCI */
431 

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