465 E1000_DESC_UNUSED(ring)); |
469 E1000_DESC_UNUSED(ring)); |
466 } |
470 } |
467 |
471 |
468 adapter->tx_queue_len = netdev->tx_queue_len; |
472 adapter->tx_queue_len = netdev->tx_queue_len; |
469 |
473 |
470 mod_timer(&adapter->watchdog_timer, jiffies); |
474 if (!adapter->ecdev) { |
|
475 mod_timer(&adapter->watchdog_timer, jiffies); |
471 |
476 |
472 #ifdef CONFIG_E1000_NAPI |
477 #ifdef CONFIG_E1000_NAPI |
473 if (!adapter->ecdev) netif_poll_enable(netdev); |
478 netif_poll_enable(netdev); |
474 #endif |
479 #endif |
475 e1000_irq_enable(adapter); |
480 e1000_irq_enable(adapter); |
|
481 } |
476 |
482 |
477 return 0; |
483 return 0; |
478 } |
484 } |
479 |
485 |
480 /** |
486 /** |
527 void |
533 void |
528 e1000_down(struct e1000_adapter *adapter) |
534 e1000_down(struct e1000_adapter *adapter) |
529 { |
535 { |
530 struct net_device *netdev = adapter->netdev; |
536 struct net_device *netdev = adapter->netdev; |
531 |
537 |
532 e1000_irq_disable(adapter); |
538 if (!adapter->ecdev) { |
533 |
539 e1000_irq_disable(adapter); |
534 del_timer_sync(&adapter->tx_fifo_stall_timer); |
540 |
535 del_timer_sync(&adapter->watchdog_timer); |
541 del_timer_sync(&adapter->tx_fifo_stall_timer); |
536 del_timer_sync(&adapter->phy_info_timer); |
542 del_timer_sync(&adapter->watchdog_timer); |
|
543 del_timer_sync(&adapter->phy_info_timer); |
537 |
544 |
538 #ifdef CONFIG_E1000_NAPI |
545 #ifdef CONFIG_E1000_NAPI |
539 if (!adapter->ecdev) netif_poll_disable(netdev); |
546 netif_poll_disable(netdev); |
540 #endif |
547 #endif |
541 netdev->tx_queue_len = adapter->tx_queue_len; |
548 netdev->tx_queue_len = adapter->tx_queue_len; |
|
549 } |
542 adapter->link_speed = 0; |
550 adapter->link_speed = 0; |
543 adapter->link_duplex = 0; |
551 adapter->link_duplex = 0; |
544 if (!adapter->ecdev) { |
552 if (!adapter->ecdev) { |
545 netif_carrier_off(netdev); |
553 netif_carrier_off(netdev); |
546 netif_stop_queue(netdev); |
554 netif_stop_queue(netdev); |
2459 if (adapter->ecdev) { |
2470 if (adapter->ecdev) { |
2460 ecdev_set_link(adapter->ecdev, 1); |
2471 ecdev_set_link(adapter->ecdev, 1); |
2461 } else { |
2472 } else { |
2462 netif_carrier_on(netdev); |
2473 netif_carrier_on(netdev); |
2463 netif_wake_queue(netdev); |
2474 netif_wake_queue(netdev); |
|
2475 mod_timer(&adapter->phy_info_timer, jiffies + 2 * HZ); |
2464 } |
2476 } |
2465 mod_timer(&adapter->phy_info_timer, jiffies + 2 * HZ); |
|
2466 adapter->smartspeed = 0; |
2477 adapter->smartspeed = 0; |
2467 } |
2478 } |
2468 } else { |
2479 } else { |
2469 if ((adapter->ecdev && ecdev_get_link(adapter->ecdev)) |
2480 if ((adapter->ecdev && ecdev_get_link(adapter->ecdev)) |
2470 || (!adapter->ecdev && netif_carrier_ok(netdev))) { |
2481 || (!adapter->ecdev && netif_carrier_ok(netdev))) { |
2474 if (adapter->ecdev) { |
2485 if (adapter->ecdev) { |
2475 ecdev_set_link(adapter->ecdev, 0); |
2486 ecdev_set_link(adapter->ecdev, 0); |
2476 } else { |
2487 } else { |
2477 netif_carrier_off(netdev); |
2488 netif_carrier_off(netdev); |
2478 netif_stop_queue(netdev); |
2489 netif_stop_queue(netdev); |
|
2490 mod_timer(&adapter->phy_info_timer, jiffies + 2 * HZ); |
2479 } |
2491 } |
2480 mod_timer(&adapter->phy_info_timer, jiffies + 2 * HZ); |
|
2481 |
2492 |
2482 /* 80003ES2LAN workaround-- |
2493 /* 80003ES2LAN workaround-- |
2483 * For packet buffer work-around on link down event; |
2494 * For packet buffer work-around on link down event; |
2484 * disable receives in the ISR and |
2495 * disable receives in the ISR and |
2485 * reset device here in the watchdog |
2496 * reset device here in the watchdog |
2505 adapter->gotcl = adapter->stats.gotcl - adapter->gotcl_old; |
2516 adapter->gotcl = adapter->stats.gotcl - adapter->gotcl_old; |
2506 adapter->gotcl_old = adapter->stats.gotcl; |
2517 adapter->gotcl_old = adapter->stats.gotcl; |
2507 |
2518 |
2508 e1000_update_adaptive(&adapter->hw); |
2519 e1000_update_adaptive(&adapter->hw); |
2509 |
2520 |
2510 if ((adapter->ecdev && !ecdev_get_link(adapter->ecdev)) |
2521 if (!adapter->ecdev && !netif_carrier_ok(netdev)) { |
2511 || (!adapter->ecdev && !netif_carrier_ok(netdev))) { |
|
2512 if (E1000_DESC_UNUSED(txdr) + 1 < txdr->count) { |
2522 if (E1000_DESC_UNUSED(txdr) + 1 < txdr->count) { |
2513 /* We've lost link, so the controller stops DMA, |
2523 /* We've lost link, so the controller stops DMA, |
2514 * but we've got queued Tx work that's never going |
2524 * but we've got queued Tx work that's never going |
2515 * to get done, so reset controller to flush Tx. |
2525 * to get done, so reset controller to flush Tx. |
2516 * (Do the reset outside of interrupt context). */ |
2526 * (Do the reset outside of interrupt context). */ |
2534 |
2544 |
2535 /* Cause software interrupt to ensure rx ring is cleaned */ |
2545 /* Cause software interrupt to ensure rx ring is cleaned */ |
2536 E1000_WRITE_REG(&adapter->hw, ICS, E1000_ICS_RXDMT0); |
2546 E1000_WRITE_REG(&adapter->hw, ICS, E1000_ICS_RXDMT0); |
2537 |
2547 |
2538 /* Force detection of hung controller every watchdog period */ |
2548 /* Force detection of hung controller every watchdog period */ |
2539 adapter->detect_tx_hung = TRUE; |
2549 if (!adapter->ecdev) adapter->detect_tx_hung = TRUE; |
2540 |
2550 |
2541 /* With 82571 controllers, LAA may be overwritten due to controller |
2551 /* With 82571 controllers, LAA may be overwritten due to controller |
2542 * reset from the other port. Set the appropriate LAA in RAR[0] */ |
2552 * reset from the other port. Set the appropriate LAA in RAR[0] */ |
2543 if (adapter->hw.mac_type == e1000_82571 && adapter->hw.laa_is_present) |
2553 if (adapter->hw.mac_type == e1000_82571 && adapter->hw.laa_is_present) |
2544 e1000_rar_set(&adapter->hw, adapter->hw.mac_addr, 0); |
2554 e1000_rar_set(&adapter->hw, adapter->hw.mac_addr, 0); |
2545 |
2555 |
2546 /* Reset the timer */ |
2556 /* Reset the timer */ |
2547 mod_timer(&adapter->watchdog_timer, jiffies + 2 * HZ); |
2557 if (!adapter->ecdev) |
|
2558 mod_timer(&adapter->watchdog_timer, jiffies + 2 * HZ); |
2548 } |
2559 } |
2549 |
2560 |
2550 #define E1000_TX_FLAGS_CSUM 0x00000001 |
2561 #define E1000_TX_FLAGS_CSUM 0x00000001 |
2551 #define E1000_TX_FLAGS_VLAN 0x00000002 |
2562 #define E1000_TX_FLAGS_VLAN 0x00000002 |
2552 #define E1000_TX_FLAGS_TSO 0x00000004 |
2563 #define E1000_TX_FLAGS_TSO 0x00000004 |
3029 return NETDEV_TX_BUSY; |
3040 return NETDEV_TX_BUSY; |
3030 } |
3041 } |
3031 |
3042 |
3032 if (unlikely(adapter->hw.mac_type == e1000_82547)) { |
3043 if (unlikely(adapter->hw.mac_type == e1000_82547)) { |
3033 if (unlikely(e1000_82547_fifo_workaround(adapter, skb))) { |
3044 if (unlikely(e1000_82547_fifo_workaround(adapter, skb))) { |
3034 if (!adapter->ecdev) |
3045 if (!adapter->ecdev) { |
3035 netif_stop_queue(netdev); |
3046 netif_stop_queue(netdev); |
3036 mod_timer(&adapter->tx_fifo_stall_timer, jiffies); |
3047 mod_timer(&adapter->tx_fifo_stall_timer, jiffies); |
3037 if (!adapter->ecdev) |
|
3038 spin_unlock_irqrestore(&tx_ring->tx_lock, flags); |
3048 spin_unlock_irqrestore(&tx_ring->tx_lock, flags); |
|
3049 } |
3039 return NETDEV_TX_BUSY; |
3050 return NETDEV_TX_BUSY; |
3040 } |
3051 } |
3041 } |
3052 } |
3042 |
3053 |
3043 if (unlikely(adapter->vlgrp && vlan_tx_tag_present(skb))) { |
3054 if (unlikely(adapter->vlgrp && vlan_tx_tag_present(skb))) { |
3386 |
3397 |
3387 if (!adapter->ecdev) |
3398 if (!adapter->ecdev) |
3388 spin_unlock_irqrestore(&adapter->stats_lock, flags); |
3399 spin_unlock_irqrestore(&adapter->stats_lock, flags); |
3389 } |
3400 } |
3390 |
3401 |
3391 void ec_poll(struct net_device *dev) |
3402 void ec_poll(struct net_device *netdev) |
3392 { |
3403 { |
3393 e1000_intr(0, dev, NULL); |
3404 struct e1000_adapter *adapter = netdev_priv(netdev); |
|
3405 |
|
3406 if (jiffies - adapter->ec_watchdog_jiffies >= 2 * HZ) { |
|
3407 e1000_watchdog_task(adapter); |
|
3408 adapter->ec_watchdog_jiffies = jiffies; |
|
3409 } |
|
3410 |
|
3411 e1000_intr(0, netdev, NULL); |
3394 } |
3412 } |
3395 |
3413 |
3396 /** |
3414 /** |
3397 * e1000_intr - Interrupt Handler |
3415 * e1000_intr - Interrupt Handler |
3398 * @irq: interrupt number |
3416 * @irq: interrupt number |
3424 e1000_irq_enable(adapter); |
3442 e1000_irq_enable(adapter); |
3425 #endif |
3443 #endif |
3426 return IRQ_NONE; /* Not our interrupt */ |
3444 return IRQ_NONE; /* Not our interrupt */ |
3427 } |
3445 } |
3428 |
3446 |
3429 if (unlikely(icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC))) { |
3447 if (!adapter->ecdev && unlikely(icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC))) { |
3430 hw->get_link_status = 1; |
3448 hw->get_link_status = 1; |
3431 /* 80003ES2LAN workaround-- |
3449 /* 80003ES2LAN workaround-- |
3432 * For packet buffer work-around on link down event; |
3450 * For packet buffer work-around on link down event; |
3433 * disable receives here in the ISR and |
3451 * disable receives here in the ISR and |
3434 * reset adapter in watchdog |
3452 * reset adapter in watchdog |
3435 */ |
3453 */ |
3436 if (((adapter->ecdev && ecdev_get_link(adapter->ecdev)) |
3454 if (netif_carrier_ok(netdev) && |
3437 || (!adapter->ecdev && netif_carrier_ok(netdev))) && |
3455 (adapter->hw.mac_type == e1000_80003es2lan)) { |
3438 (adapter->hw.mac_type == e1000_80003es2lan)) { |
|
3439 /* disable receives */ |
3456 /* disable receives */ |
3440 rctl = E1000_READ_REG(hw, RCTL); |
3457 rctl = E1000_READ_REG(hw, RCTL); |
3441 E1000_WRITE_REG(hw, RCTL, rctl & ~E1000_RCTL_EN); |
3458 E1000_WRITE_REG(hw, RCTL, rctl & ~E1000_RCTL_EN); |
3442 } |
3459 } |
3443 mod_timer(&adapter->watchdog_timer, jiffies); |
3460 mod_timer(&adapter->watchdog_timer, jiffies); |
3444 } |
3461 } |
3445 |
3462 |
3446 #ifdef CONFIG_E1000_NAPI |
3463 #ifdef CONFIG_E1000_NAPI |
3447 if (unlikely(hw->mac_type < e1000_82571)) { |
3464 if (!adapter->ecdev) { |
3448 atomic_inc(&adapter->irq_sem); |
3465 if (unlikely(hw->mac_type < e1000_82571)) { |
3449 E1000_WRITE_REG(hw, IMC, ~0); |
3466 atomic_inc(&adapter->irq_sem); |
3450 E1000_WRITE_FLUSH(hw); |
3467 E1000_WRITE_REG(hw, IMC, ~0); |
3451 } |
3468 E1000_WRITE_FLUSH(hw); |
3452 if (!adapter->ecdev) { |
3469 } |
|
3470 |
3453 if (likely(netif_rx_schedule_prep(netdev))) |
3471 if (likely(netif_rx_schedule_prep(netdev))) |
3454 __netif_rx_schedule(netdev); |
3472 __netif_rx_schedule(netdev); |
3455 else |
3473 else |
3456 e1000_irq_enable(adapter); |
3474 e1000_irq_enable(adapter); |
3457 } |
3475 } |
3458 #else |
3476 #else |
3459 /* Writing IMC and IMS is needed for 82547. |
3477 /* Writing IMC and IMS is needed for 82547. |
3460 * Due to Hub Link bus being occupied, an interrupt |
3478 * Due to Hub Link bus being occupied, an interrupt |
3461 * de-assertion message is not able to be sent. |
3479 * de-assertion message is not able to be sent. |
3462 * When an interrupt assertion message is generated later, |
3480 * When an interrupt assertion message is generated later, |
3464 * That causes APIC to think 82547 is in de-assertion |
3482 * That causes APIC to think 82547 is in de-assertion |
3465 * state, while 82547 is in assertion state, resulting |
3483 * state, while 82547 is in assertion state, resulting |
3466 * in dead lock. Writing IMC forces 82547 into |
3484 * in dead lock. Writing IMC forces 82547 into |
3467 * de-assertion state. |
3485 * de-assertion state. |
3468 */ |
3486 */ |
3469 if (hw->mac_type == e1000_82547 || hw->mac_type == e1000_82547_rev_2) { |
3487 if (!adapter->ecdev && |
|
3488 (hw->mac_type == e1000_82547 || hw->mac_type == e1000_82547_rev_2)) { |
3470 atomic_inc(&adapter->irq_sem); |
3489 atomic_inc(&adapter->irq_sem); |
3471 E1000_WRITE_REG(hw, IMC, ~0); |
3490 E1000_WRITE_REG(hw, IMC, ~0); |
3472 } |
3491 } |
3473 |
3492 |
3474 for (i = 0; i < E1000_MAX_INTR; i++) |
3493 for (i = 0; i < E1000_MAX_INTR; i++) |
3475 if (unlikely(!adapter->clean_rx(adapter, adapter->rx_ring) & |
3494 if (unlikely(!adapter->clean_rx(adapter, adapter->rx_ring) & |
3476 !e1000_clean_tx_irq(adapter, adapter->tx_ring))) |
3495 !e1000_clean_tx_irq(adapter, adapter->tx_ring))) |
3477 break; |
3496 break; |
3478 |
3497 |
3479 if (hw->mac_type == e1000_82547 || hw->mac_type == e1000_82547_rev_2) |
3498 if (adapter->ecdev && |
|
3499 (hw->mac_type == e1000_82547 || hw->mac_type == e1000_82547_rev_2)) |
3480 e1000_irq_enable(adapter); |
3500 e1000_irq_enable(adapter); |
3481 |
3501 |
3482 #endif |
3502 #endif |
3483 |
3503 |
3484 return IRQ_HANDLED; |
3504 return IRQ_HANDLED; |
3579 |
3599 |
3580 tx_ring->next_to_clean = i; |
3600 tx_ring->next_to_clean = i; |
3581 |
3601 |
3582 #define TX_WAKE_THRESHOLD 32 |
3602 #define TX_WAKE_THRESHOLD 32 |
3583 if (unlikely(!adapter->ecdev && cleaned && netif_queue_stopped(netdev) && |
3603 if (unlikely(!adapter->ecdev && cleaned && netif_queue_stopped(netdev) && |
3584 netif_carrier_ok(netdev))) { |
3604 netif_carrier_ok(netdev))) { |
3585 spin_lock(&tx_ring->tx_lock); |
3605 spin_lock(&tx_ring->tx_lock); |
3586 if (netif_queue_stopped(netdev) && |
3606 if (netif_queue_stopped(netdev) && |
3587 (E1000_DESC_UNUSED(tx_ring) >= TX_WAKE_THRESHOLD)) |
3607 (E1000_DESC_UNUSED(tx_ring) >= TX_WAKE_THRESHOLD)) |
3588 netif_wake_queue(netdev); |
3608 netif_wake_queue(netdev); |
3589 spin_unlock(&tx_ring->tx_lock); |
3609 spin_unlock(&tx_ring->tx_lock); |
3590 } |
3610 } |
3591 |
3611 |
3592 if (adapter->detect_tx_hung) { |
3612 if(!adapter->ecdev && adapter->detect_tx_hung) { |
3593 /* Detect a transmit hang in hardware, this serializes the |
3613 /* Detect a transmit hang in hardware, this serializes the |
3594 * check with the clearing of time_stamp and movement of i */ |
3614 * check with the clearing of time_stamp and movement of i */ |
3595 adapter->detect_tx_hung = FALSE; |
3615 adapter->detect_tx_hung = FALSE; |
3596 if (tx_ring->buffer_info[eop].dma && |
3616 if (tx_ring->buffer_info[eop].dma && |
3597 time_after(jiffies, tx_ring->buffer_info[eop].time_stamp + |
3617 time_after(jiffies, tx_ring->buffer_info[eop].time_stamp + |
3609 "buffer_info[next_to_clean]\n" |
3629 "buffer_info[next_to_clean]\n" |
3610 " time_stamp <%lx>\n" |
3630 " time_stamp <%lx>\n" |
3611 " next_to_watch <%x>\n" |
3631 " next_to_watch <%x>\n" |
3612 " jiffies <%lx>\n" |
3632 " jiffies <%lx>\n" |
3613 " next_to_watch.status <%x>\n", |
3633 " next_to_watch.status <%x>\n", |
3614 (unsigned long)((tx_ring - adapter->tx_ring) / |
3634 (unsigned long)((tx_ring - adapter->tx_ring) / |
3615 sizeof(struct e1000_tx_ring)), |
3635 sizeof(struct e1000_tx_ring)), |
3616 readl(adapter->hw.hw_addr + tx_ring->tdh), |
3636 readl(adapter->hw.hw_addr + tx_ring->tdh), |
3617 readl(adapter->hw.hw_addr + tx_ring->tdt), |
3637 readl(adapter->hw.hw_addr + tx_ring->tdt), |
3618 tx_ring->next_to_use, |
3638 tx_ring->next_to_use, |
3619 tx_ring->next_to_clean, |
3639 tx_ring->next_to_clean, |
3620 tx_ring->buffer_info[eop].time_stamp, |
3640 tx_ring->buffer_info[eop].time_stamp, |
3621 eop, |
3641 eop, |
3622 jiffies, |
3642 jiffies, |
3623 eop_desc->upper.fields.status); |
3643 eop_desc->upper.fields.status); |
3624 if (!adapter->ecdev) netif_stop_queue(netdev); |
3644 netif_stop_queue(netdev); |
3625 } |
3645 } |
3626 } |
3646 } |
3627 return cleaned; |
3647 return cleaned; |
3628 } |
3648 } |
3629 |
3649 |
3750 } |
3770 } |
3751 |
3771 |
3752 if (!adapter->ecdev && unlikely(rx_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK)) { |
3772 if (!adapter->ecdev && unlikely(rx_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK)) { |
3753 last_byte = *(skb->data + length - 1); |
3773 last_byte = *(skb->data + length - 1); |
3754 if (TBI_ACCEPT(&adapter->hw, status, |
3774 if (TBI_ACCEPT(&adapter->hw, status, |
3755 rx_desc->errors, length, last_byte)) { |
3775 rx_desc->errors, length, last_byte)) { |
3756 spin_lock_irqsave(&adapter->stats_lock, flags); |
3776 spin_lock_irqsave(&adapter->stats_lock, flags); |
3757 e1000_tbi_adjust_stats(&adapter->hw, |
3777 e1000_tbi_adjust_stats(&adapter->hw, |
3758 &adapter->stats, |
3778 &adapter->stats, |
3759 length, skb->data); |
3779 length, skb->data); |
3760 spin_unlock_irqrestore(&adapter->stats_lock, |
3780 spin_unlock_irqrestore(&adapter->stats_lock, |
3761 flags); |
3781 flags); |
3762 length--; |
3782 length--; |
3763 } else { |
3783 } else { |
3764 /* recycle */ |
3784 /* recycle */ |
3765 buffer_info->skb = skb; |
3785 buffer_info->skb = skb; |
3766 goto next_desc; |
3786 goto next_desc; |
3771 * performance for small packets with large amounts |
3791 * performance for small packets with large amounts |
3772 * of reassembly being done in the stack */ |
3792 * of reassembly being done in the stack */ |
3773 #define E1000_CB_LENGTH 256 |
3793 #define E1000_CB_LENGTH 256 |
3774 if (!adapter->ecdev && length < E1000_CB_LENGTH) { |
3794 if (!adapter->ecdev && length < E1000_CB_LENGTH) { |
3775 struct sk_buff *new_skb = |
3795 struct sk_buff *new_skb = |
3776 netdev_alloc_skb(netdev, length + NET_IP_ALIGN); |
3796 netdev_alloc_skb(netdev, length + NET_IP_ALIGN); |
3777 if (new_skb) { |
3797 if (new_skb) { |
3778 skb_reserve(new_skb, NET_IP_ALIGN); |
3798 skb_reserve(new_skb, NET_IP_ALIGN); |
3779 new_skb->dev = netdev; |
3799 new_skb->dev = netdev; |
3780 memcpy(new_skb->data - NET_IP_ALIGN, |
3800 memcpy(new_skb->data - NET_IP_ALIGN, |
3781 skb->data - NET_IP_ALIGN, |
3801 skb->data - NET_IP_ALIGN, |
3782 length + NET_IP_ALIGN); |
3802 length + NET_IP_ALIGN); |
3783 /* save the skb in buffer_info as good */ |
3803 /* save the skb in buffer_info as good */ |
3784 buffer_info->skb = skb; |
3804 buffer_info->skb = skb; |
3785 skb = new_skb; |
3805 skb = new_skb; |
3786 skb_put(skb, length); |
3806 skb_put(skb, length); |
3787 } |
3807 } |
3796 ((uint32_t)(rx_desc->errors) << 24), |
3816 ((uint32_t)(rx_desc->errors) << 24), |
3797 le16_to_cpu(rx_desc->csum), skb); |
3817 le16_to_cpu(rx_desc->csum), skb); |
3798 |
3818 |
3799 if (adapter->ecdev) { |
3819 if (adapter->ecdev) { |
3800 ecdev_receive(adapter->ecdev, skb->data, length); |
3820 ecdev_receive(adapter->ecdev, skb->data, length); |
|
3821 skb_trim(skb, 0); |
|
3822 |
|
3823 if(unlikely((i & ~(E1000_RX_BUFFER_WRITE - 1)) == i)) { |
|
3824 /* Force memory writes to complete before letting h/w |
|
3825 * know there are new descriptors to fetch. (Only |
|
3826 * applicable for weak-ordered memory model archs, |
|
3827 * such as IA-64). */ |
|
3828 wmb(); |
|
3829 E1000_WRITE_REG(&adapter->hw, RDT, i); |
|
3830 } |
3801 } else { |
3831 } else { |
3802 skb->protocol = eth_type_trans(skb, netdev); |
3832 skb->protocol = eth_type_trans(skb, netdev); |
3803 #ifdef CONFIG_E1000_NAPI |
3833 #ifdef CONFIG_E1000_NAPI |
3804 if (unlikely(adapter->vlgrp && |
3834 if (unlikely(adapter->vlgrp && |
3805 (status & E1000_RXD_STAT_VP))) { |
3835 (status & E1000_RXD_STAT_VP))) { |
3980 if (likely(rx_desc->wb.upper.header_status & |
4010 if (likely(rx_desc->wb.upper.header_status & |
3981 cpu_to_le16(E1000_RXDPS_HDRSTAT_HDRSP))) |
4011 cpu_to_le16(E1000_RXDPS_HDRSTAT_HDRSP))) |
3982 adapter->rx_hdr_split++; |
4012 adapter->rx_hdr_split++; |
3983 if (adapter->ecdev) { |
4013 if (adapter->ecdev) { |
3984 ecdev_receive(adapter->ecdev, skb->data, length); |
4014 ecdev_receive(adapter->ecdev, skb->data, length); |
|
4015 skb_trim(skb, 0); |
|
4016 |
|
4017 if(unlikely((i & ~(E1000_RX_BUFFER_WRITE - 1)) == i)) { |
|
4018 /* Force memory writes to complete before letting h/w |
|
4019 * know there are new descriptors to fetch. (Only |
|
4020 * applicable for weak-ordered memory model archs, |
|
4021 * such as IA-64). */ |
|
4022 wmb(); |
|
4023 /* Hardware increments by 16 bytes, but packet split |
|
4024 * descriptors are 32 bytes...so we increment tail |
|
4025 * twice as much. |
|
4026 */ |
|
4027 E1000_WRITE_REG(&adapter->hw, RDT, i<<1); |
|
4028 } |
3985 } else { |
4029 } else { |
3986 skb->protocol = eth_type_trans(skb, netdev); |
4030 skb->protocol = eth_type_trans(skb, netdev); |
3987 #ifdef CONFIG_E1000_NAPI |
4031 #ifdef CONFIG_E1000_NAPI |
3988 if (unlikely(adapter->vlgrp && (staterr & E1000_RXD_STAT_VP))) { |
4032 if (unlikely(adapter->vlgrp && (staterr & E1000_RXD_STAT_VP))) { |
3989 vlan_hwaccel_receive_skb(skb, adapter->vlgrp, |
4033 vlan_hwaccel_receive_skb(skb, adapter->vlgrp, |
4342 switch (cmd) { |
4386 switch (cmd) { |
4343 case SIOCGMIIPHY: |
4387 case SIOCGMIIPHY: |
4344 data->phy_id = adapter->hw.phy_addr; |
4388 data->phy_id = adapter->hw.phy_addr; |
4345 break; |
4389 break; |
4346 case SIOCGMIIREG: |
4390 case SIOCGMIIREG: |
4347 if (!capable(CAP_NET_ADMIN)) |
4391 if(adapter->ecdev || !capable(CAP_NET_ADMIN)) |
4348 return -EPERM; |
4392 return -EPERM; |
4349 spin_lock_irqsave(&adapter->stats_lock, flags); |
4393 spin_lock_irqsave(&adapter->stats_lock, flags); |
4350 if (e1000_read_phy_reg(&adapter->hw, data->reg_num & 0x1F, |
4394 if (e1000_read_phy_reg(&adapter->hw, data->reg_num & 0x1F, |
4351 &data->val_out)) { |
4395 &data->val_out)) { |
4352 spin_unlock_irqrestore(&adapter->stats_lock, flags); |
4396 spin_unlock_irqrestore(&adapter->stats_lock, flags); |
4353 return -EIO; |
4397 return -EIO; |
4354 } |
4398 } |
4355 spin_unlock_irqrestore(&adapter->stats_lock, flags); |
4399 spin_unlock_irqrestore(&adapter->stats_lock, flags); |
4356 break; |
4400 break; |
4357 case SIOCSMIIREG: |
4401 case SIOCSMIIREG: |
4358 if (!capable(CAP_NET_ADMIN)) |
4402 if(adapter->ecdev || !capable(CAP_NET_ADMIN)) |
4359 return -EPERM; |
4403 return -EPERM; |
4360 if (data->reg_num & ~(0x1F)) |
4404 if (data->reg_num & ~(0x1F)) |
4361 return -EFAULT; |
4405 return -EFAULT; |
4362 mii_reg = data->val_in; |
4406 mii_reg = data->val_in; |
4363 spin_lock_irqsave(&adapter->stats_lock, flags); |
4407 spin_lock_irqsave(&adapter->stats_lock, flags); |