 @@ -1,14 +1,14 @@
-/*	$NetBSD: ipmi.c,v 1.38 2009/07/11 05:03:11 pgoyette Exp $ */
+/*	$NetBSD: ipmi.c,v 1.39 2009/07/20 19:11:30 dyoung Exp $ */
 /*
  * Copyright (c) 2006 Manuel Bouyer.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
 @@ -47,27 +47,27 @@
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ipmi.c,v 1.38 2009/07/11 05:03:11 pgoyette Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ipmi.c,v 1.39 2009/07/20 19:11:30 dyoung Exp $");
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/device.h>
 #include <sys/extent.h>
 #include <sys/callout.h>
 #include <sys/envsys.h>
 #include <sys/malloc.h>
 #include <sys/kthread.h>
 #include <sys/bus.h>
 #include <sys/intr.h>
 @@ -85,27 +85,26 @@ struct ipmi_sensor {
 	uint8_t	*i_sdr;
 	int		i_num;
 	int		i_stype;
 	int		i_etype;
 	char		i_envdesc[64];
 	int 		i_envtype; /* envsys compatible type */
 	int		i_envnum; /* envsys index */
 	sysmon_envsys_lim_t i_limits;
 	SLIST_ENTRY(ipmi_sensor) i_list;
 };
 int	ipmi_nintr;
 int	ipmi_dbg = 0;
 int	ipmi_poll = 1;
 int	ipmi_enabled = 0;
 #define SENSOR_REFRESH_RATE (5 * hz)
 #define SMBIOS_TYPE_IPMI	0x26
 /*
  * Format of SMBIOS IPMI Flags
+ *
  * bit0: interrupt trigger mode (1=level, 0=edge)
  * bit1: interrupt polarity (1=active high, 0=active low)
  * bit2: reserved
  * bit3: address LSB (1=odd,0=even)
 @@ -168,49 +167,51 @@ long signextend(unsigned long, int);
 SLIST_HEAD(ipmi_sensors_head, ipmi_sensor);
 struct ipmi_sensors_head ipmi_sensor_list =
     SLIST_HEAD_INITIALIZER(&ipmi_sensor_list);
 void	dumpb(const char *, int, const uint8_t *);
 int	read_sensor(struct ipmi_softc *, struct ipmi_sensor *);
 int	add_sdr_sensor(struct ipmi_softc *, uint8_t *);
 int	get_sdr_partial(struct ipmi_softc *, uint16_t, uint16_t,
 	    uint8_t, uint8_t, void *, uint16_t *);
 int	get_sdr(struct ipmi_softc *, uint16_t, uint16_t *);
 char	*ipmi_buf_acquire(struct ipmi_softc *, size_t);
 void	ipmi_buf_release(struct ipmi_softc *, char *);
 int	ipmi_sendcmd(struct ipmi_softc *, int, int, int, int, int, const void*);
 int	ipmi_recvcmd(struct ipmi_softc *, int, int *, void *);
 void	ipmi_delay(struct ipmi_softc *, int);
 int	ipmi_watchdog_setmode(struct sysmon_wdog *);
 int	ipmi_watchdog_tickle(struct sysmon_wdog *);
 void	ipmi_dotickle(struct ipmi_softc *);
 int	ipmi_intr(void *);
 int	ipmi_match(device_t, cfdata_t, void *);
 void	ipmi_attach(device_t, device_t, void *);
 static int ipmi_detach(device_t, int);
 long	ipow(long, int);
 long	ipmi_convert(uint8_t, struct sdrtype1 *, long);
 void	ipmi_sensor_name(char *, int, uint8_t, uint8_t *);
 /* BMC Helper Functions */
 uint8_t bmc_read(struct ipmi_softc *, int);
 void	bmc_write(struct ipmi_softc *, int, uint8_t);
 int	bmc_io_wait(struct ipmi_softc *, int, uint8_t, uint8_t, const char *);
-int	bmc_io_wait_spin(struct ipmi_softc *, int, uint8_t, uint8_t,
+int	bmc_io_wait_spin(struct ipmi_softc *, int, uint8_t, uint8_t);
-    const char *);
+int	bmc_io_wait_sleep(struct ipmi_softc *, int, uint8_t, uint8_t);
 void	_bmc_io_wait(void *);
 void	*bt_buildmsg(struct ipmi_softc *, int, int, int, const void *, int *);
 void	*cmn_buildmsg(struct ipmi_softc *, int, int, int, const void *, int *);
 int	getbits(uint8_t *, int, int);
 int	ipmi_sensor_type(int, int, int);
 void	ipmi_smbios_probe(struct smbios_ipmi *, struct ipmi_attach_args *);
 void	ipmi_refresh_sensors(struct ipmi_softc *sc);
 int	ipmi_map_regs(struct ipmi_softc *sc, struct ipmi_attach_args *ia);
 void	ipmi_unmap_regs(struct ipmi_softc *sc);
 void	*scan_sig(long, long, int, int, const void *);
 @@ -282,88 +283,62 @@ uint8_t
 bmc_read(struct ipmi_softc *sc, int offset)
+{
 	return (bus_space_read_1(sc->sc_iot, sc->sc_ioh,
 	    offset * sc->sc_if_iospacing));
+}
 void
 bmc_write(struct ipmi_softc *sc, int offset, uint8_t val)
+{
 	bus_space_write_1(sc->sc_iot, sc->sc_ioh,
 	    offset * sc->sc_if_iospacing, val);
+}
-void
+int
-_bmc_io_wait(void *arg)
+bmc_io_wait_sleep(struct ipmi_softc *sc, int offset, uint8_t mask,
     uint8_t value)
+{
-	struct ipmi_softc	*sc = arg;
+	int retries;
-	struct ipmi_bmc_args	*a = sc->sc_iowait_args;
+	uint8_t v;
-	*a->v = bmc_read(sc, a->offset);
+	KASSERT(mutex_owned(&sc->sc_cmd_mtx));
 	if ((*a->v & a->mask) == a->value) {
 		sc->sc_wakeup = 0;
 		wakeup(sc);
 		return;
-	if (++sc->sc_retries > sc->sc_max_retries) {
+	for (retries = 0; retries < sc->sc_max_retries; retries++) {
-		sc->sc_wakeup = 0;
+		v = bmc_read(sc, offset);
-		wakeup(sc);
+		if ((v & mask) == value)
-		return;
+			return v;
 		cv_timedwait(&sc->sc_cmd_sleep, &sc->sc_cmd_mtx, 1);
+	}
 	return -1;
 	callout_schedule(&sc->sc_callout, 1);
+}
 int
 bmc_io_wait(struct ipmi_softc *sc, int offset, uint8_t mask, uint8_t value,
     const char *lbl)
+{
-	volatile uint8_t	v;
+	int v;
 	int			u;
 	struct ipmi_bmc_args	args;
 	u = bmc_io_wait_spin(sc, offset, mask, value, lbl);
 	if (cold || u != -1)
 		return u;
 	sc->sc_retries = 0;
 	sc->sc_wakeup = 1;
 	args.offset = offset;
 	args.mask = mask;
 	args.value = value;
 	args.v = &v;
 	sc->sc_iowait_args = &args;
 	_bmc_io_wait(sc);
 	while (sc->sc_wakeup)
 		tsleep(sc, PWAIT, lbl, 0);
 	if (sc->sc_retries > sc->sc_max_retries) {
 		dbg_printf(1, "ipmi: bmc_io_wait fails : v=%.2x m=%.2x "
 		    "b=%.2x %s\n", v, mask, value, lbl);
 		return (-1);
-	return (v);
+	v = bmc_io_wait_spin(sc, offset, mask, value);
 	if (cold || v != -1)
 		return v;
 	return bmc_io_wait_sleep(sc, offset, mask, value);
+}
 int
 bmc_io_wait_spin(struct ipmi_softc *sc, int offset, uint8_t mask,
-    uint8_t value, const char *lbl)
+    uint8_t value)
+{
-	volatile uint8_t	v;
+	uint8_t	v;
 	int			count = cold ? 5000 : 500;
 	/* ~us */
 	while (count--) {
 		v = bmc_read(sc, offset);
 		if ((v & mask) == value)
 			return v;
 		delay(1);
+	}
 	return (-1);
 @@ -971,27 +946,27 @@ ipmi_smbios_probe(struct smbios_ipmi *pi
  * This is used by BT protocol
+ *
  * Returns a buffer to an allocated message, txlen contains length
  *   of allocated message
  */
 void *
 bt_buildmsg(struct ipmi_softc *sc, int nfLun, int cmd, int len,
     const void *data, int *txlen)
+{
 	uint8_t *buf;
 	/* Block transfer needs 4 extra bytes: length/netfn/seq/cmd + data */
 	*txlen = len + 4;
-	buf = malloc(*txlen, M_DEVBUF, M_WAITOK|M_CANFAIL);
+	buf = ipmi_buf_acquire(sc, *txlen);
 	if (buf == NULL)
 		return (NULL);
 	buf[IPMI_BTMSG_LEN] = len + 3;
 	buf[IPMI_BTMSG_NFLN] = nfLun;
 	buf[IPMI_BTMSG_SEQ] = sc->sc_btseq++;
 	buf[IPMI_BTMSG_CMD] = cmd;
 	if (len && data)
 		memcpy(buf + IPMI_BTMSG_DATASND, data, len);
 	return (buf);
+}
 @@ -1000,39 +975,43 @@ bt_buildmsg(struct ipmi_softc *sc, int n
  * This is used by both SMIC and KCS protocols
+ *
  * Returns a buffer to an allocated message, txlen contains length
  *   of allocated message
  */
 void *
 cmn_buildmsg(struct ipmi_softc *sc, int nfLun, int cmd, int len,
     const void *data, int *txlen)
+{
 	uint8_t *buf;
 	/* Common needs two extra bytes: nfLun/cmd + data */
 	*txlen = len + 2;
-	buf = malloc(*txlen, M_DEVBUF, M_WAITOK|M_CANFAIL);
+	buf = ipmi_buf_acquire(sc, *txlen);
 	if (buf == NULL)
 		return (NULL);
 	buf[IPMI_MSG_NFLN] = nfLun;
 	buf[IPMI_MSG_CMD] = cmd;
 	if (len && data)
 		memcpy(buf + IPMI_MSG_DATASND, data, len);
 	return (buf);
+}
-/* Send an IPMI command */
+/*
  * ipmi_sendcmd: caller must hold sc_cmd_mtx.
+ *
  * Send an IPMI command
  */
 int
 ipmi_sendcmd(struct ipmi_softc *sc, int rssa, int rslun, int netfn, int cmd,
     int txlen, const void *data)
+{
 	uint8_t	*buf;
 	int		rc = -1;
 	dbg_printf(50, "ipmi_sendcmd: rssa=%.2x nfln=%.2x cmd=%.2x len=%.2x\n",
 	    rssa, NETFN_LUN(netfn, rslun), cmd, txlen);
 	dbg_dump(10, " send", txlen, data);
 	if (rssa != BMC_SA) {
 #if 0
 		buf = sc->sc_if->buildmsg(sc, NETFN_LUN(APP_NETFN, BMC_LUN),
 @@ -1052,126 +1031,159 @@ ipmi_sendcmd(struct ipmi_softc *sc, int
 		/* Set message checksum */
 		imbreq->data[txlen] = cksum8(&imbreq->rqSa, txlen + 3);
 #endif
 		goto done;
 	} else
 		buf = sc->sc_if->buildmsg(sc, NETFN_LUN(netfn, rslun), cmd,
 		    txlen, data, &txlen);
 	if (buf == NULL) {
 		printf("ipmi: sendcmd malloc fails\n");
 		goto done;
+	}
 	rc = sc->sc_if->sendmsg(sc, txlen, buf);
-	free(buf, M_DEVBUF);
+	ipmi_buf_release(sc, buf);
 	ipmi_delay(sc, 50); /* give bmc chance to digest command */
 done:
 	return (rc);
+}
 void
 ipmi_buf_release(struct ipmi_softc *sc, char *buf)
+{
 	KASSERT(sc->sc_buf_rsvd);
 	KASSERT(sc->sc_buf == buf);
 	sc->sc_buf_rsvd = false;
+}
 char *
 ipmi_buf_acquire(struct ipmi_softc *sc, size_t len)
+{
 	KASSERT(len <= sizeof(sc->sc_buf));
 	if (sc->sc_buf_rsvd || len > sizeof(sc->sc_buf))
 		return NULL;
 	sc->sc_buf_rsvd = true;
 	return sc->sc_buf;
+}
 /*
  * ipmi_recvcmd: caller must hold sc_cmd_mtx.
  */
 int
 ipmi_recvcmd(struct ipmi_softc *sc, int maxlen, int *rxlen, void *data)
+{
 	uint8_t	*buf, rc = 0;
 	int		rawlen;
 	/* Need three extra bytes: netfn/cmd/ccode + data */
-	buf = malloc(maxlen + 3, M_DEVBUF, M_WAITOK|M_CANFAIL);
+	buf = ipmi_buf_acquire(sc, maxlen + 3);
 	if (buf == NULL) {
 		printf("ipmi: ipmi_recvcmd: malloc fails\n");
 		return (-1);
+	}
 	/* Receive message from interface, copy out result data */
 	if (sc->sc_if->recvmsg(sc, maxlen + 3, &rawlen, buf))
 		return (-1);
 	*rxlen = rawlen - IPMI_MSG_DATARCV;
 	if (*rxlen > 0 && data)
 		memcpy(data, buf + IPMI_MSG_DATARCV, *rxlen);
 	if ((rc = buf[IPMI_MSG_CCODE]) != 0)
 		dbg_printf(1, "ipmi_recvmsg: nfln=%.2x cmd=%.2x err=%.2x\n",
 		    buf[IPMI_MSG_NFLN], buf[IPMI_MSG_CMD], buf[IPMI_MSG_CCODE]);
 	dbg_printf(50, "ipmi_recvcmd: nfln=%.2x cmd=%.2x err=%.2x len=%.2x\n",
 	    buf[IPMI_MSG_NFLN], buf[IPMI_MSG_CMD], buf[IPMI_MSG_CCODE],
 	    *rxlen);
 	dbg_dump(10, " recv", *rxlen, data);
-	free(buf, M_DEVBUF);
+	ipmi_buf_release(sc, buf);
 	return (rc);
+}
 /*
  * ipmi_delay: caller must hold sc_cmd_mtx.
  */
 void
 ipmi_delay(struct ipmi_softc *sc, int ms)
+{
 	if (cold)
 		delay(ms * 1000);
 	else
-		while (tsleep(sc, PWAIT, "ipmicmd", mstohz(ms)) != EWOULDBLOCK);
+		cv_timedwait(&sc->sc_cmd_sleep, &sc->sc_cmd_mtx, mstohz(ms));
+}
 /* Read a partial SDR entry */
 int
 get_sdr_partial(struct ipmi_softc *sc, uint16_t recordId, uint16_t reserveId,
     uint8_t offset, uint8_t length, void *buffer, uint16_t *nxtRecordId)
+{
 	uint8_t	cmd[256 + 8];
 	int		len;
 	((uint16_t *) cmd)[0] = reserveId;
 	((uint16_t *) cmd)[1] = recordId;
 	cmd[4] = offset;
 	cmd[5] = length;
 	mutex_enter(&sc->sc_cmd_mtx);
 	if (ipmi_sendcmd(sc, BMC_SA, 0, STORAGE_NETFN, STORAGE_GET_SDR, 6,
 	    cmd)) {
 		mutex_exit(&sc->sc_cmd_mtx);
 		printf("ipmi: sendcmd fails\n");
 		return (-1);
+	}
 	if (ipmi_recvcmd(sc, 8 + length, &len, cmd)) {
 		mutex_exit(&sc->sc_cmd_mtx);
 		printf("ipmi: getSdrPartial: recvcmd fails\n");
 		return (-1);
+	}
 	mutex_exit(&sc->sc_cmd_mtx);
 	if (nxtRecordId)
 		*nxtRecordId = *(uint16_t *) cmd;
 	memcpy(buffer, cmd + 2, len - 2);
 	return (0);
+}
 int maxsdrlen = 0x10;
 /* Read an entire SDR; pass to add sensor */
 int
 get_sdr(struct ipmi_softc *sc, uint16_t recid, uint16_t *nxtrec)
+{
 	uint16_t	resid = 0;
 	int		len, sdrlen, offset;
 	uint8_t	*psdr;
 	struct sdrhdr	shdr;
 	mutex_enter(&sc->sc_cmd_mtx);
 	/* Reserve SDR */
 	if (ipmi_sendcmd(sc, BMC_SA, 0, STORAGE_NETFN, STORAGE_RESERVE_SDR,
 , NULL)) {
 		mutex_exit(&sc->sc_cmd_mtx);
 		printf("ipmi: reserve send fails\n");
 		return (-1);
+	}
 	if (ipmi_recvcmd(sc, sizeof(resid), &len, &resid)) {
 		mutex_exit(&sc->sc_cmd_mtx);
 		printf("ipmi: reserve recv fails\n");
 		return (-1);
+	}
 	mutex_exit(&sc->sc_cmd_mtx);
 	/* Get SDR Header */
 	if (get_sdr_partial(sc, recid, resid, 0, sizeof shdr, &shdr, nxtrec)) {
 		printf("ipmi: get header fails\n");
 		return (-1);
+	}
 	/* Allocate space for entire SDR Length of SDR in header does not
 	 * include header length */
 	sdrlen = sizeof(shdr) + shdr.record_length;
 	psdr = malloc(sdrlen, M_DEVBUF, M_WAITOK|M_CANFAIL);
 	if (psdr == NULL)
 		return -1;
 	memcpy(psdr, &shdr, sizeof(shdr));
 @@ -1370,34 +1382,39 @@ ipmi_get_limits(struct sysmon_envsys *sm
 			ipmi_get_sensor_limits(sc, ipmi_s, limits);
 			ipmi_s->i_limits = *limits;
 			return;
+		}
+	}
 	return;
+}
 void
 ipmi_get_sensor_limits(struct ipmi_softc *sc, struct ipmi_sensor *psensor,
 		       sysmon_envsys_lim_t *limits)
+{
 	struct sdrtype1	*s1 = (struct sdrtype1 *)psensor->i_sdr;
 	bool failure;
 	int	rxlen;
 	uint8_t	data[32];
 	limits->sel_flags = 0;
 	data[0] = psensor->i_num;
-	if (ipmi_sendcmd(sc, s1->owner_id, s1->owner_lun,
+	mutex_enter(&sc->sc_cmd_mtx);
 	failure =
 	    ipmi_sendcmd(sc, s1->owner_id, s1->owner_lun,
 			 SE_NETFN, SE_GET_SENSOR_THRESHOLD, 1, data) ||
-	    ipmi_recvcmd(sc, sizeof(data), &rxlen, data))
+	    ipmi_recvcmd(sc, sizeof(data), &rxlen, data);
 	mutex_exit(&sc->sc_cmd_mtx);
 	if (failure)
 		return;
 	dbg_printf(25, "recvdata: %.2x %.2x %.2x %.2x %.2x %.2x %.2x\n",
 	    data[0], data[1], data[2], data[3], data[4], data[5], data[6]);
 	if (data[0] & 0x20 && data[6] != 0xff) {
 		limits->sel_critmax = ipmi_convert_sensor(&data[6], psensor);
 		limits->sel_flags |= PROP_CRITMAX;
+	}
 	if (data[0] & 0x10 && data[5] != 0xff) {
 		limits->sel_critmax = ipmi_convert_sensor(&data[5], psensor);
 		limits->sel_flags |= PROP_CRITMAX;
+	}
 @@ -1475,50 +1492,53 @@ ipmi_sensor_status(struct ipmi_softc *sc
 			return ENVSYS_SWARNOVER;
+		}
 		break;
+	}
 	return ENVSYS_SVALID;
+}
 int
 read_sensor(struct ipmi_softc *sc, struct ipmi_sensor *psensor)
+{
 	struct sdrtype1	*s1 = (struct sdrtype1 *) psensor->i_sdr;
 	uint8_t	data[8];
-	int		rxlen, rv = -1;
+	int		rxlen;
 	envsys_data_t *edata = &sc->sc_sensor[psensor->i_envnum];
 	mutex_enter(&sc->sc_lock);
 	memset(data, 0, sizeof(data));
 	data[0] = psensor->i_num;
 	mutex_enter(&sc->sc_cmd_mtx);
 	if (ipmi_sendcmd(sc, s1->owner_id, s1->owner_lun, SE_NETFN,
 	    SE_GET_SENSOR_READING, 1, data))
-		goto done;
+		goto err;
 	if (ipmi_recvcmd(sc, sizeof(data), &rxlen, data))
-		goto done;
+		goto err;
 	mutex_exit(&sc->sc_cmd_mtx);
 	dbg_printf(10, "values=%.2x %.2x %.2x %.2x %s\n",
 	    data[0],data[1],data[2],data[3], edata->desc);
 	if (data[1] & IPMI_INVALID_SENSOR) {
 		/* Check if sensor is valid */
 		edata->state = ENVSYS_SINVALID;
 	} else {
 		edata->state = ipmi_sensor_status(sc, psensor, edata, data);
+	}
-	rv = 0;
+	return 0;
-done:
+err:
-	mutex_exit(&sc->sc_lock);
+	mutex_exit(&sc->sc_cmd_mtx);
-	return (rv);
+	return -1;
+}
 int
 ipmi_sensor_type(int type, int ext_type, int entity)
+{
 	switch (ext_type << 8L | type) {
 	case IPMI_SENSOR_TYPE_TEMP:
 		return (ENVSYS_STEMP);
 	case IPMI_SENSOR_TYPE_VOLT:
 		return (ENVSYS_SVOLTS_DC);
 	case IPMI_SENSOR_TYPE_FAN:
 @@ -1665,29 +1685,26 @@ ipmi_intr(void *arg)
 	v = bmc_read(sc, _KCS_STATUS_REGISTER);
 	if (v & KCS_OBF)
 		++ipmi_nintr;
 	return (0);
+}
 /* Handle IPMI Timer - reread sensor values */
 void
 ipmi_refresh_sensors(struct ipmi_softc *sc)
+{
 	if (!ipmi_poll)
 		return;
 	if (SLIST_EMPTY(&ipmi_sensor_list))
 		return;
 	sc->current_sensor = SLIST_NEXT(sc->current_sensor, i_list);
 	if (sc->current_sensor == NULL)
 		sc->current_sensor = SLIST_FIRST(&ipmi_sensor_list);
 	if (read_sensor(sc, sc->current_sensor)) {
 		dbg_printf(1, "ipmi: error reading\n");
+	}
+}
 int
 @@ -1754,74 +1771,82 @@ ipmi_probe(struct ipmi_attach_args *ia)
 	return (1);
+}
 int
 ipmi_match(device_t parent, cfdata_t cf, void *aux)
+{
 	struct ipmi_softc sc;
 	struct ipmi_attach_args *ia = aux;
 	uint8_t		cmd[32];
 	int			len;
 	int			rv = 0;
 	memset(&sc, 0, sizeof(sc));
 	/* Map registers */
 	if (ipmi_map_regs(&sc, ia) != 0)
 		return 0;
 	sc.sc_if->probe(&sc);
 	mutex_init(&sc.sc_cmd_mtx, MUTEX_DEFAULT, IPL_SOFTCLOCK);
 	mutex_enter(&sc.sc_cmd_mtx);
 	/* Identify BMC device early to detect lying bios */
 	if (ipmi_sendcmd(&sc, BMC_SA, 0, APP_NETFN, APP_GET_DEVICE_ID,
 , NULL)) {
 		mutex_exit(&sc.sc_cmd_mtx);
 		dbg_printf(1, ": unable to send get device id "
 		    "command\n");
 		goto unmap;
+	}
 	if (ipmi_recvcmd(&sc, sizeof(cmd), &len, cmd)) {
 		mutex_exit(&sc.sc_cmd_mtx);
 		dbg_printf(1, ": unable to retrieve device id\n");
 		goto unmap;
+	}
 	mutex_exit(&sc.sc_cmd_mtx);
 	dbg_dump(1, "bmc data", len, cmd);
 	rv = 1; /* GETID worked, we got IPMI */
 unmap:
 	mutex_destroy(&sc.sc_cmd_mtx);
 	ipmi_unmap_regs(&sc);
 	return rv;
+}
 static void
 ipmi_thread(void *cookie)
+{
 	device_t		self = cookie;
 	struct ipmi_softc	*sc = device_private(self);
 	struct ipmi_attach_args *ia = &sc->sc_ia;
 	uint16_t		rec;
 	struct ipmi_sensor *ipmi_s;
 	int i;
 	int current_index_typ[ENVSYS_NSENSORS];
-	sc->sc_thread_running = 1;
+	sc->sc_thread_running = true;
 	/* lock around read_sensor so that no one messes with the bmc regs */
-	mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_NONE);
+	mutex_init(&sc->sc_cmd_mtx, MUTEX_DEFAULT, IPL_SOFTCLOCK);
 	cv_init(&sc->sc_cmd_sleep, "ipmicmd");
 	mutex_init(&sc->sc_poll_mtx, MUTEX_DEFAULT, IPL_SOFTCLOCK);
 	cv_init(&sc->sc_poll_cv, "ipmi_poll");
 	/* setup ticker */
 	sc->sc_retries = 0;
 	sc->sc_wakeup = 0;
 	sc->sc_max_retries = hz * 90; /* 90 seconds max */
 	callout_init(&sc->sc_callout, 0);
 	callout_setfunc(&sc->sc_callout, _bmc_io_wait, sc);
 	/* Map registers */
 	ipmi_map_regs(sc, ia);
 	/* Scan SDRs, add sensors to list */
 	for (rec = 0; rec != 0xFFFF;)
 		if (get_sdr(sc, rec, &rec))
 			break;
 	/* fill in sensor infos: */
 	/* get indexes for each unit, and number of units */
 	current_index_typ[0] = 0;
 	for (i = 1; i < ENVSYS_NSENSORS; i++) {
 @@ -1890,58 +1915,66 @@ ipmi_thread(void *cookie)
 	if (ia->iaa_if_irq != -1)
 		aprint_verbose_dev(self, " irq %d\n", ia->iaa_if_irq);
 	/* setup flag to exclude iic */
 	ipmi_enabled = 1;
 	/* Setup Watchdog timer */
 	sc->sc_wdog.smw_name = device_xname(sc->sc_dev);
 	sc->sc_wdog.smw_cookie = sc;
 	sc->sc_wdog.smw_setmode = ipmi_watchdog_setmode;
 	sc->sc_wdog.smw_tickle = ipmi_watchdog_tickle;
 	sysmon_wdog_register(&sc->sc_wdog);
 	mutex_enter(&sc->sc_poll_mtx);
 	while (sc->sc_thread_running) {
 		ipmi_refresh_sensors(sc);
-		tsleep(&sc->sc_thread_running, PWAIT, "ipmi_poll",
+		cv_timedwait(&sc->sc_poll_cv, &sc->sc_poll_mtx,
 		    SENSOR_REFRESH_RATE);
 		if (sc->sc_tickle_due) {
 			ipmi_dotickle(sc);
 			sc->sc_tickle_due = false;
+		}
+	}
 	mutex_exit(&sc->sc_poll_mtx);
 	kthread_exit(0);
+}
 void
 ipmi_attach(device_t parent, device_t self, void *aux)
+{
 	struct ipmi_softc	*sc = device_private(self);
 	sc->sc_ia = *(struct ipmi_attach_args *)aux;
 	sc->sc_dev = self;
 	aprint_normal("\n");
 	if (kthread_create(PRI_NONE, 0, NULL, ipmi_thread, self,
 	    &sc->sc_kthread, "ipmi") != 0) {
 		aprint_error("ipmi: unable to create thread, disabled\n");
+	}
+}
 static int
 ipmi_detach(device_t self, int flags)
+{
 	struct ipmi_sensor *i;
 	int rc;
 	struct ipmi_softc *sc = device_private(self);
-	sc->sc_thread_running = 0;
+	mutex_enter(&sc->sc_poll_mtx);
-	wakeup(&sc->sc_thread_running);
+	sc->sc_thread_running = false;
 	cv_signal(&sc->sc_poll_cv);
 	mutex_exit(&sc->sc_poll_mtx);
 	if ((rc = sysmon_wdog_unregister(&sc->sc_wdog)) != 0) {
 		if (rc == ERESTART)
 			rc = EINTR;
 		return rc;
+	}
 	/* cancel any pending countdown */
 	sc->sc_wdog.smw_mode &= ~WDOG_MODE_MASK;
 	sc->sc_wdog.smw_mode |= WDOG_MODE_DISARMED;
 	sc->sc_wdog.smw_period = WDOG_PERIOD_DEFAULT;
 	if ((rc = ipmi_watchdog_setmode(&sc->sc_wdog)) != 0)
 @@ -1957,86 +1990,97 @@ ipmi_detach(device_t self, int flags)
 	while ((i = SLIST_FIRST(&ipmi_sensor_list)) != NULL) {
 		SLIST_REMOVE_HEAD(&ipmi_sensor_list, i_list);
 		free(i, M_DEVBUF);
+	}
 	if (sc->sc_sensor != NULL) {
 		free(sc->sc_sensor, M_DEVBUF);
 		sc->sc_sensor = NULL;
+	}
 	ipmi_unmap_regs(sc);
-	callout_destroy(&sc->sc_callout);
+	cv_destroy(&sc->sc_poll_cv);
-	mutex_destroy(&sc->sc_lock);
+	mutex_destroy(&sc->sc_poll_mtx);
 	cv_destroy(&sc->sc_cmd_sleep);
 	mutex_destroy(&sc->sc_cmd_mtx);
 	return 0;
+}
 int
 ipmi_watchdog_setmode(struct sysmon_wdog *smwdog)
+{
 	struct ipmi_softc	*sc = smwdog->smw_cookie;
 	struct ipmi_get_watchdog gwdog;
 	struct ipmi_set_watchdog swdog;
-	int			s, rc, len;
+	int			rc, len;
 	if (smwdog->smw_period < 10)
 		return EINVAL;
 	if (smwdog->smw_period == WDOG_PERIOD_DEFAULT)
 		sc->sc_wdog.smw_period = 10;
 	else
 		sc->sc_wdog.smw_period = smwdog->smw_period;
-	s = splsoftclock();
+	mutex_enter(&sc->sc_cmd_mtx);
 	/* see if we can properly task to the watchdog */
 	rc = ipmi_sendcmd(sc, BMC_SA, BMC_LUN, APP_NETFN,
 	    APP_GET_WATCHDOG_TIMER, 0, NULL);
 	rc = ipmi_recvcmd(sc, sizeof(gwdog), &len, &gwdog);
 	mutex_exit(&sc->sc_cmd_mtx);
 	if (rc) {
 		printf("ipmi: APP_GET_WATCHDOG_TIMER returned 0x%x\n", rc);
 		splx(s);
 		return EIO;
+	}
 	memset(&swdog, 0, sizeof(swdog));
 	/* Period is 10ths/sec */
-	swdog.wdog_timeout = htole32(sc->sc_wdog.smw_period * 10);
+	swdog.wdog_timeout = htole16(sc->sc_wdog.smw_period * 10);
-	swdog.wdog_action = 0;
+	if ((smwdog->smw_mode & WDOG_MODE_MASK) == WDOG_MODE_DISARMED)
-	if ((smwdog->smw_mode & WDOG_MODE_MASK) == WDOG_MODE_DISARMED) {
+		swdog.wdog_action = IPMI_WDOG_ACT_DISABLED;
-		swdog.wdog_action |= IPMI_WDOG_ACT_DISABLED;
+	else
-	} else {
+		swdog.wdog_action = IPMI_WDOG_ACT_RESET;
 		swdog.wdog_action |= IPMI_WDOG_ACT_RESET;
 	swdog.wdog_use = IPMI_WDOG_USE_USE_OS;
-	rc = ipmi_sendcmd(sc, BMC_SA, BMC_LUN, APP_NETFN,
+	mutex_enter(&sc->sc_cmd_mtx);
-	    APP_SET_WATCHDOG_TIMER, sizeof(swdog), &swdog);
+	if ((rc = ipmi_sendcmd(sc, BMC_SA, BMC_LUN, APP_NETFN,
-	rc = ipmi_recvcmd(sc, 0, &len, NULL);
+	    APP_SET_WATCHDOG_TIMER, sizeof(swdog), &swdog)) == 0)
-	splx(s);
+		rc = ipmi_recvcmd(sc, 0, &len, NULL);
 	mutex_exit(&sc->sc_cmd_mtx);
 	if (rc) {
 		printf("ipmi: APP_SET_WATCHDOG_TIMER returned 0x%x\n", rc);
 		return EIO;
+	}
 	return (0);
+}
 int
 ipmi_watchdog_tickle(struct sysmon_wdog *smwdog)
+{
 	struct ipmi_softc	*sc = smwdog->smw_cookie;
 	int			s, rc, len;
-	s = splsoftclock();
+	mutex_enter(&sc->sc_poll_mtx);
 	sc->sc_tickle_due = true;
 	cv_signal(&sc->sc_poll_cv);
 	mutex_exit(&sc->sc_poll_mtx);
 	return 0;
+}
 void
 ipmi_dotickle(struct ipmi_softc *sc)
+{
 	int			rc, len;
 	mutex_enter(&sc->sc_cmd_mtx);
 	/* tickle the watchdog */
-	rc = ipmi_sendcmd(sc, BMC_SA, BMC_LUN, APP_NETFN,
+	if ((rc = ipmi_sendcmd(sc, BMC_SA, BMC_LUN, APP_NETFN,
-	    APP_RESET_WATCHDOG, 0, NULL);
+	    APP_RESET_WATCHDOG, 0, NULL)) == 0)
-	rc = ipmi_recvcmd(sc, 0, &len, NULL);
+		rc = ipmi_recvcmd(sc, 0, &len, NULL);
-	splx(s);
+	mutex_exit(&sc->sc_cmd_mtx);
-	if (rc) {
+	if (rc != 0) {
-		printf("ipmi: watchdog tickle returned 0x%x\n", rc);
+		printf("%s: watchdog tickle returned 0x%x\n",
-		return EIO;
+		    device_xname(sc->sc_dev), rc);
+	}
 	return (0);
+}

 @@ -1,14 +1,14 @@
-/* $NetBSD: ipmivar.h,v 1.9 2008/11/03 12:25:53 cegger Exp $ */
+/* $NetBSD: ipmivar.h,v 1.10 2009/07/20 19:11:30 dyoung Exp $ */
 /*
  * Copyright (c) 2005 Jordan Hargrave
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
 @@ -18,50 +18,44 @@
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
+ *
  */
 #include <sys/mutex.h>
 #include <sys/condvar.h>
 #include <dev/sysmon/sysmonvar.h>
 #ifndef _IPMIVAR_H_
 #define _IPMIVAR_H_
 #define IPMI_IF_KCS		1
 #define IPMI_IF_SMIC		2
 #define IPMI_IF_BT		3
 #define IPMI_IF_KCS_NREGS	2
 #define IPMI_IF_SMIC_NREGS	3
 #define IPMI_IF_BT_NREGS	3
 struct ipmi_thread;
 struct ipmi_softc;
 struct ipmi_bmc_args{
 	int			offset;
 	uint8_t		mask;
 	uint8_t		value;
 	volatile uint8_t	*v;
 };
 struct ipmi_attach_args {
 	bus_space_tag_t	iaa_iot;
 	bus_space_tag_t	iaa_memt;
 	int		iaa_if_type;
 	int		iaa_if_rev;
 	int		iaa_if_iotype;
 	int		iaa_if_iobase;
 	int		iaa_if_iospacing;
 	int		iaa_if_irq;
 	int		iaa_if_irqlvl;
 };
 @@ -82,69 +76,85 @@ struct ipmi_softc {
 	struct ipmi_if		*sc_if;		/* Interface layer */
 	int			sc_if_iospacing; /* Spacing of I/O ports */
 	int			sc_if_rev;	/* IPMI Revision */
 	struct ipmi_attach_args	sc_ia;
 	void			*sc_ih;		/* Interrupt/IO handles */
 	bus_space_tag_t		sc_iot;
 	bus_space_handle_t	sc_ioh;
 	int			sc_btseq;
 	struct lwp		*sc_kthread;
 	struct callout		sc_callout;
 	int			sc_max_retries;
 	int			sc_retries;
 	int			sc_wakeup;
-	kmutex_t		sc_lock;
+	kmutex_t		sc_poll_mtx;
 	kcondvar_t		sc_poll_cv;
 	kmutex_t		sc_cmd_mtx;
 	kcondvar_t		sc_cmd_sleep;
 	struct ipmi_bmc_args	*sc_iowait_args;
 	struct ipmi_sensor	*current_sensor;
-	volatile int		sc_thread_running;
+	volatile bool		sc_thread_running;
 	volatile bool		sc_tickle_due;
 	struct sysmon_wdog	sc_wdog;
 	struct sysmon_envsys	*sc_envsys;
 	envsys_data_t		*sc_sensor;
 	int 		sc_nsensors; /* total number of sensors */
 	int		sc_nsensors_typ[ENVSYS_NSENSORS]; /* number per type */
 	char		sc_buf[64];
 	bool		sc_buf_rsvd;
 };
 struct ipmi_thread {
 	struct ipmi_softc   *sc;
 	volatile int	    running;
 };
-#define IPMI_WDOG_USE_NLOG		0x80
+#define IPMI_WDOG_USE_NOLOG		__BIT(7)
-#define IPMI_WDOG_USE_NSTOP		0x40
+#define IPMI_WDOG_USE_NOSTOP		__BIT(6)
-#define IPMI_WDOG_USE_USE_MASK		0x07
+#define IPMI_WDOG_USE_RSVD1		__BITS(5, 3)
-#define IPMI_WDOG_USE_USE_FRB2		0x01
+#define IPMI_WDOG_USE_USE_MASK		__BITS(2, 0)
-#define IPMI_WDOG_USE_USE_POST		0x02
+#define IPMI_WDOG_USE_USE_RSVD		__SHIFTIN(0, IPMI_WDOG_USE_USE_MASK);
-#define IPMI_WDOG_USE_USE_OSLOAD	0x03
+#define IPMI_WDOG_USE_USE_FRB2		__SHIFTIN(1, IPMI_WDOG_USE_USE_MASK);
-#define IPMI_WDOG_USE_USE_OS		0x04
+#define IPMI_WDOG_USE_USE_POST		__SHIFTIN(2, IPMI_WDOG_USE_USE_MASK);
-#define IPMI_WDOG_USE_USE_EOM		0x05
+#define IPMI_WDOG_USE_USE_OSLOAD	__SHIFTIN(3, IPMI_WDOG_USE_USE_MASK);
 #define IPMI_WDOG_USE_USE_OS		__SHIFTIN(4, IPMI_WDOG_USE_USE_MASK);
-#define IPMI_WDOG_ACT_MASK		0x07
+#define IPMI_WDOG_USE_USE_OEM		__SHIFTIN(5, IPMI_WDOG_USE_USE_MASK);
 #define IPMI_WDOG_ACT_DISABLED		0x00
-#define IPMI_WDOG_ACT_RESET		0x01
+#define IPMI_WDOG_ACT_PRE_RSVD1		__BIT(7)
-#define IPMI_WDOG_ACT_PWROFF		0x02
+#define IPMI_WDOG_ACT_PRE_MASK		__BITS(6, 4)
-#define IPMI_WDOG_ACT_PWRCYCLE		0x03
+#define IPMI_WDOG_ACT_PRE_DISABLED	__SHIFTIN(0, IPMI_WDOG_ACT_MASK)
 #define IPMI_WDOG_ACT_PRE_SMI		__SHIFTIN(1, IPMI_WDOG_ACT_MASK)
-#define IPMI_WDOG_ACT_PRE_MASK		0x70
+#define IPMI_WDOG_ACT_PRE_NMI		__SHIFTIN(2, IPMI_WDOG_ACT_MASK)
-#define IPMI_WDOG_ACT_PRE_DISABLED	0x00
+#define IPMI_WDOG_ACT_PRE_INTERRUPT	__SHIFTIN(3, IPMI_WDOG_ACT_MASK)
-#define IPMI_WDOG_ACT_PRE_SMI		0x10
+#define IPMI_WDOG_ACT_PRE_RSVD0		__BIT(3)
-#define IPMI_WDOG_ACT_PRE_NMI		0x20
+#define IPMI_WDOG_ACT_MASK		__BITS(2, 0)
-#define IPMI_WDOG_ACT_PRE_INTERRUPT	0x30
+#define IPMI_WDOG_ACT_DISABLED		__SHIFTIN(0, IPMI_WDOG_ACT_MASK)
 #define IPMI_WDOG_ACT_RESET		__SHIFTIN(1, IPMI_WDOG_ACT_MASK)
 #define IPMI_WDOG_ACT_PWROFF		__SHIFTIN(2, IPMI_WDOG_ACT_MASK)
 #define IPMI_WDOG_ACT_PWRCYCLE		__SHIFTIN(3, IPMI_WDOG_ACT_MASK)
 #define IPMI_WDOG_FLAGS_RSVD1		__BITS(7, 6)
 #define IPMI_WDOG_FLAGS_OEM		__BIT(5)
 #define IPMI_WDOG_FLAGS_OS		__BIT(4)
 #define IPMI_WDOG_FLAGS_OSLOAD		__BIT(3)
 #define IPMI_WDOG_FLAGS_POST		__BIT(2)
 #define IPMI_WDOG_FLAGS_FRB2		__BIT(1)
 #define IPMI_WDOG_FLAGS_RSVD0		__BIT(0)
 struct ipmi_set_watchdog {
 	uint8_t		wdog_use;
 	uint8_t		wdog_action;
 	uint8_t		wdog_pretimeout;
 	uint8_t		wdog_flags;
 	uint16_t		wdog_timeout;
 } __packed;
 struct ipmi_get_watchdog {
 	uint8_t		wdog_use;
 	uint8_t		wdog_action;
 	uint8_t		wdog_pretimeout;