velocity_proc.c

VIA千兆网卡芯片VT6122的linux驱动源代码

    if (len <= off + count)
        *eof = 1;

    *start = page + off;
    len -= off;

    if (len > count)
        len = count;

    if (len < 0)
        len = 0;
    return len;
}

static const char* MIB_STRINGS[HW_MIB_SIZE]={
    "RxAllPkts",
    "ifRxOkPkts",
    "ifTxOkPkts",
    "ifRxErrorPkts",
    "ifRxRuntOkPkt",
    "ifRxRuntErrPkt",
    "ifRx64Pkts",
    "ifTx64Pkts",
    "ifRx65To127Pkts",
    "ifTx65To127Pkts",
    "ifRx128To255Pkts",
    "ifTx128To255Pkts",
    "ifRx256To511Pkts",
    "ifTx256To511Pkts",
    "ifRx512To1023Pkts",
    "ifTx512To1023Pkts",
    "ifRx1024To1518Pkts",
    "ifTx1024To1518Pkts",
    "ifTxEtherCollisions",
    "ifRxPktCRCE",
    "ifRxJumboPkts",
    "ifTxJumboPkts",
    "ifRxMacControlFrames",
    "ifTxMacControlFrames",
    "ifRxPktFAE",
    "ifRxLongOkPkt",
    "ifRxLongPktErrPkt",
    "ifTXSQEErrors",
    "ifRxNobuf",
    "ifRxSymbolErrors",
    "ifInRangeLenthErrors",
    "ifLateCollisions"
};

static int FunStatRead(PVELOCITY_PROC_ENTRY pEntry,char* buf) {
    PVELOCITY_INFO pInfo=pEntry->pInfo;
    int         len=0;
    int         i;

    spin_lock_irq(&pInfo->lock);
    velocity_update_hw_mibs(&pInfo->hw);
    spin_unlock_irq(&pInfo->lock);
    len+=sprintf(&buf[len],"Hardware MIB Counter:\n");
    for (i=0;i<HW_MIB_SIZE;i++)
        len+=sprintf(&buf[len],"%d: %s\t%d\n",i+1,MIB_STRINGS[i], pInfo->hw.adwHWMIBCounters[i]);

    len=strlen(buf);

    return len;
}

static int FunConfRead(PVELOCITY_PROC_ENTRY pEntry,char* buf) {
    PVELOCITY_INFO pInfo=pEntry->pInfo;
    int len=0;
    PROC_CONF_TYPE  op=pEntry->data;
    switch(op) {
    case CONF_RX_DESC:
        len=sprintf(buf,"%d",pInfo->hw.sOpts.nRxDescs);
        break;

    case CONF_TX_DESC:
        len=sprintf(buf,"%d",pInfo->hw.sOpts.nTxDescs);
        break;

    case CONF_RX_THRESH:
        len=sprintf(buf,"%d",pInfo->hw.sOpts.rx_thresh);
        break;
    case CONF_SPD_DPX: {
        int mii_status=mii_check_media_mode(&pInfo->hw);
        int r=0;
        if (mii_status & VELOCITY_AUTONEG_ENABLE)
            r=0;
        else if ((mii_status & (VELOCITY_SPEED_100|VELOCITY_DUPLEX_FULL))
                ==(VELOCITY_SPEED_100|VELOCITY_DUPLEX_FULL))
            r=2;
        else if ((mii_status & (VELOCITY_SPEED_10|VELOCITY_DUPLEX_FULL))
                ==(VELOCITY_SPEED_10|VELOCITY_DUPLEX_FULL))
            r=4;
        else if (mii_status & (VELOCITY_SPEED_100))
            r=1;
        else if (mii_status & (VELOCITY_SPEED_10))
            r=3;
        len=sprintf(buf,"%d",r);
        }
        break;
    case CONF_DMA_LEN:
        len=sprintf(buf,"%d",pInfo->hw.sOpts.DMA_length);
        break;
    case CONF_WOL_OPTS:
        len=sprintf(buf,"%d",pInfo->hw.sOpts.wol_opts);
        break;
    case CONF_FLOW_CTRL:
        len=sprintf(buf,"%d",pInfo->hw.sOpts.flow_cntl);
        break;
    case CONF_VAL_PKT:
        len=sprintf(buf,"%d",
            (pInfo->hw.flags & VELOCITY_FLAGS_VAL_PKT_LEN) ? 1 : 0);
        break;
    case CONF_ENABLE_MRDPL:
        len=sprintf(buf,"%d",
            (pInfo->hw.flags & VELOCITY_FLAGS_MRDPL) ? 1 : 0);
        break;
    case CONF_ENABLE_TAG:
        len=sprintf(buf,"%d",
            (pInfo->hw.flags & VELOCITY_FLAGS_TAGGING) ? 1 : 0);
        break;
    case CONF_VID_SETTING:
        len=sprintf(buf,"%d",pInfo->hw.sOpts.vid);
        break;
    }
    return len;
}

static int FunConfWrite(PVELOCITY_PROC_ENTRY pEntry, const char* buf,
    unsigned long len) {
    PVELOCITY_INFO pInfo=pEntry->pInfo;
    PROC_CONF_TYPE  op=pEntry->data;
    long l;

    l=atol(buf,len);
    if (l<0)
        return -EINVAL;

    switch(op) {
    case CONF_RX_DESC:
        if (pInfo->hw.flags & VELOCITY_FLAGS_OPENED)
            return -EACCES;
        if ((l<4)||(l>128))
            return -EINVAL;
        pInfo->hw.sOpts.nRxDescs=(l +3 ) & ~3 ;
        break;
    case CONF_TX_DESC:
        if (pInfo->hw.flags & VELOCITY_FLAGS_OPENED)
            return -EACCES;
        if ((l<16)||(l>128))
            return -EINVAL;
        pInfo->hw.sOpts.nTxDescs=l;
        break;

    case CONF_RX_THRESH:
        if ((l<0)||(l>7))
            return -EINVAL;
        pInfo->hw.sOpts.rx_thresh=l;
        mac_set_rx_thresh(&pInfo->hw,pInfo->hw.sOpts.rx_thresh);
        break;

    case CONF_SPD_DPX: {
        int new_status=0;

        switch(l) {
        case 0:
            new_status=VELOCITY_AUTONEG_ENABLE;
            break;
        case 1:
            new_status=VELOCITY_SPEED_100;
            break;
        case 2:
            new_status=VELOCITY_SPEED_100|VELOCITY_DUPLEX_FULL;
            break;
        case 3:
            new_status=VELOCITY_SPEED_10;
            break;
        case 4:
            new_status=VELOCITY_SPEED_10|VELOCITY_DUPLEX_FULL;
            break;
        }

        velocity_set_media_mode(&pInfo->hw,pInfo->hw.sOpts.spd_dpx);
        }
        break;

    case CONF_DMA_LEN:
        if ((l<0)||(l>7))
            return -EINVAL;
        pInfo->hw.sOpts.DMA_length=l;
        mac_set_dma_length(&pInfo->hw,pInfo->hw.sOpts.DMA_length);
        break;

    case CONF_WOL_OPTS:
        if ((l<0)||(l>16))
            return -EINVAL;
        pInfo->hw.sOpts.wol_opts=l;
        if (l==0)
            pInfo->hw.flags &=(~VELOCITY_FLAGS_WOL_ENABLED);
        else
            pInfo->hw.flags |=VELOCITY_FLAGS_WOL_ENABLED;
        break;

    case CONF_FLOW_CTRL:
        if (pInfo->hw.flags & VELOCITY_FLAGS_OPENED)
            return -EACCES;
        if ((l<1)||(l>3))
            return -EINVAL;
        pInfo->hw.sOpts.flow_cntl=l;
        break;

    case CONF_VAL_PKT:
        if (l==0) {
            pInfo->hw.flags &=~VELOCITY_FLAGS_VAL_PKT_LEN;
            pInfo->hw.sOpts.flags &=~VELOCITY_FLAGS_VAL_PKT_LEN;
        }
        else if (l==1) {
            pInfo->hw.flags |=VELOCITY_FLAGS_VAL_PKT_LEN;
            pInfo->hw.sOpts.flags |=VELOCITY_FLAGS_VAL_PKT_LEN;
        }
        else
            return -EINVAL;
        break;

    case CONF_ENABLE_MRDPL:
        if (l==0) {
            pInfo->hw.flags &= ~VELOCITY_FLAGS_MRDPL;
            pInfo->hw.sOpts.flags &= ~VELOCITY_FLAGS_VAL_PKT_LEN;
        }
        else if (l==1) {
            pInfo->hw.flags |= VELOCITY_FLAGS_MRDPL;
            pInfo->hw.sOpts.flags |= VELOCITY_FLAGS_MRDPL;
        }
        else
            return -EINVAL;
        break;
    case CONF_ENABLE_TAG:
        if (l==0) {
            pInfo->hw.flags &=~VELOCITY_FLAGS_TAGGING;
            pInfo->hw.sOpts.flags &=~VELOCITY_FLAGS_TAGGING;
        }
        else if (l==1) {
            pInfo->hw.flags |=VELOCITY_FLAGS_TAGGING;
            pInfo->hw.sOpts.flags |=VELOCITY_FLAGS_TAGGING;
        }
        else
            return -EINVAL;
        break;
    case CONF_VID_SETTING:
        if ((l<0) || (l>4094))
            return -EINVAL;
        pInfo->hw.sOpts.vid=l;
        pInfo->hw.flags |=VELOCITY_FLAGS_TAGGING;
        pInfo->hw.sOpts.flags |=VELOCITY_FLAGS_TAGGING;
        velocity_init_cam_filter(&pInfo->hw);

        break;
    }
    return 0;
}

static void velocity_UpdateRMONStats(PVELOCITY_INFO pInfo) {
    spin_lock_irq(&pInfo->lock);
    velocity_update_hw_mibs(&pInfo->hw);
    spin_unlock_irq(&pInfo->lock);
/*
    pInfo->adwRMONStats[RMON_DropEvents]
    pInfo->adwRMONStats[RMON_CRCAlignErrors]
    pInfo->adwRMONStats[RMON_UndersizePkts]
    pInfo->adwRMONStats[RMON_OversizePkts]
    pInfo->adwRMONStats[RMON_Fragments]
    pInfo->adwRMONStats[RMON_Jabbers]
    pInfo->adwRMONStats[RMON_Collisions]*/

    pInfo->adwRMONStats[RMON_MulticastPkts]
        =pInfo->stats.multicast;
    pInfo->adwRMONStats[RMON_Pkts]
        =pInfo->hw.adwHWMIBCounters[HW_MIB_ifRxAllPkts];
    pInfo->adwRMONStats[RMON_Pkts64Octets]
        =pInfo->hw.adwHWMIBCounters[HW_MIB_ifRx64Pkts];
    pInfo->adwRMONStats[RMON_Pkts65to127Octets]
        =pInfo->hw.adwHWMIBCounters[HW_MIB_ifRx65To127Pkts];
    pInfo->adwRMONStats[RMON_Pkts128to255Octets]
        =pInfo->hw.adwHWMIBCounters[HW_MIB_ifRx128To255Pkts];
    pInfo->adwRMONStats[RMON_Pkts256to511Octets]
        =pInfo->hw.adwHWMIBCounters[HW_MIB_ifRx256To511Pkts];
    pInfo->adwRMONStats[RMON_Pkts512to1023Octets]
        =pInfo->hw.adwHWMIBCounters[HW_MIB_ifRx512To1023Pkts];
    pInfo->adwRMONStats[RMON_Pkts1024to1518Octets]
        =pInfo->hw.adwHWMIBCounters[HW_MIB_ifRx1024To1518Pkts];

}

static int FunRMONRead(PVELOCITY_PROC_ENTRY pEntry,char* buf) {
    PVELOCITY_INFO     pInfo   =pEntry->pInfo;
    PROC_RMON_TYPE  op      =pEntry->data;
    int len=0;

    if (op<0 || op>RMON_TAB_SIZE)
        return -EINVAL;

    velocity_UpdateRMONStats(pInfo);
    len=sprintf(buf,"%d",pInfo->adwRMONStats[op]);
    return len;
}