📄 device_main.c
字号:
pRD->m_rd0RD0.f1Owner = OWNED_BY_NIC;
#ifdef PRIVATE_OBJ
ref_set_rx_jiffies(pDevice->dev);
#else
pDevice->dev->last_rx = jiffies;
#endif
}
pDevice->pCurrRD[uIdx]=pRD;
return works;
}
static BOOL device_alloc_rx_buf(PSDevice pDevice, PSRxDesc pRD) {
PDEVICE_RD_INFO pRDInfo=pRD->pRDInfo;
#ifdef PRIVATE_OBJ
pRDInfo->skb=dev_alloc_skb(pDevice->rx_buf_sz);
if (pRDInfo->skb==NULL)
return FALSE;
ref_skb_remap(pDevice->dev, &(pRDInfo->ref_skb), pRDInfo->skb);
pRDInfo->skb_dma = pci_map_single(pDevice->pcid, pRDInfo->ref_skb.tail, pDevice->rx_buf_sz,
PCI_DMA_FROMDEVICE);
#else
pRDInfo->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
if (pRDInfo->skb==NULL)
return FALSE;
ASSERT(pRDInfo->skb);
pRDInfo->skb->dev = pDevice->dev;
pRDInfo->skb_dma = pci_map_single(pDevice->pcid, pRDInfo->skb->tail, pDevice->rx_buf_sz,
PCI_DMA_FROMDEVICE);
#endif
*((PU32) &(pRD->m_rd0RD0)) = 0;
pRD->m_rd0RD0.wResCount = cpu_to_le16(pDevice->rx_buf_sz);
pRD->m_rd0RD0.f1Owner = OWNED_BY_NIC;
pRD->m_rd1RD1.wReqCount = cpu_to_le16(pDevice->rx_buf_sz);
pRD->buff_addr = cpu_to_le32(pRDInfo->skb_dma);
return TRUE;
}
BOOL device_alloc_frag_buf(PSDevice pDevice, PSDeFragControlBlock pDeF) {
#ifdef PRIVATE_OBJ
pDeF->skb=dev_alloc_skb(pDevice->rx_buf_sz);
if (pDeF->skb==NULL)
return FALSE;
ref_skb_remap(pDevice->dev, &(pDeF->ref_skb), pDeF->skb);
#else
pDeF->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
if (pDeF->skb == NULL)
return FALSE;
ASSERT(pDeF->skb);
pDeF->skb->dev = pDevice->dev;
#endif
return TRUE;
}
static int device_tx_srv(PSDevice pDevice, UINT uIdx) {
PSTxDesc pTD;
BOOL bFull=FALSE;
int works = 0;
BYTE byTsr0;
BYTE byTsr1;
UINT uFrameSize, uFIFOHeaderSize;
PSTxBufHead pTxBufHead;
struct net_device_stats* pStats = &pDevice->stats;
struct sk_buff* skb;
UINT uNodeIndex;
PSMgmtObject pMgmt = pDevice->pMgmt;
#ifdef PRIVATE_OBJ
ref_sk_buff ref_skb;
#endif
for (pTD = pDevice->apTailTD[uIdx]; pDevice->iTDUsed[uIdx] >0; pTD = pTD->next) {
if (pTD->m_td0TD0.f1Owner == OWNED_BY_NIC)
break;
if (works++>15)
break;
byTsr0 = pTD->m_td0TD0.byTSR0;
byTsr1 = pTD->m_td0TD0.byTSR1;
//Only the status of first TD in the chain is correct
if (pTD->m_td1TD1.byTCR & TCR_STP) {
if ((pTD->pTDInfo->byFlags & TD_FLAGS_NETIF_SKB) != 0) {
uFIFOHeaderSize = pTD->pTDInfo->dwHeaderLength;
uFrameSize = pTD->pTDInfo->dwReqCount - uFIFOHeaderSize;
pTxBufHead = (PSTxBufHead) (pTD->pTDInfo->buf);
#ifdef PRIVATE_OBJ
ref_skb_remap(pDevice->dev, &ref_skb, pTD->pTDInfo->skb);
#endif
// Update the statistics based on the Transmit status
// now, we DO'NT check TSR0_CDH
STAvUpdateTDStatCounter(&pDevice->scStatistic,
byTsr0, byTsr1,
(PBYTE)(pTD->pTDInfo->buf + uFIFOHeaderSize),
uFrameSize, uIdx);
BSSvUpdateNodeTxCounter(pDevice,
byTsr0, byTsr1,
(PBYTE)(pTD->pTDInfo->buf),
uFIFOHeaderSize
);
if (BITbIsBitOff(byTsr1, TSR1_TERR)) {
if (byTsr0 != 0) {
DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Tx[%d] OK but has error. tsr1[%02X] tsr0[%02X].\n",
(INT)uIdx, byTsr1, byTsr0);
}
if ((pTxBufHead->wFragCtl & FRAGCTL_ENDFRAG) != FRAGCTL_NONFRAG) {
pDevice->s802_11Counter.TransmittedFragmentCount ++;
}
pStats->tx_packets++;
#ifdef PRIVATE_OBJ
pStats->tx_bytes += *(ref_skb.len);
#else
pStats->tx_bytes += pTD->pTDInfo->skb->len;
#endif
}
else {
DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Tx[%d] dropped & tsr1[%02X] tsr0[%02X].\n",
(INT)uIdx, byTsr1, byTsr0);
pStats->tx_errors++;
pStats->tx_dropped++;
}
}
if ((pTD->pTDInfo->byFlags & TD_FLAGS_PRIV_SKB) != 0) {
if (pDevice->bEnableHostapd) {
DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "tx call back netif.. \n");
#ifdef PRIVATE_OBJ
ref_skb_remap(pDevice->apdev, &(ref_skb), pTD->pTDInfo->skb);
ref_skb.mac.raw = ref_skb.data;
*(ref_skb.pkt_type) = PACKET_OTHERHOST;
//*(ref_skb.protocol) = htons(ETH_P_802_2);
memset(ref_skb.cb, 0, sizeof(ref_skb.cb));
netif_rx(ref_skb.skb);
#else
skb = pTD->pTDInfo->skb;
skb->dev = pDevice->apdev;
skb->mac.raw = skb->data;
skb->pkt_type = PACKET_OTHERHOST;
//skb->protocol = htons(ETH_P_802_2);
memset(skb->cb, 0, sizeof(skb->cb));
netif_rx(skb);
#endif
}
}
if (BITbIsBitOn(byTsr1, TSR1_TERR)) {
if ((pTD->pTDInfo->byFlags & TD_FLAGS_PRIV_SKB) != 0) {
DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Tx[%d] fail has error. tsr1[%02X] tsr0[%02X].\n",
(INT)uIdx, byTsr1, byTsr0);
}
// DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Tx[%d] fail has error. tsr1[%02X] tsr0[%02X].\n",
// (INT)uIdx, byTsr1, byTsr0);
if ((pMgmt->eCurrMode == WMAC_MODE_ESS_AP) &&
(pTD->pTDInfo->byFlags & TD_FLAGS_NETIF_SKB)) {
WORD wAID;
BYTE byMask[8] = {1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80};
skb = pTD->pTDInfo->skb;
if (BSSDBbIsSTAInNodeDB(pMgmt, (PBYTE)(skb->data), &uNodeIndex)) {
if (pMgmt->sNodeDBTable[uNodeIndex].bPSEnable) {
skb_queue_tail(&pMgmt->sNodeDBTable[uNodeIndex].sTxPSQueue, skb);
pMgmt->sNodeDBTable[uNodeIndex].wEnQueueCnt++;
// set tx map
wAID = pMgmt->sNodeDBTable[uNodeIndex].wAID;
pMgmt->abyPSTxMap[wAID >> 3] |= byMask[wAID & 7];
pTD->pTDInfo->byFlags &= ~(TD_FLAGS_NETIF_SKB);
DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "tx_srv:tx fail re-queue sta index= %d, QueCnt= %d\n"
,(INT)uNodeIndex, pMgmt->sNodeDBTable[uNodeIndex].wEnQueueCnt);
pStats->tx_errors--;
pStats->tx_dropped--;
}
}
}
}
device_free_tx_buf(pDevice,pTD);
pDevice->iTDUsed[uIdx]--;
}
}
if (uIdx == TYPE_AC0DMA) {
// RESERV_AC0DMA reserved for relay
if (AVAIL_TD(pDevice, uIdx) < RESERV_AC0DMA) {
bFull = TRUE;
DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO " AC0DMA is Full = %d\n", pDevice->iTDUsed[uIdx]);
}
if (netif_queue_stopped(pDevice->dev) && (bFull==FALSE)){
netif_wake_queue(pDevice->dev);
}
}
pDevice->apTailTD[uIdx] = pTD;
return works;
}
static void device_error(PSDevice pDevice, WORD status) {
if (status & ISR_FETALERR) {
DEVICE_PRT(MSG_LEVEL_ERR, KERN_ERR
"%s: Hardware fatal error.\n",
pDevice->dev->name);
netif_stop_queue(pDevice->dev);
del_timer(&pDevice->sTimerCommand);
del_timer(&(pDevice->pMgmt->sTimerSecondCallback));
pDevice->bCmdRunning = FALSE;
MACbShutdown(pDevice->PortOffset);
return;
}
}
static void device_free_tx_buf(PSDevice pDevice, PSTxDesc pDesc) {
PDEVICE_TD_INFO pTDInfo=pDesc->pTDInfo;
struct sk_buff* skb=pTDInfo->skb;
// pre-allocated buf_dma can't be unmapped.
if (pTDInfo->skb_dma && (pTDInfo->skb_dma != pTDInfo->buf_dma)) {
pci_unmap_single(pDevice->pcid,pTDInfo->skb_dma,skb->len,
PCI_DMA_TODEVICE);
}
if ((pTDInfo->byFlags & TD_FLAGS_NETIF_SKB) != 0)
dev_kfree_skb_irq(skb);
pTDInfo->skb_dma = 0;
pTDInfo->skb = 0;
pTDInfo->byFlags = 0;
}
#ifdef PRIVATE_OBJ
int __device_open(HANDLE pExDevice) {
PSDevice_info pDevice_info = (PSDevice_info)pExDevice;
PSDevice pDevice = (PSDevice)(pDevice_info->pWDevice);
#else
static int device_open(struct net_device *dev) {
PSDevice pDevice=(PSDevice) dev->priv;
int i;
#endif
pDevice->rx_buf_sz = PKT_BUF_SZ;
if (!device_init_rings(pDevice)) {
return -ENOMEM;
}
#ifndef PRIVATE_OBJ
i=request_irq(pDevice->pcid->irq, &device_intr, SA_SHIRQ, dev->name, dev);
if (i)
return i;
#endif
device_init_rd0_ring(pDevice);
device_init_rd1_ring(pDevice);
device_init_defrag_cb(pDevice);
device_init_td0_ring(pDevice);
device_init_td1_ring(pDevice);
// VNTWIFIvSet11h(pDevice->pMgmt, pDevice->b11hEnable);
if (pDevice->bDiversityRegCtlON) {
device_init_diversity_timer(pDevice);
}
vMgrObjectInit(pDevice);
vMgrTimerInit(pDevice);
if (( SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_RADIOCTL)&0x06)==0x04)
return -ENOMEM;
device_init_registers(pDevice, DEVICE_INIT_COLD);
MACvReadEtherAddress(pDevice->PortOffset, pDevice->abyCurrentNetAddr);
memcpy(pDevice->pMgmt->abyMACAddr, pDevice->abyCurrentNetAddr, U_ETHER_ADDR_LEN);
#ifdef PRIVATE_OBJ
__device_set_multi(pExDevice);
#else
device_set_multi(pDevice->dev);
#endif
// Init for Key Management
KeyvInitTable(&pDevice->sKey, pDevice->PortOffset);
add_timer(&(pDevice->pMgmt->sTimerSecondCallback));
// Patch: if WEP key already set by iwconfig but device not yet open
if ((pDevice->bEncryptionEnable == TRUE) && (pDevice->bTransmitKey == TRUE)) {
KeybSetDefaultKey(&(pDevice->sKey),
(DWORD)(pDevice->byKeyIndex | (1 << 31)),
pDevice->uKeyLength,
NULL,
pDevice->abyKey,
KEY_CTL_WEP,
pDevice->PortOffset,
pDevice->byLocalID
);
pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
}
MACvIntEnable(pDevice->PortOffset, IMR_MASK_VALUE);
if (pDevice->pMgmt->eConfigMode == WMAC_CONFIG_AP) {
bScheduleCommand((HANDLE)pDevice, WLAN_CMD_RUN_AP, NULL);
}
else {
bScheduleCommand((HANDLE)pDevice, WLAN_CMD_BSSID_SCAN, NULL);
bScheduleCommand((HANDLE)pDevice, WLAN_CMD_SSID, NULL);
}
pDevice->flags |=DEVICE_FLAGS_OPENED;
#ifndef PRIVATE_OBJ
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
MOD_INC_USE_COUNT;
#endif
#endif
DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open success.. \n");
return 0;
}
#ifdef PRIVATE_OBJ
int __device_close(HANDLE pExDevice) {
PSDevice_info pDevice_info = (PSDevice_info)pExDevice;
struct net_device *dev = pDevice_info->dev;
PSDevice pDevice = (PSDevice)(pDevice_info->pWDevice);
#else
static int device_close(struct net_device *dev) {
PSDevice pDevice=(PSDevice) dev->priv;
#endif
PSMgmtObject pMgmt = pDevice->pMgmt;
del_timer(&pDevice->sTimerCommand);
del_timer(&pMgmt->sTimerSecondCallback);
if (pDevice->bDiversityRegCtlON) {
del_timer(&pDevice->TimerSQ3Tmax1);
del_timer(&pDevice->TimerSQ3Tmax2);
del_timer(&pDevice->TimerSQ3Tmax3);
}
netif_stop_queue(dev);
pDevice->bCmdRunning = FALSE;
MACbShutdown(pDevice->PortOffset);
MACbSoftwareReset(pDevice->PortOffset);
CARDbRadioPowe⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -