tests/qtest/ipmi-bt-test.c

   1 /*
   2  * IPMI BT test cases, using the external interface for checking
   3  *
   4  * Copyright (c) 2012 Corey Minyard <cminyard@mvista.com>
   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
  27 #include <sys/socket.h>
  28 #include <netinet/in.h>
  29 #include <netinet/ip.h>
  30 #include <netinet/tcp.h>
  31
  32
  33 #include "libqtest-single.h"
  34 #include "qemu-common.h"
  35
  36 #define IPMI_IRQ        5
  37
  38 #define IPMI_BT_BASE    0xe4
  39
  40 #define IPMI_BT_CTLREG_CLR_WR_PTR  0
  41 #define IPMI_BT_CTLREG_CLR_RD_PTR  1
  42 #define IPMI_BT_CTLREG_H2B_ATN     2
  43 #define IPMI_BT_CTLREG_B2H_ATN     3
  44 #define IPMI_BT_CTLREG_SMS_ATN     4
  45 #define IPMI_BT_CTLREG_H_BUSY      6
  46 #define IPMI_BT_CTLREG_B_BUSY      7
  47
  48 #define IPMI_BT_CTLREG_GET(b) ((bt_get_ctrlreg() >> (b)) & 1)
  49 #define IPMI_BT_CTLREG_GET_H2B_ATN() IPMI_BT_CTLREG_GET(IPMI_BT_CTLREG_H2B_ATN)
  50 #define IPMI_BT_CTLREG_GET_B2H_ATN() IPMI_BT_CTLREG_GET(IPMI_BT_CTLREG_B2H_ATN)
  51 #define IPMI_BT_CTLREG_GET_SMS_ATN() IPMI_BT_CTLREG_GET(IPMI_BT_CTLREG_SMS_ATN)
  52 #define IPMI_BT_CTLREG_GET_H_BUSY()  IPMI_BT_CTLREG_GET(IPMI_BT_CTLREG_H_BUSY)
  53 #define IPMI_BT_CTLREG_GET_B_BUSY()  IPMI_BT_CTLREG_GET(IPMI_BT_CTLREG_B_BUSY)
  54
  55 #define IPMI_BT_CTLREG_SET(b) bt_write_ctrlreg(1 << (b))
  56 #define IPMI_BT_CTLREG_SET_CLR_WR_PTR() IPMI_BT_CTLREG_SET( \
  57                                                 IPMI_BT_CTLREG_CLR_WR_PTR)
  58 #define IPMI_BT_CTLREG_SET_CLR_RD_PTR() IPMI_BT_CTLREG_SET( \
  59                                                 IPMI_BT_CTLREG_CLR_RD_PTR)
  60 #define IPMI_BT_CTLREG_SET_H2B_ATN()  IPMI_BT_CTLREG_SET(IPMI_BT_CTLREG_H2B_ATN)
  61 #define IPMI_BT_CTLREG_SET_B2H_ATN()  IPMI_BT_CTLREG_SET(IPMI_BT_CTLREG_B2H_ATN)
  62 #define IPMI_BT_CTLREG_SET_SMS_ATN()  IPMI_BT_CTLREG_SET(IPMI_BT_CTLREG_SMS_ATN)
  63 #define IPMI_BT_CTLREG_SET_H_BUSY()   IPMI_BT_CTLREG_SET(IPMI_BT_CTLREG_H_BUSY)
  64
  65 static int bt_ints_enabled;
  66
  67 static uint8_t bt_get_ctrlreg(void)
  68 {
  69     return inb(IPMI_BT_BASE);
  70 }
  71
  72 static void bt_write_ctrlreg(uint8_t val)
  73 {
  74     outb(IPMI_BT_BASE, val);
  75 }
  76
  77 static uint8_t bt_get_buf(void)
  78 {
  79     return inb(IPMI_BT_BASE + 1);
  80 }
  81
  82 static void bt_write_buf(uint8_t val)
  83 {
  84     outb(IPMI_BT_BASE + 1, val);
  85 }
  86
  87 static uint8_t bt_get_irqreg(void)
  88 {
  89     return inb(IPMI_BT_BASE + 2);
  90 }
  91
  92 static void bt_write_irqreg(uint8_t val)
  93 {
  94     outb(IPMI_BT_BASE + 2, val);
  95 }
  96
  97 static void bt_wait_b_busy(void)
  98 {
  99     unsigned int count = 1000;
 100     while (IPMI_BT_CTLREG_GET_B_BUSY() != 0) {
 101         g_assert(--count != 0);
 102         usleep(100);
 103     }
 104 }
 105
 106 static void bt_wait_b2h_atn(void)
 107 {
 108     unsigned int count = 1000;
 109     while (IPMI_BT_CTLREG_GET_B2H_ATN() == 0) {
 110         g_assert(--count != 0);
 111         usleep(100);
 112     }
 113 }
 114
 115
 116 static int emu_lfd;
 117 static int emu_fd;
 118 static in_port_t emu_port;
 119 static uint8_t inbuf[100];
 120 static unsigned int inbuf_len;
 121 static unsigned int inbuf_pos;
 122 static int last_was_aa;
 123
 124 static void read_emu_data(void)
 125 {
 126     fd_set readfds;
 127     int rv;
 128     struct timeval tv;
 129
 130     FD_ZERO(&readfds);
 131     FD_SET(emu_fd, &readfds);
 132     tv.tv_sec = 10;
 133     tv.tv_usec = 0;
 134     rv = select(emu_fd + 1, &readfds, NULL, NULL, &tv);
 135     if (rv == -1) {
 136         perror("select");
 137     }
 138     g_assert(rv == 1);
 139     rv = read(emu_fd, inbuf, sizeof(inbuf));
 140     if (rv == -1) {
 141         perror("read");
 142     }
 143     g_assert(rv > 0);
 144     inbuf_len = rv;
 145     inbuf_pos = 0;
 146 }
 147
 148 static void write_emu_msg(uint8_t *msg, unsigned int len)
 149 {
 150     int rv;
 151
 152 #ifdef DEBUG_TEST
 153     {
 154         unsigned int i;
 155         printf("sending:");
 156         for (i = 0; i < len; i++) {
 157             printf(" %2.2x", msg[i]);
 158         }
 159         printf("\n");
 160     }
 161 #endif
 162     rv = write(emu_fd, msg, len);
 163     g_assert(rv == len);
 164 }
 165
 166 static void get_emu_msg(uint8_t *msg, unsigned int *len)
 167 {
 168     unsigned int outpos = 0;
 169
 170     for (;;) {
 171         while (inbuf_pos < inbuf_len) {
 172             uint8_t ch = inbuf[inbuf_pos++];
 173
 174             g_assert(outpos < *len);
 175             if (last_was_aa) {
 176                 assert(ch & 0x10);
 177                 msg[outpos++] = ch & ~0x10;
 178                 last_was_aa = 0;
 179             } else if (ch == 0xaa) {
 180                 last_was_aa = 1;
 181             } else {
 182                 msg[outpos++] = ch;
 183                 if ((ch == 0xa0) || (ch == 0xa1)) {
 184                     /* Message complete */
 185                     *len = outpos;
 186                     goto done;
 187                 }
 188             }
 189         }
 190         read_emu_data();
 191     }
 192  done:
 193 #ifdef DEBUG_TEST
 194     {
 195         unsigned int i;
 196         printf("Msg:");
 197         for (i = 0; i < outpos; i++) {
 198             printf(" %2.2x", msg[i]);
 199         }
 200         printf("\n");
 201     }
 202 #endif
 203     return;
 204 }
 205
 206 static uint8_t
 207 ipmb_checksum(const unsigned char *data, int size, unsigned char start)
 208 {
 209         unsigned char csum = start;
 210
 211         for (; size > 0; size--, data++) {
 212                 csum += *data;
 213         }
 214         return csum;
 215 }
 216
 217 static uint8_t get_dev_id_cmd[] = { 0x18, 0x01 };
 218 static uint8_t get_dev_id_rsp[] = { 0x1c, 0x01, 0x00, 0x20, 0x00, 0x00, 0x00,
 219                                     0x02, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00 };
 220
 221 static uint8_t set_bmc_globals_cmd[] = { 0x18, 0x2e, 0x0f };
 222 static uint8_t set_bmc_globals_rsp[] = { 0x1c, 0x2e, 0x00 };
 223 static uint8_t enable_irq_cmd[] = { 0x05, 0xa1 };
 224
 225 static void emu_msg_handler(void)
 226 {
 227     uint8_t msg[100];
 228     unsigned int msg_len = sizeof(msg);
 229
 230     get_emu_msg(msg, &msg_len);
 231     g_assert(msg_len >= 5);
 232     g_assert(msg[msg_len - 1] == 0xa0);
 233     msg_len--;
 234     g_assert(ipmb_checksum(msg, msg_len, 0) == 0);
 235     msg_len--;
 236     if ((msg[1] == get_dev_id_cmd[0]) && (msg[2] == get_dev_id_cmd[1])) {
 237         memcpy(msg + 1, get_dev_id_rsp, sizeof(get_dev_id_rsp));
 238         msg_len = sizeof(get_dev_id_rsp) + 1;
 239         msg[msg_len] = -ipmb_checksum(msg, msg_len, 0);
 240         msg_len++;
 241         msg[msg_len++] = 0xa0;
 242         write_emu_msg(msg, msg_len);
 243     } else if ((msg[1] == set_bmc_globals_cmd[0]) &&
 244                (msg[2] == set_bmc_globals_cmd[1])) {
 245         write_emu_msg(enable_irq_cmd, sizeof(enable_irq_cmd));
 246         memcpy(msg + 1, set_bmc_globals_rsp, sizeof(set_bmc_globals_rsp));
 247         msg_len = sizeof(set_bmc_globals_rsp) + 1;
 248         msg[msg_len] = -ipmb_checksum(msg, msg_len, 0);
 249         msg_len++;
 250         msg[msg_len++] = 0xa0;
 251         write_emu_msg(msg, msg_len);
 252     } else {
 253         g_assert(0);
 254     }
 255 }
 256
 257 static void bt_cmd(uint8_t *cmd, unsigned int cmd_len,
 258                     uint8_t *rsp, unsigned int *rsp_len)
 259 {
 260     unsigned int i, len, j = 0;
 261     uint8_t seq = 5;
 262
 263     /* Should be idle */
 264     g_assert(bt_get_ctrlreg() == 0);
 265
 266     bt_wait_b_busy();
 267     IPMI_BT_CTLREG_SET_CLR_WR_PTR();
 268     bt_write_buf(cmd_len + 1);
 269     bt_write_buf(cmd[0]);
 270     bt_write_buf(seq);
 271     for (i = 1; i < cmd_len; i++) {
 272         bt_write_buf(cmd[i]);
 273     }
 274     IPMI_BT_CTLREG_SET_H2B_ATN();
 275
 276     emu_msg_handler(); /* We should get a message on the socket here. */
 277
 278     bt_wait_b2h_atn();
 279     if (bt_ints_enabled) {
 280         g_assert((bt_get_irqreg() & 0x02) == 0x02);
 281         g_assert(get_irq(IPMI_IRQ));
 282         bt_write_irqreg(0x03);
 283     } else {
 284         g_assert(!get_irq(IPMI_IRQ));
 285     }
 286     IPMI_BT_CTLREG_SET_H_BUSY();
 287     IPMI_BT_CTLREG_SET_B2H_ATN();
 288     IPMI_BT_CTLREG_SET_CLR_RD_PTR();
 289     len = bt_get_buf();
 290     g_assert(len >= 4);
 291     rsp[0] = bt_get_buf();
 292     assert(bt_get_buf() == seq);
 293     len--;
 294     for (j = 1; j < len; j++) {
 295         rsp[j] = bt_get_buf();
 296     }
 297     IPMI_BT_CTLREG_SET_H_BUSY();
 298     *rsp_len = j;
 299 }
 300
 301
 302 /*
 303  * We should get a connect request and a short message with capabilities.
 304  */
 305 static void test_connect(void)
 306 {
 307     fd_set readfds;
 308     int rv;
 309     int val;
 310     struct timeval tv;
 311     uint8_t msg[100];
 312     unsigned int msglen;
 313     static uint8_t exp1[] = { 0xff, 0x01, 0xa1 }; /* A protocol version */
 314     static uint8_t exp2[] = { 0x08, 0x3f, 0xa1 }; /* A capabilities cmd */
 315
 316     FD_ZERO(&readfds);
 317     FD_SET(emu_lfd, &readfds);
 318     tv.tv_sec = 10;
 319     tv.tv_usec = 0;
 320     rv = select(emu_lfd + 1, &readfds, NULL, NULL, &tv);
 321     g_assert(rv == 1);
 322     emu_fd = accept(emu_lfd, NULL, 0);
 323     if (emu_fd < 0) {
 324         perror("accept");
 325     }
 326     g_assert(emu_fd >= 0);
 327
 328     val = 1;
 329     rv = setsockopt(emu_fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof(val));
 330     g_assert(rv != -1);
 331
 332     /* Report our version */
 333     write_emu_msg(exp1, sizeof(exp1));
 334
 335     /* Validate that we get the info we expect. */
 336     msglen = sizeof(msg);
 337     get_emu_msg(msg, &msglen);
 338     g_assert(msglen == sizeof(exp1));
 339     g_assert(memcmp(msg, exp1, msglen) == 0);
 340     msglen = sizeof(msg);
 341     get_emu_msg(msg, &msglen);
 342     g_assert(msglen == sizeof(exp2));
 343     g_assert(memcmp(msg, exp2, msglen) == 0);
 344 }
 345
 346 /*
 347  * Send a get_device_id to do a basic test.
 348  */
 349 static void test_bt_base(void)
 350 {
 351     uint8_t rsp[20];
 352     unsigned int rsplen = sizeof(rsp);
 353
 354     bt_cmd(get_dev_id_cmd, sizeof(get_dev_id_cmd), rsp, &rsplen);
 355     g_assert(rsplen == sizeof(get_dev_id_rsp));
 356     g_assert(memcmp(get_dev_id_rsp, rsp, rsplen) == 0);
 357 }
 358
 359 /*
 360  * Enable IRQs for the interface.
 361  */
 362 static void test_enable_irq(void)
 363 {
 364     uint8_t rsp[20];
 365     unsigned int rsplen = sizeof(rsp);
 366
 367     bt_cmd(set_bmc_globals_cmd, sizeof(set_bmc_globals_cmd), rsp, &rsplen);
 368     g_assert(rsplen == sizeof(set_bmc_globals_rsp));
 369     g_assert(memcmp(set_bmc_globals_rsp, rsp, rsplen) == 0);
 370     bt_write_irqreg(0x01);
 371     bt_ints_enabled = 1;
 372 }
 373
 374 /*
 375  * Create a local TCP socket with any port, then save off the port we got.
 376  */
 377 static void open_socket(void)
 378 {
 379     struct sockaddr_in myaddr;
 380     socklen_t addrlen;
 381
 382     myaddr.sin_family = AF_INET;
 383     myaddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
 384     myaddr.sin_port = 0;
 385     emu_lfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 386     if (emu_lfd == -1) {
 387         perror("socket");
 388         exit(1);
 389     }
 390     if (bind(emu_lfd, (struct sockaddr *) &myaddr, sizeof(myaddr)) == -1) {
 391         perror("bind");
 392         exit(1);
 393     }
 394     addrlen = sizeof(myaddr);
 395     if (getsockname(emu_lfd, (struct sockaddr *) &myaddr , &addrlen) == -1) {
 396         perror("getsockname");
 397         exit(1);
 398     }
 399     emu_port = ntohs(myaddr.sin_port);
 400     assert(listen(emu_lfd, 1) != -1);
 401 }
 402
 403 int main(int argc, char **argv)
 404 {
 405     int ret;
 406
 407     open_socket();
 408
 409     /* Run the tests */
 410     g_test_init(&argc, &argv, NULL);
 411
 412     global_qtest = qtest_initf(
 413         " -chardev socket,id=ipmi0,host=localhost,port=%d,reconnect=10"
 414         " -device ipmi-bmc-extern,chardev=ipmi0,id=bmc0"
 415         " -device isa-ipmi-bt,bmc=bmc0", emu_port);
 416     qtest_irq_intercept_in(global_qtest, "ioapic");
 417     qtest_add_func("/ipmi/extern/connect", test_connect);
 418     qtest_add_func("/ipmi/extern/bt_base", test_bt_base);
 419     qtest_add_func("/ipmi/extern/bt_enable_irq", test_enable_irq);
 420     qtest_add_func("/ipmi/extern/bt_base_irq", test_bt_base);
 421     ret = g_test_run();
 422     qtest_quit(global_qtest);
 423
 424     return ret;
 425 }