/************************************************************************
* control_console
*
* 引数： caller
* packet
*
* 返値： E_NOSPT を返す。
*
* 処理：
*
*/
W
control_console (ID caller, DDEV_CTL_REQ *packet)
{
DDEV_RES res;
switch (packet->cmd)
{
case CONSOLE_CLEAR:
clear_console ();
res.body.ctl_res.dd = packet->dd;
res.body.ctl_res.errcd = E_OK;
res.body.ctl_res.errinfo = E_OK;
snd_mbf (caller, sizeof (res), &res);
return (E_OK);
case CONSOLE_MOVE:
if (packet->len != 2)
{
res.body.ctl_res.dd = packet->dd;
res.body.ctl_res.errcd = E_PAR;
res.body.ctl_res.errinfo = E_PAR;
snd_mbf (caller, sizeof (res), &res);
return (E_PAR);
}
set_curpos (packet->param[0], packet->param[1]);
res.body.ctl_res.dd = packet->dd;
res.body.ctl_res.errcd = E_OK;
res.body.ctl_res.errinfo = E_OK;
snd_mbf (caller, sizeof (res), &res);
return (E_OK);
default:
res.body.ctl_res.dd = packet->dd;
res.body.ctl_res.errcd = E_NOSPT;
res.body.ctl_res.errinfo = E_NOSPT;
snd_mbf (caller, sizeof (res), &res);
return (E_NOSPT);
}
}
void
task3(intptr_t exinf)
{
ER_UINT ercd;
check_point(7);
ercd = snd_mbf(MBF1, string2, 26);
check_ercd(ercd, E_OK);
check_point(12);
ercd = wup_tsk(TASK1);
check_ercd(ercd, E_OK);
check_point(14);
ercd = snd_mbf(MBF1, string3, 10);
check_ercd(ercd, E_OK);
check_point(18);
ercd = snd_mbf(MBF1, string2, 26);
check_ercd(ercd, E_OK);
check_point(20);
check_assert(strncmp(buf1, string2, 26) == 0);
ercd = rcv_mbf(MBF1, buf1);
check_ercd(ercd, 26);
check_assert(strncmp(buf1, string1, 26) == 0);
ercd = chg_pri(TASK2, TPRI_INI);
check_ercd(ercd, E_OK);
check_point(21);
ercd = snd_mbf(MBF1, string1, 26);
check_ercd(ercd, E_OK);
check_point(0);
}
static W
read_device2 (ID device, W offset, UW dd, W size, void *buf)
{
DDEV_REQ req; /* 要求パケット */
DDEV_RES res; /* 返答パケット */
ER error;
W rsize;
#ifdef notdef
W i;
#endif
/* printf ("*** READ *** %d, offset = %d, size = %d\n", device, offset, size); */
req.header.mbfid = dev_recv;
req.header.msgtyp = DEV_REA;
req.body.rea_req.dd = dd;
req.body.rea_req.start = offset;
req.body.rea_req.size = size;
error = snd_mbf (device, sizeof (req), &req);
if (error != E_OK)
{
/* printf ("cannot send packet. %d\n", error); */
return (error);
}
/* printf ("kernel: snd_mbf\n"); /* */
rsize = sizeof (res);
rcv_mbf ((UB *)&res, (INT *)&rsize, dev_recv);
/* printf ("read_device2: rcv_mbf\n"); /* */
/* printf ("res.dd = %d\n", res.body.rea_res.dd); */
/* printf ("res.error = %d\n", res.body.rea_res.errcd); */
/* printf ("res.errinfo = %d\n", res.body.rea_res.errinfo); */
if (res.body.rea_res.a_size > 0)
{
/* printf ("res.a_size = 0x%x\n", res.body.rea_res.a_size); */
bcopy ((B*)res.body.rea_res.dt, buf, size);
}
#ifdef notdef
for (i = 0; i < 8; i++)
{
printf ("0x%x, ", res.body.rea_res.dt[i]);
}
#endif
return (E_OK);
}
/************************************************************************
* write_console
*
* 引数： caller
* packet
*
* 返値：
*
* 処理： カレントポインタの位置に文字列を表示する。
* このとき、エスケープシーケンスによる処理も行う。
*
*/
W
write_console(ID caller, DDEV_WRI_REQ *packet)
{
DDEV_RES res;
int i;
ER error;
error = E_OK;
for (i = 0; i < (packet->size); i++)
{
error = write_char (packet->dt[i]);
if (error != E_OK)
break;
}
res.body.wri_res.dd = packet->dd;
res.body.wri_res.errcd = error;
res.body.wri_res.errinfo = error;
res.body.wri_res.a_size = i;
snd_mbf (caller, sizeof (res), &res);
return (error);
}
/*************************************************************************
* read_keyboard ---
*
* 引数： caller
* packet
*
* 返値： E_OK を返す。
*
* 処理： メッセージの送り手に読み込んだ文字列を返す。
*
*/
W
read_keyboard (ID caller, DDEV_REA_REQ *packet)
{
DDEV_RES res;
W i;
res.body.rea_res.dd = packet->dd;
for (i = 0; i < packet->size; i++)
{
res.body.rea_res.dt[i] = read_key (driver_mode);
}
res.body.rea_res.a_size = i;
res.body.rea_res.errcd = E_OK;
res.body.rea_res.errinfo = E_OK;
#if 0
dbg_printf("KEYBOARD: send to caller\n");
#endif
snd_mbf (caller, sizeof (res), &res);
return (E_OK);
}
W send_switch_msg()
{
DDEV_REQ req;
DDEV_RES res;
W rsize;
W error;
if (wconsole == 0) {
if (find_port (WCONSOLE_DRIVER, &wconsole) != E_PORT_OK)
return(E_DEV);
}
if (local_recv == 0) {
local_recv = get_port (sizeof (DDEV_RES), sizeof (DDEV_RES));
if (local_recv <= 0) return(E_NOMEM);
}
req.header.mbfid = local_recv;
req.header.msgtyp = DEV_CTL;
req.body.ctl_req.cmd = WC_CHGFCS;
req.body.ctl_req.len = 0;
#ifdef notdef
dbg_printf("KEYBOARD: send to wconsole\n");
#endif
error = snd_mbf (wconsole, sizeof (req), &req);
if (error != E_OK) {
dbg_printf("KEYBOARD: can't send to wconsole %d\n", error);
return (error);
}
rsize = sizeof (res);
#ifdef notdef
dbg_printf("KEYBOARD: wait from wconsole\n");
#endif
error = rcv_mbf (&res, (INT *)&rsize, local_recv);
#ifdef notdef
dbg_printf("KEYBOARD: recv from wconsole\n");
#endif
if (res.body.ctl_res.errcd != E_OK) {
return (res.body.ctl_res.errcd);
}
}
/* relay_keyboard()
*/
W relay_keyboard (ID caller, DDEV_RLY_REQ *packet)
{
DDEV_REQ req;
W i;
req.header.mbfid = local_recv;
req.header.msgtyp = DEV_RLY;
req.body.rly_req.dd = packet->dd;
#ifdef notdef
dbg_printf("KEYBOARD: read %d\n", packet->size);
#endif
for (i = 0; i < packet->size; i++)
{
req.body.rly_req.dt[i] = read_key (driver_mode);
}
req.body.rly_req.size = i;
#ifdef notdef
dbg_printf("KEYBORAD: send relay to wconsole\n");
#endif
snd_mbf (caller, sizeof (req), &req);
return (E_OK);
}
void
task2(intptr_t exinf)
{
ER_UINT ercd;
check_point(2);
ercd = snd_mbf(MBF1, string1, 26);
check_ercd(ercd, E_OK);
check_point(9);
check_assert(strncmp(buf1, string1, 26) == 0);
ercd = rcv_mbf(MBF1, buf1);
check_ercd(ercd, 26);
check_assert(strncmp(buf1, string2, 26) == 0);
check_point(10);
ercd = snd_mbf(MBF1, string3, 10);
check_ercd(ercd, E_OK);
ercd = rcv_mbf(MBF1, buf1);
check_ercd(ercd, 10);
check_assert(strncmp(buf1, string3, 10) == 0);
check_point(11);
ercd = snd_mbf(MBF1, string1, 26);
check_ercd(ercd, E_OK);
check_point(16);
check_assert(strncmp(buf1, string1, 26) == 0);
ercd = rcv_mbf(MBF1, buf1);
check_ercd(ercd, 10);
check_assert(strncmp(buf1, string3, 10) == 0);
check_point(17);
ercd = snd_mbf(MBF1, string1, 26);
check_ercd(ercd, E_OK);
check_point(22);
ercd = snd_mbf(MBF1, string2, 10);
check_ercd(ercd, E_OK);
check_point(25);
ercd = rcv_mbf(MBF1, buf1);
check_ercd(ercd, 10);
check_assert(strncmp(buf1, string2, 10) == 0);
ercd = chg_pri(TASK3, TPRI_INI);
check_ercd(ercd, E_OK);
check_point(26);
ercd = snd_mbf(MBF1, string3, 10);
check_ercd(ercd, E_OK);
check_point(28);
ercd = rcv_mbf(MBF1, buf1);
check_ercd(ercd, 10);
check_assert(strncmp(buf1, string3, 10) == 0);
ercd = chg_pri(TASK3, TPRI_INI);
check_ercd(ercd, E_OK);
check_point(29);
ercd = snd_mbf(MBF1, string1, 26);
check_ercd(ercd, E_OK);
check_point(31);
check_assert(strncmp(buf1, string1, 26) == 0);
ercd = chg_pri(TSK_SELF, TPRI_INI);
check_ercd(ercd, E_OK);
check_point(32);
ercd = snd_mbf(MBF1, string2, 10);
check_ercd(ercd, E_OK);
check_point(35);
ercd = rcv_mbf(MBF1, buf1);
check_ercd(ercd, 10);
check_assert(strncmp(buf1, string2, 10) == 0);
ercd = chg_pri(TSK_SELF, TPRI_INI);
check_ercd(ercd, E_OK);
check_point(36);
ercd = snd_mbf(MBF1, string3, 10);
check_ercd(ercd, E_OK);
check_point(38);
ercd = rcv_mbf(MBF1, buf1);
check_ercd(ercd, 10);
check_assert(strncmp(buf1, string3, 10) == 0);
ercd = rcv_mbf(MBF1, buf1);
check_ercd(ercd, 26);
check_assert(strncmp(buf1, string1, 26) == 0);
check_finish(39);
check_point(0);
}
/*
* ポートマネージャにメッセージバッファ情報を登録する。
* この関数の中で一時的に受信用のメッセージポートを作成する。
*
*/
PORT_MANAGER_ERROR
regist_port (PORT_NAME *name, ID port)
{
struct recv_port_message_t recv_msg;
struct port_manager_msg_t send_msg;
ID recv_port;
W rsize;
/*
* ポートマネージャからの返答受けつけ用のメッセージバッファ作成。
*/
recv_port = get_port (sizeof (recv_msg), sizeof (recv_msg));
if (recv_port == 0)
{
#ifdef DEBUG
dbg_printf ("regist_port: cannot get port.\n");
#endif /* DEBUG */
return (E_PORT_SYSTEM);
}
/*
* ポートマネージャへ送る要求メッセージを作成。
*/
send_msg.hdr.type = REGIST_PORT;
send_msg.hdr.size = sizeof (send_msg);
send_msg.hdr.rport = recv_port;
strcpy (&(send_msg.body.regist.name), name);
send_msg.body.regist.port = port;
#ifdef DEBUG
dbg_printf ("regist_port: name = <%s>\n", &(send_msg.body.regist.name));
#endif /* DEBUG */
/*
* ポートマネージャに対して登録要求メッセージを送信する。
*/
if (snd_mbf (PORT_MANAGER_PORT, sizeof (send_msg), &send_msg) != E_OK)
{
del_mbf (recv_port);
return (E_PORT_SYSTEM);
}
#ifdef DEBUG
dbg_printf ("port_manager:snd_msg: ok.\n");
#endif /* DEBUG */
/*
* ポートマネージャからの返答メッセージの受けつけ
*/
if (rcv_mbf (&recv_msg, &rsize, recv_port) != E_OK)
{
del_mbf (recv_port);
return (E_PORT_SYSTEM);
}
#ifdef DEBUG
dbg_printf ("port_manager:rcv_msg: ok.\n");
#endif /* DEBUG */
/*
* 使いおわった返答受信用のメッセージバッファを削除する。
*/
del_mbf (recv_port);
#ifdef DEBUG
dbg_printf ("port_manager: errno = %d\n", recv_msg.error);
#endif /* DEBUG */
return (recv_msg.error);
}
/* sfs_read_device - デバイスからデータを読み込む
*
*/
W
sfs_read_device (ID device, B *buf, W start, W length, W *rlength)
{
DDEV_REQ req; /* 要求パケット */
DDEV_RES res; /* 返答パケット */
ID res_port;
W errno;
W rest_length;
W rsize;
ID send_port;
UW dd;
errno = get_device_info (device, &send_port, &dd);
if (errno)
{
return (errno);
}
res_port = get_port (sizeof (res), sizeof (res));
if (res_port <= 0)
{
return (EP_NOMEM);
}
#ifdef notdef
printk ("sfs_read_device: start = %d, size = %d\n", start, length);
#endif /* FMDEBUG */
*rlength = 0;
for (rest_length = length; rest_length > 0; rest_length -= BLOCK_SIZE)
{
req.header.mbfid = res_port;
req.header.msgtyp = DEV_REA;
req.body.rea_req.dd = dd;
req.body.rea_req.start = start + (length - rest_length);
req.body.rea_req.size
= (BLOCK_SIZE > rest_length) ? rest_length : BLOCK_SIZE;
errno = snd_mbf (send_port, sizeof (req), &req);
if (errno != E_OK)
{
dbg_printf ("cannot send packet. %d\n", errno); /* */
del_mbf (res_port);
return (errno);
}
rsize = sizeof (res);
errno = rcv_mbf ((UB *)&res, (VP)&rsize, res_port);
if (errno != E_OK)
{
dbg_printf ("cannot send packet. %d\n", errno); /* */
del_mbf (res_port);
return (errno);
}
else if (res.body.rea_res.errinfo != E_OK) {
del_mbf (res_port);
return (res.body.rea_res.errinfo);
}
bcopy (res.body.rea_res.dt, &buf[length - rest_length],
res.body.rea_res.a_size);
*rlength += res.body.rea_res.a_size;
}
del_mbf (res_port);
return (E_OK);
}
void
task3(intptr_t exinf)
{
ER_UINT ercd;
check_point(3);
ercd = snd_mbf(MBF1, string2, 26);
check_ercd(ercd, E_OK);
check_point(7);
ercd = snd_mbf(MBF1, string3, 10);
check_ercd(ercd, E_OK);
check_point(9);
ercd = rcv_mbf(MBF1, buf1);
check_ercd(ercd, 10);
check_assert(strncmp(buf1, string3, 10) == 0);
check_point(10);
ercd = act_tsk(TASK2);
check_ercd(ercd, E_OK);
check_point(12);
ercd = wup_tsk(TASK1);
check_ercd(ercd, E_OK);
check_point(14);
ercd = ter_tsk(TASK2);
check_ercd(ercd, E_OK);
check_point(17);
ercd = snd_mbf(MBF1, string2, 26);
check_ercd(ercd, E_OK);
check_point(22);
ercd = snd_mbf(MBF1, string3, 10);
check_ercd(ercd, E_OK);
check_point(25);
ercd = rcv_mbf(MBF1, buf1);
check_ercd(ercd, 10);
check_assert(strncmp(buf1, string3, 10) == 0);
check_point(26);
ercd = wup_tsk(TASK2);
check_ercd(ercd, E_OK);
check_point(28);
ercd = wup_tsk(TASK1);
check_ercd(ercd, E_OK);
check_point(30);
ercd = rel_wai(TASK2);
check_ercd(ercd, E_OK);
check_point(33);
ercd = snd_mbf(MBF1, string2, 26);
check_ercd(ercd, E_OK);
check_point(40);
ercd = snd_mbf(MBF1, string3, 10);
check_ercd(ercd, E_OK);
check_point(44);
ercd = rcv_mbf(MBF1, buf1);
check_ercd(ercd, 10);
check_assert(strncmp(buf1, string3, 10) == 0);
check_point(45);
ercd = wup_tsk(TASK2);
check_ercd(ercd, E_OK);
check_point(47);
ercd = wup_tsk(TASK1);
check_ercd(ercd, E_OK);
check_point(49);
ercd = sta_alm(ALM1, 1000U);
check_ercd(ercd, E_OK);
ercd = slp_tsk();
check_ercd(ercd, E_OK);
check_point(53);
ercd = snd_mbf(MBF1, string2, 26);
check_ercd(ercd, E_OK);
check_point(57);
ercd = snd_mbf(MBF1, string3, 10);
check_ercd(ercd, E_OK);
check_point(59);
ercd = rcv_mbf(MBF1, buf1);
check_ercd(ercd, 10);
check_assert(strncmp(buf1, string3, 10) == 0);
check_point(60);
ercd = wup_tsk(TASK2);
check_ercd(ercd, E_OK);
check_point(62);
ercd = wup_tsk(TASK1);
check_ercd(ercd, E_OK);
check_point(64);
ercd = slp_tsk();
check_ercd(ercd, E_OK);
check_point(0);
}
void
task2(intptr_t exinf)
{
ER_UINT ercd;
switch (++task2_count) {
case 1:
check_point(2);
ercd = snd_mbf(MBF1, string1, 26);
check_ercd(ercd, E_OK);
check_point(0);
case 2:
check_point(6);
ercd = snd_mbf(MBF1, string1, 26);
check_ercd(ercd, E_OK);
check_point(0);
case 3:
check_point(11);
ercd = snd_mbf(MBF1, string1, 26);
check_ercd(ercd, E_OK);
check_point(0);
case 4:
check_point(16);
ercd = snd_mbf(MBF1, string1, 26);
check_ercd(ercd, E_RLWAI);
check_point(19);
ercd = slp_tsk();
check_ercd(ercd, E_OK);
check_point(21);
ercd = snd_mbf(MBF1, string1, 26);
check_ercd(ercd, E_RLWAI);
check_point(24);
ercd = slp_tsk();
check_ercd(ercd, E_OK);
check_point(27);
ercd = snd_mbf(MBF1, string1, 26);
check_ercd(ercd, E_RLWAI);
check_point(32);
ercd = snd_mbf(MBF1, string1, 26);
check_ercd(ercd, E_RLWAI);
check_point(37);
ercd = slp_tsk();
check_ercd(ercd, E_OK);
check_point(39);
ercd = snd_mbf(MBF1, string1, 26);
check_ercd(ercd, E_RLWAI);
check_point(43);
ercd = slp_tsk();
check_ercd(ercd, E_OK);
check_point(46);
ercd = snd_mbf(MBF1, string1, 26);
check_ercd(ercd, E_RLWAI);
check_point(52);
ercd = tsnd_mbf(MBF1, string1, 26, 1000U);
check_ercd(ercd, E_TMOUT);
check_point(54);
ercd = tslp_tsk(1000U);
check_ercd(ercd, E_TMOUT);
check_point(55);
ercd = rcv_mbf(MBF1, buf1);
check_ercd(ercd, 26);
check_assert(strncmp(buf1, string2, 26) == 0);
check_point(56);
ercd = tsnd_mbf(MBF1, string1, 26, 1000U);
check_ercd(ercd, E_TMOUT);
check_point(58);
ercd = slp_tsk();
check_ercd(ercd, E_OK);
check_point(61);
ercd = tsnd_mbf(MBF1, string1, 26, 1000U);
check_ercd(ercd, E_TMOUT);
check_finish(66);
check_point(0);
default:
check_point(0);
}
check_point(0);
}
void
task1(intptr_t exinf)
{
ER_UINT ercd;
test_start(__FILE__);
set_bit_func(bit_kernel);
check_point(1);
ercd = act_tsk(TASK2);
check_ercd(ercd, E_OK);
ercd = act_tsk(TASK3);
check_ercd(ercd, E_OK);
ercd = tslp_tsk(1000U);
check_ercd(ercd, E_TMOUT);
check_point(4);
ercd = ter_tsk(TASK2);
check_ercd(ercd, E_OK);
ercd = tslp_tsk(1000U);
check_ercd(ercd, E_TMOUT);
check_point(5);
ercd = rcv_mbf(MBF1, buf1);
check_ercd(ercd, 26);
check_assert(strncmp(buf1, string2, 26) == 0);
ercd = act_tsk(TASK2);
check_ercd(ercd, E_OK);
ercd = tslp_tsk(1000U);
check_ercd(ercd, E_TMOUT);
check_point(8);
ercd = ter_tsk(TASK2);
check_ercd(ercd, E_OK);
ercd = slp_tsk();
check_ercd(ercd, E_OK);
check_point(13);
ercd = snd_mbf(MBF1, string3, 10);
check_ercd(ercd, E_OK);
check_point(15);
ercd = rcv_mbf(MBF1, buf1);
check_ercd(ercd, 10);
check_assert(strncmp(buf1, string3, 10) == 0);
ercd = act_tsk(TASK2);
check_ercd(ercd, E_OK);
ercd = tslp_tsk(1000U);
check_ercd(ercd, E_TMOUT);
check_point(18);
ercd = rel_wai(TASK2);
check_ercd(ercd, E_OK);
ercd = tslp_tsk(1000U);
check_ercd(ercd, E_TMOUT);
check_point(20);
ercd = rcv_mbf(MBF1, buf1);
check_ercd(ercd, 26);
check_assert(strncmp(buf1, string2, 26) == 0);
ercd = wup_tsk(TASK2);
check_ercd(ercd, E_OK);
ercd = tslp_tsk(1000U);
check_ercd(ercd, E_TMOUT);
check_point(23);
ercd = rel_wai(TASK2);
check_ercd(ercd, E_OK);
ercd = slp_tsk();
check_ercd(ercd, E_OK);
check_point(29);
ercd = snd_mbf(MBF1, string3, 10);
check_ercd(ercd, E_OK);
check_point(31);
ercd = rcv_mbf(MBF1, buf1);
check_ercd(ercd, 10);
check_assert(strncmp(buf1, string3, 10) == 0);
ercd = tslp_tsk(1000U);
check_ercd(ercd, E_TMOUT);
check_point(34);
ercd = sta_alm(ALM1, 1000U);
check_ercd(ercd, E_OK);
ercd = slp_tsk();
check_ercd(ercd, E_OK);
check_point(36);
ercd = tslp_tsk(1000U);
check_ercd(ercd, E_TMOUT);
check_point(38);
ercd = rcv_mbf(MBF1, buf1);
check_ercd(ercd, 26);
check_assert(strncmp(buf1, string2, 26) == 0);
ercd = wup_tsk(TASK2);
check_ercd(ercd, E_OK);
ercd = tslp_tsk(1000U);
check_ercd(ercd, E_TMOUT);
check_point(41);
ercd = sta_alm(ALM1, 1000U);
check_ercd(ercd, E_OK);
ercd = slp_tsk();
check_ercd(ercd, E_OK);
check_point(48);
ercd = snd_mbf(MBF1, string3, 10);
check_ercd(ercd, E_OK);
check_point(51);
ercd = rcv_mbf(MBF1, buf1);
check_ercd(ercd, 10);
check_assert(strncmp(buf1, string3, 10) == 0);
ercd = wup_tsk(TASK3);
check_ercd(ercd, E_OK);
ercd = slp_tsk();
check_ercd(ercd, E_OK);
check_point(63);
ercd = snd_mbf(MBF1, string3, 10);
check_ercd(ercd, E_OK);
check_point(65);
ercd = rcv_mbf(MBF1, buf1);
check_ercd(ercd, 10);
check_assert(strncmp(buf1, string3, 10) == 0);
ercd = slp_tsk();
check_ercd(ercd, E_OK);
check_point(0);
}
W
ether (W ac, B **av)
{
DDEV_REQ req; /* 要求パケット */
DDEV_RES res; /* 返答パケット */
W rsize;
ER error;
ID recv;
ID console;
if (ac < 1)
{
printf ("usage: ether command\n");
printf (" reset\n");
printf (" probe\n");
printf (" init\n");
printf (" macaddr\n");
printf (" arp\n");
printf (" \n");
return (0);
}
recv = get_port (sizeof (DDEV_RES), sizeof (DDEV_RES));
if (recv <= 0)
{
return (E_SYS);
}
if (find_port (NE2000_DRIVER, &console) != E_PORT_OK)
{
return (E_SYS);
}
if (strcmp (av[1], "reset") == 0)
{
/* Ether adaptor reset */
req.header.mbfid = recv;
req.header.msgtyp = DEV_CTL;
req.body.ctl_req.dd = 0;
req.body.ctl_req.cmd = NE2000_RESET;
req.body.ctl_req.len = 0;
error = snd_mbf (console, sizeof (req), &req);
if (error != E_OK)
{
return (error);
}
rsize = sizeof (res);
error = rcv_mbf (&res, (INT *)&rsize, recv);
if (res.body.ctl_res.errcd != E_OK)
{
del_mbf (recv);
return (res.body.ctl_res.errcd);
}
}
else if (strcmp (av[1], "probe") == 0)
{
/* Ether adaptor probe */
req.header.mbfid = recv;
req.header.msgtyp = DEV_CTL;
req.body.ctl_req.dd = 0;
req.body.ctl_req.cmd = NE2000_PROBE;
req.body.ctl_req.len = 0;
error = snd_mbf (console, sizeof (req), &req);
if (error != E_OK)
{
return (error);
}
rsize = sizeof (res);
error = rcv_mbf (&res, (INT *)&rsize, recv);
if (res.body.ctl_res.errcd != E_OK)
{
del_mbf (recv);
return (res.body.ctl_res.errcd);
}
}
else if (strcmp (av[1], "init") == 0)
{
/* Ether adaptor initialize */
}
else if (strcmp (av[1], "macaddr") == 0)
{
W i;
req.header.mbfid = recv;
req.header.msgtyp = DEV_CTL;
req.body.ctl_req.dd = 0;
req.body.ctl_req.cmd = NE2000_GETMAC;
req.body.ctl_req.len = 0;
error = snd_mbf (console, sizeof (req), &req);
if (error != E_OK)
{
del_mbf (recv);
return (error);
}
rsize = sizeof (res);
error = rcv_mbf (&res, (INT *)&rsize, recv);
if (res.body.ctl_res.errcd != E_OK)
{
del_mbf (recv);
return (res.body.ctl_res.errcd);
}
printf ("mac address: ");
for (i = 0; i < MACADDRLEN; i++)
{
printf ("%x ", res.body.ctl_res.res[i]);
my_macaddr[i] = res.body.ctl_res.res[i];
}
printf ("\n");
}
else if (strcmp (av[1], "arp") == 0)
{
#define MYADDR 0xC0A80003
#define htons(s) (UH)(((UH)s << 8) | ((UH)s >> 8))
struct arp_buf
{
UB dest_ether[6];
UB src_ether[6];
UH ether_type;
UH hardware;
UH protocol;
UB hardware_length;
UB protocol_length;
UH opcode;
UB sender_macaddr[6];
UB sender_ip[4];
UB target_macaddr[6];
UB target_ip[4];
} arp;
W i;
for (i = 0; i < 6; i++)
{
arp.src_ether[i] = my_macaddr[i];
arp.dest_ether[i] = 0xff;
arp.sender_macaddr[i] = my_macaddr[i];
arp.target_macaddr[i] = 0xff;
}
arp.ether_type = 0x0608;
arp.sender_ip[0] = 192;
arp.sender_ip[1] = 168;
arp.sender_ip[2] = 0;
arp.sender_ip[3] = 3;
for (i = 0; i < 4; i++)
{
arp.target_ip[i] = 0xff;
}
arp.hardware = htons (1);
arp.protocol = htons (0x0800);
arp.hardware_length = 0x06;
arp.protocol_length = 0x04;
arp.opcode = htons (1);
req.header.mbfid = recv;
req.header.msgtyp = DEV_WRI;
req.body.wri_req.dd = 0;
req.body.wri_req.start = &arp;
req.body.wri_req.size = sizeof (arp);
get_tid (&req.header.tskid);
printf ("send ether\n");
error = snd_mbf (console, sizeof (req), &req);
if (error != E_OK)
{
del_mbf (recv);
return (error);
}
rsize = sizeof (res);
error = rcv_mbf (&res, (INT *)&rsize, recv);
if (res.body.ctl_res.errcd != E_OK)
{
del_mbf (recv);
return (res.body.ctl_res.errcd);
}
}
else
{
printf ("Unknown command: %s\n", av[1]);
del_mbf (recv);
return (1);
}
del_mbf (recv);
return (0);
}
