/*      $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);
}