drivers/s390/cio/qdio.c

   1 /*
   2  *
   3  * linux/drivers/s390/cio/qdio.c
   4  *
   5  * Linux for S/390 QDIO base support, Hipersocket base support
   6  * version 2
   7  *
   8  * Copyright 2000,2002 IBM Corporation
   9  * Author(s):             Utz Bacher <utz.bacher@de.ibm.com>
  10  * 2.6 cio integration by Cornelia Huck <cohuck@de.ibm.com>
  11  *
  12  * Restriction: only 63 iqdio subchannels would have its own indicator,
  13  * after that, subsequent subchannels share one indicator
  14  *
  15  *
  16  *
  17  *
  18  * This program is free software; you can redistribute it and/or modify
  19  * it under the terms of the GNU General Public License as published by
  20  * the Free Software Foundation; either version 2, or (at your option)
  21  * any later version.
  22  *
  23  * This program is distributed in the hope that it will be useful,
  24  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  25  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26  * GNU General Public License for more details.
  27  *
  28  * You should have received a copy of the GNU General Public License
  29  * along with this program; if not, write to the Free Software
  30  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  31  */
  32
  33 #include <linux/config.h>
  34 #include <linux/module.h>
  35 #include <linux/init.h>
  36
  37 #include <linux/slab.h>
  38 #include <linux/kernel.h>
  39 #include <linux/proc_fs.h>
  40 #include <linux/timer.h>
  41
  42 #include <asm/ccwdev.h>
  43 #include <asm/io.h>
  44 #include <asm/atomic.h>
  45 #include <asm/semaphore.h>
  46 #include <asm/timex.h>
  47
  48 #include <asm/debug.h>
  49 #include <asm/qdio.h>
  50
  51 #include "cio.h"
  52 #include "css.h"
  53 #include "device.h"
  54 #include "airq.h"
  55 #include "qdio.h"
  56 #include "ioasm.h"
  57 #include "chsc.h"
  58
  59 #define VERSION_QDIO_C "$Revision: 1.83 $"
  60
  61 /****************** MODULE PARAMETER VARIABLES ********************/
  62 MODULE_AUTHOR("Utz Bacher <utz.bacher@de.ibm.com>");
  63 MODULE_DESCRIPTION("QDIO base support version 2, " \
  64                    "Copyright 2000 IBM Corporation");
  65 MODULE_LICENSE("GPL");
  66
  67 /******************** HERE WE GO ***********************************/
  68
  69 static const char version[] = "QDIO base support version 2 ("
  70         VERSION_QDIO_C "/" VERSION_QDIO_H  "/" VERSION_CIO_QDIO_H ")";
  71
  72 #ifdef QDIO_PERFORMANCE_STATS
  73 static int proc_perf_file_registration;
  74 static unsigned long i_p_c, i_p_nc, o_p_c, o_p_nc, ii_p_c, ii_p_nc;
  75 static struct qdio_perf_stats perf_stats;
  76 #endif /* QDIO_PERFORMANCE_STATS */
  77
  78 static int hydra_thinints;
  79 static int omit_svs;
  80
  81 static int indicator_used[INDICATORS_PER_CACHELINE];
  82 static __u32 * volatile indicators;
  83 static __u32 volatile spare_indicator;
  84 static atomic_t spare_indicator_usecount;
  85
  86 static debug_info_t *qdio_dbf_setup;
  87 static debug_info_t *qdio_dbf_sbal;
  88 static debug_info_t *qdio_dbf_trace;
  89 static debug_info_t *qdio_dbf_sense;
  90 #ifdef QDIO_DBF_LIKE_HELL
  91 static debug_info_t *qdio_dbf_slsb_out;
  92 static debug_info_t *qdio_dbf_slsb_in;
  93 #endif /* QDIO_DBF_LIKE_HELL */
  94
  95 /* iQDIO stuff: */
  96 static volatile struct qdio_q *tiq_list=NULL; /* volatile as it could change
  97                                                  during a while loop */
  98 static spinlock_t ttiq_list_lock=SPIN_LOCK_UNLOCKED;
  99 static int register_thinint_result;
 100 static void tiqdio_tl(unsigned long);
 101 static DECLARE_TASKLET(tiqdio_tasklet,tiqdio_tl,0);
 102
 103 /* not a macro, as one of the arguments is atomic_read */
 104 static inline int
 105 qdio_min(int a,int b)
 106 {
 107         if (a<b)
 108                 return a;
 109         else
 110                 return b;
 111 }
 112
 113 /***************** SCRUBBER HELPER ROUTINES **********************/
 114
 115 static inline volatile __u64
 116 qdio_get_micros(void)
 117 {
 118         return (get_clock() >> 10); /* time>>12 is microseconds */
 119 }
 120
 121 /*
 122  * unfortunately, we can't just xchg the values; in do_QDIO we want to reserve
 123  * the q in any case, so that we'll not be interrupted when we are in
 124  * qdio_mark_tiq... shouldn't have a really bad impact, as reserving almost
 125  * ever works (last famous words)
 126  */
 127 static inline int
 128 qdio_reserve_q(struct qdio_q *q)
 129 {
 130         return atomic_add_return(1,&q->use_count) - 1;
 131 }
 132
 133 static inline void
 134 qdio_release_q(struct qdio_q *q)
 135 {
 136         atomic_dec(&q->use_count);
 137 }
 138
 139 static volatile inline void
 140 qdio_set_slsb(volatile char *slsb, unsigned char value)
 141 {
 142         xchg((char*)slsb,value);
 143 }
 144
 145 static inline int
 146 qdio_siga_sync(struct qdio_q *q, unsigned int gpr2,
 147                unsigned int gpr3)
 148 {
 149         int cc;
 150
 151         QDIO_DBF_TEXT4(0,trace,"sigasync");
 152         QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
 153
 154 #ifdef QDIO_PERFORMANCE_STATS
 155         perf_stats.siga_syncs++;
 156 #endif /* QDIO_PERFORMANCE_STATS */
 157
 158         cc = do_siga_sync(q->irq, gpr2, gpr3);
 159         if (cc)
 160                 QDIO_DBF_HEX3(0,trace,&cc,sizeof(int*));
 161
 162         return cc;
 163 }
 164
 165 static inline int
 166 qdio_siga_sync_q(struct qdio_q *q)
 167 {
 168         if (q->is_input_q)
 169                 return qdio_siga_sync(q, 0, q->mask);
 170         return qdio_siga_sync(q, q->mask, 0);
 171 }
 172
 173 /*
 174  * returns QDIO_SIGA_ERROR_ACCESS_EXCEPTION as cc, when SIGA returns
 175  * an access exception
 176  */
 177 static inline int
 178 qdio_siga_output(struct qdio_q *q)
 179 {
 180         int cc;
 181         __u32 busy_bit;
 182         __u64 start_time=0;
 183
 184 #ifdef QDIO_PERFORMANCE_STATS
 185         perf_stats.siga_outs++;
 186 #endif /* QDIO_PERFORMANCE_STATS */
 187
 188         QDIO_DBF_TEXT4(0,trace,"sigaout");
 189         QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
 190
 191         for (;;) {
 192                 cc = do_siga_output(q->irq, q->mask, &busy_bit);
 193 //QDIO_PRINT_ERR("cc=%x, busy=%x\n",cc,busy_bit);
 194                 if ((cc==2) && (busy_bit) && (q->is_iqdio_q)) {
 195                         if (!start_time)
 196                                 start_time=NOW;
 197                         if ((NOW-start_time)>QDIO_BUSY_BIT_PATIENCE)
 198                                 break;
 199                 } else
 200                         break;
 201         }
 202
 203         if ((cc==2) && (busy_bit))
 204                 cc |= QDIO_SIGA_ERROR_B_BIT_SET;
 205
 206         if (cc)
 207                 QDIO_DBF_HEX3(0,trace,&cc,sizeof(int*));
 208
 209         return cc;
 210 }
 211
 212 static inline int
 213 qdio_siga_input(struct qdio_q *q)
 214 {
 215         int cc;
 216
 217         QDIO_DBF_TEXT4(0,trace,"sigain");
 218         QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
 219
 220 #ifdef QDIO_PERFORMANCE_STATS
 221         perf_stats.siga_ins++;
 222 #endif /* QDIO_PERFORMANCE_STATS */
 223
 224         cc = do_siga_input(q->irq, q->mask);
 225
 226         if (cc)
 227                 QDIO_DBF_HEX3(0,trace,&cc,sizeof(int*));
 228
 229         return cc;
 230 }
 231
 232 /* locked by the locks in qdio_activate and qdio_cleanup */
 233 static __u32 * volatile
 234 qdio_get_indicator(void)
 235 {
 236         int i;
 237
 238         for (i=1;i<INDICATORS_PER_CACHELINE;i++)
 239                 if (!indicator_used[i]) {
 240                         indicator_used[i]=1;
 241                         return indicators+i;
 242                 }
 243         atomic_inc(&spare_indicator_usecount);
 244         return (__u32 * volatile) &spare_indicator;
 245 }
 246
 247 /* locked by the locks in qdio_activate and qdio_cleanup */
 248 static void
 249 qdio_put_indicator(__u32 *addr)
 250 {
 251         int i;
 252
 253         if ( (addr) && (addr!=&spare_indicator) ) {
 254                 i=addr-indicators;
 255                 indicator_used[i]=0;
 256         }
 257         if (addr == &spare_indicator)
 258                 atomic_dec(&spare_indicator_usecount);
 259 }
 260
 261 static inline volatile void
 262 tiqdio_clear_summary_bit(__u32 *location)
 263 {
 264         QDIO_DBF_TEXT5(0,trace,"clrsummb");
 265         QDIO_DBF_HEX5(0,trace,&location,sizeof(void*));
 266
 267         xchg(location,0);
 268 }
 269
 270 static inline volatile void
 271 tiqdio_set_summary_bit(__u32 *location)
 272 {
 273         QDIO_DBF_TEXT5(0,trace,"setsummb");
 274         QDIO_DBF_HEX5(0,trace,&location,sizeof(void*));
 275
 276         xchg(location,-1);
 277 }
 278
 279 static inline void
 280 tiqdio_sched_tl(void)
 281 {
 282         tasklet_hi_schedule(&tiqdio_tasklet);
 283 }
 284
 285 static inline void
 286 qdio_mark_tiq(struct qdio_q *q)
 287 {
 288         unsigned long flags;
 289
 290         QDIO_DBF_TEXT4(0,trace,"mark iq");
 291         QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
 292
 293         spin_lock_irqsave(&ttiq_list_lock,flags);
 294         if (unlikely(atomic_read(&q->is_in_shutdown)))
 295                 goto out_unlock;
 296
 297         if (!q->is_input_q)
 298                 goto out_unlock;
 299
 300         if ((q->list_prev) || (q->list_next))
 301                 goto out_unlock;
 302
 303         if (!tiq_list) {
 304                 tiq_list=q;
 305                 q->list_prev=q;
 306                 q->list_next=q;
 307         } else {
 308                 q->list_next=tiq_list;
 309                 q->list_prev=tiq_list->list_prev;
 310                 tiq_list->list_prev->list_next=q;
 311                 tiq_list->list_prev=q;
 312         }
 313         spin_unlock_irqrestore(&ttiq_list_lock,flags);
 314
 315         tiqdio_set_summary_bit((__u32*)q->dev_st_chg_ind);
 316         tiqdio_sched_tl();
 317         return;
 318 out_unlock:
 319         spin_unlock_irqrestore(&ttiq_list_lock,flags);
 320         return;
 321 }
 322
 323 static inline void
 324 qdio_mark_q(struct qdio_q *q)
 325 {
 326         QDIO_DBF_TEXT4(0,trace,"mark q");
 327         QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
 328
 329         if (unlikely(atomic_read(&q->is_in_shutdown)))
 330                 return;
 331
 332         tasklet_schedule(&q->tasklet);
 333 }
 334
 335 static inline int
 336 qdio_stop_polling(struct qdio_q *q)
 337 {
 338 #ifdef QDIO_USE_PROCESSING_STATE
 339         int gsf;
 340
 341         if (!atomic_swap(&q->polling,0))
 342                 return 1;
 343
 344         QDIO_DBF_TEXT4(0,trace,"stoppoll");
 345         QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
 346
 347         /* show the card that we are not polling anymore */
 348         if (!q->is_input_q)
 349                 return 1;
 350
 351         gsf=GET_SAVED_FRONTIER(q);
 352         set_slsb(&q->slsb.acc.val[(gsf+QDIO_MAX_BUFFERS_PER_Q-1)&
 353                                   (QDIO_MAX_BUFFERS_PER_Q-1)],
 354                  SLSB_P_INPUT_NOT_INIT);
 355         /*
 356          * we don't issue this SYNC_MEMORY, as we trust Rick T and
 357          * moreover will not use the PROCESSING state under VM, so
 358          * q->polling was 0 anyway
 359          */
 360         /*SYNC_MEMORY;*/
 361         if (q->slsb.acc.val[gsf]!=SLSB_P_INPUT_PRIMED)
 362                 return 1;
 363         /*
 364          * set our summary bit again, as otherwise there is a
 365          * small window we can miss between resetting it and
 366          * checking for PRIMED state
 367          */
 368         if (q->is_iqdio_q)
 369                 tiqdio_set_summary_bit((__u32*)q->dev_st_chg_ind);
 370         return 0;
 371
 372 #else /* QDIO_USE_PROCESSING_STATE */
 373         return 1;
 374 #endif /* QDIO_USE_PROCESSING_STATE */
 375 }
 376
 377 /*
 378  * see the comment in do_QDIO and before qdio_reserve_q about the
 379  * sophisticated locking outside of unmark_q, so that we don't need to
 380  * disable the interrupts :-)
 381 */
 382 static inline void
 383 qdio_unmark_q(struct qdio_q *q)
 384 {
 385         unsigned long flags;
 386
 387         QDIO_DBF_TEXT4(0,trace,"unmark q");
 388         QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
 389
 390         if ((!q->list_prev)||(!q->list_next))
 391                 return;
 392
 393         if ((q->is_thinint_q)&&(q->is_input_q)) {
 394                 /* iQDIO */
 395                 spin_lock_irqsave(&ttiq_list_lock,flags);
 396                 /* in case cleanup has done this already and simultanously
 397                  * qdio_unmark_q is called from the interrupt handler, we've
 398                  * got to check this in this specific case again */
 399                 if ((!q->list_prev)||(!q->list_next))
 400                         goto out;
 401                 if (q->list_next==q) {
 402                         /* q was the only interesting q */
 403                         tiq_list=NULL;
 404                         q->list_next=NULL;
 405                         q->list_prev=NULL;
 406                 } else {
 407                         q->list_next->list_prev=q->list_prev;
 408                         q->list_prev->list_next=q->list_next;
 409                         tiq_list=q->list_next;
 410                         q->list_next=NULL;
 411                         q->list_prev=NULL;
 412                 }
 413 out:
 414                 spin_unlock_irqrestore(&ttiq_list_lock,flags);
 415         }
 416 }
 417
 418 static inline unsigned long
 419 tiqdio_clear_global_summary(void)
 420 {
 421         unsigned long time;
 422
 423         QDIO_DBF_TEXT5(0,trace,"clrglobl");
 424
 425         time = do_clear_global_summary();
 426
 427         QDIO_DBF_HEX5(0,trace,&time,sizeof(unsigned long));
 428
 429         return time;
 430 }
 431
 432
 433 /************************* OUTBOUND ROUTINES *******************************/
 434
 435 inline static int
 436 qdio_get_outbound_buffer_frontier(struct qdio_q *q)
 437 {
 438         int f,f_mod_no;
 439         volatile char *slsb;
 440         int first_not_to_check;
 441         char dbf_text[15];
 442
 443         QDIO_DBF_TEXT4(0,trace,"getobfro");
 444         QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
 445
 446         slsb=&q->slsb.acc.val[0];
 447         f_mod_no=f=q->first_to_check;
 448         /*
 449          * f points to already processed elements, so f+no_used is correct...
 450          * ... but: we don't check 128 buffers, as otherwise
 451          * qdio_has_outbound_q_moved would return 0
 452          */
 453         first_not_to_check=f+qdio_min(atomic_read(&q->number_of_buffers_used),
 454                                       (QDIO_MAX_BUFFERS_PER_Q-1));
 455
 456         if ((!q->is_iqdio_q)&&(!q->hydra_gives_outbound_pcis))
 457                 SYNC_MEMORY;
 458
 459 check_next:
 460         if (f==first_not_to_check)
 461                 goto out;
 462
 463         switch(slsb[f_mod_no]) {
 464
 465         /* the adapter has not fetched the output yet */
 466         case SLSB_CU_OUTPUT_PRIMED:
 467                 QDIO_DBF_TEXT5(0,trace,"outpprim");
 468                 break;
 469
 470         /* the adapter got it */
 471         case SLSB_P_OUTPUT_EMPTY:
 472                 atomic_dec(&q->number_of_buffers_used);
 473                 f++;
 474                 f_mod_no=f&(QDIO_MAX_BUFFERS_PER_Q-1);
 475                 QDIO_DBF_TEXT5(0,trace,"outpempt");
 476                 goto check_next;
 477
 478         case SLSB_P_OUTPUT_ERROR:
 479                 QDIO_DBF_TEXT3(0,trace,"outperr");
 480                 sprintf(dbf_text,"%x-%x-%x",f_mod_no,
 481                         q->sbal[f_mod_no]->element[14].sbalf.value,
 482                         q->sbal[f_mod_no]->element[15].sbalf.value);
 483                 QDIO_DBF_TEXT3(1,trace,dbf_text);
 484                 QDIO_DBF_HEX2(1,sbal,q->sbal[f_mod_no],256);
 485
 486                 /* kind of process the buffer */
 487                 set_slsb(&q->slsb.acc.val[f_mod_no], SLSB_P_OUTPUT_NOT_INIT);
 488
 489                 /*
 490                  * we increment the frontier, as this buffer
 491                  * was processed obviously
 492                  */
 493                 atomic_dec(&q->number_of_buffers_used);
 494                 f_mod_no=(f_mod_no+1)&(QDIO_MAX_BUFFERS_PER_Q-1);
 495
 496                 if (q->qdio_error)
 497                         q->error_status_flags|=
 498                                 QDIO_STATUS_MORE_THAN_ONE_QDIO_ERROR;
 499                 q->qdio_error=SLSB_P_OUTPUT_ERROR;
 500                 q->error_status_flags|=QDIO_STATUS_LOOK_FOR_ERROR;
 501
 502                 break;
 503
 504         /* no new buffers */
 505         default:
 506                 QDIO_DBF_TEXT5(0,trace,"outpni");
 507         }
 508 out:
 509         return (q->first_to_check=f_mod_no);
 510 }
 511
 512 /* all buffers are processed */
 513 inline static int
 514 qdio_is_outbound_q_done(struct qdio_q *q)
 515 {
 516         int no_used;
 517         char dbf_text[15];
 518
 519         no_used=atomic_read(&q->number_of_buffers_used);
 520
 521         if (no_used) {
 522                 sprintf(dbf_text,"oqisnt%02x",no_used);
 523                 QDIO_DBF_TEXT4(0,trace,dbf_text);
 524         } else {
 525                 QDIO_DBF_TEXT4(0,trace,"oqisdone");
 526         }
 527         QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
 528         return (no_used==0);
 529 }
 530
 531 inline static int
 532 qdio_has_outbound_q_moved(struct qdio_q *q)
 533 {
 534         int i;
 535
 536         i=qdio_get_outbound_buffer_frontier(q);
 537
 538         if ( (i!=GET_SAVED_FRONTIER(q)) ||
 539              (q->error_status_flags&QDIO_STATUS_LOOK_FOR_ERROR) ) {
 540                 SAVE_FRONTIER(q,i);
 541                 QDIO_DBF_TEXT4(0,trace,"oqhasmvd");
 542                 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
 543                 return 1;
 544         } else {
 545                 QDIO_DBF_TEXT4(0,trace,"oqhsntmv");
 546                 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
 547                 return 0;
 548         }
 549 }
 550
 551 inline static void
 552 qdio_kick_outbound_q(struct qdio_q *q)
 553 {
 554         int result;
 555         char dbf_text[15];
 556
 557         QDIO_DBF_TEXT4(0,trace,"kickoutq");
 558         QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
 559
 560         if (!q->siga_out)
 561                 return;
 562
 563         /* here's the story with cc=2 and busy bit set (thanks, Rick):
 564          * VM's CP could present us cc=2 and busy bit set on SIGA-write
 565          * during reconfiguration of their Guest LAN (only in HIPERS mode,
 566          * QDIO mode is asynchronous -- cc=2 and busy bit there will take
 567          * the queues down immediately; and not being under VM we have a
 568          * problem on cc=2 and busy bit set right away).
 569          *
 570          * Therefore qdio_siga_output will try for a short time constantly,
 571          * if such a condition occurs. If it doesn't change, it will
 572          * increase the busy_siga_counter and save the timestamp, and
 573          * schedule the queue for later processing (via mark_q, using the
 574          * queue tasklet). __qdio_outbound_processing will check out the
 575          * counter. If non-zero, it will call qdio_kick_outbound_q as often
 576          * as the value of the counter. This will attempt further SIGA
 577          * instructions. For each successful SIGA, the counter is
 578          * decreased, for failing SIGAs the counter remains the same, after
 579          * all.
 580          * After some time of no movement, qdio_kick_outbound_q will
 581          * finally fail and reflect corresponding error codes to call
 582          * the upper layer module and have it take the queues down.
 583          *
 584          * Note that this is a change from the original HiperSockets design
 585          * (saying cc=2 and busy bit means take the queues down), but in
 586          * these days Guest LAN didn't exist... excessive cc=2 with busy bit
 587          * conditions will still take the queues down, but the threshold is
 588          * higher due to the Guest LAN environment.
 589          */
 590
 591
 592         result=qdio_siga_output(q);
 593
 594                 switch (result) {
 595                 case 0:
 596                 /* went smooth this time, reset timestamp */
 597                         QDIO_DBF_TEXT3(0,trace,"cc2reslv");
 598                         sprintf(dbf_text,"%4x%2x%2x",q->irq,q->q_no,
 599                                 atomic_read(&q->busy_siga_counter));
 600                         QDIO_DBF_TEXT3(0,trace,dbf_text);
 601                         q->timing.busy_start=0;
 602                         break;
 603                 case (2|QDIO_SIGA_ERROR_B_BIT_SET):
 604                         /* cc=2 and busy bit: */
 605                 atomic_inc(&q->busy_siga_counter);
 606
 607                         /* if the last siga was successful, save
 608                          * timestamp here */
 609                         if (!q->timing.busy_start)
 610                                 q->timing.busy_start=NOW;
 611
 612                         /* if we're in time, don't touch error_status_flags
 613                          * and siga_error */
 614                         if (NOW-q->timing.busy_start<QDIO_BUSY_BIT_GIVE_UP) {
 615                                 qdio_mark_q(q);
 616                                 break;
 617                         }
 618                         QDIO_DBF_TEXT2(0,trace,"cc2REPRT");
 619                         sprintf(dbf_text,"%4x%2x%2x",q->irq,q->q_no,
 620                                 atomic_read(&q->busy_siga_counter));
 621                         QDIO_DBF_TEXT3(0,trace,dbf_text);
 622                         /* else fallthrough and report error */
 623                 default:
 624                         /* for plain cc=1, 2 or 3: */
 625                         if (q->siga_error)
 626                                 q->error_status_flags|=
 627                                         QDIO_STATUS_MORE_THAN_ONE_SIGA_ERROR;
 628                         q->error_status_flags|=
 629                                 QDIO_STATUS_LOOK_FOR_ERROR;
 630                         q->siga_error=result;
 631                 }
 632 }
 633
 634 inline static void
 635 qdio_kick_outbound_handler(struct qdio_q *q)
 636 {
 637         int start, end, real_end, count;
 638         char dbf_text[15];
 639
 640         start = q->first_element_to_kick;
 641         /* last_move_ftc was just updated */
 642         real_end = GET_SAVED_FRONTIER(q);
 643         end = (real_end+QDIO_MAX_BUFFERS_PER_Q-1)&
 644                 (QDIO_MAX_BUFFERS_PER_Q-1);
 645         count = (end+QDIO_MAX_BUFFERS_PER_Q+1-start)&
 646                 (QDIO_MAX_BUFFERS_PER_Q-1);
 647
 648         QDIO_DBF_TEXT4(0,trace,"kickouth");
 649         QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
 650
 651         sprintf(dbf_text,"s=%2xc=%2x",start,count);
 652         QDIO_DBF_TEXT4(0,trace,dbf_text);
 653
 654         if (q->state==QDIO_IRQ_STATE_ACTIVE)
 655                 q->handler(q->cdev,QDIO_STATUS_OUTBOUND_INT|
 656                            q->error_status_flags,
 657                            q->qdio_error,q->siga_error,q->q_no,start,count,
 658                            q->int_parm);
 659
 660         /* for the next time: */
 661         q->first_element_to_kick=real_end;
 662         q->qdio_error=0;
 663         q->siga_error=0;
 664         q->error_status_flags=0;
 665 }
 666
 667 static inline void
 668 __qdio_outbound_processing(struct qdio_q *q)
 669 {
 670         int siga_attempts;
 671
 672         QDIO_DBF_TEXT4(0,trace,"qoutproc");
 673         QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
 674
 675         if (unlikely(qdio_reserve_q(q))) {
 676                 qdio_release_q(q);
 677 #ifdef QDIO_PERFORMANCE_STATS
 678                 o_p_c++;
 679 #endif /* QDIO_PERFORMANCE_STATS */
 680                 /* as we're sissies, we'll check next time */
 681                 if (likely(!atomic_read(&q->is_in_shutdown))) {
 682                         qdio_mark_q(q);
 683                         QDIO_DBF_TEXT4(0,trace,"busy,agn");
 684                 }
 685                 return;
 686         }
 687 #ifdef QDIO_PERFORMANCE_STATS
 688         o_p_nc++;
 689         perf_stats.tl_runs++;
 690 #endif /* QDIO_PERFORMANCE_STATS */
 691
 692         /* see comment in qdio_kick_outbound_q */
 693         siga_attempts=atomic_read(&q->busy_siga_counter);
 694         while (siga_attempts) {
 695                 atomic_dec(&q->busy_siga_counter);
 696                 qdio_kick_outbound_q(q);
 697                 siga_attempts--;
 698         }
 699
 700         if (qdio_has_outbound_q_moved(q))
 701                 qdio_kick_outbound_handler(q);
 702
 703         if (q->is_iqdio_q) {
 704                 /*
 705                  * for asynchronous queues, we better check, if the fill
 706                  * level is too high. for synchronous queues, the fill
 707                  * level will never be that high.
 708                  */
 709                 if (atomic_read(&q->number_of_buffers_used)>
 710                     IQDIO_FILL_LEVEL_TO_POLL)
 711                         qdio_mark_q(q);
 712
 713         } else if (!q->hydra_gives_outbound_pcis)
 714                 if (!qdio_is_outbound_q_done(q))
 715                         qdio_mark_q(q);
 716
 717         qdio_release_q(q);
 718 }
 719
 720 static void
 721 qdio_outbound_processing(struct qdio_q *q)
 722 {
 723         __qdio_outbound_processing(q);
 724 }
 725
 726 /************************* INBOUND ROUTINES *******************************/
 727
 728
 729 inline static int
 730 qdio_get_inbound_buffer_frontier(struct qdio_q *q)
 731 {
 732         int f,f_mod_no;
 733         volatile char *slsb;
 734         int first_not_to_check;
 735         char dbf_text[15];
 736 #ifdef QDIO_USE_PROCESSING_STATE
 737         int last_position=-1;
 738 #endif /* QDIO_USE_PROCESSING_STATE */
 739
 740         QDIO_DBF_TEXT4(0,trace,"getibfro");
 741         QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
 742
 743         slsb=&q->slsb.acc.val[0];
 744         f_mod_no=f=q->first_to_check;
 745         /*
 746          * we don't check 128 buffers, as otherwise qdio_has_inbound_q_moved
 747          * would return 0
 748          */
 749         first_not_to_check=f+qdio_min(atomic_read(&q->number_of_buffers_used),
 750                                       (QDIO_MAX_BUFFERS_PER_Q-1));
 751
 752         /*
 753          * we don't use this one, as a PCI or we after a thin interrupt
 754          * will sync the queues
 755          */
 756         /* SYNC_MEMORY;*/
 757
 758 check_next:
 759         f_mod_no=f&(QDIO_MAX_BUFFERS_PER_Q-1);
 760         if (f==first_not_to_check)
 761                 goto out;
 762         switch (slsb[f_mod_no]) {
 763
 764         /* CU_EMPTY means frontier is reached */
 765         case SLSB_CU_INPUT_EMPTY:
 766                 QDIO_DBF_TEXT5(0,trace,"inptempt");
 767                 break;
 768
 769         /* P_PRIMED means set slsb to P_PROCESSING and move on */
 770         case SLSB_P_INPUT_PRIMED:
 771                 QDIO_DBF_TEXT5(0,trace,"inptprim");
 772
 773 #ifdef QDIO_USE_PROCESSING_STATE
 774                 /*
 775                  * as soon as running under VM, polling the input queues will
 776                  * kill VM in terms of CP overhead
 777                  */
 778                 if (q->siga_sync) {
 779                         set_slsb(&slsb[f_mod_no],SLSB_P_INPUT_NOT_INIT);
 780                 } else {
 781                         /* set the previous buffer to NOT_INIT. The current
 782                          * buffer will be set to PROCESSING at the end of
 783                          * this function to avoid further interrupts. */
 784                         if (last_position>=0)
 785                                 set_slsb(&slsb[last_position],
 786                                          SLSB_P_INPUT_NOT_INIT);
 787                         atomic_set(&q->polling,1);
 788                         last_position=f_mod_no;
 789                 }
 790 #else /* QDIO_USE_PROCESSING_STATE */
 791                 set_slsb(&slsb[f_mod_no],SLSB_P_INPUT_NOT_INIT);
 792 #endif /* QDIO_USE_PROCESSING_STATE */
 793                 /*
 794                  * not needed, as the inbound queue will be synced on the next
 795                  * siga-r
 796                  */
 797                 /*SYNC_MEMORY;*/
 798                 f++;
 799                 atomic_dec(&q->number_of_buffers_used);
 800                 goto check_next;
 801
 802         case SLSB_P_INPUT_NOT_INIT:
 803         case SLSB_P_INPUT_PROCESSING:
 804                 QDIO_DBF_TEXT5(0,trace,"inpnipro");
 805                 break;
 806
 807         /* P_ERROR means frontier is reached, break and report error */
 808         case SLSB_P_INPUT_ERROR:
 809                 sprintf(dbf_text,"inperr%2x",f_mod_no);
 810                 QDIO_DBF_TEXT3(1,trace,dbf_text);
 811                 QDIO_DBF_HEX2(1,sbal,q->sbal[f_mod_no],256);
 812
 813                 /* kind of process the buffer */
 814                 set_slsb(&slsb[f_mod_no],SLSB_P_INPUT_NOT_INIT);
 815
 816                 if (q->qdio_error)
 817                         q->error_status_flags|=
 818                                 QDIO_STATUS_MORE_THAN_ONE_QDIO_ERROR;
 819                 q->qdio_error=SLSB_P_INPUT_ERROR;
 820                 q->error_status_flags|=QDIO_STATUS_LOOK_FOR_ERROR;
 821
 822                 /* we increment the frontier, as this buffer
 823                  * was processed obviously */
 824                 f_mod_no=(f_mod_no+1)&(QDIO_MAX_BUFFERS_PER_Q-1);
 825                 atomic_dec(&q->number_of_buffers_used);
 826
 827 #ifdef QDIO_USE_PROCESSING_STATE
 828                 last_position=-1;
 829 #endif /* QDIO_USE_PROCESSING_STATE */
 830
 831                 break;
 832
 833         /* everything else means frontier not changed (HALTED or so) */
 834         default:
 835                 break;
 836         }
 837 out:
 838         q->first_to_check=f_mod_no;
 839
 840 #ifdef QDIO_USE_PROCESSING_STATE
 841         if (last_position>=0)
 842                 set_slsb(&slsb[last_position],SLSB_P_INPUT_PROCESSING);
 843 #endif /* QDIO_USE_PROCESSING_STATE */
 844
 845         QDIO_DBF_HEX4(0,trace,&q->first_to_check,sizeof(int));
 846
 847         return q->first_to_check;
 848 }
 849
 850 inline static int
 851 qdio_has_inbound_q_moved(struct qdio_q *q)
 852 {
 853         int i;
 854
 855 #ifdef QDIO_PERFORMANCE_STATS
 856         static int old_pcis=0;
 857         static int old_thinints=0;
 858
 859         if ((old_pcis==perf_stats.pcis)&&(old_thinints==perf_stats.thinints))
 860                 perf_stats.start_time_inbound=NOW;
 861         else
 862                 old_pcis=perf_stats.pcis;
 863 #endif /* QDIO_PERFORMANCE_STATS */
 864
 865         i=qdio_get_inbound_buffer_frontier(q);
 866         if ( (i!=GET_SAVED_FRONTIER(q)) ||
 867              (q->error_status_flags&QDIO_STATUS_LOOK_FOR_ERROR) ) {
 868                 SAVE_FRONTIER(q,i);
 869                 if ((!q->siga_sync)&&(!q->hydra_gives_outbound_pcis))
 870                         SAVE_TIMESTAMP(q);
 871
 872                 QDIO_DBF_TEXT4(0,trace,"inhasmvd");
 873                 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
 874                 return 1;
 875         } else {
 876                 QDIO_DBF_TEXT4(0,trace,"inhsntmv");
 877                 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
 878                 return 0;
 879         }
 880 }
 881
 882 /* means, no more buffers to be filled */
 883 inline static int
 884 iqdio_is_inbound_q_done(struct qdio_q *q)
 885 {
 886         int no_used;
 887         char dbf_text[15];
 888
 889         no_used=atomic_read(&q->number_of_buffers_used);
 890
 891         /* propagate the change from 82 to 80 through VM */
 892         SYNC_MEMORY;
 893
 894         if (no_used) {
 895                 sprintf(dbf_text,"iqisnt%02x",no_used);
 896                 QDIO_DBF_TEXT4(0,trace,dbf_text);
 897         } else {
 898                 QDIO_DBF_TEXT4(0,trace,"iniqisdo");
 899         }
 900         QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
 901
 902         if (!no_used)
 903                 return 1;
 904
 905         if (!q->siga_sync)
 906                 /* we'll check for more primed buffers in qeth_stop_polling */
 907                 return 0;
 908
 909         if (q->slsb.acc.val[q->first_to_check]!=SLSB_P_INPUT_PRIMED)
 910                 /*
 911                  * nothing more to do, if next buffer is not PRIMED.
 912                  * note that we did a SYNC_MEMORY before, that there
 913                  * has been a sychnronization.
 914                  * we will return 0 below, as there is nothing to do
 915                  * (stop_polling not necessary, as we have not been
 916                  * using the PROCESSING state
 917                  */
 918                 return 0;
 919
 920         /*
 921          * ok, the next input buffer is primed. that means, that device state
 922          * change indicator and adapter local summary are set, so we will find
 923          * it next time.
 924          * we will return 0 below, as there is nothing to do, except scheduling
 925          * ourselves for the next time.
 926          */
 927         tiqdio_set_summary_bit((__u32*)q->dev_st_chg_ind);
 928         tiqdio_sched_tl();
 929         return 0;
 930 }
 931
 932 inline static int
 933 qdio_is_inbound_q_done(struct qdio_q *q)
 934 {
 935         int no_used;
 936         char dbf_text[15];
 937
 938         no_used=atomic_read(&q->number_of_buffers_used);
 939
 940         /*
 941          * we need that one for synchronization with the adapter, as it
 942          * does a kind of PCI avoidance
 943          */
 944         SYNC_MEMORY;
 945
 946         if (!no_used) {
 947                 QDIO_DBF_TEXT4(0,trace,"inqisdnA");
 948                 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
 949                 QDIO_DBF_TEXT4(0,trace,dbf_text);
 950                 return 1;
 951         }
 952
 953         if (q->slsb.acc.val[q->first_to_check]==SLSB_P_INPUT_PRIMED) {
 954                 /* we got something to do */
 955                 QDIO_DBF_TEXT4(0,trace,"inqisntA");
 956                 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
 957                 return 0;
 958         }
 959
 960         /* on VM, we don't poll, so the q is always done here */
 961         if (q->siga_sync)
 962                 return 1;
 963         if (q->hydra_gives_outbound_pcis)
 964                 return 1;
 965
 966         /*
 967          * at this point we know, that inbound first_to_check
 968          * has (probably) not moved (see qdio_inbound_processing)
 969          */
 970         if (NOW>GET_SAVED_TIMESTAMP(q)+q->timing.threshold) {
 971                 QDIO_DBF_TEXT4(0,trace,"inqisdon");
 972                 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
 973                 sprintf(dbf_text,"pf%02xcn%02x",q->first_to_check,no_used);
 974                 QDIO_DBF_TEXT4(0,trace,dbf_text);
 975                 return 1;
 976         } else {
 977                 QDIO_DBF_TEXT4(0,trace,"inqisntd");
 978                 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
 979                 sprintf(dbf_text,"pf%02xcn%02x",q->first_to_check,no_used);
 980                 QDIO_DBF_TEXT4(0,trace,dbf_text);
 981                 return 0;
 982         }
 983 }
 984
 985 inline static void
 986 qdio_kick_inbound_handler(struct qdio_q *q)
 987 {
 988         int count, start, end, real_end, i;
 989         char dbf_text[15];
 990
 991         QDIO_DBF_TEXT4(0,trace,"kickinh");
 992         QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
 993
 994         start=q->first_element_to_kick;
 995         real_end=q->first_to_check;
 996         end=(real_end+QDIO_MAX_BUFFERS_PER_Q-1)&(QDIO_MAX_BUFFERS_PER_Q-1);
 997
 998         i=start;
 999         count=0;
1000         while (1) {
1001                 count++;
1002                 if (i==end)
1003                         break;
1004                 i=(i+1)&(QDIO_MAX_BUFFERS_PER_Q-1);
1005         }
1006
1007         sprintf(dbf_text,"s=%2xc=%2x",start,count);
1008         QDIO_DBF_TEXT4(0,trace,dbf_text);
1009
1010         if (likely(q->state==QDIO_IRQ_STATE_ACTIVE))
1011                 q->handler(q->cdev,
1012                            QDIO_STATUS_INBOUND_INT|q->error_status_flags,
1013                            q->qdio_error,q->siga_error,q->q_no,start,count,
1014                            q->int_parm);
1015
1016         /* for the next time: */
1017         q->first_element_to_kick=real_end;
1018         q->qdio_error=0;
1019         q->siga_error=0;
1020         q->error_status_flags=0;
1021
1022 #ifdef QDIO_PERFORMANCE_STATS
1023         perf_stats.inbound_time+=NOW-perf_stats.start_time_inbound;
1024         perf_stats.inbound_cnt++;
1025 #endif /* QDIO_PERFORMANCE_STATS */
1026 }
1027
1028 static inline void
1029 __tiqdio_inbound_processing(struct qdio_q *q, int spare_ind_was_set)
1030 {
1031         struct qdio_irq *irq_ptr;
1032         struct qdio_q *oq;
1033         int i;
1034
1035         QDIO_DBF_TEXT4(0,trace,"iqinproc");
1036         QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
1037
1038         /*
1039          * we first want to reserve the q, so that we know, that we don't
1040          * interrupt ourselves and call qdio_unmark_q, as is_in_shutdown might
1041          * be set
1042          */
1043         if (unlikely(qdio_reserve_q(q))) {
1044                 qdio_release_q(q);
1045 #ifdef QDIO_PERFORMANCE_STATS
1046                 ii_p_c++;
1047 #endif /* QDIO_PERFORMANCE_STATS */
1048                 /*
1049                  * as we might just be about to stop polling, we make
1050                  * sure that we check again at least once more
1051                  */
1052                 tiqdio_sched_tl();
1053                 return;
1054         }
1055 #ifdef QDIO_PERFORMANCE_STATS
1056         ii_p_nc++;
1057 #endif /* QDIO_PERFORMANCE_STATS */
1058         if (unlikely(atomic_read(&q->is_in_shutdown))) {
1059                 qdio_unmark_q(q);
1060                 goto out;
1061         }
1062
1063         /*
1064          * we reset spare_ind_was_set, when the queue does not use the
1065          * spare indicator
1066          */
1067         if (spare_ind_was_set)
1068                 spare_ind_was_set = (q->dev_st_chg_ind == &spare_indicator);
1069
1070         if (!(*(q->dev_st_chg_ind)) && !spare_ind_was_set)
1071                 goto out;
1072         /*
1073          * q->dev_st_chg_ind is the indicator, be it shared or not.
1074          * only clear it, if indicator is non-shared
1075          */
1076         if (!spare_ind_was_set)
1077                 tiqdio_clear_summary_bit((__u32*)q->dev_st_chg_ind);
1078
1079         if (q->hydra_gives_outbound_pcis) {
1080                 if (!q->siga_sync_done_on_thinints) {
1081                         SYNC_MEMORY_ALL;
1082                 } else if ((!q->siga_sync_done_on_outb_tis)&&
1083                          (q->hydra_gives_outbound_pcis)) {
1084                         SYNC_MEMORY_ALL_OUTB;
1085                 }
1086         } else {
1087                 SYNC_MEMORY;
1088         }
1089         /*
1090          * maybe we have to do work on our outbound queues... at least
1091          * we have to check the outbound-int-capable thinint-capable
1092          * queues
1093          */
1094         if (q->hydra_gives_outbound_pcis) {
1095                 irq_ptr = (struct qdio_irq*)q->irq_ptr;
1096                 for (i=0;i<irq_ptr->no_output_qs;i++) {
1097                         oq = irq_ptr->output_qs[i];
1098 #ifdef QDIO_PERFORMANCE_STATS
1099                         perf_stats.tl_runs--;
1100 #endif /* QDIO_PERFORMANCE_STATS */
1101                         if (!qdio_is_outbound_q_done(oq))
1102                                 __qdio_outbound_processing(oq);
1103                 }
1104         }
1105
1106         if (!qdio_has_inbound_q_moved(q))
1107                 goto out;
1108
1109         qdio_kick_inbound_handler(q);
1110         if (iqdio_is_inbound_q_done(q))
1111                 if (!qdio_stop_polling(q)) {
1112                         /*
1113                          * we set the flags to get into the stuff next time,
1114                          * see also comment in qdio_stop_polling
1115                          */
1116                         tiqdio_set_summary_bit((__u32*)q->dev_st_chg_ind);
1117                         tiqdio_sched_tl();
1118                 }
1119 out:
1120         qdio_release_q(q);
1121 }
1122
1123 static void
1124 tiqdio_inbound_processing(struct qdio_q *q)
1125 {
1126         __tiqdio_inbound_processing(q, atomic_read(&spare_indicator_usecount));
1127 }
1128
1129 static inline void
1130 __qdio_inbound_processing(struct qdio_q *q)
1131 {
1132         int q_laps=0;
1133
1134         QDIO_DBF_TEXT4(0,trace,"qinproc");
1135         QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
1136
1137         if (unlikely(qdio_reserve_q(q))) {
1138                 qdio_release_q(q);
1139 #ifdef QDIO_PERFORMANCE_STATS
1140                 i_p_c++;
1141 #endif /* QDIO_PERFORMANCE_STATS */
1142                 /* as we're sissies, we'll check next time */
1143                 if (likely(!atomic_read(&q->is_in_shutdown))) {
1144                         qdio_mark_q(q);
1145                         QDIO_DBF_TEXT4(0,trace,"busy,agn");
1146                 }
1147                 return;
1148         }
1149 #ifdef QDIO_PERFORMANCE_STATS
1150         i_p_nc++;
1151         perf_stats.tl_runs++;
1152 #endif /* QDIO_PERFORMANCE_STATS */
1153
1154 again:
1155         if (qdio_has_inbound_q_moved(q)) {
1156                 qdio_kick_inbound_handler(q);
1157                 if (!qdio_stop_polling(q)) {
1158                         q_laps++;
1159                         if (q_laps<QDIO_Q_LAPS)
1160                                 goto again;
1161                 }
1162                 qdio_mark_q(q);
1163         } else {
1164                 if (!qdio_is_inbound_q_done(q))
1165                         /* means poll time is not yet over */
1166                         qdio_mark_q(q);
1167         }
1168
1169         qdio_release_q(q);
1170 }
1171
1172 static void
1173 qdio_inbound_processing(struct qdio_q *q)
1174 {
1175         __qdio_inbound_processing(q);
1176 }
1177
1178 /************************* MAIN ROUTINES *******************************/
1179
1180 #ifdef QDIO_USE_PROCESSING_STATE
1181 static inline int
1182 tiqdio_reset_processing_state(struct qdio_q *q, int q_laps)
1183 {
1184         if (!q) {
1185                 tiqdio_sched_tl();
1186                 return 0;
1187         }
1188
1189         /*
1190          * under VM, we have not used the PROCESSING state, so no
1191          * need to stop polling
1192          */
1193         if (q->siga_sync)
1194                 return 2;
1195
1196         if (unlikely(qdio_reserve_q(q))) {
1197                 qdio_release_q(q);
1198 #ifdef QDIO_PERFORMANCE_STATS
1199                 ii_p_c++;
1200 #endif /* QDIO_PERFORMANCE_STATS */
1201                 /*
1202                  * as we might just be about to stop polling, we make
1203                  * sure that we check again at least once more
1204                  */
1205
1206                 /*
1207                  * sanity -- we'd get here without setting the
1208                  * dev st chg ind
1209                  */
1210                 tiqdio_set_summary_bit((__u32*)q->dev_st_chg_ind);
1211                 tiqdio_sched_tl();
1212                 return 0;
1213         }
1214         if (qdio_stop_polling(q)) {
1215                 qdio_release_q(q);
1216                 return 2;
1217         }
1218         if (q_laps<QDIO_Q_LAPS-1) {
1219                 qdio_release_q(q);
1220                 return 3;
1221         }
1222         /*
1223          * we set the flags to get into the stuff
1224          * next time, see also comment in qdio_stop_polling
1225          */
1226         tiqdio_set_summary_bit((__u32*)q->dev_st_chg_ind);
1227         tiqdio_sched_tl();
1228         qdio_release_q(q);
1229         return 1;
1230
1231 }
1232 #endif /* QDIO_USE_PROCESSING_STATE */
1233
1234 static inline void
1235 tiqdio_inbound_checks(void)
1236 {
1237         struct qdio_q *q;
1238         int spare_ind_was_set=0;
1239 #ifdef QDIO_USE_PROCESSING_STATE
1240         int q_laps=0;
1241 #endif /* QDIO_USE_PROCESSING_STATE */
1242
1243         QDIO_DBF_TEXT4(0,trace,"iqdinbck");
1244         QDIO_DBF_TEXT5(0,trace,"iqlocsum");
1245
1246 #ifdef QDIO_USE_PROCESSING_STATE
1247 again:
1248 #endif /* QDIO_USE_PROCESSING_STATE */
1249
1250         /* when the spare indicator is used and set, save that and clear it */
1251         if ((atomic_read(&spare_indicator_usecount)) && spare_indicator) {
1252                 spare_ind_was_set = 1;
1253                 tiqdio_clear_summary_bit((__u32*)&spare_indicator);
1254         }
1255
1256         q=(struct qdio_q*)tiq_list;
1257         do {
1258                 if (!q)
1259                         break;
1260                 __tiqdio_inbound_processing(q, spare_ind_was_set);
1261                 q=(struct qdio_q*)q->list_next;
1262         } while (q!=(struct qdio_q*)tiq_list);
1263
1264 #ifdef QDIO_USE_PROCESSING_STATE
1265         q=(struct qdio_q*)tiq_list;
1266         do {
1267                 int ret;
1268
1269                 ret = tiqdio_reset_processing_state(q, q_laps);
1270                 switch (ret) {
1271                 case 0:
1272                         return;
1273                 case 1:
1274                         q_laps++;
1275                 case 2:
1276                         q = (struct qdio_q*)q->list_next;
1277                         break;
1278                 default:
1279                         q_laps++;
1280                         goto again;
1281                 }
1282         } while (q!=(struct qdio_q*)tiq_list);
1283 #endif /* QDIO_USE_PROCESSING_STATE */
1284 }
1285
1286 static void
1287 tiqdio_tl(unsigned long data)
1288 {
1289         QDIO_DBF_TEXT4(0,trace,"iqdio_tl");
1290
1291 #ifdef QDIO_PERFORMANCE_STATS
1292         perf_stats.tl_runs++;
1293 #endif /* QDIO_PERFORMANCE_STATS */
1294
1295         tiqdio_inbound_checks();
1296 }
1297
1298 /********************* GENERAL HELPER_ROUTINES ***********************/
1299
1300 static void
1301 qdio_release_irq_memory(struct qdio_irq *irq_ptr)
1302 {
1303         int i;
1304
1305         for (i=0;i<QDIO_MAX_QUEUES_PER_IRQ;i++) {
1306                 if (!irq_ptr->input_qs[i])
1307                         goto next;
1308
1309                 if (irq_ptr->input_qs[i]->slib)
1310                         kfree(irq_ptr->input_qs[i]->slib);
1311                 kfree(irq_ptr->input_qs[i]);
1312
1313 next:
1314                 if (!irq_ptr->output_qs[i])
1315                         continue;
1316
1317                 if (irq_ptr->output_qs[i]->slib)
1318                         kfree(irq_ptr->output_qs[i]->slib);
1319                 kfree(irq_ptr->output_qs[i]);
1320
1321         }
1322         kfree(irq_ptr->qdr);
1323         kfree(irq_ptr->actual_alloc);   /* This frees irq_ptr itself. */
1324 }
1325
1326 static void
1327 qdio_set_impl_params(struct qdio_irq *irq_ptr,
1328                      unsigned int qib_param_field_format,
1329                      /* pointer to 128 bytes or NULL, if no param field */
1330                      unsigned char *qib_param_field,
1331                      /* pointer to no_queues*128 words of data or NULL */
1332                      unsigned int no_input_qs,
1333                      unsigned int no_output_qs,
1334                      unsigned long *input_slib_elements,
1335                      unsigned long *output_slib_elements)
1336 {
1337         int i,j;
1338
1339         if (!irq_ptr)
1340                 return;
1341
1342         irq_ptr->qib.pfmt=qib_param_field_format;
1343         if (qib_param_field)
1344                 memcpy(irq_ptr->qib.parm,qib_param_field,
1345                        QDIO_MAX_BUFFERS_PER_Q);
1346
1347         if (input_slib_elements)
1348                 for (i=0;i<no_input_qs;i++) {
1349                         for (j=0;j<QDIO_MAX_BUFFERS_PER_Q;j++)
1350                                 irq_ptr->input_qs[i]->slib->slibe[j].parms=
1351                                         input_slib_elements[
1352                                                 i*QDIO_MAX_BUFFERS_PER_Q+j];
1353                 }
1354         if (output_slib_elements)
1355                 for (i=0;i<no_output_qs;i++) {
1356                         for (j=0;j<QDIO_MAX_BUFFERS_PER_Q;j++)
1357                                 irq_ptr->output_qs[i]->slib->slibe[j].parms=
1358                                         output_slib_elements[
1359                                                 i*QDIO_MAX_BUFFERS_PER_Q+j];
1360                 }
1361 }
1362
1363 static int
1364 qdio_alloc_qs(struct qdio_irq *irq_ptr,
1365               int no_input_qs, int no_output_qs)
1366 {
1367         int i;
1368         struct qdio_q *q;
1369         int result=-ENOMEM;
1370
1371         for (i=0;i<no_input_qs;i++) {
1372                 q=kmalloc(sizeof(struct qdio_q),GFP_KERNEL);
1373
1374                 if (!q) {
1375                         QDIO_PRINT_ERR("kmalloc of q failed!\n");
1376                         goto out;
1377                 }
1378
1379                 memset(q,0,sizeof(struct qdio_q));
1380
1381                 q->slib=kmalloc(PAGE_SIZE,GFP_KERNEL);
1382                 if (!q->slib) {
1383                         QDIO_PRINT_ERR("kmalloc of slib failed!\n");
1384                         goto out;
1385                 }
1386
1387                 irq_ptr->input_qs[i]=q;
1388         }
1389
1390         for (i=0;i<no_output_qs;i++) {
1391                 q=kmalloc(sizeof(struct qdio_q),GFP_KERNEL);
1392
1393                 if (!q) {
1394                         goto out;
1395                 }
1396
1397                 memset(q,0,sizeof(struct qdio_q));
1398
1399                 q->slib=kmalloc(PAGE_SIZE,GFP_KERNEL);
1400                 if (!q->slib) {
1401                         QDIO_PRINT_ERR("kmalloc of slib failed!\n");
1402                         goto out;
1403                 }
1404
1405                 irq_ptr->output_qs[i]=q;
1406         }
1407
1408         result=0;
1409 out:
1410         return result;
1411 }
1412
1413 static void
1414 qdio_fill_qs(struct qdio_irq *irq_ptr, struct ccw_device *cdev,
1415              int no_input_qs, int no_output_qs,
1416              qdio_handler_t *input_handler,
1417              qdio_handler_t *output_handler,
1418              unsigned long int_parm,int q_format,
1419              unsigned long flags,
1420              void **inbound_sbals_array,
1421              void **outbound_sbals_array)
1422 {
1423         struct qdio_q *q;
1424         int i,j;
1425         char dbf_text[20]; /* see qdio_initialize */
1426         void *ptr;
1427         int available;
1428
1429         sprintf(dbf_text,"qfqs%4x",cdev->private->irq);
1430         QDIO_DBF_TEXT0(0,setup,dbf_text);
1431         for (i=0;i<no_input_qs;i++) {
1432                 q=irq_ptr->input_qs[i];
1433
1434                 memset(q,0,((char*)&q->slib)-((char*)q));
1435                 sprintf(dbf_text,"in-q%4x",i);
1436                 QDIO_DBF_TEXT0(0,setup,dbf_text);
1437                 QDIO_DBF_HEX0(0,setup,&q,sizeof(void*));
1438
1439                 memset(q->slib,0,PAGE_SIZE);
1440                 q->sl=(struct sl*)(((char*)q->slib)+PAGE_SIZE/2);
1441
1442                 available=0;
1443
1444                 for (j=0;j<QDIO_MAX_BUFFERS_PER_Q;j++)
1445                         q->sbal[j]=*(inbound_sbals_array++);
1446
1447                 q->queue_type=q_format;
1448                 q->int_parm=int_parm;
1449                 q->irq=irq_ptr->irq;
1450                 q->irq_ptr = irq_ptr;
1451                 q->cdev = cdev;
1452                 q->mask=1<<(31-i);
1453                 q->q_no=i;
1454                 q->is_input_q=1;
1455                 q->first_to_check=0;
1456                 q->last_move_ftc=0;
1457                 q->handler=input_handler;
1458                 q->dev_st_chg_ind=irq_ptr->dev_st_chg_ind;
1459
1460                 q->tasklet.data=(unsigned long)q;
1461                 /* q->is_thinint_q isn't valid at this time, but
1462                  * irq_ptr->is_thinint_irq is */
1463                 q->tasklet.func=(void(*)(unsigned long))
1464                         ((irq_ptr->is_thinint_irq)?&tiqdio_inbound_processing:
1465                          &qdio_inbound_processing);
1466
1467                 /* actually this is not used for inbound queues. yet. */
1468                 atomic_set(&q->busy_siga_counter,0);
1469                 q->timing.busy_start=0;
1470
1471 /*              for (j=0;j<QDIO_STATS_NUMBER;j++)
1472                         q->timing.last_transfer_times[j]=(qdio_get_micros()/
1473                                                           QDIO_STATS_NUMBER)*j;
1474                 q->timing.last_transfer_index=QDIO_STATS_NUMBER-1;
1475 */
1476
1477                 /* fill in slib */
1478                 if (i>0) irq_ptr->input_qs[i-1]->slib->nsliba=
1479                                  (unsigned long)(q->slib);
1480                 q->slib->sla=(unsigned long)(q->sl);
1481                 q->slib->slsba=(unsigned long)(&q->slsb.acc.val[0]);
1482
1483                 /* fill in sl */
1484                 for (j=0;j<QDIO_MAX_BUFFERS_PER_Q;j++)
1485                         q->sl->element[j].sbal=(unsigned long)(q->sbal[j]);
1486
1487                 QDIO_DBF_TEXT2(0,setup,"sl-sb-b0");
1488                 ptr=(void*)q->sl;
1489                 QDIO_DBF_HEX2(0,setup,&ptr,sizeof(void*));
1490                 ptr=(void*)&q->slsb;
1491                 QDIO_DBF_HEX2(0,setup,&ptr,sizeof(void*));
1492                 ptr=(void*)q->sbal[0];
1493                 QDIO_DBF_HEX2(0,setup,&ptr,sizeof(void*));
1494
1495                 /* fill in slsb */
1496                 for (j=0;j<QDIO_MAX_BUFFERS_PER_Q;j++) {
1497                         set_slsb(&q->slsb.acc.val[j],
1498                                  SLSB_P_INPUT_NOT_INIT);
1499 /*                      q->sbal[j]->element[1].sbalf.i1.key=QDIO_STORAGE_KEY;*/
1500                 }
1501         }
1502
1503         for (i=0;i<no_output_qs;i++) {
1504                 q=irq_ptr->output_qs[i];
1505                 memset(q,0,((char*)&q->slib)-((char*)q));
1506
1507                 sprintf(dbf_text,"outq%4x",i);
1508                 QDIO_DBF_TEXT0(0,setup,dbf_text);
1509                 QDIO_DBF_HEX0(0,setup,&q,sizeof(void*));
1510
1511                 memset(q->slib,0,PAGE_SIZE);
1512                 q->sl=(struct sl*)(((char*)q->slib)+PAGE_SIZE/2);
1513
1514                 available=0;
1515
1516                 for (j=0;j<QDIO_MAX_BUFFERS_PER_Q;j++)
1517                         q->sbal[j]=*(outbound_sbals_array++);
1518
1519                 q->queue_type=q_format;
1520                 q->int_parm=int_parm;
1521                 q->is_input_q=0;
1522                 q->irq=irq_ptr->irq;
1523                 q->cdev = cdev;
1524                 q->irq_ptr = irq_ptr;
1525                 q->mask=1<<(31-i);
1526                 q->q_no=i;
1527                 q->first_to_check=0;
1528                 q->last_move_ftc=0;
1529                 q->handler=output_handler;
1530
1531                 q->tasklet.data=(unsigned long)q;
1532                 q->tasklet.func=(void(*)(unsigned long))
1533                         &qdio_outbound_processing;
1534
1535                 atomic_set(&q->busy_siga_counter,0);
1536                 q->timing.busy_start=0;
1537
1538                 /* fill in slib */
1539                 if (i>0) irq_ptr->output_qs[i-1]->slib->nsliba=
1540                                  (unsigned long)(q->slib);
1541                 q->slib->sla=(unsigned long)(q->sl);
1542                 q->slib->slsba=(unsigned long)(&q->slsb.acc.val[0]);
1543
1544                 /* fill in sl */
1545                 for (j=0;j<QDIO_MAX_BUFFERS_PER_Q;j++)
1546                         q->sl->element[j].sbal=(unsigned long)(q->sbal[j]);
1547
1548                 QDIO_DBF_TEXT2(0,setup,"sl-sb-b0");
1549                 ptr=(void*)q->sl;
1550                 QDIO_DBF_HEX2(0,setup,&ptr,sizeof(void*));
1551                 ptr=(void*)&q->slsb;
1552                 QDIO_DBF_HEX2(0,setup,&ptr,sizeof(void*));
1553                 ptr=(void*)q->sbal[0];
1554                 QDIO_DBF_HEX2(0,setup,&ptr,sizeof(void*));
1555
1556                 /* fill in slsb */
1557                 for (j=0;j<QDIO_MAX_BUFFERS_PER_Q;j++) {
1558                         set_slsb(&q->slsb.acc.val[j],
1559                                  SLSB_P_OUTPUT_NOT_INIT);
1560 /*                      q->sbal[j]->element[1].sbalf.i1.key=QDIO_STORAGE_KEY;*/
1561                 }
1562         }
1563 }
1564
1565 static void
1566 qdio_fill_thresholds(struct qdio_irq *irq_ptr,
1567                      unsigned int no_input_qs,
1568                      unsigned int no_output_qs,
1569                      unsigned int min_input_threshold,
1570                      unsigned int max_input_threshold,
1571                      unsigned int min_output_threshold,
1572                      unsigned int max_output_threshold)
1573 {
1574         int i;
1575         struct qdio_q *q;
1576
1577         for (i=0;i<no_input_qs;i++) {
1578                 q=irq_ptr->input_qs[i];
1579                 q->timing.threshold=max_input_threshold;
1580 /*              for (j=0;j<QDIO_STATS_CLASSES;j++) {
1581                         q->threshold_classes[j].threshold=
1582                                 min_input_threshold+
1583                                 (max_input_threshold-min_input_threshold)/
1584                                 QDIO_STATS_CLASSES;
1585                 }
1586                 qdio_use_thresholds(q,QDIO_STATS_CLASSES/2);*/
1587         }
1588         for (i=0;i<no_output_qs;i++) {
1589                 q=irq_ptr->output_qs[i];
1590                 q->timing.threshold=max_output_threshold;
1591 /*              for (j=0;j<QDIO_STATS_CLASSES;j++) {
1592                         q->threshold_classes[j].threshold=
1593                                 min_output_threshold+
1594                                 (max_output_threshold-min_output_threshold)/
1595                                 QDIO_STATS_CLASSES;
1596                 }
1597                 qdio_use_thresholds(q,QDIO_STATS_CLASSES/2);*/
1598         }
1599 }
1600
1601 static int
1602 tiqdio_thinint_handler(void)
1603 {
1604         QDIO_DBF_TEXT4(0,trace,"thin_int");
1605
1606 #ifdef QDIO_PERFORMANCE_STATS
1607         perf_stats.thinints++;
1608         perf_stats.start_time_inbound=NOW;
1609 #endif /* QDIO_PERFORMANCE_STATS */
1610
1611         /* SVS only when needed:
1612          * issue SVS to benefit from iqdio interrupt avoidance
1613          * (SVS clears AISOI)*/
1614         if (!omit_svs)
1615                 tiqdio_clear_global_summary();
1616
1617         tiqdio_inbound_checks();
1618         return 0;
1619 }
1620
1621 static void
1622 qdio_set_state(struct qdio_irq *irq_ptr, enum qdio_irq_states state)
1623 {
1624         int i;
1625         char dbf_text[15];
1626
1627         QDIO_DBF_TEXT5(0,trace,"newstate");
1628         sprintf(dbf_text,"%4x%4x",irq_ptr->irq,state);
1629         QDIO_DBF_TEXT5(0,trace,dbf_text);
1630
1631         irq_ptr->state=state;
1632         for (i=0;i<irq_ptr->no_input_qs;i++)
1633                 irq_ptr->input_qs[i]->state=state;
1634         for (i=0;i<irq_ptr->no_output_qs;i++)
1635                 irq_ptr->output_qs[i]->state=state;
1636         mb();
1637 }
1638
1639 static inline void
1640 qdio_irq_check_sense(int irq, struct irb *irb)
1641 {
1642         char dbf_text[15];
1643
1644         if (irb->esw.esw0.erw.cons) {
1645                 sprintf(dbf_text,"sens%4x",irq);
1646                 QDIO_DBF_TEXT2(1,trace,dbf_text);
1647                 QDIO_DBF_HEX0(0,sense,irb,QDIO_DBF_SENSE_LEN);
1648
1649                 QDIO_PRINT_WARN("sense data available on qdio channel.\n");
1650                 HEXDUMP16(WARN,"irb: ",irb);
1651                 HEXDUMP16(WARN,"sense data: ",irb->ecw);
1652         }
1653
1654 }
1655
1656 static inline void
1657 qdio_handle_pci(struct qdio_irq *irq_ptr)
1658 {
1659         int i;
1660         struct qdio_q *q;
1661
1662 #ifdef QDIO_PERFORMANCE_STATS
1663         perf_stats.pcis++;
1664         perf_stats.start_time_inbound=NOW;
1665 #endif /* QDIO_PERFORMANCE_STATS */
1666         for (i=0;i<irq_ptr->no_input_qs;i++) {
1667                 q=irq_ptr->input_qs[i];
1668                 if (q->is_input_q&QDIO_FLAG_NO_INPUT_INTERRUPT_CONTEXT)
1669                         qdio_mark_q(q);
1670                 else {
1671 #ifdef QDIO_PERFORMANCE_STATS
1672                         perf_stats.tl_runs--;
1673 #endif /* QDIO_PERFORMANCE_STATS */
1674                         __qdio_inbound_processing(q);
1675                 }
1676         }
1677         if (!irq_ptr->hydra_gives_outbound_pcis)
1678                 return;
1679         for (i=0;i<irq_ptr->no_output_qs;i++) {
1680                 q=irq_ptr->output_qs[i];
1681 #ifdef QDIO_PERFORMANCE_STATS
1682                 perf_stats.tl_runs--;
1683 #endif /* QDIO_PERFORMANCE_STATS */
1684                 if (qdio_is_outbound_q_done(q))
1685                         continue;
1686                 if (!irq_ptr->sync_done_on_outb_pcis)
1687                         SYNC_MEMORY;
1688                 __qdio_outbound_processing(q);
1689         }
1690 }
1691
1692 static void qdio_establish_handle_irq(struct ccw_device*, int, int);
1693
1694 static inline void
1695 qdio_handle_activate_check(struct ccw_device *cdev, unsigned long intparm,
1696                            int cstat, int dstat)
1697 {
1698         struct qdio_irq *irq_ptr;
1699         struct qdio_q *q;
1700         char dbf_text[15];
1701
1702         irq_ptr = cdev->private->qdio_data;
1703
1704         QDIO_DBF_TEXT2(1, trace, "ick2");
1705         sprintf(dbf_text,"%s", cdev->dev.bus_id);
1706         QDIO_DBF_TEXT2(1,trace,dbf_text);
1707         QDIO_DBF_HEX2(0,trace,&intparm,sizeof(int));
1708         QDIO_DBF_HEX2(0,trace,&dstat,sizeof(int));
1709         QDIO_DBF_HEX2(0,trace,&cstat,sizeof(int));
1710         QDIO_PRINT_ERR("received check condition on activate " \
1711                        "queues on device %s (cs=x%x, ds=x%x).\n",
1712                        cdev->dev.bus_id, cstat, dstat);
1713         if (irq_ptr->no_input_qs) {
1714                 q=irq_ptr->input_qs[0];
1715         } else if (irq_ptr->no_output_qs) {
1716                 q=irq_ptr->output_qs[0];
1717         } else {
1718                 QDIO_PRINT_ERR("oops... no queue registered for device %s!?\n",
1719                                cdev->dev.bus_id);
1720                 goto omit_handler_call;
1721         }
1722         q->handler(q->cdev,QDIO_STATUS_ACTIVATE_CHECK_CONDITION|
1723                    QDIO_STATUS_LOOK_FOR_ERROR,
1724                    0,0,0,-1,-1,q->int_parm);
1725 omit_handler_call:
1726         qdio_set_state(irq_ptr,QDIO_IRQ_STATE_STOPPED);
1727
1728 }
1729
1730 static void
1731 qdio_call_shutdown(void *data)
1732 {
1733         struct ccw_device *cdev;
1734
1735         cdev = (struct ccw_device *)data;
1736         qdio_shutdown(cdev, QDIO_FLAG_CLEANUP_USING_CLEAR);
1737         put_device(&cdev->dev);
1738 }
1739
1740 static void
1741 qdio_timeout_handler(struct ccw_device *cdev)
1742 {
1743         struct qdio_irq *irq_ptr;
1744         char dbf_text[15];
1745
1746         QDIO_DBF_TEXT2(0, trace, "qtoh");
1747         sprintf(dbf_text, "%s", cdev->dev.bus_id);
1748         QDIO_DBF_TEXT2(0, trace, dbf_text);
1749
1750         irq_ptr = cdev->private->qdio_data;
1751         sprintf(dbf_text, "state:%d", irq_ptr->state);
1752         QDIO_DBF_TEXT2(0, trace, dbf_text);
1753
1754         switch (irq_ptr->state) {
1755         case QDIO_IRQ_STATE_INACTIVE:
1756                 QDIO_PRINT_ERR("establish queues on irq %04x: timed out\n",
1757                                irq_ptr->irq);
1758                 QDIO_DBF_TEXT2(1,setup,"eq:timeo");
1759                 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_ERR);
1760                 break;
1761         case QDIO_IRQ_STATE_CLEANUP:
1762                 QDIO_PRINT_INFO("Did not get interrupt on cleanup, irq=0x%x.\n",
1763                                 irq_ptr->irq);
1764                 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_ERR);
1765                 break;
1766         case QDIO_IRQ_STATE_ESTABLISHED:
1767         case QDIO_IRQ_STATE_ACTIVE:
1768                 /* I/O has been terminated by common I/O layer. */
1769                 QDIO_PRINT_INFO("Queues on irq %04x killed by cio.\n",
1770                                 irq_ptr->irq);
1771                 QDIO_DBF_TEXT2(1, trace, "cio:term");
1772                 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_STOPPED);
1773                 if (get_device(&cdev->dev)) {
1774                         /* Can't call shutdown from interrupt context. */
1775                         PREPARE_WORK(&cdev->private->kick_work,
1776                                      qdio_call_shutdown, (void *)cdev);
1777                         queue_work(ccw_device_work, &cdev->private->kick_work);
1778                 }
1779                 break;
1780         default:
1781                 BUG();
1782         }
1783         ccw_device_set_timeout(cdev, 0);
1784         wake_up(&cdev->private->wait_q);
1785 }
1786
1787 static void
1788 qdio_handler(struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
1789 {
1790         struct qdio_irq *irq_ptr;
1791         int cstat,dstat;
1792         char dbf_text[15];
1793
1794         QDIO_DBF_TEXT4(0, trace, "qint");
1795         sprintf(dbf_text, "%s", cdev->dev.bus_id);
1796         QDIO_DBF_TEXT4(0, trace, dbf_text);
1797
1798         if (!intparm) {
1799                 QDIO_PRINT_ERR("got unsolicited interrupt in qdio " \
1800                                   "handler, device %s\n", cdev->dev.bus_id);
1801                 return;
1802         }
1803
1804         irq_ptr = cdev->private->qdio_data;
1805         if (!irq_ptr) {
1806                 QDIO_DBF_TEXT2(1, trace, "uint");
1807                 sprintf(dbf_text,"%s", cdev->dev.bus_id);
1808                 QDIO_DBF_TEXT2(1,trace,dbf_text);
1809                 QDIO_PRINT_ERR("received interrupt on unused device %s!\n",
1810                                cdev->dev.bus_id);
1811                 return;
1812         }
1813
1814         if (IS_ERR(irb)) {
1815                 /* Currently running i/o is in error. */
1816                 switch (PTR_ERR(irb)) {
1817                 case -EIO:
1818                         QDIO_PRINT_ERR("i/o error on device %s\n",
1819                                        cdev->dev.bus_id);
1820                         return;
1821                 case -ETIMEDOUT:
1822                         qdio_timeout_handler(cdev);
1823                         return;
1824                 default:
1825                         QDIO_PRINT_ERR("unknown error state %ld on device %s\n",
1826                                        PTR_ERR(irb), cdev->dev.bus_id);
1827                         return;
1828                 }
1829         }
1830
1831         qdio_irq_check_sense(irq_ptr->irq, irb);
1832
1833         sprintf(dbf_text, "state:%d", irq_ptr->state);
1834         QDIO_DBF_TEXT4(0, trace, dbf_text);
1835
1836         cstat = irb->scsw.cstat;
1837         dstat = irb->scsw.dstat;
1838
1839         switch (irq_ptr->state) {
1840         case QDIO_IRQ_STATE_INACTIVE:
1841                 qdio_establish_handle_irq(cdev, cstat, dstat);
1842                 break;
1843
1844         case QDIO_IRQ_STATE_CLEANUP:
1845                 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_INACTIVE);
1846                 break;
1847
1848         case QDIO_IRQ_STATE_ESTABLISHED:
1849         case QDIO_IRQ_STATE_ACTIVE:
1850                 if (cstat & SCHN_STAT_PCI) {
1851                         qdio_handle_pci(irq_ptr);
1852                         break;
1853                 }
1854
1855                 if ((cstat&~SCHN_STAT_PCI)||dstat) {
1856                         qdio_handle_activate_check(cdev, intparm, cstat, dstat);
1857                         break;
1858                 }
1859         default:
1860                 QDIO_PRINT_ERR("got interrupt for queues in state %d on " \
1861                                "device %s?!\n",
1862                                irq_ptr->state, cdev->dev.bus_id);
1863         }
1864         wake_up(&cdev->private->wait_q);
1865
1866 }
1867
1868 int
1869 qdio_synchronize(struct ccw_device *cdev, unsigned int flags,
1870                  unsigned int queue_number)
1871 {
1872         int cc;
1873         struct qdio_q *q;
1874         struct qdio_irq *irq_ptr;
1875         char dbf_text[15]="SyncXXXX";
1876         void *ptr;
1877
1878         irq_ptr = cdev->private->qdio_data;
1879         if (!irq_ptr)
1880                 return -ENODEV;
1881
1882         *((int*)(&dbf_text[4])) = irq_ptr->irq;
1883         QDIO_DBF_HEX4(0,trace,dbf_text,QDIO_DBF_TRACE_LEN);
1884         *((int*)(&dbf_text[0]))=flags;
1885         *((int*)(&dbf_text[4]))=queue_number;
1886         QDIO_DBF_HEX4(0,trace,dbf_text,QDIO_DBF_TRACE_LEN);
1887
1888         if (flags&QDIO_FLAG_SYNC_INPUT) {
1889                 q=irq_ptr->input_qs[queue_number];
1890                 if (!q)
1891                         return -EINVAL;
1892                 cc = do_siga_sync(q->irq, 0, q->mask);
1893         } else if (flags&QDIO_FLAG_SYNC_OUTPUT) {
1894                 q=irq_ptr->output_qs[queue_number];
1895                 if (!q)
1896                         return -EINVAL;
1897                 cc = do_siga_sync(q->irq, q->mask, 0);
1898         } else
1899                 return -EINVAL;
1900
1901         ptr=&cc;
1902         if (cc)
1903                 QDIO_DBF_HEX3(0,trace,&ptr,sizeof(int));
1904
1905         return cc;
1906 }
1907
1908 static unsigned char
1909 qdio_check_siga_needs(int sch)
1910 {
1911         int result;
1912         unsigned char qdioac;
1913
1914         struct {
1915                 struct chsc_header request;
1916                 u16 reserved1;
1917                 u16 first_sch;
1918                 u16 reserved2;
1919                 u16 last_sch;
1920                 u32 reserved3;
1921                 struct chsc_header response;
1922                 u32 reserved4;
1923                 u8  flags;
1924                 u8  reserved5;
1925                 u16 sch;
1926                 u8  qfmt;
1927                 u8  reserved6;
1928                 u8  qdioac;
1929                 u8  sch_class;
1930                 u8  reserved7;
1931                 u8  icnt;
1932                 u8  reserved8;
1933                 u8  ocnt;
1934         } *ssqd_area;
1935
1936         ssqd_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
1937         if (!ssqd_area) {
1938                 QDIO_PRINT_WARN("Could not get memory for chsc. Using all " \
1939                                 "SIGAs for sch x%x.\n", sch);
1940                 return CHSC_FLAG_SIGA_INPUT_NECESSARY ||
1941                         CHSC_FLAG_SIGA_OUTPUT_NECESSARY ||
1942                         CHSC_FLAG_SIGA_SYNC_NECESSARY; /* all flags set */
1943         }
1944         ssqd_area->request = (struct chsc_header) {
1945                 .length = 0x0010,
1946                 .code   = 0x0024,
1947         };
1948
1949         ssqd_area->first_sch = sch;
1950         ssqd_area->last_sch = sch;
1951
1952         result=chsc(ssqd_area);
1953
1954         if (result) {
1955                 QDIO_PRINT_WARN("CHSC returned cc %i. Using all " \
1956                                 "SIGAs for sch x%x.\n",
1957                                 result,sch);
1958                 qdioac = CHSC_FLAG_SIGA_INPUT_NECESSARY ||
1959                         CHSC_FLAG_SIGA_OUTPUT_NECESSARY ||
1960                         CHSC_FLAG_SIGA_SYNC_NECESSARY; /* all flags set */
1961                 goto out;
1962         }
1963
1964         if (ssqd_area->response.code != QDIO_CHSC_RESPONSE_CODE_OK) {
1965                 QDIO_PRINT_WARN("response upon checking SIGA needs " \
1966                                 "is 0x%x. Using all SIGAs for sch x%x.\n",
1967                                 ssqd_area->response.code, sch);
1968                 qdioac = CHSC_FLAG_SIGA_INPUT_NECESSARY ||
1969                         CHSC_FLAG_SIGA_OUTPUT_NECESSARY ||
1970                         CHSC_FLAG_SIGA_SYNC_NECESSARY; /* all flags set */
1971                 goto out;
1972         }
1973         if (!(ssqd_area->flags & CHSC_FLAG_QDIO_CAPABILITY) ||
1974             !(ssqd_area->flags & CHSC_FLAG_VALIDITY) ||
1975             (ssqd_area->sch != sch)) {
1976                 QDIO_PRINT_WARN("huh? problems checking out sch x%x... " \
1977                                 "using all SIGAs.\n",sch);
1978                 qdioac = CHSC_FLAG_SIGA_INPUT_NECESSARY |
1979                         CHSC_FLAG_SIGA_OUTPUT_NECESSARY |
1980                         CHSC_FLAG_SIGA_SYNC_NECESSARY; /* worst case */
1981                 goto out;
1982         }
1983
1984         qdioac = ssqd_area->qdioac;
1985 out:
1986         free_page ((unsigned long) ssqd_area);
1987         return qdioac;
1988 }
1989
1990 static unsigned int
1991 tiqdio_check_chsc_availability(void)
1992 {
1993         char dbf_text[15];
1994
1995         if (!css_characteristics_avail)
1996                 return -EIO;
1997
1998         /* Check for bit 41. */
1999         if (!css_general_characteristics.aif) {
2000                 QDIO_PRINT_WARN("Adapter interruption facility not " \
2001                                 "installed.\n");
2002                 return -ENOENT;
2003         }
2004         /* Check for bits 107 and 108. */
2005         if (!css_chsc_characteristics.scssc ||
2006             !css_chsc_characteristics.scsscf) {
2007                 QDIO_PRINT_WARN("Set Chan Subsys. Char. & Fast-CHSCs " \
2008                                 "not available.\n");
2009                 return -ENOENT;
2010         }
2011
2012         /* Check for OSA/FCP thin interrupts (bit 67). */
2013         hydra_thinints = css_general_characteristics.aif_osa;
2014         sprintf(dbf_text,"hydrati%1x", hydra_thinints);
2015         QDIO_DBF_TEXT0(0,setup,dbf_text);
2016
2017         /* Check for aif time delay disablement fac (bit 56). If installed,
2018          * omit svs even under lpar (good point by rick again) */
2019         omit_svs = css_general_characteristics.aif_tdd;
2020         sprintf(dbf_text,"omitsvs%1x", omit_svs);
2021         QDIO_DBF_TEXT0(0,setup,dbf_text);
2022         return 0;
2023 }
2024
2025
2026 static unsigned int
2027 tiqdio_set_subchannel_ind(struct qdio_irq *irq_ptr, int reset_to_zero)
2028 {
2029         unsigned long real_addr_local_summary_bit;
2030         unsigned long real_addr_dev_st_chg_ind;
2031         void *ptr;
2032         char dbf_text[15];
2033
2034         unsigned int resp_code;
2035         int result;
2036
2037         struct {
2038                 struct chsc_header request;
2039                 u16 operation_code;
2040                 u16 reserved1;
2041                 u32 reserved2;
2042                 u32 reserved3;
2043                 u64 summary_indicator_addr;
2044                 u64 subchannel_indicator_addr;
2045                 u32 ks:4;
2046                 u32 kc:4;
2047                 u32 reserved4:21;
2048                 u32 isc:3;
2049                 u32 reserved5[2];
2050                 u32 subsystem_id;
2051                 u32 reserved6[1004];
2052                 struct chsc_header response;
2053                 u32 reserved7;
2054         } *scssc_area;
2055
2056         if (!irq_ptr->is_thinint_irq)
2057                 return -ENODEV;
2058
2059         if (reset_to_zero) {
2060                 real_addr_local_summary_bit=0;
2061                 real_addr_dev_st_chg_ind=0;
2062         } else {
2063                 real_addr_local_summary_bit=
2064                         virt_to_phys((volatile void *)indicators);
2065                 real_addr_dev_st_chg_ind=
2066                         virt_to_phys((volatile void *)irq_ptr->dev_st_chg_ind);
2067         }
2068
2069         scssc_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
2070         if (!scssc_area) {
2071                 QDIO_PRINT_WARN("No memory for setting indicators on " \
2072                                 "subchannel x%x.\n", irq_ptr->irq);
2073                 return -ENOMEM;
2074         }
2075         scssc_area->request = (struct chsc_header) {
2076                 .length = 0x0fe0,
2077                 .code   = 0x0021,
2078         };
2079         scssc_area->operation_code = 0;
2080
2081         scssc_area->summary_indicator_addr = real_addr_local_summary_bit;
2082         scssc_area->subchannel_indicator_addr = real_addr_dev_st_chg_ind;
2083         scssc_area->ks = QDIO_STORAGE_KEY;
2084         scssc_area->kc = QDIO_STORAGE_KEY;
2085         scssc_area->isc = TIQDIO_THININT_ISC;
2086         scssc_area->subsystem_id = (1<<16) + irq_ptr->irq;
2087
2088         result = chsc(scssc_area);
2089         if (result) {
2090                 QDIO_PRINT_WARN("could not set indicators on irq x%x, " \
2091                                 "cc=%i.\n",irq_ptr->irq,result);
2092                 result = -EIO;
2093                 goto out;
2094         }
2095
2096         resp_code = scssc_area->response.code;
2097         if (resp_code!=QDIO_CHSC_RESPONSE_CODE_OK) {
2098                 QDIO_PRINT_WARN("response upon setting indicators " \
2099                                 "is 0x%x.\n",resp_code);
2100                 sprintf(dbf_text,"sidR%4x",resp_code);
2101                 QDIO_DBF_TEXT1(0,trace,dbf_text);
2102                 QDIO_DBF_TEXT1(0,setup,dbf_text);
2103                 ptr=&scssc_area->response;
2104                 QDIO_DBF_HEX2(1,setup,&ptr,QDIO_DBF_SETUP_LEN);
2105                 result = -EIO;
2106                 goto out;
2107         }
2108
2109         QDIO_DBF_TEXT2(0,setup,"setscind");
2110         QDIO_DBF_HEX2(0,setup,&real_addr_local_summary_bit,
2111                       sizeof(unsigned long));
2112         QDIO_DBF_HEX2(0,setup,&real_addr_dev_st_chg_ind,sizeof(unsigned long));
2113         result = 0;
2114 out:
2115         free_page ((unsigned long) scssc_area);
2116         return result;
2117
2118 }
2119
2120 static unsigned int
2121 tiqdio_set_delay_target(struct qdio_irq *irq_ptr, unsigned long delay_target)
2122 {
2123         unsigned int resp_code;
2124         int result;
2125         void *ptr;
2126         char dbf_text[15];
2127
2128         struct {
2129                 struct chsc_header request;
2130                 u16 operation_code;
2131                 u16 reserved1;
2132                 u32 reserved2;
2133                 u32 reserved3;
2134                 u32 reserved4[2];
2135                 u32 delay_target;
2136                 u32 reserved5[1009];
2137                 struct chsc_header response;
2138                 u32 reserved6;
2139         } *scsscf_area;
2140
2141         if (!irq_ptr->is_thinint_irq)
2142                 return -ENODEV;
2143
2144         scsscf_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
2145         if (!scsscf_area) {
2146                 QDIO_PRINT_WARN("No memory for setting delay target on " \
2147                                 "subchannel x%x.\n", irq_ptr->irq);
2148                 return -ENOMEM;
2149         }
2150         scsscf_area->request = (struct chsc_header) {
2151                 .length = 0x0fe0,
2152                 .code   = 0x1027,
2153         };
2154
2155         scsscf_area->delay_target = delay_target<<16;
2156
2157         result=chsc(scsscf_area);
2158         if (result) {
2159                 QDIO_PRINT_WARN("could not set delay target on irq x%x, " \
2160                                 "cc=%i. Continuing.\n",irq_ptr->irq,result);
2161                 result = -EIO;
2162                 goto out;
2163         }
2164
2165         resp_code = scsscf_area->response.code;
2166         if (resp_code!=QDIO_CHSC_RESPONSE_CODE_OK) {
2167                 QDIO_PRINT_WARN("response upon setting delay target " \
2168                                 "is 0x%x. Continuing.\n",resp_code);
2169                 sprintf(dbf_text,"sdtR%4x",resp_code);
2170                 QDIO_DBF_TEXT1(0,trace,dbf_text);
2171                 QDIO_DBF_TEXT1(0,setup,dbf_text);
2172                 ptr=&scsscf_area->response;
2173                 QDIO_DBF_HEX2(1,trace,&ptr,QDIO_DBF_TRACE_LEN);
2174         }
2175         QDIO_DBF_TEXT2(0,trace,"delytrgt");
2176         QDIO_DBF_HEX2(0,trace,&delay_target,sizeof(unsigned long));
2177         result = 0; /* not critical */
2178 out:
2179         free_page ((unsigned long) scsscf_area);
2180         return result;
2181 }
2182
2183 int
2184 qdio_cleanup(struct ccw_device *cdev, int how)
2185 {
2186         struct qdio_irq *irq_ptr;
2187         char dbf_text[15];
2188         int rc;
2189
2190         irq_ptr = cdev->private->qdio_data;
2191         if (!irq_ptr)
2192                 return -ENODEV;
2193
2194         sprintf(dbf_text,"qcln%4x",irq_ptr->irq);
2195         QDIO_DBF_TEXT1(0,trace,dbf_text);
2196         QDIO_DBF_TEXT0(0,setup,dbf_text);
2197
2198         rc = qdio_shutdown(cdev, how);
2199         if ((rc == 0) || (rc == -EINPROGRESS))
2200                 rc = qdio_free(cdev);
2201         return rc;
2202 }
2203
2204 int
2205 qdio_shutdown(struct ccw_device *cdev, int how)
2206 {
2207         struct qdio_irq *irq_ptr;
2208         int i;
2209         int result = 0;
2210         int rc;
2211         unsigned long flags;
2212         int timeout;
2213         char dbf_text[15];
2214
2215         irq_ptr = cdev->private->qdio_data;
2216         if (!irq_ptr)
2217                 return -ENODEV;
2218
2219         down(&irq_ptr->setting_up_sema);
2220
2221         sprintf(dbf_text,"qsqs%4x",irq_ptr->irq);
2222         QDIO_DBF_TEXT1(0,trace,dbf_text);
2223         QDIO_DBF_TEXT0(0,setup,dbf_text);
2224
2225         /* mark all qs as uninteresting */
2226         for (i=0;i<irq_ptr->no_input_qs;i++)
2227                 atomic_set(&irq_ptr->input_qs[i]->is_in_shutdown,1);
2228
2229         for (i=0;i<irq_ptr->no_output_qs;i++)
2230                 atomic_set(&irq_ptr->output_qs[i]->is_in_shutdown,1);
2231
2232         tasklet_kill(&tiqdio_tasklet);
2233
2234         for (i=0;i<irq_ptr->no_input_qs;i++) {
2235                 qdio_unmark_q(irq_ptr->input_qs[i]);
2236                 tasklet_kill(&irq_ptr->input_qs[i]->tasklet);
2237                 wait_event_interruptible_timeout(cdev->private->wait_q,
2238                                                  !atomic_read(&irq_ptr->
2239                                                               input_qs[i]->
2240                                                               use_count),
2241                                                  QDIO_NO_USE_COUNT_TIMEOUT);
2242                 if (atomic_read(&irq_ptr->input_qs[i]->use_count))
2243                         result=-EINPROGRESS;
2244         }
2245
2246         for (i=0;i<irq_ptr->no_output_qs;i++) {
2247                 tasklet_kill(&irq_ptr->output_qs[i]->tasklet);
2248                 wait_event_interruptible_timeout(cdev->private->wait_q,
2249                                                  !atomic_read(&irq_ptr->
2250                                                               output_qs[i]->
2251                                                               use_count),
2252                                                  QDIO_NO_USE_COUNT_TIMEOUT);
2253                 if (atomic_read(&irq_ptr->output_qs[i]->use_count))
2254                         result=-EINPROGRESS;
2255         }
2256
2257         /* cleanup subchannel */
2258         spin_lock_irqsave(get_ccwdev_lock(cdev),flags);
2259         if (how&QDIO_FLAG_CLEANUP_USING_CLEAR) {
2260                 rc = ccw_device_clear(cdev, QDIO_DOING_CLEANUP);
2261                 timeout=QDIO_CLEANUP_CLEAR_TIMEOUT;
2262         } else if (how&QDIO_FLAG_CLEANUP_USING_HALT) {
2263                 rc = ccw_device_halt(cdev, QDIO_DOING_CLEANUP);
2264                 timeout=QDIO_CLEANUP_HALT_TIMEOUT;
2265         } else { /* default behaviour */
2266                 rc = ccw_device_halt(cdev, QDIO_DOING_CLEANUP);
2267                 timeout=QDIO_CLEANUP_HALT_TIMEOUT;
2268         }
2269         if (rc == -ENODEV) {
2270                 /* No need to wait for device no longer present. */
2271                 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_INACTIVE);
2272                 spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
2273         } else if (rc == 0) {
2274                 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_CLEANUP);
2275                 ccw_device_set_timeout(cdev, timeout);
2276                 spin_unlock_irqrestore(get_ccwdev_lock(cdev),flags);
2277
2278                 wait_event(cdev->private->wait_q,
2279                            irq_ptr->state == QDIO_IRQ_STATE_INACTIVE ||
2280                            irq_ptr->state == QDIO_IRQ_STATE_ERR);
2281         } else {
2282                 QDIO_PRINT_INFO("ccw_device_{halt,clear} returned %d for "
2283                                 "device %s\n", result, cdev->dev.bus_id);
2284                 spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
2285                 result = rc;
2286                 goto out;
2287         }
2288         if (irq_ptr->is_thinint_irq) {
2289                 qdio_put_indicator((__u32*)irq_ptr->dev_st_chg_ind);
2290                 tiqdio_set_subchannel_ind(irq_ptr,1);
2291                 /* reset adapter interrupt indicators */
2292         }
2293
2294         /* exchange int handlers, if necessary */
2295         if ((void*)cdev->handler == (void*)qdio_handler)
2296                 cdev->handler=irq_ptr->original_int_handler;
2297
2298         /* Ignore errors. */
2299         qdio_set_state(irq_ptr, QDIO_IRQ_STATE_INACTIVE);
2300         ccw_device_set_timeout(cdev, 0);
2301 out:
2302         up(&irq_ptr->setting_up_sema);
2303         return result;
2304 }
2305
2306 int
2307 qdio_free(struct ccw_device *cdev)
2308 {
2309         struct qdio_irq *irq_ptr;
2310         char dbf_text[15];
2311
2312         irq_ptr = cdev->private->qdio_data;
2313         if (!irq_ptr)
2314                 return -ENODEV;
2315
2316         down(&irq_ptr->setting_up_sema);
2317
2318         sprintf(dbf_text,"qfqs%4x",irq_ptr->irq);
2319         QDIO_DBF_TEXT1(0,trace,dbf_text);
2320         QDIO_DBF_TEXT0(0,setup,dbf_text);
2321
2322         cdev->private->qdio_data = 0;
2323
2324         up(&irq_ptr->setting_up_sema);
2325
2326         qdio_release_irq_memory(irq_ptr);
2327         module_put(THIS_MODULE);
2328         return 0;
2329 }
2330
2331 static inline void
2332 qdio_allocate_do_dbf(struct qdio_initialize *init_data)
2333 {
2334         char dbf_text[20]; /* if a printf printed out more than 8 chars */
2335
2336         sprintf(dbf_text,"qfmt:%x",init_data->q_format);
2337         QDIO_DBF_TEXT0(0,setup,dbf_text);
2338         QDIO_DBF_HEX0(0,setup,init_data->adapter_name,8);
2339         sprintf(dbf_text,"qpff%4x",init_data->qib_param_field_format);
2340         QDIO_DBF_TEXT0(0,setup,dbf_text);
2341         QDIO_DBF_HEX0(0,setup,&init_data->qib_param_field,sizeof(char*));
2342         QDIO_DBF_HEX0(0,setup,&init_data->input_slib_elements,sizeof(long*));
2343         QDIO_DBF_HEX0(0,setup,&init_data->output_slib_elements,sizeof(long*));
2344         sprintf(dbf_text,"miit%4x",init_data->min_input_threshold);
2345         QDIO_DBF_TEXT0(0,setup,dbf_text);
2346         sprintf(dbf_text,"mait%4x",init_data->max_input_threshold);
2347         QDIO_DBF_TEXT0(0,setup,dbf_text);
2348         sprintf(dbf_text,"miot%4x",init_data->min_output_threshold);
2349         QDIO_DBF_TEXT0(0,setup,dbf_text);
2350         sprintf(dbf_text,"maot%4x",init_data->max_output_threshold);
2351         QDIO_DBF_TEXT0(0,setup,dbf_text);
2352         sprintf(dbf_text,"niq:%4x",init_data->no_input_qs);
2353         QDIO_DBF_TEXT0(0,setup,dbf_text);
2354         sprintf(dbf_text,"noq:%4x",init_data->no_output_qs);
2355         QDIO_DBF_TEXT0(0,setup,dbf_text);
2356         QDIO_DBF_HEX0(0,setup,&init_data->input_handler,sizeof(void*));
2357         QDIO_DBF_HEX0(0,setup,&init_data->output_handler,sizeof(void*));
2358         QDIO_DBF_HEX0(0,setup,&init_data->int_parm,sizeof(long));
2359         QDIO_DBF_HEX0(0,setup,&init_data->flags,sizeof(long));
2360         QDIO_DBF_HEX0(0,setup,&init_data->input_sbal_addr_array,sizeof(void*));
2361         QDIO_DBF_HEX0(0,setup,&init_data->output_sbal_addr_array,sizeof(void*));
2362 }
2363
2364 static inline void
2365 qdio_allocate_fill_input_desc(struct qdio_irq *irq_ptr, int i, int iqfmt)
2366 {
2367         irq_ptr->input_qs[i]->is_iqdio_q = iqfmt;
2368         irq_ptr->input_qs[i]->is_thinint_q = irq_ptr->is_thinint_irq;
2369
2370         irq_ptr->qdr->qdf0[i].sliba=(unsigned long)(irq_ptr->input_qs[i]->slib);
2371
2372         irq_ptr->qdr->qdf0[i].sla=(unsigned long)(irq_ptr->input_qs[i]->sl);
2373
2374         irq_ptr->qdr->qdf0[i].slsba=
2375                 (unsigned long)(&irq_ptr->input_qs[i]->slsb.acc.val[0]);
2376
2377         irq_ptr->qdr->qdf0[i].akey=QDIO_STORAGE_KEY;
2378         irq_ptr->qdr->qdf0[i].bkey=QDIO_STORAGE_KEY;
2379         irq_ptr->qdr->qdf0[i].ckey=QDIO_STORAGE_KEY;
2380         irq_ptr->qdr->qdf0[i].dkey=QDIO_STORAGE_KEY;
2381 }
2382
2383 static inline void
2384 qdio_allocate_fill_output_desc(struct qdio_irq *irq_ptr, int i,
2385                                int j, int iqfmt)
2386 {
2387         irq_ptr->output_qs[i]->is_iqdio_q = iqfmt;
2388         irq_ptr->output_qs[i]->is_thinint_q = irq_ptr->is_thinint_irq;
2389
2390         irq_ptr->qdr->qdf0[i+j].sliba=(unsigned long)(irq_ptr->output_qs[i]->slib);
2391
2392         irq_ptr->qdr->qdf0[i+j].sla=(unsigned long)(irq_ptr->output_qs[i]->sl);
2393
2394         irq_ptr->qdr->qdf0[i+j].slsba=
2395                 (unsigned long)(&irq_ptr->output_qs[i]->slsb.acc.val[0]);
2396
2397         irq_ptr->qdr->qdf0[i+j].akey=QDIO_STORAGE_KEY;
2398         irq_ptr->qdr->qdf0[i+j].bkey=QDIO_STORAGE_KEY;
2399         irq_ptr->qdr->qdf0[i+j].ckey=QDIO_STORAGE_KEY;
2400         irq_ptr->qdr->qdf0[i+j].dkey=QDIO_STORAGE_KEY;
2401 }
2402
2403
2404 static inline void
2405 qdio_initialize_set_siga_flags_input(struct qdio_irq *irq_ptr)
2406 {
2407         int i;
2408
2409         for (i=0;i<irq_ptr->no_input_qs;i++) {
2410                 irq_ptr->input_qs[i]->siga_sync=
2411                         irq_ptr->qdioac&CHSC_FLAG_SIGA_SYNC_NECESSARY;
2412                 irq_ptr->input_qs[i]->siga_in=
2413                         irq_ptr->qdioac&CHSC_FLAG_SIGA_INPUT_NECESSARY;
2414                 irq_ptr->input_qs[i]->siga_out=
2415                         irq_ptr->qdioac&CHSC_FLAG_SIGA_OUTPUT_NECESSARY;
2416                 irq_ptr->input_qs[i]->siga_sync_done_on_thinints=
2417                         irq_ptr->qdioac&CHSC_FLAG_SIGA_SYNC_DONE_ON_THININTS;
2418                 irq_ptr->input_qs[i]->hydra_gives_outbound_pcis=
2419                         irq_ptr->hydra_gives_outbound_pcis;
2420                 irq_ptr->input_qs[i]->siga_sync_done_on_outb_tis=
2421                         ((irq_ptr->qdioac&
2422                           (CHSC_FLAG_SIGA_SYNC_DONE_ON_OUTB_PCIS|
2423                            CHSC_FLAG_SIGA_SYNC_DONE_ON_THININTS))==
2424                          (CHSC_FLAG_SIGA_SYNC_DONE_ON_OUTB_PCIS|
2425                           CHSC_FLAG_SIGA_SYNC_DONE_ON_THININTS));
2426
2427         }
2428 }
2429
2430 static inline void
2431 qdio_initialize_set_siga_flags_output(struct qdio_irq *irq_ptr)
2432 {
2433         int i;
2434
2435         for (i=0;i<irq_ptr->no_output_qs;i++) {
2436                 irq_ptr->output_qs[i]->siga_sync=
2437                         irq_ptr->qdioac&CHSC_FLAG_SIGA_SYNC_NECESSARY;
2438                 irq_ptr->output_qs[i]->siga_in=
2439                         irq_ptr->qdioac&CHSC_FLAG_SIGA_INPUT_NECESSARY;
2440                 irq_ptr->output_qs[i]->siga_out=
2441                         irq_ptr->qdioac&CHSC_FLAG_SIGA_OUTPUT_NECESSARY;
2442                 irq_ptr->output_qs[i]->siga_sync_done_on_thinints=
2443                         irq_ptr->qdioac&CHSC_FLAG_SIGA_SYNC_DONE_ON_THININTS;
2444                 irq_ptr->output_qs[i]->hydra_gives_outbound_pcis=
2445                         irq_ptr->hydra_gives_outbound_pcis;
2446                 irq_ptr->output_qs[i]->siga_sync_done_on_outb_tis=
2447                         ((irq_ptr->qdioac&
2448                           (CHSC_FLAG_SIGA_SYNC_DONE_ON_OUTB_PCIS|
2449                            CHSC_FLAG_SIGA_SYNC_DONE_ON_THININTS))==
2450                          (CHSC_FLAG_SIGA_SYNC_DONE_ON_OUTB_PCIS|
2451                           CHSC_FLAG_SIGA_SYNC_DONE_ON_THININTS));
2452
2453         }
2454 }
2455
2456 static inline int
2457 qdio_establish_irq_check_for_errors(struct ccw_device *cdev, int cstat,
2458                                     int dstat)
2459 {
2460         char dbf_text[15];
2461         struct qdio_irq *irq_ptr;
2462
2463         irq_ptr = cdev->private->qdio_data;
2464
2465         if (cstat || (dstat & ~(DEV_STAT_CHN_END|DEV_STAT_DEV_END))) {
2466                 sprintf(dbf_text,"ick1%4x",irq_ptr->irq);
2467                 QDIO_DBF_TEXT2(1,trace,dbf_text);
2468                 QDIO_DBF_HEX2(0,trace,&dstat,sizeof(int));
2469                 QDIO_DBF_HEX2(0,trace,&cstat,sizeof(int));
2470                 QDIO_PRINT_ERR("received check condition on establish " \
2471                                "queues on irq 0x%x (cs=x%x, ds=x%x).\n",
2472                                irq_ptr->irq,cstat,dstat);
2473                 qdio_set_state(irq_ptr,QDIO_IRQ_STATE_ERR);
2474         }
2475
2476         if (!(dstat & DEV_STAT_DEV_END)) {
2477                 QDIO_DBF_TEXT2(1,setup,"eq:no de");
2478                 QDIO_DBF_HEX2(0,setup,&dstat, sizeof(dstat));
2479                 QDIO_DBF_HEX2(0,setup,&cstat, sizeof(cstat));
2480                 QDIO_PRINT_ERR("establish queues on irq %04x: didn't get "
2481                                "device end: dstat=%02x, cstat=%02x\n",
2482                                irq_ptr->irq, dstat, cstat);
2483                 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_ERR);
2484                 return 1;
2485         }
2486
2487         if (dstat & ~(DEV_STAT_CHN_END|DEV_STAT_DEV_END)) {
2488                 QDIO_DBF_TEXT2(1,setup,"eq:badio");
2489                 QDIO_DBF_HEX2(0,setup,&dstat, sizeof(dstat));
2490                 QDIO_DBF_HEX2(0,setup,&cstat, sizeof(cstat));
2491                 QDIO_PRINT_ERR("establish queues on irq %04x: got "
2492                                "the following devstat: dstat=%02x, "
2493                                "cstat=%02x\n",
2494                                irq_ptr->irq, dstat, cstat);
2495                 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_ERR);
2496                 return 1;
2497         }
2498         return 0;
2499 }
2500
2501 static void
2502 qdio_establish_handle_irq(struct ccw_device *cdev, int cstat, int dstat)
2503 {
2504         struct qdio_irq *irq_ptr;
2505         char dbf_text[15];
2506
2507         irq_ptr = cdev->private->qdio_data;
2508
2509         sprintf(dbf_text,"qehi%4x",cdev->private->irq);
2510         QDIO_DBF_TEXT0(0,setup,dbf_text);
2511         QDIO_DBF_TEXT0(0,trace,dbf_text);
2512
2513         if (qdio_establish_irq_check_for_errors(cdev, cstat, dstat)) {
2514                 ccw_device_set_timeout(cdev, 0);
2515                 return;
2516         }
2517
2518         qdio_set_state(irq_ptr,QDIO_IRQ_STATE_ESTABLISHED);
2519         ccw_device_set_timeout(cdev, 0);
2520 }
2521
2522 int
2523 qdio_initialize(struct qdio_initialize *init_data)
2524 {
2525         int rc;
2526         char dbf_text[15];
2527
2528         sprintf(dbf_text,"qini%4x",init_data->cdev->private->irq);
2529         QDIO_DBF_TEXT0(0,setup,dbf_text);
2530         QDIO_DBF_TEXT0(0,trace,dbf_text);
2531
2532         rc = qdio_allocate(init_data);
2533         if (rc == 0) {
2534                 rc = qdio_establish(init_data);
2535                 if (rc != 0)
2536                         qdio_free(init_data->cdev);
2537         }
2538
2539         return rc;
2540 }
2541
2542
2543 int
2544 qdio_allocate(struct qdio_initialize *init_data)
2545 {
2546         char *mem;
2547         unsigned off;
2548         struct qdio_irq *irq_ptr;
2549         char dbf_text[15];
2550
2551         sprintf(dbf_text,"qalc%4x",init_data->cdev->private->irq);
2552         QDIO_DBF_TEXT0(0,setup,dbf_text);
2553         QDIO_DBF_TEXT0(0,trace,dbf_text);
2554         if ( (init_data->no_input_qs>QDIO_MAX_QUEUES_PER_IRQ) ||
2555              (init_data->no_output_qs>QDIO_MAX_QUEUES_PER_IRQ) ||
2556              ((init_data->no_input_qs) && (!init_data->input_handler)) ||
2557              ((init_data->no_output_qs) && (!init_data->output_handler)) )
2558                 return -EINVAL;
2559
2560         if (!init_data->input_sbal_addr_array)
2561                 return -EINVAL;
2562
2563         if (!init_data->output_sbal_addr_array)
2564                 return -EINVAL;
2565
2566         qdio_allocate_do_dbf(init_data);
2567
2568         /* create irq */
2569         mem = kmalloc(sizeof(struct qdio_irq) + 0xff, GFP_KERNEL | GFP_DMA);
2570
2571         QDIO_DBF_TEXT0(0,setup,"irq_ptr:");
2572         QDIO_DBF_HEX0(0,setup,&irq_ptr,sizeof(void*));
2573
2574         if (!mem) {
2575                 QDIO_PRINT_ERR("kmalloc of irq_ptr failed!\n");
2576                 return -ENOMEM;
2577         }
2578
2579         irq_ptr = (struct qdio_irq *) mem;
2580         if ((off = ((unsigned long) mem) & 0xff) != 0)
2581                 irq_ptr = (struct qdio_irq *)(mem + 0x100 - off);
2582         memset(irq_ptr,0,sizeof(struct qdio_irq));
2583         irq_ptr->actual_alloc = mem;
2584
2585         init_MUTEX(&irq_ptr->setting_up_sema);
2586
2587         irq_ptr->qdr=kmalloc(sizeof(struct qdr), GFP_KERNEL | GFP_DMA);
2588         if (!(irq_ptr->qdr)) {
2589                 kfree(irq_ptr);
2590                 QDIO_PRINT_ERR("kmalloc of irq_ptr->qdr failed!\n");
2591                 return -ENOMEM;
2592         }
2593         QDIO_DBF_TEXT0(0,setup,"qdr:");
2594         QDIO_DBF_HEX0(0,setup,&irq_ptr->qdr,sizeof(void*));
2595
2596         if (qdio_alloc_qs(irq_ptr,
2597                           init_data->no_input_qs,
2598                           init_data->no_output_qs)) {
2599                 qdio_release_irq_memory(irq_ptr);
2600                 return -ENOMEM;
2601         }
2602
2603         init_data->cdev->private->qdio_data = irq_ptr;
2604
2605         qdio_set_state(irq_ptr,QDIO_IRQ_STATE_INACTIVE);
2606
2607         return 0;
2608 }
2609
2610 int qdio_fill_irq(struct qdio_initialize *init_data)
2611 {
2612         int i;
2613         char dbf_text[15];
2614         struct ciw *ciw;
2615         int is_iqdio;
2616         struct qdio_irq *irq_ptr;
2617
2618         irq_ptr = init_data->cdev->private->qdio_data;
2619
2620         memset(irq_ptr,0,((char*)&irq_ptr->qdr)-((char*)irq_ptr));
2621
2622         /* wipes qib.ac, required by ar7063 */
2623         memset(irq_ptr->qdr,0,sizeof(struct qdr));
2624
2625         irq_ptr->int_parm=init_data->int_parm;
2626
2627         irq_ptr->irq = init_data->cdev->private->irq;
2628         irq_ptr->no_input_qs=init_data->no_input_qs;
2629         irq_ptr->no_output_qs=init_data->no_output_qs;
2630
2631         if (init_data->q_format==QDIO_IQDIO_QFMT) {
2632                 irq_ptr->is_iqdio_irq=1;
2633                 irq_ptr->is_thinint_irq=1;
2634         } else {
2635                 irq_ptr->is_iqdio_irq=0;
2636                 irq_ptr->is_thinint_irq=hydra_thinints;
2637         }
2638         sprintf(dbf_text,"is_i_t%1x%1x",
2639                 irq_ptr->is_iqdio_irq,irq_ptr->is_thinint_irq);
2640         QDIO_DBF_TEXT2(0,setup,dbf_text);
2641
2642         if (irq_ptr->is_thinint_irq) {
2643                 irq_ptr->dev_st_chg_ind=qdio_get_indicator();
2644                 QDIO_DBF_HEX1(0,setup,&irq_ptr->dev_st_chg_ind,sizeof(void*));
2645                 if (!irq_ptr->dev_st_chg_ind) {
2646                         QDIO_PRINT_WARN("no indicator location available " \
2647                                         "for irq 0x%x\n",irq_ptr->irq);
2648                         qdio_release_irq_memory(irq_ptr);
2649                         return -ENOBUFS;
2650                 }
2651         }
2652
2653         /* defaults */
2654         irq_ptr->equeue.cmd=DEFAULT_ESTABLISH_QS_CMD;
2655         irq_ptr->equeue.count=DEFAULT_ESTABLISH_QS_COUNT;
2656         irq_ptr->aqueue.cmd=DEFAULT_ACTIVATE_QS_CMD;
2657         irq_ptr->aqueue.count=DEFAULT_ACTIVATE_QS_COUNT;
2658
2659         qdio_fill_qs(irq_ptr, init_data->cdev,
2660                      init_data->no_input_qs,
2661                      init_data->no_output_qs,
2662                      init_data->input_handler,
2663                      init_data->output_handler,init_data->int_parm,
2664                      init_data->q_format,init_data->flags,
2665                      init_data->input_sbal_addr_array,
2666                      init_data->output_sbal_addr_array);
2667
2668         if (!try_module_get(THIS_MODULE)) {
2669                 QDIO_PRINT_CRIT("try_module_get() failed!\n");
2670                 qdio_release_irq_memory(irq_ptr);
2671                 return -EINVAL;
2672         }
2673
2674         qdio_fill_thresholds(irq_ptr,init_data->no_input_qs,
2675                              init_data->no_output_qs,
2676                              init_data->min_input_threshold,
2677                              init_data->max_input_threshold,
2678                              init_data->min_output_threshold,
2679                              init_data->max_output_threshold);
2680
2681         /* fill in qdr */
2682         irq_ptr->qdr->qfmt=init_data->q_format;
2683         irq_ptr->qdr->iqdcnt=init_data->no_input_qs;
2684         irq_ptr->qdr->oqdcnt=init_data->no_output_qs;
2685         irq_ptr->qdr->iqdsz=sizeof(struct qdesfmt0)/4; /* size in words */
2686         irq_ptr->qdr->oqdsz=sizeof(struct qdesfmt0)/4;
2687
2688         irq_ptr->qdr->qiba=(unsigned long)&irq_ptr->qib;
2689         irq_ptr->qdr->qkey=QDIO_STORAGE_KEY;
2690
2691         /* fill in qib */
2692         irq_ptr->qib.qfmt=init_data->q_format;
2693         if (init_data->no_input_qs)
2694                 irq_ptr->qib.isliba=(unsigned long)(irq_ptr->input_qs[0]->slib);
2695         if (init_data->no_output_qs)
2696                 irq_ptr->qib.osliba=(unsigned long)(irq_ptr->output_qs[0]->slib);
2697         memcpy(irq_ptr->qib.ebcnam,init_data->adapter_name,8);
2698
2699         qdio_set_impl_params(irq_ptr,init_data->qib_param_field_format,
2700                              init_data->qib_param_field,
2701                              init_data->no_input_qs,
2702                              init_data->no_output_qs,
2703                              init_data->input_slib_elements,
2704                              init_data->output_slib_elements);
2705
2706         /* first input descriptors, then output descriptors */
2707         is_iqdio = (init_data->q_format == QDIO_IQDIO_QFMT) ? 1 : 0;
2708         for (i=0;i<init_data->no_input_qs;i++)
2709                 qdio_allocate_fill_input_desc(irq_ptr, i, is_iqdio);
2710
2711         for (i=0;i<init_data->no_output_qs;i++)
2712                 qdio_allocate_fill_output_desc(irq_ptr, i,
2713                                                init_data->no_input_qs,
2714                                                is_iqdio);
2715
2716         /* qdr, qib, sls, slsbs, slibs, sbales filled. */
2717
2718         /* get qdio commands */
2719         ciw = ccw_device_get_ciw(init_data->cdev, CIW_TYPE_EQUEUE);
2720         if (!ciw) {
2721                 QDIO_DBF_TEXT2(1,setup,"no eq");
2722                 QDIO_PRINT_INFO("No equeue CIW found for QDIO commands. "
2723                                 "Trying to use default.\n");
2724         } else
2725                 irq_ptr->equeue = *ciw;
2726         ciw = ccw_device_get_ciw(init_data->cdev, CIW_TYPE_AQUEUE);
2727         if (!ciw) {
2728                 QDIO_DBF_TEXT2(1,setup,"no aq");
2729                 QDIO_PRINT_INFO("No aqueue CIW found for QDIO commands. "
2730                                 "Trying to use default.\n");
2731         } else
2732                 irq_ptr->aqueue = *ciw;
2733
2734         /* Set new interrupt handler. */
2735         irq_ptr->original_int_handler = init_data->cdev->handler;
2736         init_data->cdev->handler = qdio_handler;
2737
2738         return 0;
2739 }
2740
2741 int
2742 qdio_establish(struct qdio_initialize *init_data)
2743 {
2744         struct qdio_irq *irq_ptr;
2745         unsigned long saveflags;
2746         int result, result2;
2747         struct ccw_device *cdev;
2748         char dbf_text[20];
2749
2750         cdev=init_data->cdev;
2751         irq_ptr = cdev->private->qdio_data;
2752         if (!irq_ptr)
2753                 return -EINVAL;
2754
2755         if (cdev->private->state != DEV_STATE_ONLINE)
2756                 return -EINVAL;
2757
2758         down(&irq_ptr->setting_up_sema);
2759
2760         qdio_fill_irq(init_data);
2761
2762         /* the thinint CHSC stuff */
2763         if (irq_ptr->is_thinint_irq) {
2764
2765                 result = tiqdio_set_subchannel_ind(irq_ptr,0);
2766                 if (result) {
2767                         up(&irq_ptr->setting_up_sema);
2768                         qdio_shutdown(cdev, QDIO_FLAG_CLEANUP_USING_CLEAR);
2769                         return result;
2770                 }
2771                 tiqdio_set_delay_target(irq_ptr,TIQDIO_DELAY_TARGET);
2772         }
2773
2774         sprintf(dbf_text,"qest%4x",cdev->private->irq);
2775         QDIO_DBF_TEXT0(0,setup,dbf_text);
2776         QDIO_DBF_TEXT0(0,trace,dbf_text);
2777
2778         /* establish q */
2779         irq_ptr->ccw.cmd_code=irq_ptr->equeue.cmd;
2780         irq_ptr->ccw.flags=CCW_FLAG_SLI;
2781         irq_ptr->ccw.count=irq_ptr->equeue.count;
2782         irq_ptr->ccw.cda=QDIO_GET_ADDR(irq_ptr->qdr);
2783
2784         spin_lock_irqsave(get_ccwdev_lock(cdev),saveflags);
2785
2786         ccw_device_set_options(cdev, 0);
2787         result=ccw_device_start_timeout(cdev,&irq_ptr->ccw,
2788                                         QDIO_DOING_ESTABLISH,0, 0,
2789                                         QDIO_ESTABLISH_TIMEOUT);
2790         if (result) {
2791                 result2=ccw_device_start_timeout(cdev,&irq_ptr->ccw,
2792                                                  QDIO_DOING_ESTABLISH,0,0,
2793                                                  QDIO_ESTABLISH_TIMEOUT);
2794                 sprintf(dbf_text,"eq:io%4x",result);
2795                 QDIO_DBF_TEXT2(1,setup,dbf_text);
2796                 if (result2) {
2797                         sprintf(dbf_text,"eq:io%4x",result);
2798                         QDIO_DBF_TEXT2(1,setup,dbf_text);
2799                 }
2800                 QDIO_PRINT_WARN("establish queues on irq %04x: do_IO " \
2801                            "returned %i, next try returned %i\n",
2802                            irq_ptr->irq,result,result2);
2803                 result=result2;
2804                 if (result)
2805                         ccw_device_set_timeout(cdev, 0);
2806         }
2807
2808         spin_unlock_irqrestore(get_ccwdev_lock(cdev),saveflags);
2809
2810         if (result) {
2811                 up(&irq_ptr->setting_up_sema);
2812                 qdio_shutdown(cdev,QDIO_FLAG_CLEANUP_USING_CLEAR);
2813                 return result;
2814         }
2815
2816         wait_event_interruptible_timeout(cdev->private->wait_q,
2817                  irq_ptr->state == QDIO_IRQ_STATE_ESTABLISHED ||
2818                  irq_ptr->state == QDIO_IRQ_STATE_ERR,
2819                  QDIO_ESTABLISH_TIMEOUT);
2820
2821         if (irq_ptr->state == QDIO_IRQ_STATE_ESTABLISHED)
2822                 result = 0;
2823         else {
2824                 up(&irq_ptr->setting_up_sema);
2825                 qdio_shutdown(cdev, QDIO_FLAG_CLEANUP_USING_CLEAR);
2826                 return -EIO;
2827         }
2828
2829         irq_ptr->qdioac=qdio_check_siga_needs(irq_ptr->irq);
2830         /* if this gets set once, we're running under VM and can omit SVSes */
2831         if (irq_ptr->qdioac&CHSC_FLAG_SIGA_SYNC_NECESSARY)
2832                 omit_svs=1;
2833
2834         sprintf(dbf_text,"qdioac%2x",irq_ptr->qdioac);
2835         QDIO_DBF_TEXT2(0,setup,dbf_text);
2836
2837         sprintf(dbf_text,"qib ac%2x",irq_ptr->qib.ac);
2838         QDIO_DBF_TEXT2(0,setup,dbf_text);
2839
2840         irq_ptr->hydra_gives_outbound_pcis=
2841                 irq_ptr->qib.ac&QIB_AC_OUTBOUND_PCI_SUPPORTED;
2842         irq_ptr->sync_done_on_outb_pcis=
2843                 irq_ptr->qdioac&CHSC_FLAG_SIGA_SYNC_DONE_ON_OUTB_PCIS;
2844
2845         qdio_initialize_set_siga_flags_input(irq_ptr);
2846         qdio_initialize_set_siga_flags_output(irq_ptr);
2847
2848         up(&irq_ptr->setting_up_sema);
2849
2850         return result;
2851
2852 }
2853
2854 int
2855 qdio_activate(struct ccw_device *cdev, int flags)
2856 {
2857         struct qdio_irq *irq_ptr;
2858         int i,result=0,result2;
2859         unsigned long saveflags;
2860         char dbf_text[20]; /* see qdio_initialize */
2861
2862         irq_ptr = cdev->private->qdio_data;
2863         if (!irq_ptr)
2864                 return -ENODEV;
2865
2866         if (cdev->private->state != DEV_STATE_ONLINE)
2867                 return -EINVAL;
2868
2869         down(&irq_ptr->setting_up_sema);
2870         if (irq_ptr->state==QDIO_IRQ_STATE_INACTIVE) {
2871                 result=-EBUSY;
2872                 goto out;
2873         }
2874
2875         sprintf(dbf_text,"qact%4x", irq_ptr->irq);
2876         QDIO_DBF_TEXT2(0,setup,dbf_text);
2877         QDIO_DBF_TEXT2(0,trace,dbf_text);
2878
2879         /* activate q */
2880         irq_ptr->ccw.cmd_code=irq_ptr->aqueue.cmd;
2881         irq_ptr->ccw.flags=CCW_FLAG_SLI;
2882         irq_ptr->ccw.count=irq_ptr->aqueue.count;
2883         irq_ptr->ccw.cda=QDIO_GET_ADDR(0);
2884
2885         spin_lock_irqsave(get_ccwdev_lock(cdev),saveflags);
2886
2887         ccw_device_set_timeout(cdev, 0);
2888         ccw_device_set_options(cdev, CCWDEV_REPORT_ALL);
2889         result=ccw_device_start(cdev,&irq_ptr->ccw,QDIO_DOING_ACTIVATE,
2890                                 0, DOIO_DENY_PREFETCH);
2891         if (result) {
2892                 result2=ccw_device_start(cdev,&irq_ptr->ccw,
2893                                          QDIO_DOING_ACTIVATE,0,0);
2894                 sprintf(dbf_text,"aq:io%4x",result);
2895                 QDIO_DBF_TEXT2(1,setup,dbf_text);
2896                 if (result2) {
2897                         sprintf(dbf_text,"aq:io%4x",result);
2898                         QDIO_DBF_TEXT2(1,setup,dbf_text);
2899                 }
2900                 QDIO_PRINT_WARN("activate queues on irq %04x: do_IO " \
2901                            "returned %i, next try returned %i\n",
2902                            irq_ptr->irq,result,result2);
2903                 result=result2;
2904         }
2905
2906         spin_unlock_irqrestore(get_ccwdev_lock(cdev),saveflags);
2907         if (result)
2908                 goto out;
2909
2910         for (i=0;i<irq_ptr->no_input_qs;i++) {
2911                 if (irq_ptr->is_thinint_irq) {
2912                         /*
2913                          * that way we know, that, if we will get interrupted
2914                          * by tiqdio_inbound_processing, qdio_unmark_q will
2915                          * not be called
2916                          */
2917                         qdio_reserve_q(irq_ptr->input_qs[i]);
2918                         qdio_mark_tiq(irq_ptr->input_qs[i]);
2919                         qdio_release_q(irq_ptr->input_qs[i]);
2920                 }
2921         }
2922
2923         if (flags&QDIO_FLAG_NO_INPUT_INTERRUPT_CONTEXT) {
2924                 for (i=0;i<irq_ptr->no_input_qs;i++) {
2925                         irq_ptr->input_qs[i]->is_input_q|=
2926                                 QDIO_FLAG_NO_INPUT_INTERRUPT_CONTEXT;
2927                 }
2928         }
2929
2930         wait_event_interruptible_timeout(cdev->private->wait_q,
2931                                          ((irq_ptr->state ==
2932                                           QDIO_IRQ_STATE_STOPPED) ||
2933                                           (irq_ptr->state ==
2934                                            QDIO_IRQ_STATE_ERR)),
2935                                          QDIO_ACTIVATE_TIMEOUT);
2936
2937         switch (irq_ptr->state) {
2938         case QDIO_IRQ_STATE_STOPPED:
2939         case QDIO_IRQ_STATE_ERR:
2940                 up(&irq_ptr->setting_up_sema);
2941                 qdio_shutdown(cdev, QDIO_FLAG_CLEANUP_USING_CLEAR);
2942                 down(&irq_ptr->setting_up_sema);
2943                 result = -EIO;
2944                 break;
2945         default:
2946                 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_ACTIVE);
2947                 result = 0;
2948         }
2949  out:
2950         up(&irq_ptr->setting_up_sema);
2951
2952         return result;
2953 }
2954
2955 /* buffers filled forwards again to make Rick happy */
2956 static inline void
2957 qdio_do_qdio_fill_input(struct qdio_q *q, unsigned int qidx,
2958                         unsigned int count, struct qdio_buffer *buffers)
2959 {
2960         for (;;) {
2961                 set_slsb(&q->slsb.acc.val[qidx],SLSB_CU_INPUT_EMPTY);
2962                 count--;
2963                 if (!count) break;
2964                 qidx=(qidx+1)&(QDIO_MAX_BUFFERS_PER_Q-1);
2965         }
2966
2967         /* not necessary, as the queues are synced during the SIGA read */
2968         /*SYNC_MEMORY;*/
2969 }
2970
2971 static inline void
2972 qdio_do_qdio_fill_output(struct qdio_q *q, unsigned int qidx,
2973                          unsigned int count, struct qdio_buffer *buffers)
2974 {
2975         for (;;) {
2976                 set_slsb(&q->slsb.acc.val[qidx],SLSB_CU_OUTPUT_PRIMED);
2977                 count--;
2978                 if (!count) break;
2979                 qidx=(qidx+1)&(QDIO_MAX_BUFFERS_PER_Q-1);
2980         }
2981
2982         /* SIGA write will sync the queues */
2983         /*SYNC_MEMORY;*/
2984 }
2985
2986 static inline void
2987 do_qdio_handle_inbound(struct qdio_q *q, unsigned int callflags,
2988                        unsigned int qidx, unsigned int count,
2989                        struct qdio_buffer *buffers)
2990 {
2991         int used_elements;
2992
2993         /* This is the inbound handling of queues */
2994         used_elements=atomic_add_return(count, &q->number_of_buffers_used) - count;
2995
2996         qdio_do_qdio_fill_input(q,qidx,count,buffers);
2997
2998         if ((used_elements+count==QDIO_MAX_BUFFERS_PER_Q)&&
2999             (callflags&QDIO_FLAG_UNDER_INTERRUPT))
3000                 atomic_swap(&q->polling,0);
3001
3002         if (used_elements)
3003                 return;
3004         if (callflags&QDIO_FLAG_DONT_SIGA)
3005                 return;
3006         if (q->siga_in) {
3007                 int result;
3008
3009                 result=qdio_siga_input(q);
3010                 if (result) {
3011                         if (q->siga_error)
3012                                 q->error_status_flags|=
3013                                         QDIO_STATUS_MORE_THAN_ONE_SIGA_ERROR;
3014                         q->error_status_flags|=QDIO_STATUS_LOOK_FOR_ERROR;
3015                         q->siga_error=result;
3016                 }
3017         }
3018
3019         qdio_mark_q(q);
3020 }
3021
3022 static inline void
3023 do_qdio_handle_outbound(struct qdio_q *q, unsigned int callflags,
3024                         unsigned int qidx, unsigned int count,
3025                         struct qdio_buffer *buffers)
3026 {
3027         int used_elements;
3028
3029         /* This is the outbound handling of queues */
3030 #ifdef QDIO_PERFORMANCE_STATS
3031         perf_stats.start_time_outbound=NOW;
3032 #endif /* QDIO_PERFORMANCE_STATS */
3033
3034         qdio_do_qdio_fill_output(q,qidx,count,buffers);
3035
3036         used_elements=atomic_add_return(count, &q->number_of_buffers_used) - count;
3037
3038         if (callflags&QDIO_FLAG_DONT_SIGA) {
3039 #ifdef QDIO_PERFORMANCE_STATS
3040                 perf_stats.outbound_time+=NOW-perf_stats.start_time_outbound;
3041                 perf_stats.outbound_cnt++;
3042 #endif /* QDIO_PERFORMANCE_STATS */
3043                 return;
3044         }
3045         if (q->is_iqdio_q) {
3046                 /* one siga for every sbal */
3047                 while (count--)
3048                         qdio_kick_outbound_q(q);
3049
3050                 __qdio_outbound_processing(q);
3051         } else {
3052                 /* under VM, we do a SIGA sync unconditionally */
3053                 SYNC_MEMORY;
3054                 else {
3055                         /*
3056                          * w/o shadow queues (else branch of
3057                          * SYNC_MEMORY :-/ ), we try to
3058                          * fast-requeue buffers
3059                          */
3060                         if (q->slsb.acc.val[(qidx+QDIO_MAX_BUFFERS_PER_Q-1)
3061                                             &(QDIO_MAX_BUFFERS_PER_Q-1)]!=
3062                             SLSB_CU_OUTPUT_PRIMED) {
3063                                 qdio_kick_outbound_q(q);
3064                         } else {
3065                                 QDIO_DBF_TEXT3(0,trace, "fast-req");
3066 #ifdef QDIO_PERFORMANCE_STATS
3067                                 perf_stats.fast_reqs++;
3068 #endif /* QDIO_PERFORMANCE_STATS */
3069                         }
3070                 }
3071                 /*
3072                  * only marking the q could take too long,
3073                  * the upper layer module could do a lot of
3074                  * traffic in that time
3075                  */
3076                 __qdio_outbound_processing(q);
3077         }
3078
3079 #ifdef QDIO_PERFORMANCE_STATS
3080         perf_stats.outbound_time+=NOW-perf_stats.start_time_outbound;
3081         perf_stats.outbound_cnt++;
3082 #endif /* QDIO_PERFORMANCE_STATS */
3083 }
3084
3085 /* count must be 1 in iqdio */
3086 int
3087 do_QDIO(struct ccw_device *cdev,unsigned int callflags,
3088         unsigned int queue_number, unsigned int qidx,
3089         unsigned int count,struct qdio_buffer *buffers)
3090 {
3091         struct qdio_irq *irq_ptr;
3092
3093         char dbf_text[20];
3094
3095         sprintf(dbf_text,"doQD%04x",cdev->private->irq);
3096         QDIO_DBF_TEXT3(0,trace,dbf_text);
3097
3098         if ( (qidx>QDIO_MAX_BUFFERS_PER_Q) ||
3099              (count>QDIO_MAX_BUFFERS_PER_Q) ||
3100              (queue_number>QDIO_MAX_QUEUES_PER_IRQ) )
3101                 return -EINVAL;
3102
3103         if (count==0)
3104                 return 0;
3105
3106         irq_ptr = cdev->private->qdio_data;
3107         if (!irq_ptr)
3108                 return -ENODEV;
3109
3110         if (callflags&QDIO_FLAG_SYNC_INPUT)
3111                 QDIO_DBF_HEX3(0,trace,&irq_ptr->input_qs[queue_number],
3112                               sizeof(void*));
3113         else
3114                 QDIO_DBF_HEX3(0,trace,&irq_ptr->output_qs[queue_number],
3115                               sizeof(void*));
3116         sprintf(dbf_text,"flag%04x",callflags);
3117         QDIO_DBF_TEXT3(0,trace,dbf_text);
3118         sprintf(dbf_text,"qi%02xct%02x",qidx,count);
3119         QDIO_DBF_TEXT3(0,trace,dbf_text);
3120
3121         if (irq_ptr->state!=QDIO_IRQ_STATE_ACTIVE)
3122                 return -EBUSY;
3123
3124         if (callflags&QDIO_FLAG_SYNC_INPUT)
3125                 do_qdio_handle_inbound(irq_ptr->input_qs[queue_number],
3126                                        callflags, qidx, count, buffers);
3127         else if (callflags&QDIO_FLAG_SYNC_OUTPUT)
3128                 do_qdio_handle_outbound(irq_ptr->output_qs[queue_number],
3129                                         callflags, qidx, count, buffers);
3130         else {
3131                 QDIO_DBF_TEXT3(1,trace,"doQD:inv");
3132                 return -EINVAL;
3133         }
3134         return 0;
3135 }
3136
3137 #ifdef QDIO_PERFORMANCE_STATS
3138 static int
3139 qdio_perf_procfile_read(char *buffer, char **buffer_location, off_t offset,
3140                         int buffer_length, int *eof, void *data)
3141 {
3142         int c=0;
3143
3144         /* we are always called with buffer_length=4k, so we all
3145            deliver on the first read */
3146         if (offset>0)
3147                 return 0;
3148
3149 #define _OUTP_IT(x...) c+=sprintf(buffer+c,x)
3150         _OUTP_IT("i_p_nc/c=%lu/%lu\n",i_p_nc,i_p_c);
3151         _OUTP_IT("ii_p_nc/c=%lu/%lu\n",ii_p_nc,ii_p_c);
3152         _OUTP_IT("o_p_nc/c=%lu/%lu\n",o_p_nc,o_p_c);
3153         _OUTP_IT("Number of tasklet runs (total)                  : %u\n",
3154                  perf_stats.tl_runs);
3155         _OUTP_IT("\n");
3156         _OUTP_IT("Number of SIGA sync's issued                    : %u\n",
3157                  perf_stats.siga_syncs);
3158         _OUTP_IT("Number of SIGA in's issued                      : %u\n",
3159                  perf_stats.siga_ins);
3160         _OUTP_IT("Number of SIGA out's issued                     : %u\n",
3161                  perf_stats.siga_outs);
3162         _OUTP_IT("Number of PCIs caught                           : %u\n",
3163                  perf_stats.pcis);
3164         _OUTP_IT("Number of adapter interrupts caught             : %u\n",
3165                  perf_stats.thinints);
3166         _OUTP_IT("Number of fast requeues (outg. SBALs w/o SIGA)  : %u\n",
3167                  perf_stats.fast_reqs);
3168         _OUTP_IT("\n");
3169         _OUTP_IT("Total time of all inbound actions (us) incl. UL : %u\n",
3170                  perf_stats.inbound_time);
3171         _OUTP_IT("Number of inbound transfers                     : %u\n",
3172                  perf_stats.inbound_cnt);
3173         _OUTP_IT("Total time of all outbound do_QDIOs (us)        : %u\n",
3174                  perf_stats.outbound_time);
3175         _OUTP_IT("Number of do_QDIOs outbound                     : %u\n",
3176                  perf_stats.outbound_cnt);
3177         _OUTP_IT("\n");
3178
3179         return c;
3180 }
3181
3182 static struct proc_dir_entry *qdio_perf_proc_file;
3183 #endif /* QDIO_PERFORMANCE_STATS */
3184
3185 static void
3186 qdio_add_procfs_entry(void)
3187 {
3188 #ifdef QDIO_PERFORMANCE_STATS
3189         proc_perf_file_registration=0;
3190         qdio_perf_proc_file=create_proc_entry(QDIO_PERF,
3191                                               S_IFREG|0444,&proc_root);
3192         if (qdio_perf_proc_file) {
3193                 qdio_perf_proc_file->read_proc=&qdio_perf_procfile_read;
3194         } else proc_perf_file_registration=-1;
3195
3196         if (proc_perf_file_registration)
3197                 QDIO_PRINT_WARN("was not able to register perf. " \
3198                                 "proc-file (%i).\n",
3199                                 proc_perf_file_registration);
3200 #endif /* QDIO_PERFORMANCE_STATS */
3201 }
3202
3203 static void
3204 qdio_remove_procfs_entry(void)
3205 {
3206 #ifdef QDIO_PERFORMANCE_STATS
3207         perf_stats.tl_runs=0;
3208
3209         if (!proc_perf_file_registration) /* means if it went ok earlier */
3210                 remove_proc_entry(QDIO_PERF,&proc_root);
3211 #endif /* QDIO_PERFORMANCE_STATS */
3212 }
3213
3214 static void
3215 tiqdio_register_thinints(void)
3216 {
3217         char dbf_text[20];
3218         register_thinint_result=
3219                 s390_register_adapter_interrupt(&tiqdio_thinint_handler);
3220         if (register_thinint_result) {
3221                 sprintf(dbf_text,"regthn%x",(register_thinint_result&0xff));
3222                 QDIO_DBF_TEXT0(0,setup,dbf_text);
3223                 QDIO_PRINT_ERR("failed to register adapter handler " \
3224                                "(rc=%i).\nAdapter interrupts might " \
3225                                "not work. Continuing.\n",
3226                                register_thinint_result);
3227         }
3228 }
3229
3230 static void
3231 tiqdio_unregister_thinints(void)
3232 {
3233         if (!register_thinint_result)
3234                 s390_unregister_adapter_interrupt(&tiqdio_thinint_handler);
3235 }
3236
3237 static int
3238 qdio_get_qdio_memory(void)
3239 {
3240         int i;
3241         indicator_used[0]=1;
3242
3243         for (i=1;i<INDICATORS_PER_CACHELINE;i++)
3244                 indicator_used[i]=0;
3245         indicators=(__u32*)kmalloc(sizeof(__u32)*(INDICATORS_PER_CACHELINE),
3246                                    GFP_KERNEL);
3247         if (!indicators) return -ENOMEM;
3248         memset(indicators,0,sizeof(__u32)*(INDICATORS_PER_CACHELINE));
3249         return 0;
3250 }
3251
3252 static void
3253 qdio_release_qdio_memory(void)
3254 {
3255         if (indicators)
3256                 kfree(indicators);
3257 }
3258
3259 static void
3260 qdio_unregister_dbf_views(void)
3261 {
3262         if (qdio_dbf_setup)
3263                 debug_unregister(qdio_dbf_setup);
3264         if (qdio_dbf_sbal)
3265                 debug_unregister(qdio_dbf_sbal);
3266         if (qdio_dbf_sense)
3267                 debug_unregister(qdio_dbf_sense);
3268         if (qdio_dbf_trace)
3269                 debug_unregister(qdio_dbf_trace);
3270 #ifdef QDIO_DBF_LIKE_HELL
3271         if (qdio_dbf_slsb_out)
3272                 debug_unregister(qdio_dbf_slsb_out);
3273         if (qdio_dbf_slsb_in)
3274                 debug_unregister(qdio_dbf_slsb_in);
3275 #endif /* QDIO_DBF_LIKE_HELL */
3276 }
3277
3278 static int
3279 qdio_register_dbf_views(void)
3280 {
3281         qdio_dbf_setup=debug_register(QDIO_DBF_SETUP_NAME,
3282                                       QDIO_DBF_SETUP_INDEX,
3283                                       QDIO_DBF_SETUP_NR_AREAS,
3284                                       QDIO_DBF_SETUP_LEN);
3285         if (!qdio_dbf_setup)
3286                 goto oom;
3287         debug_register_view(qdio_dbf_setup,&debug_hex_ascii_view);
3288         debug_set_level(qdio_dbf_setup,QDIO_DBF_SETUP_LEVEL);
3289
3290         qdio_dbf_sbal=debug_register(QDIO_DBF_SBAL_NAME,
3291                                      QDIO_DBF_SBAL_INDEX,
3292                                      QDIO_DBF_SBAL_NR_AREAS,
3293                                      QDIO_DBF_SBAL_LEN);
3294         if (!qdio_dbf_sbal)
3295                 goto oom;
3296
3297         debug_register_view(qdio_dbf_sbal,&debug_hex_ascii_view);
3298         debug_set_level(qdio_dbf_sbal,QDIO_DBF_SBAL_LEVEL);
3299
3300         qdio_dbf_sense=debug_register(QDIO_DBF_SENSE_NAME,
3301                                       QDIO_DBF_SENSE_INDEX,
3302                                       QDIO_DBF_SENSE_NR_AREAS,
3303                                       QDIO_DBF_SENSE_LEN);
3304         if (!qdio_dbf_sense)
3305                 goto oom;
3306
3307         debug_register_view(qdio_dbf_sense,&debug_hex_ascii_view);
3308         debug_set_level(qdio_dbf_sense,QDIO_DBF_SENSE_LEVEL);
3309
3310         qdio_dbf_trace=debug_register(QDIO_DBF_TRACE_NAME,
3311                                       QDIO_DBF_TRACE_INDEX,
3312                                       QDIO_DBF_TRACE_NR_AREAS,
3313                                       QDIO_DBF_TRACE_LEN);
3314         if (!qdio_dbf_trace)
3315                 goto oom;
3316
3317         debug_register_view(qdio_dbf_trace,&debug_hex_ascii_view);
3318         debug_set_level(qdio_dbf_trace,QDIO_DBF_TRACE_LEVEL);
3319
3320 #ifdef QDIO_DBF_LIKE_HELL
3321         qdio_dbf_slsb_out=debug_register(QDIO_DBF_SLSB_OUT_NAME,
3322                                          QDIO_DBF_SLSB_OUT_INDEX,
3323                                          QDIO_DBF_SLSB_OUT_NR_AREAS,
3324                                          QDIO_DBF_SLSB_OUT_LEN);
3325         if (!qdio_dbf_slsb_out)
3326                 goto oom;
3327         debug_register_view(qdio_dbf_slsb_out,&debug_hex_ascii_view);
3328         debug_set_level(qdio_dbf_slsb_out,QDIO_DBF_SLSB_OUT_LEVEL);
3329
3330         qdio_dbf_slsb_in=debug_register(QDIO_DBF_SLSB_IN_NAME,
3331                                         QDIO_DBF_SLSB_IN_INDEX,
3332                                         QDIO_DBF_SLSB_IN_NR_AREAS,
3333                                         QDIO_DBF_SLSB_IN_LEN);
3334         if (!qdio_dbf_slsb_in)
3335                 goto oom;
3336         debug_register_view(qdio_dbf_slsb_in,&debug_hex_ascii_view);
3337         debug_set_level(qdio_dbf_slsb_in,QDIO_DBF_SLSB_IN_LEVEL);
3338 #endif /* QDIO_DBF_LIKE_HELL */
3339         return 0;
3340 oom:
3341         QDIO_PRINT_ERR("not enough memory for dbf.\n");
3342         qdio_unregister_dbf_views();
3343         return -ENOMEM;
3344 }
3345
3346 static int __init
3347 init_QDIO(void)
3348 {
3349         int res;
3350 #ifdef QDIO_PERFORMANCE_STATS
3351         void *ptr;
3352 #endif /* QDIO_PERFORMANCE_STATS */
3353
3354         printk("qdio: loading %s\n",version);
3355
3356         res=qdio_get_qdio_memory();
3357         if (res)
3358                 return res;
3359
3360         res = qdio_register_dbf_views();
3361         if (res)
3362                 return res;
3363
3364         QDIO_DBF_TEXT0(0,setup,"initQDIO");
3365
3366 #ifdef QDIO_PERFORMANCE_STATS
3367         memset((void*)&perf_stats,0,sizeof(perf_stats));
3368         QDIO_DBF_TEXT0(0,setup,"perfstat");
3369         ptr=&perf_stats;
3370         QDIO_DBF_HEX0(0,setup,&ptr,sizeof(void*));
3371 #endif /* QDIO_PERFORMANCE_STATS */
3372
3373         qdio_add_procfs_entry();
3374
3375         if (tiqdio_check_chsc_availability())
3376                 QDIO_PRINT_ERR("Not all CHSCs supported. Continuing.\n");
3377
3378         tiqdio_register_thinints();
3379
3380         return 0;
3381  }
3382
3383 static void __exit
3384 cleanup_QDIO(void)
3385 {
3386         tiqdio_unregister_thinints();
3387         qdio_remove_procfs_entry();
3388         qdio_release_qdio_memory();
3389         qdio_unregister_dbf_views();
3390
3391         printk("qdio: %s: module removed\n",version);
3392 }
3393
3394 module_init(init_QDIO);
3395 module_exit(cleanup_QDIO);
3396
3397 EXPORT_SYMBOL(qdio_allocate);
3398 EXPORT_SYMBOL(qdio_establish);
3399 EXPORT_SYMBOL(qdio_initialize);
3400 EXPORT_SYMBOL(qdio_activate);
3401 EXPORT_SYMBOL(do_QDIO);
3402 EXPORT_SYMBOL(qdio_shutdown);
3403 EXPORT_SYMBOL(qdio_free);
3404 EXPORT_SYMBOL(qdio_cleanup);
3405 EXPORT_SYMBOL(qdio_synchronize);