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#define DEFAULT_BURST_CAP_SIZE		(MAX_TX_FIFO_SIZE)
  50#define DEFAULT_BULK_IN_DELAY		(0x0800)
  51#define MAX_SINGLE_PACKET_SIZE		(9000)
  52#define DEFAULT_TX_CSUM_ENABLE		(true)
  53#define DEFAULT_RX_CSUM_ENABLE		(true)
  54#define DEFAULT_TSO_CSUM_ENABLE		(true)
  55#define DEFAULT_VLAN_FILTER_ENABLE	(true)
  56#define DEFAULT_VLAN_RX_OFFLOAD		(true)
  57#define TX_OVERHEAD			(8)
  58#define RXW_PADDING			2
  59
  60#define LAN78XX_USB_VENDOR_ID		(0x0424)
  61#define LAN7800_USB_PRODUCT_ID		(0x7800)
  62#define LAN7850_USB_PRODUCT_ID		(0x7850)
  63#define LAN7801_USB_PRODUCT_ID		(0x7801)
  64#define LAN78XX_EEPROM_MAGIC		(0x78A5)
  65#define LAN78XX_OTP_MAGIC		(0x78F3)
  66
  67#define	MII_READ			1
  68#define	MII_WRITE			0
  69
  70#define EEPROM_INDICATOR		(0xA5)
  71#define EEPROM_MAC_OFFSET		(0x01)
  72#define MAX_EEPROM_SIZE			512
  73#define OTP_INDICATOR_1			(0xF3)
  74#define OTP_INDICATOR_2			(0xF7)
  75
  76#define WAKE_ALL			(WAKE_PHY | WAKE_UCAST | \
  77					 WAKE_MCAST | WAKE_BCAST | \
  78					 WAKE_ARP | WAKE_MAGIC)
  79
  80/* USB related defines */
  81#define BULK_IN_PIPE			1
  82#define BULK_OUT_PIPE			2
  83
  84/* default autosuspend delay (mSec)*/
  85#define DEFAULT_AUTOSUSPEND_DELAY	(10 * 1000)
  86
  87/* statistic update interval (mSec) */
  88#define STAT_UPDATE_TIMER		(1 * 1000)
  89
  90/* defines interrupts from interrupt EP */
  91#define MAX_INT_EP			(32)
  92#define INT_EP_INTEP			(31)
  93#define INT_EP_OTP_WR_DONE		(28)
  94#define INT_EP_EEE_TX_LPI_START		(26)
  95#define INT_EP_EEE_TX_LPI_STOP		(25)
  96#define INT_EP_EEE_RX_LPI		(24)
  97#define INT_EP_MAC_RESET_TIMEOUT	(23)
  98#define INT_EP_RDFO			(22)
  99#define INT_EP_TXE			(21)
 100#define INT_EP_USB_STATUS		(20)
 101#define INT_EP_TX_DIS			(19)
 102#define INT_EP_RX_DIS			(18)
 103#define INT_EP_PHY			(17)
 104#define INT_EP_DP			(16)
 105#define INT_EP_MAC_ERR			(15)
 106#define INT_EP_TDFU			(14)
 107#define INT_EP_TDFO			(13)
 108#define INT_EP_UTX			(12)
 109#define INT_EP_GPIO_11			(11)
 110#define INT_EP_GPIO_10			(10)
 111#define INT_EP_GPIO_9			(9)
 112#define INT_EP_GPIO_8			(8)
 113#define INT_EP_GPIO_7			(7)
 114#define INT_EP_GPIO_6			(6)
 115#define INT_EP_GPIO_5			(5)
 116#define INT_EP_GPIO_4			(4)
 117#define INT_EP_GPIO_3			(3)
 118#define INT_EP_GPIO_2			(2)
 119#define INT_EP_GPIO_1			(1)
 120#define INT_EP_GPIO_0			(0)
 121
 122static const char lan78xx_gstrings[][ETH_GSTRING_LEN] = {
 123	"RX FCS Errors",
 124	"RX Alignment Errors",
 125	"Rx Fragment Errors",
 126	"RX Jabber Errors",
 127	"RX Undersize Frame Errors",
 128	"RX Oversize Frame Errors",
 129	"RX Dropped Frames",
 130	"RX Unicast Byte Count",
 131	"RX Broadcast Byte Count",
 132	"RX Multicast Byte Count",
 133	"RX Unicast Frames",
 134	"RX Broadcast Frames",
 135	"RX Multicast Frames",
 136	"RX Pause Frames",
 137	"RX 64 Byte Frames",
 138	"RX 65 - 127 Byte Frames",
 139	"RX 128 - 255 Byte Frames",
 140	"RX 256 - 511 Bytes Frames",
 141	"RX 512 - 1023 Byte Frames",
 142	"RX 1024 - 1518 Byte Frames",
 143	"RX Greater 1518 Byte Frames",
 144	"EEE RX LPI Transitions",
 145	"EEE RX LPI Time",
 146	"TX FCS Errors",
 147	"TX Excess Deferral Errors",
 148	"TX Carrier Errors",
 149	"TX Bad Byte Count",
 150	"TX Single Collisions",
 151	"TX Multiple Collisions",
 152	"TX Excessive Collision",
 153	"TX Late Collisions",
 154	"TX Unicast Byte Count",
 155	"TX Broadcast Byte Count",
 156	"TX Multicast Byte Count",
 157	"TX Unicast Frames",
 158	"TX Broadcast Frames",
 159	"TX Multicast Frames",
 160	"TX Pause Frames",
 161	"TX 64 Byte Frames",
 162	"TX 65 - 127 Byte Frames",
 163	"TX 128 - 255 Byte Frames",
 164	"TX 256 - 511 Bytes Frames",
 165	"TX 512 - 1023 Byte Frames",
 166	"TX 1024 - 1518 Byte Frames",
 167	"TX Greater 1518 Byte Frames",
 168	"EEE TX LPI Transitions",
 169	"EEE TX LPI Time",
 170};
 171
 172struct lan78xx_statstage {
 173	u32 rx_fcs_errors;
 174	u32 rx_alignment_errors;
 175	u32 rx_fragment_errors;
 176	u32 rx_jabber_errors;
 177	u32 rx_undersize_frame_errors;
 178	u32 rx_oversize_frame_errors;
 179	u32 rx_dropped_frames;
 180	u32 rx_unicast_byte_count;
 181	u32 rx_broadcast_byte_count;
 182	u32 rx_multicast_byte_count;
 183	u32 rx_unicast_frames;
 184	u32 rx_broadcast_frames;
 185	u32 rx_multicast_frames;
 186	u32 rx_pause_frames;
 187	u32 rx_64_byte_frames;
 188	u32 rx_65_127_byte_frames;
 189	u32 rx_128_255_byte_frames;
 190	u32 rx_256_511_bytes_frames;
 191	u32 rx_512_1023_byte_frames;
 192	u32 rx_1024_1518_byte_frames;
 193	u32 rx_greater_1518_byte_frames;
 194	u32 eee_rx_lpi_transitions;
 195	u32 eee_rx_lpi_time;
 196	u32 tx_fcs_errors;
 197	u32 tx_excess_deferral_errors;
 198	u32 tx_carrier_errors;
 199	u32 tx_bad_byte_count;
 200	u32 tx_single_collisions;
 201	u32 tx_multiple_collisions;
 202	u32 tx_excessive_collision;
 203	u32 tx_late_collisions;
 204	u32 tx_unicast_byte_count;
 205	u32 tx_broadcast_byte_count;
 206	u32 tx_multicast_byte_count;
 207	u32 tx_unicast_frames;
 208	u32 tx_broadcast_frames;
 209	u32 tx_multicast_frames;
 210	u32 tx_pause_frames;
 211	u32 tx_64_byte_frames;
 212	u32 tx_65_127_byte_frames;
 213	u32 tx_128_255_byte_frames;
 214	u32 tx_256_511_bytes_frames;
 215	u32 tx_512_1023_byte_frames;
 216	u32 tx_1024_1518_byte_frames;
 217	u32 tx_greater_1518_byte_frames;
 218	u32 eee_tx_lpi_transitions;
 219	u32 eee_tx_lpi_time;
 220};
 221
 222struct lan78xx_statstage64 {
 223	u64 rx_fcs_errors;
 224	u64 rx_alignment_errors;
 225	u64 rx_fragment_errors;
 226	u64 rx_jabber_errors;
 227	u64 rx_undersize_frame_errors;
 228	u64 rx_oversize_frame_errors;
 229	u64 rx_dropped_frames;
 230	u64 rx_unicast_byte_count;
 231	u64 rx_broadcast_byte_count;
 232	u64 rx_multicast_byte_count;
 233	u64 rx_unicast_frames;
 234	u64 rx_broadcast_frames;
 235	u64 rx_multicast_frames;
 236	u64 rx_pause_frames;
 237	u64 rx_64_byte_frames;
 238	u64 rx_65_127_byte_frames;
 239	u64 rx_128_255_byte_frames;
 240	u64 rx_256_511_bytes_frames;
 241	u64 rx_512_1023_byte_frames;
 242	u64 rx_1024_1518_byte_frames;
 243	u64 rx_greater_1518_byte_frames;
 244	u64 eee_rx_lpi_transitions;
 245	u64 eee_rx_lpi_time;
 246	u64 tx_fcs_errors;
 247	u64 tx_excess_deferral_errors;
 248	u64 tx_carrier_errors;
 249	u64 tx_bad_byte_count;
 250	u64 tx_single_collisions;
 251	u64 tx_multiple_collisions;
 252	u64 tx_excessive_collision;
 253	u64 tx_late_collisions;
 254	u64 tx_unicast_byte_count;
 255	u64 tx_broadcast_byte_count;
 256	u64 tx_multicast_byte_count;
 257	u64 tx_unicast_frames;
 258	u64 tx_broadcast_frames;
 259	u64 tx_multicast_frames;
 260	u64 tx_pause_frames;
 261	u64 tx_64_byte_frames;
 262	u64 tx_65_127_byte_frames;
 263	u64 tx_128_255_byte_frames;
 264	u64 tx_256_511_bytes_frames;
 265	u64 tx_512_1023_byte_frames;
 266	u64 tx_1024_1518_byte_frames;
 267	u64 tx_greater_1518_byte_frames;
 268	u64 eee_tx_lpi_transitions;
 269	u64 eee_tx_lpi_time;
 270};
 271
 272static u32 lan78xx_regs[] = {
 273	ID_REV,
 274	INT_STS,
 275	HW_CFG,
 276	PMT_CTL,
 277	E2P_CMD,
 278	E2P_DATA,
 279	USB_STATUS,
 280	VLAN_TYPE,
 281	MAC_CR,
 282	MAC_RX,
 283	MAC_TX,
 284	FLOW,
 285	ERR_STS,
 286	MII_ACC,
 287	MII_DATA,
 288	EEE_TX_LPI_REQ_DLY,
 289	EEE_TW_TX_SYS,
 290	EEE_TX_LPI_REM_DLY,
 291	WUCSR
 292};
 293
 294#define PHY_REG_SIZE (32 * sizeof(u32))
 295
 296struct lan78xx_net;
 297
 298struct lan78xx_priv {
 299	struct lan78xx_net *dev;
 300	u32 rfe_ctl;
 301	u32 mchash_table[DP_SEL_VHF_HASH_LEN]; /* multicast hash table */
 302	u32 pfilter_table[NUM_OF_MAF][2]; /* perfect filter table */
 303	u32 vlan_table[DP_SEL_VHF_VLAN_LEN];
 304	struct mutex dataport_mutex; /* for dataport access */
 305	spinlock_t rfe_ctl_lock; /* for rfe register access */
 306	struct work_struct set_multicast;
 307	struct work_struct set_vlan;
 308	u32 wol;
 309};
 310
 311enum skb_state {
 312	illegal = 0,
 313	tx_start,
 314	tx_done,
 315	rx_start,
 316	rx_done,
 317	rx_cleanup,
 318	unlink_start
 319};
 320
 321struct skb_data {		/* skb->cb is one of these */
 322	struct urb *urb;
 323	struct lan78xx_net *dev;
 324	enum skb_state state;
 325	size_t length;
 326	int num_of_packet;
 327};
 328
 329struct usb_context {
 330	struct usb_ctrlrequest req;
 331	struct lan78xx_net *dev;
 332};
 333
 334#define EVENT_TX_HALT			0
 335#define EVENT_RX_HALT			1
 336#define EVENT_RX_MEMORY			2
 337#define EVENT_STS_SPLIT			3
 338#define EVENT_LINK_RESET		4
 339#define EVENT_RX_PAUSED			5
 340#define EVENT_DEV_WAKING		6
 341#define EVENT_DEV_ASLEEP		7
 342#define EVENT_DEV_OPEN			8
 343#define EVENT_STAT_UPDATE		9
 344
 345struct statstage {
 346	struct mutex			access_lock;	/* for stats access */
 347	struct lan78xx_statstage	saved;
 348	struct lan78xx_statstage	rollover_count;
 349	struct lan78xx_statstage	rollover_max;
 350	struct lan78xx_statstage64	curr_stat;
 351};
 352
 353struct irq_domain_data {
 354	struct irq_domain	*irqdomain;
 355	unsigned int		phyirq;
 356	struct irq_chip		*irqchip;
 357	irq_flow_handler_t	irq_handler;
 358	u32			irqenable;
 359	struct mutex		irq_lock;		/* for irq bus access */
 360};
 361
 362struct lan78xx_net {
 363	struct net_device	*net;
 364	struct usb_device	*udev;
 365	struct usb_interface	*intf;
 366	void			*driver_priv;
 367
 368	int			rx_qlen;
 369	int			tx_qlen;
 370	struct sk_buff_head	rxq;
 371	struct sk_buff_head	txq;
 372	struct sk_buff_head	done;
 373	struct sk_buff_head	rxq_pause;
 374	struct sk_buff_head	txq_pend;
 375
 376	struct tasklet_struct	bh;
 377	struct delayed_work	wq;
 378
 
 
 
 
 379	int			msg_enable;
 380
 381	struct urb		*urb_intr;
 382	struct usb_anchor	deferred;
 383
 384	struct mutex		phy_mutex; /* for phy access */
 385	unsigned		pipe_in, pipe_out, pipe_intr;
 386
 387	u32			hard_mtu;	/* count any extra framing */
 388	size_t			rx_urb_size;	/* size for rx urbs */
 389
 390	unsigned long		flags;
 391
 392	wait_queue_head_t	*wait;
 393	unsigned char		suspend_count;
 394
 395	unsigned		maxpacket;
 396	struct timer_list	delay;
 397	struct timer_list	stat_monitor;
 398
 399	unsigned long		data[5];
 400
 401	int			link_on;
 402	u8			mdix_ctrl;
 403
 404	u32			chipid;
 405	u32			chiprev;
 406	struct mii_bus		*mdiobus;
 407	phy_interface_t		interface;
 408
 409	int			fc_autoneg;
 410	u8			fc_request_control;
 411
 412	int			delta;
 413	struct statstage	stats;
 414
 415	struct irq_domain_data	domain_data;
 416};
 417
 418/* define external phy id */
 419#define	PHY_LAN8835			(0x0007C130)
 420#define	PHY_KSZ9031RNX			(0x00221620)
 421
 422/* use ethtool to change the level for any given device */
 423static int msg_level = -1;
 424module_param(msg_level, int, 0);
 425MODULE_PARM_DESC(msg_level, "Override default message level");
 426
 427static int lan78xx_read_reg(struct lan78xx_net *dev, u32 index, u32 *data)
 428{
 429	u32 *buf = kmalloc(sizeof(u32), GFP_KERNEL);
 430	int ret;
 431
 432	if (!buf)
 433		return -ENOMEM;
 434
 435	ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
 436			      USB_VENDOR_REQUEST_READ_REGISTER,
 437			      USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 438			      0, index, buf, 4, USB_CTRL_GET_TIMEOUT);
 439	if (likely(ret >= 0)) {
 440		le32_to_cpus(buf);
 441		*data = *buf;
 442	} else {
 443		netdev_warn(dev->net,
 444			    "Failed to read register index 0x%08x. ret = %d",
 445			    index, ret);
 446	}
 447
 448	kfree(buf);
 449
 450	return ret;
 451}
 452
 453static int lan78xx_write_reg(struct lan78xx_net *dev, u32 index, u32 data)
 454{
 455	u32 *buf = kmalloc(sizeof(u32), GFP_KERNEL);
 456	int ret;
 457
 458	if (!buf)
 459		return -ENOMEM;
 460
 461	*buf = data;
 462	cpu_to_le32s(buf);
 463
 464	ret = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
 465			      USB_VENDOR_REQUEST_WRITE_REGISTER,
 466			      USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 467			      0, index, buf, 4, USB_CTRL_SET_TIMEOUT);
 468	if (unlikely(ret < 0)) {
 469		netdev_warn(dev->net,
 470			    "Failed to write register index 0x%08x. ret = %d",
 471			    index, ret);
 472	}
 473
 474	kfree(buf);
 475
 476	return ret;
 477}
 478
 479static int lan78xx_read_stats(struct lan78xx_net *dev,
 480			      struct lan78xx_statstage *data)
 481{
 482	int ret = 0;
 483	int i;
 484	struct lan78xx_statstage *stats;
 485	u32 *src;
 486	u32 *dst;
 487
 488	stats = kmalloc(sizeof(*stats), GFP_KERNEL);
 489	if (!stats)
 490		return -ENOMEM;
 491
 492	ret = usb_control_msg(dev->udev,
 493			      usb_rcvctrlpipe(dev->udev, 0),
 494			      USB_VENDOR_REQUEST_GET_STATS,
 495			      USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 496			      0,
 497			      0,
 498			      (void *)stats,
 499			      sizeof(*stats),
 500			      USB_CTRL_SET_TIMEOUT);
 501	if (likely(ret >= 0)) {
 502		src = (u32 *)stats;
 503		dst = (u32 *)data;
 504		for (i = 0; i < sizeof(*stats)/sizeof(u32); i++) {
 505			le32_to_cpus(&src[i]);
 506			dst[i] = src[i];
 507		}
 508	} else {
 509		netdev_warn(dev->net,
 510			    "Failed to read stat ret = %d", ret);
 511	}
 512
 513	kfree(stats);
 514
 515	return ret;
 516}
 517
 518#define check_counter_rollover(struct1, dev_stats, member) {	\
 519	if (struct1->member < dev_stats.saved.member)		\
 520		dev_stats.rollover_count.member++;		\
 521	}
 522
 523static void lan78xx_check_stat_rollover(struct lan78xx_net *dev,
 524					struct lan78xx_statstage *stats)
 525{
 526	check_counter_rollover(stats, dev->stats, rx_fcs_errors);
 527	check_counter_rollover(stats, dev->stats, rx_alignment_errors);
 528	check_counter_rollover(stats, dev->stats, rx_fragment_errors);
 529	check_counter_rollover(stats, dev->stats, rx_jabber_errors);
 530	check_counter_rollover(stats, dev->stats, rx_undersize_frame_errors);
 531	check_counter_rollover(stats, dev->stats, rx_oversize_frame_errors);
 532	check_counter_rollover(stats, dev->stats, rx_dropped_frames);
 533	check_counter_rollover(stats, dev->stats, rx_unicast_byte_count);
 534	check_counter_rollover(stats, dev->stats, rx_broadcast_byte_count);
 535	check_counter_rollover(stats, dev->stats, rx_multicast_byte_count);
 536	check_counter_rollover(stats, dev->stats, rx_unicast_frames);
 537	check_counter_rollover(stats, dev->stats, rx_broadcast_frames);
 538	check_counter_rollover(stats, dev->stats, rx_multicast_frames);
 539	check_counter_rollover(stats, dev->stats, rx_pause_frames);
 540	check_counter_rollover(stats, dev->stats, rx_64_byte_frames);
 541	check_counter_rollover(stats, dev->stats, rx_65_127_byte_frames);
 542	check_counter_rollover(stats, dev->stats, rx_128_255_byte_frames);
 543	check_counter_rollover(stats, dev->stats, rx_256_511_bytes_frames);
 544	check_counter_rollover(stats, dev->stats, rx_512_1023_byte_frames);
 545	check_counter_rollover(stats, dev->stats, rx_1024_1518_byte_frames);
 546	check_counter_rollover(stats, dev->stats, rx_greater_1518_byte_frames);
 547	check_counter_rollover(stats, dev->stats, eee_rx_lpi_transitions);
 548	check_counter_rollover(stats, dev->stats, eee_rx_lpi_time);
 549	check_counter_rollover(stats, dev->stats, tx_fcs_errors);
 550	check_counter_rollover(stats, dev->stats, tx_excess_deferral_errors);
 551	check_counter_rollover(stats, dev->stats, tx_carrier_errors);
 552	check_counter_rollover(stats, dev->stats, tx_bad_byte_count);
 553	check_counter_rollover(stats, dev->stats, tx_single_collisions);
 554	check_counter_rollover(stats, dev->stats, tx_multiple_collisions);
 555	check_counter_rollover(stats, dev->stats, tx_excessive_collision);
 556	check_counter_rollover(stats, dev->stats, tx_late_collisions);
 557	check_counter_rollover(stats, dev->stats, tx_unicast_byte_count);
 558	check_counter_rollover(stats, dev->stats, tx_broadcast_byte_count);
 559	check_counter_rollover(stats, dev->stats, tx_multicast_byte_count);
 560	check_counter_rollover(stats, dev->stats, tx_unicast_frames);
 561	check_counter_rollover(stats, dev->stats, tx_broadcast_frames);
 562	check_counter_rollover(stats, dev->stats, tx_multicast_frames);
 563	check_counter_rollover(stats, dev->stats, tx_pause_frames);
 564	check_counter_rollover(stats, dev->stats, tx_64_byte_frames);
 565	check_counter_rollover(stats, dev->stats, tx_65_127_byte_frames);
 566	check_counter_rollover(stats, dev->stats, tx_128_255_byte_frames);
 567	check_counter_rollover(stats, dev->stats, tx_256_511_bytes_frames);
 568	check_counter_rollover(stats, dev->stats, tx_512_1023_byte_frames);
 569	check_counter_rollover(stats, dev->stats, tx_1024_1518_byte_frames);
 570	check_counter_rollover(stats, dev->stats, tx_greater_1518_byte_frames);
 571	check_counter_rollover(stats, dev->stats, eee_tx_lpi_transitions);
 572	check_counter_rollover(stats, dev->stats, eee_tx_lpi_time);
 573
 574	memcpy(&dev->stats.saved, stats, sizeof(struct lan78xx_statstage));
 575}
 576
 577static void lan78xx_update_stats(struct lan78xx_net *dev)
 578{
 579	u32 *p, *count, *max;
 580	u64 *data;
 581	int i;
 582	struct lan78xx_statstage lan78xx_stats;
 583
 584	if (usb_autopm_get_interface(dev->intf) < 0)
 585		return;
 586
 587	p = (u32 *)&lan78xx_stats;
 588	count = (u32 *)&dev->stats.rollover_count;
 589	max = (u32 *)&dev->stats.rollover_max;
 590	data = (u64 *)&dev->stats.curr_stat;
 591
 592	mutex_lock(&dev->stats.access_lock);
 593
 594	if (lan78xx_read_stats(dev, &lan78xx_stats) > 0)
 595		lan78xx_check_stat_rollover(dev, &lan78xx_stats);
 596
 597	for (i = 0; i < (sizeof(lan78xx_stats) / (sizeof(u32))); i++)
 598		data[i] = (u64)p[i] + ((u64)count[i] * ((u64)max[i] + 1));
 599
 600	mutex_unlock(&dev->stats.access_lock);
 601
 602	usb_autopm_put_interface(dev->intf);
 603}
 604
 605/* Loop until the read is completed with timeout called with phy_mutex held */
 606static int lan78xx_phy_wait_not_busy(struct lan78xx_net *dev)
 607{
 608	unsigned long start_time = jiffies;
 609	u32 val;
 610	int ret;
 611
 612	do {
 613		ret = lan78xx_read_reg(dev, MII_ACC, &val);
 614		if (unlikely(ret < 0))
 615			return -EIO;
 616
 617		if (!(val & MII_ACC_MII_BUSY_))
 618			return 0;
 619	} while (!time_after(jiffies, start_time + HZ));
 620
 621	return -EIO;
 622}
 623
 624static inline u32 mii_access(int id, int index, int read)
 625{
 626	u32 ret;
 627
 628	ret = ((u32)id << MII_ACC_PHY_ADDR_SHIFT_) & MII_ACC_PHY_ADDR_MASK_;
 629	ret |= ((u32)index << MII_ACC_MIIRINDA_SHIFT_) & MII_ACC_MIIRINDA_MASK_;
 630	if (read)
 631		ret |= MII_ACC_MII_READ_;
 632	else
 633		ret |= MII_ACC_MII_WRITE_;
 634	ret |= MII_ACC_MII_BUSY_;
 635
 636	return ret;
 637}
 638
 639static int lan78xx_wait_eeprom(struct lan78xx_net *dev)
 640{
 641	unsigned long start_time = jiffies;
 642	u32 val;
 643	int ret;
 644
 645	do {
 646		ret = lan78xx_read_reg(dev, E2P_CMD, &val);
 647		if (unlikely(ret < 0))
 648			return -EIO;
 649
 650		if (!(val & E2P_CMD_EPC_BUSY_) ||
 651		    (val & E2P_CMD_EPC_TIMEOUT_))
 652			break;
 653		usleep_range(40, 100);
 654	} while (!time_after(jiffies, start_time + HZ));
 655
 656	if (val & (E2P_CMD_EPC_TIMEOUT_ | E2P_CMD_EPC_BUSY_)) {
 657		netdev_warn(dev->net, "EEPROM read operation timeout");
 658		return -EIO;
 659	}
 660
 661	return 0;
 662}
 663
 664static int lan78xx_eeprom_confirm_not_busy(struct lan78xx_net *dev)
 665{
 666	unsigned long start_time = jiffies;
 667	u32 val;
 668	int ret;
 669
 670	do {
 671		ret = lan78xx_read_reg(dev, E2P_CMD, &val);
 672		if (unlikely(ret < 0))
 673			return -EIO;
 674
 675		if (!(val & E2P_CMD_EPC_BUSY_))
 676			return 0;
 677
 678		usleep_range(40, 100);
 679	} while (!time_after(jiffies, start_time + HZ));
 680
 681	netdev_warn(dev->net, "EEPROM is busy");
 682	return -EIO;
 683}
 684
 685static int lan78xx_read_raw_eeprom(struct lan78xx_net *dev, u32 offset,
 686				   u32 length, u8 *data)
 687{
 688	u32 val;
 689	u32 saved;
 690	int i, ret;
 691	int retval;
 692
 693	/* depends on chip, some EEPROM pins are muxed with LED function.
 694	 * disable & restore LED function to access EEPROM.
 695	 */
 696	ret = lan78xx_read_reg(dev, HW_CFG, &val);
 697	saved = val;
 698	if (dev->chipid == ID_REV_CHIP_ID_7800_) {
 699		val &= ~(HW_CFG_LED1_EN_ | HW_CFG_LED0_EN_);
 700		ret = lan78xx_write_reg(dev, HW_CFG, val);
 701	}
 702
 703	retval = lan78xx_eeprom_confirm_not_busy(dev);
 704	if (retval)
 705		return retval;
 706
 707	for (i = 0; i < length; i++) {
 708		val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_READ_;
 709		val |= (offset & E2P_CMD_EPC_ADDR_MASK_);
 710		ret = lan78xx_write_reg(dev, E2P_CMD, val);
 711		if (unlikely(ret < 0)) {
 712			retval = -EIO;
 713			goto exit;
 714		}
 715
 716		retval = lan78xx_wait_eeprom(dev);
 717		if (retval < 0)
 718			goto exit;
 719
 720		ret = lan78xx_read_reg(dev, E2P_DATA, &val);
 721		if (unlikely(ret < 0)) {
 722			retval = -EIO;
 723			goto exit;
 724		}
 725
 726		data[i] = val & 0xFF;
 727		offset++;
 728	}
 729
 730	retval = 0;
 731exit:
 732	if (dev->chipid == ID_REV_CHIP_ID_7800_)
 733		ret = lan78xx_write_reg(dev, HW_CFG, saved);
 734
 735	return retval;
 736}
 737
 738static int lan78xx_read_eeprom(struct lan78xx_net *dev, u32 offset,
 739			       u32 length, u8 *data)
 740{
 741	u8 sig;
 742	int ret;
 743
 744	ret = lan78xx_read_raw_eeprom(dev, 0, 1, &sig);
 745	if ((ret == 0) && (sig == EEPROM_INDICATOR))
 746		ret = lan78xx_read_raw_eeprom(dev, offset, length, data);
 747	else
 748		ret = -EINVAL;
 749
 750	return ret;
 751}
 752
 753static int lan78xx_write_raw_eeprom(struct lan78xx_net *dev, u32 offset,
 754				    u32 length, u8 *data)
 755{
 756	u32 val;
 757	u32 saved;
 758	int i, ret;
 759	int retval;
 760
 761	/* depends on chip, some EEPROM pins are muxed with LED function.
 762	 * disable & restore LED function to access EEPROM.
 763	 */
 764	ret = lan78xx_read_reg(dev, HW_CFG, &val);
 765	saved = val;
 766	if (dev->chipid == ID_REV_CHIP_ID_7800_) {
 767		val &= ~(HW_CFG_LED1_EN_ | HW_CFG_LED0_EN_);
 768		ret = lan78xx_write_reg(dev, HW_CFG, val);
 769	}
 770
 771	retval = lan78xx_eeprom_confirm_not_busy(dev);
 772	if (retval)
 773		goto exit;
 774
 775	/* Issue write/erase enable command */
 776	val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_EWEN_;
 777	ret = lan78xx_write_reg(dev, E2P_CMD, val);
 778	if (unlikely(ret < 0)) {
 779		retval = -EIO;
 780		goto exit;
 781	}
 782
 783	retval = lan78xx_wait_eeprom(dev);
 784	if (retval < 0)
 785		goto exit;
 786
 787	for (i = 0; i < length; i++) {
 788		/* Fill data register */
 789		val = data[i];
 790		ret = lan78xx_write_reg(dev, E2P_DATA, val);
 791		if (ret < 0) {
 792			retval = -EIO;
 793			goto exit;
 794		}
 795
 796		/* Send "write" command */
 797		val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_WRITE_;
 798		val |= (offset & E2P_CMD_EPC_ADDR_MASK_);
 799		ret = lan78xx_write_reg(dev, E2P_CMD, val);
 800		if (ret < 0) {
 801			retval = -EIO;
 802			goto exit;
 803		}
 804
 805		retval = lan78xx_wait_eeprom(dev);
 806		if (retval < 0)
 807			goto exit;
 808
 809		offset++;
 810	}
 811
 812	retval = 0;
 813exit:
 814	if (dev->chipid == ID_REV_CHIP_ID_7800_)
 815		ret = lan78xx_write_reg(dev, HW_CFG, saved);
 816
 817	return retval;
 818}
 819
 820static int lan78xx_read_raw_otp(struct lan78xx_net *dev, u32 offset,
 821				u32 length, u8 *data)
 822{
 823	int i;
 
 824	u32 buf;
 825	unsigned long timeout;
 826
 827	lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
 828
 829	if (buf & OTP_PWR_DN_PWRDN_N_) {
 830		/* clear it and wait to be cleared */
 831		lan78xx_write_reg(dev, OTP_PWR_DN, 0);
 832
 833		timeout = jiffies + HZ;
 834		do {
 835			usleep_range(1, 10);
 836			lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
 837			if (time_after(jiffies, timeout)) {
 838				netdev_warn(dev->net,
 839					    "timeout on OTP_PWR_DN");
 840				return -EIO;
 841			}
 842		} while (buf & OTP_PWR_DN_PWRDN_N_);
 843	}
 844
 845	for (i = 0; i < length; i++) {
 846		lan78xx_write_reg(dev, OTP_ADDR1,
 847					((offset + i) >> 8) & OTP_ADDR1_15_11);
 848		lan78xx_write_reg(dev, OTP_ADDR2,
 849					((offset + i) & OTP_ADDR2_10_3));
 850
 851		lan78xx_write_reg(dev, OTP_FUNC_CMD, OTP_FUNC_CMD_READ_);
 852		lan78xx_write_reg(dev, OTP_CMD_GO, OTP_CMD_GO_GO_);
 853
 854		timeout = jiffies + HZ;
 855		do {
 856			udelay(1);
 857			lan78xx_read_reg(dev, OTP_STATUS, &buf);
 858			if (time_after(jiffies, timeout)) {
 859				netdev_warn(dev->net,
 860					    "timeout on OTP_STATUS");
 861				return -EIO;
 862			}
 863		} while (buf & OTP_STATUS_BUSY_);
 864
 865		lan78xx_read_reg(dev, OTP_RD_DATA, &buf);
 866
 867		data[i] = (u8)(buf & 0xFF);
 868	}
 869
 870	return 0;
 871}
 872
 873static int lan78xx_write_raw_otp(struct lan78xx_net *dev, u32 offset,
 874				 u32 length, u8 *data)
 875{
 876	int i;
 
 877	u32 buf;
 878	unsigned long timeout;
 879
 880	lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
 881
 882	if (buf & OTP_PWR_DN_PWRDN_N_) {
 883		/* clear it and wait to be cleared */
 884		lan78xx_write_reg(dev, OTP_PWR_DN, 0);
 885
 886		timeout = jiffies + HZ;
 887		do {
 888			udelay(1);
 889			lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
 890			if (time_after(jiffies, timeout)) {
 891				netdev_warn(dev->net,
 892					    "timeout on OTP_PWR_DN completion");
 893				return -EIO;
 894			}
 895		} while (buf & OTP_PWR_DN_PWRDN_N_);
 896	}
 897
 898	/* set to BYTE program mode */
 899	lan78xx_write_reg(dev, OTP_PRGM_MODE, OTP_PRGM_MODE_BYTE_);
 900
 901	for (i = 0; i < length; i++) {
 902		lan78xx_write_reg(dev, OTP_ADDR1,
 903					((offset + i) >> 8) & OTP_ADDR1_15_11);
 904		lan78xx_write_reg(dev, OTP_ADDR2,
 905					((offset + i) & OTP_ADDR2_10_3));
 906		lan78xx_write_reg(dev, OTP_PRGM_DATA, data[i]);
 907		lan78xx_write_reg(dev, OTP_TST_CMD, OTP_TST_CMD_PRGVRFY_);
 908		lan78xx_write_reg(dev, OTP_CMD_GO, OTP_CMD_GO_GO_);
 909
 910		timeout = jiffies + HZ;
 911		do {
 912			udelay(1);
 913			lan78xx_read_reg(dev, OTP_STATUS, &buf);
 914			if (time_after(jiffies, timeout)) {
 915				netdev_warn(dev->net,
 916					    "Timeout on OTP_STATUS completion");
 917				return -EIO;
 918			}
 919		} while (buf & OTP_STATUS_BUSY_);
 920	}
 921
 922	return 0;
 923}
 924
 925static int lan78xx_read_otp(struct lan78xx_net *dev, u32 offset,
 926			    u32 length, u8 *data)
 927{
 928	u8 sig;
 929	int ret;
 930
 931	ret = lan78xx_read_raw_otp(dev, 0, 1, &sig);
 932
 933	if (ret == 0) {
 934		if (sig == OTP_INDICATOR_2)
 
 
 935			offset += 0x100;
 936		else if (sig != OTP_INDICATOR_1)
 937			ret = -EINVAL;
 938		if (!ret)
 939			ret = lan78xx_read_raw_otp(dev, offset, length, data);
 940	}
 941
 942	return ret;
 943}
 944
 945static int lan78xx_dataport_wait_not_busy(struct lan78xx_net *dev)
 946{
 947	int i, ret;
 948
 949	for (i = 0; i < 100; i++) {
 950		u32 dp_sel;
 951
 952		ret = lan78xx_read_reg(dev, DP_SEL, &dp_sel);
 953		if (unlikely(ret < 0))
 954			return -EIO;
 955
 956		if (dp_sel & DP_SEL_DPRDY_)
 957			return 0;
 958
 959		usleep_range(40, 100);
 960	}
 961
 962	netdev_warn(dev->net, "lan78xx_dataport_wait_not_busy timed out");
 963
 964	return -EIO;
 965}
 966
 967static int lan78xx_dataport_write(struct lan78xx_net *dev, u32 ram_select,
 968				  u32 addr, u32 length, u32 *buf)
 969{
 970	struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
 971	u32 dp_sel;
 972	int i, ret;
 973
 974	if (usb_autopm_get_interface(dev->intf) < 0)
 975			return 0;
 976
 977	mutex_lock(&pdata->dataport_mutex);
 978
 979	ret = lan78xx_dataport_wait_not_busy(dev);
 980	if (ret < 0)
 981		goto done;
 982
 983	ret = lan78xx_read_reg(dev, DP_SEL, &dp_sel);
 984
 985	dp_sel &= ~DP_SEL_RSEL_MASK_;
 986	dp_sel |= ram_select;
 987	ret = lan78xx_write_reg(dev, DP_SEL, dp_sel);
 988
 989	for (i = 0; i < length; i++) {
 990		ret = lan78xx_write_reg(dev, DP_ADDR, addr + i);
 991
 992		ret = lan78xx_write_reg(dev, DP_DATA, buf[i]);
 993
 994		ret = lan78xx_write_reg(dev, DP_CMD, DP_CMD_WRITE_);
 995
 996		ret = lan78xx_dataport_wait_not_busy(dev);
 997		if (ret < 0)
 998			goto done;
 999	}
1000
1001done:
1002	mutex_unlock(&pdata->dataport_mutex);
1003	usb_autopm_put_interface(dev->intf);
1004
1005	return ret;
1006}
1007
1008static void lan78xx_set_addr_filter(struct lan78xx_priv *pdata,
1009				    int index, u8 addr[ETH_ALEN])
1010{
1011	u32 temp;
1012
1013	if ((pdata) && (index > 0) && (index < NUM_OF_MAF)) {
1014		temp = addr[3];
1015		temp = addr[2] | (temp << 8);
1016		temp = addr[1] | (temp << 8);
1017		temp = addr[0] | (temp << 8);
1018		pdata->pfilter_table[index][1] = temp;
1019		temp = addr[5];
1020		temp = addr[4] | (temp << 8);
1021		temp |= MAF_HI_VALID_ | MAF_HI_TYPE_DST_;
1022		pdata->pfilter_table[index][0] = temp;
1023	}
1024}
1025
1026/* returns hash bit number for given MAC address */
1027static inline u32 lan78xx_hash(char addr[ETH_ALEN])
1028{
1029	return (ether_crc(ETH_ALEN, addr) >> 23) & 0x1ff;
1030}
1031
1032static void lan78xx_deferred_multicast_write(struct work_struct *param)
1033{
1034	struct lan78xx_priv *pdata =
1035			container_of(param, struct lan78xx_priv, set_multicast);
1036	struct lan78xx_net *dev = pdata->dev;
1037	int i;
 
1038
1039	netif_dbg(dev, drv, dev->net, "deferred multicast write 0x%08x\n",
1040		  pdata->rfe_ctl);
1041
1042	lan78xx_dataport_write(dev, DP_SEL_RSEL_VLAN_DA_, DP_SEL_VHF_VLAN_LEN,
1043			       DP_SEL_VHF_HASH_LEN, pdata->mchash_table);
1044
1045	for (i = 1; i < NUM_OF_MAF; i++) {
1046		lan78xx_write_reg(dev, MAF_HI(i), 0);
1047		lan78xx_write_reg(dev, MAF_LO(i),
1048					pdata->pfilter_table[i][1]);
1049		lan78xx_write_reg(dev, MAF_HI(i),
1050					pdata->pfilter_table[i][0]);
1051	}
1052
1053	lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
1054}
1055
1056static void lan78xx_set_multicast(struct net_device *netdev)
1057{
1058	struct lan78xx_net *dev = netdev_priv(netdev);
1059	struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1060	unsigned long flags;
1061	int i;
1062
1063	spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);
1064
1065	pdata->rfe_ctl &= ~(RFE_CTL_UCAST_EN_ | RFE_CTL_MCAST_EN_ |
1066			    RFE_CTL_DA_PERFECT_ | RFE_CTL_MCAST_HASH_);
1067
1068	for (i = 0; i < DP_SEL_VHF_HASH_LEN; i++)
1069			pdata->mchash_table[i] = 0;
1070	/* pfilter_table[0] has own HW address */
1071	for (i = 1; i < NUM_OF_MAF; i++) {
1072			pdata->pfilter_table[i][0] =
1073			pdata->pfilter_table[i][1] = 0;
1074	}
1075
1076	pdata->rfe_ctl |= RFE_CTL_BCAST_EN_;
1077
1078	if (dev->net->flags & IFF_PROMISC) {
1079		netif_dbg(dev, drv, dev->net, "promiscuous mode enabled");
1080		pdata->rfe_ctl |= RFE_CTL_MCAST_EN_ | RFE_CTL_UCAST_EN_;
1081	} else {
1082		if (dev->net->flags & IFF_ALLMULTI) {
1083			netif_dbg(dev, drv, dev->net,
1084				  "receive all multicast enabled");
1085			pdata->rfe_ctl |= RFE_CTL_MCAST_EN_;
1086		}
1087	}
1088
1089	if (netdev_mc_count(dev->net)) {
1090		struct netdev_hw_addr *ha;
1091		int i;
1092
1093		netif_dbg(dev, drv, dev->net, "receive multicast hash filter");
1094
1095		pdata->rfe_ctl |= RFE_CTL_DA_PERFECT_;
1096
1097		i = 1;
1098		netdev_for_each_mc_addr(ha, netdev) {
1099			/* set first 32 into Perfect Filter */
1100			if (i < 33) {
1101				lan78xx_set_addr_filter(pdata, i, ha->addr);
1102			} else {
1103				u32 bitnum = lan78xx_hash(ha->addr);
1104
1105				pdata->mchash_table[bitnum / 32] |=
1106							(1 << (bitnum % 32));
1107				pdata->rfe_ctl |= RFE_CTL_MCAST_HASH_;
1108			}
1109			i++;
1110		}
1111	}
1112
1113	spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags);
1114
1115	/* defer register writes to a sleepable context */
1116	schedule_work(&pdata->set_multicast);
1117}
1118
1119static int lan78xx_update_flowcontrol(struct lan78xx_net *dev, u8 duplex,
1120				      u16 lcladv, u16 rmtadv)
1121{
1122	u32 flow = 0, fct_flow = 0;
 
1123	u8 cap;
1124
1125	if (dev->fc_autoneg)
1126		cap = mii_resolve_flowctrl_fdx(lcladv, rmtadv);
1127	else
1128		cap = dev->fc_request_control;
1129
1130	if (cap & FLOW_CTRL_TX)
1131		flow |= (FLOW_CR_TX_FCEN_ | 0xFFFF);
1132
1133	if (cap & FLOW_CTRL_RX)
1134		flow |= FLOW_CR_RX_FCEN_;
1135
1136	if (dev->udev->speed == USB_SPEED_SUPER)
1137		fct_flow = 0x817;
1138	else if (dev->udev->speed == USB_SPEED_HIGH)
1139		fct_flow = 0x211;
1140
1141	netif_dbg(dev, link, dev->net, "rx pause %s, tx pause %s",
1142		  (cap & FLOW_CTRL_RX ? "enabled" : "disabled"),
1143		  (cap & FLOW_CTRL_TX ? "enabled" : "disabled"));
1144
1145	lan78xx_write_reg(dev, FCT_FLOW, fct_flow);
1146
1147	/* threshold value should be set before enabling flow */
1148	lan78xx_write_reg(dev, FLOW, flow);
1149
1150	return 0;
1151}
1152
1153static int lan78xx_link_reset(struct lan78xx_net *dev)
1154{
1155	struct phy_device *phydev = dev->net->phydev;
1156	struct ethtool_link_ksettings ecmd;
1157	int ladv, radv, ret, link;
1158	u32 buf;
1159
 
 
 
 
 
1160	/* clear LAN78xx interrupt status */
1161	ret = lan78xx_write_reg(dev, INT_STS, INT_STS_PHY_INT_);
1162	if (unlikely(ret < 0))
1163		return -EIO;
1164
1165	mutex_lock(&phydev->lock);
1166	phy_read_status(phydev);
1167	link = phydev->link;
1168	mutex_unlock(&phydev->lock);
1169
1170	if (!link && dev->link_on) {
1171		dev->link_on = false;
1172
1173		/* reset MAC */
1174		ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1175		if (unlikely(ret < 0))
1176			return -EIO;
1177		buf |= MAC_CR_RST_;
1178		ret = lan78xx_write_reg(dev, MAC_CR, buf);
1179		if (unlikely(ret < 0))
1180			return -EIO;
1181
 
 
1182		del_timer(&dev->stat_monitor);
1183	} else if (link && !dev->link_on) {
1184		dev->link_on = true;
1185
1186		phy_ethtool_ksettings_get(phydev, &ecmd);
 
 
1187
1188		if (dev->udev->speed == USB_SPEED_SUPER) {
1189			if (ecmd.base.speed == 1000) {
1190				/* disable U2 */
1191				ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1192				buf &= ~USB_CFG1_DEV_U2_INIT_EN_;
1193				ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1194				/* enable U1 */
1195				ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1196				buf |= USB_CFG1_DEV_U1_INIT_EN_;
1197				ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1198			} else {
1199				/* enable U1 & U2 */
1200				ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1201				buf |= USB_CFG1_DEV_U2_INIT_EN_;
1202				buf |= USB_CFG1_DEV_U1_INIT_EN_;
1203				ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1204			}
1205		}
1206
1207		ladv = phy_read(phydev, MII_ADVERTISE);
1208		if (ladv < 0)
1209			return ladv;
1210
1211		radv = phy_read(phydev, MII_LPA);
1212		if (radv < 0)
1213			return radv;
1214
1215		netif_dbg(dev, link, dev->net,
1216			  "speed: %u duplex: %d anadv: 0x%04x anlpa: 0x%04x",
1217			  ecmd.base.speed, ecmd.base.duplex, ladv, radv);
1218
1219		ret = lan78xx_update_flowcontrol(dev, ecmd.base.duplex, ladv,
1220						 radv);
1221
1222		if (!timer_pending(&dev->stat_monitor)) {
1223			dev->delta = 1;
1224			mod_timer(&dev->stat_monitor,
1225				  jiffies + STAT_UPDATE_TIMER);
1226		}
1227
1228		tasklet_schedule(&dev->bh);
1229	}
1230
1231	return ret;
1232}
1233
1234/* some work can't be done in tasklets, so we use keventd
1235 *
1236 * NOTE:  annoying asymmetry:  if it's active, schedule_work() fails,
1237 * but tasklet_schedule() doesn't.	hope the failure is rare.
1238 */
1239static void lan78xx_defer_kevent(struct lan78xx_net *dev, int work)
1240{
1241	set_bit(work, &dev->flags);
1242	if (!schedule_delayed_work(&dev->wq, 0))
1243		netdev_err(dev->net, "kevent %d may have been dropped\n", work);
1244}
1245
1246static void lan78xx_status(struct lan78xx_net *dev, struct urb *urb)
1247{
1248	u32 intdata;
1249
1250	if (urb->actual_length != 4) {
1251		netdev_warn(dev->net,
1252			    "unexpected urb length %d", urb->actual_length);
1253		return;
1254	}
1255
1256	intdata = get_unaligned_le32(urb->transfer_buffer);
 
1257
1258	if (intdata & INT_ENP_PHY_INT) {
1259		netif_dbg(dev, link, dev->net, "PHY INTR: 0x%08x\n", intdata);
1260		lan78xx_defer_kevent(dev, EVENT_LINK_RESET);
1261
1262		if (dev->domain_data.phyirq > 0) {
1263			local_irq_disable();
1264			generic_handle_irq(dev->domain_data.phyirq);
1265			local_irq_enable();
1266		}
1267	} else
1268		netdev_warn(dev->net,
1269			    "unexpected interrupt: 0x%08x\n", intdata);
1270}
1271
1272static int lan78xx_ethtool_get_eeprom_len(struct net_device *netdev)
1273{
1274	return MAX_EEPROM_SIZE;
1275}
1276
1277static int lan78xx_ethtool_get_eeprom(struct net_device *netdev,
1278				      struct ethtool_eeprom *ee, u8 *data)
1279{
1280	struct lan78xx_net *dev = netdev_priv(netdev);
1281	int ret;
1282
1283	ret = usb_autopm_get_interface(dev->intf);
1284	if (ret)
1285		return ret;
1286
1287	ee->magic = LAN78XX_EEPROM_MAGIC;
1288
1289	ret = lan78xx_read_raw_eeprom(dev, ee->offset, ee->len, data);
1290
1291	usb_autopm_put_interface(dev->intf);
1292
1293	return ret;
1294}
1295
1296static int lan78xx_ethtool_set_eeprom(struct net_device *netdev,
1297				      struct ethtool_eeprom *ee, u8 *data)
1298{
1299	struct lan78xx_net *dev = netdev_priv(netdev);
1300	int ret;
1301
1302	ret = usb_autopm_get_interface(dev->intf);
1303	if (ret)
1304		return ret;
1305
1306	/* Invalid EEPROM_INDICATOR at offset zero will result in a failure
1307	 * to load data from EEPROM
1308	 */
1309	if (ee->magic == LAN78XX_EEPROM_MAGIC)
1310		ret = lan78xx_write_raw_eeprom(dev, ee->offset, ee->len, data);
1311	else if ((ee->magic == LAN78XX_OTP_MAGIC) &&
1312		 (ee->offset == 0) &&
1313		 (ee->len == 512) &&
1314		 (data[0] == OTP_INDICATOR_1))
1315		ret = lan78xx_write_raw_otp(dev, ee->offset, ee->len, data);
1316
1317	usb_autopm_put_interface(dev->intf);
1318
1319	return ret;
1320}
1321
1322static void lan78xx_get_strings(struct net_device *netdev, u32 stringset,
1323				u8 *data)
1324{
1325	if (stringset == ETH_SS_STATS)
1326		memcpy(data, lan78xx_gstrings, sizeof(lan78xx_gstrings));
1327}
1328
1329static int lan78xx_get_sset_count(struct net_device *netdev, int sset)
1330{
1331	if (sset == ETH_SS_STATS)
1332		return ARRAY_SIZE(lan78xx_gstrings);
1333	else
1334		return -EOPNOTSUPP;
1335}
1336
1337static void lan78xx_get_stats(struct net_device *netdev,
1338			      struct ethtool_stats *stats, u64 *data)
1339{
1340	struct lan78xx_net *dev = netdev_priv(netdev);
1341
1342	lan78xx_update_stats(dev);
1343
1344	mutex_lock(&dev->stats.access_lock);
1345	memcpy(data, &dev->stats.curr_stat, sizeof(dev->stats.curr_stat));
1346	mutex_unlock(&dev->stats.access_lock);
1347}
1348
1349static void lan78xx_get_wol(struct net_device *netdev,
1350			    struct ethtool_wolinfo *wol)
1351{
1352	struct lan78xx_net *dev = netdev_priv(netdev);
1353	int ret;
1354	u32 buf;
1355	struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1356
1357	if (usb_autopm_get_interface(dev->intf) < 0)
1358			return;
1359
1360	ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
1361	if (unlikely(ret < 0)) {
1362		wol->supported = 0;
1363		wol->wolopts = 0;
1364	} else {
1365		if (buf & USB_CFG_RMT_WKP_) {
1366			wol->supported = WAKE_ALL;
1367			wol->wolopts = pdata->wol;
1368		} else {
1369			wol->supported = 0;
1370			wol->wolopts = 0;
1371		}
1372	}
1373
1374	usb_autopm_put_interface(dev->intf);
1375}
1376
1377static int lan78xx_set_wol(struct net_device *netdev,
1378			   struct ethtool_wolinfo *wol)
1379{
1380	struct lan78xx_net *dev = netdev_priv(netdev);
1381	struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1382	int ret;
1383
1384	ret = usb_autopm_get_interface(dev->intf);
1385	if (ret < 0)
1386		return ret;
1387
1388	if (wol->wolopts & ~WAKE_ALL)
1389		return -EINVAL;
1390
1391	pdata->wol = wol->wolopts;
 
 
 
 
 
 
 
 
 
1392
1393	device_set_wakeup_enable(&dev->udev->dev, (bool)wol->wolopts);
1394
1395	phy_ethtool_set_wol(netdev->phydev, wol);
1396
1397	usb_autopm_put_interface(dev->intf);
1398
1399	return ret;
1400}
1401
1402static int lan78xx_get_eee(struct net_device *net, struct ethtool_eee *edata)
1403{
1404	struct lan78xx_net *dev = netdev_priv(net);
1405	struct phy_device *phydev = net->phydev;
1406	int ret;
1407	u32 buf;
1408
1409	ret = usb_autopm_get_interface(dev->intf);
1410	if (ret < 0)
1411		return ret;
1412
1413	ret = phy_ethtool_get_eee(phydev, edata);
1414	if (ret < 0)
1415		goto exit;
1416
1417	ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1418	if (buf & MAC_CR_EEE_EN_) {
1419		edata->eee_enabled = true;
1420		edata->eee_active = !!(edata->advertised &
1421				       edata->lp_advertised);
1422		edata->tx_lpi_enabled = true;
1423		/* EEE_TX_LPI_REQ_DLY & tx_lpi_timer are same uSec unit */
1424		ret = lan78xx_read_reg(dev, EEE_TX_LPI_REQ_DLY, &buf);
1425		edata->tx_lpi_timer = buf;
1426	} else {
1427		edata->eee_enabled = false;
1428		edata->eee_active = false;
1429		edata->tx_lpi_enabled = false;
1430		edata->tx_lpi_timer = 0;
1431	}
1432
1433	ret = 0;
1434exit:
1435	usb_autopm_put_interface(dev->intf);
1436
1437	return ret;
1438}
1439
1440static int lan78xx_set_eee(struct net_device *net, struct ethtool_eee *edata)
1441{
1442	struct lan78xx_net *dev = netdev_priv(net);
1443	int ret;
1444	u32 buf;
1445
1446	ret = usb_autopm_get_interface(dev->intf);
1447	if (ret < 0)
1448		return ret;
1449
1450	if (edata->eee_enabled) {
1451		ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1452		buf |= MAC_CR_EEE_EN_;
1453		ret = lan78xx_write_reg(dev, MAC_CR, buf);
1454
1455		phy_ethtool_set_eee(net->phydev, edata);
1456
1457		buf = (u32)edata->tx_lpi_timer;
1458		ret = lan78xx_write_reg(dev, EEE_TX_LPI_REQ_DLY, buf);
1459	} else {
1460		ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1461		buf &= ~MAC_CR_EEE_EN_;
1462		ret = lan78xx_write_reg(dev, MAC_CR, buf);
1463	}
1464
1465	usb_autopm_put_interface(dev->intf);
1466
1467	return 0;
1468}
1469
1470static u32 lan78xx_get_link(struct net_device *net)
1471{
1472	u32 link;
1473
1474	mutex_lock(&net->phydev->lock);
1475	phy_read_status(net->phydev);
1476	link = net->phydev->link;
1477	mutex_unlock(&net->phydev->lock);
1478
1479	return link;
 
 
 
 
 
1480}
1481
1482static void lan78xx_get_drvinfo(struct net_device *net,
1483				struct ethtool_drvinfo *info)
1484{
1485	struct lan78xx_net *dev = netdev_priv(net);
1486
1487	strncpy(info->driver, DRIVER_NAME, sizeof(info->driver));
 
1488	usb_make_path(dev->udev, info->bus_info, sizeof(info->bus_info));
1489}
1490
1491static u32 lan78xx_get_msglevel(struct net_device *net)
1492{
1493	struct lan78xx_net *dev = netdev_priv(net);
1494
1495	return dev->msg_enable;
1496}
1497
1498static void lan78xx_set_msglevel(struct net_device *net, u32 level)
1499{
1500	struct lan78xx_net *dev = netdev_priv(net);
1501
1502	dev->msg_enable = level;
1503}
1504
1505static int lan78xx_get_link_ksettings(struct net_device *net,
1506				      struct ethtool_link_ksettings *cmd)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1507{
1508	struct lan78xx_net *dev = netdev_priv(net);
1509	struct phy_device *phydev = net->phydev;
1510	int ret;
 
1511
1512	ret = usb_autopm_get_interface(dev->intf);
1513	if (ret < 0)
1514		return ret;
1515
1516	phy_ethtool_ksettings_get(phydev, cmd);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1517
1518	usb_autopm_put_interface(dev->intf);
1519
1520	return ret;
1521}
1522
1523static int lan78xx_set_link_ksettings(struct net_device *net,
1524				      const struct ethtool_link_ksettings *cmd)
1525{
1526	struct lan78xx_net *dev = netdev_priv(net);
1527	struct phy_device *phydev = net->phydev;
1528	int ret = 0;
1529	int temp;
1530
1531	ret = usb_autopm_get_interface(dev->intf);
1532	if (ret < 0)
1533		return ret;
1534
 
 
 
 
1535	/* change speed & duplex */
1536	ret = phy_ethtool_ksettings_set(phydev, cmd);
1537
1538	if (!cmd->base.autoneg) {
1539		/* force link down */
1540		temp = phy_read(phydev, MII_BMCR);
1541		phy_write(phydev, MII_BMCR, temp | BMCR_LOOPBACK);
1542		mdelay(1);
1543		phy_write(phydev, MII_BMCR, temp);
1544	}
1545
1546	usb_autopm_put_interface(dev->intf);
1547
1548	return ret;
1549}
1550
1551static void lan78xx_get_pause(struct net_device *net,
1552			      struct ethtool_pauseparam *pause)
1553{
1554	struct lan78xx_net *dev = netdev_priv(net);
1555	struct phy_device *phydev = net->phydev;
1556	struct ethtool_link_ksettings ecmd;
1557
1558	phy_ethtool_ksettings_get(phydev, &ecmd);
1559
1560	pause->autoneg = dev->fc_autoneg;
1561
1562	if (dev->fc_request_control & FLOW_CTRL_TX)
1563		pause->tx_pause = 1;
1564
1565	if (dev->fc_request_control & FLOW_CTRL_RX)
1566		pause->rx_pause = 1;
1567}
1568
1569static int lan78xx_set_pause(struct net_device *net,
1570			     struct ethtool_pauseparam *pause)
1571{
1572	struct lan78xx_net *dev = netdev_priv(net);
1573	struct phy_device *phydev = net->phydev;
1574	struct ethtool_link_ksettings ecmd;
1575	int ret;
1576
1577	phy_ethtool_ksettings_get(phydev, &ecmd);
1578
1579	if (pause->autoneg && !ecmd.base.autoneg) {
1580		ret = -EINVAL;
1581		goto exit;
1582	}
1583
1584	dev->fc_request_control = 0;
1585	if (pause->rx_pause)
1586		dev->fc_request_control |= FLOW_CTRL_RX;
1587
1588	if (pause->tx_pause)
1589		dev->fc_request_control |= FLOW_CTRL_TX;
1590
1591	if (ecmd.base.autoneg) {
1592		__ETHTOOL_DECLARE_LINK_MODE_MASK(fc) = { 0, };
1593		u32 mii_adv;
1594
1595		linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT,
1596				   ecmd.link_modes.advertising);
1597		linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
1598				   ecmd.link_modes.advertising);
1599		mii_adv = (u32)mii_advertise_flowctrl(dev->fc_request_control);
1600		mii_adv_to_linkmode_adv_t(fc, mii_adv);
1601		linkmode_or(ecmd.link_modes.advertising, fc,
1602			    ecmd.link_modes.advertising);
1603
1604		phy_ethtool_ksettings_set(phydev, &ecmd);
1605	}
1606
1607	dev->fc_autoneg = pause->autoneg;
1608
1609	ret = 0;
1610exit:
1611	return ret;
1612}
1613
1614static int lan78xx_get_regs_len(struct net_device *netdev)
1615{
1616	if (!netdev->phydev)
1617		return (sizeof(lan78xx_regs));
1618	else
1619		return (sizeof(lan78xx_regs) + PHY_REG_SIZE);
1620}
1621
1622static void
1623lan78xx_get_regs(struct net_device *netdev, struct ethtool_regs *regs,
1624		 void *buf)
1625{
1626	u32 *data = buf;
1627	int i, j;
1628	struct lan78xx_net *dev = netdev_priv(netdev);
1629
1630	/* Read Device/MAC registers */
1631	for (i = 0; i < ARRAY_SIZE(lan78xx_regs); i++)
1632		lan78xx_read_reg(dev, lan78xx_regs[i], &data[i]);
1633
1634	if (!netdev->phydev)
1635		return;
1636
1637	/* Read PHY registers */
1638	for (j = 0; j < 32; i++, j++)
1639		data[i] = phy_read(netdev->phydev, j);
1640}
1641
1642static const struct ethtool_ops lan78xx_ethtool_ops = {
1643	.get_link	= lan78xx_get_link,
1644	.nway_reset	= phy_ethtool_nway_reset,
1645	.get_drvinfo	= lan78xx_get_drvinfo,
1646	.get_msglevel	= lan78xx_get_msglevel,
1647	.set_msglevel	= lan78xx_set_msglevel,
 
 
1648	.get_eeprom_len = lan78xx_ethtool_get_eeprom_len,
1649	.get_eeprom	= lan78xx_ethtool_get_eeprom,
1650	.set_eeprom	= lan78xx_ethtool_set_eeprom,
1651	.get_ethtool_stats = lan78xx_get_stats,
1652	.get_sset_count = lan78xx_get_sset_count,
1653	.get_strings	= lan78xx_get_strings,
1654	.get_wol	= lan78xx_get_wol,
1655	.set_wol	= lan78xx_set_wol,
1656	.get_ts_info	= ethtool_op_get_ts_info,
1657	.get_eee	= lan78xx_get_eee,
1658	.set_eee	= lan78xx_set_eee,
1659	.get_pauseparam	= lan78xx_get_pause,
1660	.set_pauseparam	= lan78xx_set_pause,
1661	.get_link_ksettings = lan78xx_get_link_ksettings,
1662	.set_link_ksettings = lan78xx_set_link_ksettings,
1663	.get_regs_len	= lan78xx_get_regs_len,
1664	.get_regs	= lan78xx_get_regs,
1665};
1666
 
 
 
 
 
 
 
 
1667static void lan78xx_init_mac_address(struct lan78xx_net *dev)
1668{
1669	u32 addr_lo, addr_hi;
 
1670	u8 addr[6];
1671
1672	lan78xx_read_reg(dev, RX_ADDRL, &addr_lo);
1673	lan78xx_read_reg(dev, RX_ADDRH, &addr_hi);
1674
1675	addr[0] = addr_lo & 0xFF;
1676	addr[1] = (addr_lo >> 8) & 0xFF;
1677	addr[2] = (addr_lo >> 16) & 0xFF;
1678	addr[3] = (addr_lo >> 24) & 0xFF;
1679	addr[4] = addr_hi & 0xFF;
1680	addr[5] = (addr_hi >> 8) & 0xFF;
1681
1682	if (!is_valid_ether_addr(addr)) {
1683		if (!eth_platform_get_mac_address(&dev->udev->dev, addr)) {
1684			/* valid address present in Device Tree */
1685			netif_dbg(dev, ifup, dev->net,
1686				  "MAC address read from Device Tree");
1687		} else if (((lan78xx_read_eeprom(dev, EEPROM_MAC_OFFSET,
1688						 ETH_ALEN, addr) == 0) ||
1689			    (lan78xx_read_otp(dev, EEPROM_MAC_OFFSET,
1690					      ETH_ALEN, addr) == 0)) &&
1691			   is_valid_ether_addr(addr)) {
1692			/* eeprom values are valid so use them */
1693			netif_dbg(dev, ifup, dev->net,
1694				  "MAC address read from EEPROM");
 
 
 
 
 
 
 
 
 
 
1695		} else {
1696			/* generate random MAC */
1697			eth_random_addr(addr);
1698			netif_dbg(dev, ifup, dev->net,
1699				  "MAC address set to random addr");
1700		}
1701
1702		addr_lo = addr[0] | (addr[1] << 8) |
1703			  (addr[2] << 16) | (addr[3] << 24);
1704		addr_hi = addr[4] | (addr[5] << 8);
1705
1706		lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
1707		lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
1708	}
1709
1710	lan78xx_write_reg(dev, MAF_LO(0), addr_lo);
1711	lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_);
1712
1713	ether_addr_copy(dev->net->dev_addr, addr);
1714}
1715
1716/* MDIO read and write wrappers for phylib */
1717static int lan78xx_mdiobus_read(struct mii_bus *bus, int phy_id, int idx)
1718{
1719	struct lan78xx_net *dev = bus->priv;
1720	u32 val, addr;
1721	int ret;
1722
1723	ret = usb_autopm_get_interface(dev->intf);
1724	if (ret < 0)
1725		return ret;
1726
1727	mutex_lock(&dev->phy_mutex);
1728
1729	/* confirm MII not busy */
1730	ret = lan78xx_phy_wait_not_busy(dev);
1731	if (ret < 0)
1732		goto done;
1733
1734	/* set the address, index & direction (read from PHY) */
1735	addr = mii_access(phy_id, idx, MII_READ);
1736	ret = lan78xx_write_reg(dev, MII_ACC, addr);
1737
1738	ret = lan78xx_phy_wait_not_busy(dev);
1739	if (ret < 0)
1740		goto done;
1741
1742	ret = lan78xx_read_reg(dev, MII_DATA, &val);
1743
1744	ret = (int)(val & 0xFFFF);
1745
1746done:
1747	mutex_unlock(&dev->phy_mutex);
1748	usb_autopm_put_interface(dev->intf);
1749
1750	return ret;
1751}
1752
1753static int lan78xx_mdiobus_write(struct mii_bus *bus, int phy_id, int idx,
1754				 u16 regval)
1755{
1756	struct lan78xx_net *dev = bus->priv;
1757	u32 val, addr;
1758	int ret;
1759
1760	ret = usb_autopm_get_interface(dev->intf);
1761	if (ret < 0)
1762		return ret;
1763
1764	mutex_lock(&dev->phy_mutex);
1765
1766	/* confirm MII not busy */
1767	ret = lan78xx_phy_wait_not_busy(dev);
1768	if (ret < 0)
1769		goto done;
1770
1771	val = (u32)regval;
1772	ret = lan78xx_write_reg(dev, MII_DATA, val);
1773
1774	/* set the address, index & direction (write to PHY) */
1775	addr = mii_access(phy_id, idx, MII_WRITE);
1776	ret = lan78xx_write_reg(dev, MII_ACC, addr);
1777
1778	ret = lan78xx_phy_wait_not_busy(dev);
1779	if (ret < 0)
1780		goto done;
1781
1782done:
1783	mutex_unlock(&dev->phy_mutex);
1784	usb_autopm_put_interface(dev->intf);
1785	return 0;
1786}
1787
1788static int lan78xx_mdio_init(struct lan78xx_net *dev)
1789{
1790	struct device_node *node;
1791	int ret;
1792
1793	dev->mdiobus = mdiobus_alloc();
1794	if (!dev->mdiobus) {
1795		netdev_err(dev->net, "can't allocate MDIO bus\n");
1796		return -ENOMEM;
1797	}
1798
1799	dev->mdiobus->priv = (void *)dev;
1800	dev->mdiobus->read = lan78xx_mdiobus_read;
1801	dev->mdiobus->write = lan78xx_mdiobus_write;
1802	dev->mdiobus->name = "lan78xx-mdiobus";
1803	dev->mdiobus->parent = &dev->udev->dev;
1804
1805	snprintf(dev->mdiobus->id, MII_BUS_ID_SIZE, "usb-%03d:%03d",
1806		 dev->udev->bus->busnum, dev->udev->devnum);
1807
1808	switch (dev->chipid) {
1809	case ID_REV_CHIP_ID_7800_:
1810	case ID_REV_CHIP_ID_7850_:
1811		/* set to internal PHY id */
1812		dev->mdiobus->phy_mask = ~(1 << 1);
1813		break;
1814	case ID_REV_CHIP_ID_7801_:
1815		/* scan thru PHYAD[2..0] */
1816		dev->mdiobus->phy_mask = ~(0xFF);
1817		break;
1818	}
1819
1820	node = of_get_child_by_name(dev->udev->dev.of_node, "mdio");
1821	ret = of_mdiobus_register(dev->mdiobus, node);
1822	of_node_put(node);
1823	if (ret) {
1824		netdev_err(dev->net, "can't register MDIO bus\n");
1825		goto exit1;
1826	}
1827
1828	netdev_dbg(dev->net, "registered mdiobus bus %s\n", dev->mdiobus->id);
1829	return 0;
1830exit1:
1831	mdiobus_free(dev->mdiobus);
1832	return ret;
1833}
1834
1835static void lan78xx_remove_mdio(struct lan78xx_net *dev)
1836{
1837	mdiobus_unregister(dev->mdiobus);
1838	mdiobus_free(dev->mdiobus);
1839}
1840
1841static void lan78xx_link_status_change(struct net_device *net)
1842{
1843	struct phy_device *phydev = net->phydev;
1844	int temp;
1845
1846	/* At forced 100 F/H mode, chip may fail to set mode correctly
1847	 * when cable is switched between long(~50+m) and short one.
1848	 * As workaround, set to 10 before setting to 100
1849	 * at forced 100 F/H mode.
1850	 */
1851	if (!phydev->autoneg && (phydev->speed == 100)) {
1852		/* disable phy interrupt */
1853		temp = phy_read(phydev, LAN88XX_INT_MASK);
1854		temp &= ~LAN88XX_INT_MASK_MDINTPIN_EN_;
1855		phy_write(phydev, LAN88XX_INT_MASK, temp);
1856
1857		temp = phy_read(phydev, MII_BMCR);
1858		temp &= ~(BMCR_SPEED100 | BMCR_SPEED1000);
1859		phy_write(phydev, MII_BMCR, temp); /* set to 10 first */
1860		temp |= BMCR_SPEED100;
1861		phy_write(phydev, MII_BMCR, temp); /* set to 100 later */
1862
1863		/* clear pending interrupt generated while workaround */
1864		temp = phy_read(phydev, LAN88XX_INT_STS);
1865
1866		/* enable phy interrupt back */
1867		temp = phy_read(phydev, LAN88XX_INT_MASK);
1868		temp |= LAN88XX_INT_MASK_MDINTPIN_EN_;
1869		phy_write(phydev, LAN88XX_INT_MASK, temp);
1870	}
1871}
1872
1873static int irq_map(struct irq_domain *d, unsigned int irq,
1874		   irq_hw_number_t hwirq)
1875{
1876	struct irq_domain_data *data = d->host_data;
1877
1878	irq_set_chip_data(irq, data);
1879	irq_set_chip_and_handler(irq, data->irqchip, data->irq_handler);
1880	irq_set_noprobe(irq);
1881
1882	return 0;
1883}
1884
1885static void irq_unmap(struct irq_domain *d, unsigned int irq)
1886{
1887	irq_set_chip_and_handler(irq, NULL, NULL);
1888	irq_set_chip_data(irq, NULL);
1889}
1890
1891static const struct irq_domain_ops chip_domain_ops = {
1892	.map	= irq_map,
1893	.unmap	= irq_unmap,
1894};
1895
1896static void lan78xx_irq_mask(struct irq_data *irqd)
1897{
1898	struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
1899
1900	data->irqenable &= ~BIT(irqd_to_hwirq(irqd));
1901}
1902
1903static void lan78xx_irq_unmask(struct irq_data *irqd)
1904{
1905	struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
1906
1907	data->irqenable |= BIT(irqd_to_hwirq(irqd));
1908}
1909
1910static void lan78xx_irq_bus_lock(struct irq_data *irqd)
1911{
1912	struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
1913
1914	mutex_lock(&data->irq_lock);
1915}
1916
1917static void lan78xx_irq_bus_sync_unlock(struct irq_data *irqd)
1918{
1919	struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
1920	struct lan78xx_net *dev =
1921			container_of(data, struct lan78xx_net, domain_data);
1922	u32 buf;
1923
1924	/* call register access here because irq_bus_lock & irq_bus_sync_unlock
1925	 * are only two callbacks executed in non-atomic contex.
1926	 */
1927	lan78xx_read_reg(dev, INT_EP_CTL, &buf);
1928	if (buf != data->irqenable)
1929		lan78xx_write_reg(dev, INT_EP_CTL, data->irqenable);
1930
1931	mutex_unlock(&data->irq_lock);
1932}
1933
1934static struct irq_chip lan78xx_irqchip = {
1935	.name			= "lan78xx-irqs",
1936	.irq_mask		= lan78xx_irq_mask,
1937	.irq_unmask		= lan78xx_irq_unmask,
1938	.irq_bus_lock		= lan78xx_irq_bus_lock,
1939	.irq_bus_sync_unlock	= lan78xx_irq_bus_sync_unlock,
1940};
1941
1942static int lan78xx_setup_irq_domain(struct lan78xx_net *dev)
1943{
1944	struct device_node *of_node;
1945	struct irq_domain *irqdomain;
1946	unsigned int irqmap = 0;
1947	u32 buf;
1948	int ret = 0;
1949
1950	of_node = dev->udev->dev.parent->of_node;
1951
1952	mutex_init(&dev->domain_data.irq_lock);
1953
1954	lan78xx_read_reg(dev, INT_EP_CTL, &buf);
1955	dev->domain_data.irqenable = buf;
1956
1957	dev->domain_data.irqchip = &lan78xx_irqchip;
1958	dev->domain_data.irq_handler = handle_simple_irq;
1959
1960	irqdomain = irq_domain_add_simple(of_node, MAX_INT_EP, 0,
1961					  &chip_domain_ops, &dev->domain_data);
1962	if (irqdomain) {
1963		/* create mapping for PHY interrupt */
1964		irqmap = irq_create_mapping(irqdomain, INT_EP_PHY);
1965		if (!irqmap) {
1966			irq_domain_remove(irqdomain);
1967
1968			irqdomain = NULL;
1969			ret = -EINVAL;
1970		}
1971	} else {
1972		ret = -EINVAL;
1973	}
1974
1975	dev->domain_data.irqdomain = irqdomain;
1976	dev->domain_data.phyirq = irqmap;
1977
1978	return ret;
1979}
1980
1981static void lan78xx_remove_irq_domain(struct lan78xx_net *dev)
1982{
1983	if (dev->domain_data.phyirq > 0) {
1984		irq_dispose_mapping(dev->domain_data.phyirq);
1985
1986		if (dev->domain_data.irqdomain)
1987			irq_domain_remove(dev->domain_data.irqdomain);
1988	}
1989	dev->domain_data.phyirq = 0;
1990	dev->domain_data.irqdomain = NULL;
1991}
1992
1993static int lan8835_fixup(struct phy_device *phydev)
1994{
1995	int buf;
1996	struct lan78xx_net *dev = netdev_priv(phydev->attached_dev);
1997
1998	/* LED2/PME_N/IRQ_N/RGMII_ID pin to IRQ_N mode */
1999	buf = phy_read_mmd(phydev, MDIO_MMD_PCS, 0x8010);
2000	buf &= ~0x1800;
2001	buf |= 0x0800;
2002	phy_write_mmd(phydev, MDIO_MMD_PCS, 0x8010, buf);
2003
2004	/* RGMII MAC TXC Delay Enable */
2005	lan78xx_write_reg(dev, MAC_RGMII_ID,
2006				MAC_RGMII_ID_TXC_DELAY_EN_);
2007
2008	/* RGMII TX DLL Tune Adjust */
2009	lan78xx_write_reg(dev, RGMII_TX_BYP_DLL, 0x3D00);
2010
2011	dev->interface = PHY_INTERFACE_MODE_RGMII_TXID;
2012
2013	return 1;
2014}
2015
2016static int ksz9031rnx_fixup(struct phy_device *phydev)
2017{
2018	struct lan78xx_net *dev = netdev_priv(phydev->attached_dev);
2019
2020	/* Micrel9301RNX PHY configuration */
2021	/* RGMII Control Signal Pad Skew */
2022	phy_write_mmd(phydev, MDIO_MMD_WIS, 4, 0x0077);
2023	/* RGMII RX Data Pad Skew */
2024	phy_write_mmd(phydev, MDIO_MMD_WIS, 5, 0x7777);
2025	/* RGMII RX Clock Pad Skew */
2026	phy_write_mmd(phydev, MDIO_MMD_WIS, 8, 0x1FF);
2027
2028	dev->interface = PHY_INTERFACE_MODE_RGMII_RXID;
2029
2030	return 1;
2031}
2032
2033static struct phy_device *lan7801_phy_init(struct lan78xx_net *dev)
2034{
2035	u32 buf;
2036	int ret;
2037	struct fixed_phy_status fphy_status = {
2038		.link = 1,
2039		.speed = SPEED_1000,
2040		.duplex = DUPLEX_FULL,
2041	};
2042	struct phy_device *phydev;
2043
2044	phydev = phy_find_first(dev->mdiobus);
2045	if (!phydev) {
2046		netdev_dbg(dev->net, "PHY Not Found!! Registering Fixed PHY\n");
2047		phydev = fixed_phy_register(PHY_POLL, &fphy_status, NULL);
2048		if (IS_ERR(phydev)) {
2049			netdev_err(dev->net, "No PHY/fixed_PHY found\n");
2050			return NULL;
2051		}
2052		netdev_dbg(dev->net, "Registered FIXED PHY\n");
2053		dev->interface = PHY_INTERFACE_MODE_RGMII;
2054		ret = lan78xx_write_reg(dev, MAC_RGMII_ID,
2055					MAC_RGMII_ID_TXC_DELAY_EN_);
2056		ret = lan78xx_write_reg(dev, RGMII_TX_BYP_DLL, 0x3D00);
2057		ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2058		buf |= HW_CFG_CLK125_EN_;
2059		buf |= HW_CFG_REFCLK25_EN_;
2060		ret = lan78xx_write_reg(dev, HW_CFG, buf);
2061	} else {
2062		if (!phydev->drv) {
2063			netdev_err(dev->net, "no PHY driver found\n");
2064			return NULL;
2065		}
2066		dev->interface = PHY_INTERFACE_MODE_RGMII;
2067		/* external PHY fixup for KSZ9031RNX */
2068		ret = phy_register_fixup_for_uid(PHY_KSZ9031RNX, 0xfffffff0,
2069						 ksz9031rnx_fixup);
2070		if (ret < 0) {
2071			netdev_err(dev->net, "Failed to register fixup for PHY_KSZ9031RNX\n");
2072			return NULL;
2073		}
2074		/* external PHY fixup for LAN8835 */
2075		ret = phy_register_fixup_for_uid(PHY_LAN8835, 0xfffffff0,
2076						 lan8835_fixup);
2077		if (ret < 0) {
2078			netdev_err(dev->net, "Failed to register fixup for PHY_LAN8835\n");
2079			return NULL;
2080		}
2081		/* add more external PHY fixup here if needed */
2082
2083		phydev->is_internal = false;
2084	}
2085	return phydev;
2086}
2087
2088static int lan78xx_phy_init(struct lan78xx_net *dev)
2089{
2090	__ETHTOOL_DECLARE_LINK_MODE_MASK(fc) = { 0, };
2091	int ret;
2092	u32 mii_adv;
2093	struct phy_device *phydev;
2094
2095	switch (dev->chipid) {
2096	case ID_REV_CHIP_ID_7801_:
2097		phydev = lan7801_phy_init(dev);
2098		if (!phydev) {
2099			netdev_err(dev->net, "lan7801: PHY Init Failed");
2100			return -EIO;
2101		}
2102		break;
2103
2104	case ID_REV_CHIP_ID_7800_:
2105	case ID_REV_CHIP_ID_7850_:
2106		phydev = phy_find_first(dev->mdiobus);
2107		if (!phydev) {
2108			netdev_err(dev->net, "no PHY found\n");
2109			return -EIO;
2110		}
2111		phydev->is_internal = true;
2112		dev->interface = PHY_INTERFACE_MODE_GMII;
2113		break;
2114
2115	default:
2116		netdev_err(dev->net, "Unknown CHIP ID found\n");
 
2117		return -EIO;
2118	}
2119
2120	/* if phyirq is not set, use polling mode in phylib */
2121	if (dev->domain_data.phyirq > 0)
2122		phydev->irq = dev->domain_data.phyirq;
2123	else
2124		phydev->irq = 0;
2125	netdev_dbg(dev->net, "phydev->irq = %d\n", phydev->irq);
 
2126
2127	/* set to AUTOMDIX */
2128	phydev->mdix = ETH_TP_MDI_AUTO;
2129
2130	ret = phy_connect_direct(dev->net, phydev,
2131				 lan78xx_link_status_change,
2132				 dev->interface);
2133	if (ret) {
2134		netdev_err(dev->net, "can't attach PHY to %s\n",
2135			   dev->mdiobus->id);
2136		if (dev->chipid == ID_REV_CHIP_ID_7801_) {
2137			if (phy_is_pseudo_fixed_link(phydev)) {
2138				fixed_phy_unregister(phydev);
2139			} else {
2140				phy_unregister_fixup_for_uid(PHY_KSZ9031RNX,
2141							     0xfffffff0);
2142				phy_unregister_fixup_for_uid(PHY_LAN8835,
2143							     0xfffffff0);
2144			}
2145		}
2146		return -EIO;
2147	}
2148
 
 
 
2149	/* MAC doesn't support 1000T Half */
2150	phy_remove_link_mode(phydev, ETHTOOL_LINK_MODE_1000baseT_Half_BIT);
2151
2152	/* support both flow controls */
2153	dev->fc_request_control = (FLOW_CTRL_RX | FLOW_CTRL_TX);
2154	linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2155			   phydev->advertising);
2156	linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
2157			   phydev->advertising);
2158	mii_adv = (u32)mii_advertise_flowctrl(dev->fc_request_control);
2159	mii_adv_to_linkmode_adv_t(fc, mii_adv);
2160	linkmode_or(phydev->advertising, fc, phydev->advertising);
2161
2162	if (phydev->mdio.dev.of_node) {
2163		u32 reg;
2164		int len;
2165
2166		len = of_property_count_elems_of_size(phydev->mdio.dev.of_node,
2167						      "microchip,led-modes",
2168						      sizeof(u32));
2169		if (len >= 0) {
2170			/* Ensure the appropriate LEDs are enabled */
2171			lan78xx_read_reg(dev, HW_CFG, &reg);
2172			reg &= ~(HW_CFG_LED0_EN_ |
2173				 HW_CFG_LED1_EN_ |
2174				 HW_CFG_LED2_EN_ |
2175				 HW_CFG_LED3_EN_);
2176			reg |= (len > 0) * HW_CFG_LED0_EN_ |
2177				(len > 1) * HW_CFG_LED1_EN_ |
2178				(len > 2) * HW_CFG_LED2_EN_ |
2179				(len > 3) * HW_CFG_LED3_EN_;
2180			lan78xx_write_reg(dev, HW_CFG, reg);
2181		}
2182	}
2183
2184	genphy_config_aneg(phydev);
2185
2186	dev->fc_autoneg = phydev->autoneg;
2187
 
 
 
 
2188	return 0;
2189}
2190
2191static int lan78xx_set_rx_max_frame_length(struct lan78xx_net *dev, int size)
2192{
 
2193	u32 buf;
2194	bool rxenabled;
2195
2196	lan78xx_read_reg(dev, MAC_RX, &buf);
2197
2198	rxenabled = ((buf & MAC_RX_RXEN_) != 0);
2199
2200	if (rxenabled) {
2201		buf &= ~MAC_RX_RXEN_;
2202		lan78xx_write_reg(dev, MAC_RX, buf);
2203	}
2204
2205	/* add 4 to size for FCS */
2206	buf &= ~MAC_RX_MAX_SIZE_MASK_;
2207	buf |= (((size + 4) << MAC_RX_MAX_SIZE_SHIFT_) & MAC_RX_MAX_SIZE_MASK_);
2208
2209	lan78xx_write_reg(dev, MAC_RX, buf);
2210
2211	if (rxenabled) {
2212		buf |= MAC_RX_RXEN_;
2213		lan78xx_write_reg(dev, MAC_RX, buf);
2214	}
2215
2216	return 0;
2217}
2218
2219static int unlink_urbs(struct lan78xx_net *dev, struct sk_buff_head *q)
2220{
2221	struct sk_buff *skb;
2222	unsigned long flags;
2223	int count = 0;
2224
2225	spin_lock_irqsave(&q->lock, flags);
2226	while (!skb_queue_empty(q)) {
2227		struct skb_data	*entry;
2228		struct urb *urb;
2229		int ret;
2230
2231		skb_queue_walk(q, skb) {
2232			entry = (struct skb_data *)skb->cb;
2233			if (entry->state != unlink_start)
2234				goto found;
2235		}
2236		break;
2237found:
2238		entry->state = unlink_start;
2239		urb = entry->urb;
2240
2241		/* Get reference count of the URB to avoid it to be
2242		 * freed during usb_unlink_urb, which may trigger
2243		 * use-after-free problem inside usb_unlink_urb since
2244		 * usb_unlink_urb is always racing with .complete
2245		 * handler(include defer_bh).
2246		 */
2247		usb_get_urb(urb);
2248		spin_unlock_irqrestore(&q->lock, flags);
2249		/* during some PM-driven resume scenarios,
2250		 * these (async) unlinks complete immediately
2251		 */
2252		ret = usb_unlink_urb(urb);
2253		if (ret != -EINPROGRESS && ret != 0)
2254			netdev_dbg(dev->net, "unlink urb err, %d\n", ret);
2255		else
2256			count++;
2257		usb_put_urb(urb);
2258		spin_lock_irqsave(&q->lock, flags);
2259	}
2260	spin_unlock_irqrestore(&q->lock, flags);
2261	return count;
2262}
2263
2264static int lan78xx_change_mtu(struct net_device *netdev, int new_mtu)
2265{
2266	struct lan78xx_net *dev = netdev_priv(netdev);
2267	int ll_mtu = new_mtu + netdev->hard_header_len;
2268	int old_hard_mtu = dev->hard_mtu;
2269	int old_rx_urb_size = dev->rx_urb_size;
 
2270
 
 
 
 
 
2271	/* no second zero-length packet read wanted after mtu-sized packets */
2272	if ((ll_mtu % dev->maxpacket) == 0)
2273		return -EDOM;
2274
2275	lan78xx_set_rx_max_frame_length(dev, new_mtu + VLAN_ETH_HLEN);
2276
2277	netdev->mtu = new_mtu;
2278
2279	dev->hard_mtu = netdev->mtu + netdev->hard_header_len;
2280	if (dev->rx_urb_size == old_hard_mtu) {
2281		dev->rx_urb_size = dev->hard_mtu;
2282		if (dev->rx_urb_size > old_rx_urb_size) {
2283			if (netif_running(dev->net)) {
2284				unlink_urbs(dev, &dev->rxq);
2285				tasklet_schedule(&dev->bh);
2286			}
2287		}
2288	}
2289
2290	return 0;
2291}
2292
2293static int lan78xx_set_mac_addr(struct net_device *netdev, void *p)
2294{
2295	struct lan78xx_net *dev = netdev_priv(netdev);
2296	struct sockaddr *addr = p;
2297	u32 addr_lo, addr_hi;
 
2298
2299	if (netif_running(netdev))
2300		return -EBUSY;
2301
2302	if (!is_valid_ether_addr(addr->sa_data))
2303		return -EADDRNOTAVAIL;
2304
2305	ether_addr_copy(netdev->dev_addr, addr->sa_data);
2306
2307	addr_lo = netdev->dev_addr[0] |
2308		  netdev->dev_addr[1] << 8 |
2309		  netdev->dev_addr[2] << 16 |
2310		  netdev->dev_addr[3] << 24;
2311	addr_hi = netdev->dev_addr[4] |
2312		  netdev->dev_addr[5] << 8;
2313
2314	lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
2315	lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
2316
2317	/* Added to support MAC address changes */
2318	lan78xx_write_reg(dev, MAF_LO(0), addr_lo);
2319	lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_);
2320
2321	return 0;
2322}
2323
2324/* Enable or disable Rx checksum offload engine */
2325static int lan78xx_set_features(struct net_device *netdev,
2326				netdev_features_t features)
2327{
2328	struct lan78xx_net *dev = netdev_priv(netdev);
2329	struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2330	unsigned long flags;
 
2331
2332	spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);
2333
2334	if (features & NETIF_F_RXCSUM) {
2335		pdata->rfe_ctl |= RFE_CTL_TCPUDP_COE_ | RFE_CTL_IP_COE_;
2336		pdata->rfe_ctl |= RFE_CTL_ICMP_COE_ | RFE_CTL_IGMP_COE_;
2337	} else {
2338		pdata->rfe_ctl &= ~(RFE_CTL_TCPUDP_COE_ | RFE_CTL_IP_COE_);
2339		pdata->rfe_ctl &= ~(RFE_CTL_ICMP_COE_ | RFE_CTL_IGMP_COE_);
2340	}
2341
2342	if (features & NETIF_F_HW_VLAN_CTAG_RX)
2343		pdata->rfe_ctl |= RFE_CTL_VLAN_STRIP_;
2344	else
2345		pdata->rfe_ctl &= ~RFE_CTL_VLAN_STRIP_;
2346
2347	if (features & NETIF_F_HW_VLAN_CTAG_FILTER)
2348		pdata->rfe_ctl |= RFE_CTL_VLAN_FILTER_;
2349	else
2350		pdata->rfe_ctl &= ~RFE_CTL_VLAN_FILTER_;
2351
2352	spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags);
2353
2354	lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
2355
2356	return 0;
2357}
2358
2359static void lan78xx_deferred_vlan_write(struct work_struct *param)
2360{
2361	struct lan78xx_priv *pdata =
2362			container_of(param, struct lan78xx_priv, set_vlan);
2363	struct lan78xx_net *dev = pdata->dev;
2364
2365	lan78xx_dataport_write(dev, DP_SEL_RSEL_VLAN_DA_, 0,
2366			       DP_SEL_VHF_VLAN_LEN, pdata->vlan_table);
2367}
2368
2369static int lan78xx_vlan_rx_add_vid(struct net_device *netdev,
2370				   __be16 proto, u16 vid)
2371{
2372	struct lan78xx_net *dev = netdev_priv(netdev);
2373	struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2374	u16 vid_bit_index;
2375	u16 vid_dword_index;
2376
2377	vid_dword_index = (vid >> 5) & 0x7F;
2378	vid_bit_index = vid & 0x1F;
2379
2380	pdata->vlan_table[vid_dword_index] |= (1 << vid_bit_index);
2381
2382	/* defer register writes to a sleepable context */
2383	schedule_work(&pdata->set_vlan);
2384
2385	return 0;
2386}
2387
2388static int lan78xx_vlan_rx_kill_vid(struct net_device *netdev,
2389				    __be16 proto, u16 vid)
2390{
2391	struct lan78xx_net *dev = netdev_priv(netdev);
2392	struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2393	u16 vid_bit_index;
2394	u16 vid_dword_index;
2395
2396	vid_dword_index = (vid >> 5) & 0x7F;
2397	vid_bit_index = vid & 0x1F;
2398
2399	pdata->vlan_table[vid_dword_index] &= ~(1 << vid_bit_index);
2400
2401	/* defer register writes to a sleepable context */
2402	schedule_work(&pdata->set_vlan);
2403
2404	return 0;
2405}
2406
2407static void lan78xx_init_ltm(struct lan78xx_net *dev)
2408{
2409	int ret;
2410	u32 buf;
2411	u32 regs[6] = { 0 };
2412
2413	ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
2414	if (buf & USB_CFG1_LTM_ENABLE_) {
2415		u8 temp[2];
2416		/* Get values from EEPROM first */
2417		if (lan78xx_read_eeprom(dev, 0x3F, 2, temp) == 0) {
2418			if (temp[0] == 24) {
2419				ret = lan78xx_read_raw_eeprom(dev,
2420							      temp[1] * 2,
2421							      24,
2422							      (u8 *)regs);
2423				if (ret < 0)
2424					return;
2425			}
2426		} else if (lan78xx_read_otp(dev, 0x3F, 2, temp) == 0) {
2427			if (temp[0] == 24) {
2428				ret = lan78xx_read_raw_otp(dev,
2429							   temp[1] * 2,
2430							   24,
2431							   (u8 *)regs);
2432				if (ret < 0)
2433					return;
2434			}
2435		}
2436	}
2437
2438	lan78xx_write_reg(dev, LTM_BELT_IDLE0, regs[0]);
2439	lan78xx_write_reg(dev, LTM_BELT_IDLE1, regs[1]);
2440	lan78xx_write_reg(dev, LTM_BELT_ACT0, regs[2]);
2441	lan78xx_write_reg(dev, LTM_BELT_ACT1, regs[3]);
2442	lan78xx_write_reg(dev, LTM_INACTIVE0, regs[4]);
2443	lan78xx_write_reg(dev, LTM_INACTIVE1, regs[5]);
2444}
2445
2446static int lan78xx_reset(struct lan78xx_net *dev)
2447{
2448	struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2449	u32 buf;
2450	int ret = 0;
2451	unsigned long timeout;
2452	u8 sig;
2453
2454	ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2455	buf |= HW_CFG_LRST_;
2456	ret = lan78xx_write_reg(dev, HW_CFG, buf);
2457
2458	timeout = jiffies + HZ;
2459	do {
2460		mdelay(1);
2461		ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2462		if (time_after(jiffies, timeout)) {
2463			netdev_warn(dev->net,
2464				    "timeout on completion of LiteReset");
2465			return -EIO;
2466		}
2467	} while (buf & HW_CFG_LRST_);
2468
2469	lan78xx_init_mac_address(dev);
2470
2471	/* save DEVID for later usage */
2472	ret = lan78xx_read_reg(dev, ID_REV, &buf);
2473	dev->chipid = (buf & ID_REV_CHIP_ID_MASK_) >> 16;
2474	dev->chiprev = buf & ID_REV_CHIP_REV_MASK_;
2475
2476	/* Respond to the IN token with a NAK */
2477	ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
2478	buf |= USB_CFG_BIR_;
2479	ret = lan78xx_write_reg(dev, USB_CFG0, buf);
2480
2481	/* Init LTM */
2482	lan78xx_init_ltm(dev);
2483
 
 
 
2484	if (dev->udev->speed == USB_SPEED_SUPER) {
2485		buf = DEFAULT_BURST_CAP_SIZE / SS_USB_PKT_SIZE;
2486		dev->rx_urb_size = DEFAULT_BURST_CAP_SIZE;
2487		dev->rx_qlen = 4;
2488		dev->tx_qlen = 4;
2489	} else if (dev->udev->speed == USB_SPEED_HIGH) {
2490		buf = DEFAULT_BURST_CAP_SIZE / HS_USB_PKT_SIZE;
2491		dev->rx_urb_size = DEFAULT_BURST_CAP_SIZE;
2492		dev->rx_qlen = RX_MAX_QUEUE_MEMORY / dev->rx_urb_size;
2493		dev->tx_qlen = RX_MAX_QUEUE_MEMORY / dev->hard_mtu;
2494	} else {
2495		buf = DEFAULT_BURST_CAP_SIZE / FS_USB_PKT_SIZE;
2496		dev->rx_urb_size = DEFAULT_BURST_CAP_SIZE;
2497		dev->rx_qlen = 4;
2498		dev->tx_qlen = 4;
2499	}
2500
2501	ret = lan78xx_write_reg(dev, BURST_CAP, buf);
2502	ret = lan78xx_write_reg(dev, BULK_IN_DLY, DEFAULT_BULK_IN_DELAY);
2503
2504	ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2505	buf |= HW_CFG_MEF_;
2506	ret = lan78xx_write_reg(dev, HW_CFG, buf);
2507
2508	ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
2509	buf |= USB_CFG_BCE_;
2510	ret = lan78xx_write_reg(dev, USB_CFG0, buf);
2511
2512	/* set FIFO sizes */
2513	buf = (MAX_RX_FIFO_SIZE - 512) / 512;
2514	ret = lan78xx_write_reg(dev, FCT_RX_FIFO_END, buf);
2515
2516	buf = (MAX_TX_FIFO_SIZE - 512) / 512;
2517	ret = lan78xx_write_reg(dev, FCT_TX_FIFO_END, buf);
2518
2519	ret = lan78xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL_);
2520	ret = lan78xx_write_reg(dev, FLOW, 0);
2521	ret = lan78xx_write_reg(dev, FCT_FLOW, 0);
2522
2523	/* Don't need rfe_ctl_lock during initialisation */
2524	ret = lan78xx_read_reg(dev, RFE_CTL, &pdata->rfe_ctl);
2525	pdata->rfe_ctl |= RFE_CTL_BCAST_EN_ | RFE_CTL_DA_PERFECT_;
2526	ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
2527
2528	/* Enable or disable checksum offload engines */
2529	lan78xx_set_features(dev->net, dev->net->features);
2530
2531	lan78xx_set_multicast(dev->net);
2532
2533	/* reset PHY */
2534	ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
2535	buf |= PMT_CTL_PHY_RST_;
2536	ret = lan78xx_write_reg(dev, PMT_CTL, buf);
2537
2538	timeout = jiffies + HZ;
2539	do {
2540		mdelay(1);
2541		ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
2542		if (time_after(jiffies, timeout)) {
2543			netdev_warn(dev->net, "timeout waiting for PHY Reset");
2544			return -EIO;
2545		}
2546	} while ((buf & PMT_CTL_PHY_RST_) || !(buf & PMT_CTL_READY_));
2547
2548	ret = lan78xx_read_reg(dev, MAC_CR, &buf);
2549	/* LAN7801 only has RGMII mode */
2550	if (dev->chipid == ID_REV_CHIP_ID_7801_)
2551		buf &= ~MAC_CR_GMII_EN_;
2552
2553	if (dev->chipid == ID_REV_CHIP_ID_7800_) {
2554		ret = lan78xx_read_raw_eeprom(dev, 0, 1, &sig);
2555		if (!ret && sig != EEPROM_INDICATOR) {
2556			/* Implies there is no external eeprom. Set mac speed */
2557			netdev_info(dev->net, "No External EEPROM. Setting MAC Speed\n");
2558			buf |= MAC_CR_AUTO_DUPLEX_ | MAC_CR_AUTO_SPEED_;
2559		}
2560	}
2561	ret = lan78xx_write_reg(dev, MAC_CR, buf);
2562
 
 
 
 
 
2563	ret = lan78xx_read_reg(dev, MAC_TX, &buf);
2564	buf |= MAC_TX_TXEN_;
2565	ret = lan78xx_write_reg(dev, MAC_TX, buf);
2566
2567	ret = lan78xx_read_reg(dev, FCT_TX_CTL, &buf);
2568	buf |= FCT_TX_CTL_EN_;
2569	ret = lan78xx_write_reg(dev, FCT_TX_CTL, buf);
2570
2571	ret = lan78xx_set_rx_max_frame_length(dev,
2572					      dev->net->mtu + VLAN_ETH_HLEN);
2573
2574	ret = lan78xx_read_reg(dev, MAC_RX, &buf);
2575	buf |= MAC_RX_RXEN_;
2576	ret = lan78xx_write_reg(dev, MAC_RX, buf);
2577
2578	ret = lan78xx_read_reg(dev, FCT_RX_CTL, &buf);
2579	buf |= FCT_RX_CTL_EN_;
2580	ret = lan78xx_write_reg(dev, FCT_RX_CTL, buf);
2581
2582	return 0;
2583}
2584
2585static void lan78xx_init_stats(struct lan78xx_net *dev)
2586{
2587	u32 *p;
2588	int i;
2589
2590	/* initialize for stats update
2591	 * some counters are 20bits and some are 32bits
2592	 */
2593	p = (u32 *)&dev->stats.rollover_max;
2594	for (i = 0; i < (sizeof(dev->stats.rollover_max) / (sizeof(u32))); i++)
2595		p[i] = 0xFFFFF;
2596
2597	dev->stats.rollover_max.rx_unicast_byte_count = 0xFFFFFFFF;
2598	dev->stats.rollover_max.rx_broadcast_byte_count = 0xFFFFFFFF;
2599	dev->stats.rollover_max.rx_multicast_byte_count = 0xFFFFFFFF;
2600	dev->stats.rollover_max.eee_rx_lpi_transitions = 0xFFFFFFFF;
2601	dev->stats.rollover_max.eee_rx_lpi_time = 0xFFFFFFFF;
2602	dev->stats.rollover_max.tx_unicast_byte_count = 0xFFFFFFFF;
2603	dev->stats.rollover_max.tx_broadcast_byte_count = 0xFFFFFFFF;
2604	dev->stats.rollover_max.tx_multicast_byte_count = 0xFFFFFFFF;
2605	dev->stats.rollover_max.eee_tx_lpi_transitions = 0xFFFFFFFF;
2606	dev->stats.rollover_max.eee_tx_lpi_time = 0xFFFFFFFF;
2607
2608	set_bit(EVENT_STAT_UPDATE, &dev->flags);
2609}
2610
2611static int lan78xx_open(struct net_device *net)
2612{
2613	struct lan78xx_net *dev = netdev_priv(net);
2614	int ret;
2615
2616	ret = usb_autopm_get_interface(dev->intf);
2617	if (ret < 0)
2618		goto out;
2619
2620	phy_start(net->phydev);
 
 
2621
2622	netif_dbg(dev, ifup, dev->net, "phy initialised successfully");
 
 
2623
2624	/* for Link Check */
2625	if (dev->urb_intr) {
2626		ret = usb_submit_urb(dev->urb_intr, GFP_KERNEL);
2627		if (ret < 0) {
2628			netif_err(dev, ifup, dev->net,
2629				  "intr submit %d\n", ret);
2630			goto done;
2631		}
2632	}
2633
2634	lan78xx_init_stats(dev);
2635
2636	set_bit(EVENT_DEV_OPEN, &dev->flags);
2637
2638	netif_start_queue(net);
2639
2640	dev->link_on = false;
2641
2642	lan78xx_defer_kevent(dev, EVENT_LINK_RESET);
2643done:
2644	usb_autopm_put_interface(dev->intf);
2645
2646out:
2647	return ret;
2648}
2649
2650static void lan78xx_terminate_urbs(struct lan78xx_net *dev)
2651{
2652	DECLARE_WAIT_QUEUE_HEAD_ONSTACK(unlink_wakeup);
2653	DECLARE_WAITQUEUE(wait, current);
2654	int temp;
2655
2656	/* ensure there are no more active urbs */
2657	add_wait_queue(&unlink_wakeup, &wait);
2658	set_current_state(TASK_UNINTERRUPTIBLE);
2659	dev->wait = &unlink_wakeup;
2660	temp = unlink_urbs(dev, &dev->txq) + unlink_urbs(dev, &dev->rxq);
2661
2662	/* maybe wait for deletions to finish. */
2663	while (!skb_queue_empty(&dev->rxq) &&
2664	       !skb_queue_empty(&dev->txq) &&
2665	       !skb_queue_empty(&dev->done)) {
2666		schedule_timeout(msecs_to_jiffies(UNLINK_TIMEOUT_MS));
2667		set_current_state(TASK_UNINTERRUPTIBLE);
2668		netif_dbg(dev, ifdown, dev->net,
2669			  "waited for %d urb completions\n", temp);
2670	}
2671	set_current_state(TASK_RUNNING);
2672	dev->wait = NULL;
2673	remove_wait_queue(&unlink_wakeup, &wait);
2674}
2675
2676static int lan78xx_stop(struct net_device *net)
2677{
2678	struct lan78xx_net *dev = netdev_priv(net);
2679
2680	if (timer_pending(&dev->stat_monitor))
2681		del_timer_sync(&dev->stat_monitor);
2682
2683	if (net->phydev)
2684		phy_stop(net->phydev);
 
2685
2686	clear_bit(EVENT_DEV_OPEN, &dev->flags);
2687	netif_stop_queue(net);
2688
2689	netif_info(dev, ifdown, dev->net,
2690		   "stop stats: rx/tx %lu/%lu, errs %lu/%lu\n",
2691		   net->stats.rx_packets, net->stats.tx_packets,
2692		   net->stats.rx_errors, net->stats.tx_errors);
2693
2694	lan78xx_terminate_urbs(dev);
2695
2696	usb_kill_urb(dev->urb_intr);
2697
2698	skb_queue_purge(&dev->rxq_pause);
2699
2700	/* deferred work (task, timer, softirq) must also stop.
2701	 * can't flush_scheduled_work() until we drop rtnl (later),
2702	 * else workers could deadlock; so make workers a NOP.
2703	 */
2704	dev->flags = 0;
2705	cancel_delayed_work_sync(&dev->wq);
2706	tasklet_kill(&dev->bh);
2707
2708	usb_autopm_put_interface(dev->intf);
2709
2710	return 0;
2711}
2712
 
 
 
 
 
2713static struct sk_buff *lan78xx_tx_prep(struct lan78xx_net *dev,
2714				       struct sk_buff *skb, gfp_t flags)
2715{
2716	u32 tx_cmd_a, tx_cmd_b;
2717	void *ptr;
2718
2719	if (skb_cow_head(skb, TX_OVERHEAD)) {
 
 
 
2720		dev_kfree_skb_any(skb);
2721		return NULL;
 
 
2722	}
2723
2724	if (skb_linearize(skb)) {
2725		dev_kfree_skb_any(skb);
2726		return NULL;
2727	}
2728
2729	tx_cmd_a = (u32)(skb->len & TX_CMD_A_LEN_MASK_) | TX_CMD_A_FCS_;
2730
2731	if (skb->ip_summed == CHECKSUM_PARTIAL)
2732		tx_cmd_a |= TX_CMD_A_IPE_ | TX_CMD_A_TPE_;
2733
2734	tx_cmd_b = 0;
2735	if (skb_is_gso(skb)) {
2736		u16 mss = max(skb_shinfo(skb)->gso_size, TX_CMD_B_MSS_MIN_);
2737
2738		tx_cmd_b = (mss << TX_CMD_B_MSS_SHIFT_) & TX_CMD_B_MSS_MASK_;
2739
2740		tx_cmd_a |= TX_CMD_A_LSO_;
2741	}
2742
2743	if (skb_vlan_tag_present(skb)) {
2744		tx_cmd_a |= TX_CMD_A_IVTG_;
2745		tx_cmd_b |= skb_vlan_tag_get(skb) & TX_CMD_B_VTAG_MASK_;
2746	}
2747
2748	ptr = skb_push(skb, 8);
2749	put_unaligned_le32(tx_cmd_a, ptr);
2750	put_unaligned_le32(tx_cmd_b, ptr + 4);
 
 
 
 
2751
2752	return skb;
2753}
2754
2755static enum skb_state defer_bh(struct lan78xx_net *dev, struct sk_buff *skb,
2756			       struct sk_buff_head *list, enum skb_state state)
2757{
2758	unsigned long flags;
2759	enum skb_state old_state;
2760	struct skb_data *entry = (struct skb_data *)skb->cb;
2761
2762	spin_lock_irqsave(&list->lock, flags);
2763	old_state = entry->state;
2764	entry->state = state;
2765
2766	__skb_unlink(skb, list);
2767	spin_unlock(&list->lock);
2768	spin_lock(&dev->done.lock);
2769
2770	__skb_queue_tail(&dev->done, skb);
2771	if (skb_queue_len(&dev->done) == 1)
2772		tasklet_schedule(&dev->bh);
2773	spin_unlock_irqrestore(&dev->done.lock, flags);
2774
2775	return old_state;
2776}
2777
2778static void tx_complete(struct urb *urb)
2779{
2780	struct sk_buff *skb = (struct sk_buff *)urb->context;
2781	struct skb_data *entry = (struct skb_data *)skb->cb;
2782	struct lan78xx_net *dev = entry->dev;
2783
2784	if (urb->status == 0) {
2785		dev->net->stats.tx_packets += entry->num_of_packet;
2786		dev->net->stats.tx_bytes += entry->length;
2787	} else {
2788		dev->net->stats.tx_errors++;
2789
2790		switch (urb->status) {
2791		case -EPIPE:
2792			lan78xx_defer_kevent(dev, EVENT_TX_HALT);
2793			break;
2794
2795		/* software-driven interface shutdown */
2796		case -ECONNRESET:
2797		case -ESHUTDOWN:
2798			break;
2799
2800		case -EPROTO:
2801		case -ETIME:
2802		case -EILSEQ:
2803			netif_stop_queue(dev->net);
2804			break;
2805		default:
2806			netif_dbg(dev, tx_err, dev->net,
2807				  "tx err %d\n", entry->urb->status);
2808			break;
2809		}
2810	}
2811
2812	usb_autopm_put_interface_async(dev->intf);
2813
2814	defer_bh(dev, skb, &dev->txq, tx_done);
2815}
2816
2817static void lan78xx_queue_skb(struct sk_buff_head *list,
2818			      struct sk_buff *newsk, enum skb_state state)
2819{
2820	struct skb_data *entry = (struct skb_data *)newsk->cb;
2821
2822	__skb_queue_tail(list, newsk);
2823	entry->state = state;
2824}
2825
2826static netdev_tx_t
2827lan78xx_start_xmit(struct sk_buff *skb, struct net_device *net)
2828{
2829	struct lan78xx_net *dev = netdev_priv(net);
2830	struct sk_buff *skb2 = NULL;
2831
2832	if (skb) {
2833		skb_tx_timestamp(skb);
2834		skb2 = lan78xx_tx_prep(dev, skb, GFP_ATOMIC);
2835	}
2836
2837	if (skb2) {
2838		skb_queue_tail(&dev->txq_pend, skb2);
2839
2840		/* throttle TX patch at slower than SUPER SPEED USB */
2841		if ((dev->udev->speed < USB_SPEED_SUPER) &&
2842		    (skb_queue_len(&dev->txq_pend) > 10))
2843			netif_stop_queue(net);
2844	} else {
2845		netif_dbg(dev, tx_err, dev->net,
2846			  "lan78xx_tx_prep return NULL\n");
2847		dev->net->stats.tx_errors++;
2848		dev->net->stats.tx_dropped++;
2849	}
2850
2851	tasklet_schedule(&dev->bh);
2852
2853	return NETDEV_TX_OK;
2854}
2855
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2856static int lan78xx_bind(struct lan78xx_net *dev, struct usb_interface *intf)
2857{
2858	struct lan78xx_priv *pdata = NULL;
2859	int ret;
2860	int i;
2861
 
 
2862	dev->data[0] = (unsigned long)kzalloc(sizeof(*pdata), GFP_KERNEL);
2863
2864	pdata = (struct lan78xx_priv *)(dev->data[0]);
2865	if (!pdata) {
2866		netdev_warn(dev->net, "Unable to allocate lan78xx_priv");
2867		return -ENOMEM;
2868	}
2869
2870	pdata->dev = dev;
2871
2872	spin_lock_init(&pdata->rfe_ctl_lock);
2873	mutex_init(&pdata->dataport_mutex);
2874
2875	INIT_WORK(&pdata->set_multicast, lan78xx_deferred_multicast_write);
2876
2877	for (i = 0; i < DP_SEL_VHF_VLAN_LEN; i++)
2878		pdata->vlan_table[i] = 0;
2879
2880	INIT_WORK(&pdata->set_vlan, lan78xx_deferred_vlan_write);
2881
2882	dev->net->features = 0;
2883
2884	if (DEFAULT_TX_CSUM_ENABLE)
2885		dev->net->features |= NETIF_F_HW_CSUM;
2886
2887	if (DEFAULT_RX_CSUM_ENABLE)
2888		dev->net->features |= NETIF_F_RXCSUM;
2889
2890	if (DEFAULT_TSO_CSUM_ENABLE)
2891		dev->net->features |= NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_SG;
2892
2893	if (DEFAULT_VLAN_RX_OFFLOAD)
2894		dev->net->features |= NETIF_F_HW_VLAN_CTAG_RX;
2895
2896	if (DEFAULT_VLAN_FILTER_ENABLE)
2897		dev->net->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
2898
2899	dev->net->hw_features = dev->net->features;
2900
2901	ret = lan78xx_setup_irq_domain(dev);
2902	if (ret < 0) {
2903		netdev_warn(dev->net,
2904			    "lan78xx_setup_irq_domain() failed : %d", ret);
2905		goto out1;
2906	}
2907
2908	dev->net->hard_header_len += TX_OVERHEAD;
2909	dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;
2910
2911	/* Init all registers */
2912	ret = lan78xx_reset(dev);
2913	if (ret) {
2914		netdev_warn(dev->net, "Registers INIT FAILED....");
2915		goto out2;
2916	}
2917
2918	ret = lan78xx_mdio_init(dev);
2919	if (ret) {
2920		netdev_warn(dev->net, "MDIO INIT FAILED.....");
2921		goto out2;
2922	}
2923
2924	dev->net->flags |= IFF_MULTICAST;
2925
2926	pdata->wol = WAKE_MAGIC;
2927
2928	return ret;
2929
2930out2:
2931	lan78xx_remove_irq_domain(dev);
2932
2933out1:
2934	netdev_warn(dev->net, "Bind routine FAILED");
2935	cancel_work_sync(&pdata->set_multicast);
2936	cancel_work_sync(&pdata->set_vlan);
2937	kfree(pdata);
2938	return ret;
2939}
2940
2941static void lan78xx_unbind(struct lan78xx_net *dev, struct usb_interface *intf)
2942{
2943	struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2944
2945	lan78xx_remove_irq_domain(dev);
2946
2947	lan78xx_remove_mdio(dev);
2948
2949	if (pdata) {
2950		cancel_work_sync(&pdata->set_multicast);
2951		cancel_work_sync(&pdata->set_vlan);
2952		netif_dbg(dev, ifdown, dev->net, "free pdata");
2953		kfree(pdata);
2954		pdata = NULL;
2955		dev->data[0] = 0;
2956	}
2957}
2958
2959static void lan78xx_rx_csum_offload(struct lan78xx_net *dev,
2960				    struct sk_buff *skb,
2961				    u32 rx_cmd_a, u32 rx_cmd_b)
2962{
2963	/* HW Checksum offload appears to be flawed if used when not stripping
2964	 * VLAN headers. Drop back to S/W checksums under these conditions.
2965	 */
2966	if (!(dev->net->features & NETIF_F_RXCSUM) ||
2967	    unlikely(rx_cmd_a & RX_CMD_A_ICSM_) ||
2968	    ((rx_cmd_a & RX_CMD_A_FVTG_) &&
2969	     !(dev->net->features & NETIF_F_HW_VLAN_CTAG_RX))) {
2970		skb->ip_summed = CHECKSUM_NONE;
2971	} else {
2972		skb->csum = ntohs((u16)(rx_cmd_b >> RX_CMD_B_CSUM_SHIFT_));
2973		skb->ip_summed = CHECKSUM_COMPLETE;
2974	}
2975}
2976
2977static void lan78xx_rx_vlan_offload(struct lan78xx_net *dev,
2978				    struct sk_buff *skb,
2979				    u32 rx_cmd_a, u32 rx_cmd_b)
2980{
2981	if ((dev->net->features & NETIF_F_HW_VLAN_CTAG_RX) &&
2982	    (rx_cmd_a & RX_CMD_A_FVTG_))
2983		__vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q),
2984				       (rx_cmd_b & 0xffff));
2985}
2986
2987static void lan78xx_skb_return(struct lan78xx_net *dev, struct sk_buff *skb)
2988{
2989	int status;
2990
2991	if (test_bit(EVENT_RX_PAUSED, &dev->flags)) {
2992		skb_queue_tail(&dev->rxq_pause, skb);
2993		return;
2994	}
2995
2996	dev->net->stats.rx_packets++;
2997	dev->net->stats.rx_bytes += skb->len;
2998
2999	skb->protocol = eth_type_trans(skb, dev->net);
3000
3001	netif_dbg(dev, rx_status, dev->net, "< rx, len %zu, type 0x%x\n",
3002		  skb->len + sizeof(struct ethhdr), skb->protocol);
3003	memset(skb->cb, 0, sizeof(struct skb_data));
3004
3005	if (skb_defer_rx_timestamp(skb))
3006		return;
3007
3008	status = netif_rx(skb);
3009	if (status != NET_RX_SUCCESS)
3010		netif_dbg(dev, rx_err, dev->net,
3011			  "netif_rx status %d\n", status);
3012}
3013
3014static int lan78xx_rx(struct lan78xx_net *dev, struct sk_buff *skb)
3015{
3016	if (skb->len < dev->net->hard_header_len)
3017		return 0;
3018
3019	while (skb->len > 0) {
3020		u32 rx_cmd_a, rx_cmd_b, align_count, size;
3021		u16 rx_cmd_c;
3022		struct sk_buff *skb2;
3023		unsigned char *packet;
3024
3025		rx_cmd_a = get_unaligned_le32(skb->data);
 
3026		skb_pull(skb, sizeof(rx_cmd_a));
3027
3028		rx_cmd_b = get_unaligned_le32(skb->data);
 
3029		skb_pull(skb, sizeof(rx_cmd_b));
3030
3031		rx_cmd_c = get_unaligned_le16(skb->data);
 
3032		skb_pull(skb, sizeof(rx_cmd_c));
3033
3034		packet = skb->data;
3035
3036		/* get the packet length */
3037		size = (rx_cmd_a & RX_CMD_A_LEN_MASK_);
3038		align_count = (4 - ((size + RXW_PADDING) % 4)) % 4;
3039
3040		if (unlikely(rx_cmd_a & RX_CMD_A_RED_)) {
3041			netif_dbg(dev, rx_err, dev->net,
3042				  "Error rx_cmd_a=0x%08x", rx_cmd_a);
3043		} else {
3044			/* last frame in this batch */
3045			if (skb->len == size) {
3046				lan78xx_rx_csum_offload(dev, skb,
3047							rx_cmd_a, rx_cmd_b);
3048				lan78xx_rx_vlan_offload(dev, skb,
3049							rx_cmd_a, rx_cmd_b);
3050
3051				skb_trim(skb, skb->len - 4); /* remove fcs */
3052				skb->truesize = size + sizeof(struct sk_buff);
3053
3054				return 1;
3055			}
3056
3057			skb2 = skb_clone(skb, GFP_ATOMIC);
3058			if (unlikely(!skb2)) {
3059				netdev_warn(dev->net, "Error allocating skb");
3060				return 0;
3061			}
3062
3063			skb2->len = size;
3064			skb2->data = packet;
3065			skb_set_tail_pointer(skb2, size);
3066
3067			lan78xx_rx_csum_offload(dev, skb2, rx_cmd_a, rx_cmd_b);
3068			lan78xx_rx_vlan_offload(dev, skb2, rx_cmd_a, rx_cmd_b);
3069
3070			skb_trim(skb2, skb2->len - 4); /* remove fcs */
3071			skb2->truesize = size + sizeof(struct sk_buff);
3072
3073			lan78xx_skb_return(dev, skb2);
3074		}
3075
3076		skb_pull(skb, size);
3077
3078		/* padding bytes before the next frame starts */
3079		if (skb->len)
3080			skb_pull(skb, align_count);
3081	}
3082
3083	return 1;
3084}
3085
3086static inline void rx_process(struct lan78xx_net *dev, struct sk_buff *skb)
3087{
3088	if (!lan78xx_rx(dev, skb)) {
3089		dev->net->stats.rx_errors++;
3090		goto done;
3091	}
3092
3093	if (skb->len) {
3094		lan78xx_skb_return(dev, skb);
3095		return;
3096	}
3097
3098	netif_dbg(dev, rx_err, dev->net, "drop\n");
3099	dev->net->stats.rx_errors++;
3100done:
3101	skb_queue_tail(&dev->done, skb);
3102}
3103
3104static void rx_complete(struct urb *urb);
3105
3106static int rx_submit(struct lan78xx_net *dev, struct urb *urb, gfp_t flags)
3107{
3108	struct sk_buff *skb;
3109	struct skb_data *entry;
3110	unsigned long lockflags;
3111	size_t size = dev->rx_urb_size;
3112	int ret = 0;
3113
3114	skb = netdev_alloc_skb_ip_align(dev->net, size);
3115	if (!skb) {
3116		usb_free_urb(urb);
3117		return -ENOMEM;
3118	}
3119
3120	entry = (struct skb_data *)skb->cb;
3121	entry->urb = urb;
3122	entry->dev = dev;
3123	entry->length = 0;
3124
3125	usb_fill_bulk_urb(urb, dev->udev, dev->pipe_in,
3126			  skb->data, size, rx_complete, skb);
3127
3128	spin_lock_irqsave(&dev->rxq.lock, lockflags);
3129
3130	if (netif_device_present(dev->net) &&
3131	    netif_running(dev->net) &&
3132	    !test_bit(EVENT_RX_HALT, &dev->flags) &&
3133	    !test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3134		ret = usb_submit_urb(urb, GFP_ATOMIC);
3135		switch (ret) {
3136		case 0:
3137			lan78xx_queue_skb(&dev->rxq, skb, rx_start);
3138			break;
3139		case -EPIPE:
3140			lan78xx_defer_kevent(dev, EVENT_RX_HALT);
3141			break;
3142		case -ENODEV:
3143			netif_dbg(dev, ifdown, dev->net, "device gone\n");
3144			netif_device_detach(dev->net);
3145			break;
3146		case -EHOSTUNREACH:
3147			ret = -ENOLINK;
3148			break;
3149		default:
3150			netif_dbg(dev, rx_err, dev->net,
3151				  "rx submit, %d\n", ret);
3152			tasklet_schedule(&dev->bh);
3153		}
3154	} else {
3155		netif_dbg(dev, ifdown, dev->net, "rx: stopped\n");
3156		ret = -ENOLINK;
3157	}
3158	spin_unlock_irqrestore(&dev->rxq.lock, lockflags);
3159	if (ret) {
3160		dev_kfree_skb_any(skb);
3161		usb_free_urb(urb);
3162	}
3163	return ret;
3164}
3165
3166static void rx_complete(struct urb *urb)
3167{
3168	struct sk_buff	*skb = (struct sk_buff *)urb->context;
3169	struct skb_data	*entry = (struct skb_data *)skb->cb;
3170	struct lan78xx_net *dev = entry->dev;
3171	int urb_status = urb->status;
3172	enum skb_state state;
3173
3174	skb_put(skb, urb->actual_length);
3175	state = rx_done;
3176	entry->urb = NULL;
3177
3178	switch (urb_status) {
3179	case 0:
3180		if (skb->len < dev->net->hard_header_len) {
3181			state = rx_cleanup;
3182			dev->net->stats.rx_errors++;
3183			dev->net->stats.rx_length_errors++;
3184			netif_dbg(dev, rx_err, dev->net,
3185				  "rx length %d\n", skb->len);
3186		}
3187		usb_mark_last_busy(dev->udev);
3188		break;
3189	case -EPIPE:
3190		dev->net->stats.rx_errors++;
3191		lan78xx_defer_kevent(dev, EVENT_RX_HALT);
3192		fallthrough;
3193	case -ECONNRESET:				/* async unlink */
3194	case -ESHUTDOWN:				/* hardware gone */
3195		netif_dbg(dev, ifdown, dev->net,
3196			  "rx shutdown, code %d\n", urb_status);
3197		state = rx_cleanup;
3198		entry->urb = urb;
3199		urb = NULL;
3200		break;
3201	case -EPROTO:
3202	case -ETIME:
3203	case -EILSEQ:
3204		dev->net->stats.rx_errors++;
3205		state = rx_cleanup;
3206		entry->urb = urb;
3207		urb = NULL;
3208		break;
3209
3210	/* data overrun ... flush fifo? */
3211	case -EOVERFLOW:
3212		dev->net->stats.rx_over_errors++;
3213		fallthrough;
3214
3215	default:
3216		state = rx_cleanup;
3217		dev->net->stats.rx_errors++;
3218		netif_dbg(dev, rx_err, dev->net, "rx status %d\n", urb_status);
3219		break;
3220	}
3221
3222	state = defer_bh(dev, skb, &dev->rxq, state);
3223
3224	if (urb) {
3225		if (netif_running(dev->net) &&
3226		    !test_bit(EVENT_RX_HALT, &dev->flags) &&
3227		    state != unlink_start) {
3228			rx_submit(dev, urb, GFP_ATOMIC);
3229			return;
3230		}
3231		usb_free_urb(urb);
3232	}
3233	netif_dbg(dev, rx_err, dev->net, "no read resubmitted\n");
3234}
3235
3236static void lan78xx_tx_bh(struct lan78xx_net *dev)
3237{
3238	int length;
3239	struct urb *urb = NULL;
3240	struct skb_data *entry;
3241	unsigned long flags;
3242	struct sk_buff_head *tqp = &dev->txq_pend;
3243	struct sk_buff *skb, *skb2;
3244	int ret;
3245	int count, pos;
3246	int skb_totallen, pkt_cnt;
3247
3248	skb_totallen = 0;
3249	pkt_cnt = 0;
3250	count = 0;
3251	length = 0;
3252	spin_lock_irqsave(&tqp->lock, flags);
3253	skb_queue_walk(tqp, skb) {
3254		if (skb_is_gso(skb)) {
3255			if (!skb_queue_is_first(tqp, skb)) {
3256				/* handle previous packets first */
3257				break;
3258			}
3259			count = 1;
3260			length = skb->len - TX_OVERHEAD;
3261			__skb_unlink(skb, tqp);
3262			spin_unlock_irqrestore(&tqp->lock, flags);
3263			goto gso_skb;
3264		}
3265
3266		if ((skb_totallen + skb->len) > MAX_SINGLE_PACKET_SIZE)
3267			break;
3268		skb_totallen = skb->len + roundup(skb_totallen, sizeof(u32));
3269		pkt_cnt++;
3270	}
3271	spin_unlock_irqrestore(&tqp->lock, flags);
3272
3273	/* copy to a single skb */
3274	skb = alloc_skb(skb_totallen, GFP_ATOMIC);
3275	if (!skb)
3276		goto drop;
3277
3278	skb_put(skb, skb_totallen);
3279
3280	for (count = pos = 0; count < pkt_cnt; count++) {
3281		skb2 = skb_dequeue(tqp);
3282		if (skb2) {
3283			length += (skb2->len - TX_OVERHEAD);
3284			memcpy(skb->data + pos, skb2->data, skb2->len);
3285			pos += roundup(skb2->len, sizeof(u32));
3286			dev_kfree_skb(skb2);
3287		}
3288	}
3289
3290gso_skb:
3291	urb = usb_alloc_urb(0, GFP_ATOMIC);
3292	if (!urb)
 
3293		goto drop;
 
3294
3295	entry = (struct skb_data *)skb->cb;
3296	entry->urb = urb;
3297	entry->dev = dev;
3298	entry->length = length;
3299	entry->num_of_packet = count;
3300
3301	spin_lock_irqsave(&dev->txq.lock, flags);
3302	ret = usb_autopm_get_interface_async(dev->intf);
3303	if (ret < 0) {
3304		spin_unlock_irqrestore(&dev->txq.lock, flags);
3305		goto drop;
3306	}
3307
3308	usb_fill_bulk_urb(urb, dev->udev, dev->pipe_out,
3309			  skb->data, skb->len, tx_complete, skb);
3310
3311	if (length % dev->maxpacket == 0) {
3312		/* send USB_ZERO_PACKET */
3313		urb->transfer_flags |= URB_ZERO_PACKET;
3314	}
3315
3316#ifdef CONFIG_PM
3317	/* if this triggers the device is still a sleep */
3318	if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3319		/* transmission will be done in resume */
3320		usb_anchor_urb(urb, &dev->deferred);
3321		/* no use to process more packets */
3322		netif_stop_queue(dev->net);
3323		usb_put_urb(urb);
3324		spin_unlock_irqrestore(&dev->txq.lock, flags);
3325		netdev_dbg(dev->net, "Delaying transmission for resumption\n");
3326		return;
3327	}
3328#endif
3329
3330	ret = usb_submit_urb(urb, GFP_ATOMIC);
3331	switch (ret) {
3332	case 0:
3333		netif_trans_update(dev->net);
3334		lan78xx_queue_skb(&dev->txq, skb, tx_start);
3335		if (skb_queue_len(&dev->txq) >= dev->tx_qlen)
3336			netif_stop_queue(dev->net);
3337		break;
3338	case -EPIPE:
3339		netif_stop_queue(dev->net);
3340		lan78xx_defer_kevent(dev, EVENT_TX_HALT);
3341		usb_autopm_put_interface_async(dev->intf);
3342		break;
3343	default:
3344		usb_autopm_put_interface_async(dev->intf);
3345		netif_dbg(dev, tx_err, dev->net,
3346			  "tx: submit urb err %d\n", ret);
3347		break;
3348	}
3349
3350	spin_unlock_irqrestore(&dev->txq.lock, flags);
3351
3352	if (ret) {
3353		netif_dbg(dev, tx_err, dev->net, "drop, code %d\n", ret);
3354drop:
3355		dev->net->stats.tx_dropped++;
3356		if (skb)
3357			dev_kfree_skb_any(skb);
3358		usb_free_urb(urb);
3359	} else
3360		netif_dbg(dev, tx_queued, dev->net,
3361			  "> tx, len %d, type 0x%x\n", length, skb->protocol);
3362}
3363
3364static void lan78xx_rx_bh(struct lan78xx_net *dev)
3365{
3366	struct urb *urb;
3367	int i;
3368
3369	if (skb_queue_len(&dev->rxq) < dev->rx_qlen) {
3370		for (i = 0; i < 10; i++) {
3371			if (skb_queue_len(&dev->rxq) >= dev->rx_qlen)
3372				break;
3373			urb = usb_alloc_urb(0, GFP_ATOMIC);
3374			if (urb)
3375				if (rx_submit(dev, urb, GFP_ATOMIC) == -ENOLINK)
3376					return;
3377		}
3378
3379		if (skb_queue_len(&dev->rxq) < dev->rx_qlen)
3380			tasklet_schedule(&dev->bh);
3381	}
3382	if (skb_queue_len(&dev->txq) < dev->tx_qlen)
3383		netif_wake_queue(dev->net);
3384}
3385
3386static void lan78xx_bh(struct tasklet_struct *t)
3387{
3388	struct lan78xx_net *dev = from_tasklet(dev, t, bh);
3389	struct sk_buff *skb;
3390	struct skb_data *entry;
3391
3392	while ((skb = skb_dequeue(&dev->done))) {
3393		entry = (struct skb_data *)(skb->cb);
3394		switch (entry->state) {
3395		case rx_done:
3396			entry->state = rx_cleanup;
3397			rx_process(dev, skb);
3398			continue;
3399		case tx_done:
3400			usb_free_urb(entry->urb);
3401			dev_kfree_skb(skb);
3402			continue;
3403		case rx_cleanup:
3404			usb_free_urb(entry->urb);
3405			dev_kfree_skb(skb);
3406			continue;
3407		default:
3408			netdev_dbg(dev->net, "skb state %d\n", entry->state);
3409			return;
3410		}
3411	}
3412
3413	if (netif_device_present(dev->net) && netif_running(dev->net)) {
3414		/* reset update timer delta */
3415		if (timer_pending(&dev->stat_monitor) && (dev->delta != 1)) {
3416			dev->delta = 1;
3417			mod_timer(&dev->stat_monitor,
3418				  jiffies + STAT_UPDATE_TIMER);
3419		}
3420
3421		if (!skb_queue_empty(&dev->txq_pend))
3422			lan78xx_tx_bh(dev);
3423
3424		if (!timer_pending(&dev->delay) &&
3425		    !test_bit(EVENT_RX_HALT, &dev->flags))
3426			lan78xx_rx_bh(dev);
3427	}
3428}
3429
3430static void lan78xx_delayedwork(struct work_struct *work)
3431{
3432	int status;
3433	struct lan78xx_net *dev;
3434
3435	dev = container_of(work, struct lan78xx_net, wq.work);
3436
3437	if (test_bit(EVENT_TX_HALT, &dev->flags)) {
3438		unlink_urbs(dev, &dev->txq);
3439		status = usb_autopm_get_interface(dev->intf);
3440		if (status < 0)
3441			goto fail_pipe;
3442		status = usb_clear_halt(dev->udev, dev->pipe_out);
3443		usb_autopm_put_interface(dev->intf);
3444		if (status < 0 &&
3445		    status != -EPIPE &&
3446		    status != -ESHUTDOWN) {
3447			if (netif_msg_tx_err(dev))
3448fail_pipe:
3449				netdev_err(dev->net,
3450					   "can't clear tx halt, status %d\n",
3451					   status);
3452		} else {
3453			clear_bit(EVENT_TX_HALT, &dev->flags);
3454			if (status != -ESHUTDOWN)
3455				netif_wake_queue(dev->net);
3456		}
3457	}
3458	if (test_bit(EVENT_RX_HALT, &dev->flags)) {
3459		unlink_urbs(dev, &dev->rxq);
3460		status = usb_autopm_get_interface(dev->intf);
3461		if (status < 0)
3462				goto fail_halt;
3463		status = usb_clear_halt(dev->udev, dev->pipe_in);
3464		usb_autopm_put_interface(dev->intf);
3465		if (status < 0 &&
3466		    status != -EPIPE &&
3467		    status != -ESHUTDOWN) {
3468			if (netif_msg_rx_err(dev))
3469fail_halt:
3470				netdev_err(dev->net,
3471					   "can't clear rx halt, status %d\n",
3472					   status);
3473		} else {
3474			clear_bit(EVENT_RX_HALT, &dev->flags);
3475			tasklet_schedule(&dev->bh);
3476		}
3477	}
3478
3479	if (test_bit(EVENT_LINK_RESET, &dev->flags)) {
3480		int ret = 0;
3481
3482		clear_bit(EVENT_LINK_RESET, &dev->flags);
3483		status = usb_autopm_get_interface(dev->intf);
3484		if (status < 0)
3485			goto skip_reset;
3486		if (lan78xx_link_reset(dev) < 0) {
3487			usb_autopm_put_interface(dev->intf);
3488skip_reset:
3489			netdev_info(dev->net, "link reset failed (%d)\n",
3490				    ret);
3491		} else {
3492			usb_autopm_put_interface(dev->intf);
3493		}
3494	}
3495
3496	if (test_bit(EVENT_STAT_UPDATE, &dev->flags)) {
3497		lan78xx_update_stats(dev);
3498
3499		clear_bit(EVENT_STAT_UPDATE, &dev->flags);
3500
3501		mod_timer(&dev->stat_monitor,
3502			  jiffies + (STAT_UPDATE_TIMER * dev->delta));
3503
3504		dev->delta = min((dev->delta * 2), 50);
3505	}
3506}
3507
3508static void intr_complete(struct urb *urb)
3509{
3510	struct lan78xx_net *dev = urb->context;
3511	int status = urb->status;
3512
3513	switch (status) {
3514	/* success */
3515	case 0:
3516		lan78xx_status(dev, urb);
3517		break;
3518
3519	/* software-driven interface shutdown */
3520	case -ENOENT:			/* urb killed */
3521	case -ESHUTDOWN:		/* hardware gone */
3522		netif_dbg(dev, ifdown, dev->net,
3523			  "intr shutdown, code %d\n", status);
3524		return;
3525
3526	/* NOTE:  not throttling like RX/TX, since this endpoint
3527	 * already polls infrequently
3528	 */
3529	default:
3530		netdev_dbg(dev->net, "intr status %d\n", status);
3531		break;
3532	}
3533
3534	if (!netif_running(dev->net))
3535		return;
3536
3537	memset(urb->transfer_buffer, 0, urb->transfer_buffer_length);
3538	status = usb_submit_urb(urb, GFP_ATOMIC);
3539	if (status != 0)
3540		netif_err(dev, timer, dev->net,
3541			  "intr resubmit --> %d\n", status);
3542}
3543
3544static void lan78xx_disconnect(struct usb_interface *intf)
3545{
3546	struct lan78xx_net *dev;
3547	struct usb_device *udev;
3548	struct net_device *net;
3549	struct phy_device *phydev;
3550
3551	dev = usb_get_intfdata(intf);
3552	usb_set_intfdata(intf, NULL);
3553	if (!dev)
3554		return;
3555
3556	udev = interface_to_usbdev(intf);
3557	net = dev->net;
3558	phydev = net->phydev;
3559
3560	phy_unregister_fixup_for_uid(PHY_KSZ9031RNX, 0xfffffff0);
3561	phy_unregister_fixup_for_uid(PHY_LAN8835, 0xfffffff0);
3562
3563	phy_disconnect(net->phydev);
3564
3565	if (phy_is_pseudo_fixed_link(phydev))
3566		fixed_phy_unregister(phydev);
3567
 
3568	unregister_netdev(net);
3569
3570	cancel_delayed_work_sync(&dev->wq);
3571
3572	usb_scuttle_anchored_urbs(&dev->deferred);
3573
3574	lan78xx_unbind(dev, intf);
3575
3576	usb_kill_urb(dev->urb_intr);
3577	usb_free_urb(dev->urb_intr);
3578
3579	free_netdev(net);
3580	usb_put_dev(udev);
3581}
3582
3583static void lan78xx_tx_timeout(struct net_device *net, unsigned int txqueue)
3584{
3585	struct lan78xx_net *dev = netdev_priv(net);
3586
3587	unlink_urbs(dev, &dev->txq);
3588	tasklet_schedule(&dev->bh);
3589}
3590
3591static netdev_features_t lan78xx_features_check(struct sk_buff *skb,
3592						struct net_device *netdev,
3593						netdev_features_t features)
3594{
3595	if (skb->len + TX_OVERHEAD > MAX_SINGLE_PACKET_SIZE)
3596		features &= ~NETIF_F_GSO_MASK;
3597
3598	features = vlan_features_check(skb, features);
3599	features = vxlan_features_check(skb, features);
3600
3601	return features;
3602}
3603
3604static const struct net_device_ops lan78xx_netdev_ops = {
3605	.ndo_open		= lan78xx_open,
3606	.ndo_stop		= lan78xx_stop,
3607	.ndo_start_xmit		= lan78xx_start_xmit,
3608	.ndo_tx_timeout		= lan78xx_tx_timeout,
3609	.ndo_change_mtu		= lan78xx_change_mtu,
3610	.ndo_set_mac_address	= lan78xx_set_mac_addr,
3611	.ndo_validate_addr	= eth_validate_addr,
3612	.ndo_do_ioctl		= phy_do_ioctl_running,
3613	.ndo_set_rx_mode	= lan78xx_set_multicast,
3614	.ndo_set_features	= lan78xx_set_features,
3615	.ndo_vlan_rx_add_vid	= lan78xx_vlan_rx_add_vid,
3616	.ndo_vlan_rx_kill_vid	= lan78xx_vlan_rx_kill_vid,
3617	.ndo_features_check	= lan78xx_features_check,
3618};
3619
3620static void lan78xx_stat_monitor(struct timer_list *t)
3621{
3622	struct lan78xx_net *dev = from_timer(dev, t, stat_monitor);
 
 
3623
3624	lan78xx_defer_kevent(dev, EVENT_STAT_UPDATE);
3625}
3626
3627static int lan78xx_probe(struct usb_interface *intf,
3628			 const struct usb_device_id *id)
3629{
3630	struct usb_host_endpoint *ep_blkin, *ep_blkout, *ep_intr;
3631	struct lan78xx_net *dev;
3632	struct net_device *netdev;
3633	struct usb_device *udev;
3634	int ret;
3635	unsigned maxp;
3636	unsigned period;
3637	u8 *buf = NULL;
3638
3639	udev = interface_to_usbdev(intf);
3640	udev = usb_get_dev(udev);
3641
 
3642	netdev = alloc_etherdev(sizeof(struct lan78xx_net));
3643	if (!netdev) {
3644		dev_err(&intf->dev, "Error: OOM\n");
3645		ret = -ENOMEM;
3646		goto out1;
3647	}
3648
3649	/* netdev_printk() needs this */
3650	SET_NETDEV_DEV(netdev, &intf->dev);
3651
3652	dev = netdev_priv(netdev);
3653	dev->udev = udev;
3654	dev->intf = intf;
3655	dev->net = netdev;
3656	dev->msg_enable = netif_msg_init(msg_level, NETIF_MSG_DRV
3657					| NETIF_MSG_PROBE | NETIF_MSG_LINK);
3658
3659	skb_queue_head_init(&dev->rxq);
3660	skb_queue_head_init(&dev->txq);
3661	skb_queue_head_init(&dev->done);
3662	skb_queue_head_init(&dev->rxq_pause);
3663	skb_queue_head_init(&dev->txq_pend);
3664	mutex_init(&dev->phy_mutex);
3665
3666	tasklet_setup(&dev->bh, lan78xx_bh);
3667	INIT_DELAYED_WORK(&dev->wq, lan78xx_delayedwork);
3668	init_usb_anchor(&dev->deferred);
3669
3670	netdev->netdev_ops = &lan78xx_netdev_ops;
3671	netdev->watchdog_timeo = TX_TIMEOUT_JIFFIES;
3672	netdev->ethtool_ops = &lan78xx_ethtool_ops;
3673
 
 
3674	dev->delta = 1;
3675	timer_setup(&dev->stat_monitor, lan78xx_stat_monitor, 0);
3676
3677	mutex_init(&dev->stats.access_lock);
3678
3679	if (intf->cur_altsetting->desc.bNumEndpoints < 3) {
3680		ret = -ENODEV;
3681		goto out2;
3682	}
3683
3684	dev->pipe_in = usb_rcvbulkpipe(udev, BULK_IN_PIPE);
3685	ep_blkin = usb_pipe_endpoint(udev, dev->pipe_in);
3686	if (!ep_blkin || !usb_endpoint_is_bulk_in(&ep_blkin->desc)) {
3687		ret = -ENODEV;
3688		goto out2;
3689	}
3690
3691	dev->pipe_out = usb_sndbulkpipe(udev, BULK_OUT_PIPE);
3692	ep_blkout = usb_pipe_endpoint(udev, dev->pipe_out);
3693	if (!ep_blkout || !usb_endpoint_is_bulk_out(&ep_blkout->desc)) {
3694		ret = -ENODEV;
3695		goto out2;
3696	}
3697
3698	ep_intr = &intf->cur_altsetting->endpoint[2];
3699	if (!usb_endpoint_is_int_in(&ep_intr->desc)) {
3700		ret = -ENODEV;
3701		goto out2;
3702	}
3703
3704	dev->pipe_intr = usb_rcvintpipe(dev->udev,
3705					usb_endpoint_num(&ep_intr->desc));
3706
3707	ret = lan78xx_bind(dev, intf);
3708	if (ret < 0)
3709		goto out2;
 
3710
3711	if (netdev->mtu > (dev->hard_mtu - netdev->hard_header_len))
3712		netdev->mtu = dev->hard_mtu - netdev->hard_header_len;
3713
3714	/* MTU range: 68 - 9000 */
3715	netdev->max_mtu = MAX_SINGLE_PACKET_SIZE;
3716	netif_set_gso_max_size(netdev, MAX_SINGLE_PACKET_SIZE - MAX_HEADER);
 
 
 
 
 
 
 
 
3717
3718	period = ep_intr->desc.bInterval;
3719	maxp = usb_maxpacket(dev->udev, dev->pipe_intr, 0);
3720	buf = kmalloc(maxp, GFP_KERNEL);
3721	if (buf) {
3722		dev->urb_intr = usb_alloc_urb(0, GFP_KERNEL);
3723		if (!dev->urb_intr) {
3724			ret = -ENOMEM;
3725			kfree(buf);
3726			goto out3;
3727		} else {
3728			usb_fill_int_urb(dev->urb_intr, dev->udev,
3729					 dev->pipe_intr, buf, maxp,
3730					 intr_complete, dev, period);
3731			dev->urb_intr->transfer_flags |= URB_FREE_BUFFER;
3732		}
3733	}
3734
3735	dev->maxpacket = usb_maxpacket(dev->udev, dev->pipe_out, 1);
3736
3737	/* driver requires remote-wakeup capability during autosuspend. */
3738	intf->needs_remote_wakeup = 1;
3739
3740	ret = lan78xx_phy_init(dev);
3741	if (ret < 0)
3742		goto out4;
3743
3744	ret = register_netdev(netdev);
3745	if (ret != 0) {
3746		netif_err(dev, probe, netdev, "couldn't register the device\n");
3747		goto out5;
3748	}
3749
3750	usb_set_intfdata(intf, dev);
3751
3752	ret = device_set_wakeup_enable(&udev->dev, true);
3753
3754	 /* Default delay of 2sec has more overhead than advantage.
3755	  * Set to 10sec as default.
3756	  */
3757	pm_runtime_set_autosuspend_delay(&udev->dev,
3758					 DEFAULT_AUTOSUSPEND_DELAY);
3759
3760	return 0;
3761
3762out5:
3763	phy_disconnect(netdev->phydev);
3764out4:
3765	usb_free_urb(dev->urb_intr);
3766out3:
3767	lan78xx_unbind(dev, intf);
3768out2:
3769	free_netdev(netdev);
3770out1:
3771	usb_put_dev(udev);
3772
3773	return ret;
3774}
3775
3776static u16 lan78xx_wakeframe_crc16(const u8 *buf, int len)
3777{
3778	const u16 crc16poly = 0x8005;
3779	int i;
3780	u16 bit, crc, msb;
3781	u8 data;
3782
3783	crc = 0xFFFF;
3784	for (i = 0; i < len; i++) {
3785		data = *buf++;
3786		for (bit = 0; bit < 8; bit++) {
3787			msb = crc >> 15;
3788			crc <<= 1;
3789
3790			if (msb ^ (u16)(data & 1)) {
3791				crc ^= crc16poly;
3792				crc |= (u16)0x0001U;
3793			}
3794			data >>= 1;
3795		}
3796	}
3797
3798	return crc;
3799}
3800
3801static int lan78xx_set_suspend(struct lan78xx_net *dev, u32 wol)
3802{
3803	u32 buf;
 
3804	int mask_index;
3805	u16 crc;
3806	u32 temp_wucsr;
3807	u32 temp_pmt_ctl;
3808	const u8 ipv4_multicast[3] = { 0x01, 0x00, 0x5E };
3809	const u8 ipv6_multicast[3] = { 0x33, 0x33 };
3810	const u8 arp_type[2] = { 0x08, 0x06 };
3811
3812	lan78xx_read_reg(dev, MAC_TX, &buf);
3813	buf &= ~MAC_TX_TXEN_;
3814	lan78xx_write_reg(dev, MAC_TX, buf);
3815	lan78xx_read_reg(dev, MAC_RX, &buf);
3816	buf &= ~MAC_RX_RXEN_;
3817	lan78xx_write_reg(dev, MAC_RX, buf);
3818
3819	lan78xx_write_reg(dev, WUCSR, 0);
3820	lan78xx_write_reg(dev, WUCSR2, 0);
3821	lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
3822
3823	temp_wucsr = 0;
3824
3825	temp_pmt_ctl = 0;
3826	lan78xx_read_reg(dev, PMT_CTL, &temp_pmt_ctl);
3827	temp_pmt_ctl &= ~PMT_CTL_RES_CLR_WKP_EN_;
3828	temp_pmt_ctl |= PMT_CTL_RES_CLR_WKP_STS_;
3829
3830	for (mask_index = 0; mask_index < NUM_OF_WUF_CFG; mask_index++)
3831		lan78xx_write_reg(dev, WUF_CFG(mask_index), 0);
3832
3833	mask_index = 0;
3834	if (wol & WAKE_PHY) {
3835		temp_pmt_ctl |= PMT_CTL_PHY_WAKE_EN_;
3836
3837		temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3838		temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3839		temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3840	}
3841	if (wol & WAKE_MAGIC) {
3842		temp_wucsr |= WUCSR_MPEN_;
3843
3844		temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3845		temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3846		temp_pmt_ctl |= PMT_CTL_SUS_MODE_3_;
3847	}
3848	if (wol & WAKE_BCAST) {
3849		temp_wucsr |= WUCSR_BCST_EN_;
3850
3851		temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3852		temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3853		temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3854	}
3855	if (wol & WAKE_MCAST) {
3856		temp_wucsr |= WUCSR_WAKE_EN_;
3857
3858		/* set WUF_CFG & WUF_MASK for IPv4 Multicast */
3859		crc = lan78xx_wakeframe_crc16(ipv4_multicast, 3);
3860		lan78xx_write_reg(dev, WUF_CFG(mask_index),
3861					WUF_CFGX_EN_ |
3862					WUF_CFGX_TYPE_MCAST_ |
3863					(0 << WUF_CFGX_OFFSET_SHIFT_) |
3864					(crc & WUF_CFGX_CRC16_MASK_));
3865
3866		lan78xx_write_reg(dev, WUF_MASK0(mask_index), 7);
3867		lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
3868		lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
3869		lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
3870		mask_index++;
3871
3872		/* for IPv6 Multicast */
3873		crc = lan78xx_wakeframe_crc16(ipv6_multicast, 2);
3874		lan78xx_write_reg(dev, WUF_CFG(mask_index),
3875					WUF_CFGX_EN_ |
3876					WUF_CFGX_TYPE_MCAST_ |
3877					(0 << WUF_CFGX_OFFSET_SHIFT_) |
3878					(crc & WUF_CFGX_CRC16_MASK_));
3879
3880		lan78xx_write_reg(dev, WUF_MASK0(mask_index), 3);
3881		lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
3882		lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
3883		lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
3884		mask_index++;
3885
3886		temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3887		temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3888		temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3889	}
3890	if (wol & WAKE_UCAST) {
3891		temp_wucsr |= WUCSR_PFDA_EN_;
3892
3893		temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3894		temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3895		temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3896	}
3897	if (wol & WAKE_ARP) {
3898		temp_wucsr |= WUCSR_WAKE_EN_;
3899
3900		/* set WUF_CFG & WUF_MASK
3901		 * for packettype (offset 12,13) = ARP (0x0806)
3902		 */
3903		crc = lan78xx_wakeframe_crc16(arp_type, 2);
3904		lan78xx_write_reg(dev, WUF_CFG(mask_index),
3905					WUF_CFGX_EN_ |
3906					WUF_CFGX_TYPE_ALL_ |
3907					(0 << WUF_CFGX_OFFSET_SHIFT_) |
3908					(crc & WUF_CFGX_CRC16_MASK_));
3909
3910		lan78xx_write_reg(dev, WUF_MASK0(mask_index), 0x3000);
3911		lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
3912		lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
3913		lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
3914		mask_index++;
3915
3916		temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3917		temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3918		temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3919	}
3920
3921	lan78xx_write_reg(dev, WUCSR, temp_wucsr);
3922
3923	/* when multiple WOL bits are set */
3924	if (hweight_long((unsigned long)wol) > 1) {
3925		temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3926		temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3927		temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3928	}
3929	lan78xx_write_reg(dev, PMT_CTL, temp_pmt_ctl);
3930
3931	/* clear WUPS */
3932	lan78xx_read_reg(dev, PMT_CTL, &buf);
3933	buf |= PMT_CTL_WUPS_MASK_;
3934	lan78xx_write_reg(dev, PMT_CTL, buf);
3935
3936	lan78xx_read_reg(dev, MAC_RX, &buf);
3937	buf |= MAC_RX_RXEN_;
3938	lan78xx_write_reg(dev, MAC_RX, buf);
3939
3940	return 0;
3941}
3942
3943static int lan78xx_suspend(struct usb_interface *intf, pm_message_t message)
3944{
3945	struct lan78xx_net *dev = usb_get_intfdata(intf);
3946	struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
3947	u32 buf;
3948	int ret;
 
 
 
3949
3950	if (!dev->suspend_count++) {
3951		spin_lock_irq(&dev->txq.lock);
3952		/* don't autosuspend while transmitting */
3953		if ((skb_queue_len(&dev->txq) ||
3954		     skb_queue_len(&dev->txq_pend)) &&
3955			PMSG_IS_AUTO(message)) {
3956			spin_unlock_irq(&dev->txq.lock);
3957			ret = -EBUSY;
3958			goto out;
3959		} else {
3960			set_bit(EVENT_DEV_ASLEEP, &dev->flags);
3961			spin_unlock_irq(&dev->txq.lock);
3962		}
3963
3964		/* stop TX & RX */
3965		ret = lan78xx_read_reg(dev, MAC_TX, &buf);
3966		buf &= ~MAC_TX_TXEN_;
3967		ret = lan78xx_write_reg(dev, MAC_TX, buf);
3968		ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3969		buf &= ~MAC_RX_RXEN_;
3970		ret = lan78xx_write_reg(dev, MAC_RX, buf);
3971
3972		/* empty out the rx and queues */
3973		netif_device_detach(dev->net);
3974		lan78xx_terminate_urbs(dev);
3975		usb_kill_urb(dev->urb_intr);
3976
3977		/* reattach */
3978		netif_device_attach(dev->net);
3979	}
3980
3981	if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3982		del_timer(&dev->stat_monitor);
3983
3984		if (PMSG_IS_AUTO(message)) {
3985			/* auto suspend (selective suspend) */
3986			ret = lan78xx_read_reg(dev, MAC_TX, &buf);
3987			buf &= ~MAC_TX_TXEN_;
3988			ret = lan78xx_write_reg(dev, MAC_TX, buf);
3989			ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3990			buf &= ~MAC_RX_RXEN_;
3991			ret = lan78xx_write_reg(dev, MAC_RX, buf);
3992
3993			ret = lan78xx_write_reg(dev, WUCSR, 0);
3994			ret = lan78xx_write_reg(dev, WUCSR2, 0);
3995			ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
3996
3997			/* set goodframe wakeup */
3998			ret = lan78xx_read_reg(dev, WUCSR, &buf);
3999
4000			buf |= WUCSR_RFE_WAKE_EN_;
4001			buf |= WUCSR_STORE_WAKE_;
4002
4003			ret = lan78xx_write_reg(dev, WUCSR, buf);
4004
4005			ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
4006
4007			buf &= ~PMT_CTL_RES_CLR_WKP_EN_;
4008			buf |= PMT_CTL_RES_CLR_WKP_STS_;
4009
4010			buf |= PMT_CTL_PHY_WAKE_EN_;
4011			buf |= PMT_CTL_WOL_EN_;
4012			buf &= ~PMT_CTL_SUS_MODE_MASK_;
4013			buf |= PMT_CTL_SUS_MODE_3_;
4014
4015			ret = lan78xx_write_reg(dev, PMT_CTL, buf);
4016
4017			ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
4018
4019			buf |= PMT_CTL_WUPS_MASK_;
4020
4021			ret = lan78xx_write_reg(dev, PMT_CTL, buf);
4022
4023			ret = lan78xx_read_reg(dev, MAC_RX, &buf);
4024			buf |= MAC_RX_RXEN_;
4025			ret = lan78xx_write_reg(dev, MAC_RX, buf);
4026		} else {
4027			lan78xx_set_suspend(dev, pdata->wol);
4028		}
4029	}
4030
4031	ret = 0;
4032out:
4033	return ret;
4034}
4035
4036static int lan78xx_resume(struct usb_interface *intf)
4037{
4038	struct lan78xx_net *dev = usb_get_intfdata(intf);
4039	struct sk_buff *skb;
4040	struct urb *res;
4041	int ret;
4042	u32 buf;
4043
4044	if (!timer_pending(&dev->stat_monitor)) {
4045		dev->delta = 1;
4046		mod_timer(&dev->stat_monitor,
4047			  jiffies + STAT_UPDATE_TIMER);
4048	}
4049
4050	if (!--dev->suspend_count) {
4051		/* resume interrupt URBs */
4052		if (dev->urb_intr && test_bit(EVENT_DEV_OPEN, &dev->flags))
4053				usb_submit_urb(dev->urb_intr, GFP_NOIO);
4054
4055		spin_lock_irq(&dev->txq.lock);
4056		while ((res = usb_get_from_anchor(&dev->deferred))) {
4057			skb = (struct sk_buff *)res->context;
4058			ret = usb_submit_urb(res, GFP_ATOMIC);
4059			if (ret < 0) {
4060				dev_kfree_skb_any(skb);
4061				usb_free_urb(res);
4062				usb_autopm_put_interface_async(dev->intf);
4063			} else {
4064				netif_trans_update(dev->net);
4065				lan78xx_queue_skb(&dev->txq, skb, tx_start);
4066			}
4067		}
4068
4069		clear_bit(EVENT_DEV_ASLEEP, &dev->flags);
4070		spin_unlock_irq(&dev->txq.lock);
4071
4072		if (test_bit(EVENT_DEV_OPEN, &dev->flags)) {
4073			if (!(skb_queue_len(&dev->txq) >= dev->tx_qlen))
4074				netif_start_queue(dev->net);
4075			tasklet_schedule(&dev->bh);
4076		}
4077	}
4078
4079	ret = lan78xx_write_reg(dev, WUCSR2, 0);
4080	ret = lan78xx_write_reg(dev, WUCSR, 0);
4081	ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
4082
4083	ret = lan78xx_write_reg(dev, WUCSR2, WUCSR2_NS_RCD_ |
4084					     WUCSR2_ARP_RCD_ |
4085					     WUCSR2_IPV6_TCPSYN_RCD_ |
4086					     WUCSR2_IPV4_TCPSYN_RCD_);
4087
4088	ret = lan78xx_write_reg(dev, WUCSR, WUCSR_EEE_TX_WAKE_ |
4089					    WUCSR_EEE_RX_WAKE_ |
4090					    WUCSR_PFDA_FR_ |
4091					    WUCSR_RFE_WAKE_FR_ |
4092					    WUCSR_WUFR_ |
4093					    WUCSR_MPR_ |
4094					    WUCSR_BCST_FR_);
4095
4096	ret = lan78xx_read_reg(dev, MAC_TX, &buf);
4097	buf |= MAC_TX_TXEN_;
4098	ret = lan78xx_write_reg(dev, MAC_TX, buf);
4099
4100	return 0;
4101}
4102
4103static int lan78xx_reset_resume(struct usb_interface *intf)
4104{
4105	struct lan78xx_net *dev = usb_get_intfdata(intf);
4106
4107	lan78xx_reset(dev);
4108
4109	phy_start(dev->net->phydev);
4110
4111	return lan78xx_resume(intf);
4112}
4113
4114static const struct usb_device_id products[] = {
4115	{
4116	/* LAN7800 USB Gigabit Ethernet Device */
4117	USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7800_USB_PRODUCT_ID),
4118	},
4119	{
4120	/* LAN7850 USB Gigabit Ethernet Device */
4121	USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7850_USB_PRODUCT_ID),
4122	},
4123	{
4124	/* LAN7801 USB Gigabit Ethernet Device */
4125	USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7801_USB_PRODUCT_ID),
4126	},
4127	{},
4128};
4129MODULE_DEVICE_TABLE(usb, products);
4130
4131static struct usb_driver lan78xx_driver = {
4132	.name			= DRIVER_NAME,
4133	.id_table		= products,
4134	.probe			= lan78xx_probe,
4135	.disconnect		= lan78xx_disconnect,
4136	.suspend		= lan78xx_suspend,
4137	.resume			= lan78xx_resume,
4138	.reset_resume		= lan78xx_reset_resume,
4139	.supports_autosuspend	= 1,
4140	.disable_hub_initiated_lpm = 1,
4141};
4142
4143module_usb_driver(lan78xx_driver);
4144
4145MODULE_AUTHOR(DRIVER_AUTHOR);
4146MODULE_DESCRIPTION(DRIVER_DESC);
4147MODULE_LICENSE("GPL");