hw/ipmi/isa_ipmi_kcs.c

   1 /*
   2  * QEMU ISA IPMI KCS emulation
   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 #include "qemu/osdep.h"
  26 #include "qemu/log.h"
  27 #include "qemu/module.h"
  28 #include "qapi/error.h"
  29 #include "hw/ipmi/ipmi.h"
  30 #include "hw/irq.h"
  31 #include "hw/isa/isa.h"
  32 #include "hw/qdev-properties.h"
  33 #include "migration/vmstate.h"
  34
  35 #define IPMI_KCS_OBF_BIT        0
  36 #define IPMI_KCS_IBF_BIT        1
  37 #define IPMI_KCS_SMS_ATN_BIT    2
  38 #define IPMI_KCS_CD_BIT         3
  39
  40 #define IPMI_KCS_OBF_MASK          (1 << IPMI_KCS_OBF_BIT)
  41 #define IPMI_KCS_GET_OBF(d)        (((d) >> IPMI_KCS_OBF_BIT) & 0x1)
  42 #define IPMI_KCS_SET_OBF(d, v)     (d) = (((d) & ~IPMI_KCS_OBF_MASK) | \
  43                                        (((v) & 1) << IPMI_KCS_OBF_BIT))
  44 #define IPMI_KCS_IBF_MASK          (1 << IPMI_KCS_IBF_BIT)
  45 #define IPMI_KCS_GET_IBF(d)        (((d) >> IPMI_KCS_IBF_BIT) & 0x1)
  46 #define IPMI_KCS_SET_IBF(d, v)     (d) = (((d) & ~IPMI_KCS_IBF_MASK) | \
  47                                        (((v) & 1) << IPMI_KCS_IBF_BIT))
  48 #define IPMI_KCS_SMS_ATN_MASK      (1 << IPMI_KCS_SMS_ATN_BIT)
  49 #define IPMI_KCS_GET_SMS_ATN(d)    (((d) >> IPMI_KCS_SMS_ATN_BIT) & 0x1)
  50 #define IPMI_KCS_SET_SMS_ATN(d, v) (d) = (((d) & ~IPMI_KCS_SMS_ATN_MASK) | \
  51                                        (((v) & 1) << IPMI_KCS_SMS_ATN_BIT))
  52 #define IPMI_KCS_CD_MASK           (1 << IPMI_KCS_CD_BIT)
  53 #define IPMI_KCS_GET_CD(d)         (((d) >> IPMI_KCS_CD_BIT) & 0x1)
  54 #define IPMI_KCS_SET_CD(d, v)      (d) = (((d) & ~IPMI_KCS_CD_MASK) | \
  55                                        (((v) & 1) << IPMI_KCS_CD_BIT))
  56
  57 #define IPMI_KCS_IDLE_STATE        0
  58 #define IPMI_KCS_READ_STATE        1
  59 #define IPMI_KCS_WRITE_STATE       2
  60 #define IPMI_KCS_ERROR_STATE       3
  61
  62 #define IPMI_KCS_GET_STATE(d)    (((d) >> 6) & 0x3)
  63 #define IPMI_KCS_SET_STATE(d, v) ((d) = ((d) & ~0xc0) | (((v) & 0x3) << 6))
  64
  65 #define IPMI_KCS_ABORT_STATUS_CMD       0x60
  66 #define IPMI_KCS_WRITE_START_CMD        0x61
  67 #define IPMI_KCS_WRITE_END_CMD          0x62
  68 #define IPMI_KCS_READ_CMD               0x68
  69
  70 #define IPMI_KCS_STATUS_NO_ERR          0x00
  71 #define IPMI_KCS_STATUS_ABORTED_ERR     0x01
  72 #define IPMI_KCS_STATUS_BAD_CC_ERR      0x02
  73 #define IPMI_KCS_STATUS_LENGTH_ERR      0x06
  74
  75 typedef struct IPMIKCS {
  76     IPMIBmc *bmc;
  77
  78     bool do_wake;
  79
  80     qemu_irq irq;
  81
  82     uint32_t io_base;
  83     unsigned long io_length;
  84     MemoryRegion io;
  85
  86     bool obf_irq_set;
  87     bool atn_irq_set;
  88     bool use_irq;
  89     bool irqs_enabled;
  90
  91     uint8_t outmsg[MAX_IPMI_MSG_SIZE];
  92     uint32_t outpos;
  93     uint32_t outlen;
  94
  95     uint8_t inmsg[MAX_IPMI_MSG_SIZE];
  96     uint32_t inlen;
  97     bool write_end;
  98
  99     uint8_t status_reg;
 100     uint8_t data_out_reg;
 101
 102     int16_t data_in_reg; /* -1 means not written */
 103     int16_t cmd_reg;
 104
 105     /*
 106      * This is a response number that we send with the command to make
 107      * sure that the response matches the command.
 108      */
 109     uint8_t waiting_rsp;
 110 } IPMIKCS;
 111
 112 #define SET_OBF() \
 113     do {                                                                      \
 114         IPMI_KCS_SET_OBF(ik->status_reg, 1);                                  \
 115         if (ik->use_irq && ik->irqs_enabled && !ik->obf_irq_set) {            \
 116             ik->obf_irq_set = 1;                                              \
 117             if (!ik->atn_irq_set) {                                           \
 118                 qemu_irq_raise(ik->irq);                                      \
 119             }                                                                 \
 120         }                                                                     \
 121     } while (0)
 122
 123 static void ipmi_kcs_signal(IPMIKCS *ik, IPMIInterface *ii)
 124 {
 125     IPMIInterfaceClass *iic = IPMI_INTERFACE_GET_CLASS(ii);
 126
 127     ik->do_wake = 1;
 128     while (ik->do_wake) {
 129         ik->do_wake = 0;
 130         iic->handle_if_event(ii);
 131     }
 132 }
 133
 134 static void ipmi_kcs_handle_event(IPMIInterface *ii)
 135 {
 136     IPMIInterfaceClass *iic = IPMI_INTERFACE_GET_CLASS(ii);
 137     IPMIKCS *ik = iic->get_backend_data(ii);
 138
 139     if (ik->cmd_reg == IPMI_KCS_ABORT_STATUS_CMD) {
 140         if (IPMI_KCS_GET_STATE(ik->status_reg) != IPMI_KCS_ERROR_STATE) {
 141             ik->waiting_rsp++; /* Invalidate the message */
 142             ik->outmsg[0] = IPMI_KCS_STATUS_ABORTED_ERR;
 143             ik->outlen = 1;
 144             ik->outpos = 0;
 145             IPMI_KCS_SET_STATE(ik->status_reg, IPMI_KCS_ERROR_STATE);
 146             SET_OBF();
 147         }
 148         goto out;
 149     }
 150
 151     switch (IPMI_KCS_GET_STATE(ik->status_reg)) {
 152     case IPMI_KCS_IDLE_STATE:
 153         if (ik->cmd_reg == IPMI_KCS_WRITE_START_CMD) {
 154             IPMI_KCS_SET_STATE(ik->status_reg, IPMI_KCS_WRITE_STATE);
 155             ik->cmd_reg = -1;
 156             ik->write_end = 0;
 157             ik->inlen = 0;
 158             SET_OBF();
 159         }
 160         break;
 161
 162     case IPMI_KCS_READ_STATE:
 163     handle_read:
 164         if (ik->outpos >= ik->outlen) {
 165             IPMI_KCS_SET_STATE(ik->status_reg, IPMI_KCS_IDLE_STATE);
 166             SET_OBF();
 167         } else if (ik->data_in_reg == IPMI_KCS_READ_CMD) {
 168             ik->data_out_reg = ik->outmsg[ik->outpos];
 169             ik->outpos++;
 170             SET_OBF();
 171         } else {
 172             ik->outmsg[0] = IPMI_KCS_STATUS_BAD_CC_ERR;
 173             ik->outlen = 1;
 174             ik->outpos = 0;
 175             IPMI_KCS_SET_STATE(ik->status_reg, IPMI_KCS_ERROR_STATE);
 176             SET_OBF();
 177             goto out;
 178         }
 179         break;
 180
 181     case IPMI_KCS_WRITE_STATE:
 182         if (ik->data_in_reg != -1) {
 183             /*
 184              * Don't worry about input overrun here, that will be
 185              * handled in the BMC.
 186              */
 187             if (ik->inlen < sizeof(ik->inmsg)) {
 188                 ik->inmsg[ik->inlen] = ik->data_in_reg;
 189             }
 190             ik->inlen++;
 191         }
 192         if (ik->write_end) {
 193             IPMIBmcClass *bk = IPMI_BMC_GET_CLASS(ik->bmc);
 194             ik->outlen = 0;
 195             ik->write_end = 0;
 196             ik->outpos = 0;
 197             bk->handle_command(ik->bmc, ik->inmsg, ik->inlen, sizeof(ik->inmsg),
 198                                ik->waiting_rsp);
 199             goto out_noibf;
 200         } else if (ik->cmd_reg == IPMI_KCS_WRITE_END_CMD) {
 201             ik->cmd_reg = -1;
 202             ik->write_end = 1;
 203         }
 204         SET_OBF();
 205         break;
 206
 207     case IPMI_KCS_ERROR_STATE:
 208         if (ik->data_in_reg != -1) {
 209             IPMI_KCS_SET_STATE(ik->status_reg, IPMI_KCS_READ_STATE);
 210             ik->data_in_reg = IPMI_KCS_READ_CMD;
 211             goto handle_read;
 212         }
 213         break;
 214     }
 215
 216     if (ik->cmd_reg != -1) {
 217         /* Got an invalid command */
 218         ik->outmsg[0] = IPMI_KCS_STATUS_BAD_CC_ERR;
 219         ik->outlen = 1;
 220         ik->outpos = 0;
 221         IPMI_KCS_SET_STATE(ik->status_reg, IPMI_KCS_ERROR_STATE);
 222     }
 223
 224  out:
 225     ik->cmd_reg = -1;
 226     ik->data_in_reg = -1;
 227     IPMI_KCS_SET_IBF(ik->status_reg, 0);
 228  out_noibf:
 229     return;
 230 }
 231
 232 static void ipmi_kcs_handle_rsp(IPMIInterface *ii, uint8_t msg_id,
 233                                 unsigned char *rsp, unsigned int rsp_len)
 234 {
 235     IPMIInterfaceClass *iic = IPMI_INTERFACE_GET_CLASS(ii);
 236     IPMIKCS *ik = iic->get_backend_data(ii);
 237
 238     if (ik->waiting_rsp == msg_id) {
 239         ik->waiting_rsp++;
 240         if (rsp_len > sizeof(ik->outmsg)) {
 241             ik->outmsg[0] = rsp[0];
 242             ik->outmsg[1] = rsp[1];
 243             ik->outmsg[2] = IPMI_CC_CANNOT_RETURN_REQ_NUM_BYTES;
 244             ik->outlen = 3;
 245         } else {
 246             memcpy(ik->outmsg, rsp, rsp_len);
 247             ik->outlen = rsp_len;
 248         }
 249         IPMI_KCS_SET_STATE(ik->status_reg, IPMI_KCS_READ_STATE);
 250         ik->data_in_reg = IPMI_KCS_READ_CMD;
 251         ipmi_kcs_signal(ik, ii);
 252     }
 253 }
 254
 255
 256 static uint64_t ipmi_kcs_ioport_read(void *opaque, hwaddr addr, unsigned size)
 257 {
 258     IPMIInterface *ii = opaque;
 259     IPMIInterfaceClass *iic = IPMI_INTERFACE_GET_CLASS(ii);
 260     IPMIKCS *ik = iic->get_backend_data(ii);
 261     uint32_t ret;
 262
 263     switch (addr & 1) {
 264     case 0:
 265         ret = ik->data_out_reg;
 266         IPMI_KCS_SET_OBF(ik->status_reg, 0);
 267         if (ik->obf_irq_set) {
 268             ik->obf_irq_set = 0;
 269             if (!ik->atn_irq_set) {
 270                 qemu_irq_lower(ik->irq);
 271             }
 272         }
 273         break;
 274     case 1:
 275         ret = ik->status_reg;
 276         if (ik->atn_irq_set) {
 277             ik->atn_irq_set = 0;
 278             if (!ik->obf_irq_set) {
 279                 qemu_irq_lower(ik->irq);
 280             }
 281         }
 282         break;
 283     }
 284     return ret;
 285 }
 286
 287 static void ipmi_kcs_ioport_write(void *opaque, hwaddr addr, uint64_t val,
 288                                   unsigned size)
 289 {
 290     IPMIInterface *ii = opaque;
 291     IPMIInterfaceClass *iic = IPMI_INTERFACE_GET_CLASS(ii);
 292     IPMIKCS *ik = iic->get_backend_data(ii);
 293
 294     if (IPMI_KCS_GET_IBF(ik->status_reg)) {
 295         return;
 296     }
 297
 298     switch (addr & 1) {
 299     case 0:
 300         ik->data_in_reg = val;
 301         break;
 302
 303     case 1:
 304         ik->cmd_reg = val;
 305         break;
 306     }
 307     IPMI_KCS_SET_IBF(ik->status_reg, 1);
 308     ipmi_kcs_signal(ik, ii);
 309 }
 310
 311 const MemoryRegionOps ipmi_kcs_io_ops = {
 312     .read = ipmi_kcs_ioport_read,
 313     .write = ipmi_kcs_ioport_write,
 314     .impl = {
 315         .min_access_size = 1,
 316         .max_access_size = 1,
 317     },
 318     .endianness = DEVICE_LITTLE_ENDIAN,
 319 };
 320
 321 static void ipmi_kcs_set_atn(IPMIInterface *ii, int val, int irq)
 322 {
 323     IPMIInterfaceClass *iic = IPMI_INTERFACE_GET_CLASS(ii);
 324     IPMIKCS *ik = iic->get_backend_data(ii);
 325
 326     IPMI_KCS_SET_SMS_ATN(ik->status_reg, val);
 327     if (val) {
 328         if (irq && !ik->atn_irq_set && ik->use_irq && ik->irqs_enabled) {
 329             ik->atn_irq_set = 1;
 330             if (!ik->obf_irq_set) {
 331                 qemu_irq_raise(ik->irq);
 332             }
 333         }
 334     } else {
 335         if (ik->atn_irq_set) {
 336             ik->atn_irq_set = 0;
 337             if (!ik->obf_irq_set) {
 338                 qemu_irq_lower(ik->irq);
 339             }
 340         }
 341     }
 342 }
 343
 344 static void ipmi_kcs_set_irq_enable(IPMIInterface *ii, int val)
 345 {
 346     IPMIInterfaceClass *iic = IPMI_INTERFACE_GET_CLASS(ii);
 347     IPMIKCS *ik = iic->get_backend_data(ii);
 348
 349     ik->irqs_enabled = val;
 350 }
 351
 352 static void ipmi_kcs_init(IPMIInterface *ii, Error **errp)
 353 {
 354     IPMIInterfaceClass *iic = IPMI_INTERFACE_GET_CLASS(ii);
 355     IPMIKCS *ik = iic->get_backend_data(ii);
 356
 357     ik->io_length = 2;
 358     memory_region_init_io(&ik->io, NULL, &ipmi_kcs_io_ops, ii, "ipmi-kcs", 2);
 359 }
 360
 361 #define TYPE_ISA_IPMI_KCS "isa-ipmi-kcs"
 362 #define ISA_IPMI_KCS(obj) OBJECT_CHECK(ISAIPMIKCSDevice, (obj), \
 363                                        TYPE_ISA_IPMI_KCS)
 364
 365 typedef struct ISAIPMIKCSDevice {
 366     ISADevice dev;
 367     int32_t isairq;
 368     IPMIKCS kcs;
 369     uint32_t uuid;
 370 } ISAIPMIKCSDevice;
 371
 372 static void ipmi_kcs_get_fwinfo(IPMIInterface *ii, IPMIFwInfo *info)
 373 {
 374     ISAIPMIKCSDevice *iik = ISA_IPMI_KCS(ii);
 375
 376     info->interface_name = "kcs";
 377     info->interface_type = IPMI_SMBIOS_KCS;
 378     info->ipmi_spec_major_revision = 2;
 379     info->ipmi_spec_minor_revision = 0;
 380     info->base_address = iik->kcs.io_base;
 381     info->i2c_slave_address = iik->kcs.bmc->slave_addr;
 382     info->register_length = iik->kcs.io_length;
 383     info->register_spacing = 1;
 384     info->memspace = IPMI_MEMSPACE_IO;
 385     info->irq_type = IPMI_LEVEL_IRQ;
 386     info->interrupt_number = iik->isairq;
 387     info->uuid = iik->uuid;
 388 }
 389
 390 static void ipmi_kcs_class_init(IPMIInterfaceClass *iic)
 391 {
 392     iic->init = ipmi_kcs_init;
 393     iic->set_atn = ipmi_kcs_set_atn;
 394     iic->handle_rsp = ipmi_kcs_handle_rsp;
 395     iic->handle_if_event = ipmi_kcs_handle_event;
 396     iic->set_irq_enable = ipmi_kcs_set_irq_enable;
 397     iic->get_fwinfo = ipmi_kcs_get_fwinfo;
 398 }
 399
 400 static void ipmi_isa_realize(DeviceState *dev, Error **errp)
 401 {
 402     ISADevice *isadev = ISA_DEVICE(dev);
 403     ISAIPMIKCSDevice *iik = ISA_IPMI_KCS(dev);
 404     IPMIInterface *ii = IPMI_INTERFACE(dev);
 405     IPMIInterfaceClass *iic = IPMI_INTERFACE_GET_CLASS(ii);
 406
 407     if (!iik->kcs.bmc) {
 408         error_setg(errp, "IPMI device requires a bmc attribute to be set");
 409         return;
 410     }
 411
 412     iik->uuid = ipmi_next_uuid();
 413
 414     iik->kcs.bmc->intf = ii;
 415
 416     iic->init(ii, errp);
 417     if (*errp)
 418         return;
 419
 420     if (iik->isairq > 0) {
 421         isa_init_irq(isadev, &iik->kcs.irq, iik->isairq);
 422         iik->kcs.use_irq = 1;
 423     }
 424
 425     qdev_set_legacy_instance_id(dev, iik->kcs.io_base, iik->kcs.io_length);
 426
 427     isa_register_ioport(isadev, &iik->kcs.io, iik->kcs.io_base);
 428 }
 429
 430 static int ipmi_kcs_vmstate_post_load(void *opaque, int version)
 431 {
 432     IPMIKCS *ik = opaque;
 433
 434     /* Make sure all the values are sane. */
 435     if (ik->outpos >= MAX_IPMI_MSG_SIZE || ik->outlen >= MAX_IPMI_MSG_SIZE ||
 436         ik->outpos >= ik->outlen) {
 437         qemu_log_mask(LOG_GUEST_ERROR,
 438                       "ipmi:kcs: vmstate transfer received bad out values: %d %d\n",
 439                       ik->outpos, ik->outlen);
 440         ik->outpos = 0;
 441         ik->outlen = 0;
 442     }
 443
 444     if (ik->inlen >= MAX_IPMI_MSG_SIZE) {
 445         qemu_log_mask(LOG_GUEST_ERROR,
 446                       "ipmi:kcs: vmstate transfer received bad in value: %d\n",
 447                       ik->inlen);
 448         ik->inlen = 0;
 449     }
 450
 451     return 0;
 452 }
 453
 454 static bool vmstate_kcs_before_version2(void *opaque, int version)
 455 {
 456     return version <= 1;
 457 }
 458
 459 static const VMStateDescription vmstate_IPMIKCS = {
 460     .name = TYPE_IPMI_INTERFACE_PREFIX "kcs",
 461     .version_id = 2,
 462     .minimum_version_id = 1,
 463     .post_load = ipmi_kcs_vmstate_post_load,
 464     .fields      = (VMStateField[]) {
 465         VMSTATE_BOOL(obf_irq_set, IPMIKCS),
 466         VMSTATE_BOOL(atn_irq_set, IPMIKCS),
 467         VMSTATE_UNUSED_TEST(vmstate_kcs_before_version2, 1), /* Was use_irq */
 468         VMSTATE_BOOL(irqs_enabled, IPMIKCS),
 469         VMSTATE_UINT32(outpos, IPMIKCS),
 470         VMSTATE_UINT32_V(outlen, IPMIKCS, 2),
 471         VMSTATE_UINT8_ARRAY(outmsg, IPMIKCS, MAX_IPMI_MSG_SIZE),
 472         VMSTATE_UINT32_V(inlen, IPMIKCS, 2),
 473         VMSTATE_UINT8_ARRAY(inmsg, IPMIKCS, MAX_IPMI_MSG_SIZE),
 474         VMSTATE_BOOL(write_end, IPMIKCS),
 475         VMSTATE_UINT8(status_reg, IPMIKCS),
 476         VMSTATE_UINT8(data_out_reg, IPMIKCS),
 477         VMSTATE_INT16(data_in_reg, IPMIKCS),
 478         VMSTATE_INT16(cmd_reg, IPMIKCS),
 479         VMSTATE_UINT8(waiting_rsp, IPMIKCS),
 480         VMSTATE_END_OF_LIST()
 481     }
 482 };
 483
 484 static const VMStateDescription vmstate_ISAIPMIKCSDevice = {
 485     .name = TYPE_IPMI_INTERFACE,
 486     .version_id = 2,
 487     .minimum_version_id = 1,
 488     .fields      = (VMStateField[]) {
 489         VMSTATE_VSTRUCT_TEST(kcs, ISAIPMIKCSDevice, vmstate_kcs_before_version2,
 490                              0, vmstate_IPMIKCS, IPMIKCS, 1),
 491         VMSTATE_VSTRUCT_V(kcs, ISAIPMIKCSDevice, 2, vmstate_IPMIKCS,
 492                           IPMIKCS, 2),
 493         VMSTATE_END_OF_LIST()
 494     }
 495 };
 496
 497 static void isa_ipmi_kcs_init(Object *obj)
 498 {
 499     ISAIPMIKCSDevice *iik = ISA_IPMI_KCS(obj);
 500
 501     ipmi_bmc_find_and_link(obj, (Object **) &iik->kcs.bmc);
 502
 503     /*
 504      * Version 1 had an incorrect name, it clashed with the BT
 505      * IPMI device, so receive it, but transmit a different
 506      * version.
 507      */
 508     vmstate_register(NULL, 0, &vmstate_ISAIPMIKCSDevice, iik);
 509 }
 510
 511 static void *isa_ipmi_kcs_get_backend_data(IPMIInterface *ii)
 512 {
 513     ISAIPMIKCSDevice *iik = ISA_IPMI_KCS(ii);
 514
 515     return &iik->kcs;
 516 }
 517
 518 static Property ipmi_isa_properties[] = {
 519     DEFINE_PROP_UINT32("ioport", ISAIPMIKCSDevice, kcs.io_base,  0xca2),
 520     DEFINE_PROP_INT32("irq",   ISAIPMIKCSDevice, isairq,  5),
 521     DEFINE_PROP_END_OF_LIST(),
 522 };
 523
 524 static void isa_ipmi_kcs_class_init(ObjectClass *oc, void *data)
 525 {
 526     DeviceClass *dc = DEVICE_CLASS(oc);
 527     IPMIInterfaceClass *iic = IPMI_INTERFACE_CLASS(oc);
 528
 529     dc->realize = ipmi_isa_realize;
 530     dc->props = ipmi_isa_properties;
 531
 532     iic->get_backend_data = isa_ipmi_kcs_get_backend_data;
 533     ipmi_kcs_class_init(iic);
 534 }
 535
 536 static const TypeInfo isa_ipmi_kcs_info = {
 537     .name          = TYPE_ISA_IPMI_KCS,
 538     .parent        = TYPE_ISA_DEVICE,
 539     .instance_size = sizeof(ISAIPMIKCSDevice),
 540     .instance_init = isa_ipmi_kcs_init,
 541     .class_init    = isa_ipmi_kcs_class_init,
 542     .interfaces = (InterfaceInfo[]) {
 543         { TYPE_IPMI_INTERFACE },
 544         { }
 545     }
 546 };
 547
 548 static void ipmi_register_types(void)
 549 {
 550     type_register_static(&isa_ipmi_kcs_info);
 551 }
 552
 553 type_init(ipmi_register_types)