Linux Audio

Check our new training course

Loading...
v6.8
  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * PCIe host controller driver for Axis ARTPEC-6 SoC
  4 *
  5 * Author: Niklas Cassel <niklas.cassel@axis.com>
  6 *
  7 * Based on work done by Phil Edworthy <phil@edworthys.org>
  8 */
  9
 10#include <linux/delay.h>
 11#include <linux/kernel.h>
 12#include <linux/init.h>
 13#include <linux/of.h>
 14#include <linux/pci.h>
 15#include <linux/platform_device.h>
 16#include <linux/resource.h>
 17#include <linux/signal.h>
 18#include <linux/types.h>
 19#include <linux/interrupt.h>
 20#include <linux/mfd/syscon.h>
 21#include <linux/regmap.h>
 22
 23#include "pcie-designware.h"
 24
 25#define to_artpec6_pcie(x)	dev_get_drvdata((x)->dev)
 26
 27enum artpec_pcie_variants {
 28	ARTPEC6,
 29	ARTPEC7,
 30};
 31
 32struct artpec6_pcie {
 33	struct dw_pcie		*pci;
 34	struct regmap		*regmap;	/* DT axis,syscon-pcie */
 35	void __iomem		*phy_base;	/* DT phy */
 36	enum artpec_pcie_variants variant;
 37	enum dw_pcie_device_mode mode;
 38};
 39
 40struct artpec_pcie_of_data {
 41	enum artpec_pcie_variants variant;
 42	enum dw_pcie_device_mode mode;
 43};
 44
 45static const struct of_device_id artpec6_pcie_of_match[];
 46
 
 
 
 
 
 
 
 47/* ARTPEC-6 specific registers */
 48#define PCIECFG				0x18
 49#define  PCIECFG_DBG_OEN		BIT(24)
 50#define  PCIECFG_CORE_RESET_REQ		BIT(21)
 51#define  PCIECFG_LTSSM_ENABLE		BIT(20)
 52#define  PCIECFG_DEVICE_TYPE_MASK	GENMASK(19, 16)
 53#define  PCIECFG_CLKREQ_B		BIT(11)
 54#define  PCIECFG_REFCLK_ENABLE		BIT(10)
 55#define  PCIECFG_PLL_ENABLE		BIT(9)
 56#define  PCIECFG_PCLK_ENABLE		BIT(8)
 57#define  PCIECFG_RISRCREN		BIT(4)
 58#define  PCIECFG_MODE_TX_DRV_EN		BIT(3)
 59#define  PCIECFG_CISRREN		BIT(2)
 60#define  PCIECFG_MACRO_ENABLE		BIT(0)
 61/* ARTPEC-7 specific fields */
 62#define  PCIECFG_REFCLKSEL		BIT(23)
 63#define  PCIECFG_NOC_RESET		BIT(3)
 64
 65#define PCIESTAT			0x1c
 66/* ARTPEC-7 specific fields */
 67#define  PCIESTAT_EXTREFCLK		BIT(3)
 68
 69#define NOCCFG				0x40
 70#define  NOCCFG_ENABLE_CLK_PCIE		BIT(4)
 71#define  NOCCFG_POWER_PCIE_IDLEACK	BIT(3)
 72#define  NOCCFG_POWER_PCIE_IDLE		BIT(2)
 73#define  NOCCFG_POWER_PCIE_IDLEREQ	BIT(1)
 74
 75#define PHY_STATUS			0x118
 76#define  PHY_COSPLLLOCK			BIT(0)
 77
 78#define PHY_TX_ASIC_OUT			0x4040
 79#define  PHY_TX_ASIC_OUT_TX_ACK		BIT(0)
 80
 81#define PHY_RX_ASIC_OUT			0x405c
 82#define  PHY_RX_ASIC_OUT_ACK		BIT(0)
 83
 84static u32 artpec6_pcie_readl(struct artpec6_pcie *artpec6_pcie, u32 offset)
 85{
 86	u32 val;
 87
 88	regmap_read(artpec6_pcie->regmap, offset, &val);
 89	return val;
 90}
 91
 92static void artpec6_pcie_writel(struct artpec6_pcie *artpec6_pcie, u32 offset, u32 val)
 93{
 94	regmap_write(artpec6_pcie->regmap, offset, val);
 95}
 96
 97static u64 artpec6_pcie_cpu_addr_fixup(struct dw_pcie *pci, u64 pci_addr)
 98{
 99	struct artpec6_pcie *artpec6_pcie = to_artpec6_pcie(pci);
100	struct dw_pcie_rp *pp = &pci->pp;
101	struct dw_pcie_ep *ep = &pci->ep;
102
103	switch (artpec6_pcie->mode) {
104	case DW_PCIE_RC_TYPE:
105		return pci_addr - pp->cfg0_base;
106	case DW_PCIE_EP_TYPE:
107		return pci_addr - ep->phys_base;
108	default:
109		dev_err(pci->dev, "UNKNOWN device type\n");
110	}
111	return pci_addr;
112}
113
114static int artpec6_pcie_establish_link(struct dw_pcie *pci)
115{
116	struct artpec6_pcie *artpec6_pcie = to_artpec6_pcie(pci);
117	u32 val;
118
119	val = artpec6_pcie_readl(artpec6_pcie, PCIECFG);
120	val |= PCIECFG_LTSSM_ENABLE;
121	artpec6_pcie_writel(artpec6_pcie, PCIECFG, val);
122
123	return 0;
124}
125
126static void artpec6_pcie_stop_link(struct dw_pcie *pci)
127{
128	struct artpec6_pcie *artpec6_pcie = to_artpec6_pcie(pci);
129	u32 val;
130
131	val = artpec6_pcie_readl(artpec6_pcie, PCIECFG);
132	val &= ~PCIECFG_LTSSM_ENABLE;
133	artpec6_pcie_writel(artpec6_pcie, PCIECFG, val);
134}
135
136static const struct dw_pcie_ops dw_pcie_ops = {
137	.cpu_addr_fixup = artpec6_pcie_cpu_addr_fixup,
138	.start_link = artpec6_pcie_establish_link,
139	.stop_link = artpec6_pcie_stop_link,
140};
141
142static void artpec6_pcie_wait_for_phy_a6(struct artpec6_pcie *artpec6_pcie)
143{
144	struct dw_pcie *pci = artpec6_pcie->pci;
145	struct device *dev = pci->dev;
146	u32 val;
147	unsigned int retries;
148
149	retries = 50;
150	do {
151		usleep_range(1000, 2000);
152		val = artpec6_pcie_readl(artpec6_pcie, NOCCFG);
153		retries--;
154	} while (retries &&
155		(val & (NOCCFG_POWER_PCIE_IDLEACK | NOCCFG_POWER_PCIE_IDLE)));
156	if (!retries)
157		dev_err(dev, "PCIe clock manager did not leave idle state\n");
158
159	retries = 50;
160	do {
161		usleep_range(1000, 2000);
162		val = readl(artpec6_pcie->phy_base + PHY_STATUS);
163		retries--;
164	} while (retries && !(val & PHY_COSPLLLOCK));
165	if (!retries)
166		dev_err(dev, "PHY PLL did not lock\n");
167}
168
169static void artpec6_pcie_wait_for_phy_a7(struct artpec6_pcie *artpec6_pcie)
170{
171	struct dw_pcie *pci = artpec6_pcie->pci;
172	struct device *dev = pci->dev;
173	u32 val;
174	u16 phy_status_tx, phy_status_rx;
175	unsigned int retries;
176
177	retries = 50;
178	do {
179		usleep_range(1000, 2000);
180		val = artpec6_pcie_readl(artpec6_pcie, NOCCFG);
181		retries--;
182	} while (retries &&
183		(val & (NOCCFG_POWER_PCIE_IDLEACK | NOCCFG_POWER_PCIE_IDLE)));
184	if (!retries)
185		dev_err(dev, "PCIe clock manager did not leave idle state\n");
186
187	retries = 50;
188	do {
189		usleep_range(1000, 2000);
190		phy_status_tx = readw(artpec6_pcie->phy_base + PHY_TX_ASIC_OUT);
191		phy_status_rx = readw(artpec6_pcie->phy_base + PHY_RX_ASIC_OUT);
192		retries--;
193	} while (retries && ((phy_status_tx & PHY_TX_ASIC_OUT_TX_ACK) ||
194				(phy_status_rx & PHY_RX_ASIC_OUT_ACK)));
195	if (!retries)
196		dev_err(dev, "PHY did not enter Pn state\n");
197}
198
199static void artpec6_pcie_wait_for_phy(struct artpec6_pcie *artpec6_pcie)
200{
201	switch (artpec6_pcie->variant) {
202	case ARTPEC6:
203		artpec6_pcie_wait_for_phy_a6(artpec6_pcie);
204		break;
205	case ARTPEC7:
206		artpec6_pcie_wait_for_phy_a7(artpec6_pcie);
207		break;
208	}
209}
210
211static void artpec6_pcie_init_phy_a6(struct artpec6_pcie *artpec6_pcie)
212{
213	u32 val;
214
215	val = artpec6_pcie_readl(artpec6_pcie, PCIECFG);
216	val |=  PCIECFG_RISRCREN |	/* Receiver term. 50 Ohm */
217		PCIECFG_MODE_TX_DRV_EN |
218		PCIECFG_CISRREN |	/* Reference clock term. 100 Ohm */
219		PCIECFG_MACRO_ENABLE;
220	val |= PCIECFG_REFCLK_ENABLE;
221	val &= ~PCIECFG_DBG_OEN;
222	val &= ~PCIECFG_CLKREQ_B;
223	artpec6_pcie_writel(artpec6_pcie, PCIECFG, val);
224	usleep_range(5000, 6000);
225
226	val = artpec6_pcie_readl(artpec6_pcie, NOCCFG);
227	val |= NOCCFG_ENABLE_CLK_PCIE;
228	artpec6_pcie_writel(artpec6_pcie, NOCCFG, val);
229	usleep_range(20, 30);
230
231	val = artpec6_pcie_readl(artpec6_pcie, PCIECFG);
232	val |= PCIECFG_PCLK_ENABLE | PCIECFG_PLL_ENABLE;
233	artpec6_pcie_writel(artpec6_pcie, PCIECFG, val);
234	usleep_range(6000, 7000);
235
236	val = artpec6_pcie_readl(artpec6_pcie, NOCCFG);
237	val &= ~NOCCFG_POWER_PCIE_IDLEREQ;
238	artpec6_pcie_writel(artpec6_pcie, NOCCFG, val);
239}
240
241static void artpec6_pcie_init_phy_a7(struct artpec6_pcie *artpec6_pcie)
242{
243	struct dw_pcie *pci = artpec6_pcie->pci;
244	u32 val;
245	bool extrefclk;
246
247	/* Check if external reference clock is connected */
248	val = artpec6_pcie_readl(artpec6_pcie, PCIESTAT);
249	extrefclk = !!(val & PCIESTAT_EXTREFCLK);
250	dev_dbg(pci->dev, "Using reference clock: %s\n",
251		extrefclk ? "external" : "internal");
252
253	val = artpec6_pcie_readl(artpec6_pcie, PCIECFG);
254	val |=  PCIECFG_RISRCREN |	/* Receiver term. 50 Ohm */
255		PCIECFG_PCLK_ENABLE;
256	if (extrefclk)
257		val |= PCIECFG_REFCLKSEL;
258	else
259		val &= ~PCIECFG_REFCLKSEL;
260	artpec6_pcie_writel(artpec6_pcie, PCIECFG, val);
261	usleep_range(10, 20);
262
263	val = artpec6_pcie_readl(artpec6_pcie, NOCCFG);
264	val |= NOCCFG_ENABLE_CLK_PCIE;
265	artpec6_pcie_writel(artpec6_pcie, NOCCFG, val);
266	usleep_range(20, 30);
267
268	val = artpec6_pcie_readl(artpec6_pcie, NOCCFG);
269	val &= ~NOCCFG_POWER_PCIE_IDLEREQ;
270	artpec6_pcie_writel(artpec6_pcie, NOCCFG, val);
271}
272
273static void artpec6_pcie_init_phy(struct artpec6_pcie *artpec6_pcie)
274{
275	switch (artpec6_pcie->variant) {
276	case ARTPEC6:
277		artpec6_pcie_init_phy_a6(artpec6_pcie);
278		break;
279	case ARTPEC7:
280		artpec6_pcie_init_phy_a7(artpec6_pcie);
281		break;
282	}
283}
284
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
285static void artpec6_pcie_assert_core_reset(struct artpec6_pcie *artpec6_pcie)
286{
287	u32 val;
288
289	val = artpec6_pcie_readl(artpec6_pcie, PCIECFG);
290	switch (artpec6_pcie->variant) {
291	case ARTPEC6:
292		val |= PCIECFG_CORE_RESET_REQ;
293		break;
294	case ARTPEC7:
295		val &= ~PCIECFG_NOC_RESET;
296		break;
297	}
298	artpec6_pcie_writel(artpec6_pcie, PCIECFG, val);
299}
300
301static void artpec6_pcie_deassert_core_reset(struct artpec6_pcie *artpec6_pcie)
302{
303	u32 val;
304
305	val = artpec6_pcie_readl(artpec6_pcie, PCIECFG);
306	switch (artpec6_pcie->variant) {
307	case ARTPEC6:
308		val &= ~PCIECFG_CORE_RESET_REQ;
309		break;
310	case ARTPEC7:
311		val |= PCIECFG_NOC_RESET;
312		break;
313	}
314	artpec6_pcie_writel(artpec6_pcie, PCIECFG, val);
315	usleep_range(100, 200);
316}
317
318static int artpec6_pcie_host_init(struct dw_pcie_rp *pp)
 
 
 
 
 
 
 
 
 
319{
320	struct dw_pcie *pci = to_dw_pcie_from_pp(pp);
321	struct artpec6_pcie *artpec6_pcie = to_artpec6_pcie(pci);
322
323	if (artpec6_pcie->variant == ARTPEC7) {
324		pci->n_fts[0] = 180;
325		pci->n_fts[1] = 180;
326	}
327	artpec6_pcie_assert_core_reset(artpec6_pcie);
328	artpec6_pcie_init_phy(artpec6_pcie);
329	artpec6_pcie_deassert_core_reset(artpec6_pcie);
330	artpec6_pcie_wait_for_phy(artpec6_pcie);
 
 
 
 
 
331
332	return 0;
333}
334
335static const struct dw_pcie_host_ops artpec6_pcie_host_ops = {
336	.init = artpec6_pcie_host_init,
337};
338
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
339static void artpec6_pcie_ep_init(struct dw_pcie_ep *ep)
340{
341	struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
342	struct artpec6_pcie *artpec6_pcie = to_artpec6_pcie(pci);
343	enum pci_barno bar;
344
345	artpec6_pcie_assert_core_reset(artpec6_pcie);
346	artpec6_pcie_init_phy(artpec6_pcie);
347	artpec6_pcie_deassert_core_reset(artpec6_pcie);
348	artpec6_pcie_wait_for_phy(artpec6_pcie);
 
349
350	for (bar = 0; bar < PCI_STD_NUM_BARS; bar++)
351		dw_pcie_ep_reset_bar(pci, bar);
352}
353
354static int artpec6_pcie_raise_irq(struct dw_pcie_ep *ep, u8 func_no,
355				  unsigned int type, u16 interrupt_num)
356{
357	struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
358
359	switch (type) {
360	case PCI_IRQ_INTX:
361		dev_err(pci->dev, "EP cannot trigger INTx IRQs\n");
362		return -EINVAL;
363	case PCI_IRQ_MSI:
364		return dw_pcie_ep_raise_msi_irq(ep, func_no, interrupt_num);
365	default:
366		dev_err(pci->dev, "UNKNOWN IRQ type\n");
367	}
368
369	return 0;
370}
371
372static const struct dw_pcie_ep_ops pcie_ep_ops = {
373	.init = artpec6_pcie_ep_init,
374	.raise_irq = artpec6_pcie_raise_irq,
375};
376
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
377static int artpec6_pcie_probe(struct platform_device *pdev)
378{
379	struct device *dev = &pdev->dev;
380	struct dw_pcie *pci;
381	struct artpec6_pcie *artpec6_pcie;
382	int ret;
 
383	const struct artpec_pcie_of_data *data;
384	enum artpec_pcie_variants variant;
385	enum dw_pcie_device_mode mode;
386	u32 val;
387
388	data = of_device_get_match_data(dev);
389	if (!data)
390		return -EINVAL;
391
 
392	variant = (enum artpec_pcie_variants)data->variant;
393	mode = (enum dw_pcie_device_mode)data->mode;
394
395	artpec6_pcie = devm_kzalloc(dev, sizeof(*artpec6_pcie), GFP_KERNEL);
396	if (!artpec6_pcie)
397		return -ENOMEM;
398
399	pci = devm_kzalloc(dev, sizeof(*pci), GFP_KERNEL);
400	if (!pci)
401		return -ENOMEM;
402
403	pci->dev = dev;
404	pci->ops = &dw_pcie_ops;
405
406	artpec6_pcie->pci = pci;
407	artpec6_pcie->variant = variant;
408	artpec6_pcie->mode = mode;
409
 
 
 
 
410	artpec6_pcie->phy_base =
411		devm_platform_ioremap_resource_byname(pdev, "phy");
412	if (IS_ERR(artpec6_pcie->phy_base))
413		return PTR_ERR(artpec6_pcie->phy_base);
414
415	artpec6_pcie->regmap =
416		syscon_regmap_lookup_by_phandle(dev->of_node,
417						"axis,syscon-pcie");
418	if (IS_ERR(artpec6_pcie->regmap))
419		return PTR_ERR(artpec6_pcie->regmap);
420
421	platform_set_drvdata(pdev, artpec6_pcie);
422
423	switch (artpec6_pcie->mode) {
424	case DW_PCIE_RC_TYPE:
425		if (!IS_ENABLED(CONFIG_PCIE_ARTPEC6_HOST))
426			return -ENODEV;
427
428		pci->pp.ops = &artpec6_pcie_host_ops;
429
430		ret = dw_pcie_host_init(&pci->pp);
431		if (ret < 0)
432			return ret;
433		break;
434	case DW_PCIE_EP_TYPE:
 
 
435		if (!IS_ENABLED(CONFIG_PCIE_ARTPEC6_EP))
436			return -ENODEV;
437
438		val = artpec6_pcie_readl(artpec6_pcie, PCIECFG);
439		val &= ~PCIECFG_DEVICE_TYPE_MASK;
440		artpec6_pcie_writel(artpec6_pcie, PCIECFG, val);
441
442		pci->ep.ops = &pcie_ep_ops;
443
444		return dw_pcie_ep_init(&pci->ep);
 
445	default:
446		dev_err(dev, "INVALID device type %d\n", artpec6_pcie->mode);
447	}
448
449	return 0;
450}
451
452static const struct artpec_pcie_of_data artpec6_pcie_rc_of_data = {
453	.variant = ARTPEC6,
454	.mode = DW_PCIE_RC_TYPE,
455};
456
457static const struct artpec_pcie_of_data artpec6_pcie_ep_of_data = {
458	.variant = ARTPEC6,
459	.mode = DW_PCIE_EP_TYPE,
460};
461
462static const struct artpec_pcie_of_data artpec7_pcie_rc_of_data = {
463	.variant = ARTPEC7,
464	.mode = DW_PCIE_RC_TYPE,
465};
466
467static const struct artpec_pcie_of_data artpec7_pcie_ep_of_data = {
468	.variant = ARTPEC7,
469	.mode = DW_PCIE_EP_TYPE,
470};
471
472static const struct of_device_id artpec6_pcie_of_match[] = {
473	{
474		.compatible = "axis,artpec6-pcie",
475		.data = &artpec6_pcie_rc_of_data,
476	},
477	{
478		.compatible = "axis,artpec6-pcie-ep",
479		.data = &artpec6_pcie_ep_of_data,
480	},
481	{
482		.compatible = "axis,artpec7-pcie",
483		.data = &artpec7_pcie_rc_of_data,
484	},
485	{
486		.compatible = "axis,artpec7-pcie-ep",
487		.data = &artpec7_pcie_ep_of_data,
488	},
489	{},
490};
491
492static struct platform_driver artpec6_pcie_driver = {
493	.probe = artpec6_pcie_probe,
494	.driver = {
495		.name	= "artpec6-pcie",
496		.of_match_table = artpec6_pcie_of_match,
497		.suppress_bind_attrs = true,
498	},
499};
500builtin_platform_driver(artpec6_pcie_driver);
v5.9
  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * PCIe host controller driver for Axis ARTPEC-6 SoC
  4 *
  5 * Author: Niklas Cassel <niklas.cassel@axis.com>
  6 *
  7 * Based on work done by Phil Edworthy <phil@edworthys.org>
  8 */
  9
 10#include <linux/delay.h>
 11#include <linux/kernel.h>
 12#include <linux/init.h>
 13#include <linux/of_device.h>
 14#include <linux/pci.h>
 15#include <linux/platform_device.h>
 16#include <linux/resource.h>
 17#include <linux/signal.h>
 18#include <linux/types.h>
 19#include <linux/interrupt.h>
 20#include <linux/mfd/syscon.h>
 21#include <linux/regmap.h>
 22
 23#include "pcie-designware.h"
 24
 25#define to_artpec6_pcie(x)	dev_get_drvdata((x)->dev)
 26
 27enum artpec_pcie_variants {
 28	ARTPEC6,
 29	ARTPEC7,
 30};
 31
 32struct artpec6_pcie {
 33	struct dw_pcie		*pci;
 34	struct regmap		*regmap;	/* DT axis,syscon-pcie */
 35	void __iomem		*phy_base;	/* DT phy */
 36	enum artpec_pcie_variants variant;
 37	enum dw_pcie_device_mode mode;
 38};
 39
 40struct artpec_pcie_of_data {
 41	enum artpec_pcie_variants variant;
 42	enum dw_pcie_device_mode mode;
 43};
 44
 45static const struct of_device_id artpec6_pcie_of_match[];
 46
 47/* PCIe Port Logic registers (memory-mapped) */
 48#define PL_OFFSET			0x700
 49
 50#define ACK_F_ASPM_CTRL_OFF		(PL_OFFSET + 0xc)
 51#define ACK_N_FTS_MASK			GENMASK(15, 8)
 52#define ACK_N_FTS(x)			(((x) << 8) & ACK_N_FTS_MASK)
 53
 54/* ARTPEC-6 specific registers */
 55#define PCIECFG				0x18
 56#define  PCIECFG_DBG_OEN		BIT(24)
 57#define  PCIECFG_CORE_RESET_REQ		BIT(21)
 58#define  PCIECFG_LTSSM_ENABLE		BIT(20)
 59#define  PCIECFG_DEVICE_TYPE_MASK	GENMASK(19, 16)
 60#define  PCIECFG_CLKREQ_B		BIT(11)
 61#define  PCIECFG_REFCLK_ENABLE		BIT(10)
 62#define  PCIECFG_PLL_ENABLE		BIT(9)
 63#define  PCIECFG_PCLK_ENABLE		BIT(8)
 64#define  PCIECFG_RISRCREN		BIT(4)
 65#define  PCIECFG_MODE_TX_DRV_EN		BIT(3)
 66#define  PCIECFG_CISRREN		BIT(2)
 67#define  PCIECFG_MACRO_ENABLE		BIT(0)
 68/* ARTPEC-7 specific fields */
 69#define  PCIECFG_REFCLKSEL		BIT(23)
 70#define  PCIECFG_NOC_RESET		BIT(3)
 71
 72#define PCIESTAT			0x1c
 73/* ARTPEC-7 specific fields */
 74#define  PCIESTAT_EXTREFCLK		BIT(3)
 75
 76#define NOCCFG				0x40
 77#define  NOCCFG_ENABLE_CLK_PCIE		BIT(4)
 78#define  NOCCFG_POWER_PCIE_IDLEACK	BIT(3)
 79#define  NOCCFG_POWER_PCIE_IDLE		BIT(2)
 80#define  NOCCFG_POWER_PCIE_IDLEREQ	BIT(1)
 81
 82#define PHY_STATUS			0x118
 83#define  PHY_COSPLLLOCK			BIT(0)
 84
 85#define PHY_TX_ASIC_OUT			0x4040
 86#define  PHY_TX_ASIC_OUT_TX_ACK		BIT(0)
 87
 88#define PHY_RX_ASIC_OUT			0x405c
 89#define  PHY_RX_ASIC_OUT_ACK		BIT(0)
 90
 91static u32 artpec6_pcie_readl(struct artpec6_pcie *artpec6_pcie, u32 offset)
 92{
 93	u32 val;
 94
 95	regmap_read(artpec6_pcie->regmap, offset, &val);
 96	return val;
 97}
 98
 99static void artpec6_pcie_writel(struct artpec6_pcie *artpec6_pcie, u32 offset, u32 val)
100{
101	regmap_write(artpec6_pcie->regmap, offset, val);
102}
103
104static u64 artpec6_pcie_cpu_addr_fixup(struct dw_pcie *pci, u64 pci_addr)
105{
106	struct artpec6_pcie *artpec6_pcie = to_artpec6_pcie(pci);
107	struct pcie_port *pp = &pci->pp;
108	struct dw_pcie_ep *ep = &pci->ep;
109
110	switch (artpec6_pcie->mode) {
111	case DW_PCIE_RC_TYPE:
112		return pci_addr - pp->cfg0_base;
113	case DW_PCIE_EP_TYPE:
114		return pci_addr - ep->phys_base;
115	default:
116		dev_err(pci->dev, "UNKNOWN device type\n");
117	}
118	return pci_addr;
119}
120
121static int artpec6_pcie_establish_link(struct dw_pcie *pci)
122{
123	struct artpec6_pcie *artpec6_pcie = to_artpec6_pcie(pci);
124	u32 val;
125
126	val = artpec6_pcie_readl(artpec6_pcie, PCIECFG);
127	val |= PCIECFG_LTSSM_ENABLE;
128	artpec6_pcie_writel(artpec6_pcie, PCIECFG, val);
129
130	return 0;
131}
132
133static void artpec6_pcie_stop_link(struct dw_pcie *pci)
134{
135	struct artpec6_pcie *artpec6_pcie = to_artpec6_pcie(pci);
136	u32 val;
137
138	val = artpec6_pcie_readl(artpec6_pcie, PCIECFG);
139	val &= ~PCIECFG_LTSSM_ENABLE;
140	artpec6_pcie_writel(artpec6_pcie, PCIECFG, val);
141}
142
143static const struct dw_pcie_ops dw_pcie_ops = {
144	.cpu_addr_fixup = artpec6_pcie_cpu_addr_fixup,
145	.start_link = artpec6_pcie_establish_link,
146	.stop_link = artpec6_pcie_stop_link,
147};
148
149static void artpec6_pcie_wait_for_phy_a6(struct artpec6_pcie *artpec6_pcie)
150{
151	struct dw_pcie *pci = artpec6_pcie->pci;
152	struct device *dev = pci->dev;
153	u32 val;
154	unsigned int retries;
155
156	retries = 50;
157	do {
158		usleep_range(1000, 2000);
159		val = artpec6_pcie_readl(artpec6_pcie, NOCCFG);
160		retries--;
161	} while (retries &&
162		(val & (NOCCFG_POWER_PCIE_IDLEACK | NOCCFG_POWER_PCIE_IDLE)));
163	if (!retries)
164		dev_err(dev, "PCIe clock manager did not leave idle state\n");
165
166	retries = 50;
167	do {
168		usleep_range(1000, 2000);
169		val = readl(artpec6_pcie->phy_base + PHY_STATUS);
170		retries--;
171	} while (retries && !(val & PHY_COSPLLLOCK));
172	if (!retries)
173		dev_err(dev, "PHY PLL did not lock\n");
174}
175
176static void artpec6_pcie_wait_for_phy_a7(struct artpec6_pcie *artpec6_pcie)
177{
178	struct dw_pcie *pci = artpec6_pcie->pci;
179	struct device *dev = pci->dev;
180	u32 val;
181	u16 phy_status_tx, phy_status_rx;
182	unsigned int retries;
183
184	retries = 50;
185	do {
186		usleep_range(1000, 2000);
187		val = artpec6_pcie_readl(artpec6_pcie, NOCCFG);
188		retries--;
189	} while (retries &&
190		(val & (NOCCFG_POWER_PCIE_IDLEACK | NOCCFG_POWER_PCIE_IDLE)));
191	if (!retries)
192		dev_err(dev, "PCIe clock manager did not leave idle state\n");
193
194	retries = 50;
195	do {
196		usleep_range(1000, 2000);
197		phy_status_tx = readw(artpec6_pcie->phy_base + PHY_TX_ASIC_OUT);
198		phy_status_rx = readw(artpec6_pcie->phy_base + PHY_RX_ASIC_OUT);
199		retries--;
200	} while (retries && ((phy_status_tx & PHY_TX_ASIC_OUT_TX_ACK) ||
201				(phy_status_rx & PHY_RX_ASIC_OUT_ACK)));
202	if (!retries)
203		dev_err(dev, "PHY did not enter Pn state\n");
204}
205
206static void artpec6_pcie_wait_for_phy(struct artpec6_pcie *artpec6_pcie)
207{
208	switch (artpec6_pcie->variant) {
209	case ARTPEC6:
210		artpec6_pcie_wait_for_phy_a6(artpec6_pcie);
211		break;
212	case ARTPEC7:
213		artpec6_pcie_wait_for_phy_a7(artpec6_pcie);
214		break;
215	}
216}
217
218static void artpec6_pcie_init_phy_a6(struct artpec6_pcie *artpec6_pcie)
219{
220	u32 val;
221
222	val = artpec6_pcie_readl(artpec6_pcie, PCIECFG);
223	val |=  PCIECFG_RISRCREN |	/* Receiver term. 50 Ohm */
224		PCIECFG_MODE_TX_DRV_EN |
225		PCIECFG_CISRREN |	/* Reference clock term. 100 Ohm */
226		PCIECFG_MACRO_ENABLE;
227	val |= PCIECFG_REFCLK_ENABLE;
228	val &= ~PCIECFG_DBG_OEN;
229	val &= ~PCIECFG_CLKREQ_B;
230	artpec6_pcie_writel(artpec6_pcie, PCIECFG, val);
231	usleep_range(5000, 6000);
232
233	val = artpec6_pcie_readl(artpec6_pcie, NOCCFG);
234	val |= NOCCFG_ENABLE_CLK_PCIE;
235	artpec6_pcie_writel(artpec6_pcie, NOCCFG, val);
236	usleep_range(20, 30);
237
238	val = artpec6_pcie_readl(artpec6_pcie, PCIECFG);
239	val |= PCIECFG_PCLK_ENABLE | PCIECFG_PLL_ENABLE;
240	artpec6_pcie_writel(artpec6_pcie, PCIECFG, val);
241	usleep_range(6000, 7000);
242
243	val = artpec6_pcie_readl(artpec6_pcie, NOCCFG);
244	val &= ~NOCCFG_POWER_PCIE_IDLEREQ;
245	artpec6_pcie_writel(artpec6_pcie, NOCCFG, val);
246}
247
248static void artpec6_pcie_init_phy_a7(struct artpec6_pcie *artpec6_pcie)
249{
250	struct dw_pcie *pci = artpec6_pcie->pci;
251	u32 val;
252	bool extrefclk;
253
254	/* Check if external reference clock is connected */
255	val = artpec6_pcie_readl(artpec6_pcie, PCIESTAT);
256	extrefclk = !!(val & PCIESTAT_EXTREFCLK);
257	dev_dbg(pci->dev, "Using reference clock: %s\n",
258		extrefclk ? "external" : "internal");
259
260	val = artpec6_pcie_readl(artpec6_pcie, PCIECFG);
261	val |=  PCIECFG_RISRCREN |	/* Receiver term. 50 Ohm */
262		PCIECFG_PCLK_ENABLE;
263	if (extrefclk)
264		val |= PCIECFG_REFCLKSEL;
265	else
266		val &= ~PCIECFG_REFCLKSEL;
267	artpec6_pcie_writel(artpec6_pcie, PCIECFG, val);
268	usleep_range(10, 20);
269
270	val = artpec6_pcie_readl(artpec6_pcie, NOCCFG);
271	val |= NOCCFG_ENABLE_CLK_PCIE;
272	artpec6_pcie_writel(artpec6_pcie, NOCCFG, val);
273	usleep_range(20, 30);
274
275	val = artpec6_pcie_readl(artpec6_pcie, NOCCFG);
276	val &= ~NOCCFG_POWER_PCIE_IDLEREQ;
277	artpec6_pcie_writel(artpec6_pcie, NOCCFG, val);
278}
279
280static void artpec6_pcie_init_phy(struct artpec6_pcie *artpec6_pcie)
281{
282	switch (artpec6_pcie->variant) {
283	case ARTPEC6:
284		artpec6_pcie_init_phy_a6(artpec6_pcie);
285		break;
286	case ARTPEC7:
287		artpec6_pcie_init_phy_a7(artpec6_pcie);
288		break;
289	}
290}
291
292static void artpec6_pcie_set_nfts(struct artpec6_pcie *artpec6_pcie)
293{
294	struct dw_pcie *pci = artpec6_pcie->pci;
295	u32 val;
296
297	if (artpec6_pcie->variant != ARTPEC7)
298		return;
299
300	/*
301	 * Increase the N_FTS (Number of Fast Training Sequences)
302	 * to be transmitted when transitioning from L0s to L0.
303	 */
304	val = dw_pcie_readl_dbi(pci, ACK_F_ASPM_CTRL_OFF);
305	val &= ~ACK_N_FTS_MASK;
306	val |= ACK_N_FTS(180);
307	dw_pcie_writel_dbi(pci, ACK_F_ASPM_CTRL_OFF, val);
308
309	/*
310	 * Set the Number of Fast Training Sequences that the core
311	 * advertises as its N_FTS during Gen2 or Gen3 link training.
312	 */
313	dw_pcie_link_set_n_fts(pci, 180);
314}
315
316static void artpec6_pcie_assert_core_reset(struct artpec6_pcie *artpec6_pcie)
317{
318	u32 val;
319
320	val = artpec6_pcie_readl(artpec6_pcie, PCIECFG);
321	switch (artpec6_pcie->variant) {
322	case ARTPEC6:
323		val |= PCIECFG_CORE_RESET_REQ;
324		break;
325	case ARTPEC7:
326		val &= ~PCIECFG_NOC_RESET;
327		break;
328	}
329	artpec6_pcie_writel(artpec6_pcie, PCIECFG, val);
330}
331
332static void artpec6_pcie_deassert_core_reset(struct artpec6_pcie *artpec6_pcie)
333{
334	u32 val;
335
336	val = artpec6_pcie_readl(artpec6_pcie, PCIECFG);
337	switch (artpec6_pcie->variant) {
338	case ARTPEC6:
339		val &= ~PCIECFG_CORE_RESET_REQ;
340		break;
341	case ARTPEC7:
342		val |= PCIECFG_NOC_RESET;
343		break;
344	}
345	artpec6_pcie_writel(artpec6_pcie, PCIECFG, val);
346	usleep_range(100, 200);
347}
348
349static void artpec6_pcie_enable_interrupts(struct artpec6_pcie *artpec6_pcie)
350{
351	struct dw_pcie *pci = artpec6_pcie->pci;
352	struct pcie_port *pp = &pci->pp;
353
354	if (IS_ENABLED(CONFIG_PCI_MSI))
355		dw_pcie_msi_init(pp);
356}
357
358static int artpec6_pcie_host_init(struct pcie_port *pp)
359{
360	struct dw_pcie *pci = to_dw_pcie_from_pp(pp);
361	struct artpec6_pcie *artpec6_pcie = to_artpec6_pcie(pci);
362
 
 
 
 
363	artpec6_pcie_assert_core_reset(artpec6_pcie);
364	artpec6_pcie_init_phy(artpec6_pcie);
365	artpec6_pcie_deassert_core_reset(artpec6_pcie);
366	artpec6_pcie_wait_for_phy(artpec6_pcie);
367	artpec6_pcie_set_nfts(artpec6_pcie);
368	dw_pcie_setup_rc(pp);
369	artpec6_pcie_establish_link(pci);
370	dw_pcie_wait_for_link(pci);
371	artpec6_pcie_enable_interrupts(artpec6_pcie);
372
373	return 0;
374}
375
376static const struct dw_pcie_host_ops artpec6_pcie_host_ops = {
377	.host_init = artpec6_pcie_host_init,
378};
379
380static int artpec6_add_pcie_port(struct artpec6_pcie *artpec6_pcie,
381				 struct platform_device *pdev)
382{
383	struct dw_pcie *pci = artpec6_pcie->pci;
384	struct pcie_port *pp = &pci->pp;
385	struct device *dev = pci->dev;
386	int ret;
387
388	if (IS_ENABLED(CONFIG_PCI_MSI)) {
389		pp->msi_irq = platform_get_irq_byname(pdev, "msi");
390		if (pp->msi_irq < 0)
391			return pp->msi_irq;
392	}
393
394	pp->ops = &artpec6_pcie_host_ops;
395
396	ret = dw_pcie_host_init(pp);
397	if (ret) {
398		dev_err(dev, "failed to initialize host\n");
399		return ret;
400	}
401
402	return 0;
403}
404
405static void artpec6_pcie_ep_init(struct dw_pcie_ep *ep)
406{
407	struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
408	struct artpec6_pcie *artpec6_pcie = to_artpec6_pcie(pci);
409	enum pci_barno bar;
410
411	artpec6_pcie_assert_core_reset(artpec6_pcie);
412	artpec6_pcie_init_phy(artpec6_pcie);
413	artpec6_pcie_deassert_core_reset(artpec6_pcie);
414	artpec6_pcie_wait_for_phy(artpec6_pcie);
415	artpec6_pcie_set_nfts(artpec6_pcie);
416
417	for (bar = 0; bar < PCI_STD_NUM_BARS; bar++)
418		dw_pcie_ep_reset_bar(pci, bar);
419}
420
421static int artpec6_pcie_raise_irq(struct dw_pcie_ep *ep, u8 func_no,
422				  enum pci_epc_irq_type type, u16 interrupt_num)
423{
424	struct dw_pcie *pci = to_dw_pcie_from_ep(ep);
425
426	switch (type) {
427	case PCI_EPC_IRQ_LEGACY:
428		dev_err(pci->dev, "EP cannot trigger legacy IRQs\n");
429		return -EINVAL;
430	case PCI_EPC_IRQ_MSI:
431		return dw_pcie_ep_raise_msi_irq(ep, func_no, interrupt_num);
432	default:
433		dev_err(pci->dev, "UNKNOWN IRQ type\n");
434	}
435
436	return 0;
437}
438
439static const struct dw_pcie_ep_ops pcie_ep_ops = {
440	.ep_init = artpec6_pcie_ep_init,
441	.raise_irq = artpec6_pcie_raise_irq,
442};
443
444static int artpec6_add_pcie_ep(struct artpec6_pcie *artpec6_pcie,
445			       struct platform_device *pdev)
446{
447	int ret;
448	struct dw_pcie_ep *ep;
449	struct resource *res;
450	struct device *dev = &pdev->dev;
451	struct dw_pcie *pci = artpec6_pcie->pci;
452
453	ep = &pci->ep;
454	ep->ops = &pcie_ep_ops;
455
456	pci->dbi_base2 = devm_platform_ioremap_resource_byname(pdev, "dbi2");
457	if (IS_ERR(pci->dbi_base2))
458		return PTR_ERR(pci->dbi_base2);
459
460	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "addr_space");
461	if (!res)
462		return -EINVAL;
463
464	ep->phys_base = res->start;
465	ep->addr_size = resource_size(res);
466
467	ret = dw_pcie_ep_init(ep);
468	if (ret) {
469		dev_err(dev, "failed to initialize endpoint\n");
470		return ret;
471	}
472
473	return 0;
474}
475
476static int artpec6_pcie_probe(struct platform_device *pdev)
477{
478	struct device *dev = &pdev->dev;
479	struct dw_pcie *pci;
480	struct artpec6_pcie *artpec6_pcie;
481	int ret;
482	const struct of_device_id *match;
483	const struct artpec_pcie_of_data *data;
484	enum artpec_pcie_variants variant;
485	enum dw_pcie_device_mode mode;
 
486
487	match = of_match_device(artpec6_pcie_of_match, dev);
488	if (!match)
489		return -EINVAL;
490
491	data = (struct artpec_pcie_of_data *)match->data;
492	variant = (enum artpec_pcie_variants)data->variant;
493	mode = (enum dw_pcie_device_mode)data->mode;
494
495	artpec6_pcie = devm_kzalloc(dev, sizeof(*artpec6_pcie), GFP_KERNEL);
496	if (!artpec6_pcie)
497		return -ENOMEM;
498
499	pci = devm_kzalloc(dev, sizeof(*pci), GFP_KERNEL);
500	if (!pci)
501		return -ENOMEM;
502
503	pci->dev = dev;
504	pci->ops = &dw_pcie_ops;
505
506	artpec6_pcie->pci = pci;
507	artpec6_pcie->variant = variant;
508	artpec6_pcie->mode = mode;
509
510	pci->dbi_base = devm_platform_ioremap_resource_byname(pdev, "dbi");
511	if (IS_ERR(pci->dbi_base))
512		return PTR_ERR(pci->dbi_base);
513
514	artpec6_pcie->phy_base =
515		devm_platform_ioremap_resource_byname(pdev, "phy");
516	if (IS_ERR(artpec6_pcie->phy_base))
517		return PTR_ERR(artpec6_pcie->phy_base);
518
519	artpec6_pcie->regmap =
520		syscon_regmap_lookup_by_phandle(dev->of_node,
521						"axis,syscon-pcie");
522	if (IS_ERR(artpec6_pcie->regmap))
523		return PTR_ERR(artpec6_pcie->regmap);
524
525	platform_set_drvdata(pdev, artpec6_pcie);
526
527	switch (artpec6_pcie->mode) {
528	case DW_PCIE_RC_TYPE:
529		if (!IS_ENABLED(CONFIG_PCIE_ARTPEC6_HOST))
530			return -ENODEV;
531
532		ret = artpec6_add_pcie_port(artpec6_pcie, pdev);
 
 
533		if (ret < 0)
534			return ret;
535		break;
536	case DW_PCIE_EP_TYPE: {
537		u32 val;
538
539		if (!IS_ENABLED(CONFIG_PCIE_ARTPEC6_EP))
540			return -ENODEV;
541
542		val = artpec6_pcie_readl(artpec6_pcie, PCIECFG);
543		val &= ~PCIECFG_DEVICE_TYPE_MASK;
544		artpec6_pcie_writel(artpec6_pcie, PCIECFG, val);
545		ret = artpec6_add_pcie_ep(artpec6_pcie, pdev);
546		if (ret < 0)
547			return ret;
548		break;
549	}
550	default:
551		dev_err(dev, "INVALID device type %d\n", artpec6_pcie->mode);
552	}
553
554	return 0;
555}
556
557static const struct artpec_pcie_of_data artpec6_pcie_rc_of_data = {
558	.variant = ARTPEC6,
559	.mode = DW_PCIE_RC_TYPE,
560};
561
562static const struct artpec_pcie_of_data artpec6_pcie_ep_of_data = {
563	.variant = ARTPEC6,
564	.mode = DW_PCIE_EP_TYPE,
565};
566
567static const struct artpec_pcie_of_data artpec7_pcie_rc_of_data = {
568	.variant = ARTPEC7,
569	.mode = DW_PCIE_RC_TYPE,
570};
571
572static const struct artpec_pcie_of_data artpec7_pcie_ep_of_data = {
573	.variant = ARTPEC7,
574	.mode = DW_PCIE_EP_TYPE,
575};
576
577static const struct of_device_id artpec6_pcie_of_match[] = {
578	{
579		.compatible = "axis,artpec6-pcie",
580		.data = &artpec6_pcie_rc_of_data,
581	},
582	{
583		.compatible = "axis,artpec6-pcie-ep",
584		.data = &artpec6_pcie_ep_of_data,
585	},
586	{
587		.compatible = "axis,artpec7-pcie",
588		.data = &artpec7_pcie_rc_of_data,
589	},
590	{
591		.compatible = "axis,artpec7-pcie-ep",
592		.data = &artpec7_pcie_ep_of_data,
593	},
594	{},
595};
596
597static struct platform_driver artpec6_pcie_driver = {
598	.probe = artpec6_pcie_probe,
599	.driver = {
600		.name	= "artpec6-pcie",
601		.of_match_table = artpec6_pcie_of_match,
602		.suppress_bind_attrs = true,
603	},
604};
605builtin_platform_driver(artpec6_pcie_driver);