1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Support for Faraday Technology FTPC100 PCI Controller
4  *
5  * Copyright (C) 2017 Linus Walleij <linus.walleij@linaro.org>
6  *
7  * Based on the out-of-tree OpenWRT patch for Cortina Gemini:
8  * Copyright (C) 2009 Janos Laube <janos.dev@gmail.com>
9  * Copyright (C) 2009 Paulius Zaleckas <paulius.zaleckas@teltonika.lt>
10  * Based on SL2312 PCI controller code
11  * Storlink (C) 2003
12  */
13 
14 #include <linux/init.h>
15 #include <linux/interrupt.h>
16 #include <linux/io.h>
17 #include <linux/kernel.h>
18 #include <linux/of_address.h>
19 #include <linux/of_device.h>
20 #include <linux/of_irq.h>
21 #include <linux/of_pci.h>
22 #include <linux/pci.h>
23 #include <linux/platform_device.h>
24 #include <linux/slab.h>
25 #include <linux/irqdomain.h>
26 #include <linux/irqchip/chained_irq.h>
27 #include <linux/bitops.h>
28 #include <linux/irq.h>
29 #include <linux/clk.h>
30 
31 #include "../pci.h"
32 
33 /*
34  * Special configuration registers directly in the first few words
35  * in I/O space.
36  */
37 #define PCI_IOSIZE	0x00
38 #define PCI_PROT	0x04 /* AHB protection */
39 #define PCI_CTRL	0x08 /* PCI control signal */
40 #define PCI_SOFTRST	0x10 /* Soft reset counter and response error enable */
41 #define PCI_CONFIG	0x28 /* PCI configuration command register */
42 #define PCI_DATA	0x2C
43 
44 #define FARADAY_PCI_STATUS_CMD		0x04 /* Status and command */
45 #define FARADAY_PCI_PMC			0x40 /* Power management control */
46 #define FARADAY_PCI_PMCSR		0x44 /* Power management status */
47 #define FARADAY_PCI_CTRL1		0x48 /* Control register 1 */
48 #define FARADAY_PCI_CTRL2		0x4C /* Control register 2 */
49 #define FARADAY_PCI_MEM1_BASE_SIZE	0x50 /* Memory base and size #1 */
50 #define FARADAY_PCI_MEM2_BASE_SIZE	0x54 /* Memory base and size #2 */
51 #define FARADAY_PCI_MEM3_BASE_SIZE	0x58 /* Memory base and size #3 */
52 
53 #define PCI_STATUS_66MHZ_CAPABLE	BIT(21)
54 
55 /* Bits 31..28 gives INTD..INTA status */
56 #define PCI_CTRL2_INTSTS_SHIFT		28
57 #define PCI_CTRL2_INTMASK_CMDERR	BIT(27)
58 #define PCI_CTRL2_INTMASK_PARERR	BIT(26)
59 /* Bits 25..22 masks INTD..INTA */
60 #define PCI_CTRL2_INTMASK_SHIFT		22
61 #define PCI_CTRL2_INTMASK_MABRT_RX	BIT(21)
62 #define PCI_CTRL2_INTMASK_TABRT_RX	BIT(20)
63 #define PCI_CTRL2_INTMASK_TABRT_TX	BIT(19)
64 #define PCI_CTRL2_INTMASK_RETRY4	BIT(18)
65 #define PCI_CTRL2_INTMASK_SERR_RX	BIT(17)
66 #define PCI_CTRL2_INTMASK_PERR_RX	BIT(16)
67 /* Bit 15 reserved */
68 #define PCI_CTRL2_MSTPRI_REQ6		BIT(14)
69 #define PCI_CTRL2_MSTPRI_REQ5		BIT(13)
70 #define PCI_CTRL2_MSTPRI_REQ4		BIT(12)
71 #define PCI_CTRL2_MSTPRI_REQ3		BIT(11)
72 #define PCI_CTRL2_MSTPRI_REQ2		BIT(10)
73 #define PCI_CTRL2_MSTPRI_REQ1		BIT(9)
74 #define PCI_CTRL2_MSTPRI_REQ0		BIT(8)
75 /* Bits 7..4 reserved */
76 /* Bits 3..0 TRDYW */
77 
78 /*
79  * Memory configs:
80  * Bit 31..20 defines the PCI side memory base
81  * Bit 19..16 (4 bits) defines the size per below
82  */
83 #define FARADAY_PCI_MEMBASE_MASK	0xfff00000
84 #define FARADAY_PCI_MEMSIZE_1MB		0x0
85 #define FARADAY_PCI_MEMSIZE_2MB		0x1
86 #define FARADAY_PCI_MEMSIZE_4MB		0x2
87 #define FARADAY_PCI_MEMSIZE_8MB		0x3
88 #define FARADAY_PCI_MEMSIZE_16MB	0x4
89 #define FARADAY_PCI_MEMSIZE_32MB	0x5
90 #define FARADAY_PCI_MEMSIZE_64MB	0x6
91 #define FARADAY_PCI_MEMSIZE_128MB	0x7
92 #define FARADAY_PCI_MEMSIZE_256MB	0x8
93 #define FARADAY_PCI_MEMSIZE_512MB	0x9
94 #define FARADAY_PCI_MEMSIZE_1GB		0xa
95 #define FARADAY_PCI_MEMSIZE_2GB		0xb
96 #define FARADAY_PCI_MEMSIZE_SHIFT	16
97 
98 /*
99  * The DMA base is set to 0x0 for all memory segments, it reflects the
100  * fact that the memory of the host system starts at 0x0.
101  */
102 #define FARADAY_PCI_DMA_MEM1_BASE	0x00000000
103 #define FARADAY_PCI_DMA_MEM2_BASE	0x00000000
104 #define FARADAY_PCI_DMA_MEM3_BASE	0x00000000
105 
106 /* Defines for PCI configuration command register */
107 #define PCI_CONF_ENABLE		BIT(31)
108 #define PCI_CONF_WHERE(r)	((r) & 0xFC)
109 #define PCI_CONF_BUS(b)		(((b) & 0xFF) << 16)
110 #define PCI_CONF_DEVICE(d)	(((d) & 0x1F) << 11)
111 #define PCI_CONF_FUNCTION(f)	(((f) & 0x07) << 8)
112 
113 /**
114  * struct faraday_pci_variant - encodes IP block differences
115  * @cascaded_irq: this host has cascaded IRQs from an interrupt controller
116  *	embedded in the host bridge.
117  */
118 struct faraday_pci_variant {
119 	bool cascaded_irq;
120 };
121 
122 struct faraday_pci {
123 	struct device *dev;
124 	void __iomem *base;
125 	struct irq_domain *irqdomain;
126 	struct pci_bus *bus;
127 	struct clk *bus_clk;
128 };
129 
130 static int faraday_res_to_memcfg(resource_size_t mem_base,
131 				 resource_size_t mem_size, u32 *val)
132 {
133 	u32 outval;
134 
135 	switch (mem_size) {
136 	case SZ_1M:
137 		outval = FARADAY_PCI_MEMSIZE_1MB;
138 		break;
139 	case SZ_2M:
140 		outval = FARADAY_PCI_MEMSIZE_2MB;
141 		break;
142 	case SZ_4M:
143 		outval = FARADAY_PCI_MEMSIZE_4MB;
144 		break;
145 	case SZ_8M:
146 		outval = FARADAY_PCI_MEMSIZE_8MB;
147 		break;
148 	case SZ_16M:
149 		outval = FARADAY_PCI_MEMSIZE_16MB;
150 		break;
151 	case SZ_32M:
152 		outval = FARADAY_PCI_MEMSIZE_32MB;
153 		break;
154 	case SZ_64M:
155 		outval = FARADAY_PCI_MEMSIZE_64MB;
156 		break;
157 	case SZ_128M:
158 		outval = FARADAY_PCI_MEMSIZE_128MB;
159 		break;
160 	case SZ_256M:
161 		outval = FARADAY_PCI_MEMSIZE_256MB;
162 		break;
163 	case SZ_512M:
164 		outval = FARADAY_PCI_MEMSIZE_512MB;
165 		break;
166 	case SZ_1G:
167 		outval = FARADAY_PCI_MEMSIZE_1GB;
168 		break;
169 	case SZ_2G:
170 		outval = FARADAY_PCI_MEMSIZE_2GB;
171 		break;
172 	default:
173 		return -EINVAL;
174 	}
175 	outval <<= FARADAY_PCI_MEMSIZE_SHIFT;
176 
177 	/* This is probably not good */
178 	if (mem_base & ~(FARADAY_PCI_MEMBASE_MASK))
179 		pr_warn("truncated PCI memory base\n");
180 	/* Translate to bridge side address space */
181 	outval |= (mem_base & FARADAY_PCI_MEMBASE_MASK);
182 	pr_debug("Translated pci base @%pap, size %pap to config %08x\n",
183 		 &mem_base, &mem_size, outval);
184 
185 	*val = outval;
186 	return 0;
187 }
188 
189 static int faraday_raw_pci_read_config(struct faraday_pci *p, int bus_number,
190 				       unsigned int fn, int config, int size,
191 				       u32 *value)
192 {
193 	writel(PCI_CONF_BUS(bus_number) |
194 			PCI_CONF_DEVICE(PCI_SLOT(fn)) |
195 			PCI_CONF_FUNCTION(PCI_FUNC(fn)) |
196 			PCI_CONF_WHERE(config) |
197 			PCI_CONF_ENABLE,
198 			p->base + PCI_CONFIG);
199 
200 	*value = readl(p->base + PCI_DATA);
201 
202 	if (size == 1)
203 		*value = (*value >> (8 * (config & 3))) & 0xFF;
204 	else if (size == 2)
205 		*value = (*value >> (8 * (config & 3))) & 0xFFFF;
206 
207 	return PCIBIOS_SUCCESSFUL;
208 }
209 
210 static int faraday_pci_read_config(struct pci_bus *bus, unsigned int fn,
211 				   int config, int size, u32 *value)
212 {
213 	struct faraday_pci *p = bus->sysdata;
214 
215 	dev_dbg(&bus->dev,
216 		"[read]  slt: %.2d, fnc: %d, cnf: 0x%.2X, val (%d bytes): 0x%.8X\n",
217 		PCI_SLOT(fn), PCI_FUNC(fn), config, size, *value);
218 
219 	return faraday_raw_pci_read_config(p, bus->number, fn, config, size, value);
220 }
221 
222 static int faraday_raw_pci_write_config(struct faraday_pci *p, int bus_number,
223 					 unsigned int fn, int config, int size,
224 					 u32 value)
225 {
226 	int ret = PCIBIOS_SUCCESSFUL;
227 
228 	writel(PCI_CONF_BUS(bus_number) |
229 			PCI_CONF_DEVICE(PCI_SLOT(fn)) |
230 			PCI_CONF_FUNCTION(PCI_FUNC(fn)) |
231 			PCI_CONF_WHERE(config) |
232 			PCI_CONF_ENABLE,
233 			p->base + PCI_CONFIG);
234 
235 	switch (size) {
236 	case 4:
237 		writel(value, p->base + PCI_DATA);
238 		break;
239 	case 2:
240 		writew(value, p->base + PCI_DATA + (config & 3));
241 		break;
242 	case 1:
243 		writeb(value, p->base + PCI_DATA + (config & 3));
244 		break;
245 	default:
246 		ret = PCIBIOS_BAD_REGISTER_NUMBER;
247 	}
248 
249 	return ret;
250 }
251 
252 static int faraday_pci_write_config(struct pci_bus *bus, unsigned int fn,
253 				    int config, int size, u32 value)
254 {
255 	struct faraday_pci *p = bus->sysdata;
256 
257 	dev_dbg(&bus->dev,
258 		"[write] slt: %.2d, fnc: %d, cnf: 0x%.2X, val (%d bytes): 0x%.8X\n",
259 		PCI_SLOT(fn), PCI_FUNC(fn), config, size, value);
260 
261 	return faraday_raw_pci_write_config(p, bus->number, fn, config, size,
262 					    value);
263 }
264 
265 static struct pci_ops faraday_pci_ops = {
266 	.read	= faraday_pci_read_config,
267 	.write	= faraday_pci_write_config,
268 };
269 
270 static void faraday_pci_ack_irq(struct irq_data *d)
271 {
272 	struct faraday_pci *p = irq_data_get_irq_chip_data(d);
273 	unsigned int reg;
274 
275 	faraday_raw_pci_read_config(p, 0, 0, FARADAY_PCI_CTRL2, 4, &reg);
276 	reg &= ~(0xF << PCI_CTRL2_INTSTS_SHIFT);
277 	reg |= BIT(irqd_to_hwirq(d) + PCI_CTRL2_INTSTS_SHIFT);
278 	faraday_raw_pci_write_config(p, 0, 0, FARADAY_PCI_CTRL2, 4, reg);
279 }
280 
281 static void faraday_pci_mask_irq(struct irq_data *d)
282 {
283 	struct faraday_pci *p = irq_data_get_irq_chip_data(d);
284 	unsigned int reg;
285 
286 	faraday_raw_pci_read_config(p, 0, 0, FARADAY_PCI_CTRL2, 4, &reg);
287 	reg &= ~((0xF << PCI_CTRL2_INTSTS_SHIFT)
288 		 | BIT(irqd_to_hwirq(d) + PCI_CTRL2_INTMASK_SHIFT));
289 	faraday_raw_pci_write_config(p, 0, 0, FARADAY_PCI_CTRL2, 4, reg);
290 }
291 
292 static void faraday_pci_unmask_irq(struct irq_data *d)
293 {
294 	struct faraday_pci *p = irq_data_get_irq_chip_data(d);
295 	unsigned int reg;
296 
297 	faraday_raw_pci_read_config(p, 0, 0, FARADAY_PCI_CTRL2, 4, &reg);
298 	reg &= ~(0xF << PCI_CTRL2_INTSTS_SHIFT);
299 	reg |= BIT(irqd_to_hwirq(d) + PCI_CTRL2_INTMASK_SHIFT);
300 	faraday_raw_pci_write_config(p, 0, 0, FARADAY_PCI_CTRL2, 4, reg);
301 }
302 
303 static void faraday_pci_irq_handler(struct irq_desc *desc)
304 {
305 	struct faraday_pci *p = irq_desc_get_handler_data(desc);
306 	struct irq_chip *irqchip = irq_desc_get_chip(desc);
307 	unsigned int irq_stat, reg, i;
308 
309 	faraday_raw_pci_read_config(p, 0, 0, FARADAY_PCI_CTRL2, 4, &reg);
310 	irq_stat = reg >> PCI_CTRL2_INTSTS_SHIFT;
311 
312 	chained_irq_enter(irqchip, desc);
313 
314 	for (i = 0; i < 4; i++) {
315 		if ((irq_stat & BIT(i)) == 0)
316 			continue;
317 		generic_handle_irq(irq_find_mapping(p->irqdomain, i));
318 	}
319 
320 	chained_irq_exit(irqchip, desc);
321 }
322 
323 static struct irq_chip faraday_pci_irq_chip = {
324 	.name = "PCI",
325 	.irq_ack = faraday_pci_ack_irq,
326 	.irq_mask = faraday_pci_mask_irq,
327 	.irq_unmask = faraday_pci_unmask_irq,
328 };
329 
330 static int faraday_pci_irq_map(struct irq_domain *domain, unsigned int irq,
331 			       irq_hw_number_t hwirq)
332 {
333 	irq_set_chip_and_handler(irq, &faraday_pci_irq_chip, handle_level_irq);
334 	irq_set_chip_data(irq, domain->host_data);
335 
336 	return 0;
337 }
338 
339 static const struct irq_domain_ops faraday_pci_irqdomain_ops = {
340 	.map = faraday_pci_irq_map,
341 };
342 
343 static int faraday_pci_setup_cascaded_irq(struct faraday_pci *p)
344 {
345 	struct device_node *intc = of_get_next_child(p->dev->of_node, NULL);
346 	int irq;
347 	int i;
348 
349 	if (!intc) {
350 		dev_err(p->dev, "missing child interrupt-controller node\n");
351 		return -EINVAL;
352 	}
353 
354 	/* All PCI IRQs cascade off this one */
355 	irq = of_irq_get(intc, 0);
356 	if (irq <= 0) {
357 		dev_err(p->dev, "failed to get parent IRQ\n");
358 		of_node_put(intc);
359 		return irq ?: -EINVAL;
360 	}
361 
362 	p->irqdomain = irq_domain_add_linear(intc, PCI_NUM_INTX,
363 					     &faraday_pci_irqdomain_ops, p);
364 	of_node_put(intc);
365 	if (!p->irqdomain) {
366 		dev_err(p->dev, "failed to create Gemini PCI IRQ domain\n");
367 		return -EINVAL;
368 	}
369 
370 	irq_set_chained_handler_and_data(irq, faraday_pci_irq_handler, p);
371 
372 	for (i = 0; i < 4; i++)
373 		irq_create_mapping(p->irqdomain, i);
374 
375 	return 0;
376 }
377 
378 static int faraday_pci_parse_map_dma_ranges(struct faraday_pci *p,
379 					    struct device_node *np)
380 {
381 	struct of_pci_range range;
382 	struct of_pci_range_parser parser;
383 	struct device *dev = p->dev;
384 	u32 confreg[3] = {
385 		FARADAY_PCI_MEM1_BASE_SIZE,
386 		FARADAY_PCI_MEM2_BASE_SIZE,
387 		FARADAY_PCI_MEM3_BASE_SIZE,
388 	};
389 	int i = 0;
390 	u32 val;
391 
392 	if (of_pci_dma_range_parser_init(&parser, np)) {
393 		dev_err(dev, "missing dma-ranges property\n");
394 		return -EINVAL;
395 	}
396 
397 	/*
398 	 * Get the dma-ranges from the device tree
399 	 */
400 	for_each_of_pci_range(&parser, &range) {
401 		u64 end = range.pci_addr + range.size - 1;
402 		int ret;
403 
404 		ret = faraday_res_to_memcfg(range.pci_addr, range.size, &val);
405 		if (ret) {
406 			dev_err(dev,
407 				"DMA range %d: illegal MEM resource size\n", i);
408 			return -EINVAL;
409 		}
410 
411 		dev_info(dev, "DMA MEM%d BASE: 0x%016llx -> 0x%016llx config %08x\n",
412 			 i + 1, range.pci_addr, end, val);
413 		if (i <= 2) {
414 			faraday_raw_pci_write_config(p, 0, 0, confreg[i],
415 						     4, val);
416 		} else {
417 			dev_err(dev, "ignore extraneous dma-range %d\n", i);
418 			break;
419 		}
420 
421 		i++;
422 	}
423 
424 	return 0;
425 }
426 
427 static int faraday_pci_probe(struct platform_device *pdev)
428 {
429 	struct device *dev = &pdev->dev;
430 	const struct faraday_pci_variant *variant =
431 		of_device_get_match_data(dev);
432 	struct resource *regs;
433 	resource_size_t io_base;
434 	struct resource_entry *win;
435 	struct faraday_pci *p;
436 	struct resource *mem;
437 	struct resource *io;
438 	struct pci_host_bridge *host;
439 	struct clk *clk;
440 	unsigned char max_bus_speed = PCI_SPEED_33MHz;
441 	unsigned char cur_bus_speed = PCI_SPEED_33MHz;
442 	int ret;
443 	u32 val;
444 	LIST_HEAD(res);
445 
446 	host = devm_pci_alloc_host_bridge(dev, sizeof(*p));
447 	if (!host)
448 		return -ENOMEM;
449 
450 	host->dev.parent = dev;
451 	host->ops = &faraday_pci_ops;
452 	host->busnr = 0;
453 	host->msi = NULL;
454 	host->map_irq = of_irq_parse_and_map_pci;
455 	host->swizzle_irq = pci_common_swizzle;
456 	p = pci_host_bridge_priv(host);
457 	host->sysdata = p;
458 	p->dev = dev;
459 
460 	/* Retrieve and enable optional clocks */
461 	clk = devm_clk_get(dev, "PCLK");
462 	if (IS_ERR(clk))
463 		return PTR_ERR(clk);
464 	ret = clk_prepare_enable(clk);
465 	if (ret) {
466 		dev_err(dev, "could not prepare PCLK\n");
467 		return ret;
468 	}
469 	p->bus_clk = devm_clk_get(dev, "PCICLK");
470 	if (IS_ERR(p->bus_clk))
471 		return PTR_ERR(p->bus_clk);
472 	ret = clk_prepare_enable(p->bus_clk);
473 	if (ret) {
474 		dev_err(dev, "could not prepare PCICLK\n");
475 		return ret;
476 	}
477 
478 	regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
479 	p->base = devm_ioremap_resource(dev, regs);
480 	if (IS_ERR(p->base))
481 		return PTR_ERR(p->base);
482 
483 	ret = devm_of_pci_get_host_bridge_resources(dev, 0, 0xff,
484 						    &res, &io_base);
485 	if (ret)
486 		return ret;
487 
488 	ret = devm_request_pci_bus_resources(dev, &res);
489 	if (ret)
490 		return ret;
491 
492 	/* Get the I/O and memory ranges from DT */
493 	resource_list_for_each_entry(win, &res) {
494 		switch (resource_type(win->res)) {
495 		case IORESOURCE_IO:
496 			io = win->res;
497 			io->name = "Gemini PCI I/O";
498 			if (!faraday_res_to_memcfg(io->start - win->offset,
499 						   resource_size(io), &val)) {
500 				/* setup I/O space size */
501 				writel(val, p->base + PCI_IOSIZE);
502 			} else {
503 				dev_err(dev, "illegal IO mem size\n");
504 				return -EINVAL;
505 			}
506 			ret = devm_pci_remap_iospace(dev, io, io_base);
507 			if (ret) {
508 				dev_warn(dev, "error %d: failed to map resource %pR\n",
509 					 ret, io);
510 				continue;
511 			}
512 			break;
513 		case IORESOURCE_MEM:
514 			mem = win->res;
515 			mem->name = "Gemini PCI MEM";
516 			break;
517 		case IORESOURCE_BUS:
518 			break;
519 		default:
520 			break;
521 		}
522 	}
523 
524 	/* Setup hostbridge */
525 	val = readl(p->base + PCI_CTRL);
526 	val |= PCI_COMMAND_IO;
527 	val |= PCI_COMMAND_MEMORY;
528 	val |= PCI_COMMAND_MASTER;
529 	writel(val, p->base + PCI_CTRL);
530 	/* Mask and clear all interrupts */
531 	faraday_raw_pci_write_config(p, 0, 0, FARADAY_PCI_CTRL2 + 2, 2, 0xF000);
532 	if (variant->cascaded_irq) {
533 		ret = faraday_pci_setup_cascaded_irq(p);
534 		if (ret) {
535 			dev_err(dev, "failed to setup cascaded IRQ\n");
536 			return ret;
537 		}
538 	}
539 
540 	/* Check bus clock if we can gear up to 66 MHz */
541 	if (!IS_ERR(p->bus_clk)) {
542 		unsigned long rate;
543 		u32 val;
544 
545 		faraday_raw_pci_read_config(p, 0, 0,
546 					    FARADAY_PCI_STATUS_CMD, 4, &val);
547 		rate = clk_get_rate(p->bus_clk);
548 
549 		if ((rate == 33000000) && (val & PCI_STATUS_66MHZ_CAPABLE)) {
550 			dev_info(dev, "33MHz bus is 66MHz capable\n");
551 			max_bus_speed = PCI_SPEED_66MHz;
552 			ret = clk_set_rate(p->bus_clk, 66000000);
553 			if (ret)
554 				dev_err(dev, "failed to set bus clock\n");
555 		} else {
556 			dev_info(dev, "33MHz only bus\n");
557 			max_bus_speed = PCI_SPEED_33MHz;
558 		}
559 
560 		/* Bumping the clock may fail so read back the rate */
561 		rate = clk_get_rate(p->bus_clk);
562 		if (rate == 33000000)
563 			cur_bus_speed = PCI_SPEED_33MHz;
564 		if (rate == 66000000)
565 			cur_bus_speed = PCI_SPEED_66MHz;
566 	}
567 
568 	ret = faraday_pci_parse_map_dma_ranges(p, dev->of_node);
569 	if (ret)
570 		return ret;
571 
572 	list_splice_init(&res, &host->windows);
573 	ret = pci_scan_root_bus_bridge(host);
574 	if (ret) {
575 		dev_err(dev, "failed to scan host: %d\n", ret);
576 		return ret;
577 	}
578 	p->bus = host->bus;
579 	p->bus->max_bus_speed = max_bus_speed;
580 	p->bus->cur_bus_speed = cur_bus_speed;
581 
582 	pci_bus_assign_resources(p->bus);
583 	pci_bus_add_devices(p->bus);
584 	pci_free_resource_list(&res);
585 
586 	return 0;
587 }
588 
589 /*
590  * We encode bridge variants here, we have at least two so it doesn't
591  * hurt to have infrastructure to encompass future variants as well.
592  */
593 static const struct faraday_pci_variant faraday_regular = {
594 	.cascaded_irq = true,
595 };
596 
597 static const struct faraday_pci_variant faraday_dual = {
598 	.cascaded_irq = false,
599 };
600 
601 static const struct of_device_id faraday_pci_of_match[] = {
602 	{
603 		.compatible = "faraday,ftpci100",
604 		.data = &faraday_regular,
605 	},
606 	{
607 		.compatible = "faraday,ftpci100-dual",
608 		.data = &faraday_dual,
609 	},
610 	{},
611 };
612 
613 static struct platform_driver faraday_pci_driver = {
614 	.driver = {
615 		.name = "ftpci100",
616 		.of_match_table = of_match_ptr(faraday_pci_of_match),
617 		.suppress_bind_attrs = true,
618 	},
619 	.probe  = faraday_pci_probe,
620 };
621 builtin_platform_driver(faraday_pci_driver);
622