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 #ifdef BCM_SHM_INTERFACE
  54 const char *bcmVirtDeviceName="bcmeth";
  55 #endif
  56
  57 static INT bcm_open(struct net_device *dev)
  58 {
  59     PMINI_ADAPTER Adapter = NULL ; //(PMINI_ADAPTER)dev->priv;
  60         Adapter = GET_BCM_ADAPTER(dev);
  61     BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "======>");
  62     if(Adapter->fw_download_done==FALSE)
  63         return -EINVAL;
  64         Adapter->if_up=1;
  65         if(Adapter->LinkUpStatus == 1){
  66                 if(netif_queue_stopped(Adapter->dev)){
  67                         netif_carrier_on(Adapter->dev);
  68                         netif_start_queue(Adapter->dev);
  69                 }
  70         }
  71
  72         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "<======");
  73     return 0;
  74 }
  75
  76 static INT bcm_close(struct net_device *dev)
  77 {
  78    PMINI_ADAPTER Adapter = NULL ;//gpadapter ;
  79    Adapter = GET_BCM_ADAPTER(dev);
  80     BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "=====>");
  81         Adapter->if_up=0;
  82         if(!netif_queue_stopped(dev)) {
  83                 netif_carrier_off(dev);
  84             netif_stop_queue(dev);
  85         }
  86     BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL,"<=====");
  87     return 0;
  88 }
  89
  90 static struct net_device_stats *bcm_get_stats(struct net_device *dev)
  91 {
  92     PLINUX_DEP_DATA pLinuxData=NULL;
  93         PMINI_ADAPTER Adapter = NULL ;// gpadapter ;
  94         Adapter = GET_BCM_ADAPTER(dev);
  95     pLinuxData = (PLINUX_DEP_DATA)(Adapter->pvOsDepData);
  96
  97     //BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Dev = %p, pLinuxData = %p", dev, pLinuxData);
  98         pLinuxData->netstats.rx_packets=atomic_read(&Adapter->RxRollOverCount)*64*1024+Adapter->PrevNumRecvDescs;
  99         pLinuxData->netstats.rx_bytes=atomic_read(&Adapter->GoodRxByteCount)+atomic_read(&Adapter->BadRxByteCount);
 100         pLinuxData->netstats.rx_dropped=atomic_read(&Adapter->RxPacketDroppedCount);
 101         pLinuxData->netstats.rx_errors=atomic_read(&Adapter->RxPacketDroppedCount);
 102         pLinuxData->netstats.rx_length_errors=0;
 103         pLinuxData->netstats.rx_frame_errors=0;
 104         pLinuxData->netstats.rx_crc_errors=0;
 105         pLinuxData->netstats.tx_bytes=atomic_read(&Adapter->GoodTxByteCount);
 106         pLinuxData->netstats.tx_packets=atomic_read(&Adapter->TxTotalPacketCount);
 107         pLinuxData->netstats.tx_dropped=atomic_read(&Adapter->TxDroppedPacketCount);
 108
 109     return &(pLinuxData->netstats);
 110 }
 111 /**
 112 @ingroup init_functions
 113 Register other driver entry points with the kernel
 114 */
 115 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 29)
 116 static struct net_device_ops bcmNetDevOps = {
 117     .ndo_open           = bcm_open,
 118     .ndo_stop           = bcm_close,
 119     .ndo_get_stats      = bcm_get_stats,
 120     .ndo_start_xmit     = bcm_transmit,
 121     .ndo_change_mtu     = eth_change_mtu,
 122     .ndo_set_mac_address = eth_mac_addr,
 123     .ndo_validate_addr  = eth_validate_addr,
 124 };
 125 #endif
 126
 127 int register_networkdev(PMINI_ADAPTER Adapter)
 128 {
 129         int result=0;
 130 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
 131         void **temp = NULL; /* actually we're *allocating* the device in alloc_etherdev */
 132 #endif
 133         Adapter->dev = alloc_etherdev(sizeof(PMINI_ADAPTER));
 134         if(!Adapter->dev)
 135         {
 136                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "ERR: No Dev");
 137                 return -ENOMEM;
 138         }
 139         gblpnetdev                                                      = Adapter->dev;
 140 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27)
 141         Adapter->dev->priv                              = Adapter;
 142 #else
 143         temp = netdev_priv(Adapter->dev);
 144         *temp = (void *)Adapter;
 145 #endif
 146         //BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "init adapterptr: %x %x\n", (UINT)Adapter, temp);
 147
 148 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 29)
 149         Adapter->dev->netdev_ops                = &bcmNetDevOps;
 150 #else
 151         Adapter->dev->open                              = bcm_open;
 152         Adapter->dev->stop                      = bcm_close;
 153         Adapter->dev->get_stats                 = bcm_get_stats;
 154         Adapter->dev->hard_start_xmit           = bcm_transmit;
 155         Adapter->dev->hard_header_len           = ETH_HLEN + LEADER_SIZE;
 156 #endif
 157
 158 #ifndef BCM_SHM_INTERFACE
 159         Adapter->dev->mtu                                       = MTU_SIZE; /* 1400 Bytes */
 160         /* Read the MAC Address from EEPROM */
 161         ReadMacAddressFromNVM(Adapter);
 162
 163
 164         /* Register the notifier block for getting netdevice events */
 165         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Registering netdevice notifier\n");
 166         result = register_netdevice_notifier(&bcm_notifier_block);
 167         if(result)
 168         {
 169                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "BCM Notifier Block did not get registered");
 170                 Adapter->bNetdeviceNotifierRegistered = FALSE;
 171                 return result;
 172         }
 173         else
 174         {
 175                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "BCM Notifier got Registered");
 176                 Adapter->bNetdeviceNotifierRegistered = TRUE;
 177         }
 178
 179 #else
 180
 181         Adapter->dev->mtu                       = CPE_MTU_SIZE;
 182
 183 #if 0
 184         //for CPE - harcode the virtual mac address
 185         Adapter->dev->dev_addr[0] =  MII_WIMAX_MACADDRESS[0];
 186         Adapter->dev->dev_addr[1] =  MII_WIMAX_MACADDRESS[1];
 187         Adapter->dev->dev_addr[2] =  MII_WIMAX_MACADDRESS[2];
 188         Adapter->dev->dev_addr[3] =  MII_WIMAX_MACADDRESS[3];
 189         Adapter->dev->dev_addr[4] =  MII_WIMAX_MACADDRESS[4];
 190         Adapter->dev->dev_addr[5] =  MII_WIMAX_MACADDRESS[5];
 191 #else
 192         ReadMacAddressFromNVM(Adapter);
 193 #endif
 194         strcpy(Adapter->dev->name, bcmVirtDeviceName); //Copy the device name
 195
 196 #endif
 197
 198         result = register_netdev(Adapter->dev);
 199         if (!result)
 200         {
 201                 Adapter->bNetworkInterfaceRegistered = TRUE ;
 202                 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Beceem Network device name is %s!", Adapter->dev->name);
 203         }
 204         else
 205         {
 206         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Network device can not be registered!");
 207                 Adapter->bNetworkInterfaceRegistered = FALSE ;
 208                 return result;
 209         }
 210
 211 #if 0
 212  Adapter->stDebugState.debug_level = DBG_LVL_CURR;
 213  Adapter->stDebugState.type =(UINT)0xffffffff;
 214  Adapter->stDebugState.subtype[DBG_TYPE_OTHERS] = 0xffffffff;
 215  Adapter->stDebugState.subtype[DBG_TYPE_RX] = 0xffffffff;
 216  Adapter->stDebugState.subtype[DBG_TYPE_TX] = 0xffffffff;
 217  Adapter->stDebugState.subtype[DBG_TYPE_INITEXIT] = 0xffffffff;
 218
 219  printk("-------ps_adapter->stDebugState.type=%x\n",Adapter->stDebugState.type);
 220  printk("-------ps_adapter->stDebugState.subtype[DBG_TYPE_OTHERS]=%x\n",Adapter->stDebugState.subtype[DBG_TYPE_OTHERS]);
 221  printk("-------ps_adapter->stDebugState.subtype[DBG_TYPE_RX]=%x\n",Adapter->stDebugState.subtype[DBG_TYPE_RX]);
 222  printk("-------ps_adapter->stDebugState.subtype[DBG_TYPE_TX]=%x\n",Adapter->stDebugState.subtype[DBG_TYPE_TX]);
 223 #endif
 224
 225         return 0;
 226 }
 227
 228 void bcm_unregister_networkdev(PMINI_ADAPTER Adapter)
 229 {
 230         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Unregistering the Net Dev...\n");
 231         if(Adapter->dev && !IS_ERR(Adapter->dev) && Adapter->bNetworkInterfaceRegistered)
 232                 unregister_netdev(Adapter->dev);
 233                 /* Unregister the notifier block */
 234         if(Adapter->bNetdeviceNotifierRegistered == TRUE)
 235         {
 236         BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Unregistering netdevice notifier\n");
 237                         unregister_netdevice_notifier(&bcm_notifier_block);
 238   }
 239 }
 240
 241 static int bcm_init(void)
 242 {
 243         printk(KERN_INFO "%s, %s\n", DRV_DESCRIPTION, DRV_VERSION);
 244         printk(KERN_INFO "%s\n", DRV_COPYRIGHT);
 245
 246         return InterfaceInitialize();
 247 }
 248
 249
 250 static void bcm_exit(void)
 251 {
 252         InterfaceExit();
 253 }
 254
 255 module_init(bcm_init);
 256 module_exit(bcm_exit);
 257
 258 MODULE_DESCRIPTION(DRV_DESCRIPTION);
 259 MODULE_VERSION(DRV_VERSION);
 260 MODULE_LICENSE ("GPL");
 261