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_irq(): Enable interrupt support on this AP queue. 23 * @aq: The AP queue 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_irq(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 int special) 73 { 74 if (special) 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, NULL, NULL); 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_sm_wait ap_sm_nop(struct ap_queue *aq) 123 { 124 return AP_SM_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_SM_WAIT_NONE, AP_SM_WAIT_AGAIN, or AP_SM_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 bool found = false; 139 size_t reslen; 140 unsigned long resgr0 = 0; 141 int parts = 0; 142 143 /* 144 * DQAP loop until response code and resgr0 indicate that 145 * the msg is totally received. As we use the very same buffer 146 * the msg is overwritten with each invocation. That's intended 147 * and the receiver of the msg is informed with a msg rc code 148 * of EMSGSIZE in such a case. 149 */ 150 do { 151 status = ap_dqap(aq->qid, &aq->reply->psmid, 152 aq->reply->msg, aq->reply->bufsize, 153 &reslen, &resgr0); 154 parts++; 155 } while (status.response_code == 0xFF && resgr0 != 0); 156 157 switch (status.response_code) { 158 case AP_RESPONSE_NORMAL: 159 aq->queue_count = max_t(int, 0, aq->queue_count - 1); 160 if (!status.queue_empty && !aq->queue_count) 161 aq->queue_count++; 162 if (aq->queue_count > 0) 163 mod_timer(&aq->timeout, 164 jiffies + aq->request_timeout); 165 list_for_each_entry(ap_msg, &aq->pendingq, list) { 166 if (ap_msg->psmid != aq->reply->psmid) 167 continue; 168 list_del_init(&ap_msg->list); 169 aq->pendingq_count--; 170 if (parts > 1) { 171 ap_msg->rc = -EMSGSIZE; 172 ap_msg->receive(aq, ap_msg, NULL); 173 } else { 174 ap_msg->receive(aq, ap_msg, aq->reply); 175 } 176 found = true; 177 break; 178 } 179 if (!found) { 180 AP_DBF_WARN("%s unassociated reply psmid=0x%016llx on 0x%02x.%04x\n", 181 __func__, aq->reply->psmid, 182 AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); 183 } 184 fallthrough; 185 case AP_RESPONSE_NO_PENDING_REPLY: 186 if (!status.queue_empty || aq->queue_count <= 0) 187 break; 188 /* The card shouldn't forget requests but who knows. */ 189 aq->queue_count = 0; 190 list_splice_init(&aq->pendingq, &aq->requestq); 191 aq->requestq_count += aq->pendingq_count; 192 aq->pendingq_count = 0; 193 break; 194 default: 195 break; 196 } 197 return status; 198 } 199 200 /** 201 * ap_sm_read(): Receive pending reply messages from an AP queue. 202 * @aq: pointer to the AP queue 203 * 204 * Returns AP_SM_WAIT_NONE, AP_SM_WAIT_AGAIN, or AP_SM_WAIT_INTERRUPT 205 */ 206 static enum ap_sm_wait ap_sm_read(struct ap_queue *aq) 207 { 208 struct ap_queue_status status; 209 210 if (!aq->reply) 211 return AP_SM_WAIT_NONE; 212 status = ap_sm_recv(aq); 213 switch (status.response_code) { 214 case AP_RESPONSE_NORMAL: 215 if (aq->queue_count > 0) { 216 aq->sm_state = AP_SM_STATE_WORKING; 217 return AP_SM_WAIT_AGAIN; 218 } 219 aq->sm_state = AP_SM_STATE_IDLE; 220 return AP_SM_WAIT_NONE; 221 case AP_RESPONSE_NO_PENDING_REPLY: 222 if (aq->queue_count > 0) 223 return aq->interrupt ? 224 AP_SM_WAIT_INTERRUPT : AP_SM_WAIT_TIMEOUT; 225 aq->sm_state = AP_SM_STATE_IDLE; 226 return AP_SM_WAIT_NONE; 227 default: 228 aq->dev_state = AP_DEV_STATE_ERROR; 229 aq->last_err_rc = status.response_code; 230 AP_DBF_WARN("%s RC 0x%02x on 0x%02x.%04x -> AP_DEV_STATE_ERROR\n", 231 __func__, status.response_code, 232 AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); 233 return AP_SM_WAIT_NONE; 234 } 235 } 236 237 /** 238 * ap_sm_write(): Send messages from the request queue to an AP queue. 239 * @aq: pointer to the AP queue 240 * 241 * Returns AP_SM_WAIT_NONE, AP_SM_WAIT_AGAIN, or AP_SM_WAIT_INTERRUPT 242 */ 243 static enum ap_sm_wait ap_sm_write(struct ap_queue *aq) 244 { 245 struct ap_queue_status status; 246 struct ap_message *ap_msg; 247 ap_qid_t qid = aq->qid; 248 249 if (aq->requestq_count <= 0) 250 return AP_SM_WAIT_NONE; 251 252 /* Start the next request on the queue. */ 253 ap_msg = list_entry(aq->requestq.next, struct ap_message, list); 254 #ifdef CONFIG_ZCRYPT_DEBUG 255 if (ap_msg->fi.action == AP_FI_ACTION_NQAP_QID_INVAL) { 256 AP_DBF_WARN("%s fi cmd 0x%04x: forcing invalid qid 0xFF00\n", 257 __func__, ap_msg->fi.cmd); 258 qid = 0xFF00; 259 } 260 #endif 261 status = __ap_send(qid, ap_msg->psmid, 262 ap_msg->msg, ap_msg->len, 263 ap_msg->flags & AP_MSG_FLAG_SPECIAL); 264 switch (status.response_code) { 265 case AP_RESPONSE_NORMAL: 266 aq->queue_count = max_t(int, 1, aq->queue_count + 1); 267 if (aq->queue_count == 1) 268 mod_timer(&aq->timeout, jiffies + aq->request_timeout); 269 list_move_tail(&ap_msg->list, &aq->pendingq); 270 aq->requestq_count--; 271 aq->pendingq_count++; 272 if (aq->queue_count < aq->card->queue_depth) { 273 aq->sm_state = AP_SM_STATE_WORKING; 274 return AP_SM_WAIT_AGAIN; 275 } 276 fallthrough; 277 case AP_RESPONSE_Q_FULL: 278 aq->sm_state = AP_SM_STATE_QUEUE_FULL; 279 return aq->interrupt ? 280 AP_SM_WAIT_INTERRUPT : AP_SM_WAIT_TIMEOUT; 281 case AP_RESPONSE_RESET_IN_PROGRESS: 282 aq->sm_state = AP_SM_STATE_RESET_WAIT; 283 return AP_SM_WAIT_TIMEOUT; 284 case AP_RESPONSE_INVALID_DOMAIN: 285 AP_DBF_WARN("%s RESPONSE_INVALID_DOMAIN on NQAP\n", __func__); 286 fallthrough; 287 case AP_RESPONSE_MESSAGE_TOO_BIG: 288 case AP_RESPONSE_REQ_FAC_NOT_INST: 289 list_del_init(&ap_msg->list); 290 aq->requestq_count--; 291 ap_msg->rc = -EINVAL; 292 ap_msg->receive(aq, ap_msg, NULL); 293 return AP_SM_WAIT_AGAIN; 294 default: 295 aq->dev_state = AP_DEV_STATE_ERROR; 296 aq->last_err_rc = status.response_code; 297 AP_DBF_WARN("%s RC 0x%02x on 0x%02x.%04x -> AP_DEV_STATE_ERROR\n", 298 __func__, status.response_code, 299 AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); 300 return AP_SM_WAIT_NONE; 301 } 302 } 303 304 /** 305 * ap_sm_read_write(): Send and receive messages to/from an AP queue. 306 * @aq: pointer to the AP queue 307 * 308 * Returns AP_SM_WAIT_NONE, AP_SM_WAIT_AGAIN, or AP_SM_WAIT_INTERRUPT 309 */ 310 static enum ap_sm_wait ap_sm_read_write(struct ap_queue *aq) 311 { 312 return min(ap_sm_read(aq), ap_sm_write(aq)); 313 } 314 315 /** 316 * ap_sm_reset(): Reset an AP queue. 317 * @aq: The AP queue 318 * 319 * Submit the Reset command to an AP queue. 320 */ 321 static enum ap_sm_wait ap_sm_reset(struct ap_queue *aq) 322 { 323 struct ap_queue_status status; 324 325 status = ap_rapq(aq->qid); 326 switch (status.response_code) { 327 case AP_RESPONSE_NORMAL: 328 case AP_RESPONSE_RESET_IN_PROGRESS: 329 aq->sm_state = AP_SM_STATE_RESET_WAIT; 330 aq->interrupt = false; 331 return AP_SM_WAIT_TIMEOUT; 332 default: 333 aq->dev_state = AP_DEV_STATE_ERROR; 334 aq->last_err_rc = status.response_code; 335 AP_DBF_WARN("%s RC 0x%02x on 0x%02x.%04x -> AP_DEV_STATE_ERROR\n", 336 __func__, status.response_code, 337 AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); 338 return AP_SM_WAIT_NONE; 339 } 340 } 341 342 /** 343 * ap_sm_reset_wait(): Test queue for completion of the reset operation 344 * @aq: pointer to the AP queue 345 * 346 * Returns AP_POLL_IMMEDIATELY, AP_POLL_AFTER_TIMEROUT or 0. 347 */ 348 static enum ap_sm_wait ap_sm_reset_wait(struct ap_queue *aq) 349 { 350 struct ap_queue_status status; 351 void *lsi_ptr; 352 353 if (aq->queue_count > 0 && aq->reply) 354 /* Try to read a completed message and get the status */ 355 status = ap_sm_recv(aq); 356 else 357 /* Get the status with TAPQ */ 358 status = ap_tapq(aq->qid, NULL); 359 360 switch (status.response_code) { 361 case AP_RESPONSE_NORMAL: 362 lsi_ptr = ap_airq_ptr(); 363 if (lsi_ptr && ap_queue_enable_irq(aq, lsi_ptr) == 0) 364 aq->sm_state = AP_SM_STATE_SETIRQ_WAIT; 365 else 366 aq->sm_state = (aq->queue_count > 0) ? 367 AP_SM_STATE_WORKING : AP_SM_STATE_IDLE; 368 return AP_SM_WAIT_AGAIN; 369 case AP_RESPONSE_BUSY: 370 case AP_RESPONSE_RESET_IN_PROGRESS: 371 return AP_SM_WAIT_TIMEOUT; 372 case AP_RESPONSE_Q_NOT_AVAIL: 373 case AP_RESPONSE_DECONFIGURED: 374 case AP_RESPONSE_CHECKSTOPPED: 375 default: 376 aq->dev_state = AP_DEV_STATE_ERROR; 377 aq->last_err_rc = status.response_code; 378 AP_DBF_WARN("%s RC 0x%02x on 0x%02x.%04x -> AP_DEV_STATE_ERROR\n", 379 __func__, status.response_code, 380 AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); 381 return AP_SM_WAIT_NONE; 382 } 383 } 384 385 /** 386 * ap_sm_setirq_wait(): Test queue for completion of the irq enablement 387 * @aq: pointer to the AP queue 388 * 389 * Returns AP_POLL_IMMEDIATELY, AP_POLL_AFTER_TIMEROUT or 0. 390 */ 391 static enum ap_sm_wait ap_sm_setirq_wait(struct ap_queue *aq) 392 { 393 struct ap_queue_status status; 394 395 if (aq->queue_count > 0 && aq->reply) 396 /* Try to read a completed message and get the status */ 397 status = ap_sm_recv(aq); 398 else 399 /* Get the status with TAPQ */ 400 status = ap_tapq(aq->qid, NULL); 401 402 if (status.irq_enabled == 1) { 403 /* Irqs are now enabled */ 404 aq->interrupt = true; 405 aq->sm_state = (aq->queue_count > 0) ? 406 AP_SM_STATE_WORKING : AP_SM_STATE_IDLE; 407 } 408 409 switch (status.response_code) { 410 case AP_RESPONSE_NORMAL: 411 if (aq->queue_count > 0) 412 return AP_SM_WAIT_AGAIN; 413 fallthrough; 414 case AP_RESPONSE_NO_PENDING_REPLY: 415 return AP_SM_WAIT_TIMEOUT; 416 default: 417 aq->dev_state = AP_DEV_STATE_ERROR; 418 aq->last_err_rc = status.response_code; 419 AP_DBF_WARN("%s RC 0x%02x on 0x%02x.%04x -> AP_DEV_STATE_ERROR\n", 420 __func__, status.response_code, 421 AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); 422 return AP_SM_WAIT_NONE; 423 } 424 } 425 426 /* 427 * AP state machine jump table 428 */ 429 static ap_func_t *ap_jumptable[NR_AP_SM_STATES][NR_AP_SM_EVENTS] = { 430 [AP_SM_STATE_RESET_START] = { 431 [AP_SM_EVENT_POLL] = ap_sm_reset, 432 [AP_SM_EVENT_TIMEOUT] = ap_sm_nop, 433 }, 434 [AP_SM_STATE_RESET_WAIT] = { 435 [AP_SM_EVENT_POLL] = ap_sm_reset_wait, 436 [AP_SM_EVENT_TIMEOUT] = ap_sm_nop, 437 }, 438 [AP_SM_STATE_SETIRQ_WAIT] = { 439 [AP_SM_EVENT_POLL] = ap_sm_setirq_wait, 440 [AP_SM_EVENT_TIMEOUT] = ap_sm_nop, 441 }, 442 [AP_SM_STATE_IDLE] = { 443 [AP_SM_EVENT_POLL] = ap_sm_write, 444 [AP_SM_EVENT_TIMEOUT] = ap_sm_nop, 445 }, 446 [AP_SM_STATE_WORKING] = { 447 [AP_SM_EVENT_POLL] = ap_sm_read_write, 448 [AP_SM_EVENT_TIMEOUT] = ap_sm_reset, 449 }, 450 [AP_SM_STATE_QUEUE_FULL] = { 451 [AP_SM_EVENT_POLL] = ap_sm_read, 452 [AP_SM_EVENT_TIMEOUT] = ap_sm_reset, 453 }, 454 }; 455 456 enum ap_sm_wait ap_sm_event(struct ap_queue *aq, enum ap_sm_event event) 457 { 458 if (aq->config && !aq->chkstop && 459 aq->dev_state > AP_DEV_STATE_UNINITIATED) 460 return ap_jumptable[aq->sm_state][event](aq); 461 else 462 return AP_SM_WAIT_NONE; 463 } 464 465 enum ap_sm_wait ap_sm_event_loop(struct ap_queue *aq, enum ap_sm_event event) 466 { 467 enum ap_sm_wait wait; 468 469 while ((wait = ap_sm_event(aq, event)) == AP_SM_WAIT_AGAIN) 470 ; 471 return wait; 472 } 473 474 /* 475 * AP queue related attributes. 476 */ 477 static ssize_t request_count_show(struct device *dev, 478 struct device_attribute *attr, 479 char *buf) 480 { 481 struct ap_queue *aq = to_ap_queue(dev); 482 bool valid = false; 483 u64 req_cnt; 484 485 spin_lock_bh(&aq->lock); 486 if (aq->dev_state > AP_DEV_STATE_UNINITIATED) { 487 req_cnt = aq->total_request_count; 488 valid = true; 489 } 490 spin_unlock_bh(&aq->lock); 491 492 if (valid) 493 return scnprintf(buf, PAGE_SIZE, "%llu\n", req_cnt); 494 else 495 return scnprintf(buf, PAGE_SIZE, "-\n"); 496 } 497 498 static ssize_t request_count_store(struct device *dev, 499 struct device_attribute *attr, 500 const char *buf, size_t count) 501 { 502 struct ap_queue *aq = to_ap_queue(dev); 503 504 spin_lock_bh(&aq->lock); 505 aq->total_request_count = 0; 506 spin_unlock_bh(&aq->lock); 507 508 return count; 509 } 510 511 static DEVICE_ATTR_RW(request_count); 512 513 static ssize_t requestq_count_show(struct device *dev, 514 struct device_attribute *attr, char *buf) 515 { 516 struct ap_queue *aq = to_ap_queue(dev); 517 unsigned int reqq_cnt = 0; 518 519 spin_lock_bh(&aq->lock); 520 if (aq->dev_state > AP_DEV_STATE_UNINITIATED) 521 reqq_cnt = aq->requestq_count; 522 spin_unlock_bh(&aq->lock); 523 return scnprintf(buf, PAGE_SIZE, "%d\n", reqq_cnt); 524 } 525 526 static DEVICE_ATTR_RO(requestq_count); 527 528 static ssize_t pendingq_count_show(struct device *dev, 529 struct device_attribute *attr, char *buf) 530 { 531 struct ap_queue *aq = to_ap_queue(dev); 532 unsigned int penq_cnt = 0; 533 534 spin_lock_bh(&aq->lock); 535 if (aq->dev_state > AP_DEV_STATE_UNINITIATED) 536 penq_cnt = aq->pendingq_count; 537 spin_unlock_bh(&aq->lock); 538 return scnprintf(buf, PAGE_SIZE, "%d\n", penq_cnt); 539 } 540 541 static DEVICE_ATTR_RO(pendingq_count); 542 543 static ssize_t reset_show(struct device *dev, 544 struct device_attribute *attr, char *buf) 545 { 546 struct ap_queue *aq = to_ap_queue(dev); 547 int rc = 0; 548 549 spin_lock_bh(&aq->lock); 550 switch (aq->sm_state) { 551 case AP_SM_STATE_RESET_START: 552 case AP_SM_STATE_RESET_WAIT: 553 rc = scnprintf(buf, PAGE_SIZE, "Reset in progress.\n"); 554 break; 555 case AP_SM_STATE_WORKING: 556 case AP_SM_STATE_QUEUE_FULL: 557 rc = scnprintf(buf, PAGE_SIZE, "Reset Timer armed.\n"); 558 break; 559 default: 560 rc = scnprintf(buf, PAGE_SIZE, "No Reset Timer set.\n"); 561 } 562 spin_unlock_bh(&aq->lock); 563 return rc; 564 } 565 566 static ssize_t reset_store(struct device *dev, 567 struct device_attribute *attr, 568 const char *buf, size_t count) 569 { 570 struct ap_queue *aq = to_ap_queue(dev); 571 572 spin_lock_bh(&aq->lock); 573 __ap_flush_queue(aq); 574 aq->sm_state = AP_SM_STATE_RESET_START; 575 ap_wait(ap_sm_event(aq, AP_SM_EVENT_POLL)); 576 spin_unlock_bh(&aq->lock); 577 578 AP_DBF_INFO("%s reset queue=%02x.%04x triggered by user\n", 579 __func__, AP_QID_CARD(aq->qid), AP_QID_QUEUE(aq->qid)); 580 581 return count; 582 } 583 584 static DEVICE_ATTR_RW(reset); 585 586 static ssize_t interrupt_show(struct device *dev, 587 struct device_attribute *attr, char *buf) 588 { 589 struct ap_queue *aq = to_ap_queue(dev); 590 int rc = 0; 591 592 spin_lock_bh(&aq->lock); 593 if (aq->sm_state == AP_SM_STATE_SETIRQ_WAIT) 594 rc = scnprintf(buf, PAGE_SIZE, "Enable Interrupt pending.\n"); 595 else if (aq->interrupt) 596 rc = scnprintf(buf, PAGE_SIZE, "Interrupts enabled.\n"); 597 else 598 rc = scnprintf(buf, PAGE_SIZE, "Interrupts disabled.\n"); 599 spin_unlock_bh(&aq->lock); 600 return rc; 601 } 602 603 static DEVICE_ATTR_RO(interrupt); 604 605 static ssize_t config_show(struct device *dev, 606 struct device_attribute *attr, char *buf) 607 { 608 struct ap_queue *aq = to_ap_queue(dev); 609 int rc; 610 611 spin_lock_bh(&aq->lock); 612 rc = scnprintf(buf, PAGE_SIZE, "%d\n", aq->config ? 1 : 0); 613 spin_unlock_bh(&aq->lock); 614 return rc; 615 } 616 617 static DEVICE_ATTR_RO(config); 618 619 static ssize_t chkstop_show(struct device *dev, 620 struct device_attribute *attr, char *buf) 621 { 622 struct ap_queue *aq = to_ap_queue(dev); 623 int rc; 624 625 spin_lock_bh(&aq->lock); 626 rc = scnprintf(buf, PAGE_SIZE, "%d\n", aq->chkstop ? 1 : 0); 627 spin_unlock_bh(&aq->lock); 628 return rc; 629 } 630 631 static DEVICE_ATTR_RO(chkstop); 632 633 #ifdef CONFIG_ZCRYPT_DEBUG 634 static ssize_t states_show(struct device *dev, 635 struct device_attribute *attr, char *buf) 636 { 637 struct ap_queue *aq = to_ap_queue(dev); 638 int rc = 0; 639 640 spin_lock_bh(&aq->lock); 641 /* queue device state */ 642 switch (aq->dev_state) { 643 case AP_DEV_STATE_UNINITIATED: 644 rc = scnprintf(buf, PAGE_SIZE, "UNINITIATED\n"); 645 break; 646 case AP_DEV_STATE_OPERATING: 647 rc = scnprintf(buf, PAGE_SIZE, "OPERATING"); 648 break; 649 case AP_DEV_STATE_SHUTDOWN: 650 rc = scnprintf(buf, PAGE_SIZE, "SHUTDOWN"); 651 break; 652 case AP_DEV_STATE_ERROR: 653 rc = scnprintf(buf, PAGE_SIZE, "ERROR"); 654 break; 655 default: 656 rc = scnprintf(buf, PAGE_SIZE, "UNKNOWN"); 657 } 658 /* state machine state */ 659 if (aq->dev_state) { 660 switch (aq->sm_state) { 661 case AP_SM_STATE_RESET_START: 662 rc += scnprintf(buf + rc, PAGE_SIZE - rc, 663 " [RESET_START]\n"); 664 break; 665 case AP_SM_STATE_RESET_WAIT: 666 rc += scnprintf(buf + rc, PAGE_SIZE - rc, 667 " [RESET_WAIT]\n"); 668 break; 669 case AP_SM_STATE_SETIRQ_WAIT: 670 rc += scnprintf(buf + rc, PAGE_SIZE - rc, 671 " [SETIRQ_WAIT]\n"); 672 break; 673 case AP_SM_STATE_IDLE: 674 rc += scnprintf(buf + rc, PAGE_SIZE - rc, 675 " [IDLE]\n"); 676 break; 677 case AP_SM_STATE_WORKING: 678 rc += scnprintf(buf + rc, PAGE_SIZE - rc, 679 " [WORKING]\n"); 680 break; 681 case AP_SM_STATE_QUEUE_FULL: 682 rc += scnprintf(buf + rc, PAGE_SIZE - rc, 683 " [FULL]\n"); 684 break; 685 default: 686 rc += scnprintf(buf + rc, PAGE_SIZE - rc, 687 " [UNKNOWN]\n"); 688 } 689 } 690 spin_unlock_bh(&aq->lock); 691 692 return rc; 693 } 694 static DEVICE_ATTR_RO(states); 695 696 static ssize_t last_err_rc_show(struct device *dev, 697 struct device_attribute *attr, char *buf) 698 { 699 struct ap_queue *aq = to_ap_queue(dev); 700 int rc; 701 702 spin_lock_bh(&aq->lock); 703 rc = aq->last_err_rc; 704 spin_unlock_bh(&aq->lock); 705 706 switch (rc) { 707 case AP_RESPONSE_NORMAL: 708 return scnprintf(buf, PAGE_SIZE, "NORMAL\n"); 709 case AP_RESPONSE_Q_NOT_AVAIL: 710 return scnprintf(buf, PAGE_SIZE, "Q_NOT_AVAIL\n"); 711 case AP_RESPONSE_RESET_IN_PROGRESS: 712 return scnprintf(buf, PAGE_SIZE, "RESET_IN_PROGRESS\n"); 713 case AP_RESPONSE_DECONFIGURED: 714 return scnprintf(buf, PAGE_SIZE, "DECONFIGURED\n"); 715 case AP_RESPONSE_CHECKSTOPPED: 716 return scnprintf(buf, PAGE_SIZE, "CHECKSTOPPED\n"); 717 case AP_RESPONSE_BUSY: 718 return scnprintf(buf, PAGE_SIZE, "BUSY\n"); 719 case AP_RESPONSE_INVALID_ADDRESS: 720 return scnprintf(buf, PAGE_SIZE, "INVALID_ADDRESS\n"); 721 case AP_RESPONSE_OTHERWISE_CHANGED: 722 return scnprintf(buf, PAGE_SIZE, "OTHERWISE_CHANGED\n"); 723 case AP_RESPONSE_Q_FULL: 724 return scnprintf(buf, PAGE_SIZE, "Q_FULL/NO_PENDING_REPLY\n"); 725 case AP_RESPONSE_INDEX_TOO_BIG: 726 return scnprintf(buf, PAGE_SIZE, "INDEX_TOO_BIG\n"); 727 case AP_RESPONSE_NO_FIRST_PART: 728 return scnprintf(buf, PAGE_SIZE, "NO_FIRST_PART\n"); 729 case AP_RESPONSE_MESSAGE_TOO_BIG: 730 return scnprintf(buf, PAGE_SIZE, "MESSAGE_TOO_BIG\n"); 731 case AP_RESPONSE_REQ_FAC_NOT_INST: 732 return scnprintf(buf, PAGE_SIZE, "REQ_FAC_NOT_INST\n"); 733 default: 734 return scnprintf(buf, PAGE_SIZE, "response code %d\n", rc); 735 } 736 } 737 static DEVICE_ATTR_RO(last_err_rc); 738 #endif 739 740 static struct attribute *ap_queue_dev_attrs[] = { 741 &dev_attr_request_count.attr, 742 &dev_attr_requestq_count.attr, 743 &dev_attr_pendingq_count.attr, 744 &dev_attr_reset.attr, 745 &dev_attr_interrupt.attr, 746 &dev_attr_config.attr, 747 &dev_attr_chkstop.attr, 748 #ifdef CONFIG_ZCRYPT_DEBUG 749 &dev_attr_states.attr, 750 &dev_attr_last_err_rc.attr, 751 #endif 752 NULL 753 }; 754 755 static struct attribute_group ap_queue_dev_attr_group = { 756 .attrs = ap_queue_dev_attrs 757 }; 758 759 static const struct attribute_group *ap_queue_dev_attr_groups[] = { 760 &ap_queue_dev_attr_group, 761 NULL 762 }; 763 764 static struct device_type ap_queue_type = { 765 .name = "ap_queue", 766 .groups = ap_queue_dev_attr_groups, 767 }; 768 769 static void ap_queue_device_release(struct device *dev) 770 { 771 struct ap_queue *aq = to_ap_queue(dev); 772 773 spin_lock_bh(&ap_queues_lock); 774 hash_del(&aq->hnode); 775 spin_unlock_bh(&ap_queues_lock); 776 777 kfree(aq); 778 } 779 780 struct ap_queue *ap_queue_create(ap_qid_t qid, int device_type) 781 { 782 struct ap_queue *aq; 783 784 aq = kzalloc(sizeof(*aq), GFP_KERNEL); 785 if (!aq) 786 return NULL; 787 aq->ap_dev.device.release = ap_queue_device_release; 788 aq->ap_dev.device.type = &ap_queue_type; 789 aq->ap_dev.device_type = device_type; 790 aq->qid = qid; 791 aq->interrupt = false; 792 spin_lock_init(&aq->lock); 793 INIT_LIST_HEAD(&aq->pendingq); 794 INIT_LIST_HEAD(&aq->requestq); 795 timer_setup(&aq->timeout, ap_request_timeout, 0); 796 797 return aq; 798 } 799 800 void ap_queue_init_reply(struct ap_queue *aq, struct ap_message *reply) 801 { 802 aq->reply = reply; 803 804 spin_lock_bh(&aq->lock); 805 ap_wait(ap_sm_event(aq, AP_SM_EVENT_POLL)); 806 spin_unlock_bh(&aq->lock); 807 } 808 EXPORT_SYMBOL(ap_queue_init_reply); 809 810 /** 811 * ap_queue_message(): Queue a request to an AP device. 812 * @aq: The AP device to queue the message to 813 * @ap_msg: The message that is to be added 814 */ 815 int ap_queue_message(struct ap_queue *aq, struct ap_message *ap_msg) 816 { 817 int rc = 0; 818 819 /* msg needs to have a valid receive-callback */ 820 BUG_ON(!ap_msg->receive); 821 822 spin_lock_bh(&aq->lock); 823 824 /* only allow to queue new messages if device state is ok */ 825 if (aq->dev_state == AP_DEV_STATE_OPERATING) { 826 list_add_tail(&ap_msg->list, &aq->requestq); 827 aq->requestq_count++; 828 aq->total_request_count++; 829 atomic64_inc(&aq->card->total_request_count); 830 } else 831 rc = -ENODEV; 832 833 /* Send/receive as many request from the queue as possible. */ 834 ap_wait(ap_sm_event_loop(aq, AP_SM_EVENT_POLL)); 835 836 spin_unlock_bh(&aq->lock); 837 838 return rc; 839 } 840 EXPORT_SYMBOL(ap_queue_message); 841 842 /** 843 * ap_cancel_message(): Cancel a crypto request. 844 * @aq: The AP device that has the message queued 845 * @ap_msg: The message that is to be removed 846 * 847 * Cancel a crypto request. This is done by removing the request 848 * from the device pending or request queue. Note that the 849 * request stays on the AP queue. When it finishes the message 850 * reply will be discarded because the psmid can't be found. 851 */ 852 void ap_cancel_message(struct ap_queue *aq, struct ap_message *ap_msg) 853 { 854 struct ap_message *tmp; 855 856 spin_lock_bh(&aq->lock); 857 if (!list_empty(&ap_msg->list)) { 858 list_for_each_entry(tmp, &aq->pendingq, list) 859 if (tmp->psmid == ap_msg->psmid) { 860 aq->pendingq_count--; 861 goto found; 862 } 863 aq->requestq_count--; 864 found: 865 list_del_init(&ap_msg->list); 866 } 867 spin_unlock_bh(&aq->lock); 868 } 869 EXPORT_SYMBOL(ap_cancel_message); 870 871 /** 872 * __ap_flush_queue(): Flush requests. 873 * @aq: Pointer to the AP queue 874 * 875 * Flush all requests from the request/pending queue of an AP device. 876 */ 877 static void __ap_flush_queue(struct ap_queue *aq) 878 { 879 struct ap_message *ap_msg, *next; 880 881 list_for_each_entry_safe(ap_msg, next, &aq->pendingq, list) { 882 list_del_init(&ap_msg->list); 883 aq->pendingq_count--; 884 ap_msg->rc = -EAGAIN; 885 ap_msg->receive(aq, ap_msg, NULL); 886 } 887 list_for_each_entry_safe(ap_msg, next, &aq->requestq, list) { 888 list_del_init(&ap_msg->list); 889 aq->requestq_count--; 890 ap_msg->rc = -EAGAIN; 891 ap_msg->receive(aq, ap_msg, NULL); 892 } 893 aq->queue_count = 0; 894 } 895 896 void ap_flush_queue(struct ap_queue *aq) 897 { 898 spin_lock_bh(&aq->lock); 899 __ap_flush_queue(aq); 900 spin_unlock_bh(&aq->lock); 901 } 902 EXPORT_SYMBOL(ap_flush_queue); 903 904 void ap_queue_prepare_remove(struct ap_queue *aq) 905 { 906 spin_lock_bh(&aq->lock); 907 /* flush queue */ 908 __ap_flush_queue(aq); 909 /* move queue device state to SHUTDOWN in progress */ 910 aq->dev_state = AP_DEV_STATE_SHUTDOWN; 911 spin_unlock_bh(&aq->lock); 912 del_timer_sync(&aq->timeout); 913 } 914 915 void ap_queue_remove(struct ap_queue *aq) 916 { 917 /* 918 * all messages have been flushed and the device state 919 * is SHUTDOWN. Now reset with zero which also clears 920 * the irq registration and move the device state 921 * to the initial value AP_DEV_STATE_UNINITIATED. 922 */ 923 spin_lock_bh(&aq->lock); 924 ap_zapq(aq->qid); 925 aq->dev_state = AP_DEV_STATE_UNINITIATED; 926 spin_unlock_bh(&aq->lock); 927 } 928 929 void ap_queue_init_state(struct ap_queue *aq) 930 { 931 spin_lock_bh(&aq->lock); 932 aq->dev_state = AP_DEV_STATE_OPERATING; 933 aq->sm_state = AP_SM_STATE_RESET_START; 934 aq->last_err_rc = 0; 935 ap_wait(ap_sm_event(aq, AP_SM_EVENT_POLL)); 936 spin_unlock_bh(&aq->lock); 937 } 938 EXPORT_SYMBOL(ap_queue_init_state); 939