Loading...
Note: File does not exist in v3.1.
1// SPDX-License-Identifier: GPL-2.0
2#include <linux/device.h>
3#include <linux/pci.h>
4#include "pci.h"
5
6/*
7 * On the state of PCI's devres implementation:
8 *
9 * The older devres API for PCI has two significant problems:
10 *
11 * 1. It is very strongly tied to the statically allocated mapping table in
12 * struct pcim_iomap_devres below. This is mostly solved in the sense of the
13 * pcim_ functions in this file providing things like ranged mapping by
14 * bypassing this table, whereas the functions that were present in the old
15 * API still enter the mapping addresses into the table for users of the old
16 * API.
17 *
18 * 2. The region-request-functions in pci.c do become managed IF the device has
19 * been enabled with pcim_enable_device() instead of pci_enable_device().
20 * This resulted in the API becoming inconsistent: Some functions have an
21 * obviously managed counter-part (e.g., pci_iomap() <-> pcim_iomap()),
22 * whereas some don't and are never managed, while others don't and are
23 * _sometimes_ managed (e.g. pci_request_region()).
24 *
25 * Consequently, in the new API, region requests performed by the pcim_
26 * functions are automatically cleaned up through the devres callback
27 * pcim_addr_resource_release().
28 *
29 * Users of pcim_enable_device() + pci_*region*() are redirected in
30 * pci.c to the managed functions here in this file. This isn't exactly
31 * perfect, but the only alternative way would be to port ALL drivers
32 * using said combination to pcim_ functions.
33 *
34 * TODO:
35 * Remove the legacy table entirely once all calls to pcim_iomap_table() in
36 * the kernel have been removed.
37 */
38
39/*
40 * Legacy struct storing addresses to whole mapped BARs.
41 */
42struct pcim_iomap_devres {
43 void __iomem *table[PCI_STD_NUM_BARS];
44};
45
46/* Used to restore the old INTx state on driver detach. */
47struct pcim_intx_devres {
48 int orig_intx;
49};
50
51enum pcim_addr_devres_type {
52 /* Default initializer. */
53 PCIM_ADDR_DEVRES_TYPE_INVALID,
54
55 /* A requested region spanning an entire BAR. */
56 PCIM_ADDR_DEVRES_TYPE_REGION,
57
58 /*
59 * A requested region spanning an entire BAR, and a mapping for
60 * the entire BAR.
61 */
62 PCIM_ADDR_DEVRES_TYPE_REGION_MAPPING,
63
64 /*
65 * A mapping within a BAR, either spanning the whole BAR or just a
66 * range. Without a requested region.
67 */
68 PCIM_ADDR_DEVRES_TYPE_MAPPING,
69};
70
71/*
72 * This struct envelops IO or MEM addresses, i.e., mappings and region
73 * requests, because those are very frequently requested and released
74 * together.
75 */
76struct pcim_addr_devres {
77 enum pcim_addr_devres_type type;
78 void __iomem *baseaddr;
79 unsigned long offset;
80 unsigned long len;
81 int bar;
82};
83
84static inline void pcim_addr_devres_clear(struct pcim_addr_devres *res)
85{
86 memset(res, 0, sizeof(*res));
87 res->bar = -1;
88}
89
90/*
91 * The following functions, __pcim_*_region*, exist as counterparts to the
92 * versions from pci.c - which, unfortunately, can be in "hybrid mode", i.e.,
93 * sometimes managed, sometimes not.
94 *
95 * To separate the APIs cleanly, we define our own, simplified versions here.
96 */
97
98/**
99 * __pcim_request_region_range - Request a ranged region
100 * @pdev: PCI device the region belongs to
101 * @bar: BAR the range is within
102 * @offset: offset from the BAR's start address
103 * @maxlen: length in bytes, beginning at @offset
104 * @name: name associated with the request
105 * @req_flags: flags for the request, e.g., for kernel-exclusive requests
106 *
107 * Returns: 0 on success, a negative error code on failure.
108 *
109 * Request a range within a device's PCI BAR. Sanity check the input.
110 */
111static int __pcim_request_region_range(struct pci_dev *pdev, int bar,
112 unsigned long offset,
113 unsigned long maxlen,
114 const char *name, int req_flags)
115{
116 resource_size_t start = pci_resource_start(pdev, bar);
117 resource_size_t len = pci_resource_len(pdev, bar);
118 unsigned long dev_flags = pci_resource_flags(pdev, bar);
119
120 if (start == 0 || len == 0) /* Unused BAR. */
121 return 0;
122 if (len <= offset)
123 return -EINVAL;
124
125 start += offset;
126 len -= offset;
127
128 if (len > maxlen && maxlen != 0)
129 len = maxlen;
130
131 if (dev_flags & IORESOURCE_IO) {
132 if (!request_region(start, len, name))
133 return -EBUSY;
134 } else if (dev_flags & IORESOURCE_MEM) {
135 if (!__request_mem_region(start, len, name, req_flags))
136 return -EBUSY;
137 } else {
138 /* That's not a device we can request anything on. */
139 return -ENODEV;
140 }
141
142 return 0;
143}
144
145static void __pcim_release_region_range(struct pci_dev *pdev, int bar,
146 unsigned long offset,
147 unsigned long maxlen)
148{
149 resource_size_t start = pci_resource_start(pdev, bar);
150 resource_size_t len = pci_resource_len(pdev, bar);
151 unsigned long flags = pci_resource_flags(pdev, bar);
152
153 if (len <= offset || start == 0)
154 return;
155
156 if (len == 0 || maxlen == 0) /* This an unused BAR. Do nothing. */
157 return;
158
159 start += offset;
160 len -= offset;
161
162 if (len > maxlen)
163 len = maxlen;
164
165 if (flags & IORESOURCE_IO)
166 release_region(start, len);
167 else if (flags & IORESOURCE_MEM)
168 release_mem_region(start, len);
169}
170
171static int __pcim_request_region(struct pci_dev *pdev, int bar,
172 const char *name, int flags)
173{
174 unsigned long offset = 0;
175 unsigned long len = pci_resource_len(pdev, bar);
176
177 return __pcim_request_region_range(pdev, bar, offset, len, name, flags);
178}
179
180static void __pcim_release_region(struct pci_dev *pdev, int bar)
181{
182 unsigned long offset = 0;
183 unsigned long len = pci_resource_len(pdev, bar);
184
185 __pcim_release_region_range(pdev, bar, offset, len);
186}
187
188static void pcim_addr_resource_release(struct device *dev, void *resource_raw)
189{
190 struct pci_dev *pdev = to_pci_dev(dev);
191 struct pcim_addr_devres *res = resource_raw;
192
193 switch (res->type) {
194 case PCIM_ADDR_DEVRES_TYPE_REGION:
195 __pcim_release_region(pdev, res->bar);
196 break;
197 case PCIM_ADDR_DEVRES_TYPE_REGION_MAPPING:
198 pci_iounmap(pdev, res->baseaddr);
199 __pcim_release_region(pdev, res->bar);
200 break;
201 case PCIM_ADDR_DEVRES_TYPE_MAPPING:
202 pci_iounmap(pdev, res->baseaddr);
203 break;
204 default:
205 break;
206 }
207}
208
209static struct pcim_addr_devres *pcim_addr_devres_alloc(struct pci_dev *pdev)
210{
211 struct pcim_addr_devres *res;
212
213 res = devres_alloc_node(pcim_addr_resource_release, sizeof(*res),
214 GFP_KERNEL, dev_to_node(&pdev->dev));
215 if (res)
216 pcim_addr_devres_clear(res);
217 return res;
218}
219
220/* Just for consistency and readability. */
221static inline void pcim_addr_devres_free(struct pcim_addr_devres *res)
222{
223 devres_free(res);
224}
225
226/*
227 * Used by devres to identify a pcim_addr_devres.
228 */
229static int pcim_addr_resources_match(struct device *dev,
230 void *a_raw, void *b_raw)
231{
232 struct pcim_addr_devres *a, *b;
233
234 a = a_raw;
235 b = b_raw;
236
237 if (a->type != b->type)
238 return 0;
239
240 switch (a->type) {
241 case PCIM_ADDR_DEVRES_TYPE_REGION:
242 case PCIM_ADDR_DEVRES_TYPE_REGION_MAPPING:
243 return a->bar == b->bar;
244 case PCIM_ADDR_DEVRES_TYPE_MAPPING:
245 return a->baseaddr == b->baseaddr;
246 default:
247 return 0;
248 }
249}
250
251static void devm_pci_unmap_iospace(struct device *dev, void *ptr)
252{
253 struct resource **res = ptr;
254
255 pci_unmap_iospace(*res);
256}
257
258/**
259 * devm_pci_remap_iospace - Managed pci_remap_iospace()
260 * @dev: Generic device to remap IO address for
261 * @res: Resource describing the I/O space
262 * @phys_addr: physical address of range to be mapped
263 *
264 * Managed pci_remap_iospace(). Map is automatically unmapped on driver
265 * detach.
266 */
267int devm_pci_remap_iospace(struct device *dev, const struct resource *res,
268 phys_addr_t phys_addr)
269{
270 const struct resource **ptr;
271 int error;
272
273 ptr = devres_alloc(devm_pci_unmap_iospace, sizeof(*ptr), GFP_KERNEL);
274 if (!ptr)
275 return -ENOMEM;
276
277 error = pci_remap_iospace(res, phys_addr);
278 if (error) {
279 devres_free(ptr);
280 } else {
281 *ptr = res;
282 devres_add(dev, ptr);
283 }
284
285 return error;
286}
287EXPORT_SYMBOL(devm_pci_remap_iospace);
288
289/**
290 * devm_pci_remap_cfgspace - Managed pci_remap_cfgspace()
291 * @dev: Generic device to remap IO address for
292 * @offset: Resource address to map
293 * @size: Size of map
294 *
295 * Managed pci_remap_cfgspace(). Map is automatically unmapped on driver
296 * detach.
297 */
298void __iomem *devm_pci_remap_cfgspace(struct device *dev,
299 resource_size_t offset,
300 resource_size_t size)
301{
302 void __iomem **ptr, *addr;
303
304 ptr = devres_alloc(devm_ioremap_release, sizeof(*ptr), GFP_KERNEL);
305 if (!ptr)
306 return NULL;
307
308 addr = pci_remap_cfgspace(offset, size);
309 if (addr) {
310 *ptr = addr;
311 devres_add(dev, ptr);
312 } else
313 devres_free(ptr);
314
315 return addr;
316}
317EXPORT_SYMBOL(devm_pci_remap_cfgspace);
318
319/**
320 * devm_pci_remap_cfg_resource - check, request region and ioremap cfg resource
321 * @dev: generic device to handle the resource for
322 * @res: configuration space resource to be handled
323 *
324 * Checks that a resource is a valid memory region, requests the memory
325 * region and ioremaps with pci_remap_cfgspace() API that ensures the
326 * proper PCI configuration space memory attributes are guaranteed.
327 *
328 * All operations are managed and will be undone on driver detach.
329 *
330 * Returns a pointer to the remapped memory or an IOMEM_ERR_PTR() encoded error
331 * code on failure. Usage example::
332 *
333 * res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
334 * base = devm_pci_remap_cfg_resource(&pdev->dev, res);
335 * if (IS_ERR(base))
336 * return PTR_ERR(base);
337 */
338void __iomem *devm_pci_remap_cfg_resource(struct device *dev,
339 struct resource *res)
340{
341 resource_size_t size;
342 const char *name;
343 void __iomem *dest_ptr;
344
345 BUG_ON(!dev);
346
347 if (!res || resource_type(res) != IORESOURCE_MEM) {
348 dev_err(dev, "invalid resource\n");
349 return IOMEM_ERR_PTR(-EINVAL);
350 }
351
352 size = resource_size(res);
353
354 if (res->name)
355 name = devm_kasprintf(dev, GFP_KERNEL, "%s %s", dev_name(dev),
356 res->name);
357 else
358 name = devm_kstrdup(dev, dev_name(dev), GFP_KERNEL);
359 if (!name)
360 return IOMEM_ERR_PTR(-ENOMEM);
361
362 if (!devm_request_mem_region(dev, res->start, size, name)) {
363 dev_err(dev, "can't request region for resource %pR\n", res);
364 return IOMEM_ERR_PTR(-EBUSY);
365 }
366
367 dest_ptr = devm_pci_remap_cfgspace(dev, res->start, size);
368 if (!dest_ptr) {
369 dev_err(dev, "ioremap failed for resource %pR\n", res);
370 devm_release_mem_region(dev, res->start, size);
371 dest_ptr = IOMEM_ERR_PTR(-ENOMEM);
372 }
373
374 return dest_ptr;
375}
376EXPORT_SYMBOL(devm_pci_remap_cfg_resource);
377
378static void __pcim_clear_mwi(void *pdev_raw)
379{
380 struct pci_dev *pdev = pdev_raw;
381
382 pci_clear_mwi(pdev);
383}
384
385/**
386 * pcim_set_mwi - a device-managed pci_set_mwi()
387 * @pdev: the PCI device for which MWI is enabled
388 *
389 * Managed pci_set_mwi().
390 *
391 * RETURNS: An appropriate -ERRNO error value on error, or zero for success.
392 */
393int pcim_set_mwi(struct pci_dev *pdev)
394{
395 int ret;
396
397 ret = devm_add_action(&pdev->dev, __pcim_clear_mwi, pdev);
398 if (ret != 0)
399 return ret;
400
401 ret = pci_set_mwi(pdev);
402 if (ret != 0)
403 devm_remove_action(&pdev->dev, __pcim_clear_mwi, pdev);
404
405 return ret;
406}
407EXPORT_SYMBOL(pcim_set_mwi);
408
409static inline bool mask_contains_bar(int mask, int bar)
410{
411 return mask & BIT(bar);
412}
413
414static void pcim_intx_restore(struct device *dev, void *data)
415{
416 struct pci_dev *pdev = to_pci_dev(dev);
417 struct pcim_intx_devres *res = data;
418
419 pci_intx(pdev, res->orig_intx);
420}
421
422static void save_orig_intx(struct pci_dev *pdev, struct pcim_intx_devres *res)
423{
424 u16 pci_command;
425
426 pci_read_config_word(pdev, PCI_COMMAND, &pci_command);
427 res->orig_intx = !(pci_command & PCI_COMMAND_INTX_DISABLE);
428}
429
430/**
431 * pcim_intx - managed pci_intx()
432 * @pdev: the PCI device to operate on
433 * @enable: boolean: whether to enable or disable PCI INTx
434 *
435 * Returns: 0 on success, -ENOMEM on error.
436 *
437 * Enable/disable PCI INTx for device @pdev.
438 * Restore the original state on driver detach.
439 */
440int pcim_intx(struct pci_dev *pdev, int enable)
441{
442 struct pcim_intx_devres *res;
443 struct device *dev = &pdev->dev;
444
445 /*
446 * pcim_intx() must only restore the INTx value that existed before the
447 * driver was loaded, i.e., before it called pcim_intx() for the
448 * first time.
449 */
450 res = devres_find(dev, pcim_intx_restore, NULL, NULL);
451 if (!res) {
452 res = devres_alloc(pcim_intx_restore, sizeof(*res), GFP_KERNEL);
453 if (!res)
454 return -ENOMEM;
455
456 save_orig_intx(pdev, res);
457 devres_add(dev, res);
458 }
459
460 pci_intx(pdev, enable);
461
462 return 0;
463}
464EXPORT_SYMBOL_GPL(pcim_intx);
465
466static void pcim_disable_device(void *pdev_raw)
467{
468 struct pci_dev *pdev = pdev_raw;
469
470 if (!pdev->pinned)
471 pci_disable_device(pdev);
472
473 pdev->is_managed = false;
474}
475
476/**
477 * pcim_enable_device - Managed pci_enable_device()
478 * @pdev: PCI device to be initialized
479 *
480 * Returns: 0 on success, negative error code on failure.
481 *
482 * Managed pci_enable_device(). Device will automatically be disabled on
483 * driver detach.
484 */
485int pcim_enable_device(struct pci_dev *pdev)
486{
487 int ret;
488
489 ret = devm_add_action(&pdev->dev, pcim_disable_device, pdev);
490 if (ret != 0)
491 return ret;
492
493 /*
494 * We prefer removing the action in case of an error over
495 * devm_add_action_or_reset() because the latter could theoretically be
496 * disturbed by users having pinned the device too soon.
497 */
498 ret = pci_enable_device(pdev);
499 if (ret != 0) {
500 devm_remove_action(&pdev->dev, pcim_disable_device, pdev);
501 return ret;
502 }
503
504 pdev->is_managed = true;
505
506 return ret;
507}
508EXPORT_SYMBOL(pcim_enable_device);
509
510/**
511 * pcim_pin_device - Pin managed PCI device
512 * @pdev: PCI device to pin
513 *
514 * Pin managed PCI device @pdev. Pinned device won't be disabled on driver
515 * detach. @pdev must have been enabled with pcim_enable_device().
516 */
517void pcim_pin_device(struct pci_dev *pdev)
518{
519 pdev->pinned = true;
520}
521EXPORT_SYMBOL(pcim_pin_device);
522
523static void pcim_iomap_release(struct device *gendev, void *res)
524{
525 /*
526 * Do nothing. This is legacy code.
527 *
528 * Cleanup of the mappings is now done directly through the callbacks
529 * registered when creating them.
530 */
531}
532
533/**
534 * pcim_iomap_table - access iomap allocation table (DEPRECATED)
535 * @pdev: PCI device to access iomap table for
536 *
537 * Returns:
538 * Const pointer to array of __iomem pointers on success, NULL on failure.
539 *
540 * Access iomap allocation table for @dev. If iomap table doesn't
541 * exist and @pdev is managed, it will be allocated. All iomaps
542 * recorded in the iomap table are automatically unmapped on driver
543 * detach.
544 *
545 * This function might sleep when the table is first allocated but can
546 * be safely called without context and guaranteed to succeed once
547 * allocated.
548 *
549 * This function is DEPRECATED. Do not use it in new code. Instead, obtain a
550 * mapping's address directly from one of the pcim_* mapping functions. For
551 * example:
552 * void __iomem \*mappy = pcim_iomap(pdev, bar, length);
553 */
554void __iomem * const *pcim_iomap_table(struct pci_dev *pdev)
555{
556 struct pcim_iomap_devres *dr, *new_dr;
557
558 dr = devres_find(&pdev->dev, pcim_iomap_release, NULL, NULL);
559 if (dr)
560 return dr->table;
561
562 new_dr = devres_alloc_node(pcim_iomap_release, sizeof(*new_dr), GFP_KERNEL,
563 dev_to_node(&pdev->dev));
564 if (!new_dr)
565 return NULL;
566 dr = devres_get(&pdev->dev, new_dr, NULL, NULL);
567 return dr->table;
568}
569EXPORT_SYMBOL(pcim_iomap_table);
570
571/*
572 * Fill the legacy mapping-table, so that drivers using the old API can
573 * still get a BAR's mapping address through pcim_iomap_table().
574 */
575static int pcim_add_mapping_to_legacy_table(struct pci_dev *pdev,
576 void __iomem *mapping, int bar)
577{
578 void __iomem **legacy_iomap_table;
579
580 if (bar >= PCI_STD_NUM_BARS)
581 return -EINVAL;
582
583 legacy_iomap_table = (void __iomem **)pcim_iomap_table(pdev);
584 if (!legacy_iomap_table)
585 return -ENOMEM;
586
587 /* The legacy mechanism doesn't allow for duplicate mappings. */
588 WARN_ON(legacy_iomap_table[bar]);
589
590 legacy_iomap_table[bar] = mapping;
591
592 return 0;
593}
594
595/*
596 * Remove a mapping. The table only contains whole-BAR mappings, so this will
597 * never interfere with ranged mappings.
598 */
599static void pcim_remove_mapping_from_legacy_table(struct pci_dev *pdev,
600 void __iomem *addr)
601{
602 int bar;
603 void __iomem **legacy_iomap_table;
604
605 legacy_iomap_table = (void __iomem **)pcim_iomap_table(pdev);
606 if (!legacy_iomap_table)
607 return;
608
609 for (bar = 0; bar < PCI_STD_NUM_BARS; bar++) {
610 if (legacy_iomap_table[bar] == addr) {
611 legacy_iomap_table[bar] = NULL;
612 return;
613 }
614 }
615}
616
617/*
618 * The same as pcim_remove_mapping_from_legacy_table(), but identifies the
619 * mapping by its BAR index.
620 */
621static void pcim_remove_bar_from_legacy_table(struct pci_dev *pdev, int bar)
622{
623 void __iomem **legacy_iomap_table;
624
625 if (bar >= PCI_STD_NUM_BARS)
626 return;
627
628 legacy_iomap_table = (void __iomem **)pcim_iomap_table(pdev);
629 if (!legacy_iomap_table)
630 return;
631
632 legacy_iomap_table[bar] = NULL;
633}
634
635/**
636 * pcim_iomap - Managed pcim_iomap()
637 * @pdev: PCI device to iomap for
638 * @bar: BAR to iomap
639 * @maxlen: Maximum length of iomap
640 *
641 * Returns: __iomem pointer on success, NULL on failure.
642 *
643 * Managed pci_iomap(). Map is automatically unmapped on driver detach. If
644 * desired, unmap manually only with pcim_iounmap().
645 *
646 * This SHOULD only be used once per BAR.
647 *
648 * NOTE:
649 * Contrary to the other pcim_* functions, this function does not return an
650 * IOMEM_ERR_PTR() on failure, but a simple NULL. This is done for backwards
651 * compatibility.
652 */
653void __iomem *pcim_iomap(struct pci_dev *pdev, int bar, unsigned long maxlen)
654{
655 void __iomem *mapping;
656 struct pcim_addr_devres *res;
657
658 res = pcim_addr_devres_alloc(pdev);
659 if (!res)
660 return NULL;
661 res->type = PCIM_ADDR_DEVRES_TYPE_MAPPING;
662
663 mapping = pci_iomap(pdev, bar, maxlen);
664 if (!mapping)
665 goto err_iomap;
666 res->baseaddr = mapping;
667
668 if (pcim_add_mapping_to_legacy_table(pdev, mapping, bar) != 0)
669 goto err_table;
670
671 devres_add(&pdev->dev, res);
672 return mapping;
673
674err_table:
675 pci_iounmap(pdev, mapping);
676err_iomap:
677 pcim_addr_devres_free(res);
678 return NULL;
679}
680EXPORT_SYMBOL(pcim_iomap);
681
682/**
683 * pcim_iounmap - Managed pci_iounmap()
684 * @pdev: PCI device to iounmap for
685 * @addr: Address to unmap
686 *
687 * Managed pci_iounmap(). @addr must have been mapped using a pcim_* mapping
688 * function.
689 */
690void pcim_iounmap(struct pci_dev *pdev, void __iomem *addr)
691{
692 struct pcim_addr_devres res_searched;
693
694 pcim_addr_devres_clear(&res_searched);
695 res_searched.type = PCIM_ADDR_DEVRES_TYPE_MAPPING;
696 res_searched.baseaddr = addr;
697
698 if (devres_release(&pdev->dev, pcim_addr_resource_release,
699 pcim_addr_resources_match, &res_searched) != 0) {
700 /* Doesn't exist. User passed nonsense. */
701 return;
702 }
703
704 pcim_remove_mapping_from_legacy_table(pdev, addr);
705}
706EXPORT_SYMBOL(pcim_iounmap);
707
708/**
709 * pcim_iomap_region - Request and iomap a PCI BAR
710 * @pdev: PCI device to map IO resources for
711 * @bar: Index of a BAR to map
712 * @name: Name associated with the request
713 *
714 * Returns: __iomem pointer on success, an IOMEM_ERR_PTR on failure.
715 *
716 * Mapping and region will get automatically released on driver detach. If
717 * desired, release manually only with pcim_iounmap_region().
718 */
719void __iomem *pcim_iomap_region(struct pci_dev *pdev, int bar,
720 const char *name)
721{
722 int ret;
723 struct pcim_addr_devres *res;
724
725 res = pcim_addr_devres_alloc(pdev);
726 if (!res)
727 return IOMEM_ERR_PTR(-ENOMEM);
728
729 res->type = PCIM_ADDR_DEVRES_TYPE_REGION_MAPPING;
730 res->bar = bar;
731
732 ret = __pcim_request_region(pdev, bar, name, 0);
733 if (ret != 0)
734 goto err_region;
735
736 res->baseaddr = pci_iomap(pdev, bar, 0);
737 if (!res->baseaddr) {
738 ret = -EINVAL;
739 goto err_iomap;
740 }
741
742 devres_add(&pdev->dev, res);
743 return res->baseaddr;
744
745err_iomap:
746 __pcim_release_region(pdev, bar);
747err_region:
748 pcim_addr_devres_free(res);
749
750 return IOMEM_ERR_PTR(ret);
751}
752EXPORT_SYMBOL(pcim_iomap_region);
753
754/**
755 * pcim_iounmap_region - Unmap and release a PCI BAR
756 * @pdev: PCI device to operate on
757 * @bar: Index of BAR to unmap and release
758 *
759 * Unmap a BAR and release its region manually. Only pass BARs that were
760 * previously mapped by pcim_iomap_region().
761 */
762void pcim_iounmap_region(struct pci_dev *pdev, int bar)
763{
764 struct pcim_addr_devres res_searched;
765
766 pcim_addr_devres_clear(&res_searched);
767 res_searched.type = PCIM_ADDR_DEVRES_TYPE_REGION_MAPPING;
768 res_searched.bar = bar;
769
770 devres_release(&pdev->dev, pcim_addr_resource_release,
771 pcim_addr_resources_match, &res_searched);
772}
773EXPORT_SYMBOL(pcim_iounmap_region);
774
775/**
776 * pcim_iomap_regions - Request and iomap PCI BARs (DEPRECATED)
777 * @pdev: PCI device to map IO resources for
778 * @mask: Mask of BARs to request and iomap
779 * @name: Name associated with the requests
780 *
781 * Returns: 0 on success, negative error code on failure.
782 *
783 * Request and iomap regions specified by @mask.
784 *
785 * This function is DEPRECATED. Do not use it in new code.
786 * Use pcim_iomap_region() instead.
787 */
788int pcim_iomap_regions(struct pci_dev *pdev, int mask, const char *name)
789{
790 int ret;
791 int bar;
792 void __iomem *mapping;
793
794 for (bar = 0; bar < DEVICE_COUNT_RESOURCE; bar++) {
795 if (!mask_contains_bar(mask, bar))
796 continue;
797
798 mapping = pcim_iomap_region(pdev, bar, name);
799 if (IS_ERR(mapping)) {
800 ret = PTR_ERR(mapping);
801 goto err;
802 }
803 ret = pcim_add_mapping_to_legacy_table(pdev, mapping, bar);
804 if (ret != 0)
805 goto err;
806 }
807
808 return 0;
809
810err:
811 while (--bar >= 0) {
812 pcim_iounmap_region(pdev, bar);
813 pcim_remove_bar_from_legacy_table(pdev, bar);
814 }
815
816 return ret;
817}
818EXPORT_SYMBOL(pcim_iomap_regions);
819
820static int _pcim_request_region(struct pci_dev *pdev, int bar, const char *name,
821 int request_flags)
822{
823 int ret;
824 struct pcim_addr_devres *res;
825
826 res = pcim_addr_devres_alloc(pdev);
827 if (!res)
828 return -ENOMEM;
829 res->type = PCIM_ADDR_DEVRES_TYPE_REGION;
830 res->bar = bar;
831
832 ret = __pcim_request_region(pdev, bar, name, request_flags);
833 if (ret != 0) {
834 pcim_addr_devres_free(res);
835 return ret;
836 }
837
838 devres_add(&pdev->dev, res);
839 return 0;
840}
841
842/**
843 * pcim_request_region - Request a PCI BAR
844 * @pdev: PCI device to requestion region for
845 * @bar: Index of BAR to request
846 * @name: Name associated with the request
847 *
848 * Returns: 0 on success, a negative error code on failure.
849 *
850 * Request region specified by @bar.
851 *
852 * The region will automatically be released on driver detach. If desired,
853 * release manually only with pcim_release_region().
854 */
855int pcim_request_region(struct pci_dev *pdev, int bar, const char *name)
856{
857 return _pcim_request_region(pdev, bar, name, 0);
858}
859EXPORT_SYMBOL(pcim_request_region);
860
861/**
862 * pcim_request_region_exclusive - Request a PCI BAR exclusively
863 * @pdev: PCI device to requestion region for
864 * @bar: Index of BAR to request
865 * @name: Name associated with the request
866 *
867 * Returns: 0 on success, a negative error code on failure.
868 *
869 * Request region specified by @bar exclusively.
870 *
871 * The region will automatically be released on driver detach. If desired,
872 * release manually only with pcim_release_region().
873 */
874int pcim_request_region_exclusive(struct pci_dev *pdev, int bar, const char *name)
875{
876 return _pcim_request_region(pdev, bar, name, IORESOURCE_EXCLUSIVE);
877}
878
879/**
880 * pcim_release_region - Release a PCI BAR
881 * @pdev: PCI device to operate on
882 * @bar: Index of BAR to release
883 *
884 * Release a region manually that was previously requested by
885 * pcim_request_region().
886 */
887void pcim_release_region(struct pci_dev *pdev, int bar)
888{
889 struct pcim_addr_devres res_searched;
890
891 pcim_addr_devres_clear(&res_searched);
892 res_searched.type = PCIM_ADDR_DEVRES_TYPE_REGION;
893 res_searched.bar = bar;
894
895 devres_release(&pdev->dev, pcim_addr_resource_release,
896 pcim_addr_resources_match, &res_searched);
897}
898
899
900/**
901 * pcim_release_all_regions - Release all regions of a PCI-device
902 * @pdev: the PCI device
903 *
904 * Release all regions previously requested through pcim_request_region()
905 * or pcim_request_all_regions().
906 *
907 * Can be called from any context, i.e., not necessarily as a counterpart to
908 * pcim_request_all_regions().
909 */
910static void pcim_release_all_regions(struct pci_dev *pdev)
911{
912 int bar;
913
914 for (bar = 0; bar < PCI_STD_NUM_BARS; bar++)
915 pcim_release_region(pdev, bar);
916}
917
918/**
919 * pcim_request_all_regions - Request all regions
920 * @pdev: PCI device to map IO resources for
921 * @name: name associated with the request
922 *
923 * Returns: 0 on success, negative error code on failure.
924 *
925 * Requested regions will automatically be released at driver detach. If
926 * desired, release individual regions with pcim_release_region() or all of
927 * them at once with pcim_release_all_regions().
928 */
929int pcim_request_all_regions(struct pci_dev *pdev, const char *name)
930{
931 int ret;
932 int bar;
933
934 for (bar = 0; bar < PCI_STD_NUM_BARS; bar++) {
935 ret = pcim_request_region(pdev, bar, name);
936 if (ret != 0)
937 goto err;
938 }
939
940 return 0;
941
942err:
943 pcim_release_all_regions(pdev);
944
945 return ret;
946}
947EXPORT_SYMBOL(pcim_request_all_regions);
948
949/**
950 * pcim_iounmap_regions - Unmap and release PCI BARs (DEPRECATED)
951 * @pdev: PCI device to map IO resources for
952 * @mask: Mask of BARs to unmap and release
953 *
954 * Unmap and release regions specified by @mask.
955 *
956 * This function is DEPRECATED. Do not use it in new code.
957 * Use pcim_iounmap_region() instead.
958 */
959void pcim_iounmap_regions(struct pci_dev *pdev, int mask)
960{
961 int i;
962
963 for (i = 0; i < PCI_STD_NUM_BARS; i++) {
964 if (!mask_contains_bar(mask, i))
965 continue;
966
967 pcim_iounmap_region(pdev, i);
968 pcim_remove_bar_from_legacy_table(pdev, i);
969 }
970}
971EXPORT_SYMBOL(pcim_iounmap_regions);
972
973/**
974 * pcim_iomap_range - Create a ranged __iomap mapping within a PCI BAR
975 * @pdev: PCI device to map IO resources for
976 * @bar: Index of the BAR
977 * @offset: Offset from the begin of the BAR
978 * @len: Length in bytes for the mapping
979 *
980 * Returns: __iomem pointer on success, an IOMEM_ERR_PTR on failure.
981 *
982 * Creates a new IO-Mapping within the specified @bar, ranging from @offset to
983 * @offset + @len.
984 *
985 * The mapping will automatically get unmapped on driver detach. If desired,
986 * release manually only with pcim_iounmap().
987 */
988void __iomem *pcim_iomap_range(struct pci_dev *pdev, int bar,
989 unsigned long offset, unsigned long len)
990{
991 void __iomem *mapping;
992 struct pcim_addr_devres *res;
993
994 res = pcim_addr_devres_alloc(pdev);
995 if (!res)
996 return IOMEM_ERR_PTR(-ENOMEM);
997
998 mapping = pci_iomap_range(pdev, bar, offset, len);
999 if (!mapping) {
1000 pcim_addr_devres_free(res);
1001 return IOMEM_ERR_PTR(-EINVAL);
1002 }
1003
1004 res->type = PCIM_ADDR_DEVRES_TYPE_MAPPING;
1005 res->baseaddr = mapping;
1006
1007 /*
1008 * Ranged mappings don't get added to the legacy-table, since the table
1009 * only ever keeps track of whole BARs.
1010 */
1011
1012 devres_add(&pdev->dev, res);
1013 return mapping;
1014}
1015EXPORT_SYMBOL(pcim_iomap_range);