ixethaccsysend.c

INTEL IXP425的VXWORKS BSP

    }
    
    return IX_SUCCESS;
}

/* this function is called suring muxUnload */
IX_STATUS ixdp425EthLibUnload(int port)
{  
#ifdef SYS_END_DEBUG
        DRV_LOG("ixdp425EthLibUnload(%d)\n", port);
#endif /* SYS_END_DEBUG */

    /* ensure the traffic is stopped */
    return ixdp425EthLibStop(port);
}

STATUS ixdp425EthEndMuxInit()
    {
    END_TBL_ENTRY     *pDevTbl;
    UINT32 phyNo;

    for ( pDevTbl = endDevTbl; pDevTbl->endLoadFunc != END_TBL_END; pDevTbl++ )
        ; /* Do nothing as we just want the increment */

    /* TODO - How to we tie phys ports to ixe's ?????? */
    for (phyNo=0; phyNo<IX_ETH_ACC_NUMBER_OF_PORTS; phyNo++)
        {

#ifndef INCLUDE_IXETHACC_PORT0_END
        if ( phyNo == 0 )
            continue;
#endif

#ifndef INCLUDE_IXETHACC_PORT1_END
        if ( phyNo == 1 )
            continue;
#endif

        /* Fill in the endDev entry for this device */
        pDevTbl->unit = phyNo;
        pDevTbl->endLoadFunc = ixEthAccEndLoad;
        pDevTbl->endLoadString = ixpEndLoadStr[phyNo];
        pDevTbl->endLoan = 1;
        pDevTbl->pBSP = NULL;
        pDevTbl->processed = FALSE;

        pDevTbl++;
        }

    return OK;
    }


STATUS ixdp425EthEndStartUp()
    {
    END_TBL_ENTRY     *pDevTbl;
    END_OBJ *         pCookie = NULL;
    UINT32 ixdp425EthEndMask;
    UINT8 nvImage[NV_RAM_IF_SIZE+1];
    UINT8 inetAddr[INET_ADDR_LEN];
    UINT8 nameAndUnit[32];
    UINT8 pNetDev[32];
    char *colon;
    int n = 0,index,ipaddrOk;

    sysNvRamGet(nvImage, NV_RAM_IF_SIZE, NV_RAM_IF_START_OFFSET);

    for ( pDevTbl = endDevTbl
            ; pDevTbl->endLoadFunc != END_TBL_END && n < IX_ETH_ACC_NUMBER_OF_PORTS
            ; pDevTbl++ )
        {
        if ( pDevTbl->endLoadFunc != ixEthAccEndLoad )
            continue;

        if ( pDevTbl->processed == FALSE )
            {
            /* Add in mux END */
            pCookie = muxDevLoad (pDevTbl->unit,
                                  pDevTbl->endLoadFunc,
                                  pDevTbl->endLoadString,
                                  pDevTbl->endLoan, 
                                  pDevTbl->pBSP);

            if (pCookie == NULL)
                {
                printf("ixdp425EthEndStartUp: muxDevLoad failed for ixp device entry %d!\n"
                       , n
                      );

                n++;
                continue;
                }
             else
                {
                /* Start END */
                if (muxDevStart(pCookie) == ERROR)
                    {
                    printf("ixdp425EthEndStartUp: muxDevStart failed for ixp device entry %d!\n"
                           , n
                          );

                    n++;
                    continue;
                    }
                }
            }

        ipaddrOk = 1;

        /* If the EthAccEnd interface is not already attached, we should bring it up here
          and assign an IP address*/
        sprintf(pNetDev,"%s","ixe");

        sprintf(nameAndUnit,"%s%d","ixe", n);

        /* need to figure out if this has been configured already */
        if (ifAddrGet(nameAndUnit,inetAddr) == ERROR)
            {
            if (ipAttach(n, pNetDev) != OK)
                {
                printf ("ixdp425EthEndStartUp: Failed to attach to device %s, unit: %d", pNetDev,n);
                }
             else
                {
                /* See if an address is in nvram */
                /* Get IP address */
                index = NV_IP_ADRS_NPE1 + n*SIZE_OF_IP_ADDRESS - NV_RAM_IF_START_OFFSET;
                memcpy(inetAddr, &nvImage[index],SIZE_OF_IP_ADDRESS);
                inetAddr[SIZE_OF_IP_ADDRESS]=0;

hardCodedRetry:
                /* See if there is a mask */
                if ( (colon = strchr(inetAddr, ':')) )
                    {
                    *colon = 0;
                    colon++;
                    for(index = 0; index < 6; index++)
                        {
                        if( isxdigit(colon[index] == 0 ) )
                            {
                            printf("ixdp425EthEndStartUp: Invalid Mask for ixe%d IP: %s:%s Discarding Mask\n"
                                ,n,inetAddr, colon);
                            colon = NULL;
                            break;
                            }
                        }
                    if(colon != NULL)
                        {
                        sscanf(colon, "%x", &ixdp425EthEndMask);
                        }
                    }

                /* Check to see if its a valid IP address */
                for(index = 0; index < SIZE_OF_IP_ADDRESS; )
                    {
                    if ( !isdigit(inetAddr[index]) && inetAddr[index] != '.' )
                        {
#if defined(IXDP_ETHACC_IP0_DEFAULT) && defined(IXDP_ETHACC_IP1_DEFAULT)
                        printf("ixdp425EthEndStartUp: Forcing Hard Coded IP Address for ixe%d\n",n);
                        sprintf(inetAddr, "%s", sysIxEthAccEndIpAddr[n]);
                        goto hardCodedRetry;
#else
                        ipaddrOk = 0;
                        printf("ixdp425EthEndStartUp: Invalid Address for ixe%d IP: %s Ignoring\n",n,inetAddr);
                        break;
#endif
                        }
                    if ( inetAddr[++index] == 0 )
                        break;
                    }

                if ( ipaddrOk )
                    {
                    ifAddrSet(nameAndUnit, inetAddr);
                    if( colon != NULL )
                        {
                        ifMaskSet(nameAndUnit, ixdp425EthEndMask);
                        printf("                ixe%d: IP Addr set to %s:%x\n"
                                ,n, inetAddr, ixdp425EthEndMask);
                        }
                    else
                        {
                        printf("                ixe%d: IP Addr set to %s\n",n, inetAddr);
                        }
                    }
                }
            }
        n++;
        }

    return OK;
    }

const char *ixIpProtoStrGet (const UINT8 ipProto)
    {
    UINT32 index;

    for (index = 0 ; index < NUM_ELEM(ixIpProtoValues) ; index++)
        {
        if (ixIpProtoValues[index].number == ipProto)
            {
            return ixIpProtoValues[index].string;
            }
        }

    return "Unknown IP protocol";
    }

struct
    {
    int number; const char *string;
    } ixEtherTypeValues[] = 
    {
    {ETHERTYPE_PUP,         "PUP"},
    {ETHERTYPE_IP,          "IP"},
    {ETHERTYPE_ARP,         "ARP"},
    {ETHERTYPE_REVARP,      "Reverse ARP"}
    };

const char *ixEthernetTypeStrGet (const UINT16 etherType)
    {
    UINT32 index;

    for (index = 0 ; index < NUM_ELEM(ixEtherTypeValues) ; index++)
        {
        if (ixEtherTypeValues[index].number == etherType)
            {
            return ixEtherTypeValues[index].string;
            }
        }

    return "Unknown Ethernet Type";
    }

void dumpMbufPtr(IX_MBUF *mBufPtr)
    {
    UINT32 j,k;

    logMsg("m_len:        %d\n",mBufPtr->m_len,0,0,0,0,0);
    logMsg("m_pkthdr.len: %d\n", mBufPtr->m_pkthdr.len,0,0,0,0,0);
    logMsg("m_next        0x%x\n",(UINT32)mBufPtr->m_next,0,0,0,0,0);
    logMsg("m_type        0x%x\n", mBufPtr->m_type,0,0,0,0,0);
    for (j=0;j<mBufPtr->m_len/16;j++)
        {
        for (k=0;k<16;k++)
            {
            logMsg("data: 0x%x\n",mBufPtr->m_data[j*16 + k],0,0,0,0,0);
            }
        }

    logMsg("\n",0,0,0,0,0,0);
    ixEthernetHdrDump(mBufPtr->m_data);

    }

/******************************************************************************
 *
 * This function can be used to output the Ethernet headers of messages. The
 * inputted mData pointer is assumed to point to the start of the Ethernet 
 * header
 *
 *****************************************************************************/
void ixEthernetHdrDump(const char * const mData)
    {
    static unsigned char *etherSrcAddr = NULL;
    static unsigned char *etherDstAddr = NULL;
    static unsigned etherType = 0;
    const char *etherTypeStr = NULL;
    BOOL nonIpHdrDetected;

    if ( (mData == NULL) )
        {
        logMsg("ERROR: RNDIS detected NULL pointer in ixEthernetDump\n",
               0,0,0,0,0,0);
        return;
        }

    logMsg("*** Ethernet Header ***\n", 0, 0, 0, 0, 0, 0);

    etherDstAddr = ((struct ether_header *) mData)->ether_dhost;
    etherSrcAddr = ((struct ether_header *) mData)->ether_shost;

    etherType = ntohs(((struct ether_header *) mData)->ether_type);

    if (etherType != ETHERTYPE_IP)
        {
        nonIpHdrDetected = TRUE;

        logMsg("[this is non-IP data]\n", 0, 0, 0, 0, 0, 0);
        }
     else
        {
        nonIpHdrDetected = FALSE;

        logMsg("[this is IP data]\n", 0, 0, 0, 0, 0 ,0);
        }

    etherTypeStr = ixEthernetTypeStrGet((const UINT16)etherType);

    logMsg("Ethernet Dst MAC: 0x%02x:%02x:%02x:%02x:%02x:%02x\n",
           etherDstAddr[0],
           etherDstAddr[1],
           etherDstAddr[2], 
           etherDstAddr[3], 
           etherDstAddr[4], 
           etherDstAddr[5] );


    logMsg("Ethernet Src MAC: 0x%02x:%02x:%02x:%02x:%02x:%02x\n",
           etherSrcAddr[0],
           etherSrcAddr[1],
           etherSrcAddr[2], 
           etherSrcAddr[3], 
           etherSrcAddr[4], 
           etherSrcAddr[5] );

    logMsg("Ethernet Type (%X): %s\n", etherType, (int)etherTypeStr, 0, 0, 0, 0);

    if (!nonIpHdrDetected)
        {
        ixIpHdrDump(mData + 14 );
        }

    }

/******************************************************************************
 *
 * This function can be used to output the IP headers of messages. The inputted
 * mData pointer is assumed to point to the start of the IP header
 *
 *****************************************************************************/
void ixIpHdrDump(const char * const mData)
    {
    static struct in_addr srcAddr;
    static struct in_addr dstAddr;
    static char ipSrcAddrStr[INET_ADDR_LEN];
    static char ipDstAddrStr[INET_ADDR_LEN];

    if (mData == NULL)
        {
        logMsg("ERROR: RNDIS detected NULL pointer in ixIpHdrDump\n",
               0,0,0,0,0,0);
        return;
        }

    /*
     * Check for a non word aligned header
     */
    if (((UINT32) mData) % 4 == 0)
        {
        logMsg("*** IP Header ***\n", 0, 0, 0, 0, 0, 0);
        }
     else
        {
        logMsg("*** IP Header *** WARNING: THIS IS NOT WORD ALIGNED\n", 0, 0, 0, 0, 0, 0);
        }

    logMsg("Total Length: %u 0x%08X\n",
           ntohs(((struct ip *) mData)->ip_len),(((struct ip *) mData)->ip_len) , 0, 0, 0, 0);

    logMsg("Protocol: %s\n",
           (int)ixIpProtoStrGet(((struct ip *) mData)->ip_p), 0, 0, 0, 0, 0);

    /*
     * Potential for the source IP address to be on a half word
     * boundary. E.g. If the RNDIS header is word aligned (44 bytes 
     * long), the Ethernet header follows directly (14 bytes), and
     * then the IP header is directly after that, then the IP 
     * will be on a half word boundary... This may have performance
     * impacts on the system.
     */
    memcpy(&(srcAddr.s_addr),
           &(((struct ip *)mData)->ip_src.s_addr),
           sizeof (UINT32));

    memcpy( &(dstAddr.s_addr),
            &(((struct ip *)mData)->ip_dst.s_addr),
            sizeof (UINT32));

    /*
     * Get the IP addresses in string dotted decimal format
     */
    inet_ntoa_b(srcAddr, ipSrcAddrStr);
    logMsg("Src Addr: %s\n", (int)ipSrcAddrStr, 0, 0, 0, 0, 0);

    inet_ntoa_b(dstAddr, ipDstAddrStr);
    logMsg("Dst Addr: %s\n", (int)ipDstAddrStr, 0, 0, 0, 0, 0);

    }

void ixEthAccEndEthernetLinkStatusMonitor(void)
    {
    unsigned phyNum = 0;
    unsigned ticksPerSecond = 0;
    BOOL linkUp[IX_ETH_ACC_NUMBER_OF_PORTS] = {FALSE, FALSE};
    enum { IX_END_UNKNOWN_MODE, IX_END_FULL_DUPLEX_MODE, IX_END_HALF_DUPLEX_MODE }
           lastDuplexMode[IX_ETH_ACC_NUMBER_OF_PORTS]
               = {  IX_END_UNKNOWN_MODE, IX_END_UNKNOWN_MODE };

    IXDP_ETHACC_PHY_CONF currentPhyConfig[IX_ETH_ACC_NUMBER_OF_PORTS];

    ticksPerSecond = sysClkRateGet();
     
    /*
     * Start the infinite loop
     */
    while (1)
        {
        for (phyNum = 0; phyNum < IX_ETH_ACC_NUMBER_OF_PORTS; phyNum++)
            {
            /* check the PHY is initialized */
            if (ixEthAccPhyAddresses[phyNum] == 0xffffffff)
                continue;
            
            /*
             * Determine the link status
             */
            if (IX_ETH_ACC_SUCCESS != 
                ixEthAccMiiLinkStatus(ixEthAccPhyAddresses[phyNum],
                                      &linkUp[phyNum],
                                      &(currentPhyConfig[phyNum].speed100),
                                      &(currentPhyConfig[phyNum].fullDuplex), 
                                      &(currentPhyConfig[phyNum].autonegotiate)))
                {
                printf("%s: Warning - ixEthAccMiiLinkStatus failed on PHY%d. "
                       "Can't determine\nthe auto negotiated parameters.Using "
                       " default values.\n",
                       "ixEthAccEndEthernetLinkStatusMonitor",
                       phyNum); 
                }
	     
            /*
             * Update the MAC mode to match the PHY mode. If autonegotiotion is not enabled,
             * then the MAC mode is already set during initialisation. If autonegotiation 
             * is enabled, the MAC mode may change at any time.
             */
            if (linkUp[phyNum] && currentPhyConfig[phyNum].autonegotiate)
                {
                if (currentPhyConfig[phyNum].fullDuplex)
                    {
                    /* check if the MAC mode is already set */
                    if (lastDuplexMode[phyNum] != IX_END_FULL_DUPLEX_MODE)
                        {
                        ixEthAccPortDuplexModeSet (phyNum,
                                                   IX_ETH_ACC_FULL_DUPLEX);
                        lastDuplexMode[phyNum] = IX_END_FULL_DUPLEX_MODE;
#ifdef SYS_END_DEBUG
                        printf("Port %d set to Full duplex\n", phyNum);
#endif
                        }
                    }
                else
                    {
                    /* check if the MAC mode is already set */
                    if (lastDuplexMode[phyNum] != IX_END_HALF_DUPLEX_MODE)
                        {
                        ixEthAccPortDuplexModeSet (phyNum,
                                                   IX_ETH_ACC_HALF_DUPLEX);
                        lastDuplexMode[phyNum] = IX_END_HALF_DUPLEX_MODE;
#ifdef SYS_END_DEBUG
                        printf("Port %d set to Half duplex\n", phyNum);
#endif
                        }
                    }
                } /* if duplex */
            } /* for phyNum */
        /*
         * This function should poll the MII link status approximately every 
         * 4 seconds
         */
        taskDelay((4 * ticksPerSecond) / IX_ETH_ACC_NUMBER_OF_PORTS);
        } /* End of while (1)*/
    }
 
#endif /* INCLUDE_IXETHACCEND */