5 #include <linux/export.h>
7 void devm_ioremap_release(struct device
*dev
, void *res
)
9 iounmap(*(void __iomem
**)res
);
12 static int devm_ioremap_match(struct device
*dev
, void *res
, void *match_data
)
14 return *(void **)res
== match_data
;
18 * devm_ioremap - Managed ioremap()
19 * @dev: Generic device to remap IO address for
20 * @offset: BUS offset to map
23 * Managed ioremap(). Map is automatically unmapped on driver detach.
25 void __iomem
*devm_ioremap(struct device
*dev
, resource_size_t offset
,
28 void __iomem
**ptr
, *addr
;
30 ptr
= devres_alloc(devm_ioremap_release
, sizeof(*ptr
), GFP_KERNEL
);
34 addr
= ioremap(offset
, size
);
43 EXPORT_SYMBOL(devm_ioremap
);
46 * devm_ioremap_nocache - Managed ioremap_nocache()
47 * @dev: Generic device to remap IO address for
48 * @offset: BUS offset to map
51 * Managed ioremap_nocache(). Map is automatically unmapped on driver
54 void __iomem
*devm_ioremap_nocache(struct device
*dev
, resource_size_t offset
,
57 void __iomem
**ptr
, *addr
;
59 ptr
= devres_alloc(devm_ioremap_release
, sizeof(*ptr
), GFP_KERNEL
);
63 addr
= ioremap_nocache(offset
, size
);
72 EXPORT_SYMBOL(devm_ioremap_nocache
);
75 * devm_iounmap - Managed iounmap()
76 * @dev: Generic device to unmap for
77 * @addr: Address to unmap
79 * Managed iounmap(). @addr must have been mapped using devm_ioremap*().
81 void devm_iounmap(struct device
*dev
, void __iomem
*addr
)
83 WARN_ON(devres_destroy(dev
, devm_ioremap_release
, devm_ioremap_match
,
87 EXPORT_SYMBOL(devm_iounmap
);
90 * devm_ioremap_resource() - check, request region, and ioremap resource
91 * @dev: generic device to handle the resource for
92 * @res: resource to be handled
94 * Checks that a resource is a valid memory region, requests the memory region
95 * and ioremaps it either as cacheable or as non-cacheable memory depending on
96 * the resource's flags. All operations are managed and will be undone on
99 * Returns a pointer to the remapped memory or an ERR_PTR() encoded error code
100 * on failure. Usage example:
102 * res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
103 * base = devm_ioremap_resource(&pdev->dev, res);
105 * return PTR_ERR(base);
107 void __iomem
*devm_ioremap_resource(struct device
*dev
, struct resource
*res
)
109 resource_size_t size
;
111 void __iomem
*dest_ptr
;
115 if (!res
|| resource_type(res
) != IORESOURCE_MEM
) {
116 dev_err(dev
, "invalid resource\n");
117 return ERR_PTR(-EINVAL
);
120 size
= resource_size(res
);
121 name
= res
->name
?: dev_name(dev
);
123 if (!devm_request_mem_region(dev
, res
->start
, size
, name
)) {
124 dev_err(dev
, "can't request region for resource %pR\n", res
);
125 return ERR_PTR(-EBUSY
);
128 if (res
->flags
& IORESOURCE_CACHEABLE
)
129 dest_ptr
= devm_ioremap(dev
, res
->start
, size
);
131 dest_ptr
= devm_ioremap_nocache(dev
, res
->start
, size
);
134 dev_err(dev
, "ioremap failed for resource %pR\n", res
);
135 devm_release_mem_region(dev
, res
->start
, size
);
136 dest_ptr
= ERR_PTR(-ENOMEM
);
141 EXPORT_SYMBOL(devm_ioremap_resource
);
144 * devm_request_and_ioremap() - Check, request region, and ioremap resource
145 * @dev: Generic device to handle the resource for
146 * @res: resource to be handled
148 * Takes all necessary steps to ioremap a mem resource. Uses managed device, so
149 * everything is undone on driver detach. Checks arguments, so you can feed
150 * it the result from e.g. platform_get_resource() directly. Returns the
151 * remapped pointer or NULL on error. Usage example:
153 * res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
154 * base = devm_request_and_ioremap(&pdev->dev, res);
156 * return -EADDRNOTAVAIL;
158 void __iomem
*devm_request_and_ioremap(struct device
*device
,
159 struct resource
*res
)
161 void __iomem
*dest_ptr
;
163 dest_ptr
= devm_ioremap_resource(device
, res
);
164 if (IS_ERR(dest_ptr
))
169 EXPORT_SYMBOL(devm_request_and_ioremap
);
171 #ifdef CONFIG_HAS_IOPORT
173 * Generic iomap devres
175 static void devm_ioport_map_release(struct device
*dev
, void *res
)
177 ioport_unmap(*(void __iomem
**)res
);
180 static int devm_ioport_map_match(struct device
*dev
, void *res
,
183 return *(void **)res
== match_data
;
187 * devm_ioport_map - Managed ioport_map()
188 * @dev: Generic device to map ioport for
190 * @nr: Number of ports to map
192 * Managed ioport_map(). Map is automatically unmapped on driver
195 void __iomem
* devm_ioport_map(struct device
*dev
, unsigned long port
,
198 void __iomem
**ptr
, *addr
;
200 ptr
= devres_alloc(devm_ioport_map_release
, sizeof(*ptr
), GFP_KERNEL
);
204 addr
= ioport_map(port
, nr
);
207 devres_add(dev
, ptr
);
213 EXPORT_SYMBOL(devm_ioport_map
);
216 * devm_ioport_unmap - Managed ioport_unmap()
217 * @dev: Generic device to unmap for
218 * @addr: Address to unmap
220 * Managed ioport_unmap(). @addr must have been mapped using
223 void devm_ioport_unmap(struct device
*dev
, void __iomem
*addr
)
226 WARN_ON(devres_destroy(dev
, devm_ioport_map_release
,
227 devm_ioport_map_match
, (void *)addr
));
229 EXPORT_SYMBOL(devm_ioport_unmap
);
235 #define PCIM_IOMAP_MAX PCI_ROM_RESOURCE
237 struct pcim_iomap_devres
{
238 void __iomem
*table
[PCIM_IOMAP_MAX
];
241 static void pcim_iomap_release(struct device
*gendev
, void *res
)
243 struct pci_dev
*dev
= container_of(gendev
, struct pci_dev
, dev
);
244 struct pcim_iomap_devres
*this = res
;
247 for (i
= 0; i
< PCIM_IOMAP_MAX
; i
++)
249 pci_iounmap(dev
, this->table
[i
]);
253 * pcim_iomap_table - access iomap allocation table
254 * @pdev: PCI device to access iomap table for
256 * Access iomap allocation table for @dev. If iomap table doesn't
257 * exist and @pdev is managed, it will be allocated. All iomaps
258 * recorded in the iomap table are automatically unmapped on driver
261 * This function might sleep when the table is first allocated but can
262 * be safely called without context and guaranteed to succed once
265 void __iomem
* const * pcim_iomap_table(struct pci_dev
*pdev
)
267 struct pcim_iomap_devres
*dr
, *new_dr
;
269 dr
= devres_find(&pdev
->dev
, pcim_iomap_release
, NULL
, NULL
);
273 new_dr
= devres_alloc(pcim_iomap_release
, sizeof(*new_dr
), GFP_KERNEL
);
276 dr
= devres_get(&pdev
->dev
, new_dr
, NULL
, NULL
);
279 EXPORT_SYMBOL(pcim_iomap_table
);
282 * pcim_iomap - Managed pcim_iomap()
283 * @pdev: PCI device to iomap for
285 * @maxlen: Maximum length of iomap
287 * Managed pci_iomap(). Map is automatically unmapped on driver
290 void __iomem
* pcim_iomap(struct pci_dev
*pdev
, int bar
, unsigned long maxlen
)
294 BUG_ON(bar
>= PCIM_IOMAP_MAX
);
296 tbl
= (void __iomem
**)pcim_iomap_table(pdev
);
297 if (!tbl
|| tbl
[bar
]) /* duplicate mappings not allowed */
300 tbl
[bar
] = pci_iomap(pdev
, bar
, maxlen
);
303 EXPORT_SYMBOL(pcim_iomap
);
306 * pcim_iounmap - Managed pci_iounmap()
307 * @pdev: PCI device to iounmap for
308 * @addr: Address to unmap
310 * Managed pci_iounmap(). @addr must have been mapped using pcim_iomap().
312 void pcim_iounmap(struct pci_dev
*pdev
, void __iomem
*addr
)
317 pci_iounmap(pdev
, addr
);
319 tbl
= (void __iomem
**)pcim_iomap_table(pdev
);
322 for (i
= 0; i
< PCIM_IOMAP_MAX
; i
++)
323 if (tbl
[i
] == addr
) {
329 EXPORT_SYMBOL(pcim_iounmap
);
332 * pcim_iomap_regions - Request and iomap PCI BARs
333 * @pdev: PCI device to map IO resources for
334 * @mask: Mask of BARs to request and iomap
335 * @name: Name used when requesting regions
337 * Request and iomap regions specified by @mask.
339 int pcim_iomap_regions(struct pci_dev
*pdev
, int mask
, const char *name
)
341 void __iomem
* const *iomap
;
344 iomap
= pcim_iomap_table(pdev
);
348 for (i
= 0; i
< DEVICE_COUNT_RESOURCE
; i
++) {
351 if (!(mask
& (1 << i
)))
355 len
= pci_resource_len(pdev
, i
);
359 rc
= pci_request_region(pdev
, i
, name
);
364 if (!pcim_iomap(pdev
, i
, 0))
371 pci_release_region(pdev
, i
);
374 if (!(mask
& (1 << i
)))
376 pcim_iounmap(pdev
, iomap
[i
]);
377 pci_release_region(pdev
, i
);
382 EXPORT_SYMBOL(pcim_iomap_regions
);
385 * pcim_iomap_regions_request_all - Request all BARs and iomap specified ones
386 * @pdev: PCI device to map IO resources for
387 * @mask: Mask of BARs to iomap
388 * @name: Name used when requesting regions
390 * Request all PCI BARs and iomap regions specified by @mask.
392 int pcim_iomap_regions_request_all(struct pci_dev
*pdev
, int mask
,
395 int request_mask
= ((1 << 6) - 1) & ~mask
;
398 rc
= pci_request_selected_regions(pdev
, request_mask
, name
);
402 rc
= pcim_iomap_regions(pdev
, mask
, name
);
404 pci_release_selected_regions(pdev
, request_mask
);
407 EXPORT_SYMBOL(pcim_iomap_regions_request_all
);
410 * pcim_iounmap_regions - Unmap and release PCI BARs
411 * @pdev: PCI device to map IO resources for
412 * @mask: Mask of BARs to unmap and release
414 * Unmap and release regions specified by @mask.
416 void pcim_iounmap_regions(struct pci_dev
*pdev
, int mask
)
418 void __iomem
* const *iomap
;
421 iomap
= pcim_iomap_table(pdev
);
425 for (i
= 0; i
< DEVICE_COUNT_RESOURCE
; i
++) {
426 if (!(mask
& (1 << i
)))
429 pcim_iounmap(pdev
, iomap
[i
]);
430 pci_release_region(pdev
, i
);
433 EXPORT_SYMBOL(pcim_iounmap_regions
);
434 #endif /* CONFIG_PCI */
435 #endif /* CONFIG_HAS_IOPORT */