Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 5a4c8d75 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6 

* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6: (33 commits)
  sony-laptop: re-read the rfkill state when resuming from suspend
  sony-laptop: check for rfkill hard block at load time
  wext: add back wireless/ dir in sysfs for cfg80211 interfaces
  wext: Add bound checks for copy_from_user
  mac80211: improve/fix mlme messages
  cfg80211: always get BSS
  iwlwifi: fix 3945 ucode info retrieval after failure
  iwlwifi: fix memory leak in command queue handling
  iwlwifi: fix debugfs buffer handling
  cfg80211: don't set privacy w/o key
  cfg80211: wext: don't display BSSID unless associated
  net: Add explicit bound checks in net/socket.c
  bridge: Fix double-free in br_add_if.
  isdn: fix netjet/isdnhdlc build errors
  atm: dereference of he_dev->rbps_virt in he_init_group()
  ax25: Add missing dev_put in ax25_setsockopt
  Revert "sit: stateless autoconf for isatap"
  net: fix double skb free in dcbnl
  net: fix nlmsg len size for skb when error bit is set.
  net: fix vlan_get_size to include vlan_flags size
  ...
parents e15daf6c eb1cf0f8

drivers/atm/he.c

+7 −7
Original line number Diff line number Diff line
@@ -921,9 +921,9 @@ he_init_group(struct he_dev *he_dev, int group) 
			he_dev->rbrq_phys);

	i = CONFIG_RBPL_SIZE;

out_free_rbpl_virt:

	while (--i)

		pci_pool_free(he_dev->rbps_pool, he_dev->rbpl_virt[i].virt,

				he_dev->rbps_base[i].phys);

	while (i--)

		pci_pool_free(he_dev->rbpl_pool, he_dev->rbpl_virt[i].virt,

				he_dev->rbpl_base[i].phys);

	kfree(he_dev->rbpl_virt);



out_free_rbpl_base:
@@ -933,11 +933,11 @@ he_init_group(struct he_dev *he_dev, int group) 
out_destroy_rbpl_pool:

	pci_pool_destroy(he_dev->rbpl_pool);



	i = CONFIG_RBPL_SIZE;

	i = CONFIG_RBPS_SIZE;

out_free_rbps_virt:

	while (--i)

		pci_pool_free(he_dev->rbpl_pool, he_dev->rbps_virt[i].virt,

				he_dev->rbpl_base[i].phys);

	while (i--)

		pci_pool_free(he_dev->rbps_pool, he_dev->rbps_virt[i].virt,

				he_dev->rbps_base[i].phys);

	kfree(he_dev->rbps_virt);



out_free_rbps_base:

drivers/isdn/hardware/mISDN/Kconfig

+1 −0
Original line number Diff line number Diff line
@@ -78,6 +78,7 @@ config MISDN_NETJET 
	depends on PCI

	select MISDN_IPAC

	select ISDN_HDLC

	select ISDN_I4L

	help

	  Enable support for Traverse Technologies NETJet PCI cards.

drivers/isdn/i4l/Kconfig

+1 −2
Original line number Diff line number Diff line
@@ -142,7 +142,6 @@ endif 


config ISDN_HDLC

	tristate

	depends on HISAX_ST5481

	select CRC_CCITT

	select BITREVERSE

drivers/net/e1000/e1000.h

+0 −3
Original line number Diff line number Diff line
@@ -149,7 +149,6 @@ do { \ 


#define AUTO_ALL_MODES            0

#define E1000_EEPROM_82544_APM    0x0004

#define E1000_EEPROM_ICH8_APME    0x0004

#define E1000_EEPROM_APME         0x0400



#ifndef E1000_MASTER_SLAVE
@@ -293,7 +292,6 @@ struct e1000_adapter { 


	u64 hw_csum_err;

	u64 hw_csum_good;

	u64 rx_hdr_split;

	u32 alloc_rx_buff_failed;

	u32 rx_int_delay;

	u32 rx_abs_int_delay;
@@ -317,7 +315,6 @@ struct e1000_adapter { 
	struct e1000_rx_ring test_rx_ring;



	int msg_enable;

	bool have_msi;



	/* to not mess up cache alignment, always add to the bottom */

	bool tso_force;

drivers/net/e1000/e1000_ethtool.c

+34 −168
Original line number Diff line number Diff line
@@ -82,7 +82,6 @@ static const struct e1000_stats e1000_gstrings_stats[] = { 
	{ "rx_long_byte_count", E1000_STAT(stats.gorcl) },

	{ "rx_csum_offload_good", E1000_STAT(hw_csum_good) },

	{ "rx_csum_offload_errors", E1000_STAT(hw_csum_err) },

	{ "rx_header_split", E1000_STAT(rx_hdr_split) },

	{ "alloc_rx_buff_failed", E1000_STAT(alloc_rx_buff_failed) },

	{ "tx_smbus", E1000_STAT(stats.mgptc) },

	{ "rx_smbus", E1000_STAT(stats.mgprc) },
@@ -114,8 +113,6 @@ static int e1000_get_settings(struct net_device *netdev, 
		                   SUPPORTED_1000baseT_Full|

		                   SUPPORTED_Autoneg |

		                   SUPPORTED_TP);

		if (hw->phy_type == e1000_phy_ife)

			ecmd->supported &= ~SUPPORTED_1000baseT_Full;

		ecmd->advertising = ADVERTISED_TP;



		if (hw->autoneg == 1) {
@@ -178,14 +175,6 @@ static int e1000_set_settings(struct net_device *netdev, 
	struct e1000_adapter *adapter = netdev_priv(netdev);

	struct e1000_hw *hw = &adapter->hw;



	/* When SoL/IDER sessions are active, autoneg/speed/duplex

	 * cannot be changed */

	if (e1000_check_phy_reset_block(hw)) {

		DPRINTK(DRV, ERR, "Cannot change link characteristics "

		        "when SoL/IDER is active.\n");

		return -EINVAL;

	}



	while (test_and_set_bit(__E1000_RESETTING, &adapter->flags))

		msleep(1);
@@ -330,9 +319,6 @@ static int e1000_set_tso(struct net_device *netdev, u32 data) 
	else

		netdev->features &= ~NETIF_F_TSO;



	if (data && (adapter->hw.mac_type > e1000_82547_rev_2))

		netdev->features |= NETIF_F_TSO6;

	else

	netdev->features &= ~NETIF_F_TSO6;



	DPRINTK(PROBE, INFO, "TSO is %s\n", data ? "Enabled" : "Disabled");
@@ -441,7 +427,6 @@ static void e1000_get_regs(struct net_device *netdev, struct ethtool_regs *regs, 
	regs_buff[24] = (u32)phy_data;  /* phy local receiver status */

	regs_buff[25] = regs_buff[24];  /* phy remote receiver status */

	if (hw->mac_type >= e1000_82540 &&

	    hw->mac_type < e1000_82571 &&

	    hw->media_type == e1000_media_type_copper) {

		regs_buff[26] = er32(MANC);

	}
@@ -554,10 +539,8 @@ static int e1000_set_eeprom(struct net_device *netdev, 
	ret_val = e1000_write_eeprom(hw, first_word,

				     last_word - first_word + 1, eeprom_buff);



	/* Update the checksum over the first part of the EEPROM if needed

	 * and flush shadow RAM for 82573 conrollers */

	if ((ret_val == 0) && ((first_word <= EEPROM_CHECKSUM_REG) ||

				(hw->mac_type == e1000_82573)))

	/* Update the checksum over the first part of the EEPROM if needed */

	if ((ret_val == 0) && (first_word <= EEPROM_CHECKSUM_REG))

		e1000_update_eeprom_checksum(hw);



	kfree(eeprom_buff);
@@ -568,31 +551,12 @@ static void e1000_get_drvinfo(struct net_device *netdev, 
			      struct ethtool_drvinfo *drvinfo)

{

	struct e1000_adapter *adapter = netdev_priv(netdev);

	struct e1000_hw *hw = &adapter->hw;

	char firmware_version[32];

	u16 eeprom_data;



	strncpy(drvinfo->driver,  e1000_driver_name, 32);

	strncpy(drvinfo->version, e1000_driver_version, 32);



	/* EEPROM image version # is reported as firmware version # for

	 * 8257{1|2|3} controllers */

	e1000_read_eeprom(hw, 5, 1, &eeprom_data);

	switch (hw->mac_type) {

	case e1000_82571:

	case e1000_82572:

	case e1000_82573:

	case e1000_80003es2lan:

	case e1000_ich8lan:

		sprintf(firmware_version, "%d.%d-%d",

			(eeprom_data & 0xF000) >> 12,

			(eeprom_data & 0x0FF0) >> 4,

			eeprom_data & 0x000F);

		break;

	default:

	sprintf(firmware_version, "N/A");

	}



	strncpy(drvinfo->fw_version, firmware_version, 32);

	strncpy(drvinfo->bus_info, pci_name(adapter->pdev), 32);

	drvinfo->regdump_len = e1000_get_regs_len(netdev);
@@ -781,21 +745,9 @@ static int e1000_reg_test(struct e1000_adapter *adapter, u64 *data) 
	/* The status register is Read Only, so a write should fail.

	 * Some bits that get toggled are ignored.

	 */

	switch (hw->mac_type) {



	/* there are several bits on newer hardware that are r/w */

	case e1000_82571:

	case e1000_82572:

	case e1000_80003es2lan:

		toggle = 0x7FFFF3FF;

		break;

	case e1000_82573:

	case e1000_ich8lan:

		toggle = 0x7FFFF033;

		break;

	default:

	toggle = 0xFFFFF833;

		break;

	}



	before = er32(STATUS);

	value = (er32(STATUS) & toggle);
@@ -810,12 +762,10 @@ static int e1000_reg_test(struct e1000_adapter *adapter, u64 *data) 
	/* restore previous status */

	ew32(STATUS, before);



	if (hw->mac_type != e1000_ich8lan) {

	REG_PATTERN_TEST(FCAL, 0xFFFFFFFF, 0xFFFFFFFF);

	REG_PATTERN_TEST(FCAH, 0x0000FFFF, 0xFFFFFFFF);

	REG_PATTERN_TEST(FCT, 0x0000FFFF, 0xFFFFFFFF);

	REG_PATTERN_TEST(VET, 0x0000FFFF, 0xFFFFFFFF);

	}



	REG_PATTERN_TEST(RDTR, 0x0000FFFF, 0xFFFFFFFF);

	REG_PATTERN_TEST(RDBAH, 0xFFFFFFFF, 0xFFFFFFFF);
@@ -830,8 +780,7 @@ static int e1000_reg_test(struct e1000_adapter *adapter, u64 *data) 


	REG_SET_AND_CHECK(RCTL, 0xFFFFFFFF, 0x00000000);



	before = (hw->mac_type == e1000_ich8lan ?

	          0x06C3B33E : 0x06DFB3FE);

	before = 0x06DFB3FE;

	REG_SET_AND_CHECK(RCTL, before, 0x003FFFFB);

	REG_SET_AND_CHECK(TCTL, 0xFFFFFFFF, 0x00000000);
@@ -839,12 +788,10 @@ static int e1000_reg_test(struct e1000_adapter *adapter, u64 *data) 


		REG_SET_AND_CHECK(RCTL, before, 0xFFFFFFFF);

		REG_PATTERN_TEST(RDBAL, 0xFFFFFFF0, 0xFFFFFFFF);

		if (hw->mac_type != e1000_ich8lan)

		REG_PATTERN_TEST(TXCW, 0xC000FFFF, 0x0000FFFF);

		REG_PATTERN_TEST(TDBAL, 0xFFFFFFF0, 0xFFFFFFFF);

		REG_PATTERN_TEST(TIDV, 0x0000FFFF, 0x0000FFFF);

		value = (hw->mac_type == e1000_ich8lan ?

		         E1000_RAR_ENTRIES_ICH8LAN : E1000_RAR_ENTRIES);

		value = E1000_RAR_ENTRIES;

		for (i = 0; i < value; i++) {

			REG_PATTERN_TEST(RA + (((i << 1) + 1) << 2), 0x8003FFFF,

			                 0xFFFFFFFF);
@@ -859,8 +806,7 @@ static int e1000_reg_test(struct e1000_adapter *adapter, u64 *data) 


	}



	value = (hw->mac_type == e1000_ich8lan ?

			E1000_MC_TBL_SIZE_ICH8LAN : E1000_MC_TBL_SIZE);

	value = E1000_MC_TBL_SIZE;

	for (i = 0; i < value; i++)

		REG_PATTERN_TEST(MTA + (i << 2), 0xFFFFFFFF, 0xFFFFFFFF);
@@ -933,9 +879,6 @@ static int e1000_intr_test(struct e1000_adapter *adapter, u64 *data) 
	/* Test each interrupt */

	for (; i < 10; i++) {



		if (hw->mac_type == e1000_ich8lan && i == 8)

			continue;



		/* Interrupt to test */

		mask = 1 << i;
@@ -1289,24 +1232,10 @@ static int e1000_integrated_phy_loopback(struct e1000_adapter *adapter) 
		e1000_write_phy_reg(hw, PHY_CTRL, 0x9140);

		/* autoneg off */

		e1000_write_phy_reg(hw, PHY_CTRL, 0x8140);

	} else if (hw->phy_type == e1000_phy_gg82563)

		e1000_write_phy_reg(hw,

		                    GG82563_PHY_KMRN_MODE_CTRL,

		                    0x1CC);

	}



	ctrl_reg = er32(CTRL);



	if (hw->phy_type == e1000_phy_ife) {

		/* force 100, set loopback */

		e1000_write_phy_reg(hw, PHY_CTRL, 0x6100);



		/* Now set up the MAC to the same speed/duplex as the PHY. */

		ctrl_reg &= ~E1000_CTRL_SPD_SEL; /* Clear the speed sel bits */

		ctrl_reg |= (E1000_CTRL_FRCSPD | /* Set the Force Speed Bit */

			     E1000_CTRL_FRCDPX | /* Set the Force Duplex Bit */

			     E1000_CTRL_SPD_100 |/* Force Speed to 100 */

			     E1000_CTRL_FD);	 /* Force Duplex to FULL */

	} else {

	/* force 1000, set loopback */

	e1000_write_phy_reg(hw, PHY_CTRL, 0x4140);
@@ -1317,7 +1246,6 @@ static int e1000_integrated_phy_loopback(struct e1000_adapter *adapter) 
			E1000_CTRL_FRCDPX | /* Set the Force Duplex Bit */

			E1000_CTRL_SPD_1000 |/* Force Speed to 1000 */

			E1000_CTRL_FD);	 /* Force Duplex to FULL */

	}



	if (hw->media_type == e1000_media_type_copper &&

	   hw->phy_type == e1000_phy_m88)
@@ -1373,14 +1301,8 @@ static int e1000_set_phy_loopback(struct e1000_adapter *adapter) 
	case e1000_82541_rev_2:

	case e1000_82547:

	case e1000_82547_rev_2:

	case e1000_82571:

	case e1000_82572:

	case e1000_82573:

	case e1000_80003es2lan:

	case e1000_ich8lan:

		return e1000_integrated_phy_loopback(adapter);

		break;



	default:

		/* Default PHY loopback work is to read the MII

		 * control register and assert bit 14 (loopback mode).
@@ -1409,14 +1331,6 @@ static int e1000_setup_loopback_test(struct e1000_adapter *adapter) 
		case e1000_82546_rev_3:

			return e1000_set_phy_loopback(adapter);

			break;

		case e1000_82571:

		case e1000_82572:

#define E1000_SERDES_LB_ON 0x410

			e1000_set_phy_loopback(adapter);

			ew32(SCTL, E1000_SERDES_LB_ON);

			msleep(10);

			return 0;

			break;

		default:

			rctl = er32(RCTL);

			rctl |= E1000_RCTL_LBM_TCVR;
@@ -1440,26 +1354,12 @@ static void e1000_loopback_cleanup(struct e1000_adapter *adapter) 
	ew32(RCTL, rctl);



	switch (hw->mac_type) {

	case e1000_82571:

	case e1000_82572:

		if (hw->media_type == e1000_media_type_fiber ||

		    hw->media_type == e1000_media_type_internal_serdes) {

#define E1000_SERDES_LB_OFF 0x400

			ew32(SCTL, E1000_SERDES_LB_OFF);

			msleep(10);

			break;

		}

		/* Fall Through */

	case e1000_82545:

	case e1000_82546:

	case e1000_82545_rev_3:

	case e1000_82546_rev_3:

	default:

		hw->autoneg = true;

		if (hw->phy_type == e1000_phy_gg82563)

			e1000_write_phy_reg(hw,

					    GG82563_PHY_KMRN_MODE_CTRL,

					    0x180);

		e1000_read_phy_reg(hw, PHY_CTRL, &phy_reg);

		if (phy_reg & MII_CR_LOOPBACK) {

			phy_reg &= ~MII_CR_LOOPBACK;
@@ -1560,17 +1460,6 @@ static int e1000_run_loopback_test(struct e1000_adapter *adapter) 


static int e1000_loopback_test(struct e1000_adapter *adapter, u64 *data)

{

	struct e1000_hw *hw = &adapter->hw;



	/* PHY loopback cannot be performed if SoL/IDER

	 * sessions are active */

	if (e1000_check_phy_reset_block(hw)) {

		DPRINTK(DRV, ERR, "Cannot do PHY loopback test "

		        "when SoL/IDER is active.\n");

		*data = 0;

		goto out;

	}



	*data = e1000_setup_desc_rings(adapter);

	if (*data)

		goto out;
@@ -1592,13 +1481,13 @@ static int e1000_link_test(struct e1000_adapter *adapter, u64 *data) 
	*data = 0;

	if (hw->media_type == e1000_media_type_internal_serdes) {

		int i = 0;

		hw->serdes_link_down = true;

		hw->serdes_has_link = false;



		/* On some blade server designs, link establishment

		 * could take as long as 2-3 minutes */

		do {

			e1000_check_for_link(hw);

			if (!hw->serdes_link_down)

			if (hw->serdes_has_link)

				return *data;

			msleep(20);

		} while (i++ < 3750);
@@ -1716,15 +1605,11 @@ static int e1000_wol_exclusion(struct e1000_adapter *adapter, 
	case E1000_DEV_ID_82545EM_COPPER:

	case E1000_DEV_ID_82546GB_QUAD_COPPER:

	case E1000_DEV_ID_82546GB_PCIE:

	case E1000_DEV_ID_82571EB_SERDES_QUAD:

		/* these don't support WoL at all */

		wol->supported = 0;

		break;

	case E1000_DEV_ID_82546EB_FIBER:

	case E1000_DEV_ID_82546GB_FIBER:

	case E1000_DEV_ID_82571EB_FIBER:

	case E1000_DEV_ID_82571EB_SERDES:

	case E1000_DEV_ID_82571EB_COPPER:

		/* Wake events not supported on port B */

		if (er32(STATUS) & E1000_STATUS_FUNC_1) {

			wol->supported = 0;
@@ -1733,10 +1618,6 @@ static int e1000_wol_exclusion(struct e1000_adapter *adapter, 
		/* return success for non excluded adapter ports */

		retval = 0;

		break;

	case E1000_DEV_ID_82571EB_QUAD_COPPER:

	case E1000_DEV_ID_82571EB_QUAD_FIBER:

	case E1000_DEV_ID_82571EB_QUAD_COPPER_LOWPROFILE:

	case E1000_DEV_ID_82571PT_QUAD_COPPER:

	case E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3:

		/* quad port adapters only support WoL on port A */

		if (!adapter->quad_port_a) {
@@ -1872,7 +1753,6 @@ static int e1000_phys_id(struct net_device *netdev, u32 data) 
	if (!data)

		data = INT_MAX;



	if (hw->mac_type < e1000_82571) {

	if (!adapter->blink_timer.function) {

		init_timer(&adapter->blink_timer);

		adapter->blink_timer.function = e1000_led_blink_callback;
@@ -1882,20 +1762,6 @@ static int e1000_phys_id(struct net_device *netdev, u32 data) 
	mod_timer(&adapter->blink_timer, jiffies);

	msleep_interruptible(data * 1000);

	del_timer_sync(&adapter->blink_timer);

	} else if (hw->phy_type == e1000_phy_ife) {

		if (!adapter->blink_timer.function) {

			init_timer(&adapter->blink_timer);

			adapter->blink_timer.function = e1000_led_blink_callback;

			adapter->blink_timer.data = (unsigned long)adapter;

		}

		mod_timer(&adapter->blink_timer, jiffies);

		msleep_interruptible(data * 1000);

		del_timer_sync(&adapter->blink_timer);

		e1000_write_phy_reg(&(adapter->hw), IFE_PHY_SPECIAL_CONTROL_LED, 0);

	} else {

		e1000_blink_led_start(hw);

		msleep_interruptible(data * 1000);

	}



	e1000_led_off(hw);

	clear_bit(E1000_LED_ON, &adapter->led_status);