1 /* 2 * CoreChip-sz SR9700 one chip USB 1.1 Ethernet Devices 3 * 4 * Author : Liu Junliang <liujunliang_ljl@163.com> 5 * 6 * Based on dm9601.c 7 * 8 * This file is licensed under the terms of the GNU General Public License 9 * version 2. This program is licensed "as is" without any warranty of any 10 * kind, whether express or implied. 11 */ 12 13 #include <linux/module.h> 14 #include <linux/sched.h> 15 #include <linux/stddef.h> 16 #include <linux/netdevice.h> 17 #include <linux/etherdevice.h> 18 #include <linux/ethtool.h> 19 #include <linux/mii.h> 20 #include <linux/usb.h> 21 #include <linux/crc32.h> 22 #include <linux/usb/usbnet.h> 23 24 #include "sr9700.h" 25 26 static int sr_read(struct usbnet *dev, u8 reg, u16 length, void *data) 27 { 28 int err; 29 30 err = usbnet_read_cmd(dev, SR_RD_REGS, SR_REQ_RD_REG, 0, reg, data, 31 length); 32 if ((err != length) && (err >= 0)) 33 err = -EINVAL; 34 return err; 35 } 36 37 static int sr_write(struct usbnet *dev, u8 reg, u16 length, void *data) 38 { 39 int err; 40 41 err = usbnet_write_cmd(dev, SR_WR_REGS, SR_REQ_WR_REG, 0, reg, data, 42 length); 43 if ((err >= 0) && (err < length)) 44 err = -EINVAL; 45 return err; 46 } 47 48 static int sr_read_reg(struct usbnet *dev, u8 reg, u8 *value) 49 { 50 return sr_read(dev, reg, 1, value); 51 } 52 53 static int sr_write_reg(struct usbnet *dev, u8 reg, u8 value) 54 { 55 return usbnet_write_cmd(dev, SR_WR_REGS, SR_REQ_WR_REG, 56 value, reg, NULL, 0); 57 } 58 59 static void sr_write_async(struct usbnet *dev, u8 reg, u16 length, 60 const void *data) 61 { 62 usbnet_write_cmd_async(dev, SR_WR_REGS, SR_REQ_WR_REG, 63 0, reg, data, length); 64 } 65 66 static void sr_write_reg_async(struct usbnet *dev, u8 reg, u8 value) 67 { 68 usbnet_write_cmd_async(dev, SR_WR_REGS, SR_REQ_WR_REG, 69 value, reg, NULL, 0); 70 } 71 72 static int wait_phy_eeprom_ready(struct usbnet *dev, int phy) 73 { 74 int i; 75 76 for (i = 0; i < SR_SHARE_TIMEOUT; i++) { 77 u8 tmp = 0; 78 int ret; 79 80 udelay(1); 81 ret = sr_read_reg(dev, SR_EPCR, &tmp); 82 if (ret < 0) 83 return ret; 84 85 /* ready */ 86 if (!(tmp & EPCR_ERRE)) 87 return 0; 88 } 89 90 netdev_err(dev->net, "%s write timed out!\n", phy ? "phy" : "eeprom"); 91 92 return -EIO; 93 } 94 95 static int sr_share_read_word(struct usbnet *dev, int phy, u8 reg, 96 __le16 *value) 97 { 98 int ret; 99 100 mutex_lock(&dev->phy_mutex); 101 102 sr_write_reg(dev, SR_EPAR, phy ? (reg | EPAR_PHY_ADR) : reg); 103 sr_write_reg(dev, SR_EPCR, phy ? (EPCR_EPOS | EPCR_ERPRR) : EPCR_ERPRR); 104 105 ret = wait_phy_eeprom_ready(dev, phy); 106 if (ret < 0) 107 goto out_unlock; 108 109 sr_write_reg(dev, SR_EPCR, 0x0); 110 ret = sr_read(dev, SR_EPDR, 2, value); 111 112 netdev_dbg(dev->net, "read shared %d 0x%02x returned 0x%04x, %d\n", 113 phy, reg, *value, ret); 114 115 out_unlock: 116 mutex_unlock(&dev->phy_mutex); 117 return ret; 118 } 119 120 static int sr_share_write_word(struct usbnet *dev, int phy, u8 reg, 121 __le16 value) 122 { 123 int ret; 124 125 mutex_lock(&dev->phy_mutex); 126 127 ret = sr_write(dev, SR_EPDR, 2, &value); 128 if (ret < 0) 129 goto out_unlock; 130 131 sr_write_reg(dev, SR_EPAR, phy ? (reg | EPAR_PHY_ADR) : reg); 132 sr_write_reg(dev, SR_EPCR, phy ? (EPCR_WEP | EPCR_EPOS | EPCR_ERPRW) : 133 (EPCR_WEP | EPCR_ERPRW)); 134 135 ret = wait_phy_eeprom_ready(dev, phy); 136 if (ret < 0) 137 goto out_unlock; 138 139 sr_write_reg(dev, SR_EPCR, 0x0); 140 141 out_unlock: 142 mutex_unlock(&dev->phy_mutex); 143 return ret; 144 } 145 146 static int sr_read_eeprom_word(struct usbnet *dev, u8 offset, void *value) 147 { 148 return sr_share_read_word(dev, 0, offset, value); 149 } 150 151 static int sr9700_get_eeprom_len(struct net_device *netdev) 152 { 153 return SR_EEPROM_LEN; 154 } 155 156 static int sr9700_get_eeprom(struct net_device *netdev, 157 struct ethtool_eeprom *eeprom, u8 *data) 158 { 159 struct usbnet *dev = netdev_priv(netdev); 160 __le16 *buf = (__le16 *)data; 161 int ret = 0; 162 int i; 163 164 /* access is 16bit */ 165 if ((eeprom->offset & 0x01) || (eeprom->len & 0x01)) 166 return -EINVAL; 167 168 for (i = 0; i < eeprom->len / 2; i++) { 169 ret = sr_read_eeprom_word(dev, eeprom->offset / 2 + i, buf + i); 170 if (ret < 0) 171 break; 172 } 173 174 return ret; 175 } 176 177 static int sr_mdio_read(struct net_device *netdev, int phy_id, int loc) 178 { 179 struct usbnet *dev = netdev_priv(netdev); 180 __le16 res; 181 int rc = 0; 182 183 if (phy_id) { 184 netdev_dbg(netdev, "Only internal phy supported\n"); 185 return 0; 186 } 187 188 /* Access NSR_LINKST bit for link status instead of MII_BMSR */ 189 if (loc == MII_BMSR) { 190 u8 value; 191 192 sr_read_reg(dev, SR_NSR, &value); 193 if (value & NSR_LINKST) 194 rc = 1; 195 } 196 sr_share_read_word(dev, 1, loc, &res); 197 if (rc == 1) 198 res = le16_to_cpu(res) | BMSR_LSTATUS; 199 else 200 res = le16_to_cpu(res) & ~BMSR_LSTATUS; 201 202 netdev_dbg(netdev, "sr_mdio_read() phy_id=0x%02x, loc=0x%02x, returns=0x%04x\n", 203 phy_id, loc, res); 204 205 return res; 206 } 207 208 static void sr_mdio_write(struct net_device *netdev, int phy_id, int loc, 209 int val) 210 { 211 struct usbnet *dev = netdev_priv(netdev); 212 __le16 res = cpu_to_le16(val); 213 214 if (phy_id) { 215 netdev_dbg(netdev, "Only internal phy supported\n"); 216 return; 217 } 218 219 netdev_dbg(netdev, "sr_mdio_write() phy_id=0x%02x, loc=0x%02x, val=0x%04x\n", 220 phy_id, loc, val); 221 222 sr_share_write_word(dev, 1, loc, res); 223 } 224 225 static u32 sr9700_get_link(struct net_device *netdev) 226 { 227 struct usbnet *dev = netdev_priv(netdev); 228 u8 value = 0; 229 int rc = 0; 230 231 /* Get the Link Status directly */ 232 sr_read_reg(dev, SR_NSR, &value); 233 if (value & NSR_LINKST) 234 rc = 1; 235 236 return rc; 237 } 238 239 static int sr9700_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd) 240 { 241 struct usbnet *dev = netdev_priv(netdev); 242 243 return generic_mii_ioctl(&dev->mii, if_mii(rq), cmd, NULL); 244 } 245 246 static const struct ethtool_ops sr9700_ethtool_ops = { 247 .get_drvinfo = usbnet_get_drvinfo, 248 .get_link = sr9700_get_link, 249 .get_msglevel = usbnet_get_msglevel, 250 .set_msglevel = usbnet_set_msglevel, 251 .get_eeprom_len = sr9700_get_eeprom_len, 252 .get_eeprom = sr9700_get_eeprom, 253 .nway_reset = usbnet_nway_reset, 254 .get_link_ksettings = usbnet_get_link_ksettings_mii, 255 .set_link_ksettings = usbnet_set_link_ksettings_mii, 256 }; 257 258 static void sr9700_set_multicast(struct net_device *netdev) 259 { 260 struct usbnet *dev = netdev_priv(netdev); 261 /* We use the 20 byte dev->data for our 8 byte filter buffer 262 * to avoid allocating memory that is tricky to free later 263 */ 264 u8 *hashes = (u8 *)&dev->data; 265 /* rx_ctl setting : enable, disable_long, disable_crc */ 266 u8 rx_ctl = RCR_RXEN | RCR_DIS_CRC | RCR_DIS_LONG; 267 268 memset(hashes, 0x00, SR_MCAST_SIZE); 269 /* broadcast address */ 270 hashes[SR_MCAST_SIZE - 1] |= SR_MCAST_ADDR_FLAG; 271 if (netdev->flags & IFF_PROMISC) { 272 rx_ctl |= RCR_PRMSC; 273 } else if (netdev->flags & IFF_ALLMULTI || 274 netdev_mc_count(netdev) > SR_MCAST_MAX) { 275 rx_ctl |= RCR_RUNT; 276 } else if (!netdev_mc_empty(netdev)) { 277 struct netdev_hw_addr *ha; 278 279 netdev_for_each_mc_addr(ha, netdev) { 280 u32 crc = ether_crc(ETH_ALEN, ha->addr) >> 26; 281 hashes[crc >> 3] |= 1 << (crc & 0x7); 282 } 283 } 284 285 sr_write_async(dev, SR_MAR, SR_MCAST_SIZE, hashes); 286 sr_write_reg_async(dev, SR_RCR, rx_ctl); 287 } 288 289 static int sr9700_set_mac_address(struct net_device *netdev, void *p) 290 { 291 struct usbnet *dev = netdev_priv(netdev); 292 struct sockaddr *addr = p; 293 294 if (!is_valid_ether_addr(addr->sa_data)) { 295 netdev_err(netdev, "not setting invalid mac address %pM\n", 296 addr->sa_data); 297 return -EINVAL; 298 } 299 300 eth_hw_addr_set(netdev, addr->sa_data); 301 sr_write_async(dev, SR_PAR, 6, netdev->dev_addr); 302 303 return 0; 304 } 305 306 static const struct net_device_ops sr9700_netdev_ops = { 307 .ndo_open = usbnet_open, 308 .ndo_stop = usbnet_stop, 309 .ndo_start_xmit = usbnet_start_xmit, 310 .ndo_tx_timeout = usbnet_tx_timeout, 311 .ndo_change_mtu = usbnet_change_mtu, 312 .ndo_get_stats64 = dev_get_tstats64, 313 .ndo_validate_addr = eth_validate_addr, 314 .ndo_eth_ioctl = sr9700_ioctl, 315 .ndo_set_rx_mode = sr9700_set_multicast, 316 .ndo_set_mac_address = sr9700_set_mac_address, 317 }; 318 319 static int sr9700_bind(struct usbnet *dev, struct usb_interface *intf) 320 { 321 struct net_device *netdev; 322 struct mii_if_info *mii; 323 int ret; 324 325 ret = usbnet_get_endpoints(dev, intf); 326 if (ret) 327 goto out; 328 329 netdev = dev->net; 330 331 netdev->netdev_ops = &sr9700_netdev_ops; 332 netdev->ethtool_ops = &sr9700_ethtool_ops; 333 netdev->hard_header_len += SR_TX_OVERHEAD; 334 dev->hard_mtu = netdev->mtu + netdev->hard_header_len; 335 /* bulkin buffer is preferably not less than 3K */ 336 dev->rx_urb_size = 3072; 337 338 mii = &dev->mii; 339 mii->dev = netdev; 340 mii->mdio_read = sr_mdio_read; 341 mii->mdio_write = sr_mdio_write; 342 mii->phy_id_mask = 0x1f; 343 mii->reg_num_mask = 0x1f; 344 345 sr_write_reg(dev, SR_NCR, NCR_RST); 346 udelay(20); 347 348 /* read MAC 349 * After Chip Power on, the Chip will reload the MAC from 350 * EEPROM automatically to PAR. In case there is no EEPROM externally, 351 * a default MAC address is stored in PAR for making chip work properly. 352 */ 353 if (sr_read(dev, SR_PAR, ETH_ALEN, netdev->dev_addr) < 0) { 354 netdev_err(netdev, "Error reading MAC address\n"); 355 ret = -ENODEV; 356 goto out; 357 } 358 359 /* power up and reset phy */ 360 sr_write_reg(dev, SR_PRR, PRR_PHY_RST); 361 /* at least 10ms, here 20ms for safe */ 362 msleep(20); 363 sr_write_reg(dev, SR_PRR, 0); 364 /* at least 1ms, here 2ms for reading right register */ 365 udelay(2 * 1000); 366 367 /* receive broadcast packets */ 368 sr9700_set_multicast(netdev); 369 370 sr_mdio_write(netdev, mii->phy_id, MII_BMCR, BMCR_RESET); 371 sr_mdio_write(netdev, mii->phy_id, MII_ADVERTISE, ADVERTISE_ALL | 372 ADVERTISE_CSMA | ADVERTISE_PAUSE_CAP); 373 mii_nway_restart(mii); 374 375 out: 376 return ret; 377 } 378 379 static int sr9700_rx_fixup(struct usbnet *dev, struct sk_buff *skb) 380 { 381 struct sk_buff *sr_skb; 382 int len; 383 384 /* skb content (packets) format : 385 * p0 p1 p2 ...... pm 386 * / \ 387 * / \ 388 * / \ 389 * / \ 390 * p0b0 p0b1 p0b2 p0b3 ...... p0b(n-4) p0b(n-3)...p0bn 391 * 392 * p0 : packet 0 393 * p0b0 : packet 0 byte 0 394 * 395 * b0: rx status 396 * b1: packet length (incl crc) low 397 * b2: packet length (incl crc) high 398 * b3..n-4: packet data 399 * bn-3..bn: ethernet packet crc 400 */ 401 if (unlikely(skb->len < SR_RX_OVERHEAD)) { 402 netdev_err(dev->net, "unexpected tiny rx frame\n"); 403 return 0; 404 } 405 406 /* one skb may contains multiple packets */ 407 while (skb->len > SR_RX_OVERHEAD) { 408 if (skb->data[0] != 0x40) 409 return 0; 410 411 /* ignore the CRC length */ 412 len = (skb->data[1] | (skb->data[2] << 8)) - 4; 413 414 if (len > ETH_FRAME_LEN) 415 return 0; 416 417 /* the last packet of current skb */ 418 if (skb->len == (len + SR_RX_OVERHEAD)) { 419 skb_pull(skb, 3); 420 skb->len = len; 421 skb_set_tail_pointer(skb, len); 422 skb->truesize = len + sizeof(struct sk_buff); 423 return 2; 424 } 425 426 /* skb_clone is used for address align */ 427 sr_skb = skb_clone(skb, GFP_ATOMIC); 428 if (!sr_skb) 429 return 0; 430 431 sr_skb->len = len; 432 sr_skb->data = skb->data + 3; 433 skb_set_tail_pointer(sr_skb, len); 434 sr_skb->truesize = len + sizeof(struct sk_buff); 435 usbnet_skb_return(dev, sr_skb); 436 437 skb_pull(skb, len + SR_RX_OVERHEAD); 438 } 439 440 return 0; 441 } 442 443 static struct sk_buff *sr9700_tx_fixup(struct usbnet *dev, struct sk_buff *skb, 444 gfp_t flags) 445 { 446 int len; 447 448 /* SR9700 can only send out one ethernet packet at once. 449 * 450 * b0 b1 b2 b3 ...... b(n-4) b(n-3)...bn 451 * 452 * b0: rx status 453 * b1: packet length (incl crc) low 454 * b2: packet length (incl crc) high 455 * b3..n-4: packet data 456 * bn-3..bn: ethernet packet crc 457 */ 458 459 len = skb->len; 460 461 if (skb_cow_head(skb, SR_TX_OVERHEAD)) { 462 dev_kfree_skb_any(skb); 463 return NULL; 464 } 465 466 __skb_push(skb, SR_TX_OVERHEAD); 467 468 /* usbnet adds padding if length is a multiple of packet size 469 * if so, adjust length value in header 470 */ 471 if ((skb->len % dev->maxpacket) == 0) 472 len++; 473 474 skb->data[0] = len; 475 skb->data[1] = len >> 8; 476 477 return skb; 478 } 479 480 static void sr9700_status(struct usbnet *dev, struct urb *urb) 481 { 482 int link; 483 u8 *buf; 484 485 /* format: 486 b0: net status 487 b1: tx status 1 488 b2: tx status 2 489 b3: rx status 490 b4: rx overflow 491 b5: rx count 492 b6: tx count 493 b7: gpr 494 */ 495 496 if (urb->actual_length < 8) 497 return; 498 499 buf = urb->transfer_buffer; 500 501 link = !!(buf[0] & 0x40); 502 if (netif_carrier_ok(dev->net) != link) { 503 usbnet_link_change(dev, link, 1); 504 netdev_dbg(dev->net, "Link Status is: %d\n", link); 505 } 506 } 507 508 static int sr9700_link_reset(struct usbnet *dev) 509 { 510 struct ethtool_cmd ecmd; 511 512 mii_check_media(&dev->mii, 1, 1); 513 mii_ethtool_gset(&dev->mii, &ecmd); 514 515 netdev_dbg(dev->net, "link_reset() speed: %d duplex: %d\n", 516 ecmd.speed, ecmd.duplex); 517 518 return 0; 519 } 520 521 static const struct driver_info sr9700_driver_info = { 522 .description = "CoreChip SR9700 USB Ethernet", 523 .flags = FLAG_ETHER, 524 .bind = sr9700_bind, 525 .rx_fixup = sr9700_rx_fixup, 526 .tx_fixup = sr9700_tx_fixup, 527 .status = sr9700_status, 528 .link_reset = sr9700_link_reset, 529 .reset = sr9700_link_reset, 530 }; 531 532 static const struct usb_device_id products[] = { 533 { 534 USB_DEVICE(0x0fe6, 0x9700), /* SR9700 device */ 535 .driver_info = (unsigned long)&sr9700_driver_info, 536 }, 537 {}, /* END */ 538 }; 539 540 MODULE_DEVICE_TABLE(usb, products); 541 542 static struct usb_driver sr9700_usb_driver = { 543 .name = "sr9700", 544 .id_table = products, 545 .probe = usbnet_probe, 546 .disconnect = usbnet_disconnect, 547 .suspend = usbnet_suspend, 548 .resume = usbnet_resume, 549 .disable_hub_initiated_lpm = 1, 550 }; 551 552 module_usb_driver(sr9700_usb_driver); 553 554 MODULE_AUTHOR("liujl <liujunliang_ljl@163.com>"); 555 MODULE_DESCRIPTION("SR9700 one chip USB 1.1 USB to Ethernet device from http://www.corechip-sz.com/"); 556 MODULE_LICENSE("GPL"); 557