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