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/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(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 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(sizeof(*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); 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(sizeof(*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 } qports; 1549 } data; 1550 }; 1551 1552 static int qeth_bridgeport_makerc(struct qeth_card *card, 1553 struct qeth_ipa_cmd *cmd) 1554 { 1555 struct qeth_ipacmd_setbridgeport *sbp = &cmd->data.sbp; 1556 enum qeth_ipa_sbp_cmd setcmd = sbp->hdr.command_code; 1557 u16 ipa_rc = cmd->hdr.return_code; 1558 u16 sbp_rc = sbp->hdr.return_code; 1559 int rc; 1560 1561 if (ipa_rc == IPA_RC_SUCCESS && sbp_rc == IPA_RC_SUCCESS) 1562 return 0; 1563 1564 if ((IS_IQD(card) && ipa_rc == IPA_RC_SUCCESS) || 1565 (!IS_IQD(card) && ipa_rc == sbp_rc)) { 1566 switch (sbp_rc) { 1567 case IPA_RC_SUCCESS: 1568 rc = 0; 1569 break; 1570 case IPA_RC_L2_UNSUPPORTED_CMD: 1571 case IPA_RC_UNSUPPORTED_COMMAND: 1572 rc = -EOPNOTSUPP; 1573 break; 1574 case IPA_RC_SBP_OSA_NOT_CONFIGURED: 1575 case IPA_RC_SBP_IQD_NOT_CONFIGURED: 1576 rc = -ENODEV; /* maybe not the best code here? */ 1577 dev_err(&card->gdev->dev, 1578 "The device is not configured as a Bridge Port\n"); 1579 break; 1580 case IPA_RC_SBP_OSA_OS_MISMATCH: 1581 case IPA_RC_SBP_IQD_OS_MISMATCH: 1582 rc = -EPERM; 1583 dev_err(&card->gdev->dev, 1584 "A Bridge Port is already configured by a different operating system\n"); 1585 break; 1586 case IPA_RC_SBP_OSA_ANO_DEV_PRIMARY: 1587 case IPA_RC_SBP_IQD_ANO_DEV_PRIMARY: 1588 switch (setcmd) { 1589 case IPA_SBP_SET_PRIMARY_BRIDGE_PORT: 1590 rc = -EEXIST; 1591 dev_err(&card->gdev->dev, 1592 "The LAN already has a primary Bridge Port\n"); 1593 break; 1594 case IPA_SBP_SET_SECONDARY_BRIDGE_PORT: 1595 rc = -EBUSY; 1596 dev_err(&card->gdev->dev, 1597 "The device is already a primary Bridge Port\n"); 1598 break; 1599 default: 1600 rc = -EIO; 1601 } 1602 break; 1603 case IPA_RC_SBP_OSA_CURRENT_SECOND: 1604 case IPA_RC_SBP_IQD_CURRENT_SECOND: 1605 rc = -EBUSY; 1606 dev_err(&card->gdev->dev, 1607 "The device is already a secondary Bridge Port\n"); 1608 break; 1609 case IPA_RC_SBP_OSA_LIMIT_SECOND: 1610 case IPA_RC_SBP_IQD_LIMIT_SECOND: 1611 rc = -EEXIST; 1612 dev_err(&card->gdev->dev, 1613 "The LAN cannot have more secondary Bridge Ports\n"); 1614 break; 1615 case IPA_RC_SBP_OSA_CURRENT_PRIMARY: 1616 case IPA_RC_SBP_IQD_CURRENT_PRIMARY: 1617 rc = -EBUSY; 1618 dev_err(&card->gdev->dev, 1619 "The device is already a primary Bridge Port\n"); 1620 break; 1621 case IPA_RC_SBP_OSA_NOT_AUTHD_BY_ZMAN: 1622 case IPA_RC_SBP_IQD_NOT_AUTHD_BY_ZMAN: 1623 rc = -EACCES; 1624 dev_err(&card->gdev->dev, 1625 "The device is not authorized to be a Bridge Port\n"); 1626 break; 1627 default: 1628 rc = -EIO; 1629 } 1630 } else { 1631 switch (ipa_rc) { 1632 case IPA_RC_NOTSUPP: 1633 rc = -EOPNOTSUPP; 1634 break; 1635 case IPA_RC_UNSUPPORTED_COMMAND: 1636 rc = -EOPNOTSUPP; 1637 break; 1638 default: 1639 rc = -EIO; 1640 } 1641 } 1642 1643 if (rc) { 1644 QETH_CARD_TEXT_(card, 2, "SBPi%04x", ipa_rc); 1645 QETH_CARD_TEXT_(card, 2, "SBPc%04x", sbp_rc); 1646 } 1647 return rc; 1648 } 1649 1650 static struct qeth_cmd_buffer *qeth_sbp_build_cmd(struct qeth_card *card, 1651 enum qeth_ipa_sbp_cmd sbp_cmd, 1652 unsigned int data_length) 1653 { 1654 enum qeth_ipa_cmds ipa_cmd = IS_IQD(card) ? IPA_CMD_SETBRIDGEPORT_IQD : 1655 IPA_CMD_SETBRIDGEPORT_OSA; 1656 struct qeth_ipacmd_sbp_hdr *hdr; 1657 struct qeth_cmd_buffer *iob; 1658 1659 iob = qeth_ipa_alloc_cmd(card, ipa_cmd, QETH_PROT_NONE, 1660 data_length + 1661 offsetof(struct qeth_ipacmd_setbridgeport, 1662 data)); 1663 if (!iob) 1664 return iob; 1665 1666 hdr = &__ipa_cmd(iob)->data.sbp.hdr; 1667 hdr->cmdlength = sizeof(*hdr) + data_length; 1668 hdr->command_code = sbp_cmd; 1669 hdr->used_total = 1; 1670 hdr->seq_no = 1; 1671 return iob; 1672 } 1673 1674 static int qeth_bridgeport_query_support_cb(struct qeth_card *card, 1675 struct qeth_reply *reply, unsigned long data) 1676 { 1677 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data; 1678 struct _qeth_sbp_cbctl *cbctl = (struct _qeth_sbp_cbctl *)reply->param; 1679 int rc; 1680 1681 QETH_CARD_TEXT(card, 2, "brqsupcb"); 1682 rc = qeth_bridgeport_makerc(card, cmd); 1683 if (rc) 1684 return rc; 1685 1686 cbctl->data.supported = 1687 cmd->data.sbp.data.query_cmds_supp.supported_cmds; 1688 return 0; 1689 } 1690 1691 /** 1692 * qeth_bridgeport_query_support() - store bitmask of supported subfunctions. 1693 * @card: qeth_card structure pointer. 1694 * 1695 * Sets bitmask of supported setbridgeport subfunctions in the qeth_card 1696 * strucutre: card->options.sbp.supported_funcs. 1697 */ 1698 static void qeth_bridgeport_query_support(struct qeth_card *card) 1699 { 1700 struct qeth_cmd_buffer *iob; 1701 struct _qeth_sbp_cbctl cbctl; 1702 1703 QETH_CARD_TEXT(card, 2, "brqsuppo"); 1704 iob = qeth_sbp_build_cmd(card, IPA_SBP_QUERY_COMMANDS_SUPPORTED, 1705 SBP_DATA_SIZEOF(query_cmds_supp)); 1706 if (!iob) 1707 return; 1708 1709 if (qeth_send_ipa_cmd(card, iob, qeth_bridgeport_query_support_cb, 1710 &cbctl)) { 1711 card->options.sbp.role = QETH_SBP_ROLE_NONE; 1712 card->options.sbp.supported_funcs = 0; 1713 return; 1714 } 1715 card->options.sbp.supported_funcs = cbctl.data.supported; 1716 } 1717 1718 static int qeth_bridgeport_query_ports_cb(struct qeth_card *card, 1719 struct qeth_reply *reply, unsigned long data) 1720 { 1721 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data; 1722 struct _qeth_sbp_cbctl *cbctl = (struct _qeth_sbp_cbctl *)reply->param; 1723 struct qeth_sbp_port_data *qports; 1724 int rc; 1725 1726 QETH_CARD_TEXT(card, 2, "brqprtcb"); 1727 rc = qeth_bridgeport_makerc(card, cmd); 1728 if (rc) 1729 return rc; 1730 1731 qports = &cmd->data.sbp.data.port_data; 1732 if (qports->entry_length != sizeof(struct qeth_sbp_port_entry)) { 1733 QETH_CARD_TEXT_(card, 2, "SBPs%04x", qports->entry_length); 1734 return -EINVAL; 1735 } 1736 /* first entry contains the state of the local port */ 1737 if (qports->num_entries > 0) { 1738 if (cbctl->data.qports.role) 1739 *cbctl->data.qports.role = qports->entry[0].role; 1740 if (cbctl->data.qports.state) 1741 *cbctl->data.qports.state = qports->entry[0].state; 1742 } 1743 return 0; 1744 } 1745 1746 /** 1747 * qeth_bridgeport_query_ports() - query local bridgeport status. 1748 * @card: qeth_card structure pointer. 1749 * @role: Role of the port: 0-none, 1-primary, 2-secondary. 1750 * @state: State of the port: 0-inactive, 1-standby, 2-active. 1751 * 1752 * Returns negative errno-compatible error indication or 0 on success. 1753 * 1754 * 'role' and 'state' are not updated in case of hardware operation failure. 1755 */ 1756 int qeth_bridgeport_query_ports(struct qeth_card *card, 1757 enum qeth_sbp_roles *role, enum qeth_sbp_states *state) 1758 { 1759 struct qeth_cmd_buffer *iob; 1760 struct _qeth_sbp_cbctl cbctl = { 1761 .data = { 1762 .qports = { 1763 .role = role, 1764 .state = state, 1765 }, 1766 }, 1767 }; 1768 1769 QETH_CARD_TEXT(card, 2, "brqports"); 1770 if (!(card->options.sbp.supported_funcs & IPA_SBP_QUERY_BRIDGE_PORTS)) 1771 return -EOPNOTSUPP; 1772 iob = qeth_sbp_build_cmd(card, IPA_SBP_QUERY_BRIDGE_PORTS, 0); 1773 if (!iob) 1774 return -ENOMEM; 1775 1776 return qeth_send_ipa_cmd(card, iob, qeth_bridgeport_query_ports_cb, 1777 &cbctl); 1778 } 1779 1780 static int qeth_bridgeport_set_cb(struct qeth_card *card, 1781 struct qeth_reply *reply, unsigned long data) 1782 { 1783 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *)data; 1784 1785 QETH_CARD_TEXT(card, 2, "brsetrcb"); 1786 return qeth_bridgeport_makerc(card, cmd); 1787 } 1788 1789 /** 1790 * qeth_bridgeport_setrole() - Assign primary role to the port. 1791 * @card: qeth_card structure pointer. 1792 * @role: Role to assign. 1793 * 1794 * Returns negative errno-compatible error indication or 0 on success. 1795 */ 1796 int qeth_bridgeport_setrole(struct qeth_card *card, enum qeth_sbp_roles role) 1797 { 1798 struct qeth_cmd_buffer *iob; 1799 enum qeth_ipa_sbp_cmd setcmd; 1800 unsigned int cmdlength = 0; 1801 1802 QETH_CARD_TEXT(card, 2, "brsetrol"); 1803 switch (role) { 1804 case QETH_SBP_ROLE_NONE: 1805 setcmd = IPA_SBP_RESET_BRIDGE_PORT_ROLE; 1806 break; 1807 case QETH_SBP_ROLE_PRIMARY: 1808 setcmd = IPA_SBP_SET_PRIMARY_BRIDGE_PORT; 1809 cmdlength = SBP_DATA_SIZEOF(set_primary); 1810 break; 1811 case QETH_SBP_ROLE_SECONDARY: 1812 setcmd = IPA_SBP_SET_SECONDARY_BRIDGE_PORT; 1813 break; 1814 default: 1815 return -EINVAL; 1816 } 1817 if (!(card->options.sbp.supported_funcs & setcmd)) 1818 return -EOPNOTSUPP; 1819 iob = qeth_sbp_build_cmd(card, setcmd, cmdlength); 1820 if (!iob) 1821 return -ENOMEM; 1822 1823 return qeth_send_ipa_cmd(card, iob, qeth_bridgeport_set_cb, NULL); 1824 } 1825 1826 static void qeth_bridgeport_an_set_cb(void *priv, 1827 struct chsc_pnso_naid_l2 *entry) 1828 { 1829 struct qeth_card *card = (struct qeth_card *)priv; 1830 u8 code; 1831 1832 code = IPA_ADDR_CHANGE_CODE_MACADDR; 1833 if (entry->addr_lnid.lnid < VLAN_N_VID) 1834 code |= IPA_ADDR_CHANGE_CODE_VLANID; 1835 qeth_bridge_emit_host_event(card, anev_reg_unreg, code, 1836 (struct net_if_token *)&entry->nit, 1837 (struct mac_addr_lnid *)&entry->addr_lnid); 1838 } 1839 1840 /** 1841 * qeth_bridgeport_an_set() - Enable or disable bridgeport address notification 1842 * @card: qeth_card structure pointer. 1843 * @enable: 0 - disable, non-zero - enable notifications 1844 * 1845 * Returns negative errno-compatible error indication or 0 on success. 1846 * 1847 * On enable, emits a series of address notifications udev events for all 1848 * currently registered hosts. 1849 */ 1850 int qeth_bridgeport_an_set(struct qeth_card *card, int enable) 1851 { 1852 int rc; 1853 1854 if (!card->options.sbp.supported_funcs) 1855 return -EOPNOTSUPP; 1856 1857 if (enable) { 1858 qeth_bridge_emit_host_event(card, anev_reset, 0, NULL, NULL); 1859 qeth_l2_set_pnso_mode(card, QETH_PNSO_BRIDGEPORT); 1860 rc = qeth_l2_pnso(card, PNSO_OC_NET_BRIDGE_INFO, 1, 1861 qeth_bridgeport_an_set_cb, card); 1862 if (rc) 1863 qeth_l2_set_pnso_mode(card, QETH_PNSO_NONE); 1864 } else { 1865 rc = qeth_l2_pnso(card, PNSO_OC_NET_BRIDGE_INFO, 0, NULL, NULL); 1866 qeth_l2_set_pnso_mode(card, QETH_PNSO_NONE); 1867 } 1868 return rc; 1869 } 1870 1871 /* VNIC Characteristics support */ 1872 1873 /* handle VNICC IPA command return codes; convert to error codes */ 1874 static int qeth_l2_vnicc_makerc(struct qeth_card *card, u16 ipa_rc) 1875 { 1876 int rc; 1877 1878 switch (ipa_rc) { 1879 case IPA_RC_SUCCESS: 1880 return ipa_rc; 1881 case IPA_RC_L2_UNSUPPORTED_CMD: 1882 case IPA_RC_NOTSUPP: 1883 rc = -EOPNOTSUPP; 1884 break; 1885 case IPA_RC_VNICC_OOSEQ: 1886 rc = -EALREADY; 1887 break; 1888 case IPA_RC_VNICC_VNICBP: 1889 rc = -EBUSY; 1890 break; 1891 case IPA_RC_L2_ADDR_TABLE_FULL: 1892 rc = -ENOSPC; 1893 break; 1894 case IPA_RC_L2_MAC_NOT_AUTH_BY_ADP: 1895 rc = -EACCES; 1896 break; 1897 default: 1898 rc = -EIO; 1899 } 1900 1901 QETH_CARD_TEXT_(card, 2, "err%04x", ipa_rc); 1902 return rc; 1903 } 1904 1905 /* generic VNICC request call back */ 1906 static int qeth_l2_vnicc_request_cb(struct qeth_card *card, 1907 struct qeth_reply *reply, 1908 unsigned long data) 1909 { 1910 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data; 1911 struct qeth_ipacmd_vnicc *rep = &cmd->data.vnicc; 1912 u32 sub_cmd = cmd->data.vnicc.hdr.sub_command; 1913 1914 QETH_CARD_TEXT(card, 2, "vniccrcb"); 1915 if (cmd->hdr.return_code) 1916 return qeth_l2_vnicc_makerc(card, cmd->hdr.return_code); 1917 /* return results to caller */ 1918 card->options.vnicc.sup_chars = rep->vnicc_cmds.supported; 1919 card->options.vnicc.cur_chars = rep->vnicc_cmds.enabled; 1920 1921 if (sub_cmd == IPA_VNICC_QUERY_CMDS) 1922 *(u32 *)reply->param = rep->data.query_cmds.sup_cmds; 1923 else if (sub_cmd == IPA_VNICC_GET_TIMEOUT) 1924 *(u32 *)reply->param = rep->data.getset_timeout.timeout; 1925 1926 return 0; 1927 } 1928 1929 static struct qeth_cmd_buffer *qeth_l2_vnicc_build_cmd(struct qeth_card *card, 1930 u32 vnicc_cmd, 1931 unsigned int data_length) 1932 { 1933 struct qeth_ipacmd_vnicc_hdr *hdr; 1934 struct qeth_cmd_buffer *iob; 1935 1936 iob = qeth_ipa_alloc_cmd(card, IPA_CMD_VNICC, QETH_PROT_NONE, 1937 data_length + 1938 offsetof(struct qeth_ipacmd_vnicc, data)); 1939 if (!iob) 1940 return NULL; 1941 1942 hdr = &__ipa_cmd(iob)->data.vnicc.hdr; 1943 hdr->data_length = sizeof(*hdr) + data_length; 1944 hdr->sub_command = vnicc_cmd; 1945 return iob; 1946 } 1947 1948 /* VNICC query VNIC characteristics request */ 1949 static int qeth_l2_vnicc_query_chars(struct qeth_card *card) 1950 { 1951 struct qeth_cmd_buffer *iob; 1952 1953 QETH_CARD_TEXT(card, 2, "vniccqch"); 1954 iob = qeth_l2_vnicc_build_cmd(card, IPA_VNICC_QUERY_CHARS, 0); 1955 if (!iob) 1956 return -ENOMEM; 1957 1958 return qeth_send_ipa_cmd(card, iob, qeth_l2_vnicc_request_cb, NULL); 1959 } 1960 1961 /* VNICC query sub commands request */ 1962 static int qeth_l2_vnicc_query_cmds(struct qeth_card *card, u32 vnic_char, 1963 u32 *sup_cmds) 1964 { 1965 struct qeth_cmd_buffer *iob; 1966 1967 QETH_CARD_TEXT(card, 2, "vniccqcm"); 1968 iob = qeth_l2_vnicc_build_cmd(card, IPA_VNICC_QUERY_CMDS, 1969 VNICC_DATA_SIZEOF(query_cmds)); 1970 if (!iob) 1971 return -ENOMEM; 1972 1973 __ipa_cmd(iob)->data.vnicc.data.query_cmds.vnic_char = vnic_char; 1974 1975 return qeth_send_ipa_cmd(card, iob, qeth_l2_vnicc_request_cb, sup_cmds); 1976 } 1977 1978 /* VNICC enable/disable characteristic request */ 1979 static int qeth_l2_vnicc_set_char(struct qeth_card *card, u32 vnic_char, 1980 u32 cmd) 1981 { 1982 struct qeth_cmd_buffer *iob; 1983 1984 QETH_CARD_TEXT(card, 2, "vniccedc"); 1985 iob = qeth_l2_vnicc_build_cmd(card, cmd, VNICC_DATA_SIZEOF(set_char)); 1986 if (!iob) 1987 return -ENOMEM; 1988 1989 __ipa_cmd(iob)->data.vnicc.data.set_char.vnic_char = vnic_char; 1990 1991 return qeth_send_ipa_cmd(card, iob, qeth_l2_vnicc_request_cb, NULL); 1992 } 1993 1994 /* VNICC get/set timeout for characteristic request */ 1995 static int qeth_l2_vnicc_getset_timeout(struct qeth_card *card, u32 vnicc, 1996 u32 cmd, u32 *timeout) 1997 { 1998 struct qeth_vnicc_getset_timeout *getset_timeout; 1999 struct qeth_cmd_buffer *iob; 2000 2001 QETH_CARD_TEXT(card, 2, "vniccgst"); 2002 iob = qeth_l2_vnicc_build_cmd(card, cmd, 2003 VNICC_DATA_SIZEOF(getset_timeout)); 2004 if (!iob) 2005 return -ENOMEM; 2006 2007 getset_timeout = &__ipa_cmd(iob)->data.vnicc.data.getset_timeout; 2008 getset_timeout->vnic_char = vnicc; 2009 2010 if (cmd == IPA_VNICC_SET_TIMEOUT) 2011 getset_timeout->timeout = *timeout; 2012 2013 return qeth_send_ipa_cmd(card, iob, qeth_l2_vnicc_request_cb, timeout); 2014 } 2015 2016 /* recover user timeout setting */ 2017 static bool qeth_l2_vnicc_recover_timeout(struct qeth_card *card, u32 vnicc, 2018 u32 *timeout) 2019 { 2020 if (card->options.vnicc.sup_chars & vnicc && 2021 card->options.vnicc.getset_timeout_sup & vnicc && 2022 !qeth_l2_vnicc_getset_timeout(card, vnicc, IPA_VNICC_SET_TIMEOUT, 2023 timeout)) 2024 return false; 2025 *timeout = QETH_VNICC_DEFAULT_TIMEOUT; 2026 return true; 2027 } 2028 2029 /* set current VNICC flag state; called from sysfs store function */ 2030 int qeth_l2_vnicc_set_state(struct qeth_card *card, u32 vnicc, bool state) 2031 { 2032 int rc = 0; 2033 u32 cmd; 2034 2035 QETH_CARD_TEXT(card, 2, "vniccsch"); 2036 2037 /* check if characteristic and enable/disable are supported */ 2038 if (!(card->options.vnicc.sup_chars & vnicc) || 2039 !(card->options.vnicc.set_char_sup & vnicc)) 2040 return -EOPNOTSUPP; 2041 2042 if (qeth_bridgeport_is_in_use(card)) 2043 return -EBUSY; 2044 2045 /* set enable/disable command and store wanted characteristic */ 2046 if (state) { 2047 cmd = IPA_VNICC_ENABLE; 2048 card->options.vnicc.wanted_chars |= vnicc; 2049 } else { 2050 cmd = IPA_VNICC_DISABLE; 2051 card->options.vnicc.wanted_chars &= ~vnicc; 2052 } 2053 2054 /* do we need to do anything? */ 2055 if (card->options.vnicc.cur_chars == card->options.vnicc.wanted_chars) 2056 return rc; 2057 2058 /* if card is not ready, simply stop here */ 2059 if (!qeth_card_hw_is_reachable(card)) { 2060 if (state) 2061 card->options.vnicc.cur_chars |= vnicc; 2062 else 2063 card->options.vnicc.cur_chars &= ~vnicc; 2064 return rc; 2065 } 2066 2067 rc = qeth_l2_vnicc_set_char(card, vnicc, cmd); 2068 if (rc) 2069 card->options.vnicc.wanted_chars = 2070 card->options.vnicc.cur_chars; 2071 else { 2072 /* successful online VNICC change; handle special cases */ 2073 if (state && vnicc == QETH_VNICC_RX_BCAST) 2074 card->options.vnicc.rx_bcast_enabled = true; 2075 if (!state && vnicc == QETH_VNICC_LEARNING) 2076 qeth_l2_vnicc_recover_timeout(card, vnicc, 2077 &card->options.vnicc.learning_timeout); 2078 } 2079 2080 return rc; 2081 } 2082 2083 /* get current VNICC flag state; called from sysfs show function */ 2084 int qeth_l2_vnicc_get_state(struct qeth_card *card, u32 vnicc, bool *state) 2085 { 2086 int rc = 0; 2087 2088 QETH_CARD_TEXT(card, 2, "vniccgch"); 2089 2090 /* check if characteristic is supported */ 2091 if (!(card->options.vnicc.sup_chars & vnicc)) 2092 return -EOPNOTSUPP; 2093 2094 if (qeth_bridgeport_is_in_use(card)) 2095 return -EBUSY; 2096 2097 /* if card is ready, query current VNICC state */ 2098 if (qeth_card_hw_is_reachable(card)) 2099 rc = qeth_l2_vnicc_query_chars(card); 2100 2101 *state = (card->options.vnicc.cur_chars & vnicc) ? true : false; 2102 return rc; 2103 } 2104 2105 /* set VNICC timeout; called from sysfs store function. Currently, only learning 2106 * supports timeout 2107 */ 2108 int qeth_l2_vnicc_set_timeout(struct qeth_card *card, u32 timeout) 2109 { 2110 int rc = 0; 2111 2112 QETH_CARD_TEXT(card, 2, "vniccsto"); 2113 2114 /* check if characteristic and set_timeout are supported */ 2115 if (!(card->options.vnicc.sup_chars & QETH_VNICC_LEARNING) || 2116 !(card->options.vnicc.getset_timeout_sup & QETH_VNICC_LEARNING)) 2117 return -EOPNOTSUPP; 2118 2119 if (qeth_bridgeport_is_in_use(card)) 2120 return -EBUSY; 2121 2122 /* do we need to do anything? */ 2123 if (card->options.vnicc.learning_timeout == timeout) 2124 return rc; 2125 2126 /* if card is not ready, simply store the value internally and return */ 2127 if (!qeth_card_hw_is_reachable(card)) { 2128 card->options.vnicc.learning_timeout = timeout; 2129 return rc; 2130 } 2131 2132 /* send timeout value to card; if successful, store value internally */ 2133 rc = qeth_l2_vnicc_getset_timeout(card, QETH_VNICC_LEARNING, 2134 IPA_VNICC_SET_TIMEOUT, &timeout); 2135 if (!rc) 2136 card->options.vnicc.learning_timeout = timeout; 2137 2138 return rc; 2139 } 2140 2141 /* get current VNICC timeout; called from sysfs show function. Currently, only 2142 * learning supports timeout 2143 */ 2144 int qeth_l2_vnicc_get_timeout(struct qeth_card *card, u32 *timeout) 2145 { 2146 int rc = 0; 2147 2148 QETH_CARD_TEXT(card, 2, "vniccgto"); 2149 2150 /* check if characteristic and get_timeout are supported */ 2151 if (!(card->options.vnicc.sup_chars & QETH_VNICC_LEARNING) || 2152 !(card->options.vnicc.getset_timeout_sup & QETH_VNICC_LEARNING)) 2153 return -EOPNOTSUPP; 2154 2155 if (qeth_bridgeport_is_in_use(card)) 2156 return -EBUSY; 2157 2158 /* if card is ready, get timeout. Otherwise, just return stored value */ 2159 *timeout = card->options.vnicc.learning_timeout; 2160 if (qeth_card_hw_is_reachable(card)) 2161 rc = qeth_l2_vnicc_getset_timeout(card, QETH_VNICC_LEARNING, 2162 IPA_VNICC_GET_TIMEOUT, 2163 timeout); 2164 2165 return rc; 2166 } 2167 2168 /* check if VNICC is currently enabled */ 2169 static bool _qeth_l2_vnicc_is_in_use(struct qeth_card *card) 2170 { 2171 if (!card->options.vnicc.sup_chars) 2172 return false; 2173 /* default values are only OK if rx_bcast was not enabled by user 2174 * or the card is offline. 2175 */ 2176 if (card->options.vnicc.cur_chars == QETH_VNICC_DEFAULT) { 2177 if (!card->options.vnicc.rx_bcast_enabled || 2178 !qeth_card_hw_is_reachable(card)) 2179 return false; 2180 } 2181 return true; 2182 } 2183 2184 /** 2185 * qeth_bridgeport_allowed - are any qeth_bridgeport functions allowed? 2186 * @card: qeth_card structure pointer 2187 * 2188 * qeth_bridgeport functionality is mutually exclusive with usage of the 2189 * VNIC Characteristics and dev2br address notifications 2190 */ 2191 bool qeth_bridgeport_allowed(struct qeth_card *card) 2192 { 2193 struct qeth_priv *priv = netdev_priv(card->dev); 2194 2195 return (!_qeth_l2_vnicc_is_in_use(card) && 2196 !(priv->brport_features & BR_LEARNING_SYNC)); 2197 } 2198 2199 /* recover user characteristic setting */ 2200 static bool qeth_l2_vnicc_recover_char(struct qeth_card *card, u32 vnicc, 2201 bool enable) 2202 { 2203 u32 cmd = enable ? IPA_VNICC_ENABLE : IPA_VNICC_DISABLE; 2204 2205 if (card->options.vnicc.sup_chars & vnicc && 2206 card->options.vnicc.set_char_sup & vnicc && 2207 !qeth_l2_vnicc_set_char(card, vnicc, cmd)) 2208 return false; 2209 card->options.vnicc.wanted_chars &= ~vnicc; 2210 card->options.vnicc.wanted_chars |= QETH_VNICC_DEFAULT & vnicc; 2211 return true; 2212 } 2213 2214 /* (re-)initialize VNICC */ 2215 static void qeth_l2_vnicc_init(struct qeth_card *card) 2216 { 2217 u32 *timeout = &card->options.vnicc.learning_timeout; 2218 bool enable, error = false; 2219 unsigned int chars_len, i; 2220 unsigned long chars_tmp; 2221 u32 sup_cmds, vnicc; 2222 2223 QETH_CARD_TEXT(card, 2, "vniccini"); 2224 /* reset rx_bcast */ 2225 card->options.vnicc.rx_bcast_enabled = 0; 2226 /* initial query and storage of VNIC characteristics */ 2227 if (qeth_l2_vnicc_query_chars(card)) { 2228 if (card->options.vnicc.wanted_chars != QETH_VNICC_DEFAULT || 2229 *timeout != QETH_VNICC_DEFAULT_TIMEOUT) 2230 dev_err(&card->gdev->dev, "Configuring the VNIC characteristics failed\n"); 2231 /* fail quietly if user didn't change the default config */ 2232 card->options.vnicc.sup_chars = 0; 2233 card->options.vnicc.cur_chars = 0; 2234 card->options.vnicc.wanted_chars = QETH_VNICC_DEFAULT; 2235 return; 2236 } 2237 /* get supported commands for each supported characteristic */ 2238 chars_tmp = card->options.vnicc.sup_chars; 2239 chars_len = sizeof(card->options.vnicc.sup_chars) * BITS_PER_BYTE; 2240 for_each_set_bit(i, &chars_tmp, chars_len) { 2241 vnicc = BIT(i); 2242 if (qeth_l2_vnicc_query_cmds(card, vnicc, &sup_cmds)) { 2243 sup_cmds = 0; 2244 error = true; 2245 } 2246 if ((sup_cmds & IPA_VNICC_SET_TIMEOUT) && 2247 (sup_cmds & IPA_VNICC_GET_TIMEOUT)) 2248 card->options.vnicc.getset_timeout_sup |= vnicc; 2249 else 2250 card->options.vnicc.getset_timeout_sup &= ~vnicc; 2251 if ((sup_cmds & IPA_VNICC_ENABLE) && 2252 (sup_cmds & IPA_VNICC_DISABLE)) 2253 card->options.vnicc.set_char_sup |= vnicc; 2254 else 2255 card->options.vnicc.set_char_sup &= ~vnicc; 2256 } 2257 /* enforce assumed default values and recover settings, if changed */ 2258 error |= qeth_l2_vnicc_recover_timeout(card, QETH_VNICC_LEARNING, 2259 timeout); 2260 /* Change chars, if necessary */ 2261 chars_tmp = card->options.vnicc.wanted_chars ^ 2262 card->options.vnicc.cur_chars; 2263 chars_len = sizeof(card->options.vnicc.wanted_chars) * BITS_PER_BYTE; 2264 for_each_set_bit(i, &chars_tmp, chars_len) { 2265 vnicc = BIT(i); 2266 enable = card->options.vnicc.wanted_chars & vnicc; 2267 error |= qeth_l2_vnicc_recover_char(card, vnicc, enable); 2268 } 2269 if (error) 2270 dev_err(&card->gdev->dev, "Configuring the VNIC characteristics failed\n"); 2271 } 2272 2273 /* configure default values of VNIC characteristics */ 2274 static void qeth_l2_vnicc_set_defaults(struct qeth_card *card) 2275 { 2276 /* characteristics values */ 2277 card->options.vnicc.sup_chars = QETH_VNICC_ALL; 2278 card->options.vnicc.cur_chars = QETH_VNICC_DEFAULT; 2279 card->options.vnicc.learning_timeout = QETH_VNICC_DEFAULT_TIMEOUT; 2280 /* supported commands */ 2281 card->options.vnicc.set_char_sup = QETH_VNICC_ALL; 2282 card->options.vnicc.getset_timeout_sup = QETH_VNICC_LEARNING; 2283 /* settings wanted by users */ 2284 card->options.vnicc.wanted_chars = QETH_VNICC_DEFAULT; 2285 } 2286 2287 static const struct device_type qeth_l2_devtype = { 2288 .name = "qeth_layer2", 2289 .groups = qeth_l2_attr_groups, 2290 }; 2291 2292 static int qeth_l2_probe_device(struct ccwgroup_device *gdev) 2293 { 2294 struct qeth_card *card = dev_get_drvdata(&gdev->dev); 2295 int rc; 2296 2297 qeth_l2_vnicc_set_defaults(card); 2298 mutex_init(&card->sbp_lock); 2299 2300 if (gdev->dev.type) { 2301 rc = device_add_groups(&gdev->dev, qeth_l2_attr_groups); 2302 if (rc) 2303 return rc; 2304 } else { 2305 gdev->dev.type = &qeth_l2_devtype; 2306 } 2307 2308 INIT_WORK(&card->rx_mode_work, qeth_l2_rx_mode_work); 2309 return 0; 2310 } 2311 2312 static void qeth_l2_remove_device(struct ccwgroup_device *gdev) 2313 { 2314 struct qeth_card *card = dev_get_drvdata(&gdev->dev); 2315 struct qeth_priv *priv; 2316 2317 if (gdev->dev.type != &qeth_l2_devtype) 2318 device_remove_groups(&gdev->dev, qeth_l2_attr_groups); 2319 2320 qeth_set_allowed_threads(card, 0, 1); 2321 wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0); 2322 2323 if (gdev->state == CCWGROUP_ONLINE) 2324 qeth_set_offline(card, card->discipline, false); 2325 2326 if (card->dev->reg_state == NETREG_REGISTERED) { 2327 priv = netdev_priv(card->dev); 2328 if (priv->brport_features & BR_LEARNING_SYNC) { 2329 rtnl_lock(); 2330 qeth_l2_br2dev_put(); 2331 rtnl_unlock(); 2332 } 2333 unregister_netdev(card->dev); 2334 } 2335 } 2336 2337 static int qeth_l2_set_online(struct qeth_card *card, bool carrier_ok) 2338 { 2339 struct net_device *dev = card->dev; 2340 int rc = 0; 2341 2342 qeth_l2_detect_dev2br_support(card); 2343 2344 mutex_lock(&card->sbp_lock); 2345 qeth_bridgeport_query_support(card); 2346 if (card->options.sbp.supported_funcs) { 2347 qeth_l2_setup_bridgeport_attrs(card); 2348 dev_info(&card->gdev->dev, 2349 "The device represents a Bridge Capable Port\n"); 2350 } 2351 mutex_unlock(&card->sbp_lock); 2352 2353 qeth_l2_register_dev_addr(card); 2354 2355 /* for the rx_bcast characteristic, init VNICC after setmac */ 2356 qeth_l2_vnicc_init(card); 2357 2358 qeth_l2_trace_features(card); 2359 2360 /* softsetup */ 2361 QETH_CARD_TEXT(card, 2, "softsetp"); 2362 2363 card->state = CARD_STATE_SOFTSETUP; 2364 2365 qeth_set_allowed_threads(card, 0xffffffff, 0); 2366 2367 if (dev->reg_state != NETREG_REGISTERED) { 2368 rc = qeth_l2_setup_netdev(card); 2369 if (rc) 2370 goto err_setup; 2371 2372 if (carrier_ok) 2373 netif_carrier_on(dev); 2374 } else { 2375 rtnl_lock(); 2376 rc = qeth_set_real_num_tx_queues(card, 2377 qeth_tx_actual_queues(card)); 2378 if (rc) { 2379 rtnl_unlock(); 2380 goto err_set_queues; 2381 } 2382 2383 if (carrier_ok) 2384 netif_carrier_on(dev); 2385 else 2386 netif_carrier_off(dev); 2387 2388 netif_device_attach(dev); 2389 qeth_enable_hw_features(dev); 2390 qeth_l2_enable_brport_features(card); 2391 2392 if (netif_running(dev)) { 2393 local_bh_disable(); 2394 napi_schedule(&card->napi); 2395 /* kick-start the NAPI softirq: */ 2396 local_bh_enable(); 2397 qeth_l2_set_rx_mode(dev); 2398 } 2399 rtnl_unlock(); 2400 } 2401 return 0; 2402 2403 err_set_queues: 2404 err_setup: 2405 qeth_set_allowed_threads(card, 0, 1); 2406 card->state = CARD_STATE_DOWN; 2407 return rc; 2408 } 2409 2410 static void qeth_l2_set_offline(struct qeth_card *card) 2411 { 2412 struct qeth_priv *priv = netdev_priv(card->dev); 2413 2414 qeth_set_allowed_threads(card, 0, 1); 2415 qeth_l2_drain_rx_mode_cache(card); 2416 2417 if (card->state == CARD_STATE_SOFTSETUP) 2418 card->state = CARD_STATE_DOWN; 2419 2420 qeth_l2_set_pnso_mode(card, QETH_PNSO_NONE); 2421 if (priv->brport_features & BR_LEARNING_SYNC) 2422 qeth_l2_dev2br_fdb_flush(card); 2423 } 2424 2425 /* Returns zero if the command is successfully "consumed" */ 2426 static int qeth_l2_control_event(struct qeth_card *card, 2427 struct qeth_ipa_cmd *cmd) 2428 { 2429 switch (cmd->hdr.command) { 2430 case IPA_CMD_SETBRIDGEPORT_OSA: 2431 case IPA_CMD_SETBRIDGEPORT_IQD: 2432 if (cmd->data.sbp.hdr.command_code == 2433 IPA_SBP_BRIDGE_PORT_STATE_CHANGE) { 2434 qeth_bridge_state_change(card, cmd); 2435 return 0; 2436 } 2437 2438 return 1; 2439 case IPA_CMD_ADDRESS_CHANGE_NOTIF: 2440 qeth_addr_change_event(card, cmd); 2441 return 0; 2442 default: 2443 return 1; 2444 } 2445 } 2446 2447 const struct qeth_discipline qeth_l2_discipline = { 2448 .setup = qeth_l2_probe_device, 2449 .remove = qeth_l2_remove_device, 2450 .set_online = qeth_l2_set_online, 2451 .set_offline = qeth_l2_set_offline, 2452 .control_event_handler = qeth_l2_control_event, 2453 }; 2454 EXPORT_SYMBOL_GPL(qeth_l2_discipline); 2455 2456 static int __init qeth_l2_init(void) 2457 { 2458 pr_info("register layer 2 discipline\n"); 2459 refcount_set(&qeth_l2_switchdev_notify_refcnt, 0); 2460 return 0; 2461 } 2462 2463 static void __exit qeth_l2_exit(void) 2464 { 2465 pr_info("unregister layer 2 discipline\n"); 2466 } 2467 2468 module_init(qeth_l2_init); 2469 module_exit(qeth_l2_exit); 2470 MODULE_AUTHOR("Frank Blaschka <frank.blaschka@de.ibm.com>"); 2471 MODULE_DESCRIPTION("qeth layer 2 discipline"); 2472 MODULE_LICENSE("GPL"); 2473