Home | History | Annotate | Line # | Download | only in x86
ipmi.c revision 1.57
      1 /*	$NetBSD$ */
      2 
      3 /*
      4  * Copyright (c) 2006 Manuel Bouyer.
      5  *
      6  * Redistribution and use in source and binary forms, with or without
      7  * modification, are permitted provided that the following conditions
      8  * are met:
      9  * 1. Redistributions of source code must retain the above copyright
     10  *    notice, this list of conditions and the following disclaimer.
     11  * 2. Redistributions in binary form must reproduce the above copyright
     12  *    notice, this list of conditions and the following disclaimer in the
     13  *    documentation and/or other materials provided with the distribution.
     14  *
     15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     25  *
     26  */
     27 
     28 /*
     29  * Copyright (c) 2005 Jordan Hargrave
     30  * All rights reserved.
     31  *
     32  * Redistribution and use in source and binary forms, with or without
     33  * modification, are permitted provided that the following conditions
     34  * are met:
     35  * 1. Redistributions of source code must retain the above copyright
     36  *    notice, this list of conditions and the following disclaimer.
     37  * 2. Redistributions in binary form must reproduce the above copyright
     38  *    notice, this list of conditions and the following disclaimer in the
     39  *    documentation and/or other materials provided with the distribution.
     40  *
     41  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
     42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     44  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
     45  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     51  * SUCH DAMAGE.
     52  */
     53 
     54 #include <sys/cdefs.h>
     55 __KERNEL_RCSID(0, "$NetBSD$");
     56 
     57 #include <sys/types.h>
     58 #include <sys/param.h>
     59 #include <sys/systm.h>
     60 #include <sys/kernel.h>
     61 #include <sys/device.h>
     62 #include <sys/extent.h>
     63 #include <sys/callout.h>
     64 #include <sys/envsys.h>
     65 #include <sys/malloc.h>
     66 #include <sys/kthread.h>
     67 #include <sys/bus.h>
     68 #include <sys/intr.h>
     69 #include <sys/rnd.h>
     70 
     71 #include <x86/smbiosvar.h>
     72 
     73 #include <dev/isa/isareg.h>
     74 #include <dev/isa/isavar.h>
     75 
     76 #include <x86/ipmivar.h>
     77 
     78 #include <uvm/uvm_extern.h>
     79 
     80 struct ipmi_sensor {
     81 	uint8_t	*i_sdr;
     82 	int		i_num;
     83 	int		i_stype;
     84 	int		i_etype;
     85 	char		i_envdesc[64];
     86 	int 		i_envtype; /* envsys compatible type */
     87 	int		i_envnum; /* envsys index */
     88 	sysmon_envsys_lim_t i_limits, i_deflims;
     89 	uint32_t	i_props, i_defprops;
     90 	SLIST_ENTRY(ipmi_sensor) i_list;
     91 	int32_t		i_prevval;	/* feed rnd source on change */
     92 	krndsource_t	i_rnd;
     93 };
     94 
     95 int	ipmi_nintr;
     96 int	ipmi_dbg = 0;
     97 int	ipmi_enabled = 0;
     98 
     99 #define SENSOR_REFRESH_RATE (hz / 2)
    100 
    101 #define SMBIOS_TYPE_IPMI	0x26
    102 
    103 /*
    104  * Format of SMBIOS IPMI Flags
    105  *
    106  * bit0: interrupt trigger mode (1=level, 0=edge)
    107  * bit1: interrupt polarity (1=active high, 0=active low)
    108  * bit2: reserved
    109  * bit3: address LSB (1=odd,0=even)
    110  * bit4: interrupt (1=specified, 0=not specified)
    111  * bit5: reserved
    112  * bit6/7: register spacing (1,4,2,err)
    113  */
    114 #define SMIPMI_FLAG_IRQLVL		(1L << 0)
    115 #define SMIPMI_FLAG_IRQEN		(1L << 3)
    116 #define SMIPMI_FLAG_ODDOFFSET		(1L << 4)
    117 #define SMIPMI_FLAG_IFSPACING(x)	(((x)>>6)&0x3)
    118 #define	 IPMI_IOSPACING_BYTE		 0
    119 #define	 IPMI_IOSPACING_WORD		 2
    120 #define	 IPMI_IOSPACING_DWORD		 1
    121 
    122 #define IPMI_BTMSG_LEN			0
    123 #define IPMI_BTMSG_NFLN			1
    124 #define IPMI_BTMSG_SEQ			2
    125 #define IPMI_BTMSG_CMD			3
    126 #define IPMI_BTMSG_CCODE		4
    127 #define IPMI_BTMSG_DATASND		4
    128 #define IPMI_BTMSG_DATARCV		5
    129 
    130 #define IPMI_MSG_NFLN			0
    131 #define IPMI_MSG_CMD			1
    132 #define IPMI_MSG_CCODE			2
    133 #define IPMI_MSG_DATASND		2
    134 #define IPMI_MSG_DATARCV		3
    135 
    136 #define IPMI_SENSOR_TYPE_TEMP		0x0101
    137 #define IPMI_SENSOR_TYPE_VOLT		0x0102
    138 #define IPMI_SENSOR_TYPE_FAN		0x0104
    139 #define IPMI_SENSOR_TYPE_INTRUSION	0x6F05
    140 #define IPMI_SENSOR_TYPE_PWRSUPPLY	0x6F08
    141 
    142 #define IPMI_NAME_UNICODE		0x00
    143 #define IPMI_NAME_BCDPLUS		0x01
    144 #define IPMI_NAME_ASCII6BIT		0x02
    145 #define IPMI_NAME_ASCII8BIT		0x03
    146 
    147 #define IPMI_ENTITY_PWRSUPPLY		0x0A
    148 
    149 #define IPMI_SENSOR_SCANNING_ENABLED	(1L << 6)
    150 #define IPMI_SENSOR_UNAVAILABLE		(1L << 5)
    151 #define IPMI_INVALID_SENSOR_P(x) \
    152 	(((x) & (IPMI_SENSOR_SCANNING_ENABLED|IPMI_SENSOR_UNAVAILABLE)) \
    153 	!= IPMI_SENSOR_SCANNING_ENABLED)
    154 
    155 #define IPMI_SDR_TYPEFULL		1
    156 #define IPMI_SDR_TYPECOMPACT		2
    157 
    158 #define byteof(x) ((x) >> 3)
    159 #define bitof(x)  (1L << ((x) & 0x7))
    160 #define TB(b,m)	  (data[2+byteof(b)] & bitof(b))
    161 
    162 #define dbg_printf(lvl, fmt...) \
    163 	if (ipmi_dbg >= lvl) \
    164 		printf(fmt);
    165 #define dbg_dump(lvl, msg, len, buf) \
    166 	if (len && ipmi_dbg >= lvl) \
    167 		dumpb(msg, len, (const uint8_t *)(buf));
    168 
    169 long signextend(unsigned long, int);
    170 
    171 SLIST_HEAD(ipmi_sensors_head, ipmi_sensor);
    172 struct ipmi_sensors_head ipmi_sensor_list =
    173     SLIST_HEAD_INITIALIZER(&ipmi_sensor_list);
    174 
    175 void	dumpb(const char *, int, const uint8_t *);
    176 
    177 int	read_sensor(struct ipmi_softc *, struct ipmi_sensor *);
    178 int	add_sdr_sensor(struct ipmi_softc *, uint8_t *);
    179 int	get_sdr_partial(struct ipmi_softc *, uint16_t, uint16_t,
    180 	    uint8_t, uint8_t, void *, uint16_t *);
    181 int	get_sdr(struct ipmi_softc *, uint16_t, uint16_t *);
    182 
    183 char	*ipmi_buf_acquire(struct ipmi_softc *, size_t);
    184 void	ipmi_buf_release(struct ipmi_softc *, char *);
    185 int	ipmi_sendcmd(struct ipmi_softc *, int, int, int, int, int, const void*);
    186 int	ipmi_recvcmd(struct ipmi_softc *, int, int *, void *);
    187 void	ipmi_delay(struct ipmi_softc *, int);
    188 
    189 int	ipmi_watchdog_setmode(struct sysmon_wdog *);
    190 int	ipmi_watchdog_tickle(struct sysmon_wdog *);
    191 void	ipmi_dotickle(struct ipmi_softc *);
    192 
    193 int	ipmi_intr(void *);
    194 int	ipmi_match(device_t, cfdata_t, void *);
    195 void	ipmi_attach(device_t, device_t, void *);
    196 static int ipmi_detach(device_t, int);
    197 
    198 long	ipmi_convert(uint8_t, struct sdrtype1 *, long);
    199 void	ipmi_sensor_name(char *, int, uint8_t, uint8_t *);
    200 
    201 /* BMC Helper Functions */
    202 uint8_t bmc_read(struct ipmi_softc *, int);
    203 void	bmc_write(struct ipmi_softc *, int, uint8_t);
    204 int	bmc_io_wait(struct ipmi_softc *, int, uint8_t, uint8_t, const char *);
    205 int	bmc_io_wait_spin(struct ipmi_softc *, int, uint8_t, uint8_t);
    206 int	bmc_io_wait_sleep(struct ipmi_softc *, int, uint8_t, uint8_t);
    207 
    208 void	*bt_buildmsg(struct ipmi_softc *, int, int, int, const void *, int *);
    209 void	*cmn_buildmsg(struct ipmi_softc *, int, int, int, const void *, int *);
    210 
    211 int	getbits(uint8_t *, int, int);
    212 int	ipmi_sensor_type(int, int, int);
    213 
    214 void	ipmi_smbios_probe(struct smbios_ipmi *, struct ipmi_attach_args *);
    215 void	ipmi_refresh_sensors(struct ipmi_softc *);
    216 int	ipmi_map_regs(struct ipmi_softc *, struct ipmi_attach_args *);
    217 void	ipmi_unmap_regs(struct ipmi_softc *);
    218 
    219 void	*scan_sig(long, long, int, int, const void *);
    220 
    221 int32_t	ipmi_convert_sensor(uint8_t *, struct ipmi_sensor *);
    222 void	ipmi_set_limits(struct sysmon_envsys *, envsys_data_t *,
    223 			sysmon_envsys_lim_t *, uint32_t *);
    224 void	ipmi_get_limits(struct sysmon_envsys *, envsys_data_t *,
    225 			sysmon_envsys_lim_t *, uint32_t *);
    226 void	ipmi_get_sensor_limits(struct ipmi_softc *, struct ipmi_sensor *,
    227 			       sysmon_envsys_lim_t *, uint32_t *);
    228 int	ipmi_sensor_status(struct ipmi_softc *, struct ipmi_sensor *,
    229 			   envsys_data_t *, uint8_t *);
    230 
    231 int	 add_child_sensors(struct ipmi_softc *, uint8_t *, int, int, int,
    232     int, int, int, const char *);
    233 
    234 bool	ipmi_suspend(device_t, const pmf_qual_t *);
    235 
    236 struct ipmi_if kcs_if = {
    237 	"KCS",
    238 	IPMI_IF_KCS_NREGS,
    239 	cmn_buildmsg,
    240 	kcs_sendmsg,
    241 	kcs_recvmsg,
    242 	kcs_reset,
    243 	kcs_probe,
    244 };
    245 
    246 struct ipmi_if smic_if = {
    247 	"SMIC",
    248 	IPMI_IF_SMIC_NREGS,
    249 	cmn_buildmsg,
    250 	smic_sendmsg,
    251 	smic_recvmsg,
    252 	smic_reset,
    253 	smic_probe,
    254 };
    255 
    256 struct ipmi_if bt_if = {
    257 	"BT",
    258 	IPMI_IF_BT_NREGS,
    259 	bt_buildmsg,
    260 	bt_sendmsg,
    261 	bt_recvmsg,
    262 	bt_reset,
    263 	bt_probe,
    264 };
    265 
    266 struct ipmi_if *ipmi_get_if(int);
    267 
    268 struct ipmi_if *
    269 ipmi_get_if(int iftype)
    270 {
    271 	switch (iftype) {
    272 	case IPMI_IF_KCS:
    273 		return (&kcs_if);
    274 	case IPMI_IF_SMIC:
    275 		return (&smic_if);
    276 	case IPMI_IF_BT:
    277 		return (&bt_if);
    278 	}
    279 
    280 	return (NULL);
    281 }
    282 
    283 /*
    284  * BMC Helper Functions
    285  */
    286 uint8_t
    287 bmc_read(struct ipmi_softc *sc, int offset)
    288 {
    289 	return (bus_space_read_1(sc->sc_iot, sc->sc_ioh,
    290 	    offset * sc->sc_if_iospacing));
    291 }
    292 
    293 void
    294 bmc_write(struct ipmi_softc *sc, int offset, uint8_t val)
    295 {
    296 	bus_space_write_1(sc->sc_iot, sc->sc_ioh,
    297 	    offset * sc->sc_if_iospacing, val);
    298 }
    299 
    300 int
    301 bmc_io_wait_sleep(struct ipmi_softc *sc, int offset, uint8_t mask,
    302     uint8_t value)
    303 {
    304 	int retries;
    305 	uint8_t v;
    306 
    307 	KASSERT(mutex_owned(&sc->sc_cmd_mtx));
    308 
    309 	for (retries = 0; retries < sc->sc_max_retries; retries++) {
    310 		v = bmc_read(sc, offset);
    311 		if ((v & mask) == value)
    312 			return v;
    313 		mutex_enter(&sc->sc_sleep_mtx);
    314 		cv_timedwait(&sc->sc_cmd_sleep, &sc->sc_sleep_mtx, 1);
    315 		mutex_exit(&sc->sc_sleep_mtx);
    316 	}
    317 	return -1;
    318 }
    319 
    320 int
    321 bmc_io_wait(struct ipmi_softc *sc, int offset, uint8_t mask, uint8_t value,
    322     const char *lbl)
    323 {
    324 	int v;
    325 
    326 	v = bmc_io_wait_spin(sc, offset, mask, value);
    327 	if (cold || v != -1)
    328 		return v;
    329 
    330 	return bmc_io_wait_sleep(sc, offset, mask, value);
    331 }
    332 
    333 int
    334 bmc_io_wait_spin(struct ipmi_softc *sc, int offset, uint8_t mask,
    335     uint8_t value)
    336 {
    337 	uint8_t	v;
    338 	int			count = cold ? 15000 : 500;
    339 	/* ~us */
    340 
    341 	while (count--) {
    342 		v = bmc_read(sc, offset);
    343 		if ((v & mask) == value)
    344 			return v;
    345 
    346 		delay(1);
    347 	}
    348 
    349 	return (-1);
    350 
    351 }
    352 
    353 #define NETFN_LUN(nf,ln) (((nf) << 2) | ((ln) & 0x3))
    354 
    355 /*
    356  * BT interface
    357  */
    358 #define _BT_CTRL_REG			0
    359 #define	  BT_CLR_WR_PTR			(1L << 0)
    360 #define	  BT_CLR_RD_PTR			(1L << 1)
    361 #define	  BT_HOST2BMC_ATN		(1L << 2)
    362 #define	  BT_BMC2HOST_ATN		(1L << 3)
    363 #define	  BT_EVT_ATN			(1L << 4)
    364 #define	  BT_HOST_BUSY			(1L << 6)
    365 #define	  BT_BMC_BUSY			(1L << 7)
    366 
    367 #define	  BT_READY	(BT_HOST_BUSY|BT_HOST2BMC_ATN|BT_BMC2HOST_ATN)
    368 
    369 #define _BT_DATAIN_REG			1
    370 #define _BT_DATAOUT_REG			1
    371 
    372 #define _BT_INTMASK_REG			2
    373 #define	 BT_IM_HIRQ_PEND		(1L << 1)
    374 #define	 BT_IM_SCI_EN			(1L << 2)
    375 #define	 BT_IM_SMI_EN			(1L << 3)
    376 #define	 BT_IM_NMI2SMI			(1L << 4)
    377 
    378 int bt_read(struct ipmi_softc *, int);
    379 int bt_write(struct ipmi_softc *, int, uint8_t);
    380 
    381 int
    382 bt_read(struct ipmi_softc *sc, int reg)
    383 {
    384 	return bmc_read(sc, reg);
    385 }
    386 
    387 int
    388 bt_write(struct ipmi_softc *sc, int reg, uint8_t data)
    389 {
    390 	if (bmc_io_wait(sc, _BT_CTRL_REG, BT_BMC_BUSY, 0, "bt_write") < 0)
    391 		return (-1);
    392 
    393 	bmc_write(sc, reg, data);
    394 	return (0);
    395 }
    396 
    397 int
    398 bt_sendmsg(struct ipmi_softc *sc, int len, const uint8_t *data)
    399 {
    400 	int i;
    401 
    402 	bt_write(sc, _BT_CTRL_REG, BT_CLR_WR_PTR);
    403 	for (i = 0; i < len; i++)
    404 		bt_write(sc, _BT_DATAOUT_REG, data[i]);
    405 
    406 	bt_write(sc, _BT_CTRL_REG, BT_HOST2BMC_ATN);
    407 	if (bmc_io_wait(sc, _BT_CTRL_REG, BT_HOST2BMC_ATN | BT_BMC_BUSY, 0,
    408 	    "bt_sendwait") < 0)
    409 		return (-1);
    410 
    411 	return (0);
    412 }
    413 
    414 int
    415 bt_recvmsg(struct ipmi_softc *sc, int maxlen, int *rxlen, uint8_t *data)
    416 {
    417 	uint8_t len, v, i;
    418 
    419 	if (bmc_io_wait(sc, _BT_CTRL_REG, BT_BMC2HOST_ATN, BT_BMC2HOST_ATN,
    420 	    "bt_recvwait") < 0)
    421 		return (-1);
    422 
    423 	bt_write(sc, _BT_CTRL_REG, BT_HOST_BUSY);
    424 	bt_write(sc, _BT_CTRL_REG, BT_BMC2HOST_ATN);
    425 	bt_write(sc, _BT_CTRL_REG, BT_CLR_RD_PTR);
    426 	len = bt_read(sc, _BT_DATAIN_REG);
    427 	for (i = IPMI_BTMSG_NFLN; i <= len; i++) {
    428 		v = bt_read(sc, _BT_DATAIN_REG);
    429 		if (i != IPMI_BTMSG_SEQ)
    430 			*(data++) = v;
    431 	}
    432 	bt_write(sc, _BT_CTRL_REG, BT_HOST_BUSY);
    433 	*rxlen = len - 1;
    434 
    435 	return (0);
    436 }
    437 
    438 int
    439 bt_reset(struct ipmi_softc *sc)
    440 {
    441 	return (-1);
    442 }
    443 
    444 int
    445 bt_probe(struct ipmi_softc *sc)
    446 {
    447 	uint8_t rv;
    448 
    449 	rv = bmc_read(sc, _BT_CTRL_REG);
    450 	rv &= BT_HOST_BUSY;
    451 	rv |= BT_CLR_WR_PTR|BT_CLR_RD_PTR|BT_BMC2HOST_ATN|BT_HOST2BMC_ATN;
    452 	bmc_write(sc, _BT_CTRL_REG, rv);
    453 
    454 	rv = bmc_read(sc, _BT_INTMASK_REG);
    455 	rv &= BT_IM_SCI_EN|BT_IM_SMI_EN|BT_IM_NMI2SMI;
    456 	rv |= BT_IM_HIRQ_PEND;
    457 	bmc_write(sc, _BT_INTMASK_REG, rv);
    458 
    459 #if 0
    460 	printf("bt_probe: %2x\n", v);
    461 	printf(" WR    : %2x\n", v & BT_CLR_WR_PTR);
    462 	printf(" RD    : %2x\n", v & BT_CLR_RD_PTR);
    463 	printf(" H2B   : %2x\n", v & BT_HOST2BMC_ATN);
    464 	printf(" B2H   : %2x\n", v & BT_BMC2HOST_ATN);
    465 	printf(" EVT   : %2x\n", v & BT_EVT_ATN);
    466 	printf(" HBSY  : %2x\n", v & BT_HOST_BUSY);
    467 	printf(" BBSY  : %2x\n", v & BT_BMC_BUSY);
    468 #endif
    469 	return (0);
    470 }
    471 
    472 /*
    473  * SMIC interface
    474  */
    475 #define _SMIC_DATAIN_REG		0
    476 #define _SMIC_DATAOUT_REG		0
    477 
    478 #define _SMIC_CTRL_REG			1
    479 #define	  SMS_CC_GET_STATUS		 0x40
    480 #define	  SMS_CC_START_TRANSFER		 0x41
    481 #define	  SMS_CC_NEXT_TRANSFER		 0x42
    482 #define	  SMS_CC_END_TRANSFER		 0x43
    483 #define	  SMS_CC_START_RECEIVE		 0x44
    484 #define	  SMS_CC_NEXT_RECEIVE		 0x45
    485 #define	  SMS_CC_END_RECEIVE		 0x46
    486 #define	  SMS_CC_TRANSFER_ABORT		 0x47
    487 
    488 #define	  SMS_SC_READY			 0xc0
    489 #define	  SMS_SC_WRITE_START		 0xc1
    490 #define	  SMS_SC_WRITE_NEXT		 0xc2
    491 #define	  SMS_SC_WRITE_END		 0xc3
    492 #define	  SMS_SC_READ_START		 0xc4
    493 #define	  SMS_SC_READ_NEXT		 0xc5
    494 #define	  SMS_SC_READ_END		 0xc6
    495 
    496 #define _SMIC_FLAG_REG			2
    497 #define	  SMIC_BUSY			(1L << 0)
    498 #define	  SMIC_SMS_ATN			(1L << 2)
    499 #define	  SMIC_EVT_ATN			(1L << 3)
    500 #define	  SMIC_SMI			(1L << 4)
    501 #define	  SMIC_TX_DATA_RDY		(1L << 6)
    502 #define	  SMIC_RX_DATA_RDY		(1L << 7)
    503 
    504 int	smic_wait(struct ipmi_softc *, uint8_t, uint8_t, const char *);
    505 int	smic_write_cmd_data(struct ipmi_softc *, uint8_t, const uint8_t *);
    506 int	smic_read_data(struct ipmi_softc *, uint8_t *);
    507 
    508 int
    509 smic_wait(struct ipmi_softc *sc, uint8_t mask, uint8_t val, const char *lbl)
    510 {
    511 	int v;
    512 
    513 	/* Wait for expected flag bits */
    514 	v = bmc_io_wait(sc, _SMIC_FLAG_REG, mask, val, "smicwait");
    515 	if (v < 0)
    516 		return (-1);
    517 
    518 	/* Return current status */
    519 	v = bmc_read(sc, _SMIC_CTRL_REG);
    520 	dbg_printf(99, "smic_wait(%s) = %.2x\n", lbl, v);
    521 	return (v);
    522 }
    523 
    524 int
    525 smic_write_cmd_data(struct ipmi_softc *sc, uint8_t cmd, const uint8_t *data)
    526 {
    527 	int	sts, v;
    528 
    529 	dbg_printf(50, "smic_wcd: %.2x %.2x\n", cmd, data ? *data : -1);
    530 	sts = smic_wait(sc, SMIC_TX_DATA_RDY | SMIC_BUSY, SMIC_TX_DATA_RDY,
    531 	    "smic_write_cmd_data ready");
    532 	if (sts < 0)
    533 		return (sts);
    534 
    535 	bmc_write(sc, _SMIC_CTRL_REG, cmd);
    536 	if (data)
    537 		bmc_write(sc, _SMIC_DATAOUT_REG, *data);
    538 
    539 	/* Toggle BUSY bit, then wait for busy bit to clear */
    540 	v = bmc_read(sc, _SMIC_FLAG_REG);
    541 	bmc_write(sc, _SMIC_FLAG_REG, v | SMIC_BUSY);
    542 
    543 	return (smic_wait(sc, SMIC_BUSY, 0, "smic_write_cmd_data busy"));
    544 }
    545 
    546 int
    547 smic_read_data(struct ipmi_softc *sc, uint8_t *data)
    548 {
    549 	int sts;
    550 
    551 	sts = smic_wait(sc, SMIC_RX_DATA_RDY | SMIC_BUSY, SMIC_RX_DATA_RDY,
    552 	    "smic_read_data");
    553 	if (sts >= 0) {
    554 		*data = bmc_read(sc, _SMIC_DATAIN_REG);
    555 		dbg_printf(50, "smic_readdata: %.2x\n", *data);
    556 	}
    557 	return (sts);
    558 }
    559 
    560 #define ErrStat(a,b) if (a) printf(b);
    561 
    562 int
    563 smic_sendmsg(struct ipmi_softc *sc, int len, const uint8_t *data)
    564 {
    565 	int sts, idx;
    566 
    567 	sts = smic_write_cmd_data(sc, SMS_CC_START_TRANSFER, &data[0]);
    568 	ErrStat(sts != SMS_SC_WRITE_START, "smic_sendmsg: wstart");
    569 	for (idx = 1; idx < len - 1; idx++) {
    570 		sts = smic_write_cmd_data(sc, SMS_CC_NEXT_TRANSFER,
    571 		    &data[idx]);
    572 		ErrStat(sts != SMS_SC_WRITE_NEXT, "smic_sendmsg: write");
    573 	}
    574 	sts = smic_write_cmd_data(sc, SMS_CC_END_TRANSFER, &data[idx]);
    575 	if (sts != SMS_SC_WRITE_END) {
    576 		dbg_printf(50, "smic_sendmsg %d/%d = %.2x\n", idx, len, sts);
    577 		return (-1);
    578 	}
    579 
    580 	return (0);
    581 }
    582 
    583 int
    584 smic_recvmsg(struct ipmi_softc *sc, int maxlen, int *len, uint8_t *data)
    585 {
    586 	int sts, idx;
    587 
    588 	*len = 0;
    589 	sts = smic_wait(sc, SMIC_RX_DATA_RDY, SMIC_RX_DATA_RDY, "smic_recvmsg");
    590 	if (sts < 0)
    591 		return (-1);
    592 
    593 	sts = smic_write_cmd_data(sc, SMS_CC_START_RECEIVE, NULL);
    594 	ErrStat(sts != SMS_SC_READ_START, "smic_recvmsg: rstart");
    595 	for (idx = 0;; ) {
    596 		sts = smic_read_data(sc, &data[idx++]);
    597 		if (sts != SMS_SC_READ_START && sts != SMS_SC_READ_NEXT)
    598 			break;
    599 		smic_write_cmd_data(sc, SMS_CC_NEXT_RECEIVE, NULL);
    600 	}
    601 	ErrStat(sts != SMS_SC_READ_END, "smic_recvmsg: rend");
    602 
    603 	*len = idx;
    604 
    605 	sts = smic_write_cmd_data(sc, SMS_CC_END_RECEIVE, NULL);
    606 	if (sts != SMS_SC_READY) {
    607 		dbg_printf(50, "smic_recvmsg %d/%d = %.2x\n", idx, maxlen, sts);
    608 		return (-1);
    609 	}
    610 
    611 	return (0);
    612 }
    613 
    614 int
    615 smic_reset(struct ipmi_softc *sc)
    616 {
    617 	return (-1);
    618 }
    619 
    620 int
    621 smic_probe(struct ipmi_softc *sc)
    622 {
    623 	/* Flag register should not be 0xFF on a good system */
    624 	if (bmc_read(sc, _SMIC_FLAG_REG) == 0xFF)
    625 		return (-1);
    626 
    627 	return (0);
    628 }
    629 
    630 /*
    631  * KCS interface
    632  */
    633 #define _KCS_DATAIN_REGISTER		0
    634 #define _KCS_DATAOUT_REGISTER		0
    635 #define	  KCS_READ_NEXT			0x68
    636 
    637 #define _KCS_COMMAND_REGISTER		1
    638 #define	  KCS_GET_STATUS		0x60
    639 #define	  KCS_WRITE_START		0x61
    640 #define	  KCS_WRITE_END			0x62
    641 
    642 #define _KCS_STATUS_REGISTER		1
    643 #define	  KCS_OBF			(1L << 0)
    644 #define	  KCS_IBF			(1L << 1)
    645 #define	  KCS_SMS_ATN			(1L << 2)
    646 #define	  KCS_CD			(1L << 3)
    647 #define	  KCS_OEM1			(1L << 4)
    648 #define	  KCS_OEM2			(1L << 5)
    649 #define	  KCS_STATE_MASK		0xc0
    650 #define	    KCS_IDLE_STATE		0x00
    651 #define	    KCS_READ_STATE		0x40
    652 #define	    KCS_WRITE_STATE		0x80
    653 #define	    KCS_ERROR_STATE		0xC0
    654 
    655 int	kcs_wait(struct ipmi_softc *, uint8_t, uint8_t, const char *);
    656 int	kcs_write_cmd(struct ipmi_softc *, uint8_t);
    657 int	kcs_write_data(struct ipmi_softc *, uint8_t);
    658 int	kcs_read_data(struct ipmi_softc *, uint8_t *);
    659 
    660 int
    661 kcs_wait(struct ipmi_softc *sc, uint8_t mask, uint8_t value, const char *lbl)
    662 {
    663 	int v;
    664 
    665 	v = bmc_io_wait(sc, _KCS_STATUS_REGISTER, mask, value, lbl);
    666 	if (v < 0)
    667 		return (v);
    668 
    669 	/* Check if output buffer full, read dummy byte	 */
    670 	if ((v & (KCS_OBF | KCS_STATE_MASK)) == (KCS_OBF | KCS_WRITE_STATE))
    671 		bmc_read(sc, _KCS_DATAIN_REGISTER);
    672 
    673 	/* Check for error state */
    674 	if ((v & KCS_STATE_MASK) == KCS_ERROR_STATE) {
    675 		bmc_write(sc, _KCS_COMMAND_REGISTER, KCS_GET_STATUS);
    676 		while (bmc_read(sc, _KCS_STATUS_REGISTER) & KCS_IBF)
    677 			;
    678 		aprint_error("ipmi: error code: %x\n",
    679 		    bmc_read(sc, _KCS_DATAIN_REGISTER));
    680 	}
    681 
    682 	return (v & KCS_STATE_MASK);
    683 }
    684 
    685 int
    686 kcs_write_cmd(struct ipmi_softc *sc, uint8_t cmd)
    687 {
    688 	/* ASSERT: IBF and OBF are clear */
    689 	dbg_printf(50, "kcswritecmd: %.2x\n", cmd);
    690 	bmc_write(sc, _KCS_COMMAND_REGISTER, cmd);
    691 
    692 	return (kcs_wait(sc, KCS_IBF, 0, "write_cmd"));
    693 }
    694 
    695 int
    696 kcs_write_data(struct ipmi_softc *sc, uint8_t data)
    697 {
    698 	/* ASSERT: IBF and OBF are clear */
    699 	dbg_printf(50, "kcswritedata: %.2x\n", data);
    700 	bmc_write(sc, _KCS_DATAOUT_REGISTER, data);
    701 
    702 	return (kcs_wait(sc, KCS_IBF, 0, "write_data"));
    703 }
    704 
    705 int
    706 kcs_read_data(struct ipmi_softc *sc, uint8_t * data)
    707 {
    708 	int sts;
    709 
    710 	sts = kcs_wait(sc, KCS_IBF | KCS_OBF, KCS_OBF, "read_data");
    711 	if (sts != KCS_READ_STATE)
    712 		return (sts);
    713 
    714 	/* ASSERT: OBF is set read data, request next byte */
    715 	*data = bmc_read(sc, _KCS_DATAIN_REGISTER);
    716 	bmc_write(sc, _KCS_DATAOUT_REGISTER, KCS_READ_NEXT);
    717 
    718 	dbg_printf(50, "kcsreaddata: %.2x\n", *data);
    719 
    720 	return (sts);
    721 }
    722 
    723 /* Exported KCS functions */
    724 int
    725 kcs_sendmsg(struct ipmi_softc *sc, int len, const uint8_t * data)
    726 {
    727 	int idx, sts;
    728 
    729 	/* ASSERT: IBF is clear */
    730 	dbg_dump(50, "kcs sendmsg", len, data);
    731 	sts = kcs_write_cmd(sc, KCS_WRITE_START);
    732 	for (idx = 0; idx < len; idx++) {
    733 		if (idx == len - 1)
    734 			sts = kcs_write_cmd(sc, KCS_WRITE_END);
    735 
    736 		if (sts != KCS_WRITE_STATE)
    737 			break;
    738 
    739 		sts = kcs_write_data(sc, data[idx]);
    740 	}
    741 	if (sts != KCS_READ_STATE) {
    742 		dbg_printf(1, "kcs sendmsg = %d/%d <%.2x>\n", idx, len, sts);
    743 		dbg_dump(1, "kcs_sendmsg", len, data);
    744 		return (-1);
    745 	}
    746 
    747 	return (0);
    748 }
    749 
    750 int
    751 kcs_recvmsg(struct ipmi_softc *sc, int maxlen, int *rxlen, uint8_t * data)
    752 {
    753 	int idx, sts;
    754 
    755 	for (idx = 0; idx < maxlen; idx++) {
    756 		sts = kcs_read_data(sc, &data[idx]);
    757 		if (sts != KCS_READ_STATE)
    758 			break;
    759 	}
    760 	sts = kcs_wait(sc, KCS_IBF, 0, "recv");
    761 	*rxlen = idx;
    762 	if (sts != KCS_IDLE_STATE) {
    763 		dbg_printf(1, "kcs read = %d/%d <%.2x>\n", idx, maxlen, sts);
    764 		return (-1);
    765 	}
    766 
    767 	dbg_dump(50, "kcs recvmsg", idx, data);
    768 
    769 	return (0);
    770 }
    771 
    772 int
    773 kcs_reset(struct ipmi_softc *sc)
    774 {
    775 	return (-1);
    776 }
    777 
    778 int
    779 kcs_probe(struct ipmi_softc *sc)
    780 {
    781 	uint8_t v;
    782 
    783 	v = bmc_read(sc, _KCS_STATUS_REGISTER);
    784 #if 0
    785 	printf("kcs_probe: %2x\n", v);
    786 	printf(" STS: %2x\n", v & KCS_STATE_MASK);
    787 	printf(" ATN: %2x\n", v & KCS_SMS_ATN);
    788 	printf(" C/D: %2x\n", v & KCS_CD);
    789 	printf(" IBF: %2x\n", v & KCS_IBF);
    790 	printf(" OBF: %2x\n", v & KCS_OBF);
    791 #else
    792 	__USE(v);
    793 #endif
    794 	return (0);
    795 }
    796 
    797 /*
    798  * IPMI code
    799  */
    800 #define READ_SMS_BUFFER		0x37
    801 #define WRITE_I2C		0x50
    802 
    803 #define GET_MESSAGE_CMD		0x33
    804 #define SEND_MESSAGE_CMD	0x34
    805 
    806 #define IPMB_CHANNEL_NUMBER	0
    807 
    808 #define PUBLIC_BUS		0
    809 
    810 #define MIN_I2C_PACKET_SIZE	3
    811 #define MIN_IMB_PACKET_SIZE	7	/* one byte for cksum */
    812 
    813 #define MIN_BTBMC_REQ_SIZE	4
    814 #define MIN_BTBMC_RSP_SIZE	5
    815 #define MIN_BMC_REQ_SIZE	2
    816 #define MIN_BMC_RSP_SIZE	3
    817 
    818 #define BMC_SA			0x20	/* BMC/ESM3 */
    819 #define FPC_SA			0x22	/* front panel */
    820 #define BP_SA			0xC0	/* Primary Backplane */
    821 #define BP2_SA			0xC2	/* Secondary Backplane */
    822 #define PBP_SA			0xC4	/* Peripheral Backplane */
    823 #define DRAC_SA			0x28	/* DRAC-III */
    824 #define DRAC3_SA		0x30	/* DRAC-III */
    825 #define BMC_LUN			0
    826 #define SMS_LUN			2
    827 
    828 struct ipmi_request {
    829 	uint8_t	rsSa;
    830 	uint8_t	rsLun;
    831 	uint8_t	netFn;
    832 	uint8_t	cmd;
    833 	uint8_t	data_len;
    834 	uint8_t	*data;
    835 };
    836 
    837 struct ipmi_response {
    838 	uint8_t	cCode;
    839 	uint8_t	data_len;
    840 	uint8_t	*data;
    841 };
    842 
    843 struct ipmi_bmc_request {
    844 	uint8_t	bmc_nfLn;
    845 	uint8_t	bmc_cmd;
    846 	uint8_t	bmc_data_len;
    847 	uint8_t	bmc_data[1];
    848 };
    849 
    850 struct ipmi_bmc_response {
    851 	uint8_t	bmc_nfLn;
    852 	uint8_t	bmc_cmd;
    853 	uint8_t	bmc_cCode;
    854 	uint8_t	bmc_data_len;
    855 	uint8_t	bmc_data[1];
    856 };
    857 
    858 
    859 CFATTACH_DECL2_NEW(ipmi, sizeof(struct ipmi_softc),
    860     ipmi_match, ipmi_attach, ipmi_detach, NULL, NULL, NULL);
    861 
    862 /* Scan memory for signature */
    863 void *
    864 scan_sig(long start, long end, int skip, int len, const void *data)
    865 {
    866 	void *va;
    867 
    868 	while (start < end) {
    869 		va = ISA_HOLE_VADDR(start);
    870 		if (memcmp(va, data, len) == 0)
    871 			return (va);
    872 
    873 		start += skip;
    874 	}
    875 
    876 	return (NULL);
    877 }
    878 
    879 void
    880 dumpb(const char *lbl, int len, const uint8_t *data)
    881 {
    882 	int idx;
    883 
    884 	printf("%s: ", lbl);
    885 	for (idx = 0; idx < len; idx++)
    886 		printf("%.2x ", data[idx]);
    887 
    888 	printf("\n");
    889 }
    890 
    891 void
    892 ipmi_smbios_probe(struct smbios_ipmi *pipmi, struct ipmi_attach_args *ia)
    893 {
    894 
    895 	dbg_printf(1, "ipmi_smbios_probe: %02x %02x %02x %02x "
    896 	    "%08" PRIx64 " %02x %02x\n",
    897 	    pipmi->smipmi_if_type,
    898 	    pipmi->smipmi_if_rev,
    899 	    pipmi->smipmi_i2c_address,
    900 	    pipmi->smipmi_nvram_address,
    901 	    pipmi->smipmi_base_address,
    902 	    pipmi->smipmi_base_flags,
    903 	    pipmi->smipmi_irq);
    904 
    905 	ia->iaa_if_type = pipmi->smipmi_if_type;
    906 	ia->iaa_if_rev = pipmi->smipmi_if_rev;
    907 	ia->iaa_if_irq = (pipmi->smipmi_base_flags & SMIPMI_FLAG_IRQEN) ?
    908 	    pipmi->smipmi_irq : -1;
    909 	ia->iaa_if_irqlvl = (pipmi->smipmi_base_flags & SMIPMI_FLAG_IRQLVL) ?
    910 	    IST_LEVEL : IST_EDGE;
    911 
    912 	switch (SMIPMI_FLAG_IFSPACING(pipmi->smipmi_base_flags)) {
    913 	case IPMI_IOSPACING_BYTE:
    914 		ia->iaa_if_iospacing = 1;
    915 		break;
    916 
    917 	case IPMI_IOSPACING_DWORD:
    918 		ia->iaa_if_iospacing = 4;
    919 		break;
    920 
    921 	case IPMI_IOSPACING_WORD:
    922 		ia->iaa_if_iospacing = 2;
    923 		break;
    924 
    925 	default:
    926 		ia->iaa_if_iospacing = 1;
    927 		aprint_error("ipmi: unknown register spacing\n");
    928 	}
    929 
    930 	/* Calculate base address (PCI BAR format) */
    931 	if (pipmi->smipmi_base_address & 0x1) {
    932 		ia->iaa_if_iotype = 'i';
    933 		ia->iaa_if_iobase = pipmi->smipmi_base_address & ~0x1;
    934 	} else {
    935 		ia->iaa_if_iotype = 'm';
    936 		ia->iaa_if_iobase = pipmi->smipmi_base_address & ~0xF;
    937 	}
    938 	if (pipmi->smipmi_base_flags & SMIPMI_FLAG_ODDOFFSET)
    939 		ia->iaa_if_iobase++;
    940 
    941 	if (pipmi->smipmi_base_flags == 0x7f) {
    942 		/* IBM 325 eServer workaround */
    943 		ia->iaa_if_iospacing = 1;
    944 		ia->iaa_if_iobase = pipmi->smipmi_base_address;
    945 		ia->iaa_if_iotype = 'i';
    946 		return;
    947 	}
    948 }
    949 
    950 /*
    951  * bt_buildmsg builds an IPMI message from a nfLun, cmd, and data
    952  * This is used by BT protocol
    953  *
    954  * Returns a buffer to an allocated message, txlen contains length
    955  *   of allocated message
    956  */
    957 void *
    958 bt_buildmsg(struct ipmi_softc *sc, int nfLun, int cmd, int len,
    959     const void *data, int *txlen)
    960 {
    961 	uint8_t *buf;
    962 
    963 	/* Block transfer needs 4 extra bytes: length/netfn/seq/cmd + data */
    964 	*txlen = len + 4;
    965 	buf = ipmi_buf_acquire(sc, *txlen);
    966 	if (buf == NULL)
    967 		return (NULL);
    968 
    969 	buf[IPMI_BTMSG_LEN] = len + 3;
    970 	buf[IPMI_BTMSG_NFLN] = nfLun;
    971 	buf[IPMI_BTMSG_SEQ] = sc->sc_btseq++;
    972 	buf[IPMI_BTMSG_CMD] = cmd;
    973 	if (len && data)
    974 		memcpy(buf + IPMI_BTMSG_DATASND, data, len);
    975 
    976 	return (buf);
    977 }
    978 
    979 /*
    980  * cmn_buildmsg builds an IPMI message from a nfLun, cmd, and data
    981  * This is used by both SMIC and KCS protocols
    982  *
    983  * Returns a buffer to an allocated message, txlen contains length
    984  *   of allocated message
    985  */
    986 void *
    987 cmn_buildmsg(struct ipmi_softc *sc, int nfLun, int cmd, int len,
    988     const void *data, int *txlen)
    989 {
    990 	uint8_t *buf;
    991 
    992 	/* Common needs two extra bytes: nfLun/cmd + data */
    993 	*txlen = len + 2;
    994 	buf = ipmi_buf_acquire(sc, *txlen);
    995 	if (buf == NULL)
    996 		return (NULL);
    997 
    998 	buf[IPMI_MSG_NFLN] = nfLun;
    999 	buf[IPMI_MSG_CMD] = cmd;
   1000 	if (len && data)
   1001 		memcpy(buf + IPMI_MSG_DATASND, data, len);
   1002 
   1003 	return (buf);
   1004 }
   1005 
   1006 /*
   1007  * ipmi_sendcmd: caller must hold sc_cmd_mtx.
   1008  *
   1009  * Send an IPMI command
   1010  */
   1011 int
   1012 ipmi_sendcmd(struct ipmi_softc *sc, int rssa, int rslun, int netfn, int cmd,
   1013     int txlen, const void *data)
   1014 {
   1015 	uint8_t	*buf;
   1016 	int		rc = -1;
   1017 
   1018 	dbg_printf(50, "ipmi_sendcmd: rssa=%.2x nfln=%.2x cmd=%.2x len=%.2x\n",
   1019 	    rssa, NETFN_LUN(netfn, rslun), cmd, txlen);
   1020 	dbg_dump(10, " send", txlen, data);
   1021 	if (rssa != BMC_SA) {
   1022 #if 0
   1023 		buf = sc->sc_if->buildmsg(sc, NETFN_LUN(APP_NETFN, BMC_LUN),
   1024 		    APP_SEND_MESSAGE, 7 + txlen, NULL, &txlen);
   1025 		pI2C->bus = (sc->if_ver == 0x09) ?
   1026 		    PUBLIC_BUS :
   1027 		    IPMB_CHANNEL_NUMBER;
   1028 
   1029 		imbreq->rsSa = rssa;
   1030 		imbreq->nfLn = NETFN_LUN(netfn, rslun);
   1031 		imbreq->cSum1 = -(imbreq->rsSa + imbreq->nfLn);
   1032 		imbreq->rqSa = BMC_SA;
   1033 		imbreq->seqLn = NETFN_LUN(sc->imb_seq++, SMS_LUN);
   1034 		imbreq->cmd = cmd;
   1035 		if (txlen)
   1036 			memcpy(imbreq->data, data, txlen);
   1037 		/* Set message checksum */
   1038 		imbreq->data[txlen] = cksum8(&imbreq->rqSa, txlen + 3);
   1039 #endif
   1040 		goto done;
   1041 	} else
   1042 		buf = sc->sc_if->buildmsg(sc, NETFN_LUN(netfn, rslun), cmd,
   1043 		    txlen, data, &txlen);
   1044 
   1045 	if (buf == NULL) {
   1046 		printf("ipmi: sendcmd buffer busy\n");
   1047 		goto done;
   1048 	}
   1049 	rc = sc->sc_if->sendmsg(sc, txlen, buf);
   1050 	ipmi_buf_release(sc, buf);
   1051 
   1052 	ipmi_delay(sc, 50); /* give bmc chance to digest command */
   1053 
   1054 done:
   1055 	return (rc);
   1056 }
   1057 
   1058 void
   1059 ipmi_buf_release(struct ipmi_softc *sc, char *buf)
   1060 {
   1061 	KASSERT(sc->sc_buf_rsvd);
   1062 	KASSERT(sc->sc_buf == buf);
   1063 	sc->sc_buf_rsvd = false;
   1064 }
   1065 
   1066 char *
   1067 ipmi_buf_acquire(struct ipmi_softc *sc, size_t len)
   1068 {
   1069 	KASSERT(len <= sizeof(sc->sc_buf));
   1070 
   1071 	if (sc->sc_buf_rsvd || len > sizeof(sc->sc_buf))
   1072 		return NULL;
   1073 	sc->sc_buf_rsvd = true;
   1074 	return sc->sc_buf;
   1075 }
   1076 
   1077 /*
   1078  * ipmi_recvcmd: caller must hold sc_cmd_mtx.
   1079  */
   1080 int
   1081 ipmi_recvcmd(struct ipmi_softc *sc, int maxlen, int *rxlen, void *data)
   1082 {
   1083 	uint8_t	*buf, rc = 0;
   1084 	int		rawlen;
   1085 
   1086 	/* Need three extra bytes: netfn/cmd/ccode + data */
   1087 	buf = ipmi_buf_acquire(sc, maxlen + 3);
   1088 	if (buf == NULL) {
   1089 		printf("ipmi: ipmi_recvcmd: malloc fails\n");
   1090 		return (-1);
   1091 	}
   1092 	/* Receive message from interface, copy out result data */
   1093 	if (sc->sc_if->recvmsg(sc, maxlen + 3, &rawlen, buf)) {
   1094 		ipmi_buf_release(sc, buf);
   1095 		return (-1);
   1096 	}
   1097 
   1098 	*rxlen = rawlen - IPMI_MSG_DATARCV;
   1099 	if (*rxlen > 0 && data)
   1100 		memcpy(data, buf + IPMI_MSG_DATARCV, *rxlen);
   1101 
   1102 	if ((rc = buf[IPMI_MSG_CCODE]) != 0)
   1103 		dbg_printf(1, "ipmi_recvmsg: nfln=%.2x cmd=%.2x err=%.2x\n",
   1104 		    buf[IPMI_MSG_NFLN], buf[IPMI_MSG_CMD], buf[IPMI_MSG_CCODE]);
   1105 
   1106 	dbg_printf(50, "ipmi_recvcmd: nfln=%.2x cmd=%.2x err=%.2x len=%.2x\n",
   1107 	    buf[IPMI_MSG_NFLN], buf[IPMI_MSG_CMD], buf[IPMI_MSG_CCODE],
   1108 	    *rxlen);
   1109 	dbg_dump(10, " recv", *rxlen, data);
   1110 
   1111 	ipmi_buf_release(sc, buf);
   1112 
   1113 	return (rc);
   1114 }
   1115 
   1116 /*
   1117  * ipmi_delay: caller must hold sc_cmd_mtx.
   1118  */
   1119 void
   1120 ipmi_delay(struct ipmi_softc *sc, int ms)
   1121 {
   1122 	if (cold)
   1123 		delay(ms * 1000);
   1124 	else {
   1125 		mutex_enter(&sc->sc_sleep_mtx);
   1126 		cv_timedwait(&sc->sc_cmd_sleep, &sc->sc_sleep_mtx, mstohz(ms));
   1127 		mutex_exit(&sc->sc_sleep_mtx);
   1128 	}
   1129 }
   1130 
   1131 /* Read a partial SDR entry */
   1132 int
   1133 get_sdr_partial(struct ipmi_softc *sc, uint16_t recordId, uint16_t reserveId,
   1134     uint8_t offset, uint8_t length, void *buffer, uint16_t *nxtRecordId)
   1135 {
   1136 	uint8_t	cmd[256 + 8];
   1137 	int		len;
   1138 
   1139 	((uint16_t *) cmd)[0] = reserveId;
   1140 	((uint16_t *) cmd)[1] = recordId;
   1141 	cmd[4] = offset;
   1142 	cmd[5] = length;
   1143 	mutex_enter(&sc->sc_cmd_mtx);
   1144 	if (ipmi_sendcmd(sc, BMC_SA, 0, STORAGE_NETFN, STORAGE_GET_SDR, 6,
   1145 	    cmd)) {
   1146 		mutex_exit(&sc->sc_cmd_mtx);
   1147 		printf("ipmi: sendcmd fails\n");
   1148 		return (-1);
   1149 	}
   1150 	if (ipmi_recvcmd(sc, 8 + length, &len, cmd)) {
   1151 		mutex_exit(&sc->sc_cmd_mtx);
   1152 		printf("ipmi: getSdrPartial: recvcmd fails\n");
   1153 		return (-1);
   1154 	}
   1155 	mutex_exit(&sc->sc_cmd_mtx);
   1156 	if (nxtRecordId)
   1157 		*nxtRecordId = *(uint16_t *) cmd;
   1158 	memcpy(buffer, cmd + 2, len - 2);
   1159 
   1160 	return (0);
   1161 }
   1162 
   1163 int maxsdrlen = 0x10;
   1164 
   1165 /* Read an entire SDR; pass to add sensor */
   1166 int
   1167 get_sdr(struct ipmi_softc *sc, uint16_t recid, uint16_t *nxtrec)
   1168 {
   1169 	uint16_t	resid = 0;
   1170 	int		len, sdrlen, offset;
   1171 	uint8_t	*psdr;
   1172 	struct sdrhdr	shdr;
   1173 
   1174 	mutex_enter(&sc->sc_cmd_mtx);
   1175 	/* Reserve SDR */
   1176 	if (ipmi_sendcmd(sc, BMC_SA, 0, STORAGE_NETFN, STORAGE_RESERVE_SDR,
   1177 	    0, NULL)) {
   1178 		mutex_exit(&sc->sc_cmd_mtx);
   1179 		printf("ipmi: reserve send fails\n");
   1180 		return (-1);
   1181 	}
   1182 	if (ipmi_recvcmd(sc, sizeof(resid), &len, &resid)) {
   1183 		mutex_exit(&sc->sc_cmd_mtx);
   1184 		printf("ipmi: reserve recv fails\n");
   1185 		return (-1);
   1186 	}
   1187 	mutex_exit(&sc->sc_cmd_mtx);
   1188 	/* Get SDR Header */
   1189 	if (get_sdr_partial(sc, recid, resid, 0, sizeof shdr, &shdr, nxtrec)) {
   1190 		printf("ipmi: get header fails\n");
   1191 		return (-1);
   1192 	}
   1193 	/* Allocate space for entire SDR Length of SDR in header does not
   1194 	 * include header length */
   1195 	sdrlen = sizeof(shdr) + shdr.record_length;
   1196 	psdr = malloc(sdrlen, M_DEVBUF, M_WAITOK|M_CANFAIL);
   1197 	if (psdr == NULL)
   1198 		return -1;
   1199 
   1200 	memcpy(psdr, &shdr, sizeof(shdr));
   1201 
   1202 	/* Read SDR Data maxsdrlen bytes at a time */
   1203 	for (offset = sizeof(shdr); offset < sdrlen; offset += maxsdrlen) {
   1204 		len = sdrlen - offset;
   1205 		if (len > maxsdrlen)
   1206 			len = maxsdrlen;
   1207 
   1208 		if (get_sdr_partial(sc, recid, resid, offset, len,
   1209 		    psdr + offset, NULL)) {
   1210 			printf("ipmi: get chunk : %d,%d fails\n",
   1211 			    offset, len);
   1212 			return (-1);
   1213 		}
   1214 	}
   1215 
   1216 	/* Add SDR to sensor list, if not wanted, free buffer */
   1217 	if (add_sdr_sensor(sc, psdr) == 0)
   1218 		free(psdr, M_DEVBUF);
   1219 
   1220 	return (0);
   1221 }
   1222 
   1223 int
   1224 getbits(uint8_t *bytes, int bitpos, int bitlen)
   1225 {
   1226 	int	v;
   1227 	int	mask;
   1228 
   1229 	bitpos += bitlen - 1;
   1230 	for (v = 0; bitlen--;) {
   1231 		v <<= 1;
   1232 		mask = 1L << (bitpos & 7);
   1233 		if (bytes[bitpos >> 3] & mask)
   1234 			v |= 1;
   1235 		bitpos--;
   1236 	}
   1237 
   1238 	return (v);
   1239 }
   1240 
   1241 /* Decode IPMI sensor name */
   1242 void
   1243 ipmi_sensor_name(char *name, int len, uint8_t typelen, uint8_t *bits)
   1244 {
   1245 	int	i, slen;
   1246 	char	bcdplus[] = "0123456789 -.:,_";
   1247 
   1248 	slen = typelen & 0x1F;
   1249 	switch (typelen >> 6) {
   1250 	case IPMI_NAME_UNICODE:
   1251 		//unicode
   1252 		break;
   1253 
   1254 	case IPMI_NAME_BCDPLUS:
   1255 		/* Characters are encoded in 4-bit BCDPLUS */
   1256 		if (len < slen * 2 + 1)
   1257 			slen = (len >> 1) - 1;
   1258 		for (i = 0; i < slen; i++) {
   1259 			*(name++) = bcdplus[bits[i] >> 4];
   1260 			*(name++) = bcdplus[bits[i] & 0xF];
   1261 		}
   1262 		break;
   1263 
   1264 	case IPMI_NAME_ASCII6BIT:
   1265 		/* Characters are encoded in 6-bit ASCII
   1266 		 *   0x00 - 0x3F maps to 0x20 - 0x5F */
   1267 		/* XXX: need to calculate max len: slen = 3/4 * len */
   1268 		if (len < slen + 1)
   1269 			slen = len - 1;
   1270 		for (i = 0; i < slen * 8; i += 6)
   1271 			*(name++) = getbits(bits, i, 6) + ' ';
   1272 		break;
   1273 
   1274 	case IPMI_NAME_ASCII8BIT:
   1275 		/* Characters are 8-bit ascii */
   1276 		if (len < slen + 1)
   1277 			slen = len - 1;
   1278 		while (slen--)
   1279 			*(name++) = *(bits++);
   1280 		break;
   1281 	}
   1282 	*name = 0;
   1283 }
   1284 
   1285 /* Sign extend a n-bit value */
   1286 long
   1287 signextend(unsigned long val, int bits)
   1288 {
   1289 	long msk = (1L << (bits-1))-1;
   1290 
   1291 	return (-(val & ~msk) | val);
   1292 }
   1293 
   1294 
   1295 /* fixpoint arithmetic */
   1296 #define FIX2INT(x)   ((int64_t)((x) >> 32))
   1297 #define INT2FIX(x)   ((int64_t)((int64_t)(x) << 32))
   1298 
   1299 #define FIX2            0x0000000200000000ll /* 2.0 */
   1300 #define FIX3            0x0000000300000000ll /* 3.0 */
   1301 #define FIXE            0x00000002b7e15163ll /* 2.71828182845904523536 */
   1302 #define FIX10           0x0000000a00000000ll /* 10.0 */
   1303 #define FIXMONE         0xffffffff00000000ll /* -1.0 */
   1304 #define FIXHALF         0x0000000080000000ll /* 0.5 */
   1305 #define FIXTHIRD        0x0000000055555555ll /* 0.33333333333333333333 */
   1306 
   1307 #define FIX1LOG2        0x0000000171547653ll /* 1.0/log(2) */
   1308 #define FIX1LOGE        0x0000000100000000ll /* 1.0/log(2.71828182845904523536) */
   1309 #define FIX1LOG10       0x000000006F2DEC55ll /* 1.0/log(10) */
   1310 
   1311 #define FIX1E           0x000000005E2D58D9ll /* 1.0/2.71828182845904523536 */
   1312 
   1313 static int64_t fixlog_a[] = {
   1314 	0x0000000100000000ll /* 1.0/1.0 */,
   1315 	0xffffffff80000000ll /* -1.0/2.0 */,
   1316 	0x0000000055555555ll /* 1.0/3.0 */,
   1317 	0xffffffffc0000000ll /* -1.0/4.0 */,
   1318 	0x0000000033333333ll /* 1.0/5.0 */,
   1319 	0x000000002aaaaaabll /* -1.0/6.0 */,
   1320 	0x0000000024924925ll /* 1.0/7.0 */,
   1321 	0x0000000020000000ll /* -1.0/8.0 */,
   1322 	0x000000001c71c71cll /* 1.0/9.0 */
   1323 };
   1324 
   1325 static int64_t fixexp_a[] = {
   1326 	0x0000000100000000ll /* 1.0/1.0 */,
   1327 	0x0000000100000000ll /* 1.0/1.0 */,
   1328 	0x0000000080000000ll /* 1.0/2.0 */,
   1329 	0x000000002aaaaaabll /* 1.0/6.0 */,
   1330 	0x000000000aaaaaabll /* 1.0/24.0 */,
   1331 	0x0000000002222222ll /* 1.0/120.0 */,
   1332 	0x00000000005b05b0ll /* 1.0/720.0 */,
   1333 	0x00000000000d00d0ll /* 1.0/5040.0 */,
   1334 	0x000000000001a01all /* 1.0/40320.0 */
   1335 };
   1336 
   1337 static int64_t
   1338 fixmul(int64_t x, int64_t y)
   1339 {
   1340 	int64_t z;
   1341 	int64_t a,b,c,d;
   1342 	int neg;
   1343 
   1344 	neg = 0;
   1345 	if (x < 0) {
   1346 		x = -x;
   1347 		neg = !neg;
   1348 	}
   1349 	if (y < 0) {
   1350 		y = -y;
   1351 		neg = !neg;
   1352 	}
   1353 
   1354 	a = FIX2INT(x);
   1355 	b = x - INT2FIX(a);
   1356 	c = FIX2INT(y);
   1357 	d = y - INT2FIX(c);
   1358 
   1359 	z = INT2FIX(a*c) + a * d + b * c + (b/2 * d/2 >> 30);
   1360 
   1361 	return neg ? -z : z;
   1362 }
   1363 
   1364 static int64_t
   1365 poly(int64_t x0, int64_t x, int64_t a[], int n)
   1366 {
   1367 	int64_t z;
   1368 	int i;
   1369 
   1370 	z  = fixmul(x0, a[0]);
   1371 	for (i=1; i<n; ++i) {
   1372 		x0 = fixmul(x0, x);
   1373 		z  = fixmul(x0, a[i]) + z;
   1374 	}
   1375 	return z;
   1376 }
   1377 
   1378 static int64_t
   1379 logx(int64_t x, int64_t y)
   1380 {
   1381 	int64_t z;
   1382 
   1383 	if (x <= INT2FIX(0)) {
   1384 		z = INT2FIX(-99999);
   1385 		goto done;
   1386 	}
   1387 
   1388 	z = INT2FIX(0);
   1389 	while (x >= FIXE) {
   1390 		x = fixmul(x, FIX1E);
   1391 		z += INT2FIX(1);
   1392 	}
   1393 	while (x < INT2FIX(1)) {
   1394 		x = fixmul(x, FIXE);
   1395 		z -= INT2FIX(1);
   1396 	}
   1397 
   1398 	x -= INT2FIX(1);
   1399 	z += poly(x, x, fixlog_a, sizeof(fixlog_a)/sizeof(fixlog_a[0]));
   1400 	z  = fixmul(z, y);
   1401 
   1402 done:
   1403 	return z;
   1404 }
   1405 
   1406 static int64_t
   1407 powx(int64_t x, int64_t y)
   1408 {
   1409 	int64_t k;
   1410 
   1411 	if (x == INT2FIX(0))
   1412 		goto done;
   1413 
   1414 	x = logx(x,y);
   1415 
   1416 	if (x < INT2FIX(0)) {
   1417 		x = INT2FIX(0) - x;
   1418 		k = -FIX2INT(x);
   1419 		x = INT2FIX(-k) - x;
   1420 	} else {
   1421 		k = FIX2INT(x);
   1422 		x = x - INT2FIX(k);
   1423 	}
   1424 
   1425 	x = poly(INT2FIX(1), x, fixexp_a, sizeof(fixexp_a)/sizeof(fixexp_a[0]));
   1426 
   1427 	while (k < 0) {
   1428 		x = fixmul(x, FIX1E);
   1429 		++k;
   1430 	}
   1431 	while (k > 0) {
   1432 		x = fixmul(x, FIXE);
   1433 		--k;
   1434 	}
   1435 
   1436 done:
   1437 	return x;
   1438 }
   1439 
   1440 /* Convert IPMI reading from sensor factors */
   1441 long
   1442 ipmi_convert(uint8_t v, struct sdrtype1 *s1, long adj)
   1443 {
   1444 	int64_t	M, B;
   1445 	char	K1, K2;
   1446 	int64_t	val, v1, v2, vs;
   1447 	int sign = (s1->units1 >> 6) & 0x3;
   1448 
   1449 	vs = (sign == 0x1 || sign == 0x2) ? (int8_t)v : v;
   1450 	if ((vs < 0) && (sign == 0x1))
   1451 		vs++;
   1452 
   1453 	/* Calculate linear reading variables */
   1454 	M  = signextend((((short)(s1->m_tolerance & 0xC0)) << 2) + s1->m, 10);
   1455 	B  = signextend((((short)(s1->b_accuracy & 0xC0)) << 2) + s1->b, 10);
   1456 	K1 = signextend(s1->rbexp & 0xF, 4);
   1457 	K2 = signextend(s1->rbexp >> 4, 4);
   1458 
   1459 	/* Calculate sensor reading:
   1460 	 *  y = L((M * v + (B * 10^K1)) * 10^(K2+adj)
   1461 	 *
   1462 	 * This commutes out to:
   1463 	 *  y = L(M*v * 10^(K2+adj) + B * 10^(K1+K2+adj)); */
   1464 	v1 = powx(FIX10, INT2FIX(K2 + adj));
   1465 	v2 = powx(FIX10, INT2FIX(K1 + K2 + adj));
   1466 	val = M * vs * v1 + B * v2;
   1467 
   1468 	/* Linearization function: y = f(x) 0 : y = x 1 : y = ln(x) 2 : y =
   1469 	 * log10(x) 3 : y = log2(x) 4 : y = e^x 5 : y = 10^x 6 : y = 2^x 7 : y
   1470 	 * = 1/x 8 : y = x^2 9 : y = x^3 10 : y = square root(x) 11 : y = cube
   1471 	 * root(x) */
   1472 	switch (s1->linear & 0x7f) {
   1473 	case 0: break;
   1474 	case 1: val = logx(val,FIX1LOGE); break;
   1475 	case 2: val = logx(val,FIX1LOG10); break;
   1476 	case 3: val = logx(val,FIX1LOG2); break;
   1477 	case 4: val = powx(FIXE,val); break;
   1478 	case 5: val = powx(FIX10,val); break;
   1479 	case 6: val = powx(FIX2,val); break;
   1480 	case 7: val = powx(val,FIXMONE); break;
   1481 	case 8: val = powx(val,FIX2); break;
   1482 	case 9: val = powx(val,FIX3); break;
   1483 	case 10: val = powx(val,FIXHALF); break;
   1484 	case 11: val = powx(val,FIXTHIRD); break;
   1485 	}
   1486 
   1487 	return FIX2INT(val);
   1488 }
   1489 
   1490 int32_t
   1491 ipmi_convert_sensor(uint8_t *reading, struct ipmi_sensor *psensor)
   1492 {
   1493 	struct sdrtype1	*s1 = (struct sdrtype1 *)psensor->i_sdr;
   1494 	int32_t val;
   1495 
   1496 	switch (psensor->i_envtype) {
   1497 	case ENVSYS_STEMP:
   1498 		val = ipmi_convert(reading[0], s1, 6) + 273150000;
   1499 		break;
   1500 
   1501 	case ENVSYS_SVOLTS_DC:
   1502 		val = ipmi_convert(reading[0], s1, 6);
   1503 		break;
   1504 
   1505 	case ENVSYS_SFANRPM:
   1506 		val = ipmi_convert(reading[0], s1, 0);
   1507 		if (((s1->units1>>3)&0x7) == 0x3)
   1508 			val *= 60; /* RPS -> RPM */
   1509 		break;
   1510 	default:
   1511 		val = 0;
   1512 		break;
   1513 	}
   1514 	return val;
   1515 }
   1516 
   1517 void
   1518 ipmi_set_limits(struct sysmon_envsys *sme, envsys_data_t *edata,
   1519 		sysmon_envsys_lim_t *limits, uint32_t *props)
   1520 {
   1521 	struct ipmi_sensor *ipmi_s;
   1522 
   1523 	/* Find the ipmi_sensor corresponding to this edata */
   1524 	SLIST_FOREACH(ipmi_s, &ipmi_sensor_list, i_list) {
   1525 		if (ipmi_s->i_envnum == edata->sensor) {
   1526 			if (limits == NULL) {
   1527 				limits = &ipmi_s->i_deflims;
   1528 				props  = &ipmi_s->i_defprops;
   1529 			}
   1530 			*props |= PROP_DRIVER_LIMITS;
   1531 			ipmi_s->i_limits = *limits;
   1532 			ipmi_s->i_props  = *props;
   1533 			return;
   1534 		}
   1535 	}
   1536 	return;
   1537 }
   1538 
   1539 void
   1540 ipmi_get_limits(struct sysmon_envsys *sme, envsys_data_t *edata,
   1541 		sysmon_envsys_lim_t *limits, uint32_t *props)
   1542 {
   1543 	struct ipmi_sensor *ipmi_s;
   1544 	struct ipmi_softc *sc = sme->sme_cookie;
   1545 
   1546 	/* Find the ipmi_sensor corresponding to this edata */
   1547 	SLIST_FOREACH(ipmi_s, &ipmi_sensor_list, i_list) {
   1548 		if (ipmi_s->i_envnum == edata->sensor) {
   1549 			ipmi_get_sensor_limits(sc, ipmi_s, limits, props);
   1550 			ipmi_s->i_limits = *limits;
   1551 			ipmi_s->i_props  = *props;
   1552 			if (ipmi_s->i_defprops == 0) {
   1553 				ipmi_s->i_defprops = *props;
   1554 				ipmi_s->i_deflims  = *limits;
   1555 			}
   1556 			return;
   1557 		}
   1558 	}
   1559 	return;
   1560 }
   1561 
   1562 void
   1563 ipmi_get_sensor_limits(struct ipmi_softc *sc, struct ipmi_sensor *psensor,
   1564 		       sysmon_envsys_lim_t *limits, uint32_t *props)
   1565 {
   1566 	struct sdrtype1	*s1 = (struct sdrtype1 *)psensor->i_sdr;
   1567 	bool failure;
   1568 	int	rxlen;
   1569 	uint8_t	data[32];
   1570 	uint32_t prop_critmax, prop_warnmax, prop_critmin, prop_warnmin;
   1571 	int32_t *pcritmax, *pwarnmax, *pcritmin, *pwarnmin;
   1572 
   1573 	*props &= ~(PROP_CRITMIN | PROP_CRITMAX | PROP_WARNMIN | PROP_WARNMAX);
   1574 	data[0] = psensor->i_num;
   1575 	mutex_enter(&sc->sc_cmd_mtx);
   1576 	failure =
   1577 	    ipmi_sendcmd(sc, s1->owner_id, s1->owner_lun,
   1578 			 SE_NETFN, SE_GET_SENSOR_THRESHOLD, 1, data) ||
   1579 	    ipmi_recvcmd(sc, sizeof(data), &rxlen, data);
   1580 	mutex_exit(&sc->sc_cmd_mtx);
   1581 	if (failure)
   1582 		return;
   1583 
   1584 	dbg_printf(25, "recvdata: %.2x %.2x %.2x %.2x %.2x %.2x %.2x\n",
   1585 	    data[0], data[1], data[2], data[3], data[4], data[5], data[6]);
   1586 
   1587 	switch (s1->linear & 0x7f) {
   1588 	case 7: /* 1/x sensor, exchange upper and lower limits */
   1589 		prop_critmax = PROP_CRITMIN;
   1590 		prop_warnmax = PROP_WARNMIN;
   1591 		prop_critmin = PROP_CRITMAX;
   1592 		prop_warnmin = PROP_WARNMAX;
   1593 		pcritmax = &limits->sel_critmin;
   1594 		pwarnmax = &limits->sel_warnmin;
   1595 		pcritmin = &limits->sel_critmax;
   1596 		pwarnmin = &limits->sel_warnmax;
   1597 		break;
   1598 	default:
   1599 		prop_critmax = PROP_CRITMAX;
   1600 		prop_warnmax = PROP_WARNMAX;
   1601 		prop_critmin = PROP_CRITMIN;
   1602 		prop_warnmin = PROP_WARNMIN;
   1603 		pcritmax = &limits->sel_critmax;
   1604 		pwarnmax = &limits->sel_warnmax;
   1605 		pcritmin = &limits->sel_critmin;
   1606 		pwarnmin = &limits->sel_warnmin;
   1607 		break;
   1608 	}
   1609 
   1610 	if (data[0] & 0x20 && data[6] != 0xff) {
   1611 		*pcritmax = ipmi_convert_sensor(&data[6], psensor);
   1612 		*props |= prop_critmax;
   1613 	}
   1614 	if (data[0] & 0x10 && data[5] != 0xff) {
   1615 		*pcritmax = ipmi_convert_sensor(&data[5], psensor);
   1616 		*props |= prop_critmax;
   1617 	}
   1618 	if (data[0] & 0x08 && data[4] != 0xff) {
   1619 		*pwarnmax = ipmi_convert_sensor(&data[4], psensor);
   1620 		*props |= prop_warnmax;
   1621 	}
   1622 	if (data[0] & 0x04 && data[3] != 0x00) {
   1623 		*pcritmin = ipmi_convert_sensor(&data[3], psensor);
   1624 		*props |= prop_critmin;
   1625 	}
   1626 	if (data[0] & 0x02 && data[2] != 0x00) {
   1627 		*pcritmin = ipmi_convert_sensor(&data[2], psensor);
   1628 		*props |= prop_critmin;
   1629 	}
   1630 	if (data[0] & 0x01 && data[1] != 0x00) {
   1631 		*pwarnmin = ipmi_convert_sensor(&data[1], psensor);
   1632 		*props |= prop_warnmin;
   1633 	}
   1634 	return;
   1635 }
   1636 
   1637 int
   1638 ipmi_sensor_status(struct ipmi_softc *sc, struct ipmi_sensor *psensor,
   1639     envsys_data_t *edata, uint8_t *reading)
   1640 {
   1641 	int	etype;
   1642 
   1643 	/* Get reading of sensor */
   1644 	edata->value_cur = ipmi_convert_sensor(reading, psensor);
   1645 
   1646 	/* Return Sensor Status */
   1647 	etype = (psensor->i_etype << 8) + psensor->i_stype;
   1648 	switch (etype) {
   1649 	case IPMI_SENSOR_TYPE_TEMP:
   1650 	case IPMI_SENSOR_TYPE_VOLT:
   1651 	case IPMI_SENSOR_TYPE_FAN:
   1652 		if (psensor->i_props & PROP_CRITMAX &&
   1653 		    edata->value_cur > psensor->i_limits.sel_critmax)
   1654 			return ENVSYS_SCRITOVER;
   1655 
   1656 		if (psensor->i_props & PROP_WARNMAX &&
   1657 		    edata->value_cur > psensor->i_limits.sel_warnmax)
   1658 			return ENVSYS_SWARNOVER;
   1659 
   1660 		if (psensor->i_props & PROP_WARNMIN &&
   1661 		    edata->value_cur < psensor->i_limits.sel_warnmin)
   1662 			return ENVSYS_SWARNUNDER;
   1663 
   1664 		if (psensor->i_props & PROP_CRITMIN &&
   1665 		    edata->value_cur < psensor->i_limits.sel_critmin)
   1666 			return ENVSYS_SCRITUNDER;
   1667 
   1668 		break;
   1669 
   1670 	case IPMI_SENSOR_TYPE_INTRUSION:
   1671 		edata->value_cur = (reading[2] & 1) ? 0 : 1;
   1672 		if (reading[2] & 0x1)
   1673 			return ENVSYS_SCRITICAL;
   1674 		break;
   1675 
   1676 	case IPMI_SENSOR_TYPE_PWRSUPPLY:
   1677 		/* Reading: 1 = present+powered, 0 = otherwise */
   1678 		edata->value_cur = (reading[2] & 1) ? 0 : 1;
   1679 		if (reading[2] & 0x10) {
   1680 			/* XXX: Need envsys type for Power Supply types
   1681 			 *   ok: power supply installed && powered
   1682 			 * warn: power supply installed && !powered
   1683 			 * crit: power supply !installed
   1684 			 */
   1685 			return ENVSYS_SCRITICAL;
   1686 		}
   1687 		if (reading[2] & 0x08) {
   1688 			/* Power supply AC lost */
   1689 			return ENVSYS_SWARNOVER;
   1690 		}
   1691 		break;
   1692 	}
   1693 
   1694 	return ENVSYS_SVALID;
   1695 }
   1696 
   1697 int
   1698 read_sensor(struct ipmi_softc *sc, struct ipmi_sensor *psensor)
   1699 {
   1700 	struct sdrtype1	*s1 = (struct sdrtype1 *) psensor->i_sdr;
   1701 	uint8_t	data[8];
   1702 	int		rxlen;
   1703 	envsys_data_t *edata = &sc->sc_sensor[psensor->i_envnum];
   1704 
   1705 	memset(data, 0, sizeof(data));
   1706 	data[0] = psensor->i_num;
   1707 
   1708 	mutex_enter(&sc->sc_cmd_mtx);
   1709 	if (ipmi_sendcmd(sc, s1->owner_id, s1->owner_lun, SE_NETFN,
   1710 	    SE_GET_SENSOR_READING, 1, data))
   1711 		goto err;
   1712 
   1713 	if (ipmi_recvcmd(sc, sizeof(data), &rxlen, data))
   1714 		goto err;
   1715 	mutex_exit(&sc->sc_cmd_mtx);
   1716 
   1717 	dbg_printf(10, "m=%u, m_tolerance=%u, b=%u, b_accuracy=%u, rbexp=%u, linear=%d\n",
   1718 	    s1->m, s1->m_tolerance, s1->b, s1->b_accuracy, s1->rbexp, s1->linear);
   1719 	dbg_printf(10, "values=%.2x %.2x %.2x %.2x %s\n",
   1720 	    data[0],data[1],data[2],data[3], edata->desc);
   1721 	if (IPMI_INVALID_SENSOR_P(data[1])) {
   1722 		/* Check if sensor is valid */
   1723 		edata->state = ENVSYS_SINVALID;
   1724 	} else {
   1725 		edata->state = ipmi_sensor_status(sc, psensor, edata, data);
   1726 	}
   1727 	return 0;
   1728 err:
   1729 	mutex_exit(&sc->sc_cmd_mtx);
   1730 	return -1;
   1731 }
   1732 
   1733 int
   1734 ipmi_sensor_type(int type, int ext_type, int entity)
   1735 {
   1736 	switch (ext_type << 8L | type) {
   1737 	case IPMI_SENSOR_TYPE_TEMP:
   1738 		return (ENVSYS_STEMP);
   1739 
   1740 	case IPMI_SENSOR_TYPE_VOLT:
   1741 		return (ENVSYS_SVOLTS_DC);
   1742 
   1743 	case IPMI_SENSOR_TYPE_FAN:
   1744 		return (ENVSYS_SFANRPM);
   1745 
   1746 	case IPMI_SENSOR_TYPE_PWRSUPPLY:
   1747 		if (entity == IPMI_ENTITY_PWRSUPPLY)
   1748 			return (ENVSYS_INDICATOR);
   1749 		break;
   1750 
   1751 	case IPMI_SENSOR_TYPE_INTRUSION:
   1752 		return (ENVSYS_INDICATOR);
   1753 	}
   1754 
   1755 	return (-1);
   1756 }
   1757 
   1758 /* Add Sensor to BSD Sysctl interface */
   1759 int
   1760 add_sdr_sensor(struct ipmi_softc *sc, uint8_t *psdr)
   1761 {
   1762 	int			rc;
   1763 	struct sdrtype1		*s1 = (struct sdrtype1 *)psdr;
   1764 	struct sdrtype2		*s2 = (struct sdrtype2 *)psdr;
   1765 	char			name[64];
   1766 
   1767 	switch (s1->sdrhdr.record_type) {
   1768 	case IPMI_SDR_TYPEFULL:
   1769 		ipmi_sensor_name(name, sizeof(name), s1->typelen, s1->name);
   1770 		rc = add_child_sensors(sc, psdr, 1, s1->sensor_num,
   1771 		    s1->sensor_type, s1->event_code, 0, s1->entity_id, name);
   1772 		break;
   1773 
   1774 	case IPMI_SDR_TYPECOMPACT:
   1775 		ipmi_sensor_name(name, sizeof(name), s2->typelen, s2->name);
   1776 		rc = add_child_sensors(sc, psdr, s2->share1 & 0xF,
   1777 		    s2->sensor_num, s2->sensor_type, s2->event_code,
   1778 		    s2->share2 & 0x7F, s2->entity_id, name);
   1779 		break;
   1780 
   1781 	default:
   1782 		return (0);
   1783 	}
   1784 
   1785 	return rc;
   1786 }
   1787 
   1788 static int
   1789 ipmi_is_dupname(char *name)
   1790 {
   1791 	struct ipmi_sensor *ipmi_s;
   1792 
   1793 	SLIST_FOREACH(ipmi_s, &ipmi_sensor_list, i_list) {
   1794 		if (strcmp(ipmi_s->i_envdesc, name) == 0) {
   1795 			return 1;
   1796 		}
   1797 	}
   1798 	return 0;
   1799 }
   1800 
   1801 int
   1802 add_child_sensors(struct ipmi_softc *sc, uint8_t *psdr, int count,
   1803     int sensor_num, int sensor_type, int ext_type, int sensor_base,
   1804     int entity, const char *name)
   1805 {
   1806 	int			typ, idx, dupcnt, c;
   1807 	char			*e;
   1808 	struct ipmi_sensor	*psensor;
   1809 	struct sdrtype1		*s1 = (struct sdrtype1 *)psdr;
   1810 
   1811 	typ = ipmi_sensor_type(sensor_type, ext_type, entity);
   1812 	if (typ == -1) {
   1813 		dbg_printf(5, "Unknown sensor type:%.2x et:%.2x sn:%.2x "
   1814 		    "name:%s\n", sensor_type, ext_type, sensor_num, name);
   1815 		return 0;
   1816 	}
   1817 	dupcnt = 0;
   1818 	sc->sc_nsensors += count;
   1819 	for (idx = 0; idx < count; idx++) {
   1820 		psensor = malloc(sizeof(struct ipmi_sensor), M_DEVBUF,
   1821 		    M_WAITOK|M_CANFAIL);
   1822 		if (psensor == NULL)
   1823 			break;
   1824 
   1825 		memset(psensor, 0, sizeof(struct ipmi_sensor));
   1826 
   1827 		/* Initialize BSD Sensor info */
   1828 		psensor->i_sdr = psdr;
   1829 		psensor->i_num = sensor_num + idx;
   1830 		psensor->i_stype = sensor_type;
   1831 		psensor->i_etype = ext_type;
   1832 		psensor->i_envtype = typ;
   1833 		if (count > 1)
   1834 			snprintf(psensor->i_envdesc,
   1835 			    sizeof(psensor->i_envdesc),
   1836 			    "%s - %d", name, sensor_base + idx);
   1837 		else
   1838 			strlcpy(psensor->i_envdesc, name,
   1839 			    sizeof(psensor->i_envdesc));
   1840 
   1841 		/*
   1842 		 * Check for duplicates.  If there are duplicates,
   1843 		 * make sure there is space in the name (if not,
   1844 		 * truncate to make space) for a count (1-99) to
   1845 		 * add to make the name unique.  If we run the
   1846 		 * counter out, just accept the duplicate (@name99)
   1847 		 * for now.
   1848 		 */
   1849 		if (ipmi_is_dupname(psensor->i_envdesc)) {
   1850 			if (strlen(psensor->i_envdesc) >=
   1851 			    sizeof(psensor->i_envdesc) - 3) {
   1852 				e = psensor->i_envdesc +
   1853 				    sizeof(psensor->i_envdesc) - 3;
   1854 			} else {
   1855 				e = psensor->i_envdesc +
   1856 				    strlen(psensor->i_envdesc);
   1857 			}
   1858 			c = psensor->i_envdesc +
   1859 			    sizeof(psensor->i_envdesc) - e;
   1860 			do {
   1861 				dupcnt++;
   1862 				snprintf(e, c, "%d", dupcnt);
   1863 			} while (dupcnt < 100 &&
   1864 			         ipmi_is_dupname(psensor->i_envdesc));
   1865 		}
   1866 
   1867 		dbg_printf(5, "add sensor:%.4x %.2x:%d ent:%.2x:%.2x %s\n",
   1868 		    s1->sdrhdr.record_id, s1->sensor_type,
   1869 		    typ, s1->entity_id, s1->entity_instance,
   1870 		    psensor->i_envdesc);
   1871 		SLIST_INSERT_HEAD(&ipmi_sensor_list, psensor, i_list);
   1872 	}
   1873 
   1874 	return (1);
   1875 }
   1876 
   1877 /* Interrupt handler */
   1878 int
   1879 ipmi_intr(void *arg)
   1880 {
   1881 	struct ipmi_softc	*sc = (struct ipmi_softc *)arg;
   1882 	int			v;
   1883 
   1884 	v = bmc_read(sc, _KCS_STATUS_REGISTER);
   1885 	if (v & KCS_OBF)
   1886 		++ipmi_nintr;
   1887 
   1888 	return (0);
   1889 }
   1890 
   1891 /* Handle IPMI Timer - reread sensor values */
   1892 void
   1893 ipmi_refresh_sensors(struct ipmi_softc *sc)
   1894 {
   1895 
   1896 	if (SLIST_EMPTY(&ipmi_sensor_list))
   1897 		return;
   1898 
   1899 	sc->current_sensor = SLIST_NEXT(sc->current_sensor, i_list);
   1900 	if (sc->current_sensor == NULL)
   1901 		sc->current_sensor = SLIST_FIRST(&ipmi_sensor_list);
   1902 
   1903 	if (read_sensor(sc, sc->current_sensor)) {
   1904 		dbg_printf(1, "ipmi: error reading\n");
   1905 	}
   1906 }
   1907 
   1908 int
   1909 ipmi_map_regs(struct ipmi_softc *sc, struct ipmi_attach_args *ia)
   1910 {
   1911 	sc->sc_if = ipmi_get_if(ia->iaa_if_type);
   1912 	if (sc->sc_if == NULL)
   1913 		return (-1);
   1914 
   1915 	if (ia->iaa_if_iotype == 'i')
   1916 		sc->sc_iot = ia->iaa_iot;
   1917 	else
   1918 		sc->sc_iot = ia->iaa_memt;
   1919 
   1920 	sc->sc_if_rev = ia->iaa_if_rev;
   1921 	sc->sc_if_iospacing = ia->iaa_if_iospacing;
   1922 	if (bus_space_map(sc->sc_iot, ia->iaa_if_iobase,
   1923 	    sc->sc_if->nregs * sc->sc_if_iospacing,
   1924 	    0, &sc->sc_ioh)) {
   1925 		printf("ipmi: bus_space_map(..., %x, %x, 0, %p) failed\n",
   1926 		    ia->iaa_if_iobase,
   1927 		    sc->sc_if->nregs * sc->sc_if_iospacing, &sc->sc_ioh);
   1928 		return (-1);
   1929 	}
   1930 #if 0
   1931 	if (iaa->if_if_irq != -1)
   1932 		sc->ih = isa_intr_establish(-1, iaa->if_if_irq,
   1933 		    iaa->if_irqlvl, IPL_BIO, ipmi_intr, sc,
   1934 		    device_xname(sc->sc_dev);
   1935 #endif
   1936 	return (0);
   1937 }
   1938 
   1939 void
   1940 ipmi_unmap_regs(struct ipmi_softc *sc)
   1941 {
   1942 	bus_space_unmap(sc->sc_iot, sc->sc_ioh,
   1943 	    sc->sc_if->nregs * sc->sc_if_iospacing);
   1944 }
   1945 
   1946 int
   1947 ipmi_probe(struct ipmi_attach_args *ia)
   1948 {
   1949 	struct dmd_ipmi *pipmi;
   1950 	struct smbtable tbl;
   1951 
   1952 	tbl.cookie = 0;
   1953 
   1954 	if (smbios_find_table(SMBIOS_TYPE_IPMIDEV, &tbl))
   1955 		ipmi_smbios_probe(tbl.tblhdr, ia);
   1956 	else {
   1957 		pipmi = (struct dmd_ipmi *)scan_sig(0xC0000L, 0xFFFFFL, 16, 4,
   1958 		    "IPMI");
   1959 		/* XXX hack to find Dell PowerEdge 8450 */
   1960 		if (pipmi == NULL) {
   1961 			/* no IPMI found */
   1962 			return (0);
   1963 		}
   1964 
   1965 		/* we have an IPMI signature, fill in attach arg structure */
   1966 		ia->iaa_if_type = pipmi->dmd_if_type;
   1967 		ia->iaa_if_rev = pipmi->dmd_if_rev;
   1968 	}
   1969 
   1970 	return (1);
   1971 }
   1972 
   1973 int
   1974 ipmi_match(device_t parent, cfdata_t cf, void *aux)
   1975 {
   1976 	struct ipmi_softc sc;
   1977 	struct ipmi_attach_args *ia = aux;
   1978 	uint8_t		cmd[32];
   1979 	int			len;
   1980 	int			rv = 0;
   1981 
   1982 	memset(&sc, 0, sizeof(sc));
   1983 
   1984 	/* Map registers */
   1985 	if (ipmi_map_regs(&sc, ia) != 0)
   1986 		return 0;
   1987 
   1988 	sc.sc_if->probe(&sc);
   1989 
   1990 	mutex_init(&sc.sc_cmd_mtx, MUTEX_DEFAULT, IPL_SOFTCLOCK);
   1991 	cv_init(&sc.sc_cmd_sleep, "ipmimtch");
   1992 	mutex_enter(&sc.sc_cmd_mtx);
   1993 	/* Identify BMC device early to detect lying bios */
   1994 	if (ipmi_sendcmd(&sc, BMC_SA, 0, APP_NETFN, APP_GET_DEVICE_ID,
   1995 	    0, NULL)) {
   1996 		mutex_exit(&sc.sc_cmd_mtx);
   1997 		dbg_printf(1, ": unable to send get device id "
   1998 		    "command\n");
   1999 		goto unmap;
   2000 	}
   2001 	if (ipmi_recvcmd(&sc, sizeof(cmd), &len, cmd)) {
   2002 		mutex_exit(&sc.sc_cmd_mtx);
   2003 		dbg_printf(1, ": unable to retrieve device id\n");
   2004 		goto unmap;
   2005 	}
   2006 	mutex_exit(&sc.sc_cmd_mtx);
   2007 
   2008 	dbg_dump(1, "bmc data", len, cmd);
   2009 	rv = 1; /* GETID worked, we got IPMI */
   2010 unmap:
   2011 	cv_destroy(&sc.sc_cmd_sleep);
   2012 	mutex_destroy(&sc.sc_cmd_mtx);
   2013 	ipmi_unmap_regs(&sc);
   2014 
   2015 	return rv;
   2016 }
   2017 
   2018 static void
   2019 ipmi_thread(void *cookie)
   2020 {
   2021 	device_t		self = cookie;
   2022 	struct ipmi_softc	*sc = device_private(self);
   2023 	struct ipmi_attach_args *ia = &sc->sc_ia;
   2024 	uint16_t		rec;
   2025 	struct ipmi_sensor *ipmi_s;
   2026 	int i;
   2027 
   2028 	sc->sc_thread_running = true;
   2029 
   2030 	/* setup ticker */
   2031 	sc->sc_max_retries = hz * 90; /* 90 seconds max */
   2032 
   2033 	/* Map registers */
   2034 	ipmi_map_regs(sc, ia);
   2035 
   2036 	/* Scan SDRs, add sensors to list */
   2037 	for (rec = 0; rec != 0xFFFF;)
   2038 		if (get_sdr(sc, rec, &rec))
   2039 			break;
   2040 
   2041 	/* allocate and fill sensor arrays */
   2042 	sc->sc_sensor =
   2043 	    malloc(sizeof(envsys_data_t) * sc->sc_nsensors,
   2044 	        M_DEVBUF, M_WAITOK | M_ZERO);
   2045 	if (sc->sc_sensor == NULL) {
   2046 		aprint_error("ipmi: can't allocate envsys_data_t\n");
   2047 		kthread_exit(0);
   2048 	}
   2049 
   2050 	sc->sc_envsys = sysmon_envsys_create();
   2051 	sc->sc_envsys->sme_cookie = sc;
   2052 	sc->sc_envsys->sme_get_limits = ipmi_get_limits;
   2053 	sc->sc_envsys->sme_set_limits = ipmi_set_limits;
   2054 
   2055 	i = 0;
   2056 	SLIST_FOREACH(ipmi_s, &ipmi_sensor_list, i_list) {
   2057 		ipmi_s->i_props = 0;
   2058 		ipmi_s->i_envnum = -1;
   2059 		sc->sc_sensor[i].units = ipmi_s->i_envtype;
   2060 		sc->sc_sensor[i].state = ENVSYS_SINVALID;
   2061 		sc->sc_sensor[i].flags |= ENVSYS_FHAS_ENTROPY;
   2062 		/*
   2063 		 * Monitor threshold limits in the sensors.
   2064 		 */
   2065 		switch (sc->sc_sensor[i].units) {
   2066 		case ENVSYS_STEMP:
   2067 		case ENVSYS_SVOLTS_DC:
   2068 		case ENVSYS_SFANRPM:
   2069 			sc->sc_sensor[i].flags |= ENVSYS_FMONLIMITS;
   2070 			break;
   2071 		default:
   2072 			sc->sc_sensor[i].flags |= ENVSYS_FMONCRITICAL;
   2073 		}
   2074 		(void)strlcpy(sc->sc_sensor[i].desc, ipmi_s->i_envdesc,
   2075 		    sizeof(sc->sc_sensor[i].desc));
   2076 		++i;
   2077 
   2078 		if (sysmon_envsys_sensor_attach(sc->sc_envsys,
   2079 						&sc->sc_sensor[i-1]))
   2080 			continue;
   2081 
   2082 		/* get reference number from envsys */
   2083 		ipmi_s->i_envnum = sc->sc_sensor[i-1].sensor;
   2084 	}
   2085 
   2086 	sc->sc_envsys->sme_name = device_xname(sc->sc_dev);
   2087 	sc->sc_envsys->sme_flags = SME_DISABLE_REFRESH;
   2088 
   2089 	if (sysmon_envsys_register(sc->sc_envsys)) {
   2090 		aprint_error("ipmi: unable to register with sysmon\n");
   2091 		sysmon_envsys_destroy(sc->sc_envsys);
   2092 	}
   2093 
   2094 	/* initialize sensor list for thread */
   2095 	if (!SLIST_EMPTY(&ipmi_sensor_list))
   2096 		sc->current_sensor = SLIST_FIRST(&ipmi_sensor_list);
   2097 
   2098 	aprint_verbose_dev(self, "version %d.%d interface %s %sbase "
   2099 	    "0x%x/%x spacing %d\n",
   2100 	    ia->iaa_if_rev >> 4, ia->iaa_if_rev & 0xF, sc->sc_if->name,
   2101 	    ia->iaa_if_iotype == 'i' ? "io" : "mem", ia->iaa_if_iobase,
   2102 	    ia->iaa_if_iospacing * sc->sc_if->nregs, ia->iaa_if_iospacing);
   2103 	if (ia->iaa_if_irq != -1)
   2104 		aprint_verbose_dev(self, " irq %d\n", ia->iaa_if_irq);
   2105 
   2106 	/* setup flag to exclude iic */
   2107 	ipmi_enabled = 1;
   2108 
   2109 	/* Setup Watchdog timer */
   2110 	sc->sc_wdog.smw_name = device_xname(sc->sc_dev);
   2111 	sc->sc_wdog.smw_cookie = sc;
   2112 	sc->sc_wdog.smw_setmode = ipmi_watchdog_setmode;
   2113 	sc->sc_wdog.smw_tickle = ipmi_watchdog_tickle;
   2114 	sysmon_wdog_register(&sc->sc_wdog);
   2115 
   2116 	/* Set up a power handler so we can possibly sleep */
   2117 	if (!pmf_device_register(self, ipmi_suspend, NULL))
   2118                 aprint_error_dev(self, "couldn't establish a power handler\n");
   2119 
   2120 	mutex_enter(&sc->sc_poll_mtx);
   2121 	while (sc->sc_thread_running) {
   2122 		ipmi_refresh_sensors(sc);
   2123 		cv_timedwait(&sc->sc_poll_cv, &sc->sc_poll_mtx,
   2124 		    SENSOR_REFRESH_RATE);
   2125 		if (sc->sc_tickle_due) {
   2126 			ipmi_dotickle(sc);
   2127 			sc->sc_tickle_due = false;
   2128 		}
   2129 	}
   2130 	mutex_exit(&sc->sc_poll_mtx);
   2131 	kthread_exit(0);
   2132 }
   2133 
   2134 void
   2135 ipmi_attach(device_t parent, device_t self, void *aux)
   2136 {
   2137 	struct ipmi_softc	*sc = device_private(self);
   2138 
   2139 	sc->sc_ia = *(struct ipmi_attach_args *)aux;
   2140 	sc->sc_dev = self;
   2141 	aprint_naive("\n");
   2142 	aprint_normal("\n");
   2143 
   2144 	/* lock around read_sensor so that no one messes with the bmc regs */
   2145 	mutex_init(&sc->sc_cmd_mtx, MUTEX_DEFAULT, IPL_SOFTCLOCK);
   2146 	mutex_init(&sc->sc_sleep_mtx, MUTEX_DEFAULT, IPL_SOFTCLOCK);
   2147 	cv_init(&sc->sc_cmd_sleep, "ipmicmd");
   2148 
   2149 	mutex_init(&sc->sc_poll_mtx, MUTEX_DEFAULT, IPL_SOFTCLOCK);
   2150 	cv_init(&sc->sc_poll_cv, "ipmipoll");
   2151 
   2152 	if (kthread_create(PRI_NONE, 0, NULL, ipmi_thread, self,
   2153 	    &sc->sc_kthread, "ipmi") != 0) {
   2154 		aprint_error("ipmi: unable to create thread, disabled\n");
   2155 	}
   2156 }
   2157 
   2158 static int
   2159 ipmi_detach(device_t self, int flags)
   2160 {
   2161 	struct ipmi_sensor *i;
   2162 	int rc;
   2163 	struct ipmi_softc *sc = device_private(self);
   2164 
   2165 	mutex_enter(&sc->sc_poll_mtx);
   2166 	sc->sc_thread_running = false;
   2167 	cv_signal(&sc->sc_poll_cv);
   2168 	mutex_exit(&sc->sc_poll_mtx);
   2169 
   2170 	if ((rc = sysmon_wdog_unregister(&sc->sc_wdog)) != 0) {
   2171 		if (rc == ERESTART)
   2172 			rc = EINTR;
   2173 		return rc;
   2174 	}
   2175 
   2176 	/* cancel any pending countdown */
   2177 	sc->sc_wdog.smw_mode &= ~WDOG_MODE_MASK;
   2178 	sc->sc_wdog.smw_mode |= WDOG_MODE_DISARMED;
   2179 	sc->sc_wdog.smw_period = WDOG_PERIOD_DEFAULT;
   2180 
   2181 	if ((rc = ipmi_watchdog_setmode(&sc->sc_wdog)) != 0)
   2182 		return rc;
   2183 
   2184 	ipmi_enabled = 0;
   2185 
   2186 	if (sc->sc_envsys != NULL) {
   2187 		/* _unregister also destroys */
   2188 		sysmon_envsys_unregister(sc->sc_envsys);
   2189 		sc->sc_envsys = NULL;
   2190 	}
   2191 
   2192 	while ((i = SLIST_FIRST(&ipmi_sensor_list)) != NULL) {
   2193 		SLIST_REMOVE_HEAD(&ipmi_sensor_list, i_list);
   2194 		free(i, M_DEVBUF);
   2195 	}
   2196 
   2197 	if (sc->sc_sensor != NULL) {
   2198 		free(sc->sc_sensor, M_DEVBUF);
   2199 		sc->sc_sensor = NULL;
   2200 	}
   2201 
   2202 	ipmi_unmap_regs(sc);
   2203 
   2204 	cv_destroy(&sc->sc_poll_cv);
   2205 	mutex_destroy(&sc->sc_poll_mtx);
   2206 	cv_destroy(&sc->sc_cmd_sleep);
   2207 	mutex_destroy(&sc->sc_sleep_mtx);
   2208 	mutex_destroy(&sc->sc_cmd_mtx);
   2209 
   2210 	return 0;
   2211 }
   2212 
   2213 int
   2214 ipmi_watchdog_setmode(struct sysmon_wdog *smwdog)
   2215 {
   2216 	struct ipmi_softc	*sc = smwdog->smw_cookie;
   2217 	struct ipmi_get_watchdog gwdog;
   2218 	struct ipmi_set_watchdog swdog;
   2219 	int			rc, len;
   2220 
   2221 	if (smwdog->smw_period < 10)
   2222 		return EINVAL;
   2223 	if (smwdog->smw_period == WDOG_PERIOD_DEFAULT)
   2224 		sc->sc_wdog.smw_period = 10;
   2225 	else
   2226 		sc->sc_wdog.smw_period = smwdog->smw_period;
   2227 
   2228 	mutex_enter(&sc->sc_cmd_mtx);
   2229 	/* see if we can properly task to the watchdog */
   2230 	rc = ipmi_sendcmd(sc, BMC_SA, BMC_LUN, APP_NETFN,
   2231 	    APP_GET_WATCHDOG_TIMER, 0, NULL);
   2232 	rc = ipmi_recvcmd(sc, sizeof(gwdog), &len, &gwdog);
   2233 	mutex_exit(&sc->sc_cmd_mtx);
   2234 	if (rc) {
   2235 		printf("ipmi: APP_GET_WATCHDOG_TIMER returned 0x%x\n", rc);
   2236 		return EIO;
   2237 	}
   2238 
   2239 	memset(&swdog, 0, sizeof(swdog));
   2240 	/* Period is 10ths/sec */
   2241 	swdog.wdog_timeout = htole16(sc->sc_wdog.smw_period * 10);
   2242 	if ((smwdog->smw_mode & WDOG_MODE_MASK) == WDOG_MODE_DISARMED)
   2243 		swdog.wdog_action = IPMI_WDOG_ACT_DISABLED;
   2244 	else
   2245 		swdog.wdog_action = IPMI_WDOG_ACT_RESET;
   2246 	swdog.wdog_use = IPMI_WDOG_USE_USE_OS;
   2247 
   2248 	mutex_enter(&sc->sc_cmd_mtx);
   2249 	if ((rc = ipmi_sendcmd(sc, BMC_SA, BMC_LUN, APP_NETFN,
   2250 	    APP_SET_WATCHDOG_TIMER, sizeof(swdog), &swdog)) == 0)
   2251 		rc = ipmi_recvcmd(sc, 0, &len, NULL);
   2252 	mutex_exit(&sc->sc_cmd_mtx);
   2253 	if (rc) {
   2254 		printf("ipmi: APP_SET_WATCHDOG_TIMER returned 0x%x\n", rc);
   2255 		return EIO;
   2256 	}
   2257 
   2258 	return (0);
   2259 }
   2260 
   2261 int
   2262 ipmi_watchdog_tickle(struct sysmon_wdog *smwdog)
   2263 {
   2264 	struct ipmi_softc	*sc = smwdog->smw_cookie;
   2265 
   2266 	mutex_enter(&sc->sc_poll_mtx);
   2267 	sc->sc_tickle_due = true;
   2268 	cv_signal(&sc->sc_poll_cv);
   2269 	mutex_exit(&sc->sc_poll_mtx);
   2270 	return 0;
   2271 }
   2272 
   2273 void
   2274 ipmi_dotickle(struct ipmi_softc *sc)
   2275 {
   2276 	int			rc, len;
   2277 
   2278 	mutex_enter(&sc->sc_cmd_mtx);
   2279 	/* tickle the watchdog */
   2280 	if ((rc = ipmi_sendcmd(sc, BMC_SA, BMC_LUN, APP_NETFN,
   2281 	    APP_RESET_WATCHDOG, 0, NULL)) == 0)
   2282 		rc = ipmi_recvcmd(sc, 0, &len, NULL);
   2283 	mutex_exit(&sc->sc_cmd_mtx);
   2284 	if (rc != 0) {
   2285 		printf("%s: watchdog tickle returned 0x%x\n",
   2286 		    device_xname(sc->sc_dev), rc);
   2287 	}
   2288 }
   2289 
   2290 bool
   2291 ipmi_suspend(device_t dev, const pmf_qual_t *qual)
   2292 {
   2293 	struct ipmi_softc *sc = device_private(dev);
   2294 
   2295 	/* Don't allow suspend if watchdog is armed */
   2296 	if ((sc->sc_wdog.smw_mode & WDOG_MODE_MASK) != WDOG_MODE_DISARMED)
   2297 		return false;
   2298 	return true;
   2299 }
   2300