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