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.
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.
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.
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
25 int asix_read_cmd(struct usbnet
*dev
, u8 cmd
, u16 value
, u16 index
,
29 ret
= usbnet_read_cmd(dev
, cmd
,
30 USB_DIR_IN
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
31 value
, index
, data
, size
);
33 if (ret
!= size
&& ret
>= 0)
38 int asix_write_cmd(struct usbnet
*dev
, u8 cmd
, u16 value
, u16 index
,
41 return usbnet_write_cmd(dev
, cmd
,
42 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
43 value
, index
, data
, size
);
46 void asix_write_cmd_async(struct usbnet
*dev
, u8 cmd
, u16 value
, u16 index
,
49 usbnet_write_cmd_async(dev
, cmd
,
50 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
51 value
, index
, data
, size
);
54 int asix_rx_fixup_internal(struct usbnet
*dev
, struct sk_buff
*skb
,
55 struct asix_rx_fixup_info
*rx
)
59 while (offset
+ sizeof(u16
) <= skb
->len
) {
64 if ((skb
->len
- offset
== sizeof(u16
)) ||
67 rx
->header
= get_unaligned_le16(
69 rx
->split_head
= true;
70 offset
+= sizeof(u16
);
73 rx
->header
|= (get_unaligned_le16(
76 rx
->split_head
= false;
77 offset
+= sizeof(u16
);
80 rx
->header
= get_unaligned_le32(skb
->data
+
82 offset
+= sizeof(u32
);
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",
93 rx
->ax_skb
= netdev_alloc_skb_ip_align(dev
->net
,
99 if (rx
->size
> dev
->net
->mtu
+ ETH_HLEN
+ VLAN_HLEN
) {
100 netdev_err(dev
->net
, "asix_rx_fixup() Bad RX Length %d\n",
102 kfree_skb(rx
->ax_skb
);
106 if (rx
->size
> skb
->len
- offset
) {
107 remaining
= rx
->size
- (skb
->len
- offset
);
108 rx
->size
= skb
->len
- offset
;
111 data
= skb_put(rx
->ax_skb
, rx
->size
);
112 memcpy(data
, skb
->data
+ offset
, rx
->size
);
114 usbnet_skb_return(dev
, rx
->ax_skb
);
116 offset
+= (rx
->size
+ 1) & 0xfffe;
117 rx
->size
= remaining
;
120 if (skb
->len
!= offset
) {
121 netdev_err(dev
->net
, "asix_rx_fixup() Bad SKB Length %d, %d\n",
129 int asix_rx_fixup_common(struct usbnet
*dev
, struct sk_buff
*skb
)
131 struct asix_common_private
*dp
= dev
->driver_priv
;
132 struct asix_rx_fixup_info
*rx
= &dp
->rx_fixup_info
;
134 return asix_rx_fixup_internal(dev
, skb
, rx
);
137 struct sk_buff
*asix_tx_fixup(struct usbnet
*dev
, struct sk_buff
*skb
,
141 int headroom
= skb_headroom(skb
);
142 int tailroom
= skb_tailroom(skb
);
144 u32 padbytes
= 0xffff0000;
146 padlen
= ((skb
->len
+ 4) & (dev
->maxpacket
- 1)) ? 0 : 4;
148 /* We need to push 4 bytes in front of frame (packet_len)
149 * and maybe add 4 bytes after the end (if padlen is 4)
151 * Avoid skb_copy_expand() expensive call, using following rules :
152 * - We are allowed to push 4 bytes in headroom if skb_header_cloned()
153 * is false (and if we have 4 bytes of headroom)
154 * - We are allowed to put 4 bytes at tail if skb_cloned()
155 * is false (and if we have 4 bytes of tailroom)
157 * TCP packets for example are cloned, but skb_header_release()
158 * was called in tcp stack, allowing us to use headroom for our needs.
160 if (!skb_header_cloned(skb
) &&
161 !(padlen
&& skb_cloned(skb
)) &&
162 headroom
+ tailroom
>= 4 + padlen
) {
163 /* following should not happen, but better be safe */
166 skb
->data
= memmove(skb
->head
+ 4, skb
->data
, skb
->len
);
167 skb_set_tail_pointer(skb
, skb
->len
);
170 struct sk_buff
*skb2
;
172 skb2
= skb_copy_expand(skb
, 4, padlen
, flags
);
173 dev_kfree_skb_any(skb
);
179 packet_len
= ((skb
->len
^ 0x0000ffff) << 16) + skb
->len
;
181 cpu_to_le32s(&packet_len
);
182 skb_copy_to_linear_data(skb
, &packet_len
, sizeof(packet_len
));
185 cpu_to_le32s(&padbytes
);
186 memcpy(skb_tail_pointer(skb
), &padbytes
, sizeof(padbytes
));
187 skb_put(skb
, sizeof(padbytes
));
192 int asix_set_sw_mii(struct usbnet
*dev
)
195 ret
= asix_write_cmd(dev
, AX_CMD_SET_SW_MII
, 0x0000, 0, 0, NULL
);
197 netdev_err(dev
->net
, "Failed to enable software MII access\n");
201 int asix_set_hw_mii(struct usbnet
*dev
)
204 ret
= asix_write_cmd(dev
, AX_CMD_SET_HW_MII
, 0x0000, 0, 0, NULL
);
206 netdev_err(dev
->net
, "Failed to enable hardware MII access\n");
210 int asix_read_phy_addr(struct usbnet
*dev
, int internal
)
212 int offset
= (internal
? 1 : 0);
214 int ret
= asix_read_cmd(dev
, AX_CMD_READ_PHY_ID
, 0, 0, 2, buf
);
216 netdev_dbg(dev
->net
, "asix_get_phy_addr()\n");
219 netdev_err(dev
->net
, "Error reading PHYID register: %02x\n", ret
);
222 netdev_dbg(dev
->net
, "asix_get_phy_addr() returning 0x%04x\n",
230 int asix_get_phy_addr(struct usbnet
*dev
)
232 /* return the address of the internal phy */
233 return asix_read_phy_addr(dev
, 1);
237 int asix_sw_reset(struct usbnet
*dev
, u8 flags
)
241 ret
= asix_write_cmd(dev
, AX_CMD_SW_RESET
, flags
, 0, 0, NULL
);
243 netdev_err(dev
->net
, "Failed to send software reset: %02x\n", ret
);
248 u16
asix_read_rx_ctl(struct usbnet
*dev
)
251 int ret
= asix_read_cmd(dev
, AX_CMD_READ_RX_CTL
, 0, 0, 2, &v
);
254 netdev_err(dev
->net
, "Error reading RX_CTL register: %02x\n", ret
);
257 ret
= le16_to_cpu(v
);
262 int asix_write_rx_ctl(struct usbnet
*dev
, u16 mode
)
266 netdev_dbg(dev
->net
, "asix_write_rx_ctl() - mode = 0x%04x\n", mode
);
267 ret
= asix_write_cmd(dev
, AX_CMD_WRITE_RX_CTL
, mode
, 0, 0, NULL
);
269 netdev_err(dev
->net
, "Failed to write RX_CTL mode to 0x%04x: %02x\n",
275 u16
asix_read_medium_status(struct usbnet
*dev
)
278 int ret
= asix_read_cmd(dev
, AX_CMD_READ_MEDIUM_STATUS
, 0, 0, 2, &v
);
281 netdev_err(dev
->net
, "Error reading Medium Status register: %02x\n",
283 return ret
; /* TODO: callers not checking for error ret */
286 return le16_to_cpu(v
);
290 int asix_write_medium_mode(struct usbnet
*dev
, u16 mode
)
294 netdev_dbg(dev
->net
, "asix_write_medium_mode() - mode = 0x%04x\n", mode
);
295 ret
= asix_write_cmd(dev
, AX_CMD_WRITE_MEDIUM_MODE
, mode
, 0, 0, NULL
);
297 netdev_err(dev
->net
, "Failed to write Medium Mode mode to 0x%04x: %02x\n",
303 int asix_write_gpio(struct usbnet
*dev
, u16 value
, int sleep
)
307 netdev_dbg(dev
->net
, "asix_write_gpio() - value = 0x%04x\n", value
);
308 ret
= asix_write_cmd(dev
, AX_CMD_WRITE_GPIOS
, value
, 0, 0, NULL
);
310 netdev_err(dev
->net
, "Failed to write GPIO value 0x%04x: %02x\n",
320 * AX88772 & AX88178 have a 16-bit RX_CTL value
322 void asix_set_multicast(struct net_device
*net
)
324 struct usbnet
*dev
= netdev_priv(net
);
325 struct asix_data
*data
= (struct asix_data
*)&dev
->data
;
326 u16 rx_ctl
= AX_DEFAULT_RX_CTL
;
328 if (net
->flags
& IFF_PROMISC
) {
329 rx_ctl
|= AX_RX_CTL_PRO
;
330 } else if (net
->flags
& IFF_ALLMULTI
||
331 netdev_mc_count(net
) > AX_MAX_MCAST
) {
332 rx_ctl
|= AX_RX_CTL_AMALL
;
333 } else if (netdev_mc_empty(net
)) {
334 /* just broadcast and directed */
336 /* We use the 20 byte dev->data
337 * for our 8 byte filter buffer
338 * to avoid allocating memory that
339 * is tricky to free later */
340 struct netdev_hw_addr
*ha
;
343 memset(data
->multi_filter
, 0, AX_MCAST_FILTER_SIZE
);
345 /* Build the multicast hash filter. */
346 netdev_for_each_mc_addr(ha
, net
) {
347 crc_bits
= ether_crc(ETH_ALEN
, ha
->addr
) >> 26;
348 data
->multi_filter
[crc_bits
>> 3] |=
352 asix_write_cmd_async(dev
, AX_CMD_WRITE_MULTI_FILTER
, 0, 0,
353 AX_MCAST_FILTER_SIZE
, data
->multi_filter
);
355 rx_ctl
|= AX_RX_CTL_AM
;
358 asix_write_cmd_async(dev
, AX_CMD_WRITE_RX_CTL
, rx_ctl
, 0, 0, NULL
);
361 int asix_mdio_read(struct net_device
*netdev
, int phy_id
, int loc
)
363 struct usbnet
*dev
= netdev_priv(netdev
);
366 mutex_lock(&dev
->phy_mutex
);
367 asix_set_sw_mii(dev
);
368 asix_read_cmd(dev
, AX_CMD_READ_MII_REG
, phy_id
,
369 (__u16
)loc
, 2, &res
);
370 asix_set_hw_mii(dev
);
371 mutex_unlock(&dev
->phy_mutex
);
373 netdev_dbg(dev
->net
, "asix_mdio_read() phy_id=0x%02x, loc=0x%02x, returns=0x%04x\n",
374 phy_id
, loc
, le16_to_cpu(res
));
376 return le16_to_cpu(res
);
379 void asix_mdio_write(struct net_device
*netdev
, int phy_id
, int loc
, int val
)
381 struct usbnet
*dev
= netdev_priv(netdev
);
382 __le16 res
= cpu_to_le16(val
);
384 netdev_dbg(dev
->net
, "asix_mdio_write() phy_id=0x%02x, loc=0x%02x, val=0x%04x\n",
386 mutex_lock(&dev
->phy_mutex
);
387 asix_set_sw_mii(dev
);
388 asix_write_cmd(dev
, AX_CMD_WRITE_MII_REG
, phy_id
, (__u16
)loc
, 2, &res
);
389 asix_set_hw_mii(dev
);
390 mutex_unlock(&dev
->phy_mutex
);
393 void asix_get_wol(struct net_device
*net
, struct ethtool_wolinfo
*wolinfo
)
395 struct usbnet
*dev
= netdev_priv(net
);
398 if (asix_read_cmd(dev
, AX_CMD_READ_MONITOR_MODE
, 0, 0, 1, &opt
) < 0) {
399 wolinfo
->supported
= 0;
400 wolinfo
->wolopts
= 0;
403 wolinfo
->supported
= WAKE_PHY
| WAKE_MAGIC
;
404 wolinfo
->wolopts
= 0;
405 if (opt
& AX_MONITOR_LINK
)
406 wolinfo
->wolopts
|= WAKE_PHY
;
407 if (opt
& AX_MONITOR_MAGIC
)
408 wolinfo
->wolopts
|= WAKE_MAGIC
;
411 int asix_set_wol(struct net_device
*net
, struct ethtool_wolinfo
*wolinfo
)
413 struct usbnet
*dev
= netdev_priv(net
);
416 if (wolinfo
->wolopts
& WAKE_PHY
)
417 opt
|= AX_MONITOR_LINK
;
418 if (wolinfo
->wolopts
& WAKE_MAGIC
)
419 opt
|= AX_MONITOR_MAGIC
;
421 if (asix_write_cmd(dev
, AX_CMD_WRITE_MONITOR_MODE
,
422 opt
, 0, 0, NULL
) < 0)
428 int asix_get_eeprom_len(struct net_device
*net
)
430 return AX_EEPROM_LEN
;
433 int asix_get_eeprom(struct net_device
*net
, struct ethtool_eeprom
*eeprom
,
436 struct usbnet
*dev
= netdev_priv(net
);
438 int first_word
, last_word
;
441 if (eeprom
->len
== 0)
444 eeprom
->magic
= AX_EEPROM_MAGIC
;
446 first_word
= eeprom
->offset
>> 1;
447 last_word
= (eeprom
->offset
+ eeprom
->len
- 1) >> 1;
449 eeprom_buff
= kmalloc(sizeof(u16
) * (last_word
- first_word
+ 1),
454 /* ax8817x returns 2 bytes from eeprom on read */
455 for (i
= first_word
; i
<= last_word
; i
++) {
456 if (asix_read_cmd(dev
, AX_CMD_READ_EEPROM
, i
, 0, 2,
457 &(eeprom_buff
[i
- first_word
])) < 0) {
463 memcpy(data
, (u8
*)eeprom_buff
+ (eeprom
->offset
& 1), eeprom
->len
);
468 int asix_set_eeprom(struct net_device
*net
, struct ethtool_eeprom
*eeprom
,
471 struct usbnet
*dev
= netdev_priv(net
);
473 int first_word
, last_word
;
477 netdev_dbg(net
, "write EEPROM len %d, offset %d, magic 0x%x\n",
478 eeprom
->len
, eeprom
->offset
, eeprom
->magic
);
480 if (eeprom
->len
== 0)
483 if (eeprom
->magic
!= AX_EEPROM_MAGIC
)
486 first_word
= eeprom
->offset
>> 1;
487 last_word
= (eeprom
->offset
+ eeprom
->len
- 1) >> 1;
489 eeprom_buff
= kmalloc(sizeof(u16
) * (last_word
- first_word
+ 1),
494 /* align data to 16 bit boundaries, read the missing data from
496 if (eeprom
->offset
& 1) {
497 ret
= asix_read_cmd(dev
, AX_CMD_READ_EEPROM
, first_word
, 0, 2,
500 netdev_err(net
, "Failed to read EEPROM at offset 0x%02x.\n", first_word
);
505 if ((eeprom
->offset
+ eeprom
->len
) & 1) {
506 ret
= asix_read_cmd(dev
, AX_CMD_READ_EEPROM
, last_word
, 0, 2,
507 &(eeprom_buff
[last_word
- first_word
]));
509 netdev_err(net
, "Failed to read EEPROM at offset 0x%02x.\n", last_word
);
514 memcpy((u8
*)eeprom_buff
+ (eeprom
->offset
& 1), data
, eeprom
->len
);
516 /* write data to EEPROM */
517 ret
= asix_write_cmd(dev
, AX_CMD_WRITE_ENABLE
, 0x0000, 0, 0, NULL
);
519 netdev_err(net
, "Failed to enable EEPROM write\n");
524 for (i
= first_word
; i
<= last_word
; i
++) {
525 netdev_dbg(net
, "write to EEPROM at offset 0x%02x, data 0x%04x\n",
526 i
, eeprom_buff
[i
- first_word
]);
527 ret
= asix_write_cmd(dev
, AX_CMD_WRITE_EEPROM
, i
,
528 eeprom_buff
[i
- first_word
], 0, NULL
);
530 netdev_err(net
, "Failed to write EEPROM at offset 0x%02x.\n",
537 ret
= asix_write_cmd(dev
, AX_CMD_WRITE_DISABLE
, 0x0000, 0, 0, NULL
);
539 netdev_err(net
, "Failed to disable EEPROM write\n");
549 void asix_get_drvinfo(struct net_device
*net
, struct ethtool_drvinfo
*info
)
551 /* Inherit standard device info */
552 usbnet_get_drvinfo(net
, info
);
553 strlcpy(info
->driver
, DRIVER_NAME
, sizeof(info
->driver
));
554 strlcpy(info
->version
, DRIVER_VERSION
, sizeof(info
->version
));
555 info
->eedump_len
= AX_EEPROM_LEN
;
558 int asix_set_mac_address(struct net_device
*net
, void *p
)
560 struct usbnet
*dev
= netdev_priv(net
);
561 struct asix_data
*data
= (struct asix_data
*)&dev
->data
;
562 struct sockaddr
*addr
= p
;
564 if (netif_running(net
))
566 if (!is_valid_ether_addr(addr
->sa_data
))
567 return -EADDRNOTAVAIL
;
569 memcpy(net
->dev_addr
, addr
->sa_data
, ETH_ALEN
);
571 /* We use the 20 byte dev->data
572 * for our 6 byte mac buffer
573 * to avoid allocating memory that
574 * is tricky to free later */
575 memcpy(data
->mac_addr
, addr
->sa_data
, ETH_ALEN
);
576 asix_write_cmd_async(dev
, AX_CMD_WRITE_NODE_ID
, 0, 0, ETH_ALEN
,