1/*- 2 * Copyright (c) 2006 IronPort Systems Inc. <ambrisko@ironport.com> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27#include <sys/cdefs.h> 28__FBSDID("$FreeBSD$"); 29 30#include <sys/param.h> 31#include <sys/systm.h> 32#include <sys/bus.h> 33#include <sys/condvar.h> 34#include <sys/eventhandler.h> 35#include <sys/kernel.h> 36#include <sys/kthread.h> 37#include <sys/module.h> 38#include <sys/rman.h> 39#include <sys/selinfo.h> 40#include <machine/bus.h> 41 42#ifdef LOCAL_MODULE 43#include <ipmi.h> 44#include <ipmivars.h> 45#else 46#include <sys/ipmi.h> 47#include <dev/ipmi/ipmivars.h> 48#endif 49 50static void smic_wait_for_tx_okay(struct ipmi_softc *); 51static void smic_wait_for_rx_okay(struct ipmi_softc *); 52static void smic_wait_for_not_busy(struct ipmi_softc *); 53static void smic_set_busy(struct ipmi_softc *); 54 55static void 56smic_wait_for_tx_okay(struct ipmi_softc *sc) 57{ 58 int flags; 59 60 do { 61 flags = INB(sc, SMIC_FLAGS); 62 } while (!(flags & SMIC_STATUS_TX_RDY)); 63} 64 65static void 66smic_wait_for_rx_okay(struct ipmi_softc *sc) 67{ 68 int flags; 69 70 do { 71 flags = INB(sc, SMIC_FLAGS); 72 } while (!(flags & SMIC_STATUS_RX_RDY)); 73} 74 75static void 76smic_wait_for_not_busy(struct ipmi_softc *sc) 77{ 78 int flags; 79 80 do { 81 flags = INB(sc, SMIC_FLAGS); 82 } while (flags & SMIC_STATUS_BUSY); 83} 84 85static void 86smic_set_busy(struct ipmi_softc *sc) 87{ 88 int flags; 89 90 flags = INB(sc, SMIC_FLAGS); 91 flags |= SMIC_STATUS_BUSY; 92 flags &= ~SMIC_STATUS_RESERVED; 93 OUTB(sc, SMIC_FLAGS, flags); 94} 95 96/* 97 * Start a transfer with a WR_START transaction that sends the NetFn/LUN 98 * address. 99 */ 100static int 101smic_start_write(struct ipmi_softc *sc, u_char data) 102{ 103 u_char error, status; 104 105 smic_wait_for_not_busy(sc); 106 107 OUTB(sc, SMIC_CTL_STS, SMIC_CC_SMS_WR_START); 108 OUTB(sc, SMIC_DATA, data); 109 smic_set_busy(sc); 110 smic_wait_for_not_busy(sc); 111 status = INB(sc, SMIC_CTL_STS); 112 if (status != SMIC_SC_SMS_WR_START) { 113 error = INB(sc, SMIC_DATA); 114 device_printf(sc->ipmi_dev, "SMIC: Write did not start %02x\n", 115 error); 116 return (0); 117 } 118 return (1); 119} 120 121/* 122 * Write a byte in the middle of the message (either the command or one of 123 * the data bytes) using a WR_NEXT transaction. 124 */ 125static int 126smic_write_next(struct ipmi_softc *sc, u_char data) 127{ 128 u_char error, status; 129 130 smic_wait_for_tx_okay(sc); 131 OUTB(sc, SMIC_CTL_STS, SMIC_CC_SMS_WR_NEXT); 132 OUTB(sc, SMIC_DATA, data); 133 smic_set_busy(sc); 134 smic_wait_for_not_busy(sc); 135 status = INB(sc, SMIC_CTL_STS); 136 if (status != SMIC_SC_SMS_WR_NEXT) { 137 error = INB(sc, SMIC_DATA); 138 device_printf(sc->ipmi_dev, "SMIC: Write did not next %02x\n", 139 error); 140 return (0); 141 } 142 return (1); 143} 144 145/* 146 * Write the last byte of a transfer to end the write phase via a WR_END 147 * transaction. 148 */ 149static int 150smic_write_last(struct ipmi_softc *sc, u_char data) 151{ 152 u_char error, status; 153 154 smic_wait_for_tx_okay(sc); 155 OUTB(sc, SMIC_CTL_STS, SMIC_CC_SMS_WR_END); 156 OUTB(sc, SMIC_DATA, data); 157 smic_set_busy(sc); 158 smic_wait_for_not_busy(sc); 159 status = INB(sc, SMIC_CTL_STS); 160 if (status != SMIC_SC_SMS_WR_END) { 161 error = INB(sc, SMIC_DATA); 162 device_printf(sc->ipmi_dev, "SMIC: Write did not end %02x\n", 163 error); 164 return (0); 165 } 166 return (1); 167} 168 169/* 170 * Start the read phase of a transfer with a RD_START transaction. 171 */ 172static int 173smic_start_read(struct ipmi_softc *sc, u_char *data) 174{ 175 u_char error, status; 176 177 smic_wait_for_not_busy(sc); 178 179 smic_wait_for_rx_okay(sc); 180 OUTB(sc, SMIC_CTL_STS, SMIC_CC_SMS_RD_START); 181 smic_set_busy(sc); 182 smic_wait_for_not_busy(sc); 183 status = INB(sc, SMIC_CTL_STS); 184 if (status != SMIC_SC_SMS_RD_START) { 185 error = INB(sc, SMIC_DATA); 186 device_printf(sc->ipmi_dev, "SMIC: Read did not start %02x\n", 187 error); 188 return (0); 189 } 190 *data = INB(sc, SMIC_DATA); 191 return (1); 192} 193 194/* 195 * Read a byte via a RD_NEXT transaction. If this was the last byte, return 196 * 2 rather than 1. 197 */ 198static int 199smic_read_byte(struct ipmi_softc *sc, u_char *data) 200{ 201 u_char error, status; 202 203 smic_wait_for_rx_okay(sc); 204 OUTB(sc, SMIC_CTL_STS, SMIC_SC_SMS_RD_NEXT); 205 smic_set_busy(sc); 206 smic_wait_for_not_busy(sc); 207 status = INB(sc, SMIC_CTL_STS); 208 if (status != SMIC_SC_SMS_RD_NEXT && 209 status != SMIC_SC_SMS_RD_END) { 210 error = INB(sc, SMIC_DATA); 211 device_printf(sc->ipmi_dev, "SMIC: Read did not next %02x\n", 212 error); 213 return (0); 214 } 215 *data = INB(sc, SMIC_DATA); 216 if (status == SMIC_SC_SMS_RD_NEXT) 217 return (1); 218 else 219 return (2); 220} 221 222/* Complete a transfer via a RD_END transaction after reading the last byte. */ 223static int 224smic_read_end(struct ipmi_softc *sc) 225{ 226 u_char error, status; 227 228 OUTB(sc, SMIC_CTL_STS, SMIC_CC_SMS_RD_END); 229 smic_set_busy(sc); 230 smic_wait_for_not_busy(sc); 231 status = INB(sc, SMIC_CTL_STS); 232 if (status != SMIC_SC_SMS_RDY) { 233 error = INB(sc, SMIC_DATA); 234 device_printf(sc->ipmi_dev, "SMIC: Read did not end %02x\n", 235 error); 236 return (0); 237 } 238 return (1); 239} 240 241static int 242smic_polled_request(struct ipmi_softc *sc, struct ipmi_request *req) 243{ 244 u_char *cp, data; 245 int i, state; 246 247 /* First, start the message with the address. */ 248 if (!smic_start_write(sc, req->ir_addr)) 249 return (0); 250#ifdef SMIC_DEBUG 251 device_printf(sc->ipmi_dev, "SMIC: WRITE_START address: %02x\n", 252 req->ir_addr); 253#endif 254 255 if (req->ir_requestlen == 0) { 256 /* Send the command as the last byte. */ 257 if (!smic_write_last(sc, req->ir_command)) 258 return (0); 259#ifdef SMIC_DEBUG 260 device_printf(sc->ipmi_dev, "SMIC: Wrote command: %02x\n", 261 req->ir_command); 262#endif 263 } else { 264 /* Send the command. */ 265 if (!smic_write_next(sc, req->ir_command)) 266 return (0); 267#ifdef SMIC_DEBUG 268 device_printf(sc->ipmi_dev, "SMIC: Wrote command: %02x\n", 269 req->ir_command); 270#endif 271 272 /* Send the payload. */ 273 cp = req->ir_request; 274 for (i = 0; i < req->ir_requestlen - 1; i++) { 275 if (!smic_write_next(sc, *cp++)) 276 return (0); 277#ifdef SMIC_DEBUG 278 device_printf(sc->ipmi_dev, "SMIC: Wrote data: %02x\n", 279 cp[-1]); 280#endif 281 } 282 if (!smic_write_last(sc, *cp)) 283 return (0); 284#ifdef SMIC_DEBUG 285 device_printf(sc->ipmi_dev, "SMIC: Write last data: %02x\n", 286 *cp); 287#endif 288 } 289 290 /* Start the read phase by reading the NetFn/LUN. */ 291 if (smic_start_read(sc, &data) != 1) 292 return (0); 293#ifdef SMIC_DEBUG 294 device_printf(sc->ipmi_dev, "SMIC: Read address: %02x\n", data); 295#endif 296 if (data != IPMI_REPLY_ADDR(req->ir_addr)) { 297 device_printf(sc->ipmi_dev, "SMIC: Reply address mismatch\n"); 298 return (0); 299 } 300 301 /* Read the command. */ 302 if (smic_read_byte(sc, &data) != 1) 303 return (0); 304#ifdef SMIC_DEBUG 305 device_printf(sc->ipmi_dev, "SMIC: Read command: %02x\n", data); 306#endif 307 if (data != req->ir_command) { 308 device_printf(sc->ipmi_dev, "SMIC: Command mismatch\n"); 309 return (0); 310 } 311 312 /* Read the completion code. */ 313 state = smic_read_byte(sc, &req->ir_compcode); 314 if (state == 0) 315 return (0); 316#ifdef SMIC_DEBUG 317 device_printf(sc->ipmi_dev, "SMIC: Read completion code: %02x\n", 318 req->ir_compcode); 319#endif 320 321 /* Finally, read the reply from the BMC. */ 322 i = 0; 323 while (state == 1) { 324 state = smic_read_byte(sc, &data); 325 if (state == 0) 326 return (0); 327 if (i < req->ir_replybuflen) { 328 req->ir_reply[i] = data; 329#ifdef SMIC_DEBUG 330 device_printf(sc->ipmi_dev, "SMIC: Read data: %02x\n", 331 data); 332 } else { 333 device_printf(sc->ipmi_dev, 334 "SMIC: Read short %02x byte %d\n", data, i + 1); 335#endif 336 } 337 i++; 338 } 339 340 /* Terminate the transfer. */ 341 if (!smic_read_end(sc)) 342 return (0); 343 req->ir_replylen = i; 344#ifdef SMIC_DEBUG 345 device_printf(sc->ipmi_dev, "SMIC: READ finished (%d bytes)\n", i); 346 if (req->ir_replybuflen < i) 347#else 348 if (req->ir_replybuflen < i && req->ir_replybuflen != 0) 349#endif 350 device_printf(sc->ipmi_dev, 351 "SMIC: Read short: %zd buffer, %d actual\n", 352 req->ir_replybuflen, i); 353 return (1); 354} 355 356static void 357smic_loop(void *arg) 358{ 359 struct ipmi_softc *sc = arg; 360 struct ipmi_request *req; 361 int i, ok; 362 363 IPMI_LOCK(sc); 364 while ((req = ipmi_dequeue_request(sc)) != NULL) { 365 IPMI_UNLOCK(sc); 366 ok = 0; 367 for (i = 0; i < 3 && !ok; i++) { 368 IPMI_IO_LOCK(sc); 369 ok = smic_polled_request(sc, req); 370 IPMI_IO_UNLOCK(sc); 371 } 372 if (ok) 373 req->ir_error = 0; 374 else 375 req->ir_error = EIO; 376 IPMI_LOCK(sc); 377 ipmi_complete_request(sc, req); 378 } 379 IPMI_UNLOCK(sc); 380 kproc_exit(0); 381} 382 383static int 384smic_startup(struct ipmi_softc *sc) 385{ 386 387 return (kproc_create(smic_loop, sc, &sc->ipmi_kthread, 0, 0, 388 "%s: smic", device_get_nameunit(sc->ipmi_dev))); 389} 390 391static int 392smic_driver_request(struct ipmi_softc *sc, struct ipmi_request *req, int timo) 393{ 394 int i, ok; 395 396 ok = 0; 397 for (i = 0; i < 3 && !ok; i++) { 398 IPMI_IO_LOCK(sc); 399 ok = smic_polled_request(sc, req); 400 IPMI_IO_UNLOCK(sc); 401 } 402 if (ok) 403 req->ir_error = 0; 404 else 405 req->ir_error = EIO; 406 return (req->ir_error); 407} 408 409int 410ipmi_smic_attach(struct ipmi_softc *sc) 411{ 412 int flags; 413 414 /* Setup function pointers. */ 415 sc->ipmi_startup = smic_startup; 416 sc->ipmi_enqueue_request = ipmi_polled_enqueue_request; 417 sc->ipmi_driver_request = smic_driver_request; 418 sc->ipmi_driver_requests_polled = 1; 419 420 /* See if we can talk to the controller. */ 421 flags = INB(sc, SMIC_FLAGS); 422 if (flags == 0xff) { 423 device_printf(sc->ipmi_dev, "couldn't find it\n"); 424 return (ENXIO); 425 } 426 427#ifdef SMIC_DEBUG 428 device_printf(sc->ipmi_dev, "SMIC: initial state: %02x\n", flags); 429#endif 430 431 return (0); 432} 433