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