1 // SPDX-License-Identifier: GPL-2.0
6 #include <linux/export.h>
7 #include <linux/of_address.h>
9 enum devm_ioremap_type
{
16 void devm_ioremap_release(struct device
*dev
, void *res
)
18 iounmap(*(void __iomem
**)res
);
21 static int devm_ioremap_match(struct device
*dev
, void *res
, void *match_data
)
23 return *(void **)res
== match_data
;
26 static void __iomem
*__devm_ioremap(struct device
*dev
, resource_size_t offset
,
28 enum devm_ioremap_type type
)
30 void __iomem
**ptr
, *addr
= NULL
;
32 ptr
= devres_alloc_node(devm_ioremap_release
, sizeof(*ptr
), GFP_KERNEL
,
39 addr
= ioremap(offset
, size
);
42 addr
= ioremap_uc(offset
, size
);
45 addr
= ioremap_wc(offset
, size
);
48 addr
= ioremap_np(offset
, size
);
62 * devm_ioremap - Managed ioremap()
63 * @dev: Generic device to remap IO address for
64 * @offset: Resource address to map
67 * Managed ioremap(). Map is automatically unmapped on driver detach.
69 void __iomem
*devm_ioremap(struct device
*dev
, resource_size_t offset
,
72 return __devm_ioremap(dev
, offset
, size
, DEVM_IOREMAP
);
74 EXPORT_SYMBOL(devm_ioremap
);
77 * devm_ioremap_uc - Managed ioremap_uc()
78 * @dev: Generic device to remap IO address for
79 * @offset: Resource address to map
82 * Managed ioremap_uc(). Map is automatically unmapped on driver detach.
84 void __iomem
*devm_ioremap_uc(struct device
*dev
, resource_size_t offset
,
87 return __devm_ioremap(dev
, offset
, size
, DEVM_IOREMAP_UC
);
89 EXPORT_SYMBOL_GPL(devm_ioremap_uc
);
92 * devm_ioremap_wc - Managed ioremap_wc()
93 * @dev: Generic device to remap IO address for
94 * @offset: Resource address to map
97 * Managed ioremap_wc(). Map is automatically unmapped on driver detach.
99 void __iomem
*devm_ioremap_wc(struct device
*dev
, resource_size_t offset
,
100 resource_size_t size
)
102 return __devm_ioremap(dev
, offset
, size
, DEVM_IOREMAP_WC
);
104 EXPORT_SYMBOL(devm_ioremap_wc
);
107 * devm_iounmap - Managed iounmap()
108 * @dev: Generic device to unmap for
109 * @addr: Address to unmap
111 * Managed iounmap(). @addr must have been mapped using devm_ioremap*().
113 void devm_iounmap(struct device
*dev
, void __iomem
*addr
)
115 WARN_ON(devres_destroy(dev
, devm_ioremap_release
, devm_ioremap_match
,
116 (__force
void *)addr
));
119 EXPORT_SYMBOL(devm_iounmap
);
121 static void __iomem
*
122 __devm_ioremap_resource(struct device
*dev
, const struct resource
*res
,
123 enum devm_ioremap_type type
)
125 resource_size_t size
;
126 void __iomem
*dest_ptr
;
131 if (!res
|| resource_type(res
) != IORESOURCE_MEM
) {
132 dev_err(dev
, "invalid resource %pR\n", res
);
133 return IOMEM_ERR_PTR(-EINVAL
);
136 if (type
== DEVM_IOREMAP
&& res
->flags
& IORESOURCE_MEM_NONPOSTED
)
137 type
= DEVM_IOREMAP_NP
;
139 size
= resource_size(res
);
142 pretty_name
= devm_kasprintf(dev
, GFP_KERNEL
, "%s %s",
143 dev_name(dev
), res
->name
);
145 pretty_name
= devm_kstrdup(dev
, dev_name(dev
), GFP_KERNEL
);
147 dev_err(dev
, "can't generate pretty name for resource %pR\n", res
);
148 return IOMEM_ERR_PTR(-ENOMEM
);
151 if (!devm_request_mem_region(dev
, res
->start
, size
, pretty_name
)) {
152 dev_err(dev
, "can't request region for resource %pR\n", res
);
153 return IOMEM_ERR_PTR(-EBUSY
);
156 dest_ptr
= __devm_ioremap(dev
, res
->start
, size
, type
);
158 dev_err(dev
, "ioremap failed for resource %pR\n", res
);
159 devm_release_mem_region(dev
, res
->start
, size
);
160 dest_ptr
= IOMEM_ERR_PTR(-ENOMEM
);
167 * devm_ioremap_resource() - check, request region, and ioremap resource
168 * @dev: generic device to handle the resource for
169 * @res: resource to be handled
171 * Checks that a resource is a valid memory region, requests the memory
172 * region and ioremaps it. All operations are managed and will be undone
177 * res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
178 * base = devm_ioremap_resource(&pdev->dev, res);
180 * return PTR_ERR(base);
182 * Return: a pointer to the remapped memory or an ERR_PTR() encoded error code
185 void __iomem
*devm_ioremap_resource(struct device
*dev
,
186 const struct resource
*res
)
188 return __devm_ioremap_resource(dev
, res
, DEVM_IOREMAP
);
190 EXPORT_SYMBOL(devm_ioremap_resource
);
193 * devm_ioremap_resource_wc() - write-combined variant of
194 * devm_ioremap_resource()
195 * @dev: generic device to handle the resource for
196 * @res: resource to be handled
198 * Return: a pointer to the remapped memory or an ERR_PTR() encoded error code
201 void __iomem
*devm_ioremap_resource_wc(struct device
*dev
,
202 const struct resource
*res
)
204 return __devm_ioremap_resource(dev
, res
, DEVM_IOREMAP_WC
);
208 * devm_of_iomap - Requests a resource and maps the memory mapped IO
209 * for a given device_node managed by a given device
211 * Checks that a resource is a valid memory region, requests the memory
212 * region and ioremaps it. All operations are managed and will be undone
213 * on driver detach of the device.
215 * This is to be used when a device requests/maps resources described
216 * by other device tree nodes (children or otherwise).
218 * @dev: The device "managing" the resource
219 * @node: The device-tree node where the resource resides
220 * @index: index of the MMIO range in the "reg" property
221 * @size: Returns the size of the resource (pass NULL if not needed)
225 * base = devm_of_iomap(&pdev->dev, node, 0, NULL);
227 * return PTR_ERR(base);
229 * Please Note: This is not a one-to-one replacement for of_iomap() because the
230 * of_iomap() function does not track whether the region is already mapped. If
231 * two drivers try to map the same memory, the of_iomap() function will succeed
232 * but the devm_of_iomap() function will return -EBUSY.
234 * Return: a pointer to the requested and mapped memory or an ERR_PTR() encoded
235 * error code on failure.
237 void __iomem
*devm_of_iomap(struct device
*dev
, struct device_node
*node
, int index
,
238 resource_size_t
*size
)
242 if (of_address_to_resource(node
, index
, &res
))
243 return IOMEM_ERR_PTR(-EINVAL
);
245 *size
= resource_size(&res
);
246 return devm_ioremap_resource(dev
, &res
);
248 EXPORT_SYMBOL(devm_of_iomap
);
250 #ifdef CONFIG_HAS_IOPORT_MAP
252 * Generic iomap devres
254 static void devm_ioport_map_release(struct device
*dev
, void *res
)
256 ioport_unmap(*(void __iomem
**)res
);
259 static int devm_ioport_map_match(struct device
*dev
, void *res
,
262 return *(void **)res
== match_data
;
266 * devm_ioport_map - Managed ioport_map()
267 * @dev: Generic device to map ioport for
269 * @nr: Number of ports to map
271 * Managed ioport_map(). Map is automatically unmapped on driver
274 * Return: a pointer to the remapped memory or NULL on failure.
276 void __iomem
*devm_ioport_map(struct device
*dev
, unsigned long port
,
279 void __iomem
**ptr
, *addr
;
281 ptr
= devres_alloc_node(devm_ioport_map_release
, sizeof(*ptr
), GFP_KERNEL
,
286 addr
= ioport_map(port
, nr
);
289 devres_add(dev
, ptr
);
295 EXPORT_SYMBOL(devm_ioport_map
);
298 * devm_ioport_unmap - Managed ioport_unmap()
299 * @dev: Generic device to unmap for
300 * @addr: Address to unmap
302 * Managed ioport_unmap(). @addr must have been mapped using
305 void devm_ioport_unmap(struct device
*dev
, void __iomem
*addr
)
308 WARN_ON(devres_destroy(dev
, devm_ioport_map_release
,
309 devm_ioport_map_match
, (__force
void *)addr
));
311 EXPORT_SYMBOL(devm_ioport_unmap
);
312 #endif /* CONFIG_HAS_IOPORT_MAP */
318 #define PCIM_IOMAP_MAX PCI_STD_NUM_BARS
320 struct pcim_iomap_devres
{
321 void __iomem
*table
[PCIM_IOMAP_MAX
];
324 static void pcim_iomap_release(struct device
*gendev
, void *res
)
326 struct pci_dev
*dev
= to_pci_dev(gendev
);
327 struct pcim_iomap_devres
*this = res
;
330 for (i
= 0; i
< PCIM_IOMAP_MAX
; i
++)
332 pci_iounmap(dev
, this->table
[i
]);
336 * pcim_iomap_table - access iomap allocation table
337 * @pdev: PCI device to access iomap table for
339 * Access iomap allocation table for @dev. If iomap table doesn't
340 * exist and @pdev is managed, it will be allocated. All iomaps
341 * recorded in the iomap table are automatically unmapped on driver
344 * This function might sleep when the table is first allocated but can
345 * be safely called without context and guaranteed to succeed once
348 void __iomem
* const *pcim_iomap_table(struct pci_dev
*pdev
)
350 struct pcim_iomap_devres
*dr
, *new_dr
;
352 dr
= devres_find(&pdev
->dev
, pcim_iomap_release
, NULL
, NULL
);
356 new_dr
= devres_alloc_node(pcim_iomap_release
, sizeof(*new_dr
), GFP_KERNEL
,
357 dev_to_node(&pdev
->dev
));
360 dr
= devres_get(&pdev
->dev
, new_dr
, NULL
, NULL
);
363 EXPORT_SYMBOL(pcim_iomap_table
);
366 * pcim_iomap - Managed pcim_iomap()
367 * @pdev: PCI device to iomap for
369 * @maxlen: Maximum length of iomap
371 * Managed pci_iomap(). Map is automatically unmapped on driver
374 void __iomem
*pcim_iomap(struct pci_dev
*pdev
, int bar
, unsigned long maxlen
)
378 BUG_ON(bar
>= PCIM_IOMAP_MAX
);
380 tbl
= (void __iomem
**)pcim_iomap_table(pdev
);
381 if (!tbl
|| tbl
[bar
]) /* duplicate mappings not allowed */
384 tbl
[bar
] = pci_iomap(pdev
, bar
, maxlen
);
387 EXPORT_SYMBOL(pcim_iomap
);
390 * pcim_iounmap - Managed pci_iounmap()
391 * @pdev: PCI device to iounmap for
392 * @addr: Address to unmap
394 * Managed pci_iounmap(). @addr must have been mapped using pcim_iomap().
396 void pcim_iounmap(struct pci_dev
*pdev
, void __iomem
*addr
)
401 pci_iounmap(pdev
, addr
);
403 tbl
= (void __iomem
**)pcim_iomap_table(pdev
);
406 for (i
= 0; i
< PCIM_IOMAP_MAX
; i
++)
407 if (tbl
[i
] == addr
) {
413 EXPORT_SYMBOL(pcim_iounmap
);
416 * pcim_iomap_regions - Request and iomap PCI BARs
417 * @pdev: PCI device to map IO resources for
418 * @mask: Mask of BARs to request and iomap
419 * @name: Name used when requesting regions
421 * Request and iomap regions specified by @mask.
423 int pcim_iomap_regions(struct pci_dev
*pdev
, int mask
, const char *name
)
425 void __iomem
* const *iomap
;
428 iomap
= pcim_iomap_table(pdev
);
432 for (i
= 0; i
< DEVICE_COUNT_RESOURCE
; i
++) {
435 if (!(mask
& (1 << i
)))
439 len
= pci_resource_len(pdev
, i
);
443 rc
= pci_request_region(pdev
, i
, name
);
448 if (!pcim_iomap(pdev
, i
, 0))
455 pci_release_region(pdev
, i
);
458 if (!(mask
& (1 << i
)))
460 pcim_iounmap(pdev
, iomap
[i
]);
461 pci_release_region(pdev
, i
);
466 EXPORT_SYMBOL(pcim_iomap_regions
);
469 * pcim_iomap_regions_request_all - Request all BARs and iomap specified ones
470 * @pdev: PCI device to map IO resources for
471 * @mask: Mask of BARs to iomap
472 * @name: Name used when requesting regions
474 * Request all PCI BARs and iomap regions specified by @mask.
476 int pcim_iomap_regions_request_all(struct pci_dev
*pdev
, int mask
,
479 int request_mask
= ((1 << 6) - 1) & ~mask
;
482 rc
= pci_request_selected_regions(pdev
, request_mask
, name
);
486 rc
= pcim_iomap_regions(pdev
, mask
, name
);
488 pci_release_selected_regions(pdev
, request_mask
);
491 EXPORT_SYMBOL(pcim_iomap_regions_request_all
);
494 * pcim_iounmap_regions - Unmap and release PCI BARs
495 * @pdev: PCI device to map IO resources for
496 * @mask: Mask of BARs to unmap and release
498 * Unmap and release regions specified by @mask.
500 void pcim_iounmap_regions(struct pci_dev
*pdev
, int mask
)
502 void __iomem
* const *iomap
;
505 iomap
= pcim_iomap_table(pdev
);
509 for (i
= 0; i
< PCIM_IOMAP_MAX
; i
++) {
510 if (!(mask
& (1 << i
)))
513 pcim_iounmap(pdev
, iomap
[i
]);
514 pci_release_region(pdev
, i
);
517 EXPORT_SYMBOL(pcim_iounmap_regions
);
518 #endif /* CONFIG_PCI */
520 static void devm_arch_phys_ac_add_release(struct device
*dev
, void *res
)
522 arch_phys_wc_del(*((int *)res
));
526 * devm_arch_phys_wc_add - Managed arch_phys_wc_add()
527 * @dev: Managed device
528 * @base: Memory base address
529 * @size: Size of memory range
531 * Adds a WC MTRR using arch_phys_wc_add() and sets up a release callback.
532 * See arch_phys_wc_add() for more information.
534 int devm_arch_phys_wc_add(struct device
*dev
, unsigned long base
, unsigned long size
)
539 mtrr
= devres_alloc_node(devm_arch_phys_ac_add_release
, sizeof(*mtrr
), GFP_KERNEL
,
544 ret
= arch_phys_wc_add(base
, size
);
551 devres_add(dev
, mtrr
);
555 EXPORT_SYMBOL(devm_arch_phys_wc_add
);
557 struct arch_io_reserve_memtype_wc_devres
{
558 resource_size_t start
;
559 resource_size_t size
;
562 static void devm_arch_io_free_memtype_wc_release(struct device
*dev
, void *res
)
564 const struct arch_io_reserve_memtype_wc_devres
*this = res
;
566 arch_io_free_memtype_wc(this->start
, this->size
);
570 * devm_arch_io_reserve_memtype_wc - Managed arch_io_reserve_memtype_wc()
571 * @dev: Managed device
572 * @start: Memory base address
573 * @size: Size of memory range
575 * Reserves a memory range with WC caching using arch_io_reserve_memtype_wc()
576 * and sets up a release callback See arch_io_reserve_memtype_wc() for more
579 int devm_arch_io_reserve_memtype_wc(struct device
*dev
, resource_size_t start
,
580 resource_size_t size
)
582 struct arch_io_reserve_memtype_wc_devres
*dr
;
585 dr
= devres_alloc_node(devm_arch_io_free_memtype_wc_release
, sizeof(*dr
), GFP_KERNEL
,
590 ret
= arch_io_reserve_memtype_wc(start
, size
);
602 EXPORT_SYMBOL(devm_arch_io_reserve_memtype_wc
);