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, see <http://www.gnu.org/licenses/>.
24 int asix_read_cmd(struct usbnet
*dev
, u8 cmd
, u16 value
, u16 index
,
25 u16 size
, void *data
, int in_pm
)
28 int (*fn
)(struct usbnet
*, u8
, u8
, u16
, u16
, void *, u16
);
35 fn
= usbnet_read_cmd_nopm
;
37 ret
= fn(dev
, cmd
, USB_DIR_IN
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
38 value
, index
, data
, size
);
40 if (unlikely(ret
< 0))
41 netdev_warn(dev
->net
, "Failed to read reg index 0x%04x: %d\n",
47 int asix_write_cmd(struct usbnet
*dev
, u8 cmd
, u16 value
, u16 index
,
48 u16 size
, void *data
, int in_pm
)
51 int (*fn
)(struct usbnet
*, u8
, u8
, u16
, u16
, const void *, u16
);
56 fn
= usbnet_write_cmd
;
58 fn
= usbnet_write_cmd_nopm
;
60 ret
= fn(dev
, cmd
, USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
61 value
, index
, data
, size
);
63 if (unlikely(ret
< 0))
64 netdev_warn(dev
->net
, "Failed to write reg index 0x%04x: %d\n",
70 void asix_write_cmd_async(struct usbnet
*dev
, u8 cmd
, u16 value
, u16 index
,
73 usbnet_write_cmd_async(dev
, cmd
,
74 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
75 value
, index
, data
, size
);
78 int asix_rx_fixup_internal(struct usbnet
*dev
, struct sk_buff
*skb
,
79 struct asix_rx_fixup_info
*rx
)
84 /* When an Ethernet frame spans multiple URB socket buffers,
85 * do a sanity test for the Data header synchronisation.
86 * Attempt to detect the situation of the previous socket buffer having
87 * been truncated or a socket buffer was missing. These situations
88 * cause a discontinuity in the data stream and therefore need to avoid
89 * appending bad data to the end of the current netdev socket buffer.
90 * Also avoid unnecessarily discarding a good current netdev socket
93 if (rx
->remaining
&& (rx
->remaining
+ sizeof(u32
) <= skb
->len
)) {
94 offset
= ((rx
->remaining
+ 1) & 0xfffe);
95 rx
->header
= get_unaligned_le32(skb
->data
+ offset
);
98 size
= (u16
)(rx
->header
& 0x7ff);
99 if (size
!= ((~rx
->header
>> 16) & 0x7ff)) {
100 netdev_err(dev
->net
, "asix_rx_fixup() Data Header synchronisation was lost, remaining %d\n",
103 kfree_skb(rx
->ax_skb
);
105 /* Discard the incomplete netdev Ethernet frame
106 * and assume the Data header is at the start of
107 * the current URB socket buffer.
114 while (offset
+ sizeof(u16
) <= skb
->len
) {
117 if (!rx
->remaining
) {
118 if (skb
->len
- offset
== sizeof(u16
)) {
119 rx
->header
= get_unaligned_le16(
121 rx
->split_head
= true;
122 offset
+= sizeof(u16
);
126 if (rx
->split_head
== true) {
127 rx
->header
|= (get_unaligned_le16(
128 skb
->data
+ offset
) << 16);
129 rx
->split_head
= false;
130 offset
+= sizeof(u16
);
132 rx
->header
= get_unaligned_le32(skb
->data
+
134 offset
+= sizeof(u32
);
137 /* take frame length from Data header 32-bit word */
138 size
= (u16
)(rx
->header
& 0x7ff);
139 if (size
!= ((~rx
->header
>> 16) & 0x7ff)) {
140 netdev_err(dev
->net
, "asix_rx_fixup() Bad Header Length 0x%x, offset %d\n",
144 if (size
> dev
->net
->mtu
+ ETH_HLEN
+ VLAN_HLEN
) {
145 netdev_dbg(dev
->net
, "asix_rx_fixup() Bad RX Length %d\n",
150 /* Sometimes may fail to get a netdev socket buffer but
151 * continue to process the URB socket buffer so that
152 * synchronisation of the Ethernet frame Data header
153 * word is maintained.
155 rx
->ax_skb
= netdev_alloc_skb_ip_align(dev
->net
, size
);
157 rx
->remaining
= size
;
160 if (rx
->remaining
> skb
->len
- offset
) {
161 copy_length
= skb
->len
- offset
;
162 rx
->remaining
-= copy_length
;
164 copy_length
= rx
->remaining
;
169 skb_put_data(rx
->ax_skb
, skb
->data
+ offset
,
172 usbnet_skb_return(dev
, rx
->ax_skb
);
175 offset
+= (copy_length
+ 1) & 0xfffe;
178 if (skb
->len
!= offset
) {
179 netdev_err(dev
->net
, "asix_rx_fixup() Bad SKB Length %d, %d\n",
187 int asix_rx_fixup_common(struct usbnet
*dev
, struct sk_buff
*skb
)
189 struct asix_common_private
*dp
= dev
->driver_priv
;
190 struct asix_rx_fixup_info
*rx
= &dp
->rx_fixup_info
;
192 return asix_rx_fixup_internal(dev
, skb
, rx
);
195 struct sk_buff
*asix_tx_fixup(struct usbnet
*dev
, struct sk_buff
*skb
,
199 int headroom
= skb_headroom(skb
);
200 int tailroom
= skb_tailroom(skb
);
202 u32 padbytes
= 0xffff0000;
204 padlen
= ((skb
->len
+ 4) & (dev
->maxpacket
- 1)) ? 0 : 4;
206 /* We need to push 4 bytes in front of frame (packet_len)
207 * and maybe add 4 bytes after the end (if padlen is 4)
209 * Avoid skb_copy_expand() expensive call, using following rules :
210 * - We are allowed to push 4 bytes in headroom if skb_header_cloned()
211 * is false (and if we have 4 bytes of headroom)
212 * - We are allowed to put 4 bytes at tail if skb_cloned()
213 * is false (and if we have 4 bytes of tailroom)
215 * TCP packets for example are cloned, but skb_header_release()
216 * was called in tcp stack, allowing us to use headroom for our needs.
218 if (!skb_header_cloned(skb
) &&
219 !(padlen
&& skb_cloned(skb
)) &&
220 headroom
+ tailroom
>= 4 + padlen
) {
221 /* following should not happen, but better be safe */
224 skb
->data
= memmove(skb
->head
+ 4, skb
->data
, skb
->len
);
225 skb_set_tail_pointer(skb
, skb
->len
);
228 struct sk_buff
*skb2
;
230 skb2
= skb_copy_expand(skb
, 4, padlen
, flags
);
231 dev_kfree_skb_any(skb
);
237 packet_len
= ((skb
->len
^ 0x0000ffff) << 16) + skb
->len
;
239 cpu_to_le32s(&packet_len
);
240 skb_copy_to_linear_data(skb
, &packet_len
, sizeof(packet_len
));
243 cpu_to_le32s(&padbytes
);
244 memcpy(skb_tail_pointer(skb
), &padbytes
, sizeof(padbytes
));
245 skb_put(skb
, sizeof(padbytes
));
248 usbnet_set_skb_tx_stats(skb
, 1, 0);
252 int asix_set_sw_mii(struct usbnet
*dev
, int in_pm
)
255 ret
= asix_write_cmd(dev
, AX_CMD_SET_SW_MII
, 0x0000, 0, 0, NULL
, in_pm
);
258 netdev_err(dev
->net
, "Failed to enable software MII access\n");
262 int asix_set_hw_mii(struct usbnet
*dev
, int in_pm
)
265 ret
= asix_write_cmd(dev
, AX_CMD_SET_HW_MII
, 0x0000, 0, 0, NULL
, in_pm
);
267 netdev_err(dev
->net
, "Failed to enable hardware MII access\n");
271 int asix_read_phy_addr(struct usbnet
*dev
, int internal
)
273 int offset
= (internal
? 1 : 0);
275 int ret
= asix_read_cmd(dev
, AX_CMD_READ_PHY_ID
, 0, 0, 2, buf
, 0);
277 netdev_dbg(dev
->net
, "asix_get_phy_addr()\n");
280 netdev_err(dev
->net
, "Error reading PHYID register: %02x\n", ret
);
283 netdev_dbg(dev
->net
, "asix_get_phy_addr() returning 0x%04x\n",
291 int asix_get_phy_addr(struct usbnet
*dev
)
293 /* return the address of the internal phy */
294 return asix_read_phy_addr(dev
, 1);
298 int asix_sw_reset(struct usbnet
*dev
, u8 flags
, int in_pm
)
302 ret
= asix_write_cmd(dev
, AX_CMD_SW_RESET
, flags
, 0, 0, NULL
, in_pm
);
304 netdev_err(dev
->net
, "Failed to send software reset: %02x\n", ret
);
309 u16
asix_read_rx_ctl(struct usbnet
*dev
, int in_pm
)
312 int ret
= asix_read_cmd(dev
, AX_CMD_READ_RX_CTL
, 0, 0, 2, &v
, in_pm
);
315 netdev_err(dev
->net
, "Error reading RX_CTL register: %02x\n", ret
);
318 ret
= le16_to_cpu(v
);
323 int asix_write_rx_ctl(struct usbnet
*dev
, u16 mode
, int in_pm
)
327 netdev_dbg(dev
->net
, "asix_write_rx_ctl() - mode = 0x%04x\n", mode
);
328 ret
= asix_write_cmd(dev
, AX_CMD_WRITE_RX_CTL
, mode
, 0, 0, NULL
, in_pm
);
330 netdev_err(dev
->net
, "Failed to write RX_CTL mode to 0x%04x: %02x\n",
336 u16
asix_read_medium_status(struct usbnet
*dev
, int in_pm
)
339 int ret
= asix_read_cmd(dev
, AX_CMD_READ_MEDIUM_STATUS
,
343 netdev_err(dev
->net
, "Error reading Medium Status register: %02x\n",
345 return ret
; /* TODO: callers not checking for error ret */
348 return le16_to_cpu(v
);
352 int asix_write_medium_mode(struct usbnet
*dev
, u16 mode
, int in_pm
)
356 netdev_dbg(dev
->net
, "asix_write_medium_mode() - mode = 0x%04x\n", mode
);
357 ret
= asix_write_cmd(dev
, AX_CMD_WRITE_MEDIUM_MODE
,
358 mode
, 0, 0, NULL
, in_pm
);
360 netdev_err(dev
->net
, "Failed to write Medium Mode mode to 0x%04x: %02x\n",
366 int asix_write_gpio(struct usbnet
*dev
, u16 value
, int sleep
, int in_pm
)
370 netdev_dbg(dev
->net
, "asix_write_gpio() - value = 0x%04x\n", value
);
371 ret
= asix_write_cmd(dev
, AX_CMD_WRITE_GPIOS
, value
, 0, 0, NULL
, in_pm
);
373 netdev_err(dev
->net
, "Failed to write GPIO value 0x%04x: %02x\n",
383 * AX88772 & AX88178 have a 16-bit RX_CTL value
385 void asix_set_multicast(struct net_device
*net
)
387 struct usbnet
*dev
= netdev_priv(net
);
388 struct asix_data
*data
= (struct asix_data
*)&dev
->data
;
389 u16 rx_ctl
= AX_DEFAULT_RX_CTL
;
391 if (net
->flags
& IFF_PROMISC
) {
392 rx_ctl
|= AX_RX_CTL_PRO
;
393 } else if (net
->flags
& IFF_ALLMULTI
||
394 netdev_mc_count(net
) > AX_MAX_MCAST
) {
395 rx_ctl
|= AX_RX_CTL_AMALL
;
396 } else if (netdev_mc_empty(net
)) {
397 /* just broadcast and directed */
399 /* We use the 20 byte dev->data
400 * for our 8 byte filter buffer
401 * to avoid allocating memory that
402 * is tricky to free later */
403 struct netdev_hw_addr
*ha
;
406 memset(data
->multi_filter
, 0, AX_MCAST_FILTER_SIZE
);
408 /* Build the multicast hash filter. */
409 netdev_for_each_mc_addr(ha
, net
) {
410 crc_bits
= ether_crc(ETH_ALEN
, ha
->addr
) >> 26;
411 data
->multi_filter
[crc_bits
>> 3] |=
415 asix_write_cmd_async(dev
, AX_CMD_WRITE_MULTI_FILTER
, 0, 0,
416 AX_MCAST_FILTER_SIZE
, data
->multi_filter
);
418 rx_ctl
|= AX_RX_CTL_AM
;
421 asix_write_cmd_async(dev
, AX_CMD_WRITE_RX_CTL
, rx_ctl
, 0, 0, NULL
);
424 int asix_mdio_read(struct net_device
*netdev
, int phy_id
, int loc
)
426 struct usbnet
*dev
= netdev_priv(netdev
);
432 mutex_lock(&dev
->phy_mutex
);
434 ret
= asix_set_sw_mii(dev
, 0);
435 if (ret
== -ENODEV
|| ret
== -ETIMEDOUT
)
437 usleep_range(1000, 1100);
438 ret
= asix_read_cmd(dev
, AX_CMD_STATMNGSTS_REG
,
440 } while (!(smsr
& AX_HOST_EN
) && (i
++ < 30) && (ret
!= -ENODEV
));
441 if (ret
== -ENODEV
|| ret
== -ETIMEDOUT
) {
442 mutex_unlock(&dev
->phy_mutex
);
446 asix_read_cmd(dev
, AX_CMD_READ_MII_REG
, phy_id
,
447 (__u16
)loc
, 2, &res
, 0);
448 asix_set_hw_mii(dev
, 0);
449 mutex_unlock(&dev
->phy_mutex
);
451 netdev_dbg(dev
->net
, "asix_mdio_read() phy_id=0x%02x, loc=0x%02x, returns=0x%04x\n",
452 phy_id
, loc
, le16_to_cpu(res
));
454 return le16_to_cpu(res
);
457 void asix_mdio_write(struct net_device
*netdev
, int phy_id
, int loc
, int val
)
459 struct usbnet
*dev
= netdev_priv(netdev
);
460 __le16 res
= cpu_to_le16(val
);
465 netdev_dbg(dev
->net
, "asix_mdio_write() phy_id=0x%02x, loc=0x%02x, val=0x%04x\n",
468 mutex_lock(&dev
->phy_mutex
);
470 ret
= asix_set_sw_mii(dev
, 0);
473 usleep_range(1000, 1100);
474 ret
= asix_read_cmd(dev
, AX_CMD_STATMNGSTS_REG
,
476 } while (!(smsr
& AX_HOST_EN
) && (i
++ < 30) && (ret
!= -ENODEV
));
477 if (ret
== -ENODEV
) {
478 mutex_unlock(&dev
->phy_mutex
);
482 asix_write_cmd(dev
, AX_CMD_WRITE_MII_REG
, phy_id
,
483 (__u16
)loc
, 2, &res
, 0);
484 asix_set_hw_mii(dev
, 0);
485 mutex_unlock(&dev
->phy_mutex
);
488 int asix_mdio_read_nopm(struct net_device
*netdev
, int phy_id
, int loc
)
490 struct usbnet
*dev
= netdev_priv(netdev
);
496 mutex_lock(&dev
->phy_mutex
);
498 ret
= asix_set_sw_mii(dev
, 1);
499 if (ret
== -ENODEV
|| ret
== -ETIMEDOUT
)
501 usleep_range(1000, 1100);
502 ret
= asix_read_cmd(dev
, AX_CMD_STATMNGSTS_REG
,
504 } while (!(smsr
& AX_HOST_EN
) && (i
++ < 30) && (ret
!= -ENODEV
));
505 if (ret
== -ENODEV
|| ret
== -ETIMEDOUT
) {
506 mutex_unlock(&dev
->phy_mutex
);
510 asix_read_cmd(dev
, AX_CMD_READ_MII_REG
, phy_id
,
511 (__u16
)loc
, 2, &res
, 1);
512 asix_set_hw_mii(dev
, 1);
513 mutex_unlock(&dev
->phy_mutex
);
515 netdev_dbg(dev
->net
, "asix_mdio_read_nopm() phy_id=0x%02x, loc=0x%02x, returns=0x%04x\n",
516 phy_id
, loc
, le16_to_cpu(res
));
518 return le16_to_cpu(res
);
522 asix_mdio_write_nopm(struct net_device
*netdev
, int phy_id
, int loc
, int val
)
524 struct usbnet
*dev
= netdev_priv(netdev
);
525 __le16 res
= cpu_to_le16(val
);
530 netdev_dbg(dev
->net
, "asix_mdio_write() phy_id=0x%02x, loc=0x%02x, val=0x%04x\n",
533 mutex_lock(&dev
->phy_mutex
);
535 ret
= asix_set_sw_mii(dev
, 1);
538 usleep_range(1000, 1100);
539 ret
= asix_read_cmd(dev
, AX_CMD_STATMNGSTS_REG
,
541 } while (!(smsr
& AX_HOST_EN
) && (i
++ < 30) && (ret
!= -ENODEV
));
542 if (ret
== -ENODEV
) {
543 mutex_unlock(&dev
->phy_mutex
);
547 asix_write_cmd(dev
, AX_CMD_WRITE_MII_REG
, phy_id
,
548 (__u16
)loc
, 2, &res
, 1);
549 asix_set_hw_mii(dev
, 1);
550 mutex_unlock(&dev
->phy_mutex
);
553 void asix_get_wol(struct net_device
*net
, struct ethtool_wolinfo
*wolinfo
)
555 struct usbnet
*dev
= netdev_priv(net
);
558 if (asix_read_cmd(dev
, AX_CMD_READ_MONITOR_MODE
,
559 0, 0, 1, &opt
, 0) < 0) {
560 wolinfo
->supported
= 0;
561 wolinfo
->wolopts
= 0;
564 wolinfo
->supported
= WAKE_PHY
| WAKE_MAGIC
;
565 wolinfo
->wolopts
= 0;
566 if (opt
& AX_MONITOR_LINK
)
567 wolinfo
->wolopts
|= WAKE_PHY
;
568 if (opt
& AX_MONITOR_MAGIC
)
569 wolinfo
->wolopts
|= WAKE_MAGIC
;
572 int asix_set_wol(struct net_device
*net
, struct ethtool_wolinfo
*wolinfo
)
574 struct usbnet
*dev
= netdev_priv(net
);
577 if (wolinfo
->wolopts
& WAKE_PHY
)
578 opt
|= AX_MONITOR_LINK
;
579 if (wolinfo
->wolopts
& WAKE_MAGIC
)
580 opt
|= AX_MONITOR_MAGIC
;
582 if (asix_write_cmd(dev
, AX_CMD_WRITE_MONITOR_MODE
,
583 opt
, 0, 0, NULL
, 0) < 0)
589 int asix_get_eeprom_len(struct net_device
*net
)
591 return AX_EEPROM_LEN
;
594 int asix_get_eeprom(struct net_device
*net
, struct ethtool_eeprom
*eeprom
,
597 struct usbnet
*dev
= netdev_priv(net
);
599 int first_word
, last_word
;
602 if (eeprom
->len
== 0)
605 eeprom
->magic
= AX_EEPROM_MAGIC
;
607 first_word
= eeprom
->offset
>> 1;
608 last_word
= (eeprom
->offset
+ eeprom
->len
- 1) >> 1;
610 eeprom_buff
= kmalloc(sizeof(u16
) * (last_word
- first_word
+ 1),
615 /* ax8817x returns 2 bytes from eeprom on read */
616 for (i
= first_word
; i
<= last_word
; i
++) {
617 if (asix_read_cmd(dev
, AX_CMD_READ_EEPROM
, i
, 0, 2,
618 &eeprom_buff
[i
- first_word
], 0) < 0) {
624 memcpy(data
, (u8
*)eeprom_buff
+ (eeprom
->offset
& 1), eeprom
->len
);
629 int asix_set_eeprom(struct net_device
*net
, struct ethtool_eeprom
*eeprom
,
632 struct usbnet
*dev
= netdev_priv(net
);
634 int first_word
, last_word
;
638 netdev_dbg(net
, "write EEPROM len %d, offset %d, magic 0x%x\n",
639 eeprom
->len
, eeprom
->offset
, eeprom
->magic
);
641 if (eeprom
->len
== 0)
644 if (eeprom
->magic
!= AX_EEPROM_MAGIC
)
647 first_word
= eeprom
->offset
>> 1;
648 last_word
= (eeprom
->offset
+ eeprom
->len
- 1) >> 1;
650 eeprom_buff
= kmalloc(sizeof(u16
) * (last_word
- first_word
+ 1),
655 /* align data to 16 bit boundaries, read the missing data from
657 if (eeprom
->offset
& 1) {
658 ret
= asix_read_cmd(dev
, AX_CMD_READ_EEPROM
, first_word
, 0, 2,
661 netdev_err(net
, "Failed to read EEPROM at offset 0x%02x.\n", first_word
);
666 if ((eeprom
->offset
+ eeprom
->len
) & 1) {
667 ret
= asix_read_cmd(dev
, AX_CMD_READ_EEPROM
, last_word
, 0, 2,
668 &eeprom_buff
[last_word
- first_word
], 0);
670 netdev_err(net
, "Failed to read EEPROM at offset 0x%02x.\n", last_word
);
675 memcpy((u8
*)eeprom_buff
+ (eeprom
->offset
& 1), data
, eeprom
->len
);
677 /* write data to EEPROM */
678 ret
= asix_write_cmd(dev
, AX_CMD_WRITE_ENABLE
, 0x0000, 0, 0, NULL
, 0);
680 netdev_err(net
, "Failed to enable EEPROM write\n");
685 for (i
= first_word
; i
<= last_word
; i
++) {
686 netdev_dbg(net
, "write to EEPROM at offset 0x%02x, data 0x%04x\n",
687 i
, eeprom_buff
[i
- first_word
]);
688 ret
= asix_write_cmd(dev
, AX_CMD_WRITE_EEPROM
, i
,
689 eeprom_buff
[i
- first_word
], 0, NULL
, 0);
691 netdev_err(net
, "Failed to write EEPROM at offset 0x%02x.\n",
698 ret
= asix_write_cmd(dev
, AX_CMD_WRITE_DISABLE
, 0x0000, 0, 0, NULL
, 0);
700 netdev_err(net
, "Failed to disable EEPROM write\n");
710 void asix_get_drvinfo(struct net_device
*net
, struct ethtool_drvinfo
*info
)
712 /* Inherit standard device info */
713 usbnet_get_drvinfo(net
, info
);
714 strlcpy(info
->driver
, DRIVER_NAME
, sizeof(info
->driver
));
715 strlcpy(info
->version
, DRIVER_VERSION
, sizeof(info
->version
));
718 int asix_set_mac_address(struct net_device
*net
, void *p
)
720 struct usbnet
*dev
= netdev_priv(net
);
721 struct asix_data
*data
= (struct asix_data
*)&dev
->data
;
722 struct sockaddr
*addr
= p
;
724 if (netif_running(net
))
726 if (!is_valid_ether_addr(addr
->sa_data
))
727 return -EADDRNOTAVAIL
;
729 memcpy(net
->dev_addr
, addr
->sa_data
, ETH_ALEN
);
731 /* We use the 20 byte dev->data
732 * for our 6 byte mac buffer
733 * to avoid allocating memory that
734 * is tricky to free later */
735 memcpy(data
->mac_addr
, addr
->sa_data
, ETH_ALEN
);
736 asix_write_cmd_async(dev
, AX_CMD_WRITE_NODE_ID
, 0, 0, ETH_ALEN
,