1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#include <linux/bitops.h>
19#include <linux/delay.h>
20#include <linux/iopoll.h>
21#include <linux/module.h>
22#include <linux/of.h>
23#include <linux/of_address.h>
24#include <linux/of_irq.h>
25#include <linux/of_pci.h>
26#include <linux/of_platform.h>
27#include <linux/pci.h>
28#include <linux/platform_device.h>
29#include <linux/reset.h>
30#include <mt7621.h>
31#include <ralink_regs.h>
32
33#include "../../pci/pci.h"
34
35
36#define MT7621_CHIP_REV_ID 0x0c
37#define RALINK_CLKCFG1 0x30
38#define RALINK_RSTCTRL 0x34
39#define CHIP_REV_MT7621_E2 0x0101
40
41
42#define RALINK_PCIE_RST BIT(23)
43
44
45#define PCIE_FTS_NUM 0x70c
46#define PCIE_FTS_NUM_MASK GENMASK(15, 8)
47#define PCIE_FTS_NUM_L0(x) ((x) & 0xff << 8)
48
49
50#define RALINK_PCIE_CLK_GEN 0x7c
51#define RALINK_PCIE_CLK_GEN1 0x80
52
53
54#define RALINK_PCI_PCICFG_ADDR 0x0000
55#define RALINK_PCI_PCIMSK_ADDR 0x000C
56#define RALINK_PCI_CONFIG_ADDR 0x0020
57#define RALINK_PCI_CONFIG_DATA 0x0024
58#define RALINK_PCI_MEMBASE 0x0028
59#define RALINK_PCI_IOBASE 0x002C
60
61
62#define MT7621_BR0_MASK GENMASK(19, 16)
63#define MT7621_BR1_MASK GENMASK(23, 20)
64#define MT7621_BR2_MASK GENMASK(27, 24)
65#define MT7621_BR_ALL_MASK GENMASK(27, 16)
66#define MT7621_BR0_SHIFT 16
67#define MT7621_BR1_SHIFT 20
68#define MT7621_BR2_SHIFT 24
69
70
71#define MT7621_PCIE_OFFSET 0x2000
72#define MT7621_NEXT_PORT 0x1000
73
74#define RALINK_PCI_BAR0SETUP_ADDR 0x0010
75#define RALINK_PCI_IMBASEBAR0_ADDR 0x0018
76#define RALINK_PCI_ID 0x0030
77#define RALINK_PCI_CLASS 0x0034
78#define RALINK_PCI_SUBID 0x0038
79#define RALINK_PCI_STATUS 0x0050
80
81
82#define PCIE_REVISION_ID BIT(0)
83#define PCIE_CLASS_CODE (0x60400 << 8)
84#define PCIE_BAR_MAP_MAX GENMASK(30, 16)
85#define PCIE_BAR_ENABLE BIT(0)
86#define PCIE_PORT_INT_EN(x) BIT(20 + (x))
87#define PCIE_PORT_CLK_EN(x) BIT(24 + (x))
88#define PCIE_PORT_PERST(x) BIT(1 + (x))
89#define PCIE_PORT_LINKUP BIT(0)
90
91#define PCIE_CLK_GEN_EN BIT(31)
92#define PCIE_CLK_GEN_DIS 0
93#define PCIE_CLK_GEN1_DIS GENMASK(30,24)
94#define PCIE_CLK_GEN1_EN (BIT(27) | BIT(25))
95#define RALINK_PCI_IO_MAP_BASE 0x1e160000
96#define MEMORY_BASE 0x0
97
98
99#define RALINK_PCIEPHY_P0P1_CTL_OFFSET 0x9000
100#define RALINK_PCIEPHY_P2_CTL_OFFSET 0xA000
101
102#define RG_P0_TO_P1_WIDTH 0x100
103
104#define RG_PE1_PIPE_REG 0x02c
105#define RG_PE1_PIPE_RST BIT(12)
106#define RG_PE1_PIPE_CMD_FRC BIT(4)
107
108#define RG_PE1_H_LCDDS_REG 0x49c
109#define RG_PE1_H_LCDDS_PCW GENMASK(30, 0)
110#define RG_PE1_H_LCDDS_PCW_VAL(x) ((0x7fffffff & (x)) << 0)
111
112#define RG_PE1_FRC_H_XTAL_REG 0x400
113#define RG_PE1_FRC_H_XTAL_TYPE BIT(8)
114#define RG_PE1_H_XTAL_TYPE GENMASK(10, 9)
115#define RG_PE1_H_XTAL_TYPE_VAL(x) ((0x3 & (x)) << 9)
116
117#define RG_PE1_FRC_PHY_REG 0x000
118#define RG_PE1_FRC_PHY_EN BIT(4)
119#define RG_PE1_PHY_EN BIT(5)
120
121#define RG_PE1_H_PLL_REG 0x490
122#define RG_PE1_H_PLL_BC GENMASK(23, 22)
123#define RG_PE1_H_PLL_BC_VAL(x) ((0x3 & (x)) << 22)
124#define RG_PE1_H_PLL_BP GENMASK(21, 18)
125#define RG_PE1_H_PLL_BP_VAL(x) ((0xf & (x)) << 18)
126#define RG_PE1_H_PLL_IR GENMASK(15, 12)
127#define RG_PE1_H_PLL_IR_VAL(x) ((0xf & (x)) << 12)
128#define RG_PE1_H_PLL_IC GENMASK(11, 8)
129#define RG_PE1_H_PLL_IC_VAL(x) ((0xf & (x)) << 8)
130#define RG_PE1_H_PLL_PREDIV GENMASK(7, 6)
131#define RG_PE1_H_PLL_PREDIV_VAL(x) ((0x3 & (x)) << 6)
132#define RG_PE1_PLL_DIVEN GENMASK(3, 1)
133#define RG_PE1_PLL_DIVEN_VAL(x) ((0x7 & (x)) << 1)
134
135#define RG_PE1_H_PLL_FBKSEL_REG 0x4bc
136#define RG_PE1_H_PLL_FBKSEL GENMASK(5, 4)
137#define RG_PE1_H_PLL_FBKSEL_VAL(x) ((0x3 & (x)) << 4)
138
139#define RG_PE1_H_LCDDS_SSC_PRD_REG 0x4a4
140#define RG_PE1_H_LCDDS_SSC_PRD GENMASK(15, 0)
141#define RG_PE1_H_LCDDS_SSC_PRD_VAL(x) ((0xffff & (x)) << 0)
142
143#define RG_PE1_H_LCDDS_SSC_DELTA_REG 0x4a8
144#define RG_PE1_H_LCDDS_SSC_DELTA GENMASK(11, 0)
145#define RG_PE1_H_LCDDS_SSC_DELTA_VAL(x) ((0xfff & (x)) << 0)
146#define RG_PE1_H_LCDDS_SSC_DELTA1 GENMASK(27, 16)
147#define RG_PE1_H_LCDDS_SSC_DELTA1_VAL(x) ((0xff & (x)) << 16)
148
149#define RG_PE1_LCDDS_CLK_PH_INV_REG 0x4a0
150#define RG_PE1_LCDDS_CLK_PH_INV BIT(5)
151
152#define RG_PE1_H_PLL_BR_REG 0x4ac
153#define RG_PE1_H_PLL_BR GENMASK(18, 16)
154#define RG_PE1_H_PLL_BR_VAL(x) ((0x7 & (x)) << 16)
155
156#define RG_PE1_MSTCKDIV_REG 0x414
157#define RG_PE1_MSTCKDIV GENMASK(7, 6)
158#define RG_PE1_MSTCKDIV_VAL(x) ((0x3 & (x)) << 6)
159
160#define RG_PE1_FRC_MSTCKDIV BIT(5)
161
162
163
164
165
166
167
168
169
170
171
172struct mt7621_pcie_port {
173 void __iomem *base;
174 struct list_head list;
175 struct mt7621_pcie *pcie;
176 u32 phy_reg_offset;
177 struct reset_control *pcie_rst;
178 u32 slot;
179 bool enabled;
180};
181
182
183
184
185
186
187
188
189
190
191
192struct mt7621_pcie {
193 void __iomem *base;
194 struct device *dev;
195 struct resource io;
196 struct resource mem;
197 struct resource busn;
198 struct {
199 resource_size_t mem;
200 resource_size_t io;
201 } offset;
202 struct list_head ports;
203};
204
205static inline u32 pcie_read(struct mt7621_pcie *pcie, u32 reg)
206{
207 return readl(pcie->base + reg);
208}
209
210static inline void pcie_write(struct mt7621_pcie *pcie, u32 val, u32 reg)
211{
212 writel(val, pcie->base + reg);
213}
214
215static inline u32 pcie_port_read(struct mt7621_pcie_port *port, u32 reg)
216{
217 return readl(port->base + reg);
218}
219
220static inline void pcie_port_write(struct mt7621_pcie_port *port,
221 u32 val, u32 reg)
222{
223 writel(val, port->base + reg);
224}
225
226static inline u32 mt7621_pci_get_cfgaddr(unsigned int bus, unsigned int slot,
227 unsigned int func, unsigned int where)
228{
229 return (((where & 0xF00) >> 8) << 24) | (bus << 16) | (slot << 11) |
230 (func << 8) | (where & 0xfc) | 0x80000000;
231}
232
233static void __iomem *mt7621_pcie_map_bus(struct pci_bus *bus,
234 unsigned int devfn, int where)
235{
236 struct mt7621_pcie *pcie = bus->sysdata;
237 u32 address = mt7621_pci_get_cfgaddr(bus->number, PCI_SLOT(devfn),
238 PCI_FUNC(devfn), where);
239
240 writel(address, pcie->base + RALINK_PCI_CONFIG_ADDR);
241
242 return pcie->base + RALINK_PCI_CONFIG_DATA + (where & 3);
243}
244
245struct pci_ops mt7621_pci_ops = {
246 .map_bus = mt7621_pcie_map_bus,
247 .read = pci_generic_config_read,
248 .write = pci_generic_config_write,
249};
250
251static u32 read_config(struct mt7621_pcie *pcie, unsigned int dev, u32 reg)
252{
253 u32 address = mt7621_pci_get_cfgaddr(0, dev, 0, reg);
254
255 pcie_write(pcie, address, RALINK_PCI_CONFIG_ADDR);
256 return pcie_read(pcie, RALINK_PCI_CONFIG_DATA);
257}
258
259static void write_config(struct mt7621_pcie *pcie, unsigned int dev,
260 u32 reg, u32 val)
261{
262 u32 address = mt7621_pci_get_cfgaddr(0, dev, 0, reg);
263
264 pcie_write(pcie, address, RALINK_PCI_CONFIG_ADDR);
265 pcie_write(pcie, val, RALINK_PCI_CONFIG_DATA);
266}
267
268static void bypass_pipe_rst(struct mt7621_pcie_port *port)
269{
270 struct mt7621_pcie *pcie = port->pcie;
271 u32 phy_offset = port->phy_reg_offset;
272 u32 offset = (port->slot != 1) ?
273 phy_offset + RG_PE1_PIPE_REG :
274 phy_offset + RG_PE1_PIPE_REG + RG_P0_TO_P1_WIDTH;
275 u32 reg = pcie_read(pcie, offset);
276
277 reg &= ~(RG_PE1_PIPE_RST | RG_PE1_PIPE_CMD_FRC);
278 reg |= (RG_PE1_PIPE_RST | RG_PE1_PIPE_CMD_FRC);
279 pcie_write(pcie, reg, offset);
280}
281
282static void set_phy_for_ssc(struct mt7621_pcie_port *port)
283{
284 struct mt7621_pcie *pcie = port->pcie;
285 struct device *dev = pcie->dev;
286 u32 phy_offset = port->phy_reg_offset;
287 u32 reg = rt_sysc_r32(SYSC_REG_SYSTEM_CONFIG0);
288 u32 offset;
289 u32 val;
290
291 reg = (reg >> 6) & 0x7;
292
293
294 offset = phy_offset + RG_PE1_FRC_H_XTAL_REG;
295 val = pcie_read(pcie, offset);
296 val &= ~(RG_PE1_FRC_H_XTAL_TYPE | RG_PE1_H_XTAL_TYPE);
297 val |= RG_PE1_FRC_H_XTAL_TYPE;
298 val |= RG_PE1_H_XTAL_TYPE_VAL(0x00);
299 pcie_write(pcie, val, offset);
300
301
302 offset = (port->slot != 1) ?
303 phy_offset + RG_PE1_FRC_PHY_REG :
304 phy_offset + RG_PE1_FRC_PHY_REG + RG_P0_TO_P1_WIDTH;
305 val = pcie_read(pcie, offset);
306 val &= ~(RG_PE1_FRC_PHY_EN | RG_PE1_PHY_EN);
307 val |= RG_PE1_FRC_PHY_EN;
308 pcie_write(pcie, val, offset);
309
310
311 offset = phy_offset + RG_PE1_H_PLL_REG;
312 val = pcie_read(pcie, offset);
313 val &= ~(RG_PE1_H_PLL_PREDIV);
314
315 if (reg <= 5 && reg >= 3) {
316 val |= RG_PE1_H_PLL_PREDIV_VAL(0x01);
317 pcie_write(pcie, val, offset);
318 dev_info(dev, "Xtal is 40MHz\n");
319 } else {
320 val |= RG_PE1_H_PLL_PREDIV_VAL(0x00);
321 pcie_write(pcie, val, offset);
322 if (reg >= 6) {
323 dev_info(dev, "Xtal is 25MHz\n");
324
325
326 offset = phy_offset + RG_PE1_H_PLL_FBKSEL_REG;
327 val = pcie_read(pcie, offset);
328 val &= ~(RG_PE1_H_PLL_FBKSEL);
329 val |= RG_PE1_H_PLL_FBKSEL_VAL(0x01);
330 pcie_write(pcie, val, offset);
331
332
333 offset = phy_offset + RG_PE1_H_LCDDS_SSC_PRD_REG;
334 val = pcie_read(pcie, offset);
335 val &= ~(RG_PE1_H_LCDDS_SSC_PRD);
336 val |= RG_PE1_H_LCDDS_SSC_PRD_VAL(0x18000000);
337 pcie_write(pcie, val, offset);
338
339
340 offset = phy_offset + RG_PE1_H_LCDDS_SSC_PRD_REG;
341 val = pcie_read(pcie, offset);
342 val &= ~(RG_PE1_H_LCDDS_SSC_PRD);
343 val |= RG_PE1_H_LCDDS_SSC_PRD_VAL(0x18d);
344 pcie_write(pcie, val, offset);
345
346
347 offset = phy_offset + RG_PE1_H_LCDDS_SSC_DELTA_REG;
348 val = pcie_read(pcie, offset);
349 val &= ~(RG_PE1_H_LCDDS_SSC_DELTA |
350 RG_PE1_H_LCDDS_SSC_DELTA1);
351 val |= RG_PE1_H_LCDDS_SSC_DELTA_VAL(0x4a);
352 val |= RG_PE1_H_LCDDS_SSC_DELTA1_VAL(0x4a);
353 pcie_write(pcie, val, offset);
354 } else {
355 dev_info(dev, "Xtal is 20MHz\n");
356 }
357 }
358
359
360 offset = phy_offset + RG_PE1_LCDDS_CLK_PH_INV_REG;
361 val = pcie_read(pcie, offset);
362 val &= ~(RG_PE1_LCDDS_CLK_PH_INV);
363 val |= RG_PE1_LCDDS_CLK_PH_INV;
364 pcie_write(pcie, val, offset);
365
366
367 offset = phy_offset + RG_PE1_H_PLL_REG;
368 val = pcie_read(pcie, offset);
369 val &= ~(RG_PE1_H_PLL_BC | RG_PE1_H_PLL_BP | RG_PE1_H_PLL_IR |
370 RG_PE1_H_PLL_IC | RG_PE1_PLL_DIVEN);
371 val |= RG_PE1_H_PLL_BC_VAL(0x02);
372 val |= RG_PE1_H_PLL_BP_VAL(0x06);
373 val |= RG_PE1_H_PLL_IR_VAL(0x02);
374 val |= RG_PE1_H_PLL_IC_VAL(0x01);
375 val |= RG_PE1_PLL_DIVEN_VAL(0x02);
376 pcie_write(pcie, val, offset);
377
378 offset = phy_offset + RG_PE1_H_PLL_BR_REG;
379 val = pcie_read(pcie, offset);
380 val &= ~(RG_PE1_H_PLL_BR);
381 val |= RG_PE1_H_PLL_BR_VAL(0x00);
382 pcie_write(pcie, val, offset);
383
384 if (reg <= 5 && reg >= 3) {
385
386 offset = phy_offset + RG_PE1_MSTCKDIV_REG;
387 val = pcie_read(pcie, offset);
388 val &= ~(RG_PE1_MSTCKDIV | RG_PE1_FRC_MSTCKDIV);
389 val |= (RG_PE1_MSTCKDIV_VAL(0x01) | RG_PE1_FRC_MSTCKDIV);
390 pcie_write(pcie, val, offset);
391 }
392
393
394 offset = (port->slot != 1) ?
395 phy_offset + RG_PE1_FRC_PHY_REG :
396 phy_offset + RG_PE1_FRC_PHY_REG + RG_P0_TO_P1_WIDTH;
397 val = pcie_read(pcie, offset);
398 val &= ~(RG_PE1_FRC_PHY_EN | RG_PE1_PHY_EN);
399 val |= (RG_PE1_FRC_PHY_EN | RG_PE1_PHY_EN);
400 pcie_write(pcie, val, offset);
401}
402
403static void mt7621_enable_phy(struct mt7621_pcie_port *port)
404{
405 u32 chip_rev_id = rt_sysc_r32(MT7621_CHIP_REV_ID);
406
407 if ((chip_rev_id & 0xFFFF) == CHIP_REV_MT7621_E2)
408 bypass_pipe_rst(port);
409 set_phy_for_ssc(port);
410}
411
412static inline void mt7621_control_assert(struct mt7621_pcie_port *port)
413{
414 u32 chip_rev_id = rt_sysc_r32(MT7621_CHIP_REV_ID);
415
416 if ((chip_rev_id & 0xFFFF) == CHIP_REV_MT7621_E2)
417 reset_control_assert(port->pcie_rst);
418 else
419 reset_control_deassert(port->pcie_rst);
420}
421
422static inline void mt7621_control_deassert(struct mt7621_pcie_port *port)
423{
424 u32 chip_rev_id = rt_sysc_r32(MT7621_CHIP_REV_ID);
425
426 if ((chip_rev_id & 0xFFFF) == CHIP_REV_MT7621_E2)
427 reset_control_deassert(port->pcie_rst);
428 else
429 reset_control_assert(port->pcie_rst);
430}
431
432static void mt7621_reset_port(struct mt7621_pcie_port *port)
433{
434 mt7621_control_assert(port);
435 msleep(100);
436 mt7621_control_deassert(port);
437}
438
439static void setup_cm_memory_region(struct mt7621_pcie *pcie)
440{
441 struct resource *mem_resource = &pcie->mem;
442 struct device *dev = pcie->dev;
443 resource_size_t mask;
444
445 if (mips_cps_numiocu(0)) {
446
447
448
449
450
451 mask = ~(mem_resource->end - mem_resource->start);
452
453 write_gcr_reg1_base(mem_resource->start);
454 write_gcr_reg1_mask(mask | CM_GCR_REGn_MASK_CMTGT_IOCU0);
455 dev_info(dev, "PCI coherence region base: 0x%08llx, mask/settings: 0x%08llx\n",
456 (unsigned long long)read_gcr_reg1_base(),
457 (unsigned long long)read_gcr_reg1_mask());
458 }
459}
460
461static int mt7621_pci_parse_request_of_pci_ranges(struct mt7621_pcie *pcie)
462{
463 struct device *dev = pcie->dev;
464 struct device_node *node = dev->of_node;
465 struct of_pci_range_parser parser;
466 struct of_pci_range range;
467 int err;
468
469 if (of_pci_range_parser_init(&parser, node)) {
470 dev_err(dev, "missing \"ranges\" property\n");
471 return -EINVAL;
472 }
473
474 for_each_of_pci_range(&parser, &range) {
475 struct resource *res = NULL;
476
477 switch (range.flags & IORESOURCE_TYPE_BITS) {
478 case IORESOURCE_IO:
479 ioremap(range.cpu_addr, range.size);
480 res = &pcie->io;
481 pcie->offset.io = 0x00000000UL;
482 break;
483 case IORESOURCE_MEM:
484 res = &pcie->mem;
485 pcie->offset.mem = 0x00000000UL;
486 break;
487 }
488
489 if (res != NULL)
490 of_pci_range_to_resource(&range, node, res);
491 }
492
493 err = of_pci_parse_bus_range(node, &pcie->busn);
494 if (err < 0) {
495 dev_err(dev, "failed to parse bus ranges property: %d\n", err);
496 pcie->busn.name = node->name;
497 pcie->busn.start = 0;
498 pcie->busn.end = 0xff;
499 pcie->busn.flags = IORESOURCE_BUS;
500 }
501
502 return 0;
503}
504
505static int mt7621_pcie_parse_port(struct mt7621_pcie *pcie,
506 struct device_node *node,
507 int slot)
508{
509 struct mt7621_pcie_port *port;
510 struct device *dev = pcie->dev;
511 struct device_node *pnode = dev->of_node;
512 struct resource regs;
513 char name[6];
514 int err;
515
516 port = devm_kzalloc(dev, sizeof(*port), GFP_KERNEL);
517 if (!port)
518 return -ENOMEM;
519
520 err = of_address_to_resource(pnode, slot + 1, ®s);
521 if (err) {
522 dev_err(dev, "missing \"reg\" property\n");
523 return err;
524 }
525
526 port->base = devm_ioremap_resource(dev, ®s);
527 if (IS_ERR(port->base))
528 return PTR_ERR(port->base);
529
530 snprintf(name, sizeof(name), "pcie%d", slot);
531 port->pcie_rst = devm_reset_control_get_exclusive(dev, name);
532 if (PTR_ERR(port->pcie_rst) == -EPROBE_DEFER) {
533 dev_err(dev, "failed to get pcie%d reset control\n", slot);
534 return PTR_ERR(port->pcie_rst);
535 }
536
537 port->slot = slot;
538 port->pcie = pcie;
539 port->phy_reg_offset = (slot != 2) ?
540 RALINK_PCIEPHY_P0P1_CTL_OFFSET :
541 RALINK_PCIEPHY_P2_CTL_OFFSET;
542
543 INIT_LIST_HEAD(&port->list);
544 list_add_tail(&port->list, &pcie->ports);
545
546 return 0;
547}
548
549static int mt7621_pcie_parse_dt(struct mt7621_pcie *pcie)
550{
551 struct device *dev = pcie->dev;
552 struct device_node *node = dev->of_node, *child;
553 struct resource regs;
554 int err;
555
556 err = of_address_to_resource(node, 0, ®s);
557 if (err) {
558 dev_err(dev, "missing \"reg\" property\n");
559 return err;
560 }
561
562 pcie->base = devm_ioremap_resource(dev, ®s);
563 if (IS_ERR(pcie->base))
564 return PTR_ERR(pcie->base);
565
566 for_each_available_child_of_node(node, child) {
567 int slot;
568
569 err = of_pci_get_devfn(child);
570 if (err < 0) {
571 dev_err(dev, "failed to parse devfn: %d\n", err);
572 return err;
573 }
574
575 slot = PCI_SLOT(err);
576
577 err = mt7621_pcie_parse_port(pcie, child, slot);
578 if (err)
579 return err;
580 }
581
582 return 0;
583}
584
585static int mt7621_pcie_init_port(struct mt7621_pcie_port *port)
586{
587 struct mt7621_pcie *pcie = port->pcie;
588 struct device *dev = pcie->dev;
589 u32 slot = port->slot;
590 u32 val = 0;
591
592
593
594
595
596 mt7621_reset_port(port);
597
598 val = read_config(pcie, slot, PCIE_FTS_NUM);
599 dev_info(dev, "Port %d N_FTS = %x\n", (unsigned int)val, slot);
600
601 if ((pcie_port_read(port, RALINK_PCI_STATUS) & PCIE_PORT_LINKUP) == 0) {
602 dev_err(dev, "pcie%d no card, disable it (RST & CLK)\n", slot);
603 mt7621_control_assert(port);
604 rt_sysc_m32(PCIE_PORT_CLK_EN(slot), 0, RALINK_CLKCFG1);
605 port->enabled = false;
606 } else {
607 port->enabled = true;
608 }
609
610 mt7621_enable_phy(port);
611
612 return 0;
613}
614
615static void mt7621_pcie_init_ports(struct mt7621_pcie *pcie)
616{
617 struct device *dev = pcie->dev;
618 struct mt7621_pcie_port *port, *tmp;
619 int err;
620
621 list_for_each_entry_safe(port, tmp, &pcie->ports, list) {
622 u32 slot = port->slot;
623
624 err = mt7621_pcie_init_port(port);
625 if (err) {
626 dev_err(dev, "Initiating port %d failed\n", slot);
627 list_del(&port->list);
628 }
629 }
630
631 rt_sysc_m32(0, RALINK_PCIE_RST, RALINK_RSTCTRL);
632 rt_sysc_m32(0x30, 2 << 4, SYSC_REG_SYSTEM_CONFIG1);
633 rt_sysc_m32(PCIE_CLK_GEN_EN, PCIE_CLK_GEN_DIS, RALINK_PCIE_CLK_GEN);
634 rt_sysc_m32(PCIE_CLK_GEN1_DIS, PCIE_CLK_GEN1_EN, RALINK_PCIE_CLK_GEN1);
635 rt_sysc_m32(PCIE_CLK_GEN_DIS, PCIE_CLK_GEN_EN, RALINK_PCIE_CLK_GEN);
636 msleep(50);
637 rt_sysc_m32(RALINK_PCIE_RST, 0, RALINK_RSTCTRL);
638}
639
640static int mt7621_pcie_enable_port(struct mt7621_pcie_port *port)
641{
642 struct mt7621_pcie *pcie = port->pcie;
643 u32 slot = port->slot;
644 u32 offset = MT7621_PCIE_OFFSET + (slot * MT7621_NEXT_PORT);
645 u32 val;
646 int err;
647
648
649 val = pcie_read(pcie, RALINK_PCI_PCICFG_ADDR);
650 val |= PCIE_PORT_PERST(slot);
651 pcie_write(pcie, val, RALINK_PCI_PCICFG_ADDR);
652
653
654 val = pcie_read(pcie, RALINK_PCI_PCICFG_ADDR);
655 val &= ~PCIE_PORT_PERST(slot);
656 pcie_write(pcie, val, RALINK_PCI_PCICFG_ADDR);
657
658
659 err = readl_poll_timeout(port->base + RALINK_PCI_STATUS,
660 val, !!(val & PCIE_PORT_LINKUP),
661 20, 100 * USEC_PER_MSEC);
662 if (err)
663 return -ETIMEDOUT;
664
665
666 val = pcie_read(pcie, RALINK_PCI_PCIMSK_ADDR);
667 val |= PCIE_PORT_INT_EN(slot);
668 pcie_write(pcie, val, RALINK_PCI_PCIMSK_ADDR);
669
670
671 pcie_write(pcie, PCIE_BAR_MAP_MAX | PCIE_BAR_ENABLE,
672 offset + RALINK_PCI_BAR0SETUP_ADDR);
673 pcie_write(pcie, MEMORY_BASE,
674 offset + RALINK_PCI_IMBASEBAR0_ADDR);
675
676
677 pcie_write(pcie, PCIE_CLASS_CODE | PCIE_REVISION_ID,
678 offset + RALINK_PCI_CLASS);
679
680 return 0;
681}
682
683static void mt7621_pcie_enable_ports(struct mt7621_pcie *pcie)
684{
685 struct device *dev = pcie->dev;
686 struct mt7621_pcie_port *port;
687 u8 num_slots_enabled = 0;
688 u32 slot;
689 u32 val;
690
691 list_for_each_entry(port, &pcie->ports, list) {
692 if (port->enabled) {
693 if (!mt7621_pcie_enable_port(port)) {
694 dev_err(dev, "de-assert port %d PERST_N\n",
695 port->slot);
696 continue;
697 }
698 dev_info(dev, "PCIE%d enabled\n", slot);
699 num_slots_enabled++;
700 }
701 }
702
703 for (slot = 0; slot < num_slots_enabled; slot++) {
704 val = read_config(pcie, slot, 0x4);
705 write_config(pcie, slot, 0x4, val | 0x4);
706
707 val = read_config(pcie, slot, PCIE_FTS_NUM);
708 val &= ~PCIE_FTS_NUM_MASK;
709 val |= PCIE_FTS_NUM_L0(0x50);
710 write_config(pcie, slot, PCIE_FTS_NUM, val);
711 }
712}
713
714static int mt7621_pcie_init_virtual_bridges(struct mt7621_pcie *pcie)
715{
716 u32 pcie_link_status = 0;
717 u32 val= 0;
718 struct mt7621_pcie_port *port;
719
720 list_for_each_entry(port, &pcie->ports, list) {
721 u32 slot = port->slot;
722
723 if (port->enabled)
724 pcie_link_status |= BIT(slot);
725 }
726
727 if (pcie_link_status == 0)
728 return -1;
729
730
731
732
733
734
735
736
737
738
739
740
741 switch (pcie_link_status) {
742 case 2:
743 val = pcie_read(pcie, RALINK_PCI_PCICFG_ADDR);
744 val &= ~(MT7621_BR0_MASK | MT7621_BR1_MASK);
745 val |= 0x1 << MT7621_BR0_SHIFT;
746 val |= 0x0 << MT7621_BR1_SHIFT;
747 pcie_write(pcie, val, RALINK_PCI_PCICFG_ADDR);
748 break;
749 case 4:
750 val = pcie_read(pcie, RALINK_PCI_PCICFG_ADDR);
751 val &= ~MT7621_BR_ALL_MASK;
752 val |= 0x1 << MT7621_BR0_SHIFT;
753 val |= 0x2 << MT7621_BR1_SHIFT;
754 val |= 0x0 << MT7621_BR2_SHIFT;
755 pcie_write(pcie, val, RALINK_PCI_PCICFG_ADDR);
756 break;
757 case 5:
758 val = pcie_read(pcie, RALINK_PCI_PCICFG_ADDR);
759 val &= ~MT7621_BR_ALL_MASK;
760 val |= 0x0 << MT7621_BR0_SHIFT;
761 val |= 0x2 << MT7621_BR1_SHIFT;
762 val |= 0x1 << MT7621_BR2_SHIFT;
763 pcie_write(pcie, val, RALINK_PCI_PCICFG_ADDR);
764 break;
765 case 6:
766 val = pcie_read(pcie, RALINK_PCI_PCICFG_ADDR);
767 val &= ~MT7621_BR_ALL_MASK;
768 val |= 0x2 << MT7621_BR0_SHIFT;
769 val |= 0x0 << MT7621_BR1_SHIFT;
770 val |= 0x1 << MT7621_BR2_SHIFT;
771 pcie_write(pcie, val, RALINK_PCI_PCICFG_ADDR);
772 break;
773 }
774
775 return 0;
776}
777
778static int mt7621_pcie_request_resources(struct mt7621_pcie *pcie,
779 struct list_head *res)
780{
781 struct device *dev = pcie->dev;
782 int err;
783
784 pci_add_resource_offset(res, &pcie->io, pcie->offset.io);
785 pci_add_resource_offset(res, &pcie->mem, pcie->offset.mem);
786 pci_add_resource(res, &pcie->busn);
787
788 err = devm_request_pci_bus_resources(dev, res);
789 if (err < 0)
790 return err;
791
792 return 0;
793}
794
795static int mt7621_pcie_register_host(struct pci_host_bridge *host,
796 struct list_head *res)
797{
798 struct mt7621_pcie *pcie = pci_host_bridge_priv(host);
799
800 list_splice_init(res, &host->windows);
801 host->busnr = pcie->busn.start;
802 host->dev.parent = pcie->dev;
803 host->ops = &mt7621_pci_ops;
804 host->map_irq = of_irq_parse_and_map_pci;
805 host->swizzle_irq = pci_common_swizzle;
806 host->sysdata = pcie;
807
808 return pci_host_probe(host);
809}
810
811static int mt7621_pci_probe(struct platform_device *pdev)
812{
813 struct device *dev = &pdev->dev;
814 struct mt7621_pcie *pcie;
815 struct pci_host_bridge *bridge;
816 int err;
817 LIST_HEAD(res);
818
819 if (!dev->of_node)
820 return -ENODEV;
821
822 bridge = devm_pci_alloc_host_bridge(dev, sizeof(*pcie));
823 if (!bridge)
824 return -ENOMEM;
825
826 pcie = pci_host_bridge_priv(bridge);
827 pcie->dev = dev;
828 platform_set_drvdata(pdev, pcie);
829 INIT_LIST_HEAD(&pcie->ports);
830
831 err = mt7621_pcie_parse_dt(pcie);
832 if (err) {
833 dev_err(dev, "Parsing DT failed\n");
834 return err;
835 }
836
837
838 iomem_resource.start = 0;
839 iomem_resource.end = ~0UL;
840 ioport_resource.start = 0;
841 ioport_resource.end = ~0UL;
842
843 mt7621_pcie_init_ports(pcie);
844
845 err = mt7621_pcie_init_virtual_bridges(pcie);
846 if (err) {
847 dev_err(dev, "Nothing is connected in virtual bridges. Exiting...");
848 return 0;
849 }
850
851 pcie_write(pcie, 0xffffffff, RALINK_PCI_MEMBASE);
852 pcie_write(pcie, RALINK_PCI_IO_MAP_BASE, RALINK_PCI_IOBASE);
853
854 mt7621_pcie_enable_ports(pcie);
855
856 err = mt7621_pci_parse_request_of_pci_ranges(pcie);
857 if (err) {
858 dev_err(dev, "Error requesting pci resources from ranges");
859 return err;
860 }
861
862 setup_cm_memory_region(pcie);
863
864 err = mt7621_pcie_request_resources(pcie, &res);
865 if (err) {
866 dev_err(dev, "Error requesting resources\n");
867 return err;
868 }
869
870 err = mt7621_pcie_register_host(bridge, &res);
871 if (err) {
872 dev_err(dev, "Error registering host\n");
873 return err;
874 }
875
876 return 0;
877}
878
879static const struct of_device_id mt7621_pci_ids[] = {
880 { .compatible = "mediatek,mt7621-pci" },
881 {},
882};
883MODULE_DEVICE_TABLE(of, mt7621_pci_ids);
884
885static struct platform_driver mt7621_pci_driver = {
886 .probe = mt7621_pci_probe,
887 .driver = {
888 .name = "mt7621-pci",
889 .of_match_table = of_match_ptr(mt7621_pci_ids),
890 },
891};
892
893static int __init mt7621_pci_init(void)
894{
895 return platform_driver_register(&mt7621_pci_driver);
896}
897
898arch_initcall(mt7621_pci_init);
899