drivers/staging/bcm/Bcmnet.c

   1 #include "headers.h"
   2
   3 #define DRV_DESCRIPTION "Beceem Communications Inc. WiMAX driver"
   4 #define DRV_VERSION     "5.2.7.3P1"
   5 #define DRV_COPYRIGHT   "Copyright 2010. Beceem Communications Inc"
   6
   7 static INT bcm_notify_event(struct notifier_block *nb, ULONG event, PVOID dev)
   8 {
   9         struct net_device *ndev = (struct net_device*)dev;
  10     PMINI_ADAPTER Adapter = GET_BCM_ADAPTER(gblpnetdev);
  11         //PMINI_ADAPTER         Adapter = (PMINI_ADAPTER)ndev->priv;
  12         if(strncmp(ndev->name,gblpnetdev->name,5)==0)
  13         {
  14                 switch(event)
  15                 {
  16                         case NETDEV_CHANGEADDR:
  17                         case NETDEV_GOING_DOWN:
  18                                 /*ignore this */
  19                                         break;
  20                         case NETDEV_DOWN:
  21                                 break;
  22
  23                         case NETDEV_UP:
  24                                 break;
  25
  26                         case NETDEV_REGISTER:
  27                                  /* Increment the Reference Count for "veth0" */
  28                                  BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Register RefCount: %x\n",
  29                                                                         netdev_refcnt_read(ndev));
  30                                  dev_hold(ndev);
  31                                  break;
  32
  33                         case NETDEV_UNREGISTER:
  34                                  /* Decrement the Reference Count for "veth0" */
  35                                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Unregister RefCnt: %x\n",
  36                                                                         netdev_refcnt_read(ndev));
  37                                 dev_put(ndev);
  38                                 break;
  39                 };
  40         }
  41         return NOTIFY_DONE;
  42 }
  43
  44 /* Notifier block to receive netdevice events */
  45 static struct notifier_block bcm_notifier_block =
  46 {
  47         .notifier_call = bcm_notify_event,
  48 };
  49
  50 struct net_device *gblpnetdev;
  51 /***************************************************************************************/
  52 /* proto-type of lower function */
  53
  54 static INT bcm_open(struct net_device *dev)
  55 {
  56     PMINI_ADAPTER Adapter = NULL ; //(PMINI_ADAPTER)dev->priv;
  57         Adapter = GET_BCM_ADAPTER(dev);
  58     BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "======>");
  59     if(Adapter->fw_download_done==FALSE)
  60         return -EINVAL;
  61         Adapter->if_up=1;
  62         if(Adapter->LinkUpStatus == 1){
  63                 if(netif_queue_stopped(Adapter->dev)){
  64                         netif_carrier_on(Adapter->dev);
  65                         netif_start_queue(Adapter->dev);
  66                 }
  67         }
  68
  69         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "<======");
  70     return 0;
  71 }
  72
  73 static INT bcm_close(struct net_device *dev)
  74 {
  75    PMINI_ADAPTER Adapter = NULL ;//gpadapter ;
  76    Adapter = GET_BCM_ADAPTER(dev);
  77     BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "=====>");
  78         Adapter->if_up=0;
  79         if(!netif_queue_stopped(dev)) {
  80                 netif_carrier_off(dev);
  81             netif_stop_queue(dev);
  82         }
  83     BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL,"<=====");
  84     return 0;
  85 }
  86
  87 static struct net_device_stats *bcm_get_stats(struct net_device *dev)
  88 {
  89     PLINUX_DEP_DATA pLinuxData=NULL;
  90         PMINI_ADAPTER Adapter = NULL ;// gpadapter ;
  91         Adapter = GET_BCM_ADAPTER(dev);
  92     pLinuxData = (PLINUX_DEP_DATA)(Adapter->pvOsDepData);
  93
  94     //BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Dev = %p, pLinuxData = %p", dev, pLinuxData);
  95         pLinuxData->netstats.rx_packets=atomic_read(&Adapter->RxRollOverCount)*64*1024+Adapter->PrevNumRecvDescs;
  96         pLinuxData->netstats.rx_bytes=atomic_read(&Adapter->GoodRxByteCount)+atomic_read(&Adapter->BadRxByteCount);
  97         pLinuxData->netstats.rx_dropped=atomic_read(&Adapter->RxPacketDroppedCount);
  98         pLinuxData->netstats.rx_errors=atomic_read(&Adapter->RxPacketDroppedCount);
  99         pLinuxData->netstats.rx_length_errors=0;
 100         pLinuxData->netstats.rx_frame_errors=0;
 101         pLinuxData->netstats.rx_crc_errors=0;
 102         pLinuxData->netstats.tx_bytes=atomic_read(&Adapter->GoodTxByteCount);
 103         pLinuxData->netstats.tx_packets=atomic_read(&Adapter->TxTotalPacketCount);
 104         pLinuxData->netstats.tx_dropped=atomic_read(&Adapter->TxDroppedPacketCount);
 105
 106     return &(pLinuxData->netstats);
 107 }
 108 /**
 109 @ingroup init_functions
 110 Register other driver entry points with the kernel
 111 */
 112 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 29)
 113 static struct net_device_ops bcmNetDevOps = {
 114     .ndo_open           = bcm_open,
 115     .ndo_stop           = bcm_close,
 116     .ndo_get_stats      = bcm_get_stats,
 117     .ndo_start_xmit     = bcm_transmit,
 118     .ndo_change_mtu     = eth_change_mtu,
 119     .ndo_set_mac_address = eth_mac_addr,
 120     .ndo_validate_addr  = eth_validate_addr,
 121 };
 122 #endif
 123
 124 int register_networkdev(PMINI_ADAPTER Adapter)
 125 {
 126         int result=0;
 127 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
 128         void **temp = NULL; /* actually we're *allocating* the device in alloc_etherdev */
 129 #endif
 130         Adapter->dev = alloc_etherdev(sizeof(PMINI_ADAPTER));
 131         if(!Adapter->dev)
 132         {
 133                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "ERR: No Dev");
 134                 return -ENOMEM;
 135         }
 136         gblpnetdev                                                      = Adapter->dev;
 137 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27)
 138         Adapter->dev->priv                              = Adapter;
 139 #else
 140         temp = netdev_priv(Adapter->dev);
 141         *temp = (void *)Adapter;
 142 #endif
 143         //BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "init adapterptr: %x %x\n", (UINT)Adapter, temp);
 144
 145 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 29)
 146         Adapter->dev->netdev_ops                = &bcmNetDevOps;
 147 #else
 148         Adapter->dev->open                              = bcm_open;
 149         Adapter->dev->stop                      = bcm_close;
 150         Adapter->dev->get_stats                 = bcm_get_stats;
 151         Adapter->dev->hard_start_xmit           = bcm_transmit;
 152         Adapter->dev->hard_header_len           = ETH_HLEN + LEADER_SIZE;
 153 #endif
 154
 155         Adapter->dev->mtu                                       = MTU_SIZE; /* 1400 Bytes */
 156         /* Read the MAC Address from EEPROM */
 157         ReadMacAddressFromNVM(Adapter);
 158
 159
 160         /* Register the notifier block for getting netdevice events */
 161         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Registering netdevice notifier\n");
 162         result = register_netdevice_notifier(&bcm_notifier_block);
 163         if(result)
 164         {
 165                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "BCM Notifier Block did not get registered");
 166                 Adapter->bNetdeviceNotifierRegistered = FALSE;
 167                 return result;
 168         }
 169         else
 170         {
 171                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "BCM Notifier got Registered");
 172                 Adapter->bNetdeviceNotifierRegistered = TRUE;
 173         }
 174
 175
 176         result = register_netdev(Adapter->dev);
 177         if (!result)
 178         {
 179                 Adapter->bNetworkInterfaceRegistered = TRUE ;
 180                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Beceem Network device name is %s!", Adapter->dev->name);
 181         }
 182         else
 183         {
 184         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Network device can not be registered!");
 185                 Adapter->bNetworkInterfaceRegistered = FALSE ;
 186                 return result;
 187         }
 188
 189 #if 0
 190  Adapter->stDebugState.debug_level = DBG_LVL_CURR;
 191  Adapter->stDebugState.type =(UINT)0xffffffff;
 192  Adapter->stDebugState.subtype[DBG_TYPE_OTHERS] = 0xffffffff;
 193  Adapter->stDebugState.subtype[DBG_TYPE_RX] = 0xffffffff;
 194  Adapter->stDebugState.subtype[DBG_TYPE_TX] = 0xffffffff;
 195  Adapter->stDebugState.subtype[DBG_TYPE_INITEXIT] = 0xffffffff;
 196
 197  printk("-------ps_adapter->stDebugState.type=%x\n",Adapter->stDebugState.type);
 198  printk("-------ps_adapter->stDebugState.subtype[DBG_TYPE_OTHERS]=%x\n",Adapter->stDebugState.subtype[DBG_TYPE_OTHERS]);
 199  printk("-------ps_adapter->stDebugState.subtype[DBG_TYPE_RX]=%x\n",Adapter->stDebugState.subtype[DBG_TYPE_RX]);
 200  printk("-------ps_adapter->stDebugState.subtype[DBG_TYPE_TX]=%x\n",Adapter->stDebugState.subtype[DBG_TYPE_TX]);
 201 #endif
 202
 203         return 0;
 204 }
 205
 206 void bcm_unregister_networkdev(PMINI_ADAPTER Adapter)
 207 {
 208         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Unregistering the Net Dev...\n");
 209         if(Adapter->dev && !IS_ERR(Adapter->dev) && Adapter->bNetworkInterfaceRegistered)
 210                 unregister_netdev(Adapter->dev);
 211                 /* Unregister the notifier block */
 212         if(Adapter->bNetdeviceNotifierRegistered == TRUE)
 213         {
 214         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Unregistering netdevice notifier\n");
 215                         unregister_netdevice_notifier(&bcm_notifier_block);
 216   }
 217 }
 218
 219 static int bcm_init(void)
 220 {
 221         printk(KERN_INFO "%s, %s\n", DRV_DESCRIPTION, DRV_VERSION);
 222         printk(KERN_INFO "%s\n", DRV_COPYRIGHT);
 223
 224         return InterfaceInitialize();
 225 }
 226
 227
 228 static void bcm_exit(void)
 229 {
 230         InterfaceExit();
 231 }
 232
 233 module_init(bcm_init);
 234 module_exit(bcm_exit);
 235
 236 MODULE_DESCRIPTION(DRV_DESCRIPTION);
 237 MODULE_VERSION(DRV_VERSION);
 238 MODULE_LICENSE ("GPL");
 239