Merge pull request #43 from spicyjpeg/cmake

Even more CMake fixes, submodules, pads example

4 files changed, 580 insertions, 0 deletions

diff --git a/examples/io/pads/CMakeLists.txt b/examples/io/pads/CMakeLists.txt
new file mode 100644
index 0000000..5bd7f5d
--- /dev/null
+++ b/examples/io/pads/CMakeLists.txt
@@ -0,0 +1,22 @@
+# PSn00bSDK example CMake script
+# (C) 2021 spicyjpeg - MPL licensed
+
+cmake_minimum_required(VERSION 3.20)
+
+if(NOT DEFINED CMAKE_TOOLCHAIN_FILE AND DEFINED ENV{PSN00BSDK_LIBS})
+	set(CMAKE_TOOLCHAIN_FILE $ENV{PSN00BSDK_LIBS}/cmake/sdk.cmake)
+endif()
+
+project(
+	pads
+	LANGUAGES    C ASM
+	VERSION      1.0.0
+	DESCRIPTION  "PSn00bSDK controller polling example"
+	HOMEPAGE_URL "http://lameguy64.net/?page=psn00bsdk"
+)
+
+file(GLOB _sources *.c *.s)
+psn00bsdk_add_executable(pads STATIC ${_sources})
+#psn00bsdk_add_cd_image(pads_iso pads iso.xml DEPENDS pads)
+
+install(FILES ${PROJECT_BINARY_DIR}/pads.exe TYPE BIN)
diff --git a/examples/io/pads/main.c b/examples/io/pads/main.c
new file mode 100644
index 0000000..92beb1c
--- /dev/null
+++ b/examples/io/pads/main.c
@@ -0,0 +1,279 @@
+/*
+ * 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 hasn't yet been tested on real hardware and/or with
+ * unofficial controllers, which might behave differently at higher poll rates.
+ * Also keep in mind that many emulators emulate controllers and memory cards
+ * inaccurately. It is thus recommended to test controller I/O code extensively
+ * and handle as many edge cases as possible (e.g. partial but valid responses,
+ * zerofilled responses, slow replies) for maximum compatibility.
+ */
+
+#include <stdint.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
+
+#define BGCOLOR_R 48
+#define BGCOLOR_G 24
+#define BGCOLOR_B  0
+
+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), BGCOLOR_R, BGCOLOR_G, BGCOLOR_B);
+	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), BGCOLOR_R, BGCOLOR_G, BGCOLOR_B);
+	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 identified as digital is
+// actually a DualShock in digital mode by checking if it started identifying
+// as CONFIG_MODE after receiving a configuration command.
+void dualshock_init_cb(uint32_t port, const volatile uint8_t *buff, size_t rx_len) {
+	PADTYPE *pad = (PADTYPE *) buff;
+
+	if (
+		(rx_len < 2) ||
+		(pad->raw.prefix != 0x5a) ||
+		(pad->raw.type != PAD_ID_CONFIG_MODE)
+	) {
+		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 force analog mode on, unlock rumble (not used
+	// in this example) and enable longer responses containing button pressure
+	// readings.
+	// TODO: find out if passing 0x03 instead of 0x02 in PAD_CMD_SET_ANALOG
+	// locks the analog button, as emulated by DuckStation...
+	// https://gist.github.com/scanlime/5042071
+	send_pad_cmd(port, PAD_CMD_SET_ANALOG,      0x01, 0x02, 0);
+	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 (
+		rx_len &&
+		(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);
+
+			// The pad only identifies as CONFIG_MODE after at least another
+			// command is sent.
+			send_pad_cmd(port, PAD_CMD_CONFIG_MODE, 0x01, 0x00, 0);
+			send_pad_cmd(port, PAD_CMD_CONFIG_MODE, 0x01, 0x00, &dualshock_init_cb);
+		}
+
+	} else {
+		//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++) {
+			// TODO.
+			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;
+			}
+
+			PADTYPE    *pad = (PADTYPE *) pad_buff[port];
+			PAD_TYPEID type = pad->raw.type;
+
+			// 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. Thus making sure the prefix is 0x5a
+			// isn't enough to reliably detect pads.
+			/*if ((pad->raw.prefix != 0x5a) && (type != PAD_ID_ANALOG)) {
+				FntPrint(-1, "\n\nPORT %d: INVALID RESPONSE\n", port + 1);
+				if ((counter % 64) < 32)
+					FntPrint(-1, " CHECK CONNECTION...");
+
+				continue;
+			}*/
+
+			FntPrint(
+				-1,
+				"\n\nPORT %d: %s (TYPE=%d)\n",
+				port + 1,
+				PAD_TYPEIDS[type],
+				type
+			);
+
+			// Print a hexdump of the payload returned by the pad.
+			for (uint32_t i = 0; i < pad_buff_len[port]; i++)
+				FntPrint(
+					-1,
+					((i - 2) % 8) ? " %02x" : "\n %02x",
+					pad_buff[port][i]
+				);
+		}
+
+		FntFlush(-1);
+		display(&ctx);
+	}
+
+	return 0;
+}
diff --git a/examples/io/pads/spi.c b/examples/io/pads/spi.c
new file mode 100644
index 0000000..e01b3f6
--- /dev/null
+++ b/examples/io/pads/spi.c
@@ -0,0 +1,218 @@
+/*
+ * PSn00bSDK controller polling example (SPI driver)
+ * (C) 2021 spicyjpeg - MPL licensed
+ *
+ * This is a fairly complete timer driven, asynchronous high-speed SPI driver,
+ * with support for sending custom commands (including memory card access), in
+ * about 200 lines of code. Feel free to copypaste and adapt it.
+ *
+ * The way this works is by maintaining a queue of requests to send, each with
+ * its own payload and callback. Timer 2 is configured to trigger an IRQ at
+ * regular intervals. On each tick, the next request in the queue (or a poll
+ * command if no request is pending) is prepared and the first byte is
+ * sent; if the controller asks for more data by pulling /ACK low, the next
+ * byte is sent and the received byte is placed into a buffer. This goes on
+ * until the last byte is exchanged and the controller stops asserting /ACK.
+ *
+ * On the next tick, the response buffer is passed to the request's callback
+ * and reset, and the next request in the queue is sent. This blindly assumes
+ * it only takes one tick for a request/response to be sent, which is the case
+ * for controllers' very small packets but not for memory cards. It is
+ * advisable to call spi_set_poll_rate() to temporarily reduce poll rate while
+ * accessing memory cards.
+ *
+ * Note that this driver completely takes over the SPI bus, so you won't be
+ * able to use any BIOS functions that rely on SPI access (i.e. pad and memory
+ * card APIs) alongside it.
+ */
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include <psxetc.h>
+#include <psxapi.h>
+#include <psxpad.h>
+
+#include "spi.h"
+
+/* Register definitions */
+
+#define F_CPU 33868800UL
+
+#define TIM_VALUE(N)	*((volatile uint32_t *) 0x1f801100 + 4 * (N))
+#define TIM_CTRL(N)		*((volatile uint32_t *) 0x1f801104 + 4 * (N))
+#define TIM_RELOAD(N)	*((volatile uint32_t *) 0x1f801108 + 4 * (N))
+
+// IMPORTANT: even though JOY_TXRX is a 32-bit register, it should only be
+// accessed as 8-bit. Reading it as 16 or 32-bit works fine on real hardware,
+// but leads to problems in some emulators.
+#define JOY_TXRX		*((volatile uint8_t *)  0x1f801040)
+#define JOY_STAT		*((volatile uint16_t *) 0x1f801044)
+#define JOY_MODE		*((volatile uint16_t *) 0x1f801048)
+#define JOY_CTRL		*((volatile uint16_t *) 0x1f80104a)
+#define JOY_BAUD		*((volatile uint16_t *) 0x1f80104e)
+
+/* Internal structures and globals */
+
+typedef struct _SPICONTEXT {
+	uint8_t     tx_buff[SPI_BUFF_LEN];
+	uint8_t     rx_buff[SPI_BUFF_LEN];
+	uint32_t    tx_len, rx_len, port;
+	SPICALLBACK callback;
+} SPICONTEXT;
+
+static volatile SPICONTEXT          ctx;
+static volatile SPIREQUEST volatile *current_req;
+static SPICALLBACK                  default_cb;
+
+/* Request queue management */
+
+static void prepare_poll_req(void) {
+	PADREQUEST *req = (PADREQUEST *) ctx.tx_buff;
+
+	req->addr     = 0x01;
+	req->cmd      = PAD_CMD_READ;
+	req->tap_mode = 0x00; // 0x01 to enable extended multitap response
+	req->motor_l  = 0x00;
+	req->motor_r  = 0x00;
+
+	ctx.tx_len   = 4;
+	ctx.rx_len   = 0;
+	ctx.port    ^= 1;
+	ctx.callback = default_cb;
+}
+
+static void prepare_next_req(void) {
+	// Copy the contents of the first request in the queue into the TX buffer.
+	memcpy((void *) ctx.tx_buff, (void *) current_req->data, current_req->len);
+
+	ctx.tx_len   = current_req->len;
+	ctx.rx_len   = 0;
+	ctx.port     = current_req->port;
+	ctx.callback = current_req->callback;
+
+	// Pop the first request from the queue by deallocating it and adjusting
+	// the pointer to the first queue item.
+	SPIREQUEST *next = current_req->next;
+
+	free((void *) current_req);
+	current_req = next;
+}
+
+/* Interrupt handlers */
+
+static void poll_timer_tick(void) {
+	// Fetch the last response byte, which wasn't followed by a pulse on /ACK,
+	// from the RX FIFO.
+	if (JOY_STAT & 0x0002)
+		ctx.rx_buff[ctx.rx_len - 1] = (uint8_t) JOY_TXRX;
+
+	if (ctx.callback)
+		ctx.callback(ctx.port, ctx.rx_buff, ctx.rx_len);
+
+	// If the request queue is empty, create a pad polling request.
+	if (current_req)
+		prepare_next_req();
+	else
+		prepare_poll_req();
+
+	// Prepare the SPI port by clearing any pending IRQ, pulling /CS high and
+	// enabling the /ACK IRQ. In order to communicate with controllers, /CS has
+	// to be driven low again for about 20 us before sending the first byte.
+	JOY_CTRL = 0x0010;
+	for (uint32_t i = 0; i < 50; i++)
+		__asm__("nop");
+
+	JOY_CTRL = 0x1003 | (ctx.port << 13);
+	for (uint32_t i = 0; i < 500; i++)
+		__asm__("nop");
+
+	// Send the first byte indicating which device to address. If the matching
+	// device is connected, it will reply by triggering the /ACK IRQ.
+	JOY_TXRX = ctx.tx_buff[0];
+}
+
+static void spi_ack_handler(void) {
+	// Wait until /ACK is pulled up by the controller before sending the next
+	// byte. According to nocash docs, this has to be done before resetting the
+	// IRQ.
+	while (JOY_STAT & 0x0080)
+		__asm__("nop");
+
+	// Keep /CS pulled low and acknowledge the IRQ (bit 4) to ensure it can be
+	// triggered again.
+	JOY_CTRL = 0x1013 | (ctx.port << 13);
+
+	if (!ctx.rx_len) {
+		// We just sent the first address byte. Obviously the response we
+		// received was read from an open bus, so the SPI port's internal FIFO
+		// must be flushed (by performing dummy reads) to ensure we are only
+		// going to read valid data from now on.
+		JOY_TXRX;
+
+	} else if (ctx.rx_len <= SPI_BUFF_LEN) {
+		// If this is not the first byte, put it in the RX buffer.
+		ctx.rx_buff[ctx.rx_len - 1] = (uint8_t) JOY_TXRX;
+	}
+
+	// Send the next byte, or a null byte if there is no more data to send and
+	// we're just reading a response.
+	ctx.rx_len++;
+	if (ctx.rx_len < ctx.tx_len)
+		JOY_TXRX = (uint32_t) ctx.tx_buff[ctx.rx_len];
+	else
+		JOY_TXRX = 0x00;
+}
+
+/* Public API */
+
+SPIREQUEST *spi_new_request(void) {
+	SPIREQUEST *req = malloc(sizeof(SPIREQUEST));
+
+	req->len      = 0;
+	req->port     = 0;
+	req->callback = 0;
+	req->next     = 0;
+
+	// Find the last queued request by traversing the linked list and append a
+	// pointer to the new request.
+	if (!current_req) {
+		current_req = req;
+	} else {
+		volatile SPIREQUEST *volatile last = current_req;
+		while (last->next)
+			last = last->next;
+
+		last->next = req;
+	}
+
+	return req;
+}
+
+void spi_set_poll_rate(uint32_t value) {
+	TIM_CTRL(2) = 0x0258; // CLK/8 input, IRQ on reload, disable one-shot IRQ
+
+	if (value < 65)
+		TIM_RELOAD(2) = 0xffff;
+	else
+		TIM_RELOAD(2) = (F_CPU / 8) / value;
+}
+
+void spi_init(SPICALLBACK callback) {
+	// Disable the BIOS timer handler (which for some stupid reason is enabled
+	// by default, even though it does nothing) and set up custom interrupt
+	// handlers.
+	EnterCriticalSection();
+	ChangeClearRCnt(2, 0);
+	InterruptCallback(6, &poll_timer_tick);
+	InterruptCallback(7, &spi_ack_handler);
+	ExitCriticalSection();
+
+	JOY_CTRL = 0x0040; // Reset all registers
+	JOY_MODE = 0x000d; // 1x multiplier, 8 data bits, no parity
+	JOY_BAUD = 0x0088; // 250000 bps
+
+	spi_set_poll_rate(250);
+	current_req = 0;
+	default_cb  = callback;
+}
diff --git a/examples/io/pads/spi.h b/examples/io/pads/spi.h
new file mode 100644
index 0000000..1c473cd
--- /dev/null
+++ b/examples/io/pads/spi.h
@@ -0,0 +1,61 @@
+/*
+ * PSn00bSDK controller polling example (SPI driver)
+ * (C) 2021 spicyjpeg - MPL licensed
+ */
+
+#ifndef __SPI_H
+#define __SPI_H
+
+#include <stdint.h>
+#include <psxpad.h>
+
+//#define SPI_BUFF_LEN 34
+#define SPI_BUFF_LEN 140
+
+/* Request structures */
+
+typedef void (*SPICALLBACK)(uint32_t port, const volatile uint8_t *buff, size_t rx_len);
+
+typedef struct _SPIREQUEST {
+	union {
+		uint8_t        data[SPI_BUFF_LEN];
+		PADREQUEST     pad_req;
+		MCDREQUEST     mcd_req;
+	};
+	uint32_t           len, port;
+	SPICALLBACK        callback;
+	struct _SPIREQUEST *next;
+} SPIREQUEST;
+
+/* Public API */
+
+/**
+ * @brief Allocates a new request object and adds it to the request queue. The
+ * object must be populated afterwards by setting the length, callback and
+ * filling in the TX data buffer.
+ */
+SPIREQUEST *spi_new_request(void);
+
+/**
+ * @brief Changes the controller polling rate. The lowest supported rate is 65
+ * Hz (requests sent every 1/65th of a second, each port polled at 32.5 Hz when
+ * no request is pending).
+ *
+ * @param value
+ */
+void spi_set_poll_rate(uint32_t value);
+
+/**
+ * @brief Installs the SPI and timer 2 interrupt handlers and starts the poll
+ * timer. By default the polling rate is set to 250 Hz (125 Hz per port),
+ * however it can be changed at any time by calling spi_set_poll_rate().
+ *
+ * The provided callback (if any) is called to report the result of poll
+ * requests, which are issued automatically when no other request is in the
+ * queue. Passing NULL as callback does not disable auto-polling.
+ *
+ * @param callback
+ */
+void spi_init(SPICALLBACK callback);
+
+#endif