blob: e53ac67e1e48fab708ccd849f166b014b1dfa9d9 [file] [log] [blame]
Jan Glauber779e6e12008-07-17 17:16:48 +02001/*
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
27MODULE_AUTHOR("Utz Bacher <utz.bacher@de.ibm.com>,"\
28 "Jan Glauber <jang@linux.vnet.ibm.com>");
29MODULE_DESCRIPTION("QDIO base support");
30MODULE_LICENSE("GPL");
31
32static 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
50static 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 */
76static inline int do_siga_output(unsigned long schid, unsigned long mask,
Jan Glauber7a0b4cb2008-12-25 13:38:48 +010077 unsigned int *bb, unsigned int fc)
Jan Glauber779e6e12008-07-17 17:16:48 +020078{
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
96static inline int qdio_check_ccq(struct qdio_q *q, unsigned int ccq)
97{
Jan Glauber779e6e12008-07-17 17:16:48 +020098 /* all done or next buffer state different */
99 if (ccq == 0 || ccq == 32)
100 return 0;
101 /* not all buffers processed */
102 if (ccq == 96 || ccq == 97)
103 return 1;
104 /* notify devices immediately */
Jan Glauber22f99342008-12-25 13:38:46 +0100105 DBF_ERROR("%4x ccq:%3d", SCH_NO(q), ccq);
Jan Glauber779e6e12008-07-17 17:16:48 +0200106 return -EIO;
107}
108
109/**
110 * qdio_do_eqbs - extract buffer states for QEBSM
111 * @q: queue to manipulate
112 * @state: state of the extracted buffers
113 * @start: buffer number to start at
114 * @count: count of buffers to examine
Jan Glauber50f769d2008-12-25 13:38:47 +0100115 * @auto_ack: automatically acknowledge buffers
Jan Glauber779e6e12008-07-17 17:16:48 +0200116 *
Coly Li73ac36e2009-01-07 18:09:16 -0800117 * Returns the number of successfully extracted equal buffer states.
Jan Glauber779e6e12008-07-17 17:16:48 +0200118 * Stops processing if a state is different from the last buffers state.
119 */
120static int qdio_do_eqbs(struct qdio_q *q, unsigned char *state,
Jan Glauber50f769d2008-12-25 13:38:47 +0100121 int start, int count, int auto_ack)
Jan Glauber779e6e12008-07-17 17:16:48 +0200122{
123 unsigned int ccq = 0;
124 int tmp_count = count, tmp_start = start;
125 int nr = q->nr;
126 int rc;
Jan Glauber779e6e12008-07-17 17:16:48 +0200127
128 BUG_ON(!q->irq_ptr->sch_token);
Jan Glauber23589d02008-12-25 13:38:44 +0100129 qdio_perf_stat_inc(&perf_stats.debug_eqbs_all);
Jan Glauber779e6e12008-07-17 17:16:48 +0200130
131 if (!q->is_input_q)
132 nr += q->irq_ptr->nr_input_qs;
133again:
Jan Glauber50f769d2008-12-25 13:38:47 +0100134 ccq = do_eqbs(q->irq_ptr->sch_token, state, nr, &tmp_start, &tmp_count,
135 auto_ack);
Jan Glauber779e6e12008-07-17 17:16:48 +0200136 rc = qdio_check_ccq(q, ccq);
137
138 /* At least one buffer was processed, return and extract the remaining
139 * buffers later.
140 */
Jan Glauber23589d02008-12-25 13:38:44 +0100141 if ((ccq == 96) && (count != tmp_count)) {
142 qdio_perf_stat_inc(&perf_stats.debug_eqbs_incomplete);
Jan Glauber779e6e12008-07-17 17:16:48 +0200143 return (count - tmp_count);
Jan Glauber23589d02008-12-25 13:38:44 +0100144 }
Jan Glauber22f99342008-12-25 13:38:46 +0100145
Jan Glauber779e6e12008-07-17 17:16:48 +0200146 if (rc == 1) {
Jan Glauber22f99342008-12-25 13:38:46 +0100147 DBF_DEV_EVENT(DBF_WARN, q->irq_ptr, "EQBS again:%2d", ccq);
Jan Glauber779e6e12008-07-17 17:16:48 +0200148 goto again;
149 }
150
151 if (rc < 0) {
Jan Glauber22f99342008-12-25 13:38:46 +0100152 DBF_ERROR("%4x EQBS ERROR", SCH_NO(q));
153 DBF_ERROR("%3d%3d%2d", count, tmp_count, nr);
Jan Glauber779e6e12008-07-17 17:16:48 +0200154 q->handler(q->irq_ptr->cdev,
155 QDIO_ERROR_ACTIVATE_CHECK_CONDITION,
156 0, -1, -1, q->irq_ptr->int_parm);
157 return 0;
158 }
159 return count - tmp_count;
160}
161
162/**
163 * qdio_do_sqbs - set buffer states for QEBSM
164 * @q: queue to manipulate
165 * @state: new state of the buffers
166 * @start: first buffer number to change
167 * @count: how many buffers to change
168 *
169 * Returns the number of successfully changed buffers.
170 * Does retrying until the specified count of buffer states is set or an
171 * error occurs.
172 */
173static int qdio_do_sqbs(struct qdio_q *q, unsigned char state, int start,
174 int count)
175{
176 unsigned int ccq = 0;
177 int tmp_count = count, tmp_start = start;
178 int nr = q->nr;
179 int rc;
Jan Glauber779e6e12008-07-17 17:16:48 +0200180
Jan Glauber50f769d2008-12-25 13:38:47 +0100181 if (!count)
182 return 0;
183
Jan Glauber779e6e12008-07-17 17:16:48 +0200184 BUG_ON(!q->irq_ptr->sch_token);
Jan Glauber23589d02008-12-25 13:38:44 +0100185 qdio_perf_stat_inc(&perf_stats.debug_sqbs_all);
Jan Glauber779e6e12008-07-17 17:16:48 +0200186
187 if (!q->is_input_q)
188 nr += q->irq_ptr->nr_input_qs;
189again:
190 ccq = do_sqbs(q->irq_ptr->sch_token, state, nr, &tmp_start, &tmp_count);
191 rc = qdio_check_ccq(q, ccq);
192 if (rc == 1) {
Jan Glauber22f99342008-12-25 13:38:46 +0100193 DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "SQBS again:%2d", ccq);
Jan Glauber23589d02008-12-25 13:38:44 +0100194 qdio_perf_stat_inc(&perf_stats.debug_sqbs_incomplete);
Jan Glauber779e6e12008-07-17 17:16:48 +0200195 goto again;
196 }
197 if (rc < 0) {
Jan Glauber22f99342008-12-25 13:38:46 +0100198 DBF_ERROR("%4x SQBS ERROR", SCH_NO(q));
199 DBF_ERROR("%3d%3d%2d", count, tmp_count, nr);
Jan Glauber779e6e12008-07-17 17:16:48 +0200200 q->handler(q->irq_ptr->cdev,
201 QDIO_ERROR_ACTIVATE_CHECK_CONDITION,
202 0, -1, -1, q->irq_ptr->int_parm);
203 return 0;
204 }
205 WARN_ON(tmp_count);
206 return count - tmp_count;
207}
208
209/* returns number of examined buffers and their common state in *state */
210static inline int get_buf_states(struct qdio_q *q, unsigned int bufnr,
Jan Glauber50f769d2008-12-25 13:38:47 +0100211 unsigned char *state, unsigned int count,
212 int auto_ack)
Jan Glauber779e6e12008-07-17 17:16:48 +0200213{
214 unsigned char __state = 0;
215 int i;
216
217 BUG_ON(bufnr > QDIO_MAX_BUFFERS_MASK);
218 BUG_ON(count > QDIO_MAX_BUFFERS_PER_Q);
219
220 if (is_qebsm(q))
Jan Glauber50f769d2008-12-25 13:38:47 +0100221 return qdio_do_eqbs(q, state, bufnr, count, auto_ack);
Jan Glauber779e6e12008-07-17 17:16:48 +0200222
223 for (i = 0; i < count; i++) {
224 if (!__state)
225 __state = q->slsb.val[bufnr];
226 else if (q->slsb.val[bufnr] != __state)
227 break;
228 bufnr = next_buf(bufnr);
229 }
230 *state = __state;
231 return i;
232}
233
234inline int get_buf_state(struct qdio_q *q, unsigned int bufnr,
Jan Glauber50f769d2008-12-25 13:38:47 +0100235 unsigned char *state, int auto_ack)
Jan Glauber779e6e12008-07-17 17:16:48 +0200236{
Jan Glauber50f769d2008-12-25 13:38:47 +0100237 return get_buf_states(q, bufnr, state, 1, auto_ack);
Jan Glauber779e6e12008-07-17 17:16:48 +0200238}
239
240/* wrap-around safe setting of slsb states, returns number of changed buffers */
241static inline int set_buf_states(struct qdio_q *q, int bufnr,
242 unsigned char state, int count)
243{
244 int i;
245
246 BUG_ON(bufnr > QDIO_MAX_BUFFERS_MASK);
247 BUG_ON(count > QDIO_MAX_BUFFERS_PER_Q);
248
249 if (is_qebsm(q))
250 return qdio_do_sqbs(q, state, bufnr, count);
251
252 for (i = 0; i < count; i++) {
253 xchg(&q->slsb.val[bufnr], state);
254 bufnr = next_buf(bufnr);
255 }
256 return count;
257}
258
259static inline int set_buf_state(struct qdio_q *q, int bufnr,
260 unsigned char state)
261{
262 return set_buf_states(q, bufnr, state, 1);
263}
264
265/* set slsb states to initial state */
266void qdio_init_buf_states(struct qdio_irq *irq_ptr)
267{
268 struct qdio_q *q;
269 int i;
270
271 for_each_input_queue(irq_ptr, q, i)
272 set_buf_states(q, 0, SLSB_P_INPUT_NOT_INIT,
273 QDIO_MAX_BUFFERS_PER_Q);
274 for_each_output_queue(irq_ptr, q, i)
275 set_buf_states(q, 0, SLSB_P_OUTPUT_NOT_INIT,
276 QDIO_MAX_BUFFERS_PER_Q);
277}
278
279static int qdio_siga_sync(struct qdio_q *q, unsigned int output,
280 unsigned int input)
281{
282 int cc;
283
284 if (!need_siga_sync(q))
285 return 0;
286
Jan Glauber7a0b4cb2008-12-25 13:38:48 +0100287 DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "siga-s:%1d", q->nr);
Jan Glauber779e6e12008-07-17 17:16:48 +0200288 qdio_perf_stat_inc(&perf_stats.siga_sync);
289
290 cc = do_siga_sync(q->irq_ptr->schid, output, input);
Jan Glauber22f99342008-12-25 13:38:46 +0100291 if (cc)
292 DBF_ERROR("%4x SIGA-S:%2d", SCH_NO(q), cc);
Jan Glauber779e6e12008-07-17 17:16:48 +0200293 return cc;
294}
295
296inline 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
304static inline int qdio_siga_sync_out(struct qdio_q *q)
305{
306 return qdio_siga_sync(q, ~0U, 0);
307}
308
309static inline int qdio_siga_sync_all(struct qdio_q *q)
310{
311 return qdio_siga_sync(q, ~0U, ~0U);
312}
313
Jan Glauber7a0b4cb2008-12-25 13:38:48 +0100314static int qdio_siga_output(struct qdio_q *q, unsigned int *busy_bit)
Jan Glauber779e6e12008-07-17 17:16:48 +0200315{
Jan Glauber779e6e12008-07-17 17:16:48 +0200316 unsigned long schid;
Jan Glauber7a0b4cb2008-12-25 13:38:48 +0100317 unsigned int fc = 0;
318 u64 start_time = 0;
319 int cc;
Jan Glauber779e6e12008-07-17 17:16:48 +0200320
Jan Glauber7a0b4cb2008-12-25 13:38:48 +0100321 if (q->u.out.use_enh_siga)
Klaus-Dieter Wacker7a0f4752008-10-10 21:33:18 +0200322 fc = 3;
Jan Glauber7a0b4cb2008-12-25 13:38:48 +0100323
324 if (is_qebsm(q)) {
Jan Glauber779e6e12008-07-17 17:16:48 +0200325 schid = q->irq_ptr->sch_token;
326 fc |= 0x80;
327 }
Jan Glauber7a0b4cb2008-12-25 13:38:48 +0100328 else
329 schid = *((u32 *)&q->irq_ptr->schid);
Jan Glauber779e6e12008-07-17 17:16:48 +0200330
Jan Glauber779e6e12008-07-17 17:16:48 +0200331again:
Jan Glauber7a0b4cb2008-12-25 13:38:48 +0100332 cc = do_siga_output(schid, q->mask, busy_bit, fc);
Jan Glauber58eb27c2008-08-21 19:46:34 +0200333
Jan Glauber7a0b4cb2008-12-25 13:38:48 +0100334 /* hipersocket busy condition */
335 if (*busy_bit) {
336 WARN_ON(queue_type(q) != QDIO_IQDIO_QFMT || cc != 2);
337
338 if (!start_time) {
Jan Glauber779e6e12008-07-17 17:16:48 +0200339 start_time = get_usecs();
Jan Glauber7a0b4cb2008-12-25 13:38:48 +0100340 goto again;
341 }
342 if ((get_usecs() - start_time) < QDIO_BUSY_BIT_PATIENCE)
Jan Glauber779e6e12008-07-17 17:16:48 +0200343 goto again;
344 }
Jan Glauber779e6e12008-07-17 17:16:48 +0200345 return cc;
346}
347
348static inline int qdio_siga_input(struct qdio_q *q)
349{
350 int cc;
351
Jan Glauber22f99342008-12-25 13:38:46 +0100352 DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "siga-r:%1d", q->nr);
Jan Glauber779e6e12008-07-17 17:16:48 +0200353 qdio_perf_stat_inc(&perf_stats.siga_in);
354
355 cc = do_siga_input(q->irq_ptr->schid, q->mask);
356 if (cc)
Jan Glauber22f99342008-12-25 13:38:46 +0100357 DBF_ERROR("%4x SIGA-R:%2d", SCH_NO(q), cc);
Jan Glauber779e6e12008-07-17 17:16:48 +0200358 return cc;
359}
360
361/* called from thinint inbound handler */
362void qdio_sync_after_thinint(struct qdio_q *q)
363{
364 if (pci_out_supported(q)) {
365 if (need_siga_sync_thinint(q))
366 qdio_siga_sync_all(q);
367 else if (need_siga_sync_out_thinint(q))
368 qdio_siga_sync_out(q);
369 } else
370 qdio_siga_sync_q(q);
371}
372
373inline void qdio_stop_polling(struct qdio_q *q)
374{
Jan Glauber50f769d2008-12-25 13:38:47 +0100375 if (!q->u.in.polling)
Jan Glauber779e6e12008-07-17 17:16:48 +0200376 return;
Jan Glauber50f769d2008-12-25 13:38:47 +0100377
Jan Glauber779e6e12008-07-17 17:16:48 +0200378 q->u.in.polling = 0;
379 qdio_perf_stat_inc(&perf_stats.debug_stop_polling);
380
381 /* show the card that we are not polling anymore */
Jan Glauber50f769d2008-12-25 13:38:47 +0100382 if (is_qebsm(q)) {
Jan Glaubere85dea02009-03-26 15:24:29 +0100383 set_buf_states(q, q->u.in.ack_start, SLSB_P_INPUT_NOT_INIT,
Jan Glauber50f769d2008-12-25 13:38:47 +0100384 q->u.in.ack_count);
385 q->u.in.ack_count = 0;
386 } else
Jan Glaubere85dea02009-03-26 15:24:29 +0100387 set_buf_state(q, q->u.in.ack_start, SLSB_P_INPUT_NOT_INIT);
Jan Glauber779e6e12008-07-17 17:16:48 +0200388}
389
Jan Glauber50f769d2008-12-25 13:38:47 +0100390static void announce_buffer_error(struct qdio_q *q, int count)
Jan Glauber779e6e12008-07-17 17:16:48 +0200391{
Jan Glauber7a0b4cb2008-12-25 13:38:48 +0100392 q->qdio_error |= QDIO_ERROR_SLSB_STATE;
Jan Glauber50f769d2008-12-25 13:38:47 +0100393
394 /* special handling for no target buffer empty */
395 if ((!q->is_input_q &&
396 (q->sbal[q->first_to_check]->element[15].flags & 0xff) == 0x10)) {
397 qdio_perf_stat_inc(&perf_stats.outbound_target_full);
398 DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "OUTFULL FTC:%3d",
399 q->first_to_check);
400 return;
401 }
402
Jan Glauber22f99342008-12-25 13:38:46 +0100403 DBF_ERROR("%4x BUF ERROR", SCH_NO(q));
404 DBF_ERROR((q->is_input_q) ? "IN:%2d" : "OUT:%2d", q->nr);
Jan Glauber50f769d2008-12-25 13:38:47 +0100405 DBF_ERROR("FTC:%3d C:%3d", q->first_to_check, count);
Jan Glauber22f99342008-12-25 13:38:46 +0100406 DBF_ERROR("F14:%2x F15:%2x",
407 q->sbal[q->first_to_check]->element[14].flags & 0xff,
408 q->sbal[q->first_to_check]->element[15].flags & 0xff);
Jan Glauber50f769d2008-12-25 13:38:47 +0100409}
Jan Glauber779e6e12008-07-17 17:16:48 +0200410
Jan Glauber50f769d2008-12-25 13:38:47 +0100411static inline void inbound_primed(struct qdio_q *q, int count)
412{
413 int new;
414
415 DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "in prim: %3d", count);
416
417 /* for QEBSM the ACK was already set by EQBS */
418 if (is_qebsm(q)) {
419 if (!q->u.in.polling) {
420 q->u.in.polling = 1;
421 q->u.in.ack_count = count;
Jan Glaubere85dea02009-03-26 15:24:29 +0100422 q->u.in.ack_start = q->first_to_check;
Jan Glauber50f769d2008-12-25 13:38:47 +0100423 return;
424 }
425
426 /* delete the previous ACK's */
Jan Glaubere85dea02009-03-26 15:24:29 +0100427 set_buf_states(q, q->u.in.ack_start, SLSB_P_INPUT_NOT_INIT,
Jan Glauber50f769d2008-12-25 13:38:47 +0100428 q->u.in.ack_count);
429 q->u.in.ack_count = count;
Jan Glaubere85dea02009-03-26 15:24:29 +0100430 q->u.in.ack_start = q->first_to_check;
Jan Glauber50f769d2008-12-25 13:38:47 +0100431 return;
432 }
433
434 /*
435 * ACK the newest buffer. The ACK will be removed in qdio_stop_polling
436 * or by the next inbound run.
437 */
438 new = add_buf(q->first_to_check, count - 1);
439 if (q->u.in.polling) {
440 /* reset the previous ACK but first set the new one */
441 set_buf_state(q, new, SLSB_P_INPUT_ACK);
Jan Glaubere85dea02009-03-26 15:24:29 +0100442 set_buf_state(q, q->u.in.ack_start, SLSB_P_INPUT_NOT_INIT);
Jan Glauber3fdf1e12009-03-26 15:24:28 +0100443 } else {
Jan Glauber50f769d2008-12-25 13:38:47 +0100444 q->u.in.polling = 1;
Jan Glauber3fdf1e12009-03-26 15:24:28 +0100445 set_buf_state(q, new, SLSB_P_INPUT_ACK);
Jan Glauber50f769d2008-12-25 13:38:47 +0100446 }
447
Jan Glaubere85dea02009-03-26 15:24:29 +0100448 q->u.in.ack_start = new;
Jan Glauber50f769d2008-12-25 13:38:47 +0100449 count--;
450 if (!count)
451 return;
452
453 /*
454 * Need to change all PRIMED buffers to NOT_INIT, otherwise
455 * we're loosing initiative in the thinint code.
456 */
Jan Glauber3fdf1e12009-03-26 15:24:28 +0100457 set_buf_states(q, q->first_to_check, SLSB_P_INPUT_NOT_INIT,
Jan Glauber50f769d2008-12-25 13:38:47 +0100458 count);
Jan Glauber779e6e12008-07-17 17:16:48 +0200459}
460
461static int get_inbound_buffer_frontier(struct qdio_q *q)
462{
463 int count, stop;
464 unsigned char state;
465
466 /*
Jan Glauber779e6e12008-07-17 17:16:48 +0200467 * 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 /*
474 * No siga sync here, as a PCI or we after a thin interrupt
475 * will sync the queues.
476 */
477
478 /* need to set count to 1 for non-qebsm */
479 if (!is_qebsm(q))
480 count = 1;
481
482check_next:
483 if (q->first_to_check == stop)
484 goto out;
485
Jan Glauber50f769d2008-12-25 13:38:47 +0100486 count = get_buf_states(q, q->first_to_check, &state, count, 1);
Jan Glauber779e6e12008-07-17 17:16:48 +0200487 if (!count)
488 goto out;
489
490 switch (state) {
491 case SLSB_P_INPUT_PRIMED:
Jan Glauber50f769d2008-12-25 13:38:47 +0100492 inbound_primed(q, count);
Jan Glauber779e6e12008-07-17 17:16:48 +0200493 /*
494 * No siga-sync needed for non-qebsm here, as the inbound queue
495 * will be synced on the next siga-r, resp.
496 * tiqdio_is_inbound_q_done will do the siga-sync.
497 */
498 q->first_to_check = add_buf(q->first_to_check, count);
499 atomic_sub(count, &q->nr_buf_used);
500 goto check_next;
501 case SLSB_P_INPUT_ERROR:
Jan Glauber50f769d2008-12-25 13:38:47 +0100502 announce_buffer_error(q, count);
Jan Glauber779e6e12008-07-17 17:16:48 +0200503 /* process the buffer, the upper layer will take care of it */
504 q->first_to_check = add_buf(q->first_to_check, count);
505 atomic_sub(count, &q->nr_buf_used);
506 break;
507 case SLSB_CU_INPUT_EMPTY:
508 case SLSB_P_INPUT_NOT_INIT:
509 case SLSB_P_INPUT_ACK:
Jan Glauber22f99342008-12-25 13:38:46 +0100510 DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "in nop");
Jan Glauber779e6e12008-07-17 17:16:48 +0200511 break;
512 default:
513 BUG();
514 }
515out:
Jan Glauber779e6e12008-07-17 17:16:48 +0200516 return q->first_to_check;
517}
518
519int qdio_inbound_q_moved(struct qdio_q *q)
520{
521 int bufnr;
522
523 bufnr = get_inbound_buffer_frontier(q);
524
Jan Glaubere85dea02009-03-26 15:24:29 +0100525 if ((bufnr != q->last_move) || q->qdio_error) {
526 q->last_move = bufnr;
Jan Glauber779e6e12008-07-17 17:16:48 +0200527 if (!need_siga_sync(q) && !pci_out_supported(q))
528 q->u.in.timestamp = get_usecs();
529
Jan Glauber22f99342008-12-25 13:38:46 +0100530 DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "in moved");
Jan Glauber779e6e12008-07-17 17:16:48 +0200531 return 1;
532 } else
533 return 0;
534}
535
536static int qdio_inbound_q_done(struct qdio_q *q)
537{
Jan Glauber9a1ce282008-12-25 13:38:45 +0100538 unsigned char state = 0;
Jan Glauber779e6e12008-07-17 17:16:48 +0200539
540 if (!atomic_read(&q->nr_buf_used))
541 return 1;
542
543 /*
544 * We need that one for synchronization with the adapter, as it
545 * does a kind of PCI avoidance.
546 */
547 qdio_siga_sync_q(q);
548
Jan Glauber50f769d2008-12-25 13:38:47 +0100549 get_buf_state(q, q->first_to_check, &state, 0);
Jan Glauber779e6e12008-07-17 17:16:48 +0200550 if (state == SLSB_P_INPUT_PRIMED)
551 /* we got something to do */
552 return 0;
553
554 /* on VM, we don't poll, so the q is always done here */
555 if (need_siga_sync(q) || pci_out_supported(q))
556 return 1;
557
558 /*
559 * At this point we know, that inbound first_to_check
560 * has (probably) not moved (see qdio_inbound_processing).
561 */
562 if (get_usecs() > q->u.in.timestamp + QDIO_INPUT_THRESHOLD) {
Jan Glauber22f99342008-12-25 13:38:46 +0100563 DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "in done:%3d",
564 q->first_to_check);
Jan Glauber779e6e12008-07-17 17:16:48 +0200565 return 1;
566 } else {
Jan Glauber22f99342008-12-25 13:38:46 +0100567 DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "in notd:%3d",
568 q->first_to_check);
Jan Glauber779e6e12008-07-17 17:16:48 +0200569 return 0;
570 }
571}
572
573void qdio_kick_inbound_handler(struct qdio_q *q)
574{
575 int count, start, end;
Jan Glauber779e6e12008-07-17 17:16:48 +0200576
577 qdio_perf_stat_inc(&perf_stats.inbound_handler);
578
579 start = q->first_to_kick;
580 end = q->first_to_check;
581 if (end >= start)
582 count = end - start;
583 else
584 count = end + QDIO_MAX_BUFFERS_PER_Q - start;
585
Jan Glauber22f99342008-12-25 13:38:46 +0100586 DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "kih s:%3d c:%3d", start, count);
Jan Glauber779e6e12008-07-17 17:16:48 +0200587
588 if (unlikely(q->irq_ptr->state != QDIO_IRQ_STATE_ACTIVE))
589 return;
590
591 q->handler(q->irq_ptr->cdev, q->qdio_error, q->nr,
592 start, count, q->irq_ptr->int_parm);
593
594 /* for the next time */
595 q->first_to_kick = q->first_to_check;
596 q->qdio_error = 0;
597}
598
599static void __qdio_inbound_processing(struct qdio_q *q)
600{
601 qdio_perf_stat_inc(&perf_stats.tasklet_inbound);
602again:
603 if (!qdio_inbound_q_moved(q))
604 return;
605
606 qdio_kick_inbound_handler(q);
607
608 if (!qdio_inbound_q_done(q))
609 /* means poll time is not yet over */
610 goto again;
611
612 qdio_stop_polling(q);
613 /*
614 * We need to check again to not lose initiative after
615 * resetting the ACK state.
616 */
617 if (!qdio_inbound_q_done(q))
618 goto again;
619}
620
621/* inbound tasklet */
622void qdio_inbound_processing(unsigned long data)
623{
624 struct qdio_q *q = (struct qdio_q *)data;
625 __qdio_inbound_processing(q);
626}
627
628static int get_outbound_buffer_frontier(struct qdio_q *q)
629{
630 int count, stop;
631 unsigned char state;
632
633 if (((queue_type(q) != QDIO_IQDIO_QFMT) && !pci_out_supported(q)) ||
634 (queue_type(q) == QDIO_IQDIO_QFMT && multicast_outbound(q)))
635 qdio_siga_sync_q(q);
636
637 /*
638 * Don't check 128 buffers, as otherwise qdio_inbound_q_moved
639 * would return 0.
640 */
641 count = min(atomic_read(&q->nr_buf_used), QDIO_MAX_BUFFERS_MASK);
642 stop = add_buf(q->first_to_check, count);
643
644 /* need to set count to 1 for non-qebsm */
645 if (!is_qebsm(q))
646 count = 1;
647
648check_next:
649 if (q->first_to_check == stop)
650 return q->first_to_check;
651
Jan Glauber50f769d2008-12-25 13:38:47 +0100652 count = get_buf_states(q, q->first_to_check, &state, count, 0);
Jan Glauber779e6e12008-07-17 17:16:48 +0200653 if (!count)
654 return q->first_to_check;
655
656 switch (state) {
657 case SLSB_P_OUTPUT_EMPTY:
658 /* the adapter got it */
Jan Glauber22f99342008-12-25 13:38:46 +0100659 DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "out empty:%1d %3d", q->nr, count);
Jan Glauber779e6e12008-07-17 17:16:48 +0200660
661 atomic_sub(count, &q->nr_buf_used);
662 q->first_to_check = add_buf(q->first_to_check, count);
663 /*
664 * We fetch all buffer states at once. get_buf_states may
665 * return count < stop. For QEBSM we do not loop.
666 */
667 if (is_qebsm(q))
668 break;
669 goto check_next;
670 case SLSB_P_OUTPUT_ERROR:
Jan Glauber50f769d2008-12-25 13:38:47 +0100671 announce_buffer_error(q, count);
Jan Glauber779e6e12008-07-17 17:16:48 +0200672 /* process the buffer, the upper layer will take care of it */
673 q->first_to_check = add_buf(q->first_to_check, count);
674 atomic_sub(count, &q->nr_buf_used);
675 break;
676 case SLSB_CU_OUTPUT_PRIMED:
677 /* the adapter has not fetched the output yet */
Jan Glauber22f99342008-12-25 13:38:46 +0100678 DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "out primed:%1d", q->nr);
Jan Glauber779e6e12008-07-17 17:16:48 +0200679 break;
680 case SLSB_P_OUTPUT_NOT_INIT:
681 case SLSB_P_OUTPUT_HALTED:
682 break;
683 default:
684 BUG();
685 }
686 return q->first_to_check;
687}
688
689/* all buffers processed? */
690static inline int qdio_outbound_q_done(struct qdio_q *q)
691{
692 return atomic_read(&q->nr_buf_used) == 0;
693}
694
695static inline int qdio_outbound_q_moved(struct qdio_q *q)
696{
697 int bufnr;
698
699 bufnr = get_outbound_buffer_frontier(q);
700
Jan Glaubere85dea02009-03-26 15:24:29 +0100701 if ((bufnr != q->last_move) || q->qdio_error) {
702 q->last_move = bufnr;
Jan Glauber22f99342008-12-25 13:38:46 +0100703 DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "out moved:%1d", q->nr);
Jan Glauber779e6e12008-07-17 17:16:48 +0200704 return 1;
705 } else
706 return 0;
707}
708
Jan Glauberd303b6f2009-03-26 15:24:31 +0100709static int qdio_kick_outbound_q(struct qdio_q *q)
Jan Glauber779e6e12008-07-17 17:16:48 +0200710{
Jan Glauber7a0b4cb2008-12-25 13:38:48 +0100711 unsigned int busy_bit;
712 int cc;
Jan Glauber779e6e12008-07-17 17:16:48 +0200713
714 if (!need_siga_out(q))
Jan Glauberd303b6f2009-03-26 15:24:31 +0100715 return 0;
Jan Glauber779e6e12008-07-17 17:16:48 +0200716
Jan Glauber7a0b4cb2008-12-25 13:38:48 +0100717 DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "siga-w:%1d", q->nr);
718 qdio_perf_stat_inc(&perf_stats.siga_out);
719
720 cc = qdio_siga_output(q, &busy_bit);
721 switch (cc) {
Jan Glauber779e6e12008-07-17 17:16:48 +0200722 case 0:
Jan Glauber779e6e12008-07-17 17:16:48 +0200723 break;
Jan Glauber7a0b4cb2008-12-25 13:38:48 +0100724 case 2:
725 if (busy_bit) {
726 DBF_ERROR("%4x cc2 REP:%1d", SCH_NO(q), q->nr);
Jan Glauberd303b6f2009-03-26 15:24:31 +0100727 cc |= QDIO_ERROR_SIGA_BUSY;
728 } else
729 DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "siga-w cc2:%1d", q->nr);
Jan Glauber7a0b4cb2008-12-25 13:38:48 +0100730 break;
731 case 1:
732 case 3:
733 DBF_ERROR("%4x SIGA-W:%1d", SCH_NO(q), cc);
Jan Glauber7a0b4cb2008-12-25 13:38:48 +0100734 break;
Jan Glauber779e6e12008-07-17 17:16:48 +0200735 }
Jan Glauberd303b6f2009-03-26 15:24:31 +0100736 return cc;
Jan Glauber779e6e12008-07-17 17:16:48 +0200737}
738
739static void qdio_kick_outbound_handler(struct qdio_q *q)
740{
741 int start, end, count;
Jan Glauber779e6e12008-07-17 17:16:48 +0200742
743 start = q->first_to_kick;
Jan Glaubere85dea02009-03-26 15:24:29 +0100744 end = q->last_move;
Jan Glauber779e6e12008-07-17 17:16:48 +0200745 if (end >= start)
746 count = end - start;
747 else
748 count = end + QDIO_MAX_BUFFERS_PER_Q - start;
749
Jan Glauber22f99342008-12-25 13:38:46 +0100750 DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "kickouth: %1d", q->nr);
751 DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "s:%3d c:%3d", start, count);
Jan Glauber779e6e12008-07-17 17:16:48 +0200752
753 if (unlikely(q->irq_ptr->state != QDIO_IRQ_STATE_ACTIVE))
754 return;
755
756 q->handler(q->irq_ptr->cdev, q->qdio_error, q->nr, start, count,
757 q->irq_ptr->int_parm);
758
759 /* for the next time: */
Jan Glaubere85dea02009-03-26 15:24:29 +0100760 q->first_to_kick = q->last_move;
Jan Glauber779e6e12008-07-17 17:16:48 +0200761 q->qdio_error = 0;
762}
763
764static void __qdio_outbound_processing(struct qdio_q *q)
765{
Jan Glauber779e6e12008-07-17 17:16:48 +0200766 qdio_perf_stat_inc(&perf_stats.tasklet_outbound);
Jan Glauber779e6e12008-07-17 17:16:48 +0200767 BUG_ON(atomic_read(&q->nr_buf_used) < 0);
768
769 if (qdio_outbound_q_moved(q))
770 qdio_kick_outbound_handler(q);
771
Jan Glauberc38f9602009-03-26 15:24:26 +0100772 if (queue_type(q) == QDIO_ZFCP_QFMT)
Jan Glauber779e6e12008-07-17 17:16:48 +0200773 if (!pci_out_supported(q) && !qdio_outbound_q_done(q))
Jan Glauberc38f9602009-03-26 15:24:26 +0100774 goto sched;
Jan Glauber779e6e12008-07-17 17:16:48 +0200775
776 /* bail out for HiperSockets unicast queues */
777 if (queue_type(q) == QDIO_IQDIO_QFMT && !multicast_outbound(q))
778 return;
779
Ursula Braun4bcb3a32008-10-10 21:33:04 +0200780 if ((queue_type(q) == QDIO_IQDIO_QFMT) &&
Jan Glauberc38f9602009-03-26 15:24:26 +0100781 (atomic_read(&q->nr_buf_used)) > QDIO_IQDIO_POLL_LVL)
782 goto sched;
Ursula Braun4bcb3a32008-10-10 21:33:04 +0200783
Jan Glauber779e6e12008-07-17 17:16:48 +0200784 if (q->u.out.pci_out_enabled)
785 return;
786
787 /*
788 * Now we know that queue type is either qeth without pci enabled
789 * or HiperSockets multicast. Make sure buffer switch from PRIMED to
790 * EMPTY is noticed and outbound_handler is called after some time.
791 */
792 if (qdio_outbound_q_done(q))
793 del_timer(&q->u.out.timer);
794 else {
795 if (!timer_pending(&q->u.out.timer)) {
796 mod_timer(&q->u.out.timer, jiffies + 10 * HZ);
797 qdio_perf_stat_inc(&perf_stats.debug_tl_out_timer);
798 }
799 }
Jan Glauberc38f9602009-03-26 15:24:26 +0100800 return;
801
802sched:
803 if (unlikely(q->irq_ptr->state == QDIO_IRQ_STATE_STOPPED))
804 return;
805 tasklet_schedule(&q->tasklet);
Jan Glauber779e6e12008-07-17 17:16:48 +0200806}
807
808/* outbound tasklet */
809void qdio_outbound_processing(unsigned long data)
810{
811 struct qdio_q *q = (struct qdio_q *)data;
812 __qdio_outbound_processing(q);
813}
814
815void qdio_outbound_timer(unsigned long data)
816{
817 struct qdio_q *q = (struct qdio_q *)data;
Jan Glauberc38f9602009-03-26 15:24:26 +0100818
819 if (unlikely(q->irq_ptr->state == QDIO_IRQ_STATE_STOPPED))
820 return;
Jan Glauber779e6e12008-07-17 17:16:48 +0200821 tasklet_schedule(&q->tasklet);
822}
823
824/* called from thinint inbound tasklet */
825void qdio_check_outbound_after_thinint(struct qdio_q *q)
826{
827 struct qdio_q *out;
828 int i;
829
830 if (!pci_out_supported(q))
831 return;
832
833 for_each_output_queue(q->irq_ptr, out, i)
834 if (!qdio_outbound_q_done(out))
835 tasklet_schedule(&out->tasklet);
836}
837
838static inline void qdio_set_state(struct qdio_irq *irq_ptr,
839 enum qdio_irq_states state)
840{
Jan Glauber22f99342008-12-25 13:38:46 +0100841 DBF_DEV_EVENT(DBF_INFO, irq_ptr, "newstate: %1d", state);
Jan Glauber779e6e12008-07-17 17:16:48 +0200842
843 irq_ptr->state = state;
844 mb();
845}
846
Jan Glauber22f99342008-12-25 13:38:46 +0100847static void qdio_irq_check_sense(struct qdio_irq *irq_ptr, struct irb *irb)
Jan Glauber779e6e12008-07-17 17:16:48 +0200848{
Jan Glauber779e6e12008-07-17 17:16:48 +0200849 if (irb->esw.esw0.erw.cons) {
Jan Glauber22f99342008-12-25 13:38:46 +0100850 DBF_ERROR("%4x sense:", irq_ptr->schid.sch_no);
851 DBF_ERROR_HEX(irb, 64);
852 DBF_ERROR_HEX(irb->ecw, 64);
Jan Glauber779e6e12008-07-17 17:16:48 +0200853 }
854}
855
856/* PCI interrupt handler */
857static void qdio_int_handler_pci(struct qdio_irq *irq_ptr)
858{
859 int i;
860 struct qdio_q *q;
861
Jan Glauberc38f9602009-03-26 15:24:26 +0100862 if (unlikely(irq_ptr->state == QDIO_IRQ_STATE_STOPPED))
863 return;
864
Jan Glauber779e6e12008-07-17 17:16:48 +0200865 qdio_perf_stat_inc(&perf_stats.pci_int);
866
867 for_each_input_queue(irq_ptr, q, i)
868 tasklet_schedule(&q->tasklet);
869
870 if (!(irq_ptr->qib.ac & QIB_AC_OUTBOUND_PCI_SUPPORTED))
871 return;
872
873 for_each_output_queue(irq_ptr, q, i) {
874 if (qdio_outbound_q_done(q))
875 continue;
876
877 if (!siga_syncs_out_pci(q))
878 qdio_siga_sync_q(q);
879
880 tasklet_schedule(&q->tasklet);
881 }
882}
883
884static void qdio_handle_activate_check(struct ccw_device *cdev,
885 unsigned long intparm, int cstat, int dstat)
886{
887 struct qdio_irq *irq_ptr = cdev->private->qdio_data;
888 struct qdio_q *q;
Jan Glauber779e6e12008-07-17 17:16:48 +0200889
Jan Glauber22f99342008-12-25 13:38:46 +0100890 DBF_ERROR("%4x ACT CHECK", irq_ptr->schid.sch_no);
891 DBF_ERROR("intp :%lx", intparm);
892 DBF_ERROR("ds: %2x cs:%2x", dstat, cstat);
Jan Glauber779e6e12008-07-17 17:16:48 +0200893
894 if (irq_ptr->nr_input_qs) {
895 q = irq_ptr->input_qs[0];
896 } else if (irq_ptr->nr_output_qs) {
897 q = irq_ptr->output_qs[0];
898 } else {
899 dump_stack();
900 goto no_handler;
901 }
902 q->handler(q->irq_ptr->cdev, QDIO_ERROR_ACTIVATE_CHECK_CONDITION,
903 0, -1, -1, irq_ptr->int_parm);
904no_handler:
905 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_STOPPED);
906}
907
908static void qdio_call_shutdown(struct work_struct *work)
909{
910 struct ccw_device_private *priv;
911 struct ccw_device *cdev;
912
913 priv = container_of(work, struct ccw_device_private, kick_work);
914 cdev = priv->cdev;
915 qdio_shutdown(cdev, QDIO_FLAG_CLEANUP_USING_CLEAR);
916 put_device(&cdev->dev);
917}
918
919static void qdio_int_error(struct ccw_device *cdev)
920{
921 struct qdio_irq *irq_ptr = cdev->private->qdio_data;
922
923 switch (irq_ptr->state) {
924 case QDIO_IRQ_STATE_INACTIVE:
925 case QDIO_IRQ_STATE_CLEANUP:
926 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_ERR);
927 break;
928 case QDIO_IRQ_STATE_ESTABLISHED:
929 case QDIO_IRQ_STATE_ACTIVE:
930 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_STOPPED);
931 if (get_device(&cdev->dev)) {
932 /* Can't call shutdown from interrupt context. */
933 PREPARE_WORK(&cdev->private->kick_work,
934 qdio_call_shutdown);
935 queue_work(ccw_device_work, &cdev->private->kick_work);
936 }
937 break;
938 default:
939 WARN_ON(1);
940 }
941 wake_up(&cdev->private->wait_q);
942}
943
944static int qdio_establish_check_errors(struct ccw_device *cdev, int cstat,
Jan Glauber22f99342008-12-25 13:38:46 +0100945 int dstat)
Jan Glauber779e6e12008-07-17 17:16:48 +0200946{
947 struct qdio_irq *irq_ptr = cdev->private->qdio_data;
948
949 if (cstat || (dstat & ~(DEV_STAT_CHN_END | DEV_STAT_DEV_END))) {
Jan Glauber22f99342008-12-25 13:38:46 +0100950 DBF_ERROR("EQ:ck con");
Jan Glauber779e6e12008-07-17 17:16:48 +0200951 goto error;
952 }
953
954 if (!(dstat & DEV_STAT_DEV_END)) {
Jan Glauber22f99342008-12-25 13:38:46 +0100955 DBF_ERROR("EQ:no dev");
Jan Glauber779e6e12008-07-17 17:16:48 +0200956 goto error;
957 }
958
959 if (dstat & ~(DEV_STAT_CHN_END | DEV_STAT_DEV_END)) {
Jan Glauber22f99342008-12-25 13:38:46 +0100960 DBF_ERROR("EQ: bad io");
Jan Glauber779e6e12008-07-17 17:16:48 +0200961 goto error;
962 }
963 return 0;
964error:
Jan Glauber22f99342008-12-25 13:38:46 +0100965 DBF_ERROR("%4x EQ:error", irq_ptr->schid.sch_no);
966 DBF_ERROR("ds: %2x cs:%2x", dstat, cstat);
967
Jan Glauber779e6e12008-07-17 17:16:48 +0200968 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_ERR);
969 return 1;
970}
971
972static void qdio_establish_handle_irq(struct ccw_device *cdev, int cstat,
973 int dstat)
974{
975 struct qdio_irq *irq_ptr = cdev->private->qdio_data;
Jan Glauber779e6e12008-07-17 17:16:48 +0200976
Jan Glauber22f99342008-12-25 13:38:46 +0100977 DBF_DEV_EVENT(DBF_INFO, irq_ptr, "qest irq");
Jan Glauber779e6e12008-07-17 17:16:48 +0200978 if (!qdio_establish_check_errors(cdev, cstat, dstat))
979 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_ESTABLISHED);
980}
981
982/* qdio interrupt handler */
983void qdio_int_handler(struct ccw_device *cdev, unsigned long intparm,
984 struct irb *irb)
985{
986 struct qdio_irq *irq_ptr = cdev->private->qdio_data;
987 int cstat, dstat;
Jan Glauber779e6e12008-07-17 17:16:48 +0200988
989 qdio_perf_stat_inc(&perf_stats.qdio_int);
990
991 if (!intparm || !irq_ptr) {
Jan Glauber22f99342008-12-25 13:38:46 +0100992 DBF_ERROR("qint:%4x", cdev->private->schid.sch_no);
Jan Glauber779e6e12008-07-17 17:16:48 +0200993 return;
994 }
995
996 if (IS_ERR(irb)) {
997 switch (PTR_ERR(irb)) {
998 case -EIO:
Jan Glauber22f99342008-12-25 13:38:46 +0100999 DBF_ERROR("%4x IO error", irq_ptr->schid.sch_no);
Jan Glauber779e6e12008-07-17 17:16:48 +02001000 return;
1001 case -ETIMEDOUT:
Jan Glauber22f99342008-12-25 13:38:46 +01001002 DBF_ERROR("%4x IO timeout", irq_ptr->schid.sch_no);
Jan Glauber779e6e12008-07-17 17:16:48 +02001003 qdio_int_error(cdev);
1004 return;
1005 default:
1006 WARN_ON(1);
1007 return;
1008 }
1009 }
Jan Glauber22f99342008-12-25 13:38:46 +01001010 qdio_irq_check_sense(irq_ptr, irb);
Jan Glauber779e6e12008-07-17 17:16:48 +02001011
1012 cstat = irb->scsw.cmd.cstat;
1013 dstat = irb->scsw.cmd.dstat;
1014
1015 switch (irq_ptr->state) {
1016 case QDIO_IRQ_STATE_INACTIVE:
1017 qdio_establish_handle_irq(cdev, cstat, dstat);
1018 break;
1019
1020 case QDIO_IRQ_STATE_CLEANUP:
1021 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_INACTIVE);
1022 break;
1023
1024 case QDIO_IRQ_STATE_ESTABLISHED:
1025 case QDIO_IRQ_STATE_ACTIVE:
1026 if (cstat & SCHN_STAT_PCI) {
1027 qdio_int_handler_pci(irq_ptr);
1028 /* no state change so no need to wake up wait_q */
1029 return;
1030 }
1031 if ((cstat & ~SCHN_STAT_PCI) || dstat) {
1032 qdio_handle_activate_check(cdev, intparm, cstat,
1033 dstat);
1034 break;
1035 }
1036 default:
1037 WARN_ON(1);
1038 }
1039 wake_up(&cdev->private->wait_q);
1040}
1041
1042/**
1043 * qdio_get_ssqd_desc - get qdio subchannel description
1044 * @cdev: ccw device to get description for
Jan Glauberbbd50e12008-12-25 13:38:43 +01001045 * @data: where to store the ssqd
Jan Glauber779e6e12008-07-17 17:16:48 +02001046 *
Jan Glauberbbd50e12008-12-25 13:38:43 +01001047 * Returns 0 or an error code. The results of the chsc are stored in the
1048 * specified structure.
Jan Glauber779e6e12008-07-17 17:16:48 +02001049 */
Jan Glauberbbd50e12008-12-25 13:38:43 +01001050int qdio_get_ssqd_desc(struct ccw_device *cdev,
1051 struct qdio_ssqd_desc *data)
Jan Glauber779e6e12008-07-17 17:16:48 +02001052{
Jan Glauber779e6e12008-07-17 17:16:48 +02001053
Jan Glauberbbd50e12008-12-25 13:38:43 +01001054 if (!cdev || !cdev->private)
1055 return -EINVAL;
1056
Jan Glauber22f99342008-12-25 13:38:46 +01001057 DBF_EVENT("get ssqd:%4x", cdev->private->schid.sch_no);
Jan Glauberbbd50e12008-12-25 13:38:43 +01001058 return qdio_setup_get_ssqd(NULL, &cdev->private->schid, data);
Jan Glauber779e6e12008-07-17 17:16:48 +02001059}
1060EXPORT_SYMBOL_GPL(qdio_get_ssqd_desc);
1061
1062/**
1063 * qdio_cleanup - shutdown queues and free data structures
1064 * @cdev: associated ccw device
1065 * @how: use halt or clear to shutdown
1066 *
Jan Glauber700e9822009-03-26 15:24:27 +01001067 * This function calls qdio_shutdown() for @cdev with method @how.
1068 * and qdio_free(). The qdio_free() return value is ignored since
1069 * !irq_ptr is already checked.
Jan Glauber779e6e12008-07-17 17:16:48 +02001070 */
1071int qdio_cleanup(struct ccw_device *cdev, int how)
1072{
Jan Glauber22f99342008-12-25 13:38:46 +01001073 struct qdio_irq *irq_ptr = cdev->private->qdio_data;
Jan Glauber779e6e12008-07-17 17:16:48 +02001074 int rc;
1075
Jan Glauber779e6e12008-07-17 17:16:48 +02001076 if (!irq_ptr)
1077 return -ENODEV;
1078
Jan Glauber779e6e12008-07-17 17:16:48 +02001079 rc = qdio_shutdown(cdev, how);
Jan Glauber700e9822009-03-26 15:24:27 +01001080
1081 qdio_free(cdev);
Jan Glauber779e6e12008-07-17 17:16:48 +02001082 return rc;
1083}
1084EXPORT_SYMBOL_GPL(qdio_cleanup);
1085
1086static void qdio_shutdown_queues(struct ccw_device *cdev)
1087{
1088 struct qdio_irq *irq_ptr = cdev->private->qdio_data;
1089 struct qdio_q *q;
1090 int i;
1091
1092 for_each_input_queue(irq_ptr, q, i)
Jan Glauberc38f9602009-03-26 15:24:26 +01001093 tasklet_kill(&q->tasklet);
Jan Glauber779e6e12008-07-17 17:16:48 +02001094
1095 for_each_output_queue(irq_ptr, q, i) {
Jan Glauber779e6e12008-07-17 17:16:48 +02001096 del_timer(&q->u.out.timer);
Jan Glauberc38f9602009-03-26 15:24:26 +01001097 tasklet_kill(&q->tasklet);
Jan Glauber779e6e12008-07-17 17:16:48 +02001098 }
1099}
1100
1101/**
1102 * qdio_shutdown - shut down a qdio subchannel
1103 * @cdev: associated ccw device
1104 * @how: use halt or clear to shutdown
1105 */
1106int qdio_shutdown(struct ccw_device *cdev, int how)
1107{
Jan Glauber22f99342008-12-25 13:38:46 +01001108 struct qdio_irq *irq_ptr = cdev->private->qdio_data;
Jan Glauber779e6e12008-07-17 17:16:48 +02001109 int rc;
1110 unsigned long flags;
Jan Glauber779e6e12008-07-17 17:16:48 +02001111
Jan Glauber779e6e12008-07-17 17:16:48 +02001112 if (!irq_ptr)
1113 return -ENODEV;
1114
Jan Glauberb4547402009-03-26 15:24:24 +01001115 BUG_ON(irqs_disabled());
Jan Glauber22f99342008-12-25 13:38:46 +01001116 DBF_EVENT("qshutdown:%4x", cdev->private->schid.sch_no);
1117
Jan Glauber779e6e12008-07-17 17:16:48 +02001118 mutex_lock(&irq_ptr->setup_mutex);
1119 /*
1120 * Subchannel was already shot down. We cannot prevent being called
1121 * twice since cio may trigger a shutdown asynchronously.
1122 */
1123 if (irq_ptr->state == QDIO_IRQ_STATE_INACTIVE) {
1124 mutex_unlock(&irq_ptr->setup_mutex);
1125 return 0;
1126 }
1127
Jan Glauberc38f9602009-03-26 15:24:26 +01001128 /*
1129 * Indicate that the device is going down. Scheduling the queue
1130 * tasklets is forbidden from here on.
1131 */
1132 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_STOPPED);
1133
Jan Glauber779e6e12008-07-17 17:16:48 +02001134 tiqdio_remove_input_queues(irq_ptr);
1135 qdio_shutdown_queues(cdev);
1136 qdio_shutdown_debug_entries(irq_ptr, cdev);
1137
1138 /* cleanup subchannel */
1139 spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
1140
1141 if (how & QDIO_FLAG_CLEANUP_USING_CLEAR)
1142 rc = ccw_device_clear(cdev, QDIO_DOING_CLEANUP);
1143 else
1144 /* default behaviour is halt */
1145 rc = ccw_device_halt(cdev, QDIO_DOING_CLEANUP);
1146 if (rc) {
Jan Glauber22f99342008-12-25 13:38:46 +01001147 DBF_ERROR("%4x SHUTD ERR", irq_ptr->schid.sch_no);
1148 DBF_ERROR("rc:%4d", rc);
Jan Glauber779e6e12008-07-17 17:16:48 +02001149 goto no_cleanup;
1150 }
1151
1152 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_CLEANUP);
1153 spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
1154 wait_event_interruptible_timeout(cdev->private->wait_q,
1155 irq_ptr->state == QDIO_IRQ_STATE_INACTIVE ||
1156 irq_ptr->state == QDIO_IRQ_STATE_ERR,
1157 10 * HZ);
1158 spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
1159
1160no_cleanup:
1161 qdio_shutdown_thinint(irq_ptr);
1162
1163 /* restore interrupt handler */
1164 if ((void *)cdev->handler == (void *)qdio_int_handler)
1165 cdev->handler = irq_ptr->orig_handler;
1166 spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
1167
1168 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_INACTIVE);
1169 mutex_unlock(&irq_ptr->setup_mutex);
Jan Glauber779e6e12008-07-17 17:16:48 +02001170 if (rc)
1171 return rc;
1172 return 0;
1173}
1174EXPORT_SYMBOL_GPL(qdio_shutdown);
1175
1176/**
1177 * qdio_free - free data structures for a qdio subchannel
1178 * @cdev: associated ccw device
1179 */
1180int qdio_free(struct ccw_device *cdev)
1181{
Jan Glauber22f99342008-12-25 13:38:46 +01001182 struct qdio_irq *irq_ptr = cdev->private->qdio_data;
Jan Glauber779e6e12008-07-17 17:16:48 +02001183
Jan Glauber779e6e12008-07-17 17:16:48 +02001184 if (!irq_ptr)
1185 return -ENODEV;
1186
Jan Glauber22f99342008-12-25 13:38:46 +01001187 DBF_EVENT("qfree:%4x", cdev->private->schid.sch_no);
Jan Glauber779e6e12008-07-17 17:16:48 +02001188 mutex_lock(&irq_ptr->setup_mutex);
Jan Glauber22f99342008-12-25 13:38:46 +01001189
1190 if (irq_ptr->debug_area != NULL) {
1191 debug_unregister(irq_ptr->debug_area);
1192 irq_ptr->debug_area = NULL;
1193 }
Jan Glauber779e6e12008-07-17 17:16:48 +02001194 cdev->private->qdio_data = NULL;
1195 mutex_unlock(&irq_ptr->setup_mutex);
1196
1197 qdio_release_memory(irq_ptr);
1198 return 0;
1199}
1200EXPORT_SYMBOL_GPL(qdio_free);
1201
1202/**
1203 * qdio_initialize - allocate and establish queues for a qdio subchannel
1204 * @init_data: initialization data
1205 *
1206 * This function first allocates queues via qdio_allocate() and on success
1207 * establishes them via qdio_establish().
1208 */
1209int qdio_initialize(struct qdio_initialize *init_data)
1210{
1211 int rc;
Jan Glauber779e6e12008-07-17 17:16:48 +02001212
1213 rc = qdio_allocate(init_data);
1214 if (rc)
1215 return rc;
1216
1217 rc = qdio_establish(init_data);
1218 if (rc)
1219 qdio_free(init_data->cdev);
1220 return rc;
1221}
1222EXPORT_SYMBOL_GPL(qdio_initialize);
1223
1224/**
1225 * qdio_allocate - allocate qdio queues and associated data
1226 * @init_data: initialization data
1227 */
1228int qdio_allocate(struct qdio_initialize *init_data)
1229{
1230 struct qdio_irq *irq_ptr;
Jan Glauber779e6e12008-07-17 17:16:48 +02001231
Jan Glauber22f99342008-12-25 13:38:46 +01001232 DBF_EVENT("qallocate:%4x", init_data->cdev->private->schid.sch_no);
Jan Glauber779e6e12008-07-17 17:16:48 +02001233
1234 if ((init_data->no_input_qs && !init_data->input_handler) ||
1235 (init_data->no_output_qs && !init_data->output_handler))
1236 return -EINVAL;
1237
1238 if ((init_data->no_input_qs > QDIO_MAX_QUEUES_PER_IRQ) ||
1239 (init_data->no_output_qs > QDIO_MAX_QUEUES_PER_IRQ))
1240 return -EINVAL;
1241
1242 if ((!init_data->input_sbal_addr_array) ||
1243 (!init_data->output_sbal_addr_array))
1244 return -EINVAL;
1245
Jan Glauber779e6e12008-07-17 17:16:48 +02001246 /* irq_ptr must be in GFP_DMA since it contains ccw1.cda */
1247 irq_ptr = (void *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
1248 if (!irq_ptr)
1249 goto out_err;
Jan Glauber779e6e12008-07-17 17:16:48 +02001250
1251 mutex_init(&irq_ptr->setup_mutex);
Jan Glauber22f99342008-12-25 13:38:46 +01001252 qdio_allocate_dbf(init_data, irq_ptr);
Jan Glauber779e6e12008-07-17 17:16:48 +02001253
1254 /*
1255 * Allocate a page for the chsc calls in qdio_establish.
1256 * Must be pre-allocated since a zfcp recovery will call
1257 * qdio_establish. In case of low memory and swap on a zfcp disk
1258 * we may not be able to allocate memory otherwise.
1259 */
1260 irq_ptr->chsc_page = get_zeroed_page(GFP_KERNEL);
1261 if (!irq_ptr->chsc_page)
1262 goto out_rel;
1263
1264 /* qdr is used in ccw1.cda which is u32 */
Jan Glauber3b8e3002008-08-01 16:39:17 +02001265 irq_ptr->qdr = (struct qdr *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
Jan Glauber779e6e12008-07-17 17:16:48 +02001266 if (!irq_ptr->qdr)
1267 goto out_rel;
1268 WARN_ON((unsigned long)irq_ptr->qdr & 0xfff);
1269
Jan Glauber779e6e12008-07-17 17:16:48 +02001270 if (qdio_allocate_qs(irq_ptr, init_data->no_input_qs,
1271 init_data->no_output_qs))
1272 goto out_rel;
1273
1274 init_data->cdev->private->qdio_data = irq_ptr;
1275 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_INACTIVE);
1276 return 0;
1277out_rel:
1278 qdio_release_memory(irq_ptr);
1279out_err:
1280 return -ENOMEM;
1281}
1282EXPORT_SYMBOL_GPL(qdio_allocate);
1283
1284/**
1285 * qdio_establish - establish queues on a qdio subchannel
1286 * @init_data: initialization data
1287 */
1288int qdio_establish(struct qdio_initialize *init_data)
1289{
Jan Glauber779e6e12008-07-17 17:16:48 +02001290 struct qdio_irq *irq_ptr;
1291 struct ccw_device *cdev = init_data->cdev;
1292 unsigned long saveflags;
1293 int rc;
1294
Jan Glauber22f99342008-12-25 13:38:46 +01001295 DBF_EVENT("qestablish:%4x", cdev->private->schid.sch_no);
Jan Glauber58eb27c2008-08-21 19:46:34 +02001296
Jan Glauber779e6e12008-07-17 17:16:48 +02001297 irq_ptr = cdev->private->qdio_data;
1298 if (!irq_ptr)
1299 return -ENODEV;
1300
1301 if (cdev->private->state != DEV_STATE_ONLINE)
1302 return -EINVAL;
1303
Jan Glauber779e6e12008-07-17 17:16:48 +02001304 mutex_lock(&irq_ptr->setup_mutex);
1305 qdio_setup_irq(init_data);
1306
1307 rc = qdio_establish_thinint(irq_ptr);
1308 if (rc) {
1309 mutex_unlock(&irq_ptr->setup_mutex);
1310 qdio_shutdown(cdev, QDIO_FLAG_CLEANUP_USING_CLEAR);
1311 return rc;
1312 }
1313
1314 /* establish q */
1315 irq_ptr->ccw.cmd_code = irq_ptr->equeue.cmd;
1316 irq_ptr->ccw.flags = CCW_FLAG_SLI;
1317 irq_ptr->ccw.count = irq_ptr->equeue.count;
1318 irq_ptr->ccw.cda = (u32)((addr_t)irq_ptr->qdr);
1319
1320 spin_lock_irqsave(get_ccwdev_lock(cdev), saveflags);
1321 ccw_device_set_options_mask(cdev, 0);
1322
1323 rc = ccw_device_start(cdev, &irq_ptr->ccw, QDIO_DOING_ESTABLISH, 0, 0);
1324 if (rc) {
Jan Glauber22f99342008-12-25 13:38:46 +01001325 DBF_ERROR("%4x est IO ERR", irq_ptr->schid.sch_no);
1326 DBF_ERROR("rc:%4x", rc);
Jan Glauber779e6e12008-07-17 17:16:48 +02001327 }
1328 spin_unlock_irqrestore(get_ccwdev_lock(cdev), saveflags);
1329
1330 if (rc) {
1331 mutex_unlock(&irq_ptr->setup_mutex);
1332 qdio_shutdown(cdev, QDIO_FLAG_CLEANUP_USING_CLEAR);
1333 return rc;
1334 }
1335
1336 wait_event_interruptible_timeout(cdev->private->wait_q,
1337 irq_ptr->state == QDIO_IRQ_STATE_ESTABLISHED ||
1338 irq_ptr->state == QDIO_IRQ_STATE_ERR, HZ);
1339
1340 if (irq_ptr->state != QDIO_IRQ_STATE_ESTABLISHED) {
1341 mutex_unlock(&irq_ptr->setup_mutex);
1342 qdio_shutdown(cdev, QDIO_FLAG_CLEANUP_USING_CLEAR);
1343 return -EIO;
1344 }
1345
1346 qdio_setup_ssqd_info(irq_ptr);
Jan Glauber22f99342008-12-25 13:38:46 +01001347 DBF_EVENT("qDmmwc:%2x", irq_ptr->ssqd_desc.mmwc);
1348 DBF_EVENT("qib ac:%4x", irq_ptr->qib.ac);
Jan Glauber779e6e12008-07-17 17:16:48 +02001349
1350 /* qebsm is now setup if available, initialize buffer states */
1351 qdio_init_buf_states(irq_ptr);
1352
1353 mutex_unlock(&irq_ptr->setup_mutex);
1354 qdio_print_subchannel_info(irq_ptr, cdev);
1355 qdio_setup_debug_entries(irq_ptr, cdev);
1356 return 0;
1357}
1358EXPORT_SYMBOL_GPL(qdio_establish);
1359
1360/**
1361 * qdio_activate - activate queues on a qdio subchannel
1362 * @cdev: associated cdev
1363 */
1364int qdio_activate(struct ccw_device *cdev)
1365{
1366 struct qdio_irq *irq_ptr;
1367 int rc;
1368 unsigned long saveflags;
Jan Glauber779e6e12008-07-17 17:16:48 +02001369
Jan Glauber22f99342008-12-25 13:38:46 +01001370 DBF_EVENT("qactivate:%4x", cdev->private->schid.sch_no);
Jan Glauber58eb27c2008-08-21 19:46:34 +02001371
Jan Glauber779e6e12008-07-17 17:16:48 +02001372 irq_ptr = cdev->private->qdio_data;
1373 if (!irq_ptr)
1374 return -ENODEV;
1375
1376 if (cdev->private->state != DEV_STATE_ONLINE)
1377 return -EINVAL;
1378
1379 mutex_lock(&irq_ptr->setup_mutex);
1380 if (irq_ptr->state == QDIO_IRQ_STATE_INACTIVE) {
1381 rc = -EBUSY;
1382 goto out;
1383 }
1384
Jan Glauber779e6e12008-07-17 17:16:48 +02001385 irq_ptr->ccw.cmd_code = irq_ptr->aqueue.cmd;
1386 irq_ptr->ccw.flags = CCW_FLAG_SLI;
1387 irq_ptr->ccw.count = irq_ptr->aqueue.count;
1388 irq_ptr->ccw.cda = 0;
1389
1390 spin_lock_irqsave(get_ccwdev_lock(cdev), saveflags);
1391 ccw_device_set_options(cdev, CCWDEV_REPORT_ALL);
1392
1393 rc = ccw_device_start(cdev, &irq_ptr->ccw, QDIO_DOING_ACTIVATE,
1394 0, DOIO_DENY_PREFETCH);
1395 if (rc) {
Jan Glauber22f99342008-12-25 13:38:46 +01001396 DBF_ERROR("%4x act IO ERR", irq_ptr->schid.sch_no);
1397 DBF_ERROR("rc:%4x", rc);
Jan Glauber779e6e12008-07-17 17:16:48 +02001398 }
1399 spin_unlock_irqrestore(get_ccwdev_lock(cdev), saveflags);
1400
1401 if (rc)
1402 goto out;
1403
1404 if (is_thinint_irq(irq_ptr))
1405 tiqdio_add_input_queues(irq_ptr);
1406
1407 /* wait for subchannel to become active */
1408 msleep(5);
1409
1410 switch (irq_ptr->state) {
1411 case QDIO_IRQ_STATE_STOPPED:
1412 case QDIO_IRQ_STATE_ERR:
Jan Glaubere4c14e22009-03-26 15:24:25 +01001413 rc = -EIO;
1414 break;
Jan Glauber779e6e12008-07-17 17:16:48 +02001415 default:
1416 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_ACTIVE);
1417 rc = 0;
1418 }
1419out:
1420 mutex_unlock(&irq_ptr->setup_mutex);
1421 return rc;
1422}
1423EXPORT_SYMBOL_GPL(qdio_activate);
1424
1425static inline int buf_in_between(int bufnr, int start, int count)
1426{
1427 int end = add_buf(start, count);
1428
1429 if (end > start) {
1430 if (bufnr >= start && bufnr < end)
1431 return 1;
1432 else
1433 return 0;
1434 }
1435
1436 /* wrap-around case */
1437 if ((bufnr >= start && bufnr <= QDIO_MAX_BUFFERS_PER_Q) ||
1438 (bufnr < end))
1439 return 1;
1440 else
1441 return 0;
1442}
1443
1444/**
1445 * handle_inbound - reset processed input buffers
1446 * @q: queue containing the buffers
1447 * @callflags: flags
1448 * @bufnr: first buffer to process
1449 * @count: how many buffers are emptied
1450 */
Jan Glauberd303b6f2009-03-26 15:24:31 +01001451static int handle_inbound(struct qdio_q *q, unsigned int callflags,
1452 int bufnr, int count)
Jan Glauber779e6e12008-07-17 17:16:48 +02001453{
Jan Glauberd303b6f2009-03-26 15:24:31 +01001454 int used, diff;
Jan Glauber779e6e12008-07-17 17:16:48 +02001455
Jan Glauber50f769d2008-12-25 13:38:47 +01001456 if (!q->u.in.polling)
1457 goto set;
1458
1459 /* protect against stop polling setting an ACK for an emptied slsb */
1460 if (count == QDIO_MAX_BUFFERS_PER_Q) {
1461 /* overwriting everything, just delete polling status */
1462 q->u.in.polling = 0;
1463 q->u.in.ack_count = 0;
1464 goto set;
Jan Glaubere85dea02009-03-26 15:24:29 +01001465 } else if (buf_in_between(q->u.in.ack_start, bufnr, count)) {
Jan Glauber50f769d2008-12-25 13:38:47 +01001466 if (is_qebsm(q)) {
Jan Glaubere85dea02009-03-26 15:24:29 +01001467 /* partial overwrite, just update ack_start */
Jan Glauber50f769d2008-12-25 13:38:47 +01001468 diff = add_buf(bufnr, count);
Jan Glaubere85dea02009-03-26 15:24:29 +01001469 diff = sub_buf(diff, q->u.in.ack_start);
Jan Glauber50f769d2008-12-25 13:38:47 +01001470 q->u.in.ack_count -= diff;
1471 if (q->u.in.ack_count <= 0) {
1472 q->u.in.polling = 0;
1473 q->u.in.ack_count = 0;
Jan Glauber50f769d2008-12-25 13:38:47 +01001474 goto set;
1475 }
Jan Glaubere85dea02009-03-26 15:24:29 +01001476 q->u.in.ack_start = add_buf(q->u.in.ack_start, diff);
Jan Glauber50f769d2008-12-25 13:38:47 +01001477 }
1478 else
1479 /* the only ACK will be deleted, so stop polling */
Jan Glauber779e6e12008-07-17 17:16:48 +02001480 q->u.in.polling = 0;
Jan Glauber50f769d2008-12-25 13:38:47 +01001481 }
Jan Glauber779e6e12008-07-17 17:16:48 +02001482
Jan Glauber50f769d2008-12-25 13:38:47 +01001483set:
Jan Glauber779e6e12008-07-17 17:16:48 +02001484 count = set_buf_states(q, bufnr, SLSB_CU_INPUT_EMPTY, count);
Jan Glauber779e6e12008-07-17 17:16:48 +02001485
1486 used = atomic_add_return(count, &q->nr_buf_used) - count;
1487 BUG_ON(used + count > QDIO_MAX_BUFFERS_PER_Q);
1488
1489 /* no need to signal as long as the adapter had free buffers */
1490 if (used)
Jan Glauberd303b6f2009-03-26 15:24:31 +01001491 return 0;
Jan Glauber779e6e12008-07-17 17:16:48 +02001492
Jan Glauberd303b6f2009-03-26 15:24:31 +01001493 if (need_siga_in(q))
1494 return qdio_siga_input(q);
1495 return 0;
Jan Glauber779e6e12008-07-17 17:16:48 +02001496}
1497
1498/**
1499 * handle_outbound - process filled outbound buffers
1500 * @q: queue containing the buffers
1501 * @callflags: flags
1502 * @bufnr: first buffer to process
1503 * @count: how many buffers are filled
1504 */
Jan Glauberd303b6f2009-03-26 15:24:31 +01001505static int handle_outbound(struct qdio_q *q, unsigned int callflags,
1506 int bufnr, int count)
Jan Glauber779e6e12008-07-17 17:16:48 +02001507{
1508 unsigned char state;
Jan Glauberd303b6f2009-03-26 15:24:31 +01001509 int used, rc = 0;
Jan Glauber779e6e12008-07-17 17:16:48 +02001510
1511 qdio_perf_stat_inc(&perf_stats.outbound_handler);
1512
1513 count = set_buf_states(q, bufnr, SLSB_CU_OUTPUT_PRIMED, count);
1514 used = atomic_add_return(count, &q->nr_buf_used);
1515 BUG_ON(used > QDIO_MAX_BUFFERS_PER_Q);
1516
1517 if (callflags & QDIO_FLAG_PCI_OUT)
1518 q->u.out.pci_out_enabled = 1;
1519 else
1520 q->u.out.pci_out_enabled = 0;
1521
1522 if (queue_type(q) == QDIO_IQDIO_QFMT) {
1523 if (multicast_outbound(q))
Jan Glauberd303b6f2009-03-26 15:24:31 +01001524 rc = qdio_kick_outbound_q(q);
Jan Glauber779e6e12008-07-17 17:16:48 +02001525 else
Klaus-Dieter Wacker7a0f4752008-10-10 21:33:18 +02001526 if ((q->irq_ptr->ssqd_desc.mmwc > 1) &&
1527 (count > 1) &&
1528 (count <= q->irq_ptr->ssqd_desc.mmwc)) {
1529 /* exploit enhanced SIGA */
1530 q->u.out.use_enh_siga = 1;
Jan Glauberd303b6f2009-03-26 15:24:31 +01001531 rc = qdio_kick_outbound_q(q);
Klaus-Dieter Wacker7a0f4752008-10-10 21:33:18 +02001532 } else {
1533 /*
1534 * One siga-w per buffer required for unicast
1535 * HiperSockets.
1536 */
1537 q->u.out.use_enh_siga = 0;
Jan Glauberd303b6f2009-03-26 15:24:31 +01001538 while (count--) {
1539 rc = qdio_kick_outbound_q(q);
1540 if (rc)
1541 goto out;
1542 }
Klaus-Dieter Wacker7a0f4752008-10-10 21:33:18 +02001543 }
Jan Glauber779e6e12008-07-17 17:16:48 +02001544 goto out;
1545 }
1546
1547 if (need_siga_sync(q)) {
1548 qdio_siga_sync_q(q);
1549 goto out;
1550 }
1551
1552 /* try to fast requeue buffers */
Jan Glauber50f769d2008-12-25 13:38:47 +01001553 get_buf_state(q, prev_buf(bufnr), &state, 0);
Jan Glauber779e6e12008-07-17 17:16:48 +02001554 if (state != SLSB_CU_OUTPUT_PRIMED)
Jan Glauberd303b6f2009-03-26 15:24:31 +01001555 rc = qdio_kick_outbound_q(q);
Jan Glauber779e6e12008-07-17 17:16:48 +02001556 else {
Jan Glauber22f99342008-12-25 13:38:46 +01001557 DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "fast-req");
Jan Glauber779e6e12008-07-17 17:16:48 +02001558 qdio_perf_stat_inc(&perf_stats.fast_requeue);
1559 }
1560out:
Jan Glauber779e6e12008-07-17 17:16:48 +02001561 tasklet_schedule(&q->tasklet);
Jan Glauberd303b6f2009-03-26 15:24:31 +01001562 return rc;
Jan Glauber779e6e12008-07-17 17:16:48 +02001563}
1564
1565/**
1566 * do_QDIO - process input or output buffers
1567 * @cdev: associated ccw_device for the qdio subchannel
1568 * @callflags: input or output and special flags from the program
1569 * @q_nr: queue number
1570 * @bufnr: buffer number
1571 * @count: how many buffers to process
1572 */
1573int do_QDIO(struct ccw_device *cdev, unsigned int callflags,
1574 int q_nr, int bufnr, int count)
1575{
1576 struct qdio_irq *irq_ptr;
Jan Glauber779e6e12008-07-17 17:16:48 +02001577
1578 if ((bufnr > QDIO_MAX_BUFFERS_PER_Q) ||
1579 (count > QDIO_MAX_BUFFERS_PER_Q) ||
1580 (q_nr > QDIO_MAX_QUEUES_PER_IRQ))
1581 return -EINVAL;
1582
1583 if (!count)
1584 return 0;
1585
1586 irq_ptr = cdev->private->qdio_data;
1587 if (!irq_ptr)
1588 return -ENODEV;
1589
Jan Glauber779e6e12008-07-17 17:16:48 +02001590 if (callflags & QDIO_FLAG_SYNC_INPUT)
Jan Glauber22f99342008-12-25 13:38:46 +01001591 DBF_DEV_EVENT(DBF_INFO, irq_ptr, "doQDIO input");
Jan Glauber779e6e12008-07-17 17:16:48 +02001592 else
Jan Glauber22f99342008-12-25 13:38:46 +01001593 DBF_DEV_EVENT(DBF_INFO, irq_ptr, "doQDIO output");
1594 DBF_DEV_EVENT(DBF_INFO, irq_ptr, "q:%1d flag:%4x", q_nr, callflags);
1595 DBF_DEV_EVENT(DBF_INFO, irq_ptr, "buf:%2d cnt:%3d", bufnr, count);
Jan Glauber779e6e12008-07-17 17:16:48 +02001596
1597 if (irq_ptr->state != QDIO_IRQ_STATE_ACTIVE)
1598 return -EBUSY;
1599
1600 if (callflags & QDIO_FLAG_SYNC_INPUT)
Jan Glauberd303b6f2009-03-26 15:24:31 +01001601 return handle_inbound(irq_ptr->input_qs[q_nr],
1602 callflags, bufnr, count);
Jan Glauber779e6e12008-07-17 17:16:48 +02001603 else if (callflags & QDIO_FLAG_SYNC_OUTPUT)
Jan Glauberd303b6f2009-03-26 15:24:31 +01001604 return handle_outbound(irq_ptr->output_qs[q_nr],
1605 callflags, bufnr, count);
1606 return -EINVAL;
Jan Glauber779e6e12008-07-17 17:16:48 +02001607}
1608EXPORT_SYMBOL_GPL(do_QDIO);
1609
1610static int __init init_QDIO(void)
1611{
1612 int rc;
1613
1614 rc = qdio_setup_init();
1615 if (rc)
1616 return rc;
1617 rc = tiqdio_allocate_memory();
1618 if (rc)
1619 goto out_cache;
1620 rc = qdio_debug_init();
1621 if (rc)
1622 goto out_ti;
1623 rc = qdio_setup_perf_stats();
1624 if (rc)
1625 goto out_debug;
1626 rc = tiqdio_register_thinints();
1627 if (rc)
1628 goto out_perf;
1629 return 0;
1630
1631out_perf:
1632 qdio_remove_perf_stats();
1633out_debug:
1634 qdio_debug_exit();
1635out_ti:
1636 tiqdio_free_memory();
1637out_cache:
1638 qdio_setup_exit();
1639 return rc;
1640}
1641
1642static void __exit exit_QDIO(void)
1643{
1644 tiqdio_unregister_thinints();
1645 tiqdio_free_memory();
1646 qdio_remove_perf_stats();
1647 qdio_debug_exit();
1648 qdio_setup_exit();
1649}
1650
1651module_init(init_QDIO);
1652module_exit(exit_QDIO);