nsmos.c

NATIONAL公司DP83816芯片Linux下驱动

      case SIOCGMIIPHY    :
                             // Get the Phy Addr Index
                             data->phy_id = 
                                  MplPhyGetDeviceAddr(adapter->mplContext);
                             // Fall thru

      case SIOCGMIIREG    :
                             // Read MII register
                             data->val_out = 
                                   MplPhyMdioRead(adapter->mplContext,
                                                   data->phy_id & 0x1F,
                                                   data->reg_num & 0x1F);
                             break;

      case SIOCSMIIREG    :
                             if (!capable(CAP_NET_ADMIN))
                             {
                                ret = -EPERM;
                             }
                             else
                             {
                                // Write MII register
                                 MplPhyMdioWrite(adapter->mplContext,
                                                   data->phy_id & 0x1F,
                                                   data->reg_num & 0x1F,
                                                   data->val_in);
                             }
                             break;

      default             :    
                             adapter = NULL;
                             ret = -EPERM;
    }

   // NO(NsmIoctl);
   return ret;
}


NS_SINT
NsmChangeMtu(struct net_device *netdev, int new_mtu)
{
//FM: Need to validate with MPL CAPS
   NO(NsmChangeMtu);

   NO(NsmChangeMtu);
   return 0x0;
}

#ifdef L26
NS_SINT
#else
NS_VOID
#endif
NsmIsr(NS_SINT irq, void *data, struct pt_regs *regs)
{
   NSM_CONTEXT *adapter = (NSM_CONTEXT *)data;
   NS_UINT fragsConsumed = 0x0;

   // Check if there are pending interrupts
   if (MplInterruptCheck(adapter->mplContext) == NS_STATUS_SUCCESS)
   {
      // Check if we have receive events
      if (MplInterruptCheckReceive(adapter->mplContext) == NS_STATUS_SUCCESS)
      {
         // Let MPL process this receive
         spin_lock(&adapter->rxLock);
         MplReceive(adapter->mplContext, 0x0, &fragsConsumed);
         spin_unlock(&adapter->rxLock);

         adapter->rxdEmpty += fragsConsumed;

         // We need to continously replenish the Rx engine with 
         //  new buffers - Check it is time to do so
         if (adapter->rxdEmpty >= (adapter->rxdCnt / NSM_DEFAULT_RX_REPL))
         {
            spin_lock(&adapter->rxLock);
            replenishTask((unsigned long)adapter);
            spin_unlock(&adapter->rxLock);

            // Rxds that are empty should be zero now!
            adapter->rxdEmpty = 0x0;
         }
      }

      // Check if we have transmit events
      if (MplInterruptCheckTransmit(adapter->mplContext) == NS_STATUS_SUCCESS)
      {
         spin_lock(&adapter->txLock);
         MplTransmitDone(adapter->mplContext, 0x0);
         spin_unlock(&adapter->txLock);
      }

      // Check if we have internal events
      if (MplInterruptCheckInternal(adapter->mplContext) == NS_STATUS_SUCCESS)
      {
         MplInterruptDoneInternal(adapter->mplContext, 0x0);
      }

      // Re-Enable Interrupts
      MplInterruptEnable(adapter->mplContext);

#ifdef L26
      return IRQ_HANDLED;
#else
      return; 
#endif
   }
   else
   {
#ifdef L26
      return IRQ_NONE;
#else
      return; 
#endif
   }
}

NS_SINT
NsmClose(struct net_device *netdev)
{
   NSM_CONTEXT *adapter = (NSM_CONTEXT *) netdev->priv;

   NI(NsmClose);

   // Stop the Net Stack - Just in case
   netif_carrier_off(netdev);
   netif_stop_queue(netdev);

   // Disable Interrupts - Doing this for load-only mode too?
   MplInterruptDisable(adapter->mplContext);

   // Stop link monitoring
   if (adapter->opMode != MPL_MODE_LOAD_ONLY)
   {
      // Kill Link Monitoring Tasklet
      tasklet_kill(&adapter->linkMonTask);
   }

   // Reset Transmit Engine - To get back pending fragments
   spin_lock_irq(&adapter->txLock);
   MplTransmitReset(adapter->mplContext);
   spin_unlock_irq(&adapter->txLock);

   // Reset Receive Engine - To get back pending fragments
   spin_lock_irq(&adapter->rxLock);
   MplReceiveReset(adapter->mplContext);
   spin_unlock_irq(&adapter->rxLock);

#ifdef NSM_DIAG_MODE
   // UnInitialize Diag Module
   if (adapter->opMode != MPL_MODE_NORMAL)
   {
      NsmDiagUnInitialize(adapter);
   }
#endif //NSM_DIAG_MODE

   // Free the MPL Pkt Fragments 
   freeRxFrags(adapter);

   // Close MPL
   MplClose(adapter->mplContext);

   //Task Offloads Diables
   // Rx Filter (Multicast and Unicast Filtering)
   MplTaskFilterCfg(adapter->mplContext, NS_FALSE);

   // Release Interrupt
   free_irq(netdev->irq, adapter);

   NO(NsmClose);
   return 0x0;
}


// Local Functions

static NS_VOID 
readPciInfo(NSM_CONTEXT *adapter)
{
   struct pci_dev *pdev = adapter->pdev;
   
   NI(readPciInfo);

   pci_read_config_byte(pdev, PCI_REVISION_ID, &adapter->pciRevId);
   pci_read_config_word(pdev, PCI_SUBSYSTEM_VENDOR_ID,
                             &adapter->pciSubVendorId);
   pci_read_config_word(pdev, PCI_SUBSYSTEM_ID, &adapter->pciSubDeviceId);

   NO(readPciInfo);
   return;
}

static NS_VOID 
setDataFields(NSM_CONTEXT *adapter)
{
   struct net_device *netdev = adapter->netdev;

   NI(setDataFields);

   // The rx buffer size
   if (netdev->mtu <= ENET_MTU)
   {
      adapter->rxBufferLen = ENET_BUFFER_SIZE; 
   }
   else
   {
      adapter->rxBufferLen = netdev->mtu + 32; 
   }

#ifdef NSM_DIAG_MODE
   // Make Tx buffer length same as Rx
   adapter->txBufferLen = adapter->rxBufferLen; 
#endif
  
   // Note the MTU ..include the Eth Hdr size and CRC len also
   adapter->mtu = netdev->mtu + ENET_HEADER_SIZE + CRC_LENGTH;

   NO(setDataFields);
   return;
}

static NS_VOID 
readUserOptions(NSM_CONTEXT *adapter)
{
   NI(readUserOptions);

   // Transmit Descriptor Count
   if (TxDCnt[NsmAdapterCnt] != -1) 
   {
      adapter->txdCnt = TxDCnt[NsmAdapterCnt];
   }
   else
   {
      adapter->txdCnt = NSM_DEFAULT_TXD_CNT;
   }

   // Transmit Priority Queue
   if (TxQCnt[NsmAdapterCnt] != -1) 
   {
      adapter->txQCnt = TxQCnt[NsmAdapterCnt];
   }
   else
   {
      adapter->txQCnt = NSM_DEFAULT_TX_Q_CNT;
   }

   // Receive Descriptor Count
   if (RxDCnt[NsmAdapterCnt] != -1) 
   {
      adapter->rxdCnt = RxDCnt[NsmAdapterCnt];
   }
   else
   {
      adapter->rxdCnt = NSM_DEFAULT_RXD_CNT;
   }

   // Receive Priority Queue
   if (RxQCnt[NsmAdapterCnt] != -1) 
   {
      // This currently has to be = 0x01
      adapter->rxQCnt = NSM_DEFAULT_RX_Q_CNT;
   }
   else
   {
      adapter->rxQCnt = NSM_DEFAULT_RX_Q_CNT;
   }

   // AutoNeg
   if (LinkMode[NsmAdapterCnt] != -1) 
   {
      switch (LinkMode[NsmAdapterCnt]) 
      {
         case 0x0   :   adapter->linkMode = MPL_LINK_MODE_AUTO;
                        break;
         case 0x1   :   adapter->linkMode = MPL_LINK_MODE_FORCED;
                        break;
         default    :   adapter->linkMode = NSM_DEFAULT_LINK_MODE;
      }
   }
   else
   {
      adapter->linkMode = NSM_DEFAULT_LINK_MODE;
   }

   // Speed 
   if (LinkSpeed[NsmAdapterCnt] != -1) 
   {
      switch (LinkSpeed[NsmAdapterCnt]) 
      {
         case 0x0   :   adapter->linkSpeed = MPL_LINK_SPEED_HUNDREDMBPS;
                        break;
         case 0x1   :   adapter->linkSpeed = MPL_LINK_SPEED_TENMBPS;
                        break;
         default    :   adapter->linkSpeed = NSM_DEFAULT_LINK_SPEED;
      }
   }
   else
   {
      adapter->linkSpeed = NSM_DEFAULT_LINK_SPEED;
   }

   // Duplex
   if (LinkDuplex[NsmAdapterCnt] != -1) 
   {
      switch (LinkDuplex[NsmAdapterCnt]) 
      {
         case 0x0   :   adapter->linkDuplex = MPL_LINK_DUPLEX_FULL;
                        break;
         case 0x1   :   adapter->linkDuplex = MPL_LINK_DUPLEX_HALF;
                        break;
         default    :   adapter->linkDuplex = NSM_DEFAULT_LINK_DUPLEX;
      }
   }
   else
   {
      adapter->linkDuplex = NSM_DEFAULT_LINK_DUPLEX;
   }

   // Pause
   if (LinkPause[NsmAdapterCnt] != -1) 
   {
      switch (LinkPause[NsmAdapterCnt]) 
      {
         case 0x0   :   adapter->linkPause = MPL_LINK_PAUSE_RECEIVE;
                        break;
         case 0x1   :   adapter->linkPause = MPL_LINK_PAUSE_TRANSMIT;
                        break;
         case 0x2   :   adapter->linkPause = MPL_LINK_PAUSE_SYMMETRICAL;
                        break;
         case 0x3   :   adapter->linkPause = MPL_LINK_PAUSE_NONE;
                        break;
         default    :   adapter->linkPause = NSM_DEFAULT_LINK_PAUSE;
      }
   }
   else
   {
      adapter->linkPause = NSM_DEFAULT_LINK_PAUSE;
   }

   // Intr Holdoff
   if (IntTimeHold[NsmAdapterCnt] != -1) 
   {
      adapter->timerHold = IntTimeHold[NsmAdapterCnt];
   }
   else
   {
      adapter->timerHold = NSM_DEFAULT_INTR_TIMER_HOLD;
   }

   // Intr Holdoff
   if (IntTxHold[NsmAdapterCnt] != -1) 
   {
      adapter->txHold = IntTxHold[NsmAdapterCnt];
   }
   else
      adapter->txHold = NSM_DEFAULT_INTR_TX_HOLD;

   // Intr Holdoff
   if (IntRxHold[NsmAdapterCnt] != -1) 
   {
      adapter->rxHold = IntRxHold[NsmAdapterCnt];
   }
   else
      adapter->rxHold = NSM_DEFAULT_INTR_RX_HOLD;

   // Operation Mode
   if (OpMode[NsmAdapterCnt] != -1) 
   {
      switch (OpMode[NsmAdapterCnt]) 
      {
         case 0x0   :   adapter->opMode = MPL_MODE_NORMAL;
                        break;
         case 0x1   :   adapter->opMode = MPL_MODE_MONITOR;
                        break;
         case 0x2   :   adapter->opMode = MPL_MODE_LOAD_ONLY;
                        break;
         default    :   adapter->opMode = NSM_DEFAULT_MODE;
      }
   }
   else
   {
      adapter->opMode = NSM_DEFAULT_MODE;
   }

   // WoL Modes
   if (Wol[NsmAdapterCnt] != -1) 
   {
      adapter->wolModes = Wol[NsmAdapterCnt];
   }

#ifdef NSM_DIAG_MODE
   // Diag Sts Queue length (in terms of packets)
   if (DiagStsQueue[NsmAdapterCnt] != -1) 
   {
      adapter->diagStsQueueSize = DiagStsQueue[NsmAdapterCnt];
   }
   else
   {
      adapter->diagStsQueueSize = NSM_DIAG_DEFAULT_STS_QUEUE_SIZE;
   }
#else
   // When NOT in diag mode, force the mode to be Normal
   adapter->opMode = MPL_MODE_NORMAL;
#endif //NSM_DIAG_MODE

#ifdef NSM_DEBUG
   // NSM Debug Zones
   if (NsmDebugZones[NsmAdapterCnt] != -1) 
   {
      NsmDbgSettings = NsmDebugZones[NsmAdapterCnt];
   }

   // Mpl Debug Zones
   if (MplDebugZones[NsmAdapterCnt] != -1) 
   {
      MplPathZones = MplDebugZones[NsmAdapterCnt];
   }
#endif //NSM_DEBUG

   NO(readUserOptions);
   return;
}

static NS_BOOLEAN
configMac(NSM_CONTEXT *adapter)
{
   MPL_STATUS status = NS_STATUS_SUCCESS;
   MPL_TRANSMIT_CFG txCfg;
   MPL_RECEIVE_CFG  rxCfg;
   NS_UINT8 i;

   NI(configMac);

   // Transmit Engine Config

   // Make sure the priority queues requested is within what is supported
   if (adapter->txQCnt > adapter->mplCaps.txCaps.priorityQCnt)
   {
      adapter->txQCnt = NSM_DEFAULT_TX_Q_CNT;
   }