/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 * Copyright (c) 2011 Bayard G. Bell. All rights reserved.
 */


#include <sys/types.h>
#include <sys/conf.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/ddi_impldefs.h>
#include <sys/obpdefs.h>
#include <sys/cmn_err.h>
#include <sys/errno.h>
#include <sys/kmem.h>
#include <sys/debug.h>
#include <sys/sysmacros.h>
#include <sys/ivintr.h>
#include <sys/callb.h>
#include <sys/autoconf.h>
#include <sys/intreg.h>
#include <sys/modctl.h>
#include <sys/proc.h>
#include <sys/disp.h>
#include <sys/fhc.h>
#include <sys/environ.h>

/* Useful debugging Stuff */
#include <sys/nexusdebug.h>

/*
 * Function prototypes
 */
static int environ_attach(dev_info_t *devi, ddi_attach_cmd_t cmd);

static int environ_detach(dev_info_t *devi, ddi_detach_cmd_t cmd);

static int environ_init(struct environ_soft_state *softsp);

void environ_add_temp_kstats(struct environ_soft_state *softsp);

static void overtemp_wakeup(void *);

static void environ_overtemp_poll(void);

/*
 * Configuration data structures
 */
static struct cb_ops environ_cb_ops = {
        nulldev,                        /* open */
        nulldev,                        /* close */
        nulldev,                        /* strategy */
        nulldev,                        /* print */
        nodev,                          /* dump */
        nulldev,                        /* read */
        nulldev,                        /* write */
        nulldev,                        /* ioctl */
        nodev,                          /* devmap */
        nodev,                          /* mmap */
        nodev,                          /* segmap */
        nochpoll,                       /* poll */
        ddi_prop_op,                    /* cb_prop_op */
        0,                              /* streamtab */
        D_MP | D_NEW | D_HOTPLUG,       /* Driver compatibility flag */
        CB_REV,                         /* rev */
        nodev,                          /* cb_aread */
        nodev                           /* cb_awrite */
};

static struct dev_ops environ_ops = {
        DEVO_REV,                       /* devo_rev, */
        0,                              /* refcnt */
        ddi_no_info,                    /* getinfo */
        nulldev,                        /* identify */
        nulldev,                        /* probe */
        environ_attach,                 /* attach */
        environ_detach,                 /* detach */
        nulldev,                        /* reset */
        &environ_cb_ops,                /* cb_ops */
        (struct bus_ops *)0,            /* bus_ops */
        nulldev,                        /* power */
        ddi_quiesce_not_needed,                 /* quiesce */
};

void *environp;                 /* environ soft state hook */

/*
 * Mutex used to protect the soft state list and their data.
 */
static kmutex_t overtemp_mutex;

/* The CV is used to wakeup the thread when needed. */
static kcondvar_t overtemp_cv;

/* linked list of all environ soft states */
struct environ_soft_state *tempsp_list = NULL;

/* overtemp polling routine timeout delay */
static int overtemp_timeout_sec = OVERTEMP_TIMEOUT_SEC;

/* Should the environ_overtemp_poll thread be running? */
static int environ_do_overtemp_thread = 1;

/* Indicates whether or not the overtemp thread has been started */
static int environ_overtemp_thread_started = 0;

extern struct mod_ops mod_driverops;

static struct modldrv modldrv = {
        &mod_driverops,         /* module type, this one is a driver */
        "Environment Leaf",     /* name of module */
        &environ_ops,           /* driver ops */
};

static struct modlinkage modlinkage = {
        MODREV_1,
        (void *)&modldrv,
        NULL
};

/*
 * These are the module initialization routines.
 */

int
_init(void)
{
        int error;

        if ((error = ddi_soft_state_init(&environp,
            sizeof (struct environ_soft_state), 1)) != 0)
                return (error);

        return (mod_install(&modlinkage));
}

int
_fini(void)
{
        int error;

        if ((error = mod_remove(&modlinkage)) != 0)
                return (error);

        ddi_soft_state_fini(&environp);
        return (0);
}

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

static int
environ_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
        struct environ_soft_state *softsp;
        int instance;

        switch (cmd) {
        case DDI_ATTACH:
                break;

        case DDI_RESUME:
                return (DDI_SUCCESS);

        default:
                return (DDI_FAILURE);
        }

        instance = ddi_get_instance(devi);

        if (ddi_soft_state_zalloc(environp, instance) != DDI_SUCCESS)
                return (DDI_FAILURE);

        softsp = ddi_get_soft_state(environp, instance);

        /* Set the dip in the soft state */
        softsp->dip = devi;

        /*
         * The DDI documentation on ddi_getprop() routine says that
         * you should always use the real dev_t when calling it,
         * but all calls found in uts use either DDI_DEV_T_ANY
         * or DDI_DEV_T_NONE. No notes either on how to find the real
         * dev_t. So we are doing it in two steps.
         */
        softsp->pdip = ddi_get_parent(softsp->dip);

        if ((softsp->board = (int)ddi_getprop(DDI_DEV_T_ANY, softsp->pdip,
            DDI_PROP_DONTPASS, OBP_BOARDNUM, -1)) == -1) {
                cmn_err(CE_WARN, "environ%d: unable to retrieve %s property",
                    instance, OBP_BOARDNUM);
                goto bad;
        }

        DPRINTF(ENVIRON_ATTACH_DEBUG, ("environ: devi= 0x%p\n, softsp=0x%p,",
            (void *)devi, (void *)softsp));

        /*
         * Init the temperature device here. We start the overtemp
         * polling thread here.
         */
        if (environ_init(softsp) != DDI_SUCCESS)
                goto bad;

        /* nothing to suspend/resume here */
        (void) ddi_prop_update_string(DDI_DEV_T_NONE, devi,
            "pm-hardware-state", "no-suspend-resume");

        ddi_report_dev(devi);

        if (environ_overtemp_thread_started == 0) {
                /*
                 * set up the overtemp mutex and condition variable before
                 * starting the thread.
                 */
                mutex_init(&overtemp_mutex, NULL, MUTEX_DEFAULT, NULL);
                cv_init(&overtemp_cv, NULL, CV_DRIVER, NULL);

                /* Start the overtemp polling thread now. */
                (void) thread_create(NULL, 0, (void (*)())environ_overtemp_poll,
                    NULL, 0, &p0, TS_RUN, minclsyspri);
                environ_overtemp_thread_started++;
        }

        (void) fhc_bdlist_lock(softsp->board);
        fhc_bd_env_set(softsp->board, (void *)softsp);
        fhc_bdlist_unlock();

        return (DDI_SUCCESS);

bad:
        ddi_soft_state_free(environp, instance);
        return (DDI_FAILURE);
}

/* ARGSUSED */
static int
environ_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
{
        int instance;
        struct environ_soft_state *softsp;
        struct environ_soft_state **vect;       /* used in list deletion */
        struct environ_soft_state *temp;        /* used in list deletion */

        /* get the instance of this devi */
        instance = ddi_get_instance(devi);

        /* get the soft state pointer for this device node */
        softsp = ddi_get_soft_state(environp, instance);

        switch (cmd) {
        case DDI_SUSPEND:
                return (DDI_SUCCESS);

        case DDI_DETACH:
                (void) fhc_bdlist_lock(softsp->board);
                if (fhc_bd_detachable(softsp->board))
                        break;
                else
                        fhc_bdlist_unlock();
                /* FALLTHROUGH */

        default:
                return (DDI_FAILURE);
        }

        fhc_bd_env_set(softsp->board, NULL);

        fhc_bdlist_unlock();

        /* remove the environmental kstats if they were allocated */
        if (softsp->environ_ksp)
                kstat_delete(softsp->environ_ksp);
        if (softsp->environ_oksp)
                kstat_delete(softsp->environ_oksp);

        /*
         * remove from soft state pointer from the singly linked list of
         * soft state pointers for temperature monitoring.
         */
        mutex_enter(&overtemp_mutex);

        /*
         * find the soft state for this instance in the soft state list
         * and remove it from the list
         */
        for (temp = tempsp_list, vect = &tempsp_list; temp != NULL;
            vect = &temp->next, temp = temp->next) {
                if (temp == softsp) {
                        *vect = temp->next;
                        break;
                }
        }

        mutex_exit(&overtemp_mutex);

        /* unmap the registers (if they have been mapped) */
        if (softsp->temp_reg)
                ddi_unmap_regs(devi, 0, (caddr_t *)&softsp->temp_reg, 0, 0);

        /* deallocate the soft state instance */
        ddi_soft_state_free(environp, instance);

        ddi_prop_remove_all(devi);

        return (DDI_SUCCESS);
}

static int
environ_init(struct environ_soft_state *softsp)
{
        uchar_t tmp;

        /*
         * If this environment node is on a CPU-less system board, i.e.,
         * board type MEM_TYPE, then we do not want to map in, read
         * the temperature register, create the polling entry for
         * the overtemp polling thread, or create a kstat entry.
         *
         * The reason for this is that when no CPU modules are present
         * on a CPU/Memory board, then the thermistors are not present,
         * and the output of the A/D convertor is the max 8 bit value (0xFF)
         */
        if (fhc_bd_type(softsp->board) == MEM_BOARD) {
                return (DDI_SUCCESS);
        }

        /*
         * Map in the temperature register. Once the temperature register
         * is mapped, the timeout thread can read the temperature and
         * update the temperature in the softsp.
         */
        if (ddi_map_regs(softsp->dip, 0,
            (caddr_t *)&softsp->temp_reg, 0, 0)) {
                cmn_err(CE_WARN, "environ%d: unable to map temperature "
                    "register", ddi_get_instance(softsp->dip));
                return (DDI_FAILURE);
        }

        /* Initialize the temperature */
        init_temp_arrays(&softsp->tempstat);

        /*
         * Do a priming read on the ADC, and throw away the first value
         * read. This is a feature of the ADC hardware. After a power cycle
         * it does not contains valid data until a read occurs.
         */
        tmp = *(softsp->temp_reg);

        /* Wait 30 usec for ADC hardware to stabilize. */
        DELAY(30);

#ifdef lint
        tmp = tmp;
#endif

        /*
         * Now add this soft state structure to the front of the linked list
         * of soft state structures.
         */
        mutex_enter(&overtemp_mutex);
        softsp->next = tempsp_list;
        tempsp_list = softsp;
        mutex_exit(&overtemp_mutex);

        /* Create kstats for this instance of the environ driver */
        environ_add_temp_kstats(softsp);

        return (DDI_SUCCESS);
}

/* ARGSUSED */
static void
overtemp_wakeup(void *arg)
{
        /*
         * grab mutex to guarantee that our wakeup call
         * arrives after we go to sleep -- so we can't sleep forever.
         */
        mutex_enter(&overtemp_mutex);
        cv_signal(&overtemp_cv);
        mutex_exit(&overtemp_mutex);
}

/*
 * This function polls all the system board digital temperature registers
 * and stores them in the history buffers using the fhc driver support
 * routines.
 * The temperature detected must then be checked against our current
 * policy for what to do in the case of overtemperature situations. We
 * must also allow for manufacturing's use of a heat chamber.
 */
static void
environ_overtemp_poll(void)
{
        struct environ_soft_state *list;
        callb_cpr_t cprinfo;

        CALLB_CPR_INIT(&cprinfo, &overtemp_mutex, callb_generic_cpr, "environ");

        /* The overtemp data strcutures are protected by a mutex. */
        mutex_enter(&overtemp_mutex);

        while (environ_do_overtemp_thread) {

                /*
                 * for each environment node that has been attached,
                 * read it and check for overtemp.
                 */
                for (list = tempsp_list; list != NULL; list = list->next) {
                        if (list->temp_reg == NULL) {
                                continue;
                        }

                        update_temp(list->pdip, &list->tempstat,
                            *(list->temp_reg));
                }

                CALLB_CPR_SAFE_BEGIN(&cprinfo);

                /* now have this thread sleep for a while */
                (void) timeout(overtemp_wakeup, NULL, overtemp_timeout_sec*hz);

                cv_wait(&overtemp_cv, &overtemp_mutex);

                CALLB_CPR_SAFE_END(&cprinfo, &overtemp_mutex);
        }
        CALLB_CPR_EXIT(&cprinfo);
        thread_exit();
        /* NOTREACHED */
}

void
environ_add_temp_kstats(struct environ_soft_state *softsp)
{
        struct  kstat   *tksp;
        struct  kstat   *ttsp;  /* environ temperature test kstat */

        /*
         * Create the overtemp kstat required for the environment driver.
         * The kstat instances are tagged with the physical board number
         * instead of ddi instance number.
         */
        if ((tksp = kstat_create("unix", softsp->board,
            OVERTEMP_KSTAT_NAME, "misc", KSTAT_TYPE_RAW,
            sizeof (struct temp_stats), KSTAT_FLAG_PERSISTENT)) == NULL) {
                cmn_err(CE_WARN, "environ%d: temp kstat_create failed",
                        ddi_get_instance(softsp->dip));
        } else {
                tksp->ks_update = overtemp_kstat_update;
                tksp->ks_private = (void *) &softsp->tempstat;
                softsp->environ_ksp = tksp;
                kstat_install(tksp);
        }

        /*
         * Create the temperature override kstat, for testability.
         * The kstat instances are tagged with the physical board number
         * instead of ddi instance number.
         */
        if ((ttsp = kstat_create("unix", softsp->board,
            TEMP_OVERRIDE_KSTAT_NAME, "misc", KSTAT_TYPE_RAW, sizeof (short),
            KSTAT_FLAG_PERSISTENT | KSTAT_FLAG_WRITABLE)) == NULL) {
                cmn_err(CE_WARN, "environ%d: temp override kstat_create failed",
                    ddi_get_instance(softsp->dip));
        } else {
                ttsp->ks_update = temp_override_kstat_update;
                ttsp->ks_private = (void *) &softsp->tempstat.override;
                softsp->environ_oksp = ttsp;
                kstat_install(ttsp);
        }
}