/*	$OpenBSD: octiic.c,v 1.3 2020/09/10 16:40:40 visa Exp $	*/

/*
 * Copyright (c) 2019 Visa Hankala
 *
 * Permission to use, copy, modify, and 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.
 */

/*
 * Driver for OCTEON two-wire serial interface core.
 */

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

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

#define _I2C_PRIVATE
#include <dev/i2c/i2cvar.h>

#include <dev/ofw/fdt.h>
#include <dev/ofw/openfirm.h>
#include <dev/ofw/ofw_misc.h>

struct octiic_softc {
	struct device		 sc_dev;
	int			 sc_node;
	bus_space_tag_t		 sc_iot;
	bus_space_handle_t	 sc_ioh;

	struct i2c_bus		 sc_i2c_bus;
	struct i2c_controller	 sc_i2c_tag;
	struct rwlock		 sc_i2c_lock;

	int			 sc_start_sent;
};

int	octiic_match(struct device *, void *, void *);
void	octiic_attach(struct device *, struct device *, void *);

int	octiic_i2c_acquire_bus(void *, int);
void	octiic_i2c_release_bus(void *, int);
int	octiic_i2c_send_start(void *, int);
int	octiic_i2c_send_stop(void *, int);
int	octiic_i2c_initiate_xfer(void *, i2c_addr_t, int);
int	octiic_i2c_read_byte(void *, uint8_t *, int);
int	octiic_i2c_write_byte(void *, uint8_t, int);
void	octiic_i2c_scan(struct device *, struct i2cbus_attach_args *, void *);

int	octiic_reg_read(struct octiic_softc *, uint8_t, uint8_t *);
int	octiic_reg_write(struct octiic_softc *, uint8_t, uint8_t);
int	octiic_set_clock(struct octiic_softc *, uint32_t);
int	octiic_wait(struct octiic_softc *, uint8_t, int);

const struct cfattach octiic_ca = {
	sizeof(struct octiic_softc), octiic_match, octiic_attach
};

struct cfdriver octiic_cd = {
	NULL, "octiic", DV_DULL
};

#define TWSI_RD_8(sc, reg) \
	bus_space_read_8((sc)->sc_iot, (sc)->sc_ioh, (reg))
#define TWSI_WR_8(sc, reg, val) \
	bus_space_write_8((sc)->sc_iot, (sc)->sc_ioh, (reg), (val))

#define TWSI_SW_TWSI		0x00
#define   TWSI_SW_TWSI_V		0x8000000000000000ull
#define   TWSI_SW_TWSI_SLONLY		0x4000000000000000ull
#define   TWSI_SW_TWSI_EIA		0x2000000000000000ull
#define   TWSI_SW_TWSI_OP_M		0x1e00000000000000ull
#define   TWSI_SW_TWSI_OP_S		57
#define   TWSI_SW_TWSI_R                0x0100000000000000ull
#define   TWSI_SW_TWSI_SOVR		0x0080000000000000ull
#define   TWSI_SW_TWSI_SIZE_M		0x0070000000000000ull
#define   TWSI_SW_TWSI_SIZE_S		52
#define   TWSI_SW_TWSI_SCR_M		0x000c000000000000ull
#define   TWSI_SW_TWSI_SCR_S		50
#define   TWSI_SW_TWSI_A_M		0x0003ff0000000000ull
#define   TWSI_SW_TWSI_A_S		40
#define   TWSI_SW_TWSI_IA_M		0x000000f800000000ull
#define   TWSI_SW_TWSI_IA_S		35
#define   TWSI_SW_TWSI_EOP_IA_M		0x0000000700000000ull
#define   TWSI_SW_TWSI_EOP_IA_S		32
#define   TWSI_SW_TWSI_D_M		0x00000000ffffffffull

/* Opcodes for field TWSI_SW_TWSI_OP */
#define TWSI_OP_CLK			0x04
#define TWSI_OP_EOP			0x06

/* Addresses for field TWSI_SW_TWSI_IA */
#define TWSI_IA_DATA			0x01
#define TWSI_IA_CTL			0x02
#define TWSI_IA_CLKCTL			0x03	/* write only */
#define TWSI_IA_STAT			0x03	/* read only */
#define TWSI_IA_RST			0x07

#define TWSI_INT		0x10

/* Control register bits */
#define TWSI_CTL_CE			0x80
#define TWSI_CTL_ENAB			0x40
#define TWSI_CTL_STA			0x20
#define TWSI_CTL_STP			0x10
#define TWSI_CTL_IFLG			0x08
#define TWSI_CTL_AAK			0x04

/* Core states */
#define TWSI_STAT_ERROR			0x00
#define TWSI_STAT_START			0x08
#define TWSI_STAT_RSTART		0x10
#define TWSI_STAT_AWT_ACK		0x18
#define TWSI_STAT_MBT_ACK		0x28
#define TWSI_STAT_ART_ACK		0x40
#define TWSI_STAT_MBR_ACK		0x50
#define TWSI_STAT_MBR_NAK		0x58
#define TWSI_STAT_IDLE			0xf8

int
octiic_match(struct device *parent, void *match, void *aux)
{
	struct fdt_attach_args *fa = aux;

	return OF_is_compatible(fa->fa_node, "cavium,octeon-3860-twsi") ||
	    OF_is_compatible(fa->fa_node, "cavium,octeon-7890-twsi");
}

void
octiic_attach(struct device *parent, struct device *self, void *aux)
{
	struct i2cbus_attach_args iba;
	struct fdt_attach_args *faa = aux;
	struct octiic_softc *sc = (struct octiic_softc *)self;
	uint32_t freq;

	sc->sc_node = faa->fa_node;
	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(": failed to map registers\n");
		return;
	}

	freq = OF_getpropint(faa->fa_node, "clock-frequency", 100000);
	if (octiic_set_clock(sc, freq) != 0) {
		printf(": clock setup failed\n");
		return;
	}

	/* Reset the controller. */
	if (octiic_reg_write(sc, TWSI_IA_RST, 0) != 0) {
		printf(": register write timeout\n");
		return;
	}

	delay(1000);

	if (octiic_wait(sc, TWSI_STAT_IDLE, I2C_F_POLL) != 0) {
		printf(": reset failed\n");
		return;
	}

	printf("\n");

	rw_init(&sc->sc_i2c_lock, "iiclk");
	sc->sc_i2c_tag.ic_cookie = sc;
	sc->sc_i2c_tag.ic_acquire_bus = octiic_i2c_acquire_bus;
	sc->sc_i2c_tag.ic_release_bus = octiic_i2c_release_bus;
	sc->sc_i2c_tag.ic_send_start = octiic_i2c_send_start;
	sc->sc_i2c_tag.ic_send_stop = octiic_i2c_send_stop;
	sc->sc_i2c_tag.ic_initiate_xfer = octiic_i2c_initiate_xfer;
	sc->sc_i2c_tag.ic_read_byte = octiic_i2c_read_byte;
	sc->sc_i2c_tag.ic_write_byte = octiic_i2c_write_byte;

	memset(&iba, 0, sizeof(iba));
	iba.iba_name = "iic";
	iba.iba_tag = &sc->sc_i2c_tag;
	iba.iba_bus_scan = octiic_i2c_scan;
	iba.iba_bus_scan_arg = sc;
	config_found(self, &iba, iicbus_print);

	sc->sc_i2c_bus.ib_node = sc->sc_node;
	sc->sc_i2c_bus.ib_ic = &sc->sc_i2c_tag;
	i2c_register(&sc->sc_i2c_bus);
}

int
octiic_i2c_acquire_bus(void *arg, int flags)
{
	struct octiic_softc *sc = arg;

	if (cold || (flags & I2C_F_POLL))
		return 0;

	return rw_enter(&sc->sc_i2c_lock, RW_WRITE | RW_INTR);
}

void
octiic_i2c_release_bus(void *arg, int flags)
{
	struct octiic_softc *sc = arg;

	if (cold || (flags & I2C_F_POLL))
		return;

	rw_exit(&sc->sc_i2c_lock);
}

int
octiic_i2c_send_start(void *cookie, int flags)
{
	struct octiic_softc *sc = cookie;
	int error;
	uint8_t nstate;

	error = octiic_reg_write(sc, TWSI_IA_CTL, TWSI_CTL_ENAB | TWSI_CTL_STA);
	if (error != 0)
		return error;

	delay(10);

	if (sc->sc_start_sent)
		nstate = TWSI_STAT_RSTART;
	else
		nstate = TWSI_STAT_START;
	error = octiic_wait(sc, nstate, flags);
	if (error != 0)
		return error;

	sc->sc_start_sent = 1;

	return 0;
}

int
octiic_i2c_send_stop(void *cookie, int flags)
{
	struct octiic_softc *sc = cookie;

	sc->sc_start_sent = 0;

	return octiic_reg_write(sc, TWSI_IA_CTL, TWSI_CTL_ENAB | TWSI_CTL_STP);
}

int
octiic_i2c_initiate_xfer(void *cookie, i2c_addr_t addr, int flags)
{
	struct octiic_softc *sc = cookie;
	int error;
	uint8_t mode = 0, nstate;

	error = octiic_i2c_send_start(sc, flags);
	if (error != 0)
		return error;

	if (flags & I2C_F_READ)
		mode = 0x01;
	nstate = flags & I2C_F_READ ? TWSI_STAT_ART_ACK : TWSI_STAT_AWT_ACK;

	/* Handle 10-bit addressing. */
	if (addr > 0x7f) {
		octiic_reg_write(sc, TWSI_IA_DATA, ((addr >> 7) << 1) | mode);
		octiic_reg_write(sc, TWSI_IA_CTL, TWSI_CTL_ENAB);

		error = octiic_wait(sc, nstate, flags);
		if (error != 0)
			return error;
	}

	octiic_reg_write(sc, TWSI_IA_DATA, ((addr & 0x7f) << 1) | mode);
	octiic_reg_write(sc, TWSI_IA_CTL, TWSI_CTL_ENAB);

	error = octiic_wait(sc, nstate, flags);
	if (error != 0)
		return error;

	return 0;
}

int
octiic_i2c_read_byte(void *cookie, uint8_t *datap, int flags)
{
	struct octiic_softc *sc = cookie;
	int error;
	uint8_t ctl, nstate;

	ctl = TWSI_CTL_ENAB;
	if ((flags & I2C_F_LAST) == 0)
		ctl |= TWSI_CTL_AAK;
	octiic_reg_write(sc, TWSI_IA_CTL, ctl);

	nstate = flags & I2C_F_LAST ? TWSI_STAT_MBR_NAK : TWSI_STAT_MBR_ACK;
	error = octiic_wait(sc, nstate, flags);
	if (error != 0)
		return error;

	octiic_reg_read(sc, TWSI_IA_DATA, datap);

	if (flags & I2C_F_STOP)
		error = octiic_i2c_send_stop(sc, flags);

	return 0;
}

int
octiic_i2c_write_byte(void *cookie, uint8_t data, int flags)
{
	struct octiic_softc *sc = cookie;
	int error;

	octiic_reg_write(sc, TWSI_IA_DATA, data);
	octiic_reg_write(sc, TWSI_IA_CTL, TWSI_CTL_ENAB);

	error = octiic_wait(sc, TWSI_STAT_MBT_ACK, flags);
	if (error != 0)
		return error;

	if (flags & I2C_F_STOP)
		error = octiic_i2c_send_stop(sc, flags);

	return error;
}

void
octiic_i2c_scan(struct device *self, struct i2cbus_attach_args *iba, void *arg)
{
	struct i2c_attach_args ia;
	char name[32];
	uint32_t reg[1];
	struct octiic_softc *sc = arg;
	int node;

	for (node = OF_child(sc->sc_node); node != 0; node = OF_peer(node)) {
		memset(name, 0, sizeof(name));
		memset(reg, 0, sizeof(reg));

		if (OF_getprop(node, "compatible", name, sizeof(name)) == -1)
			continue;
		if (name[0] == '\0')
			continue;

		if (OF_getprop(node, "reg", &reg, sizeof(reg)) != sizeof(reg))
			continue;

		memset(&ia, 0, sizeof(ia));
		ia.ia_tag = iba->iba_tag;
		ia.ia_addr = reg[0];
		ia.ia_name = name;
		ia.ia_cookie = &node;
		config_found(self, &ia, iic_print);
	}
}

int
octiic_reg_read(struct octiic_softc *sc, uint8_t reg, uint8_t *pval)
{
	uint64_t data;
	int timeout;

	TWSI_WR_8(sc, TWSI_SW_TWSI, TWSI_SW_TWSI_V | TWSI_SW_TWSI_R |
	    ((uint64_t)TWSI_OP_EOP << TWSI_SW_TWSI_OP_S) |
	    ((uint64_t)reg << TWSI_SW_TWSI_EOP_IA_S));

	for (timeout = 100000; timeout > 0; timeout--) {
		data = TWSI_RD_8(sc, TWSI_SW_TWSI);
		if ((data & TWSI_SW_TWSI_V) == 0)
			break;
		delay(1);
	}
	if (timeout == 0)
		return ETIMEDOUT;

	*pval = (uint8_t)data;
	return 0;
}

int
octiic_reg_write(struct octiic_softc *sc, uint8_t reg, uint8_t val)
{
	uint64_t data;
	int timeout;

	TWSI_WR_8(sc, TWSI_SW_TWSI, TWSI_SW_TWSI_V |
	    ((uint64_t)TWSI_OP_EOP << TWSI_SW_TWSI_OP_S) |
	    ((uint64_t)reg << TWSI_SW_TWSI_EOP_IA_S) | val);

	for (timeout = 100000; timeout > 0; timeout--) {
		data = TWSI_RD_8(sc, TWSI_SW_TWSI);
		if ((data & TWSI_SW_TWSI_V) == 0)
			break;
		delay(1);
	}
	if (timeout == 0)
		return ETIMEDOUT;

	return 0;
}

/*
 * Wait until the controller has finished current operation.
 * Fail if the new state is not `nstate'.
 */
int
octiic_wait(struct octiic_softc *sc, uint8_t nstate, int flags)
{
	uint8_t ctl, stat;
	int timeout;

	for (timeout = 100000; timeout > 0; timeout--) {
		octiic_reg_read(sc, TWSI_IA_CTL, &ctl);
		if (ctl & TWSI_CTL_IFLG)
			break;
	}

	octiic_reg_read(sc, TWSI_IA_STAT, &stat);
	if (stat != nstate)
		return EIO;

	return 0;
}

int
octiic_set_clock(struct octiic_softc *sc, uint32_t freq)
{
	uint64_t best_tclk = 0, tclk;
	uint64_t ioclk = octeon_ioclock_speed();
	int best_m = 2, best_n = 0, best_thp = 24;
	int m, n, thp;

	/*
	 * Find a combination of clock dividers `thp', `m' and `n' that gives
	 * bus frequency close to but no more than `freq'.
	 */
#define TCLK(ioclk, thp, n, m) \
    ((ioclk) / (20 * ((thp) + 1) * (1 << (n)) * ((m) + 1)))
	for (thp = 6; thp <= 72 && best_tclk < freq; thp <<= 1) {
		for (n = 7; n > 0; n--) {
			if (TCLK(ioclk, thp, n, 16) > freq)
				break;
		}
		for (m = 15; m > 2; m--) {
			if (TCLK(ioclk, thp, n, m - 1) > freq)
				break;
		}

		tclk = TCLK(ioclk, thp, n, m);
		if (tclk <= freq && tclk > best_tclk) {
			best_tclk = tclk;
			best_thp = thp;
			best_m = m;
			best_n = n;
		}
	}
#undef TCLK

	TWSI_WR_8(sc, TWSI_SW_TWSI, TWSI_SW_TWSI_V |
	    ((uint64_t)TWSI_OP_CLK << TWSI_SW_TWSI_OP_S) | best_thp);

	octiic_reg_write(sc, TWSI_IA_CLKCTL, (best_m << 3) | best_n);

	return 0;
}