/*
* 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 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* Driver to map the PIC for the chicago platform.
*/
#include <sys/types.h>
#include <sys/time.h>
#include <sys/errno.h>
#include <sys/cmn_err.h>
#include <sys/param.h>
#include <sys/modctl.h>
#include <sys/conf.h>
#include <sys/open.h>
#include <sys/stat.h>
#include <sys/clock.h>
#include <sys/pic.h>
#include <sys/pic16f747.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/file.h>
/* dev_ops and cb_ops entry point function declarations */
static int pic_attach(dev_info_t *, ddi_attach_cmd_t);
static int pic_detach(dev_info_t *, ddi_detach_cmd_t);
static int pic_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);
static int pic_open(dev_t *, int, int, cred_t *);
static int pic_close(dev_t, int, int, cred_t *);
static int pic_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);
struct cb_ops pic_cb_ops = {
pic_open,
pic_close,
nodev,
nodev,
nodev, /* dump */
nodev,
nodev,
pic_ioctl,
nodev, /* devmap */
nodev,
ddi_segmap, /* segmap */
nochpoll,
ddi_prop_op,
NULL, /* for STREAMS drivers */
D_NEW | D_MP /* driver compatibility flag */
};
static struct dev_ops pic_dev_ops = {
DEVO_REV, /* driver build version */
0, /* device reference count */
pic_getinfo,
nulldev,
nulldev, /* probe */
pic_attach,
pic_detach,
nulldev, /* reset */
&pic_cb_ops,
(struct bus_ops *)NULL,
nulldev, /* power */
ddi_quiesce_not_supported, /* devo_quiesce */
};
/*
* Fans' and sensors' node names and register offsets
*/
static struct minor_node_info pic_nodes[N_PIC_NODES] = {
{NULL, 0, 0}, /* Reserved */
{"fan_0", RF_FAN0_PERIOD, F0_FLT_BIT}, /* System Fan 0 */
{"fan_1", RF_FAN1_PERIOD, F1_FLT_BIT}, /* System Fan 1 */
{"fan_2", RF_FAN2_PERIOD, F2_FLT_BIT}, /* System Fan 2 */
{"fan_3", RF_FAN3_PERIOD, F3_FLT_BIT}, /* System Fan 3 */
{"fan_4", RF_FAN4_PERIOD, F4_FLT_BIT}, /* System Fan 4 */
{"adt7462", RF_LOCAL_TEMP, 0}, /* ADT7462 Local Temperature */
{"cpu_0", RF_REMOTE1_TEMP, 0}, /* CPU 0 temp */
{"cpu_1", RF_REMOTE2_TEMP, 0}, /* CPU 1 temp */
{"mb", RF_REMOTE3_TEMP, 0}, /* Motherboard temp */
{"lm95221", RF_LM95221_TEMP, 0}, /* LM95221 Local Temperature */
{"fire", RF_FIRE_TEMP, 0}, /* FIRE Temp */
{"lsi1064", RF_LSI1064_TEMP, 0}, /* LSI1064 Temp */
{"front_panel", RF_FRONT_TEMP, 0}, /* Front Panel Temperature */
{"psu", RF_PSU_TEMP, PSUF_FLT_BIT} /* PSU Temp (and ffault) */
};
/*
* Soft state
*/
struct pic_softc {
dev_info_t *dip;
kmutex_t mutex;
uint8_t *cmd_reg;
ddi_acc_handle_t cmd_handle;
};
#define getsoftc(inst) ((struct pic_softc *)ddi_get_soft_state(statep, (inst)))
/* module configuration stuff */
static void *statep;
extern struct mod_ops mod_driverops;
static struct modldrv modldrv = {
&mod_driverops,
"pic_client driver",
&pic_dev_ops
};
static struct modlinkage modlinkage = {
MODREV_1,
&modldrv,
0
};
int
_init(void)
{
int e;
if (e = ddi_soft_state_init(&statep, sizeof (struct pic_softc),
MAX_PIC_INSTANCES)) {
return (e);
}
if ((e = mod_install(&modlinkage)) != 0)
ddi_soft_state_fini(&statep);
return (e);
}
int
_fini(void)
{
int e;
if ((e = mod_remove(&modlinkage)) != 0)
return (e);
ddi_soft_state_fini(&statep);
return (DDI_SUCCESS);
}
int
_info(struct modinfo *modinfop)
{
return (mod_info(&modlinkage, modinfop));
}
/*ARGSUSED*/
static int
pic_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result)
{
int inst;
int retval = DDI_SUCCESS;
struct pic_softc *softc;
inst = PIC_MINOR_TO_INST(getminor((dev_t)arg));
switch (cmd) {
case DDI_INFO_DEVT2DEVINFO:
if ((softc = getsoftc(inst)) == NULL) {
*result = (void *)NULL;
retval = DDI_FAILURE;
} else
*result = (void *)softc->dip;
break;
case DDI_INFO_DEVT2INSTANCE:
*result = (void *)((uintptr_t)inst);
break;
default:
retval = DDI_FAILURE;
}
return (retval);
}
static int
pic_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
int inst;
int i;
struct pic_softc *softc = NULL;
char *minor_name;
int minor;
char name[80];
ddi_device_acc_attr_t dev_attr;
int res;
switch (cmd) {
case DDI_ATTACH:
inst = ddi_get_instance(dip);
if (inst >= MAX_PIC_INSTANCES) {
cmn_err(CE_WARN, "attach failed, too many instances\n");
return (DDI_FAILURE);
}
(void) sprintf(name, "env-monitor%d", inst);
minor = PIC_INST_TO_MINOR(inst) | PIC_UNIT_TO_MINOR(0);
if (ddi_create_minor_node(dip, name, S_IFCHR, minor,
DDI_PSEUDO, NULL) == DDI_FAILURE) {
cmn_err(CE_WARN,
"ddi_create_minor_node() failed for inst %d\n",
inst);
return (DDI_FAILURE);
}
/* Allocate a soft state structure for this instance */
if (ddi_soft_state_zalloc(statep, inst) != DDI_SUCCESS) {
cmn_err(CE_WARN, " ddi_soft_state_zalloc() failed "
"for inst %d\n", inst);
goto attach_failed;
}
/* Setup soft state */
softc = getsoftc(inst);
softc->dip = dip;
mutex_init(&softc->mutex, NULL, MUTEX_DRIVER, NULL);
/* Setup device attributes */
dev_attr.devacc_attr_version = DDI_DEVICE_ATTR_V0;
dev_attr.devacc_attr_endian_flags = DDI_STRUCTURE_LE_ACC;
dev_attr.devacc_attr_dataorder = DDI_STRICTORDER_ACC;
/*
* The RF_COMMAND/RF_STATUS and RF_IND_DATA/RF_IND_ADDR
* register pairs are mapped as one register set starting
* from 0x0 and length 0x42.
*/
res = ddi_regs_map_setup(dip, 0, (caddr_t *)&softc->cmd_reg,
0, 0x42, &dev_attr, &softc->cmd_handle);
if (res != DDI_SUCCESS) {
cmn_err(CE_WARN, "ddi_regs_map_setup() failed\n");
goto attach_failed;
}
/* Set up fans' and sensors' device minor nodes */
for (i = 1; i < N_PIC_NODES; i++) {
minor_name = pic_nodes[i].minor_name;
minor = PIC_INST_TO_MINOR(inst) | PIC_UNIT_TO_MINOR(i);
if (ddi_create_minor_node(dip, minor_name, S_IFCHR,
minor, PICDEV_NODE_TYPE, NULL) == DDI_FAILURE) {
cmn_err(CE_WARN,
"%s:%d ddi_create_minor_node failed",
ddi_driver_name(dip), inst);
(void) pic_detach(dip, DDI_DETACH);
return (DDI_FAILURE);
}
}
/* Create main environmental node */
ddi_report_dev(dip);
return (DDI_SUCCESS);
case DDI_RESUME:
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
attach_failed:
/* Free soft state, if allocated. remove minor node if added earlier */
if (softc)
ddi_soft_state_free(statep, inst);
ddi_remove_minor_node(dip, NULL);
return (DDI_FAILURE);
}
static int
pic_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
int inst;
struct pic_softc *softc;
switch (cmd) {
case DDI_DETACH:
inst = ddi_get_instance(dip);
if ((softc = getsoftc(inst)) == NULL)
return (ENXIO);
(void) ddi_regs_map_free(&softc->cmd_handle);
/* Free the soft state and remove minor node added earlier */
mutex_destroy(&softc->mutex);
ddi_soft_state_free(statep, inst);
ddi_remove_minor_node(dip, NULL);
return (DDI_SUCCESS);
case DDI_SUSPEND:
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
}
/*ARGSUSED*/
static int
pic_open(dev_t *devp, int flag, int otyp, cred_t *credp)
{
int inst = PIC_MINOR_TO_INST(getminor(*devp));
return (getsoftc(inst) == NULL ? ENXIO : 0);
}
/*ARGSUSED*/
static int
pic_close(dev_t dev, int flag, int otyp, cred_t *credp)
{
int inst = PIC_MINOR_TO_INST(getminor(dev));
return (getsoftc(inst) == NULL ? ENXIO : 0);
}
/*ARGSUSED*/
static int
pic_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp, int *rvalp)
{
int inst;
int node;
struct pic_softc *softc;
uint8_t in_command;
int16_t tempr;
inst = PIC_MINOR_TO_INST(getminor(dev));
if ((softc = getsoftc(inst)) == NULL)
return (ENXIO);
mutex_enter(&softc->mutex);
if (ddi_copyin((caddr_t)arg, &in_command, sizeof (in_command),
mode) != DDI_SUCCESS) {
mutex_exit(&softc->mutex);
return (EFAULT);
}
node = PIC_MINOR_TO_UNIT(getminor(dev));
if ((node >= N_PIC_NODES) || (node < 1)) {
mutex_exit(&softc->mutex);
return (ENXIO);
}
switch (cmd) {
case PIC_GET_TEMPERATURE:
drv_usecwait(10);
/* select the temp sensor */
(void) ddi_put8(softc->cmd_handle, (uint8_t *)softc->cmd_reg +
RF_IND_ADDR, pic_nodes[node].reg_offset);
/* retrieve temperature data */
tempr = (int16_t)ddi_get8(softc->cmd_handle,
(uint8_t *)softc->cmd_reg + RF_IND_DATA);
mutex_exit(&softc->mutex);
if (tempr == 0xff)
return (EIO);
/*
* The temp is passed in as a uint8 value, we need to convert
* it to a signed 16 bit value to be able to handle the range
* of -64 to 190 degrees.
*/
tempr -= 64;
(void) ddi_copyout(&tempr, (caddr_t)arg, sizeof (tempr), mode);
return (0);
case PIC_GET_FAN_SPEED:
drv_usecwait(10);
/* select fan */
(void) ddi_put8(softc->cmd_handle, (uint8_t *)softc->cmd_reg +
RF_IND_ADDR, pic_nodes[node].reg_offset);
/* retrieve fan data */
in_command = ddi_get8(softc->cmd_handle,
(uint8_t *)softc->cmd_reg + RF_IND_DATA);
mutex_exit(&softc->mutex);
if (in_command == 0xff)
return (EIO);
(void) ddi_copyout(&in_command, (caddr_t)arg, 1, mode);
return (0);
case PIC_SET_FAN_SPEED:
/* select fan */
(void) ddi_put8(softc->cmd_handle, (uint8_t *)softc->cmd_reg +
RF_IND_ADDR, pic_nodes[node].reg_offset);
/* send the fan data */
(void) ddi_put8(softc->cmd_handle,
(uint8_t *)softc->cmd_reg + RF_IND_DATA, in_command);
mutex_exit(&softc->mutex);
return (0);
case PIC_GET_STATUS:
mutex_exit(&softc->mutex);
/* we don't read the status reg anymore */
in_command = 0;
(void) ddi_copyout(&in_command, (caddr_t)arg, 1, mode);
return (0);
case PIC_GET_FAN_STATUS:
drv_usecwait(10);
/* read ffault register */
(void) ddi_put8(softc->cmd_handle, (uint8_t *)softc->cmd_reg +
RF_IND_ADDR, RF_FAN_STATUS);
/* retrieve fan failure status */
in_command = ddi_get8(softc->cmd_handle,
(uint8_t *)softc->cmd_reg + RF_IND_DATA);
mutex_exit(&softc->mutex);
if (in_command == 0xff)
return (EIO);
in_command = (in_command >> pic_nodes[node].ff_shift) & 0x1;
(void) ddi_copyout(&in_command, (caddr_t)arg, 1, mode);
return (0);
case PIC_SET_ESTAR_MODE:
(void) ddi_put8(softc->cmd_handle,
(uint8_t *)softc->cmd_reg + RF_COMMAND, CMD_TO_ESTAR);
mutex_exit(&softc->mutex);
return (0);
default:
mutex_exit(&softc->mutex);
cmn_err(CE_NOTE, "cmd %d isnt valid", cmd);
return (EINVAL);
}
}