1 /* 2 * IPMI KCS test cases, using the local interface. 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 <stdint.h> 26 #include <string.h> 27 #include <stdio.h> 28 29 #include <glib.h> 30 31 #include "libqtest.h" 32 33 #define IPMI_IRQ 5 34 35 #define IPMI_KCS_BASE 0xca2 36 37 #define IPMI_KCS_STATUS_ABORT 0x60 38 #define IPMI_KCS_CMD_WRITE_START 0x61 39 #define IPMI_KCS_CMD_WRITE_END 0x62 40 #define IPMI_KCS_CMD_READ 0x68 41 42 #define IPMI_KCS_ABORTED_BY_CMD 0x01 43 44 #define IPMI_KCS_CMDREG_GET_STATE() ((kcs_get_cmdreg() >> 6) & 3) 45 #define IPMI_KCS_STATE_IDLE 0 46 #define IPMI_KCS_STATE_READ 1 47 #define IPMI_KCS_STATE_WRITE 2 48 #define IPMI_KCS_STATE_ERROR 3 49 #define IPMI_KCS_CMDREG_GET_CD() ((kcs_get_cmdreg() >> 3) & 1) 50 #define IPMI_KCS_CMDREG_GET_ATN() ((kcs_get_cmdreg() >> 2) & 1) 51 #define IPMI_KCS_CMDREG_GET_IBF() ((kcs_get_cmdreg() >> 1) & 1) 52 #define IPMI_KCS_CMDREG_GET_OBF() ((kcs_get_cmdreg() >> 0) & 1) 53 54 static int kcs_ints_enabled; 55 56 static uint8_t kcs_get_cmdreg(void) 57 { 58 return inb(IPMI_KCS_BASE + 1); 59 } 60 61 static void kcs_write_cmdreg(uint8_t val) 62 { 63 outb(IPMI_KCS_BASE + 1, val); 64 } 65 66 static uint8_t kcs_get_datareg(void) 67 { 68 return inb(IPMI_KCS_BASE); 69 } 70 71 static void kcs_write_datareg(uint8_t val) 72 { 73 outb(IPMI_KCS_BASE, val); 74 } 75 76 static void kcs_wait_ibf(void) 77 { 78 unsigned int count = 1000; 79 while (IPMI_KCS_CMDREG_GET_IBF() != 0) { 80 g_assert(--count != 0); 81 } 82 } 83 84 static void kcs_wait_obf(void) 85 { 86 unsigned int count = 1000; 87 while (IPMI_KCS_CMDREG_GET_OBF() == 0) { 88 g_assert(--count != 0); 89 } 90 } 91 92 static void kcs_clear_obf(void) 93 { 94 if (kcs_ints_enabled) { 95 g_assert(get_irq(IPMI_IRQ)); 96 } else { 97 g_assert(!get_irq(IPMI_IRQ)); 98 } 99 g_assert(IPMI_KCS_CMDREG_GET_OBF() == 1); 100 kcs_get_datareg(); 101 g_assert(IPMI_KCS_CMDREG_GET_OBF() == 0); 102 g_assert(!get_irq(IPMI_IRQ)); 103 } 104 105 static void kcs_check_state(uint8_t state) 106 { 107 g_assert(IPMI_KCS_CMDREG_GET_STATE() == state); 108 } 109 110 static void kcs_cmd(uint8_t *cmd, unsigned int cmd_len, 111 uint8_t *rsp, unsigned int *rsp_len) 112 { 113 unsigned int i, j = 0; 114 115 /* Should be idle */ 116 g_assert(kcs_get_cmdreg() == 0); 117 118 kcs_write_cmdreg(IPMI_KCS_CMD_WRITE_START); 119 kcs_wait_ibf(); 120 kcs_check_state(IPMI_KCS_STATE_WRITE); 121 kcs_clear_obf(); 122 for (i = 0; i < cmd_len; i++) { 123 kcs_write_datareg(cmd[i]); 124 kcs_wait_ibf(); 125 kcs_check_state(IPMI_KCS_STATE_WRITE); 126 kcs_clear_obf(); 127 } 128 kcs_write_cmdreg(IPMI_KCS_CMD_WRITE_END); 129 kcs_wait_ibf(); 130 kcs_check_state(IPMI_KCS_STATE_WRITE); 131 kcs_clear_obf(); 132 kcs_write_datareg(0); 133 next_read_byte: 134 kcs_wait_ibf(); 135 switch (IPMI_KCS_CMDREG_GET_STATE()) { 136 case IPMI_KCS_STATE_READ: 137 kcs_wait_obf(); 138 g_assert(j < *rsp_len); 139 rsp[j++] = kcs_get_datareg(); 140 kcs_write_datareg(IPMI_KCS_CMD_READ); 141 goto next_read_byte; 142 break; 143 144 case IPMI_KCS_STATE_IDLE: 145 kcs_wait_obf(); 146 kcs_get_datareg(); 147 break; 148 149 default: 150 g_assert(0); 151 } 152 *rsp_len = j; 153 } 154 155 static void kcs_abort(uint8_t *cmd, unsigned int cmd_len, 156 uint8_t *rsp, unsigned int *rsp_len) 157 { 158 unsigned int i, j = 0; 159 unsigned int retries = 4; 160 161 /* Should be idle */ 162 g_assert(kcs_get_cmdreg() == 0); 163 164 kcs_write_cmdreg(IPMI_KCS_CMD_WRITE_START); 165 kcs_wait_ibf(); 166 kcs_check_state(IPMI_KCS_STATE_WRITE); 167 kcs_clear_obf(); 168 for (i = 0; i < cmd_len; i++) { 169 kcs_write_datareg(cmd[i]); 170 kcs_wait_ibf(); 171 kcs_check_state(IPMI_KCS_STATE_WRITE); 172 kcs_clear_obf(); 173 } 174 kcs_write_cmdreg(IPMI_KCS_CMD_WRITE_END); 175 kcs_wait_ibf(); 176 kcs_check_state(IPMI_KCS_STATE_WRITE); 177 kcs_clear_obf(); 178 kcs_write_datareg(0); 179 kcs_wait_ibf(); 180 switch (IPMI_KCS_CMDREG_GET_STATE()) { 181 case IPMI_KCS_STATE_READ: 182 kcs_wait_obf(); 183 g_assert(j < *rsp_len); 184 rsp[j++] = kcs_get_datareg(); 185 kcs_write_datareg(IPMI_KCS_CMD_READ); 186 break; 187 188 default: 189 g_assert(0); 190 } 191 192 /* Start the abort here */ 193 retry_abort: 194 g_assert(retries > 0); 195 196 kcs_wait_ibf(); 197 kcs_write_cmdreg(IPMI_KCS_STATUS_ABORT); 198 kcs_wait_ibf(); 199 kcs_clear_obf(); 200 kcs_write_datareg(0); 201 kcs_wait_ibf(); 202 if (IPMI_KCS_CMDREG_GET_STATE() != IPMI_KCS_STATE_READ) { 203 retries--; 204 goto retry_abort; 205 } 206 kcs_wait_obf(); 207 rsp[0] = kcs_get_datareg(); 208 kcs_write_datareg(IPMI_KCS_CMD_READ); 209 kcs_wait_ibf(); 210 if (IPMI_KCS_CMDREG_GET_STATE() != IPMI_KCS_STATE_IDLE) { 211 retries--; 212 goto retry_abort; 213 } 214 kcs_wait_obf(); 215 kcs_clear_obf(); 216 217 *rsp_len = j; 218 } 219 220 221 static uint8_t get_dev_id_cmd[] = { 0x18, 0x01 }; 222 static uint8_t get_dev_id_rsp[] = { 0x1c, 0x01, 0x00, 0x20, 0x00, 0x00, 0x00, 223 0x02, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00 }; 224 225 /* 226 * Send a get_device_id to do a basic test. 227 */ 228 static void test_kcs_base(void) 229 { 230 uint8_t rsp[20]; 231 unsigned int rsplen = sizeof(rsp); 232 233 kcs_cmd(get_dev_id_cmd, sizeof(get_dev_id_cmd), rsp, &rsplen); 234 g_assert(rsplen == sizeof(get_dev_id_rsp)); 235 g_assert(memcmp(get_dev_id_rsp, rsp, rsplen) == 0); 236 } 237 238 /* 239 * Abort a kcs operation while reading 240 */ 241 static void test_kcs_abort(void) 242 { 243 uint8_t rsp[20]; 244 unsigned int rsplen = sizeof(rsp); 245 246 kcs_abort(get_dev_id_cmd, sizeof(get_dev_id_cmd), rsp, &rsplen); 247 g_assert(rsp[0] == IPMI_KCS_ABORTED_BY_CMD); 248 } 249 250 static uint8_t set_bmc_globals_cmd[] = { 0x18, 0x2e, 0x0f }; 251 static uint8_t set_bmc_globals_rsp[] = { 0x1c, 0x2e, 0x00 }; 252 253 /* 254 * Enable interrupts 255 */ 256 static void test_enable_irq(void) 257 { 258 uint8_t rsp[20]; 259 unsigned int rsplen = sizeof(rsp); 260 261 kcs_cmd(set_bmc_globals_cmd, sizeof(set_bmc_globals_cmd), rsp, &rsplen); 262 g_assert(rsplen == sizeof(set_bmc_globals_rsp)); 263 g_assert(memcmp(set_bmc_globals_rsp, rsp, rsplen) == 0); 264 kcs_ints_enabled = 1; 265 } 266 267 int main(int argc, char **argv) 268 { 269 const char *arch = qtest_get_arch(); 270 char *cmdline; 271 int ret; 272 273 /* Check architecture */ 274 if (strcmp(arch, "i386") && strcmp(arch, "x86_64")) { 275 g_test_message("Skipping test for non-x86\n"); 276 return 0; 277 } 278 279 /* Run the tests */ 280 g_test_init(&argc, &argv, NULL); 281 282 cmdline = g_strdup_printf("-vnc none -device ipmi-bmc-sim,id=bmc0" 283 " -device isa-ipmi-kcs,bmc=bmc0"); 284 qtest_start(cmdline); 285 qtest_irq_intercept_in(global_qtest, "ioapic"); 286 qtest_add_func("/ipmi/local/kcs_base", test_kcs_base); 287 qtest_add_func("/ipmi/local/kcs_abort", test_kcs_abort); 288 qtest_add_func("/ipmi/local/kcs_enable_irq", test_enable_irq); 289 qtest_add_func("/ipmi/local/kcs_base_irq", test_kcs_base); 290 qtest_add_func("/ipmi/local/kcs_abort_irq", test_kcs_abort); 291 ret = g_test_run(); 292 qtest_quit(global_qtest); 293 294 return ret; 295 } 296