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