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