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, see <http://www.gnu.org/licenses/>. 20 */ 21 22 #include "asix.h" 23 24 int asix_read_cmd(struct usbnet *dev, u8 cmd, u16 value, u16 index, 25 u16 size, void *data, int in_pm) 26 { 27 int ret; 28 int (*fn)(struct usbnet *, u8, u8, u16, u16, void *, u16); 29 30 BUG_ON(!dev); 31 32 if (!in_pm) 33 fn = usbnet_read_cmd; 34 else 35 fn = usbnet_read_cmd_nopm; 36 37 ret = fn(dev, cmd, USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 38 value, index, data, size); 39 40 if (unlikely(ret < 0)) 41 netdev_warn(dev->net, "Failed to read reg index 0x%04x: %d\n", 42 index, ret); 43 44 return ret; 45 } 46 47 int asix_write_cmd(struct usbnet *dev, u8 cmd, u16 value, u16 index, 48 u16 size, void *data, int in_pm) 49 { 50 int ret; 51 int (*fn)(struct usbnet *, u8, u8, u16, u16, const void *, u16); 52 53 BUG_ON(!dev); 54 55 if (!in_pm) 56 fn = usbnet_write_cmd; 57 else 58 fn = usbnet_write_cmd_nopm; 59 60 ret = fn(dev, cmd, USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 61 value, index, data, size); 62 63 if (unlikely(ret < 0)) 64 netdev_warn(dev->net, "Failed to write reg index 0x%04x: %d\n", 65 index, ret); 66 67 return ret; 68 } 69 70 void asix_write_cmd_async(struct usbnet *dev, u8 cmd, u16 value, u16 index, 71 u16 size, void *data) 72 { 73 usbnet_write_cmd_async(dev, cmd, 74 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 75 value, index, data, size); 76 } 77 78 int asix_rx_fixup_internal(struct usbnet *dev, struct sk_buff *skb, 79 struct asix_rx_fixup_info *rx) 80 { 81 int offset = 0; 82 u16 size; 83 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 91 * buffer. 92 */ 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); 96 offset = 0; 97 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", 101 rx->remaining); 102 if (rx->ax_skb) { 103 kfree_skb(rx->ax_skb); 104 rx->ax_skb = NULL; 105 /* Discard the incomplete netdev Ethernet frame 106 * and assume the Data header is at the start of 107 * the current URB socket buffer. 108 */ 109 } 110 rx->remaining = 0; 111 } 112 } 113 114 while (offset + sizeof(u16) <= skb->len) { 115 u16 copy_length; 116 117 if (!rx->remaining) { 118 if (skb->len - offset == sizeof(u16)) { 119 rx->header = get_unaligned_le16( 120 skb->data + offset); 121 rx->split_head = true; 122 offset += sizeof(u16); 123 break; 124 } 125 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); 131 } else { 132 rx->header = get_unaligned_le32(skb->data + 133 offset); 134 offset += sizeof(u32); 135 } 136 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", 141 rx->header, offset); 142 return 0; 143 } 144 if (size > dev->net->mtu + ETH_HLEN + VLAN_HLEN) { 145 netdev_dbg(dev->net, "asix_rx_fixup() Bad RX Length %d\n", 146 size); 147 return 0; 148 } 149 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. 154 */ 155 rx->ax_skb = netdev_alloc_skb_ip_align(dev->net, size); 156 157 rx->remaining = size; 158 } 159 160 if (rx->remaining > skb->len - offset) { 161 copy_length = skb->len - offset; 162 rx->remaining -= copy_length; 163 } else { 164 copy_length = rx->remaining; 165 rx->remaining = 0; 166 } 167 168 if (rx->ax_skb) { 169 skb_put_data(rx->ax_skb, skb->data + offset, 170 copy_length); 171 if (!rx->remaining) 172 usbnet_skb_return(dev, rx->ax_skb); 173 } 174 175 offset += (copy_length + 1) & 0xfffe; 176 } 177 178 if (skb->len != offset) { 179 netdev_err(dev->net, "asix_rx_fixup() Bad SKB Length %d, %d\n", 180 skb->len, offset); 181 return 0; 182 } 183 184 return 1; 185 } 186 187 int asix_rx_fixup_common(struct usbnet *dev, struct sk_buff *skb) 188 { 189 struct asix_common_private *dp = dev->driver_priv; 190 struct asix_rx_fixup_info *rx = &dp->rx_fixup_info; 191 192 return asix_rx_fixup_internal(dev, skb, rx); 193 } 194 195 struct sk_buff *asix_tx_fixup(struct usbnet *dev, struct sk_buff *skb, 196 gfp_t flags) 197 { 198 int padlen; 199 int headroom = skb_headroom(skb); 200 int tailroom = skb_tailroom(skb); 201 u32 packet_len; 202 u32 padbytes = 0xffff0000; 203 204 padlen = ((skb->len + 4) & (dev->maxpacket - 1)) ? 0 : 4; 205 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) 208 * 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) 214 * 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. 217 */ 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 */ 222 if (headroom < 4 || 223 tailroom < padlen) { 224 skb->data = memmove(skb->head + 4, skb->data, skb->len); 225 skb_set_tail_pointer(skb, skb->len); 226 } 227 } else { 228 struct sk_buff *skb2; 229 230 skb2 = skb_copy_expand(skb, 4, padlen, flags); 231 dev_kfree_skb_any(skb); 232 skb = skb2; 233 if (!skb) 234 return NULL; 235 } 236 237 packet_len = ((skb->len ^ 0x0000ffff) << 16) + skb->len; 238 skb_push(skb, 4); 239 cpu_to_le32s(&packet_len); 240 skb_copy_to_linear_data(skb, &packet_len, sizeof(packet_len)); 241 242 if (padlen) { 243 cpu_to_le32s(&padbytes); 244 memcpy(skb_tail_pointer(skb), &padbytes, sizeof(padbytes)); 245 skb_put(skb, sizeof(padbytes)); 246 } 247 248 usbnet_set_skb_tx_stats(skb, 1, 0); 249 return skb; 250 } 251 252 int asix_set_sw_mii(struct usbnet *dev, int in_pm) 253 { 254 int ret; 255 ret = asix_write_cmd(dev, AX_CMD_SET_SW_MII, 0x0000, 0, 0, NULL, in_pm); 256 257 if (ret < 0) 258 netdev_err(dev->net, "Failed to enable software MII access\n"); 259 return ret; 260 } 261 262 int asix_set_hw_mii(struct usbnet *dev, int in_pm) 263 { 264 int ret; 265 ret = asix_write_cmd(dev, AX_CMD_SET_HW_MII, 0x0000, 0, 0, NULL, in_pm); 266 if (ret < 0) 267 netdev_err(dev->net, "Failed to enable hardware MII access\n"); 268 return ret; 269 } 270 271 int asix_read_phy_addr(struct usbnet *dev, int internal) 272 { 273 int offset = (internal ? 1 : 0); 274 u8 buf[2]; 275 int ret = asix_read_cmd(dev, AX_CMD_READ_PHY_ID, 0, 0, 2, buf, 0); 276 277 netdev_dbg(dev->net, "asix_get_phy_addr()\n"); 278 279 if (ret < 0) { 280 netdev_err(dev->net, "Error reading PHYID register: %02x\n", ret); 281 goto out; 282 } 283 netdev_dbg(dev->net, "asix_get_phy_addr() returning 0x%04x\n", 284 *((__le16 *)buf)); 285 ret = buf[offset]; 286 287 out: 288 return ret; 289 } 290 291 int asix_get_phy_addr(struct usbnet *dev) 292 { 293 /* return the address of the internal phy */ 294 return asix_read_phy_addr(dev, 1); 295 } 296 297 298 int asix_sw_reset(struct usbnet *dev, u8 flags, int in_pm) 299 { 300 int ret; 301 302 ret = asix_write_cmd(dev, AX_CMD_SW_RESET, flags, 0, 0, NULL, in_pm); 303 if (ret < 0) 304 netdev_err(dev->net, "Failed to send software reset: %02x\n", ret); 305 306 return ret; 307 } 308 309 u16 asix_read_rx_ctl(struct usbnet *dev, int in_pm) 310 { 311 __le16 v; 312 int ret = asix_read_cmd(dev, AX_CMD_READ_RX_CTL, 0, 0, 2, &v, in_pm); 313 314 if (ret < 0) { 315 netdev_err(dev->net, "Error reading RX_CTL register: %02x\n", ret); 316 goto out; 317 } 318 ret = le16_to_cpu(v); 319 out: 320 return ret; 321 } 322 323 int asix_write_rx_ctl(struct usbnet *dev, u16 mode, int in_pm) 324 { 325 int ret; 326 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); 329 if (ret < 0) 330 netdev_err(dev->net, "Failed to write RX_CTL mode to 0x%04x: %02x\n", 331 mode, ret); 332 333 return ret; 334 } 335 336 u16 asix_read_medium_status(struct usbnet *dev, int in_pm) 337 { 338 __le16 v; 339 int ret = asix_read_cmd(dev, AX_CMD_READ_MEDIUM_STATUS, 340 0, 0, 2, &v, in_pm); 341 342 if (ret < 0) { 343 netdev_err(dev->net, "Error reading Medium Status register: %02x\n", 344 ret); 345 return ret; /* TODO: callers not checking for error ret */ 346 } 347 348 return le16_to_cpu(v); 349 350 } 351 352 int asix_write_medium_mode(struct usbnet *dev, u16 mode, int in_pm) 353 { 354 int ret; 355 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); 359 if (ret < 0) 360 netdev_err(dev->net, "Failed to write Medium Mode mode to 0x%04x: %02x\n", 361 mode, ret); 362 363 return ret; 364 } 365 366 int asix_write_gpio(struct usbnet *dev, u16 value, int sleep, int in_pm) 367 { 368 int ret; 369 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); 372 if (ret < 0) 373 netdev_err(dev->net, "Failed to write GPIO value 0x%04x: %02x\n", 374 value, ret); 375 376 if (sleep) 377 msleep(sleep); 378 379 return ret; 380 } 381 382 /* 383 * AX88772 & AX88178 have a 16-bit RX_CTL value 384 */ 385 void asix_set_multicast(struct net_device *net) 386 { 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; 390 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 */ 398 } else { 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; 404 u32 crc_bits; 405 406 memset(data->multi_filter, 0, AX_MCAST_FILTER_SIZE); 407 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] |= 412 1 << (crc_bits & 7); 413 } 414 415 asix_write_cmd_async(dev, AX_CMD_WRITE_MULTI_FILTER, 0, 0, 416 AX_MCAST_FILTER_SIZE, data->multi_filter); 417 418 rx_ctl |= AX_RX_CTL_AM; 419 } 420 421 asix_write_cmd_async(dev, AX_CMD_WRITE_RX_CTL, rx_ctl, 0, 0, NULL); 422 } 423 424 int asix_mdio_read(struct net_device *netdev, int phy_id, int loc) 425 { 426 struct usbnet *dev = netdev_priv(netdev); 427 __le16 res; 428 u8 smsr; 429 int i = 0; 430 int ret; 431 432 mutex_lock(&dev->phy_mutex); 433 do { 434 ret = asix_set_sw_mii(dev, 0); 435 if (ret == -ENODEV || ret == -ETIMEDOUT) 436 break; 437 usleep_range(1000, 1100); 438 ret = asix_read_cmd(dev, AX_CMD_STATMNGSTS_REG, 439 0, 0, 1, &smsr, 0); 440 } while (!(smsr & AX_HOST_EN) && (i++ < 30) && (ret != -ENODEV)); 441 if (ret == -ENODEV || ret == -ETIMEDOUT) { 442 mutex_unlock(&dev->phy_mutex); 443 return ret; 444 } 445 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); 450 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)); 453 454 return le16_to_cpu(res); 455 } 456 457 void asix_mdio_write(struct net_device *netdev, int phy_id, int loc, int val) 458 { 459 struct usbnet *dev = netdev_priv(netdev); 460 __le16 res = cpu_to_le16(val); 461 u8 smsr; 462 int i = 0; 463 int ret; 464 465 netdev_dbg(dev->net, "asix_mdio_write() phy_id=0x%02x, loc=0x%02x, val=0x%04x\n", 466 phy_id, loc, val); 467 468 mutex_lock(&dev->phy_mutex); 469 do { 470 ret = asix_set_sw_mii(dev, 0); 471 if (ret == -ENODEV) 472 break; 473 usleep_range(1000, 1100); 474 ret = asix_read_cmd(dev, AX_CMD_STATMNGSTS_REG, 475 0, 0, 1, &smsr, 0); 476 } while (!(smsr & AX_HOST_EN) && (i++ < 30) && (ret != -ENODEV)); 477 if (ret == -ENODEV) { 478 mutex_unlock(&dev->phy_mutex); 479 return; 480 } 481 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); 486 } 487 488 int asix_mdio_read_nopm(struct net_device *netdev, int phy_id, int loc) 489 { 490 struct usbnet *dev = netdev_priv(netdev); 491 __le16 res; 492 u8 smsr; 493 int i = 0; 494 int ret; 495 496 mutex_lock(&dev->phy_mutex); 497 do { 498 ret = asix_set_sw_mii(dev, 1); 499 if (ret == -ENODEV || ret == -ETIMEDOUT) 500 break; 501 usleep_range(1000, 1100); 502 ret = asix_read_cmd(dev, AX_CMD_STATMNGSTS_REG, 503 0, 0, 1, &smsr, 1); 504 } while (!(smsr & AX_HOST_EN) && (i++ < 30) && (ret != -ENODEV)); 505 if (ret == -ENODEV || ret == -ETIMEDOUT) { 506 mutex_unlock(&dev->phy_mutex); 507 return ret; 508 } 509 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); 514 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)); 517 518 return le16_to_cpu(res); 519 } 520 521 void 522 asix_mdio_write_nopm(struct net_device *netdev, int phy_id, int loc, int val) 523 { 524 struct usbnet *dev = netdev_priv(netdev); 525 __le16 res = cpu_to_le16(val); 526 u8 smsr; 527 int i = 0; 528 int ret; 529 530 netdev_dbg(dev->net, "asix_mdio_write() phy_id=0x%02x, loc=0x%02x, val=0x%04x\n", 531 phy_id, loc, val); 532 533 mutex_lock(&dev->phy_mutex); 534 do { 535 ret = asix_set_sw_mii(dev, 1); 536 if (ret == -ENODEV) 537 break; 538 usleep_range(1000, 1100); 539 ret = asix_read_cmd(dev, AX_CMD_STATMNGSTS_REG, 540 0, 0, 1, &smsr, 1); 541 } while (!(smsr & AX_HOST_EN) && (i++ < 30) && (ret != -ENODEV)); 542 if (ret == -ENODEV) { 543 mutex_unlock(&dev->phy_mutex); 544 return; 545 } 546 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); 551 } 552 553 void asix_get_wol(struct net_device *net, struct ethtool_wolinfo *wolinfo) 554 { 555 struct usbnet *dev = netdev_priv(net); 556 u8 opt; 557 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; 562 return; 563 } 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; 570 } 571 572 int asix_set_wol(struct net_device *net, struct ethtool_wolinfo *wolinfo) 573 { 574 struct usbnet *dev = netdev_priv(net); 575 u8 opt = 0; 576 577 if (wolinfo->wolopts & WAKE_PHY) 578 opt |= AX_MONITOR_LINK; 579 if (wolinfo->wolopts & WAKE_MAGIC) 580 opt |= AX_MONITOR_MAGIC; 581 582 if (asix_write_cmd(dev, AX_CMD_WRITE_MONITOR_MODE, 583 opt, 0, 0, NULL, 0) < 0) 584 return -EINVAL; 585 586 return 0; 587 } 588 589 int asix_get_eeprom_len(struct net_device *net) 590 { 591 return AX_EEPROM_LEN; 592 } 593 594 int asix_get_eeprom(struct net_device *net, struct ethtool_eeprom *eeprom, 595 u8 *data) 596 { 597 struct usbnet *dev = netdev_priv(net); 598 u16 *eeprom_buff; 599 int first_word, last_word; 600 int i; 601 602 if (eeprom->len == 0) 603 return -EINVAL; 604 605 eeprom->magic = AX_EEPROM_MAGIC; 606 607 first_word = eeprom->offset >> 1; 608 last_word = (eeprom->offset + eeprom->len - 1) >> 1; 609 610 eeprom_buff = kmalloc(sizeof(u16) * (last_word - first_word + 1), 611 GFP_KERNEL); 612 if (!eeprom_buff) 613 return -ENOMEM; 614 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) { 619 kfree(eeprom_buff); 620 return -EIO; 621 } 622 } 623 624 memcpy(data, (u8 *)eeprom_buff + (eeprom->offset & 1), eeprom->len); 625 kfree(eeprom_buff); 626 return 0; 627 } 628 629 int asix_set_eeprom(struct net_device *net, struct ethtool_eeprom *eeprom, 630 u8 *data) 631 { 632 struct usbnet *dev = netdev_priv(net); 633 u16 *eeprom_buff; 634 int first_word, last_word; 635 int i; 636 int ret; 637 638 netdev_dbg(net, "write EEPROM len %d, offset %d, magic 0x%x\n", 639 eeprom->len, eeprom->offset, eeprom->magic); 640 641 if (eeprom->len == 0) 642 return -EINVAL; 643 644 if (eeprom->magic != AX_EEPROM_MAGIC) 645 return -EINVAL; 646 647 first_word = eeprom->offset >> 1; 648 last_word = (eeprom->offset + eeprom->len - 1) >> 1; 649 650 eeprom_buff = kmalloc(sizeof(u16) * (last_word - first_word + 1), 651 GFP_KERNEL); 652 if (!eeprom_buff) 653 return -ENOMEM; 654 655 /* align data to 16 bit boundaries, read the missing data from 656 the EEPROM */ 657 if (eeprom->offset & 1) { 658 ret = asix_read_cmd(dev, AX_CMD_READ_EEPROM, first_word, 0, 2, 659 &eeprom_buff[0], 0); 660 if (ret < 0) { 661 netdev_err(net, "Failed to read EEPROM at offset 0x%02x.\n", first_word); 662 goto free; 663 } 664 } 665 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); 669 if (ret < 0) { 670 netdev_err(net, "Failed to read EEPROM at offset 0x%02x.\n", last_word); 671 goto free; 672 } 673 } 674 675 memcpy((u8 *)eeprom_buff + (eeprom->offset & 1), data, eeprom->len); 676 677 /* write data to EEPROM */ 678 ret = asix_write_cmd(dev, AX_CMD_WRITE_ENABLE, 0x0000, 0, 0, NULL, 0); 679 if (ret < 0) { 680 netdev_err(net, "Failed to enable EEPROM write\n"); 681 goto free; 682 } 683 msleep(20); 684 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); 690 if (ret < 0) { 691 netdev_err(net, "Failed to write EEPROM at offset 0x%02x.\n", 692 i); 693 goto free; 694 } 695 msleep(20); 696 } 697 698 ret = asix_write_cmd(dev, AX_CMD_WRITE_DISABLE, 0x0000, 0, 0, NULL, 0); 699 if (ret < 0) { 700 netdev_err(net, "Failed to disable EEPROM write\n"); 701 goto free; 702 } 703 704 ret = 0; 705 free: 706 kfree(eeprom_buff); 707 return ret; 708 } 709 710 void asix_get_drvinfo(struct net_device *net, struct ethtool_drvinfo *info) 711 { 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)); 716 } 717 718 int asix_set_mac_address(struct net_device *net, void *p) 719 { 720 struct usbnet *dev = netdev_priv(net); 721 struct asix_data *data = (struct asix_data *)&dev->data; 722 struct sockaddr *addr = p; 723 724 if (netif_running(net)) 725 return -EBUSY; 726 if (!is_valid_ether_addr(addr->sa_data)) 727 return -EADDRNOTAVAIL; 728 729 memcpy(net->dev_addr, addr->sa_data, ETH_ALEN); 730 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, 737 data->mac_addr); 738 739 return 0; 740 } 741