Map register blocks individually
v3 cover Map register blocks individually
From: Ira Weiny <[email protected]>
Changes for v3:
From Jonathan:
Add Reviews. Thanks!
Add back the kernel doc comment and enhance it a bit Update commit messages with more details. Remove CXL_REGLOC_RBI_MAX
Dan
Add pcim_enable_device() back in because it is needed and is not incompatible with pci_release_mem_regions() like I originally though.
Change cxl_ioremap_block() to devm_cxl_iomap_block()
Add kernel doc comment for cxl_probe_component_regs() Update HDM patch to devm_cxl_iomap_block() call.
Some hardware implementations mix component and device registers into the same BAR and the driver stack is going to have independent mapping implementations for those 2 cases. Furthermore, it will be nice to have finer grained mappings should user space want to map some register blocks.
Unfortunately, the information for the register blocks is contained inside the BARs themselves. Which means the BAR must be mapped, probed, and unmapped prior to the registers being mapped individually.
The series starts by introducing the helper function cxl_decode_register_block(). Then breaks out region reservation and register mapping. Separates mapping the registers into a probe stage and mapping stage. The probe stage creates a list of register blocks which is then iterated to map the individual register blocks.
Once mapping is performed in 2 steps the pci device management is removed and the resource reservation can be done per register block as well.
Finally, mapping the HDM decoder register block is added.
Ben Widawsky (1):
cxl/pci: Add HDM decoder capabilities
Ira Weiny (4):
cxl/mem: Introduce cxl_decode_register_block() cxl/mem: Reserve all device regions at once cxl/mem: Map registers based on capabilities cxl/mem: Reserve individual register block regions
drivers/cxl/core.c | 193 ++++++++++++++++++++++++++++++++++++++++++--- drivers/cxl/cxl.h | 98 ++++++++++++++++++++--- drivers/cxl/pci.c | 164 ++++++++++++++++++++++++++++++-------- 3 files changed, 402 insertions(+), 53 deletions(-)
Signature · 1 line
2.28.0.rc0.12.gb6a658bd00c9
PATCH v3 1/5 cxl/mem: Introduce cxl_decode_register_block()
From: Ira Weiny <[email protected]>
Each register block located in the DVSEC needs to be decoded from 2 words, 'register offset high' and 'register offset low'.
Create a function, cxl_decode_register_block() to perform this decode and return the bar, offset, and register type of the register block.
Then use the values decoded in cxl_mem_map_regblock() instead of passing the raw registers.
--- drivers/cxl/pci.c | 26 ++++++++++++++++++-------- 1 file changed, 18 insertions(+), 8 deletions(-)
drivers/cxl/pci.c +18 -8
@@ -922,17 +922,13 @@ static struct cxl_mem *cxl_mem_create(struct pci_dev *pdev)return cxlm; } -static void __iomem *cxl_mem_map_regblock (struct cxl_mem *cxlm,u32 reg_lo,u32 reg_hi) +static void __iomem *cxl_mem_map_regblock (struct cxl_mem *cxlm, +u8 bar,u64 offset) {struct pci_dev *pdev = cxlm->pdev;struct device *dev = &pdev->dev; -u64 offset; -u8 bar;int rc; - offset = ((u64 )reg_hi <<32 ) | (reg_lo &CXL_REGLOC_ADDR_MASK ); - bar =FIELD_GET (CXL_REGLOC_BIR_MASK , reg_lo); -/* Basic sanity check that BAR is big enough */ if (pci_resource_len (pdev, bar) < offset) { dev_err(dev, "BAR%d: %pr: too small (offset: %#llx)\n", bar,
@@ -974,6 +970,14 @@ static int cxl_mem_dvsec(struct pci_dev *pdev, int dvsec)return 0 ; } +static void cxl_decode_register_block (u32 reg_lo,u32 reg_hi, +u8 *bar,u64 *offset,u8 *reg_type) +{ + *offset = ((u64 )reg_hi <<32 ) | (reg_lo &CXL_REGLOC_ADDR_MASK ); + *bar =FIELD_GET (CXL_REGLOC_BIR_MASK , reg_lo); + *reg_type =FIELD_GET (CXL_REGLOC_RBI_MASK , reg_lo); +} +/** * cxl_mem_setup_regs() - Setup necessary MMIO. * @cxlm: The CXL memory device to communicate with.
@@ -1009,15 +1013,21 @@ static int cxl_mem_setup_regs(struct cxl_mem *cxlm)for (i =0 ; i < regblocks; i++, regloc +=8 ) {u32 reg_lo, reg_hi;u8 reg_type; +u64 offset; +u8 bar;/* "register low and high" contain other bits */ pci_read_config_dword (pdev, regloc, ®_lo);pci_read_config_dword (pdev, regloc +4 , ®_hi); - reg_type =FIELD_GET (CXL_REGLOC_RBI_MASK , reg_lo); +cxl_decode_register_block (reg_lo, reg_hi, &bar, &offset, + ®_type); + +dev_dbg (dev,"Found register block in bar %u @ 0x%llx of type %u\n" , + bar, offset, reg_type);if (reg_type ==CXL_REGLOC_RBI_MEMDEV ) { - base =cxl_mem_map_regblock (cxlm, reg_lo, reg_hi); + base =cxl_mem_map_regblock (cxlm, bar, offset);if (IS_ERR (base))return PTR_ERR (base);break ;
Signature · 1 line
2.28.0.rc0.12.gb6a658bd00c9
PATCH v3 2/5 cxl/mem: Reserve all device regions at once
In reply to [email protected]From: Ira Weiny <[email protected]>
In order to remap individual register sets each bar region must be reserved prior to mapping. Because the details of individual register sets are contained within the BARs themselves, the bar must be mapped 2 times, once to extract this information and a second time for each register set.
Rather than attempt to reserve each BAR individually and track if that bar has been reserved. Open code pcim_iomap_regions() by first reserving all memory regions on the device and then mapping the bars individually as needed.
NOTE pci_request_mem_regions() does not need a corresponding pci_release_mem_regions() because the pci device is managed via pcim_enable_device().
--- drivers/cxl/pci.c | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-)
drivers/cxl/pci.c +11 -7
@@ -927,7 +927,7 @@ static void __iomem *cxl_mem_map_regblock(struct cxl_mem *cxlm, {struct pci_dev *pdev = cxlm->pdev;struct device *dev = &pdev->dev; -int rc; +void __iomem *addr;/* Basic sanity check that BAR is big enough */ if (pci_resource_len (pdev, bar) < offset) {
@@ -936,13 +936,14 @@ static void __iomem *cxl_mem_map_regblock(struct cxl_mem *cxlm,return IOMEM_ERR_PTR (-ENXIO ); } - rc =pcim_iomap_regions (pdev,BIT (bar),pci_name (pdev)); -if (rc) { + addr =pcim_iomap (pdev, bar,0 ); +if (!addr) {dev_err (dev,"failed to map registers\n" ); -return IOMEM_ERR_PTR (rc); +return addr; } -dev_dbg (dev,"Mapped CXL Memory Device resource\n" ); +dev_dbg (dev,"Mapped CXL Memory Device resource bar %u @ %#llx\n" , + bar, offset);return pcim_iomap_table (pdev)[bar] + offset; }
@@ -1003,6 +1004,9 @@ static int cxl_mem_setup_regs(struct cxl_mem *cxlm)return -ENXIO ; } +if (pci_request_mem_regions (pdev,pci_name (pdev))) +return -ENODEV ; +/* Get the size of the Register Locator DVSEC */ pci_read_config_dword (pdev, regloc +PCI_DVSEC_HEADER1 , ®loc_size); regloc_size =FIELD_GET (PCI_DVSEC_HEADER1_LENGTH_MASK , regloc_size);
@@ -1028,8 +1032,8 @@ static int cxl_mem_setup_regs(struct cxl_mem *cxlm)if (reg_type ==CXL_REGLOC_RBI_MEMDEV ) { base =cxl_mem_map_regblock (cxlm, bar, offset); -if (IS_ERR (base)) -return PTR_ERR (base); +if (!base) +return -ENOMEM ;break ; } }
Signature · 1 line
2.28.0.rc0.12.gb6a658bd00c9
PATCH v3 3/5 cxl/mem: Map registers based on capabilities
In reply to [email protected]From: Ira Weiny <[email protected]>
The information required to map registers based on capabilities is contained within the bars themselves. This means the bar must be mapped to read the information needed and then unmapped to map the individual parts of the BAR based on capabilities.
Change cxl_setup_device_regs() to return a new cxl_register_map, change the name to cxl_probe_device_regs(). Allocate and place cxl_register_maps on a list while processing all of the specified register blocks.
After probing all the register blocks go back and map smaller registers blocks based on their capabilities and dispose of the cxl_register_maps.
NOTE: pci_iomap() is not managed automatically via pcim_enable_device() so be careful to call pci_iounmap() correctly.
---
Changes for V3
From Jonathan:
Add back the kernel doc comment and enhance it a bit
--- drivers/cxl/core.c | 73 +++++++++++++++++++++++++---- drivers/cxl/cxl.h | 33 ++++++++++++-- drivers/cxl/pci.c | 111 ++++++++++++++++++++++++++++++++++++--------- 3 files changed, 181 insertions(+), 36 deletions(-)
drivers/cxl/core.c +63 -10
@@ -3,6 +3,7 @@#include <linux/io-64-nonatomic-lo-hi.h> #include <linux/device.h> #include <linux/module.h> +#include <linux/pci.h> #include "cxl.h" /**
@@ -13,18 +14,20 @@*/ /** -* cxl_setup_device_regs() - Detect CXL Device register blocks +* cxl_probe_device_regs() - Detect CXL Device register blocks * @dev: Host device of the @base mapping * @base: Mapping of CXL 2.0 8.2.8 CXL Device Register Interface -* @regs: Base pointers for device register blocks (see CXL_DEVICE_REGS()) +* @map: Map object describing the register block information found +* +* Probe for device register information and return it in map object. */ -void cxl_setup_device_regs (struct device *dev,void __iomem *base, -struct cxl_device_regs *regs) +void cxl_probe_device_regs (struct device *dev,void __iomem *base, +struct cxl_device_reg_map *map) {int cap, cap_count;u64 cap_array; - *regs = (struct cxl_device_regs ) {0 }; + *map = (struct cxl_device_reg_map ){0 }; cap_array =readq (base +CXLDEV_CAP_ARRAY_OFFSET ); if (FIELD_GET(CXLDEV_CAP_ARRAY_ID_MASK, cap_array) !=
@@ -35,29 +38,38 @@ void cxl_setup_device_regs(struct device *dev, void __iomem *base,for (cap =1 ; cap <= cap_count; cap++) {void __iomem *register_block; -u32 offset; +u32 offset, length;u16 cap_id; cap_id =FIELD_GET (CXLDEV_CAP_HDR_CAP_ID_MASK ,readl (base + cap *0x10 )); offset =readl (base + cap *0x10 +0x4 ); + length =readl (base + cap *0x10 +0x8 ); + register_block = base + offset;switch (cap_id) {case CXLDEV_CAP_CAP_ID_DEVICE_STATUS :dev_dbg (dev,"found Status capability (0x%x)\n" , offset); - regs->status = register_block; + + map->status.valid = true; + map->status.offset = offset; + map->status.size = length;break ;case CXLDEV_CAP_CAP_ID_PRIMARY_MAILBOX :dev_dbg (dev,"found Mailbox capability (0x%x)\n" , offset); - regs->mbox = register_block; + map->mbox.valid = true; + map->mbox.offset = offset; + map->mbox.size = length;break ;case CXLDEV_CAP_CAP_ID_SECONDARY_MAILBOX :dev_dbg (dev,"found Secondary Mailbox capability (0x%x)\n" , offset);break ;case CXLDEV_CAP_CAP_ID_MEMDEV :dev_dbg (dev,"found Memory Device capability (0x%x)\n" , offset); - regs->memdev = register_block; + map->memdev.valid = true; + map->memdev.offset = offset; + map->memdev.size = length;break ;default :if (cap_id >=0x8000 )
@@ -68,7 +80,48 @@ void cxl_setup_device_regs(struct device *dev, void __iomem *base, } } } -EXPORT_SYMBOL_GPL (cxl_setup_device_regs); +EXPORT_SYMBOL_GPL (cxl_probe_device_regs); + +int cxl_map_device_regs (struct pci_dev *pdev, +struct cxl_device_regs *regs, +struct cxl_register_map *map) +{ +struct device *dev = &pdev->dev; +resource_size_t phys_addr; + + phys_addr =pci_resource_start (pdev, map->barno); + phys_addr += map->block_offset; + +if (map->device_map.status.valid) { +resource_size_t addr; +resource_size_t length; + + addr = phys_addr + map->device_map.status.offset; + length = map->device_map.status.size; + regs->status =devm_ioremap (dev, addr, length); + } + +if (map->device_map.mbox.valid) { +resource_size_t addr; +resource_size_t length; + + addr = phys_addr + map->device_map.mbox.offset; + length = map->device_map.mbox.size; + regs->mbox =devm_ioremap (dev, addr, length); + } + +if (map->device_map.memdev.valid) { +resource_size_t addr; +resource_size_t length; + + addr = phys_addr + map->device_map.memdev.offset; + length = map->device_map.memdev.size; + regs->memdev =devm_ioremap (dev, addr, length); + } + +return 0 ; +} +EXPORT_SYMBOL_GPL (cxl_map_device_regs);struct bus_type cxl_bus_type = { .name ="cxl" ,
drivers/cxl/cxl.h +28 -5
@@ -53,9 +53,7 @@ struct cxl_device_regs {/* * Note, the anonymous union organization allows for per * register-block-type helper routines, without requiring block-type -* agnostic code to include the prefix. I.e. -* cxl_setup_device_regs(&cxlm->regs.dev) vs readl(cxlm->regs.mbox). -* The specificity reads naturally from left-to-right. +* agnostic code to include the prefix. */ struct cxl_regs { union {
@@ -66,8 +64,33 @@ struct cxl_regs { }; }; -void cxl_setup_device_regs (struct device *dev,void __iomem *base, -struct cxl_device_regs *regs); +struct cxl_reg_map { +bool valid; +unsigned long offset; +unsigned long size; +}; + +struct cxl_device_reg_map { +struct cxl_reg_map status; +struct cxl_reg_map mbox; +struct cxl_reg_map memdev; +}; + +struct cxl_register_map { +struct list_head list; +u64 block_offset; +u8 reg_type; +u8 barno; +union { +struct cxl_device_reg_map device_map; + }; +}; + +void cxl_probe_device_regs (struct device *dev,void __iomem *base, +struct cxl_device_reg_map *map); +int cxl_map_device_regs (struct pci_dev *pdev, +struct cxl_device_regs *regs, +struct cxl_register_map *map);extern struct bus_type cxl_bus_type;#endif /* __CXL_H__ */
drivers/cxl/pci.c +90 -21
165 lines not on this page · raw message
Signature · 1 line
2.28.0.rc0.12.gb6a658bd00c9
PATCH 1/1 cxl/mem: Map registers based on capabilities
From: Ira Weiny <[email protected]>
The information required to map registers based on capabilities is contained within the bars themselves. This means the bar must be mapped to read the information needed and then unmapped to map the individual parts of the BAR based on capabilities.
Change cxl_setup_device_regs() to return a new cxl_register_map, change the name to cxl_probe_device_regs(). Allocate and place cxl_register_maps on a list while processing all of the specified register blocks.
After probing all the register blocks go back and map smaller registers blocks based on their capabilities and dispose of the cxl_register_maps.
NOTE: pci_iomap() is not managed automatically via pcim_enable_device() so be careful to call pci_iounmap() correctly.
---
Changes for V3.1
Fix 0-day
Quoted 1 line
Quoted 1 line
drivers/cxl/core.c:40:17: warning: variable 'register_block' set but not used [-Wunused-but-set-variable]
40 | void __iomem *register_block; --- drivers/cxl/core.c | 74 +++++++++++++++++++++++++----- drivers/cxl/cxl.h | 33 ++++++++++++-- drivers/cxl/pci.c | 111 ++++++++++++++++++++++++++++++++++++--------- 3 files changed, 180 insertions(+), 38 deletions(-)
drivers/cxl/core.c +62 -12
@@ -3,6 +3,7 @@#include <linux/io-64-nonatomic-lo-hi.h> #include <linux/device.h> #include <linux/module.h> +#include <linux/pci.h> #include "cxl.h" /**
@@ -13,18 +14,20 @@*/ /** -* cxl_setup_device_regs() - Detect CXL Device register blocks +* cxl_probe_device_regs() - Detect CXL Device register blocks * @dev: Host device of the @base mapping * @base: Mapping of CXL 2.0 8.2.8 CXL Device Register Interface -* @regs: Base pointers for device register blocks (see CXL_DEVICE_REGS()) +* @map: Map object describing the register block information found +* +* Probe for device register information and return it in map object. */ -void cxl_setup_device_regs (struct device *dev,void __iomem *base, -struct cxl_device_regs *regs) +void cxl_probe_device_regs (struct device *dev,void __iomem *base, +struct cxl_device_reg_map *map) {int cap, cap_count;u64 cap_array; - *regs = (struct cxl_device_regs ) {0 }; + *map = (struct cxl_device_reg_map ){0 }; cap_array =readq (base +CXLDEV_CAP_ARRAY_OFFSET ); if (FIELD_GET(CXLDEV_CAP_ARRAY_ID_MASK, cap_array) !=
@@ -34,30 +37,36 @@ void cxl_setup_device_regs(struct device *dev, void __iomem *base, cap_count =FIELD_GET (CXLDEV_CAP_ARRAY_COUNT_MASK , cap_array);for (cap =1 ; cap <= cap_count; cap++) { -void __iomem *register_block; -u32 offset; +u32 offset, length;u16 cap_id; cap_id =FIELD_GET (CXLDEV_CAP_HDR_CAP_ID_MASK ,readl (base + cap *0x10 )); offset =readl (base + cap *0x10 +0x4 ); - register_block = base + offset; + length =readl (base + cap *0x10 +0x8 );switch (cap_id) {case CXLDEV_CAP_CAP_ID_DEVICE_STATUS :dev_dbg (dev,"found Status capability (0x%x)\n" , offset); - regs->status = register_block; + + map->status.valid = true; + map->status.offset = offset; + map->status.size = length;break ;case CXLDEV_CAP_CAP_ID_PRIMARY_MAILBOX :dev_dbg (dev,"found Mailbox capability (0x%x)\n" , offset); - regs->mbox = register_block; + map->mbox.valid = true; + map->mbox.offset = offset; + map->mbox.size = length;break ;case CXLDEV_CAP_CAP_ID_SECONDARY_MAILBOX :dev_dbg (dev,"found Secondary Mailbox capability (0x%x)\n" , offset);break ;case CXLDEV_CAP_CAP_ID_MEMDEV :dev_dbg (dev,"found Memory Device capability (0x%x)\n" , offset); - regs->memdev = register_block; + map->memdev.valid = true; + map->memdev.offset = offset; + map->memdev.size = length;break ;default :if (cap_id >=0x8000 )
@@ -68,7 +77,48 @@ void cxl_setup_device_regs(struct device *dev, void __iomem *base, } } } -EXPORT_SYMBOL_GPL (cxl_setup_device_regs); +EXPORT_SYMBOL_GPL (cxl_probe_device_regs); + +int cxl_map_device_regs (struct pci_dev *pdev, +struct cxl_device_regs *regs, +struct cxl_register_map *map) +{ +struct device *dev = &pdev->dev; +resource_size_t phys_addr; + + phys_addr =pci_resource_start (pdev, map->barno); + phys_addr += map->block_offset; + +if (map->device_map.status.valid) { +resource_size_t addr; +resource_size_t length; + + addr = phys_addr + map->device_map.status.offset; + length = map->device_map.status.size; + regs->status =devm_ioremap (dev, addr, length); + } + +if (map->device_map.mbox.valid) { +resource_size_t addr; +resource_size_t length; + + addr = phys_addr + map->device_map.mbox.offset; + length = map->device_map.mbox.size; + regs->mbox =devm_ioremap (dev, addr, length); + } + +if (map->device_map.memdev.valid) { +resource_size_t addr; +resource_size_t length; + + addr = phys_addr + map->device_map.memdev.offset; + length = map->device_map.memdev.size; + regs->memdev =devm_ioremap (dev, addr, length); + } + +return 0 ; +} +EXPORT_SYMBOL_GPL (cxl_map_device_regs);struct bus_type cxl_bus_type = { .name ="cxl" ,
drivers/cxl/cxl.h +28 -5
@@ -53,9 +53,7 @@ struct cxl_device_regs {/* * Note, the anonymous union organization allows for per * register-block-type helper routines, without requiring block-type -* agnostic code to include the prefix. I.e. -* cxl_setup_device_regs(&cxlm->regs.dev) vs readl(cxlm->regs.mbox). -* The specificity reads naturally from left-to-right. +* agnostic code to include the prefix. */ struct cxl_regs { union {
@@ -66,8 +64,33 @@ struct cxl_regs { }; }; -void cxl_setup_device_regs (struct device *dev,void __iomem *base, -struct cxl_device_regs *regs); +struct cxl_reg_map { +bool valid; +unsigned long offset; +unsigned long size; +}; + +struct cxl_device_reg_map { +struct cxl_reg_map status; +struct cxl_reg_map mbox; +struct cxl_reg_map memdev; +}; + +struct cxl_register_map { +struct list_head list; +u64 block_offset; +u8 reg_type; +u8 barno; +union { +struct cxl_device_reg_map device_map; + }; +}; + +void cxl_probe_device_regs (struct device *dev,void __iomem *base, +struct cxl_device_reg_map *map); +int cxl_map_device_regs (struct pci_dev *pdev, +struct cxl_device_regs *regs, +struct cxl_register_map *map);extern struct bus_type cxl_bus_type;#endif /* __CXL_H__ */
drivers/cxl/pci.c +90 -21
165 lines not on this page · raw message
Signature · 1 line
2.28.0.rc0.12.gb6a658bd00c9
Re: [PATCH V3.1] cxl/mem: Map registers based on capabilities
Quoted 24 lines · On Thu, Jun 3, 2021 at 5:51 PM <[email protected]> wrote:
From: Ira Weiny <[email protected]>
The information required to map registers based on capabilities is contained within the bars themselves. This means the bar must be mapped to read the information needed and then unmapped to map the individual parts of the BAR based on capabilities.
Change
cxl_setup_device_regs()to return a newcxl_register_map, change the name tocxl_probe_device_regs(). Allocate and placecxl_register_mapson a list while processing all of the specified register blocks.After probing all the register blocks go back and map smaller registers blocks based on their capabilities and dispose of the
cxl_register_maps.NOTE:
pci_iomap()is not managed automatically viapcim_enable_device()so be careful to callpci_iounmap()correctly.Reviewed-by Jonathan Cameron <[email protected]>Signed-off-by Ira Weiny <[email protected]>Signed-off-by Dan Williams <[email protected]>
Quoted 6 lines
---
Changes for V3.1
Fix 0-dayQuoted 1 line
Quoted 1 line
drivers/cxl/core.c:40:17: warning: variable 'register_block' set but not used [-Wunused-but-set-variable]40 | void __iomem *register_block;
Just a note for next time if you want to be friendly to "b4 am" using maintainers. Roll the version and include the patch number in the resend, i.e.: in this case: "[PATCH v4 3/5] cxl/mem: Map registers based on capabilities". I was able to manually create a bundle in the proper order on patchwork for the two "3.1" updates.
PATCH v3 4/5 cxl/mem: Reserve individual register block regions
In reply to [email protected]From: Ira Weiny <[email protected]>
Some hardware implementations mix component and device registers into the same BAR and the driver stack is going to need independent mapping implementations for those 2 cases. Furthermore, it will be nice to have finer grained mappings should user space want to map some register blocks.
Now that individual register blocks are mapped; those blocks regions should be reserved individually to fully separate the register blocks.
Release the 'global' memory reservation and create individual register block region reservations through devm.
NOTE: pci_release_mem_regions() is still compatible with pcim_enable_device() because it removes the automatic region release when called. So preserve the pcim_enable_device() so that the pcim interface can be called if needed.
---
Changes for V3
Dan
Add pcim_enable_device() back in because it is needed and is not incompatible with pci_release_mem_regions() like I originally though.
Change cxl_ioremap_block() to devm_cxl_iomap_block()
Jonathan
Update commit message with more details.
--- drivers/cxl/core.c | 36 ++++++++++++++++++++++++++++++++---- drivers/cxl/pci.c | 2 ++ 2 files changed, 34 insertions(+), 4 deletions(-)
drivers/cxl/core.c +32 -4
@@ -82,11 +82,33 @@ void cxl_probe_device_regs(struct device *dev, void __iomem *base, }EXPORT_SYMBOL_GPL (cxl_probe_device_regs); +static void __iomem *devm_cxl_iomap_block (struct pci_dev *pdev, +resource_size_t addr, +resource_size_t length) +{ +struct device *dev = &pdev->dev; +void __iomem *ret_val; +struct resource *res; + + res =devm_request_mem_region (dev, addr, length,pci_name (pdev)); +if (!res) { +dev_err (dev,"Failed to request region %#llx-%#llx\n" , + addr, addr+length); +return NULL ; + } + + ret_val =devm_ioremap (dev, addr, length); +if (!ret_val) +dev_err (dev,"Failed to map region %#llx-%#llx\n" , + addr, addr+length); + +return ret_val; +} +int cxl_map_device_regs (struct pci_dev *pdev,struct cxl_device_regs *regs,struct cxl_register_map *map) { -struct device *dev = &pdev->dev;resource_size_t phys_addr; phys_addr =pci_resource_start (pdev, map->barno);
@@ -98,7 +120,9 @@ int cxl_map_device_regs(struct pci_dev *pdev, addr = phys_addr + map->device_map.status.offset; length = map->device_map.status.size; - regs->status =devm_ioremap (dev, addr, length); + regs->status =devm_cxl_iomap_block (pdev, addr, length); +if (!regs->status) +return -ENOMEM ; }if (map->device_map.mbox.valid) {
@@ -107,7 +131,9 @@ int cxl_map_device_regs(struct pci_dev *pdev, addr = phys_addr + map->device_map.mbox.offset; length = map->device_map.mbox.size; - regs->mbox =devm_ioremap (dev, addr, length); + regs->mbox =devm_cxl_iomap_block (pdev, addr, length); +if (!regs->mbox) +return -ENOMEM ; }if (map->device_map.memdev.valid) {
@@ -116,7 +142,9 @@ int cxl_map_device_regs(struct pci_dev *pdev, addr = phys_addr + map->device_map.memdev.offset; length = map->device_map.memdev.size; - regs->memdev =devm_ioremap (dev, addr, length); + regs->memdev =devm_cxl_iomap_block (pdev, addr, length); +if (!regs->memdev) +return -ENOMEM ; }return 0 ;
drivers/cxl/pci.c +2 -0
@@ -1110,6 +1110,8 @@ static int cxl_mem_setup_regs(struct cxl_mem *cxlm) goto free_maps; } +pci_release_mem_regions (pdev); +list_for_each_entry (map, ®ister_maps, list) { ret =cxl_map_regs (cxlm, map);if (ret)
Signature · 1 line
2.28.0.rc0.12.gb6a658bd00c9
PATCH 1/1 cxl/mem: Reserve individual register block regions
From: Ira Weiny <[email protected]>
Some hardware implementations mix component and device registers into the same BAR and the driver stack is going to need independent mapping implementations for those 2 cases. Furthermore, it will be nice to have finer grained mappings should user space want to map some register blocks.
Now that individual register blocks are mapped; those blocks regions should be reserved individually to fully separate the register blocks.
Release the 'global' memory reservation and create individual register block region reservations through devm.
NOTE: pci_release_mem_regions() is still compatible with pcim_enable_device() because it removes the automatic region release when called. So preserve the pcim_enable_device() so that the pcim interface can be called if needed.
---
Changes for v3.1
Fix 0-day warnings:
Quoted 1 line
Quoted 1 line
drivers/cxl/core.c:96:4: warning: format specifies type 'unsigned long long' but the argument has type 'resource_size_t' (aka 'unsigned int') [-Wformat]
addr, addr+length); --- drivers/cxl/core.c | 36 ++++++++++++++++++++++++++++++++---- drivers/cxl/pci.c | 2 ++ 2 files changed, 34 insertions(+), 4 deletions(-)
drivers/cxl/core.c +32 -4
@@ -79,11 +79,33 @@ void cxl_probe_device_regs(struct device *dev, void __iomem *base, }EXPORT_SYMBOL_GPL (cxl_probe_device_regs); +static void __iomem *devm_cxl_iomap_block (struct pci_dev *pdev, +resource_size_t addr, +resource_size_t length) +{ +struct device *dev = &pdev->dev; +void __iomem *ret_val; +struct resource *res; + + res =devm_request_mem_region (dev, addr, length,pci_name (pdev)); +if (!res) { +resource_size_t end = addr + length -1 ; + +dev_err (dev,"Failed to request region %pa-%pa\n" , &addr, &end); +return NULL ; + } + + ret_val =devm_ioremap (dev, addr, length); +if (!ret_val) +dev_err (dev,"Failed to map region %pr\n" , res); + +return ret_val; +} +int cxl_map_device_regs (struct pci_dev *pdev,struct cxl_device_regs *regs,struct cxl_register_map *map) { -struct device *dev = &pdev->dev;resource_size_t phys_addr; phys_addr =pci_resource_start (pdev, map->barno);
@@ -95,7 +117,9 @@ int cxl_map_device_regs(struct pci_dev *pdev, addr = phys_addr + map->device_map.status.offset; length = map->device_map.status.size; - regs->status =devm_ioremap (dev, addr, length); + regs->status =devm_cxl_iomap_block (pdev, addr, length); +if (!regs->status) +return -ENOMEM ; }if (map->device_map.mbox.valid) {
@@ -104,7 +128,9 @@ int cxl_map_device_regs(struct pci_dev *pdev, addr = phys_addr + map->device_map.mbox.offset; length = map->device_map.mbox.size; - regs->mbox =devm_ioremap (dev, addr, length); + regs->mbox =devm_cxl_iomap_block (pdev, addr, length); +if (!regs->mbox) +return -ENOMEM ; }if (map->device_map.memdev.valid) {
@@ -113,7 +139,9 @@ int cxl_map_device_regs(struct pci_dev *pdev, addr = phys_addr + map->device_map.memdev.offset; length = map->device_map.memdev.size; - regs->memdev =devm_ioremap (dev, addr, length); + regs->memdev =devm_cxl_iomap_block (pdev, addr, length); +if (!regs->memdev) +return -ENOMEM ; }return 0 ;
drivers/cxl/pci.c +2 -0
@@ -1110,6 +1110,8 @@ static int cxl_mem_setup_regs(struct cxl_mem *cxlm) goto free_maps; } +pci_release_mem_regions (pdev); +list_for_each_entry (map, ®ister_maps, list) { ret =cxl_map_regs (cxlm, map);if (ret)
Signature · 1 line
2.28.0.rc0.12.gb6a658bd00c9
PATCH v3 5/5 cxl/pci: Add HDM decoder capabilities
In reply to [email protected]From: Ben Widawsky <[email protected]>
An HDM decoder is defined in the CXL 2.0 specification as a mechanism that allow devices and upstream ports to claim memory address ranges and participate in interleave sets. HDM decoder registers are within the component register block defined in CXL 2.0 8.2.3 CXL 2.0 Component Registers as part of the CXL.cache and CXL.mem subregion.
The Component Register Block is found via the Register Locator DVSEC in a similar fashion to how the CXL Device Register Block is found. The primary difference is the capability id size of the Component Register Block is a single DWORD instead of 4 DWORDS.
It's now possible to configure a CXL type 3 device's HDM decoder. Such programming is expected for CXL devices with persistent memory, and hot plugged CXL devices that participate in CXL.mem with volatile memory.
Add probe and mapping functions for the component register blocks.
---
Changes for V3:
Johnathan
Remove CXL_REGLOC_RBI_MAX
Add kernel doc comment for cxl_probe_component_regs() Update to devm_cxl_iomap_block() call.
--- drivers/cxl/core.c | 92 ++++++++++++++++++++++++++++++++++++++++++++++ drivers/cxl/cxl.h | 65 +++++++++++++++++++++++++++++--- drivers/cxl/pci.c | 15 ++++++++ 3 files changed, 166 insertions(+), 6 deletions(-)
drivers/cxl/core.c +92 -0
@@ -13,6 +13,78 @@* point for cross-device interleave coordination through cxl ports. */ +/** +* cxl_probe_component_regs() - Detect CXL Component register blocks +* @dev: Host device of the @base mapping +* @base: Mapping containing the HDM Decoder Capability Header +* @map: Map object describing the register block information found +* +* See CXL 2.0 8.2.4 Component Register Layout and Definition +* See CXL 2.0 8.2.5.5 CXL Device Register Interface +* +* Probe for component register information and return it in map object. +*/ +void cxl_probe_component_regs (struct device *dev,void __iomem *base, +struct cxl_component_reg_map *map) +{ +int cap, cap_count; +u64 cap_array; + + *map = (struct cxl_component_reg_map ) {0 }; + +/* +* CXL.cache and CXL.mem registers are at offset 0x1000 as defined in +* CXL 2.0 8.2.4 Table 141. +*/ + base +=CXL_CM_OFFSET ; + + cap_array =readq (base +CXL_CM_CAP_HDR_OFFSET ); + +if (FIELD_GET (CXL_CM_CAP_HDR_ID_MASK , cap_array) !=CM_CAP_HDR_CAP_ID ) { +dev_err (dev, +"Couldn't locate the CXL.cache and CXL.mem capability array header./n" ); +return ; + } + +/* It's assumed that future versions will be backward compatible */ + cap_count =FIELD_GET (CXL_CM_CAP_HDR_ARRAY_SIZE_MASK , cap_array); + +for (cap =1 ; cap <= cap_count; cap++) { +void __iomem *register_block; +u32 hdr; +int decoder_cnt; +u16 cap_id, offset; +u32 length; + + hdr =readl (base + cap *0x4 ); + + cap_id =FIELD_GET (CXL_CM_CAP_HDR_ID_MASK , hdr); + offset =FIELD_GET (CXL_CM_CAP_PTR_MASK , hdr); + register_block = base + offset; + +switch (cap_id) { +case CXL_CM_CAP_CAP_ID_HDM : +dev_dbg (dev,"found HDM decoder capability (0x%x)\n" , + offset); + + hdr =readl (register_block); + + decoder_cnt =FIELD_GET (CXL_HDM_DECODER_COUNT_MASK , hdr); + length =0x20 * decoder_cnt +0x10 ; + + map->hdm_decoder.valid = true; + map->hdm_decoder.offset = offset; + map->hdm_decoder.size = length; +break ; +default : +dev_dbg (dev,"Unknown CM cap ID: %d (0x%x)\n" , cap_id, + offset); +break ; + } + } +} +EXPORT_SYMBOL_GPL (cxl_probe_component_regs); +/** * cxl_probe_device_regs() - Detect CXL Device register blocks * @dev: Host device of the @base mapping
@@ -105,6 +177,26 @@ static void __iomem *devm_cxl_iomap_block(struct pci_dev *pdev,return ret_val; } +int cxl_map_component_regs (struct pci_dev *pdev, +struct cxl_component_regs *regs, +struct cxl_register_map *map) +{ +resource_size_t phys_addr; +resource_size_t length; + + phys_addr =pci_resource_start (pdev, map->barno); + phys_addr += map->block_offset; + + phys_addr += map->component_map.hdm_decoder.offset; + length = map->component_map.hdm_decoder.size; + regs->hdm_decoder =devm_cxl_iomap_block (pdev, phys_addr, length); +if (!regs->hdm_decoder) +return -ENOMEM ; + +return 0 ; +} +EXPORT_SYMBOL_GPL (cxl_map_component_regs); +int cxl_map_device_regs (struct pci_dev *pdev,struct cxl_device_regs *regs,struct cxl_register_map *map)
drivers/cxl/cxl.h +59 -6
107 lines not on this page · raw message
drivers/cxl/pci.c +15 -0
@@ -982,9 +982,20 @@ static int cxl_probe_regs(struct cxl_mem *cxlm, void __iomem *base, {struct pci_dev *pdev = cxlm->pdev;struct device *dev = &pdev->dev; +struct cxl_component_reg_map *comp_map;struct cxl_device_reg_map *dev_map;switch (map->reg_type) { +case CXL_REGLOC_RBI_COMPONENT : + comp_map = &map->component_map; +cxl_probe_component_regs (dev, base, comp_map); +if (!comp_map->hdm_decoder.valid) { +dev_err (dev,"HDM decoder registers not found\n" ); +return -ENXIO ; + } + +dev_dbg (dev,"Set up component registers\n" ); +break ;case CXL_REGLOC_RBI_MEMDEV : dev_map = &map->device_map;cxl_probe_device_regs (dev, base, dev_map);
@@ -1012,6 +1023,10 @@ static int cxl_map_regs(struct cxl_mem *cxlm, struct cxl_register_map *map)struct device *dev = &pdev->dev;switch (map->reg_type) { +case CXL_REGLOC_RBI_COMPONENT : +cxl_map_component_regs (pdev, &cxlm->regs.component, map); +dev_dbg (dev,"Mapping component registers...\n" ); +break ;case CXL_REGLOC_RBI_MEMDEV :cxl_map_device_regs (pdev, &cxlm->regs.device_regs, map);dev_dbg (dev,"Probing device registers...\n" );
Signature · 1 line
2.28.0.rc0.12.gb6a658bd00c9