drivers/staging/bcm/Bcmnet.c

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