1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * PCIe controller driver for Renesas R-Car Gen4 Series SoCs
4 * Copyright (C) 2022-2023 Renesas Electronics Corporation
5 *
6 * The r8a779g0 (R-Car V4H) controller requires a specific firmware to be
7 * provided, to initialize the PHY. Otherwise, the PCIe controller will not
8 * work.
9 */
10
11 #include <linux/delay.h>
12 #include <linux/firmware.h>
13 #include <linux/interrupt.h>
14 #include <linux/io.h>
15 #include <linux/iopoll.h>
16 #include <linux/module.h>
17 #include <linux/of.h>
18 #include <linux/pci.h>
19 #include <linux/platform_device.h>
20 #include <linux/pm_runtime.h>
21 #include <linux/reset.h>
22
23 #include "../../pci.h"
24 #include "pcie-designware.h"
25
26 /* Renesas-specific */
27 /* PCIe Mode Setting Register 0 */
28 #define PCIEMSR0 0x0000
29 #define APP_SRIS_MODE BIT(6)
30 #define DEVICE_TYPE_EP 0
31 #define DEVICE_TYPE_RC BIT(4)
32 #define BIFUR_MOD_SET_ON BIT(0)
33
34 /* PCIe Interrupt Status 0 */
35 #define PCIEINTSTS0 0x0084
36
37 /* PCIe Interrupt Status 0 Enable */
38 #define PCIEINTSTS0EN 0x0310
39 #define MSI_CTRL_INT BIT(26)
40 #define SMLH_LINK_UP BIT(7)
41 #define RDLH_LINK_UP BIT(6)
42
43 /* PCIe DMA Interrupt Status Enable */
44 #define PCIEDMAINTSTSEN 0x0314
45 #define PCIEDMAINTSTSEN_INIT GENMASK(15, 0)
46
47 /* Port Logic Registers 89 */
48 #define PRTLGC89 0x0b70
49
50 /* Port Logic Registers 90 */
51 #define PRTLGC90 0x0b74
52
53 /* PCIe Reset Control Register 1 */
54 #define PCIERSTCTRL1 0x0014
55 #define APP_HOLD_PHY_RST BIT(16)
56 #define APP_LTSSM_ENABLE BIT(0)
57
58 /* PCIe Power Management Control */
59 #define PCIEPWRMNGCTRL 0x0070
60 #define APP_CLK_REQ_N BIT(11)
61 #define APP_CLK_PM_EN BIT(10)
62
63 #define RCAR_NUM_SPEED_CHANGE_RETRIES 10
64 #define RCAR_MAX_LINK_SPEED 4
65
66 #define RCAR_GEN4_PCIE_EP_FUNC_DBI_OFFSET 0x1000
67 #define RCAR_GEN4_PCIE_EP_FUNC_DBI2_OFFSET 0x800
68
69 #define RCAR_GEN4_PCIE_FIRMWARE_NAME "rcar_gen4_pcie.bin"
70 #define RCAR_GEN4_PCIE_FIRMWARE_BASE_ADDR 0xc000
71 MODULE_FIRMWARE(RCAR_GEN4_PCIE_FIRMWARE_NAME);
72
73 struct rcar_gen4_pcie;
74 struct rcar_gen4_pcie_drvdata {
75 void (*additional_common_init)(struct rcar_gen4_pcie *rcar);
76 int (*ltssm_control)(struct rcar_gen4_pcie *rcar, bool enable);
77 enum dw_pcie_device_mode mode;
78 };
79
80 struct rcar_gen4_pcie {
81 struct dw_pcie dw;
82 void __iomem *base;
83 void __iomem *phy_base;
84 struct platform_device *pdev;
85 const struct rcar_gen4_pcie_drvdata *drvdata;
86 };
87 #define to_rcar_gen4_pcie(_dw) container_of(_dw, struct rcar_gen4_pcie, dw)
88
89 /* Common */
rcar_gen4_pcie_link_up(struct dw_pcie * dw)90 static bool rcar_gen4_pcie_link_up(struct dw_pcie *dw)
91 {
92 struct rcar_gen4_pcie *rcar = to_rcar_gen4_pcie(dw);
93 u32 val, mask;
94
95 val = readl(rcar->base + PCIEINTSTS0);
96 mask = RDLH_LINK_UP | SMLH_LINK_UP;
97
98 return (val & mask) == mask;
99 }
100
101 /*
102 * Manually initiate the speed change. Return 0 if change succeeded; otherwise
103 * -ETIMEDOUT.
104 */
rcar_gen4_pcie_speed_change(struct dw_pcie * dw)105 static int rcar_gen4_pcie_speed_change(struct dw_pcie *dw)
106 {
107 u32 val;
108 int i;
109
110 val = dw_pcie_readl_dbi(dw, PCIE_LINK_WIDTH_SPEED_CONTROL);
111 val &= ~PORT_LOGIC_SPEED_CHANGE;
112 dw_pcie_writel_dbi(dw, PCIE_LINK_WIDTH_SPEED_CONTROL, val);
113
114 val = dw_pcie_readl_dbi(dw, PCIE_LINK_WIDTH_SPEED_CONTROL);
115 val |= PORT_LOGIC_SPEED_CHANGE;
116 dw_pcie_writel_dbi(dw, PCIE_LINK_WIDTH_SPEED_CONTROL, val);
117
118 for (i = 0; i < RCAR_NUM_SPEED_CHANGE_RETRIES; i++) {
119 val = dw_pcie_readl_dbi(dw, PCIE_LINK_WIDTH_SPEED_CONTROL);
120 if (!(val & PORT_LOGIC_SPEED_CHANGE))
121 return 0;
122 usleep_range(10000, 11000);
123 }
124
125 return -ETIMEDOUT;
126 }
127
128 /*
129 * Enable LTSSM of this controller and manually initiate the speed change.
130 * Always return 0.
131 */
rcar_gen4_pcie_start_link(struct dw_pcie * dw)132 static int rcar_gen4_pcie_start_link(struct dw_pcie *dw)
133 {
134 struct rcar_gen4_pcie *rcar = to_rcar_gen4_pcie(dw);
135 int i, changes, ret;
136
137 if (rcar->drvdata->ltssm_control) {
138 ret = rcar->drvdata->ltssm_control(rcar, true);
139 if (ret)
140 return ret;
141 }
142
143 /*
144 * Require direct speed change with retrying here if the max_link_speed
145 * is PCIe Gen2 or higher.
146 */
147 changes = min_not_zero(dw->max_link_speed, RCAR_MAX_LINK_SPEED) - 1;
148
149 /*
150 * Since dw_pcie_setup_rc() sets it once, PCIe Gen2 will be trained.
151 * So, this needs remaining times for up to PCIe Gen4 if RC mode.
152 */
153 if (changes && rcar->drvdata->mode == DW_PCIE_RC_TYPE)
154 changes--;
155
156 for (i = 0; i < changes; i++) {
157 /* It may not be connected in EP mode yet. So, break the loop */
158 if (rcar_gen4_pcie_speed_change(dw))
159 break;
160 }
161
162 return 0;
163 }
164
rcar_gen4_pcie_stop_link(struct dw_pcie * dw)165 static void rcar_gen4_pcie_stop_link(struct dw_pcie *dw)
166 {
167 struct rcar_gen4_pcie *rcar = to_rcar_gen4_pcie(dw);
168
169 if (rcar->drvdata->ltssm_control)
170 rcar->drvdata->ltssm_control(rcar, false);
171 }
172
rcar_gen4_pcie_common_init(struct rcar_gen4_pcie * rcar)173 static int rcar_gen4_pcie_common_init(struct rcar_gen4_pcie *rcar)
174 {
175 struct dw_pcie *dw = &rcar->dw;
176 u32 val;
177 int ret;
178
179 ret = clk_bulk_prepare_enable(DW_PCIE_NUM_CORE_CLKS, dw->core_clks);
180 if (ret) {
181 dev_err(dw->dev, "Enabling core clocks failed\n");
182 return ret;
183 }
184
185 if (!reset_control_status(dw->core_rsts[DW_PCIE_PWR_RST].rstc))
186 reset_control_assert(dw->core_rsts[DW_PCIE_PWR_RST].rstc);
187
188 val = readl(rcar->base + PCIEMSR0);
189 if (rcar->drvdata->mode == DW_PCIE_RC_TYPE) {
190 val |= DEVICE_TYPE_RC;
191 } else if (rcar->drvdata->mode == DW_PCIE_EP_TYPE) {
192 val |= DEVICE_TYPE_EP;
193 } else {
194 ret = -EINVAL;
195 goto err_unprepare;
196 }
197
198 if (dw->num_lanes < 4)
199 val |= BIFUR_MOD_SET_ON;
200
201 writel(val, rcar->base + PCIEMSR0);
202
203 ret = reset_control_deassert(dw->core_rsts[DW_PCIE_PWR_RST].rstc);
204 if (ret)
205 goto err_unprepare;
206
207 if (rcar->drvdata->additional_common_init)
208 rcar->drvdata->additional_common_init(rcar);
209
210 return 0;
211
212 err_unprepare:
213 clk_bulk_disable_unprepare(DW_PCIE_NUM_CORE_CLKS, dw->core_clks);
214
215 return ret;
216 }
217
rcar_gen4_pcie_common_deinit(struct rcar_gen4_pcie * rcar)218 static void rcar_gen4_pcie_common_deinit(struct rcar_gen4_pcie *rcar)
219 {
220 struct dw_pcie *dw = &rcar->dw;
221
222 reset_control_assert(dw->core_rsts[DW_PCIE_PWR_RST].rstc);
223 clk_bulk_disable_unprepare(DW_PCIE_NUM_CORE_CLKS, dw->core_clks);
224 }
225
rcar_gen4_pcie_prepare(struct rcar_gen4_pcie * rcar)226 static int rcar_gen4_pcie_prepare(struct rcar_gen4_pcie *rcar)
227 {
228 struct device *dev = rcar->dw.dev;
229 int err;
230
231 pm_runtime_enable(dev);
232 err = pm_runtime_resume_and_get(dev);
233 if (err < 0) {
234 dev_err(dev, "Runtime resume failed\n");
235 pm_runtime_disable(dev);
236 }
237
238 return err;
239 }
240
rcar_gen4_pcie_unprepare(struct rcar_gen4_pcie * rcar)241 static void rcar_gen4_pcie_unprepare(struct rcar_gen4_pcie *rcar)
242 {
243 struct device *dev = rcar->dw.dev;
244
245 pm_runtime_put(dev);
246 pm_runtime_disable(dev);
247 }
248
rcar_gen4_pcie_get_resources(struct rcar_gen4_pcie * rcar)249 static int rcar_gen4_pcie_get_resources(struct rcar_gen4_pcie *rcar)
250 {
251 rcar->phy_base = devm_platform_ioremap_resource_byname(rcar->pdev, "phy");
252 if (IS_ERR(rcar->phy_base))
253 return PTR_ERR(rcar->phy_base);
254
255 /* Renesas-specific registers */
256 rcar->base = devm_platform_ioremap_resource_byname(rcar->pdev, "app");
257
258 return PTR_ERR_OR_ZERO(rcar->base);
259 }
260
261 static const struct dw_pcie_ops dw_pcie_ops = {
262 .start_link = rcar_gen4_pcie_start_link,
263 .stop_link = rcar_gen4_pcie_stop_link,
264 .link_up = rcar_gen4_pcie_link_up,
265 };
266
rcar_gen4_pcie_alloc(struct platform_device * pdev)267 static struct rcar_gen4_pcie *rcar_gen4_pcie_alloc(struct platform_device *pdev)
268 {
269 struct device *dev = &pdev->dev;
270 struct rcar_gen4_pcie *rcar;
271
272 rcar = devm_kzalloc(dev, sizeof(*rcar), GFP_KERNEL);
273 if (!rcar)
274 return ERR_PTR(-ENOMEM);
275
276 rcar->dw.ops = &dw_pcie_ops;
277 rcar->dw.dev = dev;
278 rcar->pdev = pdev;
279 rcar->dw.edma.mf = EDMA_MF_EDMA_UNROLL;
280 dw_pcie_cap_set(&rcar->dw, REQ_RES);
281 platform_set_drvdata(pdev, rcar);
282
283 return rcar;
284 }
285
286 /* Host mode */
rcar_gen4_pcie_host_init(struct dw_pcie_rp * pp)287 static int rcar_gen4_pcie_host_init(struct dw_pcie_rp *pp)
288 {
289 struct dw_pcie *dw = to_dw_pcie_from_pp(pp);
290 struct rcar_gen4_pcie *rcar = to_rcar_gen4_pcie(dw);
291 int ret;
292 u32 val;
293
294 gpiod_set_value_cansleep(dw->pe_rst, 1);
295
296 ret = rcar_gen4_pcie_common_init(rcar);
297 if (ret)
298 return ret;
299
300 /*
301 * According to the section 3.5.7.2 "RC Mode" in DWC PCIe Dual Mode
302 * Rev.5.20a and 3.5.6.1 "RC mode" in DWC PCIe RC databook v5.20a, we
303 * should disable two BARs to avoid unnecessary memory assignment
304 * during device enumeration.
305 */
306 dw_pcie_writel_dbi2(dw, PCI_BASE_ADDRESS_0, 0x0);
307 dw_pcie_writel_dbi2(dw, PCI_BASE_ADDRESS_1, 0x0);
308
309 /* Enable MSI interrupt signal */
310 val = readl(rcar->base + PCIEINTSTS0EN);
311 val |= MSI_CTRL_INT;
312 writel(val, rcar->base + PCIEINTSTS0EN);
313
314 msleep(PCIE_T_PVPERL_MS); /* pe_rst requires 100msec delay */
315
316 gpiod_set_value_cansleep(dw->pe_rst, 0);
317
318 return 0;
319 }
320
rcar_gen4_pcie_host_deinit(struct dw_pcie_rp * pp)321 static void rcar_gen4_pcie_host_deinit(struct dw_pcie_rp *pp)
322 {
323 struct dw_pcie *dw = to_dw_pcie_from_pp(pp);
324 struct rcar_gen4_pcie *rcar = to_rcar_gen4_pcie(dw);
325
326 gpiod_set_value_cansleep(dw->pe_rst, 1);
327 rcar_gen4_pcie_common_deinit(rcar);
328 }
329
330 static const struct dw_pcie_host_ops rcar_gen4_pcie_host_ops = {
331 .init = rcar_gen4_pcie_host_init,
332 .deinit = rcar_gen4_pcie_host_deinit,
333 };
334
rcar_gen4_add_dw_pcie_rp(struct rcar_gen4_pcie * rcar)335 static int rcar_gen4_add_dw_pcie_rp(struct rcar_gen4_pcie *rcar)
336 {
337 struct dw_pcie_rp *pp = &rcar->dw.pp;
338
339 if (!IS_ENABLED(CONFIG_PCIE_RCAR_GEN4_HOST))
340 return -ENODEV;
341
342 pp->num_vectors = MAX_MSI_IRQS;
343 pp->ops = &rcar_gen4_pcie_host_ops;
344
345 return dw_pcie_host_init(pp);
346 }
347
rcar_gen4_remove_dw_pcie_rp(struct rcar_gen4_pcie * rcar)348 static void rcar_gen4_remove_dw_pcie_rp(struct rcar_gen4_pcie *rcar)
349 {
350 dw_pcie_host_deinit(&rcar->dw.pp);
351 }
352
353 /* Endpoint mode */
rcar_gen4_pcie_ep_pre_init(struct dw_pcie_ep * ep)354 static void rcar_gen4_pcie_ep_pre_init(struct dw_pcie_ep *ep)
355 {
356 struct dw_pcie *dw = to_dw_pcie_from_ep(ep);
357 struct rcar_gen4_pcie *rcar = to_rcar_gen4_pcie(dw);
358 int ret;
359
360 ret = rcar_gen4_pcie_common_init(rcar);
361 if (ret)
362 return;
363
364 writel(PCIEDMAINTSTSEN_INIT, rcar->base + PCIEDMAINTSTSEN);
365 }
366
rcar_gen4_pcie_ep_init(struct dw_pcie_ep * ep)367 static void rcar_gen4_pcie_ep_init(struct dw_pcie_ep *ep)
368 {
369 struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
370 enum pci_barno bar;
371
372 for (bar = 0; bar < PCI_STD_NUM_BARS; bar++)
373 dw_pcie_ep_reset_bar(pci, bar);
374 }
375
rcar_gen4_pcie_ep_deinit(struct rcar_gen4_pcie * rcar)376 static void rcar_gen4_pcie_ep_deinit(struct rcar_gen4_pcie *rcar)
377 {
378 writel(0, rcar->base + PCIEDMAINTSTSEN);
379 rcar_gen4_pcie_common_deinit(rcar);
380 }
381
rcar_gen4_pcie_ep_raise_irq(struct dw_pcie_ep * ep,u8 func_no,unsigned int type,u16 interrupt_num)382 static int rcar_gen4_pcie_ep_raise_irq(struct dw_pcie_ep *ep, u8 func_no,
383 unsigned int type, u16 interrupt_num)
384 {
385 struct dw_pcie *dw = to_dw_pcie_from_ep(ep);
386
387 switch (type) {
388 case PCI_IRQ_INTX:
389 return dw_pcie_ep_raise_intx_irq(ep, func_no);
390 case PCI_IRQ_MSI:
391 return dw_pcie_ep_raise_msi_irq(ep, func_no, interrupt_num);
392 default:
393 dev_err(dw->dev, "Unknown IRQ type\n");
394 return -EINVAL;
395 }
396
397 return 0;
398 }
399
400 static const struct pci_epc_features rcar_gen4_pcie_epc_features = {
401 .linkup_notifier = false,
402 .msi_capable = true,
403 .msix_capable = false,
404 .bar[BAR_1] = { .type = BAR_RESERVED, },
405 .bar[BAR_3] = { .type = BAR_RESERVED, },
406 .bar[BAR_4] = { .type = BAR_FIXED, .fixed_size = 256 },
407 .bar[BAR_5] = { .type = BAR_RESERVED, },
408 .align = SZ_1M,
409 };
410
411 static const struct pci_epc_features*
rcar_gen4_pcie_ep_get_features(struct dw_pcie_ep * ep)412 rcar_gen4_pcie_ep_get_features(struct dw_pcie_ep *ep)
413 {
414 return &rcar_gen4_pcie_epc_features;
415 }
416
rcar_gen4_pcie_ep_get_dbi_offset(struct dw_pcie_ep * ep,u8 func_no)417 static unsigned int rcar_gen4_pcie_ep_get_dbi_offset(struct dw_pcie_ep *ep,
418 u8 func_no)
419 {
420 return func_no * RCAR_GEN4_PCIE_EP_FUNC_DBI_OFFSET;
421 }
422
rcar_gen4_pcie_ep_get_dbi2_offset(struct dw_pcie_ep * ep,u8 func_no)423 static unsigned int rcar_gen4_pcie_ep_get_dbi2_offset(struct dw_pcie_ep *ep,
424 u8 func_no)
425 {
426 return func_no * RCAR_GEN4_PCIE_EP_FUNC_DBI2_OFFSET;
427 }
428
429 static const struct dw_pcie_ep_ops pcie_ep_ops = {
430 .pre_init = rcar_gen4_pcie_ep_pre_init,
431 .init = rcar_gen4_pcie_ep_init,
432 .raise_irq = rcar_gen4_pcie_ep_raise_irq,
433 .get_features = rcar_gen4_pcie_ep_get_features,
434 .get_dbi_offset = rcar_gen4_pcie_ep_get_dbi_offset,
435 .get_dbi2_offset = rcar_gen4_pcie_ep_get_dbi2_offset,
436 };
437
rcar_gen4_add_dw_pcie_ep(struct rcar_gen4_pcie * rcar)438 static int rcar_gen4_add_dw_pcie_ep(struct rcar_gen4_pcie *rcar)
439 {
440 struct dw_pcie_ep *ep = &rcar->dw.ep;
441 struct device *dev = rcar->dw.dev;
442 int ret;
443
444 if (!IS_ENABLED(CONFIG_PCIE_RCAR_GEN4_EP))
445 return -ENODEV;
446
447 ep->ops = &pcie_ep_ops;
448
449 ret = dw_pcie_ep_init(ep);
450 if (ret) {
451 rcar_gen4_pcie_ep_deinit(rcar);
452 return ret;
453 }
454
455 ret = dw_pcie_ep_init_registers(ep);
456 if (ret) {
457 dev_err(dev, "Failed to initialize DWC endpoint registers\n");
458 dw_pcie_ep_deinit(ep);
459 rcar_gen4_pcie_ep_deinit(rcar);
460 }
461
462 pci_epc_init_notify(ep->epc);
463
464 return ret;
465 }
466
rcar_gen4_remove_dw_pcie_ep(struct rcar_gen4_pcie * rcar)467 static void rcar_gen4_remove_dw_pcie_ep(struct rcar_gen4_pcie *rcar)
468 {
469 dw_pcie_ep_deinit(&rcar->dw.ep);
470 rcar_gen4_pcie_ep_deinit(rcar);
471 }
472
473 /* Common */
rcar_gen4_add_dw_pcie(struct rcar_gen4_pcie * rcar)474 static int rcar_gen4_add_dw_pcie(struct rcar_gen4_pcie *rcar)
475 {
476 rcar->drvdata = of_device_get_match_data(&rcar->pdev->dev);
477 if (!rcar->drvdata)
478 return -EINVAL;
479
480 switch (rcar->drvdata->mode) {
481 case DW_PCIE_RC_TYPE:
482 return rcar_gen4_add_dw_pcie_rp(rcar);
483 case DW_PCIE_EP_TYPE:
484 return rcar_gen4_add_dw_pcie_ep(rcar);
485 default:
486 return -EINVAL;
487 }
488 }
489
rcar_gen4_pcie_probe(struct platform_device * pdev)490 static int rcar_gen4_pcie_probe(struct platform_device *pdev)
491 {
492 struct rcar_gen4_pcie *rcar;
493 int err;
494
495 rcar = rcar_gen4_pcie_alloc(pdev);
496 if (IS_ERR(rcar))
497 return PTR_ERR(rcar);
498
499 err = rcar_gen4_pcie_get_resources(rcar);
500 if (err)
501 return err;
502
503 err = rcar_gen4_pcie_prepare(rcar);
504 if (err)
505 return err;
506
507 err = rcar_gen4_add_dw_pcie(rcar);
508 if (err)
509 goto err_unprepare;
510
511 return 0;
512
513 err_unprepare:
514 rcar_gen4_pcie_unprepare(rcar);
515
516 return err;
517 }
518
rcar_gen4_remove_dw_pcie(struct rcar_gen4_pcie * rcar)519 static void rcar_gen4_remove_dw_pcie(struct rcar_gen4_pcie *rcar)
520 {
521 switch (rcar->drvdata->mode) {
522 case DW_PCIE_RC_TYPE:
523 rcar_gen4_remove_dw_pcie_rp(rcar);
524 break;
525 case DW_PCIE_EP_TYPE:
526 rcar_gen4_remove_dw_pcie_ep(rcar);
527 break;
528 default:
529 break;
530 }
531 }
532
rcar_gen4_pcie_remove(struct platform_device * pdev)533 static void rcar_gen4_pcie_remove(struct platform_device *pdev)
534 {
535 struct rcar_gen4_pcie *rcar = platform_get_drvdata(pdev);
536
537 rcar_gen4_remove_dw_pcie(rcar);
538 rcar_gen4_pcie_unprepare(rcar);
539 }
540
r8a779f0_pcie_ltssm_control(struct rcar_gen4_pcie * rcar,bool enable)541 static int r8a779f0_pcie_ltssm_control(struct rcar_gen4_pcie *rcar, bool enable)
542 {
543 u32 val;
544
545 val = readl(rcar->base + PCIERSTCTRL1);
546 if (enable) {
547 val |= APP_LTSSM_ENABLE;
548 val &= ~APP_HOLD_PHY_RST;
549 } else {
550 /*
551 * Since the datasheet of R-Car doesn't mention how to assert
552 * the APP_HOLD_PHY_RST, don't assert it again. Otherwise,
553 * hang-up issue happened in the dw_edma_core_off() when
554 * the controller didn't detect a PCI device.
555 */
556 val &= ~APP_LTSSM_ENABLE;
557 }
558 writel(val, rcar->base + PCIERSTCTRL1);
559
560 return 0;
561 }
562
rcar_gen4_pcie_additional_common_init(struct rcar_gen4_pcie * rcar)563 static void rcar_gen4_pcie_additional_common_init(struct rcar_gen4_pcie *rcar)
564 {
565 struct dw_pcie *dw = &rcar->dw;
566 u32 val;
567
568 val = dw_pcie_readl_dbi(dw, PCIE_PORT_LANE_SKEW);
569 val &= ~PORT_LANE_SKEW_INSERT_MASK;
570 if (dw->num_lanes < 4)
571 val |= BIT(6);
572 dw_pcie_writel_dbi(dw, PCIE_PORT_LANE_SKEW, val);
573
574 val = readl(rcar->base + PCIEPWRMNGCTRL);
575 val |= APP_CLK_REQ_N | APP_CLK_PM_EN;
576 writel(val, rcar->base + PCIEPWRMNGCTRL);
577 }
578
rcar_gen4_pcie_phy_reg_update_bits(struct rcar_gen4_pcie * rcar,u32 offset,u32 mask,u32 val)579 static void rcar_gen4_pcie_phy_reg_update_bits(struct rcar_gen4_pcie *rcar,
580 u32 offset, u32 mask, u32 val)
581 {
582 u32 tmp;
583
584 tmp = readl(rcar->phy_base + offset);
585 tmp &= ~mask;
586 tmp |= val;
587 writel(tmp, rcar->phy_base + offset);
588 }
589
590 /*
591 * SoC datasheet suggests checking port logic register bits during firmware
592 * write. If read returns non-zero value, then this function returns -EAGAIN
593 * indicating that the write needs to be done again. If read returns zero,
594 * then return 0 to indicate success.
595 */
rcar_gen4_pcie_reg_test_bit(struct rcar_gen4_pcie * rcar,u32 offset,u32 mask)596 static int rcar_gen4_pcie_reg_test_bit(struct rcar_gen4_pcie *rcar,
597 u32 offset, u32 mask)
598 {
599 struct dw_pcie *dw = &rcar->dw;
600
601 if (dw_pcie_readl_dbi(dw, offset) & mask)
602 return -EAGAIN;
603
604 return 0;
605 }
606
rcar_gen4_pcie_download_phy_firmware(struct rcar_gen4_pcie * rcar)607 static int rcar_gen4_pcie_download_phy_firmware(struct rcar_gen4_pcie *rcar)
608 {
609 /* The check_addr values are magical numbers in the datasheet */
610 static const u32 check_addr[] = {
611 0x00101018,
612 0x00101118,
613 0x00101021,
614 0x00101121,
615 };
616 struct dw_pcie *dw = &rcar->dw;
617 const struct firmware *fw;
618 unsigned int i, timeout;
619 u32 data;
620 int ret;
621
622 ret = request_firmware(&fw, RCAR_GEN4_PCIE_FIRMWARE_NAME, dw->dev);
623 if (ret) {
624 dev_err(dw->dev, "Failed to load firmware (%s): %d\n",
625 RCAR_GEN4_PCIE_FIRMWARE_NAME, ret);
626 return ret;
627 }
628
629 for (i = 0; i < (fw->size / 2); i++) {
630 data = fw->data[(i * 2) + 1] << 8 | fw->data[i * 2];
631 timeout = 100;
632 do {
633 dw_pcie_writel_dbi(dw, PRTLGC89, RCAR_GEN4_PCIE_FIRMWARE_BASE_ADDR + i);
634 dw_pcie_writel_dbi(dw, PRTLGC90, data);
635 if (!rcar_gen4_pcie_reg_test_bit(rcar, PRTLGC89, BIT(30)))
636 break;
637 if (!(--timeout)) {
638 ret = -ETIMEDOUT;
639 goto exit;
640 }
641 usleep_range(100, 200);
642 } while (1);
643 }
644
645 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x0f8, BIT(17), BIT(17));
646
647 for (i = 0; i < ARRAY_SIZE(check_addr); i++) {
648 timeout = 100;
649 do {
650 dw_pcie_writel_dbi(dw, PRTLGC89, check_addr[i]);
651 ret = rcar_gen4_pcie_reg_test_bit(rcar, PRTLGC89, BIT(30));
652 ret |= rcar_gen4_pcie_reg_test_bit(rcar, PRTLGC90, BIT(0));
653 if (!ret)
654 break;
655 if (!(--timeout)) {
656 ret = -ETIMEDOUT;
657 goto exit;
658 }
659 usleep_range(100, 200);
660 } while (1);
661 }
662
663 exit:
664 release_firmware(fw);
665
666 return ret;
667 }
668
rcar_gen4_pcie_ltssm_control(struct rcar_gen4_pcie * rcar,bool enable)669 static int rcar_gen4_pcie_ltssm_control(struct rcar_gen4_pcie *rcar, bool enable)
670 {
671 struct dw_pcie *dw = &rcar->dw;
672 u32 val;
673 int ret;
674
675 if (!enable) {
676 val = readl(rcar->base + PCIERSTCTRL1);
677 val &= ~APP_LTSSM_ENABLE;
678 writel(val, rcar->base + PCIERSTCTRL1);
679
680 return 0;
681 }
682
683 val = dw_pcie_readl_dbi(dw, PCIE_PORT_FORCE);
684 val |= PORT_FORCE_DO_DESKEW_FOR_SRIS;
685 dw_pcie_writel_dbi(dw, PCIE_PORT_FORCE, val);
686
687 val = readl(rcar->base + PCIEMSR0);
688 val |= APP_SRIS_MODE;
689 writel(val, rcar->base + PCIEMSR0);
690
691 /*
692 * The R-Car Gen4 datasheet doesn't describe the PHY registers' name.
693 * But, the initialization procedure describes these offsets. So,
694 * this driver has magical offset numbers.
695 */
696 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x700, BIT(28), 0);
697 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x700, BIT(20), 0);
698 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x700, BIT(12), 0);
699 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x700, BIT(4), 0);
700
701 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x148, GENMASK(23, 22), BIT(22));
702 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x148, GENMASK(18, 16), GENMASK(17, 16));
703 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x148, GENMASK(7, 6), BIT(6));
704 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x148, GENMASK(2, 0), GENMASK(11, 0));
705 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x1d4, GENMASK(16, 15), GENMASK(16, 15));
706 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x514, BIT(26), BIT(26));
707 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x0f8, BIT(16), 0);
708 rcar_gen4_pcie_phy_reg_update_bits(rcar, 0x0f8, BIT(19), BIT(19));
709
710 val = readl(rcar->base + PCIERSTCTRL1);
711 val &= ~APP_HOLD_PHY_RST;
712 writel(val, rcar->base + PCIERSTCTRL1);
713
714 ret = readl_poll_timeout(rcar->phy_base + 0x0f8, val, !(val & BIT(18)), 100, 10000);
715 if (ret < 0)
716 return ret;
717
718 ret = rcar_gen4_pcie_download_phy_firmware(rcar);
719 if (ret)
720 return ret;
721
722 val = readl(rcar->base + PCIERSTCTRL1);
723 val |= APP_LTSSM_ENABLE;
724 writel(val, rcar->base + PCIERSTCTRL1);
725
726 return 0;
727 }
728
729 static struct rcar_gen4_pcie_drvdata drvdata_r8a779f0_pcie = {
730 .ltssm_control = r8a779f0_pcie_ltssm_control,
731 .mode = DW_PCIE_RC_TYPE,
732 };
733
734 static struct rcar_gen4_pcie_drvdata drvdata_r8a779f0_pcie_ep = {
735 .ltssm_control = r8a779f0_pcie_ltssm_control,
736 .mode = DW_PCIE_EP_TYPE,
737 };
738
739 static struct rcar_gen4_pcie_drvdata drvdata_rcar_gen4_pcie = {
740 .additional_common_init = rcar_gen4_pcie_additional_common_init,
741 .ltssm_control = rcar_gen4_pcie_ltssm_control,
742 .mode = DW_PCIE_RC_TYPE,
743 };
744
745 static struct rcar_gen4_pcie_drvdata drvdata_rcar_gen4_pcie_ep = {
746 .additional_common_init = rcar_gen4_pcie_additional_common_init,
747 .ltssm_control = rcar_gen4_pcie_ltssm_control,
748 .mode = DW_PCIE_EP_TYPE,
749 };
750
751 static const struct of_device_id rcar_gen4_pcie_of_match[] = {
752 {
753 .compatible = "renesas,r8a779f0-pcie",
754 .data = &drvdata_r8a779f0_pcie,
755 },
756 {
757 .compatible = "renesas,r8a779f0-pcie-ep",
758 .data = &drvdata_r8a779f0_pcie_ep,
759 },
760 {
761 .compatible = "renesas,rcar-gen4-pcie",
762 .data = &drvdata_rcar_gen4_pcie,
763 },
764 {
765 .compatible = "renesas,rcar-gen4-pcie-ep",
766 .data = &drvdata_rcar_gen4_pcie_ep,
767 },
768 {},
769 };
770 MODULE_DEVICE_TABLE(of, rcar_gen4_pcie_of_match);
771
772 static struct platform_driver rcar_gen4_pcie_driver = {
773 .driver = {
774 .name = "pcie-rcar-gen4",
775 .of_match_table = rcar_gen4_pcie_of_match,
776 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
777 },
778 .probe = rcar_gen4_pcie_probe,
779 .remove = rcar_gen4_pcie_remove,
780 };
781 module_platform_driver(rcar_gen4_pcie_driver);
782
783 MODULE_DESCRIPTION("Renesas R-Car Gen4 PCIe controller driver");
784 MODULE_LICENSE("GPL");
785