xref: /openbmc/linux/drivers/s390/cio/qdio_main.c (revision b6dcefde)
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 
26 MODULE_AUTHOR("Utz Bacher <utz.bacher@de.ibm.com>,"\
27 	"Jan Glauber <jang@linux.vnet.ibm.com>");
28 MODULE_DESCRIPTION("QDIO base support");
29 MODULE_LICENSE("GPL");
30 
31 static inline int do_siga_sync(struct subchannel_id schid,
32 			       unsigned int out_mask, unsigned int in_mask)
33 {
34 	register unsigned long __fc asm ("0") = 2;
35 	register struct subchannel_id __schid asm ("1") = schid;
36 	register unsigned long out asm ("2") = out_mask;
37 	register unsigned long in asm ("3") = in_mask;
38 	int cc;
39 
40 	asm volatile(
41 		"	siga	0\n"
42 		"	ipm	%0\n"
43 		"	srl	%0,28\n"
44 		: "=d" (cc)
45 		: "d" (__fc), "d" (__schid), "d" (out), "d" (in) : "cc");
46 	return cc;
47 }
48 
49 static inline int do_siga_input(struct subchannel_id schid, unsigned int mask)
50 {
51 	register unsigned long __fc asm ("0") = 1;
52 	register struct subchannel_id __schid asm ("1") = schid;
53 	register unsigned long __mask asm ("2") = mask;
54 	int cc;
55 
56 	asm volatile(
57 		"	siga	0\n"
58 		"	ipm	%0\n"
59 		"	srl	%0,28\n"
60 		: "=d" (cc)
61 		: "d" (__fc), "d" (__schid), "d" (__mask) : "cc", "memory");
62 	return cc;
63 }
64 
65 /**
66  * do_siga_output - perform SIGA-w/wt function
67  * @schid: subchannel id or in case of QEBSM the subchannel token
68  * @mask: which output queues to process
69  * @bb: busy bit indicator, set only if SIGA-w/wt could not access a buffer
70  * @fc: function code to perform
71  *
72  * Returns cc or QDIO_ERROR_SIGA_ACCESS_EXCEPTION.
73  * Note: For IQDC unicast queues only the highest priority queue is processed.
74  */
75 static inline int do_siga_output(unsigned long schid, unsigned long mask,
76 				 unsigned int *bb, unsigned int fc)
77 {
78 	register unsigned long __fc asm("0") = fc;
79 	register unsigned long __schid asm("1") = schid;
80 	register unsigned long __mask asm("2") = mask;
81 	int cc = QDIO_ERROR_SIGA_ACCESS_EXCEPTION;
82 
83 	asm volatile(
84 		"	siga	0\n"
85 		"0:	ipm	%0\n"
86 		"	srl	%0,28\n"
87 		"1:\n"
88 		EX_TABLE(0b, 1b)
89 		: "+d" (cc), "+d" (__fc), "+d" (__schid), "+d" (__mask)
90 		: : "cc", "memory");
91 	*bb = ((unsigned int) __fc) >> 31;
92 	return cc;
93 }
94 
95 static inline int qdio_check_ccq(struct qdio_q *q, unsigned int ccq)
96 {
97 	/* all done or next buffer state different */
98 	if (ccq == 0 || ccq == 32)
99 		return 0;
100 	/* not all buffers processed */
101 	if (ccq == 96 || ccq == 97)
102 		return 1;
103 	/* notify devices immediately */
104 	DBF_ERROR("%4x ccq:%3d", SCH_NO(q), ccq);
105 	return -EIO;
106 }
107 
108 /**
109  * qdio_do_eqbs - extract buffer states for QEBSM
110  * @q: queue to manipulate
111  * @state: state of the extracted buffers
112  * @start: buffer number to start at
113  * @count: count of buffers to examine
114  * @auto_ack: automatically acknowledge buffers
115  *
116  * Returns the number of successfully extracted equal buffer states.
117  * Stops processing if a state is different from the last buffers state.
118  */
119 static int qdio_do_eqbs(struct qdio_q *q, unsigned char *state,
120 			int start, int count, int auto_ack)
121 {
122 	unsigned int ccq = 0;
123 	int tmp_count = count, tmp_start = start;
124 	int nr = q->nr;
125 	int rc;
126 
127 	BUG_ON(!q->irq_ptr->sch_token);
128 	qperf_inc(q, eqbs);
129 
130 	if (!q->is_input_q)
131 		nr += q->irq_ptr->nr_input_qs;
132 again:
133 	ccq = do_eqbs(q->irq_ptr->sch_token, state, nr, &tmp_start, &tmp_count,
134 		      auto_ack);
135 	rc = qdio_check_ccq(q, ccq);
136 
137 	/* At least one buffer was processed, return and extract the remaining
138 	 * buffers later.
139 	 */
140 	if ((ccq == 96) && (count != tmp_count)) {
141 		qperf_inc(q, eqbs_partial);
142 		return (count - tmp_count);
143 	}
144 
145 	if (rc == 1) {
146 		DBF_DEV_EVENT(DBF_WARN, q->irq_ptr, "EQBS again:%2d", ccq);
147 		goto again;
148 	}
149 
150 	if (rc < 0) {
151 		DBF_ERROR("%4x EQBS ERROR", SCH_NO(q));
152 		DBF_ERROR("%3d%3d%2d", count, tmp_count, nr);
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 
180 	if (!count)
181 		return 0;
182 
183 	BUG_ON(!q->irq_ptr->sch_token);
184 	qperf_inc(q, sqbs);
185 
186 	if (!q->is_input_q)
187 		nr += q->irq_ptr->nr_input_qs;
188 again:
189 	ccq = do_sqbs(q->irq_ptr->sch_token, state, nr, &tmp_start, &tmp_count);
190 	rc = qdio_check_ccq(q, ccq);
191 	if (rc == 1) {
192 		DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "SQBS again:%2d", ccq);
193 		qperf_inc(q, sqbs_partial);
194 		goto again;
195 	}
196 	if (rc < 0) {
197 		DBF_ERROR("%4x SQBS ERROR", SCH_NO(q));
198 		DBF_ERROR("%3d%3d%2d", count, tmp_count, nr);
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 				 int auto_ack)
212 {
213 	unsigned char __state = 0;
214 	int i;
215 
216 	BUG_ON(bufnr > QDIO_MAX_BUFFERS_MASK);
217 	BUG_ON(count > QDIO_MAX_BUFFERS_PER_Q);
218 
219 	if (is_qebsm(q))
220 		return qdio_do_eqbs(q, state, bufnr, count, auto_ack);
221 
222 	for (i = 0; i < count; i++) {
223 		if (!__state)
224 			__state = q->slsb.val[bufnr];
225 		else if (q->slsb.val[bufnr] != __state)
226 			break;
227 		bufnr = next_buf(bufnr);
228 	}
229 	*state = __state;
230 	return i;
231 }
232 
233 static inline int get_buf_state(struct qdio_q *q, unsigned int bufnr,
234 				unsigned char *state, int auto_ack)
235 {
236 	return get_buf_states(q, bufnr, state, 1, auto_ack);
237 }
238 
239 /* wrap-around safe setting of slsb states, returns number of changed buffers */
240 static inline int set_buf_states(struct qdio_q *q, int bufnr,
241 				 unsigned char state, int count)
242 {
243 	int i;
244 
245 	BUG_ON(bufnr > QDIO_MAX_BUFFERS_MASK);
246 	BUG_ON(count > QDIO_MAX_BUFFERS_PER_Q);
247 
248 	if (is_qebsm(q))
249 		return qdio_do_sqbs(q, state, bufnr, count);
250 
251 	for (i = 0; i < count; i++) {
252 		xchg(&q->slsb.val[bufnr], state);
253 		bufnr = next_buf(bufnr);
254 	}
255 	return count;
256 }
257 
258 static inline int set_buf_state(struct qdio_q *q, int bufnr,
259 				unsigned char state)
260 {
261 	return set_buf_states(q, bufnr, state, 1);
262 }
263 
264 /* set slsb states to initial state */
265 void qdio_init_buf_states(struct qdio_irq *irq_ptr)
266 {
267 	struct qdio_q *q;
268 	int i;
269 
270 	for_each_input_queue(irq_ptr, q, i)
271 		set_buf_states(q, 0, SLSB_P_INPUT_NOT_INIT,
272 			       QDIO_MAX_BUFFERS_PER_Q);
273 	for_each_output_queue(irq_ptr, q, i)
274 		set_buf_states(q, 0, SLSB_P_OUTPUT_NOT_INIT,
275 			       QDIO_MAX_BUFFERS_PER_Q);
276 }
277 
278 static inline int qdio_siga_sync(struct qdio_q *q, unsigned int output,
279 			  unsigned int input)
280 {
281 	int cc;
282 
283 	if (!need_siga_sync(q))
284 		return 0;
285 
286 	DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "siga-s:%1d", q->nr);
287 	qperf_inc(q, siga_sync);
288 
289 	cc = do_siga_sync(q->irq_ptr->schid, output, input);
290 	if (cc)
291 		DBF_ERROR("%4x SIGA-S:%2d", SCH_NO(q), cc);
292 	return cc;
293 }
294 
295 static inline int qdio_siga_sync_q(struct qdio_q *q)
296 {
297 	if (q->is_input_q)
298 		return qdio_siga_sync(q, 0, q->mask);
299 	else
300 		return qdio_siga_sync(q, q->mask, 0);
301 }
302 
303 static inline int qdio_siga_sync_out(struct qdio_q *q)
304 {
305 	return qdio_siga_sync(q, ~0U, 0);
306 }
307 
308 static inline int qdio_siga_sync_all(struct qdio_q *q)
309 {
310 	return qdio_siga_sync(q, ~0U, ~0U);
311 }
312 
313 static int qdio_siga_output(struct qdio_q *q, unsigned int *busy_bit)
314 {
315 	unsigned long schid;
316 	unsigned int fc = 0;
317 	u64 start_time = 0;
318 	int cc;
319 
320 	if (q->u.out.use_enh_siga)
321 		fc = 3;
322 
323 	if (is_qebsm(q)) {
324 		schid = q->irq_ptr->sch_token;
325 		fc |= 0x80;
326 	}
327 	else
328 		schid = *((u32 *)&q->irq_ptr->schid);
329 
330 again:
331 	cc = do_siga_output(schid, q->mask, busy_bit, fc);
332 
333 	/* hipersocket busy condition */
334 	if (*busy_bit) {
335 		WARN_ON(queue_type(q) != QDIO_IQDIO_QFMT || cc != 2);
336 
337 		if (!start_time) {
338 			start_time = get_usecs();
339 			goto again;
340 		}
341 		if ((get_usecs() - start_time) < QDIO_BUSY_BIT_PATIENCE)
342 			goto again;
343 	}
344 	return cc;
345 }
346 
347 static inline int qdio_siga_input(struct qdio_q *q)
348 {
349 	int cc;
350 
351 	DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "siga-r:%1d", q->nr);
352 	qperf_inc(q, siga_read);
353 
354 	cc = do_siga_input(q->irq_ptr->schid, q->mask);
355 	if (cc)
356 		DBF_ERROR("%4x SIGA-R:%2d", SCH_NO(q), cc);
357 	return cc;
358 }
359 
360 static inline void qdio_sync_after_thinint(struct qdio_q *q)
361 {
362 	if (pci_out_supported(q)) {
363 		if (need_siga_sync_thinint(q))
364 			qdio_siga_sync_all(q);
365 		else if (need_siga_sync_out_thinint(q))
366 			qdio_siga_sync_out(q);
367 	} else
368 		qdio_siga_sync_q(q);
369 }
370 
371 int debug_get_buf_state(struct qdio_q *q, unsigned int bufnr,
372 			unsigned char *state)
373 {
374 	qdio_siga_sync_q(q);
375 	return get_buf_states(q, bufnr, state, 1, 0);
376 }
377 
378 static inline void qdio_stop_polling(struct qdio_q *q)
379 {
380 	if (!q->u.in.polling)
381 		return;
382 
383 	q->u.in.polling = 0;
384 	qperf_inc(q, stop_polling);
385 
386 	/* show the card that we are not polling anymore */
387 	if (is_qebsm(q)) {
388 		set_buf_states(q, q->u.in.ack_start, SLSB_P_INPUT_NOT_INIT,
389 			       q->u.in.ack_count);
390 		q->u.in.ack_count = 0;
391 	} else
392 		set_buf_state(q, q->u.in.ack_start, SLSB_P_INPUT_NOT_INIT);
393 }
394 
395 static void announce_buffer_error(struct qdio_q *q, int count)
396 {
397 	q->qdio_error |= QDIO_ERROR_SLSB_STATE;
398 
399 	/* special handling for no target buffer empty */
400 	if ((!q->is_input_q &&
401 	    (q->sbal[q->first_to_check]->element[15].flags & 0xff) == 0x10)) {
402 		qperf_inc(q, target_full);
403 		DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "OUTFULL FTC:%02x",
404 			      q->first_to_check);
405 		return;
406 	}
407 
408 	DBF_ERROR("%4x BUF ERROR", SCH_NO(q));
409 	DBF_ERROR((q->is_input_q) ? "IN:%2d" : "OUT:%2d", q->nr);
410 	DBF_ERROR("FTC:%3d C:%3d", q->first_to_check, count);
411 	DBF_ERROR("F14:%2x F15:%2x",
412 		  q->sbal[q->first_to_check]->element[14].flags & 0xff,
413 		  q->sbal[q->first_to_check]->element[15].flags & 0xff);
414 }
415 
416 static inline void inbound_primed(struct qdio_q *q, int count)
417 {
418 	int new;
419 
420 	DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "in prim: %02x", count);
421 
422 	/* for QEBSM the ACK was already set by EQBS */
423 	if (is_qebsm(q)) {
424 		if (!q->u.in.polling) {
425 			q->u.in.polling = 1;
426 			q->u.in.ack_count = count;
427 			q->u.in.ack_start = q->first_to_check;
428 			return;
429 		}
430 
431 		/* delete the previous ACK's */
432 		set_buf_states(q, q->u.in.ack_start, SLSB_P_INPUT_NOT_INIT,
433 			       q->u.in.ack_count);
434 		q->u.in.ack_count = count;
435 		q->u.in.ack_start = q->first_to_check;
436 		return;
437 	}
438 
439 	/*
440 	 * ACK the newest buffer. The ACK will be removed in qdio_stop_polling
441 	 * or by the next inbound run.
442 	 */
443 	new = add_buf(q->first_to_check, count - 1);
444 	if (q->u.in.polling) {
445 		/* reset the previous ACK but first set the new one */
446 		set_buf_state(q, new, SLSB_P_INPUT_ACK);
447 		set_buf_state(q, q->u.in.ack_start, SLSB_P_INPUT_NOT_INIT);
448 	} else {
449 		q->u.in.polling = 1;
450 		set_buf_state(q, new, SLSB_P_INPUT_ACK);
451 	}
452 
453 	q->u.in.ack_start = new;
454 	count--;
455 	if (!count)
456 		return;
457 	/* need to change ALL buffers to get more interrupts */
458 	set_buf_states(q, q->first_to_check, SLSB_P_INPUT_NOT_INIT, count);
459 }
460 
461 static int get_inbound_buffer_frontier(struct qdio_q *q)
462 {
463 	int count, stop;
464 	unsigned char state;
465 
466 	/*
467 	 * Don't check 128 buffers, as otherwise qdio_inbound_q_moved
468 	 * would return 0.
469 	 */
470 	count = min(atomic_read(&q->nr_buf_used), QDIO_MAX_BUFFERS_MASK);
471 	stop = add_buf(q->first_to_check, count);
472 
473 	if (q->first_to_check == stop)
474 		goto out;
475 
476 	/*
477 	 * No siga sync here, as a PCI or we after a thin interrupt
478 	 * already sync'ed the queues.
479 	 */
480 	count = get_buf_states(q, q->first_to_check, &state, count, 1);
481 	if (!count)
482 		goto out;
483 
484 	switch (state) {
485 	case SLSB_P_INPUT_PRIMED:
486 		inbound_primed(q, count);
487 		q->first_to_check = add_buf(q->first_to_check, count);
488 		if (atomic_sub(count, &q->nr_buf_used) == 0)
489 			qperf_inc(q, inbound_queue_full);
490 		break;
491 	case SLSB_P_INPUT_ERROR:
492 		announce_buffer_error(q, count);
493 		/* process the buffer, the upper layer will take care of it */
494 		q->first_to_check = add_buf(q->first_to_check, count);
495 		atomic_sub(count, &q->nr_buf_used);
496 		break;
497 	case SLSB_CU_INPUT_EMPTY:
498 	case SLSB_P_INPUT_NOT_INIT:
499 	case SLSB_P_INPUT_ACK:
500 		DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "in nop");
501 		break;
502 	default:
503 		BUG();
504 	}
505 out:
506 	return q->first_to_check;
507 }
508 
509 static int qdio_inbound_q_moved(struct qdio_q *q)
510 {
511 	int bufnr;
512 
513 	bufnr = get_inbound_buffer_frontier(q);
514 
515 	if ((bufnr != q->last_move) || q->qdio_error) {
516 		q->last_move = bufnr;
517 		if (!is_thinint_irq(q->irq_ptr) && !MACHINE_IS_VM)
518 			q->u.in.timestamp = get_usecs();
519 		return 1;
520 	} else
521 		return 0;
522 }
523 
524 static inline int qdio_inbound_q_done(struct qdio_q *q)
525 {
526 	unsigned char state = 0;
527 
528 	if (!atomic_read(&q->nr_buf_used))
529 		return 1;
530 
531 	qdio_siga_sync_q(q);
532 	get_buf_state(q, q->first_to_check, &state, 0);
533 
534 	if (state == SLSB_P_INPUT_PRIMED || state == SLSB_P_INPUT_ERROR)
535 		/* more work coming */
536 		return 0;
537 
538 	if (is_thinint_irq(q->irq_ptr))
539 		return 1;
540 
541 	/* don't poll under z/VM */
542 	if (MACHINE_IS_VM)
543 		return 1;
544 
545 	/*
546 	 * At this point we know, that inbound first_to_check
547 	 * has (probably) not moved (see qdio_inbound_processing).
548 	 */
549 	if (get_usecs() > q->u.in.timestamp + QDIO_INPUT_THRESHOLD) {
550 		DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "in done:%02x",
551 			      q->first_to_check);
552 		return 1;
553 	} else
554 		return 0;
555 }
556 
557 static void qdio_kick_handler(struct qdio_q *q)
558 {
559 	int start = q->first_to_kick;
560 	int end = q->first_to_check;
561 	int count;
562 
563 	if (unlikely(q->irq_ptr->state != QDIO_IRQ_STATE_ACTIVE))
564 		return;
565 
566 	count = sub_buf(end, start);
567 
568 	if (q->is_input_q) {
569 		qperf_inc(q, inbound_handler);
570 		DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "kih s:%02x c:%02x", start, count);
571 	} else
572 		qperf_inc(q, outbound_handler);
573 		DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "koh: s:%02x c:%02x",
574 			      start, count);
575 
576 	q->handler(q->irq_ptr->cdev, q->qdio_error, q->nr, start, count,
577 		   q->irq_ptr->int_parm);
578 
579 	/* for the next time */
580 	q->first_to_kick = end;
581 	q->qdio_error = 0;
582 }
583 
584 static void __qdio_inbound_processing(struct qdio_q *q)
585 {
586 	qperf_inc(q, tasklet_inbound);
587 again:
588 	if (!qdio_inbound_q_moved(q))
589 		return;
590 
591 	qdio_kick_handler(q);
592 
593 	if (!qdio_inbound_q_done(q)) {
594 		/* means poll time is not yet over */
595 		qperf_inc(q, tasklet_inbound_resched);
596 		goto again;
597 	}
598 
599 	qdio_stop_polling(q);
600 	/*
601 	 * We need to check again to not lose initiative after
602 	 * resetting the ACK state.
603 	 */
604 	if (!qdio_inbound_q_done(q)) {
605 		qperf_inc(q, tasklet_inbound_resched2);
606 		goto again;
607 	}
608 }
609 
610 void qdio_inbound_processing(unsigned long data)
611 {
612 	struct qdio_q *q = (struct qdio_q *)data;
613 	__qdio_inbound_processing(q);
614 }
615 
616 static int get_outbound_buffer_frontier(struct qdio_q *q)
617 {
618 	int count, stop;
619 	unsigned char state;
620 
621 	if (((queue_type(q) != QDIO_IQDIO_QFMT) && !pci_out_supported(q)) ||
622 	    (queue_type(q) == QDIO_IQDIO_QFMT && multicast_outbound(q)))
623 		qdio_siga_sync_q(q);
624 
625 	/*
626 	 * Don't check 128 buffers, as otherwise qdio_inbound_q_moved
627 	 * would return 0.
628 	 */
629 	count = min(atomic_read(&q->nr_buf_used), QDIO_MAX_BUFFERS_MASK);
630 	stop = add_buf(q->first_to_check, count);
631 
632 	if (q->first_to_check == stop)
633 		return q->first_to_check;
634 
635 	count = get_buf_states(q, q->first_to_check, &state, count, 0);
636 	if (!count)
637 		return q->first_to_check;
638 
639 	switch (state) {
640 	case SLSB_P_OUTPUT_EMPTY:
641 		/* the adapter got it */
642 		DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "out empty:%1d %02x", q->nr, count);
643 
644 		atomic_sub(count, &q->nr_buf_used);
645 		q->first_to_check = add_buf(q->first_to_check, count);
646 		break;
647 	case SLSB_P_OUTPUT_ERROR:
648 		announce_buffer_error(q, count);
649 		/* process the buffer, the upper layer will take care of it */
650 		q->first_to_check = add_buf(q->first_to_check, count);
651 		atomic_sub(count, &q->nr_buf_used);
652 		break;
653 	case SLSB_CU_OUTPUT_PRIMED:
654 		/* the adapter has not fetched the output yet */
655 		DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "out primed:%1d", q->nr);
656 		break;
657 	case SLSB_P_OUTPUT_NOT_INIT:
658 	case SLSB_P_OUTPUT_HALTED:
659 		break;
660 	default:
661 		BUG();
662 	}
663 	return q->first_to_check;
664 }
665 
666 /* all buffers processed? */
667 static inline int qdio_outbound_q_done(struct qdio_q *q)
668 {
669 	return atomic_read(&q->nr_buf_used) == 0;
670 }
671 
672 static inline int qdio_outbound_q_moved(struct qdio_q *q)
673 {
674 	int bufnr;
675 
676 	bufnr = get_outbound_buffer_frontier(q);
677 
678 	if ((bufnr != q->last_move) || q->qdio_error) {
679 		q->last_move = bufnr;
680 		DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "out moved:%1d", q->nr);
681 		return 1;
682 	} else
683 		return 0;
684 }
685 
686 static int qdio_kick_outbound_q(struct qdio_q *q)
687 {
688 	unsigned int busy_bit;
689 	int cc;
690 
691 	if (!need_siga_out(q))
692 		return 0;
693 
694 	DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "siga-w:%1d", q->nr);
695 	qperf_inc(q, siga_write);
696 
697 	cc = qdio_siga_output(q, &busy_bit);
698 	switch (cc) {
699 	case 0:
700 		break;
701 	case 2:
702 		if (busy_bit) {
703 			DBF_ERROR("%4x cc2 REP:%1d", SCH_NO(q), q->nr);
704 			cc |= QDIO_ERROR_SIGA_BUSY;
705 		} else
706 			DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "siga-w cc2:%1d", q->nr);
707 		break;
708 	case 1:
709 	case 3:
710 		DBF_ERROR("%4x SIGA-W:%1d", SCH_NO(q), cc);
711 		break;
712 	}
713 	return cc;
714 }
715 
716 static void __qdio_outbound_processing(struct qdio_q *q)
717 {
718 	qperf_inc(q, tasklet_outbound);
719 	BUG_ON(atomic_read(&q->nr_buf_used) < 0);
720 
721 	if (qdio_outbound_q_moved(q))
722 		qdio_kick_handler(q);
723 
724 	if (queue_type(q) == QDIO_ZFCP_QFMT)
725 		if (!pci_out_supported(q) && !qdio_outbound_q_done(q))
726 			goto sched;
727 
728 	/* bail out for HiperSockets unicast queues */
729 	if (queue_type(q) == QDIO_IQDIO_QFMT && !multicast_outbound(q))
730 		return;
731 
732 	if ((queue_type(q) == QDIO_IQDIO_QFMT) &&
733 	    (atomic_read(&q->nr_buf_used)) > QDIO_IQDIO_POLL_LVL)
734 		goto sched;
735 
736 	if (q->u.out.pci_out_enabled)
737 		return;
738 
739 	/*
740 	 * Now we know that queue type is either qeth without pci enabled
741 	 * or HiperSockets multicast. Make sure buffer switch from PRIMED to
742 	 * EMPTY is noticed and outbound_handler is called after some time.
743 	 */
744 	if (qdio_outbound_q_done(q))
745 		del_timer(&q->u.out.timer);
746 	else
747 		if (!timer_pending(&q->u.out.timer))
748 			mod_timer(&q->u.out.timer, jiffies + 10 * HZ);
749 	return;
750 
751 sched:
752 	if (unlikely(q->irq_ptr->state == QDIO_IRQ_STATE_STOPPED))
753 		return;
754 	tasklet_schedule(&q->tasklet);
755 }
756 
757 /* outbound tasklet */
758 void qdio_outbound_processing(unsigned long data)
759 {
760 	struct qdio_q *q = (struct qdio_q *)data;
761 	__qdio_outbound_processing(q);
762 }
763 
764 void qdio_outbound_timer(unsigned long data)
765 {
766 	struct qdio_q *q = (struct qdio_q *)data;
767 
768 	if (unlikely(q->irq_ptr->state == QDIO_IRQ_STATE_STOPPED))
769 		return;
770 	tasklet_schedule(&q->tasklet);
771 }
772 
773 static inline void qdio_check_outbound_after_thinint(struct qdio_q *q)
774 {
775 	struct qdio_q *out;
776 	int i;
777 
778 	if (!pci_out_supported(q))
779 		return;
780 
781 	for_each_output_queue(q->irq_ptr, out, i)
782 		if (!qdio_outbound_q_done(out))
783 			tasklet_schedule(&out->tasklet);
784 }
785 
786 static void __tiqdio_inbound_processing(struct qdio_q *q)
787 {
788 	qperf_inc(q, tasklet_inbound);
789 	qdio_sync_after_thinint(q);
790 
791 	/*
792 	 * The interrupt could be caused by a PCI request. Check the
793 	 * PCI capable outbound queues.
794 	 */
795 	qdio_check_outbound_after_thinint(q);
796 
797 	if (!qdio_inbound_q_moved(q))
798 		return;
799 
800 	qdio_kick_handler(q);
801 
802 	if (!qdio_inbound_q_done(q)) {
803 		qperf_inc(q, tasklet_inbound_resched);
804 		if (likely(q->irq_ptr->state != QDIO_IRQ_STATE_STOPPED)) {
805 			tasklet_schedule(&q->tasklet);
806 			return;
807 		}
808 	}
809 
810 	qdio_stop_polling(q);
811 	/*
812 	 * We need to check again to not lose initiative after
813 	 * resetting the ACK state.
814 	 */
815 	if (!qdio_inbound_q_done(q)) {
816 		qperf_inc(q, tasklet_inbound_resched2);
817 		if (likely(q->irq_ptr->state != QDIO_IRQ_STATE_STOPPED))
818 			tasklet_schedule(&q->tasklet);
819 	}
820 }
821 
822 void tiqdio_inbound_processing(unsigned long data)
823 {
824 	struct qdio_q *q = (struct qdio_q *)data;
825 	__tiqdio_inbound_processing(q);
826 }
827 
828 static inline void qdio_set_state(struct qdio_irq *irq_ptr,
829 				  enum qdio_irq_states state)
830 {
831 	DBF_DEV_EVENT(DBF_INFO, irq_ptr, "newstate: %1d", state);
832 
833 	irq_ptr->state = state;
834 	mb();
835 }
836 
837 static void qdio_irq_check_sense(struct qdio_irq *irq_ptr, struct irb *irb)
838 {
839 	if (irb->esw.esw0.erw.cons) {
840 		DBF_ERROR("%4x sense:", irq_ptr->schid.sch_no);
841 		DBF_ERROR_HEX(irb, 64);
842 		DBF_ERROR_HEX(irb->ecw, 64);
843 	}
844 }
845 
846 /* PCI interrupt handler */
847 static void qdio_int_handler_pci(struct qdio_irq *irq_ptr)
848 {
849 	int i;
850 	struct qdio_q *q;
851 
852 	if (unlikely(irq_ptr->state == QDIO_IRQ_STATE_STOPPED))
853 		return;
854 
855 	for_each_input_queue(irq_ptr, q, i)
856 		tasklet_schedule(&q->tasklet);
857 
858 	if (!(irq_ptr->qib.ac & QIB_AC_OUTBOUND_PCI_SUPPORTED))
859 		return;
860 
861 	for_each_output_queue(irq_ptr, q, i) {
862 		if (qdio_outbound_q_done(q))
863 			continue;
864 
865 		if (!siga_syncs_out_pci(q))
866 			qdio_siga_sync_q(q);
867 
868 		tasklet_schedule(&q->tasklet);
869 	}
870 }
871 
872 static void qdio_handle_activate_check(struct ccw_device *cdev,
873 				unsigned long intparm, int cstat, int dstat)
874 {
875 	struct qdio_irq *irq_ptr = cdev->private->qdio_data;
876 	struct qdio_q *q;
877 
878 	DBF_ERROR("%4x ACT CHECK", irq_ptr->schid.sch_no);
879 	DBF_ERROR("intp :%lx", intparm);
880 	DBF_ERROR("ds: %2x cs:%2x", dstat, cstat);
881 
882 	if (irq_ptr->nr_input_qs) {
883 		q = irq_ptr->input_qs[0];
884 	} else if (irq_ptr->nr_output_qs) {
885 		q = irq_ptr->output_qs[0];
886 	} else {
887 		dump_stack();
888 		goto no_handler;
889 	}
890 	q->handler(q->irq_ptr->cdev, QDIO_ERROR_ACTIVATE_CHECK_CONDITION,
891 		   0, -1, -1, irq_ptr->int_parm);
892 no_handler:
893 	qdio_set_state(irq_ptr, QDIO_IRQ_STATE_STOPPED);
894 }
895 
896 static void qdio_establish_handle_irq(struct ccw_device *cdev, int cstat,
897 				      int dstat)
898 {
899 	struct qdio_irq *irq_ptr = cdev->private->qdio_data;
900 
901 	DBF_DEV_EVENT(DBF_INFO, irq_ptr, "qest irq");
902 
903 	if (cstat)
904 		goto error;
905 	if (dstat & ~(DEV_STAT_DEV_END | DEV_STAT_CHN_END))
906 		goto error;
907 	if (!(dstat & DEV_STAT_DEV_END))
908 		goto error;
909 	qdio_set_state(irq_ptr, QDIO_IRQ_STATE_ESTABLISHED);
910 	return;
911 
912 error:
913 	DBF_ERROR("%4x EQ:error", irq_ptr->schid.sch_no);
914 	DBF_ERROR("ds: %2x cs:%2x", dstat, cstat);
915 	qdio_set_state(irq_ptr, QDIO_IRQ_STATE_ERR);
916 }
917 
918 /* qdio interrupt handler */
919 void qdio_int_handler(struct ccw_device *cdev, unsigned long intparm,
920 		      struct irb *irb)
921 {
922 	struct qdio_irq *irq_ptr = cdev->private->qdio_data;
923 	int cstat, dstat;
924 
925 	if (!intparm || !irq_ptr) {
926 		DBF_ERROR("qint:%4x", cdev->private->schid.sch_no);
927 		return;
928 	}
929 
930 	if (IS_ERR(irb)) {
931 		switch (PTR_ERR(irb)) {
932 		case -EIO:
933 			DBF_ERROR("%4x IO error", irq_ptr->schid.sch_no);
934 			qdio_set_state(irq_ptr, QDIO_IRQ_STATE_ERR);
935 			wake_up(&cdev->private->wait_q);
936 			return;
937 		default:
938 			WARN_ON(1);
939 			return;
940 		}
941 	}
942 	qdio_irq_check_sense(irq_ptr, irb);
943 	cstat = irb->scsw.cmd.cstat;
944 	dstat = irb->scsw.cmd.dstat;
945 
946 	switch (irq_ptr->state) {
947 	case QDIO_IRQ_STATE_INACTIVE:
948 		qdio_establish_handle_irq(cdev, cstat, dstat);
949 		break;
950 	case QDIO_IRQ_STATE_CLEANUP:
951 		qdio_set_state(irq_ptr, QDIO_IRQ_STATE_INACTIVE);
952 		break;
953 	case QDIO_IRQ_STATE_ESTABLISHED:
954 	case QDIO_IRQ_STATE_ACTIVE:
955 		if (cstat & SCHN_STAT_PCI) {
956 			qdio_int_handler_pci(irq_ptr);
957 			return;
958 		}
959 		if (cstat || dstat)
960 			qdio_handle_activate_check(cdev, intparm, cstat,
961 						   dstat);
962 		break;
963 	case QDIO_IRQ_STATE_STOPPED:
964 		break;
965 	default:
966 		WARN_ON(1);
967 	}
968 	wake_up(&cdev->private->wait_q);
969 }
970 
971 /**
972  * qdio_get_ssqd_desc - get qdio subchannel description
973  * @cdev: ccw device to get description for
974  * @data: where to store the ssqd
975  *
976  * Returns 0 or an error code. The results of the chsc are stored in the
977  * specified structure.
978  */
979 int qdio_get_ssqd_desc(struct ccw_device *cdev,
980 		       struct qdio_ssqd_desc *data)
981 {
982 
983 	if (!cdev || !cdev->private)
984 		return -EINVAL;
985 
986 	DBF_EVENT("get ssqd:%4x", cdev->private->schid.sch_no);
987 	return qdio_setup_get_ssqd(NULL, &cdev->private->schid, data);
988 }
989 EXPORT_SYMBOL_GPL(qdio_get_ssqd_desc);
990 
991 /**
992  * qdio_cleanup - shutdown queues and free data structures
993  * @cdev: associated ccw device
994  * @how: use halt or clear to shutdown
995  *
996  * This function calls qdio_shutdown() for @cdev with method @how.
997  * and qdio_free(). The qdio_free() return value is ignored since
998  * !irq_ptr is already checked.
999  */
1000 int qdio_cleanup(struct ccw_device *cdev, int how)
1001 {
1002 	struct qdio_irq *irq_ptr = cdev->private->qdio_data;
1003 	int rc;
1004 
1005 	if (!irq_ptr)
1006 		return -ENODEV;
1007 
1008 	rc = qdio_shutdown(cdev, how);
1009 
1010 	qdio_free(cdev);
1011 	return rc;
1012 }
1013 EXPORT_SYMBOL_GPL(qdio_cleanup);
1014 
1015 static void qdio_shutdown_queues(struct ccw_device *cdev)
1016 {
1017 	struct qdio_irq *irq_ptr = cdev->private->qdio_data;
1018 	struct qdio_q *q;
1019 	int i;
1020 
1021 	for_each_input_queue(irq_ptr, q, i)
1022 		tasklet_kill(&q->tasklet);
1023 
1024 	for_each_output_queue(irq_ptr, q, i) {
1025 		del_timer(&q->u.out.timer);
1026 		tasklet_kill(&q->tasklet);
1027 	}
1028 }
1029 
1030 /**
1031  * qdio_shutdown - shut down a qdio subchannel
1032  * @cdev: associated ccw device
1033  * @how: use halt or clear to shutdown
1034  */
1035 int qdio_shutdown(struct ccw_device *cdev, int how)
1036 {
1037 	struct qdio_irq *irq_ptr = cdev->private->qdio_data;
1038 	int rc;
1039 	unsigned long flags;
1040 
1041 	if (!irq_ptr)
1042 		return -ENODEV;
1043 
1044 	BUG_ON(irqs_disabled());
1045 	DBF_EVENT("qshutdown:%4x", cdev->private->schid.sch_no);
1046 
1047 	mutex_lock(&irq_ptr->setup_mutex);
1048 	/*
1049 	 * Subchannel was already shot down. We cannot prevent being called
1050 	 * twice since cio may trigger a shutdown asynchronously.
1051 	 */
1052 	if (irq_ptr->state == QDIO_IRQ_STATE_INACTIVE) {
1053 		mutex_unlock(&irq_ptr->setup_mutex);
1054 		return 0;
1055 	}
1056 
1057 	/*
1058 	 * Indicate that the device is going down. Scheduling the queue
1059 	 * tasklets is forbidden from here on.
1060 	 */
1061 	qdio_set_state(irq_ptr, QDIO_IRQ_STATE_STOPPED);
1062 
1063 	tiqdio_remove_input_queues(irq_ptr);
1064 	qdio_shutdown_queues(cdev);
1065 	qdio_shutdown_debug_entries(irq_ptr, cdev);
1066 
1067 	/* cleanup subchannel */
1068 	spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
1069 
1070 	if (how & QDIO_FLAG_CLEANUP_USING_CLEAR)
1071 		rc = ccw_device_clear(cdev, QDIO_DOING_CLEANUP);
1072 	else
1073 		/* default behaviour is halt */
1074 		rc = ccw_device_halt(cdev, QDIO_DOING_CLEANUP);
1075 	if (rc) {
1076 		DBF_ERROR("%4x SHUTD ERR", irq_ptr->schid.sch_no);
1077 		DBF_ERROR("rc:%4d", rc);
1078 		goto no_cleanup;
1079 	}
1080 
1081 	qdio_set_state(irq_ptr, QDIO_IRQ_STATE_CLEANUP);
1082 	spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
1083 	wait_event_interruptible_timeout(cdev->private->wait_q,
1084 		irq_ptr->state == QDIO_IRQ_STATE_INACTIVE ||
1085 		irq_ptr->state == QDIO_IRQ_STATE_ERR,
1086 		10 * HZ);
1087 	spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
1088 
1089 no_cleanup:
1090 	qdio_shutdown_thinint(irq_ptr);
1091 
1092 	/* restore interrupt handler */
1093 	if ((void *)cdev->handler == (void *)qdio_int_handler)
1094 		cdev->handler = irq_ptr->orig_handler;
1095 	spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
1096 
1097 	qdio_set_state(irq_ptr, QDIO_IRQ_STATE_INACTIVE);
1098 	mutex_unlock(&irq_ptr->setup_mutex);
1099 	if (rc)
1100 		return rc;
1101 	return 0;
1102 }
1103 EXPORT_SYMBOL_GPL(qdio_shutdown);
1104 
1105 /**
1106  * qdio_free - free data structures for a qdio subchannel
1107  * @cdev: associated ccw device
1108  */
1109 int qdio_free(struct ccw_device *cdev)
1110 {
1111 	struct qdio_irq *irq_ptr = cdev->private->qdio_data;
1112 
1113 	if (!irq_ptr)
1114 		return -ENODEV;
1115 
1116 	DBF_EVENT("qfree:%4x", cdev->private->schid.sch_no);
1117 	mutex_lock(&irq_ptr->setup_mutex);
1118 
1119 	if (irq_ptr->debug_area != NULL) {
1120 		debug_unregister(irq_ptr->debug_area);
1121 		irq_ptr->debug_area = NULL;
1122 	}
1123 	cdev->private->qdio_data = NULL;
1124 	mutex_unlock(&irq_ptr->setup_mutex);
1125 
1126 	qdio_release_memory(irq_ptr);
1127 	return 0;
1128 }
1129 EXPORT_SYMBOL_GPL(qdio_free);
1130 
1131 /**
1132  * qdio_initialize - allocate and establish queues for a qdio subchannel
1133  * @init_data: initialization data
1134  *
1135  * This function first allocates queues via qdio_allocate() and on success
1136  * establishes them via qdio_establish().
1137  */
1138 int qdio_initialize(struct qdio_initialize *init_data)
1139 {
1140 	int rc;
1141 
1142 	rc = qdio_allocate(init_data);
1143 	if (rc)
1144 		return rc;
1145 
1146 	rc = qdio_establish(init_data);
1147 	if (rc)
1148 		qdio_free(init_data->cdev);
1149 	return rc;
1150 }
1151 EXPORT_SYMBOL_GPL(qdio_initialize);
1152 
1153 /**
1154  * qdio_allocate - allocate qdio queues and associated data
1155  * @init_data: initialization data
1156  */
1157 int qdio_allocate(struct qdio_initialize *init_data)
1158 {
1159 	struct qdio_irq *irq_ptr;
1160 
1161 	DBF_EVENT("qallocate:%4x", init_data->cdev->private->schid.sch_no);
1162 
1163 	if ((init_data->no_input_qs && !init_data->input_handler) ||
1164 	    (init_data->no_output_qs && !init_data->output_handler))
1165 		return -EINVAL;
1166 
1167 	if ((init_data->no_input_qs > QDIO_MAX_QUEUES_PER_IRQ) ||
1168 	    (init_data->no_output_qs > QDIO_MAX_QUEUES_PER_IRQ))
1169 		return -EINVAL;
1170 
1171 	if ((!init_data->input_sbal_addr_array) ||
1172 	    (!init_data->output_sbal_addr_array))
1173 		return -EINVAL;
1174 
1175 	/* irq_ptr must be in GFP_DMA since it contains ccw1.cda */
1176 	irq_ptr = (void *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
1177 	if (!irq_ptr)
1178 		goto out_err;
1179 
1180 	mutex_init(&irq_ptr->setup_mutex);
1181 	qdio_allocate_dbf(init_data, irq_ptr);
1182 
1183 	/*
1184 	 * Allocate a page for the chsc calls in qdio_establish.
1185 	 * Must be pre-allocated since a zfcp recovery will call
1186 	 * qdio_establish. In case of low memory and swap on a zfcp disk
1187 	 * we may not be able to allocate memory otherwise.
1188 	 */
1189 	irq_ptr->chsc_page = get_zeroed_page(GFP_KERNEL);
1190 	if (!irq_ptr->chsc_page)
1191 		goto out_rel;
1192 
1193 	/* qdr is used in ccw1.cda which is u32 */
1194 	irq_ptr->qdr = (struct qdr *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
1195 	if (!irq_ptr->qdr)
1196 		goto out_rel;
1197 	WARN_ON((unsigned long)irq_ptr->qdr & 0xfff);
1198 
1199 	if (qdio_allocate_qs(irq_ptr, init_data->no_input_qs,
1200 			     init_data->no_output_qs))
1201 		goto out_rel;
1202 
1203 	init_data->cdev->private->qdio_data = irq_ptr;
1204 	qdio_set_state(irq_ptr, QDIO_IRQ_STATE_INACTIVE);
1205 	return 0;
1206 out_rel:
1207 	qdio_release_memory(irq_ptr);
1208 out_err:
1209 	return -ENOMEM;
1210 }
1211 EXPORT_SYMBOL_GPL(qdio_allocate);
1212 
1213 /**
1214  * qdio_establish - establish queues on a qdio subchannel
1215  * @init_data: initialization data
1216  */
1217 int qdio_establish(struct qdio_initialize *init_data)
1218 {
1219 	struct qdio_irq *irq_ptr;
1220 	struct ccw_device *cdev = init_data->cdev;
1221 	unsigned long saveflags;
1222 	int rc;
1223 
1224 	DBF_EVENT("qestablish:%4x", cdev->private->schid.sch_no);
1225 
1226 	irq_ptr = cdev->private->qdio_data;
1227 	if (!irq_ptr)
1228 		return -ENODEV;
1229 
1230 	if (cdev->private->state != DEV_STATE_ONLINE)
1231 		return -EINVAL;
1232 
1233 	mutex_lock(&irq_ptr->setup_mutex);
1234 	qdio_setup_irq(init_data);
1235 
1236 	rc = qdio_establish_thinint(irq_ptr);
1237 	if (rc) {
1238 		mutex_unlock(&irq_ptr->setup_mutex);
1239 		qdio_shutdown(cdev, QDIO_FLAG_CLEANUP_USING_CLEAR);
1240 		return rc;
1241 	}
1242 
1243 	/* establish q */
1244 	irq_ptr->ccw.cmd_code = irq_ptr->equeue.cmd;
1245 	irq_ptr->ccw.flags = CCW_FLAG_SLI;
1246 	irq_ptr->ccw.count = irq_ptr->equeue.count;
1247 	irq_ptr->ccw.cda = (u32)((addr_t)irq_ptr->qdr);
1248 
1249 	spin_lock_irqsave(get_ccwdev_lock(cdev), saveflags);
1250 	ccw_device_set_options_mask(cdev, 0);
1251 
1252 	rc = ccw_device_start(cdev, &irq_ptr->ccw, QDIO_DOING_ESTABLISH, 0, 0);
1253 	if (rc) {
1254 		DBF_ERROR("%4x est IO ERR", irq_ptr->schid.sch_no);
1255 		DBF_ERROR("rc:%4x", rc);
1256 	}
1257 	spin_unlock_irqrestore(get_ccwdev_lock(cdev), saveflags);
1258 
1259 	if (rc) {
1260 		mutex_unlock(&irq_ptr->setup_mutex);
1261 		qdio_shutdown(cdev, QDIO_FLAG_CLEANUP_USING_CLEAR);
1262 		return rc;
1263 	}
1264 
1265 	wait_event_interruptible_timeout(cdev->private->wait_q,
1266 		irq_ptr->state == QDIO_IRQ_STATE_ESTABLISHED ||
1267 		irq_ptr->state == QDIO_IRQ_STATE_ERR, HZ);
1268 
1269 	if (irq_ptr->state != QDIO_IRQ_STATE_ESTABLISHED) {
1270 		mutex_unlock(&irq_ptr->setup_mutex);
1271 		qdio_shutdown(cdev, QDIO_FLAG_CLEANUP_USING_CLEAR);
1272 		return -EIO;
1273 	}
1274 
1275 	qdio_setup_ssqd_info(irq_ptr);
1276 	DBF_EVENT("qDmmwc:%2x", irq_ptr->ssqd_desc.mmwc);
1277 	DBF_EVENT("qib ac:%4x", irq_ptr->qib.ac);
1278 
1279 	/* qebsm is now setup if available, initialize buffer states */
1280 	qdio_init_buf_states(irq_ptr);
1281 
1282 	mutex_unlock(&irq_ptr->setup_mutex);
1283 	qdio_print_subchannel_info(irq_ptr, cdev);
1284 	qdio_setup_debug_entries(irq_ptr, cdev);
1285 	return 0;
1286 }
1287 EXPORT_SYMBOL_GPL(qdio_establish);
1288 
1289 /**
1290  * qdio_activate - activate queues on a qdio subchannel
1291  * @cdev: associated cdev
1292  */
1293 int qdio_activate(struct ccw_device *cdev)
1294 {
1295 	struct qdio_irq *irq_ptr;
1296 	int rc;
1297 	unsigned long saveflags;
1298 
1299 	DBF_EVENT("qactivate:%4x", cdev->private->schid.sch_no);
1300 
1301 	irq_ptr = cdev->private->qdio_data;
1302 	if (!irq_ptr)
1303 		return -ENODEV;
1304 
1305 	if (cdev->private->state != DEV_STATE_ONLINE)
1306 		return -EINVAL;
1307 
1308 	mutex_lock(&irq_ptr->setup_mutex);
1309 	if (irq_ptr->state == QDIO_IRQ_STATE_INACTIVE) {
1310 		rc = -EBUSY;
1311 		goto out;
1312 	}
1313 
1314 	irq_ptr->ccw.cmd_code = irq_ptr->aqueue.cmd;
1315 	irq_ptr->ccw.flags = CCW_FLAG_SLI;
1316 	irq_ptr->ccw.count = irq_ptr->aqueue.count;
1317 	irq_ptr->ccw.cda = 0;
1318 
1319 	spin_lock_irqsave(get_ccwdev_lock(cdev), saveflags);
1320 	ccw_device_set_options(cdev, CCWDEV_REPORT_ALL);
1321 
1322 	rc = ccw_device_start(cdev, &irq_ptr->ccw, QDIO_DOING_ACTIVATE,
1323 			      0, DOIO_DENY_PREFETCH);
1324 	if (rc) {
1325 		DBF_ERROR("%4x act IO ERR", irq_ptr->schid.sch_no);
1326 		DBF_ERROR("rc:%4x", rc);
1327 	}
1328 	spin_unlock_irqrestore(get_ccwdev_lock(cdev), saveflags);
1329 
1330 	if (rc)
1331 		goto out;
1332 
1333 	if (is_thinint_irq(irq_ptr))
1334 		tiqdio_add_input_queues(irq_ptr);
1335 
1336 	/* wait for subchannel to become active */
1337 	msleep(5);
1338 
1339 	switch (irq_ptr->state) {
1340 	case QDIO_IRQ_STATE_STOPPED:
1341 	case QDIO_IRQ_STATE_ERR:
1342 		rc = -EIO;
1343 		break;
1344 	default:
1345 		qdio_set_state(irq_ptr, QDIO_IRQ_STATE_ACTIVE);
1346 		rc = 0;
1347 	}
1348 out:
1349 	mutex_unlock(&irq_ptr->setup_mutex);
1350 	return rc;
1351 }
1352 EXPORT_SYMBOL_GPL(qdio_activate);
1353 
1354 static inline int buf_in_between(int bufnr, int start, int count)
1355 {
1356 	int end = add_buf(start, count);
1357 
1358 	if (end > start) {
1359 		if (bufnr >= start && bufnr < end)
1360 			return 1;
1361 		else
1362 			return 0;
1363 	}
1364 
1365 	/* wrap-around case */
1366 	if ((bufnr >= start && bufnr <= QDIO_MAX_BUFFERS_PER_Q) ||
1367 	    (bufnr < end))
1368 		return 1;
1369 	else
1370 		return 0;
1371 }
1372 
1373 /**
1374  * handle_inbound - reset processed input buffers
1375  * @q: queue containing the buffers
1376  * @callflags: flags
1377  * @bufnr: first buffer to process
1378  * @count: how many buffers are emptied
1379  */
1380 static int handle_inbound(struct qdio_q *q, unsigned int callflags,
1381 			  int bufnr, int count)
1382 {
1383 	int used, diff;
1384 
1385 	qperf_inc(q, inbound_call);
1386 
1387 	if (!q->u.in.polling)
1388 		goto set;
1389 
1390 	/* protect against stop polling setting an ACK for an emptied slsb */
1391 	if (count == QDIO_MAX_BUFFERS_PER_Q) {
1392 		/* overwriting everything, just delete polling status */
1393 		q->u.in.polling = 0;
1394 		q->u.in.ack_count = 0;
1395 		goto set;
1396 	} else if (buf_in_between(q->u.in.ack_start, bufnr, count)) {
1397 		if (is_qebsm(q)) {
1398 			/* partial overwrite, just update ack_start */
1399 			diff = add_buf(bufnr, count);
1400 			diff = sub_buf(diff, q->u.in.ack_start);
1401 			q->u.in.ack_count -= diff;
1402 			if (q->u.in.ack_count <= 0) {
1403 				q->u.in.polling = 0;
1404 				q->u.in.ack_count = 0;
1405 				goto set;
1406 			}
1407 			q->u.in.ack_start = add_buf(q->u.in.ack_start, diff);
1408 		}
1409 		else
1410 			/* the only ACK will be deleted, so stop polling */
1411 			q->u.in.polling = 0;
1412 	}
1413 
1414 set:
1415 	count = set_buf_states(q, bufnr, SLSB_CU_INPUT_EMPTY, count);
1416 
1417 	used = atomic_add_return(count, &q->nr_buf_used) - count;
1418 	BUG_ON(used + count > QDIO_MAX_BUFFERS_PER_Q);
1419 
1420 	/* no need to signal as long as the adapter had free buffers */
1421 	if (used)
1422 		return 0;
1423 
1424 	if (need_siga_in(q))
1425 		return qdio_siga_input(q);
1426 	return 0;
1427 }
1428 
1429 /**
1430  * handle_outbound - process filled outbound buffers
1431  * @q: queue containing the buffers
1432  * @callflags: flags
1433  * @bufnr: first buffer to process
1434  * @count: how many buffers are filled
1435  */
1436 static int handle_outbound(struct qdio_q *q, unsigned int callflags,
1437 			   int bufnr, int count)
1438 {
1439 	unsigned char state;
1440 	int used, rc = 0;
1441 
1442 	qperf_inc(q, outbound_call);
1443 
1444 	count = set_buf_states(q, bufnr, SLSB_CU_OUTPUT_PRIMED, count);
1445 	used = atomic_add_return(count, &q->nr_buf_used);
1446 	BUG_ON(used > QDIO_MAX_BUFFERS_PER_Q);
1447 
1448 	if (callflags & QDIO_FLAG_PCI_OUT) {
1449 		q->u.out.pci_out_enabled = 1;
1450 		qperf_inc(q, pci_request_int);
1451 	}
1452 	else
1453 		q->u.out.pci_out_enabled = 0;
1454 
1455 	if (queue_type(q) == QDIO_IQDIO_QFMT) {
1456 		if (multicast_outbound(q))
1457 			rc = qdio_kick_outbound_q(q);
1458 		else
1459 			if ((q->irq_ptr->ssqd_desc.mmwc > 1) &&
1460 			    (count > 1) &&
1461 			    (count <= q->irq_ptr->ssqd_desc.mmwc)) {
1462 				/* exploit enhanced SIGA */
1463 				q->u.out.use_enh_siga = 1;
1464 				rc = qdio_kick_outbound_q(q);
1465 			} else {
1466 				/*
1467 				* One siga-w per buffer required for unicast
1468 				* HiperSockets.
1469 				*/
1470 				q->u.out.use_enh_siga = 0;
1471 				while (count--) {
1472 					rc = qdio_kick_outbound_q(q);
1473 					if (rc)
1474 						goto out;
1475 				}
1476 			}
1477 		goto out;
1478 	}
1479 
1480 	if (need_siga_sync(q)) {
1481 		qdio_siga_sync_q(q);
1482 		goto out;
1483 	}
1484 
1485 	/* try to fast requeue buffers */
1486 	get_buf_state(q, prev_buf(bufnr), &state, 0);
1487 	if (state != SLSB_CU_OUTPUT_PRIMED)
1488 		rc = qdio_kick_outbound_q(q);
1489 	else
1490 		qperf_inc(q, fast_requeue);
1491 
1492 out:
1493 	tasklet_schedule(&q->tasklet);
1494 	return rc;
1495 }
1496 
1497 /**
1498  * do_QDIO - process input or output buffers
1499  * @cdev: associated ccw_device for the qdio subchannel
1500  * @callflags: input or output and special flags from the program
1501  * @q_nr: queue number
1502  * @bufnr: buffer number
1503  * @count: how many buffers to process
1504  */
1505 int do_QDIO(struct ccw_device *cdev, unsigned int callflags,
1506 	    int q_nr, unsigned int bufnr, unsigned int count)
1507 {
1508 	struct qdio_irq *irq_ptr;
1509 
1510 	if (bufnr >= QDIO_MAX_BUFFERS_PER_Q || count > QDIO_MAX_BUFFERS_PER_Q)
1511 		return -EINVAL;
1512 
1513 	irq_ptr = cdev->private->qdio_data;
1514 	if (!irq_ptr)
1515 		return -ENODEV;
1516 
1517 	DBF_DEV_EVENT(DBF_INFO, irq_ptr,
1518 		      "do%02x b:%02x c:%02x", callflags, bufnr, count);
1519 
1520 	if (irq_ptr->state != QDIO_IRQ_STATE_ACTIVE)
1521 		return -EBUSY;
1522 
1523 	if (callflags & QDIO_FLAG_SYNC_INPUT)
1524 		return handle_inbound(irq_ptr->input_qs[q_nr],
1525 				      callflags, bufnr, count);
1526 	else if (callflags & QDIO_FLAG_SYNC_OUTPUT)
1527 		return handle_outbound(irq_ptr->output_qs[q_nr],
1528 				       callflags, bufnr, count);
1529 	return -EINVAL;
1530 }
1531 EXPORT_SYMBOL_GPL(do_QDIO);
1532 
1533 static int __init init_QDIO(void)
1534 {
1535 	int rc;
1536 
1537 	rc = qdio_setup_init();
1538 	if (rc)
1539 		return rc;
1540 	rc = tiqdio_allocate_memory();
1541 	if (rc)
1542 		goto out_cache;
1543 	rc = qdio_debug_init();
1544 	if (rc)
1545 		goto out_ti;
1546 	rc = tiqdio_register_thinints();
1547 	if (rc)
1548 		goto out_debug;
1549 	return 0;
1550 
1551 out_debug:
1552 	qdio_debug_exit();
1553 out_ti:
1554 	tiqdio_free_memory();
1555 out_cache:
1556 	qdio_setup_exit();
1557 	return rc;
1558 }
1559 
1560 static void __exit exit_QDIO(void)
1561 {
1562 	tiqdio_unregister_thinints();
1563 	tiqdio_free_memory();
1564 	qdio_debug_exit();
1565 	qdio_setup_exit();
1566 }
1567 
1568 module_init(init_QDIO);
1569 module_exit(exit_QDIO);
1570