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