xref: /src/sys/arch/playstation2/dev/sbus.c

/*	$NetBSD: sbus.c,v 1.20 2022/02/11 17:30:48 riastradh Exp $	*/

/*-
 * Copyright (c) 2001 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by UCHIYAMA Yasushi.
 *
 * 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.
 */

/*
 * PlayStation 2 internal PCMCIA/USB interface unit.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: sbus.c,v 1.20 2022/02/11 17:30:48 riastradh Exp $");

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

#include <machine/bootinfo.h>
#include <machine/autoconf.h>

#include <playstation2/playstation2/interrupt.h>

#include <playstation2/ee/eevar.h>
#include <playstation2/ee/intcvar.h>
#include <playstation2/dev/sbusvar.h>
#include <playstation2/dev/sbusreg.h>

#ifdef DEBUG
#define STATIC
#else
#define STATIC static
#endif

STATIC void sbus_type2_pcmcia_intr_clear(void);
STATIC void sbus_type2_pcmcia_intr_enable(void);
STATIC void sbus_type2_pcmcia_intr_disable(void);
STATIC void sbus_type2_pcmcia_intr_reinstall(void);
STATIC void sbus_type3_pcmcia_intr_clear(void);
STATIC void sbus_type3_pcmcia_intr_enable(void);
STATIC void sbus_type3_pcmcia_intr_disable(void);
STATIC void sbus_type3_pcmcia_intr_reinstall(void);
STATIC int sbus_spurious_intr(void *);

STATIC void (*sbus_pcmcia_intr_clear)(void);
STATIC void (*sbus_pcmcia_intr_enable)(void);
STATIC void (*sbus_pcmcia_intr_disable)(void);
STATIC void (*sbus_pcmcia_intr_reinstall)(void);

STATIC int (*sbus_pcmcia_intr)(void *) = sbus_spurious_intr;
STATIC void *sbus_pcmcia_context;
STATIC int (*sbus_usb_intr)(void *) = sbus_spurious_intr;
STATIC void *sbus_usb_context;

STATIC void sbus_init(int);
STATIC int sbus_intr(void *);

STATIC int sbus_match(device_t, cfdata_t, void *);
STATIC void sbus_attach(device_t, device_t, void *);
STATIC int sbus_search(device_t, cfdata_t,
		       const int *, void *);
STATIC int sbus_print(void *, const char *);

CFATTACH_DECL_NEW(sbus, 0,
    sbus_match, sbus_attach, NULL, NULL);

extern struct cfdriver sbus_cd;
STATIC int __sbus_attached;

int
sbus_match(device_t parent, cfdata_t cf, void *aux)
{
	struct mainbus_attach_args *ma = aux;

	if (strcmp(ma->ma_name, sbus_cd.cd_name) != 0)
		return (0);

	return (!__sbus_attached);
}

void
sbus_attach(device_t parent, device_t self, void *aux)
{
	int type = BOOTINFO_REF(BOOTINFO_PCMCIA_TYPE);

	printf(": controller type %d\n", type);

	/* Initialize SBUS controller */
	sbus_init(type);

	config_search(self, NULL,
	    CFARGS(.search = sbus_search));
}

int
sbus_search(device_t parent, cfdata_t cf,
	    const int *ldesc, void *aux)
{
	struct sbus_attach_args sa;

	if (config_probe(parent, cf, &sa))
		config_attach(parent, cf, &sa, sbus_print, CFARGS_NONE);

	return (0);
}

int
sbus_print(void *aux, const char *pnp)
{

	return (pnp ? QUIET : UNCONF);
}

void
sbus_init(int type)
{
	/* install model dependent hook */
#define SET_PCMCIA_INTR_OPS(x)	 					\
	sbus_pcmcia_intr_clear = sbus_type##x##_pcmcia_intr_clear;	\
	sbus_pcmcia_intr_enable = sbus_type##x##_pcmcia_intr_enable;	\
	sbus_pcmcia_intr_disable = sbus_type##x##_pcmcia_intr_disable;	\
	sbus_pcmcia_intr_reinstall = sbus_type##x##_pcmcia_intr_reinstall

	switch (type) {
	default:
		panic("unknown pcmcia controller type = %d", type);
		break;
	case 0:
		/* FALLTHROUGH */
	case 1:
		/* FALLTHROUGH */
	case 2:
		SET_PCMCIA_INTR_OPS(2);
		break;
	case 3:
		SET_PCMCIA_INTR_OPS(3);
		break;
	}
#undef SET_PCMCIA_INTR_OPS
	/* disable interrupt */
	(*sbus_pcmcia_intr_disable)();

	/* clear interrupt */
	(*sbus_pcmcia_intr_clear)();
	_reg_write_4(SBUS_SMFLG_REG, SMFLG_PCMCIA_INT);
	_reg_write_4(SBUS_SMFLG_REG, SMFLG_USB_INT);

	/* connect to INTC */
	intc_intr_establish(I_CH1_SBUS, IPL_BIO, sbus_intr, 0);
}

void *
sbus_intr_establish(enum sbus_irq irq, int (*ih_func)(void *), void *ih_arg)
{
	switch (irq) {
	default:
		panic("unknown IRQ");
		break;
	case SBUS_IRQ_PCMCIA:
		sbus_pcmcia_intr = ih_func;
		sbus_pcmcia_context = ih_arg;
		(*sbus_pcmcia_intr_enable)();
		break;
	case SBUS_IRQ_USB:
		sbus_usb_intr = ih_func;
		sbus_usb_context = ih_arg;
		break;
	}

	return (void *)irq;
}

void
sbus_intr_disestablish(void *handle)
{
	int irq = (int)handle;

	switch (irq) {
	default:
		panic("unknown IRQ");
		break;
	case SBUS_IRQ_PCMCIA:
		sbus_pcmcia_intr = sbus_spurious_intr;
		(*sbus_pcmcia_intr_disable)();
		break;
	case SBUS_IRQ_USB:
		sbus_usb_intr = sbus_spurious_intr;
		break;
	}
}

int
sbus_intr(void *arg)
{
	u_int32_t stat;

	_playstation2_evcnt.sbus.ev_count++;
	stat = _reg_read_4(SBUS_SMFLG_REG);

	if (stat & SMFLG_PCMCIA_INT) {
		(*sbus_pcmcia_intr_clear)();
		_reg_write_4(SBUS_SMFLG_REG, SMFLG_PCMCIA_INT);
		(*sbus_pcmcia_intr)(sbus_pcmcia_context);
	}

	if (stat & SMFLG_USB_INT) {
		_reg_write_4(SBUS_SMFLG_REG, SMFLG_USB_INT);
		(*sbus_usb_intr)(sbus_usb_context);
	}

	(*sbus_pcmcia_intr_reinstall)();

	return (1);
}

int
sbus_spurious_intr(void *arg)
{

	printf("spurious interrupt.\n");

	return (1);
}

/* SCPH-18000 */
void
sbus_type2_pcmcia_intr_clear(void)
{

	if (_reg_read_2(SBUS_PCMCIA_CSC1_REG16) & 0x080)
		_reg_write_2(SBUS_PCMCIA_CSC1_REG16, 0xffff);
}

void
sbus_type2_pcmcia_intr_enable(void)
{

	_reg_write_2(SBUS_PCMCIA_TIMR_REG16, 0);
}

void
sbus_type2_pcmcia_intr_disable(void)
{

	_reg_write_2(SBUS_PCMCIA_TIMR_REG16, 1);
}

void
sbus_type2_pcmcia_intr_reinstall(void)
{
	u_int16_t r = _reg_read_2(SBUS_PCMCIA_TIMR_REG16);

	_reg_write_2(SBUS_PCMCIA_TIMR_REG16, 1);
	_reg_write_2(SBUS_PCMCIA_TIMR_REG16, r);
}

/* SCPH-30000/35000 */
void
sbus_type3_pcmcia_intr_clear(void)
{
	/* nothing */
}

void
sbus_type3_pcmcia_intr_enable(void)
{

	_reg_write_2(SBUS_PCMCIA3_TIMR_REG16, 0);
}

void
sbus_type3_pcmcia_intr_disable(void)
{

	_reg_write_2(SBUS_PCMCIA3_TIMR_REG16, 1);
}

void
sbus_type3_pcmcia_intr_reinstall(void)
{
	u_int16_t r = _reg_read_2(SBUS_PCMCIA3_TIMR_REG16);

	_reg_write_2(SBUS_PCMCIA3_TIMR_REG16, 1);
	_reg_write_2(SBUS_PCMCIA3_TIMR_REG16, r);
}