1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright IBM Corp. 2007, 2009 4 * Author(s): Utz Bacher <utz.bacher@de.ibm.com>, 5 * Frank Pavlic <fpavlic@de.ibm.com>, 6 * Thomas Spatzier <tspat@de.ibm.com>, 7 * Frank Blaschka <frank.blaschka@de.ibm.com> 8 */ 9 10 #define KMSG_COMPONENT "qeth" 11 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 12 13 #include <linux/compat.h> 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/log2.h> 20 #include <linux/ip.h> 21 #include <linux/tcp.h> 22 #include <linux/mii.h> 23 #include <linux/kthread.h> 24 #include <linux/slab.h> 25 #include <linux/if_vlan.h> 26 #include <linux/netdevice.h> 27 #include <linux/netdev_features.h> 28 #include <linux/skbuff.h> 29 #include <linux/vmalloc.h> 30 31 #include <net/iucv/af_iucv.h> 32 #include <net/dsfield.h> 33 34 #include <asm/ebcdic.h> 35 #include <asm/chpid.h> 36 #include <asm/io.h> 37 #include <asm/sysinfo.h> 38 #include <asm/diag.h> 39 #include <asm/cio.h> 40 #include <asm/ccwdev.h> 41 #include <asm/cpcmd.h> 42 43 #include "qeth_core.h" 44 45 struct qeth_dbf_info qeth_dbf[QETH_DBF_INFOS] = { 46 /* define dbf - Name, Pages, Areas, Maxlen, Level, View, Handle */ 47 /* N P A M L V H */ 48 [QETH_DBF_SETUP] = {"qeth_setup", 49 8, 1, 8, 5, &debug_hex_ascii_view, NULL}, 50 [QETH_DBF_MSG] = {"qeth_msg", 8, 1, 11 * sizeof(long), 3, 51 &debug_sprintf_view, NULL}, 52 [QETH_DBF_CTRL] = {"qeth_control", 53 8, 1, QETH_DBF_CTRL_LEN, 5, &debug_hex_ascii_view, NULL}, 54 }; 55 EXPORT_SYMBOL_GPL(qeth_dbf); 56 57 struct kmem_cache *qeth_core_header_cache; 58 EXPORT_SYMBOL_GPL(qeth_core_header_cache); 59 static struct kmem_cache *qeth_qdio_outbuf_cache; 60 61 static struct device *qeth_core_root_dev; 62 static struct lock_class_key qdio_out_skb_queue_key; 63 64 static void qeth_send_control_data_cb(struct qeth_card *card, 65 struct qeth_channel *channel, 66 struct qeth_cmd_buffer *iob); 67 static struct qeth_cmd_buffer *qeth_get_buffer(struct qeth_channel *); 68 static void qeth_free_buffer_pool(struct qeth_card *); 69 static int qeth_qdio_establish(struct qeth_card *); 70 static void qeth_free_qdio_buffers(struct qeth_card *); 71 static void qeth_notify_skbs(struct qeth_qdio_out_q *queue, 72 struct qeth_qdio_out_buffer *buf, 73 enum iucv_tx_notify notification); 74 static void qeth_release_skbs(struct qeth_qdio_out_buffer *buf); 75 static int qeth_init_qdio_out_buf(struct qeth_qdio_out_q *, int); 76 77 static void qeth_close_dev_handler(struct work_struct *work) 78 { 79 struct qeth_card *card; 80 81 card = container_of(work, struct qeth_card, close_dev_work); 82 QETH_CARD_TEXT(card, 2, "cldevhdl"); 83 ccwgroup_set_offline(card->gdev); 84 } 85 86 static const char *qeth_get_cardname(struct qeth_card *card) 87 { 88 if (card->info.guestlan) { 89 switch (card->info.type) { 90 case QETH_CARD_TYPE_OSD: 91 return " Virtual NIC QDIO"; 92 case QETH_CARD_TYPE_IQD: 93 return " Virtual NIC Hiper"; 94 case QETH_CARD_TYPE_OSM: 95 return " Virtual NIC QDIO - OSM"; 96 case QETH_CARD_TYPE_OSX: 97 return " Virtual NIC QDIO - OSX"; 98 default: 99 return " unknown"; 100 } 101 } else { 102 switch (card->info.type) { 103 case QETH_CARD_TYPE_OSD: 104 return " OSD Express"; 105 case QETH_CARD_TYPE_IQD: 106 return " HiperSockets"; 107 case QETH_CARD_TYPE_OSN: 108 return " OSN QDIO"; 109 case QETH_CARD_TYPE_OSM: 110 return " OSM QDIO"; 111 case QETH_CARD_TYPE_OSX: 112 return " OSX QDIO"; 113 default: 114 return " unknown"; 115 } 116 } 117 return " n/a"; 118 } 119 120 /* max length to be returned: 14 */ 121 const char *qeth_get_cardname_short(struct qeth_card *card) 122 { 123 if (card->info.guestlan) { 124 switch (card->info.type) { 125 case QETH_CARD_TYPE_OSD: 126 return "Virt.NIC QDIO"; 127 case QETH_CARD_TYPE_IQD: 128 return "Virt.NIC Hiper"; 129 case QETH_CARD_TYPE_OSM: 130 return "Virt.NIC OSM"; 131 case QETH_CARD_TYPE_OSX: 132 return "Virt.NIC OSX"; 133 default: 134 return "unknown"; 135 } 136 } else { 137 switch (card->info.type) { 138 case QETH_CARD_TYPE_OSD: 139 switch (card->info.link_type) { 140 case QETH_LINK_TYPE_FAST_ETH: 141 return "OSD_100"; 142 case QETH_LINK_TYPE_HSTR: 143 return "HSTR"; 144 case QETH_LINK_TYPE_GBIT_ETH: 145 return "OSD_1000"; 146 case QETH_LINK_TYPE_10GBIT_ETH: 147 return "OSD_10GIG"; 148 case QETH_LINK_TYPE_25GBIT_ETH: 149 return "OSD_25GIG"; 150 case QETH_LINK_TYPE_LANE_ETH100: 151 return "OSD_FE_LANE"; 152 case QETH_LINK_TYPE_LANE_TR: 153 return "OSD_TR_LANE"; 154 case QETH_LINK_TYPE_LANE_ETH1000: 155 return "OSD_GbE_LANE"; 156 case QETH_LINK_TYPE_LANE: 157 return "OSD_ATM_LANE"; 158 default: 159 return "OSD_Express"; 160 } 161 case QETH_CARD_TYPE_IQD: 162 return "HiperSockets"; 163 case QETH_CARD_TYPE_OSN: 164 return "OSN"; 165 case QETH_CARD_TYPE_OSM: 166 return "OSM_1000"; 167 case QETH_CARD_TYPE_OSX: 168 return "OSX_10GIG"; 169 default: 170 return "unknown"; 171 } 172 } 173 return "n/a"; 174 } 175 176 void qeth_set_allowed_threads(struct qeth_card *card, unsigned long threads, 177 int clear_start_mask) 178 { 179 unsigned long flags; 180 181 spin_lock_irqsave(&card->thread_mask_lock, flags); 182 card->thread_allowed_mask = threads; 183 if (clear_start_mask) 184 card->thread_start_mask &= threads; 185 spin_unlock_irqrestore(&card->thread_mask_lock, flags); 186 wake_up(&card->wait_q); 187 } 188 EXPORT_SYMBOL_GPL(qeth_set_allowed_threads); 189 190 int qeth_threads_running(struct qeth_card *card, unsigned long threads) 191 { 192 unsigned long flags; 193 int rc = 0; 194 195 spin_lock_irqsave(&card->thread_mask_lock, flags); 196 rc = (card->thread_running_mask & threads); 197 spin_unlock_irqrestore(&card->thread_mask_lock, flags); 198 return rc; 199 } 200 EXPORT_SYMBOL_GPL(qeth_threads_running); 201 202 void qeth_clear_working_pool_list(struct qeth_card *card) 203 { 204 struct qeth_buffer_pool_entry *pool_entry, *tmp; 205 206 QETH_CARD_TEXT(card, 5, "clwrklst"); 207 list_for_each_entry_safe(pool_entry, tmp, 208 &card->qdio.in_buf_pool.entry_list, list){ 209 list_del(&pool_entry->list); 210 } 211 } 212 EXPORT_SYMBOL_GPL(qeth_clear_working_pool_list); 213 214 static int qeth_alloc_buffer_pool(struct qeth_card *card) 215 { 216 struct qeth_buffer_pool_entry *pool_entry; 217 void *ptr; 218 int i, j; 219 220 QETH_CARD_TEXT(card, 5, "alocpool"); 221 for (i = 0; i < card->qdio.init_pool.buf_count; ++i) { 222 pool_entry = kzalloc(sizeof(*pool_entry), GFP_KERNEL); 223 if (!pool_entry) { 224 qeth_free_buffer_pool(card); 225 return -ENOMEM; 226 } 227 for (j = 0; j < QETH_MAX_BUFFER_ELEMENTS(card); ++j) { 228 ptr = (void *) __get_free_page(GFP_KERNEL); 229 if (!ptr) { 230 while (j > 0) 231 free_page((unsigned long) 232 pool_entry->elements[--j]); 233 kfree(pool_entry); 234 qeth_free_buffer_pool(card); 235 return -ENOMEM; 236 } 237 pool_entry->elements[j] = ptr; 238 } 239 list_add(&pool_entry->init_list, 240 &card->qdio.init_pool.entry_list); 241 } 242 return 0; 243 } 244 245 int qeth_realloc_buffer_pool(struct qeth_card *card, int bufcnt) 246 { 247 QETH_CARD_TEXT(card, 2, "realcbp"); 248 249 if (card->state != CARD_STATE_DOWN) 250 return -EPERM; 251 252 /* TODO: steel/add buffers from/to a running card's buffer pool (?) */ 253 qeth_clear_working_pool_list(card); 254 qeth_free_buffer_pool(card); 255 card->qdio.in_buf_pool.buf_count = bufcnt; 256 card->qdio.init_pool.buf_count = bufcnt; 257 return qeth_alloc_buffer_pool(card); 258 } 259 EXPORT_SYMBOL_GPL(qeth_realloc_buffer_pool); 260 261 static void qeth_free_qdio_queue(struct qeth_qdio_q *q) 262 { 263 if (!q) 264 return; 265 266 qdio_free_buffers(q->qdio_bufs, QDIO_MAX_BUFFERS_PER_Q); 267 kfree(q); 268 } 269 270 static struct qeth_qdio_q *qeth_alloc_qdio_queue(void) 271 { 272 struct qeth_qdio_q *q = kzalloc(sizeof(*q), GFP_KERNEL); 273 int i; 274 275 if (!q) 276 return NULL; 277 278 if (qdio_alloc_buffers(q->qdio_bufs, QDIO_MAX_BUFFERS_PER_Q)) { 279 kfree(q); 280 return NULL; 281 } 282 283 for (i = 0; i < QDIO_MAX_BUFFERS_PER_Q; ++i) 284 q->bufs[i].buffer = q->qdio_bufs[i]; 285 286 QETH_DBF_HEX(SETUP, 2, &q, sizeof(void *)); 287 return q; 288 } 289 290 static int qeth_cq_init(struct qeth_card *card) 291 { 292 int rc; 293 294 if (card->options.cq == QETH_CQ_ENABLED) { 295 QETH_DBF_TEXT(SETUP, 2, "cqinit"); 296 qdio_reset_buffers(card->qdio.c_q->qdio_bufs, 297 QDIO_MAX_BUFFERS_PER_Q); 298 card->qdio.c_q->next_buf_to_init = 127; 299 rc = do_QDIO(CARD_DDEV(card), QDIO_FLAG_SYNC_INPUT, 300 card->qdio.no_in_queues - 1, 0, 301 127); 302 if (rc) { 303 QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc); 304 goto out; 305 } 306 } 307 rc = 0; 308 out: 309 return rc; 310 } 311 312 static int qeth_alloc_cq(struct qeth_card *card) 313 { 314 int rc; 315 316 if (card->options.cq == QETH_CQ_ENABLED) { 317 int i; 318 struct qdio_outbuf_state *outbuf_states; 319 320 QETH_DBF_TEXT(SETUP, 2, "cqon"); 321 card->qdio.c_q = qeth_alloc_qdio_queue(); 322 if (!card->qdio.c_q) { 323 rc = -1; 324 goto kmsg_out; 325 } 326 card->qdio.no_in_queues = 2; 327 card->qdio.out_bufstates = 328 kcalloc(card->qdio.no_out_queues * 329 QDIO_MAX_BUFFERS_PER_Q, 330 sizeof(struct qdio_outbuf_state), 331 GFP_KERNEL); 332 outbuf_states = card->qdio.out_bufstates; 333 if (outbuf_states == NULL) { 334 rc = -1; 335 goto free_cq_out; 336 } 337 for (i = 0; i < card->qdio.no_out_queues; ++i) { 338 card->qdio.out_qs[i]->bufstates = outbuf_states; 339 outbuf_states += QDIO_MAX_BUFFERS_PER_Q; 340 } 341 } else { 342 QETH_DBF_TEXT(SETUP, 2, "nocq"); 343 card->qdio.c_q = NULL; 344 card->qdio.no_in_queues = 1; 345 } 346 QETH_DBF_TEXT_(SETUP, 2, "iqc%d", card->qdio.no_in_queues); 347 rc = 0; 348 out: 349 return rc; 350 free_cq_out: 351 qeth_free_qdio_queue(card->qdio.c_q); 352 card->qdio.c_q = NULL; 353 kmsg_out: 354 dev_err(&card->gdev->dev, "Failed to create completion queue\n"); 355 goto out; 356 } 357 358 static void qeth_free_cq(struct qeth_card *card) 359 { 360 if (card->qdio.c_q) { 361 --card->qdio.no_in_queues; 362 qeth_free_qdio_queue(card->qdio.c_q); 363 card->qdio.c_q = NULL; 364 } 365 kfree(card->qdio.out_bufstates); 366 card->qdio.out_bufstates = NULL; 367 } 368 369 static enum iucv_tx_notify qeth_compute_cq_notification(int sbalf15, 370 int delayed) 371 { 372 enum iucv_tx_notify n; 373 374 switch (sbalf15) { 375 case 0: 376 n = delayed ? TX_NOTIFY_DELAYED_OK : TX_NOTIFY_OK; 377 break; 378 case 4: 379 case 16: 380 case 17: 381 case 18: 382 n = delayed ? TX_NOTIFY_DELAYED_UNREACHABLE : 383 TX_NOTIFY_UNREACHABLE; 384 break; 385 default: 386 n = delayed ? TX_NOTIFY_DELAYED_GENERALERROR : 387 TX_NOTIFY_GENERALERROR; 388 break; 389 } 390 391 return n; 392 } 393 394 static void qeth_cleanup_handled_pending(struct qeth_qdio_out_q *q, int bidx, 395 int forced_cleanup) 396 { 397 if (q->card->options.cq != QETH_CQ_ENABLED) 398 return; 399 400 if (q->bufs[bidx]->next_pending != NULL) { 401 struct qeth_qdio_out_buffer *head = q->bufs[bidx]; 402 struct qeth_qdio_out_buffer *c = q->bufs[bidx]->next_pending; 403 404 while (c) { 405 if (forced_cleanup || 406 atomic_read(&c->state) == 407 QETH_QDIO_BUF_HANDLED_DELAYED) { 408 struct qeth_qdio_out_buffer *f = c; 409 QETH_CARD_TEXT(f->q->card, 5, "fp"); 410 QETH_CARD_TEXT_(f->q->card, 5, "%lx", (long) f); 411 /* release here to avoid interleaving between 412 outbound tasklet and inbound tasklet 413 regarding notifications and lifecycle */ 414 qeth_release_skbs(c); 415 416 c = f->next_pending; 417 WARN_ON_ONCE(head->next_pending != f); 418 head->next_pending = c; 419 kmem_cache_free(qeth_qdio_outbuf_cache, f); 420 } else { 421 head = c; 422 c = c->next_pending; 423 } 424 425 } 426 } 427 if (forced_cleanup && (atomic_read(&(q->bufs[bidx]->state)) == 428 QETH_QDIO_BUF_HANDLED_DELAYED)) { 429 /* for recovery situations */ 430 qeth_init_qdio_out_buf(q, bidx); 431 QETH_CARD_TEXT(q->card, 2, "clprecov"); 432 } 433 } 434 435 436 static void qeth_qdio_handle_aob(struct qeth_card *card, 437 unsigned long phys_aob_addr) 438 { 439 struct qaob *aob; 440 struct qeth_qdio_out_buffer *buffer; 441 enum iucv_tx_notify notification; 442 unsigned int i; 443 444 aob = (struct qaob *) phys_to_virt(phys_aob_addr); 445 QETH_CARD_TEXT(card, 5, "haob"); 446 QETH_CARD_TEXT_(card, 5, "%lx", phys_aob_addr); 447 buffer = (struct qeth_qdio_out_buffer *) aob->user1; 448 QETH_CARD_TEXT_(card, 5, "%lx", aob->user1); 449 450 if (atomic_cmpxchg(&buffer->state, QETH_QDIO_BUF_PRIMED, 451 QETH_QDIO_BUF_IN_CQ) == QETH_QDIO_BUF_PRIMED) { 452 notification = TX_NOTIFY_OK; 453 } else { 454 WARN_ON_ONCE(atomic_read(&buffer->state) != 455 QETH_QDIO_BUF_PENDING); 456 atomic_set(&buffer->state, QETH_QDIO_BUF_IN_CQ); 457 notification = TX_NOTIFY_DELAYED_OK; 458 } 459 460 if (aob->aorc != 0) { 461 QETH_CARD_TEXT_(card, 2, "aorc%02X", aob->aorc); 462 notification = qeth_compute_cq_notification(aob->aorc, 1); 463 } 464 qeth_notify_skbs(buffer->q, buffer, notification); 465 466 /* Free dangling allocations. The attached skbs are handled by 467 * qeth_cleanup_handled_pending(). 468 */ 469 for (i = 0; 470 i < aob->sb_count && i < QETH_MAX_BUFFER_ELEMENTS(card); 471 i++) { 472 if (aob->sba[i] && buffer->is_header[i]) 473 kmem_cache_free(qeth_core_header_cache, 474 (void *) aob->sba[i]); 475 } 476 atomic_set(&buffer->state, QETH_QDIO_BUF_HANDLED_DELAYED); 477 478 qdio_release_aob(aob); 479 } 480 481 static inline int qeth_is_cq(struct qeth_card *card, unsigned int queue) 482 { 483 return card->options.cq == QETH_CQ_ENABLED && 484 card->qdio.c_q != NULL && 485 queue != 0 && 486 queue == card->qdio.no_in_queues - 1; 487 } 488 489 static void qeth_setup_ccw(struct ccw1 *ccw, u8 cmd_code, u32 len, void *data) 490 { 491 ccw->cmd_code = cmd_code; 492 ccw->flags = CCW_FLAG_SLI; 493 ccw->count = len; 494 ccw->cda = (__u32) __pa(data); 495 } 496 497 static int __qeth_issue_next_read(struct qeth_card *card) 498 { 499 struct qeth_channel *channel = &card->read; 500 struct qeth_cmd_buffer *iob; 501 int rc; 502 503 QETH_CARD_TEXT(card, 5, "issnxrd"); 504 if (channel->state != CH_STATE_UP) 505 return -EIO; 506 iob = qeth_get_buffer(channel); 507 if (!iob) { 508 dev_warn(&card->gdev->dev, "The qeth device driver " 509 "failed to recover an error on the device\n"); 510 QETH_DBF_MESSAGE(2, "issue_next_read on device %x failed: no iob available\n", 511 CARD_DEVID(card)); 512 return -ENOMEM; 513 } 514 qeth_setup_ccw(channel->ccw, CCW_CMD_READ, QETH_BUFSIZE, iob->data); 515 QETH_CARD_TEXT(card, 6, "noirqpnd"); 516 rc = ccw_device_start(channel->ccwdev, channel->ccw, 517 (addr_t) iob, 0, 0); 518 if (rc) { 519 QETH_DBF_MESSAGE(2, "error %i on device %x when starting next read ccw!\n", 520 rc, CARD_DEVID(card)); 521 atomic_set(&channel->irq_pending, 0); 522 qeth_release_buffer(channel, iob); 523 card->read_or_write_problem = 1; 524 qeth_schedule_recovery(card); 525 wake_up(&card->wait_q); 526 } 527 return rc; 528 } 529 530 static int qeth_issue_next_read(struct qeth_card *card) 531 { 532 int ret; 533 534 spin_lock_irq(get_ccwdev_lock(CARD_RDEV(card))); 535 ret = __qeth_issue_next_read(card); 536 spin_unlock_irq(get_ccwdev_lock(CARD_RDEV(card))); 537 538 return ret; 539 } 540 541 static struct qeth_reply *qeth_alloc_reply(struct qeth_card *card) 542 { 543 struct qeth_reply *reply; 544 545 reply = kzalloc(sizeof(struct qeth_reply), GFP_ATOMIC); 546 if (reply) { 547 refcount_set(&reply->refcnt, 1); 548 atomic_set(&reply->received, 0); 549 init_waitqueue_head(&reply->wait_q); 550 } 551 return reply; 552 } 553 554 static void qeth_get_reply(struct qeth_reply *reply) 555 { 556 refcount_inc(&reply->refcnt); 557 } 558 559 static void qeth_put_reply(struct qeth_reply *reply) 560 { 561 if (refcount_dec_and_test(&reply->refcnt)) 562 kfree(reply); 563 } 564 565 static void qeth_enqueue_reply(struct qeth_card *card, struct qeth_reply *reply) 566 { 567 spin_lock_irq(&card->lock); 568 list_add_tail(&reply->list, &card->cmd_waiter_list); 569 spin_unlock_irq(&card->lock); 570 } 571 572 static void qeth_dequeue_reply(struct qeth_card *card, struct qeth_reply *reply) 573 { 574 spin_lock_irq(&card->lock); 575 list_del(&reply->list); 576 spin_unlock_irq(&card->lock); 577 } 578 579 static void qeth_notify_reply(struct qeth_reply *reply) 580 { 581 atomic_inc(&reply->received); 582 wake_up(&reply->wait_q); 583 } 584 585 static void qeth_issue_ipa_msg(struct qeth_ipa_cmd *cmd, int rc, 586 struct qeth_card *card) 587 { 588 const char *ipa_name; 589 int com = cmd->hdr.command; 590 ipa_name = qeth_get_ipa_cmd_name(com); 591 592 if (rc) 593 QETH_DBF_MESSAGE(2, "IPA: %s(%#x) for device %x returned %#x \"%s\"\n", 594 ipa_name, com, CARD_DEVID(card), rc, 595 qeth_get_ipa_msg(rc)); 596 else 597 QETH_DBF_MESSAGE(5, "IPA: %s(%#x) for device %x succeeded\n", 598 ipa_name, com, CARD_DEVID(card)); 599 } 600 601 static struct qeth_ipa_cmd *qeth_check_ipa_data(struct qeth_card *card, 602 struct qeth_ipa_cmd *cmd) 603 { 604 QETH_CARD_TEXT(card, 5, "chkipad"); 605 606 if (IS_IPA_REPLY(cmd)) { 607 if (cmd->hdr.command != IPA_CMD_SETCCID && 608 cmd->hdr.command != IPA_CMD_DELCCID && 609 cmd->hdr.command != IPA_CMD_MODCCID && 610 cmd->hdr.command != IPA_CMD_SET_DIAG_ASS) 611 qeth_issue_ipa_msg(cmd, cmd->hdr.return_code, card); 612 return cmd; 613 } 614 615 /* handle unsolicited event: */ 616 switch (cmd->hdr.command) { 617 case IPA_CMD_STOPLAN: 618 if (cmd->hdr.return_code == IPA_RC_VEPA_TO_VEB_TRANSITION) { 619 dev_err(&card->gdev->dev, 620 "Interface %s is down because the adjacent port is no longer in reflective relay mode\n", 621 QETH_CARD_IFNAME(card)); 622 schedule_work(&card->close_dev_work); 623 } else { 624 dev_warn(&card->gdev->dev, 625 "The link for interface %s on CHPID 0x%X failed\n", 626 QETH_CARD_IFNAME(card), card->info.chpid); 627 qeth_issue_ipa_msg(cmd, cmd->hdr.return_code, card); 628 netif_carrier_off(card->dev); 629 } 630 return NULL; 631 case IPA_CMD_STARTLAN: 632 dev_info(&card->gdev->dev, 633 "The link for %s on CHPID 0x%X has been restored\n", 634 QETH_CARD_IFNAME(card), card->info.chpid); 635 if (card->info.hwtrap) 636 card->info.hwtrap = 2; 637 qeth_schedule_recovery(card); 638 return NULL; 639 case IPA_CMD_SETBRIDGEPORT_IQD: 640 case IPA_CMD_SETBRIDGEPORT_OSA: 641 case IPA_CMD_ADDRESS_CHANGE_NOTIF: 642 if (card->discipline->control_event_handler(card, cmd)) 643 return cmd; 644 return NULL; 645 case IPA_CMD_MODCCID: 646 return cmd; 647 case IPA_CMD_REGISTER_LOCAL_ADDR: 648 QETH_CARD_TEXT(card, 3, "irla"); 649 return NULL; 650 case IPA_CMD_UNREGISTER_LOCAL_ADDR: 651 QETH_CARD_TEXT(card, 3, "urla"); 652 return NULL; 653 default: 654 QETH_DBF_MESSAGE(2, "Received data is IPA but not a reply!\n"); 655 return cmd; 656 } 657 } 658 659 void qeth_clear_ipacmd_list(struct qeth_card *card) 660 { 661 struct qeth_reply *reply; 662 unsigned long flags; 663 664 QETH_CARD_TEXT(card, 4, "clipalst"); 665 666 spin_lock_irqsave(&card->lock, flags); 667 list_for_each_entry(reply, &card->cmd_waiter_list, list) { 668 reply->rc = -EIO; 669 qeth_notify_reply(reply); 670 } 671 spin_unlock_irqrestore(&card->lock, flags); 672 } 673 EXPORT_SYMBOL_GPL(qeth_clear_ipacmd_list); 674 675 static int qeth_check_idx_response(struct qeth_card *card, 676 unsigned char *buffer) 677 { 678 if (!buffer) 679 return 0; 680 681 QETH_DBF_HEX(CTRL, 2, buffer, QETH_DBF_CTRL_LEN); 682 if ((buffer[2] & 0xc0) == 0xc0) { 683 QETH_DBF_MESSAGE(2, "received an IDX TERMINATE with cause code %#04x\n", 684 buffer[4]); 685 QETH_CARD_TEXT(card, 2, "ckidxres"); 686 QETH_CARD_TEXT(card, 2, " idxterm"); 687 QETH_CARD_TEXT_(card, 2, " rc%d", -EIO); 688 if (buffer[4] == 0xf6) { 689 dev_err(&card->gdev->dev, 690 "The qeth device is not configured " 691 "for the OSI layer required by z/VM\n"); 692 return -EPERM; 693 } 694 return -EIO; 695 } 696 return 0; 697 } 698 699 static struct qeth_cmd_buffer *__qeth_get_buffer(struct qeth_channel *channel) 700 { 701 __u8 index; 702 703 index = channel->io_buf_no; 704 do { 705 if (channel->iob[index].state == BUF_STATE_FREE) { 706 channel->iob[index].state = BUF_STATE_LOCKED; 707 channel->io_buf_no = (channel->io_buf_no + 1) % 708 QETH_CMD_BUFFER_NO; 709 memset(channel->iob[index].data, 0, QETH_BUFSIZE); 710 return channel->iob + index; 711 } 712 index = (index + 1) % QETH_CMD_BUFFER_NO; 713 } while (index != channel->io_buf_no); 714 715 return NULL; 716 } 717 718 void qeth_release_buffer(struct qeth_channel *channel, 719 struct qeth_cmd_buffer *iob) 720 { 721 unsigned long flags; 722 723 spin_lock_irqsave(&channel->iob_lock, flags); 724 iob->state = BUF_STATE_FREE; 725 iob->callback = qeth_send_control_data_cb; 726 if (iob->reply) { 727 qeth_put_reply(iob->reply); 728 iob->reply = NULL; 729 } 730 spin_unlock_irqrestore(&channel->iob_lock, flags); 731 wake_up(&channel->wait_q); 732 } 733 EXPORT_SYMBOL_GPL(qeth_release_buffer); 734 735 static void qeth_release_buffer_cb(struct qeth_card *card, 736 struct qeth_channel *channel, 737 struct qeth_cmd_buffer *iob) 738 { 739 qeth_release_buffer(channel, iob); 740 } 741 742 static void qeth_cancel_cmd(struct qeth_cmd_buffer *iob, int rc) 743 { 744 struct qeth_reply *reply = iob->reply; 745 746 if (reply) { 747 reply->rc = rc; 748 qeth_notify_reply(reply); 749 } 750 qeth_release_buffer(iob->channel, iob); 751 } 752 753 static struct qeth_cmd_buffer *qeth_get_buffer(struct qeth_channel *channel) 754 { 755 struct qeth_cmd_buffer *buffer = NULL; 756 unsigned long flags; 757 758 spin_lock_irqsave(&channel->iob_lock, flags); 759 buffer = __qeth_get_buffer(channel); 760 spin_unlock_irqrestore(&channel->iob_lock, flags); 761 return buffer; 762 } 763 764 struct qeth_cmd_buffer *qeth_wait_for_buffer(struct qeth_channel *channel) 765 { 766 struct qeth_cmd_buffer *buffer; 767 wait_event(channel->wait_q, 768 ((buffer = qeth_get_buffer(channel)) != NULL)); 769 return buffer; 770 } 771 EXPORT_SYMBOL_GPL(qeth_wait_for_buffer); 772 773 void qeth_clear_cmd_buffers(struct qeth_channel *channel) 774 { 775 int cnt; 776 777 for (cnt = 0; cnt < QETH_CMD_BUFFER_NO; cnt++) 778 qeth_release_buffer(channel, &channel->iob[cnt]); 779 channel->io_buf_no = 0; 780 } 781 EXPORT_SYMBOL_GPL(qeth_clear_cmd_buffers); 782 783 static void qeth_send_control_data_cb(struct qeth_card *card, 784 struct qeth_channel *channel, 785 struct qeth_cmd_buffer *iob) 786 { 787 struct qeth_ipa_cmd *cmd = NULL; 788 struct qeth_reply *reply = NULL; 789 struct qeth_reply *r; 790 unsigned long flags; 791 int rc = 0; 792 793 QETH_CARD_TEXT(card, 4, "sndctlcb"); 794 rc = qeth_check_idx_response(card, iob->data); 795 switch (rc) { 796 case 0: 797 break; 798 case -EIO: 799 qeth_clear_ipacmd_list(card); 800 qeth_schedule_recovery(card); 801 /* fall through */ 802 default: 803 goto out; 804 } 805 806 if (IS_IPA(iob->data)) { 807 cmd = (struct qeth_ipa_cmd *) PDU_ENCAPSULATION(iob->data); 808 cmd = qeth_check_ipa_data(card, cmd); 809 if (!cmd) 810 goto out; 811 if (IS_OSN(card) && card->osn_info.assist_cb && 812 cmd->hdr.command != IPA_CMD_STARTLAN) { 813 card->osn_info.assist_cb(card->dev, cmd); 814 goto out; 815 } 816 } else { 817 /* non-IPA commands should only flow during initialization */ 818 if (card->state != CARD_STATE_DOWN) 819 goto out; 820 } 821 822 /* match against pending cmd requests */ 823 spin_lock_irqsave(&card->lock, flags); 824 list_for_each_entry(r, &card->cmd_waiter_list, list) { 825 if ((r->seqno == QETH_IDX_COMMAND_SEQNO) || 826 (cmd && (r->seqno == cmd->hdr.seqno))) { 827 reply = r; 828 /* take the object outside the lock */ 829 qeth_get_reply(reply); 830 break; 831 } 832 } 833 spin_unlock_irqrestore(&card->lock, flags); 834 835 if (!reply) 836 goto out; 837 838 if (!reply->callback) { 839 rc = 0; 840 } else { 841 if (cmd) { 842 reply->offset = (u16)((char *)cmd - (char *)iob->data); 843 rc = reply->callback(card, reply, (unsigned long)cmd); 844 } else { 845 rc = reply->callback(card, reply, (unsigned long)iob); 846 } 847 } 848 849 if (rc <= 0) { 850 reply->rc = rc; 851 qeth_notify_reply(reply); 852 } 853 854 qeth_put_reply(reply); 855 856 out: 857 memcpy(&card->seqno.pdu_hdr_ack, 858 QETH_PDU_HEADER_SEQ_NO(iob->data), 859 QETH_SEQ_NO_LENGTH); 860 qeth_release_buffer(channel, iob); 861 } 862 863 static int qeth_set_thread_start_bit(struct qeth_card *card, 864 unsigned long thread) 865 { 866 unsigned long flags; 867 868 spin_lock_irqsave(&card->thread_mask_lock, flags); 869 if (!(card->thread_allowed_mask & thread) || 870 (card->thread_start_mask & thread)) { 871 spin_unlock_irqrestore(&card->thread_mask_lock, flags); 872 return -EPERM; 873 } 874 card->thread_start_mask |= thread; 875 spin_unlock_irqrestore(&card->thread_mask_lock, flags); 876 return 0; 877 } 878 879 void qeth_clear_thread_start_bit(struct qeth_card *card, unsigned long thread) 880 { 881 unsigned long flags; 882 883 spin_lock_irqsave(&card->thread_mask_lock, flags); 884 card->thread_start_mask &= ~thread; 885 spin_unlock_irqrestore(&card->thread_mask_lock, flags); 886 wake_up(&card->wait_q); 887 } 888 EXPORT_SYMBOL_GPL(qeth_clear_thread_start_bit); 889 890 void qeth_clear_thread_running_bit(struct qeth_card *card, unsigned long thread) 891 { 892 unsigned long flags; 893 894 spin_lock_irqsave(&card->thread_mask_lock, flags); 895 card->thread_running_mask &= ~thread; 896 spin_unlock_irqrestore(&card->thread_mask_lock, flags); 897 wake_up_all(&card->wait_q); 898 } 899 EXPORT_SYMBOL_GPL(qeth_clear_thread_running_bit); 900 901 static int __qeth_do_run_thread(struct qeth_card *card, unsigned long thread) 902 { 903 unsigned long flags; 904 int rc = 0; 905 906 spin_lock_irqsave(&card->thread_mask_lock, flags); 907 if (card->thread_start_mask & thread) { 908 if ((card->thread_allowed_mask & thread) && 909 !(card->thread_running_mask & thread)) { 910 rc = 1; 911 card->thread_start_mask &= ~thread; 912 card->thread_running_mask |= thread; 913 } else 914 rc = -EPERM; 915 } 916 spin_unlock_irqrestore(&card->thread_mask_lock, flags); 917 return rc; 918 } 919 920 int qeth_do_run_thread(struct qeth_card *card, unsigned long thread) 921 { 922 int rc = 0; 923 924 wait_event(card->wait_q, 925 (rc = __qeth_do_run_thread(card, thread)) >= 0); 926 return rc; 927 } 928 EXPORT_SYMBOL_GPL(qeth_do_run_thread); 929 930 void qeth_schedule_recovery(struct qeth_card *card) 931 { 932 QETH_CARD_TEXT(card, 2, "startrec"); 933 if (qeth_set_thread_start_bit(card, QETH_RECOVER_THREAD) == 0) 934 schedule_work(&card->kernel_thread_starter); 935 } 936 EXPORT_SYMBOL_GPL(qeth_schedule_recovery); 937 938 static int qeth_get_problem(struct qeth_card *card, struct ccw_device *cdev, 939 struct irb *irb) 940 { 941 int dstat, cstat; 942 char *sense; 943 944 sense = (char *) irb->ecw; 945 cstat = irb->scsw.cmd.cstat; 946 dstat = irb->scsw.cmd.dstat; 947 948 if (cstat & (SCHN_STAT_CHN_CTRL_CHK | SCHN_STAT_INTF_CTRL_CHK | 949 SCHN_STAT_CHN_DATA_CHK | SCHN_STAT_CHAIN_CHECK | 950 SCHN_STAT_PROT_CHECK | SCHN_STAT_PROG_CHECK)) { 951 QETH_CARD_TEXT(card, 2, "CGENCHK"); 952 dev_warn(&cdev->dev, "The qeth device driver " 953 "failed to recover an error on the device\n"); 954 QETH_DBF_MESSAGE(2, "check on channel %x with dstat=%#x, cstat=%#x\n", 955 CCW_DEVID(cdev), dstat, cstat); 956 print_hex_dump(KERN_WARNING, "qeth: irb ", DUMP_PREFIX_OFFSET, 957 16, 1, irb, 64, 1); 958 return 1; 959 } 960 961 if (dstat & DEV_STAT_UNIT_CHECK) { 962 if (sense[SENSE_RESETTING_EVENT_BYTE] & 963 SENSE_RESETTING_EVENT_FLAG) { 964 QETH_CARD_TEXT(card, 2, "REVIND"); 965 return 1; 966 } 967 if (sense[SENSE_COMMAND_REJECT_BYTE] & 968 SENSE_COMMAND_REJECT_FLAG) { 969 QETH_CARD_TEXT(card, 2, "CMDREJi"); 970 return 1; 971 } 972 if ((sense[2] == 0xaf) && (sense[3] == 0xfe)) { 973 QETH_CARD_TEXT(card, 2, "AFFE"); 974 return 1; 975 } 976 if ((!sense[0]) && (!sense[1]) && (!sense[2]) && (!sense[3])) { 977 QETH_CARD_TEXT(card, 2, "ZEROSEN"); 978 return 0; 979 } 980 QETH_CARD_TEXT(card, 2, "DGENCHK"); 981 return 1; 982 } 983 return 0; 984 } 985 986 static int qeth_check_irb_error(struct qeth_card *card, struct ccw_device *cdev, 987 unsigned long intparm, struct irb *irb) 988 { 989 if (!IS_ERR(irb)) 990 return 0; 991 992 switch (PTR_ERR(irb)) { 993 case -EIO: 994 QETH_DBF_MESSAGE(2, "i/o-error on channel %x\n", 995 CCW_DEVID(cdev)); 996 QETH_CARD_TEXT(card, 2, "ckirberr"); 997 QETH_CARD_TEXT_(card, 2, " rc%d", -EIO); 998 return -EIO; 999 case -ETIMEDOUT: 1000 dev_warn(&cdev->dev, "A hardware operation timed out" 1001 " on the device\n"); 1002 QETH_CARD_TEXT(card, 2, "ckirberr"); 1003 QETH_CARD_TEXT_(card, 2, " rc%d", -ETIMEDOUT); 1004 if (intparm == QETH_RCD_PARM) { 1005 if (card->data.ccwdev == cdev) { 1006 card->data.state = CH_STATE_DOWN; 1007 wake_up(&card->wait_q); 1008 } 1009 } 1010 return -ETIMEDOUT; 1011 default: 1012 QETH_DBF_MESSAGE(2, "unknown error %ld on channel %x\n", 1013 PTR_ERR(irb), CCW_DEVID(cdev)); 1014 QETH_CARD_TEXT(card, 2, "ckirberr"); 1015 QETH_CARD_TEXT(card, 2, " rc???"); 1016 return PTR_ERR(irb); 1017 } 1018 } 1019 1020 static void qeth_irq(struct ccw_device *cdev, unsigned long intparm, 1021 struct irb *irb) 1022 { 1023 int rc; 1024 int cstat, dstat; 1025 struct qeth_cmd_buffer *iob = NULL; 1026 struct ccwgroup_device *gdev; 1027 struct qeth_channel *channel; 1028 struct qeth_card *card; 1029 1030 /* while we hold the ccwdev lock, this stays valid: */ 1031 gdev = dev_get_drvdata(&cdev->dev); 1032 card = dev_get_drvdata(&gdev->dev); 1033 if (!card) 1034 return; 1035 1036 QETH_CARD_TEXT(card, 5, "irq"); 1037 1038 if (card->read.ccwdev == cdev) { 1039 channel = &card->read; 1040 QETH_CARD_TEXT(card, 5, "read"); 1041 } else if (card->write.ccwdev == cdev) { 1042 channel = &card->write; 1043 QETH_CARD_TEXT(card, 5, "write"); 1044 } else { 1045 channel = &card->data; 1046 QETH_CARD_TEXT(card, 5, "data"); 1047 } 1048 1049 if (qeth_intparm_is_iob(intparm)) 1050 iob = (struct qeth_cmd_buffer *) __va((addr_t)intparm); 1051 1052 rc = qeth_check_irb_error(card, cdev, intparm, irb); 1053 if (rc) { 1054 /* IO was terminated, free its resources. */ 1055 if (iob) 1056 qeth_cancel_cmd(iob, rc); 1057 atomic_set(&channel->irq_pending, 0); 1058 wake_up(&card->wait_q); 1059 return; 1060 } 1061 1062 atomic_set(&channel->irq_pending, 0); 1063 1064 if (irb->scsw.cmd.fctl & (SCSW_FCTL_CLEAR_FUNC)) 1065 channel->state = CH_STATE_STOPPED; 1066 1067 if (irb->scsw.cmd.fctl & (SCSW_FCTL_HALT_FUNC)) 1068 channel->state = CH_STATE_HALTED; 1069 1070 /*let's wake up immediately on data channel*/ 1071 if ((channel == &card->data) && (intparm != 0) && 1072 (intparm != QETH_RCD_PARM)) 1073 goto out; 1074 1075 if (intparm == QETH_CLEAR_CHANNEL_PARM) { 1076 QETH_CARD_TEXT(card, 6, "clrchpar"); 1077 /* we don't have to handle this further */ 1078 intparm = 0; 1079 } 1080 if (intparm == QETH_HALT_CHANNEL_PARM) { 1081 QETH_CARD_TEXT(card, 6, "hltchpar"); 1082 /* we don't have to handle this further */ 1083 intparm = 0; 1084 } 1085 1086 cstat = irb->scsw.cmd.cstat; 1087 dstat = irb->scsw.cmd.dstat; 1088 1089 if ((dstat & DEV_STAT_UNIT_EXCEP) || 1090 (dstat & DEV_STAT_UNIT_CHECK) || 1091 (cstat)) { 1092 if (irb->esw.esw0.erw.cons) { 1093 dev_warn(&channel->ccwdev->dev, 1094 "The qeth device driver failed to recover " 1095 "an error on the device\n"); 1096 QETH_DBF_MESSAGE(2, "sense data available on channel %x: cstat %#X dstat %#X\n", 1097 CCW_DEVID(channel->ccwdev), cstat, 1098 dstat); 1099 print_hex_dump(KERN_WARNING, "qeth: irb ", 1100 DUMP_PREFIX_OFFSET, 16, 1, irb, 32, 1); 1101 print_hex_dump(KERN_WARNING, "qeth: sense data ", 1102 DUMP_PREFIX_OFFSET, 16, 1, irb->ecw, 32, 1); 1103 } 1104 if (intparm == QETH_RCD_PARM) { 1105 channel->state = CH_STATE_DOWN; 1106 goto out; 1107 } 1108 rc = qeth_get_problem(card, cdev, irb); 1109 if (rc) { 1110 card->read_or_write_problem = 1; 1111 if (iob) 1112 qeth_cancel_cmd(iob, rc); 1113 qeth_clear_ipacmd_list(card); 1114 qeth_schedule_recovery(card); 1115 goto out; 1116 } 1117 } 1118 1119 if (intparm == QETH_RCD_PARM) { 1120 channel->state = CH_STATE_RCD_DONE; 1121 goto out; 1122 } 1123 if (channel == &card->data) 1124 return; 1125 if (channel == &card->read && 1126 channel->state == CH_STATE_UP) 1127 __qeth_issue_next_read(card); 1128 1129 if (iob && iob->callback) 1130 iob->callback(card, iob->channel, iob); 1131 1132 out: 1133 wake_up(&card->wait_q); 1134 return; 1135 } 1136 1137 static void qeth_notify_skbs(struct qeth_qdio_out_q *q, 1138 struct qeth_qdio_out_buffer *buf, 1139 enum iucv_tx_notify notification) 1140 { 1141 struct sk_buff *skb; 1142 1143 skb_queue_walk(&buf->skb_list, skb) { 1144 QETH_CARD_TEXT_(q->card, 5, "skbn%d", notification); 1145 QETH_CARD_TEXT_(q->card, 5, "%lx", (long) skb); 1146 if (skb->protocol == htons(ETH_P_AF_IUCV) && skb->sk) 1147 iucv_sk(skb->sk)->sk_txnotify(skb, notification); 1148 } 1149 } 1150 1151 static void qeth_release_skbs(struct qeth_qdio_out_buffer *buf) 1152 { 1153 struct sk_buff *skb; 1154 1155 /* release may never happen from within CQ tasklet scope */ 1156 WARN_ON_ONCE(atomic_read(&buf->state) == QETH_QDIO_BUF_IN_CQ); 1157 1158 if (atomic_read(&buf->state) == QETH_QDIO_BUF_PENDING) 1159 qeth_notify_skbs(buf->q, buf, TX_NOTIFY_GENERALERROR); 1160 1161 while ((skb = __skb_dequeue(&buf->skb_list)) != NULL) 1162 consume_skb(skb); 1163 } 1164 1165 static void qeth_clear_output_buffer(struct qeth_qdio_out_q *queue, 1166 struct qeth_qdio_out_buffer *buf) 1167 { 1168 int i; 1169 1170 /* is PCI flag set on buffer? */ 1171 if (buf->buffer->element[0].sflags & SBAL_SFLAGS0_PCI_REQ) 1172 atomic_dec(&queue->set_pci_flags_count); 1173 1174 qeth_release_skbs(buf); 1175 1176 for (i = 0; i < QETH_MAX_BUFFER_ELEMENTS(queue->card); ++i) { 1177 if (buf->buffer->element[i].addr && buf->is_header[i]) 1178 kmem_cache_free(qeth_core_header_cache, 1179 buf->buffer->element[i].addr); 1180 buf->is_header[i] = 0; 1181 } 1182 1183 qeth_scrub_qdio_buffer(buf->buffer, 1184 QETH_MAX_BUFFER_ELEMENTS(queue->card)); 1185 buf->next_element_to_fill = 0; 1186 atomic_set(&buf->state, QETH_QDIO_BUF_EMPTY); 1187 } 1188 1189 static void qeth_clear_outq_buffers(struct qeth_qdio_out_q *q, int free) 1190 { 1191 int j; 1192 1193 for (j = 0; j < QDIO_MAX_BUFFERS_PER_Q; ++j) { 1194 if (!q->bufs[j]) 1195 continue; 1196 qeth_cleanup_handled_pending(q, j, 1); 1197 qeth_clear_output_buffer(q, q->bufs[j]); 1198 if (free) { 1199 kmem_cache_free(qeth_qdio_outbuf_cache, q->bufs[j]); 1200 q->bufs[j] = NULL; 1201 } 1202 } 1203 } 1204 1205 void qeth_clear_qdio_buffers(struct qeth_card *card) 1206 { 1207 int i; 1208 1209 QETH_CARD_TEXT(card, 2, "clearqdbf"); 1210 /* clear outbound buffers to free skbs */ 1211 for (i = 0; i < card->qdio.no_out_queues; ++i) { 1212 if (card->qdio.out_qs[i]) { 1213 qeth_clear_outq_buffers(card->qdio.out_qs[i], 0); 1214 } 1215 } 1216 } 1217 EXPORT_SYMBOL_GPL(qeth_clear_qdio_buffers); 1218 1219 static void qeth_free_buffer_pool(struct qeth_card *card) 1220 { 1221 struct qeth_buffer_pool_entry *pool_entry, *tmp; 1222 int i = 0; 1223 list_for_each_entry_safe(pool_entry, tmp, 1224 &card->qdio.init_pool.entry_list, init_list){ 1225 for (i = 0; i < QETH_MAX_BUFFER_ELEMENTS(card); ++i) 1226 free_page((unsigned long)pool_entry->elements[i]); 1227 list_del(&pool_entry->init_list); 1228 kfree(pool_entry); 1229 } 1230 } 1231 1232 static void qeth_clean_channel(struct qeth_channel *channel) 1233 { 1234 struct ccw_device *cdev = channel->ccwdev; 1235 int cnt; 1236 1237 QETH_DBF_TEXT(SETUP, 2, "freech"); 1238 1239 spin_lock_irq(get_ccwdev_lock(cdev)); 1240 cdev->handler = NULL; 1241 spin_unlock_irq(get_ccwdev_lock(cdev)); 1242 1243 for (cnt = 0; cnt < QETH_CMD_BUFFER_NO; cnt++) 1244 kfree(channel->iob[cnt].data); 1245 kfree(channel->ccw); 1246 } 1247 1248 static int qeth_setup_channel(struct qeth_channel *channel, bool alloc_buffers) 1249 { 1250 struct ccw_device *cdev = channel->ccwdev; 1251 int cnt; 1252 1253 QETH_DBF_TEXT(SETUP, 2, "setupch"); 1254 1255 channel->ccw = kmalloc(sizeof(struct ccw1), GFP_KERNEL | GFP_DMA); 1256 if (!channel->ccw) 1257 return -ENOMEM; 1258 channel->state = CH_STATE_DOWN; 1259 atomic_set(&channel->irq_pending, 0); 1260 init_waitqueue_head(&channel->wait_q); 1261 1262 spin_lock_irq(get_ccwdev_lock(cdev)); 1263 cdev->handler = qeth_irq; 1264 spin_unlock_irq(get_ccwdev_lock(cdev)); 1265 1266 if (!alloc_buffers) 1267 return 0; 1268 1269 for (cnt = 0; cnt < QETH_CMD_BUFFER_NO; cnt++) { 1270 channel->iob[cnt].data = kmalloc(QETH_BUFSIZE, 1271 GFP_KERNEL | GFP_DMA); 1272 if (channel->iob[cnt].data == NULL) 1273 break; 1274 channel->iob[cnt].state = BUF_STATE_FREE; 1275 channel->iob[cnt].channel = channel; 1276 channel->iob[cnt].callback = qeth_send_control_data_cb; 1277 } 1278 if (cnt < QETH_CMD_BUFFER_NO) { 1279 qeth_clean_channel(channel); 1280 return -ENOMEM; 1281 } 1282 channel->io_buf_no = 0; 1283 spin_lock_init(&channel->iob_lock); 1284 1285 return 0; 1286 } 1287 1288 static void qeth_set_single_write_queues(struct qeth_card *card) 1289 { 1290 if ((atomic_read(&card->qdio.state) != QETH_QDIO_UNINITIALIZED) && 1291 (card->qdio.no_out_queues == 4)) 1292 qeth_free_qdio_buffers(card); 1293 1294 card->qdio.no_out_queues = 1; 1295 if (card->qdio.default_out_queue != 0) 1296 dev_info(&card->gdev->dev, "Priority Queueing not supported\n"); 1297 1298 card->qdio.default_out_queue = 0; 1299 } 1300 1301 static void qeth_set_multiple_write_queues(struct qeth_card *card) 1302 { 1303 if ((atomic_read(&card->qdio.state) != QETH_QDIO_UNINITIALIZED) && 1304 (card->qdio.no_out_queues == 1)) { 1305 qeth_free_qdio_buffers(card); 1306 card->qdio.default_out_queue = 2; 1307 } 1308 card->qdio.no_out_queues = 4; 1309 } 1310 1311 static void qeth_update_from_chp_desc(struct qeth_card *card) 1312 { 1313 struct ccw_device *ccwdev; 1314 struct channel_path_desc_fmt0 *chp_dsc; 1315 1316 QETH_DBF_TEXT(SETUP, 2, "chp_desc"); 1317 1318 ccwdev = card->data.ccwdev; 1319 chp_dsc = ccw_device_get_chp_desc(ccwdev, 0); 1320 if (!chp_dsc) 1321 goto out; 1322 1323 card->info.func_level = 0x4100 + chp_dsc->desc; 1324 if (card->info.type == QETH_CARD_TYPE_IQD) 1325 goto out; 1326 1327 /* CHPP field bit 6 == 1 -> single queue */ 1328 if ((chp_dsc->chpp & 0x02) == 0x02) 1329 qeth_set_single_write_queues(card); 1330 else 1331 qeth_set_multiple_write_queues(card); 1332 out: 1333 kfree(chp_dsc); 1334 QETH_DBF_TEXT_(SETUP, 2, "nr:%x", card->qdio.no_out_queues); 1335 QETH_DBF_TEXT_(SETUP, 2, "lvl:%02x", card->info.func_level); 1336 } 1337 1338 static void qeth_init_qdio_info(struct qeth_card *card) 1339 { 1340 QETH_DBF_TEXT(SETUP, 4, "intqdinf"); 1341 atomic_set(&card->qdio.state, QETH_QDIO_UNINITIALIZED); 1342 card->qdio.do_prio_queueing = QETH_PRIOQ_DEFAULT; 1343 card->qdio.default_out_queue = QETH_DEFAULT_QUEUE; 1344 card->qdio.no_out_queues = QETH_MAX_QUEUES; 1345 1346 /* inbound */ 1347 card->qdio.no_in_queues = 1; 1348 card->qdio.in_buf_size = QETH_IN_BUF_SIZE_DEFAULT; 1349 if (card->info.type == QETH_CARD_TYPE_IQD) 1350 card->qdio.init_pool.buf_count = QETH_IN_BUF_COUNT_HSDEFAULT; 1351 else 1352 card->qdio.init_pool.buf_count = QETH_IN_BUF_COUNT_DEFAULT; 1353 card->qdio.in_buf_pool.buf_count = card->qdio.init_pool.buf_count; 1354 INIT_LIST_HEAD(&card->qdio.in_buf_pool.entry_list); 1355 INIT_LIST_HEAD(&card->qdio.init_pool.entry_list); 1356 } 1357 1358 static void qeth_set_initial_options(struct qeth_card *card) 1359 { 1360 card->options.route4.type = NO_ROUTER; 1361 card->options.route6.type = NO_ROUTER; 1362 card->options.rx_sg_cb = QETH_RX_SG_CB; 1363 card->options.isolation = ISOLATION_MODE_NONE; 1364 card->options.cq = QETH_CQ_DISABLED; 1365 card->options.layer = QETH_DISCIPLINE_UNDETERMINED; 1366 } 1367 1368 static int qeth_do_start_thread(struct qeth_card *card, unsigned long thread) 1369 { 1370 unsigned long flags; 1371 int rc = 0; 1372 1373 spin_lock_irqsave(&card->thread_mask_lock, flags); 1374 QETH_CARD_TEXT_(card, 4, " %02x%02x%02x", 1375 (u8) card->thread_start_mask, 1376 (u8) card->thread_allowed_mask, 1377 (u8) card->thread_running_mask); 1378 rc = (card->thread_start_mask & thread); 1379 spin_unlock_irqrestore(&card->thread_mask_lock, flags); 1380 return rc; 1381 } 1382 1383 static void qeth_start_kernel_thread(struct work_struct *work) 1384 { 1385 struct task_struct *ts; 1386 struct qeth_card *card = container_of(work, struct qeth_card, 1387 kernel_thread_starter); 1388 QETH_CARD_TEXT(card , 2, "strthrd"); 1389 1390 if (card->read.state != CH_STATE_UP && 1391 card->write.state != CH_STATE_UP) 1392 return; 1393 if (qeth_do_start_thread(card, QETH_RECOVER_THREAD)) { 1394 ts = kthread_run(card->discipline->recover, (void *)card, 1395 "qeth_recover"); 1396 if (IS_ERR(ts)) { 1397 qeth_clear_thread_start_bit(card, QETH_RECOVER_THREAD); 1398 qeth_clear_thread_running_bit(card, 1399 QETH_RECOVER_THREAD); 1400 } 1401 } 1402 } 1403 1404 static void qeth_buffer_reclaim_work(struct work_struct *); 1405 static void qeth_setup_card(struct qeth_card *card) 1406 { 1407 QETH_DBF_TEXT(SETUP, 2, "setupcrd"); 1408 QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *)); 1409 1410 card->info.type = CARD_RDEV(card)->id.driver_info; 1411 card->state = CARD_STATE_DOWN; 1412 spin_lock_init(&card->mclock); 1413 spin_lock_init(&card->lock); 1414 spin_lock_init(&card->ip_lock); 1415 spin_lock_init(&card->thread_mask_lock); 1416 mutex_init(&card->conf_mutex); 1417 mutex_init(&card->discipline_mutex); 1418 INIT_WORK(&card->kernel_thread_starter, qeth_start_kernel_thread); 1419 INIT_LIST_HEAD(&card->cmd_waiter_list); 1420 init_waitqueue_head(&card->wait_q); 1421 qeth_set_initial_options(card); 1422 /* IP address takeover */ 1423 INIT_LIST_HEAD(&card->ipato.entries); 1424 qeth_init_qdio_info(card); 1425 INIT_DELAYED_WORK(&card->buffer_reclaim_work, qeth_buffer_reclaim_work); 1426 INIT_WORK(&card->close_dev_work, qeth_close_dev_handler); 1427 } 1428 1429 static void qeth_core_sl_print(struct seq_file *m, struct service_level *slr) 1430 { 1431 struct qeth_card *card = container_of(slr, struct qeth_card, 1432 qeth_service_level); 1433 if (card->info.mcl_level[0]) 1434 seq_printf(m, "qeth: %s firmware level %s\n", 1435 CARD_BUS_ID(card), card->info.mcl_level); 1436 } 1437 1438 static struct qeth_card *qeth_alloc_card(struct ccwgroup_device *gdev) 1439 { 1440 struct qeth_card *card; 1441 1442 QETH_DBF_TEXT(SETUP, 2, "alloccrd"); 1443 card = kzalloc(sizeof(*card), GFP_KERNEL); 1444 if (!card) 1445 goto out; 1446 QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *)); 1447 1448 card->gdev = gdev; 1449 dev_set_drvdata(&gdev->dev, card); 1450 CARD_RDEV(card) = gdev->cdev[0]; 1451 CARD_WDEV(card) = gdev->cdev[1]; 1452 CARD_DDEV(card) = gdev->cdev[2]; 1453 1454 card->event_wq = alloc_ordered_workqueue("%s", 0, dev_name(&gdev->dev)); 1455 if (!card->event_wq) 1456 goto out_wq; 1457 if (qeth_setup_channel(&card->read, true)) 1458 goto out_ip; 1459 if (qeth_setup_channel(&card->write, true)) 1460 goto out_channel; 1461 if (qeth_setup_channel(&card->data, false)) 1462 goto out_data; 1463 card->qeth_service_level.seq_print = qeth_core_sl_print; 1464 register_service_level(&card->qeth_service_level); 1465 return card; 1466 1467 out_data: 1468 qeth_clean_channel(&card->write); 1469 out_channel: 1470 qeth_clean_channel(&card->read); 1471 out_ip: 1472 destroy_workqueue(card->event_wq); 1473 out_wq: 1474 dev_set_drvdata(&gdev->dev, NULL); 1475 kfree(card); 1476 out: 1477 return NULL; 1478 } 1479 1480 static int qeth_clear_channel(struct qeth_card *card, 1481 struct qeth_channel *channel) 1482 { 1483 int rc; 1484 1485 QETH_CARD_TEXT(card, 3, "clearch"); 1486 spin_lock_irq(get_ccwdev_lock(channel->ccwdev)); 1487 rc = ccw_device_clear(channel->ccwdev, QETH_CLEAR_CHANNEL_PARM); 1488 spin_unlock_irq(get_ccwdev_lock(channel->ccwdev)); 1489 1490 if (rc) 1491 return rc; 1492 rc = wait_event_interruptible_timeout(card->wait_q, 1493 channel->state == CH_STATE_STOPPED, QETH_TIMEOUT); 1494 if (rc == -ERESTARTSYS) 1495 return rc; 1496 if (channel->state != CH_STATE_STOPPED) 1497 return -ETIME; 1498 channel->state = CH_STATE_DOWN; 1499 return 0; 1500 } 1501 1502 static int qeth_halt_channel(struct qeth_card *card, 1503 struct qeth_channel *channel) 1504 { 1505 int rc; 1506 1507 QETH_CARD_TEXT(card, 3, "haltch"); 1508 spin_lock_irq(get_ccwdev_lock(channel->ccwdev)); 1509 rc = ccw_device_halt(channel->ccwdev, QETH_HALT_CHANNEL_PARM); 1510 spin_unlock_irq(get_ccwdev_lock(channel->ccwdev)); 1511 1512 if (rc) 1513 return rc; 1514 rc = wait_event_interruptible_timeout(card->wait_q, 1515 channel->state == CH_STATE_HALTED, QETH_TIMEOUT); 1516 if (rc == -ERESTARTSYS) 1517 return rc; 1518 if (channel->state != CH_STATE_HALTED) 1519 return -ETIME; 1520 return 0; 1521 } 1522 1523 static int qeth_halt_channels(struct qeth_card *card) 1524 { 1525 int rc1 = 0, rc2 = 0, rc3 = 0; 1526 1527 QETH_CARD_TEXT(card, 3, "haltchs"); 1528 rc1 = qeth_halt_channel(card, &card->read); 1529 rc2 = qeth_halt_channel(card, &card->write); 1530 rc3 = qeth_halt_channel(card, &card->data); 1531 if (rc1) 1532 return rc1; 1533 if (rc2) 1534 return rc2; 1535 return rc3; 1536 } 1537 1538 static int qeth_clear_channels(struct qeth_card *card) 1539 { 1540 int rc1 = 0, rc2 = 0, rc3 = 0; 1541 1542 QETH_CARD_TEXT(card, 3, "clearchs"); 1543 rc1 = qeth_clear_channel(card, &card->read); 1544 rc2 = qeth_clear_channel(card, &card->write); 1545 rc3 = qeth_clear_channel(card, &card->data); 1546 if (rc1) 1547 return rc1; 1548 if (rc2) 1549 return rc2; 1550 return rc3; 1551 } 1552 1553 static int qeth_clear_halt_card(struct qeth_card *card, int halt) 1554 { 1555 int rc = 0; 1556 1557 QETH_CARD_TEXT(card, 3, "clhacrd"); 1558 1559 if (halt) 1560 rc = qeth_halt_channels(card); 1561 if (rc) 1562 return rc; 1563 return qeth_clear_channels(card); 1564 } 1565 1566 int qeth_qdio_clear_card(struct qeth_card *card, int use_halt) 1567 { 1568 int rc = 0; 1569 1570 QETH_CARD_TEXT(card, 3, "qdioclr"); 1571 switch (atomic_cmpxchg(&card->qdio.state, QETH_QDIO_ESTABLISHED, 1572 QETH_QDIO_CLEANING)) { 1573 case QETH_QDIO_ESTABLISHED: 1574 if (card->info.type == QETH_CARD_TYPE_IQD) 1575 rc = qdio_shutdown(CARD_DDEV(card), 1576 QDIO_FLAG_CLEANUP_USING_HALT); 1577 else 1578 rc = qdio_shutdown(CARD_DDEV(card), 1579 QDIO_FLAG_CLEANUP_USING_CLEAR); 1580 if (rc) 1581 QETH_CARD_TEXT_(card, 3, "1err%d", rc); 1582 atomic_set(&card->qdio.state, QETH_QDIO_ALLOCATED); 1583 break; 1584 case QETH_QDIO_CLEANING: 1585 return rc; 1586 default: 1587 break; 1588 } 1589 rc = qeth_clear_halt_card(card, use_halt); 1590 if (rc) 1591 QETH_CARD_TEXT_(card, 3, "2err%d", rc); 1592 card->state = CARD_STATE_DOWN; 1593 return rc; 1594 } 1595 EXPORT_SYMBOL_GPL(qeth_qdio_clear_card); 1596 1597 static int qeth_read_conf_data(struct qeth_card *card, void **buffer, 1598 int *length) 1599 { 1600 struct ciw *ciw; 1601 char *rcd_buf; 1602 int ret; 1603 struct qeth_channel *channel = &card->data; 1604 1605 /* 1606 * scan for RCD command in extended SenseID data 1607 */ 1608 ciw = ccw_device_get_ciw(channel->ccwdev, CIW_TYPE_RCD); 1609 if (!ciw || ciw->cmd == 0) 1610 return -EOPNOTSUPP; 1611 rcd_buf = kzalloc(ciw->count, GFP_KERNEL | GFP_DMA); 1612 if (!rcd_buf) 1613 return -ENOMEM; 1614 1615 qeth_setup_ccw(channel->ccw, ciw->cmd, ciw->count, rcd_buf); 1616 channel->state = CH_STATE_RCD; 1617 spin_lock_irq(get_ccwdev_lock(channel->ccwdev)); 1618 ret = ccw_device_start_timeout(channel->ccwdev, channel->ccw, 1619 QETH_RCD_PARM, LPM_ANYPATH, 0, 1620 QETH_RCD_TIMEOUT); 1621 spin_unlock_irq(get_ccwdev_lock(channel->ccwdev)); 1622 if (!ret) 1623 wait_event(card->wait_q, 1624 (channel->state == CH_STATE_RCD_DONE || 1625 channel->state == CH_STATE_DOWN)); 1626 if (channel->state == CH_STATE_DOWN) 1627 ret = -EIO; 1628 else 1629 channel->state = CH_STATE_DOWN; 1630 if (ret) { 1631 kfree(rcd_buf); 1632 *buffer = NULL; 1633 *length = 0; 1634 } else { 1635 *length = ciw->count; 1636 *buffer = rcd_buf; 1637 } 1638 return ret; 1639 } 1640 1641 static void qeth_configure_unitaddr(struct qeth_card *card, char *prcd) 1642 { 1643 QETH_DBF_TEXT(SETUP, 2, "cfgunit"); 1644 card->info.chpid = prcd[30]; 1645 card->info.unit_addr2 = prcd[31]; 1646 card->info.cula = prcd[63]; 1647 card->info.guestlan = ((prcd[0x10] == _ascebc['V']) && 1648 (prcd[0x11] == _ascebc['M'])); 1649 } 1650 1651 static enum qeth_discipline_id qeth_vm_detect_layer(struct qeth_card *card) 1652 { 1653 enum qeth_discipline_id disc = QETH_DISCIPLINE_UNDETERMINED; 1654 struct diag26c_vnic_resp *response = NULL; 1655 struct diag26c_vnic_req *request = NULL; 1656 struct ccw_dev_id id; 1657 char userid[80]; 1658 int rc = 0; 1659 1660 QETH_DBF_TEXT(SETUP, 2, "vmlayer"); 1661 1662 cpcmd("QUERY USERID", userid, sizeof(userid), &rc); 1663 if (rc) 1664 goto out; 1665 1666 request = kzalloc(sizeof(*request), GFP_KERNEL | GFP_DMA); 1667 response = kzalloc(sizeof(*response), GFP_KERNEL | GFP_DMA); 1668 if (!request || !response) { 1669 rc = -ENOMEM; 1670 goto out; 1671 } 1672 1673 ccw_device_get_id(CARD_RDEV(card), &id); 1674 request->resp_buf_len = sizeof(*response); 1675 request->resp_version = DIAG26C_VERSION6_VM65918; 1676 request->req_format = DIAG26C_VNIC_INFO; 1677 ASCEBC(userid, 8); 1678 memcpy(&request->sys_name, userid, 8); 1679 request->devno = id.devno; 1680 1681 QETH_DBF_HEX(CTRL, 2, request, sizeof(*request)); 1682 rc = diag26c(request, response, DIAG26C_PORT_VNIC); 1683 QETH_DBF_HEX(CTRL, 2, request, sizeof(*request)); 1684 if (rc) 1685 goto out; 1686 QETH_DBF_HEX(CTRL, 2, response, sizeof(*response)); 1687 1688 if (request->resp_buf_len < sizeof(*response) || 1689 response->version != request->resp_version) { 1690 rc = -EIO; 1691 goto out; 1692 } 1693 1694 if (response->protocol == VNIC_INFO_PROT_L2) 1695 disc = QETH_DISCIPLINE_LAYER2; 1696 else if (response->protocol == VNIC_INFO_PROT_L3) 1697 disc = QETH_DISCIPLINE_LAYER3; 1698 1699 out: 1700 kfree(response); 1701 kfree(request); 1702 if (rc) 1703 QETH_DBF_TEXT_(SETUP, 2, "err%x", rc); 1704 return disc; 1705 } 1706 1707 /* Determine whether the device requires a specific layer discipline */ 1708 static enum qeth_discipline_id qeth_enforce_discipline(struct qeth_card *card) 1709 { 1710 enum qeth_discipline_id disc = QETH_DISCIPLINE_UNDETERMINED; 1711 1712 if (card->info.type == QETH_CARD_TYPE_OSM || 1713 card->info.type == QETH_CARD_TYPE_OSN) 1714 disc = QETH_DISCIPLINE_LAYER2; 1715 else if (card->info.guestlan) 1716 disc = (card->info.type == QETH_CARD_TYPE_IQD) ? 1717 QETH_DISCIPLINE_LAYER3 : 1718 qeth_vm_detect_layer(card); 1719 1720 switch (disc) { 1721 case QETH_DISCIPLINE_LAYER2: 1722 QETH_DBF_TEXT(SETUP, 3, "force l2"); 1723 break; 1724 case QETH_DISCIPLINE_LAYER3: 1725 QETH_DBF_TEXT(SETUP, 3, "force l3"); 1726 break; 1727 default: 1728 QETH_DBF_TEXT(SETUP, 3, "force no"); 1729 } 1730 1731 return disc; 1732 } 1733 1734 static void qeth_configure_blkt_default(struct qeth_card *card, char *prcd) 1735 { 1736 QETH_DBF_TEXT(SETUP, 2, "cfgblkt"); 1737 1738 if (prcd[74] == 0xF0 && prcd[75] == 0xF0 && 1739 prcd[76] >= 0xF1 && prcd[76] <= 0xF4) { 1740 card->info.blkt.time_total = 0; 1741 card->info.blkt.inter_packet = 0; 1742 card->info.blkt.inter_packet_jumbo = 0; 1743 } else { 1744 card->info.blkt.time_total = 250; 1745 card->info.blkt.inter_packet = 5; 1746 card->info.blkt.inter_packet_jumbo = 15; 1747 } 1748 } 1749 1750 static void qeth_init_tokens(struct qeth_card *card) 1751 { 1752 card->token.issuer_rm_w = 0x00010103UL; 1753 card->token.cm_filter_w = 0x00010108UL; 1754 card->token.cm_connection_w = 0x0001010aUL; 1755 card->token.ulp_filter_w = 0x0001010bUL; 1756 card->token.ulp_connection_w = 0x0001010dUL; 1757 } 1758 1759 static void qeth_init_func_level(struct qeth_card *card) 1760 { 1761 switch (card->info.type) { 1762 case QETH_CARD_TYPE_IQD: 1763 card->info.func_level = QETH_IDX_FUNC_LEVEL_IQD; 1764 break; 1765 case QETH_CARD_TYPE_OSD: 1766 case QETH_CARD_TYPE_OSN: 1767 card->info.func_level = QETH_IDX_FUNC_LEVEL_OSD; 1768 break; 1769 default: 1770 break; 1771 } 1772 } 1773 1774 static int qeth_idx_activate_get_answer(struct qeth_card *card, 1775 struct qeth_channel *channel, 1776 void (*reply_cb)(struct qeth_card *, 1777 struct qeth_channel *, 1778 struct qeth_cmd_buffer *)) 1779 { 1780 struct qeth_cmd_buffer *iob; 1781 int rc; 1782 1783 QETH_DBF_TEXT(SETUP, 2, "idxanswr"); 1784 iob = qeth_get_buffer(channel); 1785 if (!iob) 1786 return -ENOMEM; 1787 iob->callback = reply_cb; 1788 qeth_setup_ccw(channel->ccw, CCW_CMD_READ, QETH_BUFSIZE, iob->data); 1789 1790 wait_event(card->wait_q, 1791 atomic_cmpxchg(&channel->irq_pending, 0, 1) == 0); 1792 QETH_DBF_TEXT(SETUP, 6, "noirqpnd"); 1793 spin_lock_irq(get_ccwdev_lock(channel->ccwdev)); 1794 rc = ccw_device_start_timeout(channel->ccwdev, channel->ccw, 1795 (addr_t) iob, 0, 0, QETH_TIMEOUT); 1796 spin_unlock_irq(get_ccwdev_lock(channel->ccwdev)); 1797 1798 if (rc) { 1799 QETH_DBF_MESSAGE(2, "Error2 in activating channel rc=%d\n", rc); 1800 QETH_DBF_TEXT_(SETUP, 2, "2err%d", rc); 1801 atomic_set(&channel->irq_pending, 0); 1802 qeth_release_buffer(channel, iob); 1803 wake_up(&card->wait_q); 1804 return rc; 1805 } 1806 rc = wait_event_interruptible_timeout(card->wait_q, 1807 channel->state == CH_STATE_UP, QETH_TIMEOUT); 1808 if (rc == -ERESTARTSYS) 1809 return rc; 1810 if (channel->state != CH_STATE_UP) { 1811 rc = -ETIME; 1812 QETH_DBF_TEXT_(SETUP, 2, "3err%d", rc); 1813 } else 1814 rc = 0; 1815 return rc; 1816 } 1817 1818 static int qeth_idx_activate_channel(struct qeth_card *card, 1819 struct qeth_channel *channel, 1820 void (*reply_cb)(struct qeth_card *, 1821 struct qeth_channel *, 1822 struct qeth_cmd_buffer *)) 1823 { 1824 struct qeth_cmd_buffer *iob; 1825 __u16 temp; 1826 __u8 tmp; 1827 int rc; 1828 struct ccw_dev_id temp_devid; 1829 1830 QETH_DBF_TEXT(SETUP, 2, "idxactch"); 1831 1832 iob = qeth_get_buffer(channel); 1833 if (!iob) 1834 return -ENOMEM; 1835 iob->callback = reply_cb; 1836 qeth_setup_ccw(channel->ccw, CCW_CMD_WRITE, IDX_ACTIVATE_SIZE, 1837 iob->data); 1838 if (channel == &card->write) { 1839 memcpy(iob->data, IDX_ACTIVATE_WRITE, IDX_ACTIVATE_SIZE); 1840 memcpy(QETH_TRANSPORT_HEADER_SEQ_NO(iob->data), 1841 &card->seqno.trans_hdr, QETH_SEQ_NO_LENGTH); 1842 card->seqno.trans_hdr++; 1843 } else { 1844 memcpy(iob->data, IDX_ACTIVATE_READ, IDX_ACTIVATE_SIZE); 1845 memcpy(QETH_TRANSPORT_HEADER_SEQ_NO(iob->data), 1846 &card->seqno.trans_hdr, QETH_SEQ_NO_LENGTH); 1847 } 1848 tmp = ((u8)card->dev->dev_port) | 0x80; 1849 memcpy(QETH_IDX_ACT_PNO(iob->data), &tmp, 1); 1850 memcpy(QETH_IDX_ACT_ISSUER_RM_TOKEN(iob->data), 1851 &card->token.issuer_rm_w, QETH_MPC_TOKEN_LENGTH); 1852 memcpy(QETH_IDX_ACT_FUNC_LEVEL(iob->data), 1853 &card->info.func_level, sizeof(__u16)); 1854 ccw_device_get_id(CARD_DDEV(card), &temp_devid); 1855 memcpy(QETH_IDX_ACT_QDIO_DEV_CUA(iob->data), &temp_devid.devno, 2); 1856 temp = (card->info.cula << 8) + card->info.unit_addr2; 1857 memcpy(QETH_IDX_ACT_QDIO_DEV_REALADDR(iob->data), &temp, 2); 1858 1859 wait_event(card->wait_q, 1860 atomic_cmpxchg(&channel->irq_pending, 0, 1) == 0); 1861 QETH_DBF_TEXT(SETUP, 6, "noirqpnd"); 1862 spin_lock_irq(get_ccwdev_lock(channel->ccwdev)); 1863 rc = ccw_device_start_timeout(channel->ccwdev, channel->ccw, 1864 (addr_t) iob, 0, 0, QETH_TIMEOUT); 1865 spin_unlock_irq(get_ccwdev_lock(channel->ccwdev)); 1866 1867 if (rc) { 1868 QETH_DBF_MESSAGE(2, "Error1 in activating channel. rc=%d\n", 1869 rc); 1870 QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc); 1871 atomic_set(&channel->irq_pending, 0); 1872 qeth_release_buffer(channel, iob); 1873 wake_up(&card->wait_q); 1874 return rc; 1875 } 1876 rc = wait_event_interruptible_timeout(card->wait_q, 1877 channel->state == CH_STATE_ACTIVATING, QETH_TIMEOUT); 1878 if (rc == -ERESTARTSYS) 1879 return rc; 1880 if (channel->state != CH_STATE_ACTIVATING) { 1881 dev_warn(&channel->ccwdev->dev, "The qeth device driver" 1882 " failed to recover an error on the device\n"); 1883 QETH_DBF_MESSAGE(2, "IDX activate timed out on channel %x\n", 1884 CCW_DEVID(channel->ccwdev)); 1885 QETH_DBF_TEXT_(SETUP, 2, "2err%d", -ETIME); 1886 return -ETIME; 1887 } 1888 return qeth_idx_activate_get_answer(card, channel, reply_cb); 1889 } 1890 1891 static int qeth_peer_func_level(int level) 1892 { 1893 if ((level & 0xff) == 8) 1894 return (level & 0xff) + 0x400; 1895 if (((level >> 8) & 3) == 1) 1896 return (level & 0xff) + 0x200; 1897 return level; 1898 } 1899 1900 static void qeth_idx_write_cb(struct qeth_card *card, 1901 struct qeth_channel *channel, 1902 struct qeth_cmd_buffer *iob) 1903 { 1904 __u16 temp; 1905 1906 QETH_DBF_TEXT(SETUP , 2, "idxwrcb"); 1907 1908 if (channel->state == CH_STATE_DOWN) { 1909 channel->state = CH_STATE_ACTIVATING; 1910 goto out; 1911 } 1912 1913 if (!(QETH_IS_IDX_ACT_POS_REPLY(iob->data))) { 1914 if (QETH_IDX_ACT_CAUSE_CODE(iob->data) == QETH_IDX_ACT_ERR_EXCL) 1915 dev_err(&channel->ccwdev->dev, 1916 "The adapter is used exclusively by another " 1917 "host\n"); 1918 else 1919 QETH_DBF_MESSAGE(2, "IDX_ACTIVATE on channel %x: negative reply\n", 1920 CCW_DEVID(channel->ccwdev)); 1921 goto out; 1922 } 1923 memcpy(&temp, QETH_IDX_ACT_FUNC_LEVEL(iob->data), 2); 1924 if ((temp & ~0x0100) != qeth_peer_func_level(card->info.func_level)) { 1925 QETH_DBF_MESSAGE(2, "IDX_ACTIVATE on channel %x: function level mismatch (sent: %#x, received: %#x)\n", 1926 CCW_DEVID(channel->ccwdev), 1927 card->info.func_level, temp); 1928 goto out; 1929 } 1930 channel->state = CH_STATE_UP; 1931 out: 1932 qeth_release_buffer(channel, iob); 1933 } 1934 1935 static void qeth_idx_read_cb(struct qeth_card *card, 1936 struct qeth_channel *channel, 1937 struct qeth_cmd_buffer *iob) 1938 { 1939 __u16 temp; 1940 1941 QETH_DBF_TEXT(SETUP , 2, "idxrdcb"); 1942 if (channel->state == CH_STATE_DOWN) { 1943 channel->state = CH_STATE_ACTIVATING; 1944 goto out; 1945 } 1946 1947 if (qeth_check_idx_response(card, iob->data)) 1948 goto out; 1949 1950 if (!(QETH_IS_IDX_ACT_POS_REPLY(iob->data))) { 1951 switch (QETH_IDX_ACT_CAUSE_CODE(iob->data)) { 1952 case QETH_IDX_ACT_ERR_EXCL: 1953 dev_err(&channel->ccwdev->dev, 1954 "The adapter is used exclusively by another " 1955 "host\n"); 1956 break; 1957 case QETH_IDX_ACT_ERR_AUTH: 1958 case QETH_IDX_ACT_ERR_AUTH_USER: 1959 dev_err(&channel->ccwdev->dev, 1960 "Setting the device online failed because of " 1961 "insufficient authorization\n"); 1962 break; 1963 default: 1964 QETH_DBF_MESSAGE(2, "IDX_ACTIVATE on channel %x: negative reply\n", 1965 CCW_DEVID(channel->ccwdev)); 1966 } 1967 QETH_CARD_TEXT_(card, 2, "idxread%c", 1968 QETH_IDX_ACT_CAUSE_CODE(iob->data)); 1969 goto out; 1970 } 1971 1972 memcpy(&temp, QETH_IDX_ACT_FUNC_LEVEL(iob->data), 2); 1973 if (temp != qeth_peer_func_level(card->info.func_level)) { 1974 QETH_DBF_MESSAGE(2, "IDX_ACTIVATE on channel %x: function level mismatch (sent: %#x, received: %#x)\n", 1975 CCW_DEVID(channel->ccwdev), 1976 card->info.func_level, temp); 1977 goto out; 1978 } 1979 memcpy(&card->token.issuer_rm_r, 1980 QETH_IDX_ACT_ISSUER_RM_TOKEN(iob->data), 1981 QETH_MPC_TOKEN_LENGTH); 1982 memcpy(&card->info.mcl_level[0], 1983 QETH_IDX_REPLY_LEVEL(iob->data), QETH_MCL_LENGTH); 1984 channel->state = CH_STATE_UP; 1985 out: 1986 qeth_release_buffer(channel, iob); 1987 } 1988 1989 void qeth_prepare_control_data(struct qeth_card *card, int len, 1990 struct qeth_cmd_buffer *iob) 1991 { 1992 qeth_setup_ccw(iob->channel->ccw, CCW_CMD_WRITE, len, iob->data); 1993 iob->callback = qeth_release_buffer_cb; 1994 1995 memcpy(QETH_TRANSPORT_HEADER_SEQ_NO(iob->data), 1996 &card->seqno.trans_hdr, QETH_SEQ_NO_LENGTH); 1997 card->seqno.trans_hdr++; 1998 memcpy(QETH_PDU_HEADER_SEQ_NO(iob->data), 1999 &card->seqno.pdu_hdr, QETH_SEQ_NO_LENGTH); 2000 card->seqno.pdu_hdr++; 2001 memcpy(QETH_PDU_HEADER_ACK_SEQ_NO(iob->data), 2002 &card->seqno.pdu_hdr_ack, QETH_SEQ_NO_LENGTH); 2003 QETH_DBF_HEX(CTRL, 2, iob->data, min(len, QETH_DBF_CTRL_LEN)); 2004 } 2005 EXPORT_SYMBOL_GPL(qeth_prepare_control_data); 2006 2007 /** 2008 * qeth_send_control_data() - send control command to the card 2009 * @card: qeth_card structure pointer 2010 * @len: size of the command buffer 2011 * @iob: qeth_cmd_buffer pointer 2012 * @reply_cb: callback function pointer 2013 * @cb_card: pointer to the qeth_card structure 2014 * @cb_reply: pointer to the qeth_reply structure 2015 * @cb_cmd: pointer to the original iob for non-IPA 2016 * commands, or to the qeth_ipa_cmd structure 2017 * for the IPA commands. 2018 * @reply_param: private pointer passed to the callback 2019 * 2020 * Callback function gets called one or more times, with cb_cmd 2021 * pointing to the response returned by the hardware. Callback 2022 * function must return 2023 * > 0 if more reply blocks are expected, 2024 * 0 if the last or only reply block is received, and 2025 * < 0 on error. 2026 * Callback function can get the value of the reply_param pointer from the 2027 * field 'param' of the structure qeth_reply. 2028 */ 2029 2030 static int qeth_send_control_data(struct qeth_card *card, int len, 2031 struct qeth_cmd_buffer *iob, 2032 int (*reply_cb)(struct qeth_card *cb_card, 2033 struct qeth_reply *cb_reply, 2034 unsigned long cb_cmd), 2035 void *reply_param) 2036 { 2037 struct qeth_channel *channel = iob->channel; 2038 int rc; 2039 struct qeth_reply *reply = NULL; 2040 unsigned long timeout, event_timeout; 2041 struct qeth_ipa_cmd *cmd = NULL; 2042 2043 QETH_CARD_TEXT(card, 2, "sendctl"); 2044 2045 if (card->read_or_write_problem) { 2046 qeth_release_buffer(channel, iob); 2047 return -EIO; 2048 } 2049 reply = qeth_alloc_reply(card); 2050 if (!reply) { 2051 qeth_release_buffer(channel, iob); 2052 return -ENOMEM; 2053 } 2054 reply->callback = reply_cb; 2055 reply->param = reply_param; 2056 2057 /* pairs with qeth_release_buffer(): */ 2058 qeth_get_reply(reply); 2059 iob->reply = reply; 2060 2061 while (atomic_cmpxchg(&channel->irq_pending, 0, 1)) ; 2062 2063 if (IS_IPA(iob->data)) { 2064 cmd = __ipa_cmd(iob); 2065 cmd->hdr.seqno = card->seqno.ipa++; 2066 reply->seqno = cmd->hdr.seqno; 2067 event_timeout = QETH_IPA_TIMEOUT; 2068 } else { 2069 reply->seqno = QETH_IDX_COMMAND_SEQNO; 2070 event_timeout = QETH_TIMEOUT; 2071 } 2072 qeth_prepare_control_data(card, len, iob); 2073 2074 qeth_enqueue_reply(card, reply); 2075 2076 timeout = jiffies + event_timeout; 2077 2078 QETH_CARD_TEXT(card, 6, "noirqpnd"); 2079 spin_lock_irq(get_ccwdev_lock(channel->ccwdev)); 2080 rc = ccw_device_start_timeout(channel->ccwdev, channel->ccw, 2081 (addr_t) iob, 0, 0, event_timeout); 2082 spin_unlock_irq(get_ccwdev_lock(channel->ccwdev)); 2083 if (rc) { 2084 QETH_DBF_MESSAGE(2, "qeth_send_control_data on device %x: ccw_device_start rc = %i\n", 2085 CARD_DEVID(card), rc); 2086 QETH_CARD_TEXT_(card, 2, " err%d", rc); 2087 qeth_dequeue_reply(card, reply); 2088 qeth_put_reply(reply); 2089 qeth_release_buffer(channel, iob); 2090 atomic_set(&channel->irq_pending, 0); 2091 wake_up(&card->wait_q); 2092 return rc; 2093 } 2094 2095 /* we have only one long running ipassist, since we can ensure 2096 process context of this command we can sleep */ 2097 if (cmd && cmd->hdr.command == IPA_CMD_SETIP && 2098 cmd->hdr.prot_version == QETH_PROT_IPV4) { 2099 if (!wait_event_timeout(reply->wait_q, 2100 atomic_read(&reply->received), event_timeout)) 2101 goto time_err; 2102 } else { 2103 while (!atomic_read(&reply->received)) { 2104 if (time_after(jiffies, timeout)) 2105 goto time_err; 2106 cpu_relax(); 2107 } 2108 } 2109 2110 qeth_dequeue_reply(card, reply); 2111 rc = reply->rc; 2112 qeth_put_reply(reply); 2113 return rc; 2114 2115 time_err: 2116 qeth_dequeue_reply(card, reply); 2117 qeth_put_reply(reply); 2118 return -ETIME; 2119 } 2120 2121 static int qeth_cm_enable_cb(struct qeth_card *card, struct qeth_reply *reply, 2122 unsigned long data) 2123 { 2124 struct qeth_cmd_buffer *iob; 2125 2126 QETH_DBF_TEXT(SETUP, 2, "cmenblcb"); 2127 2128 iob = (struct qeth_cmd_buffer *) data; 2129 memcpy(&card->token.cm_filter_r, 2130 QETH_CM_ENABLE_RESP_FILTER_TOKEN(iob->data), 2131 QETH_MPC_TOKEN_LENGTH); 2132 return 0; 2133 } 2134 2135 static int qeth_cm_enable(struct qeth_card *card) 2136 { 2137 int rc; 2138 struct qeth_cmd_buffer *iob; 2139 2140 QETH_DBF_TEXT(SETUP, 2, "cmenable"); 2141 2142 iob = qeth_wait_for_buffer(&card->write); 2143 memcpy(iob->data, CM_ENABLE, CM_ENABLE_SIZE); 2144 memcpy(QETH_CM_ENABLE_ISSUER_RM_TOKEN(iob->data), 2145 &card->token.issuer_rm_r, QETH_MPC_TOKEN_LENGTH); 2146 memcpy(QETH_CM_ENABLE_FILTER_TOKEN(iob->data), 2147 &card->token.cm_filter_w, QETH_MPC_TOKEN_LENGTH); 2148 2149 rc = qeth_send_control_data(card, CM_ENABLE_SIZE, iob, 2150 qeth_cm_enable_cb, NULL); 2151 return rc; 2152 } 2153 2154 static int qeth_cm_setup_cb(struct qeth_card *card, struct qeth_reply *reply, 2155 unsigned long data) 2156 { 2157 struct qeth_cmd_buffer *iob; 2158 2159 QETH_DBF_TEXT(SETUP, 2, "cmsetpcb"); 2160 2161 iob = (struct qeth_cmd_buffer *) data; 2162 memcpy(&card->token.cm_connection_r, 2163 QETH_CM_SETUP_RESP_DEST_ADDR(iob->data), 2164 QETH_MPC_TOKEN_LENGTH); 2165 return 0; 2166 } 2167 2168 static int qeth_cm_setup(struct qeth_card *card) 2169 { 2170 int rc; 2171 struct qeth_cmd_buffer *iob; 2172 2173 QETH_DBF_TEXT(SETUP, 2, "cmsetup"); 2174 2175 iob = qeth_wait_for_buffer(&card->write); 2176 memcpy(iob->data, CM_SETUP, CM_SETUP_SIZE); 2177 memcpy(QETH_CM_SETUP_DEST_ADDR(iob->data), 2178 &card->token.issuer_rm_r, QETH_MPC_TOKEN_LENGTH); 2179 memcpy(QETH_CM_SETUP_CONNECTION_TOKEN(iob->data), 2180 &card->token.cm_connection_w, QETH_MPC_TOKEN_LENGTH); 2181 memcpy(QETH_CM_SETUP_FILTER_TOKEN(iob->data), 2182 &card->token.cm_filter_r, QETH_MPC_TOKEN_LENGTH); 2183 rc = qeth_send_control_data(card, CM_SETUP_SIZE, iob, 2184 qeth_cm_setup_cb, NULL); 2185 return rc; 2186 } 2187 2188 static int qeth_update_max_mtu(struct qeth_card *card, unsigned int max_mtu) 2189 { 2190 struct net_device *dev = card->dev; 2191 unsigned int new_mtu; 2192 2193 if (!max_mtu) { 2194 /* IQD needs accurate max MTU to set up its RX buffers: */ 2195 if (IS_IQD(card)) 2196 return -EINVAL; 2197 /* tolerate quirky HW: */ 2198 max_mtu = ETH_MAX_MTU; 2199 } 2200 2201 rtnl_lock(); 2202 if (IS_IQD(card)) { 2203 /* move any device with default MTU to new max MTU: */ 2204 new_mtu = (dev->mtu == dev->max_mtu) ? max_mtu : dev->mtu; 2205 2206 /* adjust RX buffer size to new max MTU: */ 2207 card->qdio.in_buf_size = max_mtu + 2 * PAGE_SIZE; 2208 if (dev->max_mtu && dev->max_mtu != max_mtu) 2209 qeth_free_qdio_buffers(card); 2210 } else { 2211 if (dev->mtu) 2212 new_mtu = dev->mtu; 2213 /* default MTUs for first setup: */ 2214 else if (IS_LAYER2(card)) 2215 new_mtu = ETH_DATA_LEN; 2216 else 2217 new_mtu = ETH_DATA_LEN - 8; /* allow for LLC + SNAP */ 2218 } 2219 2220 dev->max_mtu = max_mtu; 2221 dev->mtu = min(new_mtu, max_mtu); 2222 rtnl_unlock(); 2223 return 0; 2224 } 2225 2226 static int qeth_get_mtu_outof_framesize(int framesize) 2227 { 2228 switch (framesize) { 2229 case 0x4000: 2230 return 8192; 2231 case 0x6000: 2232 return 16384; 2233 case 0xa000: 2234 return 32768; 2235 case 0xffff: 2236 return 57344; 2237 default: 2238 return 0; 2239 } 2240 } 2241 2242 static int qeth_ulp_enable_cb(struct qeth_card *card, struct qeth_reply *reply, 2243 unsigned long data) 2244 { 2245 __u16 mtu, framesize; 2246 __u16 len; 2247 __u8 link_type; 2248 struct qeth_cmd_buffer *iob; 2249 2250 QETH_DBF_TEXT(SETUP, 2, "ulpenacb"); 2251 2252 iob = (struct qeth_cmd_buffer *) data; 2253 memcpy(&card->token.ulp_filter_r, 2254 QETH_ULP_ENABLE_RESP_FILTER_TOKEN(iob->data), 2255 QETH_MPC_TOKEN_LENGTH); 2256 if (card->info.type == QETH_CARD_TYPE_IQD) { 2257 memcpy(&framesize, QETH_ULP_ENABLE_RESP_MAX_MTU(iob->data), 2); 2258 mtu = qeth_get_mtu_outof_framesize(framesize); 2259 } else { 2260 mtu = *(__u16 *)QETH_ULP_ENABLE_RESP_MAX_MTU(iob->data); 2261 } 2262 *(u16 *)reply->param = mtu; 2263 2264 memcpy(&len, QETH_ULP_ENABLE_RESP_DIFINFO_LEN(iob->data), 2); 2265 if (len >= QETH_MPC_DIFINFO_LEN_INDICATES_LINK_TYPE) { 2266 memcpy(&link_type, 2267 QETH_ULP_ENABLE_RESP_LINK_TYPE(iob->data), 1); 2268 card->info.link_type = link_type; 2269 } else 2270 card->info.link_type = 0; 2271 QETH_DBF_TEXT_(SETUP, 2, "link%d", card->info.link_type); 2272 return 0; 2273 } 2274 2275 static u8 qeth_mpc_select_prot_type(struct qeth_card *card) 2276 { 2277 if (IS_OSN(card)) 2278 return QETH_PROT_OSN2; 2279 return IS_LAYER2(card) ? QETH_PROT_LAYER2 : QETH_PROT_TCPIP; 2280 } 2281 2282 static int qeth_ulp_enable(struct qeth_card *card) 2283 { 2284 u8 prot_type = qeth_mpc_select_prot_type(card); 2285 struct qeth_cmd_buffer *iob; 2286 u16 max_mtu; 2287 int rc; 2288 2289 /*FIXME: trace view callbacks*/ 2290 QETH_DBF_TEXT(SETUP, 2, "ulpenabl"); 2291 2292 iob = qeth_wait_for_buffer(&card->write); 2293 memcpy(iob->data, ULP_ENABLE, ULP_ENABLE_SIZE); 2294 2295 *(QETH_ULP_ENABLE_LINKNUM(iob->data)) = (u8) card->dev->dev_port; 2296 memcpy(QETH_ULP_ENABLE_PROT_TYPE(iob->data), &prot_type, 1); 2297 memcpy(QETH_ULP_ENABLE_DEST_ADDR(iob->data), 2298 &card->token.cm_connection_r, QETH_MPC_TOKEN_LENGTH); 2299 memcpy(QETH_ULP_ENABLE_FILTER_TOKEN(iob->data), 2300 &card->token.ulp_filter_w, QETH_MPC_TOKEN_LENGTH); 2301 rc = qeth_send_control_data(card, ULP_ENABLE_SIZE, iob, 2302 qeth_ulp_enable_cb, &max_mtu); 2303 if (rc) 2304 return rc; 2305 return qeth_update_max_mtu(card, max_mtu); 2306 } 2307 2308 static int qeth_ulp_setup_cb(struct qeth_card *card, struct qeth_reply *reply, 2309 unsigned long data) 2310 { 2311 struct qeth_cmd_buffer *iob; 2312 2313 QETH_DBF_TEXT(SETUP, 2, "ulpstpcb"); 2314 2315 iob = (struct qeth_cmd_buffer *) data; 2316 memcpy(&card->token.ulp_connection_r, 2317 QETH_ULP_SETUP_RESP_CONNECTION_TOKEN(iob->data), 2318 QETH_MPC_TOKEN_LENGTH); 2319 if (!strncmp("00S", QETH_ULP_SETUP_RESP_CONNECTION_TOKEN(iob->data), 2320 3)) { 2321 QETH_DBF_TEXT(SETUP, 2, "olmlimit"); 2322 dev_err(&card->gdev->dev, "A connection could not be " 2323 "established because of an OLM limit\n"); 2324 return -EMLINK; 2325 } 2326 return 0; 2327 } 2328 2329 static int qeth_ulp_setup(struct qeth_card *card) 2330 { 2331 int rc; 2332 __u16 temp; 2333 struct qeth_cmd_buffer *iob; 2334 struct ccw_dev_id dev_id; 2335 2336 QETH_DBF_TEXT(SETUP, 2, "ulpsetup"); 2337 2338 iob = qeth_wait_for_buffer(&card->write); 2339 memcpy(iob->data, ULP_SETUP, ULP_SETUP_SIZE); 2340 2341 memcpy(QETH_ULP_SETUP_DEST_ADDR(iob->data), 2342 &card->token.cm_connection_r, QETH_MPC_TOKEN_LENGTH); 2343 memcpy(QETH_ULP_SETUP_CONNECTION_TOKEN(iob->data), 2344 &card->token.ulp_connection_w, QETH_MPC_TOKEN_LENGTH); 2345 memcpy(QETH_ULP_SETUP_FILTER_TOKEN(iob->data), 2346 &card->token.ulp_filter_r, QETH_MPC_TOKEN_LENGTH); 2347 2348 ccw_device_get_id(CARD_DDEV(card), &dev_id); 2349 memcpy(QETH_ULP_SETUP_CUA(iob->data), &dev_id.devno, 2); 2350 temp = (card->info.cula << 8) + card->info.unit_addr2; 2351 memcpy(QETH_ULP_SETUP_REAL_DEVADDR(iob->data), &temp, 2); 2352 rc = qeth_send_control_data(card, ULP_SETUP_SIZE, iob, 2353 qeth_ulp_setup_cb, NULL); 2354 return rc; 2355 } 2356 2357 static int qeth_init_qdio_out_buf(struct qeth_qdio_out_q *q, int bidx) 2358 { 2359 struct qeth_qdio_out_buffer *newbuf; 2360 2361 newbuf = kmem_cache_zalloc(qeth_qdio_outbuf_cache, GFP_ATOMIC); 2362 if (!newbuf) 2363 return -ENOMEM; 2364 2365 newbuf->buffer = q->qdio_bufs[bidx]; 2366 skb_queue_head_init(&newbuf->skb_list); 2367 lockdep_set_class(&newbuf->skb_list.lock, &qdio_out_skb_queue_key); 2368 newbuf->q = q; 2369 newbuf->next_pending = q->bufs[bidx]; 2370 atomic_set(&newbuf->state, QETH_QDIO_BUF_EMPTY); 2371 q->bufs[bidx] = newbuf; 2372 return 0; 2373 } 2374 2375 static void qeth_free_output_queue(struct qeth_qdio_out_q *q) 2376 { 2377 if (!q) 2378 return; 2379 2380 qeth_clear_outq_buffers(q, 1); 2381 qdio_free_buffers(q->qdio_bufs, QDIO_MAX_BUFFERS_PER_Q); 2382 kfree(q); 2383 } 2384 2385 static struct qeth_qdio_out_q *qeth_alloc_qdio_out_buf(void) 2386 { 2387 struct qeth_qdio_out_q *q = kzalloc(sizeof(*q), GFP_KERNEL); 2388 2389 if (!q) 2390 return NULL; 2391 2392 if (qdio_alloc_buffers(q->qdio_bufs, QDIO_MAX_BUFFERS_PER_Q)) { 2393 kfree(q); 2394 return NULL; 2395 } 2396 return q; 2397 } 2398 2399 static int qeth_alloc_qdio_buffers(struct qeth_card *card) 2400 { 2401 int i, j; 2402 2403 QETH_DBF_TEXT(SETUP, 2, "allcqdbf"); 2404 2405 if (atomic_cmpxchg(&card->qdio.state, QETH_QDIO_UNINITIALIZED, 2406 QETH_QDIO_ALLOCATED) != QETH_QDIO_UNINITIALIZED) 2407 return 0; 2408 2409 QETH_DBF_TEXT(SETUP, 2, "inq"); 2410 card->qdio.in_q = qeth_alloc_qdio_queue(); 2411 if (!card->qdio.in_q) 2412 goto out_nomem; 2413 2414 /* inbound buffer pool */ 2415 if (qeth_alloc_buffer_pool(card)) 2416 goto out_freeinq; 2417 2418 /* outbound */ 2419 for (i = 0; i < card->qdio.no_out_queues; ++i) { 2420 card->qdio.out_qs[i] = qeth_alloc_qdio_out_buf(); 2421 if (!card->qdio.out_qs[i]) 2422 goto out_freeoutq; 2423 QETH_DBF_TEXT_(SETUP, 2, "outq %i", i); 2424 QETH_DBF_HEX(SETUP, 2, &card->qdio.out_qs[i], sizeof(void *)); 2425 card->qdio.out_qs[i]->queue_no = i; 2426 /* give outbound qeth_qdio_buffers their qdio_buffers */ 2427 for (j = 0; j < QDIO_MAX_BUFFERS_PER_Q; ++j) { 2428 WARN_ON(card->qdio.out_qs[i]->bufs[j] != NULL); 2429 if (qeth_init_qdio_out_buf(card->qdio.out_qs[i], j)) 2430 goto out_freeoutqbufs; 2431 } 2432 } 2433 2434 /* completion */ 2435 if (qeth_alloc_cq(card)) 2436 goto out_freeoutq; 2437 2438 return 0; 2439 2440 out_freeoutqbufs: 2441 while (j > 0) { 2442 --j; 2443 kmem_cache_free(qeth_qdio_outbuf_cache, 2444 card->qdio.out_qs[i]->bufs[j]); 2445 card->qdio.out_qs[i]->bufs[j] = NULL; 2446 } 2447 out_freeoutq: 2448 while (i > 0) { 2449 qeth_free_output_queue(card->qdio.out_qs[--i]); 2450 card->qdio.out_qs[i] = NULL; 2451 } 2452 qeth_free_buffer_pool(card); 2453 out_freeinq: 2454 qeth_free_qdio_queue(card->qdio.in_q); 2455 card->qdio.in_q = NULL; 2456 out_nomem: 2457 atomic_set(&card->qdio.state, QETH_QDIO_UNINITIALIZED); 2458 return -ENOMEM; 2459 } 2460 2461 static void qeth_free_qdio_buffers(struct qeth_card *card) 2462 { 2463 int i, j; 2464 2465 if (atomic_xchg(&card->qdio.state, QETH_QDIO_UNINITIALIZED) == 2466 QETH_QDIO_UNINITIALIZED) 2467 return; 2468 2469 qeth_free_cq(card); 2470 cancel_delayed_work_sync(&card->buffer_reclaim_work); 2471 for (j = 0; j < QDIO_MAX_BUFFERS_PER_Q; ++j) { 2472 if (card->qdio.in_q->bufs[j].rx_skb) 2473 dev_kfree_skb_any(card->qdio.in_q->bufs[j].rx_skb); 2474 } 2475 qeth_free_qdio_queue(card->qdio.in_q); 2476 card->qdio.in_q = NULL; 2477 /* inbound buffer pool */ 2478 qeth_free_buffer_pool(card); 2479 /* free outbound qdio_qs */ 2480 for (i = 0; i < card->qdio.no_out_queues; i++) { 2481 qeth_free_output_queue(card->qdio.out_qs[i]); 2482 card->qdio.out_qs[i] = NULL; 2483 } 2484 } 2485 2486 static void qeth_create_qib_param_field(struct qeth_card *card, 2487 char *param_field) 2488 { 2489 2490 param_field[0] = _ascebc['P']; 2491 param_field[1] = _ascebc['C']; 2492 param_field[2] = _ascebc['I']; 2493 param_field[3] = _ascebc['T']; 2494 *((unsigned int *) (¶m_field[4])) = QETH_PCI_THRESHOLD_A(card); 2495 *((unsigned int *) (¶m_field[8])) = QETH_PCI_THRESHOLD_B(card); 2496 *((unsigned int *) (¶m_field[12])) = QETH_PCI_TIMER_VALUE(card); 2497 } 2498 2499 static void qeth_create_qib_param_field_blkt(struct qeth_card *card, 2500 char *param_field) 2501 { 2502 param_field[16] = _ascebc['B']; 2503 param_field[17] = _ascebc['L']; 2504 param_field[18] = _ascebc['K']; 2505 param_field[19] = _ascebc['T']; 2506 *((unsigned int *) (¶m_field[20])) = card->info.blkt.time_total; 2507 *((unsigned int *) (¶m_field[24])) = card->info.blkt.inter_packet; 2508 *((unsigned int *) (¶m_field[28])) = 2509 card->info.blkt.inter_packet_jumbo; 2510 } 2511 2512 static int qeth_qdio_activate(struct qeth_card *card) 2513 { 2514 QETH_DBF_TEXT(SETUP, 3, "qdioact"); 2515 return qdio_activate(CARD_DDEV(card)); 2516 } 2517 2518 static int qeth_dm_act(struct qeth_card *card) 2519 { 2520 int rc; 2521 struct qeth_cmd_buffer *iob; 2522 2523 QETH_DBF_TEXT(SETUP, 2, "dmact"); 2524 2525 iob = qeth_wait_for_buffer(&card->write); 2526 memcpy(iob->data, DM_ACT, DM_ACT_SIZE); 2527 2528 memcpy(QETH_DM_ACT_DEST_ADDR(iob->data), 2529 &card->token.cm_connection_r, QETH_MPC_TOKEN_LENGTH); 2530 memcpy(QETH_DM_ACT_CONNECTION_TOKEN(iob->data), 2531 &card->token.ulp_connection_r, QETH_MPC_TOKEN_LENGTH); 2532 rc = qeth_send_control_data(card, DM_ACT_SIZE, iob, NULL, NULL); 2533 return rc; 2534 } 2535 2536 static int qeth_mpc_initialize(struct qeth_card *card) 2537 { 2538 int rc; 2539 2540 QETH_DBF_TEXT(SETUP, 2, "mpcinit"); 2541 2542 rc = qeth_issue_next_read(card); 2543 if (rc) { 2544 QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc); 2545 return rc; 2546 } 2547 rc = qeth_cm_enable(card); 2548 if (rc) { 2549 QETH_DBF_TEXT_(SETUP, 2, "2err%d", rc); 2550 goto out_qdio; 2551 } 2552 rc = qeth_cm_setup(card); 2553 if (rc) { 2554 QETH_DBF_TEXT_(SETUP, 2, "3err%d", rc); 2555 goto out_qdio; 2556 } 2557 rc = qeth_ulp_enable(card); 2558 if (rc) { 2559 QETH_DBF_TEXT_(SETUP, 2, "4err%d", rc); 2560 goto out_qdio; 2561 } 2562 rc = qeth_ulp_setup(card); 2563 if (rc) { 2564 QETH_DBF_TEXT_(SETUP, 2, "5err%d", rc); 2565 goto out_qdio; 2566 } 2567 rc = qeth_alloc_qdio_buffers(card); 2568 if (rc) { 2569 QETH_DBF_TEXT_(SETUP, 2, "5err%d", rc); 2570 goto out_qdio; 2571 } 2572 rc = qeth_qdio_establish(card); 2573 if (rc) { 2574 QETH_DBF_TEXT_(SETUP, 2, "6err%d", rc); 2575 qeth_free_qdio_buffers(card); 2576 goto out_qdio; 2577 } 2578 rc = qeth_qdio_activate(card); 2579 if (rc) { 2580 QETH_DBF_TEXT_(SETUP, 2, "7err%d", rc); 2581 goto out_qdio; 2582 } 2583 rc = qeth_dm_act(card); 2584 if (rc) { 2585 QETH_DBF_TEXT_(SETUP, 2, "8err%d", rc); 2586 goto out_qdio; 2587 } 2588 2589 return 0; 2590 out_qdio: 2591 qeth_qdio_clear_card(card, card->info.type != QETH_CARD_TYPE_IQD); 2592 qdio_free(CARD_DDEV(card)); 2593 return rc; 2594 } 2595 2596 void qeth_print_status_message(struct qeth_card *card) 2597 { 2598 switch (card->info.type) { 2599 case QETH_CARD_TYPE_OSD: 2600 case QETH_CARD_TYPE_OSM: 2601 case QETH_CARD_TYPE_OSX: 2602 /* VM will use a non-zero first character 2603 * to indicate a HiperSockets like reporting 2604 * of the level OSA sets the first character to zero 2605 * */ 2606 if (!card->info.mcl_level[0]) { 2607 sprintf(card->info.mcl_level, "%02x%02x", 2608 card->info.mcl_level[2], 2609 card->info.mcl_level[3]); 2610 break; 2611 } 2612 /* fallthrough */ 2613 case QETH_CARD_TYPE_IQD: 2614 if ((card->info.guestlan) || 2615 (card->info.mcl_level[0] & 0x80)) { 2616 card->info.mcl_level[0] = (char) _ebcasc[(__u8) 2617 card->info.mcl_level[0]]; 2618 card->info.mcl_level[1] = (char) _ebcasc[(__u8) 2619 card->info.mcl_level[1]]; 2620 card->info.mcl_level[2] = (char) _ebcasc[(__u8) 2621 card->info.mcl_level[2]]; 2622 card->info.mcl_level[3] = (char) _ebcasc[(__u8) 2623 card->info.mcl_level[3]]; 2624 card->info.mcl_level[QETH_MCL_LENGTH] = 0; 2625 } 2626 break; 2627 default: 2628 memset(&card->info.mcl_level[0], 0, QETH_MCL_LENGTH + 1); 2629 } 2630 dev_info(&card->gdev->dev, 2631 "Device is a%s card%s%s%s\nwith link type %s.\n", 2632 qeth_get_cardname(card), 2633 (card->info.mcl_level[0]) ? " (level: " : "", 2634 (card->info.mcl_level[0]) ? card->info.mcl_level : "", 2635 (card->info.mcl_level[0]) ? ")" : "", 2636 qeth_get_cardname_short(card)); 2637 } 2638 EXPORT_SYMBOL_GPL(qeth_print_status_message); 2639 2640 static void qeth_initialize_working_pool_list(struct qeth_card *card) 2641 { 2642 struct qeth_buffer_pool_entry *entry; 2643 2644 QETH_CARD_TEXT(card, 5, "inwrklst"); 2645 2646 list_for_each_entry(entry, 2647 &card->qdio.init_pool.entry_list, init_list) { 2648 qeth_put_buffer_pool_entry(card, entry); 2649 } 2650 } 2651 2652 static struct qeth_buffer_pool_entry *qeth_find_free_buffer_pool_entry( 2653 struct qeth_card *card) 2654 { 2655 struct list_head *plh; 2656 struct qeth_buffer_pool_entry *entry; 2657 int i, free; 2658 struct page *page; 2659 2660 if (list_empty(&card->qdio.in_buf_pool.entry_list)) 2661 return NULL; 2662 2663 list_for_each(plh, &card->qdio.in_buf_pool.entry_list) { 2664 entry = list_entry(plh, struct qeth_buffer_pool_entry, list); 2665 free = 1; 2666 for (i = 0; i < QETH_MAX_BUFFER_ELEMENTS(card); ++i) { 2667 if (page_count(virt_to_page(entry->elements[i])) > 1) { 2668 free = 0; 2669 break; 2670 } 2671 } 2672 if (free) { 2673 list_del_init(&entry->list); 2674 return entry; 2675 } 2676 } 2677 2678 /* no free buffer in pool so take first one and swap pages */ 2679 entry = list_entry(card->qdio.in_buf_pool.entry_list.next, 2680 struct qeth_buffer_pool_entry, list); 2681 for (i = 0; i < QETH_MAX_BUFFER_ELEMENTS(card); ++i) { 2682 if (page_count(virt_to_page(entry->elements[i])) > 1) { 2683 page = alloc_page(GFP_ATOMIC); 2684 if (!page) { 2685 return NULL; 2686 } else { 2687 free_page((unsigned long)entry->elements[i]); 2688 entry->elements[i] = page_address(page); 2689 QETH_CARD_STAT_INC(card, rx_sg_alloc_page); 2690 } 2691 } 2692 } 2693 list_del_init(&entry->list); 2694 return entry; 2695 } 2696 2697 static int qeth_init_input_buffer(struct qeth_card *card, 2698 struct qeth_qdio_buffer *buf) 2699 { 2700 struct qeth_buffer_pool_entry *pool_entry; 2701 int i; 2702 2703 if ((card->options.cq == QETH_CQ_ENABLED) && (!buf->rx_skb)) { 2704 buf->rx_skb = netdev_alloc_skb(card->dev, 2705 QETH_RX_PULL_LEN + ETH_HLEN); 2706 if (!buf->rx_skb) 2707 return 1; 2708 } 2709 2710 pool_entry = qeth_find_free_buffer_pool_entry(card); 2711 if (!pool_entry) 2712 return 1; 2713 2714 /* 2715 * since the buffer is accessed only from the input_tasklet 2716 * there shouldn't be a need to synchronize; also, since we use 2717 * the QETH_IN_BUF_REQUEUE_THRESHOLD we should never run out off 2718 * buffers 2719 */ 2720 2721 buf->pool_entry = pool_entry; 2722 for (i = 0; i < QETH_MAX_BUFFER_ELEMENTS(card); ++i) { 2723 buf->buffer->element[i].length = PAGE_SIZE; 2724 buf->buffer->element[i].addr = pool_entry->elements[i]; 2725 if (i == QETH_MAX_BUFFER_ELEMENTS(card) - 1) 2726 buf->buffer->element[i].eflags = SBAL_EFLAGS_LAST_ENTRY; 2727 else 2728 buf->buffer->element[i].eflags = 0; 2729 buf->buffer->element[i].sflags = 0; 2730 } 2731 return 0; 2732 } 2733 2734 int qeth_init_qdio_queues(struct qeth_card *card) 2735 { 2736 int i, j; 2737 int rc; 2738 2739 QETH_DBF_TEXT(SETUP, 2, "initqdqs"); 2740 2741 /* inbound queue */ 2742 qdio_reset_buffers(card->qdio.in_q->qdio_bufs, QDIO_MAX_BUFFERS_PER_Q); 2743 memset(&card->rx, 0, sizeof(struct qeth_rx)); 2744 qeth_initialize_working_pool_list(card); 2745 /*give only as many buffers to hardware as we have buffer pool entries*/ 2746 for (i = 0; i < card->qdio.in_buf_pool.buf_count - 1; ++i) 2747 qeth_init_input_buffer(card, &card->qdio.in_q->bufs[i]); 2748 card->qdio.in_q->next_buf_to_init = 2749 card->qdio.in_buf_pool.buf_count - 1; 2750 rc = do_QDIO(CARD_DDEV(card), QDIO_FLAG_SYNC_INPUT, 0, 0, 2751 card->qdio.in_buf_pool.buf_count - 1); 2752 if (rc) { 2753 QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc); 2754 return rc; 2755 } 2756 2757 /* completion */ 2758 rc = qeth_cq_init(card); 2759 if (rc) { 2760 return rc; 2761 } 2762 2763 /* outbound queue */ 2764 for (i = 0; i < card->qdio.no_out_queues; ++i) { 2765 qdio_reset_buffers(card->qdio.out_qs[i]->qdio_bufs, 2766 QDIO_MAX_BUFFERS_PER_Q); 2767 for (j = 0; j < QDIO_MAX_BUFFERS_PER_Q; ++j) { 2768 qeth_clear_output_buffer(card->qdio.out_qs[i], 2769 card->qdio.out_qs[i]->bufs[j]); 2770 } 2771 card->qdio.out_qs[i]->card = card; 2772 card->qdio.out_qs[i]->next_buf_to_fill = 0; 2773 card->qdio.out_qs[i]->do_pack = 0; 2774 atomic_set(&card->qdio.out_qs[i]->used_buffers, 0); 2775 atomic_set(&card->qdio.out_qs[i]->set_pci_flags_count, 0); 2776 atomic_set(&card->qdio.out_qs[i]->state, 2777 QETH_OUT_Q_UNLOCKED); 2778 } 2779 return 0; 2780 } 2781 EXPORT_SYMBOL_GPL(qeth_init_qdio_queues); 2782 2783 static __u8 qeth_get_ipa_adp_type(enum qeth_link_types link_type) 2784 { 2785 switch (link_type) { 2786 case QETH_LINK_TYPE_HSTR: 2787 return 2; 2788 default: 2789 return 1; 2790 } 2791 } 2792 2793 static void qeth_fill_ipacmd_header(struct qeth_card *card, 2794 struct qeth_ipa_cmd *cmd, 2795 enum qeth_ipa_cmds command, 2796 enum qeth_prot_versions prot) 2797 { 2798 cmd->hdr.command = command; 2799 cmd->hdr.initiator = IPA_CMD_INITIATOR_HOST; 2800 /* cmd->hdr.seqno is set by qeth_send_control_data() */ 2801 cmd->hdr.adapter_type = qeth_get_ipa_adp_type(card->info.link_type); 2802 cmd->hdr.rel_adapter_no = (u8) card->dev->dev_port; 2803 cmd->hdr.prim_version_no = IS_LAYER2(card) ? 2 : 1; 2804 cmd->hdr.param_count = 1; 2805 cmd->hdr.prot_version = prot; 2806 } 2807 2808 void qeth_prepare_ipa_cmd(struct qeth_card *card, struct qeth_cmd_buffer *iob, 2809 u16 cmd_length) 2810 { 2811 u16 total_length = IPA_PDU_HEADER_SIZE + cmd_length; 2812 u8 prot_type = qeth_mpc_select_prot_type(card); 2813 2814 memcpy(iob->data, IPA_PDU_HEADER, IPA_PDU_HEADER_SIZE); 2815 memcpy(QETH_IPA_PDU_LEN_TOTAL(iob->data), &total_length, 2); 2816 memcpy(QETH_IPA_CMD_PROT_TYPE(iob->data), &prot_type, 1); 2817 memcpy(QETH_IPA_PDU_LEN_PDU1(iob->data), &cmd_length, 2); 2818 memcpy(QETH_IPA_PDU_LEN_PDU2(iob->data), &cmd_length, 2); 2819 memcpy(QETH_IPA_CMD_DEST_ADDR(iob->data), 2820 &card->token.ulp_connection_r, QETH_MPC_TOKEN_LENGTH); 2821 memcpy(QETH_IPA_PDU_LEN_PDU3(iob->data), &cmd_length, 2); 2822 } 2823 EXPORT_SYMBOL_GPL(qeth_prepare_ipa_cmd); 2824 2825 struct qeth_cmd_buffer *qeth_get_ipacmd_buffer(struct qeth_card *card, 2826 enum qeth_ipa_cmds ipacmd, enum qeth_prot_versions prot) 2827 { 2828 struct qeth_cmd_buffer *iob; 2829 2830 iob = qeth_get_buffer(&card->write); 2831 if (iob) { 2832 qeth_prepare_ipa_cmd(card, iob, sizeof(struct qeth_ipa_cmd)); 2833 qeth_fill_ipacmd_header(card, __ipa_cmd(iob), ipacmd, prot); 2834 } else { 2835 dev_warn(&card->gdev->dev, 2836 "The qeth driver ran out of channel command buffers\n"); 2837 QETH_DBF_MESSAGE(1, "device %x ran out of channel command buffers", 2838 CARD_DEVID(card)); 2839 } 2840 2841 return iob; 2842 } 2843 EXPORT_SYMBOL_GPL(qeth_get_ipacmd_buffer); 2844 2845 static int qeth_send_ipa_cmd_cb(struct qeth_card *card, 2846 struct qeth_reply *reply, unsigned long data) 2847 { 2848 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data; 2849 2850 return (cmd->hdr.return_code) ? -EIO : 0; 2851 } 2852 2853 /** 2854 * qeth_send_ipa_cmd() - send an IPA command 2855 * 2856 * See qeth_send_control_data() for explanation of the arguments. 2857 */ 2858 2859 int qeth_send_ipa_cmd(struct qeth_card *card, struct qeth_cmd_buffer *iob, 2860 int (*reply_cb)(struct qeth_card *, struct qeth_reply*, 2861 unsigned long), 2862 void *reply_param) 2863 { 2864 u16 length; 2865 int rc; 2866 2867 QETH_CARD_TEXT(card, 4, "sendipa"); 2868 2869 if (reply_cb == NULL) 2870 reply_cb = qeth_send_ipa_cmd_cb; 2871 memcpy(&length, QETH_IPA_PDU_LEN_TOTAL(iob->data), 2); 2872 rc = qeth_send_control_data(card, length, iob, reply_cb, reply_param); 2873 if (rc == -ETIME) { 2874 qeth_clear_ipacmd_list(card); 2875 qeth_schedule_recovery(card); 2876 } 2877 return rc; 2878 } 2879 EXPORT_SYMBOL_GPL(qeth_send_ipa_cmd); 2880 2881 static int qeth_send_startlan_cb(struct qeth_card *card, 2882 struct qeth_reply *reply, unsigned long data) 2883 { 2884 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data; 2885 2886 if (cmd->hdr.return_code == IPA_RC_LAN_OFFLINE) 2887 return -ENETDOWN; 2888 2889 return (cmd->hdr.return_code) ? -EIO : 0; 2890 } 2891 2892 static int qeth_send_startlan(struct qeth_card *card) 2893 { 2894 struct qeth_cmd_buffer *iob; 2895 2896 QETH_DBF_TEXT(SETUP, 2, "strtlan"); 2897 2898 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_STARTLAN, 0); 2899 if (!iob) 2900 return -ENOMEM; 2901 return qeth_send_ipa_cmd(card, iob, qeth_send_startlan_cb, NULL); 2902 } 2903 2904 static int qeth_setadpparms_inspect_rc(struct qeth_ipa_cmd *cmd) 2905 { 2906 if (!cmd->hdr.return_code) 2907 cmd->hdr.return_code = 2908 cmd->data.setadapterparms.hdr.return_code; 2909 return cmd->hdr.return_code; 2910 } 2911 2912 static int qeth_query_setadapterparms_cb(struct qeth_card *card, 2913 struct qeth_reply *reply, unsigned long data) 2914 { 2915 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data; 2916 2917 QETH_CARD_TEXT(card, 3, "quyadpcb"); 2918 if (qeth_setadpparms_inspect_rc(cmd)) 2919 return -EIO; 2920 2921 if (cmd->data.setadapterparms.data.query_cmds_supp.lan_type & 0x7f) { 2922 card->info.link_type = 2923 cmd->data.setadapterparms.data.query_cmds_supp.lan_type; 2924 QETH_DBF_TEXT_(SETUP, 2, "lnk %d", card->info.link_type); 2925 } 2926 card->options.adp.supported_funcs = 2927 cmd->data.setadapterparms.data.query_cmds_supp.supported_cmds; 2928 return 0; 2929 } 2930 2931 static struct qeth_cmd_buffer *qeth_get_adapter_cmd(struct qeth_card *card, 2932 __u32 command, __u32 cmdlen) 2933 { 2934 struct qeth_cmd_buffer *iob; 2935 struct qeth_ipa_cmd *cmd; 2936 2937 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_SETADAPTERPARMS, 2938 QETH_PROT_IPV4); 2939 if (iob) { 2940 cmd = __ipa_cmd(iob); 2941 cmd->data.setadapterparms.hdr.cmdlength = cmdlen; 2942 cmd->data.setadapterparms.hdr.command_code = command; 2943 cmd->data.setadapterparms.hdr.used_total = 1; 2944 cmd->data.setadapterparms.hdr.seq_no = 1; 2945 } 2946 2947 return iob; 2948 } 2949 2950 static int qeth_query_setadapterparms(struct qeth_card *card) 2951 { 2952 int rc; 2953 struct qeth_cmd_buffer *iob; 2954 2955 QETH_CARD_TEXT(card, 3, "queryadp"); 2956 iob = qeth_get_adapter_cmd(card, IPA_SETADP_QUERY_COMMANDS_SUPPORTED, 2957 sizeof(struct qeth_ipacmd_setadpparms)); 2958 if (!iob) 2959 return -ENOMEM; 2960 rc = qeth_send_ipa_cmd(card, iob, qeth_query_setadapterparms_cb, NULL); 2961 return rc; 2962 } 2963 2964 static int qeth_query_ipassists_cb(struct qeth_card *card, 2965 struct qeth_reply *reply, unsigned long data) 2966 { 2967 struct qeth_ipa_cmd *cmd; 2968 2969 QETH_DBF_TEXT(SETUP, 2, "qipasscb"); 2970 2971 cmd = (struct qeth_ipa_cmd *) data; 2972 2973 switch (cmd->hdr.return_code) { 2974 case IPA_RC_SUCCESS: 2975 break; 2976 case IPA_RC_NOTSUPP: 2977 case IPA_RC_L2_UNSUPPORTED_CMD: 2978 QETH_DBF_TEXT(SETUP, 2, "ipaunsup"); 2979 card->options.ipa4.supported_funcs |= IPA_SETADAPTERPARMS; 2980 card->options.ipa6.supported_funcs |= IPA_SETADAPTERPARMS; 2981 return -EOPNOTSUPP; 2982 default: 2983 QETH_DBF_MESSAGE(1, "IPA_CMD_QIPASSIST on device %x: Unhandled rc=%#x\n", 2984 CARD_DEVID(card), cmd->hdr.return_code); 2985 return -EIO; 2986 } 2987 2988 if (cmd->hdr.prot_version == QETH_PROT_IPV4) { 2989 card->options.ipa4.supported_funcs = cmd->hdr.ipa_supported; 2990 card->options.ipa4.enabled_funcs = cmd->hdr.ipa_enabled; 2991 } else if (cmd->hdr.prot_version == QETH_PROT_IPV6) { 2992 card->options.ipa6.supported_funcs = cmd->hdr.ipa_supported; 2993 card->options.ipa6.enabled_funcs = cmd->hdr.ipa_enabled; 2994 } else 2995 QETH_DBF_MESSAGE(1, "IPA_CMD_QIPASSIST on device %x: Flawed LIC detected\n", 2996 CARD_DEVID(card)); 2997 return 0; 2998 } 2999 3000 static int qeth_query_ipassists(struct qeth_card *card, 3001 enum qeth_prot_versions prot) 3002 { 3003 int rc; 3004 struct qeth_cmd_buffer *iob; 3005 3006 QETH_DBF_TEXT_(SETUP, 2, "qipassi%i", prot); 3007 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_QIPASSIST, prot); 3008 if (!iob) 3009 return -ENOMEM; 3010 rc = qeth_send_ipa_cmd(card, iob, qeth_query_ipassists_cb, NULL); 3011 return rc; 3012 } 3013 3014 static int qeth_query_switch_attributes_cb(struct qeth_card *card, 3015 struct qeth_reply *reply, unsigned long data) 3016 { 3017 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data; 3018 struct qeth_query_switch_attributes *attrs; 3019 struct qeth_switch_info *sw_info; 3020 3021 QETH_CARD_TEXT(card, 2, "qswiatcb"); 3022 if (qeth_setadpparms_inspect_rc(cmd)) 3023 return -EIO; 3024 3025 sw_info = (struct qeth_switch_info *)reply->param; 3026 attrs = &cmd->data.setadapterparms.data.query_switch_attributes; 3027 sw_info->capabilities = attrs->capabilities; 3028 sw_info->settings = attrs->settings; 3029 QETH_CARD_TEXT_(card, 2, "%04x%04x", sw_info->capabilities, 3030 sw_info->settings); 3031 return 0; 3032 } 3033 3034 int qeth_query_switch_attributes(struct qeth_card *card, 3035 struct qeth_switch_info *sw_info) 3036 { 3037 struct qeth_cmd_buffer *iob; 3038 3039 QETH_CARD_TEXT(card, 2, "qswiattr"); 3040 if (!qeth_adp_supported(card, IPA_SETADP_QUERY_SWITCH_ATTRIBUTES)) 3041 return -EOPNOTSUPP; 3042 if (!netif_carrier_ok(card->dev)) 3043 return -ENOMEDIUM; 3044 iob = qeth_get_adapter_cmd(card, IPA_SETADP_QUERY_SWITCH_ATTRIBUTES, 3045 sizeof(struct qeth_ipacmd_setadpparms_hdr)); 3046 if (!iob) 3047 return -ENOMEM; 3048 return qeth_send_ipa_cmd(card, iob, 3049 qeth_query_switch_attributes_cb, sw_info); 3050 } 3051 3052 static int qeth_query_setdiagass_cb(struct qeth_card *card, 3053 struct qeth_reply *reply, unsigned long data) 3054 { 3055 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data; 3056 u16 rc = cmd->hdr.return_code; 3057 3058 if (rc) { 3059 QETH_CARD_TEXT_(card, 2, "diagq:%x", rc); 3060 return -EIO; 3061 } 3062 3063 card->info.diagass_support = cmd->data.diagass.ext; 3064 return 0; 3065 } 3066 3067 static int qeth_query_setdiagass(struct qeth_card *card) 3068 { 3069 struct qeth_cmd_buffer *iob; 3070 struct qeth_ipa_cmd *cmd; 3071 3072 QETH_DBF_TEXT(SETUP, 2, "qdiagass"); 3073 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_SET_DIAG_ASS, 0); 3074 if (!iob) 3075 return -ENOMEM; 3076 cmd = __ipa_cmd(iob); 3077 cmd->data.diagass.subcmd_len = 16; 3078 cmd->data.diagass.subcmd = QETH_DIAGS_CMD_QUERY; 3079 return qeth_send_ipa_cmd(card, iob, qeth_query_setdiagass_cb, NULL); 3080 } 3081 3082 static void qeth_get_trap_id(struct qeth_card *card, struct qeth_trap_id *tid) 3083 { 3084 unsigned long info = get_zeroed_page(GFP_KERNEL); 3085 struct sysinfo_2_2_2 *info222 = (struct sysinfo_2_2_2 *)info; 3086 struct sysinfo_3_2_2 *info322 = (struct sysinfo_3_2_2 *)info; 3087 struct ccw_dev_id ccwid; 3088 int level; 3089 3090 tid->chpid = card->info.chpid; 3091 ccw_device_get_id(CARD_RDEV(card), &ccwid); 3092 tid->ssid = ccwid.ssid; 3093 tid->devno = ccwid.devno; 3094 if (!info) 3095 return; 3096 level = stsi(NULL, 0, 0, 0); 3097 if ((level >= 2) && (stsi(info222, 2, 2, 2) == 0)) 3098 tid->lparnr = info222->lpar_number; 3099 if ((level >= 3) && (stsi(info322, 3, 2, 2) == 0)) { 3100 EBCASC(info322->vm[0].name, sizeof(info322->vm[0].name)); 3101 memcpy(tid->vmname, info322->vm[0].name, sizeof(tid->vmname)); 3102 } 3103 free_page(info); 3104 return; 3105 } 3106 3107 static int qeth_hw_trap_cb(struct qeth_card *card, 3108 struct qeth_reply *reply, unsigned long data) 3109 { 3110 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data; 3111 u16 rc = cmd->hdr.return_code; 3112 3113 if (rc) { 3114 QETH_CARD_TEXT_(card, 2, "trapc:%x", rc); 3115 return -EIO; 3116 } 3117 return 0; 3118 } 3119 3120 int qeth_hw_trap(struct qeth_card *card, enum qeth_diags_trap_action action) 3121 { 3122 struct qeth_cmd_buffer *iob; 3123 struct qeth_ipa_cmd *cmd; 3124 3125 QETH_DBF_TEXT(SETUP, 2, "diagtrap"); 3126 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_SET_DIAG_ASS, 0); 3127 if (!iob) 3128 return -ENOMEM; 3129 cmd = __ipa_cmd(iob); 3130 cmd->data.diagass.subcmd_len = 80; 3131 cmd->data.diagass.subcmd = QETH_DIAGS_CMD_TRAP; 3132 cmd->data.diagass.type = 1; 3133 cmd->data.diagass.action = action; 3134 switch (action) { 3135 case QETH_DIAGS_TRAP_ARM: 3136 cmd->data.diagass.options = 0x0003; 3137 cmd->data.diagass.ext = 0x00010000 + 3138 sizeof(struct qeth_trap_id); 3139 qeth_get_trap_id(card, 3140 (struct qeth_trap_id *)cmd->data.diagass.cdata); 3141 break; 3142 case QETH_DIAGS_TRAP_DISARM: 3143 cmd->data.diagass.options = 0x0001; 3144 break; 3145 case QETH_DIAGS_TRAP_CAPTURE: 3146 break; 3147 } 3148 return qeth_send_ipa_cmd(card, iob, qeth_hw_trap_cb, NULL); 3149 } 3150 EXPORT_SYMBOL_GPL(qeth_hw_trap); 3151 3152 static int qeth_check_qdio_errors(struct qeth_card *card, 3153 struct qdio_buffer *buf, 3154 unsigned int qdio_error, 3155 const char *dbftext) 3156 { 3157 if (qdio_error) { 3158 QETH_CARD_TEXT(card, 2, dbftext); 3159 QETH_CARD_TEXT_(card, 2, " F15=%02X", 3160 buf->element[15].sflags); 3161 QETH_CARD_TEXT_(card, 2, " F14=%02X", 3162 buf->element[14].sflags); 3163 QETH_CARD_TEXT_(card, 2, " qerr=%X", qdio_error); 3164 if ((buf->element[15].sflags) == 0x12) { 3165 QETH_CARD_STAT_INC(card, rx_dropped); 3166 return 0; 3167 } else 3168 return 1; 3169 } 3170 return 0; 3171 } 3172 3173 static void qeth_queue_input_buffer(struct qeth_card *card, int index) 3174 { 3175 struct qeth_qdio_q *queue = card->qdio.in_q; 3176 struct list_head *lh; 3177 int count; 3178 int i; 3179 int rc; 3180 int newcount = 0; 3181 3182 count = (index < queue->next_buf_to_init)? 3183 card->qdio.in_buf_pool.buf_count - 3184 (queue->next_buf_to_init - index) : 3185 card->qdio.in_buf_pool.buf_count - 3186 (queue->next_buf_to_init + QDIO_MAX_BUFFERS_PER_Q - index); 3187 /* only requeue at a certain threshold to avoid SIGAs */ 3188 if (count >= QETH_IN_BUF_REQUEUE_THRESHOLD(card)) { 3189 for (i = queue->next_buf_to_init; 3190 i < queue->next_buf_to_init + count; ++i) { 3191 if (qeth_init_input_buffer(card, 3192 &queue->bufs[i % QDIO_MAX_BUFFERS_PER_Q])) { 3193 break; 3194 } else { 3195 newcount++; 3196 } 3197 } 3198 3199 if (newcount < count) { 3200 /* we are in memory shortage so we switch back to 3201 traditional skb allocation and drop packages */ 3202 atomic_set(&card->force_alloc_skb, 3); 3203 count = newcount; 3204 } else { 3205 atomic_add_unless(&card->force_alloc_skb, -1, 0); 3206 } 3207 3208 if (!count) { 3209 i = 0; 3210 list_for_each(lh, &card->qdio.in_buf_pool.entry_list) 3211 i++; 3212 if (i == card->qdio.in_buf_pool.buf_count) { 3213 QETH_CARD_TEXT(card, 2, "qsarbw"); 3214 card->reclaim_index = index; 3215 schedule_delayed_work( 3216 &card->buffer_reclaim_work, 3217 QETH_RECLAIM_WORK_TIME); 3218 } 3219 return; 3220 } 3221 3222 /* 3223 * according to old code it should be avoided to requeue all 3224 * 128 buffers in order to benefit from PCI avoidance. 3225 * this function keeps at least one buffer (the buffer at 3226 * 'index') un-requeued -> this buffer is the first buffer that 3227 * will be requeued the next time 3228 */ 3229 rc = do_QDIO(CARD_DDEV(card), QDIO_FLAG_SYNC_INPUT, 0, 3230 queue->next_buf_to_init, count); 3231 if (rc) { 3232 QETH_CARD_TEXT(card, 2, "qinberr"); 3233 } 3234 queue->next_buf_to_init = (queue->next_buf_to_init + count) % 3235 QDIO_MAX_BUFFERS_PER_Q; 3236 } 3237 } 3238 3239 static void qeth_buffer_reclaim_work(struct work_struct *work) 3240 { 3241 struct qeth_card *card = container_of(work, struct qeth_card, 3242 buffer_reclaim_work.work); 3243 3244 QETH_CARD_TEXT_(card, 2, "brw:%x", card->reclaim_index); 3245 qeth_queue_input_buffer(card, card->reclaim_index); 3246 } 3247 3248 static void qeth_handle_send_error(struct qeth_card *card, 3249 struct qeth_qdio_out_buffer *buffer, unsigned int qdio_err) 3250 { 3251 int sbalf15 = buffer->buffer->element[15].sflags; 3252 3253 QETH_CARD_TEXT(card, 6, "hdsnderr"); 3254 if (card->info.type == QETH_CARD_TYPE_IQD) { 3255 if (sbalf15 == 0) { 3256 qdio_err = 0; 3257 } else { 3258 qdio_err = 1; 3259 } 3260 } 3261 qeth_check_qdio_errors(card, buffer->buffer, qdio_err, "qouterr"); 3262 3263 if (!qdio_err) 3264 return; 3265 3266 if ((sbalf15 >= 15) && (sbalf15 <= 31)) 3267 return; 3268 3269 QETH_CARD_TEXT(card, 1, "lnkfail"); 3270 QETH_CARD_TEXT_(card, 1, "%04x %02x", 3271 (u16)qdio_err, (u8)sbalf15); 3272 } 3273 3274 /** 3275 * qeth_prep_flush_pack_buffer - Prepares flushing of a packing buffer. 3276 * @queue: queue to check for packing buffer 3277 * 3278 * Returns number of buffers that were prepared for flush. 3279 */ 3280 static int qeth_prep_flush_pack_buffer(struct qeth_qdio_out_q *queue) 3281 { 3282 struct qeth_qdio_out_buffer *buffer; 3283 3284 buffer = queue->bufs[queue->next_buf_to_fill]; 3285 if ((atomic_read(&buffer->state) == QETH_QDIO_BUF_EMPTY) && 3286 (buffer->next_element_to_fill > 0)) { 3287 /* it's a packing buffer */ 3288 atomic_set(&buffer->state, QETH_QDIO_BUF_PRIMED); 3289 queue->next_buf_to_fill = 3290 (queue->next_buf_to_fill + 1) % QDIO_MAX_BUFFERS_PER_Q; 3291 return 1; 3292 } 3293 return 0; 3294 } 3295 3296 /* 3297 * Switched to packing state if the number of used buffers on a queue 3298 * reaches a certain limit. 3299 */ 3300 static void qeth_switch_to_packing_if_needed(struct qeth_qdio_out_q *queue) 3301 { 3302 if (!queue->do_pack) { 3303 if (atomic_read(&queue->used_buffers) 3304 >= QETH_HIGH_WATERMARK_PACK){ 3305 /* switch non-PACKING -> PACKING */ 3306 QETH_CARD_TEXT(queue->card, 6, "np->pack"); 3307 QETH_TXQ_STAT_INC(queue, packing_mode_switch); 3308 queue->do_pack = 1; 3309 } 3310 } 3311 } 3312 3313 /* 3314 * Switches from packing to non-packing mode. If there is a packing 3315 * buffer on the queue this buffer will be prepared to be flushed. 3316 * In that case 1 is returned to inform the caller. If no buffer 3317 * has to be flushed, zero is returned. 3318 */ 3319 static int qeth_switch_to_nonpacking_if_needed(struct qeth_qdio_out_q *queue) 3320 { 3321 if (queue->do_pack) { 3322 if (atomic_read(&queue->used_buffers) 3323 <= QETH_LOW_WATERMARK_PACK) { 3324 /* switch PACKING -> non-PACKING */ 3325 QETH_CARD_TEXT(queue->card, 6, "pack->np"); 3326 QETH_TXQ_STAT_INC(queue, packing_mode_switch); 3327 queue->do_pack = 0; 3328 return qeth_prep_flush_pack_buffer(queue); 3329 } 3330 } 3331 return 0; 3332 } 3333 3334 static void qeth_flush_buffers(struct qeth_qdio_out_q *queue, int index, 3335 int count) 3336 { 3337 struct qeth_qdio_out_buffer *buf; 3338 int rc; 3339 int i; 3340 unsigned int qdio_flags; 3341 3342 for (i = index; i < index + count; ++i) { 3343 int bidx = i % QDIO_MAX_BUFFERS_PER_Q; 3344 buf = queue->bufs[bidx]; 3345 buf->buffer->element[buf->next_element_to_fill - 1].eflags |= 3346 SBAL_EFLAGS_LAST_ENTRY; 3347 3348 if (queue->bufstates) 3349 queue->bufstates[bidx].user = buf; 3350 3351 if (queue->card->info.type == QETH_CARD_TYPE_IQD) 3352 continue; 3353 3354 if (!queue->do_pack) { 3355 if ((atomic_read(&queue->used_buffers) >= 3356 (QETH_HIGH_WATERMARK_PACK - 3357 QETH_WATERMARK_PACK_FUZZ)) && 3358 !atomic_read(&queue->set_pci_flags_count)) { 3359 /* it's likely that we'll go to packing 3360 * mode soon */ 3361 atomic_inc(&queue->set_pci_flags_count); 3362 buf->buffer->element[0].sflags |= SBAL_SFLAGS0_PCI_REQ; 3363 } 3364 } else { 3365 if (!atomic_read(&queue->set_pci_flags_count)) { 3366 /* 3367 * there's no outstanding PCI any more, so we 3368 * have to request a PCI to be sure the the PCI 3369 * will wake at some time in the future then we 3370 * can flush packed buffers that might still be 3371 * hanging around, which can happen if no 3372 * further send was requested by the stack 3373 */ 3374 atomic_inc(&queue->set_pci_flags_count); 3375 buf->buffer->element[0].sflags |= SBAL_SFLAGS0_PCI_REQ; 3376 } 3377 } 3378 } 3379 3380 QETH_TXQ_STAT_ADD(queue, bufs, count); 3381 netif_trans_update(queue->card->dev); 3382 qdio_flags = QDIO_FLAG_SYNC_OUTPUT; 3383 if (atomic_read(&queue->set_pci_flags_count)) 3384 qdio_flags |= QDIO_FLAG_PCI_OUT; 3385 atomic_add(count, &queue->used_buffers); 3386 rc = do_QDIO(CARD_DDEV(queue->card), qdio_flags, 3387 queue->queue_no, index, count); 3388 if (rc) { 3389 QETH_TXQ_STAT_ADD(queue, tx_errors, count); 3390 /* ignore temporary SIGA errors without busy condition */ 3391 if (rc == -ENOBUFS) 3392 return; 3393 QETH_CARD_TEXT(queue->card, 2, "flushbuf"); 3394 QETH_CARD_TEXT_(queue->card, 2, " q%d", queue->queue_no); 3395 QETH_CARD_TEXT_(queue->card, 2, " idx%d", index); 3396 QETH_CARD_TEXT_(queue->card, 2, " c%d", count); 3397 QETH_CARD_TEXT_(queue->card, 2, " err%d", rc); 3398 3399 /* this must not happen under normal circumstances. if it 3400 * happens something is really wrong -> recover */ 3401 qeth_schedule_recovery(queue->card); 3402 return; 3403 } 3404 } 3405 3406 static void qeth_check_outbound_queue(struct qeth_qdio_out_q *queue) 3407 { 3408 int index; 3409 int flush_cnt = 0; 3410 int q_was_packing = 0; 3411 3412 /* 3413 * check if weed have to switch to non-packing mode or if 3414 * we have to get a pci flag out on the queue 3415 */ 3416 if ((atomic_read(&queue->used_buffers) <= QETH_LOW_WATERMARK_PACK) || 3417 !atomic_read(&queue->set_pci_flags_count)) { 3418 if (atomic_xchg(&queue->state, QETH_OUT_Q_LOCKED_FLUSH) == 3419 QETH_OUT_Q_UNLOCKED) { 3420 /* 3421 * If we get in here, there was no action in 3422 * do_send_packet. So, we check if there is a 3423 * packing buffer to be flushed here. 3424 */ 3425 netif_stop_queue(queue->card->dev); 3426 index = queue->next_buf_to_fill; 3427 q_was_packing = queue->do_pack; 3428 /* queue->do_pack may change */ 3429 barrier(); 3430 flush_cnt += qeth_switch_to_nonpacking_if_needed(queue); 3431 if (!flush_cnt && 3432 !atomic_read(&queue->set_pci_flags_count)) 3433 flush_cnt += qeth_prep_flush_pack_buffer(queue); 3434 if (q_was_packing) 3435 QETH_TXQ_STAT_ADD(queue, bufs_pack, flush_cnt); 3436 if (flush_cnt) 3437 qeth_flush_buffers(queue, index, flush_cnt); 3438 atomic_set(&queue->state, QETH_OUT_Q_UNLOCKED); 3439 } 3440 } 3441 } 3442 3443 static void qeth_qdio_start_poll(struct ccw_device *ccwdev, int queue, 3444 unsigned long card_ptr) 3445 { 3446 struct qeth_card *card = (struct qeth_card *)card_ptr; 3447 3448 if (card->dev->flags & IFF_UP) 3449 napi_schedule(&card->napi); 3450 } 3451 3452 int qeth_configure_cq(struct qeth_card *card, enum qeth_cq cq) 3453 { 3454 int rc; 3455 3456 if (card->options.cq == QETH_CQ_NOTAVAILABLE) { 3457 rc = -1; 3458 goto out; 3459 } else { 3460 if (card->options.cq == cq) { 3461 rc = 0; 3462 goto out; 3463 } 3464 3465 if (card->state != CARD_STATE_DOWN) { 3466 rc = -1; 3467 goto out; 3468 } 3469 3470 qeth_free_qdio_buffers(card); 3471 card->options.cq = cq; 3472 rc = 0; 3473 } 3474 out: 3475 return rc; 3476 3477 } 3478 EXPORT_SYMBOL_GPL(qeth_configure_cq); 3479 3480 static void qeth_qdio_cq_handler(struct qeth_card *card, unsigned int qdio_err, 3481 unsigned int queue, int first_element, 3482 int count) 3483 { 3484 struct qeth_qdio_q *cq = card->qdio.c_q; 3485 int i; 3486 int rc; 3487 3488 if (!qeth_is_cq(card, queue)) 3489 return; 3490 3491 QETH_CARD_TEXT_(card, 5, "qcqhe%d", first_element); 3492 QETH_CARD_TEXT_(card, 5, "qcqhc%d", count); 3493 QETH_CARD_TEXT_(card, 5, "qcqherr%d", qdio_err); 3494 3495 if (qdio_err) { 3496 netif_stop_queue(card->dev); 3497 qeth_schedule_recovery(card); 3498 return; 3499 } 3500 3501 for (i = first_element; i < first_element + count; ++i) { 3502 int bidx = i % QDIO_MAX_BUFFERS_PER_Q; 3503 struct qdio_buffer *buffer = cq->qdio_bufs[bidx]; 3504 int e = 0; 3505 3506 while ((e < QDIO_MAX_ELEMENTS_PER_BUFFER) && 3507 buffer->element[e].addr) { 3508 unsigned long phys_aob_addr; 3509 3510 phys_aob_addr = (unsigned long) buffer->element[e].addr; 3511 qeth_qdio_handle_aob(card, phys_aob_addr); 3512 ++e; 3513 } 3514 qeth_scrub_qdio_buffer(buffer, QDIO_MAX_ELEMENTS_PER_BUFFER); 3515 } 3516 rc = do_QDIO(CARD_DDEV(card), QDIO_FLAG_SYNC_INPUT, queue, 3517 card->qdio.c_q->next_buf_to_init, 3518 count); 3519 if (rc) { 3520 dev_warn(&card->gdev->dev, 3521 "QDIO reported an error, rc=%i\n", rc); 3522 QETH_CARD_TEXT(card, 2, "qcqherr"); 3523 } 3524 card->qdio.c_q->next_buf_to_init = (card->qdio.c_q->next_buf_to_init 3525 + count) % QDIO_MAX_BUFFERS_PER_Q; 3526 } 3527 3528 static void qeth_qdio_input_handler(struct ccw_device *ccwdev, 3529 unsigned int qdio_err, int queue, 3530 int first_elem, int count, 3531 unsigned long card_ptr) 3532 { 3533 struct qeth_card *card = (struct qeth_card *)card_ptr; 3534 3535 QETH_CARD_TEXT_(card, 2, "qihq%d", queue); 3536 QETH_CARD_TEXT_(card, 2, "qiec%d", qdio_err); 3537 3538 if (qeth_is_cq(card, queue)) 3539 qeth_qdio_cq_handler(card, qdio_err, queue, first_elem, count); 3540 else if (qdio_err) 3541 qeth_schedule_recovery(card); 3542 } 3543 3544 static void qeth_qdio_output_handler(struct ccw_device *ccwdev, 3545 unsigned int qdio_error, int __queue, 3546 int first_element, int count, 3547 unsigned long card_ptr) 3548 { 3549 struct qeth_card *card = (struct qeth_card *) card_ptr; 3550 struct qeth_qdio_out_q *queue = card->qdio.out_qs[__queue]; 3551 struct qeth_qdio_out_buffer *buffer; 3552 int i; 3553 3554 QETH_CARD_TEXT(card, 6, "qdouhdl"); 3555 if (qdio_error & QDIO_ERROR_FATAL) { 3556 QETH_CARD_TEXT(card, 2, "achkcond"); 3557 netif_stop_queue(card->dev); 3558 qeth_schedule_recovery(card); 3559 return; 3560 } 3561 3562 for (i = first_element; i < (first_element + count); ++i) { 3563 int bidx = i % QDIO_MAX_BUFFERS_PER_Q; 3564 buffer = queue->bufs[bidx]; 3565 qeth_handle_send_error(card, buffer, qdio_error); 3566 3567 if (queue->bufstates && 3568 (queue->bufstates[bidx].flags & 3569 QDIO_OUTBUF_STATE_FLAG_PENDING) != 0) { 3570 WARN_ON_ONCE(card->options.cq != QETH_CQ_ENABLED); 3571 3572 if (atomic_cmpxchg(&buffer->state, 3573 QETH_QDIO_BUF_PRIMED, 3574 QETH_QDIO_BUF_PENDING) == 3575 QETH_QDIO_BUF_PRIMED) { 3576 qeth_notify_skbs(queue, buffer, 3577 TX_NOTIFY_PENDING); 3578 } 3579 QETH_CARD_TEXT_(queue->card, 5, "pel%d", bidx); 3580 3581 /* prepare the queue slot for re-use: */ 3582 qeth_scrub_qdio_buffer(buffer->buffer, 3583 QETH_MAX_BUFFER_ELEMENTS(card)); 3584 if (qeth_init_qdio_out_buf(queue, bidx)) { 3585 QETH_CARD_TEXT(card, 2, "outofbuf"); 3586 qeth_schedule_recovery(card); 3587 } 3588 } else { 3589 if (card->options.cq == QETH_CQ_ENABLED) { 3590 enum iucv_tx_notify n; 3591 3592 n = qeth_compute_cq_notification( 3593 buffer->buffer->element[15].sflags, 0); 3594 qeth_notify_skbs(queue, buffer, n); 3595 } 3596 3597 qeth_clear_output_buffer(queue, buffer); 3598 } 3599 qeth_cleanup_handled_pending(queue, bidx, 0); 3600 } 3601 atomic_sub(count, &queue->used_buffers); 3602 /* check if we need to do something on this outbound queue */ 3603 if (card->info.type != QETH_CARD_TYPE_IQD) 3604 qeth_check_outbound_queue(queue); 3605 3606 netif_wake_queue(queue->card->dev); 3607 } 3608 3609 /* We cannot use outbound queue 3 for unicast packets on HiperSockets */ 3610 static inline int qeth_cut_iqd_prio(struct qeth_card *card, int queue_num) 3611 { 3612 if ((card->info.type == QETH_CARD_TYPE_IQD) && (queue_num == 3)) 3613 return 2; 3614 return queue_num; 3615 } 3616 3617 /** 3618 * Note: Function assumes that we have 4 outbound queues. 3619 */ 3620 int qeth_get_priority_queue(struct qeth_card *card, struct sk_buff *skb, 3621 int ipv) 3622 { 3623 __be16 *tci; 3624 u8 tos; 3625 3626 switch (card->qdio.do_prio_queueing) { 3627 case QETH_PRIO_Q_ING_TOS: 3628 case QETH_PRIO_Q_ING_PREC: 3629 switch (ipv) { 3630 case 4: 3631 tos = ipv4_get_dsfield(ip_hdr(skb)); 3632 break; 3633 case 6: 3634 tos = ipv6_get_dsfield(ipv6_hdr(skb)); 3635 break; 3636 default: 3637 return card->qdio.default_out_queue; 3638 } 3639 if (card->qdio.do_prio_queueing == QETH_PRIO_Q_ING_PREC) 3640 return qeth_cut_iqd_prio(card, ~tos >> 6 & 3); 3641 if (tos & IPTOS_MINCOST) 3642 return qeth_cut_iqd_prio(card, 3); 3643 if (tos & IPTOS_RELIABILITY) 3644 return 2; 3645 if (tos & IPTOS_THROUGHPUT) 3646 return 1; 3647 if (tos & IPTOS_LOWDELAY) 3648 return 0; 3649 break; 3650 case QETH_PRIO_Q_ING_SKB: 3651 if (skb->priority > 5) 3652 return 0; 3653 return qeth_cut_iqd_prio(card, ~skb->priority >> 1 & 3); 3654 case QETH_PRIO_Q_ING_VLAN: 3655 tci = &((struct ethhdr *)skb->data)->h_proto; 3656 if (be16_to_cpu(*tci) == ETH_P_8021Q) 3657 return qeth_cut_iqd_prio(card, 3658 ~be16_to_cpu(*(tci + 1)) >> (VLAN_PRIO_SHIFT + 1) & 3); 3659 break; 3660 default: 3661 break; 3662 } 3663 return card->qdio.default_out_queue; 3664 } 3665 EXPORT_SYMBOL_GPL(qeth_get_priority_queue); 3666 3667 /** 3668 * qeth_get_elements_for_frags() - find number of SBALEs for skb frags. 3669 * @skb: SKB address 3670 * 3671 * Returns the number of pages, and thus QDIO buffer elements, needed to cover 3672 * fragmented part of the SKB. Returns zero for linear SKB. 3673 */ 3674 static int qeth_get_elements_for_frags(struct sk_buff *skb) 3675 { 3676 int cnt, elements = 0; 3677 3678 for (cnt = 0; cnt < skb_shinfo(skb)->nr_frags; cnt++) { 3679 struct skb_frag_struct *frag = &skb_shinfo(skb)->frags[cnt]; 3680 3681 elements += qeth_get_elements_for_range( 3682 (addr_t)skb_frag_address(frag), 3683 (addr_t)skb_frag_address(frag) + skb_frag_size(frag)); 3684 } 3685 return elements; 3686 } 3687 3688 /** 3689 * qeth_count_elements() - Counts the number of QDIO buffer elements needed 3690 * to transmit an skb. 3691 * @skb: the skb to operate on. 3692 * @data_offset: skip this part of the skb's linear data 3693 * 3694 * Returns the number of pages, and thus QDIO buffer elements, needed to map the 3695 * skb's data (both its linear part and paged fragments). 3696 */ 3697 unsigned int qeth_count_elements(struct sk_buff *skb, unsigned int data_offset) 3698 { 3699 unsigned int elements = qeth_get_elements_for_frags(skb); 3700 addr_t end = (addr_t)skb->data + skb_headlen(skb); 3701 addr_t start = (addr_t)skb->data + data_offset; 3702 3703 if (start != end) 3704 elements += qeth_get_elements_for_range(start, end); 3705 return elements; 3706 } 3707 EXPORT_SYMBOL_GPL(qeth_count_elements); 3708 3709 #define QETH_HDR_CACHE_OBJ_SIZE (sizeof(struct qeth_hdr_tso) + \ 3710 MAX_TCP_HEADER) 3711 3712 /** 3713 * qeth_add_hw_header() - add a HW header to an skb. 3714 * @skb: skb that the HW header should be added to. 3715 * @hdr: double pointer to a qeth_hdr. When returning with >= 0, 3716 * it contains a valid pointer to a qeth_hdr. 3717 * @hdr_len: length of the HW header. 3718 * @proto_len: length of protocol headers that need to be in same page as the 3719 * HW header. 3720 * 3721 * Returns the pushed length. If the header can't be pushed on 3722 * (eg. because it would cross a page boundary), it is allocated from 3723 * the cache instead and 0 is returned. 3724 * The number of needed buffer elements is returned in @elements. 3725 * Error to create the hdr is indicated by returning with < 0. 3726 */ 3727 static int qeth_add_hw_header(struct qeth_qdio_out_q *queue, 3728 struct sk_buff *skb, struct qeth_hdr **hdr, 3729 unsigned int hdr_len, unsigned int proto_len, 3730 unsigned int *elements) 3731 { 3732 const unsigned int max_elements = QETH_MAX_BUFFER_ELEMENTS(queue->card); 3733 const unsigned int contiguous = proto_len ? proto_len : 1; 3734 unsigned int __elements; 3735 addr_t start, end; 3736 bool push_ok; 3737 int rc; 3738 3739 check_layout: 3740 start = (addr_t)skb->data - hdr_len; 3741 end = (addr_t)skb->data; 3742 3743 if (qeth_get_elements_for_range(start, end + contiguous) == 1) { 3744 /* Push HW header into same page as first protocol header. */ 3745 push_ok = true; 3746 /* ... but TSO always needs a separate element for headers: */ 3747 if (skb_is_gso(skb)) 3748 __elements = 1 + qeth_count_elements(skb, proto_len); 3749 else 3750 __elements = qeth_count_elements(skb, 0); 3751 } else if (!proto_len && qeth_get_elements_for_range(start, end) == 1) { 3752 /* Push HW header into a new page. */ 3753 push_ok = true; 3754 __elements = 1 + qeth_count_elements(skb, 0); 3755 } else { 3756 /* Use header cache, copy protocol headers up. */ 3757 push_ok = false; 3758 __elements = 1 + qeth_count_elements(skb, proto_len); 3759 } 3760 3761 /* Compress skb to fit into one IO buffer: */ 3762 if (__elements > max_elements) { 3763 if (!skb_is_nonlinear(skb)) { 3764 /* Drop it, no easy way of shrinking it further. */ 3765 QETH_DBF_MESSAGE(2, "Dropped an oversized skb (Max Elements=%u / Actual=%u / Length=%u).\n", 3766 max_elements, __elements, skb->len); 3767 return -E2BIG; 3768 } 3769 3770 rc = skb_linearize(skb); 3771 if (rc) { 3772 QETH_TXQ_STAT_INC(queue, skbs_linearized_fail); 3773 return rc; 3774 } 3775 3776 QETH_TXQ_STAT_INC(queue, skbs_linearized); 3777 /* Linearization changed the layout, re-evaluate: */ 3778 goto check_layout; 3779 } 3780 3781 *elements = __elements; 3782 /* Add the header: */ 3783 if (push_ok) { 3784 *hdr = skb_push(skb, hdr_len); 3785 return hdr_len; 3786 } 3787 /* fall back */ 3788 if (hdr_len + proto_len > QETH_HDR_CACHE_OBJ_SIZE) 3789 return -E2BIG; 3790 *hdr = kmem_cache_alloc(qeth_core_header_cache, GFP_ATOMIC); 3791 if (!*hdr) 3792 return -ENOMEM; 3793 /* Copy protocol headers behind HW header: */ 3794 skb_copy_from_linear_data(skb, ((char *)*hdr) + hdr_len, proto_len); 3795 return 0; 3796 } 3797 3798 static void __qeth_fill_buffer(struct sk_buff *skb, 3799 struct qeth_qdio_out_buffer *buf, 3800 bool is_first_elem, unsigned int offset) 3801 { 3802 struct qdio_buffer *buffer = buf->buffer; 3803 int element = buf->next_element_to_fill; 3804 int length = skb_headlen(skb) - offset; 3805 char *data = skb->data + offset; 3806 int length_here, cnt; 3807 3808 /* map linear part into buffer element(s) */ 3809 while (length > 0) { 3810 /* length_here is the remaining amount of data in this page */ 3811 length_here = PAGE_SIZE - ((unsigned long) data % PAGE_SIZE); 3812 if (length < length_here) 3813 length_here = length; 3814 3815 buffer->element[element].addr = data; 3816 buffer->element[element].length = length_here; 3817 length -= length_here; 3818 if (is_first_elem) { 3819 is_first_elem = false; 3820 if (length || skb_is_nonlinear(skb)) 3821 /* skb needs additional elements */ 3822 buffer->element[element].eflags = 3823 SBAL_EFLAGS_FIRST_FRAG; 3824 else 3825 buffer->element[element].eflags = 0; 3826 } else { 3827 buffer->element[element].eflags = 3828 SBAL_EFLAGS_MIDDLE_FRAG; 3829 } 3830 data += length_here; 3831 element++; 3832 } 3833 3834 /* map page frags into buffer element(s) */ 3835 for (cnt = 0; cnt < skb_shinfo(skb)->nr_frags; cnt++) { 3836 skb_frag_t *frag = &skb_shinfo(skb)->frags[cnt]; 3837 3838 data = skb_frag_address(frag); 3839 length = skb_frag_size(frag); 3840 while (length > 0) { 3841 length_here = PAGE_SIZE - 3842 ((unsigned long) data % PAGE_SIZE); 3843 if (length < length_here) 3844 length_here = length; 3845 3846 buffer->element[element].addr = data; 3847 buffer->element[element].length = length_here; 3848 buffer->element[element].eflags = 3849 SBAL_EFLAGS_MIDDLE_FRAG; 3850 length -= length_here; 3851 data += length_here; 3852 element++; 3853 } 3854 } 3855 3856 if (buffer->element[element - 1].eflags) 3857 buffer->element[element - 1].eflags = SBAL_EFLAGS_LAST_FRAG; 3858 buf->next_element_to_fill = element; 3859 } 3860 3861 /** 3862 * qeth_fill_buffer() - map skb into an output buffer 3863 * @queue: QDIO queue to submit the buffer on 3864 * @buf: buffer to transport the skb 3865 * @skb: skb to map into the buffer 3866 * @hdr: qeth_hdr for this skb. Either at skb->data, or allocated 3867 * from qeth_core_header_cache. 3868 * @offset: when mapping the skb, start at skb->data + offset 3869 * @hd_len: if > 0, build a dedicated header element of this size 3870 */ 3871 static int qeth_fill_buffer(struct qeth_qdio_out_q *queue, 3872 struct qeth_qdio_out_buffer *buf, 3873 struct sk_buff *skb, struct qeth_hdr *hdr, 3874 unsigned int offset, unsigned int hd_len) 3875 { 3876 struct qdio_buffer *buffer = buf->buffer; 3877 bool is_first_elem = true; 3878 3879 __skb_queue_tail(&buf->skb_list, skb); 3880 3881 /* build dedicated header element */ 3882 if (hd_len) { 3883 int element = buf->next_element_to_fill; 3884 is_first_elem = false; 3885 3886 buffer->element[element].addr = hdr; 3887 buffer->element[element].length = hd_len; 3888 buffer->element[element].eflags = SBAL_EFLAGS_FIRST_FRAG; 3889 /* remember to free cache-allocated qeth_hdr: */ 3890 buf->is_header[element] = ((void *)hdr != skb->data); 3891 buf->next_element_to_fill++; 3892 } 3893 3894 __qeth_fill_buffer(skb, buf, is_first_elem, offset); 3895 3896 if (!queue->do_pack) { 3897 QETH_CARD_TEXT(queue->card, 6, "fillbfnp"); 3898 } else { 3899 QETH_CARD_TEXT(queue->card, 6, "fillbfpa"); 3900 3901 QETH_TXQ_STAT_INC(queue, skbs_pack); 3902 /* If the buffer still has free elements, keep using it. */ 3903 if (buf->next_element_to_fill < 3904 QETH_MAX_BUFFER_ELEMENTS(queue->card)) 3905 return 0; 3906 } 3907 3908 /* flush out the buffer */ 3909 atomic_set(&buf->state, QETH_QDIO_BUF_PRIMED); 3910 queue->next_buf_to_fill = (queue->next_buf_to_fill + 1) % 3911 QDIO_MAX_BUFFERS_PER_Q; 3912 return 1; 3913 } 3914 3915 static int qeth_do_send_packet_fast(struct qeth_qdio_out_q *queue, 3916 struct sk_buff *skb, struct qeth_hdr *hdr, 3917 unsigned int offset, unsigned int hd_len) 3918 { 3919 int index = queue->next_buf_to_fill; 3920 struct qeth_qdio_out_buffer *buffer = queue->bufs[index]; 3921 3922 /* 3923 * check if buffer is empty to make sure that we do not 'overtake' 3924 * ourselves and try to fill a buffer that is already primed 3925 */ 3926 if (atomic_read(&buffer->state) != QETH_QDIO_BUF_EMPTY) 3927 return -EBUSY; 3928 qeth_fill_buffer(queue, buffer, skb, hdr, offset, hd_len); 3929 qeth_flush_buffers(queue, index, 1); 3930 return 0; 3931 } 3932 3933 int qeth_do_send_packet(struct qeth_card *card, struct qeth_qdio_out_q *queue, 3934 struct sk_buff *skb, struct qeth_hdr *hdr, 3935 unsigned int offset, unsigned int hd_len, 3936 int elements_needed) 3937 { 3938 struct qeth_qdio_out_buffer *buffer; 3939 int start_index; 3940 int flush_count = 0; 3941 int do_pack = 0; 3942 int tmp; 3943 int rc = 0; 3944 3945 /* spin until we get the queue ... */ 3946 while (atomic_cmpxchg(&queue->state, QETH_OUT_Q_UNLOCKED, 3947 QETH_OUT_Q_LOCKED) != QETH_OUT_Q_UNLOCKED); 3948 start_index = queue->next_buf_to_fill; 3949 buffer = queue->bufs[queue->next_buf_to_fill]; 3950 /* 3951 * check if buffer is empty to make sure that we do not 'overtake' 3952 * ourselves and try to fill a buffer that is already primed 3953 */ 3954 if (atomic_read(&buffer->state) != QETH_QDIO_BUF_EMPTY) { 3955 atomic_set(&queue->state, QETH_OUT_Q_UNLOCKED); 3956 return -EBUSY; 3957 } 3958 /* check if we need to switch packing state of this queue */ 3959 qeth_switch_to_packing_if_needed(queue); 3960 if (queue->do_pack) { 3961 do_pack = 1; 3962 /* does packet fit in current buffer? */ 3963 if ((QETH_MAX_BUFFER_ELEMENTS(card) - 3964 buffer->next_element_to_fill) < elements_needed) { 3965 /* ... no -> set state PRIMED */ 3966 atomic_set(&buffer->state, QETH_QDIO_BUF_PRIMED); 3967 flush_count++; 3968 queue->next_buf_to_fill = 3969 (queue->next_buf_to_fill + 1) % 3970 QDIO_MAX_BUFFERS_PER_Q; 3971 buffer = queue->bufs[queue->next_buf_to_fill]; 3972 /* we did a step forward, so check buffer state 3973 * again */ 3974 if (atomic_read(&buffer->state) != 3975 QETH_QDIO_BUF_EMPTY) { 3976 qeth_flush_buffers(queue, start_index, 3977 flush_count); 3978 atomic_set(&queue->state, 3979 QETH_OUT_Q_UNLOCKED); 3980 rc = -EBUSY; 3981 goto out; 3982 } 3983 } 3984 } 3985 3986 flush_count += qeth_fill_buffer(queue, buffer, skb, hdr, offset, 3987 hd_len); 3988 if (flush_count) 3989 qeth_flush_buffers(queue, start_index, flush_count); 3990 else if (!atomic_read(&queue->set_pci_flags_count)) 3991 atomic_xchg(&queue->state, QETH_OUT_Q_LOCKED_FLUSH); 3992 /* 3993 * queue->state will go from LOCKED -> UNLOCKED or from 3994 * LOCKED_FLUSH -> LOCKED if output_handler wanted to 'notify' us 3995 * (switch packing state or flush buffer to get another pci flag out). 3996 * In that case we will enter this loop 3997 */ 3998 while (atomic_dec_return(&queue->state)) { 3999 start_index = queue->next_buf_to_fill; 4000 /* check if we can go back to non-packing state */ 4001 tmp = qeth_switch_to_nonpacking_if_needed(queue); 4002 /* 4003 * check if we need to flush a packing buffer to get a pci 4004 * flag out on the queue 4005 */ 4006 if (!tmp && !atomic_read(&queue->set_pci_flags_count)) 4007 tmp = qeth_prep_flush_pack_buffer(queue); 4008 if (tmp) { 4009 qeth_flush_buffers(queue, start_index, tmp); 4010 flush_count += tmp; 4011 } 4012 } 4013 out: 4014 /* at this point the queue is UNLOCKED again */ 4015 if (do_pack) 4016 QETH_TXQ_STAT_ADD(queue, bufs_pack, flush_count); 4017 4018 return rc; 4019 } 4020 EXPORT_SYMBOL_GPL(qeth_do_send_packet); 4021 4022 static void qeth_fill_tso_ext(struct qeth_hdr_tso *hdr, 4023 unsigned int payload_len, struct sk_buff *skb, 4024 unsigned int proto_len) 4025 { 4026 struct qeth_hdr_ext_tso *ext = &hdr->ext; 4027 4028 ext->hdr_tot_len = sizeof(*ext); 4029 ext->imb_hdr_no = 1; 4030 ext->hdr_type = 1; 4031 ext->hdr_version = 1; 4032 ext->hdr_len = 28; 4033 ext->payload_len = payload_len; 4034 ext->mss = skb_shinfo(skb)->gso_size; 4035 ext->dg_hdr_len = proto_len; 4036 } 4037 4038 int qeth_xmit(struct qeth_card *card, struct sk_buff *skb, 4039 struct qeth_qdio_out_q *queue, int ipv, int cast_type, 4040 void (*fill_header)(struct qeth_qdio_out_q *queue, 4041 struct qeth_hdr *hdr, struct sk_buff *skb, 4042 int ipv, int cast_type, 4043 unsigned int data_len)) 4044 { 4045 unsigned int proto_len, hw_hdr_len; 4046 unsigned int frame_len = skb->len; 4047 bool is_tso = skb_is_gso(skb); 4048 unsigned int data_offset = 0; 4049 struct qeth_hdr *hdr = NULL; 4050 unsigned int hd_len = 0; 4051 unsigned int elements; 4052 int push_len, rc; 4053 bool is_sg; 4054 4055 if (is_tso) { 4056 hw_hdr_len = sizeof(struct qeth_hdr_tso); 4057 proto_len = skb_transport_offset(skb) + tcp_hdrlen(skb); 4058 } else { 4059 hw_hdr_len = sizeof(struct qeth_hdr); 4060 proto_len = (IS_IQD(card) && IS_LAYER2(card)) ? ETH_HLEN : 0; 4061 } 4062 4063 rc = skb_cow_head(skb, hw_hdr_len); 4064 if (rc) 4065 return rc; 4066 4067 push_len = qeth_add_hw_header(queue, skb, &hdr, hw_hdr_len, proto_len, 4068 &elements); 4069 if (push_len < 0) 4070 return push_len; 4071 if (is_tso || !push_len) { 4072 /* HW header needs its own buffer element. */ 4073 hd_len = hw_hdr_len + proto_len; 4074 data_offset = push_len + proto_len; 4075 } 4076 memset(hdr, 0, hw_hdr_len); 4077 fill_header(queue, hdr, skb, ipv, cast_type, frame_len); 4078 if (is_tso) 4079 qeth_fill_tso_ext((struct qeth_hdr_tso *) hdr, 4080 frame_len - proto_len, skb, proto_len); 4081 4082 is_sg = skb_is_nonlinear(skb); 4083 if (IS_IQD(card)) { 4084 rc = qeth_do_send_packet_fast(queue, skb, hdr, data_offset, 4085 hd_len); 4086 } else { 4087 /* TODO: drop skb_orphan() once TX completion is fast enough */ 4088 skb_orphan(skb); 4089 rc = qeth_do_send_packet(card, queue, skb, hdr, data_offset, 4090 hd_len, elements); 4091 } 4092 4093 if (!rc) { 4094 QETH_TXQ_STAT_ADD(queue, buf_elements, elements); 4095 if (is_sg) 4096 QETH_TXQ_STAT_INC(queue, skbs_sg); 4097 if (is_tso) { 4098 QETH_TXQ_STAT_INC(queue, skbs_tso); 4099 QETH_TXQ_STAT_ADD(queue, tso_bytes, frame_len); 4100 } 4101 } else { 4102 if (!push_len) 4103 kmem_cache_free(qeth_core_header_cache, hdr); 4104 if (rc == -EBUSY) 4105 /* roll back to ETH header */ 4106 skb_pull(skb, push_len); 4107 } 4108 return rc; 4109 } 4110 EXPORT_SYMBOL_GPL(qeth_xmit); 4111 4112 static int qeth_setadp_promisc_mode_cb(struct qeth_card *card, 4113 struct qeth_reply *reply, unsigned long data) 4114 { 4115 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data; 4116 struct qeth_ipacmd_setadpparms *setparms; 4117 4118 QETH_CARD_TEXT(card, 4, "prmadpcb"); 4119 4120 setparms = &(cmd->data.setadapterparms); 4121 if (qeth_setadpparms_inspect_rc(cmd)) { 4122 QETH_CARD_TEXT_(card, 4, "prmrc%x", cmd->hdr.return_code); 4123 setparms->data.mode = SET_PROMISC_MODE_OFF; 4124 } 4125 card->info.promisc_mode = setparms->data.mode; 4126 return (cmd->hdr.return_code) ? -EIO : 0; 4127 } 4128 4129 void qeth_setadp_promisc_mode(struct qeth_card *card) 4130 { 4131 enum qeth_ipa_promisc_modes mode; 4132 struct net_device *dev = card->dev; 4133 struct qeth_cmd_buffer *iob; 4134 struct qeth_ipa_cmd *cmd; 4135 4136 QETH_CARD_TEXT(card, 4, "setprom"); 4137 4138 if (((dev->flags & IFF_PROMISC) && 4139 (card->info.promisc_mode == SET_PROMISC_MODE_ON)) || 4140 (!(dev->flags & IFF_PROMISC) && 4141 (card->info.promisc_mode == SET_PROMISC_MODE_OFF))) 4142 return; 4143 mode = SET_PROMISC_MODE_OFF; 4144 if (dev->flags & IFF_PROMISC) 4145 mode = SET_PROMISC_MODE_ON; 4146 QETH_CARD_TEXT_(card, 4, "mode:%x", mode); 4147 4148 iob = qeth_get_adapter_cmd(card, IPA_SETADP_SET_PROMISC_MODE, 4149 sizeof(struct qeth_ipacmd_setadpparms_hdr) + 8); 4150 if (!iob) 4151 return; 4152 cmd = __ipa_cmd(iob); 4153 cmd->data.setadapterparms.data.mode = mode; 4154 qeth_send_ipa_cmd(card, iob, qeth_setadp_promisc_mode_cb, NULL); 4155 } 4156 EXPORT_SYMBOL_GPL(qeth_setadp_promisc_mode); 4157 4158 static int qeth_setadpparms_change_macaddr_cb(struct qeth_card *card, 4159 struct qeth_reply *reply, unsigned long data) 4160 { 4161 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data; 4162 struct qeth_ipacmd_setadpparms *adp_cmd; 4163 4164 QETH_CARD_TEXT(card, 4, "chgmaccb"); 4165 if (qeth_setadpparms_inspect_rc(cmd)) 4166 return -EIO; 4167 4168 adp_cmd = &cmd->data.setadapterparms; 4169 if (!is_valid_ether_addr(adp_cmd->data.change_addr.addr)) 4170 return -EADDRNOTAVAIL; 4171 4172 if (IS_LAYER2(card) && IS_OSD(card) && !IS_VM_NIC(card) && 4173 !(adp_cmd->hdr.flags & QETH_SETADP_FLAGS_VIRTUAL_MAC)) 4174 return -EADDRNOTAVAIL; 4175 4176 ether_addr_copy(card->dev->dev_addr, adp_cmd->data.change_addr.addr); 4177 return 0; 4178 } 4179 4180 int qeth_setadpparms_change_macaddr(struct qeth_card *card) 4181 { 4182 int rc; 4183 struct qeth_cmd_buffer *iob; 4184 struct qeth_ipa_cmd *cmd; 4185 4186 QETH_CARD_TEXT(card, 4, "chgmac"); 4187 4188 iob = qeth_get_adapter_cmd(card, IPA_SETADP_ALTER_MAC_ADDRESS, 4189 sizeof(struct qeth_ipacmd_setadpparms_hdr) + 4190 sizeof(struct qeth_change_addr)); 4191 if (!iob) 4192 return -ENOMEM; 4193 cmd = __ipa_cmd(iob); 4194 cmd->data.setadapterparms.data.change_addr.cmd = CHANGE_ADDR_READ_MAC; 4195 cmd->data.setadapterparms.data.change_addr.addr_size = ETH_ALEN; 4196 ether_addr_copy(cmd->data.setadapterparms.data.change_addr.addr, 4197 card->dev->dev_addr); 4198 rc = qeth_send_ipa_cmd(card, iob, qeth_setadpparms_change_macaddr_cb, 4199 NULL); 4200 return rc; 4201 } 4202 EXPORT_SYMBOL_GPL(qeth_setadpparms_change_macaddr); 4203 4204 static int qeth_setadpparms_set_access_ctrl_cb(struct qeth_card *card, 4205 struct qeth_reply *reply, unsigned long data) 4206 { 4207 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data; 4208 struct qeth_set_access_ctrl *access_ctrl_req; 4209 int fallback = *(int *)reply->param; 4210 4211 QETH_CARD_TEXT(card, 4, "setaccb"); 4212 if (cmd->hdr.return_code) 4213 return -EIO; 4214 qeth_setadpparms_inspect_rc(cmd); 4215 4216 access_ctrl_req = &cmd->data.setadapterparms.data.set_access_ctrl; 4217 QETH_DBF_TEXT_(SETUP, 2, "setaccb"); 4218 QETH_DBF_TEXT_(SETUP, 2, "%s", card->gdev->dev.kobj.name); 4219 QETH_DBF_TEXT_(SETUP, 2, "rc=%d", 4220 cmd->data.setadapterparms.hdr.return_code); 4221 if (cmd->data.setadapterparms.hdr.return_code != 4222 SET_ACCESS_CTRL_RC_SUCCESS) 4223 QETH_DBF_MESSAGE(3, "ERR:SET_ACCESS_CTRL(%#x) on device %x: %#x\n", 4224 access_ctrl_req->subcmd_code, CARD_DEVID(card), 4225 cmd->data.setadapterparms.hdr.return_code); 4226 switch (cmd->data.setadapterparms.hdr.return_code) { 4227 case SET_ACCESS_CTRL_RC_SUCCESS: 4228 if (card->options.isolation == ISOLATION_MODE_NONE) { 4229 dev_info(&card->gdev->dev, 4230 "QDIO data connection isolation is deactivated\n"); 4231 } else { 4232 dev_info(&card->gdev->dev, 4233 "QDIO data connection isolation is activated\n"); 4234 } 4235 break; 4236 case SET_ACCESS_CTRL_RC_ALREADY_NOT_ISOLATED: 4237 QETH_DBF_MESSAGE(2, "QDIO data connection isolation on device %x already deactivated\n", 4238 CARD_DEVID(card)); 4239 if (fallback) 4240 card->options.isolation = card->options.prev_isolation; 4241 break; 4242 case SET_ACCESS_CTRL_RC_ALREADY_ISOLATED: 4243 QETH_DBF_MESSAGE(2, "QDIO data connection isolation on device %x already activated\n", 4244 CARD_DEVID(card)); 4245 if (fallback) 4246 card->options.isolation = card->options.prev_isolation; 4247 break; 4248 case SET_ACCESS_CTRL_RC_NOT_SUPPORTED: 4249 dev_err(&card->gdev->dev, "Adapter does not " 4250 "support QDIO data connection isolation\n"); 4251 break; 4252 case SET_ACCESS_CTRL_RC_NONE_SHARED_ADAPTER: 4253 dev_err(&card->gdev->dev, 4254 "Adapter is dedicated. " 4255 "QDIO data connection isolation not supported\n"); 4256 if (fallback) 4257 card->options.isolation = card->options.prev_isolation; 4258 break; 4259 case SET_ACCESS_CTRL_RC_ACTIVE_CHECKSUM_OFF: 4260 dev_err(&card->gdev->dev, 4261 "TSO does not permit QDIO data connection isolation\n"); 4262 if (fallback) 4263 card->options.isolation = card->options.prev_isolation; 4264 break; 4265 case SET_ACCESS_CTRL_RC_REFLREL_UNSUPPORTED: 4266 dev_err(&card->gdev->dev, "The adjacent switch port does not " 4267 "support reflective relay mode\n"); 4268 if (fallback) 4269 card->options.isolation = card->options.prev_isolation; 4270 break; 4271 case SET_ACCESS_CTRL_RC_REFLREL_FAILED: 4272 dev_err(&card->gdev->dev, "The reflective relay mode cannot be " 4273 "enabled at the adjacent switch port"); 4274 if (fallback) 4275 card->options.isolation = card->options.prev_isolation; 4276 break; 4277 case SET_ACCESS_CTRL_RC_REFLREL_DEACT_FAILED: 4278 dev_warn(&card->gdev->dev, "Turning off reflective relay mode " 4279 "at the adjacent switch failed\n"); 4280 break; 4281 default: 4282 /* this should never happen */ 4283 if (fallback) 4284 card->options.isolation = card->options.prev_isolation; 4285 break; 4286 } 4287 return (cmd->hdr.return_code) ? -EIO : 0; 4288 } 4289 4290 static int qeth_setadpparms_set_access_ctrl(struct qeth_card *card, 4291 enum qeth_ipa_isolation_modes isolation, int fallback) 4292 { 4293 int rc; 4294 struct qeth_cmd_buffer *iob; 4295 struct qeth_ipa_cmd *cmd; 4296 struct qeth_set_access_ctrl *access_ctrl_req; 4297 4298 QETH_CARD_TEXT(card, 4, "setacctl"); 4299 4300 QETH_DBF_TEXT_(SETUP, 2, "setacctl"); 4301 QETH_DBF_TEXT_(SETUP, 2, "%s", card->gdev->dev.kobj.name); 4302 4303 iob = qeth_get_adapter_cmd(card, IPA_SETADP_SET_ACCESS_CONTROL, 4304 sizeof(struct qeth_ipacmd_setadpparms_hdr) + 4305 sizeof(struct qeth_set_access_ctrl)); 4306 if (!iob) 4307 return -ENOMEM; 4308 cmd = __ipa_cmd(iob); 4309 access_ctrl_req = &cmd->data.setadapterparms.data.set_access_ctrl; 4310 access_ctrl_req->subcmd_code = isolation; 4311 4312 rc = qeth_send_ipa_cmd(card, iob, qeth_setadpparms_set_access_ctrl_cb, 4313 &fallback); 4314 QETH_DBF_TEXT_(SETUP, 2, "rc=%d", rc); 4315 return rc; 4316 } 4317 4318 int qeth_set_access_ctrl_online(struct qeth_card *card, int fallback) 4319 { 4320 int rc = 0; 4321 4322 QETH_CARD_TEXT(card, 4, "setactlo"); 4323 4324 if ((card->info.type == QETH_CARD_TYPE_OSD || 4325 card->info.type == QETH_CARD_TYPE_OSX) && 4326 qeth_adp_supported(card, IPA_SETADP_SET_ACCESS_CONTROL)) { 4327 rc = qeth_setadpparms_set_access_ctrl(card, 4328 card->options.isolation, fallback); 4329 if (rc) { 4330 QETH_DBF_MESSAGE(3, "IPA(SET_ACCESS_CTRL(%d) on device %x: sent failed\n", 4331 rc, CARD_DEVID(card)); 4332 rc = -EOPNOTSUPP; 4333 } 4334 } else if (card->options.isolation != ISOLATION_MODE_NONE) { 4335 card->options.isolation = ISOLATION_MODE_NONE; 4336 4337 dev_err(&card->gdev->dev, "Adapter does not " 4338 "support QDIO data connection isolation\n"); 4339 rc = -EOPNOTSUPP; 4340 } 4341 return rc; 4342 } 4343 EXPORT_SYMBOL_GPL(qeth_set_access_ctrl_online); 4344 4345 void qeth_tx_timeout(struct net_device *dev) 4346 { 4347 struct qeth_card *card; 4348 4349 card = dev->ml_priv; 4350 QETH_CARD_TEXT(card, 4, "txtimeo"); 4351 QETH_CARD_STAT_INC(card, tx_errors); 4352 qeth_schedule_recovery(card); 4353 } 4354 EXPORT_SYMBOL_GPL(qeth_tx_timeout); 4355 4356 static int qeth_mdio_read(struct net_device *dev, int phy_id, int regnum) 4357 { 4358 struct qeth_card *card = dev->ml_priv; 4359 int rc = 0; 4360 4361 switch (regnum) { 4362 case MII_BMCR: /* Basic mode control register */ 4363 rc = BMCR_FULLDPLX; 4364 if ((card->info.link_type != QETH_LINK_TYPE_GBIT_ETH) && 4365 (card->info.link_type != QETH_LINK_TYPE_OSN) && 4366 (card->info.link_type != QETH_LINK_TYPE_10GBIT_ETH) && 4367 (card->info.link_type != QETH_LINK_TYPE_25GBIT_ETH)) 4368 rc |= BMCR_SPEED100; 4369 break; 4370 case MII_BMSR: /* Basic mode status register */ 4371 rc = BMSR_ERCAP | BMSR_ANEGCOMPLETE | BMSR_LSTATUS | 4372 BMSR_10HALF | BMSR_10FULL | BMSR_100HALF | BMSR_100FULL | 4373 BMSR_100BASE4; 4374 break; 4375 case MII_PHYSID1: /* PHYS ID 1 */ 4376 rc = (dev->dev_addr[0] << 16) | (dev->dev_addr[1] << 8) | 4377 dev->dev_addr[2]; 4378 rc = (rc >> 5) & 0xFFFF; 4379 break; 4380 case MII_PHYSID2: /* PHYS ID 2 */ 4381 rc = (dev->dev_addr[2] << 10) & 0xFFFF; 4382 break; 4383 case MII_ADVERTISE: /* Advertisement control reg */ 4384 rc = ADVERTISE_ALL; 4385 break; 4386 case MII_LPA: /* Link partner ability reg */ 4387 rc = LPA_10HALF | LPA_10FULL | LPA_100HALF | LPA_100FULL | 4388 LPA_100BASE4 | LPA_LPACK; 4389 break; 4390 case MII_EXPANSION: /* Expansion register */ 4391 break; 4392 case MII_DCOUNTER: /* disconnect counter */ 4393 break; 4394 case MII_FCSCOUNTER: /* false carrier counter */ 4395 break; 4396 case MII_NWAYTEST: /* N-way auto-neg test register */ 4397 break; 4398 case MII_RERRCOUNTER: /* rx error counter */ 4399 rc = card->stats.rx_errors; 4400 break; 4401 case MII_SREVISION: /* silicon revision */ 4402 break; 4403 case MII_RESV1: /* reserved 1 */ 4404 break; 4405 case MII_LBRERROR: /* loopback, rx, bypass error */ 4406 break; 4407 case MII_PHYADDR: /* physical address */ 4408 break; 4409 case MII_RESV2: /* reserved 2 */ 4410 break; 4411 case MII_TPISTATUS: /* TPI status for 10mbps */ 4412 break; 4413 case MII_NCONFIG: /* network interface config */ 4414 break; 4415 default: 4416 break; 4417 } 4418 return rc; 4419 } 4420 4421 static int qeth_snmp_command_cb(struct qeth_card *card, 4422 struct qeth_reply *reply, unsigned long sdata) 4423 { 4424 struct qeth_ipa_cmd *cmd; 4425 struct qeth_arp_query_info *qinfo; 4426 unsigned char *data; 4427 void *snmp_data; 4428 __u16 data_len; 4429 4430 QETH_CARD_TEXT(card, 3, "snpcmdcb"); 4431 4432 cmd = (struct qeth_ipa_cmd *) sdata; 4433 data = (unsigned char *)((char *)cmd - reply->offset); 4434 qinfo = (struct qeth_arp_query_info *) reply->param; 4435 4436 if (cmd->hdr.return_code) { 4437 QETH_CARD_TEXT_(card, 4, "scer1%x", cmd->hdr.return_code); 4438 return -EIO; 4439 } 4440 if (cmd->data.setadapterparms.hdr.return_code) { 4441 cmd->hdr.return_code = 4442 cmd->data.setadapterparms.hdr.return_code; 4443 QETH_CARD_TEXT_(card, 4, "scer2%x", cmd->hdr.return_code); 4444 return -EIO; 4445 } 4446 data_len = *((__u16 *)QETH_IPA_PDU_LEN_PDU1(data)); 4447 if (cmd->data.setadapterparms.hdr.seq_no == 1) { 4448 snmp_data = &cmd->data.setadapterparms.data.snmp; 4449 data_len -= offsetof(struct qeth_ipa_cmd, 4450 data.setadapterparms.data.snmp); 4451 } else { 4452 snmp_data = &cmd->data.setadapterparms.data.snmp.request; 4453 data_len -= offsetof(struct qeth_ipa_cmd, 4454 data.setadapterparms.data.snmp.request); 4455 } 4456 4457 /* check if there is enough room in userspace */ 4458 if ((qinfo->udata_len - qinfo->udata_offset) < data_len) { 4459 QETH_CARD_TEXT_(card, 4, "scer3%i", -ENOSPC); 4460 return -ENOSPC; 4461 } 4462 QETH_CARD_TEXT_(card, 4, "snore%i", 4463 cmd->data.setadapterparms.hdr.used_total); 4464 QETH_CARD_TEXT_(card, 4, "sseqn%i", 4465 cmd->data.setadapterparms.hdr.seq_no); 4466 /*copy entries to user buffer*/ 4467 memcpy(qinfo->udata + qinfo->udata_offset, snmp_data, data_len); 4468 qinfo->udata_offset += data_len; 4469 4470 /* check if all replies received ... */ 4471 QETH_CARD_TEXT_(card, 4, "srtot%i", 4472 cmd->data.setadapterparms.hdr.used_total); 4473 QETH_CARD_TEXT_(card, 4, "srseq%i", 4474 cmd->data.setadapterparms.hdr.seq_no); 4475 if (cmd->data.setadapterparms.hdr.seq_no < 4476 cmd->data.setadapterparms.hdr.used_total) 4477 return 1; 4478 return 0; 4479 } 4480 4481 static int qeth_snmp_command(struct qeth_card *card, char __user *udata) 4482 { 4483 struct qeth_cmd_buffer *iob; 4484 struct qeth_ipa_cmd *cmd; 4485 struct qeth_snmp_ureq *ureq; 4486 unsigned int req_len; 4487 struct qeth_arp_query_info qinfo = {0, }; 4488 int rc = 0; 4489 4490 QETH_CARD_TEXT(card, 3, "snmpcmd"); 4491 4492 if (card->info.guestlan) 4493 return -EOPNOTSUPP; 4494 4495 if ((!qeth_adp_supported(card, IPA_SETADP_SET_SNMP_CONTROL)) && 4496 IS_LAYER3(card)) 4497 return -EOPNOTSUPP; 4498 4499 /* skip 4 bytes (data_len struct member) to get req_len */ 4500 if (copy_from_user(&req_len, udata + sizeof(int), sizeof(int))) 4501 return -EFAULT; 4502 if (req_len > (QETH_BUFSIZE - IPA_PDU_HEADER_SIZE - 4503 sizeof(struct qeth_ipacmd_hdr) - 4504 sizeof(struct qeth_ipacmd_setadpparms_hdr))) 4505 return -EINVAL; 4506 ureq = memdup_user(udata, req_len + sizeof(struct qeth_snmp_ureq_hdr)); 4507 if (IS_ERR(ureq)) { 4508 QETH_CARD_TEXT(card, 2, "snmpnome"); 4509 return PTR_ERR(ureq); 4510 } 4511 qinfo.udata_len = ureq->hdr.data_len; 4512 qinfo.udata = kzalloc(qinfo.udata_len, GFP_KERNEL); 4513 if (!qinfo.udata) { 4514 kfree(ureq); 4515 return -ENOMEM; 4516 } 4517 qinfo.udata_offset = sizeof(struct qeth_snmp_ureq_hdr); 4518 4519 iob = qeth_get_adapter_cmd(card, IPA_SETADP_SET_SNMP_CONTROL, 4520 QETH_SNMP_SETADP_CMDLENGTH + req_len); 4521 if (!iob) { 4522 rc = -ENOMEM; 4523 goto out; 4524 } 4525 4526 /* for large requests, fix-up the length fields: */ 4527 qeth_prepare_ipa_cmd(card, iob, QETH_SETADP_BASE_LEN + req_len); 4528 4529 cmd = __ipa_cmd(iob); 4530 memcpy(&cmd->data.setadapterparms.data.snmp, &ureq->cmd, req_len); 4531 rc = qeth_send_ipa_cmd(card, iob, qeth_snmp_command_cb, &qinfo); 4532 if (rc) 4533 QETH_DBF_MESSAGE(2, "SNMP command failed on device %x: (%#x)\n", 4534 CARD_DEVID(card), rc); 4535 else { 4536 if (copy_to_user(udata, qinfo.udata, qinfo.udata_len)) 4537 rc = -EFAULT; 4538 } 4539 out: 4540 kfree(ureq); 4541 kfree(qinfo.udata); 4542 return rc; 4543 } 4544 4545 static int qeth_setadpparms_query_oat_cb(struct qeth_card *card, 4546 struct qeth_reply *reply, unsigned long data) 4547 { 4548 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *)data; 4549 struct qeth_qoat_priv *priv; 4550 char *resdata; 4551 int resdatalen; 4552 4553 QETH_CARD_TEXT(card, 3, "qoatcb"); 4554 if (qeth_setadpparms_inspect_rc(cmd)) 4555 return -EIO; 4556 4557 priv = (struct qeth_qoat_priv *)reply->param; 4558 resdatalen = cmd->data.setadapterparms.hdr.cmdlength; 4559 resdata = (char *)data + 28; 4560 4561 if (resdatalen > (priv->buffer_len - priv->response_len)) 4562 return -ENOSPC; 4563 4564 memcpy((priv->buffer + priv->response_len), resdata, 4565 resdatalen); 4566 priv->response_len += resdatalen; 4567 4568 if (cmd->data.setadapterparms.hdr.seq_no < 4569 cmd->data.setadapterparms.hdr.used_total) 4570 return 1; 4571 return 0; 4572 } 4573 4574 static int qeth_query_oat_command(struct qeth_card *card, char __user *udata) 4575 { 4576 int rc = 0; 4577 struct qeth_cmd_buffer *iob; 4578 struct qeth_ipa_cmd *cmd; 4579 struct qeth_query_oat *oat_req; 4580 struct qeth_query_oat_data oat_data; 4581 struct qeth_qoat_priv priv; 4582 void __user *tmp; 4583 4584 QETH_CARD_TEXT(card, 3, "qoatcmd"); 4585 4586 if (!qeth_adp_supported(card, IPA_SETADP_QUERY_OAT)) { 4587 rc = -EOPNOTSUPP; 4588 goto out; 4589 } 4590 4591 if (copy_from_user(&oat_data, udata, 4592 sizeof(struct qeth_query_oat_data))) { 4593 rc = -EFAULT; 4594 goto out; 4595 } 4596 4597 priv.buffer_len = oat_data.buffer_len; 4598 priv.response_len = 0; 4599 priv.buffer = vzalloc(oat_data.buffer_len); 4600 if (!priv.buffer) { 4601 rc = -ENOMEM; 4602 goto out; 4603 } 4604 4605 iob = qeth_get_adapter_cmd(card, IPA_SETADP_QUERY_OAT, 4606 sizeof(struct qeth_ipacmd_setadpparms_hdr) + 4607 sizeof(struct qeth_query_oat)); 4608 if (!iob) { 4609 rc = -ENOMEM; 4610 goto out_free; 4611 } 4612 cmd = __ipa_cmd(iob); 4613 oat_req = &cmd->data.setadapterparms.data.query_oat; 4614 oat_req->subcmd_code = oat_data.command; 4615 4616 rc = qeth_send_ipa_cmd(card, iob, qeth_setadpparms_query_oat_cb, 4617 &priv); 4618 if (!rc) { 4619 if (is_compat_task()) 4620 tmp = compat_ptr(oat_data.ptr); 4621 else 4622 tmp = (void __user *)(unsigned long)oat_data.ptr; 4623 4624 if (copy_to_user(tmp, priv.buffer, 4625 priv.response_len)) { 4626 rc = -EFAULT; 4627 goto out_free; 4628 } 4629 4630 oat_data.response_len = priv.response_len; 4631 4632 if (copy_to_user(udata, &oat_data, 4633 sizeof(struct qeth_query_oat_data))) 4634 rc = -EFAULT; 4635 } 4636 4637 out_free: 4638 vfree(priv.buffer); 4639 out: 4640 return rc; 4641 } 4642 4643 static int qeth_query_card_info_cb(struct qeth_card *card, 4644 struct qeth_reply *reply, unsigned long data) 4645 { 4646 struct carrier_info *carrier_info = (struct carrier_info *)reply->param; 4647 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *)data; 4648 struct qeth_query_card_info *card_info; 4649 4650 QETH_CARD_TEXT(card, 2, "qcrdincb"); 4651 if (qeth_setadpparms_inspect_rc(cmd)) 4652 return -EIO; 4653 4654 card_info = &cmd->data.setadapterparms.data.card_info; 4655 carrier_info->card_type = card_info->card_type; 4656 carrier_info->port_mode = card_info->port_mode; 4657 carrier_info->port_speed = card_info->port_speed; 4658 return 0; 4659 } 4660 4661 int qeth_query_card_info(struct qeth_card *card, 4662 struct carrier_info *carrier_info) 4663 { 4664 struct qeth_cmd_buffer *iob; 4665 4666 QETH_CARD_TEXT(card, 2, "qcrdinfo"); 4667 if (!qeth_adp_supported(card, IPA_SETADP_QUERY_CARD_INFO)) 4668 return -EOPNOTSUPP; 4669 iob = qeth_get_adapter_cmd(card, IPA_SETADP_QUERY_CARD_INFO, 4670 sizeof(struct qeth_ipacmd_setadpparms_hdr)); 4671 if (!iob) 4672 return -ENOMEM; 4673 return qeth_send_ipa_cmd(card, iob, qeth_query_card_info_cb, 4674 (void *)carrier_info); 4675 } 4676 4677 /** 4678 * qeth_vm_request_mac() - Request a hypervisor-managed MAC address 4679 * @card: pointer to a qeth_card 4680 * 4681 * Returns 4682 * 0, if a MAC address has been set for the card's netdevice 4683 * a return code, for various error conditions 4684 */ 4685 int qeth_vm_request_mac(struct qeth_card *card) 4686 { 4687 struct diag26c_mac_resp *response; 4688 struct diag26c_mac_req *request; 4689 struct ccw_dev_id id; 4690 int rc; 4691 4692 QETH_DBF_TEXT(SETUP, 2, "vmreqmac"); 4693 4694 request = kzalloc(sizeof(*request), GFP_KERNEL | GFP_DMA); 4695 response = kzalloc(sizeof(*response), GFP_KERNEL | GFP_DMA); 4696 if (!request || !response) { 4697 rc = -ENOMEM; 4698 goto out; 4699 } 4700 4701 ccw_device_get_id(CARD_DDEV(card), &id); 4702 request->resp_buf_len = sizeof(*response); 4703 request->resp_version = DIAG26C_VERSION2; 4704 request->op_code = DIAG26C_GET_MAC; 4705 request->devno = id.devno; 4706 4707 QETH_DBF_HEX(CTRL, 2, request, sizeof(*request)); 4708 rc = diag26c(request, response, DIAG26C_MAC_SERVICES); 4709 QETH_DBF_HEX(CTRL, 2, request, sizeof(*request)); 4710 if (rc) 4711 goto out; 4712 QETH_DBF_HEX(CTRL, 2, response, sizeof(*response)); 4713 4714 if (request->resp_buf_len < sizeof(*response) || 4715 response->version != request->resp_version) { 4716 rc = -EIO; 4717 QETH_DBF_TEXT(SETUP, 2, "badresp"); 4718 QETH_DBF_HEX(SETUP, 2, &request->resp_buf_len, 4719 sizeof(request->resp_buf_len)); 4720 } else if (!is_valid_ether_addr(response->mac)) { 4721 rc = -EINVAL; 4722 QETH_DBF_TEXT(SETUP, 2, "badmac"); 4723 QETH_DBF_HEX(SETUP, 2, response->mac, ETH_ALEN); 4724 } else { 4725 ether_addr_copy(card->dev->dev_addr, response->mac); 4726 } 4727 4728 out: 4729 kfree(response); 4730 kfree(request); 4731 return rc; 4732 } 4733 EXPORT_SYMBOL_GPL(qeth_vm_request_mac); 4734 4735 static int qeth_get_qdio_q_format(struct qeth_card *card) 4736 { 4737 if (card->info.type == QETH_CARD_TYPE_IQD) 4738 return QDIO_IQDIO_QFMT; 4739 else 4740 return QDIO_QETH_QFMT; 4741 } 4742 4743 static void qeth_determine_capabilities(struct qeth_card *card) 4744 { 4745 int rc; 4746 int length; 4747 char *prcd; 4748 struct ccw_device *ddev; 4749 int ddev_offline = 0; 4750 4751 QETH_DBF_TEXT(SETUP, 2, "detcapab"); 4752 ddev = CARD_DDEV(card); 4753 if (!ddev->online) { 4754 ddev_offline = 1; 4755 rc = ccw_device_set_online(ddev); 4756 if (rc) { 4757 QETH_DBF_TEXT_(SETUP, 2, "3err%d", rc); 4758 goto out; 4759 } 4760 } 4761 4762 rc = qeth_read_conf_data(card, (void **) &prcd, &length); 4763 if (rc) { 4764 QETH_DBF_MESSAGE(2, "qeth_read_conf_data on device %x returned %i\n", 4765 CARD_DEVID(card), rc); 4766 QETH_DBF_TEXT_(SETUP, 2, "5err%d", rc); 4767 goto out_offline; 4768 } 4769 qeth_configure_unitaddr(card, prcd); 4770 if (ddev_offline) 4771 qeth_configure_blkt_default(card, prcd); 4772 kfree(prcd); 4773 4774 rc = qdio_get_ssqd_desc(ddev, &card->ssqd); 4775 if (rc) 4776 QETH_DBF_TEXT_(SETUP, 2, "6err%d", rc); 4777 4778 QETH_DBF_TEXT_(SETUP, 2, "qfmt%d", card->ssqd.qfmt); 4779 QETH_DBF_TEXT_(SETUP, 2, "ac1:%02x", card->ssqd.qdioac1); 4780 QETH_DBF_TEXT_(SETUP, 2, "ac2:%04x", card->ssqd.qdioac2); 4781 QETH_DBF_TEXT_(SETUP, 2, "ac3:%04x", card->ssqd.qdioac3); 4782 QETH_DBF_TEXT_(SETUP, 2, "icnt%d", card->ssqd.icnt); 4783 if (!((card->ssqd.qfmt != QDIO_IQDIO_QFMT) || 4784 ((card->ssqd.qdioac1 & CHSC_AC1_INITIATE_INPUTQ) == 0) || 4785 ((card->ssqd.qdioac3 & CHSC_AC3_FORMAT2_CQ_AVAILABLE) == 0))) { 4786 dev_info(&card->gdev->dev, 4787 "Completion Queueing supported\n"); 4788 } else { 4789 card->options.cq = QETH_CQ_NOTAVAILABLE; 4790 } 4791 4792 4793 out_offline: 4794 if (ddev_offline == 1) 4795 ccw_device_set_offline(ddev); 4796 out: 4797 return; 4798 } 4799 4800 static void qeth_qdio_establish_cq(struct qeth_card *card, 4801 struct qdio_buffer **in_sbal_ptrs, 4802 void (**queue_start_poll) 4803 (struct ccw_device *, int, 4804 unsigned long)) 4805 { 4806 int i; 4807 4808 if (card->options.cq == QETH_CQ_ENABLED) { 4809 int offset = QDIO_MAX_BUFFERS_PER_Q * 4810 (card->qdio.no_in_queues - 1); 4811 for (i = 0; i < QDIO_MAX_BUFFERS_PER_Q; ++i) { 4812 in_sbal_ptrs[offset + i] = (struct qdio_buffer *) 4813 virt_to_phys(card->qdio.c_q->bufs[i].buffer); 4814 } 4815 4816 queue_start_poll[card->qdio.no_in_queues - 1] = NULL; 4817 } 4818 } 4819 4820 static int qeth_qdio_establish(struct qeth_card *card) 4821 { 4822 struct qdio_initialize init_data; 4823 char *qib_param_field; 4824 struct qdio_buffer **in_sbal_ptrs; 4825 void (**queue_start_poll) (struct ccw_device *, int, unsigned long); 4826 struct qdio_buffer **out_sbal_ptrs; 4827 int i, j, k; 4828 int rc = 0; 4829 4830 QETH_DBF_TEXT(SETUP, 2, "qdioest"); 4831 4832 qib_param_field = kzalloc(QDIO_MAX_BUFFERS_PER_Q, 4833 GFP_KERNEL); 4834 if (!qib_param_field) { 4835 rc = -ENOMEM; 4836 goto out_free_nothing; 4837 } 4838 4839 qeth_create_qib_param_field(card, qib_param_field); 4840 qeth_create_qib_param_field_blkt(card, qib_param_field); 4841 4842 in_sbal_ptrs = kcalloc(card->qdio.no_in_queues * QDIO_MAX_BUFFERS_PER_Q, 4843 sizeof(void *), 4844 GFP_KERNEL); 4845 if (!in_sbal_ptrs) { 4846 rc = -ENOMEM; 4847 goto out_free_qib_param; 4848 } 4849 for (i = 0; i < QDIO_MAX_BUFFERS_PER_Q; ++i) { 4850 in_sbal_ptrs[i] = (struct qdio_buffer *) 4851 virt_to_phys(card->qdio.in_q->bufs[i].buffer); 4852 } 4853 4854 queue_start_poll = kcalloc(card->qdio.no_in_queues, sizeof(void *), 4855 GFP_KERNEL); 4856 if (!queue_start_poll) { 4857 rc = -ENOMEM; 4858 goto out_free_in_sbals; 4859 } 4860 for (i = 0; i < card->qdio.no_in_queues; ++i) 4861 queue_start_poll[i] = qeth_qdio_start_poll; 4862 4863 qeth_qdio_establish_cq(card, in_sbal_ptrs, queue_start_poll); 4864 4865 out_sbal_ptrs = 4866 kcalloc(card->qdio.no_out_queues * QDIO_MAX_BUFFERS_PER_Q, 4867 sizeof(void *), 4868 GFP_KERNEL); 4869 if (!out_sbal_ptrs) { 4870 rc = -ENOMEM; 4871 goto out_free_queue_start_poll; 4872 } 4873 for (i = 0, k = 0; i < card->qdio.no_out_queues; ++i) 4874 for (j = 0; j < QDIO_MAX_BUFFERS_PER_Q; ++j, ++k) { 4875 out_sbal_ptrs[k] = (struct qdio_buffer *)virt_to_phys( 4876 card->qdio.out_qs[i]->bufs[j]->buffer); 4877 } 4878 4879 memset(&init_data, 0, sizeof(struct qdio_initialize)); 4880 init_data.cdev = CARD_DDEV(card); 4881 init_data.q_format = qeth_get_qdio_q_format(card); 4882 init_data.qib_param_field_format = 0; 4883 init_data.qib_param_field = qib_param_field; 4884 init_data.no_input_qs = card->qdio.no_in_queues; 4885 init_data.no_output_qs = card->qdio.no_out_queues; 4886 init_data.input_handler = qeth_qdio_input_handler; 4887 init_data.output_handler = qeth_qdio_output_handler; 4888 init_data.queue_start_poll_array = queue_start_poll; 4889 init_data.int_parm = (unsigned long) card; 4890 init_data.input_sbal_addr_array = in_sbal_ptrs; 4891 init_data.output_sbal_addr_array = out_sbal_ptrs; 4892 init_data.output_sbal_state_array = card->qdio.out_bufstates; 4893 init_data.scan_threshold = 4894 (card->info.type == QETH_CARD_TYPE_IQD) ? 1 : 32; 4895 4896 if (atomic_cmpxchg(&card->qdio.state, QETH_QDIO_ALLOCATED, 4897 QETH_QDIO_ESTABLISHED) == QETH_QDIO_ALLOCATED) { 4898 rc = qdio_allocate(&init_data); 4899 if (rc) { 4900 atomic_set(&card->qdio.state, QETH_QDIO_ALLOCATED); 4901 goto out; 4902 } 4903 rc = qdio_establish(&init_data); 4904 if (rc) { 4905 atomic_set(&card->qdio.state, QETH_QDIO_ALLOCATED); 4906 qdio_free(CARD_DDEV(card)); 4907 } 4908 } 4909 4910 switch (card->options.cq) { 4911 case QETH_CQ_ENABLED: 4912 dev_info(&card->gdev->dev, "Completion Queue support enabled"); 4913 break; 4914 case QETH_CQ_DISABLED: 4915 dev_info(&card->gdev->dev, "Completion Queue support disabled"); 4916 break; 4917 default: 4918 break; 4919 } 4920 out: 4921 kfree(out_sbal_ptrs); 4922 out_free_queue_start_poll: 4923 kfree(queue_start_poll); 4924 out_free_in_sbals: 4925 kfree(in_sbal_ptrs); 4926 out_free_qib_param: 4927 kfree(qib_param_field); 4928 out_free_nothing: 4929 return rc; 4930 } 4931 4932 static void qeth_core_free_card(struct qeth_card *card) 4933 { 4934 QETH_DBF_TEXT(SETUP, 2, "freecrd"); 4935 QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *)); 4936 qeth_clean_channel(&card->read); 4937 qeth_clean_channel(&card->write); 4938 qeth_clean_channel(&card->data); 4939 destroy_workqueue(card->event_wq); 4940 qeth_free_qdio_buffers(card); 4941 unregister_service_level(&card->qeth_service_level); 4942 dev_set_drvdata(&card->gdev->dev, NULL); 4943 kfree(card); 4944 } 4945 4946 void qeth_trace_features(struct qeth_card *card) 4947 { 4948 QETH_CARD_TEXT(card, 2, "features"); 4949 QETH_CARD_HEX(card, 2, &card->options.ipa4, sizeof(card->options.ipa4)); 4950 QETH_CARD_HEX(card, 2, &card->options.ipa6, sizeof(card->options.ipa6)); 4951 QETH_CARD_HEX(card, 2, &card->options.adp, sizeof(card->options.adp)); 4952 QETH_CARD_HEX(card, 2, &card->info.diagass_support, 4953 sizeof(card->info.diagass_support)); 4954 } 4955 EXPORT_SYMBOL_GPL(qeth_trace_features); 4956 4957 static struct ccw_device_id qeth_ids[] = { 4958 {CCW_DEVICE_DEVTYPE(0x1731, 0x01, 0x1732, 0x01), 4959 .driver_info = QETH_CARD_TYPE_OSD}, 4960 {CCW_DEVICE_DEVTYPE(0x1731, 0x05, 0x1732, 0x05), 4961 .driver_info = QETH_CARD_TYPE_IQD}, 4962 {CCW_DEVICE_DEVTYPE(0x1731, 0x06, 0x1732, 0x06), 4963 .driver_info = QETH_CARD_TYPE_OSN}, 4964 {CCW_DEVICE_DEVTYPE(0x1731, 0x02, 0x1732, 0x03), 4965 .driver_info = QETH_CARD_TYPE_OSM}, 4966 {CCW_DEVICE_DEVTYPE(0x1731, 0x02, 0x1732, 0x02), 4967 .driver_info = QETH_CARD_TYPE_OSX}, 4968 {}, 4969 }; 4970 MODULE_DEVICE_TABLE(ccw, qeth_ids); 4971 4972 static struct ccw_driver qeth_ccw_driver = { 4973 .driver = { 4974 .owner = THIS_MODULE, 4975 .name = "qeth", 4976 }, 4977 .ids = qeth_ids, 4978 .probe = ccwgroup_probe_ccwdev, 4979 .remove = ccwgroup_remove_ccwdev, 4980 }; 4981 4982 int qeth_core_hardsetup_card(struct qeth_card *card, bool *carrier_ok) 4983 { 4984 int retries = 3; 4985 int rc; 4986 4987 QETH_DBF_TEXT(SETUP, 2, "hrdsetup"); 4988 atomic_set(&card->force_alloc_skb, 0); 4989 qeth_update_from_chp_desc(card); 4990 retry: 4991 if (retries < 3) 4992 QETH_DBF_MESSAGE(2, "Retrying to do IDX activates on device %x.\n", 4993 CARD_DEVID(card)); 4994 rc = qeth_qdio_clear_card(card, card->info.type != QETH_CARD_TYPE_IQD); 4995 ccw_device_set_offline(CARD_DDEV(card)); 4996 ccw_device_set_offline(CARD_WDEV(card)); 4997 ccw_device_set_offline(CARD_RDEV(card)); 4998 qdio_free(CARD_DDEV(card)); 4999 rc = ccw_device_set_online(CARD_RDEV(card)); 5000 if (rc) 5001 goto retriable; 5002 rc = ccw_device_set_online(CARD_WDEV(card)); 5003 if (rc) 5004 goto retriable; 5005 rc = ccw_device_set_online(CARD_DDEV(card)); 5006 if (rc) 5007 goto retriable; 5008 retriable: 5009 if (rc == -ERESTARTSYS) { 5010 QETH_DBF_TEXT(SETUP, 2, "break1"); 5011 return rc; 5012 } else if (rc) { 5013 QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc); 5014 if (--retries < 0) 5015 goto out; 5016 else 5017 goto retry; 5018 } 5019 qeth_determine_capabilities(card); 5020 qeth_init_tokens(card); 5021 qeth_init_func_level(card); 5022 rc = qeth_idx_activate_channel(card, &card->read, qeth_idx_read_cb); 5023 if (rc == -ERESTARTSYS) { 5024 QETH_DBF_TEXT(SETUP, 2, "break2"); 5025 return rc; 5026 } else if (rc) { 5027 QETH_DBF_TEXT_(SETUP, 2, "3err%d", rc); 5028 if (--retries < 0) 5029 goto out; 5030 else 5031 goto retry; 5032 } 5033 rc = qeth_idx_activate_channel(card, &card->write, qeth_idx_write_cb); 5034 if (rc == -ERESTARTSYS) { 5035 QETH_DBF_TEXT(SETUP, 2, "break3"); 5036 return rc; 5037 } else if (rc) { 5038 QETH_DBF_TEXT_(SETUP, 2, "4err%d", rc); 5039 if (--retries < 0) 5040 goto out; 5041 else 5042 goto retry; 5043 } 5044 card->read_or_write_problem = 0; 5045 rc = qeth_mpc_initialize(card); 5046 if (rc) { 5047 QETH_DBF_TEXT_(SETUP, 2, "5err%d", rc); 5048 goto out; 5049 } 5050 5051 rc = qeth_send_startlan(card); 5052 if (rc) { 5053 QETH_DBF_TEXT_(SETUP, 2, "6err%d", rc); 5054 if (rc == -ENETDOWN) { 5055 dev_warn(&card->gdev->dev, "The LAN is offline\n"); 5056 *carrier_ok = false; 5057 } else { 5058 goto out; 5059 } 5060 } else { 5061 *carrier_ok = true; 5062 } 5063 5064 card->options.ipa4.supported_funcs = 0; 5065 card->options.ipa6.supported_funcs = 0; 5066 card->options.adp.supported_funcs = 0; 5067 card->options.sbp.supported_funcs = 0; 5068 card->info.diagass_support = 0; 5069 rc = qeth_query_ipassists(card, QETH_PROT_IPV4); 5070 if (rc == -ENOMEM) 5071 goto out; 5072 if (qeth_is_supported(card, IPA_IPV6)) { 5073 rc = qeth_query_ipassists(card, QETH_PROT_IPV6); 5074 if (rc == -ENOMEM) 5075 goto out; 5076 } 5077 if (qeth_is_supported(card, IPA_SETADAPTERPARMS)) { 5078 rc = qeth_query_setadapterparms(card); 5079 if (rc < 0) { 5080 QETH_DBF_TEXT_(SETUP, 2, "7err%d", rc); 5081 goto out; 5082 } 5083 } 5084 if (qeth_adp_supported(card, IPA_SETADP_SET_DIAG_ASSIST)) { 5085 rc = qeth_query_setdiagass(card); 5086 if (rc < 0) { 5087 QETH_DBF_TEXT_(SETUP, 2, "8err%d", rc); 5088 goto out; 5089 } 5090 } 5091 return 0; 5092 out: 5093 dev_warn(&card->gdev->dev, "The qeth device driver failed to recover " 5094 "an error on the device\n"); 5095 QETH_DBF_MESSAGE(2, "Initialization for device %x failed in hardsetup! rc=%d\n", 5096 CARD_DEVID(card), rc); 5097 return rc; 5098 } 5099 EXPORT_SYMBOL_GPL(qeth_core_hardsetup_card); 5100 5101 static void qeth_create_skb_frag(struct qdio_buffer_element *element, 5102 struct sk_buff *skb, int offset, int data_len) 5103 { 5104 struct page *page = virt_to_page(element->addr); 5105 unsigned int next_frag; 5106 5107 /* first fill the linear space */ 5108 if (!skb->len) { 5109 unsigned int linear = min(data_len, skb_tailroom(skb)); 5110 5111 skb_put_data(skb, element->addr + offset, linear); 5112 data_len -= linear; 5113 if (!data_len) 5114 return; 5115 offset += linear; 5116 /* fall through to add page frag for remaining data */ 5117 } 5118 5119 next_frag = skb_shinfo(skb)->nr_frags; 5120 get_page(page); 5121 skb_add_rx_frag(skb, next_frag, page, offset, data_len, data_len); 5122 } 5123 5124 static inline int qeth_is_last_sbale(struct qdio_buffer_element *sbale) 5125 { 5126 return (sbale->eflags & SBAL_EFLAGS_LAST_ENTRY); 5127 } 5128 5129 struct sk_buff *qeth_core_get_next_skb(struct qeth_card *card, 5130 struct qeth_qdio_buffer *qethbuffer, 5131 struct qdio_buffer_element **__element, int *__offset, 5132 struct qeth_hdr **hdr) 5133 { 5134 struct qdio_buffer_element *element = *__element; 5135 struct qdio_buffer *buffer = qethbuffer->buffer; 5136 int offset = *__offset; 5137 struct sk_buff *skb; 5138 int skb_len = 0; 5139 void *data_ptr; 5140 int data_len; 5141 int headroom = 0; 5142 int use_rx_sg = 0; 5143 5144 /* qeth_hdr must not cross element boundaries */ 5145 while (element->length < offset + sizeof(struct qeth_hdr)) { 5146 if (qeth_is_last_sbale(element)) 5147 return NULL; 5148 element++; 5149 offset = 0; 5150 } 5151 *hdr = element->addr + offset; 5152 5153 offset += sizeof(struct qeth_hdr); 5154 switch ((*hdr)->hdr.l2.id) { 5155 case QETH_HEADER_TYPE_LAYER2: 5156 skb_len = (*hdr)->hdr.l2.pkt_length; 5157 break; 5158 case QETH_HEADER_TYPE_LAYER3: 5159 skb_len = (*hdr)->hdr.l3.length; 5160 headroom = ETH_HLEN; 5161 break; 5162 case QETH_HEADER_TYPE_OSN: 5163 skb_len = (*hdr)->hdr.osn.pdu_length; 5164 headroom = sizeof(struct qeth_hdr); 5165 break; 5166 default: 5167 break; 5168 } 5169 5170 if (!skb_len) 5171 return NULL; 5172 5173 if (((skb_len >= card->options.rx_sg_cb) && 5174 (!(card->info.type == QETH_CARD_TYPE_OSN)) && 5175 (!atomic_read(&card->force_alloc_skb))) || 5176 (card->options.cq == QETH_CQ_ENABLED)) 5177 use_rx_sg = 1; 5178 5179 if (use_rx_sg && qethbuffer->rx_skb) { 5180 /* QETH_CQ_ENABLED only: */ 5181 skb = qethbuffer->rx_skb; 5182 qethbuffer->rx_skb = NULL; 5183 } else { 5184 unsigned int linear = (use_rx_sg) ? QETH_RX_PULL_LEN : skb_len; 5185 5186 skb = napi_alloc_skb(&card->napi, linear + headroom); 5187 } 5188 if (!skb) 5189 goto no_mem; 5190 if (headroom) 5191 skb_reserve(skb, headroom); 5192 5193 data_ptr = element->addr + offset; 5194 while (skb_len) { 5195 data_len = min(skb_len, (int)(element->length - offset)); 5196 if (data_len) { 5197 if (use_rx_sg) 5198 qeth_create_skb_frag(element, skb, offset, 5199 data_len); 5200 else 5201 skb_put_data(skb, data_ptr, data_len); 5202 } 5203 skb_len -= data_len; 5204 if (skb_len) { 5205 if (qeth_is_last_sbale(element)) { 5206 QETH_CARD_TEXT(card, 4, "unexeob"); 5207 QETH_CARD_HEX(card, 2, buffer, sizeof(void *)); 5208 dev_kfree_skb_any(skb); 5209 QETH_CARD_STAT_INC(card, rx_errors); 5210 return NULL; 5211 } 5212 element++; 5213 offset = 0; 5214 data_ptr = element->addr; 5215 } else { 5216 offset += data_len; 5217 } 5218 } 5219 *__element = element; 5220 *__offset = offset; 5221 if (use_rx_sg) { 5222 QETH_CARD_STAT_INC(card, rx_sg_skbs); 5223 QETH_CARD_STAT_ADD(card, rx_sg_frags, 5224 skb_shinfo(skb)->nr_frags); 5225 } 5226 return skb; 5227 no_mem: 5228 if (net_ratelimit()) { 5229 QETH_CARD_TEXT(card, 2, "noskbmem"); 5230 } 5231 QETH_CARD_STAT_INC(card, rx_dropped); 5232 return NULL; 5233 } 5234 EXPORT_SYMBOL_GPL(qeth_core_get_next_skb); 5235 5236 int qeth_poll(struct napi_struct *napi, int budget) 5237 { 5238 struct qeth_card *card = container_of(napi, struct qeth_card, napi); 5239 int work_done = 0; 5240 struct qeth_qdio_buffer *buffer; 5241 int done; 5242 int new_budget = budget; 5243 5244 while (1) { 5245 if (!card->rx.b_count) { 5246 card->rx.qdio_err = 0; 5247 card->rx.b_count = qdio_get_next_buffers( 5248 card->data.ccwdev, 0, &card->rx.b_index, 5249 &card->rx.qdio_err); 5250 if (card->rx.b_count <= 0) { 5251 card->rx.b_count = 0; 5252 break; 5253 } 5254 card->rx.b_element = 5255 &card->qdio.in_q->bufs[card->rx.b_index] 5256 .buffer->element[0]; 5257 card->rx.e_offset = 0; 5258 } 5259 5260 while (card->rx.b_count) { 5261 buffer = &card->qdio.in_q->bufs[card->rx.b_index]; 5262 if (!(card->rx.qdio_err && 5263 qeth_check_qdio_errors(card, buffer->buffer, 5264 card->rx.qdio_err, "qinerr"))) 5265 work_done += 5266 card->discipline->process_rx_buffer( 5267 card, new_budget, &done); 5268 else 5269 done = 1; 5270 5271 if (done) { 5272 QETH_CARD_STAT_INC(card, rx_bufs); 5273 qeth_put_buffer_pool_entry(card, 5274 buffer->pool_entry); 5275 qeth_queue_input_buffer(card, card->rx.b_index); 5276 card->rx.b_count--; 5277 if (card->rx.b_count) { 5278 card->rx.b_index = 5279 (card->rx.b_index + 1) % 5280 QDIO_MAX_BUFFERS_PER_Q; 5281 card->rx.b_element = 5282 &card->qdio.in_q 5283 ->bufs[card->rx.b_index] 5284 .buffer->element[0]; 5285 card->rx.e_offset = 0; 5286 } 5287 } 5288 5289 if (work_done >= budget) 5290 goto out; 5291 else 5292 new_budget = budget - work_done; 5293 } 5294 } 5295 5296 napi_complete_done(napi, work_done); 5297 if (qdio_start_irq(card->data.ccwdev, 0)) 5298 napi_schedule(&card->napi); 5299 out: 5300 return work_done; 5301 } 5302 EXPORT_SYMBOL_GPL(qeth_poll); 5303 5304 static int qeth_setassparms_inspect_rc(struct qeth_ipa_cmd *cmd) 5305 { 5306 if (!cmd->hdr.return_code) 5307 cmd->hdr.return_code = cmd->data.setassparms.hdr.return_code; 5308 return cmd->hdr.return_code; 5309 } 5310 5311 static int qeth_setassparms_get_caps_cb(struct qeth_card *card, 5312 struct qeth_reply *reply, 5313 unsigned long data) 5314 { 5315 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data; 5316 struct qeth_ipa_caps *caps = reply->param; 5317 5318 if (qeth_setassparms_inspect_rc(cmd)) 5319 return -EIO; 5320 5321 caps->supported = cmd->data.setassparms.data.caps.supported; 5322 caps->enabled = cmd->data.setassparms.data.caps.enabled; 5323 return 0; 5324 } 5325 5326 int qeth_setassparms_cb(struct qeth_card *card, 5327 struct qeth_reply *reply, unsigned long data) 5328 { 5329 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data; 5330 5331 QETH_CARD_TEXT(card, 4, "defadpcb"); 5332 5333 if (cmd->hdr.return_code) 5334 return -EIO; 5335 5336 cmd->hdr.return_code = cmd->data.setassparms.hdr.return_code; 5337 if (cmd->hdr.prot_version == QETH_PROT_IPV4) 5338 card->options.ipa4.enabled_funcs = cmd->hdr.ipa_enabled; 5339 if (cmd->hdr.prot_version == QETH_PROT_IPV6) 5340 card->options.ipa6.enabled_funcs = cmd->hdr.ipa_enabled; 5341 return 0; 5342 } 5343 EXPORT_SYMBOL_GPL(qeth_setassparms_cb); 5344 5345 struct qeth_cmd_buffer *qeth_get_setassparms_cmd(struct qeth_card *card, 5346 enum qeth_ipa_funcs ipa_func, 5347 __u16 cmd_code, __u16 len, 5348 enum qeth_prot_versions prot) 5349 { 5350 struct qeth_cmd_buffer *iob; 5351 struct qeth_ipa_cmd *cmd; 5352 5353 QETH_CARD_TEXT(card, 4, "getasscm"); 5354 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_SETASSPARMS, prot); 5355 5356 if (iob) { 5357 cmd = __ipa_cmd(iob); 5358 cmd->data.setassparms.hdr.assist_no = ipa_func; 5359 cmd->data.setassparms.hdr.length = 8 + len; 5360 cmd->data.setassparms.hdr.command_code = cmd_code; 5361 } 5362 5363 return iob; 5364 } 5365 EXPORT_SYMBOL_GPL(qeth_get_setassparms_cmd); 5366 5367 int qeth_send_simple_setassparms_prot(struct qeth_card *card, 5368 enum qeth_ipa_funcs ipa_func, 5369 u16 cmd_code, long data, 5370 enum qeth_prot_versions prot) 5371 { 5372 int length = 0; 5373 struct qeth_cmd_buffer *iob; 5374 5375 QETH_CARD_TEXT_(card, 4, "simassp%i", prot); 5376 if (data) 5377 length = sizeof(__u32); 5378 iob = qeth_get_setassparms_cmd(card, ipa_func, cmd_code, length, prot); 5379 if (!iob) 5380 return -ENOMEM; 5381 5382 __ipa_cmd(iob)->data.setassparms.data.flags_32bit = (__u32) data; 5383 return qeth_send_ipa_cmd(card, iob, qeth_setassparms_cb, NULL); 5384 } 5385 EXPORT_SYMBOL_GPL(qeth_send_simple_setassparms_prot); 5386 5387 static void qeth_unregister_dbf_views(void) 5388 { 5389 int x; 5390 for (x = 0; x < QETH_DBF_INFOS; x++) { 5391 debug_unregister(qeth_dbf[x].id); 5392 qeth_dbf[x].id = NULL; 5393 } 5394 } 5395 5396 void qeth_dbf_longtext(debug_info_t *id, int level, char *fmt, ...) 5397 { 5398 char dbf_txt_buf[32]; 5399 va_list args; 5400 5401 if (!debug_level_enabled(id, level)) 5402 return; 5403 va_start(args, fmt); 5404 vsnprintf(dbf_txt_buf, sizeof(dbf_txt_buf), fmt, args); 5405 va_end(args); 5406 debug_text_event(id, level, dbf_txt_buf); 5407 } 5408 EXPORT_SYMBOL_GPL(qeth_dbf_longtext); 5409 5410 static int qeth_register_dbf_views(void) 5411 { 5412 int ret; 5413 int x; 5414 5415 for (x = 0; x < QETH_DBF_INFOS; x++) { 5416 /* register the areas */ 5417 qeth_dbf[x].id = debug_register(qeth_dbf[x].name, 5418 qeth_dbf[x].pages, 5419 qeth_dbf[x].areas, 5420 qeth_dbf[x].len); 5421 if (qeth_dbf[x].id == NULL) { 5422 qeth_unregister_dbf_views(); 5423 return -ENOMEM; 5424 } 5425 5426 /* register a view */ 5427 ret = debug_register_view(qeth_dbf[x].id, qeth_dbf[x].view); 5428 if (ret) { 5429 qeth_unregister_dbf_views(); 5430 return ret; 5431 } 5432 5433 /* set a passing level */ 5434 debug_set_level(qeth_dbf[x].id, qeth_dbf[x].level); 5435 } 5436 5437 return 0; 5438 } 5439 5440 static DEFINE_MUTEX(qeth_mod_mutex); /* for synchronized module loading */ 5441 5442 int qeth_core_load_discipline(struct qeth_card *card, 5443 enum qeth_discipline_id discipline) 5444 { 5445 mutex_lock(&qeth_mod_mutex); 5446 switch (discipline) { 5447 case QETH_DISCIPLINE_LAYER3: 5448 card->discipline = try_then_request_module( 5449 symbol_get(qeth_l3_discipline), "qeth_l3"); 5450 break; 5451 case QETH_DISCIPLINE_LAYER2: 5452 card->discipline = try_then_request_module( 5453 symbol_get(qeth_l2_discipline), "qeth_l2"); 5454 break; 5455 default: 5456 break; 5457 } 5458 mutex_unlock(&qeth_mod_mutex); 5459 5460 if (!card->discipline) { 5461 dev_err(&card->gdev->dev, "There is no kernel module to " 5462 "support discipline %d\n", discipline); 5463 return -EINVAL; 5464 } 5465 5466 card->options.layer = discipline; 5467 return 0; 5468 } 5469 5470 void qeth_core_free_discipline(struct qeth_card *card) 5471 { 5472 if (IS_LAYER2(card)) 5473 symbol_put(qeth_l2_discipline); 5474 else 5475 symbol_put(qeth_l3_discipline); 5476 card->options.layer = QETH_DISCIPLINE_UNDETERMINED; 5477 card->discipline = NULL; 5478 } 5479 5480 const struct device_type qeth_generic_devtype = { 5481 .name = "qeth_generic", 5482 .groups = qeth_generic_attr_groups, 5483 }; 5484 EXPORT_SYMBOL_GPL(qeth_generic_devtype); 5485 5486 static const struct device_type qeth_osn_devtype = { 5487 .name = "qeth_osn", 5488 .groups = qeth_osn_attr_groups, 5489 }; 5490 5491 #define DBF_NAME_LEN 20 5492 5493 struct qeth_dbf_entry { 5494 char dbf_name[DBF_NAME_LEN]; 5495 debug_info_t *dbf_info; 5496 struct list_head dbf_list; 5497 }; 5498 5499 static LIST_HEAD(qeth_dbf_list); 5500 static DEFINE_MUTEX(qeth_dbf_list_mutex); 5501 5502 static debug_info_t *qeth_get_dbf_entry(char *name) 5503 { 5504 struct qeth_dbf_entry *entry; 5505 debug_info_t *rc = NULL; 5506 5507 mutex_lock(&qeth_dbf_list_mutex); 5508 list_for_each_entry(entry, &qeth_dbf_list, dbf_list) { 5509 if (strcmp(entry->dbf_name, name) == 0) { 5510 rc = entry->dbf_info; 5511 break; 5512 } 5513 } 5514 mutex_unlock(&qeth_dbf_list_mutex); 5515 return rc; 5516 } 5517 5518 static int qeth_add_dbf_entry(struct qeth_card *card, char *name) 5519 { 5520 struct qeth_dbf_entry *new_entry; 5521 5522 card->debug = debug_register(name, 2, 1, 8); 5523 if (!card->debug) { 5524 QETH_DBF_TEXT_(SETUP, 2, "%s", "qcdbf"); 5525 goto err; 5526 } 5527 if (debug_register_view(card->debug, &debug_hex_ascii_view)) 5528 goto err_dbg; 5529 new_entry = kzalloc(sizeof(struct qeth_dbf_entry), GFP_KERNEL); 5530 if (!new_entry) 5531 goto err_dbg; 5532 strncpy(new_entry->dbf_name, name, DBF_NAME_LEN); 5533 new_entry->dbf_info = card->debug; 5534 mutex_lock(&qeth_dbf_list_mutex); 5535 list_add(&new_entry->dbf_list, &qeth_dbf_list); 5536 mutex_unlock(&qeth_dbf_list_mutex); 5537 5538 return 0; 5539 5540 err_dbg: 5541 debug_unregister(card->debug); 5542 err: 5543 return -ENOMEM; 5544 } 5545 5546 static void qeth_clear_dbf_list(void) 5547 { 5548 struct qeth_dbf_entry *entry, *tmp; 5549 5550 mutex_lock(&qeth_dbf_list_mutex); 5551 list_for_each_entry_safe(entry, tmp, &qeth_dbf_list, dbf_list) { 5552 list_del(&entry->dbf_list); 5553 debug_unregister(entry->dbf_info); 5554 kfree(entry); 5555 } 5556 mutex_unlock(&qeth_dbf_list_mutex); 5557 } 5558 5559 static struct net_device *qeth_alloc_netdev(struct qeth_card *card) 5560 { 5561 struct net_device *dev; 5562 5563 switch (card->info.type) { 5564 case QETH_CARD_TYPE_IQD: 5565 dev = alloc_netdev(0, "hsi%d", NET_NAME_UNKNOWN, ether_setup); 5566 break; 5567 case QETH_CARD_TYPE_OSN: 5568 dev = alloc_netdev(0, "osn%d", NET_NAME_UNKNOWN, ether_setup); 5569 break; 5570 default: 5571 dev = alloc_etherdev(0); 5572 } 5573 5574 if (!dev) 5575 return NULL; 5576 5577 dev->ml_priv = card; 5578 dev->watchdog_timeo = QETH_TX_TIMEOUT; 5579 dev->min_mtu = IS_OSN(card) ? 64 : 576; 5580 /* initialized when device first goes online: */ 5581 dev->max_mtu = 0; 5582 dev->mtu = 0; 5583 SET_NETDEV_DEV(dev, &card->gdev->dev); 5584 netif_carrier_off(dev); 5585 5586 if (IS_OSN(card)) { 5587 dev->ethtool_ops = &qeth_osn_ethtool_ops; 5588 } else { 5589 dev->ethtool_ops = &qeth_ethtool_ops; 5590 dev->priv_flags &= ~IFF_TX_SKB_SHARING; 5591 dev->hw_features |= NETIF_F_SG; 5592 dev->vlan_features |= NETIF_F_SG; 5593 if (IS_IQD(card)) 5594 dev->features |= NETIF_F_SG; 5595 } 5596 5597 return dev; 5598 } 5599 5600 struct net_device *qeth_clone_netdev(struct net_device *orig) 5601 { 5602 struct net_device *clone = qeth_alloc_netdev(orig->ml_priv); 5603 5604 if (!clone) 5605 return NULL; 5606 5607 clone->dev_port = orig->dev_port; 5608 return clone; 5609 } 5610 5611 static int qeth_core_probe_device(struct ccwgroup_device *gdev) 5612 { 5613 struct qeth_card *card; 5614 struct device *dev; 5615 int rc; 5616 enum qeth_discipline_id enforced_disc; 5617 char dbf_name[DBF_NAME_LEN]; 5618 5619 QETH_DBF_TEXT(SETUP, 2, "probedev"); 5620 5621 dev = &gdev->dev; 5622 if (!get_device(dev)) 5623 return -ENODEV; 5624 5625 QETH_DBF_TEXT_(SETUP, 2, "%s", dev_name(&gdev->dev)); 5626 5627 card = qeth_alloc_card(gdev); 5628 if (!card) { 5629 QETH_DBF_TEXT_(SETUP, 2, "1err%d", -ENOMEM); 5630 rc = -ENOMEM; 5631 goto err_dev; 5632 } 5633 5634 snprintf(dbf_name, sizeof(dbf_name), "qeth_card_%s", 5635 dev_name(&gdev->dev)); 5636 card->debug = qeth_get_dbf_entry(dbf_name); 5637 if (!card->debug) { 5638 rc = qeth_add_dbf_entry(card, dbf_name); 5639 if (rc) 5640 goto err_card; 5641 } 5642 5643 qeth_setup_card(card); 5644 qeth_update_from_chp_desc(card); 5645 5646 card->dev = qeth_alloc_netdev(card); 5647 if (!card->dev) { 5648 rc = -ENOMEM; 5649 goto err_card; 5650 } 5651 5652 qeth_determine_capabilities(card); 5653 enforced_disc = qeth_enforce_discipline(card); 5654 switch (enforced_disc) { 5655 case QETH_DISCIPLINE_UNDETERMINED: 5656 gdev->dev.type = &qeth_generic_devtype; 5657 break; 5658 default: 5659 card->info.layer_enforced = true; 5660 rc = qeth_core_load_discipline(card, enforced_disc); 5661 if (rc) 5662 goto err_load; 5663 5664 gdev->dev.type = (card->info.type != QETH_CARD_TYPE_OSN) 5665 ? card->discipline->devtype 5666 : &qeth_osn_devtype; 5667 rc = card->discipline->setup(card->gdev); 5668 if (rc) 5669 goto err_disc; 5670 break; 5671 } 5672 5673 return 0; 5674 5675 err_disc: 5676 qeth_core_free_discipline(card); 5677 err_load: 5678 free_netdev(card->dev); 5679 err_card: 5680 qeth_core_free_card(card); 5681 err_dev: 5682 put_device(dev); 5683 return rc; 5684 } 5685 5686 static void qeth_core_remove_device(struct ccwgroup_device *gdev) 5687 { 5688 struct qeth_card *card = dev_get_drvdata(&gdev->dev); 5689 5690 QETH_DBF_TEXT(SETUP, 2, "removedv"); 5691 5692 if (card->discipline) { 5693 card->discipline->remove(gdev); 5694 qeth_core_free_discipline(card); 5695 } 5696 5697 free_netdev(card->dev); 5698 qeth_core_free_card(card); 5699 put_device(&gdev->dev); 5700 } 5701 5702 static int qeth_core_set_online(struct ccwgroup_device *gdev) 5703 { 5704 struct qeth_card *card = dev_get_drvdata(&gdev->dev); 5705 int rc = 0; 5706 enum qeth_discipline_id def_discipline; 5707 5708 if (!card->discipline) { 5709 if (card->info.type == QETH_CARD_TYPE_IQD) 5710 def_discipline = QETH_DISCIPLINE_LAYER3; 5711 else 5712 def_discipline = QETH_DISCIPLINE_LAYER2; 5713 rc = qeth_core_load_discipline(card, def_discipline); 5714 if (rc) 5715 goto err; 5716 rc = card->discipline->setup(card->gdev); 5717 if (rc) { 5718 qeth_core_free_discipline(card); 5719 goto err; 5720 } 5721 } 5722 rc = card->discipline->set_online(gdev); 5723 err: 5724 return rc; 5725 } 5726 5727 static int qeth_core_set_offline(struct ccwgroup_device *gdev) 5728 { 5729 struct qeth_card *card = dev_get_drvdata(&gdev->dev); 5730 return card->discipline->set_offline(gdev); 5731 } 5732 5733 static void qeth_core_shutdown(struct ccwgroup_device *gdev) 5734 { 5735 struct qeth_card *card = dev_get_drvdata(&gdev->dev); 5736 qeth_set_allowed_threads(card, 0, 1); 5737 if ((gdev->state == CCWGROUP_ONLINE) && card->info.hwtrap) 5738 qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM); 5739 qeth_qdio_clear_card(card, 0); 5740 qeth_clear_qdio_buffers(card); 5741 qdio_free(CARD_DDEV(card)); 5742 } 5743 5744 static int qeth_core_freeze(struct ccwgroup_device *gdev) 5745 { 5746 struct qeth_card *card = dev_get_drvdata(&gdev->dev); 5747 if (card->discipline && card->discipline->freeze) 5748 return card->discipline->freeze(gdev); 5749 return 0; 5750 } 5751 5752 static int qeth_core_thaw(struct ccwgroup_device *gdev) 5753 { 5754 struct qeth_card *card = dev_get_drvdata(&gdev->dev); 5755 if (card->discipline && card->discipline->thaw) 5756 return card->discipline->thaw(gdev); 5757 return 0; 5758 } 5759 5760 static int qeth_core_restore(struct ccwgroup_device *gdev) 5761 { 5762 struct qeth_card *card = dev_get_drvdata(&gdev->dev); 5763 if (card->discipline && card->discipline->restore) 5764 return card->discipline->restore(gdev); 5765 return 0; 5766 } 5767 5768 static ssize_t group_store(struct device_driver *ddrv, const char *buf, 5769 size_t count) 5770 { 5771 int err; 5772 5773 err = ccwgroup_create_dev(qeth_core_root_dev, to_ccwgroupdrv(ddrv), 3, 5774 buf); 5775 5776 return err ? err : count; 5777 } 5778 static DRIVER_ATTR_WO(group); 5779 5780 static struct attribute *qeth_drv_attrs[] = { 5781 &driver_attr_group.attr, 5782 NULL, 5783 }; 5784 static struct attribute_group qeth_drv_attr_group = { 5785 .attrs = qeth_drv_attrs, 5786 }; 5787 static const struct attribute_group *qeth_drv_attr_groups[] = { 5788 &qeth_drv_attr_group, 5789 NULL, 5790 }; 5791 5792 static struct ccwgroup_driver qeth_core_ccwgroup_driver = { 5793 .driver = { 5794 .groups = qeth_drv_attr_groups, 5795 .owner = THIS_MODULE, 5796 .name = "qeth", 5797 }, 5798 .ccw_driver = &qeth_ccw_driver, 5799 .setup = qeth_core_probe_device, 5800 .remove = qeth_core_remove_device, 5801 .set_online = qeth_core_set_online, 5802 .set_offline = qeth_core_set_offline, 5803 .shutdown = qeth_core_shutdown, 5804 .prepare = NULL, 5805 .complete = NULL, 5806 .freeze = qeth_core_freeze, 5807 .thaw = qeth_core_thaw, 5808 .restore = qeth_core_restore, 5809 }; 5810 5811 struct qeth_card *qeth_get_card_by_busid(char *bus_id) 5812 { 5813 struct ccwgroup_device *gdev; 5814 struct qeth_card *card; 5815 5816 gdev = get_ccwgroupdev_by_busid(&qeth_core_ccwgroup_driver, bus_id); 5817 if (!gdev) 5818 return NULL; 5819 5820 card = dev_get_drvdata(&gdev->dev); 5821 put_device(&gdev->dev); 5822 return card; 5823 } 5824 EXPORT_SYMBOL_GPL(qeth_get_card_by_busid); 5825 5826 int qeth_do_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) 5827 { 5828 struct qeth_card *card = dev->ml_priv; 5829 struct mii_ioctl_data *mii_data; 5830 int rc = 0; 5831 5832 if (!card) 5833 return -ENODEV; 5834 5835 switch (cmd) { 5836 case SIOC_QETH_ADP_SET_SNMP_CONTROL: 5837 rc = qeth_snmp_command(card, rq->ifr_ifru.ifru_data); 5838 break; 5839 case SIOC_QETH_GET_CARD_TYPE: 5840 if ((card->info.type == QETH_CARD_TYPE_OSD || 5841 card->info.type == QETH_CARD_TYPE_OSM || 5842 card->info.type == QETH_CARD_TYPE_OSX) && 5843 !card->info.guestlan) 5844 return 1; 5845 else 5846 return 0; 5847 case SIOCGMIIPHY: 5848 mii_data = if_mii(rq); 5849 mii_data->phy_id = 0; 5850 break; 5851 case SIOCGMIIREG: 5852 mii_data = if_mii(rq); 5853 if (mii_data->phy_id != 0) 5854 rc = -EINVAL; 5855 else 5856 mii_data->val_out = qeth_mdio_read(dev, 5857 mii_data->phy_id, mii_data->reg_num); 5858 break; 5859 case SIOC_QETH_QUERY_OAT: 5860 rc = qeth_query_oat_command(card, rq->ifr_ifru.ifru_data); 5861 break; 5862 default: 5863 if (card->discipline->do_ioctl) 5864 rc = card->discipline->do_ioctl(dev, rq, cmd); 5865 else 5866 rc = -EOPNOTSUPP; 5867 } 5868 if (rc) 5869 QETH_CARD_TEXT_(card, 2, "ioce%x", rc); 5870 return rc; 5871 } 5872 EXPORT_SYMBOL_GPL(qeth_do_ioctl); 5873 5874 static int qeth_start_csum_cb(struct qeth_card *card, struct qeth_reply *reply, 5875 unsigned long data) 5876 { 5877 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data; 5878 u32 *features = reply->param; 5879 5880 if (qeth_setassparms_inspect_rc(cmd)) 5881 return -EIO; 5882 5883 *features = cmd->data.setassparms.data.flags_32bit; 5884 return 0; 5885 } 5886 5887 static int qeth_set_csum_off(struct qeth_card *card, enum qeth_ipa_funcs cstype, 5888 enum qeth_prot_versions prot) 5889 { 5890 return qeth_send_simple_setassparms_prot(card, cstype, 5891 IPA_CMD_ASS_STOP, 0, prot); 5892 } 5893 5894 static int qeth_set_csum_on(struct qeth_card *card, enum qeth_ipa_funcs cstype, 5895 enum qeth_prot_versions prot) 5896 { 5897 u32 required_features = QETH_IPA_CHECKSUM_UDP | QETH_IPA_CHECKSUM_TCP; 5898 struct qeth_cmd_buffer *iob; 5899 struct qeth_ipa_caps caps; 5900 u32 features; 5901 int rc; 5902 5903 /* some L3 HW requires combined L3+L4 csum offload: */ 5904 if (IS_LAYER3(card) && prot == QETH_PROT_IPV4 && 5905 cstype == IPA_OUTBOUND_CHECKSUM) 5906 required_features |= QETH_IPA_CHECKSUM_IP_HDR; 5907 5908 iob = qeth_get_setassparms_cmd(card, cstype, IPA_CMD_ASS_START, 0, 5909 prot); 5910 if (!iob) 5911 return -ENOMEM; 5912 5913 rc = qeth_send_ipa_cmd(card, iob, qeth_start_csum_cb, &features); 5914 if (rc) 5915 return rc; 5916 5917 if ((required_features & features) != required_features) { 5918 qeth_set_csum_off(card, cstype, prot); 5919 return -EOPNOTSUPP; 5920 } 5921 5922 iob = qeth_get_setassparms_cmd(card, cstype, IPA_CMD_ASS_ENABLE, 4, 5923 prot); 5924 if (!iob) { 5925 qeth_set_csum_off(card, cstype, prot); 5926 return -ENOMEM; 5927 } 5928 5929 if (features & QETH_IPA_CHECKSUM_LP2LP) 5930 required_features |= QETH_IPA_CHECKSUM_LP2LP; 5931 __ipa_cmd(iob)->data.setassparms.data.flags_32bit = required_features; 5932 rc = qeth_send_ipa_cmd(card, iob, qeth_setassparms_get_caps_cb, &caps); 5933 if (rc) { 5934 qeth_set_csum_off(card, cstype, prot); 5935 return rc; 5936 } 5937 5938 if (!qeth_ipa_caps_supported(&caps, required_features) || 5939 !qeth_ipa_caps_enabled(&caps, required_features)) { 5940 qeth_set_csum_off(card, cstype, prot); 5941 return -EOPNOTSUPP; 5942 } 5943 5944 dev_info(&card->gdev->dev, "HW Checksumming (%sbound IPv%d) enabled\n", 5945 cstype == IPA_INBOUND_CHECKSUM ? "in" : "out", prot); 5946 if (!qeth_ipa_caps_enabled(&caps, QETH_IPA_CHECKSUM_LP2LP) && 5947 cstype == IPA_OUTBOUND_CHECKSUM) 5948 dev_warn(&card->gdev->dev, 5949 "Hardware checksumming is performed only if %s and its peer use different OSA Express 3 ports\n", 5950 QETH_CARD_IFNAME(card)); 5951 return 0; 5952 } 5953 5954 static int qeth_set_ipa_csum(struct qeth_card *card, bool on, int cstype, 5955 enum qeth_prot_versions prot) 5956 { 5957 return on ? qeth_set_csum_on(card, cstype, prot) : 5958 qeth_set_csum_off(card, cstype, prot); 5959 } 5960 5961 static int qeth_start_tso_cb(struct qeth_card *card, struct qeth_reply *reply, 5962 unsigned long data) 5963 { 5964 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data; 5965 struct qeth_tso_start_data *tso_data = reply->param; 5966 5967 if (qeth_setassparms_inspect_rc(cmd)) 5968 return -EIO; 5969 5970 tso_data->mss = cmd->data.setassparms.data.tso.mss; 5971 tso_data->supported = cmd->data.setassparms.data.tso.supported; 5972 return 0; 5973 } 5974 5975 static int qeth_set_tso_off(struct qeth_card *card, 5976 enum qeth_prot_versions prot) 5977 { 5978 return qeth_send_simple_setassparms_prot(card, IPA_OUTBOUND_TSO, 5979 IPA_CMD_ASS_STOP, 0, prot); 5980 } 5981 5982 static int qeth_set_tso_on(struct qeth_card *card, 5983 enum qeth_prot_versions prot) 5984 { 5985 struct qeth_tso_start_data tso_data; 5986 struct qeth_cmd_buffer *iob; 5987 struct qeth_ipa_caps caps; 5988 int rc; 5989 5990 iob = qeth_get_setassparms_cmd(card, IPA_OUTBOUND_TSO, 5991 IPA_CMD_ASS_START, 0, prot); 5992 if (!iob) 5993 return -ENOMEM; 5994 5995 rc = qeth_send_ipa_cmd(card, iob, qeth_start_tso_cb, &tso_data); 5996 if (rc) 5997 return rc; 5998 5999 if (!tso_data.mss || !(tso_data.supported & QETH_IPA_LARGE_SEND_TCP)) { 6000 qeth_set_tso_off(card, prot); 6001 return -EOPNOTSUPP; 6002 } 6003 6004 iob = qeth_get_setassparms_cmd(card, IPA_OUTBOUND_TSO, 6005 IPA_CMD_ASS_ENABLE, sizeof(caps), prot); 6006 if (!iob) { 6007 qeth_set_tso_off(card, prot); 6008 return -ENOMEM; 6009 } 6010 6011 /* enable TSO capability */ 6012 __ipa_cmd(iob)->data.setassparms.data.caps.enabled = 6013 QETH_IPA_LARGE_SEND_TCP; 6014 rc = qeth_send_ipa_cmd(card, iob, qeth_setassparms_get_caps_cb, &caps); 6015 if (rc) { 6016 qeth_set_tso_off(card, prot); 6017 return rc; 6018 } 6019 6020 if (!qeth_ipa_caps_supported(&caps, QETH_IPA_LARGE_SEND_TCP) || 6021 !qeth_ipa_caps_enabled(&caps, QETH_IPA_LARGE_SEND_TCP)) { 6022 qeth_set_tso_off(card, prot); 6023 return -EOPNOTSUPP; 6024 } 6025 6026 dev_info(&card->gdev->dev, "TSOv%u enabled (MSS: %u)\n", prot, 6027 tso_data.mss); 6028 return 0; 6029 } 6030 6031 static int qeth_set_ipa_tso(struct qeth_card *card, bool on, 6032 enum qeth_prot_versions prot) 6033 { 6034 return on ? qeth_set_tso_on(card, prot) : qeth_set_tso_off(card, prot); 6035 } 6036 6037 static int qeth_set_ipa_rx_csum(struct qeth_card *card, bool on) 6038 { 6039 int rc_ipv4 = (on) ? -EOPNOTSUPP : 0; 6040 int rc_ipv6; 6041 6042 if (qeth_is_supported(card, IPA_INBOUND_CHECKSUM)) 6043 rc_ipv4 = qeth_set_ipa_csum(card, on, IPA_INBOUND_CHECKSUM, 6044 QETH_PROT_IPV4); 6045 if (!qeth_is_supported6(card, IPA_INBOUND_CHECKSUM_V6)) 6046 /* no/one Offload Assist available, so the rc is trivial */ 6047 return rc_ipv4; 6048 6049 rc_ipv6 = qeth_set_ipa_csum(card, on, IPA_INBOUND_CHECKSUM, 6050 QETH_PROT_IPV6); 6051 6052 if (on) 6053 /* enable: success if any Assist is active */ 6054 return (rc_ipv6) ? rc_ipv4 : 0; 6055 6056 /* disable: failure if any Assist is still active */ 6057 return (rc_ipv6) ? rc_ipv6 : rc_ipv4; 6058 } 6059 6060 /** 6061 * qeth_enable_hw_features() - (Re-)Enable HW functions for device features 6062 * @dev: a net_device 6063 */ 6064 void qeth_enable_hw_features(struct net_device *dev) 6065 { 6066 struct qeth_card *card = dev->ml_priv; 6067 netdev_features_t features; 6068 6069 features = dev->features; 6070 /* force-off any feature that might need an IPA sequence. 6071 * netdev_update_features() will restart them. 6072 */ 6073 dev->features &= ~dev->hw_features; 6074 /* toggle VLAN filter, so that VIDs are re-programmed: */ 6075 if (IS_LAYER2(card) && IS_VM_NIC(card)) { 6076 dev->features &= ~NETIF_F_HW_VLAN_CTAG_FILTER; 6077 dev->wanted_features |= NETIF_F_HW_VLAN_CTAG_FILTER; 6078 } 6079 netdev_update_features(dev); 6080 if (features != dev->features) 6081 dev_warn(&card->gdev->dev, 6082 "Device recovery failed to restore all offload features\n"); 6083 } 6084 EXPORT_SYMBOL_GPL(qeth_enable_hw_features); 6085 6086 int qeth_set_features(struct net_device *dev, netdev_features_t features) 6087 { 6088 struct qeth_card *card = dev->ml_priv; 6089 netdev_features_t changed = dev->features ^ features; 6090 int rc = 0; 6091 6092 QETH_DBF_TEXT(SETUP, 2, "setfeat"); 6093 QETH_DBF_HEX(SETUP, 2, &features, sizeof(features)); 6094 6095 if ((changed & NETIF_F_IP_CSUM)) { 6096 rc = qeth_set_ipa_csum(card, features & NETIF_F_IP_CSUM, 6097 IPA_OUTBOUND_CHECKSUM, QETH_PROT_IPV4); 6098 if (rc) 6099 changed ^= NETIF_F_IP_CSUM; 6100 } 6101 if (changed & NETIF_F_IPV6_CSUM) { 6102 rc = qeth_set_ipa_csum(card, features & NETIF_F_IPV6_CSUM, 6103 IPA_OUTBOUND_CHECKSUM, QETH_PROT_IPV6); 6104 if (rc) 6105 changed ^= NETIF_F_IPV6_CSUM; 6106 } 6107 if (changed & NETIF_F_RXCSUM) { 6108 rc = qeth_set_ipa_rx_csum(card, features & NETIF_F_RXCSUM); 6109 if (rc) 6110 changed ^= NETIF_F_RXCSUM; 6111 } 6112 if (changed & NETIF_F_TSO) { 6113 rc = qeth_set_ipa_tso(card, features & NETIF_F_TSO, 6114 QETH_PROT_IPV4); 6115 if (rc) 6116 changed ^= NETIF_F_TSO; 6117 } 6118 if (changed & NETIF_F_TSO6) { 6119 rc = qeth_set_ipa_tso(card, features & NETIF_F_TSO6, 6120 QETH_PROT_IPV6); 6121 if (rc) 6122 changed ^= NETIF_F_TSO6; 6123 } 6124 6125 /* everything changed successfully? */ 6126 if ((dev->features ^ features) == changed) 6127 return 0; 6128 /* something went wrong. save changed features and return error */ 6129 dev->features ^= changed; 6130 return -EIO; 6131 } 6132 EXPORT_SYMBOL_GPL(qeth_set_features); 6133 6134 netdev_features_t qeth_fix_features(struct net_device *dev, 6135 netdev_features_t features) 6136 { 6137 struct qeth_card *card = dev->ml_priv; 6138 6139 QETH_DBF_TEXT(SETUP, 2, "fixfeat"); 6140 if (!qeth_is_supported(card, IPA_OUTBOUND_CHECKSUM)) 6141 features &= ~NETIF_F_IP_CSUM; 6142 if (!qeth_is_supported6(card, IPA_OUTBOUND_CHECKSUM_V6)) 6143 features &= ~NETIF_F_IPV6_CSUM; 6144 if (!qeth_is_supported(card, IPA_INBOUND_CHECKSUM) && 6145 !qeth_is_supported6(card, IPA_INBOUND_CHECKSUM_V6)) 6146 features &= ~NETIF_F_RXCSUM; 6147 if (!qeth_is_supported(card, IPA_OUTBOUND_TSO)) 6148 features &= ~NETIF_F_TSO; 6149 if (!qeth_is_supported6(card, IPA_OUTBOUND_TSO)) 6150 features &= ~NETIF_F_TSO6; 6151 6152 QETH_DBF_HEX(SETUP, 2, &features, sizeof(features)); 6153 return features; 6154 } 6155 EXPORT_SYMBOL_GPL(qeth_fix_features); 6156 6157 netdev_features_t qeth_features_check(struct sk_buff *skb, 6158 struct net_device *dev, 6159 netdev_features_t features) 6160 { 6161 /* GSO segmentation builds skbs with 6162 * a (small) linear part for the headers, and 6163 * page frags for the data. 6164 * Compared to a linear skb, the header-only part consumes an 6165 * additional buffer element. This reduces buffer utilization, and 6166 * hurts throughput. So compress small segments into one element. 6167 */ 6168 if (netif_needs_gso(skb, features)) { 6169 /* match skb_segment(): */ 6170 unsigned int doffset = skb->data - skb_mac_header(skb); 6171 unsigned int hsize = skb_shinfo(skb)->gso_size; 6172 unsigned int hroom = skb_headroom(skb); 6173 6174 /* linearize only if resulting skb allocations are order-0: */ 6175 if (SKB_DATA_ALIGN(hroom + doffset + hsize) <= SKB_MAX_HEAD(0)) 6176 features &= ~NETIF_F_SG; 6177 } 6178 6179 return vlan_features_check(skb, features); 6180 } 6181 EXPORT_SYMBOL_GPL(qeth_features_check); 6182 6183 void qeth_get_stats64(struct net_device *dev, struct rtnl_link_stats64 *stats) 6184 { 6185 struct qeth_card *card = dev->ml_priv; 6186 struct qeth_qdio_out_q *queue; 6187 unsigned int i; 6188 6189 QETH_CARD_TEXT(card, 5, "getstat"); 6190 6191 stats->rx_packets = card->stats.rx_packets; 6192 stats->rx_bytes = card->stats.rx_bytes; 6193 stats->rx_errors = card->stats.rx_errors; 6194 stats->rx_dropped = card->stats.rx_dropped; 6195 stats->multicast = card->stats.rx_multicast; 6196 stats->tx_errors = card->stats.tx_errors; 6197 6198 for (i = 0; i < card->qdio.no_out_queues; i++) { 6199 queue = card->qdio.out_qs[i]; 6200 6201 stats->tx_packets += queue->stats.tx_packets; 6202 stats->tx_bytes += queue->stats.tx_bytes; 6203 stats->tx_errors += queue->stats.tx_errors; 6204 stats->tx_dropped += queue->stats.tx_dropped; 6205 } 6206 } 6207 EXPORT_SYMBOL_GPL(qeth_get_stats64); 6208 6209 int qeth_open(struct net_device *dev) 6210 { 6211 struct qeth_card *card = dev->ml_priv; 6212 6213 QETH_CARD_TEXT(card, 4, "qethopen"); 6214 6215 if (qdio_stop_irq(CARD_DDEV(card), 0) < 0) 6216 return -EIO; 6217 6218 card->data.state = CH_STATE_UP; 6219 netif_start_queue(dev); 6220 6221 napi_enable(&card->napi); 6222 local_bh_disable(); 6223 napi_schedule(&card->napi); 6224 /* kick-start the NAPI softirq: */ 6225 local_bh_enable(); 6226 return 0; 6227 } 6228 EXPORT_SYMBOL_GPL(qeth_open); 6229 6230 int qeth_stop(struct net_device *dev) 6231 { 6232 struct qeth_card *card = dev->ml_priv; 6233 6234 QETH_CARD_TEXT(card, 4, "qethstop"); 6235 netif_tx_disable(dev); 6236 napi_disable(&card->napi); 6237 return 0; 6238 } 6239 EXPORT_SYMBOL_GPL(qeth_stop); 6240 6241 static int __init qeth_core_init(void) 6242 { 6243 int rc; 6244 6245 pr_info("loading core functions\n"); 6246 6247 rc = qeth_register_dbf_views(); 6248 if (rc) 6249 goto dbf_err; 6250 qeth_core_root_dev = root_device_register("qeth"); 6251 rc = PTR_ERR_OR_ZERO(qeth_core_root_dev); 6252 if (rc) 6253 goto register_err; 6254 qeth_core_header_cache = 6255 kmem_cache_create("qeth_hdr", QETH_HDR_CACHE_OBJ_SIZE, 6256 roundup_pow_of_two(QETH_HDR_CACHE_OBJ_SIZE), 6257 0, NULL); 6258 if (!qeth_core_header_cache) { 6259 rc = -ENOMEM; 6260 goto slab_err; 6261 } 6262 qeth_qdio_outbuf_cache = kmem_cache_create("qeth_buf", 6263 sizeof(struct qeth_qdio_out_buffer), 0, 0, NULL); 6264 if (!qeth_qdio_outbuf_cache) { 6265 rc = -ENOMEM; 6266 goto cqslab_err; 6267 } 6268 rc = ccw_driver_register(&qeth_ccw_driver); 6269 if (rc) 6270 goto ccw_err; 6271 rc = ccwgroup_driver_register(&qeth_core_ccwgroup_driver); 6272 if (rc) 6273 goto ccwgroup_err; 6274 6275 return 0; 6276 6277 ccwgroup_err: 6278 ccw_driver_unregister(&qeth_ccw_driver); 6279 ccw_err: 6280 kmem_cache_destroy(qeth_qdio_outbuf_cache); 6281 cqslab_err: 6282 kmem_cache_destroy(qeth_core_header_cache); 6283 slab_err: 6284 root_device_unregister(qeth_core_root_dev); 6285 register_err: 6286 qeth_unregister_dbf_views(); 6287 dbf_err: 6288 pr_err("Initializing the qeth device driver failed\n"); 6289 return rc; 6290 } 6291 6292 static void __exit qeth_core_exit(void) 6293 { 6294 qeth_clear_dbf_list(); 6295 ccwgroup_driver_unregister(&qeth_core_ccwgroup_driver); 6296 ccw_driver_unregister(&qeth_ccw_driver); 6297 kmem_cache_destroy(qeth_qdio_outbuf_cache); 6298 kmem_cache_destroy(qeth_core_header_cache); 6299 root_device_unregister(qeth_core_root_dev); 6300 qeth_unregister_dbf_views(); 6301 pr_info("core functions removed\n"); 6302 } 6303 6304 module_init(qeth_core_init); 6305 module_exit(qeth_core_exit); 6306 MODULE_AUTHOR("Frank Blaschka <frank.blaschka@de.ibm.com>"); 6307 MODULE_DESCRIPTION("qeth core functions"); 6308 MODULE_LICENSE("GPL"); 6309