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
 488 /**
 489  * pcim_enable_device - Managed pci_enable_device()
 490  * @pdev: PCI device to be initialized
 491  *
 492  * Returns: 0 on success, negative error code on failure.
 493  *
 494  * Managed pci_enable_device(). Device will automatically be disabled on
 495  * driver detach.
 496  */
 497 int pcim_enable_device(struct pci_dev *pdev)
 498 {
 499         int ret;
 500
 501         ret = devm_add_action(&pdev->dev, pcim_disable_device, pdev);
 502         if (ret != 0)
 503                 return ret;
 504
 505         /*
 506          * We prefer removing the action in case of an error over
 507          * devm_add_action_or_reset() because the latter could theoretically be
 508          * disturbed by users having pinned the device too soon.
 509          */
 510         ret = pci_enable_device(pdev);
 511         if (ret != 0) {
 512                 devm_remove_action(&pdev->dev, pcim_disable_device, pdev);
 513                 return ret;
 514         }
 515
 516         pdev->is_managed = true;
 517
 518         return ret;
 519 }
 520 EXPORT_SYMBOL(pcim_enable_device);
 521
 522 /**
 523  * pcim_pin_device - Pin managed PCI device
 524  * @pdev: PCI device to pin
 525  *
 526  * Pin managed PCI device @pdev. Pinned device won't be disabled on driver
 527  * detach. @pdev must have been enabled with pcim_enable_device().
 528  */
 529 void pcim_pin_device(struct pci_dev *pdev)
 530 {
 531         pdev->pinned = true;
 532 }
 533 EXPORT_SYMBOL(pcim_pin_device);
 534
 535 static void pcim_iomap_release(struct device *gendev, void *res)
 536 {
 537         /*
 538          * Do nothing. This is legacy code.
 539          *
 540          * Cleanup of the mappings is now done directly through the callbacks
 541          * registered when creating them.
 542          */
 543 }
 544
 545 /**
 546  * pcim_iomap_table - access iomap allocation table (DEPRECATED)
 547  * @pdev: PCI device to access iomap table for
 548  *
 549  * Returns:
 550  * Const pointer to array of __iomem pointers on success, NULL on failure.
 551  *
 552  * Access iomap allocation table for @dev.  If iomap table doesn't
 553  * exist and @pdev is managed, it will be allocated.  All iomaps
 554  * recorded in the iomap table are automatically unmapped on driver
 555  * detach.
 556  *
 557  * This function might sleep when the table is first allocated but can
 558  * be safely called without context and guaranteed to succeed once
 559  * allocated.
 560  *
 561  * This function is DEPRECATED. Do not use it in new code. Instead, obtain a
 562  * mapping's address directly from one of the pcim_* mapping functions. For
 563  * example:
 564  * void __iomem \*mappy = pcim_iomap(pdev, bar, length);
 565  */
 566 void __iomem * const *pcim_iomap_table(struct pci_dev *pdev)
 567 {
 568         struct pcim_iomap_devres *dr, *new_dr;
 569
 570         dr = devres_find(&pdev->dev, pcim_iomap_release, NULL, NULL);
 571         if (dr)
 572                 return dr->table;
 573
 574         new_dr = devres_alloc_node(pcim_iomap_release, sizeof(*new_dr), GFP_KERNEL,
 575                                    dev_to_node(&pdev->dev));
 576         if (!new_dr)
 577                 return NULL;
 578         dr = devres_get(&pdev->dev, new_dr, NULL, NULL);
 579         return dr->table;
 580 }
 581 EXPORT_SYMBOL(pcim_iomap_table);
 582
 583 /*
 584  * Fill the legacy mapping-table, so that drivers using the old API can
 585  * still get a BAR's mapping address through pcim_iomap_table().
 586  */
 587 static int pcim_add_mapping_to_legacy_table(struct pci_dev *pdev,
 588                                             void __iomem *mapping, int bar)
 589 {
 590         void __iomem **legacy_iomap_table;
 591
 592         if (bar >= PCI_STD_NUM_BARS)
 593                 return -EINVAL;
 594
 595         legacy_iomap_table = (void __iomem **)pcim_iomap_table(pdev);
 596         if (!legacy_iomap_table)
 597                 return -ENOMEM;
 598
 599         /* The legacy mechanism doesn't allow for duplicate mappings. */
 600         WARN_ON(legacy_iomap_table[bar]);
 601
 602         legacy_iomap_table[bar] = mapping;
 603
 604         return 0;
 605 }
 606
 607 /*
 608  * Remove a mapping. The table only contains whole-BAR mappings, so this will
 609  * never interfere with ranged mappings.
 610  */
 611 static void pcim_remove_mapping_from_legacy_table(struct pci_dev *pdev,
 612                                                   void __iomem *addr)
 613 {
 614         int bar;
 615         void __iomem **legacy_iomap_table;
 616
 617         legacy_iomap_table = (void __iomem **)pcim_iomap_table(pdev);
 618         if (!legacy_iomap_table)
 619                 return;
 620
 621         for (bar = 0; bar < PCI_STD_NUM_BARS; bar++) {
 622                 if (legacy_iomap_table[bar] == addr) {
 623                         legacy_iomap_table[bar] = NULL;
 624                         return;
 625                 }
 626         }
 627 }
 628
 629 /*
 630  * The same as pcim_remove_mapping_from_legacy_table(), but identifies the
 631  * mapping by its BAR index.
 632  */
 633 static void pcim_remove_bar_from_legacy_table(struct pci_dev *pdev, int bar)
 634 {
 635         void __iomem **legacy_iomap_table;
 636
 637         if (bar >= PCI_STD_NUM_BARS)
 638                 return;
 639
 640         legacy_iomap_table = (void __iomem **)pcim_iomap_table(pdev);
 641         if (!legacy_iomap_table)
 642                 return;
 643
 644         legacy_iomap_table[bar] = NULL;
 645 }
 646
 647 /**
 648  * pcim_iomap - Managed pcim_iomap()
 649  * @pdev: PCI device to iomap for
 650  * @bar: BAR to iomap
 651  * @maxlen: Maximum length of iomap
 652  *
 653  * Returns: __iomem pointer on success, NULL on failure.
 654  *
 655  * Managed pci_iomap(). Map is automatically unmapped on driver detach. If
 656  * desired, unmap manually only with pcim_iounmap().
 657  *
 658  * This SHOULD only be used once per BAR.
 659  *
 660  * NOTE:
 661  * Contrary to the other pcim_* functions, this function does not return an
 662  * IOMEM_ERR_PTR() on failure, but a simple NULL. This is done for backwards
 663  * compatibility.
 664  */
 665 void __iomem *pcim_iomap(struct pci_dev *pdev, int bar, unsigned long maxlen)
 666 {
 667         void __iomem *mapping;
 668         struct pcim_addr_devres *res;
 669
 670         res = pcim_addr_devres_alloc(pdev);
 671         if (!res)
 672                 return NULL;
 673         res->type = PCIM_ADDR_DEVRES_TYPE_MAPPING;
 674
 675         mapping = pci_iomap(pdev, bar, maxlen);
 676         if (!mapping)
 677                 goto err_iomap;
 678         res->baseaddr = mapping;
 679
 680         if (pcim_add_mapping_to_legacy_table(pdev, mapping, bar) != 0)
 681                 goto err_table;
 682
 683         devres_add(&pdev->dev, res);
 684         return mapping;
 685
 686 err_table:
 687         pci_iounmap(pdev, mapping);
 688 err_iomap:
 689         pcim_addr_devres_free(res);
 690         return NULL;
 691 }
 692 EXPORT_SYMBOL(pcim_iomap);
 693
 694 /**
 695  * pcim_iounmap - Managed pci_iounmap()
 696  * @pdev: PCI device to iounmap for
 697  * @addr: Address to unmap
 698  *
 699  * Managed pci_iounmap(). @addr must have been mapped using a pcim_* mapping
 700  * function.
 701  */
 702 void pcim_iounmap(struct pci_dev *pdev, void __iomem *addr)
 703 {
 704         struct pcim_addr_devres res_searched;
 705
 706         pcim_addr_devres_clear(&res_searched);
 707         res_searched.type = PCIM_ADDR_DEVRES_TYPE_MAPPING;
 708         res_searched.baseaddr = addr;
 709
 710         if (devres_release(&pdev->dev, pcim_addr_resource_release,
 711                         pcim_addr_resources_match, &res_searched) != 0) {
 712                 /* Doesn't exist. User passed nonsense. */
 713                 return;
 714         }
 715
 716         pcim_remove_mapping_from_legacy_table(pdev, addr);
 717 }
 718 EXPORT_SYMBOL(pcim_iounmap);
 719
 720 /**
 721  * pcim_iomap_region - Request and iomap a PCI BAR
 722  * @pdev: PCI device to map IO resources for
 723  * @bar: Index of a BAR to map
 724  * @name: Name associated with the request
 725  *
 726  * Returns: __iomem pointer on success, an IOMEM_ERR_PTR on failure.
 727  *
 728  * Mapping and region will get automatically released on driver detach. If
 729  * desired, release manually only with pcim_iounmap_region().
 730  */
 731 static void __iomem *pcim_iomap_region(struct pci_dev *pdev, int bar,
 732                                        const char *name)
 733 {
 734         int ret;
 735         struct pcim_addr_devres *res;
 736
 737         res = pcim_addr_devres_alloc(pdev);
 738         if (!res)
 739                 return IOMEM_ERR_PTR(-ENOMEM);
 740
 741         res->type = PCIM_ADDR_DEVRES_TYPE_REGION_MAPPING;
 742         res->bar = bar;
 743
 744         ret = __pcim_request_region(pdev, bar, name, 0);
 745         if (ret != 0)
 746                 goto err_region;
 747
 748         res->baseaddr = pci_iomap(pdev, bar, 0);
 749         if (!res->baseaddr) {
 750                 ret = -EINVAL;
 751                 goto err_iomap;
 752         }
 753
 754         devres_add(&pdev->dev, res);
 755         return res->baseaddr;
 756
 757 err_iomap:
 758         __pcim_release_region(pdev, bar);
 759 err_region:
 760         pcim_addr_devres_free(res);
 761
 762         return IOMEM_ERR_PTR(ret);
 763 }
 764
 765 /**
 766  * pcim_iounmap_region - Unmap and release a PCI BAR
 767  * @pdev: PCI device to operate on
 768  * @bar: Index of BAR to unmap and release
 769  *
 770  * Unmap a BAR and release its region manually. Only pass BARs that were
 771  * previously mapped by pcim_iomap_region().
 772  */
 773 static void pcim_iounmap_region(struct pci_dev *pdev, int bar)
 774 {
 775         struct pcim_addr_devres res_searched;
 776
 777         pcim_addr_devres_clear(&res_searched);
 778         res_searched.type = PCIM_ADDR_DEVRES_TYPE_REGION_MAPPING;
 779         res_searched.bar = bar;
 780
 781         devres_release(&pdev->dev, pcim_addr_resource_release,
 782                         pcim_addr_resources_match, &res_searched);
 783 }
 784
 785 /**
 786  * pcim_iomap_regions - Request and iomap PCI BARs
 787  * @pdev: PCI device to map IO resources for
 788  * @mask: Mask of BARs to request and iomap
 789  * @name: Name associated with the requests
 790  *
 791  * Returns: 0 on success, negative error code on failure.
 792  *
 793  * Request and iomap regions specified by @mask.
 794  */
 795 int pcim_iomap_regions(struct pci_dev *pdev, int mask, const char *name)
 796 {
 797         int ret;
 798         int bar;
 799         void __iomem *mapping;
 800
 801         for (bar = 0; bar < DEVICE_COUNT_RESOURCE; bar++) {
 802                 if (!mask_contains_bar(mask, bar))
 803                         continue;
 804
 805                 mapping = pcim_iomap_region(pdev, bar, name);
 806                 if (IS_ERR(mapping)) {
 807                         ret = PTR_ERR(mapping);
 808                         goto err;
 809                 }
 810                 ret = pcim_add_mapping_to_legacy_table(pdev, mapping, bar);
 811                 if (ret != 0)
 812                         goto err;
 813         }
 814
 815         return 0;
 816
 817 err:
 818         while (--bar >= 0) {
 819                 pcim_iounmap_region(pdev, bar);
 820                 pcim_remove_bar_from_legacy_table(pdev, bar);
 821         }
 822
 823         return ret;
 824 }
 825 EXPORT_SYMBOL(pcim_iomap_regions);
 826
 827 static int _pcim_request_region(struct pci_dev *pdev, int bar, const char *name,
 828                                 int request_flags)
 829 {
 830         int ret;
 831         struct pcim_addr_devres *res;
 832
 833         res = pcim_addr_devres_alloc(pdev);
 834         if (!res)
 835                 return -ENOMEM;
 836         res->type = PCIM_ADDR_DEVRES_TYPE_REGION;
 837         res->bar = bar;
 838
 839         ret = __pcim_request_region(pdev, bar, name, request_flags);
 840         if (ret != 0) {
 841                 pcim_addr_devres_free(res);
 842                 return ret;
 843         }
 844
 845         devres_add(&pdev->dev, res);
 846         return 0;
 847 }
 848
 849 /**
 850  * pcim_request_region - Request a PCI BAR
 851  * @pdev: PCI device to requestion region for
 852  * @bar: Index of BAR to request
 853  * @name: Name associated with the request
 854  *
 855  * Returns: 0 on success, a negative error code on failure.
 856  *
 857  * Request region specified by @bar.
 858  *
 859  * The region will automatically be released on driver detach. If desired,
 860  * release manually only with pcim_release_region().
 861  */
 862 int pcim_request_region(struct pci_dev *pdev, int bar, const char *name)
 863 {
 864         return _pcim_request_region(pdev, bar, name, 0);
 865 }
 866
 867 /**
 868  * pcim_request_region_exclusive - Request a PCI BAR exclusively
 869  * @pdev: PCI device to requestion region for
 870  * @bar: Index of BAR to request
 871  * @name: Name associated with the request
 872  *
 873  * Returns: 0 on success, a negative error code on failure.
 874  *
 875  * Request region specified by @bar exclusively.
 876  *
 877  * The region will automatically be released on driver detach. If desired,
 878  * release manually only with pcim_release_region().
 879  */
 880 int pcim_request_region_exclusive(struct pci_dev *pdev, int bar, const char *name)
 881 {
 882         return _pcim_request_region(pdev, bar, name, IORESOURCE_EXCLUSIVE);
 883 }
 884
 885 /**
 886  * pcim_release_region - Release a PCI BAR
 887  * @pdev: PCI device to operate on
 888  * @bar: Index of BAR to release
 889  *
 890  * Release a region manually that was previously requested by
 891  * pcim_request_region().
 892  */
 893 void pcim_release_region(struct pci_dev *pdev, int bar)
 894 {
 895         struct pcim_addr_devres res_searched;
 896
 897         pcim_addr_devres_clear(&res_searched);
 898         res_searched.type = PCIM_ADDR_DEVRES_TYPE_REGION;
 899         res_searched.bar = bar;
 900
 901         devres_release(&pdev->dev, pcim_addr_resource_release,
 902                         pcim_addr_resources_match, &res_searched);
 903 }
 904
 905
 906 /**
 907  * pcim_release_all_regions - Release all regions of a PCI-device
 908  * @pdev: the PCI device
 909  *
 910  * Release all regions previously requested through pcim_request_region()
 911  * or pcim_request_all_regions().
 912  *
 913  * Can be called from any context, i.e., not necessarily as a counterpart to
 914  * pcim_request_all_regions().
 915  */
 916 static void pcim_release_all_regions(struct pci_dev *pdev)
 917 {
 918         int bar;
 919
 920         for (bar = 0; bar < PCI_STD_NUM_BARS; bar++)
 921                 pcim_release_region(pdev, bar);
 922 }
 923
 924 /**
 925  * pcim_request_all_regions - Request all regions
 926  * @pdev: PCI device to map IO resources for
 927  * @name: name associated with the request
 928  *
 929  * Returns: 0 on success, negative error code on failure.
 930  *
 931  * Requested regions will automatically be released at driver detach. If
 932  * desired, release individual regions with pcim_release_region() or all of
 933  * them at once with pcim_release_all_regions().
 934  */
 935 static int pcim_request_all_regions(struct pci_dev *pdev, const char *name)
 936 {
 937         int ret;
 938         int bar;
 939
 940         for (bar = 0; bar < PCI_STD_NUM_BARS; bar++) {
 941                 ret = pcim_request_region(pdev, bar, name);
 942                 if (ret != 0)
 943                         goto err;
 944         }
 945
 946         return 0;
 947
 948 err:
 949         pcim_release_all_regions(pdev);
 950
 951         return ret;
 952 }
 953
 954 /**
 955  * pcim_iomap_regions_request_all - Request all BARs and iomap specified ones
 956  *                      (DEPRECATED)
 957  * @pdev: PCI device to map IO resources for
 958  * @mask: Mask of BARs to iomap
 959  * @name: Name associated with the requests
 960  *
 961  * Returns: 0 on success, negative error code on failure.
 962  *
 963  * Request all PCI BARs and iomap regions specified by @mask.
 964  *
 965  * To release these resources manually, call pcim_release_region() for the
 966  * regions and pcim_iounmap() for the mappings.
 967  *
 968  * This function is DEPRECATED. Don't use it in new code. Instead, use one
 969  * of the pcim_* region request functions in combination with a pcim_*
 970  * mapping function.
 971  */
 972 int pcim_iomap_regions_request_all(struct pci_dev *pdev, int mask,
 973                                    const char *name)
 974 {
 975         int bar;
 976         int ret;
 977         void __iomem **legacy_iomap_table;
 978
 979         ret = pcim_request_all_regions(pdev, name);
 980         if (ret != 0)
 981                 return ret;
 982
 983         for (bar = 0; bar < PCI_STD_NUM_BARS; bar++) {
 984                 if (!mask_contains_bar(mask, bar))
 985                         continue;
 986                 if (!pcim_iomap(pdev, bar, 0))
 987                         goto err;
 988         }
 989
 990         return 0;
 991
 992 err:
 993         /*
 994          * If bar is larger than 0, then pcim_iomap() above has most likely
 995          * failed because of -EINVAL. If it is equal 0, most likely the table
 996          * couldn't be created, indicating -ENOMEM.
 997          */
 998         ret = bar > 0 ? -EINVAL : -ENOMEM;
 999         legacy_iomap_table = (void __iomem **)pcim_iomap_table(pdev);
1000
1001         while (--bar >= 0)
1002                 pcim_iounmap(pdev, legacy_iomap_table[bar]);
1003
1004         pcim_release_all_regions(pdev);
1005
1006         return ret;
1007 }
1008 EXPORT_SYMBOL(pcim_iomap_regions_request_all);
1009
1010 /**
1011  * pcim_iounmap_regions - Unmap and release PCI BARs
1012  * @pdev: PCI device to map IO resources for
1013  * @mask: Mask of BARs to unmap and release
1014  *
1015  * Unmap and release regions specified by @mask.
1016  */
1017 void pcim_iounmap_regions(struct pci_dev *pdev, int mask)
1018 {
1019         int i;
1020
1021         for (i = 0; i < PCI_STD_NUM_BARS; i++) {
1022                 if (!mask_contains_bar(mask, i))
1023                         continue;
1024
1025                 pcim_iounmap_region(pdev, i);
1026                 pcim_remove_bar_from_legacy_table(pdev, i);
1027         }
1028 }
1029 EXPORT_SYMBOL(pcim_iounmap_regions);
1030
1031 /**
1032  * pcim_iomap_range - Create a ranged __iomap mapping within a PCI BAR
1033  * @pdev: PCI device to map IO resources for
1034  * @bar: Index of the BAR
1035  * @offset: Offset from the begin of the BAR
1036  * @len: Length in bytes for the mapping
1037  *
1038  * Returns: __iomem pointer on success, an IOMEM_ERR_PTR on failure.
1039  *
1040  * Creates a new IO-Mapping within the specified @bar, ranging from @offset to
1041  * @offset + @len.
1042  *
1043  * The mapping will automatically get unmapped on driver detach. If desired,
1044  * release manually only with pcim_iounmap().
1045  */
1046 void __iomem *pcim_iomap_range(struct pci_dev *pdev, int bar,
1047                 unsigned long offset, unsigned long len)
1048 {
1049         void __iomem *mapping;
1050         struct pcim_addr_devres *res;
1051
1052         res = pcim_addr_devres_alloc(pdev);
1053         if (!res)
1054                 return IOMEM_ERR_PTR(-ENOMEM);
1055
1056         mapping = pci_iomap_range(pdev, bar, offset, len);
1057         if (!mapping) {
1058                 pcim_addr_devres_free(res);
1059                 return IOMEM_ERR_PTR(-EINVAL);
1060         }
1061
1062         res->type = PCIM_ADDR_DEVRES_TYPE_MAPPING;
1063         res->baseaddr = mapping;
1064
1065         /*
1066          * Ranged mappings don't get added to the legacy-table, since the table
1067          * only ever keeps track of whole BARs.
1068          */
1069
1070         devres_add(&pdev->dev, res);
1071         return mapping;
1072 }
1073 EXPORT_SYMBOL(pcim_iomap_range);