1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2017 Joyent, Inc.
24 * Copyright 2013 Nexenta Systems, Inc. All rights reserved.
25 */
26
27 /*
28 * The ipmi driver is an openipmi compatible IPMI driver based on the FreeBSD
29 * driver.
30 *
31 * The current implementation has several limitations:
32 * 1) It only does discovery through the SMBIOS. The FreeBSD driver has
33 * several additional ways to discover the IPMI device (acpi, bus checking,
34 * etc.). This support could be ported if necessary.
35 * 2) The driver currently only supports the IPMI KCS_MODE mode (reported
36 * through the SMBIOS as SMBIOS SMB_IPMI_T_KCS). Support for the other modes
37 * (BT_MODE, SMIC_MODE, SSIF_MODE) could be ported if necessary.
38 * 3) The driver does not currently set up an IPMI watchdog. This also could
39 * be ported if necessary.
40 */
41
42 #include <sys/devops.h>
43 #include <sys/conf.h>
44 #include <sys/modctl.h>
45 #include <sys/types.h>
46 #include <sys/file.h>
47 #include <sys/errno.h>
48 #include <sys/open.h>
49 #include <sys/cred.h>
50 #include <sys/uio.h>
51 #include <sys/stat.h>
52 #include <sys/cmn_err.h>
53 #include <sys/ddi.h>
54 #include <sys/sunddi.h>
55 #include <sys/smbios.h>
56 #include <sys/smbios_impl.h>
57 #include <sys/policy.h>
58 #include <sys/ipmi.h>
59 #include "ipmivars.h"
60
61 static dev_info_t *ipmi_dip;
62 static boolean_t ipmi_attached = B_FALSE;
63 static boolean_t ipmi_found = B_FALSE;
64 static struct ipmi_softc softc;
65 static struct ipmi_softc *sc = &softc;
66 static list_t dev_list;
67 static id_space_t *minor_ids;
68 static kmutex_t dev_list_lock;
69
70 #define PTRIN(p) ((void *)(uintptr_t)(p))
71 #define PTROUT(p) ((uintptr_t)(p))
72
73 /*
74 * Use the SMBIOS info to determine if the system has an IPMI.
75 */
76 static int
77 get_smbios_ipmi_info(void)
78 {
79 smbios_ipmi_t ipmi;
80
81 if (ksmbios == NULL || smbios_info_ipmi(ksmbios, &ipmi) == SMB_ERR)
82 return (DDI_FAILURE);
83
84 cmn_err(CE_CONT, "!SMBIOS type 0x%x, addr 0x%llx", ipmi.smbip_type,
85 (long long unsigned int)(ipmi.smbip_addr));
86
87 /*
88 * Some systems have a bios that will report an IPMI device even when
89 * it is not installed. In this case we see 0x0 as the base address.
90 * If we see this address, assume the device is not really present.
91 */
92 if (ipmi.smbip_addr == 0) {
93 cmn_err(CE_WARN, "!SMBIOS: Invalid base address");
94 return (DDI_FAILURE);
95 }
96
97 sc->ipmi_io_type = ipmi.smbip_type;
98 switch (ipmi.smbip_type) {
99 case SMB_IPMI_T_KCS:
100 case SMB_IPMI_T_SMIC:
101 sc->ipmi_io_address = ipmi.smbip_addr;
102 sc->ipmi_io_mode = (ipmi.smbip_flags & SMB_IPMI_F_IOADDR) ?
103 1 : 0;
104 sc->ipmi_io_spacing = ipmi.smbip_regspacing;
105 break;
106 case SMB_IPMI_T_SSIF:
107 if ((ipmi.smbip_addr & 0xffffffffffffff00) != 0) {
108 cmn_err(CE_WARN, "!SMBIOS: Invalid SSIF SMBus address, "
109 "using BMC I2C slave address instead");
110 sc->ipmi_io_address = ipmi.smbip_i2c;
111 } else {
112 sc->ipmi_io_address = ipmi.smbip_addr;
113 }
114 break;
115 default:
116 return (DDI_FAILURE);
117 }
118
119 if (ipmi.smbip_intr > 15) {
120 cmn_err(CE_WARN, "!SMBIOS: Non-ISA IRQ %d for IPMI",
121 ipmi.smbip_intr);
122 return (DDI_FAILURE);
123 }
124
125 sc->ipmi_io_irq = ipmi.smbip_intr;
126 return (DDI_SUCCESS);
127 }
128
129 static ipmi_device_t *
130 lookup_ipmidev_by_dev(dev_t dev)
131 {
132 ipmi_device_t *p;
133
134 mutex_enter(&dev_list_lock);
135 for (p = list_head(&dev_list); p; p = list_next(&dev_list, p)) {
136 if (dev == p->ipmi_dev) {
137 mutex_exit(&dev_list_lock);
138 return (p);
139 }
140 }
141 mutex_exit(&dev_list_lock);
142 return (NULL);
143 }
144
145 /*
146 * Each open returns a new pseudo device.
147 */
148 /*ARGSUSED*/
149 static int
150 ipmi_open(dev_t *devp, int flag, int otyp, cred_t *cred)
151 {
152 minor_t minor;
153 ipmi_device_t *dev;
154
155 if (ipmi_attached == B_FALSE)
156 return (ENXIO);
157
158 if (ipmi_found == B_FALSE)
159 return (ENODEV);
160
161 /* exclusive opens are not supported */
162 if (flag & FEXCL)
163 return (ENOTSUP);
164
165 if ((minor = (minor_t)id_alloc_nosleep(minor_ids)) == 0)
166 return (ENODEV);
167
168 /* Initialize the per file descriptor data. */
169 dev = kmem_zalloc(sizeof (ipmi_device_t), KM_SLEEP);
170
171 dev->ipmi_pollhead = kmem_zalloc(sizeof (pollhead_t), KM_SLEEP);
172
173 TAILQ_INIT(&dev->ipmi_completed_requests);
174 dev->ipmi_address = IPMI_BMC_SLAVE_ADDR;
175 dev->ipmi_lun = IPMI_BMC_SMS_LUN;
176 *devp = makedevice(getmajor(*devp), minor);
177 dev->ipmi_dev = *devp;
178 cv_init(&dev->ipmi_cv, NULL, CV_DEFAULT, NULL);
179
180 mutex_enter(&dev_list_lock);
181 list_insert_head(&dev_list, dev);
182 mutex_exit(&dev_list_lock);
183
184 return (0);
185 }
186
187 /*ARGSUSED*/
188 static int
189 ipmi_close(dev_t dev, int flag, int otyp, cred_t *cred)
190 {
191 ipmi_device_t *dp;
192 struct ipmi_request *req, *next;
193
194 if ((dp = lookup_ipmidev_by_dev(dev)) == NULL)
195 return (ENODEV);
196
197 IPMI_LOCK(sc);
198 /* remove any pending requests */
199 req = TAILQ_FIRST(&sc->ipmi_pending_requests);
200 while (req != NULL) {
201 next = TAILQ_NEXT(req, ir_link);
202
203 if (req->ir_owner == dp) {
204 TAILQ_REMOVE(&sc->ipmi_pending_requests, req, ir_link);
205 ipmi_free_request(req);
206 }
207 req = next;
208 }
209
210 dp->ipmi_status |= IPMI_CLOSING;
211 while (dp->ipmi_status & IPMI_BUSY)
212 cv_wait(&dp->ipmi_cv, &sc->ipmi_lock);
213 IPMI_UNLOCK(sc);
214
215 /* remove any requests in queue of stuff completed */
216 while ((req = TAILQ_FIRST(&dp->ipmi_completed_requests)) != NULL) {
217 TAILQ_REMOVE(&dp->ipmi_completed_requests, req, ir_link);
218 ipmi_free_request(req);
219 }
220
221 mutex_enter(&dev_list_lock);
222 list_remove(&dev_list, dp);
223 mutex_exit(&dev_list_lock);
224 id_free(minor_ids, getminor(dev));
225 cv_destroy(&dp->ipmi_cv);
226 kmem_free(dp->ipmi_pollhead, sizeof (pollhead_t));
227 kmem_free(dp, sizeof (ipmi_device_t));
228
229 return (0);
230 }
231
232 /*ARGSUSED*/
233 static int
234 ipmi_ioctl(dev_t dv, int cmd, intptr_t data, int flags, cred_t *cr, int *rvalp)
235 {
236 struct ipmi_device *dev;
237 struct ipmi_request *kreq;
238 struct ipmi_req req;
239 struct ipmi_recv recv;
240 struct ipmi_recv32 recv32;
241 struct ipmi_addr addr;
242 int error, len;
243 model_t model;
244 int orig_cmd = 0;
245 uchar_t t_lun;
246
247 if (secpolicy_sys_config(cr, B_FALSE) != 0)
248 return (EPERM);
249
250 if ((dev = lookup_ipmidev_by_dev(dv)) == NULL)
251 return (ENODEV);
252
253 model = get_udatamodel();
254 if (model == DATAMODEL_NATIVE) {
255 switch (cmd) {
256 case IPMICTL_SEND_COMMAND:
257 if (copyin((void *)data, &req, sizeof (req)))
258 return (EFAULT);
259 break;
260 case IPMICTL_RECEIVE_MSG_TRUNC:
261 case IPMICTL_RECEIVE_MSG:
262 if (copyin((void *)data, &recv, sizeof (recv)))
263 return (EFAULT);
264 break;
265 }
266 } else {
267 /* Convert 32-bit structures to native. */
268 struct ipmi_req32 req32;
269
270 switch (cmd) {
271 case IPMICTL_SEND_COMMAND_32:
272 if (copyin((void *)data, &req32, sizeof (req32)))
273 return (EFAULT);
274
275 req.addr = PTRIN(req32.addr);
276 req.addr_len = req32.addr_len;
277 req.msgid = req32.msgid;
278 req.msg.netfn = req32.msg.netfn;
279 req.msg.cmd = req32.msg.cmd;
280 req.msg.data_len = req32.msg.data_len;
281 req.msg.data = PTRIN(req32.msg.data);
282
283 cmd = IPMICTL_SEND_COMMAND;
284 break;
285
286 case IPMICTL_RECEIVE_MSG_TRUNC_32:
287 case IPMICTL_RECEIVE_MSG_32:
288 if (copyin((void *)data, &recv32, sizeof (recv32)))
289 return (EFAULT);
290
291 recv.addr = PTRIN(recv32.addr);
292 recv.addr_len = recv32.addr_len;
293 recv.msg.data_len = recv32.msg.data_len;
294 recv.msg.data = PTRIN(recv32.msg.data);
295
296 orig_cmd = cmd;
297 cmd = (cmd == IPMICTL_RECEIVE_MSG_TRUNC_32) ?
298 IPMICTL_RECEIVE_MSG_TRUNC : IPMICTL_RECEIVE_MSG;
299 break;
300 }
301 }
302
303 switch (cmd) {
304 case IPMICTL_SEND_COMMAND:
305 /* Check that we didn't get a ridiculous length */
306 if (req.msg.data_len > IPMI_MAX_RX)
307 return (EINVAL);
308
309 kreq = ipmi_alloc_request(dev, req.msgid,
310 IPMI_ADDR(req.msg.netfn, 0), req.msg.cmd,
311 req.msg.data_len, IPMI_MAX_RX);
312 /* This struct is the same for 32/64 */
313 if (req.msg.data_len > 0 &&
314 copyin(req.msg.data, kreq->ir_request, req.msg.data_len)) {
315 ipmi_free_request(kreq);
316 return (EFAULT);
317 }
318 IPMI_LOCK(sc);
319 dev->ipmi_requests++;
320 error = sc->ipmi_enqueue_request(sc, kreq);
321 IPMI_UNLOCK(sc);
322 if (error)
323 return (error);
324 break;
325
326 case IPMICTL_RECEIVE_MSG_TRUNC:
327 case IPMICTL_RECEIVE_MSG:
328 /* This struct is the same for 32/64 */
329 if (copyin(recv.addr, &addr, sizeof (addr)))
330 return (EFAULT);
331
332 IPMI_LOCK(sc);
333 kreq = TAILQ_FIRST(&dev->ipmi_completed_requests);
334 if (kreq == NULL) {
335 IPMI_UNLOCK(sc);
336 return (EAGAIN);
337 }
338 addr.channel = IPMI_BMC_CHANNEL;
339 recv.recv_type = IPMI_RESPONSE_RECV_TYPE;
340 recv.msgid = kreq->ir_msgid;
341 recv.msg.netfn = IPMI_REPLY_ADDR(kreq->ir_addr) >> 2;
342 recv.msg.cmd = kreq->ir_command;
343 error = kreq->ir_error;
344 if (error) {
345 TAILQ_REMOVE(&dev->ipmi_completed_requests, kreq,
346 ir_link);
347 dev->ipmi_requests--;
348 IPMI_UNLOCK(sc);
349 ipmi_free_request(kreq);
350 return (error);
351 }
352 len = kreq->ir_replylen + 1;
353 if (recv.msg.data_len < len && cmd == IPMICTL_RECEIVE_MSG) {
354 IPMI_UNLOCK(sc);
355 return (EMSGSIZE);
356 }
357 TAILQ_REMOVE(&dev->ipmi_completed_requests, kreq, ir_link);
358 dev->ipmi_requests--;
359 IPMI_UNLOCK(sc);
360 len = min(recv.msg.data_len, len);
361 recv.msg.data_len = (unsigned short)len;
362
363 if (orig_cmd == IPMICTL_RECEIVE_MSG_TRUNC_32 ||
364 orig_cmd == IPMICTL_RECEIVE_MSG_32) {
365 /* Update changed fields in 32-bit structure. */
366 recv32.recv_type = recv.recv_type;
367 recv32.msgid = (int32_t)recv.msgid;
368 recv32.msg.netfn = recv.msg.netfn;
369 recv32.msg.cmd = recv.msg.cmd;
370 recv32.msg.data_len = recv.msg.data_len;
371
372 error = copyout(&recv32, (void *)data, sizeof (recv32));
373 } else {
374 error = copyout(&recv, (void *)data, sizeof (recv));
375 }
376
377 /* This struct is the same for 32/64 */
378 if (error == 0)
379 error = copyout(&addr, recv.addr, sizeof (addr));
380 if (error == 0)
381 error = copyout(&kreq->ir_compcode, recv.msg.data, 1);
382 if (error == 0)
383 error = copyout(kreq->ir_reply, recv.msg.data + 1,
384 len - 1);
385 ipmi_free_request(kreq);
386
387 if (error)
388 return (EFAULT);
389
390 break;
391
392 case IPMICTL_SET_MY_ADDRESS_CMD:
393 IPMI_LOCK(sc);
394 if (copyin((void *)data, &dev->ipmi_address,
395 sizeof (dev->ipmi_address))) {
396 IPMI_UNLOCK(sc);
397 return (EFAULT);
398 }
399 IPMI_UNLOCK(sc);
400 break;
401
402 case IPMICTL_GET_MY_ADDRESS_CMD:
403 IPMI_LOCK(sc);
404 if (copyout(&dev->ipmi_address, (void *)data,
405 sizeof (dev->ipmi_address))) {
406 IPMI_UNLOCK(sc);
407 return (EFAULT);
408 }
409 IPMI_UNLOCK(sc);
410 break;
411
412 case IPMICTL_SET_MY_LUN_CMD:
413 IPMI_LOCK(sc);
414 if (copyin((void *)data, &t_lun, sizeof (t_lun))) {
415 IPMI_UNLOCK(sc);
416 return (EFAULT);
417 }
418 dev->ipmi_lun = t_lun & 0x3;
419 IPMI_UNLOCK(sc);
420 break;
421
422 case IPMICTL_GET_MY_LUN_CMD:
423 IPMI_LOCK(sc);
424 if (copyout(&dev->ipmi_lun, (void *)data,
425 sizeof (dev->ipmi_lun))) {
426 IPMI_UNLOCK(sc);
427 return (EFAULT);
428 }
429 IPMI_UNLOCK(sc);
430 break;
431
432 case IPMICTL_SET_GETS_EVENTS_CMD:
433 break;
434
435 case IPMICTL_REGISTER_FOR_CMD:
436 case IPMICTL_UNREGISTER_FOR_CMD:
437 return (EINVAL);
438
439 default:
440 return (EINVAL);
441 }
442
443 return (0);
444 }
445
446 static int
447 ipmi_poll(dev_t dv, short events, int anyyet, short *reventsp,
448 pollhead_t **phpp)
449 {
450 struct ipmi_device *dev;
451 short revent = 0;
452
453 if ((dev = lookup_ipmidev_by_dev(dv)) == NULL)
454 return (ENODEV);
455
456 if (events & (POLLIN | POLLRDNORM)) {
457 if (!TAILQ_EMPTY(&dev->ipmi_completed_requests))
458 revent |= events & (POLLIN | POLLRDNORM);
459 if (dev->ipmi_requests == 0)
460 revent |= POLLERR;
461 }
462
463 if ((revent == 0 && !anyyet) || (events & POLLET)) {
464 *phpp = dev->ipmi_pollhead;
465 }
466
467 *reventsp = revent;
468 return (0);
469 }
470
471 /*ARGSUSED*/
472 static int
473 ipmi_info(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **resultp)
474 {
475 switch (cmd) {
476 case DDI_INFO_DEVT2DEVINFO:
477 *resultp = ipmi_dip;
478 return (DDI_SUCCESS);
479 case DDI_INFO_DEVT2INSTANCE:
480 *resultp = NULL;
481 return (DDI_SUCCESS);
482 }
483 return (DDI_FAILURE);
484 }
485
486 static void
487 ipmi_cleanup(dev_info_t *dip)
488 {
489 /* poke the taskq so that it can terminate */
490 IPMI_LOCK(sc);
491 sc->ipmi_detaching = 1;
492 cv_signal(&sc->ipmi_request_added);
493 IPMI_UNLOCK(sc);
494
495 ipmi_shutdown(sc);
496 ddi_remove_minor_node(dip, NULL);
497 ipmi_dip = NULL;
498
499 mutex_destroy(&dev_list_lock);
500 list_destroy(&dev_list);
501 id_space_destroy(minor_ids);
502
503 sc->ipmi_detaching = 0;
504 }
505
506 static int
507 ipmi_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
508 {
509 if (cmd != DDI_ATTACH)
510 return (DDI_FAILURE);
511
512 /* this driver only supports one device instance */
513 if (ddi_get_instance(dip) != 0) {
514 cmn_err(CE_WARN,
515 "!not attaching to non-zero device instance %d",
516 ddi_get_instance(dip));
517 return (DDI_FAILURE);
518 }
519
520 if (get_smbios_ipmi_info() == DDI_FAILURE)
521 return (DDI_FAILURE);
522
523 /*
524 * Support for the other types (SMIC, SSIF) should be added here.
525 */
526 switch (sc->ipmi_io_type) {
527 case SMB_IPMI_T_KCS:
528 if (ipmi_kcs_attach(sc) != 0)
529 return (DDI_FAILURE);
530 break;
531 default:
532 return (DDI_FAILURE);
533 }
534 ipmi_found = B_TRUE;
535
536 if (ddi_create_minor_node(dip, "ipmi", S_IFCHR, 0, DDI_PSEUDO,
537 0) == DDI_FAILURE) {
538 cmn_err(CE_WARN, "!attach could not create minor node");
539 ddi_remove_minor_node(dip, NULL);
540 return (DDI_FAILURE);
541 }
542
543 ipmi_dip = dip;
544
545 list_create(&dev_list, sizeof (ipmi_device_t),
546 offsetof(ipmi_device_t, ipmi_node));
547 mutex_init(&dev_list_lock, NULL, MUTEX_DRIVER, NULL);
548
549 /* Create ID space for open devs. ID 0 is reserved. */
550 minor_ids = id_space_create("ipmi_id_space", 1, 128);
551
552 if (ipmi_startup(sc) != B_TRUE) {
553 ipmi_cleanup(dip);
554 return (DDI_FAILURE);
555 }
556
557 ipmi_attached = B_TRUE;
558
559 return (DDI_SUCCESS);
560 }
561
562 static int
563 ipmi_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
564 {
565 if (cmd != DDI_DETACH)
566 return (DDI_FAILURE);
567
568 if (ipmi_found == B_FALSE)
569 return (DDI_SUCCESS);
570
571 mutex_enter(&dev_list_lock);
572 if (!list_is_empty(&dev_list)) {
573 mutex_exit(&dev_list_lock);
574 return (DDI_FAILURE);
575 }
576 mutex_exit(&dev_list_lock);
577
578 ipmi_cleanup(dip);
579
580 ipmi_attached = B_FALSE;
581 return (DDI_SUCCESS);
582 }
583
584 static struct cb_ops ipmi_cb_ops = {
585 ipmi_open,
586 ipmi_close,
587 nodev, /* strategy */
588 nodev, /* print */
589 nodev, /* dump */
590 nodev, /* read */
591 nodev, /* write */
592 ipmi_ioctl,
593 nodev, /* devmap */
594 nodev, /* mmap */
595 nodev, /* segmap */
596 ipmi_poll,
597 ddi_prop_op,
598 NULL, /* streamtab */
599 D_NEW | D_MP, /* flags */
600 CB_REV,
601 nodev, /* awread */
602 nodev /* awrite */
603 };
604
605 static struct dev_ops ipmi_ops = {
606 DEVO_REV,
607 0, /* reference count */
608 ipmi_info,
609 nulldev, /* identify */
610 nulldev, /* probe */
611 ipmi_attach,
612 ipmi_detach,
613 nodev, /* reset */
614 &ipmi_cb_ops,
615 NULL, /* bus ops */
616 NULL, /* power */
617 ddi_quiesce_not_needed,
618 };
619
620 static struct modldrv md = {
621 &mod_driverops, "ipmi driver", &ipmi_ops
622 };
623
624 static struct modlinkage ml = {
625 MODREV_1, &md, NULL
626 };
627
628 int
629 _init(void)
630 {
631 return (mod_install(&ml));
632 }
633
634 int
635 _fini(void)
636 {
637 return (mod_remove(&ml));
638 }
639
640 int
641 _info(struct modinfo *mip)
642 {
643 return (mod_info(&ml, mip));
644 }