source: azure_iot_hub/trunk/asp3_dcre/tinet/netdev/if_rx62n/if_rx62n.c@ 388

/*
 *  TINET (TCP/IP Protocol Stack)
 * 
 *  Copyright (C) 2001-2009 by Dep. of Computer Science and Engineering
 *                   Tomakomai National College of Technology, JAPAN
 *  Copyright (C) 2014-2017 by Cores Co., Ltd. Japan
 * 
 *  上記著作権者
は，以下の(1)～(4)ã®æ¡ä»¶ã‚’æº€ãŸã™å ´åˆã«é™ã‚Šï¼Œæœ¬ã‚½ãƒ•ãƒˆã‚¦ã‚§
 *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
 *  変・再é…
å¸ƒï¼ˆä»¥ä¸‹ï¼Œåˆ©ç”¨ã¨å‘¼ã¶ï¼‰ã™ã‚‹ã“とを無償で許諾する．
 *  (1) æœ¬ã‚½ãƒ•ãƒˆã‚¦ã‚§ã‚¢ã‚’ã‚½ãƒ¼ã‚¹ã‚³ãƒ¼ãƒ‰ã®å½¢ã§åˆ©ç”¨ã™ã‚‹å ´åˆã«ã¯ï¼Œä¸Šè¨˜ã®è‘—ä½œ
 *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
 *      スコード中に含まれていること．
 *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
 *      用できる形で再é…
å¸ƒã™ã‚‹å ´åˆã«ã¯ï¼Œå†é…
å¸ƒã«ä¼´ã†ãƒ‰ã‚­ãƒ¥ãƒ¡ãƒ³ãƒˆï¼ˆåˆ©ç”¨
 *      者
マニュアルなど）に，上記の著作権表示，この利用条件および下記
 *      の無保証規定を掲載すること．
 *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
 *      用できない形で再é…
å¸ƒã™ã‚‹å ´åˆã«ã¯ï¼Œæ¬¡ã®ã„ずれかの条件を満たすこ
 *      と．
 *    (a) 再é…
å¸ƒã«ä¼´ã†ãƒ‰ã‚­ãƒ¥ãƒ¡ãƒ³ãƒˆï¼ˆåˆ©ç”¨è€…
マニュアルなど）に，上記の著
 *        作権表示，この利用条件および下記の無保証規定を掲載すること．
 *    (b) 再é…
å¸ƒã®å½¢æ…
‹ã‚’，別に定める方法によって，TOPPERSプロジェクトに
 *        å ±å‘Šã™ã‚‹ã“ã¨ï¼Ž
 *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
 *      害からも，上記著作権者
およびTOPPERSプロジェクトをå…
è²¬ã™ã‚‹ã“と．
 *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
 *      由に基づく請求からも，上記著作権者
およびTOPPERSプロジェクトを
 *      å…
è²¬ã™ã‚‹ã“と．
 * 
 *  本ソフトウェアは，無保証で提供されているものである．上記著作権者
お
 *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
 *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
 *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
 *  ã®è²¬ä»»ã‚’è² ã‚ãªã„ï¼Ž
 * 
 *  @(#) $Id: if_rx62n.c 388 2019-05-22 11:25:18Z coas-nagasima $
 */

/*
 * Copyright (c) 1995, David Greenman
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice unmodified, this list of conditions, and the following
 *    disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 * 
 * $FreeBSD: src/sys/i386/isa/if_ed.c,v 1.148.2.4 1999/09/25 13:08:18 nyan Exp $
 */

#ifdef TARGET_KERNEL_ASP

#define CAST(type, val)         ((type)(val))

#include <kernel.h>
#include <sil.h>
#include <t_syslog.h>
#include "kernel_cfg.h"
#include "kernel/kernel_impl.h"

#endif  /* of #ifdef TARGET_KERNEL_ASP */

#ifdef TARGET_KERNEL_JSP

#include <s_services.h>
#include <t_services.h>
#include "kernel_id.h"

#endif  /* of #ifdef TARGET_KERNEL_JSP */

#include <tinet_defs.h>
#include <tinet_config.h>

#include <net/if.h>
#include <net/ethernet.h>
#include <net/if_arp.h>
#include <net/net.h>
#include <net/net_timer.h>
#include <net/net_count.h>
#include <net/net_buf.h>

#include "if_rx62nreg.h"
#include <string.h>
#include "ether_phy.h"

#ifdef _MSC_VER
#include <stdlib.h>
#endif

#ifndef TMO_IF_RX62N_GET_NET_BUF
#define TMO_IF_RX62N_GET_NET_BUF                ULONG_C(1000000)        /* [us] */
#endif

void mbed_mac_address(char *mac);

/*
 *  ネットワークインタフェースに依存するソフトウェア情
å ± 
 */

typedef struct t_rx62n_softc {
        PHY_STATE_T state;
        T_RX62N_TX_DESC *tx_write;
        T_RX62N_RX_DESC *rx_read;
        bool_t link_pre;
        bool_t link_now;
        bool_t over_flow;
} T_RX62N_SOFTC;

/*
 *  ネットワークインタフェースのソフトウェア情
å ±
 */

/* ネットワークインタフェースに依存するソフトウェア情
å ± */

static T_RX62N_SOFTC rx62n_softc;

typedef struct t_rx62n_buf {
        uint8_t rx_buff[NUM_IF_RX62N_RXBUF][32 * (((int)&((T_NET_BUF *)0)->buf + IF_RX62N_BUF_PAGE_SIZE + 31) / 32)];
        uint8_t tx_buff[NUM_IF_RX62N_TXBUF][32 * ((IF_RX62N_BUF_PAGE_SIZE + 31) / 32)];
        T_RX62N_RX_DESC rx_desc[NUM_IF_RX62N_RXBUF];
        T_RX62N_TX_DESC tx_desc[NUM_IF_RX62N_TXBUF];
} T_RX62N_BUF;

#if defined(__RX)
#pragma section ETH_MEMORY
#define __attribute__(x)
#endif
T_RX62N_BUF __attribute__((section("ETH_MEMORY"),aligned(16))) rx62n_buf;
#if defined(__RX)
#pragma section
#endif

/* ネットワークインタフェースに依存しないソフトウェア情
å ± */

T_IF_SOFTC if_softc = {
        {0,},                                           /* ネットワークインタフェースのアドレス       */
        0,                                                      /* 送信タイムアウト                     */
        &rx62n_softc,                           /* ディバイス依存のソフトウェア情
å ±     */
        SEM_IF_RX62N_SBUF_READY,        /* 送信セマフォ                   */
        SEM_IF_RX62N_RBUF_READY,        /* 受信セマフォ                   */

#ifdef SUPPORT_INET6

        IF_MADDR_INIT,                          /* マルチキャストアドレスリスト   */

#endif  /* of #ifdef SUPPORT_INET6 */
};

/*
 *  局所変数
 */

static void rx62n_stop (T_RX62N_SOFTC *sc);
static void rx62n_init_sub (T_IF_SOFTC *ic);
static void rx62n_set_ecmr (T_IF_SOFTC *ic, PHY_MODE_T mode);

#ifdef SUPPORT_INET6

static uint32_t ds_crc (uint8_t *addr);
static void ds_getmcaf (T_IF_SOFTC *ic, uint32_t *mcaf);

/*
 *  ds_crc -- イーサネットアドレスの CRC を計算する。
 */

#define POLYNOMIAL      0x04c11db6

static uint32_t
ds_crc (uint8_t *addr)
{
        uint32_t        crc = ULONG_C(0xffffffff);
        int_t           carry, len, bit;
        uint8_t         byte;

        for (len = ETHER_ADDR_LEN; len -- > 0; ) {
                byte = *addr ++;
                for (bit = 8; bit -- > 0; ) {
                        carry   = ((crc & ULONG_C(0x80000000)) ? 1 : 0) ^ (byte & UINT_C(0x01));
                        crc   <<= 1;
                        byte   >>= 1;
                        if (carry)
                                crc = (crc ^ POLYNOMIAL) | carry;
                }
        }
        return crc;
}

#undef POLYNOMIAL

/*
 *  ds_getmcaf -- マルチキャストアドレスのリストからマルチキャストアドレス
 *                フィルタを計算する。
 */

static void
ds_getmcaf (T_IF_SOFTC *ic, uint32_t *mcaf)
{
        uint32_t        count, index;
        uint8_t         *af = (uint8_t*)mcaf;

        mcaf[0] = mcaf[1] = 0;

        for (count = MAX_IF_MADDR_CNT; count -- > 0; ) {
                index = ds_crc(ic->maddrs[count].lladdr) >> 26;
                af[index >> 3] |= 1 << (index & 7);
        }
}

/*
 * rx62n_setrcr -- 受信構成レジスタ (RCR) を設定する。
 */

static void
rx62n_setrcr (T_IF_SOFTC *ic)
{
        T_RX62N_SOFTC   *sc = ic->sc;
}

/*
 * rx62n_addmulti -- ãƒžãƒ«ãƒã‚­ãƒ£ã‚¹ãƒˆã‚¢ãƒ‰ãƒ¬ã‚¹ã‚’è¿½åŠ ã™ã‚‹ã€‚
 */

ER
rx62n_addmulti (T_IF_SOFTC *ic)
{
        rx62n_setrcr(ic);
        return E_OK;
}

#endif  /* of #ifdef SUPPORT_INET6 */

/*
 *  rx62n_stop -- ネットワークインタフェースを停止する。
 * 
 *    注意: NIC 割り込み禁止状æ…
‹ã§å‘¼ã³å‡ºã™ã“と。
 */

static void
rx62n_stop (T_RX62N_SOFTC *sc)
{
        /* 動作モードクリア */
        sil_wrw_mem(ETHERC_ECMR, 0x00000000);
        /* リンク変化割り込み無効 */
        sil_wrw_mem(ETHERC_ECSIPR, 0x00000000);
}

/*
 *  rx62n_init_sub -- ネットワークインタフェースの初期化
 * 
 *    注意: NIC 割り込み禁止状æ…
‹ã§å‘¼ã³å‡ºã™ã“と。
 */

static void
rx62n_init_sub (T_IF_SOFTC *ic)
{
        T_RX62N_SOFTC *sc = ic->sc;
        uint8_t *mac_addr = ic->ifaddr.lladdr;
        PHY_STATE_T state = PHY_STATE_UNINIT;

        /* MAC部ソフトウエア・リセット */
        sil_wrw_mem(EDMAC_EDMR, sil_rew_mem(EDMAC_EDMR) | EDMAC_EDMR_SWR_BIT);

        dly_tsk(1000);

        sil_wrw_mem(ETHERC_MAHR, ((uint32_t)mac_addr[0] << 24)
                | ((uint32_t)mac_addr[1] << 16) | ((uint32_t)mac_addr[2] << 8 )
                |  (uint32_t)mac_addr[3]);
        sil_wrw_mem(ETHERC_MALR, ((uint32_t)mac_addr[4] << 8 )
                | (uint32_t)mac_addr[5]);

        /* PHYリセット */
        while ((state = phy_reset(state, 0)) != PHY_STATE_RESET);
        sc->state = state;

        /* Clear all ETHERC status BFR, PSRTO, LCHNG, MPD, ICD */
        sil_wrw_mem(ETHERC_ECSR, 0x00000037);

        /* リンク変化割り込み有効 */
        sil_wrw_mem(ETHERC_ECSIPR, sil_rew_mem(ETHERC_ECSIPR) | ETHERC_ECSIPR_LCHNGIP);

        /* Clear all ETHERC and EDMAC status bits */
        sil_wrw_mem(EDMAC_EESR, 0x47FF0F9F);

        /* 送受信割り込み有効 */
        sil_wrw_mem(EDMAC_EESIPR, (EDMAC_EESIPR_TCIP | EDMAC_EESIPR_FRIP | EDMAC_EESIPR_RDEIP | EDMAC_EESIPR_FROFIP));

        /* 受信フレーム長上限（バッファサイズ） */
        sil_wrw_mem(ETHERC_RFLR, IF_RX62N_BUF_PAGE_SIZE);

        /* 96ビット時間（初期値） */
        sil_wrw_mem(ETHERC_IPGR, 0x00000014);

        /* Set little endian mode */
        sil_wrw_mem(EDMAC_EDMR, sil_rew_mem(EDMAC_EDMR) | EDMAC_EDMR_DE_BIT);

        /* Initialize Rx descriptor list address */
        sil_wrw_mem(EDMAC_RDLAR, (uint32_t)rx62n_buf.rx_desc);
        /* Initialize Tx descriptor list address */
        sil_wrw_mem(EDMAC_TDLAR, (uint32_t)rx62n_buf.tx_desc);
        /* Copy-back status is RFE & TFE only */
        sil_wrw_mem(EDMAC_TRSCER, 0x00000000);
        /* Threshold of Tx_FIFO */
        sil_wrw_mem(EDMAC_TFTR, 0x00000000);
        /* Transmit fifo & receive fifo is 2048 bytes */
        sil_wrw_mem(EDMAC_FDR, 0x00000707);
        /* RR in EDRRR is under driver control */
        sil_wrw_mem(EDMAC_RMCR, 0x00000001);

        sc->link_pre = false;
        sc->link_now = false;

#if defined(TARGET_KERNEL_ASP)

        /* ターゲット依存部の割込み初期化 */
        rx62n_inter_init();

#endif  /* of #if defined(TARGET_KERNEL_ASP) */

#if defined(TARGET_KERNEL_JSP) && TKERNEL_PRVER >= 0x1042u      /* JSP-1.4.2 以降 */

        /* ターゲット依存部の割込み初期化 */
        rx62n_inter_init();

#endif  /* of #if defined(TARGET_KERNEL_JSP) && TKERNEL_PRVER >= 0x1042u */
}


/*
 *  rx62n_set_ecmr -- ECMRレジスタの設定
 */

static void
rx62n_set_ecmr (T_IF_SOFTC *ic, PHY_MODE_T mode)
{
        uint32_t ecmr;

        ecmr = ETHERC_ECMR_RE | ETHERC_ECMR_TE/* | ETHERC_ECMR_PRM*/;

        if ((mode & 0x01) != 0)
                ecmr |= ETHERC_ECMR_DM;
        if ((mode & 0x02) != 0)
                ecmr |= ETHERC_ECMR_RTM;

        /* 動作モード設定 */
        sil_wrw_mem(ETHERC_ECMR, ecmr);
}

/*
 * rx62n_reset -- ネットワークインタフェースをリセットする。
 */

void
rx62n_reset (T_IF_SOFTC *ic)
{
#ifdef TARGET_KERNEL_JSP
        IPM     ipm;
#endif

        /* NIC からの割り込みを禁止する。*/
#ifdef TARGET_KERNEL_JSP
        ipm = rx62n_dis_inter();
#endif
#ifdef TARGET_KERNEL_ASP
        syscall(dis_int(INTNO_IF_RX62N_TRX));
#endif
        ether_set_link_down();

        NET_COUNT_ETHER_NIC(net_count_ether_nic[NC_ETHER_NIC_RESETS], 1);
        rx62n_stop(ic->sc);
        rx62n_init_sub(ic);

        if (sil_rew_mem(EDMAC_EDRRR) == 0) {
                sil_wrw_mem(EDMAC_EDRRR, EDMAC_EDRRR_RR);
        }

        /* 送受信を有効 */
        rx62n_set_ecmr(ic, 1);

        /* NIC からの割り込みを許可する。*/
#ifdef TARGET_KERNEL_JSP
        rx62n_ena_inter(ipm);
#endif
#ifdef TARGET_KERNEL_ASP
        syscall(ena_int(INTNO_IF_RX62N_TRX));
#endif
}

/*
 *  get_rx62n_softc -- ネットワークインタフェースのソフトウェア情
å ±ã‚’è¿”ã™ã€‚
 */

T_IF_SOFTC *
rx62n_get_softc (void)
{
        return &if_softc;
}

/*
 * rx62n_watchdog -- ネットワークインタフェースのワッチドッグタイムアウト
 */

void
rx62n_watchdog (T_IF_SOFTC *ic)
{
        rx62n_reset(ic);
}

/*
 * rx62n_probe -- ネットワークインタフェースの検出
 */

void
rx62n_probe (T_IF_SOFTC *ic)
{
        int i;
#if defined(TARGET_KERNEL_ASP)

        /* ターゲット依存部のバスの初期化 */
        rx62n_bus_init();

#endif  /* of #if defined(TARGET_KERNEL_ASP) */
#if defined(TARGET_KERNEL_JSP) && TKERNEL_PRVER >= 0x1042u      /* JSP-1.4.2 以降 */

        /* ターゲット依存部のバスの初期化 */
        rx62n_bus_init();

#endif  /* of #if defined(TARGET_KERNEL_JSP) && TKERNEL_PRVER >= 0x1042u */

        mbed_mac_address(ic->ifaddr.lladdr);
}

/*
 * rx62n_init -- ネットワークインタフェースの初期化
 */

void
rx62n_init (T_IF_SOFTC *ic)
{
#ifdef TARGET_KERNEL_JSP
        IPM     ipm;
#endif
        T_RX62N_SOFTC *sc = ic->sc;
        T_RX62N_TX_DESC *tdsc;
        T_RX62N_RX_DESC *rdsc;
        int i;

        /* NIC からの割り込みを禁止する。*/
#ifdef TARGET_KERNEL_JSP
        ipm = rx62n_dis_inter();
#endif
#ifdef TARGET_KERNEL_ASP
        syscall(dis_int(INTNO_IF_RX62N_TRX));
#endif

        tdsc = (T_RX62N_TX_DESC *)rx62n_buf.tx_desc;
        sc->tx_write = tdsc;
        for ( i=0 ; i < NUM_IF_RX62N_TXBUF ; i++ ) {
                memset(tdsc, 0, sizeof(*tdsc));
                tdsc->tbl = 0;
                tdsc->tba = (uint32_t)&rx62n_buf.tx_buff[i];
                tdsc++;
        }
        tdsc--;
        tdsc->tdle = 1;

        rdsc = (T_RX62N_RX_DESC *)rx62n_buf.rx_desc;
        sc->rx_read = rdsc;
        for ( i=0 ; i < NUM_IF_RX62N_RXBUF ; i++ ) {
                memset(rdsc, 0, sizeof(*rdsc));
                rdsc->rbl = IF_RX62N_BUF_PAGE_SIZE;
                rdsc->rba = (uint32_t)&rx62n_buf.rx_buff[i] + (uint32_t)&((T_NET_BUF *)0)->buf;
                rdsc->rfl = 0;
                rdsc->ract = 1;
                rdsc++;
        }
        rdsc--;
        rdsc->rdle = 1;

        /* rx62n_init 本体を呼び出す。*/
        rx62n_init_sub(ic);

        if (sil_rew_mem(EDMAC_EDRRR) == 0) {
                sil_wrw_mem(EDMAC_EDRRR, EDMAC_EDRRR_RR);
        }

        /* 送受信を有効 */
        rx62n_set_ecmr(ic, 1);

        /* NIC からの割り込みを許可する。*/
#ifdef TARGET_KERNEL_JSP
        rx62n_ena_inter(ipm);
#endif
#ifdef TARGET_KERNEL_ASP
        syscall(ena_int(INTNO_IF_RX62N_TRX));
#endif

        syscall(sta_cyc(CYC_IF_RX62N_LINK));
}


/* 
 * rx62n_link -- リンク状æ…
‹ã®å¤‰åŒ–に対する処理
 */
bool_t
rx62n_link(T_IF_SOFTC *ic)
{
        T_RX62N_SOFTC *sc = ic->sc;
        PHY_MODE_T mode;
        uint8_t phy_addr = 0;

        if(sc->state == PHY_STATE_NEGOTIATED){
                if(!phy_is_link(phy_addr))
                        sc->state = PHY_STATE_RESET;
                return true;
        }

        /* PHYの初期化 */
        sc->state = phy_initialize(sc->state, phy_addr, &mode);
        if(sc->state != PHY_STATE_NEGOTIATED){
                return false;
        }

        /* ECMRレジスタの設定 */
        rx62n_set_ecmr(ic, mode);
        return true;
}

/*
 * rx62n_read -- フレームの読み込み
 */

T_NET_BUF *
rx62n_read (T_IF_SOFTC *ic)
{
        T_RX62N_SOFTC *sc = ic->sc;
        T_RX62N_RX_DESC *desc;
        uint16_t len;
        T_NET_BUF *input = NULL;
        uint16_t align;
        uint8_t *dst;
        ER error;
        PHY_MODE_T mode;

        sc->link_now = rx62n_link(ic);
        if (sc->link_pre != sc->link_now) {
                sc->link_pre = sc->link_now;
                /* リンク状æ…
‹ã«å¤‰åŒ–あり */
                if (sc->link_now) {
                        ether_set_link_up();
                }
                else {
                        ether_set_link_down();
                }
        }

        if (sc->over_flow) {
                sc->over_flow = false;
        }

        desc = sc->rx_read;

        if (desc->ract != 0) {
                return NULL;
        }

        len = desc->rfl;
        /*
         *  +-----------+--------+---------+---------+
         *  | Ehter HDR | IP HDR | TCP HDR | TCP SDU |
         *  +-----------+--------+---------+---------+
         *        14        20        20        n
         *   <----------------- len ---------------->
         *              ^
         *              t_net_buf で 4 オクテット境界にアラインされている。
         *
         *  tcp_input と udp_input では、擬似ヘッダと SDU でチェックサムを
         *  計算するが、n が 4 オクテット境界になるように SDU の後ろに 0 を
         *  パッディングする。その分を考æ…
®ã—て net_buf を獲得しなければならない。
         */
        align = ((((len - sizeof(T_IF_HDR)) + 3) >> 2) << 2) + sizeof(T_IF_HDR);

        if ((error = tget_net_buf(&input, align, TMO_IF_RX62N_GET_NET_BUF)) == E_OK && input != NULL) {
                dst = input->buf + IF_ETHER_NIC_HDR_ALIGN;
                memcpy(dst, (void *)desc->rba, len);
        }
        else {
                NET_COUNT_ETHER_NIC(net_count_ether_nic[NC_ETHER_NIC_IN_ERR_PACKETS], 1);
                NET_COUNT_ETHER_NIC(net_count_ether_nic[NC_ETHER_NIC_NO_BUFS], 1);
        }

        desc->rfp = 0;
        desc->ract = 1;

        desc++;
        if (desc == &rx62n_buf.rx_desc[NUM_IF_RX62N_RXBUF]) {
                desc = rx62n_buf.rx_desc;
        }
        sc->rx_read = desc;

        if (sil_rew_mem(EDMAC_EDRRR) == 0) {
                sil_wrw_mem(EDMAC_EDRRR, EDMAC_EDRRR_RR);
        }

        return input;
}

/*
 * rx62n_start -- 送信フレームをバッファリングする。
 */

void
rx62n_start (T_IF_SOFTC *ic, T_NET_BUF *output)
{
        T_RX62N_SOFTC *sc = ic->sc;
        T_RX62N_TX_DESC *desc, *next;
        uint8_t *buf = NULL;
        int32_t len, res, pos;
        uint32_t tfp;

        for ( res = output->len, pos = 0; res > 0; res -= len, pos += len ) {
                desc = sc->tx_write;

                while (desc->tact != 0) {
                        tslp_tsk(1000);
                }

                buf = (uint8_t *)desc->tba + IF_ETHER_NIC_HDR_ALIGN;

                next = desc + 1;
                if (next == &rx62n_buf.tx_desc[NUM_IF_RX62N_TXBUF]) {
                        next = rx62n_buf.tx_desc;
                }
                sc->tx_write = next;

                len = res;
                if ( len > IF_RX62N_BUF_PAGE_SIZE ) {
                        len = IF_RX62N_BUF_PAGE_SIZE;
                        tfp = 0x0;
                }
                else
                        tfp = 0x1;

                if (pos == 0)
                        tfp |= 0x2;

                memcpy(buf, (uint8_t *)output->buf + pos, len);

                desc->tbl = len;
                desc->tfp = tfp;
                desc->tact = 1;
        }

        if (sil_rew_mem(EDMAC_EDTRR) == 0) {
                sil_wrw_mem(EDMAC_EDTRR, EDMAC_EDTRR_TR);
        }
}

/*
 *  RX62N Ethernet Controler 送受信割り込みハンドラ
 */

void
if_rx62n_trx_handler (void)
{
        T_IF_SOFTC *ic;
        T_RX62N_SOFTC *sc;
        uint32_t ecsr, eesr;

        ic = &if_softc;
        sc = ic->sc;

        ecsr = sil_rew_mem(ETHERC_ECSR);

        if (ecsr & ETHERC_ECSR_LCHNG) {
                /* ETHERCéƒ¨å‰²ã‚Šè¾¼ã¿è¦å› ã‚¯ãƒªã‚¢ */
                sil_wrw_mem(ETHERC_ECSR, ETHERC_ECSR_LCHNG);

                /* 受信割り込み処理 */
                isig_sem(ic->semid_rxb_ready);
        }

        eesr = sil_rew_mem(EDMAC_EESR);

        if (eesr & EDMAC_EESR_FR) {
                /* DMAéƒ¨å‰²ã‚Šè¾¼ã¿è¦å› ã‚¯ãƒªã‚¢ */
                sil_wrw_mem(EDMAC_EESR, EDMAC_EESR_FR);

                /* 受信割り込み処理 */
                isig_sem(ic->semid_rxb_ready);
        }
        if (eesr & EDMAC_EESR_TC) {
                /* DMAéƒ¨å‰²ã‚Šè¾¼ã¿è¦å› ã‚¯ãƒªã‚¢ */
                sil_wrw_mem(EDMAC_EESR, EDMAC_EESR_TC);

                /* 送信割り込み処理 */
                isig_sem(ic->semid_txb_ready);
        }
        if (eesr & (EDMAC_EESR_FROF | EDMAC_EESR_RDE)) {
                /* DMAéƒ¨å‰²ã‚Šè¾¼ã¿è¦å› ã‚¯ãƒªã‚¢ */
                sil_wrw_mem(EDMAC_EESR, EDMAC_EESR_FROF | EDMAC_EESR_RDE);

                sc->over_flow = true;

                /* 受信割り込み処理 */
                isig_sem(ic->semid_rxb_ready);
        }
}

void if_rx62n_cyclic_handler(void)
{
        T_IF_SOFTC *ic;
        T_RX62N_SOFTC *sc;

        ic = &if_softc;
        sc = ic->sc;

        /* 受信割り込み処理 */
        isig_sem(ic->semid_rxb_ready);
}