Merge branch 's390-qeth-updates-2020-11-17'

+15 -7

drivers/s390/net/qeth_core.h

··· 701 701 QETH_PNSO_ADDR_INFO, 702 702 }; 703 703 704 + enum qeth_link_mode { 705 + QETH_LINK_MODE_UNKNOWN, 706 + QETH_LINK_MODE_FIBRE_SHORT, 707 + QETH_LINK_MODE_FIBRE_LONG, 708 + }; 709 + 710 + struct qeth_link_info { 711 + u32 speed; 712 + u8 duplex; 713 + u8 port; 714 + enum qeth_link_mode link_mode; 715 + }; 716 + 704 717 #define QETH_BROADCAST_WITH_ECHO 0x01 705 718 #define QETH_BROADCAST_WITHOUT_ECHO 0x02 706 719 struct qeth_card_info { ··· 745 732 struct qeth_card_blkt blkt; 746 733 __u32 diagass_support; 747 734 __u32 hwtrap; 735 + struct qeth_link_info link_info; 748 736 }; 749 737 750 738 enum qeth_discipline_id { ··· 808 794 int e_offset; 809 795 int qdio_err; 810 796 u8 bufs_refill; 811 - }; 812 - 813 - struct carrier_info { 814 - __u8 card_type; 815 - __u16 port_mode; 816 - __u32 port_speed; 817 797 }; 818 798 819 799 struct qeth_switch_info { ··· 1116 1108 int qeth_query_switch_attributes(struct qeth_card *card, 1117 1109 struct qeth_switch_info *sw_info); 1118 1110 int qeth_query_card_info(struct qeth_card *card, 1119 - struct carrier_info *carrier_info); 1111 + struct qeth_link_info *link_info); 1120 1112 int qeth_setadpparms_set_access_ctrl(struct qeth_card *card, 1121 1113 enum qeth_ipa_isolation_modes mode); 1122 1114

+216 -7

drivers/s390/net/qeth_core_main.c

··· 4868 4868 static int qeth_query_card_info_cb(struct qeth_card *card, 4869 4869 struct qeth_reply *reply, unsigned long data) 4870 4870 { 4871 - struct carrier_info *carrier_info = (struct carrier_info *)reply->param; 4872 4871 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *)data; 4872 + struct qeth_link_info *link_info = reply->param; 4873 4873 struct qeth_query_card_info *card_info; 4874 4874 4875 4875 QETH_CARD_TEXT(card, 2, "qcrdincb"); ··· 4877 4877 return -EIO; 4878 4878 4879 4879 card_info = &cmd->data.setadapterparms.data.card_info; 4880 - carrier_info->card_type = card_info->card_type; 4881 - carrier_info->port_mode = card_info->port_mode; 4882 - carrier_info->port_speed = card_info->port_speed; 4880 + netdev_dbg(card->dev, 4881 + "card info: card_type=0x%02x, port_mode=0x%04x, port_speed=0x%08x\n", 4882 + card_info->card_type, card_info->port_mode, 4883 + card_info->port_speed); 4884 + 4885 + switch (card_info->port_mode) { 4886 + case CARD_INFO_PORTM_FULLDUPLEX: 4887 + link_info->duplex = DUPLEX_FULL; 4888 + break; 4889 + case CARD_INFO_PORTM_HALFDUPLEX: 4890 + link_info->duplex = DUPLEX_HALF; 4891 + break; 4892 + default: 4893 + link_info->duplex = DUPLEX_UNKNOWN; 4894 + } 4895 + 4896 + switch (card_info->card_type) { 4897 + case CARD_INFO_TYPE_1G_COPPER_A: 4898 + case CARD_INFO_TYPE_1G_COPPER_B: 4899 + link_info->speed = SPEED_1000; 4900 + link_info->port = PORT_TP; 4901 + break; 4902 + case CARD_INFO_TYPE_1G_FIBRE_A: 4903 + case CARD_INFO_TYPE_1G_FIBRE_B: 4904 + link_info->speed = SPEED_1000; 4905 + link_info->port = PORT_FIBRE; 4906 + break; 4907 + case CARD_INFO_TYPE_10G_FIBRE_A: 4908 + case CARD_INFO_TYPE_10G_FIBRE_B: 4909 + link_info->speed = SPEED_10000; 4910 + link_info->port = PORT_FIBRE; 4911 + break; 4912 + default: 4913 + switch (card_info->port_speed) { 4914 + case CARD_INFO_PORTS_10M: 4915 + link_info->speed = SPEED_10; 4916 + break; 4917 + case CARD_INFO_PORTS_100M: 4918 + link_info->speed = SPEED_100; 4919 + break; 4920 + case CARD_INFO_PORTS_1G: 4921 + link_info->speed = SPEED_1000; 4922 + break; 4923 + case CARD_INFO_PORTS_10G: 4924 + link_info->speed = SPEED_10000; 4925 + break; 4926 + case CARD_INFO_PORTS_25G: 4927 + link_info->speed = SPEED_25000; 4928 + break; 4929 + default: 4930 + link_info->speed = SPEED_UNKNOWN; 4931 + } 4932 + 4933 + link_info->port = PORT_OTHER; 4934 + } 4935 + 4883 4936 return 0; 4884 4937 } 4885 4938 4886 4939 int qeth_query_card_info(struct qeth_card *card, 4887 - struct carrier_info *carrier_info) 4940 + struct qeth_link_info *link_info) 4888 4941 { 4889 4942 struct qeth_cmd_buffer *iob; 4890 4943 ··· 4947 4894 iob = qeth_get_adapter_cmd(card, IPA_SETADP_QUERY_CARD_INFO, 0); 4948 4895 if (!iob) 4949 4896 return -ENOMEM; 4950 - return qeth_send_ipa_cmd(card, iob, qeth_query_card_info_cb, 4951 - (void *)carrier_info); 4897 + 4898 + return qeth_send_ipa_cmd(card, iob, qeth_query_card_info_cb, link_info); 4899 + } 4900 + 4901 + static int qeth_init_link_info_oat_cb(struct qeth_card *card, 4902 + struct qeth_reply *reply_priv, 4903 + unsigned long data) 4904 + { 4905 + struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *)data; 4906 + struct qeth_link_info *link_info = reply_priv->param; 4907 + struct qeth_query_oat_physical_if *phys_if; 4908 + struct qeth_query_oat_reply *reply; 4909 + 4910 + if (qeth_setadpparms_inspect_rc(cmd)) 4911 + return -EIO; 4912 + 4913 + /* Multi-part reply is unexpected, don't bother: */ 4914 + if (cmd->data.setadapterparms.hdr.used_total > 1) 4915 + return -EINVAL; 4916 + 4917 + /* Expect the reply to start with phys_if data: */ 4918 + reply = &cmd->data.setadapterparms.data.query_oat.reply[0]; 4919 + if (reply->type != QETH_QOAT_REPLY_TYPE_PHYS_IF || 4920 + reply->length < sizeof(*reply)) 4921 + return -EINVAL; 4922 + 4923 + phys_if = &reply->phys_if; 4924 + 4925 + switch (phys_if->speed_duplex) { 4926 + case QETH_QOAT_PHYS_SPEED_10M_HALF: 4927 + link_info->speed = SPEED_10; 4928 + link_info->duplex = DUPLEX_HALF; 4929 + break; 4930 + case QETH_QOAT_PHYS_SPEED_10M_FULL: 4931 + link_info->speed = SPEED_10; 4932 + link_info->duplex = DUPLEX_FULL; 4933 + break; 4934 + case QETH_QOAT_PHYS_SPEED_100M_HALF: 4935 + link_info->speed = SPEED_100; 4936 + link_info->duplex = DUPLEX_HALF; 4937 + break; 4938 + case QETH_QOAT_PHYS_SPEED_100M_FULL: 4939 + link_info->speed = SPEED_100; 4940 + link_info->duplex = DUPLEX_FULL; 4941 + break; 4942 + case QETH_QOAT_PHYS_SPEED_1000M_HALF: 4943 + link_info->speed = SPEED_1000; 4944 + link_info->duplex = DUPLEX_HALF; 4945 + break; 4946 + case QETH_QOAT_PHYS_SPEED_1000M_FULL: 4947 + link_info->speed = SPEED_1000; 4948 + link_info->duplex = DUPLEX_FULL; 4949 + break; 4950 + case QETH_QOAT_PHYS_SPEED_10G_FULL: 4951 + link_info->speed = SPEED_10000; 4952 + link_info->duplex = DUPLEX_FULL; 4953 + break; 4954 + case QETH_QOAT_PHYS_SPEED_25G_FULL: 4955 + link_info->speed = SPEED_25000; 4956 + link_info->duplex = DUPLEX_FULL; 4957 + break; 4958 + case QETH_QOAT_PHYS_SPEED_UNKNOWN: 4959 + default: 4960 + link_info->speed = SPEED_UNKNOWN; 4961 + link_info->duplex = DUPLEX_UNKNOWN; 4962 + break; 4963 + } 4964 + 4965 + switch (phys_if->media_type) { 4966 + case QETH_QOAT_PHYS_MEDIA_COPPER: 4967 + link_info->port = PORT_TP; 4968 + link_info->link_mode = QETH_LINK_MODE_UNKNOWN; 4969 + break; 4970 + case QETH_QOAT_PHYS_MEDIA_FIBRE_SHORT: 4971 + link_info->port = PORT_FIBRE; 4972 + link_info->link_mode = QETH_LINK_MODE_FIBRE_SHORT; 4973 + break; 4974 + case QETH_QOAT_PHYS_MEDIA_FIBRE_LONG: 4975 + link_info->port = PORT_FIBRE; 4976 + link_info->link_mode = QETH_LINK_MODE_FIBRE_LONG; 4977 + break; 4978 + default: 4979 + link_info->port = PORT_OTHER; 4980 + link_info->link_mode = QETH_LINK_MODE_UNKNOWN; 4981 + break; 4982 + } 4983 + 4984 + return 0; 4985 + } 4986 + 4987 + static void qeth_init_link_info(struct qeth_card *card) 4988 + { 4989 + card->info.link_info.duplex = DUPLEX_FULL; 4990 + 4991 + if (IS_IQD(card) || IS_VM_NIC(card)) { 4992 + card->info.link_info.speed = SPEED_10000; 4993 + card->info.link_info.port = PORT_FIBRE; 4994 + card->info.link_info.link_mode = QETH_LINK_MODE_FIBRE_SHORT; 4995 + } else { 4996 + switch (card->info.link_type) { 4997 + case QETH_LINK_TYPE_FAST_ETH: 4998 + case QETH_LINK_TYPE_LANE_ETH100: 4999 + card->info.link_info.speed = SPEED_100; 5000 + card->info.link_info.port = PORT_TP; 5001 + break; 5002 + case QETH_LINK_TYPE_GBIT_ETH: 5003 + case QETH_LINK_TYPE_LANE_ETH1000: 5004 + card->info.link_info.speed = SPEED_1000; 5005 + card->info.link_info.port = PORT_FIBRE; 5006 + break; 5007 + case QETH_LINK_TYPE_10GBIT_ETH: 5008 + card->info.link_info.speed = SPEED_10000; 5009 + card->info.link_info.port = PORT_FIBRE; 5010 + break; 5011 + case QETH_LINK_TYPE_25GBIT_ETH: 5012 + card->info.link_info.speed = SPEED_25000; 5013 + card->info.link_info.port = PORT_FIBRE; 5014 + break; 5015 + default: 5016 + dev_info(&card->gdev->dev, "Unknown link type %x\n", 5017 + card->info.link_type); 5018 + card->info.link_info.speed = SPEED_UNKNOWN; 5019 + card->info.link_info.port = PORT_OTHER; 5020 + } 5021 + 5022 + card->info.link_info.link_mode = QETH_LINK_MODE_UNKNOWN; 5023 + } 5024 + 5025 + /* Get more accurate data via QUERY OAT: */ 5026 + if (qeth_adp_supported(card, IPA_SETADP_QUERY_OAT)) { 5027 + struct qeth_link_info link_info; 5028 + struct qeth_cmd_buffer *iob; 5029 + 5030 + iob = qeth_get_adapter_cmd(card, IPA_SETADP_QUERY_OAT, 5031 + SETADP_DATA_SIZEOF(query_oat)); 5032 + if (iob) { 5033 + struct qeth_ipa_cmd *cmd = __ipa_cmd(iob); 5034 + struct qeth_query_oat *oat_req; 5035 + 5036 + oat_req = &cmd->data.setadapterparms.data.query_oat; 5037 + oat_req->subcmd_code = QETH_QOAT_SCOPE_INTERFACE; 5038 + 5039 + if (!qeth_send_ipa_cmd(card, iob, 5040 + qeth_init_link_info_oat_cb, 5041 + &link_info)) { 5042 + if (link_info.speed != SPEED_UNKNOWN) 5043 + card->info.link_info.speed = link_info.speed; 5044 + if (link_info.duplex != DUPLEX_UNKNOWN) 5045 + card->info.link_info.duplex = link_info.duplex; 5046 + if (link_info.port != PORT_OTHER) 5047 + card->info.link_info.port = link_info.port; 5048 + if (link_info.link_mode != QETH_LINK_MODE_UNKNOWN) 5049 + card->info.link_info.link_mode = link_info.link_mode; 5050 + } 5051 + } 5052 + } 4952 5053 } 4953 5054 4954 5055 /** ··· 5488 5281 if (rc) 5489 5282 goto out; 5490 5283 } 5284 + 5285 + qeth_init_link_info(card); 5491 5286 5492 5287 rc = qeth_init_qdio_queues(card); 5493 5288 if (rc) {

+38 -2

drivers/s390/net/qeth_core_mpc.h

··· 489 489 __u8 reserved[8]; 490 490 } __attribute__((packed)); 491 491 492 + #define QETH_QOAT_PHYS_SPEED_UNKNOWN 0x00 493 + #define QETH_QOAT_PHYS_SPEED_10M_HALF 0x01 494 + #define QETH_QOAT_PHYS_SPEED_10M_FULL 0x02 495 + #define QETH_QOAT_PHYS_SPEED_100M_HALF 0x03 496 + #define QETH_QOAT_PHYS_SPEED_100M_FULL 0x04 497 + #define QETH_QOAT_PHYS_SPEED_1000M_HALF 0x05 498 + #define QETH_QOAT_PHYS_SPEED_1000M_FULL 0x06 499 + // n/a 0x07 500 + #define QETH_QOAT_PHYS_SPEED_10G_FULL 0x08 501 + // n/a 0x09 502 + #define QETH_QOAT_PHYS_SPEED_25G_FULL 0x0A 503 + 504 + #define QETH_QOAT_PHYS_MEDIA_COPPER 0x01 505 + #define QETH_QOAT_PHYS_MEDIA_FIBRE_SHORT 0x02 506 + #define QETH_QOAT_PHYS_MEDIA_FIBRE_LONG 0x04 507 + 508 + struct qeth_query_oat_physical_if { 509 + u8 res_head[33]; 510 + u8 speed_duplex; 511 + u8 media_type; 512 + u8 res_tail[29]; 513 + }; 514 + 515 + #define QETH_QOAT_REPLY_TYPE_PHYS_IF 0x0004 516 + 517 + struct qeth_query_oat_reply { 518 + u16 type; 519 + u16 length; 520 + u16 version; 521 + u8 res[10]; 522 + struct qeth_query_oat_physical_if phys_if; 523 + }; 524 + 525 + #define QETH_QOAT_SCOPE_INTERFACE 0x00000001 526 + 492 527 struct qeth_query_oat { 493 - __u32 subcmd_code; 494 - __u8 reserved[12]; 528 + u32 subcmd_code; 529 + u8 reserved[12]; 530 + struct qeth_query_oat_reply reply[]; 495 531 } __packed; 496 532 497 533 struct qeth_qoat_priv {

+88 -155

drivers/s390/net/qeth_ethtool.c

··· 324 324 /* Autoneg and full-duplex are supported and advertised unconditionally. */ 325 325 /* Always advertise and support all speeds up to specified, and only one */ 326 326 /* specified port type. */ 327 - static void qeth_set_cmd_adv_sup(struct ethtool_link_ksettings *cmd, 328 - int maxspeed, int porttype) 327 + static void qeth_set_ethtool_link_modes(struct ethtool_link_ksettings *cmd, 328 + enum qeth_link_mode link_mode) 329 329 { 330 330 ethtool_link_ksettings_zero_link_mode(cmd, supported); 331 331 ethtool_link_ksettings_zero_link_mode(cmd, advertising); ··· 334 334 ethtool_link_ksettings_add_link_mode(cmd, supported, Autoneg); 335 335 ethtool_link_ksettings_add_link_mode(cmd, advertising, Autoneg); 336 336 337 - switch (porttype) { 337 + switch (cmd->base.port) { 338 338 case PORT_TP: 339 339 ethtool_link_ksettings_add_link_mode(cmd, supported, TP); 340 340 ethtool_link_ksettings_add_link_mode(cmd, advertising, TP); 341 + 342 + switch (cmd->base.speed) { 343 + case SPEED_10000: 344 + ethtool_link_ksettings_add_link_mode(cmd, supported, 345 + 10000baseT_Full); 346 + ethtool_link_ksettings_add_link_mode(cmd, advertising, 347 + 10000baseT_Full); 348 + fallthrough; 349 + case SPEED_1000: 350 + ethtool_link_ksettings_add_link_mode(cmd, supported, 351 + 1000baseT_Full); 352 + ethtool_link_ksettings_add_link_mode(cmd, advertising, 353 + 1000baseT_Full); 354 + ethtool_link_ksettings_add_link_mode(cmd, supported, 355 + 1000baseT_Half); 356 + ethtool_link_ksettings_add_link_mode(cmd, advertising, 357 + 1000baseT_Half); 358 + fallthrough; 359 + case SPEED_100: 360 + ethtool_link_ksettings_add_link_mode(cmd, supported, 361 + 100baseT_Full); 362 + ethtool_link_ksettings_add_link_mode(cmd, advertising, 363 + 100baseT_Full); 364 + ethtool_link_ksettings_add_link_mode(cmd, supported, 365 + 100baseT_Half); 366 + ethtool_link_ksettings_add_link_mode(cmd, advertising, 367 + 100baseT_Half); 368 + fallthrough; 369 + case SPEED_10: 370 + ethtool_link_ksettings_add_link_mode(cmd, supported, 371 + 10baseT_Full); 372 + ethtool_link_ksettings_add_link_mode(cmd, advertising, 373 + 10baseT_Full); 374 + ethtool_link_ksettings_add_link_mode(cmd, supported, 375 + 10baseT_Half); 376 + ethtool_link_ksettings_add_link_mode(cmd, advertising, 377 + 10baseT_Half); 378 + break; 379 + default: 380 + break; 381 + } 382 + 341 383 break; 342 384 case PORT_FIBRE: 343 385 ethtool_link_ksettings_add_link_mode(cmd, supported, FIBRE); 344 386 ethtool_link_ksettings_add_link_mode(cmd, advertising, FIBRE); 345 - break; 346 - default: 347 - ethtool_link_ksettings_add_link_mode(cmd, supported, TP); 348 - ethtool_link_ksettings_add_link_mode(cmd, advertising, TP); 349 - WARN_ON_ONCE(1); 350 - } 351 387 352 - /* partially does fall through, to also select lower speeds */ 353 - switch (maxspeed) { 354 - case SPEED_25000: 355 - ethtool_link_ksettings_add_link_mode(cmd, supported, 356 - 25000baseSR_Full); 357 - ethtool_link_ksettings_add_link_mode(cmd, advertising, 358 - 25000baseSR_Full); 359 - break; 360 - case SPEED_10000: 361 - ethtool_link_ksettings_add_link_mode(cmd, supported, 362 - 10000baseT_Full); 363 - ethtool_link_ksettings_add_link_mode(cmd, advertising, 364 - 10000baseT_Full); 365 - fallthrough; 366 - case SPEED_1000: 367 - ethtool_link_ksettings_add_link_mode(cmd, supported, 368 - 1000baseT_Full); 369 - ethtool_link_ksettings_add_link_mode(cmd, advertising, 370 - 1000baseT_Full); 371 - ethtool_link_ksettings_add_link_mode(cmd, supported, 372 - 1000baseT_Half); 373 - ethtool_link_ksettings_add_link_mode(cmd, advertising, 374 - 1000baseT_Half); 375 - fallthrough; 376 - case SPEED_100: 377 - ethtool_link_ksettings_add_link_mode(cmd, supported, 378 - 100baseT_Full); 379 - ethtool_link_ksettings_add_link_mode(cmd, advertising, 380 - 100baseT_Full); 381 - ethtool_link_ksettings_add_link_mode(cmd, supported, 382 - 100baseT_Half); 383 - ethtool_link_ksettings_add_link_mode(cmd, advertising, 384 - 100baseT_Half); 385 - fallthrough; 386 - case SPEED_10: 387 - ethtool_link_ksettings_add_link_mode(cmd, supported, 388 - 10baseT_Full); 389 - ethtool_link_ksettings_add_link_mode(cmd, advertising, 390 - 10baseT_Full); 391 - ethtool_link_ksettings_add_link_mode(cmd, supported, 392 - 10baseT_Half); 393 - ethtool_link_ksettings_add_link_mode(cmd, advertising, 394 - 10baseT_Half); 388 + switch (cmd->base.speed) { 389 + case SPEED_25000: 390 + ethtool_link_ksettings_add_link_mode(cmd, supported, 391 + 25000baseSR_Full); 392 + ethtool_link_ksettings_add_link_mode(cmd, advertising, 393 + 25000baseSR_Full); 394 + break; 395 + case SPEED_10000: 396 + if (link_mode == QETH_LINK_MODE_FIBRE_LONG) { 397 + ethtool_link_ksettings_add_link_mode(cmd, supported, 398 + 10000baseLR_Full); 399 + ethtool_link_ksettings_add_link_mode(cmd, advertising, 400 + 10000baseLR_Full); 401 + } else if (link_mode == QETH_LINK_MODE_FIBRE_SHORT) { 402 + ethtool_link_ksettings_add_link_mode(cmd, supported, 403 + 10000baseSR_Full); 404 + ethtool_link_ksettings_add_link_mode(cmd, advertising, 405 + 10000baseSR_Full); 406 + } 407 + break; 408 + case SPEED_1000: 409 + ethtool_link_ksettings_add_link_mode(cmd, supported, 410 + 1000baseX_Full); 411 + ethtool_link_ksettings_add_link_mode(cmd, advertising, 412 + 1000baseX_Full); 413 + break; 414 + default: 415 + break; 416 + } 417 + 395 418 break; 396 419 default: 397 - ethtool_link_ksettings_add_link_mode(cmd, supported, 398 - 10baseT_Full); 399 - ethtool_link_ksettings_add_link_mode(cmd, advertising, 400 - 10baseT_Full); 401 - ethtool_link_ksettings_add_link_mode(cmd, supported, 402 - 10baseT_Half); 403 - ethtool_link_ksettings_add_link_mode(cmd, advertising, 404 - 10baseT_Half); 405 - WARN_ON_ONCE(1); 420 + break; 406 421 } 407 422 } 408 - 409 423 410 424 static int qeth_get_link_ksettings(struct net_device *netdev, 411 425 struct ethtool_link_ksettings *cmd) 412 426 { 413 427 struct qeth_card *card = netdev->ml_priv; 414 - enum qeth_link_types link_type; 415 - struct carrier_info carrier_info; 416 - int rc; 428 + struct qeth_link_info link_info; 417 429 418 - if (IS_IQD(card) || IS_VM_NIC(card)) 419 - link_type = QETH_LINK_TYPE_10GBIT_ETH; 420 - else 421 - link_type = card->info.link_type; 422 - 423 - cmd->base.duplex = DUPLEX_FULL; 430 + cmd->base.speed = card->info.link_info.speed; 431 + cmd->base.duplex = card->info.link_info.duplex; 432 + cmd->base.port = card->info.link_info.port; 424 433 cmd->base.autoneg = AUTONEG_ENABLE; 425 434 cmd->base.phy_address = 0; 426 435 cmd->base.mdio_support = 0; 427 436 cmd->base.eth_tp_mdix = ETH_TP_MDI_INVALID; 428 437 cmd->base.eth_tp_mdix_ctrl = ETH_TP_MDI_INVALID; 429 438 430 - switch (link_type) { 431 - case QETH_LINK_TYPE_FAST_ETH: 432 - case QETH_LINK_TYPE_LANE_ETH100: 433 - cmd->base.speed = SPEED_100; 434 - cmd->base.port = PORT_TP; 435 - break; 436 - case QETH_LINK_TYPE_GBIT_ETH: 437 - case QETH_LINK_TYPE_LANE_ETH1000: 438 - cmd->base.speed = SPEED_1000; 439 - cmd->base.port = PORT_FIBRE; 440 - break; 441 - case QETH_LINK_TYPE_10GBIT_ETH: 442 - cmd->base.speed = SPEED_10000; 443 - cmd->base.port = PORT_FIBRE; 444 - break; 445 - case QETH_LINK_TYPE_25GBIT_ETH: 446 - cmd->base.speed = SPEED_25000; 447 - cmd->base.port = PORT_FIBRE; 448 - break; 449 - default: 450 - cmd->base.speed = SPEED_10; 451 - cmd->base.port = PORT_TP; 452 - } 453 - qeth_set_cmd_adv_sup(cmd, cmd->base.speed, cmd->base.port); 454 - 455 439 /* Check if we can obtain more accurate information. */ 456 - /* If QUERY_CARD_INFO command is not supported or fails, */ 457 - /* just return the heuristics that was filled above. */ 458 - rc = qeth_query_card_info(card, &carrier_info); 459 - if (rc == -EOPNOTSUPP) /* for old hardware, return heuristic */ 460 - return 0; 461 - if (rc) /* report error from the hardware operation */ 462 - return rc; 463 - /* on success, fill in the information got from the hardware */ 464 - 465 - netdev_dbg(netdev, 466 - "card info: card_type=0x%02x, port_mode=0x%04x, port_speed=0x%08x\n", 467 - carrier_info.card_type, 468 - carrier_info.port_mode, 469 - carrier_info.port_speed); 470 - 471 - /* Update attributes for which we've obtained more authoritative */ 472 - /* information, leave the rest the way they where filled above. */ 473 - switch (carrier_info.card_type) { 474 - case CARD_INFO_TYPE_1G_COPPER_A: 475 - case CARD_INFO_TYPE_1G_COPPER_B: 476 - cmd->base.port = PORT_TP; 477 - qeth_set_cmd_adv_sup(cmd, SPEED_1000, cmd->base.port); 478 - break; 479 - case CARD_INFO_TYPE_1G_FIBRE_A: 480 - case CARD_INFO_TYPE_1G_FIBRE_B: 481 - cmd->base.port = PORT_FIBRE; 482 - qeth_set_cmd_adv_sup(cmd, SPEED_1000, cmd->base.port); 483 - break; 484 - case CARD_INFO_TYPE_10G_FIBRE_A: 485 - case CARD_INFO_TYPE_10G_FIBRE_B: 486 - cmd->base.port = PORT_FIBRE; 487 - qeth_set_cmd_adv_sup(cmd, SPEED_10000, cmd->base.port); 488 - break; 440 + if (!qeth_query_card_info(card, &link_info)) { 441 + if (link_info.speed != SPEED_UNKNOWN) 442 + cmd->base.speed = link_info.speed; 443 + if (link_info.duplex != DUPLEX_UNKNOWN) 444 + cmd->base.duplex = link_info.duplex; 445 + if (link_info.port != PORT_OTHER) 446 + cmd->base.port = link_info.port; 489 447 } 490 448 491 - switch (carrier_info.port_mode) { 492 - case CARD_INFO_PORTM_FULLDUPLEX: 493 - cmd->base.duplex = DUPLEX_FULL; 494 - break; 495 - case CARD_INFO_PORTM_HALFDUPLEX: 496 - cmd->base.duplex = DUPLEX_HALF; 497 - break; 498 - } 499 - 500 - switch (carrier_info.port_speed) { 501 - case CARD_INFO_PORTS_10M: 502 - cmd->base.speed = SPEED_10; 503 - break; 504 - case CARD_INFO_PORTS_100M: 505 - cmd->base.speed = SPEED_100; 506 - break; 507 - case CARD_INFO_PORTS_1G: 508 - cmd->base.speed = SPEED_1000; 509 - break; 510 - case CARD_INFO_PORTS_10G: 511 - cmd->base.speed = SPEED_10000; 512 - break; 513 - case CARD_INFO_PORTS_25G: 514 - cmd->base.speed = SPEED_25000; 515 - break; 516 - } 449 + qeth_set_ethtool_link_modes(cmd, card->info.link_info.link_mode); 517 450 518 451 return 0; 519 452 }

+15 -18

drivers/s390/net/qeth_l2_main.c

··· 737 737 * 738 738 * On enable, emits a series of address notifications for all 739 739 * currently registered hosts. 740 - * 741 - * Must be called under rtnl_lock 742 740 */ 743 741 static int qeth_l2_dev2br_an_set(struct qeth_card *card, bool enable) 744 742 { ··· 1287 1289 if (READ_ONCE(card->info.pnso_mode) == QETH_PNSO_NONE) 1288 1290 goto free; 1289 1291 1290 - /* Potential re-config in progress, try again later: */ 1291 - if (!rtnl_trylock()) { 1292 - queue_delayed_work(card->event_wq, dwork, 1293 - msecs_to_jiffies(100)); 1294 - return; 1295 - } 1296 - if (!netif_device_present(card->dev)) 1297 - goto out_unlock; 1298 - 1299 1292 if (data->ac_event.lost_event_mask) { 1293 + /* Potential re-config in progress, try again later: */ 1294 + if (!rtnl_trylock()) { 1295 + queue_delayed_work(card->event_wq, dwork, 1296 + msecs_to_jiffies(100)); 1297 + return; 1298 + } 1299 + 1300 + if (!netif_device_present(card->dev)) { 1301 + rtnl_unlock(); 1302 + goto free; 1303 + } 1304 + 1300 1305 QETH_DBF_MESSAGE(3, 1301 1306 "Address change notification overflow on device %x\n", 1302 1307 CARD_DEVID(card)); ··· 1329 1328 "Address Notification resynced on device %x\n", 1330 1329 CARD_DEVID(card)); 1331 1330 } 1331 + 1332 + rtnl_unlock(); 1332 1333 } else { 1333 1334 for (i = 0; i < data->ac_event.num_entries; i++) { 1334 1335 struct qeth_ipacmd_addr_change_entry *entry = ··· 1341 1338 &entry->addr_lnid); 1342 1339 } 1343 1340 } 1344 - 1345 - out_unlock: 1346 - rtnl_unlock(); 1347 1341 1348 1342 free: 1349 1343 kfree(data); ··· 2310 2310 card->state = CARD_STATE_DOWN; 2311 2311 2312 2312 qeth_l2_set_pnso_mode(card, QETH_PNSO_NONE); 2313 - if (priv->brport_features & BR_LEARNING_SYNC) { 2314 - rtnl_lock(); 2313 + if (priv->brport_features & BR_LEARNING_SYNC) 2315 2314 qeth_l2_dev2br_fdb_flush(card); 2316 - rtnl_unlock(); 2317 - } 2318 2315 } 2319 2316 2320 2317 /* Returns zero if the command is successfully "consumed" */

+1 -4

drivers/s390/net/qeth_l3_main.c

··· 104 104 qeth_l3_convert_addr_to_bits(ipatoe->addr, ipatoe_bits, 105 105 (ipatoe->proto == QETH_PROT_IPV4) ? 106 106 4 : 16); 107 - if (addr->proto == QETH_PROT_IPV4) 108 - rc = !memcmp(addr_bits, ipatoe_bits, ipatoe->mask_bits); 109 - else 110 - rc = !memcmp(addr_bits, ipatoe_bits, ipatoe->mask_bits); 107 + rc = !memcmp(addr_bits, ipatoe_bits, ipatoe->mask_bits); 111 108 if (rc) 112 109 break; 113 110 }

Configure Feed

Configure Feed