sunfire/io/environ.c

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