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