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