microsoft
/
WSL2-Linux-Kernel
зеркало из https://github.com/microsoft/WSL2-Linux-Kernel.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Staging: et131x: first pass RX cleanup 

Sort out the variable naming and clean up types and obvious trivia

Signed-off-by: Alan Cox <alan@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
This commit is contained in:
Alan Cox 2009-10-06 15:48:57 +01:00 коммит произвёл Greg Kroah-Hartman
Родитель 9c60684b72
Коммит 4fbdf811bc
1 изменённых файлов: 205 добавлений и 209 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

414
drivers/staging/et131x/et1310_rx.c
Просмотреть файл

@ -106,9 +106,9 @@ void nic_return_rfd(struct et131x_adapter *etdev, PMP_RFD pMpRfd);
*/ */
int et131x_rx_dma_memory_alloc(struct et131x_adapter *adapter) int et131x_rx_dma_memory_alloc(struct et131x_adapter *adapter)
{ {
uint32_t OuterLoop, InnerLoop; u32 i, j;
uint32_t bufsize; u32 bufsize;
uint32_t pktStatRingSize, FBRChunkSize; u32 pktStatRingSize, FBRChunkSize;
RX_RING_t *rx_ring; RX_RING_t *rx_ring;
/* Setup some convenience pointers */ /* Setup some convenience pointers */
@ -227,11 +227,11 @@ int et131x_rx_dma_memory_alloc(struct et131x_adapter *adapter)
rx_ring->Fbr0offset); rx_ring->Fbr0offset);
#endif #endif
for (OuterLoop = 0; OuterLoop < (rx_ring->Fbr1NumEntries / FBR_CHUNKS); for (i = 0; i < (rx_ring->Fbr1NumEntries / FBR_CHUNKS);
OuterLoop++) { i++) {
uint64_t Fbr1Offset; u64 Fbr1Offset;
uint64_t Fbr1TempPa; u64 Fbr1TempPa;
uint32_t Fbr1Align; u32 Fbr1Align;
/* This code allocates an area of memory big enough for N /* This code allocates an area of memory big enough for N
* free buffers + (buffer_size - 1) so that the buffers can * free buffers + (buffer_size - 1) so that the buffers can
@ -247,39 +247,39 @@ int et131x_rx_dma_memory_alloc(struct et131x_adapter *adapter)
FBRChunkSize = FBRChunkSize =
(FBR_CHUNKS * rx_ring->Fbr1BufferSize) + Fbr1Align - 1; (FBR_CHUNKS * rx_ring->Fbr1BufferSize) + Fbr1Align - 1;
rx_ring->Fbr1MemVa[OuterLoop] = rx_ring->Fbr1MemVa[i] =
pci_alloc_consistent(adapter->pdev, FBRChunkSize, pci_alloc_consistent(adapter->pdev, FBRChunkSize,
&rx_ring->Fbr1MemPa[OuterLoop]); &rx_ring->Fbr1MemPa[i]);
if (!rx_ring->Fbr1MemVa[OuterLoop]) { if (!rx_ring->Fbr1MemVa[i]) {
dev_err(&adapter->pdev->dev, dev_err(&adapter->pdev->dev,
"Could not alloc memory\n"); "Could not alloc memory\n");
return -ENOMEM; return -ENOMEM;
} }
/* See NOTE in "Save Physical Address" comment above */ /* See NOTE in "Save Physical Address" comment above */
Fbr1TempPa = rx_ring->Fbr1MemPa[OuterLoop]; Fbr1TempPa = rx_ring->Fbr1MemPa[i];
et131x_align_allocated_memory(adapter, et131x_align_allocated_memory(adapter,
&Fbr1TempPa, &Fbr1TempPa,
&Fbr1Offset, (Fbr1Align - 1)); &Fbr1Offset, (Fbr1Align - 1));
for (InnerLoop = 0; InnerLoop < FBR_CHUNKS; InnerLoop++) { for (j = 0; j < FBR_CHUNKS; j++) {
uint32_t index = (OuterLoop * FBR_CHUNKS) + InnerLoop; u32 index = (i * FBR_CHUNKS) + j;
/* Save the Virtual address of this index for quick /* Save the Virtual address of this index for quick
* access later * access later
*/ */
rx_ring->Fbr[1]->Va[index] = rx_ring->Fbr[1]->Va[index] =
(uint8_t *) rx_ring->Fbr1MemVa[OuterLoop] + (uint8_t *) rx_ring->Fbr1MemVa[i] +
(InnerLoop * rx_ring->Fbr1BufferSize) + Fbr1Offset; (j * rx_ring->Fbr1BufferSize) + Fbr1Offset;
/* now store the physical address in the descriptor /* now store the physical address in the descriptor
* so the device can access it * so the device can access it
*/ */
rx_ring->Fbr[1]->PAHigh[index] = rx_ring->Fbr[1]->PAHigh[index] =
(uint32_t) (Fbr1TempPa >> 32); (u32) (Fbr1TempPa >> 32);
rx_ring->Fbr[1]->PALow[index] = (uint32_t) Fbr1TempPa; rx_ring->Fbr[1]->PALow[index] = (u32) Fbr1TempPa;
Fbr1TempPa += rx_ring->Fbr1BufferSize; Fbr1TempPa += rx_ring->Fbr1BufferSize;
@ -292,40 +292,40 @@ int et131x_rx_dma_memory_alloc(struct et131x_adapter *adapter)
#ifdef USE_FBR0 #ifdef USE_FBR0
/* Same for FBR0 (if in use) */ /* Same for FBR0 (if in use) */
for (OuterLoop = 0; OuterLoop < (rx_ring->Fbr0NumEntries / FBR_CHUNKS); for (i = 0; i < (rx_ring->Fbr0NumEntries / FBR_CHUNKS);
OuterLoop++) { i++) {
uint64_t Fbr0Offset; u64 Fbr0Offset;
uint64_t Fbr0TempPa; u64 Fbr0TempPa;
FBRChunkSize = ((FBR_CHUNKS + 1) * rx_ring->Fbr0BufferSize) - 1; FBRChunkSize = ((FBR_CHUNKS + 1) * rx_ring->Fbr0BufferSize) - 1;
rx_ring->Fbr0MemVa[OuterLoop] = rx_ring->Fbr0MemVa[i] =
pci_alloc_consistent(adapter->pdev, FBRChunkSize, pci_alloc_consistent(adapter->pdev, FBRChunkSize,
&rx_ring->Fbr0MemPa[OuterLoop]); &rx_ring->Fbr0MemPa[i]);
if (!rx_ring->Fbr0MemVa[OuterLoop]) { if (!rx_ring->Fbr0MemVa[i]) {
dev_err(&adapter->pdev->dev, dev_err(&adapter->pdev->dev,
"Could not alloc memory\n"); "Could not alloc memory\n");
return -ENOMEM; return -ENOMEM;
} }
/* See NOTE in "Save Physical Address" comment above */ /* See NOTE in "Save Physical Address" comment above */
Fbr0TempPa = rx_ring->Fbr0MemPa[OuterLoop]; Fbr0TempPa = rx_ring->Fbr0MemPa[i];
et131x_align_allocated_memory(adapter, et131x_align_allocated_memory(adapter,
&Fbr0TempPa, &Fbr0TempPa,
&Fbr0Offset, &Fbr0Offset,
rx_ring->Fbr0BufferSize - 1); rx_ring->Fbr0BufferSize - 1);
for (InnerLoop = 0; InnerLoop < FBR_CHUNKS; InnerLoop++) { for (j = 0; j < FBR_CHUNKS; j++) {
uint32_t index = (OuterLoop * FBR_CHUNKS) + InnerLoop; u32 index = (i * FBR_CHUNKS) + j;
rx_ring->Fbr[0]->Va[index] = rx_ring->Fbr[0]->Va[index] =
(uint8_t *) rx_ring->Fbr0MemVa[OuterLoop] + (uint8_t *) rx_ring->Fbr0MemVa[i] +
(InnerLoop * rx_ring->Fbr0BufferSize) + Fbr0Offset; (j * rx_ring->Fbr0BufferSize) + Fbr0Offset;
rx_ring->Fbr[0]->PAHigh[index] = rx_ring->Fbr[0]->PAHigh[index] =
(uint32_t) (Fbr0TempPa >> 32); (u32) (Fbr0TempPa >> 32);
rx_ring->Fbr[0]->PALow[index] = (uint32_t) Fbr0TempPa; rx_ring->Fbr[0]->PALow[index] = (u32) Fbr0TempPa;
Fbr0TempPa += rx_ring->Fbr0BufferSize; Fbr0TempPa += rx_ring->Fbr0BufferSize;
@ -400,10 +400,10 @@ int et131x_rx_dma_memory_alloc(struct et131x_adapter *adapter)
*/ */
void et131x_rx_dma_memory_free(struct et131x_adapter *adapter) void et131x_rx_dma_memory_free(struct et131x_adapter *adapter)
{ {
uint32_t index; u32 index;
uint32_t bufsize; u32 bufsize;
uint32_t pktStatRingSize; u32 pktStatRingSize;
PMP_RFD pMpRfd; PMP_RFD rfd;
RX_RING_t *rx_ring; RX_RING_t *rx_ring;
/* Setup some convenience pointers */ /* Setup some convenience pointers */
@ -413,18 +413,18 @@ void et131x_rx_dma_memory_free(struct et131x_adapter *adapter)
WARN_ON(rx_ring->nReadyRecv != rx_ring->NumRfd); WARN_ON(rx_ring->nReadyRecv != rx_ring->NumRfd);
while (!list_empty(&rx_ring->RecvList)) { while (!list_empty(&rx_ring->RecvList)) {
pMpRfd = (MP_RFD *) list_entry(rx_ring->RecvList.next, rfd = (MP_RFD *) list_entry(rx_ring->RecvList.next,
MP_RFD, list_node); MP_RFD, list_node);
list_del(&pMpRfd->list_node); list_del(&rfd->list_node);
et131x_rfd_resources_free(adapter, pMpRfd); et131x_rfd_resources_free(adapter, rfd);
} }
while (!list_empty(&rx_ring->RecvPendingList)) { while (!list_empty(&rx_ring->RecvPendingList)) {
pMpRfd = (MP_RFD *) list_entry(rx_ring->RecvPendingList.next, rfd = (MP_RFD *) list_entry(rx_ring->RecvPendingList.next,
MP_RFD, list_node); MP_RFD, list_node);
list_del(&pMpRfd->list_node); list_del(&rfd->list_node);
et131x_rfd_resources_free(adapter, pMpRfd); et131x_rfd_resources_free(adapter, rfd);
} }
/* Free Free Buffer Ring 1 */ /* Free Free Buffer Ring 1 */
@ -433,7 +433,7 @@ void et131x_rx_dma_memory_free(struct et131x_adapter *adapter)
for (index = 0; index < for (index = 0; index <
(rx_ring->Fbr1NumEntries / FBR_CHUNKS); index++) { (rx_ring->Fbr1NumEntries / FBR_CHUNKS); index++) {
if (rx_ring->Fbr1MemVa[index]) { if (rx_ring->Fbr1MemVa[index]) {
uint32_t Fbr1Align; u32 Fbr1Align;
if (rx_ring->Fbr1BufferSize > 4096) if (rx_ring->Fbr1BufferSize > 4096)
Fbr1Align = 4096; Fbr1Align = 4096;
@ -552,49 +552,49 @@ void et131x_rx_dma_memory_free(struct et131x_adapter *adapter)
int et131x_init_recv(struct et131x_adapter *adapter) int et131x_init_recv(struct et131x_adapter *adapter)
{ {
int status = -ENOMEM; int status = -ENOMEM;
PMP_RFD pMpRfd = NULL; PMP_RFD rfd = NULL;
uint32_t RfdCount; u32 rfdct;
uint32_t TotalNumRfd = 0; u32 numrfd = 0;
RX_RING_t *rx_ring = NULL; RX_RING_t *rx_ring = NULL;
/* Setup some convenience pointers */ /* Setup some convenience pointers */
rx_ring = (RX_RING_t *) &adapter->RxRing; rx_ring = (RX_RING_t *) &adapter->RxRing;
/* Setup each RFD */ /* Setup each RFD */
for (RfdCount = 0; RfdCount < rx_ring->NumRfd; RfdCount++) { for (rfdct = 0; rfdct < rx_ring->NumRfd; rfdct++) {
pMpRfd = (MP_RFD *) kmem_cache_alloc(rx_ring->RecvLookaside, rfd = (MP_RFD *) kmem_cache_alloc(rx_ring->RecvLookaside,
GFP_ATOMIC | GFP_DMA); GFP_ATOMIC | GFP_DMA);
if (!pMpRfd) { if (!rfd) {
dev_err(&adapter->pdev->dev, dev_err(&adapter->pdev->dev,
"Couldn't alloc RFD out of kmem_cache\n"); "Couldn't alloc RFD out of kmem_cache\n");
status = -ENOMEM; status = -ENOMEM;
continue; continue;
} }
status = et131x_rfd_resources_alloc(adapter, pMpRfd); status = et131x_rfd_resources_alloc(adapter, rfd);
if (status != 0) { if (status != 0) {
dev_err(&adapter->pdev->dev, dev_err(&adapter->pdev->dev,
"Couldn't alloc packet for RFD\n"); "Couldn't alloc packet for RFD\n");
kmem_cache_free(rx_ring->RecvLookaside, pMpRfd); kmem_cache_free(rx_ring->RecvLookaside, rfd);
continue; continue;
} }
/* Add this RFD to the RecvList */ /* Add this RFD to the RecvList */
list_add_tail(&pMpRfd->list_node, &rx_ring->RecvList); list_add_tail(&rfd->list_node, &rx_ring->RecvList);
/* Increment both the available RFD's, and the total RFD's. */ /* Increment both the available RFD's, and the total RFD's. */
rx_ring->nReadyRecv++; rx_ring->nReadyRecv++;
TotalNumRfd++; numrfd++;
} }
if (TotalNumRfd > NIC_MIN_NUM_RFD) if (numrfd > NIC_MIN_NUM_RFD)
status = 0; status = 0;
rx_ring->NumRfd = TotalNumRfd; rx_ring->NumRfd = numrfd;
if (status != 0) { if (status != 0) {
kmem_cache_free(rx_ring->RecvLookaside, pMpRfd); kmem_cache_free(rx_ring->RecvLookaside, rfd);
dev_err(&adapter->pdev->dev, dev_err(&adapter->pdev->dev,
"Allocation problems in et131x_init_recv\n"); "Allocation problems in et131x_init_recv\n");
} }
@ -604,13 +604,13 @@ int et131x_init_recv(struct et131x_adapter *adapter)
/** /**
* et131x_rfd_resources_alloc * et131x_rfd_resources_alloc
* @adapter: pointer to our private adapter structure * @adapter: pointer to our private adapter structure
* @pMpRfd: pointer to a RFD * @rfd: pointer to a RFD
* *
* Returns 0 on success and errno on failure (as defined in errno.h) * Returns 0 on success and errno on failure (as defined in errno.h)
*/ */
int et131x_rfd_resources_alloc(struct et131x_adapter *adapter, MP_RFD *pMpRfd) int et131x_rfd_resources_alloc(struct et131x_adapter *adapter, MP_RFD *rfd)
{ {
pMpRfd->Packet = NULL; rfd->Packet = NULL;
return 0; return 0;
} }
@ -618,12 +618,12 @@ int et131x_rfd_resources_alloc(struct et131x_adapter *adapter, MP_RFD *pMpRfd)
/** /**
* et131x_rfd_resources_free - Free the packet allocated for the given RFD * et131x_rfd_resources_free - Free the packet allocated for the given RFD
* @adapter: pointer to our private adapter structure * @adapter: pointer to our private adapter structure
* @pMpRfd: pointer to a RFD * @rfd: pointer to a RFD
*/ */
void et131x_rfd_resources_free(struct et131x_adapter *adapter, MP_RFD *pMpRfd) void et131x_rfd_resources_free(struct et131x_adapter *adapter, MP_RFD *rfd)
{ {
pMpRfd->Packet = NULL; rfd->Packet = NULL;
kmem_cache_free(adapter->RxRing.RecvLookaside, pMpRfd); kmem_cache_free(adapter->RxRing.RecvLookaside, rfd);
} }
/** /**
@ -633,9 +633,9 @@ void et131x_rfd_resources_free(struct et131x_adapter *adapter, MP_RFD *pMpRfd)
void ConfigRxDmaRegs(struct et131x_adapter *etdev) void ConfigRxDmaRegs(struct et131x_adapter *etdev)
{ {
struct _RXDMA_t __iomem *rx_dma = &etdev->regs->rxdma; struct _RXDMA_t __iomem *rx_dma = &etdev->regs->rxdma;
struct _rx_ring_t *pRxLocal = &etdev->RxRing; struct _rx_ring_t *rx_local = &etdev->RxRing;
PFBR_DESC_t fbr_entry; PFBR_DESC_t fbr_entry;
uint32_t entry; u32 entry;
RXDMA_PSR_NUM_DES_t psr_num_des; RXDMA_PSR_NUM_DES_t psr_num_des;
unsigned long flags; unsigned long flags;
@ -649,19 +649,19 @@ void ConfigRxDmaRegs(struct et131x_adapter *etdev)
* are ever returned, make sure the high part is retrieved here * are ever returned, make sure the high part is retrieved here
* before storing the adjusted address. * before storing the adjusted address.
*/ */
writel((uint32_t) ((u64)pRxLocal->pRxStatusPa >> 32), writel((u32) ((u64)rx_local->pRxStatusPa >> 32),
&rx_dma->dma_wb_base_hi); &rx_dma->dma_wb_base_hi);
writel((uint32_t) pRxLocal->pRxStatusPa, &rx_dma->dma_wb_base_lo); writel((u32) rx_local->pRxStatusPa, &rx_dma->dma_wb_base_lo);
memset(pRxLocal->pRxStatusVa, 0, sizeof(RX_STATUS_BLOCK_t)); memset(rx_local->pRxStatusVa, 0, sizeof(RX_STATUS_BLOCK_t));
/* Set the address and parameters of the packet status ring into the /* Set the address and parameters of the packet status ring into the
* 1310's registers * 1310's registers
*/ */
writel((uint32_t) ((u64)pRxLocal->pPSRingPa >> 32), writel((u32) ((u64)rx_local->pPSRingPa >> 32),
&rx_dma->psr_base_hi); &rx_dma->psr_base_hi);
writel((uint32_t) pRxLocal->pPSRingPa, &rx_dma->psr_base_lo); writel((u32) rx_local->pPSRingPa, &rx_dma->psr_base_lo);
writel(pRxLocal->PsrNumEntries - 1, &rx_dma->psr_num_des.value); writel(rx_local->PsrNumEntries - 1, &rx_dma->psr_num_des.value);
writel(0, &rx_dma->psr_full_offset.value); writel(0, &rx_dma->psr_full_offset.value);
psr_num_des.value = readl(&rx_dma->psr_num_des.value); psr_num_des.value = readl(&rx_dma->psr_num_des.value);
@ -671,14 +671,14 @@ void ConfigRxDmaRegs(struct et131x_adapter *etdev)
spin_lock_irqsave(&etdev->RcvLock, flags); spin_lock_irqsave(&etdev->RcvLock, flags);
/* These local variables track the PSR in the adapter structure */ /* These local variables track the PSR in the adapter structure */
pRxLocal->local_psr_full.bits.psr_full = 0; rx_local->local_psr_full.bits.psr_full = 0;
pRxLocal->local_psr_full.bits.psr_full_wrap = 0; rx_local->local_psr_full.bits.psr_full_wrap = 0;
/* Now's the best time to initialize FBR1 contents */ /* Now's the best time to initialize FBR1 contents */
fbr_entry = (PFBR_DESC_t) pRxLocal->pFbr1RingVa; fbr_entry = (PFBR_DESC_t) rx_local->pFbr1RingVa;
for (entry = 0; entry < pRxLocal->Fbr1NumEntries; entry++) { for (entry = 0; entry < rx_local->Fbr1NumEntries; entry++) {
fbr_entry->addr_hi = pRxLocal->Fbr[1]->PAHigh[entry]; fbr_entry->addr_hi = rx_local->Fbr[1]->PAHigh[entry];
fbr_entry->addr_lo = pRxLocal->Fbr[1]->PALow[entry]; fbr_entry->addr_lo = rx_local->Fbr[1]->PALow[entry];
fbr_entry->word2.bits.bi = entry; fbr_entry->word2.bits.bi = entry;
fbr_entry++; fbr_entry++;
} }
@ -686,38 +686,38 @@ void ConfigRxDmaRegs(struct et131x_adapter *etdev)
/* Set the address and parameters of Free buffer ring 1 (and 0 if /* Set the address and parameters of Free buffer ring 1 (and 0 if
* required) into the 1310's registers * required) into the 1310's registers
*/ */
writel((uint32_t) (pRxLocal->Fbr1Realpa >> 32), &rx_dma->fbr1_base_hi); writel((u32) (rx_local->Fbr1Realpa >> 32), &rx_dma->fbr1_base_hi);
writel((uint32_t) pRxLocal->Fbr1Realpa, &rx_dma->fbr1_base_lo); writel((u32) rx_local->Fbr1Realpa, &rx_dma->fbr1_base_lo);
writel(pRxLocal->Fbr1NumEntries - 1, &rx_dma->fbr1_num_des.value); writel(rx_local->Fbr1NumEntries - 1, &rx_dma->fbr1_num_des.value);
writel(ET_DMA10_WRAP, &rx_dma->fbr1_full_offset); writel(ET_DMA10_WRAP, &rx_dma->fbr1_full_offset);
/* This variable tracks the free buffer ring 1 full position, so it /* This variable tracks the free buffer ring 1 full position, so it
* has to match the above. * has to match the above.
*/ */
pRxLocal->local_Fbr1_full = ET_DMA10_WRAP; rx_local->local_Fbr1_full = ET_DMA10_WRAP;
writel(((pRxLocal->Fbr1NumEntries * LO_MARK_PERCENT_FOR_RX) / 100) - 1, writel(((rx_local->Fbr1NumEntries * LO_MARK_PERCENT_FOR_RX) / 100) - 1,
&rx_dma->fbr1_min_des.value); &rx_dma->fbr1_min_des.value);
#ifdef USE_FBR0 #ifdef USE_FBR0
/* Now's the best time to initialize FBR0 contents */ /* Now's the best time to initialize FBR0 contents */
fbr_entry = (PFBR_DESC_t) pRxLocal->pFbr0RingVa; fbr_entry = (PFBR_DESC_t) rx_local->pFbr0RingVa;
for (entry = 0; entry < pRxLocal->Fbr0NumEntries; entry++) { for (entry = 0; entry < rx_local->Fbr0NumEntries; entry++) {
fbr_entry->addr_hi = pRxLocal->Fbr[0]->PAHigh[entry]; fbr_entry->addr_hi = rx_local->Fbr[0]->PAHigh[entry];
fbr_entry->addr_lo = pRxLocal->Fbr[0]->PALow[entry]; fbr_entry->addr_lo = rx_local->Fbr[0]->PALow[entry];
fbr_entry->word2.bits.bi = entry; fbr_entry->word2.bits.bi = entry;
fbr_entry++; fbr_entry++;
} }
writel((uint32_t) (pRxLocal->Fbr0Realpa >> 32), &rx_dma->fbr0_base_hi); writel((u32) (rx_local->Fbr0Realpa >> 32), &rx_dma->fbr0_base_hi);
writel((uint32_t) pRxLocal->Fbr0Realpa, &rx_dma->fbr0_base_lo); writel((u32) rx_local->Fbr0Realpa, &rx_dma->fbr0_base_lo);
writel(pRxLocal->Fbr0NumEntries - 1, &rx_dma->fbr0_num_des.value); writel(rx_local->Fbr0NumEntries - 1, &rx_dma->fbr0_num_des.value);
writel(ET_DMA10_WRAP, &rx_dma->fbr0_full_offset); writel(ET_DMA10_WRAP, &rx_dma->fbr0_full_offset);
/* This variable tracks the free buffer ring 0 full position, so it /* This variable tracks the free buffer ring 0 full position, so it
* has to match the above. * has to match the above.
*/ */
pRxLocal->local_Fbr0_full = ET_DMA10_WRAP; rx_local->local_Fbr0_full = ET_DMA10_WRAP;
writel(((pRxLocal->Fbr0NumEntries * LO_MARK_PERCENT_FOR_RX) / 100) - 1, writel(((rx_local->Fbr0NumEntries * LO_MARK_PERCENT_FOR_RX) / 100) - 1,
&rx_dma->fbr0_min_des.value); &rx_dma->fbr0_min_des.value);
#endif #endif
@ -818,7 +818,7 @@ void et131x_rx_dma_enable(struct et131x_adapter *etdev)
* nic_rx_pkts - Checks the hardware for available packets * nic_rx_pkts - Checks the hardware for available packets
* @etdev: pointer to our adapter * @etdev: pointer to our adapter
* *
* Returns pMpRfd, a pointer to our MPRFD. * Returns rfd, a pointer to our MPRFD.
* *
* Checks the hardware for available packets, using completion ring * Checks the hardware for available packets, using completion ring
* If packets are available, it gets an RFD from the RecvList, attaches * If packets are available, it gets an RFD from the RecvList, attaches
@ -827,119 +827,119 @@ void et131x_rx_dma_enable(struct et131x_adapter *etdev)
*/ */
PMP_RFD nic_rx_pkts(struct et131x_adapter *etdev) PMP_RFD nic_rx_pkts(struct et131x_adapter *etdev)
{ {
struct _rx_ring_t *pRxLocal = &etdev->RxRing; struct _rx_ring_t *rx_local = &etdev->RxRing;
PRX_STATUS_BLOCK_t pRxStatusBlock; PRX_STATUS_BLOCK_t status;
PPKT_STAT_DESC_t pPSREntry; PPKT_STAT_DESC_t psr;
PMP_RFD pMpRfd; PMP_RFD rfd;
uint32_t nIndex; u32 i;
uint8_t *pBufVa; uint8_t *buf;
unsigned long flags; unsigned long flags;
struct list_head *element; struct list_head *element;
uint8_t ringIndex; uint8_t rindex;
uint16_t bufferIndex; uint16_t bindex;
uint32_t localLen; u32 len;
PKT_STAT_DESC_WORD0_t Word0; PKT_STAT_DESC_WORD0_t Word0;
/* RX Status block is written by the DMA engine prior to every /* RX Status block is written by the DMA engine prior to every
* interrupt. It contains the next to be used entry in the Packet * interrupt. It contains the next to be used entry in the Packet
* Status Ring, and also the two Free Buffer rings. * Status Ring, and also the two Free Buffer rings.
*/ */
pRxStatusBlock = (PRX_STATUS_BLOCK_t) pRxLocal->pRxStatusVa; status = (PRX_STATUS_BLOCK_t) rx_local->pRxStatusVa;
if (pRxStatusBlock->Word1.bits.PSRoffset == if (status->Word1.bits.PSRoffset ==
pRxLocal->local_psr_full.bits.psr_full && rx_local->local_psr_full.bits.psr_full &&
pRxStatusBlock->Word1.bits.PSRwrap == status->Word1.bits.PSRwrap ==
pRxLocal->local_psr_full.bits.psr_full_wrap) { rx_local->local_psr_full.bits.psr_full_wrap) {
/* Looks like this ring is not updated yet */ /* Looks like this ring is not updated yet */
return NULL; return NULL;
} }
/* The packet status ring indicates that data is available. */ /* The packet status ring indicates that data is available. */
pPSREntry = (PPKT_STAT_DESC_t) (pRxLocal->pPSRingVa) + psr = (PPKT_STAT_DESC_t) (rx_local->pPSRingVa) +
pRxLocal->local_psr_full.bits.psr_full; rx_local->local_psr_full.bits.psr_full;
/* Grab any information that is required once the PSR is /* Grab any information that is required once the PSR is
* advanced, since we can no longer rely on the memory being * advanced, since we can no longer rely on the memory being
* accurate * accurate
*/ */
localLen = pPSREntry->word1.bits.length; len = psr->word1.bits.length;
ringIndex = (uint8_t) pPSREntry->word1.bits.ri; rindex = (uint8_t) psr->word1.bits.ri;
bufferIndex = (uint16_t) pPSREntry->word1.bits.bi; bindex = (uint16_t) psr->word1.bits.bi;
Word0 = pPSREntry->word0; Word0 = psr->word0;
/* Indicate that we have used this PSR entry. */ /* Indicate that we have used this PSR entry. */
if (++pRxLocal->local_psr_full.bits.psr_full > if (++rx_local->local_psr_full.bits.psr_full >
pRxLocal->PsrNumEntries - 1) { rx_local->PsrNumEntries - 1) {
pRxLocal->local_psr_full.bits.psr_full = 0; rx_local->local_psr_full.bits.psr_full = 0;
pRxLocal->local_psr_full.bits.psr_full_wrap ^= 1; rx_local->local_psr_full.bits.psr_full_wrap ^= 1;
} }
writel(pRxLocal->local_psr_full.value, writel(rx_local->local_psr_full.value,
&etdev->regs->rxdma.psr_full_offset.value); &etdev->regs->rxdma.psr_full_offset.value);
#ifndef USE_FBR0 #ifndef USE_FBR0
if (ringIndex != 1) { if (rindex != 1) {
return NULL; return NULL;
} }
#endif #endif
#ifdef USE_FBR0 #ifdef USE_FBR0
if (ringIndex > 1 || if (rindex > 1 ||
(ringIndex == 0 && (rindex == 0 &&
bufferIndex > pRxLocal->Fbr0NumEntries - 1) || bindex > rx_local->Fbr0NumEntries - 1) ||
(ringIndex == 1 && (rindex == 1 &&
bufferIndex > pRxLocal->Fbr1NumEntries - 1)) bindex > rx_local->Fbr1NumEntries - 1))
#else #else
if (ringIndex != 1 || if (rindex != 1 ||
bufferIndex > pRxLocal->Fbr1NumEntries - 1) bindex > rx_local->Fbr1NumEntries - 1)
#endif #endif
{ {
/* Illegal buffer or ring index cannot be used by S/W*/ /* Illegal buffer or ring index cannot be used by S/W*/
dev_err(&etdev->pdev->dev, dev_err(&etdev->pdev->dev,
"NICRxPkts PSR Entry %d indicates " "NICRxPkts PSR Entry %d indicates "
"length of %d and/or bad bi(%d)\n", "length of %d and/or bad bi(%d)\n",
pRxLocal->local_psr_full.bits.psr_full, rx_local->local_psr_full.bits.psr_full,
localLen, bufferIndex); len, bindex);
return NULL; return NULL;
} }
/* Get and fill the RFD. */ /* Get and fill the RFD. */
spin_lock_irqsave(&etdev->RcvLock, flags); spin_lock_irqsave(&etdev->RcvLock, flags);
pMpRfd = NULL; rfd = NULL;
element = pRxLocal->RecvList.next; element = rx_local->RecvList.next;
pMpRfd = (PMP_RFD) list_entry(element, MP_RFD, list_node); rfd = (PMP_RFD) list_entry(element, MP_RFD, list_node);
if (pMpRfd == NULL) { if (rfd == NULL) {
spin_unlock_irqrestore(&etdev->RcvLock, flags); spin_unlock_irqrestore(&etdev->RcvLock, flags);
return NULL; return NULL;
} }
list_del(&pMpRfd->list_node); list_del(&rfd->list_node);
pRxLocal->nReadyRecv--; rx_local->nReadyRecv--;
spin_unlock_irqrestore(&etdev->RcvLock, flags); spin_unlock_irqrestore(&etdev->RcvLock, flags);
pMpRfd->bufferindex = bufferIndex; rfd->bufferindex = bindex;
pMpRfd->ringindex = ringIndex; rfd->ringindex = rindex;
/* In V1 silicon, there is a bug which screws up filtering of /* In V1 silicon, there is a bug which screws up filtering of
* runt packets. Therefore runt packet filtering is disabled * runt packets. Therefore runt packet filtering is disabled
* in the MAC and the packets are dropped here. They are * in the MAC and the packets are dropped here. They are
* also counted here. * also counted here.
*/ */
if (localLen < (NIC_MIN_PACKET_SIZE + 4)) { if (len < (NIC_MIN_PACKET_SIZE + 4)) {
etdev->Stats.other_errors++; etdev->Stats.other_errors++;
localLen = 0; len = 0;
} }
if (localLen) { if (len) {
if (etdev->ReplicaPhyLoopbk == 1) { if (etdev->ReplicaPhyLoopbk == 1) {
pBufVa = pRxLocal->Fbr[ringIndex]->Va[bufferIndex]; buf = rx_local->Fbr[rindex]->Va[bindex];
if (memcmp(&pBufVa[6], &etdev->CurrentAddress[0], if (memcmp(&buf[6], &etdev->CurrentAddress[0],
ETH_ALEN) == 0) { ETH_ALEN) == 0) {
if (memcmp(&pBufVa[42], "Replica packet", if (memcmp(&buf[42], "Replica packet",
ETH_HLEN)) { ETH_HLEN)) {
etdev->ReplicaPhyLoopbkPF = 1; etdev->ReplicaPhyLoopbkPF = 1;
} }
@ -959,28 +959,28 @@ PMP_RFD nic_rx_pkts(struct et131x_adapter *etdev)
if ((etdev->PacketFilter & ET131X_PACKET_TYPE_MULTICAST) if ((etdev->PacketFilter & ET131X_PACKET_TYPE_MULTICAST)
&& !(etdev->PacketFilter & ET131X_PACKET_TYPE_PROMISCUOUS) && !(etdev->PacketFilter & ET131X_PACKET_TYPE_PROMISCUOUS)
&& !(etdev->PacketFilter & ET131X_PACKET_TYPE_ALL_MULTICAST)) { && !(etdev->PacketFilter & ET131X_PACKET_TYPE_ALL_MULTICAST)) {
pBufVa = pRxLocal->Fbr[ringIndex]-> buf = rx_local->Fbr[rindex]->
Va[bufferIndex]; Va[bindex];
/* Loop through our list to see if the /* Loop through our list to see if the
* destination address of this packet * destination address of this packet
* matches one in our list. * matches one in our list.
*/ */
for (nIndex = 0; for (i = 0;
nIndex < etdev->MCAddressCount; i < etdev->MCAddressCount;
nIndex++) { i++) {
if (pBufVa[0] == if (buf[0] ==
etdev->MCList[nIndex][0] etdev->MCList[i][0]
&& pBufVa[1] == && buf[1] ==
etdev->MCList[nIndex][1] etdev->MCList[i][1]
&& pBufVa[2] == && buf[2] ==
etdev->MCList[nIndex][2] etdev->MCList[i][2]
&& pBufVa[3] == && buf[3] ==
etdev->MCList[nIndex][3] etdev->MCList[i][3]
&& pBufVa[4] == && buf[4] ==
etdev->MCList[nIndex][4] etdev->MCList[i][4]
&& pBufVa[5] == && buf[5] ==
etdev->MCList[nIndex][5]) { etdev->MCList[i][5]) {
break; break;
} }
} }
@ -993,11 +993,11 @@ PMP_RFD nic_rx_pkts(struct et131x_adapter *etdev)
* so we free our RFD when we return * so we free our RFD when we return
* from this function. * from this function.
*/ */
if (nIndex == etdev->MCAddressCount) if (i == etdev->MCAddressCount)
localLen = 0; len = 0;
} }
if (localLen > 0) if (len > 0)
etdev->Stats.multircv++; etdev->Stats.multircv++;
} else if (Word0.value & ALCATEL_BROADCAST_PKT) } else if (Word0.value & ALCATEL_BROADCAST_PKT)
etdev->Stats.brdcstrcv++; etdev->Stats.brdcstrcv++;
@ -1010,24 +1010,24 @@ PMP_RFD nic_rx_pkts(struct et131x_adapter *etdev)
etdev->Stats.unircv++; etdev->Stats.unircv++;
} }
if (localLen > 0) { if (len > 0) {
struct sk_buff *skb = NULL; struct sk_buff *skb = NULL;
/* pMpRfd->PacketSize = localLen - 4; */ /* rfd->PacketSize = len - 4; */
pMpRfd->PacketSize = localLen; rfd->PacketSize = len;
skb = dev_alloc_skb(pMpRfd->PacketSize + 2); skb = dev_alloc_skb(rfd->PacketSize + 2);
if (!skb) { if (!skb) {
dev_err(&etdev->pdev->dev, dev_err(&etdev->pdev->dev,
"Couldn't alloc an SKB for Rx\n"); "Couldn't alloc an SKB for Rx\n");
return NULL; return NULL;
} }
etdev->net_stats.rx_bytes += pMpRfd->PacketSize; etdev->net_stats.rx_bytes += rfd->PacketSize;
memcpy(skb_put(skb, pMpRfd->PacketSize), memcpy(skb_put(skb, rfd->PacketSize),
pRxLocal->Fbr[ringIndex]->Va[bufferIndex], rx_local->Fbr[rindex]->Va[bindex],
pMpRfd->PacketSize); rfd->PacketSize);
skb->dev = etdev->netdev; skb->dev = etdev->netdev;
skb->protocol = eth_type_trans(skb, etdev->netdev); skb->protocol = eth_type_trans(skb, etdev->netdev);
@ -1035,11 +1035,11 @@ PMP_RFD nic_rx_pkts(struct et131x_adapter *etdev)
netif_rx(skb); netif_rx(skb);
} else { } else {
pMpRfd->PacketSize = 0; rfd->PacketSize = 0;
} }
nic_return_rfd(etdev, pMpRfd); nic_return_rfd(etdev, rfd);
return pMpRfd; return rfd;
} }
/** /**
@ -1050,7 +1050,7 @@ PMP_RFD nic_rx_pkts(struct et131x_adapter *etdev)
*/ */
void et131x_reset_recv(struct et131x_adapter *etdev) void et131x_reset_recv(struct et131x_adapter *etdev)
{ {
PMP_RFD pMpRfd; PMP_RFD rfd;
struct list_head *element; struct list_head *element;
WARN_ON(list_empty(&etdev->RxRing.RecvList)); WARN_ON(list_empty(&etdev->RxRing.RecvList));
@ -1061,9 +1061,9 @@ void et131x_reset_recv(struct et131x_adapter *etdev)
while (!list_empty(&etdev->RxRing.RecvPendingList)) { while (!list_empty(&etdev->RxRing.RecvPendingList)) {
element = etdev->RxRing.RecvPendingList.next; element = etdev->RxRing.RecvPendingList.next;
pMpRfd = (PMP_RFD) list_entry(element, MP_RFD, list_node); rfd = (PMP_RFD) list_entry(element, MP_RFD, list_node);
list_move_tail(&pMpRfd->list_node, &etdev->RxRing.RecvList); list_move_tail(&rfd->list_node, &etdev->RxRing.RecvList);
} }
} }
@ -1075,27 +1075,24 @@ void et131x_reset_recv(struct et131x_adapter *etdev)
*/ */
void et131x_handle_recv_interrupt(struct et131x_adapter *etdev) void et131x_handle_recv_interrupt(struct et131x_adapter *etdev)
{ {
PMP_RFD pMpRfd = NULL; PMP_RFD rfd = NULL;
struct sk_buff *PacketArray[NUM_PACKETS_HANDLED]; struct sk_buff *packets[NUM_PACKETS_HANDLED];
PMP_RFD RFDFreeArray[NUM_PACKETS_HANDLED]; PMP_RFD freed[NUM_PACKETS_HANDLED];
uint32_t PacketArrayCount = 0; u32 count = 0;
uint32_t PacketsToHandle; u32 nfree = 0;
uint32_t PacketFreeCount = 0; bool done = true;
bool TempUnfinishedRec = false;
PacketsToHandle = NUM_PACKETS_HANDLED;
/* Process up to available RFD's */ /* Process up to available RFD's */
while (PacketArrayCount < PacketsToHandle) { while (count < NUM_PACKETS_HANDLED) {
if (list_empty(&etdev->RxRing.RecvList)) { if (list_empty(&etdev->RxRing.RecvList)) {
WARN_ON(etdev->RxRing.nReadyRecv != 0); WARN_ON(etdev->RxRing.nReadyRecv != 0);
TempUnfinishedRec = true; done = false;
break; break;
} }
pMpRfd = nic_rx_pkts(etdev); rfd = nic_rx_pkts(etdev);
if (pMpRfd == NULL) if (rfd == NULL)
break; break;
/* Do not receive any packets until a filter has been set. /* Do not receive any packets until a filter has been set.
@ -1105,7 +1102,7 @@ void et131x_handle_recv_interrupt(struct et131x_adapter *etdev)
*/ */
if (!etdev->PacketFilter || if (!etdev->PacketFilter ||
!(etdev->Flags & fMP_ADAPTER_LINK_DETECTION) || !(etdev->Flags & fMP_ADAPTER_LINK_DETECTION) ||
pMpRfd->PacketSize == 0) { rfd->PacketSize == 0) {
continue; continue;
} }
@ -1123,26 +1120,25 @@ void et131x_handle_recv_interrupt(struct et131x_adapter *etdev)
* pending list anyway. * pending list anyway.
*/ */
} else { } else {
RFDFreeArray[PacketFreeCount] = pMpRfd; freed[nfree] = rfd;
PacketFreeCount++; nfree++;
dev_warn(&etdev->pdev->dev, dev_warn(&etdev->pdev->dev,
"RFD's are running out\n"); "RFD's are running out\n");
} }
PacketArray[PacketArrayCount] = pMpRfd->Packet; packets[count] = rfd->Packet;
PacketArrayCount++; count++;
} }
if ((PacketArrayCount == NUM_PACKETS_HANDLED) || TempUnfinishedRec) { if (count == NUM_PACKETS_HANDLED || !done) {
etdev->RxRing.UnfinishedReceives = true; etdev->RxRing.UnfinishedReceives = true;
writel(PARM_TX_TIME_INT_DEF * NANO_IN_A_MICRO, writel(PARM_TX_TIME_INT_DEF * NANO_IN_A_MICRO,
&etdev->regs->global.watchdog_timer); &etdev->regs->global.watchdog_timer);
} else { } else
/* Watchdog timer will disable itself if appropriate. */ /* Watchdog timer will disable itself if appropriate. */
etdev->RxRing.UnfinishedReceives = false; etdev->RxRing.UnfinishedReceives = false;
} }
}
static inline u32 bump_fbr(u32 *fbr, u32 limit) static inline u32 bump_fbr(u32 *fbr, u32 limit)
{ {
@ -1165,14 +1161,14 @@ static inline u32 bump_fbr(u32 *fbr, u32 limit)
/** /**
* NICReturnRFD - Recycle a RFD and put it back onto the receive list * NICReturnRFD - Recycle a RFD and put it back onto the receive list
* @etdev: pointer to our adapter * @etdev: pointer to our adapter
* @pMpRfd: pointer to the RFD * @rfd: pointer to the RFD
*/ */
void nic_return_rfd(struct et131x_adapter *etdev, PMP_RFD pMpRfd) void nic_return_rfd(struct et131x_adapter *etdev, PMP_RFD rfd)
{ {
struct _rx_ring_t *rx_local = &etdev->RxRing; struct _rx_ring_t *rx_local = &etdev->RxRing;
struct _RXDMA_t __iomem *rx_dma = &etdev->regs->rxdma; struct _RXDMA_t __iomem *rx_dma = &etdev->regs->rxdma;
uint16_t bi = pMpRfd->bufferindex; uint16_t bi = rfd->bufferindex;
uint8_t ri = pMpRfd->ringindex; uint8_t ri = rfd->ringindex;
unsigned long flags; unsigned long flags;
/* We don't use any of the OOB data besides status. Otherwise, we /* We don't use any of the OOB data besides status. Otherwise, we
@ -1186,7 +1182,7 @@ void nic_return_rfd(struct et131x_adapter *etdev, PMP_RFD pMpRfd)
spin_lock_irqsave(&etdev->FbrLock, flags); spin_lock_irqsave(&etdev->FbrLock, flags);
if (ri == 1) { if (ri == 1) {
PFBR_DESC_t pNextDesc = PFBR_DESC_t next =
(PFBR_DESC_t) (rx_local->pFbr1RingVa) + (PFBR_DESC_t) (rx_local->pFbr1RingVa) +
INDEX10(rx_local->local_Fbr1_full); INDEX10(rx_local->local_Fbr1_full);
@ -1194,9 +1190,9 @@ void nic_return_rfd(struct et131x_adapter *etdev, PMP_RFD pMpRfd)
* the PA / Buffer Index for the returned buffer into * the PA / Buffer Index for the returned buffer into
* the oldest (next to be freed)FBR entry * the oldest (next to be freed)FBR entry
*/ */
pNextDesc->addr_hi = rx_local->Fbr[1]->PAHigh[bi]; next->addr_hi = rx_local->Fbr[1]->PAHigh[bi];
pNextDesc->addr_lo = rx_local->Fbr[1]->PALow[bi]; next->addr_lo = rx_local->Fbr[1]->PALow[bi];
pNextDesc->word2.value = bi; next->word2.value = bi;
writel(bump_fbr(&rx_local->local_Fbr1_full, writel(bump_fbr(&rx_local->local_Fbr1_full,
rx_local->Fbr1NumEntries - 1), rx_local->Fbr1NumEntries - 1),
@ -1204,7 +1200,7 @@ void nic_return_rfd(struct et131x_adapter *etdev, PMP_RFD pMpRfd)
} }
#ifdef USE_FBR0 #ifdef USE_FBR0
else { else {
PFBR_DESC_t pNextDesc = PFBR_DESC_t next =
(PFBR_DESC_t) rx_local->pFbr0RingVa + (PFBR_DESC_t) rx_local->pFbr0RingVa +
INDEX10(rx_local->local_Fbr0_full); INDEX10(rx_local->local_Fbr0_full);
@ -1212,9 +1208,9 @@ void nic_return_rfd(struct et131x_adapter *etdev, PMP_RFD pMpRfd)
* the PA / Buffer Index for the returned buffer into * the PA / Buffer Index for the returned buffer into
* the oldest (next to be freed) FBR entry * the oldest (next to be freed) FBR entry
*/ */
pNextDesc->addr_hi = rx_local->Fbr[0]->PAHigh[bi]; next->addr_hi = rx_local->Fbr[0]->PAHigh[bi];
pNextDesc->addr_lo = rx_local->Fbr[0]->PALow[bi]; next->addr_lo = rx_local->Fbr[0]->PALow[bi];
pNextDesc->word2.value = bi; next->word2.value = bi;
writel(bump_fbr(&rx_local->local_Fbr0_full, writel(bump_fbr(&rx_local->local_Fbr0_full,
rx_local->Fbr0NumEntries - 1), rx_local->Fbr0NumEntries - 1),
@ -1231,7 +1227,7 @@ void nic_return_rfd(struct et131x_adapter *etdev, PMP_RFD pMpRfd)
* our list * our list
*/ */
spin_lock_irqsave(&etdev->RcvLock, flags); spin_lock_irqsave(&etdev->RcvLock, flags);
list_add_tail(&pMpRfd->list_node, &rx_local->RecvList); list_add_tail(&rfd->list_node, &rx_local->RecvList);
rx_local->nReadyRecv++; rx_local->nReadyRecv++;
spin_unlock_irqrestore(&etdev->RcvLock, flags); spin_unlock_irqrestore(&etdev->RcvLock, flags);