void
exmct_attach(struct device *parent, struct device *self, void *args)
{
struct armv7_attach_args *aa = args;
struct exmct_softc *sc = (struct exmct_softc *) self;
struct armv7mem mem;
uint32_t i, mask, reg;
sc->sc_iot = aa->aa_iot;
#if NFDT > 0
if (aa->aa_node) {
struct fdt_memory fdtmem;
if (fdt_get_memory_address(aa->aa_node, 0, &fdtmem))
panic("%s: could not extract memory data from FDT",
__func__);
mem.addr = fdtmem.addr;
mem.size = fdtmem.size;
} else
#endif
{
mem.addr = aa->aa_dev->mem[0].addr;
mem.size = aa->aa_dev->mem[0].size;
}
if (bus_space_map(sc->sc_iot, mem.addr, mem.size, 0, &sc->sc_ioh))
panic("%s: bus_space_map failed!", __func__);
printf("\n");
exmct_sc = sc;
bus_space_write_4(sc->sc_iot, sc->sc_ioh, MCT_CTRL,
bus_space_read_4(sc->sc_iot, sc->sc_ioh, MCT_CTRL) | MCT_CTRL_START);
mask = (1 << 16);
/* Wait 10 times until written value is applied */
for (i = 0; i < 10; i++) {
reg = bus_space_read_4(sc->sc_iot, sc->sc_ioh, MCT_WRITE_STAT);
if (reg & mask) {
bus_space_write_4(sc->sc_iot, sc->sc_ioh,
MCT_WRITE_STAT, mask);
return;
}
cpufunc_nullop();
}
/* NOTREACHED */
panic("%s: Can't enable timer!", __func__);
}
void
sxiuart_init_cons(void)
{
struct fdt_memory mem;
void *node;
if ((node = fdt_find_cons("snps,dw-apb-uart")) == NULL)
return;
if (fdt_get_memory_address(node, 0, &mem))
return;
sxiuartcnattach(&armv7_a4x_bs_tag, mem.addr, comcnspeed, 24000000,
comcnmode);
}
static void
mvmdio_attach(struct device *parent, struct device *self, void *aux)
{
struct mvmdio_softc *sc = (struct mvmdio_softc *) self;
struct armv7_attach_args *aa = aux;
struct fdt_memory mem;
printf("\n");
clk_enable(clk_fdt_get(aa->aa_node, 0));
if (fdt_get_memory_address(aa->aa_node, 0, &mem))
panic("%s: cannot extract memory", sc->sc_dev.dv_xname);
sc->sc_iot = aa->aa_iot;
if (bus_space_map(sc->sc_iot, mem.addr, mem.size, 0, &sc->sc_ioh))
panic("%s: cannot map registers", sc->sc_dev.dv_xname);
mtx_init(&sc->sc_mtx, IPL_NET);
}
void
bcmpm_attach(struct device *parent, struct device *self, void *args)
{
struct bcmpm_softc *sc = (struct bcmpm_softc *)self;
struct armv7_attach_args *aa = args;
struct fdt_memory mem;
sc->sc_iot = aa->aa_iot;
if (fdt_get_memory_address(aa->aa_node, 0, &mem))
panic("%s: could not extract memory data from FDT",
__func__);
if (bus_space_map(sc->sc_iot, mem.addr, mem.size, 0, &sc->sc_ioh))
panic("%s: bus_space_map failed!", __func__);
printf("\n");
bcmpm_sc = sc;
extern void (*fdt_platform_watchdog_reset_fn)(void);
fdt_platform_watchdog_reset_fn = bcmpm_wdog_reset;
wdog_register(bcmpm_wdog_cb, sc);
}
void
mpic_attach(struct device *parent, struct device *self, void *args)
{
struct mpic_softc *sc = (struct mpic_softc *)self;
struct armv7_attach_args *aa = args;
uint32_t main, mainsize, cpu, cpusize;
struct fdt_memory mem;
int i;
mpic = sc;
arm_init_smask();
if (fdt_get_memory_address(aa->aa_node, 0, &mem))
panic("%s: cannot extract main memory",
sc->sc_dev.dv_xname);
main = mem.addr;
mainsize = mem.size;
if (fdt_get_memory_address(aa->aa_node, 1, &mem))
panic("%s: cannot extract cpu memory",
sc->sc_dev.dv_xname);
cpu = mem.addr;
cpusize = mem.size;
if (fdt_node_property_int(aa->aa_node,
"#interrupt-cells", &sc->sc_ncells) != 1)
panic("%s: no #interrupt-cells property",
sc->sc_dev.dv_xname);
sc->sc_iot = aa->aa_iot;
if (bus_space_map(sc->sc_iot, main, mainsize, 0, &sc->sc_m_ioh))
panic("%s: main bus_space_map failed!", __func__);
if (bus_space_map(sc->sc_iot, cpu, cpusize, 0, &sc->sc_c_ioh))
panic("%s: cpu bus_space_map failed!", __func__);
evcount_attach(&sc->sc_spur, "irq1023/spur", NULL);
sc->sc_nintr = (bus_space_read_4(sc->sc_iot, sc->sc_m_ioh,
MPIC_CTRL) >> 2) & 0x3ff;
printf(" nirq %d\n", sc->sc_nintr);
/* Disable all interrupts */
for (i = 0; i < sc->sc_nintr; i++) {
bus_space_write_4(sc->sc_iot, sc->sc_m_ioh, MPIC_ICE, i);
bus_space_write_4(sc->sc_iot, sc->sc_c_ioh, MPIC_ISM, i);
}
/* Clear pending IPIs */
bus_space_write_4(sc->sc_iot, sc->sc_c_ioh, MPIC_DOORBELL_CAUSE, 0);
/* Enable hardware priorization selection */
bus_space_write_4(sc->sc_iot, sc->sc_m_ioh, MPIC_CTRL,
MPIC_CTRL_PRIO_EN);
sc->sc_mpic_handler = mallocarray(sc->sc_nintr,
sizeof(*sc->sc_mpic_handler), M_DEVBUF, M_ZERO | M_NOWAIT);
for (i = 0; i < sc->sc_nintr; i++) {
TAILQ_INIT(&sc->sc_mpic_handler[i].is_list);
}
mpic_setipl(IPL_HIGH); /* XXX ??? */
mpic_calc_mask();
/* insert self as interrupt handler */
arm_set_intr_handler(mpic_splraise, mpic_spllower, mpic_splx,
mpic_setipl, mpic_intr_establish, mpic_intr_disestablish,
mpic_intr_string, mpic_irq_handler);
arm_set_intr_handler_fdt(aa->aa_node, mpic_intr_establish_fdt_idx);
/* enable interrupts */
intr_enable();
}
void
imxehci_attach(struct device *parent, struct device *self, void *aux)
{
struct imxehci_softc *sc = (struct imxehci_softc *)self;
struct ehci_softc *esc;
struct armv7_attach_args *aa = aux;
struct fdt_memory hmem, pmem, mmem;
int irq, r;
sc->iot = aa->aa_iot;
sc->sc_dmat = aa->aa_dmat;
if (aa->aa_node) {
uint32_t ints[3];
void *node;
if (fdt_get_memory_address(aa->aa_node, 0, &hmem))
panic("%s: could not extract memory data from FDT",
__func__);
node = fdt_find_node_by_phandle_prop(aa->aa_node, "fsl,usbphy");
if (node == NULL || fdt_get_memory_address(node, 0, &pmem))
panic("%s: could not extract phy data from FDT",
__func__);
node = fdt_find_node_by_phandle_prop(aa->aa_node, "fsl,usbmisc");
if (node == NULL || fdt_get_memory_address(node, 0, &mmem))
panic("%s: could not extract phy data from FDT",
__func__);
/* TODO: Add interrupt FDT API. */
if (fdt_node_property_ints(aa->aa_node, "interrupts",
ints, 3) != 3)
panic("%s: could not extract interrupt data from FDT",
__func__);
irq = ints[1];
} else {
hmem.addr = aa->aa_dev->mem[0].addr;
hmem.size = aa->aa_dev->mem[0].size;
pmem.addr = aa->aa_dev->mem[1].addr;
pmem.size = aa->aa_dev->mem[1].size;
mmem.addr = aa->aa_dev->mem[2].addr;
mmem.size = aa->aa_dev->mem[2].size;
irq = aa->aa_dev->irq[0];
}
/* Map I/O space */
if (bus_space_map(sc->iot, hmem.addr, hmem.size, 0, &sc->uh_ioh)) {
printf(": cannot map mem space\n");
goto hmem;
}
sc->ioh = sc->uh_ioh + 0x100;
sc->sc_size = hmem.size;
if (bus_space_map(sc->iot, pmem.addr, pmem.size, 0, &sc->ph_ioh)) {
printf(": cannot map mem space\n");
goto pmem;
}
if (bus_space_map(sc->iot, mmem.addr, mmem.size, 0, &sc->nc_ioh)) {
printf(": cannot map mem space\n");
goto mmem;
}
clk_enable(clk_get("usboh3"));
delay(1000);
if (hmem.addr == USBUH1_ADDR) {
/* enable usb port power */
switch (board_id)
{
case BOARD_ID_IMX6_CUBOXI:
case BOARD_ID_IMX6_HUMMINGBOARD:
imxgpio_set_bit(EHCI_HUMMINGBOARD_USB_H1_PWR);
imxgpio_set_dir(EHCI_HUMMINGBOARD_USB_H1_PWR, IMXGPIO_DIR_OUT);
delay(10);
break;
case BOARD_ID_IMX6_SABRELITE:
imxgpio_clear_bit(EHCI_NITROGEN6X_USB_HUB_RST);
imxgpio_set_dir(EHCI_NITROGEN6X_USB_HUB_RST, IMXGPIO_DIR_OUT);
delay(1000 * 2);
imxgpio_set_bit(EHCI_NITROGEN6X_USB_HUB_RST);
delay(10);
break;
case BOARD_ID_IMX6_SABRESD:
imxgpio_set_bit(EHCI_SABRESD_USB_PWR);
imxgpio_set_dir(EHCI_SABRESD_USB_PWR, IMXGPIO_DIR_OUT);
delay(10);
break;
case BOARD_ID_IMX6_UTILITE:
imxgpio_clear_bit(EHCI_UTILITE_USB_HUB_RST);
imxgpio_set_dir(EHCI_UTILITE_USB_HUB_RST, IMXGPIO_DIR_OUT);
delay(10);
imxgpio_set_bit(EHCI_UTILITE_USB_HUB_RST);
delay(1000);
break;
}
/* disable the carger detection, else signal on DP will be poor */
imxccm_disable_usb2_chrg_detect();
/* power host 1 */
clk_enable(clk_get("pll7_usb_host"));
clk_enable(clk_get("usbphy2_gate"));
/* over current and polarity setting */
bus_space_write_4(sc->iot, sc->nc_ioh, USBNC_USB_UH1_CTRL,
bus_space_read_4(sc->iot, sc->nc_ioh, USBNC_USB_UH1_CTRL) |
(USBNC_USB_UH1_CTRL_OVER_CUR_POL | USBNC_USB_UH1_CTRL_OVER_CUR_DIS));
} else if (hmem.addr == USBOTG_ADDR) {
/* enable usb port power */
switch (board_id)
{
case BOARD_ID_IMX6_CUBOXI:
case BOARD_ID_IMX6_HUMMINGBOARD:
imxgpio_set_bit(EHCI_HUMMINGBOARD_USB_OTG_PWR);
imxgpio_set_dir(EHCI_HUMMINGBOARD_USB_OTG_PWR, IMXGPIO_DIR_OUT);
delay(10);
break;
}
/* disable the carger detection, else signal on DP will be poor */
imxccm_disable_usb1_chrg_detect();
/* power host 0 */
clk_enable(clk_get("pll3_usb_otg"));
clk_enable(clk_get("usbphy1_gate"));
/* over current and polarity setting */
bus_space_write_4(sc->iot, sc->nc_ioh, USBNC_USB_OTG_CTRL,
bus_space_read_4(sc->iot, sc->nc_ioh, USBNC_USB_OTG_CTRL) |
(USBNC_USB_OTG_CTRL_OVER_CUR_POL | USBNC_USB_OTG_CTRL_OVER_CUR_DIS));
}
bus_space_write_4(sc->iot, sc->ph_ioh, USBPHY_CTRL_CLR,
USBPHY_CTRL_CLKGATE);
/* Disable interrupts, so we don't get any spurious ones. */
sc->sc_offs = EREAD1(sc, EHCI_CAPLENGTH);
EOWRITE2(sc, EHCI_USBINTR, 0);
/* Stop then Reset */
uint32_t val = EOREAD4(sc, EHCI_USBCMD);
val &= ~EHCI_CMD_RS;
EOWRITE4(sc, EHCI_USBCMD, val);
while (EOREAD4(sc, EHCI_USBCMD) & EHCI_CMD_RS)
;
val = EOREAD4(sc, EHCI_USBCMD);
val |= EHCI_CMD_HCRESET;
EOWRITE4(sc, EHCI_USBCMD, val);
while (EOREAD4(sc, EHCI_USBCMD) & EHCI_CMD_HCRESET)
;
/* Reset USBPHY module */
bus_space_write_4(sc->iot, sc->ph_ioh, USBPHY_CTRL_SET, USBPHY_CTRL_SFTRST);
delay(10);
/* Remove CLKGATE and SFTRST */
bus_space_write_4(sc->iot, sc->ph_ioh, USBPHY_CTRL_CLR,
USBPHY_CTRL_CLKGATE | USBPHY_CTRL_SFTRST);
delay(10);
/* Power up the PHY */
bus_space_write_4(sc->iot, sc->ph_ioh, USBPHY_PWD, 0);
/* enable FS/LS device */
bus_space_write_4(sc->iot, sc->ph_ioh, USBPHY_CTRL_SET,
USBPHY_CTRL_ENUTMILEVEL2 | USBPHY_CTRL_ENUTMILEVEL3);
/* set host mode */
EWRITE4(sc, EHCI_USBMODE,
EREAD4(sc, EHCI_USBMODE) | EHCI_USBMODE_HOST);
/* set to UTMI mode */
EOWRITE4(sc, EHCI_PORTSC(1),
EOREAD4(sc, EHCI_PORTSC(1)) & ~EHCI_PS_PTS_UTMI_MASK);
printf("\n");
if ((esc = (struct ehci_softc *)config_found(self, NULL, NULL)) == NULL)
goto mmem;
esc->iot = sc->iot;
esc->ioh = sc->ioh;
esc->sc_bus.dmatag = sc->sc_dmat;
esc->sc_offs = sc->sc_offs;
sc->sc_ih = arm_intr_establish(irq, IPL_USB,
ehci_intr, esc, esc->sc_bus.bdev.dv_xname);
if (sc->sc_ih == NULL) {
printf(": unable to establish interrupt\n");
return;
}
strlcpy(esc->sc_vendor, "i.MX6", sizeof(esc->sc_vendor));
r = ehci_init(esc);
if (r != USBD_NORMAL_COMPLETION) {
printf("%s: init failed, error=%d\n",
esc->sc_bus.bdev.dv_xname, r);
goto intr;
}
printf("\n");
config_found((struct device *)esc, &esc->sc_bus, usbctlprint);
goto out;
intr:
arm_intr_disestablish(sc->sc_ih);
sc->sc_ih = NULL;
mmem:
bus_space_unmap(sc->iot, sc->nc_ioh, mmem.size);
pmem:
bus_space_unmap(sc->iot, sc->ph_ioh, pmem.size);
hmem:
bus_space_unmap(sc->iot, sc->uh_ioh, sc->sc_size);
sc->sc_size = 0;
out:
return;
}