xref: /linux/drivers/net/usb/asix_common.c (revision 4f2c0a4acffbec01079c28f839422e64ddeff004)
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  
asix_read_cmd(struct usbnet * dev,u8 cmd,u16 value,u16 index,u16 size,void * data,int in_pm)14  int __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  
asix_write_cmd(struct usbnet * dev,u8 cmd,u16 value,u16 index,u16 size,void * data,int in_pm)40  int 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  
asix_write_cmd_async(struct usbnet * dev,u8 cmd,u16 value,u16 index,u16 size,void * data)63  void 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  
asix_set_sw_mii(struct usbnet * dev,int in_pm)71  static 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  
asix_set_hw_mii(struct usbnet * dev,int in_pm)82  static 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  
asix_check_host_enable(struct usbnet * dev,int in_pm)92  static 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  
reset_asix_rx_fixup_info(struct asix_rx_fixup_info * rx)115  static 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  
asix_rx_fixup_internal(struct usbnet * dev,struct sk_buff * skb,struct asix_rx_fixup_info * rx)136  int 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  
asix_rx_fixup_common(struct usbnet * dev,struct sk_buff * skb)242  int 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  
asix_rx_fixup_common_free(struct asix_common_private * dp)250  void 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  
asix_tx_fixup(struct usbnet * dev,struct sk_buff * skb,gfp_t flags)265  struct 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  
asix_read_phy_addr(struct usbnet * dev,bool internal)321  int 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  	netdev_dbg(dev->net, "%s PHY address 0x%x\n",
339  		   internal ? "internal" : "external", ret);
340  
341  	return ret;
342  
343  error:
344  	netdev_err(dev->net, "Error reading PHY_ID register: %02x\n", ret);
345  
346  	return ret;
347  }
348  
asix_sw_reset(struct usbnet * dev,u8 flags,int in_pm)349  int asix_sw_reset(struct usbnet *dev, u8 flags, int in_pm)
350  {
351  	int ret;
352  
353  	ret = asix_write_cmd(dev, AX_CMD_SW_RESET, flags, 0, 0, NULL, in_pm);
354  	if (ret < 0)
355  		netdev_err(dev->net, "Failed to send software reset: %02x\n", ret);
356  
357  	return ret;
358  }
359  
asix_read_rx_ctl(struct usbnet * dev,int in_pm)360  u16 asix_read_rx_ctl(struct usbnet *dev, int in_pm)
361  {
362  	__le16 v;
363  	int ret = asix_read_cmd(dev, AX_CMD_READ_RX_CTL, 0, 0, 2, &v, in_pm);
364  
365  	if (ret < 0) {
366  		netdev_err(dev->net, "Error reading RX_CTL register: %02x\n", ret);
367  		goto out;
368  	}
369  	ret = le16_to_cpu(v);
370  out:
371  	return ret;
372  }
373  
asix_write_rx_ctl(struct usbnet * dev,u16 mode,int in_pm)374  int asix_write_rx_ctl(struct usbnet *dev, u16 mode, int in_pm)
375  {
376  	int ret;
377  
378  	netdev_dbg(dev->net, "asix_write_rx_ctl() - mode = 0x%04x\n", mode);
379  	ret = asix_write_cmd(dev, AX_CMD_WRITE_RX_CTL, mode, 0, 0, NULL, in_pm);
380  	if (ret < 0)
381  		netdev_err(dev->net, "Failed to write RX_CTL mode to 0x%04x: %02x\n",
382  			   mode, ret);
383  
384  	return ret;
385  }
386  
asix_read_medium_status(struct usbnet * dev,int in_pm)387  u16 asix_read_medium_status(struct usbnet *dev, int in_pm)
388  {
389  	__le16 v;
390  	int ret = asix_read_cmd(dev, AX_CMD_READ_MEDIUM_STATUS,
391  				0, 0, 2, &v, in_pm);
392  
393  	if (ret < 0) {
394  		netdev_err(dev->net, "Error reading Medium Status register: %02x\n",
395  			   ret);
396  		return ret;	/* TODO: callers not checking for error ret */
397  	}
398  
399  	return le16_to_cpu(v);
400  
401  }
402  
asix_write_medium_mode(struct usbnet * dev,u16 mode,int in_pm)403  int asix_write_medium_mode(struct usbnet *dev, u16 mode, int in_pm)
404  {
405  	int ret;
406  
407  	netdev_dbg(dev->net, "asix_write_medium_mode() - mode = 0x%04x\n", mode);
408  	ret = asix_write_cmd(dev, AX_CMD_WRITE_MEDIUM_MODE,
409  			     mode, 0, 0, NULL, in_pm);
410  	if (ret < 0)
411  		netdev_err(dev->net, "Failed to write Medium Mode mode to 0x%04x: %02x\n",
412  			   mode, ret);
413  
414  	return ret;
415  }
416  
417  /* set MAC link settings according to information from phylib */
asix_adjust_link(struct net_device * netdev)418  void asix_adjust_link(struct net_device *netdev)
419  {
420  	struct phy_device *phydev = netdev->phydev;
421  	struct usbnet *dev = netdev_priv(netdev);
422  	u16 mode = 0;
423  
424  	if (phydev->link) {
425  		mode = AX88772_MEDIUM_DEFAULT;
426  
427  		if (phydev->duplex == DUPLEX_HALF)
428  			mode &= ~AX_MEDIUM_FD;
429  
430  		if (phydev->speed != SPEED_100)
431  			mode &= ~AX_MEDIUM_PS;
432  	}
433  
434  	asix_write_medium_mode(dev, mode, 0);
435  	phy_print_status(phydev);
436  	usbnet_link_change(dev, phydev->link, 0);
437  }
438  
asix_write_gpio(struct usbnet * dev,u16 value,int sleep,int in_pm)439  int asix_write_gpio(struct usbnet *dev, u16 value, int sleep, int in_pm)
440  {
441  	int ret;
442  
443  	netdev_dbg(dev->net, "asix_write_gpio() - value = 0x%04x\n", value);
444  	ret = asix_write_cmd(dev, AX_CMD_WRITE_GPIOS, value, 0, 0, NULL, in_pm);
445  	if (ret < 0)
446  		netdev_err(dev->net, "Failed to write GPIO value 0x%04x: %02x\n",
447  			   value, ret);
448  
449  	if (sleep)
450  		msleep(sleep);
451  
452  	return ret;
453  }
454  
455  /*
456   * AX88772 & AX88178 have a 16-bit RX_CTL value
457   */
asix_set_multicast(struct net_device * net)458  void asix_set_multicast(struct net_device *net)
459  {
460  	struct usbnet *dev = netdev_priv(net);
461  	struct asix_data *data = (struct asix_data *)&dev->data;
462  	u16 rx_ctl = AX_DEFAULT_RX_CTL;
463  
464  	if (net->flags & IFF_PROMISC) {
465  		rx_ctl |= AX_RX_CTL_PRO;
466  	} else if (net->flags & IFF_ALLMULTI ||
467  		   netdev_mc_count(net) > AX_MAX_MCAST) {
468  		rx_ctl |= AX_RX_CTL_AMALL;
469  	} else if (netdev_mc_empty(net)) {
470  		/* just broadcast and directed */
471  	} else {
472  		/* We use the 20 byte dev->data
473  		 * for our 8 byte filter buffer
474  		 * to avoid allocating memory that
475  		 * is tricky to free later */
476  		struct netdev_hw_addr *ha;
477  		u32 crc_bits;
478  
479  		memset(data->multi_filter, 0, AX_MCAST_FILTER_SIZE);
480  
481  		/* Build the multicast hash filter. */
482  		netdev_for_each_mc_addr(ha, net) {
483  			crc_bits = ether_crc(ETH_ALEN, ha->addr) >> 26;
484  			data->multi_filter[crc_bits >> 3] |=
485  			    1 << (crc_bits & 7);
486  		}
487  
488  		asix_write_cmd_async(dev, AX_CMD_WRITE_MULTI_FILTER, 0, 0,
489  				   AX_MCAST_FILTER_SIZE, data->multi_filter);
490  
491  		rx_ctl |= AX_RX_CTL_AM;
492  	}
493  
494  	asix_write_cmd_async(dev, AX_CMD_WRITE_RX_CTL, rx_ctl, 0, 0, NULL);
495  }
496  
__asix_mdio_read(struct net_device * netdev,int phy_id,int loc,bool in_pm)497  static int __asix_mdio_read(struct net_device *netdev, int phy_id, int loc,
498  			    bool in_pm)
499  {
500  	struct usbnet *dev = netdev_priv(netdev);
501  	__le16 res;
502  	int ret;
503  
504  	mutex_lock(&dev->phy_mutex);
505  
506  	ret = asix_check_host_enable(dev, in_pm);
507  	if (ret == -ENODEV || ret == -ETIMEDOUT) {
508  		mutex_unlock(&dev->phy_mutex);
509  		return ret;
510  	}
511  
512  	ret = asix_read_cmd(dev, AX_CMD_READ_MII_REG, phy_id, (__u16)loc, 2,
513  			    &res, in_pm);
514  	if (ret < 0)
515  		goto out;
516  
517  	ret = asix_set_hw_mii(dev, in_pm);
518  out:
519  	mutex_unlock(&dev->phy_mutex);
520  
521  	netdev_dbg(dev->net, "asix_mdio_read() phy_id=0x%02x, loc=0x%02x, returns=0x%04x\n",
522  			phy_id, loc, le16_to_cpu(res));
523  
524  	return ret < 0 ? ret : le16_to_cpu(res);
525  }
526  
asix_mdio_read(struct net_device * netdev,int phy_id,int loc)527  int asix_mdio_read(struct net_device *netdev, int phy_id, int loc)
528  {
529  	return __asix_mdio_read(netdev, phy_id, loc, false);
530  }
531  
__asix_mdio_write(struct net_device * netdev,int phy_id,int loc,int val,bool in_pm)532  static int __asix_mdio_write(struct net_device *netdev, int phy_id, int loc,
533  			     int val, bool in_pm)
534  {
535  	struct usbnet *dev = netdev_priv(netdev);
536  	__le16 res = cpu_to_le16(val);
537  	int ret;
538  
539  	netdev_dbg(dev->net, "asix_mdio_write() phy_id=0x%02x, loc=0x%02x, val=0x%04x\n",
540  			phy_id, loc, val);
541  
542  	mutex_lock(&dev->phy_mutex);
543  
544  	ret = asix_check_host_enable(dev, in_pm);
545  	if (ret == -ENODEV)
546  		goto out;
547  
548  	ret = asix_write_cmd(dev, AX_CMD_WRITE_MII_REG, phy_id, (__u16)loc, 2,
549  			     &res, in_pm);
550  	if (ret < 0)
551  		goto out;
552  
553  	ret = asix_set_hw_mii(dev, in_pm);
554  out:
555  	mutex_unlock(&dev->phy_mutex);
556  
557  	return ret < 0 ? ret : 0;
558  }
559  
asix_mdio_write(struct net_device * netdev,int phy_id,int loc,int val)560  void asix_mdio_write(struct net_device *netdev, int phy_id, int loc, int val)
561  {
562  	__asix_mdio_write(netdev, phy_id, loc, val, false);
563  }
564  
565  /* MDIO read and write wrappers for phylib */
asix_mdio_bus_read(struct mii_bus * bus,int phy_id,int regnum)566  int asix_mdio_bus_read(struct mii_bus *bus, int phy_id, int regnum)
567  {
568  	struct usbnet *priv = bus->priv;
569  
570  	return __asix_mdio_read(priv->net, phy_id, regnum, false);
571  }
572  
asix_mdio_bus_write(struct mii_bus * bus,int phy_id,int regnum,u16 val)573  int asix_mdio_bus_write(struct mii_bus *bus, int phy_id, int regnum, u16 val)
574  {
575  	struct usbnet *priv = bus->priv;
576  
577  	return __asix_mdio_write(priv->net, phy_id, regnum, val, false);
578  }
579  
asix_mdio_read_nopm(struct net_device * netdev,int phy_id,int loc)580  int asix_mdio_read_nopm(struct net_device *netdev, int phy_id, int loc)
581  {
582  	return __asix_mdio_read(netdev, phy_id, loc, true);
583  }
584  
585  void
asix_mdio_write_nopm(struct net_device * netdev,int phy_id,int loc,int val)586  asix_mdio_write_nopm(struct net_device *netdev, int phy_id, int loc, int val)
587  {
588  	__asix_mdio_write(netdev, phy_id, loc, val, true);
589  }
590  
asix_get_wol(struct net_device * net,struct ethtool_wolinfo * wolinfo)591  void asix_get_wol(struct net_device *net, struct ethtool_wolinfo *wolinfo)
592  {
593  	struct usbnet *dev = netdev_priv(net);
594  	u8 opt;
595  
596  	if (asix_read_cmd(dev, AX_CMD_READ_MONITOR_MODE,
597  			  0, 0, 1, &opt, 0) < 0) {
598  		wolinfo->supported = 0;
599  		wolinfo->wolopts = 0;
600  		return;
601  	}
602  	wolinfo->supported = WAKE_PHY | WAKE_MAGIC;
603  	wolinfo->wolopts = 0;
604  	if (opt & AX_MONITOR_LINK)
605  		wolinfo->wolopts |= WAKE_PHY;
606  	if (opt & AX_MONITOR_MAGIC)
607  		wolinfo->wolopts |= WAKE_MAGIC;
608  }
609  
asix_set_wol(struct net_device * net,struct ethtool_wolinfo * wolinfo)610  int asix_set_wol(struct net_device *net, struct ethtool_wolinfo *wolinfo)
611  {
612  	struct usbnet *dev = netdev_priv(net);
613  	u8 opt = 0;
614  
615  	if (wolinfo->wolopts & ~(WAKE_PHY | WAKE_MAGIC))
616  		return -EINVAL;
617  
618  	if (wolinfo->wolopts & WAKE_PHY)
619  		opt |= AX_MONITOR_LINK;
620  	if (wolinfo->wolopts & WAKE_MAGIC)
621  		opt |= AX_MONITOR_MAGIC;
622  
623  	if (asix_write_cmd(dev, AX_CMD_WRITE_MONITOR_MODE,
624  			      opt, 0, 0, NULL, 0) < 0)
625  		return -EINVAL;
626  
627  	return 0;
628  }
629  
asix_get_eeprom_len(struct net_device * net)630  int asix_get_eeprom_len(struct net_device *net)
631  {
632  	return AX_EEPROM_LEN;
633  }
634  
asix_get_eeprom(struct net_device * net,struct ethtool_eeprom * eeprom,u8 * data)635  int asix_get_eeprom(struct net_device *net, struct ethtool_eeprom *eeprom,
636  		    u8 *data)
637  {
638  	struct usbnet *dev = netdev_priv(net);
639  	u16 *eeprom_buff;
640  	int first_word, last_word;
641  	int i;
642  
643  	if (eeprom->len == 0)
644  		return -EINVAL;
645  
646  	eeprom->magic = AX_EEPROM_MAGIC;
647  
648  	first_word = eeprom->offset >> 1;
649  	last_word = (eeprom->offset + eeprom->len - 1) >> 1;
650  
651  	eeprom_buff = kmalloc_array(last_word - first_word + 1, sizeof(u16),
652  				    GFP_KERNEL);
653  	if (!eeprom_buff)
654  		return -ENOMEM;
655  
656  	/* ax8817x returns 2 bytes from eeprom on read */
657  	for (i = first_word; i <= last_word; i++) {
658  		if (asix_read_cmd(dev, AX_CMD_READ_EEPROM, i, 0, 2,
659  				  &eeprom_buff[i - first_word], 0) < 0) {
660  			kfree(eeprom_buff);
661  			return -EIO;
662  		}
663  	}
664  
665  	memcpy(data, (u8 *)eeprom_buff + (eeprom->offset & 1), eeprom->len);
666  	kfree(eeprom_buff);
667  	return 0;
668  }
669  
asix_set_eeprom(struct net_device * net,struct ethtool_eeprom * eeprom,u8 * data)670  int asix_set_eeprom(struct net_device *net, struct ethtool_eeprom *eeprom,
671  		    u8 *data)
672  {
673  	struct usbnet *dev = netdev_priv(net);
674  	u16 *eeprom_buff;
675  	int first_word, last_word;
676  	int i;
677  	int ret;
678  
679  	netdev_dbg(net, "write EEPROM len %d, offset %d, magic 0x%x\n",
680  		   eeprom->len, eeprom->offset, eeprom->magic);
681  
682  	if (eeprom->len == 0)
683  		return -EINVAL;
684  
685  	if (eeprom->magic != AX_EEPROM_MAGIC)
686  		return -EINVAL;
687  
688  	first_word = eeprom->offset >> 1;
689  	last_word = (eeprom->offset + eeprom->len - 1) >> 1;
690  
691  	eeprom_buff = kmalloc_array(last_word - first_word + 1, sizeof(u16),
692  				    GFP_KERNEL);
693  	if (!eeprom_buff)
694  		return -ENOMEM;
695  
696  	/* align data to 16 bit boundaries, read the missing data from
697  	   the EEPROM */
698  	if (eeprom->offset & 1) {
699  		ret = asix_read_cmd(dev, AX_CMD_READ_EEPROM, first_word, 0, 2,
700  				    &eeprom_buff[0], 0);
701  		if (ret < 0) {
702  			netdev_err(net, "Failed to read EEPROM at offset 0x%02x.\n", first_word);
703  			goto free;
704  		}
705  	}
706  
707  	if ((eeprom->offset + eeprom->len) & 1) {
708  		ret = asix_read_cmd(dev, AX_CMD_READ_EEPROM, last_word, 0, 2,
709  				    &eeprom_buff[last_word - first_word], 0);
710  		if (ret < 0) {
711  			netdev_err(net, "Failed to read EEPROM at offset 0x%02x.\n", last_word);
712  			goto free;
713  		}
714  	}
715  
716  	memcpy((u8 *)eeprom_buff + (eeprom->offset & 1), data, eeprom->len);
717  
718  	/* write data to EEPROM */
719  	ret = asix_write_cmd(dev, AX_CMD_WRITE_ENABLE, 0x0000, 0, 0, NULL, 0);
720  	if (ret < 0) {
721  		netdev_err(net, "Failed to enable EEPROM write\n");
722  		goto free;
723  	}
724  	msleep(20);
725  
726  	for (i = first_word; i <= last_word; i++) {
727  		netdev_dbg(net, "write to EEPROM at offset 0x%02x, data 0x%04x\n",
728  			   i, eeprom_buff[i - first_word]);
729  		ret = asix_write_cmd(dev, AX_CMD_WRITE_EEPROM, i,
730  				     eeprom_buff[i - first_word], 0, NULL, 0);
731  		if (ret < 0) {
732  			netdev_err(net, "Failed to write EEPROM at offset 0x%02x.\n",
733  				   i);
734  			goto free;
735  		}
736  		msleep(20);
737  	}
738  
739  	ret = asix_write_cmd(dev, AX_CMD_WRITE_DISABLE, 0x0000, 0, 0, NULL, 0);
740  	if (ret < 0) {
741  		netdev_err(net, "Failed to disable EEPROM write\n");
742  		goto free;
743  	}
744  
745  	ret = 0;
746  free:
747  	kfree(eeprom_buff);
748  	return ret;
749  }
750  
asix_get_drvinfo(struct net_device * net,struct ethtool_drvinfo * info)751  void asix_get_drvinfo(struct net_device *net, struct ethtool_drvinfo *info)
752  {
753  	/* Inherit standard device info */
754  	usbnet_get_drvinfo(net, info);
755  	strscpy(info->driver, DRIVER_NAME, sizeof(info->driver));
756  	strscpy(info->version, DRIVER_VERSION, sizeof(info->version));
757  }
758  
asix_set_mac_address(struct net_device * net,void * p)759  int asix_set_mac_address(struct net_device *net, void *p)
760  {
761  	struct usbnet *dev = netdev_priv(net);
762  	struct asix_data *data = (struct asix_data *)&dev->data;
763  	struct sockaddr *addr = p;
764  
765  	if (netif_running(net))
766  		return -EBUSY;
767  	if (!is_valid_ether_addr(addr->sa_data))
768  		return -EADDRNOTAVAIL;
769  
770  	eth_hw_addr_set(net, addr->sa_data);
771  
772  	/* We use the 20 byte dev->data
773  	 * for our 6 byte mac buffer
774  	 * to avoid allocating memory that
775  	 * is tricky to free later */
776  	memcpy(data->mac_addr, addr->sa_data, ETH_ALEN);
777  	asix_write_cmd_async(dev, AX_CMD_WRITE_NODE_ID, 0, 0, ETH_ALEN,
778  							data->mac_addr);
779  
780  	return 0;
781  }
782