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 fallthrough; 156 case AP_RESPONSE_NO_PENDING_REPLY: 157 if (!status.queue_empty || aq->queue_count <= 0) 158 break; 159 /* The card shouldn't forget requests but who knows. */ 160 aq->queue_count = 0; 161 list_splice_init(&aq->pendingq, &aq->requestq); 162 aq->requestq_count += aq->pendingq_count; 163 aq->pendingq_count = 0; 164 break; 165 default: 166 break; 167 } 168 return status; 169 } 170 171 /** 172 * ap_sm_read(): Receive pending reply messages from an AP queue. 173 * @aq: pointer to the AP queue 174 * 175 * Returns AP_WAIT_NONE, AP_WAIT_AGAIN, or AP_WAIT_INTERRUPT 176 */ 177 static enum ap_wait ap_sm_read(struct ap_queue *aq) 178 { 179 struct ap_queue_status status; 180 181 if (!aq->reply) 182 return AP_WAIT_NONE; 183 status = ap_sm_recv(aq); 184 switch (status.response_code) { 185 case AP_RESPONSE_NORMAL: 186 if (aq->queue_count > 0) { 187 aq->state = AP_STATE_WORKING; 188 return AP_WAIT_AGAIN; 189 } 190 aq->state = AP_STATE_IDLE; 191 return AP_WAIT_NONE; 192 case AP_RESPONSE_NO_PENDING_REPLY: 193 if (aq->queue_count > 0) 194 return AP_WAIT_INTERRUPT; 195 aq->state = AP_STATE_IDLE; 196 return AP_WAIT_NONE; 197 default: 198 aq->state = AP_STATE_BORKED; 199 return AP_WAIT_NONE; 200 } 201 } 202 203 /** 204 * ap_sm_write(): Send messages from the request queue to an AP queue. 205 * @aq: pointer to the AP queue 206 * 207 * Returns AP_WAIT_NONE, AP_WAIT_AGAIN, or AP_WAIT_INTERRUPT 208 */ 209 static enum ap_wait ap_sm_write(struct ap_queue *aq) 210 { 211 struct ap_queue_status status; 212 struct ap_message *ap_msg; 213 214 if (aq->requestq_count <= 0) 215 return AP_WAIT_NONE; 216 /* Start the next request on the queue. */ 217 ap_msg = list_entry(aq->requestq.next, struct ap_message, list); 218 status = __ap_send(aq->qid, ap_msg->psmid, 219 ap_msg->message, ap_msg->length, ap_msg->special); 220 switch (status.response_code) { 221 case AP_RESPONSE_NORMAL: 222 aq->queue_count++; 223 if (aq->queue_count == 1) 224 mod_timer(&aq->timeout, jiffies + aq->request_timeout); 225 list_move_tail(&ap_msg->list, &aq->pendingq); 226 aq->requestq_count--; 227 aq->pendingq_count++; 228 if (aq->queue_count < aq->card->queue_depth) { 229 aq->state = AP_STATE_WORKING; 230 return AP_WAIT_AGAIN; 231 } 232 fallthrough; 233 case AP_RESPONSE_Q_FULL: 234 aq->state = AP_STATE_QUEUE_FULL; 235 return AP_WAIT_INTERRUPT; 236 case AP_RESPONSE_RESET_IN_PROGRESS: 237 aq->state = AP_STATE_RESET_WAIT; 238 return AP_WAIT_TIMEOUT; 239 case AP_RESPONSE_MESSAGE_TOO_BIG: 240 case AP_RESPONSE_REQ_FAC_NOT_INST: 241 list_del_init(&ap_msg->list); 242 aq->requestq_count--; 243 ap_msg->rc = -EINVAL; 244 ap_msg->receive(aq, ap_msg, NULL); 245 return AP_WAIT_AGAIN; 246 default: 247 aq->state = AP_STATE_BORKED; 248 return AP_WAIT_NONE; 249 } 250 } 251 252 /** 253 * ap_sm_read_write(): Send and receive messages to/from an AP queue. 254 * @aq: pointer to the AP queue 255 * 256 * Returns AP_WAIT_NONE, AP_WAIT_AGAIN, or AP_WAIT_INTERRUPT 257 */ 258 static enum ap_wait ap_sm_read_write(struct ap_queue *aq) 259 { 260 return min(ap_sm_read(aq), ap_sm_write(aq)); 261 } 262 263 /** 264 * ap_sm_reset(): Reset an AP queue. 265 * @qid: The AP queue number 266 * 267 * Submit the Reset command to an AP queue. 268 */ 269 static enum ap_wait ap_sm_reset(struct ap_queue *aq) 270 { 271 struct ap_queue_status status; 272 273 status = ap_rapq(aq->qid); 274 switch (status.response_code) { 275 case AP_RESPONSE_NORMAL: 276 case AP_RESPONSE_RESET_IN_PROGRESS: 277 aq->state = AP_STATE_RESET_WAIT; 278 aq->interrupt = AP_INTR_DISABLED; 279 return AP_WAIT_TIMEOUT; 280 case AP_RESPONSE_BUSY: 281 return AP_WAIT_TIMEOUT; 282 case AP_RESPONSE_Q_NOT_AVAIL: 283 case AP_RESPONSE_DECONFIGURED: 284 case AP_RESPONSE_CHECKSTOPPED: 285 default: 286 aq->state = AP_STATE_BORKED; 287 return AP_WAIT_NONE; 288 } 289 } 290 291 /** 292 * ap_sm_reset_wait(): Test queue for completion of the reset operation 293 * @aq: pointer to the AP queue 294 * 295 * Returns AP_POLL_IMMEDIATELY, AP_POLL_AFTER_TIMEROUT or 0. 296 */ 297 static enum ap_wait ap_sm_reset_wait(struct ap_queue *aq) 298 { 299 struct ap_queue_status status; 300 void *lsi_ptr; 301 302 if (aq->queue_count > 0 && aq->reply) 303 /* Try to read a completed message and get the status */ 304 status = ap_sm_recv(aq); 305 else 306 /* Get the status with TAPQ */ 307 status = ap_tapq(aq->qid, NULL); 308 309 switch (status.response_code) { 310 case AP_RESPONSE_NORMAL: 311 lsi_ptr = ap_airq_ptr(); 312 if (lsi_ptr && ap_queue_enable_interruption(aq, lsi_ptr) == 0) 313 aq->state = AP_STATE_SETIRQ_WAIT; 314 else 315 aq->state = (aq->queue_count > 0) ? 316 AP_STATE_WORKING : AP_STATE_IDLE; 317 return AP_WAIT_AGAIN; 318 case AP_RESPONSE_BUSY: 319 case AP_RESPONSE_RESET_IN_PROGRESS: 320 return AP_WAIT_TIMEOUT; 321 case AP_RESPONSE_Q_NOT_AVAIL: 322 case AP_RESPONSE_DECONFIGURED: 323 case AP_RESPONSE_CHECKSTOPPED: 324 default: 325 aq->state = AP_STATE_BORKED; 326 return AP_WAIT_NONE; 327 } 328 } 329 330 /** 331 * ap_sm_setirq_wait(): Test queue for completion of the irq enablement 332 * @aq: pointer to the AP queue 333 * 334 * Returns AP_POLL_IMMEDIATELY, AP_POLL_AFTER_TIMEROUT or 0. 335 */ 336 static enum ap_wait ap_sm_setirq_wait(struct ap_queue *aq) 337 { 338 struct ap_queue_status status; 339 340 if (aq->queue_count > 0 && aq->reply) 341 /* Try to read a completed message and get the status */ 342 status = ap_sm_recv(aq); 343 else 344 /* Get the status with TAPQ */ 345 status = ap_tapq(aq->qid, NULL); 346 347 if (status.irq_enabled == 1) { 348 /* Irqs are now enabled */ 349 aq->interrupt = AP_INTR_ENABLED; 350 aq->state = (aq->queue_count > 0) ? 351 AP_STATE_WORKING : AP_STATE_IDLE; 352 } 353 354 switch (status.response_code) { 355 case AP_RESPONSE_NORMAL: 356 if (aq->queue_count > 0) 357 return AP_WAIT_AGAIN; 358 fallthrough; 359 case AP_RESPONSE_NO_PENDING_REPLY: 360 return AP_WAIT_TIMEOUT; 361 default: 362 aq->state = AP_STATE_BORKED; 363 return AP_WAIT_NONE; 364 } 365 } 366 367 /* 368 * AP state machine jump table 369 */ 370 static ap_func_t *ap_jumptable[NR_AP_STATES][NR_AP_EVENTS] = { 371 [AP_STATE_RESET_START] = { 372 [AP_EVENT_POLL] = ap_sm_reset, 373 [AP_EVENT_TIMEOUT] = ap_sm_nop, 374 }, 375 [AP_STATE_RESET_WAIT] = { 376 [AP_EVENT_POLL] = ap_sm_reset_wait, 377 [AP_EVENT_TIMEOUT] = ap_sm_nop, 378 }, 379 [AP_STATE_SETIRQ_WAIT] = { 380 [AP_EVENT_POLL] = ap_sm_setirq_wait, 381 [AP_EVENT_TIMEOUT] = ap_sm_nop, 382 }, 383 [AP_STATE_IDLE] = { 384 [AP_EVENT_POLL] = ap_sm_write, 385 [AP_EVENT_TIMEOUT] = ap_sm_nop, 386 }, 387 [AP_STATE_WORKING] = { 388 [AP_EVENT_POLL] = ap_sm_read_write, 389 [AP_EVENT_TIMEOUT] = ap_sm_reset, 390 }, 391 [AP_STATE_QUEUE_FULL] = { 392 [AP_EVENT_POLL] = ap_sm_read, 393 [AP_EVENT_TIMEOUT] = ap_sm_reset, 394 }, 395 [AP_STATE_REMOVE] = { 396 [AP_EVENT_POLL] = ap_sm_nop, 397 [AP_EVENT_TIMEOUT] = ap_sm_nop, 398 }, 399 [AP_STATE_UNBOUND] = { 400 [AP_EVENT_POLL] = ap_sm_nop, 401 [AP_EVENT_TIMEOUT] = ap_sm_nop, 402 }, 403 [AP_STATE_BORKED] = { 404 [AP_EVENT_POLL] = ap_sm_nop, 405 [AP_EVENT_TIMEOUT] = ap_sm_nop, 406 }, 407 }; 408 409 enum ap_wait ap_sm_event(struct ap_queue *aq, enum ap_event event) 410 { 411 return ap_jumptable[aq->state][event](aq); 412 } 413 414 enum ap_wait ap_sm_event_loop(struct ap_queue *aq, enum ap_event event) 415 { 416 enum ap_wait wait; 417 418 while ((wait = ap_sm_event(aq, event)) == AP_WAIT_AGAIN) 419 ; 420 return wait; 421 } 422 423 /* 424 * AP queue related attributes. 425 */ 426 static ssize_t request_count_show(struct device *dev, 427 struct device_attribute *attr, 428 char *buf) 429 { 430 struct ap_queue *aq = to_ap_queue(dev); 431 u64 req_cnt; 432 433 spin_lock_bh(&aq->lock); 434 req_cnt = aq->total_request_count; 435 spin_unlock_bh(&aq->lock); 436 return scnprintf(buf, PAGE_SIZE, "%llu\n", req_cnt); 437 } 438 439 static ssize_t request_count_store(struct device *dev, 440 struct device_attribute *attr, 441 const char *buf, size_t count) 442 { 443 struct ap_queue *aq = to_ap_queue(dev); 444 445 spin_lock_bh(&aq->lock); 446 aq->total_request_count = 0; 447 spin_unlock_bh(&aq->lock); 448 449 return count; 450 } 451 452 static DEVICE_ATTR_RW(request_count); 453 454 static ssize_t requestq_count_show(struct device *dev, 455 struct device_attribute *attr, char *buf) 456 { 457 struct ap_queue *aq = to_ap_queue(dev); 458 unsigned int reqq_cnt = 0; 459 460 spin_lock_bh(&aq->lock); 461 reqq_cnt = aq->requestq_count; 462 spin_unlock_bh(&aq->lock); 463 return scnprintf(buf, PAGE_SIZE, "%d\n", reqq_cnt); 464 } 465 466 static DEVICE_ATTR_RO(requestq_count); 467 468 static ssize_t pendingq_count_show(struct device *dev, 469 struct device_attribute *attr, char *buf) 470 { 471 struct ap_queue *aq = to_ap_queue(dev); 472 unsigned int penq_cnt = 0; 473 474 spin_lock_bh(&aq->lock); 475 penq_cnt = aq->pendingq_count; 476 spin_unlock_bh(&aq->lock); 477 return scnprintf(buf, PAGE_SIZE, "%d\n", penq_cnt); 478 } 479 480 static DEVICE_ATTR_RO(pendingq_count); 481 482 static ssize_t reset_show(struct device *dev, 483 struct device_attribute *attr, char *buf) 484 { 485 struct ap_queue *aq = to_ap_queue(dev); 486 int rc = 0; 487 488 spin_lock_bh(&aq->lock); 489 switch (aq->state) { 490 case AP_STATE_RESET_START: 491 case AP_STATE_RESET_WAIT: 492 rc = scnprintf(buf, PAGE_SIZE, "Reset in progress.\n"); 493 break; 494 case AP_STATE_WORKING: 495 case AP_STATE_QUEUE_FULL: 496 rc = scnprintf(buf, PAGE_SIZE, "Reset Timer armed.\n"); 497 break; 498 default: 499 rc = scnprintf(buf, PAGE_SIZE, "No Reset Timer set.\n"); 500 } 501 spin_unlock_bh(&aq->lock); 502 return rc; 503 } 504 505 static ssize_t reset_store(struct device *dev, 506 struct device_attribute *attr, 507 const char *buf, size_t count) 508 { 509 struct ap_queue *aq = to_ap_queue(dev); 510 511 spin_lock_bh(&aq->lock); 512 __ap_flush_queue(aq); 513 aq->state = AP_STATE_RESET_START; 514 ap_wait(ap_sm_event(aq, AP_EVENT_POLL)); 515 spin_unlock_bh(&aq->lock); 516 517 AP_DBF(DBF_INFO, "reset queue=%02x.%04x triggered by user\n", 518 AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); 519 520 return count; 521 } 522 523 static DEVICE_ATTR_RW(reset); 524 525 static ssize_t interrupt_show(struct device *dev, 526 struct device_attribute *attr, char *buf) 527 { 528 struct ap_queue *aq = to_ap_queue(dev); 529 int rc = 0; 530 531 spin_lock_bh(&aq->lock); 532 if (aq->state == AP_STATE_SETIRQ_WAIT) 533 rc = scnprintf(buf, PAGE_SIZE, "Enable Interrupt pending.\n"); 534 else if (aq->interrupt == AP_INTR_ENABLED) 535 rc = scnprintf(buf, PAGE_SIZE, "Interrupts enabled.\n"); 536 else 537 rc = scnprintf(buf, PAGE_SIZE, "Interrupts disabled.\n"); 538 spin_unlock_bh(&aq->lock); 539 return rc; 540 } 541 542 static DEVICE_ATTR_RO(interrupt); 543 544 static struct attribute *ap_queue_dev_attrs[] = { 545 &dev_attr_request_count.attr, 546 &dev_attr_requestq_count.attr, 547 &dev_attr_pendingq_count.attr, 548 &dev_attr_reset.attr, 549 &dev_attr_interrupt.attr, 550 NULL 551 }; 552 553 static struct attribute_group ap_queue_dev_attr_group = { 554 .attrs = ap_queue_dev_attrs 555 }; 556 557 static const struct attribute_group *ap_queue_dev_attr_groups[] = { 558 &ap_queue_dev_attr_group, 559 NULL 560 }; 561 562 static struct device_type ap_queue_type = { 563 .name = "ap_queue", 564 .groups = ap_queue_dev_attr_groups, 565 }; 566 567 static void ap_queue_device_release(struct device *dev) 568 { 569 struct ap_queue *aq = to_ap_queue(dev); 570 571 spin_lock_bh(&ap_queues_lock); 572 hash_del(&aq->hnode); 573 spin_unlock_bh(&ap_queues_lock); 574 575 kfree(aq); 576 } 577 578 struct ap_queue *ap_queue_create(ap_qid_t qid, int device_type) 579 { 580 struct ap_queue *aq; 581 582 aq = kzalloc(sizeof(*aq), GFP_KERNEL); 583 if (!aq) 584 return NULL; 585 aq->ap_dev.device.release = ap_queue_device_release; 586 aq->ap_dev.device.type = &ap_queue_type; 587 aq->ap_dev.device_type = device_type; 588 aq->qid = qid; 589 aq->state = AP_STATE_UNBOUND; 590 aq->interrupt = AP_INTR_DISABLED; 591 spin_lock_init(&aq->lock); 592 INIT_LIST_HEAD(&aq->pendingq); 593 INIT_LIST_HEAD(&aq->requestq); 594 timer_setup(&aq->timeout, ap_request_timeout, 0); 595 596 return aq; 597 } 598 599 void ap_queue_init_reply(struct ap_queue *aq, struct ap_message *reply) 600 { 601 aq->reply = reply; 602 603 spin_lock_bh(&aq->lock); 604 ap_wait(ap_sm_event(aq, AP_EVENT_POLL)); 605 spin_unlock_bh(&aq->lock); 606 } 607 EXPORT_SYMBOL(ap_queue_init_reply); 608 609 /** 610 * ap_queue_message(): Queue a request to an AP device. 611 * @aq: The AP device to queue the message to 612 * @ap_msg: The message that is to be added 613 */ 614 void ap_queue_message(struct ap_queue *aq, struct ap_message *ap_msg) 615 { 616 /* For asynchronous message handling a valid receive-callback 617 * is required. 618 */ 619 BUG_ON(!ap_msg->receive); 620 621 spin_lock_bh(&aq->lock); 622 /* Queue the message. */ 623 list_add_tail(&ap_msg->list, &aq->requestq); 624 aq->requestq_count++; 625 aq->total_request_count++; 626 atomic64_inc(&aq->card->total_request_count); 627 /* Send/receive as many request from the queue as possible. */ 628 ap_wait(ap_sm_event_loop(aq, AP_EVENT_POLL)); 629 spin_unlock_bh(&aq->lock); 630 } 631 EXPORT_SYMBOL(ap_queue_message); 632 633 /** 634 * ap_cancel_message(): Cancel a crypto request. 635 * @aq: The AP device that has the message queued 636 * @ap_msg: The message that is to be removed 637 * 638 * Cancel a crypto request. This is done by removing the request 639 * from the device pending or request queue. Note that the 640 * request stays on the AP queue. When it finishes the message 641 * reply will be discarded because the psmid can't be found. 642 */ 643 void ap_cancel_message(struct ap_queue *aq, struct ap_message *ap_msg) 644 { 645 struct ap_message *tmp; 646 647 spin_lock_bh(&aq->lock); 648 if (!list_empty(&ap_msg->list)) { 649 list_for_each_entry(tmp, &aq->pendingq, list) 650 if (tmp->psmid == ap_msg->psmid) { 651 aq->pendingq_count--; 652 goto found; 653 } 654 aq->requestq_count--; 655 found: 656 list_del_init(&ap_msg->list); 657 } 658 spin_unlock_bh(&aq->lock); 659 } 660 EXPORT_SYMBOL(ap_cancel_message); 661 662 /** 663 * __ap_flush_queue(): Flush requests. 664 * @aq: Pointer to the AP queue 665 * 666 * Flush all requests from the request/pending queue of an AP device. 667 */ 668 static void __ap_flush_queue(struct ap_queue *aq) 669 { 670 struct ap_message *ap_msg, *next; 671 672 list_for_each_entry_safe(ap_msg, next, &aq->pendingq, list) { 673 list_del_init(&ap_msg->list); 674 aq->pendingq_count--; 675 ap_msg->rc = -EAGAIN; 676 ap_msg->receive(aq, ap_msg, NULL); 677 } 678 list_for_each_entry_safe(ap_msg, next, &aq->requestq, list) { 679 list_del_init(&ap_msg->list); 680 aq->requestq_count--; 681 ap_msg->rc = -EAGAIN; 682 ap_msg->receive(aq, ap_msg, NULL); 683 } 684 aq->queue_count = 0; 685 } 686 687 void ap_flush_queue(struct ap_queue *aq) 688 { 689 spin_lock_bh(&aq->lock); 690 __ap_flush_queue(aq); 691 spin_unlock_bh(&aq->lock); 692 } 693 EXPORT_SYMBOL(ap_flush_queue); 694 695 void ap_queue_prepare_remove(struct ap_queue *aq) 696 { 697 spin_lock_bh(&aq->lock); 698 /* flush queue */ 699 __ap_flush_queue(aq); 700 /* set REMOVE state to prevent new messages are queued in */ 701 aq->state = AP_STATE_REMOVE; 702 spin_unlock_bh(&aq->lock); 703 del_timer_sync(&aq->timeout); 704 } 705 706 void ap_queue_remove(struct ap_queue *aq) 707 { 708 /* 709 * all messages have been flushed and the state is 710 * AP_STATE_REMOVE. Now reset with zero which also 711 * clears the irq registration and move the state 712 * to AP_STATE_UNBOUND to signal that this queue 713 * is not used by any driver currently. 714 */ 715 spin_lock_bh(&aq->lock); 716 ap_zapq(aq->qid); 717 aq->state = AP_STATE_UNBOUND; 718 spin_unlock_bh(&aq->lock); 719 } 720 721 void ap_queue_init_state(struct ap_queue *aq) 722 { 723 spin_lock_bh(&aq->lock); 724 aq->state = AP_STATE_RESET_START; 725 ap_wait(ap_sm_event(aq, AP_EVENT_POLL)); 726 spin_unlock_bh(&aq->lock); 727 } 728 EXPORT_SYMBOL(ap_queue_init_state); 729