gei82543end.c

intel 82543 千兆网卡 vxworks驱动源码

        case DRV_ETHER_GET_DUPLEX:
        case DRV_ETHER_GET_SPEED:
        case DRV_ETHER_SET_MAC_ADDRESS:
        case DRV_ETHER_ADD_MAC_MULTI_ADDRESS:
            if ((char*)NULL == data)
            {
                DRV_LOG (DRV_DEBUG_IOCTL, "gei82545EndIoctl OUT for data is not valid\n",1,2,3,4,5,6);
                return (ERROR);
            }
            break;
        default:
            break;
    }
    /*reading the general status register to get the status*/
    GEI_READ_REG(INTEL_82543GC_STATUS,statusregval);

    switch ((UINT32) cmd)
    {
        case DRV_GET_LINK_STATE:
            DRV_LOG (DRV_DEBUG_IOCTL, "gei82545EndIoctl GET LINK STATE \n",1,2,3,4,5,6);
            gei82543LinkStatusGet(pDrvCtrl);
            *((UINT32 *)data) = pDrvCtrl->linkStatus;
            break;

        case DRV_GET_TYPE_INFO:
            DRV_LOG (DRV_DEBUG_IOCTL, "gei82545EndIoctl GET TYPE INFO \n",1,2,3,4,5,6);
            if(GEI_FIBER_MEDIA==pDrvCtrl->cableType)
            {
                *((UINT32 *)data) = 2;
            }
            else
            {
                *((UINT32 *)data) = 1;
            }
            break;

        case DRV_ETHER_GET_DUPLEX:
            DRV_LOG (DRV_DEBUG_IOCTL, "gei82545EndIoctl GET DUPLEX \n",1,2,3,4,5,6);

            gei82543DuplexGet(pDrvCtrl);
            *((UINT32 *)data)=pDrvCtrl->duplex;

            DRV_LOG (DRV_DEBUG_IOCTL, "gei82545EndIoctl GET DUPLEX:%d\n",*((UINT32 *)data),2,3,4,5,6);
            break;
            
        case DRV_ETHER_GET_SPEED:
            DRV_LOG (DRV_DEBUG_IOCTL, "gei82545EndIoctl GET SPEED \n",1,2,3,4,5,6);

            gei82543SpeedGet(pDrvCtrl);
            *((UINT32 *)data)=pDrvCtrl->speed;
            
            DRV_LOG (DRV_DEBUG_IOCTL, "gei82545EndIoctl GET SPEED:%d\n",*((UINT32 *)data),2,3,4,5,6);
            break;

        case DRV_ETHER_SET_AUTO_NEGOTIATION:
            DRV_LOG (DRV_DEBUG_IOCTL, "gei82545EndIoctl SET AUTO-NEG \n",1,2,3,4,5,6);

            if(DRV_AUTO_NEGOTIATION_ENABLE == ((AUTO_NEGOTIATION_PARA)datatmp))
            {
                error=gei82543AutoNegoSet(pDrvCtrl,1);
            }
            else if(DRV_AUTO_NEGOTIATION_DISABLE == ((AUTO_NEGOTIATION_PARA)datatmp))
            {
                error=gei82543AutoNegoSet(pDrvCtrl,0);
            }
            else 
            {
                error=ERROR;
            }            
            break;


        case DRV_ETHER_SET_DUPLEX:
            DRV_LOG (DRV_DEBUG_IOCTL, "gei82545EndIoctl SET DUPLEX %d \n",(int)data,2,3,4,5,6);

            if(DRV_ETHER_SET_DUPLEX_FULL == ((ETHER_SET_DUPLEX_PARA)datatmp))
            {
                error=gei82543DuplexSet(pDrvCtrl,1);
            }
            else if(DRV_ETHER_SET_DUPLEX_HALF == ((ETHER_SET_DUPLEX_PARA)datatmp))
            {
                error=gei82543DuplexSet(pDrvCtrl,0);
            }
            else 
            {
                error=ERROR;
            }                        
            break;

        case DRV_ETHER_SET_SPEED:
            DRV_LOG (DRV_DEBUG_IOCTL, "gei82545EndIoctl SET SPEED...\n",1,2,3,4,5,6);
            if(DRV_ETHER_SET_SPEED_1000==((ETHER_SET_SPEED_PARA)datatmp))
            {
                error=gei82543SpeedSet(pDrvCtrl,1000);
            }
            else if(DRV_ETHER_SET_SPEED_100==((ETHER_SET_SPEED_PARA)datatmp))
            {
                error=gei82543SpeedSet(pDrvCtrl,100);
            }
            else if(DRV_ETHER_SET_SPEED_10==((ETHER_SET_SPEED_PARA)datatmp))
            {
                error=gei82543SpeedSet(pDrvCtrl,10);
            }
            else 
            {
                error=ERROR;
            }                        
            break;

        case DRV_ETHERNET_SET_LOOPBACK:
            DRV_LOG (DRV_DEBUG_IOCTL, "gei82545EndIoctl SET LOOPBACK %d \n",(int)data,2,3,4,5,6);
            if(DRV_ENABLE == ((DRV_STATUS)datatmp))
            {
                error=gei82543LoopBackSet(pDrvCtrl,1);
            }
            if(DRV_DISABLE == ((DRV_STATUS)datatmp))
            {
                error=gei82543LoopBackSet(pDrvCtrl,0);
            }
            DRV_LOG (DRV_DEBUG_IOCTL,"gei82545EndIoctl Set Loopback Done\n",1,2,3,4,5,6);
            break;

        case DRV_ETHER_PHY_SHUTDOWN:
            DRV_LOG (DRV_DEBUG_IOCTL, "gei82545EndIoctl SHUTDOWN %d \n",(int)data,2,3,4,5,6);
            if(DRV_DISABLE== ((DRV_STATUS)datatmp))/*shut down*/
            {
                error = gei82543ShutdownSet(pDrvCtrl,1);
            }
            else if(DRV_ENABLE== ((DRV_STATUS)datatmp))/*no shut down*/
            {
                error = gei82543ShutdownSet(pDrvCtrl,0);
            }
            else
            {
                error = ERROR;
            }
            break;

        case DRV_ETHER_SET_MAC_ADDRESS:/*consider get mac address?*/
            DRV_LOG (DRV_DEBUG_IOCTL,"gei82545EndIoctl SET MAC-ADDR\n",1,2,3,4,5,6);

            bcopy (data,(char *)&(pDrvCtrl->adaptor.enetAddr[0]),6);
            gei82543EtherRxAdrSet (pDrvCtrl, pDrvCtrl->adaptor.enetAddr, 0);
            DRV_LOG (DRV_DEBUG_IOCTL,"gei82545EndIoctl SET MAC-ADDR Done\n",1,2,3,4,5,6);
            return error;

        case DRV_ETHER_TRANSPORT_MODE_ENABLE:
            DRV_LOG (DRV_DEBUG_IOCTL,"gei82545EndIoctl TRANSPORT MODE ENABLE\n",1,2,3,4,5,6);

            reconfig=(int)pDrvCtrl->flags;
            if (!(reconfig &FLAG_PROMISC_MODE))
            {
                reconfig = 1;
                GEI_FLAG_SET(FLAG_PROMISC_MODE);
            }

            if (!(reconfig &FLAG_ALLMULTI_MODE))
            {
                reconfig = 1;
                GEI_FLAG_SET (FLAG_ALLMULTI_MODE);
            }

            if(!(reconfig &FLAG_MULTICAST_MODE))
            {
                reconfig=1;
                GEI_FLAG_SET(FLAG_MULTICAST_MODE);
            }

            if(!(reconfig &FLAG_BROADCAST_MODE))
            {
                reconfig=1;
                GEI_FLAG_SET(FLAG_BROADCAST_MODE);
            }

            if (1 ==reconfig )
            {
                gei82543EndConfigure(pDrvCtrl);
                DRV_LOG (DRV_DEBUG_IOCTL,"gei82545EndIoctl:TRANSPORT MODE ENABLE Done\n",1,2,3,4,5,6);
            }

            break;

        case DRV_ETHER_TRANSPORT_MODE_DISABLE:
            DRV_LOG (DRV_DEBUG_IOCTL,"gei82545EndIoctl TRANSPORT MODE DISABLE\n",1,2,3,4,5,6);

            reconfig=pDrvCtrl->flags;
            if (reconfig &FLAG_PROMISC_MODE)
            {
                reconfig = 1;
                GEI_FLAG_CLEAR(FLAG_PROMISC_MODE);
            }

            if (reconfig &FLAG_ALLMULTI_MODE)
            {
                reconfig = 1;
                GEI_FLAG_CLEAR (FLAG_ALLMULTI_MODE);
            }

            if(reconfig &FLAG_MULTICAST_MODE)
            {
                reconfig=1;
                GEI_FLAG_CLEAR(FLAG_MULTICAST_MODE);
            }

            if(reconfig &FLAG_BROADCAST_MODE)
            {
                reconfig=1;
                GEI_FLAG_CLEAR(FLAG_BROADCAST_MODE);
            }

            if (1==reconfig)
            {
                gei82543EndConfigure(pDrvCtrl);
                DRV_LOG (DRV_DEBUG_IOCTL,"gei82545EndIoctl:TRANSPORT MODE DISABLE Done\n",1,2,3,4,5,6);
            }

            break;

        case DRV_ETHER_ADD_MAC_MULTI_ADDRESS:/*consider delete or get the multi mac add?*/
            DRV_LOG (DRV_DEBUG_IOCTL,"gei82545EndIoctl ADD MAC-MULTI-ADDR\n",1,2,3,4,5,6);
            if (ERROR==(error=gei82543EndMCastAdd(pDrvCtrl,data)))
            {
                DRV_LOG(DRV_DEBUG_IOCTL,"gei82545EndIoctl gei82545EndMCastAdd error\n",1,2,3,4,5,6);
            }
            break;

        default:
            DRV_LOG (DRV_DEBUG_IOCTL, "invalid IOCTL command \n",1,2,3,4,5,6);
            break;
    }

    DRV_LOG (DRV_DEBUG_IOCTL, ("IOCTL command Done\n"), 0,0,0,0,0,0);
    return error;
}
/*************************************************************************
*
* gei82543EndConfigure - re-configure chip interface
*
* This routine re-configures the interface such as promisc, multicast
* and broadcast modes
*
* RETURNS: N/A.
*/
 void gei82543EndConfigure
    (
    END_DEVICE *    pDrvCtrl        /* device to configure */
    )
{
    int    oldVal;
    int    newVal;

    DRV_LOG (DRV_DEBUG_IOCTL, ("gei82543EndConfig...\n"), 1,2,3,4,5,6);

    /*(void)taskLock ();*/

    /* save flags for later use */
    oldVal = pDrvCtrl->flags;
#if 0
    newVal = END_FLAGS_GET((struct end_object *)&pDrvCtrl->drvObj);

    /* set the driver flag based on END_FLAGS */
    if (newVal & IFF_PROMISC)
    {
        pDrvCtrl->flags |= FLAG_PROMISC_MODE;
    }
    else
    {
        pDrvCtrl->flags &= ~FLAG_PROMISC_MODE;
    }

    if (newVal & IFF_ALLMULTI)
    {
        pDrvCtrl->flags |= FLAG_ALLMULTI_MODE;
    }
    else
    {
        pDrvCtrl->flags &= ~FLAG_ALLMULTI_MODE;
    }

    if (newVal & IFF_MULTICAST)
    {
        pDrvCtrl->flags |= FLAG_MULTICAST_MODE;
    }
    else
    {
        pDrvCtrl->flags &= ~FLAG_MULTICAST_MODE;
    }

    if (newVal & IFF_BROADCAST)
    {
        pDrvCtrl->flags |= FLAG_BROADCAST_MODE;
    }
    else
    {
        pDrvCtrl->flags &= ~FLAG_BROADCAST_MODE;
    }

    if (oldVal == (int)pDrvCtrl->flags)
    {
        (void)taskUnlock ();
        return;
    }
#endif
    /* read RX control register */
    GEI_READ_REG(INTEL_82543GC_RCTL, newVal);

    /* prepare new value for RX control register */
    if (pDrvCtrl->flags & FLAG_PROMISC_MODE)
    {
        newVal |= (RCTL_UPE_BIT | RCTL_MPE_BIT | RCTL_BAM_BIT);
    }
    else
    {
        newVal &= ~(RCTL_UPE_BIT | RCTL_MPE_BIT);
    }

    if (pDrvCtrl->flags & FLAG_ALLMULTI_MODE)
    {
        newVal |= RCTL_MPE_BIT;
    }

    else if (!(pDrvCtrl->flags & FLAG_PROMISC_MODE))
    {
        newVal &= ~RCTL_MPE_BIT;
    }

    if (pDrvCtrl->flags & FLAG_BROADCAST_MODE)
    {
        newVal |= RCTL_BAM_BIT;
    }

    else if (!(pDrvCtrl->flags & FLAG_PROMISC_MODE))
    {
        newVal &= ~RCTL_BAM_BIT;
    }

    /* set up RX control register if needed */
    if (newVal != oldVal)
    {
        GEI_WRITE_REG(INTEL_82543GC_RCTL, (UINT32)newVal);
    }

    pDrvCtrl->rxCtrlRegVal=(UINT32)newVal;
    
    /* set up Multicasting address */
    gei82543AddrFilterSet (pDrvCtrl);

    /*(void)taskUnlock ();*/

    DRV_LOG (DRV_DEBUG_IOCTL, ("gei82543EndConfig...Done\n"),
                                0, 0, 0, 0, 0, 0);
    return;
}

/*************************************************************************
*
* gei82543AddrFilterSet - set the address filter for multicast addresses
*
* This routine goes through all of the multicast addresses on the list
* of addresses (added with the endAddrAdd() routine) and sets the
* device's filter correctly.
*
* RETURNS: N/A.
*/

LOCAL void gei82543AddrFilterSet
    (
    END_DEVICE *pDrvCtrl    /* device to be updated */
    )
{
    ETHER_MULTI* pCurr;                      /* multi table address */
    int          count;                      /* number of multi address */
    int          i;                          /* index */
    int          col;                        /* column in MTA */
    int          row;                        /* row in MTA */
    int          tmp=0;                        /* temporary */