drivers/staging/bcm/Bcmnet.c

   1 #include "headers.h"
   2
   3 struct net_device *gblpnetdev;
   4 /***************************************************************************************/
   5 /* proto-type of lower function */
   6
   7 static INT bcm_open(struct net_device *dev)
   8 {
   9     PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(dev);
  10
  11     BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "======>");
  12     if(Adapter->fw_download_done==FALSE)
  13         return -EINVAL;
  14         if(Adapter->LinkUpStatus == 1){
  15                 if(netif_queue_stopped(Adapter->dev)){
  16                         netif_carrier_on(Adapter->dev);
  17                         netif_start_queue(Adapter->dev);
  18                 }
  19         }
  20
  21         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "<======");
  22     return 0;
  23 }
  24
  25 static INT bcm_close(struct net_device *dev)
  26 {
  27    PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(dev);
  28
  29     BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "=====>");
  30         if(!netif_queue_stopped(dev)) {
  31                 netif_carrier_off(dev);
  32             netif_stop_queue(dev);
  33         }
  34     BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL,"<=====");
  35     return 0;
  36 }
  37
  38 static struct net_device_stats *bcm_get_stats(struct net_device *dev)
  39 {
  40         PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(dev);
  41         struct net_device_stats*        netstats = &dev->stats;
  42
  43         netstats->rx_packets = atomic_read(&Adapter->RxRollOverCount)*64*1024
  44                 + Adapter->PrevNumRecvDescs;
  45         netstats->rx_bytes = atomic_read(&Adapter->GoodRxByteCount)
  46                 + atomic_read(&Adapter->BadRxByteCount);
  47
  48         netstats->rx_dropped = atomic_read(&Adapter->RxPacketDroppedCount);
  49         netstats->rx_errors  = atomic_read(&Adapter->RxPacketDroppedCount);
  50         netstats->tx_bytes   = atomic_read(&Adapter->GoodTxByteCount);
  51         netstats->tx_packets = atomic_read(&Adapter->TxTotalPacketCount);
  52         netstats->tx_dropped = atomic_read(&Adapter->TxDroppedPacketCount);
  53
  54         return netstats;
  55 }
  56
  57 /**
  58 @ingroup init_functions
  59 Register other driver entry points with the kernel
  60 */
  61 static const struct net_device_ops bcmNetDevOps = {
  62     .ndo_open           = bcm_open,
  63     .ndo_stop           = bcm_close,
  64     .ndo_get_stats      = bcm_get_stats,
  65     .ndo_start_xmit     = bcm_transmit,
  66     .ndo_change_mtu     = eth_change_mtu,
  67     .ndo_set_mac_address = eth_mac_addr,
  68     .ndo_validate_addr  = eth_validate_addr,
  69 };
  70
  71 static struct device_type wimax_type = {
  72         .name   = "wimax",
  73 };
  74
  75 static int bcm_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
  76 {
  77         cmd->supported          = 0;
  78         cmd->advertising        = 0;
  79         cmd->speed              = SPEED_10000;
  80         cmd->duplex             = DUPLEX_FULL;
  81         cmd->port               = PORT_TP;
  82         cmd->phy_address        = 0;
  83         cmd->transceiver        = XCVR_INTERNAL;
  84         cmd->autoneg            = AUTONEG_DISABLE;
  85         cmd->maxtxpkt           = 0;
  86         cmd->maxrxpkt           = 0;
  87         return 0;
  88 }
  89
  90 static void bcm_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
  91 {
  92         PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(dev);
  93         PS_INTERFACE_ADAPTER psIntfAdapter = Adapter->pvInterfaceAdapter;
  94         struct usb_device *udev = interface_to_usbdev(psIntfAdapter->interface);
  95
  96         strcpy(info->driver, DRV_NAME);
  97         strcpy(info->version, DRV_VERSION);
  98         snprintf(info->fw_version, sizeof(info->fw_version), "%u.%u",
  99                  Adapter->uiFlashLayoutMajorVersion,
 100                  Adapter->uiFlashLayoutMinorVersion);
 101
 102         usb_make_path(udev, info->bus_info, sizeof(info->bus_info));
 103 }
 104
 105 static u32 bcm_get_link(struct net_device *dev)
 106 {
 107         PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(dev);
 108
 109         return Adapter->LinkUpStatus;
 110 }
 111
 112 static const struct ethtool_ops bcm_ethtool_ops = {
 113         .get_settings   = bcm_get_settings,
 114         .get_drvinfo    = bcm_get_drvinfo,
 115         .get_link       = bcm_get_link,
 116 };
 117
 118 int register_networkdev(PMINI_ADAPTER Adapter)
 119 {
 120         struct net_device *net = Adapter->dev;
 121         int result;
 122
 123         net->netdev_ops = &bcmNetDevOps;
 124         net->ethtool_ops = &bcm_ethtool_ops;
 125         net->mtu          = MTU_SIZE; /* 1400 Bytes */
 126         net->tx_queue_len = TX_QLEN;
 127         net->flags |= IFF_NOARP;
 128         net->flags &= ~(IFF_BROADCAST|IFF_MULTICAST);
 129
 130         netif_carrier_off(net);
 131
 132         SET_NETDEV_DEVTYPE(net, &wimax_type);
 133
 134         /* Read the MAC Address from EEPROM */
 135         ReadMacAddressFromNVM(Adapter);
 136
 137         result = register_netdev(net);
 138         if (result == 0)
 139                 gblpnetdev = Adapter->dev = net;
 140         else {
 141                 Adapter->dev = NULL;
 142                 free_netdev(net);
 143         }
 144
 145         return result;
 146 }
 147
 148 static int bcm_init(void)
 149 {
 150         printk(KERN_INFO "%s, %s\n", DRV_DESCRIPTION, DRV_VERSION);
 151         printk(KERN_INFO "%s\n", DRV_COPYRIGHT);
 152
 153         return InterfaceInitialize();
 154 }
 155
 156
 157 static void bcm_exit(void)
 158 {
 159         InterfaceExit();
 160 }
 161
 162 module_init(bcm_init);
 163 module_exit(bcm_exit);
 164
 165 MODULE_DESCRIPTION(DRV_DESCRIPTION);
 166 MODULE_VERSION(DRV_VERSION);
 167 MODULE_LICENSE ("GPL");
 168