Added io/pads example, psxpad.h definitions, bugfixes

1 files changed, 259 insertions, 0 deletions

diff --git a/examples/io/pads/main.c b/examples/io/pads/main.c
new file mode 100644
index 0000000..bb56a27
--- /dev/null
+++ b/examples/io/pads/main.c
@@ -0,0 +1,259 @@
+/*
+ * PSn00bSDK controller polling example
+ * (C) 2021 spicyjpeg - MPL licensed
+ *
+ * This example shows how to poll controllers at high speeds (250 Hz) by using
+ * timer interrupts and communicating with devices on the SPI controller bus
+ * manually rather than relying on the BIOS pad driver, which is limited to
+ * 50/60 Hz and does not support custom commands. The example also demonstrates
+ * using configuration mode commands to force DualShock pads into analog mode
+ * and enable button pressure sensing on DualShock 2 (PS2) controllers.
+ *
+ * See spi.c for details on how the low-level SPI communication driver works.
+ * The DualShock handshaking logic is implemented here (see poll_cb() and
+ * dualshock_init_cb()). There is no support for memory cards in this example,
+ * but the code in spi.c can be used to read/write sectors on a memory card and
+ * combined with a higher-level filesystem driver for full support.
+ *
+ * IMPORTANT: this example doesn't work on pcsx-redux, and hasn't yet been
+ * tested on real hardware and/or with unofficial controllers. It works on
+ * DuckStation and no$psx though.
+ */
+
+#include <sys/types.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <psxetc.h>
+#include <psxgpu.h>
+#include <psxpad.h>
+
+#include "spi.h"
+
+static const char *const PAD_TYPEIDS[] = {
+	"[UNKNOWN]",
+	"MOUSE",
+	"NEGCON",
+	"IRQ10_GUN",
+	"DIGITAL",
+	"ANALOG_STICK",
+	"GUNCON",
+	"ANALOG",
+	"MULTITAP",
+	"[UNKNOWN]",
+	"[UNKNOWN]",
+	"[UNKNOWN]",
+	"[UNKNOWN]",
+	"[UNKNOWN]",
+	"JOGCON",
+	"CONFIG_MODE"
+};
+
+/* Display/GPU context utilities */
+
+#define SCREEN_XRES 320
+#define SCREEN_YRES 240
+
+typedef struct {
+	DISPENV  disp;
+	DRAWENV  draw;
+} DB;
+
+typedef struct {
+	DB       db[2];
+	uint32_t db_active;
+} CONTEXT;
+
+void init_context(CONTEXT *ctx) {
+	DB *db;
+
+	ResetGraph(0);
+	ctx->db_active = 0;
+
+	db = &(ctx->db[0]);
+	SetDefDispEnv(&(db->disp),           0, 0, SCREEN_XRES, SCREEN_YRES);
+	SetDefDrawEnv(&(db->draw), SCREEN_XRES, 0, SCREEN_XRES, SCREEN_YRES);
+	setRGB0(&(db->draw), 63, 0, 127);
+	db->draw.isbg = 1;
+	db->draw.dtd  = 1;
+
+	db = &(ctx->db[1]);
+	SetDefDispEnv(&(db->disp), SCREEN_XRES, 0, SCREEN_XRES, SCREEN_YRES);
+	SetDefDrawEnv(&(db->draw),           0, 0, SCREEN_XRES, SCREEN_YRES);
+	setRGB0(&(db->draw), 63, 0, 127);
+	db->draw.isbg = 1;
+	db->draw.dtd  = 1;
+
+	PutDrawEnv(&(db->draw));
+	//PutDispEnv(&(db->disp));
+
+	// Create a text stream at the top of the screen.
+	FntLoad(960, 0);
+	FntOpen(8, 16, 304, 208, 2, 512);
+}
+
+void display(CONTEXT *ctx) {
+	DB *db;
+
+	DrawSync(0);
+	VSync(0);
+	ctx->db_active ^= 1;
+
+	db = &(ctx->db[ctx->db_active]);
+	PutDrawEnv(&(db->draw));
+	PutDispEnv(&(db->disp));
+	SetDispMask(1);
+}
+
+/* Pad buffers and callback */
+
+static volatile uint8_t  pad_buff[2][34];
+static volatile size_t   pad_buff_len[2];
+static volatile uint32_t pad_digital_only[2] = { 0, 0 };
+
+// Just a wrapper around spi_new_request(). This does not send the command
+// immediately but adds it to the driver's request queue.
+void send_pad_cmd(
+	uint32_t    port,
+	PAD_COMMAND cmd,
+	uint8_t     arg1,
+	uint8_t     arg2,
+	SPICALLBACK callback
+) {
+	SPIREQUEST *req = spi_new_request();
+
+	req->len              = 9;
+	req->port             = port;
+	req->callback         = callback;
+	req->pad_req.addr     = 0x01;
+	req->pad_req.cmd      = cmd;
+	req->pad_req.tap_mode = 0x00;
+	req->pad_req.motor_r  = arg1;
+	req->pad_req.motor_l  = arg2;
+
+	// The padding bytes must be 0xff when unlocking vibration motors.
+	memset(
+		req->pad_req.dummy,
+		(cmd == PAD_CMD_REQUEST_CONFIG) ? 0xff : 0x00,
+		4
+	);
+}
+
+// This callback determines whether a pad that identifies as digital is
+// actually a DualShock in digital mode by checking how it replied to the
+// CONFIG_MODE command.
+void dualshock_init_cb(uint32_t port, const volatile uint8_t *buff, size_t rx_len) {
+	// Flag the pad as digital-only if it didn't reply.
+	// FIXME: rx_len should be 8 for digital pads, but sometimes it's only 4
+	if (rx_len < 4) {
+		printf("no, pad is digital-only (len = %d)\n", rx_len);
+
+		pad_digital_only[port] = 1;
+		return;
+	}
+
+	printf("yes, forcing analog mode (len = %d)\n", rx_len);
+
+	// Issue further commands to finish configuring the controller.
+	// https://gist.github.com/scanlime/5042071
+	send_pad_cmd(port, PAD_CMD_SET_ANALOG,      0x01, 0x02, 0); // 0x03 disables analog button...?
+	send_pad_cmd(port, PAD_CMD_INIT_PRESSURE,   0x00, 0x00, 0); // Ignored by DualShock 1
+	send_pad_cmd(port, PAD_CMD_REQUEST_CONFIG,  0x00, 0x01, 0);
+	send_pad_cmd(port, PAD_CMD_RESPONSE_CONFIG, 0xff, 0xff, 0); // Ignored by DualShock 1
+	send_pad_cmd(port, PAD_CMD_CONFIG_MODE,     0x00, 0x00, 0);
+}
+
+// This function is called by the pad timer ISR each time a pad is polled and a
+// response (even an invalid/incomplete one) is received.
+void poll_cb(uint32_t port, const volatile uint8_t *buff, size_t rx_len) {
+	// Copy the response to a persistent buffer so it can be accessed from the
+	// main loop and displayed on screen.
+	pad_buff_len[port] = rx_len;
+	if (rx_len)
+		memcpy((void *) pad_buff[port], (void *) buff, rx_len);
+
+	PADTYPE *pad = (PADTYPE *) buff;
+
+	// If this pad identifies as a digital pad and hasn't been flagged as a
+	// digital-only pad already, attempt to put it into analog mode by entering
+	// configuration mode. It this fails, it will be flagged as digital-only.
+	// The digital-only flag is reset when the controller is unplugged or stops
+	// returning digital pad responses.
+	if ((pad->raw.prefix == 0x5a) && (pad->raw.type == PAD_ID_DIGITAL)) {
+		if (!pad_digital_only[port]) {
+			printf("Detecting if pad %d supports config mode... ", port + 1);
+
+			send_pad_cmd(
+				port,
+				PAD_CMD_CONFIG_MODE,
+				0x01,
+				0x00,
+				&dualshock_init_cb
+			);
+		}
+
+	} else if (pad_digital_only[port]) {
+		printf("Clearing digital-only flag for pad %d\n", port + 1);
+
+		pad_digital_only[port] = 0;
+	}
+}
+
+/* Main */
+
+static CONTEXT ctx;
+
+int main(int argc, const char* argv[]) {
+	init_context(&ctx);
+	spi_init(&poll_cb);
+
+	uint32_t counter = 0;
+
+	while (1) {
+		FntPrint(-1, "COUNTER=%d", counter++);
+
+		for (uint32_t port = 0; port < 2; port++) {
+			PADTYPE *pad = (PADTYPE *) pad_buff[port];
+
+			// According to nocash docs, there is a hardware bug in DualShock
+			// controllers that causes the prefix byte (normally 0x5a) to turn
+			// into 0x00 if the analog button is pressed after configuration
+			// commands have been used.
+			//if (!pad->raw.prefix != 0x5a) {
+			if (!pad_buff_len[port]) {
+				FntPrint(-1, "\n\nPORT %d: NO DEVICE FOUND\n", port + 1);
+				if ((counter % 64) < 32)
+					FntPrint(-1, " CONNECT PAD NOW...");
+
+				continue;
+			}
+
+			uint32_t type = pad->raw.type;
+			uint32_t len  = pad->raw.len * 2;
+			if (type == PAD_ID_MULTITAP)
+				len = 32;
+
+			FntPrint(
+				-1,
+				"\n\nPORT %d: %s\n TYPE=%d LEN=%d",
+				port + 1,
+				PAD_TYPEIDS[type],
+				type,
+				len
+			);
+
+			// Print a hexdump of the payload returned by the pad.
+			for (uint32_t i = 0; i < len; i++)
+				FntPrint(
+					-1,
+					(i % 8) ? " %02x" : "\n %02x",
+					pad_buff[port][i + 2]
+				);
+		}
+
+		FntFlush(-1);
+		display(&ctx);
+	}
+
+	return 0;
+}