OpenGrok

/* $NetBSD: gecko.c,v 1.1 2026/01/09 22:54:29 jmcneill Exp $ */

/*-
 * Copyright (c) 2025 Jared McNeill <jmcneill (at) invisible.ca>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

/*
 * Serial console support over USB Gecko.
 */

#include <sys/cdefs.h>

__KERNEL_RCSID(0, "$NetBSD: gecko.c,v 1.1 2026/01/09 22:54:29 jmcneill Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/bus.h>
#include <sys/bitops.h>
#include <sys/conf.h>
#include <sys/device.h>
#include <machine/pio.h>
#include <machine/wii.h>

#include <dev/cons.h>

#include "exi.h"
#include "exireg.h"
#include "gecko.h"

#define USBGECKO_CSR					\
	(__SHIFTIN(1, EXI_CSR_CS) |			\
	 __SHIFTIN(EXI_FREQ_32MHZ, EXI_CSR_CLK))
#define USBGECKO_CR(len, rdwr)				\
	(__SHIFTIN((len) - 1, EXI_CR_TLEN) | 		\
	 (rdwr) | EXI_CR_TSTART)

#define USBGECKO_CMD_LED_OFF	0x7000
#define USBGECKO_CMD_LED_ON	0x8000
#define USBGECKO_CMD_ID		0x9000
#define USBGECKO_CMD_RECV_BYTE	0xa000
#define USBGECKO_CMD_SEND_BYTE	0xb000


#define RD4(reg)		in32(EXI_BASE + (reg))
#define WR4(reg, val)		out32(EXI_BASE + (reg), val)

static int	usbgecko_cngetc(dev_t);
static void	usbgecko_cnputc(dev_t, int);
static void	usbgecko_cnpollc(dev_t, int);

static struct cnm_state usbgecko_cnmstate;
static struct consdev usbgecko_consdev = {
	.cn_getc = usbgecko_cngetc,
	.cn_putc = usbgecko_cnputc,
	.cn_pollc = usbgecko_cnpollc,
	.cn_dev = NODEV,
	.cn_pri = CN_NORMAL,
};
static uint32_t usbgecko_chan;
static bool usbgecko_found;

struct usbgecko_softc {
	device_t	sc_dev;
	uint8_t		sc_chan;
	uint8_t		sc_device;
};

static struct usbgecko_softc *usbgecko_sc;

static int	usbgecko_match(device_t, cfdata_t, void *);
static void	usbgecko_attach(device_t, device_t, void *);

CFATTACH_DECL_NEW(gecko, sizeof(struct usbgecko_softc),
    usbgecko_match, usbgecko_attach, NULL, NULL);

static void
usbgecko_wait(void)
{
	int retry;

	for (retry = 0; retry < 1000; retry++) {
		if ((RD4(EXI_CR(usbgecko_chan)) & EXI_CR_TSTART) == 0) {
			return;
		}
	}
}

static uint16_t
usbgecko_command(uint16_t command)
{
	struct usbgecko_softc *sc = usbgecko_sc;
	uint32_t command32 = (uint32_t)command << 16;
	uint16_t value;

	if (sc != NULL) {
		exi_select(sc->sc_chan, sc->sc_device, EXI_FREQ_32MHZ);
		exi_sendrecv_imm(sc->sc_chan, sc->sc_device, &command32,
		    &value, sizeof(value));
		exi_unselect(sc->sc_chan);
	} else {
		WR4(EXI_CSR(usbgecko_chan), USBGECKO_CSR);
		WR4(EXI_DATA(usbgecko_chan), command32);
		WR4(EXI_CR(usbgecko_chan), USBGECKO_CR(2, EXI_CR_RW_READWRITE));
		usbgecko_wait();
		value = RD4(EXI_DATA(usbgecko_chan)) >> 16;
		WR4(EXI_CSR(usbgecko_chan), 0);
	}

	return value;
}

static uint32_t
usbgecko_id(void)
{
	uint32_t value;

	KASSERT(usbgecko_sc == NULL);

	WR4(EXI_CSR(usbgecko_chan), USBGECKO_CSR);
	WR4(EXI_DATA(usbgecko_chan), 0);
	WR4(EXI_CR(usbgecko_chan), USBGECKO_CR(2, EXI_CR_RW_READWRITE));
	usbgecko_wait();
	WR4(EXI_CR(usbgecko_chan), USBGECKO_CR(sizeof(value),
	    EXI_CR_RW_READWRITE));
	usbgecko_wait();
	value = RD4(EXI_DATA(usbgecko_chan));
	WR4(EXI_CSR(usbgecko_chan), 0);

	return value;
}

static int
usbgecko_cngetc(dev_t dev)
{
	uint16_t value;

	value = usbgecko_command(USBGECKO_CMD_RECV_BYTE);
	return (value & 0x0800) == 0 ? -1 : (value & 0xff);
}

static void
usbgecko_cnputc(dev_t dev, int c)
{
	c &= 0xff;
	usbgecko_command(USBGECKO_CMD_SEND_BYTE | (c << 4));
}

static void
usbgecko_cnpollc(dev_t dev, int on)
{
}

static bool
usbgecko_detect(void)
{
	return usbgecko_id() == 0 &&
	       usbgecko_command(USBGECKO_CMD_ID) == 0x0470;
}

void
usbgecko_consinit(void)
{
	WR4(EXI_CSR(0), 0);
	WR4(EXI_CSR(1), 0);
	WR4(EXI_CSR(2), 0);

	WR4(EXI_CSR(0), EXI_CSR_EXTINT | EXI_CSR_EXTINTMASK);
	WR4(EXI_CSR(1), EXI_CSR_EXTINT | EXI_CSR_EXTINTMASK);

	usbgecko_chan = 0;
	if (!usbgecko_detect()) {
		usbgecko_chan = 1;
		if (!usbgecko_detect()) {
			return;
		}
	}

	cn_tab = &usbgecko_consdev;
	cn_init_magic(&usbgecko_cnmstate);
	cn_set_magic("\047\001");

	usbgecko_command(USBGECKO_CMD_LED_ON);
	usbgecko_found = true;
}

static int
usbgecko_match(device_t parent, cfdata_t cf, void *aux)
{
	struct exi_attach_args * const eaa = aux;

	return usbgecko_found &&
	       eaa->eaa_id == 0 &&
	       eaa->eaa_chan == usbgecko_chan &&
	       eaa->eaa_device == 0;
}

static void
usbgecko_attach(device_t parent, device_t self, void *aux)
{
	struct usbgecko_softc *sc = device_private(self);
	struct exi_attach_args * const eaa = aux;

	aprint_naive("\n");
	aprint_normal(": USB Gecko\n");

	sc->sc_dev = self;
	sc->sc_chan = eaa->eaa_chan;
	sc->sc_device = eaa->eaa_device;

	usbgecko_sc = sc;
}