xref: /openbmc/linux/drivers/net/usb/asix_common.c (revision b4e18b29)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * ASIX AX8817X based USB 2.0 Ethernet Devices
4  * Copyright (C) 2003-2006 David Hollis <dhollis@davehollis.com>
5  * Copyright (C) 2005 Phil Chang <pchang23@sbcglobal.net>
6  * Copyright (C) 2006 James Painter <jamie.painter@iname.com>
7  * Copyright (c) 2002-2003 TiVo Inc.
8  */
9 
10 #include "asix.h"
11 
12 int asix_read_cmd(struct usbnet *dev, u8 cmd, u16 value, u16 index,
13 		  u16 size, void *data, int in_pm)
14 {
15 	int ret;
16 	int (*fn)(struct usbnet *, u8, u8, u16, u16, void *, u16);
17 
18 	BUG_ON(!dev);
19 
20 	if (!in_pm)
21 		fn = usbnet_read_cmd;
22 	else
23 		fn = usbnet_read_cmd_nopm;
24 
25 	ret = fn(dev, cmd, USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
26 		 value, index, data, size);
27 
28 	if (unlikely(ret < 0))
29 		netdev_warn(dev->net, "Failed to read reg index 0x%04x: %d\n",
30 			    index, ret);
31 
32 	return ret;
33 }
34 
35 int asix_write_cmd(struct usbnet *dev, u8 cmd, u16 value, u16 index,
36 		   u16 size, void *data, int in_pm)
37 {
38 	int ret;
39 	int (*fn)(struct usbnet *, u8, u8, u16, u16, const void *, u16);
40 
41 	BUG_ON(!dev);
42 
43 	if (!in_pm)
44 		fn = usbnet_write_cmd;
45 	else
46 		fn = usbnet_write_cmd_nopm;
47 
48 	ret = fn(dev, cmd, USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
49 		 value, index, data, size);
50 
51 	if (unlikely(ret < 0))
52 		netdev_warn(dev->net, "Failed to write reg index 0x%04x: %d\n",
53 			    index, ret);
54 
55 	return ret;
56 }
57 
58 void asix_write_cmd_async(struct usbnet *dev, u8 cmd, u16 value, u16 index,
59 			  u16 size, void *data)
60 {
61 	usbnet_write_cmd_async(dev, cmd,
62 			       USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
63 			       value, index, data, size);
64 }
65 
66 static void reset_asix_rx_fixup_info(struct asix_rx_fixup_info *rx)
67 {
68 	/* Reset the variables that have a lifetime outside of
69 	 * asix_rx_fixup_internal() so that future processing starts from a
70 	 * known set of initial conditions.
71 	 */
72 
73 	if (rx->ax_skb) {
74 		/* Discard any incomplete Ethernet frame in the netdev buffer */
75 		kfree_skb(rx->ax_skb);
76 		rx->ax_skb = NULL;
77 	}
78 
79 	/* Assume the Data header 32-bit word is at the start of the current
80 	 * or next URB socket buffer so reset all the state variables.
81 	 */
82 	rx->remaining = 0;
83 	rx->split_head = false;
84 	rx->header = 0;
85 }
86 
87 int asix_rx_fixup_internal(struct usbnet *dev, struct sk_buff *skb,
88 			   struct asix_rx_fixup_info *rx)
89 {
90 	int offset = 0;
91 	u16 size;
92 
93 	/* When an Ethernet frame spans multiple URB socket buffers,
94 	 * do a sanity test for the Data header synchronisation.
95 	 * Attempt to detect the situation of the previous socket buffer having
96 	 * been truncated or a socket buffer was missing. These situations
97 	 * cause a discontinuity in the data stream and therefore need to avoid
98 	 * appending bad data to the end of the current netdev socket buffer.
99 	 * Also avoid unnecessarily discarding a good current netdev socket
100 	 * buffer.
101 	 */
102 	if (rx->remaining && (rx->remaining + sizeof(u32) <= skb->len)) {
103 		offset = ((rx->remaining + 1) & 0xfffe);
104 		rx->header = get_unaligned_le32(skb->data + offset);
105 		offset = 0;
106 
107 		size = (u16)(rx->header & 0x7ff);
108 		if (size != ((~rx->header >> 16) & 0x7ff)) {
109 			netdev_err(dev->net, "asix_rx_fixup() Data Header synchronisation was lost, remaining %d\n",
110 				   rx->remaining);
111 			reset_asix_rx_fixup_info(rx);
112 		}
113 	}
114 
115 	while (offset + sizeof(u16) <= skb->len) {
116 		u16 copy_length;
117 
118 		if (!rx->remaining) {
119 			if (skb->len - offset == sizeof(u16)) {
120 				rx->header = get_unaligned_le16(
121 						skb->data + offset);
122 				rx->split_head = true;
123 				offset += sizeof(u16);
124 				break;
125 			}
126 
127 			if (rx->split_head == true) {
128 				rx->header |= (get_unaligned_le16(
129 						skb->data + offset) << 16);
130 				rx->split_head = false;
131 				offset += sizeof(u16);
132 			} else {
133 				rx->header = get_unaligned_le32(skb->data +
134 								offset);
135 				offset += sizeof(u32);
136 			}
137 
138 			/* take frame length from Data header 32-bit word */
139 			size = (u16)(rx->header & 0x7ff);
140 			if (size != ((~rx->header >> 16) & 0x7ff)) {
141 				netdev_err(dev->net, "asix_rx_fixup() Bad Header Length 0x%x, offset %d\n",
142 					   rx->header, offset);
143 				reset_asix_rx_fixup_info(rx);
144 				return 0;
145 			}
146 			if (size > dev->net->mtu + ETH_HLEN + VLAN_HLEN) {
147 				netdev_dbg(dev->net, "asix_rx_fixup() Bad RX Length %d\n",
148 					   size);
149 				reset_asix_rx_fixup_info(rx);
150 				return 0;
151 			}
152 
153 			/* Sometimes may fail to get a netdev socket buffer but
154 			 * continue to process the URB socket buffer so that
155 			 * synchronisation of the Ethernet frame Data header
156 			 * word is maintained.
157 			 */
158 			rx->ax_skb = netdev_alloc_skb_ip_align(dev->net, size);
159 
160 			rx->remaining = size;
161 		}
162 
163 		if (rx->remaining > skb->len - offset) {
164 			copy_length = skb->len - offset;
165 			rx->remaining -= copy_length;
166 		} else {
167 			copy_length = rx->remaining;
168 			rx->remaining = 0;
169 		}
170 
171 		if (rx->ax_skb) {
172 			skb_put_data(rx->ax_skb, skb->data + offset,
173 				     copy_length);
174 			if (!rx->remaining) {
175 				usbnet_skb_return(dev, rx->ax_skb);
176 				rx->ax_skb = NULL;
177 			}
178 		}
179 
180 		offset += (copy_length + 1) & 0xfffe;
181 	}
182 
183 	if (skb->len != offset) {
184 		netdev_err(dev->net, "asix_rx_fixup() Bad SKB Length %d, %d\n",
185 			   skb->len, offset);
186 		reset_asix_rx_fixup_info(rx);
187 		return 0;
188 	}
189 
190 	return 1;
191 }
192 
193 int asix_rx_fixup_common(struct usbnet *dev, struct sk_buff *skb)
194 {
195 	struct asix_common_private *dp = dev->driver_priv;
196 	struct asix_rx_fixup_info *rx = &dp->rx_fixup_info;
197 
198 	return asix_rx_fixup_internal(dev, skb, rx);
199 }
200 
201 void asix_rx_fixup_common_free(struct asix_common_private *dp)
202 {
203 	struct asix_rx_fixup_info *rx;
204 
205 	if (!dp)
206 		return;
207 
208 	rx = &dp->rx_fixup_info;
209 
210 	if (rx->ax_skb) {
211 		kfree_skb(rx->ax_skb);
212 		rx->ax_skb = NULL;
213 	}
214 }
215 
216 struct sk_buff *asix_tx_fixup(struct usbnet *dev, struct sk_buff *skb,
217 			      gfp_t flags)
218 {
219 	int padlen;
220 	int headroom = skb_headroom(skb);
221 	int tailroom = skb_tailroom(skb);
222 	u32 packet_len;
223 	u32 padbytes = 0xffff0000;
224 	void *ptr;
225 
226 	padlen = ((skb->len + 4) & (dev->maxpacket - 1)) ? 0 : 4;
227 
228 	/* We need to push 4 bytes in front of frame (packet_len)
229 	 * and maybe add 4 bytes after the end (if padlen is 4)
230 	 *
231 	 * Avoid skb_copy_expand() expensive call, using following rules :
232 	 * - We are allowed to push 4 bytes in headroom if skb_header_cloned()
233 	 *   is false (and if we have 4 bytes of headroom)
234 	 * - We are allowed to put 4 bytes at tail if skb_cloned()
235 	 *   is false (and if we have 4 bytes of tailroom)
236 	 *
237 	 * TCP packets for example are cloned, but __skb_header_release()
238 	 * was called in tcp stack, allowing us to use headroom for our needs.
239 	 */
240 	if (!skb_header_cloned(skb) &&
241 	    !(padlen && skb_cloned(skb)) &&
242 	    headroom + tailroom >= 4 + padlen) {
243 		/* following should not happen, but better be safe */
244 		if (headroom < 4 ||
245 		    tailroom < padlen) {
246 			skb->data = memmove(skb->head + 4, skb->data, skb->len);
247 			skb_set_tail_pointer(skb, skb->len);
248 		}
249 	} else {
250 		struct sk_buff *skb2;
251 
252 		skb2 = skb_copy_expand(skb, 4, padlen, flags);
253 		dev_kfree_skb_any(skb);
254 		skb = skb2;
255 		if (!skb)
256 			return NULL;
257 	}
258 
259 	packet_len = ((skb->len ^ 0x0000ffff) << 16) + skb->len;
260 	ptr = skb_push(skb, 4);
261 	put_unaligned_le32(packet_len, ptr);
262 
263 	if (padlen) {
264 		put_unaligned_le32(padbytes, skb_tail_pointer(skb));
265 		skb_put(skb, sizeof(padbytes));
266 	}
267 
268 	usbnet_set_skb_tx_stats(skb, 1, 0);
269 	return skb;
270 }
271 
272 int asix_set_sw_mii(struct usbnet *dev, int in_pm)
273 {
274 	int ret;
275 	ret = asix_write_cmd(dev, AX_CMD_SET_SW_MII, 0x0000, 0, 0, NULL, in_pm);
276 
277 	if (ret < 0)
278 		netdev_err(dev->net, "Failed to enable software MII access\n");
279 	return ret;
280 }
281 
282 int asix_set_hw_mii(struct usbnet *dev, int in_pm)
283 {
284 	int ret;
285 	ret = asix_write_cmd(dev, AX_CMD_SET_HW_MII, 0x0000, 0, 0, NULL, in_pm);
286 	if (ret < 0)
287 		netdev_err(dev->net, "Failed to enable hardware MII access\n");
288 	return ret;
289 }
290 
291 int asix_read_phy_addr(struct usbnet *dev, int internal)
292 {
293 	int offset = (internal ? 1 : 0);
294 	u8 buf[2];
295 	int ret = asix_read_cmd(dev, AX_CMD_READ_PHY_ID, 0, 0, 2, buf, 0);
296 
297 	netdev_dbg(dev->net, "asix_get_phy_addr()\n");
298 
299 	if (ret < 2) {
300 		netdev_err(dev->net, "Error reading PHYID register: %02x\n", ret);
301 		goto out;
302 	}
303 	netdev_dbg(dev->net, "asix_get_phy_addr() returning 0x%04x\n",
304 		   *((__le16 *)buf));
305 	ret = buf[offset];
306 
307 out:
308 	return ret;
309 }
310 
311 int asix_get_phy_addr(struct usbnet *dev)
312 {
313 	/* return the address of the internal phy */
314 	return asix_read_phy_addr(dev, 1);
315 }
316 
317 
318 int asix_sw_reset(struct usbnet *dev, u8 flags, int in_pm)
319 {
320 	int ret;
321 
322 	ret = asix_write_cmd(dev, AX_CMD_SW_RESET, flags, 0, 0, NULL, in_pm);
323 	if (ret < 0)
324 		netdev_err(dev->net, "Failed to send software reset: %02x\n", ret);
325 
326 	return ret;
327 }
328 
329 u16 asix_read_rx_ctl(struct usbnet *dev, int in_pm)
330 {
331 	__le16 v;
332 	int ret = asix_read_cmd(dev, AX_CMD_READ_RX_CTL, 0, 0, 2, &v, in_pm);
333 
334 	if (ret < 0) {
335 		netdev_err(dev->net, "Error reading RX_CTL register: %02x\n", ret);
336 		goto out;
337 	}
338 	ret = le16_to_cpu(v);
339 out:
340 	return ret;
341 }
342 
343 int asix_write_rx_ctl(struct usbnet *dev, u16 mode, int in_pm)
344 {
345 	int ret;
346 
347 	netdev_dbg(dev->net, "asix_write_rx_ctl() - mode = 0x%04x\n", mode);
348 	ret = asix_write_cmd(dev, AX_CMD_WRITE_RX_CTL, mode, 0, 0, NULL, in_pm);
349 	if (ret < 0)
350 		netdev_err(dev->net, "Failed to write RX_CTL mode to 0x%04x: %02x\n",
351 			   mode, ret);
352 
353 	return ret;
354 }
355 
356 u16 asix_read_medium_status(struct usbnet *dev, int in_pm)
357 {
358 	__le16 v;
359 	int ret = asix_read_cmd(dev, AX_CMD_READ_MEDIUM_STATUS,
360 				0, 0, 2, &v, in_pm);
361 
362 	if (ret < 0) {
363 		netdev_err(dev->net, "Error reading Medium Status register: %02x\n",
364 			   ret);
365 		return ret;	/* TODO: callers not checking for error ret */
366 	}
367 
368 	return le16_to_cpu(v);
369 
370 }
371 
372 int asix_write_medium_mode(struct usbnet *dev, u16 mode, int in_pm)
373 {
374 	int ret;
375 
376 	netdev_dbg(dev->net, "asix_write_medium_mode() - mode = 0x%04x\n", mode);
377 	ret = asix_write_cmd(dev, AX_CMD_WRITE_MEDIUM_MODE,
378 			     mode, 0, 0, NULL, in_pm);
379 	if (ret < 0)
380 		netdev_err(dev->net, "Failed to write Medium Mode mode to 0x%04x: %02x\n",
381 			   mode, ret);
382 
383 	return ret;
384 }
385 
386 int asix_write_gpio(struct usbnet *dev, u16 value, int sleep, int in_pm)
387 {
388 	int ret;
389 
390 	netdev_dbg(dev->net, "asix_write_gpio() - value = 0x%04x\n", value);
391 	ret = asix_write_cmd(dev, AX_CMD_WRITE_GPIOS, value, 0, 0, NULL, in_pm);
392 	if (ret < 0)
393 		netdev_err(dev->net, "Failed to write GPIO value 0x%04x: %02x\n",
394 			   value, ret);
395 
396 	if (sleep)
397 		msleep(sleep);
398 
399 	return ret;
400 }
401 
402 /*
403  * AX88772 & AX88178 have a 16-bit RX_CTL value
404  */
405 void asix_set_multicast(struct net_device *net)
406 {
407 	struct usbnet *dev = netdev_priv(net);
408 	struct asix_data *data = (struct asix_data *)&dev->data;
409 	u16 rx_ctl = AX_DEFAULT_RX_CTL;
410 
411 	if (net->flags & IFF_PROMISC) {
412 		rx_ctl |= AX_RX_CTL_PRO;
413 	} else if (net->flags & IFF_ALLMULTI ||
414 		   netdev_mc_count(net) > AX_MAX_MCAST) {
415 		rx_ctl |= AX_RX_CTL_AMALL;
416 	} else if (netdev_mc_empty(net)) {
417 		/* just broadcast and directed */
418 	} else {
419 		/* We use the 20 byte dev->data
420 		 * for our 8 byte filter buffer
421 		 * to avoid allocating memory that
422 		 * is tricky to free later */
423 		struct netdev_hw_addr *ha;
424 		u32 crc_bits;
425 
426 		memset(data->multi_filter, 0, AX_MCAST_FILTER_SIZE);
427 
428 		/* Build the multicast hash filter. */
429 		netdev_for_each_mc_addr(ha, net) {
430 			crc_bits = ether_crc(ETH_ALEN, ha->addr) >> 26;
431 			data->multi_filter[crc_bits >> 3] |=
432 			    1 << (crc_bits & 7);
433 		}
434 
435 		asix_write_cmd_async(dev, AX_CMD_WRITE_MULTI_FILTER, 0, 0,
436 				   AX_MCAST_FILTER_SIZE, data->multi_filter);
437 
438 		rx_ctl |= AX_RX_CTL_AM;
439 	}
440 
441 	asix_write_cmd_async(dev, AX_CMD_WRITE_RX_CTL, rx_ctl, 0, 0, NULL);
442 }
443 
444 int asix_mdio_read(struct net_device *netdev, int phy_id, int loc)
445 {
446 	struct usbnet *dev = netdev_priv(netdev);
447 	__le16 res;
448 	u8 smsr;
449 	int i = 0;
450 	int ret;
451 
452 	mutex_lock(&dev->phy_mutex);
453 	do {
454 		ret = asix_set_sw_mii(dev, 0);
455 		if (ret == -ENODEV || ret == -ETIMEDOUT)
456 			break;
457 		usleep_range(1000, 1100);
458 		ret = asix_read_cmd(dev, AX_CMD_STATMNGSTS_REG,
459 				    0, 0, 1, &smsr, 0);
460 	} while (!(smsr & AX_HOST_EN) && (i++ < 30) && (ret != -ENODEV));
461 	if (ret == -ENODEV || ret == -ETIMEDOUT) {
462 		mutex_unlock(&dev->phy_mutex);
463 		return ret;
464 	}
465 
466 	asix_read_cmd(dev, AX_CMD_READ_MII_REG, phy_id,
467 				(__u16)loc, 2, &res, 0);
468 	asix_set_hw_mii(dev, 0);
469 	mutex_unlock(&dev->phy_mutex);
470 
471 	netdev_dbg(dev->net, "asix_mdio_read() phy_id=0x%02x, loc=0x%02x, returns=0x%04x\n",
472 			phy_id, loc, le16_to_cpu(res));
473 
474 	return le16_to_cpu(res);
475 }
476 
477 void asix_mdio_write(struct net_device *netdev, int phy_id, int loc, int val)
478 {
479 	struct usbnet *dev = netdev_priv(netdev);
480 	__le16 res = cpu_to_le16(val);
481 	u8 smsr;
482 	int i = 0;
483 	int ret;
484 
485 	netdev_dbg(dev->net, "asix_mdio_write() phy_id=0x%02x, loc=0x%02x, val=0x%04x\n",
486 			phy_id, loc, val);
487 
488 	mutex_lock(&dev->phy_mutex);
489 	do {
490 		ret = asix_set_sw_mii(dev, 0);
491 		if (ret == -ENODEV)
492 			break;
493 		usleep_range(1000, 1100);
494 		ret = asix_read_cmd(dev, AX_CMD_STATMNGSTS_REG,
495 				    0, 0, 1, &smsr, 0);
496 	} while (!(smsr & AX_HOST_EN) && (i++ < 30) && (ret != -ENODEV));
497 	if (ret == -ENODEV) {
498 		mutex_unlock(&dev->phy_mutex);
499 		return;
500 	}
501 
502 	asix_write_cmd(dev, AX_CMD_WRITE_MII_REG, phy_id,
503 		       (__u16)loc, 2, &res, 0);
504 	asix_set_hw_mii(dev, 0);
505 	mutex_unlock(&dev->phy_mutex);
506 }
507 
508 int asix_mdio_read_nopm(struct net_device *netdev, int phy_id, int loc)
509 {
510 	struct usbnet *dev = netdev_priv(netdev);
511 	__le16 res;
512 	u8 smsr;
513 	int i = 0;
514 	int ret;
515 
516 	mutex_lock(&dev->phy_mutex);
517 	do {
518 		ret = asix_set_sw_mii(dev, 1);
519 		if (ret == -ENODEV || ret == -ETIMEDOUT)
520 			break;
521 		usleep_range(1000, 1100);
522 		ret = asix_read_cmd(dev, AX_CMD_STATMNGSTS_REG,
523 				    0, 0, 1, &smsr, 1);
524 	} while (!(smsr & AX_HOST_EN) && (i++ < 30) && (ret != -ENODEV));
525 	if (ret == -ENODEV || ret == -ETIMEDOUT) {
526 		mutex_unlock(&dev->phy_mutex);
527 		return ret;
528 	}
529 
530 	asix_read_cmd(dev, AX_CMD_READ_MII_REG, phy_id,
531 		      (__u16)loc, 2, &res, 1);
532 	asix_set_hw_mii(dev, 1);
533 	mutex_unlock(&dev->phy_mutex);
534 
535 	netdev_dbg(dev->net, "asix_mdio_read_nopm() phy_id=0x%02x, loc=0x%02x, returns=0x%04x\n",
536 			phy_id, loc, le16_to_cpu(res));
537 
538 	return le16_to_cpu(res);
539 }
540 
541 void
542 asix_mdio_write_nopm(struct net_device *netdev, int phy_id, int loc, int val)
543 {
544 	struct usbnet *dev = netdev_priv(netdev);
545 	__le16 res = cpu_to_le16(val);
546 	u8 smsr;
547 	int i = 0;
548 	int ret;
549 
550 	netdev_dbg(dev->net, "asix_mdio_write() phy_id=0x%02x, loc=0x%02x, val=0x%04x\n",
551 			phy_id, loc, val);
552 
553 	mutex_lock(&dev->phy_mutex);
554 	do {
555 		ret = asix_set_sw_mii(dev, 1);
556 		if (ret == -ENODEV)
557 			break;
558 		usleep_range(1000, 1100);
559 		ret = asix_read_cmd(dev, AX_CMD_STATMNGSTS_REG,
560 				    0, 0, 1, &smsr, 1);
561 	} while (!(smsr & AX_HOST_EN) && (i++ < 30) && (ret != -ENODEV));
562 	if (ret == -ENODEV) {
563 		mutex_unlock(&dev->phy_mutex);
564 		return;
565 	}
566 
567 	asix_write_cmd(dev, AX_CMD_WRITE_MII_REG, phy_id,
568 		       (__u16)loc, 2, &res, 1);
569 	asix_set_hw_mii(dev, 1);
570 	mutex_unlock(&dev->phy_mutex);
571 }
572 
573 void asix_get_wol(struct net_device *net, struct ethtool_wolinfo *wolinfo)
574 {
575 	struct usbnet *dev = netdev_priv(net);
576 	u8 opt;
577 
578 	if (asix_read_cmd(dev, AX_CMD_READ_MONITOR_MODE,
579 			  0, 0, 1, &opt, 0) < 0) {
580 		wolinfo->supported = 0;
581 		wolinfo->wolopts = 0;
582 		return;
583 	}
584 	wolinfo->supported = WAKE_PHY | WAKE_MAGIC;
585 	wolinfo->wolopts = 0;
586 	if (opt & AX_MONITOR_LINK)
587 		wolinfo->wolopts |= WAKE_PHY;
588 	if (opt & AX_MONITOR_MAGIC)
589 		wolinfo->wolopts |= WAKE_MAGIC;
590 }
591 
592 int asix_set_wol(struct net_device *net, struct ethtool_wolinfo *wolinfo)
593 {
594 	struct usbnet *dev = netdev_priv(net);
595 	u8 opt = 0;
596 
597 	if (wolinfo->wolopts & ~(WAKE_PHY | WAKE_MAGIC))
598 		return -EINVAL;
599 
600 	if (wolinfo->wolopts & WAKE_PHY)
601 		opt |= AX_MONITOR_LINK;
602 	if (wolinfo->wolopts & WAKE_MAGIC)
603 		opt |= AX_MONITOR_MAGIC;
604 
605 	if (asix_write_cmd(dev, AX_CMD_WRITE_MONITOR_MODE,
606 			      opt, 0, 0, NULL, 0) < 0)
607 		return -EINVAL;
608 
609 	return 0;
610 }
611 
612 int asix_get_eeprom_len(struct net_device *net)
613 {
614 	return AX_EEPROM_LEN;
615 }
616 
617 int asix_get_eeprom(struct net_device *net, struct ethtool_eeprom *eeprom,
618 		    u8 *data)
619 {
620 	struct usbnet *dev = netdev_priv(net);
621 	u16 *eeprom_buff;
622 	int first_word, last_word;
623 	int i;
624 
625 	if (eeprom->len == 0)
626 		return -EINVAL;
627 
628 	eeprom->magic = AX_EEPROM_MAGIC;
629 
630 	first_word = eeprom->offset >> 1;
631 	last_word = (eeprom->offset + eeprom->len - 1) >> 1;
632 
633 	eeprom_buff = kmalloc_array(last_word - first_word + 1, sizeof(u16),
634 				    GFP_KERNEL);
635 	if (!eeprom_buff)
636 		return -ENOMEM;
637 
638 	/* ax8817x returns 2 bytes from eeprom on read */
639 	for (i = first_word; i <= last_word; i++) {
640 		if (asix_read_cmd(dev, AX_CMD_READ_EEPROM, i, 0, 2,
641 				  &eeprom_buff[i - first_word], 0) < 0) {
642 			kfree(eeprom_buff);
643 			return -EIO;
644 		}
645 	}
646 
647 	memcpy(data, (u8 *)eeprom_buff + (eeprom->offset & 1), eeprom->len);
648 	kfree(eeprom_buff);
649 	return 0;
650 }
651 
652 int asix_set_eeprom(struct net_device *net, struct ethtool_eeprom *eeprom,
653 		    u8 *data)
654 {
655 	struct usbnet *dev = netdev_priv(net);
656 	u16 *eeprom_buff;
657 	int first_word, last_word;
658 	int i;
659 	int ret;
660 
661 	netdev_dbg(net, "write EEPROM len %d, offset %d, magic 0x%x\n",
662 		   eeprom->len, eeprom->offset, eeprom->magic);
663 
664 	if (eeprom->len == 0)
665 		return -EINVAL;
666 
667 	if (eeprom->magic != AX_EEPROM_MAGIC)
668 		return -EINVAL;
669 
670 	first_word = eeprom->offset >> 1;
671 	last_word = (eeprom->offset + eeprom->len - 1) >> 1;
672 
673 	eeprom_buff = kmalloc_array(last_word - first_word + 1, sizeof(u16),
674 				    GFP_KERNEL);
675 	if (!eeprom_buff)
676 		return -ENOMEM;
677 
678 	/* align data to 16 bit boundaries, read the missing data from
679 	   the EEPROM */
680 	if (eeprom->offset & 1) {
681 		ret = asix_read_cmd(dev, AX_CMD_READ_EEPROM, first_word, 0, 2,
682 				    &eeprom_buff[0], 0);
683 		if (ret < 0) {
684 			netdev_err(net, "Failed to read EEPROM at offset 0x%02x.\n", first_word);
685 			goto free;
686 		}
687 	}
688 
689 	if ((eeprom->offset + eeprom->len) & 1) {
690 		ret = asix_read_cmd(dev, AX_CMD_READ_EEPROM, last_word, 0, 2,
691 				    &eeprom_buff[last_word - first_word], 0);
692 		if (ret < 0) {
693 			netdev_err(net, "Failed to read EEPROM at offset 0x%02x.\n", last_word);
694 			goto free;
695 		}
696 	}
697 
698 	memcpy((u8 *)eeprom_buff + (eeprom->offset & 1), data, eeprom->len);
699 
700 	/* write data to EEPROM */
701 	ret = asix_write_cmd(dev, AX_CMD_WRITE_ENABLE, 0x0000, 0, 0, NULL, 0);
702 	if (ret < 0) {
703 		netdev_err(net, "Failed to enable EEPROM write\n");
704 		goto free;
705 	}
706 	msleep(20);
707 
708 	for (i = first_word; i <= last_word; i++) {
709 		netdev_dbg(net, "write to EEPROM at offset 0x%02x, data 0x%04x\n",
710 			   i, eeprom_buff[i - first_word]);
711 		ret = asix_write_cmd(dev, AX_CMD_WRITE_EEPROM, i,
712 				     eeprom_buff[i - first_word], 0, NULL, 0);
713 		if (ret < 0) {
714 			netdev_err(net, "Failed to write EEPROM at offset 0x%02x.\n",
715 				   i);
716 			goto free;
717 		}
718 		msleep(20);
719 	}
720 
721 	ret = asix_write_cmd(dev, AX_CMD_WRITE_DISABLE, 0x0000, 0, 0, NULL, 0);
722 	if (ret < 0) {
723 		netdev_err(net, "Failed to disable EEPROM write\n");
724 		goto free;
725 	}
726 
727 	ret = 0;
728 free:
729 	kfree(eeprom_buff);
730 	return ret;
731 }
732 
733 void asix_get_drvinfo(struct net_device *net, struct ethtool_drvinfo *info)
734 {
735 	/* Inherit standard device info */
736 	usbnet_get_drvinfo(net, info);
737 	strlcpy(info->driver, DRIVER_NAME, sizeof(info->driver));
738 	strlcpy(info->version, DRIVER_VERSION, sizeof(info->version));
739 }
740 
741 int asix_set_mac_address(struct net_device *net, void *p)
742 {
743 	struct usbnet *dev = netdev_priv(net);
744 	struct asix_data *data = (struct asix_data *)&dev->data;
745 	struct sockaddr *addr = p;
746 
747 	if (netif_running(net))
748 		return -EBUSY;
749 	if (!is_valid_ether_addr(addr->sa_data))
750 		return -EADDRNOTAVAIL;
751 
752 	memcpy(net->dev_addr, addr->sa_data, ETH_ALEN);
753 
754 	/* We use the 20 byte dev->data
755 	 * for our 6 byte mac buffer
756 	 * to avoid allocating memory that
757 	 * is tricky to free later */
758 	memcpy(data->mac_addr, addr->sa_data, ETH_ALEN);
759 	asix_write_cmd_async(dev, AX_CMD_WRITE_NODE_ID, 0, 0, ETH_ALEN,
760 							data->mac_addr);
761 
762 	return 0;
763 }
764