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