/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2020 Oxide Computer Company
 */

/*
 * This driver is used to implement parts of the ksensor test suite.
 */

#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/modctl.h>
#include <sys/conf.h>
#include <sys/devops.h>
#include <sys/zone.h>
#include <sys/sensors.h>

typedef struct ksensor_test {
        dev_info_t *kt_dip;
        id_t kt_sensor1;
        id_t kt_sensor2;
        id_t kt_sensor3;
        id_t kt_sensor4;
        id_t kt_sensor5;
        id_t kt_volt;
        id_t kt_current;
} ksensor_test_t;

static int
ksensor_test_temp(void *arg, sensor_ioctl_scalar_t *scalar)
{
        scalar->sis_unit = SENSOR_UNIT_CELSIUS;
        scalar->sis_gran = 4;
        scalar->sis_prec = -2;
        scalar->sis_value = 23;
        return (0);
}

static const ksensor_ops_t ksensor_test_temp_ops = {
        .kso_kind = ksensor_kind_temperature,
        .kso_scalar = ksensor_test_temp
};

static int
ksensor_test_volt(void *arg, sensor_ioctl_scalar_t *scalar)
{
        scalar->sis_unit = SENSOR_UNIT_VOLTS;
        scalar->sis_gran = 1000;
        scalar->sis_prec = 0;
        scalar->sis_value = 3300;
        return (0);
}

static const ksensor_ops_t ksensor_test_volt_ops = {
        .kso_kind = ksensor_kind_voltage,
        .kso_scalar = ksensor_test_volt
};

static int
ksensor_test_current(void *arg, sensor_ioctl_scalar_t *scalar)
{
        scalar->sis_unit = SENSOR_UNIT_AMPS;
        scalar->sis_gran = 10;
        scalar->sis_prec = 0;
        scalar->sis_value = 5;
        return (0);
}

static const ksensor_ops_t ksensor_test_current_ops = {
        .kso_kind = ksensor_kind_current,
        .kso_scalar = ksensor_test_current
};

static int
ksensor_test_kind_eio(void *arg, sensor_ioctl_kind_t *kindp)
{
        return (EIO);
}

static int
ksensor_test_temp_eio(void *arg, sensor_ioctl_scalar_t *scalar)
{
        return (EIO);
}

static const ksensor_ops_t ksensor_test_eio_ops = {
        .kso_kind = ksensor_test_kind_eio,
        .kso_scalar = ksensor_test_temp_eio
};

static int
ksensor_test_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
        int ret;
        char buf[128];
        ksensor_test_t *kt;

        switch (cmd) {
        case DDI_RESUME:
                return (DDI_SUCCESS);
        case DDI_ATTACH:
                break;
        default:
                return (DDI_FAILURE);
        }

        kt = kmem_zalloc(sizeof (ksensor_test_t), KM_SLEEP);
        kt->kt_dip = dip;

        (void) snprintf(buf, sizeof (buf), "test.temp.%d.1",
            ddi_get_instance(dip));
        if ((ret = ksensor_create(dip, &ksensor_test_temp_ops, NULL, buf,
            "ddi_sensor:test", &kt->kt_sensor1)) != 0) {
                dev_err(dip, CE_WARN, "failed to attatch sensor %s: %d", buf,
                    ret);
                goto err;
        }

        (void) snprintf(buf, sizeof (buf), "test.temp.%d.2",
            ddi_get_instance(dip));
        if ((ret = ksensor_create(dip, &ksensor_test_temp_ops, NULL, buf,
            "ddi_sensor:test", &kt->kt_sensor2)) != 0) {
                dev_err(dip, CE_WARN, "failed to attatch sensor %s: %d", buf,
                    ret);
                goto err;
        }

        (void) snprintf(buf, sizeof (buf), "test.temp.%d.3",
            ddi_get_instance(dip));
        if ((ret = ksensor_create(dip, &ksensor_test_temp_ops, NULL, buf,
            "ddi_sensor:test", &kt->kt_sensor3)) != 0) {
                dev_err(dip, CE_WARN, "failed to attach sensor %s: %d", buf,
                    ret);
                goto err;
        }

        (void) snprintf(buf, sizeof (buf), "test.temp.%d.4",
            ddi_get_instance(dip));
        if ((ret = ksensor_create(dip, &ksensor_test_temp_ops, NULL, buf,
            "ddi_sensor:test", &kt->kt_sensor4)) != 0) {
                dev_err(dip, CE_WARN, "failed to attach sensor %s: %d", buf,
                    ret);
                goto err;
        }

        (void) snprintf(buf, sizeof (buf), "test.eio.%d",
            ddi_get_instance(dip));
        if ((ret = ksensor_create(dip, &ksensor_test_eio_ops, NULL, buf,
            "ddi_sensor:test", &kt->kt_sensor5)) != 0) {
                dev_err(dip, CE_WARN, "failed to attach sensor %s: %d", buf,
                    ret);
                goto err;
        }

        (void) snprintf(buf, sizeof (buf), "test.volt.%d.1",
            ddi_get_instance(dip));
        if ((ret = ksensor_create(dip, &ksensor_test_volt_ops, NULL, buf,
            "ddi_sensor:test", &kt->kt_volt)) != 0) {
                dev_err(dip, CE_WARN, "failed to attach sensor %s: %d", buf,
                    ret);
                goto err;
        }

        (void) snprintf(buf, sizeof (buf), "test.current.%d.1",
            ddi_get_instance(dip));
        if ((ret = ksensor_create(dip, &ksensor_test_current_ops, NULL, buf,
            "ddi_sensor:test", &kt->kt_current)) != 0) {
                dev_err(dip, CE_WARN, "failed to attach sensor %s: %d", buf,
                    ret);
                goto err;
        }

        ddi_set_driver_private(dip, kt);

        return (DDI_SUCCESS);
err:
        (void) ksensor_remove(dip, KSENSOR_ALL_IDS);
        kmem_free(kt, sizeof (ksensor_test_t));
        return (DDI_FAILURE);
}

static int
ksensor_test_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
        ksensor_test_t *kt;

        switch (cmd) {
        case DDI_DETACH:
                break;
        case DDI_SUSPEND:
                return (DDI_SUCCESS);
        default:
                return (DDI_FAILURE);
        }

        kt = ddi_get_driver_private(dip);
        if (kt == NULL) {
                dev_err(dip, CE_WARN, "failed to find ksensor_test_t");
                return (DDI_FAILURE);
        }

        if (kt->kt_sensor3 != 0 &&
            ksensor_remove(dip, kt->kt_sensor3) != 0) {
                dev_err(dip, CE_WARN, "failed to remove sensor 3");
                return (DDI_FAILURE);
        }
        kt->kt_sensor3 = 0;
        if (ksensor_remove(dip, KSENSOR_ALL_IDS) != 0) {
                dev_err(dip, CE_WARN, "failed to remove sensors");
                return (DDI_FAILURE);
        }
        kmem_free(kt, sizeof (*kt));
        ddi_set_driver_private(dip, NULL);
        return (DDI_SUCCESS);
}

static struct dev_ops ksensor_test_dev_ops = {
        .devo_rev = DEVO_REV,
        .devo_refcnt = 0,
        .devo_getinfo = nodev,
        .devo_identify = nulldev,
        .devo_probe = nulldev,
        .devo_attach = ksensor_test_attach,
        .devo_detach = ksensor_test_detach,
        .devo_reset = nodev,
        .devo_power = ddi_power,
        .devo_quiesce = ddi_quiesce_not_needed,
};

static struct modldrv ksensor_test_modldrv = {
        .drv_modops = &mod_driverops,
        .drv_linkinfo = "Kernel Sensor test driver",
        .drv_dev_ops = &ksensor_test_dev_ops
};

static struct modlinkage ksensor_test_modlinkage = {
        .ml_rev = MODREV_1,
        .ml_linkage = { &ksensor_test_modldrv, NULL }
};

int
_init(void)
{
        return (mod_install(&ksensor_test_modlinkage));
}

int
_info(struct modinfo *modinfop)
{
        return (mod_info(&ksensor_test_modlinkage, modinfop));
}

int
_fini(void)
{
        return (mod_remove(&ksensor_test_modlinkage));
}