[S390] qdio: make sure qdr is aligned to page size
[linux-2.6.git] / drivers / s390 / cio / qdio_main.c
1 /*
2  * linux/drivers/s390/cio/qdio_main.c
3  *
4  * Linux for s390 qdio support, buffer handling, qdio API and module support.
5  *
6  * Copyright 2000,2008 IBM Corp.
7  * Author(s): Utz Bacher <utz.bacher@de.ibm.com>
8  *            Jan Glauber <jang@linux.vnet.ibm.com>
9  * 2.6 cio integration by Cornelia Huck <cornelia.huck@de.ibm.com>
10  */
11 #include <linux/module.h>
12 #include <linux/init.h>
13 #include <linux/kernel.h>
14 #include <linux/timer.h>
15 #include <linux/delay.h>
16 #include <asm/atomic.h>
17 #include <asm/debug.h>
18 #include <asm/qdio.h>
19
20 #include "cio.h"
21 #include "css.h"
22 #include "device.h"
23 #include "qdio.h"
24 #include "qdio_debug.h"
25 #include "qdio_perf.h"
26
27 MODULE_AUTHOR("Utz Bacher <utz.bacher@de.ibm.com>,"\
28         "Jan Glauber <jang@linux.vnet.ibm.com>");
29 MODULE_DESCRIPTION("QDIO base support");
30 MODULE_LICENSE("GPL");
31
32 static inline int do_siga_sync(struct subchannel_id schid,
33                                unsigned int out_mask, unsigned int in_mask)
34 {
35         register unsigned long __fc asm ("0") = 2;
36         register struct subchannel_id __schid asm ("1") = schid;
37         register unsigned long out asm ("2") = out_mask;
38         register unsigned long in asm ("3") = in_mask;
39         int cc;
40
41         asm volatile(
42                 "       siga    0\n"
43                 "       ipm     %0\n"
44                 "       srl     %0,28\n"
45                 : "=d" (cc)
46                 : "d" (__fc), "d" (__schid), "d" (out), "d" (in) : "cc");
47         return cc;
48 }
49
50 static inline int do_siga_input(struct subchannel_id schid, unsigned int mask)
51 {
52         register unsigned long __fc asm ("0") = 1;
53         register struct subchannel_id __schid asm ("1") = schid;
54         register unsigned long __mask asm ("2") = mask;
55         int cc;
56
57         asm volatile(
58                 "       siga    0\n"
59                 "       ipm     %0\n"
60                 "       srl     %0,28\n"
61                 : "=d" (cc)
62                 : "d" (__fc), "d" (__schid), "d" (__mask) : "cc", "memory");
63         return cc;
64 }
65
66 /**
67  * do_siga_output - perform SIGA-w/wt function
68  * @schid: subchannel id or in case of QEBSM the subchannel token
69  * @mask: which output queues to process
70  * @bb: busy bit indicator, set only if SIGA-w/wt could not access a buffer
71  * @fc: function code to perform
72  *
73  * Returns cc or QDIO_ERROR_SIGA_ACCESS_EXCEPTION.
74  * Note: For IQDC unicast queues only the highest priority queue is processed.
75  */
76 static inline int do_siga_output(unsigned long schid, unsigned long mask,
77                                  u32 *bb, unsigned int fc)
78 {
79         register unsigned long __fc asm("0") = fc;
80         register unsigned long __schid asm("1") = schid;
81         register unsigned long __mask asm("2") = mask;
82         int cc = QDIO_ERROR_SIGA_ACCESS_EXCEPTION;
83
84         asm volatile(
85                 "       siga    0\n"
86                 "0:     ipm     %0\n"
87                 "       srl     %0,28\n"
88                 "1:\n"
89                 EX_TABLE(0b, 1b)
90                 : "+d" (cc), "+d" (__fc), "+d" (__schid), "+d" (__mask)
91                 : : "cc", "memory");
92         *bb = ((unsigned int) __fc) >> 31;
93         return cc;
94 }
95
96 static inline int qdio_check_ccq(struct qdio_q *q, unsigned int ccq)
97 {
98         char dbf_text[15];
99
100         /* all done or next buffer state different */
101         if (ccq == 0 || ccq == 32)
102                 return 0;
103         /* not all buffers processed */
104         if (ccq == 96 || ccq == 97)
105                 return 1;
106         /* notify devices immediately */
107         sprintf(dbf_text, "%d", ccq);
108         QDIO_DBF_TEXT2(1, trace, dbf_text);
109         return -EIO;
110 }
111
112 /**
113  * qdio_do_eqbs - extract buffer states for QEBSM
114  * @q: queue to manipulate
115  * @state: state of the extracted buffers
116  * @start: buffer number to start at
117  * @count: count of buffers to examine
118  *
119  * Returns the number of successfull extracted equal buffer states.
120  * Stops processing if a state is different from the last buffers state.
121  */
122 static int qdio_do_eqbs(struct qdio_q *q, unsigned char *state,
123                         int start, int count)
124 {
125         unsigned int ccq = 0;
126         int tmp_count = count, tmp_start = start;
127         int nr = q->nr;
128         int rc;
129         char dbf_text[15];
130
131         BUG_ON(!q->irq_ptr->sch_token);
132
133         if (!q->is_input_q)
134                 nr += q->irq_ptr->nr_input_qs;
135 again:
136         ccq = do_eqbs(q->irq_ptr->sch_token, state, nr, &tmp_start, &tmp_count);
137         rc = qdio_check_ccq(q, ccq);
138
139         /* At least one buffer was processed, return and extract the remaining
140          * buffers later.
141          */
142         if ((ccq == 96) && (count != tmp_count))
143                 return (count - tmp_count);
144         if (rc == 1) {
145                 QDIO_DBF_TEXT5(1, trace, "eqAGAIN");
146                 goto again;
147         }
148
149         if (rc < 0) {
150                 QDIO_DBF_TEXT2(1, trace, "eqberr");
151                 sprintf(dbf_text, "%2x,%2x,%d,%d", count, tmp_count, ccq, nr);
152                 QDIO_DBF_TEXT2(1, trace, dbf_text);
153                 q->handler(q->irq_ptr->cdev,
154                            QDIO_ERROR_ACTIVATE_CHECK_CONDITION,
155                            0, -1, -1, q->irq_ptr->int_parm);
156                 return 0;
157         }
158         return count - tmp_count;
159 }
160
161 /**
162  * qdio_do_sqbs - set buffer states for QEBSM
163  * @q: queue to manipulate
164  * @state: new state of the buffers
165  * @start: first buffer number to change
166  * @count: how many buffers to change
167  *
168  * Returns the number of successfully changed buffers.
169  * Does retrying until the specified count of buffer states is set or an
170  * error occurs.
171  */
172 static int qdio_do_sqbs(struct qdio_q *q, unsigned char state, int start,
173                         int count)
174 {
175         unsigned int ccq = 0;
176         int tmp_count = count, tmp_start = start;
177         int nr = q->nr;
178         int rc;
179         char dbf_text[15];
180
181         BUG_ON(!q->irq_ptr->sch_token);
182
183         if (!q->is_input_q)
184                 nr += q->irq_ptr->nr_input_qs;
185 again:
186         ccq = do_sqbs(q->irq_ptr->sch_token, state, nr, &tmp_start, &tmp_count);
187         rc = qdio_check_ccq(q, ccq);
188         if (rc == 1) {
189                 QDIO_DBF_TEXT5(1, trace, "sqAGAIN");
190                 goto again;
191         }
192         if (rc < 0) {
193                 QDIO_DBF_TEXT3(1, trace, "sqberr");
194                 sprintf(dbf_text, "%2x,%2x", count, tmp_count);
195                 QDIO_DBF_TEXT3(1, trace, dbf_text);
196                 sprintf(dbf_text, "%d,%d", ccq, nr);
197                 QDIO_DBF_TEXT3(1, trace, dbf_text);
198
199                 q->handler(q->irq_ptr->cdev,
200                            QDIO_ERROR_ACTIVATE_CHECK_CONDITION,
201                            0, -1, -1, q->irq_ptr->int_parm);
202                 return 0;
203         }
204         WARN_ON(tmp_count);
205         return count - tmp_count;
206 }
207
208 /* returns number of examined buffers and their common state in *state */
209 static inline int get_buf_states(struct qdio_q *q, unsigned int bufnr,
210                                  unsigned char *state, unsigned int count)
211 {
212         unsigned char __state = 0;
213         int i;
214
215         BUG_ON(bufnr > QDIO_MAX_BUFFERS_MASK);
216         BUG_ON(count > QDIO_MAX_BUFFERS_PER_Q);
217
218         if (is_qebsm(q))
219                 return qdio_do_eqbs(q, state, bufnr, count);
220
221         for (i = 0; i < count; i++) {
222                 if (!__state)
223                         __state = q->slsb.val[bufnr];
224                 else if (q->slsb.val[bufnr] != __state)
225                         break;
226                 bufnr = next_buf(bufnr);
227         }
228         *state = __state;
229         return i;
230 }
231
232 inline int get_buf_state(struct qdio_q *q, unsigned int bufnr,
233                   unsigned char *state)
234 {
235         return get_buf_states(q, bufnr, state, 1);
236 }
237
238 /* wrap-around safe setting of slsb states, returns number of changed buffers */
239 static inline int set_buf_states(struct qdio_q *q, int bufnr,
240                                  unsigned char state, int count)
241 {
242         int i;
243
244         BUG_ON(bufnr > QDIO_MAX_BUFFERS_MASK);
245         BUG_ON(count > QDIO_MAX_BUFFERS_PER_Q);
246
247         if (is_qebsm(q))
248                 return qdio_do_sqbs(q, state, bufnr, count);
249
250         for (i = 0; i < count; i++) {
251                 xchg(&q->slsb.val[bufnr], state);
252                 bufnr = next_buf(bufnr);
253         }
254         return count;
255 }
256
257 static inline int set_buf_state(struct qdio_q *q, int bufnr,
258                                 unsigned char state)
259 {
260         return set_buf_states(q, bufnr, state, 1);
261 }
262
263 /* set slsb states to initial state */
264 void qdio_init_buf_states(struct qdio_irq *irq_ptr)
265 {
266         struct qdio_q *q;
267         int i;
268
269         for_each_input_queue(irq_ptr, q, i)
270                 set_buf_states(q, 0, SLSB_P_INPUT_NOT_INIT,
271                                QDIO_MAX_BUFFERS_PER_Q);
272         for_each_output_queue(irq_ptr, q, i)
273                 set_buf_states(q, 0, SLSB_P_OUTPUT_NOT_INIT,
274                                QDIO_MAX_BUFFERS_PER_Q);
275 }
276
277 static int qdio_siga_sync(struct qdio_q *q, unsigned int output,
278                           unsigned int input)
279 {
280         int cc;
281
282         if (!need_siga_sync(q))
283                 return 0;
284
285         qdio_perf_stat_inc(&perf_stats.siga_sync);
286
287         cc = do_siga_sync(q->irq_ptr->schid, output, input);
288         if (cc) {
289                 QDIO_DBF_TEXT4(0, trace, "sigasync");
290                 QDIO_DBF_HEX4(0, trace, &q, sizeof(void *));
291                 QDIO_DBF_HEX3(0, trace, &cc, sizeof(int *));
292         }
293         return cc;
294 }
295
296 inline int qdio_siga_sync_q(struct qdio_q *q)
297 {
298         if (q->is_input_q)
299                 return qdio_siga_sync(q, 0, q->mask);
300         else
301                 return qdio_siga_sync(q, q->mask, 0);
302 }
303
304 static inline int qdio_siga_sync_out(struct qdio_q *q)
305 {
306         return qdio_siga_sync(q, ~0U, 0);
307 }
308
309 static inline int qdio_siga_sync_all(struct qdio_q *q)
310 {
311         return qdio_siga_sync(q, ~0U, ~0U);
312 }
313
314 static inline int qdio_do_siga_output(struct qdio_q *q, unsigned int *busy_bit)
315 {
316         unsigned int fc = 0;
317         unsigned long schid;
318
319         if (!is_qebsm(q))
320                 schid = *((u32 *)&q->irq_ptr->schid);
321         else {
322                 schid = q->irq_ptr->sch_token;
323                 fc |= 0x80;
324         }
325         return do_siga_output(schid, q->mask, busy_bit, fc);
326 }
327
328 static int qdio_siga_output(struct qdio_q *q)
329 {
330         int cc;
331         u32 busy_bit;
332         u64 start_time = 0;
333
334         QDIO_DBF_TEXT5(0, trace, "sigaout");
335         QDIO_DBF_HEX5(0, trace, &q, sizeof(void *));
336
337         qdio_perf_stat_inc(&perf_stats.siga_out);
338 again:
339         cc = qdio_do_siga_output(q, &busy_bit);
340         if (queue_type(q) == QDIO_IQDIO_QFMT && cc == 2 && busy_bit) {
341                 if (!start_time)
342                         start_time = get_usecs();
343                 else if ((get_usecs() - start_time) < QDIO_BUSY_BIT_PATIENCE)
344                         goto again;
345         }
346
347         if (cc == 2 && busy_bit)
348                 cc |= QDIO_ERROR_SIGA_BUSY;
349         if (cc)
350                 QDIO_DBF_HEX3(0, trace, &cc, sizeof(int *));
351         return cc;
352 }
353
354 static inline int qdio_siga_input(struct qdio_q *q)
355 {
356         int cc;
357
358         QDIO_DBF_TEXT4(0, trace, "sigain");
359         QDIO_DBF_HEX4(0, trace, &q, sizeof(void *));
360
361         qdio_perf_stat_inc(&perf_stats.siga_in);
362
363         cc = do_siga_input(q->irq_ptr->schid, q->mask);
364         if (cc)
365                 QDIO_DBF_HEX3(0, trace, &cc, sizeof(int *));
366         return cc;
367 }
368
369 /* called from thinint inbound handler */
370 void qdio_sync_after_thinint(struct qdio_q *q)
371 {
372         if (pci_out_supported(q)) {
373                 if (need_siga_sync_thinint(q))
374                         qdio_siga_sync_all(q);
375                 else if (need_siga_sync_out_thinint(q))
376                         qdio_siga_sync_out(q);
377         } else
378                 qdio_siga_sync_q(q);
379 }
380
381 inline void qdio_stop_polling(struct qdio_q *q)
382 {
383         spin_lock_bh(&q->u.in.lock);
384         if (!q->u.in.polling) {
385                 spin_unlock_bh(&q->u.in.lock);
386                 return;
387         }
388         q->u.in.polling = 0;
389         qdio_perf_stat_inc(&perf_stats.debug_stop_polling);
390
391         /* show the card that we are not polling anymore */
392         set_buf_state(q, q->last_move_ftc, SLSB_P_INPUT_NOT_INIT);
393         spin_unlock_bh(&q->u.in.lock);
394 }
395
396 static void announce_buffer_error(struct qdio_q *q)
397 {
398         char dbf_text[15];
399
400         if (q->is_input_q)
401                 QDIO_DBF_TEXT3(1, trace, "inperr");
402         else
403                 QDIO_DBF_TEXT3(0, trace, "outperr");
404
405         sprintf(dbf_text, "%x-%x-%x", q->first_to_check,
406                 q->sbal[q->first_to_check]->element[14].flags,
407                 q->sbal[q->first_to_check]->element[15].flags);
408         QDIO_DBF_TEXT3(1, trace, dbf_text);
409         QDIO_DBF_HEX2(1, trace, q->sbal[q->first_to_check], 256);
410
411         q->qdio_error = QDIO_ERROR_SLSB_STATE;
412 }
413
414 static int get_inbound_buffer_frontier(struct qdio_q *q)
415 {
416         int count, stop;
417         unsigned char state;
418
419         /*
420          * If we still poll don't update last_move_ftc, keep the
421          * previously ACK buffer there.
422          */
423         if (!q->u.in.polling)
424                 q->last_move_ftc = q->first_to_check;
425
426         /*
427          * Don't check 128 buffers, as otherwise qdio_inbound_q_moved
428          * would return 0.
429          */
430         count = min(atomic_read(&q->nr_buf_used), QDIO_MAX_BUFFERS_MASK);
431         stop = add_buf(q->first_to_check, count);
432
433         /*
434          * No siga sync here, as a PCI or we after a thin interrupt
435          * will sync the queues.
436          */
437
438         /* need to set count to 1 for non-qebsm */
439         if (!is_qebsm(q))
440                 count = 1;
441
442 check_next:
443         if (q->first_to_check == stop)
444                 goto out;
445
446         count = get_buf_states(q, q->first_to_check, &state, count);
447         if (!count)
448                 goto out;
449
450         switch (state) {
451         case SLSB_P_INPUT_PRIMED:
452                 QDIO_DBF_TEXT5(0, trace, "inptprim");
453
454                 /*
455                  * Only ACK the first buffer. The ACK will be removed in
456                  * qdio_stop_polling.
457                  */
458                 if (q->u.in.polling)
459                         state = SLSB_P_INPUT_NOT_INIT;
460                 else {
461                         q->u.in.polling = 1;
462                         state = SLSB_P_INPUT_ACK;
463                 }
464                 set_buf_state(q, q->first_to_check, state);
465
466                 /*
467                  * Need to change all PRIMED buffers to NOT_INIT, otherwise
468                  * we're loosing initiative in the thinint code.
469                  */
470                 if (count > 1)
471                         set_buf_states(q, next_buf(q->first_to_check),
472                                        SLSB_P_INPUT_NOT_INIT, count - 1);
473
474                 /*
475                  * No siga-sync needed for non-qebsm here, as the inbound queue
476                  * will be synced on the next siga-r, resp.
477                  * tiqdio_is_inbound_q_done will do the siga-sync.
478                  */
479                 q->first_to_check = add_buf(q->first_to_check, count);
480                 atomic_sub(count, &q->nr_buf_used);
481                 goto check_next;
482         case SLSB_P_INPUT_ERROR:
483                 announce_buffer_error(q);
484                 /* process the buffer, the upper layer will take care of it */
485                 q->first_to_check = add_buf(q->first_to_check, count);
486                 atomic_sub(count, &q->nr_buf_used);
487                 break;
488         case SLSB_CU_INPUT_EMPTY:
489         case SLSB_P_INPUT_NOT_INIT:
490         case SLSB_P_INPUT_ACK:
491                 QDIO_DBF_TEXT5(0, trace, "inpnipro");
492                 break;
493         default:
494                 BUG();
495         }
496 out:
497         QDIO_DBF_HEX4(0, trace, &q->first_to_check, sizeof(int));
498         return q->first_to_check;
499 }
500
501 int qdio_inbound_q_moved(struct qdio_q *q)
502 {
503         int bufnr;
504
505         bufnr = get_inbound_buffer_frontier(q);
506
507         if ((bufnr != q->last_move_ftc) || q->qdio_error) {
508                 if (!need_siga_sync(q) && !pci_out_supported(q))
509                         q->u.in.timestamp = get_usecs();
510
511                 QDIO_DBF_TEXT4(0, trace, "inhasmvd");
512                 QDIO_DBF_HEX4(0, trace, &q, sizeof(void *));
513                 return 1;
514         } else
515                 return 0;
516 }
517
518 static int qdio_inbound_q_done(struct qdio_q *q)
519 {
520         unsigned char state;
521 #ifdef CONFIG_QDIO_DEBUG
522         char dbf_text[15];
523 #endif
524
525         if (!atomic_read(&q->nr_buf_used))
526                 return 1;
527
528         /*
529          * We need that one for synchronization with the adapter, as it
530          * does a kind of PCI avoidance.
531          */
532         qdio_siga_sync_q(q);
533
534         get_buf_state(q, q->first_to_check, &state);
535         if (state == SLSB_P_INPUT_PRIMED)
536                 /* we got something to do */
537                 return 0;
538
539         /* on VM, we don't poll, so the q is always done here */
540         if (need_siga_sync(q) || pci_out_supported(q))
541                 return 1;
542
543         /*
544          * At this point we know, that inbound first_to_check
545          * has (probably) not moved (see qdio_inbound_processing).
546          */
547         if (get_usecs() > q->u.in.timestamp + QDIO_INPUT_THRESHOLD) {
548 #ifdef CONFIG_QDIO_DEBUG
549                 QDIO_DBF_TEXT4(0, trace, "inqisdon");
550                 QDIO_DBF_HEX4(0, trace, &q, sizeof(void *));
551                 sprintf(dbf_text, "pf%02x", q->first_to_check);
552                 QDIO_DBF_TEXT4(0, trace, dbf_text);
553 #endif /* CONFIG_QDIO_DEBUG */
554                 return 1;
555         } else {
556 #ifdef CONFIG_QDIO_DEBUG
557                 QDIO_DBF_TEXT4(0, trace, "inqisntd");
558                 QDIO_DBF_HEX4(0, trace, &q, sizeof(void *));
559                 sprintf(dbf_text, "pf%02x", q->first_to_check);
560                 QDIO_DBF_TEXT4(0, trace, dbf_text);
561 #endif /* CONFIG_QDIO_DEBUG */
562                 return 0;
563         }
564 }
565
566 void qdio_kick_inbound_handler(struct qdio_q *q)
567 {
568         int count, start, end;
569 #ifdef CONFIG_QDIO_DEBUG
570         char dbf_text[15];
571 #endif
572
573         qdio_perf_stat_inc(&perf_stats.inbound_handler);
574
575         start = q->first_to_kick;
576         end = q->first_to_check;
577         if (end >= start)
578                 count = end - start;
579         else
580                 count = end + QDIO_MAX_BUFFERS_PER_Q - start;
581
582 #ifdef CONFIG_QDIO_DEBUG
583         sprintf(dbf_text, "s=%2xc=%2x", start, count);
584         QDIO_DBF_TEXT4(0, trace, dbf_text);
585 #endif /* CONFIG_QDIO_DEBUG */
586
587         if (unlikely(q->irq_ptr->state != QDIO_IRQ_STATE_ACTIVE))
588                 return;
589
590         q->handler(q->irq_ptr->cdev, q->qdio_error, q->nr,
591                    start, count, q->irq_ptr->int_parm);
592
593         /* for the next time */
594         q->first_to_kick = q->first_to_check;
595         q->qdio_error = 0;
596 }
597
598 static void __qdio_inbound_processing(struct qdio_q *q)
599 {
600         qdio_perf_stat_inc(&perf_stats.tasklet_inbound);
601 again:
602         if (!qdio_inbound_q_moved(q))
603                 return;
604
605         qdio_kick_inbound_handler(q);
606
607         if (!qdio_inbound_q_done(q))
608                 /* means poll time is not yet over */
609                 goto again;
610
611         qdio_stop_polling(q);
612         /*
613          * We need to check again to not lose initiative after
614          * resetting the ACK state.
615          */
616         if (!qdio_inbound_q_done(q))
617                 goto again;
618 }
619
620 /* inbound tasklet */
621 void qdio_inbound_processing(unsigned long data)
622 {
623         struct qdio_q *q = (struct qdio_q *)data;
624         __qdio_inbound_processing(q);
625 }
626
627 static int get_outbound_buffer_frontier(struct qdio_q *q)
628 {
629         int count, stop;
630         unsigned char state;
631
632         if (((queue_type(q) != QDIO_IQDIO_QFMT) && !pci_out_supported(q)) ||
633             (queue_type(q) == QDIO_IQDIO_QFMT && multicast_outbound(q)))
634                 qdio_siga_sync_q(q);
635
636         /*
637          * Don't check 128 buffers, as otherwise qdio_inbound_q_moved
638          * would return 0.
639          */
640         count = min(atomic_read(&q->nr_buf_used), QDIO_MAX_BUFFERS_MASK);
641         stop = add_buf(q->first_to_check, count);
642
643         /* need to set count to 1 for non-qebsm */
644         if (!is_qebsm(q))
645                 count = 1;
646
647 check_next:
648         if (q->first_to_check == stop)
649                 return q->first_to_check;
650
651         count = get_buf_states(q, q->first_to_check, &state, count);
652         if (!count)
653                 return q->first_to_check;
654
655         switch (state) {
656         case SLSB_P_OUTPUT_EMPTY:
657                 /* the adapter got it */
658                 QDIO_DBF_TEXT5(0, trace, "outpempt");
659
660                 atomic_sub(count, &q->nr_buf_used);
661                 q->first_to_check = add_buf(q->first_to_check, count);
662                 /*
663                  * We fetch all buffer states at once. get_buf_states may
664                  * return count < stop. For QEBSM we do not loop.
665                  */
666                 if (is_qebsm(q))
667                         break;
668                 goto check_next;
669         case SLSB_P_OUTPUT_ERROR:
670                 announce_buffer_error(q);
671                 /* process the buffer, the upper layer will take care of it */
672                 q->first_to_check = add_buf(q->first_to_check, count);
673                 atomic_sub(count, &q->nr_buf_used);
674                 break;
675         case SLSB_CU_OUTPUT_PRIMED:
676                 /* the adapter has not fetched the output yet */
677                 QDIO_DBF_TEXT5(0, trace, "outpprim");
678                 break;
679         case SLSB_P_OUTPUT_NOT_INIT:
680         case SLSB_P_OUTPUT_HALTED:
681                 break;
682         default:
683                 BUG();
684         }
685         return q->first_to_check;
686 }
687
688 /* all buffers processed? */
689 static inline int qdio_outbound_q_done(struct qdio_q *q)
690 {
691         return atomic_read(&q->nr_buf_used) == 0;
692 }
693
694 static inline int qdio_outbound_q_moved(struct qdio_q *q)
695 {
696         int bufnr;
697
698         bufnr = get_outbound_buffer_frontier(q);
699
700         if ((bufnr != q->last_move_ftc) || q->qdio_error) {
701                 q->last_move_ftc = bufnr;
702                 QDIO_DBF_TEXT4(0, trace, "oqhasmvd");
703                 QDIO_DBF_HEX4(0, trace, &q, sizeof(void *));
704                 return 1;
705         } else
706                 return 0;
707 }
708
709 /*
710  * VM could present us cc=2 and busy bit set on SIGA-write
711  * during reconfiguration of their Guest LAN (only in iqdio mode,
712  * otherwise qdio is asynchronous and cc=2 and busy bit there will take
713  * the queues down immediately).
714  *
715  * Therefore qdio_siga_output will try for a short time constantly,
716  * if such a condition occurs. If it doesn't change, it will
717  * increase the busy_siga_counter and save the timestamp, and
718  * schedule the queue for later processing. qdio_outbound_processing
719  * will check out the counter. If non-zero, it will call qdio_kick_outbound_q
720  * as often as the value of the counter. This will attempt further SIGA
721  * instructions. For each successful SIGA, the counter is
722  * decreased, for failing SIGAs the counter remains the same, after
723  * all. After some time of no movement, qdio_kick_outbound_q will
724  * finally fail and reflect corresponding error codes to call
725  * the upper layer module and have it take the queues down.
726  *
727  * Note that this is a change from the original HiperSockets design
728  * (saying cc=2 and busy bit means take the queues down), but in
729  * these days Guest LAN didn't exist... excessive cc=2 with busy bit
730  * conditions will still take the queues down, but the threshold is
731  * higher due to the Guest LAN environment.
732  *
733  * Called from outbound tasklet and do_QDIO handler.
734  */
735 static void qdio_kick_outbound_q(struct qdio_q *q)
736 {
737         int rc;
738 #ifdef CONFIG_QDIO_DEBUG
739         char dbf_text[15];
740
741         QDIO_DBF_TEXT5(0, trace, "kickoutq");
742         QDIO_DBF_HEX5(0, trace, &q, sizeof(void *));
743 #endif /* CONFIG_QDIO_DEBUG */
744
745         if (!need_siga_out(q))
746                 return;
747
748         rc = qdio_siga_output(q);
749         switch (rc) {
750         case 0:
751                 /* went smooth this time, reset timestamp */
752                 q->u.out.timestamp = 0;
753
754                 /* TODO: improve error handling for CC=0 case */
755 #ifdef CONFIG_QDIO_DEBUG
756                 QDIO_DBF_TEXT3(0, trace, "cc2reslv");
757                 sprintf(dbf_text, "%4x%2x%2x", q->irq_ptr->schid.sch_no, q->nr,
758                         atomic_read(&q->u.out.busy_siga_counter));
759                 QDIO_DBF_TEXT3(0, trace, dbf_text);
760 #endif /* CONFIG_QDIO_DEBUG */
761                 break;
762         /* cc=2 and busy bit */
763         case (2 | QDIO_ERROR_SIGA_BUSY):
764                 atomic_inc(&q->u.out.busy_siga_counter);
765
766                 /* if the last siga was successful, save timestamp here */
767                 if (!q->u.out.timestamp)
768                         q->u.out.timestamp = get_usecs();
769
770                 /* if we're in time, don't touch qdio_error */
771                 if (get_usecs() - q->u.out.timestamp < QDIO_BUSY_BIT_GIVE_UP) {
772                         tasklet_schedule(&q->tasklet);
773                         break;
774                 }
775                 QDIO_DBF_TEXT2(0, trace, "cc2REPRT");
776 #ifdef CONFIG_QDIO_DEBUG
777                 sprintf(dbf_text, "%4x%2x%2x", q->irq_ptr->schid.sch_no, q->nr,
778                         atomic_read(&q->u.out.busy_siga_counter));
779                 QDIO_DBF_TEXT3(0, trace, dbf_text);
780 #endif /* CONFIG_QDIO_DEBUG */
781         default:
782                 /* for plain cc=1, 2 or 3 */
783                 q->qdio_error = rc;
784         }
785 }
786
787 static void qdio_kick_outbound_handler(struct qdio_q *q)
788 {
789         int start, end, count;
790 #ifdef CONFIG_QDIO_DEBUG
791         char dbf_text[15];
792 #endif
793
794         start = q->first_to_kick;
795         end = q->last_move_ftc;
796         if (end >= start)
797                 count = end - start;
798         else
799                 count = end + QDIO_MAX_BUFFERS_PER_Q - start;
800
801 #ifdef CONFIG_QDIO_DEBUG
802         QDIO_DBF_TEXT4(0, trace, "kickouth");
803         QDIO_DBF_HEX4(0, trace, &q, sizeof(void *));
804
805         sprintf(dbf_text, "s=%2xc=%2x", start, count);
806         QDIO_DBF_TEXT4(0, trace, dbf_text);
807 #endif /* CONFIG_QDIO_DEBUG */
808
809         if (unlikely(q->irq_ptr->state != QDIO_IRQ_STATE_ACTIVE))
810                 return;
811
812         q->handler(q->irq_ptr->cdev, q->qdio_error, q->nr, start, count,
813                    q->irq_ptr->int_parm);
814
815         /* for the next time: */
816         q->first_to_kick = q->last_move_ftc;
817         q->qdio_error = 0;
818 }
819
820 static void __qdio_outbound_processing(struct qdio_q *q)
821 {
822         int siga_attempts;
823
824         qdio_perf_stat_inc(&perf_stats.tasklet_outbound);
825
826         /* see comment in qdio_kick_outbound_q */
827         siga_attempts = atomic_read(&q->u.out.busy_siga_counter);
828         while (siga_attempts--) {
829                 atomic_dec(&q->u.out.busy_siga_counter);
830                 qdio_kick_outbound_q(q);
831         }
832
833         BUG_ON(atomic_read(&q->nr_buf_used) < 0);
834
835         if (qdio_outbound_q_moved(q))
836                 qdio_kick_outbound_handler(q);
837
838         if (queue_type(q) == QDIO_ZFCP_QFMT) {
839                 if (!pci_out_supported(q) && !qdio_outbound_q_done(q))
840                         tasklet_schedule(&q->tasklet);
841                 return;
842         }
843
844         /* bail out for HiperSockets unicast queues */
845         if (queue_type(q) == QDIO_IQDIO_QFMT && !multicast_outbound(q))
846                 return;
847
848         if (q->u.out.pci_out_enabled)
849                 return;
850
851         /*
852          * Now we know that queue type is either qeth without pci enabled
853          * or HiperSockets multicast. Make sure buffer switch from PRIMED to
854          * EMPTY is noticed and outbound_handler is called after some time.
855          */
856         if (qdio_outbound_q_done(q))
857                 del_timer(&q->u.out.timer);
858         else {
859                 if (!timer_pending(&q->u.out.timer)) {
860                         mod_timer(&q->u.out.timer, jiffies + 10 * HZ);
861                         qdio_perf_stat_inc(&perf_stats.debug_tl_out_timer);
862                 }
863         }
864 }
865
866 /* outbound tasklet */
867 void qdio_outbound_processing(unsigned long data)
868 {
869         struct qdio_q *q = (struct qdio_q *)data;
870         __qdio_outbound_processing(q);
871 }
872
873 void qdio_outbound_timer(unsigned long data)
874 {
875         struct qdio_q *q = (struct qdio_q *)data;
876         tasklet_schedule(&q->tasklet);
877 }
878
879 /* called from thinint inbound tasklet */
880 void qdio_check_outbound_after_thinint(struct qdio_q *q)
881 {
882         struct qdio_q *out;
883         int i;
884
885         if (!pci_out_supported(q))
886                 return;
887
888         for_each_output_queue(q->irq_ptr, out, i)
889                 if (!qdio_outbound_q_done(out))
890                         tasklet_schedule(&out->tasklet);
891 }
892
893 static inline void qdio_set_state(struct qdio_irq *irq_ptr,
894                                   enum qdio_irq_states state)
895 {
896 #ifdef CONFIG_QDIO_DEBUG
897         char dbf_text[15];
898
899         QDIO_DBF_TEXT5(0, trace, "newstate");
900         sprintf(dbf_text, "%4x%4x", irq_ptr->schid.sch_no, state);
901         QDIO_DBF_TEXT5(0, trace, dbf_text);
902 #endif /* CONFIG_QDIO_DEBUG */
903
904         irq_ptr->state = state;
905         mb();
906 }
907
908 static void qdio_irq_check_sense(struct subchannel_id schid, struct irb *irb)
909 {
910         char dbf_text[15];
911
912         if (irb->esw.esw0.erw.cons) {
913                 sprintf(dbf_text, "sens%4x", schid.sch_no);
914                 QDIO_DBF_TEXT2(1, trace, dbf_text);
915                 QDIO_DBF_HEX0(0, trace, irb, 64);
916                 QDIO_DBF_HEX0(0, trace, irb->ecw, 64);
917         }
918 }
919
920 /* PCI interrupt handler */
921 static void qdio_int_handler_pci(struct qdio_irq *irq_ptr)
922 {
923         int i;
924         struct qdio_q *q;
925
926         qdio_perf_stat_inc(&perf_stats.pci_int);
927
928         for_each_input_queue(irq_ptr, q, i)
929                 tasklet_schedule(&q->tasklet);
930
931         if (!(irq_ptr->qib.ac & QIB_AC_OUTBOUND_PCI_SUPPORTED))
932                 return;
933
934         for_each_output_queue(irq_ptr, q, i) {
935                 if (qdio_outbound_q_done(q))
936                         continue;
937
938                 if (!siga_syncs_out_pci(q))
939                         qdio_siga_sync_q(q);
940
941                 tasklet_schedule(&q->tasklet);
942         }
943 }
944
945 static void qdio_handle_activate_check(struct ccw_device *cdev,
946                                 unsigned long intparm, int cstat, int dstat)
947 {
948         struct qdio_irq *irq_ptr = cdev->private->qdio_data;
949         struct qdio_q *q;
950         char dbf_text[15];
951
952         QDIO_DBF_TEXT2(1, trace, "ick2");
953         sprintf(dbf_text, "%s", cdev->dev.bus_id);
954         QDIO_DBF_TEXT2(1, trace, dbf_text);
955         QDIO_DBF_HEX2(0, trace, &intparm, sizeof(int));
956         QDIO_DBF_HEX2(0, trace, &dstat, sizeof(int));
957         QDIO_DBF_HEX2(0, trace, &cstat, sizeof(int));
958
959         if (irq_ptr->nr_input_qs) {
960                 q = irq_ptr->input_qs[0];
961         } else if (irq_ptr->nr_output_qs) {
962                 q = irq_ptr->output_qs[0];
963         } else {
964                 dump_stack();
965                 goto no_handler;
966         }
967         q->handler(q->irq_ptr->cdev, QDIO_ERROR_ACTIVATE_CHECK_CONDITION,
968                    0, -1, -1, irq_ptr->int_parm);
969 no_handler:
970         qdio_set_state(irq_ptr, QDIO_IRQ_STATE_STOPPED);
971 }
972
973 static void qdio_call_shutdown(struct work_struct *work)
974 {
975         struct ccw_device_private *priv;
976         struct ccw_device *cdev;
977
978         priv = container_of(work, struct ccw_device_private, kick_work);
979         cdev = priv->cdev;
980         qdio_shutdown(cdev, QDIO_FLAG_CLEANUP_USING_CLEAR);
981         put_device(&cdev->dev);
982 }
983
984 static void qdio_int_error(struct ccw_device *cdev)
985 {
986         struct qdio_irq *irq_ptr = cdev->private->qdio_data;
987
988         switch (irq_ptr->state) {
989         case QDIO_IRQ_STATE_INACTIVE:
990         case QDIO_IRQ_STATE_CLEANUP:
991                 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_ERR);
992                 break;
993         case QDIO_IRQ_STATE_ESTABLISHED:
994         case QDIO_IRQ_STATE_ACTIVE:
995                 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_STOPPED);
996                 if (get_device(&cdev->dev)) {
997                         /* Can't call shutdown from interrupt context. */
998                         PREPARE_WORK(&cdev->private->kick_work,
999                                      qdio_call_shutdown);
1000                         queue_work(ccw_device_work, &cdev->private->kick_work);
1001                 }
1002                 break;
1003         default:
1004                 WARN_ON(1);
1005         }
1006         wake_up(&cdev->private->wait_q);
1007 }
1008
1009 static int qdio_establish_check_errors(struct ccw_device *cdev, int cstat,
1010                                            int dstat)
1011 {
1012         struct qdio_irq *irq_ptr = cdev->private->qdio_data;
1013
1014         if (cstat || (dstat & ~(DEV_STAT_CHN_END | DEV_STAT_DEV_END))) {
1015                 QDIO_DBF_TEXT2(1, setup, "eq:ckcon");
1016                 goto error;
1017         }
1018
1019         if (!(dstat & DEV_STAT_DEV_END)) {
1020                 QDIO_DBF_TEXT2(1, setup, "eq:no de");
1021                 goto error;
1022         }
1023
1024         if (dstat & ~(DEV_STAT_CHN_END | DEV_STAT_DEV_END)) {
1025                 QDIO_DBF_TEXT2(1, setup, "eq:badio");
1026                 goto error;
1027         }
1028         return 0;
1029 error:
1030         QDIO_DBF_HEX2(0, trace, &cstat, sizeof(int));
1031         QDIO_DBF_HEX2(0, trace, &dstat, sizeof(int));
1032         qdio_set_state(irq_ptr, QDIO_IRQ_STATE_ERR);
1033         return 1;
1034 }
1035
1036 static void qdio_establish_handle_irq(struct ccw_device *cdev, int cstat,
1037                                       int dstat)
1038 {
1039         struct qdio_irq *irq_ptr = cdev->private->qdio_data;
1040         char dbf_text[15];
1041
1042         sprintf(dbf_text, "qehi%4x", cdev->private->schid.sch_no);
1043         QDIO_DBF_TEXT0(0, setup, dbf_text);
1044         QDIO_DBF_TEXT0(0, trace, dbf_text);
1045
1046         if (!qdio_establish_check_errors(cdev, cstat, dstat))
1047                 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_ESTABLISHED);
1048 }
1049
1050 /* qdio interrupt handler */
1051 void qdio_int_handler(struct ccw_device *cdev, unsigned long intparm,
1052                       struct irb *irb)
1053 {
1054         struct qdio_irq *irq_ptr = cdev->private->qdio_data;
1055         int cstat, dstat;
1056         char dbf_text[15];
1057
1058         qdio_perf_stat_inc(&perf_stats.qdio_int);
1059
1060         if (!intparm || !irq_ptr) {
1061                 sprintf(dbf_text, "qihd%4x", cdev->private->schid.sch_no);
1062                 QDIO_DBF_TEXT2(1, setup, dbf_text);
1063                 return;
1064         }
1065
1066         if (IS_ERR(irb)) {
1067                 switch (PTR_ERR(irb)) {
1068                 case -EIO:
1069                         sprintf(dbf_text, "ierr%4x",
1070                                 cdev->private->schid.sch_no);
1071                         QDIO_DBF_TEXT2(1, setup, dbf_text);
1072                         qdio_int_error(cdev);
1073                         return;
1074                 case -ETIMEDOUT:
1075                         sprintf(dbf_text, "qtoh%4x",
1076                                 cdev->private->schid.sch_no);
1077                         QDIO_DBF_TEXT2(1, setup, dbf_text);
1078                         qdio_int_error(cdev);
1079                         return;
1080                 default:
1081                         WARN_ON(1);
1082                         return;
1083                 }
1084         }
1085         qdio_irq_check_sense(irq_ptr->schid, irb);
1086
1087         cstat = irb->scsw.cmd.cstat;
1088         dstat = irb->scsw.cmd.dstat;
1089
1090         switch (irq_ptr->state) {
1091         case QDIO_IRQ_STATE_INACTIVE:
1092                 qdio_establish_handle_irq(cdev, cstat, dstat);
1093                 break;
1094
1095         case QDIO_IRQ_STATE_CLEANUP:
1096                 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_INACTIVE);
1097                 break;
1098
1099         case QDIO_IRQ_STATE_ESTABLISHED:
1100         case QDIO_IRQ_STATE_ACTIVE:
1101                 if (cstat & SCHN_STAT_PCI) {
1102                         qdio_int_handler_pci(irq_ptr);
1103                         /* no state change so no need to wake up wait_q */
1104                         return;
1105                 }
1106                 if ((cstat & ~SCHN_STAT_PCI) || dstat) {
1107                         qdio_handle_activate_check(cdev, intparm, cstat,
1108                                                    dstat);
1109                         break;
1110                 }
1111         default:
1112                 WARN_ON(1);
1113         }
1114         wake_up(&cdev->private->wait_q);
1115 }
1116
1117 /**
1118  * qdio_get_ssqd_desc - get qdio subchannel description
1119  * @cdev: ccw device to get description for
1120  *
1121  * Returns a pointer to the saved qdio subchannel description,
1122  * or NULL for not setup qdio devices.
1123  */
1124 struct qdio_ssqd_desc *qdio_get_ssqd_desc(struct ccw_device *cdev)
1125 {
1126         struct qdio_irq *irq_ptr;
1127
1128         QDIO_DBF_TEXT0(0, setup, "getssqd");
1129
1130         irq_ptr = cdev->private->qdio_data;
1131         if (!irq_ptr)
1132                 return NULL;
1133
1134         return &irq_ptr->ssqd_desc;
1135 }
1136 EXPORT_SYMBOL_GPL(qdio_get_ssqd_desc);
1137
1138 /**
1139  * qdio_cleanup - shutdown queues and free data structures
1140  * @cdev: associated ccw device
1141  * @how: use halt or clear to shutdown
1142  *
1143  * This function calls qdio_shutdown() for @cdev with method @how
1144  * and on success qdio_free() for @cdev.
1145  */
1146 int qdio_cleanup(struct ccw_device *cdev, int how)
1147 {
1148         struct qdio_irq *irq_ptr;
1149         char dbf_text[15];
1150         int rc;
1151
1152         irq_ptr = cdev->private->qdio_data;
1153         if (!irq_ptr)
1154                 return -ENODEV;
1155
1156         sprintf(dbf_text, "qcln%4x", irq_ptr->schid.sch_no);
1157         QDIO_DBF_TEXT1(0, trace, dbf_text);
1158         QDIO_DBF_TEXT0(0, setup, dbf_text);
1159
1160         rc = qdio_shutdown(cdev, how);
1161         if (rc == 0)
1162                 rc = qdio_free(cdev);
1163         return rc;
1164 }
1165 EXPORT_SYMBOL_GPL(qdio_cleanup);
1166
1167 static void qdio_shutdown_queues(struct ccw_device *cdev)
1168 {
1169         struct qdio_irq *irq_ptr = cdev->private->qdio_data;
1170         struct qdio_q *q;
1171         int i;
1172
1173         for_each_input_queue(irq_ptr, q, i)
1174                 tasklet_disable(&q->tasklet);
1175
1176         for_each_output_queue(irq_ptr, q, i) {
1177                 tasklet_disable(&q->tasklet);
1178                 del_timer(&q->u.out.timer);
1179         }
1180 }
1181
1182 /**
1183  * qdio_shutdown - shut down a qdio subchannel
1184  * @cdev: associated ccw device
1185  * @how: use halt or clear to shutdown
1186  */
1187 int qdio_shutdown(struct ccw_device *cdev, int how)
1188 {
1189         struct qdio_irq *irq_ptr;
1190         int rc;
1191         unsigned long flags;
1192         char dbf_text[15];
1193
1194         irq_ptr = cdev->private->qdio_data;
1195         if (!irq_ptr)
1196                 return -ENODEV;
1197
1198         mutex_lock(&irq_ptr->setup_mutex);
1199         /*
1200          * Subchannel was already shot down. We cannot prevent being called
1201          * twice since cio may trigger a shutdown asynchronously.
1202          */
1203         if (irq_ptr->state == QDIO_IRQ_STATE_INACTIVE) {
1204                 mutex_unlock(&irq_ptr->setup_mutex);
1205                 return 0;
1206         }
1207
1208         sprintf(dbf_text, "qsqs%4x", irq_ptr->schid.sch_no);
1209         QDIO_DBF_TEXT1(0, trace, dbf_text);
1210         QDIO_DBF_TEXT0(0, setup, dbf_text);
1211
1212         tiqdio_remove_input_queues(irq_ptr);
1213         qdio_shutdown_queues(cdev);
1214         qdio_shutdown_debug_entries(irq_ptr, cdev);
1215
1216         /* cleanup subchannel */
1217         spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
1218
1219         if (how & QDIO_FLAG_CLEANUP_USING_CLEAR)
1220                 rc = ccw_device_clear(cdev, QDIO_DOING_CLEANUP);
1221         else
1222                 /* default behaviour is halt */
1223                 rc = ccw_device_halt(cdev, QDIO_DOING_CLEANUP);
1224         if (rc) {
1225                 sprintf(dbf_text, "sher%4x", irq_ptr->schid.sch_no);
1226                 QDIO_DBF_TEXT0(0, setup, dbf_text);
1227                 sprintf(dbf_text, "rc=%d", rc);
1228                 QDIO_DBF_TEXT0(0, setup, dbf_text);
1229                 goto no_cleanup;
1230         }
1231
1232         qdio_set_state(irq_ptr, QDIO_IRQ_STATE_CLEANUP);
1233         spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
1234         wait_event_interruptible_timeout(cdev->private->wait_q,
1235                 irq_ptr->state == QDIO_IRQ_STATE_INACTIVE ||
1236                 irq_ptr->state == QDIO_IRQ_STATE_ERR,
1237                 10 * HZ);
1238         spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
1239
1240 no_cleanup:
1241         qdio_shutdown_thinint(irq_ptr);
1242
1243         /* restore interrupt handler */
1244         if ((void *)cdev->handler == (void *)qdio_int_handler)
1245                 cdev->handler = irq_ptr->orig_handler;
1246         spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
1247
1248         qdio_set_state(irq_ptr, QDIO_IRQ_STATE_INACTIVE);
1249         mutex_unlock(&irq_ptr->setup_mutex);
1250         module_put(THIS_MODULE);
1251         if (rc)
1252                 return rc;
1253         return 0;
1254 }
1255 EXPORT_SYMBOL_GPL(qdio_shutdown);
1256
1257 /**
1258  * qdio_free - free data structures for a qdio subchannel
1259  * @cdev: associated ccw device
1260  */
1261 int qdio_free(struct ccw_device *cdev)
1262 {
1263         struct qdio_irq *irq_ptr;
1264         char dbf_text[15];
1265
1266         irq_ptr = cdev->private->qdio_data;
1267         if (!irq_ptr)
1268                 return -ENODEV;
1269
1270         mutex_lock(&irq_ptr->setup_mutex);
1271
1272         sprintf(dbf_text, "qfqs%4x", irq_ptr->schid.sch_no);
1273         QDIO_DBF_TEXT1(0, trace, dbf_text);
1274         QDIO_DBF_TEXT0(0, setup, dbf_text);
1275
1276         cdev->private->qdio_data = NULL;
1277         mutex_unlock(&irq_ptr->setup_mutex);
1278
1279         qdio_release_memory(irq_ptr);
1280         return 0;
1281 }
1282 EXPORT_SYMBOL_GPL(qdio_free);
1283
1284 /**
1285  * qdio_initialize - allocate and establish queues for a qdio subchannel
1286  * @init_data: initialization data
1287  *
1288  * This function first allocates queues via qdio_allocate() and on success
1289  * establishes them via qdio_establish().
1290  */
1291 int qdio_initialize(struct qdio_initialize *init_data)
1292 {
1293         int rc;
1294         char dbf_text[15];
1295
1296         sprintf(dbf_text, "qini%4x", init_data->cdev->private->schid.sch_no);
1297         QDIO_DBF_TEXT0(0, setup, dbf_text);
1298         QDIO_DBF_TEXT0(0, trace, dbf_text);
1299
1300         rc = qdio_allocate(init_data);
1301         if (rc)
1302                 return rc;
1303
1304         rc = qdio_establish(init_data);
1305         if (rc)
1306                 qdio_free(init_data->cdev);
1307         return rc;
1308 }
1309 EXPORT_SYMBOL_GPL(qdio_initialize);
1310
1311 /**
1312  * qdio_allocate - allocate qdio queues and associated data
1313  * @init_data: initialization data
1314  */
1315 int qdio_allocate(struct qdio_initialize *init_data)
1316 {
1317         struct qdio_irq *irq_ptr;
1318         char dbf_text[15];
1319
1320         sprintf(dbf_text, "qalc%4x", init_data->cdev->private->schid.sch_no);
1321         QDIO_DBF_TEXT0(0, setup, dbf_text);
1322         QDIO_DBF_TEXT0(0, trace, dbf_text);
1323
1324         if ((init_data->no_input_qs && !init_data->input_handler) ||
1325             (init_data->no_output_qs && !init_data->output_handler))
1326                 return -EINVAL;
1327
1328         if ((init_data->no_input_qs > QDIO_MAX_QUEUES_PER_IRQ) ||
1329             (init_data->no_output_qs > QDIO_MAX_QUEUES_PER_IRQ))
1330                 return -EINVAL;
1331
1332         if ((!init_data->input_sbal_addr_array) ||
1333             (!init_data->output_sbal_addr_array))
1334                 return -EINVAL;
1335
1336         qdio_allocate_do_dbf(init_data);
1337
1338         /* irq_ptr must be in GFP_DMA since it contains ccw1.cda */
1339         irq_ptr = (void *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
1340         if (!irq_ptr)
1341                 goto out_err;
1342         QDIO_DBF_TEXT0(0, setup, "irq_ptr:");
1343         QDIO_DBF_HEX0(0, setup, &irq_ptr, sizeof(void *));
1344
1345         mutex_init(&irq_ptr->setup_mutex);
1346
1347         /*
1348          * Allocate a page for the chsc calls in qdio_establish.
1349          * Must be pre-allocated since a zfcp recovery will call
1350          * qdio_establish. In case of low memory and swap on a zfcp disk
1351          * we may not be able to allocate memory otherwise.
1352          */
1353         irq_ptr->chsc_page = get_zeroed_page(GFP_KERNEL);
1354         if (!irq_ptr->chsc_page)
1355                 goto out_rel;
1356
1357         /* qdr is used in ccw1.cda which is u32 */
1358         irq_ptr->qdr = (struct qdr *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
1359         if (!irq_ptr->qdr)
1360                 goto out_rel;
1361         WARN_ON((unsigned long)irq_ptr->qdr & 0xfff);
1362
1363         QDIO_DBF_TEXT0(0, setup, "qdr:");
1364         QDIO_DBF_HEX0(0, setup, &irq_ptr->qdr, sizeof(void *));
1365
1366         if (qdio_allocate_qs(irq_ptr, init_data->no_input_qs,
1367                              init_data->no_output_qs))
1368                 goto out_rel;
1369
1370         init_data->cdev->private->qdio_data = irq_ptr;
1371         qdio_set_state(irq_ptr, QDIO_IRQ_STATE_INACTIVE);
1372         return 0;
1373 out_rel:
1374         qdio_release_memory(irq_ptr);
1375 out_err:
1376         return -ENOMEM;
1377 }
1378 EXPORT_SYMBOL_GPL(qdio_allocate);
1379
1380 /**
1381  * qdio_establish - establish queues on a qdio subchannel
1382  * @init_data: initialization data
1383  */
1384 int qdio_establish(struct qdio_initialize *init_data)
1385 {
1386         char dbf_text[20];
1387         struct qdio_irq *irq_ptr;
1388         struct ccw_device *cdev = init_data->cdev;
1389         unsigned long saveflags;
1390         int rc;
1391
1392         irq_ptr = cdev->private->qdio_data;
1393         if (!irq_ptr)
1394                 return -ENODEV;
1395
1396         if (cdev->private->state != DEV_STATE_ONLINE)
1397                 return -EINVAL;
1398
1399         if (!try_module_get(THIS_MODULE))
1400                 return -EINVAL;
1401
1402         sprintf(dbf_text, "qest%4x", cdev->private->schid.sch_no);
1403         QDIO_DBF_TEXT0(0, setup, dbf_text);
1404         QDIO_DBF_TEXT0(0, trace, dbf_text);
1405
1406         mutex_lock(&irq_ptr->setup_mutex);
1407         qdio_setup_irq(init_data);
1408
1409         rc = qdio_establish_thinint(irq_ptr);
1410         if (rc) {
1411                 mutex_unlock(&irq_ptr->setup_mutex);
1412                 qdio_shutdown(cdev, QDIO_FLAG_CLEANUP_USING_CLEAR);
1413                 return rc;
1414         }
1415
1416         /* establish q */
1417         irq_ptr->ccw.cmd_code = irq_ptr->equeue.cmd;
1418         irq_ptr->ccw.flags = CCW_FLAG_SLI;
1419         irq_ptr->ccw.count = irq_ptr->equeue.count;
1420         irq_ptr->ccw.cda = (u32)((addr_t)irq_ptr->qdr);
1421
1422         spin_lock_irqsave(get_ccwdev_lock(cdev), saveflags);
1423         ccw_device_set_options_mask(cdev, 0);
1424
1425         rc = ccw_device_start(cdev, &irq_ptr->ccw, QDIO_DOING_ESTABLISH, 0, 0);
1426         if (rc) {
1427                 sprintf(dbf_text, "eq:io%4x", irq_ptr->schid.sch_no);
1428                 QDIO_DBF_TEXT2(1, setup, dbf_text);
1429                 sprintf(dbf_text, "eq:rc%4x", rc);
1430                 QDIO_DBF_TEXT2(1, setup, dbf_text);
1431         }
1432         spin_unlock_irqrestore(get_ccwdev_lock(cdev), saveflags);
1433
1434         if (rc) {
1435                 mutex_unlock(&irq_ptr->setup_mutex);
1436                 qdio_shutdown(cdev, QDIO_FLAG_CLEANUP_USING_CLEAR);
1437                 return rc;
1438         }
1439
1440         wait_event_interruptible_timeout(cdev->private->wait_q,
1441                 irq_ptr->state == QDIO_IRQ_STATE_ESTABLISHED ||
1442                 irq_ptr->state == QDIO_IRQ_STATE_ERR, HZ);
1443
1444         if (irq_ptr->state != QDIO_IRQ_STATE_ESTABLISHED) {
1445                 mutex_unlock(&irq_ptr->setup_mutex);
1446                 qdio_shutdown(cdev, QDIO_FLAG_CLEANUP_USING_CLEAR);
1447                 return -EIO;
1448         }
1449
1450         qdio_setup_ssqd_info(irq_ptr);
1451         sprintf(dbf_text, "qib ac%2x", irq_ptr->qib.ac);
1452         QDIO_DBF_TEXT2(0, setup, dbf_text);
1453
1454         /* qebsm is now setup if available, initialize buffer states */
1455         qdio_init_buf_states(irq_ptr);
1456
1457         mutex_unlock(&irq_ptr->setup_mutex);
1458         qdio_print_subchannel_info(irq_ptr, cdev);
1459         qdio_setup_debug_entries(irq_ptr, cdev);
1460         return 0;
1461 }
1462 EXPORT_SYMBOL_GPL(qdio_establish);
1463
1464 /**
1465  * qdio_activate - activate queues on a qdio subchannel
1466  * @cdev: associated cdev
1467  */
1468 int qdio_activate(struct ccw_device *cdev)
1469 {
1470         struct qdio_irq *irq_ptr;
1471         int rc;
1472         unsigned long saveflags;
1473         char dbf_text[20];
1474
1475         irq_ptr = cdev->private->qdio_data;
1476         if (!irq_ptr)
1477                 return -ENODEV;
1478
1479         if (cdev->private->state != DEV_STATE_ONLINE)
1480                 return -EINVAL;
1481
1482         mutex_lock(&irq_ptr->setup_mutex);
1483         if (irq_ptr->state == QDIO_IRQ_STATE_INACTIVE) {
1484                 rc = -EBUSY;
1485                 goto out;
1486         }
1487
1488         sprintf(dbf_text, "qact%4x", irq_ptr->schid.sch_no);
1489         QDIO_DBF_TEXT2(0, setup, dbf_text);
1490         QDIO_DBF_TEXT2(0, trace, dbf_text);
1491
1492         irq_ptr->ccw.cmd_code = irq_ptr->aqueue.cmd;
1493         irq_ptr->ccw.flags = CCW_FLAG_SLI;
1494         irq_ptr->ccw.count = irq_ptr->aqueue.count;
1495         irq_ptr->ccw.cda = 0;
1496
1497         spin_lock_irqsave(get_ccwdev_lock(cdev), saveflags);
1498         ccw_device_set_options(cdev, CCWDEV_REPORT_ALL);
1499
1500         rc = ccw_device_start(cdev, &irq_ptr->ccw, QDIO_DOING_ACTIVATE,
1501                               0, DOIO_DENY_PREFETCH);
1502         if (rc) {
1503                 sprintf(dbf_text, "aq:io%4x", irq_ptr->schid.sch_no);
1504                 QDIO_DBF_TEXT2(1, setup, dbf_text);
1505                 sprintf(dbf_text, "aq:rc%4x", rc);
1506                 QDIO_DBF_TEXT2(1, setup, dbf_text);
1507         }
1508         spin_unlock_irqrestore(get_ccwdev_lock(cdev), saveflags);
1509
1510         if (rc)
1511                 goto out;
1512
1513         if (is_thinint_irq(irq_ptr))
1514                 tiqdio_add_input_queues(irq_ptr);
1515
1516         /* wait for subchannel to become active */
1517         msleep(5);
1518
1519         switch (irq_ptr->state) {
1520         case QDIO_IRQ_STATE_STOPPED:
1521         case QDIO_IRQ_STATE_ERR:
1522                 mutex_unlock(&irq_ptr->setup_mutex);
1523                 qdio_shutdown(cdev, QDIO_FLAG_CLEANUP_USING_CLEAR);
1524                 return -EIO;
1525         default:
1526                 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_ACTIVE);
1527                 rc = 0;
1528         }
1529 out:
1530         mutex_unlock(&irq_ptr->setup_mutex);
1531         return rc;
1532 }
1533 EXPORT_SYMBOL_GPL(qdio_activate);
1534
1535 static inline int buf_in_between(int bufnr, int start, int count)
1536 {
1537         int end = add_buf(start, count);
1538
1539         if (end > start) {
1540                 if (bufnr >= start && bufnr < end)
1541                         return 1;
1542                 else
1543                         return 0;
1544         }
1545
1546         /* wrap-around case */
1547         if ((bufnr >= start && bufnr <= QDIO_MAX_BUFFERS_PER_Q) ||
1548             (bufnr < end))
1549                 return 1;
1550         else
1551                 return 0;
1552 }
1553
1554 /**
1555  * handle_inbound - reset processed input buffers
1556  * @q: queue containing the buffers
1557  * @callflags: flags
1558  * @bufnr: first buffer to process
1559  * @count: how many buffers are emptied
1560  */
1561 static void handle_inbound(struct qdio_q *q, unsigned int callflags,
1562                            int bufnr, int count)
1563 {
1564         unsigned long flags;
1565         int used, rc;
1566
1567         /*
1568          * do_QDIO could run in parallel with the queue tasklet so the
1569          * upper-layer programm could empty the ACK'ed buffer here.
1570          * If that happens we must clear the polling flag, otherwise
1571          * qdio_stop_polling() could set the buffer to NOT_INIT after
1572          * it was set to EMPTY which would kill us.
1573          */
1574         spin_lock_irqsave(&q->u.in.lock, flags);
1575         if (q->u.in.polling)
1576                 if (buf_in_between(q->last_move_ftc, bufnr, count))
1577                         q->u.in.polling = 0;
1578
1579         count = set_buf_states(q, bufnr, SLSB_CU_INPUT_EMPTY, count);
1580         spin_unlock_irqrestore(&q->u.in.lock, flags);
1581
1582         used = atomic_add_return(count, &q->nr_buf_used) - count;
1583         BUG_ON(used + count > QDIO_MAX_BUFFERS_PER_Q);
1584
1585         /* no need to signal as long as the adapter had free buffers */
1586         if (used)
1587                 return;
1588
1589         if (need_siga_in(q)) {
1590                 rc = qdio_siga_input(q);
1591                 if (rc)
1592                         q->qdio_error = rc;
1593         }
1594 }
1595
1596 /**
1597  * handle_outbound - process filled outbound buffers
1598  * @q: queue containing the buffers
1599  * @callflags: flags
1600  * @bufnr: first buffer to process
1601  * @count: how many buffers are filled
1602  */
1603 static void handle_outbound(struct qdio_q *q, unsigned int callflags,
1604                             int bufnr, int count)
1605 {
1606         unsigned char state;
1607         int used;
1608
1609         qdio_perf_stat_inc(&perf_stats.outbound_handler);
1610
1611         count = set_buf_states(q, bufnr, SLSB_CU_OUTPUT_PRIMED, count);
1612         used = atomic_add_return(count, &q->nr_buf_used);
1613         BUG_ON(used > QDIO_MAX_BUFFERS_PER_Q);
1614
1615         if (callflags & QDIO_FLAG_PCI_OUT)
1616                 q->u.out.pci_out_enabled = 1;
1617         else
1618                 q->u.out.pci_out_enabled = 0;
1619
1620         if (queue_type(q) == QDIO_IQDIO_QFMT) {
1621                 if (multicast_outbound(q))
1622                         qdio_kick_outbound_q(q);
1623                 else
1624                         /*
1625                          * One siga-w per buffer required for unicast
1626                          * HiperSockets.
1627                          */
1628                         while (count--)
1629                                 qdio_kick_outbound_q(q);
1630                 goto out;
1631         }
1632
1633         if (need_siga_sync(q)) {
1634                 qdio_siga_sync_q(q);
1635                 goto out;
1636         }
1637
1638         /* try to fast requeue buffers */
1639         get_buf_state(q, prev_buf(bufnr), &state);
1640         if (state != SLSB_CU_OUTPUT_PRIMED)
1641                 qdio_kick_outbound_q(q);
1642         else {
1643                 QDIO_DBF_TEXT5(0, trace, "fast-req");
1644                 qdio_perf_stat_inc(&perf_stats.fast_requeue);
1645         }
1646 out:
1647         /* Fixme: could wait forever if called from process context */
1648         tasklet_schedule(&q->tasklet);
1649 }
1650
1651 /**
1652  * do_QDIO - process input or output buffers
1653  * @cdev: associated ccw_device for the qdio subchannel
1654  * @callflags: input or output and special flags from the program
1655  * @q_nr: queue number
1656  * @bufnr: buffer number
1657  * @count: how many buffers to process
1658  */
1659 int do_QDIO(struct ccw_device *cdev, unsigned int callflags,
1660             int q_nr, int bufnr, int count)
1661 {
1662         struct qdio_irq *irq_ptr;
1663 #ifdef CONFIG_QDIO_DEBUG
1664         char dbf_text[20];
1665
1666         sprintf(dbf_text, "doQD%04x", cdev->private->schid.sch_no);
1667         QDIO_DBF_TEXT3(0, trace, dbf_text);
1668 #endif /* CONFIG_QDIO_DEBUG */
1669
1670         if ((bufnr > QDIO_MAX_BUFFERS_PER_Q) ||
1671             (count > QDIO_MAX_BUFFERS_PER_Q) ||
1672             (q_nr > QDIO_MAX_QUEUES_PER_IRQ))
1673                 return -EINVAL;
1674
1675         if (!count)
1676                 return 0;
1677
1678         irq_ptr = cdev->private->qdio_data;
1679         if (!irq_ptr)
1680                 return -ENODEV;
1681
1682 #ifdef CONFIG_QDIO_DEBUG
1683         if (callflags & QDIO_FLAG_SYNC_INPUT)
1684                 QDIO_DBF_HEX3(0, trace, &irq_ptr->input_qs[q_nr],
1685                               sizeof(void *));
1686         else
1687                 QDIO_DBF_HEX3(0, trace, &irq_ptr->output_qs[q_nr],
1688                               sizeof(void *));
1689
1690         sprintf(dbf_text, "flag%04x", callflags);
1691         QDIO_DBF_TEXT3(0, trace, dbf_text);
1692         sprintf(dbf_text, "qi%02xct%02x", bufnr, count);
1693         QDIO_DBF_TEXT3(0, trace, dbf_text);
1694 #endif /* CONFIG_QDIO_DEBUG */
1695
1696         if (irq_ptr->state != QDIO_IRQ_STATE_ACTIVE)
1697                 return -EBUSY;
1698
1699         if (callflags & QDIO_FLAG_SYNC_INPUT)
1700                 handle_inbound(irq_ptr->input_qs[q_nr],
1701                                callflags, bufnr, count);
1702         else if (callflags & QDIO_FLAG_SYNC_OUTPUT)
1703                 handle_outbound(irq_ptr->output_qs[q_nr],
1704                                 callflags, bufnr, count);
1705         else {
1706                 QDIO_DBF_TEXT3(1, trace, "doQD:inv");
1707                 return -EINVAL;
1708         }
1709         return 0;
1710 }
1711 EXPORT_SYMBOL_GPL(do_QDIO);
1712
1713 static int __init init_QDIO(void)
1714 {
1715         int rc;
1716
1717         rc = qdio_setup_init();
1718         if (rc)
1719                 return rc;
1720         rc = tiqdio_allocate_memory();
1721         if (rc)
1722                 goto out_cache;
1723         rc = qdio_debug_init();
1724         if (rc)
1725                 goto out_ti;
1726         rc = qdio_setup_perf_stats();
1727         if (rc)
1728                 goto out_debug;
1729         rc = tiqdio_register_thinints();
1730         if (rc)
1731                 goto out_perf;
1732         return 0;
1733
1734 out_perf:
1735         qdio_remove_perf_stats();
1736 out_debug:
1737         qdio_debug_exit();
1738 out_ti:
1739         tiqdio_free_memory();
1740 out_cache:
1741         qdio_setup_exit();
1742         return rc;
1743 }
1744
1745 static void __exit exit_QDIO(void)
1746 {
1747         tiqdio_unregister_thinints();
1748         tiqdio_free_memory();
1749         qdio_remove_perf_stats();
1750         qdio_debug_exit();
1751         qdio_setup_exit();
1752 }
1753
1754 module_init(init_QDIO);
1755 module_exit(exit_QDIO);