/*
 * Driver for IO port access
 *
 * PC-DOS compatibility requirements:
 *      Nearly all locations have defined values, see
 *      the PC AT Hardware reference manual for details.
 *
 */

#include <sys/param.h>
#include <sys/types.h>
#include <sys/sysmacros.h>
#if 0
#include <sys/dir.h>
#endif
#include <sys/signal.h>
#include <sys/systm.h>
#include <sys/user.h>
#include <sys/errno.h>
#include <sys/file.h>
#include <sys/modctl.h>
#include <sys/open.h>
#include <sys/stat.h>
#include <sys/conf.h>
#include <sys/cmn_err.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>

static void *state_head;  /* opaque handle top of state structs */

/* Prototypes */

static int
iopattach(dev_info_t *dip, ddi_attach_cmd_t cmd);

static int
iopgetinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **resultp);

static int 
iopdetach(dev_info_t *dip, ddi_detach_cmd_t cmd);

static int
iopopen(dev_t *devp, int flag, int otyp, cred_t *credp);

static int
iopclose(dev_t dev, int openflags, int otyp, cred_t *credp);

static int
iopioctl(dev_t dev, 
         int cmd, 
         intptr_t arg, 
         int mode, 
         cred_t *credp,
         int *rvalp);

/* device operations */
#define IOPREAD 1
#define IOPWRITE 2

typedef struct iop_struct {         /* per-unit structure */
    dev_info_t *dip;
    kmutex_t mutex;
} iop;

typedef struct iopbuf_struct{
    unsigned int port;
    unsigned char port_value;
} iopbuf;

static struct cb_ops iop_cb_ops = {
    iopopen,
    iopclose,
    nodev,                 /* not a block driver */
    nodev,                 /* no print */
    nodev,                 /* no dump */
    nodev,                 /* no read */
    nodev,                 /* no write */
    iopioctl,
    nodev,                 /* no devmap */
    nodev,                 /* no mmap */
    nodev,                 /* no segmap */
    nochpoll,              /* no chpoll */
    ddi_prop_op,
    0,                     /* not a STREAMS driver */
    D_NEW | D_MP,          /* (hopefully) MT and MP safe */
};

static struct dev_ops iop_ops = 
{
    DEVO_REV,              /* devo_rev */
    0,                     /* devo_refcnt */
    iopgetinfo,            /* devo_getinfo */
    nulldev,               /* devo_identify */
    nulldev,               /* devo_probe */
    iopattach,             /* devo_attach */
    iopdetach,             /* devo_detach */
    nodev,                 /* devo_reset */
    &iop_cb_ops,           /* devo_cb_ops */
    (struct bus_ops *)0,   /* devo_bus_ops */
    nodev                  /* devo_power */
};

extern struct mod_ops mod_driverops;

static struct modldrv modldrv = {
    &mod_driverops,
    "Simon's IO Port driver 0.9",
    &iop_ops
};
    
static struct modlinkage modlinkage = {
    MODREV_1, 
    {(void *)&modldrv, NULL,}
};

/* Globally exported functions */
int
_init(void)
{
    int error;
    
#ifdef DEBUG
    cmn_err(CE_CONT, "_init: start\n");
#endif
    if ((error = ddi_soft_state_init(&state_head, sizeof(iop), 1)) != 0) {
#ifdef DEBUG
        cmn_err(CE_CONT, "_init: couldn't ddi_soft_state_init\n");
#endif
        return error;
    }
    if ((error = mod_install(&modlinkage)) != 0) {
#ifdef DEBUG
        cmn_err(CE_CONT, "_init: couldn't mod_install\n");
#endif
        ddi_soft_state_fini(&state_head);
    }
#ifdef DEBUG
    cmn_err(CE_CONT, "_init: done\n");
#endif

    return error;
}

int
_info(struct modinfo *modinfop)
{
    int retval;
    
#ifdef DEBUG
    cmn_err(CE_CONT, "_info: start\n");
#endif
    retval = mod_info(&modlinkage, modinfop);
#ifdef DEBUG
    cmn_err(CE_CONT, "_info: done\n");
#endif
    return retval;
}

int
_fini(void)
{
    int status;
    
#ifdef DEBUG
    cmn_err(CE_CONT, "_fini: start\n");
#endif
    if ((status = mod_remove(&modlinkage)) != 0) {
#ifdef DEBUG
        cmn_err(CE_CONT, "_fini: couldn't mod_remove\n");
#endif
        return status;
    }
    ddi_soft_state_fini(&state_head);
#ifdef DEBUG
    cmn_err(CE_CONT, "_fini: done\n");
#endif
    return status;
}

static int
iopattach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
    int instance;
    iop *iop_p;
    
    switch(cmd) {
    case DDI_ATTACH:
        break;
    default:
        return DDI_FAILURE;
    }
    instance = ddi_get_instance(dip);
#ifdef DEBUG
    cmn_err(CE_CONT, "iopattach: start, instance = %d\n", instance);
#endif
    if (ddi_soft_state_zalloc(state_head, instance) != 0) {
#ifdef DEBUG
        cmn_err(CE_CONT, "iopattach: ddi_soft_state_zalloc failed\n");
#endif
        return DDI_FAILURE;
    }
    iop_p = (iop *)ddi_get_soft_state(state_head, instance);
    ddi_set_driver_private(dip, (caddr_t)iop_p);
    iop_p->dip = dip;
    mutex_init(&iop_p->mutex, "iop mutex", MUTEX_DRIVER, (void *)0);
    if (ddi_create_minor_node(dip, ddi_get_name(dip), S_IFCHR, instance,
                              DDI_PSEUDO, 0) == DDI_FAILURE)
    {
        mutex_destroy(&iop_p->mutex);
        ddi_soft_state_free(state_head, instance);
#ifdef DEBUG
        cmn_err(CE_CONT, "iopattach: ddi_create_minor_node failed\n");
#endif
        return DDI_FAILURE;
    }
    ddi_report_dev(dip);
#ifdef DEBUG
    cmn_err(CE_CONT, "iopattach: done\n");
#endif
    return DDI_SUCCESS;
}

static int
iopgetinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **resultp)
{
    int error;
    iop *iop_p;
        
#ifdef DEBUG
    cmn_err(CE_CONT, "iopgetinfo: start\n");
#endif
    switch(cmd) {
    case DDI_INFO_DEVT2DEVINFO:
        iop_p = (iop *)ddi_get_soft_state(state_head, 
                                          getminor((dev_t)arg));
        if (iop_p == NULL) {
            *resultp = NULL;
#ifdef DEBUG
            cmn_err(CE_CONT, "iopgetinfo: ddi_get_soft_state failed\n");
#endif
            error = DDI_FAILURE;
        } else {
            mutex_enter(&iop_p->mutex);
            *resultp = iop_p->dip;
            mutex_exit(&iop_p->mutex);
            error = DDI_SUCCESS;
        }
        break;
    case DDI_INFO_DEVT2INSTANCE:
        *resultp = (void *)getminor((dev_t)arg);
        error = DDI_SUCCESS;
        break;
    default:
        *resultp = NULL;
        return DDI_FAILURE;
    }
#ifdef DEBUG
    cmn_err(CE_CONT, "iopgetinfo: done\n");
#endif
    return error;
}

static int 
iopdetach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
    iop *iop_p;
    int instance;
    
#ifdef DEBUG
    cmn_err(CE_CONT, "iopdetach: start\n");
#endif
    switch(cmd) {
    case DDI_DETACH:
        break;
    default:
        return DDI_FAILURE;
    }
    
    instance = ddi_get_instance(dip);
    iop_p = (iop *)ddi_get_soft_state(state_head, instance);
    ddi_remove_minor_node(dip, NULL);
    mutex_destroy(&iop_p->mutex);
    ddi_soft_state_free(state_head, instance);
#ifdef DEBUG
    cmn_err(CE_CONT, "iopdetach: done\n");
#endif
    return DDI_SUCCESS;
}

static int
iopopen(dev_t *devp, int flag, int otyp, cred_t *credp)
{
    int retval = 0;
    iop *iop_p;
    
    iop_p = (iop *)ddi_get_soft_state(state_head, getminor(*devp));
    
    if (iop_p == NULL) {
        return ENXIO;
    }
    
    if (otyp != OTYP_CHR) {
        return EINVAL;
    }
  
    if ((flag & FWRITE) &&
        (drv_priv(credp) != 0)) 
    {
        retval = EACCES;
    } else {
        retval = 0;
    }
    return retval;
}

static int
iopclose(dev_t dev, int openflags, int otyp, cred_t *credp)
{
    iop *iop_p;
    
    iop_p = (iop *)ddi_get_soft_state(state_head, getminor(dev));
    return 0;
}

/* cmd should be IOPREAD or IOPWRITE
   arg is the address (of the io port)
   */
int
iopioctl(dev_t dev, 
         int cmd, 
         intptr_t arg, 
         int mode, 
         cred_t *credp,
         int *rvalp)
{
    iop *iop_p;
    int retval = 0;
    iopbuf tmpbuf;
    
    iop_p = (iop *)ddi_get_soft_state(state_head, getminor(dev));

    /* we will have to check privileges once we do writes */
    switch (cmd) {
    case IOPREAD:
        mutex_enter(&iop_p->mutex);
        if (ddi_copyin((caddr_t)arg, 
                       (caddr_t)&tmpbuf, 
                       sizeof(tmpbuf),
                       mode)) 
        {
            retval = EFAULT;
        } else {
            tmpbuf.port_value = inb(tmpbuf.port);
            ddi_copyout((caddr_t)&tmpbuf.port_value, 
                        (caddr_t)(arg+sizeof(tmpbuf.port)),
                        sizeof(tmpbuf.port),
                        mode);
        }
        mutex_exit(&iop_p->mutex);
        break;
    case IOPWRITE:
        mutex_enter(&iop_p->mutex);
        if (ddi_copyin((caddr_t)arg,
                       (caddr_t)&tmpbuf,
                       sizeof(tmpbuf),
                       mode)) 
        {
            retval = EFAULT;
        } else {
            outb(tmpbuf.port,tmpbuf.port_value);
        }
        mutex_exit(&iop_p->mutex);
        break;
    default:
        retval = EINVAL;
        break;
    }
    return retval;
    
}