2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
4 * Copyright (c) 2019 Michal Meloun <mmel@FreeBSD.org>
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 /* Base class for all Synopsys DesignWare PCI/PCIe drivers */
31 #include <sys/cdefs.h>
32 __FBSDID("$FreeBSD$");
35 #include <sys/param.h>
36 #include <sys/systm.h>
38 #include <sys/devmap.h>
40 #include <sys/kernel.h>
42 #include <sys/malloc.h>
43 #include <sys/module.h>
44 #include <sys/mutex.h>
47 #include <machine/bus.h>
48 #include <machine/intr.h>
49 #include <machine/resource.h>
51 #include <dev/ofw/ofw_bus.h>
52 #include <dev/ofw/ofw_bus_subr.h>
53 #include <dev/ofw/ofw_pci.h>
54 #include <dev/ofw/ofwpci.h>
55 #include <dev/pci/pcivar.h>
56 #include <dev/pci/pcireg.h>
57 #include <dev/pci/pcib_private.h>
58 #include <dev/pci/pci_dw.h>
61 #include "pci_dw_if.h"
65 #define debugf(fmt, args...) do { printf(fmt,##args); } while (0)
67 #define debugf(fmt, args...)
70 #define DBI_WR1(sc, reg, val) pci_dw_dbi_wr1((sc)->dev, reg, val)
71 #define DBI_WR2(sc, reg, val) pci_dw_dbi_wr2((sc)->dev, reg, val)
72 #define DBI_WR4(sc, reg, val) pci_dw_dbi_wr4((sc)->dev, reg, val)
73 #define DBI_RD1(sc, reg) pci_dw_dbi_rd1((sc)->dev, reg)
74 #define DBI_RD2(sc, reg) pci_dw_dbi_rd2((sc)->dev, reg)
75 #define DBI_RD4(sc, reg) pci_dw_dbi_rd4((sc)->dev, reg)
77 #define PCI_BUS_SHIFT 20
78 #define PCI_SLOT_SHIFT 15
79 #define PCI_FUNC_SHIFT 12
80 #define PCI_BUS_MASK 0xFF
81 #define PCI_SLOT_MASK 0x1F
82 #define PCI_FUNC_MASK 0x07
83 #define PCI_REG_MASK 0xFFF
86 #define IATU_CFG_BUS(bus) ((uint64_t)((bus) & 0xff) << 24)
87 #define IATU_CFG_SLOT(slot) ((uint64_t)((slot) & 0x1f) << 19)
88 #define IATU_CFG_FUNC(func) ((uint64_t)((func) & 0x07) << 16)
93 pci_dw_dbi_read(device_t dev, u_int reg, int width)
95 struct pci_dw_softc *sc;
97 sc = device_get_softc(dev);
98 MPASS(sc->dbi_res != NULL);
102 return (bus_read_4(sc->dbi_res, reg));
104 return (bus_read_2(sc->dbi_res, reg));
106 return (bus_read_1(sc->dbi_res, reg));
108 device_printf(sc->dev, "Unsupported width: %d\n", width);
114 pci_dw_dbi_write(device_t dev, u_int reg, uint32_t val, int width)
116 struct pci_dw_softc *sc;
118 sc = device_get_softc(dev);
119 MPASS(sc->dbi_res != NULL);
123 bus_write_4(sc->dbi_res, reg, val);
126 bus_write_2(sc->dbi_res, reg, val);
129 bus_write_1(sc->dbi_res, reg, val);
132 device_printf(sc->dev, "Unsupported width: %d\n", width);
139 pci_dw_dbi_protect(struct pci_dw_softc *sc, bool protect)
143 reg = DBI_RD4(sc, DW_MISC_CONTROL_1);
145 reg &= ~DBI_RO_WR_EN;
148 DBI_WR4(sc, DW_MISC_CONTROL_1, reg);
152 pci_dw_check_dev(struct pci_dw_softc *sc, u_int bus, u_int slot, u_int func,
158 if (bus < sc->bus_start || bus > sc->bus_end || slot > PCI_SLOTMAX ||
159 func > PCI_FUNCMAX || reg > PCIE_REGMAX)
162 /* link is needed for access to all non-root busses */
163 if (bus != sc->root_bus) {
164 rv = PCI_DW_GET_LINK(sc->dev, &status);
165 if (rv != 0 || !status)
170 /* we have only 1 device with 1 function root port */
171 if (slot > 0 || func > 0)
176 /* Map one uoutbound ATU region */
178 pci_dw_map_out_atu(struct pci_dw_softc *sc, int idx, int type,
179 uint64_t pa, uint64_t pci_addr, uint32_t size)
187 DBI_WR4(sc, DW_IATU_VIEWPORT, IATU_REGION_INDEX(idx));
188 DBI_WR4(sc, DW_IATU_LWR_BASE_ADDR, pa & 0xFFFFFFFF);
189 DBI_WR4(sc, DW_IATU_UPPER_BASE_ADDR, (pa >> 32) & 0xFFFFFFFF);
190 DBI_WR4(sc, DW_IATU_LIMIT_ADDR, (pa + size - 1) & 0xFFFFFFFF);
191 DBI_WR4(sc, DW_IATU_LWR_TARGET_ADDR, pci_addr & 0xFFFFFFFF);
192 DBI_WR4(sc, DW_IATU_UPPER_TARGET_ADDR, (pci_addr >> 32) & 0xFFFFFFFF);
193 DBI_WR4(sc, DW_IATU_CTRL1, IATU_CTRL1_TYPE(type));
194 DBI_WR4(sc, DW_IATU_CTRL2, IATU_CTRL2_REGION_EN);
196 /* Wait until setup becomes valid */
197 for (i = 10; i > 0; i--) {
198 reg = DBI_RD4(sc, DW_IATU_CTRL2);
199 if (reg & IATU_CTRL2_REGION_EN)
203 device_printf(sc->dev,
204 "Cannot map outbound region(%d) in iATU\n", idx);
209 pci_dw_setup_hw(struct pci_dw_softc *sc)
214 pci_dw_dbi_protect(sc, false);
216 /* Setup config registers */
217 DBI_WR1(sc, PCIR_CLASS, PCIC_BRIDGE);
218 DBI_WR1(sc, PCIR_SUBCLASS, PCIS_BRIDGE_PCI);
219 DBI_WR4(sc, PCIR_BAR(0), 4);
220 DBI_WR4(sc, PCIR_BAR(1), 0);
221 DBI_WR1(sc, PCIR_INTPIN, 1);
222 DBI_WR1(sc, PCIR_PRIBUS_1, sc->root_bus);
223 DBI_WR1(sc, PCIR_SECBUS_1, sc->sub_bus);
224 DBI_WR1(sc, PCIR_SUBBUS_1, sc->bus_end);
225 DBI_WR2(sc, PCIR_COMMAND,
226 PCIM_CMD_PORTEN | PCIM_CMD_MEMEN |
227 PCIM_CMD_BUSMASTEREN | PCIM_CMD_SERRESPEN);
228 pci_dw_dbi_protect(sc, true);
230 /* Setup outbound memory window */
231 rv = pci_dw_map_out_atu(sc, 0, IATU_CTRL1_TYPE_MEM,
232 sc->mem_range.host, sc->mem_range.pci, sc->mem_range.size);
236 /* If we have enouht viewports ..*/
237 if (sc->num_viewport >= 3 && sc->io_range.size != 0) {
238 /* Setup outbound I/O window */
239 rv = pci_dw_map_out_atu(sc, 0, IATU_CTRL1_TYPE_MEM,
240 sc->io_range.host, sc->io_range.pci, sc->io_range.size);
244 /* XXX Should we handle also prefetch memory? */
247 /* Adjust number of lanes */
248 reg = DBI_RD4(sc, DW_PORT_LINK_CTRL);
249 reg &= ~PORT_LINK_CAPABLE(~0);
250 switch (sc->num_lanes) {
252 reg |= PORT_LINK_CAPABLE(PORT_LINK_CAPABLE_1);
255 reg |= PORT_LINK_CAPABLE(PORT_LINK_CAPABLE_2);
258 reg |= PORT_LINK_CAPABLE(PORT_LINK_CAPABLE_4);
261 reg |= PORT_LINK_CAPABLE(PORT_LINK_CAPABLE_8);
264 reg |= PORT_LINK_CAPABLE(PORT_LINK_CAPABLE_16);
267 reg |= PORT_LINK_CAPABLE(PORT_LINK_CAPABLE_32);
270 device_printf(sc->dev,
271 "'num-lanes' property have invalid value: %d\n",
275 DBI_WR4(sc, DW_PORT_LINK_CTRL, reg);
279 reg = DBI_RD4(sc, DW_GEN2_CTRL);
280 reg &= ~GEN2_CTRL_NUM_OF_LANES(~0);
281 switch (sc->num_lanes) {
283 reg |= GEN2_CTRL_NUM_OF_LANES(GEN2_CTRL_NUM_OF_LANES_1);
286 reg |= GEN2_CTRL_NUM_OF_LANES(GEN2_CTRL_NUM_OF_LANES_2);
289 reg |= GEN2_CTRL_NUM_OF_LANES(GEN2_CTRL_NUM_OF_LANES_4);
292 reg |= GEN2_CTRL_NUM_OF_LANES(GEN2_CTRL_NUM_OF_LANES_8);
295 reg |= GEN2_CTRL_NUM_OF_LANES(GEN2_CTRL_NUM_OF_LANES_16);
298 reg |= GEN2_CTRL_NUM_OF_LANES(GEN2_CTRL_NUM_OF_LANES_32);
301 DBI_WR4(sc, DW_GEN2_CTRL, reg);
303 reg = DBI_RD4(sc, DW_GEN2_CTRL);
304 reg |= DIRECT_SPEED_CHANGE;
305 DBI_WR4(sc, DW_GEN2_CTRL, reg);
312 pci_dw_decode_ranges(struct pci_dw_softc *sc, struct ofw_pci_range *ranges,
317 for (i = 0; i < nranges; i++) {
318 if ((ranges[i].pci_hi & OFW_PCI_PHYS_HI_SPACEMASK) ==
319 OFW_PCI_PHYS_HI_SPACE_IO) {
320 if (sc->io_range.size != 0) {
321 device_printf(sc->dev,
322 "Duplicated IO range found in DT\n");
325 sc->io_range = ranges[i];
327 if (((ranges[i].pci_hi & OFW_PCI_PHYS_HI_SPACEMASK) ==
328 OFW_PCI_PHYS_HI_SPACE_MEM32)) {
329 if (ranges[i].pci_hi & OFW_PCI_PHYS_HI_PREFETCHABLE) {
330 if (sc->pref_mem_range.size != 0) {
331 device_printf(sc->dev,
332 "Duplicated memory range found "
336 sc->pref_mem_range = ranges[i];
338 if (sc->mem_range.size != 0) {
339 device_printf(sc->dev,
340 "Duplicated memory range found "
344 sc->mem_range = ranges[i];
348 if (sc->mem_range.size == 0) {
349 device_printf(sc->dev,
350 " Not all required ranges are found in DT\n");
358 /*-----------------------------------------------------------------------------
360 * P C I B I N T E R F A C E
364 pci_dw_read_config(device_t dev, u_int bus, u_int slot,
365 u_int func, u_int reg, int bytes)
367 struct pci_dw_softc *sc;
368 struct resource *res;
373 sc = device_get_softc(dev);
375 if (!pci_dw_check_dev(sc, bus, slot, func, reg))
376 return (0xFFFFFFFFU);
378 if (bus == sc->root_bus) {
381 addr = IATU_CFG_BUS(bus) | IATU_CFG_SLOT(slot) |
383 if (bus == sc->sub_bus)
384 type = IATU_CTRL1_TYPE_CFG0;
386 type = IATU_CTRL1_TYPE_CFG1;
387 rv = pci_dw_map_out_atu(sc, 1, type,
388 sc->cfg_pa, addr, sc->cfg_size);
390 return (0xFFFFFFFFU);
396 data = bus_read_1(res, reg);
399 data = bus_read_2(res, reg);
402 data = bus_read_4(res, reg);
413 pci_dw_write_config(device_t dev, u_int bus, u_int slot,
414 u_int func, u_int reg, uint32_t val, int bytes)
416 struct pci_dw_softc *sc;
417 struct resource *res;
421 sc = device_get_softc(dev);
422 if (!pci_dw_check_dev(sc, bus, slot, func, reg))
425 if (bus == sc->root_bus) {
428 addr = IATU_CFG_BUS(bus) | IATU_CFG_SLOT(slot) |
430 if (bus == sc->sub_bus)
431 type = IATU_CTRL1_TYPE_CFG0;
433 type = IATU_CTRL1_TYPE_CFG1;
434 rv = pci_dw_map_out_atu(sc, 1, type,
435 sc->cfg_pa, addr, sc->cfg_size);
444 bus_write_1(res, reg, val);
447 bus_write_2(res, reg, val);
450 bus_write_4(res, reg, val);
458 pci_dw_alloc_msi(device_t pci, device_t child, int count,
459 int maxcount, int *irqs)
461 phandle_t msi_parent;
464 rv = ofw_bus_msimap(ofw_bus_get_node(pci), pci_get_rid(child),
469 return (intr_alloc_msi(pci, child, msi_parent, count, maxcount,
474 pci_dw_release_msi(device_t pci, device_t child, int count, int *irqs)
476 phandle_t msi_parent;
479 rv = ofw_bus_msimap(ofw_bus_get_node(pci), pci_get_rid(child),
483 return (intr_release_msi(pci, child, msi_parent, count, irqs));
487 pci_dw_map_msi(device_t pci, device_t child, int irq, uint64_t *addr,
490 phandle_t msi_parent;
493 rv = ofw_bus_msimap(ofw_bus_get_node(pci), pci_get_rid(child),
498 return (intr_map_msi(pci, child, msi_parent, irq, addr, data));
502 pci_dw_alloc_msix(device_t pci, device_t child, int *irq)
504 phandle_t msi_parent;
507 rv = ofw_bus_msimap(ofw_bus_get_node(pci), pci_get_rid(child),
511 return (intr_alloc_msix(pci, child, msi_parent, irq));
515 pci_dw_release_msix(device_t pci, device_t child, int irq)
517 phandle_t msi_parent;
520 rv = ofw_bus_msimap(ofw_bus_get_node(pci), pci_get_rid(child),
524 return (intr_release_msix(pci, child, msi_parent, irq));
528 pci_dw_get_id(device_t pci, device_t child, enum pci_id_type type,
536 if (type != PCI_ID_MSI)
537 return (pcib_get_id(pci, child, type, id));
539 node = ofw_bus_get_node(pci);
540 pci_rid = pci_get_rid(child);
542 rv = ofw_bus_msimap(node, pci_rid, NULL, &rid);
550 /*-----------------------------------------------------------------------------
552 * B U S / D E V I C E I N T E R F A C E
555 pci_dw_get_dma_tag(device_t dev, device_t child)
557 struct pci_dw_softc *sc;
559 sc = device_get_softc(dev);
564 pci_dw_init(device_t dev)
566 struct pci_dw_softc *sc;
569 sc = device_get_softc(dev);
571 sc->node = ofw_bus_get_node(dev);
573 mtx_init(&sc->mtx, "pci_dw_mtx", NULL, MTX_DEF);
575 /* XXXn Should not be this configurable ? */
581 /* Read FDT properties */
583 sc->coherent = OF_hasprop(sc->node, "dma-coherent");
585 rv = OF_getencprop(sc->node, "num-viewport", &sc->num_viewport,
586 sizeof(sc->num_viewport));
587 if (rv != sizeof(sc->num_viewport))
588 sc->num_viewport = 2;
590 rv = OF_getencprop(sc->node, "num-lanes", &sc->num_lanes,
591 sizeof(sc->num_viewport));
592 if (rv != sizeof(sc->num_lanes))
594 if (sc->num_lanes != 1 && sc->num_lanes != 2 &&
595 sc->num_lanes != 4 && sc->num_lanes != 8) {
597 "invalid number of lanes: %d\n",sc->num_lanes);
604 rv = ofw_bus_find_string_index(sc->node, "reg-names", "config", &rid);
606 device_printf(dev, "Cannot get config space memory\n");
610 sc->cfg_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid,
612 if (sc->cfg_res == NULL) {
613 device_printf(dev, "Cannot allocate config space(rid: %d)\n",
619 /* Fill up config region related variables */
620 sc->cfg_size = rman_get_size(sc->cfg_res);
621 sc->cfg_pa = rman_get_start(sc->cfg_res) ;
624 device_printf(dev, "Bus is%s cache-coherent\n",
625 sc->coherent ? "" : " not");
626 rv = bus_dma_tag_create(bus_get_dma_tag(dev), /* parent */
627 1, 0, /* alignment, bounds */
628 BUS_SPACE_MAXADDR, /* lowaddr */
629 BUS_SPACE_MAXADDR, /* highaddr */
630 NULL, NULL, /* filter, filterarg */
631 BUS_SPACE_MAXSIZE, /* maxsize */
632 BUS_SPACE_UNRESTRICTED, /* nsegments */
633 BUS_SPACE_MAXSIZE, /* maxsegsize */
634 sc->coherent ? BUS_DMA_COHERENT : 0, /* flags */
635 NULL, NULL, /* lockfunc, lockarg */
640 rv = ofw_pci_init(dev);
643 rv = pci_dw_decode_ranges(sc, sc->ofw_pci.sc_range,
644 sc->ofw_pci.sc_nrange);
648 rv = pci_dw_setup_hw(sc);
652 device_add_child(dev, "pci", -1);
654 return (bus_generic_attach(dev));
660 static device_method_t pci_dw_methods[] = {
663 DEVMETHOD(bus_get_dma_tag, pci_dw_get_dma_tag),
666 DEVMETHOD(pcib_read_config, pci_dw_read_config),
667 DEVMETHOD(pcib_write_config, pci_dw_write_config),
668 DEVMETHOD(pcib_alloc_msi, pci_dw_alloc_msi),
669 DEVMETHOD(pcib_release_msi, pci_dw_release_msi),
670 DEVMETHOD(pcib_alloc_msix, pci_dw_alloc_msix),
671 DEVMETHOD(pcib_release_msix, pci_dw_release_msix),
672 DEVMETHOD(pcib_map_msi, pci_dw_map_msi),
673 DEVMETHOD(pcib_get_id, pci_dw_get_id),
675 /* OFW bus interface */
676 DEVMETHOD(ofw_bus_get_compat, ofw_bus_gen_get_compat),
677 DEVMETHOD(ofw_bus_get_model, ofw_bus_gen_get_model),
678 DEVMETHOD(ofw_bus_get_name, ofw_bus_gen_get_name),
679 DEVMETHOD(ofw_bus_get_node, ofw_bus_gen_get_node),
680 DEVMETHOD(ofw_bus_get_type, ofw_bus_gen_get_type),
682 /* PCI DW interface */
683 DEVMETHOD(pci_dw_dbi_read, pci_dw_dbi_read),
684 DEVMETHOD(pci_dw_dbi_write, pci_dw_dbi_write),
688 DEFINE_CLASS_1(pcib, pci_dw_driver, pci_dw_methods,
689 sizeof(struct pci_dw_softc), ofw_pci_driver);