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
,
28 ret
= usbnet_read_cmd(dev
, cmd
,
29 USB_DIR_IN
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
30 value
, index
, data
, size
);
32 if (ret
!= size
&& ret
>= 0)
37 int asix_write_cmd(struct usbnet
*dev
, u8 cmd
, u16 value
, u16 index
,
40 return usbnet_write_cmd(dev
, cmd
,
41 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
42 value
, index
, data
, size
);
45 void asix_write_cmd_async(struct usbnet
*dev
, u8 cmd
, u16 value
, u16 index
,
48 usbnet_write_cmd_async(dev
, cmd
,
49 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
50 value
, index
, data
, size
);
53 int asix_rx_fixup_internal(struct usbnet
*dev
, struct sk_buff
*skb
,
54 struct asix_rx_fixup_info
*rx
)
59 /* When an Ethernet frame spans multiple URB socket buffers,
60 * do a sanity test for the Data header synchronisation.
61 * Attempt to detect the situation of the previous socket buffer having
62 * been truncated or a socket buffer was missing. These situations
63 * cause a discontinuity in the data stream and therefore need to avoid
64 * appending bad data to the end of the current netdev socket buffer.
65 * Also avoid unnecessarily discarding a good current netdev socket
68 if (rx
->remaining
&& (rx
->remaining
+ sizeof(u32
) <= skb
->len
)) {
69 offset
= ((rx
->remaining
+ 1) & 0xfffe);
70 rx
->header
= get_unaligned_le32(skb
->data
+ offset
);
73 size
= (u16
)(rx
->header
& 0x7ff);
74 if (size
!= ((~rx
->header
>> 16) & 0x7ff)) {
75 netdev_err(dev
->net
, "asix_rx_fixup() Data Header synchronisation was lost, remaining %d\n",
78 kfree_skb(rx
->ax_skb
);
80 /* Discard the incomplete netdev Ethernet frame
81 * and assume the Data header is at the start of
82 * the current URB socket buffer.
89 while (offset
+ sizeof(u16
) <= skb
->len
) {
94 if (skb
->len
- offset
== sizeof(u16
)) {
95 rx
->header
= get_unaligned_le16(
97 rx
->split_head
= true;
98 offset
+= sizeof(u16
);
102 if (rx
->split_head
== true) {
103 rx
->header
|= (get_unaligned_le16(
104 skb
->data
+ offset
) << 16);
105 rx
->split_head
= false;
106 offset
+= sizeof(u16
);
108 rx
->header
= get_unaligned_le32(skb
->data
+
110 offset
+= sizeof(u32
);
113 /* take frame length from Data header 32-bit word */
114 size
= (u16
)(rx
->header
& 0x7ff);
115 if (size
!= ((~rx
->header
>> 16) & 0x7ff)) {
116 netdev_err(dev
->net
, "asix_rx_fixup() Bad Header Length 0x%x, offset %d\n",
120 if (size
> dev
->net
->mtu
+ ETH_HLEN
+ VLAN_HLEN
) {
121 netdev_dbg(dev
->net
, "asix_rx_fixup() Bad RX Length %d\n",
126 /* Sometimes may fail to get a netdev socket buffer but
127 * continue to process the URB socket buffer so that
128 * synchronisation of the Ethernet frame Data header
129 * word is maintained.
131 rx
->ax_skb
= netdev_alloc_skb_ip_align(dev
->net
, size
);
133 rx
->remaining
= size
;
136 if (rx
->remaining
> skb
->len
- offset
) {
137 copy_length
= skb
->len
- offset
;
138 rx
->remaining
-= copy_length
;
140 copy_length
= rx
->remaining
;
145 data
= skb_put(rx
->ax_skb
, copy_length
);
146 memcpy(data
, skb
->data
+ offset
, copy_length
);
148 usbnet_skb_return(dev
, rx
->ax_skb
);
151 offset
+= (copy_length
+ 1) & 0xfffe;
154 if (skb
->len
!= offset
) {
155 netdev_err(dev
->net
, "asix_rx_fixup() Bad SKB Length %d, %d\n",
163 int asix_rx_fixup_common(struct usbnet
*dev
, struct sk_buff
*skb
)
165 struct asix_common_private
*dp
= dev
->driver_priv
;
166 struct asix_rx_fixup_info
*rx
= &dp
->rx_fixup_info
;
168 return asix_rx_fixup_internal(dev
, skb
, rx
);
171 struct sk_buff
*asix_tx_fixup(struct usbnet
*dev
, struct sk_buff
*skb
,
175 int headroom
= skb_headroom(skb
);
176 int tailroom
= skb_tailroom(skb
);
178 u32 padbytes
= 0xffff0000;
180 padlen
= ((skb
->len
+ 4) & (dev
->maxpacket
- 1)) ? 0 : 4;
182 /* We need to push 4 bytes in front of frame (packet_len)
183 * and maybe add 4 bytes after the end (if padlen is 4)
185 * Avoid skb_copy_expand() expensive call, using following rules :
186 * - We are allowed to push 4 bytes in headroom if skb_header_cloned()
187 * is false (and if we have 4 bytes of headroom)
188 * - We are allowed to put 4 bytes at tail if skb_cloned()
189 * is false (and if we have 4 bytes of tailroom)
191 * TCP packets for example are cloned, but skb_header_release()
192 * was called in tcp stack, allowing us to use headroom for our needs.
194 if (!skb_header_cloned(skb
) &&
195 !(padlen
&& skb_cloned(skb
)) &&
196 headroom
+ tailroom
>= 4 + padlen
) {
197 /* following should not happen, but better be safe */
200 skb
->data
= memmove(skb
->head
+ 4, skb
->data
, skb
->len
);
201 skb_set_tail_pointer(skb
, skb
->len
);
204 struct sk_buff
*skb2
;
206 skb2
= skb_copy_expand(skb
, 4, padlen
, flags
);
207 dev_kfree_skb_any(skb
);
213 packet_len
= ((skb
->len
^ 0x0000ffff) << 16) + skb
->len
;
215 cpu_to_le32s(&packet_len
);
216 skb_copy_to_linear_data(skb
, &packet_len
, sizeof(packet_len
));
219 cpu_to_le32s(&padbytes
);
220 memcpy(skb_tail_pointer(skb
), &padbytes
, sizeof(padbytes
));
221 skb_put(skb
, sizeof(padbytes
));
224 usbnet_set_skb_tx_stats(skb
, 1, 0);
228 int asix_set_sw_mii(struct usbnet
*dev
)
231 ret
= asix_write_cmd(dev
, AX_CMD_SET_SW_MII
, 0x0000, 0, 0, NULL
);
233 netdev_err(dev
->net
, "Failed to enable software MII access\n");
237 int asix_set_hw_mii(struct usbnet
*dev
)
240 ret
= asix_write_cmd(dev
, AX_CMD_SET_HW_MII
, 0x0000, 0, 0, NULL
);
242 netdev_err(dev
->net
, "Failed to enable hardware MII access\n");
246 int asix_read_phy_addr(struct usbnet
*dev
, int internal
)
248 int offset
= (internal
? 1 : 0);
250 int ret
= asix_read_cmd(dev
, AX_CMD_READ_PHY_ID
, 0, 0, 2, buf
);
252 netdev_dbg(dev
->net
, "asix_get_phy_addr()\n");
255 netdev_err(dev
->net
, "Error reading PHYID register: %02x\n", ret
);
258 netdev_dbg(dev
->net
, "asix_get_phy_addr() returning 0x%04x\n",
266 int asix_get_phy_addr(struct usbnet
*dev
)
268 /* return the address of the internal phy */
269 return asix_read_phy_addr(dev
, 1);
273 int asix_sw_reset(struct usbnet
*dev
, u8 flags
)
277 ret
= asix_write_cmd(dev
, AX_CMD_SW_RESET
, flags
, 0, 0, NULL
);
279 netdev_err(dev
->net
, "Failed to send software reset: %02x\n", ret
);
284 u16
asix_read_rx_ctl(struct usbnet
*dev
)
287 int ret
= asix_read_cmd(dev
, AX_CMD_READ_RX_CTL
, 0, 0, 2, &v
);
290 netdev_err(dev
->net
, "Error reading RX_CTL register: %02x\n", ret
);
293 ret
= le16_to_cpu(v
);
298 int asix_write_rx_ctl(struct usbnet
*dev
, u16 mode
)
302 netdev_dbg(dev
->net
, "asix_write_rx_ctl() - mode = 0x%04x\n", mode
);
303 ret
= asix_write_cmd(dev
, AX_CMD_WRITE_RX_CTL
, mode
, 0, 0, NULL
);
305 netdev_err(dev
->net
, "Failed to write RX_CTL mode to 0x%04x: %02x\n",
311 u16
asix_read_medium_status(struct usbnet
*dev
)
314 int ret
= asix_read_cmd(dev
, AX_CMD_READ_MEDIUM_STATUS
, 0, 0, 2, &v
);
317 netdev_err(dev
->net
, "Error reading Medium Status register: %02x\n",
319 return ret
; /* TODO: callers not checking for error ret */
322 return le16_to_cpu(v
);
326 int asix_write_medium_mode(struct usbnet
*dev
, u16 mode
)
330 netdev_dbg(dev
->net
, "asix_write_medium_mode() - mode = 0x%04x\n", mode
);
331 ret
= asix_write_cmd(dev
, AX_CMD_WRITE_MEDIUM_MODE
, mode
, 0, 0, NULL
);
333 netdev_err(dev
->net
, "Failed to write Medium Mode mode to 0x%04x: %02x\n",
339 int asix_write_gpio(struct usbnet
*dev
, u16 value
, int sleep
)
343 netdev_dbg(dev
->net
, "asix_write_gpio() - value = 0x%04x\n", value
);
344 ret
= asix_write_cmd(dev
, AX_CMD_WRITE_GPIOS
, value
, 0, 0, NULL
);
346 netdev_err(dev
->net
, "Failed to write GPIO value 0x%04x: %02x\n",
356 * AX88772 & AX88178 have a 16-bit RX_CTL value
358 void asix_set_multicast(struct net_device
*net
)
360 struct usbnet
*dev
= netdev_priv(net
);
361 struct asix_data
*data
= (struct asix_data
*)&dev
->data
;
362 u16 rx_ctl
= AX_DEFAULT_RX_CTL
;
364 if (net
->flags
& IFF_PROMISC
) {
365 rx_ctl
|= AX_RX_CTL_PRO
;
366 } else if (net
->flags
& IFF_ALLMULTI
||
367 netdev_mc_count(net
) > AX_MAX_MCAST
) {
368 rx_ctl
|= AX_RX_CTL_AMALL
;
369 } else if (netdev_mc_empty(net
)) {
370 /* just broadcast and directed */
372 /* We use the 20 byte dev->data
373 * for our 8 byte filter buffer
374 * to avoid allocating memory that
375 * is tricky to free later */
376 struct netdev_hw_addr
*ha
;
379 memset(data
->multi_filter
, 0, AX_MCAST_FILTER_SIZE
);
381 /* Build the multicast hash filter. */
382 netdev_for_each_mc_addr(ha
, net
) {
383 crc_bits
= ether_crc(ETH_ALEN
, ha
->addr
) >> 26;
384 data
->multi_filter
[crc_bits
>> 3] |=
388 asix_write_cmd_async(dev
, AX_CMD_WRITE_MULTI_FILTER
, 0, 0,
389 AX_MCAST_FILTER_SIZE
, data
->multi_filter
);
391 rx_ctl
|= AX_RX_CTL_AM
;
394 asix_write_cmd_async(dev
, AX_CMD_WRITE_RX_CTL
, rx_ctl
, 0, 0, NULL
);
397 int asix_mdio_read(struct net_device
*netdev
, int phy_id
, int loc
)
399 struct usbnet
*dev
= netdev_priv(netdev
);
402 mutex_lock(&dev
->phy_mutex
);
403 asix_set_sw_mii(dev
);
404 asix_read_cmd(dev
, AX_CMD_READ_MII_REG
, phy_id
,
405 (__u16
)loc
, 2, &res
);
406 asix_set_hw_mii(dev
);
407 mutex_unlock(&dev
->phy_mutex
);
409 netdev_dbg(dev
->net
, "asix_mdio_read() phy_id=0x%02x, loc=0x%02x, returns=0x%04x\n",
410 phy_id
, loc
, le16_to_cpu(res
));
412 return le16_to_cpu(res
);
415 void asix_mdio_write(struct net_device
*netdev
, int phy_id
, int loc
, int val
)
417 struct usbnet
*dev
= netdev_priv(netdev
);
418 __le16 res
= cpu_to_le16(val
);
420 netdev_dbg(dev
->net
, "asix_mdio_write() phy_id=0x%02x, loc=0x%02x, val=0x%04x\n",
422 mutex_lock(&dev
->phy_mutex
);
423 asix_set_sw_mii(dev
);
424 asix_write_cmd(dev
, AX_CMD_WRITE_MII_REG
, phy_id
, (__u16
)loc
, 2, &res
);
425 asix_set_hw_mii(dev
);
426 mutex_unlock(&dev
->phy_mutex
);
429 void asix_get_wol(struct net_device
*net
, struct ethtool_wolinfo
*wolinfo
)
431 struct usbnet
*dev
= netdev_priv(net
);
434 if (asix_read_cmd(dev
, AX_CMD_READ_MONITOR_MODE
, 0, 0, 1, &opt
) < 0) {
435 wolinfo
->supported
= 0;
436 wolinfo
->wolopts
= 0;
439 wolinfo
->supported
= WAKE_PHY
| WAKE_MAGIC
;
440 wolinfo
->wolopts
= 0;
441 if (opt
& AX_MONITOR_LINK
)
442 wolinfo
->wolopts
|= WAKE_PHY
;
443 if (opt
& AX_MONITOR_MAGIC
)
444 wolinfo
->wolopts
|= WAKE_MAGIC
;
447 int asix_set_wol(struct net_device
*net
, struct ethtool_wolinfo
*wolinfo
)
449 struct usbnet
*dev
= netdev_priv(net
);
452 if (wolinfo
->wolopts
& WAKE_PHY
)
453 opt
|= AX_MONITOR_LINK
;
454 if (wolinfo
->wolopts
& WAKE_MAGIC
)
455 opt
|= AX_MONITOR_MAGIC
;
457 if (asix_write_cmd(dev
, AX_CMD_WRITE_MONITOR_MODE
,
458 opt
, 0, 0, NULL
) < 0)
464 int asix_get_eeprom_len(struct net_device
*net
)
466 return AX_EEPROM_LEN
;
469 int asix_get_eeprom(struct net_device
*net
, struct ethtool_eeprom
*eeprom
,
472 struct usbnet
*dev
= netdev_priv(net
);
474 int first_word
, last_word
;
477 if (eeprom
->len
== 0)
480 eeprom
->magic
= AX_EEPROM_MAGIC
;
482 first_word
= eeprom
->offset
>> 1;
483 last_word
= (eeprom
->offset
+ eeprom
->len
- 1) >> 1;
485 eeprom_buff
= kmalloc(sizeof(u16
) * (last_word
- first_word
+ 1),
490 /* ax8817x returns 2 bytes from eeprom on read */
491 for (i
= first_word
; i
<= last_word
; i
++) {
492 if (asix_read_cmd(dev
, AX_CMD_READ_EEPROM
, i
, 0, 2,
493 &(eeprom_buff
[i
- first_word
])) < 0) {
499 memcpy(data
, (u8
*)eeprom_buff
+ (eeprom
->offset
& 1), eeprom
->len
);
504 int asix_set_eeprom(struct net_device
*net
, struct ethtool_eeprom
*eeprom
,
507 struct usbnet
*dev
= netdev_priv(net
);
509 int first_word
, last_word
;
513 netdev_dbg(net
, "write EEPROM len %d, offset %d, magic 0x%x\n",
514 eeprom
->len
, eeprom
->offset
, eeprom
->magic
);
516 if (eeprom
->len
== 0)
519 if (eeprom
->magic
!= AX_EEPROM_MAGIC
)
522 first_word
= eeprom
->offset
>> 1;
523 last_word
= (eeprom
->offset
+ eeprom
->len
- 1) >> 1;
525 eeprom_buff
= kmalloc(sizeof(u16
) * (last_word
- first_word
+ 1),
530 /* align data to 16 bit boundaries, read the missing data from
532 if (eeprom
->offset
& 1) {
533 ret
= asix_read_cmd(dev
, AX_CMD_READ_EEPROM
, first_word
, 0, 2,
536 netdev_err(net
, "Failed to read EEPROM at offset 0x%02x.\n", first_word
);
541 if ((eeprom
->offset
+ eeprom
->len
) & 1) {
542 ret
= asix_read_cmd(dev
, AX_CMD_READ_EEPROM
, last_word
, 0, 2,
543 &(eeprom_buff
[last_word
- first_word
]));
545 netdev_err(net
, "Failed to read EEPROM at offset 0x%02x.\n", last_word
);
550 memcpy((u8
*)eeprom_buff
+ (eeprom
->offset
& 1), data
, eeprom
->len
);
552 /* write data to EEPROM */
553 ret
= asix_write_cmd(dev
, AX_CMD_WRITE_ENABLE
, 0x0000, 0, 0, NULL
);
555 netdev_err(net
, "Failed to enable EEPROM write\n");
560 for (i
= first_word
; i
<= last_word
; i
++) {
561 netdev_dbg(net
, "write to EEPROM at offset 0x%02x, data 0x%04x\n",
562 i
, eeprom_buff
[i
- first_word
]);
563 ret
= asix_write_cmd(dev
, AX_CMD_WRITE_EEPROM
, i
,
564 eeprom_buff
[i
- first_word
], 0, NULL
);
566 netdev_err(net
, "Failed to write EEPROM at offset 0x%02x.\n",
573 ret
= asix_write_cmd(dev
, AX_CMD_WRITE_DISABLE
, 0x0000, 0, 0, NULL
);
575 netdev_err(net
, "Failed to disable EEPROM write\n");
585 void asix_get_drvinfo(struct net_device
*net
, struct ethtool_drvinfo
*info
)
587 /* Inherit standard device info */
588 usbnet_get_drvinfo(net
, info
);
589 strlcpy(info
->driver
, DRIVER_NAME
, sizeof(info
->driver
));
590 strlcpy(info
->version
, DRIVER_VERSION
, sizeof(info
->version
));
593 int asix_set_mac_address(struct net_device
*net
, void *p
)
595 struct usbnet
*dev
= netdev_priv(net
);
596 struct asix_data
*data
= (struct asix_data
*)&dev
->data
;
597 struct sockaddr
*addr
= p
;
599 if (netif_running(net
))
601 if (!is_valid_ether_addr(addr
->sa_data
))
602 return -EADDRNOTAVAIL
;
604 memcpy(net
->dev_addr
, addr
->sa_data
, ETH_ALEN
);
606 /* We use the 20 byte dev->data
607 * for our 6 byte mac buffer
608 * to avoid allocating memory that
609 * is tricky to free later */
610 memcpy(data
->mac_addr
, addr
->sa_data
, ETH_ALEN
);
611 asix_write_cmd_async(dev
, AX_CMD_WRITE_NODE_ID
, 0, 0, ETH_ALEN
,