brintos / linux-shallow public Read only

1// SPDX-License-Identifier: GPL-2.0+2/*3 * Copyright (C) 2015 Microchip Technology4 */5#include <linux/module.h>6#include <linux/netdevice.h>7#include <linux/etherdevice.h>8#include <linux/ethtool.h>9#include <linux/usb.h>10#include <linux/crc32.h>11#include <linux/signal.h>12#include <linux/slab.h>13#include <linux/if_vlan.h>14#include <linux/uaccess.h>15#include <linux/linkmode.h>16#include <linux/list.h>17#include <linux/ip.h>18#include <linux/ipv6.h>19#include <linux/mdio.h>20#include <linux/phy.h>21#include <net/ip6_checksum.h>22#include <net/vxlan.h>23#include <linux/interrupt.h>24#include <linux/irqdomain.h>25#include <linux/irq.h>26#include <linux/irqchip/chained_irq.h>27#include <linux/microchipphy.h>28#include <linux/phy_fixed.h>29#include <linux/of_mdio.h>30#include <linux/of_net.h>31#include "lan78xx.h"32 33#define DRIVER_AUTHOR	"WOOJUNG HUH <woojung.huh@microchip.com>"34#define DRIVER_DESC	"LAN78XX USB 3.0 Gigabit Ethernet Devices"35#define DRIVER_NAME	"lan78xx"36 37#define TX_TIMEOUT_JIFFIES		(5 * HZ)38#define THROTTLE_JIFFIES		(HZ / 8)39#define UNLINK_TIMEOUT_MS		340 41#define RX_MAX_QUEUE_MEMORY		(60 * 1518)42 43#define SS_USB_PKT_SIZE			(1024)44#define HS_USB_PKT_SIZE			(512)45#define FS_USB_PKT_SIZE			(64)46 47#define MAX_RX_FIFO_SIZE		(12 * 1024)48#define MAX_TX_FIFO_SIZE		(12 * 1024)49 50#define FLOW_THRESHOLD(n)		((((n) + 511) / 512) & 0x7F)51#define FLOW_CTRL_THRESHOLD(on, off)	((FLOW_THRESHOLD(on)  << 0) | \52					 (FLOW_THRESHOLD(off) << 8))53 54/* Flow control turned on when Rx FIFO level rises above this level (bytes) */55#define FLOW_ON_SS			921656#define FLOW_ON_HS			870457 58/* Flow control turned off when Rx FIFO level falls below this level (bytes) */59#define FLOW_OFF_SS			409660#define FLOW_OFF_HS			102461 62#define DEFAULT_BURST_CAP_SIZE		(MAX_TX_FIFO_SIZE)63#define DEFAULT_BULK_IN_DELAY		(0x0800)64#define MAX_SINGLE_PACKET_SIZE		(9000)65#define DEFAULT_TX_CSUM_ENABLE		(true)66#define DEFAULT_RX_CSUM_ENABLE		(true)67#define DEFAULT_TSO_CSUM_ENABLE		(true)68#define DEFAULT_VLAN_FILTER_ENABLE	(true)69#define DEFAULT_VLAN_RX_OFFLOAD		(true)70#define TX_ALIGNMENT			(4)71#define RXW_PADDING			272 73#define LAN78XX_USB_VENDOR_ID		(0x0424)74#define LAN7800_USB_PRODUCT_ID		(0x7800)75#define LAN7850_USB_PRODUCT_ID		(0x7850)76#define LAN7801_USB_PRODUCT_ID		(0x7801)77#define LAN78XX_EEPROM_MAGIC		(0x78A5)78#define LAN78XX_OTP_MAGIC		(0x78F3)79#define AT29M2AF_USB_VENDOR_ID		(0x07C9)80#define AT29M2AF_USB_PRODUCT_ID	(0x0012)81 82#define	MII_READ			183#define	MII_WRITE			084 85#define EEPROM_INDICATOR		(0xA5)86#define EEPROM_MAC_OFFSET		(0x01)87#define MAX_EEPROM_SIZE			51288#define OTP_INDICATOR_1			(0xF3)89#define OTP_INDICATOR_2			(0xF7)90 91#define WAKE_ALL			(WAKE_PHY | WAKE_UCAST | \92					 WAKE_MCAST | WAKE_BCAST | \93					 WAKE_ARP | WAKE_MAGIC)94 95#define TX_URB_NUM			1096#define TX_SS_URB_NUM			TX_URB_NUM97#define TX_HS_URB_NUM			TX_URB_NUM98#define TX_FS_URB_NUM			TX_URB_NUM99 100/* A single URB buffer must be large enough to hold a complete jumbo packet101 */102#define TX_SS_URB_SIZE			(32 * 1024)103#define TX_HS_URB_SIZE			(16 * 1024)104#define TX_FS_URB_SIZE			(10 * 1024)105 106#define RX_SS_URB_NUM			30107#define RX_HS_URB_NUM			10108#define RX_FS_URB_NUM			10109#define RX_SS_URB_SIZE			TX_SS_URB_SIZE110#define RX_HS_URB_SIZE			TX_HS_URB_SIZE111#define RX_FS_URB_SIZE			TX_FS_URB_SIZE112 113#define SS_BURST_CAP_SIZE		RX_SS_URB_SIZE114#define SS_BULK_IN_DELAY		0x2000115#define HS_BURST_CAP_SIZE		RX_HS_URB_SIZE116#define HS_BULK_IN_DELAY		0x2000117#define FS_BURST_CAP_SIZE		RX_FS_URB_SIZE118#define FS_BULK_IN_DELAY		0x2000119 120#define TX_CMD_LEN			8121#define TX_SKB_MIN_LEN			(TX_CMD_LEN + ETH_HLEN)122#define LAN78XX_TSO_SIZE(dev)		((dev)->tx_urb_size - TX_SKB_MIN_LEN)123 124#define RX_CMD_LEN			10125#define RX_SKB_MIN_LEN			(RX_CMD_LEN + ETH_HLEN)126#define RX_MAX_FRAME_LEN(mtu)		((mtu) + ETH_HLEN + VLAN_HLEN)127 128/* USB related defines */129#define BULK_IN_PIPE			1130#define BULK_OUT_PIPE			2131 132/* default autosuspend delay (mSec)*/133#define DEFAULT_AUTOSUSPEND_DELAY	(10 * 1000)134 135/* statistic update interval (mSec) */136#define STAT_UPDATE_TIMER		(1 * 1000)137 138/* time to wait for MAC or FCT to stop (jiffies) */139#define HW_DISABLE_TIMEOUT		(HZ / 10)140 141/* time to wait between polling MAC or FCT state (ms) */142#define HW_DISABLE_DELAY_MS		1143 144/* defines interrupts from interrupt EP */145#define MAX_INT_EP			(32)146#define INT_EP_INTEP			(31)147#define INT_EP_OTP_WR_DONE		(28)148#define INT_EP_EEE_TX_LPI_START		(26)149#define INT_EP_EEE_TX_LPI_STOP		(25)150#define INT_EP_EEE_RX_LPI		(24)151#define INT_EP_MAC_RESET_TIMEOUT	(23)152#define INT_EP_RDFO			(22)153#define INT_EP_TXE			(21)154#define INT_EP_USB_STATUS		(20)155#define INT_EP_TX_DIS			(19)156#define INT_EP_RX_DIS			(18)157#define INT_EP_PHY			(17)158#define INT_EP_DP			(16)159#define INT_EP_MAC_ERR			(15)160#define INT_EP_TDFU			(14)161#define INT_EP_TDFO			(13)162#define INT_EP_UTX			(12)163#define INT_EP_GPIO_11			(11)164#define INT_EP_GPIO_10			(10)165#define INT_EP_GPIO_9			(9)166#define INT_EP_GPIO_8			(8)167#define INT_EP_GPIO_7			(7)168#define INT_EP_GPIO_6			(6)169#define INT_EP_GPIO_5			(5)170#define INT_EP_GPIO_4			(4)171#define INT_EP_GPIO_3			(3)172#define INT_EP_GPIO_2			(2)173#define INT_EP_GPIO_1			(1)174#define INT_EP_GPIO_0			(0)175 176static const char lan78xx_gstrings[][ETH_GSTRING_LEN] = {177	"RX FCS Errors",178	"RX Alignment Errors",179	"Rx Fragment Errors",180	"RX Jabber Errors",181	"RX Undersize Frame Errors",182	"RX Oversize Frame Errors",183	"RX Dropped Frames",184	"RX Unicast Byte Count",185	"RX Broadcast Byte Count",186	"RX Multicast Byte Count",187	"RX Unicast Frames",188	"RX Broadcast Frames",189	"RX Multicast Frames",190	"RX Pause Frames",191	"RX 64 Byte Frames",192	"RX 65 - 127 Byte Frames",193	"RX 128 - 255 Byte Frames",194	"RX 256 - 511 Bytes Frames",195	"RX 512 - 1023 Byte Frames",196	"RX 1024 - 1518 Byte Frames",197	"RX Greater 1518 Byte Frames",198	"EEE RX LPI Transitions",199	"EEE RX LPI Time",200	"TX FCS Errors",201	"TX Excess Deferral Errors",202	"TX Carrier Errors",203	"TX Bad Byte Count",204	"TX Single Collisions",205	"TX Multiple Collisions",206	"TX Excessive Collision",207	"TX Late Collisions",208	"TX Unicast Byte Count",209	"TX Broadcast Byte Count",210	"TX Multicast Byte Count",211	"TX Unicast Frames",212	"TX Broadcast Frames",213	"TX Multicast Frames",214	"TX Pause Frames",215	"TX 64 Byte Frames",216	"TX 65 - 127 Byte Frames",217	"TX 128 - 255 Byte Frames",218	"TX 256 - 511 Bytes Frames",219	"TX 512 - 1023 Byte Frames",220	"TX 1024 - 1518 Byte Frames",221	"TX Greater 1518 Byte Frames",222	"EEE TX LPI Transitions",223	"EEE TX LPI Time",224};225 226struct lan78xx_statstage {227	u32 rx_fcs_errors;228	u32 rx_alignment_errors;229	u32 rx_fragment_errors;230	u32 rx_jabber_errors;231	u32 rx_undersize_frame_errors;232	u32 rx_oversize_frame_errors;233	u32 rx_dropped_frames;234	u32 rx_unicast_byte_count;235	u32 rx_broadcast_byte_count;236	u32 rx_multicast_byte_count;237	u32 rx_unicast_frames;238	u32 rx_broadcast_frames;239	u32 rx_multicast_frames;240	u32 rx_pause_frames;241	u32 rx_64_byte_frames;242	u32 rx_65_127_byte_frames;243	u32 rx_128_255_byte_frames;244	u32 rx_256_511_bytes_frames;245	u32 rx_512_1023_byte_frames;246	u32 rx_1024_1518_byte_frames;247	u32 rx_greater_1518_byte_frames;248	u32 eee_rx_lpi_transitions;249	u32 eee_rx_lpi_time;250	u32 tx_fcs_errors;251	u32 tx_excess_deferral_errors;252	u32 tx_carrier_errors;253	u32 tx_bad_byte_count;254	u32 tx_single_collisions;255	u32 tx_multiple_collisions;256	u32 tx_excessive_collision;257	u32 tx_late_collisions;258	u32 tx_unicast_byte_count;259	u32 tx_broadcast_byte_count;260	u32 tx_multicast_byte_count;261	u32 tx_unicast_frames;262	u32 tx_broadcast_frames;263	u32 tx_multicast_frames;264	u32 tx_pause_frames;265	u32 tx_64_byte_frames;266	u32 tx_65_127_byte_frames;267	u32 tx_128_255_byte_frames;268	u32 tx_256_511_bytes_frames;269	u32 tx_512_1023_byte_frames;270	u32 tx_1024_1518_byte_frames;271	u32 tx_greater_1518_byte_frames;272	u32 eee_tx_lpi_transitions;273	u32 eee_tx_lpi_time;274};275 276struct lan78xx_statstage64 {277	u64 rx_fcs_errors;278	u64 rx_alignment_errors;279	u64 rx_fragment_errors;280	u64 rx_jabber_errors;281	u64 rx_undersize_frame_errors;282	u64 rx_oversize_frame_errors;283	u64 rx_dropped_frames;284	u64 rx_unicast_byte_count;285	u64 rx_broadcast_byte_count;286	u64 rx_multicast_byte_count;287	u64 rx_unicast_frames;288	u64 rx_broadcast_frames;289	u64 rx_multicast_frames;290	u64 rx_pause_frames;291	u64 rx_64_byte_frames;292	u64 rx_65_127_byte_frames;293	u64 rx_128_255_byte_frames;294	u64 rx_256_511_bytes_frames;295	u64 rx_512_1023_byte_frames;296	u64 rx_1024_1518_byte_frames;297	u64 rx_greater_1518_byte_frames;298	u64 eee_rx_lpi_transitions;299	u64 eee_rx_lpi_time;300	u64 tx_fcs_errors;301	u64 tx_excess_deferral_errors;302	u64 tx_carrier_errors;303	u64 tx_bad_byte_count;304	u64 tx_single_collisions;305	u64 tx_multiple_collisions;306	u64 tx_excessive_collision;307	u64 tx_late_collisions;308	u64 tx_unicast_byte_count;309	u64 tx_broadcast_byte_count;310	u64 tx_multicast_byte_count;311	u64 tx_unicast_frames;312	u64 tx_broadcast_frames;313	u64 tx_multicast_frames;314	u64 tx_pause_frames;315	u64 tx_64_byte_frames;316	u64 tx_65_127_byte_frames;317	u64 tx_128_255_byte_frames;318	u64 tx_256_511_bytes_frames;319	u64 tx_512_1023_byte_frames;320	u64 tx_1024_1518_byte_frames;321	u64 tx_greater_1518_byte_frames;322	u64 eee_tx_lpi_transitions;323	u64 eee_tx_lpi_time;324};325 326static u32 lan78xx_regs[] = {327	ID_REV,328	INT_STS,329	HW_CFG,330	PMT_CTL,331	E2P_CMD,332	E2P_DATA,333	USB_STATUS,334	VLAN_TYPE,335	MAC_CR,336	MAC_RX,337	MAC_TX,338	FLOW,339	ERR_STS,340	MII_ACC,341	MII_DATA,342	EEE_TX_LPI_REQ_DLY,343	EEE_TW_TX_SYS,344	EEE_TX_LPI_REM_DLY,345	WUCSR346};347 348#define PHY_REG_SIZE (32 * sizeof(u32))349 350struct lan78xx_net;351 352struct lan78xx_priv {353	struct lan78xx_net *dev;354	u32 rfe_ctl;355	u32 mchash_table[DP_SEL_VHF_HASH_LEN]; /* multicast hash table */356	u32 pfilter_table[NUM_OF_MAF][2]; /* perfect filter table */357	u32 vlan_table[DP_SEL_VHF_VLAN_LEN];358	struct mutex dataport_mutex; /* for dataport access */359	spinlock_t rfe_ctl_lock; /* for rfe register access */360	struct work_struct set_multicast;361	struct work_struct set_vlan;362	u32 wol;363};364 365enum skb_state {366	illegal = 0,367	tx_start,368	tx_done,369	rx_start,370	rx_done,371	rx_cleanup,372	unlink_start373};374 375struct skb_data {		/* skb->cb is one of these */376	struct urb *urb;377	struct lan78xx_net *dev;378	enum skb_state state;379	size_t length;380	int num_of_packet;381};382 383#define EVENT_TX_HALT			0384#define EVENT_RX_HALT			1385#define EVENT_RX_MEMORY			2386#define EVENT_STS_SPLIT			3387#define EVENT_LINK_RESET		4388#define EVENT_RX_PAUSED			5389#define EVENT_DEV_WAKING		6390#define EVENT_DEV_ASLEEP		7391#define EVENT_DEV_OPEN			8392#define EVENT_STAT_UPDATE		9393#define EVENT_DEV_DISCONNECT		10394 395struct statstage {396	struct mutex			access_lock;	/* for stats access */397	struct lan78xx_statstage	saved;398	struct lan78xx_statstage	rollover_count;399	struct lan78xx_statstage	rollover_max;400	struct lan78xx_statstage64	curr_stat;401};402 403struct irq_domain_data {404	struct irq_domain	*irqdomain;405	unsigned int		phyirq;406	struct irq_chip		*irqchip;407	irq_flow_handler_t	irq_handler;408	u32			irqenable;409	struct mutex		irq_lock;		/* for irq bus access */410};411 412struct lan78xx_net {413	struct net_device	*net;414	struct usb_device	*udev;415	struct usb_interface	*intf;416	void			*driver_priv;417 418	unsigned int		tx_pend_data_len;419	size_t			n_tx_urbs;420	size_t			n_rx_urbs;421	size_t			tx_urb_size;422	size_t			rx_urb_size;423 424	struct sk_buff_head	rxq_free;425	struct sk_buff_head	rxq;426	struct sk_buff_head	rxq_done;427	struct sk_buff_head	rxq_overflow;428	struct sk_buff_head	txq_free;429	struct sk_buff_head	txq;430	struct sk_buff_head	txq_pend;431 432	struct napi_struct	napi;433 434	struct delayed_work	wq;435 436	int			msg_enable;437 438	struct urb		*urb_intr;439	struct usb_anchor	deferred;440 441	struct mutex		dev_mutex; /* serialise open/stop wrt suspend/resume */442	struct mutex		phy_mutex; /* for phy access */443	unsigned int		pipe_in, pipe_out, pipe_intr;444 445	unsigned int		bulk_in_delay;446	unsigned int		burst_cap;447 448	unsigned long		flags;449 450	wait_queue_head_t	*wait;451	unsigned char		suspend_count;452 453	unsigned int		maxpacket;454	struct timer_list	stat_monitor;455 456	unsigned long		data[5];457 458	int			link_on;459	u8			mdix_ctrl;460 461	u32			chipid;462	u32			chiprev;463	struct mii_bus		*mdiobus;464	phy_interface_t		interface;465 466	int			fc_autoneg;467	u8			fc_request_control;468 469	int			delta;470	struct statstage	stats;471 472	struct irq_domain_data	domain_data;473};474 475/* define external phy id */476#define	PHY_LAN8835			(0x0007C130)477#define	PHY_KSZ9031RNX			(0x00221620)478 479/* use ethtool to change the level for any given device */480static int msg_level = -1;481module_param(msg_level, int, 0);482MODULE_PARM_DESC(msg_level, "Override default message level");483 484static struct sk_buff *lan78xx_get_buf(struct sk_buff_head *buf_pool)485{486	if (skb_queue_empty(buf_pool))487		return NULL;488 489	return skb_dequeue(buf_pool);490}491 492static void lan78xx_release_buf(struct sk_buff_head *buf_pool,493				struct sk_buff *buf)494{495	buf->data = buf->head;496	skb_reset_tail_pointer(buf);497 498	buf->len = 0;499	buf->data_len = 0;500 501	skb_queue_tail(buf_pool, buf);502}503 504static void lan78xx_free_buf_pool(struct sk_buff_head *buf_pool)505{506	struct skb_data *entry;507	struct sk_buff *buf;508 509	while (!skb_queue_empty(buf_pool)) {510		buf = skb_dequeue(buf_pool);511		if (buf) {512			entry = (struct skb_data *)buf->cb;513			usb_free_urb(entry->urb);514			dev_kfree_skb_any(buf);515		}516	}517}518 519static int lan78xx_alloc_buf_pool(struct sk_buff_head *buf_pool,520				  size_t n_urbs, size_t urb_size,521				  struct lan78xx_net *dev)522{523	struct skb_data *entry;524	struct sk_buff *buf;525	struct urb *urb;526	int i;527 528	skb_queue_head_init(buf_pool);529 530	for (i = 0; i < n_urbs; i++) {531		buf = alloc_skb(urb_size, GFP_ATOMIC);532		if (!buf)533			goto error;534 535		if (skb_linearize(buf) != 0) {536			dev_kfree_skb_any(buf);537			goto error;538		}539 540		urb = usb_alloc_urb(0, GFP_ATOMIC);541		if (!urb) {542			dev_kfree_skb_any(buf);543			goto error;544		}545 546		entry = (struct skb_data *)buf->cb;547		entry->urb = urb;548		entry->dev = dev;549		entry->length = 0;550		entry->num_of_packet = 0;551 552		skb_queue_tail(buf_pool, buf);553	}554 555	return 0;556 557error:558	lan78xx_free_buf_pool(buf_pool);559 560	return -ENOMEM;561}562 563static struct sk_buff *lan78xx_get_rx_buf(struct lan78xx_net *dev)564{565	return lan78xx_get_buf(&dev->rxq_free);566}567 568static void lan78xx_release_rx_buf(struct lan78xx_net *dev,569				   struct sk_buff *rx_buf)570{571	lan78xx_release_buf(&dev->rxq_free, rx_buf);572}573 574static void lan78xx_free_rx_resources(struct lan78xx_net *dev)575{576	lan78xx_free_buf_pool(&dev->rxq_free);577}578 579static int lan78xx_alloc_rx_resources(struct lan78xx_net *dev)580{581	return lan78xx_alloc_buf_pool(&dev->rxq_free,582				      dev->n_rx_urbs, dev->rx_urb_size, dev);583}584 585static struct sk_buff *lan78xx_get_tx_buf(struct lan78xx_net *dev)586{587	return lan78xx_get_buf(&dev->txq_free);588}589 590static void lan78xx_release_tx_buf(struct lan78xx_net *dev,591				   struct sk_buff *tx_buf)592{593	lan78xx_release_buf(&dev->txq_free, tx_buf);594}595 596static void lan78xx_free_tx_resources(struct lan78xx_net *dev)597{598	lan78xx_free_buf_pool(&dev->txq_free);599}600 601static int lan78xx_alloc_tx_resources(struct lan78xx_net *dev)602{603	return lan78xx_alloc_buf_pool(&dev->txq_free,604				      dev->n_tx_urbs, dev->tx_urb_size, dev);605}606 607static int lan78xx_read_reg(struct lan78xx_net *dev, u32 index, u32 *data)608{609	u32 *buf;610	int ret;611 612	if (test_bit(EVENT_DEV_DISCONNECT, &dev->flags))613		return -ENODEV;614 615	buf = kmalloc(sizeof(u32), GFP_KERNEL);616	if (!buf)617		return -ENOMEM;618 619	ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),620			      USB_VENDOR_REQUEST_READ_REGISTER,621			      USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,622			      0, index, buf, 4, USB_CTRL_GET_TIMEOUT);623	if (likely(ret >= 0)) {624		le32_to_cpus(buf);625		*data = *buf;626	} else if (net_ratelimit()) {627		netdev_warn(dev->net,628			    "Failed to read register index 0x%08x. ret = %d",629			    index, ret);630	}631 632	kfree(buf);633 634	return ret;635}636 637static int lan78xx_write_reg(struct lan78xx_net *dev, u32 index, u32 data)638{639	u32 *buf;640	int ret;641 642	if (test_bit(EVENT_DEV_DISCONNECT, &dev->flags))643		return -ENODEV;644 645	buf = kmalloc(sizeof(u32), GFP_KERNEL);646	if (!buf)647		return -ENOMEM;648 649	*buf = data;650	cpu_to_le32s(buf);651 652	ret = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),653			      USB_VENDOR_REQUEST_WRITE_REGISTER,654			      USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,655			      0, index, buf, 4, USB_CTRL_SET_TIMEOUT);656	if (unlikely(ret < 0) &&657	    net_ratelimit()) {658		netdev_warn(dev->net,659			    "Failed to write register index 0x%08x. ret = %d",660			    index, ret);661	}662 663	kfree(buf);664 665	return ret;666}667 668static int lan78xx_update_reg(struct lan78xx_net *dev, u32 reg, u32 mask,669			      u32 data)670{671	int ret;672	u32 buf;673 674	ret = lan78xx_read_reg(dev, reg, &buf);675	if (ret < 0)676		return ret;677 678	buf &= ~mask;679	buf |= (mask & data);680 681	ret = lan78xx_write_reg(dev, reg, buf);682	if (ret < 0)683		return ret;684 685	return 0;686}687 688static int lan78xx_read_stats(struct lan78xx_net *dev,689			      struct lan78xx_statstage *data)690{691	int ret = 0;692	int i;693	struct lan78xx_statstage *stats;694	u32 *src;695	u32 *dst;696 697	stats = kmalloc(sizeof(*stats), GFP_KERNEL);698	if (!stats)699		return -ENOMEM;700 701	ret = usb_control_msg(dev->udev,702			      usb_rcvctrlpipe(dev->udev, 0),703			      USB_VENDOR_REQUEST_GET_STATS,704			      USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,705			      0,706			      0,707			      (void *)stats,708			      sizeof(*stats),709			      USB_CTRL_SET_TIMEOUT);710	if (likely(ret >= 0)) {711		src = (u32 *)stats;712		dst = (u32 *)data;713		for (i = 0; i < sizeof(*stats) / sizeof(u32); i++) {714			le32_to_cpus(&src[i]);715			dst[i] = src[i];716		}717	} else {718		netdev_warn(dev->net,719			    "Failed to read stat ret = %d", ret);720	}721 722	kfree(stats);723 724	return ret;725}726 727#define check_counter_rollover(struct1, dev_stats, member)		\728	do {								\729		if ((struct1)->member < (dev_stats).saved.member)	\730			(dev_stats).rollover_count.member++;		\731	} while (0)732 733static void lan78xx_check_stat_rollover(struct lan78xx_net *dev,734					struct lan78xx_statstage *stats)735{736	check_counter_rollover(stats, dev->stats, rx_fcs_errors);737	check_counter_rollover(stats, dev->stats, rx_alignment_errors);738	check_counter_rollover(stats, dev->stats, rx_fragment_errors);739	check_counter_rollover(stats, dev->stats, rx_jabber_errors);740	check_counter_rollover(stats, dev->stats, rx_undersize_frame_errors);741	check_counter_rollover(stats, dev->stats, rx_oversize_frame_errors);742	check_counter_rollover(stats, dev->stats, rx_dropped_frames);743	check_counter_rollover(stats, dev->stats, rx_unicast_byte_count);744	check_counter_rollover(stats, dev->stats, rx_broadcast_byte_count);745	check_counter_rollover(stats, dev->stats, rx_multicast_byte_count);746	check_counter_rollover(stats, dev->stats, rx_unicast_frames);747	check_counter_rollover(stats, dev->stats, rx_broadcast_frames);748	check_counter_rollover(stats, dev->stats, rx_multicast_frames);749	check_counter_rollover(stats, dev->stats, rx_pause_frames);750	check_counter_rollover(stats, dev->stats, rx_64_byte_frames);751	check_counter_rollover(stats, dev->stats, rx_65_127_byte_frames);752	check_counter_rollover(stats, dev->stats, rx_128_255_byte_frames);753	check_counter_rollover(stats, dev->stats, rx_256_511_bytes_frames);754	check_counter_rollover(stats, dev->stats, rx_512_1023_byte_frames);755	check_counter_rollover(stats, dev->stats, rx_1024_1518_byte_frames);756	check_counter_rollover(stats, dev->stats, rx_greater_1518_byte_frames);757	check_counter_rollover(stats, dev->stats, eee_rx_lpi_transitions);758	check_counter_rollover(stats, dev->stats, eee_rx_lpi_time);759	check_counter_rollover(stats, dev->stats, tx_fcs_errors);760	check_counter_rollover(stats, dev->stats, tx_excess_deferral_errors);761	check_counter_rollover(stats, dev->stats, tx_carrier_errors);762	check_counter_rollover(stats, dev->stats, tx_bad_byte_count);763	check_counter_rollover(stats, dev->stats, tx_single_collisions);764	check_counter_rollover(stats, dev->stats, tx_multiple_collisions);765	check_counter_rollover(stats, dev->stats, tx_excessive_collision);766	check_counter_rollover(stats, dev->stats, tx_late_collisions);767	check_counter_rollover(stats, dev->stats, tx_unicast_byte_count);768	check_counter_rollover(stats, dev->stats, tx_broadcast_byte_count);769	check_counter_rollover(stats, dev->stats, tx_multicast_byte_count);770	check_counter_rollover(stats, dev->stats, tx_unicast_frames);771	check_counter_rollover(stats, dev->stats, tx_broadcast_frames);772	check_counter_rollover(stats, dev->stats, tx_multicast_frames);773	check_counter_rollover(stats, dev->stats, tx_pause_frames);774	check_counter_rollover(stats, dev->stats, tx_64_byte_frames);775	check_counter_rollover(stats, dev->stats, tx_65_127_byte_frames);776	check_counter_rollover(stats, dev->stats, tx_128_255_byte_frames);777	check_counter_rollover(stats, dev->stats, tx_256_511_bytes_frames);778	check_counter_rollover(stats, dev->stats, tx_512_1023_byte_frames);779	check_counter_rollover(stats, dev->stats, tx_1024_1518_byte_frames);780	check_counter_rollover(stats, dev->stats, tx_greater_1518_byte_frames);781	check_counter_rollover(stats, dev->stats, eee_tx_lpi_transitions);782	check_counter_rollover(stats, dev->stats, eee_tx_lpi_time);783 784	memcpy(&dev->stats.saved, stats, sizeof(struct lan78xx_statstage));785}786 787static void lan78xx_update_stats(struct lan78xx_net *dev)788{789	u32 *p, *count, *max;790	u64 *data;791	int i;792	struct lan78xx_statstage lan78xx_stats;793 794	if (usb_autopm_get_interface(dev->intf) < 0)795		return;796 797	p = (u32 *)&lan78xx_stats;798	count = (u32 *)&dev->stats.rollover_count;799	max = (u32 *)&dev->stats.rollover_max;800	data = (u64 *)&dev->stats.curr_stat;801 802	mutex_lock(&dev->stats.access_lock);803 804	if (lan78xx_read_stats(dev, &lan78xx_stats) > 0)805		lan78xx_check_stat_rollover(dev, &lan78xx_stats);806 807	for (i = 0; i < (sizeof(lan78xx_stats) / (sizeof(u32))); i++)808		data[i] = (u64)p[i] + ((u64)count[i] * ((u64)max[i] + 1));809 810	mutex_unlock(&dev->stats.access_lock);811 812	usb_autopm_put_interface(dev->intf);813}814 815/* Loop until the read is completed with timeout called with phy_mutex held */816static int lan78xx_phy_wait_not_busy(struct lan78xx_net *dev)817{818	unsigned long start_time = jiffies;819	u32 val;820	int ret;821 822	do {823		ret = lan78xx_read_reg(dev, MII_ACC, &val);824		if (unlikely(ret < 0))825			return -EIO;826 827		if (!(val & MII_ACC_MII_BUSY_))828			return 0;829	} while (!time_after(jiffies, start_time + HZ));830 831	return -EIO;832}833 834static inline u32 mii_access(int id, int index, int read)835{836	u32 ret;837 838	ret = ((u32)id << MII_ACC_PHY_ADDR_SHIFT_) & MII_ACC_PHY_ADDR_MASK_;839	ret |= ((u32)index << MII_ACC_MIIRINDA_SHIFT_) & MII_ACC_MIIRINDA_MASK_;840	if (read)841		ret |= MII_ACC_MII_READ_;842	else843		ret |= MII_ACC_MII_WRITE_;844	ret |= MII_ACC_MII_BUSY_;845 846	return ret;847}848 849static int lan78xx_wait_eeprom(struct lan78xx_net *dev)850{851	unsigned long start_time = jiffies;852	u32 val;853	int ret;854 855	do {856		ret = lan78xx_read_reg(dev, E2P_CMD, &val);857		if (unlikely(ret < 0))858			return -EIO;859 860		if (!(val & E2P_CMD_EPC_BUSY_) ||861		    (val & E2P_CMD_EPC_TIMEOUT_))862			break;863		usleep_range(40, 100);864	} while (!time_after(jiffies, start_time + HZ));865 866	if (val & (E2P_CMD_EPC_TIMEOUT_ | E2P_CMD_EPC_BUSY_)) {867		netdev_warn(dev->net, "EEPROM read operation timeout");868		return -EIO;869	}870 871	return 0;872}873 874static int lan78xx_eeprom_confirm_not_busy(struct lan78xx_net *dev)875{876	unsigned long start_time = jiffies;877	u32 val;878	int ret;879 880	do {881		ret = lan78xx_read_reg(dev, E2P_CMD, &val);882		if (unlikely(ret < 0))883			return -EIO;884 885		if (!(val & E2P_CMD_EPC_BUSY_))886			return 0;887 888		usleep_range(40, 100);889	} while (!time_after(jiffies, start_time + HZ));890 891	netdev_warn(dev->net, "EEPROM is busy");892	return -EIO;893}894 895static int lan78xx_read_raw_eeprom(struct lan78xx_net *dev, u32 offset,896				   u32 length, u8 *data)897{898	u32 val;899	u32 saved;900	int i, ret;901	int retval;902 903	/* depends on chip, some EEPROM pins are muxed with LED function.904	 * disable & restore LED function to access EEPROM.905	 */906	ret = lan78xx_read_reg(dev, HW_CFG, &val);907	saved = val;908	if (dev->chipid == ID_REV_CHIP_ID_7800_) {909		val &= ~(HW_CFG_LED1_EN_ | HW_CFG_LED0_EN_);910		ret = lan78xx_write_reg(dev, HW_CFG, val);911	}912 913	retval = lan78xx_eeprom_confirm_not_busy(dev);914	if (retval)915		return retval;916 917	for (i = 0; i < length; i++) {918		val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_READ_;919		val |= (offset & E2P_CMD_EPC_ADDR_MASK_);920		ret = lan78xx_write_reg(dev, E2P_CMD, val);921		if (unlikely(ret < 0)) {922			retval = -EIO;923			goto exit;924		}925 926		retval = lan78xx_wait_eeprom(dev);927		if (retval < 0)928			goto exit;929 930		ret = lan78xx_read_reg(dev, E2P_DATA, &val);931		if (unlikely(ret < 0)) {932			retval = -EIO;933			goto exit;934		}935 936		data[i] = val & 0xFF;937		offset++;938	}939 940	retval = 0;941exit:942	if (dev->chipid == ID_REV_CHIP_ID_7800_)943		ret = lan78xx_write_reg(dev, HW_CFG, saved);944 945	return retval;946}947 948static int lan78xx_read_eeprom(struct lan78xx_net *dev, u32 offset,949			       u32 length, u8 *data)950{951	u8 sig;952	int ret;953 954	ret = lan78xx_read_raw_eeprom(dev, 0, 1, &sig);955	if ((ret == 0) && (sig == EEPROM_INDICATOR))956		ret = lan78xx_read_raw_eeprom(dev, offset, length, data);957	else958		ret = -EINVAL;959 960	return ret;961}962 963static int lan78xx_write_raw_eeprom(struct lan78xx_net *dev, u32 offset,964				    u32 length, u8 *data)965{966	u32 val;967	u32 saved;968	int i, ret;969	int retval;970 971	/* depends on chip, some EEPROM pins are muxed with LED function.972	 * disable & restore LED function to access EEPROM.973	 */974	ret = lan78xx_read_reg(dev, HW_CFG, &val);975	saved = val;976	if (dev->chipid == ID_REV_CHIP_ID_7800_) {977		val &= ~(HW_CFG_LED1_EN_ | HW_CFG_LED0_EN_);978		ret = lan78xx_write_reg(dev, HW_CFG, val);979	}980 981	retval = lan78xx_eeprom_confirm_not_busy(dev);982	if (retval)983		goto exit;984 985	/* Issue write/erase enable command */986	val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_EWEN_;987	ret = lan78xx_write_reg(dev, E2P_CMD, val);988	if (unlikely(ret < 0)) {989		retval = -EIO;990		goto exit;991	}992 993	retval = lan78xx_wait_eeprom(dev);994	if (retval < 0)995		goto exit;996 997	for (i = 0; i < length; i++) {998		/* Fill data register */999		val = data[i];1000		ret = lan78xx_write_reg(dev, E2P_DATA, val);1001		if (ret < 0) {1002			retval = -EIO;1003			goto exit;1004		}1005 1006		/* Send "write" command */1007		val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_WRITE_;1008		val |= (offset & E2P_CMD_EPC_ADDR_MASK_);1009		ret = lan78xx_write_reg(dev, E2P_CMD, val);1010		if (ret < 0) {1011			retval = -EIO;1012			goto exit;1013		}1014 1015		retval = lan78xx_wait_eeprom(dev);1016		if (retval < 0)1017			goto exit;1018 1019		offset++;1020	}1021 1022	retval = 0;1023exit:1024	if (dev->chipid == ID_REV_CHIP_ID_7800_)1025		ret = lan78xx_write_reg(dev, HW_CFG, saved);1026 1027	return retval;1028}1029 1030static int lan78xx_read_raw_otp(struct lan78xx_net *dev, u32 offset,1031				u32 length, u8 *data)1032{1033	int i;1034	u32 buf;1035	unsigned long timeout;1036 1037	lan78xx_read_reg(dev, OTP_PWR_DN, &buf);1038 1039	if (buf & OTP_PWR_DN_PWRDN_N_) {1040		/* clear it and wait to be cleared */1041		lan78xx_write_reg(dev, OTP_PWR_DN, 0);1042 1043		timeout = jiffies + HZ;1044		do {1045			usleep_range(1, 10);1046			lan78xx_read_reg(dev, OTP_PWR_DN, &buf);1047			if (time_after(jiffies, timeout)) {1048				netdev_warn(dev->net,1049					    "timeout on OTP_PWR_DN");1050				return -EIO;1051			}1052		} while (buf & OTP_PWR_DN_PWRDN_N_);1053	}1054 1055	for (i = 0; i < length; i++) {1056		lan78xx_write_reg(dev, OTP_ADDR1,1057				  ((offset + i) >> 8) & OTP_ADDR1_15_11);1058		lan78xx_write_reg(dev, OTP_ADDR2,1059				  ((offset + i) & OTP_ADDR2_10_3));1060 1061		lan78xx_write_reg(dev, OTP_FUNC_CMD, OTP_FUNC_CMD_READ_);1062		lan78xx_write_reg(dev, OTP_CMD_GO, OTP_CMD_GO_GO_);1063 1064		timeout = jiffies + HZ;1065		do {1066			udelay(1);1067			lan78xx_read_reg(dev, OTP_STATUS, &buf);1068			if (time_after(jiffies, timeout)) {1069				netdev_warn(dev->net,1070					    "timeout on OTP_STATUS");1071				return -EIO;1072			}1073		} while (buf & OTP_STATUS_BUSY_);1074 1075		lan78xx_read_reg(dev, OTP_RD_DATA, &buf);1076 1077		data[i] = (u8)(buf & 0xFF);1078	}1079 1080	return 0;1081}1082 1083static int lan78xx_write_raw_otp(struct lan78xx_net *dev, u32 offset,1084				 u32 length, u8 *data)1085{1086	int i;1087	u32 buf;1088	unsigned long timeout;1089 1090	lan78xx_read_reg(dev, OTP_PWR_DN, &buf);1091 1092	if (buf & OTP_PWR_DN_PWRDN_N_) {1093		/* clear it and wait to be cleared */1094		lan78xx_write_reg(dev, OTP_PWR_DN, 0);1095 1096		timeout = jiffies + HZ;1097		do {1098			udelay(1);1099			lan78xx_read_reg(dev, OTP_PWR_DN, &buf);1100			if (time_after(jiffies, timeout)) {1101				netdev_warn(dev->net,1102					    "timeout on OTP_PWR_DN completion");1103				return -EIO;1104			}1105		} while (buf & OTP_PWR_DN_PWRDN_N_);1106	}1107 1108	/* set to BYTE program mode */1109	lan78xx_write_reg(dev, OTP_PRGM_MODE, OTP_PRGM_MODE_BYTE_);1110 1111	for (i = 0; i < length; i++) {1112		lan78xx_write_reg(dev, OTP_ADDR1,1113				  ((offset + i) >> 8) & OTP_ADDR1_15_11);1114		lan78xx_write_reg(dev, OTP_ADDR2,1115				  ((offset + i) & OTP_ADDR2_10_3));1116		lan78xx_write_reg(dev, OTP_PRGM_DATA, data[i]);1117		lan78xx_write_reg(dev, OTP_TST_CMD, OTP_TST_CMD_PRGVRFY_);1118		lan78xx_write_reg(dev, OTP_CMD_GO, OTP_CMD_GO_GO_);1119 1120		timeout = jiffies + HZ;1121		do {1122			udelay(1);1123			lan78xx_read_reg(dev, OTP_STATUS, &buf);1124			if (time_after(jiffies, timeout)) {1125				netdev_warn(dev->net,1126					    "Timeout on OTP_STATUS completion");1127				return -EIO;1128			}1129		} while (buf & OTP_STATUS_BUSY_);1130	}1131 1132	return 0;1133}1134 1135static int lan78xx_read_otp(struct lan78xx_net *dev, u32 offset,1136			    u32 length, u8 *data)1137{1138	u8 sig;1139	int ret;1140 1141	ret = lan78xx_read_raw_otp(dev, 0, 1, &sig);1142 1143	if (ret == 0) {1144		if (sig == OTP_INDICATOR_2)1145			offset += 0x100;1146		else if (sig != OTP_INDICATOR_1)1147			ret = -EINVAL;1148		if (!ret)1149			ret = lan78xx_read_raw_otp(dev, offset, length, data);1150	}1151 1152	return ret;1153}1154 1155static int lan78xx_dataport_wait_not_busy(struct lan78xx_net *dev)1156{1157	int i, ret;1158 1159	for (i = 0; i < 100; i++) {1160		u32 dp_sel;1161 1162		ret = lan78xx_read_reg(dev, DP_SEL, &dp_sel);1163		if (unlikely(ret < 0))1164			return -EIO;1165 1166		if (dp_sel & DP_SEL_DPRDY_)1167			return 0;1168 1169		usleep_range(40, 100);1170	}1171 1172	netdev_warn(dev->net, "%s timed out", __func__);1173 1174	return -EIO;1175}1176 1177static int lan78xx_dataport_write(struct lan78xx_net *dev, u32 ram_select,1178				  u32 addr, u32 length, u32 *buf)1179{1180	struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);1181	u32 dp_sel;1182	int i, ret;1183 1184	if (usb_autopm_get_interface(dev->intf) < 0)1185		return 0;1186 1187	mutex_lock(&pdata->dataport_mutex);1188 1189	ret = lan78xx_dataport_wait_not_busy(dev);1190	if (ret < 0)1191		goto done;1192 1193	ret = lan78xx_read_reg(dev, DP_SEL, &dp_sel);1194 1195	dp_sel &= ~DP_SEL_RSEL_MASK_;1196	dp_sel |= ram_select;1197	ret = lan78xx_write_reg(dev, DP_SEL, dp_sel);1198 1199	for (i = 0; i < length; i++) {1200		ret = lan78xx_write_reg(dev, DP_ADDR, addr + i);1201 1202		ret = lan78xx_write_reg(dev, DP_DATA, buf[i]);1203 1204		ret = lan78xx_write_reg(dev, DP_CMD, DP_CMD_WRITE_);1205 1206		ret = lan78xx_dataport_wait_not_busy(dev);1207		if (ret < 0)1208			goto done;1209	}1210 1211done:1212	mutex_unlock(&pdata->dataport_mutex);1213	usb_autopm_put_interface(dev->intf);1214 1215	return ret;1216}1217 1218static void lan78xx_set_addr_filter(struct lan78xx_priv *pdata,1219				    int index, u8 addr[ETH_ALEN])1220{1221	u32 temp;1222 1223	if ((pdata) && (index > 0) && (index < NUM_OF_MAF)) {1224		temp = addr[3];1225		temp = addr[2] | (temp << 8);1226		temp = addr[1] | (temp << 8);1227		temp = addr[0] | (temp << 8);1228		pdata->pfilter_table[index][1] = temp;1229		temp = addr[5];1230		temp = addr[4] | (temp << 8);1231		temp |= MAF_HI_VALID_ | MAF_HI_TYPE_DST_;1232		pdata->pfilter_table[index][0] = temp;1233	}1234}1235 1236/* returns hash bit number for given MAC address */1237static inline u32 lan78xx_hash(char addr[ETH_ALEN])1238{1239	return (ether_crc(ETH_ALEN, addr) >> 23) & 0x1ff;1240}1241 1242static void lan78xx_deferred_multicast_write(struct work_struct *param)1243{1244	struct lan78xx_priv *pdata =1245			container_of(param, struct lan78xx_priv, set_multicast);1246	struct lan78xx_net *dev = pdata->dev;1247	int i;1248 1249	netif_dbg(dev, drv, dev->net, "deferred multicast write 0x%08x\n",1250		  pdata->rfe_ctl);1251 1252	lan78xx_dataport_write(dev, DP_SEL_RSEL_VLAN_DA_, DP_SEL_VHF_VLAN_LEN,1253			       DP_SEL_VHF_HASH_LEN, pdata->mchash_table);1254 1255	for (i = 1; i < NUM_OF_MAF; i++) {1256		lan78xx_write_reg(dev, MAF_HI(i), 0);1257		lan78xx_write_reg(dev, MAF_LO(i),1258				  pdata->pfilter_table[i][1]);1259		lan78xx_write_reg(dev, MAF_HI(i),1260				  pdata->pfilter_table[i][0]);1261	}1262 1263	lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);1264}1265 1266static void lan78xx_set_multicast(struct net_device *netdev)1267{1268	struct lan78xx_net *dev = netdev_priv(netdev);1269	struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);1270	unsigned long flags;1271	int i;1272 1273	spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);1274 1275	pdata->rfe_ctl &= ~(RFE_CTL_UCAST_EN_ | RFE_CTL_MCAST_EN_ |1276			    RFE_CTL_DA_PERFECT_ | RFE_CTL_MCAST_HASH_);1277 1278	for (i = 0; i < DP_SEL_VHF_HASH_LEN; i++)1279		pdata->mchash_table[i] = 0;1280 1281	/* pfilter_table[0] has own HW address */1282	for (i = 1; i < NUM_OF_MAF; i++) {1283		pdata->pfilter_table[i][0] = 0;1284		pdata->pfilter_table[i][1] = 0;1285	}1286 1287	pdata->rfe_ctl |= RFE_CTL_BCAST_EN_;1288 1289	if (dev->net->flags & IFF_PROMISC) {1290		netif_dbg(dev, drv, dev->net, "promiscuous mode enabled");1291		pdata->rfe_ctl |= RFE_CTL_MCAST_EN_ | RFE_CTL_UCAST_EN_;1292	} else {1293		if (dev->net->flags & IFF_ALLMULTI) {1294			netif_dbg(dev, drv, dev->net,1295				  "receive all multicast enabled");1296			pdata->rfe_ctl |= RFE_CTL_MCAST_EN_;1297		}1298	}1299 1300	if (netdev_mc_count(dev->net)) {1301		struct netdev_hw_addr *ha;1302		int i;1303 1304		netif_dbg(dev, drv, dev->net, "receive multicast hash filter");1305 1306		pdata->rfe_ctl |= RFE_CTL_DA_PERFECT_;1307 1308		i = 1;1309		netdev_for_each_mc_addr(ha, netdev) {1310			/* set first 32 into Perfect Filter */1311			if (i < 33) {1312				lan78xx_set_addr_filter(pdata, i, ha->addr);1313			} else {1314				u32 bitnum = lan78xx_hash(ha->addr);1315 1316				pdata->mchash_table[bitnum / 32] |=1317							(1 << (bitnum % 32));1318				pdata->rfe_ctl |= RFE_CTL_MCAST_HASH_;1319			}1320			i++;1321		}1322	}1323 1324	spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags);1325 1326	/* defer register writes to a sleepable context */1327	schedule_work(&pdata->set_multicast);1328}1329 1330static int lan78xx_update_flowcontrol(struct lan78xx_net *dev, u8 duplex,1331				      u16 lcladv, u16 rmtadv)1332{1333	u32 flow = 0, fct_flow = 0;1334	u8 cap;1335 1336	if (dev->fc_autoneg)1337		cap = mii_resolve_flowctrl_fdx(lcladv, rmtadv);1338	else1339		cap = dev->fc_request_control;1340 1341	if (cap & FLOW_CTRL_TX)1342		flow |= (FLOW_CR_TX_FCEN_ | 0xFFFF);1343 1344	if (cap & FLOW_CTRL_RX)1345		flow |= FLOW_CR_RX_FCEN_;1346 1347	if (dev->udev->speed == USB_SPEED_SUPER)1348		fct_flow = FLOW_CTRL_THRESHOLD(FLOW_ON_SS, FLOW_OFF_SS);1349	else if (dev->udev->speed == USB_SPEED_HIGH)1350		fct_flow = FLOW_CTRL_THRESHOLD(FLOW_ON_HS, FLOW_OFF_HS);1351 1352	netif_dbg(dev, link, dev->net, "rx pause %s, tx pause %s",1353		  (cap & FLOW_CTRL_RX ? "enabled" : "disabled"),1354		  (cap & FLOW_CTRL_TX ? "enabled" : "disabled"));1355 1356	lan78xx_write_reg(dev, FCT_FLOW, fct_flow);1357 1358	/* threshold value should be set before enabling flow */1359	lan78xx_write_reg(dev, FLOW, flow);1360 1361	return 0;1362}1363 1364static void lan78xx_rx_urb_submit_all(struct lan78xx_net *dev);1365 1366static int lan78xx_mac_reset(struct lan78xx_net *dev)1367{1368	unsigned long start_time = jiffies;1369	u32 val;1370	int ret;1371 1372	mutex_lock(&dev->phy_mutex);1373 1374	/* Resetting the device while there is activity on the MDIO1375	 * bus can result in the MAC interface locking up and not1376	 * completing register access transactions.1377	 */1378	ret = lan78xx_phy_wait_not_busy(dev);1379	if (ret < 0)1380		goto done;1381 1382	ret = lan78xx_read_reg(dev, MAC_CR, &val);1383	if (ret < 0)1384		goto done;1385 1386	val |= MAC_CR_RST_;1387	ret = lan78xx_write_reg(dev, MAC_CR, val);1388	if (ret < 0)1389		goto done;1390 1391	/* Wait for the reset to complete before allowing any further1392	 * MAC register accesses otherwise the MAC may lock up.1393	 */1394	do {1395		ret = lan78xx_read_reg(dev, MAC_CR, &val);1396		if (ret < 0)1397			goto done;1398 1399		if (!(val & MAC_CR_RST_)) {1400			ret = 0;1401			goto done;1402		}1403	} while (!time_after(jiffies, start_time + HZ));1404 1405	ret = -ETIMEDOUT;1406done:1407	mutex_unlock(&dev->phy_mutex);1408 1409	return ret;1410}1411 1412static int lan78xx_link_reset(struct lan78xx_net *dev)1413{1414	struct phy_device *phydev = dev->net->phydev;1415	struct ethtool_link_ksettings ecmd;1416	int ladv, radv, ret, link;1417	u32 buf;1418 1419	/* clear LAN78xx interrupt status */1420	ret = lan78xx_write_reg(dev, INT_STS, INT_STS_PHY_INT_);1421	if (unlikely(ret < 0))1422		return ret;1423 1424	mutex_lock(&phydev->lock);1425	phy_read_status(phydev);1426	link = phydev->link;1427	mutex_unlock(&phydev->lock);1428 1429	if (!link && dev->link_on) {1430		dev->link_on = false;1431 1432		/* reset MAC */1433		ret = lan78xx_mac_reset(dev);1434		if (ret < 0)1435			return ret;1436 1437		del_timer(&dev->stat_monitor);1438	} else if (link && !dev->link_on) {1439		dev->link_on = true;1440 1441		phy_ethtool_ksettings_get(phydev, &ecmd);1442 1443		if (dev->udev->speed == USB_SPEED_SUPER) {1444			if (ecmd.base.speed == 1000) {1445				/* disable U2 */1446				ret = lan78xx_read_reg(dev, USB_CFG1, &buf);1447				if (ret < 0)1448					return ret;1449				buf &= ~USB_CFG1_DEV_U2_INIT_EN_;1450				ret = lan78xx_write_reg(dev, USB_CFG1, buf);1451				if (ret < 0)1452					return ret;1453				/* enable U1 */1454				ret = lan78xx_read_reg(dev, USB_CFG1, &buf);1455				if (ret < 0)1456					return ret;1457				buf |= USB_CFG1_DEV_U1_INIT_EN_;1458				ret = lan78xx_write_reg(dev, USB_CFG1, buf);1459				if (ret < 0)1460					return ret;1461			} else {1462				/* enable U1 & U2 */1463				ret = lan78xx_read_reg(dev, USB_CFG1, &buf);1464				if (ret < 0)1465					return ret;1466				buf |= USB_CFG1_DEV_U2_INIT_EN_;1467				buf |= USB_CFG1_DEV_U1_INIT_EN_;1468				ret = lan78xx_write_reg(dev, USB_CFG1, buf);1469				if (ret < 0)1470					return ret;1471			}1472		}1473 1474		ladv = phy_read(phydev, MII_ADVERTISE);1475		if (ladv < 0)1476			return ladv;1477 1478		radv = phy_read(phydev, MII_LPA);1479		if (radv < 0)1480			return radv;1481 1482		netif_dbg(dev, link, dev->net,1483			  "speed: %u duplex: %d anadv: 0x%04x anlpa: 0x%04x",1484			  ecmd.base.speed, ecmd.base.duplex, ladv, radv);1485 1486		ret = lan78xx_update_flowcontrol(dev, ecmd.base.duplex, ladv,1487						 radv);1488		if (ret < 0)1489			return ret;1490 1491		if (!timer_pending(&dev->stat_monitor)) {1492			dev->delta = 1;1493			mod_timer(&dev->stat_monitor,1494				  jiffies + STAT_UPDATE_TIMER);1495		}1496 1497		lan78xx_rx_urb_submit_all(dev);1498 1499		local_bh_disable();1500		napi_schedule(&dev->napi);1501		local_bh_enable();1502	}1503 1504	return 0;1505}1506 1507/* some work can't be done in tasklets, so we use keventd1508 *1509 * NOTE:  annoying asymmetry:  if it's active, schedule_work() fails,1510 * but tasklet_schedule() doesn't.	hope the failure is rare.1511 */1512static void lan78xx_defer_kevent(struct lan78xx_net *dev, int work)1513{1514	set_bit(work, &dev->flags);1515	if (!schedule_delayed_work(&dev->wq, 0))1516		netdev_err(dev->net, "kevent %d may have been dropped\n", work);1517}1518 1519static void lan78xx_status(struct lan78xx_net *dev, struct urb *urb)1520{1521	u32 intdata;1522 1523	if (urb->actual_length != 4) {1524		netdev_warn(dev->net,1525			    "unexpected urb length %d", urb->actual_length);1526		return;1527	}1528 1529	intdata = get_unaligned_le32(urb->transfer_buffer);1530 1531	if (intdata & INT_ENP_PHY_INT) {1532		netif_dbg(dev, link, dev->net, "PHY INTR: 0x%08x\n", intdata);1533		lan78xx_defer_kevent(dev, EVENT_LINK_RESET);1534 1535		if (dev->domain_data.phyirq > 0)1536			generic_handle_irq_safe(dev->domain_data.phyirq);1537	} else {1538		netdev_warn(dev->net,1539			    "unexpected interrupt: 0x%08x\n", intdata);1540	}1541}1542 1543static int lan78xx_ethtool_get_eeprom_len(struct net_device *netdev)1544{1545	return MAX_EEPROM_SIZE;1546}1547 1548static int lan78xx_ethtool_get_eeprom(struct net_device *netdev,1549				      struct ethtool_eeprom *ee, u8 *data)1550{1551	struct lan78xx_net *dev = netdev_priv(netdev);1552	int ret;1553 1554	ret = usb_autopm_get_interface(dev->intf);1555	if (ret)1556		return ret;1557 1558	ee->magic = LAN78XX_EEPROM_MAGIC;1559 1560	ret = lan78xx_read_raw_eeprom(dev, ee->offset, ee->len, data);1561 1562	usb_autopm_put_interface(dev->intf);1563 1564	return ret;1565}1566 1567static int lan78xx_ethtool_set_eeprom(struct net_device *netdev,1568				      struct ethtool_eeprom *ee, u8 *data)1569{1570	struct lan78xx_net *dev = netdev_priv(netdev);1571	int ret;1572 1573	ret = usb_autopm_get_interface(dev->intf);1574	if (ret)1575		return ret;1576 1577	/* Invalid EEPROM_INDICATOR at offset zero will result in a failure1578	 * to load data from EEPROM1579	 */1580	if (ee->magic == LAN78XX_EEPROM_MAGIC)1581		ret = lan78xx_write_raw_eeprom(dev, ee->offset, ee->len, data);1582	else if ((ee->magic == LAN78XX_OTP_MAGIC) &&1583		 (ee->offset == 0) &&1584		 (ee->len == 512) &&1585		 (data[0] == OTP_INDICATOR_1))1586		ret = lan78xx_write_raw_otp(dev, ee->offset, ee->len, data);1587 1588	usb_autopm_put_interface(dev->intf);1589 1590	return ret;1591}1592 1593static void lan78xx_get_strings(struct net_device *netdev, u32 stringset,1594				u8 *data)1595{1596	if (stringset == ETH_SS_STATS)1597		memcpy(data, lan78xx_gstrings, sizeof(lan78xx_gstrings));1598}1599 1600static int lan78xx_get_sset_count(struct net_device *netdev, int sset)1601{1602	if (sset == ETH_SS_STATS)1603		return ARRAY_SIZE(lan78xx_gstrings);1604	else1605		return -EOPNOTSUPP;1606}1607 1608static void lan78xx_get_stats(struct net_device *netdev,1609			      struct ethtool_stats *stats, u64 *data)1610{1611	struct lan78xx_net *dev = netdev_priv(netdev);1612 1613	lan78xx_update_stats(dev);1614 1615	mutex_lock(&dev->stats.access_lock);1616	memcpy(data, &dev->stats.curr_stat, sizeof(dev->stats.curr_stat));1617	mutex_unlock(&dev->stats.access_lock);1618}1619 1620static void lan78xx_get_wol(struct net_device *netdev,1621			    struct ethtool_wolinfo *wol)1622{1623	struct lan78xx_net *dev = netdev_priv(netdev);1624	int ret;1625	u32 buf;1626	struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);1627 1628	if (usb_autopm_get_interface(dev->intf) < 0)1629		return;1630 1631	ret = lan78xx_read_reg(dev, USB_CFG0, &buf);1632	if (unlikely(ret < 0)) {1633		wol->supported = 0;1634		wol->wolopts = 0;1635	} else {1636		if (buf & USB_CFG_RMT_WKP_) {1637			wol->supported = WAKE_ALL;1638			wol->wolopts = pdata->wol;1639		} else {1640			wol->supported = 0;1641			wol->wolopts = 0;1642		}1643	}1644 1645	usb_autopm_put_interface(dev->intf);1646}1647 1648static int lan78xx_set_wol(struct net_device *netdev,1649			   struct ethtool_wolinfo *wol)1650{1651	struct lan78xx_net *dev = netdev_priv(netdev);1652	struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);1653	int ret;1654 1655	ret = usb_autopm_get_interface(dev->intf);1656	if (ret < 0)1657		return ret;1658 1659	if (wol->wolopts & ~WAKE_ALL)1660		return -EINVAL;1661 1662	pdata->wol = wol->wolopts;1663 1664	device_set_wakeup_enable(&dev->udev->dev, (bool)wol->wolopts);1665 1666	phy_ethtool_set_wol(netdev->phydev, wol);1667 1668	usb_autopm_put_interface(dev->intf);1669 1670	return ret;1671}1672 1673static int lan78xx_get_eee(struct net_device *net, struct ethtool_keee *edata)1674{1675	struct lan78xx_net *dev = netdev_priv(net);1676	struct phy_device *phydev = net->phydev;1677	int ret;1678	u32 buf;1679 1680	ret = usb_autopm_get_interface(dev->intf);1681	if (ret < 0)1682		return ret;1683 1684	ret = phy_ethtool_get_eee(phydev, edata);1685	if (ret < 0)1686		goto exit;1687 1688	ret = lan78xx_read_reg(dev, MAC_CR, &buf);1689	if (buf & MAC_CR_EEE_EN_) {1690		/* EEE_TX_LPI_REQ_DLY & tx_lpi_timer are same uSec unit */1691		ret = lan78xx_read_reg(dev, EEE_TX_LPI_REQ_DLY, &buf);1692		edata->tx_lpi_timer = buf;1693	} else {1694		edata->tx_lpi_timer = 0;1695	}1696 1697	ret = 0;1698exit:1699	usb_autopm_put_interface(dev->intf);1700 1701	return ret;1702}1703 1704static int lan78xx_set_eee(struct net_device *net, struct ethtool_keee *edata)1705{1706	struct lan78xx_net *dev = netdev_priv(net);1707	int ret;1708	u32 buf;1709 1710	ret = usb_autopm_get_interface(dev->intf);1711	if (ret < 0)1712		return ret;1713 1714	ret = phy_ethtool_set_eee(net->phydev, edata);1715	if (ret < 0)1716		goto out;1717 1718	buf = (u32)edata->tx_lpi_timer;1719	ret = lan78xx_write_reg(dev, EEE_TX_LPI_REQ_DLY, buf);1720out:1721	usb_autopm_put_interface(dev->intf);1722 1723	return ret;1724}1725 1726static u32 lan78xx_get_link(struct net_device *net)1727{1728	u32 link;1729 1730	mutex_lock(&net->phydev->lock);1731	phy_read_status(net->phydev);1732	link = net->phydev->link;1733	mutex_unlock(&net->phydev->lock);1734 1735	return link;1736}1737 1738static void lan78xx_get_drvinfo(struct net_device *net,1739				struct ethtool_drvinfo *info)1740{1741	struct lan78xx_net *dev = netdev_priv(net);1742 1743	strscpy(info->driver, DRIVER_NAME, sizeof(info->driver));1744	usb_make_path(dev->udev, info->bus_info, sizeof(info->bus_info));1745}1746 1747static u32 lan78xx_get_msglevel(struct net_device *net)1748{1749	struct lan78xx_net *dev = netdev_priv(net);1750 1751	return dev->msg_enable;1752}1753 1754static void lan78xx_set_msglevel(struct net_device *net, u32 level)1755{1756	struct lan78xx_net *dev = netdev_priv(net);1757 1758	dev->msg_enable = level;1759}1760 1761static int lan78xx_get_link_ksettings(struct net_device *net,1762				      struct ethtool_link_ksettings *cmd)1763{1764	struct lan78xx_net *dev = netdev_priv(net);1765	struct phy_device *phydev = net->phydev;1766	int ret;1767 1768	ret = usb_autopm_get_interface(dev->intf);1769	if (ret < 0)1770		return ret;1771 1772	phy_ethtool_ksettings_get(phydev, cmd);1773 1774	usb_autopm_put_interface(dev->intf);1775 1776	return ret;1777}1778 1779static int lan78xx_set_link_ksettings(struct net_device *net,1780				      const struct ethtool_link_ksettings *cmd)1781{1782	struct lan78xx_net *dev = netdev_priv(net);1783	struct phy_device *phydev = net->phydev;1784	int ret = 0;1785	int temp;1786 1787	ret = usb_autopm_get_interface(dev->intf);1788	if (ret < 0)1789		return ret;1790 1791	/* change speed & duplex */1792	ret = phy_ethtool_ksettings_set(phydev, cmd);1793 1794	if (!cmd->base.autoneg) {1795		/* force link down */1796		temp = phy_read(phydev, MII_BMCR);1797		phy_write(phydev, MII_BMCR, temp | BMCR_LOOPBACK);1798		mdelay(1);1799		phy_write(phydev, MII_BMCR, temp);1800	}1801 1802	usb_autopm_put_interface(dev->intf);1803 1804	return ret;1805}1806 1807static void lan78xx_get_pause(struct net_device *net,1808			      struct ethtool_pauseparam *pause)1809{1810	struct lan78xx_net *dev = netdev_priv(net);1811	struct phy_device *phydev = net->phydev;1812	struct ethtool_link_ksettings ecmd;1813 1814	phy_ethtool_ksettings_get(phydev, &ecmd);1815 1816	pause->autoneg = dev->fc_autoneg;1817 1818	if (dev->fc_request_control & FLOW_CTRL_TX)1819		pause->tx_pause = 1;1820 1821	if (dev->fc_request_control & FLOW_CTRL_RX)1822		pause->rx_pause = 1;1823}1824 1825static int lan78xx_set_pause(struct net_device *net,1826			     struct ethtool_pauseparam *pause)1827{1828	struct lan78xx_net *dev = netdev_priv(net);1829	struct phy_device *phydev = net->phydev;1830	struct ethtool_link_ksettings ecmd;1831	int ret;1832 1833	phy_ethtool_ksettings_get(phydev, &ecmd);1834 1835	if (pause->autoneg && !ecmd.base.autoneg) {1836		ret = -EINVAL;1837		goto exit;1838	}1839 1840	dev->fc_request_control = 0;1841	if (pause->rx_pause)1842		dev->fc_request_control |= FLOW_CTRL_RX;1843 1844	if (pause->tx_pause)1845		dev->fc_request_control |= FLOW_CTRL_TX;1846 1847	if (ecmd.base.autoneg) {1848		__ETHTOOL_DECLARE_LINK_MODE_MASK(fc) = { 0, };1849		u32 mii_adv;1850 1851		linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT,1852				   ecmd.link_modes.advertising);1853		linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,1854				   ecmd.link_modes.advertising);1855		mii_adv = (u32)mii_advertise_flowctrl(dev->fc_request_control);1856		mii_adv_to_linkmode_adv_t(fc, mii_adv);1857		linkmode_or(ecmd.link_modes.advertising, fc,1858			    ecmd.link_modes.advertising);1859 1860		phy_ethtool_ksettings_set(phydev, &ecmd);1861	}1862 1863	dev->fc_autoneg = pause->autoneg;1864 1865	ret = 0;1866exit:1867	return ret;1868}1869 1870static int lan78xx_get_regs_len(struct net_device *netdev)1871{1872	if (!netdev->phydev)1873		return (sizeof(lan78xx_regs));1874	else1875		return (sizeof(lan78xx_regs) + PHY_REG_SIZE);1876}1877 1878static void1879lan78xx_get_regs(struct net_device *netdev, struct ethtool_regs *regs,1880		 void *buf)1881{1882	u32 *data = buf;1883	int i, j;1884	struct lan78xx_net *dev = netdev_priv(netdev);1885 1886	/* Read Device/MAC registers */1887	for (i = 0; i < ARRAY_SIZE(lan78xx_regs); i++)1888		lan78xx_read_reg(dev, lan78xx_regs[i], &data[i]);1889 1890	if (!netdev->phydev)1891		return;1892 1893	/* Read PHY registers */1894	for (j = 0; j < 32; i++, j++)1895		data[i] = phy_read(netdev->phydev, j);1896}1897 1898static const struct ethtool_ops lan78xx_ethtool_ops = {1899	.get_link	= lan78xx_get_link,1900	.nway_reset	= phy_ethtool_nway_reset,1901	.get_drvinfo	= lan78xx_get_drvinfo,1902	.get_msglevel	= lan78xx_get_msglevel,1903	.set_msglevel	= lan78xx_set_msglevel,1904	.get_eeprom_len = lan78xx_ethtool_get_eeprom_len,1905	.get_eeprom	= lan78xx_ethtool_get_eeprom,1906	.set_eeprom	= lan78xx_ethtool_set_eeprom,1907	.get_ethtool_stats = lan78xx_get_stats,1908	.get_sset_count = lan78xx_get_sset_count,1909	.get_strings	= lan78xx_get_strings,1910	.get_wol	= lan78xx_get_wol,1911	.set_wol	= lan78xx_set_wol,1912	.get_ts_info	= ethtool_op_get_ts_info,1913	.get_eee	= lan78xx_get_eee,1914	.set_eee	= lan78xx_set_eee,1915	.get_pauseparam	= lan78xx_get_pause,1916	.set_pauseparam	= lan78xx_set_pause,1917	.get_link_ksettings = lan78xx_get_link_ksettings,1918	.set_link_ksettings = lan78xx_set_link_ksettings,1919	.get_regs_len	= lan78xx_get_regs_len,1920	.get_regs	= lan78xx_get_regs,1921};1922 1923static void lan78xx_init_mac_address(struct lan78xx_net *dev)1924{1925	u32 addr_lo, addr_hi;1926	u8 addr[6];1927 1928	lan78xx_read_reg(dev, RX_ADDRL, &addr_lo);1929	lan78xx_read_reg(dev, RX_ADDRH, &addr_hi);1930 1931	addr[0] = addr_lo & 0xFF;1932	addr[1] = (addr_lo >> 8) & 0xFF;1933	addr[2] = (addr_lo >> 16) & 0xFF;1934	addr[3] = (addr_lo >> 24) & 0xFF;1935	addr[4] = addr_hi & 0xFF;1936	addr[5] = (addr_hi >> 8) & 0xFF;1937 1938	if (!is_valid_ether_addr(addr)) {1939		if (!eth_platform_get_mac_address(&dev->udev->dev, addr)) {1940			/* valid address present in Device Tree */1941			netif_dbg(dev, ifup, dev->net,1942				  "MAC address read from Device Tree");1943		} else if (((lan78xx_read_eeprom(dev, EEPROM_MAC_OFFSET,1944						 ETH_ALEN, addr) == 0) ||1945			    (lan78xx_read_otp(dev, EEPROM_MAC_OFFSET,1946					      ETH_ALEN, addr) == 0)) &&1947			   is_valid_ether_addr(addr)) {1948			/* eeprom values are valid so use them */1949			netif_dbg(dev, ifup, dev->net,1950				  "MAC address read from EEPROM");1951		} else {1952			/* generate random MAC */1953			eth_random_addr(addr);1954			netif_dbg(dev, ifup, dev->net,1955				  "MAC address set to random addr");1956		}1957 1958		addr_lo = addr[0] | (addr[1] << 8) |1959			  (addr[2] << 16) | (addr[3] << 24);1960		addr_hi = addr[4] | (addr[5] << 8);1961 1962		lan78xx_write_reg(dev, RX_ADDRL, addr_lo);1963		lan78xx_write_reg(dev, RX_ADDRH, addr_hi);1964	}1965 1966	lan78xx_write_reg(dev, MAF_LO(0), addr_lo);1967	lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_);1968 1969	eth_hw_addr_set(dev->net, addr);1970}1971 1972/* MDIO read and write wrappers for phylib */1973static int lan78xx_mdiobus_read(struct mii_bus *bus, int phy_id, int idx)1974{1975	struct lan78xx_net *dev = bus->priv;1976	u32 val, addr;1977	int ret;1978 1979	ret = usb_autopm_get_interface(dev->intf);1980	if (ret < 0)1981		return ret;1982 1983	mutex_lock(&dev->phy_mutex);1984 1985	/* confirm MII not busy */1986	ret = lan78xx_phy_wait_not_busy(dev);1987	if (ret < 0)1988		goto done;1989 1990	/* set the address, index & direction (read from PHY) */1991	addr = mii_access(phy_id, idx, MII_READ);1992	ret = lan78xx_write_reg(dev, MII_ACC, addr);1993 1994	ret = lan78xx_phy_wait_not_busy(dev);1995	if (ret < 0)1996		goto done;1997 1998	ret = lan78xx_read_reg(dev, MII_DATA, &val);1999 2000	ret = (int)(val & 0xFFFF);2001 2002done:2003	mutex_unlock(&dev->phy_mutex);2004	usb_autopm_put_interface(dev->intf);2005 2006	return ret;2007}2008 2009static int lan78xx_mdiobus_write(struct mii_bus *bus, int phy_id, int idx,2010				 u16 regval)2011{2012	struct lan78xx_net *dev = bus->priv;2013	u32 val, addr;2014	int ret;2015 2016	ret = usb_autopm_get_interface(dev->intf);2017	if (ret < 0)2018		return ret;2019 2020	mutex_lock(&dev->phy_mutex);2021 2022	/* confirm MII not busy */2023	ret = lan78xx_phy_wait_not_busy(dev);2024	if (ret < 0)2025		goto done;2026 2027	val = (u32)regval;2028	ret = lan78xx_write_reg(dev, MII_DATA, val);2029 2030	/* set the address, index & direction (write to PHY) */2031	addr = mii_access(phy_id, idx, MII_WRITE);2032	ret = lan78xx_write_reg(dev, MII_ACC, addr);2033 2034	ret = lan78xx_phy_wait_not_busy(dev);2035	if (ret < 0)2036		goto done;2037 2038done:2039	mutex_unlock(&dev->phy_mutex);2040	usb_autopm_put_interface(dev->intf);2041	return 0;2042}2043 2044static int lan78xx_mdio_init(struct lan78xx_net *dev)2045{2046	struct device_node *node;2047	int ret;2048 2049	dev->mdiobus = mdiobus_alloc();2050	if (!dev->mdiobus) {2051		netdev_err(dev->net, "can't allocate MDIO bus\n");2052		return -ENOMEM;2053	}2054 2055	dev->mdiobus->priv = (void *)dev;2056	dev->mdiobus->read = lan78xx_mdiobus_read;2057	dev->mdiobus->write = lan78xx_mdiobus_write;2058	dev->mdiobus->name = "lan78xx-mdiobus";2059	dev->mdiobus->parent = &dev->udev->dev;2060 2061	snprintf(dev->mdiobus->id, MII_BUS_ID_SIZE, "usb-%03d:%03d",2062		 dev->udev->bus->busnum, dev->udev->devnum);2063 2064	switch (dev->chipid) {2065	case ID_REV_CHIP_ID_7800_:2066	case ID_REV_CHIP_ID_7850_:2067		/* set to internal PHY id */2068		dev->mdiobus->phy_mask = ~(1 << 1);2069		break;2070	case ID_REV_CHIP_ID_7801_:2071		/* scan thru PHYAD[2..0] */2072		dev->mdiobus->phy_mask = ~(0xFF);2073		break;2074	}2075 2076	node = of_get_child_by_name(dev->udev->dev.of_node, "mdio");2077	ret = of_mdiobus_register(dev->mdiobus, node);2078	of_node_put(node);2079	if (ret) {2080		netdev_err(dev->net, "can't register MDIO bus\n");2081		goto exit1;2082	}2083 2084	netdev_dbg(dev->net, "registered mdiobus bus %s\n", dev->mdiobus->id);2085	return 0;2086exit1:2087	mdiobus_free(dev->mdiobus);2088	return ret;2089}2090 2091static void lan78xx_remove_mdio(struct lan78xx_net *dev)2092{2093	mdiobus_unregister(dev->mdiobus);2094	mdiobus_free(dev->mdiobus);2095}2096 2097static void lan78xx_link_status_change(struct net_device *net)2098{2099	struct lan78xx_net *dev = netdev_priv(net);2100	struct phy_device *phydev = net->phydev;2101	u32 data;2102	int ret;2103 2104	ret = lan78xx_read_reg(dev, MAC_CR, &data);2105	if (ret < 0)2106		return;2107 2108	if (phydev->enable_tx_lpi)2109		data |=  MAC_CR_EEE_EN_;2110	else2111		data &= ~MAC_CR_EEE_EN_;2112	lan78xx_write_reg(dev, MAC_CR, data);2113 2114	phy_print_status(phydev);2115}2116 2117static int irq_map(struct irq_domain *d, unsigned int irq,2118		   irq_hw_number_t hwirq)2119{2120	struct irq_domain_data *data = d->host_data;2121 2122	irq_set_chip_data(irq, data);2123	irq_set_chip_and_handler(irq, data->irqchip, data->irq_handler);2124	irq_set_noprobe(irq);2125 2126	return 0;2127}2128 2129static void irq_unmap(struct irq_domain *d, unsigned int irq)2130{2131	irq_set_chip_and_handler(irq, NULL, NULL);2132	irq_set_chip_data(irq, NULL);2133}2134 2135static const struct irq_domain_ops chip_domain_ops = {2136	.map	= irq_map,2137	.unmap	= irq_unmap,2138};2139 2140static void lan78xx_irq_mask(struct irq_data *irqd)2141{2142	struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);2143 2144	data->irqenable &= ~BIT(irqd_to_hwirq(irqd));2145}2146 2147static void lan78xx_irq_unmask(struct irq_data *irqd)2148{2149	struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);2150 2151	data->irqenable |= BIT(irqd_to_hwirq(irqd));2152}2153 2154static void lan78xx_irq_bus_lock(struct irq_data *irqd)2155{2156	struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);2157 2158	mutex_lock(&data->irq_lock);2159}2160 2161static void lan78xx_irq_bus_sync_unlock(struct irq_data *irqd)2162{2163	struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);2164	struct lan78xx_net *dev =2165			container_of(data, struct lan78xx_net, domain_data);2166	u32 buf;2167 2168	/* call register access here because irq_bus_lock & irq_bus_sync_unlock2169	 * are only two callbacks executed in non-atomic contex.2170	 */2171	lan78xx_read_reg(dev, INT_EP_CTL, &buf);2172	if (buf != data->irqenable)2173		lan78xx_write_reg(dev, INT_EP_CTL, data->irqenable);2174 2175	mutex_unlock(&data->irq_lock);2176}2177 2178static struct irq_chip lan78xx_irqchip = {2179	.name			= "lan78xx-irqs",2180	.irq_mask		= lan78xx_irq_mask,2181	.irq_unmask		= lan78xx_irq_unmask,2182	.irq_bus_lock		= lan78xx_irq_bus_lock,2183	.irq_bus_sync_unlock	= lan78xx_irq_bus_sync_unlock,2184};2185 2186static int lan78xx_setup_irq_domain(struct lan78xx_net *dev)2187{2188	struct device_node *of_node;2189	struct irq_domain *irqdomain;2190	unsigned int irqmap = 0;2191	u32 buf;2192	int ret = 0;2193 2194	of_node = dev->udev->dev.parent->of_node;2195 2196	mutex_init(&dev->domain_data.irq_lock);2197 2198	lan78xx_read_reg(dev, INT_EP_CTL, &buf);2199	dev->domain_data.irqenable = buf;2200 2201	dev->domain_data.irqchip = &lan78xx_irqchip;2202	dev->domain_data.irq_handler = handle_simple_irq;2203 2204	irqdomain = irq_domain_add_simple(of_node, MAX_INT_EP, 0,2205					  &chip_domain_ops, &dev->domain_data);2206	if (irqdomain) {2207		/* create mapping for PHY interrupt */2208		irqmap = irq_create_mapping(irqdomain, INT_EP_PHY);2209		if (!irqmap) {2210			irq_domain_remove(irqdomain);2211 2212			irqdomain = NULL;2213			ret = -EINVAL;2214		}2215	} else {2216		ret = -EINVAL;2217	}2218 2219	dev->domain_data.irqdomain = irqdomain;2220	dev->domain_data.phyirq = irqmap;2221 2222	return ret;2223}2224 2225static void lan78xx_remove_irq_domain(struct lan78xx_net *dev)2226{2227	if (dev->domain_data.phyirq > 0) {2228		irq_dispose_mapping(dev->domain_data.phyirq);2229 2230		if (dev->domain_data.irqdomain)2231			irq_domain_remove(dev->domain_data.irqdomain);2232	}2233	dev->domain_data.phyirq = 0;2234	dev->domain_data.irqdomain = NULL;2235}2236 2237static int lan8835_fixup(struct phy_device *phydev)2238{2239	int buf;2240	struct lan78xx_net *dev = netdev_priv(phydev->attached_dev);2241 2242	/* LED2/PME_N/IRQ_N/RGMII_ID pin to IRQ_N mode */2243	buf = phy_read_mmd(phydev, MDIO_MMD_PCS, 0x8010);2244	buf &= ~0x1800;2245	buf |= 0x0800;2246	phy_write_mmd(phydev, MDIO_MMD_PCS, 0x8010, buf);2247 2248	/* RGMII MAC TXC Delay Enable */2249	lan78xx_write_reg(dev, MAC_RGMII_ID,2250			  MAC_RGMII_ID_TXC_DELAY_EN_);2251 2252	/* RGMII TX DLL Tune Adjust */2253	lan78xx_write_reg(dev, RGMII_TX_BYP_DLL, 0x3D00);2254 2255	dev->interface = PHY_INTERFACE_MODE_RGMII_TXID;2256 2257	return 1;2258}2259 2260static int ksz9031rnx_fixup(struct phy_device *phydev)2261{2262	struct lan78xx_net *dev = netdev_priv(phydev->attached_dev);2263 2264	/* Micrel9301RNX PHY configuration */2265	/* RGMII Control Signal Pad Skew */2266	phy_write_mmd(phydev, MDIO_MMD_WIS, 4, 0x0077);2267	/* RGMII RX Data Pad Skew */2268	phy_write_mmd(phydev, MDIO_MMD_WIS, 5, 0x7777);2269	/* RGMII RX Clock Pad Skew */2270	phy_write_mmd(phydev, MDIO_MMD_WIS, 8, 0x1FF);2271 2272	dev->interface = PHY_INTERFACE_MODE_RGMII_RXID;2273 2274	return 1;2275}2276 2277static struct phy_device *lan7801_phy_init(struct lan78xx_net *dev)2278{2279	u32 buf;2280	int ret;2281	struct fixed_phy_status fphy_status = {2282		.link = 1,2283		.speed = SPEED_1000,2284		.duplex = DUPLEX_FULL,2285	};2286	struct phy_device *phydev;2287 2288	phydev = phy_find_first(dev->mdiobus);2289	if (!phydev) {2290		netdev_dbg(dev->net, "PHY Not Found!! Registering Fixed PHY\n");2291		phydev = fixed_phy_register(PHY_POLL, &fphy_status, NULL);2292		if (IS_ERR(phydev)) {2293			netdev_err(dev->net, "No PHY/fixed_PHY found\n");2294			return NULL;2295		}2296		netdev_dbg(dev->net, "Registered FIXED PHY\n");2297		dev->interface = PHY_INTERFACE_MODE_RGMII;2298		ret = lan78xx_write_reg(dev, MAC_RGMII_ID,2299					MAC_RGMII_ID_TXC_DELAY_EN_);2300		ret = lan78xx_write_reg(dev, RGMII_TX_BYP_DLL, 0x3D00);2301		ret = lan78xx_read_reg(dev, HW_CFG, &buf);2302		buf |= HW_CFG_CLK125_EN_;2303		buf |= HW_CFG_REFCLK25_EN_;2304		ret = lan78xx_write_reg(dev, HW_CFG, buf);2305	} else {2306		if (!phydev->drv) {2307			netdev_err(dev->net, "no PHY driver found\n");2308			return NULL;2309		}2310		dev->interface = PHY_INTERFACE_MODE_RGMII;2311		/* external PHY fixup for KSZ9031RNX */2312		ret = phy_register_fixup_for_uid(PHY_KSZ9031RNX, 0xfffffff0,2313						 ksz9031rnx_fixup);2314		if (ret < 0) {2315			netdev_err(dev->net, "Failed to register fixup for PHY_KSZ9031RNX\n");2316			return NULL;2317		}2318		/* external PHY fixup for LAN8835 */2319		ret = phy_register_fixup_for_uid(PHY_LAN8835, 0xfffffff0,2320						 lan8835_fixup);2321		if (ret < 0) {2322			netdev_err(dev->net, "Failed to register fixup for PHY_LAN8835\n");2323			return NULL;2324		}2325		/* add more external PHY fixup here if needed */2326 2327		phydev->is_internal = false;2328	}2329	return phydev;2330}2331 2332static int lan78xx_phy_init(struct lan78xx_net *dev)2333{2334	__ETHTOOL_DECLARE_LINK_MODE_MASK(fc) = { 0, };2335	int ret;2336	u32 mii_adv;2337	struct phy_device *phydev;2338 2339	switch (dev->chipid) {2340	case ID_REV_CHIP_ID_7801_:2341		phydev = lan7801_phy_init(dev);2342		if (!phydev) {2343			netdev_err(dev->net, "lan7801: PHY Init Failed");2344			return -EIO;2345		}2346		break;2347 2348	case ID_REV_CHIP_ID_7800_:2349	case ID_REV_CHIP_ID_7850_:2350		phydev = phy_find_first(dev->mdiobus);2351		if (!phydev) {2352			netdev_err(dev->net, "no PHY found\n");2353			return -EIO;2354		}2355		phydev->is_internal = true;2356		dev->interface = PHY_INTERFACE_MODE_GMII;2357		break;2358 2359	default:2360		netdev_err(dev->net, "Unknown CHIP ID found\n");2361		return -EIO;2362	}2363 2364	/* if phyirq is not set, use polling mode in phylib */2365	if (dev->domain_data.phyirq > 0)2366		phydev->irq = dev->domain_data.phyirq;2367	else2368		phydev->irq = PHY_POLL;2369	netdev_dbg(dev->net, "phydev->irq = %d\n", phydev->irq);2370 2371	/* set to AUTOMDIX */2372	phydev->mdix = ETH_TP_MDI_AUTO;2373 2374	ret = phy_connect_direct(dev->net, phydev,2375				 lan78xx_link_status_change,2376				 dev->interface);2377	if (ret) {2378		netdev_err(dev->net, "can't attach PHY to %s\n",2379			   dev->mdiobus->id);2380		if (dev->chipid == ID_REV_CHIP_ID_7801_) {2381			if (phy_is_pseudo_fixed_link(phydev)) {2382				fixed_phy_unregister(phydev);2383			} else {2384				phy_unregister_fixup_for_uid(PHY_KSZ9031RNX,2385							     0xfffffff0);2386				phy_unregister_fixup_for_uid(PHY_LAN8835,2387							     0xfffffff0);2388			}2389		}2390		return -EIO;2391	}2392 2393	/* MAC doesn't support 1000T Half */2394	phy_remove_link_mode(phydev, ETHTOOL_LINK_MODE_1000baseT_Half_BIT);2395 2396	/* support both flow controls */2397	dev->fc_request_control = (FLOW_CTRL_RX | FLOW_CTRL_TX);2398	linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT,2399			   phydev->advertising);2400	linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,2401			   phydev->advertising);2402	mii_adv = (u32)mii_advertise_flowctrl(dev->fc_request_control);2403	mii_adv_to_linkmode_adv_t(fc, mii_adv);2404	linkmode_or(phydev->advertising, fc, phydev->advertising);2405 2406	phy_support_eee(phydev);2407 2408	if (phydev->mdio.dev.of_node) {2409		u32 reg;2410		int len;2411 2412		len = of_property_count_elems_of_size(phydev->mdio.dev.of_node,2413						      "microchip,led-modes",2414						      sizeof(u32));2415		if (len >= 0) {2416			/* Ensure the appropriate LEDs are enabled */2417			lan78xx_read_reg(dev, HW_CFG, &reg);2418			reg &= ~(HW_CFG_LED0_EN_ |2419				 HW_CFG_LED1_EN_ |2420				 HW_CFG_LED2_EN_ |2421				 HW_CFG_LED3_EN_);2422			reg |= (len > 0) * HW_CFG_LED0_EN_ |2423				(len > 1) * HW_CFG_LED1_EN_ |2424				(len > 2) * HW_CFG_LED2_EN_ |2425				(len > 3) * HW_CFG_LED3_EN_;2426			lan78xx_write_reg(dev, HW_CFG, reg);2427		}2428	}2429 2430	genphy_config_aneg(phydev);2431 2432	dev->fc_autoneg = phydev->autoneg;2433 2434	return 0;2435}2436 2437static int lan78xx_set_rx_max_frame_length(struct lan78xx_net *dev, int size)2438{2439	u32 buf;2440	bool rxenabled;2441 2442	lan78xx_read_reg(dev, MAC_RX, &buf);2443 2444	rxenabled = ((buf & MAC_RX_RXEN_) != 0);2445 2446	if (rxenabled) {2447		buf &= ~MAC_RX_RXEN_;2448		lan78xx_write_reg(dev, MAC_RX, buf);2449	}2450 2451	/* add 4 to size for FCS */2452	buf &= ~MAC_RX_MAX_SIZE_MASK_;2453	buf |= (((size + 4) << MAC_RX_MAX_SIZE_SHIFT_) & MAC_RX_MAX_SIZE_MASK_);2454 2455	lan78xx_write_reg(dev, MAC_RX, buf);2456 2457	if (rxenabled) {2458		buf |= MAC_RX_RXEN_;2459		lan78xx_write_reg(dev, MAC_RX, buf);2460	}2461 2462	return 0;2463}2464 2465static int unlink_urbs(struct lan78xx_net *dev, struct sk_buff_head *q)2466{2467	struct sk_buff *skb;2468	unsigned long flags;2469	int count = 0;2470 2471	spin_lock_irqsave(&q->lock, flags);2472	while (!skb_queue_empty(q)) {2473		struct skb_data	*entry;2474		struct urb *urb;2475		int ret;2476 2477		skb_queue_walk(q, skb) {2478			entry = (struct skb_data *)skb->cb;2479			if (entry->state != unlink_start)2480				goto found;2481		}2482		break;2483found:2484		entry->state = unlink_start;2485		urb = entry->urb;2486 2487		/* Get reference count of the URB to avoid it to be2488		 * freed during usb_unlink_urb, which may trigger2489		 * use-after-free problem inside usb_unlink_urb since2490		 * usb_unlink_urb is always racing with .complete2491		 * handler(include defer_bh).2492		 */2493		usb_get_urb(urb);2494		spin_unlock_irqrestore(&q->lock, flags);2495		/* during some PM-driven resume scenarios,2496		 * these (async) unlinks complete immediately2497		 */2498		ret = usb_unlink_urb(urb);2499		if (ret != -EINPROGRESS && ret != 0)2500			netdev_dbg(dev->net, "unlink urb err, %d\n", ret);2501		else2502			count++;2503		usb_put_urb(urb);2504		spin_lock_irqsave(&q->lock, flags);2505	}2506	spin_unlock_irqrestore(&q->lock, flags);2507	return count;2508}2509 2510static int lan78xx_change_mtu(struct net_device *netdev, int new_mtu)2511{2512	struct lan78xx_net *dev = netdev_priv(netdev);2513	int max_frame_len = RX_MAX_FRAME_LEN(new_mtu);2514	int ret;2515 2516	/* no second zero-length packet read wanted after mtu-sized packets */2517	if ((max_frame_len % dev->maxpacket) == 0)2518		return -EDOM;2519 2520	ret = usb_autopm_get_interface(dev->intf);2521	if (ret < 0)2522		return ret;2523 2524	ret = lan78xx_set_rx_max_frame_length(dev, max_frame_len);2525	if (!ret)2526		WRITE_ONCE(netdev->mtu, new_mtu);2527 2528	usb_autopm_put_interface(dev->intf);2529 2530	return ret;2531}2532 2533static int lan78xx_set_mac_addr(struct net_device *netdev, void *p)2534{2535	struct lan78xx_net *dev = netdev_priv(netdev);2536	struct sockaddr *addr = p;2537	u32 addr_lo, addr_hi;2538 2539	if (netif_running(netdev))2540		return -EBUSY;2541 2542	if (!is_valid_ether_addr(addr->sa_data))2543		return -EADDRNOTAVAIL;2544 2545	eth_hw_addr_set(netdev, addr->sa_data);2546 2547	addr_lo = netdev->dev_addr[0] |2548		  netdev->dev_addr[1] << 8 |2549		  netdev->dev_addr[2] << 16 |2550		  netdev->dev_addr[3] << 24;2551	addr_hi = netdev->dev_addr[4] |2552		  netdev->dev_addr[5] << 8;2553 2554	lan78xx_write_reg(dev, RX_ADDRL, addr_lo);2555	lan78xx_write_reg(dev, RX_ADDRH, addr_hi);2556 2557	/* Added to support MAC address changes */2558	lan78xx_write_reg(dev, MAF_LO(0), addr_lo);2559	lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_);2560 2561	return 0;2562}2563 2564/* Enable or disable Rx checksum offload engine */2565static int lan78xx_set_features(struct net_device *netdev,2566				netdev_features_t features)2567{2568	struct lan78xx_net *dev = netdev_priv(netdev);2569	struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);2570	unsigned long flags;2571 2572	spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);2573 2574	if (features & NETIF_F_RXCSUM) {2575		pdata->rfe_ctl |= RFE_CTL_TCPUDP_COE_ | RFE_CTL_IP_COE_;2576		pdata->rfe_ctl |= RFE_CTL_ICMP_COE_ | RFE_CTL_IGMP_COE_;2577	} else {2578		pdata->rfe_ctl &= ~(RFE_CTL_TCPUDP_COE_ | RFE_CTL_IP_COE_);2579		pdata->rfe_ctl &= ~(RFE_CTL_ICMP_COE_ | RFE_CTL_IGMP_COE_);2580	}2581 2582	if (features & NETIF_F_HW_VLAN_CTAG_RX)2583		pdata->rfe_ctl |= RFE_CTL_VLAN_STRIP_;2584	else2585		pdata->rfe_ctl &= ~RFE_CTL_VLAN_STRIP_;2586 2587	if (features & NETIF_F_HW_VLAN_CTAG_FILTER)2588		pdata->rfe_ctl |= RFE_CTL_VLAN_FILTER_;2589	else2590		pdata->rfe_ctl &= ~RFE_CTL_VLAN_FILTER_;2591 2592	spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags);2593 2594	lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);2595 2596	return 0;2597}2598 2599static void lan78xx_deferred_vlan_write(struct work_struct *param)2600{2601	struct lan78xx_priv *pdata =2602			container_of(param, struct lan78xx_priv, set_vlan);2603	struct lan78xx_net *dev = pdata->dev;2604 2605	lan78xx_dataport_write(dev, DP_SEL_RSEL_VLAN_DA_, 0,2606			       DP_SEL_VHF_VLAN_LEN, pdata->vlan_table);2607}2608 2609static int lan78xx_vlan_rx_add_vid(struct net_device *netdev,2610				   __be16 proto, u16 vid)2611{2612	struct lan78xx_net *dev = netdev_priv(netdev);2613	struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);2614	u16 vid_bit_index;2615	u16 vid_dword_index;2616 2617	vid_dword_index = (vid >> 5) & 0x7F;2618	vid_bit_index = vid & 0x1F;2619 2620	pdata->vlan_table[vid_dword_index] |= (1 << vid_bit_index);2621 2622	/* defer register writes to a sleepable context */2623	schedule_work(&pdata->set_vlan);2624 2625	return 0;2626}2627 2628static int lan78xx_vlan_rx_kill_vid(struct net_device *netdev,2629				    __be16 proto, u16 vid)2630{2631	struct lan78xx_net *dev = netdev_priv(netdev);2632	struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);2633	u16 vid_bit_index;2634	u16 vid_dword_index;2635 2636	vid_dword_index = (vid >> 5) & 0x7F;2637	vid_bit_index = vid & 0x1F;2638 2639	pdata->vlan_table[vid_dword_index] &= ~(1 << vid_bit_index);2640 2641	/* defer register writes to a sleepable context */2642	schedule_work(&pdata->set_vlan);2643 2644	return 0;2645}2646 2647static void lan78xx_init_ltm(struct lan78xx_net *dev)2648{2649	int ret;2650	u32 buf;2651	u32 regs[6] = { 0 };2652 2653	ret = lan78xx_read_reg(dev, USB_CFG1, &buf);2654	if (buf & USB_CFG1_LTM_ENABLE_) {2655		u8 temp[2];2656		/* Get values from EEPROM first */2657		if (lan78xx_read_eeprom(dev, 0x3F, 2, temp) == 0) {2658			if (temp[0] == 24) {2659				ret = lan78xx_read_raw_eeprom(dev,2660							      temp[1] * 2,2661							      24,2662							      (u8 *)regs);2663				if (ret < 0)2664					return;2665			}2666		} else if (lan78xx_read_otp(dev, 0x3F, 2, temp) == 0) {2667			if (temp[0] == 24) {2668				ret = lan78xx_read_raw_otp(dev,2669							   temp[1] * 2,2670							   24,2671							   (u8 *)regs);2672				if (ret < 0)2673					return;2674			}2675		}2676	}2677 2678	lan78xx_write_reg(dev, LTM_BELT_IDLE0, regs[0]);2679	lan78xx_write_reg(dev, LTM_BELT_IDLE1, regs[1]);2680	lan78xx_write_reg(dev, LTM_BELT_ACT0, regs[2]);2681	lan78xx_write_reg(dev, LTM_BELT_ACT1, regs[3]);2682	lan78xx_write_reg(dev, LTM_INACTIVE0, regs[4]);2683	lan78xx_write_reg(dev, LTM_INACTIVE1, regs[5]);2684}2685 2686static int lan78xx_urb_config_init(struct lan78xx_net *dev)2687{2688	int result = 0;2689 2690	switch (dev->udev->speed) {2691	case USB_SPEED_SUPER:2692		dev->rx_urb_size = RX_SS_URB_SIZE;2693		dev->tx_urb_size = TX_SS_URB_SIZE;2694		dev->n_rx_urbs = RX_SS_URB_NUM;2695		dev->n_tx_urbs = TX_SS_URB_NUM;2696		dev->bulk_in_delay = SS_BULK_IN_DELAY;2697		dev->burst_cap = SS_BURST_CAP_SIZE / SS_USB_PKT_SIZE;2698		break;2699	case USB_SPEED_HIGH:2700		dev->rx_urb_size = RX_HS_URB_SIZE;2701		dev->tx_urb_size = TX_HS_URB_SIZE;2702		dev->n_rx_urbs = RX_HS_URB_NUM;2703		dev->n_tx_urbs = TX_HS_URB_NUM;2704		dev->bulk_in_delay = HS_BULK_IN_DELAY;2705		dev->burst_cap = HS_BURST_CAP_SIZE / HS_USB_PKT_SIZE;2706		break;2707	case USB_SPEED_FULL:2708		dev->rx_urb_size = RX_FS_URB_SIZE;2709		dev->tx_urb_size = TX_FS_URB_SIZE;2710		dev->n_rx_urbs = RX_FS_URB_NUM;2711		dev->n_tx_urbs = TX_FS_URB_NUM;2712		dev->bulk_in_delay = FS_BULK_IN_DELAY;2713		dev->burst_cap = FS_BURST_CAP_SIZE / FS_USB_PKT_SIZE;2714		break;2715	default:2716		netdev_warn(dev->net, "USB bus speed not supported\n");2717		result = -EIO;2718		break;2719	}2720 2721	return result;2722}2723 2724static int lan78xx_start_hw(struct lan78xx_net *dev, u32 reg, u32 hw_enable)2725{2726	return lan78xx_update_reg(dev, reg, hw_enable, hw_enable);2727}2728 2729static int lan78xx_stop_hw(struct lan78xx_net *dev, u32 reg, u32 hw_enabled,2730			   u32 hw_disabled)2731{2732	unsigned long timeout;2733	bool stopped = true;2734	int ret;2735	u32 buf;2736 2737	/* Stop the h/w block (if not already stopped) */2738 2739	ret = lan78xx_read_reg(dev, reg, &buf);2740	if (ret < 0)2741		return ret;2742 2743	if (buf & hw_enabled) {2744		buf &= ~hw_enabled;2745 2746		ret = lan78xx_write_reg(dev, reg, buf);2747		if (ret < 0)2748			return ret;2749 2750		stopped = false;2751		timeout = jiffies + HW_DISABLE_TIMEOUT;2752		do  {2753			ret = lan78xx_read_reg(dev, reg, &buf);2754			if (ret < 0)2755				return ret;2756 2757			if (buf & hw_disabled)2758				stopped = true;2759			else2760				msleep(HW_DISABLE_DELAY_MS);2761		} while (!stopped && !time_after(jiffies, timeout));2762	}2763 2764	ret = stopped ? 0 : -ETIME;2765 2766	return ret;2767}2768 2769static int lan78xx_flush_fifo(struct lan78xx_net *dev, u32 reg, u32 fifo_flush)2770{2771	return lan78xx_update_reg(dev, reg, fifo_flush, fifo_flush);2772}2773 2774static int lan78xx_start_tx_path(struct lan78xx_net *dev)2775{2776	int ret;2777 2778	netif_dbg(dev, drv, dev->net, "start tx path");2779 2780	/* Start the MAC transmitter */2781 2782	ret = lan78xx_start_hw(dev, MAC_TX, MAC_TX_TXEN_);2783	if (ret < 0)2784		return ret;2785 2786	/* Start the Tx FIFO */2787 2788	ret = lan78xx_start_hw(dev, FCT_TX_CTL, FCT_TX_CTL_EN_);2789	if (ret < 0)2790		return ret;2791 2792	return 0;2793}2794 2795static int lan78xx_stop_tx_path(struct lan78xx_net *dev)2796{2797	int ret;2798 2799	netif_dbg(dev, drv, dev->net, "stop tx path");2800 2801	/* Stop the Tx FIFO */2802 2803	ret = lan78xx_stop_hw(dev, FCT_TX_CTL, FCT_TX_CTL_EN_, FCT_TX_CTL_DIS_);2804	if (ret < 0)2805		return ret;2806 2807	/* Stop the MAC transmitter */2808 2809	ret = lan78xx_stop_hw(dev, MAC_TX, MAC_TX_TXEN_, MAC_TX_TXD_);2810	if (ret < 0)2811		return ret;2812 2813	return 0;2814}2815 2816/* The caller must ensure the Tx path is stopped before calling2817 * lan78xx_flush_tx_fifo().2818 */2819static int lan78xx_flush_tx_fifo(struct lan78xx_net *dev)2820{2821	return lan78xx_flush_fifo(dev, FCT_TX_CTL, FCT_TX_CTL_RST_);2822}2823 2824static int lan78xx_start_rx_path(struct lan78xx_net *dev)2825{2826	int ret;2827 2828	netif_dbg(dev, drv, dev->net, "start rx path");2829 2830	/* Start the Rx FIFO */2831 2832	ret = lan78xx_start_hw(dev, FCT_RX_CTL, FCT_RX_CTL_EN_);2833	if (ret < 0)2834		return ret;2835 2836	/* Start the MAC receiver*/2837 2838	ret = lan78xx_start_hw(dev, MAC_RX, MAC_RX_RXEN_);2839	if (ret < 0)2840		return ret;2841 2842	return 0;2843}2844 2845static int lan78xx_stop_rx_path(struct lan78xx_net *dev)2846{2847	int ret;2848 2849	netif_dbg(dev, drv, dev->net, "stop rx path");2850 2851	/* Stop the MAC receiver */2852 2853	ret = lan78xx_stop_hw(dev, MAC_RX, MAC_RX_RXEN_, MAC_RX_RXD_);2854	if (ret < 0)2855		return ret;2856 2857	/* Stop the Rx FIFO */2858 2859	ret = lan78xx_stop_hw(dev, FCT_RX_CTL, FCT_RX_CTL_EN_, FCT_RX_CTL_DIS_);2860	if (ret < 0)2861		return ret;2862 2863	return 0;2864}2865 2866/* The caller must ensure the Rx path is stopped before calling2867 * lan78xx_flush_rx_fifo().2868 */2869static int lan78xx_flush_rx_fifo(struct lan78xx_net *dev)2870{2871	return lan78xx_flush_fifo(dev, FCT_RX_CTL, FCT_RX_CTL_RST_);2872}2873 2874static int lan78xx_reset(struct lan78xx_net *dev)2875{2876	struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);2877	unsigned long timeout;2878	int ret;2879	u32 buf;2880	u8 sig;2881 2882	ret = lan78xx_read_reg(dev, HW_CFG, &buf);2883	if (ret < 0)2884		return ret;2885 2886	buf |= HW_CFG_LRST_;2887 2888	ret = lan78xx_write_reg(dev, HW_CFG, buf);2889	if (ret < 0)2890		return ret;2891 2892	timeout = jiffies + HZ;2893	do {2894		mdelay(1);2895		ret = lan78xx_read_reg(dev, HW_CFG, &buf);2896		if (ret < 0)2897			return ret;2898 2899		if (time_after(jiffies, timeout)) {2900			netdev_warn(dev->net,2901				    "timeout on completion of LiteReset");2902			ret = -ETIMEDOUT;2903			return ret;2904		}2905	} while (buf & HW_CFG_LRST_);2906 2907	lan78xx_init_mac_address(dev);2908 2909	/* save DEVID for later usage */2910	ret = lan78xx_read_reg(dev, ID_REV, &buf);2911	if (ret < 0)2912		return ret;2913 2914	dev->chipid = (buf & ID_REV_CHIP_ID_MASK_) >> 16;2915	dev->chiprev = buf & ID_REV_CHIP_REV_MASK_;2916 2917	/* Respond to the IN token with a NAK */2918	ret = lan78xx_read_reg(dev, USB_CFG0, &buf);2919	if (ret < 0)2920		return ret;2921 2922	buf |= USB_CFG_BIR_;2923 2924	ret = lan78xx_write_reg(dev, USB_CFG0, buf);2925	if (ret < 0)2926		return ret;2927 2928	/* Init LTM */2929	lan78xx_init_ltm(dev);2930 2931	ret = lan78xx_write_reg(dev, BURST_CAP, dev->burst_cap);2932	if (ret < 0)2933		return ret;2934 2935	ret = lan78xx_write_reg(dev, BULK_IN_DLY, dev->bulk_in_delay);2936	if (ret < 0)2937		return ret;2938 2939	ret = lan78xx_read_reg(dev, HW_CFG, &buf);2940	if (ret < 0)2941		return ret;2942 2943	buf |= HW_CFG_MEF_;2944	buf |= HW_CFG_CLK125_EN_;2945	buf |= HW_CFG_REFCLK25_EN_;2946 2947	ret = lan78xx_write_reg(dev, HW_CFG, buf);2948	if (ret < 0)2949		return ret;2950 2951	ret = lan78xx_read_reg(dev, USB_CFG0, &buf);2952	if (ret < 0)2953		return ret;2954 2955	buf |= USB_CFG_BCE_;2956 2957	ret = lan78xx_write_reg(dev, USB_CFG0, buf);2958	if (ret < 0)2959		return ret;2960 2961	/* set FIFO sizes */2962	buf = (MAX_RX_FIFO_SIZE - 512) / 512;2963 2964	ret = lan78xx_write_reg(dev, FCT_RX_FIFO_END, buf);2965	if (ret < 0)2966		return ret;2967 2968	buf = (MAX_TX_FIFO_SIZE - 512) / 512;2969 2970	ret = lan78xx_write_reg(dev, FCT_TX_FIFO_END, buf);2971	if (ret < 0)2972		return ret;2973 2974	ret = lan78xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL_);2975	if (ret < 0)2976		return ret;2977 2978	ret = lan78xx_write_reg(dev, FLOW, 0);2979	if (ret < 0)2980		return ret;2981 2982	ret = lan78xx_write_reg(dev, FCT_FLOW, 0);2983	if (ret < 0)2984		return ret;2985 2986	/* Don't need rfe_ctl_lock during initialisation */2987	ret = lan78xx_read_reg(dev, RFE_CTL, &pdata->rfe_ctl);2988	if (ret < 0)2989		return ret;2990 2991	pdata->rfe_ctl |= RFE_CTL_BCAST_EN_ | RFE_CTL_DA_PERFECT_;2992 2993	ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);2994	if (ret < 0)2995		return ret;2996 2997	/* Enable or disable checksum offload engines */2998	ret = lan78xx_set_features(dev->net, dev->net->features);2999	if (ret < 0)3000		return ret;3001 3002	lan78xx_set_multicast(dev->net);3003 3004	/* reset PHY */3005	ret = lan78xx_read_reg(dev, PMT_CTL, &buf);3006	if (ret < 0)3007		return ret;3008 3009	buf |= PMT_CTL_PHY_RST_;3010 3011	ret = lan78xx_write_reg(dev, PMT_CTL, buf);3012	if (ret < 0)3013		return ret;3014 3015	timeout = jiffies + HZ;3016	do {3017		mdelay(1);3018		ret = lan78xx_read_reg(dev, PMT_CTL, &buf);3019		if (ret < 0)3020			return ret;3021 3022		if (time_after(jiffies, timeout)) {3023			netdev_warn(dev->net, "timeout waiting for PHY Reset");3024			ret = -ETIMEDOUT;3025			return ret;3026		}3027	} while ((buf & PMT_CTL_PHY_RST_) || !(buf & PMT_CTL_READY_));3028 3029	ret = lan78xx_read_reg(dev, MAC_CR, &buf);3030	if (ret < 0)3031		return ret;3032 3033	/* LAN7801 only has RGMII mode */3034	if (dev->chipid == ID_REV_CHIP_ID_7801_) {3035		buf &= ~MAC_CR_GMII_EN_;3036		/* Enable Auto Duplex and Auto speed */3037		buf |= MAC_CR_AUTO_DUPLEX_ | MAC_CR_AUTO_SPEED_;3038	}3039 3040	if (dev->chipid == ID_REV_CHIP_ID_7800_ ||3041	    dev->chipid == ID_REV_CHIP_ID_7850_) {3042		ret = lan78xx_read_raw_eeprom(dev, 0, 1, &sig);3043		if (!ret && sig != EEPROM_INDICATOR) {3044			/* Implies there is no external eeprom. Set mac speed */3045			netdev_info(dev->net, "No External EEPROM. Setting MAC Speed\n");3046			buf |= MAC_CR_AUTO_DUPLEX_ | MAC_CR_AUTO_SPEED_;3047		}3048	}3049	ret = lan78xx_write_reg(dev, MAC_CR, buf);3050	if (ret < 0)3051		return ret;3052 3053	ret = lan78xx_set_rx_max_frame_length(dev,3054					      RX_MAX_FRAME_LEN(dev->net->mtu));3055 3056	return ret;3057}3058 3059static void lan78xx_init_stats(struct lan78xx_net *dev)3060{3061	u32 *p;3062	int i;3063 3064	/* initialize for stats update3065	 * some counters are 20bits and some are 32bits3066	 */3067	p = (u32 *)&dev->stats.rollover_max;3068	for (i = 0; i < (sizeof(dev->stats.rollover_max) / (sizeof(u32))); i++)3069		p[i] = 0xFFFFF;3070 3071	dev->stats.rollover_max.rx_unicast_byte_count = 0xFFFFFFFF;3072	dev->stats.rollover_max.rx_broadcast_byte_count = 0xFFFFFFFF;3073	dev->stats.rollover_max.rx_multicast_byte_count = 0xFFFFFFFF;3074	dev->stats.rollover_max.eee_rx_lpi_transitions = 0xFFFFFFFF;3075	dev->stats.rollover_max.eee_rx_lpi_time = 0xFFFFFFFF;3076	dev->stats.rollover_max.tx_unicast_byte_count = 0xFFFFFFFF;3077	dev->stats.rollover_max.tx_broadcast_byte_count = 0xFFFFFFFF;3078	dev->stats.rollover_max.tx_multicast_byte_count = 0xFFFFFFFF;3079	dev->stats.rollover_max.eee_tx_lpi_transitions = 0xFFFFFFFF;3080	dev->stats.rollover_max.eee_tx_lpi_time = 0xFFFFFFFF;3081 3082	set_bit(EVENT_STAT_UPDATE, &dev->flags);3083}3084 3085static int lan78xx_open(struct net_device *net)3086{3087	struct lan78xx_net *dev = netdev_priv(net);3088	int ret;3089 3090	netif_dbg(dev, ifup, dev->net, "open device");3091 3092	ret = usb_autopm_get_interface(dev->intf);3093	if (ret < 0)3094		return ret;3095 3096	mutex_lock(&dev->dev_mutex);3097 3098	phy_start(net->phydev);3099 3100	netif_dbg(dev, ifup, dev->net, "phy initialised successfully");3101 3102	/* for Link Check */3103	if (dev->urb_intr) {3104		ret = usb_submit_urb(dev->urb_intr, GFP_KERNEL);3105		if (ret < 0) {3106			netif_err(dev, ifup, dev->net,3107				  "intr submit %d\n", ret);3108			goto done;3109		}3110	}3111 3112	ret = lan78xx_flush_rx_fifo(dev);3113	if (ret < 0)3114		goto done;3115	ret = lan78xx_flush_tx_fifo(dev);3116	if (ret < 0)3117		goto done;3118 3119	ret = lan78xx_start_tx_path(dev);3120	if (ret < 0)3121		goto done;3122	ret = lan78xx_start_rx_path(dev);3123	if (ret < 0)3124		goto done;3125 3126	lan78xx_init_stats(dev);3127 3128	set_bit(EVENT_DEV_OPEN, &dev->flags);3129 3130	netif_start_queue(net);3131 3132	dev->link_on = false;3133 3134	napi_enable(&dev->napi);3135 3136	lan78xx_defer_kevent(dev, EVENT_LINK_RESET);3137done:3138	mutex_unlock(&dev->dev_mutex);3139 3140	if (ret < 0)3141		usb_autopm_put_interface(dev->intf);3142 3143	return ret;3144}3145 3146static void lan78xx_terminate_urbs(struct lan78xx_net *dev)3147{3148	DECLARE_WAIT_QUEUE_HEAD_ONSTACK(unlink_wakeup);3149	DECLARE_WAITQUEUE(wait, current);3150	int temp;3151 3152	/* ensure there are no more active urbs */3153	add_wait_queue(&unlink_wakeup, &wait);3154	set_current_state(TASK_UNINTERRUPTIBLE);3155	dev->wait = &unlink_wakeup;3156	temp = unlink_urbs(dev, &dev->txq) + unlink_urbs(dev, &dev->rxq);3157 3158	/* maybe wait for deletions to finish. */3159	while (!skb_queue_empty(&dev->rxq) ||3160	       !skb_queue_empty(&dev->txq)) {3161		schedule_timeout(msecs_to_jiffies(UNLINK_TIMEOUT_MS));3162		set_current_state(TASK_UNINTERRUPTIBLE);3163		netif_dbg(dev, ifdown, dev->net,3164			  "waited for %d urb completions", temp);3165	}3166	set_current_state(TASK_RUNNING);3167	dev->wait = NULL;3168	remove_wait_queue(&unlink_wakeup, &wait);3169 3170	/* empty Rx done, Rx overflow and Tx pend queues3171	 */3172	while (!skb_queue_empty(&dev->rxq_done)) {3173		struct sk_buff *skb = skb_dequeue(&dev->rxq_done);3174 3175		lan78xx_release_rx_buf(dev, skb);3176	}3177 3178	skb_queue_purge(&dev->rxq_overflow);3179	skb_queue_purge(&dev->txq_pend);3180}3181 3182static int lan78xx_stop(struct net_device *net)3183{3184	struct lan78xx_net *dev = netdev_priv(net);3185 3186	netif_dbg(dev, ifup, dev->net, "stop device");3187 3188	mutex_lock(&dev->dev_mutex);3189 3190	if (timer_pending(&dev->stat_monitor))3191		del_timer_sync(&dev->stat_monitor);3192 3193	clear_bit(EVENT_DEV_OPEN, &dev->flags);3194	netif_stop_queue(net);3195	napi_disable(&dev->napi);3196 3197	lan78xx_terminate_urbs(dev);3198 3199	netif_info(dev, ifdown, dev->net,3200		   "stop stats: rx/tx %lu/%lu, errs %lu/%lu\n",3201		   net->stats.rx_packets, net->stats.tx_packets,3202		   net->stats.rx_errors, net->stats.tx_errors);3203 3204	/* ignore errors that occur stopping the Tx and Rx data paths */3205	lan78xx_stop_tx_path(dev);3206	lan78xx_stop_rx_path(dev);3207 3208	if (net->phydev)3209		phy_stop(net->phydev);3210 3211	usb_kill_urb(dev->urb_intr);3212 3213	/* deferred work (task, timer, softirq) must also stop.3214	 * can't flush_scheduled_work() until we drop rtnl (later),3215	 * else workers could deadlock; so make workers a NOP.3216	 */3217	clear_bit(EVENT_TX_HALT, &dev->flags);3218	clear_bit(EVENT_RX_HALT, &dev->flags);3219	clear_bit(EVENT_LINK_RESET, &dev->flags);3220	clear_bit(EVENT_STAT_UPDATE, &dev->flags);3221 3222	cancel_delayed_work_sync(&dev->wq);3223 3224	usb_autopm_put_interface(dev->intf);3225 3226	mutex_unlock(&dev->dev_mutex);3227 3228	return 0;3229}3230 3231static enum skb_state defer_bh(struct lan78xx_net *dev, struct sk_buff *skb,3232			       struct sk_buff_head *list, enum skb_state state)3233{3234	unsigned long flags;3235	enum skb_state old_state;3236	struct skb_data *entry = (struct skb_data *)skb->cb;3237 3238	spin_lock_irqsave(&list->lock, flags);3239	old_state = entry->state;3240	entry->state = state;3241 3242	__skb_unlink(skb, list);3243	spin_unlock(&list->lock);3244	spin_lock(&dev->rxq_done.lock);3245 3246	__skb_queue_tail(&dev->rxq_done, skb);3247	if (skb_queue_len(&dev->rxq_done) == 1)3248		napi_schedule(&dev->napi);3249 3250	spin_unlock_irqrestore(&dev->rxq_done.lock, flags);3251 3252	return old_state;3253}3254 3255static void tx_complete(struct urb *urb)3256{3257	struct sk_buff *skb = (struct sk_buff *)urb->context;3258	struct skb_data *entry = (struct skb_data *)skb->cb;3259	struct lan78xx_net *dev = entry->dev;3260 3261	if (urb->status == 0) {3262		dev->net->stats.tx_packets += entry->num_of_packet;3263		dev->net->stats.tx_bytes += entry->length;3264	} else {3265		dev->net->stats.tx_errors += entry->num_of_packet;3266 3267		switch (urb->status) {3268		case -EPIPE:3269			lan78xx_defer_kevent(dev, EVENT_TX_HALT);3270			break;3271 3272		/* software-driven interface shutdown */3273		case -ECONNRESET:3274		case -ESHUTDOWN:3275			netif_dbg(dev, tx_err, dev->net,3276				  "tx err interface gone %d\n",3277				  entry->urb->status);3278			break;3279 3280		case -EPROTO:3281		case -ETIME:3282		case -EILSEQ:3283			netif_stop_queue(dev->net);3284			netif_dbg(dev, tx_err, dev->net,3285				  "tx err queue stopped %d\n",3286				  entry->urb->status);3287			break;3288		default:3289			netif_dbg(dev, tx_err, dev->net,3290				  "unknown tx err %d\n",3291				  entry->urb->status);3292			break;3293		}3294	}3295 3296	usb_autopm_put_interface_async(dev->intf);3297 3298	skb_unlink(skb, &dev->txq);3299 3300	lan78xx_release_tx_buf(dev, skb);3301 3302	/* Re-schedule NAPI if Tx data pending but no URBs in progress.3303	 */3304	if (skb_queue_empty(&dev->txq) &&3305	    !skb_queue_empty(&dev->txq_pend))3306		napi_schedule(&dev->napi);3307}3308 3309static void lan78xx_queue_skb(struct sk_buff_head *list,3310			      struct sk_buff *newsk, enum skb_state state)3311{3312	struct skb_data *entry = (struct skb_data *)newsk->cb;3313 3314	__skb_queue_tail(list, newsk);3315	entry->state = state;3316}3317 3318static unsigned int lan78xx_tx_urb_space(struct lan78xx_net *dev)3319{3320	return skb_queue_len(&dev->txq_free) * dev->tx_urb_size;3321}3322 3323static unsigned int lan78xx_tx_pend_data_len(struct lan78xx_net *dev)3324{3325	return dev->tx_pend_data_len;3326}3327 3328static void lan78xx_tx_pend_skb_add(struct lan78xx_net *dev,3329				    struct sk_buff *skb,3330				    unsigned int *tx_pend_data_len)3331{3332	unsigned long flags;3333 3334	spin_lock_irqsave(&dev->txq_pend.lock, flags);3335 3336	__skb_queue_tail(&dev->txq_pend, skb);3337 3338	dev->tx_pend_data_len += skb->len;3339	*tx_pend_data_len = dev->tx_pend_data_len;3340 3341	spin_unlock_irqrestore(&dev->txq_pend.lock, flags);3342}3343 3344static void lan78xx_tx_pend_skb_head_add(struct lan78xx_net *dev,3345					 struct sk_buff *skb,3346					 unsigned int *tx_pend_data_len)3347{3348	unsigned long flags;3349 3350	spin_lock_irqsave(&dev->txq_pend.lock, flags);3351 3352	__skb_queue_head(&dev->txq_pend, skb);3353 3354	dev->tx_pend_data_len += skb->len;3355	*tx_pend_data_len = dev->tx_pend_data_len;3356 3357	spin_unlock_irqrestore(&dev->txq_pend.lock, flags);3358}3359 3360static void lan78xx_tx_pend_skb_get(struct lan78xx_net *dev,3361				    struct sk_buff **skb,3362				    unsigned int *tx_pend_data_len)3363{3364	unsigned long flags;3365 3366	spin_lock_irqsave(&dev->txq_pend.lock, flags);3367 3368	*skb = __skb_dequeue(&dev->txq_pend);3369	if (*skb)3370		dev->tx_pend_data_len -= (*skb)->len;3371	*tx_pend_data_len = dev->tx_pend_data_len;3372 3373	spin_unlock_irqrestore(&dev->txq_pend.lock, flags);3374}3375 3376static netdev_tx_t3377lan78xx_start_xmit(struct sk_buff *skb, struct net_device *net)3378{3379	struct lan78xx_net *dev = netdev_priv(net);3380	unsigned int tx_pend_data_len;3381 3382	if (test_bit(EVENT_DEV_ASLEEP, &dev->flags))3383		schedule_delayed_work(&dev->wq, 0);3384 3385	skb_tx_timestamp(skb);3386 3387	lan78xx_tx_pend_skb_add(dev, skb, &tx_pend_data_len);3388 3389	/* Set up a Tx URB if none is in progress */3390 3391	if (skb_queue_empty(&dev->txq))3392		napi_schedule(&dev->napi);3393 3394	/* Stop stack Tx queue if we have enough data to fill3395	 * all the free Tx URBs.3396	 */3397	if (tx_pend_data_len > lan78xx_tx_urb_space(dev)) {3398		netif_stop_queue(net);3399 3400		netif_dbg(dev, hw, dev->net, "tx data len: %u, urb space %u",3401			  tx_pend_data_len, lan78xx_tx_urb_space(dev));3402 3403		/* Kick off transmission of pending data */3404 3405		if (!skb_queue_empty(&dev->txq_free))3406			napi_schedule(&dev->napi);3407	}3408 3409	return NETDEV_TX_OK;3410}3411 3412static int lan78xx_bind(struct lan78xx_net *dev, struct usb_interface *intf)3413{3414	struct lan78xx_priv *pdata = NULL;3415	int ret;3416	int i;3417 3418	dev->data[0] = (unsigned long)kzalloc(sizeof(*pdata), GFP_KERNEL);3419 3420	pdata = (struct lan78xx_priv *)(dev->data[0]);3421	if (!pdata) {3422		netdev_warn(dev->net, "Unable to allocate lan78xx_priv");3423		return -ENOMEM;3424	}3425 3426	pdata->dev = dev;3427 3428	spin_lock_init(&pdata->rfe_ctl_lock);3429	mutex_init(&pdata->dataport_mutex);3430 3431	INIT_WORK(&pdata->set_multicast, lan78xx_deferred_multicast_write);3432 3433	for (i = 0; i < DP_SEL_VHF_VLAN_LEN; i++)3434		pdata->vlan_table[i] = 0;3435 3436	INIT_WORK(&pdata->set_vlan, lan78xx_deferred_vlan_write);3437 3438	dev->net->features = 0;3439 3440	if (DEFAULT_TX_CSUM_ENABLE)3441		dev->net->features |= NETIF_F_HW_CSUM;3442 3443	if (DEFAULT_RX_CSUM_ENABLE)3444		dev->net->features |= NETIF_F_RXCSUM;3445 3446	if (DEFAULT_TSO_CSUM_ENABLE)3447		dev->net->features |= NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_SG;3448 3449	if (DEFAULT_VLAN_RX_OFFLOAD)3450		dev->net->features |= NETIF_F_HW_VLAN_CTAG_RX;3451 3452	if (DEFAULT_VLAN_FILTER_ENABLE)3453		dev->net->features |= NETIF_F_HW_VLAN_CTAG_FILTER;3454 3455	dev->net->hw_features = dev->net->features;3456 3457	ret = lan78xx_setup_irq_domain(dev);3458	if (ret < 0) {3459		netdev_warn(dev->net,3460			    "lan78xx_setup_irq_domain() failed : %d", ret);3461		goto out1;3462	}3463 3464	/* Init all registers */3465	ret = lan78xx_reset(dev);3466	if (ret) {3467		netdev_warn(dev->net, "Registers INIT FAILED....");3468		goto out2;3469	}3470 3471	ret = lan78xx_mdio_init(dev);3472	if (ret) {3473		netdev_warn(dev->net, "MDIO INIT FAILED.....");3474		goto out2;3475	}3476 3477	dev->net->flags |= IFF_MULTICAST;3478 3479	pdata->wol = WAKE_MAGIC;3480 3481	return ret;3482 3483out2:3484	lan78xx_remove_irq_domain(dev);3485 3486out1:3487	netdev_warn(dev->net, "Bind routine FAILED");3488	cancel_work_sync(&pdata->set_multicast);3489	cancel_work_sync(&pdata->set_vlan);3490	kfree(pdata);3491	return ret;3492}3493 3494static void lan78xx_unbind(struct lan78xx_net *dev, struct usb_interface *intf)3495{3496	struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);3497 3498	lan78xx_remove_irq_domain(dev);3499 3500	lan78xx_remove_mdio(dev);3501 3502	if (pdata) {3503		cancel_work_sync(&pdata->set_multicast);3504		cancel_work_sync(&pdata->set_vlan);3505		netif_dbg(dev, ifdown, dev->net, "free pdata");3506		kfree(pdata);3507		pdata = NULL;3508		dev->data[0] = 0;3509	}3510}3511 3512static void lan78xx_rx_csum_offload(struct lan78xx_net *dev,3513				    struct sk_buff *skb,3514				    u32 rx_cmd_a, u32 rx_cmd_b)3515{3516	/* HW Checksum offload appears to be flawed if used when not stripping3517	 * VLAN headers. Drop back to S/W checksums under these conditions.3518	 */3519	if (!(dev->net->features & NETIF_F_RXCSUM) ||3520	    unlikely(rx_cmd_a & RX_CMD_A_ICSM_) ||3521	    ((rx_cmd_a & RX_CMD_A_FVTG_) &&3522	     !(dev->net->features & NETIF_F_HW_VLAN_CTAG_RX))) {3523		skb->ip_summed = CHECKSUM_NONE;3524	} else {3525		skb->csum = ntohs((u16)(rx_cmd_b >> RX_CMD_B_CSUM_SHIFT_));3526		skb->ip_summed = CHECKSUM_COMPLETE;3527	}3528}3529 3530static void lan78xx_rx_vlan_offload(struct lan78xx_net *dev,3531				    struct sk_buff *skb,3532				    u32 rx_cmd_a, u32 rx_cmd_b)3533{3534	if ((dev->net->features & NETIF_F_HW_VLAN_CTAG_RX) &&3535	    (rx_cmd_a & RX_CMD_A_FVTG_))3536		__vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q),3537				       (rx_cmd_b & 0xffff));3538}3539 3540static void lan78xx_skb_return(struct lan78xx_net *dev, struct sk_buff *skb)3541{3542	dev->net->stats.rx_packets++;3543	dev->net->stats.rx_bytes += skb->len;3544 3545	skb->protocol = eth_type_trans(skb, dev->net);3546 3547	netif_dbg(dev, rx_status, dev->net, "< rx, len %zu, type 0x%x\n",3548		  skb->len + sizeof(struct ethhdr), skb->protocol);3549	memset(skb->cb, 0, sizeof(struct skb_data));3550 3551	if (skb_defer_rx_timestamp(skb))3552		return;3553 3554	napi_gro_receive(&dev->napi, skb);3555}3556 3557static int lan78xx_rx(struct lan78xx_net *dev, struct sk_buff *skb,3558		      int budget, int *work_done)3559{3560	if (skb->len < RX_SKB_MIN_LEN)3561		return 0;3562 3563	/* Extract frames from the URB buffer and pass each one to3564	 * the stack in a new NAPI SKB.3565	 */3566	while (skb->len > 0) {3567		u32 rx_cmd_a, rx_cmd_b, align_count, size;3568		u16 rx_cmd_c;3569		unsigned char *packet;3570 3571		rx_cmd_a = get_unaligned_le32(skb->data);3572		skb_pull(skb, sizeof(rx_cmd_a));3573 3574		rx_cmd_b = get_unaligned_le32(skb->data);3575		skb_pull(skb, sizeof(rx_cmd_b));3576 3577		rx_cmd_c = get_unaligned_le16(skb->data);3578		skb_pull(skb, sizeof(rx_cmd_c));3579 3580		packet = skb->data;3581 3582		/* get the packet length */3583		size = (rx_cmd_a & RX_CMD_A_LEN_MASK_);3584		align_count = (4 - ((size + RXW_PADDING) % 4)) % 4;3585 3586		if (unlikely(size > skb->len)) {3587			netif_dbg(dev, rx_err, dev->net,3588				  "size err rx_cmd_a=0x%08x\n",3589				  rx_cmd_a);3590			return 0;3591		}3592 3593		if (unlikely(rx_cmd_a & RX_CMD_A_RED_)) {3594			netif_dbg(dev, rx_err, dev->net,3595				  "Error rx_cmd_a=0x%08x", rx_cmd_a);3596		} else {3597			u32 frame_len;3598			struct sk_buff *skb2;3599 3600			if (unlikely(size < ETH_FCS_LEN)) {3601				netif_dbg(dev, rx_err, dev->net,3602					  "size err rx_cmd_a=0x%08x\n",3603					  rx_cmd_a);3604				return 0;3605			}3606 3607			frame_len = size - ETH_FCS_LEN;3608 3609			skb2 = napi_alloc_skb(&dev->napi, frame_len);3610			if (!skb2)3611				return 0;3612 3613			memcpy(skb2->data, packet, frame_len);3614 3615			skb_put(skb2, frame_len);3616 3617			lan78xx_rx_csum_offload(dev, skb2, rx_cmd_a, rx_cmd_b);3618			lan78xx_rx_vlan_offload(dev, skb2, rx_cmd_a, rx_cmd_b);3619 3620			/* Processing of the URB buffer must complete once3621			 * it has started. If the NAPI work budget is exhausted3622			 * while frames remain they are added to the overflow3623			 * queue for delivery in the next NAPI polling cycle.3624			 */3625			if (*work_done < budget) {3626				lan78xx_skb_return(dev, skb2);3627				++(*work_done);3628			} else {3629				skb_queue_tail(&dev->rxq_overflow, skb2);3630			}3631		}3632 3633		skb_pull(skb, size);3634 3635		/* skip padding bytes before the next frame starts */3636		if (skb->len)3637			skb_pull(skb, align_count);3638	}3639 3640	return 1;3641}3642 3643static inline void rx_process(struct lan78xx_net *dev, struct sk_buff *skb,3644			      int budget, int *work_done)3645{3646	if (!lan78xx_rx(dev, skb, budget, work_done)) {3647		netif_dbg(dev, rx_err, dev->net, "drop\n");3648		dev->net->stats.rx_errors++;3649	}3650}3651 3652static void rx_complete(struct urb *urb)3653{3654	struct sk_buff	*skb = (struct sk_buff *)urb->context;3655	struct skb_data	*entry = (struct skb_data *)skb->cb;3656	struct lan78xx_net *dev = entry->dev;3657	int urb_status = urb->status;3658	enum skb_state state;3659 3660	netif_dbg(dev, rx_status, dev->net,3661		  "rx done: status %d", urb->status);3662 3663	skb_put(skb, urb->actual_length);3664	state = rx_done;3665 3666	if (urb != entry->urb)3667		netif_warn(dev, rx_err, dev->net, "URB pointer mismatch");3668 3669	switch (urb_status) {3670	case 0:3671		if (skb->len < RX_SKB_MIN_LEN) {3672			state = rx_cleanup;3673			dev->net->stats.rx_errors++;3674			dev->net->stats.rx_length_errors++;3675			netif_dbg(dev, rx_err, dev->net,3676				  "rx length %d\n", skb->len);3677		}3678		usb_mark_last_busy(dev->udev);3679		break;3680	case -EPIPE:3681		dev->net->stats.rx_errors++;3682		lan78xx_defer_kevent(dev, EVENT_RX_HALT);3683		fallthrough;3684	case -ECONNRESET:				/* async unlink */3685	case -ESHUTDOWN:				/* hardware gone */3686		netif_dbg(dev, ifdown, dev->net,3687			  "rx shutdown, code %d\n", urb_status);3688		state = rx_cleanup;3689		break;3690	case -EPROTO:3691	case -ETIME:3692	case -EILSEQ:3693		dev->net->stats.rx_errors++;3694		state = rx_cleanup;3695		break;3696 3697	/* data overrun ... flush fifo? */3698	case -EOVERFLOW:3699		dev->net->stats.rx_over_errors++;3700		fallthrough;3701 3702	default:3703		state = rx_cleanup;3704		dev->net->stats.rx_errors++;3705		netif_dbg(dev, rx_err, dev->net, "rx status %d\n", urb_status);3706		break;3707	}3708 3709	state = defer_bh(dev, skb, &dev->rxq, state);3710}3711 3712static int rx_submit(struct lan78xx_net *dev, struct sk_buff *skb, gfp_t flags)3713{3714	struct skb_data	*entry = (struct skb_data *)skb->cb;3715	size_t size = dev->rx_urb_size;3716	struct urb *urb = entry->urb;3717	unsigned long lockflags;3718	int ret = 0;3719 3720	usb_fill_bulk_urb(urb, dev->udev, dev->pipe_in,3721			  skb->data, size, rx_complete, skb);3722 3723	spin_lock_irqsave(&dev->rxq.lock, lockflags);3724 3725	if (netif_device_present(dev->net) &&3726	    netif_running(dev->net) &&3727	    !test_bit(EVENT_RX_HALT, &dev->flags) &&3728	    !test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {3729		ret = usb_submit_urb(urb, flags);3730		switch (ret) {3731		case 0:3732			lan78xx_queue_skb(&dev->rxq, skb, rx_start);3733			break;3734		case -EPIPE:3735			lan78xx_defer_kevent(dev, EVENT_RX_HALT);3736			break;3737		case -ENODEV:3738		case -ENOENT:3739			netif_dbg(dev, ifdown, dev->net, "device gone\n");3740			netif_device_detach(dev->net);3741			break;3742		case -EHOSTUNREACH:3743			ret = -ENOLINK;3744			napi_schedule(&dev->napi);3745			break;3746		default:3747			netif_dbg(dev, rx_err, dev->net,3748				  "rx submit, %d\n", ret);3749			napi_schedule(&dev->napi);3750			break;3751		}3752	} else {3753		netif_dbg(dev, ifdown, dev->net, "rx: stopped\n");3754		ret = -ENOLINK;3755	}3756	spin_unlock_irqrestore(&dev->rxq.lock, lockflags);3757 3758	if (ret)3759		lan78xx_release_rx_buf(dev, skb);3760 3761	return ret;3762}3763 3764static void lan78xx_rx_urb_submit_all(struct lan78xx_net *dev)3765{3766	struct sk_buff *rx_buf;3767 3768	/* Ensure the maximum number of Rx URBs is submitted3769	 */3770	while ((rx_buf = lan78xx_get_rx_buf(dev)) != NULL) {3771		if (rx_submit(dev, rx_buf, GFP_ATOMIC) != 0)3772			break;3773	}3774}3775 3776static void lan78xx_rx_urb_resubmit(struct lan78xx_net *dev,3777				    struct sk_buff *rx_buf)3778{3779	/* reset SKB data pointers */3780 3781	rx_buf->data = rx_buf->head;3782	skb_reset_tail_pointer(rx_buf);3783	rx_buf->len = 0;3784	rx_buf->data_len = 0;3785 3786	rx_submit(dev, rx_buf, GFP_ATOMIC);3787}3788 3789static void lan78xx_fill_tx_cmd_words(struct sk_buff *skb, u8 *buffer)3790{3791	u32 tx_cmd_a;3792	u32 tx_cmd_b;3793 3794	tx_cmd_a = (u32)(skb->len & TX_CMD_A_LEN_MASK_) | TX_CMD_A_FCS_;3795 3796	if (skb->ip_summed == CHECKSUM_PARTIAL)3797		tx_cmd_a |= TX_CMD_A_IPE_ | TX_CMD_A_TPE_;3798 3799	tx_cmd_b = 0;3800	if (skb_is_gso(skb)) {3801		u16 mss = max(skb_shinfo(skb)->gso_size, TX_CMD_B_MSS_MIN_);3802 3803		tx_cmd_b = (mss << TX_CMD_B_MSS_SHIFT_) & TX_CMD_B_MSS_MASK_;3804 3805		tx_cmd_a |= TX_CMD_A_LSO_;3806	}3807 3808	if (skb_vlan_tag_present(skb)) {3809		tx_cmd_a |= TX_CMD_A_IVTG_;3810		tx_cmd_b |= skb_vlan_tag_get(skb) & TX_CMD_B_VTAG_MASK_;3811	}3812 3813	put_unaligned_le32(tx_cmd_a, buffer);3814	put_unaligned_le32(tx_cmd_b, buffer + 4);3815}3816 3817static struct skb_data *lan78xx_tx_buf_fill(struct lan78xx_net *dev,3818					    struct sk_buff *tx_buf)3819{3820	struct skb_data *entry = (struct skb_data *)tx_buf->cb;3821	int remain = dev->tx_urb_size;3822	u8 *tx_data = tx_buf->data;3823	u32 urb_len = 0;3824 3825	entry->num_of_packet = 0;3826	entry->length = 0;3827 3828	/* Work through the pending SKBs and copy the data of each SKB into3829	 * the URB buffer if there room for all the SKB data.3830	 *3831	 * There must be at least DST+SRC+TYPE in the SKB (with padding enabled)3832	 */3833	while (remain >= TX_SKB_MIN_LEN) {3834		unsigned int pending_bytes;3835		unsigned int align_bytes;3836		struct sk_buff *skb;3837		unsigned int len;3838 3839		lan78xx_tx_pend_skb_get(dev, &skb, &pending_bytes);3840 3841		if (!skb)3842			break;3843 3844		align_bytes = (TX_ALIGNMENT - (urb_len % TX_ALIGNMENT)) %3845			      TX_ALIGNMENT;3846		len = align_bytes + TX_CMD_LEN + skb->len;3847		if (len > remain) {3848			lan78xx_tx_pend_skb_head_add(dev, skb, &pending_bytes);3849			break;3850		}3851 3852		tx_data += align_bytes;3853 3854		lan78xx_fill_tx_cmd_words(skb, tx_data);3855		tx_data += TX_CMD_LEN;3856 3857		len = skb->len;3858		if (skb_copy_bits(skb, 0, tx_data, len) < 0) {3859			struct net_device_stats *stats = &dev->net->stats;3860 3861			stats->tx_dropped++;3862			dev_kfree_skb_any(skb);3863			tx_data -= TX_CMD_LEN;3864			continue;3865		}3866 3867		tx_data += len;3868		entry->length += len;3869		entry->num_of_packet += skb_shinfo(skb)->gso_segs ?: 1;3870 3871		dev_kfree_skb_any(skb);3872 3873		urb_len = (u32)(tx_data - (u8 *)tx_buf->data);3874 3875		remain = dev->tx_urb_size - urb_len;3876	}3877 3878	skb_put(tx_buf, urb_len);3879 3880	return entry;3881}3882 3883static void lan78xx_tx_bh(struct lan78xx_net *dev)3884{3885	int ret;3886 3887	/* Start the stack Tx queue if it was stopped3888	 */3889	netif_tx_lock(dev->net);3890	if (netif_queue_stopped(dev->net)) {3891		if (lan78xx_tx_pend_data_len(dev) < lan78xx_tx_urb_space(dev))3892			netif_wake_queue(dev->net);3893	}3894	netif_tx_unlock(dev->net);3895 3896	/* Go through the Tx pending queue and set up URBs to transfer3897	 * the data to the device. Stop if no more pending data or URBs,3898	 * or if an error occurs when a URB is submitted.3899	 */3900	do {3901		struct skb_data *entry;3902		struct sk_buff *tx_buf;3903		unsigned long flags;3904 3905		if (skb_queue_empty(&dev->txq_pend))3906			break;3907 3908		tx_buf = lan78xx_get_tx_buf(dev);3909		if (!tx_buf)3910			break;3911 3912		entry = lan78xx_tx_buf_fill(dev, tx_buf);3913 3914		spin_lock_irqsave(&dev->txq.lock, flags);3915		ret = usb_autopm_get_interface_async(dev->intf);3916		if (ret < 0) {3917			spin_unlock_irqrestore(&dev->txq.lock, flags);3918			goto out;3919		}3920 3921		usb_fill_bulk_urb(entry->urb, dev->udev, dev->pipe_out,3922				  tx_buf->data, tx_buf->len, tx_complete,3923				  tx_buf);3924 3925		if (tx_buf->len % dev->maxpacket == 0) {3926			/* send USB_ZERO_PACKET */3927			entry->urb->transfer_flags |= URB_ZERO_PACKET;3928		}3929 3930#ifdef CONFIG_PM3931		/* if device is asleep stop outgoing packet processing */3932		if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {3933			usb_anchor_urb(entry->urb, &dev->deferred);3934			netif_stop_queue(dev->net);3935			spin_unlock_irqrestore(&dev->txq.lock, flags);3936			netdev_dbg(dev->net,3937				   "Delaying transmission for resumption\n");3938			return;3939		}3940#endif3941		ret = usb_submit_urb(entry->urb, GFP_ATOMIC);3942		switch (ret) {3943		case 0:3944			netif_trans_update(dev->net);3945			lan78xx_queue_skb(&dev->txq, tx_buf, tx_start);3946			break;3947		case -EPIPE:3948			netif_stop_queue(dev->net);3949			lan78xx_defer_kevent(dev, EVENT_TX_HALT);3950			usb_autopm_put_interface_async(dev->intf);3951			break;3952		case -ENODEV:3953		case -ENOENT:3954			netif_dbg(dev, tx_err, dev->net,3955				  "tx submit urb err %d (disconnected?)", ret);3956			netif_device_detach(dev->net);3957			break;3958		default:3959			usb_autopm_put_interface_async(dev->intf);3960			netif_dbg(dev, tx_err, dev->net,3961				  "tx submit urb err %d\n", ret);3962			break;3963		}3964 3965		spin_unlock_irqrestore(&dev->txq.lock, flags);3966 3967		if (ret) {3968			netdev_warn(dev->net, "failed to tx urb %d\n", ret);3969out:3970			dev->net->stats.tx_dropped += entry->num_of_packet;3971			lan78xx_release_tx_buf(dev, tx_buf);3972		}3973	} while (ret == 0);3974}3975 3976static int lan78xx_bh(struct lan78xx_net *dev, int budget)3977{3978	struct sk_buff_head done;3979	struct sk_buff *rx_buf;3980	struct skb_data *entry;3981	unsigned long flags;3982	int work_done = 0;3983 3984	/* Pass frames received in the last NAPI cycle before3985	 * working on newly completed URBs.3986	 */3987	while (!skb_queue_empty(&dev->rxq_overflow)) {3988		lan78xx_skb_return(dev, skb_dequeue(&dev->rxq_overflow));3989		++work_done;3990	}3991 3992	/* Take a snapshot of the done queue and move items to a3993	 * temporary queue. Rx URB completions will continue to add3994	 * to the done queue.3995	 */3996	__skb_queue_head_init(&done);3997 3998	spin_lock_irqsave(&dev->rxq_done.lock, flags);3999	skb_queue_splice_init(&dev->rxq_done, &done);4000	spin_unlock_irqrestore(&dev->rxq_done.lock, flags);4001 4002	/* Extract receive frames from completed URBs and4003	 * pass them to the stack. Re-submit each completed URB.4004	 */4005	while ((work_done < budget) &&4006	       (rx_buf = __skb_dequeue(&done))) {4007		entry = (struct skb_data *)(rx_buf->cb);4008		switch (entry->state) {4009		case rx_done:4010			rx_process(dev, rx_buf, budget, &work_done);4011			break;4012		case rx_cleanup:4013			break;4014		default:4015			netdev_dbg(dev->net, "rx buf state %d\n",4016				   entry->state);4017			break;4018		}4019 4020		lan78xx_rx_urb_resubmit(dev, rx_buf);4021	}4022 4023	/* If budget was consumed before processing all the URBs put them4024	 * back on the front of the done queue. They will be first to be4025	 * processed in the next NAPI cycle.4026	 */4027	spin_lock_irqsave(&dev->rxq_done.lock, flags);4028	skb_queue_splice(&done, &dev->rxq_done);4029	spin_unlock_irqrestore(&dev->rxq_done.lock, flags);4030 4031	if (netif_device_present(dev->net) && netif_running(dev->net)) {4032		/* reset update timer delta */4033		if (timer_pending(&dev->stat_monitor) && (dev->delta != 1)) {4034			dev->delta = 1;4035			mod_timer(&dev->stat_monitor,4036				  jiffies + STAT_UPDATE_TIMER);4037		}4038 4039		/* Submit all free Rx URBs */4040 4041		if (!test_bit(EVENT_RX_HALT, &dev->flags))4042			lan78xx_rx_urb_submit_all(dev);4043 4044		/* Submit new Tx URBs */4045 4046		lan78xx_tx_bh(dev);4047	}4048 4049	return work_done;4050}4051 4052static int lan78xx_poll(struct napi_struct *napi, int budget)4053{4054	struct lan78xx_net *dev = container_of(napi, struct lan78xx_net, napi);4055	int result = budget;4056	int work_done;4057 4058	/* Don't do any work if the device is suspended */4059 4060	if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {4061		napi_complete_done(napi, 0);4062		return 0;4063	}4064 4065	/* Process completed URBs and submit new URBs */4066 4067	work_done = lan78xx_bh(dev, budget);4068 4069	if (work_done < budget) {4070		napi_complete_done(napi, work_done);4071 4072		/* Start a new polling cycle if data was received or4073		 * data is waiting to be transmitted.4074		 */4075		if (!skb_queue_empty(&dev->rxq_done)) {4076			napi_schedule(napi);4077		} else if (netif_carrier_ok(dev->net)) {4078			if (skb_queue_empty(&dev->txq) &&4079			    !skb_queue_empty(&dev->txq_pend)) {4080				napi_schedule(napi);4081			} else {4082				netif_tx_lock(dev->net);4083				if (netif_queue_stopped(dev->net)) {4084					netif_wake_queue(dev->net);4085					napi_schedule(napi);4086				}4087				netif_tx_unlock(dev->net);4088			}4089		}4090		result = work_done;4091	}4092 4093	return result;4094}4095 4096static void lan78xx_delayedwork(struct work_struct *work)4097{4098	int status;4099	struct lan78xx_net *dev;4100 4101	dev = container_of(work, struct lan78xx_net, wq.work);4102 4103	if (test_bit(EVENT_DEV_DISCONNECT, &dev->flags))4104		return;4105 4106	if (usb_autopm_get_interface(dev->intf) < 0)4107		return;4108 4109	if (test_bit(EVENT_TX_HALT, &dev->flags)) {4110		unlink_urbs(dev, &dev->txq);4111 4112		status = usb_clear_halt(dev->udev, dev->pipe_out);4113		if (status < 0 &&4114		    status != -EPIPE &&4115		    status != -ESHUTDOWN) {4116			if (netif_msg_tx_err(dev))4117				netdev_err(dev->net,4118					   "can't clear tx halt, status %d\n",4119					   status);4120		} else {4121			clear_bit(EVENT_TX_HALT, &dev->flags);4122			if (status != -ESHUTDOWN)4123				netif_wake_queue(dev->net);4124		}4125	}4126 4127	if (test_bit(EVENT_RX_HALT, &dev->flags)) {4128		unlink_urbs(dev, &dev->rxq);4129		status = usb_clear_halt(dev->udev, dev->pipe_in);4130		if (status < 0 &&4131		    status != -EPIPE &&4132		    status != -ESHUTDOWN) {4133			if (netif_msg_rx_err(dev))4134				netdev_err(dev->net,4135					   "can't clear rx halt, status %d\n",4136					   status);4137		} else {4138			clear_bit(EVENT_RX_HALT, &dev->flags);4139			napi_schedule(&dev->napi);4140		}4141	}4142 4143	if (test_bit(EVENT_LINK_RESET, &dev->flags)) {4144		int ret = 0;4145 4146		clear_bit(EVENT_LINK_RESET, &dev->flags);4147		if (lan78xx_link_reset(dev) < 0) {4148			netdev_info(dev->net, "link reset failed (%d)\n",4149				    ret);4150		}4151	}4152 4153	if (test_bit(EVENT_STAT_UPDATE, &dev->flags)) {4154		lan78xx_update_stats(dev);4155 4156		clear_bit(EVENT_STAT_UPDATE, &dev->flags);4157 4158		mod_timer(&dev->stat_monitor,4159			  jiffies + (STAT_UPDATE_TIMER * dev->delta));4160 4161		dev->delta = min((dev->delta * 2), 50);4162	}4163 4164	usb_autopm_put_interface(dev->intf);4165}4166 4167static void intr_complete(struct urb *urb)4168{4169	struct lan78xx_net *dev = urb->context;4170	int status = urb->status;4171 4172	switch (status) {4173	/* success */4174	case 0:4175		lan78xx_status(dev, urb);4176		break;4177 4178	/* software-driven interface shutdown */4179	case -ENOENT:			/* urb killed */4180	case -ENODEV:			/* hardware gone */4181	case -ESHUTDOWN:		/* hardware gone */4182		netif_dbg(dev, ifdown, dev->net,4183			  "intr shutdown, code %d\n", status);4184		return;4185 4186	/* NOTE:  not throttling like RX/TX, since this endpoint4187	 * already polls infrequently4188	 */4189	default:4190		netdev_dbg(dev->net, "intr status %d\n", status);4191		break;4192	}4193 4194	if (!netif_device_present(dev->net) ||4195	    !netif_running(dev->net)) {4196		netdev_warn(dev->net, "not submitting new status URB");4197		return;4198	}4199 4200	memset(urb->transfer_buffer, 0, urb->transfer_buffer_length);4201	status = usb_submit_urb(urb, GFP_ATOMIC);4202 4203	switch (status) {4204	case  0:4205		break;4206	case -ENODEV:4207	case -ENOENT:4208		netif_dbg(dev, timer, dev->net,4209			  "intr resubmit %d (disconnect?)", status);4210		netif_device_detach(dev->net);4211		break;4212	default:4213		netif_err(dev, timer, dev->net,4214			  "intr resubmit --> %d\n", status);4215		break;4216	}4217}4218 4219static void lan78xx_disconnect(struct usb_interface *intf)4220{4221	struct lan78xx_net *dev;4222	struct usb_device *udev;4223	struct net_device *net;4224	struct phy_device *phydev;4225 4226	dev = usb_get_intfdata(intf);4227	usb_set_intfdata(intf, NULL);4228	if (!dev)4229		return;4230 4231	netif_napi_del(&dev->napi);4232 4233	udev = interface_to_usbdev(intf);4234	net = dev->net;4235 4236	unregister_netdev(net);4237 4238	timer_shutdown_sync(&dev->stat_monitor);4239	set_bit(EVENT_DEV_DISCONNECT, &dev->flags);4240	cancel_delayed_work_sync(&dev->wq);4241 4242	phydev = net->phydev;4243 4244	phy_unregister_fixup_for_uid(PHY_KSZ9031RNX, 0xfffffff0);4245	phy_unregister_fixup_for_uid(PHY_LAN8835, 0xfffffff0);4246 4247	phy_disconnect(net->phydev);4248 4249	if (phy_is_pseudo_fixed_link(phydev))4250		fixed_phy_unregister(phydev);4251 4252	usb_scuttle_anchored_urbs(&dev->deferred);4253 4254	lan78xx_unbind(dev, intf);4255 4256	lan78xx_free_tx_resources(dev);4257	lan78xx_free_rx_resources(dev);4258 4259	usb_kill_urb(dev->urb_intr);4260	usb_free_urb(dev->urb_intr);4261 4262	free_netdev(net);4263	usb_put_dev(udev);4264}4265 4266static void lan78xx_tx_timeout(struct net_device *net, unsigned int txqueue)4267{4268	struct lan78xx_net *dev = netdev_priv(net);4269 4270	unlink_urbs(dev, &dev->txq);4271	napi_schedule(&dev->napi);4272}4273 4274static netdev_features_t lan78xx_features_check(struct sk_buff *skb,4275						struct net_device *netdev,4276						netdev_features_t features)4277{4278	struct lan78xx_net *dev = netdev_priv(netdev);4279 4280	if (skb->len > LAN78XX_TSO_SIZE(dev))4281		features &= ~NETIF_F_GSO_MASK;4282 4283	features = vlan_features_check(skb, features);4284	features = vxlan_features_check(skb, features);4285 4286	return features;4287}4288 4289static const struct net_device_ops lan78xx_netdev_ops = {4290	.ndo_open		= lan78xx_open,4291	.ndo_stop		= lan78xx_stop,4292	.ndo_start_xmit		= lan78xx_start_xmit,4293	.ndo_tx_timeout		= lan78xx_tx_timeout,4294	.ndo_change_mtu		= lan78xx_change_mtu,4295	.ndo_set_mac_address	= lan78xx_set_mac_addr,4296	.ndo_validate_addr	= eth_validate_addr,4297	.ndo_eth_ioctl		= phy_do_ioctl_running,4298	.ndo_set_rx_mode	= lan78xx_set_multicast,4299	.ndo_set_features	= lan78xx_set_features,4300	.ndo_vlan_rx_add_vid	= lan78xx_vlan_rx_add_vid,4301	.ndo_vlan_rx_kill_vid	= lan78xx_vlan_rx_kill_vid,4302	.ndo_features_check	= lan78xx_features_check,4303};4304 4305static void lan78xx_stat_monitor(struct timer_list *t)4306{4307	struct lan78xx_net *dev = from_timer(dev, t, stat_monitor);4308 4309	lan78xx_defer_kevent(dev, EVENT_STAT_UPDATE);4310}4311 4312static int lan78xx_probe(struct usb_interface *intf,4313			 const struct usb_device_id *id)4314{4315	struct usb_host_endpoint *ep_blkin, *ep_blkout, *ep_intr;4316	struct lan78xx_net *dev;4317	struct net_device *netdev;4318	struct usb_device *udev;4319	int ret;4320	unsigned int maxp;4321	unsigned int period;4322	u8 *buf = NULL;4323 4324	udev = interface_to_usbdev(intf);4325	udev = usb_get_dev(udev);4326 4327	netdev = alloc_etherdev(sizeof(struct lan78xx_net));4328	if (!netdev) {4329		dev_err(&intf->dev, "Error: OOM\n");4330		ret = -ENOMEM;4331		goto out1;4332	}4333 4334	/* netdev_printk() needs this */4335	SET_NETDEV_DEV(netdev, &intf->dev);4336 4337	dev = netdev_priv(netdev);4338	dev->udev = udev;4339	dev->intf = intf;4340	dev->net = netdev;4341	dev->msg_enable = netif_msg_init(msg_level, NETIF_MSG_DRV4342					| NETIF_MSG_PROBE | NETIF_MSG_LINK);4343 4344	skb_queue_head_init(&dev->rxq);4345	skb_queue_head_init(&dev->txq);4346	skb_queue_head_init(&dev->rxq_done);4347	skb_queue_head_init(&dev->txq_pend);4348	skb_queue_head_init(&dev->rxq_overflow);4349	mutex_init(&dev->phy_mutex);4350	mutex_init(&dev->dev_mutex);4351 4352	ret = lan78xx_urb_config_init(dev);4353	if (ret < 0)4354		goto out2;4355 4356	ret = lan78xx_alloc_tx_resources(dev);4357	if (ret < 0)4358		goto out2;4359 4360	ret = lan78xx_alloc_rx_resources(dev);4361	if (ret < 0)4362		goto out3;4363 4364	/* MTU range: 68 - 9000 */4365	netdev->max_mtu = MAX_SINGLE_PACKET_SIZE;4366 4367	netif_set_tso_max_size(netdev, LAN78XX_TSO_SIZE(dev));4368 4369	netif_napi_add(netdev, &dev->napi, lan78xx_poll);4370 4371	INIT_DELAYED_WORK(&dev->wq, lan78xx_delayedwork);4372	init_usb_anchor(&dev->deferred);4373 4374	netdev->netdev_ops = &lan78xx_netdev_ops;4375	netdev->watchdog_timeo = TX_TIMEOUT_JIFFIES;4376	netdev->ethtool_ops = &lan78xx_ethtool_ops;4377 4378	dev->delta = 1;4379	timer_setup(&dev->stat_monitor, lan78xx_stat_monitor, 0);4380 4381	mutex_init(&dev->stats.access_lock);4382 4383	if (intf->cur_altsetting->desc.bNumEndpoints < 3) {4384		ret = -ENODEV;4385		goto out4;4386	}4387 4388	dev->pipe_in = usb_rcvbulkpipe(udev, BULK_IN_PIPE);4389	ep_blkin = usb_pipe_endpoint(udev, dev->pipe_in);4390	if (!ep_blkin || !usb_endpoint_is_bulk_in(&ep_blkin->desc)) {4391		ret = -ENODEV;4392		goto out4;4393	}4394 4395	dev->pipe_out = usb_sndbulkpipe(udev, BULK_OUT_PIPE);4396	ep_blkout = usb_pipe_endpoint(udev, dev->pipe_out);4397	if (!ep_blkout || !usb_endpoint_is_bulk_out(&ep_blkout->desc)) {4398		ret = -ENODEV;4399		goto out4;4400	}4401 4402	ep_intr = &intf->cur_altsetting->endpoint[2];4403	if (!usb_endpoint_is_int_in(&ep_intr->desc)) {4404		ret = -ENODEV;4405		goto out4;4406	}4407 4408	dev->pipe_intr = usb_rcvintpipe(dev->udev,4409					usb_endpoint_num(&ep_intr->desc));4410 4411	ret = lan78xx_bind(dev, intf);4412	if (ret < 0)4413		goto out4;4414 4415	period = ep_intr->desc.bInterval;4416	maxp = usb_maxpacket(dev->udev, dev->pipe_intr);4417	buf = kmalloc(maxp, GFP_KERNEL);4418	if (!buf) {4419		ret = -ENOMEM;4420		goto out5;4421	}4422 4423	dev->urb_intr = usb_alloc_urb(0, GFP_KERNEL);4424	if (!dev->urb_intr) {4425		ret = -ENOMEM;4426		goto out6;4427	} else {4428		usb_fill_int_urb(dev->urb_intr, dev->udev,4429				 dev->pipe_intr, buf, maxp,4430				 intr_complete, dev, period);4431		dev->urb_intr->transfer_flags |= URB_FREE_BUFFER;4432	}4433 4434	dev->maxpacket = usb_maxpacket(dev->udev, dev->pipe_out);4435 4436	/* Reject broken descriptors. */4437	if (dev->maxpacket == 0) {4438		ret = -ENODEV;4439		goto out6;4440	}4441 4442	/* driver requires remote-wakeup capability during autosuspend. */4443	intf->needs_remote_wakeup = 1;4444 4445	ret = lan78xx_phy_init(dev);4446	if (ret < 0)4447		goto out7;4448 4449	ret = register_netdev(netdev);4450	if (ret != 0) {4451		netif_err(dev, probe, netdev, "couldn't register the device\n");4452		goto out8;4453	}4454 4455	usb_set_intfdata(intf, dev);4456 4457	ret = device_set_wakeup_enable(&udev->dev, true);4458 4459	 /* Default delay of 2sec has more overhead than advantage.4460	  * Set to 10sec as default.4461	  */4462	pm_runtime_set_autosuspend_delay(&udev->dev,4463					 DEFAULT_AUTOSUSPEND_DELAY);4464 4465	return 0;4466 4467out8:4468	phy_disconnect(netdev->phydev);4469out7:4470	usb_free_urb(dev->urb_intr);4471out6:4472	kfree(buf);4473out5:4474	lan78xx_unbind(dev, intf);4475out4:4476	netif_napi_del(&dev->napi);4477	lan78xx_free_rx_resources(dev);4478out3:4479	lan78xx_free_tx_resources(dev);4480out2:4481	free_netdev(netdev);4482out1:4483	usb_put_dev(udev);4484 4485	return ret;4486}4487 4488static u16 lan78xx_wakeframe_crc16(const u8 *buf, int len)4489{4490	const u16 crc16poly = 0x8005;4491	int i;4492	u16 bit, crc, msb;4493	u8 data;4494 4495	crc = 0xFFFF;4496	for (i = 0; i < len; i++) {4497		data = *buf++;4498		for (bit = 0; bit < 8; bit++) {4499			msb = crc >> 15;4500			crc <<= 1;4501 4502			if (msb ^ (u16)(data & 1)) {4503				crc ^= crc16poly;4504				crc |= (u16)0x0001U;4505			}4506			data >>= 1;4507		}4508	}4509 4510	return crc;4511}4512 4513static int lan78xx_set_auto_suspend(struct lan78xx_net *dev)4514{4515	u32 buf;4516	int ret;4517 4518	ret = lan78xx_stop_tx_path(dev);4519	if (ret < 0)4520		return ret;4521 4522	ret = lan78xx_stop_rx_path(dev);4523	if (ret < 0)4524		return ret;4525 4526	/* auto suspend (selective suspend) */4527 4528	ret = lan78xx_write_reg(dev, WUCSR, 0);4529	if (ret < 0)4530		return ret;4531	ret = lan78xx_write_reg(dev, WUCSR2, 0);4532	if (ret < 0)4533		return ret;4534	ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);4535	if (ret < 0)4536		return ret;4537 4538	/* set goodframe wakeup */4539 4540	ret = lan78xx_read_reg(dev, WUCSR, &buf);4541	if (ret < 0)4542		return ret;4543 4544	buf |= WUCSR_RFE_WAKE_EN_;4545	buf |= WUCSR_STORE_WAKE_;4546 4547	ret = lan78xx_write_reg(dev, WUCSR, buf);4548	if (ret < 0)4549		return ret;4550 4551	ret = lan78xx_read_reg(dev, PMT_CTL, &buf);4552	if (ret < 0)4553		return ret;4554 4555	buf &= ~PMT_CTL_RES_CLR_WKP_EN_;4556	buf |= PMT_CTL_RES_CLR_WKP_STS_;4557	buf |= PMT_CTL_PHY_WAKE_EN_;4558	buf |= PMT_CTL_WOL_EN_;4559	buf &= ~PMT_CTL_SUS_MODE_MASK_;4560	buf |= PMT_CTL_SUS_MODE_3_;4561 4562	ret = lan78xx_write_reg(dev, PMT_CTL, buf);4563	if (ret < 0)4564		return ret;4565 4566	ret = lan78xx_read_reg(dev, PMT_CTL, &buf);4567	if (ret < 0)4568		return ret;4569 4570	buf |= PMT_CTL_WUPS_MASK_;4571 4572	ret = lan78xx_write_reg(dev, PMT_CTL, buf);4573	if (ret < 0)4574		return ret;4575 4576	ret = lan78xx_start_rx_path(dev);4577 4578	return ret;4579}4580 4581static int lan78xx_set_suspend(struct lan78xx_net *dev, u32 wol)4582{4583	const u8 ipv4_multicast[3] = { 0x01, 0x00, 0x5E };4584	const u8 ipv6_multicast[3] = { 0x33, 0x33 };4585	const u8 arp_type[2] = { 0x08, 0x06 };4586	u32 temp_pmt_ctl;4587	int mask_index;4588	u32 temp_wucsr;4589	u32 buf;4590	u16 crc;4591	int ret;4592 4593	ret = lan78xx_stop_tx_path(dev);4594	if (ret < 0)4595		return ret;4596	ret = lan78xx_stop_rx_path(dev);4597	if (ret < 0)4598		return ret;4599 4600	ret = lan78xx_write_reg(dev, WUCSR, 0);4601	if (ret < 0)4602		return ret;4603	ret = lan78xx_write_reg(dev, WUCSR2, 0);4604	if (ret < 0)4605		return ret;4606	ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);4607	if (ret < 0)4608		return ret;4609 4610	temp_wucsr = 0;4611 4612	temp_pmt_ctl = 0;4613 4614	ret = lan78xx_read_reg(dev, PMT_CTL, &temp_pmt_ctl);4615	if (ret < 0)4616		return ret;4617 4618	temp_pmt_ctl &= ~PMT_CTL_RES_CLR_WKP_EN_;4619	temp_pmt_ctl |= PMT_CTL_RES_CLR_WKP_STS_;4620 4621	for (mask_index = 0; mask_index < NUM_OF_WUF_CFG; mask_index++) {4622		ret = lan78xx_write_reg(dev, WUF_CFG(mask_index), 0);4623		if (ret < 0)4624			return ret;4625	}4626 4627	mask_index = 0;4628	if (wol & WAKE_PHY) {4629		temp_pmt_ctl |= PMT_CTL_PHY_WAKE_EN_;4630 4631		temp_pmt_ctl |= PMT_CTL_WOL_EN_;4632		temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;4633		temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;4634	}4635	if (wol & WAKE_MAGIC) {4636		temp_wucsr |= WUCSR_MPEN_;4637 4638		temp_pmt_ctl |= PMT_CTL_WOL_EN_;4639		temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;4640		temp_pmt_ctl |= PMT_CTL_SUS_MODE_3_;4641	}4642	if (wol & WAKE_BCAST) {4643		temp_wucsr |= WUCSR_BCST_EN_;4644 4645		temp_pmt_ctl |= PMT_CTL_WOL_EN_;4646		temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;4647		temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;4648	}4649	if (wol & WAKE_MCAST) {4650		temp_wucsr |= WUCSR_WAKE_EN_;4651 4652		/* set WUF_CFG & WUF_MASK for IPv4 Multicast */4653		crc = lan78xx_wakeframe_crc16(ipv4_multicast, 3);4654		ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),4655					WUF_CFGX_EN_ |4656					WUF_CFGX_TYPE_MCAST_ |4657					(0 << WUF_CFGX_OFFSET_SHIFT_) |4658					(crc & WUF_CFGX_CRC16_MASK_));4659		if (ret < 0)4660			return ret;4661 4662		ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 7);4663		if (ret < 0)4664			return ret;4665		ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);4666		if (ret < 0)4667			return ret;4668		ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);4669		if (ret < 0)4670			return ret;4671		ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);4672		if (ret < 0)4673			return ret;4674 4675		mask_index++;4676 4677		/* for IPv6 Multicast */4678		crc = lan78xx_wakeframe_crc16(ipv6_multicast, 2);4679		ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),4680					WUF_CFGX_EN_ |4681					WUF_CFGX_TYPE_MCAST_ |4682					(0 << WUF_CFGX_OFFSET_SHIFT_) |4683					(crc & WUF_CFGX_CRC16_MASK_));4684		if (ret < 0)4685			return ret;4686 4687		ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 3);4688		if (ret < 0)4689			return ret;4690		ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);4691		if (ret < 0)4692			return ret;4693		ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);4694		if (ret < 0)4695			return ret;4696		ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);4697		if (ret < 0)4698			return ret;4699 4700		mask_index++;4701 4702		temp_pmt_ctl |= PMT_CTL_WOL_EN_;4703		temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;4704		temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;4705	}4706	if (wol & WAKE_UCAST) {4707		temp_wucsr |= WUCSR_PFDA_EN_;4708 4709		temp_pmt_ctl |= PMT_CTL_WOL_EN_;4710		temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;4711		temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;4712	}4713	if (wol & WAKE_ARP) {4714		temp_wucsr |= WUCSR_WAKE_EN_;4715 4716		/* set WUF_CFG & WUF_MASK4717		 * for packettype (offset 12,13) = ARP (0x0806)4718		 */4719		crc = lan78xx_wakeframe_crc16(arp_type, 2);4720		ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),4721					WUF_CFGX_EN_ |4722					WUF_CFGX_TYPE_ALL_ |4723					(0 << WUF_CFGX_OFFSET_SHIFT_) |4724					(crc & WUF_CFGX_CRC16_MASK_));4725		if (ret < 0)4726			return ret;4727 4728		ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 0x3000);4729		if (ret < 0)4730			return ret;4731		ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);4732		if (ret < 0)4733			return ret;4734		ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);4735		if (ret < 0)4736			return ret;4737		ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);4738		if (ret < 0)4739			return ret;4740 4741		mask_index++;4742 4743		temp_pmt_ctl |= PMT_CTL_WOL_EN_;4744		temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;4745		temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;4746	}4747 4748	ret = lan78xx_write_reg(dev, WUCSR, temp_wucsr);4749	if (ret < 0)4750		return ret;4751 4752	/* when multiple WOL bits are set */4753	if (hweight_long((unsigned long)wol) > 1) {4754		temp_pmt_ctl |= PMT_CTL_WOL_EN_;4755		temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;4756		temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;4757	}4758	ret = lan78xx_write_reg(dev, PMT_CTL, temp_pmt_ctl);4759	if (ret < 0)4760		return ret;4761 4762	/* clear WUPS */4763	ret = lan78xx_read_reg(dev, PMT_CTL, &buf);4764	if (ret < 0)4765		return ret;4766 4767	buf |= PMT_CTL_WUPS_MASK_;4768 4769	ret = lan78xx_write_reg(dev, PMT_CTL, buf);4770	if (ret < 0)4771		return ret;4772 4773	ret = lan78xx_start_rx_path(dev);4774 4775	return ret;4776}4777 4778static int lan78xx_suspend(struct usb_interface *intf, pm_message_t message)4779{4780	struct lan78xx_net *dev = usb_get_intfdata(intf);4781	bool dev_open;4782	int ret;4783 4784	mutex_lock(&dev->dev_mutex);4785 4786	netif_dbg(dev, ifdown, dev->net,4787		  "suspending: pm event %#x", message.event);4788 4789	dev_open = test_bit(EVENT_DEV_OPEN, &dev->flags);4790 4791	if (dev_open) {4792		spin_lock_irq(&dev->txq.lock);4793		/* don't autosuspend while transmitting */4794		if ((skb_queue_len(&dev->txq) ||4795		     skb_queue_len(&dev->txq_pend)) &&4796		    PMSG_IS_AUTO(message)) {4797			spin_unlock_irq(&dev->txq.lock);4798			ret = -EBUSY;4799			goto out;4800		} else {4801			set_bit(EVENT_DEV_ASLEEP, &dev->flags);4802			spin_unlock_irq(&dev->txq.lock);4803		}4804 4805		/* stop RX */4806		ret = lan78xx_stop_rx_path(dev);4807		if (ret < 0)4808			goto out;4809 4810		ret = lan78xx_flush_rx_fifo(dev);4811		if (ret < 0)4812			goto out;4813 4814		/* stop Tx */4815		ret = lan78xx_stop_tx_path(dev);4816		if (ret < 0)4817			goto out;4818 4819		/* empty out the Rx and Tx queues */4820		netif_device_detach(dev->net);4821		lan78xx_terminate_urbs(dev);4822		usb_kill_urb(dev->urb_intr);4823 4824		/* reattach */4825		netif_device_attach(dev->net);4826 4827		del_timer(&dev->stat_monitor);4828 4829		if (PMSG_IS_AUTO(message)) {4830			ret = lan78xx_set_auto_suspend(dev);4831			if (ret < 0)4832				goto out;4833		} else {4834			struct lan78xx_priv *pdata;4835 4836			pdata = (struct lan78xx_priv *)(dev->data[0]);4837			netif_carrier_off(dev->net);4838			ret = lan78xx_set_suspend(dev, pdata->wol);4839			if (ret < 0)4840				goto out;4841		}4842	} else {4843		/* Interface is down; don't allow WOL and PHY4844		 * events to wake up the host4845		 */4846		u32 buf;4847 4848		set_bit(EVENT_DEV_ASLEEP, &dev->flags);4849 4850		ret = lan78xx_write_reg(dev, WUCSR, 0);4851		if (ret < 0)4852			goto out;4853		ret = lan78xx_write_reg(dev, WUCSR2, 0);4854		if (ret < 0)4855			goto out;4856 4857		ret = lan78xx_read_reg(dev, PMT_CTL, &buf);4858		if (ret < 0)4859			goto out;4860 4861		buf &= ~PMT_CTL_RES_CLR_WKP_EN_;4862		buf |= PMT_CTL_RES_CLR_WKP_STS_;4863		buf &= ~PMT_CTL_SUS_MODE_MASK_;4864		buf |= PMT_CTL_SUS_MODE_3_;4865 4866		ret = lan78xx_write_reg(dev, PMT_CTL, buf);4867		if (ret < 0)4868			goto out;4869 4870		ret = lan78xx_read_reg(dev, PMT_CTL, &buf);4871		if (ret < 0)4872			goto out;4873 4874		buf |= PMT_CTL_WUPS_MASK_;4875 4876		ret = lan78xx_write_reg(dev, PMT_CTL, buf);4877		if (ret < 0)4878			goto out;4879	}4880 4881	ret = 0;4882out:4883	mutex_unlock(&dev->dev_mutex);4884 4885	return ret;4886}4887 4888static bool lan78xx_submit_deferred_urbs(struct lan78xx_net *dev)4889{4890	bool pipe_halted = false;4891	struct urb *urb;4892 4893	while ((urb = usb_get_from_anchor(&dev->deferred))) {4894		struct sk_buff *skb = urb->context;4895		int ret;4896 4897		if (!netif_device_present(dev->net) ||4898		    !netif_carrier_ok(dev->net) ||4899		    pipe_halted) {4900			lan78xx_release_tx_buf(dev, skb);4901			continue;4902		}4903 4904		ret = usb_submit_urb(urb, GFP_ATOMIC);4905 4906		if (ret == 0) {4907			netif_trans_update(dev->net);4908			lan78xx_queue_skb(&dev->txq, skb, tx_start);4909		} else {4910			if (ret == -EPIPE) {4911				netif_stop_queue(dev->net);4912				pipe_halted = true;4913			} else if (ret == -ENODEV) {4914				netif_device_detach(dev->net);4915			}4916 4917			lan78xx_release_tx_buf(dev, skb);4918		}4919	}4920 4921	return pipe_halted;4922}4923 4924static int lan78xx_resume(struct usb_interface *intf)4925{4926	struct lan78xx_net *dev = usb_get_intfdata(intf);4927	bool dev_open;4928	int ret;4929 4930	mutex_lock(&dev->dev_mutex);4931 4932	netif_dbg(dev, ifup, dev->net, "resuming device");4933 4934	dev_open = test_bit(EVENT_DEV_OPEN, &dev->flags);4935 4936	if (dev_open) {4937		bool pipe_halted = false;4938 4939		ret = lan78xx_flush_tx_fifo(dev);4940		if (ret < 0)4941			goto out;4942 4943		if (dev->urb_intr) {4944			int ret = usb_submit_urb(dev->urb_intr, GFP_KERNEL);4945 4946			if (ret < 0) {4947				if (ret == -ENODEV)4948					netif_device_detach(dev->net);4949				netdev_warn(dev->net, "Failed to submit intr URB");4950			}4951		}4952 4953		spin_lock_irq(&dev->txq.lock);4954 4955		if (netif_device_present(dev->net)) {4956			pipe_halted = lan78xx_submit_deferred_urbs(dev);4957 4958			if (pipe_halted)4959				lan78xx_defer_kevent(dev, EVENT_TX_HALT);4960		}4961 4962		clear_bit(EVENT_DEV_ASLEEP, &dev->flags);4963 4964		spin_unlock_irq(&dev->txq.lock);4965 4966		if (!pipe_halted &&4967		    netif_device_present(dev->net) &&4968		    (lan78xx_tx_pend_data_len(dev) < lan78xx_tx_urb_space(dev)))4969			netif_start_queue(dev->net);4970 4971		ret = lan78xx_start_tx_path(dev);4972		if (ret < 0)4973			goto out;4974 4975		napi_schedule(&dev->napi);4976 4977		if (!timer_pending(&dev->stat_monitor)) {4978			dev->delta = 1;4979			mod_timer(&dev->stat_monitor,4980				  jiffies + STAT_UPDATE_TIMER);4981		}4982 4983	} else {4984		clear_bit(EVENT_DEV_ASLEEP, &dev->flags);4985	}4986 4987	ret = lan78xx_write_reg(dev, WUCSR2, 0);4988	if (ret < 0)4989		goto out;4990	ret = lan78xx_write_reg(dev, WUCSR, 0);4991	if (ret < 0)4992		goto out;4993	ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);4994	if (ret < 0)4995		goto out;4996 4997	ret = lan78xx_write_reg(dev, WUCSR2, WUCSR2_NS_RCD_ |4998					     WUCSR2_ARP_RCD_ |4999					     WUCSR2_IPV6_TCPSYN_RCD_ |5000					     WUCSR2_IPV4_TCPSYN_RCD_);5001	if (ret < 0)5002		goto out;5003 5004	ret = lan78xx_write_reg(dev, WUCSR, WUCSR_EEE_TX_WAKE_ |5005					    WUCSR_EEE_RX_WAKE_ |5006					    WUCSR_PFDA_FR_ |5007					    WUCSR_RFE_WAKE_FR_ |5008					    WUCSR_WUFR_ |5009					    WUCSR_MPR_ |5010					    WUCSR_BCST_FR_);5011	if (ret < 0)5012		goto out;5013 5014	ret = 0;5015out:5016	mutex_unlock(&dev->dev_mutex);5017 5018	return ret;5019}5020 5021static int lan78xx_reset_resume(struct usb_interface *intf)5022{5023	struct lan78xx_net *dev = usb_get_intfdata(intf);5024	int ret;5025 5026	netif_dbg(dev, ifup, dev->net, "(reset) resuming device");5027 5028	ret = lan78xx_reset(dev);5029	if (ret < 0)5030		return ret;5031 5032	phy_start(dev->net->phydev);5033 5034	ret = lan78xx_resume(intf);5035 5036	return ret;5037}5038 5039static const struct usb_device_id products[] = {5040	{5041	/* LAN7800 USB Gigabit Ethernet Device */5042	USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7800_USB_PRODUCT_ID),5043	},5044	{5045	/* LAN7850 USB Gigabit Ethernet Device */5046	USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7850_USB_PRODUCT_ID),5047	},5048	{5049	/* LAN7801 USB Gigabit Ethernet Device */5050	USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7801_USB_PRODUCT_ID),5051	},5052	{5053	/* ATM2-AF USB Gigabit Ethernet Device */5054	USB_DEVICE(AT29M2AF_USB_VENDOR_ID, AT29M2AF_USB_PRODUCT_ID),5055	},5056	{},5057};5058MODULE_DEVICE_TABLE(usb, products);5059 5060static struct usb_driver lan78xx_driver = {5061	.name			= DRIVER_NAME,5062	.id_table		= products,5063	.probe			= lan78xx_probe,5064	.disconnect		= lan78xx_disconnect,5065	.suspend		= lan78xx_suspend,5066	.resume			= lan78xx_resume,5067	.reset_resume		= lan78xx_reset_resume,5068	.supports_autosuspend	= 1,5069	.disable_hub_initiated_lpm = 1,5070};5071 5072module_usb_driver(lan78xx_driver);5073 5074MODULE_AUTHOR(DRIVER_AUTHOR);5075MODULE_DESCRIPTION(DRIVER_DESC);5076MODULE_LICENSE("GPL");5077