1// SPDX-License-Identifier: GPL-2.0+
   2/*
   3 * Copyright (C) 2015 Microchip Technology
 
 
 
 
 
 
 
 
 
 
 
 
 
   4 */
 
   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		3
  40
  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			9216
  56#define FLOW_ON_HS			8704
  57
  58/* Flow control turned off when Rx FIFO level falls below this level (bytes) */
  59#define FLOW_OFF_SS			4096
  60#define FLOW_OFF_HS			1024
  61
  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			2
  72
  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			1
  83#define	MII_WRITE			0
  84
  85#define EEPROM_INDICATOR		(0xA5)
  86#define EEPROM_MAC_OFFSET		(0x01)
  87#define MAX_EEPROM_SIZE			512
  88#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			10
  96#define TX_SS_URB_NUM			TX_URB_NUM
  97#define TX_HS_URB_NUM			TX_URB_NUM
  98#define TX_FS_URB_NUM			TX_URB_NUM
  99
 100/* A single URB buffer must be large enough to hold a complete jumbo packet
 101 */
 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			30
 107#define RX_HS_URB_NUM			10
 108#define RX_FS_URB_NUM			10
 109#define RX_SS_URB_SIZE			TX_SS_URB_SIZE
 110#define RX_HS_URB_SIZE			TX_HS_URB_SIZE
 111#define RX_FS_URB_SIZE			TX_FS_URB_SIZE
 112
 113#define SS_BURST_CAP_SIZE		RX_SS_URB_SIZE
 114#define SS_BULK_IN_DELAY		0x2000
 115#define HS_BURST_CAP_SIZE		RX_HS_URB_SIZE
 116#define HS_BULK_IN_DELAY		0x2000
 117#define FS_BURST_CAP_SIZE		RX_FS_URB_SIZE
 118#define FS_BULK_IN_DELAY		0x2000
 119
 120#define TX_CMD_LEN			8
 121#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			10
 125#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			1
 130#define BULK_OUT_PIPE			2
 131
 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		1
 143
 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	WUCSR
 346};
 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_start
 373};
 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			0
 384#define EVENT_RX_HALT			1
 385#define EVENT_RX_MEMORY			2
 386#define EVENT_STS_SPLIT			3
 387#define EVENT_LINK_RESET		4
 388#define EVENT_RX_PAUSED			5
 389#define EVENT_DEV_WAKING		6
 390#define EVENT_DEV_ASLEEP		7
 391#define EVENT_DEV_OPEN			8
 392#define EVENT_STAT_UPDATE		9
 393#define EVENT_DEV_DISCONNECT		10
 394
 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	else
 843		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	else
 958		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	else
1339		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 MDIO
1375	 * bus can result in the MAC interface locking up and not
1376	 * 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 further
1392	 * 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 keventd
1508 *
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 failure
1578	 * to load data from EEPROM
1579	 */
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	else
1605		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	if (wol->wolopts & ~WAKE_ALL)
1656		return -EINVAL;
1657
1658	ret = usb_autopm_get_interface(dev->intf);
1659	if (ret < 0)
1660		return ret;
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	else
1875		return (sizeof(lan78xx_regs) + PHY_REG_SIZE);
1876}
1877
1878static void
1879lan78xx_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	else
2111		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_unlock
2169	 * 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	else
2368		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				phy_device_free(phydev);
2384			} else {
2385				phy_unregister_fixup_for_uid(PHY_KSZ9031RNX,
2386							     0xfffffff0);
2387				phy_unregister_fixup_for_uid(PHY_LAN8835,
2388							     0xfffffff0);
2389			}
2390		}
2391		return -EIO;
2392	}
2393
2394	/* MAC doesn't support 1000T Half */
2395	phy_remove_link_mode(phydev, ETHTOOL_LINK_MODE_1000baseT_Half_BIT);
2396
2397	/* support both flow controls */
2398	dev->fc_request_control = (FLOW_CTRL_RX | FLOW_CTRL_TX);
2399	linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2400			   phydev->advertising);
2401	linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
2402			   phydev->advertising);
2403	mii_adv = (u32)mii_advertise_flowctrl(dev->fc_request_control);
2404	mii_adv_to_linkmode_adv_t(fc, mii_adv);
2405	linkmode_or(phydev->advertising, fc, phydev->advertising);
2406
2407	phy_support_eee(phydev);
2408
2409	if (phydev->mdio.dev.of_node) {
2410		u32 reg;
2411		int len;
2412
2413		len = of_property_count_elems_of_size(phydev->mdio.dev.of_node,
2414						      "microchip,led-modes",
2415						      sizeof(u32));
2416		if (len >= 0) {
2417			/* Ensure the appropriate LEDs are enabled */
2418			lan78xx_read_reg(dev, HW_CFG, &reg);
2419			reg &= ~(HW_CFG_LED0_EN_ |
2420				 HW_CFG_LED1_EN_ |
2421				 HW_CFG_LED2_EN_ |
2422				 HW_CFG_LED3_EN_);
2423			reg |= (len > 0) * HW_CFG_LED0_EN_ |
2424				(len > 1) * HW_CFG_LED1_EN_ |
2425				(len > 2) * HW_CFG_LED2_EN_ |
2426				(len > 3) * HW_CFG_LED3_EN_;
2427			lan78xx_write_reg(dev, HW_CFG, reg);
2428		}
2429	}
2430
2431	genphy_config_aneg(phydev);
2432
2433	dev->fc_autoneg = phydev->autoneg;
2434
 
 
 
 
2435	return 0;
 
 
 
 
 
 
2436}
2437
2438static int lan78xx_set_rx_max_frame_length(struct lan78xx_net *dev, int size)
2439{
 
2440	u32 buf;
2441	bool rxenabled;
2442
2443	lan78xx_read_reg(dev, MAC_RX, &buf);
2444
2445	rxenabled = ((buf & MAC_RX_RXEN_) != 0);
2446
2447	if (rxenabled) {
2448		buf &= ~MAC_RX_RXEN_;
2449		lan78xx_write_reg(dev, MAC_RX, buf);
2450	}
2451
2452	/* add 4 to size for FCS */
2453	buf &= ~MAC_RX_MAX_SIZE_MASK_;
2454	buf |= (((size + 4) << MAC_RX_MAX_SIZE_SHIFT_) & MAC_RX_MAX_SIZE_MASK_);
2455
2456	lan78xx_write_reg(dev, MAC_RX, buf);
2457
2458	if (rxenabled) {
2459		buf |= MAC_RX_RXEN_;
2460		lan78xx_write_reg(dev, MAC_RX, buf);
2461	}
2462
2463	return 0;
2464}
2465
2466static int unlink_urbs(struct lan78xx_net *dev, struct sk_buff_head *q)
2467{
2468	struct sk_buff *skb;
2469	unsigned long flags;
2470	int count = 0;
2471
2472	spin_lock_irqsave(&q->lock, flags);
2473	while (!skb_queue_empty(q)) {
2474		struct skb_data	*entry;
2475		struct urb *urb;
2476		int ret;
2477
2478		skb_queue_walk(q, skb) {
2479			entry = (struct skb_data *)skb->cb;
2480			if (entry->state != unlink_start)
2481				goto found;
2482		}
2483		break;
2484found:
2485		entry->state = unlink_start;
2486		urb = entry->urb;
2487
2488		/* Get reference count of the URB to avoid it to be
2489		 * freed during usb_unlink_urb, which may trigger
2490		 * use-after-free problem inside usb_unlink_urb since
2491		 * usb_unlink_urb is always racing with .complete
2492		 * handler(include defer_bh).
2493		 */
2494		usb_get_urb(urb);
2495		spin_unlock_irqrestore(&q->lock, flags);
2496		/* during some PM-driven resume scenarios,
2497		 * these (async) unlinks complete immediately
2498		 */
2499		ret = usb_unlink_urb(urb);
2500		if (ret != -EINPROGRESS && ret != 0)
2501			netdev_dbg(dev->net, "unlink urb err, %d\n", ret);
2502		else
2503			count++;
2504		usb_put_urb(urb);
2505		spin_lock_irqsave(&q->lock, flags);
2506	}
2507	spin_unlock_irqrestore(&q->lock, flags);
2508	return count;
2509}
2510
2511static int lan78xx_change_mtu(struct net_device *netdev, int new_mtu)
2512{
2513	struct lan78xx_net *dev = netdev_priv(netdev);
2514	int max_frame_len = RX_MAX_FRAME_LEN(new_mtu);
 
 
2515	int ret;
2516
2517	/* no second zero-length packet read wanted after mtu-sized packets */
2518	if ((max_frame_len % dev->maxpacket) == 0)
2519		return -EDOM;
2520
2521	ret = usb_autopm_get_interface(dev->intf);
2522	if (ret < 0)
2523		return ret;
2524
2525	ret = lan78xx_set_rx_max_frame_length(dev, max_frame_len);
2526	if (!ret)
2527		WRITE_ONCE(netdev->mtu, new_mtu);
2528
2529	usb_autopm_put_interface(dev->intf);
 
 
 
 
 
 
 
 
 
2530
2531	return ret;
2532}
2533
2534static int lan78xx_set_mac_addr(struct net_device *netdev, void *p)
2535{
2536	struct lan78xx_net *dev = netdev_priv(netdev);
2537	struct sockaddr *addr = p;
2538	u32 addr_lo, addr_hi;
 
2539
2540	if (netif_running(netdev))
2541		return -EBUSY;
2542
2543	if (!is_valid_ether_addr(addr->sa_data))
2544		return -EADDRNOTAVAIL;
2545
2546	eth_hw_addr_set(netdev, addr->sa_data);
2547
2548	addr_lo = netdev->dev_addr[0] |
2549		  netdev->dev_addr[1] << 8 |
2550		  netdev->dev_addr[2] << 16 |
2551		  netdev->dev_addr[3] << 24;
2552	addr_hi = netdev->dev_addr[4] |
2553		  netdev->dev_addr[5] << 8;
2554
2555	lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
2556	lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
2557
2558	/* Added to support MAC address changes */
2559	lan78xx_write_reg(dev, MAF_LO(0), addr_lo);
2560	lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_);
2561
2562	return 0;
2563}
2564
2565/* Enable or disable Rx checksum offload engine */
2566static int lan78xx_set_features(struct net_device *netdev,
2567				netdev_features_t features)
2568{
2569	struct lan78xx_net *dev = netdev_priv(netdev);
2570	struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2571	unsigned long flags;
 
2572
2573	spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);
2574
2575	if (features & NETIF_F_RXCSUM) {
2576		pdata->rfe_ctl |= RFE_CTL_TCPUDP_COE_ | RFE_CTL_IP_COE_;
2577		pdata->rfe_ctl |= RFE_CTL_ICMP_COE_ | RFE_CTL_IGMP_COE_;
2578	} else {
2579		pdata->rfe_ctl &= ~(RFE_CTL_TCPUDP_COE_ | RFE_CTL_IP_COE_);
2580		pdata->rfe_ctl &= ~(RFE_CTL_ICMP_COE_ | RFE_CTL_IGMP_COE_);
2581	}
2582
2583	if (features & NETIF_F_HW_VLAN_CTAG_RX)
2584		pdata->rfe_ctl |= RFE_CTL_VLAN_STRIP_;
2585	else
2586		pdata->rfe_ctl &= ~RFE_CTL_VLAN_STRIP_;
2587
2588	if (features & NETIF_F_HW_VLAN_CTAG_FILTER)
2589		pdata->rfe_ctl |= RFE_CTL_VLAN_FILTER_;
2590	else
2591		pdata->rfe_ctl &= ~RFE_CTL_VLAN_FILTER_;
2592
2593	spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags);
2594
2595	lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
2596
2597	return 0;
2598}
2599
2600static void lan78xx_deferred_vlan_write(struct work_struct *param)
2601{
2602	struct lan78xx_priv *pdata =
2603			container_of(param, struct lan78xx_priv, set_vlan);
2604	struct lan78xx_net *dev = pdata->dev;
2605
2606	lan78xx_dataport_write(dev, DP_SEL_RSEL_VLAN_DA_, 0,
2607			       DP_SEL_VHF_VLAN_LEN, pdata->vlan_table);
2608}
2609
2610static int lan78xx_vlan_rx_add_vid(struct net_device *netdev,
2611				   __be16 proto, u16 vid)
2612{
2613	struct lan78xx_net *dev = netdev_priv(netdev);
2614	struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2615	u16 vid_bit_index;
2616	u16 vid_dword_index;
2617
2618	vid_dword_index = (vid >> 5) & 0x7F;
2619	vid_bit_index = vid & 0x1F;
2620
2621	pdata->vlan_table[vid_dword_index] |= (1 << vid_bit_index);
2622
2623	/* defer register writes to a sleepable context */
2624	schedule_work(&pdata->set_vlan);
2625
2626	return 0;
2627}
2628
2629static int lan78xx_vlan_rx_kill_vid(struct net_device *netdev,
2630				    __be16 proto, u16 vid)
2631{
2632	struct lan78xx_net *dev = netdev_priv(netdev);
2633	struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2634	u16 vid_bit_index;
2635	u16 vid_dword_index;
2636
2637	vid_dword_index = (vid >> 5) & 0x7F;
2638	vid_bit_index = vid & 0x1F;
2639
2640	pdata->vlan_table[vid_dword_index] &= ~(1 << vid_bit_index);
2641
2642	/* defer register writes to a sleepable context */
2643	schedule_work(&pdata->set_vlan);
2644
2645	return 0;
2646}
2647
2648static void lan78xx_init_ltm(struct lan78xx_net *dev)
2649{
2650	int ret;
2651	u32 buf;
2652	u32 regs[6] = { 0 };
2653
2654	ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
2655	if (buf & USB_CFG1_LTM_ENABLE_) {
2656		u8 temp[2];
2657		/* Get values from EEPROM first */
2658		if (lan78xx_read_eeprom(dev, 0x3F, 2, temp) == 0) {
2659			if (temp[0] == 24) {
2660				ret = lan78xx_read_raw_eeprom(dev,
2661							      temp[1] * 2,
2662							      24,
2663							      (u8 *)regs);
2664				if (ret < 0)
2665					return;
2666			}
2667		} else if (lan78xx_read_otp(dev, 0x3F, 2, temp) == 0) {
2668			if (temp[0] == 24) {
2669				ret = lan78xx_read_raw_otp(dev,
2670							   temp[1] * 2,
2671							   24,
2672							   (u8 *)regs);
2673				if (ret < 0)
2674					return;
2675			}
2676		}
2677	}
2678
2679	lan78xx_write_reg(dev, LTM_BELT_IDLE0, regs[0]);
2680	lan78xx_write_reg(dev, LTM_BELT_IDLE1, regs[1]);
2681	lan78xx_write_reg(dev, LTM_BELT_ACT0, regs[2]);
2682	lan78xx_write_reg(dev, LTM_BELT_ACT1, regs[3]);
2683	lan78xx_write_reg(dev, LTM_INACTIVE0, regs[4]);
2684	lan78xx_write_reg(dev, LTM_INACTIVE1, regs[5]);
2685}
2686
2687static int lan78xx_urb_config_init(struct lan78xx_net *dev)
2688{
2689	int result = 0;
2690
2691	switch (dev->udev->speed) {
2692	case USB_SPEED_SUPER:
2693		dev->rx_urb_size = RX_SS_URB_SIZE;
2694		dev->tx_urb_size = TX_SS_URB_SIZE;
2695		dev->n_rx_urbs = RX_SS_URB_NUM;
2696		dev->n_tx_urbs = TX_SS_URB_NUM;
2697		dev->bulk_in_delay = SS_BULK_IN_DELAY;
2698		dev->burst_cap = SS_BURST_CAP_SIZE / SS_USB_PKT_SIZE;
2699		break;
2700	case USB_SPEED_HIGH:
2701		dev->rx_urb_size = RX_HS_URB_SIZE;
2702		dev->tx_urb_size = TX_HS_URB_SIZE;
2703		dev->n_rx_urbs = RX_HS_URB_NUM;
2704		dev->n_tx_urbs = TX_HS_URB_NUM;
2705		dev->bulk_in_delay = HS_BULK_IN_DELAY;
2706		dev->burst_cap = HS_BURST_CAP_SIZE / HS_USB_PKT_SIZE;
2707		break;
2708	case USB_SPEED_FULL:
2709		dev->rx_urb_size = RX_FS_URB_SIZE;
2710		dev->tx_urb_size = TX_FS_URB_SIZE;
2711		dev->n_rx_urbs = RX_FS_URB_NUM;
2712		dev->n_tx_urbs = TX_FS_URB_NUM;
2713		dev->bulk_in_delay = FS_BULK_IN_DELAY;
2714		dev->burst_cap = FS_BURST_CAP_SIZE / FS_USB_PKT_SIZE;
2715		break;
2716	default:
2717		netdev_warn(dev->net, "USB bus speed not supported\n");
2718		result = -EIO;
2719		break;
2720	}
2721
2722	return result;
2723}
2724
2725static int lan78xx_start_hw(struct lan78xx_net *dev, u32 reg, u32 hw_enable)
2726{
2727	return lan78xx_update_reg(dev, reg, hw_enable, hw_enable);
2728}
2729
2730static int lan78xx_stop_hw(struct lan78xx_net *dev, u32 reg, u32 hw_enabled,
2731			   u32 hw_disabled)
2732{
2733	unsigned long timeout;
2734	bool stopped = true;
2735	int ret;
2736	u32 buf;
2737
2738	/* Stop the h/w block (if not already stopped) */
2739
2740	ret = lan78xx_read_reg(dev, reg, &buf);
2741	if (ret < 0)
2742		return ret;
2743
2744	if (buf & hw_enabled) {
2745		buf &= ~hw_enabled;
2746
2747		ret = lan78xx_write_reg(dev, reg, buf);
2748		if (ret < 0)
2749			return ret;
2750
2751		stopped = false;
2752		timeout = jiffies + HW_DISABLE_TIMEOUT;
2753		do  {
2754			ret = lan78xx_read_reg(dev, reg, &buf);
2755			if (ret < 0)
2756				return ret;
2757
2758			if (buf & hw_disabled)
2759				stopped = true;
2760			else
2761				msleep(HW_DISABLE_DELAY_MS);
2762		} while (!stopped && !time_after(jiffies, timeout));
2763	}
2764
2765	ret = stopped ? 0 : -ETIME;
2766
2767	return ret;
2768}
2769
2770static int lan78xx_flush_fifo(struct lan78xx_net *dev, u32 reg, u32 fifo_flush)
2771{
2772	return lan78xx_update_reg(dev, reg, fifo_flush, fifo_flush);
2773}
2774
2775static int lan78xx_start_tx_path(struct lan78xx_net *dev)
2776{
2777	int ret;
2778
2779	netif_dbg(dev, drv, dev->net, "start tx path");
2780
2781	/* Start the MAC transmitter */
2782
2783	ret = lan78xx_start_hw(dev, MAC_TX, MAC_TX_TXEN_);
2784	if (ret < 0)
2785		return ret;
2786
2787	/* Start the Tx FIFO */
2788
2789	ret = lan78xx_start_hw(dev, FCT_TX_CTL, FCT_TX_CTL_EN_);
2790	if (ret < 0)
2791		return ret;
2792
2793	return 0;
2794}
2795
2796static int lan78xx_stop_tx_path(struct lan78xx_net *dev)
2797{
2798	int ret;
2799
2800	netif_dbg(dev, drv, dev->net, "stop tx path");
2801
2802	/* Stop the Tx FIFO */
2803
2804	ret = lan78xx_stop_hw(dev, FCT_TX_CTL, FCT_TX_CTL_EN_, FCT_TX_CTL_DIS_);
2805	if (ret < 0)
2806		return ret;
2807
2808	/* Stop the MAC transmitter */
2809
2810	ret = lan78xx_stop_hw(dev, MAC_TX, MAC_TX_TXEN_, MAC_TX_TXD_);
2811	if (ret < 0)
2812		return ret;
2813
2814	return 0;
2815}
2816
2817/* The caller must ensure the Tx path is stopped before calling
2818 * lan78xx_flush_tx_fifo().
2819 */
2820static int lan78xx_flush_tx_fifo(struct lan78xx_net *dev)
2821{
2822	return lan78xx_flush_fifo(dev, FCT_TX_CTL, FCT_TX_CTL_RST_);
2823}
2824
2825static int lan78xx_start_rx_path(struct lan78xx_net *dev)
2826{
2827	int ret;
2828
2829	netif_dbg(dev, drv, dev->net, "start rx path");
2830
2831	/* Start the Rx FIFO */
2832
2833	ret = lan78xx_start_hw(dev, FCT_RX_CTL, FCT_RX_CTL_EN_);
2834	if (ret < 0)
2835		return ret;
2836
2837	/* Start the MAC receiver*/
2838
2839	ret = lan78xx_start_hw(dev, MAC_RX, MAC_RX_RXEN_);
2840	if (ret < 0)
2841		return ret;
2842
2843	return 0;
2844}
2845
2846static int lan78xx_stop_rx_path(struct lan78xx_net *dev)
2847{
2848	int ret;
2849
2850	netif_dbg(dev, drv, dev->net, "stop rx path");
2851
2852	/* Stop the MAC receiver */
2853
2854	ret = lan78xx_stop_hw(dev, MAC_RX, MAC_RX_RXEN_, MAC_RX_RXD_);
2855	if (ret < 0)
2856		return ret;
2857
2858	/* Stop the Rx FIFO */
2859
2860	ret = lan78xx_stop_hw(dev, FCT_RX_CTL, FCT_RX_CTL_EN_, FCT_RX_CTL_DIS_);
2861	if (ret < 0)
2862		return ret;
2863
2864	return 0;
2865}
2866
2867/* The caller must ensure the Rx path is stopped before calling
2868 * lan78xx_flush_rx_fifo().
2869 */
2870static int lan78xx_flush_rx_fifo(struct lan78xx_net *dev)
2871{
2872	return lan78xx_flush_fifo(dev, FCT_RX_CTL, FCT_RX_CTL_RST_);
2873}
2874
2875static int lan78xx_reset(struct lan78xx_net *dev)
2876{
2877	struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2878	unsigned long timeout;
2879	int ret;
2880	u32 buf;
2881	u8 sig;
 
2882
2883	ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2884	if (ret < 0)
2885		return ret;
2886
2887	buf |= HW_CFG_LRST_;
2888
2889	ret = lan78xx_write_reg(dev, HW_CFG, buf);
2890	if (ret < 0)
2891		return ret;
2892
2893	timeout = jiffies + HZ;
2894	do {
2895		mdelay(1);
2896		ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2897		if (ret < 0)
2898			return ret;
2899
2900		if (time_after(jiffies, timeout)) {
2901			netdev_warn(dev->net,
2902				    "timeout on completion of LiteReset");
2903			ret = -ETIMEDOUT;
2904			return ret;
2905		}
2906	} while (buf & HW_CFG_LRST_);
2907
2908	lan78xx_init_mac_address(dev);
2909
2910	/* save DEVID for later usage */
2911	ret = lan78xx_read_reg(dev, ID_REV, &buf);
2912	if (ret < 0)
2913		return ret;
2914
2915	dev->chipid = (buf & ID_REV_CHIP_ID_MASK_) >> 16;
2916	dev->chiprev = buf & ID_REV_CHIP_REV_MASK_;
2917
2918	/* Respond to the IN token with a NAK */
2919	ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
2920	if (ret < 0)
2921		return ret;
2922
2923	buf |= USB_CFG_BIR_;
2924
2925	ret = lan78xx_write_reg(dev, USB_CFG0, buf);
2926	if (ret < 0)
2927		return ret;
2928
2929	/* Init LTM */
2930	lan78xx_init_ltm(dev);
2931
2932	ret = lan78xx_write_reg(dev, BURST_CAP, dev->burst_cap);
2933	if (ret < 0)
2934		return ret;
2935
2936	ret = lan78xx_write_reg(dev, BULK_IN_DLY, dev->bulk_in_delay);
2937	if (ret < 0)
2938		return ret;
 
 
 
 
 
 
 
 
 
 
 
 
2939
2940	ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2941	if (ret < 0)
2942		return ret;
2943
 
2944	buf |= HW_CFG_MEF_;
2945	buf |= HW_CFG_CLK125_EN_;
2946	buf |= HW_CFG_REFCLK25_EN_;
2947
2948	ret = lan78xx_write_reg(dev, HW_CFG, buf);
2949	if (ret < 0)
2950		return ret;
2951
2952	ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
2953	if (ret < 0)
2954		return ret;
2955
2956	buf |= USB_CFG_BCE_;
2957
2958	ret = lan78xx_write_reg(dev, USB_CFG0, buf);
2959	if (ret < 0)
2960		return ret;
2961
2962	/* set FIFO sizes */
2963	buf = (MAX_RX_FIFO_SIZE - 512) / 512;
2964
2965	ret = lan78xx_write_reg(dev, FCT_RX_FIFO_END, buf);
2966	if (ret < 0)
2967		return ret;
2968
2969	buf = (MAX_TX_FIFO_SIZE - 512) / 512;
2970
2971	ret = lan78xx_write_reg(dev, FCT_TX_FIFO_END, buf);
2972	if (ret < 0)
2973		return ret;
2974
2975	ret = lan78xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL_);
2976	if (ret < 0)
2977		return ret;
2978
2979	ret = lan78xx_write_reg(dev, FLOW, 0);
2980	if (ret < 0)
2981		return ret;
2982
2983	ret = lan78xx_write_reg(dev, FCT_FLOW, 0);
2984	if (ret < 0)
2985		return ret;
2986
2987	/* Don't need rfe_ctl_lock during initialisation */
2988	ret = lan78xx_read_reg(dev, RFE_CTL, &pdata->rfe_ctl);
2989	if (ret < 0)
2990		return ret;
2991
2992	pdata->rfe_ctl |= RFE_CTL_BCAST_EN_ | RFE_CTL_DA_PERFECT_;
2993
2994	ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
2995	if (ret < 0)
2996		return ret;
2997
2998	/* Enable or disable checksum offload engines */
2999	ret = lan78xx_set_features(dev->net, dev->net->features);
3000	if (ret < 0)
3001		return ret;
3002
3003	lan78xx_set_multicast(dev->net);
3004
3005	/* reset PHY */
3006	ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
3007	if (ret < 0)
3008		return ret;
3009
3010	buf |= PMT_CTL_PHY_RST_;
3011
3012	ret = lan78xx_write_reg(dev, PMT_CTL, buf);
3013	if (ret < 0)
3014		return ret;
3015
3016	timeout = jiffies + HZ;
3017	do {
3018		mdelay(1);
3019		ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
3020		if (ret < 0)
3021			return ret;
3022
3023		if (time_after(jiffies, timeout)) {
3024			netdev_warn(dev->net, "timeout waiting for PHY Reset");
3025			ret = -ETIMEDOUT;
3026			return ret;
3027		}
3028	} while ((buf & PMT_CTL_PHY_RST_) || !(buf & PMT_CTL_READY_));
3029
3030	ret = lan78xx_read_reg(dev, MAC_CR, &buf);
3031	if (ret < 0)
3032		return ret;
3033
3034	/* LAN7801 only has RGMII mode */
3035	if (dev->chipid == ID_REV_CHIP_ID_7801_) {
3036		buf &= ~MAC_CR_GMII_EN_;
3037		/* Enable Auto Duplex and Auto speed */
3038		buf |= MAC_CR_AUTO_DUPLEX_ | MAC_CR_AUTO_SPEED_;
3039	}
3040
3041	if (dev->chipid == ID_REV_CHIP_ID_7800_ ||
3042	    dev->chipid == ID_REV_CHIP_ID_7850_) {
3043		ret = lan78xx_read_raw_eeprom(dev, 0, 1, &sig);
3044		if (!ret && sig != EEPROM_INDICATOR) {
3045			/* Implies there is no external eeprom. Set mac speed */
3046			netdev_info(dev->net, "No External EEPROM. Setting MAC Speed\n");
3047			buf |= MAC_CR_AUTO_DUPLEX_ | MAC_CR_AUTO_SPEED_;
3048		}
3049	}
3050	ret = lan78xx_write_reg(dev, MAC_CR, buf);
3051	if (ret < 0)
3052		return ret;
3053
3054	ret = lan78xx_set_rx_max_frame_length(dev,
3055					      RX_MAX_FRAME_LEN(dev->net->mtu));
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3056
3057	return ret;
3058}
3059
3060static void lan78xx_init_stats(struct lan78xx_net *dev)
3061{
3062	u32 *p;
3063	int i;
3064
3065	/* initialize for stats update
3066	 * some counters are 20bits and some are 32bits
3067	 */
3068	p = (u32 *)&dev->stats.rollover_max;
3069	for (i = 0; i < (sizeof(dev->stats.rollover_max) / (sizeof(u32))); i++)
3070		p[i] = 0xFFFFF;
3071
3072	dev->stats.rollover_max.rx_unicast_byte_count = 0xFFFFFFFF;
3073	dev->stats.rollover_max.rx_broadcast_byte_count = 0xFFFFFFFF;
3074	dev->stats.rollover_max.rx_multicast_byte_count = 0xFFFFFFFF;
3075	dev->stats.rollover_max.eee_rx_lpi_transitions = 0xFFFFFFFF;
3076	dev->stats.rollover_max.eee_rx_lpi_time = 0xFFFFFFFF;
3077	dev->stats.rollover_max.tx_unicast_byte_count = 0xFFFFFFFF;
3078	dev->stats.rollover_max.tx_broadcast_byte_count = 0xFFFFFFFF;
3079	dev->stats.rollover_max.tx_multicast_byte_count = 0xFFFFFFFF;
3080	dev->stats.rollover_max.eee_tx_lpi_transitions = 0xFFFFFFFF;
3081	dev->stats.rollover_max.eee_tx_lpi_time = 0xFFFFFFFF;
3082
3083	set_bit(EVENT_STAT_UPDATE, &dev->flags);
3084}
3085
3086static int lan78xx_open(struct net_device *net)
3087{
3088	struct lan78xx_net *dev = netdev_priv(net);
3089	int ret;
3090
3091	netif_dbg(dev, ifup, dev->net, "open device");
3092
3093	ret = usb_autopm_get_interface(dev->intf);
3094	if (ret < 0)
3095		return ret;
3096
3097	mutex_lock(&dev->dev_mutex);
3098
3099	phy_start(net->phydev);
 
 
3100
3101	netif_dbg(dev, ifup, dev->net, "phy initialised successfully");
 
 
3102
3103	/* for Link Check */
3104	if (dev->urb_intr) {
3105		ret = usb_submit_urb(dev->urb_intr, GFP_KERNEL);
3106		if (ret < 0) {
3107			netif_err(dev, ifup, dev->net,
3108				  "intr submit %d\n", ret);
3109			goto done;
3110		}
3111	}
3112
3113	ret = lan78xx_flush_rx_fifo(dev);
3114	if (ret < 0)
3115		goto done;
3116	ret = lan78xx_flush_tx_fifo(dev);
3117	if (ret < 0)
3118		goto done;
3119
3120	ret = lan78xx_start_tx_path(dev);
3121	if (ret < 0)
3122		goto done;
3123	ret = lan78xx_start_rx_path(dev);
3124	if (ret < 0)
3125		goto done;
3126
3127	lan78xx_init_stats(dev);
3128
3129	set_bit(EVENT_DEV_OPEN, &dev->flags);
3130
3131	netif_start_queue(net);
3132
3133	dev->link_on = false;
3134
3135	napi_enable(&dev->napi);
3136
3137	lan78xx_defer_kevent(dev, EVENT_LINK_RESET);
3138done:
3139	mutex_unlock(&dev->dev_mutex);
3140
3141	if (ret < 0)
3142		usb_autopm_put_interface(dev->intf);
3143
 
3144	return ret;
3145}
3146
3147static void lan78xx_terminate_urbs(struct lan78xx_net *dev)
3148{
3149	DECLARE_WAIT_QUEUE_HEAD_ONSTACK(unlink_wakeup);
3150	DECLARE_WAITQUEUE(wait, current);
3151	int temp;
3152
3153	/* ensure there are no more active urbs */
3154	add_wait_queue(&unlink_wakeup, &wait);
3155	set_current_state(TASK_UNINTERRUPTIBLE);
3156	dev->wait = &unlink_wakeup;
3157	temp = unlink_urbs(dev, &dev->txq) + unlink_urbs(dev, &dev->rxq);
3158
3159	/* maybe wait for deletions to finish. */
3160	while (!skb_queue_empty(&dev->rxq) ||
3161	       !skb_queue_empty(&dev->txq)) {
 
3162		schedule_timeout(msecs_to_jiffies(UNLINK_TIMEOUT_MS));
3163		set_current_state(TASK_UNINTERRUPTIBLE);
3164		netif_dbg(dev, ifdown, dev->net,
3165			  "waited for %d urb completions", temp);
3166	}
3167	set_current_state(TASK_RUNNING);
3168	dev->wait = NULL;
3169	remove_wait_queue(&unlink_wakeup, &wait);
3170
3171	/* empty Rx done, Rx overflow and Tx pend queues
3172	 */
3173	while (!skb_queue_empty(&dev->rxq_done)) {
3174		struct sk_buff *skb = skb_dequeue(&dev->rxq_done);
3175
3176		lan78xx_release_rx_buf(dev, skb);
3177	}
3178
3179	skb_queue_purge(&dev->rxq_overflow);
3180	skb_queue_purge(&dev->txq_pend);
3181}
3182
3183static int lan78xx_stop(struct net_device *net)
3184{
3185	struct lan78xx_net *dev = netdev_priv(net);
3186
3187	netif_dbg(dev, ifup, dev->net, "stop device");
3188
3189	mutex_lock(&dev->dev_mutex);
3190
3191	if (timer_pending(&dev->stat_monitor))
3192		del_timer_sync(&dev->stat_monitor);
3193
 
 
 
 
 
 
 
 
3194	clear_bit(EVENT_DEV_OPEN, &dev->flags);
3195	netif_stop_queue(net);
3196	napi_disable(&dev->napi);
3197
3198	lan78xx_terminate_urbs(dev);
3199
3200	netif_info(dev, ifdown, dev->net,
3201		   "stop stats: rx/tx %lu/%lu, errs %lu/%lu\n",
3202		   net->stats.rx_packets, net->stats.tx_packets,
3203		   net->stats.rx_errors, net->stats.tx_errors);
3204
3205	/* ignore errors that occur stopping the Tx and Rx data paths */
3206	lan78xx_stop_tx_path(dev);
3207	lan78xx_stop_rx_path(dev);
3208
3209	if (net->phydev)
3210		phy_stop(net->phydev);
3211
3212	usb_kill_urb(dev->urb_intr);
3213
 
 
3214	/* deferred work (task, timer, softirq) must also stop.
3215	 * can't flush_scheduled_work() until we drop rtnl (later),
3216	 * else workers could deadlock; so make workers a NOP.
3217	 */
3218	clear_bit(EVENT_TX_HALT, &dev->flags);
3219	clear_bit(EVENT_RX_HALT, &dev->flags);
3220	clear_bit(EVENT_LINK_RESET, &dev->flags);
3221	clear_bit(EVENT_STAT_UPDATE, &dev->flags);
3222
3223	cancel_delayed_work_sync(&dev->wq);
 
3224
3225	usb_autopm_put_interface(dev->intf);
3226
3227	mutex_unlock(&dev->dev_mutex);
3228
3229	return 0;
3230}
3231
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3232static enum skb_state defer_bh(struct lan78xx_net *dev, struct sk_buff *skb,
3233			       struct sk_buff_head *list, enum skb_state state)
3234{
3235	unsigned long flags;
3236	enum skb_state old_state;
3237	struct skb_data *entry = (struct skb_data *)skb->cb;
3238
3239	spin_lock_irqsave(&list->lock, flags);
3240	old_state = entry->state;
3241	entry->state = state;
3242
3243	__skb_unlink(skb, list);
3244	spin_unlock(&list->lock);
3245	spin_lock(&dev->rxq_done.lock);
3246
3247	__skb_queue_tail(&dev->rxq_done, skb);
3248	if (skb_queue_len(&dev->rxq_done) == 1)
3249		napi_schedule(&dev->napi);
3250
3251	spin_unlock_irqrestore(&dev->rxq_done.lock, flags);
 
 
 
3252
3253	return old_state;
3254}
3255
3256static void tx_complete(struct urb *urb)
3257{
3258	struct sk_buff *skb = (struct sk_buff *)urb->context;
3259	struct skb_data *entry = (struct skb_data *)skb->cb;
3260	struct lan78xx_net *dev = entry->dev;
3261
3262	if (urb->status == 0) {
3263		dev->net->stats.tx_packets += entry->num_of_packet;
3264		dev->net->stats.tx_bytes += entry->length;
3265	} else {
3266		dev->net->stats.tx_errors += entry->num_of_packet;
3267
3268		switch (urb->status) {
3269		case -EPIPE:
3270			lan78xx_defer_kevent(dev, EVENT_TX_HALT);
3271			break;
3272
3273		/* software-driven interface shutdown */
3274		case -ECONNRESET:
3275		case -ESHUTDOWN:
3276			netif_dbg(dev, tx_err, dev->net,
3277				  "tx err interface gone %d\n",
3278				  entry->urb->status);
3279			break;
3280
3281		case -EPROTO:
3282		case -ETIME:
3283		case -EILSEQ:
3284			netif_stop_queue(dev->net);
3285			netif_dbg(dev, tx_err, dev->net,
3286				  "tx err queue stopped %d\n",
3287				  entry->urb->status);
3288			break;
3289		default:
3290			netif_dbg(dev, tx_err, dev->net,
3291				  "unknown tx err %d\n",
3292				  entry->urb->status);
3293			break;
3294		}
3295	}
3296
3297	usb_autopm_put_interface_async(dev->intf);
3298
3299	skb_unlink(skb, &dev->txq);
3300
3301	lan78xx_release_tx_buf(dev, skb);
3302
3303	/* Re-schedule NAPI if Tx data pending but no URBs in progress.
3304	 */
3305	if (skb_queue_empty(&dev->txq) &&
3306	    !skb_queue_empty(&dev->txq_pend))
3307		napi_schedule(&dev->napi);
3308}
3309
3310static void lan78xx_queue_skb(struct sk_buff_head *list,
3311			      struct sk_buff *newsk, enum skb_state state)
3312{
3313	struct skb_data *entry = (struct skb_data *)newsk->cb;
3314
3315	__skb_queue_tail(list, newsk);
3316	entry->state = state;
3317}
3318
3319static unsigned int lan78xx_tx_urb_space(struct lan78xx_net *dev)
3320{
3321	return skb_queue_len(&dev->txq_free) * dev->tx_urb_size;
3322}
3323
3324static unsigned int lan78xx_tx_pend_data_len(struct lan78xx_net *dev)
3325{
3326	return dev->tx_pend_data_len;
3327}
3328
3329static void lan78xx_tx_pend_skb_add(struct lan78xx_net *dev,
3330				    struct sk_buff *skb,
3331				    unsigned int *tx_pend_data_len)
3332{
3333	unsigned long flags;
3334
3335	spin_lock_irqsave(&dev->txq_pend.lock, flags);
3336
3337	__skb_queue_tail(&dev->txq_pend, skb);
3338
3339	dev->tx_pend_data_len += skb->len;
3340	*tx_pend_data_len = dev->tx_pend_data_len;
3341
3342	spin_unlock_irqrestore(&dev->txq_pend.lock, flags);
3343}
3344
3345static void lan78xx_tx_pend_skb_head_add(struct lan78xx_net *dev,
3346					 struct sk_buff *skb,
3347					 unsigned int *tx_pend_data_len)
3348{
3349	unsigned long flags;
3350
3351	spin_lock_irqsave(&dev->txq_pend.lock, flags);
3352
3353	__skb_queue_head(&dev->txq_pend, skb);
3354
3355	dev->tx_pend_data_len += skb->len;
3356	*tx_pend_data_len = dev->tx_pend_data_len;
3357
3358	spin_unlock_irqrestore(&dev->txq_pend.lock, flags);
3359}
3360
3361static void lan78xx_tx_pend_skb_get(struct lan78xx_net *dev,
3362				    struct sk_buff **skb,
3363				    unsigned int *tx_pend_data_len)
3364{
3365	unsigned long flags;
3366
3367	spin_lock_irqsave(&dev->txq_pend.lock, flags);
3368
3369	*skb = __skb_dequeue(&dev->txq_pend);
3370	if (*skb)
3371		dev->tx_pend_data_len -= (*skb)->len;
3372	*tx_pend_data_len = dev->tx_pend_data_len;
3373
3374	spin_unlock_irqrestore(&dev->txq_pend.lock, flags);
3375}
3376
3377static netdev_tx_t
3378lan78xx_start_xmit(struct sk_buff *skb, struct net_device *net)
3379{
3380	struct lan78xx_net *dev = netdev_priv(net);
3381	unsigned int tx_pend_data_len;
3382
3383	if (test_bit(EVENT_DEV_ASLEEP, &dev->flags))
3384		schedule_delayed_work(&dev->wq, 0);
3385
3386	skb_tx_timestamp(skb);
3387
3388	lan78xx_tx_pend_skb_add(dev, skb, &tx_pend_data_len);
3389
3390	/* Set up a Tx URB if none is in progress */
 
3391
3392	if (skb_queue_empty(&dev->txq))
3393		napi_schedule(&dev->napi);
3394
3395	/* Stop stack Tx queue if we have enough data to fill
3396	 * all the free Tx URBs.
3397	 */
3398	if (tx_pend_data_len > lan78xx_tx_urb_space(dev)) {
3399		netif_stop_queue(net);
 
 
 
 
 
3400
3401		netif_dbg(dev, hw, dev->net, "tx data len: %u, urb space %u",
3402			  tx_pend_data_len, lan78xx_tx_urb_space(dev));
3403
3404		/* Kick off transmission of pending data */
 
3405
3406		if (!skb_queue_empty(&dev->txq_free))
3407			napi_schedule(&dev->napi);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3408	}
 
 
3409
3410	return NETDEV_TX_OK;
 
 
 
 
 
 
 
 
3411}
3412
3413static int lan78xx_bind(struct lan78xx_net *dev, struct usb_interface *intf)
3414{
3415	struct lan78xx_priv *pdata = NULL;
3416	int ret;
3417	int i;
3418
 
 
3419	dev->data[0] = (unsigned long)kzalloc(sizeof(*pdata), GFP_KERNEL);
3420
3421	pdata = (struct lan78xx_priv *)(dev->data[0]);
3422	if (!pdata) {
3423		netdev_warn(dev->net, "Unable to allocate lan78xx_priv");
3424		return -ENOMEM;
3425	}
3426
3427	pdata->dev = dev;
3428
3429	spin_lock_init(&pdata->rfe_ctl_lock);
3430	mutex_init(&pdata->dataport_mutex);
3431
3432	INIT_WORK(&pdata->set_multicast, lan78xx_deferred_multicast_write);
3433
3434	for (i = 0; i < DP_SEL_VHF_VLAN_LEN; i++)
3435		pdata->vlan_table[i] = 0;
3436
3437	INIT_WORK(&pdata->set_vlan, lan78xx_deferred_vlan_write);
3438
3439	dev->net->features = 0;
3440
3441	if (DEFAULT_TX_CSUM_ENABLE)
3442		dev->net->features |= NETIF_F_HW_CSUM;
3443
3444	if (DEFAULT_RX_CSUM_ENABLE)
3445		dev->net->features |= NETIF_F_RXCSUM;
3446
3447	if (DEFAULT_TSO_CSUM_ENABLE)
3448		dev->net->features |= NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_SG;
3449
3450	if (DEFAULT_VLAN_RX_OFFLOAD)
3451		dev->net->features |= NETIF_F_HW_VLAN_CTAG_RX;
3452
3453	if (DEFAULT_VLAN_FILTER_ENABLE)
3454		dev->net->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
3455
3456	dev->net->hw_features = dev->net->features;
3457
3458	ret = lan78xx_setup_irq_domain(dev);
3459	if (ret < 0) {
3460		netdev_warn(dev->net,
3461			    "lan78xx_setup_irq_domain() failed : %d", ret);
3462		goto out1;
 
3463	}
3464
3465	/* Init all registers */
3466	ret = lan78xx_reset(dev);
3467	if (ret) {
3468		netdev_warn(dev->net, "Registers INIT FAILED....");
3469		goto out2;
3470	}
3471
3472	ret = lan78xx_mdio_init(dev);
3473	if (ret) {
3474		netdev_warn(dev->net, "MDIO INIT FAILED.....");
3475		goto out2;
3476	}
3477
3478	dev->net->flags |= IFF_MULTICAST;
3479
3480	pdata->wol = WAKE_MAGIC;
3481
3482	return ret;
3483
3484out2:
3485	lan78xx_remove_irq_domain(dev);
3486
3487out1:
3488	netdev_warn(dev->net, "Bind routine FAILED");
3489	cancel_work_sync(&pdata->set_multicast);
3490	cancel_work_sync(&pdata->set_vlan);
3491	kfree(pdata);
3492	return ret;
3493}
3494
3495static void lan78xx_unbind(struct lan78xx_net *dev, struct usb_interface *intf)
3496{
3497	struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
3498
3499	lan78xx_remove_irq_domain(dev);
3500
3501	lan78xx_remove_mdio(dev);
3502
3503	if (pdata) {
3504		cancel_work_sync(&pdata->set_multicast);
3505		cancel_work_sync(&pdata->set_vlan);
3506		netif_dbg(dev, ifdown, dev->net, "free pdata");
3507		kfree(pdata);
3508		pdata = NULL;
3509		dev->data[0] = 0;
3510	}
3511}
3512
3513static void lan78xx_rx_csum_offload(struct lan78xx_net *dev,
3514				    struct sk_buff *skb,
3515				    u32 rx_cmd_a, u32 rx_cmd_b)
3516{
3517	/* HW Checksum offload appears to be flawed if used when not stripping
3518	 * VLAN headers. Drop back to S/W checksums under these conditions.
3519	 */
3520	if (!(dev->net->features & NETIF_F_RXCSUM) ||
3521	    unlikely(rx_cmd_a & RX_CMD_A_ICSM_) ||
3522	    ((rx_cmd_a & RX_CMD_A_FVTG_) &&
3523	     !(dev->net->features & NETIF_F_HW_VLAN_CTAG_RX))) {
3524		skb->ip_summed = CHECKSUM_NONE;
3525	} else {
3526		skb->csum = ntohs((u16)(rx_cmd_b >> RX_CMD_B_CSUM_SHIFT_));
3527		skb->ip_summed = CHECKSUM_COMPLETE;
3528	}
3529}
3530
3531static void lan78xx_rx_vlan_offload(struct lan78xx_net *dev,
3532				    struct sk_buff *skb,
3533				    u32 rx_cmd_a, u32 rx_cmd_b)
3534{
3535	if ((dev->net->features & NETIF_F_HW_VLAN_CTAG_RX) &&
3536	    (rx_cmd_a & RX_CMD_A_FVTG_))
3537		__vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q),
3538				       (rx_cmd_b & 0xffff));
3539}
3540
3541static void lan78xx_skb_return(struct lan78xx_net *dev, struct sk_buff *skb)
3542{
 
 
 
 
 
 
 
3543	dev->net->stats.rx_packets++;
3544	dev->net->stats.rx_bytes += skb->len;
3545
3546	skb->protocol = eth_type_trans(skb, dev->net);
3547
3548	netif_dbg(dev, rx_status, dev->net, "< rx, len %zu, type 0x%x\n",
3549		  skb->len + sizeof(struct ethhdr), skb->protocol);
3550	memset(skb->cb, 0, sizeof(struct skb_data));
3551
3552	if (skb_defer_rx_timestamp(skb))
3553		return;
3554
3555	napi_gro_receive(&dev->napi, skb);
 
 
 
3556}
3557
3558static int lan78xx_rx(struct lan78xx_net *dev, struct sk_buff *skb,
3559		      int budget, int *work_done)
3560{
3561	if (skb->len < RX_SKB_MIN_LEN)
3562		return 0;
3563
3564	/* Extract frames from the URB buffer and pass each one to
3565	 * the stack in a new NAPI SKB.
3566	 */
3567	while (skb->len > 0) {
3568		u32 rx_cmd_a, rx_cmd_b, align_count, size;
3569		u16 rx_cmd_c;
 
3570		unsigned char *packet;
3571
3572		rx_cmd_a = get_unaligned_le32(skb->data);
 
3573		skb_pull(skb, sizeof(rx_cmd_a));
3574
3575		rx_cmd_b = get_unaligned_le32(skb->data);
 
3576		skb_pull(skb, sizeof(rx_cmd_b));
3577
3578		rx_cmd_c = get_unaligned_le16(skb->data);
 
3579		skb_pull(skb, sizeof(rx_cmd_c));
3580
3581		packet = skb->data;
3582
3583		/* get the packet length */
3584		size = (rx_cmd_a & RX_CMD_A_LEN_MASK_);
3585		align_count = (4 - ((size + RXW_PADDING) % 4)) % 4;
3586
3587		if (unlikely(size > skb->len)) {
3588			netif_dbg(dev, rx_err, dev->net,
3589				  "size err rx_cmd_a=0x%08x\n",
3590				  rx_cmd_a);
3591			return 0;
3592		}
3593
3594		if (unlikely(rx_cmd_a & RX_CMD_A_RED_)) {
3595			netif_dbg(dev, rx_err, dev->net,
3596				  "Error rx_cmd_a=0x%08x", rx_cmd_a);
3597		} else {
3598			u32 frame_len;
3599			struct sk_buff *skb2;
 
 
3600
3601			if (unlikely(size < ETH_FCS_LEN)) {
3602				netif_dbg(dev, rx_err, dev->net,
3603					  "size err rx_cmd_a=0x%08x\n",
3604					  rx_cmd_a);
3605				return 0;
3606			}
3607
3608			frame_len = size - ETH_FCS_LEN;
 
3609
3610			skb2 = napi_alloc_skb(&dev->napi, frame_len);
3611			if (!skb2)
 
3612				return 0;
 
3613
3614			memcpy(skb2->data, packet, frame_len);
3615
3616			skb_put(skb2, frame_len);
3617
3618			lan78xx_rx_csum_offload(dev, skb2, rx_cmd_a, rx_cmd_b);
3619			lan78xx_rx_vlan_offload(dev, skb2, rx_cmd_a, rx_cmd_b);
3620
3621			/* Processing of the URB buffer must complete once
3622			 * it has started. If the NAPI work budget is exhausted
3623			 * while frames remain they are added to the overflow
3624			 * queue for delivery in the next NAPI polling cycle.
3625			 */
3626			if (*work_done < budget) {
3627				lan78xx_skb_return(dev, skb2);
3628				++(*work_done);
3629			} else {
3630				skb_queue_tail(&dev->rxq_overflow, skb2);
3631			}
3632		}
3633
3634		skb_pull(skb, size);
3635
3636		/* skip padding bytes before the next frame starts */
3637		if (skb->len)
3638			skb_pull(skb, align_count);
3639	}
3640
3641	return 1;
3642}
3643
3644static inline void rx_process(struct lan78xx_net *dev, struct sk_buff *skb,
3645			      int budget, int *work_done)
3646{
3647	if (!lan78xx_rx(dev, skb, budget, work_done)) {
3648		netif_dbg(dev, rx_err, dev->net, "drop\n");
3649		dev->net->stats.rx_errors++;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3650	}
 
3651}
3652
3653static void rx_complete(struct urb *urb)
3654{
3655	struct sk_buff	*skb = (struct sk_buff *)urb->context;
3656	struct skb_data	*entry = (struct skb_data *)skb->cb;
3657	struct lan78xx_net *dev = entry->dev;
3658	int urb_status = urb->status;
3659	enum skb_state state;
3660
3661	netif_dbg(dev, rx_status, dev->net,
3662		  "rx done: status %d", urb->status);
3663
3664	skb_put(skb, urb->actual_length);
3665	state = rx_done;
3666
3667	if (urb != entry->urb)
3668		netif_warn(dev, rx_err, dev->net, "URB pointer mismatch");
3669
3670	switch (urb_status) {
3671	case 0:
3672		if (skb->len < RX_SKB_MIN_LEN) {
3673			state = rx_cleanup;
3674			dev->net->stats.rx_errors++;
3675			dev->net->stats.rx_length_errors++;
3676			netif_dbg(dev, rx_err, dev->net,
3677				  "rx length %d\n", skb->len);
3678		}
3679		usb_mark_last_busy(dev->udev);
3680		break;
3681	case -EPIPE:
3682		dev->net->stats.rx_errors++;
3683		lan78xx_defer_kevent(dev, EVENT_RX_HALT);
3684		fallthrough;
3685	case -ECONNRESET:				/* async unlink */
3686	case -ESHUTDOWN:				/* hardware gone */
3687		netif_dbg(dev, ifdown, dev->net,
3688			  "rx shutdown, code %d\n", urb_status);
3689		state = rx_cleanup;
 
 
3690		break;
3691	case -EPROTO:
3692	case -ETIME:
3693	case -EILSEQ:
3694		dev->net->stats.rx_errors++;
3695		state = rx_cleanup;
 
 
3696		break;
3697
3698	/* data overrun ... flush fifo? */
3699	case -EOVERFLOW:
3700		dev->net->stats.rx_over_errors++;
3701		fallthrough;
3702
3703	default:
3704		state = rx_cleanup;
3705		dev->net->stats.rx_errors++;
3706		netif_dbg(dev, rx_err, dev->net, "rx status %d\n", urb_status);
3707		break;
3708	}
3709
3710	state = defer_bh(dev, skb, &dev->rxq, state);
3711}
3712
3713static int rx_submit(struct lan78xx_net *dev, struct sk_buff *skb, gfp_t flags)
3714{
3715	struct skb_data	*entry = (struct skb_data *)skb->cb;
3716	size_t size = dev->rx_urb_size;
3717	struct urb *urb = entry->urb;
3718	unsigned long lockflags;
3719	int ret = 0;
3720
3721	usb_fill_bulk_urb(urb, dev->udev, dev->pipe_in,
3722			  skb->data, size, rx_complete, skb);
3723
3724	spin_lock_irqsave(&dev->rxq.lock, lockflags);
3725
3726	if (netif_device_present(dev->net) &&
3727	    netif_running(dev->net) &&
3728	    !test_bit(EVENT_RX_HALT, &dev->flags) &&
3729	    !test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3730		ret = usb_submit_urb(urb, flags);
3731		switch (ret) {
3732		case 0:
3733			lan78xx_queue_skb(&dev->rxq, skb, rx_start);
3734			break;
3735		case -EPIPE:
3736			lan78xx_defer_kevent(dev, EVENT_RX_HALT);
3737			break;
3738		case -ENODEV:
3739		case -ENOENT:
3740			netif_dbg(dev, ifdown, dev->net, "device gone\n");
3741			netif_device_detach(dev->net);
3742			break;
3743		case -EHOSTUNREACH:
3744			ret = -ENOLINK;
3745			napi_schedule(&dev->napi);
3746			break;
3747		default:
3748			netif_dbg(dev, rx_err, dev->net,
3749				  "rx submit, %d\n", ret);
3750			napi_schedule(&dev->napi);
3751			break;
3752		}
3753	} else {
3754		netif_dbg(dev, ifdown, dev->net, "rx: stopped\n");
3755		ret = -ENOLINK;
3756	}
3757	spin_unlock_irqrestore(&dev->rxq.lock, lockflags);
3758
3759	if (ret)
3760		lan78xx_release_rx_buf(dev, skb);
3761
3762	return ret;
3763}
3764
3765static void lan78xx_rx_urb_submit_all(struct lan78xx_net *dev)
3766{
3767	struct sk_buff *rx_buf;
 
 
 
 
 
 
 
 
3768
3769	/* Ensure the maximum number of Rx URBs is submitted
3770	 */
3771	while ((rx_buf = lan78xx_get_rx_buf(dev)) != NULL) {
3772		if (rx_submit(dev, rx_buf, GFP_ATOMIC) != 0)
 
 
 
 
 
 
 
 
 
 
 
 
 
3773			break;
 
 
3774	}
3775}
3776
3777static void lan78xx_rx_urb_resubmit(struct lan78xx_net *dev,
3778				    struct sk_buff *rx_buf)
3779{
3780	/* reset SKB data pointers */
3781
3782	rx_buf->data = rx_buf->head;
3783	skb_reset_tail_pointer(rx_buf);
3784	rx_buf->len = 0;
3785	rx_buf->data_len = 0;
3786
3787	rx_submit(dev, rx_buf, GFP_ATOMIC);
3788}
3789
3790static void lan78xx_fill_tx_cmd_words(struct sk_buff *skb, u8 *buffer)
3791{
3792	u32 tx_cmd_a;
3793	u32 tx_cmd_b;
 
 
 
 
 
3794
3795	tx_cmd_a = (u32)(skb->len & TX_CMD_A_LEN_MASK_) | TX_CMD_A_FCS_;
 
 
 
3796
3797	if (skb->ip_summed == CHECKSUM_PARTIAL)
3798		tx_cmd_a |= TX_CMD_A_IPE_ | TX_CMD_A_TPE_;
 
 
 
3799
3800	tx_cmd_b = 0;
3801	if (skb_is_gso(skb)) {
3802		u16 mss = max(skb_shinfo(skb)->gso_size, TX_CMD_B_MSS_MIN_);
 
 
 
3803
3804		tx_cmd_b = (mss << TX_CMD_B_MSS_SHIFT_) & TX_CMD_B_MSS_MASK_;
 
3805
3806		tx_cmd_a |= TX_CMD_A_LSO_;
 
 
3807	}
3808
3809	if (skb_vlan_tag_present(skb)) {
3810		tx_cmd_a |= TX_CMD_A_IVTG_;
3811		tx_cmd_b |= skb_vlan_tag_get(skb) & TX_CMD_B_VTAG_MASK_;
 
 
 
 
 
 
 
 
3812	}
 
3813
3814	put_unaligned_le32(tx_cmd_a, buffer);
3815	put_unaligned_le32(tx_cmd_b, buffer + 4);
3816}
3817
3818static struct skb_data *lan78xx_tx_buf_fill(struct lan78xx_net *dev,
3819					    struct sk_buff *tx_buf)
3820{
3821	struct skb_data *entry = (struct skb_data *)tx_buf->cb;
3822	int remain = dev->tx_urb_size;
3823	u8 *tx_data = tx_buf->data;
3824	u32 urb_len = 0;
3825
3826	entry->num_of_packet = 0;
3827	entry->length = 0;
3828
3829	/* Work through the pending SKBs and copy the data of each SKB into
3830	 * the URB buffer if there room for all the SKB data.
3831	 *
3832	 * There must be at least DST+SRC+TYPE in the SKB (with padding enabled)
3833	 */
3834	while (remain >= TX_SKB_MIN_LEN) {
3835		unsigned int pending_bytes;
3836		unsigned int align_bytes;
3837		struct sk_buff *skb;
3838		unsigned int len;
3839
3840		lan78xx_tx_pend_skb_get(dev, &skb, &pending_bytes);
3841
3842		if (!skb)
3843			break;
3844
3845		align_bytes = (TX_ALIGNMENT - (urb_len % TX_ALIGNMENT)) %
3846			      TX_ALIGNMENT;
3847		len = align_bytes + TX_CMD_LEN + skb->len;
3848		if (len > remain) {
3849			lan78xx_tx_pend_skb_head_add(dev, skb, &pending_bytes);
3850			break;
3851		}
3852
3853		tx_data += align_bytes;
3854
3855		lan78xx_fill_tx_cmd_words(skb, tx_data);
3856		tx_data += TX_CMD_LEN;
3857
3858		len = skb->len;
3859		if (skb_copy_bits(skb, 0, tx_data, len) < 0) {
3860			struct net_device_stats *stats = &dev->net->stats;
3861
3862			stats->tx_dropped++;
3863			dev_kfree_skb_any(skb);
3864			tx_data -= TX_CMD_LEN;
3865			continue;
3866		}
3867
3868		tx_data += len;
3869		entry->length += len;
3870		entry->num_of_packet += skb_shinfo(skb)->gso_segs ?: 1;
3871
3872		dev_kfree_skb_any(skb);
3873
3874		urb_len = (u32)(tx_data - (u8 *)tx_buf->data);
3875
3876		remain = dev->tx_urb_size - urb_len;
3877	}
3878
3879	skb_put(tx_buf, urb_len);
3880
3881	return entry;
 
 
 
 
 
 
 
 
 
3882}
3883
3884static void lan78xx_tx_bh(struct lan78xx_net *dev)
3885{
3886	int ret;
3887
3888	/* Start the stack Tx queue if it was stopped
3889	 */
3890	netif_tx_lock(dev->net);
3891	if (netif_queue_stopped(dev->net)) {
3892		if (lan78xx_tx_pend_data_len(dev) < lan78xx_tx_urb_space(dev))
3893			netif_wake_queue(dev->net);
3894	}
3895	netif_tx_unlock(dev->net);
3896
3897	/* Go through the Tx pending queue and set up URBs to transfer
3898	 * the data to the device. Stop if no more pending data or URBs,
3899	 * or if an error occurs when a URB is submitted.
3900	 */
3901	do {
3902		struct skb_data *entry;
3903		struct sk_buff *tx_buf;
3904		unsigned long flags;
3905
3906		if (skb_queue_empty(&dev->txq_pend))
3907			break;
3908
3909		tx_buf = lan78xx_get_tx_buf(dev);
3910		if (!tx_buf)
3911			break;
3912
3913		entry = lan78xx_tx_buf_fill(dev, tx_buf);
3914
3915		spin_lock_irqsave(&dev->txq.lock, flags);
3916		ret = usb_autopm_get_interface_async(dev->intf);
3917		if (ret < 0) {
3918			spin_unlock_irqrestore(&dev->txq.lock, flags);
3919			goto out;
3920		}
3921
3922		usb_fill_bulk_urb(entry->urb, dev->udev, dev->pipe_out,
3923				  tx_buf->data, tx_buf->len, tx_complete,
3924				  tx_buf);
3925
3926		if (tx_buf->len % dev->maxpacket == 0) {
3927			/* send USB_ZERO_PACKET */
3928			entry->urb->transfer_flags |= URB_ZERO_PACKET;
3929		}
3930
3931#ifdef CONFIG_PM
3932		/* if device is asleep stop outgoing packet processing */
3933		if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3934			usb_anchor_urb(entry->urb, &dev->deferred);
3935			netif_stop_queue(dev->net);
3936			spin_unlock_irqrestore(&dev->txq.lock, flags);
3937			netdev_dbg(dev->net,
3938				   "Delaying transmission for resumption\n");
3939			return;
3940		}
3941#endif
3942		ret = usb_submit_urb(entry->urb, GFP_ATOMIC);
3943		switch (ret) {
3944		case 0:
3945			netif_trans_update(dev->net);
3946			lan78xx_queue_skb(&dev->txq, tx_buf, tx_start);
3947			break;
3948		case -EPIPE:
3949			netif_stop_queue(dev->net);
3950			lan78xx_defer_kevent(dev, EVENT_TX_HALT);
3951			usb_autopm_put_interface_async(dev->intf);
3952			break;
3953		case -ENODEV:
3954		case -ENOENT:
3955			netif_dbg(dev, tx_err, dev->net,
3956				  "tx submit urb err %d (disconnected?)", ret);
3957			netif_device_detach(dev->net);
3958			break;
3959		default:
3960			usb_autopm_put_interface_async(dev->intf);
3961			netif_dbg(dev, tx_err, dev->net,
3962				  "tx submit urb err %d\n", ret);
3963			break;
3964		}
3965
3966		spin_unlock_irqrestore(&dev->txq.lock, flags);
3967
3968		if (ret) {
3969			netdev_warn(dev->net, "failed to tx urb %d\n", ret);
3970out:
3971			dev->net->stats.tx_dropped += entry->num_of_packet;
3972			lan78xx_release_tx_buf(dev, tx_buf);
3973		}
3974	} while (ret == 0);
3975}
3976
3977static int lan78xx_bh(struct lan78xx_net *dev, int budget)
3978{
3979	struct sk_buff_head done;
3980	struct sk_buff *rx_buf;
3981	struct skb_data *entry;
3982	unsigned long flags;
3983	int work_done = 0;
3984
3985	/* Pass frames received in the last NAPI cycle before
3986	 * working on newly completed URBs.
3987	 */
3988	while (!skb_queue_empty(&dev->rxq_overflow)) {
3989		lan78xx_skb_return(dev, skb_dequeue(&dev->rxq_overflow));
3990		++work_done;
3991	}
3992
3993	/* Take a snapshot of the done queue and move items to a
3994	 * temporary queue. Rx URB completions will continue to add
3995	 * to the done queue.
3996	 */
3997	__skb_queue_head_init(&done);
3998
3999	spin_lock_irqsave(&dev->rxq_done.lock, flags);
4000	skb_queue_splice_init(&dev->rxq_done, &done);
4001	spin_unlock_irqrestore(&dev->rxq_done.lock, flags);
4002
4003	/* Extract receive frames from completed URBs and
4004	 * pass them to the stack. Re-submit each completed URB.
4005	 */
4006	while ((work_done < budget) &&
4007	       (rx_buf = __skb_dequeue(&done))) {
4008		entry = (struct skb_data *)(rx_buf->cb);
4009		switch (entry->state) {
4010		case rx_done:
4011			rx_process(dev, rx_buf, budget, &work_done);
4012			break;
 
 
 
 
 
4013		case rx_cleanup:
4014			break;
 
 
4015		default:
4016			netdev_dbg(dev->net, "rx buf state %d\n",
4017				   entry->state);
4018			break;
4019		}
4020
4021		lan78xx_rx_urb_resubmit(dev, rx_buf);
4022	}
4023
4024	/* If budget was consumed before processing all the URBs put them
4025	 * back on the front of the done queue. They will be first to be
4026	 * processed in the next NAPI cycle.
4027	 */
4028	spin_lock_irqsave(&dev->rxq_done.lock, flags);
4029	skb_queue_splice(&done, &dev->rxq_done);
4030	spin_unlock_irqrestore(&dev->rxq_done.lock, flags);
4031
4032	if (netif_device_present(dev->net) && netif_running(dev->net)) {
4033		/* reset update timer delta */
4034		if (timer_pending(&dev->stat_monitor) && (dev->delta != 1)) {
4035			dev->delta = 1;
4036			mod_timer(&dev->stat_monitor,
4037				  jiffies + STAT_UPDATE_TIMER);
4038		}
4039
4040		/* Submit all free Rx URBs */
4041
4042		if (!test_bit(EVENT_RX_HALT, &dev->flags))
4043			lan78xx_rx_urb_submit_all(dev);
4044
4045		/* Submit new Tx URBs */
4046
4047		lan78xx_tx_bh(dev);
4048	}
4049
4050	return work_done;
4051}
4052
4053static int lan78xx_poll(struct napi_struct *napi, int budget)
4054{
4055	struct lan78xx_net *dev = container_of(napi, struct lan78xx_net, napi);
4056	int result = budget;
4057	int work_done;
4058
4059	/* Don't do any work if the device is suspended */
4060
4061	if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
4062		napi_complete_done(napi, 0);
4063		return 0;
4064	}
4065
4066	/* Process completed URBs and submit new URBs */
4067
4068	work_done = lan78xx_bh(dev, budget);
4069
4070	if (work_done < budget) {
4071		napi_complete_done(napi, work_done);
4072
4073		/* Start a new polling cycle if data was received or
4074		 * data is waiting to be transmitted.
4075		 */
4076		if (!skb_queue_empty(&dev->rxq_done)) {
4077			napi_schedule(napi);
4078		} else if (netif_carrier_ok(dev->net)) {
4079			if (skb_queue_empty(&dev->txq) &&
4080			    !skb_queue_empty(&dev->txq_pend)) {
4081				napi_schedule(napi);
4082			} else {
4083				netif_tx_lock(dev->net);
4084				if (netif_queue_stopped(dev->net)) {
4085					netif_wake_queue(dev->net);
4086					napi_schedule(napi);
4087				}
4088				netif_tx_unlock(dev->net);
4089			}
4090		}
4091		result = work_done;
4092	}
4093
4094	return result;
4095}
4096
4097static void lan78xx_delayedwork(struct work_struct *work)
4098{
4099	int status;
4100	struct lan78xx_net *dev;
4101
4102	dev = container_of(work, struct lan78xx_net, wq.work);
4103
4104	if (test_bit(EVENT_DEV_DISCONNECT, &dev->flags))
4105		return;
4106
4107	if (usb_autopm_get_interface(dev->intf) < 0)
4108		return;
4109
4110	if (test_bit(EVENT_TX_HALT, &dev->flags)) {
4111		unlink_urbs(dev, &dev->txq);
4112
 
 
4113		status = usb_clear_halt(dev->udev, dev->pipe_out);
 
4114		if (status < 0 &&
4115		    status != -EPIPE &&
4116		    status != -ESHUTDOWN) {
4117			if (netif_msg_tx_err(dev))
 
4118				netdev_err(dev->net,
4119					   "can't clear tx halt, status %d\n",
4120					   status);
4121		} else {
4122			clear_bit(EVENT_TX_HALT, &dev->flags);
4123			if (status != -ESHUTDOWN)
4124				netif_wake_queue(dev->net);
4125		}
4126	}
4127
4128	if (test_bit(EVENT_RX_HALT, &dev->flags)) {
4129		unlink_urbs(dev, &dev->rxq);
 
 
 
4130		status = usb_clear_halt(dev->udev, dev->pipe_in);
 
4131		if (status < 0 &&
4132		    status != -EPIPE &&
4133		    status != -ESHUTDOWN) {
4134			if (netif_msg_rx_err(dev))
 
4135				netdev_err(dev->net,
4136					   "can't clear rx halt, status %d\n",
4137					   status);
4138		} else {
4139			clear_bit(EVENT_RX_HALT, &dev->flags);
4140			napi_schedule(&dev->napi);
4141		}
4142	}
4143
4144	if (test_bit(EVENT_LINK_RESET, &dev->flags)) {
4145		int ret = 0;
4146
4147		clear_bit(EVENT_LINK_RESET, &dev->flags);
 
 
 
4148		if (lan78xx_link_reset(dev) < 0) {
 
 
4149			netdev_info(dev->net, "link reset failed (%d)\n",
4150				    ret);
 
 
4151		}
4152	}
4153
4154	if (test_bit(EVENT_STAT_UPDATE, &dev->flags)) {
4155		lan78xx_update_stats(dev);
4156
4157		clear_bit(EVENT_STAT_UPDATE, &dev->flags);
4158
4159		mod_timer(&dev->stat_monitor,
4160			  jiffies + (STAT_UPDATE_TIMER * dev->delta));
4161
4162		dev->delta = min((dev->delta * 2), 50);
4163	}
4164
4165	usb_autopm_put_interface(dev->intf);
4166}
4167
4168static void intr_complete(struct urb *urb)
4169{
4170	struct lan78xx_net *dev = urb->context;
4171	int status = urb->status;
4172
4173	switch (status) {
4174	/* success */
4175	case 0:
4176		lan78xx_status(dev, urb);
4177		break;
4178
4179	/* software-driven interface shutdown */
4180	case -ENOENT:			/* urb killed */
4181	case -ENODEV:			/* hardware gone */
4182	case -ESHUTDOWN:		/* hardware gone */
4183		netif_dbg(dev, ifdown, dev->net,
4184			  "intr shutdown, code %d\n", status);
4185		return;
4186
4187	/* NOTE:  not throttling like RX/TX, since this endpoint
4188	 * already polls infrequently
4189	 */
4190	default:
4191		netdev_dbg(dev->net, "intr status %d\n", status);
4192		break;
4193	}
4194
4195	if (!netif_device_present(dev->net) ||
4196	    !netif_running(dev->net)) {
4197		netdev_warn(dev->net, "not submitting new status URB");
4198		return;
4199	}
4200
4201	memset(urb->transfer_buffer, 0, urb->transfer_buffer_length);
4202	status = usb_submit_urb(urb, GFP_ATOMIC);
4203
4204	switch (status) {
4205	case  0:
4206		break;
4207	case -ENODEV:
4208	case -ENOENT:
4209		netif_dbg(dev, timer, dev->net,
4210			  "intr resubmit %d (disconnect?)", status);
4211		netif_device_detach(dev->net);
4212		break;
4213	default:
4214		netif_err(dev, timer, dev->net,
4215			  "intr resubmit --> %d\n", status);
4216		break;
4217	}
4218}
4219
4220static void lan78xx_disconnect(struct usb_interface *intf)
4221{
4222	struct lan78xx_net *dev;
4223	struct usb_device *udev;
4224	struct net_device *net;
4225	struct phy_device *phydev;
4226
4227	dev = usb_get_intfdata(intf);
4228	usb_set_intfdata(intf, NULL);
4229	if (!dev)
4230		return;
4231
4232	netif_napi_del(&dev->napi);
4233
4234	udev = interface_to_usbdev(intf);
4235	net = dev->net;
4236
 
4237	unregister_netdev(net);
4238
4239	timer_shutdown_sync(&dev->stat_monitor);
4240	set_bit(EVENT_DEV_DISCONNECT, &dev->flags);
4241	cancel_delayed_work_sync(&dev->wq);
4242
4243	phydev = net->phydev;
4244
4245	phy_unregister_fixup_for_uid(PHY_KSZ9031RNX, 0xfffffff0);
4246	phy_unregister_fixup_for_uid(PHY_LAN8835, 0xfffffff0);
4247
4248	phy_disconnect(net->phydev);
4249
4250	if (phy_is_pseudo_fixed_link(phydev)) {
4251		fixed_phy_unregister(phydev);
4252		phy_device_free(phydev);
4253	}
4254
4255	usb_scuttle_anchored_urbs(&dev->deferred);
4256
4257	lan78xx_unbind(dev, intf);
4258
4259	lan78xx_free_tx_resources(dev);
4260	lan78xx_free_rx_resources(dev);
4261
4262	usb_kill_urb(dev->urb_intr);
4263	usb_free_urb(dev->urb_intr);
4264
4265	free_netdev(net);
4266	usb_put_dev(udev);
4267}
4268
4269static void lan78xx_tx_timeout(struct net_device *net, unsigned int txqueue)
4270{
4271	struct lan78xx_net *dev = netdev_priv(net);
4272
4273	unlink_urbs(dev, &dev->txq);
4274	napi_schedule(&dev->napi);
4275}
4276
4277static netdev_features_t lan78xx_features_check(struct sk_buff *skb,
4278						struct net_device *netdev,
4279						netdev_features_t features)
4280{
4281	struct lan78xx_net *dev = netdev_priv(netdev);
4282
4283	if (skb->len > LAN78XX_TSO_SIZE(dev))
4284		features &= ~NETIF_F_GSO_MASK;
4285
4286	features = vlan_features_check(skb, features);
4287	features = vxlan_features_check(skb, features);
4288
4289	return features;
4290}
4291
4292static const struct net_device_ops lan78xx_netdev_ops = {
4293	.ndo_open		= lan78xx_open,
4294	.ndo_stop		= lan78xx_stop,
4295	.ndo_start_xmit		= lan78xx_start_xmit,
4296	.ndo_tx_timeout		= lan78xx_tx_timeout,
4297	.ndo_change_mtu		= lan78xx_change_mtu,
4298	.ndo_set_mac_address	= lan78xx_set_mac_addr,
4299	.ndo_validate_addr	= eth_validate_addr,
4300	.ndo_eth_ioctl		= phy_do_ioctl_running,
4301	.ndo_set_rx_mode	= lan78xx_set_multicast,
4302	.ndo_set_features	= lan78xx_set_features,
4303	.ndo_vlan_rx_add_vid	= lan78xx_vlan_rx_add_vid,
4304	.ndo_vlan_rx_kill_vid	= lan78xx_vlan_rx_kill_vid,
4305	.ndo_features_check	= lan78xx_features_check,
4306};
4307
4308static void lan78xx_stat_monitor(struct timer_list *t)
4309{
4310	struct lan78xx_net *dev = from_timer(dev, t, stat_monitor);
 
 
4311
4312	lan78xx_defer_kevent(dev, EVENT_STAT_UPDATE);
4313}
4314
4315static int lan78xx_probe(struct usb_interface *intf,
4316			 const struct usb_device_id *id)
4317{
4318	struct usb_host_endpoint *ep_blkin, *ep_blkout, *ep_intr;
4319	struct lan78xx_net *dev;
4320	struct net_device *netdev;
4321	struct usb_device *udev;
4322	int ret;
4323	unsigned int maxp;
4324	unsigned int period;
4325	u8 *buf = NULL;
4326
4327	udev = interface_to_usbdev(intf);
4328	udev = usb_get_dev(udev);
4329
 
4330	netdev = alloc_etherdev(sizeof(struct lan78xx_net));
4331	if (!netdev) {
4332		dev_err(&intf->dev, "Error: OOM\n");
4333		ret = -ENOMEM;
4334		goto out1;
4335	}
4336
4337	/* netdev_printk() needs this */
4338	SET_NETDEV_DEV(netdev, &intf->dev);
4339
4340	dev = netdev_priv(netdev);
4341	dev->udev = udev;
4342	dev->intf = intf;
4343	dev->net = netdev;
4344	dev->msg_enable = netif_msg_init(msg_level, NETIF_MSG_DRV
4345					| NETIF_MSG_PROBE | NETIF_MSG_LINK);
4346
4347	skb_queue_head_init(&dev->rxq);
4348	skb_queue_head_init(&dev->txq);
4349	skb_queue_head_init(&dev->rxq_done);
 
4350	skb_queue_head_init(&dev->txq_pend);
4351	skb_queue_head_init(&dev->rxq_overflow);
4352	mutex_init(&dev->phy_mutex);
4353	mutex_init(&dev->dev_mutex);
4354
4355	ret = lan78xx_urb_config_init(dev);
4356	if (ret < 0)
4357		goto out2;
4358
4359	ret = lan78xx_alloc_tx_resources(dev);
4360	if (ret < 0)
4361		goto out2;
4362
4363	ret = lan78xx_alloc_rx_resources(dev);
4364	if (ret < 0)
4365		goto out3;
4366
4367	/* MTU range: 68 - 9000 */
4368	netdev->max_mtu = MAX_SINGLE_PACKET_SIZE;
4369
4370	netif_set_tso_max_size(netdev, LAN78XX_TSO_SIZE(dev));
4371
4372	netif_napi_add(netdev, &dev->napi, lan78xx_poll);
4373
 
4374	INIT_DELAYED_WORK(&dev->wq, lan78xx_delayedwork);
4375	init_usb_anchor(&dev->deferred);
4376
4377	netdev->netdev_ops = &lan78xx_netdev_ops;
4378	netdev->watchdog_timeo = TX_TIMEOUT_JIFFIES;
4379	netdev->ethtool_ops = &lan78xx_ethtool_ops;
4380
 
 
4381	dev->delta = 1;
4382	timer_setup(&dev->stat_monitor, lan78xx_stat_monitor, 0);
4383
4384	mutex_init(&dev->stats.access_lock);
4385
4386	if (intf->cur_altsetting->desc.bNumEndpoints < 3) {
4387		ret = -ENODEV;
4388		goto out4;
4389	}
4390
4391	dev->pipe_in = usb_rcvbulkpipe(udev, BULK_IN_PIPE);
4392	ep_blkin = usb_pipe_endpoint(udev, dev->pipe_in);
4393	if (!ep_blkin || !usb_endpoint_is_bulk_in(&ep_blkin->desc)) {
4394		ret = -ENODEV;
4395		goto out4;
4396	}
4397
4398	dev->pipe_out = usb_sndbulkpipe(udev, BULK_OUT_PIPE);
4399	ep_blkout = usb_pipe_endpoint(udev, dev->pipe_out);
4400	if (!ep_blkout || !usb_endpoint_is_bulk_out(&ep_blkout->desc)) {
4401		ret = -ENODEV;
4402		goto out4;
4403	}
4404
4405	ep_intr = &intf->cur_altsetting->endpoint[2];
4406	if (!usb_endpoint_is_int_in(&ep_intr->desc)) {
4407		ret = -ENODEV;
4408		goto out4;
4409	}
4410
4411	dev->pipe_intr = usb_rcvintpipe(dev->udev,
4412					usb_endpoint_num(&ep_intr->desc));
 
4413
4414	ret = lan78xx_bind(dev, intf);
4415	if (ret < 0)
4416		goto out4;
4417
4418	period = ep_intr->desc.bInterval;
4419	maxp = usb_maxpacket(dev->udev, dev->pipe_intr);
4420
4421	dev->urb_intr = usb_alloc_urb(0, GFP_KERNEL);
4422	if (!dev->urb_intr) {
4423		ret = -ENOMEM;
4424		goto out5;
4425	}
4426
 
4427	buf = kmalloc(maxp, GFP_KERNEL);
4428	if (!buf) {
4429		ret = -ENOMEM;
4430		goto free_urbs;
4431	}
4432
4433	usb_fill_int_urb(dev->urb_intr, dev->udev,
4434			 dev->pipe_intr, buf, maxp,
4435			 intr_complete, dev, period);
4436	dev->urb_intr->transfer_flags |= URB_FREE_BUFFER;
4437
4438	dev->maxpacket = usb_maxpacket(dev->udev, dev->pipe_out);
4439
4440	/* Reject broken descriptors. */
4441	if (dev->maxpacket == 0) {
4442		ret = -ENODEV;
4443		goto free_urbs;
4444	}
4445
 
 
4446	/* driver requires remote-wakeup capability during autosuspend. */
4447	intf->needs_remote_wakeup = 1;
4448
4449	ret = lan78xx_phy_init(dev);
4450	if (ret < 0)
4451		goto free_urbs;
4452
4453	ret = register_netdev(netdev);
4454	if (ret != 0) {
4455		netif_err(dev, probe, netdev, "couldn't register the device\n");
4456		goto out8;
4457	}
4458
4459	usb_set_intfdata(intf, dev);
4460
4461	ret = device_set_wakeup_enable(&udev->dev, true);
4462
4463	 /* Default delay of 2sec has more overhead than advantage.
4464	  * Set to 10sec as default.
4465	  */
4466	pm_runtime_set_autosuspend_delay(&udev->dev,
4467					 DEFAULT_AUTOSUSPEND_DELAY);
4468
4469	return 0;
4470
4471out8:
4472	phy_disconnect(netdev->phydev);
4473free_urbs:
4474	usb_free_urb(dev->urb_intr);
4475out5:
4476	lan78xx_unbind(dev, intf);
4477out4:
4478	netif_napi_del(&dev->napi);
4479	lan78xx_free_rx_resources(dev);
4480out3:
4481	lan78xx_free_tx_resources(dev);
4482out2:
4483	free_netdev(netdev);
4484out1:
4485	usb_put_dev(udev);
4486
4487	return ret;
4488}
4489
4490static u16 lan78xx_wakeframe_crc16(const u8 *buf, int len)
4491{
4492	const u16 crc16poly = 0x8005;
4493	int i;
4494	u16 bit, crc, msb;
4495	u8 data;
4496
4497	crc = 0xFFFF;
4498	for (i = 0; i < len; i++) {
4499		data = *buf++;
4500		for (bit = 0; bit < 8; bit++) {
4501			msb = crc >> 15;
4502			crc <<= 1;
4503
4504			if (msb ^ (u16)(data & 1)) {
4505				crc ^= crc16poly;
4506				crc |= (u16)0x0001U;
4507			}
4508			data >>= 1;
4509		}
4510	}
4511
4512	return crc;
4513}
4514
4515static int lan78xx_set_auto_suspend(struct lan78xx_net *dev)
4516{
4517	u32 buf;
4518	int ret;
4519
4520	ret = lan78xx_stop_tx_path(dev);
4521	if (ret < 0)
4522		return ret;
4523
4524	ret = lan78xx_stop_rx_path(dev);
4525	if (ret < 0)
4526		return ret;
4527
4528	/* auto suspend (selective suspend) */
4529
4530	ret = lan78xx_write_reg(dev, WUCSR, 0);
4531	if (ret < 0)
4532		return ret;
4533	ret = lan78xx_write_reg(dev, WUCSR2, 0);
4534	if (ret < 0)
4535		return ret;
4536	ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
4537	if (ret < 0)
4538		return ret;
4539
4540	/* set goodframe wakeup */
4541
4542	ret = lan78xx_read_reg(dev, WUCSR, &buf);
4543	if (ret < 0)
4544		return ret;
4545
4546	buf |= WUCSR_RFE_WAKE_EN_;
4547	buf |= WUCSR_STORE_WAKE_;
4548
4549	ret = lan78xx_write_reg(dev, WUCSR, buf);
4550	if (ret < 0)
4551		return ret;
4552
4553	ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
4554	if (ret < 0)
4555		return ret;
4556
4557	buf &= ~PMT_CTL_RES_CLR_WKP_EN_;
4558	buf |= PMT_CTL_RES_CLR_WKP_STS_;
4559	buf |= PMT_CTL_PHY_WAKE_EN_;
4560	buf |= PMT_CTL_WOL_EN_;
4561	buf &= ~PMT_CTL_SUS_MODE_MASK_;
4562	buf |= PMT_CTL_SUS_MODE_3_;
4563
4564	ret = lan78xx_write_reg(dev, PMT_CTL, buf);
4565	if (ret < 0)
4566		return ret;
4567
4568	ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
4569	if (ret < 0)
4570		return ret;
4571
4572	buf |= PMT_CTL_WUPS_MASK_;
4573
4574	ret = lan78xx_write_reg(dev, PMT_CTL, buf);
4575	if (ret < 0)
4576		return ret;
4577
4578	ret = lan78xx_start_rx_path(dev);
4579
4580	return ret;
4581}
4582
4583static int lan78xx_set_suspend(struct lan78xx_net *dev, u32 wol)
4584{
4585	const u8 ipv4_multicast[3] = { 0x01, 0x00, 0x5E };
4586	const u8 ipv6_multicast[3] = { 0x33, 0x33 };
4587	const u8 arp_type[2] = { 0x08, 0x06 };
4588	u32 temp_pmt_ctl;
4589	int mask_index;
4590	u32 temp_wucsr;
4591	u32 buf;
4592	u16 crc;
4593	int ret;
4594
4595	ret = lan78xx_stop_tx_path(dev);
4596	if (ret < 0)
4597		return ret;
4598	ret = lan78xx_stop_rx_path(dev);
4599	if (ret < 0)
4600		return ret;
4601
4602	ret = lan78xx_write_reg(dev, WUCSR, 0);
4603	if (ret < 0)
4604		return ret;
4605	ret = lan78xx_write_reg(dev, WUCSR2, 0);
4606	if (ret < 0)
4607		return ret;
4608	ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
4609	if (ret < 0)
4610		return ret;
4611
4612	temp_wucsr = 0;
4613
4614	temp_pmt_ctl = 0;
4615
4616	ret = lan78xx_read_reg(dev, PMT_CTL, &temp_pmt_ctl);
4617	if (ret < 0)
4618		return ret;
4619
4620	temp_pmt_ctl &= ~PMT_CTL_RES_CLR_WKP_EN_;
4621	temp_pmt_ctl |= PMT_CTL_RES_CLR_WKP_STS_;
4622
4623	for (mask_index = 0; mask_index < NUM_OF_WUF_CFG; mask_index++) {
4624		ret = lan78xx_write_reg(dev, WUF_CFG(mask_index), 0);
4625		if (ret < 0)
4626			return ret;
4627	}
4628
4629	mask_index = 0;
4630	if (wol & WAKE_PHY) {
4631		temp_pmt_ctl |= PMT_CTL_PHY_WAKE_EN_;
4632
4633		temp_pmt_ctl |= PMT_CTL_WOL_EN_;
4634		temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
4635		temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
4636	}
4637	if (wol & WAKE_MAGIC) {
4638		temp_wucsr |= WUCSR_MPEN_;
4639
4640		temp_pmt_ctl |= PMT_CTL_WOL_EN_;
4641		temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
4642		temp_pmt_ctl |= PMT_CTL_SUS_MODE_3_;
4643	}
4644	if (wol & WAKE_BCAST) {
4645		temp_wucsr |= WUCSR_BCST_EN_;
4646
4647		temp_pmt_ctl |= PMT_CTL_WOL_EN_;
4648		temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
4649		temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
4650	}
4651	if (wol & WAKE_MCAST) {
4652		temp_wucsr |= WUCSR_WAKE_EN_;
4653
4654		/* set WUF_CFG & WUF_MASK for IPv4 Multicast */
4655		crc = lan78xx_wakeframe_crc16(ipv4_multicast, 3);
4656		ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
4657					WUF_CFGX_EN_ |
4658					WUF_CFGX_TYPE_MCAST_ |
4659					(0 << WUF_CFGX_OFFSET_SHIFT_) |
4660					(crc & WUF_CFGX_CRC16_MASK_));
4661		if (ret < 0)
4662			return ret;
4663
4664		ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 7);
4665		if (ret < 0)
4666			return ret;
4667		ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
4668		if (ret < 0)
4669			return ret;
4670		ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
4671		if (ret < 0)
4672			return ret;
4673		ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
4674		if (ret < 0)
4675			return ret;
4676
4677		mask_index++;
4678
4679		/* for IPv6 Multicast */
4680		crc = lan78xx_wakeframe_crc16(ipv6_multicast, 2);
4681		ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
4682					WUF_CFGX_EN_ |
4683					WUF_CFGX_TYPE_MCAST_ |
4684					(0 << WUF_CFGX_OFFSET_SHIFT_) |
4685					(crc & WUF_CFGX_CRC16_MASK_));
4686		if (ret < 0)
4687			return ret;
4688
4689		ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 3);
4690		if (ret < 0)
4691			return ret;
4692		ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
4693		if (ret < 0)
4694			return ret;
4695		ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
4696		if (ret < 0)
4697			return ret;
4698		ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
4699		if (ret < 0)
4700			return ret;
4701
4702		mask_index++;
4703
4704		temp_pmt_ctl |= PMT_CTL_WOL_EN_;
4705		temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
4706		temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
4707	}
4708	if (wol & WAKE_UCAST) {
4709		temp_wucsr |= WUCSR_PFDA_EN_;
4710
4711		temp_pmt_ctl |= PMT_CTL_WOL_EN_;
4712		temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
4713		temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
4714	}
4715	if (wol & WAKE_ARP) {
4716		temp_wucsr |= WUCSR_WAKE_EN_;
4717
4718		/* set WUF_CFG & WUF_MASK
4719		 * for packettype (offset 12,13) = ARP (0x0806)
4720		 */
4721		crc = lan78xx_wakeframe_crc16(arp_type, 2);
4722		ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
4723					WUF_CFGX_EN_ |
4724					WUF_CFGX_TYPE_ALL_ |
4725					(0 << WUF_CFGX_OFFSET_SHIFT_) |
4726					(crc & WUF_CFGX_CRC16_MASK_));
4727		if (ret < 0)
4728			return ret;
4729
4730		ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 0x3000);
4731		if (ret < 0)
4732			return ret;
4733		ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
4734		if (ret < 0)
4735			return ret;
4736		ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
4737		if (ret < 0)
4738			return ret;
4739		ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
4740		if (ret < 0)
4741			return ret;
4742
4743		mask_index++;
4744
4745		temp_pmt_ctl |= PMT_CTL_WOL_EN_;
4746		temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
4747		temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
4748	}
4749
4750	ret = lan78xx_write_reg(dev, WUCSR, temp_wucsr);
4751	if (ret < 0)
4752		return ret;
4753
4754	/* when multiple WOL bits are set */
4755	if (hweight_long((unsigned long)wol) > 1) {
4756		temp_pmt_ctl |= PMT_CTL_WOL_EN_;
4757		temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
4758		temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
4759	}
4760	ret = lan78xx_write_reg(dev, PMT_CTL, temp_pmt_ctl);
4761	if (ret < 0)
4762		return ret;
4763
4764	/* clear WUPS */
4765	ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
4766	if (ret < 0)
4767		return ret;
4768
4769	buf |= PMT_CTL_WUPS_MASK_;
4770
4771	ret = lan78xx_write_reg(dev, PMT_CTL, buf);
4772	if (ret < 0)
4773		return ret;
4774
4775	ret = lan78xx_start_rx_path(dev);
 
 
4776
4777	return ret;
4778}
4779
4780static int lan78xx_suspend(struct usb_interface *intf, pm_message_t message)
4781{
4782	struct lan78xx_net *dev = usb_get_intfdata(intf);
4783	bool dev_open;
 
4784	int ret;
 
4785
4786	mutex_lock(&dev->dev_mutex);
4787
4788	netif_dbg(dev, ifdown, dev->net,
4789		  "suspending: pm event %#x", message.event);
4790
4791	dev_open = test_bit(EVENT_DEV_OPEN, &dev->flags);
4792
4793	if (dev_open) {
4794		spin_lock_irq(&dev->txq.lock);
4795		/* don't autosuspend while transmitting */
4796		if ((skb_queue_len(&dev->txq) ||
4797		     skb_queue_len(&dev->txq_pend)) &&
4798		    PMSG_IS_AUTO(message)) {
4799			spin_unlock_irq(&dev->txq.lock);
4800			ret = -EBUSY;
4801			goto out;
4802		} else {
4803			set_bit(EVENT_DEV_ASLEEP, &dev->flags);
4804			spin_unlock_irq(&dev->txq.lock);
4805		}
4806
4807		/* stop RX */
4808		ret = lan78xx_stop_rx_path(dev);
4809		if (ret < 0)
4810			goto out;
4811
4812		ret = lan78xx_flush_rx_fifo(dev);
4813		if (ret < 0)
4814			goto out;
4815
4816		/* stop Tx */
4817		ret = lan78xx_stop_tx_path(dev);
4818		if (ret < 0)
4819			goto out;
4820
4821		/* empty out the Rx and Tx queues */
4822		netif_device_detach(dev->net);
4823		lan78xx_terminate_urbs(dev);
4824		usb_kill_urb(dev->urb_intr);
4825
4826		/* reattach */
4827		netif_device_attach(dev->net);
 
4828
 
4829		del_timer(&dev->stat_monitor);
4830
4831		if (PMSG_IS_AUTO(message)) {
4832			ret = lan78xx_set_auto_suspend(dev);
4833			if (ret < 0)
4834				goto out;
4835		} else {
4836			struct lan78xx_priv *pdata;
4837
4838			pdata = (struct lan78xx_priv *)(dev->data[0]);
4839			netif_carrier_off(dev->net);
4840			ret = lan78xx_set_suspend(dev, pdata->wol);
4841			if (ret < 0)
4842				goto out;
4843		}
4844	} else {
4845		/* Interface is down; don't allow WOL and PHY
4846		 * events to wake up the host
4847		 */
4848		u32 buf;
4849
4850		set_bit(EVENT_DEV_ASLEEP, &dev->flags);
4851
4852		ret = lan78xx_write_reg(dev, WUCSR, 0);
4853		if (ret < 0)
4854			goto out;
4855		ret = lan78xx_write_reg(dev, WUCSR2, 0);
4856		if (ret < 0)
4857			goto out;
4858
4859		ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
4860		if (ret < 0)
4861			goto out;
4862
4863		buf &= ~PMT_CTL_RES_CLR_WKP_EN_;
4864		buf |= PMT_CTL_RES_CLR_WKP_STS_;
4865		buf &= ~PMT_CTL_SUS_MODE_MASK_;
4866		buf |= PMT_CTL_SUS_MODE_3_;
4867
4868		ret = lan78xx_write_reg(dev, PMT_CTL, buf);
4869		if (ret < 0)
4870			goto out;
4871
4872		ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
4873		if (ret < 0)
4874			goto out;
4875
4876		buf |= PMT_CTL_WUPS_MASK_;
4877
4878		ret = lan78xx_write_reg(dev, PMT_CTL, buf);
4879		if (ret < 0)
4880			goto out;
4881	}
4882
4883	ret = 0;
4884out:
4885	mutex_unlock(&dev->dev_mutex);
4886
4887	return ret;
4888}
 
 
4889
4890static bool lan78xx_submit_deferred_urbs(struct lan78xx_net *dev)
4891{
4892	bool pipe_halted = false;
4893	struct urb *urb;
4894
4895	while ((urb = usb_get_from_anchor(&dev->deferred))) {
4896		struct sk_buff *skb = urb->context;
4897		int ret;
4898
4899		if (!netif_device_present(dev->net) ||
4900		    !netif_carrier_ok(dev->net) ||
4901		    pipe_halted) {
4902			lan78xx_release_tx_buf(dev, skb);
4903			continue;
4904		}
4905
4906		ret = usb_submit_urb(urb, GFP_ATOMIC);
4907
4908		if (ret == 0) {
4909			netif_trans_update(dev->net);
4910			lan78xx_queue_skb(&dev->txq, skb, tx_start);
4911		} else {
4912			if (ret == -EPIPE) {
4913				netif_stop_queue(dev->net);
4914				pipe_halted = true;
4915			} else if (ret == -ENODEV) {
4916				netif_device_detach(dev->net);
4917			}
4918
4919			lan78xx_release_tx_buf(dev, skb);
4920		}
4921	}
4922
4923	return pipe_halted;
 
 
4924}
4925
4926static int lan78xx_resume(struct usb_interface *intf)
4927{
4928	struct lan78xx_net *dev = usb_get_intfdata(intf);
4929	bool dev_open;
 
4930	int ret;
 
4931
4932	mutex_lock(&dev->dev_mutex);
4933
4934	netif_dbg(dev, ifup, dev->net, "resuming device");
4935
4936	dev_open = test_bit(EVENT_DEV_OPEN, &dev->flags);
4937
4938	if (dev_open) {
4939		bool pipe_halted = false;
4940
4941		ret = lan78xx_flush_tx_fifo(dev);
4942		if (ret < 0)
4943			goto out;
4944
4945		if (dev->urb_intr) {
4946			int ret = usb_submit_urb(dev->urb_intr, GFP_KERNEL);
 
 
4947
 
 
 
 
4948			if (ret < 0) {
4949				if (ret == -ENODEV)
4950					netif_device_detach(dev->net);
4951				netdev_warn(dev->net, "Failed to submit intr URB");
 
 
 
4952			}
4953		}
4954
4955		spin_lock_irq(&dev->txq.lock);
4956
4957		if (netif_device_present(dev->net)) {
4958			pipe_halted = lan78xx_submit_deferred_urbs(dev);
4959
4960			if (pipe_halted)
4961				lan78xx_defer_kevent(dev, EVENT_TX_HALT);
4962		}
4963
4964		clear_bit(EVENT_DEV_ASLEEP, &dev->flags);
4965
4966		spin_unlock_irq(&dev->txq.lock);
4967
4968		if (!pipe_halted &&
4969		    netif_device_present(dev->net) &&
4970		    (lan78xx_tx_pend_data_len(dev) < lan78xx_tx_urb_space(dev)))
4971			netif_start_queue(dev->net);
4972
4973		ret = lan78xx_start_tx_path(dev);
4974		if (ret < 0)
4975			goto out;
4976
4977		napi_schedule(&dev->napi);
4978
4979		if (!timer_pending(&dev->stat_monitor)) {
4980			dev->delta = 1;
4981			mod_timer(&dev->stat_monitor,
4982				  jiffies + STAT_UPDATE_TIMER);
4983		}
4984
4985	} else {
4986		clear_bit(EVENT_DEV_ASLEEP, &dev->flags);
4987	}
4988
4989	ret = lan78xx_write_reg(dev, WUCSR2, 0);
4990	if (ret < 0)
4991		goto out;
4992	ret = lan78xx_write_reg(dev, WUCSR, 0);
4993	if (ret < 0)
4994		goto out;
4995	ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
4996	if (ret < 0)
4997		goto out;
4998
4999	ret = lan78xx_write_reg(dev, WUCSR2, WUCSR2_NS_RCD_ |
5000					     WUCSR2_ARP_RCD_ |
5001					     WUCSR2_IPV6_TCPSYN_RCD_ |
5002					     WUCSR2_IPV4_TCPSYN_RCD_);
5003	if (ret < 0)
5004		goto out;
5005
5006	ret = lan78xx_write_reg(dev, WUCSR, WUCSR_EEE_TX_WAKE_ |
5007					    WUCSR_EEE_RX_WAKE_ |
5008					    WUCSR_PFDA_FR_ |
5009					    WUCSR_RFE_WAKE_FR_ |
5010					    WUCSR_WUFR_ |
5011					    WUCSR_MPR_ |
5012					    WUCSR_BCST_FR_);
5013	if (ret < 0)
5014		goto out;
5015
5016	ret = 0;
5017out:
5018	mutex_unlock(&dev->dev_mutex);
5019
5020	return ret;
5021}
5022
5023static int lan78xx_reset_resume(struct usb_interface *intf)
5024{
5025	struct lan78xx_net *dev = usb_get_intfdata(intf);
5026	int ret;
5027
5028	netif_dbg(dev, ifup, dev->net, "(reset) resuming device");
5029
5030	ret = lan78xx_reset(dev);
5031	if (ret < 0)
5032		return ret;
5033
5034	phy_start(dev->net->phydev);
5035
5036	ret = lan78xx_resume(intf);
5037
5038	return ret;
5039}
5040
5041static const struct usb_device_id products[] = {
5042	{
5043	/* LAN7800 USB Gigabit Ethernet Device */
5044	USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7800_USB_PRODUCT_ID),
5045	},
5046	{
5047	/* LAN7850 USB Gigabit Ethernet Device */
5048	USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7850_USB_PRODUCT_ID),
5049	},
5050	{
5051	/* LAN7801 USB Gigabit Ethernet Device */
5052	USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7801_USB_PRODUCT_ID),
5053	},
5054	{
5055	/* ATM2-AF USB Gigabit Ethernet Device */
5056	USB_DEVICE(AT29M2AF_USB_VENDOR_ID, AT29M2AF_USB_PRODUCT_ID),
5057	},
5058	{},
5059};
5060MODULE_DEVICE_TABLE(usb, products);
5061
5062static struct usb_driver lan78xx_driver = {
5063	.name			= DRIVER_NAME,
5064	.id_table		= products,
5065	.probe			= lan78xx_probe,
5066	.disconnect		= lan78xx_disconnect,
5067	.suspend		= lan78xx_suspend,
5068	.resume			= lan78xx_resume,
5069	.reset_resume		= lan78xx_reset_resume,
5070	.supports_autosuspend	= 1,
5071	.disable_hub_initiated_lpm = 1,
5072};
5073
5074module_usb_driver(lan78xx_driver);
5075
5076MODULE_AUTHOR(DRIVER_AUTHOR);
5077MODULE_DESCRIPTION(DRIVER_DESC);
5078MODULE_LICENSE("GPL");