drivers/s390/net/qeth_core_main.c

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