drivers/pci/controller/dwc/pcie-designware.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Synopsys DesignWare PCIe host controller driver
   4  *
   5  * Copyright (C) 2013 Samsung Electronics Co., Ltd.
   6  *              https://www.samsung.com
   7  *
   8  * Author: Jingoo Han <jg1.han@samsung.com>
   9  */
  10
  11 #include <linux/delay.h>
  12 #include <linux/of.h>
  13 #include <linux/types.h>
  14
  15 #include "../../pci.h"
  16 #include "pcie-designware.h"
  17
  18 /*
  19  * These interfaces resemble the pci_find_*capability() interfaces, but these
  20  * are for configuring host controllers, which are bridges *to* PCI devices but
  21  * are not PCI devices themselves.
  22  */
  23 static u8 __dw_pcie_find_next_cap(struct dw_pcie *pci, u8 cap_ptr,
  24                                   u8 cap)
  25 {
  26         u8 cap_id, next_cap_ptr;
  27         u16 reg;
  28
  29         if (!cap_ptr)
  30                 return 0;
  31
  32         reg = dw_pcie_readw_dbi(pci, cap_ptr);
  33         cap_id = (reg & 0x00ff);
  34
  35         if (cap_id > PCI_CAP_ID_MAX)
  36                 return 0;
  37
  38         if (cap_id == cap)
  39                 return cap_ptr;
  40
  41         next_cap_ptr = (reg & 0xff00) >> 8;
  42         return __dw_pcie_find_next_cap(pci, next_cap_ptr, cap);
  43 }
  44
  45 u8 dw_pcie_find_capability(struct dw_pcie *pci, u8 cap)
  46 {
  47         u8 next_cap_ptr;
  48         u16 reg;
  49
  50         reg = dw_pcie_readw_dbi(pci, PCI_CAPABILITY_LIST);
  51         next_cap_ptr = (reg & 0x00ff);
  52
  53         return __dw_pcie_find_next_cap(pci, next_cap_ptr, cap);
  54 }
  55 EXPORT_SYMBOL_GPL(dw_pcie_find_capability);
  56
  57 static u16 dw_pcie_find_next_ext_capability(struct dw_pcie *pci, u16 start,
  58                                             u8 cap)
  59 {
  60         u32 header;
  61         int ttl;
  62         int pos = PCI_CFG_SPACE_SIZE;
  63
  64         /* minimum 8 bytes per capability */
  65         ttl = (PCI_CFG_SPACE_EXP_SIZE - PCI_CFG_SPACE_SIZE) / 8;
  66
  67         if (start)
  68                 pos = start;
  69
  70         header = dw_pcie_readl_dbi(pci, pos);
  71         /*
  72          * If we have no capabilities, this is indicated by cap ID,
  73          * cap version and next pointer all being 0.
  74          */
  75         if (header == 0)
  76                 return 0;
  77
  78         while (ttl-- > 0) {
  79                 if (PCI_EXT_CAP_ID(header) == cap && pos != start)
  80                         return pos;
  81
  82                 pos = PCI_EXT_CAP_NEXT(header);
  83                 if (pos < PCI_CFG_SPACE_SIZE)
  84                         break;
  85
  86                 header = dw_pcie_readl_dbi(pci, pos);
  87         }
  88
  89         return 0;
  90 }
  91
  92 u16 dw_pcie_find_ext_capability(struct dw_pcie *pci, u8 cap)
  93 {
  94         return dw_pcie_find_next_ext_capability(pci, 0, cap);
  95 }
  96 EXPORT_SYMBOL_GPL(dw_pcie_find_ext_capability);
  97
  98 int dw_pcie_read(void __iomem *addr, int size, u32 *val)
  99 {
 100         if (!IS_ALIGNED((uintptr_t)addr, size)) {
 101                 *val = 0;
 102                 return PCIBIOS_BAD_REGISTER_NUMBER;
 103         }
 104
 105         if (size == 4) {
 106                 *val = readl(addr);
 107         } else if (size == 2) {
 108                 *val = readw(addr);
 109         } else if (size == 1) {
 110                 *val = readb(addr);
 111         } else {
 112                 *val = 0;
 113                 return PCIBIOS_BAD_REGISTER_NUMBER;
 114         }
 115
 116         return PCIBIOS_SUCCESSFUL;
 117 }
 118 EXPORT_SYMBOL_GPL(dw_pcie_read);
 119
 120 int dw_pcie_write(void __iomem *addr, int size, u32 val)
 121 {
 122         if (!IS_ALIGNED((uintptr_t)addr, size))
 123                 return PCIBIOS_BAD_REGISTER_NUMBER;
 124
 125         if (size == 4)
 126                 writel(val, addr);
 127         else if (size == 2)
 128                 writew(val, addr);
 129         else if (size == 1)
 130                 writeb(val, addr);
 131         else
 132                 return PCIBIOS_BAD_REGISTER_NUMBER;
 133
 134         return PCIBIOS_SUCCESSFUL;
 135 }
 136 EXPORT_SYMBOL_GPL(dw_pcie_write);
 137
 138 u32 dw_pcie_read_dbi(struct dw_pcie *pci, u32 reg, size_t size)
 139 {
 140         int ret;
 141         u32 val;
 142
 143         if (pci->ops->read_dbi)
 144                 return pci->ops->read_dbi(pci, pci->dbi_base, reg, size);
 145
 146         ret = dw_pcie_read(pci->dbi_base + reg, size, &val);
 147         if (ret)
 148                 dev_err(pci->dev, "Read DBI address failed\n");
 149
 150         return val;
 151 }
 152 EXPORT_SYMBOL_GPL(dw_pcie_read_dbi);
 153
 154 void dw_pcie_write_dbi(struct dw_pcie *pci, u32 reg, size_t size, u32 val)
 155 {
 156         int ret;
 157
 158         if (pci->ops->write_dbi) {
 159                 pci->ops->write_dbi(pci, pci->dbi_base, reg, size, val);
 160                 return;
 161         }
 162
 163         ret = dw_pcie_write(pci->dbi_base + reg, size, val);
 164         if (ret)
 165                 dev_err(pci->dev, "Write DBI address failed\n");
 166 }
 167 EXPORT_SYMBOL_GPL(dw_pcie_write_dbi);
 168
 169 void dw_pcie_write_dbi2(struct dw_pcie *pci, u32 reg, size_t size, u32 val)
 170 {
 171         int ret;
 172
 173         if (pci->ops->write_dbi2) {
 174                 pci->ops->write_dbi2(pci, pci->dbi_base2, reg, size, val);
 175                 return;
 176         }
 177
 178         ret = dw_pcie_write(pci->dbi_base2 + reg, size, val);
 179         if (ret)
 180                 dev_err(pci->dev, "write DBI address failed\n");
 181 }
 182
 183 static u32 dw_pcie_readl_atu(struct dw_pcie *pci, u32 reg)
 184 {
 185         int ret;
 186         u32 val;
 187
 188         if (pci->ops->read_dbi)
 189                 return pci->ops->read_dbi(pci, pci->atu_base, reg, 4);
 190
 191         ret = dw_pcie_read(pci->atu_base + reg, 4, &val);
 192         if (ret)
 193                 dev_err(pci->dev, "Read ATU address failed\n");
 194
 195         return val;
 196 }
 197
 198 static void dw_pcie_writel_atu(struct dw_pcie *pci, u32 reg, u32 val)
 199 {
 200         int ret;
 201
 202         if (pci->ops->write_dbi) {
 203                 pci->ops->write_dbi(pci, pci->atu_base, reg, 4, val);
 204                 return;
 205         }
 206
 207         ret = dw_pcie_write(pci->atu_base + reg, 4, val);
 208         if (ret)
 209                 dev_err(pci->dev, "Write ATU address failed\n");
 210 }
 211
 212 static u32 dw_pcie_readl_ob_unroll(struct dw_pcie *pci, u32 index, u32 reg)
 213 {
 214         u32 offset = PCIE_GET_ATU_OUTB_UNR_REG_OFFSET(index);
 215
 216         return dw_pcie_readl_atu(pci, offset + reg);
 217 }
 218
 219 static void dw_pcie_writel_ob_unroll(struct dw_pcie *pci, u32 index, u32 reg,
 220                                      u32 val)
 221 {
 222         u32 offset = PCIE_GET_ATU_OUTB_UNR_REG_OFFSET(index);
 223
 224         dw_pcie_writel_atu(pci, offset + reg, val);
 225 }
 226
 227 static void dw_pcie_prog_outbound_atu_unroll(struct dw_pcie *pci, int index,
 228                                              int type, u64 cpu_addr,
 229                                              u64 pci_addr, u32 size)
 230 {
 231         u32 retries, val;
 232         u64 limit_addr = cpu_addr + size - 1;
 233
 234         dw_pcie_writel_ob_unroll(pci, index, PCIE_ATU_UNR_LOWER_BASE,
 235                                  lower_32_bits(cpu_addr));
 236         dw_pcie_writel_ob_unroll(pci, index, PCIE_ATU_UNR_UPPER_BASE,
 237                                  upper_32_bits(cpu_addr));
 238         dw_pcie_writel_ob_unroll(pci, index, PCIE_ATU_UNR_LOWER_LIMIT,
 239                                  lower_32_bits(limit_addr));
 240         dw_pcie_writel_ob_unroll(pci, index, PCIE_ATU_UNR_UPPER_LIMIT,
 241                                  upper_32_bits(limit_addr));
 242         dw_pcie_writel_ob_unroll(pci, index, PCIE_ATU_UNR_LOWER_TARGET,
 243                                  lower_32_bits(pci_addr));
 244         dw_pcie_writel_ob_unroll(pci, index, PCIE_ATU_UNR_UPPER_TARGET,
 245                                  upper_32_bits(pci_addr));
 246         dw_pcie_writel_ob_unroll(pci, index, PCIE_ATU_UNR_REGION_CTRL1,
 247                                  type);
 248         dw_pcie_writel_ob_unroll(pci, index, PCIE_ATU_UNR_REGION_CTRL2,
 249                                  PCIE_ATU_ENABLE);
 250
 251         /*
 252          * Make sure ATU enable takes effect before any subsequent config
 253          * and I/O accesses.
 254          */
 255         for (retries = 0; retries < LINK_WAIT_MAX_IATU_RETRIES; retries++) {
 256                 val = dw_pcie_readl_ob_unroll(pci, index,
 257                                               PCIE_ATU_UNR_REGION_CTRL2);
 258                 if (val & PCIE_ATU_ENABLE)
 259                         return;
 260
 261                 mdelay(LINK_WAIT_IATU);
 262         }
 263         dev_err(pci->dev, "Outbound iATU is not being enabled\n");
 264 }
 265
 266 void dw_pcie_prog_outbound_atu(struct dw_pcie *pci, int index, int type,
 267                                u64 cpu_addr, u64 pci_addr, u32 size)
 268 {
 269         u32 retries, val;
 270
 271         if (pci->ops->cpu_addr_fixup)
 272                 cpu_addr = pci->ops->cpu_addr_fixup(pci, cpu_addr);
 273
 274         if (pci->iatu_unroll_enabled) {
 275                 dw_pcie_prog_outbound_atu_unroll(pci, index, type, cpu_addr,
 276                                                  pci_addr, size);
 277                 return;
 278         }
 279
 280         dw_pcie_writel_dbi(pci, PCIE_ATU_VIEWPORT,
 281                            PCIE_ATU_REGION_OUTBOUND | index);
 282         dw_pcie_writel_dbi(pci, PCIE_ATU_LOWER_BASE,
 283                            lower_32_bits(cpu_addr));
 284         dw_pcie_writel_dbi(pci, PCIE_ATU_UPPER_BASE,
 285                            upper_32_bits(cpu_addr));
 286         dw_pcie_writel_dbi(pci, PCIE_ATU_LIMIT,
 287                            lower_32_bits(cpu_addr + size - 1));
 288         dw_pcie_writel_dbi(pci, PCIE_ATU_LOWER_TARGET,
 289                            lower_32_bits(pci_addr));
 290         dw_pcie_writel_dbi(pci, PCIE_ATU_UPPER_TARGET,
 291                            upper_32_bits(pci_addr));
 292         dw_pcie_writel_dbi(pci, PCIE_ATU_CR1, type);
 293         dw_pcie_writel_dbi(pci, PCIE_ATU_CR2, PCIE_ATU_ENABLE);
 294
 295         /*
 296          * Make sure ATU enable takes effect before any subsequent config
 297          * and I/O accesses.
 298          */
 299         for (retries = 0; retries < LINK_WAIT_MAX_IATU_RETRIES; retries++) {
 300                 val = dw_pcie_readl_dbi(pci, PCIE_ATU_CR2);
 301                 if (val & PCIE_ATU_ENABLE)
 302                         return;
 303
 304                 mdelay(LINK_WAIT_IATU);
 305         }
 306         dev_err(pci->dev, "Outbound iATU is not being enabled\n");
 307 }
 308
 309 static u32 dw_pcie_readl_ib_unroll(struct dw_pcie *pci, u32 index, u32 reg)
 310 {
 311         u32 offset = PCIE_GET_ATU_INB_UNR_REG_OFFSET(index);
 312
 313         return dw_pcie_readl_atu(pci, offset + reg);
 314 }
 315
 316 static void dw_pcie_writel_ib_unroll(struct dw_pcie *pci, u32 index, u32 reg,
 317                                      u32 val)
 318 {
 319         u32 offset = PCIE_GET_ATU_INB_UNR_REG_OFFSET(index);
 320
 321         dw_pcie_writel_atu(pci, offset + reg, val);
 322 }
 323
 324 static int dw_pcie_prog_inbound_atu_unroll(struct dw_pcie *pci, int index,
 325                                            int bar, u64 cpu_addr,
 326                                            enum dw_pcie_as_type as_type)
 327 {
 328         int type;
 329         u32 retries, val;
 330
 331         dw_pcie_writel_ib_unroll(pci, index, PCIE_ATU_UNR_LOWER_TARGET,
 332                                  lower_32_bits(cpu_addr));
 333         dw_pcie_writel_ib_unroll(pci, index, PCIE_ATU_UNR_UPPER_TARGET,
 334                                  upper_32_bits(cpu_addr));
 335
 336         switch (as_type) {
 337         case DW_PCIE_AS_MEM:
 338                 type = PCIE_ATU_TYPE_MEM;
 339                 break;
 340         case DW_PCIE_AS_IO:
 341                 type = PCIE_ATU_TYPE_IO;
 342                 break;
 343         default:
 344                 return -EINVAL;
 345         }
 346
 347         dw_pcie_writel_ib_unroll(pci, index, PCIE_ATU_UNR_REGION_CTRL1, type);
 348         dw_pcie_writel_ib_unroll(pci, index, PCIE_ATU_UNR_REGION_CTRL2,
 349                                  PCIE_ATU_ENABLE |
 350                                  PCIE_ATU_BAR_MODE_ENABLE | (bar << 8));
 351
 352         /*
 353          * Make sure ATU enable takes effect before any subsequent config
 354          * and I/O accesses.
 355          */
 356         for (retries = 0; retries < LINK_WAIT_MAX_IATU_RETRIES; retries++) {
 357                 val = dw_pcie_readl_ib_unroll(pci, index,
 358                                               PCIE_ATU_UNR_REGION_CTRL2);
 359                 if (val & PCIE_ATU_ENABLE)
 360                         return 0;
 361
 362                 mdelay(LINK_WAIT_IATU);
 363         }
 364         dev_err(pci->dev, "Inbound iATU is not being enabled\n");
 365
 366         return -EBUSY;
 367 }
 368
 369 int dw_pcie_prog_inbound_atu(struct dw_pcie *pci, int index, int bar,
 370                              u64 cpu_addr, enum dw_pcie_as_type as_type)
 371 {
 372         int type;
 373         u32 retries, val;
 374
 375         if (pci->iatu_unroll_enabled)
 376                 return dw_pcie_prog_inbound_atu_unroll(pci, index, bar,
 377                                                        cpu_addr, as_type);
 378
 379         dw_pcie_writel_dbi(pci, PCIE_ATU_VIEWPORT, PCIE_ATU_REGION_INBOUND |
 380                            index);
 381         dw_pcie_writel_dbi(pci, PCIE_ATU_LOWER_TARGET, lower_32_bits(cpu_addr));
 382         dw_pcie_writel_dbi(pci, PCIE_ATU_UPPER_TARGET, upper_32_bits(cpu_addr));
 383
 384         switch (as_type) {
 385         case DW_PCIE_AS_MEM:
 386                 type = PCIE_ATU_TYPE_MEM;
 387                 break;
 388         case DW_PCIE_AS_IO:
 389                 type = PCIE_ATU_TYPE_IO;
 390                 break;
 391         default:
 392                 return -EINVAL;
 393         }
 394
 395         dw_pcie_writel_dbi(pci, PCIE_ATU_CR1, type);
 396         dw_pcie_writel_dbi(pci, PCIE_ATU_CR2, PCIE_ATU_ENABLE
 397                            | PCIE_ATU_BAR_MODE_ENABLE | (bar << 8));
 398
 399         /*
 400          * Make sure ATU enable takes effect before any subsequent config
 401          * and I/O accesses.
 402          */
 403         for (retries = 0; retries < LINK_WAIT_MAX_IATU_RETRIES; retries++) {
 404                 val = dw_pcie_readl_dbi(pci, PCIE_ATU_CR2);
 405                 if (val & PCIE_ATU_ENABLE)
 406                         return 0;
 407
 408                 mdelay(LINK_WAIT_IATU);
 409         }
 410         dev_err(pci->dev, "Inbound iATU is not being enabled\n");
 411
 412         return -EBUSY;
 413 }
 414
 415 void dw_pcie_disable_atu(struct dw_pcie *pci, int index,
 416                          enum dw_pcie_region_type type)
 417 {
 418         int region;
 419
 420         switch (type) {
 421         case DW_PCIE_REGION_INBOUND:
 422                 region = PCIE_ATU_REGION_INBOUND;
 423                 break;
 424         case DW_PCIE_REGION_OUTBOUND:
 425                 region = PCIE_ATU_REGION_OUTBOUND;
 426                 break;
 427         default:
 428                 return;
 429         }
 430
 431         dw_pcie_writel_dbi(pci, PCIE_ATU_VIEWPORT, region | index);
 432         dw_pcie_writel_dbi(pci, PCIE_ATU_CR2, (u32)~PCIE_ATU_ENABLE);
 433 }
 434
 435 int dw_pcie_wait_for_link(struct dw_pcie *pci)
 436 {
 437         int retries;
 438
 439         /* Check if the link is up or not */
 440         for (retries = 0; retries < LINK_WAIT_MAX_RETRIES; retries++) {
 441                 if (dw_pcie_link_up(pci)) {
 442                         dev_info(pci->dev, "Link up\n");
 443                         return 0;
 444                 }
 445                 usleep_range(LINK_WAIT_USLEEP_MIN, LINK_WAIT_USLEEP_MAX);
 446         }
 447
 448         dev_info(pci->dev, "Phy link never came up\n");
 449
 450         return -ETIMEDOUT;
 451 }
 452 EXPORT_SYMBOL_GPL(dw_pcie_wait_for_link);
 453
 454 int dw_pcie_link_up(struct dw_pcie *pci)
 455 {
 456         u32 val;
 457
 458         if (pci->ops->link_up)
 459                 return pci->ops->link_up(pci);
 460
 461         val = readl(pci->dbi_base + PCIE_PORT_DEBUG1);
 462         return ((val & PCIE_PORT_DEBUG1_LINK_UP) &&
 463                 (!(val & PCIE_PORT_DEBUG1_LINK_IN_TRAINING)));
 464 }
 465
 466 void dw_pcie_upconfig_setup(struct dw_pcie *pci)
 467 {
 468         u32 val;
 469
 470         val = dw_pcie_readl_dbi(pci, PCIE_PORT_MULTI_LANE_CTRL);
 471         val |= PORT_MLTI_UPCFG_SUPPORT;
 472         dw_pcie_writel_dbi(pci, PCIE_PORT_MULTI_LANE_CTRL, val);
 473 }
 474 EXPORT_SYMBOL_GPL(dw_pcie_upconfig_setup);
 475
 476 static void dw_pcie_link_set_max_speed(struct dw_pcie *pci, u32 link_gen)
 477 {
 478         u32 cap, ctrl2, link_speed;
 479         u8 offset = dw_pcie_find_capability(pci, PCI_CAP_ID_EXP);
 480
 481         cap = dw_pcie_readl_dbi(pci, offset + PCI_EXP_LNKCAP);
 482         ctrl2 = dw_pcie_readl_dbi(pci, offset + PCI_EXP_LNKCTL2);
 483         ctrl2 &= ~PCI_EXP_LNKCTL2_TLS;
 484
 485         switch (pcie_link_speed[link_gen]) {
 486         case PCIE_SPEED_2_5GT:
 487                 link_speed = PCI_EXP_LNKCTL2_TLS_2_5GT;
 488                 break;
 489         case PCIE_SPEED_5_0GT:
 490                 link_speed = PCI_EXP_LNKCTL2_TLS_5_0GT;
 491                 break;
 492         case PCIE_SPEED_8_0GT:
 493                 link_speed = PCI_EXP_LNKCTL2_TLS_8_0GT;
 494                 break;
 495         case PCIE_SPEED_16_0GT:
 496                 link_speed = PCI_EXP_LNKCTL2_TLS_16_0GT;
 497                 break;
 498         default:
 499                 /* Use hardware capability */
 500                 link_speed = FIELD_GET(PCI_EXP_LNKCAP_SLS, cap);
 501                 ctrl2 &= ~PCI_EXP_LNKCTL2_HASD;
 502                 break;
 503         }
 504
 505         dw_pcie_writel_dbi(pci, offset + PCI_EXP_LNKCTL2, ctrl2 | link_speed);
 506
 507         cap &= ~((u32)PCI_EXP_LNKCAP_SLS);
 508         dw_pcie_writel_dbi(pci, offset + PCI_EXP_LNKCAP, cap | link_speed);
 509
 510 }
 511
 512 void dw_pcie_link_set_n_fts(struct dw_pcie *pci, u32 n_fts)
 513 {
 514         u32 val;
 515
 516         val = dw_pcie_readl_dbi(pci, PCIE_LINK_WIDTH_SPEED_CONTROL);
 517         val &= ~PORT_LOGIC_N_FTS_MASK;
 518         val |= n_fts & PORT_LOGIC_N_FTS_MASK;
 519         dw_pcie_writel_dbi(pci, PCIE_LINK_WIDTH_SPEED_CONTROL, val);
 520 }
 521 EXPORT_SYMBOL_GPL(dw_pcie_link_set_n_fts);
 522
 523 static u8 dw_pcie_iatu_unroll_enabled(struct dw_pcie *pci)
 524 {
 525         u32 val;
 526
 527         val = dw_pcie_readl_dbi(pci, PCIE_ATU_VIEWPORT);
 528         if (val == 0xffffffff)
 529                 return 1;
 530
 531         return 0;
 532 }
 533
 534 void dw_pcie_setup(struct dw_pcie *pci)
 535 {
 536         u32 val;
 537         struct device *dev = pci->dev;
 538         struct device_node *np = dev->of_node;
 539
 540         if (pci->version >= 0x480A || (!pci->version &&
 541                                        dw_pcie_iatu_unroll_enabled(pci))) {
 542                 pci->iatu_unroll_enabled = true;
 543                 if (!pci->atu_base)
 544                         pci->atu_base = pci->dbi_base + DEFAULT_DBI_ATU_OFFSET;
 545         }
 546         dev_dbg(pci->dev, "iATU unroll: %s\n", pci->iatu_unroll_enabled ?
 547                 "enabled" : "disabled");
 548
 549         if (pci->link_gen > 0)
 550                 dw_pcie_link_set_max_speed(pci, pci->link_gen);
 551
 552         val = dw_pcie_readl_dbi(pci, PCIE_PORT_LINK_CONTROL);
 553         val &= ~PORT_LINK_FAST_LINK_MODE;
 554         dw_pcie_writel_dbi(pci, PCIE_PORT_LINK_CONTROL, val);
 555
 556         of_property_read_u32(np, "num-lanes", &pci->num_lanes);
 557         if (!pci->num_lanes) {
 558                 dev_dbg(pci->dev, "Using h/w default number of lanes\n");
 559                 return;
 560         }
 561
 562         /* Set the number of lanes */
 563         val &= ~PORT_LINK_FAST_LINK_MODE;
 564         val &= ~PORT_LINK_MODE_MASK;
 565         switch (pci->num_lanes) {
 566         case 1:
 567                 val |= PORT_LINK_MODE_1_LANES;
 568                 break;
 569         case 2:
 570                 val |= PORT_LINK_MODE_2_LANES;
 571                 break;
 572         case 4:
 573                 val |= PORT_LINK_MODE_4_LANES;
 574                 break;
 575         case 8:
 576                 val |= PORT_LINK_MODE_8_LANES;
 577                 break;
 578         default:
 579                 dev_err(pci->dev, "num-lanes %u: invalid value\n", pci->num_lanes);
 580                 return;
 581         }
 582         dw_pcie_writel_dbi(pci, PCIE_PORT_LINK_CONTROL, val);
 583
 584         /* Set link width speed control register */
 585         val = dw_pcie_readl_dbi(pci, PCIE_LINK_WIDTH_SPEED_CONTROL);
 586         val &= ~PORT_LOGIC_LINK_WIDTH_MASK;
 587         switch (pci->num_lanes) {
 588         case 1:
 589                 val |= PORT_LOGIC_LINK_WIDTH_1_LANES;
 590                 break;
 591         case 2:
 592                 val |= PORT_LOGIC_LINK_WIDTH_2_LANES;
 593                 break;
 594         case 4:
 595                 val |= PORT_LOGIC_LINK_WIDTH_4_LANES;
 596                 break;
 597         case 8:
 598                 val |= PORT_LOGIC_LINK_WIDTH_8_LANES;
 599                 break;
 600         }
 601         dw_pcie_writel_dbi(pci, PCIE_LINK_WIDTH_SPEED_CONTROL, val);
 602
 603         if (of_property_read_bool(np, "snps,enable-cdm-check")) {
 604                 val = dw_pcie_readl_dbi(pci, PCIE_PL_CHK_REG_CONTROL_STATUS);
 605                 val |= PCIE_PL_CHK_REG_CHK_REG_CONTINUOUS |
 606                        PCIE_PL_CHK_REG_CHK_REG_START;
 607                 dw_pcie_writel_dbi(pci, PCIE_PL_CHK_REG_CONTROL_STATUS, val);
 608         }
 609 }