drivers/pci/devres.c

   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  */
  42 struct pcim_iomap_devres {
  43         void __iomem *table[PCI_STD_NUM_BARS];
  44 };
  45
  46 /* Used to restore the old INTx state on driver detach. */
  47 struct pcim_intx_devres {
  48         int orig_intx;
  49 };
  50
  51 enum 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  */
  76 struct 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
  84 static 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  */
 111 static 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
 145 static 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
 171 static 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
 180 static 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
 188 static 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
 209 static 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. */
 221 static 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  */
 229 static 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
 251 static 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  */
 267 int 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 }
 287 EXPORT_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  */
 298 void __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 }
 317 EXPORT_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  */
 338 void __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 }
 376 EXPORT_SYMBOL(devm_pci_remap_cfg_resource);
 377
 378 static 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  */
 393 int 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 }
 407 EXPORT_SYMBOL(pcim_set_mwi);
 408
 409 static inline bool mask_contains_bar(int mask, int bar)
 410 {
 411         return mask & BIT(bar);
 412 }
 413
 414 /*
 415  * This is a copy of pci_intx() used to bypass the problem of recursive
 416  * function calls due to the hybrid nature of pci_intx().
 417  */
 418 static void __pcim_intx(struct pci_dev *pdev, int enable)
 419 {
 420         u16 pci_command, new;
 421
 422         pci_read_config_word(pdev, PCI_COMMAND, &pci_command);
 423
 424         if (enable)
 425                 new = pci_command & ~PCI_COMMAND_INTX_DISABLE;
 426         else
 427                 new = pci_command | PCI_COMMAND_INTX_DISABLE;
 428
 429         if (new != pci_command)
 430                 pci_write_config_word(pdev, PCI_COMMAND, new);
 431 }
 432
 433 static void pcim_intx_restore(struct device *dev, void *data)
 434 {
 435         struct pci_dev *pdev = to_pci_dev(dev);
 436         struct pcim_intx_devres *res = data;
 437
 438         __pcim_intx(pdev, res->orig_intx);
 439 }
 440
 441 static struct pcim_intx_devres *get_or_create_intx_devres(struct device *dev)
 442 {
 443         struct pcim_intx_devres *res;
 444
 445         res = devres_find(dev, pcim_intx_restore, NULL, NULL);
 446         if (res)
 447                 return res;
 448
 449         res = devres_alloc(pcim_intx_restore, sizeof(*res), GFP_KERNEL);
 450         if (res)
 451                 devres_add(dev, res);
 452
 453         return res;
 454 }
 455
 456 /**
 457  * pcim_intx - managed pci_intx()
 458  * @pdev: the PCI device to operate on
 459  * @enable: boolean: whether to enable or disable PCI INTx
 460  *
 461  * Returns: 0 on success, -ENOMEM on error.
 462  *
 463  * Enable/disable PCI INTx for device @pdev.
 464  * Restore the original state on driver detach.
 465  */
 466 int pcim_intx(struct pci_dev *pdev, int enable)
 467 {
 468         struct pcim_intx_devres *res;
 469
 470         res = get_or_create_intx_devres(&pdev->dev);
 471         if (!res)
 472                 return -ENOMEM;
 473
 474         res->orig_intx = !enable;
 475         __pcim_intx(pdev, enable);
 476
 477         return 0;
 478 }
 479
 480 static void pcim_disable_device(void *pdev_raw)
 481 {
 482         struct pci_dev *pdev = pdev_raw;
 483
 484         if (!pdev->pinned)
 485                 pci_disable_device(pdev);
 486
 487         pdev->is_managed = false;
 488 }
 489
 490 /**
 491  * pcim_enable_device - Managed pci_enable_device()
 492  * @pdev: PCI device to be initialized
 493  *
 494  * Returns: 0 on success, negative error code on failure.
 495  *
 496  * Managed pci_enable_device(). Device will automatically be disabled on
 497  * driver detach.
 498  */
 499 int pcim_enable_device(struct pci_dev *pdev)
 500 {
 501         int ret;
 502
 503         ret = devm_add_action(&pdev->dev, pcim_disable_device, pdev);
 504         if (ret != 0)
 505                 return ret;
 506
 507         /*
 508          * We prefer removing the action in case of an error over
 509          * devm_add_action_or_reset() because the latter could theoretically be
 510          * disturbed by users having pinned the device too soon.
 511          */
 512         ret = pci_enable_device(pdev);
 513         if (ret != 0) {
 514                 devm_remove_action(&pdev->dev, pcim_disable_device, pdev);
 515                 return ret;
 516         }
 517
 518         pdev->is_managed = true;
 519
 520         return ret;
 521 }
 522 EXPORT_SYMBOL(pcim_enable_device);
 523
 524 /**
 525  * pcim_pin_device - Pin managed PCI device
 526  * @pdev: PCI device to pin
 527  *
 528  * Pin managed PCI device @pdev. Pinned device won't be disabled on driver
 529  * detach. @pdev must have been enabled with pcim_enable_device().
 530  */
 531 void pcim_pin_device(struct pci_dev *pdev)
 532 {
 533         pdev->pinned = true;
 534 }
 535 EXPORT_SYMBOL(pcim_pin_device);
 536
 537 static void pcim_iomap_release(struct device *gendev, void *res)
 538 {
 539         /*
 540          * Do nothing. This is legacy code.
 541          *
 542          * Cleanup of the mappings is now done directly through the callbacks
 543          * registered when creating them.
 544          */
 545 }
 546
 547 /**
 548  * pcim_iomap_table - access iomap allocation table (DEPRECATED)
 549  * @pdev: PCI device to access iomap table for
 550  *
 551  * Returns:
 552  * Const pointer to array of __iomem pointers on success, NULL on failure.
 553  *
 554  * Access iomap allocation table for @dev.  If iomap table doesn't
 555  * exist and @pdev is managed, it will be allocated.  All iomaps
 556  * recorded in the iomap table are automatically unmapped on driver
 557  * detach.
 558  *
 559  * This function might sleep when the table is first allocated but can
 560  * be safely called without context and guaranteed to succeed once
 561  * allocated.
 562  *
 563  * This function is DEPRECATED. Do not use it in new code. Instead, obtain a
 564  * mapping's address directly from one of the pcim_* mapping functions. For
 565  * example:
 566  * void __iomem \*mappy = pcim_iomap(pdev, bar, length);
 567  */
 568 void __iomem * const *pcim_iomap_table(struct pci_dev *pdev)
 569 {
 570         struct pcim_iomap_devres *dr, *new_dr;
 571
 572         dr = devres_find(&pdev->dev, pcim_iomap_release, NULL, NULL);
 573         if (dr)
 574                 return dr->table;
 575
 576         new_dr = devres_alloc_node(pcim_iomap_release, sizeof(*new_dr), GFP_KERNEL,
 577                                    dev_to_node(&pdev->dev));
 578         if (!new_dr)
 579                 return NULL;
 580         dr = devres_get(&pdev->dev, new_dr, NULL, NULL);
 581         return dr->table;
 582 }
 583 EXPORT_SYMBOL(pcim_iomap_table);
 584
 585 /*
 586  * Fill the legacy mapping-table, so that drivers using the old API can
 587  * still get a BAR's mapping address through pcim_iomap_table().
 588  */
 589 static int pcim_add_mapping_to_legacy_table(struct pci_dev *pdev,
 590                                             void __iomem *mapping, int bar)
 591 {
 592         void __iomem **legacy_iomap_table;
 593
 594         if (bar >= PCI_STD_NUM_BARS)
 595                 return -EINVAL;
 596
 597         legacy_iomap_table = (void __iomem **)pcim_iomap_table(pdev);
 598         if (!legacy_iomap_table)
 599                 return -ENOMEM;
 600
 601         /* The legacy mechanism doesn't allow for duplicate mappings. */
 602         WARN_ON(legacy_iomap_table[bar]);
 603
 604         legacy_iomap_table[bar] = mapping;
 605
 606         return 0;
 607 }
 608
 609 /*
 610  * Remove a mapping. The table only contains whole-BAR mappings, so this will
 611  * never interfere with ranged mappings.
 612  */
 613 static void pcim_remove_mapping_from_legacy_table(struct pci_dev *pdev,
 614                                                   void __iomem *addr)
 615 {
 616         int bar;
 617         void __iomem **legacy_iomap_table;
 618
 619         legacy_iomap_table = (void __iomem **)pcim_iomap_table(pdev);
 620         if (!legacy_iomap_table)
 621                 return;
 622
 623         for (bar = 0; bar < PCI_STD_NUM_BARS; bar++) {
 624                 if (legacy_iomap_table[bar] == addr) {
 625                         legacy_iomap_table[bar] = NULL;
 626                         return;
 627                 }
 628         }
 629 }
 630
 631 /*
 632  * The same as pcim_remove_mapping_from_legacy_table(), but identifies the
 633  * mapping by its BAR index.
 634  */
 635 static void pcim_remove_bar_from_legacy_table(struct pci_dev *pdev, int bar)
 636 {
 637         void __iomem **legacy_iomap_table;
 638
 639         if (bar >= PCI_STD_NUM_BARS)
 640                 return;
 641
 642         legacy_iomap_table = (void __iomem **)pcim_iomap_table(pdev);
 643         if (!legacy_iomap_table)
 644                 return;
 645
 646         legacy_iomap_table[bar] = NULL;
 647 }
 648
 649 /**
 650  * pcim_iomap - Managed pcim_iomap()
 651  * @pdev: PCI device to iomap for
 652  * @bar: BAR to iomap
 653  * @maxlen: Maximum length of iomap
 654  *
 655  * Returns: __iomem pointer on success, NULL on failure.
 656  *
 657  * Managed pci_iomap(). Map is automatically unmapped on driver detach. If
 658  * desired, unmap manually only with pcim_iounmap().
 659  *
 660  * This SHOULD only be used once per BAR.
 661  *
 662  * NOTE:
 663  * Contrary to the other pcim_* functions, this function does not return an
 664  * IOMEM_ERR_PTR() on failure, but a simple NULL. This is done for backwards
 665  * compatibility.
 666  */
 667 void __iomem *pcim_iomap(struct pci_dev *pdev, int bar, unsigned long maxlen)
 668 {
 669         void __iomem *mapping;
 670         struct pcim_addr_devres *res;
 671
 672         res = pcim_addr_devres_alloc(pdev);
 673         if (!res)
 674                 return NULL;
 675         res->type = PCIM_ADDR_DEVRES_TYPE_MAPPING;
 676
 677         mapping = pci_iomap(pdev, bar, maxlen);
 678         if (!mapping)
 679                 goto err_iomap;
 680         res->baseaddr = mapping;
 681
 682         if (pcim_add_mapping_to_legacy_table(pdev, mapping, bar) != 0)
 683                 goto err_table;
 684
 685         devres_add(&pdev->dev, res);
 686         return mapping;
 687
 688 err_table:
 689         pci_iounmap(pdev, mapping);
 690 err_iomap:
 691         pcim_addr_devres_free(res);
 692         return NULL;
 693 }
 694 EXPORT_SYMBOL(pcim_iomap);
 695
 696 /**
 697  * pcim_iounmap - Managed pci_iounmap()
 698  * @pdev: PCI device to iounmap for
 699  * @addr: Address to unmap
 700  *
 701  * Managed pci_iounmap(). @addr must have been mapped using a pcim_* mapping
 702  * function.
 703  */
 704 void pcim_iounmap(struct pci_dev *pdev, void __iomem *addr)
 705 {
 706         struct pcim_addr_devres res_searched;
 707
 708         pcim_addr_devres_clear(&res_searched);
 709         res_searched.type = PCIM_ADDR_DEVRES_TYPE_MAPPING;
 710         res_searched.baseaddr = addr;
 711
 712         if (devres_release(&pdev->dev, pcim_addr_resource_release,
 713                         pcim_addr_resources_match, &res_searched) != 0) {
 714                 /* Doesn't exist. User passed nonsense. */
 715                 return;
 716         }
 717
 718         pcim_remove_mapping_from_legacy_table(pdev, addr);
 719 }
 720 EXPORT_SYMBOL(pcim_iounmap);
 721
 722 /**
 723  * pcim_iomap_region - Request and iomap a PCI BAR
 724  * @pdev: PCI device to map IO resources for
 725  * @bar: Index of a BAR to map
 726  * @name: Name associated with the request
 727  *
 728  * Returns: __iomem pointer on success, an IOMEM_ERR_PTR on failure.
 729  *
 730  * Mapping and region will get automatically released on driver detach. If
 731  * desired, release manually only with pcim_iounmap_region().
 732  */
 733 void __iomem *pcim_iomap_region(struct pci_dev *pdev, int bar,
 734                                        const char *name)
 735 {
 736         int ret;
 737         struct pcim_addr_devres *res;
 738
 739         res = pcim_addr_devres_alloc(pdev);
 740         if (!res)
 741                 return IOMEM_ERR_PTR(-ENOMEM);
 742
 743         res->type = PCIM_ADDR_DEVRES_TYPE_REGION_MAPPING;
 744         res->bar = bar;
 745
 746         ret = __pcim_request_region(pdev, bar, name, 0);
 747         if (ret != 0)
 748                 goto err_region;
 749
 750         res->baseaddr = pci_iomap(pdev, bar, 0);
 751         if (!res->baseaddr) {
 752                 ret = -EINVAL;
 753                 goto err_iomap;
 754         }
 755
 756         devres_add(&pdev->dev, res);
 757         return res->baseaddr;
 758
 759 err_iomap:
 760         __pcim_release_region(pdev, bar);
 761 err_region:
 762         pcim_addr_devres_free(res);
 763
 764         return IOMEM_ERR_PTR(ret);
 765 }
 766 EXPORT_SYMBOL(pcim_iomap_region);
 767
 768 /**
 769  * pcim_iounmap_region - Unmap and release a PCI BAR
 770  * @pdev: PCI device to operate on
 771  * @bar: Index of BAR to unmap and release
 772  *
 773  * Unmap a BAR and release its region manually. Only pass BARs that were
 774  * previously mapped by pcim_iomap_region().
 775  */
 776 void pcim_iounmap_region(struct pci_dev *pdev, int bar)
 777 {
 778         struct pcim_addr_devres res_searched;
 779
 780         pcim_addr_devres_clear(&res_searched);
 781         res_searched.type = PCIM_ADDR_DEVRES_TYPE_REGION_MAPPING;
 782         res_searched.bar = bar;
 783
 784         devres_release(&pdev->dev, pcim_addr_resource_release,
 785                         pcim_addr_resources_match, &res_searched);
 786 }
 787 EXPORT_SYMBOL(pcim_iounmap_region);
 788
 789 /**
 790  * pcim_iomap_regions - Request and iomap PCI BARs (DEPRECATED)
 791  * @pdev: PCI device to map IO resources for
 792  * @mask: Mask of BARs to request and iomap
 793  * @name: Name associated with the requests
 794  *
 795  * Returns: 0 on success, negative error code on failure.
 796  *
 797  * Request and iomap regions specified by @mask.
 798  *
 799  * This function is DEPRECATED. Do not use it in new code.
 800  * Use pcim_iomap_region() instead.
 801  */
 802 int pcim_iomap_regions(struct pci_dev *pdev, int mask, const char *name)
 803 {
 804         int ret;
 805         int bar;
 806         void __iomem *mapping;
 807
 808         for (bar = 0; bar < DEVICE_COUNT_RESOURCE; bar++) {
 809                 if (!mask_contains_bar(mask, bar))
 810                         continue;
 811
 812                 mapping = pcim_iomap_region(pdev, bar, name);
 813                 if (IS_ERR(mapping)) {
 814                         ret = PTR_ERR(mapping);
 815                         goto err;
 816                 }
 817                 ret = pcim_add_mapping_to_legacy_table(pdev, mapping, bar);
 818                 if (ret != 0)
 819                         goto err;
 820         }
 821
 822         return 0;
 823
 824 err:
 825         while (--bar >= 0) {
 826                 pcim_iounmap_region(pdev, bar);
 827                 pcim_remove_bar_from_legacy_table(pdev, bar);
 828         }
 829
 830         return ret;
 831 }
 832 EXPORT_SYMBOL(pcim_iomap_regions);
 833
 834 static int _pcim_request_region(struct pci_dev *pdev, int bar, const char *name,
 835                                 int request_flags)
 836 {
 837         int ret;
 838         struct pcim_addr_devres *res;
 839
 840         res = pcim_addr_devres_alloc(pdev);
 841         if (!res)
 842                 return -ENOMEM;
 843         res->type = PCIM_ADDR_DEVRES_TYPE_REGION;
 844         res->bar = bar;
 845
 846         ret = __pcim_request_region(pdev, bar, name, request_flags);
 847         if (ret != 0) {
 848                 pcim_addr_devres_free(res);
 849                 return ret;
 850         }
 851
 852         devres_add(&pdev->dev, res);
 853         return 0;
 854 }
 855
 856 /**
 857  * pcim_request_region - Request a PCI BAR
 858  * @pdev: PCI device to requestion region for
 859  * @bar: Index of BAR to request
 860  * @name: Name associated with the request
 861  *
 862  * Returns: 0 on success, a negative error code on failure.
 863  *
 864  * Request region specified by @bar.
 865  *
 866  * The region will automatically be released on driver detach. If desired,
 867  * release manually only with pcim_release_region().
 868  */
 869 int pcim_request_region(struct pci_dev *pdev, int bar, const char *name)
 870 {
 871         return _pcim_request_region(pdev, bar, name, 0);
 872 }
 873 EXPORT_SYMBOL(pcim_request_region);
 874
 875 /**
 876  * pcim_request_region_exclusive - Request a PCI BAR exclusively
 877  * @pdev: PCI device to requestion region for
 878  * @bar: Index of BAR to request
 879  * @name: Name associated with the request
 880  *
 881  * Returns: 0 on success, a negative error code on failure.
 882  *
 883  * Request region specified by @bar exclusively.
 884  *
 885  * The region will automatically be released on driver detach. If desired,
 886  * release manually only with pcim_release_region().
 887  */
 888 int pcim_request_region_exclusive(struct pci_dev *pdev, int bar, const char *name)
 889 {
 890         return _pcim_request_region(pdev, bar, name, IORESOURCE_EXCLUSIVE);
 891 }
 892
 893 /**
 894  * pcim_release_region - Release a PCI BAR
 895  * @pdev: PCI device to operate on
 896  * @bar: Index of BAR to release
 897  *
 898  * Release a region manually that was previously requested by
 899  * pcim_request_region().
 900  */
 901 void pcim_release_region(struct pci_dev *pdev, int bar)
 902 {
 903         struct pcim_addr_devres res_searched;
 904
 905         pcim_addr_devres_clear(&res_searched);
 906         res_searched.type = PCIM_ADDR_DEVRES_TYPE_REGION;
 907         res_searched.bar = bar;
 908
 909         devres_release(&pdev->dev, pcim_addr_resource_release,
 910                         pcim_addr_resources_match, &res_searched);
 911 }
 912
 913
 914 /**
 915  * pcim_release_all_regions - Release all regions of a PCI-device
 916  * @pdev: the PCI device
 917  *
 918  * Release all regions previously requested through pcim_request_region()
 919  * or pcim_request_all_regions().
 920  *
 921  * Can be called from any context, i.e., not necessarily as a counterpart to
 922  * pcim_request_all_regions().
 923  */
 924 static void pcim_release_all_regions(struct pci_dev *pdev)
 925 {
 926         int bar;
 927
 928         for (bar = 0; bar < PCI_STD_NUM_BARS; bar++)
 929                 pcim_release_region(pdev, bar);
 930 }
 931
 932 /**
 933  * pcim_request_all_regions - Request all regions
 934  * @pdev: PCI device to map IO resources for
 935  * @name: name associated with the request
 936  *
 937  * Returns: 0 on success, negative error code on failure.
 938  *
 939  * Requested regions will automatically be released at driver detach. If
 940  * desired, release individual regions with pcim_release_region() or all of
 941  * them at once with pcim_release_all_regions().
 942  */
 943 int pcim_request_all_regions(struct pci_dev *pdev, const char *name)
 944 {
 945         int ret;
 946         int bar;
 947
 948         for (bar = 0; bar < PCI_STD_NUM_BARS; bar++) {
 949                 ret = pcim_request_region(pdev, bar, name);
 950                 if (ret != 0)
 951                         goto err;
 952         }
 953
 954         return 0;
 955
 956 err:
 957         pcim_release_all_regions(pdev);
 958
 959         return ret;
 960 }
 961 EXPORT_SYMBOL(pcim_request_all_regions);
 962
 963 /**
 964  * pcim_iounmap_regions - Unmap and release PCI BARs (DEPRECATED)
 965  * @pdev: PCI device to map IO resources for
 966  * @mask: Mask of BARs to unmap and release
 967  *
 968  * Unmap and release regions specified by @mask.
 969  *
 970  * This function is DEPRECATED. Do not use it in new code.
 971  * Use pcim_iounmap_region() instead.
 972  */
 973 void pcim_iounmap_regions(struct pci_dev *pdev, int mask)
 974 {
 975         int i;
 976
 977         for (i = 0; i < PCI_STD_NUM_BARS; i++) {
 978                 if (!mask_contains_bar(mask, i))
 979                         continue;
 980
 981                 pcim_iounmap_region(pdev, i);
 982                 pcim_remove_bar_from_legacy_table(pdev, i);
 983         }
 984 }
 985 EXPORT_SYMBOL(pcim_iounmap_regions);
 986
 987 /**
 988  * pcim_iomap_range - Create a ranged __iomap mapping within a PCI BAR
 989  * @pdev: PCI device to map IO resources for
 990  * @bar: Index of the BAR
 991  * @offset: Offset from the begin of the BAR
 992  * @len: Length in bytes for the mapping
 993  *
 994  * Returns: __iomem pointer on success, an IOMEM_ERR_PTR on failure.
 995  *
 996  * Creates a new IO-Mapping within the specified @bar, ranging from @offset to
 997  * @offset + @len.
 998  *
 999  * The mapping will automatically get unmapped on driver detach. If desired,
1000  * release manually only with pcim_iounmap().
1001  */
1002 void __iomem *pcim_iomap_range(struct pci_dev *pdev, int bar,
1003                 unsigned long offset, unsigned long len)
1004 {
1005         void __iomem *mapping;
1006         struct pcim_addr_devres *res;
1007
1008         res = pcim_addr_devres_alloc(pdev);
1009         if (!res)
1010                 return IOMEM_ERR_PTR(-ENOMEM);
1011
1012         mapping = pci_iomap_range(pdev, bar, offset, len);
1013         if (!mapping) {
1014                 pcim_addr_devres_free(res);
1015                 return IOMEM_ERR_PTR(-EINVAL);
1016         }
1017
1018         res->type = PCIM_ADDR_DEVRES_TYPE_MAPPING;
1019         res->baseaddr = mapping;
1020
1021         /*
1022          * Ranged mappings don't get added to the legacy-table, since the table
1023          * only ever keeps track of whole BARs.
1024          */
1025
1026         devres_add(&pdev->dev, res);
1027         return mapping;
1028 }
1029 EXPORT_SYMBOL(pcim_iomap_range);