1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright IBM Corp. 2016, 2023 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 * some AP queue helper functions 23 */ 24 25 static inline bool ap_q_supports_bind(struct ap_queue *aq) 26 { 27 return aq->card->hwinfo.ep11 || aq->card->hwinfo.accel; 28 } 29 30 static inline bool ap_q_supports_assoc(struct ap_queue *aq) 31 { 32 return aq->card->hwinfo.ep11; 33 } 34 35 static inline bool ap_q_needs_bind(struct ap_queue *aq) 36 { 37 return ap_q_supports_bind(aq) && ap_sb_available(); 38 } 39 40 /** 41 * ap_queue_enable_irq(): Enable interrupt support on this AP queue. 42 * @aq: The AP queue 43 * @ind: the notification indicator byte 44 * 45 * Enables interruption on AP queue via ap_aqic(). Based on the return 46 * value it waits a while and tests the AP queue if interrupts 47 * have been switched on using ap_test_queue(). 48 */ 49 static int ap_queue_enable_irq(struct ap_queue *aq, void *ind) 50 { 51 union ap_qirq_ctrl qirqctrl = { .value = 0 }; 52 struct ap_queue_status status; 53 54 qirqctrl.ir = 1; 55 qirqctrl.isc = AP_ISC; 56 status = ap_aqic(aq->qid, qirqctrl, virt_to_phys(ind)); 57 if (status.async) 58 return -EPERM; 59 switch (status.response_code) { 60 case AP_RESPONSE_NORMAL: 61 case AP_RESPONSE_OTHERWISE_CHANGED: 62 return 0; 63 case AP_RESPONSE_Q_NOT_AVAIL: 64 case AP_RESPONSE_DECONFIGURED: 65 case AP_RESPONSE_CHECKSTOPPED: 66 case AP_RESPONSE_INVALID_ADDRESS: 67 pr_err("Registering adapter interrupts for AP device %02x.%04x failed\n", 68 AP_QID_CARD(aq->qid), 69 AP_QID_QUEUE(aq->qid)); 70 return -EOPNOTSUPP; 71 case AP_RESPONSE_RESET_IN_PROGRESS: 72 case AP_RESPONSE_BUSY: 73 default: 74 return -EBUSY; 75 } 76 } 77 78 /** 79 * __ap_send(): Send message to adjunct processor queue. 80 * @qid: The AP queue number 81 * @psmid: The program supplied message identifier 82 * @msg: The message text 83 * @msglen: The message length 84 * @special: Special Bit 85 * 86 * Returns AP queue status structure. 87 * Condition code 1 on NQAP can't happen because the L bit is 1. 88 * Condition code 2 on NQAP also means the send is incomplete, 89 * because a segment boundary was reached. The NQAP is repeated. 90 */ 91 static inline struct ap_queue_status 92 __ap_send(ap_qid_t qid, unsigned long psmid, void *msg, size_t msglen, 93 int special) 94 { 95 if (special) 96 qid |= 0x400000UL; 97 return ap_nqap(qid, psmid, msg, msglen); 98 } 99 100 /* State machine definitions and helpers */ 101 102 static enum ap_sm_wait ap_sm_nop(struct ap_queue *aq) 103 { 104 return AP_SM_WAIT_NONE; 105 } 106 107 /** 108 * ap_sm_recv(): Receive pending reply messages from an AP queue but do 109 * not change the state of the device. 110 * @aq: pointer to the AP queue 111 * 112 * Returns AP_SM_WAIT_NONE, AP_SM_WAIT_AGAIN, or AP_SM_WAIT_INTERRUPT 113 */ 114 static struct ap_queue_status ap_sm_recv(struct ap_queue *aq) 115 { 116 struct ap_queue_status status; 117 struct ap_message *ap_msg; 118 bool found = false; 119 size_t reslen; 120 unsigned long resgr0 = 0; 121 int parts = 0; 122 123 /* 124 * DQAP loop until response code and resgr0 indicate that 125 * the msg is totally received. As we use the very same buffer 126 * the msg is overwritten with each invocation. That's intended 127 * and the receiver of the msg is informed with a msg rc code 128 * of EMSGSIZE in such a case. 129 */ 130 do { 131 status = ap_dqap(aq->qid, &aq->reply->psmid, 132 aq->reply->msg, aq->reply->bufsize, 133 &aq->reply->len, &reslen, &resgr0); 134 parts++; 135 } while (status.response_code == 0xFF && resgr0 != 0); 136 137 switch (status.response_code) { 138 case AP_RESPONSE_NORMAL: 139 print_hex_dump_debug("aprpl: ", DUMP_PREFIX_ADDRESS, 16, 1, 140 aq->reply->msg, aq->reply->len, false); 141 aq->queue_count = max_t(int, 0, aq->queue_count - 1); 142 if (!status.queue_empty && !aq->queue_count) 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 if (parts > 1) { 153 ap_msg->rc = -EMSGSIZE; 154 ap_msg->receive(aq, ap_msg, NULL); 155 } else { 156 ap_msg->receive(aq, ap_msg, aq->reply); 157 } 158 found = true; 159 break; 160 } 161 if (!found) { 162 AP_DBF_WARN("%s unassociated reply psmid=0x%016lx on 0x%02x.%04x\n", 163 __func__, aq->reply->psmid, 164 AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); 165 } 166 fallthrough; 167 case AP_RESPONSE_NO_PENDING_REPLY: 168 if (!status.queue_empty || aq->queue_count <= 0) 169 break; 170 /* The card shouldn't forget requests but who knows. */ 171 aq->queue_count = 0; 172 list_splice_init(&aq->pendingq, &aq->requestq); 173 aq->requestq_count += aq->pendingq_count; 174 pr_debug("%s queue 0x%02x.%04x rescheduled %d reqs (new req %d)\n", 175 __func__, AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid), 176 aq->pendingq_count, aq->requestq_count); 177 aq->pendingq_count = 0; 178 break; 179 default: 180 break; 181 } 182 return status; 183 } 184 185 /** 186 * ap_sm_read(): Receive pending reply messages from an AP queue. 187 * @aq: pointer to the AP queue 188 * 189 * Returns AP_SM_WAIT_NONE, AP_SM_WAIT_AGAIN, or AP_SM_WAIT_INTERRUPT 190 */ 191 static enum ap_sm_wait ap_sm_read(struct ap_queue *aq) 192 { 193 struct ap_queue_status status; 194 195 if (!aq->reply) 196 return AP_SM_WAIT_NONE; 197 status = ap_sm_recv(aq); 198 if (status.async) 199 return AP_SM_WAIT_NONE; 200 switch (status.response_code) { 201 case AP_RESPONSE_NORMAL: 202 if (aq->queue_count > 0) { 203 aq->sm_state = AP_SM_STATE_WORKING; 204 return AP_SM_WAIT_AGAIN; 205 } 206 aq->sm_state = AP_SM_STATE_IDLE; 207 break; 208 case AP_RESPONSE_NO_PENDING_REPLY: 209 if (aq->queue_count > 0) 210 return status.irq_enabled ? 211 AP_SM_WAIT_INTERRUPT : AP_SM_WAIT_HIGH_TIMEOUT; 212 aq->sm_state = AP_SM_STATE_IDLE; 213 break; 214 default: 215 aq->dev_state = AP_DEV_STATE_ERROR; 216 aq->last_err_rc = status.response_code; 217 AP_DBF_WARN("%s RC 0x%02x on 0x%02x.%04x -> AP_DEV_STATE_ERROR\n", 218 __func__, status.response_code, 219 AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); 220 return AP_SM_WAIT_NONE; 221 } 222 /* Check and maybe enable irq support (again) on this queue */ 223 if (!status.irq_enabled && status.queue_empty) { 224 void *lsi_ptr = ap_airq_ptr(); 225 226 if (lsi_ptr && ap_queue_enable_irq(aq, lsi_ptr) == 0) { 227 aq->sm_state = AP_SM_STATE_SETIRQ_WAIT; 228 return AP_SM_WAIT_AGAIN; 229 } 230 } 231 return AP_SM_WAIT_NONE; 232 } 233 234 /** 235 * ap_sm_write(): Send messages from the request queue to an AP queue. 236 * @aq: pointer to the AP queue 237 * 238 * Returns AP_SM_WAIT_NONE, AP_SM_WAIT_AGAIN, or AP_SM_WAIT_INTERRUPT 239 */ 240 static enum ap_sm_wait ap_sm_write(struct ap_queue *aq) 241 { 242 struct ap_queue_status status; 243 struct ap_message *ap_msg; 244 ap_qid_t qid = aq->qid; 245 246 if (aq->requestq_count <= 0) 247 return AP_SM_WAIT_NONE; 248 249 /* Start the next request on the queue. */ 250 ap_msg = list_entry(aq->requestq.next, struct ap_message, list); 251 print_hex_dump_debug("apreq: ", DUMP_PREFIX_ADDRESS, 16, 1, 252 ap_msg->msg, ap_msg->len, false); 253 status = __ap_send(qid, ap_msg->psmid, 254 ap_msg->msg, ap_msg->len, 255 ap_msg->flags & AP_MSG_FLAG_SPECIAL); 256 if (status.async) 257 return AP_SM_WAIT_NONE; 258 switch (status.response_code) { 259 case AP_RESPONSE_NORMAL: 260 aq->queue_count = max_t(int, 1, aq->queue_count + 1); 261 if (aq->queue_count == 1) 262 mod_timer(&aq->timeout, jiffies + aq->request_timeout); 263 list_move_tail(&ap_msg->list, &aq->pendingq); 264 aq->requestq_count--; 265 aq->pendingq_count++; 266 if (aq->queue_count < aq->card->hwinfo.qd) { 267 aq->sm_state = AP_SM_STATE_WORKING; 268 return AP_SM_WAIT_AGAIN; 269 } 270 fallthrough; 271 case AP_RESPONSE_Q_FULL: 272 aq->sm_state = AP_SM_STATE_QUEUE_FULL; 273 return status.irq_enabled ? 274 AP_SM_WAIT_INTERRUPT : AP_SM_WAIT_HIGH_TIMEOUT; 275 case AP_RESPONSE_RESET_IN_PROGRESS: 276 aq->sm_state = AP_SM_STATE_RESET_WAIT; 277 return AP_SM_WAIT_LOW_TIMEOUT; 278 case AP_RESPONSE_INVALID_DOMAIN: 279 AP_DBF_WARN("%s RESPONSE_INVALID_DOMAIN on NQAP\n", __func__); 280 fallthrough; 281 case AP_RESPONSE_MESSAGE_TOO_BIG: 282 case AP_RESPONSE_REQ_FAC_NOT_INST: 283 list_del_init(&ap_msg->list); 284 aq->requestq_count--; 285 ap_msg->rc = -EINVAL; 286 ap_msg->receive(aq, ap_msg, NULL); 287 return AP_SM_WAIT_AGAIN; 288 default: 289 aq->dev_state = AP_DEV_STATE_ERROR; 290 aq->last_err_rc = status.response_code; 291 AP_DBF_WARN("%s RC 0x%02x on 0x%02x.%04x -> AP_DEV_STATE_ERROR\n", 292 __func__, status.response_code, 293 AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); 294 return AP_SM_WAIT_NONE; 295 } 296 } 297 298 /** 299 * ap_sm_read_write(): Send and receive messages to/from an AP queue. 300 * @aq: pointer to the AP queue 301 * 302 * Returns AP_SM_WAIT_NONE, AP_SM_WAIT_AGAIN, or AP_SM_WAIT_INTERRUPT 303 */ 304 static enum ap_sm_wait ap_sm_read_write(struct ap_queue *aq) 305 { 306 return min(ap_sm_read(aq), ap_sm_write(aq)); 307 } 308 309 /** 310 * ap_sm_reset(): Reset an AP queue. 311 * @aq: The AP queue 312 * 313 * Submit the Reset command to an AP queue. 314 */ 315 static enum ap_sm_wait ap_sm_reset(struct ap_queue *aq) 316 { 317 struct ap_queue_status status; 318 319 status = ap_rapq(aq->qid, aq->rapq_fbit); 320 if (status.async) 321 return AP_SM_WAIT_NONE; 322 switch (status.response_code) { 323 case AP_RESPONSE_NORMAL: 324 case AP_RESPONSE_RESET_IN_PROGRESS: 325 aq->sm_state = AP_SM_STATE_RESET_WAIT; 326 aq->rapq_fbit = 0; 327 return AP_SM_WAIT_LOW_TIMEOUT; 328 default: 329 aq->dev_state = AP_DEV_STATE_ERROR; 330 aq->last_err_rc = status.response_code; 331 AP_DBF_WARN("%s RC 0x%02x on 0x%02x.%04x -> AP_DEV_STATE_ERROR\n", 332 __func__, status.response_code, 333 AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); 334 return AP_SM_WAIT_NONE; 335 } 336 } 337 338 /** 339 * ap_sm_reset_wait(): Test queue for completion of the reset operation 340 * @aq: pointer to the AP queue 341 * 342 * Returns AP_POLL_IMMEDIATELY, AP_POLL_AFTER_TIMEROUT or 0. 343 */ 344 static enum ap_sm_wait ap_sm_reset_wait(struct ap_queue *aq) 345 { 346 struct ap_queue_status status; 347 struct ap_tapq_hwinfo hwinfo; 348 void *lsi_ptr; 349 350 /* Get the status with TAPQ */ 351 status = ap_test_queue(aq->qid, 1, &hwinfo); 352 353 switch (status.response_code) { 354 case AP_RESPONSE_NORMAL: 355 aq->se_bstate = hwinfo.bs; 356 lsi_ptr = ap_airq_ptr(); 357 if (lsi_ptr && ap_queue_enable_irq(aq, lsi_ptr) == 0) 358 aq->sm_state = AP_SM_STATE_SETIRQ_WAIT; 359 else 360 aq->sm_state = (aq->queue_count > 0) ? 361 AP_SM_STATE_WORKING : AP_SM_STATE_IDLE; 362 return AP_SM_WAIT_AGAIN; 363 case AP_RESPONSE_BUSY: 364 case AP_RESPONSE_RESET_IN_PROGRESS: 365 return AP_SM_WAIT_LOW_TIMEOUT; 366 case AP_RESPONSE_Q_NOT_AVAIL: 367 case AP_RESPONSE_DECONFIGURED: 368 case AP_RESPONSE_CHECKSTOPPED: 369 default: 370 aq->dev_state = AP_DEV_STATE_ERROR; 371 aq->last_err_rc = status.response_code; 372 AP_DBF_WARN("%s RC 0x%02x on 0x%02x.%04x -> AP_DEV_STATE_ERROR\n", 373 __func__, status.response_code, 374 AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); 375 return AP_SM_WAIT_NONE; 376 } 377 } 378 379 /** 380 * ap_sm_setirq_wait(): Test queue for completion of the irq enablement 381 * @aq: pointer to the AP queue 382 * 383 * Returns AP_POLL_IMMEDIATELY, AP_POLL_AFTER_TIMEROUT or 0. 384 */ 385 static enum ap_sm_wait ap_sm_setirq_wait(struct ap_queue *aq) 386 { 387 struct ap_queue_status status; 388 389 if (aq->queue_count > 0 && aq->reply) 390 /* Try to read a completed message and get the status */ 391 status = ap_sm_recv(aq); 392 else 393 /* Get the status with TAPQ */ 394 status = ap_tapq(aq->qid, NULL); 395 396 if (status.irq_enabled == 1) { 397 /* Irqs are now enabled */ 398 aq->sm_state = (aq->queue_count > 0) ? 399 AP_SM_STATE_WORKING : AP_SM_STATE_IDLE; 400 } 401 402 switch (status.response_code) { 403 case AP_RESPONSE_NORMAL: 404 if (aq->queue_count > 0) 405 return AP_SM_WAIT_AGAIN; 406 fallthrough; 407 case AP_RESPONSE_NO_PENDING_REPLY: 408 return AP_SM_WAIT_LOW_TIMEOUT; 409 default: 410 aq->dev_state = AP_DEV_STATE_ERROR; 411 aq->last_err_rc = status.response_code; 412 AP_DBF_WARN("%s RC 0x%02x on 0x%02x.%04x -> AP_DEV_STATE_ERROR\n", 413 __func__, status.response_code, 414 AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); 415 return AP_SM_WAIT_NONE; 416 } 417 } 418 419 /** 420 * ap_sm_assoc_wait(): Test queue for completion of a pending 421 * association request. 422 * @aq: pointer to the AP queue 423 */ 424 static enum ap_sm_wait ap_sm_assoc_wait(struct ap_queue *aq) 425 { 426 struct ap_queue_status status; 427 struct ap_tapq_hwinfo hwinfo; 428 429 status = ap_test_queue(aq->qid, 1, &hwinfo); 430 /* handle asynchronous error on this queue */ 431 if (status.async && status.response_code) { 432 aq->dev_state = AP_DEV_STATE_ERROR; 433 aq->last_err_rc = status.response_code; 434 AP_DBF_WARN("%s asynch RC 0x%02x on 0x%02x.%04x -> AP_DEV_STATE_ERROR\n", 435 __func__, status.response_code, 436 AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); 437 return AP_SM_WAIT_NONE; 438 } 439 if (status.response_code > AP_RESPONSE_BUSY) { 440 aq->dev_state = AP_DEV_STATE_ERROR; 441 aq->last_err_rc = status.response_code; 442 AP_DBF_WARN("%s RC 0x%02x on 0x%02x.%04x -> AP_DEV_STATE_ERROR\n", 443 __func__, status.response_code, 444 AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); 445 return AP_SM_WAIT_NONE; 446 } 447 448 /* update queue's SE bind state */ 449 aq->se_bstate = hwinfo.bs; 450 451 /* check bs bits */ 452 switch (hwinfo.bs) { 453 case AP_BS_Q_USABLE: 454 /* association is through */ 455 aq->sm_state = AP_SM_STATE_IDLE; 456 pr_debug("%s queue 0x%02x.%04x associated with %u\n", 457 __func__, AP_QID_CARD(aq->qid), 458 AP_QID_QUEUE(aq->qid), aq->assoc_idx); 459 return AP_SM_WAIT_NONE; 460 case AP_BS_Q_USABLE_NO_SECURE_KEY: 461 /* association still pending */ 462 return AP_SM_WAIT_LOW_TIMEOUT; 463 default: 464 /* reset from 'outside' happened or no idea at all */ 465 aq->assoc_idx = ASSOC_IDX_INVALID; 466 aq->dev_state = AP_DEV_STATE_ERROR; 467 aq->last_err_rc = status.response_code; 468 AP_DBF_WARN("%s bs 0x%02x on 0x%02x.%04x -> AP_DEV_STATE_ERROR\n", 469 __func__, hwinfo.bs, 470 AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); 471 return AP_SM_WAIT_NONE; 472 } 473 } 474 475 /* 476 * AP state machine jump table 477 */ 478 static ap_func_t *ap_jumptable[NR_AP_SM_STATES][NR_AP_SM_EVENTS] = { 479 [AP_SM_STATE_RESET_START] = { 480 [AP_SM_EVENT_POLL] = ap_sm_reset, 481 [AP_SM_EVENT_TIMEOUT] = ap_sm_nop, 482 }, 483 [AP_SM_STATE_RESET_WAIT] = { 484 [AP_SM_EVENT_POLL] = ap_sm_reset_wait, 485 [AP_SM_EVENT_TIMEOUT] = ap_sm_nop, 486 }, 487 [AP_SM_STATE_SETIRQ_WAIT] = { 488 [AP_SM_EVENT_POLL] = ap_sm_setirq_wait, 489 [AP_SM_EVENT_TIMEOUT] = ap_sm_nop, 490 }, 491 [AP_SM_STATE_IDLE] = { 492 [AP_SM_EVENT_POLL] = ap_sm_write, 493 [AP_SM_EVENT_TIMEOUT] = ap_sm_nop, 494 }, 495 [AP_SM_STATE_WORKING] = { 496 [AP_SM_EVENT_POLL] = ap_sm_read_write, 497 [AP_SM_EVENT_TIMEOUT] = ap_sm_reset, 498 }, 499 [AP_SM_STATE_QUEUE_FULL] = { 500 [AP_SM_EVENT_POLL] = ap_sm_read, 501 [AP_SM_EVENT_TIMEOUT] = ap_sm_reset, 502 }, 503 [AP_SM_STATE_ASSOC_WAIT] = { 504 [AP_SM_EVENT_POLL] = ap_sm_assoc_wait, 505 [AP_SM_EVENT_TIMEOUT] = ap_sm_reset, 506 }, 507 }; 508 509 enum ap_sm_wait ap_sm_event(struct ap_queue *aq, enum ap_sm_event event) 510 { 511 if (aq->config && !aq->chkstop && 512 aq->dev_state > AP_DEV_STATE_UNINITIATED) 513 return ap_jumptable[aq->sm_state][event](aq); 514 else 515 return AP_SM_WAIT_NONE; 516 } 517 518 enum ap_sm_wait ap_sm_event_loop(struct ap_queue *aq, enum ap_sm_event event) 519 { 520 enum ap_sm_wait wait; 521 522 while ((wait = ap_sm_event(aq, event)) == AP_SM_WAIT_AGAIN) 523 ; 524 return wait; 525 } 526 527 /* 528 * AP queue related attributes. 529 */ 530 static ssize_t request_count_show(struct device *dev, 531 struct device_attribute *attr, 532 char *buf) 533 { 534 struct ap_queue *aq = to_ap_queue(dev); 535 bool valid = false; 536 u64 req_cnt; 537 538 spin_lock_bh(&aq->lock); 539 if (aq->dev_state > AP_DEV_STATE_UNINITIATED) { 540 req_cnt = aq->total_request_count; 541 valid = true; 542 } 543 spin_unlock_bh(&aq->lock); 544 545 if (valid) 546 return sysfs_emit(buf, "%llu\n", req_cnt); 547 else 548 return sysfs_emit(buf, "-\n"); 549 } 550 551 static ssize_t request_count_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 aq->total_request_count = 0; 559 spin_unlock_bh(&aq->lock); 560 561 return count; 562 } 563 564 static DEVICE_ATTR_RW(request_count); 565 566 static ssize_t requestq_count_show(struct device *dev, 567 struct device_attribute *attr, char *buf) 568 { 569 struct ap_queue *aq = to_ap_queue(dev); 570 unsigned int reqq_cnt = 0; 571 572 spin_lock_bh(&aq->lock); 573 if (aq->dev_state > AP_DEV_STATE_UNINITIATED) 574 reqq_cnt = aq->requestq_count; 575 spin_unlock_bh(&aq->lock); 576 return sysfs_emit(buf, "%d\n", reqq_cnt); 577 } 578 579 static DEVICE_ATTR_RO(requestq_count); 580 581 static ssize_t pendingq_count_show(struct device *dev, 582 struct device_attribute *attr, char *buf) 583 { 584 struct ap_queue *aq = to_ap_queue(dev); 585 unsigned int penq_cnt = 0; 586 587 spin_lock_bh(&aq->lock); 588 if (aq->dev_state > AP_DEV_STATE_UNINITIATED) 589 penq_cnt = aq->pendingq_count; 590 spin_unlock_bh(&aq->lock); 591 return sysfs_emit(buf, "%d\n", penq_cnt); 592 } 593 594 static DEVICE_ATTR_RO(pendingq_count); 595 596 static ssize_t reset_show(struct device *dev, 597 struct device_attribute *attr, char *buf) 598 { 599 struct ap_queue *aq = to_ap_queue(dev); 600 int rc = 0; 601 602 spin_lock_bh(&aq->lock); 603 switch (aq->sm_state) { 604 case AP_SM_STATE_RESET_START: 605 case AP_SM_STATE_RESET_WAIT: 606 rc = sysfs_emit(buf, "Reset in progress.\n"); 607 break; 608 case AP_SM_STATE_WORKING: 609 case AP_SM_STATE_QUEUE_FULL: 610 rc = sysfs_emit(buf, "Reset Timer armed.\n"); 611 break; 612 default: 613 rc = sysfs_emit(buf, "No Reset Timer set.\n"); 614 } 615 spin_unlock_bh(&aq->lock); 616 return rc; 617 } 618 619 static ssize_t reset_store(struct device *dev, 620 struct device_attribute *attr, 621 const char *buf, size_t count) 622 { 623 struct ap_queue *aq = to_ap_queue(dev); 624 625 spin_lock_bh(&aq->lock); 626 __ap_flush_queue(aq); 627 aq->sm_state = AP_SM_STATE_RESET_START; 628 ap_wait(ap_sm_event(aq, AP_SM_EVENT_POLL)); 629 spin_unlock_bh(&aq->lock); 630 631 AP_DBF_INFO("%s reset queue=%02x.%04x triggered by user\n", 632 __func__, AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); 633 634 return count; 635 } 636 637 static DEVICE_ATTR_RW(reset); 638 639 static ssize_t interrupt_show(struct device *dev, 640 struct device_attribute *attr, char *buf) 641 { 642 struct ap_queue *aq = to_ap_queue(dev); 643 struct ap_queue_status status; 644 int rc = 0; 645 646 spin_lock_bh(&aq->lock); 647 if (aq->sm_state == AP_SM_STATE_SETIRQ_WAIT) { 648 rc = sysfs_emit(buf, "Enable Interrupt pending.\n"); 649 } else { 650 status = ap_tapq(aq->qid, NULL); 651 if (status.irq_enabled) 652 rc = sysfs_emit(buf, "Interrupts enabled.\n"); 653 else 654 rc = sysfs_emit(buf, "Interrupts disabled.\n"); 655 } 656 spin_unlock_bh(&aq->lock); 657 658 return rc; 659 } 660 661 static DEVICE_ATTR_RO(interrupt); 662 663 static ssize_t config_show(struct device *dev, 664 struct device_attribute *attr, char *buf) 665 { 666 struct ap_queue *aq = to_ap_queue(dev); 667 int rc; 668 669 spin_lock_bh(&aq->lock); 670 rc = sysfs_emit(buf, "%d\n", aq->config ? 1 : 0); 671 spin_unlock_bh(&aq->lock); 672 return rc; 673 } 674 675 static DEVICE_ATTR_RO(config); 676 677 static ssize_t chkstop_show(struct device *dev, 678 struct device_attribute *attr, char *buf) 679 { 680 struct ap_queue *aq = to_ap_queue(dev); 681 int rc; 682 683 spin_lock_bh(&aq->lock); 684 rc = sysfs_emit(buf, "%d\n", aq->chkstop ? 1 : 0); 685 spin_unlock_bh(&aq->lock); 686 return rc; 687 } 688 689 static DEVICE_ATTR_RO(chkstop); 690 691 static ssize_t ap_functions_show(struct device *dev, 692 struct device_attribute *attr, char *buf) 693 { 694 struct ap_queue *aq = to_ap_queue(dev); 695 struct ap_queue_status status; 696 struct ap_tapq_hwinfo hwinfo; 697 698 status = ap_test_queue(aq->qid, 1, &hwinfo); 699 if (status.response_code > AP_RESPONSE_BUSY) { 700 pr_debug("%s RC 0x%02x on tapq(0x%02x.%04x)\n", 701 __func__, status.response_code, 702 AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); 703 return -EIO; 704 } 705 706 return sysfs_emit(buf, "0x%08X\n", hwinfo.fac); 707 } 708 709 static DEVICE_ATTR_RO(ap_functions); 710 711 #ifdef CONFIG_AP_DEBUG 712 static ssize_t states_show(struct device *dev, 713 struct device_attribute *attr, char *buf) 714 { 715 struct ap_queue *aq = to_ap_queue(dev); 716 int rc = 0; 717 718 spin_lock_bh(&aq->lock); 719 /* queue device state */ 720 switch (aq->dev_state) { 721 case AP_DEV_STATE_UNINITIATED: 722 rc = sysfs_emit(buf, "UNINITIATED\n"); 723 break; 724 case AP_DEV_STATE_OPERATING: 725 rc = sysfs_emit(buf, "OPERATING"); 726 break; 727 case AP_DEV_STATE_SHUTDOWN: 728 rc = sysfs_emit(buf, "SHUTDOWN"); 729 break; 730 case AP_DEV_STATE_ERROR: 731 rc = sysfs_emit(buf, "ERROR"); 732 break; 733 default: 734 rc = sysfs_emit(buf, "UNKNOWN"); 735 } 736 /* state machine state */ 737 if (aq->dev_state) { 738 switch (aq->sm_state) { 739 case AP_SM_STATE_RESET_START: 740 rc += sysfs_emit_at(buf, rc, " [RESET_START]\n"); 741 break; 742 case AP_SM_STATE_RESET_WAIT: 743 rc += sysfs_emit_at(buf, rc, " [RESET_WAIT]\n"); 744 break; 745 case AP_SM_STATE_SETIRQ_WAIT: 746 rc += sysfs_emit_at(buf, rc, " [SETIRQ_WAIT]\n"); 747 break; 748 case AP_SM_STATE_IDLE: 749 rc += sysfs_emit_at(buf, rc, " [IDLE]\n"); 750 break; 751 case AP_SM_STATE_WORKING: 752 rc += sysfs_emit_at(buf, rc, " [WORKING]\n"); 753 break; 754 case AP_SM_STATE_QUEUE_FULL: 755 rc += sysfs_emit_at(buf, rc, " [FULL]\n"); 756 break; 757 case AP_SM_STATE_ASSOC_WAIT: 758 rc += sysfs_emit_at(buf, rc, " [ASSOC_WAIT]\n"); 759 break; 760 default: 761 rc += sysfs_emit_at(buf, rc, " [UNKNOWN]\n"); 762 } 763 } 764 spin_unlock_bh(&aq->lock); 765 766 return rc; 767 } 768 static DEVICE_ATTR_RO(states); 769 770 static ssize_t last_err_rc_show(struct device *dev, 771 struct device_attribute *attr, char *buf) 772 { 773 struct ap_queue *aq = to_ap_queue(dev); 774 int rc; 775 776 spin_lock_bh(&aq->lock); 777 rc = aq->last_err_rc; 778 spin_unlock_bh(&aq->lock); 779 780 switch (rc) { 781 case AP_RESPONSE_NORMAL: 782 return sysfs_emit(buf, "NORMAL\n"); 783 case AP_RESPONSE_Q_NOT_AVAIL: 784 return sysfs_emit(buf, "Q_NOT_AVAIL\n"); 785 case AP_RESPONSE_RESET_IN_PROGRESS: 786 return sysfs_emit(buf, "RESET_IN_PROGRESS\n"); 787 case AP_RESPONSE_DECONFIGURED: 788 return sysfs_emit(buf, "DECONFIGURED\n"); 789 case AP_RESPONSE_CHECKSTOPPED: 790 return sysfs_emit(buf, "CHECKSTOPPED\n"); 791 case AP_RESPONSE_BUSY: 792 return sysfs_emit(buf, "BUSY\n"); 793 case AP_RESPONSE_INVALID_ADDRESS: 794 return sysfs_emit(buf, "INVALID_ADDRESS\n"); 795 case AP_RESPONSE_OTHERWISE_CHANGED: 796 return sysfs_emit(buf, "OTHERWISE_CHANGED\n"); 797 case AP_RESPONSE_Q_FULL: 798 return sysfs_emit(buf, "Q_FULL/NO_PENDING_REPLY\n"); 799 case AP_RESPONSE_INDEX_TOO_BIG: 800 return sysfs_emit(buf, "INDEX_TOO_BIG\n"); 801 case AP_RESPONSE_NO_FIRST_PART: 802 return sysfs_emit(buf, "NO_FIRST_PART\n"); 803 case AP_RESPONSE_MESSAGE_TOO_BIG: 804 return sysfs_emit(buf, "MESSAGE_TOO_BIG\n"); 805 case AP_RESPONSE_REQ_FAC_NOT_INST: 806 return sysfs_emit(buf, "REQ_FAC_NOT_INST\n"); 807 default: 808 return sysfs_emit(buf, "response code %d\n", rc); 809 } 810 } 811 static DEVICE_ATTR_RO(last_err_rc); 812 #endif 813 814 static struct attribute *ap_queue_dev_attrs[] = { 815 &dev_attr_request_count.attr, 816 &dev_attr_requestq_count.attr, 817 &dev_attr_pendingq_count.attr, 818 &dev_attr_reset.attr, 819 &dev_attr_interrupt.attr, 820 &dev_attr_config.attr, 821 &dev_attr_chkstop.attr, 822 &dev_attr_ap_functions.attr, 823 #ifdef CONFIG_AP_DEBUG 824 &dev_attr_states.attr, 825 &dev_attr_last_err_rc.attr, 826 #endif 827 NULL 828 }; 829 830 static struct attribute_group ap_queue_dev_attr_group = { 831 .attrs = ap_queue_dev_attrs 832 }; 833 834 static const struct attribute_group *ap_queue_dev_attr_groups[] = { 835 &ap_queue_dev_attr_group, 836 NULL 837 }; 838 839 static struct device_type ap_queue_type = { 840 .name = "ap_queue", 841 .groups = ap_queue_dev_attr_groups, 842 }; 843 844 static ssize_t se_bind_show(struct device *dev, 845 struct device_attribute *attr, char *buf) 846 { 847 struct ap_queue *aq = to_ap_queue(dev); 848 struct ap_queue_status status; 849 struct ap_tapq_hwinfo hwinfo; 850 851 if (!ap_q_supports_bind(aq)) 852 return sysfs_emit(buf, "-\n"); 853 854 status = ap_test_queue(aq->qid, 1, &hwinfo); 855 if (status.response_code > AP_RESPONSE_BUSY) { 856 pr_debug("%s RC 0x%02x on tapq(0x%02x.%04x)\n", 857 __func__, status.response_code, 858 AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); 859 return -EIO; 860 } 861 862 /* update queue's SE bind state */ 863 spin_lock_bh(&aq->lock); 864 aq->se_bstate = hwinfo.bs; 865 spin_unlock_bh(&aq->lock); 866 867 switch (hwinfo.bs) { 868 case AP_BS_Q_USABLE: 869 case AP_BS_Q_USABLE_NO_SECURE_KEY: 870 return sysfs_emit(buf, "bound\n"); 871 default: 872 return sysfs_emit(buf, "unbound\n"); 873 } 874 } 875 876 static ssize_t se_bind_store(struct device *dev, 877 struct device_attribute *attr, 878 const char *buf, size_t count) 879 { 880 struct ap_queue *aq = to_ap_queue(dev); 881 struct ap_queue_status status; 882 struct ap_tapq_hwinfo hwinfo; 883 bool value; 884 int rc; 885 886 if (!ap_q_supports_bind(aq)) 887 return -EINVAL; 888 889 /* only 0 (unbind) and 1 (bind) allowed */ 890 rc = kstrtobool(buf, &value); 891 if (rc) 892 return rc; 893 894 if (!value) { 895 /* Unbind. Set F bit arg and trigger RAPQ */ 896 spin_lock_bh(&aq->lock); 897 __ap_flush_queue(aq); 898 aq->rapq_fbit = 1; 899 _ap_queue_init_state(aq); 900 rc = count; 901 goto out; 902 } 903 904 /* Bind. Check current SE bind state */ 905 status = ap_test_queue(aq->qid, 1, &hwinfo); 906 if (status.response_code) { 907 AP_DBF_WARN("%s RC 0x%02x on tapq(0x%02x.%04x)\n", 908 __func__, status.response_code, 909 AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); 910 return -EIO; 911 } 912 913 /* Update BS state */ 914 spin_lock_bh(&aq->lock); 915 aq->se_bstate = hwinfo.bs; 916 if (hwinfo.bs != AP_BS_Q_AVAIL_FOR_BINDING) { 917 AP_DBF_WARN("%s bind attempt with bs %d on queue 0x%02x.%04x\n", 918 __func__, hwinfo.bs, 919 AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); 920 rc = -EINVAL; 921 goto out; 922 } 923 924 /* Check SM state */ 925 if (aq->sm_state < AP_SM_STATE_IDLE) { 926 rc = -EBUSY; 927 goto out; 928 } 929 930 /* invoke BAPQ */ 931 status = ap_bapq(aq->qid); 932 if (status.response_code) { 933 AP_DBF_WARN("%s RC 0x%02x on bapq(0x%02x.%04x)\n", 934 __func__, status.response_code, 935 AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); 936 rc = -EIO; 937 goto out; 938 } 939 aq->assoc_idx = ASSOC_IDX_INVALID; 940 941 /* verify SE bind state */ 942 status = ap_test_queue(aq->qid, 1, &hwinfo); 943 if (status.response_code) { 944 AP_DBF_WARN("%s RC 0x%02x on tapq(0x%02x.%04x)\n", 945 __func__, status.response_code, 946 AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); 947 rc = -EIO; 948 goto out; 949 } 950 aq->se_bstate = hwinfo.bs; 951 if (!(hwinfo.bs == AP_BS_Q_USABLE || 952 hwinfo.bs == AP_BS_Q_USABLE_NO_SECURE_KEY)) { 953 AP_DBF_WARN("%s BAPQ success, but bs shows %d on queue 0x%02x.%04x\n", 954 __func__, hwinfo.bs, 955 AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); 956 rc = -EIO; 957 goto out; 958 } 959 960 /* SE bind was successful */ 961 AP_DBF_INFO("%s bapq(0x%02x.%04x) success\n", __func__, 962 AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); 963 rc = count; 964 965 out: 966 spin_unlock_bh(&aq->lock); 967 return rc; 968 } 969 970 static DEVICE_ATTR_RW(se_bind); 971 972 static ssize_t se_associate_show(struct device *dev, 973 struct device_attribute *attr, char *buf) 974 { 975 struct ap_queue *aq = to_ap_queue(dev); 976 struct ap_queue_status status; 977 struct ap_tapq_hwinfo hwinfo; 978 979 if (!ap_q_supports_assoc(aq)) 980 return sysfs_emit(buf, "-\n"); 981 982 status = ap_test_queue(aq->qid, 1, &hwinfo); 983 if (status.response_code > AP_RESPONSE_BUSY) { 984 pr_debug("%s RC 0x%02x on tapq(0x%02x.%04x)\n", 985 __func__, status.response_code, 986 AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); 987 return -EIO; 988 } 989 990 /* update queue's SE bind state */ 991 spin_lock_bh(&aq->lock); 992 aq->se_bstate = hwinfo.bs; 993 spin_unlock_bh(&aq->lock); 994 995 switch (hwinfo.bs) { 996 case AP_BS_Q_USABLE: 997 if (aq->assoc_idx == ASSOC_IDX_INVALID) { 998 AP_DBF_WARN("%s AP_BS_Q_USABLE but invalid assoc_idx\n", __func__); 999 return -EIO; 1000 } 1001 return sysfs_emit(buf, "associated %u\n", aq->assoc_idx); 1002 case AP_BS_Q_USABLE_NO_SECURE_KEY: 1003 if (aq->assoc_idx != ASSOC_IDX_INVALID) 1004 return sysfs_emit(buf, "association pending\n"); 1005 fallthrough; 1006 default: 1007 return sysfs_emit(buf, "unassociated\n"); 1008 } 1009 } 1010 1011 static ssize_t se_associate_store(struct device *dev, 1012 struct device_attribute *attr, 1013 const char *buf, size_t count) 1014 { 1015 struct ap_queue *aq = to_ap_queue(dev); 1016 struct ap_queue_status status; 1017 struct ap_tapq_hwinfo hwinfo; 1018 unsigned int value; 1019 int rc; 1020 1021 if (!ap_q_supports_assoc(aq)) 1022 return -EINVAL; 1023 1024 /* association index needs to be >= 0 */ 1025 rc = kstrtouint(buf, 0, &value); 1026 if (rc) 1027 return rc; 1028 if (value >= ASSOC_IDX_INVALID) 1029 return -EINVAL; 1030 1031 /* check current SE bind state */ 1032 status = ap_test_queue(aq->qid, 1, &hwinfo); 1033 if (status.response_code) { 1034 AP_DBF_WARN("%s RC 0x%02x on tapq(0x%02x.%04x)\n", 1035 __func__, status.response_code, 1036 AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); 1037 return -EIO; 1038 } 1039 spin_lock_bh(&aq->lock); 1040 aq->se_bstate = hwinfo.bs; 1041 if (hwinfo.bs != AP_BS_Q_USABLE_NO_SECURE_KEY) { 1042 AP_DBF_WARN("%s association attempt with bs %d on queue 0x%02x.%04x\n", 1043 __func__, hwinfo.bs, 1044 AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); 1045 rc = -EINVAL; 1046 goto out; 1047 } 1048 1049 /* check SM state */ 1050 if (aq->sm_state != AP_SM_STATE_IDLE) { 1051 rc = -EBUSY; 1052 goto out; 1053 } 1054 1055 /* trigger the asynchronous association request */ 1056 status = ap_aapq(aq->qid, value); 1057 switch (status.response_code) { 1058 case AP_RESPONSE_NORMAL: 1059 case AP_RESPONSE_STATE_CHANGE_IN_PROGRESS: 1060 aq->sm_state = AP_SM_STATE_ASSOC_WAIT; 1061 aq->assoc_idx = value; 1062 ap_wait(ap_sm_event(aq, AP_SM_EVENT_POLL)); 1063 break; 1064 default: 1065 AP_DBF_WARN("%s RC 0x%02x on aapq(0x%02x.%04x)\n", 1066 __func__, status.response_code, 1067 AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); 1068 rc = -EIO; 1069 goto out; 1070 } 1071 1072 rc = count; 1073 1074 out: 1075 spin_unlock_bh(&aq->lock); 1076 return rc; 1077 } 1078 1079 static DEVICE_ATTR_RW(se_associate); 1080 1081 static struct attribute *ap_queue_dev_sb_attrs[] = { 1082 &dev_attr_se_bind.attr, 1083 &dev_attr_se_associate.attr, 1084 NULL 1085 }; 1086 1087 static struct attribute_group ap_queue_dev_sb_attr_group = { 1088 .attrs = ap_queue_dev_sb_attrs 1089 }; 1090 1091 static const struct attribute_group *ap_queue_dev_sb_attr_groups[] = { 1092 &ap_queue_dev_sb_attr_group, 1093 NULL 1094 }; 1095 1096 static void ap_queue_device_release(struct device *dev) 1097 { 1098 struct ap_queue *aq = to_ap_queue(dev); 1099 1100 spin_lock_bh(&ap_queues_lock); 1101 hash_del(&aq->hnode); 1102 spin_unlock_bh(&ap_queues_lock); 1103 1104 kfree(aq); 1105 } 1106 1107 struct ap_queue *ap_queue_create(ap_qid_t qid, int device_type) 1108 { 1109 struct ap_queue *aq; 1110 1111 aq = kzalloc(sizeof(*aq), GFP_KERNEL); 1112 if (!aq) 1113 return NULL; 1114 aq->ap_dev.device.release = ap_queue_device_release; 1115 aq->ap_dev.device.type = &ap_queue_type; 1116 aq->ap_dev.device_type = device_type; 1117 // add optional SE secure binding attributes group 1118 if (ap_sb_available() && is_prot_virt_guest()) 1119 aq->ap_dev.device.groups = ap_queue_dev_sb_attr_groups; 1120 aq->qid = qid; 1121 spin_lock_init(&aq->lock); 1122 INIT_LIST_HEAD(&aq->pendingq); 1123 INIT_LIST_HEAD(&aq->requestq); 1124 timer_setup(&aq->timeout, ap_request_timeout, 0); 1125 1126 return aq; 1127 } 1128 1129 void ap_queue_init_reply(struct ap_queue *aq, struct ap_message *reply) 1130 { 1131 aq->reply = reply; 1132 1133 spin_lock_bh(&aq->lock); 1134 ap_wait(ap_sm_event(aq, AP_SM_EVENT_POLL)); 1135 spin_unlock_bh(&aq->lock); 1136 } 1137 EXPORT_SYMBOL(ap_queue_init_reply); 1138 1139 /** 1140 * ap_queue_message(): Queue a request to an AP device. 1141 * @aq: The AP device to queue the message to 1142 * @ap_msg: The message that is to be added 1143 */ 1144 int ap_queue_message(struct ap_queue *aq, struct ap_message *ap_msg) 1145 { 1146 int rc = 0; 1147 1148 /* msg needs to have a valid receive-callback */ 1149 BUG_ON(!ap_msg->receive); 1150 1151 spin_lock_bh(&aq->lock); 1152 1153 /* only allow to queue new messages if device state is ok */ 1154 if (aq->dev_state == AP_DEV_STATE_OPERATING) { 1155 list_add_tail(&ap_msg->list, &aq->requestq); 1156 aq->requestq_count++; 1157 aq->total_request_count++; 1158 atomic64_inc(&aq->card->total_request_count); 1159 } else { 1160 rc = -ENODEV; 1161 } 1162 1163 /* Send/receive as many request from the queue as possible. */ 1164 ap_wait(ap_sm_event_loop(aq, AP_SM_EVENT_POLL)); 1165 1166 spin_unlock_bh(&aq->lock); 1167 1168 return rc; 1169 } 1170 EXPORT_SYMBOL(ap_queue_message); 1171 1172 /** 1173 * ap_queue_usable(): Check if queue is usable just now. 1174 * @aq: The AP queue device to test for usability. 1175 * This function is intended for the scheduler to query if it makes 1176 * sense to enqueue a message into this AP queue device by calling 1177 * ap_queue_message(). The perspective is very short-term as the 1178 * state machine and device state(s) may change at any time. 1179 */ 1180 bool ap_queue_usable(struct ap_queue *aq) 1181 { 1182 bool rc = true; 1183 1184 spin_lock_bh(&aq->lock); 1185 1186 /* check for not configured or checkstopped */ 1187 if (!aq->config || aq->chkstop) { 1188 rc = false; 1189 goto unlock_and_out; 1190 } 1191 1192 /* device state needs to be ok */ 1193 if (aq->dev_state != AP_DEV_STATE_OPERATING) { 1194 rc = false; 1195 goto unlock_and_out; 1196 } 1197 1198 /* SE guest's queues additionally need to be bound */ 1199 if (ap_q_needs_bind(aq) && 1200 !(aq->se_bstate == AP_BS_Q_USABLE || 1201 aq->se_bstate == AP_BS_Q_USABLE_NO_SECURE_KEY)) 1202 rc = false; 1203 1204 unlock_and_out: 1205 spin_unlock_bh(&aq->lock); 1206 return rc; 1207 } 1208 EXPORT_SYMBOL(ap_queue_usable); 1209 1210 /** 1211 * ap_cancel_message(): Cancel a crypto request. 1212 * @aq: The AP device that has the message queued 1213 * @ap_msg: The message that is to be removed 1214 * 1215 * Cancel a crypto request. This is done by removing the request 1216 * from the device pending or request queue. Note that the 1217 * request stays on the AP queue. When it finishes the message 1218 * reply will be discarded because the psmid can't be found. 1219 */ 1220 void ap_cancel_message(struct ap_queue *aq, struct ap_message *ap_msg) 1221 { 1222 struct ap_message *tmp; 1223 1224 spin_lock_bh(&aq->lock); 1225 if (!list_empty(&ap_msg->list)) { 1226 list_for_each_entry(tmp, &aq->pendingq, list) 1227 if (tmp->psmid == ap_msg->psmid) { 1228 aq->pendingq_count--; 1229 goto found; 1230 } 1231 aq->requestq_count--; 1232 found: 1233 list_del_init(&ap_msg->list); 1234 } 1235 spin_unlock_bh(&aq->lock); 1236 } 1237 EXPORT_SYMBOL(ap_cancel_message); 1238 1239 /** 1240 * __ap_flush_queue(): Flush requests. 1241 * @aq: Pointer to the AP queue 1242 * 1243 * Flush all requests from the request/pending queue of an AP device. 1244 */ 1245 static void __ap_flush_queue(struct ap_queue *aq) 1246 { 1247 struct ap_message *ap_msg, *next; 1248 1249 list_for_each_entry_safe(ap_msg, next, &aq->pendingq, list) { 1250 list_del_init(&ap_msg->list); 1251 aq->pendingq_count--; 1252 ap_msg->rc = -EAGAIN; 1253 ap_msg->receive(aq, ap_msg, NULL); 1254 } 1255 list_for_each_entry_safe(ap_msg, next, &aq->requestq, list) { 1256 list_del_init(&ap_msg->list); 1257 aq->requestq_count--; 1258 ap_msg->rc = -EAGAIN; 1259 ap_msg->receive(aq, ap_msg, NULL); 1260 } 1261 aq->queue_count = 0; 1262 } 1263 1264 void ap_flush_queue(struct ap_queue *aq) 1265 { 1266 spin_lock_bh(&aq->lock); 1267 __ap_flush_queue(aq); 1268 spin_unlock_bh(&aq->lock); 1269 } 1270 EXPORT_SYMBOL(ap_flush_queue); 1271 1272 void ap_queue_prepare_remove(struct ap_queue *aq) 1273 { 1274 spin_lock_bh(&aq->lock); 1275 /* flush queue */ 1276 __ap_flush_queue(aq); 1277 /* move queue device state to SHUTDOWN in progress */ 1278 aq->dev_state = AP_DEV_STATE_SHUTDOWN; 1279 spin_unlock_bh(&aq->lock); 1280 del_timer_sync(&aq->timeout); 1281 } 1282 1283 void ap_queue_remove(struct ap_queue *aq) 1284 { 1285 /* 1286 * all messages have been flushed and the device state 1287 * is SHUTDOWN. Now reset with zero which also clears 1288 * the irq registration and move the device state 1289 * to the initial value AP_DEV_STATE_UNINITIATED. 1290 */ 1291 spin_lock_bh(&aq->lock); 1292 ap_zapq(aq->qid, 0); 1293 aq->dev_state = AP_DEV_STATE_UNINITIATED; 1294 spin_unlock_bh(&aq->lock); 1295 } 1296 1297 void _ap_queue_init_state(struct ap_queue *aq) 1298 { 1299 aq->dev_state = AP_DEV_STATE_OPERATING; 1300 aq->sm_state = AP_SM_STATE_RESET_START; 1301 aq->last_err_rc = 0; 1302 aq->assoc_idx = ASSOC_IDX_INVALID; 1303 ap_wait(ap_sm_event(aq, AP_SM_EVENT_POLL)); 1304 } 1305 1306 void ap_queue_init_state(struct ap_queue *aq) 1307 { 1308 spin_lock_bh(&aq->lock); 1309 _ap_queue_init_state(aq); 1310 spin_unlock_bh(&aq->lock); 1311 } 1312 EXPORT_SYMBOL(ap_queue_init_state); 1313