ne2000monic.cpp

MONA是为数不多的C++语言编写的一个很小的操作系统

/*!
    \file   Ne2000MoNic.cpp
    \brief  Ne2000僪儔僀僶僋儔僗

    Copyright (c) 2004 Yamami
    All rights reserved.
    License=MIT/X License

    \author  Yamami
    \version $Revision: 1.2 $
    \date   create:2004/07/28 update:$Date: 2004/10/31 14:29:43 $
*/

/*! \class Ne2000MoNic
 *  \brief Ne2000僪儔僀僶僋儔僗
 */



#include "Ne2000MoNic.h"


/*!
    \brief initialize
         Ne2000MoNic 僐儞僗僩儔僋僞
    \author Yamami
    \date   create:2004/08/08 update:
*/
Ne2000MoNic::Ne2000MoNic()
{

}


/*!
    \brief initialize
         Ne2000MoNic init
    \author Yamami
    \return int 寢壥 0:惓忢 丄 0埲奜:堎忢
    \date   create:2004/08/12 update:
*/
int Ne2000MoNic::init() 
{

    int reti;
    

    //僾儔僀儀乕僩儊儞僶弶婜壔
    ne_ringbuf_status=0;
    ne_ringbuf_bound=0;
    ne_ringbuf_len=0;

    ne_rx_start=0;      /* 庴怣僷働僢僩杮懱偺奐巒傾僪儗僗 */
    frame_len=0;        /* 庴怣僷働僢僩杮懱偺挿偝 */
    ne_rx_bound=0;      /* 庴怣屻偺嫬奅儗僕僗僞抣 */
    ne_rx_write_p=0;    /* 庴怣僷働僢僩彂偒崬傒傾僪儗僗 */
    ne_rx_sub_len=0;    /* 愜傝曉偟暘偺挿偝 */
    ne_rx_remain_len=0; /* 巆傝偺挿偝(愜傝曉偟偑側偄偲偒偼杮懱偺挿偝偲摨偠) */
    
    ne_sizeof_test_pattern=20;

    //Ne2000 懚嵼妋擣
    reti = nic_probe();
    if(reti != 0 ){
        printf("Does Not Exist Ne2K!!!\n");
        return -1;
    }

    //偙偙偱MAC傾僪儗僗傪昞帵偟偰傒傞
    //int i;
    //printf("MAC ADR:");
    //for(i=0 ;i < 6 ; i++){
    //    printf("%x ",ether_mac_addr[i]);
    //}
    //printf("\n");

    //Ne2000 弶婜壔
    nic_init();

    return 0;
}


/*!
    \brief frame_input
        NE2000 僨乕僞擖椡儖乕僠儞
        杮棃偼丄NE2000偐傜偺妱傝崬傒偵偰僐乕儖偝傟傞丅
        僥僗僩僾儘僌儔儉偱偼丄帋尡揑偵MonaMain 偱僐乕儖丅
    \param  void
    \return void

    \author Yamami
    \date   create:2004/08/03 update:$Date: 2004/10/31 14:29:43 $
*/
void Ne2000MoNic::frame_input(void)
{

    byte sts,*buf;
    //僶僂儞僟儕儗僕僗僞 偲丄僇儗儞僩儁乕僕儗僕僗僞偼8價僢僩暆
    //僨乕僞偵傾僋僙僗偡傞嵺丄8價僢僩僔僼僩偟偰16價僢僩暆傾僋僙僗傪峴偆
    word  bnd,cpg;

    buf=frame_buf;

    // Page 0
    outp8( NE_P0_COMMAND, NE_CR_STA );
    // sts <- 庴怣僗僥乕僞僗儗僕僗僞(Receive Status Reg)
    sts=inp8( NE_P0_RSR );

//Yamami 僨僶僢僌
//printf("sts : %x\n",sts);

    if( ( sts & NE_RSTAT_OVER ) !=0 ){
        //printf("FIFO OverFlow\n");
        return; // 庴怣FIFO僆乕僶乕僼儘乕偟偨
    }

    if( ( inp8( NE_P0_ISR ) & NE_ISR_OVW ) !=0 ){
        //printf("RING OverFlow\n");
        return; // 庴怣儕儞僌僶僢僼傽僆乕僶乕僼儘乕
    }

    //  庴怣惉岟
    if( ( sts & NE_RSTAT_PRX ) ==0 ){
        //printf("Not Exist Packet \n");
        return; //  庴怣僷働僢僩側偟
    }

    //儁乕僕傪柧帵揑偵愗傝懼偊偰 bnd 偲 cpg 傪撉傓
    outp8(NE_P0_COMMAND, NE_CR_PS0 | NE_CR_STA); /* Page 0 */
    bnd=inp8( NE_P0_BNRY ) + 1;      // bnd <-bnd  
    //bnd=inp8( NE_P0_BNRY );      // bnd <-bnd 偙偙偱+1偟側偄
    outp8(NE_P1_COMMAND, NE_CR_PS1 | NE_CR_STA); /* Page 1 */
    cpg=inp8( NE_P1_CURR );          // cpg <- Current Page
    
    //Page0偵栠偟偰偍偔
    outp8( NE_P0_COMMAND, NE_CR_PS0 );


//Yamami 僨僶僢僌
//printf("bnd : %x\n",bnd);
//printf("cpg : %x\n",cpg);


    if( bnd == NE_RX_PAGE_STOP ){
        // if last page then set to start page
        bnd=NE_RX_PAGE_START;
    }
    if( cpg == NE_RX_PAGE_STOP ){
        /* if last page then set to start page */
        cpg=NE_RX_PAGE_START; 
    }
    if( cpg == bnd ){        // Current Page = bound ?
        //printf("Not Exist Packet buffer \n");
        return;         // = 側傜 僶僢僼傽忋偵僷働僢僩側偟
    }

    
    // bound+1 儁乕僕偺愭摢4僶僀僩傪撉傒崬傓
    // Yamami 伀偩偲丄楢懕偟偨曄悢愰尵偑丄楢懕偟偨4僶僀僩偱偁傞帠偵棅偭偰偄傞丠丠
    // 僶僢僼傽偵堦扷儕乕僪偟偰丄戙擖偡傞張棟偵曄峏
    //ne_pio_readmem( bnd << 8, &ne_ringbuf_status, 4 );

    byte bndBuf[4];
    ne_pio_readmem( bnd << 8, bndBuf, 4 );

// Yamami僨僶僢僌 儕乕僪傾僪儗僗偺昞帵
//printf("Read Src = bnd << 8 : %x\n",bnd << 8);

    ne_ringbuf_status = bndBuf[0]; /* Receive Status */
    ne_ringbuf_bound = bndBuf[1] & 0xFF; /* Next Packet Pointer */
    ne_ringbuf_len = bndBuf[3] * 256 + bndBuf[2];   /* Receive Byte Count */

    //仾偙傟偑丄偦傟偧傟媡偺傛偆側婥偑偡傞丅僄儞僨傿傾儞偺堘偄丠丠
    //  偙偺帠偼丄Read/Write懁傪曄峏
    //ne_ringbuf_status = bndBuf[1]; /* Receive Status */
    //ne_ringbuf_bound = bndBuf[0] & 0xFF; /* Next Packet Pointer */
    //ne_ringbuf_len = bndBuf[2] * 256 + bndBuf[3];   /* Receive Byte Count */

// Yamami僨僶僢僌
//printf("ne_ringbuf_status : %x\n",ne_ringbuf_status);
//printf("ne_ringbuf_bound  : %x\n",ne_ringbuf_bound);
//printf("ne_ringbuf_len : %x\n",ne_ringbuf_len);

    ne_rx_start=(bnd << 8) + 4; // 僷働僢僩杮懱偺奐巒傾僪儗僗

    // CRC偺暘偺挿偝傪堷偔
    // CRC偺暘偺挿偝傪堷偔 ? CRC偠傖側偔偰ne_ringbuf_*偺4 byte?
    frame_len=ne_ringbuf_len - 4; /* 僷働僢僩杮懱偺挿偝 */

    // 庴怣廔椆屻偺嫬奅儗僕僗僞抣
    ne_rx_bound=ne_ringbuf_bound;

    if( ( ne_ringbuf_status & NE_RSTAT_PRX ) !=0 ){
                    // 庴怣偑惓忢廔椆偟偨
        if( frame_len >= ETHER_HEADER_SIZE ){
                    // 嵟抁挿傛傝抁偄偲偒偼僄儔乕
            if( frame_len < ETHER_MAX_PACKET ) {
                    // 嵟戝挿傛傝挿偄偲偒偼僄儔乕

                ne_rx_remain_len=frame_len;

                // 僷働僢僩偺庢傝崬傒張棟
                // 愜傝曉偟暘偺挿偝
                ne_rx_sub_len=NE_RX_PAGE_STOP * 256 - ne_rx_start;

// Yamami僨僶僢僌
//printf("frame_input 03 ne_rx_start=%x\n",ne_rx_start);
//printf("frame_input 04 ne_rx_sub_len=%x\n",ne_rx_sub_len);

                if( ne_rx_sub_len < frame_len ){
                    // 庴怣偡傋偒僷働僢僩偼愜傝曉偟偰偄傞
                    // 慜敿晹偺撉傒崬傒
                    ne_pio_readmem( ne_rx_start, buf, ne_rx_sub_len );
                    ne_rx_start=NE_RX_PAGE_START * 256;

                    // 彂偒崬傒傾僪儗僗偺峏怴
                    buf+=ne_rx_sub_len;
                    // 巆傝偺撉傒崬傒挿偺峏怴
                    ne_rx_remain_len=frame_len - ne_rx_sub_len;
                }
                // 僷働僢僩偺撉傒崬傒
                ne_pio_readmem( ne_rx_start, buf, ne_rx_remain_len );
                
            }
            else{
                //printf("Error frame_len >= ETHER_MAX_PACKET \n");
            }
        }
        else{
            //printf("Error frame_len >= ETHER_HEADER_SIZE \n");
        }
    }
    else{
        //printf("Error ne_ringbuf_status & NE_RSTAT_PRX = 0 \n");
    }

    // Yamami 僶僂儞僟儕儗僕僗僞 偺峏怴
    bnd=ne_rx_bound; 
    if( bnd == NE_RX_PAGE_START ){
        bnd=NE_RX_PAGE_STOP;
    }
    bnd--;
    outp8( NE_P0_BNRY, bnd );    // 嫬奅儗僕僗僞 = 師偺僶僢僼傽 - 1

//Yamami 僨僶僢僌
//printf("UpdateAfter bnd : %x\n",bnd);

    //  妱傝崬傒僗僥乕僞僗儗僕僗僞僋儕傾
    outp8( NE_P0_ISR, 0xff );
    
    //H8 傛傝
    outp8(NE_P0_IMR, NE_IMR_PRXE); /* Packet Receive interrupt enable */

}



/*!
    \brief frame_output
        NE2000 僨乕僞弌椡儖乕僠儞
    \param  byte *pkt [in] 僨乕僞僷働僢僩傊偺億僀儞僞
    \param  byte *mac [in] 憲傝愭MAC傾僪儗僗傊偺億僀儞僞
    \param  dword size [in] 僷働僢僩僒僀僘
    \param  word pid [in] 僾儘僩僐儖ID(ETHER_PROTO)
    \return void

    \author Yamami
    \date   create:2004/08/03 update:$Date: 2004/10/31 14:29:43 $
*/
void Ne2000MoNic::frame_output( byte *pkt, byte *mac, dword size, word pid )
{
    
    dword        ptx_type=0;
    dword        ptx_size=0;
    byte       *ptx_packet=0;
    byte       *ptx_dest=0;
    
    
    // 憲怣偑姰椆偟偰偄傞偐偳偆偐僠僃僢僋偡傞
    while( ( inp8( NE_P0_COMMAND ) & 0x04 ) !=0 );

//Yamami 僨僶僢僌
//printf("frame_output 01\n");
    
    ptx_dest=mac;
    ptx_size=size;
    ptx_packet=pkt;
    // 僱僢僩儚乕僋僶僀僩僆乕僟乕偵曄姺偡傞
    // Yamami 曄姺晄梫丠
    ptx_type=(pid >> 8)+(pid << 8);

//Yamami 僨僶僢僌
//int i;
//for(i=0 ; i<2 ; i++){
//    printf("ptx[1] = %x \n",(byte *)(&ptx_type + 1));
//}


    // 妱傝崬傒嬛巭
    // 憲怣張棟拞偵庴怣偡傞偲儗僕僗僞偑嫸偭偰偟傑偆
    //disableInterrupt();
    disableNetWork();

    // 埗愭傾僪儗僗偺彂偒崬傒
    ne_pio_writemem( ptx_dest, NE_TX_PAGE_START << 8, 6 );
    // 憲怣尦傾僪儗僗偺彂偒崬傒
    ne_pio_writemem( ether_mac_addr, ( NE_TX_PAGE_START << 8 ) + 6, 6 );
    // 僾儘僩僐儖ID偺彂偒崬傒
    ne_pio_writemem( (byte *)&ptx_type, ( NE_TX_PAGE_START << 8 ) + 12, 2 );
    // 僨乕僞晹暘偺彂偒崬傒
    ne_pio_writemem( ptx_packet, ( NE_TX_PAGE_START << 8 ) + 14, ptx_size );

    ptx_size+=ETHER_HEADER_SIZE;

    // 嵟彫僷働僢僩挿傛傝抁偄偐偳偆偐傪僠僃僢僋偡傞
    if( ptx_size < ETHER_MIN_PACKET ){
        ptx_size=ETHER_MIN_PACKET;
    }

    outp8( NE_P0_COMMAND, NE_CR_PS0 + NE_CR_RD2 + NE_CR_STA );
    
    // 憲怣僶僢僼傽椞堟偺巜掕
    outp8( NE_P0_TPSR, NE_TX_PAGE_START );
    
    // 憲怣挿偺巜掕
    outp8( NE_P0_TBCR0, ptx_size & 0xff);
    outp8( NE_P0_TBCR1, ptx_size >> 8 );

    // 憲怣柦椷傪敪峴偡傞
    outp8( NE_P0_COMMAND, NE_CR_PS0 + NE_CR_TXP + NE_CR_RD2 + NE_CR_STA );

    // 妱傝崬傒嫋壜
    //enableInterrupt();
    enableNetWork();

//Yamami 僨僶僢僌
//printf("frame_output 02\n");

    // 憲怣偑姰椆偟偰偄傞偐偳偆偐僠僃僢僋偡傞
    while( ( inp8( NE_P0_COMMAND ) & 0x04 ) !=0 );

//Yamami 僨僶僢僌
//printf("frame_output 03\n");

}


/*!
    \brief nic_probe
        NE2000専嵏儖乕僠儞
        僶僢僼傽儊儌儕偵彂偒崬傒偲撉傒崬傒傪峴偄丄NE2000偑懚嵼偡傞偙偲傪妋擣偡傞
    \param  void
    \return void

    \author Yamami
    \date   create:2004/08/01 update:$Date: 2004/10/31 14:29:43 $
*/
int Ne2000MoNic::nic_probe(void)
{
    int i;

    /* 僜僼僩僂僃傾儕僙僢僩 */
    //outp8( NE_ASIC_RESET, inp8( NE_ASIC_RESET ) ); 
    /* 儕僙僢僩姰椆傑偱懸偮 */
    //ne_wait_func(0);

    /* DMA 傪嫮惂掆巭偡傞丅 */
    outp8( NE_P0_COMMAND, NE_CR_RD2 + NE_CR_STP );