1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 2006 IronPort Systems Inc. <[email protected]>
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29 #include <sys/cdefs.h>
30 __FBSDID("$FreeBSD$");
31
32 #include <sys/param.h>
33 #include <sys/systm.h>
34 #include <sys/bus.h>
35 #include <sys/condvar.h>
36 #include <sys/eventhandler.h>
37 #include <sys/kernel.h>
38 #include <sys/kthread.h>
39 #include <sys/rman.h>
40 #include <sys/selinfo.h>
41 #include <machine/bus.h>
42
43 #ifdef LOCAL_MODULE
44 #include <ipmi.h>
45 #include <ipmivars.h>
46 #else
47 #include <sys/ipmi.h>
48 #include <dev/ipmi/ipmivars.h>
49 #endif
50
51 static void kcs_clear_obf(struct ipmi_softc *, int);
52 static void kcs_error(struct ipmi_softc *);
53 static int kcs_wait_for_ibf(struct ipmi_softc *, int);
54 static int kcs_wait_for_obf(struct ipmi_softc *, int);
55
56 static int
kcs_wait_for_ibf(struct ipmi_softc * sc,int state)57 kcs_wait_for_ibf(struct ipmi_softc *sc, int state)
58 {
59 int status, start = ticks;
60
61 status = INB(sc, KCS_CTL_STS);
62 if (state == 0) {
63 /* WAIT FOR IBF = 0 */
64 while (ticks - start < MAX_TIMEOUT && status & KCS_STATUS_IBF) {
65 DELAY(100);
66 status = INB(sc, KCS_CTL_STS);
67 }
68 } else {
69 /* WAIT FOR IBF = 1 */
70 while (ticks - start < MAX_TIMEOUT &&
71 !(status & KCS_STATUS_IBF)) {
72 DELAY(100);
73 status = INB(sc, KCS_CTL_STS);
74 }
75 }
76 return (status);
77 }
78
79 static int
kcs_wait_for_obf(struct ipmi_softc * sc,int state)80 kcs_wait_for_obf(struct ipmi_softc *sc, int state)
81 {
82 int status, start = ticks;
83
84 status = INB(sc, KCS_CTL_STS);
85 if (state == 0) {
86 /* WAIT FOR OBF = 0 */
87 while (ticks - start < MAX_TIMEOUT && status & KCS_STATUS_OBF) {
88 DELAY(100);
89 status = INB(sc, KCS_CTL_STS);
90 }
91 } else {
92 /* WAIT FOR OBF = 1 */
93 while (ticks - start < MAX_TIMEOUT &&
94 !(status & KCS_STATUS_OBF)) {
95 DELAY(100);
96 status = INB(sc, KCS_CTL_STS);
97 }
98 }
99 return (status);
100 }
101
102 static void
kcs_clear_obf(struct ipmi_softc * sc,int status)103 kcs_clear_obf(struct ipmi_softc *sc, int status)
104 {
105 int data;
106
107 /* Clear OBF */
108 if (status & KCS_STATUS_OBF) {
109 data = INB(sc, KCS_DATA);
110 }
111 }
112
113 static void
kcs_error(struct ipmi_softc * sc)114 kcs_error(struct ipmi_softc *sc)
115 {
116 int retry, status;
117 u_char data;
118
119 for (retry = 0; retry < 2; retry++) {
120
121 /* Wait for IBF = 0 */
122 status = kcs_wait_for_ibf(sc, 0);
123
124 /* ABORT */
125 OUTB(sc, KCS_CTL_STS, KCS_CONTROL_GET_STATUS_ABORT);
126
127 /* Wait for IBF = 0 */
128 status = kcs_wait_for_ibf(sc, 0);
129
130 /* Clear OBF */
131 kcs_clear_obf(sc, status);
132
133 if (status & KCS_STATUS_OBF) {
134 data = INB(sc, KCS_DATA);
135 if (data != 0)
136 device_printf(sc->ipmi_dev,
137 "KCS Error Data %02x\n", data);
138 }
139
140 /* 0x00 to DATA_IN */
141 OUTB(sc, KCS_DATA, 0x00);
142
143 /* Wait for IBF = 0 */
144 status = kcs_wait_for_ibf(sc, 0);
145
146 if (KCS_STATUS_STATE(status) == KCS_STATUS_STATE_READ) {
147
148 /* Wait for OBF = 1 */
149 status = kcs_wait_for_obf(sc, 1);
150
151 /* Read error status */
152 data = INB(sc, KCS_DATA);
153 if (data != 0 && (data != 0xff || bootverbose))
154 device_printf(sc->ipmi_dev, "KCS error: %02x\n",
155 data);
156
157 /* Write READ into Data_in */
158 OUTB(sc, KCS_DATA, KCS_DATA_IN_READ);
159
160 /* Wait for IBF = 0 */
161 status = kcs_wait_for_ibf(sc, 0);
162 }
163
164 /* IDLE STATE */
165 if (KCS_STATUS_STATE(status) == KCS_STATUS_STATE_IDLE) {
166 /* Wait for OBF = 1 */
167 status = kcs_wait_for_obf(sc, 1);
168
169 /* Clear OBF */
170 kcs_clear_obf(sc, status);
171 return;
172 }
173 }
174 device_printf(sc->ipmi_dev, "KCS: Error retry exhausted\n");
175 }
176
177 /*
178 * Start to write a request. Waits for IBF to clear and then sends the
179 * WR_START command.
180 */
181 static int
kcs_start_write(struct ipmi_softc * sc)182 kcs_start_write(struct ipmi_softc *sc)
183 {
184 int retry, status;
185
186 for (retry = 0; retry < 10; retry++) {
187 /* Wait for IBF = 0 */
188 status = kcs_wait_for_ibf(sc, 0);
189 if (status & KCS_STATUS_IBF)
190 return (0);
191
192 /* Clear OBF */
193 kcs_clear_obf(sc, status);
194
195 /* Write start to command */
196 OUTB(sc, KCS_CTL_STS, KCS_CONTROL_WRITE_START);
197
198 /* Wait for IBF = 0 */
199 status = kcs_wait_for_ibf(sc, 0);
200 if (status & KCS_STATUS_IBF)
201 return (0);
202
203 if (KCS_STATUS_STATE(status) == KCS_STATUS_STATE_WRITE)
204 break;
205 DELAY(1000000);
206 }
207
208 if (KCS_STATUS_STATE(status) != KCS_STATUS_STATE_WRITE)
209 /* error state */
210 return (0);
211
212 /* Clear OBF */
213 kcs_clear_obf(sc, status);
214
215 return (1);
216 }
217
218 /*
219 * Write a byte of the request message, excluding the last byte of the
220 * message which requires special handling.
221 */
222 static int
kcs_write_byte(struct ipmi_softc * sc,u_char data)223 kcs_write_byte(struct ipmi_softc *sc, u_char data)
224 {
225 int status;
226
227 /* Data to Data */
228 OUTB(sc, KCS_DATA, data);
229
230 /* Wait for IBF = 0 */
231 status = kcs_wait_for_ibf(sc, 0);
232 if (status & KCS_STATUS_IBF)
233 return (0);
234
235 if (KCS_STATUS_STATE(status) != KCS_STATUS_STATE_WRITE)
236 return (0);
237
238 /* Clear OBF */
239 kcs_clear_obf(sc, status);
240 return (1);
241 }
242
243 /*
244 * Write the last byte of a request message.
245 */
246 static int
kcs_write_last_byte(struct ipmi_softc * sc,u_char data)247 kcs_write_last_byte(struct ipmi_softc *sc, u_char data)
248 {
249 int status;
250
251 /* Write end to command */
252 OUTB(sc, KCS_CTL_STS, KCS_CONTROL_WRITE_END);
253
254 /* Wait for IBF = 0 */
255 status = kcs_wait_for_ibf(sc, 0);
256 if (status & KCS_STATUS_IBF)
257 return (0);
258
259 if (KCS_STATUS_STATE(status) != KCS_STATUS_STATE_WRITE)
260 /* error state */
261 return (0);
262
263 /* Clear OBF */
264 kcs_clear_obf(sc, status);
265
266 /* Send data byte to DATA. */
267 OUTB(sc, KCS_DATA, data);
268 return (1);
269 }
270
271 /*
272 * Read one byte of the reply message.
273 */
274 static int
kcs_read_byte(struct ipmi_softc * sc,u_char * data)275 kcs_read_byte(struct ipmi_softc *sc, u_char *data)
276 {
277 int status;
278 u_char dummy;
279
280 /* Wait for IBF = 0 */
281 status = kcs_wait_for_ibf(sc, 0);
282
283 /* Read State */
284 if (KCS_STATUS_STATE(status) == KCS_STATUS_STATE_READ) {
285
286 /* Wait for OBF = 1 */
287 status = kcs_wait_for_obf(sc, 1);
288 if ((status & KCS_STATUS_OBF) == 0)
289 return (0);
290
291 /* Read Data_out */
292 *data = INB(sc, KCS_DATA);
293
294 /* Write READ into Data_in */
295 OUTB(sc, KCS_DATA, KCS_DATA_IN_READ);
296 return (1);
297 }
298
299 /* Idle State */
300 if (KCS_STATUS_STATE(status) == KCS_STATUS_STATE_IDLE) {
301
302 /* Wait for OBF = 1*/
303 status = kcs_wait_for_obf(sc, 1);
304 if ((status & KCS_STATUS_OBF) == 0)
305 return (0);
306
307 /* Read Dummy */
308 dummy = INB(sc, KCS_DATA);
309 return (2);
310 }
311
312 /* Error State */
313 return (0);
314 }
315
316 /*
317 * Send a request message and collect the reply. Returns true if we
318 * succeed.
319 */
320 static int
kcs_polled_request(struct ipmi_softc * sc,struct ipmi_request * req)321 kcs_polled_request(struct ipmi_softc *sc, struct ipmi_request *req)
322 {
323 u_char *cp, data;
324 int i, state;
325
326 IPMI_IO_LOCK(sc);
327
328 /* Send the request. */
329 if (!kcs_start_write(sc)) {
330 device_printf(sc->ipmi_dev, "KCS: Failed to start write\n");
331 goto fail;
332 }
333 #ifdef KCS_DEBUG
334 device_printf(sc->ipmi_dev, "KCS: WRITE_START... ok\n");
335 #endif
336
337 if (!kcs_write_byte(sc, req->ir_addr)) {
338 device_printf(sc->ipmi_dev, "KCS: Failed to write address\n");
339 goto fail;
340 }
341 #ifdef KCS_DEBUG
342 device_printf(sc->ipmi_dev, "KCS: Wrote address: %02x\n", req->ir_addr);
343 #endif
344
345 if (req->ir_requestlen == 0) {
346 if (!kcs_write_last_byte(sc, req->ir_command)) {
347 device_printf(sc->ipmi_dev,
348 "KCS: Failed to write command\n");
349 goto fail;
350 }
351 #ifdef KCS_DEBUG
352 device_printf(sc->ipmi_dev, "KCS: Wrote command: %02x\n",
353 req->ir_command);
354 #endif
355 } else {
356 if (!kcs_write_byte(sc, req->ir_command)) {
357 device_printf(sc->ipmi_dev,
358 "KCS: Failed to write command\n");
359 goto fail;
360 }
361 #ifdef KCS_DEBUG
362 device_printf(sc->ipmi_dev, "KCS: Wrote command: %02x\n",
363 req->ir_command);
364 #endif
365
366 cp = req->ir_request;
367 for (i = 0; i < req->ir_requestlen - 1; i++) {
368 if (!kcs_write_byte(sc, *cp++)) {
369 device_printf(sc->ipmi_dev,
370 "KCS: Failed to write data byte %d\n",
371 i + 1);
372 goto fail;
373 }
374 #ifdef KCS_DEBUG
375 device_printf(sc->ipmi_dev, "KCS: Wrote data: %02x\n",
376 cp[-1]);
377 #endif
378 }
379
380 if (!kcs_write_last_byte(sc, *cp)) {
381 device_printf(sc->ipmi_dev,
382 "KCS: Failed to write last dta byte\n");
383 goto fail;
384 }
385 #ifdef KCS_DEBUG
386 device_printf(sc->ipmi_dev, "KCS: Wrote last data: %02x\n",
387 *cp);
388 #endif
389 }
390
391 /* Read the reply. First, read the NetFn/LUN. */
392 if (kcs_read_byte(sc, &data) != 1) {
393 device_printf(sc->ipmi_dev, "KCS: Failed to read address\n");
394 goto fail;
395 }
396 #ifdef KCS_DEBUG
397 device_printf(sc->ipmi_dev, "KCS: Read address: %02x\n", data);
398 #endif
399 if (data != IPMI_REPLY_ADDR(req->ir_addr)) {
400 device_printf(sc->ipmi_dev, "KCS: Reply address mismatch\n");
401 goto fail;
402 }
403
404 /* Next we read the command. */
405 if (kcs_read_byte(sc, &data) != 1) {
406 device_printf(sc->ipmi_dev, "KCS: Failed to read command\n");
407 goto fail;
408 }
409 #ifdef KCS_DEBUG
410 device_printf(sc->ipmi_dev, "KCS: Read command: %02x\n", data);
411 #endif
412 if (data != req->ir_command) {
413 device_printf(sc->ipmi_dev, "KCS: Command mismatch\n");
414 goto fail;
415 }
416
417 /* Next we read the completion code. */
418 if (kcs_read_byte(sc, &req->ir_compcode) != 1) {
419 if (bootverbose) {
420 device_printf(sc->ipmi_dev,
421 "KCS: Failed to read completion code\n");
422 }
423 goto fail;
424 }
425 #ifdef KCS_DEBUG
426 device_printf(sc->ipmi_dev, "KCS: Read completion code: %02x\n",
427 req->ir_compcode);
428 #endif
429
430 /* Finally, read the reply from the BMC. */
431 i = 0;
432 for (;;) {
433 state = kcs_read_byte(sc, &data);
434 if (state == 0) {
435 device_printf(sc->ipmi_dev,
436 "KCS: Read failed on byte %d\n", i + 1);
437 goto fail;
438 }
439 if (state == 2)
440 break;
441 if (i < req->ir_replybuflen) {
442 req->ir_reply[i] = data;
443 #ifdef KCS_DEBUG
444 device_printf(sc->ipmi_dev, "KCS: Read data %02x\n",
445 data);
446 } else {
447 device_printf(sc->ipmi_dev,
448 "KCS: Read short %02x byte %d\n", data, i + 1);
449 #endif
450 }
451 i++;
452 }
453 IPMI_IO_UNLOCK(sc);
454 req->ir_replylen = i;
455 #ifdef KCS_DEBUG
456 device_printf(sc->ipmi_dev, "KCS: READ finished (%d bytes)\n", i);
457 if (req->ir_replybuflen < i)
458 #else
459 if (req->ir_replybuflen < i && req->ir_replybuflen != 0)
460 #endif
461 device_printf(sc->ipmi_dev,
462 "KCS: Read short: %zd buffer, %d actual\n",
463 req->ir_replybuflen, i);
464 return (1);
465 fail:
466 kcs_error(sc);
467 IPMI_IO_UNLOCK(sc);
468 return (0);
469 }
470
471 static void
kcs_loop(void * arg)472 kcs_loop(void *arg)
473 {
474 struct ipmi_softc *sc = arg;
475 struct ipmi_request *req;
476 int i, ok;
477
478 IPMI_LOCK(sc);
479 while ((req = ipmi_dequeue_request(sc)) != NULL) {
480 IPMI_UNLOCK(sc);
481 ok = 0;
482 for (i = 0; i < 3 && !ok; i++)
483 ok = kcs_polled_request(sc, req);
484 if (ok)
485 req->ir_error = 0;
486 else
487 req->ir_error = EIO;
488 IPMI_LOCK(sc);
489 ipmi_complete_request(sc, req);
490 }
491 IPMI_UNLOCK(sc);
492 kproc_exit(0);
493 }
494
495 static int
kcs_startup(struct ipmi_softc * sc)496 kcs_startup(struct ipmi_softc *sc)
497 {
498
499 return (kproc_create(kcs_loop, sc, &sc->ipmi_kthread, 0, 0, "%s: kcs",
500 device_get_nameunit(sc->ipmi_dev)));
501 }
502
503 static int
kcs_driver_request(struct ipmi_softc * sc,struct ipmi_request * req,int timo)504 kcs_driver_request(struct ipmi_softc *sc, struct ipmi_request *req, int timo)
505 {
506 int i, ok;
507
508 ok = 0;
509 for (i = 0; i < 3 && !ok; i++)
510 ok = kcs_polled_request(sc, req);
511 if (ok)
512 req->ir_error = 0;
513 else
514 req->ir_error = EIO;
515 return (req->ir_error);
516 }
517
518 int
ipmi_kcs_attach(struct ipmi_softc * sc)519 ipmi_kcs_attach(struct ipmi_softc *sc)
520 {
521 int status;
522
523 /* Setup function pointers. */
524 sc->ipmi_startup = kcs_startup;
525 sc->ipmi_enqueue_request = ipmi_polled_enqueue_request;
526 sc->ipmi_driver_request = kcs_driver_request;
527 sc->ipmi_driver_requests_polled = 1;
528
529 /* See if we can talk to the controller. */
530 status = INB(sc, KCS_CTL_STS);
531 if (status == 0xff) {
532 device_printf(sc->ipmi_dev, "couldn't find it\n");
533 return (ENXIO);
534 }
535
536 #ifdef KCS_DEBUG
537 device_printf(sc->ipmi_dev, "KCS: initial state: %02x\n", status);
538 #endif
539 if (status & KCS_STATUS_OBF ||
540 KCS_STATUS_STATE(status) != KCS_STATUS_STATE_IDLE)
541 kcs_error(sc);
542
543 return (0);
544 }
545
546 /*
547 * Determine the alignment automatically for a PCI attachment. In this case,
548 * any unused bytes will return 0x00 when read. We make use of the C/D bit
549 * in the CTL_STS register to try to start a GET_STATUS transaction. When
550 * we write the command, that bit should be set, so we should get a non-zero
551 * value back when we read CTL_STS if the offset we are testing is the CTL_STS
552 * register.
553 */
554 int
ipmi_kcs_probe_align(struct ipmi_softc * sc)555 ipmi_kcs_probe_align(struct ipmi_softc *sc)
556 {
557 int data, status;
558
559 sc->ipmi_io_spacing = 1;
560 retry:
561 #ifdef KCS_DEBUG
562 device_printf(sc->ipmi_dev, "Trying KCS align %d... ", sc->ipmi_io_spacing);
563 #endif
564
565 /* Wait for IBF = 0 */
566 status = INB(sc, KCS_CTL_STS);
567 while (status & KCS_STATUS_IBF) {
568 DELAY(100);
569 status = INB(sc, KCS_CTL_STS);
570 }
571
572 OUTB(sc, KCS_CTL_STS, KCS_CONTROL_GET_STATUS_ABORT);
573
574 /* Wait for IBF = 0 */
575 status = INB(sc, KCS_CTL_STS);
576 while (status & KCS_STATUS_IBF) {
577 DELAY(100);
578 status = INB(sc, KCS_CTL_STS);
579 }
580
581 /* If we got 0x00 back, then this must not be the CTL_STS register. */
582 if (status == 0) {
583 #ifdef KCS_DEBUG
584 printf("failed\n");
585 #endif
586 sc->ipmi_io_spacing <<= 1;
587 if (sc->ipmi_io_spacing > 4)
588 return (0);
589 goto retry;
590 }
591 #ifdef KCS_DEBUG
592 printf("ok\n");
593 #endif
594
595 /* Finish out the transaction. */
596
597 /* Clear OBF */
598 if (status & KCS_STATUS_OBF)
599 data = INB(sc, KCS_DATA);
600
601 /* 0x00 to DATA_IN */
602 OUTB(sc, KCS_DATA, 0);
603
604 /* Wait for IBF = 0 */
605 status = INB(sc, KCS_CTL_STS);
606 while (status & KCS_STATUS_IBF) {
607 DELAY(100);
608 status = INB(sc, KCS_CTL_STS);
609 }
610
611 if (KCS_STATUS_STATE(status) == KCS_STATUS_STATE_READ) {
612 /* Wait for IBF = 1 */
613 while (!(status & KCS_STATUS_OBF)) {
614 DELAY(100);
615 status = INB(sc, KCS_CTL_STS);
616 }
617
618 /* Read error status. */
619 data = INB(sc, KCS_DATA);
620
621 /* Write dummy READ to DATA_IN. */
622 OUTB(sc, KCS_DATA, KCS_DATA_IN_READ);
623
624 /* Wait for IBF = 0 */
625 status = INB(sc, KCS_CTL_STS);
626 while (status & KCS_STATUS_IBF) {
627 DELAY(100);
628 status = INB(sc, KCS_CTL_STS);
629 }
630 }
631
632 if (KCS_STATUS_STATE(status) == KCS_STATUS_STATE_IDLE) {
633 /* Wait for IBF = 1 */
634 while (!(status & KCS_STATUS_OBF)) {
635 DELAY(100);
636 status = INB(sc, KCS_CTL_STS);
637 }
638
639 /* Clear OBF */
640 if (status & KCS_STATUS_OBF)
641 data = INB(sc, KCS_DATA);
642 } else
643 device_printf(sc->ipmi_dev, "KCS probe: end state %x\n",
644 KCS_STATUS_STATE(status));
645
646 return (1);
647 }
648