1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright IBM Corp. 2016 4 * Author(s): Martin Schwidefsky <schwidefsky@de.ibm.com> 5 * 6 * Adjunct processor bus, queue related code. 7 */ 8 9 #define KMSG_COMPONENT "ap" 10 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 11 12 #include <linux/init.h> 13 #include <linux/slab.h> 14 #include <asm/facility.h> 15 16 #include "ap_bus.h" 17 #include "ap_debug.h" 18 19 static void __ap_flush_queue(struct ap_queue *aq); 20 21 /** 22 * ap_queue_enable_interruption(): Enable interruption on an AP queue. 23 * @qid: The AP queue number 24 * @ind: the notification indicator byte 25 * 26 * Enables interruption on AP queue via ap_aqic(). Based on the return 27 * value it waits a while and tests the AP queue if interrupts 28 * have been switched on using ap_test_queue(). 29 */ 30 static int ap_queue_enable_interruption(struct ap_queue *aq, void *ind) 31 { 32 struct ap_queue_status status; 33 struct ap_qirq_ctrl qirqctrl = { 0 }; 34 35 qirqctrl.ir = 1; 36 qirqctrl.isc = AP_ISC; 37 status = ap_aqic(aq->qid, qirqctrl, ind); 38 switch (status.response_code) { 39 case AP_RESPONSE_NORMAL: 40 case AP_RESPONSE_OTHERWISE_CHANGED: 41 return 0; 42 case AP_RESPONSE_Q_NOT_AVAIL: 43 case AP_RESPONSE_DECONFIGURED: 44 case AP_RESPONSE_CHECKSTOPPED: 45 case AP_RESPONSE_INVALID_ADDRESS: 46 pr_err("Registering adapter interrupts for AP device %02x.%04x failed\n", 47 AP_QID_CARD(aq->qid), 48 AP_QID_QUEUE(aq->qid)); 49 return -EOPNOTSUPP; 50 case AP_RESPONSE_RESET_IN_PROGRESS: 51 case AP_RESPONSE_BUSY: 52 default: 53 return -EBUSY; 54 } 55 } 56 57 /** 58 * __ap_send(): Send message to adjunct processor queue. 59 * @qid: The AP queue number 60 * @psmid: The program supplied message identifier 61 * @msg: The message text 62 * @length: The message length 63 * @special: Special Bit 64 * 65 * Returns AP queue status structure. 66 * Condition code 1 on NQAP can't happen because the L bit is 1. 67 * Condition code 2 on NQAP also means the send is incomplete, 68 * because a segment boundary was reached. The NQAP is repeated. 69 */ 70 static inline struct ap_queue_status 71 __ap_send(ap_qid_t qid, unsigned long long psmid, void *msg, size_t length, 72 unsigned int special) 73 { 74 if (special == 1) 75 qid |= 0x400000UL; 76 return ap_nqap(qid, psmid, msg, length); 77 } 78 79 int ap_send(ap_qid_t qid, unsigned long long psmid, void *msg, size_t length) 80 { 81 struct ap_queue_status status; 82 83 status = __ap_send(qid, psmid, msg, length, 0); 84 switch (status.response_code) { 85 case AP_RESPONSE_NORMAL: 86 return 0; 87 case AP_RESPONSE_Q_FULL: 88 case AP_RESPONSE_RESET_IN_PROGRESS: 89 return -EBUSY; 90 case AP_RESPONSE_REQ_FAC_NOT_INST: 91 return -EINVAL; 92 default: /* Device is gone. */ 93 return -ENODEV; 94 } 95 } 96 EXPORT_SYMBOL(ap_send); 97 98 int ap_recv(ap_qid_t qid, unsigned long long *psmid, void *msg, size_t length) 99 { 100 struct ap_queue_status status; 101 102 if (msg == NULL) 103 return -EINVAL; 104 status = ap_dqap(qid, psmid, msg, length); 105 switch (status.response_code) { 106 case AP_RESPONSE_NORMAL: 107 return 0; 108 case AP_RESPONSE_NO_PENDING_REPLY: 109 if (status.queue_empty) 110 return -ENOENT; 111 return -EBUSY; 112 case AP_RESPONSE_RESET_IN_PROGRESS: 113 return -EBUSY; 114 default: 115 return -ENODEV; 116 } 117 } 118 EXPORT_SYMBOL(ap_recv); 119 120 /* State machine definitions and helpers */ 121 122 static enum ap_wait ap_sm_nop(struct ap_queue *aq) 123 { 124 return AP_WAIT_NONE; 125 } 126 127 /** 128 * ap_sm_recv(): Receive pending reply messages from an AP queue but do 129 * not change the state of the device. 130 * @aq: pointer to the AP queue 131 * 132 * Returns AP_WAIT_NONE, AP_WAIT_AGAIN, or AP_WAIT_INTERRUPT 133 */ 134 static struct ap_queue_status ap_sm_recv(struct ap_queue *aq) 135 { 136 struct ap_queue_status status; 137 struct ap_message *ap_msg; 138 139 status = ap_dqap(aq->qid, &aq->reply->psmid, 140 aq->reply->message, aq->reply->length); 141 switch (status.response_code) { 142 case AP_RESPONSE_NORMAL: 143 aq->queue_count--; 144 if (aq->queue_count > 0) 145 mod_timer(&aq->timeout, 146 jiffies + aq->request_timeout); 147 list_for_each_entry(ap_msg, &aq->pendingq, list) { 148 if (ap_msg->psmid != aq->reply->psmid) 149 continue; 150 list_del_init(&ap_msg->list); 151 aq->pendingq_count--; 152 ap_msg->receive(aq, ap_msg, aq->reply); 153 break; 154 } 155 case AP_RESPONSE_NO_PENDING_REPLY: 156 if (!status.queue_empty || aq->queue_count <= 0) 157 break; 158 /* The card shouldn't forget requests but who knows. */ 159 aq->queue_count = 0; 160 list_splice_init(&aq->pendingq, &aq->requestq); 161 aq->requestq_count += aq->pendingq_count; 162 aq->pendingq_count = 0; 163 break; 164 default: 165 break; 166 } 167 return status; 168 } 169 170 /** 171 * ap_sm_read(): Receive pending reply messages from an AP queue. 172 * @aq: pointer to the AP queue 173 * 174 * Returns AP_WAIT_NONE, AP_WAIT_AGAIN, or AP_WAIT_INTERRUPT 175 */ 176 static enum ap_wait ap_sm_read(struct ap_queue *aq) 177 { 178 struct ap_queue_status status; 179 180 if (!aq->reply) 181 return AP_WAIT_NONE; 182 status = ap_sm_recv(aq); 183 switch (status.response_code) { 184 case AP_RESPONSE_NORMAL: 185 if (aq->queue_count > 0) { 186 aq->state = AP_STATE_WORKING; 187 return AP_WAIT_AGAIN; 188 } 189 aq->state = AP_STATE_IDLE; 190 return AP_WAIT_NONE; 191 case AP_RESPONSE_NO_PENDING_REPLY: 192 if (aq->queue_count > 0) 193 return AP_WAIT_INTERRUPT; 194 aq->state = AP_STATE_IDLE; 195 return AP_WAIT_NONE; 196 default: 197 aq->state = AP_STATE_BORKED; 198 return AP_WAIT_NONE; 199 } 200 } 201 202 /** 203 * ap_sm_suspend_read(): Receive pending reply messages from an AP queue 204 * without changing the device state in between. In suspend mode we don't 205 * allow sending new requests, therefore just fetch pending replies. 206 * @aq: pointer to the AP queue 207 * 208 * Returns AP_WAIT_NONE or AP_WAIT_AGAIN 209 */ 210 static enum ap_wait ap_sm_suspend_read(struct ap_queue *aq) 211 { 212 struct ap_queue_status status; 213 214 if (!aq->reply) 215 return AP_WAIT_NONE; 216 status = ap_sm_recv(aq); 217 switch (status.response_code) { 218 case AP_RESPONSE_NORMAL: 219 if (aq->queue_count > 0) 220 return AP_WAIT_AGAIN; 221 /* fall through */ 222 default: 223 return AP_WAIT_NONE; 224 } 225 } 226 227 /** 228 * ap_sm_write(): Send messages from the request queue to an AP queue. 229 * @aq: pointer to the AP queue 230 * 231 * Returns AP_WAIT_NONE, AP_WAIT_AGAIN, or AP_WAIT_INTERRUPT 232 */ 233 static enum ap_wait ap_sm_write(struct ap_queue *aq) 234 { 235 struct ap_queue_status status; 236 struct ap_message *ap_msg; 237 238 if (aq->requestq_count <= 0) 239 return AP_WAIT_NONE; 240 /* Start the next request on the queue. */ 241 ap_msg = list_entry(aq->requestq.next, struct ap_message, list); 242 status = __ap_send(aq->qid, ap_msg->psmid, 243 ap_msg->message, ap_msg->length, ap_msg->special); 244 switch (status.response_code) { 245 case AP_RESPONSE_NORMAL: 246 aq->queue_count++; 247 if (aq->queue_count == 1) 248 mod_timer(&aq->timeout, jiffies + aq->request_timeout); 249 list_move_tail(&ap_msg->list, &aq->pendingq); 250 aq->requestq_count--; 251 aq->pendingq_count++; 252 if (aq->queue_count < aq->card->queue_depth) { 253 aq->state = AP_STATE_WORKING; 254 return AP_WAIT_AGAIN; 255 } 256 /* fall through */ 257 case AP_RESPONSE_Q_FULL: 258 aq->state = AP_STATE_QUEUE_FULL; 259 return AP_WAIT_INTERRUPT; 260 case AP_RESPONSE_RESET_IN_PROGRESS: 261 aq->state = AP_STATE_RESET_WAIT; 262 return AP_WAIT_TIMEOUT; 263 case AP_RESPONSE_MESSAGE_TOO_BIG: 264 case AP_RESPONSE_REQ_FAC_NOT_INST: 265 list_del_init(&ap_msg->list); 266 aq->requestq_count--; 267 ap_msg->rc = -EINVAL; 268 ap_msg->receive(aq, ap_msg, NULL); 269 return AP_WAIT_AGAIN; 270 default: 271 aq->state = AP_STATE_BORKED; 272 return AP_WAIT_NONE; 273 } 274 } 275 276 /** 277 * ap_sm_read_write(): Send and receive messages to/from an AP queue. 278 * @aq: pointer to the AP queue 279 * 280 * Returns AP_WAIT_NONE, AP_WAIT_AGAIN, or AP_WAIT_INTERRUPT 281 */ 282 static enum ap_wait ap_sm_read_write(struct ap_queue *aq) 283 { 284 return min(ap_sm_read(aq), ap_sm_write(aq)); 285 } 286 287 /** 288 * ap_sm_reset(): Reset an AP queue. 289 * @qid: The AP queue number 290 * 291 * Submit the Reset command to an AP queue. 292 */ 293 static enum ap_wait ap_sm_reset(struct ap_queue *aq) 294 { 295 struct ap_queue_status status; 296 297 status = ap_rapq(aq->qid); 298 switch (status.response_code) { 299 case AP_RESPONSE_NORMAL: 300 case AP_RESPONSE_RESET_IN_PROGRESS: 301 aq->state = AP_STATE_RESET_WAIT; 302 aq->interrupt = AP_INTR_DISABLED; 303 return AP_WAIT_TIMEOUT; 304 case AP_RESPONSE_BUSY: 305 return AP_WAIT_TIMEOUT; 306 case AP_RESPONSE_Q_NOT_AVAIL: 307 case AP_RESPONSE_DECONFIGURED: 308 case AP_RESPONSE_CHECKSTOPPED: 309 default: 310 aq->state = AP_STATE_BORKED; 311 return AP_WAIT_NONE; 312 } 313 } 314 315 /** 316 * ap_sm_reset_wait(): Test queue for completion of the reset operation 317 * @aq: pointer to the AP queue 318 * 319 * Returns AP_POLL_IMMEDIATELY, AP_POLL_AFTER_TIMEROUT or 0. 320 */ 321 static enum ap_wait ap_sm_reset_wait(struct ap_queue *aq) 322 { 323 struct ap_queue_status status; 324 void *lsi_ptr; 325 326 if (aq->queue_count > 0 && aq->reply) 327 /* Try to read a completed message and get the status */ 328 status = ap_sm_recv(aq); 329 else 330 /* Get the status with TAPQ */ 331 status = ap_tapq(aq->qid, NULL); 332 333 switch (status.response_code) { 334 case AP_RESPONSE_NORMAL: 335 lsi_ptr = ap_airq_ptr(); 336 if (lsi_ptr && ap_queue_enable_interruption(aq, lsi_ptr) == 0) 337 aq->state = AP_STATE_SETIRQ_WAIT; 338 else 339 aq->state = (aq->queue_count > 0) ? 340 AP_STATE_WORKING : AP_STATE_IDLE; 341 return AP_WAIT_AGAIN; 342 case AP_RESPONSE_BUSY: 343 case AP_RESPONSE_RESET_IN_PROGRESS: 344 return AP_WAIT_TIMEOUT; 345 case AP_RESPONSE_Q_NOT_AVAIL: 346 case AP_RESPONSE_DECONFIGURED: 347 case AP_RESPONSE_CHECKSTOPPED: 348 default: 349 aq->state = AP_STATE_BORKED; 350 return AP_WAIT_NONE; 351 } 352 } 353 354 /** 355 * ap_sm_setirq_wait(): Test queue for completion of the irq enablement 356 * @aq: pointer to the AP queue 357 * 358 * Returns AP_POLL_IMMEDIATELY, AP_POLL_AFTER_TIMEROUT or 0. 359 */ 360 static enum ap_wait ap_sm_setirq_wait(struct ap_queue *aq) 361 { 362 struct ap_queue_status status; 363 364 if (aq->queue_count > 0 && aq->reply) 365 /* Try to read a completed message and get the status */ 366 status = ap_sm_recv(aq); 367 else 368 /* Get the status with TAPQ */ 369 status = ap_tapq(aq->qid, NULL); 370 371 if (status.irq_enabled == 1) { 372 /* Irqs are now enabled */ 373 aq->interrupt = AP_INTR_ENABLED; 374 aq->state = (aq->queue_count > 0) ? 375 AP_STATE_WORKING : AP_STATE_IDLE; 376 } 377 378 switch (status.response_code) { 379 case AP_RESPONSE_NORMAL: 380 if (aq->queue_count > 0) 381 return AP_WAIT_AGAIN; 382 /* fallthrough */ 383 case AP_RESPONSE_NO_PENDING_REPLY: 384 return AP_WAIT_TIMEOUT; 385 default: 386 aq->state = AP_STATE_BORKED; 387 return AP_WAIT_NONE; 388 } 389 } 390 391 /* 392 * AP state machine jump table 393 */ 394 static ap_func_t *ap_jumptable[NR_AP_STATES][NR_AP_EVENTS] = { 395 [AP_STATE_RESET_START] = { 396 [AP_EVENT_POLL] = ap_sm_reset, 397 [AP_EVENT_TIMEOUT] = ap_sm_nop, 398 }, 399 [AP_STATE_RESET_WAIT] = { 400 [AP_EVENT_POLL] = ap_sm_reset_wait, 401 [AP_EVENT_TIMEOUT] = ap_sm_nop, 402 }, 403 [AP_STATE_SETIRQ_WAIT] = { 404 [AP_EVENT_POLL] = ap_sm_setirq_wait, 405 [AP_EVENT_TIMEOUT] = ap_sm_nop, 406 }, 407 [AP_STATE_IDLE] = { 408 [AP_EVENT_POLL] = ap_sm_write, 409 [AP_EVENT_TIMEOUT] = ap_sm_nop, 410 }, 411 [AP_STATE_WORKING] = { 412 [AP_EVENT_POLL] = ap_sm_read_write, 413 [AP_EVENT_TIMEOUT] = ap_sm_reset, 414 }, 415 [AP_STATE_QUEUE_FULL] = { 416 [AP_EVENT_POLL] = ap_sm_read, 417 [AP_EVENT_TIMEOUT] = ap_sm_reset, 418 }, 419 [AP_STATE_SUSPEND_WAIT] = { 420 [AP_EVENT_POLL] = ap_sm_suspend_read, 421 [AP_EVENT_TIMEOUT] = ap_sm_nop, 422 }, 423 [AP_STATE_UNBOUND] = { 424 [AP_EVENT_POLL] = ap_sm_nop, 425 [AP_EVENT_TIMEOUT] = ap_sm_nop, 426 }, 427 [AP_STATE_BORKED] = { 428 [AP_EVENT_POLL] = ap_sm_nop, 429 [AP_EVENT_TIMEOUT] = ap_sm_nop, 430 }, 431 }; 432 433 enum ap_wait ap_sm_event(struct ap_queue *aq, enum ap_event event) 434 { 435 return ap_jumptable[aq->state][event](aq); 436 } 437 438 enum ap_wait ap_sm_event_loop(struct ap_queue *aq, enum ap_event event) 439 { 440 enum ap_wait wait; 441 442 while ((wait = ap_sm_event(aq, event)) == AP_WAIT_AGAIN) 443 ; 444 return wait; 445 } 446 447 /* 448 * Power management for queue devices 449 */ 450 void ap_queue_suspend(struct ap_device *ap_dev) 451 { 452 struct ap_queue *aq = to_ap_queue(&ap_dev->device); 453 454 /* Poll on the device until all requests are finished. */ 455 spin_lock_bh(&aq->lock); 456 aq->state = AP_STATE_SUSPEND_WAIT; 457 while (ap_sm_event(aq, AP_EVENT_POLL) != AP_WAIT_NONE) 458 ; 459 aq->state = AP_STATE_BORKED; 460 spin_unlock_bh(&aq->lock); 461 } 462 EXPORT_SYMBOL(ap_queue_suspend); 463 464 void ap_queue_resume(struct ap_device *ap_dev) 465 { 466 } 467 EXPORT_SYMBOL(ap_queue_resume); 468 469 /* 470 * AP queue related attributes. 471 */ 472 static ssize_t request_count_show(struct device *dev, 473 struct device_attribute *attr, 474 char *buf) 475 { 476 struct ap_queue *aq = to_ap_queue(dev); 477 unsigned int req_cnt; 478 479 spin_lock_bh(&aq->lock); 480 req_cnt = aq->total_request_count; 481 spin_unlock_bh(&aq->lock); 482 return snprintf(buf, PAGE_SIZE, "%d\n", req_cnt); 483 } 484 485 static ssize_t request_count_store(struct device *dev, 486 struct device_attribute *attr, 487 const char *buf, size_t count) 488 { 489 struct ap_queue *aq = to_ap_queue(dev); 490 491 spin_lock_bh(&aq->lock); 492 aq->total_request_count = 0; 493 spin_unlock_bh(&aq->lock); 494 495 return count; 496 } 497 498 static DEVICE_ATTR_RW(request_count); 499 500 static ssize_t requestq_count_show(struct device *dev, 501 struct device_attribute *attr, char *buf) 502 { 503 struct ap_queue *aq = to_ap_queue(dev); 504 unsigned int reqq_cnt = 0; 505 506 spin_lock_bh(&aq->lock); 507 reqq_cnt = aq->requestq_count; 508 spin_unlock_bh(&aq->lock); 509 return snprintf(buf, PAGE_SIZE, "%d\n", reqq_cnt); 510 } 511 512 static DEVICE_ATTR_RO(requestq_count); 513 514 static ssize_t pendingq_count_show(struct device *dev, 515 struct device_attribute *attr, char *buf) 516 { 517 struct ap_queue *aq = to_ap_queue(dev); 518 unsigned int penq_cnt = 0; 519 520 spin_lock_bh(&aq->lock); 521 penq_cnt = aq->pendingq_count; 522 spin_unlock_bh(&aq->lock); 523 return snprintf(buf, PAGE_SIZE, "%d\n", penq_cnt); 524 } 525 526 static DEVICE_ATTR_RO(pendingq_count); 527 528 static ssize_t reset_show(struct device *dev, 529 struct device_attribute *attr, char *buf) 530 { 531 struct ap_queue *aq = to_ap_queue(dev); 532 int rc = 0; 533 534 spin_lock_bh(&aq->lock); 535 switch (aq->state) { 536 case AP_STATE_RESET_START: 537 case AP_STATE_RESET_WAIT: 538 rc = snprintf(buf, PAGE_SIZE, "Reset in progress.\n"); 539 break; 540 case AP_STATE_WORKING: 541 case AP_STATE_QUEUE_FULL: 542 rc = snprintf(buf, PAGE_SIZE, "Reset Timer armed.\n"); 543 break; 544 default: 545 rc = snprintf(buf, PAGE_SIZE, "No Reset Timer set.\n"); 546 } 547 spin_unlock_bh(&aq->lock); 548 return rc; 549 } 550 551 static ssize_t reset_store(struct device *dev, 552 struct device_attribute *attr, 553 const char *buf, size_t count) 554 { 555 struct ap_queue *aq = to_ap_queue(dev); 556 557 spin_lock_bh(&aq->lock); 558 __ap_flush_queue(aq); 559 aq->state = AP_STATE_RESET_START; 560 ap_wait(ap_sm_event(aq, AP_EVENT_POLL)); 561 spin_unlock_bh(&aq->lock); 562 563 AP_DBF(DBF_INFO, "reset queue=%02x.%04x triggered by user\n", 564 AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); 565 566 return count; 567 } 568 569 static DEVICE_ATTR_RW(reset); 570 571 static ssize_t interrupt_show(struct device *dev, 572 struct device_attribute *attr, char *buf) 573 { 574 struct ap_queue *aq = to_ap_queue(dev); 575 int rc = 0; 576 577 spin_lock_bh(&aq->lock); 578 if (aq->state == AP_STATE_SETIRQ_WAIT) 579 rc = snprintf(buf, PAGE_SIZE, "Enable Interrupt pending.\n"); 580 else if (aq->interrupt == AP_INTR_ENABLED) 581 rc = snprintf(buf, PAGE_SIZE, "Interrupts enabled.\n"); 582 else 583 rc = snprintf(buf, PAGE_SIZE, "Interrupts disabled.\n"); 584 spin_unlock_bh(&aq->lock); 585 return rc; 586 } 587 588 static DEVICE_ATTR_RO(interrupt); 589 590 static struct attribute *ap_queue_dev_attrs[] = { 591 &dev_attr_request_count.attr, 592 &dev_attr_requestq_count.attr, 593 &dev_attr_pendingq_count.attr, 594 &dev_attr_reset.attr, 595 &dev_attr_interrupt.attr, 596 NULL 597 }; 598 599 static struct attribute_group ap_queue_dev_attr_group = { 600 .attrs = ap_queue_dev_attrs 601 }; 602 603 static const struct attribute_group *ap_queue_dev_attr_groups[] = { 604 &ap_queue_dev_attr_group, 605 NULL 606 }; 607 608 static struct device_type ap_queue_type = { 609 .name = "ap_queue", 610 .groups = ap_queue_dev_attr_groups, 611 }; 612 613 static void ap_queue_device_release(struct device *dev) 614 { 615 struct ap_queue *aq = to_ap_queue(dev); 616 617 if (!list_empty(&aq->list)) { 618 spin_lock_bh(&ap_list_lock); 619 list_del_init(&aq->list); 620 spin_unlock_bh(&ap_list_lock); 621 } 622 kfree(aq); 623 } 624 625 struct ap_queue *ap_queue_create(ap_qid_t qid, int device_type) 626 { 627 struct ap_queue *aq; 628 629 aq = kzalloc(sizeof(*aq), GFP_KERNEL); 630 if (!aq) 631 return NULL; 632 aq->ap_dev.device.release = ap_queue_device_release; 633 aq->ap_dev.device.type = &ap_queue_type; 634 aq->ap_dev.device_type = device_type; 635 aq->qid = qid; 636 aq->state = AP_STATE_RESET_START; 637 aq->interrupt = AP_INTR_DISABLED; 638 spin_lock_init(&aq->lock); 639 INIT_LIST_HEAD(&aq->list); 640 INIT_LIST_HEAD(&aq->pendingq); 641 INIT_LIST_HEAD(&aq->requestq); 642 timer_setup(&aq->timeout, ap_request_timeout, 0); 643 644 return aq; 645 } 646 647 void ap_queue_init_reply(struct ap_queue *aq, struct ap_message *reply) 648 { 649 aq->reply = reply; 650 651 spin_lock_bh(&aq->lock); 652 ap_wait(ap_sm_event(aq, AP_EVENT_POLL)); 653 spin_unlock_bh(&aq->lock); 654 } 655 EXPORT_SYMBOL(ap_queue_init_reply); 656 657 /** 658 * ap_queue_message(): Queue a request to an AP device. 659 * @aq: The AP device to queue the message to 660 * @ap_msg: The message that is to be added 661 */ 662 void ap_queue_message(struct ap_queue *aq, struct ap_message *ap_msg) 663 { 664 /* For asynchronous message handling a valid receive-callback 665 * is required. 666 */ 667 BUG_ON(!ap_msg->receive); 668 669 spin_lock_bh(&aq->lock); 670 /* Queue the message. */ 671 list_add_tail(&ap_msg->list, &aq->requestq); 672 aq->requestq_count++; 673 aq->total_request_count++; 674 atomic_inc(&aq->card->total_request_count); 675 /* Send/receive as many request from the queue as possible. */ 676 ap_wait(ap_sm_event_loop(aq, AP_EVENT_POLL)); 677 spin_unlock_bh(&aq->lock); 678 } 679 EXPORT_SYMBOL(ap_queue_message); 680 681 /** 682 * ap_cancel_message(): Cancel a crypto request. 683 * @aq: The AP device that has the message queued 684 * @ap_msg: The message that is to be removed 685 * 686 * Cancel a crypto request. This is done by removing the request 687 * from the device pending or request queue. Note that the 688 * request stays on the AP queue. When it finishes the message 689 * reply will be discarded because the psmid can't be found. 690 */ 691 void ap_cancel_message(struct ap_queue *aq, struct ap_message *ap_msg) 692 { 693 struct ap_message *tmp; 694 695 spin_lock_bh(&aq->lock); 696 if (!list_empty(&ap_msg->list)) { 697 list_for_each_entry(tmp, &aq->pendingq, list) 698 if (tmp->psmid == ap_msg->psmid) { 699 aq->pendingq_count--; 700 goto found; 701 } 702 aq->requestq_count--; 703 found: 704 list_del_init(&ap_msg->list); 705 } 706 spin_unlock_bh(&aq->lock); 707 } 708 EXPORT_SYMBOL(ap_cancel_message); 709 710 /** 711 * __ap_flush_queue(): Flush requests. 712 * @aq: Pointer to the AP queue 713 * 714 * Flush all requests from the request/pending queue of an AP device. 715 */ 716 static void __ap_flush_queue(struct ap_queue *aq) 717 { 718 struct ap_message *ap_msg, *next; 719 720 list_for_each_entry_safe(ap_msg, next, &aq->pendingq, list) { 721 list_del_init(&ap_msg->list); 722 aq->pendingq_count--; 723 ap_msg->rc = -EAGAIN; 724 ap_msg->receive(aq, ap_msg, NULL); 725 } 726 list_for_each_entry_safe(ap_msg, next, &aq->requestq, list) { 727 list_del_init(&ap_msg->list); 728 aq->requestq_count--; 729 ap_msg->rc = -EAGAIN; 730 ap_msg->receive(aq, ap_msg, NULL); 731 } 732 aq->queue_count = 0; 733 } 734 735 void ap_flush_queue(struct ap_queue *aq) 736 { 737 spin_lock_bh(&aq->lock); 738 __ap_flush_queue(aq); 739 spin_unlock_bh(&aq->lock); 740 } 741 EXPORT_SYMBOL(ap_flush_queue); 742 743 void ap_queue_remove(struct ap_queue *aq) 744 { 745 ap_flush_queue(aq); 746 del_timer_sync(&aq->timeout); 747 748 /* reset with zero, also clears irq registration */ 749 spin_lock_bh(&aq->lock); 750 ap_zapq(aq->qid); 751 aq->state = AP_STATE_UNBOUND; 752 spin_unlock_bh(&aq->lock); 753 } 754 EXPORT_SYMBOL(ap_queue_remove); 755 756 void ap_queue_reinit_state(struct ap_queue *aq) 757 { 758 spin_lock_bh(&aq->lock); 759 aq->state = AP_STATE_RESET_START; 760 ap_wait(ap_sm_event(aq, AP_EVENT_POLL)); 761 spin_unlock_bh(&aq->lock); 762 } 763 EXPORT_SYMBOL(ap_queue_reinit_state); 764