]> Git Repo - linux.git/blob - drivers/cxl/core/regs.c
Linux 6.14-rc3
[linux.git] / drivers / cxl / core / regs.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /* Copyright(c) 2020 Intel Corporation. */
3 #include <linux/io-64-nonatomic-lo-hi.h>
4 #include <linux/device.h>
5 #include <linux/slab.h>
6 #include <linux/pci.h>
7 #include <cxlmem.h>
8 #include <cxlpci.h>
9 #include <pmu.h>
10
11 #include "core.h"
12
13 /**
14  * DOC: cxl registers
15  *
16  * CXL device capabilities are enumerated by PCI DVSEC (Designated
17  * Vendor-specific) and / or descriptors provided by platform firmware.
18  * They can be defined as a set like the device and component registers
19  * mandated by CXL Section 8.1.12.2 Memory Device PCIe Capabilities and
20  * Extended Capabilities, or they can be individual capabilities
21  * appended to bridged and endpoint devices.
22  *
23  * Provide common infrastructure for enumerating and mapping these
24  * discrete capabilities.
25  */
26
27 /**
28  * cxl_probe_component_regs() - Detect CXL Component register blocks
29  * @dev: Host device of the @base mapping
30  * @base: Mapping containing the HDM Decoder Capability Header
31  * @map: Map object describing the register block information found
32  *
33  * See CXL 2.0 8.2.4 Component Register Layout and Definition
34  * See CXL 2.0 8.2.5.5 CXL Device Register Interface
35  *
36  * Probe for component register information and return it in map object.
37  */
38 void cxl_probe_component_regs(struct device *dev, void __iomem *base,
39                               struct cxl_component_reg_map *map)
40 {
41         int cap, cap_count;
42         u32 cap_array;
43
44         *map = (struct cxl_component_reg_map) { 0 };
45
46         /*
47          * CXL.cache and CXL.mem registers are at offset 0x1000 as defined in
48          * CXL 2.0 8.2.4 Table 141.
49          */
50         base += CXL_CM_OFFSET;
51
52         cap_array = readl(base + CXL_CM_CAP_HDR_OFFSET);
53
54         if (FIELD_GET(CXL_CM_CAP_HDR_ID_MASK, cap_array) != CM_CAP_HDR_CAP_ID) {
55                 dev_dbg(dev,
56                         "Couldn't locate the CXL.cache and CXL.mem capability array header.\n");
57                 return;
58         }
59
60         /* It's assumed that future versions will be backward compatible */
61         cap_count = FIELD_GET(CXL_CM_CAP_HDR_ARRAY_SIZE_MASK, cap_array);
62
63         for (cap = 1; cap <= cap_count; cap++) {
64                 void __iomem *register_block;
65                 struct cxl_reg_map *rmap;
66                 u16 cap_id, offset;
67                 u32 length, hdr;
68
69                 hdr = readl(base + cap * 0x4);
70
71                 cap_id = FIELD_GET(CXL_CM_CAP_HDR_ID_MASK, hdr);
72                 offset = FIELD_GET(CXL_CM_CAP_PTR_MASK, hdr);
73                 register_block = base + offset;
74                 hdr = readl(register_block);
75
76                 rmap = NULL;
77                 switch (cap_id) {
78                 case CXL_CM_CAP_CAP_ID_HDM: {
79                         int decoder_cnt;
80
81                         dev_dbg(dev, "found HDM decoder capability (0x%x)\n",
82                                 offset);
83
84                         decoder_cnt = cxl_hdm_decoder_count(hdr);
85                         length = 0x20 * decoder_cnt + 0x10;
86                         rmap = &map->hdm_decoder;
87                         break;
88                 }
89                 case CXL_CM_CAP_CAP_ID_RAS:
90                         dev_dbg(dev, "found RAS capability (0x%x)\n",
91                                 offset);
92                         length = CXL_RAS_CAPABILITY_LENGTH;
93                         rmap = &map->ras;
94                         break;
95                 default:
96                         dev_dbg(dev, "Unknown CM cap ID: %d (0x%x)\n", cap_id,
97                                 offset);
98                         break;
99                 }
100
101                 if (!rmap)
102                         continue;
103                 rmap->valid = true;
104                 rmap->id = cap_id;
105                 rmap->offset = CXL_CM_OFFSET + offset;
106                 rmap->size = length;
107         }
108 }
109 EXPORT_SYMBOL_NS_GPL(cxl_probe_component_regs, "CXL");
110
111 /**
112  * cxl_probe_device_regs() - Detect CXL Device register blocks
113  * @dev: Host device of the @base mapping
114  * @base: Mapping of CXL 2.0 8.2.8 CXL Device Register Interface
115  * @map: Map object describing the register block information found
116  *
117  * Probe for device register information and return it in map object.
118  */
119 void cxl_probe_device_regs(struct device *dev, void __iomem *base,
120                            struct cxl_device_reg_map *map)
121 {
122         int cap, cap_count;
123         u64 cap_array;
124
125         *map = (struct cxl_device_reg_map){ 0 };
126
127         cap_array = readq(base + CXLDEV_CAP_ARRAY_OFFSET);
128         if (FIELD_GET(CXLDEV_CAP_ARRAY_ID_MASK, cap_array) !=
129             CXLDEV_CAP_ARRAY_CAP_ID)
130                 return;
131
132         cap_count = FIELD_GET(CXLDEV_CAP_ARRAY_COUNT_MASK, cap_array);
133
134         for (cap = 1; cap <= cap_count; cap++) {
135                 struct cxl_reg_map *rmap;
136                 u32 offset, length;
137                 u16 cap_id;
138
139                 cap_id = FIELD_GET(CXLDEV_CAP_HDR_CAP_ID_MASK,
140                                    readl(base + cap * 0x10));
141                 offset = readl(base + cap * 0x10 + 0x4);
142                 length = readl(base + cap * 0x10 + 0x8);
143
144                 rmap = NULL;
145                 switch (cap_id) {
146                 case CXLDEV_CAP_CAP_ID_DEVICE_STATUS:
147                         dev_dbg(dev, "found Status capability (0x%x)\n", offset);
148                         rmap = &map->status;
149                         break;
150                 case CXLDEV_CAP_CAP_ID_PRIMARY_MAILBOX:
151                         dev_dbg(dev, "found Mailbox capability (0x%x)\n", offset);
152                         rmap = &map->mbox;
153                         break;
154                 case CXLDEV_CAP_CAP_ID_SECONDARY_MAILBOX:
155                         dev_dbg(dev, "found Secondary Mailbox capability (0x%x)\n", offset);
156                         break;
157                 case CXLDEV_CAP_CAP_ID_MEMDEV:
158                         dev_dbg(dev, "found Memory Device capability (0x%x)\n", offset);
159                         rmap = &map->memdev;
160                         break;
161                 default:
162                         if (cap_id >= 0x8000)
163                                 dev_dbg(dev, "Vendor cap ID: %#x offset: %#x\n", cap_id, offset);
164                         else
165                                 dev_dbg(dev, "Unknown cap ID: %#x offset: %#x\n", cap_id, offset);
166                         break;
167                 }
168
169                 if (!rmap)
170                         continue;
171                 rmap->valid = true;
172                 rmap->id = cap_id;
173                 rmap->offset = offset;
174                 rmap->size = length;
175         }
176 }
177 EXPORT_SYMBOL_NS_GPL(cxl_probe_device_regs, "CXL");
178
179 void __iomem *devm_cxl_iomap_block(struct device *dev, resource_size_t addr,
180                                    resource_size_t length)
181 {
182         void __iomem *ret_val;
183         struct resource *res;
184
185         if (WARN_ON_ONCE(addr == CXL_RESOURCE_NONE))
186                 return NULL;
187
188         res = devm_request_mem_region(dev, addr, length, dev_name(dev));
189         if (!res) {
190                 resource_size_t end = addr + length - 1;
191
192                 dev_err(dev, "Failed to request region %pa-%pa\n", &addr, &end);
193                 return NULL;
194         }
195
196         ret_val = devm_ioremap(dev, addr, length);
197         if (!ret_val)
198                 dev_err(dev, "Failed to map region %pr\n", res);
199
200         return ret_val;
201 }
202
203 int cxl_map_component_regs(const struct cxl_register_map *map,
204                            struct cxl_component_regs *regs,
205                            unsigned long map_mask)
206 {
207         struct device *host = map->host;
208         struct mapinfo {
209                 const struct cxl_reg_map *rmap;
210                 void __iomem **addr;
211         } mapinfo[] = {
212                 { &map->component_map.hdm_decoder, &regs->hdm_decoder },
213                 { &map->component_map.ras, &regs->ras },
214         };
215         int i;
216
217         for (i = 0; i < ARRAY_SIZE(mapinfo); i++) {
218                 struct mapinfo *mi = &mapinfo[i];
219                 resource_size_t addr;
220                 resource_size_t length;
221
222                 if (!mi->rmap->valid)
223                         continue;
224                 if (!test_bit(mi->rmap->id, &map_mask))
225                         continue;
226                 addr = map->resource + mi->rmap->offset;
227                 length = mi->rmap->size;
228                 *(mi->addr) = devm_cxl_iomap_block(host, addr, length);
229                 if (!*(mi->addr))
230                         return -ENOMEM;
231         }
232
233         return 0;
234 }
235 EXPORT_SYMBOL_NS_GPL(cxl_map_component_regs, "CXL");
236
237 int cxl_map_device_regs(const struct cxl_register_map *map,
238                         struct cxl_device_regs *regs)
239 {
240         struct device *host = map->host;
241         resource_size_t phys_addr = map->resource;
242         struct mapinfo {
243                 const struct cxl_reg_map *rmap;
244                 void __iomem **addr;
245         } mapinfo[] = {
246                 { &map->device_map.status, &regs->status, },
247                 { &map->device_map.mbox, &regs->mbox, },
248                 { &map->device_map.memdev, &regs->memdev, },
249         };
250         int i;
251
252         for (i = 0; i < ARRAY_SIZE(mapinfo); i++) {
253                 struct mapinfo *mi = &mapinfo[i];
254                 resource_size_t length;
255                 resource_size_t addr;
256
257                 if (!mi->rmap->valid)
258                         continue;
259
260                 addr = phys_addr + mi->rmap->offset;
261                 length = mi->rmap->size;
262                 *(mi->addr) = devm_cxl_iomap_block(host, addr, length);
263                 if (!*(mi->addr))
264                         return -ENOMEM;
265         }
266
267         return 0;
268 }
269 EXPORT_SYMBOL_NS_GPL(cxl_map_device_regs, "CXL");
270
271 static bool cxl_decode_regblock(struct pci_dev *pdev, u32 reg_lo, u32 reg_hi,
272                                 struct cxl_register_map *map)
273 {
274         u8 reg_type = FIELD_GET(CXL_DVSEC_REG_LOCATOR_BLOCK_ID_MASK, reg_lo);
275         int bar = FIELD_GET(CXL_DVSEC_REG_LOCATOR_BIR_MASK, reg_lo);
276         u64 offset = ((u64)reg_hi << 32) |
277                      (reg_lo & CXL_DVSEC_REG_LOCATOR_BLOCK_OFF_LOW_MASK);
278
279         if (offset > pci_resource_len(pdev, bar)) {
280                 dev_warn(&pdev->dev,
281                          "BAR%d: %pr: too small (offset: %pa, type: %d)\n", bar,
282                          &pdev->resource[bar], &offset, reg_type);
283                 return false;
284         }
285
286         map->reg_type = reg_type;
287         map->resource = pci_resource_start(pdev, bar) + offset;
288         map->max_size = pci_resource_len(pdev, bar) - offset;
289         return true;
290 }
291
292 /*
293  * __cxl_find_regblock_instance() - Locate a register block or count instances by type / index
294  * Use CXL_INSTANCES_COUNT for @index if counting instances.
295  *
296  * __cxl_find_regblock_instance() may return:
297  * 0 - if register block enumerated.
298  * >= 0 - if counting instances.
299  * < 0 - error code otherwise.
300  */
301 static int __cxl_find_regblock_instance(struct pci_dev *pdev, enum cxl_regloc_type type,
302                                         struct cxl_register_map *map, int index)
303 {
304         u32 regloc_size, regblocks;
305         int instance = 0;
306         int regloc, i;
307
308         *map = (struct cxl_register_map) {
309                 .host = &pdev->dev,
310                 .resource = CXL_RESOURCE_NONE,
311         };
312
313         regloc = pci_find_dvsec_capability(pdev, PCI_VENDOR_ID_CXL,
314                                            CXL_DVSEC_REG_LOCATOR);
315         if (!regloc)
316                 return -ENXIO;
317
318         pci_read_config_dword(pdev, regloc + PCI_DVSEC_HEADER1, &regloc_size);
319         regloc_size = FIELD_GET(PCI_DVSEC_HEADER1_LENGTH_MASK, regloc_size);
320
321         regloc += CXL_DVSEC_REG_LOCATOR_BLOCK1_OFFSET;
322         regblocks = (regloc_size - CXL_DVSEC_REG_LOCATOR_BLOCK1_OFFSET) / 8;
323
324         for (i = 0; i < regblocks; i++, regloc += 8) {
325                 u32 reg_lo, reg_hi;
326
327                 pci_read_config_dword(pdev, regloc, &reg_lo);
328                 pci_read_config_dword(pdev, regloc + 4, &reg_hi);
329
330                 if (!cxl_decode_regblock(pdev, reg_lo, reg_hi, map))
331                         continue;
332
333                 if (map->reg_type == type) {
334                         if (index == instance)
335                                 return 0;
336                         instance++;
337                 }
338         }
339
340         map->resource = CXL_RESOURCE_NONE;
341         if (index == CXL_INSTANCES_COUNT)
342                 return instance;
343
344         return -ENODEV;
345 }
346
347 /**
348  * cxl_find_regblock_instance() - Locate a register block by type / index
349  * @pdev: The CXL PCI device to enumerate.
350  * @type: Register Block Indicator id
351  * @map: Enumeration output, clobbered on error
352  * @index: Index into which particular instance of a regblock wanted in the
353  *         order found in register locator DVSEC.
354  *
355  * Return: 0 if register block enumerated, negative error code otherwise
356  *
357  * A CXL DVSEC may point to one or more register blocks, search for them
358  * by @type and @index.
359  */
360 int cxl_find_regblock_instance(struct pci_dev *pdev, enum cxl_regloc_type type,
361                                struct cxl_register_map *map, unsigned int index)
362 {
363         return __cxl_find_regblock_instance(pdev, type, map, index);
364 }
365 EXPORT_SYMBOL_NS_GPL(cxl_find_regblock_instance, "CXL");
366
367 /**
368  * cxl_find_regblock() - Locate register blocks by type
369  * @pdev: The CXL PCI device to enumerate.
370  * @type: Register Block Indicator id
371  * @map: Enumeration output, clobbered on error
372  *
373  * Return: 0 if register block enumerated, negative error code otherwise
374  *
375  * A CXL DVSEC may point to one or more register blocks, search for them
376  * by @type.
377  */
378 int cxl_find_regblock(struct pci_dev *pdev, enum cxl_regloc_type type,
379                       struct cxl_register_map *map)
380 {
381         return __cxl_find_regblock_instance(pdev, type, map, 0);
382 }
383 EXPORT_SYMBOL_NS_GPL(cxl_find_regblock, "CXL");
384
385 /**
386  * cxl_count_regblock() - Count instances of a given regblock type.
387  * @pdev: The CXL PCI device to enumerate.
388  * @type: Register Block Indicator id
389  *
390  * Some regblocks may be repeated. Count how many instances.
391  *
392  * Return: non-negative count of matching regblocks, negative error code otherwise.
393  */
394 int cxl_count_regblock(struct pci_dev *pdev, enum cxl_regloc_type type)
395 {
396         struct cxl_register_map map;
397
398         return __cxl_find_regblock_instance(pdev, type, &map, CXL_INSTANCES_COUNT);
399 }
400 EXPORT_SYMBOL_NS_GPL(cxl_count_regblock, "CXL");
401
402 int cxl_map_pmu_regs(struct cxl_register_map *map, struct cxl_pmu_regs *regs)
403 {
404         struct device *dev = map->host;
405         resource_size_t phys_addr;
406
407         phys_addr = map->resource;
408         regs->pmu = devm_cxl_iomap_block(dev, phys_addr, CXL_PMU_REGMAP_SIZE);
409         if (!regs->pmu)
410                 return -ENOMEM;
411
412         return 0;
413 }
414 EXPORT_SYMBOL_NS_GPL(cxl_map_pmu_regs, "CXL");
415
416 static int cxl_map_regblock(struct cxl_register_map *map)
417 {
418         struct device *host = map->host;
419
420         map->base = ioremap(map->resource, map->max_size);
421         if (!map->base) {
422                 dev_err(host, "failed to map registers\n");
423                 return -ENOMEM;
424         }
425
426         dev_dbg(host, "Mapped CXL Memory Device resource %pa\n", &map->resource);
427         return 0;
428 }
429
430 static void cxl_unmap_regblock(struct cxl_register_map *map)
431 {
432         iounmap(map->base);
433         map->base = NULL;
434 }
435
436 static int cxl_probe_regs(struct cxl_register_map *map)
437 {
438         struct cxl_component_reg_map *comp_map;
439         struct cxl_device_reg_map *dev_map;
440         struct device *host = map->host;
441         void __iomem *base = map->base;
442
443         switch (map->reg_type) {
444         case CXL_REGLOC_RBI_COMPONENT:
445                 comp_map = &map->component_map;
446                 cxl_probe_component_regs(host, base, comp_map);
447                 dev_dbg(host, "Set up component registers\n");
448                 break;
449         case CXL_REGLOC_RBI_MEMDEV:
450                 dev_map = &map->device_map;
451                 cxl_probe_device_regs(host, base, dev_map);
452                 if (!dev_map->status.valid || !dev_map->mbox.valid ||
453                     !dev_map->memdev.valid) {
454                         dev_err(host, "registers not found: %s%s%s\n",
455                                 !dev_map->status.valid ? "status " : "",
456                                 !dev_map->mbox.valid ? "mbox " : "",
457                                 !dev_map->memdev.valid ? "memdev " : "");
458                         return -ENXIO;
459                 }
460
461                 dev_dbg(host, "Probing device registers...\n");
462                 break;
463         default:
464                 break;
465         }
466
467         return 0;
468 }
469
470 int cxl_setup_regs(struct cxl_register_map *map)
471 {
472         int rc;
473
474         rc = cxl_map_regblock(map);
475         if (rc)
476                 return rc;
477
478         rc = cxl_probe_regs(map);
479         cxl_unmap_regblock(map);
480
481         return rc;
482 }
483 EXPORT_SYMBOL_NS_GPL(cxl_setup_regs, "CXL");
484
485 u16 cxl_rcrb_to_aer(struct device *dev, resource_size_t rcrb)
486 {
487         void __iomem *addr;
488         u16 offset = 0;
489         u32 cap_hdr;
490
491         if (WARN_ON_ONCE(rcrb == CXL_RESOURCE_NONE))
492                 return 0;
493
494         if (!request_mem_region(rcrb, SZ_4K, dev_name(dev)))
495                 return 0;
496
497         addr = ioremap(rcrb, SZ_4K);
498         if (!addr)
499                 goto out;
500
501         cap_hdr = readl(addr + offset);
502         while (PCI_EXT_CAP_ID(cap_hdr) != PCI_EXT_CAP_ID_ERR) {
503                 offset = PCI_EXT_CAP_NEXT(cap_hdr);
504
505                 /* Offset 0 terminates capability list. */
506                 if (!offset)
507                         break;
508                 cap_hdr = readl(addr + offset);
509         }
510
511         if (offset)
512                 dev_dbg(dev, "found AER extended capability (0x%x)\n", offset);
513
514         iounmap(addr);
515 out:
516         release_mem_region(rcrb, SZ_4K);
517
518         return offset;
519 }
520
521 static resource_size_t cxl_rcrb_to_linkcap(struct device *dev, struct cxl_dport *dport)
522 {
523         resource_size_t rcrb = dport->rcrb.base;
524         void __iomem *addr;
525         u32 cap_hdr;
526         u16 offset;
527
528         if (!request_mem_region(rcrb, SZ_4K, "CXL RCRB"))
529                 return CXL_RESOURCE_NONE;
530
531         addr = ioremap(rcrb, SZ_4K);
532         if (!addr) {
533                 dev_err(dev, "Failed to map region %pr\n", addr);
534                 release_mem_region(rcrb, SZ_4K);
535                 return CXL_RESOURCE_NONE;
536         }
537
538         offset = FIELD_GET(PCI_RCRB_CAP_LIST_ID_MASK, readw(addr + PCI_CAPABILITY_LIST));
539         cap_hdr = readl(addr + offset);
540         while ((FIELD_GET(PCI_RCRB_CAP_HDR_ID_MASK, cap_hdr)) != PCI_CAP_ID_EXP) {
541                 offset = FIELD_GET(PCI_RCRB_CAP_HDR_NEXT_MASK, cap_hdr);
542                 if (offset == 0 || offset > SZ_4K) {
543                         offset = 0;
544                         break;
545                 }
546                 cap_hdr = readl(addr + offset);
547         }
548
549         iounmap(addr);
550         release_mem_region(rcrb, SZ_4K);
551         if (!offset)
552                 return CXL_RESOURCE_NONE;
553
554         return offset;
555 }
556
557 int cxl_dport_map_rcd_linkcap(struct pci_dev *pdev, struct cxl_dport *dport)
558 {
559         void __iomem *dport_pcie_cap = NULL;
560         resource_size_t pos;
561         struct cxl_rcrb_info *ri;
562
563         ri = &dport->rcrb;
564         pos = cxl_rcrb_to_linkcap(&pdev->dev, dport);
565         if (pos == CXL_RESOURCE_NONE)
566                 return -ENXIO;
567
568         dport_pcie_cap = devm_cxl_iomap_block(&pdev->dev,
569                                               ri->base + pos,
570                                               PCI_CAP_EXP_SIZEOF);
571         dport->regs.rcd_pcie_cap = dport_pcie_cap;
572
573         return 0;
574 }
575 EXPORT_SYMBOL_NS_GPL(cxl_dport_map_rcd_linkcap, "CXL");
576
577 resource_size_t __rcrb_to_component(struct device *dev, struct cxl_rcrb_info *ri,
578                                     enum cxl_rcrb which)
579 {
580         resource_size_t component_reg_phys;
581         resource_size_t rcrb = ri->base;
582         void __iomem *addr;
583         u32 bar0, bar1;
584         u16 cmd;
585         u32 id;
586
587         if (which == CXL_RCRB_UPSTREAM)
588                 rcrb += SZ_4K;
589
590         /*
591          * RCRB's BAR[0..1] point to component block containing CXL
592          * subsystem component registers. MEMBAR extraction follows
593          * the PCI Base spec here, esp. 64 bit extraction and memory
594          * ranges alignment (6.0, 7.5.1.2.1).
595          */
596         if (!request_mem_region(rcrb, SZ_4K, "CXL RCRB"))
597                 return CXL_RESOURCE_NONE;
598         addr = ioremap(rcrb, SZ_4K);
599         if (!addr) {
600                 dev_err(dev, "Failed to map region %pr\n", addr);
601                 release_mem_region(rcrb, SZ_4K);
602                 return CXL_RESOURCE_NONE;
603         }
604
605         id = readl(addr + PCI_VENDOR_ID);
606         cmd = readw(addr + PCI_COMMAND);
607         bar0 = readl(addr + PCI_BASE_ADDRESS_0);
608         bar1 = readl(addr + PCI_BASE_ADDRESS_1);
609         iounmap(addr);
610         release_mem_region(rcrb, SZ_4K);
611
612         /*
613          * Sanity check, see CXL 3.0 Figure 9-8 CXL Device that Does Not
614          * Remap Upstream Port and Component Registers
615          */
616         if (id == U32_MAX) {
617                 if (which == CXL_RCRB_DOWNSTREAM)
618                         dev_err(dev, "Failed to access Downstream Port RCRB\n");
619                 return CXL_RESOURCE_NONE;
620         }
621         if (!(cmd & PCI_COMMAND_MEMORY))
622                 return CXL_RESOURCE_NONE;
623         /* The RCRB is a Memory Window, and the MEM_TYPE_1M bit is obsolete */
624         if (bar0 & (PCI_BASE_ADDRESS_MEM_TYPE_1M | PCI_BASE_ADDRESS_SPACE_IO))
625                 return CXL_RESOURCE_NONE;
626
627         component_reg_phys = bar0 & PCI_BASE_ADDRESS_MEM_MASK;
628         if (bar0 & PCI_BASE_ADDRESS_MEM_TYPE_64)
629                 component_reg_phys |= ((u64)bar1) << 32;
630
631         if (!component_reg_phys)
632                 return CXL_RESOURCE_NONE;
633
634         /* MEMBAR is block size (64k) aligned. */
635         if (!IS_ALIGNED(component_reg_phys, CXL_COMPONENT_REG_BLOCK_SIZE))
636                 return CXL_RESOURCE_NONE;
637
638         return component_reg_phys;
639 }
640
641 resource_size_t cxl_rcd_component_reg_phys(struct device *dev,
642                                            struct cxl_dport *dport)
643 {
644         if (!dport->rch)
645                 return CXL_RESOURCE_NONE;
646         return __rcrb_to_component(dev, &dport->rcrb, CXL_RCRB_UPSTREAM);
647 }
648 EXPORT_SYMBOL_NS_GPL(cxl_rcd_component_reg_phys, "CXL");
This page took 0.068784 seconds and 4 git commands to generate.