[mirror_qemu.git] / tests / ipmi-bt-test.c

/*
 * IPMI BT test cases, using the external interface for checking
 *
 * Copyright (c) 2012 Corey Minyard <cminyard@mvista.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#include "qemu/osdep.h"

#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/tcp.h>


#include "libqtest-single.h"
#include "qemu-common.h"

#define IPMI_IRQ        5

#define IPMI_BT_BASE    0xe4

#define IPMI_BT_CTLREG_CLR_WR_PTR  0
#define IPMI_BT_CTLREG_CLR_RD_PTR  1
#define IPMI_BT_CTLREG_H2B_ATN     2
#define IPMI_BT_CTLREG_B2H_ATN     3
#define IPMI_BT_CTLREG_SMS_ATN     4
#define IPMI_BT_CTLREG_H_BUSY      6
#define IPMI_BT_CTLREG_B_BUSY      7

#define IPMI_BT_CTLREG_GET(b) ((bt_get_ctrlreg() >> (b)) & 1)
#define IPMI_BT_CTLREG_GET_H2B_ATN() IPMI_BT_CTLREG_GET(IPMI_BT_CTLREG_H2B_ATN)
#define IPMI_BT_CTLREG_GET_B2H_ATN() IPMI_BT_CTLREG_GET(IPMI_BT_CTLREG_B2H_ATN)
#define IPMI_BT_CTLREG_GET_SMS_ATN() IPMI_BT_CTLREG_GET(IPMI_BT_CTLREG_SMS_ATN)
#define IPMI_BT_CTLREG_GET_H_BUSY()  IPMI_BT_CTLREG_GET(IPMI_BT_CTLREG_H_BUSY)
#define IPMI_BT_CTLREG_GET_B_BUSY()  IPMI_BT_CTLREG_GET(IPMI_BT_CTLREG_B_BUSY)

#define IPMI_BT_CTLREG_SET(b) bt_write_ctrlreg(1 << (b))
#define IPMI_BT_CTLREG_SET_CLR_WR_PTR() IPMI_BT_CTLREG_SET( \
                                                IPMI_BT_CTLREG_CLR_WR_PTR)
#define IPMI_BT_CTLREG_SET_CLR_RD_PTR() IPMI_BT_CTLREG_SET( \
                                                IPMI_BT_CTLREG_CLR_RD_PTR)
#define IPMI_BT_CTLREG_SET_H2B_ATN()  IPMI_BT_CTLREG_SET(IPMI_BT_CTLREG_H2B_ATN)
#define IPMI_BT_CTLREG_SET_B2H_ATN()  IPMI_BT_CTLREG_SET(IPMI_BT_CTLREG_B2H_ATN)
#define IPMI_BT_CTLREG_SET_SMS_ATN()  IPMI_BT_CTLREG_SET(IPMI_BT_CTLREG_SMS_ATN)
#define IPMI_BT_CTLREG_SET_H_BUSY()   IPMI_BT_CTLREG_SET(IPMI_BT_CTLREG_H_BUSY)

static int bt_ints_enabled;

static uint8_t bt_get_ctrlreg(void)
{
    return inb(IPMI_BT_BASE);
}

static void bt_write_ctrlreg(uint8_t val)
{
    outb(IPMI_BT_BASE, val);
}

static uint8_t bt_get_buf(void)
{
    return inb(IPMI_BT_BASE + 1);
}

static void bt_write_buf(uint8_t val)
{
    outb(IPMI_BT_BASE + 1, val);
}

static uint8_t bt_get_irqreg(void)
{
    return inb(IPMI_BT_BASE + 2);
}

static void bt_write_irqreg(uint8_t val)
{
    outb(IPMI_BT_BASE + 2, val);
}

static void bt_wait_b_busy(void)
{
    unsigned int count = 1000;
    while (IPMI_BT_CTLREG_GET_B_BUSY() != 0) {
        g_assert(--count != 0);
        usleep(100);
    }
}

static void bt_wait_b2h_atn(void)
{
    unsigned int count = 1000;
    while (IPMI_BT_CTLREG_GET_B2H_ATN() == 0) {
        g_assert(--count != 0);
        usleep(100);
    }
}


static int emu_lfd;
static int emu_fd;
static in_port_t emu_port;
static uint8_t inbuf[100];
static unsigned int inbuf_len;
static unsigned int inbuf_pos;
static int last_was_aa;

static void read_emu_data(void)
{
    fd_set readfds;
    int rv;
    struct timeval tv;

    FD_ZERO(&readfds);
    FD_SET(emu_fd, &readfds);
    tv.tv_sec = 10;
    tv.tv_usec = 0;
    rv = select(emu_fd + 1, &readfds, NULL, NULL, &tv);
    if (rv == -1) {
        perror("select");
    }
    g_assert(rv == 1);
    rv = read(emu_fd, inbuf, sizeof(inbuf));
    if (rv == -1) {
        perror("read");
    }
    g_assert(rv > 0);
    inbuf_len = rv;
    inbuf_pos = 0;
}

static void write_emu_msg(uint8_t *msg, unsigned int len)
{
    int rv;

#ifdef DEBUG_TEST
    {
        unsigned int i;
        printf("sending:");
        for (i = 0; i < len; i++) {
            printf(" %2.2x", msg[i]);
        }
        printf("\n");
    }
#endif
    rv = write(emu_fd, msg, len);
    g_assert(rv == len);
}

static void get_emu_msg(uint8_t *msg, unsigned int *len)
{
    unsigned int outpos = 0;

    for (;;) {
        while (inbuf_pos < inbuf_len) {
            uint8_t ch = inbuf[inbuf_pos++];

            g_assert(outpos < *len);
            if (last_was_aa) {
                assert(ch & 0x10);
                msg[outpos++] = ch & ~0x10;
                last_was_aa = 0;
            } else if (ch == 0xaa) {
                last_was_aa = 1;
            } else {
                msg[outpos++] = ch;
                if ((ch == 0xa0) || (ch == 0xa1)) {
                    /* Message complete */
                    *len = outpos;
                    goto done;
                }
            }
        }
        read_emu_data();
    }
 done:
#ifdef DEBUG_TEST
    {
        unsigned int i;
        printf("Msg:");
        for (i = 0; i < outpos; i++) {
            printf(" %2.2x", msg[i]);
        }
        printf("\n");
    }
#endif
    return;
}

static uint8_t
ipmb_checksum(const unsigned char *data, int size, unsigned char start)
{
        unsigned char csum = start;

        for (; size > 0; size--, data++) {
                csum += *data;
        }
        return csum;
}

static uint8_t get_dev_id_cmd[] = { 0x18, 0x01 };
static uint8_t get_dev_id_rsp[] = { 0x1c, 0x01, 0x00, 0x20, 0x00, 0x00, 0x00,
                                    0x02, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00 };

static uint8_t set_bmc_globals_cmd[] = { 0x18, 0x2e, 0x0f };
static uint8_t set_bmc_globals_rsp[] = { 0x1c, 0x2e, 0x00 };
static uint8_t enable_irq_cmd[] = { 0x05, 0xa1 };

static void emu_msg_handler(void)
{
    uint8_t msg[100];
    unsigned int msg_len = sizeof(msg);

    get_emu_msg(msg, &msg_len);
    g_assert(msg_len >= 5);
    g_assert(msg[msg_len - 1] == 0xa0);
    msg_len--;
    g_assert(ipmb_checksum(msg, msg_len, 0) == 0);
    msg_len--;
    if ((msg[1] == get_dev_id_cmd[0]) && (msg[2] == get_dev_id_cmd[1])) {
        memcpy(msg + 1, get_dev_id_rsp, sizeof(get_dev_id_rsp));
        msg_len = sizeof(get_dev_id_rsp) + 1;
        msg[msg_len] = -ipmb_checksum(msg, msg_len, 0);
        msg_len++;
        msg[msg_len++] = 0xa0;
        write_emu_msg(msg, msg_len);
    } else if ((msg[1] == set_bmc_globals_cmd[0]) &&
               (msg[2] == set_bmc_globals_cmd[1])) {
        write_emu_msg(enable_irq_cmd, sizeof(enable_irq_cmd));
        memcpy(msg + 1, set_bmc_globals_rsp, sizeof(set_bmc_globals_rsp));
        msg_len = sizeof(set_bmc_globals_rsp) + 1;
        msg[msg_len] = -ipmb_checksum(msg, msg_len, 0);
        msg_len++;
        msg[msg_len++] = 0xa0;
        write_emu_msg(msg, msg_len);
    } else {
        g_assert(0);
    }
}

static void bt_cmd(uint8_t *cmd, unsigned int cmd_len,
                    uint8_t *rsp, unsigned int *rsp_len)
{
    unsigned int i, len, j = 0;
    uint8_t seq = 5;

    /* Should be idle */
    g_assert(bt_get_ctrlreg() == 0);

    bt_wait_b_busy();
    IPMI_BT_CTLREG_SET_CLR_WR_PTR();
    bt_write_buf(cmd_len + 1);
    bt_write_buf(cmd[0]);
    bt_write_buf(seq);
    for (i = 1; i < cmd_len; i++) {
        bt_write_buf(cmd[i]);
    }
    IPMI_BT_CTLREG_SET_H2B_ATN();

    emu_msg_handler(); /* We should get a message on the socket here. */

    bt_wait_b2h_atn();
    if (bt_ints_enabled) {
        g_assert((bt_get_irqreg() & 0x02) == 0x02);
        g_assert(get_irq(IPMI_IRQ));
        bt_write_irqreg(0x03);
    } else {
        g_assert(!get_irq(IPMI_IRQ));
    }
    IPMI_BT_CTLREG_SET_H_BUSY();
    IPMI_BT_CTLREG_SET_B2H_ATN();
    IPMI_BT_CTLREG_SET_CLR_RD_PTR();
    len = bt_get_buf();
    g_assert(len >= 4);
    rsp[0] = bt_get_buf();
    assert(bt_get_buf() == seq);
    len--;
    for (j = 1; j < len; j++) {
        rsp[j] = bt_get_buf();
    }
    IPMI_BT_CTLREG_SET_H_BUSY();
    *rsp_len = j;
}


/*
 * We should get a connect request and a short message with capabilities.
 */
static void test_connect(void)
{
    fd_set readfds;
    int rv;
    int val;
    struct timeval tv;
    uint8_t msg[100];
    unsigned int msglen;
    static uint8_t exp1[] = { 0xff, 0x01, 0xa1 }; /* A protocol version */
    static uint8_t exp2[] = { 0x08, 0x3f, 0xa1 }; /* A capabilities cmd */

    FD_ZERO(&readfds);
    FD_SET(emu_lfd, &readfds);
    tv.tv_sec = 10;
    tv.tv_usec = 0;
    rv = select(emu_lfd + 1, &readfds, NULL, NULL, &tv);
    g_assert(rv == 1);
    emu_fd = accept(emu_lfd, NULL, 0);
    if (emu_fd < 0) {
        perror("accept");
    }
    g_assert(emu_fd >= 0);

    val = 1;
    rv = setsockopt(emu_fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof(val));
    g_assert(rv != -1);

    /* Report our version */
    write_emu_msg(exp1, sizeof(exp1));

    /* Validate that we get the info we expect. */
    msglen = sizeof(msg);
    get_emu_msg(msg, &msglen);
    g_assert(msglen == sizeof(exp1));
    g_assert(memcmp(msg, exp1, msglen) == 0);
    msglen = sizeof(msg);
    get_emu_msg(msg, &msglen);
    g_assert(msglen == sizeof(exp2));
    g_assert(memcmp(msg, exp2, msglen) == 0);
}

/*
 * Send a get_device_id to do a basic test.
 */
static void test_bt_base(void)
{
    uint8_t rsp[20];
    unsigned int rsplen = sizeof(rsp);

    bt_cmd(get_dev_id_cmd, sizeof(get_dev_id_cmd), rsp, &rsplen);
    g_assert(rsplen == sizeof(get_dev_id_rsp));
    g_assert(memcmp(get_dev_id_rsp, rsp, rsplen) == 0);
}

/*
 * Enable IRQs for the interface.
 */
static void test_enable_irq(void)
{
    uint8_t rsp[20];
    unsigned int rsplen = sizeof(rsp);

    bt_cmd(set_bmc_globals_cmd, sizeof(set_bmc_globals_cmd), rsp, &rsplen);
    g_assert(rsplen == sizeof(set_bmc_globals_rsp));
    g_assert(memcmp(set_bmc_globals_rsp, rsp, rsplen) == 0);
    bt_write_irqreg(0x01);
    bt_ints_enabled = 1;
}

/*
 * Create a local TCP socket with any port, then save off the port we got.
 */
static void open_socket(void)
{
    struct sockaddr_in myaddr;
    socklen_t addrlen;

    myaddr.sin_family = AF_INET;
    myaddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
    myaddr.sin_port = 0;
    emu_lfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (emu_lfd == -1) {
        perror("socket");
        exit(1);
    }
    if (bind(emu_lfd, (struct sockaddr *) &myaddr, sizeof(myaddr)) == -1) {
        perror("bind");
        exit(1);
    }
    addrlen = sizeof(myaddr);
    if (getsockname(emu_lfd, (struct sockaddr *) &myaddr , &addrlen) == -1) {
        perror("getsockname");
        exit(1);
    }
    emu_port = ntohs(myaddr.sin_port);
    assert(listen(emu_lfd, 1) != -1);
}

int main(int argc, char **argv)
{
    int ret;

    open_socket();

    /* Run the tests */
    g_test_init(&argc, &argv, NULL);

    global_qtest = qtest_initf(
        " -chardev socket,id=ipmi0,host=localhost,port=%d,reconnect=10"
        " -device ipmi-bmc-extern,chardev=ipmi0,id=bmc0"
        " -device isa-ipmi-bt,bmc=bmc0", emu_port);
    qtest_irq_intercept_in(global_qtest, "ioapic");
    qtest_add_func("/ipmi/extern/connect", test_connect);
    qtest_add_func("/ipmi/extern/bt_base", test_bt_base);
    qtest_add_func("/ipmi/extern/bt_enable_irq", test_enable_irq);
    qtest_add_func("/ipmi/extern/bt_base_irq", test_bt_base);
    ret = g_test_run();
    qtest_quit(global_qtest);

    return ret;
}
Commit	Line	Data
24f976d3 CM	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
681c28a3	25	#include "qemu/osdep.h"
24f976d3 CM	26
	27	#include <sys/socket.h>
	28	#include <netinet/in.h>
	29	#include <netinet/ip.h>
	30	#include <netinet/tcp.h>
	31
24f976d3	32
77cd44b9	33	#include "libqtest-single.h"
24f976d3 CM	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);
77cd44b9	102	usleep(100);
24f976d3 CM	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);
77cd44b9	111	usleep(100);
24f976d3 CM	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])) {
77cd44b9	245	write_emu_msg(enable_irq_cmd, sizeof(enable_irq_cmd));
24f976d3 CM	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);
24f976d3 CM	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 */
f53b9f36	314	static uint8_t exp2[] = { 0x08, 0x3f, 0xa1 }; /* A capabilities cmd */
24f976d3 CM	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	{
24f976d3 CM	405	int ret;
24f976d3 CM	406
24f976d3 CM	407	open_socket();
	408
	409	/* Run the tests */
	410	g_test_init(&argc, &argv, NULL);
	411
88b988c8	412	global_qtest = qtest_initf(
78b27bad EB	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);
24f976d3 CM	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	}