3 * linux/drivers/s390/cio/qdio.c
5 * Linux for S/390 QDIO base support, Hipersocket base support
8 * Copyright 2000,2002 IBM Corporation
9 * Author(s): Utz Bacher <utz.bacher@de.ibm.com>
10 * 2.6 cio integration by Cornelia Huck <cohuck@de.ibm.com>
12 * Restriction: only 63 iqdio subchannels would have its own indicator,
13 * after that, subsequent subchannels share one indicator
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)
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.
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.
33 #include <linux/config.h>
34 #include <linux/module.h>
35 #include <linux/init.h>
37 #include <linux/slab.h>
38 #include <linux/kernel.h>
39 #include <linux/proc_fs.h>
40 #include <linux/timer.h>
42 #include <asm/ccwdev.h>
44 #include <asm/atomic.h>
45 #include <asm/semaphore.h>
46 #include <asm/timex.h>
48 #include <asm/debug.h>
59 #define VERSION_QDIO_C "$Revision: 1.83 $"
61 /****************** MODULE PARAMETER VARIABLES ********************/
62 MODULE_AUTHOR("Utz Bacher <utz.bacher@de.ibm.com>");
63 MODULE_DESCRIPTION("QDIO base support version 2, " \
64 "Copyright 2000 IBM Corporation");
65 MODULE_LICENSE("GPL");
67 /******************** HERE WE GO ***********************************/
69 static const char version[] = "QDIO base support version 2 ("
70 VERSION_QDIO_C "/" VERSION_QDIO_H "/" VERSION_CIO_QDIO_H ")";
72 #ifdef QDIO_PERFORMANCE_STATS
73 static int proc_perf_file_registration;
74 static unsigned long i_p_c, i_p_nc, o_p_c, o_p_nc, ii_p_c, ii_p_nc;
75 static struct qdio_perf_stats perf_stats;
76 #endif /* QDIO_PERFORMANCE_STATS */
78 static int hydra_thinints;
81 static int indicator_used[INDICATORS_PER_CACHELINE];
82 static __u32 * volatile indicators;
83 static __u32 volatile spare_indicator;
84 static atomic_t spare_indicator_usecount;
86 static debug_info_t *qdio_dbf_setup;
87 static debug_info_t *qdio_dbf_sbal;
88 static debug_info_t *qdio_dbf_trace;
89 static debug_info_t *qdio_dbf_sense;
90 #ifdef QDIO_DBF_LIKE_HELL
91 static debug_info_t *qdio_dbf_slsb_out;
92 static debug_info_t *qdio_dbf_slsb_in;
93 #endif /* QDIO_DBF_LIKE_HELL */
96 static volatile struct qdio_q *tiq_list=NULL; /* volatile as it could change
97 during a while loop */
98 static spinlock_t ttiq_list_lock=SPIN_LOCK_UNLOCKED;
99 static int register_thinint_result;
100 static void tiqdio_tl(unsigned long);
101 static DECLARE_TASKLET(tiqdio_tasklet,tiqdio_tl,0);
103 /* not a macro, as one of the arguments is atomic_read */
105 qdio_min(int a,int b)
113 /***************** SCRUBBER HELPER ROUTINES **********************/
115 static inline volatile __u64
116 qdio_get_micros(void)
118 return (get_clock() >> 10); /* time>>12 is microseconds */
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)
128 qdio_reserve_q(struct qdio_q *q)
130 return atomic_add_return(1,&q->use_count) - 1;
134 qdio_release_q(struct qdio_q *q)
136 atomic_dec(&q->use_count);
139 static volatile inline void
140 qdio_set_slsb(volatile char *slsb, unsigned char value)
142 xchg((char*)slsb,value);
146 qdio_siga_sync(struct qdio_q *q, unsigned int gpr2,
151 QDIO_DBF_TEXT4(0,trace,"sigasync");
152 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
154 #ifdef QDIO_PERFORMANCE_STATS
155 perf_stats.siga_syncs++;
156 #endif /* QDIO_PERFORMANCE_STATS */
158 cc = do_siga_sync(q->irq, gpr2, gpr3);
160 QDIO_DBF_HEX3(0,trace,&cc,sizeof(int*));
166 qdio_siga_sync_q(struct qdio_q *q)
169 return qdio_siga_sync(q, 0, q->mask);
170 return qdio_siga_sync(q, q->mask, 0);
174 * returns QDIO_SIGA_ERROR_ACCESS_EXCEPTION as cc, when SIGA returns
175 * an access exception
178 qdio_siga_output(struct qdio_q *q)
184 #ifdef QDIO_PERFORMANCE_STATS
185 perf_stats.siga_outs++;
186 #endif /* QDIO_PERFORMANCE_STATS */
188 QDIO_DBF_TEXT4(0,trace,"sigaout");
189 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
192 cc = do_siga_output(q->irq, q->mask, &busy_bit);
193 //QDIO_PRINT_ERR("cc=%x, busy=%x\n",cc,busy_bit);
194 if ((cc==2) && (busy_bit) && (q->is_iqdio_q)) {
197 if ((NOW-start_time)>QDIO_BUSY_BIT_PATIENCE)
203 if ((cc==2) && (busy_bit))
204 cc |= QDIO_SIGA_ERROR_B_BIT_SET;
207 QDIO_DBF_HEX3(0,trace,&cc,sizeof(int*));
213 qdio_siga_input(struct qdio_q *q)
217 QDIO_DBF_TEXT4(0,trace,"sigain");
218 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
220 #ifdef QDIO_PERFORMANCE_STATS
221 perf_stats.siga_ins++;
222 #endif /* QDIO_PERFORMANCE_STATS */
224 cc = do_siga_input(q->irq, q->mask);
227 QDIO_DBF_HEX3(0,trace,&cc,sizeof(int*));
232 /* locked by the locks in qdio_activate and qdio_cleanup */
233 static __u32 * volatile
234 qdio_get_indicator(void)
238 for (i=1;i<INDICATORS_PER_CACHELINE;i++)
239 if (!indicator_used[i]) {
243 atomic_inc(&spare_indicator_usecount);
244 return (__u32 * volatile) &spare_indicator;
247 /* locked by the locks in qdio_activate and qdio_cleanup */
249 qdio_put_indicator(__u32 *addr)
253 if ( (addr) && (addr!=&spare_indicator) ) {
257 if (addr == &spare_indicator)
258 atomic_dec(&spare_indicator_usecount);
261 static inline volatile void
262 tiqdio_clear_summary_bit(__u32 *location)
264 QDIO_DBF_TEXT5(0,trace,"clrsummb");
265 QDIO_DBF_HEX5(0,trace,&location,sizeof(void*));
270 static inline volatile void
271 tiqdio_set_summary_bit(__u32 *location)
273 QDIO_DBF_TEXT5(0,trace,"setsummb");
274 QDIO_DBF_HEX5(0,trace,&location,sizeof(void*));
280 tiqdio_sched_tl(void)
282 tasklet_hi_schedule(&tiqdio_tasklet);
286 qdio_mark_tiq(struct qdio_q *q)
290 QDIO_DBF_TEXT4(0,trace,"mark iq");
291 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
293 spin_lock_irqsave(&ttiq_list_lock,flags);
294 if (unlikely(atomic_read(&q->is_in_shutdown)))
300 if ((q->list_prev) || (q->list_next))
308 q->list_next=tiq_list;
309 q->list_prev=tiq_list->list_prev;
310 tiq_list->list_prev->list_next=q;
311 tiq_list->list_prev=q;
313 spin_unlock_irqrestore(&ttiq_list_lock,flags);
315 tiqdio_set_summary_bit((__u32*)q->dev_st_chg_ind);
319 spin_unlock_irqrestore(&ttiq_list_lock,flags);
324 qdio_mark_q(struct qdio_q *q)
326 QDIO_DBF_TEXT4(0,trace,"mark q");
327 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
329 if (unlikely(atomic_read(&q->is_in_shutdown)))
332 tasklet_schedule(&q->tasklet);
336 qdio_stop_polling(struct qdio_q *q)
338 #ifdef QDIO_USE_PROCESSING_STATE
341 if (!atomic_swap(&q->polling,0))
344 QDIO_DBF_TEXT4(0,trace,"stoppoll");
345 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
347 /* show the card that we are not polling anymore */
351 gsf=GET_SAVED_FRONTIER(q);
352 set_slsb(&q->slsb.acc.val[(gsf+QDIO_MAX_BUFFERS_PER_Q-1)&
353 (QDIO_MAX_BUFFERS_PER_Q-1)],
354 SLSB_P_INPUT_NOT_INIT);
356 * we don't issue this SYNC_MEMORY, as we trust Rick T and
357 * moreover will not use the PROCESSING state under VM, so
358 * q->polling was 0 anyway
361 if (q->slsb.acc.val[gsf]!=SLSB_P_INPUT_PRIMED)
364 * set our summary bit again, as otherwise there is a
365 * small window we can miss between resetting it and
366 * checking for PRIMED state
369 tiqdio_set_summary_bit((__u32*)q->dev_st_chg_ind);
372 #else /* QDIO_USE_PROCESSING_STATE */
374 #endif /* QDIO_USE_PROCESSING_STATE */
378 * see the comment in do_QDIO and before qdio_reserve_q about the
379 * sophisticated locking outside of unmark_q, so that we don't need to
380 * disable the interrupts :-)
383 qdio_unmark_q(struct qdio_q *q)
387 QDIO_DBF_TEXT4(0,trace,"unmark q");
388 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
390 if ((!q->list_prev)||(!q->list_next))
393 if ((q->is_thinint_q)&&(q->is_input_q)) {
395 spin_lock_irqsave(&ttiq_list_lock,flags);
396 /* in case cleanup has done this already and simultanously
397 * qdio_unmark_q is called from the interrupt handler, we've
398 * got to check this in this specific case again */
399 if ((!q->list_prev)||(!q->list_next))
401 if (q->list_next==q) {
402 /* q was the only interesting q */
407 q->list_next->list_prev=q->list_prev;
408 q->list_prev->list_next=q->list_next;
409 tiq_list=q->list_next;
414 spin_unlock_irqrestore(&ttiq_list_lock,flags);
418 static inline unsigned long
419 tiqdio_clear_global_summary(void)
423 QDIO_DBF_TEXT5(0,trace,"clrglobl");
425 time = do_clear_global_summary();
427 QDIO_DBF_HEX5(0,trace,&time,sizeof(unsigned long));
433 /************************* OUTBOUND ROUTINES *******************************/
436 qdio_get_outbound_buffer_frontier(struct qdio_q *q)
440 int first_not_to_check;
443 QDIO_DBF_TEXT4(0,trace,"getobfro");
444 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
446 slsb=&q->slsb.acc.val[0];
447 f_mod_no=f=q->first_to_check;
449 * f points to already processed elements, so f+no_used is correct...
450 * ... but: we don't check 128 buffers, as otherwise
451 * qdio_has_outbound_q_moved would return 0
453 first_not_to_check=f+qdio_min(atomic_read(&q->number_of_buffers_used),
454 (QDIO_MAX_BUFFERS_PER_Q-1));
456 if ((!q->is_iqdio_q)&&(!q->hydra_gives_outbound_pcis))
460 if (f==first_not_to_check)
463 switch(slsb[f_mod_no]) {
465 /* the adapter has not fetched the output yet */
466 case SLSB_CU_OUTPUT_PRIMED:
467 QDIO_DBF_TEXT5(0,trace,"outpprim");
470 /* the adapter got it */
471 case SLSB_P_OUTPUT_EMPTY:
472 atomic_dec(&q->number_of_buffers_used);
474 f_mod_no=f&(QDIO_MAX_BUFFERS_PER_Q-1);
475 QDIO_DBF_TEXT5(0,trace,"outpempt");
478 case SLSB_P_OUTPUT_ERROR:
479 QDIO_DBF_TEXT3(0,trace,"outperr");
480 sprintf(dbf_text,"%x-%x-%x",f_mod_no,
481 q->sbal[f_mod_no]->element[14].sbalf.value,
482 q->sbal[f_mod_no]->element[15].sbalf.value);
483 QDIO_DBF_TEXT3(1,trace,dbf_text);
484 QDIO_DBF_HEX2(1,sbal,q->sbal[f_mod_no],256);
486 /* kind of process the buffer */
487 set_slsb(&q->slsb.acc.val[f_mod_no], SLSB_P_OUTPUT_NOT_INIT);
490 * we increment the frontier, as this buffer
491 * was processed obviously
493 atomic_dec(&q->number_of_buffers_used);
494 f_mod_no=(f_mod_no+1)&(QDIO_MAX_BUFFERS_PER_Q-1);
497 q->error_status_flags|=
498 QDIO_STATUS_MORE_THAN_ONE_QDIO_ERROR;
499 q->qdio_error=SLSB_P_OUTPUT_ERROR;
500 q->error_status_flags|=QDIO_STATUS_LOOK_FOR_ERROR;
506 QDIO_DBF_TEXT5(0,trace,"outpni");
509 return (q->first_to_check=f_mod_no);
512 /* all buffers are processed */
514 qdio_is_outbound_q_done(struct qdio_q *q)
519 no_used=atomic_read(&q->number_of_buffers_used);
522 sprintf(dbf_text,"oqisnt%02x",no_used);
523 QDIO_DBF_TEXT4(0,trace,dbf_text);
525 QDIO_DBF_TEXT4(0,trace,"oqisdone");
527 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
532 qdio_has_outbound_q_moved(struct qdio_q *q)
536 i=qdio_get_outbound_buffer_frontier(q);
538 if ( (i!=GET_SAVED_FRONTIER(q)) ||
539 (q->error_status_flags&QDIO_STATUS_LOOK_FOR_ERROR) ) {
541 QDIO_DBF_TEXT4(0,trace,"oqhasmvd");
542 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
545 QDIO_DBF_TEXT4(0,trace,"oqhsntmv");
546 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
552 qdio_kick_outbound_q(struct qdio_q *q)
557 QDIO_DBF_TEXT4(0,trace,"kickoutq");
558 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
563 /* here's the story with cc=2 and busy bit set (thanks, Rick):
564 * VM's CP could present us cc=2 and busy bit set on SIGA-write
565 * during reconfiguration of their Guest LAN (only in HIPERS mode,
566 * QDIO mode is asynchronous -- cc=2 and busy bit there will take
567 * the queues down immediately; and not being under VM we have a
568 * problem on cc=2 and busy bit set right away).
570 * Therefore qdio_siga_output will try for a short time constantly,
571 * if such a condition occurs. If it doesn't change, it will
572 * increase the busy_siga_counter and save the timestamp, and
573 * schedule the queue for later processing (via mark_q, using the
574 * queue tasklet). __qdio_outbound_processing will check out the
575 * counter. If non-zero, it will call qdio_kick_outbound_q as often
576 * as the value of the counter. This will attempt further SIGA
577 * instructions. For each successful SIGA, the counter is
578 * decreased, for failing SIGAs the counter remains the same, after
580 * After some time of no movement, qdio_kick_outbound_q will
581 * finally fail and reflect corresponding error codes to call
582 * the upper layer module and have it take the queues down.
584 * Note that this is a change from the original HiperSockets design
585 * (saying cc=2 and busy bit means take the queues down), but in
586 * these days Guest LAN didn't exist... excessive cc=2 with busy bit
587 * conditions will still take the queues down, but the threshold is
588 * higher due to the Guest LAN environment.
592 result=qdio_siga_output(q);
596 /* went smooth this time, reset timestamp */
597 QDIO_DBF_TEXT3(0,trace,"cc2reslv");
598 sprintf(dbf_text,"%4x%2x%2x",q->irq,q->q_no,
599 atomic_read(&q->busy_siga_counter));
600 QDIO_DBF_TEXT3(0,trace,dbf_text);
601 q->timing.busy_start=0;
603 case (2|QDIO_SIGA_ERROR_B_BIT_SET):
604 /* cc=2 and busy bit: */
605 atomic_inc(&q->busy_siga_counter);
607 /* if the last siga was successful, save
609 if (!q->timing.busy_start)
610 q->timing.busy_start=NOW;
612 /* if we're in time, don't touch error_status_flags
614 if (NOW-q->timing.busy_start<QDIO_BUSY_BIT_GIVE_UP) {
618 QDIO_DBF_TEXT2(0,trace,"cc2REPRT");
619 sprintf(dbf_text,"%4x%2x%2x",q->irq,q->q_no,
620 atomic_read(&q->busy_siga_counter));
621 QDIO_DBF_TEXT3(0,trace,dbf_text);
622 /* else fallthrough and report error */
624 /* for plain cc=1, 2 or 3: */
626 q->error_status_flags|=
627 QDIO_STATUS_MORE_THAN_ONE_SIGA_ERROR;
628 q->error_status_flags|=
629 QDIO_STATUS_LOOK_FOR_ERROR;
630 q->siga_error=result;
635 qdio_kick_outbound_handler(struct qdio_q *q)
637 int start, end, real_end, count;
640 start = q->first_element_to_kick;
641 /* last_move_ftc was just updated */
642 real_end = GET_SAVED_FRONTIER(q);
643 end = (real_end+QDIO_MAX_BUFFERS_PER_Q-1)&
644 (QDIO_MAX_BUFFERS_PER_Q-1);
645 count = (end+QDIO_MAX_BUFFERS_PER_Q+1-start)&
646 (QDIO_MAX_BUFFERS_PER_Q-1);
648 QDIO_DBF_TEXT4(0,trace,"kickouth");
649 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
651 sprintf(dbf_text,"s=%2xc=%2x",start,count);
652 QDIO_DBF_TEXT4(0,trace,dbf_text);
654 if (q->state==QDIO_IRQ_STATE_ACTIVE)
655 q->handler(q->cdev,QDIO_STATUS_OUTBOUND_INT|
656 q->error_status_flags,
657 q->qdio_error,q->siga_error,q->q_no,start,count,
660 /* for the next time: */
661 q->first_element_to_kick=real_end;
664 q->error_status_flags=0;
668 __qdio_outbound_processing(struct qdio_q *q)
672 QDIO_DBF_TEXT4(0,trace,"qoutproc");
673 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
675 if (unlikely(qdio_reserve_q(q))) {
677 #ifdef QDIO_PERFORMANCE_STATS
679 #endif /* QDIO_PERFORMANCE_STATS */
680 /* as we're sissies, we'll check next time */
681 if (likely(!atomic_read(&q->is_in_shutdown))) {
683 QDIO_DBF_TEXT4(0,trace,"busy,agn");
687 #ifdef QDIO_PERFORMANCE_STATS
689 perf_stats.tl_runs++;
690 #endif /* QDIO_PERFORMANCE_STATS */
692 /* see comment in qdio_kick_outbound_q */
693 siga_attempts=atomic_read(&q->busy_siga_counter);
694 while (siga_attempts) {
695 atomic_dec(&q->busy_siga_counter);
696 qdio_kick_outbound_q(q);
700 if (qdio_has_outbound_q_moved(q))
701 qdio_kick_outbound_handler(q);
705 * for asynchronous queues, we better check, if the fill
706 * level is too high. for synchronous queues, the fill
707 * level will never be that high.
709 if (atomic_read(&q->number_of_buffers_used)>
710 IQDIO_FILL_LEVEL_TO_POLL)
713 } else if (!q->hydra_gives_outbound_pcis)
714 if (!qdio_is_outbound_q_done(q))
721 qdio_outbound_processing(struct qdio_q *q)
723 __qdio_outbound_processing(q);
726 /************************* INBOUND ROUTINES *******************************/
730 qdio_get_inbound_buffer_frontier(struct qdio_q *q)
734 int first_not_to_check;
736 #ifdef QDIO_USE_PROCESSING_STATE
737 int last_position=-1;
738 #endif /* QDIO_USE_PROCESSING_STATE */
740 QDIO_DBF_TEXT4(0,trace,"getibfro");
741 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
743 slsb=&q->slsb.acc.val[0];
744 f_mod_no=f=q->first_to_check;
746 * we don't check 128 buffers, as otherwise qdio_has_inbound_q_moved
749 first_not_to_check=f+qdio_min(atomic_read(&q->number_of_buffers_used),
750 (QDIO_MAX_BUFFERS_PER_Q-1));
753 * we don't use this one, as a PCI or we after a thin interrupt
754 * will sync the queues
759 f_mod_no=f&(QDIO_MAX_BUFFERS_PER_Q-1);
760 if (f==first_not_to_check)
762 switch (slsb[f_mod_no]) {
764 /* CU_EMPTY means frontier is reached */
765 case SLSB_CU_INPUT_EMPTY:
766 QDIO_DBF_TEXT5(0,trace,"inptempt");
769 /* P_PRIMED means set slsb to P_PROCESSING and move on */
770 case SLSB_P_INPUT_PRIMED:
771 QDIO_DBF_TEXT5(0,trace,"inptprim");
773 #ifdef QDIO_USE_PROCESSING_STATE
775 * as soon as running under VM, polling the input queues will
776 * kill VM in terms of CP overhead
779 set_slsb(&slsb[f_mod_no],SLSB_P_INPUT_NOT_INIT);
781 /* set the previous buffer to NOT_INIT. The current
782 * buffer will be set to PROCESSING at the end of
783 * this function to avoid further interrupts. */
784 if (last_position>=0)
785 set_slsb(&slsb[last_position],
786 SLSB_P_INPUT_NOT_INIT);
787 atomic_set(&q->polling,1);
788 last_position=f_mod_no;
790 #else /* QDIO_USE_PROCESSING_STATE */
791 set_slsb(&slsb[f_mod_no],SLSB_P_INPUT_NOT_INIT);
792 #endif /* QDIO_USE_PROCESSING_STATE */
794 * not needed, as the inbound queue will be synced on the next
799 atomic_dec(&q->number_of_buffers_used);
802 case SLSB_P_INPUT_NOT_INIT:
803 case SLSB_P_INPUT_PROCESSING:
804 QDIO_DBF_TEXT5(0,trace,"inpnipro");
807 /* P_ERROR means frontier is reached, break and report error */
808 case SLSB_P_INPUT_ERROR:
809 sprintf(dbf_text,"inperr%2x",f_mod_no);
810 QDIO_DBF_TEXT3(1,trace,dbf_text);
811 QDIO_DBF_HEX2(1,sbal,q->sbal[f_mod_no],256);
813 /* kind of process the buffer */
814 set_slsb(&slsb[f_mod_no],SLSB_P_INPUT_NOT_INIT);
817 q->error_status_flags|=
818 QDIO_STATUS_MORE_THAN_ONE_QDIO_ERROR;
819 q->qdio_error=SLSB_P_INPUT_ERROR;
820 q->error_status_flags|=QDIO_STATUS_LOOK_FOR_ERROR;
822 /* we increment the frontier, as this buffer
823 * was processed obviously */
824 f_mod_no=(f_mod_no+1)&(QDIO_MAX_BUFFERS_PER_Q-1);
825 atomic_dec(&q->number_of_buffers_used);
827 #ifdef QDIO_USE_PROCESSING_STATE
829 #endif /* QDIO_USE_PROCESSING_STATE */
833 /* everything else means frontier not changed (HALTED or so) */
838 q->first_to_check=f_mod_no;
840 #ifdef QDIO_USE_PROCESSING_STATE
841 if (last_position>=0)
842 set_slsb(&slsb[last_position],SLSB_P_INPUT_PROCESSING);
843 #endif /* QDIO_USE_PROCESSING_STATE */
845 QDIO_DBF_HEX4(0,trace,&q->first_to_check,sizeof(int));
847 return q->first_to_check;
851 qdio_has_inbound_q_moved(struct qdio_q *q)
855 #ifdef QDIO_PERFORMANCE_STATS
856 static int old_pcis=0;
857 static int old_thinints=0;
859 if ((old_pcis==perf_stats.pcis)&&(old_thinints==perf_stats.thinints))
860 perf_stats.start_time_inbound=NOW;
862 old_pcis=perf_stats.pcis;
863 #endif /* QDIO_PERFORMANCE_STATS */
865 i=qdio_get_inbound_buffer_frontier(q);
866 if ( (i!=GET_SAVED_FRONTIER(q)) ||
867 (q->error_status_flags&QDIO_STATUS_LOOK_FOR_ERROR) ) {
869 if ((!q->siga_sync)&&(!q->hydra_gives_outbound_pcis))
872 QDIO_DBF_TEXT4(0,trace,"inhasmvd");
873 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
876 QDIO_DBF_TEXT4(0,trace,"inhsntmv");
877 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
882 /* means, no more buffers to be filled */
884 iqdio_is_inbound_q_done(struct qdio_q *q)
889 no_used=atomic_read(&q->number_of_buffers_used);
891 /* propagate the change from 82 to 80 through VM */
895 sprintf(dbf_text,"iqisnt%02x",no_used);
896 QDIO_DBF_TEXT4(0,trace,dbf_text);
898 QDIO_DBF_TEXT4(0,trace,"iniqisdo");
900 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
906 /* we'll check for more primed buffers in qeth_stop_polling */
909 if (q->slsb.acc.val[q->first_to_check]!=SLSB_P_INPUT_PRIMED)
911 * nothing more to do, if next buffer is not PRIMED.
912 * note that we did a SYNC_MEMORY before, that there
913 * has been a sychnronization.
914 * we will return 0 below, as there is nothing to do
915 * (stop_polling not necessary, as we have not been
916 * using the PROCESSING state
921 * ok, the next input buffer is primed. that means, that device state
922 * change indicator and adapter local summary are set, so we will find
924 * we will return 0 below, as there is nothing to do, except scheduling
925 * ourselves for the next time.
927 tiqdio_set_summary_bit((__u32*)q->dev_st_chg_ind);
933 qdio_is_inbound_q_done(struct qdio_q *q)
938 no_used=atomic_read(&q->number_of_buffers_used);
941 * we need that one for synchronization with the adapter, as it
942 * does a kind of PCI avoidance
947 QDIO_DBF_TEXT4(0,trace,"inqisdnA");
948 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
949 QDIO_DBF_TEXT4(0,trace,dbf_text);
953 if (q->slsb.acc.val[q->first_to_check]==SLSB_P_INPUT_PRIMED) {
954 /* we got something to do */
955 QDIO_DBF_TEXT4(0,trace,"inqisntA");
956 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
960 /* on VM, we don't poll, so the q is always done here */
963 if (q->hydra_gives_outbound_pcis)
967 * at this point we know, that inbound first_to_check
968 * has (probably) not moved (see qdio_inbound_processing)
970 if (NOW>GET_SAVED_TIMESTAMP(q)+q->timing.threshold) {
971 QDIO_DBF_TEXT4(0,trace,"inqisdon");
972 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
973 sprintf(dbf_text,"pf%02xcn%02x",q->first_to_check,no_used);
974 QDIO_DBF_TEXT4(0,trace,dbf_text);
977 QDIO_DBF_TEXT4(0,trace,"inqisntd");
978 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
979 sprintf(dbf_text,"pf%02xcn%02x",q->first_to_check,no_used);
980 QDIO_DBF_TEXT4(0,trace,dbf_text);
986 qdio_kick_inbound_handler(struct qdio_q *q)
988 int count, start, end, real_end, i;
991 QDIO_DBF_TEXT4(0,trace,"kickinh");
992 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
994 start=q->first_element_to_kick;
995 real_end=q->first_to_check;
996 end=(real_end+QDIO_MAX_BUFFERS_PER_Q-1)&(QDIO_MAX_BUFFERS_PER_Q-1);
1004 i=(i+1)&(QDIO_MAX_BUFFERS_PER_Q-1);
1007 sprintf(dbf_text,"s=%2xc=%2x",start,count);
1008 QDIO_DBF_TEXT4(0,trace,dbf_text);
1010 if (likely(q->state==QDIO_IRQ_STATE_ACTIVE))
1012 QDIO_STATUS_INBOUND_INT|q->error_status_flags,
1013 q->qdio_error,q->siga_error,q->q_no,start,count,
1016 /* for the next time: */
1017 q->first_element_to_kick=real_end;
1020 q->error_status_flags=0;
1022 #ifdef QDIO_PERFORMANCE_STATS
1023 perf_stats.inbound_time+=NOW-perf_stats.start_time_inbound;
1024 perf_stats.inbound_cnt++;
1025 #endif /* QDIO_PERFORMANCE_STATS */
1029 __tiqdio_inbound_processing(struct qdio_q *q, int spare_ind_was_set)
1031 struct qdio_irq *irq_ptr;
1035 QDIO_DBF_TEXT4(0,trace,"iqinproc");
1036 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
1039 * we first want to reserve the q, so that we know, that we don't
1040 * interrupt ourselves and call qdio_unmark_q, as is_in_shutdown might
1043 if (unlikely(qdio_reserve_q(q))) {
1045 #ifdef QDIO_PERFORMANCE_STATS
1047 #endif /* QDIO_PERFORMANCE_STATS */
1049 * as we might just be about to stop polling, we make
1050 * sure that we check again at least once more
1055 #ifdef QDIO_PERFORMANCE_STATS
1057 #endif /* QDIO_PERFORMANCE_STATS */
1058 if (unlikely(atomic_read(&q->is_in_shutdown))) {
1064 * we reset spare_ind_was_set, when the queue does not use the
1067 if (spare_ind_was_set)
1068 spare_ind_was_set = (q->dev_st_chg_ind == &spare_indicator);
1070 if (!(*(q->dev_st_chg_ind)) && !spare_ind_was_set)
1073 * q->dev_st_chg_ind is the indicator, be it shared or not.
1074 * only clear it, if indicator is non-shared
1076 if (!spare_ind_was_set)
1077 tiqdio_clear_summary_bit((__u32*)q->dev_st_chg_ind);
1079 if (q->hydra_gives_outbound_pcis) {
1080 if (!q->siga_sync_done_on_thinints) {
1082 } else if ((!q->siga_sync_done_on_outb_tis)&&
1083 (q->hydra_gives_outbound_pcis)) {
1084 SYNC_MEMORY_ALL_OUTB;
1090 * maybe we have to do work on our outbound queues... at least
1091 * we have to check the outbound-int-capable thinint-capable
1094 if (q->hydra_gives_outbound_pcis) {
1095 irq_ptr = (struct qdio_irq*)q->irq_ptr;
1096 for (i=0;i<irq_ptr->no_output_qs;i++) {
1097 oq = irq_ptr->output_qs[i];
1098 #ifdef QDIO_PERFORMANCE_STATS
1099 perf_stats.tl_runs--;
1100 #endif /* QDIO_PERFORMANCE_STATS */
1101 if (!qdio_is_outbound_q_done(oq))
1102 __qdio_outbound_processing(oq);
1106 if (!qdio_has_inbound_q_moved(q))
1109 qdio_kick_inbound_handler(q);
1110 if (iqdio_is_inbound_q_done(q))
1111 if (!qdio_stop_polling(q)) {
1113 * we set the flags to get into the stuff next time,
1114 * see also comment in qdio_stop_polling
1116 tiqdio_set_summary_bit((__u32*)q->dev_st_chg_ind);
1124 tiqdio_inbound_processing(struct qdio_q *q)
1126 __tiqdio_inbound_processing(q, atomic_read(&spare_indicator_usecount));
1130 __qdio_inbound_processing(struct qdio_q *q)
1134 QDIO_DBF_TEXT4(0,trace,"qinproc");
1135 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
1137 if (unlikely(qdio_reserve_q(q))) {
1139 #ifdef QDIO_PERFORMANCE_STATS
1141 #endif /* QDIO_PERFORMANCE_STATS */
1142 /* as we're sissies, we'll check next time */
1143 if (likely(!atomic_read(&q->is_in_shutdown))) {
1145 QDIO_DBF_TEXT4(0,trace,"busy,agn");
1149 #ifdef QDIO_PERFORMANCE_STATS
1151 perf_stats.tl_runs++;
1152 #endif /* QDIO_PERFORMANCE_STATS */
1155 if (qdio_has_inbound_q_moved(q)) {
1156 qdio_kick_inbound_handler(q);
1157 if (!qdio_stop_polling(q)) {
1159 if (q_laps<QDIO_Q_LAPS)
1164 if (!qdio_is_inbound_q_done(q))
1165 /* means poll time is not yet over */
1173 qdio_inbound_processing(struct qdio_q *q)
1175 __qdio_inbound_processing(q);
1178 /************************* MAIN ROUTINES *******************************/
1180 #ifdef QDIO_USE_PROCESSING_STATE
1182 tiqdio_reset_processing_state(struct qdio_q *q, int q_laps)
1190 * under VM, we have not used the PROCESSING state, so no
1191 * need to stop polling
1196 if (unlikely(qdio_reserve_q(q))) {
1198 #ifdef QDIO_PERFORMANCE_STATS
1200 #endif /* QDIO_PERFORMANCE_STATS */
1202 * as we might just be about to stop polling, we make
1203 * sure that we check again at least once more
1207 * sanity -- we'd get here without setting the
1210 tiqdio_set_summary_bit((__u32*)q->dev_st_chg_ind);
1214 if (qdio_stop_polling(q)) {
1218 if (q_laps<QDIO_Q_LAPS-1) {
1223 * we set the flags to get into the stuff
1224 * next time, see also comment in qdio_stop_polling
1226 tiqdio_set_summary_bit((__u32*)q->dev_st_chg_ind);
1232 #endif /* QDIO_USE_PROCESSING_STATE */
1235 tiqdio_inbound_checks(void)
1238 int spare_ind_was_set=0;
1239 #ifdef QDIO_USE_PROCESSING_STATE
1241 #endif /* QDIO_USE_PROCESSING_STATE */
1243 QDIO_DBF_TEXT4(0,trace,"iqdinbck");
1244 QDIO_DBF_TEXT5(0,trace,"iqlocsum");
1246 #ifdef QDIO_USE_PROCESSING_STATE
1248 #endif /* QDIO_USE_PROCESSING_STATE */
1250 /* when the spare indicator is used and set, save that and clear it */
1251 if ((atomic_read(&spare_indicator_usecount)) && spare_indicator) {
1252 spare_ind_was_set = 1;
1253 tiqdio_clear_summary_bit((__u32*)&spare_indicator);
1256 q=(struct qdio_q*)tiq_list;
1260 __tiqdio_inbound_processing(q, spare_ind_was_set);
1261 q=(struct qdio_q*)q->list_next;
1262 } while (q!=(struct qdio_q*)tiq_list);
1264 #ifdef QDIO_USE_PROCESSING_STATE
1265 q=(struct qdio_q*)tiq_list;
1269 ret = tiqdio_reset_processing_state(q, q_laps);
1276 q = (struct qdio_q*)q->list_next;
1282 } while (q!=(struct qdio_q*)tiq_list);
1283 #endif /* QDIO_USE_PROCESSING_STATE */
1287 tiqdio_tl(unsigned long data)
1289 QDIO_DBF_TEXT4(0,trace,"iqdio_tl");
1291 #ifdef QDIO_PERFORMANCE_STATS
1292 perf_stats.tl_runs++;
1293 #endif /* QDIO_PERFORMANCE_STATS */
1295 tiqdio_inbound_checks();
1298 /********************* GENERAL HELPER_ROUTINES ***********************/
1301 qdio_release_irq_memory(struct qdio_irq *irq_ptr)
1305 for (i=0;i<QDIO_MAX_QUEUES_PER_IRQ;i++) {
1306 if (!irq_ptr->input_qs[i])
1309 if (irq_ptr->input_qs[i]->slib)
1310 kfree(irq_ptr->input_qs[i]->slib);
1311 kfree(irq_ptr->input_qs[i]);
1314 if (!irq_ptr->output_qs[i])
1317 if (irq_ptr->output_qs[i]->slib)
1318 kfree(irq_ptr->output_qs[i]->slib);
1319 kfree(irq_ptr->output_qs[i]);
1322 kfree(irq_ptr->qdr);
1323 kfree(irq_ptr->actual_alloc); /* This frees irq_ptr itself. */
1327 qdio_set_impl_params(struct qdio_irq *irq_ptr,
1328 unsigned int qib_param_field_format,
1329 /* pointer to 128 bytes or NULL, if no param field */
1330 unsigned char *qib_param_field,
1331 /* pointer to no_queues*128 words of data or NULL */
1332 unsigned int no_input_qs,
1333 unsigned int no_output_qs,
1334 unsigned long *input_slib_elements,
1335 unsigned long *output_slib_elements)
1342 irq_ptr->qib.pfmt=qib_param_field_format;
1343 if (qib_param_field)
1344 memcpy(irq_ptr->qib.parm,qib_param_field,
1345 QDIO_MAX_BUFFERS_PER_Q);
1347 if (input_slib_elements)
1348 for (i=0;i<no_input_qs;i++) {
1349 for (j=0;j<QDIO_MAX_BUFFERS_PER_Q;j++)
1350 irq_ptr->input_qs[i]->slib->slibe[j].parms=
1351 input_slib_elements[
1352 i*QDIO_MAX_BUFFERS_PER_Q+j];
1354 if (output_slib_elements)
1355 for (i=0;i<no_output_qs;i++) {
1356 for (j=0;j<QDIO_MAX_BUFFERS_PER_Q;j++)
1357 irq_ptr->output_qs[i]->slib->slibe[j].parms=
1358 output_slib_elements[
1359 i*QDIO_MAX_BUFFERS_PER_Q+j];
1364 qdio_alloc_qs(struct qdio_irq *irq_ptr,
1365 int no_input_qs, int no_output_qs)
1371 for (i=0;i<no_input_qs;i++) {
1372 q=kmalloc(sizeof(struct qdio_q),GFP_KERNEL);
1375 QDIO_PRINT_ERR("kmalloc of q failed!\n");
1379 memset(q,0,sizeof(struct qdio_q));
1381 q->slib=kmalloc(PAGE_SIZE,GFP_KERNEL);
1383 QDIO_PRINT_ERR("kmalloc of slib failed!\n");
1387 irq_ptr->input_qs[i]=q;
1390 for (i=0;i<no_output_qs;i++) {
1391 q=kmalloc(sizeof(struct qdio_q),GFP_KERNEL);
1397 memset(q,0,sizeof(struct qdio_q));
1399 q->slib=kmalloc(PAGE_SIZE,GFP_KERNEL);
1401 QDIO_PRINT_ERR("kmalloc of slib failed!\n");
1405 irq_ptr->output_qs[i]=q;
1414 qdio_fill_qs(struct qdio_irq *irq_ptr, struct ccw_device *cdev,
1415 int no_input_qs, int no_output_qs,
1416 qdio_handler_t *input_handler,
1417 qdio_handler_t *output_handler,
1418 unsigned long int_parm,int q_format,
1419 unsigned long flags,
1420 void **inbound_sbals_array,
1421 void **outbound_sbals_array)
1425 char dbf_text[20]; /* see qdio_initialize */
1429 sprintf(dbf_text,"qfqs%4x",cdev->private->irq);
1430 QDIO_DBF_TEXT0(0,setup,dbf_text);
1431 for (i=0;i<no_input_qs;i++) {
1432 q=irq_ptr->input_qs[i];
1434 memset(q,0,((char*)&q->slib)-((char*)q));
1435 sprintf(dbf_text,"in-q%4x",i);
1436 QDIO_DBF_TEXT0(0,setup,dbf_text);
1437 QDIO_DBF_HEX0(0,setup,&q,sizeof(void*));
1439 memset(q->slib,0,PAGE_SIZE);
1440 q->sl=(struct sl*)(((char*)q->slib)+PAGE_SIZE/2);
1444 for (j=0;j<QDIO_MAX_BUFFERS_PER_Q;j++)
1445 q->sbal[j]=*(inbound_sbals_array++);
1447 q->queue_type=q_format;
1448 q->int_parm=int_parm;
1449 q->irq=irq_ptr->irq;
1450 q->irq_ptr = irq_ptr;
1455 q->first_to_check=0;
1457 q->handler=input_handler;
1458 q->dev_st_chg_ind=irq_ptr->dev_st_chg_ind;
1460 q->tasklet.data=(unsigned long)q;
1461 /* q->is_thinint_q isn't valid at this time, but
1462 * irq_ptr->is_thinint_irq is */
1463 q->tasklet.func=(void(*)(unsigned long))
1464 ((irq_ptr->is_thinint_irq)?&tiqdio_inbound_processing:
1465 &qdio_inbound_processing);
1467 /* actually this is not used for inbound queues. yet. */
1468 atomic_set(&q->busy_siga_counter,0);
1469 q->timing.busy_start=0;
1471 /* for (j=0;j<QDIO_STATS_NUMBER;j++)
1472 q->timing.last_transfer_times[j]=(qdio_get_micros()/
1473 QDIO_STATS_NUMBER)*j;
1474 q->timing.last_transfer_index=QDIO_STATS_NUMBER-1;
1478 if (i>0) irq_ptr->input_qs[i-1]->slib->nsliba=
1479 (unsigned long)(q->slib);
1480 q->slib->sla=(unsigned long)(q->sl);
1481 q->slib->slsba=(unsigned long)(&q->slsb.acc.val[0]);
1484 for (j=0;j<QDIO_MAX_BUFFERS_PER_Q;j++)
1485 q->sl->element[j].sbal=(unsigned long)(q->sbal[j]);
1487 QDIO_DBF_TEXT2(0,setup,"sl-sb-b0");
1489 QDIO_DBF_HEX2(0,setup,&ptr,sizeof(void*));
1490 ptr=(void*)&q->slsb;
1491 QDIO_DBF_HEX2(0,setup,&ptr,sizeof(void*));
1492 ptr=(void*)q->sbal[0];
1493 QDIO_DBF_HEX2(0,setup,&ptr,sizeof(void*));
1496 for (j=0;j<QDIO_MAX_BUFFERS_PER_Q;j++) {
1497 set_slsb(&q->slsb.acc.val[j],
1498 SLSB_P_INPUT_NOT_INIT);
1499 /* q->sbal[j]->element[1].sbalf.i1.key=QDIO_STORAGE_KEY;*/
1503 for (i=0;i<no_output_qs;i++) {
1504 q=irq_ptr->output_qs[i];
1505 memset(q,0,((char*)&q->slib)-((char*)q));
1507 sprintf(dbf_text,"outq%4x",i);
1508 QDIO_DBF_TEXT0(0,setup,dbf_text);
1509 QDIO_DBF_HEX0(0,setup,&q,sizeof(void*));
1511 memset(q->slib,0,PAGE_SIZE);
1512 q->sl=(struct sl*)(((char*)q->slib)+PAGE_SIZE/2);
1516 for (j=0;j<QDIO_MAX_BUFFERS_PER_Q;j++)
1517 q->sbal[j]=*(outbound_sbals_array++);
1519 q->queue_type=q_format;
1520 q->int_parm=int_parm;
1522 q->irq=irq_ptr->irq;
1524 q->irq_ptr = irq_ptr;
1527 q->first_to_check=0;
1529 q->handler=output_handler;
1531 q->tasklet.data=(unsigned long)q;
1532 q->tasklet.func=(void(*)(unsigned long))
1533 &qdio_outbound_processing;
1535 atomic_set(&q->busy_siga_counter,0);
1536 q->timing.busy_start=0;
1539 if (i>0) irq_ptr->output_qs[i-1]->slib->nsliba=
1540 (unsigned long)(q->slib);
1541 q->slib->sla=(unsigned long)(q->sl);
1542 q->slib->slsba=(unsigned long)(&q->slsb.acc.val[0]);
1545 for (j=0;j<QDIO_MAX_BUFFERS_PER_Q;j++)
1546 q->sl->element[j].sbal=(unsigned long)(q->sbal[j]);
1548 QDIO_DBF_TEXT2(0,setup,"sl-sb-b0");
1550 QDIO_DBF_HEX2(0,setup,&ptr,sizeof(void*));
1551 ptr=(void*)&q->slsb;
1552 QDIO_DBF_HEX2(0,setup,&ptr,sizeof(void*));
1553 ptr=(void*)q->sbal[0];
1554 QDIO_DBF_HEX2(0,setup,&ptr,sizeof(void*));
1557 for (j=0;j<QDIO_MAX_BUFFERS_PER_Q;j++) {
1558 set_slsb(&q->slsb.acc.val[j],
1559 SLSB_P_OUTPUT_NOT_INIT);
1560 /* q->sbal[j]->element[1].sbalf.i1.key=QDIO_STORAGE_KEY;*/
1566 qdio_fill_thresholds(struct qdio_irq *irq_ptr,
1567 unsigned int no_input_qs,
1568 unsigned int no_output_qs,
1569 unsigned int min_input_threshold,
1570 unsigned int max_input_threshold,
1571 unsigned int min_output_threshold,
1572 unsigned int max_output_threshold)
1577 for (i=0;i<no_input_qs;i++) {
1578 q=irq_ptr->input_qs[i];
1579 q->timing.threshold=max_input_threshold;
1580 /* for (j=0;j<QDIO_STATS_CLASSES;j++) {
1581 q->threshold_classes[j].threshold=
1582 min_input_threshold+
1583 (max_input_threshold-min_input_threshold)/
1586 qdio_use_thresholds(q,QDIO_STATS_CLASSES/2);*/
1588 for (i=0;i<no_output_qs;i++) {
1589 q=irq_ptr->output_qs[i];
1590 q->timing.threshold=max_output_threshold;
1591 /* for (j=0;j<QDIO_STATS_CLASSES;j++) {
1592 q->threshold_classes[j].threshold=
1593 min_output_threshold+
1594 (max_output_threshold-min_output_threshold)/
1597 qdio_use_thresholds(q,QDIO_STATS_CLASSES/2);*/
1602 tiqdio_thinint_handler(void)
1604 QDIO_DBF_TEXT4(0,trace,"thin_int");
1606 #ifdef QDIO_PERFORMANCE_STATS
1607 perf_stats.thinints++;
1608 perf_stats.start_time_inbound=NOW;
1609 #endif /* QDIO_PERFORMANCE_STATS */
1611 /* SVS only when needed:
1612 * issue SVS to benefit from iqdio interrupt avoidance
1613 * (SVS clears AISOI)*/
1615 tiqdio_clear_global_summary();
1617 tiqdio_inbound_checks();
1622 qdio_set_state(struct qdio_irq *irq_ptr, enum qdio_irq_states state)
1627 QDIO_DBF_TEXT5(0,trace,"newstate");
1628 sprintf(dbf_text,"%4x%4x",irq_ptr->irq,state);
1629 QDIO_DBF_TEXT5(0,trace,dbf_text);
1631 irq_ptr->state=state;
1632 for (i=0;i<irq_ptr->no_input_qs;i++)
1633 irq_ptr->input_qs[i]->state=state;
1634 for (i=0;i<irq_ptr->no_output_qs;i++)
1635 irq_ptr->output_qs[i]->state=state;
1640 qdio_irq_check_sense(int irq, struct irb *irb)
1644 if (irb->esw.esw0.erw.cons) {
1645 sprintf(dbf_text,"sens%4x",irq);
1646 QDIO_DBF_TEXT2(1,trace,dbf_text);
1647 QDIO_DBF_HEX0(0,sense,irb,QDIO_DBF_SENSE_LEN);
1649 QDIO_PRINT_WARN("sense data available on qdio channel.\n");
1650 HEXDUMP16(WARN,"irb: ",irb);
1651 HEXDUMP16(WARN,"sense data: ",irb->ecw);
1657 qdio_handle_pci(struct qdio_irq *irq_ptr)
1662 #ifdef QDIO_PERFORMANCE_STATS
1664 perf_stats.start_time_inbound=NOW;
1665 #endif /* QDIO_PERFORMANCE_STATS */
1666 for (i=0;i<irq_ptr->no_input_qs;i++) {
1667 q=irq_ptr->input_qs[i];
1668 if (q->is_input_q&QDIO_FLAG_NO_INPUT_INTERRUPT_CONTEXT)
1671 #ifdef QDIO_PERFORMANCE_STATS
1672 perf_stats.tl_runs--;
1673 #endif /* QDIO_PERFORMANCE_STATS */
1674 __qdio_inbound_processing(q);
1677 if (!irq_ptr->hydra_gives_outbound_pcis)
1679 for (i=0;i<irq_ptr->no_output_qs;i++) {
1680 q=irq_ptr->output_qs[i];
1681 #ifdef QDIO_PERFORMANCE_STATS
1682 perf_stats.tl_runs--;
1683 #endif /* QDIO_PERFORMANCE_STATS */
1684 if (qdio_is_outbound_q_done(q))
1686 if (!irq_ptr->sync_done_on_outb_pcis)
1688 __qdio_outbound_processing(q);
1692 static void qdio_establish_handle_irq(struct ccw_device*, int, int);
1695 qdio_handle_activate_check(struct ccw_device *cdev, unsigned long intparm,
1696 int cstat, int dstat)
1698 struct qdio_irq *irq_ptr;
1702 irq_ptr = cdev->private->qdio_data;
1704 QDIO_DBF_TEXT2(1, trace, "ick2");
1705 sprintf(dbf_text,"%s", cdev->dev.bus_id);
1706 QDIO_DBF_TEXT2(1,trace,dbf_text);
1707 QDIO_DBF_HEX2(0,trace,&intparm,sizeof(int));
1708 QDIO_DBF_HEX2(0,trace,&dstat,sizeof(int));
1709 QDIO_DBF_HEX2(0,trace,&cstat,sizeof(int));
1710 QDIO_PRINT_ERR("received check condition on activate " \
1711 "queues on device %s (cs=x%x, ds=x%x).\n",
1712 cdev->dev.bus_id, cstat, dstat);
1713 if (irq_ptr->no_input_qs) {
1714 q=irq_ptr->input_qs[0];
1715 } else if (irq_ptr->no_output_qs) {
1716 q=irq_ptr->output_qs[0];
1718 QDIO_PRINT_ERR("oops... no queue registered for device %s!?\n",
1720 goto omit_handler_call;
1722 q->handler(q->cdev,QDIO_STATUS_ACTIVATE_CHECK_CONDITION|
1723 QDIO_STATUS_LOOK_FOR_ERROR,
1724 0,0,0,-1,-1,q->int_parm);
1726 qdio_set_state(irq_ptr,QDIO_IRQ_STATE_STOPPED);
1731 qdio_call_shutdown(void *data)
1733 struct ccw_device *cdev;
1735 cdev = (struct ccw_device *)data;
1736 qdio_shutdown(cdev, QDIO_FLAG_CLEANUP_USING_CLEAR);
1737 put_device(&cdev->dev);
1741 qdio_timeout_handler(struct ccw_device *cdev)
1743 struct qdio_irq *irq_ptr;
1746 QDIO_DBF_TEXT2(0, trace, "qtoh");
1747 sprintf(dbf_text, "%s", cdev->dev.bus_id);
1748 QDIO_DBF_TEXT2(0, trace, dbf_text);
1750 irq_ptr = cdev->private->qdio_data;
1751 sprintf(dbf_text, "state:%d", irq_ptr->state);
1752 QDIO_DBF_TEXT2(0, trace, dbf_text);
1754 switch (irq_ptr->state) {
1755 case QDIO_IRQ_STATE_INACTIVE:
1756 QDIO_PRINT_ERR("establish queues on irq %04x: timed out\n",
1758 QDIO_DBF_TEXT2(1,setup,"eq:timeo");
1759 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_ERR);
1761 case QDIO_IRQ_STATE_CLEANUP:
1762 QDIO_PRINT_INFO("Did not get interrupt on cleanup, irq=0x%x.\n",
1764 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_ERR);
1766 case QDIO_IRQ_STATE_ESTABLISHED:
1767 case QDIO_IRQ_STATE_ACTIVE:
1768 /* I/O has been terminated by common I/O layer. */
1769 QDIO_PRINT_INFO("Queues on irq %04x killed by cio.\n",
1771 QDIO_DBF_TEXT2(1, trace, "cio:term");
1772 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_STOPPED);
1773 if (get_device(&cdev->dev)) {
1774 /* Can't call shutdown from interrupt context. */
1775 PREPARE_WORK(&cdev->private->kick_work,
1776 qdio_call_shutdown, (void *)cdev);
1777 queue_work(ccw_device_work, &cdev->private->kick_work);
1783 ccw_device_set_timeout(cdev, 0);
1784 wake_up(&cdev->private->wait_q);
1788 qdio_handler(struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
1790 struct qdio_irq *irq_ptr;
1794 QDIO_DBF_TEXT4(0, trace, "qint");
1795 sprintf(dbf_text, "%s", cdev->dev.bus_id);
1796 QDIO_DBF_TEXT4(0, trace, dbf_text);
1799 QDIO_PRINT_ERR("got unsolicited interrupt in qdio " \
1800 "handler, device %s\n", cdev->dev.bus_id);
1804 irq_ptr = cdev->private->qdio_data;
1806 QDIO_DBF_TEXT2(1, trace, "uint");
1807 sprintf(dbf_text,"%s", cdev->dev.bus_id);
1808 QDIO_DBF_TEXT2(1,trace,dbf_text);
1809 QDIO_PRINT_ERR("received interrupt on unused device %s!\n",
1815 /* Currently running i/o is in error. */
1816 switch (PTR_ERR(irb)) {
1818 QDIO_PRINT_ERR("i/o error on device %s\n",
1822 qdio_timeout_handler(cdev);
1825 QDIO_PRINT_ERR("unknown error state %ld on device %s\n",
1826 PTR_ERR(irb), cdev->dev.bus_id);
1831 qdio_irq_check_sense(irq_ptr->irq, irb);
1833 sprintf(dbf_text, "state:%d", irq_ptr->state);
1834 QDIO_DBF_TEXT4(0, trace, dbf_text);
1836 cstat = irb->scsw.cstat;
1837 dstat = irb->scsw.dstat;
1839 switch (irq_ptr->state) {
1840 case QDIO_IRQ_STATE_INACTIVE:
1841 qdio_establish_handle_irq(cdev, cstat, dstat);
1844 case QDIO_IRQ_STATE_CLEANUP:
1845 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_INACTIVE);
1848 case QDIO_IRQ_STATE_ESTABLISHED:
1849 case QDIO_IRQ_STATE_ACTIVE:
1850 if (cstat & SCHN_STAT_PCI) {
1851 qdio_handle_pci(irq_ptr);
1855 if ((cstat&~SCHN_STAT_PCI)||dstat) {
1856 qdio_handle_activate_check(cdev, intparm, cstat, dstat);
1860 QDIO_PRINT_ERR("got interrupt for queues in state %d on " \
1862 irq_ptr->state, cdev->dev.bus_id);
1864 wake_up(&cdev->private->wait_q);
1869 qdio_synchronize(struct ccw_device *cdev, unsigned int flags,
1870 unsigned int queue_number)
1874 struct qdio_irq *irq_ptr;
1875 char dbf_text[15]="SyncXXXX";
1878 irq_ptr = cdev->private->qdio_data;
1882 *((int*)(&dbf_text[4])) = irq_ptr->irq;
1883 QDIO_DBF_HEX4(0,trace,dbf_text,QDIO_DBF_TRACE_LEN);
1884 *((int*)(&dbf_text[0]))=flags;
1885 *((int*)(&dbf_text[4]))=queue_number;
1886 QDIO_DBF_HEX4(0,trace,dbf_text,QDIO_DBF_TRACE_LEN);
1888 if (flags&QDIO_FLAG_SYNC_INPUT) {
1889 q=irq_ptr->input_qs[queue_number];
1892 cc = do_siga_sync(q->irq, 0, q->mask);
1893 } else if (flags&QDIO_FLAG_SYNC_OUTPUT) {
1894 q=irq_ptr->output_qs[queue_number];
1897 cc = do_siga_sync(q->irq, q->mask, 0);
1903 QDIO_DBF_HEX3(0,trace,&ptr,sizeof(int));
1908 static unsigned char
1909 qdio_check_siga_needs(int sch)
1912 unsigned char qdioac;
1915 struct chsc_header request;
1921 struct chsc_header response;
1936 ssqd_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
1938 QDIO_PRINT_WARN("Could not get memory for chsc. Using all " \
1939 "SIGAs for sch x%x.\n", sch);
1940 return CHSC_FLAG_SIGA_INPUT_NECESSARY ||
1941 CHSC_FLAG_SIGA_OUTPUT_NECESSARY ||
1942 CHSC_FLAG_SIGA_SYNC_NECESSARY; /* all flags set */
1944 ssqd_area->request = (struct chsc_header) {
1949 ssqd_area->first_sch = sch;
1950 ssqd_area->last_sch = sch;
1952 result=chsc(ssqd_area);
1955 QDIO_PRINT_WARN("CHSC returned cc %i. Using all " \
1956 "SIGAs for sch x%x.\n",
1958 qdioac = CHSC_FLAG_SIGA_INPUT_NECESSARY ||
1959 CHSC_FLAG_SIGA_OUTPUT_NECESSARY ||
1960 CHSC_FLAG_SIGA_SYNC_NECESSARY; /* all flags set */
1964 if (ssqd_area->response.code != QDIO_CHSC_RESPONSE_CODE_OK) {
1965 QDIO_PRINT_WARN("response upon checking SIGA needs " \
1966 "is 0x%x. Using all SIGAs for sch x%x.\n",
1967 ssqd_area->response.code, sch);
1968 qdioac = CHSC_FLAG_SIGA_INPUT_NECESSARY ||
1969 CHSC_FLAG_SIGA_OUTPUT_NECESSARY ||
1970 CHSC_FLAG_SIGA_SYNC_NECESSARY; /* all flags set */
1973 if (!(ssqd_area->flags & CHSC_FLAG_QDIO_CAPABILITY) ||
1974 !(ssqd_area->flags & CHSC_FLAG_VALIDITY) ||
1975 (ssqd_area->sch != sch)) {
1976 QDIO_PRINT_WARN("huh? problems checking out sch x%x... " \
1977 "using all SIGAs.\n",sch);
1978 qdioac = CHSC_FLAG_SIGA_INPUT_NECESSARY |
1979 CHSC_FLAG_SIGA_OUTPUT_NECESSARY |
1980 CHSC_FLAG_SIGA_SYNC_NECESSARY; /* worst case */
1984 qdioac = ssqd_area->qdioac;
1986 free_page ((unsigned long) ssqd_area);
1991 tiqdio_check_chsc_availability(void)
1995 if (!css_characteristics_avail)
1998 /* Check for bit 41. */
1999 if (!css_general_characteristics.aif) {
2000 QDIO_PRINT_WARN("Adapter interruption facility not " \
2004 /* Check for bits 107 and 108. */
2005 if (!css_chsc_characteristics.scssc ||
2006 !css_chsc_characteristics.scsscf) {
2007 QDIO_PRINT_WARN("Set Chan Subsys. Char. & Fast-CHSCs " \
2008 "not available.\n");
2012 /* Check for OSA/FCP thin interrupts (bit 67). */
2013 hydra_thinints = css_general_characteristics.aif_osa;
2014 sprintf(dbf_text,"hydrati%1x", hydra_thinints);
2015 QDIO_DBF_TEXT0(0,setup,dbf_text);
2017 /* Check for aif time delay disablement fac (bit 56). If installed,
2018 * omit svs even under lpar (good point by rick again) */
2019 omit_svs = css_general_characteristics.aif_tdd;
2020 sprintf(dbf_text,"omitsvs%1x", omit_svs);
2021 QDIO_DBF_TEXT0(0,setup,dbf_text);
2027 tiqdio_set_subchannel_ind(struct qdio_irq *irq_ptr, int reset_to_zero)
2029 unsigned long real_addr_local_summary_bit;
2030 unsigned long real_addr_dev_st_chg_ind;
2034 unsigned int resp_code;
2038 struct chsc_header request;
2043 u64 summary_indicator_addr;
2044 u64 subchannel_indicator_addr;
2051 u32 reserved6[1004];
2052 struct chsc_header response;
2056 if (!irq_ptr->is_thinint_irq)
2059 if (reset_to_zero) {
2060 real_addr_local_summary_bit=0;
2061 real_addr_dev_st_chg_ind=0;
2063 real_addr_local_summary_bit=
2064 virt_to_phys((volatile void *)indicators);
2065 real_addr_dev_st_chg_ind=
2066 virt_to_phys((volatile void *)irq_ptr->dev_st_chg_ind);
2069 scssc_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
2071 QDIO_PRINT_WARN("No memory for setting indicators on " \
2072 "subchannel x%x.\n", irq_ptr->irq);
2075 scssc_area->request = (struct chsc_header) {
2079 scssc_area->operation_code = 0;
2081 scssc_area->summary_indicator_addr = real_addr_local_summary_bit;
2082 scssc_area->subchannel_indicator_addr = real_addr_dev_st_chg_ind;
2083 scssc_area->ks = QDIO_STORAGE_KEY;
2084 scssc_area->kc = QDIO_STORAGE_KEY;
2085 scssc_area->isc = TIQDIO_THININT_ISC;
2086 scssc_area->subsystem_id = (1<<16) + irq_ptr->irq;
2088 result = chsc(scssc_area);
2090 QDIO_PRINT_WARN("could not set indicators on irq x%x, " \
2091 "cc=%i.\n",irq_ptr->irq,result);
2096 resp_code = scssc_area->response.code;
2097 if (resp_code!=QDIO_CHSC_RESPONSE_CODE_OK) {
2098 QDIO_PRINT_WARN("response upon setting indicators " \
2099 "is 0x%x.\n",resp_code);
2100 sprintf(dbf_text,"sidR%4x",resp_code);
2101 QDIO_DBF_TEXT1(0,trace,dbf_text);
2102 QDIO_DBF_TEXT1(0,setup,dbf_text);
2103 ptr=&scssc_area->response;
2104 QDIO_DBF_HEX2(1,setup,&ptr,QDIO_DBF_SETUP_LEN);
2109 QDIO_DBF_TEXT2(0,setup,"setscind");
2110 QDIO_DBF_HEX2(0,setup,&real_addr_local_summary_bit,
2111 sizeof(unsigned long));
2112 QDIO_DBF_HEX2(0,setup,&real_addr_dev_st_chg_ind,sizeof(unsigned long));
2115 free_page ((unsigned long) scssc_area);
2121 tiqdio_set_delay_target(struct qdio_irq *irq_ptr, unsigned long delay_target)
2123 unsigned int resp_code;
2129 struct chsc_header request;
2136 u32 reserved5[1009];
2137 struct chsc_header response;
2141 if (!irq_ptr->is_thinint_irq)
2144 scsscf_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
2146 QDIO_PRINT_WARN("No memory for setting delay target on " \
2147 "subchannel x%x.\n", irq_ptr->irq);
2150 scsscf_area->request = (struct chsc_header) {
2155 scsscf_area->delay_target = delay_target<<16;
2157 result=chsc(scsscf_area);
2159 QDIO_PRINT_WARN("could not set delay target on irq x%x, " \
2160 "cc=%i. Continuing.\n",irq_ptr->irq,result);
2165 resp_code = scsscf_area->response.code;
2166 if (resp_code!=QDIO_CHSC_RESPONSE_CODE_OK) {
2167 QDIO_PRINT_WARN("response upon setting delay target " \
2168 "is 0x%x. Continuing.\n",resp_code);
2169 sprintf(dbf_text,"sdtR%4x",resp_code);
2170 QDIO_DBF_TEXT1(0,trace,dbf_text);
2171 QDIO_DBF_TEXT1(0,setup,dbf_text);
2172 ptr=&scsscf_area->response;
2173 QDIO_DBF_HEX2(1,trace,&ptr,QDIO_DBF_TRACE_LEN);
2175 QDIO_DBF_TEXT2(0,trace,"delytrgt");
2176 QDIO_DBF_HEX2(0,trace,&delay_target,sizeof(unsigned long));
2177 result = 0; /* not critical */
2179 free_page ((unsigned long) scsscf_area);
2184 qdio_cleanup(struct ccw_device *cdev, int how)
2186 struct qdio_irq *irq_ptr;
2190 irq_ptr = cdev->private->qdio_data;
2194 sprintf(dbf_text,"qcln%4x",irq_ptr->irq);
2195 QDIO_DBF_TEXT1(0,trace,dbf_text);
2196 QDIO_DBF_TEXT0(0,setup,dbf_text);
2198 rc = qdio_shutdown(cdev, how);
2199 if ((rc == 0) || (rc == -EINPROGRESS))
2200 rc = qdio_free(cdev);
2205 qdio_shutdown(struct ccw_device *cdev, int how)
2207 struct qdio_irq *irq_ptr;
2211 unsigned long flags;
2215 irq_ptr = cdev->private->qdio_data;
2219 down(&irq_ptr->setting_up_sema);
2221 sprintf(dbf_text,"qsqs%4x",irq_ptr->irq);
2222 QDIO_DBF_TEXT1(0,trace,dbf_text);
2223 QDIO_DBF_TEXT0(0,setup,dbf_text);
2225 /* mark all qs as uninteresting */
2226 for (i=0;i<irq_ptr->no_input_qs;i++)
2227 atomic_set(&irq_ptr->input_qs[i]->is_in_shutdown,1);
2229 for (i=0;i<irq_ptr->no_output_qs;i++)
2230 atomic_set(&irq_ptr->output_qs[i]->is_in_shutdown,1);
2232 tasklet_kill(&tiqdio_tasklet);
2234 for (i=0;i<irq_ptr->no_input_qs;i++) {
2235 qdio_unmark_q(irq_ptr->input_qs[i]);
2236 tasklet_kill(&irq_ptr->input_qs[i]->tasklet);
2237 wait_event_interruptible_timeout(cdev->private->wait_q,
2238 !atomic_read(&irq_ptr->
2241 QDIO_NO_USE_COUNT_TIMEOUT);
2242 if (atomic_read(&irq_ptr->input_qs[i]->use_count))
2243 result=-EINPROGRESS;
2246 for (i=0;i<irq_ptr->no_output_qs;i++) {
2247 tasklet_kill(&irq_ptr->output_qs[i]->tasklet);
2248 wait_event_interruptible_timeout(cdev->private->wait_q,
2249 !atomic_read(&irq_ptr->
2252 QDIO_NO_USE_COUNT_TIMEOUT);
2253 if (atomic_read(&irq_ptr->output_qs[i]->use_count))
2254 result=-EINPROGRESS;
2257 /* cleanup subchannel */
2258 spin_lock_irqsave(get_ccwdev_lock(cdev),flags);
2259 if (how&QDIO_FLAG_CLEANUP_USING_CLEAR) {
2260 rc = ccw_device_clear(cdev, QDIO_DOING_CLEANUP);
2261 timeout=QDIO_CLEANUP_CLEAR_TIMEOUT;
2262 } else if (how&QDIO_FLAG_CLEANUP_USING_HALT) {
2263 rc = ccw_device_halt(cdev, QDIO_DOING_CLEANUP);
2264 timeout=QDIO_CLEANUP_HALT_TIMEOUT;
2265 } else { /* default behaviour */
2266 rc = ccw_device_halt(cdev, QDIO_DOING_CLEANUP);
2267 timeout=QDIO_CLEANUP_HALT_TIMEOUT;
2269 if (rc == -ENODEV) {
2270 /* No need to wait for device no longer present. */
2271 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_INACTIVE);
2272 spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
2273 } else if (rc == 0) {
2274 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_CLEANUP);
2275 ccw_device_set_timeout(cdev, timeout);
2276 spin_unlock_irqrestore(get_ccwdev_lock(cdev),flags);
2278 wait_event(cdev->private->wait_q,
2279 irq_ptr->state == QDIO_IRQ_STATE_INACTIVE ||
2280 irq_ptr->state == QDIO_IRQ_STATE_ERR);
2282 QDIO_PRINT_INFO("ccw_device_{halt,clear} returned %d for "
2283 "device %s\n", result, cdev->dev.bus_id);
2284 spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
2288 if (irq_ptr->is_thinint_irq) {
2289 qdio_put_indicator((__u32*)irq_ptr->dev_st_chg_ind);
2290 tiqdio_set_subchannel_ind(irq_ptr,1);
2291 /* reset adapter interrupt indicators */
2294 /* exchange int handlers, if necessary */
2295 if ((void*)cdev->handler == (void*)qdio_handler)
2296 cdev->handler=irq_ptr->original_int_handler;
2298 /* Ignore errors. */
2299 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_INACTIVE);
2300 ccw_device_set_timeout(cdev, 0);
2302 up(&irq_ptr->setting_up_sema);
2307 qdio_free(struct ccw_device *cdev)
2309 struct qdio_irq *irq_ptr;
2312 irq_ptr = cdev->private->qdio_data;
2316 down(&irq_ptr->setting_up_sema);
2318 sprintf(dbf_text,"qfqs%4x",irq_ptr->irq);
2319 QDIO_DBF_TEXT1(0,trace,dbf_text);
2320 QDIO_DBF_TEXT0(0,setup,dbf_text);
2322 cdev->private->qdio_data = 0;
2324 up(&irq_ptr->setting_up_sema);
2326 qdio_release_irq_memory(irq_ptr);
2327 module_put(THIS_MODULE);
2332 qdio_allocate_do_dbf(struct qdio_initialize *init_data)
2334 char dbf_text[20]; /* if a printf printed out more than 8 chars */
2336 sprintf(dbf_text,"qfmt:%x",init_data->q_format);
2337 QDIO_DBF_TEXT0(0,setup,dbf_text);
2338 QDIO_DBF_HEX0(0,setup,init_data->adapter_name,8);
2339 sprintf(dbf_text,"qpff%4x",init_data->qib_param_field_format);
2340 QDIO_DBF_TEXT0(0,setup,dbf_text);
2341 QDIO_DBF_HEX0(0,setup,&init_data->qib_param_field,sizeof(char*));
2342 QDIO_DBF_HEX0(0,setup,&init_data->input_slib_elements,sizeof(long*));
2343 QDIO_DBF_HEX0(0,setup,&init_data->output_slib_elements,sizeof(long*));
2344 sprintf(dbf_text,"miit%4x",init_data->min_input_threshold);
2345 QDIO_DBF_TEXT0(0,setup,dbf_text);
2346 sprintf(dbf_text,"mait%4x",init_data->max_input_threshold);
2347 QDIO_DBF_TEXT0(0,setup,dbf_text);
2348 sprintf(dbf_text,"miot%4x",init_data->min_output_threshold);
2349 QDIO_DBF_TEXT0(0,setup,dbf_text);
2350 sprintf(dbf_text,"maot%4x",init_data->max_output_threshold);
2351 QDIO_DBF_TEXT0(0,setup,dbf_text);
2352 sprintf(dbf_text,"niq:%4x",init_data->no_input_qs);
2353 QDIO_DBF_TEXT0(0,setup,dbf_text);
2354 sprintf(dbf_text,"noq:%4x",init_data->no_output_qs);
2355 QDIO_DBF_TEXT0(0,setup,dbf_text);
2356 QDIO_DBF_HEX0(0,setup,&init_data->input_handler,sizeof(void*));
2357 QDIO_DBF_HEX0(0,setup,&init_data->output_handler,sizeof(void*));
2358 QDIO_DBF_HEX0(0,setup,&init_data->int_parm,sizeof(long));
2359 QDIO_DBF_HEX0(0,setup,&init_data->flags,sizeof(long));
2360 QDIO_DBF_HEX0(0,setup,&init_data->input_sbal_addr_array,sizeof(void*));
2361 QDIO_DBF_HEX0(0,setup,&init_data->output_sbal_addr_array,sizeof(void*));
2365 qdio_allocate_fill_input_desc(struct qdio_irq *irq_ptr, int i, int iqfmt)
2367 irq_ptr->input_qs[i]->is_iqdio_q = iqfmt;
2368 irq_ptr->input_qs[i]->is_thinint_q = irq_ptr->is_thinint_irq;
2370 irq_ptr->qdr->qdf0[i].sliba=(unsigned long)(irq_ptr->input_qs[i]->slib);
2372 irq_ptr->qdr->qdf0[i].sla=(unsigned long)(irq_ptr->input_qs[i]->sl);
2374 irq_ptr->qdr->qdf0[i].slsba=
2375 (unsigned long)(&irq_ptr->input_qs[i]->slsb.acc.val[0]);
2377 irq_ptr->qdr->qdf0[i].akey=QDIO_STORAGE_KEY;
2378 irq_ptr->qdr->qdf0[i].bkey=QDIO_STORAGE_KEY;
2379 irq_ptr->qdr->qdf0[i].ckey=QDIO_STORAGE_KEY;
2380 irq_ptr->qdr->qdf0[i].dkey=QDIO_STORAGE_KEY;
2384 qdio_allocate_fill_output_desc(struct qdio_irq *irq_ptr, int i,
2387 irq_ptr->output_qs[i]->is_iqdio_q = iqfmt;
2388 irq_ptr->output_qs[i]->is_thinint_q = irq_ptr->is_thinint_irq;
2390 irq_ptr->qdr->qdf0[i+j].sliba=(unsigned long)(irq_ptr->output_qs[i]->slib);
2392 irq_ptr->qdr->qdf0[i+j].sla=(unsigned long)(irq_ptr->output_qs[i]->sl);
2394 irq_ptr->qdr->qdf0[i+j].slsba=
2395 (unsigned long)(&irq_ptr->output_qs[i]->slsb.acc.val[0]);
2397 irq_ptr->qdr->qdf0[i+j].akey=QDIO_STORAGE_KEY;
2398 irq_ptr->qdr->qdf0[i+j].bkey=QDIO_STORAGE_KEY;
2399 irq_ptr->qdr->qdf0[i+j].ckey=QDIO_STORAGE_KEY;
2400 irq_ptr->qdr->qdf0[i+j].dkey=QDIO_STORAGE_KEY;
2405 qdio_initialize_set_siga_flags_input(struct qdio_irq *irq_ptr)
2409 for (i=0;i<irq_ptr->no_input_qs;i++) {
2410 irq_ptr->input_qs[i]->siga_sync=
2411 irq_ptr->qdioac&CHSC_FLAG_SIGA_SYNC_NECESSARY;
2412 irq_ptr->input_qs[i]->siga_in=
2413 irq_ptr->qdioac&CHSC_FLAG_SIGA_INPUT_NECESSARY;
2414 irq_ptr->input_qs[i]->siga_out=
2415 irq_ptr->qdioac&CHSC_FLAG_SIGA_OUTPUT_NECESSARY;
2416 irq_ptr->input_qs[i]->siga_sync_done_on_thinints=
2417 irq_ptr->qdioac&CHSC_FLAG_SIGA_SYNC_DONE_ON_THININTS;
2418 irq_ptr->input_qs[i]->hydra_gives_outbound_pcis=
2419 irq_ptr->hydra_gives_outbound_pcis;
2420 irq_ptr->input_qs[i]->siga_sync_done_on_outb_tis=
2422 (CHSC_FLAG_SIGA_SYNC_DONE_ON_OUTB_PCIS|
2423 CHSC_FLAG_SIGA_SYNC_DONE_ON_THININTS))==
2424 (CHSC_FLAG_SIGA_SYNC_DONE_ON_OUTB_PCIS|
2425 CHSC_FLAG_SIGA_SYNC_DONE_ON_THININTS));
2431 qdio_initialize_set_siga_flags_output(struct qdio_irq *irq_ptr)
2435 for (i=0;i<irq_ptr->no_output_qs;i++) {
2436 irq_ptr->output_qs[i]->siga_sync=
2437 irq_ptr->qdioac&CHSC_FLAG_SIGA_SYNC_NECESSARY;
2438 irq_ptr->output_qs[i]->siga_in=
2439 irq_ptr->qdioac&CHSC_FLAG_SIGA_INPUT_NECESSARY;
2440 irq_ptr->output_qs[i]->siga_out=
2441 irq_ptr->qdioac&CHSC_FLAG_SIGA_OUTPUT_NECESSARY;
2442 irq_ptr->output_qs[i]->siga_sync_done_on_thinints=
2443 irq_ptr->qdioac&CHSC_FLAG_SIGA_SYNC_DONE_ON_THININTS;
2444 irq_ptr->output_qs[i]->hydra_gives_outbound_pcis=
2445 irq_ptr->hydra_gives_outbound_pcis;
2446 irq_ptr->output_qs[i]->siga_sync_done_on_outb_tis=
2448 (CHSC_FLAG_SIGA_SYNC_DONE_ON_OUTB_PCIS|
2449 CHSC_FLAG_SIGA_SYNC_DONE_ON_THININTS))==
2450 (CHSC_FLAG_SIGA_SYNC_DONE_ON_OUTB_PCIS|
2451 CHSC_FLAG_SIGA_SYNC_DONE_ON_THININTS));
2457 qdio_establish_irq_check_for_errors(struct ccw_device *cdev, int cstat,
2461 struct qdio_irq *irq_ptr;
2463 irq_ptr = cdev->private->qdio_data;
2465 if (cstat || (dstat & ~(DEV_STAT_CHN_END|DEV_STAT_DEV_END))) {
2466 sprintf(dbf_text,"ick1%4x",irq_ptr->irq);
2467 QDIO_DBF_TEXT2(1,trace,dbf_text);
2468 QDIO_DBF_HEX2(0,trace,&dstat,sizeof(int));
2469 QDIO_DBF_HEX2(0,trace,&cstat,sizeof(int));
2470 QDIO_PRINT_ERR("received check condition on establish " \
2471 "queues on irq 0x%x (cs=x%x, ds=x%x).\n",
2472 irq_ptr->irq,cstat,dstat);
2473 qdio_set_state(irq_ptr,QDIO_IRQ_STATE_ERR);
2476 if (!(dstat & DEV_STAT_DEV_END)) {
2477 QDIO_DBF_TEXT2(1,setup,"eq:no de");
2478 QDIO_DBF_HEX2(0,setup,&dstat, sizeof(dstat));
2479 QDIO_DBF_HEX2(0,setup,&cstat, sizeof(cstat));
2480 QDIO_PRINT_ERR("establish queues on irq %04x: didn't get "
2481 "device end: dstat=%02x, cstat=%02x\n",
2482 irq_ptr->irq, dstat, cstat);
2483 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_ERR);
2487 if (dstat & ~(DEV_STAT_CHN_END|DEV_STAT_DEV_END)) {
2488 QDIO_DBF_TEXT2(1,setup,"eq:badio");
2489 QDIO_DBF_HEX2(0,setup,&dstat, sizeof(dstat));
2490 QDIO_DBF_HEX2(0,setup,&cstat, sizeof(cstat));
2491 QDIO_PRINT_ERR("establish queues on irq %04x: got "
2492 "the following devstat: dstat=%02x, "
2494 irq_ptr->irq, dstat, cstat);
2495 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_ERR);
2502 qdio_establish_handle_irq(struct ccw_device *cdev, int cstat, int dstat)
2504 struct qdio_irq *irq_ptr;
2507 irq_ptr = cdev->private->qdio_data;
2509 sprintf(dbf_text,"qehi%4x",cdev->private->irq);
2510 QDIO_DBF_TEXT0(0,setup,dbf_text);
2511 QDIO_DBF_TEXT0(0,trace,dbf_text);
2513 if (qdio_establish_irq_check_for_errors(cdev, cstat, dstat)) {
2514 ccw_device_set_timeout(cdev, 0);
2518 qdio_set_state(irq_ptr,QDIO_IRQ_STATE_ESTABLISHED);
2519 ccw_device_set_timeout(cdev, 0);
2523 qdio_initialize(struct qdio_initialize *init_data)
2528 sprintf(dbf_text,"qini%4x",init_data->cdev->private->irq);
2529 QDIO_DBF_TEXT0(0,setup,dbf_text);
2530 QDIO_DBF_TEXT0(0,trace,dbf_text);
2532 rc = qdio_allocate(init_data);
2534 rc = qdio_establish(init_data);
2536 qdio_free(init_data->cdev);
2544 qdio_allocate(struct qdio_initialize *init_data)
2548 struct qdio_irq *irq_ptr;
2551 sprintf(dbf_text,"qalc%4x",init_data->cdev->private->irq);
2552 QDIO_DBF_TEXT0(0,setup,dbf_text);
2553 QDIO_DBF_TEXT0(0,trace,dbf_text);
2554 if ( (init_data->no_input_qs>QDIO_MAX_QUEUES_PER_IRQ) ||
2555 (init_data->no_output_qs>QDIO_MAX_QUEUES_PER_IRQ) ||
2556 ((init_data->no_input_qs) && (!init_data->input_handler)) ||
2557 ((init_data->no_output_qs) && (!init_data->output_handler)) )
2560 if (!init_data->input_sbal_addr_array)
2563 if (!init_data->output_sbal_addr_array)
2566 qdio_allocate_do_dbf(init_data);
2569 mem = kmalloc(sizeof(struct qdio_irq) + 0xff, GFP_KERNEL | GFP_DMA);
2571 QDIO_DBF_TEXT0(0,setup,"irq_ptr:");
2572 QDIO_DBF_HEX0(0,setup,&irq_ptr,sizeof(void*));
2575 QDIO_PRINT_ERR("kmalloc of irq_ptr failed!\n");
2579 irq_ptr = (struct qdio_irq *) mem;
2580 if ((off = ((unsigned long) mem) & 0xff) != 0)
2581 irq_ptr = (struct qdio_irq *)(mem + 0x100 - off);
2582 memset(irq_ptr,0,sizeof(struct qdio_irq));
2583 irq_ptr->actual_alloc = mem;
2585 init_MUTEX(&irq_ptr->setting_up_sema);
2587 irq_ptr->qdr=kmalloc(sizeof(struct qdr), GFP_KERNEL | GFP_DMA);
2588 if (!(irq_ptr->qdr)) {
2590 QDIO_PRINT_ERR("kmalloc of irq_ptr->qdr failed!\n");
2593 QDIO_DBF_TEXT0(0,setup,"qdr:");
2594 QDIO_DBF_HEX0(0,setup,&irq_ptr->qdr,sizeof(void*));
2596 if (qdio_alloc_qs(irq_ptr,
2597 init_data->no_input_qs,
2598 init_data->no_output_qs)) {
2599 qdio_release_irq_memory(irq_ptr);
2603 init_data->cdev->private->qdio_data = irq_ptr;
2605 qdio_set_state(irq_ptr,QDIO_IRQ_STATE_INACTIVE);
2610 int qdio_fill_irq(struct qdio_initialize *init_data)
2616 struct qdio_irq *irq_ptr;
2618 irq_ptr = init_data->cdev->private->qdio_data;
2620 memset(irq_ptr,0,((char*)&irq_ptr->qdr)-((char*)irq_ptr));
2622 /* wipes qib.ac, required by ar7063 */
2623 memset(irq_ptr->qdr,0,sizeof(struct qdr));
2625 irq_ptr->int_parm=init_data->int_parm;
2627 irq_ptr->irq = init_data->cdev->private->irq;
2628 irq_ptr->no_input_qs=init_data->no_input_qs;
2629 irq_ptr->no_output_qs=init_data->no_output_qs;
2631 if (init_data->q_format==QDIO_IQDIO_QFMT) {
2632 irq_ptr->is_iqdio_irq=1;
2633 irq_ptr->is_thinint_irq=1;
2635 irq_ptr->is_iqdio_irq=0;
2636 irq_ptr->is_thinint_irq=hydra_thinints;
2638 sprintf(dbf_text,"is_i_t%1x%1x",
2639 irq_ptr->is_iqdio_irq,irq_ptr->is_thinint_irq);
2640 QDIO_DBF_TEXT2(0,setup,dbf_text);
2642 if (irq_ptr->is_thinint_irq) {
2643 irq_ptr->dev_st_chg_ind=qdio_get_indicator();
2644 QDIO_DBF_HEX1(0,setup,&irq_ptr->dev_st_chg_ind,sizeof(void*));
2645 if (!irq_ptr->dev_st_chg_ind) {
2646 QDIO_PRINT_WARN("no indicator location available " \
2647 "for irq 0x%x\n",irq_ptr->irq);
2648 qdio_release_irq_memory(irq_ptr);
2654 irq_ptr->equeue.cmd=DEFAULT_ESTABLISH_QS_CMD;
2655 irq_ptr->equeue.count=DEFAULT_ESTABLISH_QS_COUNT;
2656 irq_ptr->aqueue.cmd=DEFAULT_ACTIVATE_QS_CMD;
2657 irq_ptr->aqueue.count=DEFAULT_ACTIVATE_QS_COUNT;
2659 qdio_fill_qs(irq_ptr, init_data->cdev,
2660 init_data->no_input_qs,
2661 init_data->no_output_qs,
2662 init_data->input_handler,
2663 init_data->output_handler,init_data->int_parm,
2664 init_data->q_format,init_data->flags,
2665 init_data->input_sbal_addr_array,
2666 init_data->output_sbal_addr_array);
2668 if (!try_module_get(THIS_MODULE)) {
2669 QDIO_PRINT_CRIT("try_module_get() failed!\n");
2670 qdio_release_irq_memory(irq_ptr);
2674 qdio_fill_thresholds(irq_ptr,init_data->no_input_qs,
2675 init_data->no_output_qs,
2676 init_data->min_input_threshold,
2677 init_data->max_input_threshold,
2678 init_data->min_output_threshold,
2679 init_data->max_output_threshold);
2682 irq_ptr->qdr->qfmt=init_data->q_format;
2683 irq_ptr->qdr->iqdcnt=init_data->no_input_qs;
2684 irq_ptr->qdr->oqdcnt=init_data->no_output_qs;
2685 irq_ptr->qdr->iqdsz=sizeof(struct qdesfmt0)/4; /* size in words */
2686 irq_ptr->qdr->oqdsz=sizeof(struct qdesfmt0)/4;
2688 irq_ptr->qdr->qiba=(unsigned long)&irq_ptr->qib;
2689 irq_ptr->qdr->qkey=QDIO_STORAGE_KEY;
2692 irq_ptr->qib.qfmt=init_data->q_format;
2693 if (init_data->no_input_qs)
2694 irq_ptr->qib.isliba=(unsigned long)(irq_ptr->input_qs[0]->slib);
2695 if (init_data->no_output_qs)
2696 irq_ptr->qib.osliba=(unsigned long)(irq_ptr->output_qs[0]->slib);
2697 memcpy(irq_ptr->qib.ebcnam,init_data->adapter_name,8);
2699 qdio_set_impl_params(irq_ptr,init_data->qib_param_field_format,
2700 init_data->qib_param_field,
2701 init_data->no_input_qs,
2702 init_data->no_output_qs,
2703 init_data->input_slib_elements,
2704 init_data->output_slib_elements);
2706 /* first input descriptors, then output descriptors */
2707 is_iqdio = (init_data->q_format == QDIO_IQDIO_QFMT) ? 1 : 0;
2708 for (i=0;i<init_data->no_input_qs;i++)
2709 qdio_allocate_fill_input_desc(irq_ptr, i, is_iqdio);
2711 for (i=0;i<init_data->no_output_qs;i++)
2712 qdio_allocate_fill_output_desc(irq_ptr, i,
2713 init_data->no_input_qs,
2716 /* qdr, qib, sls, slsbs, slibs, sbales filled. */
2718 /* get qdio commands */
2719 ciw = ccw_device_get_ciw(init_data->cdev, CIW_TYPE_EQUEUE);
2721 QDIO_DBF_TEXT2(1,setup,"no eq");
2722 QDIO_PRINT_INFO("No equeue CIW found for QDIO commands. "
2723 "Trying to use default.\n");
2725 irq_ptr->equeue = *ciw;
2726 ciw = ccw_device_get_ciw(init_data->cdev, CIW_TYPE_AQUEUE);
2728 QDIO_DBF_TEXT2(1,setup,"no aq");
2729 QDIO_PRINT_INFO("No aqueue CIW found for QDIO commands. "
2730 "Trying to use default.\n");
2732 irq_ptr->aqueue = *ciw;
2734 /* Set new interrupt handler. */
2735 irq_ptr->original_int_handler = init_data->cdev->handler;
2736 init_data->cdev->handler = qdio_handler;
2742 qdio_establish(struct qdio_initialize *init_data)
2744 struct qdio_irq *irq_ptr;
2745 unsigned long saveflags;
2746 int result, result2;
2747 struct ccw_device *cdev;
2750 cdev=init_data->cdev;
2751 irq_ptr = cdev->private->qdio_data;
2755 if (cdev->private->state != DEV_STATE_ONLINE)
2758 down(&irq_ptr->setting_up_sema);
2760 qdio_fill_irq(init_data);
2762 /* the thinint CHSC stuff */
2763 if (irq_ptr->is_thinint_irq) {
2765 result = tiqdio_set_subchannel_ind(irq_ptr,0);
2767 up(&irq_ptr->setting_up_sema);
2768 qdio_shutdown(cdev, QDIO_FLAG_CLEANUP_USING_CLEAR);
2771 tiqdio_set_delay_target(irq_ptr,TIQDIO_DELAY_TARGET);
2774 sprintf(dbf_text,"qest%4x",cdev->private->irq);
2775 QDIO_DBF_TEXT0(0,setup,dbf_text);
2776 QDIO_DBF_TEXT0(0,trace,dbf_text);
2779 irq_ptr->ccw.cmd_code=irq_ptr->equeue.cmd;
2780 irq_ptr->ccw.flags=CCW_FLAG_SLI;
2781 irq_ptr->ccw.count=irq_ptr->equeue.count;
2782 irq_ptr->ccw.cda=QDIO_GET_ADDR(irq_ptr->qdr);
2784 spin_lock_irqsave(get_ccwdev_lock(cdev),saveflags);
2786 ccw_device_set_options(cdev, 0);
2787 result=ccw_device_start_timeout(cdev,&irq_ptr->ccw,
2788 QDIO_DOING_ESTABLISH,0, 0,
2789 QDIO_ESTABLISH_TIMEOUT);
2791 result2=ccw_device_start_timeout(cdev,&irq_ptr->ccw,
2792 QDIO_DOING_ESTABLISH,0,0,
2793 QDIO_ESTABLISH_TIMEOUT);
2794 sprintf(dbf_text,"eq:io%4x",result);
2795 QDIO_DBF_TEXT2(1,setup,dbf_text);
2797 sprintf(dbf_text,"eq:io%4x",result);
2798 QDIO_DBF_TEXT2(1,setup,dbf_text);
2800 QDIO_PRINT_WARN("establish queues on irq %04x: do_IO " \
2801 "returned %i, next try returned %i\n",
2802 irq_ptr->irq,result,result2);
2805 ccw_device_set_timeout(cdev, 0);
2808 spin_unlock_irqrestore(get_ccwdev_lock(cdev),saveflags);
2811 up(&irq_ptr->setting_up_sema);
2812 qdio_shutdown(cdev,QDIO_FLAG_CLEANUP_USING_CLEAR);
2816 wait_event_interruptible_timeout(cdev->private->wait_q,
2817 irq_ptr->state == QDIO_IRQ_STATE_ESTABLISHED ||
2818 irq_ptr->state == QDIO_IRQ_STATE_ERR,
2819 QDIO_ESTABLISH_TIMEOUT);
2821 if (irq_ptr->state == QDIO_IRQ_STATE_ESTABLISHED)
2824 up(&irq_ptr->setting_up_sema);
2825 qdio_shutdown(cdev, QDIO_FLAG_CLEANUP_USING_CLEAR);
2829 irq_ptr->qdioac=qdio_check_siga_needs(irq_ptr->irq);
2830 /* if this gets set once, we're running under VM and can omit SVSes */
2831 if (irq_ptr->qdioac&CHSC_FLAG_SIGA_SYNC_NECESSARY)
2834 sprintf(dbf_text,"qdioac%2x",irq_ptr->qdioac);
2835 QDIO_DBF_TEXT2(0,setup,dbf_text);
2837 sprintf(dbf_text,"qib ac%2x",irq_ptr->qib.ac);
2838 QDIO_DBF_TEXT2(0,setup,dbf_text);
2840 irq_ptr->hydra_gives_outbound_pcis=
2841 irq_ptr->qib.ac&QIB_AC_OUTBOUND_PCI_SUPPORTED;
2842 irq_ptr->sync_done_on_outb_pcis=
2843 irq_ptr->qdioac&CHSC_FLAG_SIGA_SYNC_DONE_ON_OUTB_PCIS;
2845 qdio_initialize_set_siga_flags_input(irq_ptr);
2846 qdio_initialize_set_siga_flags_output(irq_ptr);
2848 up(&irq_ptr->setting_up_sema);
2855 qdio_activate(struct ccw_device *cdev, int flags)
2857 struct qdio_irq *irq_ptr;
2858 int i,result=0,result2;
2859 unsigned long saveflags;
2860 char dbf_text[20]; /* see qdio_initialize */
2862 irq_ptr = cdev->private->qdio_data;
2866 if (cdev->private->state != DEV_STATE_ONLINE)
2869 down(&irq_ptr->setting_up_sema);
2870 if (irq_ptr->state==QDIO_IRQ_STATE_INACTIVE) {
2875 sprintf(dbf_text,"qact%4x", irq_ptr->irq);
2876 QDIO_DBF_TEXT2(0,setup,dbf_text);
2877 QDIO_DBF_TEXT2(0,trace,dbf_text);
2880 irq_ptr->ccw.cmd_code=irq_ptr->aqueue.cmd;
2881 irq_ptr->ccw.flags=CCW_FLAG_SLI;
2882 irq_ptr->ccw.count=irq_ptr->aqueue.count;
2883 irq_ptr->ccw.cda=QDIO_GET_ADDR(0);
2885 spin_lock_irqsave(get_ccwdev_lock(cdev),saveflags);
2887 ccw_device_set_timeout(cdev, 0);
2888 ccw_device_set_options(cdev, CCWDEV_REPORT_ALL);
2889 result=ccw_device_start(cdev,&irq_ptr->ccw,QDIO_DOING_ACTIVATE,
2890 0, DOIO_DENY_PREFETCH);
2892 result2=ccw_device_start(cdev,&irq_ptr->ccw,
2893 QDIO_DOING_ACTIVATE,0,0);
2894 sprintf(dbf_text,"aq:io%4x",result);
2895 QDIO_DBF_TEXT2(1,setup,dbf_text);
2897 sprintf(dbf_text,"aq:io%4x",result);
2898 QDIO_DBF_TEXT2(1,setup,dbf_text);
2900 QDIO_PRINT_WARN("activate queues on irq %04x: do_IO " \
2901 "returned %i, next try returned %i\n",
2902 irq_ptr->irq,result,result2);
2906 spin_unlock_irqrestore(get_ccwdev_lock(cdev),saveflags);
2910 for (i=0;i<irq_ptr->no_input_qs;i++) {
2911 if (irq_ptr->is_thinint_irq) {
2913 * that way we know, that, if we will get interrupted
2914 * by tiqdio_inbound_processing, qdio_unmark_q will
2917 qdio_reserve_q(irq_ptr->input_qs[i]);
2918 qdio_mark_tiq(irq_ptr->input_qs[i]);
2919 qdio_release_q(irq_ptr->input_qs[i]);
2923 if (flags&QDIO_FLAG_NO_INPUT_INTERRUPT_CONTEXT) {
2924 for (i=0;i<irq_ptr->no_input_qs;i++) {
2925 irq_ptr->input_qs[i]->is_input_q|=
2926 QDIO_FLAG_NO_INPUT_INTERRUPT_CONTEXT;
2930 wait_event_interruptible_timeout(cdev->private->wait_q,
2932 QDIO_IRQ_STATE_STOPPED) ||
2934 QDIO_IRQ_STATE_ERR)),
2935 QDIO_ACTIVATE_TIMEOUT);
2937 switch (irq_ptr->state) {
2938 case QDIO_IRQ_STATE_STOPPED:
2939 case QDIO_IRQ_STATE_ERR:
2940 up(&irq_ptr->setting_up_sema);
2941 qdio_shutdown(cdev, QDIO_FLAG_CLEANUP_USING_CLEAR);
2942 down(&irq_ptr->setting_up_sema);
2946 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_ACTIVE);
2950 up(&irq_ptr->setting_up_sema);
2955 /* buffers filled forwards again to make Rick happy */
2957 qdio_do_qdio_fill_input(struct qdio_q *q, unsigned int qidx,
2958 unsigned int count, struct qdio_buffer *buffers)
2961 set_slsb(&q->slsb.acc.val[qidx],SLSB_CU_INPUT_EMPTY);
2964 qidx=(qidx+1)&(QDIO_MAX_BUFFERS_PER_Q-1);
2967 /* not necessary, as the queues are synced during the SIGA read */
2972 qdio_do_qdio_fill_output(struct qdio_q *q, unsigned int qidx,
2973 unsigned int count, struct qdio_buffer *buffers)
2976 set_slsb(&q->slsb.acc.val[qidx],SLSB_CU_OUTPUT_PRIMED);
2979 qidx=(qidx+1)&(QDIO_MAX_BUFFERS_PER_Q-1);
2982 /* SIGA write will sync the queues */
2987 do_qdio_handle_inbound(struct qdio_q *q, unsigned int callflags,
2988 unsigned int qidx, unsigned int count,
2989 struct qdio_buffer *buffers)
2993 /* This is the inbound handling of queues */
2994 used_elements=atomic_add_return(count, &q->number_of_buffers_used) - count;
2996 qdio_do_qdio_fill_input(q,qidx,count,buffers);
2998 if ((used_elements+count==QDIO_MAX_BUFFERS_PER_Q)&&
2999 (callflags&QDIO_FLAG_UNDER_INTERRUPT))
3000 atomic_swap(&q->polling,0);
3004 if (callflags&QDIO_FLAG_DONT_SIGA)
3009 result=qdio_siga_input(q);
3012 q->error_status_flags|=
3013 QDIO_STATUS_MORE_THAN_ONE_SIGA_ERROR;
3014 q->error_status_flags|=QDIO_STATUS_LOOK_FOR_ERROR;
3015 q->siga_error=result;
3023 do_qdio_handle_outbound(struct qdio_q *q, unsigned int callflags,
3024 unsigned int qidx, unsigned int count,
3025 struct qdio_buffer *buffers)
3029 /* This is the outbound handling of queues */
3030 #ifdef QDIO_PERFORMANCE_STATS
3031 perf_stats.start_time_outbound=NOW;
3032 #endif /* QDIO_PERFORMANCE_STATS */
3034 qdio_do_qdio_fill_output(q,qidx,count,buffers);
3036 used_elements=atomic_add_return(count, &q->number_of_buffers_used) - count;
3038 if (callflags&QDIO_FLAG_DONT_SIGA) {
3039 #ifdef QDIO_PERFORMANCE_STATS
3040 perf_stats.outbound_time+=NOW-perf_stats.start_time_outbound;
3041 perf_stats.outbound_cnt++;
3042 #endif /* QDIO_PERFORMANCE_STATS */
3045 if (q->is_iqdio_q) {
3046 /* one siga for every sbal */
3048 qdio_kick_outbound_q(q);
3050 __qdio_outbound_processing(q);
3052 /* under VM, we do a SIGA sync unconditionally */
3056 * w/o shadow queues (else branch of
3057 * SYNC_MEMORY :-/ ), we try to
3058 * fast-requeue buffers
3060 if (q->slsb.acc.val[(qidx+QDIO_MAX_BUFFERS_PER_Q-1)
3061 &(QDIO_MAX_BUFFERS_PER_Q-1)]!=
3062 SLSB_CU_OUTPUT_PRIMED) {
3063 qdio_kick_outbound_q(q);
3065 QDIO_DBF_TEXT3(0,trace, "fast-req");
3066 #ifdef QDIO_PERFORMANCE_STATS
3067 perf_stats.fast_reqs++;
3068 #endif /* QDIO_PERFORMANCE_STATS */
3072 * only marking the q could take too long,
3073 * the upper layer module could do a lot of
3074 * traffic in that time
3076 __qdio_outbound_processing(q);
3079 #ifdef QDIO_PERFORMANCE_STATS
3080 perf_stats.outbound_time+=NOW-perf_stats.start_time_outbound;
3081 perf_stats.outbound_cnt++;
3082 #endif /* QDIO_PERFORMANCE_STATS */
3085 /* count must be 1 in iqdio */
3087 do_QDIO(struct ccw_device *cdev,unsigned int callflags,
3088 unsigned int queue_number, unsigned int qidx,
3089 unsigned int count,struct qdio_buffer *buffers)
3091 struct qdio_irq *irq_ptr;
3095 sprintf(dbf_text,"doQD%04x",cdev->private->irq);
3096 QDIO_DBF_TEXT3(0,trace,dbf_text);
3098 if ( (qidx>QDIO_MAX_BUFFERS_PER_Q) ||
3099 (count>QDIO_MAX_BUFFERS_PER_Q) ||
3100 (queue_number>QDIO_MAX_QUEUES_PER_IRQ) )
3106 irq_ptr = cdev->private->qdio_data;
3110 if (callflags&QDIO_FLAG_SYNC_INPUT)
3111 QDIO_DBF_HEX3(0,trace,&irq_ptr->input_qs[queue_number],
3114 QDIO_DBF_HEX3(0,trace,&irq_ptr->output_qs[queue_number],
3116 sprintf(dbf_text,"flag%04x",callflags);
3117 QDIO_DBF_TEXT3(0,trace,dbf_text);
3118 sprintf(dbf_text,"qi%02xct%02x",qidx,count);
3119 QDIO_DBF_TEXT3(0,trace,dbf_text);
3121 if (irq_ptr->state!=QDIO_IRQ_STATE_ACTIVE)
3124 if (callflags&QDIO_FLAG_SYNC_INPUT)
3125 do_qdio_handle_inbound(irq_ptr->input_qs[queue_number],
3126 callflags, qidx, count, buffers);
3127 else if (callflags&QDIO_FLAG_SYNC_OUTPUT)
3128 do_qdio_handle_outbound(irq_ptr->output_qs[queue_number],
3129 callflags, qidx, count, buffers);
3131 QDIO_DBF_TEXT3(1,trace,"doQD:inv");
3137 #ifdef QDIO_PERFORMANCE_STATS
3139 qdio_perf_procfile_read(char *buffer, char **buffer_location, off_t offset,
3140 int buffer_length, int *eof, void *data)
3144 /* we are always called with buffer_length=4k, so we all
3145 deliver on the first read */
3149 #define _OUTP_IT(x...) c+=sprintf(buffer+c,x)
3150 _OUTP_IT("i_p_nc/c=%lu/%lu\n",i_p_nc,i_p_c);
3151 _OUTP_IT("ii_p_nc/c=%lu/%lu\n",ii_p_nc,ii_p_c);
3152 _OUTP_IT("o_p_nc/c=%lu/%lu\n",o_p_nc,o_p_c);
3153 _OUTP_IT("Number of tasklet runs (total) : %u\n",
3154 perf_stats.tl_runs);
3156 _OUTP_IT("Number of SIGA sync's issued : %u\n",
3157 perf_stats.siga_syncs);
3158 _OUTP_IT("Number of SIGA in's issued : %u\n",
3159 perf_stats.siga_ins);
3160 _OUTP_IT("Number of SIGA out's issued : %u\n",
3161 perf_stats.siga_outs);
3162 _OUTP_IT("Number of PCIs caught : %u\n",
3164 _OUTP_IT("Number of adapter interrupts caught : %u\n",
3165 perf_stats.thinints);
3166 _OUTP_IT("Number of fast requeues (outg. SBALs w/o SIGA) : %u\n",
3167 perf_stats.fast_reqs);
3169 _OUTP_IT("Total time of all inbound actions (us) incl. UL : %u\n",
3170 perf_stats.inbound_time);
3171 _OUTP_IT("Number of inbound transfers : %u\n",
3172 perf_stats.inbound_cnt);
3173 _OUTP_IT("Total time of all outbound do_QDIOs (us) : %u\n",
3174 perf_stats.outbound_time);
3175 _OUTP_IT("Number of do_QDIOs outbound : %u\n",
3176 perf_stats.outbound_cnt);
3182 static struct proc_dir_entry *qdio_perf_proc_file;
3183 #endif /* QDIO_PERFORMANCE_STATS */
3186 qdio_add_procfs_entry(void)
3188 #ifdef QDIO_PERFORMANCE_STATS
3189 proc_perf_file_registration=0;
3190 qdio_perf_proc_file=create_proc_entry(QDIO_PERF,
3191 S_IFREG|0444,&proc_root);
3192 if (qdio_perf_proc_file) {
3193 qdio_perf_proc_file->read_proc=&qdio_perf_procfile_read;
3194 } else proc_perf_file_registration=-1;
3196 if (proc_perf_file_registration)
3197 QDIO_PRINT_WARN("was not able to register perf. " \
3198 "proc-file (%i).\n",
3199 proc_perf_file_registration);
3200 #endif /* QDIO_PERFORMANCE_STATS */
3204 qdio_remove_procfs_entry(void)
3206 #ifdef QDIO_PERFORMANCE_STATS
3207 perf_stats.tl_runs=0;
3209 if (!proc_perf_file_registration) /* means if it went ok earlier */
3210 remove_proc_entry(QDIO_PERF,&proc_root);
3211 #endif /* QDIO_PERFORMANCE_STATS */
3215 tiqdio_register_thinints(void)
3218 register_thinint_result=
3219 s390_register_adapter_interrupt(&tiqdio_thinint_handler);
3220 if (register_thinint_result) {
3221 sprintf(dbf_text,"regthn%x",(register_thinint_result&0xff));
3222 QDIO_DBF_TEXT0(0,setup,dbf_text);
3223 QDIO_PRINT_ERR("failed to register adapter handler " \
3224 "(rc=%i).\nAdapter interrupts might " \
3225 "not work. Continuing.\n",
3226 register_thinint_result);
3231 tiqdio_unregister_thinints(void)
3233 if (!register_thinint_result)
3234 s390_unregister_adapter_interrupt(&tiqdio_thinint_handler);
3238 qdio_get_qdio_memory(void)
3241 indicator_used[0]=1;
3243 for (i=1;i<INDICATORS_PER_CACHELINE;i++)
3244 indicator_used[i]=0;
3245 indicators=(__u32*)kmalloc(sizeof(__u32)*(INDICATORS_PER_CACHELINE),
3247 if (!indicators) return -ENOMEM;
3248 memset(indicators,0,sizeof(__u32)*(INDICATORS_PER_CACHELINE));
3253 qdio_release_qdio_memory(void)
3260 qdio_unregister_dbf_views(void)
3263 debug_unregister(qdio_dbf_setup);
3265 debug_unregister(qdio_dbf_sbal);
3267 debug_unregister(qdio_dbf_sense);
3269 debug_unregister(qdio_dbf_trace);
3270 #ifdef QDIO_DBF_LIKE_HELL
3271 if (qdio_dbf_slsb_out)
3272 debug_unregister(qdio_dbf_slsb_out);
3273 if (qdio_dbf_slsb_in)
3274 debug_unregister(qdio_dbf_slsb_in);
3275 #endif /* QDIO_DBF_LIKE_HELL */
3279 qdio_register_dbf_views(void)
3281 qdio_dbf_setup=debug_register(QDIO_DBF_SETUP_NAME,
3282 QDIO_DBF_SETUP_INDEX,
3283 QDIO_DBF_SETUP_NR_AREAS,
3284 QDIO_DBF_SETUP_LEN);
3285 if (!qdio_dbf_setup)
3287 debug_register_view(qdio_dbf_setup,&debug_hex_ascii_view);
3288 debug_set_level(qdio_dbf_setup,QDIO_DBF_SETUP_LEVEL);
3290 qdio_dbf_sbal=debug_register(QDIO_DBF_SBAL_NAME,
3291 QDIO_DBF_SBAL_INDEX,
3292 QDIO_DBF_SBAL_NR_AREAS,
3297 debug_register_view(qdio_dbf_sbal,&debug_hex_ascii_view);
3298 debug_set_level(qdio_dbf_sbal,QDIO_DBF_SBAL_LEVEL);
3300 qdio_dbf_sense=debug_register(QDIO_DBF_SENSE_NAME,
3301 QDIO_DBF_SENSE_INDEX,
3302 QDIO_DBF_SENSE_NR_AREAS,
3303 QDIO_DBF_SENSE_LEN);
3304 if (!qdio_dbf_sense)
3307 debug_register_view(qdio_dbf_sense,&debug_hex_ascii_view);
3308 debug_set_level(qdio_dbf_sense,QDIO_DBF_SENSE_LEVEL);
3310 qdio_dbf_trace=debug_register(QDIO_DBF_TRACE_NAME,
3311 QDIO_DBF_TRACE_INDEX,
3312 QDIO_DBF_TRACE_NR_AREAS,
3313 QDIO_DBF_TRACE_LEN);
3314 if (!qdio_dbf_trace)
3317 debug_register_view(qdio_dbf_trace,&debug_hex_ascii_view);
3318 debug_set_level(qdio_dbf_trace,QDIO_DBF_TRACE_LEVEL);
3320 #ifdef QDIO_DBF_LIKE_HELL
3321 qdio_dbf_slsb_out=debug_register(QDIO_DBF_SLSB_OUT_NAME,
3322 QDIO_DBF_SLSB_OUT_INDEX,
3323 QDIO_DBF_SLSB_OUT_NR_AREAS,
3324 QDIO_DBF_SLSB_OUT_LEN);
3325 if (!qdio_dbf_slsb_out)
3327 debug_register_view(qdio_dbf_slsb_out,&debug_hex_ascii_view);
3328 debug_set_level(qdio_dbf_slsb_out,QDIO_DBF_SLSB_OUT_LEVEL);
3330 qdio_dbf_slsb_in=debug_register(QDIO_DBF_SLSB_IN_NAME,
3331 QDIO_DBF_SLSB_IN_INDEX,
3332 QDIO_DBF_SLSB_IN_NR_AREAS,
3333 QDIO_DBF_SLSB_IN_LEN);
3334 if (!qdio_dbf_slsb_in)
3336 debug_register_view(qdio_dbf_slsb_in,&debug_hex_ascii_view);
3337 debug_set_level(qdio_dbf_slsb_in,QDIO_DBF_SLSB_IN_LEVEL);
3338 #endif /* QDIO_DBF_LIKE_HELL */
3341 QDIO_PRINT_ERR("not enough memory for dbf.\n");
3342 qdio_unregister_dbf_views();
3350 #ifdef QDIO_PERFORMANCE_STATS
3352 #endif /* QDIO_PERFORMANCE_STATS */
3354 printk("qdio: loading %s\n",version);
3356 res=qdio_get_qdio_memory();
3360 res = qdio_register_dbf_views();
3364 QDIO_DBF_TEXT0(0,setup,"initQDIO");
3366 #ifdef QDIO_PERFORMANCE_STATS
3367 memset((void*)&perf_stats,0,sizeof(perf_stats));
3368 QDIO_DBF_TEXT0(0,setup,"perfstat");
3370 QDIO_DBF_HEX0(0,setup,&ptr,sizeof(void*));
3371 #endif /* QDIO_PERFORMANCE_STATS */
3373 qdio_add_procfs_entry();
3375 if (tiqdio_check_chsc_availability())
3376 QDIO_PRINT_ERR("Not all CHSCs supported. Continuing.\n");
3378 tiqdio_register_thinints();
3386 tiqdio_unregister_thinints();
3387 qdio_remove_procfs_entry();
3388 qdio_release_qdio_memory();
3389 qdio_unregister_dbf_views();
3391 printk("qdio: %s: module removed\n",version);
3394 module_init(init_QDIO);
3395 module_exit(cleanup_QDIO);
3397 EXPORT_SYMBOL(qdio_allocate);
3398 EXPORT_SYMBOL(qdio_establish);
3399 EXPORT_SYMBOL(qdio_initialize);
3400 EXPORT_SYMBOL(qdio_activate);
3401 EXPORT_SYMBOL(do_QDIO);
3402 EXPORT_SYMBOL(qdio_shutdown);
3403 EXPORT_SYMBOL(qdio_free);
3404 EXPORT_SYMBOL(qdio_cleanup);
3405 EXPORT_SYMBOL(qdio_synchronize);