xref: /openbmc/linux/drivers/net/usb/asix_common.c (revision 12eb4683)
1 /*
2  * ASIX AX8817X based USB 2.0 Ethernet Devices
3  * Copyright (C) 2003-2006 David Hollis <dhollis@davehollis.com>
4  * Copyright (C) 2005 Phil Chang <pchang23@sbcglobal.net>
5  * Copyright (C) 2006 James Painter <jamie.painter@iname.com>
6  * Copyright (c) 2002-2003 TiVo Inc.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21  */
22 
23 #include "asix.h"
24 
25 int asix_read_cmd(struct usbnet *dev, u8 cmd, u16 value, u16 index,
26 		  u16 size, void *data)
27 {
28 	int ret;
29 	ret = usbnet_read_cmd(dev, cmd,
30 			       USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
31 			       value, index, data, size);
32 
33 	if (ret != size && ret >= 0)
34 		return -EINVAL;
35 	return ret;
36 }
37 
38 int asix_write_cmd(struct usbnet *dev, u8 cmd, u16 value, u16 index,
39 		   u16 size, void *data)
40 {
41 	return usbnet_write_cmd(dev, cmd,
42 				USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
43 				value, index, data, size);
44 }
45 
46 void asix_write_cmd_async(struct usbnet *dev, u8 cmd, u16 value, u16 index,
47 			  u16 size, void *data)
48 {
49 	usbnet_write_cmd_async(dev, cmd,
50 			       USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
51 			       value, index, data, size);
52 }
53 
54 int asix_rx_fixup_internal(struct usbnet *dev, struct sk_buff *skb,
55 			   struct asix_rx_fixup_info *rx)
56 {
57 	int offset = 0;
58 
59 	while (offset + sizeof(u16) <= skb->len) {
60 		u16 remaining = 0;
61 		unsigned char *data;
62 
63 		if (!rx->size) {
64 			if ((skb->len - offset == sizeof(u16)) ||
65 			    rx->split_head) {
66 				if(!rx->split_head) {
67 					rx->header = get_unaligned_le16(
68 							skb->data + offset);
69 					rx->split_head = true;
70 					offset += sizeof(u16);
71 					break;
72 				} else {
73 					rx->header |= (get_unaligned_le16(
74 							skb->data + offset)
75 							<< 16);
76 					rx->split_head = false;
77 					offset += sizeof(u16);
78 				}
79 			} else {
80 				rx->header = get_unaligned_le32(skb->data +
81 								offset);
82 				offset += sizeof(u32);
83 			}
84 
85 			/* get the packet length */
86 			rx->size = (u16) (rx->header & 0x7ff);
87 			if (rx->size != ((~rx->header >> 16) & 0x7ff)) {
88 				netdev_err(dev->net, "asix_rx_fixup() Bad Header Length 0x%x, offset %d\n",
89 					   rx->header, offset);
90 				rx->size = 0;
91 				return 0;
92 			}
93 			rx->ax_skb = netdev_alloc_skb_ip_align(dev->net,
94 							       rx->size);
95 			if (!rx->ax_skb)
96 				return 0;
97 		}
98 
99 		if (rx->size > dev->net->mtu + ETH_HLEN + VLAN_HLEN) {
100 			netdev_err(dev->net, "asix_rx_fixup() Bad RX Length %d\n",
101 				   rx->size);
102 			kfree_skb(rx->ax_skb);
103 			rx->ax_skb = NULL;
104 			rx->size = 0U;
105 
106 			return 0;
107 		}
108 
109 		if (rx->size > skb->len - offset) {
110 			remaining = rx->size - (skb->len - offset);
111 			rx->size = skb->len - offset;
112 		}
113 
114 		data = skb_put(rx->ax_skb, rx->size);
115 		memcpy(data, skb->data + offset, rx->size);
116 		if (!remaining)
117 			usbnet_skb_return(dev, rx->ax_skb);
118 
119 		offset += (rx->size + 1) & 0xfffe;
120 		rx->size = remaining;
121 	}
122 
123 	if (skb->len != offset) {
124 		netdev_err(dev->net, "asix_rx_fixup() Bad SKB Length %d, %d\n",
125 			   skb->len, offset);
126 		return 0;
127 	}
128 
129 	return 1;
130 }
131 
132 int asix_rx_fixup_common(struct usbnet *dev, struct sk_buff *skb)
133 {
134 	struct asix_common_private *dp = dev->driver_priv;
135 	struct asix_rx_fixup_info *rx = &dp->rx_fixup_info;
136 
137 	return asix_rx_fixup_internal(dev, skb, rx);
138 }
139 
140 struct sk_buff *asix_tx_fixup(struct usbnet *dev, struct sk_buff *skb,
141 			      gfp_t flags)
142 {
143 	int padlen;
144 	int headroom = skb_headroom(skb);
145 	int tailroom = skb_tailroom(skb);
146 	u32 packet_len;
147 	u32 padbytes = 0xffff0000;
148 
149 	padlen = ((skb->len + 4) & (dev->maxpacket - 1)) ? 0 : 4;
150 
151 	/* We need to push 4 bytes in front of frame (packet_len)
152 	 * and maybe add 4 bytes after the end (if padlen is 4)
153 	 *
154 	 * Avoid skb_copy_expand() expensive call, using following rules :
155 	 * - We are allowed to push 4 bytes in headroom if skb_header_cloned()
156 	 *   is false (and if we have 4 bytes of headroom)
157 	 * - We are allowed to put 4 bytes at tail if skb_cloned()
158 	 *   is false (and if we have 4 bytes of tailroom)
159 	 *
160 	 * TCP packets for example are cloned, but skb_header_release()
161 	 * was called in tcp stack, allowing us to use headroom for our needs.
162 	 */
163 	if (!skb_header_cloned(skb) &&
164 	    !(padlen && skb_cloned(skb)) &&
165 	    headroom + tailroom >= 4 + padlen) {
166 		/* following should not happen, but better be safe */
167 		if (headroom < 4 ||
168 		    tailroom < padlen) {
169 			skb->data = memmove(skb->head + 4, skb->data, skb->len);
170 			skb_set_tail_pointer(skb, skb->len);
171 		}
172 	} else {
173 		struct sk_buff *skb2;
174 
175 		skb2 = skb_copy_expand(skb, 4, padlen, flags);
176 		dev_kfree_skb_any(skb);
177 		skb = skb2;
178 		if (!skb)
179 			return NULL;
180 	}
181 
182 	packet_len = ((skb->len ^ 0x0000ffff) << 16) + skb->len;
183 	skb_push(skb, 4);
184 	cpu_to_le32s(&packet_len);
185 	skb_copy_to_linear_data(skb, &packet_len, sizeof(packet_len));
186 
187 	if (padlen) {
188 		cpu_to_le32s(&padbytes);
189 		memcpy(skb_tail_pointer(skb), &padbytes, sizeof(padbytes));
190 		skb_put(skb, sizeof(padbytes));
191 	}
192 	return skb;
193 }
194 
195 int asix_set_sw_mii(struct usbnet *dev)
196 {
197 	int ret;
198 	ret = asix_write_cmd(dev, AX_CMD_SET_SW_MII, 0x0000, 0, 0, NULL);
199 	if (ret < 0)
200 		netdev_err(dev->net, "Failed to enable software MII access\n");
201 	return ret;
202 }
203 
204 int asix_set_hw_mii(struct usbnet *dev)
205 {
206 	int ret;
207 	ret = asix_write_cmd(dev, AX_CMD_SET_HW_MII, 0x0000, 0, 0, NULL);
208 	if (ret < 0)
209 		netdev_err(dev->net, "Failed to enable hardware MII access\n");
210 	return ret;
211 }
212 
213 int asix_read_phy_addr(struct usbnet *dev, int internal)
214 {
215 	int offset = (internal ? 1 : 0);
216 	u8 buf[2];
217 	int ret = asix_read_cmd(dev, AX_CMD_READ_PHY_ID, 0, 0, 2, buf);
218 
219 	netdev_dbg(dev->net, "asix_get_phy_addr()\n");
220 
221 	if (ret < 0) {
222 		netdev_err(dev->net, "Error reading PHYID register: %02x\n", ret);
223 		goto out;
224 	}
225 	netdev_dbg(dev->net, "asix_get_phy_addr() returning 0x%04x\n",
226 		   *((__le16 *)buf));
227 	ret = buf[offset];
228 
229 out:
230 	return ret;
231 }
232 
233 int asix_get_phy_addr(struct usbnet *dev)
234 {
235 	/* return the address of the internal phy */
236 	return asix_read_phy_addr(dev, 1);
237 }
238 
239 
240 int asix_sw_reset(struct usbnet *dev, u8 flags)
241 {
242 	int ret;
243 
244         ret = asix_write_cmd(dev, AX_CMD_SW_RESET, flags, 0, 0, NULL);
245 	if (ret < 0)
246 		netdev_err(dev->net, "Failed to send software reset: %02x\n", ret);
247 
248 	return ret;
249 }
250 
251 u16 asix_read_rx_ctl(struct usbnet *dev)
252 {
253 	__le16 v;
254 	int ret = asix_read_cmd(dev, AX_CMD_READ_RX_CTL, 0, 0, 2, &v);
255 
256 	if (ret < 0) {
257 		netdev_err(dev->net, "Error reading RX_CTL register: %02x\n", ret);
258 		goto out;
259 	}
260 	ret = le16_to_cpu(v);
261 out:
262 	return ret;
263 }
264 
265 int asix_write_rx_ctl(struct usbnet *dev, u16 mode)
266 {
267 	int ret;
268 
269 	netdev_dbg(dev->net, "asix_write_rx_ctl() - mode = 0x%04x\n", mode);
270 	ret = asix_write_cmd(dev, AX_CMD_WRITE_RX_CTL, mode, 0, 0, NULL);
271 	if (ret < 0)
272 		netdev_err(dev->net, "Failed to write RX_CTL mode to 0x%04x: %02x\n",
273 			   mode, ret);
274 
275 	return ret;
276 }
277 
278 u16 asix_read_medium_status(struct usbnet *dev)
279 {
280 	__le16 v;
281 	int ret = asix_read_cmd(dev, AX_CMD_READ_MEDIUM_STATUS, 0, 0, 2, &v);
282 
283 	if (ret < 0) {
284 		netdev_err(dev->net, "Error reading Medium Status register: %02x\n",
285 			   ret);
286 		return ret;	/* TODO: callers not checking for error ret */
287 	}
288 
289 	return le16_to_cpu(v);
290 
291 }
292 
293 int asix_write_medium_mode(struct usbnet *dev, u16 mode)
294 {
295 	int ret;
296 
297 	netdev_dbg(dev->net, "asix_write_medium_mode() - mode = 0x%04x\n", mode);
298 	ret = asix_write_cmd(dev, AX_CMD_WRITE_MEDIUM_MODE, mode, 0, 0, NULL);
299 	if (ret < 0)
300 		netdev_err(dev->net, "Failed to write Medium Mode mode to 0x%04x: %02x\n",
301 			   mode, ret);
302 
303 	return ret;
304 }
305 
306 int asix_write_gpio(struct usbnet *dev, u16 value, int sleep)
307 {
308 	int ret;
309 
310 	netdev_dbg(dev->net, "asix_write_gpio() - value = 0x%04x\n", value);
311 	ret = asix_write_cmd(dev, AX_CMD_WRITE_GPIOS, value, 0, 0, NULL);
312 	if (ret < 0)
313 		netdev_err(dev->net, "Failed to write GPIO value 0x%04x: %02x\n",
314 			   value, ret);
315 
316 	if (sleep)
317 		msleep(sleep);
318 
319 	return ret;
320 }
321 
322 /*
323  * AX88772 & AX88178 have a 16-bit RX_CTL value
324  */
325 void asix_set_multicast(struct net_device *net)
326 {
327 	struct usbnet *dev = netdev_priv(net);
328 	struct asix_data *data = (struct asix_data *)&dev->data;
329 	u16 rx_ctl = AX_DEFAULT_RX_CTL;
330 
331 	if (net->flags & IFF_PROMISC) {
332 		rx_ctl |= AX_RX_CTL_PRO;
333 	} else if (net->flags & IFF_ALLMULTI ||
334 		   netdev_mc_count(net) > AX_MAX_MCAST) {
335 		rx_ctl |= AX_RX_CTL_AMALL;
336 	} else if (netdev_mc_empty(net)) {
337 		/* just broadcast and directed */
338 	} else {
339 		/* We use the 20 byte dev->data
340 		 * for our 8 byte filter buffer
341 		 * to avoid allocating memory that
342 		 * is tricky to free later */
343 		struct netdev_hw_addr *ha;
344 		u32 crc_bits;
345 
346 		memset(data->multi_filter, 0, AX_MCAST_FILTER_SIZE);
347 
348 		/* Build the multicast hash filter. */
349 		netdev_for_each_mc_addr(ha, net) {
350 			crc_bits = ether_crc(ETH_ALEN, ha->addr) >> 26;
351 			data->multi_filter[crc_bits >> 3] |=
352 			    1 << (crc_bits & 7);
353 		}
354 
355 		asix_write_cmd_async(dev, AX_CMD_WRITE_MULTI_FILTER, 0, 0,
356 				   AX_MCAST_FILTER_SIZE, data->multi_filter);
357 
358 		rx_ctl |= AX_RX_CTL_AM;
359 	}
360 
361 	asix_write_cmd_async(dev, AX_CMD_WRITE_RX_CTL, rx_ctl, 0, 0, NULL);
362 }
363 
364 int asix_mdio_read(struct net_device *netdev, int phy_id, int loc)
365 {
366 	struct usbnet *dev = netdev_priv(netdev);
367 	__le16 res;
368 
369 	mutex_lock(&dev->phy_mutex);
370 	asix_set_sw_mii(dev);
371 	asix_read_cmd(dev, AX_CMD_READ_MII_REG, phy_id,
372 				(__u16)loc, 2, &res);
373 	asix_set_hw_mii(dev);
374 	mutex_unlock(&dev->phy_mutex);
375 
376 	netdev_dbg(dev->net, "asix_mdio_read() phy_id=0x%02x, loc=0x%02x, returns=0x%04x\n",
377 		   phy_id, loc, le16_to_cpu(res));
378 
379 	return le16_to_cpu(res);
380 }
381 
382 void asix_mdio_write(struct net_device *netdev, int phy_id, int loc, int val)
383 {
384 	struct usbnet *dev = netdev_priv(netdev);
385 	__le16 res = cpu_to_le16(val);
386 
387 	netdev_dbg(dev->net, "asix_mdio_write() phy_id=0x%02x, loc=0x%02x, val=0x%04x\n",
388 		   phy_id, loc, val);
389 	mutex_lock(&dev->phy_mutex);
390 	asix_set_sw_mii(dev);
391 	asix_write_cmd(dev, AX_CMD_WRITE_MII_REG, phy_id, (__u16)loc, 2, &res);
392 	asix_set_hw_mii(dev);
393 	mutex_unlock(&dev->phy_mutex);
394 }
395 
396 void asix_get_wol(struct net_device *net, struct ethtool_wolinfo *wolinfo)
397 {
398 	struct usbnet *dev = netdev_priv(net);
399 	u8 opt;
400 
401 	if (asix_read_cmd(dev, AX_CMD_READ_MONITOR_MODE, 0, 0, 1, &opt) < 0) {
402 		wolinfo->supported = 0;
403 		wolinfo->wolopts = 0;
404 		return;
405 	}
406 	wolinfo->supported = WAKE_PHY | WAKE_MAGIC;
407 	wolinfo->wolopts = 0;
408 	if (opt & AX_MONITOR_LINK)
409 		wolinfo->wolopts |= WAKE_PHY;
410 	if (opt & AX_MONITOR_MAGIC)
411 		wolinfo->wolopts |= WAKE_MAGIC;
412 }
413 
414 int asix_set_wol(struct net_device *net, struct ethtool_wolinfo *wolinfo)
415 {
416 	struct usbnet *dev = netdev_priv(net);
417 	u8 opt = 0;
418 
419 	if (wolinfo->wolopts & WAKE_PHY)
420 		opt |= AX_MONITOR_LINK;
421 	if (wolinfo->wolopts & WAKE_MAGIC)
422 		opt |= AX_MONITOR_MAGIC;
423 
424 	if (asix_write_cmd(dev, AX_CMD_WRITE_MONITOR_MODE,
425 			      opt, 0, 0, NULL) < 0)
426 		return -EINVAL;
427 
428 	return 0;
429 }
430 
431 int asix_get_eeprom_len(struct net_device *net)
432 {
433 	return AX_EEPROM_LEN;
434 }
435 
436 int asix_get_eeprom(struct net_device *net, struct ethtool_eeprom *eeprom,
437 		    u8 *data)
438 {
439 	struct usbnet *dev = netdev_priv(net);
440 	u16 *eeprom_buff;
441 	int first_word, last_word;
442 	int i;
443 
444 	if (eeprom->len == 0)
445 		return -EINVAL;
446 
447 	eeprom->magic = AX_EEPROM_MAGIC;
448 
449 	first_word = eeprom->offset >> 1;
450 	last_word = (eeprom->offset + eeprom->len - 1) >> 1;
451 
452 	eeprom_buff = kmalloc(sizeof(u16) * (last_word - first_word + 1),
453 			      GFP_KERNEL);
454 	if (!eeprom_buff)
455 		return -ENOMEM;
456 
457 	/* ax8817x returns 2 bytes from eeprom on read */
458 	for (i = first_word; i <= last_word; i++) {
459 		if (asix_read_cmd(dev, AX_CMD_READ_EEPROM, i, 0, 2,
460 				  &(eeprom_buff[i - first_word])) < 0) {
461 			kfree(eeprom_buff);
462 			return -EIO;
463 		}
464 	}
465 
466 	memcpy(data, (u8 *)eeprom_buff + (eeprom->offset & 1), eeprom->len);
467 	kfree(eeprom_buff);
468 	return 0;
469 }
470 
471 int asix_set_eeprom(struct net_device *net, struct ethtool_eeprom *eeprom,
472 		    u8 *data)
473 {
474 	struct usbnet *dev = netdev_priv(net);
475 	u16 *eeprom_buff;
476 	int first_word, last_word;
477 	int i;
478 	int ret;
479 
480 	netdev_dbg(net, "write EEPROM len %d, offset %d, magic 0x%x\n",
481 		   eeprom->len, eeprom->offset, eeprom->magic);
482 
483 	if (eeprom->len == 0)
484 		return -EINVAL;
485 
486 	if (eeprom->magic != AX_EEPROM_MAGIC)
487 		return -EINVAL;
488 
489 	first_word = eeprom->offset >> 1;
490 	last_word = (eeprom->offset + eeprom->len - 1) >> 1;
491 
492 	eeprom_buff = kmalloc(sizeof(u16) * (last_word - first_word + 1),
493 			      GFP_KERNEL);
494 	if (!eeprom_buff)
495 		return -ENOMEM;
496 
497 	/* align data to 16 bit boundaries, read the missing data from
498 	   the EEPROM */
499 	if (eeprom->offset & 1) {
500 		ret = asix_read_cmd(dev, AX_CMD_READ_EEPROM, first_word, 0, 2,
501 				    &(eeprom_buff[0]));
502 		if (ret < 0) {
503 			netdev_err(net, "Failed to read EEPROM at offset 0x%02x.\n", first_word);
504 			goto free;
505 		}
506 	}
507 
508 	if ((eeprom->offset + eeprom->len) & 1) {
509 		ret = asix_read_cmd(dev, AX_CMD_READ_EEPROM, last_word, 0, 2,
510 				    &(eeprom_buff[last_word - first_word]));
511 		if (ret < 0) {
512 			netdev_err(net, "Failed to read EEPROM at offset 0x%02x.\n", last_word);
513 			goto free;
514 		}
515 	}
516 
517 	memcpy((u8 *)eeprom_buff + (eeprom->offset & 1), data, eeprom->len);
518 
519 	/* write data to EEPROM */
520 	ret = asix_write_cmd(dev, AX_CMD_WRITE_ENABLE, 0x0000, 0, 0, NULL);
521 	if (ret < 0) {
522 		netdev_err(net, "Failed to enable EEPROM write\n");
523 		goto free;
524 	}
525 	msleep(20);
526 
527 	for (i = first_word; i <= last_word; i++) {
528 		netdev_dbg(net, "write to EEPROM at offset 0x%02x, data 0x%04x\n",
529 			   i, eeprom_buff[i - first_word]);
530 		ret = asix_write_cmd(dev, AX_CMD_WRITE_EEPROM, i,
531 				     eeprom_buff[i - first_word], 0, NULL);
532 		if (ret < 0) {
533 			netdev_err(net, "Failed to write EEPROM at offset 0x%02x.\n",
534 				   i);
535 			goto free;
536 		}
537 		msleep(20);
538 	}
539 
540 	ret = asix_write_cmd(dev, AX_CMD_WRITE_DISABLE, 0x0000, 0, 0, NULL);
541 	if (ret < 0) {
542 		netdev_err(net, "Failed to disable EEPROM write\n");
543 		goto free;
544 	}
545 
546 	ret = 0;
547 free:
548 	kfree(eeprom_buff);
549 	return ret;
550 }
551 
552 void asix_get_drvinfo(struct net_device *net, struct ethtool_drvinfo *info)
553 {
554 	/* Inherit standard device info */
555 	usbnet_get_drvinfo(net, info);
556 	strlcpy(info->driver, DRIVER_NAME, sizeof(info->driver));
557 	strlcpy(info->version, DRIVER_VERSION, sizeof(info->version));
558 	info->eedump_len = AX_EEPROM_LEN;
559 }
560 
561 int asix_set_mac_address(struct net_device *net, void *p)
562 {
563 	struct usbnet *dev = netdev_priv(net);
564 	struct asix_data *data = (struct asix_data *)&dev->data;
565 	struct sockaddr *addr = p;
566 
567 	if (netif_running(net))
568 		return -EBUSY;
569 	if (!is_valid_ether_addr(addr->sa_data))
570 		return -EADDRNOTAVAIL;
571 
572 	memcpy(net->dev_addr, addr->sa_data, ETH_ALEN);
573 
574 	/* We use the 20 byte dev->data
575 	 * for our 6 byte mac buffer
576 	 * to avoid allocating memory that
577 	 * is tricky to free later */
578 	memcpy(data->mac_addr, addr->sa_data, ETH_ALEN);
579 	asix_write_cmd_async(dev, AX_CMD_WRITE_NODE_ID, 0, 0, ETH_ALEN,
580 							data->mac_addr);
581 
582 	return 0;
583 }
584