xref: /linux/drivers/net/usb/aqc111.c (revision 621cde16e49b3ecf7d59a8106a20aaebfb4a59a9)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* Aquantia Corp. Aquantia AQtion USB to 5GbE Controller
3  * Copyright (C) 2003-2005 David Hollis <dhollis@davehollis.com>
4  * Copyright (C) 2005 Phil Chang <pchang23@sbcglobal.net>
5  * Copyright (C) 2002-2003 TiVo Inc.
6  * Copyright (C) 2017-2018 ASIX
7  * Copyright (C) 2018 Aquantia Corp.
8  */
9 
10 #include <linux/module.h>
11 #include <linux/netdevice.h>
12 #include <linux/ethtool.h>
13 #include <linux/mii.h>
14 #include <linux/usb.h>
15 #include <linux/crc32.h>
16 #include <linux/if_vlan.h>
17 #include <linux/usb/cdc.h>
18 #include <linux/usb/usbnet.h>
19 #include <linux/linkmode.h>
20 
21 #include "aqc111.h"
22 
23 #define DRIVER_NAME "aqc111"
24 
aqc111_read_cmd_nopm(struct usbnet * dev,u8 cmd,u16 value,u16 index,u16 size,void * data)25 static int aqc111_read_cmd_nopm(struct usbnet *dev, u8 cmd, u16 value,
26 				u16 index, u16 size, void *data)
27 {
28 	int ret;
29 
30 	ret = usbnet_read_cmd_nopm(dev, cmd, USB_DIR_IN | USB_TYPE_VENDOR |
31 				   USB_RECIP_DEVICE, value, index, data, size);
32 
33 	if (unlikely(ret < 0))
34 		netdev_warn(dev->net,
35 			    "Failed to read(0x%x) reg index 0x%04x: %d\n",
36 			    cmd, index, ret);
37 
38 	return ret;
39 }
40 
aqc111_read_cmd(struct usbnet * dev,u8 cmd,u16 value,u16 index,u16 size,void * data)41 static int aqc111_read_cmd(struct usbnet *dev, u8 cmd, u16 value,
42 			   u16 index, u16 size, void *data)
43 {
44 	int ret;
45 
46 	ret = usbnet_read_cmd(dev, cmd, USB_DIR_IN | USB_TYPE_VENDOR |
47 			      USB_RECIP_DEVICE, value, index, data, size);
48 
49 	if (unlikely(ret < 0))
50 		netdev_warn(dev->net,
51 			    "Failed to read(0x%x) reg index 0x%04x: %d\n",
52 			    cmd, index, ret);
53 
54 	return ret;
55 }
56 
aqc111_read16_cmd_nopm(struct usbnet * dev,u8 cmd,u16 value,u16 index,u16 * data)57 static int aqc111_read16_cmd_nopm(struct usbnet *dev, u8 cmd, u16 value,
58 				  u16 index, u16 *data)
59 {
60 	int ret = 0;
61 
62 	ret = aqc111_read_cmd_nopm(dev, cmd, value, index, sizeof(*data), data);
63 	le16_to_cpus(data);
64 
65 	return ret;
66 }
67 
aqc111_read16_cmd(struct usbnet * dev,u8 cmd,u16 value,u16 index,u16 * data)68 static int aqc111_read16_cmd(struct usbnet *dev, u8 cmd, u16 value,
69 			     u16 index, u16 *data)
70 {
71 	int ret = 0;
72 
73 	ret = aqc111_read_cmd(dev, cmd, value, index, sizeof(*data), data);
74 	le16_to_cpus(data);
75 
76 	return ret;
77 }
78 
__aqc111_write_cmd(struct usbnet * dev,u8 cmd,u8 reqtype,u16 value,u16 index,u16 size,const void * data)79 static int __aqc111_write_cmd(struct usbnet *dev, u8 cmd, u8 reqtype,
80 			      u16 value, u16 index, u16 size, const void *data)
81 {
82 	int err = -ENOMEM;
83 	void *buf = NULL;
84 
85 	netdev_dbg(dev->net,
86 		   "%s cmd=%#x reqtype=%#x value=%#x index=%#x size=%d\n",
87 		   __func__, cmd, reqtype, value, index, size);
88 
89 	if (data) {
90 		buf = kmemdup(data, size, GFP_KERNEL);
91 		if (!buf)
92 			goto out;
93 	}
94 
95 	err = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
96 			      cmd, reqtype, value, index, buf, size,
97 			      (cmd == AQ_PHY_POWER) ? AQ_USB_PHY_SET_TIMEOUT :
98 			      AQ_USB_SET_TIMEOUT);
99 
100 	if (unlikely(err < 0))
101 		netdev_warn(dev->net,
102 			    "Failed to write(0x%x) reg index 0x%04x: %d\n",
103 			    cmd, index, err);
104 	kfree(buf);
105 
106 out:
107 	return err;
108 }
109 
aqc111_write_cmd_nopm(struct usbnet * dev,u8 cmd,u16 value,u16 index,u16 size,void * data)110 static int aqc111_write_cmd_nopm(struct usbnet *dev, u8 cmd, u16 value,
111 				 u16 index, u16 size, void *data)
112 {
113 	int ret;
114 
115 	ret = __aqc111_write_cmd(dev, cmd, USB_DIR_OUT | USB_TYPE_VENDOR |
116 				 USB_RECIP_DEVICE, value, index, size, data);
117 
118 	return ret;
119 }
120 
aqc111_write_cmd(struct usbnet * dev,u8 cmd,u16 value,u16 index,u16 size,const void * data)121 static int aqc111_write_cmd(struct usbnet *dev, u8 cmd, u16 value,
122 			    u16 index, u16 size, const void *data)
123 {
124 	int ret;
125 
126 	if (usb_autopm_get_interface(dev->intf) < 0)
127 		return -ENODEV;
128 
129 	ret = __aqc111_write_cmd(dev, cmd, USB_DIR_OUT | USB_TYPE_VENDOR |
130 				 USB_RECIP_DEVICE, value, index, size, data);
131 
132 	usb_autopm_put_interface(dev->intf);
133 
134 	return ret;
135 }
136 
aqc111_write16_cmd_nopm(struct usbnet * dev,u8 cmd,u16 value,u16 index,u16 * data)137 static int aqc111_write16_cmd_nopm(struct usbnet *dev, u8 cmd, u16 value,
138 				   u16 index, u16 *data)
139 {
140 	u16 tmp = *data;
141 
142 	cpu_to_le16s(&tmp);
143 
144 	return aqc111_write_cmd_nopm(dev, cmd, value, index, sizeof(tmp), &tmp);
145 }
146 
aqc111_write16_cmd(struct usbnet * dev,u8 cmd,u16 value,u16 index,u16 * data)147 static int aqc111_write16_cmd(struct usbnet *dev, u8 cmd, u16 value,
148 			      u16 index, u16 *data)
149 {
150 	u16 tmp = *data;
151 
152 	cpu_to_le16s(&tmp);
153 
154 	return aqc111_write_cmd(dev, cmd, value, index, sizeof(tmp), &tmp);
155 }
156 
aqc111_write32_cmd_nopm(struct usbnet * dev,u8 cmd,u16 value,u16 index,u32 * data)157 static int aqc111_write32_cmd_nopm(struct usbnet *dev, u8 cmd, u16 value,
158 				   u16 index, u32 *data)
159 {
160 	u32 tmp = *data;
161 
162 	cpu_to_le32s(&tmp);
163 
164 	return aqc111_write_cmd_nopm(dev, cmd, value, index, sizeof(tmp), &tmp);
165 }
166 
aqc111_write32_cmd(struct usbnet * dev,u8 cmd,u16 value,u16 index,u32 * data)167 static int aqc111_write32_cmd(struct usbnet *dev, u8 cmd, u16 value,
168 			      u16 index, u32 *data)
169 {
170 	u32 tmp = *data;
171 
172 	cpu_to_le32s(&tmp);
173 
174 	return aqc111_write_cmd(dev, cmd, value, index, sizeof(tmp), &tmp);
175 }
176 
aqc111_write_cmd_async(struct usbnet * dev,u8 cmd,u16 value,u16 index,u16 size,void * data)177 static int aqc111_write_cmd_async(struct usbnet *dev, u8 cmd, u16 value,
178 				  u16 index, u16 size, void *data)
179 {
180 	return usbnet_write_cmd_async(dev, cmd, USB_DIR_OUT | USB_TYPE_VENDOR |
181 				      USB_RECIP_DEVICE, value, index, data,
182 				      size);
183 }
184 
aqc111_write16_cmd_async(struct usbnet * dev,u8 cmd,u16 value,u16 index,u16 * data)185 static int aqc111_write16_cmd_async(struct usbnet *dev, u8 cmd, u16 value,
186 				    u16 index, u16 *data)
187 {
188 	u16 tmp = *data;
189 
190 	cpu_to_le16s(&tmp);
191 
192 	return aqc111_write_cmd_async(dev, cmd, value, index,
193 				      sizeof(tmp), &tmp);
194 }
195 
aqc111_get_drvinfo(struct net_device * net,struct ethtool_drvinfo * info)196 static void aqc111_get_drvinfo(struct net_device *net,
197 			       struct ethtool_drvinfo *info)
198 {
199 	struct usbnet *dev = netdev_priv(net);
200 	struct aqc111_data *aqc111_data = dev->driver_priv;
201 
202 	/* Inherit standard device info */
203 	usbnet_get_drvinfo(net, info);
204 	strscpy(info->driver, DRIVER_NAME, sizeof(info->driver));
205 	snprintf(info->fw_version, sizeof(info->fw_version), "%u.%u.%u",
206 		 aqc111_data->fw_ver.major,
207 		 aqc111_data->fw_ver.minor,
208 		 aqc111_data->fw_ver.rev);
209 	info->eedump_len = 0x00;
210 	info->regdump_len = 0x00;
211 }
212 
aqc111_get_wol(struct net_device * net,struct ethtool_wolinfo * wolinfo)213 static void aqc111_get_wol(struct net_device *net,
214 			   struct ethtool_wolinfo *wolinfo)
215 {
216 	struct usbnet *dev = netdev_priv(net);
217 	struct aqc111_data *aqc111_data = dev->driver_priv;
218 
219 	wolinfo->supported = WAKE_MAGIC;
220 	wolinfo->wolopts = 0;
221 
222 	if (aqc111_data->wol_flags & AQ_WOL_FLAG_MP)
223 		wolinfo->wolopts |= WAKE_MAGIC;
224 }
225 
aqc111_set_wol(struct net_device * net,struct ethtool_wolinfo * wolinfo)226 static int aqc111_set_wol(struct net_device *net,
227 			  struct ethtool_wolinfo *wolinfo)
228 {
229 	struct usbnet *dev = netdev_priv(net);
230 	struct aqc111_data *aqc111_data = dev->driver_priv;
231 
232 	if (wolinfo->wolopts & ~WAKE_MAGIC)
233 		return -EINVAL;
234 
235 	aqc111_data->wol_flags = 0;
236 	if (wolinfo->wolopts & WAKE_MAGIC)
237 		aqc111_data->wol_flags |= AQ_WOL_FLAG_MP;
238 
239 	return 0;
240 }
241 
aqc111_speed_to_link_mode(u32 speed,struct ethtool_link_ksettings * elk)242 static void aqc111_speed_to_link_mode(u32 speed,
243 				      struct ethtool_link_ksettings *elk)
244 {
245 	switch (speed) {
246 	case SPEED_5000:
247 		ethtool_link_ksettings_add_link_mode(elk, advertising,
248 						     5000baseT_Full);
249 		break;
250 	case SPEED_2500:
251 		ethtool_link_ksettings_add_link_mode(elk, advertising,
252 						     2500baseT_Full);
253 		break;
254 	case SPEED_1000:
255 		ethtool_link_ksettings_add_link_mode(elk, advertising,
256 						     1000baseT_Full);
257 		break;
258 	case SPEED_100:
259 		ethtool_link_ksettings_add_link_mode(elk, advertising,
260 						     100baseT_Full);
261 		break;
262 	}
263 }
264 
aqc111_get_link_ksettings(struct net_device * net,struct ethtool_link_ksettings * elk)265 static int aqc111_get_link_ksettings(struct net_device *net,
266 				     struct ethtool_link_ksettings *elk)
267 {
268 	struct usbnet *dev = netdev_priv(net);
269 	struct aqc111_data *aqc111_data = dev->driver_priv;
270 	enum usb_device_speed usb_speed = dev->udev->speed;
271 	u32 speed = SPEED_UNKNOWN;
272 
273 	ethtool_link_ksettings_zero_link_mode(elk, supported);
274 	ethtool_link_ksettings_add_link_mode(elk, supported,
275 					     100baseT_Full);
276 	ethtool_link_ksettings_add_link_mode(elk, supported,
277 					     1000baseT_Full);
278 	if (usb_speed == USB_SPEED_SUPER) {
279 		ethtool_link_ksettings_add_link_mode(elk, supported,
280 						     2500baseT_Full);
281 		ethtool_link_ksettings_add_link_mode(elk, supported,
282 						     5000baseT_Full);
283 	}
284 	ethtool_link_ksettings_add_link_mode(elk, supported, TP);
285 	ethtool_link_ksettings_add_link_mode(elk, supported, Autoneg);
286 
287 	elk->base.port = PORT_TP;
288 	elk->base.transceiver = XCVR_INTERNAL;
289 
290 	elk->base.mdio_support = 0x00; /*Not supported*/
291 
292 	if (aqc111_data->autoneg)
293 		linkmode_copy(elk->link_modes.advertising,
294 			      elk->link_modes.supported);
295 	else
296 		aqc111_speed_to_link_mode(aqc111_data->advertised_speed, elk);
297 
298 	elk->base.autoneg = aqc111_data->autoneg;
299 
300 	switch (aqc111_data->link_speed) {
301 	case AQ_INT_SPEED_5G:
302 		speed = SPEED_5000;
303 		break;
304 	case AQ_INT_SPEED_2_5G:
305 		speed = SPEED_2500;
306 		break;
307 	case AQ_INT_SPEED_1G:
308 		speed = SPEED_1000;
309 		break;
310 	case AQ_INT_SPEED_100M:
311 		speed = SPEED_100;
312 		break;
313 	}
314 	elk->base.duplex = DUPLEX_FULL;
315 	elk->base.speed = speed;
316 
317 	return 0;
318 }
319 
aqc111_set_phy_speed(struct usbnet * dev,u8 autoneg,u16 speed)320 static void aqc111_set_phy_speed(struct usbnet *dev, u8 autoneg, u16 speed)
321 {
322 	struct aqc111_data *aqc111_data = dev->driver_priv;
323 
324 	aqc111_data->phy_cfg &= ~AQ_ADV_MASK;
325 	aqc111_data->phy_cfg |= AQ_PAUSE;
326 	aqc111_data->phy_cfg |= AQ_ASYM_PAUSE;
327 	aqc111_data->phy_cfg |= AQ_DOWNSHIFT;
328 	aqc111_data->phy_cfg &= ~AQ_DSH_RETRIES_MASK;
329 	aqc111_data->phy_cfg |= (3 << AQ_DSH_RETRIES_SHIFT) &
330 				AQ_DSH_RETRIES_MASK;
331 
332 	if (autoneg == AUTONEG_ENABLE) {
333 		switch (speed) {
334 		case SPEED_5000:
335 			aqc111_data->phy_cfg |= AQ_ADV_5G;
336 			fallthrough;
337 		case SPEED_2500:
338 			aqc111_data->phy_cfg |= AQ_ADV_2G5;
339 			fallthrough;
340 		case SPEED_1000:
341 			aqc111_data->phy_cfg |= AQ_ADV_1G;
342 			fallthrough;
343 		case SPEED_100:
344 			aqc111_data->phy_cfg |= AQ_ADV_100M;
345 			/* fall-through */
346 		}
347 	} else {
348 		switch (speed) {
349 		case SPEED_5000:
350 			aqc111_data->phy_cfg |= AQ_ADV_5G;
351 			break;
352 		case SPEED_2500:
353 			aqc111_data->phy_cfg |= AQ_ADV_2G5;
354 			break;
355 		case SPEED_1000:
356 			aqc111_data->phy_cfg |= AQ_ADV_1G;
357 			break;
358 		case SPEED_100:
359 			aqc111_data->phy_cfg |= AQ_ADV_100M;
360 			break;
361 		}
362 	}
363 
364 	aqc111_write32_cmd(dev, AQ_PHY_OPS, 0, 0, &aqc111_data->phy_cfg);
365 }
366 
aqc111_set_link_ksettings(struct net_device * net,const struct ethtool_link_ksettings * elk)367 static int aqc111_set_link_ksettings(struct net_device *net,
368 				     const struct ethtool_link_ksettings *elk)
369 {
370 	struct usbnet *dev = netdev_priv(net);
371 	struct aqc111_data *aqc111_data = dev->driver_priv;
372 	enum usb_device_speed usb_speed = dev->udev->speed;
373 	u8 autoneg = elk->base.autoneg;
374 	u32 speed = elk->base.speed;
375 
376 	if (autoneg == AUTONEG_ENABLE) {
377 		if (aqc111_data->autoneg != AUTONEG_ENABLE) {
378 			aqc111_data->autoneg = AUTONEG_ENABLE;
379 			aqc111_data->advertised_speed =
380 					(usb_speed == USB_SPEED_SUPER) ?
381 					 SPEED_5000 : SPEED_1000;
382 			aqc111_set_phy_speed(dev, aqc111_data->autoneg,
383 					     aqc111_data->advertised_speed);
384 		}
385 	} else {
386 		if (speed != SPEED_100 &&
387 		    speed != SPEED_1000 &&
388 		    speed != SPEED_2500 &&
389 		    speed != SPEED_5000 &&
390 		    speed != SPEED_UNKNOWN)
391 			return -EINVAL;
392 
393 		if (elk->base.duplex != DUPLEX_FULL)
394 			return -EINVAL;
395 
396 		if (usb_speed != USB_SPEED_SUPER && speed > SPEED_1000)
397 			return -EINVAL;
398 
399 		aqc111_data->autoneg = AUTONEG_DISABLE;
400 		if (speed != SPEED_UNKNOWN)
401 			aqc111_data->advertised_speed = speed;
402 
403 		aqc111_set_phy_speed(dev, aqc111_data->autoneg,
404 				     aqc111_data->advertised_speed);
405 	}
406 
407 	return 0;
408 }
409 
410 static const struct ethtool_ops aqc111_ethtool_ops = {
411 	.get_drvinfo = aqc111_get_drvinfo,
412 	.get_wol = aqc111_get_wol,
413 	.set_wol = aqc111_set_wol,
414 	.get_msglevel = usbnet_get_msglevel,
415 	.set_msglevel = usbnet_set_msglevel,
416 	.get_link = ethtool_op_get_link,
417 	.get_link_ksettings = aqc111_get_link_ksettings,
418 	.set_link_ksettings = aqc111_set_link_ksettings
419 };
420 
aqc111_change_mtu(struct net_device * net,int new_mtu)421 static int aqc111_change_mtu(struct net_device *net, int new_mtu)
422 {
423 	struct usbnet *dev = netdev_priv(net);
424 	u16 reg16 = 0;
425 	u8 buf[5];
426 
427 	WRITE_ONCE(net->mtu, new_mtu);
428 	dev->hard_mtu = net->mtu + net->hard_header_len;
429 
430 	aqc111_read16_cmd(dev, AQ_ACCESS_MAC, SFR_MEDIUM_STATUS_MODE,
431 			  2, &reg16);
432 	if (net->mtu > 1500)
433 		reg16 |= SFR_MEDIUM_JUMBO_EN;
434 	else
435 		reg16 &= ~SFR_MEDIUM_JUMBO_EN;
436 
437 	aqc111_write16_cmd(dev, AQ_ACCESS_MAC, SFR_MEDIUM_STATUS_MODE,
438 			   2, &reg16);
439 
440 	if (dev->net->mtu > 12500) {
441 		memcpy(buf, &AQC111_BULKIN_SIZE[2], 5);
442 		/* RX bulk configuration */
443 		aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_RX_BULKIN_QCTRL,
444 				 5, 5, buf);
445 	}
446 
447 	/* Set high low water level */
448 	if (dev->net->mtu <= 4500)
449 		reg16 = 0x0810;
450 	else if (dev->net->mtu <= 9500)
451 		reg16 = 0x1020;
452 	else if (dev->net->mtu <= 12500)
453 		reg16 = 0x1420;
454 	else
455 		reg16 = 0x1A20;
456 
457 	aqc111_write16_cmd(dev, AQ_ACCESS_MAC, SFR_PAUSE_WATERLVL_LOW,
458 			   2, &reg16);
459 
460 	return 0;
461 }
462 
aqc111_set_mac_addr(struct net_device * net,void * p)463 static int aqc111_set_mac_addr(struct net_device *net, void *p)
464 {
465 	struct usbnet *dev = netdev_priv(net);
466 	int ret = 0;
467 
468 	ret = eth_mac_addr(net, p);
469 	if (ret < 0)
470 		return ret;
471 
472 	/* Set the MAC address */
473 	return aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_NODE_ID, ETH_ALEN,
474 				ETH_ALEN, net->dev_addr);
475 }
476 
aqc111_vlan_rx_kill_vid(struct net_device * net,__be16 proto,u16 vid)477 static int aqc111_vlan_rx_kill_vid(struct net_device *net,
478 				   __be16 proto, u16 vid)
479 {
480 	struct usbnet *dev = netdev_priv(net);
481 	u8 vlan_ctrl = 0;
482 	u16 reg16 = 0;
483 	u8 reg8 = 0;
484 
485 	aqc111_read_cmd(dev, AQ_ACCESS_MAC, SFR_VLAN_ID_CONTROL, 1, 1, &reg8);
486 	vlan_ctrl = reg8;
487 
488 	/* Address */
489 	reg8 = (vid / 16);
490 	aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_VLAN_ID_ADDRESS, 1, 1, &reg8);
491 	/* Data */
492 	reg8 = vlan_ctrl | SFR_VLAN_CONTROL_RD;
493 	aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_VLAN_ID_CONTROL, 1, 1, &reg8);
494 	aqc111_read16_cmd(dev, AQ_ACCESS_MAC, SFR_VLAN_ID_DATA0, 2, &reg16);
495 	reg16 &= ~(1 << (vid % 16));
496 	aqc111_write16_cmd(dev, AQ_ACCESS_MAC, SFR_VLAN_ID_DATA0, 2, &reg16);
497 	reg8 = vlan_ctrl | SFR_VLAN_CONTROL_WE;
498 	aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_VLAN_ID_CONTROL, 1, 1, &reg8);
499 
500 	return 0;
501 }
502 
aqc111_vlan_rx_add_vid(struct net_device * net,__be16 proto,u16 vid)503 static int aqc111_vlan_rx_add_vid(struct net_device *net, __be16 proto, u16 vid)
504 {
505 	struct usbnet *dev = netdev_priv(net);
506 	u8 vlan_ctrl = 0;
507 	u16 reg16 = 0;
508 	u8 reg8 = 0;
509 
510 	aqc111_read_cmd(dev, AQ_ACCESS_MAC, SFR_VLAN_ID_CONTROL, 1, 1, &reg8);
511 	vlan_ctrl = reg8;
512 
513 	/* Address */
514 	reg8 = (vid / 16);
515 	aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_VLAN_ID_ADDRESS, 1, 1, &reg8);
516 	/* Data */
517 	reg8 = vlan_ctrl | SFR_VLAN_CONTROL_RD;
518 	aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_VLAN_ID_CONTROL, 1, 1, &reg8);
519 	aqc111_read16_cmd(dev, AQ_ACCESS_MAC, SFR_VLAN_ID_DATA0, 2, &reg16);
520 	reg16 |= (1 << (vid % 16));
521 	aqc111_write16_cmd(dev, AQ_ACCESS_MAC, SFR_VLAN_ID_DATA0, 2, &reg16);
522 	reg8 = vlan_ctrl | SFR_VLAN_CONTROL_WE;
523 	aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_VLAN_ID_CONTROL, 1, 1, &reg8);
524 
525 	return 0;
526 }
527 
aqc111_set_rx_mode(struct net_device * net)528 static void aqc111_set_rx_mode(struct net_device *net)
529 {
530 	struct usbnet *dev = netdev_priv(net);
531 	struct aqc111_data *aqc111_data = dev->driver_priv;
532 	int mc_count = 0;
533 
534 	mc_count = netdev_mc_count(net);
535 
536 	aqc111_data->rxctl &= ~(SFR_RX_CTL_PRO | SFR_RX_CTL_AMALL |
537 				SFR_RX_CTL_AM);
538 
539 	if (net->flags & IFF_PROMISC) {
540 		aqc111_data->rxctl |= SFR_RX_CTL_PRO;
541 	} else if ((net->flags & IFF_ALLMULTI) || mc_count > AQ_MAX_MCAST) {
542 		aqc111_data->rxctl |= SFR_RX_CTL_AMALL;
543 	} else if (!netdev_mc_empty(net)) {
544 		u8 m_filter[AQ_MCAST_FILTER_SIZE] = { 0 };
545 		struct netdev_hw_addr *ha = NULL;
546 		u32 crc_bits = 0;
547 
548 		netdev_for_each_mc_addr(ha, net) {
549 			crc_bits = ether_crc(ETH_ALEN, ha->addr) >> 26;
550 			m_filter[crc_bits >> 3] |= BIT(crc_bits & 7);
551 		}
552 
553 		aqc111_write_cmd_async(dev, AQ_ACCESS_MAC,
554 				       SFR_MULTI_FILTER_ARRY,
555 				       AQ_MCAST_FILTER_SIZE,
556 				       AQ_MCAST_FILTER_SIZE, m_filter);
557 
558 		aqc111_data->rxctl |= SFR_RX_CTL_AM;
559 	}
560 
561 	aqc111_write16_cmd_async(dev, AQ_ACCESS_MAC, SFR_RX_CTL,
562 				 2, &aqc111_data->rxctl);
563 }
564 
aqc111_set_features(struct net_device * net,netdev_features_t features)565 static int aqc111_set_features(struct net_device *net,
566 			       netdev_features_t features)
567 {
568 	struct usbnet *dev = netdev_priv(net);
569 	struct aqc111_data *aqc111_data = dev->driver_priv;
570 	netdev_features_t changed = net->features ^ features;
571 	u16 reg16 = 0;
572 	u8 reg8 = 0;
573 
574 	if (changed & NETIF_F_IP_CSUM) {
575 		aqc111_read_cmd(dev, AQ_ACCESS_MAC, SFR_TXCOE_CTL, 1, 1, &reg8);
576 		reg8 ^= SFR_TXCOE_TCP | SFR_TXCOE_UDP;
577 		aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_TXCOE_CTL,
578 				 1, 1, &reg8);
579 	}
580 
581 	if (changed & NETIF_F_IPV6_CSUM) {
582 		aqc111_read_cmd(dev, AQ_ACCESS_MAC, SFR_TXCOE_CTL, 1, 1, &reg8);
583 		reg8 ^= SFR_TXCOE_TCPV6 | SFR_TXCOE_UDPV6;
584 		aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_TXCOE_CTL,
585 				 1, 1, &reg8);
586 	}
587 
588 	if (changed & NETIF_F_RXCSUM) {
589 		aqc111_read_cmd(dev, AQ_ACCESS_MAC, SFR_RXCOE_CTL, 1, 1, &reg8);
590 		if (features & NETIF_F_RXCSUM) {
591 			aqc111_data->rx_checksum = 1;
592 			reg8 &= ~(SFR_RXCOE_IP | SFR_RXCOE_TCP | SFR_RXCOE_UDP |
593 				  SFR_RXCOE_TCPV6 | SFR_RXCOE_UDPV6);
594 		} else {
595 			aqc111_data->rx_checksum = 0;
596 			reg8 |= SFR_RXCOE_IP | SFR_RXCOE_TCP | SFR_RXCOE_UDP |
597 				SFR_RXCOE_TCPV6 | SFR_RXCOE_UDPV6;
598 		}
599 
600 		aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_RXCOE_CTL,
601 				 1, 1, &reg8);
602 	}
603 	if (changed & NETIF_F_HW_VLAN_CTAG_FILTER) {
604 		if (features & NETIF_F_HW_VLAN_CTAG_FILTER) {
605 			u16 i = 0;
606 
607 			for (i = 0; i < 256; i++) {
608 				/* Address */
609 				reg8 = i;
610 				aqc111_write_cmd(dev, AQ_ACCESS_MAC,
611 						 SFR_VLAN_ID_ADDRESS,
612 						 1, 1, &reg8);
613 				/* Data */
614 				aqc111_write16_cmd(dev, AQ_ACCESS_MAC,
615 						   SFR_VLAN_ID_DATA0,
616 						   2, &reg16);
617 				reg8 = SFR_VLAN_CONTROL_WE;
618 				aqc111_write_cmd(dev, AQ_ACCESS_MAC,
619 						 SFR_VLAN_ID_CONTROL,
620 						 1, 1, &reg8);
621 			}
622 			aqc111_read_cmd(dev, AQ_ACCESS_MAC, SFR_VLAN_ID_CONTROL,
623 					1, 1, &reg8);
624 			reg8 |= SFR_VLAN_CONTROL_VFE;
625 			aqc111_write_cmd(dev, AQ_ACCESS_MAC,
626 					 SFR_VLAN_ID_CONTROL, 1, 1, &reg8);
627 		} else {
628 			aqc111_read_cmd(dev, AQ_ACCESS_MAC, SFR_VLAN_ID_CONTROL,
629 					1, 1, &reg8);
630 			reg8 &= ~SFR_VLAN_CONTROL_VFE;
631 			aqc111_write_cmd(dev, AQ_ACCESS_MAC,
632 					 SFR_VLAN_ID_CONTROL, 1, 1, &reg8);
633 		}
634 	}
635 
636 	return 0;
637 }
638 
639 static const struct net_device_ops aqc111_netdev_ops = {
640 	.ndo_open		= usbnet_open,
641 	.ndo_stop		= usbnet_stop,
642 	.ndo_start_xmit		= usbnet_start_xmit,
643 	.ndo_tx_timeout		= usbnet_tx_timeout,
644 	.ndo_get_stats64	= dev_get_tstats64,
645 	.ndo_change_mtu		= aqc111_change_mtu,
646 	.ndo_set_mac_address	= aqc111_set_mac_addr,
647 	.ndo_validate_addr	= eth_validate_addr,
648 	.ndo_vlan_rx_add_vid	= aqc111_vlan_rx_add_vid,
649 	.ndo_vlan_rx_kill_vid	= aqc111_vlan_rx_kill_vid,
650 	.ndo_set_rx_mode	= aqc111_set_rx_mode,
651 	.ndo_set_features	= aqc111_set_features,
652 };
653 
aqc111_read_perm_mac(struct usbnet * dev)654 static int aqc111_read_perm_mac(struct usbnet *dev)
655 {
656 	u8 buf[ETH_ALEN];
657 	int ret;
658 
659 	ret = aqc111_read_cmd(dev, AQ_FLASH_PARAMETERS, 0, 0, ETH_ALEN, buf);
660 	if (ret < 0)
661 		goto out;
662 
663 	ether_addr_copy(dev->net->perm_addr, buf);
664 
665 	return 0;
666 out:
667 	return ret;
668 }
669 
aqc111_read_fw_version(struct usbnet * dev,struct aqc111_data * aqc111_data)670 static void aqc111_read_fw_version(struct usbnet *dev,
671 				   struct aqc111_data *aqc111_data)
672 {
673 	aqc111_read_cmd(dev, AQ_ACCESS_MAC, AQ_FW_VER_MAJOR,
674 			1, 1, &aqc111_data->fw_ver.major);
675 	aqc111_read_cmd(dev, AQ_ACCESS_MAC, AQ_FW_VER_MINOR,
676 			1, 1, &aqc111_data->fw_ver.minor);
677 	aqc111_read_cmd(dev, AQ_ACCESS_MAC, AQ_FW_VER_REV,
678 			1, 1, &aqc111_data->fw_ver.rev);
679 
680 	if (aqc111_data->fw_ver.major & 0x80)
681 		aqc111_data->fw_ver.major &= ~0x80;
682 }
683 
aqc111_bind(struct usbnet * dev,struct usb_interface * intf)684 static int aqc111_bind(struct usbnet *dev, struct usb_interface *intf)
685 {
686 	struct usb_device *udev = interface_to_usbdev(intf);
687 	enum usb_device_speed usb_speed = udev->speed;
688 	struct aqc111_data *aqc111_data;
689 	int ret;
690 
691 	/* Check if vendor configuration */
692 	if (udev->actconfig->desc.bConfigurationValue != 1) {
693 		usb_driver_set_configuration(udev, 1);
694 		return -ENODEV;
695 	}
696 
697 	usb_reset_configuration(dev->udev);
698 
699 	ret = usbnet_get_endpoints(dev, intf);
700 	if (ret < 0) {
701 		netdev_dbg(dev->net, "usbnet_get_endpoints failed");
702 		return ret;
703 	}
704 
705 	aqc111_data = kzalloc(sizeof(*aqc111_data), GFP_KERNEL);
706 	if (!aqc111_data)
707 		return -ENOMEM;
708 
709 	/* store aqc111_data pointer in device data field */
710 	dev->driver_priv = aqc111_data;
711 
712 	/* Init the MAC address */
713 	ret = aqc111_read_perm_mac(dev);
714 	if (ret)
715 		goto out;
716 
717 	eth_hw_addr_set(dev->net, dev->net->perm_addr);
718 
719 	/* Set Rx urb size */
720 	dev->rx_urb_size = URB_SIZE;
721 
722 	/* Set TX needed headroom & tailroom */
723 	dev->net->needed_headroom += sizeof(u64);
724 	dev->net->needed_tailroom += sizeof(u64);
725 
726 	dev->net->max_mtu = 16334;
727 
728 	dev->net->netdev_ops = &aqc111_netdev_ops;
729 	dev->net->ethtool_ops = &aqc111_ethtool_ops;
730 
731 	if (usb_device_no_sg_constraint(dev->udev))
732 		dev->can_dma_sg = 1;
733 
734 	dev->net->hw_features |= AQ_SUPPORT_HW_FEATURE;
735 	dev->net->features |= AQ_SUPPORT_FEATURE;
736 	dev->net->vlan_features |= AQ_SUPPORT_VLAN_FEATURE;
737 
738 	netif_set_tso_max_size(dev->net, 65535);
739 
740 	aqc111_read_fw_version(dev, aqc111_data);
741 	aqc111_data->autoneg = AUTONEG_ENABLE;
742 	aqc111_data->advertised_speed = (usb_speed == USB_SPEED_SUPER) ?
743 					 SPEED_5000 : SPEED_1000;
744 
745 	return 0;
746 
747 out:
748 	kfree(aqc111_data);
749 	return ret;
750 }
751 
aqc111_unbind(struct usbnet * dev,struct usb_interface * intf)752 static void aqc111_unbind(struct usbnet *dev, struct usb_interface *intf)
753 {
754 	struct aqc111_data *aqc111_data = dev->driver_priv;
755 	u16 reg16;
756 
757 	/* Force bz */
758 	reg16 = SFR_PHYPWR_RSTCTL_BZ;
759 	aqc111_write16_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_PHYPWR_RSTCTL,
760 				2, &reg16);
761 	reg16 = 0;
762 	aqc111_write16_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_PHYPWR_RSTCTL,
763 				2, &reg16);
764 
765 	/* Power down ethernet PHY */
766 	aqc111_data->phy_cfg &= ~AQ_ADV_MASK;
767 	aqc111_data->phy_cfg |= AQ_LOW_POWER;
768 	aqc111_data->phy_cfg &= ~AQ_PHY_POWER_EN;
769 	aqc111_write32_cmd_nopm(dev, AQ_PHY_OPS, 0, 0,
770 				&aqc111_data->phy_cfg);
771 
772 	kfree(aqc111_data);
773 }
774 
aqc111_status(struct usbnet * dev,struct urb * urb)775 static void aqc111_status(struct usbnet *dev, struct urb *urb)
776 {
777 	struct aqc111_data *aqc111_data = dev->driver_priv;
778 	u64 *event_data = NULL;
779 	int link = 0;
780 
781 	if (urb->actual_length < sizeof(*event_data))
782 		return;
783 
784 	event_data = urb->transfer_buffer;
785 	le64_to_cpus(event_data);
786 
787 	if (*event_data & AQ_LS_MASK)
788 		link = 1;
789 	else
790 		link = 0;
791 
792 	aqc111_data->link_speed = (*event_data & AQ_SPEED_MASK) >>
793 				  AQ_SPEED_SHIFT;
794 	aqc111_data->link = link;
795 
796 	if (netif_carrier_ok(dev->net) != link)
797 		usbnet_defer_kevent(dev, EVENT_LINK_RESET);
798 }
799 
aqc111_configure_rx(struct usbnet * dev,struct aqc111_data * aqc111_data)800 static void aqc111_configure_rx(struct usbnet *dev,
801 				struct aqc111_data *aqc111_data)
802 {
803 	enum usb_device_speed usb_speed = dev->udev->speed;
804 	u16 link_speed = 0, usb_host = 0;
805 	u8 buf[5] = { 0 };
806 	u8 queue_num = 0;
807 	u16 reg16 = 0;
808 	u8 reg8 = 0;
809 
810 	buf[0] = 0x00;
811 	buf[1] = 0xF8;
812 	buf[2] = 0x07;
813 	switch (aqc111_data->link_speed) {
814 	case AQ_INT_SPEED_5G:
815 		link_speed = 5000;
816 		reg8 = 0x05;
817 		reg16 = 0x001F;
818 		break;
819 	case AQ_INT_SPEED_2_5G:
820 		link_speed = 2500;
821 		reg16 = 0x003F;
822 		break;
823 	case AQ_INT_SPEED_1G:
824 		link_speed = 1000;
825 		reg16 = 0x009F;
826 		break;
827 	case AQ_INT_SPEED_100M:
828 		link_speed = 100;
829 		queue_num = 1;
830 		reg16 = 0x063F;
831 		buf[1] = 0xFB;
832 		buf[2] = 0x4;
833 		break;
834 	}
835 
836 	aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_INTER_PACKET_GAP_0,
837 			 1, 1, &reg8);
838 
839 	aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_TX_PAUSE_RESEND_T, 3, 3, buf);
840 
841 	switch (usb_speed) {
842 	case USB_SPEED_SUPER:
843 		usb_host = 3;
844 		break;
845 	case USB_SPEED_HIGH:
846 		usb_host = 2;
847 		break;
848 	case USB_SPEED_FULL:
849 	case USB_SPEED_LOW:
850 		usb_host = 1;
851 		queue_num = 0;
852 		break;
853 	default:
854 		usb_host = 0;
855 		break;
856 	}
857 
858 	if (dev->net->mtu > 12500 && dev->net->mtu <= 16334)
859 		queue_num = 2; /* For Jumbo packet 16KB */
860 
861 	memcpy(buf, &AQC111_BULKIN_SIZE[queue_num], 5);
862 	/* RX bulk configuration */
863 	aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_RX_BULKIN_QCTRL, 5, 5, buf);
864 
865 	/* Set high low water level */
866 	if (dev->net->mtu <= 4500)
867 		reg16 = 0x0810;
868 	else if (dev->net->mtu <= 9500)
869 		reg16 = 0x1020;
870 	else if (dev->net->mtu <= 12500)
871 		reg16 = 0x1420;
872 	else if (dev->net->mtu <= 16334)
873 		reg16 = 0x1A20;
874 
875 	aqc111_write16_cmd(dev, AQ_ACCESS_MAC, SFR_PAUSE_WATERLVL_LOW,
876 			   2, &reg16);
877 	netdev_info(dev->net, "Link Speed %d, USB %d", link_speed, usb_host);
878 }
879 
aqc111_configure_csum_offload(struct usbnet * dev)880 static void aqc111_configure_csum_offload(struct usbnet *dev)
881 {
882 	u8 reg8 = 0;
883 
884 	if (dev->net->features & NETIF_F_RXCSUM) {
885 		reg8 |= SFR_RXCOE_IP | SFR_RXCOE_TCP | SFR_RXCOE_UDP |
886 			SFR_RXCOE_TCPV6 | SFR_RXCOE_UDPV6;
887 	}
888 	aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_RXCOE_CTL, 1, 1, &reg8);
889 
890 	reg8 = 0;
891 	if (dev->net->features & NETIF_F_IP_CSUM)
892 		reg8 |= SFR_TXCOE_IP | SFR_TXCOE_TCP | SFR_TXCOE_UDP;
893 
894 	if (dev->net->features & NETIF_F_IPV6_CSUM)
895 		reg8 |= SFR_TXCOE_TCPV6 | SFR_TXCOE_UDPV6;
896 
897 	aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_TXCOE_CTL, 1, 1, &reg8);
898 }
899 
aqc111_link_reset(struct usbnet * dev)900 static int aqc111_link_reset(struct usbnet *dev)
901 {
902 	struct aqc111_data *aqc111_data = dev->driver_priv;
903 	u16 reg16 = 0;
904 	u8 reg8 = 0;
905 
906 	if (aqc111_data->link == 1) { /* Link up */
907 		aqc111_configure_rx(dev, aqc111_data);
908 
909 		/* Vlan Tag Filter */
910 		reg8 = SFR_VLAN_CONTROL_VSO;
911 		if (dev->net->features & NETIF_F_HW_VLAN_CTAG_FILTER)
912 			reg8 |= SFR_VLAN_CONTROL_VFE;
913 
914 		aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_VLAN_ID_CONTROL,
915 				 1, 1, &reg8);
916 
917 		reg8 = 0x0;
918 		aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_BMRX_DMA_CONTROL,
919 				 1, 1, &reg8);
920 
921 		aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_BMTX_DMA_CONTROL,
922 				 1, 1, &reg8);
923 
924 		aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_ARC_CTRL, 1, 1, &reg8);
925 
926 		reg16 = SFR_RX_CTL_IPE | SFR_RX_CTL_AB;
927 		aqc111_data->rxctl = reg16;
928 		aqc111_write16_cmd(dev, AQ_ACCESS_MAC, SFR_RX_CTL, 2, &reg16);
929 
930 		reg8 = SFR_RX_PATH_READY;
931 		aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_ETH_MAC_PATH,
932 				 1, 1, &reg8);
933 
934 		reg8 = SFR_BULK_OUT_EFF_EN;
935 		aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_BULK_OUT_CTRL,
936 				 1, 1, &reg8);
937 
938 		reg16 = 0;
939 		aqc111_write16_cmd(dev, AQ_ACCESS_MAC, SFR_MEDIUM_STATUS_MODE,
940 				   2, &reg16);
941 
942 		reg16 = SFR_MEDIUM_XGMIIMODE | SFR_MEDIUM_FULL_DUPLEX;
943 		aqc111_write16_cmd(dev, AQ_ACCESS_MAC, SFR_MEDIUM_STATUS_MODE,
944 				   2, &reg16);
945 
946 		aqc111_configure_csum_offload(dev);
947 
948 		aqc111_set_rx_mode(dev->net);
949 
950 		aqc111_read16_cmd(dev, AQ_ACCESS_MAC, SFR_MEDIUM_STATUS_MODE,
951 				  2, &reg16);
952 
953 		if (dev->net->mtu > 1500)
954 			reg16 |= SFR_MEDIUM_JUMBO_EN;
955 
956 		reg16 |= SFR_MEDIUM_RECEIVE_EN | SFR_MEDIUM_RXFLOW_CTRLEN |
957 			 SFR_MEDIUM_TXFLOW_CTRLEN;
958 		aqc111_write16_cmd(dev, AQ_ACCESS_MAC, SFR_MEDIUM_STATUS_MODE,
959 				   2, &reg16);
960 
961 		aqc111_data->rxctl |= SFR_RX_CTL_START;
962 		aqc111_write16_cmd(dev, AQ_ACCESS_MAC, SFR_RX_CTL,
963 				   2, &aqc111_data->rxctl);
964 
965 		netif_carrier_on(dev->net);
966 	} else {
967 		aqc111_read16_cmd(dev, AQ_ACCESS_MAC, SFR_MEDIUM_STATUS_MODE,
968 				  2, &reg16);
969 		reg16 &= ~SFR_MEDIUM_RECEIVE_EN;
970 		aqc111_write16_cmd(dev, AQ_ACCESS_MAC, SFR_MEDIUM_STATUS_MODE,
971 				   2, &reg16);
972 
973 		aqc111_data->rxctl &= ~SFR_RX_CTL_START;
974 		aqc111_write16_cmd(dev, AQ_ACCESS_MAC, SFR_RX_CTL,
975 				   2, &aqc111_data->rxctl);
976 
977 		reg8 = SFR_BULK_OUT_FLUSH_EN | SFR_BULK_OUT_EFF_EN;
978 		aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_BULK_OUT_CTRL,
979 				 1, 1, &reg8);
980 		reg8 = SFR_BULK_OUT_EFF_EN;
981 		aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_BULK_OUT_CTRL,
982 				 1, 1, &reg8);
983 
984 		netif_carrier_off(dev->net);
985 	}
986 	return 0;
987 }
988 
aqc111_reset(struct usbnet * dev)989 static int aqc111_reset(struct usbnet *dev)
990 {
991 	struct aqc111_data *aqc111_data = dev->driver_priv;
992 	u8 reg8 = 0;
993 
994 	dev->rx_urb_size = URB_SIZE;
995 
996 	if (usb_device_no_sg_constraint(dev->udev))
997 		dev->can_dma_sg = 1;
998 
999 	dev->net->hw_features |= AQ_SUPPORT_HW_FEATURE;
1000 	dev->net->features |= AQ_SUPPORT_FEATURE;
1001 	dev->net->vlan_features |= AQ_SUPPORT_VLAN_FEATURE;
1002 
1003 	/* Power up ethernet PHY */
1004 	aqc111_data->phy_cfg = AQ_PHY_POWER_EN;
1005 	aqc111_write32_cmd(dev, AQ_PHY_OPS, 0, 0,
1006 			   &aqc111_data->phy_cfg);
1007 
1008 	/* Set the MAC address */
1009 	aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_NODE_ID, ETH_ALEN,
1010 			 ETH_ALEN, dev->net->dev_addr);
1011 
1012 	reg8 = 0xFF;
1013 	aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_BM_INT_MASK, 1, 1, &reg8);
1014 
1015 	reg8 = 0x0;
1016 	aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_SWP_CTRL, 1, 1, &reg8);
1017 
1018 	aqc111_read_cmd(dev, AQ_ACCESS_MAC, SFR_MONITOR_MODE, 1, 1, &reg8);
1019 	reg8 &= ~(SFR_MONITOR_MODE_EPHYRW | SFR_MONITOR_MODE_RWLC |
1020 		  SFR_MONITOR_MODE_RWMP | SFR_MONITOR_MODE_RWWF |
1021 		  SFR_MONITOR_MODE_RW_FLAG);
1022 	aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_MONITOR_MODE, 1, 1, &reg8);
1023 
1024 	netif_carrier_off(dev->net);
1025 
1026 	/* Phy advertise */
1027 	aqc111_set_phy_speed(dev, aqc111_data->autoneg,
1028 			     aqc111_data->advertised_speed);
1029 
1030 	return 0;
1031 }
1032 
aqc111_stop(struct usbnet * dev)1033 static int aqc111_stop(struct usbnet *dev)
1034 {
1035 	struct aqc111_data *aqc111_data = dev->driver_priv;
1036 	u16 reg16 = 0;
1037 
1038 	aqc111_read16_cmd(dev, AQ_ACCESS_MAC, SFR_MEDIUM_STATUS_MODE,
1039 			  2, &reg16);
1040 	reg16 &= ~SFR_MEDIUM_RECEIVE_EN;
1041 	aqc111_write16_cmd(dev, AQ_ACCESS_MAC, SFR_MEDIUM_STATUS_MODE,
1042 			   2, &reg16);
1043 	reg16 = 0;
1044 	aqc111_write16_cmd(dev, AQ_ACCESS_MAC, SFR_RX_CTL, 2, &reg16);
1045 
1046 	/* Put PHY to low power*/
1047 	aqc111_data->phy_cfg |= AQ_LOW_POWER;
1048 	aqc111_write32_cmd(dev, AQ_PHY_OPS, 0, 0,
1049 			   &aqc111_data->phy_cfg);
1050 
1051 	netif_carrier_off(dev->net);
1052 
1053 	return 0;
1054 }
1055 
aqc111_rx_checksum(struct sk_buff * skb,u64 pkt_desc)1056 static void aqc111_rx_checksum(struct sk_buff *skb, u64 pkt_desc)
1057 {
1058 	u32 pkt_type = 0;
1059 
1060 	skb->ip_summed = CHECKSUM_NONE;
1061 	/* checksum error bit is set */
1062 	if (pkt_desc & AQ_RX_PD_L4_ERR || pkt_desc & AQ_RX_PD_L3_ERR)
1063 		return;
1064 
1065 	pkt_type = pkt_desc & AQ_RX_PD_L4_TYPE_MASK;
1066 	/* It must be a TCP or UDP packet with a valid checksum */
1067 	if (pkt_type == AQ_RX_PD_L4_TCP || pkt_type == AQ_RX_PD_L4_UDP)
1068 		skb->ip_summed = CHECKSUM_UNNECESSARY;
1069 }
1070 
aqc111_rx_fixup(struct usbnet * dev,struct sk_buff * skb)1071 static int aqc111_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
1072 {
1073 	struct aqc111_data *aqc111_data = dev->driver_priv;
1074 	struct sk_buff *new_skb = NULL;
1075 	u32 pkt_total_offset = 0;
1076 	u64 *pkt_desc_ptr = NULL;
1077 	u32 start_of_descs = 0;
1078 	u32 desc_offset = 0; /*RX Header Offset*/
1079 	u16 pkt_count = 0;
1080 	u64 desc_hdr = 0;
1081 	u16 vlan_tag = 0;
1082 	u32 skb_len;
1083 
1084 	if (!skb)
1085 		goto err;
1086 
1087 	skb_len = skb->len;
1088 	if (skb_len < sizeof(desc_hdr))
1089 		goto err;
1090 
1091 	/* RX Descriptor Header */
1092 	skb_trim(skb, skb_len - sizeof(desc_hdr));
1093 	desc_hdr = le64_to_cpup((u64 *)skb_tail_pointer(skb));
1094 
1095 	/* Check these packets */
1096 	desc_offset = (desc_hdr & AQ_RX_DH_DESC_OFFSET_MASK) >>
1097 		      AQ_RX_DH_DESC_OFFSET_SHIFT;
1098 	pkt_count = desc_hdr & AQ_RX_DH_PKT_CNT_MASK;
1099 	start_of_descs = skb_len - ((pkt_count + 1) *  sizeof(desc_hdr));
1100 
1101 	/* self check descs position */
1102 	if (start_of_descs != desc_offset)
1103 		goto err;
1104 
1105 	/* self check desc_offset from header and make sure that the
1106 	 * bounds of the metadata array are inside the SKB
1107 	 */
1108 	if (pkt_count * 2 + desc_offset >= skb_len)
1109 		goto err;
1110 
1111 	/* Packets must not overlap the metadata array */
1112 	skb_trim(skb, desc_offset);
1113 
1114 	if (pkt_count == 0)
1115 		goto err;
1116 
1117 	/* Get the first RX packet descriptor */
1118 	pkt_desc_ptr = (u64 *)(skb->data + desc_offset);
1119 
1120 	while (pkt_count--) {
1121 		u64 pkt_desc = le64_to_cpup(pkt_desc_ptr);
1122 		u32 pkt_len_with_padd = 0;
1123 		u32 pkt_len = 0;
1124 
1125 		pkt_len = (u32)((pkt_desc & AQ_RX_PD_LEN_MASK) >>
1126 			  AQ_RX_PD_LEN_SHIFT);
1127 		pkt_len_with_padd = ((pkt_len + 7) & 0x7FFF8);
1128 
1129 		pkt_total_offset += pkt_len_with_padd;
1130 		if (pkt_total_offset > desc_offset ||
1131 		    (pkt_count == 0 && pkt_total_offset != desc_offset)) {
1132 			goto err;
1133 		}
1134 
1135 		if (pkt_desc & AQ_RX_PD_DROP ||
1136 		    !(pkt_desc & AQ_RX_PD_RX_OK) ||
1137 		    pkt_len > (dev->hard_mtu + AQ_RX_HW_PAD)) {
1138 			skb_pull(skb, pkt_len_with_padd);
1139 			/* Next RX Packet Descriptor */
1140 			pkt_desc_ptr++;
1141 			continue;
1142 		}
1143 
1144 		new_skb = netdev_alloc_skb_ip_align(dev->net, pkt_len);
1145 
1146 		if (!new_skb)
1147 			goto err;
1148 
1149 		skb_put(new_skb, pkt_len);
1150 		memcpy(new_skb->data, skb->data, pkt_len);
1151 		skb_pull(new_skb, AQ_RX_HW_PAD);
1152 
1153 		if (aqc111_data->rx_checksum)
1154 			aqc111_rx_checksum(new_skb, pkt_desc);
1155 
1156 		if (pkt_desc & AQ_RX_PD_VLAN) {
1157 			vlan_tag = pkt_desc >> AQ_RX_PD_VLAN_SHIFT;
1158 			__vlan_hwaccel_put_tag(new_skb, htons(ETH_P_8021Q),
1159 					       vlan_tag & VLAN_VID_MASK);
1160 		}
1161 
1162 		usbnet_skb_return(dev, new_skb);
1163 		if (pkt_count == 0)
1164 			break;
1165 
1166 		skb_pull(skb, pkt_len_with_padd);
1167 
1168 		/* Next RX Packet Header */
1169 		pkt_desc_ptr++;
1170 
1171 		new_skb = NULL;
1172 	}
1173 
1174 	return 1;
1175 
1176 err:
1177 	return 0;
1178 }
1179 
aqc111_tx_fixup(struct usbnet * dev,struct sk_buff * skb,gfp_t flags)1180 static struct sk_buff *aqc111_tx_fixup(struct usbnet *dev, struct sk_buff *skb,
1181 				       gfp_t flags)
1182 {
1183 	int frame_size = dev->maxpacket;
1184 	struct sk_buff *new_skb = NULL;
1185 	u64 *tx_desc_ptr = NULL;
1186 	int padding_size = 0;
1187 	int headroom = 0;
1188 	int tailroom = 0;
1189 	u64 tx_desc = 0;
1190 	u16 tci = 0;
1191 
1192 	/*Length of actual data*/
1193 	tx_desc |= skb->len & AQ_TX_DESC_LEN_MASK;
1194 
1195 	/* TSO MSS */
1196 	tx_desc |= ((u64)(skb_shinfo(skb)->gso_size & AQ_TX_DESC_MSS_MASK)) <<
1197 		   AQ_TX_DESC_MSS_SHIFT;
1198 
1199 	headroom = (skb->len + sizeof(tx_desc)) % 8;
1200 	if (headroom != 0)
1201 		padding_size = 8 - headroom;
1202 
1203 	if (((skb->len + sizeof(tx_desc) + padding_size) % frame_size) == 0) {
1204 		padding_size += 8;
1205 		tx_desc |= AQ_TX_DESC_DROP_PADD;
1206 	}
1207 
1208 	/* Vlan Tag */
1209 	if (vlan_get_tag(skb, &tci) >= 0) {
1210 		tx_desc |= AQ_TX_DESC_VLAN;
1211 		tx_desc |= ((u64)tci & AQ_TX_DESC_VLAN_MASK) <<
1212 			   AQ_TX_DESC_VLAN_SHIFT;
1213 	}
1214 
1215 	if (!dev->can_dma_sg && (dev->net->features & NETIF_F_SG) &&
1216 	    skb_linearize(skb))
1217 		return NULL;
1218 
1219 	headroom = skb_headroom(skb);
1220 	tailroom = skb_tailroom(skb);
1221 
1222 	if (!(headroom >= sizeof(tx_desc) && tailroom >= padding_size)) {
1223 		new_skb = skb_copy_expand(skb, sizeof(tx_desc),
1224 					  padding_size, flags);
1225 		dev_kfree_skb_any(skb);
1226 		skb = new_skb;
1227 		if (!skb)
1228 			return NULL;
1229 	}
1230 	if (padding_size != 0)
1231 		skb_put_zero(skb, padding_size);
1232 	/* Copy TX header */
1233 	tx_desc_ptr = skb_push(skb, sizeof(tx_desc));
1234 	*tx_desc_ptr = cpu_to_le64(tx_desc);
1235 
1236 	usbnet_set_skb_tx_stats(skb, 1, 0);
1237 
1238 	return skb;
1239 }
1240 
1241 static const struct driver_info aqc111_info = {
1242 	.description	= "Aquantia AQtion USB to 5GbE Controller",
1243 	.bind		= aqc111_bind,
1244 	.unbind		= aqc111_unbind,
1245 	.status		= aqc111_status,
1246 	.link_reset	= aqc111_link_reset,
1247 	.reset		= aqc111_reset,
1248 	.stop		= aqc111_stop,
1249 	.flags		= FLAG_ETHER | FLAG_FRAMING_AX |
1250 			  FLAG_AVOID_UNLINK_URBS | FLAG_MULTI_PACKET,
1251 	.rx_fixup	= aqc111_rx_fixup,
1252 	.tx_fixup	= aqc111_tx_fixup,
1253 };
1254 
1255 #define ASIX111_DESC \
1256 "ASIX USB 3.1 Gen1 to 5G Multi-Gigabit Ethernet Adapter"
1257 
1258 static const struct driver_info asix111_info = {
1259 	.description	= ASIX111_DESC,
1260 	.bind		= aqc111_bind,
1261 	.unbind		= aqc111_unbind,
1262 	.status		= aqc111_status,
1263 	.link_reset	= aqc111_link_reset,
1264 	.reset		= aqc111_reset,
1265 	.stop		= aqc111_stop,
1266 	.flags		= FLAG_ETHER | FLAG_FRAMING_AX |
1267 			  FLAG_AVOID_UNLINK_URBS | FLAG_MULTI_PACKET,
1268 	.rx_fixup	= aqc111_rx_fixup,
1269 	.tx_fixup	= aqc111_tx_fixup,
1270 };
1271 
1272 #undef ASIX111_DESC
1273 
1274 #define ASIX112_DESC \
1275 "ASIX USB 3.1 Gen1 to 2.5G Multi-Gigabit Ethernet Adapter"
1276 
1277 static const struct driver_info asix112_info = {
1278 	.description	= ASIX112_DESC,
1279 	.bind		= aqc111_bind,
1280 	.unbind		= aqc111_unbind,
1281 	.status		= aqc111_status,
1282 	.link_reset	= aqc111_link_reset,
1283 	.reset		= aqc111_reset,
1284 	.stop		= aqc111_stop,
1285 	.flags		= FLAG_ETHER | FLAG_FRAMING_AX |
1286 			  FLAG_AVOID_UNLINK_URBS | FLAG_MULTI_PACKET,
1287 	.rx_fixup	= aqc111_rx_fixup,
1288 	.tx_fixup	= aqc111_tx_fixup,
1289 };
1290 
1291 #undef ASIX112_DESC
1292 
1293 static const struct driver_info trendnet_info = {
1294 	.description	= "USB-C 3.1 to 5GBASE-T Ethernet Adapter",
1295 	.bind		= aqc111_bind,
1296 	.unbind		= aqc111_unbind,
1297 	.status		= aqc111_status,
1298 	.link_reset	= aqc111_link_reset,
1299 	.reset		= aqc111_reset,
1300 	.stop		= aqc111_stop,
1301 	.flags		= FLAG_ETHER | FLAG_FRAMING_AX |
1302 			  FLAG_AVOID_UNLINK_URBS | FLAG_MULTI_PACKET,
1303 	.rx_fixup	= aqc111_rx_fixup,
1304 	.tx_fixup	= aqc111_tx_fixup,
1305 };
1306 
1307 static const struct driver_info qnap_info = {
1308 	.description	= "QNAP QNA-UC5G1T USB to 5GbE Adapter",
1309 	.bind		= aqc111_bind,
1310 	.unbind		= aqc111_unbind,
1311 	.status		= aqc111_status,
1312 	.link_reset	= aqc111_link_reset,
1313 	.reset		= aqc111_reset,
1314 	.stop		= aqc111_stop,
1315 	.flags		= FLAG_ETHER | FLAG_FRAMING_AX |
1316 			  FLAG_AVOID_UNLINK_URBS | FLAG_MULTI_PACKET,
1317 	.rx_fixup	= aqc111_rx_fixup,
1318 	.tx_fixup	= aqc111_tx_fixup,
1319 };
1320 
aqc111_suspend(struct usb_interface * intf,pm_message_t message)1321 static int aqc111_suspend(struct usb_interface *intf, pm_message_t message)
1322 {
1323 	struct usbnet *dev = usb_get_intfdata(intf);
1324 	struct aqc111_data *aqc111_data = dev->driver_priv;
1325 	u16 temp_rx_ctrl = 0x00;
1326 	u16 reg16;
1327 	u8 reg8;
1328 
1329 	usbnet_suspend(intf, message);
1330 
1331 	aqc111_read16_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_RX_CTL, 2, &reg16);
1332 	temp_rx_ctrl = reg16;
1333 	/* Stop RX operations*/
1334 	reg16 &= ~SFR_RX_CTL_START;
1335 	aqc111_write16_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_RX_CTL, 2, &reg16);
1336 	/* Force bz */
1337 	aqc111_read16_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_PHYPWR_RSTCTL,
1338 			       2, &reg16);
1339 	reg16 |= SFR_PHYPWR_RSTCTL_BZ;
1340 	aqc111_write16_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_PHYPWR_RSTCTL,
1341 				2, &reg16);
1342 
1343 	reg8 = SFR_BULK_OUT_EFF_EN;
1344 	aqc111_write_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_BULK_OUT_CTRL,
1345 			      1, 1, &reg8);
1346 
1347 	temp_rx_ctrl &= ~(SFR_RX_CTL_START | SFR_RX_CTL_RF_WAK |
1348 			  SFR_RX_CTL_AP | SFR_RX_CTL_AM);
1349 	aqc111_write16_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_RX_CTL,
1350 				2, &temp_rx_ctrl);
1351 
1352 	reg8 = 0x00;
1353 	aqc111_write_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_ETH_MAC_PATH,
1354 			      1, 1, &reg8);
1355 
1356 	if (aqc111_data->wol_flags) {
1357 		struct aqc111_wol_cfg wol_cfg;
1358 
1359 		memset(&wol_cfg, 0, sizeof(struct aqc111_wol_cfg));
1360 
1361 		aqc111_data->phy_cfg |= AQ_WOL;
1362 		ether_addr_copy(wol_cfg.hw_addr, dev->net->dev_addr);
1363 		wol_cfg.flags = aqc111_data->wol_flags;
1364 
1365 		temp_rx_ctrl |= (SFR_RX_CTL_AB | SFR_RX_CTL_START);
1366 		aqc111_write16_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_RX_CTL,
1367 					2, &temp_rx_ctrl);
1368 		reg8 = 0x00;
1369 		aqc111_write_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_BM_INT_MASK,
1370 				      1, 1, &reg8);
1371 		reg8 = SFR_BMRX_DMA_EN;
1372 		aqc111_write_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_BMRX_DMA_CONTROL,
1373 				      1, 1, &reg8);
1374 		reg8 = SFR_RX_PATH_READY;
1375 		aqc111_write_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_ETH_MAC_PATH,
1376 				      1, 1, &reg8);
1377 		reg8 = 0x07;
1378 		aqc111_write_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_RX_BULKIN_QCTRL,
1379 				      1, 1, &reg8);
1380 		reg8 = 0x00;
1381 		aqc111_write_cmd_nopm(dev, AQ_ACCESS_MAC,
1382 				      SFR_RX_BULKIN_QTIMR_LOW, 1, 1, &reg8);
1383 		aqc111_write_cmd_nopm(dev, AQ_ACCESS_MAC,
1384 				      SFR_RX_BULKIN_QTIMR_HIGH, 1, 1, &reg8);
1385 		reg8 = 0xFF;
1386 		aqc111_write_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_RX_BULKIN_QSIZE,
1387 				      1, 1, &reg8);
1388 		aqc111_write_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_RX_BULKIN_QIFG,
1389 				      1, 1, &reg8);
1390 
1391 		aqc111_read16_cmd_nopm(dev, AQ_ACCESS_MAC,
1392 				       SFR_MEDIUM_STATUS_MODE, 2, &reg16);
1393 		reg16 |= SFR_MEDIUM_RECEIVE_EN;
1394 		aqc111_write16_cmd_nopm(dev, AQ_ACCESS_MAC,
1395 					SFR_MEDIUM_STATUS_MODE, 2, &reg16);
1396 
1397 		aqc111_write_cmd(dev, AQ_WOL_CFG, 0, 0,
1398 				 WOL_CFG_SIZE, &wol_cfg);
1399 		aqc111_write32_cmd(dev, AQ_PHY_OPS, 0, 0,
1400 				   &aqc111_data->phy_cfg);
1401 	} else {
1402 		aqc111_data->phy_cfg |= AQ_LOW_POWER;
1403 		aqc111_write32_cmd(dev, AQ_PHY_OPS, 0, 0,
1404 				   &aqc111_data->phy_cfg);
1405 
1406 		/* Disable RX path */
1407 		aqc111_read16_cmd_nopm(dev, AQ_ACCESS_MAC,
1408 				       SFR_MEDIUM_STATUS_MODE, 2, &reg16);
1409 		reg16 &= ~SFR_MEDIUM_RECEIVE_EN;
1410 		aqc111_write16_cmd_nopm(dev, AQ_ACCESS_MAC,
1411 					SFR_MEDIUM_STATUS_MODE, 2, &reg16);
1412 	}
1413 
1414 	return 0;
1415 }
1416 
aqc111_resume(struct usb_interface * intf)1417 static int aqc111_resume(struct usb_interface *intf)
1418 {
1419 	struct usbnet *dev = usb_get_intfdata(intf);
1420 	struct aqc111_data *aqc111_data = dev->driver_priv;
1421 	u16 reg16;
1422 	u8 reg8;
1423 
1424 	netif_carrier_off(dev->net);
1425 
1426 	/* Power up ethernet PHY */
1427 	aqc111_data->phy_cfg |= AQ_PHY_POWER_EN;
1428 	aqc111_data->phy_cfg &= ~AQ_LOW_POWER;
1429 	aqc111_data->phy_cfg &= ~AQ_WOL;
1430 
1431 	reg8 = 0xFF;
1432 	aqc111_write_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_BM_INT_MASK,
1433 			      1, 1, &reg8);
1434 	/* Configure RX control register => start operation */
1435 	reg16 = aqc111_data->rxctl;
1436 	reg16 &= ~SFR_RX_CTL_START;
1437 	aqc111_write16_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_RX_CTL, 2, &reg16);
1438 
1439 	reg16 |= SFR_RX_CTL_START;
1440 	aqc111_write16_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_RX_CTL, 2, &reg16);
1441 
1442 	aqc111_set_phy_speed(dev, aqc111_data->autoneg,
1443 			     aqc111_data->advertised_speed);
1444 
1445 	aqc111_read16_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_MEDIUM_STATUS_MODE,
1446 			       2, &reg16);
1447 	reg16 |= SFR_MEDIUM_RECEIVE_EN;
1448 	aqc111_write16_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_MEDIUM_STATUS_MODE,
1449 				2, &reg16);
1450 	reg8 = SFR_RX_PATH_READY;
1451 	aqc111_write_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_ETH_MAC_PATH,
1452 			      1, 1, &reg8);
1453 	reg8 = 0x0;
1454 	aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_BMRX_DMA_CONTROL, 1, 1, &reg8);
1455 
1456 	return usbnet_resume(intf);
1457 }
1458 
1459 #define AQC111_USB_ETH_DEV(vid, pid, table) \
1460 	USB_DEVICE_INTERFACE_CLASS((vid), (pid), USB_CLASS_VENDOR_SPEC), \
1461 	.driver_info = (unsigned long)&(table) \
1462 }, \
1463 { \
1464 	USB_DEVICE_AND_INTERFACE_INFO((vid), (pid), \
1465 				      USB_CLASS_COMM, \
1466 				      USB_CDC_SUBCLASS_ETHERNET, \
1467 				      USB_CDC_PROTO_NONE), \
1468 	.driver_info = (unsigned long)&(table),
1469 
1470 static const struct usb_device_id products[] = {
1471 	{AQC111_USB_ETH_DEV(0x2eca, 0xc101, aqc111_info)},
1472 	{AQC111_USB_ETH_DEV(0x0b95, 0x2790, asix111_info)},
1473 	{AQC111_USB_ETH_DEV(0x0b95, 0x2791, asix112_info)},
1474 	{AQC111_USB_ETH_DEV(0x20f4, 0xe05a, trendnet_info)},
1475 	{AQC111_USB_ETH_DEV(0x1c04, 0x0015, qnap_info)},
1476 	{ },/* END */
1477 };
1478 MODULE_DEVICE_TABLE(usb, products);
1479 
1480 static struct usb_driver aq_driver = {
1481 	.name		= "aqc111",
1482 	.id_table	= products,
1483 	.probe		= usbnet_probe,
1484 	.suspend	= aqc111_suspend,
1485 	.resume		= aqc111_resume,
1486 	.disconnect	= usbnet_disconnect,
1487 };
1488 
1489 module_usb_driver(aq_driver);
1490 
1491 MODULE_DESCRIPTION("Aquantia AQtion USB to 5/2.5GbE Controllers");
1492 MODULE_LICENSE("GPL");
1493