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.80 $"
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, so q->polling was 0
360 if (q->slsb.acc.val[gsf]!=SLSB_P_INPUT_PRIMED)
363 * set our summary bit again, as otherwise there is a
364 * small window we can miss between resetting it and
365 * checking for PRIMED state
368 tiqdio_set_summary_bit((__u32*)q->dev_st_chg_ind);
371 #else /* QDIO_USE_PROCESSING_STATE */
373 #endif /* QDIO_USE_PROCESSING_STATE */
377 * see the comment in do_QDIO and before qdio_reserve_q about the
378 * sophisticated locking outside of unmark_q, so that we don't need to
379 * disable the interrupts :-)
382 qdio_unmark_q(struct qdio_q *q)
386 QDIO_DBF_TEXT4(0,trace,"unmark q");
387 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
389 if ((!q->list_prev)||(!q->list_next))
392 if ((q->is_thinint_q)&&(q->is_input_q)) {
394 spin_lock_irqsave(&ttiq_list_lock,flags);
395 /* in case cleanup has done this already and simultanously
396 * qdio_unmark_q is called from the interrupt handler, we've
397 * got to check this in this specific case again */
398 if ((!q->list_prev)||(!q->list_next))
400 if (q->list_next==q) {
401 /* q was the only interesting q */
406 q->list_next->list_prev=q->list_prev;
407 q->list_prev->list_next=q->list_next;
408 tiq_list=q->list_next;
413 spin_unlock_irqrestore(&ttiq_list_lock,flags);
417 static inline unsigned long
418 tiqdio_clear_global_summary(void)
422 QDIO_DBF_TEXT5(0,trace,"clrglobl");
424 time = do_clear_global_summary();
426 QDIO_DBF_HEX5(0,trace,&time,sizeof(unsigned long));
432 /************************* OUTBOUND ROUTINES *******************************/
435 qdio_get_outbound_buffer_frontier(struct qdio_q *q)
439 int first_not_to_check;
442 QDIO_DBF_TEXT4(0,trace,"getobfro");
443 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
445 slsb=&q->slsb.acc.val[0];
446 f_mod_no=f=q->first_to_check;
448 * f points to already processed elements, so f+no_used is correct...
449 * ... but: we don't check 128 buffers, as otherwise
450 * qdio_has_outbound_q_moved would return 0
452 first_not_to_check=f+qdio_min(atomic_read(&q->number_of_buffers_used),
453 (QDIO_MAX_BUFFERS_PER_Q-1));
455 if ((!q->is_iqdio_q)&&(!q->hydra_gives_outbound_pcis))
459 if (f==first_not_to_check)
462 switch(slsb[f_mod_no]) {
464 /* the adapter has not fetched the output yet */
465 case SLSB_CU_OUTPUT_PRIMED:
466 QDIO_DBF_TEXT5(0,trace,"outpprim");
469 /* the adapter got it */
470 case SLSB_P_OUTPUT_EMPTY:
471 atomic_dec(&q->number_of_buffers_used);
473 f_mod_no=f&(QDIO_MAX_BUFFERS_PER_Q-1);
474 QDIO_DBF_TEXT5(0,trace,"outpempt");
477 case SLSB_P_OUTPUT_ERROR:
478 QDIO_DBF_TEXT3(0,trace,"outperr");
479 sprintf(dbf_text,"%x-%x-%x",f_mod_no,
480 q->sbal[f_mod_no]->element[14].sbalf.value,
481 q->sbal[f_mod_no]->element[15].sbalf.value);
482 QDIO_DBF_TEXT3(1,trace,dbf_text);
483 QDIO_DBF_HEX2(1,sbal,q->sbal[f_mod_no],256);
485 /* kind of process the buffer */
486 set_slsb(&q->slsb.acc.val[f_mod_no], SLSB_P_OUTPUT_NOT_INIT);
489 * we increment the frontier, as this buffer
490 * was processed obviously
492 atomic_dec(&q->number_of_buffers_used);
493 f_mod_no=(f_mod_no+1)&(QDIO_MAX_BUFFERS_PER_Q-1);
496 q->error_status_flags|=
497 QDIO_STATUS_MORE_THAN_ONE_QDIO_ERROR;
498 q->qdio_error=SLSB_P_OUTPUT_ERROR;
499 q->error_status_flags|=QDIO_STATUS_LOOK_FOR_ERROR;
505 QDIO_DBF_TEXT5(0,trace,"outpni");
508 return (q->first_to_check=f_mod_no);
511 /* all buffers are processed */
513 qdio_is_outbound_q_done(struct qdio_q *q)
518 no_used=atomic_read(&q->number_of_buffers_used);
521 sprintf(dbf_text,"oqisnt%02x",no_used);
522 QDIO_DBF_TEXT4(0,trace,dbf_text);
524 QDIO_DBF_TEXT4(0,trace,"oqisdone");
526 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
531 qdio_has_outbound_q_moved(struct qdio_q *q)
535 i=qdio_get_outbound_buffer_frontier(q);
537 if ( (i!=GET_SAVED_FRONTIER(q)) ||
538 (q->error_status_flags&QDIO_STATUS_LOOK_FOR_ERROR) ) {
540 QDIO_DBF_TEXT4(0,trace,"oqhasmvd");
541 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
544 QDIO_DBF_TEXT4(0,trace,"oqhsntmv");
545 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
551 qdio_kick_outbound_q(struct qdio_q *q)
556 QDIO_DBF_TEXT4(0,trace,"kickoutq");
557 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
562 /* here's the story with cc=2 and busy bit set (thanks, Rick):
563 * VM's CP could present us cc=2 and busy bit set on SIGA-write
564 * during reconfiguration of their Guest LAN (only in HIPERS mode,
565 * QDIO mode is asynchronous -- cc=2 and busy bit there will take
566 * the queues down immediately; and not being under VM we have a
567 * problem on cc=2 and busy bit set right away).
569 * Therefore qdio_siga_output will try for a short time constantly,
570 * if such a condition occurs. If it doesn't change, it will
571 * increase the busy_siga_counter and save the timestamp, and
572 * schedule the queue for later processing (via mark_q, using the
573 * queue tasklet). __qdio_outbound_processing will check out the
574 * counter. If non-zero, it will call qdio_kick_outbound_q as often
575 * as the value of the counter. This will attempt further SIGA
576 * instructions. For each successful SIGA, the counter is
577 * decreased, for failing SIGAs the counter remains the same, after
579 * After some time of no movement, qdio_kick_outbound_q will
580 * finally fail and reflect corresponding error codes to call
581 * the upper layer module and have it take the queues down.
583 * Note that this is a change from the original HiperSockets design
584 * (saying cc=2 and busy bit means take the queues down), but in
585 * these days Guest LAN didn't exist... excessive cc=2 with busy bit
586 * conditions will still take the queues down, but the threshold is
587 * higher due to the Guest LAN environment.
591 result=qdio_siga_output(q);
595 /* went smooth this time, reset timestamp */
596 QDIO_DBF_TEXT3(0,trace,"cc2reslv");
597 sprintf(dbf_text,"%4x%2x%2x",q->irq,q->q_no,
598 atomic_read(&q->busy_siga_counter));
599 QDIO_DBF_TEXT3(0,trace,dbf_text);
600 q->timing.busy_start=0;
602 case (2|QDIO_SIGA_ERROR_B_BIT_SET):
603 /* cc=2 and busy bit: */
604 atomic_inc(&q->busy_siga_counter);
606 /* if the last siga was successful, save
608 if (!q->timing.busy_start)
609 q->timing.busy_start=NOW;
611 /* if we're in time, don't touch error_status_flags
613 if (NOW-q->timing.busy_start<QDIO_BUSY_BIT_GIVE_UP) {
617 QDIO_DBF_TEXT2(0,trace,"cc2REPRT");
618 sprintf(dbf_text,"%4x%2x%2x",q->irq,q->q_no,
619 atomic_read(&q->busy_siga_counter));
620 QDIO_DBF_TEXT3(0,trace,dbf_text);
621 /* else fallthrough and report error */
623 /* for plain cc=1, 2 or 3: */
625 q->error_status_flags|=
626 QDIO_STATUS_MORE_THAN_ONE_SIGA_ERROR;
627 q->error_status_flags|=
628 QDIO_STATUS_LOOK_FOR_ERROR;
629 q->siga_error=result;
634 qdio_kick_outbound_handler(struct qdio_q *q)
636 int start, end, real_end, count;
639 start = q->first_element_to_kick;
640 /* last_move_ftc was just updated */
641 real_end = GET_SAVED_FRONTIER(q);
642 end = (real_end+QDIO_MAX_BUFFERS_PER_Q-1)&
643 (QDIO_MAX_BUFFERS_PER_Q-1);
644 count = (end+QDIO_MAX_BUFFERS_PER_Q+1-start)&
645 (QDIO_MAX_BUFFERS_PER_Q-1);
647 QDIO_DBF_TEXT4(0,trace,"kickouth");
648 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
650 sprintf(dbf_text,"s=%2xc=%2x",start,count);
651 QDIO_DBF_TEXT4(0,trace,dbf_text);
653 if (q->state==QDIO_IRQ_STATE_ACTIVE)
654 q->handler(q->cdev,QDIO_STATUS_OUTBOUND_INT|
655 q->error_status_flags,
656 q->qdio_error,q->siga_error,q->q_no,start,count,
659 /* for the next time: */
660 q->first_element_to_kick=real_end;
663 q->error_status_flags=0;
667 __qdio_outbound_processing(struct qdio_q *q)
671 QDIO_DBF_TEXT4(0,trace,"qoutproc");
672 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
674 if (unlikely(qdio_reserve_q(q))) {
676 #ifdef QDIO_PERFORMANCE_STATS
678 #endif /* QDIO_PERFORMANCE_STATS */
679 /* as we're sissies, we'll check next time */
680 if (likely(!atomic_read(&q->is_in_shutdown))) {
682 QDIO_DBF_TEXT4(0,trace,"busy,agn");
686 #ifdef QDIO_PERFORMANCE_STATS
688 perf_stats.tl_runs++;
689 #endif /* QDIO_PERFORMANCE_STATS */
691 /* see comment in qdio_kick_outbound_q */
692 siga_attempts=atomic_read(&q->busy_siga_counter);
693 while (siga_attempts) {
694 atomic_dec(&q->busy_siga_counter);
695 qdio_kick_outbound_q(q);
699 if (qdio_has_outbound_q_moved(q))
700 qdio_kick_outbound_handler(q);
704 * for asynchronous queues, we better check, if the fill
705 * level is too high. for synchronous queues, the fill
706 * level will never be that high.
708 if (atomic_read(&q->number_of_buffers_used)>
709 IQDIO_FILL_LEVEL_TO_POLL)
712 } else if (!q->hydra_gives_outbound_pcis)
713 if (!qdio_is_outbound_q_done(q))
720 qdio_outbound_processing(struct qdio_q *q)
722 __qdio_outbound_processing(q);
725 /************************* INBOUND ROUTINES *******************************/
729 qdio_get_inbound_buffer_frontier(struct qdio_q *q)
733 int first_not_to_check;
736 QDIO_DBF_TEXT4(0,trace,"getibfro");
737 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
739 slsb=&q->slsb.acc.val[0];
740 f_mod_no=f=q->first_to_check;
742 * we don't check 128 buffers, as otherwise qdio_has_inbound_q_moved
745 first_not_to_check=f+qdio_min(atomic_read(&q->number_of_buffers_used),
746 (QDIO_MAX_BUFFERS_PER_Q-1));
749 * we don't use this one, as a PCI or we after a thin interrupt
750 * will sync the queues
755 f_mod_no=f&(QDIO_MAX_BUFFERS_PER_Q-1);
756 if (f==first_not_to_check)
758 switch (slsb[f_mod_no]) {
760 /* CU_EMPTY means frontier is reached */
761 case SLSB_CU_INPUT_EMPTY:
762 QDIO_DBF_TEXT5(0,trace,"inptempt");
765 /* P_PRIMED means set slsb to P_PROCESSING and move on */
766 case SLSB_P_INPUT_PRIMED:
767 QDIO_DBF_TEXT5(0,trace,"inptprim");
769 #ifdef QDIO_USE_PROCESSING_STATE
771 * as soon as running under VM, polling the input queues will
772 * kill VM in terms of CP overhead
775 set_slsb(&slsb[f_mod_no],SLSB_P_INPUT_NOT_INIT);
777 set_slsb(&slsb[f_mod_no],SLSB_P_INPUT_PROCESSING);
778 atomic_set(&q->polling,1);
780 #else /* QDIO_USE_PROCESSING_STATE */
781 set_slsb(&slsb[f_mod_no],SLSB_P_INPUT_NOT_INIT);
782 #endif /* QDIO_USE_PROCESSING_STATE */
784 * not needed, as the inbound queue will be synced on the next
789 atomic_dec(&q->number_of_buffers_used);
792 case SLSB_P_INPUT_NOT_INIT:
793 case SLSB_P_INPUT_PROCESSING:
794 QDIO_DBF_TEXT5(0,trace,"inpnipro");
797 /* P_ERROR means frontier is reached, break and report error */
798 case SLSB_P_INPUT_ERROR:
799 sprintf(dbf_text,"inperr%2x",f_mod_no);
800 QDIO_DBF_TEXT3(1,trace,dbf_text);
801 QDIO_DBF_HEX2(1,sbal,q->sbal[f_mod_no],256);
803 /* kind of process the buffer */
804 set_slsb(&slsb[f_mod_no],SLSB_P_INPUT_NOT_INIT);
807 q->error_status_flags|=
808 QDIO_STATUS_MORE_THAN_ONE_QDIO_ERROR;
809 q->qdio_error=SLSB_P_INPUT_ERROR;
810 q->error_status_flags|=QDIO_STATUS_LOOK_FOR_ERROR;
812 /* we increment the frontier, as this buffer
813 * was processed obviously */
814 f_mod_no=(f_mod_no+1)&(QDIO_MAX_BUFFERS_PER_Q-1);
815 atomic_dec(&q->number_of_buffers_used);
819 /* everything else means frontier not changed (HALTED or so) */
824 q->first_to_check=f_mod_no;
826 QDIO_DBF_HEX4(0,trace,&q->first_to_check,sizeof(int));
828 return q->first_to_check;
832 qdio_has_inbound_q_moved(struct qdio_q *q)
836 #ifdef QDIO_PERFORMANCE_STATS
837 static int old_pcis=0;
838 static int old_thinints=0;
840 if ((old_pcis==perf_stats.pcis)&&(old_thinints==perf_stats.thinints))
841 perf_stats.start_time_inbound=NOW;
843 old_pcis=perf_stats.pcis;
844 #endif /* QDIO_PERFORMANCE_STATS */
846 i=qdio_get_inbound_buffer_frontier(q);
847 if ( (i!=GET_SAVED_FRONTIER(q)) ||
848 (q->error_status_flags&QDIO_STATUS_LOOK_FOR_ERROR) ) {
850 if ((!q->siga_sync)&&(!q->hydra_gives_outbound_pcis))
853 QDIO_DBF_TEXT4(0,trace,"inhasmvd");
854 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
857 QDIO_DBF_TEXT4(0,trace,"inhsntmv");
858 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
863 /* means, no more buffers to be filled */
865 iqdio_is_inbound_q_done(struct qdio_q *q)
870 no_used=atomic_read(&q->number_of_buffers_used);
872 /* propagate the change from 82 to 80 through VM */
876 sprintf(dbf_text,"iqisnt%02x",no_used);
877 QDIO_DBF_TEXT4(0,trace,dbf_text);
879 QDIO_DBF_TEXT4(0,trace,"iniqisdo");
881 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
887 /* we'll check for more primed buffers in qeth_stop_polling */
890 if (q->slsb.acc.val[q->first_to_check]!=SLSB_P_INPUT_PRIMED)
892 * nothing more to do, if next buffer is not PRIMED.
893 * note that we did a SYNC_MEMORY before, that there
894 * has been a sychnronization.
895 * we will return 0 below, as there is nothing to do
896 * (stop_polling not necessary, as we have not been
897 * using the PROCESSING state
902 * ok, the next input buffer is primed. that means, that device state
903 * change indicator and adapter local summary are set, so we will find
905 * we will return 0 below, as there is nothing to do, except scheduling
906 * ourselves for the next time.
908 tiqdio_set_summary_bit((__u32*)q->dev_st_chg_ind);
914 qdio_is_inbound_q_done(struct qdio_q *q)
919 no_used=atomic_read(&q->number_of_buffers_used);
922 * we need that one for synchronization with the adapter, as it
923 * does a kind of PCI avoidance
928 QDIO_DBF_TEXT4(0,trace,"inqisdnA");
929 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
930 QDIO_DBF_TEXT4(0,trace,dbf_text);
934 if (q->slsb.acc.val[q->first_to_check]==SLSB_P_INPUT_PRIMED) {
935 /* we got something to do */
936 QDIO_DBF_TEXT4(0,trace,"inqisntA");
937 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
941 /* on VM, we don't poll, so the q is always done here */
944 if (q->hydra_gives_outbound_pcis)
948 * at this point we know, that inbound first_to_check
949 * has (probably) not moved (see qdio_inbound_processing)
951 if (NOW>GET_SAVED_TIMESTAMP(q)+q->timing.threshold) {
952 QDIO_DBF_TEXT4(0,trace,"inqisdon");
953 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
954 sprintf(dbf_text,"pf%02xcn%02x",q->first_to_check,no_used);
955 QDIO_DBF_TEXT4(0,trace,dbf_text);
958 QDIO_DBF_TEXT4(0,trace,"inqisntd");
959 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
960 sprintf(dbf_text,"pf%02xcn%02x",q->first_to_check,no_used);
961 QDIO_DBF_TEXT4(0,trace,dbf_text);
967 qdio_kick_inbound_handler(struct qdio_q *q)
969 int count, start, end, real_end, i;
972 QDIO_DBF_TEXT4(0,trace,"kickinh");
973 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
975 start=q->first_element_to_kick;
976 real_end=q->first_to_check;
977 end=(real_end+QDIO_MAX_BUFFERS_PER_Q-1)&(QDIO_MAX_BUFFERS_PER_Q-1);
985 i=(i+1)&(QDIO_MAX_BUFFERS_PER_Q-1);
988 sprintf(dbf_text,"s=%2xc=%2x",start,count);
989 QDIO_DBF_TEXT4(0,trace,dbf_text);
991 if (likely(q->state==QDIO_IRQ_STATE_ACTIVE))
993 QDIO_STATUS_INBOUND_INT|q->error_status_flags,
994 q->qdio_error,q->siga_error,q->q_no,start,count,
997 /* for the next time: */
998 q->first_element_to_kick=real_end;
1001 q->error_status_flags=0;
1003 #ifdef QDIO_PERFORMANCE_STATS
1004 perf_stats.inbound_time+=NOW-perf_stats.start_time_inbound;
1005 perf_stats.inbound_cnt++;
1006 #endif /* QDIO_PERFORMANCE_STATS */
1010 __tiqdio_inbound_processing(struct qdio_q *q, int spare_ind_was_set)
1012 struct qdio_irq *irq_ptr;
1016 QDIO_DBF_TEXT4(0,trace,"iqinproc");
1017 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
1020 * we first want to reserve the q, so that we know, that we don't
1021 * interrupt ourselves and call qdio_unmark_q, as is_in_shutdown might
1024 if (unlikely(qdio_reserve_q(q))) {
1026 #ifdef QDIO_PERFORMANCE_STATS
1028 #endif /* QDIO_PERFORMANCE_STATS */
1030 * as we might just be about to stop polling, we make
1031 * sure that we check again at least once more
1036 #ifdef QDIO_PERFORMANCE_STATS
1038 #endif /* QDIO_PERFORMANCE_STATS */
1039 if (unlikely(atomic_read(&q->is_in_shutdown))) {
1045 * we reset spare_ind_was_set, when the queue does not use the
1048 if (spare_ind_was_set)
1049 spare_ind_was_set = (q->dev_st_chg_ind == &spare_indicator);
1051 if (!(*(q->dev_st_chg_ind)) && !spare_ind_was_set)
1054 * q->dev_st_chg_ind is the indicator, be it shared or not.
1055 * only clear it, if indicator is non-shared
1057 if (!spare_ind_was_set)
1058 tiqdio_clear_summary_bit((__u32*)q->dev_st_chg_ind);
1060 if (q->hydra_gives_outbound_pcis) {
1061 if (!q->siga_sync_done_on_thinints) {
1063 } else if ((!q->siga_sync_done_on_outb_tis)&&
1064 (q->hydra_gives_outbound_pcis)) {
1065 SYNC_MEMORY_ALL_OUTB;
1071 * maybe we have to do work on our outbound queues... at least
1072 * we have to check the outbound-int-capable thinint-capable
1075 if (q->hydra_gives_outbound_pcis) {
1076 irq_ptr = (struct qdio_irq*)q->irq_ptr;
1077 for (i=0;i<irq_ptr->no_output_qs;i++) {
1078 oq = irq_ptr->output_qs[i];
1079 #ifdef QDIO_PERFORMANCE_STATS
1080 perf_stats.tl_runs--;
1081 #endif /* QDIO_PERFORMANCE_STATS */
1082 if (!qdio_is_outbound_q_done(oq))
1083 __qdio_outbound_processing(oq);
1087 if (!qdio_has_inbound_q_moved(q))
1090 qdio_kick_inbound_handler(q);
1091 if (iqdio_is_inbound_q_done(q))
1092 if (!qdio_stop_polling(q)) {
1094 * we set the flags to get into the stuff next time,
1095 * see also comment in qdio_stop_polling
1097 tiqdio_set_summary_bit((__u32*)q->dev_st_chg_ind);
1105 tiqdio_inbound_processing(struct qdio_q *q)
1107 __tiqdio_inbound_processing(q, atomic_read(&spare_indicator_usecount));
1111 __qdio_inbound_processing(struct qdio_q *q)
1115 QDIO_DBF_TEXT4(0,trace,"qinproc");
1116 QDIO_DBF_HEX4(0,trace,&q,sizeof(void*));
1118 if (unlikely(qdio_reserve_q(q))) {
1120 #ifdef QDIO_PERFORMANCE_STATS
1122 #endif /* QDIO_PERFORMANCE_STATS */
1123 /* as we're sissies, we'll check next time */
1124 if (likely(!atomic_read(&q->is_in_shutdown))) {
1126 QDIO_DBF_TEXT4(0,trace,"busy,agn");
1130 #ifdef QDIO_PERFORMANCE_STATS
1132 perf_stats.tl_runs++;
1133 #endif /* QDIO_PERFORMANCE_STATS */
1136 if (qdio_has_inbound_q_moved(q)) {
1137 qdio_kick_inbound_handler(q);
1138 if (!qdio_stop_polling(q)) {
1140 if (q_laps<QDIO_Q_LAPS)
1145 if (!qdio_is_inbound_q_done(q))
1146 /* means poll time is not yet over */
1154 qdio_inbound_processing(struct qdio_q *q)
1156 __qdio_inbound_processing(q);
1159 /************************* MAIN ROUTINES *******************************/
1161 #ifdef QDIO_USE_PROCESSING_STATE
1163 tiqdio_do_inbound_checks(struct qdio_q *q, int q_laps)
1171 * under VM, we have not used the PROCESSING state, so no
1172 * need to stop polling
1177 if (unlikely(qdio_reserve_q(q))) {
1179 #ifdef QDIO_PERFORMANCE_STATS
1181 #endif /* QDIO_PERFORMANCE_STATS */
1183 * as we might just be about to stop polling, we make
1184 * sure that we check again at least once more
1188 * sanity -- we'd get here without setting the
1191 tiqdio_set_summary_bit((__u32*)q->dev_st_chg_ind);
1195 if (qdio_stop_polling(q)) {
1199 if (q_laps<QDIO_Q_LAPS-1) {
1204 * we set the flags to get into the stuff
1205 * next time, see also comment in qdio_stop_polling
1207 tiqdio_set_summary_bit((__u32*)q->dev_st_chg_ind);
1213 #endif /* QDIO_USE_PROCESSING_STATE */
1216 tiqdio_inbound_checks(void)
1219 int spare_ind_was_set=0;
1220 #ifdef QDIO_USE_PROCESSING_STATE
1222 #endif /* QDIO_USE_PROCESSING_STATE */
1224 QDIO_DBF_TEXT4(0,trace,"iqdinbck");
1225 QDIO_DBF_TEXT5(0,trace,"iqlocsum");
1227 #ifdef QDIO_USE_PROCESSING_STATE
1229 #endif /* QDIO_USE_PROCESSING_STATE */
1231 /* when the spare indicator is used and set, save that and clear it */
1232 if ((atomic_read(&spare_indicator_usecount)) && spare_indicator) {
1233 spare_ind_was_set = 1;
1234 tiqdio_clear_summary_bit((__u32*)&spare_indicator);
1237 q=(struct qdio_q*)tiq_list;
1241 __tiqdio_inbound_processing(q, spare_ind_was_set);
1242 q=(struct qdio_q*)q->list_next;
1243 } while (q!=(struct qdio_q*)tiq_list);
1245 #ifdef QDIO_USE_PROCESSING_STATE
1246 q=(struct qdio_q*)tiq_list;
1250 ret = tiqdio_do_inbound_checks(q, q_laps);
1257 q = (struct qdio_q*)q->list_next;
1263 } while (q!=(struct qdio_q*)tiq_list);
1264 #endif /* QDIO_USE_PROCESSING_STATE */
1268 tiqdio_tl(unsigned long data)
1270 QDIO_DBF_TEXT4(0,trace,"iqdio_tl");
1272 #ifdef QDIO_PERFORMANCE_STATS
1273 perf_stats.tl_runs++;
1274 #endif /* QDIO_PERFORMANCE_STATS */
1276 tiqdio_inbound_checks();
1279 /********************* GENERAL HELPER_ROUTINES ***********************/
1282 qdio_release_irq_memory(struct qdio_irq *irq_ptr)
1286 for (i=0;i<QDIO_MAX_QUEUES_PER_IRQ;i++) {
1287 if (!irq_ptr->input_qs[i])
1290 if (irq_ptr->input_qs[i]->slib)
1291 kfree(irq_ptr->input_qs[i]->slib);
1292 kfree(irq_ptr->input_qs[i]);
1295 if (!irq_ptr->output_qs[i])
1298 if (irq_ptr->output_qs[i]->slib)
1299 kfree(irq_ptr->output_qs[i]->slib);
1300 kfree(irq_ptr->output_qs[i]);
1303 kfree(irq_ptr->qdr);
1304 kfree(irq_ptr->actual_alloc); /* This frees irq_ptr itself. */
1308 qdio_set_impl_params(struct qdio_irq *irq_ptr,
1309 unsigned int qib_param_field_format,
1310 /* pointer to 128 bytes or NULL, if no param field */
1311 unsigned char *qib_param_field,
1312 /* pointer to no_queues*128 words of data or NULL */
1313 unsigned int no_input_qs,
1314 unsigned int no_output_qs,
1315 unsigned long *input_slib_elements,
1316 unsigned long *output_slib_elements)
1323 irq_ptr->qib.pfmt=qib_param_field_format;
1324 if (qib_param_field)
1325 memcpy(irq_ptr->qib.parm,qib_param_field,
1326 QDIO_MAX_BUFFERS_PER_Q);
1328 if (input_slib_elements)
1329 for (i=0;i<no_input_qs;i++) {
1330 for (j=0;j<QDIO_MAX_BUFFERS_PER_Q;j++)
1331 irq_ptr->input_qs[i]->slib->slibe[j].parms=
1332 input_slib_elements[
1333 i*QDIO_MAX_BUFFERS_PER_Q+j];
1335 if (output_slib_elements)
1336 for (i=0;i<no_output_qs;i++) {
1337 for (j=0;j<QDIO_MAX_BUFFERS_PER_Q;j++)
1338 irq_ptr->output_qs[i]->slib->slibe[j].parms=
1339 output_slib_elements[
1340 i*QDIO_MAX_BUFFERS_PER_Q+j];
1345 qdio_alloc_qs(struct qdio_irq *irq_ptr,
1346 int no_input_qs, int no_output_qs)
1352 for (i=0;i<no_input_qs;i++) {
1353 q=kmalloc(sizeof(struct qdio_q),GFP_KERNEL);
1356 QDIO_PRINT_ERR("kmalloc of q failed!\n");
1360 memset(q,0,sizeof(struct qdio_q));
1362 q->slib=kmalloc(PAGE_SIZE,GFP_KERNEL);
1364 QDIO_PRINT_ERR("kmalloc of slib failed!\n");
1368 irq_ptr->input_qs[i]=q;
1371 for (i=0;i<no_output_qs;i++) {
1372 q=kmalloc(sizeof(struct qdio_q),GFP_KERNEL);
1378 memset(q,0,sizeof(struct qdio_q));
1380 q->slib=kmalloc(PAGE_SIZE,GFP_KERNEL);
1382 QDIO_PRINT_ERR("kmalloc of slib failed!\n");
1386 irq_ptr->output_qs[i]=q;
1395 qdio_fill_qs(struct qdio_irq *irq_ptr, struct ccw_device *cdev,
1396 int no_input_qs, int no_output_qs,
1397 qdio_handler_t *input_handler,
1398 qdio_handler_t *output_handler,
1399 unsigned long int_parm,int q_format,
1400 unsigned long flags,
1401 void **inbound_sbals_array,
1402 void **outbound_sbals_array)
1406 char dbf_text[20]; /* see qdio_initialize */
1410 sprintf(dbf_text,"qfqs%4x",cdev->private->irq);
1411 QDIO_DBF_TEXT0(0,setup,dbf_text);
1412 for (i=0;i<no_input_qs;i++) {
1413 q=irq_ptr->input_qs[i];
1415 memset(q,0,((char*)&q->slib)-((char*)q));
1416 sprintf(dbf_text,"in-q%4x",i);
1417 QDIO_DBF_TEXT0(0,setup,dbf_text);
1418 QDIO_DBF_HEX0(0,setup,&q,sizeof(void*));
1420 memset(q->slib,0,PAGE_SIZE);
1421 q->sl=(struct sl*)(((char*)q->slib)+PAGE_SIZE/2);
1425 for (j=0;j<QDIO_MAX_BUFFERS_PER_Q;j++)
1426 q->sbal[j]=*(inbound_sbals_array++);
1428 q->queue_type=q_format;
1429 q->int_parm=int_parm;
1430 q->irq=irq_ptr->irq;
1431 q->irq_ptr = irq_ptr;
1436 q->first_to_check=0;
1438 q->handler=input_handler;
1439 q->dev_st_chg_ind=irq_ptr->dev_st_chg_ind;
1441 q->tasklet.data=(unsigned long)q;
1442 /* q->is_thinint_q isn't valid at this time, but
1443 * irq_ptr->is_thinint_irq is */
1444 q->tasklet.func=(void(*)(unsigned long))
1445 ((irq_ptr->is_thinint_irq)?&tiqdio_inbound_processing:
1446 &qdio_inbound_processing);
1448 /* actually this is not used for inbound queues. yet. */
1449 atomic_set(&q->busy_siga_counter,0);
1450 q->timing.busy_start=0;
1452 /* for (j=0;j<QDIO_STATS_NUMBER;j++)
1453 q->timing.last_transfer_times[j]=(qdio_get_micros()/
1454 QDIO_STATS_NUMBER)*j;
1455 q->timing.last_transfer_index=QDIO_STATS_NUMBER-1;
1459 if (i>0) irq_ptr->input_qs[i-1]->slib->nsliba=
1460 (unsigned long)(q->slib);
1461 q->slib->sla=(unsigned long)(q->sl);
1462 q->slib->slsba=(unsigned long)(&q->slsb.acc.val[0]);
1465 for (j=0;j<QDIO_MAX_BUFFERS_PER_Q;j++)
1466 q->sl->element[j].sbal=(unsigned long)(q->sbal[j]);
1468 QDIO_DBF_TEXT2(0,setup,"sl-sb-b0");
1470 QDIO_DBF_HEX2(0,setup,&ptr,sizeof(void*));
1471 ptr=(void*)&q->slsb;
1472 QDIO_DBF_HEX2(0,setup,&ptr,sizeof(void*));
1473 ptr=(void*)q->sbal[0];
1474 QDIO_DBF_HEX2(0,setup,&ptr,sizeof(void*));
1477 for (j=0;j<QDIO_MAX_BUFFERS_PER_Q;j++) {
1478 set_slsb(&q->slsb.acc.val[j],
1479 SLSB_P_INPUT_NOT_INIT);
1480 /* q->sbal[j]->element[1].sbalf.i1.key=QDIO_STORAGE_KEY;*/
1484 for (i=0;i<no_output_qs;i++) {
1485 q=irq_ptr->output_qs[i];
1486 memset(q,0,((char*)&q->slib)-((char*)q));
1488 sprintf(dbf_text,"outq%4x",i);
1489 QDIO_DBF_TEXT0(0,setup,dbf_text);
1490 QDIO_DBF_HEX0(0,setup,&q,sizeof(void*));
1492 memset(q->slib,0,PAGE_SIZE);
1493 q->sl=(struct sl*)(((char*)q->slib)+PAGE_SIZE/2);
1497 for (j=0;j<QDIO_MAX_BUFFERS_PER_Q;j++)
1498 q->sbal[j]=*(outbound_sbals_array++);
1500 q->queue_type=q_format;
1501 q->int_parm=int_parm;
1503 q->irq=irq_ptr->irq;
1505 q->irq_ptr = irq_ptr;
1508 q->first_to_check=0;
1510 q->handler=output_handler;
1512 q->tasklet.data=(unsigned long)q;
1513 q->tasklet.func=(void(*)(unsigned long))
1514 &qdio_outbound_processing;
1516 atomic_set(&q->busy_siga_counter,0);
1517 q->timing.busy_start=0;
1520 if (i>0) irq_ptr->output_qs[i-1]->slib->nsliba=
1521 (unsigned long)(q->slib);
1522 q->slib->sla=(unsigned long)(q->sl);
1523 q->slib->slsba=(unsigned long)(&q->slsb.acc.val[0]);
1526 for (j=0;j<QDIO_MAX_BUFFERS_PER_Q;j++)
1527 q->sl->element[j].sbal=(unsigned long)(q->sbal[j]);
1529 QDIO_DBF_TEXT2(0,setup,"sl-sb-b0");
1531 QDIO_DBF_HEX2(0,setup,&ptr,sizeof(void*));
1532 ptr=(void*)&q->slsb;
1533 QDIO_DBF_HEX2(0,setup,&ptr,sizeof(void*));
1534 ptr=(void*)q->sbal[0];
1535 QDIO_DBF_HEX2(0,setup,&ptr,sizeof(void*));
1538 for (j=0;j<QDIO_MAX_BUFFERS_PER_Q;j++) {
1539 set_slsb(&q->slsb.acc.val[j],
1540 SLSB_P_OUTPUT_NOT_INIT);
1541 /* q->sbal[j]->element[1].sbalf.i1.key=QDIO_STORAGE_KEY;*/
1547 qdio_fill_thresholds(struct qdio_irq *irq_ptr,
1548 unsigned int no_input_qs,
1549 unsigned int no_output_qs,
1550 unsigned int min_input_threshold,
1551 unsigned int max_input_threshold,
1552 unsigned int min_output_threshold,
1553 unsigned int max_output_threshold)
1558 for (i=0;i<no_input_qs;i++) {
1559 q=irq_ptr->input_qs[i];
1560 q->timing.threshold=max_input_threshold;
1561 /* for (j=0;j<QDIO_STATS_CLASSES;j++) {
1562 q->threshold_classes[j].threshold=
1563 min_input_threshold+
1564 (max_input_threshold-min_input_threshold)/
1567 qdio_use_thresholds(q,QDIO_STATS_CLASSES/2);*/
1569 for (i=0;i<no_output_qs;i++) {
1570 q=irq_ptr->output_qs[i];
1571 q->timing.threshold=max_output_threshold;
1572 /* for (j=0;j<QDIO_STATS_CLASSES;j++) {
1573 q->threshold_classes[j].threshold=
1574 min_output_threshold+
1575 (max_output_threshold-min_output_threshold)/
1578 qdio_use_thresholds(q,QDIO_STATS_CLASSES/2);*/
1583 tiqdio_thinint_handler(void)
1585 QDIO_DBF_TEXT4(0,trace,"thin_int");
1587 #ifdef QDIO_PERFORMANCE_STATS
1588 perf_stats.thinints++;
1589 perf_stats.start_time_inbound=NOW;
1590 #endif /* QDIO_PERFORMANCE_STATS */
1592 /* SVS only when needed:
1593 * issue SVS to benefit from iqdio interrupt avoidance
1594 * (SVS clears AISOI)*/
1596 tiqdio_clear_global_summary();
1598 tiqdio_inbound_checks();
1603 qdio_set_state(struct qdio_irq *irq_ptr, enum qdio_irq_states state)
1608 QDIO_DBF_TEXT5(0,trace,"newstate");
1609 sprintf(dbf_text,"%4x%4x",irq_ptr->irq,state);
1610 QDIO_DBF_TEXT5(0,trace,dbf_text);
1612 irq_ptr->state=state;
1613 for (i=0;i<irq_ptr->no_input_qs;i++)
1614 irq_ptr->input_qs[i]->state=state;
1615 for (i=0;i<irq_ptr->no_output_qs;i++)
1616 irq_ptr->output_qs[i]->state=state;
1621 qdio_irq_check_sense(int irq, struct irb *irb)
1625 if (irb->esw.esw0.erw.cons) {
1626 sprintf(dbf_text,"sens%4x",irq);
1627 QDIO_DBF_TEXT2(1,trace,dbf_text);
1628 QDIO_DBF_HEX0(0,sense,irb,QDIO_DBF_SENSE_LEN);
1630 QDIO_PRINT_WARN("sense data available on qdio channel.\n");
1631 HEXDUMP16(WARN,"irb: ",irb);
1632 HEXDUMP16(WARN,"sense data: ",irb->ecw);
1638 qdio_handle_pci(struct qdio_irq *irq_ptr)
1643 #ifdef QDIO_PERFORMANCE_STATS
1645 perf_stats.start_time_inbound=NOW;
1646 #endif /* QDIO_PERFORMANCE_STATS */
1647 for (i=0;i<irq_ptr->no_input_qs;i++) {
1648 q=irq_ptr->input_qs[i];
1649 if (q->is_input_q&QDIO_FLAG_NO_INPUT_INTERRUPT_CONTEXT)
1652 #ifdef QDIO_PERFORMANCE_STATS
1653 perf_stats.tl_runs--;
1654 #endif /* QDIO_PERFORMANCE_STATS */
1655 __qdio_inbound_processing(q);
1658 if (!irq_ptr->hydra_gives_outbound_pcis)
1660 for (i=0;i<irq_ptr->no_output_qs;i++) {
1661 q=irq_ptr->output_qs[i];
1662 #ifdef QDIO_PERFORMANCE_STATS
1663 perf_stats.tl_runs--;
1664 #endif /* QDIO_PERFORMANCE_STATS */
1665 if (qdio_is_outbound_q_done(q))
1667 if (!irq_ptr->sync_done_on_outb_pcis)
1669 __qdio_outbound_processing(q);
1673 static void qdio_establish_handle_irq(struct ccw_device*, int, int);
1676 qdio_handle_activate_check(struct ccw_device *cdev, unsigned long intparm,
1677 int cstat, int dstat)
1679 struct qdio_irq *irq_ptr;
1683 irq_ptr = cdev->private->qdio_data;
1685 QDIO_DBF_TEXT2(1, trace, "ick2");
1686 sprintf(dbf_text,"%s", cdev->dev.bus_id);
1687 QDIO_DBF_TEXT2(1,trace,dbf_text);
1688 QDIO_DBF_HEX2(0,trace,&intparm,sizeof(int));
1689 QDIO_DBF_HEX2(0,trace,&dstat,sizeof(int));
1690 QDIO_DBF_HEX2(0,trace,&cstat,sizeof(int));
1691 QDIO_PRINT_ERR("received check condition on activate " \
1692 "queues on device %s (cs=x%x, ds=x%x).\n",
1693 cdev->dev.bus_id, cstat, dstat);
1694 if (irq_ptr->no_input_qs) {
1695 q=irq_ptr->input_qs[0];
1696 } else if (irq_ptr->no_output_qs) {
1697 q=irq_ptr->output_qs[0];
1699 QDIO_PRINT_ERR("oops... no queue registered for device %s!?\n",
1701 goto omit_handler_call;
1703 q->handler(q->cdev,QDIO_STATUS_ACTIVATE_CHECK_CONDITION|
1704 QDIO_STATUS_LOOK_FOR_ERROR,
1705 0,0,0,-1,-1,q->int_parm);
1707 qdio_set_state(irq_ptr,QDIO_IRQ_STATE_STOPPED);
1712 qdio_call_shutdown(void *data)
1714 struct ccw_device *cdev;
1716 cdev = (struct ccw_device *)data;
1717 qdio_shutdown(cdev, QDIO_FLAG_CLEANUP_USING_CLEAR);
1718 put_device(&cdev->dev);
1722 qdio_timeout_handler(struct ccw_device *cdev)
1724 struct qdio_irq *irq_ptr;
1727 QDIO_DBF_TEXT2(0, trace, "qtoh");
1728 sprintf(dbf_text, "%s", cdev->dev.bus_id);
1729 QDIO_DBF_TEXT2(0, trace, dbf_text);
1731 irq_ptr = cdev->private->qdio_data;
1732 sprintf(dbf_text, "state:%d", irq_ptr->state);
1733 QDIO_DBF_TEXT2(0, trace, dbf_text);
1735 switch (irq_ptr->state) {
1736 case QDIO_IRQ_STATE_INACTIVE:
1737 QDIO_PRINT_ERR("establish queues on irq %04x: timed out\n",
1739 QDIO_DBF_TEXT2(1,setup,"eq:timeo");
1740 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_ERR);
1742 case QDIO_IRQ_STATE_CLEANUP:
1743 QDIO_PRINT_INFO("Did not get interrupt on cleanup, irq=0x%x.\n",
1745 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_ERR);
1747 case QDIO_IRQ_STATE_ESTABLISHED:
1748 case QDIO_IRQ_STATE_ACTIVE:
1749 /* I/O has been terminated by common I/O layer. */
1750 QDIO_PRINT_INFO("Queues on irq %04x killed by cio.\n",
1752 QDIO_DBF_TEXT2(1, trace, "cio:term");
1753 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_STOPPED);
1754 if (get_device(&cdev->dev)) {
1755 /* Can't call shutdown from interrupt context. */
1756 PREPARE_WORK(&cdev->private->kick_work,
1757 qdio_call_shutdown, (void *)cdev);
1758 queue_work(ccw_device_work, &cdev->private->kick_work);
1764 ccw_device_set_timeout(cdev, 0);
1765 wake_up(&cdev->private->wait_q);
1769 qdio_handler(struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
1771 struct qdio_irq *irq_ptr;
1775 QDIO_DBF_TEXT4(0, trace, "qint");
1776 sprintf(dbf_text, "%s", cdev->dev.bus_id);
1777 QDIO_DBF_TEXT4(0, trace, dbf_text);
1780 QDIO_PRINT_ERR("got unsolicited interrupt in qdio " \
1781 "handler, device %s\n", cdev->dev.bus_id);
1785 irq_ptr = cdev->private->qdio_data;
1787 QDIO_DBF_TEXT2(1, trace, "uint");
1788 sprintf(dbf_text,"%s", cdev->dev.bus_id);
1789 QDIO_DBF_TEXT2(1,trace,dbf_text);
1790 QDIO_PRINT_ERR("received interrupt on unused device %s!\n",
1796 /* Currently running i/o is in error. */
1797 switch (PTR_ERR(irb)) {
1799 QDIO_PRINT_ERR("i/o error on device %s\n",
1803 qdio_timeout_handler(cdev);
1806 QDIO_PRINT_ERR("unknown error state %ld on device %s\n",
1807 PTR_ERR(irb), cdev->dev.bus_id);
1812 qdio_irq_check_sense(irq_ptr->irq, irb);
1814 sprintf(dbf_text, "state:%d", irq_ptr->state);
1815 QDIO_DBF_TEXT4(0, trace, dbf_text);
1817 cstat = irb->scsw.cstat;
1818 dstat = irb->scsw.dstat;
1820 switch (irq_ptr->state) {
1821 case QDIO_IRQ_STATE_INACTIVE:
1822 qdio_establish_handle_irq(cdev, cstat, dstat);
1825 case QDIO_IRQ_STATE_CLEANUP:
1826 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_INACTIVE);
1829 case QDIO_IRQ_STATE_ESTABLISHED:
1830 case QDIO_IRQ_STATE_ACTIVE:
1831 if (cstat & SCHN_STAT_PCI) {
1832 qdio_handle_pci(irq_ptr);
1836 if ((cstat&~SCHN_STAT_PCI)||dstat) {
1837 qdio_handle_activate_check(cdev, intparm, cstat, dstat);
1841 QDIO_PRINT_ERR("got interrupt for queues in state %d on " \
1843 irq_ptr->state, cdev->dev.bus_id);
1845 wake_up(&cdev->private->wait_q);
1850 qdio_synchronize(struct ccw_device *cdev, unsigned int flags,
1851 unsigned int queue_number)
1855 struct qdio_irq *irq_ptr;
1856 char dbf_text[15]="SyncXXXX";
1859 irq_ptr = cdev->private->qdio_data;
1863 *((int*)(&dbf_text[4])) = irq_ptr->irq;
1864 QDIO_DBF_HEX4(0,trace,dbf_text,QDIO_DBF_TRACE_LEN);
1865 *((int*)(&dbf_text[0]))=flags;
1866 *((int*)(&dbf_text[4]))=queue_number;
1867 QDIO_DBF_HEX4(0,trace,dbf_text,QDIO_DBF_TRACE_LEN);
1869 if (flags&QDIO_FLAG_SYNC_INPUT) {
1870 q=irq_ptr->input_qs[queue_number];
1873 cc = do_siga_sync(q->irq, 0, q->mask);
1874 } else if (flags&QDIO_FLAG_SYNC_OUTPUT) {
1875 q=irq_ptr->output_qs[queue_number];
1878 cc = do_siga_sync(q->irq, q->mask, 0);
1884 QDIO_DBF_HEX3(0,trace,&ptr,sizeof(int));
1889 static unsigned char
1890 qdio_check_siga_needs(int sch)
1893 unsigned char qdioac;
1896 struct chsc_header request;
1902 struct chsc_header response;
1917 ssqd_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
1919 QDIO_PRINT_WARN("Could not get memory for chsc. Using all " \
1920 "SIGAs for sch x%x.\n", sch);
1921 return CHSC_FLAG_SIGA_INPUT_NECESSARY ||
1922 CHSC_FLAG_SIGA_OUTPUT_NECESSARY ||
1923 CHSC_FLAG_SIGA_SYNC_NECESSARY; /* all flags set */
1925 ssqd_area->request = (struct chsc_header) {
1930 ssqd_area->first_sch = sch;
1931 ssqd_area->last_sch = sch;
1933 result=chsc(ssqd_area);
1936 QDIO_PRINT_WARN("CHSC returned cc %i. Using all " \
1937 "SIGAs for sch x%x.\n",
1939 qdioac = CHSC_FLAG_SIGA_INPUT_NECESSARY ||
1940 CHSC_FLAG_SIGA_OUTPUT_NECESSARY ||
1941 CHSC_FLAG_SIGA_SYNC_NECESSARY; /* all flags set */
1945 if (ssqd_area->response.code != QDIO_CHSC_RESPONSE_CODE_OK) {
1946 QDIO_PRINT_WARN("response upon checking SIGA needs " \
1947 "is 0x%x. Using all SIGAs for sch x%x.\n",
1948 ssqd_area->response.code, sch);
1949 qdioac = CHSC_FLAG_SIGA_INPUT_NECESSARY ||
1950 CHSC_FLAG_SIGA_OUTPUT_NECESSARY ||
1951 CHSC_FLAG_SIGA_SYNC_NECESSARY; /* all flags set */
1954 if (!(ssqd_area->flags & CHSC_FLAG_QDIO_CAPABILITY) ||
1955 !(ssqd_area->flags & CHSC_FLAG_VALIDITY) ||
1956 (ssqd_area->sch != sch)) {
1957 QDIO_PRINT_WARN("huh? problems checking out sch x%x... " \
1958 "using all SIGAs.\n",sch);
1959 qdioac = CHSC_FLAG_SIGA_INPUT_NECESSARY |
1960 CHSC_FLAG_SIGA_OUTPUT_NECESSARY |
1961 CHSC_FLAG_SIGA_SYNC_NECESSARY; /* worst case */
1965 qdioac = ssqd_area->qdioac;
1967 free_page ((unsigned long) ssqd_area);
1972 tiqdio_check_chsc_availability(void)
1978 struct chsc_header request;
1982 struct chsc_header response;
1984 u32 general_char[510];
1988 scsc_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
1990 QDIO_PRINT_WARN("Was not able to determine available" \
1991 "CHSCs due to no memory.\n");
1995 scsc_area->request = (struct chsc_header) {
2000 result=chsc(scsc_area);
2002 QDIO_PRINT_WARN("Was not able to determine " \
2003 "available CHSCs, cc=%i.\n",
2009 if (scsc_area->response.code != 1) {
2010 QDIO_PRINT_WARN("Was not able to determine " \
2011 "available CHSCs.\n");
2015 /* Check for bit 41. */
2016 if ((scsc_area->general_char[1] & 0x00400000) != 0x00400000) {
2017 QDIO_PRINT_WARN("Adapter interruption facility not " \
2022 /* Check for bits 107 and 108. */
2023 if ((scsc_area->chsc_char[3] & 0x00180000) != 0x00180000) {
2024 QDIO_PRINT_WARN("Set Chan Subsys. Char. & Fast-CHSCs " \
2025 "not available.\n");
2030 /* Check for OSA/FCP thin interrupts (bit 67). */
2031 hydra_thinints = ((scsc_area->general_char[2] & 0x10000000)
2033 sprintf(dbf_text,"hydrati%1x", hydra_thinints);
2034 QDIO_DBF_TEXT0(0,setup,dbf_text);
2036 /* Check for aif time delay disablement fac (bit 56). If installed,
2037 * omit svs even under lpar (good point by rick again) */
2038 omit_svs = ((scsc_area->general_char[1] & 0x00000080)
2040 sprintf(dbf_text,"omitsvs%1x", omit_svs);
2041 QDIO_DBF_TEXT0(0,setup,dbf_text);
2043 free_page ((unsigned long) scsc_area);
2049 tiqdio_set_subchannel_ind(struct qdio_irq *irq_ptr, int reset_to_zero)
2051 unsigned long real_addr_local_summary_bit;
2052 unsigned long real_addr_dev_st_chg_ind;
2056 unsigned int resp_code;
2060 struct chsc_header request;
2065 u64 summary_indicator_addr;
2066 u64 subchannel_indicator_addr;
2073 u32 reserved6[1004];
2074 struct chsc_header response;
2078 if (!irq_ptr->is_thinint_irq)
2081 if (reset_to_zero) {
2082 real_addr_local_summary_bit=0;
2083 real_addr_dev_st_chg_ind=0;
2085 real_addr_local_summary_bit=
2086 virt_to_phys((volatile void *)indicators);
2087 real_addr_dev_st_chg_ind=
2088 virt_to_phys((volatile void *)irq_ptr->dev_st_chg_ind);
2091 scssc_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
2093 QDIO_PRINT_WARN("No memory for setting indicators on " \
2094 "subchannel x%x.\n", irq_ptr->irq);
2097 scssc_area->request = (struct chsc_header) {
2101 scssc_area->operation_code = 0;
2103 scssc_area->summary_indicator_addr = real_addr_local_summary_bit;
2104 scssc_area->subchannel_indicator_addr = real_addr_dev_st_chg_ind;
2105 scssc_area->ks = QDIO_STORAGE_KEY;
2106 scssc_area->kc = QDIO_STORAGE_KEY;
2107 scssc_area->isc = TIQDIO_THININT_ISC;
2108 scssc_area->subsystem_id = (1<<16) + irq_ptr->irq;
2110 result = chsc(scssc_area);
2112 QDIO_PRINT_WARN("could not set indicators on irq x%x, " \
2113 "cc=%i.\n",irq_ptr->irq,result);
2118 resp_code = scssc_area->response.code;
2119 if (resp_code!=QDIO_CHSC_RESPONSE_CODE_OK) {
2120 QDIO_PRINT_WARN("response upon setting indicators " \
2121 "is 0x%x.\n",resp_code);
2122 sprintf(dbf_text,"sidR%4x",resp_code);
2123 QDIO_DBF_TEXT1(0,trace,dbf_text);
2124 QDIO_DBF_TEXT1(0,setup,dbf_text);
2125 ptr=&scssc_area->response;
2126 QDIO_DBF_HEX2(1,setup,&ptr,QDIO_DBF_SETUP_LEN);
2131 QDIO_DBF_TEXT2(0,setup,"setscind");
2132 QDIO_DBF_HEX2(0,setup,&real_addr_local_summary_bit,
2133 sizeof(unsigned long));
2134 QDIO_DBF_HEX2(0,setup,&real_addr_dev_st_chg_ind,sizeof(unsigned long));
2137 free_page ((unsigned long) scssc_area);
2143 tiqdio_set_delay_target(struct qdio_irq *irq_ptr, unsigned long delay_target)
2145 unsigned int resp_code;
2151 struct chsc_header request;
2158 u32 reserved5[1009];
2159 struct chsc_header response;
2163 if (!irq_ptr->is_thinint_irq)
2166 scsscf_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
2168 QDIO_PRINT_WARN("No memory for setting delay target on " \
2169 "subchannel x%x.\n", irq_ptr->irq);
2172 scsscf_area->request = (struct chsc_header) {
2177 scsscf_area->delay_target = delay_target<<16;
2179 result=chsc(scsscf_area);
2181 QDIO_PRINT_WARN("could not set delay target on irq x%x, " \
2182 "cc=%i. Continuing.\n",irq_ptr->irq,result);
2187 resp_code = scsscf_area->response.code;
2188 if (resp_code!=QDIO_CHSC_RESPONSE_CODE_OK) {
2189 QDIO_PRINT_WARN("response upon setting delay target " \
2190 "is 0x%x. Continuing.\n",resp_code);
2191 sprintf(dbf_text,"sdtR%4x",resp_code);
2192 QDIO_DBF_TEXT1(0,trace,dbf_text);
2193 QDIO_DBF_TEXT1(0,setup,dbf_text);
2194 ptr=&scsscf_area->response;
2195 QDIO_DBF_HEX2(1,trace,&ptr,QDIO_DBF_TRACE_LEN);
2197 QDIO_DBF_TEXT2(0,trace,"delytrgt");
2198 QDIO_DBF_HEX2(0,trace,&delay_target,sizeof(unsigned long));
2199 result = 0; /* not critical */
2201 free_page ((unsigned long) scsscf_area);
2206 qdio_cleanup(struct ccw_device *cdev, int how)
2208 struct qdio_irq *irq_ptr;
2212 irq_ptr = cdev->private->qdio_data;
2216 sprintf(dbf_text,"qcln%4x",irq_ptr->irq);
2217 QDIO_DBF_TEXT1(0,trace,dbf_text);
2218 QDIO_DBF_TEXT0(0,setup,dbf_text);
2220 rc = qdio_shutdown(cdev, how);
2221 if ((rc == 0) || (rc == -EINPROGRESS))
2222 rc = qdio_free(cdev);
2227 qdio_shutdown(struct ccw_device *cdev, int how)
2229 struct qdio_irq *irq_ptr;
2233 unsigned long flags;
2237 irq_ptr = cdev->private->qdio_data;
2241 down(&irq_ptr->setting_up_sema);
2243 sprintf(dbf_text,"qsqs%4x",irq_ptr->irq);
2244 QDIO_DBF_TEXT1(0,trace,dbf_text);
2245 QDIO_DBF_TEXT0(0,setup,dbf_text);
2247 /* mark all qs as uninteresting */
2248 for (i=0;i<irq_ptr->no_input_qs;i++)
2249 atomic_set(&irq_ptr->input_qs[i]->is_in_shutdown,1);
2251 for (i=0;i<irq_ptr->no_output_qs;i++)
2252 atomic_set(&irq_ptr->output_qs[i]->is_in_shutdown,1);
2254 tasklet_kill(&tiqdio_tasklet);
2256 for (i=0;i<irq_ptr->no_input_qs;i++) {
2257 qdio_unmark_q(irq_ptr->input_qs[i]);
2258 tasklet_kill(&irq_ptr->input_qs[i]->tasklet);
2259 wait_event_interruptible_timeout(cdev->private->wait_q,
2260 !atomic_read(&irq_ptr->
2263 QDIO_NO_USE_COUNT_TIMEOUT);
2264 if (atomic_read(&irq_ptr->input_qs[i]->use_count))
2265 result=-EINPROGRESS;
2268 for (i=0;i<irq_ptr->no_output_qs;i++) {
2269 tasklet_kill(&irq_ptr->output_qs[i]->tasklet);
2270 wait_event_interruptible_timeout(cdev->private->wait_q,
2271 !atomic_read(&irq_ptr->
2274 QDIO_NO_USE_COUNT_TIMEOUT);
2275 if (atomic_read(&irq_ptr->output_qs[i]->use_count))
2276 result=-EINPROGRESS;
2279 /* cleanup subchannel */
2280 spin_lock_irqsave(get_ccwdev_lock(cdev),flags);
2281 if (how&QDIO_FLAG_CLEANUP_USING_CLEAR) {
2282 rc = ccw_device_clear(cdev, QDIO_DOING_CLEANUP);
2283 timeout=QDIO_CLEANUP_CLEAR_TIMEOUT;
2284 } else if (how&QDIO_FLAG_CLEANUP_USING_HALT) {
2285 rc = ccw_device_halt(cdev, QDIO_DOING_CLEANUP);
2286 timeout=QDIO_CLEANUP_HALT_TIMEOUT;
2287 } else { /* default behaviour */
2288 rc = ccw_device_halt(cdev, QDIO_DOING_CLEANUP);
2289 timeout=QDIO_CLEANUP_HALT_TIMEOUT;
2291 if (rc == -ENODEV) {
2292 /* No need to wait for device no longer present. */
2293 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_INACTIVE);
2294 spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
2295 } else if (rc == 0) {
2296 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_CLEANUP);
2297 ccw_device_set_timeout(cdev, timeout);
2298 spin_unlock_irqrestore(get_ccwdev_lock(cdev),flags);
2300 wait_event(cdev->private->wait_q,
2301 irq_ptr->state == QDIO_IRQ_STATE_INACTIVE ||
2302 irq_ptr->state == QDIO_IRQ_STATE_ERR);
2304 QDIO_PRINT_INFO("ccw_device_{halt,clear} returned %d for "
2305 "device %s\n", result, cdev->dev.bus_id);
2306 spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
2310 if (irq_ptr->is_thinint_irq) {
2311 qdio_put_indicator((__u32*)irq_ptr->dev_st_chg_ind);
2312 tiqdio_set_subchannel_ind(irq_ptr,1);
2313 /* reset adapter interrupt indicators */
2316 /* exchange int handlers, if necessary */
2317 if ((void*)cdev->handler == (void*)qdio_handler)
2318 cdev->handler=irq_ptr->original_int_handler;
2320 /* Ignore errors. */
2321 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_INACTIVE);
2322 ccw_device_set_timeout(cdev, 0);
2324 up(&irq_ptr->setting_up_sema);
2329 qdio_free(struct ccw_device *cdev)
2331 struct qdio_irq *irq_ptr;
2334 irq_ptr = cdev->private->qdio_data;
2338 down(&irq_ptr->setting_up_sema);
2340 sprintf(dbf_text,"qfqs%4x",irq_ptr->irq);
2341 QDIO_DBF_TEXT1(0,trace,dbf_text);
2342 QDIO_DBF_TEXT0(0,setup,dbf_text);
2344 cdev->private->qdio_data = 0;
2346 up(&irq_ptr->setting_up_sema);
2348 qdio_release_irq_memory(irq_ptr);
2349 module_put(THIS_MODULE);
2354 qdio_allocate_do_dbf(struct qdio_initialize *init_data)
2356 char dbf_text[20]; /* if a printf printed out more than 8 chars */
2358 sprintf(dbf_text,"qfmt:%x",init_data->q_format);
2359 QDIO_DBF_TEXT0(0,setup,dbf_text);
2360 QDIO_DBF_HEX0(0,setup,init_data->adapter_name,8);
2361 sprintf(dbf_text,"qpff%4x",init_data->qib_param_field_format);
2362 QDIO_DBF_TEXT0(0,setup,dbf_text);
2363 QDIO_DBF_HEX0(0,setup,&init_data->qib_param_field,sizeof(char*));
2364 QDIO_DBF_HEX0(0,setup,&init_data->input_slib_elements,sizeof(long*));
2365 QDIO_DBF_HEX0(0,setup,&init_data->output_slib_elements,sizeof(long*));
2366 sprintf(dbf_text,"miit%4x",init_data->min_input_threshold);
2367 QDIO_DBF_TEXT0(0,setup,dbf_text);
2368 sprintf(dbf_text,"mait%4x",init_data->max_input_threshold);
2369 QDIO_DBF_TEXT0(0,setup,dbf_text);
2370 sprintf(dbf_text,"miot%4x",init_data->min_output_threshold);
2371 QDIO_DBF_TEXT0(0,setup,dbf_text);
2372 sprintf(dbf_text,"maot%4x",init_data->max_output_threshold);
2373 QDIO_DBF_TEXT0(0,setup,dbf_text);
2374 sprintf(dbf_text,"niq:%4x",init_data->no_input_qs);
2375 QDIO_DBF_TEXT0(0,setup,dbf_text);
2376 sprintf(dbf_text,"noq:%4x",init_data->no_output_qs);
2377 QDIO_DBF_TEXT0(0,setup,dbf_text);
2378 QDIO_DBF_HEX0(0,setup,&init_data->input_handler,sizeof(void*));
2379 QDIO_DBF_HEX0(0,setup,&init_data->output_handler,sizeof(void*));
2380 QDIO_DBF_HEX0(0,setup,&init_data->int_parm,sizeof(long));
2381 QDIO_DBF_HEX0(0,setup,&init_data->flags,sizeof(long));
2382 QDIO_DBF_HEX0(0,setup,&init_data->input_sbal_addr_array,sizeof(void*));
2383 QDIO_DBF_HEX0(0,setup,&init_data->output_sbal_addr_array,sizeof(void*));
2387 qdio_allocate_fill_input_desc(struct qdio_irq *irq_ptr, int i, int iqfmt)
2389 irq_ptr->input_qs[i]->is_iqdio_q = iqfmt;
2390 irq_ptr->input_qs[i]->is_thinint_q = irq_ptr->is_thinint_irq;
2392 irq_ptr->qdr->qdf0[i].sliba=(unsigned long)(irq_ptr->input_qs[i]->slib);
2394 irq_ptr->qdr->qdf0[i].sla=(unsigned long)(irq_ptr->input_qs[i]->sl);
2396 irq_ptr->qdr->qdf0[i].slsba=
2397 (unsigned long)(&irq_ptr->input_qs[i]->slsb.acc.val[0]);
2399 irq_ptr->qdr->qdf0[i].akey=QDIO_STORAGE_KEY;
2400 irq_ptr->qdr->qdf0[i].bkey=QDIO_STORAGE_KEY;
2401 irq_ptr->qdr->qdf0[i].ckey=QDIO_STORAGE_KEY;
2402 irq_ptr->qdr->qdf0[i].dkey=QDIO_STORAGE_KEY;
2406 qdio_allocate_fill_output_desc(struct qdio_irq *irq_ptr, int i,
2409 irq_ptr->output_qs[i]->is_iqdio_q = iqfmt;
2410 irq_ptr->output_qs[i]->is_thinint_q = irq_ptr->is_thinint_irq;
2412 irq_ptr->qdr->qdf0[i+j].sliba=(unsigned long)(irq_ptr->output_qs[i]->slib);
2414 irq_ptr->qdr->qdf0[i+j].sla=(unsigned long)(irq_ptr->output_qs[i]->sl);
2416 irq_ptr->qdr->qdf0[i+j].slsba=
2417 (unsigned long)(&irq_ptr->output_qs[i]->slsb.acc.val[0]);
2419 irq_ptr->qdr->qdf0[i+j].akey=QDIO_STORAGE_KEY;
2420 irq_ptr->qdr->qdf0[i+j].bkey=QDIO_STORAGE_KEY;
2421 irq_ptr->qdr->qdf0[i+j].ckey=QDIO_STORAGE_KEY;
2422 irq_ptr->qdr->qdf0[i+j].dkey=QDIO_STORAGE_KEY;
2427 qdio_initialize_set_siga_flags_input(struct qdio_irq *irq_ptr)
2431 for (i=0;i<irq_ptr->no_input_qs;i++) {
2432 irq_ptr->input_qs[i]->siga_sync=
2433 irq_ptr->qdioac&CHSC_FLAG_SIGA_SYNC_NECESSARY;
2434 irq_ptr->input_qs[i]->siga_in=
2435 irq_ptr->qdioac&CHSC_FLAG_SIGA_INPUT_NECESSARY;
2436 irq_ptr->input_qs[i]->siga_out=
2437 irq_ptr->qdioac&CHSC_FLAG_SIGA_OUTPUT_NECESSARY;
2438 irq_ptr->input_qs[i]->siga_sync_done_on_thinints=
2439 irq_ptr->qdioac&CHSC_FLAG_SIGA_SYNC_DONE_ON_THININTS;
2440 irq_ptr->input_qs[i]->hydra_gives_outbound_pcis=
2441 irq_ptr->hydra_gives_outbound_pcis;
2442 irq_ptr->input_qs[i]->siga_sync_done_on_outb_tis=
2444 (CHSC_FLAG_SIGA_SYNC_DONE_ON_OUTB_PCIS|
2445 CHSC_FLAG_SIGA_SYNC_DONE_ON_THININTS))==
2446 (CHSC_FLAG_SIGA_SYNC_DONE_ON_OUTB_PCIS|
2447 CHSC_FLAG_SIGA_SYNC_DONE_ON_THININTS));
2453 qdio_initialize_set_siga_flags_output(struct qdio_irq *irq_ptr)
2457 for (i=0;i<irq_ptr->no_output_qs;i++) {
2458 irq_ptr->output_qs[i]->siga_sync=
2459 irq_ptr->qdioac&CHSC_FLAG_SIGA_SYNC_NECESSARY;
2460 irq_ptr->output_qs[i]->siga_in=
2461 irq_ptr->qdioac&CHSC_FLAG_SIGA_INPUT_NECESSARY;
2462 irq_ptr->output_qs[i]->siga_out=
2463 irq_ptr->qdioac&CHSC_FLAG_SIGA_OUTPUT_NECESSARY;
2464 irq_ptr->output_qs[i]->siga_sync_done_on_thinints=
2465 irq_ptr->qdioac&CHSC_FLAG_SIGA_SYNC_DONE_ON_THININTS;
2466 irq_ptr->output_qs[i]->hydra_gives_outbound_pcis=
2467 irq_ptr->hydra_gives_outbound_pcis;
2468 irq_ptr->output_qs[i]->siga_sync_done_on_outb_tis=
2470 (CHSC_FLAG_SIGA_SYNC_DONE_ON_OUTB_PCIS|
2471 CHSC_FLAG_SIGA_SYNC_DONE_ON_THININTS))==
2472 (CHSC_FLAG_SIGA_SYNC_DONE_ON_OUTB_PCIS|
2473 CHSC_FLAG_SIGA_SYNC_DONE_ON_THININTS));
2479 qdio_establish_irq_check_for_errors(struct ccw_device *cdev, int cstat,
2483 struct qdio_irq *irq_ptr;
2485 irq_ptr = cdev->private->qdio_data;
2487 if (cstat || (dstat & ~(DEV_STAT_CHN_END|DEV_STAT_DEV_END))) {
2488 sprintf(dbf_text,"ick1%4x",irq_ptr->irq);
2489 QDIO_DBF_TEXT2(1,trace,dbf_text);
2490 QDIO_DBF_HEX2(0,trace,&dstat,sizeof(int));
2491 QDIO_DBF_HEX2(0,trace,&cstat,sizeof(int));
2492 QDIO_PRINT_ERR("received check condition on establish " \
2493 "queues on irq 0x%x (cs=x%x, ds=x%x).\n",
2494 irq_ptr->irq,cstat,dstat);
2495 qdio_set_state(irq_ptr,QDIO_IRQ_STATE_ERR);
2498 if (!(dstat & DEV_STAT_DEV_END)) {
2499 QDIO_DBF_TEXT2(1,setup,"eq:no de");
2500 QDIO_DBF_HEX2(0,setup,&dstat, sizeof(dstat));
2501 QDIO_DBF_HEX2(0,setup,&cstat, sizeof(cstat));
2502 QDIO_PRINT_ERR("establish queues on irq %04x: didn't get "
2503 "device end: dstat=%02x, cstat=%02x\n",
2504 irq_ptr->irq, dstat, cstat);
2505 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_ERR);
2509 if (dstat & ~(DEV_STAT_CHN_END|DEV_STAT_DEV_END)) {
2510 QDIO_DBF_TEXT2(1,setup,"eq:badio");
2511 QDIO_DBF_HEX2(0,setup,&dstat, sizeof(dstat));
2512 QDIO_DBF_HEX2(0,setup,&cstat, sizeof(cstat));
2513 QDIO_PRINT_ERR("establish queues on irq %04x: got "
2514 "the following devstat: dstat=%02x, "
2516 irq_ptr->irq, dstat, cstat);
2517 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_ERR);
2524 qdio_establish_handle_irq(struct ccw_device *cdev, int cstat, int dstat)
2526 struct qdio_irq *irq_ptr;
2529 irq_ptr = cdev->private->qdio_data;
2531 sprintf(dbf_text,"qehi%4x",cdev->private->irq);
2532 QDIO_DBF_TEXT0(0,setup,dbf_text);
2533 QDIO_DBF_TEXT0(0,trace,dbf_text);
2535 if (qdio_establish_irq_check_for_errors(cdev, cstat, dstat)) {
2536 ccw_device_set_timeout(cdev, 0);
2540 qdio_set_state(irq_ptr,QDIO_IRQ_STATE_ESTABLISHED);
2541 ccw_device_set_timeout(cdev, 0);
2545 qdio_initialize(struct qdio_initialize *init_data)
2550 sprintf(dbf_text,"qini%4x",init_data->cdev->private->irq);
2551 QDIO_DBF_TEXT0(0,setup,dbf_text);
2552 QDIO_DBF_TEXT0(0,trace,dbf_text);
2554 rc = qdio_allocate(init_data);
2556 rc = qdio_establish(init_data);
2558 qdio_free(init_data->cdev);
2566 qdio_allocate(struct qdio_initialize *init_data)
2570 struct qdio_irq *irq_ptr;
2573 sprintf(dbf_text,"qalc%4x",init_data->cdev->private->irq);
2574 QDIO_DBF_TEXT0(0,setup,dbf_text);
2575 QDIO_DBF_TEXT0(0,trace,dbf_text);
2576 if ( (init_data->no_input_qs>QDIO_MAX_QUEUES_PER_IRQ) ||
2577 (init_data->no_output_qs>QDIO_MAX_QUEUES_PER_IRQ) ||
2578 ((init_data->no_input_qs) && (!init_data->input_handler)) ||
2579 ((init_data->no_output_qs) && (!init_data->output_handler)) )
2582 if (!init_data->input_sbal_addr_array)
2585 if (!init_data->output_sbal_addr_array)
2588 qdio_allocate_do_dbf(init_data);
2591 mem = kmalloc(sizeof(struct qdio_irq) + 0xff, GFP_KERNEL | GFP_DMA);
2593 QDIO_DBF_TEXT0(0,setup,"irq_ptr:");
2594 QDIO_DBF_HEX0(0,setup,&irq_ptr,sizeof(void*));
2597 QDIO_PRINT_ERR("kmalloc of irq_ptr failed!\n");
2601 irq_ptr = (struct qdio_irq *) mem;
2602 if ((off = ((unsigned long) mem) & 0xff) != 0)
2603 irq_ptr = (struct qdio_irq *)(mem + 0x100 - off);
2604 memset(irq_ptr,0,sizeof(struct qdio_irq));
2605 irq_ptr->actual_alloc = mem;
2607 init_MUTEX(&irq_ptr->setting_up_sema);
2609 irq_ptr->qdr=kmalloc(sizeof(struct qdr), GFP_KERNEL | GFP_DMA);
2610 if (!(irq_ptr->qdr)) {
2612 QDIO_PRINT_ERR("kmalloc of irq_ptr->qdr failed!\n");
2615 QDIO_DBF_TEXT0(0,setup,"qdr:");
2616 QDIO_DBF_HEX0(0,setup,&irq_ptr->qdr,sizeof(void*));
2618 if (qdio_alloc_qs(irq_ptr,
2619 init_data->no_input_qs,
2620 init_data->no_output_qs)) {
2621 qdio_release_irq_memory(irq_ptr);
2625 init_data->cdev->private->qdio_data = irq_ptr;
2627 qdio_set_state(irq_ptr,QDIO_IRQ_STATE_INACTIVE);
2632 int qdio_fill_irq(struct qdio_initialize *init_data)
2638 struct qdio_irq *irq_ptr;
2640 irq_ptr = init_data->cdev->private->qdio_data;
2642 memset(irq_ptr,0,((char*)&irq_ptr->qdr)-((char*)irq_ptr));
2644 /* wipes qib.ac, required by ar7063 */
2645 memset(irq_ptr->qdr,0,sizeof(struct qdr));
2647 irq_ptr->int_parm=init_data->int_parm;
2649 irq_ptr->irq = init_data->cdev->private->irq;
2650 irq_ptr->no_input_qs=init_data->no_input_qs;
2651 irq_ptr->no_output_qs=init_data->no_output_qs;
2653 if (init_data->q_format==QDIO_IQDIO_QFMT) {
2654 irq_ptr->is_iqdio_irq=1;
2655 irq_ptr->is_thinint_irq=1;
2657 irq_ptr->is_iqdio_irq=0;
2658 irq_ptr->is_thinint_irq=hydra_thinints;
2660 sprintf(dbf_text,"is_i_t%1x%1x",
2661 irq_ptr->is_iqdio_irq,irq_ptr->is_thinint_irq);
2662 QDIO_DBF_TEXT2(0,setup,dbf_text);
2664 if (irq_ptr->is_thinint_irq) {
2665 irq_ptr->dev_st_chg_ind=qdio_get_indicator();
2666 QDIO_DBF_HEX1(0,setup,&irq_ptr->dev_st_chg_ind,sizeof(void*));
2667 if (!irq_ptr->dev_st_chg_ind) {
2668 QDIO_PRINT_WARN("no indicator location available " \
2669 "for irq 0x%x\n",irq_ptr->irq);
2670 qdio_release_irq_memory(irq_ptr);
2676 irq_ptr->equeue.cmd=DEFAULT_ESTABLISH_QS_CMD;
2677 irq_ptr->equeue.count=DEFAULT_ESTABLISH_QS_COUNT;
2678 irq_ptr->aqueue.cmd=DEFAULT_ACTIVATE_QS_CMD;
2679 irq_ptr->aqueue.count=DEFAULT_ACTIVATE_QS_COUNT;
2681 qdio_fill_qs(irq_ptr, init_data->cdev,
2682 init_data->no_input_qs,
2683 init_data->no_output_qs,
2684 init_data->input_handler,
2685 init_data->output_handler,init_data->int_parm,
2686 init_data->q_format,init_data->flags,
2687 init_data->input_sbal_addr_array,
2688 init_data->output_sbal_addr_array);
2690 if (!try_module_get(THIS_MODULE)) {
2691 QDIO_PRINT_CRIT("try_module_get() failed!\n");
2692 qdio_release_irq_memory(irq_ptr);
2696 qdio_fill_thresholds(irq_ptr,init_data->no_input_qs,
2697 init_data->no_output_qs,
2698 init_data->min_input_threshold,
2699 init_data->max_input_threshold,
2700 init_data->min_output_threshold,
2701 init_data->max_output_threshold);
2704 irq_ptr->qdr->qfmt=init_data->q_format;
2705 irq_ptr->qdr->iqdcnt=init_data->no_input_qs;
2706 irq_ptr->qdr->oqdcnt=init_data->no_output_qs;
2707 irq_ptr->qdr->iqdsz=sizeof(struct qdesfmt0)/4; /* size in words */
2708 irq_ptr->qdr->oqdsz=sizeof(struct qdesfmt0)/4;
2710 irq_ptr->qdr->qiba=(unsigned long)&irq_ptr->qib;
2711 irq_ptr->qdr->qkey=QDIO_STORAGE_KEY;
2714 irq_ptr->qib.qfmt=init_data->q_format;
2715 if (init_data->no_input_qs)
2716 irq_ptr->qib.isliba=(unsigned long)(irq_ptr->input_qs[0]->slib);
2717 if (init_data->no_output_qs)
2718 irq_ptr->qib.osliba=(unsigned long)(irq_ptr->output_qs[0]->slib);
2719 memcpy(irq_ptr->qib.ebcnam,init_data->adapter_name,8);
2721 qdio_set_impl_params(irq_ptr,init_data->qib_param_field_format,
2722 init_data->qib_param_field,
2723 init_data->no_input_qs,
2724 init_data->no_output_qs,
2725 init_data->input_slib_elements,
2726 init_data->output_slib_elements);
2728 /* first input descriptors, then output descriptors */
2729 is_iqdio = (init_data->q_format == QDIO_IQDIO_QFMT) ? 1 : 0;
2730 for (i=0;i<init_data->no_input_qs;i++)
2731 qdio_allocate_fill_input_desc(irq_ptr, i, is_iqdio);
2733 for (i=0;i<init_data->no_output_qs;i++)
2734 qdio_allocate_fill_output_desc(irq_ptr, i,
2735 init_data->no_input_qs,
2738 /* qdr, qib, sls, slsbs, slibs, sbales filled. */
2740 /* get qdio commands */
2741 ciw = ccw_device_get_ciw(init_data->cdev, CIW_TYPE_EQUEUE);
2743 QDIO_DBF_TEXT2(1,setup,"no eq");
2744 QDIO_PRINT_INFO("No equeue CIW found for QDIO commands. "
2745 "Trying to use default.\n");
2747 irq_ptr->equeue = *ciw;
2748 ciw = ccw_device_get_ciw(init_data->cdev, CIW_TYPE_AQUEUE);
2750 QDIO_DBF_TEXT2(1,setup,"no aq");
2751 QDIO_PRINT_INFO("No aqueue CIW found for QDIO commands. "
2752 "Trying to use default.\n");
2754 irq_ptr->aqueue = *ciw;
2756 /* Set new interrupt handler. */
2757 irq_ptr->original_int_handler = init_data->cdev->handler;
2758 init_data->cdev->handler = qdio_handler;
2764 qdio_establish(struct qdio_initialize *init_data)
2766 struct qdio_irq *irq_ptr;
2767 unsigned long saveflags;
2768 int result, result2;
2769 struct ccw_device *cdev;
2772 cdev=init_data->cdev;
2773 irq_ptr = cdev->private->qdio_data;
2777 if (cdev->private->state != DEV_STATE_ONLINE)
2780 down(&irq_ptr->setting_up_sema);
2782 qdio_fill_irq(init_data);
2784 /* the thinint CHSC stuff */
2785 if (irq_ptr->is_thinint_irq) {
2787 result = tiqdio_set_subchannel_ind(irq_ptr,0);
2789 up(&irq_ptr->setting_up_sema);
2790 qdio_shutdown(cdev, QDIO_FLAG_CLEANUP_USING_CLEAR);
2793 tiqdio_set_delay_target(irq_ptr,TIQDIO_DELAY_TARGET);
2796 sprintf(dbf_text,"qest%4x",cdev->private->irq);
2797 QDIO_DBF_TEXT0(0,setup,dbf_text);
2798 QDIO_DBF_TEXT0(0,trace,dbf_text);
2801 irq_ptr->ccw.cmd_code=irq_ptr->equeue.cmd;
2802 irq_ptr->ccw.flags=CCW_FLAG_SLI;
2803 irq_ptr->ccw.count=irq_ptr->equeue.count;
2804 irq_ptr->ccw.cda=QDIO_GET_ADDR(irq_ptr->qdr);
2806 spin_lock_irqsave(get_ccwdev_lock(cdev),saveflags);
2808 ccw_device_set_options(cdev, 0);
2809 result=ccw_device_start_timeout(cdev,&irq_ptr->ccw,
2810 QDIO_DOING_ESTABLISH,0, 0,
2811 QDIO_ESTABLISH_TIMEOUT);
2813 result2=ccw_device_start_timeout(cdev,&irq_ptr->ccw,
2814 QDIO_DOING_ESTABLISH,0,0,
2815 QDIO_ESTABLISH_TIMEOUT);
2816 sprintf(dbf_text,"eq:io%4x",result);
2817 QDIO_DBF_TEXT2(1,setup,dbf_text);
2819 sprintf(dbf_text,"eq:io%4x",result);
2820 QDIO_DBF_TEXT2(1,setup,dbf_text);
2822 QDIO_PRINT_WARN("establish queues on irq %04x: do_IO " \
2823 "returned %i, next try returned %i\n",
2824 irq_ptr->irq,result,result2);
2827 ccw_device_set_timeout(cdev, 0);
2830 spin_unlock_irqrestore(get_ccwdev_lock(cdev),saveflags);
2833 up(&irq_ptr->setting_up_sema);
2834 qdio_shutdown(cdev,QDIO_FLAG_CLEANUP_USING_CLEAR);
2838 wait_event_interruptible_timeout(cdev->private->wait_q,
2839 irq_ptr->state == QDIO_IRQ_STATE_ESTABLISHED ||
2840 irq_ptr->state == QDIO_IRQ_STATE_ERR,
2841 QDIO_ESTABLISH_TIMEOUT);
2843 if (irq_ptr->state == QDIO_IRQ_STATE_ESTABLISHED)
2846 up(&irq_ptr->setting_up_sema);
2847 qdio_shutdown(cdev, QDIO_FLAG_CLEANUP_USING_CLEAR);
2851 irq_ptr->qdioac=qdio_check_siga_needs(irq_ptr->irq);
2852 /* if this gets set once, we're running under VM and can omit SVSes */
2853 if (irq_ptr->qdioac&CHSC_FLAG_SIGA_SYNC_NECESSARY)
2856 sprintf(dbf_text,"qdioac%2x",irq_ptr->qdioac);
2857 QDIO_DBF_TEXT2(0,setup,dbf_text);
2859 sprintf(dbf_text,"qib ac%2x",irq_ptr->qib.ac);
2860 QDIO_DBF_TEXT2(0,setup,dbf_text);
2862 irq_ptr->hydra_gives_outbound_pcis=
2863 irq_ptr->qib.ac&QIB_AC_OUTBOUND_PCI_SUPPORTED;
2864 irq_ptr->sync_done_on_outb_pcis=
2865 irq_ptr->qdioac&CHSC_FLAG_SIGA_SYNC_DONE_ON_OUTB_PCIS;
2867 qdio_initialize_set_siga_flags_input(irq_ptr);
2868 qdio_initialize_set_siga_flags_output(irq_ptr);
2870 up(&irq_ptr->setting_up_sema);
2877 qdio_activate(struct ccw_device *cdev, int flags)
2879 struct qdio_irq *irq_ptr;
2880 int i,result=0,result2;
2881 unsigned long saveflags;
2882 char dbf_text[20]; /* see qdio_initialize */
2884 irq_ptr = cdev->private->qdio_data;
2888 if (cdev->private->state != DEV_STATE_ONLINE)
2891 down(&irq_ptr->setting_up_sema);
2892 if (irq_ptr->state==QDIO_IRQ_STATE_INACTIVE) {
2897 sprintf(dbf_text,"qact%4x", irq_ptr->irq);
2898 QDIO_DBF_TEXT2(0,setup,dbf_text);
2899 QDIO_DBF_TEXT2(0,trace,dbf_text);
2902 irq_ptr->ccw.cmd_code=irq_ptr->aqueue.cmd;
2903 irq_ptr->ccw.flags=CCW_FLAG_SLI;
2904 irq_ptr->ccw.count=irq_ptr->aqueue.count;
2905 irq_ptr->ccw.cda=QDIO_GET_ADDR(0);
2907 spin_lock_irqsave(get_ccwdev_lock(cdev),saveflags);
2909 ccw_device_set_timeout(cdev, 0);
2910 ccw_device_set_options(cdev, CCWDEV_REPORT_ALL);
2911 result=ccw_device_start(cdev,&irq_ptr->ccw,QDIO_DOING_ACTIVATE,
2912 0, DOIO_DENY_PREFETCH);
2914 result2=ccw_device_start(cdev,&irq_ptr->ccw,
2915 QDIO_DOING_ACTIVATE,0,0);
2916 sprintf(dbf_text,"aq:io%4x",result);
2917 QDIO_DBF_TEXT2(1,setup,dbf_text);
2919 sprintf(dbf_text,"aq:io%4x",result);
2920 QDIO_DBF_TEXT2(1,setup,dbf_text);
2922 QDIO_PRINT_WARN("activate queues on irq %04x: do_IO " \
2923 "returned %i, next try returned %i\n",
2924 irq_ptr->irq,result,result2);
2928 spin_unlock_irqrestore(get_ccwdev_lock(cdev),saveflags);
2932 for (i=0;i<irq_ptr->no_input_qs;i++) {
2933 if (irq_ptr->is_thinint_irq) {
2935 * that way we know, that, if we will get interrupted
2936 * by tiqdio_inbound_processing, qdio_unmark_q will
2939 qdio_reserve_q(irq_ptr->input_qs[i]);
2940 qdio_mark_tiq(irq_ptr->input_qs[i]);
2941 qdio_release_q(irq_ptr->input_qs[i]);
2945 if (flags&QDIO_FLAG_NO_INPUT_INTERRUPT_CONTEXT) {
2946 for (i=0;i<irq_ptr->no_input_qs;i++) {
2947 irq_ptr->input_qs[i]->is_input_q|=
2948 QDIO_FLAG_NO_INPUT_INTERRUPT_CONTEXT;
2952 wait_event_interruptible_timeout(cdev->private->wait_q,
2954 QDIO_IRQ_STATE_STOPPED) ||
2956 QDIO_IRQ_STATE_ERR)),
2957 QDIO_ACTIVATE_TIMEOUT);
2959 switch (irq_ptr->state) {
2960 case QDIO_IRQ_STATE_STOPPED:
2961 case QDIO_IRQ_STATE_ERR:
2962 up(&irq_ptr->setting_up_sema);
2963 qdio_shutdown(cdev, QDIO_FLAG_CLEANUP_USING_CLEAR);
2964 down(&irq_ptr->setting_up_sema);
2968 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_ACTIVE);
2972 up(&irq_ptr->setting_up_sema);
2977 /* buffers filled forwards again to make Rick happy */
2979 qdio_do_qdio_fill_input(struct qdio_q *q, unsigned int qidx,
2980 unsigned int count, struct qdio_buffer *buffers)
2983 set_slsb(&q->slsb.acc.val[qidx],SLSB_CU_INPUT_EMPTY);
2986 qidx=(qidx+1)&(QDIO_MAX_BUFFERS_PER_Q-1);
2989 /* not necessary, as the queues are synced during the SIGA read */
2994 qdio_do_qdio_fill_output(struct qdio_q *q, unsigned int qidx,
2995 unsigned int count, struct qdio_buffer *buffers)
2998 set_slsb(&q->slsb.acc.val[qidx],SLSB_CU_OUTPUT_PRIMED);
3001 qidx=(qidx+1)&(QDIO_MAX_BUFFERS_PER_Q-1);
3004 /* SIGA write will sync the queues */
3009 do_qdio_handle_inbound(struct qdio_q *q, unsigned int callflags,
3010 unsigned int qidx, unsigned int count,
3011 struct qdio_buffer *buffers)
3015 /* This is the inbound handling of queues */
3016 used_elements=atomic_add_return(count, &q->number_of_buffers_used) - count;
3018 qdio_do_qdio_fill_input(q,qidx,count,buffers);
3020 if ((used_elements+count==QDIO_MAX_BUFFERS_PER_Q)&&
3021 (callflags&QDIO_FLAG_UNDER_INTERRUPT))
3022 atomic_swap(&q->polling,0);
3026 if (callflags&QDIO_FLAG_DONT_SIGA)
3031 result=qdio_siga_input(q);
3034 q->error_status_flags|=
3035 QDIO_STATUS_MORE_THAN_ONE_SIGA_ERROR;
3036 q->error_status_flags|=QDIO_STATUS_LOOK_FOR_ERROR;
3037 q->siga_error=result;
3045 do_qdio_handle_outbound(struct qdio_q *q, unsigned int callflags,
3046 unsigned int qidx, unsigned int count,
3047 struct qdio_buffer *buffers)
3051 /* This is the outbound handling of queues */
3052 #ifdef QDIO_PERFORMANCE_STATS
3053 perf_stats.start_time_outbound=NOW;
3054 #endif /* QDIO_PERFORMANCE_STATS */
3056 qdio_do_qdio_fill_output(q,qidx,count,buffers);
3058 used_elements=atomic_add_return(count, &q->number_of_buffers_used) - count;
3060 if (callflags&QDIO_FLAG_DONT_SIGA) {
3061 #ifdef QDIO_PERFORMANCE_STATS
3062 perf_stats.outbound_time+=NOW-perf_stats.start_time_outbound;
3063 perf_stats.outbound_cnt++;
3064 #endif /* QDIO_PERFORMANCE_STATS */
3067 if (q->is_iqdio_q) {
3068 /* one siga for every sbal */
3070 qdio_kick_outbound_q(q);
3072 __qdio_outbound_processing(q);
3074 /* under VM, we do a SIGA sync unconditionally */
3078 * w/o shadow queues (else branch of
3079 * SYNC_MEMORY :-/ ), we try to
3080 * fast-requeue buffers
3082 if (q->slsb.acc.val[(qidx+QDIO_MAX_BUFFERS_PER_Q-1)
3083 &(QDIO_MAX_BUFFERS_PER_Q-1)]!=
3084 SLSB_CU_OUTPUT_PRIMED) {
3085 qdio_kick_outbound_q(q);
3087 QDIO_DBF_TEXT3(0,trace, "fast-req");
3088 #ifdef QDIO_PERFORMANCE_STATS
3089 perf_stats.fast_reqs++;
3090 #endif /* QDIO_PERFORMANCE_STATS */
3094 * only marking the q could take too long,
3095 * the upper layer module could do a lot of
3096 * traffic in that time
3098 __qdio_outbound_processing(q);
3101 #ifdef QDIO_PERFORMANCE_STATS
3102 perf_stats.outbound_time+=NOW-perf_stats.start_time_outbound;
3103 perf_stats.outbound_cnt++;
3104 #endif /* QDIO_PERFORMANCE_STATS */
3107 /* count must be 1 in iqdio */
3109 do_QDIO(struct ccw_device *cdev,unsigned int callflags,
3110 unsigned int queue_number, unsigned int qidx,
3111 unsigned int count,struct qdio_buffer *buffers)
3113 struct qdio_irq *irq_ptr;
3117 sprintf(dbf_text,"doQD%04x",cdev->private->irq);
3118 QDIO_DBF_TEXT3(0,trace,dbf_text);
3120 if ( (qidx>QDIO_MAX_BUFFERS_PER_Q) ||
3121 (count>QDIO_MAX_BUFFERS_PER_Q) ||
3122 (queue_number>QDIO_MAX_QUEUES_PER_IRQ) )
3128 irq_ptr = cdev->private->qdio_data;
3132 if (callflags&QDIO_FLAG_SYNC_INPUT)
3133 QDIO_DBF_HEX3(0,trace,&irq_ptr->input_qs[queue_number],
3136 QDIO_DBF_HEX3(0,trace,&irq_ptr->output_qs[queue_number],
3138 sprintf(dbf_text,"flag%04x",callflags);
3139 QDIO_DBF_TEXT3(0,trace,dbf_text);
3140 sprintf(dbf_text,"qi%02xct%02x",qidx,count);
3141 QDIO_DBF_TEXT3(0,trace,dbf_text);
3143 if (irq_ptr->state!=QDIO_IRQ_STATE_ACTIVE)
3146 if (callflags&QDIO_FLAG_SYNC_INPUT)
3147 do_qdio_handle_inbound(irq_ptr->input_qs[queue_number],
3148 callflags, qidx, count, buffers);
3149 else if (callflags&QDIO_FLAG_SYNC_OUTPUT)
3150 do_qdio_handle_outbound(irq_ptr->output_qs[queue_number],
3151 callflags, qidx, count, buffers);
3153 QDIO_DBF_TEXT3(1,trace,"doQD:inv");
3159 #ifdef QDIO_PERFORMANCE_STATS
3161 qdio_perf_procfile_read(char *buffer, char **buffer_location, off_t offset,
3162 int buffer_length, int *eof, void *data)
3166 /* we are always called with buffer_length=4k, so we all
3167 deliver on the first read */
3171 #define _OUTP_IT(x...) c+=sprintf(buffer+c,x)
3172 _OUTP_IT("i_p_nc/c=%lu/%lu\n",i_p_nc,i_p_c);
3173 _OUTP_IT("ii_p_nc/c=%lu/%lu\n",ii_p_nc,ii_p_c);
3174 _OUTP_IT("o_p_nc/c=%lu/%lu\n",o_p_nc,o_p_c);
3175 _OUTP_IT("Number of tasklet runs (total) : %u\n",
3176 perf_stats.tl_runs);
3178 _OUTP_IT("Number of SIGA sync's issued : %u\n",
3179 perf_stats.siga_syncs);
3180 _OUTP_IT("Number of SIGA in's issued : %u\n",
3181 perf_stats.siga_ins);
3182 _OUTP_IT("Number of SIGA out's issued : %u\n",
3183 perf_stats.siga_outs);
3184 _OUTP_IT("Number of PCIs caught : %u\n",
3186 _OUTP_IT("Number of adapter interrupts caught : %u\n",
3187 perf_stats.thinints);
3188 _OUTP_IT("Number of fast requeues (outg. SBALs w/o SIGA) : %u\n",
3189 perf_stats.fast_reqs);
3191 _OUTP_IT("Total time of all inbound actions (us) incl. UL : %u\n",
3192 perf_stats.inbound_time);
3193 _OUTP_IT("Number of inbound transfers : %u\n",
3194 perf_stats.inbound_cnt);
3195 _OUTP_IT("Total time of all outbound do_QDIOs (us) : %u\n",
3196 perf_stats.outbound_time);
3197 _OUTP_IT("Number of do_QDIOs outbound : %u\n",
3198 perf_stats.outbound_cnt);
3204 static struct proc_dir_entry *qdio_perf_proc_file;
3205 #endif /* QDIO_PERFORMANCE_STATS */
3208 qdio_add_procfs_entry(void)
3210 #ifdef QDIO_PERFORMANCE_STATS
3211 proc_perf_file_registration=0;
3212 qdio_perf_proc_file=create_proc_entry(QDIO_PERF,
3213 S_IFREG|0444,&proc_root);
3214 if (qdio_perf_proc_file) {
3215 qdio_perf_proc_file->read_proc=&qdio_perf_procfile_read;
3216 } else proc_perf_file_registration=-1;
3218 if (proc_perf_file_registration)
3219 QDIO_PRINT_WARN("was not able to register perf. " \
3220 "proc-file (%i).\n",
3221 proc_perf_file_registration);
3222 #endif /* QDIO_PERFORMANCE_STATS */
3226 qdio_remove_procfs_entry(void)
3228 #ifdef QDIO_PERFORMANCE_STATS
3229 perf_stats.tl_runs=0;
3231 if (!proc_perf_file_registration) /* means if it went ok earlier */
3232 remove_proc_entry(QDIO_PERF,&proc_root);
3233 #endif /* QDIO_PERFORMANCE_STATS */
3237 tiqdio_register_thinints(void)
3240 register_thinint_result=
3241 s390_register_adapter_interrupt(&tiqdio_thinint_handler);
3242 if (register_thinint_result) {
3243 sprintf(dbf_text,"regthn%x",(register_thinint_result&0xff));
3244 QDIO_DBF_TEXT0(0,setup,dbf_text);
3245 QDIO_PRINT_ERR("failed to register adapter handler " \
3246 "(rc=%i).\nAdapter interrupts might " \
3247 "not work. Continuing.\n",
3248 register_thinint_result);
3253 tiqdio_unregister_thinints(void)
3255 if (!register_thinint_result)
3256 s390_unregister_adapter_interrupt(&tiqdio_thinint_handler);
3260 qdio_get_qdio_memory(void)
3263 indicator_used[0]=1;
3265 for (i=1;i<INDICATORS_PER_CACHELINE;i++)
3266 indicator_used[i]=0;
3267 indicators=(__u32*)kmalloc(sizeof(__u32)*(INDICATORS_PER_CACHELINE),
3269 if (!indicators) return -ENOMEM;
3270 memset(indicators,0,sizeof(__u32)*(INDICATORS_PER_CACHELINE));
3275 qdio_release_qdio_memory(void)
3282 qdio_unregister_dbf_views(void)
3285 debug_unregister(qdio_dbf_setup);
3287 debug_unregister(qdio_dbf_sbal);
3289 debug_unregister(qdio_dbf_sense);
3291 debug_unregister(qdio_dbf_trace);
3292 #ifdef QDIO_DBF_LIKE_HELL
3293 if (qdio_dbf_slsb_out)
3294 debug_unregister(qdio_dbf_slsb_out);
3295 if (qdio_dbf_slsb_in)
3296 debug_unregister(qdio_dbf_slsb_in);
3297 #endif /* QDIO_DBF_LIKE_HELL */
3301 qdio_register_dbf_views(void)
3303 qdio_dbf_setup=debug_register(QDIO_DBF_SETUP_NAME,
3304 QDIO_DBF_SETUP_INDEX,
3305 QDIO_DBF_SETUP_NR_AREAS,
3306 QDIO_DBF_SETUP_LEN);
3307 if (!qdio_dbf_setup)
3309 debug_register_view(qdio_dbf_setup,&debug_hex_ascii_view);
3310 debug_set_level(qdio_dbf_setup,QDIO_DBF_SETUP_LEVEL);
3312 qdio_dbf_sbal=debug_register(QDIO_DBF_SBAL_NAME,
3313 QDIO_DBF_SBAL_INDEX,
3314 QDIO_DBF_SBAL_NR_AREAS,
3319 debug_register_view(qdio_dbf_sbal,&debug_hex_ascii_view);
3320 debug_set_level(qdio_dbf_sbal,QDIO_DBF_SBAL_LEVEL);
3322 qdio_dbf_sense=debug_register(QDIO_DBF_SENSE_NAME,
3323 QDIO_DBF_SENSE_INDEX,
3324 QDIO_DBF_SENSE_NR_AREAS,
3325 QDIO_DBF_SENSE_LEN);
3326 if (!qdio_dbf_sense)
3329 debug_register_view(qdio_dbf_sense,&debug_hex_ascii_view);
3330 debug_set_level(qdio_dbf_sense,QDIO_DBF_SENSE_LEVEL);
3332 qdio_dbf_trace=debug_register(QDIO_DBF_TRACE_NAME,
3333 QDIO_DBF_TRACE_INDEX,
3334 QDIO_DBF_TRACE_NR_AREAS,
3335 QDIO_DBF_TRACE_LEN);
3336 if (!qdio_dbf_trace)
3339 debug_register_view(qdio_dbf_trace,&debug_hex_ascii_view);
3340 debug_set_level(qdio_dbf_trace,QDIO_DBF_TRACE_LEVEL);
3342 #ifdef QDIO_DBF_LIKE_HELL
3343 qdio_dbf_slsb_out=debug_register(QDIO_DBF_SLSB_OUT_NAME,
3344 QDIO_DBF_SLSB_OUT_INDEX,
3345 QDIO_DBF_SLSB_OUT_NR_AREAS,
3346 QDIO_DBF_SLSB_OUT_LEN);
3347 if (!qdio_dbf_slsb_out)
3349 debug_register_view(qdio_dbf_slsb_out,&debug_hex_ascii_view);
3350 debug_set_level(qdio_dbf_slsb_out,QDIO_DBF_SLSB_OUT_LEVEL);
3352 qdio_dbf_slsb_in=debug_register(QDIO_DBF_SLSB_IN_NAME,
3353 QDIO_DBF_SLSB_IN_INDEX,
3354 QDIO_DBF_SLSB_IN_NR_AREAS,
3355 QDIO_DBF_SLSB_IN_LEN);
3356 if (!qdio_dbf_slsb_in)
3358 debug_register_view(qdio_dbf_slsb_in,&debug_hex_ascii_view);
3359 debug_set_level(qdio_dbf_slsb_in,QDIO_DBF_SLSB_IN_LEVEL);
3360 #endif /* QDIO_DBF_LIKE_HELL */
3363 QDIO_PRINT_ERR("not enough memory for dbf.\n");
3364 qdio_unregister_dbf_views();
3372 #ifdef QDIO_PERFORMANCE_STATS
3374 #endif /* QDIO_PERFORMANCE_STATS */
3376 printk("qdio: loading %s\n",version);
3378 res=qdio_get_qdio_memory();
3382 res = qdio_register_dbf_views();
3386 QDIO_DBF_TEXT0(0,setup,"initQDIO");
3388 #ifdef QDIO_PERFORMANCE_STATS
3389 memset((void*)&perf_stats,0,sizeof(perf_stats));
3390 QDIO_DBF_TEXT0(0,setup,"perfstat");
3392 QDIO_DBF_HEX0(0,setup,&ptr,sizeof(void*));
3393 #endif /* QDIO_PERFORMANCE_STATS */
3395 qdio_add_procfs_entry();
3397 if (tiqdio_check_chsc_availability())
3398 QDIO_PRINT_ERR("Not all CHSCs supported. Continuing.\n");
3400 tiqdio_register_thinints();
3408 tiqdio_unregister_thinints();
3409 qdio_remove_procfs_entry();
3410 qdio_release_qdio_memory();
3411 qdio_unregister_dbf_views();
3413 printk("qdio: %s: module removed\n",version);
3416 module_init(init_QDIO);
3417 module_exit(cleanup_QDIO);
3419 EXPORT_SYMBOL(qdio_allocate);
3420 EXPORT_SYMBOL(qdio_establish);
3421 EXPORT_SYMBOL(qdio_initialize);
3422 EXPORT_SYMBOL(qdio_activate);
3423 EXPORT_SYMBOL(do_QDIO);
3424 EXPORT_SYMBOL(qdio_shutdown);
3425 EXPORT_SYMBOL(qdio_free);
3426 EXPORT_SYMBOL(qdio_cleanup);
3427 EXPORT_SYMBOL(qdio_synchronize);