1 /* 2 * Copyright IBM Corp. 2007, 2009 3 * Author(s): Utz Bacher <utz.bacher@de.ibm.com>, 4 * Frank Pavlic <fpavlic@de.ibm.com>, 5 * Thomas Spatzier <tspat@de.ibm.com>, 6 * Frank Blaschka <frank.blaschka@de.ibm.com> 7 */ 8 9 #define KMSG_COMPONENT "qeth" 10 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 11 12 #include <linux/module.h> 13 #include <linux/moduleparam.h> 14 #include <linux/string.h> 15 #include <linux/errno.h> 16 #include <linux/kernel.h> 17 #include <linux/slab.h> 18 #include <linux/etherdevice.h> 19 #include <linux/mii.h> 20 #include <linux/ip.h> 21 #include <linux/list.h> 22 23 #include "qeth_core.h" 24 #include "qeth_l2.h" 25 26 static int qeth_l2_set_offline(struct ccwgroup_device *); 27 static int qeth_l2_stop(struct net_device *); 28 static int qeth_l2_send_delmac(struct qeth_card *, __u8 *); 29 static int qeth_l2_send_setdelmac(struct qeth_card *, __u8 *, 30 enum qeth_ipa_cmds); 31 static void qeth_l2_set_multicast_list(struct net_device *); 32 static int qeth_l2_recover(void *); 33 static void qeth_bridgeport_query_support(struct qeth_card *card); 34 static void qeth_bridge_state_change(struct qeth_card *card, 35 struct qeth_ipa_cmd *cmd); 36 static void qeth_bridge_host_event(struct qeth_card *card, 37 struct qeth_ipa_cmd *cmd); 38 39 static int qeth_l2_do_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) 40 { 41 struct qeth_card *card = dev->ml_priv; 42 struct mii_ioctl_data *mii_data; 43 int rc = 0; 44 45 if (!card) 46 return -ENODEV; 47 48 if (!qeth_card_hw_is_reachable(card)) 49 return -ENODEV; 50 51 if (card->info.type == QETH_CARD_TYPE_OSN) 52 return -EPERM; 53 54 switch (cmd) { 55 case SIOC_QETH_ADP_SET_SNMP_CONTROL: 56 rc = qeth_snmp_command(card, rq->ifr_ifru.ifru_data); 57 break; 58 case SIOC_QETH_GET_CARD_TYPE: 59 if ((card->info.type == QETH_CARD_TYPE_OSD || 60 card->info.type == QETH_CARD_TYPE_OSM || 61 card->info.type == QETH_CARD_TYPE_OSX) && 62 !card->info.guestlan) 63 return 1; 64 return 0; 65 break; 66 case SIOCGMIIPHY: 67 mii_data = if_mii(rq); 68 mii_data->phy_id = 0; 69 break; 70 case SIOCGMIIREG: 71 mii_data = if_mii(rq); 72 if (mii_data->phy_id != 0) 73 rc = -EINVAL; 74 else 75 mii_data->val_out = qeth_mdio_read(dev, 76 mii_data->phy_id, mii_data->reg_num); 77 break; 78 case SIOC_QETH_QUERY_OAT: 79 rc = qeth_query_oat_command(card, rq->ifr_ifru.ifru_data); 80 break; 81 default: 82 rc = -EOPNOTSUPP; 83 } 84 if (rc) 85 QETH_CARD_TEXT_(card, 2, "ioce%d", rc); 86 return rc; 87 } 88 89 static int qeth_l2_verify_dev(struct net_device *dev) 90 { 91 struct qeth_card *card; 92 unsigned long flags; 93 int rc = 0; 94 95 read_lock_irqsave(&qeth_core_card_list.rwlock, flags); 96 list_for_each_entry(card, &qeth_core_card_list.list, list) { 97 if (card->dev == dev) { 98 rc = QETH_REAL_CARD; 99 break; 100 } 101 } 102 read_unlock_irqrestore(&qeth_core_card_list.rwlock, flags); 103 104 return rc; 105 } 106 107 static struct net_device *qeth_l2_netdev_by_devno(unsigned char *read_dev_no) 108 { 109 struct qeth_card *card; 110 struct net_device *ndev; 111 __u16 temp_dev_no; 112 unsigned long flags; 113 struct ccw_dev_id read_devid; 114 115 ndev = NULL; 116 memcpy(&temp_dev_no, read_dev_no, 2); 117 read_lock_irqsave(&qeth_core_card_list.rwlock, flags); 118 list_for_each_entry(card, &qeth_core_card_list.list, list) { 119 ccw_device_get_id(CARD_RDEV(card), &read_devid); 120 if (read_devid.devno == temp_dev_no) { 121 ndev = card->dev; 122 break; 123 } 124 } 125 read_unlock_irqrestore(&qeth_core_card_list.rwlock, flags); 126 return ndev; 127 } 128 129 static int qeth_setdel_makerc(struct qeth_card *card, int retcode) 130 { 131 int rc; 132 133 if (retcode) 134 QETH_CARD_TEXT_(card, 2, "err%04x", retcode); 135 switch (retcode) { 136 case IPA_RC_SUCCESS: 137 rc = 0; 138 break; 139 case IPA_RC_L2_UNSUPPORTED_CMD: 140 rc = -EOPNOTSUPP; 141 break; 142 case IPA_RC_L2_ADDR_TABLE_FULL: 143 rc = -ENOSPC; 144 break; 145 case IPA_RC_L2_DUP_MAC: 146 case IPA_RC_L2_DUP_LAYER3_MAC: 147 rc = -EEXIST; 148 break; 149 case IPA_RC_L2_MAC_NOT_AUTH_BY_HYP: 150 case IPA_RC_L2_MAC_NOT_AUTH_BY_ADP: 151 rc = -EPERM; 152 break; 153 case IPA_RC_L2_MAC_NOT_FOUND: 154 rc = -ENOENT; 155 break; 156 case -ENOMEM: 157 rc = -ENOMEM; 158 break; 159 default: 160 rc = -EIO; 161 break; 162 } 163 return rc; 164 } 165 166 static int qeth_l2_send_setgroupmac(struct qeth_card *card, __u8 *mac) 167 { 168 int rc; 169 170 QETH_CARD_TEXT(card, 2, "L2Sgmac"); 171 rc = qeth_setdel_makerc(card, qeth_l2_send_setdelmac(card, mac, 172 IPA_CMD_SETGMAC)); 173 if (rc == -EEXIST) 174 QETH_DBF_MESSAGE(2, "Group MAC %pM already existing on %s\n", 175 mac, QETH_CARD_IFNAME(card)); 176 else if (rc) 177 QETH_DBF_MESSAGE(2, "Could not set group MAC %pM on %s: %d\n", 178 mac, QETH_CARD_IFNAME(card), rc); 179 return rc; 180 } 181 182 static int qeth_l2_send_delgroupmac(struct qeth_card *card, __u8 *mac) 183 { 184 int rc; 185 186 QETH_CARD_TEXT(card, 2, "L2Dgmac"); 187 rc = qeth_setdel_makerc(card, qeth_l2_send_setdelmac(card, mac, 188 IPA_CMD_DELGMAC)); 189 if (rc) 190 QETH_DBF_MESSAGE(2, 191 "Could not delete group MAC %pM on %s: %d\n", 192 mac, QETH_CARD_IFNAME(card), rc); 193 return rc; 194 } 195 196 static void qeth_l2_add_mc(struct qeth_card *card, __u8 *mac, int vmac) 197 { 198 struct qeth_mc_mac *mc; 199 int rc; 200 201 mc = kmalloc(sizeof(struct qeth_mc_mac), GFP_ATOMIC); 202 203 if (!mc) 204 return; 205 206 memcpy(mc->mc_addr, mac, OSA_ADDR_LEN); 207 mc->mc_addrlen = OSA_ADDR_LEN; 208 mc->is_vmac = vmac; 209 210 if (vmac) { 211 rc = qeth_setdel_makerc(card, 212 qeth_l2_send_setdelmac(card, mac, IPA_CMD_SETVMAC)); 213 } else { 214 rc = qeth_setdel_makerc(card, 215 qeth_l2_send_setgroupmac(card, mac)); 216 } 217 218 if (!rc) 219 list_add_tail(&mc->list, &card->mc_list); 220 else 221 kfree(mc); 222 } 223 224 static void qeth_l2_del_all_mc(struct qeth_card *card, int del) 225 { 226 struct qeth_mc_mac *mc, *tmp; 227 228 spin_lock_bh(&card->mclock); 229 list_for_each_entry_safe(mc, tmp, &card->mc_list, list) { 230 if (del) { 231 if (mc->is_vmac) 232 qeth_l2_send_setdelmac(card, mc->mc_addr, 233 IPA_CMD_DELVMAC); 234 else 235 qeth_l2_send_delgroupmac(card, mc->mc_addr); 236 } 237 list_del(&mc->list); 238 kfree(mc); 239 } 240 spin_unlock_bh(&card->mclock); 241 } 242 243 static inline int qeth_l2_get_cast_type(struct qeth_card *card, 244 struct sk_buff *skb) 245 { 246 if (card->info.type == QETH_CARD_TYPE_OSN) 247 return RTN_UNSPEC; 248 if (is_broadcast_ether_addr(skb->data)) 249 return RTN_BROADCAST; 250 if (is_multicast_ether_addr(skb->data)) 251 return RTN_MULTICAST; 252 return RTN_UNSPEC; 253 } 254 255 static inline void qeth_l2_hdr_csum(struct qeth_card *card, 256 struct qeth_hdr *hdr, struct sk_buff *skb) 257 { 258 struct iphdr *iph = ip_hdr(skb); 259 260 /* tcph->check contains already the pseudo hdr checksum 261 * so just set the header flags 262 */ 263 if (iph->protocol == IPPROTO_UDP) 264 hdr->hdr.l2.flags[1] |= QETH_HDR_EXT_UDP; 265 hdr->hdr.l2.flags[1] |= QETH_HDR_EXT_CSUM_TRANSP_REQ | 266 QETH_HDR_EXT_CSUM_HDR_REQ; 267 iph->check = 0; 268 if (card->options.performance_stats) 269 card->perf_stats.tx_csum++; 270 } 271 272 static void qeth_l2_fill_header(struct qeth_card *card, struct qeth_hdr *hdr, 273 struct sk_buff *skb, int cast_type) 274 { 275 struct vlan_ethhdr *veth = (struct vlan_ethhdr *)skb_mac_header(skb); 276 277 memset(hdr, 0, sizeof(struct qeth_hdr)); 278 hdr->hdr.l2.id = QETH_HEADER_TYPE_LAYER2; 279 280 /* set byte byte 3 to casting flags */ 281 if (cast_type == RTN_MULTICAST) 282 hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_MULTICAST; 283 else if (cast_type == RTN_BROADCAST) 284 hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_BROADCAST; 285 else 286 hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_UNICAST; 287 288 hdr->hdr.l2.pkt_length = skb->len-QETH_HEADER_SIZE; 289 /* VSWITCH relies on the VLAN 290 * information to be present in 291 * the QDIO header */ 292 if (veth->h_vlan_proto == __constant_htons(ETH_P_8021Q)) { 293 hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_VLAN; 294 hdr->hdr.l2.vlan_id = ntohs(veth->h_vlan_TCI); 295 } 296 } 297 298 static int qeth_l2_send_setdelvlan_cb(struct qeth_card *card, 299 struct qeth_reply *reply, unsigned long data) 300 { 301 struct qeth_ipa_cmd *cmd; 302 303 QETH_CARD_TEXT(card, 2, "L2sdvcb"); 304 cmd = (struct qeth_ipa_cmd *) data; 305 if (cmd->hdr.return_code) { 306 QETH_DBF_MESSAGE(2, "Error in processing VLAN %i on %s: 0x%x. " 307 "Continuing\n", 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_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 (card->info.type == QETH_CARD_TYPE_OSM) { 353 QETH_CARD_TEXT(card, 3, "aidOSM"); 354 return 0; 355 } 356 if (qeth_wait_for_threads(card, QETH_RECOVER_THREAD)) { 357 QETH_CARD_TEXT(card, 3, "aidREC"); 358 return 0; 359 } 360 id = kmalloc(sizeof(struct qeth_vlan_vid), GFP_ATOMIC); 361 if (id) { 362 id->vid = vid; 363 rc = qeth_l2_send_setdelvlan(card, vid, IPA_CMD_SETVLAN); 364 if (rc) { 365 kfree(id); 366 return rc; 367 } 368 spin_lock_bh(&card->vlanlock); 369 list_add_tail(&id->list, &card->vid_list); 370 spin_unlock_bh(&card->vlanlock); 371 } else { 372 return -ENOMEM; 373 } 374 return 0; 375 } 376 377 static int qeth_l2_vlan_rx_kill_vid(struct net_device *dev, 378 __be16 proto, u16 vid) 379 { 380 struct qeth_vlan_vid *id, *tmpid = NULL; 381 struct qeth_card *card = dev->ml_priv; 382 int rc = 0; 383 384 QETH_CARD_TEXT_(card, 4, "kid:%d", vid); 385 if (card->info.type == QETH_CARD_TYPE_OSM) { 386 QETH_CARD_TEXT(card, 3, "kidOSM"); 387 return 0; 388 } 389 if (qeth_wait_for_threads(card, QETH_RECOVER_THREAD)) { 390 QETH_CARD_TEXT(card, 3, "kidREC"); 391 return 0; 392 } 393 spin_lock_bh(&card->vlanlock); 394 list_for_each_entry(id, &card->vid_list, list) { 395 if (id->vid == vid) { 396 list_del(&id->list); 397 tmpid = id; 398 break; 399 } 400 } 401 spin_unlock_bh(&card->vlanlock); 402 if (tmpid) { 403 rc = qeth_l2_send_setdelvlan(card, vid, IPA_CMD_DELVLAN); 404 kfree(tmpid); 405 } 406 qeth_l2_set_multicast_list(card->dev); 407 return rc; 408 } 409 410 static netdev_features_t qeth_l2_fix_features(struct net_device *dev, 411 netdev_features_t features) 412 { 413 struct qeth_card *card = dev->ml_priv; 414 415 QETH_DBF_TEXT(SETUP, 2, "fixfeat"); 416 if (!qeth_is_supported(card, IPA_OUTBOUND_CHECKSUM)) 417 features &= ~NETIF_F_IP_CSUM; 418 if (!qeth_is_supported(card, IPA_INBOUND_CHECKSUM)) 419 features &= ~NETIF_F_RXCSUM; 420 QETH_DBF_HEX(SETUP, 2, &features, sizeof(features)); 421 return features; 422 } 423 424 static int qeth_l2_set_features(struct net_device *dev, 425 netdev_features_t features) 426 { 427 struct qeth_card *card = dev->ml_priv; 428 netdev_features_t changed = dev->features ^ features; 429 430 QETH_DBF_TEXT(SETUP, 2, "setfeat"); 431 QETH_DBF_HEX(SETUP, 2, &features, sizeof(features)); 432 433 if (card->state == CARD_STATE_DOWN || 434 card->state == CARD_STATE_RECOVER) 435 return 0; 436 437 if (!(changed & NETIF_F_RXCSUM)) 438 return 0; 439 return qeth_set_rx_csum(card, features & NETIF_F_RXCSUM ? 1 : 0); 440 } 441 442 static void qeth_l2_stop_card(struct qeth_card *card, int recovery_mode) 443 { 444 QETH_DBF_TEXT(SETUP , 2, "stopcard"); 445 QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *)); 446 447 qeth_set_allowed_threads(card, 0, 1); 448 if (card->read.state == CH_STATE_UP && 449 card->write.state == CH_STATE_UP && 450 (card->state == CARD_STATE_UP)) { 451 if (recovery_mode && 452 card->info.type != QETH_CARD_TYPE_OSN) { 453 qeth_l2_stop(card->dev); 454 } else { 455 rtnl_lock(); 456 dev_close(card->dev); 457 rtnl_unlock(); 458 } 459 card->info.mac_bits &= ~QETH_LAYER2_MAC_REGISTERED; 460 card->state = CARD_STATE_SOFTSETUP; 461 } 462 if (card->state == CARD_STATE_SOFTSETUP) { 463 qeth_l2_del_all_mc(card, 0); 464 qeth_clear_ipacmd_list(card); 465 card->state = CARD_STATE_HARDSETUP; 466 } 467 if (card->state == CARD_STATE_HARDSETUP) { 468 qeth_qdio_clear_card(card, 0); 469 qeth_clear_qdio_buffers(card); 470 qeth_clear_working_pool_list(card); 471 card->state = CARD_STATE_DOWN; 472 } 473 if (card->state == CARD_STATE_DOWN) { 474 qeth_clear_cmd_buffers(&card->read); 475 qeth_clear_cmd_buffers(&card->write); 476 } 477 } 478 479 static int qeth_l2_process_inbound_buffer(struct qeth_card *card, 480 int budget, int *done) 481 { 482 int work_done = 0; 483 struct sk_buff *skb; 484 struct qeth_hdr *hdr; 485 unsigned int len; 486 487 *done = 0; 488 WARN_ON_ONCE(!budget); 489 while (budget) { 490 skb = qeth_core_get_next_skb(card, 491 &card->qdio.in_q->bufs[card->rx.b_index], 492 &card->rx.b_element, &card->rx.e_offset, &hdr); 493 if (!skb) { 494 *done = 1; 495 break; 496 } 497 skb->dev = card->dev; 498 switch (hdr->hdr.l2.id) { 499 case QETH_HEADER_TYPE_LAYER2: 500 skb->pkt_type = PACKET_HOST; 501 skb->protocol = eth_type_trans(skb, skb->dev); 502 if ((card->dev->features & NETIF_F_RXCSUM) 503 && ((hdr->hdr.l2.flags[1] & 504 (QETH_HDR_EXT_CSUM_HDR_REQ | 505 QETH_HDR_EXT_CSUM_TRANSP_REQ)) == 506 (QETH_HDR_EXT_CSUM_HDR_REQ | 507 QETH_HDR_EXT_CSUM_TRANSP_REQ))) 508 skb->ip_summed = CHECKSUM_UNNECESSARY; 509 else 510 skb->ip_summed = CHECKSUM_NONE; 511 if (skb->protocol == htons(ETH_P_802_2)) 512 *((__u32 *)skb->cb) = ++card->seqno.pkt_seqno; 513 len = skb->len; 514 netif_receive_skb(skb); 515 break; 516 case QETH_HEADER_TYPE_OSN: 517 if (card->info.type == QETH_CARD_TYPE_OSN) { 518 skb_push(skb, sizeof(struct qeth_hdr)); 519 skb_copy_to_linear_data(skb, hdr, 520 sizeof(struct qeth_hdr)); 521 len = skb->len; 522 card->osn_info.data_cb(skb); 523 break; 524 } 525 /* else unknown */ 526 default: 527 dev_kfree_skb_any(skb); 528 QETH_CARD_TEXT(card, 3, "inbunkno"); 529 QETH_DBF_HEX(CTRL, 3, hdr, QETH_DBF_CTRL_LEN); 530 continue; 531 } 532 work_done++; 533 budget--; 534 card->stats.rx_packets++; 535 card->stats.rx_bytes += len; 536 } 537 return work_done; 538 } 539 540 static int qeth_l2_poll(struct napi_struct *napi, int budget) 541 { 542 struct qeth_card *card = container_of(napi, struct qeth_card, napi); 543 int work_done = 0; 544 struct qeth_qdio_buffer *buffer; 545 int done; 546 int new_budget = budget; 547 548 if (card->options.performance_stats) { 549 card->perf_stats.inbound_cnt++; 550 card->perf_stats.inbound_start_time = qeth_get_micros(); 551 } 552 553 while (1) { 554 if (!card->rx.b_count) { 555 card->rx.qdio_err = 0; 556 card->rx.b_count = qdio_get_next_buffers( 557 card->data.ccwdev, 0, &card->rx.b_index, 558 &card->rx.qdio_err); 559 if (card->rx.b_count <= 0) { 560 card->rx.b_count = 0; 561 break; 562 } 563 card->rx.b_element = 564 &card->qdio.in_q->bufs[card->rx.b_index] 565 .buffer->element[0]; 566 card->rx.e_offset = 0; 567 } 568 569 while (card->rx.b_count) { 570 buffer = &card->qdio.in_q->bufs[card->rx.b_index]; 571 if (!(card->rx.qdio_err && 572 qeth_check_qdio_errors(card, buffer->buffer, 573 card->rx.qdio_err, "qinerr"))) 574 work_done += qeth_l2_process_inbound_buffer( 575 card, new_budget, &done); 576 else 577 done = 1; 578 579 if (done) { 580 if (card->options.performance_stats) 581 card->perf_stats.bufs_rec++; 582 qeth_put_buffer_pool_entry(card, 583 buffer->pool_entry); 584 qeth_queue_input_buffer(card, card->rx.b_index); 585 card->rx.b_count--; 586 if (card->rx.b_count) { 587 card->rx.b_index = 588 (card->rx.b_index + 1) % 589 QDIO_MAX_BUFFERS_PER_Q; 590 card->rx.b_element = 591 &card->qdio.in_q 592 ->bufs[card->rx.b_index] 593 .buffer->element[0]; 594 card->rx.e_offset = 0; 595 } 596 } 597 598 if (work_done >= budget) 599 goto out; 600 else 601 new_budget = budget - work_done; 602 } 603 } 604 605 napi_complete(napi); 606 if (qdio_start_irq(card->data.ccwdev, 0)) 607 napi_schedule(&card->napi); 608 out: 609 if (card->options.performance_stats) 610 card->perf_stats.inbound_time += qeth_get_micros() - 611 card->perf_stats.inbound_start_time; 612 return work_done; 613 } 614 615 static int qeth_l2_send_setdelmac(struct qeth_card *card, __u8 *mac, 616 enum qeth_ipa_cmds ipacmd) 617 { 618 struct qeth_ipa_cmd *cmd; 619 struct qeth_cmd_buffer *iob; 620 621 QETH_CARD_TEXT(card, 2, "L2sdmac"); 622 iob = qeth_get_ipacmd_buffer(card, ipacmd, QETH_PROT_IPV4); 623 if (!iob) 624 return -ENOMEM; 625 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE); 626 cmd->data.setdelmac.mac_length = OSA_ADDR_LEN; 627 memcpy(&cmd->data.setdelmac.mac, mac, OSA_ADDR_LEN); 628 return qeth_send_ipa_cmd(card, iob, NULL, NULL); 629 } 630 631 static int qeth_l2_send_setmac(struct qeth_card *card, __u8 *mac) 632 { 633 int rc; 634 635 QETH_CARD_TEXT(card, 2, "L2Setmac"); 636 rc = qeth_setdel_makerc(card, qeth_l2_send_setdelmac(card, mac, 637 IPA_CMD_SETVMAC)); 638 if (rc == 0) { 639 card->info.mac_bits |= QETH_LAYER2_MAC_REGISTERED; 640 memcpy(card->dev->dev_addr, mac, OSA_ADDR_LEN); 641 dev_info(&card->gdev->dev, 642 "MAC address %pM successfully registered on device %s\n", 643 card->dev->dev_addr, card->dev->name); 644 } else { 645 card->info.mac_bits &= ~QETH_LAYER2_MAC_REGISTERED; 646 switch (rc) { 647 case -EEXIST: 648 dev_warn(&card->gdev->dev, 649 "MAC address %pM already exists\n", mac); 650 break; 651 case -EPERM: 652 dev_warn(&card->gdev->dev, 653 "MAC address %pM is not authorized\n", mac); 654 break; 655 } 656 } 657 return rc; 658 } 659 660 static int qeth_l2_send_delmac(struct qeth_card *card, __u8 *mac) 661 { 662 int rc; 663 664 QETH_CARD_TEXT(card, 2, "L2Delmac"); 665 if (!(card->info.mac_bits & QETH_LAYER2_MAC_REGISTERED)) 666 return 0; 667 rc = qeth_setdel_makerc(card, qeth_l2_send_setdelmac(card, mac, 668 IPA_CMD_DELVMAC)); 669 if (rc == 0) 670 card->info.mac_bits &= ~QETH_LAYER2_MAC_REGISTERED; 671 return rc; 672 } 673 674 static int qeth_l2_request_initial_mac(struct qeth_card *card) 675 { 676 int rc = 0; 677 char vendor_pre[] = {0x02, 0x00, 0x00}; 678 679 QETH_DBF_TEXT(SETUP, 2, "doL2init"); 680 QETH_DBF_TEXT_(SETUP, 2, "doL2%s", CARD_BUS_ID(card)); 681 682 if (qeth_is_supported(card, IPA_SETADAPTERPARMS)) { 683 rc = qeth_query_setadapterparms(card); 684 if (rc) { 685 QETH_DBF_MESSAGE(2, "could not query adapter " 686 "parameters on device %s: x%x\n", 687 CARD_BUS_ID(card), rc); 688 } 689 } 690 691 if (card->info.type == QETH_CARD_TYPE_IQD || 692 card->info.type == QETH_CARD_TYPE_OSM || 693 card->info.type == QETH_CARD_TYPE_OSX || 694 card->info.guestlan) { 695 rc = qeth_setadpparms_change_macaddr(card); 696 if (rc) { 697 QETH_DBF_MESSAGE(2, "couldn't get MAC address on " 698 "device %s: x%x\n", CARD_BUS_ID(card), rc); 699 QETH_DBF_TEXT_(SETUP, 2, "1err%04x", rc); 700 return rc; 701 } 702 QETH_DBF_HEX(SETUP, 2, card->dev->dev_addr, OSA_ADDR_LEN); 703 } else { 704 eth_random_addr(card->dev->dev_addr); 705 memcpy(card->dev->dev_addr, vendor_pre, 3); 706 } 707 return 0; 708 } 709 710 static int qeth_l2_set_mac_address(struct net_device *dev, void *p) 711 { 712 struct sockaddr *addr = p; 713 struct qeth_card *card = dev->ml_priv; 714 int rc = 0; 715 716 QETH_CARD_TEXT(card, 3, "setmac"); 717 718 if (qeth_l2_verify_dev(dev) != QETH_REAL_CARD) { 719 QETH_CARD_TEXT(card, 3, "setmcINV"); 720 return -EOPNOTSUPP; 721 } 722 723 if (card->info.type == QETH_CARD_TYPE_OSN || 724 card->info.type == QETH_CARD_TYPE_OSM || 725 card->info.type == QETH_CARD_TYPE_OSX) { 726 QETH_CARD_TEXT(card, 3, "setmcTYP"); 727 return -EOPNOTSUPP; 728 } 729 QETH_CARD_HEX(card, 3, addr->sa_data, OSA_ADDR_LEN); 730 if (qeth_wait_for_threads(card, QETH_RECOVER_THREAD)) { 731 QETH_CARD_TEXT(card, 3, "setmcREC"); 732 return -ERESTARTSYS; 733 } 734 rc = qeth_l2_send_delmac(card, &card->dev->dev_addr[0]); 735 if (!rc || (rc == -ENOENT)) 736 rc = qeth_l2_send_setmac(card, addr->sa_data); 737 return rc ? -EINVAL : 0; 738 } 739 740 static void qeth_promisc_to_bridge(struct qeth_card *card) 741 { 742 struct net_device *dev = card->dev; 743 enum qeth_ipa_promisc_modes promisc_mode; 744 int role; 745 int rc; 746 747 QETH_CARD_TEXT(card, 3, "pmisc2br"); 748 749 if (!card->options.sbp.reflect_promisc) 750 return; 751 promisc_mode = (dev->flags & IFF_PROMISC) ? SET_PROMISC_MODE_ON 752 : SET_PROMISC_MODE_OFF; 753 if (promisc_mode == card->info.promisc_mode) 754 return; 755 756 if (promisc_mode == SET_PROMISC_MODE_ON) { 757 if (card->options.sbp.reflect_promisc_primary) 758 role = QETH_SBP_ROLE_PRIMARY; 759 else 760 role = QETH_SBP_ROLE_SECONDARY; 761 } else 762 role = QETH_SBP_ROLE_NONE; 763 764 rc = qeth_bridgeport_setrole(card, role); 765 QETH_DBF_TEXT_(SETUP, 2, "bpm%c%04x", 766 (promisc_mode == SET_PROMISC_MODE_ON) ? '+' : '-', rc); 767 if (!rc) { 768 card->options.sbp.role = role; 769 card->info.promisc_mode = promisc_mode; 770 } 771 } 772 773 static void qeth_l2_set_multicast_list(struct net_device *dev) 774 { 775 struct qeth_card *card = dev->ml_priv; 776 struct netdev_hw_addr *ha; 777 778 if (card->info.type == QETH_CARD_TYPE_OSN) 779 return ; 780 781 QETH_CARD_TEXT(card, 3, "setmulti"); 782 if (qeth_threads_running(card, QETH_RECOVER_THREAD) && 783 (card->state != CARD_STATE_UP)) 784 return; 785 qeth_l2_del_all_mc(card, 1); 786 spin_lock_bh(&card->mclock); 787 netdev_for_each_mc_addr(ha, dev) 788 qeth_l2_add_mc(card, ha->addr, 0); 789 790 netdev_for_each_uc_addr(ha, dev) 791 qeth_l2_add_mc(card, ha->addr, 1); 792 793 spin_unlock_bh(&card->mclock); 794 if (qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE)) 795 qeth_setadp_promisc_mode(card); 796 else 797 qeth_promisc_to_bridge(card); 798 } 799 800 static int qeth_l2_hard_start_xmit(struct sk_buff *skb, struct net_device *dev) 801 { 802 int rc; 803 struct qeth_hdr *hdr = NULL; 804 int elements = 0; 805 struct qeth_card *card = dev->ml_priv; 806 struct sk_buff *new_skb = skb; 807 int cast_type = qeth_l2_get_cast_type(card, skb); 808 struct qeth_qdio_out_q *queue; 809 int tx_bytes = skb->len; 810 int data_offset = -1; 811 int elements_needed = 0; 812 int hd_len = 0; 813 814 if (card->qdio.do_prio_queueing || (cast_type && 815 card->info.is_multicast_different)) 816 queue = card->qdio.out_qs[qeth_get_priority_queue(card, skb, 817 qeth_get_ip_version(skb), cast_type)]; 818 else 819 queue = card->qdio.out_qs[card->qdio.default_out_queue]; 820 821 if ((card->state != CARD_STATE_UP) || !card->lan_online) { 822 card->stats.tx_carrier_errors++; 823 goto tx_drop; 824 } 825 826 if ((card->info.type == QETH_CARD_TYPE_OSN) && 827 (skb->protocol == htons(ETH_P_IPV6))) 828 goto tx_drop; 829 830 if (card->options.performance_stats) { 831 card->perf_stats.outbound_cnt++; 832 card->perf_stats.outbound_start_time = qeth_get_micros(); 833 } 834 netif_stop_queue(dev); 835 836 if (card->info.type == QETH_CARD_TYPE_OSN) 837 hdr = (struct qeth_hdr *)skb->data; 838 else { 839 if (card->info.type == QETH_CARD_TYPE_IQD) { 840 new_skb = skb; 841 data_offset = ETH_HLEN; 842 hd_len = ETH_HLEN; 843 hdr = kmem_cache_alloc(qeth_core_header_cache, 844 GFP_ATOMIC); 845 if (!hdr) 846 goto tx_drop; 847 elements_needed++; 848 skb_reset_mac_header(new_skb); 849 qeth_l2_fill_header(card, hdr, new_skb, cast_type); 850 hdr->hdr.l2.pkt_length = new_skb->len; 851 memcpy(((char *)hdr) + sizeof(struct qeth_hdr), 852 skb_mac_header(new_skb), ETH_HLEN); 853 } else { 854 /* create a clone with writeable headroom */ 855 new_skb = skb_realloc_headroom(skb, 856 sizeof(struct qeth_hdr)); 857 if (!new_skb) 858 goto tx_drop; 859 hdr = (struct qeth_hdr *)skb_push(new_skb, 860 sizeof(struct qeth_hdr)); 861 skb_set_mac_header(new_skb, sizeof(struct qeth_hdr)); 862 qeth_l2_fill_header(card, hdr, new_skb, cast_type); 863 if (new_skb->ip_summed == CHECKSUM_PARTIAL) 864 qeth_l2_hdr_csum(card, hdr, new_skb); 865 } 866 } 867 868 elements = qeth_get_elements_no(card, new_skb, elements_needed); 869 if (!elements) { 870 if (data_offset >= 0) 871 kmem_cache_free(qeth_core_header_cache, hdr); 872 goto tx_drop; 873 } 874 875 if (card->info.type != QETH_CARD_TYPE_IQD) { 876 if (qeth_hdr_chk_and_bounce(new_skb, &hdr, 877 sizeof(struct qeth_hdr_layer2))) 878 goto tx_drop; 879 rc = qeth_do_send_packet(card, queue, new_skb, hdr, 880 elements); 881 } else 882 rc = qeth_do_send_packet_fast(card, queue, new_skb, hdr, 883 elements, data_offset, hd_len); 884 if (!rc) { 885 card->stats.tx_packets++; 886 card->stats.tx_bytes += tx_bytes; 887 if (new_skb != skb) 888 dev_kfree_skb_any(skb); 889 rc = NETDEV_TX_OK; 890 } else { 891 if (data_offset >= 0) 892 kmem_cache_free(qeth_core_header_cache, hdr); 893 894 if (rc == -EBUSY) { 895 if (new_skb != skb) 896 dev_kfree_skb_any(new_skb); 897 return NETDEV_TX_BUSY; 898 } else 899 goto tx_drop; 900 } 901 902 netif_wake_queue(dev); 903 if (card->options.performance_stats) 904 card->perf_stats.outbound_time += qeth_get_micros() - 905 card->perf_stats.outbound_start_time; 906 return rc; 907 908 tx_drop: 909 card->stats.tx_dropped++; 910 card->stats.tx_errors++; 911 if ((new_skb != skb) && new_skb) 912 dev_kfree_skb_any(new_skb); 913 dev_kfree_skb_any(skb); 914 netif_wake_queue(dev); 915 return NETDEV_TX_OK; 916 } 917 918 static int __qeth_l2_open(struct net_device *dev) 919 { 920 struct qeth_card *card = dev->ml_priv; 921 int rc = 0; 922 923 QETH_CARD_TEXT(card, 4, "qethopen"); 924 if (card->state == CARD_STATE_UP) 925 return rc; 926 if (card->state != CARD_STATE_SOFTSETUP) 927 return -ENODEV; 928 929 if ((card->info.type != QETH_CARD_TYPE_OSN) && 930 (!(card->info.mac_bits & QETH_LAYER2_MAC_REGISTERED))) { 931 QETH_CARD_TEXT(card, 4, "nomacadr"); 932 return -EPERM; 933 } 934 card->data.state = CH_STATE_UP; 935 card->state = CARD_STATE_UP; 936 netif_start_queue(dev); 937 938 if (qdio_stop_irq(card->data.ccwdev, 0) >= 0) { 939 napi_enable(&card->napi); 940 napi_schedule(&card->napi); 941 } else 942 rc = -EIO; 943 return rc; 944 } 945 946 static int qeth_l2_open(struct net_device *dev) 947 { 948 struct qeth_card *card = dev->ml_priv; 949 950 QETH_CARD_TEXT(card, 5, "qethope_"); 951 if (qeth_wait_for_threads(card, QETH_RECOVER_THREAD)) { 952 QETH_CARD_TEXT(card, 3, "openREC"); 953 return -ERESTARTSYS; 954 } 955 return __qeth_l2_open(dev); 956 } 957 958 static int qeth_l2_stop(struct net_device *dev) 959 { 960 struct qeth_card *card = dev->ml_priv; 961 962 QETH_CARD_TEXT(card, 4, "qethstop"); 963 netif_tx_disable(dev); 964 if (card->state == CARD_STATE_UP) { 965 card->state = CARD_STATE_SOFTSETUP; 966 napi_disable(&card->napi); 967 } 968 return 0; 969 } 970 971 static int qeth_l2_probe_device(struct ccwgroup_device *gdev) 972 { 973 struct qeth_card *card = dev_get_drvdata(&gdev->dev); 974 975 qeth_l2_create_device_attributes(&gdev->dev); 976 INIT_LIST_HEAD(&card->vid_list); 977 INIT_LIST_HEAD(&card->mc_list); 978 card->options.layer2 = 1; 979 card->info.hwtrap = 0; 980 return 0; 981 } 982 983 static void qeth_l2_remove_device(struct ccwgroup_device *cgdev) 984 { 985 struct qeth_card *card = dev_get_drvdata(&cgdev->dev); 986 987 qeth_l2_remove_device_attributes(&cgdev->dev); 988 qeth_set_allowed_threads(card, 0, 1); 989 wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0); 990 991 if (cgdev->state == CCWGROUP_ONLINE) 992 qeth_l2_set_offline(cgdev); 993 994 if (card->dev) { 995 unregister_netdev(card->dev); 996 card->dev = NULL; 997 } 998 return; 999 } 1000 1001 static const struct ethtool_ops qeth_l2_ethtool_ops = { 1002 .get_link = ethtool_op_get_link, 1003 .get_strings = qeth_core_get_strings, 1004 .get_ethtool_stats = qeth_core_get_ethtool_stats, 1005 .get_sset_count = qeth_core_get_sset_count, 1006 .get_drvinfo = qeth_core_get_drvinfo, 1007 .get_settings = qeth_core_ethtool_get_settings, 1008 }; 1009 1010 static const struct ethtool_ops qeth_l2_osn_ops = { 1011 .get_strings = qeth_core_get_strings, 1012 .get_ethtool_stats = qeth_core_get_ethtool_stats, 1013 .get_sset_count = qeth_core_get_sset_count, 1014 .get_drvinfo = qeth_core_get_drvinfo, 1015 }; 1016 1017 static const struct net_device_ops qeth_l2_netdev_ops = { 1018 .ndo_open = qeth_l2_open, 1019 .ndo_stop = qeth_l2_stop, 1020 .ndo_get_stats = qeth_get_stats, 1021 .ndo_start_xmit = qeth_l2_hard_start_xmit, 1022 .ndo_validate_addr = eth_validate_addr, 1023 .ndo_set_rx_mode = qeth_l2_set_multicast_list, 1024 .ndo_do_ioctl = qeth_l2_do_ioctl, 1025 .ndo_set_mac_address = qeth_l2_set_mac_address, 1026 .ndo_change_mtu = qeth_change_mtu, 1027 .ndo_vlan_rx_add_vid = qeth_l2_vlan_rx_add_vid, 1028 .ndo_vlan_rx_kill_vid = qeth_l2_vlan_rx_kill_vid, 1029 .ndo_tx_timeout = qeth_tx_timeout, 1030 .ndo_fix_features = qeth_l2_fix_features, 1031 .ndo_set_features = qeth_l2_set_features 1032 }; 1033 1034 static int qeth_l2_setup_netdev(struct qeth_card *card) 1035 { 1036 switch (card->info.type) { 1037 case QETH_CARD_TYPE_IQD: 1038 card->dev = alloc_netdev(0, "hsi%d", NET_NAME_UNKNOWN, 1039 ether_setup); 1040 break; 1041 case QETH_CARD_TYPE_OSN: 1042 card->dev = alloc_netdev(0, "osn%d", NET_NAME_UNKNOWN, 1043 ether_setup); 1044 card->dev->flags |= IFF_NOARP; 1045 break; 1046 default: 1047 card->dev = alloc_etherdev(0); 1048 } 1049 1050 if (!card->dev) 1051 return -ENODEV; 1052 1053 card->dev->ml_priv = card; 1054 card->dev->watchdog_timeo = QETH_TX_TIMEOUT; 1055 card->dev->mtu = card->info.initial_mtu; 1056 card->dev->netdev_ops = &qeth_l2_netdev_ops; 1057 card->dev->ethtool_ops = 1058 (card->info.type != QETH_CARD_TYPE_OSN) ? 1059 &qeth_l2_ethtool_ops : &qeth_l2_osn_ops; 1060 card->dev->features |= NETIF_F_HW_VLAN_CTAG_FILTER; 1061 if (card->info.type == QETH_CARD_TYPE_OSD && !card->info.guestlan) { 1062 card->dev->hw_features = NETIF_F_IP_CSUM | NETIF_F_RXCSUM; 1063 /* Turn on RX offloading per default */ 1064 card->dev->features |= NETIF_F_RXCSUM; 1065 } 1066 card->info.broadcast_capable = 1; 1067 qeth_l2_request_initial_mac(card); 1068 SET_NETDEV_DEV(card->dev, &card->gdev->dev); 1069 netif_napi_add(card->dev, &card->napi, qeth_l2_poll, QETH_NAPI_WEIGHT); 1070 return register_netdev(card->dev); 1071 } 1072 1073 static int qeth_l2_start_ipassists(struct qeth_card *card) 1074 { 1075 /* configure isolation level */ 1076 if (qeth_set_access_ctrl_online(card, 0)) 1077 return -ENODEV; 1078 if (qeth_is_supported(card, IPA_INBOUND_CHECKSUM)) 1079 qeth_set_rx_csum(card, 1); 1080 qeth_start_ipa_tx_checksum(card); 1081 return 0; 1082 } 1083 1084 static int __qeth_l2_set_online(struct ccwgroup_device *gdev, int recovery_mode) 1085 { 1086 struct qeth_card *card = dev_get_drvdata(&gdev->dev); 1087 int rc = 0; 1088 enum qeth_card_states recover_flag; 1089 1090 mutex_lock(&card->discipline_mutex); 1091 mutex_lock(&card->conf_mutex); 1092 QETH_DBF_TEXT(SETUP, 2, "setonlin"); 1093 QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *)); 1094 1095 recover_flag = card->state; 1096 rc = qeth_core_hardsetup_card(card); 1097 if (rc) { 1098 QETH_DBF_TEXT_(SETUP, 2, "2err%04x", rc); 1099 rc = -ENODEV; 1100 goto out_remove; 1101 } 1102 qeth_bridgeport_query_support(card); 1103 if (card->options.sbp.supported_funcs) 1104 dev_info(&card->gdev->dev, 1105 "The device represents a Bridge Capable Port\n"); 1106 qeth_trace_features(card); 1107 1108 if (!card->dev && qeth_l2_setup_netdev(card)) { 1109 rc = -ENODEV; 1110 goto out_remove; 1111 } 1112 1113 if (card->info.type != QETH_CARD_TYPE_OSN) 1114 qeth_l2_send_setmac(card, &card->dev->dev_addr[0]); 1115 1116 if (qeth_is_diagass_supported(card, QETH_DIAGS_CMD_TRAP)) { 1117 if (card->info.hwtrap && 1118 qeth_hw_trap(card, QETH_DIAGS_TRAP_ARM)) 1119 card->info.hwtrap = 0; 1120 } else 1121 card->info.hwtrap = 0; 1122 1123 qeth_l2_setup_bridgeport_attrs(card); 1124 1125 card->state = CARD_STATE_HARDSETUP; 1126 memset(&card->rx, 0, sizeof(struct qeth_rx)); 1127 qeth_print_status_message(card); 1128 1129 /* softsetup */ 1130 QETH_DBF_TEXT(SETUP, 2, "softsetp"); 1131 1132 rc = qeth_send_startlan(card); 1133 if (rc) { 1134 QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc); 1135 if (rc == 0xe080) { 1136 dev_warn(&card->gdev->dev, 1137 "The LAN is offline\n"); 1138 card->lan_online = 0; 1139 goto contin; 1140 } 1141 rc = -ENODEV; 1142 goto out_remove; 1143 } else 1144 card->lan_online = 1; 1145 1146 contin: 1147 if ((card->info.type == QETH_CARD_TYPE_OSD) || 1148 (card->info.type == QETH_CARD_TYPE_OSX)) { 1149 if (qeth_l2_start_ipassists(card)) 1150 goto out_remove; 1151 } 1152 1153 if (card->info.type != QETH_CARD_TYPE_OSN && 1154 card->info.type != QETH_CARD_TYPE_OSM) 1155 qeth_l2_process_vlans(card); 1156 1157 netif_tx_disable(card->dev); 1158 1159 rc = qeth_init_qdio_queues(card); 1160 if (rc) { 1161 QETH_DBF_TEXT_(SETUP, 2, "6err%d", rc); 1162 rc = -ENODEV; 1163 goto out_remove; 1164 } 1165 card->state = CARD_STATE_SOFTSETUP; 1166 if (card->lan_online) 1167 netif_carrier_on(card->dev); 1168 else 1169 netif_carrier_off(card->dev); 1170 1171 qeth_set_allowed_threads(card, 0xffffffff, 0); 1172 if (recover_flag == CARD_STATE_RECOVER) { 1173 if (recovery_mode && 1174 card->info.type != QETH_CARD_TYPE_OSN) { 1175 __qeth_l2_open(card->dev); 1176 } else { 1177 rtnl_lock(); 1178 dev_open(card->dev); 1179 rtnl_unlock(); 1180 } 1181 /* this also sets saved unicast addresses */ 1182 qeth_l2_set_multicast_list(card->dev); 1183 } 1184 /* let user_space know that device is online */ 1185 kobject_uevent(&gdev->dev.kobj, KOBJ_CHANGE); 1186 mutex_unlock(&card->conf_mutex); 1187 mutex_unlock(&card->discipline_mutex); 1188 return 0; 1189 1190 out_remove: 1191 qeth_l2_stop_card(card, 0); 1192 ccw_device_set_offline(CARD_DDEV(card)); 1193 ccw_device_set_offline(CARD_WDEV(card)); 1194 ccw_device_set_offline(CARD_RDEV(card)); 1195 qdio_free(CARD_DDEV(card)); 1196 if (recover_flag == CARD_STATE_RECOVER) 1197 card->state = CARD_STATE_RECOVER; 1198 else 1199 card->state = CARD_STATE_DOWN; 1200 mutex_unlock(&card->conf_mutex); 1201 mutex_unlock(&card->discipline_mutex); 1202 return rc; 1203 } 1204 1205 static int qeth_l2_set_online(struct ccwgroup_device *gdev) 1206 { 1207 return __qeth_l2_set_online(gdev, 0); 1208 } 1209 1210 static int __qeth_l2_set_offline(struct ccwgroup_device *cgdev, 1211 int recovery_mode) 1212 { 1213 struct qeth_card *card = dev_get_drvdata(&cgdev->dev); 1214 int rc = 0, rc2 = 0, rc3 = 0; 1215 enum qeth_card_states recover_flag; 1216 1217 mutex_lock(&card->discipline_mutex); 1218 mutex_lock(&card->conf_mutex); 1219 QETH_DBF_TEXT(SETUP, 3, "setoffl"); 1220 QETH_DBF_HEX(SETUP, 3, &card, sizeof(void *)); 1221 1222 if (card->dev && netif_carrier_ok(card->dev)) 1223 netif_carrier_off(card->dev); 1224 recover_flag = card->state; 1225 if ((!recovery_mode && card->info.hwtrap) || card->info.hwtrap == 2) { 1226 qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM); 1227 card->info.hwtrap = 1; 1228 } 1229 qeth_l2_stop_card(card, recovery_mode); 1230 rc = ccw_device_set_offline(CARD_DDEV(card)); 1231 rc2 = ccw_device_set_offline(CARD_WDEV(card)); 1232 rc3 = ccw_device_set_offline(CARD_RDEV(card)); 1233 if (!rc) 1234 rc = (rc2) ? rc2 : rc3; 1235 if (rc) 1236 QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc); 1237 qdio_free(CARD_DDEV(card)); 1238 if (recover_flag == CARD_STATE_UP) 1239 card->state = CARD_STATE_RECOVER; 1240 /* let user_space know that device is offline */ 1241 kobject_uevent(&cgdev->dev.kobj, KOBJ_CHANGE); 1242 mutex_unlock(&card->conf_mutex); 1243 mutex_unlock(&card->discipline_mutex); 1244 return 0; 1245 } 1246 1247 static int qeth_l2_set_offline(struct ccwgroup_device *cgdev) 1248 { 1249 return __qeth_l2_set_offline(cgdev, 0); 1250 } 1251 1252 static int qeth_l2_recover(void *ptr) 1253 { 1254 struct qeth_card *card; 1255 int rc = 0; 1256 1257 card = (struct qeth_card *) ptr; 1258 QETH_CARD_TEXT(card, 2, "recover1"); 1259 if (!qeth_do_run_thread(card, QETH_RECOVER_THREAD)) 1260 return 0; 1261 QETH_CARD_TEXT(card, 2, "recover2"); 1262 dev_warn(&card->gdev->dev, 1263 "A recovery process has been started for the device\n"); 1264 qeth_set_recovery_task(card); 1265 __qeth_l2_set_offline(card->gdev, 1); 1266 rc = __qeth_l2_set_online(card->gdev, 1); 1267 if (!rc) 1268 dev_info(&card->gdev->dev, 1269 "Device successfully recovered!\n"); 1270 else { 1271 qeth_close_dev(card); 1272 dev_warn(&card->gdev->dev, "The qeth device driver " 1273 "failed to recover an error on the device\n"); 1274 } 1275 qeth_clear_recovery_task(card); 1276 qeth_clear_thread_start_bit(card, QETH_RECOVER_THREAD); 1277 qeth_clear_thread_running_bit(card, QETH_RECOVER_THREAD); 1278 return 0; 1279 } 1280 1281 static int __init qeth_l2_init(void) 1282 { 1283 pr_info("register layer 2 discipline\n"); 1284 return 0; 1285 } 1286 1287 static void __exit qeth_l2_exit(void) 1288 { 1289 pr_info("unregister layer 2 discipline\n"); 1290 } 1291 1292 static void qeth_l2_shutdown(struct ccwgroup_device *gdev) 1293 { 1294 struct qeth_card *card = dev_get_drvdata(&gdev->dev); 1295 qeth_set_allowed_threads(card, 0, 1); 1296 if ((gdev->state == CCWGROUP_ONLINE) && card->info.hwtrap) 1297 qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM); 1298 qeth_qdio_clear_card(card, 0); 1299 qeth_clear_qdio_buffers(card); 1300 qdio_free(CARD_DDEV(card)); 1301 } 1302 1303 static int qeth_l2_pm_suspend(struct ccwgroup_device *gdev) 1304 { 1305 struct qeth_card *card = dev_get_drvdata(&gdev->dev); 1306 1307 if (card->dev) 1308 netif_device_detach(card->dev); 1309 qeth_set_allowed_threads(card, 0, 1); 1310 wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0); 1311 if (gdev->state == CCWGROUP_OFFLINE) 1312 return 0; 1313 if (card->state == CARD_STATE_UP) { 1314 if (card->info.hwtrap) 1315 qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM); 1316 __qeth_l2_set_offline(card->gdev, 1); 1317 } else 1318 __qeth_l2_set_offline(card->gdev, 0); 1319 return 0; 1320 } 1321 1322 static int qeth_l2_pm_resume(struct ccwgroup_device *gdev) 1323 { 1324 struct qeth_card *card = dev_get_drvdata(&gdev->dev); 1325 int rc = 0; 1326 1327 if (gdev->state == CCWGROUP_OFFLINE) 1328 goto out; 1329 1330 if (card->state == CARD_STATE_RECOVER) { 1331 rc = __qeth_l2_set_online(card->gdev, 1); 1332 if (rc) { 1333 rtnl_lock(); 1334 dev_close(card->dev); 1335 rtnl_unlock(); 1336 } 1337 } else 1338 rc = __qeth_l2_set_online(card->gdev, 0); 1339 out: 1340 qeth_set_allowed_threads(card, 0xffffffff, 0); 1341 if (card->dev) 1342 netif_device_attach(card->dev); 1343 if (rc) 1344 dev_warn(&card->gdev->dev, "The qeth device driver " 1345 "failed to recover an error on the device\n"); 1346 return rc; 1347 } 1348 1349 /* Returns zero if the command is successfully "consumed" */ 1350 static int qeth_l2_control_event(struct qeth_card *card, 1351 struct qeth_ipa_cmd *cmd) 1352 { 1353 switch (cmd->hdr.command) { 1354 case IPA_CMD_SETBRIDGEPORT_OSA: 1355 case IPA_CMD_SETBRIDGEPORT_IQD: 1356 if (cmd->data.sbp.hdr.command_code == 1357 IPA_SBP_BRIDGE_PORT_STATE_CHANGE) { 1358 qeth_bridge_state_change(card, cmd); 1359 return 0; 1360 } else 1361 return 1; 1362 case IPA_CMD_ADDRESS_CHANGE_NOTIF: 1363 qeth_bridge_host_event(card, cmd); 1364 return 0; 1365 default: 1366 return 1; 1367 } 1368 } 1369 1370 struct qeth_discipline qeth_l2_discipline = { 1371 .start_poll = qeth_qdio_start_poll, 1372 .input_handler = (qdio_handler_t *) qeth_qdio_input_handler, 1373 .output_handler = (qdio_handler_t *) qeth_qdio_output_handler, 1374 .recover = qeth_l2_recover, 1375 .setup = qeth_l2_probe_device, 1376 .remove = qeth_l2_remove_device, 1377 .set_online = qeth_l2_set_online, 1378 .set_offline = qeth_l2_set_offline, 1379 .shutdown = qeth_l2_shutdown, 1380 .freeze = qeth_l2_pm_suspend, 1381 .thaw = qeth_l2_pm_resume, 1382 .restore = qeth_l2_pm_resume, 1383 .control_event_handler = qeth_l2_control_event, 1384 }; 1385 EXPORT_SYMBOL_GPL(qeth_l2_discipline); 1386 1387 static int qeth_osn_send_control_data(struct qeth_card *card, int len, 1388 struct qeth_cmd_buffer *iob) 1389 { 1390 unsigned long flags; 1391 int rc = 0; 1392 1393 QETH_CARD_TEXT(card, 5, "osndctrd"); 1394 1395 wait_event(card->wait_q, 1396 atomic_cmpxchg(&card->write.irq_pending, 0, 1) == 0); 1397 qeth_prepare_control_data(card, len, iob); 1398 QETH_CARD_TEXT(card, 6, "osnoirqp"); 1399 spin_lock_irqsave(get_ccwdev_lock(card->write.ccwdev), flags); 1400 rc = ccw_device_start(card->write.ccwdev, &card->write.ccw, 1401 (addr_t) iob, 0, 0); 1402 spin_unlock_irqrestore(get_ccwdev_lock(card->write.ccwdev), flags); 1403 if (rc) { 1404 QETH_DBF_MESSAGE(2, "qeth_osn_send_control_data: " 1405 "ccw_device_start rc = %i\n", rc); 1406 QETH_CARD_TEXT_(card, 2, " err%d", rc); 1407 qeth_release_buffer(iob->channel, iob); 1408 atomic_set(&card->write.irq_pending, 0); 1409 wake_up(&card->wait_q); 1410 } 1411 return rc; 1412 } 1413 1414 static int qeth_osn_send_ipa_cmd(struct qeth_card *card, 1415 struct qeth_cmd_buffer *iob, int data_len) 1416 { 1417 u16 s1, s2; 1418 1419 QETH_CARD_TEXT(card, 4, "osndipa"); 1420 1421 qeth_prepare_ipa_cmd(card, iob, QETH_PROT_OSN2); 1422 s1 = (u16)(IPA_PDU_HEADER_SIZE + data_len); 1423 s2 = (u16)data_len; 1424 memcpy(QETH_IPA_PDU_LEN_TOTAL(iob->data), &s1, 2); 1425 memcpy(QETH_IPA_PDU_LEN_PDU1(iob->data), &s2, 2); 1426 memcpy(QETH_IPA_PDU_LEN_PDU2(iob->data), &s2, 2); 1427 memcpy(QETH_IPA_PDU_LEN_PDU3(iob->data), &s2, 2); 1428 return qeth_osn_send_control_data(card, s1, iob); 1429 } 1430 1431 int qeth_osn_assist(struct net_device *dev, void *data, int data_len) 1432 { 1433 struct qeth_cmd_buffer *iob; 1434 struct qeth_card *card; 1435 int rc; 1436 1437 if (!dev) 1438 return -ENODEV; 1439 card = dev->ml_priv; 1440 if (!card) 1441 return -ENODEV; 1442 QETH_CARD_TEXT(card, 2, "osnsdmc"); 1443 if (!qeth_card_hw_is_reachable(card)) 1444 return -ENODEV; 1445 iob = qeth_wait_for_buffer(&card->write); 1446 memcpy(iob->data+IPA_PDU_HEADER_SIZE, data, data_len); 1447 rc = qeth_osn_send_ipa_cmd(card, iob, data_len); 1448 return rc; 1449 } 1450 EXPORT_SYMBOL(qeth_osn_assist); 1451 1452 int qeth_osn_register(unsigned char *read_dev_no, struct net_device **dev, 1453 int (*assist_cb)(struct net_device *, void *), 1454 int (*data_cb)(struct sk_buff *)) 1455 { 1456 struct qeth_card *card; 1457 1458 *dev = qeth_l2_netdev_by_devno(read_dev_no); 1459 if (*dev == NULL) 1460 return -ENODEV; 1461 card = (*dev)->ml_priv; 1462 if (!card) 1463 return -ENODEV; 1464 QETH_CARD_TEXT(card, 2, "osnreg"); 1465 if ((assist_cb == NULL) || (data_cb == NULL)) 1466 return -EINVAL; 1467 card->osn_info.assist_cb = assist_cb; 1468 card->osn_info.data_cb = data_cb; 1469 return 0; 1470 } 1471 EXPORT_SYMBOL(qeth_osn_register); 1472 1473 void qeth_osn_deregister(struct net_device *dev) 1474 { 1475 struct qeth_card *card; 1476 1477 if (!dev) 1478 return; 1479 card = dev->ml_priv; 1480 if (!card) 1481 return; 1482 QETH_CARD_TEXT(card, 2, "osndereg"); 1483 card->osn_info.assist_cb = NULL; 1484 card->osn_info.data_cb = NULL; 1485 return; 1486 } 1487 EXPORT_SYMBOL(qeth_osn_deregister); 1488 1489 /* SETBRIDGEPORT support, async notifications */ 1490 1491 enum qeth_an_event_type {anev_reg_unreg, anev_abort, anev_reset}; 1492 1493 /** 1494 * qeth_bridge_emit_host_event() - bridgeport address change notification 1495 * @card: qeth_card structure pointer, for udev events. 1496 * @evtype: "normal" register/unregister, or abort, or reset. For abort 1497 * and reset token and addr_lnid are unused and may be NULL. 1498 * @code: event bitmask: high order bit 0x80 value 1 means removal of an 1499 * object, 0 - addition of an object. 1500 * 0x01 - VLAN, 0x02 - MAC, 0x03 - VLAN and MAC. 1501 * @token: "network token" structure identifying physical address of the port. 1502 * @addr_lnid: pointer to structure with MAC address and VLAN ID. 1503 * 1504 * This function is called when registrations and deregistrations are 1505 * reported by the hardware, and also when notifications are enabled - 1506 * for all currently registered addresses. 1507 */ 1508 static void qeth_bridge_emit_host_event(struct qeth_card *card, 1509 enum qeth_an_event_type evtype, 1510 u8 code, struct net_if_token *token, struct mac_addr_lnid *addr_lnid) 1511 { 1512 char str[7][32]; 1513 char *env[8]; 1514 int i = 0; 1515 1516 switch (evtype) { 1517 case anev_reg_unreg: 1518 snprintf(str[i], sizeof(str[i]), "BRIDGEDHOST=%s", 1519 (code & IPA_ADDR_CHANGE_CODE_REMOVAL) 1520 ? "deregister" : "register"); 1521 env[i] = str[i]; i++; 1522 if (code & IPA_ADDR_CHANGE_CODE_VLANID) { 1523 snprintf(str[i], sizeof(str[i]), "VLAN=%d", 1524 addr_lnid->lnid); 1525 env[i] = str[i]; i++; 1526 } 1527 if (code & IPA_ADDR_CHANGE_CODE_MACADDR) { 1528 snprintf(str[i], sizeof(str[i]), "MAC=%pM", 1529 addr_lnid->mac); 1530 env[i] = str[i]; i++; 1531 } 1532 snprintf(str[i], sizeof(str[i]), "NTOK_BUSID=%x.%x.%04x", 1533 token->cssid, token->ssid, token->devnum); 1534 env[i] = str[i]; i++; 1535 snprintf(str[i], sizeof(str[i]), "NTOK_IID=%02x", token->iid); 1536 env[i] = str[i]; i++; 1537 snprintf(str[i], sizeof(str[i]), "NTOK_CHPID=%02x", 1538 token->chpid); 1539 env[i] = str[i]; i++; 1540 snprintf(str[i], sizeof(str[i]), "NTOK_CHID=%04x", token->chid); 1541 env[i] = str[i]; i++; 1542 break; 1543 case anev_abort: 1544 snprintf(str[i], sizeof(str[i]), "BRIDGEDHOST=abort"); 1545 env[i] = str[i]; i++; 1546 break; 1547 case anev_reset: 1548 snprintf(str[i], sizeof(str[i]), "BRIDGEDHOST=reset"); 1549 env[i] = str[i]; i++; 1550 break; 1551 } 1552 env[i] = NULL; 1553 kobject_uevent_env(&card->gdev->dev.kobj, KOBJ_CHANGE, env); 1554 } 1555 1556 struct qeth_bridge_state_data { 1557 struct work_struct worker; 1558 struct qeth_card *card; 1559 struct qeth_sbp_state_change qports; 1560 }; 1561 1562 static void qeth_bridge_state_change_worker(struct work_struct *work) 1563 { 1564 struct qeth_bridge_state_data *data = 1565 container_of(work, struct qeth_bridge_state_data, worker); 1566 /* We are only interested in the first entry - local port */ 1567 struct qeth_sbp_port_entry *entry = &data->qports.entry[0]; 1568 char env_locrem[32]; 1569 char env_role[32]; 1570 char env_state[32]; 1571 char *env[] = { 1572 env_locrem, 1573 env_role, 1574 env_state, 1575 NULL 1576 }; 1577 1578 /* Role should not change by itself, but if it did, */ 1579 /* information from the hardware is authoritative. */ 1580 mutex_lock(&data->card->conf_mutex); 1581 data->card->options.sbp.role = entry->role; 1582 mutex_unlock(&data->card->conf_mutex); 1583 1584 snprintf(env_locrem, sizeof(env_locrem), "BRIDGEPORT=statechange"); 1585 snprintf(env_role, sizeof(env_role), "ROLE=%s", 1586 (entry->role == QETH_SBP_ROLE_NONE) ? "none" : 1587 (entry->role == QETH_SBP_ROLE_PRIMARY) ? "primary" : 1588 (entry->role == QETH_SBP_ROLE_SECONDARY) ? "secondary" : 1589 "<INVALID>"); 1590 snprintf(env_state, sizeof(env_state), "STATE=%s", 1591 (entry->state == QETH_SBP_STATE_INACTIVE) ? "inactive" : 1592 (entry->state == QETH_SBP_STATE_STANDBY) ? "standby" : 1593 (entry->state == QETH_SBP_STATE_ACTIVE) ? "active" : 1594 "<INVALID>"); 1595 kobject_uevent_env(&data->card->gdev->dev.kobj, 1596 KOBJ_CHANGE, env); 1597 kfree(data); 1598 } 1599 1600 static void qeth_bridge_state_change(struct qeth_card *card, 1601 struct qeth_ipa_cmd *cmd) 1602 { 1603 struct qeth_sbp_state_change *qports = 1604 &cmd->data.sbp.data.state_change; 1605 struct qeth_bridge_state_data *data; 1606 int extrasize; 1607 1608 QETH_CARD_TEXT(card, 2, "brstchng"); 1609 if (qports->entry_length != sizeof(struct qeth_sbp_port_entry)) { 1610 QETH_CARD_TEXT_(card, 2, "BPsz%04x", qports->entry_length); 1611 return; 1612 } 1613 extrasize = sizeof(struct qeth_sbp_port_entry) * qports->num_entries; 1614 data = kzalloc(sizeof(struct qeth_bridge_state_data) + extrasize, 1615 GFP_ATOMIC); 1616 if (!data) { 1617 QETH_CARD_TEXT(card, 2, "BPSalloc"); 1618 return; 1619 } 1620 INIT_WORK(&data->worker, qeth_bridge_state_change_worker); 1621 data->card = card; 1622 memcpy(&data->qports, qports, 1623 sizeof(struct qeth_sbp_state_change) + extrasize); 1624 queue_work(qeth_wq, &data->worker); 1625 } 1626 1627 struct qeth_bridge_host_data { 1628 struct work_struct worker; 1629 struct qeth_card *card; 1630 struct qeth_ipacmd_addr_change hostevs; 1631 }; 1632 1633 static void qeth_bridge_host_event_worker(struct work_struct *work) 1634 { 1635 struct qeth_bridge_host_data *data = 1636 container_of(work, struct qeth_bridge_host_data, worker); 1637 int i; 1638 1639 if (data->hostevs.lost_event_mask) { 1640 dev_info(&data->card->gdev->dev, 1641 "Address notification from the Bridge Port stopped %s (%s)\n", 1642 data->card->dev->name, 1643 (data->hostevs.lost_event_mask == 0x01) 1644 ? "Overflow" 1645 : (data->hostevs.lost_event_mask == 0x02) 1646 ? "Bridge port state change" 1647 : "Unknown reason"); 1648 mutex_lock(&data->card->conf_mutex); 1649 data->card->options.sbp.hostnotification = 0; 1650 mutex_unlock(&data->card->conf_mutex); 1651 qeth_bridge_emit_host_event(data->card, anev_abort, 1652 0, NULL, NULL); 1653 } else 1654 for (i = 0; i < data->hostevs.num_entries; i++) { 1655 struct qeth_ipacmd_addr_change_entry *entry = 1656 &data->hostevs.entry[i]; 1657 qeth_bridge_emit_host_event(data->card, 1658 anev_reg_unreg, 1659 entry->change_code, 1660 &entry->token, &entry->addr_lnid); 1661 } 1662 kfree(data); 1663 } 1664 1665 static void qeth_bridge_host_event(struct qeth_card *card, 1666 struct qeth_ipa_cmd *cmd) 1667 { 1668 struct qeth_ipacmd_addr_change *hostevs = 1669 &cmd->data.addrchange; 1670 struct qeth_bridge_host_data *data; 1671 int extrasize; 1672 1673 QETH_CARD_TEXT(card, 2, "brhostev"); 1674 if (cmd->hdr.return_code != 0x0000) { 1675 if (cmd->hdr.return_code == 0x0010) { 1676 if (hostevs->lost_event_mask == 0x00) 1677 hostevs->lost_event_mask = 0xff; 1678 } else { 1679 QETH_CARD_TEXT_(card, 2, "BPHe%04x", 1680 cmd->hdr.return_code); 1681 return; 1682 } 1683 } 1684 extrasize = sizeof(struct qeth_ipacmd_addr_change_entry) * 1685 hostevs->num_entries; 1686 data = kzalloc(sizeof(struct qeth_bridge_host_data) + extrasize, 1687 GFP_ATOMIC); 1688 if (!data) { 1689 QETH_CARD_TEXT(card, 2, "BPHalloc"); 1690 return; 1691 } 1692 INIT_WORK(&data->worker, qeth_bridge_host_event_worker); 1693 data->card = card; 1694 memcpy(&data->hostevs, hostevs, 1695 sizeof(struct qeth_ipacmd_addr_change) + extrasize); 1696 queue_work(qeth_wq, &data->worker); 1697 } 1698 1699 /* SETBRIDGEPORT support; sending commands */ 1700 1701 struct _qeth_sbp_cbctl { 1702 u16 ipa_rc; 1703 u16 cmd_rc; 1704 union { 1705 u32 supported; 1706 struct { 1707 enum qeth_sbp_roles *role; 1708 enum qeth_sbp_states *state; 1709 } qports; 1710 } data; 1711 }; 1712 1713 /** 1714 * qeth_bridgeport_makerc() - derive "traditional" error from hardware codes. 1715 * @card: qeth_card structure pointer, for debug messages. 1716 * @cbctl: state structure with hardware return codes. 1717 * @setcmd: IPA command code 1718 * 1719 * Returns negative errno-compatible error indication or 0 on success. 1720 */ 1721 static int qeth_bridgeport_makerc(struct qeth_card *card, 1722 struct _qeth_sbp_cbctl *cbctl, enum qeth_ipa_sbp_cmd setcmd) 1723 { 1724 int rc; 1725 int is_iqd = (card->info.type == QETH_CARD_TYPE_IQD); 1726 1727 if ((is_iqd && (cbctl->ipa_rc == IPA_RC_SUCCESS)) || 1728 (!is_iqd && (cbctl->ipa_rc == cbctl->cmd_rc))) 1729 switch (cbctl->cmd_rc) { 1730 case 0x0000: 1731 rc = 0; 1732 break; 1733 case 0x2B04: 1734 case 0x0004: 1735 rc = -EOPNOTSUPP; 1736 break; 1737 case 0x2B0C: 1738 case 0x000C: /* Not configured as bridge Port */ 1739 rc = -ENODEV; /* maybe not the best code here? */ 1740 dev_err(&card->gdev->dev, 1741 "The device is not configured as a Bridge Port\n"); 1742 break; 1743 case 0x2B14: 1744 case 0x0014: /* Another device is Primary */ 1745 switch (setcmd) { 1746 case IPA_SBP_SET_PRIMARY_BRIDGE_PORT: 1747 rc = -EEXIST; 1748 dev_err(&card->gdev->dev, 1749 "The LAN already has a primary Bridge Port\n"); 1750 break; 1751 case IPA_SBP_SET_SECONDARY_BRIDGE_PORT: 1752 rc = -EBUSY; 1753 dev_err(&card->gdev->dev, 1754 "The device is already a primary Bridge Port\n"); 1755 break; 1756 default: 1757 rc = -EIO; 1758 } 1759 break; 1760 case 0x2B18: 1761 case 0x0018: /* This device is currently Secondary */ 1762 rc = -EBUSY; 1763 dev_err(&card->gdev->dev, 1764 "The device is already a secondary Bridge Port\n"); 1765 break; 1766 case 0x2B1C: 1767 case 0x001C: /* Limit for Secondary devices reached */ 1768 rc = -EEXIST; 1769 dev_err(&card->gdev->dev, 1770 "The LAN cannot have more secondary Bridge Ports\n"); 1771 break; 1772 case 0x2B24: 1773 case 0x0024: /* This device is currently Primary */ 1774 rc = -EBUSY; 1775 dev_err(&card->gdev->dev, 1776 "The device is already a primary Bridge Port\n"); 1777 break; 1778 case 0x2B20: 1779 case 0x0020: /* Not authorized by zManager */ 1780 rc = -EACCES; 1781 dev_err(&card->gdev->dev, 1782 "The device is not authorized to be a Bridge Port\n"); 1783 break; 1784 default: 1785 rc = -EIO; 1786 } 1787 else 1788 switch (cbctl->ipa_rc) { 1789 case IPA_RC_NOTSUPP: 1790 rc = -EOPNOTSUPP; 1791 break; 1792 case IPA_RC_UNSUPPORTED_COMMAND: 1793 rc = -EOPNOTSUPP; 1794 break; 1795 default: 1796 rc = -EIO; 1797 } 1798 1799 if (rc) { 1800 QETH_CARD_TEXT_(card, 2, "SBPi%04x", cbctl->ipa_rc); 1801 QETH_CARD_TEXT_(card, 2, "SBPc%04x", cbctl->cmd_rc); 1802 } 1803 return rc; 1804 } 1805 1806 static inline int ipa_cmd_sbp(struct qeth_card *card) 1807 { 1808 return (card->info.type == QETH_CARD_TYPE_IQD) ? 1809 IPA_CMD_SETBRIDGEPORT_IQD : 1810 IPA_CMD_SETBRIDGEPORT_OSA; 1811 } 1812 1813 static int qeth_bridgeport_query_support_cb(struct qeth_card *card, 1814 struct qeth_reply *reply, unsigned long data) 1815 { 1816 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data; 1817 struct _qeth_sbp_cbctl *cbctl = (struct _qeth_sbp_cbctl *)reply->param; 1818 QETH_CARD_TEXT(card, 2, "brqsupcb"); 1819 cbctl->ipa_rc = cmd->hdr.return_code; 1820 cbctl->cmd_rc = cmd->data.sbp.hdr.return_code; 1821 if ((cbctl->ipa_rc == 0) && (cbctl->cmd_rc == 0)) { 1822 cbctl->data.supported = 1823 cmd->data.sbp.data.query_cmds_supp.supported_cmds; 1824 } else { 1825 cbctl->data.supported = 0; 1826 } 1827 return 0; 1828 } 1829 1830 /** 1831 * qeth_bridgeport_query_support() - store bitmask of supported subfunctions. 1832 * @card: qeth_card structure pointer. 1833 * 1834 * Sets bitmask of supported setbridgeport subfunctions in the qeth_card 1835 * strucutre: card->options.sbp.supported_funcs. 1836 */ 1837 static void qeth_bridgeport_query_support(struct qeth_card *card) 1838 { 1839 struct qeth_cmd_buffer *iob; 1840 struct qeth_ipa_cmd *cmd; 1841 struct _qeth_sbp_cbctl cbctl; 1842 1843 QETH_CARD_TEXT(card, 2, "brqsuppo"); 1844 iob = qeth_get_ipacmd_buffer(card, ipa_cmd_sbp(card), 0); 1845 if (!iob) 1846 return; 1847 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE); 1848 cmd->data.sbp.hdr.cmdlength = 1849 sizeof(struct qeth_ipacmd_sbp_hdr) + 1850 sizeof(struct qeth_sbp_query_cmds_supp); 1851 cmd->data.sbp.hdr.command_code = 1852 IPA_SBP_QUERY_COMMANDS_SUPPORTED; 1853 cmd->data.sbp.hdr.used_total = 1; 1854 cmd->data.sbp.hdr.seq_no = 1; 1855 if (qeth_send_ipa_cmd(card, iob, qeth_bridgeport_query_support_cb, 1856 (void *)&cbctl) || 1857 qeth_bridgeport_makerc(card, &cbctl, 1858 IPA_SBP_QUERY_COMMANDS_SUPPORTED)) { 1859 /* non-zero makerc signifies failure, and produce messages */ 1860 card->options.sbp.role = QETH_SBP_ROLE_NONE; 1861 return; 1862 } 1863 card->options.sbp.supported_funcs = cbctl.data.supported; 1864 } 1865 1866 static int qeth_bridgeport_query_ports_cb(struct qeth_card *card, 1867 struct qeth_reply *reply, unsigned long data) 1868 { 1869 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data; 1870 struct qeth_sbp_query_ports *qports = &cmd->data.sbp.data.query_ports; 1871 struct _qeth_sbp_cbctl *cbctl = (struct _qeth_sbp_cbctl *)reply->param; 1872 1873 QETH_CARD_TEXT(card, 2, "brqprtcb"); 1874 cbctl->ipa_rc = cmd->hdr.return_code; 1875 cbctl->cmd_rc = cmd->data.sbp.hdr.return_code; 1876 if ((cbctl->ipa_rc != 0) || (cbctl->cmd_rc != 0)) 1877 return 0; 1878 if (qports->entry_length != sizeof(struct qeth_sbp_port_entry)) { 1879 cbctl->cmd_rc = 0xffff; 1880 QETH_CARD_TEXT_(card, 2, "SBPs%04x", qports->entry_length); 1881 return 0; 1882 } 1883 /* first entry contains the state of the local port */ 1884 if (qports->num_entries > 0) { 1885 if (cbctl->data.qports.role) 1886 *cbctl->data.qports.role = qports->entry[0].role; 1887 if (cbctl->data.qports.state) 1888 *cbctl->data.qports.state = qports->entry[0].state; 1889 } 1890 return 0; 1891 } 1892 1893 /** 1894 * qeth_bridgeport_query_ports() - query local bridgeport status. 1895 * @card: qeth_card structure pointer. 1896 * @role: Role of the port: 0-none, 1-primary, 2-secondary. 1897 * @state: State of the port: 0-inactive, 1-standby, 2-active. 1898 * 1899 * Returns negative errno-compatible error indication or 0 on success. 1900 * 1901 * 'role' and 'state' are not updated in case of hardware operation failure. 1902 */ 1903 int qeth_bridgeport_query_ports(struct qeth_card *card, 1904 enum qeth_sbp_roles *role, enum qeth_sbp_states *state) 1905 { 1906 int rc = 0; 1907 struct qeth_cmd_buffer *iob; 1908 struct qeth_ipa_cmd *cmd; 1909 struct _qeth_sbp_cbctl cbctl = { 1910 .data = { 1911 .qports = { 1912 .role = role, 1913 .state = state, 1914 }, 1915 }, 1916 }; 1917 1918 QETH_CARD_TEXT(card, 2, "brqports"); 1919 if (!(card->options.sbp.supported_funcs & IPA_SBP_QUERY_BRIDGE_PORTS)) 1920 return -EOPNOTSUPP; 1921 iob = qeth_get_ipacmd_buffer(card, ipa_cmd_sbp(card), 0); 1922 if (!iob) 1923 return -ENOMEM; 1924 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE); 1925 cmd->data.sbp.hdr.cmdlength = 1926 sizeof(struct qeth_ipacmd_sbp_hdr); 1927 cmd->data.sbp.hdr.command_code = 1928 IPA_SBP_QUERY_BRIDGE_PORTS; 1929 cmd->data.sbp.hdr.used_total = 1; 1930 cmd->data.sbp.hdr.seq_no = 1; 1931 rc = qeth_send_ipa_cmd(card, iob, qeth_bridgeport_query_ports_cb, 1932 (void *)&cbctl); 1933 if (rc < 0) 1934 return rc; 1935 return qeth_bridgeport_makerc(card, &cbctl, IPA_SBP_QUERY_BRIDGE_PORTS); 1936 } 1937 EXPORT_SYMBOL_GPL(qeth_bridgeport_query_ports); 1938 1939 static int qeth_bridgeport_set_cb(struct qeth_card *card, 1940 struct qeth_reply *reply, unsigned long data) 1941 { 1942 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *)data; 1943 struct _qeth_sbp_cbctl *cbctl = (struct _qeth_sbp_cbctl *)reply->param; 1944 QETH_CARD_TEXT(card, 2, "brsetrcb"); 1945 cbctl->ipa_rc = cmd->hdr.return_code; 1946 cbctl->cmd_rc = cmd->data.sbp.hdr.return_code; 1947 return 0; 1948 } 1949 1950 /** 1951 * qeth_bridgeport_setrole() - Assign primary role to the port. 1952 * @card: qeth_card structure pointer. 1953 * @role: Role to assign. 1954 * 1955 * Returns negative errno-compatible error indication or 0 on success. 1956 */ 1957 int qeth_bridgeport_setrole(struct qeth_card *card, enum qeth_sbp_roles role) 1958 { 1959 int rc = 0; 1960 int cmdlength; 1961 struct qeth_cmd_buffer *iob; 1962 struct qeth_ipa_cmd *cmd; 1963 struct _qeth_sbp_cbctl cbctl; 1964 enum qeth_ipa_sbp_cmd setcmd; 1965 1966 QETH_CARD_TEXT(card, 2, "brsetrol"); 1967 switch (role) { 1968 case QETH_SBP_ROLE_NONE: 1969 setcmd = IPA_SBP_RESET_BRIDGE_PORT_ROLE; 1970 cmdlength = sizeof(struct qeth_ipacmd_sbp_hdr) + 1971 sizeof(struct qeth_sbp_reset_role); 1972 break; 1973 case QETH_SBP_ROLE_PRIMARY: 1974 setcmd = IPA_SBP_SET_PRIMARY_BRIDGE_PORT; 1975 cmdlength = sizeof(struct qeth_ipacmd_sbp_hdr) + 1976 sizeof(struct qeth_sbp_set_primary); 1977 break; 1978 case QETH_SBP_ROLE_SECONDARY: 1979 setcmd = IPA_SBP_SET_SECONDARY_BRIDGE_PORT; 1980 cmdlength = sizeof(struct qeth_ipacmd_sbp_hdr) + 1981 sizeof(struct qeth_sbp_set_secondary); 1982 break; 1983 default: 1984 return -EINVAL; 1985 } 1986 if (!(card->options.sbp.supported_funcs & setcmd)) 1987 return -EOPNOTSUPP; 1988 iob = qeth_get_ipacmd_buffer(card, ipa_cmd_sbp(card), 0); 1989 if (!iob) 1990 return -ENOMEM; 1991 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE); 1992 cmd->data.sbp.hdr.cmdlength = cmdlength; 1993 cmd->data.sbp.hdr.command_code = setcmd; 1994 cmd->data.sbp.hdr.used_total = 1; 1995 cmd->data.sbp.hdr.seq_no = 1; 1996 rc = qeth_send_ipa_cmd(card, iob, qeth_bridgeport_set_cb, 1997 (void *)&cbctl); 1998 if (rc < 0) 1999 return rc; 2000 return qeth_bridgeport_makerc(card, &cbctl, setcmd); 2001 } 2002 2003 /** 2004 * qeth_anset_makerc() - derive "traditional" error from hardware codes. 2005 * @card: qeth_card structure pointer, for debug messages. 2006 * 2007 * Returns negative errno-compatible error indication or 0 on success. 2008 */ 2009 static int qeth_anset_makerc(struct qeth_card *card, int pnso_rc, u16 response) 2010 { 2011 int rc; 2012 2013 if (pnso_rc == 0) 2014 switch (response) { 2015 case 0x0001: 2016 rc = 0; 2017 break; 2018 case 0x0004: 2019 case 0x0100: 2020 case 0x0106: 2021 rc = -EOPNOTSUPP; 2022 dev_err(&card->gdev->dev, 2023 "Setting address notification failed\n"); 2024 break; 2025 case 0x0107: 2026 rc = -EAGAIN; 2027 break; 2028 default: 2029 rc = -EIO; 2030 } 2031 else 2032 rc = -EIO; 2033 2034 if (rc) { 2035 QETH_CARD_TEXT_(card, 2, "SBPp%04x", pnso_rc); 2036 QETH_CARD_TEXT_(card, 2, "SBPr%04x", response); 2037 } 2038 return rc; 2039 } 2040 2041 static void qeth_bridgeport_an_set_cb(void *priv, 2042 enum qdio_brinfo_entry_type type, void *entry) 2043 { 2044 struct qeth_card *card = (struct qeth_card *)priv; 2045 struct qdio_brinfo_entry_l2 *l2entry; 2046 u8 code; 2047 2048 if (type != l2_addr_lnid) { 2049 WARN_ON_ONCE(1); 2050 return; 2051 } 2052 2053 l2entry = (struct qdio_brinfo_entry_l2 *)entry; 2054 code = IPA_ADDR_CHANGE_CODE_MACADDR; 2055 if (l2entry->addr_lnid.lnid) 2056 code |= IPA_ADDR_CHANGE_CODE_VLANID; 2057 qeth_bridge_emit_host_event(card, anev_reg_unreg, code, 2058 (struct net_if_token *)&l2entry->nit, 2059 (struct mac_addr_lnid *)&l2entry->addr_lnid); 2060 } 2061 2062 /** 2063 * qeth_bridgeport_an_set() - Enable or disable bridgeport address notification 2064 * @card: qeth_card structure pointer. 2065 * @enable: 0 - disable, non-zero - enable notifications 2066 * 2067 * Returns negative errno-compatible error indication or 0 on success. 2068 * 2069 * On enable, emits a series of address notifications udev events for all 2070 * currently registered hosts. 2071 */ 2072 int qeth_bridgeport_an_set(struct qeth_card *card, int enable) 2073 { 2074 int rc; 2075 u16 response; 2076 struct ccw_device *ddev; 2077 struct subchannel_id schid; 2078 2079 if (!card) 2080 return -EINVAL; 2081 if (!card->options.sbp.supported_funcs) 2082 return -EOPNOTSUPP; 2083 ddev = CARD_DDEV(card); 2084 ccw_device_get_schid(ddev, &schid); 2085 2086 if (enable) { 2087 qeth_bridge_emit_host_event(card, anev_reset, 0, NULL, NULL); 2088 rc = qdio_pnso_brinfo(schid, 1, &response, 2089 qeth_bridgeport_an_set_cb, card); 2090 } else 2091 rc = qdio_pnso_brinfo(schid, 0, &response, NULL, NULL); 2092 return qeth_anset_makerc(card, rc, response); 2093 } 2094 EXPORT_SYMBOL_GPL(qeth_bridgeport_an_set); 2095 2096 module_init(qeth_l2_init); 2097 module_exit(qeth_l2_exit); 2098 MODULE_AUTHOR("Frank Blaschka <frank.blaschka@de.ibm.com>"); 2099 MODULE_DESCRIPTION("qeth layer 2 discipline"); 2100 MODULE_LICENSE("GPL"); 2101