tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Merge branch 'upstream-linus' of master.kernel.org:/pub/scm/linux/kernel/git/jgarzik/netdev-2.6

* 'upstream-linus' of master.kernel.org:/pub/scm/linux/kernel/git/jgarzik/netdev-2.6:
r8169: fix suspend/resume for down interface
r8169: issue request_irq after the private data are completely initialized
b44: fix IFF_ALLMULTI handling of CAM slots
cxgb3 - Firwmare update
cxgb3 - Tighten xgmac workaround
cxgb3 - detect NIC only adapters
cxgb3 - Safeguard TCAM size usage

Linus Torvalds b6d3d16e 348e3fd1

+89 -46
+1 -1
drivers/net/b44.c
··· 1709 1709 bw32(bp, B44_RXCONFIG, val); 1710 1710 } else { 1711 1711 unsigned char zero[6] = {0, 0, 0, 0, 0, 0}; 1712 - int i = 0; 1712 + int i = 1; 1713 1713 1714 1714 __b44_set_mac_addr(bp); 1715 1715
+6 -3
drivers/net/cxgb3/common.h
··· 112 112 }; 113 113 114 114 enum { 115 - SUPPORTED_OFFLOAD = 1 << 24, 116 - SUPPORTED_IRQ = 1 << 25 115 + SUPPORTED_IRQ = 1 << 24 117 116 }; 118 117 119 118 enum { /* adapter interrupt-maintained statistics */ ··· 357 358 MC5_MODE_72_BIT = 2 358 359 }; 359 360 361 + /* MC5 min active region size */ 362 + enum { MC5_MIN_TIDS = 16 }; 363 + 360 364 struct vpd_params { 361 365 unsigned int cclk; 362 366 unsigned int mclk; ··· 404 402 unsigned int stats_update_period; /* MAC stats accumulation period */ 405 403 unsigned int linkpoll_period; /* link poll period in 0.1s */ 406 404 unsigned int rev; /* chip revision */ 405 + unsigned int offload; 407 406 }; 408 407 409 408 enum { /* chip revisions */ ··· 605 602 606 603 static inline int is_offload(const struct adapter *adap) 607 604 { 608 - return adapter_info(adap)->caps & SUPPORTED_OFFLOAD; 605 + return adap->params.offload; 609 606 } 610 607 611 608 static inline unsigned int core_ticks_per_usec(const struct adapter *adap)
+24 -11
drivers/net/cxgb3/cxgb3_main.c
··· 185 185 int speed, int duplex, int pause) 186 186 { 187 187 struct net_device *dev = adapter->port[port_id]; 188 + struct port_info *pi = netdev_priv(dev); 189 + struct cmac *mac = &pi->mac; 188 190 189 191 /* Skip changes from disabled ports. */ 190 192 if (!netif_running(dev)) 191 193 return; 192 194 193 195 if (link_stat != netif_carrier_ok(dev)) { 194 - if (link_stat) 196 + if (link_stat) { 197 + t3_set_reg_field(adapter, 198 + A_XGM_TXFIFO_CFG + mac->offset, 199 + F_ENDROPPKT, 0); 195 200 netif_carrier_on(dev); 196 - else 201 + } else { 197 202 netif_carrier_off(dev); 203 + t3_set_reg_field(adapter, 204 + A_XGM_TXFIFO_CFG + mac->offset, 205 + F_ENDROPPKT, F_ENDROPPKT); 206 + } 207 + 198 208 link_report(dev); 199 209 } 200 210 } ··· 417 407 static int setup_sge_qsets(struct adapter *adap) 418 408 { 419 409 int i, j, err, irq_idx = 0, qset_idx = 0, dummy_dev_idx = 0; 420 - unsigned int ntxq = is_offload(adap) ? SGE_TXQ_PER_SET : 1; 410 + unsigned int ntxq = SGE_TXQ_PER_SET; 421 411 422 412 if (adap->params.rev > 0 && !(adap->flags & USING_MSI)) 423 413 irq_idx = -1; ··· 495 485 static ssize_t set_nfilters(struct net_device *dev, unsigned int val) 496 486 { 497 487 struct adapter *adap = dev->priv; 488 + int min_tids = is_offload(adap) ? MC5_MIN_TIDS : 0; 498 489 499 490 if (adap->flags & FULL_INIT_DONE) 500 491 return -EBUSY; 501 492 if (val && adap->params.rev == 0) 502 493 return -EINVAL; 503 - if (val > t3_mc5_size(&adap->mc5) - adap->params.mc5.nservers) 494 + if (val > t3_mc5_size(&adap->mc5) - adap->params.mc5.nservers - 495 + min_tids) 504 496 return -EINVAL; 505 497 adap->params.mc5.nfilters = val; 506 498 return 0; ··· 520 508 521 509 if (adap->flags & FULL_INIT_DONE) 522 510 return -EBUSY; 523 - if (val > t3_mc5_size(&adap->mc5) - adap->params.mc5.nfilters) 511 + if (val > t3_mc5_size(&adap->mc5) - adap->params.mc5.nfilters - 512 + MC5_MIN_TIDS) 524 513 return -EINVAL; 525 514 adap->params.mc5.nservers = val; 526 515 return 0; ··· 721 708 } 722 709 } 723 710 724 - #define FW_FNAME "t3fw-%d.%d.bin" 711 + #define FW_FNAME "t3fw-%d.%d.%d.bin" 725 712 726 713 static int upgrade_fw(struct adapter *adap) 727 714 { ··· 731 718 struct device *dev = &adap->pdev->dev; 732 719 733 720 snprintf(buf, sizeof(buf), FW_FNAME, FW_VERSION_MAJOR, 734 - FW_VERSION_MINOR); 721 + FW_VERSION_MINOR, FW_VERSION_MICRO); 735 722 ret = request_firmware(&fw, buf, dev); 736 723 if (ret < 0) { 737 724 dev_err(dev, "could not upgrade firmware: unable to load %s\n", ··· 932 919 return err; 933 920 934 921 set_bit(pi->port_id, &adapter->open_device_map); 935 - if (!ofld_disable) { 922 + if (is_offload(adapter) && !ofld_disable) { 936 923 err = offload_open(dev); 937 924 if (err) 938 925 printk(KERN_WARNING ··· 2129 2116 continue; 2130 2117 2131 2118 status = 0; 2132 - if (netif_running(dev)) 2119 + if (netif_running(dev) && netif_carrier_ok(dev)) 2133 2120 status = t3b2_mac_watchdog_task(&p->mac); 2134 2121 if (status == 1) 2135 2122 p->mac.stats.num_toggled++; ··· 2280 2267 2281 2268 if (!test_bit(i, &adap->registered_device_map)) 2282 2269 continue; 2283 - printk(KERN_INFO "%s: %s %s RNIC (rev %d) %s%s\n", 2270 + printk(KERN_INFO "%s: %s %s %sNIC (rev %d) %s%s\n", 2284 2271 dev->name, ai->desc, pi->port_type->desc, 2285 - adap->params.rev, buf, 2272 + is_offload(adap) ? "R" : "", adap->params.rev, buf, 2286 2273 (adap->flags & USING_MSIX) ? " MSI-X" : 2287 2274 (adap->flags & USING_MSI) ? " MSI" : ""); 2288 2275 if (adap->name == dev->name && adap->params.vpd.mclk)
+3 -1
drivers/net/cxgb3/cxgb3_offload.c
··· 553 553 struct tid_info *t = &(T3C_DATA(tdev))->tid_maps; 554 554 555 555 spin_lock_bh(&t->atid_lock); 556 - if (t->afree) { 556 + if (t->afree && 557 + t->atids_in_use + atomic_read(&t->tids_in_use) + MC5_MIN_TIDS <= 558 + t->ntids) { 557 559 union active_open_entry *p = t->afree; 558 560 559 561 atid = (p - t->atid_tab) + t->atid_base;
+3
drivers/net/cxgb3/mc5.c
··· 328 328 unsigned int tcam_size = mc5->tcam_size; 329 329 struct adapter *adap = mc5->adapter; 330 330 331 + if (!tcam_size) 332 + return 0; 333 + 331 334 if (nroutes > MAX_ROUTES || nroutes + nservers + nfilters > tcam_size) 332 335 return -EINVAL; 333 336
+4
drivers/net/cxgb3/regs.h
··· 1940 1940 1941 1941 #define V_TXFIFOTHRESH(x) ((x) << S_TXFIFOTHRESH) 1942 1942 1943 + #define S_ENDROPPKT 21 1944 + #define V_ENDROPPKT(x) ((x) << S_ENDROPPKT) 1945 + #define F_ENDROPPKT V_ENDROPPKT(1U) 1946 + 1943 1947 #define A_XGM_SERDES_CTRL 0x890 1944 1948 #define A_XGM_SERDES_CTRL0 0x8e0 1945 1949
+1 -1
drivers/net/cxgb3/sge.c
··· 2631 2631 q->txq[TXQ_ETH].stop_thres = nports * 2632 2632 flits_to_desc(sgl_len(MAX_SKB_FRAGS + 1) + 3); 2633 2633 2634 - if (ntxq == 1) { 2634 + if (!is_offload(adapter)) { 2635 2635 #ifdef USE_RX_PAGE 2636 2636 q->fl[0].buf_size = RX_PAGE_SIZE; 2637 2637 #else
+18 -6
drivers/net/cxgb3/t3_hw.c
··· 438 438 {2, 0, 0, 0, 439 439 F_GPIO2_OEN | F_GPIO4_OEN | 440 440 F_GPIO2_OUT_VAL | F_GPIO4_OUT_VAL, F_GPIO3 | F_GPIO5, 441 - SUPPORTED_OFFLOAD, 441 + 0, 442 442 &mi1_mdio_ops, "Chelsio PE9000"}, 443 443 {2, 0, 0, 0, 444 444 F_GPIO2_OEN | F_GPIO4_OEN | 445 445 F_GPIO2_OUT_VAL | F_GPIO4_OUT_VAL, F_GPIO3 | F_GPIO5, 446 - SUPPORTED_OFFLOAD, 446 + 0, 447 447 &mi1_mdio_ops, "Chelsio T302"}, 448 448 {1, 0, 0, 0, 449 449 F_GPIO1_OEN | F_GPIO6_OEN | F_GPIO7_OEN | F_GPIO10_OEN | 450 450 F_GPIO1_OUT_VAL | F_GPIO6_OUT_VAL | F_GPIO10_OUT_VAL, 0, 451 - SUPPORTED_10000baseT_Full | SUPPORTED_AUI | SUPPORTED_OFFLOAD, 451 + SUPPORTED_10000baseT_Full | SUPPORTED_AUI, 452 452 &mi1_mdio_ext_ops, "Chelsio T310"}, 453 453 {2, 0, 0, 0, 454 454 F_GPIO1_OEN | F_GPIO2_OEN | F_GPIO4_OEN | F_GPIO5_OEN | F_GPIO6_OEN | 455 455 F_GPIO7_OEN | F_GPIO10_OEN | F_GPIO11_OEN | F_GPIO1_OUT_VAL | 456 456 F_GPIO5_OUT_VAL | F_GPIO6_OUT_VAL | F_GPIO10_OUT_VAL, 0, 457 - SUPPORTED_10000baseT_Full | SUPPORTED_AUI | SUPPORTED_OFFLOAD, 457 + SUPPORTED_10000baseT_Full | SUPPORTED_AUI, 458 458 &mi1_mdio_ext_ops, "Chelsio T320"}, 459 459 }; 460 460 ··· 2900 2900 struct adapter *adapter = mc7->adapter; 2901 2901 const struct mc7_timing_params *p = &mc7_timings[mem_type]; 2902 2902 2903 + if (!mc7->size) 2904 + return 0; 2905 + 2903 2906 val = t3_read_reg(adapter, mc7->offset + A_MC7_CFG); 2904 2907 slow = val & F_SLOW; 2905 2908 width = G_WIDTH(val); ··· 3103 3100 do { /* wait for uP to initialize */ 3104 3101 msleep(20); 3105 3102 } while (t3_read_reg(adapter, A_CIM_HOST_ACC_DATA) && --attempts); 3106 - if (!attempts) 3103 + if (!attempts) { 3104 + CH_ERR(adapter, "uP initialization timed out\n"); 3107 3105 goto out_err; 3106 + } 3108 3107 3109 3108 err = 0; 3110 3109 out_err: ··· 3206 3201 mc7->name = name; 3207 3202 mc7->offset = base_addr - MC7_PMRX_BASE_ADDR; 3208 3203 cfg = t3_read_reg(adapter, mc7->offset + A_MC7_CFG); 3209 - mc7->size = mc7_calc_size(cfg); 3204 + mc7->size = mc7->size = G_DEN(cfg) == M_DEN ? 0 : mc7_calc_size(cfg); 3210 3205 mc7->width = G_WIDTH(cfg); 3211 3206 } 3212 3207 ··· 3233 3228 V_I2C_CLKDIV(adapter->params.vpd.cclk / 80 - 1)); 3234 3229 t3_write_reg(adapter, A_T3DBG_GPIO_EN, 3235 3230 ai->gpio_out | F_GPIO0_OEN | F_GPIO0_OUT_VAL); 3231 + t3_write_reg(adapter, A_MC5_DB_SERVER_INDEX, 0); 3236 3232 3237 3233 if (adapter->params.rev == 0 || !uses_xaui(adapter)) 3238 3234 val |= F_ENRGMII; ··· 3332 3326 p->tx_num_pgs = pm_num_pages(p->chan_tx_size, p->tx_pg_size); 3333 3327 p->ntimer_qs = p->cm_size >= (128 << 20) || 3334 3328 adapter->params.rev > 0 ? 12 : 6; 3329 + } 3335 3330 3331 + adapter->params.offload = t3_mc7_size(&adapter->pmrx) && 3332 + t3_mc7_size(&adapter->pmtx) && 3333 + t3_mc7_size(&adapter->cm); 3334 + 3335 + if (is_offload(adapter)) { 3336 3336 adapter->params.mc5.nservers = DEFAULT_NSERVERS; 3337 3337 adapter->params.mc5.nfilters = adapter->params.rev > 0 ? 3338 3338 DEFAULT_NFILTERS : 0;
+4 -1
drivers/net/cxgb3/version.h
··· 36 36 #define DRV_NAME "cxgb3" 37 37 /* Driver version */ 38 38 #define DRV_VERSION "1.0-ko" 39 + 40 + /* Firmware version */ 39 41 #define FW_VERSION_MAJOR 3 40 - #define FW_VERSION_MINOR 2 42 + #define FW_VERSION_MINOR 3 43 + #define FW_VERSION_MICRO 0 41 44 #endif /* __CHELSIO_VERSION_H */
-1
drivers/net/cxgb3/xgmac.c
··· 471 471 RMON_UPDATE(mac, rx_symbol_errs, RX_SYM_CODE_ERR_FRAMES); 472 472 473 473 RMON_UPDATE(mac, rx_too_long, RX_OVERSIZE_FRAMES); 474 - mac->stats.rx_too_long += RMON_READ(mac, A_XGM_RX_MAX_PKT_SIZE_ERR_CNT); 475 474 476 475 v = RMON_READ(mac, A_XGM_RX_MAX_PKT_SIZE_ERR_CNT); 477 476 if (mac->adapter->params.rev == T3_REV_B2)
+25 -21
drivers/net/r8169.c
··· 66 66 #include <linux/init.h> 67 67 #include <linux/dma-mapping.h> 68 68 69 + #include <asm/system.h> 69 70 #include <asm/io.h> 70 71 #include <asm/irq.h> 71 72 ··· 487 486 void __iomem *); 488 487 static int rtl8169_change_mtu(struct net_device *dev, int new_mtu); 489 488 static void rtl8169_down(struct net_device *dev); 489 + static void rtl8169_rx_clear(struct rtl8169_private *tp); 490 490 491 491 #ifdef CONFIG_R8169_NAPI 492 492 static int rtl8169_poll(struct net_device *dev, int *budget); ··· 1753 1751 { 1754 1752 struct rtl8169_private *tp = netdev_priv(dev); 1755 1753 struct pci_dev *pdev = tp->pci_dev; 1756 - int retval; 1754 + int retval = -ENOMEM; 1755 + 1757 1756 1758 1757 rtl8169_set_rxbufsize(tp, dev); 1759 - 1760 - retval = 1761 - request_irq(dev->irq, rtl8169_interrupt, IRQF_SHARED, dev->name, dev); 1762 - if (retval < 0) 1763 - goto out; 1764 - 1765 - retval = -ENOMEM; 1766 1758 1767 1759 /* 1768 1760 * Rx and Tx desscriptors needs 256 bytes alignment. ··· 1765 1769 tp->TxDescArray = pci_alloc_consistent(pdev, R8169_TX_RING_BYTES, 1766 1770 &tp->TxPhyAddr); 1767 1771 if (!tp->TxDescArray) 1768 - goto err_free_irq; 1772 + goto out; 1769 1773 1770 1774 tp->RxDescArray = pci_alloc_consistent(pdev, R8169_RX_RING_BYTES, 1771 1775 &tp->RxPhyAddr); 1772 1776 if (!tp->RxDescArray) 1773 - goto err_free_tx; 1777 + goto err_free_tx_0; 1774 1778 1775 1779 retval = rtl8169_init_ring(dev); 1776 1780 if (retval < 0) 1777 - goto err_free_rx; 1781 + goto err_free_rx_1; 1778 1782 1779 1783 INIT_DELAYED_WORK(&tp->task, NULL); 1784 + 1785 + smp_mb(); 1786 + 1787 + retval = request_irq(dev->irq, rtl8169_interrupt, IRQF_SHARED, 1788 + dev->name, dev); 1789 + if (retval < 0) 1790 + goto err_release_ring_2; 1780 1791 1781 1792 rtl8169_hw_start(dev); 1782 1793 ··· 1793 1790 out: 1794 1791 return retval; 1795 1792 1796 - err_free_rx: 1793 + err_release_ring_2: 1794 + rtl8169_rx_clear(tp); 1795 + err_free_rx_1: 1797 1796 pci_free_consistent(pdev, R8169_RX_RING_BYTES, tp->RxDescArray, 1798 1797 tp->RxPhyAddr); 1799 - err_free_tx: 1798 + err_free_tx_0: 1800 1799 pci_free_consistent(pdev, R8169_TX_RING_BYTES, tp->TxDescArray, 1801 1800 tp->TxPhyAddr); 1802 - err_free_irq: 1803 - free_irq(dev->irq, dev); 1804 1801 goto out; 1805 1802 } 1806 1803 ··· 2890 2887 void __iomem *ioaddr = tp->mmio_addr; 2891 2888 2892 2889 if (!netif_running(dev)) 2893 - goto out; 2890 + goto out_pci_suspend; 2894 2891 2895 2892 netif_device_detach(dev); 2896 2893 netif_stop_queue(dev); ··· 2904 2901 2905 2902 spin_unlock_irq(&tp->lock); 2906 2903 2904 + out_pci_suspend: 2907 2905 pci_save_state(pdev); 2908 2906 pci_enable_wake(pdev, pci_choose_state(pdev, state), tp->wol_enabled); 2909 2907 pci_set_power_state(pdev, pci_choose_state(pdev, state)); 2910 - out: 2908 + 2911 2909 return 0; 2912 2910 } 2913 2911 ··· 2916 2912 { 2917 2913 struct net_device *dev = pci_get_drvdata(pdev); 2918 2914 2915 + pci_set_power_state(pdev, PCI_D0); 2916 + pci_restore_state(pdev); 2917 + pci_enable_wake(pdev, PCI_D0, 0); 2918 + 2919 2919 if (!netif_running(dev)) 2920 2920 goto out; 2921 2921 2922 2922 netif_device_attach(dev); 2923 - 2924 - pci_set_power_state(pdev, PCI_D0); 2925 - pci_restore_state(pdev); 2926 - pci_enable_wake(pdev, PCI_D0, 0); 2927 2923 2928 2924 rtl8169_schedule_work(dev, rtl8169_reset_task); 2929 2925 out: