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