ans.c

linux intel 网卡驱动,利用他可以让inel的pro 100 网卡进行网络配置和实用

**
**  Returns:    BD_ANS_STATUS -  SUCCESS if command was processed 
**                               successfully, FAILURE otherwise.
*/
BD_ANS_STATUS bd_ans_ActivateFastPolling(BOARD_PRIVATE_STRUCT *bps,
                                         iANSsupport_t *iANSdata)
{
    /* see if timer already active */
    if (iANSdata->timer_id != 0)
        return BD_ANS_SUCCESS;
    return (bd_ans_os_ActivateFastPolling(bps, iANSdata));
}

/* bd_ans_DeActivateFastPolling()
**
**  This function is called as part of an ANS IOCTL request to
**  disable status reporting or as part of a disconnect IOCTL request.
**  It will tell the driver that it no longer needs to keep updating
**  its status in the Watchdog routine.   
**
**  Arguments:  BOARD_PRIVATE_STRUCT *bps - a pointer to the adapters hw 
**                                          specific data structure.
**              iANSsupport_t *iANSdata   - pointer to the iANS required
**                                          support structure
**
**  Returns:    BD_ANS_STATUS -  SUCCESS if command was processed 
**                               successfully, FAILURE otherwise.
*/
BD_ANS_STATUS bd_ans_DeActivateFastPolling(BOARD_PRIVATE_STRUCT *bps,
                                           iANSsupport_t *iANSdata)
{
    /* if we have a non-zero timer_id, it means that we have
     * a watchdog routine going.
     */
    if (iANSdata->timer_id) {
        bd_ans_drv_StopWatchdog(bps);
        iANSdata->timer_id = 0;
    }    
    return (BD_ANS_SUCCESS);
}

/* bd_ans_SetReportingMode()
**
**  This function is called as part of an ANS ioctl request to start/stop
**  reporting status changes from the driver.  
**
**  Arguments:  BOARD_PRIVATE_STRUCT *bps - a pointer to the adapters hw 
**                                          specific data structure.
**              iANSsupport_t *iANSdata   - pointer to the iANS required
**                                          support structure
**              IANS_BD_PARAM_HEADER *header - a pointer to the start of the
**                                             ans command.
**
**  Returns:    BD_ANS_STATUS -  SUCCESS if command was processed 
**                               successfully, FAILURE otherwise.
*/
BD_ANS_STATUS bd_ans_SetReportingMode(BOARD_PRIVATE_STRUCT *bps, 
                                      iANSsupport_t *iANSdata,
                                      VOID *ans_buffer)
{
    BD_ANS_STATUS status;
    IANS_BD_PARAM_EXT_SET_MODE *iANSreport;
    iANSreport = (IANS_BD_PARAM_EXT_SET_MODE *)ans_buffer;

    DEBUGLOG1("bd_ans_SetReportingMode: %d\n",
        (iANSreport->BDIansStatusReport == IANS_REQUEST_SUPPORT));

    if (iANSreport->BDIansStatusReport == IANS_REQUEST_SUPPORT){
        status = bd_ans_ActivateFastPolling(bps, iANSdata);
        iANSdata->reporting_mode = IANS_STATUS_REPORTING_ON;
    } else {
        status = bd_ans_DeActivateFastPolling(bps, iANSdata);
        iANSdata->reporting_mode = IANS_STATUS_REPORTING_OFF;
    }

    return status;
}                                      

/* bd_ans_FillStatus()
**
**  This function is called both as part of an IOCTL request to get the
**  driver's current status, and as part of a Watchdog routine to compare
**  the current status to the previous status.  
**
**  Arguments:  BOARD_PRIVATE_STRUCT *bps - a pointer to the adapters hw 
**                                          specific data structure.
**              iANSsupport_t *iANSdata   - pointer to the iANS required
**                                          support structure
**              IANS_BD_PARAM_HEADER *header - a pointer to the start of the
**                                             ans command.
**
**  Returns:    BD_ANS_STATUS -  SUCCESS if command was processed 
**                               successfully, FAILURE otherwise.
*/                                      
BD_ANS_STATUS bd_ans_FillStatus(BOARD_PRIVATE_STRUCT *bps,
                                iANSsupport_t *iANSdata,
                                VOID *ans_buffer)
{
    IANS_BD_PARAM_STATUS *iANSstatus = (IANS_BD_PARAM_STATUS *)ans_buffer;

    DEBUGLOG("bd_ans_FillStatus: enter\n");

    /* tell iANS the supported version of this structure */
    iANSstatus->StatusVersion = IANS_STATUS_VERSION;

    /* all these support fields are initialized during the Identify request */
    /* check for link status */ 
    if (iANSdata->status_support_flags & BD_ANS_LINK_STATUS_SUPPORTED) {
        iANSstatus->LinkStatus  = *(iANSdata->link_status);

        if (iANSstatus->LinkStatus == IANS_STATUS_LINK_FAIL) {
            iANSstatus->LinkSpeed = IANS_STATUS_LINK_SPEED_NOT_SUPPORTED;
            iANSstatus->Duplex = IANS_STATUS_DUPLEX_NOT_SUPPORTED;
        } else {
            if (iANSdata->status_support_flags & BD_ANS_SPEED_STATUS_SUPPORTED) {
                switch(*(iANSdata->line_speed)) {
                case BD_ANS_10_MBPS:
                    iANSstatus->LinkSpeed = IANS_STATUS_LINK_SPEED_10MBPS;
                    break;
                case BD_ANS_100_MBPS:
                    iANSstatus->LinkSpeed = IANS_STATUS_LINK_SPEED_100MBPS;
                    break;
                case BD_ANS_1000_MBPS:
                    iANSstatus->LinkSpeed = IANS_STATUS_LINK_SPEED_1000MBPS;
                    break;
                default:
                    iANSstatus->LinkSpeed = IANS_STATUS_LINK_SPEED_NOT_SUPPORTED;
                    break;
                }
            } else {
                iANSstatus->LinkSpeed = IANS_STATUS_LINK_SPEED_NOT_SUPPORTED;
            }
            
            /* check for duplex status */   
            if (iANSdata->status_support_flags & BD_ANS_DUPLEX_STATUS_SUPPORTED) {          
                switch (*(iANSdata->duplex)) {
                case BD_ANS_DUPLEX_FULL:
                    iANSstatus->Duplex = IANS_STATUS_DUPLEX_FULL;
                    break;
                case BD_ANS_DUPLEX_HALF:
                    iANSstatus->Duplex = IANS_STATUS_DUPLEX_HALF;
                    break;
                default:
                    iANSstatus->Duplex = IANS_STATUS_DUPLEX_NOT_SUPPORTED;
                    break;
                }
            } else {
                iANSstatus->Duplex = IANS_STATUS_DUPLEX_NOT_SUPPORTED;
            }
        }
    
    } else {
        iANSstatus->LinkStatus = IANS_STATUS_LINK_NOT_SUPPORTED;
        iANSstatus->Duplex = IANS_STATUS_LINK_NOT_SUPPORTED;
        iANSstatus->LinkSpeed = IANS_STATUS_LINK_NOT_SUPPORTED;
    }

    /* check for hardware failure */
    if (iANSdata->status_support_flags & BD_ANS_HW_FAIL_STATUS_SUPPORTED) {
        iANSstatus->HardwareFailure =
            (*(iANSdata->hw_fail))?IANS_STATUS_HARDWARE_FAILURE:IANS_STATUS_HARDWARE_OK;
    } else {
        iANSstatus->HardwareFailure = IANS_STATUS_HARDWARE_NOT_SUPPORTED;
    }
    
    if (iANSdata->status_support_flags & BD_ANS_RESET_STATUS_SUPPORTED) {
        iANSstatus->DuringResetProcess = 
            (*(iANSdata->in_reset))?IANS_STATUS_DURING_RESET:IANS_STATUS_NOT_DURING_RESET;
    } else {
        iANSstatus->DuringResetProcess = IANS_STATUS_RESET_NOT_SUPPORTED;
    }
    
    /* check for suspended state */ 
    if (iANSdata->status_support_flags & BD_ANS_SUSPEND_STATUS_SUPPORTED) {
        iANSstatus->Suspended = 
            (*(iANSdata->suspended))?IANS_STATUS_SUSPENDED:IANS_STATUS_NOT_SUSPENDED; 
    } else {
        iANSstatus->Suspended = IANS_STATUS_SUSPENDED_NOT_SUPPORTED;
    }
    return (BD_ANS_SUCCESS);
}                                                                      

/* bd_ans_ResetAllModes()
**
**  This function is called as part of an ANS IOCTL request to disconnect  
**
**  Arguments:  BOARD_PRIVATE_STRUCT *bps - a pointer to the adapters hw 
**                                          specific data structure.
**              iANSsupport_t *iANSdata   - pointer to the iANS required
**                                          support structure
**
**  Returns:    BD_ANS_STATUS -  SUCCESS if command was processed 
**                               successfully, FAILURE otherwise.
*/                                                                     
BD_ANS_STATUS bd_ans_ResetAllModes(BOARD_PRIVATE_STRUCT *bps,
                                   iANSsupport_t *iANSdata)
{
    int i;

    DEBUGLOG("bd_ans_ResetAllModes: enter\n");
        
    /* in most cases I don't check the return values here because there isn't
     * much I can do about it if it fails 
     */
    (void)bd_ans_DeActivateFastPolling(bps, iANSdata);
    BD_ANS_BZERO((UCHAR *)&iANSdata->prev_status,sizeof(IANS_BD_PARAM_STATUS));
    
    /* set link to iANS as down  */
    iANSdata->iANS_status          = IANS_COMMUNICATION_DOWN;
    iANSdata->attributed_mode      = (UINT32) BD_ANS_FALSE;
    iANSdata->routing_mode         = IANS_ROUTING_OFF;
    
#ifdef IANS_BASE_VLAN_TAGGING
    /* need to reconfigure the adapter to disable tag mode */
    iANSdata->tag_mode             = IANS_BD_TAGGING_NONE;
    (void) bd_ans_drv_ConfigureTagging(bps);
    
    /* need to reconfigure the adapter to disable vlan mode */    
    iANSdata->vlan_mode = IANS_VLAN_MODE_OFF;
    (void) bd_ans_drv_ConfigureVlan(bps);
    
    /* need to reset the vlan filter table and configure the
     * adapter to disable vlan filtering 
     */
    iANSdata->vlan_filtering_mode = IANS_VLAN_FILTERING_OFF;
    iANSdata->num_vlan_filter = 0;
    for (i = 0; i < MAX_NUM_VLAN; i++) {
        iANSdata->VlanID[i] = 0;
    }
    (void) bd_ans_drv_ConfigureVlanTable(bps);
#endif

    return (BD_ANS_SUCCESS);
}

/* bd_ans_GetAllCapabilities()
**
**  This function is called as part of an ANS IOCTL request to get
**  open communication with the base driver (Identify).  It will
**  initialize all the support flags of the support structure.  
**
**  Arguments:  BOARD_PRIVATE_STRUCT *bps - a pointer to the adapters hw 
**                                          specific data structure.
**              iANSsupport_t *iANSdata   - pointer to the iANS required
**                                          support structure
**
**  Returns:    BD_ANS_STATUS -  SUCCESS if command was processed 
**                               successfully, FAILURE otherwise.
*/                                                                     

BD_ANS_STATUS bd_ans_GetAllCapabilities(BOARD_PRIVATE_STRUCT *bps,
                                        iANSsupport_t *iANSdata)
{
    /* get the OS specific capabilities */
    iANSdata->can_set_mac_addr = BD_ANS_OS_MAC_ADDR_SUPPORT;
    iANSdata->supports_stop_promiscuous = BD_ANS_OS_STOP_PROM_SUPPORT;
    
    /* get the Driver specific capabilities */
    iANSdata->status_support_flags = BD_ANS_DRV_STATUS_SUPPORT_FLAGS;
    iANSdata->max_vlan_ID_supported = BD_ANS_DRV_MAX_VLAN_ID(bps);
    iANSdata->vlan_table_size = BD_ANS_DRV_MAX_VLAN_TABLE_SIZE(bps);
    iANSdata->ISL_tag_support = BD_ANS_DRV_ISL_TAG_SUPPORT(bps);
    iANSdata->IEEE_tag_support = BD_ANS_DRV_IEEE_TAG_SUPPORT(bps);
    iANSdata->vlan_support =   BD_ANS_DRV_VLAN_SUPPORT(bps);
    iANSdata->vlan_filtering_support = BD_ANS_DRV_VLAN_FILTER_SUPPORT(bps);
    iANSdata->vlan_offload_support = BD_ANS_DRV_VLAN_OFFLOAD_SUPPORT(bps);
    
    /* get the hardware specific capabilities */
    iANSdata->available_speeds  = BD_ANS_HW_AVAILABLE_SPEEDS(bps);
    return (bd_ans_os_GetAllCapabilities(bps, iANSdata));
}                                        

/* bd_ans_Receive()
**
**  This function is called when the driver has been configured to
**  run in attributed mode (meaning we are attaching TLVs to each
**  packet).  It will perform the neccessary operations to create
**  the needed TLVs and attach them to the frame.  
**
**  Arguments:  BOARD_PRIVATE_STRUCT *bps - a pointer to the adapters hw 
**                                          specific data structure.
**              iANSSupport_t *iANSdata - pointer to ANS data structure.
**              HW_RX_DESCRIPTOR *rxd - pointer to hw dependent rx struct
**              FRAME_DATA *frame - pointer to an ethernet frame
**              OS_DATA *os_data - pointer to OS dependent frame data
**              OS_DATA **os_tlv - pointer to a pointer to the os structure
**                                 containing the tlv data.  This pointer is
**                                 modified by this routine.
**              UINT32 *tlv_list_length - pointer to the length of the
**                                      new tlv list.  This is modified
**                                      by this routine.  It is provided in 
**                                      case some OS needs to adjust the
**                                      length value in it's OS_DATA structure.
**
**  Returns:    BD_ANS_STATUS -  SUCCESS if command was processed 
**                               successfully, FAILURE otherwise.
*/                                                                     
BD_ANS_STATUS bd_ans_Receive(BOARD_PRIVATE_STRUCT *bps,
                             iANSsupport_t *iANSdata,
                             HW_RX_DESCRIPTOR *rxd,
                             FRAME_DATA *frame,
                             OS_DATA *os_frame_data,
                             OS_DATA **os_tlv,
                             UINT32 *tlv_list_length)
{
    BD_ANS_BOOLEAN Frame_is_tagged;
    peth_vlan_header_t peth_vlan_header =  (peth_vlan_header_t )frame;
    UINT16 tag;
    UINT32 tlvlist_length = 0; /* Total length of all TLVs */

    DEBUGLOG("bd_ans_Receive: enter\n");

#ifdef IANS_BASE_VLAN_TAGGING
    /* check to see if this is a qtag packet */
    
    Frame_is_tagged = bd_ans_IsQtagPacket(bps, iANSdata, rxd, peth_vlan_header);
    DEBUGLOG1("bd_ans_Receive: fram_is_tagged=%d\n", Frame_is_tagged);