pcie: host: tegra: use GFP_DMA32 for MSI mem alloc
[linux-3.10.git] / drivers / pci / host / pci-tegra.c
1 /*
2  * PCIe host controller driver for TEGRA SOCs
3  *
4  * Copyright (c) 2010, CompuLab, Ltd.
5  * Author: Mike Rapoport <mike@compulab.co.il>
6  *
7  * Based on NVIDIA PCIe driver
8  * Copyright (c) 2008-2016, NVIDIA Corporation. All rights reserved.
9  *
10  * Bits taken from arch/arm/mach-dove/pcie.c
11  *
12  * This program is free software; you can redistribute it and/or modify
13  * it under the terms of the GNU General Public License as published by
14  * the Free Software Foundation; either version 2 of the License, or
15  * (at your option) any later version.
16  *
17  * This program is distributed in the hope that it will be useful, but WITHOUT
18  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
19  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
20  * more details.
21  *
22  * You should have received a copy of the GNU General Public License along
23  * with this program; if not, write to the Free Software Foundation, Inc.,
24  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
25  */
26
27 #include <linux/kernel.h>
28 #include <linux/module.h>
29 #include <linux/debugfs.h>
30 #include <linux/uaccess.h>
31 #include <linux/pci.h>
32 #include <linux/pci-aspm.h>
33 #include <linux/interrupt.h>
34 #include <linux/irq.h>
35 #include <linux/irqdomain.h>
36 #include <linux/clk.h>
37 #include <linux/delay.h>
38 #include <linux/export.h>
39 #include <linux/clk/tegra.h>
40 #include <linux/msi.h>
41 #include <linux/slab.h>
42 #include <linux/platform_device.h>
43 #include <linux/regulator/consumer.h>
44 #include <linux/workqueue.h>
45 #include <linux/gpio.h>
46 #include <linux/clk.h>
47 #include <linux/clk/tegra.h>
48 #include <linux/async.h>
49 #include <linux/vmalloc.h>
50 #include <linux/pm_runtime.h>
51 #include <linux/tegra-powergate.h>
52 #include <linux/tegra-soc.h>
53 #include <linux/of_device.h>
54 #include <linux/of_address.h>
55 #include <linux/of_gpio.h>
56 #include <linux/of_pci.h>
57 #include <linux/tegra_prod.h>
58 #include <linux/tegra_pm_domains.h>
59 #include <linux/pinctrl/pinctrl.h>
60 #include <linux/pinctrl/consumer.h>
61 #include <linux/pinctrl/pinconf-tegra.h>
62
63 #include <asm/sizes.h>
64 #include <asm/mach/pci.h>
65 #include <asm/io.h>
66
67 #include <mach/tegra_usb_pad_ctrl.h>
68 #include <mach/io_dpd.h>
69 #include <linux/pci-tegra.h>
70
71 #define PCI_CFG_SPACE_SIZE              256
72 #define PCI_EXT_CFG_SPACE_SIZE  4096
73
74 #define AFI_AXI_BAR0_SZ                                                 0x00
75 #define AFI_AXI_BAR1_SZ                                                 0x04
76 #define AFI_AXI_BAR2_SZ                                                 0x08
77 #define AFI_AXI_BAR3_SZ                                                 0x0c
78 #define AFI_AXI_BAR4_SZ                                                 0x10
79 #define AFI_AXI_BAR5_SZ                                                 0x14
80
81 #define AFI_AXI_BAR0_START                                              0x18
82 #define AFI_AXI_BAR1_START                                              0x1c
83 #define AFI_AXI_BAR2_START                                              0x20
84 #define AFI_AXI_BAR3_START                                              0x24
85 #define AFI_AXI_BAR4_START                                              0x28
86 #define AFI_AXI_BAR5_START                                              0x2c
87
88 #define AFI_FPCI_BAR0                                                   0x30
89 #define AFI_FPCI_BAR1                                                   0x34
90 #define AFI_FPCI_BAR2                                                   0x38
91 #define AFI_FPCI_BAR3                                                   0x3c
92 #define AFI_FPCI_BAR4                                                   0x40
93 #define AFI_FPCI_BAR5                                                   0x44
94
95 #define AFI_CACHE_BAR0_SZ                                               0x48
96 #define AFI_CACHE_BAR0_ST                                               0x4c
97 #define AFI_CACHE_BAR1_SZ                                               0x50
98 #define AFI_CACHE_BAR1_ST                                               0x54
99
100 #define AFI_MSI_BAR_SZ                                                  0x60
101 #define AFI_MSI_FPCI_BAR_ST                                             0x64
102 #define AFI_MSI_AXI_BAR_ST                                              0x68
103
104 #define AFI_MSI_VEC0_0                                                  0x6c
105 #define AFI_MSI_VEC1_0                                                  0x70
106 #define AFI_MSI_VEC2_0                                                  0x74
107 #define AFI_MSI_VEC3_0                                                  0x78
108 #define AFI_MSI_VEC4_0                                                  0x7c
109 #define AFI_MSI_VEC5_0                                                  0x80
110 #define AFI_MSI_VEC6_0                                                  0x84
111 #define AFI_MSI_VEC7_0                                                  0x88
112
113 #define AFI_MSI_EN_VEC0_0                                               0x8c
114 #define AFI_MSI_EN_VEC1_0                                               0x90
115 #define AFI_MSI_EN_VEC2_0                                               0x94
116 #define AFI_MSI_EN_VEC3_0                                               0x98
117 #define AFI_MSI_EN_VEC4_0                                               0x9c
118 #define AFI_MSI_EN_VEC5_0                                               0xa0
119 #define AFI_MSI_EN_VEC6_0                                               0xa4
120 #define AFI_MSI_EN_VEC7_0                                               0xa8
121
122 #define AFI_CONFIGURATION                                               0xac
123 #define AFI_CONFIGURATION_EN_FPCI                               (1 << 0)
124
125 #define AFI_FPCI_ERROR_MASKS                                            0xb0
126
127 #define AFI_INTR_MASK                                                   0xb4
128 #define AFI_INTR_MASK_INT_MASK                                  (1 << 0)
129 #define AFI_INTR_MASK_MSI_MASK                                  (1 << 8)
130
131 #define AFI_INTR_CODE                                                   0xb8
132 #define AFI_INTR_CODE_MASK                                              0x1f
133 #define AFI_INTR_MASTER_ABORT                                           4
134 #define AFI_INTR_LEGACY                                         6
135 #define AFI_INTR_PRSNT_SENSE                                            10
136
137 #define AFI_INTR_SIGNATURE                                              0xbc
138 #define AFI_SM_INTR_ENABLE                                              0xc4
139
140 #define AFI_AFI_INTR_ENABLE                                             0xc8
141 #define AFI_INTR_EN_INI_SLVERR                                          (1 << 0)
142 #define AFI_INTR_EN_INI_DECERR                                          (1 << 1)
143 #define AFI_INTR_EN_TGT_SLVERR                                          (1 << 2)
144 #define AFI_INTR_EN_TGT_DECERR                                          (1 << 3)
145 #define AFI_INTR_EN_TGT_WRERR                                           (1 << 4)
146 #define AFI_INTR_EN_DFPCI_DECERR                                        (1 << 5)
147 #define AFI_INTR_EN_AXI_DECERR                                          (1 << 6)
148 #define AFI_INTR_EN_FPCI_TIMEOUT                                        (1 << 7)
149 #define AFI_INTR_EN_PRSNT_SENSE                                 (1 << 8)
150
151 #define AFI_PCIE_PME                                            0x0f0
152 #define AFI_PCIE_PME_TURN_OFF                                   0x101
153 #define AFI_PCIE_PME_ACK                                        0x420
154
155 #define AFI_PCIE_CONFIG                                         0x0f8
156 #define AFI_PCIE_CONFIG_PCIEC0_DISABLE_DEVICE                   (1 << 1)
157 #define AFI_PCIE_CONFIG_PCIEC1_DISABLE_DEVICE                   (1 << 2)
158 #define AFI_PCIE_CONFIG_XBAR_CONFIG_MASK                        (0xf << 20)
159 #define AFI_PCIE_CONFIG_XBAR_CONFIG_X2_X1                       (0x0 << 20)
160 #define AFI_PCIE_CONFIG_XBAR_CONFIG_X4_X1                       (0x1 << 20)
161
162 #define AFI_FUSE                                                        0x104
163 #define AFI_FUSE_PCIE_T0_GEN2_DIS                               (1 << 2)
164
165 #define AFI_PEX0_CTRL                                                   0x110
166 #define AFI_PEX1_CTRL                                                   0x118
167 #define AFI_PEX_CTRL_RST                                        (1 << 0)
168 #define AFI_PEX_CTRL_CLKREQ_EN                                  (1 << 1)
169 #define AFI_PEX_CTRL_REFCLK_EN                                  (1 << 3)
170 #define AFI_PEX_CTRL_OVERRIDE_EN                                (1 << 4)
171
172 #define AFI_PLLE_CONTROL                                        0x160
173 #define AFI_PLLE_CONTROL_BYPASS_PADS2PLLE_CONTROL               (1 << 9)
174 #define AFI_PLLE_CONTROL_BYPASS_PCIE2PLLE_CONTROL               (1 << 8)
175 #define AFI_PLLE_CONTROL_PADS2PLLE_CONTROL_EN                   (1 << 1)
176 #define AFI_PLLE_CONTROL_PCIE2PLLE_CONTROL_EN                   (1 << 0)
177
178 #define AFI_PEXBIAS_CTRL_0                                      0x168
179 #define AFI_WR_SCRATCH_0                                        0x120
180 #define AFI_WR_SCRATCH_0_RESET_VAL                              0x00202020
181 #define AFI_WR_SCRATCH_0_DEFAULT_VAL                            0x00000000
182
183 #define AFI_MSG_0                                               0x190
184 #define AFI_MSG_PM_PME_MASK                                     0x00100010
185 #define AFI_MSG_INTX_MASK                                       0x1f001f00
186 #define AFI_MSG_PM_PME0                                         (1 << 4)
187 #define AFI_MSG_RP_INT_MASK                                     0x10001000
188
189 #define RP_VEND_XP                                              0x00000F00
190 #define RP_VEND_XP_OPPORTUNISTIC_ACK                            (1 << 27)
191 #define RP_VEND_XP_OPPORTUNISTIC_UPDATEFC                       (1 << 28)
192 #define RP_VEND_XP_DL_UP                                        (1 << 30)
193 #define RP_VEND_XP_UPDATE_FC_THRESHOLD                          (0xFF << 18)
194
195 #define RP_LINK_CONTROL_STATUS                                  0x00000090
196 #define RP_LINK_CONTROL_STATUS_DL_LINK_ACTIVE   0x20000000
197 #define RP_LINK_CONTROL_STATUS_LINKSTAT_MASK    0x3fff0000
198 #define RP_LINK_CONTROL_STATUS_NEG_LINK_WIDTH   (0x3F << 20)
199 #define RP_LINK_CONTROL_STATUS_L0s_ENABLED              0x00000001
200 #define RP_LINK_CONTROL_STATUS_L1_ENABLED               0x00000002
201
202 #define RP_LINK_CONTROL_STATUS_2                                0x000000B0
203 #define RP_LINK_CONTROL_STATUS_2_TRGT_LNK_SPD_MASK      0x0000000F
204 #define RP_LINK_CONTROL_STATUS_2_TRGT_LNK_SPD_GEN1      0x00000001
205 #define RP_LINK_CONTROL_STATUS_2_TRGT_LNK_SPD_GEN2      0x00000002
206
207 #define NV_PCIE2_RP_RSR                                 0x000000A0
208 #define NV_PCIE2_RP_RSR_PMESTAT                         (1 << 16)
209
210 #define NV_PCIE2_RP_INTR_BCR                                    0x0000003C
211 #define NV_PCIE2_RP_INTR_BCR_INTR_LINE                  (0xFF << 0)
212 #define NV_PCIE2_RP_INTR_BCR_SB_RESET                   (0x1 << 22)
213
214 #define NV_PCIE2_RP_PRIV_XP_DL                                  0x00000494
215 #define PCIE2_RP_PRIV_XP_DL_GEN2_UPD_FC_TSHOLD                  (0x1FF << 1)
216
217 #define NV_PCIE2_RP_RX_HDR_LIMIT                                0x00000E00
218 #define PCIE2_RP_RX_HDR_LIMIT_PW_MASK                           (0xFF00)
219 #define PCIE2_RP_RX_HDR_LIMIT_PW                                (0x0E << 8)
220
221 #define NV_PCIE2_RP_TX_HDR_LIMIT                                0x00000E08
222 #define PCIE2_RP_TX_HDR_LIMIT_NPT_0                             32
223 #define PCIE2_RP_TX_HDR_LIMIT_NPT_1                             4
224
225 #define NV_PCIE2_RP_TIMEOUT0                                    0x00000E24
226 #define PCIE2_RP_TIMEOUT0_PAD_PWRUP_MASK                        (0xFF)
227 #define PCIE2_RP_TIMEOUT0_PAD_PWRUP                             (0xA)
228 #define PCIE2_RP_TIMEOUT0_PAD_PWRUP_CM_MASK                     (0xFFFF00)
229 #define PCIE2_RP_TIMEOUT0_PAD_PWRUP_CM                          (0x180 << 8)
230 #define PCIE2_RP_TIMEOUT0_PAD_SPDCHNG_GEN2_MASK         (0xFF << 24)
231 #define PCIE2_RP_TIMEOUT0_PAD_SPDCHNG_GEN2                      (0xA << 24)
232
233 #define NV_PCIE2_RP_TIMEOUT1                                    0x00000E28
234 #define PCIE2_RP_TIMEOUT1_RCVRY_SPD_SUCCESS_EIDLE_MASK          (0xFF << 16)
235 #define PCIE2_RP_TIMEOUT1_RCVRY_SPD_SUCCESS_EIDLE               (0x10 << 16)
236 #define PCIE2_RP_TIMEOUT1_RCVRY_SPD_UNSUCCESS_EIDLE_MASK        (0xFF << 24)
237 #define PCIE2_RP_TIMEOUT1_RCVRY_SPD_UNSUCCESS_EIDLE             (0x74 << 24)
238
239 #define NV_PCIE2_RP_LTSSM_DBGREG                        0x00000E44
240 #define PCIE2_RP_LTSSM_DBGREG_LINKFSM15         (1 << 15)
241 #define PCIE2_RP_LTSSM_DBGREG_LINKFSM16         (1 << 16)
242 #define PCIE2_RP_LTSSM_DBGREG_LINKFSM17         (1 << 17)
243
244 #define NV_PCIE2_RP_XP_REF                                      0x00000F30
245 #define PCIE2_RP_XP_REF_MICROSECOND_LIMIT_MASK                  (0xFF)
246 #define PCIE2_RP_XP_REF_MICROSECOND_LIMIT                       (0x14)
247 #define PCIE2_RP_XP_REF_MICROSECOND_ENABLE                      (1 << 8)
248 #define PCIE2_RP_XP_REF_CPL_TO_OVERRIDE                 (1 << 13)
249 #define PCIE2_RP_XP_REF_CPL_TO_CUSTOM_VALUE_MASK                (0x1FFFF << 14)
250 #define PCIE2_RP_XP_REF_CPL_TO_CUSTOM_VALUE                     (0x1770 << 14)
251
252 #define NV_PCIE2_RP_PRIV_MISC                                   0x00000FE0
253 #define PCIE2_RP_PRIV_MISC_PRSNT_MAP_EP_PRSNT                   (0xE << 0)
254 #define PCIE2_RP_PRIV_MISC_PRSNT_MAP_EP_ABSNT                   (0xF << 0)
255 #define PCIE2_RP_PRIV_MISC_CTLR_CLK_CLAMP_THRESHOLD             (0xF << 16)
256 #define PCIE2_RP_PRIV_MISC_CTLR_CLK_CLAMP_ENABLE                (1 << 23)
257 #define PCIE2_RP_PRIV_MISC_TMS_CLK_CLAMP_THRESHOLD              (0xF << 24)
258 #define PCIE2_RP_PRIV_MISC_TMS_CLK_CLAMP_ENABLE         (1 << 31)
259
260 #define NV_PCIE2_RP_VEND_XP1                                    0x00000F04
261 #define NV_PCIE2_RP_VEND_XP2                                    0x00000F08
262 #define NV_PCIE2_RP_VEND_XP_LINK_PVT_CTL_L1_ASPM_SUPPORT        (1 << 21)
263 #define NV_PCIE2_RP_VEND_XP1_RNCTRL_MAXWIDTH_MASK       (0x3F << 0)
264 #define NV_PCIE2_RP_VEND_XP1_RNCTRL_EN                          (1 << 7)
265
266 #define NV_PCIE2_RP_VEND_CTL0                                   0x00000F44
267 #define PCIE2_RP_VEND_CTL0_DSK_RST_PULSE_WIDTH_MASK             (0xF << 12)
268 #define PCIE2_RP_VEND_CTL0_DSK_RST_PULSE_WIDTH                  (0x9 << 12)
269
270 #define NV_PCIE2_RP_VEND_CTL1                                   0x00000F48
271 #define PCIE2_RP_VEND_CTL1_ERPT                         (1 << 13)
272
273 #define NV_PCIE2_RP_VEND_XP_BIST                                0x00000F4C
274 #define PCIE2_RP_VEND_XP_BIST_GOTO_L1_L2_AFTER_DLLP_DONE        (1 << 28)
275
276 #define NV_PCIE2_RP_VEND_XP_PAD_PWRDN                   0x00000F50
277 #define NV_PCIE2_RP_VEND_XP_PAD_PWRDN_L1_EN             (1 << 0)
278 #define NV_PCIE2_RP_VEND_XP_PAD_PWRDN_DYNAMIC_EN                (1 << 1)
279 #define NV_PCIE2_RP_VEND_XP_PAD_PWRDN_DISABLED_EN               (1 << 2)
280 #define NV_PCIE2_RP_VEND_XP_PAD_PWRDN_L1_CLKREQ_EN      (1 << 15)
281 #define NV_PCIE2_RP_VEND_XP_PAD_PWRDN_SLEEP_MODE_DYNAMIC_L1PP   (3 << 5)
282 #define NV_PCIE2_RP_VEND_XP_PAD_PWRDN_SLEEP_MODE_L1_L1P (2 << 3)
283 #define NV_PCIE2_RP_VEND_XP_PAD_PWRDN_SLEEP_MODE_L1_L1PP        (3 << 3)
284 #define NV_PCIE2_RP_VEND_XP_PAD_PWRDN_SLEEP_MODE_L1_CLKREQ_L1P  (2 << 16)
285 #define NV_PCIE2_RP_VEND_XP_PAD_PWRDN_SLEEP_MODE_L1_CLKREQ_L1PP (3 << 16)
286
287 #define NV_PCIE2_RP_PRIV_XP_RX_L0S_ENTRY_COUNT                  0x00000F8C
288 #define NV_PCIE2_RP_PRIV_XP_TX_L0S_ENTRY_COUNT                  0x00000F90
289 #define NV_PCIE2_RP_PRIV_XP_TX_L1_ENTRY_COUNT                   0x00000F94
290 #define NV_PCIE2_RP_LTR_REP_VAL                         0x00000C10
291 #define NV_PCIE2_RP_L1_1_ENTRY_COUNT                            0x00000C14
292 #define PCIE2_RP_L1_1_ENTRY_COUNT_RESET                 (1 << 31)
293 #define NV_PCIE2_RP_L1_2_ENTRY_COUNT                            0x00000C18
294 #define PCIE2_RP_L1_2_ENTRY_COUNT_RESET                 (1 << 31)
295
296 #define NV_PCIE2_RP_VEND_CTL2                                   0x00000FA8
297 #define PCIE2_RP_VEND_CTL2_PCA_ENABLE                           (1 << 7)
298
299 #define NV_PCIE2_RP_PRIV_XP_CONFIG                              0x00000FAC
300 #define NV_PCIE2_RP_PRIV_XP_CONFIG_LOW_PWR_DURATION_MASK        0x3
301 #define NV_PCIE2_RP_PRIV_XP_DURATION_IN_LOW_PWR_100NS   0x00000FB0
302
303 #define NV_PCIE2_RP_XP_CTL_1                                    0x00000FEC
304 #define PCIE2_RP_XP_CTL_1_SPARE_BIT29                           (1 << 29)
305
306 #define NV_PCIE2_RP_L1_PM_SUBSTATES_CYA                         0x00000C00
307 #define PCIE2_RP_L1_PM_SUBSTATES_CYA_CM_RTIME_MASK              (0xFF << 8)
308 #define PCIE2_RP_L1_PM_SUBSTATES_CYA_CM_RTIME_SHIFT             (8)
309 #define PCIE2_RP_L1_PM_SUBSTATES_CYA_T_PWRN_SCL_MASK            (0x3 << 16)
310 #define PCIE2_RP_L1_PM_SUBSTATES_CYA_T_PWRN_SCL_SHIFT           (16)
311 #define PCIE2_RP_L1_PM_SUBSTATES_CYA_T_PWRN_VAL_MASK            (0xF8 << 19)
312 #define PCIE2_RP_L1_PM_SUBSTATES_CYA_T_PWRN_VAL_SHIFT           (19)
313
314 #define NV_PCIE2_RP_L1_PM_SUBSTATES_1_CYA                       0x00000C04
315 #define PCIE2_RP_L1_PM_SUBSTATES_1_CYA_PWR_OFF_DLY_MASK (0x1FFF)
316 #define PCIE2_RP_L1_PM_SUBSTATES_1_CYA_PWR_OFF_DLY              (0x26)
317 #define PCIE2_RP_L1_PM_SUBSTATES_1_CYA_CLKREQ_ASSERTED_DLY_MASK (0x1FF << 13)
318 #define PCIE2_RP_L1_PM_SUBSTATES_1_CYA_CLKREQ_ASSERTED_DLY      (0x27 << 13)
319
320 #define NV_PCIE2_RP_L1_PM_SUBSTATES_2_CYA                       0x00000C08
321 #define PCIE2_RP_L1_PM_SUBSTATES_2_CYA_T_L1_2_DLY_MASK          (0x1FFF)
322 #define PCIE2_RP_L1_PM_SUBSTATES_2_CYA_T_L1_2_DLY               (0x4D)
323 #define PCIE2_RP_L1_PM_SUBSTATES_2_CYA_MICROSECOND_MASK (0xFF << 13)
324 #define PCIE2_RP_L1_PM_SUBSTATES_2_CYA_MICROSECOND              (0x13 << 13)
325 #define PCIE2_RP_L1_PM_SUBSTATES_2_CYA_MICROSECOND_COMP_MASK    (0xF << 21)
326 #define PCIE2_RP_L1_PM_SUBSTATES_2_CYA_MICROSECOND_COMP (0x2 << 21)
327
328 #define PCIE2_RP_L1_PM_SS_CONTROL               0x00000148
329 #define PCIE2_RP_L1_PM_SS_CONTROL_ASPM_L11_ENABLE       0x00000008
330 #define PCIE2_RP_L1_PM_SS_CONTROL_ASPM_L12_ENABLE       0x00000004
331
332 #define TEGRA_PCIE_MSELECT_CLK_204                              204000000
333 #define TEGRA_PCIE_MSELECT_CLK_408                              408000000
334 #define TEGRA_PCIE_XCLK_500                                     500000000
335 #define TEGRA_PCIE_XCLK_250                                     250000000
336 #define TEGRA_PCIE_EMC_CLK_102                                  102000000
337 #define TEGRA_PCIE_EMC_CLK_528                                  528000000
338
339 #define INT_PCI_MSI_NR                  (32 * 8)
340
341 #define DEBUG 0
342 #if DEBUG || defined(CONFIG_PCI_DEBUG)
343 #define PR_FUNC_LINE    pr_info("PCIE: %s(%d)\n", __func__, __LINE__)
344 #else
345 #define PR_FUNC_LINE    do {} while (0)
346 #endif
347
348 /* Pinctrl configuration paramaters */
349 #if defined(CONFIG_ARCH_TEGRA_21x_SOC)
350 #define pinctrl_compatible      "nvidia,tegra210-pinmux"
351 #define pin_pex_l0_clkreq       "pex_l0_clkreq_n_pa1"
352 #define pin_pex_l1_clkreq       "pex_l1_clkreq_n_pa4"
353 #else
354 #define pinctrl_compatible      "nvidia,tegra124-pinmux"
355 #define pin_pex_l0_clkreq       "pex_l0_clkreq_n_pdd2"
356 #define pin_pex_l1_clkreq       "pex_l1_clkreq_n_pdd6"
357 #endif
358
359 #ifdef CONFIG_PM_GENERIC_DOMAINS_OF
360 static struct of_device_id tegra_pcie_pd[] = {
361         { .compatible = "nvidia, tegra210-pcie-pd", },
362         { .compatible = "nvidia, tegra132-pcie-pd", },
363         { .compatible = "nvidia, tegra124-pcie-pd", },
364         {},
365 };
366 #endif
367
368 #if defined(CONFIG_ARCH_TEGRA_21x_SOC)
369 static u32 rp_to_lane_map[2][4] = { {1, 2, 3, 4}, {0} };
370 #endif
371
372 struct tegra_pcie_soc_data {
373         unsigned int    num_ports;
374         char                    **pcie_regulator_names;
375         int                             num_pcie_regulators;
376 };
377
378 struct tegra_msi {
379         struct msi_chip chip;
380         DECLARE_BITMAP(used, INT_PCI_MSI_NR);
381         struct irq_domain *domain;
382         unsigned long pages;
383         struct mutex lock;
384         int irq;
385 };
386
387 static inline struct tegra_msi *to_tegra_msi(struct msi_chip *chip)
388 {
389         return container_of(chip, struct tegra_msi, chip);
390 }
391
392 struct tegra_pcie {
393         struct device *dev;
394
395         void __iomem *pads;
396         void __iomem *afi;
397         int irq;
398
399         struct list_head buses;
400         struct list_head sys;
401         struct resource *cs;
402         struct resource *afi_res;
403         struct resource *pads_res;
404
405         struct resource io;
406         struct resource mem;
407         struct resource prefetch;
408         struct resource busn;
409
410         struct tegra_msi msi;
411
412         struct clk              *pcie_xclk;
413         struct clk              *pcie_afi;
414         struct clk              *pcie_pcie;
415         struct clk              *pcie_pll_e;
416         struct clk              *pcie_mselect;
417         struct clk              *pcie_emc;
418
419         struct list_head ports;
420         int num_ports;
421
422         int power_rails_enabled;
423         int pcie_power_enabled;
424         struct work_struct hotplug_detect;
425
426         struct regulator        **pcie_regulators;
427
428         struct tegra_pci_platform_data *plat_data;
429         struct tegra_pcie_soc_data *soc_data;
430         struct dentry *debugfs;
431         struct delayed_work detect_delay;
432         struct tegra_prod_list  *prod_list;
433 };
434
435 struct tegra_pcie_port {
436         struct tegra_pcie *pcie;
437         struct list_head list;
438         struct resource regs;
439         void __iomem *base;
440         unsigned int index;
441         unsigned int lanes;
442         int gpio_presence_detection;
443         bool disable_clock_request;
444         int status;
445         struct dentry *port_debugfs;
446 };
447
448 struct tegra_pcie_bus {
449         struct vm_struct *area;
450         struct list_head list;
451         unsigned int nr;
452 };
453
454 /* used to avoid successive hotplug disconnect or connect */
455 static bool hotplug_event;
456 /* pcie mselect, xclk and emc rate */
457 static unsigned long tegra_pcie_mselect_rate = TEGRA_PCIE_MSELECT_CLK_204;
458 static unsigned long tegra_pcie_xclk_rate = TEGRA_PCIE_XCLK_250;
459 static unsigned long tegra_pcie_emc_rate = TEGRA_PCIE_EMC_CLK_102;
460 static u32 is_gen2_speed;
461 static u16 bdf;
462 static u16 config_offset;
463 static u32 config_val;
464 static u16 config_aspm_state;
465
466 static inline struct tegra_pcie *sys_to_pcie(struct pci_sys_data *sys)
467 {
468         return sys->private_data;
469 }
470
471 static inline void afi_writel(struct tegra_pcie *pcie, u32 value,
472                                                           unsigned long offset)
473 {
474         writel(value, offset + pcie->afi);
475 }
476
477 static inline u32 afi_readl(struct tegra_pcie *pcie, unsigned long offset)
478 {
479         return readl(offset + pcie->afi);
480 }
481
482 static inline void pads_writel(struct tegra_pcie *pcie, u32 value,
483                                                            unsigned long offset)
484 {
485         writel(value, offset + pcie->pads);
486 }
487
488 static inline u32 pads_readl(struct tegra_pcie *pcie, unsigned long offset)
489 {
490         return readl(offset + pcie->pads);
491 }
492
493 static inline void rp_writel(struct tegra_pcie_port *port, u32 value,
494                                                          unsigned long offset)
495 {
496         writel(value, offset + port->base);
497 }
498
499 static inline unsigned int rp_readl(struct tegra_pcie_port *port,
500                                                         unsigned long offset)
501 {
502         return readl(offset + port->base);
503 }
504
505 /*
506  * The configuration space mapping on Tegra is somewhat similar to the ECAM
507  * defined by PCIe. However it deviates a bit in how the 4 bits for extended
508  * register accesses are mapped:
509  *
510  *    [27:24] extended register number
511  *    [23:16] bus number
512  *    [15:11] device number
513  *    [10: 8] function number
514  *    [ 7: 0] register number
515  *
516  * Mapping the whole extended configuration space would required 256 MiB of
517  * virtual address space, only a small part of which will actually be used.
518  * To work around this, a 1 MiB of virtual addresses are allocated per bus
519  * when the bus is first accessed. When the physical range is mapped, the
520  * the bus number bits are hidden so that the extended register number bits
521  * appear as bits [19:16]. Therefore the virtual mapping looks like this:
522  *
523  *    [19:16] extended register number
524  *    [15:11] device number
525  *    [10: 8] function number
526  *    [ 7: 0] register number
527  *
528  * This is achieved by stitching together 16 chunks of 64 KiB of physical
529  * address space via the MMU.
530  */
531 static unsigned long tegra_pcie_conf_offset(unsigned int devfn, int where)
532 {
533
534         return ((where & 0xf00) << 8) | (PCI_SLOT(devfn) << 11) |
535                (PCI_FUNC(devfn) << 8) | (where & 0xfc);
536 }
537
538 static struct tegra_pcie_bus *tegra_pcie_bus_alloc(struct tegra_pcie *pcie,
539                                                         unsigned int busnr)
540 {
541         phys_addr_t cs = pcie->cs->start;
542         struct tegra_pcie_bus *bus;
543         unsigned int i;
544         int err;
545 #ifndef CONFIG_ARM64
546         pgprot_t prot = L_PTE_PRESENT | L_PTE_YOUNG | L_PTE_DIRTY | L_PTE_XN |
547                         L_PTE_MT_DEV_SHARED | L_PTE_SHARED;
548 #else
549         pgprot_t prot = PTE_PRESENT | PTE_YOUNG | PTE_DIRTY | PTE_XN |
550                 PTE_SHARED | PTE_TYPE_PAGE;
551         (void)pgprot_dmacoherent(prot); /* L_PTE_MT_DEV_SHARED */
552 #endif
553
554         PR_FUNC_LINE;
555         bus = kzalloc(sizeof(*bus), GFP_KERNEL);
556         if (!bus)
557                 return ERR_PTR(-ENOMEM);
558
559         INIT_LIST_HEAD(&bus->list);
560         bus->nr = busnr;
561
562         /* allocate 1 MiB of virtual addresses */
563         bus->area = get_vm_area(SZ_1M, VM_IOREMAP);
564         if (!bus->area) {
565                 err = -ENOMEM;
566                 goto free;
567         }
568
569         /* map each of the 16 chunks of 64 KiB each.
570          *
571          * Note that each chunk still needs to increment by 16 MiB in
572          * physical space.
573          */
574         for (i = 0; i < 16; i++) {
575                 unsigned long virt = (unsigned long)bus->area->addr +
576                                      i * SZ_64K;
577                 phys_addr_t phys = cs + i * SZ_16M + busnr * SZ_64K;
578
579                 err = ioremap_page_range(virt, virt + SZ_64K, phys, prot);
580                 if (err < 0) {
581                         dev_err(pcie->dev, "ioremap_page_range() failed: %d\n",
582                                 err);
583                         goto unmap;
584                 }
585         }
586
587         return bus;
588 unmap:
589         vunmap(bus->area->addr);
590 free:
591         kfree(bus);
592         return ERR_PTR(err);
593 }
594
595 static void *tegra_pcie_bus_map(struct tegra_pcie *pcie,
596                                                         unsigned int busnr)
597 {
598         struct tegra_pcie_bus *bus;
599
600         list_for_each_entry(bus, &pcie->buses, list)
601                 if (bus->nr == busnr)
602                         return bus->area->addr;
603
604         return NULL;
605 }
606
607
608 static void __iomem *tegra_pcie_conf_address(struct pci_bus *bus,
609                                              unsigned int devfn,
610                                              int where)
611 {
612         struct tegra_pcie *pcie = sys_to_pcie(bus->sysdata);
613         void __iomem *addr = NULL;
614
615         if (bus->number == 0) {
616                 unsigned int slot = PCI_SLOT(devfn);
617                 struct tegra_pcie_port *port;
618
619                 list_for_each_entry(port, &pcie->ports, list) {
620                         if ((port->index + 1 == slot) && port->status) {
621                                 addr = port->base + (where & ~3);
622                                 break;
623                         }
624                 }
625         } else {
626                 addr = (void __iomem *)tegra_pcie_bus_map(pcie, bus->number);
627                 if (!addr) {
628                         dev_err(pcie->dev,
629                                 "failed to map cfg. space for bus %u\n",
630                                 bus->number);
631                         return NULL;
632                 }
633
634                 addr += tegra_pcie_conf_offset(devfn, where);
635         }
636
637         return addr;
638 }
639
640 static int tegra_pcie_read_conf(struct pci_bus *bus, unsigned int devfn,
641                                 int where, int size, u32 *value)
642 {
643         void __iomem *addr;
644
645         addr = tegra_pcie_conf_address(bus, devfn, where);
646         if (!addr) {
647                 *value = 0xffffffff;
648                 return PCIBIOS_DEVICE_NOT_FOUND;
649         }
650
651         *value = readl(addr);
652
653         if (size == 1)
654                 *value = (*value >> (8 * (where & 3))) & 0xff;
655         else if (size == 2)
656                 *value = (*value >> (8 * (where & 3))) & 0xffff;
657
658         return PCIBIOS_SUCCESSFUL;
659 }
660
661 static int tegra_pcie_write_conf(struct pci_bus *bus, unsigned int devfn,
662                                  int where, int size, u32 value)
663 {
664         void __iomem *addr;
665         u32 mask, tmp;
666
667         addr = tegra_pcie_conf_address(bus, devfn, where);
668         if (!addr)
669                 return PCIBIOS_DEVICE_NOT_FOUND;
670
671         if (size == 4) {
672                 writel(value, addr);
673                 return PCIBIOS_SUCCESSFUL;
674         }
675
676         if (size == 2)
677                 mask = ~(0xffff << ((where & 0x3) * 8));
678         else if (size == 1)
679                 mask = ~(0xff << ((where & 0x3) * 8));
680         else
681                 return PCIBIOS_BAD_REGISTER_NUMBER;
682
683         tmp = readl(addr) & mask;
684         tmp |= value << ((where & 0x3) * 8);
685         writel(tmp, addr);
686
687         return PCIBIOS_SUCCESSFUL;
688 }
689
690 static struct pci_ops tegra_pcie_ops = {
691         .read   = tegra_pcie_read_conf,
692         .write  = tegra_pcie_write_conf,
693 };
694
695 static void tegra_pcie_fixup_bridge(struct pci_dev *dev)
696 {
697         u16 reg;
698
699         if ((dev->class >> 16) == PCI_BASE_CLASS_BRIDGE) {
700                 pci_read_config_word(dev, PCI_COMMAND, &reg);
701                 reg |= (PCI_COMMAND_IO | PCI_COMMAND_MEMORY |
702                         PCI_COMMAND_MASTER | PCI_COMMAND_SERR);
703                 pci_write_config_word(dev, PCI_COMMAND, reg);
704         }
705 }
706 DECLARE_PCI_FIXUP_FINAL(PCI_ANY_ID, PCI_ANY_ID, tegra_pcie_fixup_bridge);
707
708 /* Tegra PCIE root complex wrongly reports device class */
709 static void tegra_pcie_fixup_class(struct pci_dev *dev)
710 {
711         dev->class = PCI_CLASS_BRIDGE_PCI << 8;
712 }
713
714 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_NVIDIA, 0x0e1c, tegra_pcie_fixup_class);
715 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_NVIDIA, 0x0e1d, tegra_pcie_fixup_class);
716
717 /* Tegra PCIE requires relaxed ordering */
718 static void tegra_pcie_relax_enable(struct pci_dev *dev)
719 {
720         pcie_capability_set_word(dev, PCI_EXP_DEVCTL, PCI_EXP_DEVCTL_RELAX_EN);
721 }
722 DECLARE_PCI_FIXUP_FINAL(PCI_ANY_ID, PCI_ANY_ID, tegra_pcie_relax_enable);
723
724 static int tegra_pcie_setup(int nr, struct pci_sys_data *sys)
725 {
726         struct tegra_pcie *pcie = sys_to_pcie(sys);
727         int err;
728
729         PR_FUNC_LINE;
730         err = devm_request_resource(pcie->dev, &iomem_resource, &pcie->mem);
731         if (err < 0)
732                 return err;
733
734         err = devm_request_resource(pcie->dev, &iomem_resource,
735                          &pcie->prefetch);
736         if (err < 0) {
737                 devm_release_resource(pcie->dev, &pcie->mem);
738                 return err;
739         }
740
741         pci_add_resource_offset(
742                 &sys->resources, &pcie->mem, sys->mem_offset);
743         pci_add_resource_offset(
744                 &sys->resources, &pcie->prefetch, sys->mem_offset);
745         pci_add_resource(&sys->resources, &pcie->busn);
746
747         pci_ioremap_io(nr * resource_size(&pcie->io), pcie->io.start);
748
749         return 1;
750 }
751
752 static int tegra_pcie_map_irq(const struct pci_dev *dev, u8 slot, u8 pin)
753 {
754         struct tegra_pcie *pcie = sys_to_pcie(dev->bus->sysdata);
755         return pcie->irq;
756 }
757
758 static void tegra_pcie_add_bus(struct pci_bus *bus)
759 {
760         struct tegra_pcie_bus *tbus;
761         struct tegra_pcie *pcie = sys_to_pcie(bus->sysdata);
762
763         PR_FUNC_LINE;
764         /* bus 0 is root complex whose config space is already mapped */
765         if (!bus->number)
766                 return;
767         if (IS_ENABLED(CONFIG_PCI_MSI))
768                 bus->msi = &pcie->msi.chip;
769
770         /* Allocate memory for new bus */
771         tbus = tegra_pcie_bus_alloc(pcie, bus->number);
772         if (IS_ERR(tbus))
773                 return;
774         list_add_tail(&tbus->list, &pcie->buses);
775 }
776
777 static struct pci_bus *tegra_pcie_scan_bus(int nr,
778                                                   struct pci_sys_data *sys)
779 {
780         struct tegra_pcie *pcie = sys_to_pcie(sys);
781         struct pci_bus *bus;
782
783         PR_FUNC_LINE;
784
785         bus = pci_create_root_bus(pcie->dev, sys->busnr, &tegra_pcie_ops, sys,
786                                   &sys->resources);
787         if (!bus)
788                 return NULL;
789
790         pci_scan_child_bus(bus);
791
792         return bus;
793 }
794
795 static unsigned long tegra_pcie_port_get_pex_ctrl(struct tegra_pcie_port *port)
796 {
797         unsigned long ret = 0;
798
799         switch (port->index) {
800         case 0:
801                 ret = AFI_PEX0_CTRL;
802                 break;
803
804         case 1:
805                 ret = AFI_PEX1_CTRL;
806                 break;
807         }
808
809         return ret;
810 }
811
812 #if defined(CONFIG_PCIEASPM)
813 static void tegra_pcie_config_l1ss_l12_thtime(void)
814 {
815         struct pci_dev *pdev = NULL;
816         u32 data = 0, pos = 0;
817
818         PR_FUNC_LINE;
819         /* program same LTR L1.2 threshold = 55us for all ports */
820         for_each_pci_dev(pdev) {
821                 pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_L1SS);
822                 if (!pos)
823                         continue;
824                 pci_read_config_dword(pdev, pos + PCI_L1SS_CTRL1, &data);
825                 data |= 0x37 << PCI_L1SS_CTRL1_L12TH_VAL_SHIFT;
826                 pci_write_config_dword(pdev, pos + PCI_L1SS_CTRL1, data);
827                 pci_read_config_dword(pdev, pos + PCI_L1SS_CTRL1, &data);
828                 data |= 0x02 << PCI_L1SS_CTRL1_L12TH_SCALE_SHIFT;
829                 pci_write_config_dword(pdev, pos + PCI_L1SS_CTRL1, data);
830         }
831 }
832
833 static void tegra_pcie_enable_ltr_support(void)
834 {
835         struct pci_dev *pdev = NULL;
836         u16 val = 0;
837         u32 data = 0, pos = 0;
838
839         PR_FUNC_LINE;
840         /* enable LTR mechanism for L1.2 support in end points */
841         for_each_pci_dev(pdev) {
842                 pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_L1SS);
843                 if (!pos)
844                         continue;
845                 pci_read_config_dword(pdev, pos + PCI_L1SS_CAP, &data);
846                 if (!((data & PCI_L1SS_CAP_ASPM_L12S) ||
847                         (data & PCI_L1SS_CAP_PM_L12S)))
848                         continue;
849                 pcie_capability_read_dword(pdev, PCI_EXP_DEVCAP2, &data);
850                 if (data & PCI_EXP_DEVCAP2_LTR) {
851                         pcie_capability_read_word(pdev, PCI_EXP_DEVCTL2, &val);
852                         val |= PCI_EXP_LTR_EN;
853                         pcie_capability_write_word(pdev, PCI_EXP_DEVCTL2, val);
854                 }
855         }
856 }
857
858 #if defined(CONFIG_ARCH_TEGRA_21x_SOC)
859 static void tegra_pcie_config_clkreq(struct tegra_pcie *pcie, u32 port)
860 {
861         static struct pinctrl_dev *pctl_dev = NULL;
862         unsigned long od_conf, tr_conf;
863
864         PR_FUNC_LINE;
865
866         if (!pctl_dev)
867                 pctl_dev = pinctrl_get_dev_from_of_compatible(
868                                 pinctrl_compatible);
869         if (!pctl_dev) {
870                 dev_err(pcie->dev,
871                         "%s(): tegra pincontrol does not found\n", __func__);
872                 return;
873         }
874
875         od_conf = TEGRA_PINCONF_PACK(TEGRA_PINCONF_PARAM_OPEN_DRAIN,
876                                 TEGRA_PIN_ENABLE);
877         tr_conf = TEGRA_PINCONF_PACK(TEGRA_PINCONF_PARAM_TRISTATE,
878                                 TEGRA_PIN_DISABLE);
879
880         /* Make CLKREQ# bi-directional if L1PM SS are enabled */
881         if (port) {
882                 pinctrl_set_config_for_group_name(pctl_dev,
883                                 pin_pex_l1_clkreq, tr_conf);
884                 pinctrl_set_config_for_group_name(pctl_dev,
885                                 pin_pex_l1_clkreq, od_conf);
886         } else {
887                 pinctrl_set_config_for_group_name(pctl_dev,
888                                 pin_pex_l0_clkreq, tr_conf);
889                 pinctrl_set_config_for_group_name(pctl_dev,
890                                 pin_pex_l0_clkreq, od_conf);
891         }
892 }
893 #endif
894
895 struct dev_ids {
896         unsigned short  vid;
897         unsigned short  did;
898 };
899
900 static struct dev_ids aspm_l0s_whitelist_dev[0] = {
901 /*      {0x14e4, 0x4355},       // BCM-4359     */
902 };
903
904 /* Enable ASPM support of all devices based on it's capability */
905 static void tegra_pcie_configure_aspm(void)
906 {
907         struct pci_dev *pdev = NULL;
908         struct tegra_pcie *pcie = NULL;
909
910         PR_FUNC_LINE;
911         for_each_pci_dev(pdev) {
912                 pcie = sys_to_pcie(pdev->bus->sysdata);
913                 break;
914         }
915         /* disable ASPM-L0s for all links unless the endpoint
916          * is a known device with proper ASPM-L0s functionality
917          */
918         for_each_pci_dev(pdev) {
919                 struct pci_dev *parent = NULL;
920                 struct tegra_pcie_port *port = NULL;
921                 unsigned long ctrl = 0;
922                 u32 rp = 0, val = 0, disable = 0, i = 0;
923                 bool whitelist = false;
924
925                 if ((pci_pcie_type(pdev) == PCI_EXP_TYPE_ROOT_PORT) ||
926                         (pci_pcie_type(pdev) == PCI_EXP_TYPE_DOWNSTREAM))
927                         continue;
928                 parent = pdev->bus->self;
929
930                 /* following needs to be done only for devices which are
931                  * directly connected to Tegra root ports */
932                 if (parent->bus->self)
933                         continue;
934                 rp = PCI_SLOT(parent->devfn);
935                 list_for_each_entry(port, &pcie->ports, list)
936                         if (rp == port->index + 1)
937                                 break;
938                 ctrl = tegra_pcie_port_get_pex_ctrl(port);
939                 /* AFI_PEX_STATUS is AFI_PEX_CTRL + 4 */
940                 val = afi_readl(port->pcie, ctrl + 4);
941                 if (val & 0x1)
942                         disable |= PCIE_LINK_STATE_CLKPM;
943
944                 /* Enable ASPM-l0s for only whitelisted devices */
945                 for (i = 0; i < ARRAY_SIZE(aspm_l0s_whitelist_dev); i++) {
946                         if ((pdev->vendor == aspm_l0s_whitelist_dev[i].vid) &&
947                                 (pdev->device == aspm_l0s_whitelist_dev[i].did))
948                                 whitelist = true;
949                 }
950                 if (!whitelist)
951                         disable |= PCIE_LINK_STATE_L0S;
952                 pci_disable_link_state_locked(pdev, disable);
953
954 #if defined(CONFIG_ARCH_TEGRA_21x_SOC)
955                 /* check if L1SS capability is supported in current device */
956                 i = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_L1SS);
957                 if (!i)
958                         continue;
959                 /* avoid L1SS config if no support of L1PM substate feature */
960                 pci_read_config_dword(pdev, i + PCI_L1SS_CAP, &val);
961                 if ((val & PCI_L1SS_CAP_L1PMS) ||
962                         (val & PCI_L1SS_CAP_L1PM_MASK))
963                         tegra_pcie_config_clkreq(pcie, port->index);
964 #endif
965         }
966         /* L1.2 specific common configuration */
967         tegra_pcie_config_l1ss_l12_thtime();
968         tegra_pcie_enable_ltr_support();
969 }
970 #endif
971
972 static void tegra_pcie_postinit(void)
973 {
974 #if defined(CONFIG_PCIEASPM)
975         tegra_pcie_configure_aspm();
976 #endif
977 }
978
979 static void tegra_pcie_teardown(int nr, struct pci_sys_data *sys)
980 {
981         struct tegra_pcie *pcie = sys_to_pcie(sys);
982         pci_iounmap_io(nr * resource_size(&pcie->io));
983 }
984
985 static struct hw_pci tegra_pcie_hw = {
986         .nr_controllers = 1,
987         .setup          = tegra_pcie_setup,
988         .scan           = tegra_pcie_scan_bus,
989         .postinit       = tegra_pcie_postinit,
990         .map_irq        = tegra_pcie_map_irq,
991         .add_bus        = tegra_pcie_add_bus,
992         .teardown       = tegra_pcie_teardown,
993 };
994
995 #ifdef HOTPLUG_ON_SYSTEM_BOOT
996 /* It enumerates the devices when dock is connected after system boot */
997 /* this is similar to pcibios_init_hw in bios32.c */
998 static void __init tegra_pcie_hotplug_init(void)
999 {
1000         struct pci_sys_data *sys = NULL;
1001         int ret, nr;
1002
1003         if (is_dock_conn_at_boot)
1004                 return;
1005
1006         PR_FUNC_LINE;
1007         tegra_pcie_preinit();
1008         for (nr = 0; nr < tegra_pcie_hw.nr_controllers; nr++) {
1009                 sys = kzalloc(sizeof(struct pci_sys_data), GFP_KERNEL);
1010                 if (!sys)
1011                         panic("PCI: unable to allocate sys data!");
1012
1013 #ifdef CONFIG_PCI_DOMAINS
1014                 sys->domain  = tegra_pcie_hw.domain;
1015 #endif
1016                 sys->busnr   = nr;
1017                 sys->swizzle = tegra_pcie_hw.swizzle;
1018                 sys->map_irq = tegra_pcie_hw.map_irq;
1019                 INIT_LIST_HEAD(&sys->resources);
1020
1021                 ret = tegra_pcie_setup(nr, sys);
1022                 if (ret > 0) {
1023                         if (list_empty(&sys->resources)) {
1024                                 pci_add_resource_offset(&sys->resources,
1025                                          &ioport_resource, sys->io_offset);
1026                                 pci_add_resource_offset(&sys->resources,
1027                                          &iomem_resource, sys->mem_offset);
1028                         }
1029                         pci_create_root_bus(NULL, nr, &tegra_pcie_ops,
1030                                         sys, &sys->resources);
1031                 }
1032         }
1033         is_dock_conn_at_boot = true;
1034 }
1035 #endif
1036
1037 static void tegra_pcie_enable_aer(struct tegra_pcie_port *port, bool enable)
1038 {
1039         unsigned int data;
1040
1041         PR_FUNC_LINE;
1042         data = rp_readl(port, NV_PCIE2_RP_VEND_CTL1);
1043         if (enable)
1044                 data |= PCIE2_RP_VEND_CTL1_ERPT;
1045         else
1046                 data &= ~PCIE2_RP_VEND_CTL1_ERPT;
1047         rp_writel(port, data, NV_PCIE2_RP_VEND_CTL1);
1048 }
1049
1050 static int tegra_pcie_attach(struct tegra_pcie *pcie)
1051 {
1052         struct pci_bus *bus = NULL;
1053         struct tegra_pcie_port *port;
1054
1055         PR_FUNC_LINE;
1056         if (!hotplug_event)
1057                 return 0;
1058
1059         /* rescan and recreate all pcie data structures */
1060         while ((bus = pci_find_next_bus(bus)) != NULL)
1061                 pci_rescan_bus(bus);
1062         /* unhide AER capability */
1063         list_for_each_entry(port, &pcie->ports, list)
1064                 if (port->status)
1065                         tegra_pcie_enable_aer(port, true);
1066
1067         hotplug_event = false;
1068         return 0;
1069 }
1070
1071 static int tegra_pcie_detach(struct tegra_pcie *pcie)
1072 {
1073         struct pci_dev *pdev = NULL;
1074         struct tegra_pcie_port *port;
1075
1076         PR_FUNC_LINE;
1077         if (hotplug_event)
1078                 return 0;
1079         hotplug_event = true;
1080
1081         /* hide AER capability to avoid log spew */
1082         list_for_each_entry(port, &pcie->ports, list)
1083                 if (port->status)
1084                         tegra_pcie_enable_aer(port, false);
1085
1086         /* remove all pcie data structures */
1087         for_each_pci_dev(pdev) {
1088                 pci_stop_and_remove_bus_device(pdev);
1089                 break;
1090         }
1091         return 0;
1092 }
1093
1094 static void tegra_pcie_prsnt_map_override(struct tegra_pcie_port *port,
1095                                         bool prsnt)
1096 {
1097         unsigned int data;
1098
1099         PR_FUNC_LINE;
1100         /* currently only hotplug on root port 0 supported */
1101         data = rp_readl(port, NV_PCIE2_RP_PRIV_MISC);
1102         data &= ~PCIE2_RP_PRIV_MISC_PRSNT_MAP_EP_ABSNT;
1103         if (prsnt)
1104                 data |= PCIE2_RP_PRIV_MISC_PRSNT_MAP_EP_PRSNT;
1105         else
1106                 data |= PCIE2_RP_PRIV_MISC_PRSNT_MAP_EP_ABSNT;
1107         rp_writel(port, data, NV_PCIE2_RP_PRIV_MISC);
1108 }
1109
1110 static void work_hotplug_handler(struct work_struct *work)
1111 {
1112         struct tegra_pcie *pcie_driver =
1113                 container_of(work, struct tegra_pcie, hotplug_detect);
1114         int val;
1115
1116         PR_FUNC_LINE;
1117         if (pcie_driver->plat_data->gpio_hot_plug == -1)
1118                 return;
1119         val = gpio_get_value(pcie_driver->plat_data->gpio_hot_plug);
1120         if (val == 0) {
1121                 dev_info(pcie_driver->dev, "PCIE Hotplug: Connected\n");
1122                 tegra_pcie_attach(pcie_driver);
1123         } else {
1124                 dev_info(pcie_driver->dev, "PCIE Hotplug: DisConnected\n");
1125                 tegra_pcie_detach(pcie_driver);
1126         }
1127 }
1128
1129 static irqreturn_t gpio_pcie_detect_isr(int irq, void *arg)
1130 {
1131         struct tegra_pcie *pcie = arg;
1132         PR_FUNC_LINE;
1133         schedule_work(&pcie->hotplug_detect);
1134         return IRQ_HANDLED;
1135 }
1136
1137 static void handle_sb_intr(struct tegra_pcie *pcie)
1138 {
1139         u32 mesg;
1140
1141         PR_FUNC_LINE;
1142         mesg = afi_readl(pcie, AFI_MSG_0);
1143         if (mesg & AFI_MSG_INTX_MASK)
1144                 /* notify device isr for INTx messages from pcie devices */
1145                 dev_dbg(pcie->dev,
1146                         "Legacy INTx interrupt occurred %x\n", mesg);
1147         else if (mesg & AFI_MSG_PM_PME_MASK) {
1148                 struct tegra_pcie_port *port, *tmp;
1149                 /* handle PME messages */
1150                 list_for_each_entry_safe(port, tmp, &pcie->ports, list)
1151                         if (port->index == (mesg & AFI_MSG_PM_PME0))
1152                                 break;
1153                 mesg = rp_readl(port, NV_PCIE2_RP_RSR);
1154                 mesg |= NV_PCIE2_RP_RSR_PMESTAT;
1155                 rp_writel(port, mesg, NV_PCIE2_RP_RSR);
1156         } else
1157                 afi_writel(pcie, mesg, AFI_MSG_0);
1158 }
1159
1160 static irqreturn_t tegra_pcie_isr(int irq, void *arg)
1161 {
1162         const char *err_msg[] = {
1163                 "Unknown",
1164                 "AXI slave error",
1165                 "AXI decode error",
1166                 "Target abort",
1167                 "Master abort",
1168                 "Invalid write",
1169                 "",
1170                 "Response decoding error",
1171                 "AXI response decoding error",
1172                 "Transcation timeout",
1173                 "",
1174                 "Slot Clock request change",
1175                 "TMS Clock clamp change",
1176                 "TMS power down",
1177                 "Peer to Peer error",
1178         };
1179         struct tegra_pcie *pcie = arg;
1180         u32 code, signature;
1181
1182         PR_FUNC_LINE;
1183         code = afi_readl(pcie, AFI_INTR_CODE) & AFI_INTR_CODE_MASK;
1184         signature = afi_readl(pcie, AFI_INTR_SIGNATURE);
1185
1186         if (code == AFI_INTR_LEGACY)
1187                 handle_sb_intr(pcie);
1188         afi_writel(pcie, 0, AFI_INTR_CODE);
1189
1190         if (code >= ARRAY_SIZE(err_msg))
1191                 code = 0;
1192
1193         /*
1194          * do not pollute kernel log with master abort reports since they
1195          * happen a lot during enumeration
1196          */
1197         if (code == AFI_INTR_MASTER_ABORT)
1198                 pr_debug("PCIE: %s, signature: %08x\n",
1199                                 err_msg[code], signature);
1200         else if ((code != AFI_INTR_LEGACY) && (code != AFI_INTR_PRSNT_SENSE))
1201                 dev_err(pcie->dev, "PCIE: %s, signature: %08x\n",
1202                                 err_msg[code], signature);
1203
1204         return IRQ_HANDLED;
1205 }
1206
1207 /*
1208  * FPCI map is as follows:
1209  * - 0xfdfc000000: I/O space
1210  * - 0xfdfe000000: type 0 configuration space
1211  * - 0xfdff000000: type 1 configuration space
1212  * - 0xfe00000000: type 0 extended configuration space
1213  * - 0xfe10000000: type 1 extended configuration space
1214  */
1215 static void tegra_pcie_setup_translations(struct tegra_pcie *pcie)
1216 {
1217         u32 fpci_bar, size, axi_address;
1218
1219         /* Bar 0: type 1 extended configuration space */
1220         fpci_bar = 0xfe100000;
1221         size = resource_size(pcie->cs);
1222         axi_address = pcie->cs->start;
1223         afi_writel(pcie, axi_address, AFI_AXI_BAR0_START);
1224         afi_writel(pcie, size >> 12, AFI_AXI_BAR0_SZ);
1225         afi_writel(pcie, fpci_bar, AFI_FPCI_BAR0);
1226
1227         /* Bar 1: downstream IO bar */
1228         fpci_bar = 0xfdfc0000;
1229         size = resource_size(&pcie->io);
1230         axi_address = pcie->io.start;
1231         afi_writel(pcie, axi_address, AFI_AXI_BAR1_START);
1232         afi_writel(pcie, size >> 12, AFI_AXI_BAR1_SZ);
1233         afi_writel(pcie, fpci_bar, AFI_FPCI_BAR1);
1234
1235         /* Bar 2: prefetchable memory BAR */
1236         fpci_bar = (((pcie->prefetch.start >> 12) & 0x0fffffff) << 4) | 0x1;
1237         size = resource_size(&pcie->prefetch);
1238         axi_address = pcie->prefetch.start;
1239         afi_writel(pcie, axi_address, AFI_AXI_BAR2_START);
1240         afi_writel(pcie, size >> 12, AFI_AXI_BAR2_SZ);
1241         afi_writel(pcie, fpci_bar, AFI_FPCI_BAR2);
1242
1243         /* Bar 3: non prefetchable memory BAR */
1244         fpci_bar = (((pcie->mem.start >> 12) & 0x0fffffff) << 4) | 0x1;
1245         size = resource_size(&pcie->mem);
1246         axi_address = pcie->mem.start;
1247         afi_writel(pcie, axi_address, AFI_AXI_BAR3_START);
1248         afi_writel(pcie, size >> 12, AFI_AXI_BAR3_SZ);
1249         afi_writel(pcie, fpci_bar, AFI_FPCI_BAR3);
1250
1251         /* NULL out the remaining BARs as they are not used */
1252         afi_writel(pcie, 0, AFI_AXI_BAR4_START);
1253         afi_writel(pcie, 0, AFI_AXI_BAR4_SZ);
1254         afi_writel(pcie, 0, AFI_FPCI_BAR4);
1255
1256         afi_writel(pcie, 0, AFI_AXI_BAR5_START);
1257         afi_writel(pcie, 0, AFI_AXI_BAR5_SZ);
1258         afi_writel(pcie, 0, AFI_FPCI_BAR5);
1259
1260         /* map all upstream transactions as uncached */
1261         afi_writel(pcie, PHYS_OFFSET, AFI_CACHE_BAR0_ST);
1262         afi_writel(pcie, 0, AFI_CACHE_BAR0_SZ);
1263         afi_writel(pcie, 0, AFI_CACHE_BAR1_ST);
1264         afi_writel(pcie, 0, AFI_CACHE_BAR1_SZ);
1265
1266         /* MSI translations are setup only when needed */
1267         afi_writel(pcie, 0, AFI_MSI_FPCI_BAR_ST);
1268         afi_writel(pcie, 0, AFI_MSI_BAR_SZ);
1269         afi_writel(pcie, 0, AFI_MSI_AXI_BAR_ST);
1270         afi_writel(pcie, 0, AFI_MSI_BAR_SZ);
1271 }
1272
1273 static int tegra_pcie_enable_pads(struct tegra_pcie *pcie, bool enable)
1274 {
1275         int err = 0;
1276
1277         PR_FUNC_LINE;
1278
1279         if (enable) {
1280                 if (pex_usb_pad_pll_reset_deassert())
1281                         dev_err(pcie->dev, "failed to deassert pex pll\n");
1282         }
1283
1284         if (!tegra_platform_is_fpga()) {
1285                 /* PCIe pad programming done in shared XUSB_PADCTL space */
1286                 err = pcie_phy_pad_enable(enable,
1287                                 pcie->plat_data->lane_map);
1288                 if (err)
1289                         dev_err(pcie->dev,
1290                                 "%s unable to initalize pads\n", __func__);
1291         }
1292
1293         if (!enable || err) {
1294                 if (pex_usb_pad_pll_reset_assert())
1295                         dev_err(pcie->dev, "failed to assert pex pll\n");
1296         }
1297
1298         return err;
1299 }
1300
1301 static void tegra_pcie_enable_wrap(void)
1302 {
1303 #if defined(CONFIG_ARCH_TEGRA_21x_SOC)
1304         u32 val;
1305         void __iomem *msel_base;
1306
1307         PR_FUNC_LINE;
1308 #define MSELECT_CONFIG_BASE     0x50060000
1309 #define MSELECT_CONFIG_WRAP_TO_INCR_SLAVE1      BIT(28)
1310 #define MSELECT_CONFIG_ERR_RESP_EN_SLAVE1       BIT(24)
1311
1312         /* Config MSELECT to support wrap trans for normal NC & GRE mapping */
1313         msel_base = ioremap(MSELECT_CONFIG_BASE, 4);
1314         val = readl(msel_base);
1315         /* Enable WRAP_TO_INCR_SLAVE1 */
1316         val |= MSELECT_CONFIG_WRAP_TO_INCR_SLAVE1;
1317         /* Disable ERR_RESP_EN_SLAVE1 */
1318         val &= ~MSELECT_CONFIG_ERR_RESP_EN_SLAVE1;
1319         writel(val, msel_base);
1320         iounmap(msel_base);
1321 #endif
1322 }
1323
1324 static int tegra_pcie_enable_controller(struct tegra_pcie *pcie)
1325 {
1326         u32 val;
1327         struct tegra_pcie_port *port, *tmp;
1328
1329         PR_FUNC_LINE;
1330         tegra_pcie_enable_wrap();
1331         /* Enable PLL power down */
1332         val = afi_readl(pcie, AFI_PLLE_CONTROL);
1333         val &= ~AFI_PLLE_CONTROL_BYPASS_PCIE2PLLE_CONTROL;
1334         val &= ~AFI_PLLE_CONTROL_BYPASS_PADS2PLLE_CONTROL;
1335         val |= AFI_PLLE_CONTROL_PADS2PLLE_CONTROL_EN;
1336         val |= AFI_PLLE_CONTROL_PCIE2PLLE_CONTROL_EN;
1337         list_for_each_entry_safe(port, tmp, &pcie->ports, list) {
1338                 if (port->disable_clock_request) {
1339                         val &= ~AFI_PLLE_CONTROL_PADS2PLLE_CONTROL_EN;
1340                         break;
1341                 }
1342         }
1343         afi_writel(pcie, val, AFI_PLLE_CONTROL);
1344
1345         afi_writel(pcie, 0, AFI_PEXBIAS_CTRL_0);
1346
1347         /* Enable all PCIE controller and */
1348         /* system management configuration of PCIE crossbar */
1349         val = afi_readl(pcie, AFI_PCIE_CONFIG);
1350         val &= ~AFI_PCIE_CONFIG_PCIEC0_DISABLE_DEVICE;
1351         if (tegra_platform_is_fpga()) {
1352                 /* FPGA supports only x2_x1 bar config */
1353                 val &= ~AFI_PCIE_CONFIG_XBAR_CONFIG_MASK;
1354                 val |= AFI_PCIE_CONFIG_XBAR_CONFIG_X2_X1;
1355         } else {
1356                 if (pcie->plat_data->lane_map & PCIE_LANES_X0_X1)
1357                         val &= ~AFI_PCIE_CONFIG_PCIEC1_DISABLE_DEVICE;
1358 #if !defined(CONFIG_ARCH_TEGRA_21x_SOC)
1359                 val &= ~AFI_PCIE_CONFIG_XBAR_CONFIG_MASK;
1360                 if (pcie->plat_data->lane_map & PCIE_LANES_X4_X0)
1361                         val |= AFI_PCIE_CONFIG_XBAR_CONFIG_X4_X1;
1362 #endif
1363         }
1364         afi_writel(pcie, val, AFI_PCIE_CONFIG);
1365
1366         /* Enable Gen 2 capability of PCIE */
1367         val = afi_readl(pcie, AFI_FUSE) & ~AFI_FUSE_PCIE_T0_GEN2_DIS;
1368         afi_writel(pcie, val, AFI_FUSE);
1369
1370         /* Finally enable PCIe */
1371         val = afi_readl(pcie, AFI_CONFIGURATION);
1372         val |=  AFI_CONFIGURATION_EN_FPCI;
1373         afi_writel(pcie, val, AFI_CONFIGURATION);
1374
1375         val = (AFI_INTR_EN_INI_SLVERR | AFI_INTR_EN_INI_DECERR |
1376                AFI_INTR_EN_TGT_SLVERR | AFI_INTR_EN_TGT_DECERR |
1377                AFI_INTR_EN_TGT_WRERR | AFI_INTR_EN_DFPCI_DECERR |
1378                AFI_INTR_EN_AXI_DECERR | AFI_INTR_EN_PRSNT_SENSE);
1379         afi_writel(pcie, val, AFI_AFI_INTR_ENABLE);
1380         afi_writel(pcie, 0xffffffff, AFI_SM_INTR_ENABLE);
1381
1382         /* FIXME: No MSI for now, only INT */
1383         afi_writel(pcie, AFI_INTR_MASK_INT_MASK, AFI_INTR_MASK);
1384
1385         /* Disable all execptions */
1386         afi_writel(pcie, 0, AFI_FPCI_ERROR_MASKS);
1387
1388         return 0;
1389 }
1390
1391 static int tegra_pcie_enable_regulators(struct tegra_pcie *pcie)
1392 {
1393         int i;
1394         PR_FUNC_LINE;
1395         if (pcie->power_rails_enabled) {
1396                 dev_info(pcie->dev, "PCIE: Already power rails enabled\n");
1397                 return 0;
1398         }
1399         pcie->power_rails_enabled = 1;
1400         dev_info(pcie->dev, "PCIE: Enable power rails\n");
1401
1402         for (i = 0; i < pcie->soc_data->num_pcie_regulators; i++) {
1403                 if (pcie->pcie_regulators[i])
1404                         if (regulator_enable(pcie->pcie_regulators[i]))
1405                                 dev_err(pcie->dev, "%s: can't enable regulator %s\n",
1406                                 __func__,
1407                                 pcie->soc_data->pcie_regulator_names[i]);
1408         }
1409
1410         return 0;
1411
1412 }
1413
1414 static int tegra_pcie_disable_regulators(struct tegra_pcie *pcie)
1415 {
1416         int i;
1417         PR_FUNC_LINE;
1418         if (pcie->power_rails_enabled == 0) {
1419                 dev_info(pcie->dev, "PCIE: Already power rails disabled\n");
1420                 return 0;
1421         }
1422         dev_info(pcie->dev, "PCIE: Disable power rails\n");
1423
1424         for (i = 0; i < pcie->soc_data->num_pcie_regulators; i++) {
1425                 if (pcie->pcie_regulators[i] != NULL)
1426                         if (regulator_disable(pcie->pcie_regulators[i]))
1427                                 dev_err(pcie->dev, "%s: can't disable regulator %s\n",
1428                                 __func__,
1429                                 pcie->soc_data->pcie_regulator_names[i]);
1430         }
1431
1432         pcie->power_rails_enabled = 0;
1433         return 0;
1434
1435 }
1436
1437 static int tegra_pcie_power_ungate(struct tegra_pcie *pcie)
1438 {
1439         int err;
1440         int partition_id;
1441
1442         PR_FUNC_LINE;
1443 #ifdef CONFIG_PM_GENERIC_DOMAINS_OF
1444         partition_id = tegra_pd_get_powergate_id(tegra_pcie_pd);
1445         if (partition_id < 0)
1446                 return -EINVAL;
1447 #else
1448         partition_id = TEGRA_POWERGATE_PCIE;
1449 #endif
1450
1451         err = clk_prepare_enable(pcie->pcie_pll_e);
1452         if (err) {
1453                 dev_err(pcie->dev, "PCIE: PLLE clk enable failed: %d\n", err);
1454                 return err;
1455         }
1456
1457         err = tegra_unpowergate_partition_with_clk_on(partition_id);
1458         if (err) {
1459                 dev_err(pcie->dev, "PCIE: powerup sequence failed: %d\n", err);
1460                 return err;
1461         }
1462
1463         err = clk_prepare_enable(pcie->pcie_mselect);
1464         if (err) {
1465                 dev_err(pcie->dev, "PCIE: mselect clk enable failed: %d\n",
1466                         err);
1467                 return err;
1468         }
1469         err = clk_enable(pcie->pcie_xclk);
1470         if (err) {
1471                 dev_err(pcie->dev, "PCIE: pciex clk enable failed: %d\n", err);
1472                 return err;
1473         }
1474         err = clk_prepare_enable(pcie->pcie_emc);
1475         if (err) {
1476                 dev_err(pcie->dev, "PCIE:  emc clk enable failed: %d\n", err);
1477                 return err;
1478         }
1479
1480         return 0;
1481 }
1482
1483 static int tegra_pcie_map_resources(struct tegra_pcie *pcie)
1484 {
1485         struct platform_device *pdev = to_platform_device(pcie->dev);
1486         struct resource *pads, *afi, *res;
1487
1488         PR_FUNC_LINE;
1489         pads = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pads");
1490
1491         pcie->pads_res = __devm_request_region(&pdev->dev, &iomem_resource,
1492                         pads->start, resource_size(pads),
1493                         "pcie-pads");
1494
1495         if (!pcie->pads_res) {
1496                 dev_err(&pdev->dev,
1497                         "PCIE: Failed to request region for pad registers\n");
1498                 return -EBUSY;
1499         }
1500
1501         pcie->pads = devm_ioremap_nocache(&pdev->dev, pads->start,
1502                                                 resource_size(pads));
1503         if (!(pcie->pads)) {
1504                 dev_err(pcie->dev, "PCIE: Failed to map PAD registers\n");
1505                 return -EADDRNOTAVAIL;
1506         }
1507
1508         afi = platform_get_resource_byname(pdev, IORESOURCE_MEM, "afi");
1509
1510         pcie->afi_res = __devm_request_region(&pdev->dev, &iomem_resource,
1511                         afi->start, resource_size(afi),
1512                         "pcie-afi");
1513
1514         if (!pcie->afi_res) {
1515                 dev_err(&pdev->dev,
1516                         "PCIE: Failed to request region for afi registers\n");
1517                 return -EBUSY;
1518         }
1519
1520         pcie->afi = devm_ioremap_nocache(&pdev->dev, afi->start,
1521                                                 resource_size(afi));
1522         if (!(pcie->afi)) {
1523                 dev_err(pcie->dev, "PCIE: Failed to map AFI registers\n");
1524                 return -EADDRNOTAVAIL;
1525         }
1526
1527         /* request configuration space, but remap later, on demand */
1528         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "cs");
1529
1530         pcie->cs = __devm_request_region(&pdev->dev, &iomem_resource,
1531                         res->start, resource_size(res), "pcie-config-space");
1532         if (!pcie->cs) {
1533                 dev_err(&pdev->dev, "PCIE: Failed to request region for CS registers\n");
1534                 return -EBUSY;
1535         }
1536
1537         return 0;
1538 }
1539
1540 static void tegra_pcie_unmap_resources(struct tegra_pcie *pcie)
1541 {
1542         struct platform_device *pdev = to_platform_device(pcie->dev);
1543
1544         PR_FUNC_LINE;
1545
1546         if (pcie->cs)
1547                 __devm_release_region(&pdev->dev, &iomem_resource,
1548                                 pcie->cs->start,
1549                                 resource_size(pcie->cs));
1550         if (pcie->afi_res)
1551                 __devm_release_region(&pdev->dev, &iomem_resource,
1552                                 pcie->afi_res->start,
1553                                 resource_size(pcie->afi_res));
1554         if (pcie->pads_res)
1555                 __devm_release_region(&pdev->dev, &iomem_resource,
1556                                 pcie->pads_res->start,
1557                                 resource_size(pcie->pads_res));
1558
1559         if (pcie->pads) {
1560                 devm_iounmap(&pdev->dev, pcie->pads);
1561                 pcie->pads = NULL;
1562         }
1563         if (pcie->afi) {
1564                 devm_iounmap(&pdev->dev, pcie->afi);
1565                 pcie->afi = NULL;
1566         }
1567 }
1568
1569 static int tegra_pcie_fpga_phy_init(struct tegra_pcie *pcie)
1570 {
1571 #define FPGA_GEN2_SPEED_SUPPORT         0x90000001
1572         struct tegra_pcie_port *port;
1573
1574         PR_FUNC_LINE;
1575         /* Do reset for FPGA pcie phy */
1576         afi_writel(pcie, AFI_WR_SCRATCH_0_RESET_VAL, AFI_WR_SCRATCH_0);
1577         udelay(10);
1578         afi_writel(pcie, AFI_WR_SCRATCH_0_DEFAULT_VAL, AFI_WR_SCRATCH_0);
1579         udelay(10);
1580         afi_writel(pcie, AFI_WR_SCRATCH_0_RESET_VAL, AFI_WR_SCRATCH_0);
1581
1582         /* required for gen2 speed support on FPGA */
1583         list_for_each_entry(port, &pcie->ports, list)
1584                 rp_writel(port,
1585                         FPGA_GEN2_SPEED_SUPPORT, NV_PCIE2_RP_VEND_XP_BIST);
1586
1587         return 0;
1588 }
1589
1590 static void tegra_pcie_pme_turnoff(struct tegra_pcie *pcie)
1591 {
1592         unsigned int data;
1593
1594         PR_FUNC_LINE;
1595         if (tegra_platform_is_fpga())
1596                 return;
1597         data = afi_readl(pcie, AFI_PCIE_PME);
1598         data |= AFI_PCIE_PME_TURN_OFF;
1599         afi_writel(pcie, data, AFI_PCIE_PME);
1600         do {
1601                 data = afi_readl(pcie, AFI_PCIE_PME);
1602         } while (!(data & AFI_PCIE_PME_ACK));
1603
1604         /* Required for PLL power down */
1605         data = afi_readl(pcie, AFI_PLLE_CONTROL);
1606         data |= AFI_PLLE_CONTROL_BYPASS_PADS2PLLE_CONTROL;
1607         afi_writel(pcie, data, AFI_PLLE_CONTROL);
1608 }
1609
1610 static struct tegra_io_dpd pexbias_io = {
1611         .name                   = "PEX_BIAS",
1612         .io_dpd_reg_index       = 0,
1613         .io_dpd_bit             = 4,
1614 };
1615 static struct tegra_io_dpd pexclk1_io = {
1616         .name                   = "PEX_CLK1",
1617         .io_dpd_reg_index       = 0,
1618         .io_dpd_bit             = 5,
1619 };
1620 static struct tegra_io_dpd pexclk2_io = {
1621         .name                   = "PEX_CLK2",
1622         .io_dpd_reg_index       = 0,
1623         .io_dpd_bit             = 6,
1624 };
1625 static int tegra_pcie_power_on(struct tegra_pcie *pcie)
1626 {
1627         int err = 0;
1628
1629         PR_FUNC_LINE;
1630         if (pcie->pcie_power_enabled) {
1631                 dev_info(pcie->dev, "PCIE: Already powered on");
1632                 goto err_exit;
1633         }
1634         pcie->pcie_power_enabled = 1;
1635         pm_runtime_get_sync(pcie->dev);
1636
1637         if (!tegra_platform_is_fpga()) {
1638                 /* disable PEX IOs DPD mode to turn on pcie */
1639                 tegra_io_dpd_disable(&pexbias_io);
1640                 tegra_io_dpd_disable(&pexclk1_io);
1641                 tegra_io_dpd_disable(&pexclk2_io);
1642         }
1643         err = tegra_pcie_map_resources(pcie);
1644         if (err) {
1645                 dev_err(pcie->dev, "PCIE: Failed to map resources\n");
1646                 goto err_map_resource;
1647         }
1648         err = tegra_pcie_power_ungate(pcie);
1649         if (err) {
1650                 dev_err(pcie->dev, "PCIE: Failed to power ungate\n");
1651                 goto err_power_ungate;
1652         }
1653         if (tegra_platform_is_fpga()) {
1654                 err = tegra_pcie_fpga_phy_init(pcie);
1655                 if (err)
1656                         dev_err(pcie->dev, "PCIE: Failed to initialize FPGA Phy\n");
1657         }
1658         return 0;
1659 err_power_ungate:
1660         tegra_pcie_unmap_resources(pcie);
1661 err_map_resource:
1662         if (!tegra_platform_is_fpga()) {
1663                 /* put PEX pads into DPD mode to save additional power */
1664                 tegra_io_dpd_enable(&pexbias_io);
1665                 tegra_io_dpd_enable(&pexclk1_io);
1666                 tegra_io_dpd_enable(&pexclk2_io);
1667         }
1668         pm_runtime_put(pcie->dev);
1669         pcie->pcie_power_enabled = 0;
1670 err_exit:
1671         return err;
1672 }
1673
1674 static int tegra_pcie_power_off(struct tegra_pcie *pcie, bool all)
1675 {
1676         int err = 0;
1677         struct tegra_pcie_port *port;
1678         int partition_id;
1679
1680         PR_FUNC_LINE;
1681         if (pcie->pcie_power_enabled == 0) {
1682                 dev_info(pcie->dev, "PCIE: Already powered off");
1683                 goto err_exit;
1684         }
1685         if (all) {
1686                 list_for_each_entry(port, &pcie->ports, list) {
1687                         tegra_pcie_prsnt_map_override(port, false);
1688                 }
1689                 tegra_pcie_pme_turnoff(pcie);
1690                 tegra_pcie_enable_pads(pcie, false);
1691         }
1692         tegra_pcie_unmap_resources(pcie);
1693         if (pcie->pcie_mselect)
1694                 clk_disable(pcie->pcie_mselect);
1695         if (pcie->pcie_xclk)
1696                 clk_disable(pcie->pcie_xclk);
1697         if (pcie->pcie_emc)
1698                 clk_disable(pcie->pcie_emc);
1699 #ifdef CONFIG_PM_GENERIC_DOMAINS_OF
1700         partition_id = tegra_pd_get_powergate_id(tegra_pcie_pd);
1701         if (partition_id < 0)
1702                 return -EINVAL;
1703 #else
1704         partition_id = TEGRA_POWERGATE_PCIE;
1705 #endif
1706         err = tegra_powergate_partition_with_clk_off(partition_id);
1707         if (err)
1708                 goto err_exit;
1709
1710         if (pcie->pcie_pll_e)
1711                 clk_disable(pcie->pcie_pll_e);
1712
1713         if (!tegra_platform_is_fpga()) {
1714                 /* put PEX pads into DPD mode to save additional power */
1715                 tegra_io_dpd_enable(&pexbias_io);
1716                 tegra_io_dpd_enable(&pexclk1_io);
1717                 tegra_io_dpd_enable(&pexclk2_io);
1718         }
1719         pm_runtime_put(pcie->dev);
1720
1721         pcie->pcie_power_enabled = 0;
1722 err_exit:
1723         return err;
1724 }
1725
1726 static int tegra_pcie_clocks_get(struct tegra_pcie *pcie)
1727 {
1728         PR_FUNC_LINE;
1729         /* get the PCIEXCLK */
1730         pcie->pcie_xclk = clk_get_sys("tegra_pcie", "pciex");
1731         if (IS_ERR_OR_NULL(pcie->pcie_xclk)) {
1732                 dev_err(pcie->dev, "unable to get PCIE Xclock\n");
1733                 return -EINVAL;
1734         }
1735         pcie->pcie_afi = clk_get_sys("tegra_pcie", "afi");
1736         if (IS_ERR_OR_NULL(pcie->pcie_afi)) {
1737                 clk_put(pcie->pcie_xclk);
1738                 dev_err(pcie->dev, "unable to get PCIE afi clock\n");
1739                 return -EINVAL;
1740         }
1741         pcie->pcie_pcie = clk_get_sys("tegra_pcie", "pcie");
1742         if (IS_ERR_OR_NULL(pcie->pcie_pcie)) {
1743                 clk_put(pcie->pcie_afi);
1744                 clk_put(pcie->pcie_xclk);
1745                 dev_err(pcie->dev, "unable to get PCIE pcie clock\n");
1746                 return -EINVAL;
1747         }
1748
1749         pcie->pcie_pll_e = clk_get_sys("tegra_pcie", "pll_e");
1750         if (IS_ERR_OR_NULL(pcie->pcie_pll_e)) {
1751                 clk_put(pcie->pcie_afi);
1752                 clk_put(pcie->pcie_xclk);
1753                 clk_put(pcie->pcie_pcie);
1754                 dev_err(pcie->dev, "unable to get PCIE PLLE clock\n");
1755                 return -EINVAL;
1756         }
1757
1758         pcie->pcie_mselect = clk_get_sys("tegra_pcie", "mselect");
1759         if (IS_ERR_OR_NULL(pcie->pcie_mselect)) {
1760                 clk_put(pcie->pcie_pll_e);
1761                 clk_put(pcie->pcie_pcie);
1762                 clk_put(pcie->pcie_afi);
1763                 clk_put(pcie->pcie_xclk);
1764                 dev_err(pcie->dev,
1765                         "unable to get PCIE mselect clock\n");
1766                 return -EINVAL;
1767         }
1768         pcie->pcie_emc = clk_get_sys("tegra_pcie", "emc");
1769         if (IS_ERR_OR_NULL(pcie->pcie_emc)) {
1770                 dev_err(pcie->dev,
1771                         "unable to get PCIE emc clock\n");
1772                 return -EINVAL;
1773         }
1774         return 0;
1775 }
1776
1777 static void tegra_pcie_clocks_put(struct tegra_pcie *pcie)
1778 {
1779         PR_FUNC_LINE;
1780         if (pcie->pcie_xclk)
1781                 clk_put(pcie->pcie_xclk);
1782         if (pcie->pcie_pcie)
1783                 clk_put(pcie->pcie_pcie);
1784         if (pcie->pcie_afi)
1785                 clk_put(pcie->pcie_afi);
1786         if (pcie->pcie_mselect)
1787                 clk_put(pcie->pcie_mselect);
1788         if (pcie->pcie_pll_e)
1789                 clk_put(pcie->pcie_pll_e);
1790         if (pcie->pcie_mselect)
1791                 clk_put(pcie->pcie_mselect);
1792         if (pcie->pcie_emc)
1793                 clk_put(pcie->pcie_emc);
1794 }
1795
1796 static int tegra_pcie_get_resources(struct tegra_pcie *pcie)
1797 {
1798         struct platform_device *pdev = to_platform_device(pcie->dev);
1799         int err;
1800
1801         PR_FUNC_LINE;
1802         pcie->power_rails_enabled = 0;
1803         pcie->pcie_power_enabled = 0;
1804
1805         err = tegra_pcie_clocks_get(pcie);
1806         if (err) {
1807                 dev_err(pcie->dev, "PCIE: failed to get clocks: %d\n", err);
1808                 goto err_clk_get;
1809         }
1810
1811         err = tegra_pcie_enable_regulators(pcie);
1812         if (err) {
1813                 dev_err(pcie->dev, "PCIE: Failed to enable regulators\n");
1814                 goto err_enable_reg;
1815         }
1816         err = tegra_pcie_power_on(pcie);
1817         if (err) {
1818                 dev_err(pcie->dev, "PCIE: Failed to power on: %d\n", err);
1819                 goto err_pwr_on;
1820         }
1821
1822         err = clk_set_rate(pcie->pcie_mselect, tegra_pcie_mselect_rate);
1823         if (err) {
1824                 dev_err(pcie->dev,
1825                         "PCIE: Failed to set mselect rate: %d\n", err);
1826                 goto err_clk_rate;
1827         }
1828
1829         err = clk_set_rate(pcie->pcie_xclk, tegra_pcie_xclk_rate);
1830         if (err) {
1831                 dev_err(pcie->dev, "PCIE: Failed to set xclk rate: %d\n", err);
1832                 goto err_clk_rate;
1833         }
1834
1835         err = clk_set_rate(pcie->pcie_emc, tegra_pcie_emc_rate);
1836         if (err)
1837                 return err;
1838
1839         err = platform_get_irq_byname(pdev, "intr");
1840         if (err < 0) {
1841                 dev_err(pcie->dev, "failed to get IRQ: %d\n", err);
1842                 goto err_clk_rate;
1843         }
1844
1845         pcie->irq = err;
1846
1847         err = devm_request_irq(&pdev->dev, pcie->irq, tegra_pcie_isr,
1848                         IRQF_SHARED, "PCIE", pcie);
1849         if (err) {
1850                 dev_err(pcie->dev, "PCIE: Failed to register IRQ: %d\n", err);
1851                 goto err_clk_rate;
1852         }
1853         set_irq_flags(pcie->irq, IRQF_VALID);
1854
1855         return 0;
1856
1857 err_clk_rate:
1858         tegra_pcie_power_off(pcie, true);
1859 err_pwr_on:
1860         tegra_pcie_disable_regulators(pcie);
1861 err_enable_reg:
1862         tegra_pcie_clocks_put(pcie);
1863 err_clk_get:
1864         return err;
1865 }
1866
1867 static void tegra_pcie_port_reset(struct tegra_pcie_port *port)
1868 {
1869         unsigned long ctrl = tegra_pcie_port_get_pex_ctrl(port);
1870         unsigned long value;
1871
1872         PR_FUNC_LINE;
1873
1874         /* pulse reset signal */
1875         value = afi_readl(port->pcie, ctrl);
1876         value &= ~AFI_PEX_CTRL_RST;
1877         afi_writel(port->pcie, value, ctrl);
1878
1879         usleep_range(1000, 2000);
1880
1881         value = afi_readl(port->pcie, ctrl);
1882         value |= AFI_PEX_CTRL_RST;
1883         afi_writel(port->pcie, value, ctrl);
1884 }
1885
1886 static void tegra_pcie_port_enable(struct tegra_pcie_port *port)
1887 {
1888         unsigned long ctrl = tegra_pcie_port_get_pex_ctrl(port);
1889         unsigned long value;
1890
1891         PR_FUNC_LINE;
1892
1893         /* enable reference clock. Enable SW override so as to allow device
1894            to get enumerated. SW override will be removed after enumeration
1895         */
1896         value = afi_readl(port->pcie, ctrl);
1897         value |= (AFI_PEX_CTRL_REFCLK_EN | AFI_PEX_CTRL_OVERRIDE_EN);
1898         /* t124 doesn't support pll power down due to RTL bug and some */
1899         /* platforms don't support clkreq, both needs to disable clkreq and */
1900         /* enable refclk override to have refclk always ON independent of EP */
1901         if (port->disable_clock_request)
1902                 value |= AFI_PEX_CTRL_CLKREQ_EN;
1903         else
1904                 value &= ~AFI_PEX_CTRL_CLKREQ_EN;
1905
1906         afi_writel(port->pcie, value, ctrl);
1907
1908         tegra_pcie_port_reset(port);
1909 }
1910
1911 static void tegra_pcie_port_disable(struct tegra_pcie_port *port)
1912 {
1913         u32 data;
1914
1915         PR_FUNC_LINE;
1916         data = afi_readl(port->pcie, AFI_PCIE_CONFIG);
1917         if (port->index)
1918                 data |= AFI_PCIE_CONFIG_PCIEC1_DISABLE_DEVICE;
1919         else
1920                 data |= AFI_PCIE_CONFIG_PCIEC0_DISABLE_DEVICE;
1921         afi_writel(port->pcie, data, AFI_PCIE_CONFIG);
1922 }
1923
1924 #if defined(CONFIG_ARCH_TEGRA_21x_SOC)
1925 static bool get_rdet_status(u32 index)
1926 {
1927         u32 i = 0;
1928         bool flag = 0;
1929         for (i = 0; i < ARRAY_SIZE(rp_to_lane_map[index]); i++)
1930                 flag |= tegra_phy_get_lane_rdet(rp_to_lane_map[index][i]);
1931         return flag;
1932 }
1933 #endif
1934
1935 /*
1936  * FIXME: If there are no PCIe cards attached, then calling this function
1937  * can result in the increase of the bootup time as there are big timeout
1938  * loops.
1939  */
1940 #define TEGRA_PCIE_LINKUP_TIMEOUT       350     /* up to 350 ms */
1941 static bool tegra_pcie_port_check_link(struct tegra_pcie_port *port)
1942 {
1943         unsigned int retries = 3;
1944         unsigned long value;
1945
1946         PR_FUNC_LINE;
1947 #if defined(CONFIG_ARCH_TEGRA_21x_SOC)
1948         if (!get_rdet_status(port->index))
1949                 return false;
1950 #endif
1951         do {
1952                 unsigned int timeout = TEGRA_PCIE_LINKUP_TIMEOUT;
1953
1954                 do {
1955                         value = readl(port->base + RP_LINK_CONTROL_STATUS);
1956                         if (value & RP_LINK_CONTROL_STATUS_DL_LINK_ACTIVE)
1957                                 return true;
1958                         usleep_range(1000, 2000);
1959                 } while (--timeout);
1960                 dev_info(port->pcie->dev, "link %u down, retrying\n",
1961                                         port->index);
1962                 tegra_pcie_port_reset(port);
1963         } while (--retries);
1964
1965         return false;
1966 }
1967
1968 #if defined(CONFIG_ARCH_TEGRA_21x_SOC)
1969 static bool t210_war;
1970 #endif
1971 static void tegra_pcie_apply_sw_war(struct tegra_pcie_port *port,
1972                                 bool enum_done)
1973 {
1974         unsigned int data;
1975 #if defined(CONFIG_ARCH_TEGRA_21x_SOC)
1976         struct tegra_pcie *pcie = port->pcie;
1977 #endif
1978         struct pci_dev *pdev = NULL;
1979
1980         PR_FUNC_LINE;
1981 #if defined(CONFIG_ARCH_TEGRA_21x_SOC)
1982         /* T210 WAR for perf bugs required when LPDDR4 */
1983         /* memory is used with both ctlrs in X4_X1 config */
1984         if (pcie->plat_data->has_memtype_lpddr4 &&
1985                 (pcie->plat_data->lane_map == PCIE_LANES_X4_X1) &&
1986                 (pcie->num_ports == pcie->soc_data->num_ports))
1987                 t210_war = 1;
1988 #endif
1989         if (enum_done) {
1990                 /* disable msi for port driver to avoid panic */
1991                 for_each_pci_dev(pdev)
1992                         if (pci_pcie_type(pdev) == PCI_EXP_TYPE_ROOT_PORT)
1993                                 pdev->msi_enabled = 0;
1994         } else {
1995
1996                 /* Some of the old PCIe end points don't get enumerated
1997                  * if RP advertises both Gen-1 and Gen-2 speeds. Hence, the
1998                  * strategy followed here is to initially advertise only
1999                  * Gen-1 and after link is up, check end point's capability
2000                  * for Gen-2 and retrain link to Gen-2 speed
2001                  */
2002                 data = rp_readl(port, RP_LINK_CONTROL_STATUS_2);
2003                 data &= ~RP_LINK_CONTROL_STATUS_2_TRGT_LNK_SPD_MASK;
2004                 data |= RP_LINK_CONTROL_STATUS_2_TRGT_LNK_SPD_GEN1;
2005                 rp_writel(port, data, RP_LINK_CONTROL_STATUS_2);
2006
2007                 /* Avoid warning during enumeration for invalid IRQ of RP */
2008                 data = rp_readl(port, NV_PCIE2_RP_INTR_BCR);
2009                 data |= NV_PCIE2_RP_INTR_BCR_INTR_LINE;
2010                 rp_writel(port, data, NV_PCIE2_RP_INTR_BCR);
2011 #if defined(CONFIG_ARCH_TEGRA_21x_SOC)
2012                 /* resize buffers for better perf, bug#1447522 */
2013                 if (t210_war) {
2014                         struct tegra_pcie_port *temp_port;
2015                         list_for_each_entry(temp_port, &pcie->ports, list) {
2016                                 data = rp_readl(temp_port,
2017                                                         NV_PCIE2_RP_XP_CTL_1);
2018                                 data |= PCIE2_RP_XP_CTL_1_SPARE_BIT29;
2019                                 rp_writel(temp_port, data,
2020                                         NV_PCIE2_RP_XP_CTL_1);
2021
2022                                 data = rp_readl(temp_port,
2023                                                 NV_PCIE2_RP_TX_HDR_LIMIT);
2024                                 if (temp_port->index)
2025                                         data |= PCIE2_RP_TX_HDR_LIMIT_NPT_1;
2026                                 else
2027                                         data |= PCIE2_RP_TX_HDR_LIMIT_NPT_0;
2028                                 rp_writel(temp_port, data,
2029                                         NV_PCIE2_RP_TX_HDR_LIMIT);
2030                         }
2031                 }
2032                 /* Bug#1461732 WAR, set clkreq asserted delay greater than */
2033                 /* power off time (2us) to avoid RP wakeup in L1.2_ENTRY */
2034                 data = rp_readl(port, NV_PCIE2_RP_L1_PM_SUBSTATES_1_CYA);
2035                 data &= ~PCIE2_RP_L1_PM_SUBSTATES_1_CYA_CLKREQ_ASSERTED_DLY_MASK;
2036                 data |= PCIE2_RP_L1_PM_SUBSTATES_1_CYA_CLKREQ_ASSERTED_DLY;
2037                 rp_writel(port, data, NV_PCIE2_RP_L1_PM_SUBSTATES_1_CYA);
2038
2039                 /* take care of link speed change error in corner cases */
2040                 data = rp_readl(port, NV_PCIE2_RP_VEND_CTL0);
2041                 data &= ~PCIE2_RP_VEND_CTL0_DSK_RST_PULSE_WIDTH_MASK;
2042                 data |= PCIE2_RP_VEND_CTL0_DSK_RST_PULSE_WIDTH;
2043                 rp_writel(port, data, NV_PCIE2_RP_VEND_CTL0);
2044
2045                 data = rp_readl(port, NV_PCIE2_RP_VEND_XP_PAD_PWRDN);
2046                 data |= NV_PCIE2_RP_VEND_XP_PAD_PWRDN_DISABLED_EN;
2047                 data |= NV_PCIE2_RP_VEND_XP_PAD_PWRDN_DYNAMIC_EN;
2048                 data |= NV_PCIE2_RP_VEND_XP_PAD_PWRDN_L1_EN;
2049                 data |= NV_PCIE2_RP_VEND_XP_PAD_PWRDN_L1_CLKREQ_EN;
2050                 data |= NV_PCIE2_RP_VEND_XP_PAD_PWRDN_SLEEP_MODE_DYNAMIC_L1PP;
2051                 data |= NV_PCIE2_RP_VEND_XP_PAD_PWRDN_SLEEP_MODE_L1_L1PP;
2052                 data |= NV_PCIE2_RP_VEND_XP_PAD_PWRDN_SLEEP_MODE_L1_CLKREQ_L1PP;
2053                 rp_writel(port, data, NV_PCIE2_RP_VEND_XP_PAD_PWRDN);
2054
2055                 /* Do timer settings only if clk25m freq equal to 19.2 MHz */
2056                 if (clk_get_rate(clk_get_sys(NULL, "clk_m")) != 19200000)
2057                         return;
2058                 data = rp_readl(port, NV_PCIE2_RP_TIMEOUT0);
2059                 data &= ~PCIE2_RP_TIMEOUT0_PAD_PWRUP_MASK;
2060                 data |= PCIE2_RP_TIMEOUT0_PAD_PWRUP;
2061                 data &= ~PCIE2_RP_TIMEOUT0_PAD_PWRUP_CM_MASK;
2062                 data |= PCIE2_RP_TIMEOUT0_PAD_PWRUP_CM;
2063                 data &= ~PCIE2_RP_TIMEOUT0_PAD_SPDCHNG_GEN2_MASK;
2064                 data |= PCIE2_RP_TIMEOUT0_PAD_SPDCHNG_GEN2;
2065                 rp_writel(port, data, NV_PCIE2_RP_TIMEOUT0);
2066
2067                 data = rp_readl(port, NV_PCIE2_RP_TIMEOUT1);
2068                 data &= ~PCIE2_RP_TIMEOUT1_RCVRY_SPD_SUCCESS_EIDLE_MASK;
2069                 data |= PCIE2_RP_TIMEOUT1_RCVRY_SPD_SUCCESS_EIDLE;
2070                 data &= ~PCIE2_RP_TIMEOUT1_RCVRY_SPD_UNSUCCESS_EIDLE_MASK;
2071                 data |= PCIE2_RP_TIMEOUT1_RCVRY_SPD_UNSUCCESS_EIDLE;
2072                 rp_writel(port, data, NV_PCIE2_RP_TIMEOUT1);
2073
2074                 data = rp_readl(port, NV_PCIE2_RP_XP_REF);
2075                 data &= ~PCIE2_RP_XP_REF_MICROSECOND_LIMIT_MASK;
2076                 data |= PCIE2_RP_XP_REF_MICROSECOND_LIMIT;
2077                 data |= PCIE2_RP_XP_REF_MICROSECOND_ENABLE;
2078                 data |= PCIE2_RP_XP_REF_CPL_TO_OVERRIDE;
2079                 data &= ~PCIE2_RP_XP_REF_CPL_TO_CUSTOM_VALUE_MASK;
2080                 data |= PCIE2_RP_XP_REF_CPL_TO_CUSTOM_VALUE;
2081                 rp_writel(port, data, NV_PCIE2_RP_XP_REF);
2082
2083                 data = rp_readl(port, NV_PCIE2_RP_L1_PM_SUBSTATES_1_CYA);
2084                 data &= ~PCIE2_RP_L1_PM_SUBSTATES_1_CYA_PWR_OFF_DLY_MASK;
2085                 data |= PCIE2_RP_L1_PM_SUBSTATES_1_CYA_PWR_OFF_DLY;
2086                 rp_writel(port, data, NV_PCIE2_RP_L1_PM_SUBSTATES_1_CYA);
2087
2088                 data = rp_readl(port, NV_PCIE2_RP_L1_PM_SUBSTATES_2_CYA);
2089                 data &= ~PCIE2_RP_L1_PM_SUBSTATES_2_CYA_T_L1_2_DLY_MASK;
2090                 data |= PCIE2_RP_L1_PM_SUBSTATES_2_CYA_T_L1_2_DLY;
2091                 data &= ~PCIE2_RP_L1_PM_SUBSTATES_2_CYA_MICROSECOND_MASK;
2092                 data |= PCIE2_RP_L1_PM_SUBSTATES_2_CYA_MICROSECOND;
2093                 data &= ~PCIE2_RP_L1_PM_SUBSTATES_2_CYA_MICROSECOND_COMP_MASK;
2094                 data |= PCIE2_RP_L1_PM_SUBSTATES_2_CYA_MICROSECOND_COMP;
2095                 rp_writel(port, data, NV_PCIE2_RP_L1_PM_SUBSTATES_2_CYA);
2096 #else
2097                 /* WAR for RAW violation on T124/T132 platforms */
2098                 data = rp_readl(port, NV_PCIE2_RP_RX_HDR_LIMIT);
2099                 data &= ~PCIE2_RP_RX_HDR_LIMIT_PW_MASK;
2100                 data |= PCIE2_RP_RX_HDR_LIMIT_PW;
2101                 rp_writel(port, data, NV_PCIE2_RP_RX_HDR_LIMIT);
2102
2103                 data = rp_readl(port, NV_PCIE2_RP_PRIV_XP_DL);
2104                 data |= PCIE2_RP_PRIV_XP_DL_GEN2_UPD_FC_TSHOLD;
2105                 rp_writel(port, data, NV_PCIE2_RP_PRIV_XP_DL);
2106
2107                 data = rp_readl(port, RP_VEND_XP);
2108                 data |= RP_VEND_XP_UPDATE_FC_THRESHOLD;
2109                 rp_writel(port, data, RP_VEND_XP);
2110
2111                 data = rp_readl(port, NV_PCIE2_RP_VEND_XP_PAD_PWRDN);
2112                 data |= NV_PCIE2_RP_VEND_XP_PAD_PWRDN_DISABLED_EN;
2113                 data |= NV_PCIE2_RP_VEND_XP_PAD_PWRDN_DYNAMIC_EN;
2114                 data |= NV_PCIE2_RP_VEND_XP_PAD_PWRDN_L1_EN;
2115                 data |= NV_PCIE2_RP_VEND_XP_PAD_PWRDN_L1_CLKREQ_EN;
2116                 data |= NV_PCIE2_RP_VEND_XP_PAD_PWRDN_SLEEP_MODE_DYNAMIC_L1PP;
2117                 data |= NV_PCIE2_RP_VEND_XP_PAD_PWRDN_SLEEP_MODE_L1_L1P;
2118                 data |= NV_PCIE2_RP_VEND_XP_PAD_PWRDN_SLEEP_MODE_L1_CLKREQ_L1P;
2119                 rp_writel(port, data, NV_PCIE2_RP_VEND_XP_PAD_PWRDN);
2120 #endif
2121         }
2122 }
2123
2124 /* Enable various features of root port */
2125 static void tegra_pcie_enable_rp_features(struct tegra_pcie_port *port)
2126 {
2127         unsigned int data;
2128
2129         PR_FUNC_LINE;
2130         if (port->pcie->prod_list) {
2131                 if (tegra_prod_set_by_name(
2132                                 &(port->pcie->pads),
2133                                 "prod_c_pad",
2134                                 port->pcie->prod_list)) {
2135                         dev_info(port->pcie->dev,
2136                                         "pad prod settings are not found in DT\n");
2137                 }
2138
2139                 if (tegra_prod_set_by_name(
2140                                 &(port->base),
2141                                 "prod_c_rp",
2142                                 port->pcie->prod_list)) {
2143                         dev_info(port->pcie->dev,
2144                                         "RP prod settings are not found in DT\n");
2145                 }
2146         }
2147
2148         /* Optimal settings to enhance bandwidth */
2149         data = rp_readl(port, RP_VEND_XP);
2150         data |= RP_VEND_XP_OPPORTUNISTIC_ACK;
2151         data |= RP_VEND_XP_OPPORTUNISTIC_UPDATEFC;
2152         rp_writel(port, data, RP_VEND_XP);
2153
2154         /* Power mangagement settings */
2155         /* Enable clock clamping by default and enable card detect */
2156         data = rp_readl(port, NV_PCIE2_RP_PRIV_MISC);
2157         data |= PCIE2_RP_PRIV_MISC_CTLR_CLK_CLAMP_THRESHOLD |
2158                 PCIE2_RP_PRIV_MISC_CTLR_CLK_CLAMP_ENABLE |
2159                 PCIE2_RP_PRIV_MISC_TMS_CLK_CLAMP_THRESHOLD |
2160                 PCIE2_RP_PRIV_MISC_TMS_CLK_CLAMP_ENABLE;
2161         rp_writel(port, data, NV_PCIE2_RP_PRIV_MISC);
2162
2163         /* Enable ASPM - L1 state support by default */
2164         data = rp_readl(port, NV_PCIE2_RP_VEND_XP1);
2165         data |= NV_PCIE2_RP_VEND_XP_LINK_PVT_CTL_L1_ASPM_SUPPORT;
2166         rp_writel(port, data, NV_PCIE2_RP_VEND_XP1);
2167
2168         /* LTSSM wait for DLLP to finish before entering L1 or L2/L3 */
2169         /* to avoid truncating of PM mesgs resulting in reciever errors */
2170         data = rp_readl(port, NV_PCIE2_RP_VEND_XP_BIST);
2171         data |= PCIE2_RP_VEND_XP_BIST_GOTO_L1_L2_AFTER_DLLP_DONE;
2172         rp_writel(port, data, NV_PCIE2_RP_VEND_XP_BIST);
2173
2174         /* unhide AER capability */
2175         tegra_pcie_enable_aer(port, true);
2176
2177 #if defined(CONFIG_ARCH_TEGRA_21x_SOC)
2178         /* program timers for L1 substate support */
2179         /* set cm_rtime = 30us and t_pwr_on = 70us as per HW team */
2180         data = rp_readl(port, NV_PCIE2_RP_L1_PM_SUBSTATES_CYA);
2181         data &= ~PCIE2_RP_L1_PM_SUBSTATES_CYA_CM_RTIME_MASK;
2182         data |= (0x1E << PCIE2_RP_L1_PM_SUBSTATES_CYA_CM_RTIME_SHIFT);
2183         rp_writel(port, data, NV_PCIE2_RP_L1_PM_SUBSTATES_CYA);
2184
2185         data = rp_readl(port, NV_PCIE2_RP_L1_PM_SUBSTATES_CYA);
2186         data &= ~(PCIE2_RP_L1_PM_SUBSTATES_CYA_T_PWRN_SCL_MASK |
2187                 PCIE2_RP_L1_PM_SUBSTATES_CYA_T_PWRN_VAL_MASK);
2188         data |= (1 << PCIE2_RP_L1_PM_SUBSTATES_CYA_T_PWRN_SCL_SHIFT) |
2189                 (7 << PCIE2_RP_L1_PM_SUBSTATES_CYA_T_PWRN_VAL_SHIFT);
2190         rp_writel(port, data, NV_PCIE2_RP_L1_PM_SUBSTATES_CYA);
2191 #endif
2192         tegra_pcie_apply_sw_war(port, false);
2193 }
2194
2195 static void tegra_pcie_update_lane_width(struct tegra_pcie_port *port)
2196 {
2197         port->lanes = rp_readl(port, RP_LINK_CONTROL_STATUS);
2198         port->lanes = (port->lanes &
2199                 RP_LINK_CONTROL_STATUS_NEG_LINK_WIDTH) >> 20;
2200 }
2201
2202 static void tegra_pcie_update_pads2plle(struct tegra_pcie_port *port)
2203 {
2204         unsigned long ctrl = 0;
2205         u32 val = 0;
2206
2207         ctrl = tegra_pcie_port_get_pex_ctrl(port);
2208         /* AFI_PEX_STATUS is AFI_PEX_CTRL + 4 */
2209         val = afi_readl(port->pcie, ctrl + 4);
2210         if (val & 0x1) {
2211                 val = afi_readl(port->pcie, AFI_PLLE_CONTROL);
2212                 val &= ~AFI_PLLE_CONTROL_PADS2PLLE_CONTROL_EN;
2213                 afi_writel(port->pcie, val, AFI_PLLE_CONTROL);
2214         }
2215 }
2216
2217 #if defined(CONFIG_ARCH_TEGRA_21x_SOC)
2218 static void mbist_war(struct tegra_pcie *pcie, bool apply)
2219 {
2220         struct tegra_pcie_port *port, *tmp;
2221         u32 data;
2222
2223         list_for_each_entry_safe(port, tmp, &pcie->ports, list) {
2224                 /* nature of MBIST bug is such that it needs to be applied
2225                  * only for RootPort-0 even if there are no devices
2226                  * connected to it */
2227                 if (port->index == 0) {
2228                         data = rp_readl(port, NV_PCIE2_RP_VEND_CTL2);
2229                         if (apply)
2230                                 data |= PCIE2_RP_VEND_CTL2_PCA_ENABLE;
2231                         else
2232                                 data &= ~PCIE2_RP_VEND_CTL2_PCA_ENABLE;
2233                         rp_writel(port, data, NV_PCIE2_RP_VEND_CTL2);
2234                 }
2235         }
2236 }
2237 #endif
2238
2239 static void tegra_pcie_check_ports(struct tegra_pcie *pcie)
2240 {
2241         struct tegra_pcie_port *port, *tmp;
2242
2243         PR_FUNC_LINE;
2244         pcie->num_ports = 0;
2245
2246 #if defined(CONFIG_ARCH_TEGRA_21x_SOC)
2247         mbist_war(pcie, true);
2248 #endif
2249         list_for_each_entry_safe(port, tmp, &pcie->ports, list) {
2250                 dev_info(pcie->dev, "probing port %u, using %u lanes and lane map as 0x%x\n",
2251                          port->index, port->lanes, pcie->plat_data->lane_map);
2252
2253                 tegra_pcie_port_enable(port);
2254                 tegra_pcie_enable_rp_features(port);
2255                 /* override presence detection */
2256                 if (gpio_is_valid(port->gpio_presence_detection))
2257                         tegra_pcie_prsnt_map_override(port,
2258                                 !(gpio_get_value_cansleep(
2259                                         port->gpio_presence_detection)));
2260                 else
2261                         tegra_pcie_prsnt_map_override(port, true);
2262         }
2263         /* Wait for clock to latch (min of 100us) */
2264         udelay(100);
2265         tegra_periph_reset_deassert(pcie->pcie_xclk);
2266         /* at this point in time, there is no end point which would
2267          * take more than 20 msec for root port to detect receiver and
2268          * set AUX_TX_RDET_STATUS bit. This would bring link up checking
2269          * time from its current value (around 200ms) to flat 20ms
2270          */
2271         usleep_range(19000, 21000);
2272         list_for_each_entry_safe(port, tmp, &pcie->ports, list) {
2273                 if (tegra_pcie_port_check_link(port)) {
2274                         port->status = 1;
2275                         pcie->num_ports++;
2276                         tegra_pcie_update_lane_width(port);
2277                         tegra_pcie_update_pads2plle(port);
2278                         continue;
2279                 }
2280                 dev_info(pcie->dev, "link %u down, ignoring\n", port->index);
2281                 tegra_pcie_port_disable(port);
2282         }
2283 #if defined(CONFIG_ARCH_TEGRA_21x_SOC)
2284                 mbist_war(pcie, false);
2285 #endif
2286 }
2287
2288 static int tegra_pcie_conf_gpios(struct tegra_pcie *pcie)
2289 {
2290         int irq, err = 0;
2291         struct tegra_pcie_port *port, *tmp;
2292
2293         PR_FUNC_LINE;
2294         if (gpio_is_valid(pcie->plat_data->gpio_hot_plug)) {
2295                 /* configure gpio for hotplug detection */
2296                 dev_info(pcie->dev, "acquiring hotplug_detect = %d\n",
2297                                 pcie->plat_data->gpio_hot_plug);
2298                 err = devm_gpio_request(pcie->dev,
2299                                 pcie->plat_data->gpio_hot_plug,
2300                                 "pcie_hotplug_detect");
2301                 if (err < 0) {
2302                         dev_err(pcie->dev, "%s: gpio_request failed %d\n",
2303                                         __func__, err);
2304                         return err;
2305                 }
2306                 err = gpio_direction_input(
2307                                 pcie->plat_data->gpio_hot_plug);
2308                 if (err < 0) {
2309                         dev_err(pcie->dev,
2310                                 "%s: gpio_direction_input failed %d\n",
2311                                 __func__, err);
2312                         return err;
2313                 }
2314                 irq = gpio_to_irq(pcie->plat_data->gpio_hot_plug);
2315                 if (irq < 0) {
2316                         dev_err(pcie->dev,
2317                                 "Unable to get irq for hotplug_detect\n");
2318                         return err;
2319                 }
2320                 err = devm_request_irq(pcie->dev, (unsigned int)irq,
2321                                 gpio_pcie_detect_isr,
2322                                 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
2323                                 "pcie_hotplug_detect",
2324                                 (void *)pcie);
2325                 if (err < 0) {
2326                         dev_err(pcie->dev,
2327                                 "Unable to claim irq for hotplug_detect\n");
2328                         return err;
2329                 }
2330         }
2331         if (gpio_is_valid(pcie->plat_data->gpio_x1_slot)) {
2332                 err = devm_gpio_request(pcie->dev,
2333                         pcie->plat_data->gpio_x1_slot, "pcie_x1_slot");
2334                 if (err < 0) {
2335                         dev_err(pcie->dev,
2336                                 "%s: pcie_x1_slot gpio_request failed %d\n",
2337                                 __func__, err);
2338                         return err;
2339                 }
2340                 err = gpio_direction_output(
2341                         pcie->plat_data->gpio_x1_slot, 1);
2342                 if (err < 0) {
2343                         dev_err(pcie->dev,
2344                                 "%s: pcie_x1_slot gpio_direction_output failed %d\n",
2345                                         __func__, err);
2346                         return err;
2347                 }
2348                 gpio_set_value_cansleep(
2349                         pcie->plat_data->gpio_x1_slot, 1);
2350         }
2351         if (gpio_is_valid(pcie->plat_data->gpio_wake)) {
2352                 err = devm_gpio_request(pcie->dev,
2353                                 pcie->plat_data->gpio_wake, "pcie_wake");
2354                 if (err < 0) {
2355                         dev_err(pcie->dev,
2356                                 "%s: pcie_wake gpio_request failed %d\n",
2357                                 __func__, err);
2358                         return err;
2359                 }
2360                 err = gpio_direction_input(
2361                                 pcie->plat_data->gpio_wake);
2362                 if (err < 0) {
2363                         dev_err(pcie->dev,
2364                                 "%s: pcie_wake gpio_direction_input failed %d\n",
2365                                         __func__, err);
2366                         return err;
2367                 }
2368         }
2369
2370         list_for_each_entry_safe(port, tmp, &pcie->ports, list) {
2371                 if (gpio_is_valid(port->gpio_presence_detection)) {
2372                         err = devm_gpio_request_one(pcie->dev,
2373                                         port->gpio_presence_detection,
2374                                         GPIOF_DIR_IN,
2375                                         "pcie_presence_detection");
2376                         if (err < 0) {
2377                                 dev_err(pcie->dev,
2378                                         "%s: pcie_prsnt gpio_request failed %d\n",
2379                                         __func__, err);
2380                                 return err;
2381                         }
2382                 }
2383         }
2384         return 0;
2385 }
2386
2387 static int tegra_pcie_scale_voltage(struct tegra_pcie *pcie, bool isGen2)
2388 {
2389         int err = 0;
2390
2391         PR_FUNC_LINE;
2392         if (isGen2) {
2393                 if (tegra_pcie_xclk_rate == TEGRA_PCIE_XCLK_500 &&
2394                         tegra_pcie_mselect_rate == TEGRA_PCIE_MSELECT_CLK_408 &&
2395                         tegra_pcie_emc_rate == TEGRA_PCIE_EMC_CLK_528)
2396                         goto skip;
2397                 /* Scale up voltage for Gen2 speed */
2398                 tegra_pcie_xclk_rate = TEGRA_PCIE_XCLK_500;
2399                 tegra_pcie_mselect_rate = TEGRA_PCIE_MSELECT_CLK_408;
2400                 tegra_pcie_emc_rate = TEGRA_PCIE_EMC_CLK_528;
2401         } else {
2402                 if (tegra_pcie_xclk_rate == TEGRA_PCIE_XCLK_250 &&
2403                         tegra_pcie_mselect_rate == TEGRA_PCIE_MSELECT_CLK_204 &&
2404                         tegra_pcie_emc_rate == TEGRA_PCIE_EMC_CLK_102)
2405                         goto skip;
2406                 /* Scale down voltage for Gen1 speed */
2407                 tegra_pcie_xclk_rate = TEGRA_PCIE_XCLK_250;
2408                 tegra_pcie_mselect_rate = TEGRA_PCIE_MSELECT_CLK_204;
2409                 tegra_pcie_emc_rate = TEGRA_PCIE_EMC_CLK_102;
2410         }
2411         err = clk_set_rate(pcie->pcie_xclk, tegra_pcie_xclk_rate);
2412         if (err)
2413                 return err;
2414         err = clk_set_rate(pcie->pcie_mselect, tegra_pcie_mselect_rate);
2415         if (err)
2416                 return err;
2417         err = clk_set_rate(pcie->pcie_emc, tegra_pcie_emc_rate);
2418 skip:
2419         return err;
2420
2421 }
2422
2423 static bool tegra_pcie_change_link_speed(struct tegra_pcie *pcie,
2424                                 struct pci_dev *pdev, bool isGen2)
2425 {
2426         u16 val, link_sts_up_spd, link_sts_dn_spd;
2427         u16 link_cap_up_spd, link_cap_dn_spd;
2428         struct pci_dev *up_dev, *dn_dev;
2429
2430         PR_FUNC_LINE;
2431         /* skip if current device is not PCI express capable */
2432         /* or is either a root port or downstream port */
2433         if (!pci_is_pcie(pdev))
2434                 goto skip;
2435         if ((pci_pcie_type(pdev) == PCI_EXP_TYPE_DOWNSTREAM) ||
2436                 (pci_pcie_type(pdev) == PCI_EXP_TYPE_ROOT_PORT))
2437                 goto skip;
2438
2439         /* initialize upstream/endpoint and downstream/root port device ptr */
2440         up_dev = pdev;
2441         dn_dev = pdev->bus->self;
2442
2443         /* read link status register to find current speed */
2444         pcie_capability_read_word(up_dev, PCI_EXP_LNKSTA, &link_sts_up_spd);
2445         link_sts_up_spd &= PCI_EXP_LNKSTA_CLS;
2446         pcie_capability_read_word(dn_dev, PCI_EXP_LNKSTA, &link_sts_dn_spd);
2447         link_sts_dn_spd &= PCI_EXP_LNKSTA_CLS;
2448         /* read link capability register to find max speed supported */
2449         pcie_capability_read_word(up_dev, PCI_EXP_LNKCAP, &link_cap_up_spd);
2450         link_cap_up_spd &= PCI_EXP_LNKCAP_SLS;
2451         pcie_capability_read_word(dn_dev, PCI_EXP_LNKCAP, &link_cap_dn_spd);
2452         link_cap_dn_spd &= PCI_EXP_LNKCAP_SLS;
2453         /* skip if both devices across the link are already trained to gen2 */
2454         if (isGen2) {
2455                 if (((link_cap_up_spd >= PCI_EXP_LNKSTA_CLS_5_0GB) &&
2456                         (link_cap_dn_spd >= PCI_EXP_LNKSTA_CLS_5_0GB)) &&
2457                         ((link_sts_up_spd != PCI_EXP_LNKSTA_CLS_5_0GB) ||
2458                          (link_sts_dn_spd != PCI_EXP_LNKSTA_CLS_5_0GB)))
2459                         goto change;
2460                 else
2461                         goto skip;
2462         } else {
2463                 /* gen1 should be supported by default by all pcie cards */
2464                 if ((link_sts_up_spd != PCI_EXP_LNKSTA_CLS_2_5GB) ||
2465                          (link_sts_dn_spd != PCI_EXP_LNKSTA_CLS_2_5GB))
2466                         goto change;
2467                 else
2468                         goto skip;
2469         }
2470
2471 change:
2472         if (tegra_pcie_scale_voltage(pcie, isGen2))
2473                 goto skip;
2474         /* Set Link Speed */
2475         pcie_capability_read_word(dn_dev, PCI_EXP_LNKCTL2, &val);
2476         val &= ~PCI_EXP_LNKSTA_CLS;
2477         if (isGen2)
2478                 val |= PCI_EXP_LNKSTA_CLS_5_0GB;
2479         else
2480                 val |= PCI_EXP_LNKSTA_CLS_2_5GB;
2481         pcie_capability_write_word(dn_dev, PCI_EXP_LNKCTL2, val);
2482
2483         /* Retrain the link */
2484         pcie_capability_read_word(dn_dev, PCI_EXP_LNKCTL, &val);
2485         val |= PCI_EXP_LNKCTL_RL;
2486         pcie_capability_write_word(dn_dev, PCI_EXP_LNKCTL, val);
2487
2488         return true;
2489 skip:
2490         return false;
2491 }
2492
2493 static bool tegra_pcie_link_speed(struct tegra_pcie *pcie, bool isGen2)
2494 {
2495         struct pci_dev *pdev = NULL;
2496         bool ret = false;
2497
2498         PR_FUNC_LINE;
2499         /* Voltage scaling should happen before any device transition */
2500         /* to Gen2 or after all devices has transitioned to Gen1 */
2501         for_each_pci_dev(pdev) {
2502                 if (tegra_pcie_change_link_speed(pcie, pdev, isGen2))
2503                         ret = true;
2504         }
2505         return ret;
2506 }
2507
2508 static void tegra_pcie_enable_features(struct tegra_pcie *pcie)
2509 {
2510         struct tegra_pcie_port *port;
2511
2512         PR_FUNC_LINE;
2513         /* configure all links to gen2 speed by default */
2514         if (!tegra_pcie_link_speed(pcie, true))
2515                 dev_info(pcie->dev, "PCIE: No Link speed change happened\n");
2516
2517         list_for_each_entry(port, &pcie->ports, list) {
2518                 if (port->status)
2519                         tegra_pcie_apply_sw_war(port, true);
2520         }
2521 }
2522 static int tegra_pcie_enable_msi(struct tegra_pcie *, bool);
2523 static int tegra_pcie_disable_msi(struct tegra_pcie *pcie);
2524
2525 static int tegra_pcie_init(struct tegra_pcie *pcie)
2526 {
2527         int err = 0;
2528         struct platform_device *pdev = to_platform_device(pcie->dev);
2529
2530         pcibios_min_io = 0x1000ul;
2531
2532         PR_FUNC_LINE;
2533         INIT_WORK(&pcie->hotplug_detect, work_hotplug_handler);
2534         err = tegra_pcie_get_resources(pcie);
2535         if (err) {
2536                 dev_err(pcie->dev, "PCIE: get resources failed\n");
2537                 return err;
2538         }
2539         err = tegra_pcie_enable_pads(pcie, true);
2540         if (err) {
2541                 dev_err(pcie->dev, "PCIE: enable pads failed\n");
2542                 goto fail_release_resource;
2543         }
2544
2545         tegra_periph_reset_deassert(pcie->pcie_afi);
2546
2547         tegra_pcie_enable_controller(pcie);
2548         err = tegra_pcie_conf_gpios(pcie);
2549         if (err) {
2550                 dev_err(pcie->dev, "PCIE: configuring gpios failed\n");
2551                 goto fail_release_resource;
2552         }
2553         /* setup the AFI address translations */
2554         tegra_pcie_setup_translations(pcie);
2555
2556         if (IS_ENABLED(CONFIG_PCI_MSI)) {
2557                 err = tegra_pcie_enable_msi(pcie, false);
2558                 if (err < 0) {
2559                         dev_err(&pdev->dev,
2560                                 "failed to enable MSI support: %d\n",
2561                                 err);
2562                         goto fail_release_resource;
2563                 }
2564         }
2565
2566         tegra_periph_reset_deassert(pcie->pcie_pcie);
2567
2568         tegra_pcie_check_ports(pcie);
2569
2570         if (pcie->num_ports) {
2571                 tegra_pcie_hw.private_data = (void **)&pcie;
2572                 tegra_pcie_hw.ops = &tegra_pcie_ops;
2573                 tegra_pcie_hw.sys = &pcie->sys;
2574                 pci_common_init_dev(pcie->dev, &tegra_pcie_hw);
2575         } else {
2576                 dev_info(pcie->dev, "PCIE: no ports detected\n");
2577                 goto fail_enum;
2578         }
2579         tegra_pcie_enable_features(pcie);
2580         /* register pcie device as wakeup source */
2581         device_init_wakeup(pcie->dev, true);
2582
2583         return 0;
2584
2585 fail_enum:
2586         if (IS_ENABLED(CONFIG_PCI_MSI))
2587                 tegra_pcie_disable_msi(pcie);
2588 fail_release_resource:
2589         tegra_pcie_power_off(pcie, true);
2590         tegra_pcie_disable_regulators(pcie);
2591         tegra_pcie_clocks_put(pcie);
2592
2593         return err;
2594 }
2595
2596 /* 1:1 matching of these to the MSI vectors, 1 per bit */
2597 /* and each mapping matches one of the available interrupts */
2598 struct msi_map_entry {
2599         bool used;
2600         u8 index;
2601         int irq;
2602 };
2603
2604 /* hardware supports 256 max*/
2605 #if (INT_PCI_MSI_NR > 256)
2606 #error "INT_PCI_MSI_NR too big"
2607 #endif
2608
2609 static int tegra_msi_alloc(struct tegra_msi *chip)
2610 {
2611         int msi;
2612
2613         PR_FUNC_LINE;
2614
2615         mutex_lock(&chip->lock);
2616
2617         msi = find_first_zero_bit(chip->used, INT_PCI_MSI_NR);
2618         if (msi < INT_PCI_MSI_NR)
2619                 set_bit(msi, chip->used);
2620         else
2621                 msi = -ENOSPC;
2622
2623         mutex_unlock(&chip->lock);
2624
2625         return msi;
2626 }
2627
2628 static void tegra_msi_free(struct tegra_msi *chip, unsigned long irq)
2629 {
2630         struct device *dev = chip->chip.dev;
2631
2632         PR_FUNC_LINE;
2633
2634         mutex_lock(&chip->lock);
2635
2636         if (!test_bit(irq, chip->used))
2637                 dev_err(dev, "trying to free unused MSI#%lu\n", irq);
2638         else
2639                 clear_bit(irq, chip->used);
2640
2641         mutex_unlock(&chip->lock);
2642 }
2643
2644
2645 static irqreturn_t tegra_pcie_msi_irq(int irq, void *data)
2646 {
2647         struct tegra_pcie *pcie = data;
2648         struct tegra_msi *msi = &pcie->msi;
2649         unsigned int i, processed = 0;
2650
2651         PR_FUNC_LINE;
2652
2653         for (i = 0; i < 8; i++) {
2654                 unsigned long reg = afi_readl(pcie, AFI_MSI_VEC0_0 + i * 4);
2655
2656                 while (reg) {
2657                         unsigned int offset = find_first_bit(&reg, 32);
2658                         unsigned int index = i * 32 + offset;
2659                         unsigned int irq;
2660
2661                         /* clear the interrupt */
2662                         afi_writel(pcie, 1 << offset, AFI_MSI_VEC0_0 + i * 4);
2663
2664                         irq = irq_find_mapping(msi->domain, index);
2665                         if (irq) {
2666                                 if (test_bit(index, msi->used))
2667                                         generic_handle_irq(irq);
2668                                 else
2669                                         dev_info(pcie->dev, "unhandled MSI\n");
2670                         } else {
2671                                 /*
2672                                  * that's weird who triggered this?
2673                                  * just clear it
2674                                  */
2675                                 dev_info(pcie->dev, "unexpected MSI\n");
2676                         }
2677
2678                         /* see if there's any more pending in this vector */
2679                         reg = afi_readl(pcie, AFI_MSI_VEC0_0 + i * 4);
2680
2681                         processed++;
2682                 }
2683         }
2684
2685         return processed > 0 ? IRQ_HANDLED : IRQ_NONE;
2686 }
2687
2688 static int tegra_msi_setup_irq(struct msi_chip *chip, struct pci_dev *pdev,
2689                                struct msi_desc *desc)
2690 {
2691         struct tegra_msi *msi = to_tegra_msi(chip);
2692         struct msi_msg msg;
2693         unsigned int irq;
2694         int hwirq;
2695
2696         PR_FUNC_LINE;
2697
2698         hwirq = tegra_msi_alloc(msi);
2699         if (hwirq < 0)
2700                 return hwirq;
2701
2702         irq = irq_create_mapping(msi->domain, hwirq);
2703         if (!irq)
2704                 return -EINVAL;
2705
2706         irq_set_msi_desc(irq, desc);
2707
2708         msg.address_lo = virt_to_phys((void *)msi->pages) & 0xFFFFFFFF;
2709 #ifdef CONFIG_ARM64
2710         msg.address_hi = virt_to_phys((void *)msi->pages) >> 32;
2711 #else
2712         msg.address_hi = 0;
2713 #endif
2714         msg.data = hwirq;
2715
2716         write_msi_msg(irq, &msg);
2717
2718         return 0;
2719 }
2720
2721 static void tegra_msi_teardown_irq(struct msi_chip *chip, unsigned int irq)
2722 {
2723         struct tegra_msi *msi = to_tegra_msi(chip);
2724         struct irq_data *d = irq_get_irq_data(irq);
2725
2726         PR_FUNC_LINE;
2727         tegra_msi_free(msi, d->hwirq);
2728 }
2729
2730 static struct irq_chip tegra_msi_irq_chip = {
2731         .name = "Tegra PCIe MSI",
2732         .irq_enable = unmask_msi_irq,
2733         .irq_disable = mask_msi_irq,
2734         .irq_mask = mask_msi_irq,
2735         .irq_unmask = unmask_msi_irq,
2736 };
2737
2738 static int tegra_msi_map(struct irq_domain *domain, unsigned int irq,
2739                          irq_hw_number_t hwirq)
2740 {
2741         PR_FUNC_LINE;
2742         irq_set_chip_and_handler(irq, &tegra_msi_irq_chip, handle_simple_irq);
2743         irq_set_chip_data(irq, domain->host_data);
2744         set_irq_flags(irq, IRQF_VALID);
2745         return 0;
2746 }
2747
2748 static const struct irq_domain_ops msi_domain_ops = {
2749         .map = tegra_msi_map,
2750 };
2751
2752 static int tegra_pcie_enable_msi(struct tegra_pcie *pcie, bool no_init)
2753 {
2754         struct platform_device *pdev = to_platform_device(pcie->dev);
2755         struct tegra_msi *msi = &pcie->msi;
2756         unsigned long base;
2757         int err;
2758         u32 reg;
2759
2760         PR_FUNC_LINE;
2761
2762         if (!msi->pages) {
2763                 if (no_init)
2764                         return true;
2765
2766                 mutex_init(&msi->lock);
2767
2768                 msi->chip.dev = pcie->dev;
2769                 msi->chip.setup_irq = tegra_msi_setup_irq;
2770                 msi->chip.teardown_irq = tegra_msi_teardown_irq;
2771
2772                 msi->domain = irq_domain_add_linear(pcie->dev->of_node,
2773                         INT_PCI_MSI_NR, &msi_domain_ops, &msi->chip);
2774                 if (!msi->domain) {
2775                         dev_err(&pdev->dev, "failed to create IRQ domain\n");
2776                         return -ENOMEM;
2777                 }
2778
2779                 err = platform_get_irq_byname(pdev, "msi");
2780                 if (err < 0) {
2781                         dev_err(&pdev->dev, "failed to get IRQ: %d\n", err);
2782                         goto err;
2783                 }
2784
2785                 msi->irq = err;
2786                 err = request_irq(msi->irq, tegra_pcie_msi_irq, 0,
2787                                   tegra_msi_irq_chip.name, pcie);
2788                 if (err < 0) {
2789                         dev_err(&pdev->dev, "failed to request IRQ: %d\n", err);
2790                         goto err;
2791                 }
2792
2793                 /* setup AFI/FPCI range */
2794                 msi->pages = __get_free_pages(GFP_DMA32, 0);
2795         }
2796         base = virt_to_phys((void *)msi->pages);
2797
2798         afi_writel(pcie, base >> 8, AFI_MSI_FPCI_BAR_ST);
2799         afi_writel(pcie, base, AFI_MSI_AXI_BAR_ST);
2800         /* this register is in 4K increments */
2801         afi_writel(pcie, 1, AFI_MSI_BAR_SZ);
2802
2803         /* enable all MSI vectors */
2804         afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC0_0);
2805         afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC1_0);
2806         afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC2_0);
2807         afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC3_0);
2808         afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC4_0);
2809         afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC5_0);
2810         afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC6_0);
2811         afi_writel(pcie, 0xffffffff, AFI_MSI_EN_VEC7_0);
2812
2813         /* and unmask the MSI interrupt */
2814         reg = afi_readl(pcie, AFI_INTR_MASK);
2815         reg |= AFI_INTR_MASK_MSI_MASK;
2816         afi_writel(pcie, reg, AFI_INTR_MASK);
2817
2818         return 0;
2819
2820 err:
2821         irq_domain_remove(msi->domain);
2822         return err;
2823 }
2824
2825 static int tegra_pcie_disable_msi(struct tegra_pcie *pcie)
2826 {
2827         struct tegra_msi *msi = &pcie->msi;
2828         unsigned int i, irq;
2829         u32 value;
2830
2831         PR_FUNC_LINE;
2832
2833         if (pcie->pcie_power_enabled == 0)
2834                 return 0;
2835
2836         /* mask the MSI interrupt */
2837         value = afi_readl(pcie, AFI_INTR_MASK);
2838         value &= ~AFI_INTR_MASK_MSI_MASK;
2839         afi_writel(pcie, value, AFI_INTR_MASK);
2840
2841         /* disable all MSI vectors */
2842         afi_writel(pcie, 0, AFI_MSI_EN_VEC0_0);
2843         afi_writel(pcie, 0, AFI_MSI_EN_VEC1_0);
2844         afi_writel(pcie, 0, AFI_MSI_EN_VEC2_0);
2845         afi_writel(pcie, 0, AFI_MSI_EN_VEC3_0);
2846         afi_writel(pcie, 0, AFI_MSI_EN_VEC4_0);
2847         afi_writel(pcie, 0, AFI_MSI_EN_VEC5_0);
2848         afi_writel(pcie, 0, AFI_MSI_EN_VEC6_0);
2849         afi_writel(pcie, 0, AFI_MSI_EN_VEC7_0);
2850
2851         free_pages(msi->pages, 0);
2852
2853         if (msi->irq > 0)
2854                 free_irq(msi->irq, pcie);
2855
2856         for (i = 0; i < INT_PCI_MSI_NR; i++) {
2857                 irq = irq_find_mapping(msi->domain, i);
2858                 if (irq > 0)
2859                         irq_dispose_mapping(irq);
2860         }
2861
2862         irq_domain_remove(msi->domain);
2863
2864         return 0;
2865 }
2866
2867 static void tegra_pcie_read_plat_data(struct tegra_pcie *pcie)
2868 {
2869         struct device_node *node = pcie->dev->of_node;
2870
2871         PR_FUNC_LINE;
2872         of_property_read_u32(node, "nvidia,boot-detect-delay",
2873                         &pcie->plat_data->boot_detect_delay);
2874         pcie->plat_data->gpio_hot_plug =
2875                 of_get_named_gpio(node, "nvidia,hot-plug-gpio", 0);
2876         pcie->plat_data->gpio_wake =
2877                 of_get_named_gpio(node, "nvidia,wake-gpio", 0);
2878         pcie->plat_data->gpio_x1_slot =
2879                 of_get_named_gpio(node, "nvidia,x1-slot-gpio", 0);
2880         pcie->plat_data->has_memtype_lpddr4 =
2881                 of_property_read_bool(node, "nvidia,has_memtype_lpddr4");
2882         if (of_property_read_u32(node, "nvidia,lane-map",
2883                         &pcie->plat_data->lane_map)) {
2884                 dev_info(pcie->dev,
2885                         "PCIE lane map attribute missing, use x4_x1 as default\n");
2886                 pcie->plat_data->lane_map = PCIE_LANES_X4_X1;
2887         }
2888 }
2889
2890 static char *t124_rail_names[] = {"hvdd-pex", "hvdd-pex-pll-e", "dvddio-pex",
2891                                 "avddio-pex", "avdd-pex-pll", "vddio-pex-ctl"};
2892
2893 static char *t210_rail_names[] = {"dvdd-pex-pll", "hvdd-pex-pll-e",
2894                                         "l0-hvddio-pex", "l0-dvddio-pex",
2895                                         "l1-hvddio-pex", "l1-dvddio-pex",
2896                                         "l2-hvddio-pex", "l2-dvddio-pex",
2897                                         "l3-hvddio-pex", "l3-dvddio-pex",
2898                                         "l4-hvddio-pex", "l4-dvddio-pex",
2899                                         "l5-hvddio-pex", "l5-dvddio-pex",
2900                                         "l6-hvddio-pex", "l6-dvddio-pex",
2901                                         "vddio-pex-ctl"};
2902
2903 static const struct tegra_pcie_soc_data tegra210_pcie_data = {
2904         .num_ports = 2,
2905         .pcie_regulator_names = t210_rail_names,
2906         .num_pcie_regulators =
2907                         sizeof(t210_rail_names) / sizeof(t210_rail_names[0]),
2908 };
2909
2910 static const struct tegra_pcie_soc_data tegra124_pcie_data = {
2911         .num_ports = 2,
2912         .pcie_regulator_names = t124_rail_names,
2913         .num_pcie_regulators =
2914                         sizeof(t124_rail_names) / sizeof(t124_rail_names[0]),
2915 };
2916
2917 static struct of_device_id tegra_pcie_of_match[] = {
2918         { .compatible = "nvidia,tegra210-pcie", .data = &tegra210_pcie_data },
2919         { .compatible = "nvidia,tegra124-pcie", .data = &tegra124_pcie_data },
2920         { }
2921 };
2922 MODULE_DEVICE_TABLE(of, tegra_pcie_of_match);
2923
2924 static int tegra_pcie_parse_dt(struct tegra_pcie *pcie)
2925 {
2926         struct tegra_pcie_soc_data *soc = pcie->soc_data;
2927         struct device_node *np = pcie->dev->of_node, *port;
2928         struct of_pci_range_parser parser;
2929         struct of_pci_range range;
2930         u32 lanes = 0, mask = 0;
2931         unsigned int lane = 0;
2932         struct resource res;
2933         int err;
2934
2935         PR_FUNC_LINE;
2936
2937         if (of_pci_range_parser_init(&parser, np)) {
2938                 dev_err(pcie->dev, "missing \"ranges\" property\n");
2939                 return -EINVAL;
2940         }
2941
2942         for_each_of_pci_range(&parser, &range) {
2943                 of_pci_range_to_resource(&range, np, &res);
2944                 switch (res.flags & IORESOURCE_TYPE_BITS) {
2945                 case IORESOURCE_IO:
2946                         memcpy(&pcie->io, &res, sizeof(res));
2947                         pcie->io.name = np->full_name;
2948                         break;
2949
2950                 case IORESOURCE_MEM:
2951                         if (res.flags & IORESOURCE_PREFETCH) {
2952                                 memcpy(&pcie->prefetch, &res, sizeof(res));
2953                                 pcie->prefetch.name = "pcie-prefetchable";
2954                         } else {
2955                                 memcpy(&pcie->mem, &res, sizeof(res));
2956                                 pcie->mem.name = "pcie-non-prefetchable";
2957                         }
2958                         break;
2959                 }
2960         }
2961
2962         err = of_pci_parse_bus_range(np, &pcie->busn);
2963         if (err < 0) {
2964                 dev_err(pcie->dev, "failed to parse ranges property: %d\n",
2965                         err);
2966                 pcie->busn.name = np->name;
2967                 pcie->busn.start = 0;
2968                 pcie->busn.end = 0xff;
2969                 pcie->busn.flags = IORESOURCE_BUS;
2970         }
2971
2972         /* parse root ports */
2973         for_each_child_of_node(np, port) {
2974                 struct tegra_pcie_port *rp;
2975                 unsigned int index;
2976                 u32 value;
2977
2978                 if (strncmp(port->type, "pci", sizeof("pci")))
2979                         continue;
2980
2981                 err = of_pci_get_devfn(port);
2982                 if (err < 0) {
2983                         dev_err(pcie->dev, "failed to parse address: %d\n",
2984                                 err);
2985                         return err;
2986                 }
2987
2988                 index = PCI_SLOT(err);
2989                 if (index < 1 || index > soc->num_ports) {
2990                         dev_err(pcie->dev, "invalid port number: %d\n", index);
2991                         return -EINVAL;
2992                 }
2993
2994                 index--;
2995
2996                 err = of_property_read_u32(port, "nvidia,num-lanes", &value);
2997                 if (err < 0) {
2998                         dev_err(pcie->dev, "failed to parse # of lanes: %d\n",
2999                                 err);
3000                         return err;
3001                 }
3002
3003                 if (value > 16) {
3004                         dev_err(pcie->dev, "invalid # of lanes: %u\n", value);
3005                         return -EINVAL;
3006                 }
3007                 lanes |= value << (index << 3);
3008
3009                 if (!of_device_is_available(port)) {
3010                         lane += value;
3011                         continue;
3012                 }
3013
3014                 mask |= ((1 << value) - 1) << lane;
3015                 lane += value;
3016
3017                 rp = devm_kzalloc(pcie->dev, sizeof(*rp), GFP_KERNEL);
3018                 if (!rp)
3019                         return -ENOMEM;
3020
3021                 err = of_address_to_resource(port, 0, &rp->regs);
3022                 if (err < 0) {
3023                         dev_err(pcie->dev, "failed to parse address: %d\n",
3024                                 err);
3025                         return err;
3026                 }
3027
3028                 rp->gpio_presence_detection =
3029                         of_get_named_gpio(port,
3030                                 "nvidia,presence-detection-gpio", 0);
3031
3032                 INIT_LIST_HEAD(&rp->list);
3033                 rp->index = index;
3034                 rp->lanes = value;
3035                 rp->pcie = pcie;
3036                 rp->base = devm_ioremap_resource(pcie->dev, &rp->regs);
3037                 if (!(rp->base))
3038                         return -EADDRNOTAVAIL;
3039                 rp->disable_clock_request = of_property_read_bool(port,
3040                         "nvidia,disable-clock-request");
3041
3042                 list_add_tail(&rp->list, &pcie->ports);
3043         }
3044
3045         return 0;
3046 }
3047
3048 static int list_devices(struct seq_file *s, void *data)
3049 {
3050         struct pci_dev *pdev = NULL;
3051         u16 vendor, device, devclass, speed;
3052         bool pass = false;
3053         int ret = 0;
3054
3055         for_each_pci_dev(pdev) {
3056                 pass = true;
3057                 ret = pci_read_config_word(pdev, PCI_VENDOR_ID, &vendor);
3058                 if (ret) {
3059                         pass = false;
3060                         break;
3061                 }
3062                 ret = pci_read_config_word(pdev, PCI_DEVICE_ID, &device);
3063                 if (ret) {
3064                         pass = false;
3065                         break;
3066                 }
3067                 ret = pci_read_config_word(pdev, PCI_CLASS_DEVICE, &devclass);
3068                 if (ret) {
3069                         pass = false;
3070                         break;
3071                 }
3072                 pcie_capability_read_word(pdev, PCI_EXP_LNKSTA, &speed);
3073
3074                 seq_printf(s, "%s  Vendor:%04x  Device id:%04x  ",
3075                                 kobject_name(&pdev->dev.kobj), vendor,
3076                                 device);
3077                 seq_printf(s, "Class:%04x  Speed:%s  Driver:%s(%s)\n", devclass,
3078                         ((speed & PCI_EXP_LNKSTA_CLS_5_0GB) ==
3079                                 PCI_EXP_LNKSTA_CLS_5_0GB) ?
3080                         "Gen2" : "Gen1",
3081                         (pdev->driver) ? "enabled" : "disabled",
3082                         (pdev->driver) ? pdev->driver->name : NULL);
3083         }
3084         if (!pass)
3085                 seq_printf(s, "Couldn't read devices\n");
3086
3087         return ret;
3088 }
3089
3090 static int apply_link_speed(struct seq_file *s, void *data)
3091 {
3092         bool pass = false;
3093         struct tegra_pcie *pcie = (struct tegra_pcie *)(s->private);
3094
3095         seq_printf(s, "Changing link speed to %s... ",
3096                 (is_gen2_speed) ? "Gen2" : "Gen1");
3097         pass = tegra_pcie_link_speed(pcie, is_gen2_speed);
3098
3099         if (pass)
3100                 seq_printf(s, "Done\n");
3101         else
3102                 seq_printf(s, "Failed\n");
3103         return 0;
3104 }
3105
3106 static int check_d3hot(struct seq_file *s, void *data)
3107 {
3108         u16 val;
3109         struct pci_dev *pdev = NULL;
3110
3111         /* Force all the devices (including RPs) in d3 hot state */
3112         for_each_pci_dev(pdev) {
3113                 if (pci_pcie_type(pdev) == PCI_EXP_TYPE_ROOT_PORT ||
3114                         pci_pcie_type(pdev) == PCI_EXP_TYPE_DOWNSTREAM)
3115                                 continue;
3116                 /* First, keep Downstream component in D3_Hot */
3117                 pci_read_config_word(pdev, pdev->pm_cap + PCI_PM_CTRL,
3118                         &val);
3119                 if ((val & PCI_PM_CTRL_STATE_MASK) == PCI_D3hot)
3120                         seq_printf(s, "device[%x:%x] is already in D3_hot]\n",
3121                                 pdev->vendor, pdev->device);
3122                 val &= ~PCI_PM_CTRL_STATE_MASK;
3123                 val |= PCI_D3hot;
3124                 pci_write_config_word(pdev, pdev->pm_cap + PCI_PM_CTRL,
3125                         val);
3126                 /* Keep corresponding upstream component in D3_Hot */
3127                 pci_read_config_word(pdev->bus->self,
3128                         pdev->bus->self->pm_cap + PCI_PM_CTRL, &val);
3129                 val &= ~PCI_PM_CTRL_STATE_MASK;
3130                 val |= PCI_D3hot;
3131                 pci_write_config_word(pdev->bus->self,
3132                         pdev->bus->self->pm_cap + PCI_PM_CTRL, val);
3133                 mdelay(100);
3134                 /* check if they have changed their state */
3135                 pci_read_config_word(pdev, pdev->pm_cap + PCI_PM_CTRL,
3136                         &val);
3137                 if ((val & PCI_PM_CTRL_STATE_MASK) == PCI_D3hot)
3138                         seq_printf(s, "device[%x:%x] transitioned to D3_hot]\n",
3139                                 pdev->vendor, pdev->device);
3140                 else
3141                         seq_printf(s, "device[%x:%x] couldn't transition]\n",
3142                                 pdev->vendor, pdev->device);
3143                 pci_read_config_word(pdev->bus->self,
3144                         pdev->bus->self->pm_cap + PCI_PM_CTRL, &val);
3145                 if ((val & PCI_PM_CTRL_STATE_MASK) == PCI_D3hot)
3146                         seq_printf(s, "device[%x:%x] transitioned to D3_hot]\n",
3147                                 pdev->bus->self->vendor,
3148                                 pdev->bus->self->device);
3149                 else
3150                         seq_printf(s, "device[%x:%x] couldn't transition]\n",
3151                                 pdev->bus->self->vendor,
3152                                 pdev->bus->self->device);
3153         }
3154
3155         return 0;
3156 }
3157
3158 static int dump_config_space(struct seq_file *s, void *data)
3159 {
3160         u8 val;
3161         int row, col;
3162         struct pci_dev *pdev = NULL;
3163
3164         for_each_pci_dev(pdev) {
3165                 int row_cnt = pci_is_pcie(pdev) ?
3166                         PCI_EXT_CFG_SPACE_SIZE : PCI_CFG_SPACE_SIZE;
3167                 seq_printf(s, "%s\n", kobject_name(&pdev->dev.kobj));
3168                 seq_printf(s, "%s\n", "------------");
3169
3170                 for (row = 0; row < (row_cnt / 16); row++) {
3171                         seq_printf(s, "%02x: ", (row * 16));
3172                         for (col = 0; col < 16; col++) {
3173                                 pci_read_config_byte(pdev, ((row * 16) + col),
3174                                         &val);
3175                                 seq_printf(s, "%02x ", val);
3176                         }
3177                         seq_printf(s, "\n");
3178                 }
3179         }
3180         return 0;
3181 }
3182
3183 static int dump_afi_space(struct seq_file *s, void *data)
3184 {
3185         u32 val, offset;
3186         struct tegra_pcie_port *port = NULL;
3187         struct tegra_pcie *pcie = (struct tegra_pcie *)(s->private);
3188
3189         list_for_each_entry(port, &pcie->ports, list) {
3190                 seq_puts(s, "Offset:  Values\n");
3191                 for (offset = 0; offset < 0x200; offset += 0x10) {
3192                         val = afi_readl(port->pcie, offset);
3193                         seq_printf(s, "%6x: %8x %8x %8x %8x\n", offset,
3194                                 afi_readl(port->pcie, offset),
3195                                 afi_readl(port->pcie, offset + 4),
3196                                 afi_readl(port->pcie, offset + 8),
3197                                 afi_readl(port->pcie, offset + 12));
3198                 }
3199         }
3200         return 0;
3201 }
3202
3203 static int config_read(struct seq_file *s, void *data)
3204 {
3205         u32 val;
3206         struct pci_dev *pdev = NULL;
3207
3208         pdev = pci_get_bus_and_slot((bdf >> 8), (bdf & 0xFF));
3209         if (!pdev) {
3210                 seq_printf(s, "%02d:%02d.%02d : Doesn't exist\n",
3211                         (bdf >> 8), PCI_SLOT(bdf), PCI_FUNC(bdf));
3212                 seq_printf(s,
3213                         "Enter (bus<<8 | dev<<3 | func) value to bdf file\n");
3214                 goto end;
3215         }
3216         if (config_offset >= PCI_EXT_CFG_SPACE_SIZE) {
3217                 seq_printf(s, "Config offset exceeds max (i.e %d) value\n",
3218                         PCI_EXT_CFG_SPACE_SIZE);
3219         }
3220         if (!(config_offset & 0x3)) {
3221                 /* read 32 */
3222                 pci_read_config_dword(pdev, config_offset, &val);
3223                 seq_printf(s, "%08x\n", val);
3224                 config_val = val;
3225         } else if (!(config_offset & 0x1)) {
3226                 /* read 16 */
3227                 pci_read_config_word(pdev, config_offset, (u16 *)&val);
3228                 seq_printf(s, "%04x\n", (u16)(val & 0xFFFF));
3229                 config_val = val & 0xFFFF;
3230         } else {
3231                 /* read 8 */
3232                 pci_read_config_byte(pdev, config_offset, (u8 *)&val);
3233                 seq_printf(s, "%02x\n", (u8)(val & 0xFF));
3234                 config_val = val & 0xFF;
3235         }
3236
3237 end:
3238         return 0;
3239 }
3240
3241 static int config_write(struct seq_file *s, void *data)
3242 {
3243         struct pci_dev *pdev = NULL;
3244
3245         pdev = pci_get_bus_and_slot((bdf >> 8), (bdf & 0xFF));
3246         if (!pdev) {
3247                 seq_printf(s, "%02d:%02d.%02d : Doesn't exist\n",
3248                         (bdf >> 8), PCI_SLOT(bdf), PCI_FUNC(bdf));
3249                 seq_printf(s,
3250                         "Enter (bus<<8 | dev<<3 | func) value to bdf file\n");
3251                 goto end;
3252         }
3253         if (config_offset >= PCI_EXT_CFG_SPACE_SIZE) {
3254                 seq_printf(s, "Config offset exceeds max (i.e %d) value\n",
3255                         PCI_EXT_CFG_SPACE_SIZE);
3256         }
3257         if (!(config_offset & 0x3)) {
3258                 /* write 32 */
3259                 pci_write_config_dword(pdev, config_offset, config_val);
3260         } else if (!(config_offset & 0x1)) {
3261                 /* write 16 */
3262                 pci_write_config_word(pdev, config_offset,
3263                         (u16)(config_val & 0xFFFF));
3264         } else {
3265                 /* write 8 */
3266                 pci_write_config_byte(pdev, config_offset,
3267                         (u8)(config_val & 0xFF));
3268         }
3269
3270 end:
3271         return 0;
3272 }
3273
3274 static int power_down(struct seq_file *s, void *data)
3275 {
3276         struct tegra_pcie_port *port = NULL;
3277         struct tegra_pcie *pcie = (struct tegra_pcie *)(s->private);
3278         u32 val;
3279         bool pass = false;
3280
3281         val = afi_readl(pcie, AFI_PCIE_PME);
3282         val |= AFI_PCIE_PME_TURN_OFF;
3283         afi_writel(pcie, val, AFI_PCIE_PME);
3284         do {
3285                 val = afi_readl(pcie, AFI_PCIE_PME);
3286         } while(!(val & AFI_PCIE_PME_ACK));
3287
3288         mdelay(1000);
3289         list_for_each_entry(port, &pcie->ports, list) {
3290                 val = rp_readl(port, NV_PCIE2_RP_LTSSM_DBGREG);
3291                 if (val & PCIE2_RP_LTSSM_DBGREG_LINKFSM16) {
3292                         pass = true;
3293                         goto out;
3294                 }
3295         }
3296
3297 out:
3298         if (pass)
3299                 seq_printf(s, "[pass: pcie_power_down]\n");
3300         else
3301                 seq_printf(s, "[fail: pcie_power_down]\n");
3302         pr_info("PCIE power_down test END..\n");
3303         return 0;
3304 }
3305
3306 static int apply_lane_width(struct seq_file *s, void *data)
3307 {
3308         unsigned int new;
3309         struct tegra_pcie_port *port = (struct tegra_pcie_port *)(s->private);
3310
3311         if (port->lanes > 0x10) {
3312                 seq_printf(s, "link width cannot be grater than 16\n");
3313                 new = rp_readl(port, RP_LINK_CONTROL_STATUS);
3314                 port->lanes = (new &
3315                         RP_LINK_CONTROL_STATUS_NEG_LINK_WIDTH) >> 20;
3316                 return 0;
3317         }
3318         new = rp_readl(port, NV_PCIE2_RP_VEND_XP1);
3319         new &= ~NV_PCIE2_RP_VEND_XP1_RNCTRL_MAXWIDTH_MASK;
3320         new |= port->lanes | NV_PCIE2_RP_VEND_XP1_RNCTRL_EN;
3321         rp_writel(port, new, NV_PCIE2_RP_VEND_XP1);
3322         mdelay(1);
3323
3324         new = rp_readl(port, RP_LINK_CONTROL_STATUS);
3325         new = (new & RP_LINK_CONTROL_STATUS_NEG_LINK_WIDTH) >> 20;
3326         if (new != port->lanes)
3327                 seq_printf(s, "can't set link width %u, falling back to %u\n",
3328                         port->lanes, new);
3329         else
3330                 seq_printf(s, "lane width %d applied\n", new);
3331         port->lanes = new;
3332         return 0;
3333 }
3334
3335 static int aspm_state_cnt(struct seq_file *s, void *data)
3336 {
3337         u32 val, cs;
3338         struct tegra_pcie_port *port = (struct tegra_pcie_port *)(s->private);
3339
3340         cs = rp_readl(port, RP_LINK_CONTROL_STATUS);
3341         /* check if L0s is enabled on this port */
3342         if (cs & RP_LINK_CONTROL_STATUS_L0s_ENABLED) {
3343                 val = rp_readl(port, NV_PCIE2_RP_PRIV_XP_TX_L0S_ENTRY_COUNT);
3344                 seq_printf(s, "Tx L0s entry count : %u\n", val);
3345         } else
3346                 seq_printf(s, "Tx L0s entry count : %s\n", "disabled");
3347
3348         val = rp_readl(port, NV_PCIE2_RP_PRIV_XP_RX_L0S_ENTRY_COUNT);
3349         seq_printf(s, "Rx L0s entry count : %u\n", val);
3350
3351         /* check if L1 is enabled on this port */
3352         if (cs & RP_LINK_CONTROL_STATUS_L1_ENABLED) {
3353                 val = rp_readl(port, NV_PCIE2_RP_PRIV_XP_TX_L1_ENTRY_COUNT);
3354                 seq_printf(s, "Link L1 entry count : %u\n", val);
3355         } else
3356                 seq_printf(s, "Link L1 entry count : %s\n", "disabled");
3357
3358 #if defined(CONFIG_ARCH_TEGRA_21x_SOC)
3359         cs = rp_readl(port, PCIE2_RP_L1_PM_SS_CONTROL);
3360         /* RESETting the count value is not possible by any means
3361                 because of HW Bug : 200034278 */
3362         /*      check if L1.1 is enabled */
3363         if (cs & PCIE2_RP_L1_PM_SS_CONTROL_ASPM_L11_ENABLE) {
3364                 val = rp_readl(port, NV_PCIE2_RP_L1_1_ENTRY_COUNT);
3365                 seq_printf(s, "Link L1.1 entry count : %u\n", (val & 0xFFFF));
3366         } else
3367                 seq_printf(s, "Link L1.1 entry count : %s\n", "disabled");
3368         /*      check if L1.2 is enabled */
3369         if (cs & PCIE2_RP_L1_PM_SS_CONTROL_ASPM_L12_ENABLE) {
3370                 val = rp_readl(port, NV_PCIE2_RP_L1_2_ENTRY_COUNT);
3371                 seq_printf(s, "Link L1.2 entry count : %u\n", (val & 0xFFFF));
3372         } else
3373                 seq_printf(s, "Link L1.2 entry count : %s\n", "disabled");
3374 #endif
3375         return 0;
3376 }
3377
3378 static char *aspm_states[] = {
3379         "Tx-L0s",
3380         "Rx-L0s",
3381         "L1",
3382         "IDLE ((Tx-L0s && Rx-L0s) + L1)"
3383 };
3384
3385 static int list_aspm_states(struct seq_file *s, void *data)
3386 {
3387         u32 i = 0;
3388         seq_printf(s, "----------------------------------------------------\n");
3389         seq_printf(s, "Note: Duration of link's residency is calcualated\n");
3390         seq_printf(s, "      only for one of the ASPM states at a time\n");
3391         seq_printf(s, "----------------------------------------------------\n");
3392         seq_printf(s, "write(echo) number from below table corresponding to\n");
3393         seq_printf(s, "one of the ASPM states for which link duration needs\n");
3394         seq_printf(s, "to be calculated to 'config_aspm_state'\n");
3395         seq_printf(s, "-----------------\n");
3396         for (i = 0; i < ARRAY_SIZE(aspm_states); i++)
3397                 seq_printf(s, "%d : %s\n", i, aspm_states[i]);
3398         seq_printf(s, "-----------------\n");
3399         return 0;
3400 }
3401
3402 static int apply_aspm_state(struct seq_file *s, void *data)
3403 {
3404         u32 val;
3405         struct tegra_pcie_port *port = (struct tegra_pcie_port *)(s->private);
3406
3407         if (config_aspm_state > ARRAY_SIZE(aspm_states)) {
3408                 seq_printf(s, "Invalid ASPM state : %u\n", config_aspm_state);
3409                 list_aspm_states(s, data);
3410         } else {
3411                 val = rp_readl(port, NV_PCIE2_RP_PRIV_XP_CONFIG);
3412                 val &= ~NV_PCIE2_RP_PRIV_XP_CONFIG_LOW_PWR_DURATION_MASK;
3413                 val |= config_aspm_state;
3414                 rp_writel(port, val, NV_PCIE2_RP_PRIV_XP_CONFIG);
3415                 seq_printf(s, "Configured for ASPM-%s state...\n",
3416                         aspm_states[config_aspm_state]);
3417         }
3418         return 0;
3419 }
3420
3421 static int get_aspm_duration(struct seq_file *s, void *data)
3422 {
3423         u32 val;
3424         struct tegra_pcie_port *port = (struct tegra_pcie_port *)(s->private);
3425
3426         val = rp_readl(port, NV_PCIE2_RP_PRIV_XP_DURATION_IN_LOW_PWR_100NS);
3427         /* 52.08 = 1000 / 19.2MHz is rounded to 52      */
3428         seq_printf(s, "ASPM-%s duration = %d ns\n",
3429                 aspm_states[config_aspm_state], (u32)((val * 100)/52));
3430         return 0;
3431 }
3432
3433 static int secondary_bus_reset(struct seq_file *s, void *data)
3434 {
3435         u32 val;
3436         struct tegra_pcie_port *port = (struct tegra_pcie_port *)(s->private);
3437
3438         val = rp_readl(port, NV_PCIE2_RP_INTR_BCR);
3439         val |= NV_PCIE2_RP_INTR_BCR_SB_RESET;
3440         rp_writel(port, val, NV_PCIE2_RP_INTR_BCR);
3441         udelay(10);
3442         val = rp_readl(port, NV_PCIE2_RP_INTR_BCR);
3443         val &= ~NV_PCIE2_RP_INTR_BCR_SB_RESET;
3444         rp_writel(port, val, NV_PCIE2_RP_INTR_BCR);
3445
3446         seq_printf(s, "Secondary Bus Reset applied successfully...\n");
3447         return 0;
3448 }
3449
3450 static void reset_l1ss_counter(struct tegra_pcie_port *port, u32 val,
3451                         unsigned long offset)
3452 {
3453         int c = 0;
3454
3455         if ((val & 0xFFFF) == 0xFFFF) {
3456                 pr_info(" Trying reset L1ss entry count to 0\n");
3457                 while (val) {
3458                         if (c++ > 50) {
3459                                 pr_info("Timeout: reset did not happen!\n");
3460                                 break;
3461                         }
3462                         val |= PCIE2_RP_L1_1_ENTRY_COUNT_RESET;
3463                         rp_writel(port, val, offset);
3464                         mdelay(1);
3465                         val = rp_readl(port, offset);
3466                 }
3467                 if (!val)
3468                         pr_info("L1ss entry count reset to 0\n");
3469         }
3470 }
3471 static int aspm_l11(struct seq_file *s, void *data)
3472 {
3473         struct pci_dev *pdev = NULL;
3474         u32 val = 0, pos = 0;
3475         struct tegra_pcie_port *port = NULL;
3476         struct tegra_pcie *pcie = (struct tegra_pcie *)(s->private);
3477
3478         pr_info("\nPCIE aspm l1.1 test START..\n");
3479         list_for_each_entry(port, &pcie->ports, list) {
3480                 /* reset RP L1.1 counter */
3481                 val = rp_readl(port, NV_PCIE2_RP_L1_1_ENTRY_COUNT);
3482                 val |= PCIE2_RP_L1_1_ENTRY_COUNT_RESET;
3483                 rp_writel(port, val, NV_PCIE2_RP_L1_1_ENTRY_COUNT);
3484
3485                 val = rp_readl(port, NV_PCIE2_RP_L1_1_ENTRY_COUNT);
3486                 pr_info("L1.1 Entry count before %x\n", val);
3487                 reset_l1ss_counter(port, val, NV_PCIE2_RP_L1_1_ENTRY_COUNT);
3488         }
3489         /* disable automatic l1ss exit by gpu */
3490         for_each_pci_dev(pdev)
3491                 if (pci_pcie_type(pdev) != PCI_EXP_TYPE_ROOT_PORT) {
3492                         pci_write_config_dword(pdev, 0x658, 0);
3493                         pci_write_config_dword(pdev, 0x150, 0xE0000015);
3494                 }
3495         for_each_pci_dev(pdev) {
3496                 u16 aspm;
3497                 pcie_capability_read_word(pdev, PCI_EXP_LNKCTL, &aspm);
3498                 aspm |= PCI_EXP_LNKCTL_ASPM_L1;
3499                 pcie_capability_write_word(pdev, PCI_EXP_LNKCTL, aspm);
3500                 pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_L1SS);
3501                 pci_read_config_dword(pdev, pos + PCI_L1SS_CTRL1, &val);
3502                 val &= ~PCI_L1SS_CAP_L1PM_MASK;
3503                 val |= PCI_L1SS_CTRL1_ASPM_L11S;
3504                 pci_write_config_dword(pdev, pos + PCI_L1SS_CTRL1, val);
3505                 if (pci_pcie_type(pdev) != PCI_EXP_TYPE_ROOT_PORT)
3506                         break;
3507         }
3508         mdelay(2000);
3509         for_each_pci_dev(pdev) {
3510                 pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_L1SS);
3511                 pci_read_config_dword(pdev, pos + PCI_L1SS_CTRL1, &val);
3512                 if (pci_pcie_type(pdev) != PCI_EXP_TYPE_ROOT_PORT)
3513                         break;
3514         }
3515         list_for_each_entry(port, &pcie->ports, list) {
3516                 val = rp_readl(port, NV_PCIE2_RP_L1_1_ENTRY_COUNT);
3517                 pr_info("L1.1 Entry count after %x\n", val);
3518         }
3519
3520         pr_info("PCIE aspm l1.1 test END..\n");
3521         return 0;
3522 }
3523
3524 static int aspm_l1ss(struct seq_file *s, void *data)
3525 {
3526         struct pci_dev *pdev = NULL;
3527         u32 val = 0, pos = 0;
3528         struct tegra_pcie_port *port = NULL;
3529         struct tegra_pcie *pcie = (struct tegra_pcie *)(s->private);
3530
3531         pr_info("\nPCIE aspm l1ss test START..\n");
3532         list_for_each_entry(port, &pcie->ports, list) {
3533                 /* reset RP L1.1 L1.2 counters */
3534                 val = rp_readl(port, NV_PCIE2_RP_L1_1_ENTRY_COUNT);
3535                 val |= PCIE2_RP_L1_1_ENTRY_COUNT_RESET;
3536                 rp_writel(port, val, NV_PCIE2_RP_L1_1_ENTRY_COUNT);
3537                 val = rp_readl(port, NV_PCIE2_RP_L1_1_ENTRY_COUNT);
3538                 pr_info("L1.1 Entry count before %x\n", val);
3539                 reset_l1ss_counter(port, val, NV_PCIE2_RP_L1_1_ENTRY_COUNT);
3540
3541                 val = rp_readl(port, NV_PCIE2_RP_L1_2_ENTRY_COUNT);
3542                 val |= PCIE2_RP_L1_2_ENTRY_COUNT_RESET;
3543                 rp_writel(port, val, NV_PCIE2_RP_L1_2_ENTRY_COUNT);
3544                 val = rp_readl(port, NV_PCIE2_RP_L1_2_ENTRY_COUNT);
3545                 pr_info("L1.2 Entry count before %x\n", val);
3546                 reset_l1ss_counter(port, val, NV_PCIE2_RP_L1_2_ENTRY_COUNT);
3547         }
3548         /* disable automatic l1ss exit by gpu */
3549         for_each_pci_dev(pdev)
3550                 if (pci_pcie_type(pdev) != PCI_EXP_TYPE_ROOT_PORT) {
3551                         pci_write_config_dword(pdev, 0x658, 0);
3552                         pci_write_config_dword(pdev, 0x150, 0xE0000015);
3553                 }
3554
3555         for_each_pci_dev(pdev) {
3556                 u16 aspm;
3557                 pcie_capability_read_word(pdev, PCI_EXP_LNKCTL, &aspm);
3558                 aspm |= PCI_EXP_LNKCTL_ASPM_L1;
3559                 pcie_capability_write_word(pdev, PCI_EXP_LNKCTL, aspm);
3560                 pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_L1SS);
3561                 pci_read_config_dword(pdev, pos + PCI_L1SS_CTRL1, &val);
3562                 val &= ~PCI_L1SS_CAP_L1PM_MASK;
3563                 val |= (PCI_L1SS_CTRL1_ASPM_L11S | PCI_L1SS_CTRL1_ASPM_L12S);
3564                 pci_write_config_dword(pdev, pos + PCI_L1SS_CTRL1, val);
3565                 if (pci_pcie_type(pdev) != PCI_EXP_TYPE_ROOT_PORT)
3566                         break;
3567         }
3568         mdelay(2000);
3569         for_each_pci_dev(pdev) {
3570                 pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_L1SS);
3571                 pci_read_config_dword(pdev, pos + PCI_L1SS_CTRL1, &val);
3572                 if (pci_pcie_type(pdev) != PCI_EXP_TYPE_ROOT_PORT)
3573                         break;
3574         }
3575         list_for_each_entry(port, &pcie->ports, list) {
3576                 u32 ltr_val;
3577                 val = rp_readl(port, NV_PCIE2_RP_L1_1_ENTRY_COUNT);
3578                 pr_info("L1.1 Entry count after %x\n", val);
3579                 val = rp_readl(port, NV_PCIE2_RP_L1_2_ENTRY_COUNT);
3580                 pr_info("L1.2 Entry count after %x\n", val);
3581
3582                 val = rp_readl(port, NV_PCIE2_RP_LTR_REP_VAL);
3583                 pr_info("LTR reproted by EP %x\n", val);
3584                 ltr_val = (val & 0x1FF) * (1 << (5 * ((val & 0x1C00) >> 10)));
3585                 if (ltr_val > (106 * 1000)) {
3586                         pr_info("EP's LTR = %u ns is > RP's threshold = %u ns\n",
3587                                         ltr_val, 106 * 1000);
3588                         pr_info("Hence only L1.2 entry allowed\n");
3589                 } else {
3590                         pr_info("EP's LTR = %u ns is < RP's threshold = %u ns\n",
3591                                         ltr_val, 106 * 1000);
3592                         pr_info("Hence only L1.1 entry allowed\n");
3593                 }
3594         }
3595
3596         pr_info("PCIE aspm l1ss test END..\n");
3597         return 0;
3598 }
3599 static struct dentry *create_tegra_pcie_debufs_file(char *name,
3600                 const struct file_operations *ops,
3601                 struct dentry *parent,
3602                 void *data)
3603 {
3604         struct dentry *d;
3605
3606         d = debugfs_create_file(name, S_IRUGO, parent, data, ops);
3607         if (!d)
3608                 debugfs_remove_recursive(parent);
3609
3610         return d;
3611 }
3612
3613 #define DEFINE_ENTRY(__name)    \
3614 static int __name ## _open(struct inode *inode, struct file *file)      \
3615 {                                                                       \
3616         return single_open(file, __name, inode->i_private); \
3617 }                                                                       \
3618 static const struct file_operations __name ## _fops = { \
3619         .open           = __name ## _open,      \
3620         .read           = seq_read,     \
3621         .llseek         = seq_lseek,    \
3622         .release        = single_release,       \
3623 };
3624
3625 /* common */
3626 DEFINE_ENTRY(list_devices)
3627 DEFINE_ENTRY(apply_link_speed)
3628 DEFINE_ENTRY(check_d3hot)
3629 DEFINE_ENTRY(dump_config_space)
3630 DEFINE_ENTRY(dump_afi_space)
3631 DEFINE_ENTRY(config_read)
3632 DEFINE_ENTRY(config_write)
3633 DEFINE_ENTRY(aspm_l11)
3634 DEFINE_ENTRY(aspm_l1ss)
3635 DEFINE_ENTRY(power_down)
3636
3637 /* Port specific */
3638 DEFINE_ENTRY(apply_lane_width)
3639 DEFINE_ENTRY(aspm_state_cnt)
3640 DEFINE_ENTRY(list_aspm_states)
3641 DEFINE_ENTRY(apply_aspm_state)
3642 DEFINE_ENTRY(get_aspm_duration)
3643 DEFINE_ENTRY(secondary_bus_reset)
3644
3645 static int tegra_pcie_port_debugfs_init(struct tegra_pcie_port *port)
3646 {
3647         struct dentry *d;
3648         char port_name;
3649
3650         sprintf(&port_name, "%d", port->index);
3651         port->port_debugfs = debugfs_create_dir(&port_name,
3652                                                         port->pcie->debugfs);
3653         if (!port->port_debugfs)
3654                 return -ENOMEM;
3655
3656         d = debugfs_create_u32("lane_width", S_IWUGO | S_IRUGO,
3657                                         port->port_debugfs,
3658                                         &(port->lanes));
3659         if (!d)
3660                 goto remove;
3661
3662         d = debugfs_create_file("apply_lane_width", S_IRUGO,
3663                                         port->port_debugfs, (void *)port,
3664                                         &apply_lane_width_fops);
3665         if (!d)
3666                 goto remove;
3667
3668         d = debugfs_create_file("aspm_state_cnt", S_IRUGO,
3669                                         port->port_debugfs, (void *)port,
3670                                         &aspm_state_cnt_fops);
3671         if (!d)
3672                 goto remove;
3673
3674         d = debugfs_create_u16("config_aspm_state", S_IWUGO | S_IRUGO,
3675                                         port->port_debugfs,
3676                                         &config_aspm_state);
3677         if (!d)
3678                 goto remove;
3679
3680         d = debugfs_create_file("apply_aspm_state", S_IRUGO,
3681                                         port->port_debugfs, (void *)port,
3682                                         &apply_aspm_state_fops);
3683         if (!d)
3684                 goto remove;
3685
3686         d = debugfs_create_file("list_aspm_states", S_IRUGO,
3687                                         port->port_debugfs, (void *)port,
3688                                         &list_aspm_states_fops);
3689         if (!d)
3690                 goto remove;
3691
3692         d = debugfs_create_file("get_aspm_duration", S_IRUGO,
3693                                         port->port_debugfs, (void *)port,
3694                                         &get_aspm_duration_fops);
3695         if (!d)
3696                 goto remove;
3697
3698         d = debugfs_create_file("secondary_bus_reset", S_IRUGO,
3699                                         port->port_debugfs, (void *)port,
3700                                         &secondary_bus_reset_fops);
3701         if (!d)
3702                 goto remove;
3703
3704         return 0;
3705
3706 remove:
3707         debugfs_remove_recursive(port->port_debugfs);
3708         port->port_debugfs = NULL;
3709         return -ENOMEM;
3710 }
3711
3712 static void *tegra_pcie_ports_seq_start(struct seq_file *s, loff_t *pos)
3713 {
3714         struct tegra_pcie *pcie = s->private;
3715
3716         if (list_empty(&pcie->ports))
3717                 return NULL;
3718
3719         seq_printf(s, "Index  Status\n");
3720
3721         return seq_list_start(&pcie->ports, *pos);
3722 }
3723
3724 static void *tegra_pcie_ports_seq_next(struct seq_file *s, void *v, loff_t *pos)
3725 {
3726         struct tegra_pcie *pcie = s->private;
3727
3728         return seq_list_next(v, &pcie->ports, pos);
3729 }
3730
3731 static void tegra_pcie_ports_seq_stop(struct seq_file *s, void *v)
3732 {
3733 }
3734
3735 static int tegra_pcie_ports_seq_show(struct seq_file *s, void *v)
3736 {
3737         bool up = false, active = false;
3738         struct tegra_pcie_port *port;
3739         unsigned int value;
3740
3741         port = list_entry(v, struct tegra_pcie_port, list);
3742
3743         if (!port->status)
3744                 return 0;
3745
3746         value = readl(port->base + RP_VEND_XP);
3747
3748         if (value & RP_VEND_XP_DL_UP)
3749                 up = true;
3750
3751         value = readl(port->base + RP_LINK_CONTROL_STATUS);
3752
3753         if (value & RP_LINK_CONTROL_STATUS_DL_LINK_ACTIVE)
3754                 active = true;
3755
3756         seq_printf(s, "%2u     ", port->index);
3757
3758         if (up)
3759                 seq_printf(s, "up");
3760
3761         if (active) {
3762                 if (up)
3763                         seq_printf(s, ", ");
3764
3765                 seq_printf(s, "active");
3766         }
3767
3768         seq_printf(s, "\n");
3769         return 0;
3770 }
3771
3772 static const struct seq_operations tegra_pcie_ports_seq_ops = {
3773         .start = tegra_pcie_ports_seq_start,
3774         .next = tegra_pcie_ports_seq_next,
3775         .stop = tegra_pcie_ports_seq_stop,
3776         .show = tegra_pcie_ports_seq_show,
3777 };
3778
3779 static int tegra_pcie_ports_open(struct inode *inode, struct file *file)
3780 {
3781         struct tegra_pcie *pcie = inode->i_private;
3782         struct seq_file *s;
3783         int err;
3784
3785         err = seq_open(file, &tegra_pcie_ports_seq_ops);
3786         if (err)
3787                 return err;
3788
3789         s = file->private_data;
3790         s->private = pcie;
3791
3792         return 0;
3793 }
3794
3795 static const struct file_operations tegra_pcie_ports_ops = {
3796         .owner = THIS_MODULE,
3797         .open = tegra_pcie_ports_open,
3798         .read = seq_read,
3799         .llseek = seq_lseek,
3800         .release = seq_release,
3801 };
3802
3803 static void tegra_pcie_debugfs_exit(struct tegra_pcie *pcie)
3804 {
3805         debugfs_remove_recursive(pcie->debugfs);
3806 }
3807
3808 static int tegra_pcie_debugfs_init(struct tegra_pcie *pcie)
3809 {
3810         struct dentry *file, *d;
3811         struct tegra_pcie_port *port;
3812
3813         pcie->debugfs = debugfs_create_dir("pcie", NULL);
3814         if (!pcie->debugfs)
3815                 return -ENOMEM;
3816
3817         file = debugfs_create_file("ports", S_IFREG | S_IRUGO, pcie->debugfs,
3818                                    pcie, &tegra_pcie_ports_ops);
3819         if (!file)
3820                 goto remove;
3821
3822         d = create_tegra_pcie_debufs_file("list_devices",
3823                                         &list_devices_fops, pcie->debugfs,
3824                                         (void *)pcie);
3825         if (!d)
3826                 goto remove;
3827
3828         d = debugfs_create_bool("is_gen2_speed(WO)", S_IWUSR, pcie->debugfs,
3829                                         &is_gen2_speed);
3830         if (!d)
3831                 goto remove;
3832
3833         d = create_tegra_pcie_debufs_file("apply_link_speed",
3834                                         &apply_link_speed_fops, pcie->debugfs,
3835                                         (void *)pcie);
3836         if (!d)
3837                 goto remove;
3838
3839         d = create_tegra_pcie_debufs_file("check_d3hot",
3840                                         &check_d3hot_fops, pcie->debugfs,
3841                                         (void *)pcie);
3842         if (!d)
3843                 goto remove;
3844
3845         d = create_tegra_pcie_debufs_file("power_down",
3846                                         &power_down_fops, pcie->debugfs,
3847                                         (void *)pcie);
3848         if (!d)
3849                 goto remove;
3850
3851         d = create_tegra_pcie_debufs_file("dump_config_space",
3852                                         &dump_config_space_fops, pcie->debugfs,
3853                                         (void *)pcie);
3854         if (!d)
3855                 goto remove;
3856
3857         d = create_tegra_pcie_debufs_file("dump_afi_space",
3858                                         &dump_afi_space_fops, pcie->debugfs,
3859                                         (void *)pcie);
3860         if (!d)
3861                 goto remove;
3862
3863         d = debugfs_create_u16("bus_dev_func", S_IWUGO | S_IRUGO,
3864                                         pcie->debugfs,
3865                                         &bdf);
3866         if (!d)
3867                 goto remove;
3868
3869         d = debugfs_create_u16("config_offset", S_IWUGO | S_IRUGO,
3870                                         pcie->debugfs,
3871                                         &config_offset);
3872         if (!d)
3873                 goto remove;
3874
3875         d = debugfs_create_u32("config_val", S_IWUGO | S_IRUGO,
3876                                         pcie->debugfs,
3877                                         &config_val);
3878         if (!d)
3879                 goto remove;
3880
3881         d = create_tegra_pcie_debufs_file("config_read",
3882                                         &config_read_fops, pcie->debugfs,
3883                                         (void *)pcie);
3884         if (!d)
3885                 goto remove;
3886
3887         d = create_tegra_pcie_debufs_file("config_write",
3888                                         &config_write_fops, pcie->debugfs,
3889                                         (void *)pcie);
3890         if (!d)
3891                 goto remove;
3892         d = create_tegra_pcie_debufs_file("aspm_l11",
3893                                         &aspm_l11_fops, pcie->debugfs,
3894                                         (void *)pcie);
3895         if (!d)
3896                 goto remove;
3897         d = create_tegra_pcie_debufs_file("aspm_l1ss",
3898                                         &aspm_l1ss_fops, pcie->debugfs,
3899                                         (void *)pcie);
3900         if (!d)
3901                 goto remove;
3902
3903         list_for_each_entry(port, &pcie->ports, list) {
3904                 if (port->status)
3905                         if (tegra_pcie_port_debugfs_init(port))
3906                                 goto remove;
3907         }
3908
3909         return 0;
3910
3911 remove:
3912         tegra_pcie_debugfs_exit(pcie);
3913         pcie->debugfs = NULL;
3914         return -ENOMEM;
3915 }
3916
3917 static int tegra_pcie_probe_complete(struct tegra_pcie *pcie)
3918 {
3919         int ret = 0;
3920         struct platform_device *pdev = to_platform_device(pcie->dev);
3921
3922         PR_FUNC_LINE;
3923         ret = tegra_pcie_init(pcie);
3924         if (ret)
3925                 return ret;
3926
3927         /* FIXME:In Bug 200160313, device hang is observed during LP0 with PCIe
3928          * device connected. When PCIe device is not under mc_clk power-domain,
3929          * this issue does not occur, but SC2/SC3 might break. So, we are calling
3930          * disable_scx_states(), that will disabled SCx states whenever PCIe
3931          * device is connected.
3932          */
3933         if (pcie->num_ports)
3934                 disable_scx_states();
3935
3936         if (IS_ENABLED(CONFIG_DEBUG_FS))
3937                 if (pcie->num_ports) {
3938                         int ret = tegra_pcie_debugfs_init(pcie);
3939                         if (ret < 0)
3940                                 dev_err(&pdev->dev, "failed to setup debugfs: %d\n",
3941                                         ret);
3942         }
3943
3944         return 0;
3945 }
3946
3947 static void pcie_delayed_detect(struct work_struct *work)
3948 {
3949         struct tegra_pcie *pcie;
3950         int ret = 0;
3951
3952         pcie = container_of(work, struct tegra_pcie, detect_delay.work);
3953         ret = tegra_pcie_probe_complete(pcie);
3954         if (ret) {
3955                 return;
3956         }
3957 }
3958
3959 static int tegra_pcie_probe(struct platform_device *pdev)
3960 {
3961         int ret = 0;
3962         int i;
3963         const struct of_device_id *match;
3964         struct tegra_pcie *pcie;
3965
3966         PR_FUNC_LINE;
3967
3968 #ifdef CONFIG_ARCH_TEGRA_21x_SOC
3969         if (tegra_bonded_out_dev(BOND_OUT_PCIE)) {
3970                 dev_err(&pdev->dev, "PCIE instance is not present\n");
3971                 return -ENODEV;
3972         }
3973 #endif
3974
3975         pcie = devm_kzalloc(&pdev->dev, sizeof(*pcie), GFP_KERNEL);
3976         if (!pcie)
3977                 return -ENOMEM;
3978
3979         platform_set_drvdata(pdev, pcie);
3980         pcie->dev = &pdev->dev;
3981
3982         /* use DT way to init platform data */
3983         pcie->plat_data = devm_kzalloc(pcie->dev,
3984                 sizeof(*(pcie->plat_data)), GFP_KERNEL);
3985         if (!(pcie->plat_data)) {
3986                 dev_err(pcie->dev, "memory alloc failed\n");
3987                 return -ENOMEM;
3988         }
3989         tegra_pcie_read_plat_data(pcie);
3990
3991         match = of_match_device(tegra_pcie_of_match, &pdev->dev);
3992         if (!match)
3993                 return -ENODEV;
3994         pcie->soc_data = (struct tegra_pcie_soc_data *)match->data;
3995
3996         pcie->pcie_regulators = devm_kzalloc(pcie->dev,
3997                 pcie->soc_data->num_pcie_regulators
3998                         * sizeof(struct regulator *), GFP_KERNEL);
3999
4000         for (i = 0; i < pcie->soc_data->num_pcie_regulators; i++) {
4001                 pcie->pcie_regulators[i] =
4002                                         devm_regulator_get(pcie->dev,
4003                         pcie->soc_data->pcie_regulator_names[i]);
4004                 if (IS_ERR(pcie->pcie_regulators[i])) {
4005                         dev_err(pcie->dev, "%s: unable to get regulator %s\n",
4006                         __func__,
4007                         pcie->soc_data->pcie_regulator_names[i]);
4008                         pcie->pcie_regulators[i] = NULL;
4009                 }
4010         }
4011
4012         INIT_LIST_HEAD(&pcie->buses);
4013         INIT_LIST_HEAD(&pcie->ports);
4014         INIT_LIST_HEAD(&pcie->sys);
4015         INIT_DELAYED_WORK(&pcie->detect_delay, pcie_delayed_detect);
4016
4017         ret = tegra_pcie_parse_dt(pcie);
4018         if (ret < 0)
4019                 return ret;
4020
4021         pcie->prod_list = tegra_prod_init(pcie->dev->of_node);
4022         if (IS_ERR(pcie->prod_list)) {
4023                 dev_err(pcie->dev, "Prod Init failed\n");
4024                 pcie->prod_list = NULL;
4025         }
4026
4027         /* Enable Runtime PM for PCIe, TODO: Need to add PCIe host device */
4028         pm_runtime_enable(pcie->dev);
4029
4030         if (pcie->plat_data->boot_detect_delay) {
4031                 unsigned long delay =
4032                         msecs_to_jiffies(pcie->plat_data->boot_detect_delay);
4033                 schedule_delayed_work(&pcie->detect_delay, delay);
4034                 return ret;
4035         }
4036
4037         ret = tegra_pcie_probe_complete(pcie);
4038         if (ret) {
4039                 pm_runtime_disable(pcie->dev);
4040                 tegra_pd_remove_device(pcie->dev);
4041         }
4042         return ret;
4043 }
4044
4045 static int tegra_pcie_remove(struct platform_device *pdev)
4046 {
4047         struct tegra_pcie *pcie = platform_get_drvdata(pdev);
4048         struct tegra_pcie_bus *bus;
4049
4050         PR_FUNC_LINE;
4051         pm_runtime_disable(pcie->dev);
4052         if (cancel_delayed_work_sync(&pcie->detect_delay))
4053                 return 0;
4054         if (IS_ENABLED(CONFIG_DEBUG_FS))
4055                 tegra_pcie_debugfs_exit(pcie);
4056         pci_common_exit(&pcie->sys);
4057         list_for_each_entry(bus, &pcie->buses, list) {
4058                 vunmap(bus->area->addr);
4059                 kfree(bus);
4060         }
4061         if (IS_ENABLED(CONFIG_PCI_MSI))
4062                 tegra_pcie_disable_msi(pcie);
4063         if (pcie->prod_list)
4064                 tegra_prod_release(&pcie->prod_list);
4065         tegra_pcie_detach(pcie);
4066         tegra_pd_remove_device(pcie->dev);
4067         tegra_pcie_power_off(pcie, true);
4068         tegra_pcie_disable_regulators(pcie);
4069         tegra_pcie_clocks_put(pcie);
4070
4071         return 0;
4072 }
4073
4074 #ifdef CONFIG_PM
4075 static int tegra_pcie_suspend_noirq(struct device *dev)
4076 {
4077         int ret = 0;
4078         struct tegra_pcie *pcie = dev_get_drvdata(dev);
4079
4080         PR_FUNC_LINE;
4081         ret = tegra_pcie_power_off(pcie, true);
4082         if (ret)
4083                 return ret;
4084         /* configure PE_WAKE signal as wake sources */
4085         if (gpio_is_valid(pcie->plat_data->gpio_wake) &&
4086                         device_may_wakeup(dev)) {
4087                 ret = enable_irq_wake(gpio_to_irq(
4088                         pcie->plat_data->gpio_wake));
4089                 if (ret < 0) {
4090                         dev_err(dev,
4091                                 "ID wake-up event failed with error %d\n", ret);
4092                 }
4093         } else{
4094                 ret = tegra_pcie_disable_regulators(pcie);
4095         }
4096
4097         return ret;
4098
4099 }
4100
4101 static int tegra_pcie_enable_msi(struct tegra_pcie *, bool);
4102
4103 static int tegra_pcie_resume_noirq(struct device *dev)
4104 {
4105         int ret = 0;
4106         struct tegra_pcie *pcie = dev_get_drvdata(dev);
4107
4108         PR_FUNC_LINE;
4109         if (gpio_is_valid(pcie->plat_data->gpio_wake) &&
4110                         device_may_wakeup(dev)) {
4111                 ret = disable_irq_wake(gpio_to_irq(
4112                         pcie->plat_data->gpio_wake));
4113                 if (ret < 0) {
4114                         dev_err(dev,
4115                                 "ID wake-up event failed with error %d\n", ret);
4116                         return ret;
4117                 }
4118         } else {
4119                 ret = tegra_pcie_enable_regulators(pcie);
4120                 if (ret) {
4121                         dev_err(pcie->dev, "PCIE: Failed to enable regulators\n");
4122                         return ret;
4123                 }
4124         }
4125         ret = tegra_pcie_power_on(pcie);
4126         if (ret) {
4127                 dev_err(dev, "PCIE: Failed to power on: %d\n", ret);
4128                 return ret;
4129         }
4130         tegra_pcie_enable_pads(pcie, true);
4131         tegra_periph_reset_deassert(pcie->pcie_afi);
4132         tegra_pcie_enable_controller(pcie);
4133         tegra_pcie_setup_translations(pcie);
4134         /* Set up MSI registers, if MSI have been enabled */
4135         tegra_pcie_enable_msi(pcie, true);
4136         tegra_periph_reset_deassert(pcie->pcie_pcie);
4137         tegra_pcie_check_ports(pcie);
4138         if (!pcie->num_ports) {
4139                 tegra_pcie_power_off(pcie, true);
4140                 ret = tegra_pcie_disable_regulators(pcie);
4141                 if (ret)
4142                         return ret;
4143         }
4144
4145         return 0;
4146 }
4147
4148 static int tegra_pcie_resume(struct device *dev)
4149 {
4150         struct tegra_pcie *pcie = dev_get_drvdata(dev);
4151         PR_FUNC_LINE;
4152         tegra_pcie_enable_features(pcie);
4153         return 0;
4154 }
4155
4156 static const struct dev_pm_ops tegra_pcie_pm_ops = {
4157         .suspend_noirq  = tegra_pcie_suspend_noirq,
4158         .resume_noirq = tegra_pcie_resume_noirq,
4159         .resume = tegra_pcie_resume,
4160         };
4161 #endif /* CONFIG_PM */
4162
4163 /* driver data is accessed after init, so use __refdata instead of __initdata */
4164 static struct platform_driver __refdata tegra_pcie_driver = {
4165         .probe   = tegra_pcie_probe,
4166         .remove  = tegra_pcie_remove,
4167         .driver  = {
4168                 .name  = "tegra-pcie",
4169                 .owner = THIS_MODULE,
4170 #ifdef CONFIG_PM
4171                 .pm    = &tegra_pcie_pm_ops,
4172 #endif
4173                 .of_match_table = tegra_pcie_of_match,
4174         },
4175 };
4176
4177 static int __init tegra_pcie_init_driver(void)
4178 {
4179         return platform_driver_register(&tegra_pcie_driver);
4180 }
4181
4182 static void __exit_refok tegra_pcie_exit_driver(void)
4183 {
4184         platform_driver_unregister(&tegra_pcie_driver);
4185 }
4186
4187 module_init(tegra_pcie_init_driver);
4188 module_exit(tegra_pcie_exit_driver);
4189 MODULE_LICENSE("GPL v2");