1 // SPDX-License-Identifier: GPL-2.0
2 #include <linux/device.h>
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 */
314 static void devm_arch_phys_ac_add_release(struct device
*dev
, void *res
)
316 arch_phys_wc_del(*((int *)res
));
320 * devm_arch_phys_wc_add - Managed arch_phys_wc_add()
321 * @dev: Managed device
322 * @base: Memory base address
323 * @size: Size of memory range
325 * Adds a WC MTRR using arch_phys_wc_add() and sets up a release callback.
326 * See arch_phys_wc_add() for more information.
328 int devm_arch_phys_wc_add(struct device
*dev
, unsigned long base
, unsigned long size
)
333 mtrr
= devres_alloc_node(devm_arch_phys_ac_add_release
, sizeof(*mtrr
), GFP_KERNEL
,
338 ret
= arch_phys_wc_add(base
, size
);
345 devres_add(dev
, mtrr
);
349 EXPORT_SYMBOL(devm_arch_phys_wc_add
);
351 struct arch_io_reserve_memtype_wc_devres
{
352 resource_size_t start
;
353 resource_size_t size
;
356 static void devm_arch_io_free_memtype_wc_release(struct device
*dev
, void *res
)
358 const struct arch_io_reserve_memtype_wc_devres
*this = res
;
360 arch_io_free_memtype_wc(this->start
, this->size
);
364 * devm_arch_io_reserve_memtype_wc - Managed arch_io_reserve_memtype_wc()
365 * @dev: Managed device
366 * @start: Memory base address
367 * @size: Size of memory range
369 * Reserves a memory range with WC caching using arch_io_reserve_memtype_wc()
370 * and sets up a release callback See arch_io_reserve_memtype_wc() for more
373 int devm_arch_io_reserve_memtype_wc(struct device
*dev
, resource_size_t start
,
374 resource_size_t size
)
376 struct arch_io_reserve_memtype_wc_devres
*dr
;
379 dr
= devres_alloc_node(devm_arch_io_free_memtype_wc_release
, sizeof(*dr
), GFP_KERNEL
,
384 ret
= arch_io_reserve_memtype_wc(start
, size
);
396 EXPORT_SYMBOL(devm_arch_io_reserve_memtype_wc
);