wii - char driver for gba / joybus devices

etc/etc.evbppc/MAKEDEV.conf

@@ -22,6 +22,7 @@ all_md)
 	makedev radio
 	makedev kttcp
 	makedev xlcom0
+	makedev gcport0 gcport1 gcport2 gcport3
 	makedev cfs
 	makedev virtio
 	;;
@@ -32,3 +33,8 @@ xlcom[0-9]*)
 	unit=${i#xlcom}
 	mkdev xlcom$unit c 99 $unit "" "" $u_uucp
 	;;
+
+gcport[0-3]*)
+	unit=${i#gcport}
+	mkdev gcport$unit c 100 $unit "" "" $u_uucp
+	;;

sys/arch/evbppc/conf/NINTENDO

@@ -132,7 +132,11 @@ options 	WSDISPLAY_MULTICONS
 
 ahb0 		at mainbus0 irq 14
 si0		at mainbus0 addr 0x0d006400 irq 3	# Serial interface
-uhid*		at si0
+gcport*		at si0
+uhid0		at gcport0
+uhid1		at gcport1
+uhid2		at gcport2
+uhid3		at gcport3
 exi0		at mainbus0 addr 0x0d006800 irq 4	# External interface
 rtcsram0	at exi0					# RTC/SRAM chip
 gecko0		at exi0					# USB Gecko

sys/arch/evbppc/conf/majors.evbppc

@@ -83,6 +83,8 @@ device-major	twe		char 76 		twe
 #device-major	obsolete	char 98			obsolete (nsmb)
 device-major 	xlcom 		char 99 		xlcom
 
+device-major	gcport		char 100
+
 # Majors up to 143 are reserved for machine-dependent drivers.
 # New machine-independent driver majors are assigned in 
 # sys/conf/majors.

sys/arch/evbppc/nintendo/dev/files.dev

@@ -30,11 +30,16 @@ attach	gecko at exi
 file	arch/evbppc/nintendo/dev/gecko.c		gecko	needs-flag
 
 define	si { }
-device	si: si, hid
+device	si: si
 attach	si at mainbus
 file	arch/evbppc/nintendo/dev/si.c			si
 
-attach	uhid at si with uhid_si
+define	gcport { }
+device	gcport: gcport, hid
+attach	gcport at si with gcport_si
+file	arch/evbppc/nintendo/dev/gcport_si.c		gcport_si
+
+attach	uhid at gcport with uhid_si
 file	arch/evbppc/nintendo/dev/uhid_si.c		uhid_si
 
 define	ahb { [addr=-1], [irq=-1] }

sys/arch/evbppc/nintendo/dev/gcport_si.c

@@ -0,0 +1,277 @@
+/* $NetBSD: gcport_si.c,v 1.0 2026/05/18 22:54:30 gummybuns Exp $ */
+
+/*-
+ * Copyright (c) 2026 ZacBrown <gummybuns@protonmail.com>
+ * 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 AUTHOR ``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 AUTHOR 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.
+ */
+
+#include <sys/cdefs.h>
+__KERNEL_RCSID(0, "$NetBSD: gcport_si.c,v 1.0 2026/05/18 22:53:30 gummybuns Exp $");
+
+#include <sys/bus.h>
+#include <sys/conf.h>
+#include <sys/device.h>
+#include <sys/ioccom.h>
+#include <sys/kmem.h>
+#include <sys/mutex.h>
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/tty.h>
+#include <sys/types.h>
+
+#include <dev/usb/usb.h>
+#include <dev/hid/uhid.h>
+
+#include "si.h"
+#include "joybus.h"
+
+struct si_payload {
+	uint32_t 	insize;		/* bytes to receive. max 128 */
+	uint32_t 	outsize;	/* bytes to send. max 128 */
+	uint32_t	*status;	/* sisr status for this channel */
+	void		*in;		/* buffer to store response */
+	void		*out;		/* buffer to send out to device */
+};
+
+extern struct cfdriver gcport_cd;
+
+#define SI_SEND		_IOWR(0, 1, struct si_payload)
+
+static int gcport_si_match(device_t, cfdata_t, void *);
+static void gcport_si_attach(device_t, device_t, void *);
+static int gcport_si_print(void *, const char *);
+static int gcport_si_rescan(device_t, const char *, const int *);
+static int siioctl_send(struct si_channel *ch, struct si_payload *sp);
+static void gcport_si_work(struct work *, void *);
+
+dev_type_open(gcport_open);
+dev_type_close(gcport_close);
+dev_type_ioctl(gcport_ioctl);
+
+const struct cdevsw gcport_cdevsw = {
+	.d_open = gcport_open,
+	.d_close = gcport_close,
+	.d_ioctl = gcport_ioctl,
+	.d_read = noread,
+	.d_write = nowrite,
+	.d_stop = nostop,
+	.d_tty = notty,
+	.d_poll = nopoll,
+	.d_mmap = nommap,
+	.d_kqfilter = nokqfilter,
+	.d_discard = nodiscard,
+	.d_flag = D_OTHER
+};
+
+CFATTACH_DECL_NEW(gcport_si, sizeof(struct gcport_softc),
+	gcport_si_match, gcport_si_attach, NULL, NULL);
+
+static int
+gcport_si_match(device_t parent, cfdata_t cf, void *aux)
+{
+	return 1;
+}
+
+static void
+gcport_si_attach(device_t parent, device_t self, void *aux)
+{
+	struct si_softc * const psc = device_private(parent);
+	struct si_attach_args * const saa = aux;
+	struct gcport_softc * const sc = device_private(self);
+	struct si_channel *ch = &psc->sc_chan[saa->saa_index];
+	int err;
+
+	sc->sc_dev = self;
+	sc->ch = ch;
+	sc->sc_bst = psc->sc_bst;
+	sc->sc_bsh = psc->sc_bsh;
+	ch->ch_gcport_dev = self;
+
+	err = workqueue_create(&ch->ch_wqp, "gcport", gcport_si_work, ch,
+	    PRI_NONE, IPL_VM, 0);
+	if (err != 0) {
+		aprint_normal("gcport_si: ch%d failed to create workqueue\n",
+		    ch->ch_index);
+		ch->ch_wqp = NULL;
+	}
+	gcport_si_rescan(self, NULL, NULL);
+}
+
+static int
+gcport_si_print(void *aux, const char *pnp)
+{
+	struct si_attach_args *saa = aux;
+
+	if (pnp != NULL) {
+		aprint_normal("uhid at %s", pnp);
+	}
+
+	/*
+	 * The Wii Operations Manual for RVL-001 refers to the controller
+	 * ports as "Nintendo GameCube Controller Sockets".
+	 */
+	aprint_normal(" socket %d", saa->saa_index + 1);
+
+	return UNCONF;
+}
+
+int
+gcport_open(dev_t dev, int flags, int mode, struct lwp *l)
+{
+	struct gcport_softc *sc;
+	struct si_channel *ch;
+	int error;
+
+	sc = device_lookup_private(&gcport_cd, minor(dev));
+
+	if (sc == NULL) {
+		return ENXIO;
+	}
+
+	ch = sc->ch;
+	mutex_enter(&ch->ch_lock);
+
+	if (ISSET(ch->ch_state, SI_STATE_OPEN)) {
+		error = EBUSY;
+		goto unlock;
+	}
+
+	ch->ch_state |= SI_STATE_OPEN;
+	error = 0;
+unlock:
+	mutex_exit(&ch->ch_lock);
+	return error;
+}
+
+int
+gcport_close(dev_t dev, int flags, int mode, struct lwp *l)
+{
+	struct gcport_softc *sc = device_lookup_private(&gcport_cd, minor(dev));
+	struct si_channel *ch = sc->ch;
+
+	mutex_enter(&ch->ch_lock);
+	ch->ch_state &= ~(SI_STATE_OPEN | SI_STATE_STOPPED);
+
+	/* cv_init is called in parent's si_attach */
+	cv_broadcast(&ch->ch_cv);
+
+	mutex_exit(&ch->ch_lock);
+	return 0;
+}
+
+static int
+gcport_si_rescan(device_t self, const char *ifattr, const int *locs)
+{
+	struct si_attach_args saa;
+	unsigned is_gcpad;
+	int res;
+	device_t uhid_dev;
+	struct gcport_softc * const gsc = device_private(self);
+	struct si_channel *ch = gsc->ch;
+	struct si_softc *sc = ch->ch_sc;
+
+	ch->ch_id = si_identify(sc, ch->ch_index);
+	is_gcpad = IS_GCPAD(ch->ch_id);
+
+	if (is_gcpad && ch->ch_uhid_dev == NULL) {
+		saa.saa_hidev = &ch->ch_hidev;
+		saa.saa_index = ch->ch_index;
+		uhid_dev = config_found(self, &saa, gcport_si_print, CFARGS_NONE);
+		ch->ch_uhid_dev = uhid_dev;
+	} else if (!is_gcpad && ch->ch_uhid_dev != NULL) {
+		res = config_detach_children(ch->ch_gcport_dev, 0);
+		if (res == 0) {
+			ch->ch_uhid_dev = NULL;
+		}
+	}
+
+	return 0;
+
+}
+
+void gcport_si_work(struct work *wk, void *arg)
+{
+	struct si_channel *ch = arg;
+	gcport_si_rescan(ch->ch_gcport_dev, NULL, NULL);
+}
+
+int
+gcport_ioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
+{
+	struct gcport_softc *sc = device_lookup_private(&gcport_cd, minor(dev));
+	struct si_channel *ch = sc->ch;
+	int err;
+
+	switch(cmd) {
+	case SI_SEND:
+		err = siioctl_send(ch, (struct si_payload *)data);
+		break;
+	default:
+		err = EINVAL;
+		break;
+	}
+
+	return err;
+}
+
+static int
+siioctl_send(struct si_channel *ch, struct si_payload *p)
+{
+	int err, outsize_r, insize_r;
+	struct si_softc *sc;
+	struct siio_send sd;
+
+	err = 0;
+	sc = ch->ch_sc;
+
+	/* siiobuf must to be written in increments of 4 bytes */
+	outsize_r = roundup(p->outsize, 4);
+	insize_r = roundup(p->insize, 4);
+
+	sd.out = kmem_zalloc(outsize_r, KM_SLEEP);
+	sd.in = kmem_zalloc(insize_r, KM_SLEEP);
+	sd.chan = ch->ch_index;
+	sd.outsize = p->outsize;
+	sd.insize = p->insize;
+
+	if ((err = copyin(p->out, sd.out, sd.outsize)) != 0) {
+		goto si_send_cleanup;
+	}
+
+	if ((err = si_send(sc, &sd)) != 0) {
+		goto si_send_cleanup;
+	}
+
+	if ((err = copyout(sd.in, p->in, sd.insize)) != 0) {
+		goto si_send_cleanup;
+	}
+
+	if ((err = copyout(&sd.status, p->status, sizeof(uint32_t))) != 0) {
+		goto si_send_cleanup;
+	}
+si_send_cleanup:
+	kmem_free(sd.out, outsize_r);
+	kmem_free(sd.in, insize_r);
+	return err;
+}