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