xref: /src/sys/dev/i2o/dpti.c

/*	$NetBSD: dpti.c,v 1.51 2023/09/07 20:07:03 ad Exp $	*/

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

/*
 * Copyright (c) 1996-2000 Distributed Processing Technology Corporation
 * Copyright (c) 2000 Adaptec Corporation
 * All rights reserved.
 *
 * TERMS AND CONDITIONS OF USE
 *
 * Redistribution and use in source form, with or without modification, are
 * permitted provided that redistributions of source code must retain the
 * above copyright notice, this list of conditions and the following disclaimer.
 *
 * This software is provided `as is' by Adaptec 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 Adaptec 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 interruptions) 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 driver software, even
 * if advised of the possibility of such damage.
 */

/*
 * Adaptec/DPT I2O control interface.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: dpti.c,v 1.51 2023/09/07 20:07:03 ad Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/device.h>
#include <sys/queue.h>
#include <sys/proc.h>
#include <sys/endian.h>
#include <sys/kmem.h>
#include <sys/conf.h>
#include <sys/ioctl.h>
#include <sys/kauth.h>

#include <sys/bus.h>
#ifdef __i386__
#include <machine/pio.h>
#include <machine/cputypes.h>
#endif

#include <dev/i2o/i2o.h>
#include <dev/i2o/i2odpt.h>
#include <dev/i2o/iopio.h>
#include <dev/i2o/iopvar.h>
#include <dev/i2o/dptivar.h>

#include "ioconf.h"

#ifdef I2ODEBUG
#define	DPRINTF(x)		printf x
#else
#define	DPRINTF(x)
#endif

static struct dpt_sig dpti_sig = {
	.dsSignature = { 'd', 'P', 't', 'S', 'i', 'G'},
	.dsSigVersion = SIG_VERSION,
#if defined(__i386__)
	.dsProcessorFamily = PROC_INTEL,
#elif defined(__powerpc__)
	.dsProcessorFamily = PROC_POWERPC,
#elif defined(__alpha__)
	.dsProcessorFamily = PROC_ALPHA,
#elif defined(__mips__)
	.dsProcessorFamily = PROC_MIPS,
#elif defined(__sparc64__)
	.dsProcessorFamily = PROC_ULTRASPARC,
#endif
#if defined(__i386__)
	.dsProcessor = PROC_386 | PROC_486 | PROC_PENTIUM | PROC_SEXIUM,
#else
	.dsProcessor = 0,
#endif
	.dsFiletype = FT_HBADRVR,
	.dsFiletypeFlags = 0,
	.dsOEM = OEM_DPT,
	.dsOS = (uint32_t)OS_FREE_BSD,	/* XXX */
	.dsCapabilities = CAP_ABOVE16MB,
	.dsDeviceSupp = DEV_ALL,
	.dsAdapterSupp = ADF_ALL_SC5,
	.dsApplication =  0,
	.dsRequirements = 0,
	.dsVersion = DPTI_VERSION,
	.dsRevision = DPTI_REVISION,
	.dsSubRevision = DPTI_SUBREVISION,
	.dsMonth = DPTI_MONTH,
	.dsDay = DPTI_DAY,
	.dsYear = DPTI_YEAR,
	.dsDescription = { '\0' },		/* Will be filled later */
};

void	dpti_attach(device_t, device_t, void *);
int	dpti_blinkled(struct dpti_softc *);
int	dpti_ctlrinfo(struct dpti_softc *, int, void *);
int	dpti_match(device_t, cfdata_t, void *);
int	dpti_passthrough(struct dpti_softc *, void *, struct proc *);
int	dpti_sysinfo(struct dpti_softc *, int, void *);

dev_type_open(dptiopen);
dev_type_ioctl(dptiioctl);

const struct cdevsw dpti_cdevsw = {
	.d_open = dptiopen,
	.d_close = nullclose,
	.d_read = noread,
	.d_write = nowrite,
	.d_ioctl = dptiioctl,
	.d_stop = nostop,
	.d_tty = notty,
	.d_poll = nopoll,
	.d_mmap = nommap,
	.d_kqfilter = nokqfilter,
	.d_discard = nodiscard,
	.d_flag = D_OTHER | D_MPSAFE,
};

CFATTACH_DECL_NEW(dpti, sizeof(struct dpti_softc),
    dpti_match, dpti_attach, NULL, NULL);

int
dpti_match(device_t parent, cfdata_t match, void *aux)
{
	struct iop_attach_args *ia;
	struct iop_softc *iop;

	ia = aux;
	iop = device_private(parent);

	if (ia->ia_class != I2O_CLASS_ANY || ia->ia_tid != I2O_TID_IOP)
		return (0);

	if (le16toh(iop->sc_status.orgid) != I2O_ORG_DPT)
		return (0);

	return (1);
}

void
dpti_attach(device_t parent, device_t self, void *aux)
{
	struct iop_softc *iop;
	struct dpti_softc *sc;
	struct {
		struct	i2o_param_op_results pr;
		struct	i2o_param_read_results prr;
		struct	i2o_dpt_param_exec_iop_buffers dib;
	} __packed param;
	int rv;

	sc = device_private(self);
	sc->sc_dev = self;
	iop = device_private(parent);

	/*
	 * Tell the world what we are.  The description in the signature
	 * must be no more than 46 bytes long (see dptivar.h).
	 */
	printf(": DPT/Adaptec RAID management interface\n");
	snprintf(dpti_sig.dsDescription, sizeof(dpti_sig.dsDescription),
	    "NetBSD %s I2O OSM", osrelease);

	rv = iop_field_get_all(iop, I2O_TID_IOP,
	    I2O_DPT_PARAM_EXEC_IOP_BUFFERS, &param,
	    sizeof(param), NULL);
	if (rv != 0)
		return;

	sc->sc_blinkled = le32toh(param.dib.serialoutputoff) + 8;
}

int
dptiopen(dev_t dev, int flag, int mode,
    struct lwp *l)
{

	if (device_lookup(&dpti_cd, minor(dev)) == NULL)
		return (ENXIO);

	return (0);
}

int
dptiioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
{
	struct iop_softc *iop;
	struct dpti_softc *sc;
	struct ioctl_pt *pt;
	int i, size, rv, linux;

	sc = device_lookup_private(&dpti_cd, minor(dev));
	iop = device_private(device_parent(sc->sc_dev));
	rv = 0;

	if (cmd == PTIOCLINUX) {
		pt = (struct ioctl_pt *)data;
		size = IOCPARM_LEN(pt->com);
		cmd = pt->com & 0xffff;
		data = pt->data;
		linux = 1;
	} else {
		size = IOCPARM_LEN(cmd);
		cmd = cmd & 0xffff;
		linux = 0;
	}

	mutex_enter(&iop->sc_conflock);
	switch (cmd) {
	case DPT_SIGNATURE:
		if (size > sizeof(dpti_sig))
			size = sizeof(dpti_sig);
		memcpy(data, &dpti_sig, size);
		break;

	case DPT_CTRLINFO:
		rv = dpti_ctlrinfo(sc, size, data);
		break;

	case DPT_SYSINFO:
		rv = dpti_sysinfo(sc, size, data);
		break;

	case DPT_BLINKLED:
		if ((i = dpti_blinkled(sc)) == -1)
			i = 0;

		if (size == 0) {
			rv = copyout(&i, *(void **)data, sizeof(i));
			break;
		}

		*(int *)data = i;
		break;

	case DPT_TARGET_BUSY:
		/*
		 * XXX This is here to stop linux_machdepioctl() from
		 * whining about an unknown ioctl.
		 */
		rv = EIO;
		break;

	case DPT_I2OUSRCMD:
		rv = kauth_authorize_device_passthru(l->l_cred, dev,
		    KAUTH_REQ_DEVICE_RAWIO_PASSTHRU_ALL, data);
		if (rv)
			break;

		if (linux) {
			rv = dpti_passthrough(sc, data, l->l_proc);
		} else {
			rv = dpti_passthrough(sc, *(void **)data, l->l_proc);
		}
		break;

	case DPT_I2ORESETCMD:
		printf("%s: I2ORESETCMD not implemented\n",
		    device_xname(sc->sc_dev));
		rv = EOPNOTSUPP;
		break;

	case DPT_I2ORESCANCMD:
		rv = iop_reconfigure(iop, 0);
		break;

	default:
		rv = ENOTTY;
		break;
	}
	mutex_exit(&iop->sc_conflock);

	return (rv);
}

int
dpti_blinkled(struct dpti_softc *sc)
{
	struct iop_softc *iop;
	u_int v;

	iop = device_private(device_parent(sc->sc_dev));

	v = bus_space_read_1(iop->sc_iot, iop->sc_ioh, sc->sc_blinkled + 0);
	if (v == 0xbc) {
		v = bus_space_read_1(iop->sc_iot, iop->sc_ioh,
		    sc->sc_blinkled + 1);
		return (v);
	}

	return (-1);
}

int
dpti_ctlrinfo(struct dpti_softc *sc, int size, void *data)
{
	struct dpt_ctlrinfo info;
	struct iop_softc *iop;
	int rv, i;

	iop = device_private(device_parent(sc->sc_dev));

	memset(&info, 0, sizeof(info));

	info.length = sizeof(info) - sizeof(u_int16_t);
	info.drvrHBAnum = device_unit(sc->sc_dev);
	info.baseAddr = iop->sc_memaddr;
	if ((i = dpti_blinkled(sc)) == -1)
		i = 0;
	info.blinkState = i;
	info.pciBusNum = iop->sc_pcibus;
	info.pciDeviceNum = iop->sc_pcidev;
	info.hbaFlags = FLG_OSD_PCI_VALID | FLG_OSD_DMA | FLG_OSD_I2O;
	info.Interrupt = 10;			/* XXX */

	if (size > sizeof(char)) {
		memcpy(data, &info, uimin(sizeof(info), size));
		rv = 0;
	} else
		rv = copyout(&info, *(void **)data, sizeof(info));

	return (rv);
}

int
dpti_sysinfo(struct dpti_softc *sc, int size, void *data)
{
	struct dpt_sysinfo info;
	int rv;
#ifdef __i386__
	int i, j;
#endif

	memset(&info, 0, sizeof(info));

#ifdef __i386__
	outb (0x70, 0x12);
	i = inb(0x71);
	j = i >> 4;
	if (i == 0x0f) {
		outb (0x70, 0x19);
		j = inb (0x71);
	}
	info.drive0CMOS = j;

	j = i & 0x0f;
	if (i == 0x0f) {
		outb (0x70, 0x1a);
		j = inb (0x71);
	}
	info.drive1CMOS = j;
	info.processorFamily = dpti_sig.dsProcessorFamily;

	/*
	 * Get the conventional memory size from CMOS.
	 */
	outb(0x70, 0x16);
	j = inb(0x71);
	j <<= 8;
	outb(0x70, 0x15);
	j |= inb(0x71);
	info.conventionalMemSize = j;

	/*
	 * Get the extended memory size from CMOS.
	 */
	outb(0x70, 0x31);
	j = inb(0x71);
	j <<= 8;
	outb(0x70, 0x30);
	j |= inb(0x71);
	info.extendedMemSize = j;

	switch (cpu_class) {
	case CPUCLASS_386:
		info.processorType = PROC_386;
		break;
	case CPUCLASS_486:
		info.processorType = PROC_486;
		break;
	case CPUCLASS_586:
		info.processorType = PROC_PENTIUM;
		break;
	case CPUCLASS_686:
	default:
		info.processorType = PROC_SEXIUM;
		break;
	}

	info.flags = SI_CMOS_Valid | SI_BusTypeValid |
	    SI_MemorySizeValid | SI_NO_SmartROM;
#else
	info.flags = SI_BusTypeValid | SI_NO_SmartROM;
#endif

	info.busType = SI_PCI_BUS;

	/*
	 * Copy out the info structure to the user.
	 */
	if (size > sizeof(char)) {
		memcpy(data, &info, uimin(sizeof(info), size));
		rv = 0;
	} else
		rv = copyout(&info, *(void **)data, sizeof(info));

	return (rv);
}

int
dpti_passthrough(struct dpti_softc *sc, void *data, struct proc *proc)
{
	struct iop_softc *iop;
	struct i2o_msg mh, *mf;
	struct i2o_reply rh;
	struct iop_msg *im;
	struct dpti_ptbuf bufs[IOP_MAX_MSG_XFERS];
	u_int32_t mbtmp[IOP_MAX_MSG_SIZE / sizeof(u_int32_t)];
	u_int32_t rbtmp[IOP_MAX_MSG_SIZE / sizeof(u_int32_t)];
	int rv, msgsize, repsize, sgoff, i, mapped, nbuf, nfrag, j, sz;
	u_int32_t *p, *pmax;

	iop = device_private(device_parent(sc->sc_dev));
	im = NULL;

	if ((rv = dpti_blinkled(sc)) != -1) {
		if (rv != 0) {
			aprint_error_dev(sc->sc_dev, "adapter blinkled = 0x%02x\n", rv);
			return (EIO);
		}
	}

	/*
	 * Copy in the message frame header and determine the size of the
	 * full message frame.
	 */
	if ((rv = copyin(data, &mh, sizeof(mh))) != 0) {
		DPRINTF(("%s: message copyin failed\n",
		    device_xname(sc->sc_dev)));
		return (rv);
	}

	msgsize = (mh.msgflags >> 14) & ~3;
	if (msgsize < sizeof(mh) || msgsize >= IOP_MAX_MSG_SIZE) {
		DPRINTF(("%s: bad message frame size\n",
		    device_xname(sc->sc_dev)));
		return (EINVAL);
	}

	/*
	 * Handle special commands.
	 */
	switch (mh.msgfunc >> 24) {
	case I2O_EXEC_IOP_RESET:
		printf("%s: I2O_EXEC_IOP_RESET not implemented\n",
		    device_xname(sc->sc_dev));
		return (EOPNOTSUPP);

	case I2O_EXEC_OUTBOUND_INIT:
		printf("%s: I2O_EXEC_OUTBOUND_INIT not implemented\n",
		    device_xname(sc->sc_dev));
		return (EOPNOTSUPP);

	case I2O_EXEC_SYS_TAB_SET:
		printf("%s: I2O_EXEC_SYS_TAB_SET not implemented\n",
		    device_xname(sc->sc_dev));
		return (EOPNOTSUPP);

	case I2O_EXEC_STATUS_GET:
		if ((rv = iop_status_get(iop, 0)) == 0)
			rv = copyout(&iop->sc_status, (char *)data + msgsize,
			    sizeof(iop->sc_status));
		return (rv);
	}

	/*
	 * Copy in the full message frame.
	 */
	if ((rv = copyin(data, mbtmp, msgsize)) != 0) {
		DPRINTF(("%s: full message copyin failed\n",
		    device_xname(sc->sc_dev)));
		return (rv);
	}

	/*
	 * Determine the size of the reply frame, and copy it in.
	 */
	if ((rv = copyin((char *)data + msgsize, &rh, sizeof(rh))) != 0) {
		DPRINTF(("%s: reply copyin failed\n",
		    device_xname(sc->sc_dev)));
		return (rv);
	}

	repsize = (rh.msgflags >> 14) & ~3;
	if (repsize < sizeof(rh) || repsize >= IOP_MAX_MSG_SIZE) {
		DPRINTF(("%s: bad reply header size\n",
		    device_xname(sc->sc_dev)));
		return (EINVAL);
	}

	if ((rv = copyin((char *)data + msgsize, rbtmp, repsize)) != 0) {
		DPRINTF(("%s: reply too large\n", device_xname(sc->sc_dev)));
		return (rv);
	}

	/*
	 * If the message has a scatter gather list, it must be comprised of
	 * simple elements.  If any one transfer contains multiple segments,
	 * we allocate a temporary buffer for it; otherwise, the buffer will
	 * be mapped directly.
	 */
	mapped = 0;
	if ((sgoff = ((mh.msgflags >> 4) & 15)) != 0) {
		if ((sgoff + 2) > (msgsize >> 2)) {
			DPRINTF(("%s: invalid message size fields\n",
			    device_xname(sc->sc_dev)));
			return (EINVAL);
		}

		memset(bufs, 0, sizeof(bufs));

		p = mbtmp + sgoff;
		pmax = mbtmp + (msgsize >> 2) - 2;

		for (nbuf = 0; nbuf < IOP_MAX_MSG_XFERS; nbuf++, p += 2) {
			if (p > pmax) {
				DPRINTF(("%s: invalid SGL (1)\n",
				    device_xname(sc->sc_dev)));
				goto bad;
			}

			if ((p[0] & 0x30000000) != I2O_SGL_SIMPLE) {
				DPRINTF(("%s: invalid SGL (2)\n",
				    device_xname(sc->sc_dev)));
				goto bad;
			}

			bufs[nbuf].db_out = (p[0] & I2O_SGL_DATA_OUT) != 0;
			bufs[nbuf].db_ptr = NULL;

			if ((p[0] & I2O_SGL_END_BUFFER) != 0) {
				if ((p[0] & 0x00ffffff) > IOP_MAX_XFER) {
					DPRINTF(("%s: buffer too large\n",
					    device_xname(sc->sc_dev)));
					goto bad;
				}

				// XXX: 32 bits
				bufs[nbuf].db_ptr = (void *)(intptr_t)p[1];
				bufs[nbuf].db_proc = proc;
				bufs[nbuf].db_size = p[0] & 0x00ffffff;

				if ((p[0] & I2O_SGL_END) != 0)
					break;

				continue;
			}

			/*
			 * The buffer has multiple segments.  Determine the
			 * total size.
			 */
			nfrag = 0;
			sz = 0;
			for (; p <= pmax; p += 2) {
				if (nfrag == DPTI_MAX_SEGS) {
					DPRINTF(("%s: too many segments\n",
					    device_xname(sc->sc_dev)));
					goto bad;
				}

				bufs[nbuf].db_frags[nfrag].iov_len =
				    p[0] & 0x00ffffff;
				// XXX: 32 bits
				bufs[nbuf].db_frags[nfrag].iov_base =
				    (void *)(intptr_t)p[1];

				sz += p[0] & 0x00ffffff;
				nfrag++;

				if ((p[0] & I2O_SGL_END) != 0) {
					if ((p[0] & I2O_SGL_END_BUFFER) == 0) {
						DPRINTF((
						    "%s: invalid SGL (3)\n",
						    device_xname(sc->sc_dev)));
						goto bad;
					}
					break;
				}
				if ((p[0] & I2O_SGL_END_BUFFER) != 0)
					break;
			}
			bufs[nbuf].db_nfrag = nfrag;

			if (p > pmax) {
				DPRINTF(("%s: invalid SGL (4)\n",
				    device_xname(sc->sc_dev)));
				goto bad;
			}

			if (sz > IOP_MAX_XFER) {
				DPRINTF(("%s: buffer too large\n",
				    device_xname(sc->sc_dev)));
				goto bad;
			}

			bufs[nbuf].db_size = sz;
			bufs[nbuf].db_ptr = kmem_zalloc(sz, KM_SLEEP);

			for (i = 0, sz = 0; i < bufs[nbuf].db_nfrag; i++) {
				rv = copyin(bufs[nbuf].db_frags[i].iov_base,
				    (char *)bufs[nbuf].db_ptr + sz,
				    bufs[nbuf].db_frags[i].iov_len);
				if (rv != 0) {
					DPRINTF(("%s: frag copyin\n",
					    device_xname(sc->sc_dev)));
					goto bad;
				}
				sz += bufs[nbuf].db_frags[i].iov_len;
			}

			if ((p[0] & I2O_SGL_END) != 0)
				break;
		}

		if (nbuf == IOP_MAX_MSG_XFERS) {
			DPRINTF(("%s: too many transfers\n",
			    device_xname(sc->sc_dev)));
			goto bad;
		}
	} else
		nbuf = -1;

	/*
	 * Allocate a wrapper, and adjust the message header fields to
	 * indicate that no scatter-gather list is currently present.
	 */

	im = iop_msg_alloc(iop, IM_WAIT | IM_NOSTATUS);
	im->im_rb = (struct i2o_reply *)rbtmp;
	mf = (struct i2o_msg *)mbtmp;
	mf->msgictx = IOP_ICTX;
	mf->msgtctx = im->im_tctx;

	if (sgoff != 0)
		mf->msgflags = (mf->msgflags & 0xff0f) | (sgoff << 16);

	/*
	 * Map the data transfer(s).
	 */
	for (i = 0; i <= nbuf; i++) {
		rv = iop_msg_map(iop, im, mbtmp, bufs[i].db_ptr,
		    bufs[i].db_size, bufs[i].db_out, bufs[i].db_proc);
		if (rv != 0) {
			DPRINTF(("%s: msg_map failed, rv = %d\n",
			    device_xname(sc->sc_dev), rv));
			goto bad;
		}
		mapped = 1;
	}

	/*
	 * Start the command and sleep until it completes.
	 */
	if ((rv = iop_msg_post(iop, im, mbtmp, 5*60*1000)) != 0)
		goto bad;

	/*
	 * Copy out the reply frame.
	 */
	if ((rv = copyout(rbtmp, (char *)data + msgsize, repsize)) != 0) {
		DPRINTF(("%s: reply copyout() failed\n",
		    device_xname(sc->sc_dev)));
	}

 bad:
	/*
	 * Free resources and return to the caller.
	 */
	if (im != NULL) {
		if (mapped)
			iop_msg_unmap(iop, im);
		iop_msg_free(iop, im);
	}

	for (i = 0; i <= nbuf; i++) {
		if (bufs[i].db_proc != NULL)
			continue;

		if (!bufs[i].db_out && rv == 0) {
			for (j = 0, sz = 0; j < bufs[i].db_nfrag; j++) {
				rv = copyout((char *)bufs[i].db_ptr + sz,
				    bufs[i].db_frags[j].iov_base,
				    bufs[i].db_frags[j].iov_len);
				if (rv != 0)
					break;
				sz += bufs[i].db_frags[j].iov_len;
			}
		}

		if (bufs[i].db_ptr != NULL)
			kmem_free(bufs[i].db_ptr, bufs[i].db_size);
	}

	return (rv);
}