asix_common.c

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