Branch data     Line data    Source code

       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  * Implement the default iomap interfaces
       4                 :            :  *
       5                 :            :  * (C) Copyright 2004 Linus Torvalds
       6                 :            :  */
       7                 :            : #include <linux/pci.h>
       8                 :            : #include <linux/io.h>
       9                 :            : 
      10                 :            : #include <linux/export.h>
      11                 :            : 
      12                 :            : #ifdef CONFIG_PCI
      13                 :            : /**
      14                 :            :  * pci_iomap_range - create a virtual mapping cookie for a PCI BAR
      15                 :            :  * @dev: PCI device that owns the BAR
      16                 :            :  * @bar: BAR number
      17                 :            :  * @offset: map memory at the given offset in BAR
      18                 :            :  * @maxlen: max length of the memory to map
      19                 :            :  *
      20                 :            :  * Using this function you will get a __iomem address to your device BAR.
      21                 :            :  * You can access it using ioread*() and iowrite*(). These functions hide
      22                 :            :  * the details if this is a MMIO or PIO address space and will just do what
      23                 :            :  * you expect from them in the correct way.
      24                 :            :  *
      25                 :            :  * @maxlen specifies the maximum length to map. If you want to get access to
      26                 :            :  * the complete BAR from offset to the end, pass %0 here.
      27                 :            :  * */
      28                 :        168 : void __iomem *pci_iomap_range(struct pci_dev *dev,
      29                 :            :                               int bar,
      30                 :            :                               unsigned long offset,
      31                 :            :                               unsigned long maxlen)
      32                 :            : {
      33                 :        168 :         resource_size_t start = pci_resource_start(dev, bar);
      34   [ -  +  -  - ]:        168 :         resource_size_t len = pci_resource_len(dev, bar);
      35                 :        168 :         unsigned long flags = pci_resource_flags(dev, bar);
      36                 :            : 
      37         [ +  - ]:        168 :         if (len <= offset || !start)
      38                 :            :                 return NULL;
      39                 :        168 :         len -= offset;
      40                 :        168 :         start += offset;
      41         [ -  + ]:        168 :         if (maxlen && len > maxlen)
      42                 :          0 :                 len = maxlen;
      43         [ +  + ]:        168 :         if (flags & IORESOURCE_IO)
      44                 :        140 :                 return __pci_ioport_map(dev, start, len);
      45         [ +  - ]:         28 :         if (flags & IORESOURCE_MEM)
      46                 :         28 :                 return ioremap(start, len);
      47                 :            :         /* What? */
      48                 :            :         return NULL;
      49                 :            : }
      50                 :            : EXPORT_SYMBOL(pci_iomap_range);
      51                 :            : 
      52                 :            : /**
      53                 :            :  * pci_iomap_wc_range - create a virtual WC mapping cookie for a PCI BAR
      54                 :            :  * @dev: PCI device that owns the BAR
      55                 :            :  * @bar: BAR number
      56                 :            :  * @offset: map memory at the given offset in BAR
      57                 :            :  * @maxlen: max length of the memory to map
      58                 :            :  *
      59                 :            :  * Using this function you will get a __iomem address to your device BAR.
      60                 :            :  * You can access it using ioread*() and iowrite*(). These functions hide
      61                 :            :  * the details if this is a MMIO or PIO address space and will just do what
      62                 :            :  * you expect from them in the correct way. When possible write combining
      63                 :            :  * is used.
      64                 :            :  *
      65                 :            :  * @maxlen specifies the maximum length to map. If you want to get access to
      66                 :            :  * the complete BAR from offset to the end, pass %0 here.
      67                 :            :  * */
      68                 :          0 : void __iomem *pci_iomap_wc_range(struct pci_dev *dev,
      69                 :            :                                  int bar,
      70                 :            :                                  unsigned long offset,
      71                 :            :                                  unsigned long maxlen)
      72                 :            : {
      73                 :          0 :         resource_size_t start = pci_resource_start(dev, bar);
      74   [ #  #  #  # ]:          0 :         resource_size_t len = pci_resource_len(dev, bar);
      75                 :          0 :         unsigned long flags = pci_resource_flags(dev, bar);
      76                 :            : 
      77                 :            : 
      78         [ #  # ]:          0 :         if (flags & IORESOURCE_IO)
      79                 :            :                 return NULL;
      80                 :            : 
      81         [ #  # ]:          0 :         if (len <= offset || !start)
      82                 :            :                 return NULL;
      83                 :            : 
      84                 :          0 :         len -= offset;
      85                 :          0 :         start += offset;
      86         [ #  # ]:          0 :         if (maxlen && len > maxlen)
      87                 :          0 :                 len = maxlen;
      88                 :            : 
      89         [ #  # ]:          0 :         if (flags & IORESOURCE_MEM)
      90                 :          0 :                 return ioremap_wc(start, len);
      91                 :            : 
      92                 :            :         /* What? */
      93                 :            :         return NULL;
      94                 :            : }
      95                 :            : EXPORT_SYMBOL_GPL(pci_iomap_wc_range);
      96                 :            : 
      97                 :            : /**
      98                 :            :  * pci_iomap - create a virtual mapping cookie for a PCI BAR
      99                 :            :  * @dev: PCI device that owns the BAR
     100                 :            :  * @bar: BAR number
     101                 :            :  * @maxlen: length of the memory to map
     102                 :            :  *
     103                 :            :  * Using this function you will get a __iomem address to your device BAR.
     104                 :            :  * You can access it using ioread*() and iowrite*(). These functions hide
     105                 :            :  * the details if this is a MMIO or PIO address space and will just do what
     106                 :            :  * you expect from them in the correct way.
     107                 :            :  *
     108                 :            :  * @maxlen specifies the maximum length to map. If you want to get access to
     109                 :            :  * the complete BAR without checking for its length first, pass %0 here.
     110                 :            :  * */
     111                 :        168 : void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long maxlen)
     112                 :            : {
     113                 :        168 :         return pci_iomap_range(dev, bar, 0, maxlen);
     114                 :            : }
     115                 :            : EXPORT_SYMBOL(pci_iomap);
     116                 :            : 
     117                 :            : /**
     118                 :            :  * pci_iomap_wc - create a virtual WC mapping cookie for a PCI BAR
     119                 :            :  * @dev: PCI device that owns the BAR
     120                 :            :  * @bar: BAR number
     121                 :            :  * @maxlen: length of the memory to map
     122                 :            :  *
     123                 :            :  * Using this function you will get a __iomem address to your device BAR.
     124                 :            :  * You can access it using ioread*() and iowrite*(). These functions hide
     125                 :            :  * the details if this is a MMIO or PIO address space and will just do what
     126                 :            :  * you expect from them in the correct way. When possible write combining
     127                 :            :  * is used.
     128                 :            :  *
     129                 :            :  * @maxlen specifies the maximum length to map. If you want to get access to
     130                 :            :  * the complete BAR without checking for its length first, pass %0 here.
     131                 :            :  * */
     132                 :          0 : void __iomem *pci_iomap_wc(struct pci_dev *dev, int bar, unsigned long maxlen)
     133                 :            : {
     134                 :          0 :         return pci_iomap_wc_range(dev, bar, 0, maxlen);
     135                 :            : }
     136                 :            : EXPORT_SYMBOL_GPL(pci_iomap_wc);
     137                 :            : #endif /* CONFIG_PCI */