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 | |
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: dev->net, |
35 | format: "Failed to read(0x%x) reg index 0x%04x: %d\n" , |
36 | cmd, index, ret); |
37 | |
38 | return ret; |
39 | } |
40 | |
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: dev->net, |
51 | format: "Failed to read(0x%x) reg index 0x%04x: %d\n" , |
52 | cmd, index, ret); |
53 | |
54 | return ret; |
55 | } |
56 | |
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, size: sizeof(*data), data); |
63 | le16_to_cpus(data); |
64 | |
65 | return ret; |
66 | } |
67 | |
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, size: sizeof(*data), data); |
74 | le16_to_cpus(data); |
75 | |
76 | return ret; |
77 | } |
78 | |
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(p: data, size, GFP_KERNEL); |
91 | if (!buf) |
92 | goto out; |
93 | } |
94 | |
95 | err = usb_control_msg(dev: dev->udev, usb_sndctrlpipe(dev->udev, 0), |
96 | request: cmd, requesttype: reqtype, value, index, data: buf, size, |
97 | timeout: (cmd == AQ_PHY_POWER) ? AQ_USB_PHY_SET_TIMEOUT : |
98 | AQ_USB_SET_TIMEOUT); |
99 | |
100 | if (unlikely(err < 0)) |
101 | netdev_warn(dev: dev->net, |
102 | format: "Failed to write(0x%x) reg index 0x%04x: %d\n" , |
103 | cmd, index, err); |
104 | kfree(objp: buf); |
105 | |
106 | out: |
107 | return err; |
108 | } |
109 | |
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 | |
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(intf: 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(intf: dev->intf); |
133 | |
134 | return ret; |
135 | } |
136 | |
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, size: sizeof(tmp), data: &tmp); |
145 | } |
146 | |
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, size: sizeof(tmp), data: &tmp); |
155 | } |
156 | |
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, size: sizeof(tmp), data: &tmp); |
165 | } |
166 | |
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, size: sizeof(tmp), data: &tmp); |
175 | } |
176 | |
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 | |
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 | size: sizeof(tmp), data: &tmp); |
194 | } |
195 | |
196 | static void aqc111_get_drvinfo(struct net_device *net, |
197 | struct ethtool_drvinfo *info) |
198 | { |
199 | struct usbnet *dev = netdev_priv(dev: net); |
200 | struct aqc111_data *aqc111_data = dev->driver_priv; |
201 | |
202 | /* Inherit standard device info */ |
203 | usbnet_get_drvinfo(net, info); |
204 | strscpy(p: info->driver, DRIVER_NAME, size: sizeof(info->driver)); |
205 | snprintf(buf: info->fw_version, size: sizeof(info->fw_version), fmt: "%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 | |
213 | static void aqc111_get_wol(struct net_device *net, |
214 | struct ethtool_wolinfo *wolinfo) |
215 | { |
216 | struct usbnet *dev = netdev_priv(dev: 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 | |
226 | static int aqc111_set_wol(struct net_device *net, |
227 | struct ethtool_wolinfo *wolinfo) |
228 | { |
229 | struct usbnet *dev = netdev_priv(dev: 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 | |
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 | |
265 | static int aqc111_get_link_ksettings(struct net_device *net, |
266 | struct ethtool_link_ksettings *elk) |
267 | { |
268 | struct usbnet *dev = netdev_priv(dev: 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(dst: elk->link_modes.advertising, |
294 | src: elk->link_modes.supported); |
295 | else |
296 | aqc111_speed_to_link_mode(speed: 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 | |
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, value: 0, index: 0, data: &aqc111_data->phy_cfg); |
365 | } |
366 | |
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(dev: 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, autoneg: aqc111_data->autoneg, |
383 | speed: 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, autoneg: aqc111_data->autoneg, |
404 | speed: 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 | |
421 | static int aqc111_change_mtu(struct net_device *net, int new_mtu) |
422 | { |
423 | struct usbnet *dev = netdev_priv(dev: net); |
424 | u16 reg16 = 0; |
425 | u8 buf[5]; |
426 | |
427 | 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 | index: 2, data: ®16); |
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 | index: 2, data: ®16); |
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 | index: 5, size: 5, data: 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 | index: 2, data: ®16); |
459 | |
460 | return 0; |
461 | } |
462 | |
463 | static int aqc111_set_mac_addr(struct net_device *net, void *p) |
464 | { |
465 | struct usbnet *dev = netdev_priv(dev: net); |
466 | int ret = 0; |
467 | |
468 | ret = eth_mac_addr(dev: 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, data: net->dev_addr); |
475 | } |
476 | |
477 | static int aqc111_vlan_rx_kill_vid(struct net_device *net, |
478 | __be16 proto, u16 vid) |
479 | { |
480 | struct usbnet *dev = netdev_priv(dev: 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, index: 1, size: 1, data: ®8); |
486 | vlan_ctrl = reg8; |
487 | |
488 | /* Address */ |
489 | reg8 = (vid / 16); |
490 | aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_VLAN_ID_ADDRESS, index: 1, size: 1, data: ®8); |
491 | /* Data */ |
492 | reg8 = vlan_ctrl | SFR_VLAN_CONTROL_RD; |
493 | aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_VLAN_ID_CONTROL, index: 1, size: 1, data: ®8); |
494 | aqc111_read16_cmd(dev, AQ_ACCESS_MAC, SFR_VLAN_ID_DATA0, index: 2, data: ®16); |
495 | reg16 &= ~(1 << (vid % 16)); |
496 | aqc111_write16_cmd(dev, AQ_ACCESS_MAC, SFR_VLAN_ID_DATA0, index: 2, data: ®16); |
497 | reg8 = vlan_ctrl | SFR_VLAN_CONTROL_WE; |
498 | aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_VLAN_ID_CONTROL, index: 1, size: 1, data: ®8); |
499 | |
500 | return 0; |
501 | } |
502 | |
503 | static int aqc111_vlan_rx_add_vid(struct net_device *net, __be16 proto, u16 vid) |
504 | { |
505 | struct usbnet *dev = netdev_priv(dev: 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, index: 1, size: 1, data: ®8); |
511 | vlan_ctrl = reg8; |
512 | |
513 | /* Address */ |
514 | reg8 = (vid / 16); |
515 | aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_VLAN_ID_ADDRESS, index: 1, size: 1, data: ®8); |
516 | /* Data */ |
517 | reg8 = vlan_ctrl | SFR_VLAN_CONTROL_RD; |
518 | aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_VLAN_ID_CONTROL, index: 1, size: 1, data: ®8); |
519 | aqc111_read16_cmd(dev, AQ_ACCESS_MAC, SFR_VLAN_ID_DATA0, index: 2, data: ®16); |
520 | reg16 |= (1 << (vid % 16)); |
521 | aqc111_write16_cmd(dev, AQ_ACCESS_MAC, SFR_VLAN_ID_DATA0, index: 2, data: ®16); |
522 | reg8 = vlan_ctrl | SFR_VLAN_CONTROL_WE; |
523 | aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_VLAN_ID_CONTROL, index: 1, size: 1, data: ®8); |
524 | |
525 | return 0; |
526 | } |
527 | |
528 | static void aqc111_set_rx_mode(struct net_device *net) |
529 | { |
530 | struct usbnet *dev = netdev_priv(dev: 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, data: 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 | index: 2, data: &aqc111_data->rxctl); |
563 | } |
564 | |
565 | static int aqc111_set_features(struct net_device *net, |
566 | netdev_features_t features) |
567 | { |
568 | struct usbnet *dev = netdev_priv(dev: 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, index: 1, size: 1, data: ®8); |
576 | reg8 ^= SFR_TXCOE_TCP | SFR_TXCOE_UDP; |
577 | aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_TXCOE_CTL, |
578 | index: 1, size: 1, data: ®8); |
579 | } |
580 | |
581 | if (changed & NETIF_F_IPV6_CSUM) { |
582 | aqc111_read_cmd(dev, AQ_ACCESS_MAC, SFR_TXCOE_CTL, index: 1, size: 1, data: ®8); |
583 | reg8 ^= SFR_TXCOE_TCPV6 | SFR_TXCOE_UDPV6; |
584 | aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_TXCOE_CTL, |
585 | index: 1, size: 1, data: ®8); |
586 | } |
587 | |
588 | if (changed & NETIF_F_RXCSUM) { |
589 | aqc111_read_cmd(dev, AQ_ACCESS_MAC, SFR_RXCOE_CTL, index: 1, size: 1, data: ®8); |
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 | index: 1, size: 1, data: ®8); |
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 | index: 1, size: 1, data: ®8); |
613 | /* Data */ |
614 | aqc111_write16_cmd(dev, AQ_ACCESS_MAC, |
615 | SFR_VLAN_ID_DATA0, |
616 | index: 2, data: ®16); |
617 | reg8 = SFR_VLAN_CONTROL_WE; |
618 | aqc111_write_cmd(dev, AQ_ACCESS_MAC, |
619 | SFR_VLAN_ID_CONTROL, |
620 | index: 1, size: 1, data: ®8); |
621 | } |
622 | aqc111_read_cmd(dev, AQ_ACCESS_MAC, SFR_VLAN_ID_CONTROL, |
623 | index: 1, size: 1, data: ®8); |
624 | reg8 |= SFR_VLAN_CONTROL_VFE; |
625 | aqc111_write_cmd(dev, AQ_ACCESS_MAC, |
626 | SFR_VLAN_ID_CONTROL, index: 1, size: 1, data: ®8); |
627 | } else { |
628 | aqc111_read_cmd(dev, AQ_ACCESS_MAC, SFR_VLAN_ID_CONTROL, |
629 | index: 1, size: 1, data: ®8); |
630 | reg8 &= ~SFR_VLAN_CONTROL_VFE; |
631 | aqc111_write_cmd(dev, AQ_ACCESS_MAC, |
632 | SFR_VLAN_ID_CONTROL, index: 1, size: 1, data: ®8); |
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 | |
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, value: 0, index: 0, ETH_ALEN, data: buf); |
660 | if (ret < 0) |
661 | goto out; |
662 | |
663 | ether_addr_copy(dst: dev->net->perm_addr, src: buf); |
664 | |
665 | return 0; |
666 | out: |
667 | return ret; |
668 | } |
669 | |
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 | index: 1, size: 1, data: &aqc111_data->fw_ver.major); |
675 | aqc111_read_cmd(dev, AQ_ACCESS_MAC, AQ_FW_VER_MINOR, |
676 | index: 1, size: 1, data: &aqc111_data->fw_ver.minor); |
677 | aqc111_read_cmd(dev, AQ_ACCESS_MAC, AQ_FW_VER_REV, |
678 | index: 1, size: 1, data: &aqc111_data->fw_ver.rev); |
679 | |
680 | if (aqc111_data->fw_ver.major & 0x80) |
681 | aqc111_data->fw_ver.major &= ~0x80; |
682 | } |
683 | |
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, config: 1); |
694 | return -ENODEV; |
695 | } |
696 | |
697 | usb_reset_configuration(dev: 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(size: 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: dev->net, addr: 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(udev: 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: dev->net, size: 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(objp: aqc111_data); |
749 | return ret; |
750 | } |
751 | |
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 | index: 2, data: ®16); |
761 | reg16 = 0; |
762 | aqc111_write16_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_PHYPWR_RSTCTL, |
763 | index: 2, data: ®16); |
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, value: 0, index: 0, |
770 | data: &aqc111_data->phy_cfg); |
771 | |
772 | kfree(objp: aqc111_data); |
773 | } |
774 | |
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: dev->net) != link) |
797 | usbnet_defer_kevent(dev, EVENT_LINK_RESET); |
798 | } |
799 | |
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 | index: 1, size: 1, data: ®8); |
838 | |
839 | aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_TX_PAUSE_RESEND_T, index: 3, size: 3, data: 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, index: 5, size: 5, data: 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 | index: 2, data: ®16); |
877 | netdev_info(dev: dev->net, format: "Link Speed %d, USB %d" , link_speed, usb_host); |
878 | } |
879 | |
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, index: 1, size: 1, data: ®8); |
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, index: 1, size: 1, data: ®8); |
898 | } |
899 | |
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 | index: 1, size: 1, data: ®8); |
916 | |
917 | reg8 = 0x0; |
918 | aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_BMRX_DMA_CONTROL, |
919 | index: 1, size: 1, data: ®8); |
920 | |
921 | aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_BMTX_DMA_CONTROL, |
922 | index: 1, size: 1, data: ®8); |
923 | |
924 | aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_ARC_CTRL, index: 1, size: 1, data: ®8); |
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, index: 2, data: ®16); |
929 | |
930 | reg8 = SFR_RX_PATH_READY; |
931 | aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_ETH_MAC_PATH, |
932 | index: 1, size: 1, data: ®8); |
933 | |
934 | reg8 = SFR_BULK_OUT_EFF_EN; |
935 | aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_BULK_OUT_CTRL, |
936 | index: 1, size: 1, data: ®8); |
937 | |
938 | reg16 = 0; |
939 | aqc111_write16_cmd(dev, AQ_ACCESS_MAC, SFR_MEDIUM_STATUS_MODE, |
940 | index: 2, data: ®16); |
941 | |
942 | reg16 = SFR_MEDIUM_XGMIIMODE | SFR_MEDIUM_FULL_DUPLEX; |
943 | aqc111_write16_cmd(dev, AQ_ACCESS_MAC, SFR_MEDIUM_STATUS_MODE, |
944 | index: 2, data: ®16); |
945 | |
946 | aqc111_configure_csum_offload(dev); |
947 | |
948 | aqc111_set_rx_mode(net: dev->net); |
949 | |
950 | aqc111_read16_cmd(dev, AQ_ACCESS_MAC, SFR_MEDIUM_STATUS_MODE, |
951 | index: 2, data: ®16); |
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 | index: 2, data: ®16); |
960 | |
961 | aqc111_data->rxctl |= SFR_RX_CTL_START; |
962 | aqc111_write16_cmd(dev, AQ_ACCESS_MAC, SFR_RX_CTL, |
963 | index: 2, data: &aqc111_data->rxctl); |
964 | |
965 | netif_carrier_on(dev: dev->net); |
966 | } else { |
967 | aqc111_read16_cmd(dev, AQ_ACCESS_MAC, SFR_MEDIUM_STATUS_MODE, |
968 | index: 2, data: ®16); |
969 | reg16 &= ~SFR_MEDIUM_RECEIVE_EN; |
970 | aqc111_write16_cmd(dev, AQ_ACCESS_MAC, SFR_MEDIUM_STATUS_MODE, |
971 | index: 2, data: ®16); |
972 | |
973 | aqc111_data->rxctl &= ~SFR_RX_CTL_START; |
974 | aqc111_write16_cmd(dev, AQ_ACCESS_MAC, SFR_RX_CTL, |
975 | index: 2, data: &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 | index: 1, size: 1, data: ®8); |
980 | reg8 = SFR_BULK_OUT_EFF_EN; |
981 | aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_BULK_OUT_CTRL, |
982 | index: 1, size: 1, data: ®8); |
983 | |
984 | netif_carrier_off(dev: dev->net); |
985 | } |
986 | return 0; |
987 | } |
988 | |
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(udev: 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, value: 0, index: 0, |
1006 | data: &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, data: dev->net->dev_addr); |
1011 | |
1012 | reg8 = 0xFF; |
1013 | aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_BM_INT_MASK, index: 1, size: 1, data: ®8); |
1014 | |
1015 | reg8 = 0x0; |
1016 | aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_SWP_CTRL, index: 1, size: 1, data: ®8); |
1017 | |
1018 | aqc111_read_cmd(dev, AQ_ACCESS_MAC, SFR_MONITOR_MODE, index: 1, size: 1, data: ®8); |
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, index: 1, size: 1, data: ®8); |
1023 | |
1024 | netif_carrier_off(dev: dev->net); |
1025 | |
1026 | /* Phy advertise */ |
1027 | aqc111_set_phy_speed(dev, autoneg: aqc111_data->autoneg, |
1028 | speed: aqc111_data->advertised_speed); |
1029 | |
1030 | return 0; |
1031 | } |
1032 | |
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 | index: 2, data: ®16); |
1040 | reg16 &= ~SFR_MEDIUM_RECEIVE_EN; |
1041 | aqc111_write16_cmd(dev, AQ_ACCESS_MAC, SFR_MEDIUM_STATUS_MODE, |
1042 | index: 2, data: ®16); |
1043 | reg16 = 0; |
1044 | aqc111_write16_cmd(dev, AQ_ACCESS_MAC, SFR_RX_CTL, index: 2, data: ®16); |
1045 | |
1046 | /* Put PHY to low power*/ |
1047 | aqc111_data->phy_cfg |= AQ_LOW_POWER; |
1048 | aqc111_write32_cmd(dev, AQ_PHY_OPS, value: 0, index: 0, |
1049 | data: &aqc111_data->phy_cfg); |
1050 | |
1051 | netif_carrier_off(dev: dev->net); |
1052 | |
1053 | return 0; |
1054 | } |
1055 | |
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 | |
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 = 0; |
1083 | |
1084 | if (!skb) |
1085 | goto err; |
1086 | |
1087 | if (skb->len == 0) |
1088 | goto err; |
1089 | |
1090 | skb_len = skb->len; |
1091 | /* RX Descriptor Header */ |
1092 | skb_trim(skb, len: skb->len - sizeof(desc_hdr)); |
1093 | desc_hdr = le64_to_cpup(p: (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, len: 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(p: 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, len: pkt_len_with_padd); |
1139 | /* Next RX Packet Descriptor */ |
1140 | pkt_desc_ptr++; |
1141 | continue; |
1142 | } |
1143 | |
1144 | /* Clone SKB */ |
1145 | new_skb = skb_clone(skb, GFP_ATOMIC); |
1146 | |
1147 | if (!new_skb) |
1148 | goto err; |
1149 | |
1150 | new_skb->len = pkt_len; |
1151 | skb_pull(skb: new_skb, AQ_RX_HW_PAD); |
1152 | skb_set_tail_pointer(skb: new_skb, offset: new_skb->len); |
1153 | |
1154 | new_skb->truesize = SKB_TRUESIZE(new_skb->len); |
1155 | if (aqc111_data->rx_checksum) |
1156 | aqc111_rx_checksum(skb: new_skb, pkt_desc); |
1157 | |
1158 | if (pkt_desc & AQ_RX_PD_VLAN) { |
1159 | vlan_tag = pkt_desc >> AQ_RX_PD_VLAN_SHIFT; |
1160 | __vlan_hwaccel_put_tag(skb: new_skb, htons(ETH_P_8021Q), |
1161 | vlan_tci: vlan_tag & VLAN_VID_MASK); |
1162 | } |
1163 | |
1164 | usbnet_skb_return(dev, new_skb); |
1165 | if (pkt_count == 0) |
1166 | break; |
1167 | |
1168 | skb_pull(skb, len: pkt_len_with_padd); |
1169 | |
1170 | /* Next RX Packet Header */ |
1171 | pkt_desc_ptr++; |
1172 | |
1173 | new_skb = NULL; |
1174 | } |
1175 | |
1176 | return 1; |
1177 | |
1178 | err: |
1179 | return 0; |
1180 | } |
1181 | |
1182 | static struct sk_buff *aqc111_tx_fixup(struct usbnet *dev, struct sk_buff *skb, |
1183 | gfp_t flags) |
1184 | { |
1185 | int frame_size = dev->maxpacket; |
1186 | struct sk_buff *new_skb = NULL; |
1187 | u64 *tx_desc_ptr = NULL; |
1188 | int padding_size = 0; |
1189 | int headroom = 0; |
1190 | int tailroom = 0; |
1191 | u64 tx_desc = 0; |
1192 | u16 tci = 0; |
1193 | |
1194 | /*Length of actual data*/ |
1195 | tx_desc |= skb->len & AQ_TX_DESC_LEN_MASK; |
1196 | |
1197 | /* TSO MSS */ |
1198 | tx_desc |= ((u64)(skb_shinfo(skb)->gso_size & AQ_TX_DESC_MSS_MASK)) << |
1199 | AQ_TX_DESC_MSS_SHIFT; |
1200 | |
1201 | headroom = (skb->len + sizeof(tx_desc)) % 8; |
1202 | if (headroom != 0) |
1203 | padding_size = 8 - headroom; |
1204 | |
1205 | if (((skb->len + sizeof(tx_desc) + padding_size) % frame_size) == 0) { |
1206 | padding_size += 8; |
1207 | tx_desc |= AQ_TX_DESC_DROP_PADD; |
1208 | } |
1209 | |
1210 | /* Vlan Tag */ |
1211 | if (vlan_get_tag(skb, vlan_tci: &tci) >= 0) { |
1212 | tx_desc |= AQ_TX_DESC_VLAN; |
1213 | tx_desc |= ((u64)tci & AQ_TX_DESC_VLAN_MASK) << |
1214 | AQ_TX_DESC_VLAN_SHIFT; |
1215 | } |
1216 | |
1217 | if (!dev->can_dma_sg && (dev->net->features & NETIF_F_SG) && |
1218 | skb_linearize(skb)) |
1219 | return NULL; |
1220 | |
1221 | headroom = skb_headroom(skb); |
1222 | tailroom = skb_tailroom(skb); |
1223 | |
1224 | if (!(headroom >= sizeof(tx_desc) && tailroom >= padding_size)) { |
1225 | new_skb = skb_copy_expand(skb, newheadroom: sizeof(tx_desc), |
1226 | newtailroom: padding_size, priority: flags); |
1227 | dev_kfree_skb_any(skb); |
1228 | skb = new_skb; |
1229 | if (!skb) |
1230 | return NULL; |
1231 | } |
1232 | if (padding_size != 0) |
1233 | skb_put_zero(skb, len: padding_size); |
1234 | /* Copy TX header */ |
1235 | tx_desc_ptr = skb_push(skb, len: sizeof(tx_desc)); |
1236 | *tx_desc_ptr = cpu_to_le64(tx_desc); |
1237 | |
1238 | usbnet_set_skb_tx_stats(skb, packets: 1, bytes_delta: 0); |
1239 | |
1240 | return skb; |
1241 | } |
1242 | |
1243 | static const struct driver_info aqc111_info = { |
1244 | .description = "Aquantia AQtion USB to 5GbE Controller" , |
1245 | .bind = aqc111_bind, |
1246 | .unbind = aqc111_unbind, |
1247 | .status = aqc111_status, |
1248 | .link_reset = aqc111_link_reset, |
1249 | .reset = aqc111_reset, |
1250 | .stop = aqc111_stop, |
1251 | .flags = FLAG_ETHER | FLAG_FRAMING_AX | |
1252 | FLAG_AVOID_UNLINK_URBS | FLAG_MULTI_PACKET, |
1253 | .rx_fixup = aqc111_rx_fixup, |
1254 | .tx_fixup = aqc111_tx_fixup, |
1255 | }; |
1256 | |
1257 | #define ASIX111_DESC \ |
1258 | "ASIX USB 3.1 Gen1 to 5G Multi-Gigabit Ethernet Adapter" |
1259 | |
1260 | static const struct driver_info asix111_info = { |
1261 | .description = ASIX111_DESC, |
1262 | .bind = aqc111_bind, |
1263 | .unbind = aqc111_unbind, |
1264 | .status = aqc111_status, |
1265 | .link_reset = aqc111_link_reset, |
1266 | .reset = aqc111_reset, |
1267 | .stop = aqc111_stop, |
1268 | .flags = FLAG_ETHER | FLAG_FRAMING_AX | |
1269 | FLAG_AVOID_UNLINK_URBS | FLAG_MULTI_PACKET, |
1270 | .rx_fixup = aqc111_rx_fixup, |
1271 | .tx_fixup = aqc111_tx_fixup, |
1272 | }; |
1273 | |
1274 | #undef ASIX111_DESC |
1275 | |
1276 | #define ASIX112_DESC \ |
1277 | "ASIX USB 3.1 Gen1 to 2.5G Multi-Gigabit Ethernet Adapter" |
1278 | |
1279 | static const struct driver_info asix112_info = { |
1280 | .description = ASIX112_DESC, |
1281 | .bind = aqc111_bind, |
1282 | .unbind = aqc111_unbind, |
1283 | .status = aqc111_status, |
1284 | .link_reset = aqc111_link_reset, |
1285 | .reset = aqc111_reset, |
1286 | .stop = aqc111_stop, |
1287 | .flags = FLAG_ETHER | FLAG_FRAMING_AX | |
1288 | FLAG_AVOID_UNLINK_URBS | FLAG_MULTI_PACKET, |
1289 | .rx_fixup = aqc111_rx_fixup, |
1290 | .tx_fixup = aqc111_tx_fixup, |
1291 | }; |
1292 | |
1293 | #undef ASIX112_DESC |
1294 | |
1295 | static const struct driver_info trendnet_info = { |
1296 | .description = "USB-C 3.1 to 5GBASE-T Ethernet Adapter" , |
1297 | .bind = aqc111_bind, |
1298 | .unbind = aqc111_unbind, |
1299 | .status = aqc111_status, |
1300 | .link_reset = aqc111_link_reset, |
1301 | .reset = aqc111_reset, |
1302 | .stop = aqc111_stop, |
1303 | .flags = FLAG_ETHER | FLAG_FRAMING_AX | |
1304 | FLAG_AVOID_UNLINK_URBS | FLAG_MULTI_PACKET, |
1305 | .rx_fixup = aqc111_rx_fixup, |
1306 | .tx_fixup = aqc111_tx_fixup, |
1307 | }; |
1308 | |
1309 | static const struct driver_info qnap_info = { |
1310 | .description = "QNAP QNA-UC5G1T USB to 5GbE Adapter" , |
1311 | .bind = aqc111_bind, |
1312 | .unbind = aqc111_unbind, |
1313 | .status = aqc111_status, |
1314 | .link_reset = aqc111_link_reset, |
1315 | .reset = aqc111_reset, |
1316 | .stop = aqc111_stop, |
1317 | .flags = FLAG_ETHER | FLAG_FRAMING_AX | |
1318 | FLAG_AVOID_UNLINK_URBS | FLAG_MULTI_PACKET, |
1319 | .rx_fixup = aqc111_rx_fixup, |
1320 | .tx_fixup = aqc111_tx_fixup, |
1321 | }; |
1322 | |
1323 | static int aqc111_suspend(struct usb_interface *intf, pm_message_t message) |
1324 | { |
1325 | struct usbnet *dev = usb_get_intfdata(intf); |
1326 | struct aqc111_data *aqc111_data = dev->driver_priv; |
1327 | u16 temp_rx_ctrl = 0x00; |
1328 | u16 reg16; |
1329 | u8 reg8; |
1330 | |
1331 | usbnet_suspend(intf, message); |
1332 | |
1333 | aqc111_read16_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_RX_CTL, index: 2, data: ®16); |
1334 | temp_rx_ctrl = reg16; |
1335 | /* Stop RX operations*/ |
1336 | reg16 &= ~SFR_RX_CTL_START; |
1337 | aqc111_write16_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_RX_CTL, index: 2, data: ®16); |
1338 | /* Force bz */ |
1339 | aqc111_read16_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_PHYPWR_RSTCTL, |
1340 | index: 2, data: ®16); |
1341 | reg16 |= SFR_PHYPWR_RSTCTL_BZ; |
1342 | aqc111_write16_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_PHYPWR_RSTCTL, |
1343 | index: 2, data: ®16); |
1344 | |
1345 | reg8 = SFR_BULK_OUT_EFF_EN; |
1346 | aqc111_write_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_BULK_OUT_CTRL, |
1347 | index: 1, size: 1, data: ®8); |
1348 | |
1349 | temp_rx_ctrl &= ~(SFR_RX_CTL_START | SFR_RX_CTL_RF_WAK | |
1350 | SFR_RX_CTL_AP | SFR_RX_CTL_AM); |
1351 | aqc111_write16_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_RX_CTL, |
1352 | index: 2, data: &temp_rx_ctrl); |
1353 | |
1354 | reg8 = 0x00; |
1355 | aqc111_write_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_ETH_MAC_PATH, |
1356 | index: 1, size: 1, data: ®8); |
1357 | |
1358 | if (aqc111_data->wol_flags) { |
1359 | struct aqc111_wol_cfg wol_cfg; |
1360 | |
1361 | memset(&wol_cfg, 0, sizeof(struct aqc111_wol_cfg)); |
1362 | |
1363 | aqc111_data->phy_cfg |= AQ_WOL; |
1364 | ether_addr_copy(dst: wol_cfg.hw_addr, src: dev->net->dev_addr); |
1365 | wol_cfg.flags = aqc111_data->wol_flags; |
1366 | |
1367 | temp_rx_ctrl |= (SFR_RX_CTL_AB | SFR_RX_CTL_START); |
1368 | aqc111_write16_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_RX_CTL, |
1369 | index: 2, data: &temp_rx_ctrl); |
1370 | reg8 = 0x00; |
1371 | aqc111_write_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_BM_INT_MASK, |
1372 | index: 1, size: 1, data: ®8); |
1373 | reg8 = SFR_BMRX_DMA_EN; |
1374 | aqc111_write_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_BMRX_DMA_CONTROL, |
1375 | index: 1, size: 1, data: ®8); |
1376 | reg8 = SFR_RX_PATH_READY; |
1377 | aqc111_write_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_ETH_MAC_PATH, |
1378 | index: 1, size: 1, data: ®8); |
1379 | reg8 = 0x07; |
1380 | aqc111_write_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_RX_BULKIN_QCTRL, |
1381 | index: 1, size: 1, data: ®8); |
1382 | reg8 = 0x00; |
1383 | aqc111_write_cmd_nopm(dev, AQ_ACCESS_MAC, |
1384 | SFR_RX_BULKIN_QTIMR_LOW, index: 1, size: 1, data: ®8); |
1385 | aqc111_write_cmd_nopm(dev, AQ_ACCESS_MAC, |
1386 | SFR_RX_BULKIN_QTIMR_HIGH, index: 1, size: 1, data: ®8); |
1387 | reg8 = 0xFF; |
1388 | aqc111_write_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_RX_BULKIN_QSIZE, |
1389 | index: 1, size: 1, data: ®8); |
1390 | aqc111_write_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_RX_BULKIN_QIFG, |
1391 | index: 1, size: 1, data: ®8); |
1392 | |
1393 | aqc111_read16_cmd_nopm(dev, AQ_ACCESS_MAC, |
1394 | SFR_MEDIUM_STATUS_MODE, index: 2, data: ®16); |
1395 | reg16 |= SFR_MEDIUM_RECEIVE_EN; |
1396 | aqc111_write16_cmd_nopm(dev, AQ_ACCESS_MAC, |
1397 | SFR_MEDIUM_STATUS_MODE, index: 2, data: ®16); |
1398 | |
1399 | aqc111_write_cmd(dev, AQ_WOL_CFG, value: 0, index: 0, |
1400 | WOL_CFG_SIZE, data: &wol_cfg); |
1401 | aqc111_write32_cmd(dev, AQ_PHY_OPS, value: 0, index: 0, |
1402 | data: &aqc111_data->phy_cfg); |
1403 | } else { |
1404 | aqc111_data->phy_cfg |= AQ_LOW_POWER; |
1405 | aqc111_write32_cmd(dev, AQ_PHY_OPS, value: 0, index: 0, |
1406 | data: &aqc111_data->phy_cfg); |
1407 | |
1408 | /* Disable RX path */ |
1409 | aqc111_read16_cmd_nopm(dev, AQ_ACCESS_MAC, |
1410 | SFR_MEDIUM_STATUS_MODE, index: 2, data: ®16); |
1411 | reg16 &= ~SFR_MEDIUM_RECEIVE_EN; |
1412 | aqc111_write16_cmd_nopm(dev, AQ_ACCESS_MAC, |
1413 | SFR_MEDIUM_STATUS_MODE, index: 2, data: ®16); |
1414 | } |
1415 | |
1416 | return 0; |
1417 | } |
1418 | |
1419 | static int aqc111_resume(struct usb_interface *intf) |
1420 | { |
1421 | struct usbnet *dev = usb_get_intfdata(intf); |
1422 | struct aqc111_data *aqc111_data = dev->driver_priv; |
1423 | u16 reg16; |
1424 | u8 reg8; |
1425 | |
1426 | netif_carrier_off(dev: dev->net); |
1427 | |
1428 | /* Power up ethernet PHY */ |
1429 | aqc111_data->phy_cfg |= AQ_PHY_POWER_EN; |
1430 | aqc111_data->phy_cfg &= ~AQ_LOW_POWER; |
1431 | aqc111_data->phy_cfg &= ~AQ_WOL; |
1432 | |
1433 | reg8 = 0xFF; |
1434 | aqc111_write_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_BM_INT_MASK, |
1435 | index: 1, size: 1, data: ®8); |
1436 | /* Configure RX control register => start operation */ |
1437 | reg16 = aqc111_data->rxctl; |
1438 | reg16 &= ~SFR_RX_CTL_START; |
1439 | aqc111_write16_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_RX_CTL, index: 2, data: ®16); |
1440 | |
1441 | reg16 |= SFR_RX_CTL_START; |
1442 | aqc111_write16_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_RX_CTL, index: 2, data: ®16); |
1443 | |
1444 | aqc111_set_phy_speed(dev, autoneg: aqc111_data->autoneg, |
1445 | speed: aqc111_data->advertised_speed); |
1446 | |
1447 | aqc111_read16_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_MEDIUM_STATUS_MODE, |
1448 | index: 2, data: ®16); |
1449 | reg16 |= SFR_MEDIUM_RECEIVE_EN; |
1450 | aqc111_write16_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_MEDIUM_STATUS_MODE, |
1451 | index: 2, data: ®16); |
1452 | reg8 = SFR_RX_PATH_READY; |
1453 | aqc111_write_cmd_nopm(dev, AQ_ACCESS_MAC, SFR_ETH_MAC_PATH, |
1454 | index: 1, size: 1, data: ®8); |
1455 | reg8 = 0x0; |
1456 | aqc111_write_cmd(dev, AQ_ACCESS_MAC, SFR_BMRX_DMA_CONTROL, index: 1, size: 1, data: ®8); |
1457 | |
1458 | return usbnet_resume(intf); |
1459 | } |
1460 | |
1461 | #define AQC111_USB_ETH_DEV(vid, pid, table) \ |
1462 | USB_DEVICE_INTERFACE_CLASS((vid), (pid), USB_CLASS_VENDOR_SPEC), \ |
1463 | .driver_info = (unsigned long)&(table) \ |
1464 | }, \ |
1465 | { \ |
1466 | USB_DEVICE_AND_INTERFACE_INFO((vid), (pid), \ |
1467 | USB_CLASS_COMM, \ |
1468 | USB_CDC_SUBCLASS_ETHERNET, \ |
1469 | USB_CDC_PROTO_NONE), \ |
1470 | .driver_info = (unsigned long)&(table), |
1471 | |
1472 | static const struct usb_device_id products[] = { |
1473 | {AQC111_USB_ETH_DEV(0x2eca, 0xc101, aqc111_info)}, |
1474 | {AQC111_USB_ETH_DEV(0x0b95, 0x2790, asix111_info)}, |
1475 | {AQC111_USB_ETH_DEV(0x0b95, 0x2791, asix112_info)}, |
1476 | {AQC111_USB_ETH_DEV(0x20f4, 0xe05a, trendnet_info)}, |
1477 | {AQC111_USB_ETH_DEV(0x1c04, 0x0015, qnap_info)}, |
1478 | { },/* END */ |
1479 | }; |
1480 | MODULE_DEVICE_TABLE(usb, products); |
1481 | |
1482 | static struct usb_driver aq_driver = { |
1483 | .name = "aqc111" , |
1484 | .id_table = products, |
1485 | .probe = usbnet_probe, |
1486 | .suspend = aqc111_suspend, |
1487 | .resume = aqc111_resume, |
1488 | .disconnect = usbnet_disconnect, |
1489 | }; |
1490 | |
1491 | module_usb_driver(aq_driver); |
1492 | |
1493 | MODULE_DESCRIPTION("Aquantia AQtion USB to 5/2.5GbE Controllers" ); |
1494 | MODULE_LICENSE("GPL" ); |
1495 | |