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