2 * IPMI BMC external connection
4 * Copyright (c) 2015 Corey Minyard, MontaVista Software, LLC
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
26 * This is designed to connect with OpenIPMI's lanserv serial interface
27 * using the "VM" connection type. See that for details.
30 #include "qemu/osdep.h"
31 #include "qemu/error-report.h"
32 #include "qemu/module.h"
33 #include "qapi/error.h"
34 #include "qemu/timer.h"
35 #include "chardev/char-fe.h"
36 #include "sysemu/sysemu.h"
37 #include "hw/ipmi/ipmi.h"
38 #include "hw/qdev-properties.h"
39 #include "migration/vmstate.h"
41 #define VM_MSG_CHAR 0xA0 /* Marks end of message */
42 #define VM_CMD_CHAR 0xA1 /* Marks end of a command */
43 #define VM_ESCAPE_CHAR 0xAA /* Set bit 4 from the next byte to 0 */
45 #define VM_PROTOCOL_VERSION 1
46 #define VM_CMD_VERSION 0xff /* A version number byte follows */
47 #define VM_CMD_NOATTN 0x00
48 #define VM_CMD_ATTN 0x01
49 #define VM_CMD_ATTN_IRQ 0x02
50 #define VM_CMD_POWEROFF 0x03
51 #define VM_CMD_RESET 0x04
52 #define VM_CMD_ENABLE_IRQ 0x05 /* Enable/disable the messaging irq */
53 #define VM_CMD_DISABLE_IRQ 0x06
54 #define VM_CMD_SEND_NMI 0x07
55 #define VM_CMD_CAPABILITIES 0x08
56 #define VM_CAPABILITIES_POWER 0x01
57 #define VM_CAPABILITIES_RESET 0x02
58 #define VM_CAPABILITIES_IRQ 0x04
59 #define VM_CAPABILITIES_NMI 0x08
60 #define VM_CAPABILITIES_ATTN 0x10
61 #define VM_CAPABILITIES_GRACEFUL_SHUTDOWN 0x20
62 #define VM_CMD_GRACEFUL_SHUTDOWN 0x09
64 #define TYPE_IPMI_BMC_EXTERN "ipmi-bmc-extern"
65 #define IPMI_BMC_EXTERN(obj) OBJECT_CHECK(IPMIBmcExtern, (obj), \
67 typedef struct IPMIBmcExtern
{
74 unsigned char inbuf
[MAX_IPMI_MSG_SIZE
+ 2];
81 unsigned char outbuf
[(MAX_IPMI_MSG_SIZE
+ 2) * 2 + 1];
85 struct QEMUTimer
*extern_timer
;
87 /* A reset event is pending to be sent upstream. */
91 static int can_receive(void *opaque
);
92 static void receive(void *opaque
, const uint8_t *buf
, int size
);
93 static void chr_event(void *opaque
, int event
);
96 ipmb_checksum(const unsigned char *data
, int size
, unsigned char start
)
98 unsigned char csum
= start
;
100 for (; size
> 0; size
--, data
++) {
106 static void continue_send(IPMIBmcExtern
*ibe
)
109 if (ibe
->outlen
== 0) {
113 ret
= qemu_chr_fe_write(&ibe
->chr
, ibe
->outbuf
+ ibe
->outpos
,
114 ibe
->outlen
- ibe
->outpos
);
118 if (ibe
->outpos
< ibe
->outlen
) {
119 /* Not fully transmitted, try again in a 10ms */
120 timer_mod_ns(ibe
->extern_timer
,
121 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
) + 10000000);
126 if (!ibe
->sending_cmd
) {
127 ibe
->waiting_rsp
= true;
129 ibe
->sending_cmd
= false;
132 if (ibe
->connected
&& ibe
->send_reset
) {
134 ibe
->outbuf
[0] = VM_CMD_RESET
;
135 ibe
->outbuf
[1] = VM_CMD_CHAR
;
138 ibe
->send_reset
= false;
139 ibe
->sending_cmd
= true;
143 if (ibe
->waiting_rsp
) {
144 /* Make sure we get a response within 4 seconds. */
145 timer_mod_ns(ibe
->extern_timer
,
146 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
) + 4000000000ULL);
152 static void extern_timeout(void *opaque
)
154 IPMIBmcExtern
*ibe
= opaque
;
155 IPMIInterface
*s
= ibe
->parent
.intf
;
157 if (ibe
->connected
) {
158 if (ibe
->waiting_rsp
&& (ibe
->outlen
== 0)) {
159 IPMIInterfaceClass
*k
= IPMI_INTERFACE_GET_CLASS(s
);
160 /* The message response timed out, return an error. */
161 ibe
->waiting_rsp
= false;
162 ibe
->inbuf
[1] = ibe
->outbuf
[1] | 0x04;
163 ibe
->inbuf
[2] = ibe
->outbuf
[2];
164 ibe
->inbuf
[3] = IPMI_CC_TIMEOUT
;
165 k
->handle_rsp(s
, ibe
->outbuf
[0], ibe
->inbuf
+ 1, 3);
172 static void addchar(IPMIBmcExtern
*ibe
, unsigned char ch
)
178 ibe
->outbuf
[ibe
->outlen
] = VM_ESCAPE_CHAR
;
184 ibe
->outbuf
[ibe
->outlen
] = ch
;
189 static void ipmi_bmc_extern_handle_command(IPMIBmc
*b
,
190 uint8_t *cmd
, unsigned int cmd_len
,
191 unsigned int max_cmd_len
,
194 IPMIBmcExtern
*ibe
= IPMI_BMC_EXTERN(b
);
195 IPMIInterface
*s
= ibe
->parent
.intf
;
196 uint8_t err
= 0, csum
;
200 /* We already have a command queued. Shouldn't ever happen. */
201 error_report("IPMI KCS: Got command when not finished with the"
202 " previous command");
206 /* If it's too short or it was truncated, return an error. */
208 err
= IPMI_CC_REQUEST_DATA_LENGTH_INVALID
;
209 } else if ((cmd_len
> max_cmd_len
) || (cmd_len
> MAX_IPMI_MSG_SIZE
)) {
210 err
= IPMI_CC_REQUEST_DATA_TRUNCATED
;
211 } else if (!ibe
->connected
) {
212 err
= IPMI_CC_BMC_INIT_IN_PROGRESS
;
215 IPMIInterfaceClass
*k
= IPMI_INTERFACE_GET_CLASS(s
);
216 unsigned char rsp
[3];
217 rsp
[0] = cmd
[0] | 0x04;
220 ibe
->waiting_rsp
= false;
221 k
->handle_rsp(s
, msg_id
, rsp
, 3);
225 addchar(ibe
, msg_id
);
226 for (i
= 0; i
< cmd_len
; i
++) {
227 addchar(ibe
, cmd
[i
]);
229 csum
= ipmb_checksum(&msg_id
, 1, 0);
230 addchar(ibe
, -ipmb_checksum(cmd
, cmd_len
, csum
));
232 ibe
->outbuf
[ibe
->outlen
] = VM_MSG_CHAR
;
235 /* Start the transmit */
242 static void handle_hw_op(IPMIBmcExtern
*ibe
, unsigned char hw_op
)
244 IPMIInterface
*s
= ibe
->parent
.intf
;
245 IPMIInterfaceClass
*k
= IPMI_INTERFACE_GET_CLASS(s
);
249 /* We only support one version at this time. */
260 case VM_CMD_ATTN_IRQ
:
264 case VM_CMD_POWEROFF
:
265 k
->do_hw_op(s
, IPMI_POWEROFF_CHASSIS
, 0);
269 k
->do_hw_op(s
, IPMI_RESET_CHASSIS
, 0);
272 case VM_CMD_ENABLE_IRQ
:
273 k
->set_irq_enable(s
, 1);
276 case VM_CMD_DISABLE_IRQ
:
277 k
->set_irq_enable(s
, 0);
280 case VM_CMD_SEND_NMI
:
281 k
->do_hw_op(s
, IPMI_SEND_NMI
, 0);
284 case VM_CMD_GRACEFUL_SHUTDOWN
:
285 k
->do_hw_op(s
, IPMI_SHUTDOWN_VIA_ACPI_OVERTEMP
, 0);
290 static void handle_msg(IPMIBmcExtern
*ibe
)
292 IPMIInterfaceClass
*k
= IPMI_INTERFACE_GET_CLASS(ibe
->parent
.intf
);
294 if (ibe
->in_escape
) {
295 ipmi_debug("msg escape not ended\n");
298 if (ibe
->inpos
< 5) {
299 ipmi_debug("msg too short\n");
302 if (ibe
->in_too_many
) {
303 ibe
->inbuf
[3] = IPMI_CC_REQUEST_DATA_TRUNCATED
;
305 } else if (ipmb_checksum(ibe
->inbuf
, ibe
->inpos
, 0) != 0) {
306 ipmi_debug("msg checksum failure\n");
309 ibe
->inpos
--; /* Remove checkum */
312 timer_del(ibe
->extern_timer
);
313 ibe
->waiting_rsp
= false;
314 k
->handle_rsp(ibe
->parent
.intf
, ibe
->inbuf
[0], ibe
->inbuf
+ 1, ibe
->inpos
- 1);
317 static int can_receive(void *opaque
)
322 static void receive(void *opaque
, const uint8_t *buf
, int size
)
324 IPMIBmcExtern
*ibe
= opaque
;
328 for (i
= 0; i
< size
; i
++) {
329 unsigned char ch
= buf
[i
];
334 ibe
->in_too_many
= false;
339 if (ibe
->in_too_many
) {
340 ipmi_debug("cmd in too many\n");
341 ibe
->in_too_many
= false;
345 if (ibe
->in_escape
) {
346 ipmi_debug("cmd in escape\n");
347 ibe
->in_too_many
= false;
349 ibe
->in_escape
= false;
352 ibe
->in_too_many
= false;
353 if (ibe
->inpos
< 1) {
356 hw_op
= ibe
->inbuf
[0];
362 ibe
->in_escape
= true;
366 if (ibe
->in_escape
) {
368 ibe
->in_escape
= false;
370 if (ibe
->in_too_many
) {
373 if (ibe
->inpos
>= sizeof(ibe
->inbuf
)) {
374 ibe
->in_too_many
= true;
377 ibe
->inbuf
[ibe
->inpos
] = ch
;
385 handle_hw_op(ibe
, hw_op
);
388 static void chr_event(void *opaque
, int event
)
390 IPMIBmcExtern
*ibe
= opaque
;
391 IPMIInterface
*s
= ibe
->parent
.intf
;
392 IPMIInterfaceClass
*k
= IPMI_INTERFACE_GET_CLASS(s
);
396 case CHR_EVENT_OPENED
:
397 ibe
->connected
= true;
400 addchar(ibe
, VM_CMD_VERSION
);
401 addchar(ibe
, VM_PROTOCOL_VERSION
);
402 ibe
->outbuf
[ibe
->outlen
] = VM_CMD_CHAR
;
404 addchar(ibe
, VM_CMD_CAPABILITIES
);
405 v
= VM_CAPABILITIES_IRQ
| VM_CAPABILITIES_ATTN
;
406 if (k
->do_hw_op(ibe
->parent
.intf
, IPMI_POWEROFF_CHASSIS
, 1) == 0) {
407 v
|= VM_CAPABILITIES_POWER
;
409 if (k
->do_hw_op(ibe
->parent
.intf
, IPMI_SHUTDOWN_VIA_ACPI_OVERTEMP
, 1)
411 v
|= VM_CAPABILITIES_GRACEFUL_SHUTDOWN
;
413 if (k
->do_hw_op(ibe
->parent
.intf
, IPMI_RESET_CHASSIS
, 1) == 0) {
414 v
|= VM_CAPABILITIES_RESET
;
416 if (k
->do_hw_op(ibe
->parent
.intf
, IPMI_SEND_NMI
, 1) == 0) {
417 v
|= VM_CAPABILITIES_NMI
;
420 ibe
->outbuf
[ibe
->outlen
] = VM_CMD_CHAR
;
422 ibe
->sending_cmd
= false;
426 case CHR_EVENT_CLOSED
:
427 if (!ibe
->connected
) {
430 ibe
->connected
= false;
432 * Don't hang the OS trying to handle the ATN bit, other end will
433 * resend on a reconnect.
436 if (ibe
->waiting_rsp
) {
437 ibe
->waiting_rsp
= false;
438 ibe
->inbuf
[1] = ibe
->outbuf
[1] | 0x04;
439 ibe
->inbuf
[2] = ibe
->outbuf
[2];
440 ibe
->inbuf
[3] = IPMI_CC_BMC_INIT_IN_PROGRESS
;
441 k
->handle_rsp(s
, ibe
->outbuf
[0], ibe
->inbuf
+ 1, 3);
447 static void ipmi_bmc_extern_handle_reset(IPMIBmc
*b
)
449 IPMIBmcExtern
*ibe
= IPMI_BMC_EXTERN(b
);
451 ibe
->send_reset
= true;
455 static void ipmi_bmc_extern_realize(DeviceState
*dev
, Error
**errp
)
457 IPMIBmcExtern
*ibe
= IPMI_BMC_EXTERN(dev
);
459 if (!qemu_chr_fe_backend_connected(&ibe
->chr
)) {
460 error_setg(errp
, "IPMI external bmc requires chardev attribute");
464 qemu_chr_fe_set_handlers(&ibe
->chr
, can_receive
, receive
,
465 chr_event
, NULL
, ibe
, NULL
, true);
468 static int ipmi_bmc_extern_post_migrate(void *opaque
, int version_id
)
470 IPMIBmcExtern
*ibe
= opaque
;
473 * We don't directly restore waiting_rsp, Instead, we return an
474 * error on the interface if a response was being waited for.
476 if (ibe
->waiting_rsp
) {
477 IPMIInterface
*ii
= ibe
->parent
.intf
;
478 IPMIInterfaceClass
*iic
= IPMI_INTERFACE_GET_CLASS(ii
);
480 ibe
->waiting_rsp
= false;
481 ibe
->inbuf
[1] = ibe
->outbuf
[1] | 0x04;
482 ibe
->inbuf
[2] = ibe
->outbuf
[2];
483 ibe
->inbuf
[3] = IPMI_CC_BMC_INIT_IN_PROGRESS
;
484 iic
->handle_rsp(ii
, ibe
->outbuf
[0], ibe
->inbuf
+ 1, 3);
489 static const VMStateDescription vmstate_ipmi_bmc_extern
= {
490 .name
= TYPE_IPMI_BMC_EXTERN
,
492 .minimum_version_id
= 1,
493 .post_load
= ipmi_bmc_extern_post_migrate
,
494 .fields
= (VMStateField
[]) {
495 VMSTATE_BOOL(send_reset
, IPMIBmcExtern
),
496 VMSTATE_BOOL(waiting_rsp
, IPMIBmcExtern
),
497 VMSTATE_END_OF_LIST()
501 static void ipmi_bmc_extern_init(Object
*obj
)
503 IPMIBmcExtern
*ibe
= IPMI_BMC_EXTERN(obj
);
505 ibe
->extern_timer
= timer_new_ns(QEMU_CLOCK_VIRTUAL
, extern_timeout
, ibe
);
506 vmstate_register(NULL
, 0, &vmstate_ipmi_bmc_extern
, ibe
);
509 static void ipmi_bmc_extern_finalize(Object
*obj
)
511 IPMIBmcExtern
*ibe
= IPMI_BMC_EXTERN(obj
);
513 timer_del(ibe
->extern_timer
);
514 timer_free(ibe
->extern_timer
);
517 static Property ipmi_bmc_extern_properties
[] = {
518 DEFINE_PROP_CHR("chardev", IPMIBmcExtern
, chr
),
519 DEFINE_PROP_END_OF_LIST(),
522 static void ipmi_bmc_extern_class_init(ObjectClass
*oc
, void *data
)
524 DeviceClass
*dc
= DEVICE_CLASS(oc
);
525 IPMIBmcClass
*bk
= IPMI_BMC_CLASS(oc
);
527 bk
->handle_command
= ipmi_bmc_extern_handle_command
;
528 bk
->handle_reset
= ipmi_bmc_extern_handle_reset
;
529 dc
->hotpluggable
= false;
530 dc
->realize
= ipmi_bmc_extern_realize
;
531 dc
->props
= ipmi_bmc_extern_properties
;
534 static const TypeInfo ipmi_bmc_extern_type
= {
535 .name
= TYPE_IPMI_BMC_EXTERN
,
536 .parent
= TYPE_IPMI_BMC
,
537 .instance_size
= sizeof(IPMIBmcExtern
),
538 .instance_init
= ipmi_bmc_extern_init
,
539 .instance_finalize
= ipmi_bmc_extern_finalize
,
540 .class_init
= ipmi_bmc_extern_class_init
,
543 static void ipmi_bmc_extern_register_types(void)
545 type_register_static(&ipmi_bmc_extern_type
);
548 type_init(ipmi_bmc_extern_register_types
)