1 /* 2 * IPMI BMC external connection 3 * 4 * Copyright (c) 2015 Corey Minyard, MontaVista Software, LLC 5 * 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: 12 * 13 * The above copyright notice and this permission notice shall be included in 14 * all copies or substantial portions of the Software. 15 * 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 22 * THE SOFTWARE. 23 */ 24 25 /* 26 * This is designed to connect with OpenIPMI's lanserv serial interface 27 * using the "VM" connection type. See that for details. 28 */ 29 30 #include "qemu/osdep.h" 31 #include "qapi/error.h" 32 #include "qemu/timer.h" 33 #include "sysemu/char.h" 34 #include "sysemu/sysemu.h" 35 #include "hw/ipmi/ipmi.h" 36 37 #define VM_MSG_CHAR 0xA0 /* Marks end of message */ 38 #define VM_CMD_CHAR 0xA1 /* Marks end of a command */ 39 #define VM_ESCAPE_CHAR 0xAA /* Set bit 4 from the next byte to 0 */ 40 41 #define VM_PROTOCOL_VERSION 1 42 #define VM_CMD_VERSION 0xff /* A version number byte follows */ 43 #define VM_CMD_NOATTN 0x00 44 #define VM_CMD_ATTN 0x01 45 #define VM_CMD_ATTN_IRQ 0x02 46 #define VM_CMD_POWEROFF 0x03 47 #define VM_CMD_RESET 0x04 48 #define VM_CMD_ENABLE_IRQ 0x05 /* Enable/disable the messaging irq */ 49 #define VM_CMD_DISABLE_IRQ 0x06 50 #define VM_CMD_SEND_NMI 0x07 51 #define VM_CMD_CAPABILITIES 0x08 52 #define VM_CAPABILITIES_POWER 0x01 53 #define VM_CAPABILITIES_RESET 0x02 54 #define VM_CAPABILITIES_IRQ 0x04 55 #define VM_CAPABILITIES_NMI 0x08 56 #define VM_CAPABILITIES_ATTN 0x10 57 #define VM_CMD_FORCEOFF 0x09 58 59 #define TYPE_IPMI_BMC_EXTERN "ipmi-bmc-extern" 60 #define IPMI_BMC_EXTERN(obj) OBJECT_CHECK(IPMIBmcExtern, (obj), \ 61 TYPE_IPMI_BMC_EXTERN) 62 typedef struct IPMIBmcExtern { 63 IPMIBmc parent; 64 65 CharDriverState *chr; 66 67 bool connected; 68 69 unsigned char inbuf[MAX_IPMI_MSG_SIZE + 2]; 70 unsigned int inpos; 71 bool in_escape; 72 bool in_too_many; 73 bool waiting_rsp; 74 bool sending_cmd; 75 76 unsigned char outbuf[(MAX_IPMI_MSG_SIZE + 2) * 2 + 1]; 77 unsigned int outpos; 78 unsigned int outlen; 79 80 struct QEMUTimer *extern_timer; 81 82 /* A reset event is pending to be sent upstream. */ 83 bool send_reset; 84 } IPMIBmcExtern; 85 86 static int can_receive(void *opaque); 87 static void receive(void *opaque, const uint8_t *buf, int size); 88 static void chr_event(void *opaque, int event); 89 90 static unsigned char 91 ipmb_checksum(const unsigned char *data, int size, unsigned char start) 92 { 93 unsigned char csum = start; 94 95 for (; size > 0; size--, data++) { 96 csum += *data; 97 } 98 return csum; 99 } 100 101 static void continue_send(IPMIBmcExtern *ibe) 102 { 103 if (ibe->outlen == 0) { 104 goto check_reset; 105 } 106 send: 107 ibe->outpos += qemu_chr_fe_write(ibe->chr, ibe->outbuf + ibe->outpos, 108 ibe->outlen - ibe->outpos); 109 if (ibe->outpos < ibe->outlen) { 110 /* Not fully transmitted, try again in a 10ms */ 111 timer_mod_ns(ibe->extern_timer, 112 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + 10000000); 113 } else { 114 /* Sent */ 115 ibe->outlen = 0; 116 ibe->outpos = 0; 117 if (!ibe->sending_cmd) { 118 ibe->waiting_rsp = true; 119 } else { 120 ibe->sending_cmd = false; 121 } 122 check_reset: 123 if (ibe->connected && ibe->send_reset) { 124 /* Send the reset */ 125 ibe->outbuf[0] = VM_CMD_RESET; 126 ibe->outbuf[1] = VM_CMD_CHAR; 127 ibe->outlen = 2; 128 ibe->outpos = 0; 129 ibe->send_reset = false; 130 ibe->sending_cmd = true; 131 goto send; 132 } 133 134 if (ibe->waiting_rsp) { 135 /* Make sure we get a response within 4 seconds. */ 136 timer_mod_ns(ibe->extern_timer, 137 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + 4000000000ULL); 138 } 139 } 140 return; 141 } 142 143 static void extern_timeout(void *opaque) 144 { 145 IPMIBmcExtern *ibe = opaque; 146 IPMIInterface *s = ibe->parent.intf; 147 148 if (ibe->connected) { 149 if (ibe->waiting_rsp && (ibe->outlen == 0)) { 150 IPMIInterfaceClass *k = IPMI_INTERFACE_GET_CLASS(s); 151 /* The message response timed out, return an error. */ 152 ibe->waiting_rsp = false; 153 ibe->inbuf[1] = ibe->outbuf[1] | 0x04; 154 ibe->inbuf[2] = ibe->outbuf[2]; 155 ibe->inbuf[3] = IPMI_CC_TIMEOUT; 156 k->handle_rsp(s, ibe->outbuf[0], ibe->inbuf + 1, 3); 157 } else { 158 continue_send(ibe); 159 } 160 } 161 } 162 163 static void addchar(IPMIBmcExtern *ibe, unsigned char ch) 164 { 165 switch (ch) { 166 case VM_MSG_CHAR: 167 case VM_CMD_CHAR: 168 case VM_ESCAPE_CHAR: 169 ibe->outbuf[ibe->outlen] = VM_ESCAPE_CHAR; 170 ibe->outlen++; 171 ch |= 0x10; 172 /* No break */ 173 174 default: 175 ibe->outbuf[ibe->outlen] = ch; 176 ibe->outlen++; 177 } 178 } 179 180 static void ipmi_bmc_extern_handle_command(IPMIBmc *b, 181 uint8_t *cmd, unsigned int cmd_len, 182 unsigned int max_cmd_len, 183 uint8_t msg_id) 184 { 185 IPMIBmcExtern *ibe = IPMI_BMC_EXTERN(b); 186 IPMIInterface *s = ibe->parent.intf; 187 uint8_t err = 0, csum; 188 unsigned int i; 189 190 if (ibe->outlen) { 191 /* We already have a command queued. Shouldn't ever happen. */ 192 fprintf(stderr, "IPMI KCS: Got command when not finished with the" 193 " previous command\n"); 194 abort(); 195 } 196 197 /* If it's too short or it was truncated, return an error. */ 198 if (cmd_len < 2) { 199 err = IPMI_CC_REQUEST_DATA_LENGTH_INVALID; 200 } else if ((cmd_len > max_cmd_len) || (cmd_len > MAX_IPMI_MSG_SIZE)) { 201 err = IPMI_CC_REQUEST_DATA_TRUNCATED; 202 } else if (!ibe->connected) { 203 err = IPMI_CC_BMC_INIT_IN_PROGRESS; 204 } 205 if (err) { 206 IPMIInterfaceClass *k = IPMI_INTERFACE_GET_CLASS(s); 207 unsigned char rsp[3]; 208 rsp[0] = cmd[0] | 0x04; 209 rsp[1] = cmd[1]; 210 rsp[2] = err; 211 ibe->waiting_rsp = false; 212 k->handle_rsp(s, msg_id, rsp, 3); 213 goto out; 214 } 215 216 addchar(ibe, msg_id); 217 for (i = 0; i < cmd_len; i++) { 218 addchar(ibe, cmd[i]); 219 } 220 csum = ipmb_checksum(&msg_id, 1, 0); 221 addchar(ibe, -ipmb_checksum(cmd, cmd_len, csum)); 222 223 ibe->outbuf[ibe->outlen] = VM_MSG_CHAR; 224 ibe->outlen++; 225 226 /* Start the transmit */ 227 continue_send(ibe); 228 229 out: 230 return; 231 } 232 233 static void handle_hw_op(IPMIBmcExtern *ibe, unsigned char hw_op) 234 { 235 IPMIInterface *s = ibe->parent.intf; 236 IPMIInterfaceClass *k = IPMI_INTERFACE_GET_CLASS(s); 237 238 switch (hw_op) { 239 case VM_CMD_VERSION: 240 /* We only support one version at this time. */ 241 break; 242 243 case VM_CMD_NOATTN: 244 k->set_atn(s, 0, 0); 245 break; 246 247 case VM_CMD_ATTN: 248 k->set_atn(s, 1, 0); 249 break; 250 251 case VM_CMD_ATTN_IRQ: 252 k->set_atn(s, 1, 1); 253 break; 254 255 case VM_CMD_POWEROFF: 256 k->do_hw_op(s, IPMI_POWEROFF_CHASSIS, 0); 257 break; 258 259 case VM_CMD_RESET: 260 k->do_hw_op(s, IPMI_RESET_CHASSIS, 0); 261 break; 262 263 case VM_CMD_ENABLE_IRQ: 264 k->set_irq_enable(s, 1); 265 break; 266 267 case VM_CMD_DISABLE_IRQ: 268 k->set_irq_enable(s, 0); 269 break; 270 271 case VM_CMD_SEND_NMI: 272 k->do_hw_op(s, IPMI_SEND_NMI, 0); 273 break; 274 275 case VM_CMD_FORCEOFF: 276 qemu_system_shutdown_request(); 277 break; 278 } 279 } 280 281 static void handle_msg(IPMIBmcExtern *ibe) 282 { 283 IPMIInterfaceClass *k = IPMI_INTERFACE_GET_CLASS(ibe->parent.intf); 284 285 if (ibe->in_escape) { 286 ipmi_debug("msg escape not ended\n"); 287 return; 288 } 289 if (ibe->inpos < 5) { 290 ipmi_debug("msg too short\n"); 291 return; 292 } 293 if (ibe->in_too_many) { 294 ibe->inbuf[3] = IPMI_CC_REQUEST_DATA_TRUNCATED; 295 ibe->inpos = 4; 296 } else if (ipmb_checksum(ibe->inbuf, ibe->inpos, 0) != 0) { 297 ipmi_debug("msg checksum failure\n"); 298 return; 299 } else { 300 ibe->inpos--; /* Remove checkum */ 301 } 302 303 timer_del(ibe->extern_timer); 304 ibe->waiting_rsp = false; 305 k->handle_rsp(ibe->parent.intf, ibe->inbuf[0], ibe->inbuf + 1, ibe->inpos - 1); 306 } 307 308 static int can_receive(void *opaque) 309 { 310 return 1; 311 } 312 313 static void receive(void *opaque, const uint8_t *buf, int size) 314 { 315 IPMIBmcExtern *ibe = opaque; 316 int i; 317 unsigned char hw_op; 318 319 for (i = 0; i < size; i++) { 320 unsigned char ch = buf[i]; 321 322 switch (ch) { 323 case VM_MSG_CHAR: 324 handle_msg(ibe); 325 ibe->in_too_many = false; 326 ibe->inpos = 0; 327 break; 328 329 case VM_CMD_CHAR: 330 if (ibe->in_too_many) { 331 ipmi_debug("cmd in too many\n"); 332 ibe->in_too_many = false; 333 ibe->inpos = 0; 334 break; 335 } 336 if (ibe->in_escape) { 337 ipmi_debug("cmd in escape\n"); 338 ibe->in_too_many = false; 339 ibe->inpos = 0; 340 ibe->in_escape = false; 341 break; 342 } 343 ibe->in_too_many = false; 344 if (ibe->inpos < 1) { 345 break; 346 } 347 hw_op = ibe->inbuf[0]; 348 ibe->inpos = 0; 349 goto out_hw_op; 350 break; 351 352 case VM_ESCAPE_CHAR: 353 ibe->in_escape = true; 354 break; 355 356 default: 357 if (ibe->in_escape) { 358 ch &= ~0x10; 359 ibe->in_escape = false; 360 } 361 if (ibe->in_too_many) { 362 break; 363 } 364 if (ibe->inpos >= sizeof(ibe->inbuf)) { 365 ibe->in_too_many = true; 366 break; 367 } 368 ibe->inbuf[ibe->inpos] = ch; 369 ibe->inpos++; 370 break; 371 } 372 } 373 return; 374 375 out_hw_op: 376 handle_hw_op(ibe, hw_op); 377 } 378 379 static void chr_event(void *opaque, int event) 380 { 381 IPMIBmcExtern *ibe = opaque; 382 IPMIInterface *s = ibe->parent.intf; 383 IPMIInterfaceClass *k = IPMI_INTERFACE_GET_CLASS(s); 384 unsigned char v; 385 386 switch (event) { 387 case CHR_EVENT_OPENED: 388 ibe->connected = true; 389 ibe->outpos = 0; 390 ibe->outlen = 0; 391 addchar(ibe, VM_CMD_VERSION); 392 addchar(ibe, VM_PROTOCOL_VERSION); 393 ibe->outbuf[ibe->outlen] = VM_CMD_CHAR; 394 ibe->outlen++; 395 addchar(ibe, VM_CMD_CAPABILITIES); 396 v = VM_CAPABILITIES_IRQ | VM_CAPABILITIES_ATTN; 397 if (k->do_hw_op(ibe->parent.intf, IPMI_POWEROFF_CHASSIS, 1) == 0) { 398 v |= VM_CAPABILITIES_POWER; 399 } 400 if (k->do_hw_op(ibe->parent.intf, IPMI_RESET_CHASSIS, 1) == 0) { 401 v |= VM_CAPABILITIES_RESET; 402 } 403 if (k->do_hw_op(ibe->parent.intf, IPMI_SEND_NMI, 1) == 0) { 404 v |= VM_CAPABILITIES_NMI; 405 } 406 addchar(ibe, v); 407 ibe->outbuf[ibe->outlen] = VM_CMD_CHAR; 408 ibe->outlen++; 409 ibe->sending_cmd = false; 410 continue_send(ibe); 411 break; 412 413 case CHR_EVENT_CLOSED: 414 if (!ibe->connected) { 415 return; 416 } 417 ibe->connected = false; 418 if (ibe->waiting_rsp) { 419 ibe->waiting_rsp = false; 420 ibe->inbuf[1] = ibe->outbuf[1] | 0x04; 421 ibe->inbuf[2] = ibe->outbuf[2]; 422 ibe->inbuf[3] = IPMI_CC_BMC_INIT_IN_PROGRESS; 423 k->handle_rsp(s, ibe->outbuf[0], ibe->inbuf + 1, 3); 424 } 425 break; 426 } 427 } 428 429 static void ipmi_bmc_extern_handle_reset(IPMIBmc *b) 430 { 431 IPMIBmcExtern *ibe = IPMI_BMC_EXTERN(b); 432 433 ibe->send_reset = true; 434 continue_send(ibe); 435 } 436 437 static void ipmi_bmc_extern_realize(DeviceState *dev, Error **errp) 438 { 439 IPMIBmcExtern *ibe = IPMI_BMC_EXTERN(dev); 440 441 if (!ibe->chr) { 442 error_setg(errp, "IPMI external bmc requires chardev attribute"); 443 return; 444 } 445 446 qemu_chr_add_handlers(ibe->chr, can_receive, receive, chr_event, ibe); 447 } 448 449 static int ipmi_bmc_extern_post_migrate(void *opaque, int version_id) 450 { 451 IPMIBmcExtern *ibe = opaque; 452 453 /* 454 * We don't directly restore waiting_rsp, Instead, we return an 455 * error on the interface if a response was being waited for. 456 */ 457 if (ibe->waiting_rsp) { 458 IPMIInterface *ii = ibe->parent.intf; 459 IPMIInterfaceClass *iic = IPMI_INTERFACE_GET_CLASS(ii); 460 461 ibe->waiting_rsp = false; 462 ibe->inbuf[1] = ibe->outbuf[1] | 0x04; 463 ibe->inbuf[2] = ibe->outbuf[2]; 464 ibe->inbuf[3] = IPMI_CC_BMC_INIT_IN_PROGRESS; 465 iic->handle_rsp(ii, ibe->outbuf[0], ibe->inbuf + 1, 3); 466 } 467 return 0; 468 } 469 470 static const VMStateDescription vmstate_ipmi_bmc_extern = { 471 .name = TYPE_IPMI_BMC_EXTERN, 472 .version_id = 1, 473 .minimum_version_id = 1, 474 .post_load = ipmi_bmc_extern_post_migrate, 475 .fields = (VMStateField[]) { 476 VMSTATE_BOOL(send_reset, IPMIBmcExtern), 477 VMSTATE_BOOL(waiting_rsp, IPMIBmcExtern), 478 VMSTATE_END_OF_LIST() 479 } 480 }; 481 482 static void ipmi_bmc_extern_init(Object *obj) 483 { 484 IPMIBmcExtern *ibe = IPMI_BMC_EXTERN(obj); 485 486 ibe->extern_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, extern_timeout, ibe); 487 vmstate_register(NULL, 0, &vmstate_ipmi_bmc_extern, ibe); 488 } 489 490 static Property ipmi_bmc_extern_properties[] = { 491 DEFINE_PROP_CHR("chardev", IPMIBmcExtern, chr), 492 DEFINE_PROP_END_OF_LIST(), 493 }; 494 495 static void ipmi_bmc_extern_class_init(ObjectClass *oc, void *data) 496 { 497 DeviceClass *dc = DEVICE_CLASS(oc); 498 IPMIBmcClass *bk = IPMI_BMC_CLASS(oc); 499 500 bk->handle_command = ipmi_bmc_extern_handle_command; 501 bk->handle_reset = ipmi_bmc_extern_handle_reset; 502 dc->realize = ipmi_bmc_extern_realize; 503 dc->props = ipmi_bmc_extern_properties; 504 } 505 506 static const TypeInfo ipmi_bmc_extern_type = { 507 .name = TYPE_IPMI_BMC_EXTERN, 508 .parent = TYPE_IPMI_BMC, 509 .instance_size = sizeof(IPMIBmcExtern), 510 .instance_init = ipmi_bmc_extern_init, 511 .class_init = ipmi_bmc_extern_class_init, 512 }; 513 514 static void ipmi_bmc_extern_register_types(void) 515 { 516 type_register_static(&ipmi_bmc_extern_type); 517 } 518 519 type_init(ipmi_bmc_extern_register_types) 520