drivers/staging/bcm/Bcmnet.c

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