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