1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2019 Synopsys, Inc. and/or its affiliates. 4 * stmmac Selftests Support 5 * 6 * Author: Jose Abreu <joabreu@synopsys.com> 7 */ 8 9 #include <linux/bitrev.h> 10 #include <linux/completion.h> 11 #include <linux/crc32.h> 12 #include <linux/ethtool.h> 13 #include <linux/ip.h> 14 #include <linux/phy.h> 15 #include <linux/udp.h> 16 #include <net/pkt_cls.h> 17 #include <net/pkt_sched.h> 18 #include <net/tcp.h> 19 #include <net/udp.h> 20 #include <net/tc_act/tc_gact.h> 21 #include "stmmac.h" 22 23 struct stmmachdr { 24 __be32 version; 25 __be64 magic; 26 u8 id; 27 } __packed; 28 29 #define STMMAC_TEST_PKT_SIZE (sizeof(struct ethhdr) + sizeof(struct iphdr) + \ 30 sizeof(struct stmmachdr)) 31 #define STMMAC_TEST_PKT_MAGIC 0xdeadcafecafedeadULL 32 #define STMMAC_LB_TIMEOUT msecs_to_jiffies(200) 33 34 struct stmmac_packet_attrs { 35 int vlan; 36 int vlan_id_in; 37 int vlan_id_out; 38 unsigned char *src; 39 const unsigned char *dst; 40 u32 ip_src; 41 u32 ip_dst; 42 int tcp; 43 int sport; 44 int dport; 45 u32 exp_hash; 46 int dont_wait; 47 int timeout; 48 int size; 49 int max_size; 50 int remove_sa; 51 u8 id; 52 int sarc; 53 u16 queue_mapping; 54 u64 timestamp; 55 }; 56 57 static u8 stmmac_test_next_id; 58 59 static struct sk_buff *stmmac_test_get_udp_skb(struct stmmac_priv *priv, 60 struct stmmac_packet_attrs *attr) 61 { 62 struct sk_buff *skb = NULL; 63 struct udphdr *uhdr = NULL; 64 struct tcphdr *thdr = NULL; 65 struct stmmachdr *shdr; 66 struct ethhdr *ehdr; 67 struct iphdr *ihdr; 68 int iplen, size; 69 70 size = attr->size + STMMAC_TEST_PKT_SIZE; 71 if (attr->vlan) { 72 size += 4; 73 if (attr->vlan > 1) 74 size += 4; 75 } 76 77 if (attr->tcp) 78 size += sizeof(struct tcphdr); 79 else 80 size += sizeof(struct udphdr); 81 82 if (attr->max_size && (attr->max_size > size)) 83 size = attr->max_size; 84 85 skb = netdev_alloc_skb(priv->dev, size); 86 if (!skb) 87 return NULL; 88 89 prefetchw(skb->data); 90 91 if (attr->vlan > 1) 92 ehdr = skb_push(skb, ETH_HLEN + 8); 93 else if (attr->vlan) 94 ehdr = skb_push(skb, ETH_HLEN + 4); 95 else if (attr->remove_sa) 96 ehdr = skb_push(skb, ETH_HLEN - 6); 97 else 98 ehdr = skb_push(skb, ETH_HLEN); 99 skb_reset_mac_header(skb); 100 101 skb_set_network_header(skb, skb->len); 102 ihdr = skb_put(skb, sizeof(*ihdr)); 103 104 skb_set_transport_header(skb, skb->len); 105 if (attr->tcp) 106 thdr = skb_put(skb, sizeof(*thdr)); 107 else 108 uhdr = skb_put(skb, sizeof(*uhdr)); 109 110 if (!attr->remove_sa) 111 eth_zero_addr(ehdr->h_source); 112 eth_zero_addr(ehdr->h_dest); 113 if (attr->src && !attr->remove_sa) 114 ether_addr_copy(ehdr->h_source, attr->src); 115 if (attr->dst) 116 ether_addr_copy(ehdr->h_dest, attr->dst); 117 118 if (!attr->remove_sa) { 119 ehdr->h_proto = htons(ETH_P_IP); 120 } else { 121 __be16 *ptr = (__be16 *)ehdr; 122 123 /* HACK */ 124 ptr[3] = htons(ETH_P_IP); 125 } 126 127 if (attr->vlan) { 128 __be16 *tag, *proto; 129 130 if (!attr->remove_sa) { 131 tag = (void *)ehdr + ETH_HLEN; 132 proto = (void *)ehdr + (2 * ETH_ALEN); 133 } else { 134 tag = (void *)ehdr + ETH_HLEN - 6; 135 proto = (void *)ehdr + ETH_ALEN; 136 } 137 138 proto[0] = htons(ETH_P_8021Q); 139 tag[0] = htons(attr->vlan_id_out); 140 tag[1] = htons(ETH_P_IP); 141 if (attr->vlan > 1) { 142 proto[0] = htons(ETH_P_8021AD); 143 tag[1] = htons(ETH_P_8021Q); 144 tag[2] = htons(attr->vlan_id_in); 145 tag[3] = htons(ETH_P_IP); 146 } 147 } 148 149 if (attr->tcp) { 150 thdr->source = htons(attr->sport); 151 thdr->dest = htons(attr->dport); 152 thdr->doff = sizeof(struct tcphdr) / 4; 153 thdr->check = 0; 154 } else { 155 uhdr->source = htons(attr->sport); 156 uhdr->dest = htons(attr->dport); 157 uhdr->len = htons(sizeof(*shdr) + sizeof(*uhdr) + attr->size); 158 if (attr->max_size) 159 uhdr->len = htons(attr->max_size - 160 (sizeof(*ihdr) + sizeof(*ehdr))); 161 uhdr->check = 0; 162 } 163 164 ihdr->ihl = 5; 165 ihdr->ttl = 32; 166 ihdr->version = 4; 167 if (attr->tcp) 168 ihdr->protocol = IPPROTO_TCP; 169 else 170 ihdr->protocol = IPPROTO_UDP; 171 iplen = sizeof(*ihdr) + sizeof(*shdr) + attr->size; 172 if (attr->tcp) 173 iplen += sizeof(*thdr); 174 else 175 iplen += sizeof(*uhdr); 176 177 if (attr->max_size) 178 iplen = attr->max_size - sizeof(*ehdr); 179 180 ihdr->tot_len = htons(iplen); 181 ihdr->frag_off = 0; 182 ihdr->saddr = htonl(attr->ip_src); 183 ihdr->daddr = htonl(attr->ip_dst); 184 ihdr->tos = 0; 185 ihdr->id = 0; 186 ip_send_check(ihdr); 187 188 shdr = skb_put(skb, sizeof(*shdr)); 189 shdr->version = 0; 190 shdr->magic = cpu_to_be64(STMMAC_TEST_PKT_MAGIC); 191 attr->id = stmmac_test_next_id; 192 shdr->id = stmmac_test_next_id++; 193 194 if (attr->size) 195 skb_put(skb, attr->size); 196 if (attr->max_size && (attr->max_size > skb->len)) 197 skb_put(skb, attr->max_size - skb->len); 198 199 skb->csum = 0; 200 skb->ip_summed = CHECKSUM_PARTIAL; 201 if (attr->tcp) { 202 thdr->check = ~tcp_v4_check(skb->len, ihdr->saddr, ihdr->daddr, 0); 203 skb->csum_start = skb_transport_header(skb) - skb->head; 204 skb->csum_offset = offsetof(struct tcphdr, check); 205 } else { 206 udp4_hwcsum(skb, ihdr->saddr, ihdr->daddr); 207 } 208 209 skb->protocol = htons(ETH_P_IP); 210 skb->pkt_type = PACKET_HOST; 211 skb->dev = priv->dev; 212 213 if (attr->timestamp) 214 skb->tstamp = ns_to_ktime(attr->timestamp); 215 216 return skb; 217 } 218 219 static struct sk_buff *stmmac_test_get_arp_skb(struct stmmac_priv *priv, 220 struct stmmac_packet_attrs *attr) 221 { 222 __be32 ip_src = htonl(attr->ip_src); 223 __be32 ip_dst = htonl(attr->ip_dst); 224 struct sk_buff *skb = NULL; 225 226 skb = arp_create(ARPOP_REQUEST, ETH_P_ARP, ip_dst, priv->dev, ip_src, 227 NULL, attr->src, attr->dst); 228 if (!skb) 229 return NULL; 230 231 skb->pkt_type = PACKET_HOST; 232 skb->dev = priv->dev; 233 234 return skb; 235 } 236 237 struct stmmac_test_priv { 238 struct stmmac_packet_attrs *packet; 239 struct packet_type pt; 240 struct completion comp; 241 int double_vlan; 242 int vlan_id; 243 int ok; 244 }; 245 246 static int stmmac_test_loopback_validate(struct sk_buff *skb, 247 struct net_device *ndev, 248 struct packet_type *pt, 249 struct net_device *orig_ndev) 250 { 251 struct stmmac_test_priv *tpriv = pt->af_packet_priv; 252 const unsigned char *dst = tpriv->packet->dst; 253 unsigned char *src = tpriv->packet->src; 254 struct stmmachdr *shdr; 255 struct ethhdr *ehdr; 256 struct udphdr *uhdr; 257 struct tcphdr *thdr; 258 struct iphdr *ihdr; 259 260 skb = skb_unshare(skb, GFP_ATOMIC); 261 if (!skb) 262 goto out; 263 264 if (skb_linearize(skb)) 265 goto out; 266 if (skb_headlen(skb) < (STMMAC_TEST_PKT_SIZE - ETH_HLEN)) 267 goto out; 268 269 ehdr = (struct ethhdr *)skb_mac_header(skb); 270 if (dst) { 271 if (!ether_addr_equal_unaligned(ehdr->h_dest, dst)) 272 goto out; 273 } 274 if (tpriv->packet->sarc) { 275 if (!ether_addr_equal_unaligned(ehdr->h_source, ehdr->h_dest)) 276 goto out; 277 } else if (src) { 278 if (!ether_addr_equal_unaligned(ehdr->h_source, src)) 279 goto out; 280 } 281 282 ihdr = ip_hdr(skb); 283 if (tpriv->double_vlan) 284 ihdr = (struct iphdr *)(skb_network_header(skb) + 4); 285 286 if (tpriv->packet->tcp) { 287 if (ihdr->protocol != IPPROTO_TCP) 288 goto out; 289 290 thdr = (struct tcphdr *)((u8 *)ihdr + 4 * ihdr->ihl); 291 if (thdr->dest != htons(tpriv->packet->dport)) 292 goto out; 293 294 shdr = (struct stmmachdr *)((u8 *)thdr + sizeof(*thdr)); 295 } else { 296 if (ihdr->protocol != IPPROTO_UDP) 297 goto out; 298 299 uhdr = (struct udphdr *)((u8 *)ihdr + 4 * ihdr->ihl); 300 if (uhdr->dest != htons(tpriv->packet->dport)) 301 goto out; 302 303 shdr = (struct stmmachdr *)((u8 *)uhdr + sizeof(*uhdr)); 304 } 305 306 if (shdr->magic != cpu_to_be64(STMMAC_TEST_PKT_MAGIC)) 307 goto out; 308 if (tpriv->packet->exp_hash && !skb->hash) 309 goto out; 310 if (tpriv->packet->id != shdr->id) 311 goto out; 312 313 tpriv->ok = true; 314 complete(&tpriv->comp); 315 out: 316 kfree_skb(skb); 317 return 0; 318 } 319 320 static int __stmmac_test_loopback(struct stmmac_priv *priv, 321 struct stmmac_packet_attrs *attr) 322 { 323 struct stmmac_test_priv *tpriv; 324 struct sk_buff *skb = NULL; 325 int ret = 0; 326 327 tpriv = kzalloc(sizeof(*tpriv), GFP_KERNEL); 328 if (!tpriv) 329 return -ENOMEM; 330 331 tpriv->ok = false; 332 init_completion(&tpriv->comp); 333 334 tpriv->pt.type = htons(ETH_P_IP); 335 tpriv->pt.func = stmmac_test_loopback_validate; 336 tpriv->pt.dev = priv->dev; 337 tpriv->pt.af_packet_priv = tpriv; 338 tpriv->packet = attr; 339 340 if (!attr->dont_wait) 341 dev_add_pack(&tpriv->pt); 342 343 skb = stmmac_test_get_udp_skb(priv, attr); 344 if (!skb) { 345 ret = -ENOMEM; 346 goto cleanup; 347 } 348 349 ret = dev_direct_xmit(skb, attr->queue_mapping); 350 if (ret) 351 goto cleanup; 352 353 if (attr->dont_wait) 354 goto cleanup; 355 356 if (!attr->timeout) 357 attr->timeout = STMMAC_LB_TIMEOUT; 358 359 wait_for_completion_timeout(&tpriv->comp, attr->timeout); 360 ret = tpriv->ok ? 0 : -ETIMEDOUT; 361 362 cleanup: 363 if (!attr->dont_wait) 364 dev_remove_pack(&tpriv->pt); 365 kfree(tpriv); 366 return ret; 367 } 368 369 static int stmmac_test_mac_loopback(struct stmmac_priv *priv) 370 { 371 struct stmmac_packet_attrs attr = { }; 372 373 attr.dst = priv->dev->dev_addr; 374 return __stmmac_test_loopback(priv, &attr); 375 } 376 377 static int stmmac_test_phy_loopback(struct stmmac_priv *priv) 378 { 379 struct stmmac_packet_attrs attr = { }; 380 int ret; 381 382 if (!priv->dev->phydev) 383 return -EOPNOTSUPP; 384 385 ret = phy_loopback(priv->dev->phydev, true); 386 if (ret) 387 return ret; 388 389 attr.dst = priv->dev->dev_addr; 390 ret = __stmmac_test_loopback(priv, &attr); 391 392 phy_loopback(priv->dev->phydev, false); 393 return ret; 394 } 395 396 static int stmmac_test_mmc(struct stmmac_priv *priv) 397 { 398 struct stmmac_counters initial, final; 399 int ret; 400 401 memset(&initial, 0, sizeof(initial)); 402 memset(&final, 0, sizeof(final)); 403 404 if (!priv->dma_cap.rmon) 405 return -EOPNOTSUPP; 406 407 /* Save previous results into internal struct */ 408 stmmac_mmc_read(priv, priv->mmcaddr, &priv->mmc); 409 410 ret = stmmac_test_mac_loopback(priv); 411 if (ret) 412 return ret; 413 414 /* These will be loopback results so no need to save them */ 415 stmmac_mmc_read(priv, priv->mmcaddr, &final); 416 417 /* 418 * The number of MMC counters available depends on HW configuration 419 * so we just use this one to validate the feature. I hope there is 420 * not a version without this counter. 421 */ 422 if (final.mmc_tx_framecount_g <= initial.mmc_tx_framecount_g) 423 return -EINVAL; 424 425 return 0; 426 } 427 428 static int stmmac_test_eee(struct stmmac_priv *priv) 429 { 430 struct stmmac_extra_stats *initial, *final; 431 int retries = 10; 432 int ret; 433 434 if (!priv->dma_cap.eee || !priv->eee_active) 435 return -EOPNOTSUPP; 436 437 initial = kzalloc(sizeof(*initial), GFP_KERNEL); 438 if (!initial) 439 return -ENOMEM; 440 441 final = kzalloc(sizeof(*final), GFP_KERNEL); 442 if (!final) { 443 ret = -ENOMEM; 444 goto out_free_initial; 445 } 446 447 memcpy(initial, &priv->xstats, sizeof(*initial)); 448 449 ret = stmmac_test_mac_loopback(priv); 450 if (ret) 451 goto out_free_final; 452 453 /* We have no traffic in the line so, sooner or later it will go LPI */ 454 while (--retries) { 455 memcpy(final, &priv->xstats, sizeof(*final)); 456 457 if (final->irq_tx_path_in_lpi_mode_n > 458 initial->irq_tx_path_in_lpi_mode_n) 459 break; 460 msleep(100); 461 } 462 463 if (!retries) { 464 ret = -ETIMEDOUT; 465 goto out_free_final; 466 } 467 468 if (final->irq_tx_path_in_lpi_mode_n <= 469 initial->irq_tx_path_in_lpi_mode_n) { 470 ret = -EINVAL; 471 goto out_free_final; 472 } 473 474 if (final->irq_tx_path_exit_lpi_mode_n <= 475 initial->irq_tx_path_exit_lpi_mode_n) { 476 ret = -EINVAL; 477 goto out_free_final; 478 } 479 480 out_free_final: 481 kfree(final); 482 out_free_initial: 483 kfree(initial); 484 return ret; 485 } 486 487 static int stmmac_filter_check(struct stmmac_priv *priv) 488 { 489 if (!(priv->dev->flags & IFF_PROMISC)) 490 return 0; 491 492 netdev_warn(priv->dev, "Test can't be run in promiscuous mode!\n"); 493 return -EOPNOTSUPP; 494 } 495 496 static bool stmmac_hash_check(struct stmmac_priv *priv, unsigned char *addr) 497 { 498 int mc_offset = 32 - priv->hw->mcast_bits_log2; 499 struct netdev_hw_addr *ha; 500 u32 hash, hash_nr; 501 502 /* First compute the hash for desired addr */ 503 hash = bitrev32(~crc32_le(~0, addr, 6)) >> mc_offset; 504 hash_nr = hash >> 5; 505 hash = 1 << (hash & 0x1f); 506 507 /* Now, check if it collides with any existing one */ 508 netdev_for_each_mc_addr(ha, priv->dev) { 509 u32 nr = bitrev32(~crc32_le(~0, ha->addr, ETH_ALEN)) >> mc_offset; 510 if (((nr >> 5) == hash_nr) && ((1 << (nr & 0x1f)) == hash)) 511 return false; 512 } 513 514 /* No collisions, address is good to go */ 515 return true; 516 } 517 518 static bool stmmac_perfect_check(struct stmmac_priv *priv, unsigned char *addr) 519 { 520 struct netdev_hw_addr *ha; 521 522 /* Check if it collides with any existing one */ 523 netdev_for_each_uc_addr(ha, priv->dev) { 524 if (!memcmp(ha->addr, addr, ETH_ALEN)) 525 return false; 526 } 527 528 /* No collisions, address is good to go */ 529 return true; 530 } 531 532 static int stmmac_test_hfilt(struct stmmac_priv *priv) 533 { 534 unsigned char gd_addr[ETH_ALEN] = {0xf1, 0xee, 0xdd, 0xcc, 0xbb, 0xaa}; 535 unsigned char bd_addr[ETH_ALEN] = {0xf1, 0xff, 0xff, 0xff, 0xff, 0xff}; 536 struct stmmac_packet_attrs attr = { }; 537 int ret, tries = 256; 538 539 ret = stmmac_filter_check(priv); 540 if (ret) 541 return ret; 542 543 if (netdev_mc_count(priv->dev) >= priv->hw->multicast_filter_bins) 544 return -EOPNOTSUPP; 545 546 while (--tries) { 547 /* We only need to check the bd_addr for collisions */ 548 bd_addr[ETH_ALEN - 1] = tries; 549 if (stmmac_hash_check(priv, bd_addr)) 550 break; 551 } 552 553 if (!tries) 554 return -EOPNOTSUPP; 555 556 ret = dev_mc_add(priv->dev, gd_addr); 557 if (ret) 558 return ret; 559 560 attr.dst = gd_addr; 561 562 /* Shall receive packet */ 563 ret = __stmmac_test_loopback(priv, &attr); 564 if (ret) 565 goto cleanup; 566 567 attr.dst = bd_addr; 568 569 /* Shall NOT receive packet */ 570 ret = __stmmac_test_loopback(priv, &attr); 571 ret = ret ? 0 : -EINVAL; 572 573 cleanup: 574 dev_mc_del(priv->dev, gd_addr); 575 return ret; 576 } 577 578 static int stmmac_test_pfilt(struct stmmac_priv *priv) 579 { 580 unsigned char gd_addr[ETH_ALEN] = {0xf0, 0x01, 0x44, 0x55, 0x66, 0x77}; 581 unsigned char bd_addr[ETH_ALEN] = {0xf0, 0xff, 0xff, 0xff, 0xff, 0xff}; 582 struct stmmac_packet_attrs attr = { }; 583 int ret, tries = 256; 584 585 if (stmmac_filter_check(priv)) 586 return -EOPNOTSUPP; 587 if (netdev_uc_count(priv->dev) >= priv->hw->unicast_filter_entries) 588 return -EOPNOTSUPP; 589 590 while (--tries) { 591 /* We only need to check the bd_addr for collisions */ 592 bd_addr[ETH_ALEN - 1] = tries; 593 if (stmmac_perfect_check(priv, bd_addr)) 594 break; 595 } 596 597 if (!tries) 598 return -EOPNOTSUPP; 599 600 ret = dev_uc_add(priv->dev, gd_addr); 601 if (ret) 602 return ret; 603 604 attr.dst = gd_addr; 605 606 /* Shall receive packet */ 607 ret = __stmmac_test_loopback(priv, &attr); 608 if (ret) 609 goto cleanup; 610 611 attr.dst = bd_addr; 612 613 /* Shall NOT receive packet */ 614 ret = __stmmac_test_loopback(priv, &attr); 615 ret = ret ? 0 : -EINVAL; 616 617 cleanup: 618 dev_uc_del(priv->dev, gd_addr); 619 return ret; 620 } 621 622 static int stmmac_test_mcfilt(struct stmmac_priv *priv) 623 { 624 unsigned char uc_addr[ETH_ALEN] = {0xf0, 0xff, 0xff, 0xff, 0xff, 0xff}; 625 unsigned char mc_addr[ETH_ALEN] = {0xf1, 0xff, 0xff, 0xff, 0xff, 0xff}; 626 struct stmmac_packet_attrs attr = { }; 627 int ret, tries = 256; 628 629 if (stmmac_filter_check(priv)) 630 return -EOPNOTSUPP; 631 if (netdev_uc_count(priv->dev) >= priv->hw->unicast_filter_entries) 632 return -EOPNOTSUPP; 633 if (netdev_mc_count(priv->dev) >= priv->hw->multicast_filter_bins) 634 return -EOPNOTSUPP; 635 636 while (--tries) { 637 /* We only need to check the mc_addr for collisions */ 638 mc_addr[ETH_ALEN - 1] = tries; 639 if (stmmac_hash_check(priv, mc_addr)) 640 break; 641 } 642 643 if (!tries) 644 return -EOPNOTSUPP; 645 646 ret = dev_uc_add(priv->dev, uc_addr); 647 if (ret) 648 return ret; 649 650 attr.dst = uc_addr; 651 652 /* Shall receive packet */ 653 ret = __stmmac_test_loopback(priv, &attr); 654 if (ret) 655 goto cleanup; 656 657 attr.dst = mc_addr; 658 659 /* Shall NOT receive packet */ 660 ret = __stmmac_test_loopback(priv, &attr); 661 ret = ret ? 0 : -EINVAL; 662 663 cleanup: 664 dev_uc_del(priv->dev, uc_addr); 665 return ret; 666 } 667 668 static int stmmac_test_ucfilt(struct stmmac_priv *priv) 669 { 670 unsigned char uc_addr[ETH_ALEN] = {0xf0, 0xff, 0xff, 0xff, 0xff, 0xff}; 671 unsigned char mc_addr[ETH_ALEN] = {0xf1, 0xff, 0xff, 0xff, 0xff, 0xff}; 672 struct stmmac_packet_attrs attr = { }; 673 int ret, tries = 256; 674 675 if (stmmac_filter_check(priv)) 676 return -EOPNOTSUPP; 677 if (netdev_uc_count(priv->dev) >= priv->hw->unicast_filter_entries) 678 return -EOPNOTSUPP; 679 if (netdev_mc_count(priv->dev) >= priv->hw->multicast_filter_bins) 680 return -EOPNOTSUPP; 681 682 while (--tries) { 683 /* We only need to check the uc_addr for collisions */ 684 uc_addr[ETH_ALEN - 1] = tries; 685 if (stmmac_perfect_check(priv, uc_addr)) 686 break; 687 } 688 689 if (!tries) 690 return -EOPNOTSUPP; 691 692 ret = dev_mc_add(priv->dev, mc_addr); 693 if (ret) 694 return ret; 695 696 attr.dst = mc_addr; 697 698 /* Shall receive packet */ 699 ret = __stmmac_test_loopback(priv, &attr); 700 if (ret) 701 goto cleanup; 702 703 attr.dst = uc_addr; 704 705 /* Shall NOT receive packet */ 706 ret = __stmmac_test_loopback(priv, &attr); 707 ret = ret ? 0 : -EINVAL; 708 709 cleanup: 710 dev_mc_del(priv->dev, mc_addr); 711 return ret; 712 } 713 714 static int stmmac_test_flowctrl_validate(struct sk_buff *skb, 715 struct net_device *ndev, 716 struct packet_type *pt, 717 struct net_device *orig_ndev) 718 { 719 struct stmmac_test_priv *tpriv = pt->af_packet_priv; 720 struct ethhdr *ehdr; 721 722 ehdr = (struct ethhdr *)skb_mac_header(skb); 723 if (!ether_addr_equal_unaligned(ehdr->h_source, orig_ndev->dev_addr)) 724 goto out; 725 if (ehdr->h_proto != htons(ETH_P_PAUSE)) 726 goto out; 727 728 tpriv->ok = true; 729 complete(&tpriv->comp); 730 out: 731 kfree_skb(skb); 732 return 0; 733 } 734 735 static int stmmac_test_flowctrl(struct stmmac_priv *priv) 736 { 737 unsigned char paddr[ETH_ALEN] = {0x01, 0x80, 0xC2, 0x00, 0x00, 0x01}; 738 struct phy_device *phydev = priv->dev->phydev; 739 u32 rx_cnt = priv->plat->rx_queues_to_use; 740 struct stmmac_test_priv *tpriv; 741 unsigned int pkt_count; 742 int i, ret = 0; 743 744 if (!phydev || (!phydev->pause && !phydev->asym_pause)) 745 return -EOPNOTSUPP; 746 747 tpriv = kzalloc(sizeof(*tpriv), GFP_KERNEL); 748 if (!tpriv) 749 return -ENOMEM; 750 751 tpriv->ok = false; 752 init_completion(&tpriv->comp); 753 tpriv->pt.type = htons(ETH_P_PAUSE); 754 tpriv->pt.func = stmmac_test_flowctrl_validate; 755 tpriv->pt.dev = priv->dev; 756 tpriv->pt.af_packet_priv = tpriv; 757 dev_add_pack(&tpriv->pt); 758 759 /* Compute minimum number of packets to make FIFO full */ 760 pkt_count = priv->plat->rx_fifo_size; 761 if (!pkt_count) 762 pkt_count = priv->dma_cap.rx_fifo_size; 763 pkt_count /= 1400; 764 pkt_count *= 2; 765 766 for (i = 0; i < rx_cnt; i++) 767 stmmac_stop_rx(priv, priv->ioaddr, i); 768 769 ret = dev_set_promiscuity(priv->dev, 1); 770 if (ret) 771 goto cleanup; 772 773 ret = dev_mc_add(priv->dev, paddr); 774 if (ret) 775 goto cleanup; 776 777 for (i = 0; i < pkt_count; i++) { 778 struct stmmac_packet_attrs attr = { }; 779 780 attr.dst = priv->dev->dev_addr; 781 attr.dont_wait = true; 782 attr.size = 1400; 783 784 ret = __stmmac_test_loopback(priv, &attr); 785 if (ret) 786 goto cleanup; 787 if (tpriv->ok) 788 break; 789 } 790 791 /* Wait for some time in case RX Watchdog is enabled */ 792 msleep(200); 793 794 for (i = 0; i < rx_cnt; i++) { 795 struct stmmac_channel *ch = &priv->channel[i]; 796 u32 tail; 797 798 tail = priv->dma_conf.rx_queue[i].dma_rx_phy + 799 (priv->dma_conf.dma_rx_size * sizeof(struct dma_desc)); 800 801 stmmac_set_rx_tail_ptr(priv, priv->ioaddr, tail, i); 802 stmmac_start_rx(priv, priv->ioaddr, i); 803 804 local_bh_disable(); 805 napi_reschedule(&ch->rx_napi); 806 local_bh_enable(); 807 } 808 809 wait_for_completion_timeout(&tpriv->comp, STMMAC_LB_TIMEOUT); 810 ret = tpriv->ok ? 0 : -ETIMEDOUT; 811 812 cleanup: 813 dev_mc_del(priv->dev, paddr); 814 dev_set_promiscuity(priv->dev, -1); 815 dev_remove_pack(&tpriv->pt); 816 kfree(tpriv); 817 return ret; 818 } 819 820 static int stmmac_test_rss(struct stmmac_priv *priv) 821 { 822 struct stmmac_packet_attrs attr = { }; 823 824 if (!priv->dma_cap.rssen || !priv->rss.enable) 825 return -EOPNOTSUPP; 826 827 attr.dst = priv->dev->dev_addr; 828 attr.exp_hash = true; 829 attr.sport = 0x321; 830 attr.dport = 0x123; 831 832 return __stmmac_test_loopback(priv, &attr); 833 } 834 835 static int stmmac_test_vlan_validate(struct sk_buff *skb, 836 struct net_device *ndev, 837 struct packet_type *pt, 838 struct net_device *orig_ndev) 839 { 840 struct stmmac_test_priv *tpriv = pt->af_packet_priv; 841 struct stmmachdr *shdr; 842 struct ethhdr *ehdr; 843 struct udphdr *uhdr; 844 struct iphdr *ihdr; 845 u16 proto; 846 847 proto = tpriv->double_vlan ? ETH_P_8021AD : ETH_P_8021Q; 848 849 skb = skb_unshare(skb, GFP_ATOMIC); 850 if (!skb) 851 goto out; 852 853 if (skb_linearize(skb)) 854 goto out; 855 if (skb_headlen(skb) < (STMMAC_TEST_PKT_SIZE - ETH_HLEN)) 856 goto out; 857 if (tpriv->vlan_id) { 858 if (skb->vlan_proto != htons(proto)) 859 goto out; 860 if (skb->vlan_tci != tpriv->vlan_id) { 861 /* Means filter did not work. */ 862 tpriv->ok = false; 863 complete(&tpriv->comp); 864 goto out; 865 } 866 } 867 868 ehdr = (struct ethhdr *)skb_mac_header(skb); 869 if (!ether_addr_equal_unaligned(ehdr->h_dest, tpriv->packet->dst)) 870 goto out; 871 872 ihdr = ip_hdr(skb); 873 if (tpriv->double_vlan) 874 ihdr = (struct iphdr *)(skb_network_header(skb) + 4); 875 if (ihdr->protocol != IPPROTO_UDP) 876 goto out; 877 878 uhdr = (struct udphdr *)((u8 *)ihdr + 4 * ihdr->ihl); 879 if (uhdr->dest != htons(tpriv->packet->dport)) 880 goto out; 881 882 shdr = (struct stmmachdr *)((u8 *)uhdr + sizeof(*uhdr)); 883 if (shdr->magic != cpu_to_be64(STMMAC_TEST_PKT_MAGIC)) 884 goto out; 885 886 tpriv->ok = true; 887 complete(&tpriv->comp); 888 889 out: 890 kfree_skb(skb); 891 return 0; 892 } 893 894 static int __stmmac_test_vlanfilt(struct stmmac_priv *priv) 895 { 896 struct stmmac_packet_attrs attr = { }; 897 struct stmmac_test_priv *tpriv; 898 struct sk_buff *skb = NULL; 899 int ret = 0, i; 900 901 tpriv = kzalloc(sizeof(*tpriv), GFP_KERNEL); 902 if (!tpriv) 903 return -ENOMEM; 904 905 tpriv->ok = false; 906 init_completion(&tpriv->comp); 907 908 tpriv->pt.type = htons(ETH_P_IP); 909 tpriv->pt.func = stmmac_test_vlan_validate; 910 tpriv->pt.dev = priv->dev; 911 tpriv->pt.af_packet_priv = tpriv; 912 tpriv->packet = &attr; 913 914 /* 915 * As we use HASH filtering, false positives may appear. This is a 916 * specially chosen ID so that adjacent IDs (+4) have different 917 * HASH values. 918 */ 919 tpriv->vlan_id = 0x123; 920 dev_add_pack(&tpriv->pt); 921 922 ret = vlan_vid_add(priv->dev, htons(ETH_P_8021Q), tpriv->vlan_id); 923 if (ret) 924 goto cleanup; 925 926 for (i = 0; i < 4; i++) { 927 attr.vlan = 1; 928 attr.vlan_id_out = tpriv->vlan_id + i; 929 attr.dst = priv->dev->dev_addr; 930 attr.sport = 9; 931 attr.dport = 9; 932 933 skb = stmmac_test_get_udp_skb(priv, &attr); 934 if (!skb) { 935 ret = -ENOMEM; 936 goto vlan_del; 937 } 938 939 ret = dev_direct_xmit(skb, 0); 940 if (ret) 941 goto vlan_del; 942 943 wait_for_completion_timeout(&tpriv->comp, STMMAC_LB_TIMEOUT); 944 ret = tpriv->ok ? 0 : -ETIMEDOUT; 945 if (ret && !i) { 946 goto vlan_del; 947 } else if (!ret && i) { 948 ret = -EINVAL; 949 goto vlan_del; 950 } else { 951 ret = 0; 952 } 953 954 tpriv->ok = false; 955 } 956 957 vlan_del: 958 vlan_vid_del(priv->dev, htons(ETH_P_8021Q), tpriv->vlan_id); 959 cleanup: 960 dev_remove_pack(&tpriv->pt); 961 kfree(tpriv); 962 return ret; 963 } 964 965 static int stmmac_test_vlanfilt(struct stmmac_priv *priv) 966 { 967 if (!priv->dma_cap.vlhash) 968 return -EOPNOTSUPP; 969 970 return __stmmac_test_vlanfilt(priv); 971 } 972 973 static int stmmac_test_vlanfilt_perfect(struct stmmac_priv *priv) 974 { 975 int ret, prev_cap = priv->dma_cap.vlhash; 976 977 if (!(priv->dev->features & NETIF_F_HW_VLAN_CTAG_FILTER)) 978 return -EOPNOTSUPP; 979 980 priv->dma_cap.vlhash = 0; 981 ret = __stmmac_test_vlanfilt(priv); 982 priv->dma_cap.vlhash = prev_cap; 983 984 return ret; 985 } 986 987 static int __stmmac_test_dvlanfilt(struct stmmac_priv *priv) 988 { 989 struct stmmac_packet_attrs attr = { }; 990 struct stmmac_test_priv *tpriv; 991 struct sk_buff *skb = NULL; 992 int ret = 0, i; 993 994 tpriv = kzalloc(sizeof(*tpriv), GFP_KERNEL); 995 if (!tpriv) 996 return -ENOMEM; 997 998 tpriv->ok = false; 999 tpriv->double_vlan = true; 1000 init_completion(&tpriv->comp); 1001 1002 tpriv->pt.type = htons(ETH_P_8021Q); 1003 tpriv->pt.func = stmmac_test_vlan_validate; 1004 tpriv->pt.dev = priv->dev; 1005 tpriv->pt.af_packet_priv = tpriv; 1006 tpriv->packet = &attr; 1007 1008 /* 1009 * As we use HASH filtering, false positives may appear. This is a 1010 * specially chosen ID so that adjacent IDs (+4) have different 1011 * HASH values. 1012 */ 1013 tpriv->vlan_id = 0x123; 1014 dev_add_pack(&tpriv->pt); 1015 1016 ret = vlan_vid_add(priv->dev, htons(ETH_P_8021AD), tpriv->vlan_id); 1017 if (ret) 1018 goto cleanup; 1019 1020 for (i = 0; i < 4; i++) { 1021 attr.vlan = 2; 1022 attr.vlan_id_out = tpriv->vlan_id + i; 1023 attr.dst = priv->dev->dev_addr; 1024 attr.sport = 9; 1025 attr.dport = 9; 1026 1027 skb = stmmac_test_get_udp_skb(priv, &attr); 1028 if (!skb) { 1029 ret = -ENOMEM; 1030 goto vlan_del; 1031 } 1032 1033 ret = dev_direct_xmit(skb, 0); 1034 if (ret) 1035 goto vlan_del; 1036 1037 wait_for_completion_timeout(&tpriv->comp, STMMAC_LB_TIMEOUT); 1038 ret = tpriv->ok ? 0 : -ETIMEDOUT; 1039 if (ret && !i) { 1040 goto vlan_del; 1041 } else if (!ret && i) { 1042 ret = -EINVAL; 1043 goto vlan_del; 1044 } else { 1045 ret = 0; 1046 } 1047 1048 tpriv->ok = false; 1049 } 1050 1051 vlan_del: 1052 vlan_vid_del(priv->dev, htons(ETH_P_8021AD), tpriv->vlan_id); 1053 cleanup: 1054 dev_remove_pack(&tpriv->pt); 1055 kfree(tpriv); 1056 return ret; 1057 } 1058 1059 static int stmmac_test_dvlanfilt(struct stmmac_priv *priv) 1060 { 1061 if (!priv->dma_cap.vlhash) 1062 return -EOPNOTSUPP; 1063 1064 return __stmmac_test_dvlanfilt(priv); 1065 } 1066 1067 static int stmmac_test_dvlanfilt_perfect(struct stmmac_priv *priv) 1068 { 1069 int ret, prev_cap = priv->dma_cap.vlhash; 1070 1071 if (!(priv->dev->features & NETIF_F_HW_VLAN_STAG_FILTER)) 1072 return -EOPNOTSUPP; 1073 1074 priv->dma_cap.vlhash = 0; 1075 ret = __stmmac_test_dvlanfilt(priv); 1076 priv->dma_cap.vlhash = prev_cap; 1077 1078 return ret; 1079 } 1080 1081 #ifdef CONFIG_NET_CLS_ACT 1082 static int stmmac_test_rxp(struct stmmac_priv *priv) 1083 { 1084 unsigned char addr[ETH_ALEN] = {0xde, 0xad, 0xbe, 0xef, 0x00, 0x00}; 1085 struct tc_cls_u32_offload cls_u32 = { }; 1086 struct stmmac_packet_attrs attr = { }; 1087 struct tc_action **actions; 1088 struct tc_u32_sel *sel; 1089 struct tcf_gact *gact; 1090 struct tcf_exts *exts; 1091 int ret, i, nk = 1; 1092 1093 if (!tc_can_offload(priv->dev)) 1094 return -EOPNOTSUPP; 1095 if (!priv->dma_cap.frpsel) 1096 return -EOPNOTSUPP; 1097 1098 sel = kzalloc(struct_size(sel, keys, nk), GFP_KERNEL); 1099 if (!sel) 1100 return -ENOMEM; 1101 1102 exts = kzalloc(sizeof(*exts), GFP_KERNEL); 1103 if (!exts) { 1104 ret = -ENOMEM; 1105 goto cleanup_sel; 1106 } 1107 1108 actions = kcalloc(nk, sizeof(*actions), GFP_KERNEL); 1109 if (!actions) { 1110 ret = -ENOMEM; 1111 goto cleanup_exts; 1112 } 1113 1114 gact = kcalloc(nk, sizeof(*gact), GFP_KERNEL); 1115 if (!gact) { 1116 ret = -ENOMEM; 1117 goto cleanup_actions; 1118 } 1119 1120 cls_u32.command = TC_CLSU32_NEW_KNODE; 1121 cls_u32.common.chain_index = 0; 1122 cls_u32.common.protocol = htons(ETH_P_ALL); 1123 cls_u32.knode.exts = exts; 1124 cls_u32.knode.sel = sel; 1125 cls_u32.knode.handle = 0x123; 1126 1127 exts->nr_actions = nk; 1128 exts->actions = actions; 1129 for (i = 0; i < nk; i++) { 1130 actions[i] = (struct tc_action *)&gact[i]; 1131 gact->tcf_action = TC_ACT_SHOT; 1132 } 1133 1134 sel->nkeys = nk; 1135 sel->offshift = 0; 1136 sel->keys[0].off = 6; 1137 sel->keys[0].val = htonl(0xdeadbeef); 1138 sel->keys[0].mask = ~0x0; 1139 1140 ret = stmmac_tc_setup_cls_u32(priv, priv, &cls_u32); 1141 if (ret) 1142 goto cleanup_act; 1143 1144 attr.dst = priv->dev->dev_addr; 1145 attr.src = addr; 1146 1147 ret = __stmmac_test_loopback(priv, &attr); 1148 ret = ret ? 0 : -EINVAL; /* Shall NOT receive packet */ 1149 1150 cls_u32.command = TC_CLSU32_DELETE_KNODE; 1151 stmmac_tc_setup_cls_u32(priv, priv, &cls_u32); 1152 1153 cleanup_act: 1154 kfree(gact); 1155 cleanup_actions: 1156 kfree(actions); 1157 cleanup_exts: 1158 kfree(exts); 1159 cleanup_sel: 1160 kfree(sel); 1161 return ret; 1162 } 1163 #else 1164 static int stmmac_test_rxp(struct stmmac_priv *priv) 1165 { 1166 return -EOPNOTSUPP; 1167 } 1168 #endif 1169 1170 static int stmmac_test_desc_sai(struct stmmac_priv *priv) 1171 { 1172 unsigned char src[ETH_ALEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; 1173 struct stmmac_packet_attrs attr = { }; 1174 int ret; 1175 1176 if (!priv->dma_cap.vlins) 1177 return -EOPNOTSUPP; 1178 1179 attr.remove_sa = true; 1180 attr.sarc = true; 1181 attr.src = src; 1182 attr.dst = priv->dev->dev_addr; 1183 1184 priv->sarc_type = 0x1; 1185 1186 ret = __stmmac_test_loopback(priv, &attr); 1187 1188 priv->sarc_type = 0x0; 1189 return ret; 1190 } 1191 1192 static int stmmac_test_desc_sar(struct stmmac_priv *priv) 1193 { 1194 unsigned char src[ETH_ALEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; 1195 struct stmmac_packet_attrs attr = { }; 1196 int ret; 1197 1198 if (!priv->dma_cap.vlins) 1199 return -EOPNOTSUPP; 1200 1201 attr.sarc = true; 1202 attr.src = src; 1203 attr.dst = priv->dev->dev_addr; 1204 1205 priv->sarc_type = 0x2; 1206 1207 ret = __stmmac_test_loopback(priv, &attr); 1208 1209 priv->sarc_type = 0x0; 1210 return ret; 1211 } 1212 1213 static int stmmac_test_reg_sai(struct stmmac_priv *priv) 1214 { 1215 unsigned char src[ETH_ALEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; 1216 struct stmmac_packet_attrs attr = { }; 1217 int ret; 1218 1219 if (!priv->dma_cap.vlins) 1220 return -EOPNOTSUPP; 1221 1222 attr.remove_sa = true; 1223 attr.sarc = true; 1224 attr.src = src; 1225 attr.dst = priv->dev->dev_addr; 1226 1227 if (stmmac_sarc_configure(priv, priv->ioaddr, 0x2)) 1228 return -EOPNOTSUPP; 1229 1230 ret = __stmmac_test_loopback(priv, &attr); 1231 1232 stmmac_sarc_configure(priv, priv->ioaddr, 0x0); 1233 return ret; 1234 } 1235 1236 static int stmmac_test_reg_sar(struct stmmac_priv *priv) 1237 { 1238 unsigned char src[ETH_ALEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; 1239 struct stmmac_packet_attrs attr = { }; 1240 int ret; 1241 1242 if (!priv->dma_cap.vlins) 1243 return -EOPNOTSUPP; 1244 1245 attr.sarc = true; 1246 attr.src = src; 1247 attr.dst = priv->dev->dev_addr; 1248 1249 if (stmmac_sarc_configure(priv, priv->ioaddr, 0x3)) 1250 return -EOPNOTSUPP; 1251 1252 ret = __stmmac_test_loopback(priv, &attr); 1253 1254 stmmac_sarc_configure(priv, priv->ioaddr, 0x0); 1255 return ret; 1256 } 1257 1258 static int stmmac_test_vlanoff_common(struct stmmac_priv *priv, bool svlan) 1259 { 1260 struct stmmac_packet_attrs attr = { }; 1261 struct stmmac_test_priv *tpriv; 1262 struct sk_buff *skb = NULL; 1263 int ret = 0; 1264 u16 proto; 1265 1266 if (!priv->dma_cap.vlins) 1267 return -EOPNOTSUPP; 1268 1269 tpriv = kzalloc(sizeof(*tpriv), GFP_KERNEL); 1270 if (!tpriv) 1271 return -ENOMEM; 1272 1273 proto = svlan ? ETH_P_8021AD : ETH_P_8021Q; 1274 1275 tpriv->ok = false; 1276 tpriv->double_vlan = svlan; 1277 init_completion(&tpriv->comp); 1278 1279 tpriv->pt.type = svlan ? htons(ETH_P_8021Q) : htons(ETH_P_IP); 1280 tpriv->pt.func = stmmac_test_vlan_validate; 1281 tpriv->pt.dev = priv->dev; 1282 tpriv->pt.af_packet_priv = tpriv; 1283 tpriv->packet = &attr; 1284 tpriv->vlan_id = 0x123; 1285 dev_add_pack(&tpriv->pt); 1286 1287 ret = vlan_vid_add(priv->dev, htons(proto), tpriv->vlan_id); 1288 if (ret) 1289 goto cleanup; 1290 1291 attr.dst = priv->dev->dev_addr; 1292 1293 skb = stmmac_test_get_udp_skb(priv, &attr); 1294 if (!skb) { 1295 ret = -ENOMEM; 1296 goto vlan_del; 1297 } 1298 1299 __vlan_hwaccel_put_tag(skb, htons(proto), tpriv->vlan_id); 1300 skb->protocol = htons(proto); 1301 1302 ret = dev_direct_xmit(skb, 0); 1303 if (ret) 1304 goto vlan_del; 1305 1306 wait_for_completion_timeout(&tpriv->comp, STMMAC_LB_TIMEOUT); 1307 ret = tpriv->ok ? 0 : -ETIMEDOUT; 1308 1309 vlan_del: 1310 vlan_vid_del(priv->dev, htons(proto), tpriv->vlan_id); 1311 cleanup: 1312 dev_remove_pack(&tpriv->pt); 1313 kfree(tpriv); 1314 return ret; 1315 } 1316 1317 static int stmmac_test_vlanoff(struct stmmac_priv *priv) 1318 { 1319 return stmmac_test_vlanoff_common(priv, false); 1320 } 1321 1322 static int stmmac_test_svlanoff(struct stmmac_priv *priv) 1323 { 1324 if (!priv->dma_cap.dvlan) 1325 return -EOPNOTSUPP; 1326 return stmmac_test_vlanoff_common(priv, true); 1327 } 1328 1329 #ifdef CONFIG_NET_CLS_ACT 1330 static int __stmmac_test_l3filt(struct stmmac_priv *priv, u32 dst, u32 src, 1331 u32 dst_mask, u32 src_mask) 1332 { 1333 struct flow_dissector_key_ipv4_addrs key, mask; 1334 unsigned long dummy_cookie = 0xdeadbeef; 1335 struct stmmac_packet_attrs attr = { }; 1336 struct flow_dissector *dissector; 1337 struct flow_cls_offload *cls; 1338 int ret, old_enable = 0; 1339 struct flow_rule *rule; 1340 1341 if (!tc_can_offload(priv->dev)) 1342 return -EOPNOTSUPP; 1343 if (!priv->dma_cap.l3l4fnum) 1344 return -EOPNOTSUPP; 1345 if (priv->rss.enable) { 1346 old_enable = priv->rss.enable; 1347 priv->rss.enable = false; 1348 stmmac_rss_configure(priv, priv->hw, NULL, 1349 priv->plat->rx_queues_to_use); 1350 } 1351 1352 dissector = kzalloc(sizeof(*dissector), GFP_KERNEL); 1353 if (!dissector) { 1354 ret = -ENOMEM; 1355 goto cleanup_rss; 1356 } 1357 1358 dissector->used_keys |= (1ULL << FLOW_DISSECTOR_KEY_IPV4_ADDRS); 1359 dissector->offset[FLOW_DISSECTOR_KEY_IPV4_ADDRS] = 0; 1360 1361 cls = kzalloc(sizeof(*cls), GFP_KERNEL); 1362 if (!cls) { 1363 ret = -ENOMEM; 1364 goto cleanup_dissector; 1365 } 1366 1367 cls->common.chain_index = 0; 1368 cls->command = FLOW_CLS_REPLACE; 1369 cls->cookie = dummy_cookie; 1370 1371 rule = kzalloc(struct_size(rule, action.entries, 1), GFP_KERNEL); 1372 if (!rule) { 1373 ret = -ENOMEM; 1374 goto cleanup_cls; 1375 } 1376 1377 rule->match.dissector = dissector; 1378 rule->match.key = (void *)&key; 1379 rule->match.mask = (void *)&mask; 1380 1381 key.src = htonl(src); 1382 key.dst = htonl(dst); 1383 mask.src = src_mask; 1384 mask.dst = dst_mask; 1385 1386 cls->rule = rule; 1387 1388 rule->action.entries[0].id = FLOW_ACTION_DROP; 1389 rule->action.entries[0].hw_stats = FLOW_ACTION_HW_STATS_ANY; 1390 rule->action.num_entries = 1; 1391 1392 attr.dst = priv->dev->dev_addr; 1393 attr.ip_dst = dst; 1394 attr.ip_src = src; 1395 1396 /* Shall receive packet */ 1397 ret = __stmmac_test_loopback(priv, &attr); 1398 if (ret) 1399 goto cleanup_rule; 1400 1401 ret = stmmac_tc_setup_cls(priv, priv, cls); 1402 if (ret) 1403 goto cleanup_rule; 1404 1405 /* Shall NOT receive packet */ 1406 ret = __stmmac_test_loopback(priv, &attr); 1407 ret = ret ? 0 : -EINVAL; 1408 1409 cls->command = FLOW_CLS_DESTROY; 1410 stmmac_tc_setup_cls(priv, priv, cls); 1411 cleanup_rule: 1412 kfree(rule); 1413 cleanup_cls: 1414 kfree(cls); 1415 cleanup_dissector: 1416 kfree(dissector); 1417 cleanup_rss: 1418 if (old_enable) { 1419 priv->rss.enable = old_enable; 1420 stmmac_rss_configure(priv, priv->hw, &priv->rss, 1421 priv->plat->rx_queues_to_use); 1422 } 1423 1424 return ret; 1425 } 1426 #else 1427 static int __stmmac_test_l3filt(struct stmmac_priv *priv, u32 dst, u32 src, 1428 u32 dst_mask, u32 src_mask) 1429 { 1430 return -EOPNOTSUPP; 1431 } 1432 #endif 1433 1434 static int stmmac_test_l3filt_da(struct stmmac_priv *priv) 1435 { 1436 u32 addr = 0x10203040; 1437 1438 return __stmmac_test_l3filt(priv, addr, 0, ~0, 0); 1439 } 1440 1441 static int stmmac_test_l3filt_sa(struct stmmac_priv *priv) 1442 { 1443 u32 addr = 0x10203040; 1444 1445 return __stmmac_test_l3filt(priv, 0, addr, 0, ~0); 1446 } 1447 1448 #ifdef CONFIG_NET_CLS_ACT 1449 static int __stmmac_test_l4filt(struct stmmac_priv *priv, u32 dst, u32 src, 1450 u32 dst_mask, u32 src_mask, bool udp) 1451 { 1452 struct { 1453 struct flow_dissector_key_basic bkey; 1454 struct flow_dissector_key_ports key; 1455 } __aligned(BITS_PER_LONG / 8) keys; 1456 struct { 1457 struct flow_dissector_key_basic bmask; 1458 struct flow_dissector_key_ports mask; 1459 } __aligned(BITS_PER_LONG / 8) masks; 1460 unsigned long dummy_cookie = 0xdeadbeef; 1461 struct stmmac_packet_attrs attr = { }; 1462 struct flow_dissector *dissector; 1463 struct flow_cls_offload *cls; 1464 int ret, old_enable = 0; 1465 struct flow_rule *rule; 1466 1467 if (!tc_can_offload(priv->dev)) 1468 return -EOPNOTSUPP; 1469 if (!priv->dma_cap.l3l4fnum) 1470 return -EOPNOTSUPP; 1471 if (priv->rss.enable) { 1472 old_enable = priv->rss.enable; 1473 priv->rss.enable = false; 1474 stmmac_rss_configure(priv, priv->hw, NULL, 1475 priv->plat->rx_queues_to_use); 1476 } 1477 1478 dissector = kzalloc(sizeof(*dissector), GFP_KERNEL); 1479 if (!dissector) { 1480 ret = -ENOMEM; 1481 goto cleanup_rss; 1482 } 1483 1484 dissector->used_keys |= (1ULL << FLOW_DISSECTOR_KEY_BASIC); 1485 dissector->used_keys |= (1ULL << FLOW_DISSECTOR_KEY_PORTS); 1486 dissector->offset[FLOW_DISSECTOR_KEY_BASIC] = 0; 1487 dissector->offset[FLOW_DISSECTOR_KEY_PORTS] = offsetof(typeof(keys), key); 1488 1489 cls = kzalloc(sizeof(*cls), GFP_KERNEL); 1490 if (!cls) { 1491 ret = -ENOMEM; 1492 goto cleanup_dissector; 1493 } 1494 1495 cls->common.chain_index = 0; 1496 cls->command = FLOW_CLS_REPLACE; 1497 cls->cookie = dummy_cookie; 1498 1499 rule = kzalloc(struct_size(rule, action.entries, 1), GFP_KERNEL); 1500 if (!rule) { 1501 ret = -ENOMEM; 1502 goto cleanup_cls; 1503 } 1504 1505 rule->match.dissector = dissector; 1506 rule->match.key = (void *)&keys; 1507 rule->match.mask = (void *)&masks; 1508 1509 keys.bkey.ip_proto = udp ? IPPROTO_UDP : IPPROTO_TCP; 1510 keys.key.src = htons(src); 1511 keys.key.dst = htons(dst); 1512 masks.mask.src = src_mask; 1513 masks.mask.dst = dst_mask; 1514 1515 cls->rule = rule; 1516 1517 rule->action.entries[0].id = FLOW_ACTION_DROP; 1518 rule->action.entries[0].hw_stats = FLOW_ACTION_HW_STATS_ANY; 1519 rule->action.num_entries = 1; 1520 1521 attr.dst = priv->dev->dev_addr; 1522 attr.tcp = !udp; 1523 attr.sport = src; 1524 attr.dport = dst; 1525 attr.ip_dst = 0; 1526 1527 /* Shall receive packet */ 1528 ret = __stmmac_test_loopback(priv, &attr); 1529 if (ret) 1530 goto cleanup_rule; 1531 1532 ret = stmmac_tc_setup_cls(priv, priv, cls); 1533 if (ret) 1534 goto cleanup_rule; 1535 1536 /* Shall NOT receive packet */ 1537 ret = __stmmac_test_loopback(priv, &attr); 1538 ret = ret ? 0 : -EINVAL; 1539 1540 cls->command = FLOW_CLS_DESTROY; 1541 stmmac_tc_setup_cls(priv, priv, cls); 1542 cleanup_rule: 1543 kfree(rule); 1544 cleanup_cls: 1545 kfree(cls); 1546 cleanup_dissector: 1547 kfree(dissector); 1548 cleanup_rss: 1549 if (old_enable) { 1550 priv->rss.enable = old_enable; 1551 stmmac_rss_configure(priv, priv->hw, &priv->rss, 1552 priv->plat->rx_queues_to_use); 1553 } 1554 1555 return ret; 1556 } 1557 #else 1558 static int __stmmac_test_l4filt(struct stmmac_priv *priv, u32 dst, u32 src, 1559 u32 dst_mask, u32 src_mask, bool udp) 1560 { 1561 return -EOPNOTSUPP; 1562 } 1563 #endif 1564 1565 static int stmmac_test_l4filt_da_tcp(struct stmmac_priv *priv) 1566 { 1567 u16 dummy_port = 0x123; 1568 1569 return __stmmac_test_l4filt(priv, dummy_port, 0, ~0, 0, false); 1570 } 1571 1572 static int stmmac_test_l4filt_sa_tcp(struct stmmac_priv *priv) 1573 { 1574 u16 dummy_port = 0x123; 1575 1576 return __stmmac_test_l4filt(priv, 0, dummy_port, 0, ~0, false); 1577 } 1578 1579 static int stmmac_test_l4filt_da_udp(struct stmmac_priv *priv) 1580 { 1581 u16 dummy_port = 0x123; 1582 1583 return __stmmac_test_l4filt(priv, dummy_port, 0, ~0, 0, true); 1584 } 1585 1586 static int stmmac_test_l4filt_sa_udp(struct stmmac_priv *priv) 1587 { 1588 u16 dummy_port = 0x123; 1589 1590 return __stmmac_test_l4filt(priv, 0, dummy_port, 0, ~0, true); 1591 } 1592 1593 static int stmmac_test_arp_validate(struct sk_buff *skb, 1594 struct net_device *ndev, 1595 struct packet_type *pt, 1596 struct net_device *orig_ndev) 1597 { 1598 struct stmmac_test_priv *tpriv = pt->af_packet_priv; 1599 struct ethhdr *ehdr; 1600 struct arphdr *ahdr; 1601 1602 ehdr = (struct ethhdr *)skb_mac_header(skb); 1603 if (!ether_addr_equal_unaligned(ehdr->h_dest, tpriv->packet->src)) 1604 goto out; 1605 1606 ahdr = arp_hdr(skb); 1607 if (ahdr->ar_op != htons(ARPOP_REPLY)) 1608 goto out; 1609 1610 tpriv->ok = true; 1611 complete(&tpriv->comp); 1612 out: 1613 kfree_skb(skb); 1614 return 0; 1615 } 1616 1617 static int stmmac_test_arpoffload(struct stmmac_priv *priv) 1618 { 1619 unsigned char src[ETH_ALEN] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06}; 1620 unsigned char dst[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; 1621 struct stmmac_packet_attrs attr = { }; 1622 struct stmmac_test_priv *tpriv; 1623 struct sk_buff *skb = NULL; 1624 u32 ip_addr = 0xdeadcafe; 1625 u32 ip_src = 0xdeadbeef; 1626 int ret; 1627 1628 if (!priv->dma_cap.arpoffsel) 1629 return -EOPNOTSUPP; 1630 1631 tpriv = kzalloc(sizeof(*tpriv), GFP_KERNEL); 1632 if (!tpriv) 1633 return -ENOMEM; 1634 1635 tpriv->ok = false; 1636 init_completion(&tpriv->comp); 1637 1638 tpriv->pt.type = htons(ETH_P_ARP); 1639 tpriv->pt.func = stmmac_test_arp_validate; 1640 tpriv->pt.dev = priv->dev; 1641 tpriv->pt.af_packet_priv = tpriv; 1642 tpriv->packet = &attr; 1643 dev_add_pack(&tpriv->pt); 1644 1645 attr.src = src; 1646 attr.ip_src = ip_src; 1647 attr.dst = dst; 1648 attr.ip_dst = ip_addr; 1649 1650 skb = stmmac_test_get_arp_skb(priv, &attr); 1651 if (!skb) { 1652 ret = -ENOMEM; 1653 goto cleanup; 1654 } 1655 1656 ret = stmmac_set_arp_offload(priv, priv->hw, true, ip_addr); 1657 if (ret) { 1658 kfree_skb(skb); 1659 goto cleanup; 1660 } 1661 1662 ret = dev_set_promiscuity(priv->dev, 1); 1663 if (ret) { 1664 kfree_skb(skb); 1665 goto cleanup; 1666 } 1667 1668 ret = dev_direct_xmit(skb, 0); 1669 if (ret) 1670 goto cleanup_promisc; 1671 1672 wait_for_completion_timeout(&tpriv->comp, STMMAC_LB_TIMEOUT); 1673 ret = tpriv->ok ? 0 : -ETIMEDOUT; 1674 1675 cleanup_promisc: 1676 dev_set_promiscuity(priv->dev, -1); 1677 cleanup: 1678 stmmac_set_arp_offload(priv, priv->hw, false, 0x0); 1679 dev_remove_pack(&tpriv->pt); 1680 kfree(tpriv); 1681 return ret; 1682 } 1683 1684 static int __stmmac_test_jumbo(struct stmmac_priv *priv, u16 queue) 1685 { 1686 struct stmmac_packet_attrs attr = { }; 1687 int size = priv->dma_conf.dma_buf_sz; 1688 1689 attr.dst = priv->dev->dev_addr; 1690 attr.max_size = size - ETH_FCS_LEN; 1691 attr.queue_mapping = queue; 1692 1693 return __stmmac_test_loopback(priv, &attr); 1694 } 1695 1696 static int stmmac_test_jumbo(struct stmmac_priv *priv) 1697 { 1698 return __stmmac_test_jumbo(priv, 0); 1699 } 1700 1701 static int stmmac_test_mjumbo(struct stmmac_priv *priv) 1702 { 1703 u32 chan, tx_cnt = priv->plat->tx_queues_to_use; 1704 int ret; 1705 1706 if (tx_cnt <= 1) 1707 return -EOPNOTSUPP; 1708 1709 for (chan = 0; chan < tx_cnt; chan++) { 1710 ret = __stmmac_test_jumbo(priv, chan); 1711 if (ret) 1712 return ret; 1713 } 1714 1715 return 0; 1716 } 1717 1718 static int stmmac_test_sph(struct stmmac_priv *priv) 1719 { 1720 unsigned long cnt_end, cnt_start = priv->xstats.rx_split_hdr_pkt_n; 1721 struct stmmac_packet_attrs attr = { }; 1722 int ret; 1723 1724 if (!priv->sph) 1725 return -EOPNOTSUPP; 1726 1727 /* Check for UDP first */ 1728 attr.dst = priv->dev->dev_addr; 1729 attr.tcp = false; 1730 1731 ret = __stmmac_test_loopback(priv, &attr); 1732 if (ret) 1733 return ret; 1734 1735 cnt_end = priv->xstats.rx_split_hdr_pkt_n; 1736 if (cnt_end <= cnt_start) 1737 return -EINVAL; 1738 1739 /* Check for TCP now */ 1740 cnt_start = cnt_end; 1741 1742 attr.dst = priv->dev->dev_addr; 1743 attr.tcp = true; 1744 1745 ret = __stmmac_test_loopback(priv, &attr); 1746 if (ret) 1747 return ret; 1748 1749 cnt_end = priv->xstats.rx_split_hdr_pkt_n; 1750 if (cnt_end <= cnt_start) 1751 return -EINVAL; 1752 1753 return 0; 1754 } 1755 1756 static int stmmac_test_tbs(struct stmmac_priv *priv) 1757 { 1758 #define STMMAC_TBS_LT_OFFSET (500 * 1000 * 1000) /* 500 ms*/ 1759 struct stmmac_packet_attrs attr = { }; 1760 struct tc_etf_qopt_offload qopt; 1761 u64 start_time, curr_time = 0; 1762 unsigned long flags; 1763 int ret, i; 1764 1765 if (!priv->hwts_tx_en) 1766 return -EOPNOTSUPP; 1767 1768 /* Find first TBS enabled Queue, if any */ 1769 for (i = 0; i < priv->plat->tx_queues_to_use; i++) 1770 if (priv->dma_conf.tx_queue[i].tbs & STMMAC_TBS_AVAIL) 1771 break; 1772 1773 if (i >= priv->plat->tx_queues_to_use) 1774 return -EOPNOTSUPP; 1775 1776 qopt.enable = true; 1777 qopt.queue = i; 1778 1779 ret = stmmac_tc_setup_etf(priv, priv, &qopt); 1780 if (ret) 1781 return ret; 1782 1783 read_lock_irqsave(&priv->ptp_lock, flags); 1784 stmmac_get_systime(priv, priv->ptpaddr, &curr_time); 1785 read_unlock_irqrestore(&priv->ptp_lock, flags); 1786 1787 if (!curr_time) { 1788 ret = -EOPNOTSUPP; 1789 goto fail_disable; 1790 } 1791 1792 start_time = curr_time; 1793 curr_time += STMMAC_TBS_LT_OFFSET; 1794 1795 attr.dst = priv->dev->dev_addr; 1796 attr.timestamp = curr_time; 1797 attr.timeout = nsecs_to_jiffies(2 * STMMAC_TBS_LT_OFFSET); 1798 attr.queue_mapping = i; 1799 1800 ret = __stmmac_test_loopback(priv, &attr); 1801 if (ret) 1802 goto fail_disable; 1803 1804 /* Check if expected time has elapsed */ 1805 read_lock_irqsave(&priv->ptp_lock, flags); 1806 stmmac_get_systime(priv, priv->ptpaddr, &curr_time); 1807 read_unlock_irqrestore(&priv->ptp_lock, flags); 1808 1809 if ((curr_time - start_time) < STMMAC_TBS_LT_OFFSET) 1810 ret = -EINVAL; 1811 1812 fail_disable: 1813 qopt.enable = false; 1814 stmmac_tc_setup_etf(priv, priv, &qopt); 1815 return ret; 1816 } 1817 1818 #define STMMAC_LOOPBACK_NONE 0 1819 #define STMMAC_LOOPBACK_MAC 1 1820 #define STMMAC_LOOPBACK_PHY 2 1821 1822 static const struct stmmac_test { 1823 char name[ETH_GSTRING_LEN]; 1824 int lb; 1825 int (*fn)(struct stmmac_priv *priv); 1826 } stmmac_selftests[] = { 1827 { 1828 .name = "MAC Loopback ", 1829 .lb = STMMAC_LOOPBACK_MAC, 1830 .fn = stmmac_test_mac_loopback, 1831 }, { 1832 .name = "PHY Loopback ", 1833 .lb = STMMAC_LOOPBACK_NONE, /* Test will handle it */ 1834 .fn = stmmac_test_phy_loopback, 1835 }, { 1836 .name = "MMC Counters ", 1837 .lb = STMMAC_LOOPBACK_PHY, 1838 .fn = stmmac_test_mmc, 1839 }, { 1840 .name = "EEE ", 1841 .lb = STMMAC_LOOPBACK_PHY, 1842 .fn = stmmac_test_eee, 1843 }, { 1844 .name = "Hash Filter MC ", 1845 .lb = STMMAC_LOOPBACK_PHY, 1846 .fn = stmmac_test_hfilt, 1847 }, { 1848 .name = "Perfect Filter UC ", 1849 .lb = STMMAC_LOOPBACK_PHY, 1850 .fn = stmmac_test_pfilt, 1851 }, { 1852 .name = "MC Filter ", 1853 .lb = STMMAC_LOOPBACK_PHY, 1854 .fn = stmmac_test_mcfilt, 1855 }, { 1856 .name = "UC Filter ", 1857 .lb = STMMAC_LOOPBACK_PHY, 1858 .fn = stmmac_test_ucfilt, 1859 }, { 1860 .name = "Flow Control ", 1861 .lb = STMMAC_LOOPBACK_PHY, 1862 .fn = stmmac_test_flowctrl, 1863 }, { 1864 .name = "RSS ", 1865 .lb = STMMAC_LOOPBACK_PHY, 1866 .fn = stmmac_test_rss, 1867 }, { 1868 .name = "VLAN Filtering ", 1869 .lb = STMMAC_LOOPBACK_PHY, 1870 .fn = stmmac_test_vlanfilt, 1871 }, { 1872 .name = "VLAN Filtering (perf) ", 1873 .lb = STMMAC_LOOPBACK_PHY, 1874 .fn = stmmac_test_vlanfilt_perfect, 1875 }, { 1876 .name = "Double VLAN Filter ", 1877 .lb = STMMAC_LOOPBACK_PHY, 1878 .fn = stmmac_test_dvlanfilt, 1879 }, { 1880 .name = "Double VLAN Filter (perf) ", 1881 .lb = STMMAC_LOOPBACK_PHY, 1882 .fn = stmmac_test_dvlanfilt_perfect, 1883 }, { 1884 .name = "Flexible RX Parser ", 1885 .lb = STMMAC_LOOPBACK_PHY, 1886 .fn = stmmac_test_rxp, 1887 }, { 1888 .name = "SA Insertion (desc) ", 1889 .lb = STMMAC_LOOPBACK_PHY, 1890 .fn = stmmac_test_desc_sai, 1891 }, { 1892 .name = "SA Replacement (desc) ", 1893 .lb = STMMAC_LOOPBACK_PHY, 1894 .fn = stmmac_test_desc_sar, 1895 }, { 1896 .name = "SA Insertion (reg) ", 1897 .lb = STMMAC_LOOPBACK_PHY, 1898 .fn = stmmac_test_reg_sai, 1899 }, { 1900 .name = "SA Replacement (reg) ", 1901 .lb = STMMAC_LOOPBACK_PHY, 1902 .fn = stmmac_test_reg_sar, 1903 }, { 1904 .name = "VLAN TX Insertion ", 1905 .lb = STMMAC_LOOPBACK_PHY, 1906 .fn = stmmac_test_vlanoff, 1907 }, { 1908 .name = "SVLAN TX Insertion ", 1909 .lb = STMMAC_LOOPBACK_PHY, 1910 .fn = stmmac_test_svlanoff, 1911 }, { 1912 .name = "L3 DA Filtering ", 1913 .lb = STMMAC_LOOPBACK_PHY, 1914 .fn = stmmac_test_l3filt_da, 1915 }, { 1916 .name = "L3 SA Filtering ", 1917 .lb = STMMAC_LOOPBACK_PHY, 1918 .fn = stmmac_test_l3filt_sa, 1919 }, { 1920 .name = "L4 DA TCP Filtering ", 1921 .lb = STMMAC_LOOPBACK_PHY, 1922 .fn = stmmac_test_l4filt_da_tcp, 1923 }, { 1924 .name = "L4 SA TCP Filtering ", 1925 .lb = STMMAC_LOOPBACK_PHY, 1926 .fn = stmmac_test_l4filt_sa_tcp, 1927 }, { 1928 .name = "L4 DA UDP Filtering ", 1929 .lb = STMMAC_LOOPBACK_PHY, 1930 .fn = stmmac_test_l4filt_da_udp, 1931 }, { 1932 .name = "L4 SA UDP Filtering ", 1933 .lb = STMMAC_LOOPBACK_PHY, 1934 .fn = stmmac_test_l4filt_sa_udp, 1935 }, { 1936 .name = "ARP Offload ", 1937 .lb = STMMAC_LOOPBACK_PHY, 1938 .fn = stmmac_test_arpoffload, 1939 }, { 1940 .name = "Jumbo Frame ", 1941 .lb = STMMAC_LOOPBACK_PHY, 1942 .fn = stmmac_test_jumbo, 1943 }, { 1944 .name = "Multichannel Jumbo ", 1945 .lb = STMMAC_LOOPBACK_PHY, 1946 .fn = stmmac_test_mjumbo, 1947 }, { 1948 .name = "Split Header ", 1949 .lb = STMMAC_LOOPBACK_PHY, 1950 .fn = stmmac_test_sph, 1951 }, { 1952 .name = "TBS (ETF Scheduler) ", 1953 .lb = STMMAC_LOOPBACK_PHY, 1954 .fn = stmmac_test_tbs, 1955 }, 1956 }; 1957 1958 void stmmac_selftest_run(struct net_device *dev, 1959 struct ethtool_test *etest, u64 *buf) 1960 { 1961 struct stmmac_priv *priv = netdev_priv(dev); 1962 int count = stmmac_selftest_get_count(priv); 1963 int i, ret; 1964 1965 memset(buf, 0, sizeof(*buf) * count); 1966 stmmac_test_next_id = 0; 1967 1968 if (etest->flags != ETH_TEST_FL_OFFLINE) { 1969 netdev_err(priv->dev, "Only offline tests are supported\n"); 1970 etest->flags |= ETH_TEST_FL_FAILED; 1971 return; 1972 } else if (!netif_carrier_ok(dev)) { 1973 netdev_err(priv->dev, "You need valid Link to execute tests\n"); 1974 etest->flags |= ETH_TEST_FL_FAILED; 1975 return; 1976 } 1977 1978 /* Wait for queues drain */ 1979 msleep(200); 1980 1981 for (i = 0; i < count; i++) { 1982 ret = 0; 1983 1984 switch (stmmac_selftests[i].lb) { 1985 case STMMAC_LOOPBACK_PHY: 1986 ret = -EOPNOTSUPP; 1987 if (dev->phydev) 1988 ret = phy_loopback(dev->phydev, true); 1989 if (!ret) 1990 break; 1991 fallthrough; 1992 case STMMAC_LOOPBACK_MAC: 1993 ret = stmmac_set_mac_loopback(priv, priv->ioaddr, true); 1994 break; 1995 case STMMAC_LOOPBACK_NONE: 1996 break; 1997 default: 1998 ret = -EOPNOTSUPP; 1999 break; 2000 } 2001 2002 /* 2003 * First tests will always be MAC / PHY loobpack. If any of 2004 * them is not supported we abort earlier. 2005 */ 2006 if (ret) { 2007 netdev_err(priv->dev, "Loopback is not supported\n"); 2008 etest->flags |= ETH_TEST_FL_FAILED; 2009 break; 2010 } 2011 2012 ret = stmmac_selftests[i].fn(priv); 2013 if (ret && (ret != -EOPNOTSUPP)) 2014 etest->flags |= ETH_TEST_FL_FAILED; 2015 buf[i] = ret; 2016 2017 switch (stmmac_selftests[i].lb) { 2018 case STMMAC_LOOPBACK_PHY: 2019 ret = -EOPNOTSUPP; 2020 if (dev->phydev) 2021 ret = phy_loopback(dev->phydev, false); 2022 if (!ret) 2023 break; 2024 fallthrough; 2025 case STMMAC_LOOPBACK_MAC: 2026 stmmac_set_mac_loopback(priv, priv->ioaddr, false); 2027 break; 2028 default: 2029 break; 2030 } 2031 } 2032 } 2033 2034 void stmmac_selftest_get_strings(struct stmmac_priv *priv, u8 *data) 2035 { 2036 u8 *p = data; 2037 int i; 2038 2039 for (i = 0; i < stmmac_selftest_get_count(priv); i++) { 2040 snprintf(p, ETH_GSTRING_LEN, "%2d. %s", i + 1, 2041 stmmac_selftests[i].name); 2042 p += ETH_GSTRING_LEN; 2043 } 2044 } 2045 2046 int stmmac_selftest_get_count(struct stmmac_priv *priv) 2047 { 2048 return ARRAY_SIZE(stmmac_selftests); 2049 } 2050