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