PCI: histb: Add an optional regulator for PCIe port power control
[muen/linux.git] / drivers / pci / dwc / pcie-histb.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * PCIe host controller driver for HiSilicon STB SoCs
4  *
5  * Copyright (C) 2016-2017 HiSilicon Co., Ltd. http://www.hisilicon.com
6  *
7  * Authors: Ruqiang Ju <juruqiang@hisilicon.com>
8  *          Jianguo Sun <sunjianguo1@huawei.com>
9  */
10
11 #include <linux/clk.h>
12 #include <linux/delay.h>
13 #include <linux/interrupt.h>
14 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/of.h>
17 #include <linux/of_gpio.h>
18 #include <linux/pci.h>
19 #include <linux/phy/phy.h>
20 #include <linux/platform_device.h>
21 #include <linux/resource.h>
22 #include <linux/reset.h>
23
24 #include "pcie-designware.h"
25
26 #define to_histb_pcie(x)        dev_get_drvdata((x)->dev)
27
28 #define PCIE_SYS_CTRL0                  0x0000
29 #define PCIE_SYS_CTRL1                  0x0004
30 #define PCIE_SYS_CTRL7                  0x001C
31 #define PCIE_SYS_CTRL13                 0x0034
32 #define PCIE_SYS_CTRL15                 0x003C
33 #define PCIE_SYS_CTRL16                 0x0040
34 #define PCIE_SYS_CTRL17                 0x0044
35
36 #define PCIE_SYS_STAT0                  0x0100
37 #define PCIE_SYS_STAT4                  0x0110
38
39 #define PCIE_RDLH_LINK_UP               BIT(5)
40 #define PCIE_XMLH_LINK_UP               BIT(15)
41 #define PCIE_ELBI_SLV_DBI_ENABLE        BIT(21)
42 #define PCIE_APP_LTSSM_ENABLE           BIT(11)
43
44 #define PCIE_DEVICE_TYPE_MASK           GENMASK(31, 28)
45 #define PCIE_WM_EP                      0
46 #define PCIE_WM_LEGACY                  BIT(1)
47 #define PCIE_WM_RC                      BIT(30)
48
49 #define PCIE_LTSSM_STATE_MASK           GENMASK(5, 0)
50 #define PCIE_LTSSM_STATE_ACTIVE         0x11
51
52 struct histb_pcie {
53         struct dw_pcie *pci;
54         struct clk *aux_clk;
55         struct clk *pipe_clk;
56         struct clk *sys_clk;
57         struct clk *bus_clk;
58         struct phy *phy;
59         struct reset_control *soft_reset;
60         struct reset_control *sys_reset;
61         struct reset_control *bus_reset;
62         void __iomem *ctrl;
63         int reset_gpio;
64         struct regulator *vpcie;
65 };
66
67 static u32 histb_pcie_readl(struct histb_pcie *histb_pcie, u32 reg)
68 {
69         return readl(histb_pcie->ctrl + reg);
70 }
71
72 static void histb_pcie_writel(struct histb_pcie *histb_pcie, u32 reg, u32 val)
73 {
74         writel(val, histb_pcie->ctrl + reg);
75 }
76
77 static void histb_pcie_dbi_w_mode(struct pcie_port *pp, bool enable)
78 {
79         struct dw_pcie *pci = to_dw_pcie_from_pp(pp);
80         struct histb_pcie *hipcie = to_histb_pcie(pci);
81         u32 val;
82
83         val = histb_pcie_readl(hipcie, PCIE_SYS_CTRL0);
84         if (enable)
85                 val |= PCIE_ELBI_SLV_DBI_ENABLE;
86         else
87                 val &= ~PCIE_ELBI_SLV_DBI_ENABLE;
88         histb_pcie_writel(hipcie, PCIE_SYS_CTRL0, val);
89 }
90
91 static void histb_pcie_dbi_r_mode(struct pcie_port *pp, bool enable)
92 {
93         struct dw_pcie *pci = to_dw_pcie_from_pp(pp);
94         struct histb_pcie *hipcie = to_histb_pcie(pci);
95         u32 val;
96
97         val = histb_pcie_readl(hipcie, PCIE_SYS_CTRL1);
98         if (enable)
99                 val |= PCIE_ELBI_SLV_DBI_ENABLE;
100         else
101                 val &= ~PCIE_ELBI_SLV_DBI_ENABLE;
102         histb_pcie_writel(hipcie, PCIE_SYS_CTRL1, val);
103 }
104
105 static u32 histb_pcie_read_dbi(struct dw_pcie *pci, void __iomem *base,
106                                u32 reg, size_t size)
107 {
108         u32 val;
109
110         histb_pcie_dbi_r_mode(&pci->pp, true);
111         dw_pcie_read(base + reg, size, &val);
112         histb_pcie_dbi_r_mode(&pci->pp, false);
113
114         return val;
115 }
116
117 static void histb_pcie_write_dbi(struct dw_pcie *pci, void __iomem *base,
118                                  u32 reg, size_t size, u32 val)
119 {
120         histb_pcie_dbi_w_mode(&pci->pp, true);
121         dw_pcie_write(base + reg, size, val);
122         histb_pcie_dbi_w_mode(&pci->pp, false);
123 }
124
125 static int histb_pcie_rd_own_conf(struct pcie_port *pp, int where,
126                                   int size, u32 *val)
127 {
128         struct dw_pcie *pci = to_dw_pcie_from_pp(pp);
129         int ret;
130
131         histb_pcie_dbi_r_mode(pp, true);
132         ret = dw_pcie_read(pci->dbi_base + where, size, val);
133         histb_pcie_dbi_r_mode(pp, false);
134
135         return ret;
136 }
137
138 static int histb_pcie_wr_own_conf(struct pcie_port *pp, int where,
139                                   int size, u32 val)
140 {
141         struct dw_pcie *pci = to_dw_pcie_from_pp(pp);
142         int ret;
143
144         histb_pcie_dbi_w_mode(pp, true);
145         ret = dw_pcie_write(pci->dbi_base + where, size, val);
146         histb_pcie_dbi_w_mode(pp, false);
147
148         return ret;
149 }
150
151 static int histb_pcie_link_up(struct dw_pcie *pci)
152 {
153         struct histb_pcie *hipcie = to_histb_pcie(pci);
154         u32 regval;
155         u32 status;
156
157         regval = histb_pcie_readl(hipcie, PCIE_SYS_STAT0);
158         status = histb_pcie_readl(hipcie, PCIE_SYS_STAT4);
159         status &= PCIE_LTSSM_STATE_MASK;
160         if ((regval & PCIE_XMLH_LINK_UP) && (regval & PCIE_RDLH_LINK_UP) &&
161             (status == PCIE_LTSSM_STATE_ACTIVE))
162                 return 1;
163
164         return 0;
165 }
166
167 static int histb_pcie_establish_link(struct pcie_port *pp)
168 {
169         struct dw_pcie *pci = to_dw_pcie_from_pp(pp);
170         struct histb_pcie *hipcie = to_histb_pcie(pci);
171         u32 regval;
172
173         if (dw_pcie_link_up(pci)) {
174                 dev_info(pci->dev, "Link already up\n");
175                 return 0;
176         }
177
178         /* PCIe RC work mode */
179         regval = histb_pcie_readl(hipcie, PCIE_SYS_CTRL0);
180         regval &= ~PCIE_DEVICE_TYPE_MASK;
181         regval |= PCIE_WM_RC;
182         histb_pcie_writel(hipcie, PCIE_SYS_CTRL0, regval);
183
184         /* setup root complex */
185         dw_pcie_setup_rc(pp);
186
187         /* assert LTSSM enable */
188         regval = histb_pcie_readl(hipcie, PCIE_SYS_CTRL7);
189         regval |= PCIE_APP_LTSSM_ENABLE;
190         histb_pcie_writel(hipcie, PCIE_SYS_CTRL7, regval);
191
192         return dw_pcie_wait_for_link(pci);
193 }
194
195 static int histb_pcie_host_init(struct pcie_port *pp)
196 {
197         histb_pcie_establish_link(pp);
198
199         if (IS_ENABLED(CONFIG_PCI_MSI))
200                 dw_pcie_msi_init(pp);
201
202         return 0;
203 }
204
205 static struct dw_pcie_host_ops histb_pcie_host_ops = {
206         .rd_own_conf = histb_pcie_rd_own_conf,
207         .wr_own_conf = histb_pcie_wr_own_conf,
208         .host_init = histb_pcie_host_init,
209 };
210
211 static irqreturn_t histb_pcie_msi_irq_handler(int irq, void *arg)
212 {
213         struct pcie_port *pp = arg;
214
215         return dw_handle_msi_irq(pp);
216 }
217
218 static void histb_pcie_host_disable(struct histb_pcie *hipcie)
219 {
220         reset_control_assert(hipcie->soft_reset);
221         reset_control_assert(hipcie->sys_reset);
222         reset_control_assert(hipcie->bus_reset);
223
224         clk_disable_unprepare(hipcie->aux_clk);
225         clk_disable_unprepare(hipcie->pipe_clk);
226         clk_disable_unprepare(hipcie->sys_clk);
227         clk_disable_unprepare(hipcie->bus_clk);
228
229         if (gpio_is_valid(hipcie->reset_gpio))
230                 gpio_set_value_cansleep(hipcie->reset_gpio, 0);
231
232         if (hipcie->vpcie)
233                 regulator_disable(hipcie->vpcie);
234 }
235
236 static int histb_pcie_host_enable(struct pcie_port *pp)
237 {
238         struct dw_pcie *pci = to_dw_pcie_from_pp(pp);
239         struct histb_pcie *hipcie = to_histb_pcie(pci);
240         struct device *dev = pci->dev;
241         int ret;
242
243         /* power on PCIe device if have */
244         if (hipcie->vpcie) {
245                 ret = regulator_enable(hipcie->vpcie);
246                 if (ret) {
247                         dev_err(dev, "failed to enable regulator: %d\n", ret);
248                         return ret;
249                 }
250         }
251
252         if (gpio_is_valid(hipcie->reset_gpio))
253                 gpio_set_value_cansleep(hipcie->reset_gpio, 1);
254
255         ret = clk_prepare_enable(hipcie->bus_clk);
256         if (ret) {
257                 dev_err(dev, "cannot prepare/enable bus clk\n");
258                 goto err_bus_clk;
259         }
260
261         ret = clk_prepare_enable(hipcie->sys_clk);
262         if (ret) {
263                 dev_err(dev, "cannot prepare/enable sys clk\n");
264                 goto err_sys_clk;
265         }
266
267         ret = clk_prepare_enable(hipcie->pipe_clk);
268         if (ret) {
269                 dev_err(dev, "cannot prepare/enable pipe clk\n");
270                 goto err_pipe_clk;
271         }
272
273         ret = clk_prepare_enable(hipcie->aux_clk);
274         if (ret) {
275                 dev_err(dev, "cannot prepare/enable aux clk\n");
276                 goto err_aux_clk;
277         }
278
279         reset_control_assert(hipcie->soft_reset);
280         reset_control_deassert(hipcie->soft_reset);
281
282         reset_control_assert(hipcie->sys_reset);
283         reset_control_deassert(hipcie->sys_reset);
284
285         reset_control_assert(hipcie->bus_reset);
286         reset_control_deassert(hipcie->bus_reset);
287
288         return 0;
289
290 err_aux_clk:
291         clk_disable_unprepare(hipcie->pipe_clk);
292 err_pipe_clk:
293         clk_disable_unprepare(hipcie->sys_clk);
294 err_sys_clk:
295         clk_disable_unprepare(hipcie->bus_clk);
296 err_bus_clk:
297         if (hipcie->vpcie)
298                 regulator_disable(hipcie->vpcie);
299
300         return ret;
301 }
302
303 static const struct dw_pcie_ops dw_pcie_ops = {
304         .read_dbi = histb_pcie_read_dbi,
305         .write_dbi = histb_pcie_write_dbi,
306         .link_up = histb_pcie_link_up,
307 };
308
309 static int histb_pcie_probe(struct platform_device *pdev)
310 {
311         struct histb_pcie *hipcie;
312         struct dw_pcie *pci;
313         struct pcie_port *pp;
314         struct resource *res;
315         struct device_node *np = pdev->dev.of_node;
316         struct device *dev = &pdev->dev;
317         enum of_gpio_flags of_flags;
318         unsigned long flag = GPIOF_DIR_OUT;
319         int ret;
320
321         hipcie = devm_kzalloc(dev, sizeof(*hipcie), GFP_KERNEL);
322         if (!hipcie)
323                 return -ENOMEM;
324
325         pci = devm_kzalloc(dev, sizeof(*pci), GFP_KERNEL);
326         if (!pci)
327                 return -ENOMEM;
328
329         hipcie->pci = pci;
330         pp = &pci->pp;
331         pci->dev = dev;
332         pci->ops = &dw_pcie_ops;
333
334         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "control");
335         hipcie->ctrl = devm_ioremap_resource(dev, res);
336         if (IS_ERR(hipcie->ctrl)) {
337                 dev_err(dev, "cannot get control reg base\n");
338                 return PTR_ERR(hipcie->ctrl);
339         }
340
341         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "rc-dbi");
342         pci->dbi_base = devm_ioremap_resource(dev, res);
343         if (IS_ERR(pci->dbi_base)) {
344                 dev_err(dev, "cannot get rc-dbi base\n");
345                 return PTR_ERR(pci->dbi_base);
346         }
347
348         hipcie->vpcie = devm_regulator_get_optional(dev, "vpcie");
349         if (IS_ERR(hipcie->vpcie)) {
350                 if (PTR_ERR(hipcie->vpcie) == -EPROBE_DEFER)
351                         return -EPROBE_DEFER;
352                 hipcie->vpcie = NULL;
353         }
354
355         hipcie->reset_gpio = of_get_named_gpio_flags(np,
356                                 "reset-gpios", 0, &of_flags);
357         if (of_flags & OF_GPIO_ACTIVE_LOW)
358                 flag |= GPIOF_ACTIVE_LOW;
359         if (gpio_is_valid(hipcie->reset_gpio)) {
360                 ret = devm_gpio_request_one(dev, hipcie->reset_gpio,
361                                 flag, "PCIe device power control");
362                 if (ret) {
363                         dev_err(dev, "unable to request gpio\n");
364                         return ret;
365                 }
366         }
367
368         hipcie->aux_clk = devm_clk_get(dev, "aux");
369         if (IS_ERR(hipcie->aux_clk)) {
370                 dev_err(dev, "Failed to get PCIe aux clk\n");
371                 return PTR_ERR(hipcie->aux_clk);
372         }
373
374         hipcie->pipe_clk = devm_clk_get(dev, "pipe");
375         if (IS_ERR(hipcie->pipe_clk)) {
376                 dev_err(dev, "Failed to get PCIe pipe clk\n");
377                 return PTR_ERR(hipcie->pipe_clk);
378         }
379
380         hipcie->sys_clk = devm_clk_get(dev, "sys");
381         if (IS_ERR(hipcie->sys_clk)) {
382                 dev_err(dev, "Failed to get PCIEe sys clk\n");
383                 return PTR_ERR(hipcie->sys_clk);
384         }
385
386         hipcie->bus_clk = devm_clk_get(dev, "bus");
387         if (IS_ERR(hipcie->bus_clk)) {
388                 dev_err(dev, "Failed to get PCIe bus clk\n");
389                 return PTR_ERR(hipcie->bus_clk);
390         }
391
392         hipcie->soft_reset = devm_reset_control_get(dev, "soft");
393         if (IS_ERR(hipcie->soft_reset)) {
394                 dev_err(dev, "couldn't get soft reset\n");
395                 return PTR_ERR(hipcie->soft_reset);
396         }
397
398         hipcie->sys_reset = devm_reset_control_get(dev, "sys");
399         if (IS_ERR(hipcie->sys_reset)) {
400                 dev_err(dev, "couldn't get sys reset\n");
401                 return PTR_ERR(hipcie->sys_reset);
402         }
403
404         hipcie->bus_reset = devm_reset_control_get(dev, "bus");
405         if (IS_ERR(hipcie->bus_reset)) {
406                 dev_err(dev, "couldn't get bus reset\n");
407                 return PTR_ERR(hipcie->bus_reset);
408         }
409
410         if (IS_ENABLED(CONFIG_PCI_MSI)) {
411                 pp->msi_irq = platform_get_irq_byname(pdev, "msi");
412                 if (pp->msi_irq < 0) {
413                         dev_err(dev, "Failed to get MSI IRQ\n");
414                         return pp->msi_irq;
415                 }
416
417                 ret = devm_request_irq(dev, pp->msi_irq,
418                                        histb_pcie_msi_irq_handler,
419                                        IRQF_SHARED, "histb-pcie-msi", pp);
420                 if (ret) {
421                         dev_err(dev, "cannot request MSI IRQ\n");
422                         return ret;
423                 }
424         }
425
426         hipcie->phy = devm_phy_get(dev, "phy");
427         if (IS_ERR(hipcie->phy)) {
428                 dev_info(dev, "no pcie-phy found\n");
429                 hipcie->phy = NULL;
430                 /* fall through here!
431                  * if no pcie-phy found, phy init
432                  * should be done under boot!
433                  */
434         } else {
435                 phy_init(hipcie->phy);
436         }
437
438         pp->root_bus_nr = -1;
439         pp->ops = &histb_pcie_host_ops;
440
441         platform_set_drvdata(pdev, hipcie);
442
443         ret = histb_pcie_host_enable(pp);
444         if (ret) {
445                 dev_err(dev, "failed to enable host\n");
446                 return ret;
447         }
448
449         ret = dw_pcie_host_init(pp);
450         if (ret) {
451                 dev_err(dev, "failed to initialize host\n");
452                 return ret;
453         }
454
455         return 0;
456 }
457
458 static int histb_pcie_remove(struct platform_device *pdev)
459 {
460         struct histb_pcie *hipcie = platform_get_drvdata(pdev);
461
462         histb_pcie_host_disable(hipcie);
463
464         if (hipcie->phy)
465                 phy_exit(hipcie->phy);
466
467         return 0;
468 }
469
470 static const struct of_device_id histb_pcie_of_match[] = {
471         { .compatible = "hisilicon,hi3798cv200-pcie", },
472         {},
473 };
474 MODULE_DEVICE_TABLE(of, histb_pcie_of_match);
475
476 static struct platform_driver histb_pcie_platform_driver = {
477         .probe  = histb_pcie_probe,
478         .remove = histb_pcie_remove,
479         .driver = {
480                 .name = "histb-pcie",
481                 .of_match_table = histb_pcie_of_match,
482         },
483 };
484 module_platform_driver(histb_pcie_platform_driver);
485
486 MODULE_DESCRIPTION("HiSilicon STB PCIe host controller driver");
487 MODULE_LICENSE("GPL v2");