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