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