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