Index: head/sys/dev/ipmi/ipmi_kcs.c =================================================================== --- head/sys/dev/ipmi/ipmi_kcs.c (revision 348995) +++ head/sys/dev/ipmi/ipmi_kcs.c (revision 348996) @@ -1,647 +1,638 @@ /*- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * * Copyright (c) 2006 IronPort Systems Inc. * 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 __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include #include #include #include #ifdef LOCAL_MODULE #include #include #else #include #include #endif +#define POLLING_DELAY_MIN 4 /* Waits are 2-3 usecs on typical systems */ +#define POLLING_DELAY_MAX 256 + 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 *, bool); +static int kcs_wait_for_obf(struct ipmi_softc *, bool); static int -kcs_wait_for_ibf(struct ipmi_softc *sc, int state) +kcs_wait(struct ipmi_softc *sc, int value, int mask) { int status, start = ticks; + int delay_usec = POLLING_DELAY_MIN; 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); - } + while (ticks - start < MAX_TIMEOUT && (status & mask) != value) { + /* + * The wait delay is increased exponentially to avoid putting + * significant load on I/O bus. + */ + DELAY(delay_usec); + status = INB(sc, KCS_CTL_STS); + if (delay_usec < POLLING_DELAY_MAX) + delay_usec *= 2; } return (status); } static int -kcs_wait_for_obf(struct ipmi_softc *sc, int state) +kcs_wait_for_ibf(struct ipmi_softc *sc, bool level) { - 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); + return (kcs_wait(sc, level ? KCS_STATUS_IBF : 0, KCS_STATUS_IBF)); +} + +static int +kcs_wait_for_obf(struct ipmi_softc *sc, bool level) +{ + + return (kcs_wait(sc, level ? KCS_STATUS_OBF : 0, KCS_STATUS_OBF)); } 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 && (data != 0xff || bootverbose)) 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); if (status & KCS_STATUS_IBF) return (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 (status & KCS_STATUS_IBF) return (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 (status & KCS_STATUS_IBF) return (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 (status & KCS_STATUS_IBF) return (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); if ((status & KCS_STATUS_OBF) == 0) return (0); /* 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); if ((status & KCS_STATUS_OBF) == 0) return (0); /* 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; IPMI_IO_LOCK(sc); /* 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) { if (bootverbose) { 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++; } IPMI_IO_UNLOCK(sc); 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); IPMI_IO_UNLOCK(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) { IPMI_UNLOCK(sc); 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_LOCK(sc); ipmi_complete_request(sc, req); } IPMI_UNLOCK(sc); kproc_exit(0); } static int kcs_startup(struct ipmi_softc *sc) { return (kproc_create(kcs_loop, sc, &sc->ipmi_kthread, 0, 0, "%s: kcs", device_get_nameunit(sc->ipmi_dev))); } static int kcs_driver_request(struct ipmi_softc *sc, struct ipmi_request *req, int timo) { int i, ok; 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; return (req->ir_error); } 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; sc->ipmi_driver_request = kcs_driver_request; sc->ipmi_driver_requests_polled = 1; /* 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); }