xref: /openbsd-src/sys/arch/octeon/dev/octuctl.c (revision fe5dbe476cf4c4896041a8fff255ac2e7a02e845)

/*	$OpenBSD: octuctl.c,v 1.2 2017/07/25 11:01:28 jmatthew Exp $ */

/*
 * Copyright (c) 2015 Jonathan Matthew  <jmatthew@openbsd.org>
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>

#include <machine/intr.h>
#include <machine/bus.h>
#include <machine/octeonreg.h>
#include <machine/octeonvar.h>
#include <machine/fdt.h>

#include <octeon/dev/iobusvar.h>
#include <octeon/dev/octuctlreg.h>
#include <octeon/dev/octuctlvar.h>

struct octuctl_softc {
	struct device		sc_dev;
	bus_space_tag_t		sc_iot;
	bus_space_handle_t	sc_ioh;
};

int	octuctl_match(struct device *, void *, void *);
void	octuctl_attach(struct device *, struct device *, void *);

const struct cfattach octuctl_ca = {
	sizeof(struct octuctl_softc), octuctl_match, octuctl_attach,
};

struct cfdriver octuctl_cd = {
	NULL, "octuctl", DV_DULL
};

uint8_t octuctl_read_1(bus_space_tag_t, bus_space_handle_t, bus_size_t);
uint16_t octuctl_read_2(bus_space_tag_t, bus_space_handle_t, bus_size_t);
uint32_t octuctl_read_4(bus_space_tag_t, bus_space_handle_t, bus_size_t);
void octuctl_write_1(bus_space_tag_t, bus_space_handle_t, bus_size_t, uint8_t);
void octuctl_write_2(bus_space_tag_t, bus_space_handle_t, bus_size_t, uint16_t);
void octuctl_write_4(bus_space_tag_t, bus_space_handle_t, bus_size_t, uint32_t);

bus_space_t octuctl_tag = {
	.bus_base = PHYS_TO_XKPHYS(0, CCA_NC),
	.bus_private = NULL,
	._space_read_1 = octuctl_read_1,
	._space_write_1 = octuctl_write_1,
	._space_read_2 = octuctl_read_2,
	._space_write_2 = octuctl_write_2,
	._space_read_4 = octuctl_read_4,
	._space_write_4 = octuctl_write_4,
	._space_map = iobus_space_map,
	._space_unmap = iobus_space_unmap,
	._space_subregion = generic_space_region,
	._space_vaddr = generic_space_vaddr
};

uint8_t
octuctl_read_1(bus_space_tag_t t, bus_space_handle_t h, bus_size_t o)
{
	return *(volatile uint8_t *)(h + (o^3));
}

uint16_t
octuctl_read_2(bus_space_tag_t t, bus_space_handle_t h, bus_size_t o)
{
	return *(volatile uint16_t *)(h + (o^2));
}

uint32_t
octuctl_read_4(bus_space_tag_t t, bus_space_handle_t h, bus_size_t o)
{
	return *(volatile uint32_t *)(h + o);
}

void
octuctl_write_1(bus_space_tag_t t, bus_space_handle_t h, bus_size_t o, uint8_t v)
{
	*(volatile uint8_t *)(h + (o^3)) = v;
}

void
octuctl_write_2(bus_space_tag_t t, bus_space_handle_t h, bus_size_t o, uint16_t v)
{
	*(volatile uint16_t *)(h + (o^2)) = v;
}

void
octuctl_write_4(bus_space_tag_t t, bus_space_handle_t h, bus_size_t o, uint32_t v)
{
	*(volatile uint32_t *)(h + o) = v;
}

int
octuctl_match(struct device *parent, void *match, void *aux)
{
	struct fdt_attach_args *faa = aux;

	return OF_is_compatible(faa->fa_node, "cavium,octeon-6335-uctl");
}

int
octuctlprint(void *aux, const char *parentname)
{
	return (QUIET);
}

void
octuctl_clock_setup(struct octuctl_softc *sc, uint64_t ctl)
{
	int div;
	int lastdiv;
	int validdiv[] = { 1, 2, 3, 4, 6, 8, 12, INT_MAX };
	int i;

	div = octeon_ioclock_speed() / UCTL_CLK_TARGET_FREQ;

	/* start usb controller reset */
	ctl |= UCTL_CLK_RST_CTL_P_POR;
	ctl &= ~(UCTL_CLK_RST_CTL_HRST |
	    UCTL_CLK_RST_CTL_P_PRST |
	    UCTL_CLK_RST_CTL_O_CLKDIV_EN |
	    UCTL_CLK_RST_CTL_H_CLKDIV_EN |
	    UCTL_CLK_RST_CTL_H_CLKDIV_RST |
	    UCTL_CLK_RST_CTL_O_CLKDIV_RST);
	bus_space_write_8(sc->sc_iot, sc->sc_ioh, UCTL_CLK_RST_CTL, ctl);

	/* set up for 12mhz crystal */
	ctl &= ~((3 << UCTL_CLK_RST_CTL_P_REFCLK_DIV_SHIFT) |
	    (3 << UCTL_CLK_RST_CTL_P_REFCLK_SEL_SHIFT));
	bus_space_write_8(sc->sc_iot, sc->sc_ioh, UCTL_CLK_RST_CTL, ctl);

	/* set clock divider */
	lastdiv = 1;
	for (i = 0; i < nitems(validdiv); i++) {
		if (div < validdiv[i]) {
			div = lastdiv;
			break;
		}
		lastdiv = validdiv[i];
	}

	ctl &= ~(0xf << UCTL_CLK_RST_CTL_H_DIV_SHIFT);
	ctl |= (div << UCTL_CLK_RST_CTL_H_DIV_SHIFT);
	bus_space_write_8(sc->sc_iot, sc->sc_ioh, UCTL_CLK_RST_CTL, ctl);

	/* turn hclk on */
	ctl = bus_space_read_8(sc->sc_iot, sc->sc_ioh,
	    UCTL_CLK_RST_CTL);
	ctl |= UCTL_CLK_RST_CTL_H_CLKDIV_EN;
	bus_space_write_8(sc->sc_iot, sc->sc_ioh, UCTL_CLK_RST_CTL, ctl);
	ctl |= UCTL_CLK_RST_CTL_H_CLKDIV_RST;
	bus_space_write_8(sc->sc_iot, sc->sc_ioh, UCTL_CLK_RST_CTL, ctl);

	delay(1);

	/* power-on-reset finished */
	ctl &= ~UCTL_CLK_RST_CTL_P_POR;
	bus_space_write_8(sc->sc_iot, sc->sc_ioh, UCTL_CLK_RST_CTL, ctl);

	delay(1000);

	/* set up ohci clocks */
	ctl |= UCTL_CLK_RST_CTL_O_CLKDIV_RST;
	bus_space_write_8(sc->sc_iot, sc->sc_ioh, UCTL_CLK_RST_CTL, ctl);
	ctl |= UCTL_CLK_RST_CTL_O_CLKDIV_EN;
	bus_space_write_8(sc->sc_iot, sc->sc_ioh, UCTL_CLK_RST_CTL, ctl);

	delay(1);

	/* phy reset */
	ctl |= UCTL_CLK_RST_CTL_P_PRST;
	bus_space_write_8(sc->sc_iot, sc->sc_ioh, UCTL_CLK_RST_CTL, ctl);

	delay(1);

	/* clear host reset */
	ctl |= UCTL_CLK_RST_CTL_HRST;
	bus_space_write_8(sc->sc_iot, sc->sc_ioh, UCTL_CLK_RST_CTL, ctl);
}

void
octuctl_attach(struct device *parent, struct device *self, void *aux)
{
	struct fdt_attach_args *faa = aux;
	struct octuctl_softc *sc = (struct octuctl_softc *)self;
	struct octuctl_attach_args uaa;
	uint64_t port_ctl;
	uint64_t ctl;
	uint64_t preg;
	uint64_t txvref;
	uint32_t reg[4];
	int port;
	int node;
	int rc;

	if (faa->fa_nreg != 1) {
		printf(": expected one IO space, got %d\n", faa->fa_nreg);
		return;
	}

	sc->sc_iot = faa->fa_iot;
	if (bus_space_map(sc->sc_iot, faa->fa_reg[0].addr, faa->fa_reg[0].size,
	    0, &sc->sc_ioh)) {
		printf(": could not map IO space\n");
		return;
	}

	rc = OF_getpropint(faa->fa_node, "#address-cells", 0);
	if (rc != 2) {
		printf(": expected #address-cells 2, got %d\n", rc);
		return;
	}
	rc = OF_getpropint(faa->fa_node, "#size-cells", 0);
	if (rc != 2) {
		printf(": expected #size-cells 2, got %d\n", rc);
		return;
	}

	/* do clock setup if not already done */
	bus_space_write_8(sc->sc_iot, sc->sc_ioh, UCTL_IF_ENA,
	    UCTL_IF_ENA_EN);
	ctl = bus_space_read_8(sc->sc_iot, sc->sc_ioh, UCTL_CLK_RST_CTL);
	if ((ctl & UCTL_CLK_RST_CTL_HRST) == 0)
		octuctl_clock_setup(sc, ctl);

	/* port phy settings */
	for (port = 0; port < 2; port++) {
		preg = UCTL_UPHY_PORTX_STATUS + (port * 8);
		port_ctl = bus_space_read_8(sc->sc_iot, sc->sc_ioh, preg);
		txvref = 0xf;
		port_ctl |= (UCTL_UPHY_PORTX_STATUS_TXPREEMPHTUNE |
		    UCTL_UPHY_PORTX_STATUS_TXRISETUNE |
		    (txvref << UCTL_UPHY_PORTX_STATUS_TXVREF_SHIFT));
		bus_space_write_8(sc->sc_iot, sc->sc_ioh, preg, port_ctl);
	}

	printf("\n");

	uaa.aa_octuctl_bust = sc->sc_iot;
	uaa.aa_bust = &octuctl_tag;
	uaa.aa_dmat = faa->fa_dmat;
	uaa.aa_ioh = sc->sc_ioh;

	for (node = OF_child(faa->fa_node); node != 0; node = OF_peer(node)) {
		if (OF_getproplen(node, "reg") != sizeof(reg))
			continue;

		OF_getpropintarray(node, "reg", reg, sizeof(reg));
		uaa.aa_reg.addr = (((uint64_t)reg[0]) << 32) | reg[1];
		uaa.aa_reg.size = (((uint64_t)reg[2]) << 32) | reg[3];
		uaa.aa_node = node;
		config_found(self, &uaa, octuctlprint);
	}
}