#define DRV_NAME "ipg"
MODULE_AUTHOR("IC Plus Corp. 2003");
-MODULE_DESCRIPTION("IC Plus IP1000 Gigabit Ethernet Adapter Linux Driver "
- DrvVer);
+MODULE_DESCRIPTION("IC Plus IP1000 Gigabit Ethernet Adapter Linux Driver");
MODULE_LICENSE("GPL");
//variable record -- index by leading revision/length
}
}
-/* Set LED_Mode JES20040127EEPROM */
static void ipg_set_led_mode(struct net_device *dev)
{
struct ipg_nic_private *sp = netdev_priv(dev);
mode = ipg_r32(ASIC_CTRL);
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 */
- if ((sp->LED_Mode & 0x01) == 1)
+ if ((sp->led_mode & 0x01) == 1)
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 */
ipg_w32(mode, ASIC_CTRL);
}
-/* Set PHYSet JES20040127EEPROM */
static void ipg_set_phy_set(struct net_device *dev)
{
struct ipg_nic_private *sp = netdev_priv(dev);
physet = ipg_r8(PHY_SET);
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);
}
* register as specified by the 'resetflags' input
* parameter.
*/
- void __iomem *ioaddr = ipg_ioaddr(dev); //JES20040127EEPROM:
+ void __iomem *ioaddr = ipg_ioaddr(dev);
unsigned int timeout_count = 0;
IPG_DEBUG_MSG("_reset\n");
if (++timeout_count > IPG_AC_RESET_TIMEOUT)
return -ETIME;
}
- /* Set LED Mode in Asic Control JES20040127EEPROM */
+ /* Set LED Mode in Asic Control */
ipg_set_led_mode(dev);
- /* Set PHYSet Register Value JES20040127EEPROM */
+ /* Set PHYSet Register Value */
ipg_set_phy_set(dev);
return 0;
}
skb = netdev_alloc_skb(dev, IPG_RXSUPPORT_SIZE + NET_IP_ALIGN);
if (!skb) {
- sp->RxBuff[entry] = NULL;
+ sp->rx_buff[entry] = NULL;
return -ENOMEM;
}
skb->dev = dev;
/* 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,
sp->rx_buf_sz, PCI_DMA_FROMDEVICE));
for (i = 0; i < IPG_RFDLIST_LENGTH; i++) {
struct ipg_rx *rxfd = sp->rxd + i;
- if (sp->RxBuff[i]) {
+ if (sp->rx_buff[i]) {
pci_unmap_single(sp->pdev,
le64_to_cpu(rxfd->frag_info) & ~IPG_RFI_FRAGLEN,
sp->rx_buf_sz, PCI_DMA_FROMDEVICE);
- IPG_DEV_KFREE_SKB(sp->RxBuff[i]);
- sp->RxBuff[i] = NULL;
+ dev_kfree_skb_irq(sp->rx_buff[i]);
+ sp->rx_buff[i] = NULL;
}
/* Clear out the RFS field. */
txfd->tfc = cpu_to_le64(IPG_TFC_TFDDONE);
- if (sp->TxBuff[i]) {
- IPG_DEV_KFREE_SKB(sp->TxBuff[i]);
- sp->TxBuff[i] = NULL;
+ if (sp->tx_buff[i]) {
+ dev_kfree_skb_irq(sp->tx_buff[i]);
+ sp->tx_buff[i] = NULL;
}
txfd->next_desc = cpu_to_le64(sp->txd_map +
ipg_w32((u32) sp->txd_map, TFD_LIST_PTR_0);
ipg_w32(0x00000000, TFD_LIST_PTR_1);
- sp->ResetCurrentTFD = 1;
+ sp->reset_current_tfd = 1;
}
/*
static void ipg_nic_txfree(struct net_device *dev)
{
struct ipg_nic_private *sp = netdev_priv(dev);
- void __iomem *ioaddr = sp->ioaddr;
- unsigned int curr;
- u64 txd_map;
- unsigned int released, pending;
-
- txd_map = (u64)sp->txd_map;
- curr = ipg_r32(TFD_LIST_PTR_0) -
- do_div(txd_map, sizeof(struct ipg_tx)) - 1;
+ unsigned int released, pending, dirty;
IPG_DEBUG_MSG("_nic_txfree\n");
pending = sp->tx_current - sp->tx_dirty;
+ dirty = sp->tx_dirty % IPG_TFDLIST_LENGTH;
for (released = 0; released < pending; released++) {
- unsigned int dirty = sp->tx_dirty % IPG_TFDLIST_LENGTH;
- struct sk_buff *skb = sp->TxBuff[dirty];
+ struct sk_buff *skb = sp->tx_buff[dirty];
struct ipg_tx *txfd = sp->txd + dirty;
IPG_DEBUG_MSG("TFC = %16.16lx\n", (unsigned long) txfd->tfc);
* If the TFDDone bit is set, free the associated
* buffer.
*/
- if (dirty == curr)
- break;
-
- /* Setup TFDDONE for compatible issue. */
- txfd->tfc |= cpu_to_le64(IPG_TFC_TFDDONE);
+ if (!(txfd->tfc & cpu_to_le64(IPG_TFC_TFDDONE)))
+ break;
/* Free the transmit buffer. */
if (skb) {
le64_to_cpu(txfd->frag_info) & ~IPG_TFI_FRAGLEN,
skb->len, PCI_DMA_TODEVICE);
- IPG_DEV_KFREE_SKB(skb);
+ dev_kfree_skb_irq(skb);
- sp->TxBuff[dirty] = NULL;
+ sp->tx_buff[dirty] = NULL;
}
+ dirty = (dirty + 1) % IPG_TFDLIST_LENGTH;
}
sp->tx_dirty += released;
unsigned int entry = dirty % IPG_RFDLIST_LENGTH;
/* rx_copybreak may poke hole here and there. */
- if (sp->RxBuff[entry])
+ if (sp->rx_buff[entry])
continue;
/* Generate a new receive buffer to replace the
previous receiving and need to continue dumping the current one
*/
enum {
- NormalPacket,
- ErrorPacket
+ NORMAL_PACKET,
+ ERROR_PACKET
};
enum {
- Frame_NoStart_NoEnd = 0,
- Frame_WithStart = 1,
- Frame_WithEnd = 10,
- Frame_WithStart_WithEnd = 11
+ FRAME_NO_START_NO_END = 0,
+ FRAME_WITH_START = 1,
+ FRAME_WITH_END = 10,
+ FRAME_WITH_START_WITH_END = 11
};
inline void ipg_nic_rx_free_skb(struct net_device *dev)
struct ipg_nic_private *sp = netdev_priv(dev);
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;
pci_unmap_single(sp->pdev,
le64_to_cpu(rxfd->frag_info & ~IPG_RFI_FRAGLEN),
sp->rx_buf_sz, PCI_DMA_FROMDEVICE);
- IPG_DEV_KFREE_SKB(sp->RxBuff[entry]);
- sp->RxBuff[entry] = NULL;
+ dev_kfree_skb_irq(sp->rx_buff[entry]);
+ sp->rx_buff[entry] = NULL;
}
}
{
struct ipg_nic_private *sp = netdev_priv(dev);
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)
- type += Frame_WithStart;
+ type += FRAME_WITH_START;
if (le64_to_cpu(rxfd->rfs) & IPG_RFS_FRAMEEND)
- type += Frame_WithEnd;
+ type += FRAME_WITH_END;
return type;
}
* buffer since it is erroneous and we will
* not pass it to higher layer processes.
*/
- if (sp->RxBuff[entry]) {
+ if (sp->rx_buff[entry]) {
pci_unmap_single(sp->pdev,
le64_to_cpu(rxfd->frag_info & ~IPG_RFI_FRAGLEN),
sp->rx_buf_sz, PCI_DMA_FROMDEVICE);
- IPG_DEV_KFREE_SKB(sp->RxBuff[entry]);
- sp->RxBuff[entry] = NULL;
+ dev_kfree_skb_irq(sp->rx_buff[entry]);
+ 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,
struct ipg_nic_private *sp,
struct ipg_rx *rxfd, unsigned entry)
{
- struct SJumbo *jumbo = &sp->Jumbo;
+ struct ipg_jumbo *jumbo = &sp->jumbo;
struct sk_buff *skb;
int framelen;
- if (jumbo->FoundStart) {
- IPG_DEV_KFREE_SKB(jumbo->skb);
- jumbo->FoundStart = 0;
- jumbo->CurrentSize = 0;
+ if (jumbo->found_start) {
+ dev_kfree_skb_irq(jumbo->skb);
+ jumbo->found_start = 0;
+ jumbo->current_size = 0;
jumbo->skb = NULL;
}
// 1: found error, 0 no error
- if (ipg_nic_rx_check_error(dev) != NormalPacket)
+ if (ipg_nic_rx_check_error(dev) != NORMAL_PACKET)
return;
- skb = sp->RxBuff[entry];
+ skb = sp->rx_buff[entry];
if (!skb)
return;
skb->ip_summed = CHECKSUM_NONE;
netif_rx(skb);
dev->last_rx = jiffies;
- sp->RxBuff[entry] = NULL;
+ sp->rx_buff[entry] = NULL;
}
static void ipg_nic_rx_with_start(struct net_device *dev,
struct ipg_nic_private *sp,
struct ipg_rx *rxfd, unsigned entry)
{
- struct SJumbo *jumbo = &sp->Jumbo;
+ struct ipg_jumbo *jumbo = &sp->jumbo;
struct pci_dev *pdev = sp->pdev;
struct sk_buff *skb;
// 1: found error, 0 no error
- if (ipg_nic_rx_check_error(dev) != NormalPacket)
+ if (ipg_nic_rx_check_error(dev) != NORMAL_PACKET)
return;
// accept this frame and send to upper layer
- skb = sp->RxBuff[entry];
+ skb = sp->rx_buff[entry];
if (!skb)
return;
- if (jumbo->FoundStart)
- IPG_DEV_KFREE_SKB(jumbo->skb);
+ if (jumbo->found_start)
+ dev_kfree_skb_irq(jumbo->skb);
pci_unmap_single(pdev, le64_to_cpu(rxfd->frag_info & ~IPG_RFI_FRAGLEN),
sp->rx_buf_sz, PCI_DMA_FROMDEVICE);
skb_put(skb, IPG_RXFRAG_SIZE);
- jumbo->FoundStart = 1;
- jumbo->CurrentSize = IPG_RXFRAG_SIZE;
+ jumbo->found_start = 1;
+ jumbo->current_size = IPG_RXFRAG_SIZE;
jumbo->skb = skb;
- sp->RxBuff[entry] = NULL;
+ sp->rx_buff[entry] = NULL;
dev->last_rx = jiffies;
}
struct ipg_nic_private *sp,
struct ipg_rx *rxfd, unsigned entry)
{
- struct SJumbo *jumbo = &sp->Jumbo;
+ struct ipg_jumbo *jumbo = &sp->jumbo;
//1: found error, 0 no error
- if (ipg_nic_rx_check_error(dev) == NormalPacket) {
- struct sk_buff *skb = sp->RxBuff[entry];
+ if (ipg_nic_rx_check_error(dev) == NORMAL_PACKET) {
+ struct sk_buff *skb = sp->rx_buff[entry];
if (!skb)
return;
- if (jumbo->FoundStart) {
+ if (jumbo->found_start) {
int framelen, endframelen;
framelen = le64_to_cpu(rxfd->rfs) & IPG_RFS_RXFRAMELEN;
- endframeLen = framelen - jumbo->CurrentSize;
+ endframeLen = framelen - jumbo->current_size;
/*
if (framelen > IPG_RXFRAG_SIZE)
framelen=IPG_RXFRAG_SIZE;
*/
if (framelen > IPG_RXSUPPORT_SIZE)
- IPG_DEV_KFREE_SKB(jumbo->skb);
+ dev_kfree_skb_irq(jumbo->skb);
else {
memcpy(skb_put(jumbo->skb, endframeLen),
skb->data, endframeLen);
}
dev->last_rx = jiffies;
- jumbo->FoundStart = 0;
- jumbo->CurrentSize = 0;
+ jumbo->found_start = 0;
+ jumbo->current_size = 0;
jumbo->skb = NULL;
ipg_nic_rx_free_skb(dev);
} else {
- IPG_DEV_KFREE_SKB(jumbo->skb);
- jumbo->FoundStart = 0;
- jumbo->CurrentSize = 0;
+ dev_kfree_skb_irq(jumbo->skb);
+ jumbo->found_start = 0;
+ jumbo->current_size = 0;
jumbo->skb = NULL;
}
}
struct ipg_nic_private *sp,
struct ipg_rx *rxfd, unsigned entry)
{
- struct SJumbo *jumbo = &sp->Jumbo;
+ struct ipg_jumbo *jumbo = &sp->jumbo;
//1: found error, 0 no error
- if (ipg_nic_rx_check_error(dev) == NormalPacket) {
- struct sk_buff *skb = sp->RxBuff[entry];
+ if (ipg_nic_rx_check_error(dev) == NORMAL_PACKET) {
+ struct sk_buff *skb = sp->rx_buff[entry];
if (skb) {
- if (jumbo->FoundStart) {
- jumbo->CurrentSize += IPG_RXFRAG_SIZE;
- if (jumbo->CurrentSize <= IPG_RXSUPPORT_SIZE) {
+ if (jumbo->found_start) {
+ jumbo->current_size += IPG_RXFRAG_SIZE;
+ if (jumbo->current_size <= IPG_RXSUPPORT_SIZE) {
memcpy(skb_put(jumbo->skb,
IPG_RXFRAG_SIZE),
skb->data, IPG_RXFRAG_SIZE);
ipg_nic_rx_free_skb(dev);
}
} else {
- IPG_DEV_KFREE_SKB(jumbo->skb);
- jumbo->FoundStart = 0;
- jumbo->CurrentSize = 0;
+ dev_kfree_skb_irq(jumbo->skb);
+ jumbo->found_start = 0;
+ jumbo->current_size = 0;
jumbo->skb = NULL;
}
}
break;
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);
break;
- case Frame_WithStart:
+ case FRAME_WITH_START:
ipg_nic_rx_with_start(dev, tp, rxfd, entry);
break;
- case Frame_WithEnd:
+ case FRAME_WITH_END:
ipg_nic_rx_with_end(dev, tp, rxfd, entry);
break;
- case Frame_NoStart_NoEnd:
+ case FRAME_NO_START_NO_END:
ipg_nic_rx_no_start_no_end(dev, tp, rxfd, entry);
break;
}
for (i = 0; i < IPG_MAXRFDPROCESS_COUNT; i++, curr++) {
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;
rxfd = sp->rxd + entry;
le64_to_cpu(info) & ~IPG_RFI_FRAGLEN,
sp->rx_buf_sz, PCI_DMA_FROMDEVICE);
- IPG_DEV_KFREE_SKB(skb);
+ dev_kfree_skb_irq(skb);
}
} else {
/* Set the buffer's protocol field to Ethernet. */
skb->protocol = eth_type_trans(skb, dev);
- /* If the frame contains an IP/TCP/UDP frame,
- * determine if upper layer must check IP/TCP/UDP
- * checksums.
- *
- * NOTE: DO NOT RELY ON THE TCP/UDP CHECKSUM
- * VERIFICATION FOR SILICON REVISIONS B3
- * AND EARLIER!
- *
- if ((le64_to_cpu(rxfd->rfs &
- (IPG_RFS_TCPDETECTED | IPG_RFS_UDPDETECTED |
- IPG_RFS_IPDETECTED))) &&
- !(le64_to_cpu(rxfd->rfs &
- (IPG_RFS_TCPERROR | IPG_RFS_UDPERROR |
- IPG_RFS_IPERROR)))) {
- * Indicate IP checksums were performed
- * by the IPG.
- *
- skb->ip_summed = CHECKSUM_UNNECESSARY;
- } else
+ /* The IPG encountered an error with (or
+ * there were no) IP/TCP/UDP checksums.
+ * This may or may not indicate an invalid
+ * IP/TCP/UDP frame was received. Let the
+ * upper layer decide.
*/
- {
- /* The IPG encountered an error with (or
- * there were no) IP/TCP/UDP checksums.
- * This may or may not indicate an invalid
- * IP/TCP/UDP frame was received. Let the
- * upper layer decide.
- */
- skb->ip_summed = CHECKSUM_NONE;
- }
+ skb->ip_summed = CHECKSUM_NONE;
/* Hand off frame for higher layer processing.
* The function netif_rx() releases the sk_buff
}
/* Assure RX buffer is not reused by IPG. */
- sp->RxBuff[entry] = NULL;
+ sp->rx_buff[entry] = NULL;
}
/*
* buffer since it is erroneous and we will
* not pass it to higher layer processes.
*/
- if (sp->RxBuff[entry]) {
+ if (sp->rx_buff[entry]) {
pci_unmap_single(sp->pdev,
le64_to_cpu(rxfd->frag_info) & ~IPG_RFI_FRAGLEN,
sp->rx_buf_sz, PCI_DMA_FROMDEVICE);
- IPG_DEV_KFREE_SKB(sp->RxBuff[entry]);
+ dev_kfree_skb_irq(sp->rx_buff[entry]);
}
/* Assure RX buffer is not reused by IPG. */
- sp->RxBuff[entry] = NULL;
+ sp->rx_buff[entry] = NULL;
}
sp->rx_current = curr;
#ifdef JUMBO_FRAME
ipg_nic_rxrestore(dev);
#endif
+ spin_lock(&sp->lock);
+
/* Get interrupt source information, and acknowledge
* some (i.e. TxDMAComplete, RxDMAComplete, RxEarly,
* IntRequested, MacControlFrame, LinkEvent) interrupts
handled = 1;
if (unlikely(!netif_running(dev)))
- goto out;
-
- spin_lock(&sp->lock);
+ goto out_unlock;
/* If RFDListEnd interrupt, restore all used RFDs. */
if (status & IPG_IS_RFD_LIST_END) {
ipg_w16(IPG_IE_TX_DMA_COMPLETE | IPG_IE_RX_DMA_COMPLETE |
IPG_IE_HOST_ERROR | IPG_IE_INT_REQUESTED | IPG_IE_TX_COMPLETE |
IPG_IE_LINK_EVENT | IPG_IE_UPDATE_STATS, INT_ENABLE);
-
+out_unlock:
spin_unlock(&sp->lock);
-out:
+
return IRQ_RETVAL(handled);
}
unsigned int 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;
- IPG_DEV_KFREE_SKB(sp->RxBuff[i]);
- sp->RxBuff[i] = NULL;
+ dev_kfree_skb_irq(sp->rx_buff[i]);
+ sp->rx_buff[i] = NULL;
pci_unmap_single(sp->pdev,
le64_to_cpu(rxfd->frag_info) & ~IPG_RFI_FRAGLEN,
sp->rx_buf_sz, PCI_DMA_FROMDEVICE);
unsigned int 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;
pci_unmap_single(sp->pdev,
le64_to_cpu(txfd->frag_info) & ~IPG_TFI_FRAGLEN,
- sp->TxBuff[i]->len, PCI_DMA_TODEVICE);
+ sp->tx_buff[i]->len, PCI_DMA_TODEVICE);
- IPG_DEV_KFREE_SKB(sp->TxBuff[i]);
+ dev_kfree_skb_irq(sp->tx_buff[i]);
- sp->TxBuff[i] = NULL;
+ sp->tx_buff[i] = NULL;
}
}
}
#ifdef JUMBO_FRAME
/* initialize JUMBO Frame control variable */
- sp->Jumbo.FoundStart = 0;
- sp->Jumbo.CurrentSize = 0;
- sp->Jumbo.skb = 0;
+ sp->jumbo.found_start = 0;
+ sp->jumbo.current_size = 0;
+ sp->jumbo.skb = 0;
dev->mtu = IPG_TXFRAG_SIZE;
#endif
if (sp->tenmbpsmode)
netif_stop_queue(dev);
- if (sp->ResetCurrentTFD) {
- sp->ResetCurrentTFD = 0;
+ if (sp->reset_current_tfd) {
+ sp->reset_current_tfd = 0;
entry = 0;
}
txfd = sp->txd + entry;
- sp->TxBuff[entry] = skb;
+ sp->tx_buff[entry] = skb;
/* Clear all TFC fields, except TFDDONE. */
txfd->tfc = cpu_to_le64(IPG_TFC_TFDDONE);
*/
if (sp->tenmbpsmode)
txfd->tfc |= cpu_to_le64(IPG_TFC_TXINDICATE);
- else if (!((sp->tx_current - sp->tx_dirty + 1) >
- IPG_FRAMESBETWEENTXDMACOMPLETES)) {
- txfd->tfc |= cpu_to_le64(IPG_TFC_TXDMAINDICATE);
- }
+ txfd->tfc |= cpu_to_le64(IPG_TFC_TXDMAINDICATE);
/* Based on compilation option, determine if FCS is to be
* appended to transmit frame by IPG.
*/
ipg_w32(IPG_DC_TX_DMA_POLL_NOW, DMA_CTRL);
if (sp->tx_current == (sp->tx_dirty + IPG_TFDLIST_LENGTH))
- netif_wake_queue(dev);
+ netif_stop_queue(dev);
spin_unlock_irqrestore(&sp->lock, flags);
}
}
-/* JES20040127EEPROM */
static int read_eeprom(struct net_device *dev, int eep_addr)
{
void __iomem *ioaddr = ipg_ioaddr(dev);
unsigned int i;
int rc;
- /* Read/Write and Reset EEPROM Value Jesse20040128EEPROM_VALUE */
+ /* Read/Write and Reset EEPROM Value */
/* 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
* RST_OUT as not compatible with some PHYs.