Annotation of sys/dev/ipmi.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: ipmi.c,v 1.58 2007/05/29 06:36:56 claudio Exp $ */
2:
3: /*
4: * Copyright (c) 2005 Jordan Hargrave
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 AUTHORS 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 AUTHORS OR CONTRIBUTORS BE LIABLE FOR
20: * 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/types.h>
30: #include <sys/param.h>
31: #include <sys/systm.h>
32: #include <sys/kernel.h>
33: #include <sys/device.h>
34: #include <sys/extent.h>
35: #include <sys/timeout.h>
36: #include <sys/sensors.h>
37: #include <sys/malloc.h>
38: #include <sys/kthread.h>
39:
40: #include <machine/bus.h>
41: #include <machine/intr.h>
42: #include <machine/smbiosvar.h>
43:
44: #include <dev/isa/isareg.h>
45: #include <dev/isa/isavar.h>
46:
47: #include <dev/ipmivar.h>
48:
49: #include <uvm/uvm_extern.h>
50:
51: struct ipmi_sensor {
52: u_int8_t *i_sdr;
53: int i_num;
54: int stype;
55: int etype;
56: struct ksensor i_sensor;
57: SLIST_ENTRY(ipmi_sensor) list;
58: };
59:
60: int ipmi_nintr;
61: int ipmi_poll = 1;
62: int ipmi_enabled = 0;
63:
64: #define SENSOR_REFRESH_RATE (5 * hz)
65:
66: #define SMBIOS_TYPE_IPMI 0x26
67:
68: #define DEVNAME(s) ((s)->sc_dev.dv_xname)
69:
70: /*
71: * Format of SMBIOS IPMI Flags
72: *
73: * bit0: interrupt trigger mode (1=level, 0=edge)
74: * bit1: interrupt polarity (1=active high, 0=active low)
75: * bit2: reserved
76: * bit3: address LSB (1=odd,0=even)
77: * bit4: interrupt (1=specified, 0=not specified)
78: * bit5: reserved
79: * bit6/7: register spacing (1,4,2,err)
80: */
81: #define SMIPMI_FLAG_IRQLVL (1L << 0)
82: #define SMIPMI_FLAG_IRQEN (1L << 3)
83: #define SMIPMI_FLAG_ODDOFFSET (1L << 4)
84: #define SMIPMI_FLAG_IFSPACING(x) (((x)>>6)&0x3)
85: #define IPMI_IOSPACING_BYTE 0
86: #define IPMI_IOSPACING_WORD 2
87: #define IPMI_IOSPACING_DWORD 1
88:
89: #define IPMI_BTMSG_LEN 0
90: #define IPMI_BTMSG_NFLN 1
91: #define IPMI_BTMSG_SEQ 2
92: #define IPMI_BTMSG_CMD 3
93: #define IPMI_BTMSG_CCODE 4
94: #define IPMI_BTMSG_DATASND 4
95: #define IPMI_BTMSG_DATARCV 5
96:
97: #define IPMI_MSG_NFLN 0
98: #define IPMI_MSG_CMD 1
99: #define IPMI_MSG_CCODE 2
100: #define IPMI_MSG_DATASND 2
101: #define IPMI_MSG_DATARCV 3
102:
103: #define IPMI_SENSOR_TYPE_TEMP 0x0101
104: #define IPMI_SENSOR_TYPE_VOLT 0x0102
105: #define IPMI_SENSOR_TYPE_FAN 0x0104
106: #define IPMI_SENSOR_TYPE_INTRUSION 0x6F05
107: #define IPMI_SENSOR_TYPE_PWRSUPPLY 0x6F08
108:
109: #define IPMI_NAME_UNICODE 0x00
110: #define IPMI_NAME_BCDPLUS 0x01
111: #define IPMI_NAME_ASCII6BIT 0x02
112: #define IPMI_NAME_ASCII8BIT 0x03
113:
114: #define IPMI_ENTITY_PWRSUPPLY 0x0A
115:
116: #define IPMI_INVALID_SENSOR (1L << 5)
117:
118: #define IPMI_SDR_TYPEFULL 1
119: #define IPMI_SDR_TYPECOMPACT 2
120:
121: #define byteof(x) ((x) >> 3)
122: #define bitof(x) (1L << ((x) & 0x7))
123: #define TB(b,m) (data[2+byteof(b)] & bitof(b))
124:
125: #ifdef IPMI_DEBUG
126: int ipmi_dbg = 0;
127: #define dbg_printf(lvl, fmt...) \
128: if (ipmi_dbg >= lvl) \
129: printf(fmt);
130: #define dbg_dump(lvl, msg, len, buf) \
131: if (len && ipmi_dbg >= lvl) \
132: dumpb(msg, len, (const u_int8_t *)(buf));
133: #else
134: #define dbg_printf(lvl, fmt...)
135: #define dbg_dump(lvl, msg, len, buf)
136: #endif
137:
138: long signextend(unsigned long, int);
139:
140: SLIST_HEAD(ipmi_sensors_head, ipmi_sensor);
141: struct ipmi_sensors_head ipmi_sensor_list =
142: SLIST_HEAD_INITIALIZER(&ipmi_sensor_list);
143:
144: struct timeout ipmi_timeout;
145:
146: void dumpb(const char *, int, const u_int8_t *);
147:
148: int read_sensor(struct ipmi_softc *, struct ipmi_sensor *);
149: int add_sdr_sensor(struct ipmi_softc *, u_int8_t *);
150: int get_sdr_partial(struct ipmi_softc *, u_int16_t, u_int16_t,
151: u_int8_t, u_int8_t, void *, u_int16_t *);
152: int get_sdr(struct ipmi_softc *, u_int16_t, u_int16_t *);
153:
154: int ipmi_sendcmd(struct ipmi_softc *, int, int, int, int, int, const void*);
155: int ipmi_recvcmd(struct ipmi_softc *, int, int *, void *);
156: void ipmi_delay(struct ipmi_softc *, int);
157:
158: int ipmi_watchdog(void *, int);
159:
160: int ipmi_intr(void *);
161: int ipmi_match(struct device *, void *, void *);
162: void ipmi_attach(struct device *, struct device *, void *);
163:
164: long ipow(long, int);
165: long ipmi_convert(u_int8_t, struct sdrtype1 *, long);
166: void ipmi_sensor_name(char *, int, u_int8_t, u_int8_t *);
167:
168: /* BMC Helper Functions */
169: u_int8_t bmc_read(struct ipmi_softc *, int);
170: void bmc_write(struct ipmi_softc *, int, u_int8_t);
171: int bmc_io_wait(struct ipmi_softc *, int, u_int8_t, u_int8_t, const char *);
172: int bmc_io_wait_cold(struct ipmi_softc *, int, u_int8_t, u_int8_t,
173: const char *);
174: void _bmc_io_wait(void *);
175:
176: void *bt_buildmsg(struct ipmi_softc *, int, int, int, const void *, int *);
177: void *cmn_buildmsg(struct ipmi_softc *, int, int, int, const void *, int *);
178:
179: int getbits(u_int8_t *, int, int);
180: int ipmi_sensor_type(int, int, int);
181:
182: void ipmi_smbios_probe(struct smbios_ipmi *, struct ipmi_attach_args *);
183: void ipmi_refresh_sensors(struct ipmi_softc *sc);
184: int ipmi_map_regs(struct ipmi_softc *sc, struct ipmi_attach_args *ia);
185: void ipmi_unmap_regs(struct ipmi_softc *sc, struct ipmi_attach_args *ia);
186:
187: void *scan_sig(long, long, int, int, const void *);
188:
189: int ipmi_test_threshold(u_int8_t, u_int8_t, u_int8_t, u_int8_t);
190: int ipmi_sensor_status(struct ipmi_softc *, struct ipmi_sensor *,
191: u_int8_t *);
192:
193: int add_child_sensors(struct ipmi_softc *, u_int8_t *, int, int, int,
194: int, int, int, const char *);
195:
196: struct ipmi_if kcs_if = {
197: "KCS",
198: IPMI_IF_KCS_NREGS,
199: cmn_buildmsg,
200: kcs_sendmsg,
201: kcs_recvmsg,
202: kcs_reset,
203: kcs_probe,
204: };
205:
206: struct ipmi_if smic_if = {
207: "SMIC",
208: IPMI_IF_SMIC_NREGS,
209: cmn_buildmsg,
210: smic_sendmsg,
211: smic_recvmsg,
212: smic_reset,
213: smic_probe,
214: };
215:
216: struct ipmi_if bt_if = {
217: "BT",
218: IPMI_IF_BT_NREGS,
219: bt_buildmsg,
220: bt_sendmsg,
221: bt_recvmsg,
222: bt_reset,
223: bt_probe,
224: };
225:
226: struct ipmi_if *ipmi_get_if(int);
227:
228: struct ipmi_if *
229: ipmi_get_if(int iftype)
230: {
231: switch (iftype) {
232: case IPMI_IF_KCS:
233: return (&kcs_if);
234: case IPMI_IF_SMIC:
235: return (&smic_if);
236: case IPMI_IF_BT:
237: return (&bt_if);
238: }
239:
240: return (NULL);
241: }
242:
243: /*
244: * BMC Helper Functions
245: */
246: u_int8_t
247: bmc_read(struct ipmi_softc *sc, int offset)
248: {
249: return (bus_space_read_1(sc->sc_iot, sc->sc_ioh,
250: offset * sc->sc_if_iospacing));
251: }
252:
253: void
254: bmc_write(struct ipmi_softc *sc, int offset, u_int8_t val)
255: {
256: bus_space_write_1(sc->sc_iot, sc->sc_ioh,
257: offset * sc->sc_if_iospacing, val);
258: }
259:
260: void
261: _bmc_io_wait(void *arg)
262: {
263: struct ipmi_softc *sc = arg;
264: struct ipmi_bmc_args *a = sc->sc_iowait_args;
265:
266: *a->v = bmc_read(sc, a->offset);
267: if ((*a->v & a->mask) == a->value) {
268: sc->sc_wakeup = 0;
269: wakeup(sc);
270: return;
271: }
272:
273: if (++sc->sc_retries > sc->sc_max_retries) {
274: sc->sc_wakeup = 0;
275: wakeup(sc);
276: return;
277: }
278:
279: timeout_add(&sc->sc_timeout, 1);
280: }
281:
282: int
283: bmc_io_wait(struct ipmi_softc *sc, int offset, u_int8_t mask, u_int8_t value,
284: const char *lbl)
285: {
286: volatile u_int8_t v;
287: struct ipmi_bmc_args args;
288:
289: if (cold)
290: return (bmc_io_wait_cold(sc, offset, mask, value, lbl));
291:
292: sc->sc_retries = 0;
293: sc->sc_wakeup = 1;
294:
295: args.offset = offset;
296: args.mask = mask;
297: args.value = value;
298: args.v = &v;
299: sc->sc_iowait_args = &args;
300:
301: _bmc_io_wait(sc);
302:
303: while (sc->sc_wakeup)
304: tsleep(sc, PWAIT, lbl, 0);
305:
306: if (sc->sc_retries > sc->sc_max_retries) {
307: dbg_printf(1, "%s: bmc_io_wait fails : v=%.2x m=%.2x "
308: "b=%.2x %s\n", DEVNAME(sc), v, mask, value, lbl);
309: return (-1);
310: }
311:
312: return (v);
313: }
314:
315: int
316: bmc_io_wait_cold(struct ipmi_softc *sc, int offset, u_int8_t mask,
317: u_int8_t value, const char *lbl)
318: {
319: volatile u_int8_t v;
320: int count = 5000000; /* == 5s XXX can be shorter */
321:
322: while (count--) {
323: v = bmc_read(sc, offset);
324: if ((v & mask) == value)
325: return v;
326:
327: delay(1);
328: }
329:
330: dbg_printf(1, "%s: bmc_io_wait_cold fails : *v=%.2x m=%.2x b=%.2x %s\n",
331: DEVNAME(sc), v, mask, value, lbl);
332: return (-1);
333:
334: }
335:
336: #define NETFN_LUN(nf,ln) (((nf) << 2) | ((ln) & 0x3))
337:
338: /*
339: * BT interface
340: */
341: #define _BT_CTRL_REG 0
342: #define BT_CLR_WR_PTR (1L << 0)
343: #define BT_CLR_RD_PTR (1L << 1)
344: #define BT_HOST2BMC_ATN (1L << 2)
345: #define BT_BMC2HOST_ATN (1L << 3)
346: #define BT_EVT_ATN (1L << 4)
347: #define BT_HOST_BUSY (1L << 6)
348: #define BT_BMC_BUSY (1L << 7)
349:
350: #define BT_READY (BT_HOST_BUSY|BT_HOST2BMC_ATN|BT_BMC2HOST_ATN)
351:
352: #define _BT_DATAIN_REG 1
353: #define _BT_DATAOUT_REG 1
354:
355: #define _BT_INTMASK_REG 2
356: #define BT_IM_HIRQ_PEND (1L << 1)
357: #define BT_IM_SCI_EN (1L << 2)
358: #define BT_IM_SMI_EN (1L << 3)
359: #define BT_IM_NMI2SMI (1L << 4)
360:
361: int bt_read(struct ipmi_softc *, int);
362: int bt_write(struct ipmi_softc *, int, uint8_t);
363:
364: int
365: bt_read(struct ipmi_softc *sc, int reg)
366: {
367: return bmc_read(sc, reg);
368: }
369:
370: int
371: bt_write(struct ipmi_softc *sc, int reg, uint8_t data)
372: {
373: if (bmc_io_wait(sc, _BT_CTRL_REG, BT_BMC_BUSY, 0, "bt_write") < 0)
374: return (-1);
375:
376: bmc_write(sc, reg, data);
377: return (0);
378: }
379:
380: int
381: bt_sendmsg(struct ipmi_softc *sc, int len, const u_int8_t *data)
382: {
383: int i;
384:
385: bt_write(sc, _BT_CTRL_REG, BT_CLR_WR_PTR);
386: for (i = 0; i < len; i++)
387: bt_write(sc, _BT_DATAOUT_REG, data[i]);
388:
389: bt_write(sc, _BT_CTRL_REG, BT_HOST2BMC_ATN);
390: if (bmc_io_wait(sc, _BT_CTRL_REG, BT_HOST2BMC_ATN | BT_BMC_BUSY, 0,
391: "bt_sendwait") < 0)
392: return (-1);
393:
394: return (0);
395: }
396:
397: int
398: bt_recvmsg(struct ipmi_softc *sc, int maxlen, int *rxlen, u_int8_t *data)
399: {
400: u_int8_t len, v, i;
401:
402: if (bmc_io_wait(sc, _BT_CTRL_REG, BT_BMC2HOST_ATN, BT_BMC2HOST_ATN,
403: "bt_recvwait") < 0)
404: return (-1);
405:
406: bt_write(sc, _BT_CTRL_REG, BT_HOST_BUSY);
407: bt_write(sc, _BT_CTRL_REG, BT_BMC2HOST_ATN);
408: bt_write(sc, _BT_CTRL_REG, BT_CLR_RD_PTR);
409: len = bt_read(sc, _BT_DATAIN_REG);
410: for (i = IPMI_BTMSG_NFLN; i <= len; i++) {
411: v = bt_read(sc, _BT_DATAIN_REG);
412: if (i != IPMI_BTMSG_SEQ)
413: *(data++) = v;
414: }
415: bt_write(sc, _BT_CTRL_REG, BT_HOST_BUSY);
416: *rxlen = len - 1;
417:
418: return (0);
419: }
420:
421: int
422: bt_reset(struct ipmi_softc *sc)
423: {
424: return (-1);
425: }
426:
427: int
428: bt_probe(struct ipmi_softc *sc)
429: {
430: u_int8_t rv;
431:
432: rv = bmc_read(sc, _BT_CTRL_REG);
433: rv &= BT_HOST_BUSY;
434: rv |= BT_CLR_WR_PTR|BT_CLR_RD_PTR|BT_BMC2HOST_ATN|BT_HOST2BMC_ATN;
435: bmc_write(sc, _BT_CTRL_REG, rv);
436:
437: rv = bmc_read(sc, _BT_INTMASK_REG);
438: rv &= BT_IM_SCI_EN|BT_IM_SMI_EN|BT_IM_NMI2SMI;
439: rv |= BT_IM_HIRQ_PEND;
440: bmc_write(sc, _BT_INTMASK_REG, rv);
441:
442: #if 0
443: printf("bt_probe: %2x\n", v);
444: printf(" WR : %2x\n", v & BT_CLR_WR_PTR);
445: printf(" RD : %2x\n", v & BT_CLR_RD_PTR);
446: printf(" H2B : %2x\n", v & BT_HOST2BMC_ATN);
447: printf(" B2H : %2x\n", v & BT_BMC2HOST_ATN);
448: printf(" EVT : %2x\n", v & BT_EVT_ATN);
449: printf(" HBSY : %2x\n", v & BT_HOST_BUSY);
450: printf(" BBSY : %2x\n", v & BT_BMC_BUSY);
451: #endif
452: return (0);
453: }
454:
455: /*
456: * SMIC interface
457: */
458: #define _SMIC_DATAIN_REG 0
459: #define _SMIC_DATAOUT_REG 0
460:
461: #define _SMIC_CTRL_REG 1
462: #define SMS_CC_GET_STATUS 0x40
463: #define SMS_CC_START_TRANSFER 0x41
464: #define SMS_CC_NEXT_TRANSFER 0x42
465: #define SMS_CC_END_TRANSFER 0x43
466: #define SMS_CC_START_RECEIVE 0x44
467: #define SMS_CC_NEXT_RECEIVE 0x45
468: #define SMS_CC_END_RECEIVE 0x46
469: #define SMS_CC_TRANSFER_ABORT 0x47
470:
471: #define SMS_SC_READY 0xc0
472: #define SMS_SC_WRITE_START 0xc1
473: #define SMS_SC_WRITE_NEXT 0xc2
474: #define SMS_SC_WRITE_END 0xc3
475: #define SMS_SC_READ_START 0xc4
476: #define SMS_SC_READ_NEXT 0xc5
477: #define SMS_SC_READ_END 0xc6
478:
479: #define _SMIC_FLAG_REG 2
480: #define SMIC_BUSY (1L << 0)
481: #define SMIC_SMS_ATN (1L << 2)
482: #define SMIC_EVT_ATN (1L << 3)
483: #define SMIC_SMI (1L << 4)
484: #define SMIC_TX_DATA_RDY (1L << 6)
485: #define SMIC_RX_DATA_RDY (1L << 7)
486:
487: int smic_wait(struct ipmi_softc *, u_int8_t, u_int8_t, const char *);
488: int smic_write_cmd_data(struct ipmi_softc *, u_int8_t, const u_int8_t *);
489: int smic_read_data(struct ipmi_softc *, u_int8_t *);
490:
491: int
492: smic_wait(struct ipmi_softc *sc, u_int8_t mask, u_int8_t val, const char *lbl)
493: {
494: int v;
495:
496: /* Wait for expected flag bits */
497: v = bmc_io_wait(sc, _SMIC_FLAG_REG, mask, val, "smicwait");
498: if (v < 0)
499: return (-1);
500:
501: /* Return current status */
502: v = bmc_read(sc, _SMIC_CTRL_REG);
503: dbg_printf(99, "smic_wait = %.2x\n", v);
504: return (v);
505: }
506:
507: int
508: smic_write_cmd_data(struct ipmi_softc *sc, u_int8_t cmd, const u_int8_t *data)
509: {
510: int sts, v;
511:
512: dbg_printf(50, "smic_wcd: %.2x %.2x\n", cmd, data ? *data : -1);
513: sts = smic_wait(sc, SMIC_TX_DATA_RDY | SMIC_BUSY, SMIC_TX_DATA_RDY,
514: "smic_write_cmd_data ready");
515: if (sts < 0)
516: return (sts);
517:
518: bmc_write(sc, _SMIC_CTRL_REG, cmd);
519: if (data)
520: bmc_write(sc, _SMIC_DATAOUT_REG, *data);
521:
522: /* Toggle BUSY bit, then wait for busy bit to clear */
523: v = bmc_read(sc, _SMIC_FLAG_REG);
524: bmc_write(sc, _SMIC_FLAG_REG, v | SMIC_BUSY);
525:
526: return (smic_wait(sc, SMIC_BUSY, 0, "smic_write_cmd_data busy"));
527: }
528:
529: int
530: smic_read_data(struct ipmi_softc *sc, u_int8_t *data)
531: {
532: int sts;
533:
534: sts = smic_wait(sc, SMIC_RX_DATA_RDY | SMIC_BUSY, SMIC_RX_DATA_RDY,
535: "smic_read_data");
536: if (sts >= 0) {
537: *data = bmc_read(sc, _SMIC_DATAIN_REG);
538: dbg_printf(50, "smic_readdata: %.2x\n", *data);
539: }
540: return (sts);
541: }
542:
543: #define ErrStat(a,b) if (a) printf(b);
544:
545: int
546: smic_sendmsg(struct ipmi_softc *sc, int len, const u_int8_t *data)
547: {
548: int sts, idx;
549:
550: sts = smic_write_cmd_data(sc, SMS_CC_START_TRANSFER, &data[0]);
551: ErrStat(sts != SMS_SC_WRITE_START, "wstart");
552: for (idx = 1; idx < len - 1; idx++) {
553: sts = smic_write_cmd_data(sc, SMS_CC_NEXT_TRANSFER,
554: &data[idx]);
555: ErrStat(sts != SMS_SC_WRITE_NEXT, "write");
556: }
557: sts = smic_write_cmd_data(sc, SMS_CC_END_TRANSFER, &data[idx]);
558: if (sts != SMS_SC_WRITE_END) {
559: dbg_printf(50, "smic_sendmsg %d/%d = %.2x\n", idx, len, sts);
560: return (-1);
561: }
562:
563: return (0);
564: }
565:
566: int
567: smic_recvmsg(struct ipmi_softc *sc, int maxlen, int *len, u_int8_t *data)
568: {
569: int sts, idx;
570:
571: *len = 0;
572: sts = smic_wait(sc, SMIC_RX_DATA_RDY, SMIC_RX_DATA_RDY, "smic_recvmsg");
573: if (sts < 0)
574: return (-1);
575:
576: sts = smic_write_cmd_data(sc, SMS_CC_START_RECEIVE, NULL);
577: ErrStat(sts != SMS_SC_READ_START, "rstart");
578: for (idx = 0;; ) {
579: sts = smic_read_data(sc, &data[idx++]);
580: if (sts != SMS_SC_READ_START && sts != SMS_SC_READ_NEXT)
581: break;
582: smic_write_cmd_data(sc, SMS_CC_NEXT_RECEIVE, NULL);
583: }
584: ErrStat(sts != SMS_SC_READ_END, "rend");
585:
586: *len = idx;
587:
588: sts = smic_write_cmd_data(sc, SMS_CC_END_RECEIVE, NULL);
589: if (sts != SMS_SC_READY) {
590: dbg_printf(50, "smic_recvmsg %d/%d = %.2x\n", idx, maxlen, sts);
591: return (-1);
592: }
593:
594: return (0);
595: }
596:
597: int
598: smic_reset(struct ipmi_softc *sc)
599: {
600: return (-1);
601: }
602:
603: int
604: smic_probe(struct ipmi_softc *sc)
605: {
606: /* Flag register should not be 0xFF on a good system */
607: if (bmc_read(sc, _SMIC_FLAG_REG) == 0xFF)
608: return (-1);
609:
610: return (0);
611: }
612:
613: /*
614: * KCS interface
615: */
616: #define _KCS_DATAIN_REGISTER 0
617: #define _KCS_DATAOUT_REGISTER 0
618: #define KCS_READ_NEXT 0x68
619:
620: #define _KCS_COMMAND_REGISTER 1
621: #define KCS_GET_STATUS 0x60
622: #define KCS_WRITE_START 0x61
623: #define KCS_WRITE_END 0x62
624:
625: #define _KCS_STATUS_REGISTER 1
626: #define KCS_OBF (1L << 0)
627: #define KCS_IBF (1L << 1)
628: #define KCS_SMS_ATN (1L << 2)
629: #define KCS_CD (1L << 3)
630: #define KCS_OEM1 (1L << 4)
631: #define KCS_OEM2 (1L << 5)
632: #define KCS_STATE_MASK 0xc0
633: #define KCS_IDLE_STATE 0x00
634: #define KCS_READ_STATE 0x40
635: #define KCS_WRITE_STATE 0x80
636: #define KCS_ERROR_STATE 0xC0
637:
638: int kcs_wait(struct ipmi_softc *, u_int8_t, u_int8_t, const char *);
639: int kcs_write_cmd(struct ipmi_softc *, u_int8_t);
640: int kcs_write_data(struct ipmi_softc *, u_int8_t);
641: int kcs_read_data(struct ipmi_softc *, u_int8_t *);
642:
643: int
644: kcs_wait(struct ipmi_softc *sc, u_int8_t mask, u_int8_t value, const char *lbl)
645: {
646: int v;
647:
648: v = bmc_io_wait(sc, _KCS_STATUS_REGISTER, mask, value, lbl);
649: if (v < 0)
650: return (v);
651:
652: /* Check if output buffer full, read dummy byte */
653: if ((v & (KCS_OBF | KCS_STATE_MASK)) == (KCS_OBF | KCS_WRITE_STATE))
654: bmc_read(sc, _KCS_DATAIN_REGISTER);
655:
656: /* Check for error state */
657: if ((v & KCS_STATE_MASK) == KCS_ERROR_STATE) {
658: bmc_write(sc, _KCS_COMMAND_REGISTER, KCS_GET_STATUS);
659: while (bmc_read(sc, _KCS_STATUS_REGISTER) & KCS_IBF)
660: ;
661: printf("%s: error code: %x\n", DEVNAME(sc),
662: bmc_read(sc, _KCS_DATAIN_REGISTER));
663: }
664:
665: return (v & KCS_STATE_MASK);
666: }
667:
668: int
669: kcs_write_cmd(struct ipmi_softc *sc, u_int8_t cmd)
670: {
671: /* ASSERT: IBF and OBF are clear */
672: dbg_printf(50, "kcswritecmd: %.2x\n", cmd);
673: bmc_write(sc, _KCS_COMMAND_REGISTER, cmd);
674:
675: return (kcs_wait(sc, KCS_IBF, 0, "write_cmd"));
676: }
677:
678: int
679: kcs_write_data(struct ipmi_softc *sc, u_int8_t data)
680: {
681: /* ASSERT: IBF and OBF are clear */
682: dbg_printf(50, "kcswritedata: %.2x\n", data);
683: bmc_write(sc, _KCS_DATAOUT_REGISTER, data);
684:
685: return (kcs_wait(sc, KCS_IBF, 0, "write_data"));
686: }
687:
688: int
689: kcs_read_data(struct ipmi_softc *sc, u_int8_t * data)
690: {
691: int sts;
692:
693: sts = kcs_wait(sc, KCS_IBF | KCS_OBF, KCS_OBF, "read_data");
694: if (sts != KCS_READ_STATE)
695: return (sts);
696:
697: /* ASSERT: OBF is set read data, request next byte */
698: *data = bmc_read(sc, _KCS_DATAIN_REGISTER);
699: bmc_write(sc, _KCS_DATAOUT_REGISTER, KCS_READ_NEXT);
700:
701: dbg_printf(50, "kcsreaddata: %.2x\n", *data);
702:
703: return (sts);
704: }
705:
706: /* Exported KCS functions */
707: int
708: kcs_sendmsg(struct ipmi_softc *sc, int len, const u_int8_t * data)
709: {
710: int idx, sts;
711:
712: /* ASSERT: IBF is clear */
713: dbg_dump(50, "kcs sendmsg", len, data);
714: sts = kcs_write_cmd(sc, KCS_WRITE_START);
715: for (idx = 0; idx < len; idx++) {
716: if (idx == len - 1)
717: sts = kcs_write_cmd(sc, KCS_WRITE_END);
718:
719: if (sts != KCS_WRITE_STATE)
720: break;
721:
722: sts = kcs_write_data(sc, data[idx]);
723: }
724: if (sts != KCS_READ_STATE) {
725: dbg_printf(1, "kcs sendmsg = %d/%d <%.2x>\n", idx, len, sts);
726: dbg_dump(1, "kcs_sendmsg", len, data);
727: return (-1);
728: }
729:
730: return (0);
731: }
732:
733: int
734: kcs_recvmsg(struct ipmi_softc *sc, int maxlen, int *rxlen, u_int8_t * data)
735: {
736: int idx, sts;
737:
738: for (idx = 0; idx < maxlen; idx++) {
739: sts = kcs_read_data(sc, &data[idx]);
740: if (sts != KCS_READ_STATE)
741: break;
742: }
743: sts = kcs_wait(sc, KCS_IBF, 0, "recv");
744: *rxlen = idx;
745: if (sts != KCS_IDLE_STATE) {
746: dbg_printf(1, "kcs read = %d/%d <%.2x>\n", idx, maxlen, sts);
747: return (-1);
748: }
749:
750: dbg_dump(50, "kcs recvmsg", idx, data);
751:
752: return (0);
753: }
754:
755: int
756: kcs_reset(struct ipmi_softc *sc)
757: {
758: return (-1);
759: }
760:
761: int
762: kcs_probe(struct ipmi_softc *sc)
763: {
764: u_int8_t v;
765:
766: v = bmc_read(sc, _KCS_STATUS_REGISTER);
767: #if 0
768: printf("kcs_probe: %2x\n", v);
769: printf(" STS: %2x\n", v & KCS_STATE_MASK);
770: printf(" ATN: %2x\n", v & KCS_SMS_ATN);
771: printf(" C/D: %2x\n", v & KCS_CD);
772: printf(" IBF: %2x\n", v & KCS_IBF);
773: printf(" OBF: %2x\n", v & KCS_OBF);
774: #endif
775: return (0);
776: }
777:
778: /*
779: * IPMI code
780: */
781: #define READ_SMS_BUFFER 0x37
782: #define WRITE_I2C 0x50
783:
784: #define GET_MESSAGE_CMD 0x33
785: #define SEND_MESSAGE_CMD 0x34
786:
787: #define IPMB_CHANNEL_NUMBER 0
788:
789: #define PUBLIC_BUS 0
790:
791: #define MIN_I2C_PACKET_SIZE 3
792: #define MIN_IMB_PACKET_SIZE 7 /* one byte for cksum */
793:
794: #define MIN_BTBMC_REQ_SIZE 4
795: #define MIN_BTBMC_RSP_SIZE 5
796: #define MIN_BMC_REQ_SIZE 2
797: #define MIN_BMC_RSP_SIZE 3
798:
799: #define BMC_SA 0x20 /* BMC/ESM3 */
800: #define FPC_SA 0x22 /* front panel */
801: #define BP_SA 0xC0 /* Primary Backplane */
802: #define BP2_SA 0xC2 /* Secondary Backplane */
803: #define PBP_SA 0xC4 /* Peripheral Backplane */
804: #define DRAC_SA 0x28 /* DRAC-III */
805: #define DRAC3_SA 0x30 /* DRAC-III */
806: #define BMC_LUN 0
807: #define SMS_LUN 2
808:
809: struct ipmi_request {
810: u_int8_t rsSa;
811: u_int8_t rsLun;
812: u_int8_t netFn;
813: u_int8_t cmd;
814: u_int8_t data_len;
815: u_int8_t *data;
816: };
817:
818: struct ipmi_response {
819: u_int8_t cCode;
820: u_int8_t data_len;
821: u_int8_t *data;
822: };
823:
824: struct ipmi_bmc_request {
825: u_int8_t bmc_nfLn;
826: u_int8_t bmc_cmd;
827: u_int8_t bmc_data_len;
828: u_int8_t bmc_data[1];
829: };
830:
831: struct ipmi_bmc_response {
832: u_int8_t bmc_nfLn;
833: u_int8_t bmc_cmd;
834: u_int8_t bmc_cCode;
835: u_int8_t bmc_data_len;
836: u_int8_t bmc_data[1];
837: };
838:
839: struct cfattach ipmi_ca = {
840: sizeof(struct ipmi_softc), ipmi_match, ipmi_attach
841: };
842:
843: struct cfdriver ipmi_cd = {
844: NULL, "ipmi", DV_DULL
845: };
846:
847: /* Scan memory for signature */
848: void *
849: scan_sig(long start, long end, int skip, int len, const void *data)
850: {
851: void *va;
852:
853: while (start < end) {
854: va = ISA_HOLE_VADDR(start);
855: if (memcmp(va, data, len) == 0)
856: return (va);
857:
858: start += skip;
859: }
860:
861: return (NULL);
862: }
863:
864: void
865: dumpb(const char *lbl, int len, const u_int8_t *data)
866: {
867: int idx;
868:
869: printf("%s: ", lbl);
870: for (idx = 0; idx < len; idx++)
871: printf("%.2x ", data[idx]);
872:
873: printf("\n");
874: }
875:
876: void
877: ipmi_smbios_probe(struct smbios_ipmi *pipmi, struct ipmi_attach_args *ia)
878: {
879:
880: dbg_printf(1, "ipmi_smbios_probe: %02x %02x %02x %02x %08llx %02x "
881: "%02x\n",
882: pipmi->smipmi_if_type,
883: pipmi->smipmi_if_rev,
884: pipmi->smipmi_i2c_address,
885: pipmi->smipmi_nvram_address,
886: pipmi->smipmi_base_address,
887: pipmi->smipmi_base_flags,
888: pipmi->smipmi_irq);
889:
890: ia->iaa_if_type = pipmi->smipmi_if_type;
891: ia->iaa_if_rev = pipmi->smipmi_if_rev;
892: ia->iaa_if_irq = (pipmi->smipmi_base_flags & SMIPMI_FLAG_IRQEN) ?
893: pipmi->smipmi_irq : -1;
894: ia->iaa_if_irqlvl = (pipmi->smipmi_base_flags & SMIPMI_FLAG_IRQLVL) ?
895: IST_LEVEL : IST_EDGE;
896:
897: switch (SMIPMI_FLAG_IFSPACING(pipmi->smipmi_base_flags)) {
898: case IPMI_IOSPACING_BYTE:
899: ia->iaa_if_iospacing = 1;
900: break;
901:
902: case IPMI_IOSPACING_DWORD:
903: ia->iaa_if_iospacing = 4;
904: break;
905:
906: case IPMI_IOSPACING_WORD:
907: ia->iaa_if_iospacing = 2;
908: break;
909:
910: default:
911: ia->iaa_if_iospacing = 1;
912: printf("ipmi: unknown register spacing\n");
913: }
914:
915: /* Calculate base address (PCI BAR format) */
916: if (pipmi->smipmi_base_address & 0x1) {
917: ia->iaa_if_iotype = 'i';
918: ia->iaa_if_iobase = pipmi->smipmi_base_address & ~0x1;
919: } else {
920: ia->iaa_if_iotype = 'm';
921: ia->iaa_if_iobase = pipmi->smipmi_base_address & ~0xF;
922: }
923: if (pipmi->smipmi_base_flags & SMIPMI_FLAG_ODDOFFSET)
924: ia->iaa_if_iobase++;
925:
926: if (pipmi->smipmi_base_flags == 0x7f) {
927: /* IBM 325 eServer workaround */
928: ia->iaa_if_iospacing = 1;
929: ia->iaa_if_iobase = pipmi->smipmi_base_address;
930: ia->iaa_if_iotype = 'i';
931: return;
932: }
933: }
934:
935: /*
936: * bt_buildmsg builds an IPMI message from a nfLun, cmd, and data
937: * This is used by BT protocol
938: *
939: * Returns a buffer to an allocated message, txlen contains length
940: * of allocated message
941: */
942: void *
943: bt_buildmsg(struct ipmi_softc *sc, int nfLun, int cmd, int len,
944: const void *data, int *txlen)
945: {
946: u_int8_t *buf;
947:
948: /* Block transfer needs 4 extra bytes: length/netfn/seq/cmd + data */
949: *txlen = len + 4;
950: buf = malloc(*txlen, M_DEVBUF, M_NOWAIT|M_CANFAIL);
951: if (buf == NULL)
952: return (NULL);
953:
954: buf[IPMI_BTMSG_LEN] = len + 3;
955: buf[IPMI_BTMSG_NFLN] = nfLun;
956: buf[IPMI_BTMSG_SEQ] = sc->sc_btseq++;
957: buf[IPMI_BTMSG_CMD] = cmd;
958: if (len && data)
959: memcpy(buf + IPMI_BTMSG_DATASND, data, len);
960:
961: return (buf);
962: }
963:
964: /*
965: * cmn_buildmsg builds an IPMI message from a nfLun, cmd, and data
966: * This is used by both SMIC and KCS protocols
967: *
968: * Returns a buffer to an allocated message, txlen contains length
969: * of allocated message
970: */
971: void *
972: cmn_buildmsg(struct ipmi_softc *sc, int nfLun, int cmd, int len,
973: const void *data, int *txlen)
974: {
975: u_int8_t *buf;
976:
977: /* Common needs two extra bytes: nfLun/cmd + data */
978: *txlen = len + 2;
979: buf = malloc(*txlen, M_DEVBUF, M_NOWAIT|M_CANFAIL);
980: if (buf == NULL)
981: return (NULL);
982:
983: buf[IPMI_MSG_NFLN] = nfLun;
984: buf[IPMI_MSG_CMD] = cmd;
985: if (len && data)
986: memcpy(buf + IPMI_MSG_DATASND, data, len);
987:
988: return (buf);
989: }
990:
991: /* Send an IPMI command */
992: int
993: ipmi_sendcmd(struct ipmi_softc *sc, int rssa, int rslun, int netfn, int cmd,
994: int txlen, const void *data)
995: {
996: u_int8_t *buf;
997: int rc = -1;
998:
999: dbg_printf(50, "ipmi_sendcmd: rssa=%.2x nfln=%.2x cmd=%.2x len=%.2x\n",
1000: rssa, NETFN_LUN(netfn, rslun), cmd, txlen);
1001: dbg_dump(10, " send", txlen, data);
1002: if (rssa != BMC_SA) {
1003: #if 0
1004: buf = sc->sc_if->buildmsg(sc, NETFN_LUN(APP_NETFN, BMC_LUN),
1005: APP_SEND_MESSAGE, 7 + txlen, NULL, &txlen);
1006: pI2C->bus = (sc->if_ver == 0x09) ?
1007: PUBLIC_BUS :
1008: IPMB_CHANNEL_NUMBER;
1009:
1010: imbreq->rsSa = rssa;
1011: imbreq->nfLn = NETFN_LUN(netfn, rslun);
1012: imbreq->cSum1 = -(imbreq->rsSa + imbreq->nfLn);
1013: imbreq->rqSa = BMC_SA;
1014: imbreq->seqLn = NETFN_LUN(sc->imb_seq++, SMS_LUN);
1015: imbreq->cmd = cmd;
1016: if (txlen)
1017: memcpy(imbreq->data, data, txlen);
1018: /* Set message checksum */
1019: imbreq->data[txlen] = cksum8(&imbreq->rqSa, txlen + 3);
1020: #endif
1021: goto done;
1022: } else
1023: buf = sc->sc_if->buildmsg(sc, NETFN_LUN(netfn, rslun), cmd,
1024: txlen, data, &txlen);
1025:
1026: if (buf == NULL) {
1027: printf("%s: sendcmd malloc fails\n", DEVNAME(sc));
1028: goto done;
1029: }
1030: rc = sc->sc_if->sendmsg(sc, txlen, buf);
1031: free(buf, M_DEVBUF);
1032:
1033: ipmi_delay(sc, 5); /* give bmc chance to digest command */
1034:
1035: done:
1036: return (rc);
1037: }
1038:
1039: int
1040: ipmi_recvcmd(struct ipmi_softc *sc, int maxlen, int *rxlen, void *data)
1041: {
1042: u_int8_t *buf, rc = 0;
1043: int rawlen;
1044:
1045: /* Need three extra bytes: netfn/cmd/ccode + data */
1046: buf = malloc(maxlen + 3, M_DEVBUF, M_NOWAIT|M_CANFAIL);
1047: if (buf == NULL) {
1048: printf("%s: ipmi_recvcmd: malloc fails\n", DEVNAME(sc));
1049: return (-1);
1050: }
1051: /* Receive message from interface, copy out result data */
1052: if (sc->sc_if->recvmsg(sc, maxlen + 3, &rawlen, buf))
1053: return (-1);
1054:
1055: *rxlen = rawlen - IPMI_MSG_DATARCV;
1056: if (*rxlen > 0 && data)
1057: memcpy(data, buf + IPMI_MSG_DATARCV, *rxlen);
1058:
1059: rc = buf[IPMI_MSG_CCODE];
1060: #ifdef IPMI_DEBUG
1061: if (rc != 0)
1062: dbg_printf(1, "ipmi_recvmsg: nfln=%.2x cmd=%.2x err=%.2x\n",
1063: buf[IPMI_MSG_NFLN], buf[IPMI_MSG_CMD], buf[IPMI_MSG_CCODE]);
1064: #endif
1065:
1066: dbg_printf(50, "ipmi_recvcmd: nfln=%.2x cmd=%.2x err=%.2x len=%.2x\n",
1067: buf[IPMI_MSG_NFLN], buf[IPMI_MSG_CMD], buf[IPMI_MSG_CCODE],
1068: *rxlen);
1069: dbg_dump(10, " recv", *rxlen, data);
1070:
1071: free(buf, M_DEVBUF);
1072:
1073: ipmi_delay(sc, 5); /* give bmc chance to digest command */
1074:
1075: return (rc);
1076: }
1077:
1078: void
1079: ipmi_delay(struct ipmi_softc *sc, int period)
1080: {
1081: /* period is in 10 ms increments */
1082: if (cold)
1083: delay(period * 10000);
1084: else
1085: while (tsleep(sc, PWAIT, "ipmicmd", period) != EWOULDBLOCK);
1086: }
1087:
1088: /* Read a partial SDR entry */
1089: int
1090: get_sdr_partial(struct ipmi_softc *sc, u_int16_t recordId, u_int16_t reserveId,
1091: u_int8_t offset, u_int8_t length, void *buffer, u_int16_t *nxtRecordId)
1092: {
1093: u_int8_t cmd[8 + length];
1094: int len;
1095:
1096: ((u_int16_t *) cmd)[0] = reserveId;
1097: ((u_int16_t *) cmd)[1] = recordId;
1098: cmd[4] = offset;
1099: cmd[5] = length;
1100: if (ipmi_sendcmd(sc, BMC_SA, 0, STORAGE_NETFN, STORAGE_GET_SDR, 6,
1101: cmd)) {
1102: printf("%s: sendcmd fails\n", DEVNAME(sc));
1103: return (-1);
1104: }
1105: if (ipmi_recvcmd(sc, 8 + length, &len, cmd)) {
1106: printf("%s: getSdrPartial: recvcmd fails\n", DEVNAME(sc));
1107: return (-1);
1108: }
1109: if (nxtRecordId)
1110: *nxtRecordId = *(uint16_t *) cmd;
1111: memcpy(buffer, cmd + 2, len - 2);
1112:
1113: return (0);
1114: }
1115:
1116: int maxsdrlen = 0x10;
1117:
1118: /* Read an entire SDR; pass to add sensor */
1119: int
1120: get_sdr(struct ipmi_softc *sc, u_int16_t recid, u_int16_t *nxtrec)
1121: {
1122: u_int16_t resid = 0;
1123: int len, sdrlen, offset;
1124: u_int8_t *psdr;
1125: struct sdrhdr shdr;
1126:
1127: /* Reserve SDR */
1128: if (ipmi_sendcmd(sc, BMC_SA, 0, STORAGE_NETFN, STORAGE_RESERVE_SDR,
1129: 0, NULL)) {
1130: printf(": reserve send fails\n");
1131: return (-1);
1132: }
1133: if (ipmi_recvcmd(sc, sizeof(resid), &len, &resid)) {
1134: printf(": reserve recv fails\n");
1135: return (-1);
1136: }
1137: /* Get SDR Header */
1138: if (get_sdr_partial(sc, recid, resid, 0, sizeof shdr, &shdr, nxtrec)) {
1139: printf(": get header fails\n");
1140: return (-1);
1141: }
1142: /* Allocate space for entire SDR Length of SDR in header does not
1143: * include header length */
1144: sdrlen = sizeof(shdr) + shdr.record_length;
1145: psdr = malloc(sdrlen, M_DEVBUF, M_NOWAIT|M_CANFAIL);
1146: if (psdr == NULL)
1147: return -1;
1148:
1149: memcpy(psdr, &shdr, sizeof(shdr));
1150:
1151: /* Read SDR Data maxsdrlen bytes at a time */
1152: for (offset = sizeof(shdr); offset < sdrlen; offset += maxsdrlen) {
1153: len = sdrlen - offset;
1154: if (len > maxsdrlen)
1155: len = maxsdrlen;
1156:
1157: if (get_sdr_partial(sc, recid, resid, offset, len,
1158: psdr + offset, NULL)) {
1159: printf(": get chunk: %d,%d fails\n", offset, len);
1160: return (-1);
1161: }
1162: }
1163:
1164: /* Add SDR to sensor list, if not wanted, free buffer */
1165: if (add_sdr_sensor(sc, psdr) == 0)
1166: free(psdr, M_DEVBUF);
1167:
1168: return (0);
1169: }
1170:
1171: int
1172: getbits(u_int8_t *bytes, int bitpos, int bitlen)
1173: {
1174: int v;
1175: int mask;
1176:
1177: bitpos += bitlen - 1;
1178: for (v = 0; bitlen--;) {
1179: v <<= 1;
1180: mask = 1L << (bitpos & 7);
1181: if (bytes[bitpos >> 3] & mask)
1182: v |= 1;
1183: bitpos--;
1184: }
1185:
1186: return (v);
1187: }
1188:
1189: /* Decode IPMI sensor name */
1190: void
1191: ipmi_sensor_name(char *name, int len, u_int8_t typelen, u_int8_t *bits)
1192: {
1193: int i, slen;
1194: char bcdplus[] = "0123456789 -.:,_";
1195:
1196: slen = typelen & 0x1F;
1197: switch (typelen >> 6) {
1198: case IPMI_NAME_UNICODE:
1199: //unicode
1200: break;
1201:
1202: case IPMI_NAME_BCDPLUS:
1203: /* Characters are encoded in 4-bit BCDPLUS */
1204: if (len < slen * 2 + 1)
1205: slen = (len >> 1) - 1;
1206: for (i = 0; i < slen; i++) {
1207: *(name++) = bcdplus[bits[i] >> 4];
1208: *(name++) = bcdplus[bits[i] & 0xF];
1209: }
1210: break;
1211:
1212: case IPMI_NAME_ASCII6BIT:
1213: /* Characters are encoded in 6-bit ASCII
1214: * 0x00 - 0x3F maps to 0x20 - 0x5F */
1215: /* XXX: need to calculate max len: slen = 3/4 * len */
1216: if (len < slen + 1)
1217: slen = len - 1;
1218: for (i = 0; i < slen * 8; i += 6)
1219: *(name++) = getbits(bits, i, 6) + ' ';
1220: break;
1221:
1222: case IPMI_NAME_ASCII8BIT:
1223: /* Characters are 8-bit ascii */
1224: if (len < slen + 1)
1225: slen = len - 1;
1226: while (slen--)
1227: *(name++) = *(bits++);
1228: break;
1229: }
1230: *name = 0;
1231: }
1232:
1233: /* Calculate val * 10^exp */
1234: long
1235: ipow(long val, int exp)
1236: {
1237: while (exp > 0) {
1238: val *= 10;
1239: exp--;
1240: }
1241:
1242: while (exp < 0) {
1243: val /= 10;
1244: exp++;
1245: }
1246:
1247: return (val);
1248: }
1249:
1250: /* Sign extend a n-bit value */
1251: long
1252: signextend(unsigned long val, int bits)
1253: {
1254: long msk = (1L << (bits-1))-1;
1255:
1256: return (-(val & ~msk) | val);
1257: }
1258:
1259: /* Convert IPMI reading from sensor factors */
1260: long
1261: ipmi_convert(u_int8_t v, struct sdrtype1 *s1, long adj)
1262: {
1263: short M, B;
1264: char K1, K2;
1265: long val;
1266:
1267: /* Calculate linear reading variables */
1268: M = signextend((((short)(s1->m_tolerance & 0xC0)) << 2) + s1->m, 10);
1269: B = signextend((((short)(s1->b_accuracy & 0xC0)) << 2) + s1->b, 10);
1270: K1 = signextend(s1->rbexp & 0xF, 4);
1271: K2 = signextend(s1->rbexp >> 4, 4);
1272:
1273: /* Calculate sensor reading:
1274: * y = L((M * v + (B * 10^K1)) * 10^(K2+adj)
1275: *
1276: * This commutes out to:
1277: * y = L(M*v * 10^(K2+adj) + B * 10^(K1+K2+adj)); */
1278: val = ipow(M * v, K2 + adj) + ipow(B, K1 + K2 + adj);
1279:
1280: /* Linearization function: y = f(x) 0 : y = x 1 : y = ln(x) 2 : y =
1281: * log10(x) 3 : y = log2(x) 4 : y = e^x 5 : y = 10^x 6 : y = 2^x 7 : y
1282: * = 1/x 8 : y = x^2 9 : y = x^3 10 : y = square root(x) 11 : y = cube
1283: * root(x) */
1284: return (val);
1285: }
1286:
1287: int
1288: ipmi_test_threshold(u_int8_t v, u_int8_t valid, u_int8_t hi, u_int8_t lo)
1289: {
1290: dbg_printf(10, "thresh: %.2x %.2x %.2x %d\n", v, lo, hi,valid);
1291: return ((valid & 1 && lo != 0x00 && v <= lo) ||
1292: (valid & 8 && hi != 0xFF && v >= hi));
1293: }
1294:
1295: int
1296: ipmi_sensor_status(struct ipmi_softc *sc, struct ipmi_sensor *psensor,
1297: u_int8_t *reading)
1298: {
1299: u_int8_t data[32];
1300: struct sdrtype1 *s1 = (struct sdrtype1 *)psensor->i_sdr;
1301: int rxlen, etype;
1302:
1303: /* Get reading of sensor */
1304: switch (psensor->i_sensor.type) {
1305: case SENSOR_TEMP:
1306: psensor->i_sensor.value = ipmi_convert(reading[0], s1, 6);
1307: psensor->i_sensor.value += 273150000;
1308: break;
1309:
1310: case SENSOR_VOLTS_DC:
1311: psensor->i_sensor.value = ipmi_convert(reading[0], s1, 6);
1312: break;
1313:
1314: case SENSOR_FANRPM:
1315: psensor->i_sensor.value = ipmi_convert(reading[0], s1, 0);
1316: if (((s1->units1>>3)&0x7) == 0x3)
1317: psensor->i_sensor.value *= 60; // RPS -> RPM
1318: break;
1319: default:
1320: break;
1321: }
1322:
1323: /* Return Sensor Status */
1324: etype = (psensor->etype << 8) + psensor->stype;
1325: switch (etype) {
1326: case IPMI_SENSOR_TYPE_TEMP:
1327: case IPMI_SENSOR_TYPE_VOLT:
1328: case IPMI_SENSOR_TYPE_FAN:
1329: data[0] = psensor->i_num;
1330: if (ipmi_sendcmd(sc, s1->owner_id, s1->owner_lun,
1331: SE_NETFN, SE_GET_SENSOR_THRESHOLD, 1, data) ||
1332: ipmi_recvcmd(sc, sizeof(data), &rxlen, data))
1333: return (SENSOR_S_UNKNOWN);
1334:
1335: dbg_printf(25, "recvdata: %.2x %.2x %.2x %.2x %.2x %.2x %.2x\n",
1336: data[0], data[1], data[2], data[3], data[4], data[5],
1337: data[6]);
1338:
1339: if (ipmi_test_threshold(*reading, data[0] >> 2 ,
1340: data[6], data[3]))
1341: return (SENSOR_S_CRIT);
1342:
1343: if (ipmi_test_threshold(*reading, data[0] >> 1,
1344: data[5], data[2]))
1345: return (SENSOR_S_CRIT);
1346:
1347: if (ipmi_test_threshold(*reading, data[0] ,
1348: data[4], data[1]))
1349: return (SENSOR_S_WARN);
1350:
1351: break;
1352:
1353: case IPMI_SENSOR_TYPE_INTRUSION:
1354: psensor->i_sensor.value = (reading[2] & 1) ? 1 : 0;
1355: if (reading[2] & 0x1)
1356: return (SENSOR_S_CRIT);
1357: break;
1358:
1359: case IPMI_SENSOR_TYPE_PWRSUPPLY:
1360: /* Reading: 1 = present+powered, 0 = otherwise */
1361: psensor->i_sensor.value = (reading[2] & 1) ? 1 : 0;
1362: if (reading[2] & 0x10) {
1363: /* XXX: Need sysctl type for Power Supply types
1364: * ok: power supply installed && powered
1365: * warn: power supply installed && !powered
1366: * crit: power supply !installed
1367: */
1368: return (SENSOR_S_CRIT);
1369: }
1370: if (reading[2] & 0x08) {
1371: /* Power supply AC lost */
1372: return (SENSOR_S_WARN);
1373: }
1374: break;
1375: }
1376:
1377: return (SENSOR_S_OK);
1378: }
1379:
1380: int
1381: read_sensor(struct ipmi_softc *sc, struct ipmi_sensor *psensor)
1382: {
1383: struct sdrtype1 *s1 = (struct sdrtype1 *) psensor->i_sdr;
1384: u_int8_t data[8];
1385: int rxlen, rv = -1;
1386:
1387: if (!cold)
1388: rw_enter_write(&sc->sc_lock);
1389:
1390: memset(data, 0, sizeof(data));
1391: data[0] = psensor->i_num;
1392: if (ipmi_sendcmd(sc, s1->owner_id, s1->owner_lun, SE_NETFN,
1393: SE_GET_SENSOR_READING, 1, data))
1394: goto done;
1395:
1396: if (ipmi_recvcmd(sc, sizeof(data), &rxlen, data))
1397: goto done;
1398:
1399: dbg_printf(10, "values=%.2x %.2x %.2x %.2x %s\n",
1400: data[0],data[1],data[2],data[3], psensor->i_sensor.desc);
1401: psensor->i_sensor.flags &= ~SENSOR_FINVALID;
1402: if (data[1] & IPMI_INVALID_SENSOR) {
1403: /* Check if sensor is valid */
1404: psensor->i_sensor.flags |= SENSOR_FINVALID;
1405: }
1406: psensor->i_sensor.status = ipmi_sensor_status(sc, psensor, data);
1407: rv = 0;
1408: done:
1409: if (!cold)
1410: rw_exit_write(&sc->sc_lock);
1411: return (rv);
1412: }
1413:
1414: int
1415: ipmi_sensor_type(int type, int ext_type, int entity)
1416: {
1417: switch (ext_type << 8L | type) {
1418: case IPMI_SENSOR_TYPE_TEMP:
1419: return (SENSOR_TEMP);
1420:
1421: case IPMI_SENSOR_TYPE_VOLT:
1422: return (SENSOR_VOLTS_DC);
1423:
1424: case IPMI_SENSOR_TYPE_FAN:
1425: return (SENSOR_FANRPM);
1426:
1427: case IPMI_SENSOR_TYPE_PWRSUPPLY:
1428: if (entity == IPMI_ENTITY_PWRSUPPLY)
1429: return (SENSOR_INDICATOR);
1430: break;
1431:
1432: case IPMI_SENSOR_TYPE_INTRUSION:
1433: return (SENSOR_INDICATOR);
1434: }
1435:
1436: return (-1);
1437: }
1438:
1439: /* Add Sensor to BSD Sysctl interface */
1440: int
1441: add_sdr_sensor(struct ipmi_softc *sc, u_int8_t *psdr)
1442: {
1443: int rc;
1444: struct sdrtype1 *s1 = (struct sdrtype1 *)psdr;
1445: struct sdrtype2 *s2 = (struct sdrtype2 *)psdr;
1446: char name[64];
1447:
1448: switch (s1->sdrhdr.record_type) {
1449: case IPMI_SDR_TYPEFULL:
1450: ipmi_sensor_name(name, sizeof(name), s1->typelen, s1->name);
1451: rc = add_child_sensors(sc, psdr, 1, s1->sensor_num,
1452: s1->sensor_type, s1->event_code, 0, s1->entity_id, name);
1453: break;
1454:
1455: case IPMI_SDR_TYPECOMPACT:
1456: ipmi_sensor_name(name, sizeof(name), s2->typelen, s2->name);
1457: rc = add_child_sensors(sc, psdr, s2->share1 & 0xF,
1458: s2->sensor_num, s2->sensor_type, s2->event_code,
1459: s2->share2 & 0x7F, s2->entity_id, name);
1460: break;
1461:
1462: default:
1463: return (0);
1464: }
1465:
1466: return rc;
1467: }
1468:
1469: int
1470: add_child_sensors(struct ipmi_softc *sc, u_int8_t *psdr, int count,
1471: int sensor_num, int sensor_type, int ext_type, int sensor_base,
1472: int entity, const char *name)
1473: {
1474: int typ, idx;
1475: struct ipmi_sensor *psensor;
1476: #ifdef IPMI_DEBUG
1477: struct sdrtype1 *s1 = (struct sdrtype1 *)psdr;
1478: #endif
1479:
1480: typ = ipmi_sensor_type(sensor_type, ext_type, entity);
1481: if (typ == -1) {
1482: dbg_printf(5, "Unknown sensor type:%.2x et:%.2x sn:%.2x "
1483: "name:%s\n", sensor_type, ext_type, sensor_num, name);
1484: return 0;
1485: }
1486: for (idx = 0; idx < count; idx++) {
1487: psensor = malloc(sizeof(struct ipmi_sensor), M_DEVBUF,
1488: M_NOWAIT|M_CANFAIL);
1489: if (psensor == NULL)
1490: break;
1491:
1492: memset(psensor, 0, sizeof(struct ipmi_sensor));
1493:
1494: /* Initialize BSD Sensor info */
1495: psensor->i_sdr = psdr;
1496: psensor->i_num = sensor_num + idx;
1497: psensor->stype = sensor_type;
1498: psensor->etype = ext_type;
1499: psensor->i_sensor.type = typ;
1500: if (count > 1)
1501: snprintf(psensor->i_sensor.desc,
1502: sizeof(psensor->i_sensor.desc),
1503: "%s - %d", name, sensor_base + idx);
1504: else
1505: strlcpy(psensor->i_sensor.desc, name,
1506: sizeof(psensor->i_sensor.desc));
1507:
1508: dbg_printf(5, "add sensor:%.4x %.2x:%d ent:%.2x:%.2x %s\n",
1509: s1->sdrhdr.record_id, s1->sensor_type,
1510: typ, s1->entity_id, s1->entity_instance,
1511: psensor->i_sensor.desc);
1512: if (read_sensor(sc, psensor) == 0) {
1513: SLIST_INSERT_HEAD(&ipmi_sensor_list, psensor, list);
1514: sensor_attach(&sc->sc_sensordev, &psensor->i_sensor);
1515: dbg_printf(5, " reading: %lld [%s]\n",
1516: psensor->i_sensor.value,
1517: psensor->i_sensor.desc);
1518: }
1519: }
1520:
1521: return (1);
1522: }
1523:
1524: /* Interrupt handler */
1525: int
1526: ipmi_intr(void *arg)
1527: {
1528: struct ipmi_softc *sc = (struct ipmi_softc *)arg;
1529: int v;
1530:
1531: v = bmc_read(sc, _KCS_STATUS_REGISTER);
1532: if (v & KCS_OBF)
1533: ++ipmi_nintr;
1534:
1535: return (0);
1536: }
1537:
1538: /* Handle IPMI Timer - reread sensor values */
1539: void
1540: ipmi_refresh_sensors(struct ipmi_softc *sc)
1541: {
1542: if (!ipmi_poll)
1543: return;
1544:
1545: if (SLIST_EMPTY(&ipmi_sensor_list))
1546: return;
1547:
1548: sc->current_sensor = SLIST_NEXT(sc->current_sensor, list);
1549: if (sc->current_sensor == NULL)
1550: sc->current_sensor = SLIST_FIRST(&ipmi_sensor_list);
1551:
1552: if (read_sensor(sc, sc->current_sensor)) {
1553: dbg_printf(1, "%s: error reading: %s\n", DEVNAME(sc),
1554: sc->current_sensor->i_sensor.desc);
1555: return;
1556: }
1557: }
1558:
1559: int
1560: ipmi_map_regs(struct ipmi_softc *sc, struct ipmi_attach_args *ia)
1561: {
1562: sc->sc_if = ipmi_get_if(ia->iaa_if_type);
1563: if (sc->sc_if == NULL)
1564: return (-1);
1565:
1566: if (ia->iaa_if_iotype == 'i')
1567: sc->sc_iot = ia->iaa_iot;
1568: else
1569: sc->sc_iot = ia->iaa_memt;
1570:
1571: sc->sc_if_rev = ia->iaa_if_rev;
1572: sc->sc_if_iospacing = ia->iaa_if_iospacing;
1573: if (bus_space_map(sc->sc_iot, ia->iaa_if_iobase,
1574: sc->sc_if->nregs * sc->sc_if_iospacing,
1575: 0, &sc->sc_ioh)) {
1576: printf("%s: bus_space_map(%x %x %x 0 %p) failed\n",
1577: DEVNAME(sc),
1578: sc->sc_iot, ia->iaa_if_iobase,
1579: sc->sc_if->nregs * sc->sc_if_iospacing, &sc->sc_ioh);
1580: return (-1);
1581: }
1582: #if 0
1583: if (iaa->if_if_irq != -1)
1584: sc->ih = isa_intr_establish(-1, iaa->if_if_irq,
1585: iaa->if_irqlvl, IPL_BIO, ipmi_intr, sc, DEVNAME(sc));
1586: #endif
1587: return (0);
1588: }
1589:
1590: void
1591: ipmi_unmap_regs(struct ipmi_softc *sc, struct ipmi_attach_args *ia)
1592: {
1593: bus_space_unmap(sc->sc_iot, sc->sc_ioh,
1594: sc->sc_if->nregs * sc->sc_if_iospacing);
1595: }
1596:
1597: void
1598: ipmi_poll_thread(void *arg)
1599: {
1600: struct ipmi_thread *thread = arg;
1601: struct ipmi_softc *sc = thread->sc;
1602:
1603: while (thread->running) {
1604: ipmi_refresh_sensors(sc);
1605: tsleep(thread, PWAIT, "ipmi_poll", SENSOR_REFRESH_RATE);
1606: }
1607: free(thread, M_DEVBUF);
1608:
1609: kthread_exit(0);
1610: }
1611:
1612: void
1613: ipmi_create_thread(void *arg)
1614: {
1615: struct ipmi_softc *sc = arg;
1616:
1617: if (kthread_create(ipmi_poll_thread, sc->sc_thread, NULL,
1618: DEVNAME(sc)) != 0) {
1619: printf("%s: unable to create polling thread, ipmi disabled\n",
1620: DEVNAME(sc));
1621: return;
1622: }
1623: }
1624:
1625: int
1626: ipmi_probe(void *aux)
1627: {
1628: struct ipmi_attach_args *ia = aux;
1629: struct dmd_ipmi *pipmi;
1630: struct smbtable tbl;
1631:
1632: tbl.cookie = 0;
1633: if (smbios_find_table(SMBIOS_TYPE_IPMIDEV, &tbl))
1634: ipmi_smbios_probe(tbl.tblhdr, ia);
1635: else {
1636: pipmi = (struct dmd_ipmi *)scan_sig(0xC0000L, 0xFFFFFL, 16, 4,
1637: "IPMI");
1638: /* XXX hack to find Dell PowerEdge 8450 */
1639: if (pipmi == NULL) {
1640: /* no IPMI found */
1641: return (0);
1642: }
1643:
1644: /* we have an IPMI signature, fill in attach arg structure */
1645: ia->iaa_if_type = pipmi->dmd_if_type;
1646: ia->iaa_if_rev = pipmi->dmd_if_rev;
1647: }
1648:
1649: return (1);
1650: }
1651:
1652: int
1653: ipmi_match(struct device *parent, void *match, void *aux)
1654: {
1655: struct ipmi_softc sc;
1656: struct ipmi_attach_args *ia = aux;
1657: struct cfdata *cf = match;
1658: u_int8_t cmd[32];
1659: int len;
1660: int rv = 0;
1661:
1662: if (strcmp(ia->iaa_name, cf->cf_driver->cd_name))
1663: return (0);
1664:
1665: /* XXX local softc is wrong wrong wrong */
1666: strlcpy(sc.sc_dev.dv_xname, "ipmi0", sizeof(sc.sc_dev.dv_xname));
1667: /* Map registers */
1668: if (ipmi_map_regs(&sc, ia) == 0) {
1669: sc.sc_if->probe(&sc);
1670:
1671: /* Identify BMC device early to detect lying bios */
1672: if (ipmi_sendcmd(&sc, BMC_SA, 0, APP_NETFN, APP_GET_DEVICE_ID,
1673: 0, NULL)) {
1674: dbg_printf(1, ": unable to send get device id "
1675: "command\n");
1676: goto unmap;
1677: }
1678: if (ipmi_recvcmd(&sc, sizeof(cmd), &len, cmd)) {
1679: dbg_printf(1, ": unable to retrieve device id\n");
1680: goto unmap;
1681: }
1682:
1683: dbg_dump(1, "bmc data", len, cmd);
1684: unmap:
1685: rv = 1; /* GETID worked, we got IPMI */
1686: ipmi_unmap_regs(&sc, ia);
1687: }
1688:
1689: return (rv);
1690: }
1691:
1692: void
1693: ipmi_attach(struct device *parent, struct device *self, void *aux)
1694: {
1695: struct ipmi_softc *sc = (void *) self;
1696: struct ipmi_attach_args *ia = aux;
1697: u_int16_t rec;
1698:
1699: /* Map registers */
1700: ipmi_map_regs(sc, ia);
1701:
1702: /* Scan SDRs, add sensors */
1703: for (rec = 0; rec != 0xFFFF;) {
1704: if (get_sdr(sc, rec, &rec)) {
1705: /* IPMI may have been advertised, but it is stillborn */
1706: ipmi_unmap_regs(sc, ia);
1707: return;
1708: }
1709: }
1710:
1711: sc->sc_thread = malloc(sizeof(struct ipmi_thread), M_DEVBUF,
1712: M_NOWAIT|M_CANFAIL);
1713: if (sc->sc_thread == NULL) {
1714: printf(": unable to allocate thread\n");
1715: return;
1716: }
1717: sc->sc_thread->sc = sc;
1718: sc->sc_thread->running = 1;
1719:
1720: /* initialize sensor list for thread */
1721: if (!SLIST_EMPTY(&ipmi_sensor_list))
1722: sc->current_sensor = SLIST_FIRST(&ipmi_sensor_list);
1723:
1724: /* Setup threads */
1725: kthread_create_deferred(ipmi_create_thread, sc);
1726:
1727: strlcpy(sc->sc_sensordev.xname, sc->sc_dev.dv_xname,
1728: sizeof(sc->sc_sensordev.xname));
1729: sensordev_install(&sc->sc_sensordev);
1730:
1731: printf(": version %d.%d interface %s %sbase 0x%x/%x spacing %d",
1732: ia->iaa_if_rev >> 4, ia->iaa_if_rev & 0xF, sc->sc_if->name,
1733: ia->iaa_if_iotype == 'i' ? "io" : "mem", ia->iaa_if_iobase,
1734: ia->iaa_if_iospacing * sc->sc_if->nregs, ia->iaa_if_iospacing);
1735: if (ia->iaa_if_irq != -1)
1736: printf(" irq %d", ia->iaa_if_irq);
1737: printf("\n");
1738:
1739: /* setup flag to exclude iic */
1740: ipmi_enabled = 1;
1741:
1742: /* Setup Watchdog timer */
1743: sc->sc_wdog_period = 0;
1744: wdog_register(sc, ipmi_watchdog);
1745:
1746: /* lock around read_sensor so that no one messes with the bmc regs */
1747: rw_init(&sc->sc_lock, DEVNAME(sc));
1748:
1749: /* setup ticker */
1750: sc->sc_retries = 0;
1751: sc->sc_wakeup = 0;
1752: sc->sc_max_retries = 50; /* 50 * 1/100 = 0.5 seconds max */
1753: timeout_set(&sc->sc_timeout, _bmc_io_wait, sc);
1754: }
1755:
1756: int
1757: ipmi_watchdog(void *arg, int period)
1758: {
1759: struct ipmi_softc *sc = arg;
1760: struct ipmi_watchdog wdog;
1761: int s, rc, len;
1762:
1763: if (sc->sc_wdog_period == period) {
1764: if (period != 0) {
1765: s = splsoftclock();
1766: /* tickle the watchdog */
1767: rc = ipmi_sendcmd(sc, BMC_SA, BMC_LUN, APP_NETFN,
1768: APP_RESET_WATCHDOG, 0, NULL);
1769: rc = ipmi_recvcmd(sc, 0, &len, NULL);
1770: splx(s);
1771: }
1772: return (period);
1773: }
1774:
1775: if (period < 10 && period > 0)
1776: period = 10;
1777:
1778: s = splsoftclock();
1779: /* XXX what to do if poking wdog fails? */
1780: rc = ipmi_sendcmd(sc, BMC_SA, BMC_LUN, APP_NETFN,
1781: APP_GET_WATCHDOG_TIMER, 0, NULL);
1782: rc = ipmi_recvcmd(sc, sizeof(wdog), &len, &wdog);
1783:
1784: /* Period is 10ths/sec */
1785: wdog.wdog_timeout = htole32(period * 10);
1786: wdog.wdog_action &= ~IPMI_WDOG_MASK;
1787: wdog.wdog_action |= (period == 0) ? IPMI_WDOG_DISABLED :
1788: IPMI_WDOG_REBOOT;
1789:
1790: rc = ipmi_sendcmd(sc, BMC_SA, BMC_LUN, APP_NETFN,
1791: APP_SET_WATCHDOG_TIMER, sizeof(wdog), &wdog);
1792: rc = ipmi_recvcmd(sc, 0, &len, NULL);
1793:
1794: splx(s);
1795:
1796: sc->sc_wdog_period = period;
1797: return (period);
1798: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to ipmi.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev