smsc95xx.c 50.2 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
 /***************************************************************************
 *
 * Copyright (C) 2007-2008 SMSC
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 *****************************************************************************/

#include <linux/module.h>
#include <linux/kmod.h>
#include <linux/init.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/ethtool.h>
#include <linux/mii.h>
#include <linux/usb.h>
29 30
#include <linux/bitrev.h>
#include <linux/crc16.h>
31 32
#include <linux/crc32.h>
#include <linux/usb/usbnet.h>
33
#include <linux/slab.h>
34 35 36
#include "smsc95xx.h"

#define SMSC_CHIPNAME			"smsc95xx"
37
#define SMSC_DRIVER_VERSION		"1.0.4"
38 39 40 41 42 43 44 45
#define HS_USB_PKT_SIZE			(512)
#define FS_USB_PKT_SIZE			(64)
#define DEFAULT_HS_BURST_CAP_SIZE	(16 * 1024 + 5 * HS_USB_PKT_SIZE)
#define DEFAULT_FS_BURST_CAP_SIZE	(6 * 1024 + 33 * FS_USB_PKT_SIZE)
#define DEFAULT_BULK_IN_DELAY		(0x00002000)
#define MAX_SINGLE_PACKET_SIZE		(2048)
#define LAN95XX_EEPROM_MAGIC		(0x9500)
#define EEPROM_MAC_OFFSET		(0x01)
46
#define DEFAULT_TX_CSUM_ENABLE		(true)
47 48 49
#define DEFAULT_RX_CSUM_ENABLE		(true)
#define SMSC95XX_INTERNAL_PHY_ID	(1)
#define SMSC95XX_TX_OVERHEAD		(8)
50
#define SMSC95XX_TX_OVERHEAD_CSUM	(12)
51
#define SUPPORTED_WAKE			(WAKE_PHY | WAKE_UCAST | WAKE_BCAST | \
52
					 WAKE_MCAST | WAKE_ARP | WAKE_MAGIC)
53

54 55 56 57
#define FEATURE_8_WAKEUP_FILTERS	(0x01)
#define FEATURE_PHY_NLP_CROSSOVER	(0x02)
#define FEATURE_AUTOSUSPEND		(0x04)

58 59 60 61 62 63 64
#define SUSPEND_SUSPEND0		(0x01)
#define SUSPEND_SUSPEND1		(0x02)
#define SUSPEND_SUSPEND2		(0x04)
#define SUSPEND_SUSPEND3		(0x08)
#define SUSPEND_ALLMODES		(SUSPEND_SUSPEND0 | SUSPEND_SUSPEND1 | \
					 SUSPEND_SUSPEND2 | SUSPEND_SUSPEND3)

65 66
struct smsc95xx_priv {
	u32 mac_cr;
67 68
	u32 hash_hi;
	u32 hash_lo;
69
	u32 wolopts;
70
	spinlock_t mac_cr_lock;
71
	u8 features;
72
	u8 suspend_flags;
73 74
};

75
static bool turbo_mode = true;
76 77 78
module_param(turbo_mode, bool, 0644);
MODULE_PARM_DESC(turbo_mode, "Enable multiple frames per Rx transaction");

79 80
static int __must_check __smsc95xx_read_reg(struct usbnet *dev, u32 index,
					    u32 *data, int in_pm)
81
{
82
	u32 buf;
83
	int ret;
84
	int (*fn)(struct usbnet *, u8, u8, u16, u16, void *, u16);
85 86 87

	BUG_ON(!dev);

88 89 90 91 92 93 94 95
	if (!in_pm)
		fn = usbnet_read_cmd;
	else
		fn = usbnet_read_cmd_nopm;

	ret = fn(dev, USB_VENDOR_REQUEST_READ_REGISTER, USB_DIR_IN
		 | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
		 0, index, &buf, 4);
96
	if (unlikely(ret < 0))
J
Joe Perches 已提交
97 98
		netdev_warn(dev->net, "Failed to read reg index 0x%08x: %d\n",
			    index, ret);
99

100 101
	le32_to_cpus(&buf);
	*data = buf;
102 103 104 105

	return ret;
}

106 107
static int __must_check __smsc95xx_write_reg(struct usbnet *dev, u32 index,
					     u32 data, int in_pm)
108
{
109
	u32 buf;
110
	int ret;
111
	int (*fn)(struct usbnet *, u8, u8, u16, u16, const void *, u16);
112 113 114

	BUG_ON(!dev);

115 116 117 118 119
	if (!in_pm)
		fn = usbnet_write_cmd;
	else
		fn = usbnet_write_cmd_nopm;

120 121
	buf = data;
	cpu_to_le32s(&buf);
122

123 124 125
	ret = fn(dev, USB_VENDOR_REQUEST_WRITE_REGISTER, USB_DIR_OUT
		 | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
		 0, index, &buf, 4);
126
	if (unlikely(ret < 0))
J
Joe Perches 已提交
127 128
		netdev_warn(dev->net, "Failed to write reg index 0x%08x: %d\n",
			    index, ret);
129 130 131 132

	return ret;
}

133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155
static int __must_check smsc95xx_read_reg_nopm(struct usbnet *dev, u32 index,
					       u32 *data)
{
	return __smsc95xx_read_reg(dev, index, data, 1);
}

static int __must_check smsc95xx_write_reg_nopm(struct usbnet *dev, u32 index,
						u32 data)
{
	return __smsc95xx_write_reg(dev, index, data, 1);
}

static int __must_check smsc95xx_read_reg(struct usbnet *dev, u32 index,
					  u32 *data)
{
	return __smsc95xx_read_reg(dev, index, data, 0);
}

static int __must_check smsc95xx_write_reg(struct usbnet *dev, u32 index,
					   u32 data)
{
	return __smsc95xx_write_reg(dev, index, data, 0);
}
156

157 158
/* Loop until the read is completed with timeout
 * called with phy_mutex held */
159 160
static int __must_check __smsc95xx_phy_wait_not_busy(struct usbnet *dev,
						     int in_pm)
161 162 163
{
	unsigned long start_time = jiffies;
	u32 val;
164
	int ret;
165 166

	do {
167
		ret = __smsc95xx_read_reg(dev, MII_ADDR, &val, in_pm);
S
Steve Glendinning 已提交
168 169 170 171 172
		if (ret < 0) {
			netdev_warn(dev->net, "Error reading MII_ACCESS\n");
			return ret;
		}

173 174 175 176 177 178 179
		if (!(val & MII_BUSY_))
			return 0;
	} while (!time_after(jiffies, start_time + HZ));

	return -EIO;
}

180 181
static int __smsc95xx_mdio_read(struct net_device *netdev, int phy_id, int idx,
				int in_pm)
182 183 184
{
	struct usbnet *dev = netdev_priv(netdev);
	u32 val, addr;
185
	int ret;
186 187 188 189

	mutex_lock(&dev->phy_mutex);

	/* confirm MII not busy */
190
	ret = __smsc95xx_phy_wait_not_busy(dev, in_pm);
S
Steve Glendinning 已提交
191 192 193 194
	if (ret < 0) {
		netdev_warn(dev->net, "MII is busy in smsc95xx_mdio_read\n");
		goto done;
	}
195 196 197 198

	/* set the address, index & direction (read from PHY) */
	phy_id &= dev->mii.phy_id_mask;
	idx &= dev->mii.reg_num_mask;
199
	addr = (phy_id << 11) | (idx << 6) | MII_READ_ | MII_BUSY_;
200
	ret = __smsc95xx_write_reg(dev, MII_ADDR, addr, in_pm);
S
Steve Glendinning 已提交
201 202 203 204
	if (ret < 0) {
		netdev_warn(dev->net, "Error writing MII_ADDR\n");
		goto done;
	}
205

206
	ret = __smsc95xx_phy_wait_not_busy(dev, in_pm);
S
Steve Glendinning 已提交
207 208 209 210
	if (ret < 0) {
		netdev_warn(dev->net, "Timed out reading MII reg %02X\n", idx);
		goto done;
	}
211

212
	ret = __smsc95xx_read_reg(dev, MII_DATA, &val, in_pm);
S
Steve Glendinning 已提交
213 214 215 216
	if (ret < 0) {
		netdev_warn(dev->net, "Error reading MII_DATA\n");
		goto done;
	}
217

218
	ret = (u16)(val & 0xFFFF);
219

220 221 222
done:
	mutex_unlock(&dev->phy_mutex);
	return ret;
223 224
}

225 226
static void __smsc95xx_mdio_write(struct net_device *netdev, int phy_id,
				  int idx, int regval, int in_pm)
227 228 229
{
	struct usbnet *dev = netdev_priv(netdev);
	u32 val, addr;
230
	int ret;
231 232 233 234

	mutex_lock(&dev->phy_mutex);

	/* confirm MII not busy */
235
	ret = __smsc95xx_phy_wait_not_busy(dev, in_pm);
S
Steve Glendinning 已提交
236 237 238 239
	if (ret < 0) {
		netdev_warn(dev->net, "MII is busy in smsc95xx_mdio_write\n");
		goto done;
	}
240 241

	val = regval;
242
	ret = __smsc95xx_write_reg(dev, MII_DATA, val, in_pm);
S
Steve Glendinning 已提交
243 244 245 246
	if (ret < 0) {
		netdev_warn(dev->net, "Error writing MII_DATA\n");
		goto done;
	}
247 248 249 250

	/* set the address, index & direction (write to PHY) */
	phy_id &= dev->mii.phy_id_mask;
	idx &= dev->mii.reg_num_mask;
251
	addr = (phy_id << 11) | (idx << 6) | MII_WRITE_ | MII_BUSY_;
252
	ret = __smsc95xx_write_reg(dev, MII_ADDR, addr, in_pm);
S
Steve Glendinning 已提交
253 254 255 256
	if (ret < 0) {
		netdev_warn(dev->net, "Error writing MII_ADDR\n");
		goto done;
	}
257

258
	ret = __smsc95xx_phy_wait_not_busy(dev, in_pm);
S
Steve Glendinning 已提交
259 260 261 262
	if (ret < 0) {
		netdev_warn(dev->net, "Timed out writing MII reg %02X\n", idx);
		goto done;
	}
263

264
done:
265 266 267
	mutex_unlock(&dev->phy_mutex);
}

268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290
static int smsc95xx_mdio_read_nopm(struct net_device *netdev, int phy_id,
				   int idx)
{
	return __smsc95xx_mdio_read(netdev, phy_id, idx, 1);
}

static void smsc95xx_mdio_write_nopm(struct net_device *netdev, int phy_id,
				     int idx, int regval)
{
	__smsc95xx_mdio_write(netdev, phy_id, idx, regval, 1);
}

static int smsc95xx_mdio_read(struct net_device *netdev, int phy_id, int idx)
{
	return __smsc95xx_mdio_read(netdev, phy_id, idx, 0);
}

static void smsc95xx_mdio_write(struct net_device *netdev, int phy_id, int idx,
				int regval)
{
	__smsc95xx_mdio_write(netdev, phy_id, idx, regval, 0);
}

291
static int __must_check smsc95xx_wait_eeprom(struct usbnet *dev)
292 293 294
{
	unsigned long start_time = jiffies;
	u32 val;
295
	int ret;
296 297

	do {
298
		ret = smsc95xx_read_reg(dev, E2P_CMD, &val);
S
Steve Glendinning 已提交
299 300 301 302 303
		if (ret < 0) {
			netdev_warn(dev->net, "Error reading E2P_CMD\n");
			return ret;
		}

304 305 306 307 308 309
		if (!(val & E2P_CMD_BUSY_) || (val & E2P_CMD_TIMEOUT_))
			break;
		udelay(40);
	} while (!time_after(jiffies, start_time + HZ));

	if (val & (E2P_CMD_TIMEOUT_ | E2P_CMD_BUSY_)) {
310
		netdev_warn(dev->net, "EEPROM read operation timeout\n");
311 312 313 314 315 316
		return -EIO;
	}

	return 0;
}

317
static int __must_check smsc95xx_eeprom_confirm_not_busy(struct usbnet *dev)
318 319 320
{
	unsigned long start_time = jiffies;
	u32 val;
321
	int ret;
322 323

	do {
324
		ret = smsc95xx_read_reg(dev, E2P_CMD, &val);
S
Steve Glendinning 已提交
325 326 327 328
		if (ret < 0) {
			netdev_warn(dev->net, "Error reading E2P_CMD\n");
			return ret;
		}
329 330 331 332 333 334 335

		if (!(val & E2P_CMD_BUSY_))
			return 0;

		udelay(40);
	} while (!time_after(jiffies, start_time + HZ));

336
	netdev_warn(dev->net, "EEPROM is busy\n");
337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354
	return -EIO;
}

static int smsc95xx_read_eeprom(struct usbnet *dev, u32 offset, u32 length,
				u8 *data)
{
	u32 val;
	int i, ret;

	BUG_ON(!dev);
	BUG_ON(!data);

	ret = smsc95xx_eeprom_confirm_not_busy(dev);
	if (ret)
		return ret;

	for (i = 0; i < length; i++) {
		val = E2P_CMD_BUSY_ | E2P_CMD_READ_ | (offset & E2P_CMD_ADDR_);
355
		ret = smsc95xx_write_reg(dev, E2P_CMD, val);
S
Steve Glendinning 已提交
356 357 358 359
		if (ret < 0) {
			netdev_warn(dev->net, "Error writing E2P_CMD\n");
			return ret;
		}
360 361 362 363 364

		ret = smsc95xx_wait_eeprom(dev);
		if (ret < 0)
			return ret;

365
		ret = smsc95xx_read_reg(dev, E2P_DATA, &val);
S
Steve Glendinning 已提交
366 367 368 369
		if (ret < 0) {
			netdev_warn(dev->net, "Error reading E2P_DATA\n");
			return ret;
		}
370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392

		data[i] = val & 0xFF;
		offset++;
	}

	return 0;
}

static int smsc95xx_write_eeprom(struct usbnet *dev, u32 offset, u32 length,
				 u8 *data)
{
	u32 val;
	int i, ret;

	BUG_ON(!dev);
	BUG_ON(!data);

	ret = smsc95xx_eeprom_confirm_not_busy(dev);
	if (ret)
		return ret;

	/* Issue write/erase enable command */
	val = E2P_CMD_BUSY_ | E2P_CMD_EWEN_;
393
	ret = smsc95xx_write_reg(dev, E2P_CMD, val);
S
Steve Glendinning 已提交
394 395 396 397
	if (ret < 0) {
		netdev_warn(dev->net, "Error writing E2P_DATA\n");
		return ret;
	}
398 399 400 401 402 403 404 405 406

	ret = smsc95xx_wait_eeprom(dev);
	if (ret < 0)
		return ret;

	for (i = 0; i < length; i++) {

		/* Fill data register */
		val = data[i];
407
		ret = smsc95xx_write_reg(dev, E2P_DATA, val);
S
Steve Glendinning 已提交
408 409 410 411
		if (ret < 0) {
			netdev_warn(dev->net, "Error writing E2P_DATA\n");
			return ret;
		}
412 413 414

		/* Send "write" command */
		val = E2P_CMD_BUSY_ | E2P_CMD_WRITE_ | (offset & E2P_CMD_ADDR_);
415
		ret = smsc95xx_write_reg(dev, E2P_CMD, val);
S
Steve Glendinning 已提交
416 417 418 419
		if (ret < 0) {
			netdev_warn(dev->net, "Error writing E2P_CMD\n");
			return ret;
		}
420 421 422 423 424 425 426 427 428 429 430

		ret = smsc95xx_wait_eeprom(dev);
		if (ret < 0)
			return ret;

		offset++;
	}

	return 0;
}

431
static int __must_check smsc95xx_write_reg_async(struct usbnet *dev, u16 index,
432
						 u32 data)
433
{
434
	const u16 size = 4;
435
	u32 buf;
436
	int ret;
437

438 439 440
	buf = data;
	cpu_to_le32s(&buf);

441 442 443
	ret = usbnet_write_cmd_async(dev, USB_VENDOR_REQUEST_WRITE_REGISTER,
				     USB_DIR_OUT | USB_TYPE_VENDOR |
				     USB_RECIP_DEVICE,
444
				     0, index, &buf, size);
445 446 447 448
	if (ret < 0)
		netdev_warn(dev->net, "Error write async cmd, sts=%d\n",
			    ret);
	return ret;
449 450 451 452 453 454 455 456 457 458 459 460 461 462 463
}

/* returns hash bit number for given MAC address
 * example:
 * 01 00 5E 00 00 01 -> returns bit number 31 */
static unsigned int smsc95xx_hash(char addr[ETH_ALEN])
{
	return (ether_crc(ETH_ALEN, addr) >> 26) & 0x3f;
}

static void smsc95xx_set_multicast(struct net_device *netdev)
{
	struct usbnet *dev = netdev_priv(netdev);
	struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
	unsigned long flags;
464
	int ret;
465

466 467 468
	pdata->hash_hi = 0;
	pdata->hash_lo = 0;

469 470 471
	spin_lock_irqsave(&pdata->mac_cr_lock, flags);

	if (dev->net->flags & IFF_PROMISC) {
472
		netif_dbg(dev, drv, dev->net, "promiscuous mode enabled\n");
473 474 475
		pdata->mac_cr |= MAC_CR_PRMS_;
		pdata->mac_cr &= ~(MAC_CR_MCPAS_ | MAC_CR_HPFILT_);
	} else if (dev->net->flags & IFF_ALLMULTI) {
476
		netif_dbg(dev, drv, dev->net, "receive all multicast enabled\n");
477 478
		pdata->mac_cr |= MAC_CR_MCPAS_;
		pdata->mac_cr &= ~(MAC_CR_PRMS_ | MAC_CR_HPFILT_);
479
	} else if (!netdev_mc_empty(dev->net)) {
480
		struct netdev_hw_addr *ha;
481 482 483 484

		pdata->mac_cr |= MAC_CR_HPFILT_;
		pdata->mac_cr &= ~(MAC_CR_PRMS_ | MAC_CR_MCPAS_);

485 486
		netdev_for_each_mc_addr(ha, netdev) {
			u32 bitnum = smsc95xx_hash(ha->addr);
487 488
			u32 mask = 0x01 << (bitnum & 0x1F);
			if (bitnum & 0x20)
489
				pdata->hash_hi |= mask;
490
			else
491
				pdata->hash_lo |= mask;
492 493
		}

494
		netif_dbg(dev, drv, dev->net, "HASHH=0x%08X, HASHL=0x%08X\n",
495
				   pdata->hash_hi, pdata->hash_lo);
496
	} else {
497
		netif_dbg(dev, drv, dev->net, "receive own packets only\n");
498 499 500 501 502 503 504
		pdata->mac_cr &=
			~(MAC_CR_PRMS_ | MAC_CR_MCPAS_ | MAC_CR_HPFILT_);
	}

	spin_unlock_irqrestore(&pdata->mac_cr_lock, flags);

	/* Initiate async writes, as we can't wait for completion here */
505
	ret = smsc95xx_write_reg_async(dev, HASHH, pdata->hash_hi);
S
Steve Glendinning 已提交
506 507
	if (ret < 0)
		netdev_warn(dev->net, "failed to initiate async write to HASHH\n");
508

509
	ret = smsc95xx_write_reg_async(dev, HASHL, pdata->hash_lo);
S
Steve Glendinning 已提交
510 511
	if (ret < 0)
		netdev_warn(dev->net, "failed to initiate async write to HASHL\n");
512

513
	ret = smsc95xx_write_reg_async(dev, MAC_CR, pdata->mac_cr);
S
Steve Glendinning 已提交
514 515
	if (ret < 0)
		netdev_warn(dev->net, "failed to initiate async write to MAC_CR\n");
516 517
}

518 519
static int smsc95xx_phy_update_flowcontrol(struct usbnet *dev, u8 duplex,
					   u16 lcladv, u16 rmtadv)
520 521 522 523
{
	u32 flow, afc_cfg = 0;

	int ret = smsc95xx_read_reg(dev, AFC_CFG, &afc_cfg);
524
	if (ret < 0)
S
Steve Glendinning 已提交
525
		return ret;
526 527

	if (duplex == DUPLEX_FULL) {
528
		u8 cap = mii_resolve_flowctrl_fdx(lcladv, rmtadv);
529 530 531 532 533 534 535 536 537 538 539

		if (cap & FLOW_CTRL_RX)
			flow = 0xFFFF0002;
		else
			flow = 0;

		if (cap & FLOW_CTRL_TX)
			afc_cfg |= 0xF;
		else
			afc_cfg &= ~0xF;

540
		netif_dbg(dev, link, dev->net, "rx pause %s, tx pause %s\n",
541 542
				   cap & FLOW_CTRL_RX ? "enabled" : "disabled",
				   cap & FLOW_CTRL_TX ? "enabled" : "disabled");
543
	} else {
544
		netif_dbg(dev, link, dev->net, "half duplex\n");
545 546 547 548
		flow = 0;
		afc_cfg |= 0xF;
	}

549
	ret = smsc95xx_write_reg(dev, FLOW, flow);
S
Steve Glendinning 已提交
550
	if (ret < 0)
551
		return ret;
552

553
	return smsc95xx_write_reg(dev, AFC_CFG, afc_cfg);
554 555 556 557 558 559
}

static int smsc95xx_link_reset(struct usbnet *dev)
{
	struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
	struct mii_if_info *mii = &dev->mii;
560
	struct ethtool_cmd ecmd = { .cmd = ETHTOOL_GSET };
561 562
	unsigned long flags;
	u16 lcladv, rmtadv;
563
	int ret;
564 565

	/* clear interrupt status */
566
	ret = smsc95xx_mdio_read(dev->net, mii->phy_id, PHY_INT_SRC);
567
	if (ret < 0)
S
Steve Glendinning 已提交
568
		return ret;
569 570

	ret = smsc95xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL_);
571
	if (ret < 0)
S
Steve Glendinning 已提交
572
		return ret;
573 574 575 576 577 578

	mii_check_media(mii, 1, 1);
	mii_ethtool_gset(&dev->mii, &ecmd);
	lcladv = smsc95xx_mdio_read(dev->net, mii->phy_id, MII_ADVERTISE);
	rmtadv = smsc95xx_mdio_read(dev->net, mii->phy_id, MII_LPA);

579 580 581
	netif_dbg(dev, link, dev->net,
		  "speed: %u duplex: %d lcladv: %04x rmtadv: %04x\n",
		  ethtool_cmd_speed(&ecmd), ecmd.duplex, lcladv, rmtadv);
582 583 584 585 586 587 588 589 590 591 592

	spin_lock_irqsave(&pdata->mac_cr_lock, flags);
	if (ecmd.duplex != DUPLEX_FULL) {
		pdata->mac_cr &= ~MAC_CR_FDPX_;
		pdata->mac_cr |= MAC_CR_RCVOWN_;
	} else {
		pdata->mac_cr &= ~MAC_CR_RCVOWN_;
		pdata->mac_cr |= MAC_CR_FDPX_;
	}
	spin_unlock_irqrestore(&pdata->mac_cr_lock, flags);

593
	ret = smsc95xx_write_reg(dev, MAC_CR, pdata->mac_cr);
594
	if (ret < 0)
S
Steve Glendinning 已提交
595
		return ret;
596

597
	ret = smsc95xx_phy_update_flowcontrol(dev, ecmd.duplex, lcladv, rmtadv);
S
Steve Glendinning 已提交
598 599
	if (ret < 0)
		netdev_warn(dev->net, "Error updating PHY flow control\n");
600

S
Steve Glendinning 已提交
601
	return ret;
602 603 604 605 606 607 608
}

static void smsc95xx_status(struct usbnet *dev, struct urb *urb)
{
	u32 intdata;

	if (urb->actual_length != 4) {
609 610
		netdev_warn(dev->net, "unexpected urb length %d\n",
			    urb->actual_length);
611 612 613 614
		return;
	}

	memcpy(&intdata, urb->transfer_buffer, 4);
615
	le32_to_cpus(&intdata);
616

617
	netif_dbg(dev, link, dev->net, "intdata: 0x%08X\n", intdata);
618 619 620 621

	if (intdata & INT_ENP_PHY_INT_)
		usbnet_defer_kevent(dev, EVENT_LINK_RESET);
	else
622 623
		netdev_warn(dev->net, "unexpected interrupt, intdata=0x%08X\n",
			    intdata);
624 625
}

626
/* Enable or disable Tx & Rx checksum offload engines */
627 628
static int smsc95xx_set_features(struct net_device *netdev,
	netdev_features_t features)
629
{
630
	struct usbnet *dev = netdev_priv(netdev);
631
	u32 read_buf;
632 633 634
	int ret;

	ret = smsc95xx_read_reg(dev, COE_CR, &read_buf);
635
	if (ret < 0)
S
Steve Glendinning 已提交
636
		return ret;
637

638
	if (features & NETIF_F_HW_CSUM)
639 640 641 642
		read_buf |= Tx_COE_EN_;
	else
		read_buf &= ~Tx_COE_EN_;

643
	if (features & NETIF_F_RXCSUM)
644 645 646 647 648
		read_buf |= Rx_COE_EN_;
	else
		read_buf &= ~Rx_COE_EN_;

	ret = smsc95xx_write_reg(dev, COE_CR, read_buf);
649
	if (ret < 0)
S
Steve Glendinning 已提交
650
		return ret;
651

652
	netif_dbg(dev, hw, dev->net, "COE_CR = 0x%08x\n", read_buf);
653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676
	return 0;
}

static int smsc95xx_ethtool_get_eeprom_len(struct net_device *net)
{
	return MAX_EEPROM_SIZE;
}

static int smsc95xx_ethtool_get_eeprom(struct net_device *netdev,
				       struct ethtool_eeprom *ee, u8 *data)
{
	struct usbnet *dev = netdev_priv(netdev);

	ee->magic = LAN95XX_EEPROM_MAGIC;

	return smsc95xx_read_eeprom(dev, ee->offset, ee->len, data);
}

static int smsc95xx_ethtool_set_eeprom(struct net_device *netdev,
				       struct ethtool_eeprom *ee, u8 *data)
{
	struct usbnet *dev = netdev_priv(netdev);

	if (ee->magic != LAN95XX_EEPROM_MAGIC) {
677 678
		netdev_warn(dev->net, "EEPROM: magic value mismatch, magic = 0x%x\n",
			    ee->magic);
679 680 681 682 683 684
		return -EINVAL;
	}

	return smsc95xx_write_eeprom(dev, ee->offset, ee->len, data);
}

685 686 687
static int smsc95xx_ethtool_getregslen(struct net_device *netdev)
{
	/* all smsc95xx registers */
688
	return COE_CR - ID_REV + sizeof(u32);
689 690 691 692 693 694 695
}

static void
smsc95xx_ethtool_getregs(struct net_device *netdev, struct ethtool_regs *regs,
			 void *buf)
{
	struct usbnet *dev = netdev_priv(netdev);
696 697
	unsigned int i, j;
	int retval;
698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714
	u32 *data = buf;

	retval = smsc95xx_read_reg(dev, ID_REV, &regs->version);
	if (retval < 0) {
		netdev_warn(netdev, "REGS: cannot read ID_REV\n");
		return;
	}

	for (i = ID_REV, j = 0; i <= COE_CR; i += (sizeof(u32)), j++) {
		retval = smsc95xx_read_reg(dev, i, &data[j]);
		if (retval < 0) {
			netdev_warn(netdev, "REGS: cannot read reg[%x]\n", i);
			return;
		}
	}
}

715 716 717 718 719 720 721 722 723 724 725 726 727 728 729
static void smsc95xx_ethtool_get_wol(struct net_device *net,
				     struct ethtool_wolinfo *wolinfo)
{
	struct usbnet *dev = netdev_priv(net);
	struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);

	wolinfo->supported = SUPPORTED_WAKE;
	wolinfo->wolopts = pdata->wolopts;
}

static int smsc95xx_ethtool_set_wol(struct net_device *net,
				    struct ethtool_wolinfo *wolinfo)
{
	struct usbnet *dev = netdev_priv(net);
	struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
730
	int ret;
731 732

	pdata->wolopts = wolinfo->wolopts & SUPPORTED_WAKE;
733 734

	ret = device_set_wakeup_enable(&dev->udev->dev, pdata->wolopts);
S
Steve Glendinning 已提交
735 736
	if (ret < 0)
		netdev_warn(dev->net, "device_set_wakeup_enable error %d\n", ret);
737

S
Steve Glendinning 已提交
738
	return ret;
739 740
}

741
static const struct ethtool_ops smsc95xx_ethtool_ops = {
742 743 744 745 746 747 748 749 750 751
	.get_link	= usbnet_get_link,
	.nway_reset	= usbnet_nway_reset,
	.get_drvinfo	= usbnet_get_drvinfo,
	.get_msglevel	= usbnet_get_msglevel,
	.set_msglevel	= usbnet_set_msglevel,
	.get_settings	= usbnet_get_settings,
	.set_settings	= usbnet_set_settings,
	.get_eeprom_len	= smsc95xx_ethtool_get_eeprom_len,
	.get_eeprom	= smsc95xx_ethtool_get_eeprom,
	.set_eeprom	= smsc95xx_ethtool_set_eeprom,
752 753
	.get_regs_len	= smsc95xx_ethtool_getregslen,
	.get_regs	= smsc95xx_ethtool_getregs,
754 755
	.get_wol	= smsc95xx_ethtool_get_wol,
	.set_wol	= smsc95xx_ethtool_set_wol,
756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774
};

static int smsc95xx_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd)
{
	struct usbnet *dev = netdev_priv(netdev);

	if (!netif_running(netdev))
		return -EINVAL;

	return generic_mii_ioctl(&dev->mii, if_mii(rq), cmd, NULL);
}

static void smsc95xx_init_mac_address(struct usbnet *dev)
{
	/* try reading mac address from EEPROM */
	if (smsc95xx_read_eeprom(dev, EEPROM_MAC_OFFSET, ETH_ALEN,
			dev->net->dev_addr) == 0) {
		if (is_valid_ether_addr(dev->net->dev_addr)) {
			/* eeprom values are valid so use them */
775
			netif_dbg(dev, ifup, dev->net, "MAC address read from EEPROM\n");
776 777 778 779 780
			return;
		}
	}

	/* no eeprom, or eeprom values are invalid. generate random MAC */
781
	eth_hw_addr_random(dev->net);
J
Joe Perches 已提交
782
	netif_dbg(dev, ifup, dev->net, "MAC address set to eth_random_addr\n");
783 784 785 786 787 788 789 790 791 792
}

static int smsc95xx_set_mac_address(struct usbnet *dev)
{
	u32 addr_lo = dev->net->dev_addr[0] | dev->net->dev_addr[1] << 8 |
		dev->net->dev_addr[2] << 16 | dev->net->dev_addr[3] << 24;
	u32 addr_hi = dev->net->dev_addr[4] | dev->net->dev_addr[5] << 8;
	int ret;

	ret = smsc95xx_write_reg(dev, ADDRL, addr_lo);
S
Steve Glendinning 已提交
793
	if (ret < 0)
794
		return ret;
795

796
	return smsc95xx_write_reg(dev, ADDRH, addr_hi);
797 798 799
}

/* starts the TX path */
800
static int smsc95xx_start_tx_path(struct usbnet *dev)
801 802 803
{
	struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
	unsigned long flags;
804
	int ret;
805 806 807 808 809 810

	/* Enable Tx at MAC */
	spin_lock_irqsave(&pdata->mac_cr_lock, flags);
	pdata->mac_cr |= MAC_CR_TXEN_;
	spin_unlock_irqrestore(&pdata->mac_cr_lock, flags);

811
	ret = smsc95xx_write_reg(dev, MAC_CR, pdata->mac_cr);
812
	if (ret < 0)
S
Steve Glendinning 已提交
813
		return ret;
814 815

	/* Enable Tx at SCSRs */
816
	return smsc95xx_write_reg(dev, TX_CFG, TX_CFG_ON_);
817 818 819
}

/* Starts the Receive path */
820
static int smsc95xx_start_rx_path(struct usbnet *dev, int in_pm)
821 822 823 824 825 826 827 828
{
	struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
	unsigned long flags;

	spin_lock_irqsave(&pdata->mac_cr_lock, flags);
	pdata->mac_cr |= MAC_CR_RXEN_;
	spin_unlock_irqrestore(&pdata->mac_cr_lock, flags);

829
	return __smsc95xx_write_reg(dev, MAC_CR, pdata->mac_cr, in_pm);
830 831 832 833
}

static int smsc95xx_phy_initialize(struct usbnet *dev)
{
834
	int bmcr, ret, timeout = 0;
835

836 837 838 839 840 841 842 843
	/* Initialize MII structure */
	dev->mii.dev = dev->net;
	dev->mii.mdio_read = smsc95xx_mdio_read;
	dev->mii.mdio_write = smsc95xx_mdio_write;
	dev->mii.phy_id_mask = 0x1f;
	dev->mii.reg_num_mask = 0x1f;
	dev->mii.phy_id = SMSC95XX_INTERNAL_PHY_ID;

844
	/* reset phy and wait for reset to complete */
845
	smsc95xx_mdio_write(dev->net, dev->mii.phy_id, MII_BMCR, BMCR_RESET);
846 847 848 849 850

	do {
		msleep(10);
		bmcr = smsc95xx_mdio_read(dev->net, dev->mii.phy_id, MII_BMCR);
		timeout++;
R
Rabin Vincent 已提交
851
	} while ((bmcr & BMCR_RESET) && (timeout < 100));
852 853 854 855 856 857

	if (timeout >= 100) {
		netdev_warn(dev->net, "timeout on PHY Reset");
		return -EIO;
	}

858 859 860 861 862
	smsc95xx_mdio_write(dev->net, dev->mii.phy_id, MII_ADVERTISE,
		ADVERTISE_ALL | ADVERTISE_CSMA | ADVERTISE_PAUSE_CAP |
		ADVERTISE_PAUSE_ASYM);

	/* read to clear */
863
	ret = smsc95xx_mdio_read(dev->net, dev->mii.phy_id, PHY_INT_SRC);
S
Steve Glendinning 已提交
864 865 866 867
	if (ret < 0) {
		netdev_warn(dev->net, "Failed to read PHY_INT_SRC during init\n");
		return ret;
	}
868 869 870 871 872

	smsc95xx_mdio_write(dev->net, dev->mii.phy_id, PHY_INT_MASK,
		PHY_INT_MASK_DEFAULT_);
	mii_nway_restart(&dev->mii);

873
	netif_dbg(dev, ifup, dev->net, "phy initialised successfully\n");
874 875 876 877 878 879 880 881 882
	return 0;
}

static int smsc95xx_reset(struct usbnet *dev)
{
	struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
	u32 read_buf, write_buf, burst_cap;
	int ret = 0, timeout;

883
	netif_dbg(dev, ifup, dev->net, "entering smsc95xx_reset\n");
884

885
	ret = smsc95xx_write_reg(dev, HW_CFG, HW_CFG_LRST_);
886
	if (ret < 0)
S
Steve Glendinning 已提交
887
		return ret;
888 889 890

	timeout = 0;
	do {
891
		msleep(10);
892
		ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf);
893
		if (ret < 0)
S
Steve Glendinning 已提交
894
			return ret;
895 896 897 898
		timeout++;
	} while ((read_buf & HW_CFG_LRST_) && (timeout < 100));

	if (timeout >= 100) {
899
		netdev_warn(dev->net, "timeout waiting for completion of Lite Reset\n");
900 901 902
		return ret;
	}

903
	ret = smsc95xx_write_reg(dev, PM_CTRL, PM_CTL_PHY_RST_);
904
	if (ret < 0)
S
Steve Glendinning 已提交
905
		return ret;
906 907 908

	timeout = 0;
	do {
909
		msleep(10);
910
		ret = smsc95xx_read_reg(dev, PM_CTRL, &read_buf);
911
		if (ret < 0)
S
Steve Glendinning 已提交
912
			return ret;
913 914 915 916
		timeout++;
	} while ((read_buf & PM_CTL_PHY_RST_) && (timeout < 100));

	if (timeout >= 100) {
917
		netdev_warn(dev->net, "timeout waiting for PHY Reset\n");
918 919 920 921 922 923 924
		return ret;
	}

	ret = smsc95xx_set_mac_address(dev);
	if (ret < 0)
		return ret;

J
Joe Perches 已提交
925 926
	netif_dbg(dev, ifup, dev->net, "MAC Address: %pM\n",
		  dev->net->dev_addr);
927 928

	ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf);
929
	if (ret < 0)
S
Steve Glendinning 已提交
930
		return ret;
931

J
Joe Perches 已提交
932 933
	netif_dbg(dev, ifup, dev->net, "Read Value from HW_CFG : 0x%08x\n",
		  read_buf);
934 935 936 937

	read_buf |= HW_CFG_BIR_;

	ret = smsc95xx_write_reg(dev, HW_CFG, read_buf);
938
	if (ret < 0)
S
Steve Glendinning 已提交
939
		return ret;
940 941

	ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf);
942
	if (ret < 0)
S
Steve Glendinning 已提交
943 944
		return ret;

945 946 947
	netif_dbg(dev, ifup, dev->net,
		  "Read Value from HW_CFG after writing HW_CFG_BIR_: 0x%08x\n",
		  read_buf);
948 949 950 951 952 953 954 955 956 957 958 959

	if (!turbo_mode) {
		burst_cap = 0;
		dev->rx_urb_size = MAX_SINGLE_PACKET_SIZE;
	} else if (dev->udev->speed == USB_SPEED_HIGH) {
		burst_cap = DEFAULT_HS_BURST_CAP_SIZE / HS_USB_PKT_SIZE;
		dev->rx_urb_size = DEFAULT_HS_BURST_CAP_SIZE;
	} else {
		burst_cap = DEFAULT_FS_BURST_CAP_SIZE / FS_USB_PKT_SIZE;
		dev->rx_urb_size = DEFAULT_FS_BURST_CAP_SIZE;
	}

J
Joe Perches 已提交
960 961
	netif_dbg(dev, ifup, dev->net, "rx_urb_size=%ld\n",
		  (ulong)dev->rx_urb_size);
962 963

	ret = smsc95xx_write_reg(dev, BURST_CAP, burst_cap);
964
	if (ret < 0)
S
Steve Glendinning 已提交
965
		return ret;
966 967

	ret = smsc95xx_read_reg(dev, BURST_CAP, &read_buf);
968
	if (ret < 0)
S
Steve Glendinning 已提交
969
		return ret;
970

971 972 973
	netif_dbg(dev, ifup, dev->net,
		  "Read Value from BURST_CAP after writing: 0x%08x\n",
		  read_buf);
974

975
	ret = smsc95xx_write_reg(dev, BULK_IN_DLY, DEFAULT_BULK_IN_DELAY);
976
	if (ret < 0)
S
Steve Glendinning 已提交
977
		return ret;
978 979

	ret = smsc95xx_read_reg(dev, BULK_IN_DLY, &read_buf);
980
	if (ret < 0)
S
Steve Glendinning 已提交
981
		return ret;
982

983 984 985
	netif_dbg(dev, ifup, dev->net,
		  "Read Value from BULK_IN_DLY after writing: 0x%08x\n",
		  read_buf);
986 987

	ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf);
988
	if (ret < 0)
S
Steve Glendinning 已提交
989
		return ret;
990

J
Joe Perches 已提交
991 992
	netif_dbg(dev, ifup, dev->net, "Read Value from HW_CFG: 0x%08x\n",
		  read_buf);
993 994 995 996 997 998 999 1000 1001 1002

	if (turbo_mode)
		read_buf |= (HW_CFG_MEF_ | HW_CFG_BCE_);

	read_buf &= ~HW_CFG_RXDOFF_;

	/* set Rx data offset=2, Make IP header aligns on word boundary. */
	read_buf |= NET_IP_ALIGN << 9;

	ret = smsc95xx_write_reg(dev, HW_CFG, read_buf);
1003
	if (ret < 0)
S
Steve Glendinning 已提交
1004
		return ret;
1005 1006

	ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf);
1007
	if (ret < 0)
S
Steve Glendinning 已提交
1008
		return ret;
1009

1010 1011
	netif_dbg(dev, ifup, dev->net,
		  "Read Value from HW_CFG after writing: 0x%08x\n", read_buf);
1012

1013
	ret = smsc95xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL_);
1014
	if (ret < 0)
S
Steve Glendinning 已提交
1015
		return ret;
1016 1017

	ret = smsc95xx_read_reg(dev, ID_REV, &read_buf);
1018
	if (ret < 0)
S
Steve Glendinning 已提交
1019
		return ret;
1020
	netif_dbg(dev, ifup, dev->net, "ID_REV = 0x%08x\n", read_buf);
1021

1022 1023 1024 1025
	/* Configure GPIO pins as LED outputs */
	write_buf = LED_GPIO_CFG_SPD_LED | LED_GPIO_CFG_LNK_LED |
		LED_GPIO_CFG_FDX_LED;
	ret = smsc95xx_write_reg(dev, LED_GPIO_CFG, write_buf);
1026
	if (ret < 0)
S
Steve Glendinning 已提交
1027
		return ret;
1028

1029
	/* Init Tx */
1030
	ret = smsc95xx_write_reg(dev, FLOW, 0);
1031
	if (ret < 0)
S
Steve Glendinning 已提交
1032
		return ret;
1033

1034
	ret = smsc95xx_write_reg(dev, AFC_CFG, AFC_CFG_DEFAULT);
1035
	if (ret < 0)
S
Steve Glendinning 已提交
1036
		return ret;
1037 1038 1039

	/* Don't need mac_cr_lock during initialisation */
	ret = smsc95xx_read_reg(dev, MAC_CR, &pdata->mac_cr);
1040
	if (ret < 0)
S
Steve Glendinning 已提交
1041
		return ret;
1042 1043 1044

	/* Init Rx */
	/* Set Vlan */
1045
	ret = smsc95xx_write_reg(dev, VLAN1, (u32)ETH_P_8021Q);
1046
	if (ret < 0)
S
Steve Glendinning 已提交
1047
		return ret;
1048

1049
	/* Enable or disable checksum offload engines */
1050
	ret = smsc95xx_set_features(dev->net, dev->net->features);
S
Steve Glendinning 已提交
1051 1052 1053 1054
	if (ret < 0) {
		netdev_warn(dev->net, "Failed to set checksum offload features\n");
		return ret;
	}
1055 1056 1057

	smsc95xx_set_multicast(dev->net);

1058
	ret = smsc95xx_phy_initialize(dev);
S
Steve Glendinning 已提交
1059 1060 1061 1062
	if (ret < 0) {
		netdev_warn(dev->net, "Failed to init PHY\n");
		return ret;
	}
1063 1064

	ret = smsc95xx_read_reg(dev, INT_EP_CTL, &read_buf);
1065
	if (ret < 0)
S
Steve Glendinning 已提交
1066
		return ret;
1067 1068 1069 1070 1071

	/* enable PHY interrupts */
	read_buf |= INT_EP_CTL_PHY_INT_;

	ret = smsc95xx_write_reg(dev, INT_EP_CTL, read_buf);
1072
	if (ret < 0)
S
Steve Glendinning 已提交
1073
		return ret;
1074

1075
	ret = smsc95xx_start_tx_path(dev);
S
Steve Glendinning 已提交
1076 1077 1078 1079
	if (ret < 0) {
		netdev_warn(dev->net, "Failed to start TX path\n");
		return ret;
	}
1080

1081
	ret = smsc95xx_start_rx_path(dev, 0);
S
Steve Glendinning 已提交
1082 1083 1084 1085
	if (ret < 0) {
		netdev_warn(dev->net, "Failed to start RX path\n");
		return ret;
	}
1086

1087
	netif_dbg(dev, ifup, dev->net, "smsc95xx_reset, return 0\n");
1088 1089 1090
	return 0;
}

1091 1092 1093 1094 1095 1096 1097 1098 1099
static const struct net_device_ops smsc95xx_netdev_ops = {
	.ndo_open		= usbnet_open,
	.ndo_stop		= usbnet_stop,
	.ndo_start_xmit		= usbnet_start_xmit,
	.ndo_tx_timeout		= usbnet_tx_timeout,
	.ndo_change_mtu		= usbnet_change_mtu,
	.ndo_set_mac_address 	= eth_mac_addr,
	.ndo_validate_addr	= eth_validate_addr,
	.ndo_do_ioctl 		= smsc95xx_ioctl,
1100
	.ndo_set_rx_mode	= smsc95xx_set_multicast,
1101
	.ndo_set_features	= smsc95xx_set_features,
1102 1103
};

1104 1105 1106
static int smsc95xx_bind(struct usbnet *dev, struct usb_interface *intf)
{
	struct smsc95xx_priv *pdata = NULL;
1107
	u32 val;
1108 1109 1110 1111 1112
	int ret;

	printk(KERN_INFO SMSC_CHIPNAME " v" SMSC_DRIVER_VERSION "\n");

	ret = usbnet_get_endpoints(dev, intf);
S
Steve Glendinning 已提交
1113 1114 1115 1116
	if (ret < 0) {
		netdev_warn(dev->net, "usbnet_get_endpoints failed: %d\n", ret);
		return ret;
	}
1117 1118

	dev->data[0] = (unsigned long)kzalloc(sizeof(struct smsc95xx_priv),
1119
					      GFP_KERNEL);
1120 1121

	pdata = (struct smsc95xx_priv *)(dev->data[0]);
1122
	if (!pdata)
1123 1124 1125 1126
		return -ENOMEM;

	spin_lock_init(&pdata->mac_cr_lock);

1127 1128 1129 1130 1131 1132
	if (DEFAULT_TX_CSUM_ENABLE)
		dev->net->features |= NETIF_F_HW_CSUM;
	if (DEFAULT_RX_CSUM_ENABLE)
		dev->net->features |= NETIF_F_RXCSUM;

	dev->net->hw_features = NETIF_F_HW_CSUM | NETIF_F_RXCSUM;
1133

1134 1135
	smsc95xx_init_mac_address(dev);

1136 1137 1138
	/* Init all registers */
	ret = smsc95xx_reset(dev);

1139 1140
	/* detect device revision as different features may be available */
	ret = smsc95xx_read_reg(dev, ID_REV, &val);
1141
	if (ret < 0)
S
Steve Glendinning 已提交
1142
		return ret;
1143
	val >>= 16;
1144 1145 1146 1147 1148 1149 1150 1151

	if ((val == ID_REV_CHIP_ID_9500A_) || (val == ID_REV_CHIP_ID_9530_) ||
	    (val == ID_REV_CHIP_ID_89530_) || (val == ID_REV_CHIP_ID_9730_))
		pdata->features = (FEATURE_8_WAKEUP_FILTERS |
			FEATURE_PHY_NLP_CROSSOVER |
			FEATURE_AUTOSUSPEND);
	else if (val == ID_REV_CHIP_ID_9512_)
		pdata->features = FEATURE_8_WAKEUP_FILTERS;
1152

1153
	dev->net->netdev_ops = &smsc95xx_netdev_ops;
1154 1155
	dev->net->ethtool_ops = &smsc95xx_ethtool_ops;
	dev->net->flags |= IFF_MULTICAST;
1156
	dev->net->hard_header_len += SMSC95XX_TX_OVERHEAD_CSUM;
S
Stephane Fillod 已提交
1157
	dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;
1158 1159 1160 1161 1162 1163 1164
	return 0;
}

static void smsc95xx_unbind(struct usbnet *dev, struct usb_interface *intf)
{
	struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
	if (pdata) {
1165
		netif_dbg(dev, ifdown, dev->net, "free pdata\n");
1166 1167 1168 1169 1170 1171
		kfree(pdata);
		pdata = NULL;
		dev->data[0] = 0;
	}
}

1172
static u32 smsc_crc(const u8 *buffer, size_t len, int filter)
1173
{
1174 1175
	u32 crc = bitrev16(crc16(0xFFFF, buffer, len));
	return crc << ((filter % 2) * 16);
1176 1177
}

1178 1179 1180 1181 1182
static int smsc95xx_enable_phy_wakeup_interrupts(struct usbnet *dev, u16 mask)
{
	struct mii_if_info *mii = &dev->mii;
	int ret;

J
Joe Perches 已提交
1183
	netdev_dbg(dev->net, "enabling PHY wakeup interrupts\n");
1184 1185 1186

	/* read to clear */
	ret = smsc95xx_mdio_read_nopm(dev->net, mii->phy_id, PHY_INT_SRC);
1187
	if (ret < 0)
S
Steve Glendinning 已提交
1188
		return ret;
1189 1190 1191

	/* enable interrupt source */
	ret = smsc95xx_mdio_read_nopm(dev->net, mii->phy_id, PHY_INT_MASK);
1192
	if (ret < 0)
S
Steve Glendinning 已提交
1193
		return ret;
1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208

	ret |= mask;

	smsc95xx_mdio_write_nopm(dev->net, mii->phy_id, PHY_INT_MASK, ret);

	return 0;
}

static int smsc95xx_link_ok_nopm(struct usbnet *dev)
{
	struct mii_if_info *mii = &dev->mii;
	int ret;

	/* first, a dummy read, needed to latch some MII phys */
	ret = smsc95xx_mdio_read_nopm(dev->net, mii->phy_id, MII_BMSR);
1209
	if (ret < 0)
S
Steve Glendinning 已提交
1210
		return ret;
1211 1212

	ret = smsc95xx_mdio_read_nopm(dev->net, mii->phy_id, MII_BMSR);
1213
	if (ret < 0)
S
Steve Glendinning 已提交
1214
		return ret;
1215 1216 1217 1218

	return !!(ret & BMSR_LSTATUS);
}

1219 1220 1221 1222 1223 1224 1225
static int smsc95xx_enter_suspend0(struct usbnet *dev)
{
	struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
	u32 val;
	int ret;

	ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1226
	if (ret < 0)
S
Steve Glendinning 已提交
1227
		return ret;
1228 1229 1230 1231 1232

	val &= (~(PM_CTL_SUS_MODE_ | PM_CTL_WUPS_ | PM_CTL_PHY_RST_));
	val |= PM_CTL_SUS_MODE_0;

	ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1233
	if (ret < 0)
S
Steve Glendinning 已提交
1234
		return ret;
1235 1236 1237 1238 1239 1240 1241 1242 1243 1244

	/* clear wol status */
	val &= ~PM_CTL_WUPS_;
	val |= PM_CTL_WUPS_WOL_;

	/* enable energy detection */
	if (pdata->wolopts & WAKE_PHY)
		val |= PM_CTL_WUPS_ED_;

	ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1245
	if (ret < 0)
S
Steve Glendinning 已提交
1246
		return ret;
1247 1248 1249

	/* read back PM_CTRL */
	ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
M
Ming Lei 已提交
1250 1251
	if (ret < 0)
		return ret;
1252

1253 1254
	pdata->suspend_flags |= SUSPEND_SUSPEND0;

M
Ming Lei 已提交
1255
	return 0;
1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273
}

static int smsc95xx_enter_suspend1(struct usbnet *dev)
{
	struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
	struct mii_if_info *mii = &dev->mii;
	u32 val;
	int ret;

	/* reconfigure link pulse detection timing for
	 * compatibility with non-standard link partners
	 */
	if (pdata->features & FEATURE_PHY_NLP_CROSSOVER)
		smsc95xx_mdio_write_nopm(dev->net, mii->phy_id,	PHY_EDPD_CONFIG,
			PHY_EDPD_CONFIG_DEFAULT);

	/* enable energy detect power-down mode */
	ret = smsc95xx_mdio_read_nopm(dev->net, mii->phy_id, PHY_MODE_CTRL_STS);
1274
	if (ret < 0)
S
Steve Glendinning 已提交
1275
		return ret;
1276 1277 1278 1279 1280 1281 1282

	ret |= MODE_CTRL_STS_EDPWRDOWN_;

	smsc95xx_mdio_write_nopm(dev->net, mii->phy_id, PHY_MODE_CTRL_STS, ret);

	/* enter SUSPEND1 mode */
	ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1283
	if (ret < 0)
S
Steve Glendinning 已提交
1284
		return ret;
1285 1286 1287 1288 1289

	val &= ~(PM_CTL_SUS_MODE_ | PM_CTL_WUPS_ | PM_CTL_PHY_RST_);
	val |= PM_CTL_SUS_MODE_1;

	ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1290
	if (ret < 0)
S
Steve Glendinning 已提交
1291
		return ret;
1292 1293 1294 1295 1296 1297

	/* clear wol status, enable energy detection */
	val &= ~PM_CTL_WUPS_;
	val |= (PM_CTL_WUPS_ED_ | PM_CTL_ED_EN_);

	ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
M
Ming Lei 已提交
1298 1299
	if (ret < 0)
		return ret;
1300

1301 1302
	pdata->suspend_flags |= SUSPEND_SUSPEND1;

M
Ming Lei 已提交
1303
	return 0;
1304 1305 1306 1307
}

static int smsc95xx_enter_suspend2(struct usbnet *dev)
{
1308
	struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
1309 1310 1311 1312
	u32 val;
	int ret;

	ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1313
	if (ret < 0)
S
Steve Glendinning 已提交
1314
		return ret;
1315 1316 1317 1318 1319

	val &= ~(PM_CTL_SUS_MODE_ | PM_CTL_WUPS_ | PM_CTL_PHY_RST_);
	val |= PM_CTL_SUS_MODE_2;

	ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
M
Ming Lei 已提交
1320 1321
	if (ret < 0)
		return ret;
1322

1323 1324
	pdata->suspend_flags |= SUSPEND_SUSPEND2;

M
Ming Lei 已提交
1325
	return 0;
1326 1327
}

1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413
static int smsc95xx_enter_suspend3(struct usbnet *dev)
{
	struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
	u32 val;
	int ret;

	ret = smsc95xx_read_reg_nopm(dev, RX_FIFO_INF, &val);
	if (ret < 0)
		return ret;

	if (val & 0xFFFF) {
		netdev_info(dev->net, "rx fifo not empty in autosuspend\n");
		return -EBUSY;
	}

	ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
	if (ret < 0)
		return ret;

	val &= ~(PM_CTL_SUS_MODE_ | PM_CTL_WUPS_ | PM_CTL_PHY_RST_);
	val |= PM_CTL_SUS_MODE_3 | PM_CTL_RES_CLR_WKP_STS;

	ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
	if (ret < 0)
		return ret;

	/* clear wol status */
	val &= ~PM_CTL_WUPS_;
	val |= PM_CTL_WUPS_WOL_;

	ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
	if (ret < 0)
		return ret;

	pdata->suspend_flags |= SUSPEND_SUSPEND3;

	return 0;
}

static int smsc95xx_autosuspend(struct usbnet *dev, u32 link_up)
{
	struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
	int ret;

	if (!netif_running(dev->net)) {
		/* interface is ifconfig down so fully power down hw */
		netdev_dbg(dev->net, "autosuspend entering SUSPEND2\n");
		return smsc95xx_enter_suspend2(dev);
	}

	if (!link_up) {
		/* link is down so enter EDPD mode, but only if device can
		 * reliably resume from it.  This check should be redundant
		 * as current FEATURE_AUTOSUSPEND parts also support
		 * FEATURE_PHY_NLP_CROSSOVER but it's included for clarity */
		if (!(pdata->features & FEATURE_PHY_NLP_CROSSOVER)) {
			netdev_warn(dev->net, "EDPD not supported\n");
			return -EBUSY;
		}

		netdev_dbg(dev->net, "autosuspend entering SUSPEND1\n");

		/* enable PHY wakeup events for if cable is attached */
		ret = smsc95xx_enable_phy_wakeup_interrupts(dev,
			PHY_INT_MASK_ANEG_COMP_);
		if (ret < 0) {
			netdev_warn(dev->net, "error enabling PHY wakeup ints\n");
			return ret;
		}

		netdev_info(dev->net, "entering SUSPEND1 mode\n");
		return smsc95xx_enter_suspend1(dev);
	}

	/* enable PHY wakeup events so we remote wakeup if cable is pulled */
	ret = smsc95xx_enable_phy_wakeup_interrupts(dev,
		PHY_INT_MASK_LINK_DOWN_);
	if (ret < 0) {
		netdev_warn(dev->net, "error enabling PHY wakeup ints\n");
		return ret;
	}

	netdev_dbg(dev->net, "autosuspend entering SUSPEND3\n");
	return smsc95xx_enter_suspend3(dev);
}

1414 1415 1416
static int smsc95xx_suspend(struct usb_interface *intf, pm_message_t message)
{
	struct usbnet *dev = usb_get_intfdata(intf);
1417
	struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
1418
	u32 val, link_up;
1419 1420
	int ret;

1421 1422 1423 1424 1425 1426 1427 1428 1429
	/* TODO: don't indicate this feature to usb framework if
	 * our current hardware doesn't have the capability
	 */
	if ((message.event == PM_EVENT_AUTO_SUSPEND) &&
	    (!(pdata->features & FEATURE_AUTOSUSPEND))) {
		netdev_warn(dev->net, "autosuspend not supported\n");
		return -EBUSY;
	}

1430
	ret = usbnet_suspend(intf, message);
S
Steve Glendinning 已提交
1431 1432 1433 1434
	if (ret < 0) {
		netdev_warn(dev->net, "usbnet_suspend error\n");
		return ret;
	}
1435

1436 1437 1438 1439 1440
	if (pdata->suspend_flags) {
		netdev_warn(dev->net, "error during last resume\n");
		pdata->suspend_flags = 0;
	}

1441 1442 1443
	/* determine if link is up using only _nopm functions */
	link_up = smsc95xx_link_ok_nopm(dev);

1444 1445 1446 1447 1448 1449
	if (message.event == PM_EVENT_AUTO_SUSPEND) {
		ret = smsc95xx_autosuspend(dev, link_up);
		goto done;
	}

	/* if we get this far we're not autosuspending */
1450 1451 1452 1453 1454
	/* if no wol options set, or if link is down and we're not waking on
	 * PHY activity, enter lowest power SUSPEND2 mode
	 */
	if (!(pdata->wolopts & SUPPORTED_WAKE) ||
		!(link_up || (pdata->wolopts & WAKE_PHY))) {
J
Joe Perches 已提交
1455
		netdev_info(dev->net, "entering SUSPEND2 mode\n");
1456 1457

		/* disable energy detect (link up) & wake up events */
1458
		ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
1459
		if (ret < 0)
S
Steve Glendinning 已提交
1460
			goto done;
1461 1462 1463

		val &= ~(WUCSR_MPEN_ | WUCSR_WAKE_EN_);

1464
		ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
1465
		if (ret < 0)
S
Steve Glendinning 已提交
1466
			goto done;
1467

1468
		ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1469
		if (ret < 0)
S
Steve Glendinning 已提交
1470
			goto done;
1471 1472 1473

		val &= ~(PM_CTL_ED_EN_ | PM_CTL_WOL_EN_);

1474
		ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1475
		if (ret < 0)
S
Steve Glendinning 已提交
1476
			goto done;
1477

1478 1479
		ret = smsc95xx_enter_suspend2(dev);
		goto done;
1480 1481
	}

1482 1483 1484
	if (pdata->wolopts & WAKE_PHY) {
		ret = smsc95xx_enable_phy_wakeup_interrupts(dev,
			(PHY_INT_MASK_ANEG_COMP_ | PHY_INT_MASK_LINK_DOWN_));
S
Steve Glendinning 已提交
1485 1486 1487 1488
		if (ret < 0) {
			netdev_warn(dev->net, "error enabling PHY wakeup ints\n");
			goto done;
		}
1489 1490 1491 1492 1493

		/* if link is down then configure EDPD and enter SUSPEND1,
		 * otherwise enter SUSPEND0 below
		 */
		if (!link_up) {
J
Joe Perches 已提交
1494
			netdev_info(dev->net, "entering SUSPEND1 mode\n");
1495 1496
			ret = smsc95xx_enter_suspend1(dev);
			goto done;
1497 1498 1499
		}
	}

1500
	if (pdata->wolopts & (WAKE_BCAST | WAKE_MCAST | WAKE_ARP | WAKE_UCAST)) {
1501
		u32 *filter_mask = kzalloc(sizeof(u32) * 32, GFP_KERNEL);
1502 1503 1504
		u32 command[2];
		u32 offset[2];
		u32 crc[4];
1505 1506 1507
		int wuff_filter_count =
			(pdata->features & FEATURE_8_WAKEUP_FILTERS) ?
			LAN9500A_WUFF_NUM : LAN9500_WUFF_NUM;
1508 1509
		int i, filter = 0;

1510 1511
		if (!filter_mask) {
			netdev_warn(dev->net, "Unable to allocate filter_mask\n");
1512 1513
			ret = -ENOMEM;
			goto done;
1514 1515
		}

1516 1517 1518 1519
		memset(command, 0, sizeof(command));
		memset(offset, 0, sizeof(offset));
		memset(crc, 0, sizeof(crc));

1520 1521
		if (pdata->wolopts & WAKE_BCAST) {
			const u8 bcast[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
J
Joe Perches 已提交
1522
			netdev_info(dev->net, "enabling broadcast detection\n");
1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534
			filter_mask[filter * 4] = 0x003F;
			filter_mask[filter * 4 + 1] = 0x00;
			filter_mask[filter * 4 + 2] = 0x00;
			filter_mask[filter * 4 + 3] = 0x00;
			command[filter/4] |= 0x05UL << ((filter % 4) * 8);
			offset[filter/4] |= 0x00 << ((filter % 4) * 8);
			crc[filter/2] |= smsc_crc(bcast, 6, filter);
			filter++;
		}

		if (pdata->wolopts & WAKE_MCAST) {
			const u8 mcast[] = {0x01, 0x00, 0x5E};
J
Joe Perches 已提交
1535
			netdev_info(dev->net, "enabling multicast detection\n");
1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547
			filter_mask[filter * 4] = 0x0007;
			filter_mask[filter * 4 + 1] = 0x00;
			filter_mask[filter * 4 + 2] = 0x00;
			filter_mask[filter * 4 + 3] = 0x00;
			command[filter/4] |= 0x09UL << ((filter % 4) * 8);
			offset[filter/4] |= 0x00  << ((filter % 4) * 8);
			crc[filter/2] |= smsc_crc(mcast, 3, filter);
			filter++;
		}

		if (pdata->wolopts & WAKE_ARP) {
			const u8 arp[] = {0x08, 0x06};
J
Joe Perches 已提交
1548
			netdev_info(dev->net, "enabling ARP detection\n");
1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559
			filter_mask[filter * 4] = 0x0003;
			filter_mask[filter * 4 + 1] = 0x00;
			filter_mask[filter * 4 + 2] = 0x00;
			filter_mask[filter * 4 + 3] = 0x00;
			command[filter/4] |= 0x05UL << ((filter % 4) * 8);
			offset[filter/4] |= 0x0C << ((filter % 4) * 8);
			crc[filter/2] |= smsc_crc(arp, 2, filter);
			filter++;
		}

		if (pdata->wolopts & WAKE_UCAST) {
J
Joe Perches 已提交
1560
			netdev_info(dev->net, "enabling unicast detection\n");
1561 1562 1563 1564 1565 1566 1567 1568 1569 1570
			filter_mask[filter * 4] = 0x003F;
			filter_mask[filter * 4 + 1] = 0x00;
			filter_mask[filter * 4 + 2] = 0x00;
			filter_mask[filter * 4 + 3] = 0x00;
			command[filter/4] |= 0x01UL << ((filter % 4) * 8);
			offset[filter/4] |= 0x00 << ((filter % 4) * 8);
			crc[filter/2] |= smsc_crc(dev->net->dev_addr, ETH_ALEN, filter);
			filter++;
		}

1571
		for (i = 0; i < (wuff_filter_count * 4); i++) {
1572
			ret = smsc95xx_write_reg_nopm(dev, WUFF, filter_mask[i]);
S
Steve Glendinning 已提交
1573
			if (ret < 0) {
1574
				kfree(filter_mask);
S
Steve Glendinning 已提交
1575 1576
				goto done;
			}
1577
		}
1578
		kfree(filter_mask);
1579

1580
		for (i = 0; i < (wuff_filter_count / 4); i++) {
1581
			ret = smsc95xx_write_reg_nopm(dev, WUFF, command[i]);
1582
			if (ret < 0)
S
Steve Glendinning 已提交
1583
				goto done;
1584 1585
		}

1586
		for (i = 0; i < (wuff_filter_count / 4); i++) {
1587
			ret = smsc95xx_write_reg_nopm(dev, WUFF, offset[i]);
1588
			if (ret < 0)
S
Steve Glendinning 已提交
1589
				goto done;
1590 1591
		}

1592
		for (i = 0; i < (wuff_filter_count / 2); i++) {
1593
			ret = smsc95xx_write_reg_nopm(dev, WUFF, crc[i]);
1594
			if (ret < 0)
S
Steve Glendinning 已提交
1595
				goto done;
1596 1597 1598
		}

		/* clear any pending pattern match packet status */
1599
		ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
1600
		if (ret < 0)
S
Steve Glendinning 已提交
1601
			goto done;
1602 1603 1604

		val |= WUCSR_WUFR_;

1605
		ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
1606
		if (ret < 0)
S
Steve Glendinning 已提交
1607
			goto done;
1608 1609
	}

1610 1611
	if (pdata->wolopts & WAKE_MAGIC) {
		/* clear any pending magic packet status */
1612
		ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
1613
		if (ret < 0)
S
Steve Glendinning 已提交
1614
			goto done;
1615 1616 1617

		val |= WUCSR_MPR_;

1618
		ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
1619
		if (ret < 0)
S
Steve Glendinning 已提交
1620
			goto done;
1621 1622
	}

1623
	/* enable/disable wakeup sources */
1624
	ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
1625
	if (ret < 0)
S
Steve Glendinning 已提交
1626
		goto done;
1627

1628
	if (pdata->wolopts & (WAKE_BCAST | WAKE_MCAST | WAKE_ARP | WAKE_UCAST)) {
J
Joe Perches 已提交
1629
		netdev_info(dev->net, "enabling pattern match wakeup\n");
1630 1631
		val |= WUCSR_WAKE_EN_;
	} else {
J
Joe Perches 已提交
1632
		netdev_info(dev->net, "disabling pattern match wakeup\n");
1633 1634 1635
		val &= ~WUCSR_WAKE_EN_;
	}

1636
	if (pdata->wolopts & WAKE_MAGIC) {
J
Joe Perches 已提交
1637
		netdev_info(dev->net, "enabling magic packet wakeup\n");
1638 1639
		val |= WUCSR_MPEN_;
	} else {
J
Joe Perches 已提交
1640
		netdev_info(dev->net, "disabling magic packet wakeup\n");
1641 1642 1643
		val &= ~WUCSR_MPEN_;
	}

1644
	ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
1645
	if (ret < 0)
S
Steve Glendinning 已提交
1646
		goto done;
1647 1648

	/* enable wol wakeup source */
1649
	ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1650
	if (ret < 0)
S
Steve Glendinning 已提交
1651
		goto done;
1652 1653 1654

	val |= PM_CTL_WOL_EN_;

1655 1656 1657 1658
	/* phy energy detect wakeup source */
	if (pdata->wolopts & WAKE_PHY)
		val |= PM_CTL_ED_EN_;

1659
	ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1660
	if (ret < 0)
S
Steve Glendinning 已提交
1661
		goto done;
1662

1663
	/* enable receiver to enable frame reception */
1664
	smsc95xx_start_rx_path(dev, 1);
1665 1666

	/* some wol options are enabled, so enter SUSPEND0 */
J
Joe Perches 已提交
1667
	netdev_info(dev->net, "entering SUSPEND0 mode\n");
1668 1669 1670 1671 1672 1673
	ret = smsc95xx_enter_suspend0(dev);

done:
	if (ret)
		usbnet_resume(intf);
	return ret;
1674 1675 1676 1677 1678 1679
}

static int smsc95xx_resume(struct usb_interface *intf)
{
	struct usbnet *dev = usb_get_intfdata(intf);
	struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
1680
	u8 suspend_flags = pdata->suspend_flags;
1681 1682 1683 1684 1685
	int ret;
	u32 val;

	BUG_ON(!dev);

1686 1687 1688 1689 1690 1691
	netdev_dbg(dev->net, "resume suspend_flags=0x%02x\n", suspend_flags);

	/* do this first to ensure it's cleared even in error case */
	pdata->suspend_flags = 0;

	if (suspend_flags & SUSPEND_ALLMODES) {
1692
		/* clear wake-up sources */
1693
		ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
1694
		if (ret < 0)
S
Steve Glendinning 已提交
1695
			return ret;
1696

1697
		val &= ~(WUCSR_WAKE_EN_ | WUCSR_MPEN_);
1698

1699
		ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
1700
		if (ret < 0)
S
Steve Glendinning 已提交
1701
			return ret;
1702 1703

		/* clear wake-up status */
1704
		ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1705
		if (ret < 0)
S
Steve Glendinning 已提交
1706
			return ret;
1707 1708 1709 1710

		val &= ~PM_CTL_WOL_EN_;
		val |= PM_CTL_WUPS_;

1711
		ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1712
		if (ret < 0)
S
Steve Glendinning 已提交
1713
			return ret;
1714 1715
	}

1716
	ret = usbnet_resume(intf);
S
Steve Glendinning 已提交
1717 1718
	if (ret < 0)
		netdev_warn(dev->net, "usbnet_resume error\n");
1719

S
Steve Glendinning 已提交
1720
	return ret;
1721 1722
}

1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747
static void smsc95xx_rx_csum_offload(struct sk_buff *skb)
{
	skb->csum = *(u16 *)(skb_tail_pointer(skb) - 2);
	skb->ip_summed = CHECKSUM_COMPLETE;
	skb_trim(skb, skb->len - 2);
}

static int smsc95xx_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
{
	while (skb->len > 0) {
		u32 header, align_count;
		struct sk_buff *ax_skb;
		unsigned char *packet;
		u16 size;

		memcpy(&header, skb->data, sizeof(header));
		le32_to_cpus(&header);
		skb_pull(skb, 4 + NET_IP_ALIGN);
		packet = skb->data;

		/* get the packet length */
		size = (u16)((header & RX_STS_FL_) >> 16);
		align_count = (4 - ((size + NET_IP_ALIGN) % 4)) % 4;

		if (unlikely(header & RX_STS_ES_)) {
1748 1749
			netif_dbg(dev, rx_err, dev->net,
				  "Error header=0x%08x\n", header);
1750 1751
			dev->net->stats.rx_errors++;
			dev->net->stats.rx_dropped++;
1752 1753

			if (header & RX_STS_CRC_) {
1754
				dev->net->stats.rx_crc_errors++;
1755 1756
			} else {
				if (header & (RX_STS_TL_ | RX_STS_RF_))
1757
					dev->net->stats.rx_frame_errors++;
1758 1759 1760

				if ((header & RX_STS_LE_) &&
					(!(header & RX_STS_FT_)))
1761
					dev->net->stats.rx_length_errors++;
1762 1763 1764 1765
			}
		} else {
			/* ETH_FRAME_LEN + 4(CRC) + 2(COE) + 4(Vlan) */
			if (unlikely(size > (ETH_FRAME_LEN + 12))) {
1766 1767
				netif_dbg(dev, rx_err, dev->net,
					  "size err header=0x%08x\n", header);
1768 1769 1770 1771 1772
				return 0;
			}

			/* last frame in this batch */
			if (skb->len == size) {
1773
				if (dev->net->features & NETIF_F_RXCSUM)
1774
					smsc95xx_rx_csum_offload(skb);
1775
				skb_trim(skb, skb->len - 4); /* remove fcs */
1776 1777 1778 1779 1780 1781 1782
				skb->truesize = size + sizeof(struct sk_buff);

				return 1;
			}

			ax_skb = skb_clone(skb, GFP_ATOMIC);
			if (unlikely(!ax_skb)) {
1783
				netdev_warn(dev->net, "Error allocating skb\n");
1784 1785 1786 1787 1788 1789 1790
				return 0;
			}

			ax_skb->len = size;
			ax_skb->data = packet;
			skb_set_tail_pointer(ax_skb, size);

1791
			if (dev->net->features & NETIF_F_RXCSUM)
1792
				smsc95xx_rx_csum_offload(ax_skb);
1793
			skb_trim(ax_skb, ax_skb->len - 4); /* remove fcs */
1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806
			ax_skb->truesize = size + sizeof(struct sk_buff);

			usbnet_skb_return(dev, ax_skb);
		}

		skb_pull(skb, size);

		/* padding bytes before the next frame starts */
		if (skb->len)
			skb_pull(skb, align_count);
	}

	if (unlikely(skb->len < 0)) {
1807
		netdev_warn(dev->net, "invalid rx length<0 %d\n", skb->len);
1808 1809 1810 1811 1812 1813
		return 0;
	}

	return 1;
}

1814 1815
static u32 smsc95xx_calc_csum_preamble(struct sk_buff *skb)
{
1816 1817
	u16 low_16 = (u16)skb_checksum_start_offset(skb);
	u16 high_16 = low_16 + skb->csum_offset;
1818 1819 1820
	return (high_16 << 16) | low_16;
}

1821 1822 1823
static struct sk_buff *smsc95xx_tx_fixup(struct usbnet *dev,
					 struct sk_buff *skb, gfp_t flags)
{
1824
	bool csum = skb->ip_summed == CHECKSUM_PARTIAL;
1825
	int overhead = csum ? SMSC95XX_TX_OVERHEAD_CSUM : SMSC95XX_TX_OVERHEAD;
1826 1827
	u32 tx_cmd_a, tx_cmd_b;

1828 1829 1830 1831
	/* We do not advertise SG, so skbs should be already linearized */
	BUG_ON(skb_shinfo(skb)->nr_frags);

	if (skb_headroom(skb) < overhead) {
1832
		struct sk_buff *skb2 = skb_copy_expand(skb,
1833
			overhead, 0, flags);
1834 1835 1836 1837 1838 1839
		dev_kfree_skb_any(skb);
		skb = skb2;
		if (!skb)
			return NULL;
	}

1840
	if (csum) {
1841 1842 1843
		if (skb->len <= 45) {
			/* workaround - hardware tx checksum does not work
			 * properly with extremely small packets */
1844
			long csstart = skb_checksum_start_offset(skb);
1845 1846 1847 1848 1849 1850 1851 1852 1853
			__wsum calc = csum_partial(skb->data + csstart,
				skb->len - csstart, 0);
			*((__sum16 *)(skb->data + csstart
				+ skb->csum_offset)) = csum_fold(calc);

			csum = false;
		} else {
			u32 csum_preamble = smsc95xx_calc_csum_preamble(skb);
			skb_push(skb, 4);
1854
			cpu_to_le32s(&csum_preamble);
1855 1856
			memcpy(skb->data, &csum_preamble, 4);
		}
1857 1858
	}

1859 1860
	skb_push(skb, 4);
	tx_cmd_b = (u32)(skb->len - 4);
1861 1862
	if (csum)
		tx_cmd_b |= TX_CMD_B_CSUM_ENABLE;
1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874
	cpu_to_le32s(&tx_cmd_b);
	memcpy(skb->data, &tx_cmd_b, 4);

	skb_push(skb, 4);
	tx_cmd_a = (u32)(skb->len - 8) | TX_CMD_A_FIRST_SEG_ |
		TX_CMD_A_LAST_SEG_;
	cpu_to_le32s(&tx_cmd_a);
	memcpy(skb->data, &tx_cmd_a, 4);

	return skb;
}

1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894
static int smsc95xx_manage_power(struct usbnet *dev, int on)
{
	struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);

	dev->intf->needs_remote_wakeup = on;

	if (pdata->features & FEATURE_AUTOSUSPEND)
		return 0;

	/* this chip revision doesn't support autosuspend */
	netdev_info(dev->net, "hardware doesn't support USB autosuspend\n");

	if (on)
		usb_autopm_get_interface_no_resume(dev->intf);
	else
		usb_autopm_put_interface(dev->intf);

	return 0;
}

1895 1896 1897 1898 1899 1900 1901 1902 1903
static const struct driver_info smsc95xx_info = {
	.description	= "smsc95xx USB 2.0 Ethernet",
	.bind		= smsc95xx_bind,
	.unbind		= smsc95xx_unbind,
	.link_reset	= smsc95xx_link_reset,
	.reset		= smsc95xx_reset,
	.rx_fixup	= smsc95xx_rx_fixup,
	.tx_fixup	= smsc95xx_tx_fixup,
	.status		= smsc95xx_status,
1904
	.manage_power	= smsc95xx_manage_power,
1905
	.flags		= FLAG_ETHER | FLAG_SEND_ZLP | FLAG_LINK_INTR,
1906 1907 1908 1909 1910 1911 1912 1913
};

static const struct usb_device_id products[] = {
	{
		/* SMSC9500 USB Ethernet Device */
		USB_DEVICE(0x0424, 0x9500),
		.driver_info = (unsigned long) &smsc95xx_info,
	},
1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928
	{
		/* SMSC9505 USB Ethernet Device */
		USB_DEVICE(0x0424, 0x9505),
		.driver_info = (unsigned long) &smsc95xx_info,
	},
	{
		/* SMSC9500A USB Ethernet Device */
		USB_DEVICE(0x0424, 0x9E00),
		.driver_info = (unsigned long) &smsc95xx_info,
	},
	{
		/* SMSC9505A USB Ethernet Device */
		USB_DEVICE(0x0424, 0x9E01),
		.driver_info = (unsigned long) &smsc95xx_info,
	},
1929 1930 1931 1932 1933
	{
		/* SMSC9512/9514 USB Hub & Ethernet Device */
		USB_DEVICE(0x0424, 0xec00),
		.driver_info = (unsigned long) &smsc95xx_info,
	},
1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983
	{
		/* SMSC9500 USB Ethernet Device (SAL10) */
		USB_DEVICE(0x0424, 0x9900),
		.driver_info = (unsigned long) &smsc95xx_info,
	},
	{
		/* SMSC9505 USB Ethernet Device (SAL10) */
		USB_DEVICE(0x0424, 0x9901),
		.driver_info = (unsigned long) &smsc95xx_info,
	},
	{
		/* SMSC9500A USB Ethernet Device (SAL10) */
		USB_DEVICE(0x0424, 0x9902),
		.driver_info = (unsigned long) &smsc95xx_info,
	},
	{
		/* SMSC9505A USB Ethernet Device (SAL10) */
		USB_DEVICE(0x0424, 0x9903),
		.driver_info = (unsigned long) &smsc95xx_info,
	},
	{
		/* SMSC9512/9514 USB Hub & Ethernet Device (SAL10) */
		USB_DEVICE(0x0424, 0x9904),
		.driver_info = (unsigned long) &smsc95xx_info,
	},
	{
		/* SMSC9500A USB Ethernet Device (HAL) */
		USB_DEVICE(0x0424, 0x9905),
		.driver_info = (unsigned long) &smsc95xx_info,
	},
	{
		/* SMSC9505A USB Ethernet Device (HAL) */
		USB_DEVICE(0x0424, 0x9906),
		.driver_info = (unsigned long) &smsc95xx_info,
	},
	{
		/* SMSC9500 USB Ethernet Device (Alternate ID) */
		USB_DEVICE(0x0424, 0x9907),
		.driver_info = (unsigned long) &smsc95xx_info,
	},
	{
		/* SMSC9500A USB Ethernet Device (Alternate ID) */
		USB_DEVICE(0x0424, 0x9908),
		.driver_info = (unsigned long) &smsc95xx_info,
	},
	{
		/* SMSC9512/9514 USB Hub & Ethernet Device (Alternate ID) */
		USB_DEVICE(0x0424, 0x9909),
		.driver_info = (unsigned long) &smsc95xx_info,
	},
1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998
	{
		/* SMSC LAN9530 USB Ethernet Device */
		USB_DEVICE(0x0424, 0x9530),
		.driver_info = (unsigned long) &smsc95xx_info,
	},
	{
		/* SMSC LAN9730 USB Ethernet Device */
		USB_DEVICE(0x0424, 0x9730),
		.driver_info = (unsigned long) &smsc95xx_info,
	},
	{
		/* SMSC LAN89530 USB Ethernet Device */
		USB_DEVICE(0x0424, 0x9E08),
		.driver_info = (unsigned long) &smsc95xx_info,
	},
1999 2000 2001 2002 2003 2004 2005 2006
	{ },		/* END */
};
MODULE_DEVICE_TABLE(usb, products);

static struct usb_driver smsc95xx_driver = {
	.name		= "smsc95xx",
	.id_table	= products,
	.probe		= usbnet_probe,
2007
	.suspend	= smsc95xx_suspend,
2008 2009
	.resume		= smsc95xx_resume,
	.reset_resume	= smsc95xx_resume,
2010
	.disconnect	= usbnet_disconnect,
2011
	.disable_hub_initiated_lpm = 1,
2012
	.supports_autosuspend = 1,
2013 2014
};

2015
module_usb_driver(smsc95xx_driver);
2016 2017

MODULE_AUTHOR("Nancy Lin");
2018
MODULE_AUTHOR("Steve Glendinning <steve.glendinning@shawell.net>");
2019 2020
MODULE_DESCRIPTION("SMSC95XX USB 2.0 Ethernet Devices");
MODULE_LICENSE("GPL");