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) 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 default: 964 WARN_ON(1); 965 } 966 wake_up(&cdev->private->wait_q); 967 } 968 969 /** 970 * qdio_get_ssqd_desc - get qdio subchannel description 971 * @cdev: ccw device to get description for 972 * @data: where to store the ssqd 973 * 974 * Returns 0 or an error code. The results of the chsc are stored in the 975 * specified structure. 976 */ 977 int qdio_get_ssqd_desc(struct ccw_device *cdev, 978 struct qdio_ssqd_desc *data) 979 { 980 981 if (!cdev || !cdev->private) 982 return -EINVAL; 983 984 DBF_EVENT("get ssqd:%4x", cdev->private->schid.sch_no); 985 return qdio_setup_get_ssqd(NULL, &cdev->private->schid, data); 986 } 987 EXPORT_SYMBOL_GPL(qdio_get_ssqd_desc); 988 989 /** 990 * qdio_cleanup - shutdown queues and free data structures 991 * @cdev: associated ccw device 992 * @how: use halt or clear to shutdown 993 * 994 * This function calls qdio_shutdown() for @cdev with method @how. 995 * and qdio_free(). The qdio_free() return value is ignored since 996 * !irq_ptr is already checked. 997 */ 998 int qdio_cleanup(struct ccw_device *cdev, int how) 999 { 1000 struct qdio_irq *irq_ptr = cdev->private->qdio_data; 1001 int rc; 1002 1003 if (!irq_ptr) 1004 return -ENODEV; 1005 1006 rc = qdio_shutdown(cdev, how); 1007 1008 qdio_free(cdev); 1009 return rc; 1010 } 1011 EXPORT_SYMBOL_GPL(qdio_cleanup); 1012 1013 static void qdio_shutdown_queues(struct ccw_device *cdev) 1014 { 1015 struct qdio_irq *irq_ptr = cdev->private->qdio_data; 1016 struct qdio_q *q; 1017 int i; 1018 1019 for_each_input_queue(irq_ptr, q, i) 1020 tasklet_kill(&q->tasklet); 1021 1022 for_each_output_queue(irq_ptr, q, i) { 1023 del_timer(&q->u.out.timer); 1024 tasklet_kill(&q->tasklet); 1025 } 1026 } 1027 1028 /** 1029 * qdio_shutdown - shut down a qdio subchannel 1030 * @cdev: associated ccw device 1031 * @how: use halt or clear to shutdown 1032 */ 1033 int qdio_shutdown(struct ccw_device *cdev, int how) 1034 { 1035 struct qdio_irq *irq_ptr = cdev->private->qdio_data; 1036 int rc; 1037 unsigned long flags; 1038 1039 if (!irq_ptr) 1040 return -ENODEV; 1041 1042 BUG_ON(irqs_disabled()); 1043 DBF_EVENT("qshutdown:%4x", cdev->private->schid.sch_no); 1044 1045 mutex_lock(&irq_ptr->setup_mutex); 1046 /* 1047 * Subchannel was already shot down. We cannot prevent being called 1048 * twice since cio may trigger a shutdown asynchronously. 1049 */ 1050 if (irq_ptr->state == QDIO_IRQ_STATE_INACTIVE) { 1051 mutex_unlock(&irq_ptr->setup_mutex); 1052 return 0; 1053 } 1054 1055 /* 1056 * Indicate that the device is going down. Scheduling the queue 1057 * tasklets is forbidden from here on. 1058 */ 1059 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_STOPPED); 1060 1061 tiqdio_remove_input_queues(irq_ptr); 1062 qdio_shutdown_queues(cdev); 1063 qdio_shutdown_debug_entries(irq_ptr, cdev); 1064 1065 /* cleanup subchannel */ 1066 spin_lock_irqsave(get_ccwdev_lock(cdev), flags); 1067 1068 if (how & QDIO_FLAG_CLEANUP_USING_CLEAR) 1069 rc = ccw_device_clear(cdev, QDIO_DOING_CLEANUP); 1070 else 1071 /* default behaviour is halt */ 1072 rc = ccw_device_halt(cdev, QDIO_DOING_CLEANUP); 1073 if (rc) { 1074 DBF_ERROR("%4x SHUTD ERR", irq_ptr->schid.sch_no); 1075 DBF_ERROR("rc:%4d", rc); 1076 goto no_cleanup; 1077 } 1078 1079 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_CLEANUP); 1080 spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags); 1081 wait_event_interruptible_timeout(cdev->private->wait_q, 1082 irq_ptr->state == QDIO_IRQ_STATE_INACTIVE || 1083 irq_ptr->state == QDIO_IRQ_STATE_ERR, 1084 10 * HZ); 1085 spin_lock_irqsave(get_ccwdev_lock(cdev), flags); 1086 1087 no_cleanup: 1088 qdio_shutdown_thinint(irq_ptr); 1089 1090 /* restore interrupt handler */ 1091 if ((void *)cdev->handler == (void *)qdio_int_handler) 1092 cdev->handler = irq_ptr->orig_handler; 1093 spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags); 1094 1095 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_INACTIVE); 1096 mutex_unlock(&irq_ptr->setup_mutex); 1097 if (rc) 1098 return rc; 1099 return 0; 1100 } 1101 EXPORT_SYMBOL_GPL(qdio_shutdown); 1102 1103 /** 1104 * qdio_free - free data structures for a qdio subchannel 1105 * @cdev: associated ccw device 1106 */ 1107 int qdio_free(struct ccw_device *cdev) 1108 { 1109 struct qdio_irq *irq_ptr = cdev->private->qdio_data; 1110 1111 if (!irq_ptr) 1112 return -ENODEV; 1113 1114 DBF_EVENT("qfree:%4x", cdev->private->schid.sch_no); 1115 mutex_lock(&irq_ptr->setup_mutex); 1116 1117 if (irq_ptr->debug_area != NULL) { 1118 debug_unregister(irq_ptr->debug_area); 1119 irq_ptr->debug_area = NULL; 1120 } 1121 cdev->private->qdio_data = NULL; 1122 mutex_unlock(&irq_ptr->setup_mutex); 1123 1124 qdio_release_memory(irq_ptr); 1125 return 0; 1126 } 1127 EXPORT_SYMBOL_GPL(qdio_free); 1128 1129 /** 1130 * qdio_initialize - allocate and establish queues for a qdio subchannel 1131 * @init_data: initialization data 1132 * 1133 * This function first allocates queues via qdio_allocate() and on success 1134 * establishes them via qdio_establish(). 1135 */ 1136 int qdio_initialize(struct qdio_initialize *init_data) 1137 { 1138 int rc; 1139 1140 rc = qdio_allocate(init_data); 1141 if (rc) 1142 return rc; 1143 1144 rc = qdio_establish(init_data); 1145 if (rc) 1146 qdio_free(init_data->cdev); 1147 return rc; 1148 } 1149 EXPORT_SYMBOL_GPL(qdio_initialize); 1150 1151 /** 1152 * qdio_allocate - allocate qdio queues and associated data 1153 * @init_data: initialization data 1154 */ 1155 int qdio_allocate(struct qdio_initialize *init_data) 1156 { 1157 struct qdio_irq *irq_ptr; 1158 1159 DBF_EVENT("qallocate:%4x", init_data->cdev->private->schid.sch_no); 1160 1161 if ((init_data->no_input_qs && !init_data->input_handler) || 1162 (init_data->no_output_qs && !init_data->output_handler)) 1163 return -EINVAL; 1164 1165 if ((init_data->no_input_qs > QDIO_MAX_QUEUES_PER_IRQ) || 1166 (init_data->no_output_qs > QDIO_MAX_QUEUES_PER_IRQ)) 1167 return -EINVAL; 1168 1169 if ((!init_data->input_sbal_addr_array) || 1170 (!init_data->output_sbal_addr_array)) 1171 return -EINVAL; 1172 1173 /* irq_ptr must be in GFP_DMA since it contains ccw1.cda */ 1174 irq_ptr = (void *) get_zeroed_page(GFP_KERNEL | GFP_DMA); 1175 if (!irq_ptr) 1176 goto out_err; 1177 1178 mutex_init(&irq_ptr->setup_mutex); 1179 qdio_allocate_dbf(init_data, irq_ptr); 1180 1181 /* 1182 * Allocate a page for the chsc calls in qdio_establish. 1183 * Must be pre-allocated since a zfcp recovery will call 1184 * qdio_establish. In case of low memory and swap on a zfcp disk 1185 * we may not be able to allocate memory otherwise. 1186 */ 1187 irq_ptr->chsc_page = get_zeroed_page(GFP_KERNEL); 1188 if (!irq_ptr->chsc_page) 1189 goto out_rel; 1190 1191 /* qdr is used in ccw1.cda which is u32 */ 1192 irq_ptr->qdr = (struct qdr *) get_zeroed_page(GFP_KERNEL | GFP_DMA); 1193 if (!irq_ptr->qdr) 1194 goto out_rel; 1195 WARN_ON((unsigned long)irq_ptr->qdr & 0xfff); 1196 1197 if (qdio_allocate_qs(irq_ptr, init_data->no_input_qs, 1198 init_data->no_output_qs)) 1199 goto out_rel; 1200 1201 init_data->cdev->private->qdio_data = irq_ptr; 1202 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_INACTIVE); 1203 return 0; 1204 out_rel: 1205 qdio_release_memory(irq_ptr); 1206 out_err: 1207 return -ENOMEM; 1208 } 1209 EXPORT_SYMBOL_GPL(qdio_allocate); 1210 1211 /** 1212 * qdio_establish - establish queues on a qdio subchannel 1213 * @init_data: initialization data 1214 */ 1215 int qdio_establish(struct qdio_initialize *init_data) 1216 { 1217 struct qdio_irq *irq_ptr; 1218 struct ccw_device *cdev = init_data->cdev; 1219 unsigned long saveflags; 1220 int rc; 1221 1222 DBF_EVENT("qestablish:%4x", cdev->private->schid.sch_no); 1223 1224 irq_ptr = cdev->private->qdio_data; 1225 if (!irq_ptr) 1226 return -ENODEV; 1227 1228 if (cdev->private->state != DEV_STATE_ONLINE) 1229 return -EINVAL; 1230 1231 mutex_lock(&irq_ptr->setup_mutex); 1232 qdio_setup_irq(init_data); 1233 1234 rc = qdio_establish_thinint(irq_ptr); 1235 if (rc) { 1236 mutex_unlock(&irq_ptr->setup_mutex); 1237 qdio_shutdown(cdev, QDIO_FLAG_CLEANUP_USING_CLEAR); 1238 return rc; 1239 } 1240 1241 /* establish q */ 1242 irq_ptr->ccw.cmd_code = irq_ptr->equeue.cmd; 1243 irq_ptr->ccw.flags = CCW_FLAG_SLI; 1244 irq_ptr->ccw.count = irq_ptr->equeue.count; 1245 irq_ptr->ccw.cda = (u32)((addr_t)irq_ptr->qdr); 1246 1247 spin_lock_irqsave(get_ccwdev_lock(cdev), saveflags); 1248 ccw_device_set_options_mask(cdev, 0); 1249 1250 rc = ccw_device_start(cdev, &irq_ptr->ccw, QDIO_DOING_ESTABLISH, 0, 0); 1251 if (rc) { 1252 DBF_ERROR("%4x est IO ERR", irq_ptr->schid.sch_no); 1253 DBF_ERROR("rc:%4x", rc); 1254 } 1255 spin_unlock_irqrestore(get_ccwdev_lock(cdev), saveflags); 1256 1257 if (rc) { 1258 mutex_unlock(&irq_ptr->setup_mutex); 1259 qdio_shutdown(cdev, QDIO_FLAG_CLEANUP_USING_CLEAR); 1260 return rc; 1261 } 1262 1263 wait_event_interruptible_timeout(cdev->private->wait_q, 1264 irq_ptr->state == QDIO_IRQ_STATE_ESTABLISHED || 1265 irq_ptr->state == QDIO_IRQ_STATE_ERR, HZ); 1266 1267 if (irq_ptr->state != QDIO_IRQ_STATE_ESTABLISHED) { 1268 mutex_unlock(&irq_ptr->setup_mutex); 1269 qdio_shutdown(cdev, QDIO_FLAG_CLEANUP_USING_CLEAR); 1270 return -EIO; 1271 } 1272 1273 qdio_setup_ssqd_info(irq_ptr); 1274 DBF_EVENT("qDmmwc:%2x", irq_ptr->ssqd_desc.mmwc); 1275 DBF_EVENT("qib ac:%4x", irq_ptr->qib.ac); 1276 1277 /* qebsm is now setup if available, initialize buffer states */ 1278 qdio_init_buf_states(irq_ptr); 1279 1280 mutex_unlock(&irq_ptr->setup_mutex); 1281 qdio_print_subchannel_info(irq_ptr, cdev); 1282 qdio_setup_debug_entries(irq_ptr, cdev); 1283 return 0; 1284 } 1285 EXPORT_SYMBOL_GPL(qdio_establish); 1286 1287 /** 1288 * qdio_activate - activate queues on a qdio subchannel 1289 * @cdev: associated cdev 1290 */ 1291 int qdio_activate(struct ccw_device *cdev) 1292 { 1293 struct qdio_irq *irq_ptr; 1294 int rc; 1295 unsigned long saveflags; 1296 1297 DBF_EVENT("qactivate:%4x", cdev->private->schid.sch_no); 1298 1299 irq_ptr = cdev->private->qdio_data; 1300 if (!irq_ptr) 1301 return -ENODEV; 1302 1303 if (cdev->private->state != DEV_STATE_ONLINE) 1304 return -EINVAL; 1305 1306 mutex_lock(&irq_ptr->setup_mutex); 1307 if (irq_ptr->state == QDIO_IRQ_STATE_INACTIVE) { 1308 rc = -EBUSY; 1309 goto out; 1310 } 1311 1312 irq_ptr->ccw.cmd_code = irq_ptr->aqueue.cmd; 1313 irq_ptr->ccw.flags = CCW_FLAG_SLI; 1314 irq_ptr->ccw.count = irq_ptr->aqueue.count; 1315 irq_ptr->ccw.cda = 0; 1316 1317 spin_lock_irqsave(get_ccwdev_lock(cdev), saveflags); 1318 ccw_device_set_options(cdev, CCWDEV_REPORT_ALL); 1319 1320 rc = ccw_device_start(cdev, &irq_ptr->ccw, QDIO_DOING_ACTIVATE, 1321 0, DOIO_DENY_PREFETCH); 1322 if (rc) { 1323 DBF_ERROR("%4x act IO ERR", irq_ptr->schid.sch_no); 1324 DBF_ERROR("rc:%4x", rc); 1325 } 1326 spin_unlock_irqrestore(get_ccwdev_lock(cdev), saveflags); 1327 1328 if (rc) 1329 goto out; 1330 1331 if (is_thinint_irq(irq_ptr)) 1332 tiqdio_add_input_queues(irq_ptr); 1333 1334 /* wait for subchannel to become active */ 1335 msleep(5); 1336 1337 switch (irq_ptr->state) { 1338 case QDIO_IRQ_STATE_STOPPED: 1339 case QDIO_IRQ_STATE_ERR: 1340 rc = -EIO; 1341 break; 1342 default: 1343 qdio_set_state(irq_ptr, QDIO_IRQ_STATE_ACTIVE); 1344 rc = 0; 1345 } 1346 out: 1347 mutex_unlock(&irq_ptr->setup_mutex); 1348 return rc; 1349 } 1350 EXPORT_SYMBOL_GPL(qdio_activate); 1351 1352 static inline int buf_in_between(int bufnr, int start, int count) 1353 { 1354 int end = add_buf(start, count); 1355 1356 if (end > start) { 1357 if (bufnr >= start && bufnr < end) 1358 return 1; 1359 else 1360 return 0; 1361 } 1362 1363 /* wrap-around case */ 1364 if ((bufnr >= start && bufnr <= QDIO_MAX_BUFFERS_PER_Q) || 1365 (bufnr < end)) 1366 return 1; 1367 else 1368 return 0; 1369 } 1370 1371 /** 1372 * handle_inbound - reset processed input buffers 1373 * @q: queue containing the buffers 1374 * @callflags: flags 1375 * @bufnr: first buffer to process 1376 * @count: how many buffers are emptied 1377 */ 1378 static int handle_inbound(struct qdio_q *q, unsigned int callflags, 1379 int bufnr, int count) 1380 { 1381 int used, diff; 1382 1383 qperf_inc(q, inbound_call); 1384 1385 if (!q->u.in.polling) 1386 goto set; 1387 1388 /* protect against stop polling setting an ACK for an emptied slsb */ 1389 if (count == QDIO_MAX_BUFFERS_PER_Q) { 1390 /* overwriting everything, just delete polling status */ 1391 q->u.in.polling = 0; 1392 q->u.in.ack_count = 0; 1393 goto set; 1394 } else if (buf_in_between(q->u.in.ack_start, bufnr, count)) { 1395 if (is_qebsm(q)) { 1396 /* partial overwrite, just update ack_start */ 1397 diff = add_buf(bufnr, count); 1398 diff = sub_buf(diff, q->u.in.ack_start); 1399 q->u.in.ack_count -= diff; 1400 if (q->u.in.ack_count <= 0) { 1401 q->u.in.polling = 0; 1402 q->u.in.ack_count = 0; 1403 goto set; 1404 } 1405 q->u.in.ack_start = add_buf(q->u.in.ack_start, diff); 1406 } 1407 else 1408 /* the only ACK will be deleted, so stop polling */ 1409 q->u.in.polling = 0; 1410 } 1411 1412 set: 1413 count = set_buf_states(q, bufnr, SLSB_CU_INPUT_EMPTY, count); 1414 1415 used = atomic_add_return(count, &q->nr_buf_used) - count; 1416 BUG_ON(used + count > QDIO_MAX_BUFFERS_PER_Q); 1417 1418 /* no need to signal as long as the adapter had free buffers */ 1419 if (used) 1420 return 0; 1421 1422 if (need_siga_in(q)) 1423 return qdio_siga_input(q); 1424 return 0; 1425 } 1426 1427 /** 1428 * handle_outbound - process filled outbound buffers 1429 * @q: queue containing the buffers 1430 * @callflags: flags 1431 * @bufnr: first buffer to process 1432 * @count: how many buffers are filled 1433 */ 1434 static int handle_outbound(struct qdio_q *q, unsigned int callflags, 1435 int bufnr, int count) 1436 { 1437 unsigned char state; 1438 int used, rc = 0; 1439 1440 qperf_inc(q, outbound_call); 1441 1442 count = set_buf_states(q, bufnr, SLSB_CU_OUTPUT_PRIMED, count); 1443 used = atomic_add_return(count, &q->nr_buf_used); 1444 BUG_ON(used > QDIO_MAX_BUFFERS_PER_Q); 1445 1446 if (callflags & QDIO_FLAG_PCI_OUT) { 1447 q->u.out.pci_out_enabled = 1; 1448 qperf_inc(q, pci_request_int); 1449 } 1450 else 1451 q->u.out.pci_out_enabled = 0; 1452 1453 if (queue_type(q) == QDIO_IQDIO_QFMT) { 1454 if (multicast_outbound(q)) 1455 rc = qdio_kick_outbound_q(q); 1456 else 1457 if ((q->irq_ptr->ssqd_desc.mmwc > 1) && 1458 (count > 1) && 1459 (count <= q->irq_ptr->ssqd_desc.mmwc)) { 1460 /* exploit enhanced SIGA */ 1461 q->u.out.use_enh_siga = 1; 1462 rc = qdio_kick_outbound_q(q); 1463 } else { 1464 /* 1465 * One siga-w per buffer required for unicast 1466 * HiperSockets. 1467 */ 1468 q->u.out.use_enh_siga = 0; 1469 while (count--) { 1470 rc = qdio_kick_outbound_q(q); 1471 if (rc) 1472 goto out; 1473 } 1474 } 1475 goto out; 1476 } 1477 1478 if (need_siga_sync(q)) { 1479 qdio_siga_sync_q(q); 1480 goto out; 1481 } 1482 1483 /* try to fast requeue buffers */ 1484 get_buf_state(q, prev_buf(bufnr), &state, 0); 1485 if (state != SLSB_CU_OUTPUT_PRIMED) 1486 rc = qdio_kick_outbound_q(q); 1487 else 1488 qperf_inc(q, fast_requeue); 1489 1490 out: 1491 tasklet_schedule(&q->tasklet); 1492 return rc; 1493 } 1494 1495 /** 1496 * do_QDIO - process input or output buffers 1497 * @cdev: associated ccw_device for the qdio subchannel 1498 * @callflags: input or output and special flags from the program 1499 * @q_nr: queue number 1500 * @bufnr: buffer number 1501 * @count: how many buffers to process 1502 */ 1503 int do_QDIO(struct ccw_device *cdev, unsigned int callflags, 1504 int q_nr, unsigned int bufnr, unsigned int count) 1505 { 1506 struct qdio_irq *irq_ptr; 1507 1508 if (bufnr >= QDIO_MAX_BUFFERS_PER_Q || count > QDIO_MAX_BUFFERS_PER_Q) 1509 return -EINVAL; 1510 1511 irq_ptr = cdev->private->qdio_data; 1512 if (!irq_ptr) 1513 return -ENODEV; 1514 1515 DBF_DEV_EVENT(DBF_INFO, irq_ptr, 1516 "do%02x b:%02x c:%02x", callflags, bufnr, count); 1517 1518 if (irq_ptr->state != QDIO_IRQ_STATE_ACTIVE) 1519 return -EBUSY; 1520 1521 if (callflags & QDIO_FLAG_SYNC_INPUT) 1522 return handle_inbound(irq_ptr->input_qs[q_nr], 1523 callflags, bufnr, count); 1524 else if (callflags & QDIO_FLAG_SYNC_OUTPUT) 1525 return handle_outbound(irq_ptr->output_qs[q_nr], 1526 callflags, bufnr, count); 1527 return -EINVAL; 1528 } 1529 EXPORT_SYMBOL_GPL(do_QDIO); 1530 1531 static int __init init_QDIO(void) 1532 { 1533 int rc; 1534 1535 rc = qdio_setup_init(); 1536 if (rc) 1537 return rc; 1538 rc = tiqdio_allocate_memory(); 1539 if (rc) 1540 goto out_cache; 1541 rc = qdio_debug_init(); 1542 if (rc) 1543 goto out_ti; 1544 rc = tiqdio_register_thinints(); 1545 if (rc) 1546 goto out_debug; 1547 return 0; 1548 1549 out_debug: 1550 qdio_debug_exit(); 1551 out_ti: 1552 tiqdio_free_memory(); 1553 out_cache: 1554 qdio_setup_exit(); 1555 return rc; 1556 } 1557 1558 static void __exit exit_QDIO(void) 1559 { 1560 tiqdio_unregister_thinints(); 1561 tiqdio_free_memory(); 1562 qdio_debug_exit(); 1563 qdio_setup_exit(); 1564 } 1565 1566 module_init(init_QDIO); 1567 module_exit(exit_QDIO); 1568