drivers/s390/cio/qdio_main.c

   1 /*
   2  * linux/drivers/s390/cio/qdio_main.c
   3  *
   4  * Linux for s390 qdio support, buffer handling, qdio API and module support.
   5  *
   6  * Copyright 2000,2008 IBM Corp.
   7  * Author(s): Utz Bacher <utz.bacher@de.ibm.com>
   8  *            Jan Glauber <jang@linux.vnet.ibm.com>
   9  * 2.6 cio integration by Cornelia Huck <cornelia.huck@de.ibm.com>
  10  */
  11 #include <linux/module.h>
  12 #include <linux/init.h>
  13 #include <linux/kernel.h>
  14 #include <linux/timer.h>
  15 #include <linux/delay.h>
  16 #include <asm/atomic.h>
  17 #include <asm/debug.h>
  18 #include <asm/qdio.h>
  19
  20 #include "cio.h"
  21 #include "css.h"
  22 #include "device.h"
  23 #include "qdio.h"
  24 #include "qdio_debug.h"
  25 #include "qdio_perf.h"
  26
  27 MODULE_AUTHOR("Utz Bacher <utz.bacher@de.ibm.com>,"\
  28         "Jan Glauber <jang@linux.vnet.ibm.com>");
  29 MODULE_DESCRIPTION("QDIO base support");
  30 MODULE_LICENSE("GPL");
  31
  32 static inline int do_siga_sync(struct subchannel_id schid,
  33                                unsigned int out_mask, unsigned int in_mask)
  34 {
  35         register unsigned long __fc asm ("0") = 2;
  36         register struct subchannel_id __schid asm ("1") = schid;
  37         register unsigned long out asm ("2") = out_mask;
  38         register unsigned long in asm ("3") = in_mask;
  39         int cc;
  40
  41         asm volatile(
  42                 "       siga    0\n"
  43                 "       ipm     %0\n"
  44                 "       srl     %0,28\n"
  45                 : "=d" (cc)
  46                 : "d" (__fc), "d" (__schid), "d" (out), "d" (in) : "cc");
  47         return cc;
  48 }
  49
  50 static inline int do_siga_input(struct subchannel_id schid, unsigned int mask)
  51 {
  52         register unsigned long __fc asm ("0") = 1;
  53         register struct subchannel_id __schid asm ("1") = schid;
  54         register unsigned long __mask asm ("2") = mask;
  55         int cc;
  56
  57         asm volatile(
  58                 "       siga    0\n"
  59                 "       ipm     %0\n"
  60                 "       srl     %0,28\n"
  61                 : "=d" (cc)
  62                 : "d" (__fc), "d" (__schid), "d" (__mask) : "cc", "memory");
  63         return cc;
  64 }
  65
  66 /**
  67  * do_siga_output - perform SIGA-w/wt function
  68  * @schid: subchannel id or in case of QEBSM the subchannel token
  69  * @mask: which output queues to process
  70  * @bb: busy bit indicator, set only if SIGA-w/wt could not access a buffer
  71  * @fc: function code to perform
  72  *
  73  * Returns cc or QDIO_ERROR_SIGA_ACCESS_EXCEPTION.
  74  * Note: For IQDC unicast queues only the highest priority queue is processed.
  75  */
  76 static inline int do_siga_output(unsigned long schid, unsigned long mask,
  77                                  u32 *bb, unsigned int fc)
  78 {
  79         register unsigned long __fc asm("0") = fc;
  80         register unsigned long __schid asm("1") = schid;
  81         register unsigned long __mask asm("2") = mask;
  82         int cc = QDIO_ERROR_SIGA_ACCESS_EXCEPTION;
  83
  84         asm volatile(
  85                 "       siga    0\n"
  86                 "0:     ipm     %0\n"
  87                 "       srl     %0,28\n"
  88                 "1:\n"
  89                 EX_TABLE(0b, 1b)
  90                 : "+d" (cc), "+d" (__fc), "+d" (__schid), "+d" (__mask)
  91                 : : "cc", "memory");
  92         *bb = ((unsigned int) __fc) >> 31;
  93         return cc;
  94 }
  95
  96 static inline int qdio_check_ccq(struct qdio_q *q, unsigned int ccq)
  97 {
  98         char dbf_text[15];
  99
 100         /* all done or next buffer state different */
 101         if (ccq == 0 || ccq == 32)
 102                 return 0;
 103         /* not all buffers processed */
 104         if (ccq == 96 || ccq == 97)
 105                 return 1;
 106         /* notify devices immediately */
 107         sprintf(dbf_text, "%d", ccq);
 108         QDIO_DBF_TEXT2(1, trace, dbf_text);
 109         return -EIO;
 110 }
 111
 112 /**
 113  * qdio_do_eqbs - extract buffer states for QEBSM
 114  * @q: queue to manipulate
 115  * @state: state of the extracted buffers
 116  * @start: buffer number to start at
 117  * @count: count of buffers to examine
 118  *
 119  * Returns the number of successfull extracted equal buffer states.
 120  * Stops processing if a state is different from the last buffers state.
 121  */
 122 static int qdio_do_eqbs(struct qdio_q *q, unsigned char *state,
 123                         int start, int count)
 124 {
 125         unsigned int ccq = 0;
 126         int tmp_count = count, tmp_start = start;
 127         int nr = q->nr;
 128         int rc;
 129         char dbf_text[15];
 130
 131         BUG_ON(!q->irq_ptr->sch_token);
 132
 133         if (!q->is_input_q)
 134                 nr += q->irq_ptr->nr_input_qs;
 135 again:
 136         ccq = do_eqbs(q->irq_ptr->sch_token, state, nr, &tmp_start, &tmp_count);
 137         rc = qdio_check_ccq(q, ccq);
 138
 139         /* At least one buffer was processed, return and extract the remaining
 140          * buffers later.
 141          */
 142         if ((ccq == 96) && (count != tmp_count))
 143                 return (count - tmp_count);
 144         if (rc == 1) {
 145                 QDIO_DBF_TEXT5(1, trace, "eqAGAIN");
 146                 goto again;
 147         }
 148
 149         if (rc < 0) {
 150                 QDIO_DBF_TEXT2(1, trace, "eqberr");
 151                 sprintf(dbf_text, "%2x,%2x,%d,%d", count, tmp_count, ccq, nr);
 152                 QDIO_DBF_TEXT2(1, trace, dbf_text);
 153                 q->handler(q->irq_ptr->cdev,
 154                            QDIO_ERROR_ACTIVATE_CHECK_CONDITION,
 155                            0, -1, -1, q->irq_ptr->int_parm);
 156                 return 0;
 157         }
 158         return count - tmp_count;
 159 }
 160
 161 /**
 162  * qdio_do_sqbs - set buffer states for QEBSM
 163  * @q: queue to manipulate
 164  * @state: new state of the buffers
 165  * @start: first buffer number to change
 166  * @count: how many buffers to change
 167  *
 168  * Returns the number of successfully changed buffers.
 169  * Does retrying until the specified count of buffer states is set or an
 170  * error occurs.
 171  */
 172 static int qdio_do_sqbs(struct qdio_q *q, unsigned char state, int start,
 173                         int count)
 174 {
 175         unsigned int ccq = 0;
 176         int tmp_count = count, tmp_start = start;
 177         int nr = q->nr;
 178         int rc;
 179         char dbf_text[15];
 180
 181         BUG_ON(!q->irq_ptr->sch_token);
 182
 183         if (!q->is_input_q)
 184                 nr += q->irq_ptr->nr_input_qs;
 185 again:
 186         ccq = do_sqbs(q->irq_ptr->sch_token, state, nr, &tmp_start, &tmp_count);
 187         rc = qdio_check_ccq(q, ccq);
 188         if (rc == 1) {
 189                 QDIO_DBF_TEXT5(1, trace, "sqAGAIN");
 190                 goto again;
 191         }
 192         if (rc < 0) {
 193                 QDIO_DBF_TEXT3(1, trace, "sqberr");
 194                 sprintf(dbf_text, "%2x,%2x", count, tmp_count);
 195                 QDIO_DBF_TEXT3(1, trace, dbf_text);
 196                 sprintf(dbf_text, "%d,%d", ccq, nr);
 197                 QDIO_DBF_TEXT3(1, trace, dbf_text);
 198
 199                 q->handler(q->irq_ptr->cdev,
 200                            QDIO_ERROR_ACTIVATE_CHECK_CONDITION,
 201                            0, -1, -1, q->irq_ptr->int_parm);
 202                 return 0;
 203         }
 204         WARN_ON(tmp_count);
 205         return count - tmp_count;
 206 }
 207
 208 /* returns number of examined buffers and their common state in *state */
 209 static inline int get_buf_states(struct qdio_q *q, unsigned int bufnr,
 210                                  unsigned char *state, unsigned int count)
 211 {
 212         unsigned char __state = 0;
 213         int i;
 214
 215         BUG_ON(bufnr > QDIO_MAX_BUFFERS_MASK);
 216         BUG_ON(count > QDIO_MAX_BUFFERS_PER_Q);
 217
 218         if (is_qebsm(q))
 219                 return qdio_do_eqbs(q, state, bufnr, count);
 220
 221         for (i = 0; i < count; i++) {
 222                 if (!__state)
 223                         __state = q->slsb.val[bufnr];
 224                 else if (q->slsb.val[bufnr] != __state)
 225                         break;
 226                 bufnr = next_buf(bufnr);
 227         }
 228         *state = __state;
 229         return i;
 230 }
 231
 232 inline int get_buf_state(struct qdio_q *q, unsigned int bufnr,
 233                   unsigned char *state)
 234 {
 235         return get_buf_states(q, bufnr, state, 1);
 236 }
 237
 238 /* wrap-around safe setting of slsb states, returns number of changed buffers */
 239 static inline int set_buf_states(struct qdio_q *q, int bufnr,
 240                                  unsigned char state, int count)
 241 {
 242         int i;
 243
 244         BUG_ON(bufnr > QDIO_MAX_BUFFERS_MASK);
 245         BUG_ON(count > QDIO_MAX_BUFFERS_PER_Q);
 246
 247         if (is_qebsm(q))
 248                 return qdio_do_sqbs(q, state, bufnr, count);
 249
 250         for (i = 0; i < count; i++) {
 251                 xchg(&q->slsb.val[bufnr], state);
 252                 bufnr = next_buf(bufnr);
 253         }
 254         return count;
 255 }
 256
 257 static inline int set_buf_state(struct qdio_q *q, int bufnr,
 258                                 unsigned char state)
 259 {
 260         return set_buf_states(q, bufnr, state, 1);
 261 }
 262
 263 /* set slsb states to initial state */
 264 void qdio_init_buf_states(struct qdio_irq *irq_ptr)
 265 {
 266         struct qdio_q *q;
 267         int i;
 268
 269         for_each_input_queue(irq_ptr, q, i)
 270                 set_buf_states(q, 0, SLSB_P_INPUT_NOT_INIT,
 271                                QDIO_MAX_BUFFERS_PER_Q);
 272         for_each_output_queue(irq_ptr, q, i)
 273                 set_buf_states(q, 0, SLSB_P_OUTPUT_NOT_INIT,
 274                                QDIO_MAX_BUFFERS_PER_Q);
 275 }
 276
 277 static int qdio_siga_sync(struct qdio_q *q, unsigned int output,
 278                           unsigned int input)
 279 {
 280         int cc;
 281
 282         if (!need_siga_sync(q))
 283                 return 0;
 284
 285         qdio_perf_stat_inc(&perf_stats.siga_sync);
 286
 287         cc = do_siga_sync(q->irq_ptr->schid, output, input);
 288         if (cc) {
 289                 QDIO_DBF_TEXT4(0, trace, "sigasync");
 290                 QDIO_DBF_HEX4(0, trace, &q, sizeof(void *));
 291                 QDIO_DBF_HEX3(0, trace, &cc, sizeof(int *));
 292         }
 293         return cc;
 294 }
 295
 296 inline int qdio_siga_sync_q(struct qdio_q *q)
 297 {
 298         if (q->is_input_q)
 299                 return qdio_siga_sync(q, 0, q->mask);
 300         else
 301                 return qdio_siga_sync(q, q->mask, 0);
 302 }
 303
 304 static inline int qdio_siga_sync_out(struct qdio_q *q)
 305 {
 306         return qdio_siga_sync(q, ~0U, 0);
 307 }
 308
 309 static inline int qdio_siga_sync_all(struct qdio_q *q)
 310 {
 311         return qdio_siga_sync(q, ~0U, ~0U);
 312 }
 313
 314 static inline int qdio_do_siga_output(struct qdio_q *q, unsigned int *busy_bit)
 315 {
 316         unsigned int fc = 0;
 317         unsigned long schid;
 318
 319         if (!is_qebsm(q))
 320                 schid = *((u32 *)&q->irq_ptr->schid);
 321         else {
 322                 schid = q->irq_ptr->sch_token;
 323                 fc |= 0x80;
 324         }
 325         return do_siga_output(schid, q->mask, busy_bit, fc);
 326 }
 327
 328 static int qdio_siga_output(struct qdio_q *q)
 329 {
 330         int cc;
 331         u32 busy_bit;
 332         u64 start_time = 0;
 333
 334         QDIO_DBF_TEXT5(0, trace, "sigaout");
 335         QDIO_DBF_HEX5(0, trace, &q, sizeof(void *));
 336
 337         qdio_perf_stat_inc(&perf_stats.siga_out);
 338 again:
 339         cc = qdio_do_siga_output(q, &busy_bit);
 340         if (queue_type(q) == QDIO_IQDIO_QFMT && cc == 2 && busy_bit) {
 341                 if (!start_time)
 342                         start_time = get_usecs();
 343                 else if ((get_usecs() - start_time) < QDIO_BUSY_BIT_PATIENCE)
 344                         goto again;
 345         }
 346
 347         if (cc == 2 && busy_bit)
 348                 cc |= QDIO_ERROR_SIGA_BUSY;
 349         if (cc)
 350                 QDIO_DBF_HEX3(0, trace, &cc, sizeof(int *));
 351         return cc;
 352 }
 353
 354 static inline int qdio_siga_input(struct qdio_q *q)
 355 {
 356         int cc;
 357
 358         QDIO_DBF_TEXT4(0, trace, "sigain");
 359         QDIO_DBF_HEX4(0, trace, &q, sizeof(void *));
 360
 361         qdio_perf_stat_inc(&perf_stats.siga_in);
 362
 363         cc = do_siga_input(q->irq_ptr->schid, q->mask);
 364         if (cc)
 365                 QDIO_DBF_HEX3(0, trace, &cc, sizeof(int *));
 366         return cc;
 367 }
 368
 369 /* called from thinint inbound handler */
 370 void qdio_sync_after_thinint(struct qdio_q *q)
 371 {
 372         if (pci_out_supported(q)) {
 373                 if (need_siga_sync_thinint(q))
 374                         qdio_siga_sync_all(q);
 375                 else if (need_siga_sync_out_thinint(q))
 376                         qdio_siga_sync_out(q);
 377         } else
 378                 qdio_siga_sync_q(q);
 379 }
 380
 381 inline void qdio_stop_polling(struct qdio_q *q)
 382 {
 383         spin_lock_bh(&q->u.in.lock);
 384         if (!q->u.in.polling) {
 385                 spin_unlock_bh(&q->u.in.lock);
 386                 return;
 387         }
 388         q->u.in.polling = 0;
 389         qdio_perf_stat_inc(&perf_stats.debug_stop_polling);
 390
 391         /* show the card that we are not polling anymore */
 392         set_buf_state(q, q->last_move_ftc, SLSB_P_INPUT_NOT_INIT);
 393         spin_unlock_bh(&q->u.in.lock);
 394 }
 395
 396 static void announce_buffer_error(struct qdio_q *q)
 397 {
 398         char dbf_text[15];
 399
 400         if (q->is_input_q)
 401                 QDIO_DBF_TEXT3(1, trace, "inperr");
 402         else
 403                 QDIO_DBF_TEXT3(0, trace, "outperr");
 404
 405         sprintf(dbf_text, "%x-%x-%x", q->first_to_check,
 406                 q->sbal[q->first_to_check]->element[14].flags,
 407                 q->sbal[q->first_to_check]->element[15].flags);
 408         QDIO_DBF_TEXT3(1, trace, dbf_text);
 409         QDIO_DBF_HEX2(1, trace, q->sbal[q->first_to_check], 256);
 410
 411         q->qdio_error = QDIO_ERROR_SLSB_STATE;
 412 }
 413
 414 static int get_inbound_buffer_frontier(struct qdio_q *q)
 415 {
 416         int count, stop;
 417         unsigned char state;
 418
 419         /*
 420          * If we still poll don't update last_move_ftc, keep the
 421          * previously ACK buffer there.
 422          */
 423         if (!q->u.in.polling)
 424                 q->last_move_ftc = q->first_to_check;
 425
 426         /*
 427          * Don't check 128 buffers, as otherwise qdio_inbound_q_moved
 428          * would return 0.
 429          */
 430         count = min(atomic_read(&q->nr_buf_used), QDIO_MAX_BUFFERS_MASK);
 431         stop = add_buf(q->first_to_check, count);
 432
 433         /*
 434          * No siga sync here, as a PCI or we after a thin interrupt
 435          * will sync the queues.
 436          */
 437
 438         /* need to set count to 1 for non-qebsm */
 439         if (!is_qebsm(q))
 440                 count = 1;
 441
 442 check_next:
 443         if (q->first_to_check == stop)
 444                 goto out;
 445
 446         count = get_buf_states(q, q->first_to_check, &state, count);
 447         if (!count)
 448                 goto out;
 449
 450         switch (state) {
 451         case SLSB_P_INPUT_PRIMED:
 452                 QDIO_DBF_TEXT5(0, trace, "inptprim");
 453
 454                 /*
 455                  * Only ACK the first buffer. The ACK will be removed in
 456                  * qdio_stop_polling.
 457                  */
 458                 if (q->u.in.polling)
 459                         state = SLSB_P_INPUT_NOT_INIT;
 460                 else {
 461                         q->u.in.polling = 1;
 462                         state = SLSB_P_INPUT_ACK;
 463                 }
 464                 set_buf_state(q, q->first_to_check, state);
 465
 466                 /*
 467                  * Need to change all PRIMED buffers to NOT_INIT, otherwise
 468                  * we're loosing initiative in the thinint code.
 469                  */
 470                 if (count > 1)
 471                         set_buf_states(q, next_buf(q->first_to_check),
 472                                        SLSB_P_INPUT_NOT_INIT, count - 1);
 473
 474                 /*
 475                  * No siga-sync needed for non-qebsm here, as the inbound queue
 476                  * will be synced on the next siga-r, resp.
 477                  * tiqdio_is_inbound_q_done will do the siga-sync.
 478                  */
 479                 q->first_to_check = add_buf(q->first_to_check, count);
 480                 atomic_sub(count, &q->nr_buf_used);
 481                 goto check_next;
 482         case SLSB_P_INPUT_ERROR:
 483                 announce_buffer_error(q);
 484                 /* process the buffer, the upper layer will take care of it */
 485                 q->first_to_check = add_buf(q->first_to_check, count);
 486                 atomic_sub(count, &q->nr_buf_used);
 487                 break;
 488         case SLSB_CU_INPUT_EMPTY:
 489         case SLSB_P_INPUT_NOT_INIT:
 490         case SLSB_P_INPUT_ACK:
 491                 QDIO_DBF_TEXT5(0, trace, "inpnipro");
 492                 break;
 493         default:
 494                 BUG();
 495         }
 496 out:
 497         QDIO_DBF_HEX4(0, trace, &q->first_to_check, sizeof(int));
 498         return q->first_to_check;
 499 }
 500
 501 int qdio_inbound_q_moved(struct qdio_q *q)
 502 {
 503         int bufnr;
 504
 505         bufnr = get_inbound_buffer_frontier(q);
 506
 507         if ((bufnr != q->last_move_ftc) || q->qdio_error) {
 508                 if (!need_siga_sync(q) && !pci_out_supported(q))
 509                         q->u.in.timestamp = get_usecs();
 510
 511                 QDIO_DBF_TEXT4(0, trace, "inhasmvd");
 512                 QDIO_DBF_HEX4(0, trace, &q, sizeof(void *));
 513                 return 1;
 514         } else
 515                 return 0;
 516 }
 517
 518 static int qdio_inbound_q_done(struct qdio_q *q)
 519 {
 520         unsigned char state;
 521 #ifdef CONFIG_QDIO_DEBUG
 522         char dbf_text[15];
 523 #endif
 524
 525         if (!atomic_read(&q->nr_buf_used))
 526                 return 1;
 527
 528         /*
 529          * We need that one for synchronization with the adapter, as it
 530          * does a kind of PCI avoidance.
 531          */
 532         qdio_siga_sync_q(q);
 533
 534         get_buf_state(q, q->first_to_check, &state);
 535         if (state == SLSB_P_INPUT_PRIMED)
 536                 /* we got something to do */
 537                 return 0;
 538
 539         /* on VM, we don't poll, so the q is always done here */
 540         if (need_siga_sync(q) || pci_out_supported(q))
 541                 return 1;
 542
 543         /*
 544          * At this point we know, that inbound first_to_check
 545          * has (probably) not moved (see qdio_inbound_processing).
 546          */
 547         if (get_usecs() > q->u.in.timestamp + QDIO_INPUT_THRESHOLD) {
 548 #ifdef CONFIG_QDIO_DEBUG
 549                 QDIO_DBF_TEXT4(0, trace, "inqisdon");
 550                 QDIO_DBF_HEX4(0, trace, &q, sizeof(void *));
 551                 sprintf(dbf_text, "pf%02x", q->first_to_check);
 552                 QDIO_DBF_TEXT4(0, trace, dbf_text);
 553 #endif /* CONFIG_QDIO_DEBUG */
 554                 return 1;
 555         } else {
 556 #ifdef CONFIG_QDIO_DEBUG
 557                 QDIO_DBF_TEXT4(0, trace, "inqisntd");
 558                 QDIO_DBF_HEX4(0, trace, &q, sizeof(void *));
 559                 sprintf(dbf_text, "pf%02x", q->first_to_check);
 560                 QDIO_DBF_TEXT4(0, trace, dbf_text);
 561 #endif /* CONFIG_QDIO_DEBUG */
 562                 return 0;
 563         }
 564 }
 565
 566 void qdio_kick_inbound_handler(struct qdio_q *q)
 567 {
 568         int count, start, end;
 569 #ifdef CONFIG_QDIO_DEBUG
 570         char dbf_text[15];
 571 #endif
 572
 573         qdio_perf_stat_inc(&perf_stats.inbound_handler);
 574
 575         start = q->first_to_kick;
 576         end = q->first_to_check;
 577         if (end >= start)
 578                 count = end - start;
 579         else
 580                 count = end + QDIO_MAX_BUFFERS_PER_Q - start;
 581
 582 #ifdef CONFIG_QDIO_DEBUG
 583         sprintf(dbf_text, "s=%2xc=%2x", start, count);
 584         QDIO_DBF_TEXT4(0, trace, dbf_text);
 585 #endif /* CONFIG_QDIO_DEBUG */
 586
 587         if (unlikely(q->irq_ptr->state != QDIO_IRQ_STATE_ACTIVE))
 588                 return;
 589
 590         q->handler(q->irq_ptr->cdev, q->qdio_error, q->nr,
 591                    start, count, q->irq_ptr->int_parm);
 592
 593         /* for the next time */
 594         q->first_to_kick = q->first_to_check;
 595         q->qdio_error = 0;
 596 }
 597
 598 static void __qdio_inbound_processing(struct qdio_q *q)
 599 {
 600         qdio_perf_stat_inc(&perf_stats.tasklet_inbound);
 601 again:
 602         if (!qdio_inbound_q_moved(q))
 603                 return;
 604
 605         qdio_kick_inbound_handler(q);
 606
 607         if (!qdio_inbound_q_done(q))
 608                 /* means poll time is not yet over */
 609                 goto again;
 610
 611         qdio_stop_polling(q);
 612         /*
 613          * We need to check again to not lose initiative after
 614          * resetting the ACK state.
 615          */
 616         if (!qdio_inbound_q_done(q))
 617                 goto again;
 618 }
 619
 620 /* inbound tasklet */
 621 void qdio_inbound_processing(unsigned long data)
 622 {
 623         struct qdio_q *q = (struct qdio_q *)data;
 624         __qdio_inbound_processing(q);
 625 }
 626
 627 static int get_outbound_buffer_frontier(struct qdio_q *q)
 628 {
 629         int count, stop;
 630         unsigned char state;
 631
 632         if (((queue_type(q) != QDIO_IQDIO_QFMT) && !pci_out_supported(q)) ||
 633             (queue_type(q) == QDIO_IQDIO_QFMT && multicast_outbound(q)))
 634                 qdio_siga_sync_q(q);
 635
 636         /*
 637          * Don't check 128 buffers, as otherwise qdio_inbound_q_moved
 638          * would return 0.
 639          */
 640         count = min(atomic_read(&q->nr_buf_used), QDIO_MAX_BUFFERS_MASK);
 641         stop = add_buf(q->first_to_check, count);
 642
 643         /* need to set count to 1 for non-qebsm */
 644         if (!is_qebsm(q))
 645                 count = 1;
 646
 647 check_next:
 648         if (q->first_to_check == stop)
 649                 return q->first_to_check;
 650
 651         count = get_buf_states(q, q->first_to_check, &state, count);
 652         if (!count)
 653                 return q->first_to_check;
 654
 655         switch (state) {
 656         case SLSB_P_OUTPUT_EMPTY:
 657                 /* the adapter got it */
 658                 QDIO_DBF_TEXT5(0, trace, "outpempt");
 659
 660                 atomic_sub(count, &q->nr_buf_used);
 661                 q->first_to_check = add_buf(q->first_to_check, count);
 662                 /*
 663                  * We fetch all buffer states at once. get_buf_states may
 664                  * return count < stop. For QEBSM we do not loop.
 665                  */
 666                 if (is_qebsm(q))
 667                         break;
 668                 goto check_next;
 669         case SLSB_P_OUTPUT_ERROR:
 670                 announce_buffer_error(q);
 671                 /* process the buffer, the upper layer will take care of it */
 672                 q->first_to_check = add_buf(q->first_to_check, count);
 673                 atomic_sub(count, &q->nr_buf_used);
 674                 break;
 675         case SLSB_CU_OUTPUT_PRIMED:
 676                 /* the adapter has not fetched the output yet */
 677                 QDIO_DBF_TEXT5(0, trace, "outpprim");
 678                 break;
 679         case SLSB_P_OUTPUT_NOT_INIT:
 680         case SLSB_P_OUTPUT_HALTED:
 681                 break;
 682         default:
 683                 BUG();
 684         }
 685         return q->first_to_check;
 686 }
 687
 688 /* all buffers processed? */
 689 static inline int qdio_outbound_q_done(struct qdio_q *q)
 690 {
 691         return atomic_read(&q->nr_buf_used) == 0;
 692 }
 693
 694 static inline int qdio_outbound_q_moved(struct qdio_q *q)
 695 {
 696         int bufnr;
 697
 698         bufnr = get_outbound_buffer_frontier(q);
 699
 700         if ((bufnr != q->last_move_ftc) || q->qdio_error) {
 701                 q->last_move_ftc = bufnr;
 702                 QDIO_DBF_TEXT4(0, trace, "oqhasmvd");
 703                 QDIO_DBF_HEX4(0, trace, &q, sizeof(void *));
 704                 return 1;
 705         } else
 706                 return 0;
 707 }
 708
 709 /*
 710  * VM could present us cc=2 and busy bit set on SIGA-write
 711  * during reconfiguration of their Guest LAN (only in iqdio mode,
 712  * otherwise qdio is asynchronous and cc=2 and busy bit there will take
 713  * the queues down immediately).
 714  *
 715  * Therefore qdio_siga_output will try for a short time constantly,
 716  * if such a condition occurs. If it doesn't change, it will
 717  * increase the busy_siga_counter and save the timestamp, and
 718  * schedule the queue for later processing. qdio_outbound_processing
 719  * will check out the counter. If non-zero, it will call qdio_kick_outbound_q
 720  * as often as the value of the counter. This will attempt further SIGA
 721  * instructions. For each successful SIGA, the counter is
 722  * decreased, for failing SIGAs the counter remains the same, after
 723  * all. After some time of no movement, qdio_kick_outbound_q will
 724  * finally fail and reflect corresponding error codes to call
 725  * the upper layer module and have it take the queues down.
 726  *
 727  * Note that this is a change from the original HiperSockets design
 728  * (saying cc=2 and busy bit means take the queues down), but in
 729  * these days Guest LAN didn't exist... excessive cc=2 with busy bit
 730  * conditions will still take the queues down, but the threshold is
 731  * higher due to the Guest LAN environment.
 732  *
 733  * Called from outbound tasklet and do_QDIO handler.
 734  */
 735 static void qdio_kick_outbound_q(struct qdio_q *q)
 736 {
 737         int rc;
 738 #ifdef CONFIG_QDIO_DEBUG
 739         char dbf_text[15];
 740
 741         QDIO_DBF_TEXT5(0, trace, "kickoutq");
 742         QDIO_DBF_HEX5(0, trace, &q, sizeof(void *));
 743 #endif /* CONFIG_QDIO_DEBUG */
 744
 745         if (!need_siga_out(q))
 746                 return;
 747
 748         rc = qdio_siga_output(q);
 749         switch (rc) {
 750         case 0:
 751                 /* went smooth this time, reset timestamp */
 752                 q->u.out.timestamp = 0;
 753
 754                 /* TODO: improve error handling for CC=0 case */
 755 #ifdef CONFIG_QDIO_DEBUG
 756                 QDIO_DBF_TEXT3(0, trace, "cc2reslv");
 757                 sprintf(dbf_text, "%4x%2x%2x", q->irq_ptr->schid.sch_no, q->nr,
 758                         atomic_read(&q->u.out.busy_siga_counter));
 759                 QDIO_DBF_TEXT3(0, trace, dbf_text);
 760 #endif /* CONFIG_QDIO_DEBUG */
 761                 break;
 762         /* cc=2 and busy bit */
 763         case (2 | QDIO_ERROR_SIGA_BUSY):
 764                 atomic_inc(&q->u.out.busy_siga_counter);
 765
 766                 /* if the last siga was successful, save timestamp here */
 767                 if (!q->u.out.timestamp)
 768                         q->u.out.timestamp = get_usecs();
 769
 770                 /* if we're in time, don't touch qdio_error */
 771                 if (get_usecs() - q->u.out.timestamp < QDIO_BUSY_BIT_GIVE_UP) {
 772                         tasklet_schedule(&q->tasklet);
 773                         break;
 774                 }
 775                 QDIO_DBF_TEXT2(0, trace, "cc2REPRT");
 776 #ifdef CONFIG_QDIO_DEBUG
 777                 sprintf(dbf_text, "%4x%2x%2x", q->irq_ptr->schid.sch_no, q->nr,
 778                         atomic_read(&q->u.out.busy_siga_counter));
 779                 QDIO_DBF_TEXT3(0, trace, dbf_text);
 780 #endif /* CONFIG_QDIO_DEBUG */
 781         default:
 782                 /* for plain cc=1, 2 or 3 */
 783                 q->qdio_error = rc;
 784         }
 785 }
 786
 787 static void qdio_kick_outbound_handler(struct qdio_q *q)
 788 {
 789         int start, end, count;
 790 #ifdef CONFIG_QDIO_DEBUG
 791         char dbf_text[15];
 792 #endif
 793
 794         start = q->first_to_kick;
 795         end = q->last_move_ftc;
 796         if (end >= start)
 797                 count = end - start;
 798         else
 799                 count = end + QDIO_MAX_BUFFERS_PER_Q - start;
 800
 801 #ifdef CONFIG_QDIO_DEBUG
 802         QDIO_DBF_TEXT4(0, trace, "kickouth");
 803         QDIO_DBF_HEX4(0, trace, &q, sizeof(void *));
 804
 805         sprintf(dbf_text, "s=%2xc=%2x", start, count);
 806         QDIO_DBF_TEXT4(0, trace, dbf_text);
 807 #endif /* CONFIG_QDIO_DEBUG */
 808
 809         if (unlikely(q->irq_ptr->state != QDIO_IRQ_STATE_ACTIVE))
 810                 return;
 811
 812         q->handler(q->irq_ptr->cdev, q->qdio_error, q->nr, start, count,
 813                    q->irq_ptr->int_parm);
 814
 815         /* for the next time: */
 816         q->first_to_kick = q->last_move_ftc;
 817         q->qdio_error = 0;
 818 }
 819
 820 static void __qdio_outbound_processing(struct qdio_q *q)
 821 {
 822         int siga_attempts;
 823
 824         qdio_perf_stat_inc(&perf_stats.tasklet_outbound);
 825
 826         /* see comment in qdio_kick_outbound_q */
 827         siga_attempts = atomic_read(&q->u.out.busy_siga_counter);
 828         while (siga_attempts--) {
 829                 atomic_dec(&q->u.out.busy_siga_counter);
 830                 qdio_kick_outbound_q(q);
 831         }
 832
 833         BUG_ON(atomic_read(&q->nr_buf_used) < 0);
 834
 835         if (qdio_outbound_q_moved(q))
 836                 qdio_kick_outbound_handler(q);
 837
 838         if (queue_type(q) == QDIO_ZFCP_QFMT) {
 839                 if (!pci_out_supported(q) && !qdio_outbound_q_done(q))
 840                         tasklet_schedule(&q->tasklet);
 841                 return;
 842         }
 843
 844         /* bail out for HiperSockets unicast queues */
 845         if (queue_type(q) == QDIO_IQDIO_QFMT && !multicast_outbound(q))
 846                 return;
 847
 848         if (q->u.out.pci_out_enabled)
 849                 return;
 850
 851         /*
 852          * Now we know that queue type is either qeth without pci enabled
 853          * or HiperSockets multicast. Make sure buffer switch from PRIMED to
 854          * EMPTY is noticed and outbound_handler is called after some time.
 855          */
 856         if (qdio_outbound_q_done(q))
 857                 del_timer(&q->u.out.timer);
 858         else {
 859                 if (!timer_pending(&q->u.out.timer)) {
 860                         mod_timer(&q->u.out.timer, jiffies + 10 * HZ);
 861                         qdio_perf_stat_inc(&perf_stats.debug_tl_out_timer);
 862                 }
 863         }
 864 }
 865
 866 /* outbound tasklet */
 867 void qdio_outbound_processing(unsigned long data)
 868 {
 869         struct qdio_q *q = (struct qdio_q *)data;
 870         __qdio_outbound_processing(q);
 871 }
 872
 873 void qdio_outbound_timer(unsigned long data)
 874 {
 875         struct qdio_q *q = (struct qdio_q *)data;
 876         tasklet_schedule(&q->tasklet);
 877 }
 878
 879 /* called from thinint inbound tasklet */
 880 void qdio_check_outbound_after_thinint(struct qdio_q *q)
 881 {
 882         struct qdio_q *out;
 883         int i;
 884
 885         if (!pci_out_supported(q))
 886                 return;
 887
 888         for_each_output_queue(q->irq_ptr, out, i)
 889                 if (!qdio_outbound_q_done(out))
 890                         tasklet_schedule(&out->tasklet);
 891 }
 892
 893 static inline void qdio_set_state(struct qdio_irq *irq_ptr,
 894                                   enum qdio_irq_states state)
 895 {
 896 #ifdef CONFIG_QDIO_DEBUG
 897         char dbf_text[15];
 898
 899         QDIO_DBF_TEXT5(0, trace, "newstate");
 900         sprintf(dbf_text, "%4x%4x", irq_ptr->schid.sch_no, state);
 901         QDIO_DBF_TEXT5(0, trace, dbf_text);
 902 #endif /* CONFIG_QDIO_DEBUG */
 903
 904         irq_ptr->state = state;
 905         mb();
 906 }
 907
 908 static void qdio_irq_check_sense(struct subchannel_id schid, struct irb *irb)
 909 {
 910         char dbf_text[15];
 911
 912         if (irb->esw.esw0.erw.cons) {
 913                 sprintf(dbf_text, "sens%4x", schid.sch_no);
 914                 QDIO_DBF_TEXT2(1, trace, dbf_text);
 915                 QDIO_DBF_HEX0(0, trace, irb, 64);
 916                 QDIO_DBF_HEX0(0, trace, irb->ecw, 64);
 917         }
 918 }
 919
 920 /* PCI interrupt handler */
 921 static void qdio_int_handler_pci(struct qdio_irq *irq_ptr)
 922 {
 923         int i;
 924         struct qdio_q *q;
 925
 926         qdio_perf_stat_inc(&perf_stats.pci_int);
 927
 928         for_each_input_queue(irq_ptr, q, i)
 929                 tasklet_schedule(&q->tasklet);
 930
 931         if (!(irq_ptr->qib.ac & QIB_AC_OUTBOUND_PCI_SUPPORTED))
 932                 return;
 933
 934         for_each_output_queue(irq_ptr, q, i) {
 935                 if (qdio_outbound_q_done(q))
 936                         continue;
 937
 938                 if (!siga_syncs_out_pci(q))
 939                         qdio_siga_sync_q(q);
 940
 941                 tasklet_schedule(&q->tasklet);
 942         }
 943 }
 944
 945 static void qdio_handle_activate_check(struct ccw_device *cdev,
 946                                 unsigned long intparm, int cstat, int dstat)
 947 {
 948         struct qdio_irq *irq_ptr = cdev->private->qdio_data;
 949         struct qdio_q *q;
 950         char dbf_text[15];
 951
 952         QDIO_DBF_TEXT2(1, trace, "ick2");
 953         sprintf(dbf_text, "%s", cdev->dev.bus_id);
 954         QDIO_DBF_TEXT2(1, trace, dbf_text);
 955         QDIO_DBF_HEX2(0, trace, &intparm, sizeof(int));
 956         QDIO_DBF_HEX2(0, trace, &dstat, sizeof(int));
 957         QDIO_DBF_HEX2(0, trace, &cstat, sizeof(int));
 958
 959         if (irq_ptr->nr_input_qs) {
 960                 q = irq_ptr->input_qs[0];
 961         } else if (irq_ptr->nr_output_qs) {
 962                 q = irq_ptr->output_qs[0];
 963         } else {
 964                 dump_stack();
 965                 goto no_handler;
 966         }
 967         q->handler(q->irq_ptr->cdev, QDIO_ERROR_ACTIVATE_CHECK_CONDITION,
 968                    0, -1, -1, irq_ptr->int_parm);
 969 no_handler:
 970         qdio_set_state(irq_ptr, QDIO_IRQ_STATE_STOPPED);
 971 }
 972
 973 static void qdio_call_shutdown(struct work_struct *work)
 974 {
 975         struct ccw_device_private *priv;
 976         struct ccw_device *cdev;
 977
 978         priv = container_of(work, struct ccw_device_private, kick_work);
 979         cdev = priv->cdev;
 980         qdio_shutdown(cdev, QDIO_FLAG_CLEANUP_USING_CLEAR);
 981         put_device(&cdev->dev);
 982 }
 983
 984 static void qdio_int_error(struct ccw_device *cdev)
 985 {
 986         struct qdio_irq *irq_ptr = cdev->private->qdio_data;
 987
 988         switch (irq_ptr->state) {
 989         case QDIO_IRQ_STATE_INACTIVE:
 990         case QDIO_IRQ_STATE_CLEANUP:
 991                 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_ERR);
 992                 break;
 993         case QDIO_IRQ_STATE_ESTABLISHED:
 994         case QDIO_IRQ_STATE_ACTIVE:
 995                 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_STOPPED);
 996                 if (get_device(&cdev->dev)) {
 997                         /* Can't call shutdown from interrupt context. */
 998                         PREPARE_WORK(&cdev->private->kick_work,
 999                                      qdio_call_shutdown);
1000                         queue_work(ccw_device_work, &cdev->private->kick_work);
1001                 }
1002                 break;
1003         default:
1004                 WARN_ON(1);
1005         }
1006         wake_up(&cdev->private->wait_q);
1007 }
1008
1009 static int qdio_establish_check_errors(struct ccw_device *cdev, int cstat,
1010                                            int dstat)
1011 {
1012         struct qdio_irq *irq_ptr = cdev->private->qdio_data;
1013
1014         if (cstat || (dstat & ~(DEV_STAT_CHN_END | DEV_STAT_DEV_END))) {
1015                 QDIO_DBF_TEXT2(1, setup, "eq:ckcon");
1016                 goto error;
1017         }
1018
1019         if (!(dstat & DEV_STAT_DEV_END)) {
1020                 QDIO_DBF_TEXT2(1, setup, "eq:no de");
1021                 goto error;
1022         }
1023
1024         if (dstat & ~(DEV_STAT_CHN_END | DEV_STAT_DEV_END)) {
1025                 QDIO_DBF_TEXT2(1, setup, "eq:badio");
1026                 goto error;
1027         }
1028         return 0;
1029 error:
1030         QDIO_DBF_HEX2(0, trace, &cstat, sizeof(int));
1031         QDIO_DBF_HEX2(0, trace, &dstat, sizeof(int));
1032         qdio_set_state(irq_ptr, QDIO_IRQ_STATE_ERR);
1033         return 1;
1034 }
1035
1036 static void qdio_establish_handle_irq(struct ccw_device *cdev, int cstat,
1037                                       int dstat)
1038 {
1039         struct qdio_irq *irq_ptr = cdev->private->qdio_data;
1040         char dbf_text[15];
1041
1042         sprintf(dbf_text, "qehi%4x", cdev->private->schid.sch_no);
1043         QDIO_DBF_TEXT0(0, setup, dbf_text);
1044         QDIO_DBF_TEXT0(0, trace, dbf_text);
1045
1046         if (!qdio_establish_check_errors(cdev, cstat, dstat))
1047                 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_ESTABLISHED);
1048 }
1049
1050 /* qdio interrupt handler */
1051 void qdio_int_handler(struct ccw_device *cdev, unsigned long intparm,
1052                       struct irb *irb)
1053 {
1054         struct qdio_irq *irq_ptr = cdev->private->qdio_data;
1055         int cstat, dstat;
1056         char dbf_text[15];
1057
1058         qdio_perf_stat_inc(&perf_stats.qdio_int);
1059
1060         if (!intparm || !irq_ptr) {
1061                 sprintf(dbf_text, "qihd%4x", cdev->private->schid.sch_no);
1062                 QDIO_DBF_TEXT2(1, setup, dbf_text);
1063                 return;
1064         }
1065
1066         if (IS_ERR(irb)) {
1067                 switch (PTR_ERR(irb)) {
1068                 case -EIO:
1069                         sprintf(dbf_text, "ierr%4x",
1070                                 cdev->private->schid.sch_no);
1071                         QDIO_DBF_TEXT2(1, setup, dbf_text);
1072                         qdio_int_error(cdev);
1073                         return;
1074                 case -ETIMEDOUT:
1075                         sprintf(dbf_text, "qtoh%4x",
1076                                 cdev->private->schid.sch_no);
1077                         QDIO_DBF_TEXT2(1, setup, dbf_text);
1078                         qdio_int_error(cdev);
1079                         return;
1080                 default:
1081                         WARN_ON(1);
1082                         return;
1083                 }
1084         }
1085         qdio_irq_check_sense(irq_ptr->schid, irb);
1086
1087         cstat = irb->scsw.cmd.cstat;
1088         dstat = irb->scsw.cmd.dstat;
1089
1090         switch (irq_ptr->state) {
1091         case QDIO_IRQ_STATE_INACTIVE:
1092                 qdio_establish_handle_irq(cdev, cstat, dstat);
1093                 break;
1094
1095         case QDIO_IRQ_STATE_CLEANUP:
1096                 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_INACTIVE);
1097                 break;
1098
1099         case QDIO_IRQ_STATE_ESTABLISHED:
1100         case QDIO_IRQ_STATE_ACTIVE:
1101                 if (cstat & SCHN_STAT_PCI) {
1102                         qdio_int_handler_pci(irq_ptr);
1103                         /* no state change so no need to wake up wait_q */
1104                         return;
1105                 }
1106                 if ((cstat & ~SCHN_STAT_PCI) || dstat) {
1107                         qdio_handle_activate_check(cdev, intparm, cstat,
1108                                                    dstat);
1109                         break;
1110                 }
1111         default:
1112                 WARN_ON(1);
1113         }
1114         wake_up(&cdev->private->wait_q);
1115 }
1116
1117 /**
1118  * qdio_get_ssqd_desc - get qdio subchannel description
1119  * @cdev: ccw device to get description for
1120  *
1121  * Returns a pointer to the saved qdio subchannel description,
1122  * or NULL for not setup qdio devices.
1123  */
1124 struct qdio_ssqd_desc *qdio_get_ssqd_desc(struct ccw_device *cdev)
1125 {
1126         struct qdio_irq *irq_ptr;
1127
1128         QDIO_DBF_TEXT0(0, setup, "getssqd");
1129
1130         irq_ptr = cdev->private->qdio_data;
1131         if (!irq_ptr)
1132                 return NULL;
1133
1134         return &irq_ptr->ssqd_desc;
1135 }
1136 EXPORT_SYMBOL_GPL(qdio_get_ssqd_desc);
1137
1138 /**
1139  * qdio_cleanup - shutdown queues and free data structures
1140  * @cdev: associated ccw device
1141  * @how: use halt or clear to shutdown
1142  *
1143  * This function calls qdio_shutdown() for @cdev with method @how
1144  * and on success qdio_free() for @cdev.
1145  */
1146 int qdio_cleanup(struct ccw_device *cdev, int how)
1147 {
1148         struct qdio_irq *irq_ptr;
1149         char dbf_text[15];
1150         int rc;
1151
1152         irq_ptr = cdev->private->qdio_data;
1153         if (!irq_ptr)
1154                 return -ENODEV;
1155
1156         sprintf(dbf_text, "qcln%4x", irq_ptr->schid.sch_no);
1157         QDIO_DBF_TEXT1(0, trace, dbf_text);
1158         QDIO_DBF_TEXT0(0, setup, dbf_text);
1159
1160         rc = qdio_shutdown(cdev, how);
1161         if (rc == 0)
1162                 rc = qdio_free(cdev);
1163         return rc;
1164 }
1165 EXPORT_SYMBOL_GPL(qdio_cleanup);
1166
1167 static void qdio_shutdown_queues(struct ccw_device *cdev)
1168 {
1169         struct qdio_irq *irq_ptr = cdev->private->qdio_data;
1170         struct qdio_q *q;
1171         int i;
1172
1173         for_each_input_queue(irq_ptr, q, i)
1174                 tasklet_disable(&q->tasklet);
1175
1176         for_each_output_queue(irq_ptr, q, i) {
1177                 tasklet_disable(&q->tasklet);
1178                 del_timer(&q->u.out.timer);
1179         }
1180 }
1181
1182 /**
1183  * qdio_shutdown - shut down a qdio subchannel
1184  * @cdev: associated ccw device
1185  * @how: use halt or clear to shutdown
1186  */
1187 int qdio_shutdown(struct ccw_device *cdev, int how)
1188 {
1189         struct qdio_irq *irq_ptr;
1190         int rc;
1191         unsigned long flags;
1192         char dbf_text[15];
1193
1194         irq_ptr = cdev->private->qdio_data;
1195         if (!irq_ptr)
1196                 return -ENODEV;
1197
1198         mutex_lock(&irq_ptr->setup_mutex);
1199         /*
1200          * Subchannel was already shot down. We cannot prevent being called
1201          * twice since cio may trigger a shutdown asynchronously.
1202          */
1203         if (irq_ptr->state == QDIO_IRQ_STATE_INACTIVE) {
1204                 mutex_unlock(&irq_ptr->setup_mutex);
1205                 return 0;
1206         }
1207
1208         sprintf(dbf_text, "qsqs%4x", irq_ptr->schid.sch_no);
1209         QDIO_DBF_TEXT1(0, trace, dbf_text);
1210         QDIO_DBF_TEXT0(0, setup, dbf_text);
1211
1212         tiqdio_remove_input_queues(irq_ptr);
1213         qdio_shutdown_queues(cdev);
1214         qdio_shutdown_debug_entries(irq_ptr, cdev);
1215
1216         /* cleanup subchannel */
1217         spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
1218
1219         if (how & QDIO_FLAG_CLEANUP_USING_CLEAR)
1220                 rc = ccw_device_clear(cdev, QDIO_DOING_CLEANUP);
1221         else
1222                 /* default behaviour is halt */
1223                 rc = ccw_device_halt(cdev, QDIO_DOING_CLEANUP);
1224         if (rc) {
1225                 sprintf(dbf_text, "sher%4x", irq_ptr->schid.sch_no);
1226                 QDIO_DBF_TEXT0(0, setup, dbf_text);
1227                 sprintf(dbf_text, "rc=%d", rc);
1228                 QDIO_DBF_TEXT0(0, setup, dbf_text);
1229                 goto no_cleanup;
1230         }
1231
1232         qdio_set_state(irq_ptr, QDIO_IRQ_STATE_CLEANUP);
1233         spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
1234         wait_event_interruptible_timeout(cdev->private->wait_q,
1235                 irq_ptr->state == QDIO_IRQ_STATE_INACTIVE ||
1236                 irq_ptr->state == QDIO_IRQ_STATE_ERR,
1237                 10 * HZ);
1238         spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
1239
1240 no_cleanup:
1241         qdio_shutdown_thinint(irq_ptr);
1242
1243         /* restore interrupt handler */
1244         if ((void *)cdev->handler == (void *)qdio_int_handler)
1245                 cdev->handler = irq_ptr->orig_handler;
1246         spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
1247
1248         qdio_set_state(irq_ptr, QDIO_IRQ_STATE_INACTIVE);
1249         mutex_unlock(&irq_ptr->setup_mutex);
1250         module_put(THIS_MODULE);
1251         if (rc)
1252                 return rc;
1253         return 0;
1254 }
1255 EXPORT_SYMBOL_GPL(qdio_shutdown);
1256
1257 /**
1258  * qdio_free - free data structures for a qdio subchannel
1259  * @cdev: associated ccw device
1260  */
1261 int qdio_free(struct ccw_device *cdev)
1262 {
1263         struct qdio_irq *irq_ptr;
1264         char dbf_text[15];
1265
1266         irq_ptr = cdev->private->qdio_data;
1267         if (!irq_ptr)
1268                 return -ENODEV;
1269
1270         mutex_lock(&irq_ptr->setup_mutex);
1271
1272         sprintf(dbf_text, "qfqs%4x", irq_ptr->schid.sch_no);
1273         QDIO_DBF_TEXT1(0, trace, dbf_text);
1274         QDIO_DBF_TEXT0(0, setup, dbf_text);
1275
1276         cdev->private->qdio_data = NULL;
1277         mutex_unlock(&irq_ptr->setup_mutex);
1278
1279         qdio_release_memory(irq_ptr);
1280         return 0;
1281 }
1282 EXPORT_SYMBOL_GPL(qdio_free);
1283
1284 /**
1285  * qdio_initialize - allocate and establish queues for a qdio subchannel
1286  * @init_data: initialization data
1287  *
1288  * This function first allocates queues via qdio_allocate() and on success
1289  * establishes them via qdio_establish().
1290  */
1291 int qdio_initialize(struct qdio_initialize *init_data)
1292 {
1293         int rc;
1294         char dbf_text[15];
1295
1296         sprintf(dbf_text, "qini%4x", init_data->cdev->private->schid.sch_no);
1297         QDIO_DBF_TEXT0(0, setup, dbf_text);
1298         QDIO_DBF_TEXT0(0, trace, dbf_text);
1299
1300         rc = qdio_allocate(init_data);
1301         if (rc)
1302                 return rc;
1303
1304         rc = qdio_establish(init_data);
1305         if (rc)
1306                 qdio_free(init_data->cdev);
1307         return rc;
1308 }
1309 EXPORT_SYMBOL_GPL(qdio_initialize);
1310
1311 /**
1312  * qdio_allocate - allocate qdio queues and associated data
1313  * @init_data: initialization data
1314  */
1315 int qdio_allocate(struct qdio_initialize *init_data)
1316 {
1317         struct qdio_irq *irq_ptr;
1318         char dbf_text[15];
1319
1320         sprintf(dbf_text, "qalc%4x", init_data->cdev->private->schid.sch_no);
1321         QDIO_DBF_TEXT0(0, setup, dbf_text);
1322         QDIO_DBF_TEXT0(0, trace, dbf_text);
1323
1324         if ((init_data->no_input_qs && !init_data->input_handler) ||
1325             (init_data->no_output_qs && !init_data->output_handler))
1326                 return -EINVAL;
1327
1328         if ((init_data->no_input_qs > QDIO_MAX_QUEUES_PER_IRQ) ||
1329             (init_data->no_output_qs > QDIO_MAX_QUEUES_PER_IRQ))
1330                 return -EINVAL;
1331
1332         if ((!init_data->input_sbal_addr_array) ||
1333             (!init_data->output_sbal_addr_array))
1334                 return -EINVAL;
1335
1336         qdio_allocate_do_dbf(init_data);
1337
1338         /* irq_ptr must be in GFP_DMA since it contains ccw1.cda */
1339         irq_ptr = (void *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
1340         if (!irq_ptr)
1341                 goto out_err;
1342         QDIO_DBF_TEXT0(0, setup, "irq_ptr:");
1343         QDIO_DBF_HEX0(0, setup, &irq_ptr, sizeof(void *));
1344
1345         mutex_init(&irq_ptr->setup_mutex);
1346
1347         /*
1348          * Allocate a page for the chsc calls in qdio_establish.
1349          * Must be pre-allocated since a zfcp recovery will call
1350          * qdio_establish. In case of low memory and swap on a zfcp disk
1351          * we may not be able to allocate memory otherwise.
1352          */
1353         irq_ptr->chsc_page = get_zeroed_page(GFP_KERNEL);
1354         if (!irq_ptr->chsc_page)
1355                 goto out_rel;
1356
1357         /* qdr is used in ccw1.cda which is u32 */
1358         irq_ptr->qdr = (struct qdr *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
1359         if (!irq_ptr->qdr)
1360                 goto out_rel;
1361         WARN_ON((unsigned long)irq_ptr->qdr & 0xfff);
1362
1363         QDIO_DBF_TEXT0(0, setup, "qdr:");
1364         QDIO_DBF_HEX0(0, setup, &irq_ptr->qdr, sizeof(void *));
1365
1366         if (qdio_allocate_qs(irq_ptr, init_data->no_input_qs,
1367                              init_data->no_output_qs))
1368                 goto out_rel;
1369
1370         init_data->cdev->private->qdio_data = irq_ptr;
1371         qdio_set_state(irq_ptr, QDIO_IRQ_STATE_INACTIVE);
1372         return 0;
1373 out_rel:
1374         qdio_release_memory(irq_ptr);
1375 out_err:
1376         return -ENOMEM;
1377 }
1378 EXPORT_SYMBOL_GPL(qdio_allocate);
1379
1380 /**
1381  * qdio_establish - establish queues on a qdio subchannel
1382  * @init_data: initialization data
1383  */
1384 int qdio_establish(struct qdio_initialize *init_data)
1385 {
1386         char dbf_text[20];
1387         struct qdio_irq *irq_ptr;
1388         struct ccw_device *cdev = init_data->cdev;
1389         unsigned long saveflags;
1390         int rc;
1391
1392         irq_ptr = cdev->private->qdio_data;
1393         if (!irq_ptr)
1394                 return -ENODEV;
1395
1396         if (cdev->private->state != DEV_STATE_ONLINE)
1397                 return -EINVAL;
1398
1399         if (!try_module_get(THIS_MODULE))
1400                 return -EINVAL;
1401
1402         sprintf(dbf_text, "qest%4x", cdev->private->schid.sch_no);
1403         QDIO_DBF_TEXT0(0, setup, dbf_text);
1404         QDIO_DBF_TEXT0(0, trace, dbf_text);
1405
1406         mutex_lock(&irq_ptr->setup_mutex);
1407         qdio_setup_irq(init_data);
1408
1409         rc = qdio_establish_thinint(irq_ptr);
1410         if (rc) {
1411                 mutex_unlock(&irq_ptr->setup_mutex);
1412                 qdio_shutdown(cdev, QDIO_FLAG_CLEANUP_USING_CLEAR);
1413                 return rc;
1414         }
1415
1416         /* establish q */
1417         irq_ptr->ccw.cmd_code = irq_ptr->equeue.cmd;
1418         irq_ptr->ccw.flags = CCW_FLAG_SLI;
1419         irq_ptr->ccw.count = irq_ptr->equeue.count;
1420         irq_ptr->ccw.cda = (u32)((addr_t)irq_ptr->qdr);
1421
1422         spin_lock_irqsave(get_ccwdev_lock(cdev), saveflags);
1423         ccw_device_set_options_mask(cdev, 0);
1424
1425         rc = ccw_device_start(cdev, &irq_ptr->ccw, QDIO_DOING_ESTABLISH, 0, 0);
1426         if (rc) {
1427                 sprintf(dbf_text, "eq:io%4x", irq_ptr->schid.sch_no);
1428                 QDIO_DBF_TEXT2(1, setup, dbf_text);
1429                 sprintf(dbf_text, "eq:rc%4x", rc);
1430                 QDIO_DBF_TEXT2(1, setup, dbf_text);
1431         }
1432         spin_unlock_irqrestore(get_ccwdev_lock(cdev), saveflags);
1433
1434         if (rc) {
1435                 mutex_unlock(&irq_ptr->setup_mutex);
1436                 qdio_shutdown(cdev, QDIO_FLAG_CLEANUP_USING_CLEAR);
1437                 return rc;
1438         }
1439
1440         wait_event_interruptible_timeout(cdev->private->wait_q,
1441                 irq_ptr->state == QDIO_IRQ_STATE_ESTABLISHED ||
1442                 irq_ptr->state == QDIO_IRQ_STATE_ERR, HZ);
1443
1444         if (irq_ptr->state != QDIO_IRQ_STATE_ESTABLISHED) {
1445                 mutex_unlock(&irq_ptr->setup_mutex);
1446                 qdio_shutdown(cdev, QDIO_FLAG_CLEANUP_USING_CLEAR);
1447                 return -EIO;
1448         }
1449
1450         qdio_setup_ssqd_info(irq_ptr);
1451         sprintf(dbf_text, "qib ac%2x", irq_ptr->qib.ac);
1452         QDIO_DBF_TEXT2(0, setup, dbf_text);
1453
1454         /* qebsm is now setup if available, initialize buffer states */
1455         qdio_init_buf_states(irq_ptr);
1456
1457         mutex_unlock(&irq_ptr->setup_mutex);
1458         qdio_print_subchannel_info(irq_ptr, cdev);
1459         qdio_setup_debug_entries(irq_ptr, cdev);
1460         return 0;
1461 }
1462 EXPORT_SYMBOL_GPL(qdio_establish);
1463
1464 /**
1465  * qdio_activate - activate queues on a qdio subchannel
1466  * @cdev: associated cdev
1467  */
1468 int qdio_activate(struct ccw_device *cdev)
1469 {
1470         struct qdio_irq *irq_ptr;
1471         int rc;
1472         unsigned long saveflags;
1473         char dbf_text[20];
1474
1475         irq_ptr = cdev->private->qdio_data;
1476         if (!irq_ptr)
1477                 return -ENODEV;
1478
1479         if (cdev->private->state != DEV_STATE_ONLINE)
1480                 return -EINVAL;
1481
1482         mutex_lock(&irq_ptr->setup_mutex);
1483         if (irq_ptr->state == QDIO_IRQ_STATE_INACTIVE) {
1484                 rc = -EBUSY;
1485                 goto out;
1486         }
1487
1488         sprintf(dbf_text, "qact%4x", irq_ptr->schid.sch_no);
1489         QDIO_DBF_TEXT2(0, setup, dbf_text);
1490         QDIO_DBF_TEXT2(0, trace, dbf_text);
1491
1492         irq_ptr->ccw.cmd_code = irq_ptr->aqueue.cmd;
1493         irq_ptr->ccw.flags = CCW_FLAG_SLI;
1494         irq_ptr->ccw.count = irq_ptr->aqueue.count;
1495         irq_ptr->ccw.cda = 0;
1496
1497         spin_lock_irqsave(get_ccwdev_lock(cdev), saveflags);
1498         ccw_device_set_options(cdev, CCWDEV_REPORT_ALL);
1499
1500         rc = ccw_device_start(cdev, &irq_ptr->ccw, QDIO_DOING_ACTIVATE,
1501                               0, DOIO_DENY_PREFETCH);
1502         if (rc) {
1503                 sprintf(dbf_text, "aq:io%4x", irq_ptr->schid.sch_no);
1504                 QDIO_DBF_TEXT2(1, setup, dbf_text);
1505                 sprintf(dbf_text, "aq:rc%4x", rc);
1506                 QDIO_DBF_TEXT2(1, setup, dbf_text);
1507         }
1508         spin_unlock_irqrestore(get_ccwdev_lock(cdev), saveflags);
1509
1510         if (rc)
1511                 goto out;
1512
1513         if (is_thinint_irq(irq_ptr))
1514                 tiqdio_add_input_queues(irq_ptr);
1515
1516         /* wait for subchannel to become active */
1517         msleep(5);
1518
1519         switch (irq_ptr->state) {
1520         case QDIO_IRQ_STATE_STOPPED:
1521         case QDIO_IRQ_STATE_ERR:
1522                 mutex_unlock(&irq_ptr->setup_mutex);
1523                 qdio_shutdown(cdev, QDIO_FLAG_CLEANUP_USING_CLEAR);
1524                 return -EIO;
1525         default:
1526                 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_ACTIVE);
1527                 rc = 0;
1528         }
1529 out:
1530         mutex_unlock(&irq_ptr->setup_mutex);
1531         return rc;
1532 }
1533 EXPORT_SYMBOL_GPL(qdio_activate);
1534
1535 static inline int buf_in_between(int bufnr, int start, int count)
1536 {
1537         int end = add_buf(start, count);
1538
1539         if (end > start) {
1540                 if (bufnr >= start && bufnr < end)
1541                         return 1;
1542                 else
1543                         return 0;
1544         }
1545
1546         /* wrap-around case */
1547         if ((bufnr >= start && bufnr <= QDIO_MAX_BUFFERS_PER_Q) ||
1548             (bufnr < end))
1549                 return 1;
1550         else
1551                 return 0;
1552 }
1553
1554 /**
1555  * handle_inbound - reset processed input buffers
1556  * @q: queue containing the buffers
1557  * @callflags: flags
1558  * @bufnr: first buffer to process
1559  * @count: how many buffers are emptied
1560  */
1561 static void handle_inbound(struct qdio_q *q, unsigned int callflags,
1562                            int bufnr, int count)
1563 {
1564         unsigned long flags;
1565         int used, rc;
1566
1567         /*
1568          * do_QDIO could run in parallel with the queue tasklet so the
1569          * upper-layer programm could empty the ACK'ed buffer here.
1570          * If that happens we must clear the polling flag, otherwise
1571          * qdio_stop_polling() could set the buffer to NOT_INIT after
1572          * it was set to EMPTY which would kill us.
1573          */
1574         spin_lock_irqsave(&q->u.in.lock, flags);
1575         if (q->u.in.polling)
1576                 if (buf_in_between(q->last_move_ftc, bufnr, count))
1577                         q->u.in.polling = 0;
1578
1579         count = set_buf_states(q, bufnr, SLSB_CU_INPUT_EMPTY, count);
1580         spin_unlock_irqrestore(&q->u.in.lock, flags);
1581
1582         used = atomic_add_return(count, &q->nr_buf_used) - count;
1583         BUG_ON(used + count > QDIO_MAX_BUFFERS_PER_Q);
1584
1585         /* no need to signal as long as the adapter had free buffers */
1586         if (used)
1587                 return;
1588
1589         if (need_siga_in(q)) {
1590                 rc = qdio_siga_input(q);
1591                 if (rc)
1592                         q->qdio_error = rc;
1593         }
1594 }
1595
1596 /**
1597  * handle_outbound - process filled outbound buffers
1598  * @q: queue containing the buffers
1599  * @callflags: flags
1600  * @bufnr: first buffer to process
1601  * @count: how many buffers are filled
1602  */
1603 static void handle_outbound(struct qdio_q *q, unsigned int callflags,
1604                             int bufnr, int count)
1605 {
1606         unsigned char state;
1607         int used;
1608
1609         qdio_perf_stat_inc(&perf_stats.outbound_handler);
1610
1611         count = set_buf_states(q, bufnr, SLSB_CU_OUTPUT_PRIMED, count);
1612         used = atomic_add_return(count, &q->nr_buf_used);
1613         BUG_ON(used > QDIO_MAX_BUFFERS_PER_Q);
1614
1615         if (callflags & QDIO_FLAG_PCI_OUT)
1616                 q->u.out.pci_out_enabled = 1;
1617         else
1618                 q->u.out.pci_out_enabled = 0;
1619
1620         if (queue_type(q) == QDIO_IQDIO_QFMT) {
1621                 if (multicast_outbound(q))
1622                         qdio_kick_outbound_q(q);
1623                 else
1624                         /*
1625                          * One siga-w per buffer required for unicast
1626                          * HiperSockets.
1627                          */
1628                         while (count--)
1629                                 qdio_kick_outbound_q(q);
1630                 goto out;
1631         }
1632
1633         if (need_siga_sync(q)) {
1634                 qdio_siga_sync_q(q);
1635                 goto out;
1636         }
1637
1638         /* try to fast requeue buffers */
1639         get_buf_state(q, prev_buf(bufnr), &state);
1640         if (state != SLSB_CU_OUTPUT_PRIMED)
1641                 qdio_kick_outbound_q(q);
1642         else {
1643                 QDIO_DBF_TEXT5(0, trace, "fast-req");
1644                 qdio_perf_stat_inc(&perf_stats.fast_requeue);
1645         }
1646 out:
1647         /* Fixme: could wait forever if called from process context */
1648         tasklet_schedule(&q->tasklet);
1649 }
1650
1651 /**
1652  * do_QDIO - process input or output buffers
1653  * @cdev: associated ccw_device for the qdio subchannel
1654  * @callflags: input or output and special flags from the program
1655  * @q_nr: queue number
1656  * @bufnr: buffer number
1657  * @count: how many buffers to process
1658  */
1659 int do_QDIO(struct ccw_device *cdev, unsigned int callflags,
1660             int q_nr, int bufnr, int count)
1661 {
1662         struct qdio_irq *irq_ptr;
1663 #ifdef CONFIG_QDIO_DEBUG
1664         char dbf_text[20];
1665
1666         sprintf(dbf_text, "doQD%04x", cdev->private->schid.sch_no);
1667         QDIO_DBF_TEXT3(0, trace, dbf_text);
1668 #endif /* CONFIG_QDIO_DEBUG */
1669
1670         if ((bufnr > QDIO_MAX_BUFFERS_PER_Q) ||
1671             (count > QDIO_MAX_BUFFERS_PER_Q) ||
1672             (q_nr > QDIO_MAX_QUEUES_PER_IRQ))
1673                 return -EINVAL;
1674
1675         if (!count)
1676                 return 0;
1677
1678         irq_ptr = cdev->private->qdio_data;
1679         if (!irq_ptr)
1680                 return -ENODEV;
1681
1682 #ifdef CONFIG_QDIO_DEBUG
1683         if (callflags & QDIO_FLAG_SYNC_INPUT)
1684                 QDIO_DBF_HEX3(0, trace, &irq_ptr->input_qs[q_nr],
1685                               sizeof(void *));
1686         else
1687                 QDIO_DBF_HEX3(0, trace, &irq_ptr->output_qs[q_nr],
1688                               sizeof(void *));
1689
1690         sprintf(dbf_text, "flag%04x", callflags);
1691         QDIO_DBF_TEXT3(0, trace, dbf_text);
1692         sprintf(dbf_text, "qi%02xct%02x", bufnr, count);
1693         QDIO_DBF_TEXT3(0, trace, dbf_text);
1694 #endif /* CONFIG_QDIO_DEBUG */
1695
1696         if (irq_ptr->state != QDIO_IRQ_STATE_ACTIVE)
1697                 return -EBUSY;
1698
1699         if (callflags & QDIO_FLAG_SYNC_INPUT)
1700                 handle_inbound(irq_ptr->input_qs[q_nr],
1701                                callflags, bufnr, count);
1702         else if (callflags & QDIO_FLAG_SYNC_OUTPUT)
1703                 handle_outbound(irq_ptr->output_qs[q_nr],
1704                                 callflags, bufnr, count);
1705         else {
1706                 QDIO_DBF_TEXT3(1, trace, "doQD:inv");
1707                 return -EINVAL;
1708         }
1709         return 0;
1710 }
1711 EXPORT_SYMBOL_GPL(do_QDIO);
1712
1713 static int __init init_QDIO(void)
1714 {
1715         int rc;
1716
1717         rc = qdio_setup_init();
1718         if (rc)
1719                 return rc;
1720         rc = tiqdio_allocate_memory();
1721         if (rc)
1722                 goto out_cache;
1723         rc = qdio_debug_init();
1724         if (rc)
1725                 goto out_ti;
1726         rc = qdio_setup_perf_stats();
1727         if (rc)
1728                 goto out_debug;
1729         rc = tiqdio_register_thinints();
1730         if (rc)
1731                 goto out_perf;
1732         return 0;
1733
1734 out_perf:
1735         qdio_remove_perf_stats();
1736 out_debug:
1737         qdio_debug_exit();
1738 out_ti:
1739         tiqdio_free_memory();
1740 out_cache:
1741         qdio_setup_exit();
1742         return rc;
1743 }
1744
1745 static void __exit exit_QDIO(void)
1746 {
1747         tiqdio_unregister_thinints();
1748         tiqdio_free_memory();
1749         qdio_remove_perf_stats();
1750         qdio_debug_exit();
1751         qdio_setup_exit();
1752 }
1753
1754 module_init(init_QDIO);
1755 module_exit(exit_QDIO);