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

Commit 10f00a49 authored by Mark Einon's avatar Mark Einon Committed by Greg Kroah-Hartman
Browse files

staging: et131x: Rename var name 'etdev' to 'adapter' throughout module 



Used regex (from vim) :%s/\<etdev\>/adapter/g

Changed because:
* 'etdev' is easily confused as a misspelling of 'netdev'
* 'adapter' is more widely used for this struct type in net drivers. This
change made comparing code with other drivers much easier.

Signed-off-by: default avatarMark Einon <mark.einon@gmail.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent bc8585fc

drivers/staging/et131x/et1310_eeprom.c

+16 −16
Original line number Diff line number Diff line
@@ -150,15 +150,15 @@ static int eeprom_wait_ready(struct pci_dev *pdev, u32 *status) 


/**

 * eeprom_write - Write a byte to the ET1310's EEPROM

 * @etdev: pointer to our private adapter structure

 * @adapter: pointer to our private adapter structure

 * @addr: the address to write

 * @data: the value to write

 *

 * Returns 1 for a successful write.

 */

static int eeprom_write(struct et131x_adapter *etdev, u32 addr, u8 data)

static int eeprom_write(struct et131x_adapter *adapter, u32 addr, u8 data)

{

	struct pci_dev *pdev = etdev->pdev;

	struct pci_dev *pdev = adapter->pdev;

	int index = 0;

	int retries;

	int err = 0;
@@ -222,7 +222,7 @@ static int eeprom_write(struct et131x_adapter *etdev, u32 addr, u8 data) 
		 * 1, this is so we do a blind write for load bug.

		 */

		if ((status & LBCIF_STATUS_GENERAL_ERROR)

			&& etdev->pdev->revision == 0)

			&& adapter->pdev->revision == 0)

			break;



		/*
@@ -280,7 +280,7 @@ static int eeprom_write(struct et131x_adapter *etdev, u32 addr, u8 data) 


/**

 * eeprom_read - Read a byte from the ET1310's EEPROM

 * @etdev: pointer to our private adapter structure

 * @adapter: pointer to our private adapter structure

 * @addr: the address from which to read

 * @pdata: a pointer to a byte in which to store the value of the read

 * @eeprom_id: the ID of the EEPROM
@@ -288,9 +288,9 @@ static int eeprom_write(struct et131x_adapter *etdev, u32 addr, u8 data) 
 *

 * Returns 1 for a successful read

 */

static int eeprom_read(struct et131x_adapter *etdev, u32 addr, u8 *pdata)

static int eeprom_read(struct et131x_adapter *adapter, u32 addr, u8 *pdata)

{

	struct pci_dev *pdev = etdev->pdev;

	struct pci_dev *pdev = adapter->pdev;

	int err;

	u32 status;
@@ -337,9 +337,9 @@ static int eeprom_read(struct et131x_adapter *etdev, u32 addr, u8 *pdata) 
	return (status & LBCIF_STATUS_ACK_ERROR) ? -EIO : 0;

}



int et131x_init_eeprom(struct et131x_adapter *etdev)

int et131x_init_eeprom(struct et131x_adapter *adapter)

{

	struct pci_dev *pdev = etdev->pdev;

	struct pci_dev *pdev = adapter->pdev;

	u8 eestatus;



	/* We first need to check the EEPROM Status code located at offset
@@ -374,7 +374,7 @@ int et131x_init_eeprom(struct et131x_adapter *etdev) 
			 * corruption seen with 1310 B Silicon

			 */

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

				if (eeprom_write(etdev, i, eedata[i]) < 0)

				if (eeprom_write(adapter, i, eedata[i]) < 0)

					write_failed = 1;

		}

		if (pdev->revision  != 0x01 || write_failed) {
@@ -387,21 +387,21 @@ int et131x_init_eeprom(struct et131x_adapter *etdev) 
			 * gather additional information that normally would

			 * come from the eeprom, like MAC Address

			 */

			etdev->has_eeprom = 0;

			adapter->has_eeprom = 0;

			return -EIO;

		}

	}

	etdev->has_eeprom = 1;

	adapter->has_eeprom = 1;



	/* Read the EEPROM for information regarding LED behavior. Refer to

	 * ET1310_phy.c, et131x_xcvr_init(), for its use.

	 */

	eeprom_read(etdev, 0x70, &etdev->eeprom_data[0]);

	eeprom_read(etdev, 0x71, &etdev->eeprom_data[1]);

	eeprom_read(adapter, 0x70, &adapter->eeprom_data[0]);

	eeprom_read(adapter, 0x71, &adapter->eeprom_data[1]);



	if (etdev->eeprom_data[0] != 0xcd)

	if (adapter->eeprom_data[0] != 0xcd)

		/* Disable all optional features */

		etdev->eeprom_data[1] = 0x00;

		adapter->eeprom_data[1] = 0x00;



	return 0;

}

drivers/staging/et131x/et1310_mac.c

+103 −103
Original line number Diff line number Diff line
@@ -100,11 +100,11 @@ 


/**

 * et1310_config_mac_regs1 - Initialize the first part of MAC regs

 * @etdev: pointer to our adapter structure

 * @adapter: pointer to our adapter structure

 */

void et1310_config_mac_regs1(struct et131x_adapter *etdev)

void et1310_config_mac_regs1(struct et131x_adapter *adapter)

{

	struct mac_regs __iomem *macregs = &etdev->regs->mac;

	struct mac_regs __iomem *macregs = &adapter->regs->mac;

	u32 station1;

	u32 station2;

	u32 ipg;
@@ -136,12 +136,12 @@ void et1310_config_mac_regs1(struct et131x_adapter *etdev) 
	 * station address is used for generating and checking pause control

	 * packets.

	 */

	station2 = (etdev->addr[1] << ET_MAC_STATION_ADDR2_OC2_SHIFT) |

		   (etdev->addr[0] << ET_MAC_STATION_ADDR2_OC1_SHIFT);

	station1 = (etdev->addr[5] << ET_MAC_STATION_ADDR1_OC6_SHIFT) |

		   (etdev->addr[4] << ET_MAC_STATION_ADDR1_OC5_SHIFT) |

		   (etdev->addr[3] << ET_MAC_STATION_ADDR1_OC4_SHIFT) |

		    etdev->addr[2];

	station2 = (adapter->addr[1] << ET_MAC_STATION_ADDR2_OC2_SHIFT) |

		   (adapter->addr[0] << ET_MAC_STATION_ADDR2_OC1_SHIFT);

	station1 = (adapter->addr[5] << ET_MAC_STATION_ADDR1_OC6_SHIFT) |

		   (adapter->addr[4] << ET_MAC_STATION_ADDR1_OC5_SHIFT) |

		   (adapter->addr[3] << ET_MAC_STATION_ADDR1_OC4_SHIFT) |

		    adapter->addr[2];

	writel(station1, &macregs->station_addr_1);

	writel(station2, &macregs->station_addr_2);
@@ -152,7 +152,7 @@ void et1310_config_mac_regs1(struct et131x_adapter *etdev) 
	 * Packets larger than (registry_jumbo_packet) that do not contain a

	 * VLAN ID will be dropped by the Rx function.

	 */

	writel(etdev->registry_jumbo_packet + 4, &macregs->max_fm_len);

	writel(adapter->registry_jumbo_packet + 4, &macregs->max_fm_len);



	/* clear out MAC config reset */

	writel(0, &macregs->cfg1);
@@ -160,25 +160,25 @@ void et1310_config_mac_regs1(struct et131x_adapter *etdev) 


/**

 * et1310_config_mac_regs2 - Initialize the second part of MAC regs

 * @etdev: pointer to our adapter structure

 * @adapter: pointer to our adapter structure

 */

void et1310_config_mac_regs2(struct et131x_adapter *etdev)

void et1310_config_mac_regs2(struct et131x_adapter *adapter)

{

	int32_t delay = 0;

	struct mac_regs __iomem *mac = &etdev->regs->mac;

	struct mac_regs __iomem *mac = &adapter->regs->mac;

	u32 cfg1;

	u32 cfg2;

	u32 ifctrl;

	u32 ctl;



	ctl = readl(&etdev->regs->txmac.ctl);

	ctl = readl(&adapter->regs->txmac.ctl);

	cfg1 = readl(&mac->cfg1);

	cfg2 = readl(&mac->cfg2);

	ifctrl = readl(&mac->if_ctrl);



	/* Set up the if mode bits */

	cfg2 &= ~0x300;

	if (etdev->linkspeed == TRUEPHY_SPEED_1000MBPS) {

	if (adapter->linkspeed == TRUEPHY_SPEED_1000MBPS) {

		cfg2 |= 0x200;

		/* Phy mode bit */

		ifctrl &= ~(1 << 24);
@@ -191,7 +191,7 @@ void et1310_config_mac_regs2(struct et131x_adapter *etdev) 
	cfg1 |= CFG1_RX_ENABLE | CFG1_TX_ENABLE | CFG1_TX_FLOW;

	/* Initialize loop back to off */

	cfg1 &= ~(CFG1_LOOPBACK | CFG1_RX_FLOW);

	if (etdev->flowcontrol == FLOW_RXONLY || etdev->flowcontrol == FLOW_BOTH)

	if (adapter->flowcontrol == FLOW_RXONLY || adapter->flowcontrol == FLOW_BOTH)

		cfg1 |= CFG1_RX_FLOW;

	writel(cfg1, &mac->cfg1);
@@ -202,11 +202,11 @@ void et1310_config_mac_regs2(struct et131x_adapter *etdev) 
	cfg2 &= ~0x0021;



	/* Turn on duplex if needed */

	if (etdev->duplex_mode)

	if (adapter->duplex_mode)

		cfg2 |= 0x01;



	ifctrl &= ~(1 << 26);

	if (!etdev->duplex_mode)

	if (!adapter->duplex_mode)

		ifctrl |= (1<<26);	/* Enable ghd */



	writel(ifctrl, &mac->if_ctrl);
@@ -219,25 +219,25 @@ void et1310_config_mac_regs2(struct et131x_adapter *etdev) 
	} while ((cfg1 & CFG1_WAIT) != CFG1_WAIT && delay < 100);



	if (delay == 100) {

		dev_warn(&etdev->pdev->dev,

		dev_warn(&adapter->pdev->dev,

		    "Syncd bits did not respond correctly cfg1 word 0x%08x\n",

			cfg1);

	}



	/* Enable txmac */

	ctl |= 0x09;	/* TX mac enable, FC disable */

	writel(ctl, &etdev->regs->txmac.ctl);

	writel(ctl, &adapter->regs->txmac.ctl);



	/* Ready to start the RXDMA/TXDMA engine */

	if (etdev->flags & fMP_ADAPTER_LOWER_POWER) {

		et131x_rx_dma_enable(etdev);

		et131x_tx_dma_enable(etdev);

	if (adapter->flags & fMP_ADAPTER_LOWER_POWER) {

		et131x_rx_dma_enable(adapter);

		et131x_tx_dma_enable(adapter);

	}

}



void et1310_config_rxmac_regs(struct et131x_adapter *etdev)

void et1310_config_rxmac_regs(struct et131x_adapter *adapter)

{

	struct rxmac_regs __iomem *rxmac = &etdev->regs->rxmac;

	struct rxmac_regs __iomem *rxmac = &adapter->regs->rxmac;

	u32 sa_lo;

	u32 sa_hi = 0;

	u32 pf_ctrl = 0;
@@ -280,22 +280,22 @@ void et1310_config_rxmac_regs(struct et131x_adapter *etdev) 
	writel(0, &rxmac->mask4_word3);



	/* Lets setup the WOL Source Address */

	sa_lo = (etdev->addr[2] << ET_WOL_LO_SA3_SHIFT) |

		(etdev->addr[3] << ET_WOL_LO_SA4_SHIFT) |

		(etdev->addr[4] << ET_WOL_LO_SA5_SHIFT) |

		 etdev->addr[5];

	sa_lo = (adapter->addr[2] << ET_WOL_LO_SA3_SHIFT) |

		(adapter->addr[3] << ET_WOL_LO_SA4_SHIFT) |

		(adapter->addr[4] << ET_WOL_LO_SA5_SHIFT) |

		 adapter->addr[5];

	writel(sa_lo, &rxmac->sa_lo);



	sa_hi = (u32) (etdev->addr[0] << ET_WOL_HI_SA1_SHIFT) |

	               etdev->addr[1];

	sa_hi = (u32) (adapter->addr[0] << ET_WOL_HI_SA1_SHIFT) |

	               adapter->addr[1];

	writel(sa_hi, &rxmac->sa_hi);



	/* Disable all Packet Filtering */

	writel(0, &rxmac->pf_ctrl);



	/* Let's initialize the Unicast Packet filtering address */

	if (etdev->packet_filter & ET131X_PACKET_TYPE_DIRECTED) {

		et1310_setup_device_for_unicast(etdev);

	if (adapter->packet_filter & ET131X_PACKET_TYPE_DIRECTED) {

		et1310_setup_device_for_unicast(adapter);

		pf_ctrl |= 4;	/* Unicast filter */

	} else {

		writel(0, &rxmac->uni_pf_addr1);
@@ -304,16 +304,16 @@ void et1310_config_rxmac_regs(struct et131x_adapter *etdev) 
	}



	/* Let's initialize the Multicast hash */

	if (!(etdev->packet_filter & ET131X_PACKET_TYPE_ALL_MULTICAST)) {

	if (!(adapter->packet_filter & ET131X_PACKET_TYPE_ALL_MULTICAST)) {

		pf_ctrl |= 2;	/* Multicast filter */

		et1310_setup_device_for_multicast(etdev);

		et1310_setup_device_for_multicast(adapter);

	}



	/* Runt packet filtering.  Didn't work in version A silicon. */

	pf_ctrl |= (NIC_MIN_PACKET_SIZE + 4) << 16;

	pf_ctrl |= 8;	/* Fragment filter */



	if (etdev->registry_jumbo_packet > 8192)

	if (adapter->registry_jumbo_packet > 8192)

		/* In order to transmit jumbo packets greater than 8k, the

		 * FIFO between RxMAC and RxDMA needs to be reduced in size

		 * to (16k - Jumbo packet size).  In order to implement this,
@@ -350,7 +350,7 @@ void et1310_config_rxmac_regs(struct et131x_adapter *etdev) 
	 * bit 16: Receive frame truncated.

	 * bit 17: Drop packet enable

	 */

	if (etdev->linkspeed == TRUEPHY_SPEED_100MBPS)

	if (adapter->linkspeed == TRUEPHY_SPEED_100MBPS)

		writel(0x30038, &rxmac->mif_ctrl);

	else

		writel(0x30030, &rxmac->mif_ctrl);
@@ -365,24 +365,24 @@ void et1310_config_rxmac_regs(struct et131x_adapter *etdev) 
	writel(0x9, &rxmac->ctrl);

}



void et1310_config_txmac_regs(struct et131x_adapter *etdev)

void et1310_config_txmac_regs(struct et131x_adapter *adapter)

{

	struct txmac_regs *txmac = &etdev->regs->txmac;

	struct txmac_regs *txmac = &adapter->regs->txmac;



	/* We need to update the Control Frame Parameters

	 * cfpt - control frame pause timer set to 64 (0x40)

	 * cfep - control frame extended pause timer set to 0x0

	 */

	if (etdev->flowcontrol == FLOW_NONE)

	if (adapter->flowcontrol == FLOW_NONE)

		writel(0, &txmac->cf_param);

	else

		writel(0x40, &txmac->cf_param);

}



void et1310_config_macstat_regs(struct et131x_adapter *etdev)

void et1310_config_macstat_regs(struct et131x_adapter *adapter)

{

	struct macstat_regs __iomem *macstat =

		&etdev->regs->macstat;

		&adapter->regs->macstat;



	/* Next we need to initialize all the macstat registers to zero on

	 * the device.
@@ -444,50 +444,50 @@ void et1310_config_macstat_regs(struct et131x_adapter *etdev) 
	writel(0xFFFE7E8B, &macstat->carry_reg2_mask);

}



void et1310_config_flow_control(struct et131x_adapter *etdev)

void et1310_config_flow_control(struct et131x_adapter *adapter)

{

	if (etdev->duplex_mode == 0) {

		etdev->flowcontrol = FLOW_NONE;

	if (adapter->duplex_mode == 0) {

		adapter->flowcontrol = FLOW_NONE;

	} else {

		char remote_pause, remote_async_pause;



		et1310_phy_access_mii_bit(etdev,

		et1310_phy_access_mii_bit(adapter,

				TRUEPHY_BIT_READ, 5, 10, &remote_pause);

		et1310_phy_access_mii_bit(etdev,

		et1310_phy_access_mii_bit(adapter,

				TRUEPHY_BIT_READ, 5, 11,

				&remote_async_pause);



		if ((remote_pause == TRUEPHY_BIT_SET) &&

		    (remote_async_pause == TRUEPHY_BIT_SET)) {

			etdev->flowcontrol = etdev->wanted_flow;

			adapter->flowcontrol = adapter->wanted_flow;

		} else if ((remote_pause == TRUEPHY_BIT_SET) &&

			   (remote_async_pause == TRUEPHY_BIT_CLEAR)) {

			if (etdev->wanted_flow == FLOW_BOTH)

				etdev->flowcontrol = FLOW_BOTH;

			if (adapter->wanted_flow == FLOW_BOTH)

				adapter->flowcontrol = FLOW_BOTH;

			else

				etdev->flowcontrol = FLOW_NONE;

				adapter->flowcontrol = FLOW_NONE;

		} else if ((remote_pause == TRUEPHY_BIT_CLEAR) &&

			   (remote_async_pause == TRUEPHY_BIT_CLEAR)) {

			etdev->flowcontrol = FLOW_NONE;

			adapter->flowcontrol = FLOW_NONE;

		} else {/* if (remote_pause == TRUEPHY_CLEAR_BIT &&

			       remote_async_pause == TRUEPHY_SET_BIT) */

			if (etdev->wanted_flow == FLOW_BOTH)

				etdev->flowcontrol = FLOW_RXONLY;

			if (adapter->wanted_flow == FLOW_BOTH)

				adapter->flowcontrol = FLOW_RXONLY;

			else

				etdev->flowcontrol = FLOW_NONE;

				adapter->flowcontrol = FLOW_NONE;

		}

	}

}



/**

 * et1310_update_macstat_host_counters - Update the local copy of the statistics

 * @etdev: pointer to the adapter structure

 * @adapter: pointer to the adapter structure

 */

void et1310_update_macstat_host_counters(struct et131x_adapter *etdev)

void et1310_update_macstat_host_counters(struct et131x_adapter *adapter)

{

	struct ce_stats *stats = &etdev->stats;

	struct ce_stats *stats = &adapter->stats;

	struct macstat_regs __iomem *macstat =

		&etdev->regs->macstat;

		&adapter->regs->macstat;



	stats->tx_collisions	       += readl(&macstat->tx_total_collisions);

	stats->tx_first_collisions     += readl(&macstat->tx_single_collisions);
@@ -509,13 +509,13 @@ void et1310_update_macstat_host_counters(struct et131x_adapter *etdev) 


/**

 * et1310_handle_macstat_interrupt

 * @etdev: pointer to the adapter structure

 * @adapter: pointer to the adapter structure

 *

 * One of the MACSTAT counters has wrapped.  Update the local copy of

 * the statistics held in the adapter structure, checking the "wrap"

 * bit for each counter.

 */

void et1310_handle_macstat_interrupt(struct et131x_adapter *etdev)

void et1310_handle_macstat_interrupt(struct et131x_adapter *adapter)

{

	u32 carry_reg1;

	u32 carry_reg2;
@@ -523,11 +523,11 @@ void et1310_handle_macstat_interrupt(struct et131x_adapter *etdev) 
	/* Read the interrupt bits from the register(s).  These are Clear On

	 * Write.

	 */

	carry_reg1 = readl(&etdev->regs->macstat.carry_reg1);

	carry_reg2 = readl(&etdev->regs->macstat.carry_reg2);

	carry_reg1 = readl(&adapter->regs->macstat.carry_reg1);

	carry_reg2 = readl(&adapter->regs->macstat.carry_reg2);



	writel(carry_reg1, &etdev->regs->macstat.carry_reg1);

	writel(carry_reg2, &etdev->regs->macstat.carry_reg2);

	writel(carry_reg1, &adapter->regs->macstat.carry_reg1);

	writel(carry_reg2, &adapter->regs->macstat.carry_reg2);



	/* We need to do update the host copy of all the MAC_STAT counters.

	 * For each counter, check it's overflow bit.  If the overflow bit is
@@ -536,38 +536,38 @@ void et1310_handle_macstat_interrupt(struct et131x_adapter *etdev) 
	 * block indicates that one of the counters has wrapped.

	 */

	if (carry_reg1 & (1 << 14))

		etdev->stats.rx_code_violations	+= COUNTER_WRAP_16_BIT;

		adapter->stats.rx_code_violations	+= COUNTER_WRAP_16_BIT;

	if (carry_reg1 & (1 << 8))

		etdev->stats.rx_align_errs	+= COUNTER_WRAP_12_BIT;

		adapter->stats.rx_align_errs	+= COUNTER_WRAP_12_BIT;

	if (carry_reg1 & (1 << 7))

		etdev->stats.rx_length_errs	+= COUNTER_WRAP_16_BIT;

		adapter->stats.rx_length_errs	+= COUNTER_WRAP_16_BIT;

	if (carry_reg1 & (1 << 2))

		etdev->stats.rx_other_errs	+= COUNTER_WRAP_16_BIT;

		adapter->stats.rx_other_errs	+= COUNTER_WRAP_16_BIT;

	if (carry_reg1 & (1 << 6))

		etdev->stats.rx_crc_errs	+= COUNTER_WRAP_16_BIT;

		adapter->stats.rx_crc_errs	+= COUNTER_WRAP_16_BIT;

	if (carry_reg1 & (1 << 3))

		etdev->stats.rx_overflows	+= COUNTER_WRAP_16_BIT;

		adapter->stats.rx_overflows	+= COUNTER_WRAP_16_BIT;

	if (carry_reg1 & (1 << 0))

		etdev->stats.rcvd_pkts_dropped	+= COUNTER_WRAP_16_BIT;

		adapter->stats.rcvd_pkts_dropped	+= COUNTER_WRAP_16_BIT;

	if (carry_reg2 & (1 << 16))

		etdev->stats.tx_max_pkt_errs	+= COUNTER_WRAP_12_BIT;

		adapter->stats.tx_max_pkt_errs	+= COUNTER_WRAP_12_BIT;

	if (carry_reg2 & (1 << 15))

		etdev->stats.tx_underflows	+= COUNTER_WRAP_12_BIT;

		adapter->stats.tx_underflows	+= COUNTER_WRAP_12_BIT;

	if (carry_reg2 & (1 << 6))

		etdev->stats.tx_first_collisions += COUNTER_WRAP_12_BIT;

		adapter->stats.tx_first_collisions += COUNTER_WRAP_12_BIT;

	if (carry_reg2 & (1 << 8))

		etdev->stats.tx_deferred	+= COUNTER_WRAP_12_BIT;

		adapter->stats.tx_deferred	+= COUNTER_WRAP_12_BIT;

	if (carry_reg2 & (1 << 5))

		etdev->stats.tx_excessive_collisions += COUNTER_WRAP_12_BIT;

		adapter->stats.tx_excessive_collisions += COUNTER_WRAP_12_BIT;

	if (carry_reg2 & (1 << 4))

		etdev->stats.tx_late_collisions	+= COUNTER_WRAP_12_BIT;

		adapter->stats.tx_late_collisions	+= COUNTER_WRAP_12_BIT;

	if (carry_reg2 & (1 << 2))

		etdev->stats.tx_collisions	+= COUNTER_WRAP_12_BIT;

		adapter->stats.tx_collisions	+= COUNTER_WRAP_12_BIT;

}



void et1310_setup_device_for_multicast(struct et131x_adapter *etdev)

void et1310_setup_device_for_multicast(struct et131x_adapter *adapter)

{

	struct rxmac_regs __iomem *rxmac = &etdev->regs->rxmac;

	struct rxmac_regs __iomem *rxmac = &adapter->regs->rxmac;

	uint32_t nIndex;

	uint32_t result;

	uint32_t hash1 = 0;
@@ -581,11 +581,11 @@ void et1310_setup_device_for_multicast(struct et131x_adapter *etdev) 
	 * specified) then we should pass NO multi-cast addresses to the

	 * driver.

	 */

	if (etdev->packet_filter & ET131X_PACKET_TYPE_MULTICAST) {

	if (adapter->packet_filter & ET131X_PACKET_TYPE_MULTICAST) {

		/* Loop through our multicast array and set up the device */

		for (nIndex = 0; nIndex < etdev->multicast_addr_count;

		for (nIndex = 0; nIndex < adapter->multicast_addr_count;

		     nIndex++) {

			result = ether_crc(6, etdev->multicast_list[nIndex]);

			result = ether_crc(6, adapter->multicast_list[nIndex]);



			result = (result & 0x3F800000) >> 23;
@@ -605,7 +605,7 @@ void et1310_setup_device_for_multicast(struct et131x_adapter *etdev) 
	}



	/* Write out the new hash to the device */

	pm_csr = readl(&etdev->regs->global.pm_csr);

	pm_csr = readl(&adapter->regs->global.pm_csr);

	if ((pm_csr & ET_PM_PHY_SW_COMA) == 0) {

		writel(hash1, &rxmac->multi_hash1);

		writel(hash2, &rxmac->multi_hash2);
@@ -614,9 +614,9 @@ void et1310_setup_device_for_multicast(struct et131x_adapter *etdev) 
	}

}



void et1310_setup_device_for_unicast(struct et131x_adapter *etdev)

void et1310_setup_device_for_unicast(struct et131x_adapter *adapter)

{

	struct rxmac_regs __iomem *rxmac = &etdev->regs->rxmac;

	struct rxmac_regs __iomem *rxmac = &adapter->regs->rxmac;

	u32 uni_pf1;

	u32 uni_pf2;

	u32 uni_pf3;
@@ -631,22 +631,22 @@ void et1310_setup_device_for_unicast(struct et131x_adapter *etdev) 
	 * Set up unicast packet filter reg 3 to be the octets 2 - 5 of the

	 * MAC address for first address

	 */

	uni_pf3 = (etdev->addr[0] << ET_UNI_PF_ADDR2_1_SHIFT) |

		  (etdev->addr[1] << ET_UNI_PF_ADDR2_2_SHIFT) |

		  (etdev->addr[0] << ET_UNI_PF_ADDR1_1_SHIFT) |

		   etdev->addr[1];



	uni_pf2 = (etdev->addr[2] << ET_UNI_PF_ADDR2_3_SHIFT) |

		  (etdev->addr[3] << ET_UNI_PF_ADDR2_4_SHIFT) |

		  (etdev->addr[4] << ET_UNI_PF_ADDR2_5_SHIFT) |

		   etdev->addr[5];



	uni_pf1 = (etdev->addr[2] << ET_UNI_PF_ADDR1_3_SHIFT) |

		  (etdev->addr[3] << ET_UNI_PF_ADDR1_4_SHIFT) |

		  (etdev->addr[4] << ET_UNI_PF_ADDR1_5_SHIFT) |

		   etdev->addr[5];



	pm_csr = readl(&etdev->regs->global.pm_csr);

	uni_pf3 = (adapter->addr[0] << ET_UNI_PF_ADDR2_1_SHIFT) |

		  (adapter->addr[1] << ET_UNI_PF_ADDR2_2_SHIFT) |

		  (adapter->addr[0] << ET_UNI_PF_ADDR1_1_SHIFT) |

		   adapter->addr[1];



	uni_pf2 = (adapter->addr[2] << ET_UNI_PF_ADDR2_3_SHIFT) |

		  (adapter->addr[3] << ET_UNI_PF_ADDR2_4_SHIFT) |

		  (adapter->addr[4] << ET_UNI_PF_ADDR2_5_SHIFT) |

		   adapter->addr[5];



	uni_pf1 = (adapter->addr[2] << ET_UNI_PF_ADDR1_3_SHIFT) |

		  (adapter->addr[3] << ET_UNI_PF_ADDR1_4_SHIFT) |

		  (adapter->addr[4] << ET_UNI_PF_ADDR1_5_SHIFT) |

		   adapter->addr[5];



	pm_csr = readl(&adapter->regs->global.pm_csr);

	if ((pm_csr & ET_PM_PHY_SW_COMA) == 0) {

		writel(uni_pf1, &rxmac->uni_pf_addr1);

		writel(uni_pf2, &rxmac->uni_pf_addr2);

drivers/staging/et131x/et1310_phy.c

+195 −195

File changed.

Preview size limit exceeded, changes collapsed.

drivers/staging/et131x/et1310_pm.c

+22 −22
Original line number Diff line number Diff line
@@ -88,7 +88,7 @@ 


/**

 * et1310_enable_phy_coma - called when network cable is unplugged

 * @etdev: pointer to our adapter structure

 * @adapter: pointer to our adapter structure

 *

 * driver receive an phy status change interrupt while in D0 and check that

 * phy_status is down.
@@ -106,75 +106,75 @@ 
 *       indicating linkup status, call the MPDisablePhyComa routine to

 *             restore JAGCore and gigE PHY

 */

void et1310_enable_phy_coma(struct et131x_adapter *etdev)

void et1310_enable_phy_coma(struct et131x_adapter *adapter)

{

	unsigned long flags;

	u32 pmcsr;



	pmcsr = readl(&etdev->regs->global.pm_csr);

	pmcsr = readl(&adapter->regs->global.pm_csr);



	/* Save the GbE PHY speed and duplex modes. Need to restore this

	 * when cable is plugged back in

	 */

	etdev->pdown_speed = etdev->ai_force_speed;

	etdev->pdown_duplex = etdev->ai_force_duplex;

	adapter->pdown_speed = adapter->ai_force_speed;

	adapter->pdown_duplex = adapter->ai_force_duplex;



	/* Stop sending packets. */

	spin_lock_irqsave(&etdev->send_hw_lock, flags);

	etdev->flags |= fMP_ADAPTER_LOWER_POWER;

	spin_unlock_irqrestore(&etdev->send_hw_lock, flags);

	spin_lock_irqsave(&adapter->send_hw_lock, flags);

	adapter->flags |= fMP_ADAPTER_LOWER_POWER;

	spin_unlock_irqrestore(&adapter->send_hw_lock, flags);



	/* Wait for outstanding Receive packets */



	/* Gate off JAGCore 3 clock domains */

	pmcsr &= ~ET_PMCSR_INIT;

	writel(pmcsr, &etdev->regs->global.pm_csr);

	writel(pmcsr, &adapter->regs->global.pm_csr);



	/* Program gigE PHY in to Coma mode */

	pmcsr |= ET_PM_PHY_SW_COMA;

	writel(pmcsr, &etdev->regs->global.pm_csr);

	writel(pmcsr, &adapter->regs->global.pm_csr);

}



/**

 * et1310_disable_phy_coma - Disable the Phy Coma Mode

 * @etdev: pointer to our adapter structure

 * @adapter: pointer to our adapter structure

 */

void et1310_disable_phy_coma(struct et131x_adapter *etdev)

void et1310_disable_phy_coma(struct et131x_adapter *adapter)

{

	u32 pmcsr;



	pmcsr = readl(&etdev->regs->global.pm_csr);

	pmcsr = readl(&adapter->regs->global.pm_csr);



	/* Disable phy_sw_coma register and re-enable JAGCore clocks */

	pmcsr |= ET_PMCSR_INIT;

	pmcsr &= ~ET_PM_PHY_SW_COMA;

	writel(pmcsr, &etdev->regs->global.pm_csr);

	writel(pmcsr, &adapter->regs->global.pm_csr);



	/* Restore the GbE PHY speed and duplex modes;

	 * Reset JAGCore; re-configure and initialize JAGCore and gigE PHY

	 */

	etdev->ai_force_speed = etdev->pdown_speed;

	etdev->ai_force_duplex = etdev->pdown_duplex;

	adapter->ai_force_speed = adapter->pdown_speed;

	adapter->ai_force_duplex = adapter->pdown_duplex;



	/* Re-initialize the send structures */

	et131x_init_send(etdev);

	et131x_init_send(adapter);



	/* Reset the RFD list and re-start RU  */

	et131x_reset_recv(etdev);

	et131x_reset_recv(adapter);



	/* Bring the device back to the state it was during init prior to

	 * autonegotiation being complete.  This way, when we get the auto-neg

	 * complete interrupt, we can complete init by calling ConfigMacREGS2.

	 */

	et131x_soft_reset(etdev);

	et131x_soft_reset(adapter);



	/* setup et1310 as per the documentation ?? */

	et131x_adapter_setup(etdev);

	et131x_adapter_setup(adapter);



	/* Allow Tx to restart */

	etdev->flags &= ~fMP_ADAPTER_LOWER_POWER;

	adapter->flags &= ~fMP_ADAPTER_LOWER_POWER;



	/* Need to re-enable Rx. */

	et131x_rx_dma_enable(etdev);

	et131x_rx_dma_enable(adapter);

}

drivers/staging/et131x/et1310_rx.c

+87 −87

File changed.

Preview size limit exceeded, changes collapsed.