1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright IBM Corp. 2007, 2009 4 * Author(s): Utz Bacher <utz.bacher@de.ibm.com>, 5 * Frank Pavlic <fpavlic@de.ibm.com>, 6 * Thomas Spatzier <tspat@de.ibm.com>, 7 * Frank Blaschka <frank.blaschka@de.ibm.com> 8 */ 9 10 #define KMSG_COMPONENT "qeth" 11 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 12 13 #include <linux/module.h> 14 #include <linux/moduleparam.h> 15 #include <linux/string.h> 16 #include <linux/errno.h> 17 #include <linux/kernel.h> 18 #include <linux/slab.h> 19 #include <linux/etherdevice.h> 20 #include <linux/if_bridge.h> 21 #include <linux/list.h> 22 #include <linux/hash.h> 23 #include <linux/hashtable.h> 24 #include <net/switchdev.h> 25 #include <asm/chsc.h> 26 #include <asm/css_chars.h> 27 #include <asm/setup.h> 28 #include "qeth_core.h" 29 #include "qeth_l2.h" 30 31 static int qeth_l2_setdelmac_makerc(struct qeth_card *card, u16 retcode) 32 { 33 int rc; 34 35 if (retcode) 36 QETH_CARD_TEXT_(card, 2, "err%04x", retcode); 37 switch (retcode) { 38 case IPA_RC_SUCCESS: 39 rc = 0; 40 break; 41 case IPA_RC_L2_UNSUPPORTED_CMD: 42 rc = -EOPNOTSUPP; 43 break; 44 case IPA_RC_L2_ADDR_TABLE_FULL: 45 rc = -ENOSPC; 46 break; 47 case IPA_RC_L2_DUP_MAC: 48 case IPA_RC_L2_DUP_LAYER3_MAC: 49 rc = -EADDRINUSE; 50 break; 51 case IPA_RC_L2_MAC_NOT_AUTH_BY_HYP: 52 case IPA_RC_L2_MAC_NOT_AUTH_BY_ADP: 53 rc = -EADDRNOTAVAIL; 54 break; 55 case IPA_RC_L2_MAC_NOT_FOUND: 56 rc = -ENOENT; 57 break; 58 default: 59 rc = -EIO; 60 break; 61 } 62 return rc; 63 } 64 65 static int qeth_l2_send_setdelmac_cb(struct qeth_card *card, 66 struct qeth_reply *reply, 67 unsigned long data) 68 { 69 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data; 70 71 return qeth_l2_setdelmac_makerc(card, cmd->hdr.return_code); 72 } 73 74 static int qeth_l2_send_setdelmac(struct qeth_card *card, __u8 *mac, 75 enum qeth_ipa_cmds ipacmd) 76 { 77 struct qeth_ipa_cmd *cmd; 78 struct qeth_cmd_buffer *iob; 79 80 QETH_CARD_TEXT(card, 2, "L2sdmac"); 81 iob = qeth_ipa_alloc_cmd(card, ipacmd, QETH_PROT_IPV4, 82 IPA_DATA_SIZEOF(setdelmac)); 83 if (!iob) 84 return -ENOMEM; 85 cmd = __ipa_cmd(iob); 86 cmd->data.setdelmac.mac_length = ETH_ALEN; 87 ether_addr_copy(cmd->data.setdelmac.mac, mac); 88 return qeth_send_ipa_cmd(card, iob, qeth_l2_send_setdelmac_cb, NULL); 89 } 90 91 static int qeth_l2_send_setmac(struct qeth_card *card, __u8 *mac) 92 { 93 int rc; 94 95 QETH_CARD_TEXT(card, 2, "L2Setmac"); 96 rc = qeth_l2_send_setdelmac(card, mac, IPA_CMD_SETVMAC); 97 if (rc == 0) { 98 dev_info(&card->gdev->dev, 99 "MAC address %pM successfully registered\n", mac); 100 } else { 101 switch (rc) { 102 case -EADDRINUSE: 103 dev_warn(&card->gdev->dev, 104 "MAC address %pM already exists\n", mac); 105 break; 106 case -EADDRNOTAVAIL: 107 dev_warn(&card->gdev->dev, 108 "MAC address %pM is not authorized\n", mac); 109 break; 110 } 111 } 112 return rc; 113 } 114 115 static int qeth_l2_write_mac(struct qeth_card *card, u8 *mac) 116 { 117 enum qeth_ipa_cmds cmd = is_multicast_ether_addr(mac) ? 118 IPA_CMD_SETGMAC : IPA_CMD_SETVMAC; 119 int rc; 120 121 QETH_CARD_TEXT(card, 2, "L2Wmac"); 122 rc = qeth_l2_send_setdelmac(card, mac, cmd); 123 if (rc == -EADDRINUSE) 124 QETH_DBF_MESSAGE(2, "MAC already registered on device %x\n", 125 CARD_DEVID(card)); 126 else if (rc) 127 QETH_DBF_MESSAGE(2, "Failed to register MAC on device %x: %d\n", 128 CARD_DEVID(card), rc); 129 return rc; 130 } 131 132 static int qeth_l2_remove_mac(struct qeth_card *card, u8 *mac) 133 { 134 enum qeth_ipa_cmds cmd = is_multicast_ether_addr(mac) ? 135 IPA_CMD_DELGMAC : IPA_CMD_DELVMAC; 136 int rc; 137 138 QETH_CARD_TEXT(card, 2, "L2Rmac"); 139 rc = qeth_l2_send_setdelmac(card, mac, cmd); 140 if (rc) 141 QETH_DBF_MESSAGE(2, "Failed to delete MAC on device %u: %d\n", 142 CARD_DEVID(card), rc); 143 return rc; 144 } 145 146 static void qeth_l2_drain_rx_mode_cache(struct qeth_card *card) 147 { 148 struct qeth_mac *mac; 149 struct hlist_node *tmp; 150 int i; 151 152 hash_for_each_safe(card->rx_mode_addrs, i, tmp, mac, hnode) { 153 hash_del(&mac->hnode); 154 kfree(mac); 155 } 156 } 157 158 static void qeth_l2_fill_header(struct qeth_qdio_out_q *queue, 159 struct qeth_hdr *hdr, struct sk_buff *skb, 160 int ipv, unsigned int data_len) 161 { 162 int cast_type = qeth_get_ether_cast_type(skb); 163 struct vlan_ethhdr *veth = vlan_eth_hdr(skb); 164 165 hdr->hdr.l2.pkt_length = data_len; 166 167 if (skb_is_gso(skb)) { 168 hdr->hdr.l2.id = QETH_HEADER_TYPE_L2_TSO; 169 } else { 170 hdr->hdr.l2.id = QETH_HEADER_TYPE_LAYER2; 171 if (skb->ip_summed == CHECKSUM_PARTIAL) 172 qeth_tx_csum(skb, &hdr->hdr.l2.flags[1], ipv); 173 } 174 175 /* set byte byte 3 to casting flags */ 176 if (cast_type == RTN_MULTICAST) 177 hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_MULTICAST; 178 else if (cast_type == RTN_BROADCAST) 179 hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_BROADCAST; 180 else 181 hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_UNICAST; 182 183 /* VSWITCH relies on the VLAN 184 * information to be present in 185 * the QDIO header */ 186 if (veth->h_vlan_proto == __constant_htons(ETH_P_8021Q)) { 187 hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_VLAN; 188 hdr->hdr.l2.vlan_id = ntohs(veth->h_vlan_TCI); 189 } 190 } 191 192 static int qeth_l2_setdelvlan_makerc(struct qeth_card *card, u16 retcode) 193 { 194 if (retcode) 195 QETH_CARD_TEXT_(card, 2, "err%04x", retcode); 196 197 switch (retcode) { 198 case IPA_RC_SUCCESS: 199 return 0; 200 case IPA_RC_L2_INVALID_VLAN_ID: 201 return -EINVAL; 202 case IPA_RC_L2_DUP_VLAN_ID: 203 return -EEXIST; 204 case IPA_RC_L2_VLAN_ID_NOT_FOUND: 205 return -ENOENT; 206 case IPA_RC_L2_VLAN_ID_NOT_ALLOWED: 207 return -EPERM; 208 default: 209 return -EIO; 210 } 211 } 212 213 static int qeth_l2_send_setdelvlan_cb(struct qeth_card *card, 214 struct qeth_reply *reply, 215 unsigned long data) 216 { 217 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data; 218 219 QETH_CARD_TEXT(card, 2, "L2sdvcb"); 220 if (cmd->hdr.return_code) { 221 QETH_DBF_MESSAGE(2, "Error in processing VLAN %u on device %x: %#x.\n", 222 cmd->data.setdelvlan.vlan_id, 223 CARD_DEVID(card), cmd->hdr.return_code); 224 QETH_CARD_TEXT_(card, 2, "L2VL%4x", cmd->hdr.command); 225 } 226 return qeth_l2_setdelvlan_makerc(card, cmd->hdr.return_code); 227 } 228 229 static int qeth_l2_send_setdelvlan(struct qeth_card *card, __u16 i, 230 enum qeth_ipa_cmds ipacmd) 231 { 232 struct qeth_ipa_cmd *cmd; 233 struct qeth_cmd_buffer *iob; 234 235 QETH_CARD_TEXT_(card, 4, "L2sdv%x", ipacmd); 236 iob = qeth_ipa_alloc_cmd(card, ipacmd, QETH_PROT_IPV4, 237 IPA_DATA_SIZEOF(setdelvlan)); 238 if (!iob) 239 return -ENOMEM; 240 cmd = __ipa_cmd(iob); 241 cmd->data.setdelvlan.vlan_id = i; 242 return qeth_send_ipa_cmd(card, iob, qeth_l2_send_setdelvlan_cb, NULL); 243 } 244 245 static int qeth_l2_vlan_rx_add_vid(struct net_device *dev, 246 __be16 proto, u16 vid) 247 { 248 struct qeth_card *card = dev->ml_priv; 249 250 QETH_CARD_TEXT_(card, 4, "aid:%d", vid); 251 if (!vid) 252 return 0; 253 254 return qeth_l2_send_setdelvlan(card, vid, IPA_CMD_SETVLAN); 255 } 256 257 static int qeth_l2_vlan_rx_kill_vid(struct net_device *dev, 258 __be16 proto, u16 vid) 259 { 260 struct qeth_card *card = dev->ml_priv; 261 262 QETH_CARD_TEXT_(card, 4, "kid:%d", vid); 263 if (!vid) 264 return 0; 265 266 return qeth_l2_send_setdelvlan(card, vid, IPA_CMD_DELVLAN); 267 } 268 269 static void qeth_l2_set_pnso_mode(struct qeth_card *card, 270 enum qeth_pnso_mode mode) 271 { 272 spin_lock_irq(get_ccwdev_lock(CARD_RDEV(card))); 273 WRITE_ONCE(card->info.pnso_mode, mode); 274 spin_unlock_irq(get_ccwdev_lock(CARD_RDEV(card))); 275 276 if (mode == QETH_PNSO_NONE) 277 drain_workqueue(card->event_wq); 278 } 279 280 static void qeth_l2_dev2br_fdb_flush(struct qeth_card *card) 281 { 282 struct switchdev_notifier_fdb_info info; 283 284 QETH_CARD_TEXT(card, 2, "fdbflush"); 285 286 info.addr = NULL; 287 /* flush all VLANs: */ 288 info.vid = 0; 289 info.added_by_user = false; 290 info.offloaded = true; 291 292 call_switchdev_notifiers(SWITCHDEV_FDB_FLUSH_TO_BRIDGE, 293 card->dev, &info.info, NULL); 294 } 295 296 static int qeth_l2_request_initial_mac(struct qeth_card *card) 297 { 298 int rc = 0; 299 300 QETH_CARD_TEXT(card, 2, "l2reqmac"); 301 302 if (MACHINE_IS_VM) { 303 rc = qeth_vm_request_mac(card); 304 if (!rc) 305 goto out; 306 QETH_DBF_MESSAGE(2, "z/VM MAC Service failed on device %x: %#x\n", 307 CARD_DEVID(card), rc); 308 QETH_CARD_TEXT_(card, 2, "err%04x", rc); 309 /* fall back to alternative mechanism: */ 310 } 311 312 if (!IS_OSN(card)) { 313 rc = qeth_setadpparms_change_macaddr(card); 314 if (!rc) 315 goto out; 316 QETH_DBF_MESSAGE(2, "READ_MAC Assist failed on device %x: %#x\n", 317 CARD_DEVID(card), rc); 318 QETH_CARD_TEXT_(card, 2, "1err%04x", rc); 319 /* fall back once more: */ 320 } 321 322 /* some devices don't support a custom MAC address: */ 323 if (IS_OSM(card) || IS_OSX(card)) 324 return (rc) ? rc : -EADDRNOTAVAIL; 325 eth_hw_addr_random(card->dev); 326 327 out: 328 QETH_CARD_HEX(card, 2, card->dev->dev_addr, card->dev->addr_len); 329 return 0; 330 } 331 332 static void qeth_l2_register_dev_addr(struct qeth_card *card) 333 { 334 if (!is_valid_ether_addr(card->dev->dev_addr)) 335 qeth_l2_request_initial_mac(card); 336 337 if (!IS_OSN(card) && !qeth_l2_send_setmac(card, card->dev->dev_addr)) 338 card->info.dev_addr_is_registered = 1; 339 else 340 card->info.dev_addr_is_registered = 0; 341 } 342 343 static int qeth_l2_validate_addr(struct net_device *dev) 344 { 345 struct qeth_card *card = dev->ml_priv; 346 347 if (card->info.dev_addr_is_registered) 348 return eth_validate_addr(dev); 349 350 QETH_CARD_TEXT(card, 4, "nomacadr"); 351 return -EPERM; 352 } 353 354 static int qeth_l2_set_mac_address(struct net_device *dev, void *p) 355 { 356 struct sockaddr *addr = p; 357 struct qeth_card *card = dev->ml_priv; 358 u8 old_addr[ETH_ALEN]; 359 int rc = 0; 360 361 QETH_CARD_TEXT(card, 3, "setmac"); 362 363 if (IS_OSM(card) || IS_OSX(card)) { 364 QETH_CARD_TEXT(card, 3, "setmcTYP"); 365 return -EOPNOTSUPP; 366 } 367 QETH_CARD_HEX(card, 3, addr->sa_data, ETH_ALEN); 368 if (!is_valid_ether_addr(addr->sa_data)) 369 return -EADDRNOTAVAIL; 370 371 /* don't register the same address twice */ 372 if (ether_addr_equal_64bits(dev->dev_addr, addr->sa_data) && 373 card->info.dev_addr_is_registered) 374 return 0; 375 376 /* add the new address, switch over, drop the old */ 377 rc = qeth_l2_send_setmac(card, addr->sa_data); 378 if (rc) 379 return rc; 380 ether_addr_copy(old_addr, dev->dev_addr); 381 ether_addr_copy(dev->dev_addr, addr->sa_data); 382 383 if (card->info.dev_addr_is_registered) 384 qeth_l2_remove_mac(card, old_addr); 385 card->info.dev_addr_is_registered = 1; 386 return 0; 387 } 388 389 static void qeth_l2_promisc_to_bridge(struct qeth_card *card, bool enable) 390 { 391 int role; 392 int rc; 393 394 QETH_CARD_TEXT(card, 3, "pmisc2br"); 395 396 if (enable) { 397 if (card->options.sbp.reflect_promisc_primary) 398 role = QETH_SBP_ROLE_PRIMARY; 399 else 400 role = QETH_SBP_ROLE_SECONDARY; 401 } else 402 role = QETH_SBP_ROLE_NONE; 403 404 rc = qeth_bridgeport_setrole(card, role); 405 QETH_CARD_TEXT_(card, 2, "bpm%c%04x", enable ? '+' : '-', rc); 406 if (!rc) { 407 card->options.sbp.role = role; 408 card->info.promisc_mode = enable; 409 } 410 } 411 412 static void qeth_l2_set_promisc_mode(struct qeth_card *card) 413 { 414 bool enable = card->dev->flags & IFF_PROMISC; 415 416 if (card->info.promisc_mode == enable) 417 return; 418 419 if (qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE)) { 420 qeth_setadp_promisc_mode(card, enable); 421 } else { 422 mutex_lock(&card->sbp_lock); 423 if (card->options.sbp.reflect_promisc) 424 qeth_l2_promisc_to_bridge(card, enable); 425 mutex_unlock(&card->sbp_lock); 426 } 427 } 428 429 /* New MAC address is added to the hash table and marked to be written on card 430 * only if there is not in the hash table storage already 431 * 432 */ 433 static void qeth_l2_add_mac(struct qeth_card *card, struct netdev_hw_addr *ha) 434 { 435 u32 mac_hash = get_unaligned((u32 *)(&ha->addr[2])); 436 struct qeth_mac *mac; 437 438 hash_for_each_possible(card->rx_mode_addrs, mac, hnode, mac_hash) { 439 if (ether_addr_equal_64bits(ha->addr, mac->mac_addr)) { 440 mac->disp_flag = QETH_DISP_ADDR_DO_NOTHING; 441 return; 442 } 443 } 444 445 mac = kzalloc(sizeof(struct qeth_mac), GFP_ATOMIC); 446 if (!mac) 447 return; 448 449 ether_addr_copy(mac->mac_addr, ha->addr); 450 mac->disp_flag = QETH_DISP_ADDR_ADD; 451 452 hash_add(card->rx_mode_addrs, &mac->hnode, mac_hash); 453 } 454 455 static void qeth_l2_rx_mode_work(struct work_struct *work) 456 { 457 struct qeth_card *card = container_of(work, struct qeth_card, 458 rx_mode_work); 459 struct net_device *dev = card->dev; 460 struct netdev_hw_addr *ha; 461 struct qeth_mac *mac; 462 struct hlist_node *tmp; 463 int i; 464 int rc; 465 466 QETH_CARD_TEXT(card, 3, "setmulti"); 467 468 netif_addr_lock_bh(dev); 469 netdev_for_each_mc_addr(ha, dev) 470 qeth_l2_add_mac(card, ha); 471 netdev_for_each_uc_addr(ha, dev) 472 qeth_l2_add_mac(card, ha); 473 netif_addr_unlock_bh(dev); 474 475 hash_for_each_safe(card->rx_mode_addrs, i, tmp, mac, hnode) { 476 switch (mac->disp_flag) { 477 case QETH_DISP_ADDR_DELETE: 478 qeth_l2_remove_mac(card, mac->mac_addr); 479 hash_del(&mac->hnode); 480 kfree(mac); 481 break; 482 case QETH_DISP_ADDR_ADD: 483 rc = qeth_l2_write_mac(card, mac->mac_addr); 484 if (rc) { 485 hash_del(&mac->hnode); 486 kfree(mac); 487 break; 488 } 489 fallthrough; 490 default: 491 /* for next call to set_rx_mode(): */ 492 mac->disp_flag = QETH_DISP_ADDR_DELETE; 493 } 494 } 495 496 qeth_l2_set_promisc_mode(card); 497 } 498 499 static int qeth_l2_xmit_osn(struct qeth_card *card, struct sk_buff *skb, 500 struct qeth_qdio_out_q *queue) 501 { 502 gfp_t gfp = GFP_ATOMIC | (skb_pfmemalloc(skb) ? __GFP_MEMALLOC : 0); 503 struct qeth_hdr *hdr = (struct qeth_hdr *)skb->data; 504 addr_t end = (addr_t)(skb->data + sizeof(*hdr)); 505 addr_t start = (addr_t)skb->data; 506 unsigned int elements = 0; 507 unsigned int hd_len = 0; 508 int rc; 509 510 if (skb->protocol == htons(ETH_P_IPV6)) 511 return -EPROTONOSUPPORT; 512 513 if (qeth_get_elements_for_range(start, end) > 1) { 514 /* Misaligned HW header, move it to its own buffer element. */ 515 hdr = kmem_cache_alloc(qeth_core_header_cache, gfp); 516 if (!hdr) 517 return -ENOMEM; 518 hd_len = sizeof(*hdr); 519 skb_copy_from_linear_data(skb, (char *)hdr, hd_len); 520 elements++; 521 } 522 523 elements += qeth_count_elements(skb, hd_len); 524 if (elements > queue->max_elements) { 525 rc = -E2BIG; 526 goto out; 527 } 528 529 rc = qeth_do_send_packet(card, queue, skb, hdr, hd_len, hd_len, 530 elements); 531 out: 532 if (rc && hd_len) 533 kmem_cache_free(qeth_core_header_cache, hdr); 534 return rc; 535 } 536 537 static netdev_tx_t qeth_l2_hard_start_xmit(struct sk_buff *skb, 538 struct net_device *dev) 539 { 540 struct qeth_card *card = dev->ml_priv; 541 u16 txq = skb_get_queue_mapping(skb); 542 struct qeth_qdio_out_q *queue; 543 int rc; 544 545 if (!skb_is_gso(skb)) 546 qdisc_skb_cb(skb)->pkt_len = skb->len; 547 if (IS_IQD(card)) 548 txq = qeth_iqd_translate_txq(dev, txq); 549 queue = card->qdio.out_qs[txq]; 550 551 if (IS_OSN(card)) 552 rc = qeth_l2_xmit_osn(card, skb, queue); 553 else 554 rc = qeth_xmit(card, skb, queue, qeth_get_ip_version(skb), 555 qeth_l2_fill_header); 556 557 if (!rc) 558 return NETDEV_TX_OK; 559 560 QETH_TXQ_STAT_INC(queue, tx_dropped); 561 kfree_skb(skb); 562 return NETDEV_TX_OK; 563 } 564 565 static u16 qeth_l2_select_queue(struct net_device *dev, struct sk_buff *skb, 566 struct net_device *sb_dev) 567 { 568 struct qeth_card *card = dev->ml_priv; 569 570 if (IS_IQD(card)) 571 return qeth_iqd_select_queue(dev, skb, 572 qeth_get_ether_cast_type(skb), 573 sb_dev); 574 575 return IS_VM_NIC(card) ? netdev_pick_tx(dev, skb, sb_dev) : 576 qeth_get_priority_queue(card, skb); 577 } 578 579 static void qeth_l2_set_rx_mode(struct net_device *dev) 580 { 581 struct qeth_card *card = dev->ml_priv; 582 583 schedule_work(&card->rx_mode_work); 584 } 585 586 /** 587 * qeth_l2_pnso() - perform network subchannel operation 588 * @card: qeth_card structure pointer 589 * @oc: Operation Code 590 * @cnc: Boolean Change-Notification Control 591 * @cb: Callback function will be executed for each element 592 * of the address list 593 * @priv: Pointer to pass to the callback function. 594 * 595 * Collects network information in a network address list and calls the 596 * callback function for every entry in the list. If "change-notification- 597 * control" is set, further changes in the address list will be reported 598 * via the IPA command. 599 */ 600 static int qeth_l2_pnso(struct qeth_card *card, u8 oc, int cnc, 601 void (*cb)(void *priv, struct chsc_pnso_naid_l2 *entry), 602 void *priv) 603 { 604 struct ccw_device *ddev = CARD_DDEV(card); 605 struct chsc_pnso_area *rr; 606 u32 prev_instance = 0; 607 int isfirstblock = 1; 608 int i, size, elems; 609 int rc; 610 611 rr = (struct chsc_pnso_area *)get_zeroed_page(GFP_KERNEL); 612 if (rr == NULL) 613 return -ENOMEM; 614 do { 615 QETH_CARD_TEXT(card, 2, "PNSO"); 616 /* on the first iteration, naihdr.resume_token will be zero */ 617 rc = ccw_device_pnso(ddev, rr, oc, rr->naihdr.resume_token, 618 cnc); 619 if (rc) 620 continue; 621 if (cb == NULL) 622 continue; 623 624 size = rr->naihdr.naids; 625 if (size != sizeof(struct chsc_pnso_naid_l2)) { 626 WARN_ON_ONCE(1); 627 continue; 628 } 629 630 elems = (rr->response.length - sizeof(struct chsc_header) - 631 sizeof(struct chsc_pnso_naihdr)) / size; 632 633 if (!isfirstblock && (rr->naihdr.instance != prev_instance)) { 634 /* Inform the caller that they need to scrap */ 635 /* the data that was already reported via cb */ 636 rc = -EAGAIN; 637 break; 638 } 639 isfirstblock = 0; 640 prev_instance = rr->naihdr.instance; 641 for (i = 0; i < elems; i++) 642 (*cb)(priv, &rr->entries[i]); 643 } while ((rc == -EBUSY) || (!rc && /* list stored */ 644 /* resume token is non-zero => list incomplete */ 645 (rr->naihdr.resume_token.t1 || rr->naihdr.resume_token.t2))); 646 647 if (rc) 648 QETH_CARD_TEXT_(card, 2, "PNrp%04x", rr->response.code); 649 650 free_page((unsigned long)rr); 651 return rc; 652 } 653 654 static bool qeth_is_my_net_if_token(struct qeth_card *card, 655 struct net_if_token *token) 656 { 657 return ((card->info.ddev_devno == token->devnum) && 658 (card->info.cssid == token->cssid) && 659 (card->info.iid == token->iid) && 660 (card->info.ssid == token->ssid) && 661 (card->info.chpid == token->chpid) && 662 (card->info.chid == token->chid)); 663 } 664 665 /** 666 * qeth_l2_dev2br_fdb_notify() - update fdb of master bridge 667 * @card: qeth_card structure pointer 668 * @code: event bitmask: high order bit 0x80 set to 669 * 1 - removal of an object 670 * 0 - addition of an object 671 * Object type(s): 672 * 0x01 - VLAN, 0x02 - MAC, 0x03 - VLAN and MAC 673 * @token: "network token" structure identifying 'physical' location 674 * of the target 675 * @addr_lnid: structure with MAC address and VLAN ID of the target 676 */ 677 static void qeth_l2_dev2br_fdb_notify(struct qeth_card *card, u8 code, 678 struct net_if_token *token, 679 struct mac_addr_lnid *addr_lnid) 680 { 681 struct switchdev_notifier_fdb_info info; 682 u8 ntfy_mac[ETH_ALEN]; 683 684 ether_addr_copy(ntfy_mac, addr_lnid->mac); 685 /* Ignore VLAN only changes */ 686 if (!(code & IPA_ADDR_CHANGE_CODE_MACADDR)) 687 return; 688 /* Ignore mcast entries */ 689 if (is_multicast_ether_addr(ntfy_mac)) 690 return; 691 /* Ignore my own addresses */ 692 if (qeth_is_my_net_if_token(card, token)) 693 return; 694 695 info.addr = ntfy_mac; 696 /* don't report VLAN IDs */ 697 info.vid = 0; 698 info.added_by_user = false; 699 info.offloaded = true; 700 701 if (code & IPA_ADDR_CHANGE_CODE_REMOVAL) { 702 call_switchdev_notifiers(SWITCHDEV_FDB_DEL_TO_BRIDGE, 703 card->dev, &info.info, NULL); 704 QETH_CARD_TEXT(card, 4, "andelmac"); 705 QETH_CARD_TEXT_(card, 4, 706 "mc%012lx", ether_addr_to_u64(ntfy_mac)); 707 } else { 708 call_switchdev_notifiers(SWITCHDEV_FDB_ADD_TO_BRIDGE, 709 card->dev, &info.info, NULL); 710 QETH_CARD_TEXT(card, 4, "anaddmac"); 711 QETH_CARD_TEXT_(card, 4, 712 "mc%012lx", ether_addr_to_u64(ntfy_mac)); 713 } 714 } 715 716 static void qeth_l2_dev2br_an_set_cb(void *priv, 717 struct chsc_pnso_naid_l2 *entry) 718 { 719 u8 code = IPA_ADDR_CHANGE_CODE_MACADDR; 720 struct qeth_card *card = priv; 721 722 if (entry->addr_lnid.lnid < VLAN_N_VID) 723 code |= IPA_ADDR_CHANGE_CODE_VLANID; 724 qeth_l2_dev2br_fdb_notify(card, code, 725 (struct net_if_token *)&entry->nit, 726 (struct mac_addr_lnid *)&entry->addr_lnid); 727 } 728 729 /** 730 * qeth_l2_dev2br_an_set() - 731 * Enable or disable 'dev to bridge network address notification' 732 * @card: qeth_card structure pointer 733 * @enable: Enable or disable 'dev to bridge network address notification' 734 * 735 * Returns negative errno-compatible error indication or 0 on success. 736 * 737 * On enable, emits a series of address notifications for all 738 * currently registered hosts. 739 * 740 * Must be called under rtnl_lock 741 */ 742 static int qeth_l2_dev2br_an_set(struct qeth_card *card, bool enable) 743 { 744 int rc; 745 746 if (enable) { 747 QETH_CARD_TEXT(card, 2, "anseton"); 748 rc = qeth_l2_pnso(card, PNSO_OC_NET_ADDR_INFO, 1, 749 qeth_l2_dev2br_an_set_cb, card); 750 if (rc == -EAGAIN) 751 /* address notification enabled, but inconsistent 752 * addresses reported -> disable address notification 753 */ 754 qeth_l2_pnso(card, PNSO_OC_NET_ADDR_INFO, 0, 755 NULL, NULL); 756 } else { 757 QETH_CARD_TEXT(card, 2, "ansetoff"); 758 rc = qeth_l2_pnso(card, PNSO_OC_NET_ADDR_INFO, 0, NULL, NULL); 759 } 760 761 return rc; 762 } 763 764 static int qeth_l2_bridge_getlink(struct sk_buff *skb, u32 pid, u32 seq, 765 struct net_device *dev, u32 filter_mask, 766 int nlflags) 767 { 768 struct qeth_priv *priv = netdev_priv(dev); 769 struct qeth_card *card = dev->ml_priv; 770 u16 mode = BRIDGE_MODE_UNDEF; 771 772 /* Do not even show qeth devs that cannot do bridge_setlink */ 773 if (!priv->brport_hw_features || !netif_device_present(dev) || 774 qeth_bridgeport_is_in_use(card)) 775 return -EOPNOTSUPP; 776 777 return ndo_dflt_bridge_getlink(skb, pid, seq, dev, 778 mode, priv->brport_features, 779 priv->brport_hw_features, 780 nlflags, filter_mask, NULL); 781 } 782 783 static const struct nla_policy qeth_brport_policy[IFLA_BRPORT_MAX + 1] = { 784 [IFLA_BRPORT_LEARNING_SYNC] = { .type = NLA_U8 }, 785 }; 786 787 /** 788 * qeth_l2_bridge_setlink() - set bridgeport attributes 789 * @dev: netdevice 790 * @nlh: netlink message header 791 * @flags: bridge flags (here: BRIDGE_FLAGS_SELF) 792 * @extack: extended ACK report struct 793 * 794 * Called under rtnl_lock 795 */ 796 static int qeth_l2_bridge_setlink(struct net_device *dev, struct nlmsghdr *nlh, 797 u16 flags, struct netlink_ext_ack *extack) 798 { 799 struct qeth_priv *priv = netdev_priv(dev); 800 struct nlattr *bp_tb[IFLA_BRPORT_MAX + 1]; 801 struct qeth_card *card = dev->ml_priv; 802 struct nlattr *attr, *nested_attr; 803 bool enable, has_protinfo = false; 804 int rem1, rem2; 805 int rc; 806 807 if (!netif_device_present(dev)) 808 return -ENODEV; 809 if (!(priv->brport_hw_features)) 810 return -EOPNOTSUPP; 811 812 nlmsg_for_each_attr(attr, nlh, sizeof(struct ifinfomsg), rem1) { 813 if (nla_type(attr) == IFLA_PROTINFO) { 814 rc = nla_parse_nested(bp_tb, IFLA_BRPORT_MAX, attr, 815 qeth_brport_policy, extack); 816 if (rc) 817 return rc; 818 has_protinfo = true; 819 } else if (nla_type(attr) == IFLA_AF_SPEC) { 820 nla_for_each_nested(nested_attr, attr, rem2) { 821 if (nla_type(nested_attr) == IFLA_BRIDGE_FLAGS) 822 continue; 823 NL_SET_ERR_MSG_ATTR(extack, nested_attr, 824 "Unsupported attribute"); 825 return -EINVAL; 826 } 827 } else { 828 NL_SET_ERR_MSG_ATTR(extack, attr, "Unsupported attribute"); 829 return -EINVAL; 830 } 831 } 832 if (!has_protinfo) 833 return 0; 834 if (!bp_tb[IFLA_BRPORT_LEARNING_SYNC]) 835 return -EINVAL; 836 enable = !!nla_get_u8(bp_tb[IFLA_BRPORT_LEARNING_SYNC]); 837 838 if (enable == !!(priv->brport_features & BR_LEARNING_SYNC)) 839 return 0; 840 841 mutex_lock(&card->sbp_lock); 842 /* do not change anything if BridgePort is enabled */ 843 if (qeth_bridgeport_is_in_use(card)) { 844 NL_SET_ERR_MSG(extack, "n/a (BridgePort)"); 845 rc = -EBUSY; 846 } else if (enable) { 847 qeth_l2_set_pnso_mode(card, QETH_PNSO_ADDR_INFO); 848 rc = qeth_l2_dev2br_an_set(card, true); 849 if (rc) 850 qeth_l2_set_pnso_mode(card, QETH_PNSO_NONE); 851 else 852 priv->brport_features |= BR_LEARNING_SYNC; 853 } else { 854 rc = qeth_l2_dev2br_an_set(card, false); 855 if (!rc) { 856 qeth_l2_set_pnso_mode(card, QETH_PNSO_NONE); 857 priv->brport_features ^= BR_LEARNING_SYNC; 858 qeth_l2_dev2br_fdb_flush(card); 859 } 860 } 861 mutex_unlock(&card->sbp_lock); 862 863 return rc; 864 } 865 866 static const struct net_device_ops qeth_l2_netdev_ops = { 867 .ndo_open = qeth_open, 868 .ndo_stop = qeth_stop, 869 .ndo_get_stats64 = qeth_get_stats64, 870 .ndo_start_xmit = qeth_l2_hard_start_xmit, 871 .ndo_features_check = qeth_features_check, 872 .ndo_select_queue = qeth_l2_select_queue, 873 .ndo_validate_addr = qeth_l2_validate_addr, 874 .ndo_set_rx_mode = qeth_l2_set_rx_mode, 875 .ndo_do_ioctl = qeth_do_ioctl, 876 .ndo_set_mac_address = qeth_l2_set_mac_address, 877 .ndo_vlan_rx_add_vid = qeth_l2_vlan_rx_add_vid, 878 .ndo_vlan_rx_kill_vid = qeth_l2_vlan_rx_kill_vid, 879 .ndo_tx_timeout = qeth_tx_timeout, 880 .ndo_fix_features = qeth_fix_features, 881 .ndo_set_features = qeth_set_features, 882 .ndo_bridge_getlink = qeth_l2_bridge_getlink, 883 .ndo_bridge_setlink = qeth_l2_bridge_setlink, 884 }; 885 886 static const struct net_device_ops qeth_osn_netdev_ops = { 887 .ndo_open = qeth_open, 888 .ndo_stop = qeth_stop, 889 .ndo_get_stats64 = qeth_get_stats64, 890 .ndo_start_xmit = qeth_l2_hard_start_xmit, 891 .ndo_validate_addr = eth_validate_addr, 892 .ndo_tx_timeout = qeth_tx_timeout, 893 }; 894 895 static int qeth_l2_setup_netdev(struct qeth_card *card) 896 { 897 int rc; 898 899 if (IS_OSN(card)) { 900 card->dev->netdev_ops = &qeth_osn_netdev_ops; 901 card->dev->flags |= IFF_NOARP; 902 goto add_napi; 903 } 904 905 rc = qeth_setup_netdev(card); 906 if (rc) 907 return rc; 908 909 card->dev->needed_headroom = sizeof(struct qeth_hdr); 910 card->dev->netdev_ops = &qeth_l2_netdev_ops; 911 card->dev->priv_flags |= IFF_UNICAST_FLT; 912 913 if (IS_OSM(card)) { 914 card->dev->features |= NETIF_F_VLAN_CHALLENGED; 915 } else { 916 if (!IS_VM_NIC(card)) 917 card->dev->hw_features |= NETIF_F_HW_VLAN_CTAG_FILTER; 918 card->dev->features |= NETIF_F_HW_VLAN_CTAG_FILTER; 919 } 920 921 if (IS_OSD(card) && !IS_VM_NIC(card)) { 922 card->dev->features |= NETIF_F_SG; 923 /* OSA 3S and earlier has no RX/TX support */ 924 if (qeth_is_supported(card, IPA_OUTBOUND_CHECKSUM)) { 925 card->dev->hw_features |= NETIF_F_IP_CSUM; 926 card->dev->vlan_features |= NETIF_F_IP_CSUM; 927 } 928 } 929 if (qeth_is_supported6(card, IPA_OUTBOUND_CHECKSUM_V6)) { 930 card->dev->hw_features |= NETIF_F_IPV6_CSUM; 931 card->dev->vlan_features |= NETIF_F_IPV6_CSUM; 932 } 933 if (qeth_is_supported(card, IPA_INBOUND_CHECKSUM) || 934 qeth_is_supported6(card, IPA_INBOUND_CHECKSUM_V6)) { 935 card->dev->hw_features |= NETIF_F_RXCSUM; 936 card->dev->vlan_features |= NETIF_F_RXCSUM; 937 } 938 if (qeth_is_supported(card, IPA_OUTBOUND_TSO)) { 939 card->dev->hw_features |= NETIF_F_TSO; 940 card->dev->vlan_features |= NETIF_F_TSO; 941 } 942 if (qeth_is_supported6(card, IPA_OUTBOUND_TSO)) { 943 card->dev->hw_features |= NETIF_F_TSO6; 944 card->dev->vlan_features |= NETIF_F_TSO6; 945 } 946 947 if (card->dev->hw_features & (NETIF_F_TSO | NETIF_F_TSO6)) { 948 card->dev->needed_headroom = sizeof(struct qeth_hdr_tso); 949 netif_keep_dst(card->dev); 950 netif_set_gso_max_size(card->dev, 951 PAGE_SIZE * (QDIO_MAX_ELEMENTS_PER_BUFFER - 1)); 952 } 953 954 add_napi: 955 netif_napi_add(card->dev, &card->napi, qeth_poll, QETH_NAPI_WEIGHT); 956 return register_netdev(card->dev); 957 } 958 959 static void qeth_l2_trace_features(struct qeth_card *card) 960 { 961 /* Set BridgePort features */ 962 QETH_CARD_TEXT(card, 2, "featuSBP"); 963 QETH_CARD_HEX(card, 2, &card->options.sbp.supported_funcs, 964 sizeof(card->options.sbp.supported_funcs)); 965 /* VNIC Characteristics features */ 966 QETH_CARD_TEXT(card, 2, "feaVNICC"); 967 QETH_CARD_HEX(card, 2, &card->options.vnicc.sup_chars, 968 sizeof(card->options.vnicc.sup_chars)); 969 } 970 971 static void qeth_l2_setup_bridgeport_attrs(struct qeth_card *card) 972 { 973 if (!card->options.sbp.reflect_promisc && 974 card->options.sbp.role != QETH_SBP_ROLE_NONE) { 975 /* Conditional to avoid spurious error messages */ 976 qeth_bridgeport_setrole(card, card->options.sbp.role); 977 /* Let the callback function refresh the stored role value. */ 978 qeth_bridgeport_query_ports(card, &card->options.sbp.role, 979 NULL); 980 } 981 if (card->options.sbp.hostnotification) { 982 if (qeth_bridgeport_an_set(card, 1)) 983 card->options.sbp.hostnotification = 0; 984 } 985 } 986 987 /** 988 * qeth_l2_detect_dev2br_support() - 989 * Detect whether this card supports 'dev to bridge fdb network address 990 * change notification' and thus can support the learning_sync bridgeport 991 * attribute 992 * @card: qeth_card structure pointer 993 * 994 * This is a destructive test and must be called before dev2br or 995 * bridgeport address notification is enabled! 996 */ 997 static void qeth_l2_detect_dev2br_support(struct qeth_card *card) 998 { 999 struct qeth_priv *priv = netdev_priv(card->dev); 1000 bool dev2br_supported; 1001 int rc; 1002 1003 QETH_CARD_TEXT(card, 2, "d2brsup"); 1004 if (!IS_IQD(card)) 1005 return; 1006 1007 /* dev2br requires valid cssid,iid,chid */ 1008 if (!card->info.ids_valid) { 1009 dev2br_supported = false; 1010 } else if (css_general_characteristics.enarf) { 1011 dev2br_supported = true; 1012 } else { 1013 /* Old machines don't have the feature bit: 1014 * Probe by testing whether a disable succeeds 1015 */ 1016 rc = qeth_l2_pnso(card, PNSO_OC_NET_ADDR_INFO, 0, NULL, NULL); 1017 dev2br_supported = !rc; 1018 } 1019 QETH_CARD_TEXT_(card, 2, "D2Bsup%02x", dev2br_supported); 1020 1021 if (dev2br_supported) 1022 priv->brport_hw_features |= BR_LEARNING_SYNC; 1023 else 1024 priv->brport_hw_features &= ~BR_LEARNING_SYNC; 1025 } 1026 1027 static void qeth_l2_enable_brport_features(struct qeth_card *card) 1028 { 1029 struct qeth_priv *priv = netdev_priv(card->dev); 1030 int rc; 1031 1032 if (priv->brport_features & BR_LEARNING_SYNC) { 1033 if (priv->brport_hw_features & BR_LEARNING_SYNC) { 1034 qeth_l2_set_pnso_mode(card, QETH_PNSO_ADDR_INFO); 1035 rc = qeth_l2_dev2br_an_set(card, true); 1036 if (rc == -EAGAIN) { 1037 /* Recoverable error, retry once */ 1038 qeth_l2_set_pnso_mode(card, QETH_PNSO_NONE); 1039 qeth_l2_dev2br_fdb_flush(card); 1040 qeth_l2_set_pnso_mode(card, QETH_PNSO_ADDR_INFO); 1041 rc = qeth_l2_dev2br_an_set(card, true); 1042 } 1043 if (rc) { 1044 netdev_err(card->dev, 1045 "failed to enable bridge learning_sync: %d\n", 1046 rc); 1047 qeth_l2_set_pnso_mode(card, QETH_PNSO_NONE); 1048 qeth_l2_dev2br_fdb_flush(card); 1049 priv->brport_features ^= BR_LEARNING_SYNC; 1050 } 1051 } else { 1052 dev_warn(&card->gdev->dev, 1053 "bridge learning_sync not supported\n"); 1054 priv->brport_features ^= BR_LEARNING_SYNC; 1055 } 1056 } 1057 } 1058 1059 #ifdef CONFIG_QETH_OSN 1060 static void qeth_osn_assist_cb(struct qeth_card *card, 1061 struct qeth_cmd_buffer *iob, 1062 unsigned int data_length) 1063 { 1064 qeth_notify_cmd(iob, 0); 1065 qeth_put_cmd(iob); 1066 } 1067 1068 int qeth_osn_assist(struct net_device *dev, void *data, int data_len) 1069 { 1070 struct qeth_cmd_buffer *iob; 1071 struct qeth_card *card; 1072 1073 if (data_len < 0) 1074 return -EINVAL; 1075 if (!dev) 1076 return -ENODEV; 1077 card = dev->ml_priv; 1078 if (!card) 1079 return -ENODEV; 1080 QETH_CARD_TEXT(card, 2, "osnsdmc"); 1081 if (!qeth_card_hw_is_reachable(card)) 1082 return -ENODEV; 1083 1084 iob = qeth_alloc_cmd(&card->write, IPA_PDU_HEADER_SIZE + data_len, 1, 1085 QETH_IPA_TIMEOUT); 1086 if (!iob) 1087 return -ENOMEM; 1088 1089 qeth_prepare_ipa_cmd(card, iob, (u16) data_len, NULL); 1090 1091 memcpy(__ipa_cmd(iob), data, data_len); 1092 iob->callback = qeth_osn_assist_cb; 1093 return qeth_send_ipa_cmd(card, iob, NULL, NULL); 1094 } 1095 EXPORT_SYMBOL(qeth_osn_assist); 1096 1097 int qeth_osn_register(unsigned char *read_dev_no, struct net_device **dev, 1098 int (*assist_cb)(struct net_device *, void *), 1099 int (*data_cb)(struct sk_buff *)) 1100 { 1101 struct qeth_card *card; 1102 char bus_id[16]; 1103 u16 devno; 1104 1105 memcpy(&devno, read_dev_no, 2); 1106 sprintf(bus_id, "0.0.%04x", devno); 1107 card = qeth_get_card_by_busid(bus_id); 1108 if (!card || !IS_OSN(card)) 1109 return -ENODEV; 1110 *dev = card->dev; 1111 1112 QETH_CARD_TEXT(card, 2, "osnreg"); 1113 if ((assist_cb == NULL) || (data_cb == NULL)) 1114 return -EINVAL; 1115 card->osn_info.assist_cb = assist_cb; 1116 card->osn_info.data_cb = data_cb; 1117 return 0; 1118 } 1119 EXPORT_SYMBOL(qeth_osn_register); 1120 1121 void qeth_osn_deregister(struct net_device *dev) 1122 { 1123 struct qeth_card *card; 1124 1125 if (!dev) 1126 return; 1127 card = dev->ml_priv; 1128 if (!card) 1129 return; 1130 QETH_CARD_TEXT(card, 2, "osndereg"); 1131 card->osn_info.assist_cb = NULL; 1132 card->osn_info.data_cb = NULL; 1133 return; 1134 } 1135 EXPORT_SYMBOL(qeth_osn_deregister); 1136 #endif 1137 1138 /* SETBRIDGEPORT support, async notifications */ 1139 1140 enum qeth_an_event_type {anev_reg_unreg, anev_abort, anev_reset}; 1141 1142 /** 1143 * qeth_bridge_emit_host_event() - bridgeport address change notification 1144 * @card: qeth_card structure pointer, for udev events. 1145 * @evtype: "normal" register/unregister, or abort, or reset. For abort 1146 * and reset token and addr_lnid are unused and may be NULL. 1147 * @code: event bitmask: high order bit 0x80 value 1 means removal of an 1148 * object, 0 - addition of an object. 1149 * 0x01 - VLAN, 0x02 - MAC, 0x03 - VLAN and MAC. 1150 * @token: "network token" structure identifying physical address of the port. 1151 * @addr_lnid: pointer to structure with MAC address and VLAN ID. 1152 * 1153 * This function is called when registrations and deregistrations are 1154 * reported by the hardware, and also when notifications are enabled - 1155 * for all currently registered addresses. 1156 */ 1157 static void qeth_bridge_emit_host_event(struct qeth_card *card, 1158 enum qeth_an_event_type evtype, 1159 u8 code, 1160 struct net_if_token *token, 1161 struct mac_addr_lnid *addr_lnid) 1162 { 1163 char str[7][32]; 1164 char *env[8]; 1165 int i = 0; 1166 1167 switch (evtype) { 1168 case anev_reg_unreg: 1169 snprintf(str[i], sizeof(str[i]), "BRIDGEDHOST=%s", 1170 (code & IPA_ADDR_CHANGE_CODE_REMOVAL) 1171 ? "deregister" : "register"); 1172 env[i] = str[i]; i++; 1173 if (code & IPA_ADDR_CHANGE_CODE_VLANID) { 1174 snprintf(str[i], sizeof(str[i]), "VLAN=%d", 1175 addr_lnid->lnid); 1176 env[i] = str[i]; i++; 1177 } 1178 if (code & IPA_ADDR_CHANGE_CODE_MACADDR) { 1179 snprintf(str[i], sizeof(str[i]), "MAC=%pM", 1180 addr_lnid->mac); 1181 env[i] = str[i]; i++; 1182 } 1183 snprintf(str[i], sizeof(str[i]), "NTOK_BUSID=%x.%x.%04x", 1184 token->cssid, token->ssid, token->devnum); 1185 env[i] = str[i]; i++; 1186 snprintf(str[i], sizeof(str[i]), "NTOK_IID=%02x", token->iid); 1187 env[i] = str[i]; i++; 1188 snprintf(str[i], sizeof(str[i]), "NTOK_CHPID=%02x", 1189 token->chpid); 1190 env[i] = str[i]; i++; 1191 snprintf(str[i], sizeof(str[i]), "NTOK_CHID=%04x", token->chid); 1192 env[i] = str[i]; i++; 1193 break; 1194 case anev_abort: 1195 snprintf(str[i], sizeof(str[i]), "BRIDGEDHOST=abort"); 1196 env[i] = str[i]; i++; 1197 break; 1198 case anev_reset: 1199 snprintf(str[i], sizeof(str[i]), "BRIDGEDHOST=reset"); 1200 env[i] = str[i]; i++; 1201 break; 1202 } 1203 env[i] = NULL; 1204 kobject_uevent_env(&card->gdev->dev.kobj, KOBJ_CHANGE, env); 1205 } 1206 1207 struct qeth_bridge_state_data { 1208 struct work_struct worker; 1209 struct qeth_card *card; 1210 u8 role; 1211 u8 state; 1212 }; 1213 1214 static void qeth_bridge_state_change_worker(struct work_struct *work) 1215 { 1216 struct qeth_bridge_state_data *data = 1217 container_of(work, struct qeth_bridge_state_data, worker); 1218 char env_locrem[32]; 1219 char env_role[32]; 1220 char env_state[32]; 1221 char *env[] = { 1222 env_locrem, 1223 env_role, 1224 env_state, 1225 NULL 1226 }; 1227 1228 snprintf(env_locrem, sizeof(env_locrem), "BRIDGEPORT=statechange"); 1229 snprintf(env_role, sizeof(env_role), "ROLE=%s", 1230 (data->role == QETH_SBP_ROLE_NONE) ? "none" : 1231 (data->role == QETH_SBP_ROLE_PRIMARY) ? "primary" : 1232 (data->role == QETH_SBP_ROLE_SECONDARY) ? "secondary" : 1233 "<INVALID>"); 1234 snprintf(env_state, sizeof(env_state), "STATE=%s", 1235 (data->state == QETH_SBP_STATE_INACTIVE) ? "inactive" : 1236 (data->state == QETH_SBP_STATE_STANDBY) ? "standby" : 1237 (data->state == QETH_SBP_STATE_ACTIVE) ? "active" : 1238 "<INVALID>"); 1239 kobject_uevent_env(&data->card->gdev->dev.kobj, 1240 KOBJ_CHANGE, env); 1241 kfree(data); 1242 } 1243 1244 static void qeth_bridge_state_change(struct qeth_card *card, 1245 struct qeth_ipa_cmd *cmd) 1246 { 1247 struct qeth_sbp_port_data *qports = &cmd->data.sbp.data.port_data; 1248 struct qeth_bridge_state_data *data; 1249 1250 QETH_CARD_TEXT(card, 2, "brstchng"); 1251 if (qports->num_entries == 0) { 1252 QETH_CARD_TEXT(card, 2, "BPempty"); 1253 return; 1254 } 1255 if (qports->entry_length != sizeof(struct qeth_sbp_port_entry)) { 1256 QETH_CARD_TEXT_(card, 2, "BPsz%04x", qports->entry_length); 1257 return; 1258 } 1259 1260 data = kzalloc(sizeof(*data), GFP_ATOMIC); 1261 if (!data) { 1262 QETH_CARD_TEXT(card, 2, "BPSalloc"); 1263 return; 1264 } 1265 INIT_WORK(&data->worker, qeth_bridge_state_change_worker); 1266 data->card = card; 1267 /* Information for the local port: */ 1268 data->role = qports->entry[0].role; 1269 data->state = qports->entry[0].state; 1270 1271 queue_work(card->event_wq, &data->worker); 1272 } 1273 1274 struct qeth_addr_change_data { 1275 struct delayed_work dwork; 1276 struct qeth_card *card; 1277 struct qeth_ipacmd_addr_change ac_event; 1278 }; 1279 1280 static void qeth_l2_dev2br_worker(struct work_struct *work) 1281 { 1282 struct delayed_work *dwork = to_delayed_work(work); 1283 struct qeth_addr_change_data *data; 1284 struct qeth_card *card; 1285 struct qeth_priv *priv; 1286 unsigned int i; 1287 int rc; 1288 1289 data = container_of(dwork, struct qeth_addr_change_data, dwork); 1290 card = data->card; 1291 priv = netdev_priv(card->dev); 1292 1293 QETH_CARD_TEXT(card, 4, "dev2brew"); 1294 1295 if (READ_ONCE(card->info.pnso_mode) == QETH_PNSO_NONE) 1296 goto free; 1297 1298 /* Potential re-config in progress, try again later: */ 1299 if (!rtnl_trylock()) { 1300 queue_delayed_work(card->event_wq, dwork, 1301 msecs_to_jiffies(100)); 1302 return; 1303 } 1304 if (!netif_device_present(card->dev)) 1305 goto out_unlock; 1306 1307 if (data->ac_event.lost_event_mask) { 1308 QETH_DBF_MESSAGE(3, 1309 "Address change notification overflow on device %x\n", 1310 CARD_DEVID(card)); 1311 /* Card fdb and bridge fdb are out of sync, card has stopped 1312 * notifications (no need to drain_workqueue). Purge all 1313 * 'extern_learn' entries from the parent bridge and restart 1314 * the notifications. 1315 */ 1316 qeth_l2_dev2br_fdb_flush(card); 1317 rc = qeth_l2_dev2br_an_set(card, true); 1318 if (rc) { 1319 /* TODO: if we want to retry after -EAGAIN, be 1320 * aware there could be stale entries in the 1321 * workqueue now, that need to be drained. 1322 * For now we give up: 1323 */ 1324 netdev_err(card->dev, 1325 "bridge learning_sync failed to recover: %d\n", 1326 rc); 1327 WRITE_ONCE(card->info.pnso_mode, 1328 QETH_PNSO_NONE); 1329 /* To remove fdb entries reported by an_set: */ 1330 qeth_l2_dev2br_fdb_flush(card); 1331 priv->brport_features ^= BR_LEARNING_SYNC; 1332 } else { 1333 QETH_DBF_MESSAGE(3, 1334 "Address Notification resynced on device %x\n", 1335 CARD_DEVID(card)); 1336 } 1337 } else { 1338 for (i = 0; i < data->ac_event.num_entries; i++) { 1339 struct qeth_ipacmd_addr_change_entry *entry = 1340 &data->ac_event.entry[i]; 1341 qeth_l2_dev2br_fdb_notify(card, 1342 entry->change_code, 1343 &entry->token, 1344 &entry->addr_lnid); 1345 } 1346 } 1347 1348 out_unlock: 1349 rtnl_unlock(); 1350 1351 free: 1352 kfree(data); 1353 } 1354 1355 static void qeth_addr_change_event_worker(struct work_struct *work) 1356 { 1357 struct delayed_work *dwork = to_delayed_work(work); 1358 struct qeth_addr_change_data *data; 1359 struct qeth_card *card; 1360 int i; 1361 1362 data = container_of(dwork, struct qeth_addr_change_data, dwork); 1363 card = data->card; 1364 1365 QETH_CARD_TEXT(data->card, 4, "adrchgew"); 1366 1367 if (READ_ONCE(card->info.pnso_mode) == QETH_PNSO_NONE) 1368 goto free; 1369 1370 if (data->ac_event.lost_event_mask) { 1371 /* Potential re-config in progress, try again later: */ 1372 if (!mutex_trylock(&card->sbp_lock)) { 1373 queue_delayed_work(card->event_wq, dwork, 1374 msecs_to_jiffies(100)); 1375 return; 1376 } 1377 1378 dev_info(&data->card->gdev->dev, 1379 "Address change notification stopped on %s (%s)\n", 1380 data->card->dev->name, 1381 (data->ac_event.lost_event_mask == 0x01) 1382 ? "Overflow" 1383 : (data->ac_event.lost_event_mask == 0x02) 1384 ? "Bridge port state change" 1385 : "Unknown reason"); 1386 1387 data->card->options.sbp.hostnotification = 0; 1388 card->info.pnso_mode = QETH_PNSO_NONE; 1389 mutex_unlock(&data->card->sbp_lock); 1390 qeth_bridge_emit_host_event(data->card, anev_abort, 1391 0, NULL, NULL); 1392 } else 1393 for (i = 0; i < data->ac_event.num_entries; i++) { 1394 struct qeth_ipacmd_addr_change_entry *entry = 1395 &data->ac_event.entry[i]; 1396 qeth_bridge_emit_host_event(data->card, 1397 anev_reg_unreg, 1398 entry->change_code, 1399 &entry->token, 1400 &entry->addr_lnid); 1401 } 1402 1403 free: 1404 kfree(data); 1405 } 1406 1407 static void qeth_addr_change_event(struct qeth_card *card, 1408 struct qeth_ipa_cmd *cmd) 1409 { 1410 struct qeth_ipacmd_addr_change *hostevs = 1411 &cmd->data.addrchange; 1412 struct qeth_addr_change_data *data; 1413 int extrasize; 1414 1415 if (card->info.pnso_mode == QETH_PNSO_NONE) 1416 return; 1417 1418 QETH_CARD_TEXT(card, 4, "adrchgev"); 1419 if (cmd->hdr.return_code != 0x0000) { 1420 if (cmd->hdr.return_code == 0x0010) { 1421 if (hostevs->lost_event_mask == 0x00) 1422 hostevs->lost_event_mask = 0xff; 1423 } else { 1424 QETH_CARD_TEXT_(card, 2, "ACHN%04x", 1425 cmd->hdr.return_code); 1426 return; 1427 } 1428 } 1429 extrasize = sizeof(struct qeth_ipacmd_addr_change_entry) * 1430 hostevs->num_entries; 1431 data = kzalloc(sizeof(struct qeth_addr_change_data) + extrasize, 1432 GFP_ATOMIC); 1433 if (!data) { 1434 QETH_CARD_TEXT(card, 2, "ACNalloc"); 1435 return; 1436 } 1437 if (card->info.pnso_mode == QETH_PNSO_BRIDGEPORT) 1438 INIT_DELAYED_WORK(&data->dwork, qeth_addr_change_event_worker); 1439 else 1440 INIT_DELAYED_WORK(&data->dwork, qeth_l2_dev2br_worker); 1441 data->card = card; 1442 memcpy(&data->ac_event, hostevs, 1443 sizeof(struct qeth_ipacmd_addr_change) + extrasize); 1444 queue_delayed_work(card->event_wq, &data->dwork, 0); 1445 } 1446 1447 /* SETBRIDGEPORT support; sending commands */ 1448 1449 struct _qeth_sbp_cbctl { 1450 union { 1451 u32 supported; 1452 struct { 1453 enum qeth_sbp_roles *role; 1454 enum qeth_sbp_states *state; 1455 } qports; 1456 } data; 1457 }; 1458 1459 static int qeth_bridgeport_makerc(struct qeth_card *card, 1460 struct qeth_ipa_cmd *cmd) 1461 { 1462 struct qeth_ipacmd_setbridgeport *sbp = &cmd->data.sbp; 1463 enum qeth_ipa_sbp_cmd setcmd = sbp->hdr.command_code; 1464 u16 ipa_rc = cmd->hdr.return_code; 1465 u16 sbp_rc = sbp->hdr.return_code; 1466 int rc; 1467 1468 if (ipa_rc == IPA_RC_SUCCESS && sbp_rc == IPA_RC_SUCCESS) 1469 return 0; 1470 1471 if ((IS_IQD(card) && ipa_rc == IPA_RC_SUCCESS) || 1472 (!IS_IQD(card) && ipa_rc == sbp_rc)) { 1473 switch (sbp_rc) { 1474 case IPA_RC_SUCCESS: 1475 rc = 0; 1476 break; 1477 case IPA_RC_L2_UNSUPPORTED_CMD: 1478 case IPA_RC_UNSUPPORTED_COMMAND: 1479 rc = -EOPNOTSUPP; 1480 break; 1481 case IPA_RC_SBP_OSA_NOT_CONFIGURED: 1482 case IPA_RC_SBP_IQD_NOT_CONFIGURED: 1483 rc = -ENODEV; /* maybe not the best code here? */ 1484 dev_err(&card->gdev->dev, 1485 "The device is not configured as a Bridge Port\n"); 1486 break; 1487 case IPA_RC_SBP_OSA_OS_MISMATCH: 1488 case IPA_RC_SBP_IQD_OS_MISMATCH: 1489 rc = -EPERM; 1490 dev_err(&card->gdev->dev, 1491 "A Bridge Port is already configured by a different operating system\n"); 1492 break; 1493 case IPA_RC_SBP_OSA_ANO_DEV_PRIMARY: 1494 case IPA_RC_SBP_IQD_ANO_DEV_PRIMARY: 1495 switch (setcmd) { 1496 case IPA_SBP_SET_PRIMARY_BRIDGE_PORT: 1497 rc = -EEXIST; 1498 dev_err(&card->gdev->dev, 1499 "The LAN already has a primary Bridge Port\n"); 1500 break; 1501 case IPA_SBP_SET_SECONDARY_BRIDGE_PORT: 1502 rc = -EBUSY; 1503 dev_err(&card->gdev->dev, 1504 "The device is already a primary Bridge Port\n"); 1505 break; 1506 default: 1507 rc = -EIO; 1508 } 1509 break; 1510 case IPA_RC_SBP_OSA_CURRENT_SECOND: 1511 case IPA_RC_SBP_IQD_CURRENT_SECOND: 1512 rc = -EBUSY; 1513 dev_err(&card->gdev->dev, 1514 "The device is already a secondary Bridge Port\n"); 1515 break; 1516 case IPA_RC_SBP_OSA_LIMIT_SECOND: 1517 case IPA_RC_SBP_IQD_LIMIT_SECOND: 1518 rc = -EEXIST; 1519 dev_err(&card->gdev->dev, 1520 "The LAN cannot have more secondary Bridge Ports\n"); 1521 break; 1522 case IPA_RC_SBP_OSA_CURRENT_PRIMARY: 1523 case IPA_RC_SBP_IQD_CURRENT_PRIMARY: 1524 rc = -EBUSY; 1525 dev_err(&card->gdev->dev, 1526 "The device is already a primary Bridge Port\n"); 1527 break; 1528 case IPA_RC_SBP_OSA_NOT_AUTHD_BY_ZMAN: 1529 case IPA_RC_SBP_IQD_NOT_AUTHD_BY_ZMAN: 1530 rc = -EACCES; 1531 dev_err(&card->gdev->dev, 1532 "The device is not authorized to be a Bridge Port\n"); 1533 break; 1534 default: 1535 rc = -EIO; 1536 } 1537 } else { 1538 switch (ipa_rc) { 1539 case IPA_RC_NOTSUPP: 1540 rc = -EOPNOTSUPP; 1541 break; 1542 case IPA_RC_UNSUPPORTED_COMMAND: 1543 rc = -EOPNOTSUPP; 1544 break; 1545 default: 1546 rc = -EIO; 1547 } 1548 } 1549 1550 if (rc) { 1551 QETH_CARD_TEXT_(card, 2, "SBPi%04x", ipa_rc); 1552 QETH_CARD_TEXT_(card, 2, "SBPc%04x", sbp_rc); 1553 } 1554 return rc; 1555 } 1556 1557 static struct qeth_cmd_buffer *qeth_sbp_build_cmd(struct qeth_card *card, 1558 enum qeth_ipa_sbp_cmd sbp_cmd, 1559 unsigned int data_length) 1560 { 1561 enum qeth_ipa_cmds ipa_cmd = IS_IQD(card) ? IPA_CMD_SETBRIDGEPORT_IQD : 1562 IPA_CMD_SETBRIDGEPORT_OSA; 1563 struct qeth_ipacmd_sbp_hdr *hdr; 1564 struct qeth_cmd_buffer *iob; 1565 1566 iob = qeth_ipa_alloc_cmd(card, ipa_cmd, QETH_PROT_NONE, 1567 data_length + 1568 offsetof(struct qeth_ipacmd_setbridgeport, 1569 data)); 1570 if (!iob) 1571 return iob; 1572 1573 hdr = &__ipa_cmd(iob)->data.sbp.hdr; 1574 hdr->cmdlength = sizeof(*hdr) + data_length; 1575 hdr->command_code = sbp_cmd; 1576 hdr->used_total = 1; 1577 hdr->seq_no = 1; 1578 return iob; 1579 } 1580 1581 static int qeth_bridgeport_query_support_cb(struct qeth_card *card, 1582 struct qeth_reply *reply, unsigned long data) 1583 { 1584 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data; 1585 struct _qeth_sbp_cbctl *cbctl = (struct _qeth_sbp_cbctl *)reply->param; 1586 int rc; 1587 1588 QETH_CARD_TEXT(card, 2, "brqsupcb"); 1589 rc = qeth_bridgeport_makerc(card, cmd); 1590 if (rc) 1591 return rc; 1592 1593 cbctl->data.supported = 1594 cmd->data.sbp.data.query_cmds_supp.supported_cmds; 1595 return 0; 1596 } 1597 1598 /** 1599 * qeth_bridgeport_query_support() - store bitmask of supported subfunctions. 1600 * @card: qeth_card structure pointer. 1601 * 1602 * Sets bitmask of supported setbridgeport subfunctions in the qeth_card 1603 * strucutre: card->options.sbp.supported_funcs. 1604 */ 1605 static void qeth_bridgeport_query_support(struct qeth_card *card) 1606 { 1607 struct qeth_cmd_buffer *iob; 1608 struct _qeth_sbp_cbctl cbctl; 1609 1610 QETH_CARD_TEXT(card, 2, "brqsuppo"); 1611 iob = qeth_sbp_build_cmd(card, IPA_SBP_QUERY_COMMANDS_SUPPORTED, 1612 SBP_DATA_SIZEOF(query_cmds_supp)); 1613 if (!iob) 1614 return; 1615 1616 if (qeth_send_ipa_cmd(card, iob, qeth_bridgeport_query_support_cb, 1617 &cbctl)) { 1618 card->options.sbp.role = QETH_SBP_ROLE_NONE; 1619 card->options.sbp.supported_funcs = 0; 1620 return; 1621 } 1622 card->options.sbp.supported_funcs = cbctl.data.supported; 1623 } 1624 1625 static int qeth_bridgeport_query_ports_cb(struct qeth_card *card, 1626 struct qeth_reply *reply, unsigned long data) 1627 { 1628 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data; 1629 struct _qeth_sbp_cbctl *cbctl = (struct _qeth_sbp_cbctl *)reply->param; 1630 struct qeth_sbp_port_data *qports; 1631 int rc; 1632 1633 QETH_CARD_TEXT(card, 2, "brqprtcb"); 1634 rc = qeth_bridgeport_makerc(card, cmd); 1635 if (rc) 1636 return rc; 1637 1638 qports = &cmd->data.sbp.data.port_data; 1639 if (qports->entry_length != sizeof(struct qeth_sbp_port_entry)) { 1640 QETH_CARD_TEXT_(card, 2, "SBPs%04x", qports->entry_length); 1641 return -EINVAL; 1642 } 1643 /* first entry contains the state of the local port */ 1644 if (qports->num_entries > 0) { 1645 if (cbctl->data.qports.role) 1646 *cbctl->data.qports.role = qports->entry[0].role; 1647 if (cbctl->data.qports.state) 1648 *cbctl->data.qports.state = qports->entry[0].state; 1649 } 1650 return 0; 1651 } 1652 1653 /** 1654 * qeth_bridgeport_query_ports() - query local bridgeport status. 1655 * @card: qeth_card structure pointer. 1656 * @role: Role of the port: 0-none, 1-primary, 2-secondary. 1657 * @state: State of the port: 0-inactive, 1-standby, 2-active. 1658 * 1659 * Returns negative errno-compatible error indication or 0 on success. 1660 * 1661 * 'role' and 'state' are not updated in case of hardware operation failure. 1662 */ 1663 int qeth_bridgeport_query_ports(struct qeth_card *card, 1664 enum qeth_sbp_roles *role, enum qeth_sbp_states *state) 1665 { 1666 struct qeth_cmd_buffer *iob; 1667 struct _qeth_sbp_cbctl cbctl = { 1668 .data = { 1669 .qports = { 1670 .role = role, 1671 .state = state, 1672 }, 1673 }, 1674 }; 1675 1676 QETH_CARD_TEXT(card, 2, "brqports"); 1677 if (!(card->options.sbp.supported_funcs & IPA_SBP_QUERY_BRIDGE_PORTS)) 1678 return -EOPNOTSUPP; 1679 iob = qeth_sbp_build_cmd(card, IPA_SBP_QUERY_BRIDGE_PORTS, 0); 1680 if (!iob) 1681 return -ENOMEM; 1682 1683 return qeth_send_ipa_cmd(card, iob, qeth_bridgeport_query_ports_cb, 1684 &cbctl); 1685 } 1686 1687 static int qeth_bridgeport_set_cb(struct qeth_card *card, 1688 struct qeth_reply *reply, unsigned long data) 1689 { 1690 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *)data; 1691 1692 QETH_CARD_TEXT(card, 2, "brsetrcb"); 1693 return qeth_bridgeport_makerc(card, cmd); 1694 } 1695 1696 /** 1697 * qeth_bridgeport_setrole() - Assign primary role to the port. 1698 * @card: qeth_card structure pointer. 1699 * @role: Role to assign. 1700 * 1701 * Returns negative errno-compatible error indication or 0 on success. 1702 */ 1703 int qeth_bridgeport_setrole(struct qeth_card *card, enum qeth_sbp_roles role) 1704 { 1705 struct qeth_cmd_buffer *iob; 1706 enum qeth_ipa_sbp_cmd setcmd; 1707 unsigned int cmdlength = 0; 1708 1709 QETH_CARD_TEXT(card, 2, "brsetrol"); 1710 switch (role) { 1711 case QETH_SBP_ROLE_NONE: 1712 setcmd = IPA_SBP_RESET_BRIDGE_PORT_ROLE; 1713 break; 1714 case QETH_SBP_ROLE_PRIMARY: 1715 setcmd = IPA_SBP_SET_PRIMARY_BRIDGE_PORT; 1716 cmdlength = SBP_DATA_SIZEOF(set_primary); 1717 break; 1718 case QETH_SBP_ROLE_SECONDARY: 1719 setcmd = IPA_SBP_SET_SECONDARY_BRIDGE_PORT; 1720 break; 1721 default: 1722 return -EINVAL; 1723 } 1724 if (!(card->options.sbp.supported_funcs & setcmd)) 1725 return -EOPNOTSUPP; 1726 iob = qeth_sbp_build_cmd(card, setcmd, cmdlength); 1727 if (!iob) 1728 return -ENOMEM; 1729 1730 return qeth_send_ipa_cmd(card, iob, qeth_bridgeport_set_cb, NULL); 1731 } 1732 1733 static void qeth_bridgeport_an_set_cb(void *priv, 1734 struct chsc_pnso_naid_l2 *entry) 1735 { 1736 struct qeth_card *card = (struct qeth_card *)priv; 1737 u8 code; 1738 1739 code = IPA_ADDR_CHANGE_CODE_MACADDR; 1740 if (entry->addr_lnid.lnid < VLAN_N_VID) 1741 code |= IPA_ADDR_CHANGE_CODE_VLANID; 1742 qeth_bridge_emit_host_event(card, anev_reg_unreg, code, 1743 (struct net_if_token *)&entry->nit, 1744 (struct mac_addr_lnid *)&entry->addr_lnid); 1745 } 1746 1747 /** 1748 * qeth_bridgeport_an_set() - Enable or disable bridgeport address notification 1749 * @card: qeth_card structure pointer. 1750 * @enable: 0 - disable, non-zero - enable notifications 1751 * 1752 * Returns negative errno-compatible error indication or 0 on success. 1753 * 1754 * On enable, emits a series of address notifications udev events for all 1755 * currently registered hosts. 1756 */ 1757 int qeth_bridgeport_an_set(struct qeth_card *card, int enable) 1758 { 1759 int rc; 1760 1761 if (!card->options.sbp.supported_funcs) 1762 return -EOPNOTSUPP; 1763 1764 if (enable) { 1765 qeth_bridge_emit_host_event(card, anev_reset, 0, NULL, NULL); 1766 qeth_l2_set_pnso_mode(card, QETH_PNSO_BRIDGEPORT); 1767 rc = qeth_l2_pnso(card, PNSO_OC_NET_BRIDGE_INFO, 1, 1768 qeth_bridgeport_an_set_cb, card); 1769 if (rc) 1770 qeth_l2_set_pnso_mode(card, QETH_PNSO_NONE); 1771 } else { 1772 rc = qeth_l2_pnso(card, PNSO_OC_NET_BRIDGE_INFO, 0, NULL, NULL); 1773 qeth_l2_set_pnso_mode(card, QETH_PNSO_NONE); 1774 } 1775 return rc; 1776 } 1777 1778 /* VNIC Characteristics support */ 1779 1780 /* handle VNICC IPA command return codes; convert to error codes */ 1781 static int qeth_l2_vnicc_makerc(struct qeth_card *card, u16 ipa_rc) 1782 { 1783 int rc; 1784 1785 switch (ipa_rc) { 1786 case IPA_RC_SUCCESS: 1787 return ipa_rc; 1788 case IPA_RC_L2_UNSUPPORTED_CMD: 1789 case IPA_RC_NOTSUPP: 1790 rc = -EOPNOTSUPP; 1791 break; 1792 case IPA_RC_VNICC_OOSEQ: 1793 rc = -EALREADY; 1794 break; 1795 case IPA_RC_VNICC_VNICBP: 1796 rc = -EBUSY; 1797 break; 1798 case IPA_RC_L2_ADDR_TABLE_FULL: 1799 rc = -ENOSPC; 1800 break; 1801 case IPA_RC_L2_MAC_NOT_AUTH_BY_ADP: 1802 rc = -EACCES; 1803 break; 1804 default: 1805 rc = -EIO; 1806 } 1807 1808 QETH_CARD_TEXT_(card, 2, "err%04x", ipa_rc); 1809 return rc; 1810 } 1811 1812 /* generic VNICC request call back */ 1813 static int qeth_l2_vnicc_request_cb(struct qeth_card *card, 1814 struct qeth_reply *reply, 1815 unsigned long data) 1816 { 1817 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data; 1818 struct qeth_ipacmd_vnicc *rep = &cmd->data.vnicc; 1819 u32 sub_cmd = cmd->data.vnicc.hdr.sub_command; 1820 1821 QETH_CARD_TEXT(card, 2, "vniccrcb"); 1822 if (cmd->hdr.return_code) 1823 return qeth_l2_vnicc_makerc(card, cmd->hdr.return_code); 1824 /* return results to caller */ 1825 card->options.vnicc.sup_chars = rep->vnicc_cmds.supported; 1826 card->options.vnicc.cur_chars = rep->vnicc_cmds.enabled; 1827 1828 if (sub_cmd == IPA_VNICC_QUERY_CMDS) 1829 *(u32 *)reply->param = rep->data.query_cmds.sup_cmds; 1830 else if (sub_cmd == IPA_VNICC_GET_TIMEOUT) 1831 *(u32 *)reply->param = rep->data.getset_timeout.timeout; 1832 1833 return 0; 1834 } 1835 1836 static struct qeth_cmd_buffer *qeth_l2_vnicc_build_cmd(struct qeth_card *card, 1837 u32 vnicc_cmd, 1838 unsigned int data_length) 1839 { 1840 struct qeth_ipacmd_vnicc_hdr *hdr; 1841 struct qeth_cmd_buffer *iob; 1842 1843 iob = qeth_ipa_alloc_cmd(card, IPA_CMD_VNICC, QETH_PROT_NONE, 1844 data_length + 1845 offsetof(struct qeth_ipacmd_vnicc, data)); 1846 if (!iob) 1847 return NULL; 1848 1849 hdr = &__ipa_cmd(iob)->data.vnicc.hdr; 1850 hdr->data_length = sizeof(*hdr) + data_length; 1851 hdr->sub_command = vnicc_cmd; 1852 return iob; 1853 } 1854 1855 /* VNICC query VNIC characteristics request */ 1856 static int qeth_l2_vnicc_query_chars(struct qeth_card *card) 1857 { 1858 struct qeth_cmd_buffer *iob; 1859 1860 QETH_CARD_TEXT(card, 2, "vniccqch"); 1861 iob = qeth_l2_vnicc_build_cmd(card, IPA_VNICC_QUERY_CHARS, 0); 1862 if (!iob) 1863 return -ENOMEM; 1864 1865 return qeth_send_ipa_cmd(card, iob, qeth_l2_vnicc_request_cb, NULL); 1866 } 1867 1868 /* VNICC query sub commands request */ 1869 static int qeth_l2_vnicc_query_cmds(struct qeth_card *card, u32 vnic_char, 1870 u32 *sup_cmds) 1871 { 1872 struct qeth_cmd_buffer *iob; 1873 1874 QETH_CARD_TEXT(card, 2, "vniccqcm"); 1875 iob = qeth_l2_vnicc_build_cmd(card, IPA_VNICC_QUERY_CMDS, 1876 VNICC_DATA_SIZEOF(query_cmds)); 1877 if (!iob) 1878 return -ENOMEM; 1879 1880 __ipa_cmd(iob)->data.vnicc.data.query_cmds.vnic_char = vnic_char; 1881 1882 return qeth_send_ipa_cmd(card, iob, qeth_l2_vnicc_request_cb, sup_cmds); 1883 } 1884 1885 /* VNICC enable/disable characteristic request */ 1886 static int qeth_l2_vnicc_set_char(struct qeth_card *card, u32 vnic_char, 1887 u32 cmd) 1888 { 1889 struct qeth_cmd_buffer *iob; 1890 1891 QETH_CARD_TEXT(card, 2, "vniccedc"); 1892 iob = qeth_l2_vnicc_build_cmd(card, cmd, VNICC_DATA_SIZEOF(set_char)); 1893 if (!iob) 1894 return -ENOMEM; 1895 1896 __ipa_cmd(iob)->data.vnicc.data.set_char.vnic_char = vnic_char; 1897 1898 return qeth_send_ipa_cmd(card, iob, qeth_l2_vnicc_request_cb, NULL); 1899 } 1900 1901 /* VNICC get/set timeout for characteristic request */ 1902 static int qeth_l2_vnicc_getset_timeout(struct qeth_card *card, u32 vnicc, 1903 u32 cmd, u32 *timeout) 1904 { 1905 struct qeth_vnicc_getset_timeout *getset_timeout; 1906 struct qeth_cmd_buffer *iob; 1907 1908 QETH_CARD_TEXT(card, 2, "vniccgst"); 1909 iob = qeth_l2_vnicc_build_cmd(card, cmd, 1910 VNICC_DATA_SIZEOF(getset_timeout)); 1911 if (!iob) 1912 return -ENOMEM; 1913 1914 getset_timeout = &__ipa_cmd(iob)->data.vnicc.data.getset_timeout; 1915 getset_timeout->vnic_char = vnicc; 1916 1917 if (cmd == IPA_VNICC_SET_TIMEOUT) 1918 getset_timeout->timeout = *timeout; 1919 1920 return qeth_send_ipa_cmd(card, iob, qeth_l2_vnicc_request_cb, timeout); 1921 } 1922 1923 /* recover user timeout setting */ 1924 static bool qeth_l2_vnicc_recover_timeout(struct qeth_card *card, u32 vnicc, 1925 u32 *timeout) 1926 { 1927 if (card->options.vnicc.sup_chars & vnicc && 1928 card->options.vnicc.getset_timeout_sup & vnicc && 1929 !qeth_l2_vnicc_getset_timeout(card, vnicc, IPA_VNICC_SET_TIMEOUT, 1930 timeout)) 1931 return false; 1932 *timeout = QETH_VNICC_DEFAULT_TIMEOUT; 1933 return true; 1934 } 1935 1936 /* set current VNICC flag state; called from sysfs store function */ 1937 int qeth_l2_vnicc_set_state(struct qeth_card *card, u32 vnicc, bool state) 1938 { 1939 int rc = 0; 1940 u32 cmd; 1941 1942 QETH_CARD_TEXT(card, 2, "vniccsch"); 1943 1944 /* check if characteristic and enable/disable are supported */ 1945 if (!(card->options.vnicc.sup_chars & vnicc) || 1946 !(card->options.vnicc.set_char_sup & vnicc)) 1947 return -EOPNOTSUPP; 1948 1949 if (qeth_bridgeport_is_in_use(card)) 1950 return -EBUSY; 1951 1952 /* set enable/disable command and store wanted characteristic */ 1953 if (state) { 1954 cmd = IPA_VNICC_ENABLE; 1955 card->options.vnicc.wanted_chars |= vnicc; 1956 } else { 1957 cmd = IPA_VNICC_DISABLE; 1958 card->options.vnicc.wanted_chars &= ~vnicc; 1959 } 1960 1961 /* do we need to do anything? */ 1962 if (card->options.vnicc.cur_chars == card->options.vnicc.wanted_chars) 1963 return rc; 1964 1965 /* if card is not ready, simply stop here */ 1966 if (!qeth_card_hw_is_reachable(card)) { 1967 if (state) 1968 card->options.vnicc.cur_chars |= vnicc; 1969 else 1970 card->options.vnicc.cur_chars &= ~vnicc; 1971 return rc; 1972 } 1973 1974 rc = qeth_l2_vnicc_set_char(card, vnicc, cmd); 1975 if (rc) 1976 card->options.vnicc.wanted_chars = 1977 card->options.vnicc.cur_chars; 1978 else { 1979 /* successful online VNICC change; handle special cases */ 1980 if (state && vnicc == QETH_VNICC_RX_BCAST) 1981 card->options.vnicc.rx_bcast_enabled = true; 1982 if (!state && vnicc == QETH_VNICC_LEARNING) 1983 qeth_l2_vnicc_recover_timeout(card, vnicc, 1984 &card->options.vnicc.learning_timeout); 1985 } 1986 1987 return rc; 1988 } 1989 1990 /* get current VNICC flag state; called from sysfs show function */ 1991 int qeth_l2_vnicc_get_state(struct qeth_card *card, u32 vnicc, bool *state) 1992 { 1993 int rc = 0; 1994 1995 QETH_CARD_TEXT(card, 2, "vniccgch"); 1996 1997 /* check if characteristic is supported */ 1998 if (!(card->options.vnicc.sup_chars & vnicc)) 1999 return -EOPNOTSUPP; 2000 2001 if (qeth_bridgeport_is_in_use(card)) 2002 return -EBUSY; 2003 2004 /* if card is ready, query current VNICC state */ 2005 if (qeth_card_hw_is_reachable(card)) 2006 rc = qeth_l2_vnicc_query_chars(card); 2007 2008 *state = (card->options.vnicc.cur_chars & vnicc) ? true : false; 2009 return rc; 2010 } 2011 2012 /* set VNICC timeout; called from sysfs store function. Currently, only learning 2013 * supports timeout 2014 */ 2015 int qeth_l2_vnicc_set_timeout(struct qeth_card *card, u32 timeout) 2016 { 2017 int rc = 0; 2018 2019 QETH_CARD_TEXT(card, 2, "vniccsto"); 2020 2021 /* check if characteristic and set_timeout are supported */ 2022 if (!(card->options.vnicc.sup_chars & QETH_VNICC_LEARNING) || 2023 !(card->options.vnicc.getset_timeout_sup & QETH_VNICC_LEARNING)) 2024 return -EOPNOTSUPP; 2025 2026 if (qeth_bridgeport_is_in_use(card)) 2027 return -EBUSY; 2028 2029 /* do we need to do anything? */ 2030 if (card->options.vnicc.learning_timeout == timeout) 2031 return rc; 2032 2033 /* if card is not ready, simply store the value internally and return */ 2034 if (!qeth_card_hw_is_reachable(card)) { 2035 card->options.vnicc.learning_timeout = timeout; 2036 return rc; 2037 } 2038 2039 /* send timeout value to card; if successful, store value internally */ 2040 rc = qeth_l2_vnicc_getset_timeout(card, QETH_VNICC_LEARNING, 2041 IPA_VNICC_SET_TIMEOUT, &timeout); 2042 if (!rc) 2043 card->options.vnicc.learning_timeout = timeout; 2044 2045 return rc; 2046 } 2047 2048 /* get current VNICC timeout; called from sysfs show function. Currently, only 2049 * learning supports timeout 2050 */ 2051 int qeth_l2_vnicc_get_timeout(struct qeth_card *card, u32 *timeout) 2052 { 2053 int rc = 0; 2054 2055 QETH_CARD_TEXT(card, 2, "vniccgto"); 2056 2057 /* check if characteristic and get_timeout are supported */ 2058 if (!(card->options.vnicc.sup_chars & QETH_VNICC_LEARNING) || 2059 !(card->options.vnicc.getset_timeout_sup & QETH_VNICC_LEARNING)) 2060 return -EOPNOTSUPP; 2061 2062 if (qeth_bridgeport_is_in_use(card)) 2063 return -EBUSY; 2064 2065 /* if card is ready, get timeout. Otherwise, just return stored value */ 2066 *timeout = card->options.vnicc.learning_timeout; 2067 if (qeth_card_hw_is_reachable(card)) 2068 rc = qeth_l2_vnicc_getset_timeout(card, QETH_VNICC_LEARNING, 2069 IPA_VNICC_GET_TIMEOUT, 2070 timeout); 2071 2072 return rc; 2073 } 2074 2075 /* check if VNICC is currently enabled */ 2076 static bool _qeth_l2_vnicc_is_in_use(struct qeth_card *card) 2077 { 2078 if (!card->options.vnicc.sup_chars) 2079 return false; 2080 /* default values are only OK if rx_bcast was not enabled by user 2081 * or the card is offline. 2082 */ 2083 if (card->options.vnicc.cur_chars == QETH_VNICC_DEFAULT) { 2084 if (!card->options.vnicc.rx_bcast_enabled || 2085 !qeth_card_hw_is_reachable(card)) 2086 return false; 2087 } 2088 return true; 2089 } 2090 2091 /** 2092 * qeth_bridgeport_allowed - are any qeth_bridgeport functions allowed? 2093 * @card: qeth_card structure pointer 2094 * 2095 * qeth_bridgeport functionality is mutually exclusive with usage of the 2096 * VNIC Characteristics and dev2br address notifications 2097 */ 2098 bool qeth_bridgeport_allowed(struct qeth_card *card) 2099 { 2100 struct qeth_priv *priv = netdev_priv(card->dev); 2101 2102 return (!_qeth_l2_vnicc_is_in_use(card) && 2103 !(priv->brport_features & BR_LEARNING_SYNC)); 2104 } 2105 2106 /* recover user characteristic setting */ 2107 static bool qeth_l2_vnicc_recover_char(struct qeth_card *card, u32 vnicc, 2108 bool enable) 2109 { 2110 u32 cmd = enable ? IPA_VNICC_ENABLE : IPA_VNICC_DISABLE; 2111 2112 if (card->options.vnicc.sup_chars & vnicc && 2113 card->options.vnicc.set_char_sup & vnicc && 2114 !qeth_l2_vnicc_set_char(card, vnicc, cmd)) 2115 return false; 2116 card->options.vnicc.wanted_chars &= ~vnicc; 2117 card->options.vnicc.wanted_chars |= QETH_VNICC_DEFAULT & vnicc; 2118 return true; 2119 } 2120 2121 /* (re-)initialize VNICC */ 2122 static void qeth_l2_vnicc_init(struct qeth_card *card) 2123 { 2124 u32 *timeout = &card->options.vnicc.learning_timeout; 2125 bool enable, error = false; 2126 unsigned int chars_len, i; 2127 unsigned long chars_tmp; 2128 u32 sup_cmds, vnicc; 2129 2130 QETH_CARD_TEXT(card, 2, "vniccini"); 2131 /* reset rx_bcast */ 2132 card->options.vnicc.rx_bcast_enabled = 0; 2133 /* initial query and storage of VNIC characteristics */ 2134 if (qeth_l2_vnicc_query_chars(card)) { 2135 if (card->options.vnicc.wanted_chars != QETH_VNICC_DEFAULT || 2136 *timeout != QETH_VNICC_DEFAULT_TIMEOUT) 2137 dev_err(&card->gdev->dev, "Configuring the VNIC characteristics failed\n"); 2138 /* fail quietly if user didn't change the default config */ 2139 card->options.vnicc.sup_chars = 0; 2140 card->options.vnicc.cur_chars = 0; 2141 card->options.vnicc.wanted_chars = QETH_VNICC_DEFAULT; 2142 return; 2143 } 2144 /* get supported commands for each supported characteristic */ 2145 chars_tmp = card->options.vnicc.sup_chars; 2146 chars_len = sizeof(card->options.vnicc.sup_chars) * BITS_PER_BYTE; 2147 for_each_set_bit(i, &chars_tmp, chars_len) { 2148 vnicc = BIT(i); 2149 if (qeth_l2_vnicc_query_cmds(card, vnicc, &sup_cmds)) { 2150 sup_cmds = 0; 2151 error = true; 2152 } 2153 if ((sup_cmds & IPA_VNICC_SET_TIMEOUT) && 2154 (sup_cmds & IPA_VNICC_GET_TIMEOUT)) 2155 card->options.vnicc.getset_timeout_sup |= vnicc; 2156 else 2157 card->options.vnicc.getset_timeout_sup &= ~vnicc; 2158 if ((sup_cmds & IPA_VNICC_ENABLE) && 2159 (sup_cmds & IPA_VNICC_DISABLE)) 2160 card->options.vnicc.set_char_sup |= vnicc; 2161 else 2162 card->options.vnicc.set_char_sup &= ~vnicc; 2163 } 2164 /* enforce assumed default values and recover settings, if changed */ 2165 error |= qeth_l2_vnicc_recover_timeout(card, QETH_VNICC_LEARNING, 2166 timeout); 2167 /* Change chars, if necessary */ 2168 chars_tmp = card->options.vnicc.wanted_chars ^ 2169 card->options.vnicc.cur_chars; 2170 chars_len = sizeof(card->options.vnicc.wanted_chars) * BITS_PER_BYTE; 2171 for_each_set_bit(i, &chars_tmp, chars_len) { 2172 vnicc = BIT(i); 2173 enable = card->options.vnicc.wanted_chars & vnicc; 2174 error |= qeth_l2_vnicc_recover_char(card, vnicc, enable); 2175 } 2176 if (error) 2177 dev_err(&card->gdev->dev, "Configuring the VNIC characteristics failed\n"); 2178 } 2179 2180 /* configure default values of VNIC characteristics */ 2181 static void qeth_l2_vnicc_set_defaults(struct qeth_card *card) 2182 { 2183 /* characteristics values */ 2184 card->options.vnicc.sup_chars = QETH_VNICC_ALL; 2185 card->options.vnicc.cur_chars = QETH_VNICC_DEFAULT; 2186 card->options.vnicc.learning_timeout = QETH_VNICC_DEFAULT_TIMEOUT; 2187 /* supported commands */ 2188 card->options.vnicc.set_char_sup = QETH_VNICC_ALL; 2189 card->options.vnicc.getset_timeout_sup = QETH_VNICC_LEARNING; 2190 /* settings wanted by users */ 2191 card->options.vnicc.wanted_chars = QETH_VNICC_DEFAULT; 2192 } 2193 2194 static const struct device_type qeth_l2_devtype = { 2195 .name = "qeth_layer2", 2196 .groups = qeth_l2_attr_groups, 2197 }; 2198 2199 static int qeth_l2_probe_device(struct ccwgroup_device *gdev) 2200 { 2201 struct qeth_card *card = dev_get_drvdata(&gdev->dev); 2202 int rc; 2203 2204 if (IS_OSN(card)) 2205 dev_notice(&gdev->dev, "OSN support will be dropped in 2021\n"); 2206 2207 qeth_l2_vnicc_set_defaults(card); 2208 mutex_init(&card->sbp_lock); 2209 2210 if (gdev->dev.type == &qeth_generic_devtype) { 2211 rc = qeth_l2_create_device_attributes(&gdev->dev); 2212 if (rc) 2213 return rc; 2214 } 2215 2216 INIT_WORK(&card->rx_mode_work, qeth_l2_rx_mode_work); 2217 return 0; 2218 } 2219 2220 static void qeth_l2_remove_device(struct ccwgroup_device *gdev) 2221 { 2222 struct qeth_card *card = dev_get_drvdata(&gdev->dev); 2223 2224 if (gdev->dev.type == &qeth_generic_devtype) 2225 qeth_l2_remove_device_attributes(&gdev->dev); 2226 qeth_set_allowed_threads(card, 0, 1); 2227 wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0); 2228 2229 if (gdev->state == CCWGROUP_ONLINE) 2230 qeth_set_offline(card, false); 2231 2232 cancel_work_sync(&card->close_dev_work); 2233 if (card->dev->reg_state == NETREG_REGISTERED) 2234 unregister_netdev(card->dev); 2235 } 2236 2237 static int qeth_l2_set_online(struct qeth_card *card, bool carrier_ok) 2238 { 2239 struct net_device *dev = card->dev; 2240 int rc = 0; 2241 2242 /* query before bridgeport_notification may be enabled */ 2243 qeth_l2_detect_dev2br_support(card); 2244 2245 mutex_lock(&card->sbp_lock); 2246 qeth_bridgeport_query_support(card); 2247 if (card->options.sbp.supported_funcs) { 2248 qeth_l2_setup_bridgeport_attrs(card); 2249 dev_info(&card->gdev->dev, 2250 "The device represents a Bridge Capable Port\n"); 2251 } 2252 mutex_unlock(&card->sbp_lock); 2253 2254 qeth_l2_register_dev_addr(card); 2255 2256 /* for the rx_bcast characteristic, init VNICC after setmac */ 2257 qeth_l2_vnicc_init(card); 2258 2259 qeth_l2_trace_features(card); 2260 2261 /* softsetup */ 2262 QETH_CARD_TEXT(card, 2, "softsetp"); 2263 2264 card->state = CARD_STATE_SOFTSETUP; 2265 2266 qeth_set_allowed_threads(card, 0xffffffff, 0); 2267 2268 if (dev->reg_state != NETREG_REGISTERED) { 2269 rc = qeth_l2_setup_netdev(card); 2270 if (rc) 2271 goto err_setup; 2272 2273 if (carrier_ok) 2274 netif_carrier_on(dev); 2275 } else { 2276 rtnl_lock(); 2277 if (carrier_ok) 2278 netif_carrier_on(dev); 2279 else 2280 netif_carrier_off(dev); 2281 2282 netif_device_attach(dev); 2283 qeth_enable_hw_features(dev); 2284 qeth_l2_enable_brport_features(card); 2285 2286 if (card->info.open_when_online) { 2287 card->info.open_when_online = 0; 2288 dev_open(dev, NULL); 2289 } 2290 rtnl_unlock(); 2291 } 2292 return 0; 2293 2294 err_setup: 2295 qeth_set_allowed_threads(card, 0, 1); 2296 card->state = CARD_STATE_DOWN; 2297 return rc; 2298 } 2299 2300 static void qeth_l2_set_offline(struct qeth_card *card) 2301 { 2302 struct qeth_priv *priv = netdev_priv(card->dev); 2303 2304 qeth_set_allowed_threads(card, 0, 1); 2305 qeth_l2_drain_rx_mode_cache(card); 2306 2307 if (card->state == CARD_STATE_SOFTSETUP) 2308 card->state = CARD_STATE_DOWN; 2309 2310 qeth_l2_set_pnso_mode(card, QETH_PNSO_NONE); 2311 if (priv->brport_features & BR_LEARNING_SYNC) { 2312 rtnl_lock(); 2313 qeth_l2_dev2br_fdb_flush(card); 2314 rtnl_unlock(); 2315 } 2316 } 2317 2318 /* Returns zero if the command is successfully "consumed" */ 2319 static int qeth_l2_control_event(struct qeth_card *card, 2320 struct qeth_ipa_cmd *cmd) 2321 { 2322 switch (cmd->hdr.command) { 2323 case IPA_CMD_SETBRIDGEPORT_OSA: 2324 case IPA_CMD_SETBRIDGEPORT_IQD: 2325 if (cmd->data.sbp.hdr.command_code == 2326 IPA_SBP_BRIDGE_PORT_STATE_CHANGE) { 2327 qeth_bridge_state_change(card, cmd); 2328 return 0; 2329 } 2330 2331 return 1; 2332 case IPA_CMD_ADDRESS_CHANGE_NOTIF: 2333 qeth_addr_change_event(card, cmd); 2334 return 0; 2335 default: 2336 return 1; 2337 } 2338 } 2339 2340 struct qeth_discipline qeth_l2_discipline = { 2341 .devtype = &qeth_l2_devtype, 2342 .setup = qeth_l2_probe_device, 2343 .remove = qeth_l2_remove_device, 2344 .set_online = qeth_l2_set_online, 2345 .set_offline = qeth_l2_set_offline, 2346 .do_ioctl = NULL, 2347 .control_event_handler = qeth_l2_control_event, 2348 }; 2349 EXPORT_SYMBOL_GPL(qeth_l2_discipline); 2350 2351 static int __init qeth_l2_init(void) 2352 { 2353 pr_info("register layer 2 discipline\n"); 2354 return 0; 2355 } 2356 2357 static void __exit qeth_l2_exit(void) 2358 { 2359 pr_info("unregister layer 2 discipline\n"); 2360 } 2361 2362 module_init(qeth_l2_init); 2363 module_exit(qeth_l2_exit); 2364 MODULE_AUTHOR("Frank Blaschka <frank.blaschka@de.ibm.com>"); 2365 MODULE_DESCRIPTION("qeth layer 2 discipline"); 2366 MODULE_LICENSE("GPL"); 2367