1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright IBM Corp. 2006, 2023 4 * Author(s): Cornelia Huck <cornelia.huck@de.ibm.com> 5 * Martin Schwidefsky <schwidefsky@de.ibm.com> 6 * Ralph Wuerthner <rwuerthn@de.ibm.com> 7 * Felix Beck <felix.beck@de.ibm.com> 8 * Holger Dengler <hd@linux.vnet.ibm.com> 9 * Harald Freudenberger <freude@linux.ibm.com> 10 * 11 * Adjunct processor bus. 12 */ 13 14 #define KMSG_COMPONENT "ap" 15 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 16 17 #include <linux/kernel_stat.h> 18 #include <linux/moduleparam.h> 19 #include <linux/init.h> 20 #include <linux/delay.h> 21 #include <linux/err.h> 22 #include <linux/freezer.h> 23 #include <linux/interrupt.h> 24 #include <linux/workqueue.h> 25 #include <linux/slab.h> 26 #include <linux/notifier.h> 27 #include <linux/kthread.h> 28 #include <linux/mutex.h> 29 #include <asm/machine.h> 30 #include <asm/airq.h> 31 #include <asm/tpi.h> 32 #include <linux/atomic.h> 33 #include <asm/isc.h> 34 #include <linux/hrtimer.h> 35 #include <linux/ktime.h> 36 #include <asm/facility.h> 37 #include <linux/crypto.h> 38 #include <linux/mod_devicetable.h> 39 #include <linux/debugfs.h> 40 #include <linux/ctype.h> 41 #include <linux/module.h> 42 #include <asm/uv.h> 43 #include <asm/chsc.h> 44 #include <linux/mempool.h> 45 46 #include "ap_bus.h" 47 #include "ap_debug.h" 48 49 MODULE_AUTHOR("IBM Corporation"); 50 MODULE_DESCRIPTION("Adjunct Processor Bus driver"); 51 MODULE_LICENSE("GPL"); 52 53 int ap_domain_index = -1; /* Adjunct Processor Domain Index */ 54 static DEFINE_SPINLOCK(ap_domain_lock); 55 module_param_named(domain, ap_domain_index, int, 0440); 56 MODULE_PARM_DESC(domain, "domain index for ap devices"); 57 EXPORT_SYMBOL(ap_domain_index); 58 59 static int ap_thread_flag; 60 module_param_named(poll_thread, ap_thread_flag, int, 0440); 61 MODULE_PARM_DESC(poll_thread, "Turn on/off poll thread, default is 0 (off)."); 62 63 static char *apm_str; 64 module_param_named(apmask, apm_str, charp, 0440); 65 MODULE_PARM_DESC(apmask, "AP bus adapter mask."); 66 67 static char *aqm_str; 68 module_param_named(aqmask, aqm_str, charp, 0440); 69 MODULE_PARM_DESC(aqmask, "AP bus domain mask."); 70 71 static int ap_useirq = 1; 72 module_param_named(useirq, ap_useirq, int, 0440); 73 MODULE_PARM_DESC(useirq, "Use interrupt if available, default is 1 (on)."); 74 75 atomic_t ap_max_msg_size = ATOMIC_INIT(AP_DEFAULT_MAX_MSG_SIZE); 76 EXPORT_SYMBOL(ap_max_msg_size); 77 78 static struct device *ap_root_device; 79 80 /* Hashtable of all queue devices on the AP bus */ 81 DEFINE_HASHTABLE(ap_queues, 8); 82 /* lock used for the ap_queues hashtable */ 83 DEFINE_SPINLOCK(ap_queues_lock); 84 85 /* Default permissions (ioctl, card and domain masking) */ 86 struct ap_perms ap_perms; 87 EXPORT_SYMBOL(ap_perms); 88 DEFINE_MUTEX(ap_perms_mutex); 89 EXPORT_SYMBOL(ap_perms_mutex); 90 91 /* # of bindings complete since init */ 92 static atomic64_t ap_bindings_complete_count = ATOMIC64_INIT(0); 93 94 /* completion for APQN bindings complete */ 95 static DECLARE_COMPLETION(ap_apqn_bindings_complete); 96 97 static struct ap_config_info qci[2]; 98 static struct ap_config_info *const ap_qci_info = &qci[0]; 99 static struct ap_config_info *const ap_qci_info_old = &qci[1]; 100 101 /* 102 * AP bus related debug feature things. 103 */ 104 debug_info_t *ap_dbf_info; 105 106 /* 107 * There is a need for a do-not-allocate-memory path through the AP bus 108 * layer. The pkey layer may be triggered via the in-kernel interface from 109 * a protected key crypto algorithm (namely PAES) to convert a secure key 110 * into a protected key. This happens in a workqueue context, so sleeping 111 * is allowed but memory allocations causing IO operations are not permitted. 112 * To accomplish this, an AP message memory pool with pre-allocated space 113 * is established. When ap_init_apmsg() with use_mempool set to true is 114 * called, instead of kmalloc() the ap message buffer is allocated from 115 * the ap_msg_pool. This pool only holds a limited amount of buffers: 116 * ap_msg_pool_min_items with the item size AP_DEFAULT_MAX_MSG_SIZE and 117 * exactly one of these items (if available) is returned if ap_init_apmsg() 118 * with the use_mempool arg set to true is called. When this pool is exhausted 119 * and use_mempool is set true, ap_init_apmsg() returns -ENOMEM without 120 * any attempt to allocate memory and the caller has to deal with that. 121 */ 122 static mempool_t *ap_msg_pool; 123 static unsigned int ap_msg_pool_min_items = 8; 124 module_param_named(msgpool_min_items, ap_msg_pool_min_items, uint, 0440); 125 MODULE_PARM_DESC(msgpool_min_items, "AP message pool minimal items"); 126 127 /* 128 * AP bus rescan related things. 129 */ 130 static bool ap_scan_bus(void); 131 static bool ap_scan_bus_result; /* result of last ap_scan_bus() */ 132 static DEFINE_MUTEX(ap_scan_bus_mutex); /* mutex ap_scan_bus() invocations */ 133 static struct task_struct *ap_scan_bus_task; /* thread holding the scan mutex */ 134 static atomic64_t ap_scan_bus_count; /* counter ap_scan_bus() invocations */ 135 static int ap_scan_bus_time = AP_CONFIG_TIME; 136 static struct timer_list ap_scan_bus_timer; 137 static void ap_scan_bus_wq_callback(struct work_struct *); 138 static DECLARE_WORK(ap_scan_bus_work, ap_scan_bus_wq_callback); 139 140 /* 141 * Tasklet & timer for AP request polling and interrupts 142 */ 143 static void ap_tasklet_fn(unsigned long); 144 static DECLARE_TASKLET_OLD(ap_tasklet, ap_tasklet_fn); 145 static DECLARE_WAIT_QUEUE_HEAD(ap_poll_wait); 146 static struct task_struct *ap_poll_kthread; 147 static DEFINE_MUTEX(ap_poll_thread_mutex); 148 static DEFINE_SPINLOCK(ap_poll_timer_lock); 149 static struct hrtimer ap_poll_timer; 150 /* 151 * In LPAR poll with 4kHz frequency. Poll every 250000 nanoseconds. 152 * If z/VM change to 1500000 nanoseconds to adjust to z/VM polling. 153 */ 154 static unsigned long poll_high_timeout = 250000UL; 155 156 /* 157 * Some state machine states only require a low frequency polling. 158 * We use 25 Hz frequency for these. 159 */ 160 static unsigned long poll_low_timeout = 40000000UL; 161 162 /* Maximum domain id, if not given via qci */ 163 static int ap_max_domain_id = 15; 164 /* Maximum adapter id, if not given via qci */ 165 static int ap_max_adapter_id = 63; 166 167 static const struct bus_type ap_bus_type; 168 169 /* Adapter interrupt definitions */ 170 static void ap_interrupt_handler(struct airq_struct *airq, 171 struct tpi_info *tpi_info); 172 173 static bool ap_irq_flag; 174 175 static struct airq_struct ap_airq = { 176 .handler = ap_interrupt_handler, 177 .isc = AP_ISC, 178 }; 179 180 /** 181 * ap_airq_ptr() - Get the address of the adapter interrupt indicator 182 * 183 * Returns the address of the local-summary-indicator of the adapter 184 * interrupt handler for AP, or NULL if adapter interrupts are not 185 * available. 186 */ 187 void *ap_airq_ptr(void) 188 { 189 if (ap_irq_flag) 190 return ap_airq.lsi_ptr; 191 return NULL; 192 } 193 194 /** 195 * ap_interrupts_available(): Test if AP interrupts are available. 196 * 197 * Returns 1 if AP interrupts are available. 198 */ 199 static int ap_interrupts_available(void) 200 { 201 return test_facility(65); 202 } 203 204 /** 205 * ap_qci_available(): Test if AP configuration 206 * information can be queried via QCI subfunction. 207 * 208 * Returns 1 if subfunction PQAP(QCI) is available. 209 */ 210 static int ap_qci_available(void) 211 { 212 return test_facility(12); 213 } 214 215 /** 216 * ap_apft_available(): Test if AP facilities test (APFT) 217 * facility is available. 218 * 219 * Returns 1 if APFT is available. 220 */ 221 static int ap_apft_available(void) 222 { 223 return test_facility(15); 224 } 225 226 /* 227 * ap_qact_available(): Test if the PQAP(QACT) subfunction is available. 228 * 229 * Returns 1 if the QACT subfunction is available. 230 */ 231 static inline int ap_qact_available(void) 232 { 233 return ap_qci_info->qact; 234 } 235 236 /* 237 * ap_sb_available(): Test if the AP secure binding facility is available. 238 * 239 * Returns 1 if secure binding facility is available. 240 */ 241 int ap_sb_available(void) 242 { 243 return ap_qci_info->apsb; 244 } 245 246 /* 247 * ap_is_se_guest(): Check for SE guest with AP pass-through support. 248 */ 249 bool ap_is_se_guest(void) 250 { 251 return is_prot_virt_guest() && ap_sb_available(); 252 } 253 EXPORT_SYMBOL(ap_is_se_guest); 254 255 /** 256 * ap_init_qci_info(): Allocate and query qci config info. 257 * Does also update the static variables ap_max_domain_id 258 * and ap_max_adapter_id if this info is available. 259 */ 260 static void __init ap_init_qci_info(void) 261 { 262 if (!ap_qci_available() || 263 ap_qci(ap_qci_info)) { 264 AP_DBF_INFO("%s QCI not supported\n", __func__); 265 return; 266 } 267 memcpy(ap_qci_info_old, ap_qci_info, sizeof(*ap_qci_info)); 268 AP_DBF_INFO("%s successful fetched initial qci info\n", __func__); 269 270 if (ap_qci_info->apxa) { 271 if (ap_qci_info->na) { 272 ap_max_adapter_id = ap_qci_info->na; 273 AP_DBF_INFO("%s new ap_max_adapter_id is %d\n", 274 __func__, ap_max_adapter_id); 275 } 276 if (ap_qci_info->nd) { 277 ap_max_domain_id = ap_qci_info->nd; 278 AP_DBF_INFO("%s new ap_max_domain_id is %d\n", 279 __func__, ap_max_domain_id); 280 } 281 } 282 } 283 284 /* 285 * ap_test_config(): helper function to extract the nrth bit 286 * within the unsigned int array field. 287 */ 288 static inline int ap_test_config(unsigned int *field, unsigned int nr) 289 { 290 return ap_test_bit((field + (nr >> 5)), (nr & 0x1f)); 291 } 292 293 /* 294 * ap_test_config_card_id(): Test, whether an AP card ID is configured. 295 * 296 * Returns 0 if the card is not configured 297 * 1 if the card is configured or 298 * if the configuration information is not available 299 */ 300 static inline int ap_test_config_card_id(unsigned int id) 301 { 302 if (id > ap_max_adapter_id) 303 return 0; 304 if (ap_qci_info->flags) 305 return ap_test_config(ap_qci_info->apm, id); 306 return 1; 307 } 308 309 /* 310 * ap_test_config_usage_domain(): Test, whether an AP usage domain 311 * is configured. 312 * 313 * Returns 0 if the usage domain is not configured 314 * 1 if the usage domain is configured or 315 * if the configuration information is not available 316 */ 317 int ap_test_config_usage_domain(unsigned int domain) 318 { 319 if (domain > ap_max_domain_id) 320 return 0; 321 if (ap_qci_info->flags) 322 return ap_test_config(ap_qci_info->aqm, domain); 323 return 1; 324 } 325 EXPORT_SYMBOL(ap_test_config_usage_domain); 326 327 /* 328 * ap_test_config_ctrl_domain(): Test, whether an AP control domain 329 * is configured. 330 * @domain AP control domain ID 331 * 332 * Returns 1 if the control domain is configured 333 * 0 in all other cases 334 */ 335 int ap_test_config_ctrl_domain(unsigned int domain) 336 { 337 if (!ap_qci_info || domain > ap_max_domain_id) 338 return 0; 339 return ap_test_config(ap_qci_info->adm, domain); 340 } 341 EXPORT_SYMBOL(ap_test_config_ctrl_domain); 342 343 /* 344 * ap_queue_info(): Check and get AP queue info. 345 * Returns: 1 if APQN exists and info is filled, 346 * 0 if APQN seems to exist but there is no info 347 * available (eg. caused by an asynch pending error) 348 * -1 invalid APQN, TAPQ error or AP queue status which 349 * indicates there is no APQN. 350 */ 351 static int ap_queue_info(ap_qid_t qid, struct ap_tapq_hwinfo *hwinfo, 352 bool *decfg, bool *cstop) 353 { 354 struct ap_queue_status status; 355 356 hwinfo->value = 0; 357 358 /* make sure we don't run into a specifiation exception */ 359 if (AP_QID_CARD(qid) > ap_max_adapter_id || 360 AP_QID_QUEUE(qid) > ap_max_domain_id) 361 return -1; 362 363 /* call TAPQ on this APQN */ 364 status = ap_test_queue(qid, ap_apft_available(), hwinfo); 365 366 switch (status.response_code) { 367 case AP_RESPONSE_NORMAL: 368 case AP_RESPONSE_RESET_IN_PROGRESS: 369 case AP_RESPONSE_DECONFIGURED: 370 case AP_RESPONSE_CHECKSTOPPED: 371 case AP_RESPONSE_BUSY: 372 /* For all these RCs the tapq info should be available */ 373 break; 374 default: 375 /* On a pending async error the info should be available */ 376 if (!status.async) 377 return -1; 378 break; 379 } 380 381 /* There should be at least one of the mode bits set */ 382 if (WARN_ON_ONCE(!hwinfo->value)) 383 return 0; 384 385 *decfg = status.response_code == AP_RESPONSE_DECONFIGURED; 386 *cstop = status.response_code == AP_RESPONSE_CHECKSTOPPED; 387 388 return 1; 389 } 390 391 void ap_wait(enum ap_sm_wait wait) 392 { 393 ktime_t hr_time; 394 395 switch (wait) { 396 case AP_SM_WAIT_AGAIN: 397 case AP_SM_WAIT_INTERRUPT: 398 if (ap_irq_flag) 399 break; 400 if (ap_poll_kthread) { 401 wake_up(&ap_poll_wait); 402 break; 403 } 404 fallthrough; 405 case AP_SM_WAIT_LOW_TIMEOUT: 406 case AP_SM_WAIT_HIGH_TIMEOUT: 407 spin_lock_bh(&ap_poll_timer_lock); 408 if (!hrtimer_is_queued(&ap_poll_timer)) { 409 hr_time = 410 wait == AP_SM_WAIT_LOW_TIMEOUT ? 411 poll_low_timeout : poll_high_timeout; 412 hrtimer_forward_now(&ap_poll_timer, hr_time); 413 hrtimer_restart(&ap_poll_timer); 414 } 415 spin_unlock_bh(&ap_poll_timer_lock); 416 break; 417 case AP_SM_WAIT_NONE: 418 default: 419 break; 420 } 421 } 422 423 /** 424 * ap_request_timeout(): Handling of request timeouts 425 * @t: timer making this callback 426 * 427 * Handles request timeouts. 428 */ 429 void ap_request_timeout(struct timer_list *t) 430 { 431 struct ap_queue *aq = from_timer(aq, t, timeout); 432 433 spin_lock_bh(&aq->lock); 434 ap_wait(ap_sm_event(aq, AP_SM_EVENT_TIMEOUT)); 435 spin_unlock_bh(&aq->lock); 436 } 437 438 /** 439 * ap_poll_timeout(): AP receive polling for finished AP requests. 440 * @unused: Unused pointer. 441 * 442 * Schedules the AP tasklet using a high resolution timer. 443 */ 444 static enum hrtimer_restart ap_poll_timeout(struct hrtimer *unused) 445 { 446 tasklet_schedule(&ap_tasklet); 447 return HRTIMER_NORESTART; 448 } 449 450 /** 451 * ap_interrupt_handler() - Schedule ap_tasklet on interrupt 452 * @airq: pointer to adapter interrupt descriptor 453 * @tpi_info: ignored 454 */ 455 static void ap_interrupt_handler(struct airq_struct *airq, 456 struct tpi_info *tpi_info) 457 { 458 inc_irq_stat(IRQIO_APB); 459 tasklet_schedule(&ap_tasklet); 460 } 461 462 /** 463 * ap_tasklet_fn(): Tasklet to poll all AP devices. 464 * @dummy: Unused variable 465 * 466 * Poll all AP devices on the bus. 467 */ 468 static void ap_tasklet_fn(unsigned long dummy) 469 { 470 int bkt; 471 struct ap_queue *aq; 472 enum ap_sm_wait wait = AP_SM_WAIT_NONE; 473 474 /* Reset the indicator if interrupts are used. Thus new interrupts can 475 * be received. Doing it in the beginning of the tasklet is therefore 476 * important that no requests on any AP get lost. 477 */ 478 if (ap_irq_flag) 479 WRITE_ONCE(*ap_airq.lsi_ptr, 0); 480 481 spin_lock_bh(&ap_queues_lock); 482 hash_for_each(ap_queues, bkt, aq, hnode) { 483 spin_lock_bh(&aq->lock); 484 wait = min(wait, ap_sm_event_loop(aq, AP_SM_EVENT_POLL)); 485 spin_unlock_bh(&aq->lock); 486 } 487 spin_unlock_bh(&ap_queues_lock); 488 489 ap_wait(wait); 490 } 491 492 static int ap_pending_requests(void) 493 { 494 int bkt; 495 struct ap_queue *aq; 496 497 spin_lock_bh(&ap_queues_lock); 498 hash_for_each(ap_queues, bkt, aq, hnode) { 499 if (aq->queue_count == 0) 500 continue; 501 spin_unlock_bh(&ap_queues_lock); 502 return 1; 503 } 504 spin_unlock_bh(&ap_queues_lock); 505 return 0; 506 } 507 508 /** 509 * ap_poll_thread(): Thread that polls for finished requests. 510 * @data: Unused pointer 511 * 512 * AP bus poll thread. The purpose of this thread is to poll for 513 * finished requests in a loop if there is a "free" cpu - that is 514 * a cpu that doesn't have anything better to do. The polling stops 515 * as soon as there is another task or if all messages have been 516 * delivered. 517 */ 518 static int ap_poll_thread(void *data) 519 { 520 DECLARE_WAITQUEUE(wait, current); 521 522 set_user_nice(current, MAX_NICE); 523 set_freezable(); 524 while (!kthread_should_stop()) { 525 add_wait_queue(&ap_poll_wait, &wait); 526 set_current_state(TASK_INTERRUPTIBLE); 527 if (!ap_pending_requests()) { 528 schedule(); 529 try_to_freeze(); 530 } 531 set_current_state(TASK_RUNNING); 532 remove_wait_queue(&ap_poll_wait, &wait); 533 if (need_resched()) { 534 schedule(); 535 try_to_freeze(); 536 continue; 537 } 538 ap_tasklet_fn(0); 539 } 540 541 return 0; 542 } 543 544 static int ap_poll_thread_start(void) 545 { 546 int rc; 547 548 if (ap_irq_flag || ap_poll_kthread) 549 return 0; 550 mutex_lock(&ap_poll_thread_mutex); 551 ap_poll_kthread = kthread_run(ap_poll_thread, NULL, "appoll"); 552 rc = PTR_ERR_OR_ZERO(ap_poll_kthread); 553 if (rc) 554 ap_poll_kthread = NULL; 555 mutex_unlock(&ap_poll_thread_mutex); 556 return rc; 557 } 558 559 static void ap_poll_thread_stop(void) 560 { 561 if (!ap_poll_kthread) 562 return; 563 mutex_lock(&ap_poll_thread_mutex); 564 kthread_stop(ap_poll_kthread); 565 ap_poll_kthread = NULL; 566 mutex_unlock(&ap_poll_thread_mutex); 567 } 568 569 #define is_card_dev(x) ((x)->parent == ap_root_device) 570 #define is_queue_dev(x) ((x)->parent != ap_root_device) 571 572 /* 573 * ap_init_apmsg() - Initialize ap_message. 574 */ 575 int ap_init_apmsg(struct ap_message *ap_msg, u32 flags) 576 { 577 unsigned int maxmsgsize; 578 579 memset(ap_msg, 0, sizeof(*ap_msg)); 580 ap_msg->flags = flags; 581 582 if (flags & AP_MSG_FLAG_MEMPOOL) { 583 ap_msg->msg = mempool_alloc_preallocated(ap_msg_pool); 584 if (!ap_msg->msg) 585 return -ENOMEM; 586 ap_msg->bufsize = AP_DEFAULT_MAX_MSG_SIZE; 587 return 0; 588 } 589 590 maxmsgsize = atomic_read(&ap_max_msg_size); 591 ap_msg->msg = kmalloc(maxmsgsize, GFP_KERNEL); 592 if (!ap_msg->msg) 593 return -ENOMEM; 594 ap_msg->bufsize = maxmsgsize; 595 596 return 0; 597 } 598 EXPORT_SYMBOL(ap_init_apmsg); 599 600 /* 601 * ap_release_apmsg() - Release ap_message. 602 */ 603 void ap_release_apmsg(struct ap_message *ap_msg) 604 { 605 if (ap_msg->flags & AP_MSG_FLAG_MEMPOOL) { 606 memzero_explicit(ap_msg->msg, ap_msg->bufsize); 607 mempool_free(ap_msg->msg, ap_msg_pool); 608 } else { 609 kfree_sensitive(ap_msg->msg); 610 } 611 } 612 EXPORT_SYMBOL(ap_release_apmsg); 613 614 /** 615 * ap_bus_match() 616 * @dev: Pointer to device 617 * @drv: Pointer to device_driver 618 * 619 * AP bus driver registration/unregistration. 620 */ 621 static int ap_bus_match(struct device *dev, const struct device_driver *drv) 622 { 623 const struct ap_driver *ap_drv = to_ap_drv(drv); 624 struct ap_device_id *id; 625 626 /* 627 * Compare device type of the device with the list of 628 * supported types of the device_driver. 629 */ 630 for (id = ap_drv->ids; id->match_flags; id++) { 631 if (is_card_dev(dev) && 632 id->match_flags & AP_DEVICE_ID_MATCH_CARD_TYPE && 633 id->dev_type == to_ap_dev(dev)->device_type) 634 return 1; 635 if (is_queue_dev(dev) && 636 id->match_flags & AP_DEVICE_ID_MATCH_QUEUE_TYPE && 637 id->dev_type == to_ap_dev(dev)->device_type) 638 return 1; 639 } 640 return 0; 641 } 642 643 /** 644 * ap_uevent(): Uevent function for AP devices. 645 * @dev: Pointer to device 646 * @env: Pointer to kobj_uevent_env 647 * 648 * It sets up a single environment variable DEV_TYPE which contains the 649 * hardware device type. 650 */ 651 static int ap_uevent(const struct device *dev, struct kobj_uevent_env *env) 652 { 653 int rc = 0; 654 const struct ap_device *ap_dev = to_ap_dev(dev); 655 656 /* Uevents from ap bus core don't need extensions to the env */ 657 if (dev == ap_root_device) 658 return 0; 659 660 if (is_card_dev(dev)) { 661 struct ap_card *ac = to_ap_card(&ap_dev->device); 662 663 /* Set up DEV_TYPE environment variable. */ 664 rc = add_uevent_var(env, "DEV_TYPE=%04X", ap_dev->device_type); 665 if (rc) 666 return rc; 667 /* Add MODALIAS= */ 668 rc = add_uevent_var(env, "MODALIAS=ap:t%02X", ap_dev->device_type); 669 if (rc) 670 return rc; 671 672 /* Add MODE=<accel|cca|ep11> */ 673 if (ac->hwinfo.accel) 674 rc = add_uevent_var(env, "MODE=accel"); 675 else if (ac->hwinfo.cca) 676 rc = add_uevent_var(env, "MODE=cca"); 677 else if (ac->hwinfo.ep11) 678 rc = add_uevent_var(env, "MODE=ep11"); 679 if (rc) 680 return rc; 681 } else { 682 struct ap_queue *aq = to_ap_queue(&ap_dev->device); 683 684 /* Add MODE=<accel|cca|ep11> */ 685 if (aq->card->hwinfo.accel) 686 rc = add_uevent_var(env, "MODE=accel"); 687 else if (aq->card->hwinfo.cca) 688 rc = add_uevent_var(env, "MODE=cca"); 689 else if (aq->card->hwinfo.ep11) 690 rc = add_uevent_var(env, "MODE=ep11"); 691 if (rc) 692 return rc; 693 } 694 695 return 0; 696 } 697 698 static void ap_send_init_scan_done_uevent(void) 699 { 700 char *envp[] = { "INITSCAN=done", NULL }; 701 702 kobject_uevent_env(&ap_root_device->kobj, KOBJ_CHANGE, envp); 703 } 704 705 static void ap_send_bindings_complete_uevent(void) 706 { 707 char buf[32]; 708 char *envp[] = { "BINDINGS=complete", buf, NULL }; 709 710 snprintf(buf, sizeof(buf), "COMPLETECOUNT=%llu", 711 atomic64_inc_return(&ap_bindings_complete_count)); 712 kobject_uevent_env(&ap_root_device->kobj, KOBJ_CHANGE, envp); 713 } 714 715 void ap_send_config_uevent(struct ap_device *ap_dev, bool cfg) 716 { 717 char buf[16]; 718 char *envp[] = { buf, NULL }; 719 720 snprintf(buf, sizeof(buf), "CONFIG=%d", cfg ? 1 : 0); 721 722 kobject_uevent_env(&ap_dev->device.kobj, KOBJ_CHANGE, envp); 723 } 724 EXPORT_SYMBOL(ap_send_config_uevent); 725 726 void ap_send_online_uevent(struct ap_device *ap_dev, int online) 727 { 728 char buf[16]; 729 char *envp[] = { buf, NULL }; 730 731 snprintf(buf, sizeof(buf), "ONLINE=%d", online ? 1 : 0); 732 733 kobject_uevent_env(&ap_dev->device.kobj, KOBJ_CHANGE, envp); 734 } 735 EXPORT_SYMBOL(ap_send_online_uevent); 736 737 static void ap_send_mask_changed_uevent(unsigned long *newapm, 738 unsigned long *newaqm) 739 { 740 char buf[100]; 741 char *envp[] = { buf, NULL }; 742 743 if (newapm) 744 snprintf(buf, sizeof(buf), 745 "APMASK=0x%016lx%016lx%016lx%016lx\n", 746 newapm[0], newapm[1], newapm[2], newapm[3]); 747 else 748 snprintf(buf, sizeof(buf), 749 "AQMASK=0x%016lx%016lx%016lx%016lx\n", 750 newaqm[0], newaqm[1], newaqm[2], newaqm[3]); 751 752 kobject_uevent_env(&ap_root_device->kobj, KOBJ_CHANGE, envp); 753 } 754 755 /* 756 * calc # of bound APQNs 757 */ 758 759 struct __ap_calc_ctrs { 760 unsigned int apqns; 761 unsigned int bound; 762 }; 763 764 static int __ap_calc_helper(struct device *dev, void *arg) 765 { 766 struct __ap_calc_ctrs *pctrs = (struct __ap_calc_ctrs *)arg; 767 768 if (is_queue_dev(dev)) { 769 pctrs->apqns++; 770 if (dev->driver) 771 pctrs->bound++; 772 } 773 774 return 0; 775 } 776 777 static void ap_calc_bound_apqns(unsigned int *apqns, unsigned int *bound) 778 { 779 struct __ap_calc_ctrs ctrs; 780 781 memset(&ctrs, 0, sizeof(ctrs)); 782 bus_for_each_dev(&ap_bus_type, NULL, (void *)&ctrs, __ap_calc_helper); 783 784 *apqns = ctrs.apqns; 785 *bound = ctrs.bound; 786 } 787 788 /* 789 * After ap bus scan do check if all existing APQNs are 790 * bound to device drivers. 791 */ 792 static void ap_check_bindings_complete(void) 793 { 794 unsigned int apqns, bound; 795 796 if (atomic64_read(&ap_scan_bus_count) >= 1) { 797 ap_calc_bound_apqns(&apqns, &bound); 798 if (bound == apqns) { 799 if (!completion_done(&ap_apqn_bindings_complete)) { 800 complete_all(&ap_apqn_bindings_complete); 801 ap_send_bindings_complete_uevent(); 802 pr_debug("all apqn bindings complete\n"); 803 } 804 } 805 } 806 } 807 808 /* 809 * Interface to wait for the AP bus to have done one initial ap bus 810 * scan and all detected APQNs have been bound to device drivers. 811 * If these both conditions are not fulfilled, this function blocks 812 * on a condition with wait_for_completion_interruptible_timeout(). 813 * If these both conditions are fulfilled (before the timeout hits) 814 * the return value is 0. If the timeout (in jiffies) hits instead 815 * -ETIME is returned. On failures negative return values are 816 * returned to the caller. 817 */ 818 int ap_wait_apqn_bindings_complete(unsigned long timeout) 819 { 820 int rc = 0; 821 long l; 822 823 if (completion_done(&ap_apqn_bindings_complete)) 824 return 0; 825 826 if (timeout) 827 l = wait_for_completion_interruptible_timeout( 828 &ap_apqn_bindings_complete, timeout); 829 else 830 l = wait_for_completion_interruptible( 831 &ap_apqn_bindings_complete); 832 if (l < 0) 833 rc = l == -ERESTARTSYS ? -EINTR : l; 834 else if (l == 0 && timeout) 835 rc = -ETIME; 836 837 pr_debug("rc=%d\n", rc); 838 return rc; 839 } 840 EXPORT_SYMBOL(ap_wait_apqn_bindings_complete); 841 842 static int __ap_queue_devices_with_id_unregister(struct device *dev, void *data) 843 { 844 if (is_queue_dev(dev) && 845 AP_QID_CARD(to_ap_queue(dev)->qid) == (int)(long)data) 846 device_unregister(dev); 847 return 0; 848 } 849 850 static int __ap_revise_reserved(struct device *dev, void *dummy) 851 { 852 int rc, card, queue, devres, drvres; 853 854 if (is_queue_dev(dev)) { 855 card = AP_QID_CARD(to_ap_queue(dev)->qid); 856 queue = AP_QID_QUEUE(to_ap_queue(dev)->qid); 857 mutex_lock(&ap_perms_mutex); 858 devres = test_bit_inv(card, ap_perms.apm) && 859 test_bit_inv(queue, ap_perms.aqm); 860 mutex_unlock(&ap_perms_mutex); 861 drvres = to_ap_drv(dev->driver)->flags 862 & AP_DRIVER_FLAG_DEFAULT; 863 if (!!devres != !!drvres) { 864 pr_debug("reprobing queue=%02x.%04x\n", card, queue); 865 rc = device_reprobe(dev); 866 if (rc) 867 AP_DBF_WARN("%s reprobing queue=%02x.%04x failed\n", 868 __func__, card, queue); 869 } 870 } 871 872 return 0; 873 } 874 875 static void ap_bus_revise_bindings(void) 876 { 877 bus_for_each_dev(&ap_bus_type, NULL, NULL, __ap_revise_reserved); 878 } 879 880 /** 881 * ap_owned_by_def_drv: indicates whether an AP adapter is reserved for the 882 * default host driver or not. 883 * @card: the APID of the adapter card to check 884 * @queue: the APQI of the queue to check 885 * 886 * Note: the ap_perms_mutex must be locked by the caller of this function. 887 * 888 * Return: an int specifying whether the AP adapter is reserved for the host (1) 889 * or not (0). 890 */ 891 int ap_owned_by_def_drv(int card, int queue) 892 { 893 int rc = 0; 894 895 if (card < 0 || card >= AP_DEVICES || queue < 0 || queue >= AP_DOMAINS) 896 return -EINVAL; 897 898 if (test_bit_inv(card, ap_perms.apm) && 899 test_bit_inv(queue, ap_perms.aqm)) 900 rc = 1; 901 902 return rc; 903 } 904 EXPORT_SYMBOL(ap_owned_by_def_drv); 905 906 /** 907 * ap_apqn_in_matrix_owned_by_def_drv: indicates whether every APQN contained in 908 * a set is reserved for the host drivers 909 * or not. 910 * @apm: a bitmap specifying a set of APIDs comprising the APQNs to check 911 * @aqm: a bitmap specifying a set of APQIs comprising the APQNs to check 912 * 913 * Note: the ap_perms_mutex must be locked by the caller of this function. 914 * 915 * Return: an int specifying whether each APQN is reserved for the host (1) or 916 * not (0) 917 */ 918 int ap_apqn_in_matrix_owned_by_def_drv(unsigned long *apm, 919 unsigned long *aqm) 920 { 921 int card, queue, rc = 0; 922 923 for (card = 0; !rc && card < AP_DEVICES; card++) 924 if (test_bit_inv(card, apm) && 925 test_bit_inv(card, ap_perms.apm)) 926 for (queue = 0; !rc && queue < AP_DOMAINS; queue++) 927 if (test_bit_inv(queue, aqm) && 928 test_bit_inv(queue, ap_perms.aqm)) 929 rc = 1; 930 931 return rc; 932 } 933 EXPORT_SYMBOL(ap_apqn_in_matrix_owned_by_def_drv); 934 935 static int ap_device_probe(struct device *dev) 936 { 937 struct ap_device *ap_dev = to_ap_dev(dev); 938 struct ap_driver *ap_drv = to_ap_drv(dev->driver); 939 int card, queue, devres, drvres, rc = -ENODEV; 940 941 if (!get_device(dev)) 942 return rc; 943 944 if (is_queue_dev(dev)) { 945 /* 946 * If the apqn is marked as reserved/used by ap bus and 947 * default drivers, only probe with drivers with the default 948 * flag set. If it is not marked, only probe with drivers 949 * with the default flag not set. 950 */ 951 card = AP_QID_CARD(to_ap_queue(dev)->qid); 952 queue = AP_QID_QUEUE(to_ap_queue(dev)->qid); 953 mutex_lock(&ap_perms_mutex); 954 devres = test_bit_inv(card, ap_perms.apm) && 955 test_bit_inv(queue, ap_perms.aqm); 956 mutex_unlock(&ap_perms_mutex); 957 drvres = ap_drv->flags & AP_DRIVER_FLAG_DEFAULT; 958 if (!!devres != !!drvres) 959 goto out; 960 } 961 962 /* 963 * Rearm the bindings complete completion to trigger 964 * bindings complete when all devices are bound again 965 */ 966 reinit_completion(&ap_apqn_bindings_complete); 967 968 /* Add queue/card to list of active queues/cards */ 969 spin_lock_bh(&ap_queues_lock); 970 if (is_queue_dev(dev)) 971 hash_add(ap_queues, &to_ap_queue(dev)->hnode, 972 to_ap_queue(dev)->qid); 973 spin_unlock_bh(&ap_queues_lock); 974 975 rc = ap_drv->probe ? ap_drv->probe(ap_dev) : -ENODEV; 976 977 if (rc) { 978 spin_lock_bh(&ap_queues_lock); 979 if (is_queue_dev(dev)) 980 hash_del(&to_ap_queue(dev)->hnode); 981 spin_unlock_bh(&ap_queues_lock); 982 } 983 984 out: 985 if (rc) 986 put_device(dev); 987 return rc; 988 } 989 990 static void ap_device_remove(struct device *dev) 991 { 992 struct ap_device *ap_dev = to_ap_dev(dev); 993 struct ap_driver *ap_drv = to_ap_drv(dev->driver); 994 995 /* prepare ap queue device removal */ 996 if (is_queue_dev(dev)) 997 ap_queue_prepare_remove(to_ap_queue(dev)); 998 999 /* driver's chance to clean up gracefully */ 1000 if (ap_drv->remove) 1001 ap_drv->remove(ap_dev); 1002 1003 /* now do the ap queue device remove */ 1004 if (is_queue_dev(dev)) 1005 ap_queue_remove(to_ap_queue(dev)); 1006 1007 /* Remove queue/card from list of active queues/cards */ 1008 spin_lock_bh(&ap_queues_lock); 1009 if (is_queue_dev(dev)) 1010 hash_del(&to_ap_queue(dev)->hnode); 1011 spin_unlock_bh(&ap_queues_lock); 1012 1013 put_device(dev); 1014 } 1015 1016 struct ap_queue *ap_get_qdev(ap_qid_t qid) 1017 { 1018 int bkt; 1019 struct ap_queue *aq; 1020 1021 spin_lock_bh(&ap_queues_lock); 1022 hash_for_each(ap_queues, bkt, aq, hnode) { 1023 if (aq->qid == qid) { 1024 get_device(&aq->ap_dev.device); 1025 spin_unlock_bh(&ap_queues_lock); 1026 return aq; 1027 } 1028 } 1029 spin_unlock_bh(&ap_queues_lock); 1030 1031 return NULL; 1032 } 1033 EXPORT_SYMBOL(ap_get_qdev); 1034 1035 int ap_driver_register(struct ap_driver *ap_drv, struct module *owner, 1036 char *name) 1037 { 1038 struct device_driver *drv = &ap_drv->driver; 1039 int rc; 1040 1041 drv->bus = &ap_bus_type; 1042 drv->owner = owner; 1043 drv->name = name; 1044 rc = driver_register(drv); 1045 1046 ap_check_bindings_complete(); 1047 1048 return rc; 1049 } 1050 EXPORT_SYMBOL(ap_driver_register); 1051 1052 void ap_driver_unregister(struct ap_driver *ap_drv) 1053 { 1054 driver_unregister(&ap_drv->driver); 1055 } 1056 EXPORT_SYMBOL(ap_driver_unregister); 1057 1058 /* 1059 * Enforce a synchronous AP bus rescan. 1060 * Returns true if the bus scan finds a change in the AP configuration 1061 * and AP devices have been added or deleted when this function returns. 1062 */ 1063 bool ap_bus_force_rescan(void) 1064 { 1065 unsigned long scan_counter = atomic64_read(&ap_scan_bus_count); 1066 bool rc = false; 1067 1068 pr_debug("> scan counter=%lu\n", scan_counter); 1069 1070 /* Only trigger AP bus scans after the initial scan is done */ 1071 if (scan_counter <= 0) 1072 goto out; 1073 1074 /* 1075 * There is one unlikely but nevertheless valid scenario where the 1076 * thread holding the mutex may try to send some crypto load but 1077 * all cards are offline so a rescan is triggered which causes 1078 * a recursive call of ap_bus_force_rescan(). A simple return if 1079 * the mutex is already locked by this thread solves this. 1080 */ 1081 if (mutex_is_locked(&ap_scan_bus_mutex)) { 1082 if (ap_scan_bus_task == current) 1083 goto out; 1084 } 1085 1086 /* Try to acquire the AP scan bus mutex */ 1087 if (mutex_trylock(&ap_scan_bus_mutex)) { 1088 /* mutex acquired, run the AP bus scan */ 1089 ap_scan_bus_task = current; 1090 ap_scan_bus_result = ap_scan_bus(); 1091 rc = ap_scan_bus_result; 1092 ap_scan_bus_task = NULL; 1093 mutex_unlock(&ap_scan_bus_mutex); 1094 goto out; 1095 } 1096 1097 /* 1098 * Mutex acquire failed. So there is currently another task 1099 * already running the AP bus scan. Then let's simple wait 1100 * for the lock which means the other task has finished and 1101 * stored the result in ap_scan_bus_result. 1102 */ 1103 if (mutex_lock_interruptible(&ap_scan_bus_mutex)) { 1104 /* some error occurred, ignore and go out */ 1105 goto out; 1106 } 1107 rc = ap_scan_bus_result; 1108 mutex_unlock(&ap_scan_bus_mutex); 1109 1110 out: 1111 pr_debug("rc=%d\n", rc); 1112 return rc; 1113 } 1114 EXPORT_SYMBOL(ap_bus_force_rescan); 1115 1116 /* 1117 * A config change has happened, force an ap bus rescan. 1118 */ 1119 static int ap_bus_cfg_chg(struct notifier_block *nb, 1120 unsigned long action, void *data) 1121 { 1122 if (action != CHSC_NOTIFY_AP_CFG) 1123 return NOTIFY_DONE; 1124 1125 pr_debug("config change, forcing bus rescan\n"); 1126 1127 ap_bus_force_rescan(); 1128 1129 return NOTIFY_OK; 1130 } 1131 1132 static struct notifier_block ap_bus_nb = { 1133 .notifier_call = ap_bus_cfg_chg, 1134 }; 1135 1136 int ap_hex2bitmap(const char *str, unsigned long *bitmap, int bits) 1137 { 1138 int i, n, b; 1139 1140 /* bits needs to be a multiple of 8 */ 1141 if (bits & 0x07) 1142 return -EINVAL; 1143 1144 if (str[0] == '0' && str[1] == 'x') 1145 str++; 1146 if (*str == 'x') 1147 str++; 1148 1149 for (i = 0; isxdigit(*str) && i < bits; str++) { 1150 b = hex_to_bin(*str); 1151 for (n = 0; n < 4; n++) 1152 if (b & (0x08 >> n)) 1153 set_bit_inv(i + n, bitmap); 1154 i += 4; 1155 } 1156 1157 if (*str == '\n') 1158 str++; 1159 if (*str) 1160 return -EINVAL; 1161 return 0; 1162 } 1163 EXPORT_SYMBOL(ap_hex2bitmap); 1164 1165 /* 1166 * modify_bitmap() - parse bitmask argument and modify an existing 1167 * bit mask accordingly. A concatenation (done with ',') of these 1168 * terms is recognized: 1169 * +<bitnr>[-<bitnr>] or -<bitnr>[-<bitnr>] 1170 * <bitnr> may be any valid number (hex, decimal or octal) in the range 1171 * 0...bits-1; the leading + or - is required. Here are some examples: 1172 * +0-15,+32,-128,-0xFF 1173 * -0-255,+1-16,+0x128 1174 * +1,+2,+3,+4,-5,-7-10 1175 * Returns the new bitmap after all changes have been applied. Every 1176 * positive value in the string will set a bit and every negative value 1177 * in the string will clear a bit. As a bit may be touched more than once, 1178 * the last 'operation' wins: 1179 * +0-255,-128 = first bits 0-255 will be set, then bit 128 will be 1180 * cleared again. All other bits are unmodified. 1181 */ 1182 static int modify_bitmap(const char *str, unsigned long *bitmap, int bits) 1183 { 1184 unsigned long a, i, z; 1185 char *np, sign; 1186 1187 /* bits needs to be a multiple of 8 */ 1188 if (bits & 0x07) 1189 return -EINVAL; 1190 1191 while (*str) { 1192 sign = *str++; 1193 if (sign != '+' && sign != '-') 1194 return -EINVAL; 1195 a = z = simple_strtoul(str, &np, 0); 1196 if (str == np || a >= bits) 1197 return -EINVAL; 1198 str = np; 1199 if (*str == '-') { 1200 z = simple_strtoul(++str, &np, 0); 1201 if (str == np || a > z || z >= bits) 1202 return -EINVAL; 1203 str = np; 1204 } 1205 for (i = a; i <= z; i++) 1206 if (sign == '+') 1207 set_bit_inv(i, bitmap); 1208 else 1209 clear_bit_inv(i, bitmap); 1210 while (*str == ',' || *str == '\n') 1211 str++; 1212 } 1213 1214 return 0; 1215 } 1216 1217 static int ap_parse_bitmap_str(const char *str, unsigned long *bitmap, int bits, 1218 unsigned long *newmap) 1219 { 1220 unsigned long size; 1221 int rc; 1222 1223 size = BITS_TO_LONGS(bits) * sizeof(unsigned long); 1224 if (*str == '+' || *str == '-') { 1225 memcpy(newmap, bitmap, size); 1226 rc = modify_bitmap(str, newmap, bits); 1227 } else { 1228 memset(newmap, 0, size); 1229 rc = ap_hex2bitmap(str, newmap, bits); 1230 } 1231 return rc; 1232 } 1233 1234 int ap_parse_mask_str(const char *str, 1235 unsigned long *bitmap, int bits, 1236 struct mutex *lock) 1237 { 1238 unsigned long *newmap, size; 1239 int rc; 1240 1241 /* bits needs to be a multiple of 8 */ 1242 if (bits & 0x07) 1243 return -EINVAL; 1244 1245 size = BITS_TO_LONGS(bits) * sizeof(unsigned long); 1246 newmap = kmalloc(size, GFP_KERNEL); 1247 if (!newmap) 1248 return -ENOMEM; 1249 if (mutex_lock_interruptible(lock)) { 1250 kfree(newmap); 1251 return -ERESTARTSYS; 1252 } 1253 rc = ap_parse_bitmap_str(str, bitmap, bits, newmap); 1254 if (rc == 0) 1255 memcpy(bitmap, newmap, size); 1256 mutex_unlock(lock); 1257 kfree(newmap); 1258 return rc; 1259 } 1260 EXPORT_SYMBOL(ap_parse_mask_str); 1261 1262 /* 1263 * AP bus attributes. 1264 */ 1265 1266 static ssize_t ap_domain_show(const struct bus_type *bus, char *buf) 1267 { 1268 return sysfs_emit(buf, "%d\n", ap_domain_index); 1269 } 1270 1271 static ssize_t ap_domain_store(const struct bus_type *bus, 1272 const char *buf, size_t count) 1273 { 1274 int domain; 1275 1276 if (sscanf(buf, "%i\n", &domain) != 1 || 1277 domain < 0 || domain > ap_max_domain_id || 1278 !test_bit_inv(domain, ap_perms.aqm)) 1279 return -EINVAL; 1280 1281 spin_lock_bh(&ap_domain_lock); 1282 ap_domain_index = domain; 1283 spin_unlock_bh(&ap_domain_lock); 1284 1285 AP_DBF_INFO("%s stored new default domain=%d\n", 1286 __func__, domain); 1287 1288 return count; 1289 } 1290 1291 static BUS_ATTR_RW(ap_domain); 1292 1293 static ssize_t ap_control_domain_mask_show(const struct bus_type *bus, char *buf) 1294 { 1295 if (!ap_qci_info->flags) /* QCI not supported */ 1296 return sysfs_emit(buf, "not supported\n"); 1297 1298 return sysfs_emit(buf, "0x%08x%08x%08x%08x%08x%08x%08x%08x\n", 1299 ap_qci_info->adm[0], ap_qci_info->adm[1], 1300 ap_qci_info->adm[2], ap_qci_info->adm[3], 1301 ap_qci_info->adm[4], ap_qci_info->adm[5], 1302 ap_qci_info->adm[6], ap_qci_info->adm[7]); 1303 } 1304 1305 static BUS_ATTR_RO(ap_control_domain_mask); 1306 1307 static ssize_t ap_usage_domain_mask_show(const struct bus_type *bus, char *buf) 1308 { 1309 if (!ap_qci_info->flags) /* QCI not supported */ 1310 return sysfs_emit(buf, "not supported\n"); 1311 1312 return sysfs_emit(buf, "0x%08x%08x%08x%08x%08x%08x%08x%08x\n", 1313 ap_qci_info->aqm[0], ap_qci_info->aqm[1], 1314 ap_qci_info->aqm[2], ap_qci_info->aqm[3], 1315 ap_qci_info->aqm[4], ap_qci_info->aqm[5], 1316 ap_qci_info->aqm[6], ap_qci_info->aqm[7]); 1317 } 1318 1319 static BUS_ATTR_RO(ap_usage_domain_mask); 1320 1321 static ssize_t ap_adapter_mask_show(const struct bus_type *bus, char *buf) 1322 { 1323 if (!ap_qci_info->flags) /* QCI not supported */ 1324 return sysfs_emit(buf, "not supported\n"); 1325 1326 return sysfs_emit(buf, "0x%08x%08x%08x%08x%08x%08x%08x%08x\n", 1327 ap_qci_info->apm[0], ap_qci_info->apm[1], 1328 ap_qci_info->apm[2], ap_qci_info->apm[3], 1329 ap_qci_info->apm[4], ap_qci_info->apm[5], 1330 ap_qci_info->apm[6], ap_qci_info->apm[7]); 1331 } 1332 1333 static BUS_ATTR_RO(ap_adapter_mask); 1334 1335 static ssize_t ap_interrupts_show(const struct bus_type *bus, char *buf) 1336 { 1337 return sysfs_emit(buf, "%d\n", ap_irq_flag ? 1 : 0); 1338 } 1339 1340 static BUS_ATTR_RO(ap_interrupts); 1341 1342 static ssize_t config_time_show(const struct bus_type *bus, char *buf) 1343 { 1344 return sysfs_emit(buf, "%d\n", ap_scan_bus_time); 1345 } 1346 1347 static ssize_t config_time_store(const struct bus_type *bus, 1348 const char *buf, size_t count) 1349 { 1350 int time; 1351 1352 if (sscanf(buf, "%d\n", &time) != 1 || time < 5 || time > 120) 1353 return -EINVAL; 1354 ap_scan_bus_time = time; 1355 mod_timer(&ap_scan_bus_timer, jiffies + ap_scan_bus_time * HZ); 1356 return count; 1357 } 1358 1359 static BUS_ATTR_RW(config_time); 1360 1361 static ssize_t poll_thread_show(const struct bus_type *bus, char *buf) 1362 { 1363 return sysfs_emit(buf, "%d\n", ap_poll_kthread ? 1 : 0); 1364 } 1365 1366 static ssize_t poll_thread_store(const struct bus_type *bus, 1367 const char *buf, size_t count) 1368 { 1369 bool value; 1370 int rc; 1371 1372 rc = kstrtobool(buf, &value); 1373 if (rc) 1374 return rc; 1375 1376 if (value) { 1377 rc = ap_poll_thread_start(); 1378 if (rc) 1379 count = rc; 1380 } else { 1381 ap_poll_thread_stop(); 1382 } 1383 return count; 1384 } 1385 1386 static BUS_ATTR_RW(poll_thread); 1387 1388 static ssize_t poll_timeout_show(const struct bus_type *bus, char *buf) 1389 { 1390 return sysfs_emit(buf, "%lu\n", poll_high_timeout); 1391 } 1392 1393 static ssize_t poll_timeout_store(const struct bus_type *bus, const char *buf, 1394 size_t count) 1395 { 1396 unsigned long value; 1397 ktime_t hr_time; 1398 int rc; 1399 1400 rc = kstrtoul(buf, 0, &value); 1401 if (rc) 1402 return rc; 1403 1404 /* 120 seconds = maximum poll interval */ 1405 if (value > 120000000000UL) 1406 return -EINVAL; 1407 poll_high_timeout = value; 1408 hr_time = poll_high_timeout; 1409 1410 spin_lock_bh(&ap_poll_timer_lock); 1411 hrtimer_cancel(&ap_poll_timer); 1412 hrtimer_set_expires(&ap_poll_timer, hr_time); 1413 hrtimer_start_expires(&ap_poll_timer, HRTIMER_MODE_ABS); 1414 spin_unlock_bh(&ap_poll_timer_lock); 1415 1416 return count; 1417 } 1418 1419 static BUS_ATTR_RW(poll_timeout); 1420 1421 static ssize_t ap_max_domain_id_show(const struct bus_type *bus, char *buf) 1422 { 1423 return sysfs_emit(buf, "%d\n", ap_max_domain_id); 1424 } 1425 1426 static BUS_ATTR_RO(ap_max_domain_id); 1427 1428 static ssize_t ap_max_adapter_id_show(const struct bus_type *bus, char *buf) 1429 { 1430 return sysfs_emit(buf, "%d\n", ap_max_adapter_id); 1431 } 1432 1433 static BUS_ATTR_RO(ap_max_adapter_id); 1434 1435 static ssize_t apmask_show(const struct bus_type *bus, char *buf) 1436 { 1437 int rc; 1438 1439 if (mutex_lock_interruptible(&ap_perms_mutex)) 1440 return -ERESTARTSYS; 1441 rc = sysfs_emit(buf, "0x%016lx%016lx%016lx%016lx\n", 1442 ap_perms.apm[0], ap_perms.apm[1], 1443 ap_perms.apm[2], ap_perms.apm[3]); 1444 mutex_unlock(&ap_perms_mutex); 1445 1446 return rc; 1447 } 1448 1449 static int __verify_card_reservations(struct device_driver *drv, void *data) 1450 { 1451 int rc = 0; 1452 struct ap_driver *ap_drv = to_ap_drv(drv); 1453 unsigned long *newapm = (unsigned long *)data; 1454 1455 /* 1456 * increase the driver's module refcounter to be sure it is not 1457 * going away when we invoke the callback function. 1458 */ 1459 if (!try_module_get(drv->owner)) 1460 return 0; 1461 1462 if (ap_drv->in_use) { 1463 rc = ap_drv->in_use(newapm, ap_perms.aqm); 1464 if (rc) 1465 rc = -EBUSY; 1466 } 1467 1468 /* release the driver's module */ 1469 module_put(drv->owner); 1470 1471 return rc; 1472 } 1473 1474 static int apmask_commit(unsigned long *newapm) 1475 { 1476 int rc; 1477 unsigned long reserved[BITS_TO_LONGS(AP_DEVICES)]; 1478 1479 /* 1480 * Check if any bits in the apmask have been set which will 1481 * result in queues being removed from non-default drivers 1482 */ 1483 if (bitmap_andnot(reserved, newapm, ap_perms.apm, AP_DEVICES)) { 1484 rc = bus_for_each_drv(&ap_bus_type, NULL, reserved, 1485 __verify_card_reservations); 1486 if (rc) 1487 return rc; 1488 } 1489 1490 memcpy(ap_perms.apm, newapm, APMASKSIZE); 1491 1492 return 0; 1493 } 1494 1495 static ssize_t apmask_store(const struct bus_type *bus, const char *buf, 1496 size_t count) 1497 { 1498 int rc, changes = 0; 1499 DECLARE_BITMAP(newapm, AP_DEVICES); 1500 1501 if (mutex_lock_interruptible(&ap_perms_mutex)) 1502 return -ERESTARTSYS; 1503 1504 rc = ap_parse_bitmap_str(buf, ap_perms.apm, AP_DEVICES, newapm); 1505 if (rc) 1506 goto done; 1507 1508 changes = memcmp(ap_perms.apm, newapm, APMASKSIZE); 1509 if (changes) 1510 rc = apmask_commit(newapm); 1511 1512 done: 1513 mutex_unlock(&ap_perms_mutex); 1514 if (rc) 1515 return rc; 1516 1517 if (changes) { 1518 ap_bus_revise_bindings(); 1519 ap_send_mask_changed_uevent(newapm, NULL); 1520 } 1521 1522 return count; 1523 } 1524 1525 static BUS_ATTR_RW(apmask); 1526 1527 static ssize_t aqmask_show(const struct bus_type *bus, char *buf) 1528 { 1529 int rc; 1530 1531 if (mutex_lock_interruptible(&ap_perms_mutex)) 1532 return -ERESTARTSYS; 1533 rc = sysfs_emit(buf, "0x%016lx%016lx%016lx%016lx\n", 1534 ap_perms.aqm[0], ap_perms.aqm[1], 1535 ap_perms.aqm[2], ap_perms.aqm[3]); 1536 mutex_unlock(&ap_perms_mutex); 1537 1538 return rc; 1539 } 1540 1541 static int __verify_queue_reservations(struct device_driver *drv, void *data) 1542 { 1543 int rc = 0; 1544 struct ap_driver *ap_drv = to_ap_drv(drv); 1545 unsigned long *newaqm = (unsigned long *)data; 1546 1547 /* 1548 * increase the driver's module refcounter to be sure it is not 1549 * going away when we invoke the callback function. 1550 */ 1551 if (!try_module_get(drv->owner)) 1552 return 0; 1553 1554 if (ap_drv->in_use) { 1555 rc = ap_drv->in_use(ap_perms.apm, newaqm); 1556 if (rc) 1557 rc = -EBUSY; 1558 } 1559 1560 /* release the driver's module */ 1561 module_put(drv->owner); 1562 1563 return rc; 1564 } 1565 1566 static int aqmask_commit(unsigned long *newaqm) 1567 { 1568 int rc; 1569 unsigned long reserved[BITS_TO_LONGS(AP_DOMAINS)]; 1570 1571 /* 1572 * Check if any bits in the aqmask have been set which will 1573 * result in queues being removed from non-default drivers 1574 */ 1575 if (bitmap_andnot(reserved, newaqm, ap_perms.aqm, AP_DOMAINS)) { 1576 rc = bus_for_each_drv(&ap_bus_type, NULL, reserved, 1577 __verify_queue_reservations); 1578 if (rc) 1579 return rc; 1580 } 1581 1582 memcpy(ap_perms.aqm, newaqm, AQMASKSIZE); 1583 1584 return 0; 1585 } 1586 1587 static ssize_t aqmask_store(const struct bus_type *bus, const char *buf, 1588 size_t count) 1589 { 1590 int rc, changes = 0; 1591 DECLARE_BITMAP(newaqm, AP_DOMAINS); 1592 1593 if (mutex_lock_interruptible(&ap_perms_mutex)) 1594 return -ERESTARTSYS; 1595 1596 rc = ap_parse_bitmap_str(buf, ap_perms.aqm, AP_DOMAINS, newaqm); 1597 if (rc) 1598 goto done; 1599 1600 changes = memcmp(ap_perms.aqm, newaqm, APMASKSIZE); 1601 if (changes) 1602 rc = aqmask_commit(newaqm); 1603 1604 done: 1605 mutex_unlock(&ap_perms_mutex); 1606 if (rc) 1607 return rc; 1608 1609 if (changes) { 1610 ap_bus_revise_bindings(); 1611 ap_send_mask_changed_uevent(NULL, newaqm); 1612 } 1613 1614 return count; 1615 } 1616 1617 static BUS_ATTR_RW(aqmask); 1618 1619 static ssize_t scans_show(const struct bus_type *bus, char *buf) 1620 { 1621 return sysfs_emit(buf, "%llu\n", atomic64_read(&ap_scan_bus_count)); 1622 } 1623 1624 static ssize_t scans_store(const struct bus_type *bus, const char *buf, 1625 size_t count) 1626 { 1627 AP_DBF_INFO("%s force AP bus rescan\n", __func__); 1628 1629 ap_bus_force_rescan(); 1630 1631 return count; 1632 } 1633 1634 static BUS_ATTR_RW(scans); 1635 1636 static ssize_t bindings_show(const struct bus_type *bus, char *buf) 1637 { 1638 int rc; 1639 unsigned int apqns, n; 1640 1641 ap_calc_bound_apqns(&apqns, &n); 1642 if (atomic64_read(&ap_scan_bus_count) >= 1 && n == apqns) 1643 rc = sysfs_emit(buf, "%u/%u (complete)\n", n, apqns); 1644 else 1645 rc = sysfs_emit(buf, "%u/%u\n", n, apqns); 1646 1647 return rc; 1648 } 1649 1650 static BUS_ATTR_RO(bindings); 1651 1652 static ssize_t features_show(const struct bus_type *bus, char *buf) 1653 { 1654 int n = 0; 1655 1656 if (!ap_qci_info->flags) /* QCI not supported */ 1657 return sysfs_emit(buf, "-\n"); 1658 1659 if (ap_qci_info->apsc) 1660 n += sysfs_emit_at(buf, n, "APSC "); 1661 if (ap_qci_info->apxa) 1662 n += sysfs_emit_at(buf, n, "APXA "); 1663 if (ap_qci_info->qact) 1664 n += sysfs_emit_at(buf, n, "QACT "); 1665 if (ap_qci_info->rc8a) 1666 n += sysfs_emit_at(buf, n, "RC8A "); 1667 if (ap_qci_info->apsb) 1668 n += sysfs_emit_at(buf, n, "APSB "); 1669 1670 sysfs_emit_at(buf, n == 0 ? 0 : n - 1, "\n"); 1671 1672 return n; 1673 } 1674 1675 static BUS_ATTR_RO(features); 1676 1677 static struct attribute *ap_bus_attrs[] = { 1678 &bus_attr_ap_domain.attr, 1679 &bus_attr_ap_control_domain_mask.attr, 1680 &bus_attr_ap_usage_domain_mask.attr, 1681 &bus_attr_ap_adapter_mask.attr, 1682 &bus_attr_config_time.attr, 1683 &bus_attr_poll_thread.attr, 1684 &bus_attr_ap_interrupts.attr, 1685 &bus_attr_poll_timeout.attr, 1686 &bus_attr_ap_max_domain_id.attr, 1687 &bus_attr_ap_max_adapter_id.attr, 1688 &bus_attr_apmask.attr, 1689 &bus_attr_aqmask.attr, 1690 &bus_attr_scans.attr, 1691 &bus_attr_bindings.attr, 1692 &bus_attr_features.attr, 1693 NULL, 1694 }; 1695 ATTRIBUTE_GROUPS(ap_bus); 1696 1697 static const struct bus_type ap_bus_type = { 1698 .name = "ap", 1699 .bus_groups = ap_bus_groups, 1700 .match = &ap_bus_match, 1701 .uevent = &ap_uevent, 1702 .probe = ap_device_probe, 1703 .remove = ap_device_remove, 1704 }; 1705 1706 /** 1707 * ap_select_domain(): Select an AP domain if possible and we haven't 1708 * already done so before. 1709 */ 1710 static void ap_select_domain(void) 1711 { 1712 struct ap_queue_status status; 1713 int card, dom; 1714 1715 /* 1716 * Choose the default domain. Either the one specified with 1717 * the "domain=" parameter or the first domain with at least 1718 * one valid APQN. 1719 */ 1720 spin_lock_bh(&ap_domain_lock); 1721 if (ap_domain_index >= 0) { 1722 /* Domain has already been selected. */ 1723 goto out; 1724 } 1725 for (dom = 0; dom <= ap_max_domain_id; dom++) { 1726 if (!ap_test_config_usage_domain(dom) || 1727 !test_bit_inv(dom, ap_perms.aqm)) 1728 continue; 1729 for (card = 0; card <= ap_max_adapter_id; card++) { 1730 if (!ap_test_config_card_id(card) || 1731 !test_bit_inv(card, ap_perms.apm)) 1732 continue; 1733 status = ap_test_queue(AP_MKQID(card, dom), 1734 ap_apft_available(), 1735 NULL); 1736 if (status.response_code == AP_RESPONSE_NORMAL) 1737 break; 1738 } 1739 if (card <= ap_max_adapter_id) 1740 break; 1741 } 1742 if (dom <= ap_max_domain_id) { 1743 ap_domain_index = dom; 1744 AP_DBF_INFO("%s new default domain is %d\n", 1745 __func__, ap_domain_index); 1746 } 1747 out: 1748 spin_unlock_bh(&ap_domain_lock); 1749 } 1750 1751 /* 1752 * This function checks the type and returns either 0 for not 1753 * supported or the highest compatible type value (which may 1754 * include the input type value). 1755 */ 1756 static int ap_get_compatible_type(ap_qid_t qid, int rawtype, unsigned int func) 1757 { 1758 int comp_type = 0; 1759 1760 /* < CEX4 is not supported */ 1761 if (rawtype < AP_DEVICE_TYPE_CEX4) { 1762 AP_DBF_WARN("%s queue=%02x.%04x unsupported type %d\n", 1763 __func__, AP_QID_CARD(qid), 1764 AP_QID_QUEUE(qid), rawtype); 1765 return 0; 1766 } 1767 /* up to CEX8 known and fully supported */ 1768 if (rawtype <= AP_DEVICE_TYPE_CEX8) 1769 return rawtype; 1770 /* 1771 * unknown new type > CEX8, check for compatibility 1772 * to the highest known and supported type which is 1773 * currently CEX8 with the help of the QACT function. 1774 */ 1775 if (ap_qact_available()) { 1776 struct ap_queue_status status; 1777 union ap_qact_ap_info apinfo = {0}; 1778 1779 apinfo.mode = (func >> 26) & 0x07; 1780 apinfo.cat = AP_DEVICE_TYPE_CEX8; 1781 status = ap_qact(qid, 0, &apinfo); 1782 if (status.response_code == AP_RESPONSE_NORMAL && 1783 apinfo.cat >= AP_DEVICE_TYPE_CEX4 && 1784 apinfo.cat <= AP_DEVICE_TYPE_CEX8) 1785 comp_type = apinfo.cat; 1786 } 1787 if (!comp_type) 1788 AP_DBF_WARN("%s queue=%02x.%04x unable to map type %d\n", 1789 __func__, AP_QID_CARD(qid), 1790 AP_QID_QUEUE(qid), rawtype); 1791 else if (comp_type != rawtype) 1792 AP_DBF_INFO("%s queue=%02x.%04x map type %d to %d\n", 1793 __func__, AP_QID_CARD(qid), AP_QID_QUEUE(qid), 1794 rawtype, comp_type); 1795 return comp_type; 1796 } 1797 1798 /* 1799 * Helper function to be used with bus_find_dev 1800 * matches for the card device with the given id 1801 */ 1802 static int __match_card_device_with_id(struct device *dev, const void *data) 1803 { 1804 return is_card_dev(dev) && to_ap_card(dev)->id == (int)(long)(void *)data; 1805 } 1806 1807 /* 1808 * Helper function to be used with bus_find_dev 1809 * matches for the queue device with a given qid 1810 */ 1811 static int __match_queue_device_with_qid(struct device *dev, const void *data) 1812 { 1813 return is_queue_dev(dev) && to_ap_queue(dev)->qid == (int)(long)data; 1814 } 1815 1816 /* 1817 * Helper function to be used with bus_find_dev 1818 * matches any queue device with given queue id 1819 */ 1820 static int __match_queue_device_with_queue_id(struct device *dev, const void *data) 1821 { 1822 return is_queue_dev(dev) && 1823 AP_QID_QUEUE(to_ap_queue(dev)->qid) == (int)(long)data; 1824 } 1825 1826 /* Helper function for notify_config_changed */ 1827 static int __drv_notify_config_changed(struct device_driver *drv, void *data) 1828 { 1829 struct ap_driver *ap_drv = to_ap_drv(drv); 1830 1831 if (try_module_get(drv->owner)) { 1832 if (ap_drv->on_config_changed) 1833 ap_drv->on_config_changed(ap_qci_info, ap_qci_info_old); 1834 module_put(drv->owner); 1835 } 1836 1837 return 0; 1838 } 1839 1840 /* Notify all drivers about an qci config change */ 1841 static inline void notify_config_changed(void) 1842 { 1843 bus_for_each_drv(&ap_bus_type, NULL, NULL, 1844 __drv_notify_config_changed); 1845 } 1846 1847 /* Helper function for notify_scan_complete */ 1848 static int __drv_notify_scan_complete(struct device_driver *drv, void *data) 1849 { 1850 struct ap_driver *ap_drv = to_ap_drv(drv); 1851 1852 if (try_module_get(drv->owner)) { 1853 if (ap_drv->on_scan_complete) 1854 ap_drv->on_scan_complete(ap_qci_info, 1855 ap_qci_info_old); 1856 module_put(drv->owner); 1857 } 1858 1859 return 0; 1860 } 1861 1862 /* Notify all drivers about bus scan complete */ 1863 static inline void notify_scan_complete(void) 1864 { 1865 bus_for_each_drv(&ap_bus_type, NULL, NULL, 1866 __drv_notify_scan_complete); 1867 } 1868 1869 /* 1870 * Helper function for ap_scan_bus(). 1871 * Remove card device and associated queue devices. 1872 */ 1873 static inline void ap_scan_rm_card_dev_and_queue_devs(struct ap_card *ac) 1874 { 1875 bus_for_each_dev(&ap_bus_type, NULL, 1876 (void *)(long)ac->id, 1877 __ap_queue_devices_with_id_unregister); 1878 device_unregister(&ac->ap_dev.device); 1879 } 1880 1881 /* 1882 * Helper function for ap_scan_bus(). 1883 * Does the scan bus job for all the domains within 1884 * a valid adapter given by an ap_card ptr. 1885 */ 1886 static inline void ap_scan_domains(struct ap_card *ac) 1887 { 1888 struct ap_tapq_hwinfo hwinfo; 1889 bool decfg, chkstop; 1890 struct ap_queue *aq; 1891 struct device *dev; 1892 ap_qid_t qid; 1893 int rc, dom; 1894 1895 /* 1896 * Go through the configuration for the domains and compare them 1897 * to the existing queue devices. Also take care of the config 1898 * and error state for the queue devices. 1899 */ 1900 1901 for (dom = 0; dom <= ap_max_domain_id; dom++) { 1902 qid = AP_MKQID(ac->id, dom); 1903 dev = bus_find_device(&ap_bus_type, NULL, 1904 (void *)(long)qid, 1905 __match_queue_device_with_qid); 1906 aq = dev ? to_ap_queue(dev) : NULL; 1907 if (!ap_test_config_usage_domain(dom)) { 1908 if (dev) { 1909 AP_DBF_INFO("%s(%d,%d) not in config anymore, rm queue dev\n", 1910 __func__, ac->id, dom); 1911 device_unregister(dev); 1912 } 1913 goto put_dev_and_continue; 1914 } 1915 /* domain is valid, get info from this APQN */ 1916 rc = ap_queue_info(qid, &hwinfo, &decfg, &chkstop); 1917 switch (rc) { 1918 case -1: 1919 if (dev) { 1920 AP_DBF_INFO("%s(%d,%d) queue_info() failed, rm queue dev\n", 1921 __func__, ac->id, dom); 1922 device_unregister(dev); 1923 } 1924 fallthrough; 1925 case 0: 1926 goto put_dev_and_continue; 1927 default: 1928 break; 1929 } 1930 /* if no queue device exists, create a new one */ 1931 if (!aq) { 1932 aq = ap_queue_create(qid, ac); 1933 if (!aq) { 1934 AP_DBF_WARN("%s(%d,%d) ap_queue_create() failed\n", 1935 __func__, ac->id, dom); 1936 continue; 1937 } 1938 aq->config = !decfg; 1939 aq->chkstop = chkstop; 1940 aq->se_bstate = hwinfo.bs; 1941 dev = &aq->ap_dev.device; 1942 dev->bus = &ap_bus_type; 1943 dev->parent = &ac->ap_dev.device; 1944 dev_set_name(dev, "%02x.%04x", ac->id, dom); 1945 /* register queue device */ 1946 rc = device_register(dev); 1947 if (rc) { 1948 AP_DBF_WARN("%s(%d,%d) device_register() failed\n", 1949 __func__, ac->id, dom); 1950 goto put_dev_and_continue; 1951 } 1952 /* get it and thus adjust reference counter */ 1953 get_device(dev); 1954 if (decfg) { 1955 AP_DBF_INFO("%s(%d,%d) new (decfg) queue dev created\n", 1956 __func__, ac->id, dom); 1957 } else if (chkstop) { 1958 AP_DBF_INFO("%s(%d,%d) new (chkstop) queue dev created\n", 1959 __func__, ac->id, dom); 1960 } else { 1961 /* nudge the queue's state machine */ 1962 ap_queue_init_state(aq); 1963 AP_DBF_INFO("%s(%d,%d) new queue dev created\n", 1964 __func__, ac->id, dom); 1965 } 1966 goto put_dev_and_continue; 1967 } 1968 /* handle state changes on already existing queue device */ 1969 spin_lock_bh(&aq->lock); 1970 /* SE bind state */ 1971 aq->se_bstate = hwinfo.bs; 1972 /* checkstop state */ 1973 if (chkstop && !aq->chkstop) { 1974 /* checkstop on */ 1975 aq->chkstop = true; 1976 if (aq->dev_state > AP_DEV_STATE_UNINITIATED) { 1977 aq->dev_state = AP_DEV_STATE_ERROR; 1978 aq->last_err_rc = AP_RESPONSE_CHECKSTOPPED; 1979 } 1980 spin_unlock_bh(&aq->lock); 1981 pr_debug("(%d,%d) queue dev checkstop on\n", 1982 ac->id, dom); 1983 /* 'receive' pending messages with -EAGAIN */ 1984 ap_flush_queue(aq); 1985 goto put_dev_and_continue; 1986 } else if (!chkstop && aq->chkstop) { 1987 /* checkstop off */ 1988 aq->chkstop = false; 1989 if (aq->dev_state > AP_DEV_STATE_UNINITIATED) 1990 _ap_queue_init_state(aq); 1991 spin_unlock_bh(&aq->lock); 1992 pr_debug("(%d,%d) queue dev checkstop off\n", 1993 ac->id, dom); 1994 goto put_dev_and_continue; 1995 } 1996 /* config state change */ 1997 if (decfg && aq->config) { 1998 /* config off this queue device */ 1999 aq->config = false; 2000 if (aq->dev_state > AP_DEV_STATE_UNINITIATED) { 2001 aq->dev_state = AP_DEV_STATE_ERROR; 2002 aq->last_err_rc = AP_RESPONSE_DECONFIGURED; 2003 } 2004 spin_unlock_bh(&aq->lock); 2005 pr_debug("(%d,%d) queue dev config off\n", 2006 ac->id, dom); 2007 ap_send_config_uevent(&aq->ap_dev, aq->config); 2008 /* 'receive' pending messages with -EAGAIN */ 2009 ap_flush_queue(aq); 2010 goto put_dev_and_continue; 2011 } else if (!decfg && !aq->config) { 2012 /* config on this queue device */ 2013 aq->config = true; 2014 if (aq->dev_state > AP_DEV_STATE_UNINITIATED) 2015 _ap_queue_init_state(aq); 2016 spin_unlock_bh(&aq->lock); 2017 pr_debug("(%d,%d) queue dev config on\n", 2018 ac->id, dom); 2019 ap_send_config_uevent(&aq->ap_dev, aq->config); 2020 goto put_dev_and_continue; 2021 } 2022 /* handle other error states */ 2023 if (!decfg && aq->dev_state == AP_DEV_STATE_ERROR) { 2024 spin_unlock_bh(&aq->lock); 2025 /* 'receive' pending messages with -EAGAIN */ 2026 ap_flush_queue(aq); 2027 /* re-init (with reset) the queue device */ 2028 ap_queue_init_state(aq); 2029 AP_DBF_INFO("%s(%d,%d) queue dev reinit enforced\n", 2030 __func__, ac->id, dom); 2031 goto put_dev_and_continue; 2032 } 2033 spin_unlock_bh(&aq->lock); 2034 put_dev_and_continue: 2035 put_device(dev); 2036 } 2037 } 2038 2039 /* 2040 * Helper function for ap_scan_bus(). 2041 * Does the scan bus job for the given adapter id. 2042 */ 2043 static inline void ap_scan_adapter(int ap) 2044 { 2045 struct ap_tapq_hwinfo hwinfo; 2046 int rc, dom, comp_type; 2047 bool decfg, chkstop; 2048 struct ap_card *ac; 2049 struct device *dev; 2050 ap_qid_t qid; 2051 2052 /* Is there currently a card device for this adapter ? */ 2053 dev = bus_find_device(&ap_bus_type, NULL, 2054 (void *)(long)ap, 2055 __match_card_device_with_id); 2056 ac = dev ? to_ap_card(dev) : NULL; 2057 2058 /* Adapter not in configuration ? */ 2059 if (!ap_test_config_card_id(ap)) { 2060 if (ac) { 2061 AP_DBF_INFO("%s(%d) ap not in config any more, rm card and queue devs\n", 2062 __func__, ap); 2063 ap_scan_rm_card_dev_and_queue_devs(ac); 2064 put_device(dev); 2065 } 2066 return; 2067 } 2068 2069 /* 2070 * Adapter ap is valid in the current configuration. So do some checks: 2071 * If no card device exists, build one. If a card device exists, check 2072 * for type and functions changed. For all this we need to find a valid 2073 * APQN first. 2074 */ 2075 2076 for (dom = 0; dom <= ap_max_domain_id; dom++) 2077 if (ap_test_config_usage_domain(dom)) { 2078 qid = AP_MKQID(ap, dom); 2079 if (ap_queue_info(qid, &hwinfo, &decfg, &chkstop) > 0) 2080 break; 2081 } 2082 if (dom > ap_max_domain_id) { 2083 /* Could not find one valid APQN for this adapter */ 2084 if (ac) { 2085 AP_DBF_INFO("%s(%d) no type info (no APQN found), rm card and queue devs\n", 2086 __func__, ap); 2087 ap_scan_rm_card_dev_and_queue_devs(ac); 2088 put_device(dev); 2089 } else { 2090 pr_debug("(%d) no type info (no APQN found), ignored\n", 2091 ap); 2092 } 2093 return; 2094 } 2095 if (!hwinfo.at) { 2096 /* No apdater type info available, an unusable adapter */ 2097 if (ac) { 2098 AP_DBF_INFO("%s(%d) no valid type (0) info, rm card and queue devs\n", 2099 __func__, ap); 2100 ap_scan_rm_card_dev_and_queue_devs(ac); 2101 put_device(dev); 2102 } else { 2103 pr_debug("(%d) no valid type (0) info, ignored\n", ap); 2104 } 2105 return; 2106 } 2107 hwinfo.value &= TAPQ_CARD_HWINFO_MASK; /* filter card specific hwinfo */ 2108 if (ac) { 2109 /* Check APQN against existing card device for changes */ 2110 if (ac->hwinfo.at != hwinfo.at) { 2111 AP_DBF_INFO("%s(%d) hwtype %d changed, rm card and queue devs\n", 2112 __func__, ap, hwinfo.at); 2113 ap_scan_rm_card_dev_and_queue_devs(ac); 2114 put_device(dev); 2115 ac = NULL; 2116 } else if (ac->hwinfo.fac != hwinfo.fac) { 2117 AP_DBF_INFO("%s(%d) functions 0x%08x changed, rm card and queue devs\n", 2118 __func__, ap, hwinfo.fac); 2119 ap_scan_rm_card_dev_and_queue_devs(ac); 2120 put_device(dev); 2121 ac = NULL; 2122 } else { 2123 /* handle checkstop state change */ 2124 if (chkstop && !ac->chkstop) { 2125 /* checkstop on */ 2126 ac->chkstop = true; 2127 AP_DBF_INFO("%s(%d) card dev checkstop on\n", 2128 __func__, ap); 2129 } else if (!chkstop && ac->chkstop) { 2130 /* checkstop off */ 2131 ac->chkstop = false; 2132 AP_DBF_INFO("%s(%d) card dev checkstop off\n", 2133 __func__, ap); 2134 } 2135 /* handle config state change */ 2136 if (decfg && ac->config) { 2137 ac->config = false; 2138 AP_DBF_INFO("%s(%d) card dev config off\n", 2139 __func__, ap); 2140 ap_send_config_uevent(&ac->ap_dev, ac->config); 2141 } else if (!decfg && !ac->config) { 2142 ac->config = true; 2143 AP_DBF_INFO("%s(%d) card dev config on\n", 2144 __func__, ap); 2145 ap_send_config_uevent(&ac->ap_dev, ac->config); 2146 } 2147 } 2148 } 2149 2150 if (!ac) { 2151 /* Build a new card device */ 2152 comp_type = ap_get_compatible_type(qid, hwinfo.at, hwinfo.fac); 2153 if (!comp_type) { 2154 AP_DBF_WARN("%s(%d) type %d, can't get compatibility type\n", 2155 __func__, ap, hwinfo.at); 2156 return; 2157 } 2158 ac = ap_card_create(ap, hwinfo, comp_type); 2159 if (!ac) { 2160 AP_DBF_WARN("%s(%d) ap_card_create() failed\n", 2161 __func__, ap); 2162 return; 2163 } 2164 ac->config = !decfg; 2165 ac->chkstop = chkstop; 2166 dev = &ac->ap_dev.device; 2167 dev->bus = &ap_bus_type; 2168 dev->parent = ap_root_device; 2169 dev_set_name(dev, "card%02x", ap); 2170 /* maybe enlarge ap_max_msg_size to support this card */ 2171 if (ac->maxmsgsize > atomic_read(&ap_max_msg_size)) { 2172 atomic_set(&ap_max_msg_size, ac->maxmsgsize); 2173 AP_DBF_INFO("%s(%d) ap_max_msg_size update to %d byte\n", 2174 __func__, ap, 2175 atomic_read(&ap_max_msg_size)); 2176 } 2177 /* Register the new card device with AP bus */ 2178 rc = device_register(dev); 2179 if (rc) { 2180 AP_DBF_WARN("%s(%d) device_register() failed\n", 2181 __func__, ap); 2182 put_device(dev); 2183 return; 2184 } 2185 /* get it and thus adjust reference counter */ 2186 get_device(dev); 2187 if (decfg) 2188 AP_DBF_INFO("%s(%d) new (decfg) card dev type=%d func=0x%08x created\n", 2189 __func__, ap, hwinfo.at, hwinfo.fac); 2190 else if (chkstop) 2191 AP_DBF_INFO("%s(%d) new (chkstop) card dev type=%d func=0x%08x created\n", 2192 __func__, ap, hwinfo.at, hwinfo.fac); 2193 else 2194 AP_DBF_INFO("%s(%d) new card dev type=%d func=0x%08x created\n", 2195 __func__, ap, hwinfo.at, hwinfo.fac); 2196 } 2197 2198 /* Verify the domains and the queue devices for this card */ 2199 ap_scan_domains(ac); 2200 2201 /* release the card device */ 2202 put_device(&ac->ap_dev.device); 2203 } 2204 2205 /** 2206 * ap_get_configuration - get the host AP configuration 2207 * 2208 * Stores the host AP configuration information returned from the previous call 2209 * to Query Configuration Information (QCI), then retrieves and stores the 2210 * current AP configuration returned from QCI. 2211 * 2212 * Return: true if the host AP configuration changed between calls to QCI; 2213 * otherwise, return false. 2214 */ 2215 static bool ap_get_configuration(void) 2216 { 2217 if (!ap_qci_info->flags) /* QCI not supported */ 2218 return false; 2219 2220 memcpy(ap_qci_info_old, ap_qci_info, sizeof(*ap_qci_info)); 2221 ap_qci(ap_qci_info); 2222 2223 return memcmp(ap_qci_info, ap_qci_info_old, 2224 sizeof(struct ap_config_info)) != 0; 2225 } 2226 2227 /* 2228 * ap_config_has_new_aps - Check current against old qci info if 2229 * new adapters have appeared. Returns true if at least one new 2230 * adapter in the apm mask is showing up. Existing adapters or 2231 * receding adapters are not counted. 2232 */ 2233 static bool ap_config_has_new_aps(void) 2234 { 2235 2236 unsigned long m[BITS_TO_LONGS(AP_DEVICES)]; 2237 2238 if (!ap_qci_info->flags) 2239 return false; 2240 2241 bitmap_andnot(m, (unsigned long *)ap_qci_info->apm, 2242 (unsigned long *)ap_qci_info_old->apm, AP_DEVICES); 2243 if (!bitmap_empty(m, AP_DEVICES)) 2244 return true; 2245 2246 return false; 2247 } 2248 2249 /* 2250 * ap_config_has_new_doms - Check current against old qci info if 2251 * new (usage) domains have appeared. Returns true if at least one 2252 * new domain in the aqm mask is showing up. Existing domains or 2253 * receding domains are not counted. 2254 */ 2255 static bool ap_config_has_new_doms(void) 2256 { 2257 unsigned long m[BITS_TO_LONGS(AP_DOMAINS)]; 2258 2259 if (!ap_qci_info->flags) 2260 return false; 2261 2262 bitmap_andnot(m, (unsigned long *)ap_qci_info->aqm, 2263 (unsigned long *)ap_qci_info_old->aqm, AP_DOMAINS); 2264 if (!bitmap_empty(m, AP_DOMAINS)) 2265 return true; 2266 2267 return false; 2268 } 2269 2270 /** 2271 * ap_scan_bus(): Scan the AP bus for new devices 2272 * Always run under mutex ap_scan_bus_mutex protection 2273 * which needs to get locked/unlocked by the caller! 2274 * Returns true if any config change has been detected 2275 * during the scan, otherwise false. 2276 */ 2277 static bool ap_scan_bus(void) 2278 { 2279 bool config_changed; 2280 int ap; 2281 2282 pr_debug(">\n"); 2283 2284 /* (re-)fetch configuration via QCI */ 2285 config_changed = ap_get_configuration(); 2286 if (config_changed) { 2287 if (ap_config_has_new_aps() || ap_config_has_new_doms()) { 2288 /* 2289 * Appearance of new adapters and/or domains need to 2290 * build new ap devices which need to get bound to an 2291 * device driver. Thus reset the APQN bindings complete 2292 * completion. 2293 */ 2294 reinit_completion(&ap_apqn_bindings_complete); 2295 } 2296 /* post a config change notify */ 2297 notify_config_changed(); 2298 } 2299 ap_select_domain(); 2300 2301 /* loop over all possible adapters */ 2302 for (ap = 0; ap <= ap_max_adapter_id; ap++) 2303 ap_scan_adapter(ap); 2304 2305 /* scan complete notify */ 2306 if (config_changed) 2307 notify_scan_complete(); 2308 2309 /* check if there is at least one queue available with default domain */ 2310 if (ap_domain_index >= 0) { 2311 struct device *dev = 2312 bus_find_device(&ap_bus_type, NULL, 2313 (void *)(long)ap_domain_index, 2314 __match_queue_device_with_queue_id); 2315 if (dev) 2316 put_device(dev); 2317 else 2318 AP_DBF_INFO("%s no queue device with default domain %d available\n", 2319 __func__, ap_domain_index); 2320 } 2321 2322 if (atomic64_inc_return(&ap_scan_bus_count) == 1) { 2323 pr_debug("init scan complete\n"); 2324 ap_send_init_scan_done_uevent(); 2325 } 2326 2327 ap_check_bindings_complete(); 2328 2329 mod_timer(&ap_scan_bus_timer, jiffies + ap_scan_bus_time * HZ); 2330 2331 pr_debug("< config_changed=%d\n", config_changed); 2332 2333 return config_changed; 2334 } 2335 2336 /* 2337 * Callback for the ap_scan_bus_timer 2338 * Runs periodically, workqueue timer (ap_scan_bus_time) 2339 */ 2340 static void ap_scan_bus_timer_callback(struct timer_list *unused) 2341 { 2342 /* 2343 * schedule work into the system long wq which when 2344 * the work is finally executed, calls the AP bus scan. 2345 */ 2346 queue_work(system_long_wq, &ap_scan_bus_work); 2347 } 2348 2349 /* 2350 * Callback for the ap_scan_bus_work 2351 */ 2352 static void ap_scan_bus_wq_callback(struct work_struct *unused) 2353 { 2354 /* 2355 * Try to invoke an ap_scan_bus(). If the mutex acquisition 2356 * fails there is currently another task already running the 2357 * AP scan bus and there is no need to wait and re-trigger the 2358 * scan again. Please note at the end of the scan bus function 2359 * the AP scan bus timer is re-armed which triggers then the 2360 * ap_scan_bus_timer_callback which enqueues a work into the 2361 * system_long_wq which invokes this function here again. 2362 */ 2363 if (mutex_trylock(&ap_scan_bus_mutex)) { 2364 ap_scan_bus_task = current; 2365 ap_scan_bus_result = ap_scan_bus(); 2366 ap_scan_bus_task = NULL; 2367 mutex_unlock(&ap_scan_bus_mutex); 2368 } 2369 } 2370 2371 static inline void __exit ap_async_exit(void) 2372 { 2373 if (ap_thread_flag) 2374 ap_poll_thread_stop(); 2375 chsc_notifier_unregister(&ap_bus_nb); 2376 cancel_work(&ap_scan_bus_work); 2377 hrtimer_cancel(&ap_poll_timer); 2378 timer_delete(&ap_scan_bus_timer); 2379 } 2380 2381 static inline int __init ap_async_init(void) 2382 { 2383 int rc; 2384 2385 /* Setup the AP bus rescan timer. */ 2386 timer_setup(&ap_scan_bus_timer, ap_scan_bus_timer_callback, 0); 2387 2388 /* 2389 * Setup the high resolution poll timer. 2390 * If we are running under z/VM adjust polling to z/VM polling rate. 2391 */ 2392 if (machine_is_vm()) 2393 poll_high_timeout = 1500000; 2394 hrtimer_setup(&ap_poll_timer, ap_poll_timeout, CLOCK_MONOTONIC, HRTIMER_MODE_ABS); 2395 2396 queue_work(system_long_wq, &ap_scan_bus_work); 2397 2398 rc = chsc_notifier_register(&ap_bus_nb); 2399 if (rc) 2400 goto out; 2401 2402 /* Start the low priority AP bus poll thread. */ 2403 if (!ap_thread_flag) 2404 return 0; 2405 2406 rc = ap_poll_thread_start(); 2407 if (rc) 2408 goto out_notifier; 2409 2410 return 0; 2411 2412 out_notifier: 2413 chsc_notifier_unregister(&ap_bus_nb); 2414 out: 2415 cancel_work(&ap_scan_bus_work); 2416 hrtimer_cancel(&ap_poll_timer); 2417 timer_delete(&ap_scan_bus_timer); 2418 return rc; 2419 } 2420 2421 static inline void ap_irq_exit(void) 2422 { 2423 if (ap_irq_flag) 2424 unregister_adapter_interrupt(&ap_airq); 2425 } 2426 2427 static inline int __init ap_irq_init(void) 2428 { 2429 int rc; 2430 2431 if (!ap_interrupts_available() || !ap_useirq) 2432 return 0; 2433 2434 rc = register_adapter_interrupt(&ap_airq); 2435 ap_irq_flag = (rc == 0); 2436 2437 return rc; 2438 } 2439 2440 static inline void ap_debug_exit(void) 2441 { 2442 debug_unregister(ap_dbf_info); 2443 } 2444 2445 static inline int __init ap_debug_init(void) 2446 { 2447 ap_dbf_info = debug_register("ap", 2, 1, 2448 AP_DBF_MAX_SPRINTF_ARGS * sizeof(long)); 2449 debug_register_view(ap_dbf_info, &debug_sprintf_view); 2450 debug_set_level(ap_dbf_info, DBF_ERR); 2451 2452 return 0; 2453 } 2454 2455 static void __init ap_perms_init(void) 2456 { 2457 /* all resources usable if no kernel parameter string given */ 2458 memset(&ap_perms.ioctlm, 0xFF, sizeof(ap_perms.ioctlm)); 2459 memset(&ap_perms.apm, 0xFF, sizeof(ap_perms.apm)); 2460 memset(&ap_perms.aqm, 0xFF, sizeof(ap_perms.aqm)); 2461 2462 /* apm kernel parameter string */ 2463 if (apm_str) { 2464 memset(&ap_perms.apm, 0, sizeof(ap_perms.apm)); 2465 ap_parse_mask_str(apm_str, ap_perms.apm, AP_DEVICES, 2466 &ap_perms_mutex); 2467 } 2468 2469 /* aqm kernel parameter string */ 2470 if (aqm_str) { 2471 memset(&ap_perms.aqm, 0, sizeof(ap_perms.aqm)); 2472 ap_parse_mask_str(aqm_str, ap_perms.aqm, AP_DOMAINS, 2473 &ap_perms_mutex); 2474 } 2475 } 2476 2477 /** 2478 * ap_module_init(): The module initialization code. 2479 * 2480 * Initializes the module. 2481 */ 2482 static int __init ap_module_init(void) 2483 { 2484 int rc; 2485 2486 rc = ap_debug_init(); 2487 if (rc) 2488 return rc; 2489 2490 if (!ap_instructions_available()) { 2491 pr_warn("The hardware system does not support AP instructions\n"); 2492 return -ENODEV; 2493 } 2494 2495 /* init ap_queue hashtable */ 2496 hash_init(ap_queues); 2497 2498 /* create ap msg buffer memory pool */ 2499 ap_msg_pool = mempool_create_kmalloc_pool(ap_msg_pool_min_items, 2500 AP_DEFAULT_MAX_MSG_SIZE); 2501 if (!ap_msg_pool) { 2502 rc = -ENOMEM; 2503 goto out; 2504 } 2505 2506 /* set up the AP permissions (ioctls, ap and aq masks) */ 2507 ap_perms_init(); 2508 2509 /* Get AP configuration data if available */ 2510 ap_init_qci_info(); 2511 2512 /* check default domain setting */ 2513 if (ap_domain_index < -1 || ap_domain_index > ap_max_domain_id || 2514 (ap_domain_index >= 0 && 2515 !test_bit_inv(ap_domain_index, ap_perms.aqm))) { 2516 pr_warn("%d is not a valid cryptographic domain\n", 2517 ap_domain_index); 2518 ap_domain_index = -1; 2519 } 2520 2521 /* Create /sys/bus/ap. */ 2522 rc = bus_register(&ap_bus_type); 2523 if (rc) 2524 goto out; 2525 2526 /* Create /sys/devices/ap. */ 2527 ap_root_device = root_device_register("ap"); 2528 rc = PTR_ERR_OR_ZERO(ap_root_device); 2529 if (rc) 2530 goto out_bus; 2531 ap_root_device->bus = &ap_bus_type; 2532 2533 /* enable interrupts if available */ 2534 rc = ap_irq_init(); 2535 if (rc) 2536 goto out_device; 2537 2538 /* Setup asynchronous work (timers, workqueue, etc). */ 2539 rc = ap_async_init(); 2540 if (rc) 2541 goto out_irq; 2542 2543 return 0; 2544 2545 out_irq: 2546 ap_irq_exit(); 2547 out_device: 2548 root_device_unregister(ap_root_device); 2549 out_bus: 2550 bus_unregister(&ap_bus_type); 2551 out: 2552 mempool_destroy(ap_msg_pool); 2553 ap_debug_exit(); 2554 return rc; 2555 } 2556 2557 static void __exit ap_module_exit(void) 2558 { 2559 ap_async_exit(); 2560 ap_irq_exit(); 2561 root_device_unregister(ap_root_device); 2562 bus_unregister(&ap_bus_type); 2563 mempool_destroy(ap_msg_pool); 2564 ap_debug_exit(); 2565 } 2566 2567 module_init(ap_module_init); 2568 module_exit(ap_module_exit); 2569