]> Git Repo - linux.git/blob - drivers/pci/controller/cadence/pcie-cadence-host.c
Merge tag 'cxl-for-6.0' of git://git.kernel.org/pub/scm/linux/kernel/git/cxl/cxl
[linux.git] / drivers / pci / controller / cadence / pcie-cadence-host.c
1 // SPDX-License-Identifier: GPL-2.0
2 // Copyright (c) 2017 Cadence
3 // Cadence PCIe host controller driver.
4 // Author: Cyrille Pitchen <[email protected]>
5
6 #include <linux/delay.h>
7 #include <linux/kernel.h>
8 #include <linux/list_sort.h>
9 #include <linux/of_address.h>
10 #include <linux/of_pci.h>
11 #include <linux/platform_device.h>
12
13 #include "pcie-cadence.h"
14
15 static u64 bar_max_size[] = {
16         [RP_BAR0] = _ULL(128 * SZ_2G),
17         [RP_BAR1] = SZ_2G,
18         [RP_NO_BAR] = _BITULL(63),
19 };
20
21 static u8 bar_aperture_mask[] = {
22         [RP_BAR0] = 0x1F,
23         [RP_BAR1] = 0xF,
24 };
25
26 void __iomem *cdns_pci_map_bus(struct pci_bus *bus, unsigned int devfn,
27                                int where)
28 {
29         struct pci_host_bridge *bridge = pci_find_host_bridge(bus);
30         struct cdns_pcie_rc *rc = pci_host_bridge_priv(bridge);
31         struct cdns_pcie *pcie = &rc->pcie;
32         unsigned int busn = bus->number;
33         u32 addr0, desc0;
34
35         if (pci_is_root_bus(bus)) {
36                 /*
37                  * Only the root port (devfn == 0) is connected to this bus.
38                  * All other PCI devices are behind some bridge hence on another
39                  * bus.
40                  */
41                 if (devfn)
42                         return NULL;
43
44                 return pcie->reg_base + (where & 0xfff);
45         }
46         /* Check that the link is up */
47         if (!(cdns_pcie_readl(pcie, CDNS_PCIE_LM_BASE) & 0x1))
48                 return NULL;
49         /* Clear AXI link-down status */
50         cdns_pcie_writel(pcie, CDNS_PCIE_AT_LINKDOWN, 0x0);
51
52         /* Update Output registers for AXI region 0. */
53         addr0 = CDNS_PCIE_AT_OB_REGION_PCI_ADDR0_NBITS(12) |
54                 CDNS_PCIE_AT_OB_REGION_PCI_ADDR0_DEVFN(devfn) |
55                 CDNS_PCIE_AT_OB_REGION_PCI_ADDR0_BUS(busn);
56         cdns_pcie_writel(pcie, CDNS_PCIE_AT_OB_REGION_PCI_ADDR0(0), addr0);
57
58         /* Configuration Type 0 or Type 1 access. */
59         desc0 = CDNS_PCIE_AT_OB_REGION_DESC0_HARDCODED_RID |
60                 CDNS_PCIE_AT_OB_REGION_DESC0_DEVFN(0);
61         /*
62          * The bus number was already set once for all in desc1 by
63          * cdns_pcie_host_init_address_translation().
64          */
65         if (busn == bridge->busnr + 1)
66                 desc0 |= CDNS_PCIE_AT_OB_REGION_DESC0_TYPE_CONF_TYPE0;
67         else
68                 desc0 |= CDNS_PCIE_AT_OB_REGION_DESC0_TYPE_CONF_TYPE1;
69         cdns_pcie_writel(pcie, CDNS_PCIE_AT_OB_REGION_DESC0(0), desc0);
70
71         return rc->cfg_base + (where & 0xfff);
72 }
73
74 static struct pci_ops cdns_pcie_host_ops = {
75         .map_bus        = cdns_pci_map_bus,
76         .read           = pci_generic_config_read,
77         .write          = pci_generic_config_write,
78 };
79
80 static int cdns_pcie_host_wait_for_link(struct cdns_pcie *pcie)
81 {
82         struct device *dev = pcie->dev;
83         int retries;
84
85         /* Check if the link is up or not */
86         for (retries = 0; retries < LINK_WAIT_MAX_RETRIES; retries++) {
87                 if (cdns_pcie_link_up(pcie)) {
88                         dev_info(dev, "Link up\n");
89                         return 0;
90                 }
91                 usleep_range(LINK_WAIT_USLEEP_MIN, LINK_WAIT_USLEEP_MAX);
92         }
93
94         return -ETIMEDOUT;
95 }
96
97 static int cdns_pcie_retrain(struct cdns_pcie *pcie)
98 {
99         u32 lnk_cap_sls, pcie_cap_off = CDNS_PCIE_RP_CAP_OFFSET;
100         u16 lnk_stat, lnk_ctl;
101         int ret = 0;
102
103         /*
104          * Set retrain bit if current speed is 2.5 GB/s,
105          * but the PCIe root port support is > 2.5 GB/s.
106          */
107
108         lnk_cap_sls = cdns_pcie_readl(pcie, (CDNS_PCIE_RP_BASE + pcie_cap_off +
109                                              PCI_EXP_LNKCAP));
110         if ((lnk_cap_sls & PCI_EXP_LNKCAP_SLS) <= PCI_EXP_LNKCAP_SLS_2_5GB)
111                 return ret;
112
113         lnk_stat = cdns_pcie_rp_readw(pcie, pcie_cap_off + PCI_EXP_LNKSTA);
114         if ((lnk_stat & PCI_EXP_LNKSTA_CLS) == PCI_EXP_LNKSTA_CLS_2_5GB) {
115                 lnk_ctl = cdns_pcie_rp_readw(pcie,
116                                              pcie_cap_off + PCI_EXP_LNKCTL);
117                 lnk_ctl |= PCI_EXP_LNKCTL_RL;
118                 cdns_pcie_rp_writew(pcie, pcie_cap_off + PCI_EXP_LNKCTL,
119                                     lnk_ctl);
120
121                 ret = cdns_pcie_host_wait_for_link(pcie);
122         }
123         return ret;
124 }
125
126 static void cdns_pcie_host_enable_ptm_response(struct cdns_pcie *pcie)
127 {
128         u32 val;
129
130         val = cdns_pcie_readl(pcie, CDNS_PCIE_LM_PTM_CTRL);
131         cdns_pcie_writel(pcie, CDNS_PCIE_LM_PTM_CTRL, val | CDNS_PCIE_LM_TPM_CTRL_PTMRSEN);
132 }
133
134 static int cdns_pcie_host_start_link(struct cdns_pcie_rc *rc)
135 {
136         struct cdns_pcie *pcie = &rc->pcie;
137         int ret;
138
139         ret = cdns_pcie_host_wait_for_link(pcie);
140
141         /*
142          * Retrain link for Gen2 training defect
143          * if quirk flag is set.
144          */
145         if (!ret && rc->quirk_retrain_flag)
146                 ret = cdns_pcie_retrain(pcie);
147
148         return ret;
149 }
150
151 static int cdns_pcie_host_init_root_port(struct cdns_pcie_rc *rc)
152 {
153         struct cdns_pcie *pcie = &rc->pcie;
154         u32 value, ctrl;
155         u32 id;
156
157         /*
158          * Set the root complex BAR configuration register:
159          * - disable both BAR0 and BAR1.
160          * - enable Prefetchable Memory Base and Limit registers in type 1
161          *   config space (64 bits).
162          * - enable IO Base and Limit registers in type 1 config
163          *   space (32 bits).
164          */
165         ctrl = CDNS_PCIE_LM_BAR_CFG_CTRL_DISABLED;
166         value = CDNS_PCIE_LM_RC_BAR_CFG_BAR0_CTRL(ctrl) |
167                 CDNS_PCIE_LM_RC_BAR_CFG_BAR1_CTRL(ctrl) |
168                 CDNS_PCIE_LM_RC_BAR_CFG_PREFETCH_MEM_ENABLE |
169                 CDNS_PCIE_LM_RC_BAR_CFG_PREFETCH_MEM_64BITS |
170                 CDNS_PCIE_LM_RC_BAR_CFG_IO_ENABLE |
171                 CDNS_PCIE_LM_RC_BAR_CFG_IO_32BITS;
172         cdns_pcie_writel(pcie, CDNS_PCIE_LM_RC_BAR_CFG, value);
173
174         /* Set root port configuration space */
175         if (rc->vendor_id != 0xffff) {
176                 id = CDNS_PCIE_LM_ID_VENDOR(rc->vendor_id) |
177                         CDNS_PCIE_LM_ID_SUBSYS(rc->vendor_id);
178                 cdns_pcie_writel(pcie, CDNS_PCIE_LM_ID, id);
179         }
180
181         if (rc->device_id != 0xffff)
182                 cdns_pcie_rp_writew(pcie, PCI_DEVICE_ID, rc->device_id);
183
184         cdns_pcie_rp_writeb(pcie, PCI_CLASS_REVISION, 0);
185         cdns_pcie_rp_writeb(pcie, PCI_CLASS_PROG, 0);
186         cdns_pcie_rp_writew(pcie, PCI_CLASS_DEVICE, PCI_CLASS_BRIDGE_PCI);
187
188         return 0;
189 }
190
191 static int cdns_pcie_host_bar_ib_config(struct cdns_pcie_rc *rc,
192                                         enum cdns_pcie_rp_bar bar,
193                                         u64 cpu_addr, u64 size,
194                                         unsigned long flags)
195 {
196         struct cdns_pcie *pcie = &rc->pcie;
197         u32 addr0, addr1, aperture, value;
198
199         if (!rc->avail_ib_bar[bar])
200                 return -EBUSY;
201
202         rc->avail_ib_bar[bar] = false;
203
204         aperture = ilog2(size);
205         addr0 = CDNS_PCIE_AT_IB_RP_BAR_ADDR0_NBITS(aperture) |
206                 (lower_32_bits(cpu_addr) & GENMASK(31, 8));
207         addr1 = upper_32_bits(cpu_addr);
208         cdns_pcie_writel(pcie, CDNS_PCIE_AT_IB_RP_BAR_ADDR0(bar), addr0);
209         cdns_pcie_writel(pcie, CDNS_PCIE_AT_IB_RP_BAR_ADDR1(bar), addr1);
210
211         if (bar == RP_NO_BAR)
212                 return 0;
213
214         value = cdns_pcie_readl(pcie, CDNS_PCIE_LM_RC_BAR_CFG);
215         value &= ~(LM_RC_BAR_CFG_CTRL_MEM_64BITS(bar) |
216                    LM_RC_BAR_CFG_CTRL_PREF_MEM_64BITS(bar) |
217                    LM_RC_BAR_CFG_CTRL_MEM_32BITS(bar) |
218                    LM_RC_BAR_CFG_CTRL_PREF_MEM_32BITS(bar) |
219                    LM_RC_BAR_CFG_APERTURE(bar, bar_aperture_mask[bar] + 2));
220         if (size + cpu_addr >= SZ_4G) {
221                 if (!(flags & IORESOURCE_PREFETCH))
222                         value |= LM_RC_BAR_CFG_CTRL_MEM_64BITS(bar);
223                 value |= LM_RC_BAR_CFG_CTRL_PREF_MEM_64BITS(bar);
224         } else {
225                 if (!(flags & IORESOURCE_PREFETCH))
226                         value |= LM_RC_BAR_CFG_CTRL_MEM_32BITS(bar);
227                 value |= LM_RC_BAR_CFG_CTRL_PREF_MEM_32BITS(bar);
228         }
229
230         value |= LM_RC_BAR_CFG_APERTURE(bar, aperture);
231         cdns_pcie_writel(pcie, CDNS_PCIE_LM_RC_BAR_CFG, value);
232
233         return 0;
234 }
235
236 static enum cdns_pcie_rp_bar
237 cdns_pcie_host_find_min_bar(struct cdns_pcie_rc *rc, u64 size)
238 {
239         enum cdns_pcie_rp_bar bar, sel_bar;
240
241         sel_bar = RP_BAR_UNDEFINED;
242         for (bar = RP_BAR0; bar <= RP_NO_BAR; bar++) {
243                 if (!rc->avail_ib_bar[bar])
244                         continue;
245
246                 if (size <= bar_max_size[bar]) {
247                         if (sel_bar == RP_BAR_UNDEFINED) {
248                                 sel_bar = bar;
249                                 continue;
250                         }
251
252                         if (bar_max_size[bar] < bar_max_size[sel_bar])
253                                 sel_bar = bar;
254                 }
255         }
256
257         return sel_bar;
258 }
259
260 static enum cdns_pcie_rp_bar
261 cdns_pcie_host_find_max_bar(struct cdns_pcie_rc *rc, u64 size)
262 {
263         enum cdns_pcie_rp_bar bar, sel_bar;
264
265         sel_bar = RP_BAR_UNDEFINED;
266         for (bar = RP_BAR0; bar <= RP_NO_BAR; bar++) {
267                 if (!rc->avail_ib_bar[bar])
268                         continue;
269
270                 if (size >= bar_max_size[bar]) {
271                         if (sel_bar == RP_BAR_UNDEFINED) {
272                                 sel_bar = bar;
273                                 continue;
274                         }
275
276                         if (bar_max_size[bar] > bar_max_size[sel_bar])
277                                 sel_bar = bar;
278                 }
279         }
280
281         return sel_bar;
282 }
283
284 static int cdns_pcie_host_bar_config(struct cdns_pcie_rc *rc,
285                                      struct resource_entry *entry)
286 {
287         u64 cpu_addr, pci_addr, size, winsize;
288         struct cdns_pcie *pcie = &rc->pcie;
289         struct device *dev = pcie->dev;
290         enum cdns_pcie_rp_bar bar;
291         unsigned long flags;
292         int ret;
293
294         cpu_addr = entry->res->start;
295         pci_addr = entry->res->start - entry->offset;
296         flags = entry->res->flags;
297         size = resource_size(entry->res);
298
299         if (entry->offset) {
300                 dev_err(dev, "PCI addr: %llx must be equal to CPU addr: %llx\n",
301                         pci_addr, cpu_addr);
302                 return -EINVAL;
303         }
304
305         while (size > 0) {
306                 /*
307                  * Try to find a minimum BAR whose size is greater than
308                  * or equal to the remaining resource_entry size. This will
309                  * fail if the size of each of the available BARs is less than
310                  * the remaining resource_entry size.
311                  * If a minimum BAR is found, IB ATU will be configured and
312                  * exited.
313                  */
314                 bar = cdns_pcie_host_find_min_bar(rc, size);
315                 if (bar != RP_BAR_UNDEFINED) {
316                         ret = cdns_pcie_host_bar_ib_config(rc, bar, cpu_addr,
317                                                            size, flags);
318                         if (ret)
319                                 dev_err(dev, "IB BAR: %d config failed\n", bar);
320                         return ret;
321                 }
322
323                 /*
324                  * If the control reaches here, it would mean the remaining
325                  * resource_entry size cannot be fitted in a single BAR. So we
326                  * find a maximum BAR whose size is less than or equal to the
327                  * remaining resource_entry size and split the resource entry
328                  * so that part of resource entry is fitted inside the maximum
329                  * BAR. The remaining size would be fitted during the next
330                  * iteration of the loop.
331                  * If a maximum BAR is not found, there is no way we can fit
332                  * this resource_entry, so we error out.
333                  */
334                 bar = cdns_pcie_host_find_max_bar(rc, size);
335                 if (bar == RP_BAR_UNDEFINED) {
336                         dev_err(dev, "No free BAR to map cpu_addr %llx\n",
337                                 cpu_addr);
338                         return -EINVAL;
339                 }
340
341                 winsize = bar_max_size[bar];
342                 ret = cdns_pcie_host_bar_ib_config(rc, bar, cpu_addr, winsize,
343                                                    flags);
344                 if (ret) {
345                         dev_err(dev, "IB BAR: %d config failed\n", bar);
346                         return ret;
347                 }
348
349                 size -= winsize;
350                 cpu_addr += winsize;
351         }
352
353         return 0;
354 }
355
356 static int cdns_pcie_host_dma_ranges_cmp(void *priv, const struct list_head *a,
357                                          const struct list_head *b)
358 {
359         struct resource_entry *entry1, *entry2;
360
361         entry1 = container_of(a, struct resource_entry, node);
362         entry2 = container_of(b, struct resource_entry, node);
363
364         return resource_size(entry2->res) - resource_size(entry1->res);
365 }
366
367 static int cdns_pcie_host_map_dma_ranges(struct cdns_pcie_rc *rc)
368 {
369         struct cdns_pcie *pcie = &rc->pcie;
370         struct device *dev = pcie->dev;
371         struct device_node *np = dev->of_node;
372         struct pci_host_bridge *bridge;
373         struct resource_entry *entry;
374         u32 no_bar_nbits = 32;
375         int err;
376
377         bridge = pci_host_bridge_from_priv(rc);
378         if (!bridge)
379                 return -ENOMEM;
380
381         if (list_empty(&bridge->dma_ranges)) {
382                 of_property_read_u32(np, "cdns,no-bar-match-nbits",
383                                      &no_bar_nbits);
384                 err = cdns_pcie_host_bar_ib_config(rc, RP_NO_BAR, 0x0,
385                                                    (u64)1 << no_bar_nbits, 0);
386                 if (err)
387                         dev_err(dev, "IB BAR: %d config failed\n", RP_NO_BAR);
388                 return err;
389         }
390
391         list_sort(NULL, &bridge->dma_ranges, cdns_pcie_host_dma_ranges_cmp);
392
393         resource_list_for_each_entry(entry, &bridge->dma_ranges) {
394                 err = cdns_pcie_host_bar_config(rc, entry);
395                 if (err) {
396                         dev_err(dev, "Fail to configure IB using dma-ranges\n");
397                         return err;
398                 }
399         }
400
401         return 0;
402 }
403
404 static int cdns_pcie_host_init_address_translation(struct cdns_pcie_rc *rc)
405 {
406         struct cdns_pcie *pcie = &rc->pcie;
407         struct pci_host_bridge *bridge = pci_host_bridge_from_priv(rc);
408         struct resource *cfg_res = rc->cfg_res;
409         struct resource_entry *entry;
410         u64 cpu_addr = cfg_res->start;
411         u32 addr0, addr1, desc1;
412         int r, busnr = 0;
413
414         entry = resource_list_first_type(&bridge->windows, IORESOURCE_BUS);
415         if (entry)
416                 busnr = entry->res->start;
417
418         /*
419          * Reserve region 0 for PCI configure space accesses:
420          * OB_REGION_PCI_ADDR0 and OB_REGION_DESC0 are updated dynamically by
421          * cdns_pci_map_bus(), other region registers are set here once for all.
422          */
423         addr1 = 0; /* Should be programmed to zero. */
424         desc1 = CDNS_PCIE_AT_OB_REGION_DESC1_BUS(busnr);
425         cdns_pcie_writel(pcie, CDNS_PCIE_AT_OB_REGION_PCI_ADDR1(0), addr1);
426         cdns_pcie_writel(pcie, CDNS_PCIE_AT_OB_REGION_DESC1(0), desc1);
427
428         if (pcie->ops->cpu_addr_fixup)
429                 cpu_addr = pcie->ops->cpu_addr_fixup(pcie, cpu_addr);
430
431         addr0 = CDNS_PCIE_AT_OB_REGION_CPU_ADDR0_NBITS(12) |
432                 (lower_32_bits(cpu_addr) & GENMASK(31, 8));
433         addr1 = upper_32_bits(cpu_addr);
434         cdns_pcie_writel(pcie, CDNS_PCIE_AT_OB_REGION_CPU_ADDR0(0), addr0);
435         cdns_pcie_writel(pcie, CDNS_PCIE_AT_OB_REGION_CPU_ADDR1(0), addr1);
436
437         r = 1;
438         resource_list_for_each_entry(entry, &bridge->windows) {
439                 struct resource *res = entry->res;
440                 u64 pci_addr = res->start - entry->offset;
441
442                 if (resource_type(res) == IORESOURCE_IO)
443                         cdns_pcie_set_outbound_region(pcie, busnr, 0, r,
444                                                       true,
445                                                       pci_pio_to_address(res->start),
446                                                       pci_addr,
447                                                       resource_size(res));
448                 else
449                         cdns_pcie_set_outbound_region(pcie, busnr, 0, r,
450                                                       false,
451                                                       res->start,
452                                                       pci_addr,
453                                                       resource_size(res));
454
455                 r++;
456         }
457
458         return cdns_pcie_host_map_dma_ranges(rc);
459 }
460
461 static int cdns_pcie_host_init(struct device *dev,
462                                struct cdns_pcie_rc *rc)
463 {
464         int err;
465
466         err = cdns_pcie_host_init_root_port(rc);
467         if (err)
468                 return err;
469
470         return cdns_pcie_host_init_address_translation(rc);
471 }
472
473 int cdns_pcie_host_setup(struct cdns_pcie_rc *rc)
474 {
475         struct device *dev = rc->pcie.dev;
476         struct platform_device *pdev = to_platform_device(dev);
477         struct device_node *np = dev->of_node;
478         struct pci_host_bridge *bridge;
479         enum cdns_pcie_rp_bar bar;
480         struct cdns_pcie *pcie;
481         struct resource *res;
482         int ret;
483
484         bridge = pci_host_bridge_from_priv(rc);
485         if (!bridge)
486                 return -ENOMEM;
487
488         pcie = &rc->pcie;
489         pcie->is_rc = true;
490
491         rc->vendor_id = 0xffff;
492         of_property_read_u32(np, "vendor-id", &rc->vendor_id);
493
494         rc->device_id = 0xffff;
495         of_property_read_u32(np, "device-id", &rc->device_id);
496
497         pcie->reg_base = devm_platform_ioremap_resource_byname(pdev, "reg");
498         if (IS_ERR(pcie->reg_base)) {
499                 dev_err(dev, "missing \"reg\"\n");
500                 return PTR_ERR(pcie->reg_base);
501         }
502
503         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "cfg");
504         rc->cfg_base = devm_pci_remap_cfg_resource(dev, res);
505         if (IS_ERR(rc->cfg_base))
506                 return PTR_ERR(rc->cfg_base);
507         rc->cfg_res = res;
508
509         if (rc->quirk_detect_quiet_flag)
510                 cdns_pcie_detect_quiet_min_delay_set(&rc->pcie);
511
512         cdns_pcie_host_enable_ptm_response(pcie);
513
514         ret = cdns_pcie_start_link(pcie);
515         if (ret) {
516                 dev_err(dev, "Failed to start link\n");
517                 return ret;
518         }
519
520         ret = cdns_pcie_host_start_link(rc);
521         if (ret)
522                 dev_dbg(dev, "PCIe link never came up\n");
523
524         for (bar = RP_BAR0; bar <= RP_NO_BAR; bar++)
525                 rc->avail_ib_bar[bar] = true;
526
527         ret = cdns_pcie_host_init(dev, rc);
528         if (ret)
529                 return ret;
530
531         if (!bridge->ops)
532                 bridge->ops = &cdns_pcie_host_ops;
533
534         ret = pci_host_probe(bridge);
535         if (ret < 0)
536                 goto err_init;
537
538         return 0;
539
540  err_init:
541         pm_runtime_put_sync(dev);
542
543         return ret;
544 }
This page took 0.067715 seconds and 4 git commands to generate.