1 /* 2 * drivers/s390/net/qeth_l2_main.c 3 * 4 * Copyright IBM Corp. 2007, 2009 5 * Author(s): Utz Bacher <utz.bacher@de.ibm.com>, 6 * Frank Pavlic <fpavlic@de.ibm.com>, 7 * Thomas Spatzier <tspat@de.ibm.com>, 8 * Frank Blaschka <frank.blaschka@de.ibm.com> 9 */ 10 11 #define KMSG_COMPONENT "qeth" 12 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 13 14 #include <linux/module.h> 15 #include <linux/moduleparam.h> 16 #include <linux/string.h> 17 #include <linux/errno.h> 18 #include <linux/kernel.h> 19 #include <linux/etherdevice.h> 20 #include <linux/mii.h> 21 #include <linux/ip.h> 22 #include <linux/list.h> 23 24 #include "qeth_core.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 int (*reply_cb) (struct qeth_card *, 32 struct qeth_reply*, 33 unsigned long)); 34 static void qeth_l2_set_multicast_list(struct net_device *); 35 static int qeth_l2_recover(void *); 36 37 static int qeth_l2_do_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) 38 { 39 struct qeth_card *card = dev->ml_priv; 40 struct mii_ioctl_data *mii_data; 41 int rc = 0; 42 43 if (!card) 44 return -ENODEV; 45 46 if ((card->state != CARD_STATE_UP) && 47 (card->state != CARD_STATE_SOFTSETUP)) 48 return -ENODEV; 49 50 if (card->info.type == QETH_CARD_TYPE_OSN) 51 return -EPERM; 52 53 switch (cmd) { 54 case SIOC_QETH_ADP_SET_SNMP_CONTROL: 55 rc = qeth_snmp_command(card, rq->ifr_ifru.ifru_data); 56 break; 57 case SIOC_QETH_GET_CARD_TYPE: 58 if ((card->info.type == QETH_CARD_TYPE_OSAE) && 59 !card->info.guestlan) 60 return 1; 61 return 0; 62 break; 63 case SIOCGMIIPHY: 64 mii_data = if_mii(rq); 65 mii_data->phy_id = 0; 66 break; 67 case SIOCGMIIREG: 68 mii_data = if_mii(rq); 69 if (mii_data->phy_id != 0) 70 rc = -EINVAL; 71 else 72 mii_data->val_out = qeth_mdio_read(dev, 73 mii_data->phy_id, mii_data->reg_num); 74 break; 75 default: 76 rc = -EOPNOTSUPP; 77 } 78 if (rc) 79 QETH_DBF_TEXT_(TRACE, 2, "ioce%d", rc); 80 return rc; 81 } 82 83 static int qeth_l2_verify_dev(struct net_device *dev) 84 { 85 struct qeth_card *card; 86 unsigned long flags; 87 int rc = 0; 88 89 read_lock_irqsave(&qeth_core_card_list.rwlock, flags); 90 list_for_each_entry(card, &qeth_core_card_list.list, list) { 91 if (card->dev == dev) { 92 rc = QETH_REAL_CARD; 93 break; 94 } 95 } 96 read_unlock_irqrestore(&qeth_core_card_list.rwlock, flags); 97 98 return rc; 99 } 100 101 static struct net_device *qeth_l2_netdev_by_devno(unsigned char *read_dev_no) 102 { 103 struct qeth_card *card; 104 struct net_device *ndev; 105 __u16 temp_dev_no; 106 unsigned long flags; 107 struct ccw_dev_id read_devid; 108 109 ndev = NULL; 110 memcpy(&temp_dev_no, read_dev_no, 2); 111 read_lock_irqsave(&qeth_core_card_list.rwlock, flags); 112 list_for_each_entry(card, &qeth_core_card_list.list, list) { 113 ccw_device_get_id(CARD_RDEV(card), &read_devid); 114 if (read_devid.devno == temp_dev_no) { 115 ndev = card->dev; 116 break; 117 } 118 } 119 read_unlock_irqrestore(&qeth_core_card_list.rwlock, flags); 120 return ndev; 121 } 122 123 static int qeth_l2_send_setgroupmac_cb(struct qeth_card *card, 124 struct qeth_reply *reply, 125 unsigned long data) 126 { 127 struct qeth_ipa_cmd *cmd; 128 __u8 *mac; 129 130 QETH_DBF_TEXT(TRACE, 2, "L2Sgmacb"); 131 cmd = (struct qeth_ipa_cmd *) data; 132 mac = &cmd->data.setdelmac.mac[0]; 133 /* MAC already registered, needed in couple/uncouple case */ 134 if (cmd->hdr.return_code == IPA_RC_L2_DUP_MAC) { 135 QETH_DBF_MESSAGE(2, "Group MAC %pM already existing on %s \n", 136 mac, QETH_CARD_IFNAME(card)); 137 cmd->hdr.return_code = 0; 138 } 139 if (cmd->hdr.return_code) 140 QETH_DBF_MESSAGE(2, "Could not set group MAC %pM on %s: %x\n", 141 mac, QETH_CARD_IFNAME(card), cmd->hdr.return_code); 142 return 0; 143 } 144 145 static int qeth_l2_send_setgroupmac(struct qeth_card *card, __u8 *mac) 146 { 147 QETH_DBF_TEXT(TRACE, 2, "L2Sgmac"); 148 return qeth_l2_send_setdelmac(card, mac, IPA_CMD_SETGMAC, 149 qeth_l2_send_setgroupmac_cb); 150 } 151 152 static int qeth_l2_send_delgroupmac_cb(struct qeth_card *card, 153 struct qeth_reply *reply, 154 unsigned long data) 155 { 156 struct qeth_ipa_cmd *cmd; 157 __u8 *mac; 158 159 QETH_DBF_TEXT(TRACE, 2, "L2Dgmacb"); 160 cmd = (struct qeth_ipa_cmd *) data; 161 mac = &cmd->data.setdelmac.mac[0]; 162 if (cmd->hdr.return_code) 163 QETH_DBF_MESSAGE(2, "Could not delete group MAC %pM on %s: %x\n", 164 mac, QETH_CARD_IFNAME(card), cmd->hdr.return_code); 165 return 0; 166 } 167 168 static int qeth_l2_send_delgroupmac(struct qeth_card *card, __u8 *mac) 169 { 170 QETH_DBF_TEXT(TRACE, 2, "L2Dgmac"); 171 return qeth_l2_send_setdelmac(card, mac, IPA_CMD_DELGMAC, 172 qeth_l2_send_delgroupmac_cb); 173 } 174 175 static void qeth_l2_add_mc(struct qeth_card *card, __u8 *mac, int vmac) 176 { 177 struct qeth_mc_mac *mc; 178 int rc; 179 180 mc = kmalloc(sizeof(struct qeth_mc_mac), GFP_ATOMIC); 181 182 if (!mc) 183 return; 184 185 memcpy(mc->mc_addr, mac, OSA_ADDR_LEN); 186 mc->mc_addrlen = OSA_ADDR_LEN; 187 mc->is_vmac = vmac; 188 189 if (vmac) { 190 rc = qeth_l2_send_setdelmac(card, mac, IPA_CMD_SETVMAC, 191 NULL); 192 } else { 193 rc = qeth_l2_send_setgroupmac(card, mac); 194 } 195 196 if (!rc) 197 list_add_tail(&mc->list, &card->mc_list); 198 else 199 kfree(mc); 200 } 201 202 static void qeth_l2_del_all_mc(struct qeth_card *card) 203 { 204 struct qeth_mc_mac *mc, *tmp; 205 206 spin_lock_bh(&card->mclock); 207 list_for_each_entry_safe(mc, tmp, &card->mc_list, list) { 208 if (mc->is_vmac) 209 qeth_l2_send_setdelmac(card, mc->mc_addr, 210 IPA_CMD_DELVMAC, NULL); 211 else 212 qeth_l2_send_delgroupmac(card, mc->mc_addr); 213 list_del(&mc->list); 214 kfree(mc); 215 } 216 spin_unlock_bh(&card->mclock); 217 } 218 219 static inline int qeth_l2_get_cast_type(struct qeth_card *card, 220 struct sk_buff *skb) 221 { 222 if (card->info.type == QETH_CARD_TYPE_OSN) 223 return RTN_UNSPEC; 224 if (is_broadcast_ether_addr(skb->data)) 225 return RTN_BROADCAST; 226 if (is_multicast_ether_addr(skb->data)) 227 return RTN_MULTICAST; 228 return RTN_UNSPEC; 229 } 230 231 static void qeth_l2_fill_header(struct qeth_card *card, struct qeth_hdr *hdr, 232 struct sk_buff *skb, int ipv, int cast_type) 233 { 234 struct vlan_ethhdr *veth = (struct vlan_ethhdr *)skb_mac_header(skb); 235 236 memset(hdr, 0, sizeof(struct qeth_hdr)); 237 hdr->hdr.l2.id = QETH_HEADER_TYPE_LAYER2; 238 239 /* set byte byte 3 to casting flags */ 240 if (cast_type == RTN_MULTICAST) 241 hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_MULTICAST; 242 else if (cast_type == RTN_BROADCAST) 243 hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_BROADCAST; 244 else 245 hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_UNICAST; 246 247 hdr->hdr.l2.pkt_length = skb->len-QETH_HEADER_SIZE; 248 /* VSWITCH relies on the VLAN 249 * information to be present in 250 * the QDIO header */ 251 if (veth->h_vlan_proto == __constant_htons(ETH_P_8021Q)) { 252 hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_VLAN; 253 hdr->hdr.l2.vlan_id = ntohs(veth->h_vlan_TCI); 254 } 255 } 256 257 static int qeth_l2_send_setdelvlan_cb(struct qeth_card *card, 258 struct qeth_reply *reply, unsigned long data) 259 { 260 struct qeth_ipa_cmd *cmd; 261 262 QETH_DBF_TEXT(TRACE, 2, "L2sdvcb"); 263 cmd = (struct qeth_ipa_cmd *) data; 264 if (cmd->hdr.return_code) { 265 QETH_DBF_MESSAGE(2, "Error in processing VLAN %i on %s: 0x%x. " 266 "Continuing\n", cmd->data.setdelvlan.vlan_id, 267 QETH_CARD_IFNAME(card), cmd->hdr.return_code); 268 QETH_DBF_TEXT_(TRACE, 2, "L2VL%4x", cmd->hdr.command); 269 QETH_DBF_TEXT_(TRACE, 2, "L2%s", CARD_BUS_ID(card)); 270 QETH_DBF_TEXT_(TRACE, 2, "err%d", cmd->hdr.return_code); 271 } 272 return 0; 273 } 274 275 static int qeth_l2_send_setdelvlan(struct qeth_card *card, __u16 i, 276 enum qeth_ipa_cmds ipacmd) 277 { 278 struct qeth_ipa_cmd *cmd; 279 struct qeth_cmd_buffer *iob; 280 281 QETH_DBF_TEXT_(TRACE, 4, "L2sdv%x", ipacmd); 282 iob = qeth_get_ipacmd_buffer(card, ipacmd, QETH_PROT_IPV4); 283 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE); 284 cmd->data.setdelvlan.vlan_id = i; 285 return qeth_send_ipa_cmd(card, iob, 286 qeth_l2_send_setdelvlan_cb, NULL); 287 } 288 289 static void qeth_l2_process_vlans(struct qeth_card *card, int clear) 290 { 291 struct qeth_vlan_vid *id; 292 QETH_DBF_TEXT(TRACE, 3, "L2prcvln"); 293 spin_lock_bh(&card->vlanlock); 294 list_for_each_entry(id, &card->vid_list, list) { 295 if (clear) 296 qeth_l2_send_setdelvlan(card, id->vid, 297 IPA_CMD_DELVLAN); 298 else 299 qeth_l2_send_setdelvlan(card, id->vid, 300 IPA_CMD_SETVLAN); 301 } 302 spin_unlock_bh(&card->vlanlock); 303 } 304 305 static void qeth_l2_vlan_rx_add_vid(struct net_device *dev, unsigned short vid) 306 { 307 struct qeth_card *card = dev->ml_priv; 308 struct qeth_vlan_vid *id; 309 310 QETH_DBF_TEXT_(TRACE, 4, "aid:%d", vid); 311 if (qeth_wait_for_threads(card, QETH_RECOVER_THREAD)) { 312 QETH_DBF_TEXT(TRACE, 3, "aidREC"); 313 return; 314 } 315 id = kmalloc(sizeof(struct qeth_vlan_vid), GFP_ATOMIC); 316 if (id) { 317 id->vid = vid; 318 qeth_l2_send_setdelvlan(card, vid, IPA_CMD_SETVLAN); 319 spin_lock_bh(&card->vlanlock); 320 list_add_tail(&id->list, &card->vid_list); 321 spin_unlock_bh(&card->vlanlock); 322 } 323 } 324 325 static void qeth_l2_vlan_rx_kill_vid(struct net_device *dev, unsigned short vid) 326 { 327 struct qeth_vlan_vid *id, *tmpid = NULL; 328 struct qeth_card *card = dev->ml_priv; 329 330 QETH_DBF_TEXT_(TRACE, 4, "kid:%d", vid); 331 if (qeth_wait_for_threads(card, QETH_RECOVER_THREAD)) { 332 QETH_DBF_TEXT(TRACE, 3, "kidREC"); 333 return; 334 } 335 spin_lock_bh(&card->vlanlock); 336 list_for_each_entry(id, &card->vid_list, list) { 337 if (id->vid == vid) { 338 list_del(&id->list); 339 tmpid = id; 340 break; 341 } 342 } 343 spin_unlock_bh(&card->vlanlock); 344 if (tmpid) { 345 qeth_l2_send_setdelvlan(card, vid, IPA_CMD_DELVLAN); 346 kfree(tmpid); 347 } 348 qeth_l2_set_multicast_list(card->dev); 349 } 350 351 static int qeth_l2_stop_card(struct qeth_card *card, int recovery_mode) 352 { 353 int rc = 0; 354 355 QETH_DBF_TEXT(SETUP , 2, "stopcard"); 356 QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *)); 357 358 qeth_set_allowed_threads(card, 0, 1); 359 if (card->read.state == CH_STATE_UP && 360 card->write.state == CH_STATE_UP && 361 (card->state == CARD_STATE_UP)) { 362 if (recovery_mode && 363 card->info.type != QETH_CARD_TYPE_OSN) { 364 qeth_l2_stop(card->dev); 365 } else { 366 rtnl_lock(); 367 dev_close(card->dev); 368 rtnl_unlock(); 369 } 370 if (!card->use_hard_stop || 371 recovery_mode) { 372 __u8 *mac = &card->dev->dev_addr[0]; 373 rc = qeth_l2_send_delmac(card, mac); 374 QETH_DBF_TEXT_(SETUP, 2, "Lerr%d", rc); 375 } 376 card->state = CARD_STATE_SOFTSETUP; 377 } 378 if (card->state == CARD_STATE_SOFTSETUP) { 379 qeth_l2_process_vlans(card, 1); 380 if (!card->use_hard_stop || 381 recovery_mode) 382 qeth_l2_del_all_mc(card); 383 qeth_clear_ipacmd_list(card); 384 card->state = CARD_STATE_HARDSETUP; 385 } 386 if (card->state == CARD_STATE_HARDSETUP) { 387 qeth_qdio_clear_card(card, 0); 388 qeth_clear_qdio_buffers(card); 389 qeth_clear_working_pool_list(card); 390 card->state = CARD_STATE_DOWN; 391 } 392 if (card->state == CARD_STATE_DOWN) { 393 qeth_clear_cmd_buffers(&card->read); 394 qeth_clear_cmd_buffers(&card->write); 395 } 396 card->use_hard_stop = 0; 397 return rc; 398 } 399 400 static void qeth_l2_process_inbound_buffer(struct qeth_card *card, 401 struct qeth_qdio_buffer *buf, int index) 402 { 403 struct qdio_buffer_element *element; 404 struct sk_buff *skb; 405 struct qeth_hdr *hdr; 406 int offset; 407 unsigned int len; 408 409 /* get first element of current buffer */ 410 element = (struct qdio_buffer_element *)&buf->buffer->element[0]; 411 offset = 0; 412 if (card->options.performance_stats) 413 card->perf_stats.bufs_rec++; 414 while ((skb = qeth_core_get_next_skb(card, buf->buffer, &element, 415 &offset, &hdr))) { 416 skb->dev = card->dev; 417 /* is device UP ? */ 418 if (!(card->dev->flags & IFF_UP)) { 419 dev_kfree_skb_any(skb); 420 continue; 421 } 422 423 switch (hdr->hdr.l2.id) { 424 case QETH_HEADER_TYPE_LAYER2: 425 skb->pkt_type = PACKET_HOST; 426 skb->protocol = eth_type_trans(skb, skb->dev); 427 if (card->options.checksum_type == NO_CHECKSUMMING) 428 skb->ip_summed = CHECKSUM_UNNECESSARY; 429 else 430 skb->ip_summed = CHECKSUM_NONE; 431 if (skb->protocol == htons(ETH_P_802_2)) 432 *((__u32 *)skb->cb) = ++card->seqno.pkt_seqno; 433 len = skb->len; 434 netif_rx(skb); 435 break; 436 case QETH_HEADER_TYPE_OSN: 437 if (card->info.type == QETH_CARD_TYPE_OSN) { 438 skb_push(skb, sizeof(struct qeth_hdr)); 439 skb_copy_to_linear_data(skb, hdr, 440 sizeof(struct qeth_hdr)); 441 len = skb->len; 442 card->osn_info.data_cb(skb); 443 break; 444 } 445 /* else unknown */ 446 default: 447 dev_kfree_skb_any(skb); 448 QETH_DBF_TEXT(TRACE, 3, "inbunkno"); 449 QETH_DBF_HEX(CTRL, 3, hdr, QETH_DBF_CTRL_LEN); 450 continue; 451 } 452 card->stats.rx_packets++; 453 card->stats.rx_bytes += len; 454 } 455 } 456 457 static int qeth_l2_send_setdelmac(struct qeth_card *card, __u8 *mac, 458 enum qeth_ipa_cmds ipacmd, 459 int (*reply_cb) (struct qeth_card *, 460 struct qeth_reply*, 461 unsigned long)) 462 { 463 struct qeth_ipa_cmd *cmd; 464 struct qeth_cmd_buffer *iob; 465 466 QETH_DBF_TEXT(TRACE, 2, "L2sdmac"); 467 iob = qeth_get_ipacmd_buffer(card, ipacmd, QETH_PROT_IPV4); 468 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE); 469 cmd->data.setdelmac.mac_length = OSA_ADDR_LEN; 470 memcpy(&cmd->data.setdelmac.mac, mac, OSA_ADDR_LEN); 471 return qeth_send_ipa_cmd(card, iob, reply_cb, NULL); 472 } 473 474 static int qeth_l2_send_setmac_cb(struct qeth_card *card, 475 struct qeth_reply *reply, 476 unsigned long data) 477 { 478 struct qeth_ipa_cmd *cmd; 479 480 QETH_DBF_TEXT(TRACE, 2, "L2Smaccb"); 481 cmd = (struct qeth_ipa_cmd *) data; 482 if (cmd->hdr.return_code) { 483 QETH_DBF_TEXT_(TRACE, 2, "L2er%x", cmd->hdr.return_code); 484 card->info.mac_bits &= ~QETH_LAYER2_MAC_REGISTERED; 485 switch (cmd->hdr.return_code) { 486 case IPA_RC_L2_DUP_MAC: 487 case IPA_RC_L2_DUP_LAYER3_MAC: 488 dev_warn(&card->gdev->dev, 489 "MAC address " 490 "%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x " 491 "already exists\n", 492 card->dev->dev_addr[0], card->dev->dev_addr[1], 493 card->dev->dev_addr[2], card->dev->dev_addr[3], 494 card->dev->dev_addr[4], card->dev->dev_addr[5]); 495 break; 496 case IPA_RC_L2_MAC_NOT_AUTH_BY_HYP: 497 case IPA_RC_L2_MAC_NOT_AUTH_BY_ADP: 498 dev_warn(&card->gdev->dev, 499 "MAC address " 500 "%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x " 501 "is not authorized\n", 502 card->dev->dev_addr[0], card->dev->dev_addr[1], 503 card->dev->dev_addr[2], card->dev->dev_addr[3], 504 card->dev->dev_addr[4], card->dev->dev_addr[5]); 505 break; 506 default: 507 break; 508 } 509 cmd->hdr.return_code = -EIO; 510 } else { 511 card->info.mac_bits |= QETH_LAYER2_MAC_REGISTERED; 512 memcpy(card->dev->dev_addr, cmd->data.setdelmac.mac, 513 OSA_ADDR_LEN); 514 dev_info(&card->gdev->dev, 515 "MAC address %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x " 516 "successfully registered on device %s\n", 517 card->dev->dev_addr[0], card->dev->dev_addr[1], 518 card->dev->dev_addr[2], card->dev->dev_addr[3], 519 card->dev->dev_addr[4], card->dev->dev_addr[5], 520 card->dev->name); 521 } 522 return 0; 523 } 524 525 static int qeth_l2_send_setmac(struct qeth_card *card, __u8 *mac) 526 { 527 QETH_DBF_TEXT(TRACE, 2, "L2Setmac"); 528 return qeth_l2_send_setdelmac(card, mac, IPA_CMD_SETVMAC, 529 qeth_l2_send_setmac_cb); 530 } 531 532 static int qeth_l2_send_delmac_cb(struct qeth_card *card, 533 struct qeth_reply *reply, 534 unsigned long data) 535 { 536 struct qeth_ipa_cmd *cmd; 537 538 QETH_DBF_TEXT(TRACE, 2, "L2Dmaccb"); 539 cmd = (struct qeth_ipa_cmd *) data; 540 if (cmd->hdr.return_code) { 541 QETH_DBF_TEXT_(TRACE, 2, "err%d", cmd->hdr.return_code); 542 cmd->hdr.return_code = -EIO; 543 return 0; 544 } 545 card->info.mac_bits &= ~QETH_LAYER2_MAC_REGISTERED; 546 547 return 0; 548 } 549 550 static int qeth_l2_send_delmac(struct qeth_card *card, __u8 *mac) 551 { 552 QETH_DBF_TEXT(TRACE, 2, "L2Delmac"); 553 if (!(card->info.mac_bits & QETH_LAYER2_MAC_REGISTERED)) 554 return 0; 555 return qeth_l2_send_setdelmac(card, mac, IPA_CMD_DELVMAC, 556 qeth_l2_send_delmac_cb); 557 } 558 559 static int qeth_l2_request_initial_mac(struct qeth_card *card) 560 { 561 int rc = 0; 562 char vendor_pre[] = {0x02, 0x00, 0x00}; 563 564 QETH_DBF_TEXT(SETUP, 2, "doL2init"); 565 QETH_DBF_TEXT_(SETUP, 2, "doL2%s", CARD_BUS_ID(card)); 566 567 rc = qeth_query_setadapterparms(card); 568 if (rc) { 569 QETH_DBF_MESSAGE(2, "could not query adapter parameters on " 570 "device %s: x%x\n", CARD_BUS_ID(card), rc); 571 } 572 573 if ((card->info.type == QETH_CARD_TYPE_IQD) || 574 (card->info.guestlan)) { 575 rc = qeth_setadpparms_change_macaddr(card); 576 if (rc) { 577 QETH_DBF_MESSAGE(2, "couldn't get MAC address on " 578 "device %s: x%x\n", CARD_BUS_ID(card), rc); 579 QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc); 580 return rc; 581 } 582 QETH_DBF_HEX(SETUP, 2, card->dev->dev_addr, OSA_ADDR_LEN); 583 } else { 584 random_ether_addr(card->dev->dev_addr); 585 memcpy(card->dev->dev_addr, vendor_pre, 3); 586 } 587 return 0; 588 } 589 590 static int qeth_l2_set_mac_address(struct net_device *dev, void *p) 591 { 592 struct sockaddr *addr = p; 593 struct qeth_card *card = dev->ml_priv; 594 int rc = 0; 595 596 QETH_DBF_TEXT(TRACE, 3, "setmac"); 597 598 if (qeth_l2_verify_dev(dev) != QETH_REAL_CARD) { 599 QETH_DBF_TEXT(TRACE, 3, "setmcINV"); 600 return -EOPNOTSUPP; 601 } 602 603 if (card->info.type == QETH_CARD_TYPE_OSN) { 604 QETH_DBF_TEXT(TRACE, 3, "setmcOSN"); 605 return -EOPNOTSUPP; 606 } 607 QETH_DBF_TEXT_(TRACE, 3, "%s", CARD_BUS_ID(card)); 608 QETH_DBF_HEX(TRACE, 3, addr->sa_data, OSA_ADDR_LEN); 609 if (qeth_wait_for_threads(card, QETH_RECOVER_THREAD)) { 610 QETH_DBF_TEXT(TRACE, 3, "setmcREC"); 611 return -ERESTARTSYS; 612 } 613 rc = qeth_l2_send_delmac(card, &card->dev->dev_addr[0]); 614 if (!rc) 615 rc = qeth_l2_send_setmac(card, addr->sa_data); 616 return rc; 617 } 618 619 static void qeth_l2_set_multicast_list(struct net_device *dev) 620 { 621 struct qeth_card *card = dev->ml_priv; 622 struct dev_addr_list *dm; 623 struct netdev_hw_addr *ha; 624 625 if (card->info.type == QETH_CARD_TYPE_OSN) 626 return ; 627 628 QETH_DBF_TEXT(TRACE, 3, "setmulti"); 629 if (qeth_threads_running(card, QETH_RECOVER_THREAD) && 630 (card->state != CARD_STATE_UP)) 631 return; 632 qeth_l2_del_all_mc(card); 633 spin_lock_bh(&card->mclock); 634 for (dm = dev->mc_list; dm; dm = dm->next) 635 qeth_l2_add_mc(card, dm->da_addr, 0); 636 637 list_for_each_entry(ha, &dev->uc.list, list) 638 qeth_l2_add_mc(card, ha->addr, 1); 639 640 spin_unlock_bh(&card->mclock); 641 if (!qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE)) 642 return; 643 qeth_setadp_promisc_mode(card); 644 } 645 646 static int qeth_l2_hard_start_xmit(struct sk_buff *skb, struct net_device *dev) 647 { 648 int rc; 649 struct qeth_hdr *hdr = NULL; 650 int elements = 0; 651 struct qeth_card *card = dev->ml_priv; 652 struct sk_buff *new_skb = skb; 653 int ipv = qeth_get_ip_version(skb); 654 int cast_type = qeth_l2_get_cast_type(card, skb); 655 struct qeth_qdio_out_q *queue = card->qdio.out_qs 656 [qeth_get_priority_queue(card, skb, ipv, cast_type)]; 657 int tx_bytes = skb->len; 658 int data_offset = -1; 659 int elements_needed = 0; 660 int hd_len = 0; 661 662 if ((card->state != CARD_STATE_UP) || !card->lan_online) { 663 card->stats.tx_carrier_errors++; 664 goto tx_drop; 665 } 666 667 if ((card->info.type == QETH_CARD_TYPE_OSN) && 668 (skb->protocol == htons(ETH_P_IPV6))) 669 goto tx_drop; 670 671 if (card->options.performance_stats) { 672 card->perf_stats.outbound_cnt++; 673 card->perf_stats.outbound_start_time = qeth_get_micros(); 674 } 675 netif_stop_queue(dev); 676 677 if (card->info.type == QETH_CARD_TYPE_OSN) 678 hdr = (struct qeth_hdr *)skb->data; 679 else { 680 if (card->info.type == QETH_CARD_TYPE_IQD) { 681 new_skb = skb; 682 data_offset = ETH_HLEN; 683 hd_len = ETH_HLEN; 684 hdr = kmem_cache_alloc(qeth_core_header_cache, 685 GFP_ATOMIC); 686 if (!hdr) 687 goto tx_drop; 688 elements_needed++; 689 skb_reset_mac_header(new_skb); 690 qeth_l2_fill_header(card, hdr, new_skb, ipv, cast_type); 691 hdr->hdr.l2.pkt_length = new_skb->len; 692 memcpy(((char *)hdr) + sizeof(struct qeth_hdr), 693 skb_mac_header(new_skb), ETH_HLEN); 694 } else { 695 /* create a clone with writeable headroom */ 696 new_skb = skb_realloc_headroom(skb, 697 sizeof(struct qeth_hdr)); 698 if (!new_skb) 699 goto tx_drop; 700 hdr = (struct qeth_hdr *)skb_push(new_skb, 701 sizeof(struct qeth_hdr)); 702 skb_set_mac_header(new_skb, sizeof(struct qeth_hdr)); 703 qeth_l2_fill_header(card, hdr, new_skb, ipv, cast_type); 704 } 705 } 706 707 elements = qeth_get_elements_no(card, (void *)hdr, new_skb, 708 elements_needed); 709 if (!elements) { 710 if (data_offset >= 0) 711 kmem_cache_free(qeth_core_header_cache, hdr); 712 goto tx_drop; 713 } 714 715 if (card->info.type != QETH_CARD_TYPE_IQD) 716 rc = qeth_do_send_packet(card, queue, new_skb, hdr, 717 elements); 718 else 719 rc = qeth_do_send_packet_fast(card, queue, new_skb, hdr, 720 elements, data_offset, hd_len); 721 if (!rc) { 722 card->stats.tx_packets++; 723 card->stats.tx_bytes += tx_bytes; 724 if (new_skb != skb) 725 dev_kfree_skb_any(skb); 726 rc = NETDEV_TX_OK; 727 } else { 728 if (data_offset >= 0) 729 kmem_cache_free(qeth_core_header_cache, hdr); 730 731 if (rc == -EBUSY) { 732 if (new_skb != skb) 733 dev_kfree_skb_any(new_skb); 734 return NETDEV_TX_BUSY; 735 } else 736 goto tx_drop; 737 } 738 739 netif_wake_queue(dev); 740 if (card->options.performance_stats) 741 card->perf_stats.outbound_time += qeth_get_micros() - 742 card->perf_stats.outbound_start_time; 743 return rc; 744 745 tx_drop: 746 card->stats.tx_dropped++; 747 card->stats.tx_errors++; 748 if ((new_skb != skb) && new_skb) 749 dev_kfree_skb_any(new_skb); 750 dev_kfree_skb_any(skb); 751 netif_wake_queue(dev); 752 return NETDEV_TX_OK; 753 } 754 755 static void qeth_l2_qdio_input_handler(struct ccw_device *ccwdev, 756 unsigned int qdio_err, unsigned int queue, 757 int first_element, int count, unsigned long card_ptr) 758 { 759 struct net_device *net_dev; 760 struct qeth_card *card; 761 struct qeth_qdio_buffer *buffer; 762 int index; 763 int i; 764 765 card = (struct qeth_card *) card_ptr; 766 net_dev = card->dev; 767 if (card->options.performance_stats) { 768 card->perf_stats.inbound_cnt++; 769 card->perf_stats.inbound_start_time = qeth_get_micros(); 770 } 771 if (qdio_err & QDIO_ERROR_ACTIVATE_CHECK_CONDITION) { 772 QETH_DBF_TEXT(TRACE, 1, "qdinchk"); 773 QETH_DBF_TEXT_(TRACE, 1, "%s", CARD_BUS_ID(card)); 774 QETH_DBF_TEXT_(TRACE, 1, "%04X%04X", first_element, 775 count); 776 QETH_DBF_TEXT_(TRACE, 1, "%04X", queue); 777 qeth_schedule_recovery(card); 778 return; 779 } 780 for (i = first_element; i < (first_element + count); ++i) { 781 index = i % QDIO_MAX_BUFFERS_PER_Q; 782 buffer = &card->qdio.in_q->bufs[index]; 783 if (!(qdio_err && 784 qeth_check_qdio_errors(buffer->buffer, qdio_err, "qinerr"))) 785 qeth_l2_process_inbound_buffer(card, buffer, index); 786 /* clear buffer and give back to hardware */ 787 qeth_put_buffer_pool_entry(card, buffer->pool_entry); 788 qeth_queue_input_buffer(card, index); 789 } 790 if (card->options.performance_stats) 791 card->perf_stats.inbound_time += qeth_get_micros() - 792 card->perf_stats.inbound_start_time; 793 } 794 795 static int qeth_l2_open(struct net_device *dev) 796 { 797 struct qeth_card *card = dev->ml_priv; 798 799 QETH_DBF_TEXT(TRACE, 4, "qethopen"); 800 if (card->state != CARD_STATE_SOFTSETUP) 801 return -ENODEV; 802 803 if ((card->info.type != QETH_CARD_TYPE_OSN) && 804 (!(card->info.mac_bits & QETH_LAYER2_MAC_REGISTERED))) { 805 QETH_DBF_TEXT(TRACE, 4, "nomacadr"); 806 return -EPERM; 807 } 808 card->data.state = CH_STATE_UP; 809 card->state = CARD_STATE_UP; 810 netif_start_queue(dev); 811 812 if (!card->lan_online && netif_carrier_ok(dev)) 813 netif_carrier_off(dev); 814 return 0; 815 } 816 817 818 static int qeth_l2_stop(struct net_device *dev) 819 { 820 struct qeth_card *card = dev->ml_priv; 821 822 QETH_DBF_TEXT(TRACE, 4, "qethstop"); 823 netif_tx_disable(dev); 824 if (card->state == CARD_STATE_UP) 825 card->state = CARD_STATE_SOFTSETUP; 826 return 0; 827 } 828 829 static int qeth_l2_probe_device(struct ccwgroup_device *gdev) 830 { 831 struct qeth_card *card = dev_get_drvdata(&gdev->dev); 832 833 INIT_LIST_HEAD(&card->vid_list); 834 INIT_LIST_HEAD(&card->mc_list); 835 card->options.layer2 = 1; 836 card->discipline.input_handler = (qdio_handler_t *) 837 qeth_l2_qdio_input_handler; 838 card->discipline.output_handler = (qdio_handler_t *) 839 qeth_qdio_output_handler; 840 card->discipline.recover = qeth_l2_recover; 841 return 0; 842 } 843 844 static void qeth_l2_remove_device(struct ccwgroup_device *cgdev) 845 { 846 struct qeth_card *card = dev_get_drvdata(&cgdev->dev); 847 848 qeth_set_allowed_threads(card, 0, 1); 849 wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0); 850 851 if (cgdev->state == CCWGROUP_ONLINE) { 852 card->use_hard_stop = 1; 853 qeth_l2_set_offline(cgdev); 854 } 855 856 if (card->dev) { 857 unregister_netdev(card->dev); 858 card->dev = NULL; 859 } 860 861 qeth_l2_del_all_mc(card); 862 return; 863 } 864 865 static const struct ethtool_ops qeth_l2_ethtool_ops = { 866 .get_link = ethtool_op_get_link, 867 .get_strings = qeth_core_get_strings, 868 .get_ethtool_stats = qeth_core_get_ethtool_stats, 869 .get_sset_count = qeth_core_get_sset_count, 870 .get_drvinfo = qeth_core_get_drvinfo, 871 .get_settings = qeth_core_ethtool_get_settings, 872 }; 873 874 static const struct ethtool_ops qeth_l2_osn_ops = { 875 .get_strings = qeth_core_get_strings, 876 .get_ethtool_stats = qeth_core_get_ethtool_stats, 877 .get_sset_count = qeth_core_get_sset_count, 878 .get_drvinfo = qeth_core_get_drvinfo, 879 }; 880 881 static const struct net_device_ops qeth_l2_netdev_ops = { 882 .ndo_open = qeth_l2_open, 883 .ndo_stop = qeth_l2_stop, 884 .ndo_get_stats = qeth_get_stats, 885 .ndo_start_xmit = qeth_l2_hard_start_xmit, 886 .ndo_validate_addr = eth_validate_addr, 887 .ndo_set_multicast_list = qeth_l2_set_multicast_list, 888 .ndo_do_ioctl = qeth_l2_do_ioctl, 889 .ndo_set_mac_address = qeth_l2_set_mac_address, 890 .ndo_change_mtu = qeth_change_mtu, 891 .ndo_vlan_rx_add_vid = qeth_l2_vlan_rx_add_vid, 892 .ndo_vlan_rx_kill_vid = qeth_l2_vlan_rx_kill_vid, 893 .ndo_tx_timeout = qeth_tx_timeout, 894 }; 895 896 static int qeth_l2_setup_netdev(struct qeth_card *card) 897 { 898 switch (card->info.type) { 899 case QETH_CARD_TYPE_OSAE: 900 card->dev = alloc_etherdev(0); 901 break; 902 case QETH_CARD_TYPE_IQD: 903 card->dev = alloc_netdev(0, "hsi%d", ether_setup); 904 break; 905 case QETH_CARD_TYPE_OSN: 906 card->dev = alloc_netdev(0, "osn%d", ether_setup); 907 card->dev->flags |= IFF_NOARP; 908 break; 909 default: 910 card->dev = alloc_etherdev(0); 911 } 912 913 if (!card->dev) 914 return -ENODEV; 915 916 card->dev->ml_priv = card; 917 card->dev->watchdog_timeo = QETH_TX_TIMEOUT; 918 card->dev->mtu = card->info.initial_mtu; 919 card->dev->netdev_ops = &qeth_l2_netdev_ops; 920 if (card->info.type != QETH_CARD_TYPE_OSN) 921 SET_ETHTOOL_OPS(card->dev, &qeth_l2_ethtool_ops); 922 else 923 SET_ETHTOOL_OPS(card->dev, &qeth_l2_osn_ops); 924 card->dev->features |= NETIF_F_HW_VLAN_FILTER; 925 card->info.broadcast_capable = 1; 926 qeth_l2_request_initial_mac(card); 927 SET_NETDEV_DEV(card->dev, &card->gdev->dev); 928 return register_netdev(card->dev); 929 } 930 931 static int __qeth_l2_set_online(struct ccwgroup_device *gdev, int recovery_mode) 932 { 933 struct qeth_card *card = dev_get_drvdata(&gdev->dev); 934 int rc = 0; 935 enum qeth_card_states recover_flag; 936 937 BUG_ON(!card); 938 QETH_DBF_TEXT(SETUP, 2, "setonlin"); 939 QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *)); 940 941 qeth_set_allowed_threads(card, QETH_RECOVER_THREAD, 1); 942 recover_flag = card->state; 943 rc = qeth_core_hardsetup_card(card); 944 if (rc) { 945 QETH_DBF_TEXT_(SETUP, 2, "2err%d", rc); 946 rc = -ENODEV; 947 goto out_remove; 948 } 949 950 if (!card->dev && qeth_l2_setup_netdev(card)) { 951 rc = -ENODEV; 952 goto out_remove; 953 } 954 955 if (card->info.type != QETH_CARD_TYPE_OSN) 956 qeth_l2_send_setmac(card, &card->dev->dev_addr[0]); 957 958 card->state = CARD_STATE_HARDSETUP; 959 qeth_print_status_message(card); 960 961 /* softsetup */ 962 QETH_DBF_TEXT(SETUP, 2, "softsetp"); 963 964 rc = qeth_send_startlan(card); 965 if (rc) { 966 QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc); 967 if (rc == 0xe080) { 968 dev_warn(&card->gdev->dev, 969 "The LAN is offline\n"); 970 card->lan_online = 0; 971 return 0; 972 } 973 rc = -ENODEV; 974 goto out_remove; 975 } else 976 card->lan_online = 1; 977 978 if (card->info.type != QETH_CARD_TYPE_OSN) { 979 /* configure isolation level */ 980 qeth_set_access_ctrl_online(card); 981 qeth_l2_process_vlans(card, 0); 982 } 983 984 netif_tx_disable(card->dev); 985 986 rc = qeth_init_qdio_queues(card); 987 if (rc) { 988 QETH_DBF_TEXT_(SETUP, 2, "6err%d", rc); 989 rc = -ENODEV; 990 goto out_remove; 991 } 992 card->state = CARD_STATE_SOFTSETUP; 993 netif_carrier_on(card->dev); 994 995 qeth_set_allowed_threads(card, 0xffffffff, 0); 996 if (recover_flag == CARD_STATE_RECOVER) { 997 if (recovery_mode && 998 card->info.type != QETH_CARD_TYPE_OSN) { 999 qeth_l2_open(card->dev); 1000 } else { 1001 rtnl_lock(); 1002 dev_open(card->dev); 1003 rtnl_unlock(); 1004 } 1005 /* this also sets saved unicast addresses */ 1006 qeth_l2_set_multicast_list(card->dev); 1007 } 1008 /* let user_space know that device is online */ 1009 kobject_uevent(&gdev->dev.kobj, KOBJ_CHANGE); 1010 return 0; 1011 1012 out_remove: 1013 card->use_hard_stop = 1; 1014 qeth_l2_stop_card(card, 0); 1015 ccw_device_set_offline(CARD_DDEV(card)); 1016 ccw_device_set_offline(CARD_WDEV(card)); 1017 ccw_device_set_offline(CARD_RDEV(card)); 1018 if (recover_flag == CARD_STATE_RECOVER) 1019 card->state = CARD_STATE_RECOVER; 1020 else 1021 card->state = CARD_STATE_DOWN; 1022 return rc; 1023 } 1024 1025 static int qeth_l2_set_online(struct ccwgroup_device *gdev) 1026 { 1027 return __qeth_l2_set_online(gdev, 0); 1028 } 1029 1030 static int __qeth_l2_set_offline(struct ccwgroup_device *cgdev, 1031 int recovery_mode) 1032 { 1033 struct qeth_card *card = dev_get_drvdata(&cgdev->dev); 1034 int rc = 0, rc2 = 0, rc3 = 0; 1035 enum qeth_card_states recover_flag; 1036 1037 QETH_DBF_TEXT(SETUP, 3, "setoffl"); 1038 QETH_DBF_HEX(SETUP, 3, &card, sizeof(void *)); 1039 1040 if (card->dev && netif_carrier_ok(card->dev)) 1041 netif_carrier_off(card->dev); 1042 recover_flag = card->state; 1043 qeth_l2_stop_card(card, recovery_mode); 1044 rc = ccw_device_set_offline(CARD_DDEV(card)); 1045 rc2 = ccw_device_set_offline(CARD_WDEV(card)); 1046 rc3 = ccw_device_set_offline(CARD_RDEV(card)); 1047 if (!rc) 1048 rc = (rc2) ? rc2 : rc3; 1049 if (rc) 1050 QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc); 1051 if (recover_flag == CARD_STATE_UP) 1052 card->state = CARD_STATE_RECOVER; 1053 /* let user_space know that device is offline */ 1054 kobject_uevent(&cgdev->dev.kobj, KOBJ_CHANGE); 1055 return 0; 1056 } 1057 1058 static int qeth_l2_set_offline(struct ccwgroup_device *cgdev) 1059 { 1060 return __qeth_l2_set_offline(cgdev, 0); 1061 } 1062 1063 static int qeth_l2_recover(void *ptr) 1064 { 1065 struct qeth_card *card; 1066 int rc = 0; 1067 1068 card = (struct qeth_card *) ptr; 1069 QETH_DBF_TEXT(TRACE, 2, "recover1"); 1070 QETH_DBF_HEX(TRACE, 2, &card, sizeof(void *)); 1071 if (!qeth_do_run_thread(card, QETH_RECOVER_THREAD)) 1072 return 0; 1073 QETH_DBF_TEXT(TRACE, 2, "recover2"); 1074 dev_warn(&card->gdev->dev, 1075 "A recovery process has been started for the device\n"); 1076 card->use_hard_stop = 1; 1077 __qeth_l2_set_offline(card->gdev, 1); 1078 rc = __qeth_l2_set_online(card->gdev, 1); 1079 /* don't run another scheduled recovery */ 1080 qeth_clear_thread_start_bit(card, QETH_RECOVER_THREAD); 1081 qeth_clear_thread_running_bit(card, QETH_RECOVER_THREAD); 1082 if (!rc) 1083 dev_info(&card->gdev->dev, 1084 "Device successfully recovered!\n"); 1085 else { 1086 if (card->dev) { 1087 rtnl_lock(); 1088 dev_close(card->dev); 1089 rtnl_unlock(); 1090 } 1091 dev_warn(&card->gdev->dev, "The qeth device driver " 1092 "failed to recover an error on the device\n"); 1093 } 1094 return 0; 1095 } 1096 1097 static int __init qeth_l2_init(void) 1098 { 1099 pr_info("register layer 2 discipline\n"); 1100 return 0; 1101 } 1102 1103 static void __exit qeth_l2_exit(void) 1104 { 1105 pr_info("unregister layer 2 discipline\n"); 1106 } 1107 1108 static void qeth_l2_shutdown(struct ccwgroup_device *gdev) 1109 { 1110 struct qeth_card *card = dev_get_drvdata(&gdev->dev); 1111 qeth_qdio_clear_card(card, 0); 1112 qeth_clear_qdio_buffers(card); 1113 } 1114 1115 static int qeth_l2_pm_suspend(struct ccwgroup_device *gdev) 1116 { 1117 struct qeth_card *card = dev_get_drvdata(&gdev->dev); 1118 1119 if (card->dev) 1120 netif_device_detach(card->dev); 1121 qeth_set_allowed_threads(card, 0, 1); 1122 wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0); 1123 if (gdev->state == CCWGROUP_OFFLINE) 1124 return 0; 1125 if (card->state == CARD_STATE_UP) { 1126 card->use_hard_stop = 1; 1127 __qeth_l2_set_offline(card->gdev, 1); 1128 } else 1129 __qeth_l2_set_offline(card->gdev, 0); 1130 return 0; 1131 } 1132 1133 static int qeth_l2_pm_resume(struct ccwgroup_device *gdev) 1134 { 1135 struct qeth_card *card = dev_get_drvdata(&gdev->dev); 1136 int rc = 0; 1137 1138 if (gdev->state == CCWGROUP_OFFLINE) 1139 goto out; 1140 1141 if (card->state == CARD_STATE_RECOVER) { 1142 rc = __qeth_l2_set_online(card->gdev, 1); 1143 if (rc) { 1144 if (card->dev) { 1145 rtnl_lock(); 1146 dev_close(card->dev); 1147 rtnl_unlock(); 1148 } 1149 } 1150 } else 1151 rc = __qeth_l2_set_online(card->gdev, 0); 1152 out: 1153 qeth_set_allowed_threads(card, 0xffffffff, 0); 1154 if (card->dev) 1155 netif_device_attach(card->dev); 1156 if (rc) 1157 dev_warn(&card->gdev->dev, "The qeth device driver " 1158 "failed to recover an error on the device\n"); 1159 return rc; 1160 } 1161 1162 struct ccwgroup_driver qeth_l2_ccwgroup_driver = { 1163 .probe = qeth_l2_probe_device, 1164 .remove = qeth_l2_remove_device, 1165 .set_online = qeth_l2_set_online, 1166 .set_offline = qeth_l2_set_offline, 1167 .shutdown = qeth_l2_shutdown, 1168 .freeze = qeth_l2_pm_suspend, 1169 .thaw = qeth_l2_pm_resume, 1170 .restore = qeth_l2_pm_resume, 1171 }; 1172 EXPORT_SYMBOL_GPL(qeth_l2_ccwgroup_driver); 1173 1174 static int qeth_osn_send_control_data(struct qeth_card *card, int len, 1175 struct qeth_cmd_buffer *iob) 1176 { 1177 unsigned long flags; 1178 int rc = 0; 1179 1180 QETH_DBF_TEXT(TRACE, 5, "osndctrd"); 1181 1182 wait_event(card->wait_q, 1183 atomic_cmpxchg(&card->write.irq_pending, 0, 1) == 0); 1184 qeth_prepare_control_data(card, len, iob); 1185 QETH_DBF_TEXT(TRACE, 6, "osnoirqp"); 1186 spin_lock_irqsave(get_ccwdev_lock(card->write.ccwdev), flags); 1187 rc = ccw_device_start(card->write.ccwdev, &card->write.ccw, 1188 (addr_t) iob, 0, 0); 1189 spin_unlock_irqrestore(get_ccwdev_lock(card->write.ccwdev), flags); 1190 if (rc) { 1191 QETH_DBF_MESSAGE(2, "qeth_osn_send_control_data: " 1192 "ccw_device_start rc = %i\n", rc); 1193 QETH_DBF_TEXT_(TRACE, 2, " err%d", rc); 1194 qeth_release_buffer(iob->channel, iob); 1195 atomic_set(&card->write.irq_pending, 0); 1196 wake_up(&card->wait_q); 1197 } 1198 return rc; 1199 } 1200 1201 static int qeth_osn_send_ipa_cmd(struct qeth_card *card, 1202 struct qeth_cmd_buffer *iob, int data_len) 1203 { 1204 u16 s1, s2; 1205 1206 QETH_DBF_TEXT(TRACE, 4, "osndipa"); 1207 1208 qeth_prepare_ipa_cmd(card, iob, QETH_PROT_OSN2); 1209 s1 = (u16)(IPA_PDU_HEADER_SIZE + data_len); 1210 s2 = (u16)data_len; 1211 memcpy(QETH_IPA_PDU_LEN_TOTAL(iob->data), &s1, 2); 1212 memcpy(QETH_IPA_PDU_LEN_PDU1(iob->data), &s2, 2); 1213 memcpy(QETH_IPA_PDU_LEN_PDU2(iob->data), &s2, 2); 1214 memcpy(QETH_IPA_PDU_LEN_PDU3(iob->data), &s2, 2); 1215 return qeth_osn_send_control_data(card, s1, iob); 1216 } 1217 1218 int qeth_osn_assist(struct net_device *dev, void *data, int data_len) 1219 { 1220 struct qeth_cmd_buffer *iob; 1221 struct qeth_card *card; 1222 int rc; 1223 1224 QETH_DBF_TEXT(TRACE, 2, "osnsdmc"); 1225 if (!dev) 1226 return -ENODEV; 1227 card = dev->ml_priv; 1228 if (!card) 1229 return -ENODEV; 1230 if ((card->state != CARD_STATE_UP) && 1231 (card->state != CARD_STATE_SOFTSETUP)) 1232 return -ENODEV; 1233 iob = qeth_wait_for_buffer(&card->write); 1234 memcpy(iob->data+IPA_PDU_HEADER_SIZE, data, data_len); 1235 rc = qeth_osn_send_ipa_cmd(card, iob, data_len); 1236 return rc; 1237 } 1238 EXPORT_SYMBOL(qeth_osn_assist); 1239 1240 int qeth_osn_register(unsigned char *read_dev_no, struct net_device **dev, 1241 int (*assist_cb)(struct net_device *, void *), 1242 int (*data_cb)(struct sk_buff *)) 1243 { 1244 struct qeth_card *card; 1245 1246 QETH_DBF_TEXT(TRACE, 2, "osnreg"); 1247 *dev = qeth_l2_netdev_by_devno(read_dev_no); 1248 if (*dev == NULL) 1249 return -ENODEV; 1250 card = (*dev)->ml_priv; 1251 if (!card) 1252 return -ENODEV; 1253 if ((assist_cb == NULL) || (data_cb == NULL)) 1254 return -EINVAL; 1255 card->osn_info.assist_cb = assist_cb; 1256 card->osn_info.data_cb = data_cb; 1257 return 0; 1258 } 1259 EXPORT_SYMBOL(qeth_osn_register); 1260 1261 void qeth_osn_deregister(struct net_device *dev) 1262 { 1263 struct qeth_card *card; 1264 1265 QETH_DBF_TEXT(TRACE, 2, "osndereg"); 1266 if (!dev) 1267 return; 1268 card = dev->ml_priv; 1269 if (!card) 1270 return; 1271 card->osn_info.assist_cb = NULL; 1272 card->osn_info.data_cb = NULL; 1273 return; 1274 } 1275 EXPORT_SYMBOL(qeth_osn_deregister); 1276 1277 module_init(qeth_l2_init); 1278 module_exit(qeth_l2_exit); 1279 MODULE_AUTHOR("Frank Blaschka <frank.blaschka@de.ibm.com>"); 1280 MODULE_DESCRIPTION("qeth layer 2 discipline"); 1281 MODULE_LICENSE("GPL"); 1282