d72a078647
- Split out the communication protocols into their own files and use a couple of function pointers in the softc that the commuication protocols setup in their own attach routine. - Add support for the SSIF interface (talking to IPMI over SMBus). - Add an ACPI attachment. - Add a PCI attachment that attaches to devices with the IPMI interface subclass. - Split the ISA attachment out into its own file: ipmi_isa.c. - Change the code to probe the SMBIOS table for an IPMI entry to just use pmap_mapbios() to map the table in rather than trying to setup a fake resource on an isa device and then activating the resource to map in the table. - Make bus attachments leaner by adding attach functions for each communication interface (ipmi_kcs_attach(), ipmi_smic_attach(), etc.) that setup per-interface data. - Formalize the model used by the driver to handle requests by adding an explicit struct ipmi_request object that holds the state of a given request and reply for the entire lifetime of the request. By bundling the request into an object, it is easier to add retry logic to the various communication backends (as well as eventually support BT mode which uses a slightly different message format than KCS, SMIC, and SSIF). - Add a per-softc lock and remove D_NEEDGIANT as the driver is now MPSAFE. - Add 32-bit compatibility ioctl shims so you can use a 32-bit ipmitool on FreeBSD/amd64. - Add ipmi(4) to i386 and amd64 NOTES. Submitted by: ambrisko (large portions of 2 and 3) Sponsored by: IronPort Systems, Yahoo! MFC after: 6 days
608 lines
14 KiB
C
608 lines
14 KiB
C
/*-
|
|
* Copyright (c) 2006 IronPort Systems Inc. <ambrisko@ironport.com>
|
|
* 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.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
* 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 AUTHOR 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>
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/bus.h>
|
|
#include <sys/condvar.h>
|
|
#include <sys/eventhandler.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/kthread.h>
|
|
#include <sys/rman.h>
|
|
#include <sys/selinfo.h>
|
|
#include <machine/bus.h>
|
|
|
|
#ifdef LOCAL_MODULE
|
|
#include <ipmi.h>
|
|
#include <ipmivars.h>
|
|
#else
|
|
#include <sys/ipmi.h>
|
|
#include <dev/ipmi/ipmivars.h>
|
|
#endif
|
|
|
|
static void kcs_clear_obf(struct ipmi_softc *, int);
|
|
static void kcs_error(struct ipmi_softc *);
|
|
static int kcs_wait_for_ibf(struct ipmi_softc *, int);
|
|
static int kcs_wait_for_obf(struct ipmi_softc *, int);
|
|
|
|
static int
|
|
kcs_wait_for_ibf(struct ipmi_softc *sc, int state)
|
|
{
|
|
int status, start = ticks;
|
|
|
|
status = INB(sc, KCS_CTL_STS);
|
|
if (state == 0) {
|
|
/* WAIT FOR IBF = 0 */
|
|
while (ticks - start < MAX_TIMEOUT && status & KCS_STATUS_IBF) {
|
|
DELAY(100);
|
|
status = INB(sc, KCS_CTL_STS);
|
|
}
|
|
} else {
|
|
/* WAIT FOR IBF = 1 */
|
|
while (ticks - start < MAX_TIMEOUT &&
|
|
!(status & KCS_STATUS_IBF)) {
|
|
DELAY(100);
|
|
status = INB(sc, KCS_CTL_STS);
|
|
}
|
|
}
|
|
return (status);
|
|
}
|
|
|
|
static int
|
|
kcs_wait_for_obf(struct ipmi_softc *sc, int state)
|
|
{
|
|
int status, start = ticks;
|
|
|
|
status = INB(sc, KCS_CTL_STS);
|
|
if (state == 0) {
|
|
/* WAIT FOR OBF = 0 */
|
|
while (ticks - start < MAX_TIMEOUT && status & KCS_STATUS_OBF) {
|
|
DELAY(100);
|
|
status = INB(sc, KCS_CTL_STS);
|
|
}
|
|
} else {
|
|
/* WAIT FOR OBF = 1 */
|
|
while (ticks - start < MAX_TIMEOUT &&
|
|
!(status & KCS_STATUS_OBF)) {
|
|
DELAY(100);
|
|
status = INB(sc, KCS_CTL_STS);
|
|
}
|
|
}
|
|
return (status);
|
|
}
|
|
|
|
static void
|
|
kcs_clear_obf(struct ipmi_softc *sc, int status)
|
|
{
|
|
int data;
|
|
|
|
/* Clear OBF */
|
|
if (status & KCS_STATUS_OBF) {
|
|
data = INB(sc, KCS_DATA);
|
|
}
|
|
}
|
|
|
|
static void
|
|
kcs_error(struct ipmi_softc *sc)
|
|
{
|
|
int retry, status;
|
|
u_char data;
|
|
|
|
for (retry = 0; retry < 2; retry++) {
|
|
|
|
/* Wait for IBF = 0 */
|
|
status = kcs_wait_for_ibf(sc, 0);
|
|
|
|
/* ABORT */
|
|
OUTB(sc, KCS_CTL_STS, KCS_CONTROL_GET_STATUS_ABORT);
|
|
|
|
/* Wait for IBF = 0 */
|
|
status = kcs_wait_for_ibf(sc, 0);
|
|
|
|
/* Clear OBF */
|
|
kcs_clear_obf(sc, status);
|
|
|
|
if (status & KCS_STATUS_OBF) {
|
|
data = INB(sc, KCS_DATA);
|
|
if (data != 0)
|
|
device_printf(sc->ipmi_dev,
|
|
"KCS Error Data %02x\n", data);
|
|
}
|
|
|
|
/* 0x00 to DATA_IN */
|
|
OUTB(sc, KCS_DATA, 0x00);
|
|
|
|
/* Wait for IBF = 0 */
|
|
status = kcs_wait_for_ibf(sc, 0);
|
|
|
|
if (KCS_STATUS_STATE(status) == KCS_STATUS_STATE_READ) {
|
|
|
|
/* Wait for OBF = 1 */
|
|
status = kcs_wait_for_obf(sc, 1);
|
|
|
|
/* Read error status */
|
|
data = INB(sc, KCS_DATA);
|
|
if (data != 0)
|
|
device_printf(sc->ipmi_dev, "KCS error: %02x\n",
|
|
data);
|
|
|
|
/* Write READ into Data_in */
|
|
OUTB(sc, KCS_DATA, KCS_DATA_IN_READ);
|
|
|
|
/* Wait for IBF = 0 */
|
|
status = kcs_wait_for_ibf(sc, 0);
|
|
}
|
|
|
|
/* IDLE STATE */
|
|
if (KCS_STATUS_STATE(status) == KCS_STATUS_STATE_IDLE) {
|
|
/* Wait for OBF = 1 */
|
|
status = kcs_wait_for_obf(sc, 1);
|
|
|
|
/* Clear OBF */
|
|
kcs_clear_obf(sc, status);
|
|
return;
|
|
}
|
|
}
|
|
device_printf(sc->ipmi_dev, "KCS Error retry exhausted\n");
|
|
}
|
|
|
|
/*
|
|
* Start to write a request. Waits for IBF to clear and then sends the
|
|
* WR_START command.
|
|
*/
|
|
static int
|
|
kcs_start_write(struct ipmi_softc *sc)
|
|
{
|
|
int retry, status;
|
|
|
|
for (retry = 0; retry < 10; retry++) {
|
|
/* Wait for IBF = 0 */
|
|
status = kcs_wait_for_ibf(sc, 0);
|
|
|
|
/* Clear OBF */
|
|
kcs_clear_obf(sc, status);
|
|
|
|
/* Write start to command */
|
|
OUTB(sc, KCS_CTL_STS, KCS_CONTROL_WRITE_START);
|
|
|
|
/* Wait for IBF = 0 */
|
|
status = kcs_wait_for_ibf(sc, 0);
|
|
if (KCS_STATUS_STATE(status) == KCS_STATUS_STATE_WRITE)
|
|
break;
|
|
DELAY(1000000);
|
|
}
|
|
|
|
if (KCS_STATUS_STATE(status) != KCS_STATUS_STATE_WRITE)
|
|
/* error state */
|
|
return (0);
|
|
|
|
/* Clear OBF */
|
|
kcs_clear_obf(sc, status);
|
|
|
|
return (1);
|
|
}
|
|
|
|
/*
|
|
* Write a byte of the request message, excluding the last byte of the
|
|
* message which requires special handling.
|
|
*/
|
|
static int
|
|
kcs_write_byte(struct ipmi_softc *sc, u_char data)
|
|
{
|
|
int status;
|
|
|
|
/* Data to Data */
|
|
OUTB(sc, KCS_DATA, data);
|
|
|
|
/* Wait for IBF = 0 */
|
|
status = kcs_wait_for_ibf(sc, 0);
|
|
|
|
if (KCS_STATUS_STATE(status) != KCS_STATUS_STATE_WRITE)
|
|
return (0);
|
|
|
|
/* Clear OBF */
|
|
kcs_clear_obf(sc, status);
|
|
return (1);
|
|
}
|
|
|
|
/*
|
|
* Write the last byte of a request message.
|
|
*/
|
|
static int
|
|
kcs_write_last_byte(struct ipmi_softc *sc, u_char data)
|
|
{
|
|
int status;
|
|
|
|
/* Write end to command */
|
|
OUTB(sc, KCS_CTL_STS, KCS_CONTROL_WRITE_END);
|
|
|
|
/* Wait for IBF = 0 */
|
|
status = kcs_wait_for_ibf(sc, 0);
|
|
|
|
if (KCS_STATUS_STATE(status) != KCS_STATUS_STATE_WRITE)
|
|
/* error state */
|
|
return (0);
|
|
|
|
/* Clear OBF */
|
|
kcs_clear_obf(sc, status);
|
|
|
|
/* Send data byte to DATA. */
|
|
OUTB(sc, KCS_DATA, data);
|
|
return (1);
|
|
}
|
|
|
|
/*
|
|
* Read one byte of the reply message.
|
|
*/
|
|
static int
|
|
kcs_read_byte(struct ipmi_softc *sc, u_char *data)
|
|
{
|
|
int status;
|
|
u_char dummy;
|
|
|
|
/* Wait for IBF = 0 */
|
|
status = kcs_wait_for_ibf(sc, 0);
|
|
|
|
/* Read State */
|
|
if (KCS_STATUS_STATE(status) == KCS_STATUS_STATE_READ) {
|
|
|
|
/* Wait for OBF = 1 */
|
|
status = kcs_wait_for_obf(sc, 1);
|
|
|
|
/* Read Data_out */
|
|
*data = INB(sc, KCS_DATA);
|
|
|
|
/* Write READ into Data_in */
|
|
OUTB(sc, KCS_DATA, KCS_DATA_IN_READ);
|
|
return (1);
|
|
}
|
|
|
|
/* Idle State */
|
|
if (KCS_STATUS_STATE(status) == KCS_STATUS_STATE_IDLE) {
|
|
|
|
/* Wait for OBF = 1*/
|
|
status = kcs_wait_for_obf(sc, 1);
|
|
|
|
/* Read Dummy */
|
|
dummy = INB(sc, KCS_DATA);
|
|
return (2);
|
|
}
|
|
|
|
/* Error State */
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Send a request message and collect the reply. Returns true if we
|
|
* succeed.
|
|
*/
|
|
static int
|
|
kcs_polled_request(struct ipmi_softc *sc, struct ipmi_request *req)
|
|
{
|
|
u_char *cp, data;
|
|
int i, state;
|
|
|
|
/* Send the request. */
|
|
if (!kcs_start_write(sc)) {
|
|
device_printf(sc->ipmi_dev, "KCS: Failed to start write\n");
|
|
goto fail;
|
|
}
|
|
#ifdef KCS_DEBUG
|
|
device_printf(sc->ipmi_dev, "KCS: WRITE_START... ok\n");
|
|
#endif
|
|
|
|
if (!kcs_write_byte(sc, req->ir_addr)) {
|
|
device_printf(sc->ipmi_dev, "KCS: Failed to write address\n");
|
|
goto fail;
|
|
}
|
|
#ifdef KCS_DEBUG
|
|
device_printf(sc->ipmi_dev, "KCS: Wrote address: %02x\n", req->ir_addr);
|
|
#endif
|
|
|
|
if (req->ir_requestlen == 0) {
|
|
if (!kcs_write_last_byte(sc, req->ir_command)) {
|
|
device_printf(sc->ipmi_dev,
|
|
"KCS: Failed to write command\n");
|
|
goto fail;
|
|
}
|
|
#ifdef KCS_DEBUG
|
|
device_printf(sc->ipmi_dev, "KCS: Wrote command: %02x\n",
|
|
req->ir_command);
|
|
#endif
|
|
} else {
|
|
if (!kcs_write_byte(sc, req->ir_command)) {
|
|
device_printf(sc->ipmi_dev,
|
|
"KCS: Failed to write command\n");
|
|
goto fail;
|
|
}
|
|
#ifdef KCS_DEBUG
|
|
device_printf(sc->ipmi_dev, "KCS: Wrote command: %02x\n",
|
|
req->ir_command);
|
|
#endif
|
|
|
|
cp = req->ir_request;
|
|
for (i = 0; i < req->ir_requestlen - 1; i++) {
|
|
if (!kcs_write_byte(sc, *cp++)) {
|
|
device_printf(sc->ipmi_dev,
|
|
"KCS: Failed to write data byte %d\n",
|
|
i + 1);
|
|
goto fail;
|
|
}
|
|
#ifdef KCS_DEBUG
|
|
device_printf(sc->ipmi_dev, "KCS: Wrote data: %02x\n",
|
|
cp[-1]);
|
|
#endif
|
|
}
|
|
|
|
if (!kcs_write_last_byte(sc, *cp)) {
|
|
device_printf(sc->ipmi_dev,
|
|
"KCS: Failed to write last dta byte\n");
|
|
goto fail;
|
|
}
|
|
#ifdef KCS_DEBUG
|
|
device_printf(sc->ipmi_dev, "KCS: Wrote last data: %02x\n",
|
|
*cp);
|
|
#endif
|
|
}
|
|
|
|
/* Read the reply. First, read the NetFn/LUN. */
|
|
if (kcs_read_byte(sc, &data) != 1) {
|
|
device_printf(sc->ipmi_dev, "KCS: Failed to read address\n");
|
|
goto fail;
|
|
}
|
|
#ifdef KCS_DEBUG
|
|
device_printf(sc->ipmi_dev, "KCS: Read address: %02x\n", data);
|
|
#endif
|
|
if (data != IPMI_REPLY_ADDR(req->ir_addr)) {
|
|
device_printf(sc->ipmi_dev, "KCS: Reply address mismatch\n");
|
|
goto fail;
|
|
}
|
|
|
|
/* Next we read the command. */
|
|
if (kcs_read_byte(sc, &data) != 1) {
|
|
device_printf(sc->ipmi_dev, "KCS: Failed to read command\n");
|
|
goto fail;
|
|
}
|
|
#ifdef KCS_DEBUG
|
|
device_printf(sc->ipmi_dev, "KCS: Read command: %02x\n", data);
|
|
#endif
|
|
if (data != req->ir_command) {
|
|
device_printf(sc->ipmi_dev, "KCS: Command mismatch\n");
|
|
goto fail;
|
|
}
|
|
|
|
/* Next we read the completion code. */
|
|
if (kcs_read_byte(sc, &req->ir_compcode) != 1) {
|
|
device_printf(sc->ipmi_dev,
|
|
"KCS: Failed to read completion code\n");
|
|
goto fail;
|
|
}
|
|
#ifdef KCS_DEBUG
|
|
device_printf(sc->ipmi_dev, "KCS: Read completion code: %02x\n",
|
|
req->ir_compcode);
|
|
#endif
|
|
|
|
/* Finally, read the reply from the BMC. */
|
|
i = 0;
|
|
for (;;) {
|
|
state = kcs_read_byte(sc, &data);
|
|
if (state == 0) {
|
|
device_printf(sc->ipmi_dev,
|
|
"KCS: Read failed on byte %d\n", i + 1);
|
|
goto fail;
|
|
}
|
|
if (state == 2)
|
|
break;
|
|
if (i < req->ir_replybuflen) {
|
|
req->ir_reply[i] = data;
|
|
#ifdef KCS_DEBUG
|
|
device_printf(sc->ipmi_dev, "KCS: Read data %02x\n",
|
|
data);
|
|
} else {
|
|
device_printf(sc->ipmi_dev,
|
|
"KCS: Read short %02x byte %d\n", data, i + 1);
|
|
#endif
|
|
}
|
|
i++;
|
|
}
|
|
req->ir_replylen = i;
|
|
#ifdef KCS_DEBUG
|
|
device_printf(sc->ipmi_dev, "KCS: READ finished (%d bytes)\n", i);
|
|
if (req->ir_replybuflen < i)
|
|
#else
|
|
if (req->ir_replybuflen < i && req->ir_replybuflen != 0)
|
|
#endif
|
|
device_printf(sc->ipmi_dev,
|
|
"KCS: Read short: %zd buffer, %d actual\n",
|
|
req->ir_replybuflen, i);
|
|
return (1);
|
|
fail:
|
|
kcs_error(sc);
|
|
return (0);
|
|
}
|
|
|
|
static void
|
|
kcs_loop(void *arg)
|
|
{
|
|
struct ipmi_softc *sc = arg;
|
|
struct ipmi_request *req;
|
|
int i, ok;
|
|
|
|
IPMI_LOCK(sc);
|
|
while ((req = ipmi_dequeue_request(sc)) != NULL) {
|
|
ok = 0;
|
|
for (i = 0; i < 3 && !ok; i++)
|
|
ok = kcs_polled_request(sc, req);
|
|
if (ok)
|
|
req->ir_error = 0;
|
|
else
|
|
req->ir_error = EIO;
|
|
ipmi_complete_request(sc, req);
|
|
}
|
|
IPMI_UNLOCK(sc);
|
|
kthread_exit(0);
|
|
}
|
|
|
|
static int
|
|
kcs_startup(struct ipmi_softc *sc)
|
|
{
|
|
|
|
return (kthread_create(kcs_loop, sc, &sc->ipmi_kthread, 0, 0, "%s: kcs",
|
|
device_get_nameunit(sc->ipmi_dev)));
|
|
}
|
|
|
|
int
|
|
ipmi_kcs_attach(struct ipmi_softc *sc)
|
|
{
|
|
int status;
|
|
|
|
/* Setup function pointers. */
|
|
sc->ipmi_startup = kcs_startup;
|
|
sc->ipmi_enqueue_request = ipmi_polled_enqueue_request;
|
|
|
|
/* See if we can talk to the controller. */
|
|
status = INB(sc, KCS_CTL_STS);
|
|
if (status == 0xff) {
|
|
device_printf(sc->ipmi_dev, "couldn't find it\n");
|
|
return (ENXIO);
|
|
}
|
|
|
|
#ifdef KCS_DEBUG
|
|
device_printf(sc->ipmi_dev, "KCS: initial state: %02x\n", status);
|
|
#endif
|
|
if (status & KCS_STATUS_OBF ||
|
|
KCS_STATUS_STATE(status) != KCS_STATUS_STATE_IDLE)
|
|
kcs_error(sc);
|
|
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Determine the alignment automatically for a PCI attachment. In this case,
|
|
* any unused bytes will return 0x00 when read. We make use of the C/D bit
|
|
* in the CTL_STS register to try to start a GET_STATUS transaction. When
|
|
* we write the command, that bit should be set, so we should get a non-zero
|
|
* value back when we read CTL_STS if the offset we are testing is the CTL_STS
|
|
* register.
|
|
*/
|
|
int
|
|
ipmi_kcs_probe_align(struct ipmi_softc *sc)
|
|
{
|
|
int data, status;
|
|
|
|
sc->ipmi_io_spacing = 1;
|
|
retry:
|
|
#ifdef KCS_DEBUG
|
|
device_printf(sc->ipmi_dev, "Trying KCS align %d... ", sc->ipmi_io_spacing);
|
|
#endif
|
|
|
|
/* Wait for IBF = 0 */
|
|
status = INB(sc, KCS_CTL_STS);
|
|
while (status & KCS_STATUS_IBF) {
|
|
DELAY(100);
|
|
status = INB(sc, KCS_CTL_STS);
|
|
}
|
|
|
|
OUTB(sc, KCS_CTL_STS, KCS_CONTROL_GET_STATUS_ABORT);
|
|
|
|
/* Wait for IBF = 0 */
|
|
status = INB(sc, KCS_CTL_STS);
|
|
while (status & KCS_STATUS_IBF) {
|
|
DELAY(100);
|
|
status = INB(sc, KCS_CTL_STS);
|
|
}
|
|
|
|
/* If we got 0x00 back, then this must not be the CTL_STS register. */
|
|
if (status == 0) {
|
|
#ifdef KCS_DEBUG
|
|
printf("failed\n");
|
|
#endif
|
|
sc->ipmi_io_spacing <<= 1;
|
|
if (sc->ipmi_io_spacing > 4)
|
|
return (0);
|
|
goto retry;
|
|
}
|
|
#ifdef KCS_DEBUG
|
|
printf("ok\n");
|
|
#endif
|
|
|
|
/* Finish out the transaction. */
|
|
|
|
/* Clear OBF */
|
|
if (status && KCS_STATUS_OBF)
|
|
data = INB(sc, KCS_DATA);
|
|
|
|
/* 0x00 to DATA_IN */
|
|
OUTB(sc, KCS_DATA, 0);
|
|
|
|
/* Wait for IBF = 0 */
|
|
status = INB(sc, KCS_CTL_STS);
|
|
while (status & KCS_STATUS_IBF) {
|
|
DELAY(100);
|
|
status = INB(sc, KCS_CTL_STS);
|
|
}
|
|
|
|
if (KCS_STATUS_STATE(status) == KCS_STATUS_STATE_READ) {
|
|
/* Wait for IBF = 1 */
|
|
while (!(status & KCS_STATUS_OBF)) {
|
|
DELAY(100);
|
|
status = INB(sc, KCS_CTL_STS);
|
|
}
|
|
|
|
/* Read error status. */
|
|
data = INB(sc, KCS_DATA);
|
|
|
|
/* Write dummy READ to DATA_IN. */
|
|
OUTB(sc, KCS_DATA, KCS_DATA_IN_READ);
|
|
|
|
/* Wait for IBF = 0 */
|
|
status = INB(sc, KCS_CTL_STS);
|
|
while (status & KCS_STATUS_IBF) {
|
|
DELAY(100);
|
|
status = INB(sc, KCS_CTL_STS);
|
|
}
|
|
}
|
|
|
|
if (KCS_STATUS_STATE(status) == KCS_STATUS_STATE_IDLE) {
|
|
/* Wait for IBF = 1 */
|
|
while (!(status & KCS_STATUS_OBF)) {
|
|
DELAY(100);
|
|
status = INB(sc, KCS_CTL_STS);
|
|
}
|
|
|
|
/* Clear OBF */
|
|
if (status && KCS_STATUS_OBF)
|
|
data = INB(sc, KCS_DATA);
|
|
} else
|
|
device_printf(sc->ipmi_dev, "KCS probe: end state %x\n",
|
|
KCS_STATUS_STATE(status));
|
|
|
|
return (1);
|
|
}
|