UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

ipg: naming convention fixes 

This changes some camel-case names to follow proper kernel naming convention.

Signed-off-by: Pekka Enberg <penberg@cs.helsinki.fi>
Cc: Francois Romieu <romieu@fr.zoreil.com>
Cc: Sorbica Shieh <sorbica@icplus.com.tw>
Cc: Jesse Huang <jesse@icplus.com.tw>
Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
Pekka Enberg 2008-01-24 02:01:17 -08:00 committed by David S. Miller
parent dea4a87cab
commit 9893ba16c8
2 changed files with 97 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

174
drivers/net/ipg.c
View File

@ -382,13 +382,13 @@ static void ipg_set_led_mode(struct net_device *dev)
mode = ipg_r32(ASIC_CTRL); mode = ipg_r32(ASIC_CTRL);
mode &= ~(IPG_AC_LED_MODE_BIT_1 | IPG_AC_LED_MODE | IPG_AC_LED_SPEED); mode &= ~(IPG_AC_LED_MODE_BIT_1 | IPG_AC_LED_MODE | IPG_AC_LED_SPEED);
if ((sp->LED_Mode & 0x03) > 1) if ((sp->led_mode & 0x03) > 1)
mode |= IPG_AC_LED_MODE_BIT_1; /* Write Asic Control Bit 29 */ mode |= IPG_AC_LED_MODE_BIT_1; /* Write Asic Control Bit 29 */
if ((sp->LED_Mode & 0x01) == 1) if ((sp->led_mode & 0x01) == 1)
mode |= IPG_AC_LED_MODE; /* Write Asic Control Bit 14 */ mode |= IPG_AC_LED_MODE; /* Write Asic Control Bit 14 */
if ((sp->LED_Mode & 0x08) == 8) if ((sp->led_mode & 0x08) == 8)
mode |= IPG_AC_LED_SPEED; /* Write Asic Control Bit 27 */ mode |= IPG_AC_LED_SPEED; /* Write Asic Control Bit 27 */
ipg_w32(mode, ASIC_CTRL); ipg_w32(mode, ASIC_CTRL);
@ -402,7 +402,7 @@ static void ipg_set_phy_set(struct net_device *dev)
physet = ipg_r8(PHY_SET); physet = ipg_r8(PHY_SET);
physet &= ~(IPG_PS_MEM_LENB9B | IPG_PS_MEM_LEN9 | IPG_PS_NON_COMPDET); physet &= ~(IPG_PS_MEM_LENB9B | IPG_PS_MEM_LEN9 | IPG_PS_NON_COMPDET);
physet |= ((sp->LED_Mode & 0x70) >> 4); physet |= ((sp->led_mode & 0x70) >> 4);
ipg_w8(physet, PHY_SET); ipg_w8(physet, PHY_SET);
} }
@ -733,7 +733,7 @@ static int ipg_get_rxbuff(struct net_device *dev, int entry)
skb = netdev_alloc_skb(dev, IPG_RXSUPPORT_SIZE + NET_IP_ALIGN); skb = netdev_alloc_skb(dev, IPG_RXSUPPORT_SIZE + NET_IP_ALIGN);
if (!skb) { if (!skb) {
sp->RxBuff[entry] = NULL; sp->rx_buff[entry] = NULL;
return -ENOMEM; return -ENOMEM;
} }
@ -746,7 +746,7 @@ static int ipg_get_rxbuff(struct net_device *dev, int entry)
skb->dev = dev; skb->dev = dev;
/* Save the address of the sk_buff structure. */ /* Save the address of the sk_buff structure. */
sp->RxBuff[entry] = skb; sp->rx_buff[entry] = skb;
rxfd->frag_info = cpu_to_le64(pci_map_single(sp->pdev, skb->data, rxfd->frag_info = cpu_to_le64(pci_map_single(sp->pdev, skb->data,
sp->rx_buf_sz, PCI_DMA_FROMDEVICE)); sp->rx_buf_sz, PCI_DMA_FROMDEVICE));
@ -769,12 +769,12 @@ static int init_rfdlist(struct net_device *dev)
for (i = 0; i < IPG_RFDLIST_LENGTH; i++) { for (i = 0; i < IPG_RFDLIST_LENGTH; i++) {
struct ipg_rx *rxfd = sp->rxd + i; struct ipg_rx *rxfd = sp->rxd + i;
if (sp->RxBuff[i]) { if (sp->rx_buff[i]) {
pci_unmap_single(sp->pdev, pci_unmap_single(sp->pdev,
le64_to_cpu(rxfd->frag_info) & ~IPG_RFI_FRAGLEN, le64_to_cpu(rxfd->frag_info) & ~IPG_RFI_FRAGLEN,
sp->rx_buf_sz, PCI_DMA_FROMDEVICE); sp->rx_buf_sz, PCI_DMA_FROMDEVICE);
dev_kfree_skb_irq(sp->RxBuff[i]); dev_kfree_skb_irq(sp->rx_buff[i]);
sp->RxBuff[i] = NULL; sp->rx_buff[i] = NULL;
} }
/* Clear out the RFS field. */ /* Clear out the RFS field. */
@ -825,9 +825,9 @@ static void init_tfdlist(struct net_device *dev)
txfd->tfc = cpu_to_le64(IPG_TFC_TFDDONE); txfd->tfc = cpu_to_le64(IPG_TFC_TFDDONE);
if (sp->TxBuff[i]) { if (sp->tx_buff[i]) {
dev_kfree_skb_irq(sp->TxBuff[i]); dev_kfree_skb_irq(sp->tx_buff[i]);
sp->TxBuff[i] = NULL; sp->tx_buff[i] = NULL;
} }
txfd->next_desc = cpu_to_le64(sp->txd_map + txfd->next_desc = cpu_to_le64(sp->txd_map +
@ -844,7 +844,7 @@ static void init_tfdlist(struct net_device *dev)
ipg_w32((u32) sp->txd_map, TFD_LIST_PTR_0); ipg_w32((u32) sp->txd_map, TFD_LIST_PTR_0);
ipg_w32(0x00000000, TFD_LIST_PTR_1); ipg_w32(0x00000000, TFD_LIST_PTR_1);
sp->ResetCurrentTFD = 1; sp->reset_current_tfd = 1;
} }
/* /*
@ -862,7 +862,7 @@ static void ipg_nic_txfree(struct net_device *dev)
dirty = sp->tx_dirty % IPG_TFDLIST_LENGTH; dirty = sp->tx_dirty % IPG_TFDLIST_LENGTH;
for (released = 0; released < pending; released++) { for (released = 0; released < pending; released++) {
struct sk_buff *skb = sp->TxBuff[dirty]; struct sk_buff *skb = sp->tx_buff[dirty];
struct ipg_tx *txfd = sp->txd + dirty; struct ipg_tx *txfd = sp->txd + dirty;
IPG_DEBUG_MSG("TFC = %16.16lx\n", (unsigned long) txfd->tfc); IPG_DEBUG_MSG("TFC = %16.16lx\n", (unsigned long) txfd->tfc);
@ -883,7 +883,7 @@ static void ipg_nic_txfree(struct net_device *dev)
dev_kfree_skb_irq(skb); dev_kfree_skb_irq(skb);
sp->TxBuff[dirty] = NULL; sp->tx_buff[dirty] = NULL;
} }
dirty = (dirty + 1) % IPG_TFDLIST_LENGTH; dirty = (dirty + 1) % IPG_TFDLIST_LENGTH;
} }
@ -1056,7 +1056,7 @@ static int ipg_nic_rxrestore(struct net_device *dev)
unsigned int entry = dirty % IPG_RFDLIST_LENGTH; unsigned int entry = dirty % IPG_RFDLIST_LENGTH;
/* rx_copybreak may poke hole here and there. */ /* rx_copybreak may poke hole here and there. */
if (sp->RxBuff[entry]) if (sp->rx_buff[entry])
continue; continue;
/* Generate a new receive buffer to replace the /* Generate a new receive buffer to replace the
@ -1087,15 +1087,15 @@ static int ipg_nic_rxrestore(struct net_device *dev)
previous receiving and need to continue dumping the current one previous receiving and need to continue dumping the current one
*/ */
enum { enum {
NormalPacket, NORMAL_PACKET,
ErrorPacket ERROR_PACKET
}; };
enum { enum {
Frame_NoStart_NoEnd = 0, FRAME_NO_START_NO_END = 0,
Frame_WithStart = 1, FRAME_WITH_START = 1,
Frame_WithEnd = 10, FRAME_WITH_END = 10,
Frame_WithStart_WithEnd = 11 FRAME_WITH_START_WITH_END = 11
}; };
inline void ipg_nic_rx_free_skb(struct net_device *dev) inline void ipg_nic_rx_free_skb(struct net_device *dev)
@ -1103,14 +1103,14 @@ inline void ipg_nic_rx_free_skb(struct net_device *dev)
struct ipg_nic_private *sp = netdev_priv(dev); struct ipg_nic_private *sp = netdev_priv(dev);
unsigned int entry = sp->rx_current % IPG_RFDLIST_LENGTH; unsigned int entry = sp->rx_current % IPG_RFDLIST_LENGTH;
if (sp->RxBuff[entry]) { if (sp->rx_buff[entry]) {
struct ipg_rx *rxfd = sp->rxd + entry; struct ipg_rx *rxfd = sp->rxd + entry;
pci_unmap_single(sp->pdev, pci_unmap_single(sp->pdev,
le64_to_cpu(rxfd->frag_info & ~IPG_RFI_FRAGLEN), le64_to_cpu(rxfd->frag_info & ~IPG_RFI_FRAGLEN),
sp->rx_buf_sz, PCI_DMA_FROMDEVICE); sp->rx_buf_sz, PCI_DMA_FROMDEVICE);
dev_kfree_skb_irq(sp->RxBuff[entry]); dev_kfree_skb_irq(sp->rx_buff[entry]);
sp->RxBuff[entry] = NULL; sp->rx_buff[entry] = NULL;
} }
} }
@ -1118,12 +1118,12 @@ inline int ipg_nic_rx_check_frame_type(struct net_device *dev)
{ {
struct ipg_nic_private *sp = netdev_priv(dev); struct ipg_nic_private *sp = netdev_priv(dev);
struct ipg_rx *rxfd = sp->rxd + (sp->rx_current % IPG_RFDLIST_LENGTH); struct ipg_rx *rxfd = sp->rxd + (sp->rx_current % IPG_RFDLIST_LENGTH);
int type = Frame_NoStart_NoEnd; int type = FRAME_NO_START_NO_END;
if (le64_to_cpu(rxfd->rfs) & IPG_RFS_FRAMESTART) if (le64_to_cpu(rxfd->rfs) & IPG_RFS_FRAMESTART)
type += Frame_WithStart; type += FRAME_WITH_START;
if (le64_to_cpu(rxfd->rfs) & IPG_RFS_FRAMEEND) if (le64_to_cpu(rxfd->rfs) & IPG_RFS_FRAMEEND)
type += Frame_WithEnd; type += FRAME_WITH_END;
return type; return type;
} }
@ -1172,39 +1172,39 @@ inline int ipg_nic_rx_check_error(struct net_device *dev)
* buffer since it is erroneous and we will * buffer since it is erroneous and we will
* not pass it to higher layer processes. * not pass it to higher layer processes.
*/ */
if (sp->RxBuff[entry]) { if (sp->rx_buff[entry]) {
pci_unmap_single(sp->pdev, pci_unmap_single(sp->pdev,
le64_to_cpu(rxfd->frag_info & ~IPG_RFI_FRAGLEN), le64_to_cpu(rxfd->frag_info & ~IPG_RFI_FRAGLEN),
sp->rx_buf_sz, PCI_DMA_FROMDEVICE); sp->rx_buf_sz, PCI_DMA_FROMDEVICE);
dev_kfree_skb_irq(sp->RxBuff[entry]); dev_kfree_skb_irq(sp->rx_buff[entry]);
sp->RxBuff[entry] = NULL; sp->rx_buff[entry] = NULL;
} }
return ErrorPacket; return ERROR_PACKET;
} }
return NormalPacket; return NORMAL_PACKET;
} }
static void ipg_nic_rx_with_start_and_end(struct net_device *dev, static void ipg_nic_rx_with_start_and_end(struct net_device *dev,
struct ipg_nic_private *sp, struct ipg_nic_private *sp,
struct ipg_rx *rxfd, unsigned entry) struct ipg_rx *rxfd, unsigned entry)
{ {
struct SJumbo *jumbo = &sp->Jumbo; struct ipg_jumbo *jumbo = &sp->jumbo;
struct sk_buff *skb; struct sk_buff *skb;
int framelen; int framelen;
if (jumbo->FoundStart) { if (jumbo->found_start) {
dev_kfree_skb_irq(jumbo->skb); dev_kfree_skb_irq(jumbo->skb);
jumbo->FoundStart = 0; jumbo->found_start = 0;
jumbo->CurrentSize = 0; jumbo->current_size = 0;
jumbo->skb = NULL; jumbo->skb = NULL;
} }
// 1: found error, 0 no error // 1: found error, 0 no error
if (ipg_nic_rx_check_error(dev) != NormalPacket) if (ipg_nic_rx_check_error(dev) != NORMAL_PACKET)
return; return;
skb = sp->RxBuff[entry]; skb = sp->rx_buff[entry];
if (!skb) if (!skb)
return; return;
@ -1218,27 +1218,27 @@ static void ipg_nic_rx_with_start_and_end(struct net_device *dev,
skb->ip_summed = CHECKSUM_NONE; skb->ip_summed = CHECKSUM_NONE;
netif_rx(skb); netif_rx(skb);
dev->last_rx = jiffies; dev->last_rx = jiffies;
sp->RxBuff[entry] = NULL; sp->rx_buff[entry] = NULL;
} }
static void ipg_nic_rx_with_start(struct net_device *dev, static void ipg_nic_rx_with_start(struct net_device *dev,
struct ipg_nic_private *sp, struct ipg_nic_private *sp,
struct ipg_rx *rxfd, unsigned entry) struct ipg_rx *rxfd, unsigned entry)
{ {
struct SJumbo *jumbo = &sp->Jumbo; struct ipg_jumbo *jumbo = &sp->jumbo;
struct pci_dev *pdev = sp->pdev; struct pci_dev *pdev = sp->pdev;
struct sk_buff *skb; struct sk_buff *skb;
// 1: found error, 0 no error // 1: found error, 0 no error
if (ipg_nic_rx_check_error(dev) != NormalPacket) if (ipg_nic_rx_check_error(dev) != NORMAL_PACKET)
return; return;
// accept this frame and send to upper layer // accept this frame and send to upper layer
skb = sp->RxBuff[entry]; skb = sp->rx_buff[entry];
if (!skb) if (!skb)
return; return;
if (jumbo->FoundStart) if (jumbo->found_start)
dev_kfree_skb_irq(jumbo->skb); dev_kfree_skb_irq(jumbo->skb);
pci_unmap_single(pdev, le64_to_cpu(rxfd->frag_info & ~IPG_RFI_FRAGLEN), pci_unmap_single(pdev, le64_to_cpu(rxfd->frag_info & ~IPG_RFI_FRAGLEN),
@ -1246,11 +1246,11 @@ static void ipg_nic_rx_with_start(struct net_device *dev,
skb_put(skb, IPG_RXFRAG_SIZE); skb_put(skb, IPG_RXFRAG_SIZE);
jumbo->FoundStart = 1; jumbo->found_start = 1;
jumbo->CurrentSize = IPG_RXFRAG_SIZE; jumbo->current_size = IPG_RXFRAG_SIZE;
jumbo->skb = skb; jumbo->skb = skb;
sp->RxBuff[entry] = NULL; sp->rx_buff[entry] = NULL;
dev->last_rx = jiffies; dev->last_rx = jiffies;
} }
@ -1258,21 +1258,21 @@ static void ipg_nic_rx_with_end(struct net_device *dev,
struct ipg_nic_private *sp, struct ipg_nic_private *sp,
struct ipg_rx *rxfd, unsigned entry) struct ipg_rx *rxfd, unsigned entry)
{ {
struct SJumbo *jumbo = &sp->Jumbo; struct ipg_jumbo *jumbo = &sp->jumbo;
//1: found error, 0 no error //1: found error, 0 no error
if (ipg_nic_rx_check_error(dev) == NormalPacket) { if (ipg_nic_rx_check_error(dev) == NORMAL_PACKET) {
struct sk_buff *skb = sp->RxBuff[entry]; struct sk_buff *skb = sp->rx_buff[entry];
if (!skb) if (!skb)
return; return;
if (jumbo->FoundStart) { if (jumbo->found_start) {
int framelen, endframelen; int framelen, endframelen;
framelen = le64_to_cpu(rxfd->rfs) & IPG_RFS_RXFRAMELEN; framelen = le64_to_cpu(rxfd->rfs) & IPG_RFS_RXFRAMELEN;
endframeLen = framelen - jumbo->CurrentSize; endframeLen = framelen - jumbo->current_size;
/* /*
if (framelen > IPG_RXFRAG_SIZE) if (framelen > IPG_RXFRAG_SIZE)
framelen=IPG_RXFRAG_SIZE; framelen=IPG_RXFRAG_SIZE;
@ -1292,15 +1292,15 @@ static void ipg_nic_rx_with_end(struct net_device *dev,
} }
dev->last_rx = jiffies; dev->last_rx = jiffies;
jumbo->FoundStart = 0; jumbo->found_start = 0;
jumbo->CurrentSize = 0; jumbo->current_size = 0;
jumbo->skb = NULL; jumbo->skb = NULL;
ipg_nic_rx_free_skb(dev); ipg_nic_rx_free_skb(dev);
} else { } else {
dev_kfree_skb_irq(jumbo->skb); dev_kfree_skb_irq(jumbo->skb);
jumbo->FoundStart = 0; jumbo->found_start = 0;
jumbo->CurrentSize = 0; jumbo->current_size = 0;
jumbo->skb = NULL; jumbo->skb = NULL;
} }
} }
@ -1309,16 +1309,16 @@ static void ipg_nic_rx_no_start_no_end(struct net_device *dev,
struct ipg_nic_private *sp, struct ipg_nic_private *sp,
struct ipg_rx *rxfd, unsigned entry) struct ipg_rx *rxfd, unsigned entry)
{ {
struct SJumbo *jumbo = &sp->Jumbo; struct ipg_jumbo *jumbo = &sp->jumbo;
//1: found error, 0 no error //1: found error, 0 no error
if (ipg_nic_rx_check_error(dev) == NormalPacket) { if (ipg_nic_rx_check_error(dev) == NORMAL_PACKET) {
struct sk_buff *skb = sp->RxBuff[entry]; struct sk_buff *skb = sp->rx_buff[entry];
if (skb) { if (skb) {
if (jumbo->FoundStart) { if (jumbo->found_start) {
jumbo->CurrentSize += IPG_RXFRAG_SIZE; jumbo->current_size += IPG_RXFRAG_SIZE;
if (jumbo->CurrentSize <= IPG_RXSUPPORT_SIZE) { if (jumbo->current_size <= IPG_RXSUPPORT_SIZE) {
memcpy(skb_put(jumbo->skb, memcpy(skb_put(jumbo->skb,
IPG_RXFRAG_SIZE), IPG_RXFRAG_SIZE),
skb->data, IPG_RXFRAG_SIZE); skb->data, IPG_RXFRAG_SIZE);
@ -1329,8 +1329,8 @@ static void ipg_nic_rx_no_start_no_end(struct net_device *dev,
} }
} else { } else {
dev_kfree_skb_irq(jumbo->skb); dev_kfree_skb_irq(jumbo->skb);
jumbo->FoundStart = 0; jumbo->found_start = 0;
jumbo->CurrentSize = 0; jumbo->current_size = 0;
jumbo->skb = NULL; jumbo->skb = NULL;
} }
} }
@ -1352,16 +1352,16 @@ static int ipg_nic_rx(struct net_device *dev)
break; break;
switch (ipg_nic_rx_check_frame_type(dev)) { switch (ipg_nic_rx_check_frame_type(dev)) {
case Frame_WithStart_WithEnd: case FRAME_WITH_START_WITH_END:
ipg_nic_rx_with_start_and_end(dev, tp, rxfd, entry); ipg_nic_rx_with_start_and_end(dev, tp, rxfd, entry);
break; break;
case Frame_WithStart: case FRAME_WITH_START:
ipg_nic_rx_with_start(dev, tp, rxfd, entry); ipg_nic_rx_with_start(dev, tp, rxfd, entry);
break; break;
case Frame_WithEnd: case FRAME_WITH_END:
ipg_nic_rx_with_end(dev, tp, rxfd, entry); ipg_nic_rx_with_end(dev, tp, rxfd, entry);
break; break;
case Frame_NoStart_NoEnd: case FRAME_NO_START_NO_END:
ipg_nic_rx_no_start_no_end(dev, tp, rxfd, entry); ipg_nic_rx_no_start_no_end(dev, tp, rxfd, entry);
break; break;
} }
@ -1400,7 +1400,7 @@ static int ipg_nic_rx(struct net_device *dev)
for (i = 0; i < IPG_MAXRFDPROCESS_COUNT; i++, curr++) { for (i = 0; i < IPG_MAXRFDPROCESS_COUNT; i++, curr++) {
unsigned int entry = curr % IPG_RFDLIST_LENGTH; unsigned int entry = curr % IPG_RFDLIST_LENGTH;
struct sk_buff *skb = sp->RxBuff[entry]; struct sk_buff *skb = sp->rx_buff[entry];
unsigned int framelen; unsigned int framelen;
rxfd = sp->rxd + entry; rxfd = sp->rxd + entry;
@ -1502,7 +1502,7 @@ static int ipg_nic_rx(struct net_device *dev)
} }
/* Assure RX buffer is not reused by IPG. */ /* Assure RX buffer is not reused by IPG. */
sp->RxBuff[entry] = NULL; sp->rx_buff[entry] = NULL;
} }
/* /*
@ -1536,15 +1536,15 @@ static int ipg_nic_rx(struct net_device *dev)
* buffer since it is erroneous and we will * buffer since it is erroneous and we will
* not pass it to higher layer processes. * not pass it to higher layer processes.
*/ */
if (sp->RxBuff[entry]) { if (sp->rx_buff[entry]) {
pci_unmap_single(sp->pdev, pci_unmap_single(sp->pdev,
le64_to_cpu(rxfd->frag_info) & ~IPG_RFI_FRAGLEN, le64_to_cpu(rxfd->frag_info) & ~IPG_RFI_FRAGLEN,
sp->rx_buf_sz, PCI_DMA_FROMDEVICE); sp->rx_buf_sz, PCI_DMA_FROMDEVICE);
dev_kfree_skb_irq(sp->RxBuff[entry]); dev_kfree_skb_irq(sp->rx_buff[entry]);
} }
/* Assure RX buffer is not reused by IPG. */ /* Assure RX buffer is not reused by IPG. */
sp->RxBuff[entry] = NULL; sp->rx_buff[entry] = NULL;
} }
sp->rx_current = curr; sp->rx_current = curr;
@ -1710,11 +1710,11 @@ static void ipg_rx_clear(struct ipg_nic_private *sp)
unsigned int i; unsigned int i;
for (i = 0; i < IPG_RFDLIST_LENGTH; i++) { for (i = 0; i < IPG_RFDLIST_LENGTH; i++) {
if (sp->RxBuff[i]) { if (sp->rx_buff[i]) {
struct ipg_rx *rxfd = sp->rxd + i; struct ipg_rx *rxfd = sp->rxd + i;
dev_kfree_skb_irq(sp->RxBuff[i]); dev_kfree_skb_irq(sp->rx_buff[i]);
sp->RxBuff[i] = NULL; sp->rx_buff[i] = NULL;
pci_unmap_single(sp->pdev, pci_unmap_single(sp->pdev,
le64_to_cpu(rxfd->frag_info) & ~IPG_RFI_FRAGLEN, le64_to_cpu(rxfd->frag_info) & ~IPG_RFI_FRAGLEN,
sp->rx_buf_sz, PCI_DMA_FROMDEVICE); sp->rx_buf_sz, PCI_DMA_FROMDEVICE);
@ -1727,16 +1727,16 @@ static void ipg_tx_clear(struct ipg_nic_private *sp)
unsigned int i; unsigned int i;
for (i = 0; i < IPG_TFDLIST_LENGTH; i++) { for (i = 0; i < IPG_TFDLIST_LENGTH; i++) {
if (sp->TxBuff[i]) { if (sp->tx_buff[i]) {
struct ipg_tx *txfd = sp->txd + i; struct ipg_tx *txfd = sp->txd + i;
pci_unmap_single(sp->pdev, pci_unmap_single(sp->pdev,
le64_to_cpu(txfd->frag_info) & ~IPG_TFI_FRAGLEN, le64_to_cpu(txfd->frag_info) & ~IPG_TFI_FRAGLEN,
sp->TxBuff[i]->len, PCI_DMA_TODEVICE); sp->tx_buff[i]->len, PCI_DMA_TODEVICE);
dev_kfree_skb_irq(sp->TxBuff[i]); dev_kfree_skb_irq(sp->tx_buff[i]);
sp->TxBuff[i] = NULL; sp->tx_buff[i] = NULL;
} }
} }
} }
@ -1807,9 +1807,9 @@ static int ipg_nic_open(struct net_device *dev)
#ifdef JUMBO_FRAME #ifdef JUMBO_FRAME
/* initialize JUMBO Frame control variable */ /* initialize JUMBO Frame control variable */
sp->Jumbo.FoundStart = 0; sp->jumbo.found_start = 0;
sp->Jumbo.CurrentSize = 0; sp->jumbo.current_size = 0;
sp->Jumbo.skb = 0; sp->jumbo.skb = 0;
dev->mtu = IPG_TXFRAG_SIZE; dev->mtu = IPG_TXFRAG_SIZE;
#endif #endif
@ -1884,14 +1884,14 @@ static int ipg_nic_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
if (sp->tenmbpsmode) if (sp->tenmbpsmode)
netif_stop_queue(dev); netif_stop_queue(dev);
if (sp->ResetCurrentTFD) { if (sp->reset_current_tfd) {
sp->ResetCurrentTFD = 0; sp->reset_current_tfd = 0;
entry = 0; entry = 0;
} }
txfd = sp->txd + entry; txfd = sp->txd + entry;
sp->TxBuff[entry] = skb; sp->tx_buff[entry] = skb;
/* Clear all TFC fields, except TFDDONE. */ /* Clear all TFC fields, except TFDDONE. */
txfd->tfc = cpu_to_le64(IPG_TFC_TFDDONE); txfd->tfc = cpu_to_le64(IPG_TFC_TFDDONE);
@ -2072,7 +2072,7 @@ static int ipg_hw_init(struct net_device *dev)
/* Read/Write and Reset EEPROM Value */ /* Read/Write and Reset EEPROM Value */
/* Read LED Mode Configuration from EEPROM */ /* Read LED Mode Configuration from EEPROM */
sp->LED_Mode = read_eeprom(dev, 6); sp->led_mode = read_eeprom(dev, 6);
/* Reset all functions within the IPG. Do not assert /* Reset all functions within the IPG. Do not assert
* RST_OUT as not compatible with some PHYs. * RST_OUT as not compatible with some PHYs.

19
drivers/net/ipg.h
View File

@ -626,7 +626,7 @@ enum ipg_regs {
#define IPG_MINUSEDRFDSTOFREE 0x80 #define IPG_MINUSEDRFDSTOFREE 0x80
/* specify the jumbo frame maximum size /* specify the jumbo frame maximum size
* per unit is 0x600 (the RxBuffer size that one RFD can carry) * per unit is 0x600 (the rx_buffer size that one RFD can carry)
*/ */
#define MAX_JUMBOSIZE 0x8 // max is 12K #define MAX_JUMBOSIZE 0x8 // max is 12K
@ -767,11 +767,12 @@ struct ipg_rx {
__le64 frag_info; __le64 frag_info;
}; };
struct SJumbo { struct ipg_jumbo {
int FoundStart; int found_start;
int CurrentSize; int current_size;
struct sk_buff *skb; struct sk_buff *skb;
}; };
/* Structure of IPG NIC specific data. */ /* Structure of IPG NIC specific data. */
struct ipg_nic_private { struct ipg_nic_private {
void __iomem *ioaddr; void __iomem *ioaddr;
@ -779,14 +780,14 @@ struct ipg_nic_private {
struct ipg_rx *rxd; struct ipg_rx *rxd;
dma_addr_t txd_map; dma_addr_t txd_map;
dma_addr_t rxd_map; dma_addr_t rxd_map;
struct sk_buff *TxBuff[IPG_TFDLIST_LENGTH]; struct sk_buff *tx_buff[IPG_TFDLIST_LENGTH];
struct sk_buff *RxBuff[IPG_RFDLIST_LENGTH]; struct sk_buff *rx_buff[IPG_RFDLIST_LENGTH];
unsigned int tx_current; unsigned int tx_current;
unsigned int tx_dirty; unsigned int tx_dirty;
unsigned int rx_current; unsigned int rx_current;
unsigned int rx_dirty; unsigned int rx_dirty;
#ifdef JUMBO_FRAME #ifdef JUMBO_FRAME
struct SJumbo Jumbo; struct ipg_jumbo jumbo;
#endif #endif
unsigned int rx_buf_sz; unsigned int rx_buf_sz;
struct pci_dev *pdev; struct pci_dev *pdev;
@ -795,12 +796,12 @@ struct ipg_nic_private {
spinlock_t lock; spinlock_t lock;
int tenmbpsmode; int tenmbpsmode;
u16 LED_Mode; u16 led_mode;
u16 station_addr[3]; /* Station Address in EEPROM Reg 0x10..0x12 */ u16 station_addr[3]; /* Station Address in EEPROM Reg 0x10..0x12 */
struct mutex mii_mutex; struct mutex mii_mutex;
struct mii_if_info mii_if; struct mii_if_info mii_if;
int ResetCurrentTFD; int reset_current_tfd;
#ifdef IPG_DEBUG #ifdef IPG_DEBUG
int RFDlistendCount; int RFDlistendCount;
int RFDListCheckedCount; int RFDListCheckedCount;