1f33ecfdeSHaren Myneni // SPDX-License-Identifier: GPL-2.0-or-later 2f33ecfdeSHaren Myneni /* 3f33ecfdeSHaren Myneni * Copyright 2020-21 IBM Corp. 4f33ecfdeSHaren Myneni */ 5f33ecfdeSHaren Myneni 6f33ecfdeSHaren Myneni #define pr_fmt(fmt) "vas: " fmt 7f33ecfdeSHaren Myneni 8f33ecfdeSHaren Myneni #include <linux/module.h> 9f33ecfdeSHaren Myneni #include <linux/kernel.h> 10f33ecfdeSHaren Myneni #include <linux/export.h> 11f33ecfdeSHaren Myneni #include <linux/types.h> 12f33ecfdeSHaren Myneni #include <linux/delay.h> 13b22f2d88SHaren Myneni #include <linux/slab.h> 146d0aaf5eSHaren Myneni #include <linux/interrupt.h> 15c736fb97SMichael Ellerman #include <linux/irqdomain.h> 16ca77d488SHaren Myneni #include <asm/machdep.h> 17f33ecfdeSHaren Myneni #include <asm/hvcall.h> 18f33ecfdeSHaren Myneni #include <asm/plpar_wrappers.h> 19f33ecfdeSHaren Myneni #include <asm/vas.h> 20f33ecfdeSHaren Myneni #include "vas.h" 21f33ecfdeSHaren Myneni 22f33ecfdeSHaren Myneni #define VAS_INVALID_WIN_ADDRESS 0xFFFFFFFFFFFFFFFFul 23f33ecfdeSHaren Myneni #define VAS_DEFAULT_DOMAIN_ID 0xFFFFFFFFFFFFFFFFul 24f33ecfdeSHaren Myneni /* The hypervisor allows one credit per window right now */ 25f33ecfdeSHaren Myneni #define DEF_WIN_CREDS 1 26f33ecfdeSHaren Myneni 27ca77d488SHaren Myneni static struct vas_all_caps caps_all; 28ca77d488SHaren Myneni static bool copypaste_feat; 29ca77d488SHaren Myneni 30ca77d488SHaren Myneni static struct vas_caps vascaps[VAS_MAX_FEAT_TYPE]; 31b22f2d88SHaren Myneni static DEFINE_MUTEX(vas_pseries_mutex); 32ca77d488SHaren Myneni 33f33ecfdeSHaren Myneni static long hcall_return_busy_check(long rc) 34f33ecfdeSHaren Myneni { 35f33ecfdeSHaren Myneni /* Check if we are stalled for some time */ 36f33ecfdeSHaren Myneni if (H_IS_LONG_BUSY(rc)) { 37f33ecfdeSHaren Myneni msleep(get_longbusy_msecs(rc)); 38f33ecfdeSHaren Myneni rc = H_BUSY; 39f33ecfdeSHaren Myneni } else if (rc == H_BUSY) { 40f33ecfdeSHaren Myneni cond_resched(); 41f33ecfdeSHaren Myneni } 42f33ecfdeSHaren Myneni 43f33ecfdeSHaren Myneni return rc; 44f33ecfdeSHaren Myneni } 45f33ecfdeSHaren Myneni 46f33ecfdeSHaren Myneni /* 47f33ecfdeSHaren Myneni * Allocate VAS window hcall 48f33ecfdeSHaren Myneni */ 49f33ecfdeSHaren Myneni static int h_allocate_vas_window(struct pseries_vas_window *win, u64 *domain, 50f33ecfdeSHaren Myneni u8 wintype, u16 credits) 51f33ecfdeSHaren Myneni { 52f33ecfdeSHaren Myneni long retbuf[PLPAR_HCALL9_BUFSIZE] = {0}; 53f33ecfdeSHaren Myneni long rc; 54f33ecfdeSHaren Myneni 55f33ecfdeSHaren Myneni do { 56f33ecfdeSHaren Myneni rc = plpar_hcall9(H_ALLOCATE_VAS_WINDOW, retbuf, wintype, 57f33ecfdeSHaren Myneni credits, domain[0], domain[1], domain[2], 58f33ecfdeSHaren Myneni domain[3], domain[4], domain[5]); 59f33ecfdeSHaren Myneni 60f33ecfdeSHaren Myneni rc = hcall_return_busy_check(rc); 61f33ecfdeSHaren Myneni } while (rc == H_BUSY); 62f33ecfdeSHaren Myneni 63f33ecfdeSHaren Myneni if (rc == H_SUCCESS) { 64f33ecfdeSHaren Myneni if (win->win_addr == VAS_INVALID_WIN_ADDRESS) { 65f33ecfdeSHaren Myneni pr_err("H_ALLOCATE_VAS_WINDOW: COPY/PASTE is not supported\n"); 66f33ecfdeSHaren Myneni return -ENOTSUPP; 67f33ecfdeSHaren Myneni } 68f33ecfdeSHaren Myneni win->vas_win.winid = retbuf[0]; 69f33ecfdeSHaren Myneni win->win_addr = retbuf[1]; 70f33ecfdeSHaren Myneni win->complete_irq = retbuf[2]; 71f33ecfdeSHaren Myneni win->fault_irq = retbuf[3]; 72f33ecfdeSHaren Myneni return 0; 73f33ecfdeSHaren Myneni } 74f33ecfdeSHaren Myneni 75f33ecfdeSHaren Myneni pr_err("H_ALLOCATE_VAS_WINDOW error: %ld, wintype: %u, credits: %u\n", 76f33ecfdeSHaren Myneni rc, wintype, credits); 77f33ecfdeSHaren Myneni 78f33ecfdeSHaren Myneni return -EIO; 79f33ecfdeSHaren Myneni } 80f33ecfdeSHaren Myneni 81f33ecfdeSHaren Myneni /* 82f33ecfdeSHaren Myneni * Deallocate VAS window hcall. 83f33ecfdeSHaren Myneni */ 84f33ecfdeSHaren Myneni static int h_deallocate_vas_window(u64 winid) 85f33ecfdeSHaren Myneni { 86f33ecfdeSHaren Myneni long rc; 87f33ecfdeSHaren Myneni 88f33ecfdeSHaren Myneni do { 89f33ecfdeSHaren Myneni rc = plpar_hcall_norets(H_DEALLOCATE_VAS_WINDOW, winid); 90f33ecfdeSHaren Myneni 91f33ecfdeSHaren Myneni rc = hcall_return_busy_check(rc); 92f33ecfdeSHaren Myneni } while (rc == H_BUSY); 93f33ecfdeSHaren Myneni 94f33ecfdeSHaren Myneni if (rc == H_SUCCESS) 95f33ecfdeSHaren Myneni return 0; 96f33ecfdeSHaren Myneni 97f33ecfdeSHaren Myneni pr_err("H_DEALLOCATE_VAS_WINDOW error: %ld, winid: %llu\n", 98f33ecfdeSHaren Myneni rc, winid); 99f33ecfdeSHaren Myneni return -EIO; 100f33ecfdeSHaren Myneni } 101f33ecfdeSHaren Myneni 102f33ecfdeSHaren Myneni /* 103f33ecfdeSHaren Myneni * Modify VAS window. 104f33ecfdeSHaren Myneni * After the window is opened with allocate window hcall, configure it 105f33ecfdeSHaren Myneni * with flags and LPAR PID before using. 106f33ecfdeSHaren Myneni */ 107f33ecfdeSHaren Myneni static int h_modify_vas_window(struct pseries_vas_window *win) 108f33ecfdeSHaren Myneni { 109f33ecfdeSHaren Myneni long rc; 110f33ecfdeSHaren Myneni 111f33ecfdeSHaren Myneni /* 112f33ecfdeSHaren Myneni * AMR value is not supported in Linux VAS implementation. 113f33ecfdeSHaren Myneni * The hypervisor ignores it if 0 is passed. 114f33ecfdeSHaren Myneni */ 115f33ecfdeSHaren Myneni do { 116f33ecfdeSHaren Myneni rc = plpar_hcall_norets(H_MODIFY_VAS_WINDOW, 117976410cdSHaren Myneni win->vas_win.winid, win->pid, 0, 118f33ecfdeSHaren Myneni VAS_MOD_WIN_FLAGS, 0); 119f33ecfdeSHaren Myneni 120f33ecfdeSHaren Myneni rc = hcall_return_busy_check(rc); 121f33ecfdeSHaren Myneni } while (rc == H_BUSY); 122f33ecfdeSHaren Myneni 123f33ecfdeSHaren Myneni if (rc == H_SUCCESS) 124f33ecfdeSHaren Myneni return 0; 125f33ecfdeSHaren Myneni 126976410cdSHaren Myneni pr_err("H_MODIFY_VAS_WINDOW error: %ld, winid %u pid %u\n", 127976410cdSHaren Myneni rc, win->vas_win.winid, win->pid); 128f33ecfdeSHaren Myneni return -EIO; 129f33ecfdeSHaren Myneni } 130f33ecfdeSHaren Myneni 131f33ecfdeSHaren Myneni /* 132f33ecfdeSHaren Myneni * This hcall is used to determine the capabilities from the hypervisor. 133f33ecfdeSHaren Myneni * @hcall: H_QUERY_VAS_CAPABILITIES or H_QUERY_NX_CAPABILITIES 134f33ecfdeSHaren Myneni * @query_type: If 0 is passed, the hypervisor returns the overall 135f33ecfdeSHaren Myneni * capabilities which provides all feature(s) that are 136f33ecfdeSHaren Myneni * available. Then query the hypervisor to get the 137f33ecfdeSHaren Myneni * corresponding capabilities for the specific feature. 138f33ecfdeSHaren Myneni * Example: H_QUERY_VAS_CAPABILITIES provides VAS GZIP QoS 139f33ecfdeSHaren Myneni * and VAS GZIP Default capabilities. 140f33ecfdeSHaren Myneni * H_QUERY_NX_CAPABILITIES provides NX GZIP 141f33ecfdeSHaren Myneni * capabilities. 142f33ecfdeSHaren Myneni * @result: Return buffer to save capabilities. 143f33ecfdeSHaren Myneni */ 144f33ecfdeSHaren Myneni int h_query_vas_capabilities(const u64 hcall, u8 query_type, u64 result) 145f33ecfdeSHaren Myneni { 146f33ecfdeSHaren Myneni long rc; 147f33ecfdeSHaren Myneni 148f33ecfdeSHaren Myneni rc = plpar_hcall_norets(hcall, query_type, result); 149f33ecfdeSHaren Myneni 150f33ecfdeSHaren Myneni if (rc == H_SUCCESS) 151f33ecfdeSHaren Myneni return 0; 152f33ecfdeSHaren Myneni 1530a006aceSNicholas Piggin /* H_FUNCTION means HV does not support VAS so don't print an error */ 1540a006aceSNicholas Piggin if (rc != H_FUNCTION) { 1550a006aceSNicholas Piggin pr_err("%s error %ld, query_type %u, result buffer 0x%llx\n", 1560a006aceSNicholas Piggin (hcall == H_QUERY_VAS_CAPABILITIES) ? 1570a006aceSNicholas Piggin "H_QUERY_VAS_CAPABILITIES" : 1580a006aceSNicholas Piggin "H_QUERY_NX_CAPABILITIES", 1590a006aceSNicholas Piggin rc, query_type, result); 1600a006aceSNicholas Piggin } 1610a006aceSNicholas Piggin 162f33ecfdeSHaren Myneni return -EIO; 163f33ecfdeSHaren Myneni } 164b22f2d88SHaren Myneni EXPORT_SYMBOL_GPL(h_query_vas_capabilities); 165b22f2d88SHaren Myneni 166b22f2d88SHaren Myneni /* 1676d0aaf5eSHaren Myneni * hcall to get fault CRB from the hypervisor. 1686d0aaf5eSHaren Myneni */ 1696d0aaf5eSHaren Myneni static int h_get_nx_fault(u32 winid, u64 buffer) 1706d0aaf5eSHaren Myneni { 1716d0aaf5eSHaren Myneni long rc; 1726d0aaf5eSHaren Myneni 1736d0aaf5eSHaren Myneni rc = plpar_hcall_norets(H_GET_NX_FAULT, winid, buffer); 1746d0aaf5eSHaren Myneni 1756d0aaf5eSHaren Myneni if (rc == H_SUCCESS) 1766d0aaf5eSHaren Myneni return 0; 1776d0aaf5eSHaren Myneni 1786d0aaf5eSHaren Myneni pr_err("H_GET_NX_FAULT error: %ld, winid %u, buffer 0x%llx\n", 1796d0aaf5eSHaren Myneni rc, winid, buffer); 1806d0aaf5eSHaren Myneni return -EIO; 1816d0aaf5eSHaren Myneni 1826d0aaf5eSHaren Myneni } 1836d0aaf5eSHaren Myneni 1846d0aaf5eSHaren Myneni /* 1856d0aaf5eSHaren Myneni * Handle the fault interrupt. 1866d0aaf5eSHaren Myneni * When the fault interrupt is received for each window, query the 1876d0aaf5eSHaren Myneni * hypervisor to get the fault CRB on the specific fault. Then 1886d0aaf5eSHaren Myneni * process the CRB by updating CSB or send signal if the user space 1896d0aaf5eSHaren Myneni * CSB is invalid. 1906d0aaf5eSHaren Myneni * Note: The hypervisor forwards an interrupt for each fault request. 1916d0aaf5eSHaren Myneni * So one fault CRB to process for each H_GET_NX_FAULT hcall. 1926d0aaf5eSHaren Myneni */ 1934cb26607SCédric Le Goater static irqreturn_t pseries_vas_fault_thread_fn(int irq, void *data) 1946d0aaf5eSHaren Myneni { 1956d0aaf5eSHaren Myneni struct pseries_vas_window *txwin = data; 1966d0aaf5eSHaren Myneni struct coprocessor_request_block crb; 1976d0aaf5eSHaren Myneni struct vas_user_win_ref *tsk_ref; 1986d0aaf5eSHaren Myneni int rc; 1996d0aaf5eSHaren Myneni 2006d0aaf5eSHaren Myneni rc = h_get_nx_fault(txwin->vas_win.winid, (u64)virt_to_phys(&crb)); 2016d0aaf5eSHaren Myneni if (!rc) { 2026d0aaf5eSHaren Myneni tsk_ref = &txwin->vas_win.task_ref; 2036d0aaf5eSHaren Myneni vas_dump_crb(&crb); 2046d0aaf5eSHaren Myneni vas_update_csb(&crb, tsk_ref); 2056d0aaf5eSHaren Myneni } 2066d0aaf5eSHaren Myneni 2076d0aaf5eSHaren Myneni return IRQ_HANDLED; 2086d0aaf5eSHaren Myneni } 2096d0aaf5eSHaren Myneni 2106d0aaf5eSHaren Myneni /* 211b22f2d88SHaren Myneni * Allocate window and setup IRQ mapping. 212b22f2d88SHaren Myneni */ 213b22f2d88SHaren Myneni static int allocate_setup_window(struct pseries_vas_window *txwin, 214b22f2d88SHaren Myneni u64 *domain, u8 wintype) 215b22f2d88SHaren Myneni { 216b22f2d88SHaren Myneni int rc; 217b22f2d88SHaren Myneni 218b22f2d88SHaren Myneni rc = h_allocate_vas_window(txwin, domain, wintype, DEF_WIN_CREDS); 219b22f2d88SHaren Myneni if (rc) 220b22f2d88SHaren Myneni return rc; 2216d0aaf5eSHaren Myneni /* 2226d0aaf5eSHaren Myneni * On PowerVM, the hypervisor setup and forwards the fault 2236d0aaf5eSHaren Myneni * interrupt per window. So the IRQ setup and fault handling 2246d0aaf5eSHaren Myneni * will be done for each open window separately. 2256d0aaf5eSHaren Myneni */ 2266d0aaf5eSHaren Myneni txwin->fault_virq = irq_create_mapping(NULL, txwin->fault_irq); 2276d0aaf5eSHaren Myneni if (!txwin->fault_virq) { 2286d0aaf5eSHaren Myneni pr_err("Failed irq mapping %d\n", txwin->fault_irq); 2296d0aaf5eSHaren Myneni rc = -EINVAL; 2306d0aaf5eSHaren Myneni goto out_win; 2316d0aaf5eSHaren Myneni } 2326d0aaf5eSHaren Myneni 2336d0aaf5eSHaren Myneni txwin->name = kasprintf(GFP_KERNEL, "vas-win-%d", 2346d0aaf5eSHaren Myneni txwin->vas_win.winid); 2356d0aaf5eSHaren Myneni if (!txwin->name) { 2366d0aaf5eSHaren Myneni rc = -ENOMEM; 2376d0aaf5eSHaren Myneni goto out_irq; 2386d0aaf5eSHaren Myneni } 2396d0aaf5eSHaren Myneni 2406d0aaf5eSHaren Myneni rc = request_threaded_irq(txwin->fault_virq, NULL, 2416d0aaf5eSHaren Myneni pseries_vas_fault_thread_fn, IRQF_ONESHOT, 2426d0aaf5eSHaren Myneni txwin->name, txwin); 2436d0aaf5eSHaren Myneni if (rc) { 2446d0aaf5eSHaren Myneni pr_err("VAS-Window[%d]: Request IRQ(%u) failed with %d\n", 2456d0aaf5eSHaren Myneni txwin->vas_win.winid, txwin->fault_virq, rc); 2466d0aaf5eSHaren Myneni goto out_free; 2476d0aaf5eSHaren Myneni } 248b22f2d88SHaren Myneni 249b22f2d88SHaren Myneni txwin->vas_win.wcreds_max = DEF_WIN_CREDS; 250b22f2d88SHaren Myneni 251b22f2d88SHaren Myneni return 0; 2526d0aaf5eSHaren Myneni out_free: 2536d0aaf5eSHaren Myneni kfree(txwin->name); 2546d0aaf5eSHaren Myneni out_irq: 2556d0aaf5eSHaren Myneni irq_dispose_mapping(txwin->fault_virq); 2566d0aaf5eSHaren Myneni out_win: 2576d0aaf5eSHaren Myneni h_deallocate_vas_window(txwin->vas_win.winid); 2586d0aaf5eSHaren Myneni return rc; 2596d0aaf5eSHaren Myneni } 2606d0aaf5eSHaren Myneni 2616d0aaf5eSHaren Myneni static inline void free_irq_setup(struct pseries_vas_window *txwin) 2626d0aaf5eSHaren Myneni { 2636d0aaf5eSHaren Myneni free_irq(txwin->fault_virq, txwin); 2646d0aaf5eSHaren Myneni kfree(txwin->name); 2656d0aaf5eSHaren Myneni irq_dispose_mapping(txwin->fault_virq); 266b22f2d88SHaren Myneni } 267b22f2d88SHaren Myneni 268b22f2d88SHaren Myneni static struct vas_window *vas_allocate_window(int vas_id, u64 flags, 269b22f2d88SHaren Myneni enum vas_cop_type cop_type) 270b22f2d88SHaren Myneni { 271b22f2d88SHaren Myneni long domain[PLPAR_HCALL9_BUFSIZE] = {VAS_DEFAULT_DOMAIN_ID}; 272b22f2d88SHaren Myneni struct vas_cop_feat_caps *cop_feat_caps; 273b22f2d88SHaren Myneni struct vas_caps *caps; 274b22f2d88SHaren Myneni struct pseries_vas_window *txwin; 275b22f2d88SHaren Myneni int rc; 276b22f2d88SHaren Myneni 277b22f2d88SHaren Myneni txwin = kzalloc(sizeof(*txwin), GFP_KERNEL); 278b22f2d88SHaren Myneni if (!txwin) 279b22f2d88SHaren Myneni return ERR_PTR(-ENOMEM); 280b22f2d88SHaren Myneni 281b22f2d88SHaren Myneni /* 282b22f2d88SHaren Myneni * A VAS window can have many credits which means that many 283b22f2d88SHaren Myneni * requests can be issued simultaneously. But the hypervisor 284b22f2d88SHaren Myneni * restricts one credit per window. 285b22f2d88SHaren Myneni * The hypervisor introduces 2 different types of credits: 286b22f2d88SHaren Myneni * Default credit type (Uses normal priority FIFO): 287b22f2d88SHaren Myneni * A limited number of credits are assigned to partitions 288b22f2d88SHaren Myneni * based on processor entitlement. But these credits may be 289b22f2d88SHaren Myneni * over-committed on a system depends on whether the CPUs 290b22f2d88SHaren Myneni * are in shared or dedicated modes - that is, more requests 291b22f2d88SHaren Myneni * may be issued across the system than NX can service at 292b22f2d88SHaren Myneni * once which can result in paste command failure (RMA_busy). 293b22f2d88SHaren Myneni * Then the process has to resend requests or fall-back to 294b22f2d88SHaren Myneni * SW compression. 295b22f2d88SHaren Myneni * Quality of Service (QoS) credit type (Uses high priority FIFO): 296b22f2d88SHaren Myneni * To avoid NX HW contention, the system admins can assign 297b22f2d88SHaren Myneni * QoS credits for each LPAR so that this partition is 298b22f2d88SHaren Myneni * guaranteed access to NX resources. These credits are 299b22f2d88SHaren Myneni * assigned to partitions via the HMC. 300b22f2d88SHaren Myneni * Refer PAPR for more information. 301b22f2d88SHaren Myneni * 302b22f2d88SHaren Myneni * Allocate window with QoS credits if user requested. Otherwise 303b22f2d88SHaren Myneni * default credits are used. 304b22f2d88SHaren Myneni */ 305b22f2d88SHaren Myneni if (flags & VAS_TX_WIN_FLAG_QOS_CREDIT) 306b22f2d88SHaren Myneni caps = &vascaps[VAS_GZIP_QOS_FEAT_TYPE]; 307b22f2d88SHaren Myneni else 308b22f2d88SHaren Myneni caps = &vascaps[VAS_GZIP_DEF_FEAT_TYPE]; 309b22f2d88SHaren Myneni 310b22f2d88SHaren Myneni cop_feat_caps = &caps->caps; 311b22f2d88SHaren Myneni 31240562fe4SHaren Myneni if (atomic_inc_return(&cop_feat_caps->nr_used_credits) > 31340562fe4SHaren Myneni atomic_read(&cop_feat_caps->nr_total_credits)) { 314b22f2d88SHaren Myneni pr_err("Credits are not available to allocate window\n"); 315b22f2d88SHaren Myneni rc = -EINVAL; 316b22f2d88SHaren Myneni goto out; 317b22f2d88SHaren Myneni } 318b22f2d88SHaren Myneni 319b22f2d88SHaren Myneni if (vas_id == -1) { 320b22f2d88SHaren Myneni /* 321b22f2d88SHaren Myneni * The user space is requesting to allocate a window on 322b22f2d88SHaren Myneni * a VAS instance where the process is executing. 323b22f2d88SHaren Myneni * On PowerVM, domain values are passed to the hypervisor 324b22f2d88SHaren Myneni * to select VAS instance. Useful if the process is 325b22f2d88SHaren Myneni * affinity to NUMA node. 326b22f2d88SHaren Myneni * The hypervisor selects VAS instance if 327b22f2d88SHaren Myneni * VAS_DEFAULT_DOMAIN_ID (-1) is passed for domain values. 328b22f2d88SHaren Myneni * The h_allocate_vas_window hcall is defined to take a 329b22f2d88SHaren Myneni * domain values as specified by h_home_node_associativity, 330b22f2d88SHaren Myneni * So no unpacking needs to be done. 331b22f2d88SHaren Myneni */ 332b22f2d88SHaren Myneni rc = plpar_hcall9(H_HOME_NODE_ASSOCIATIVITY, domain, 333b22f2d88SHaren Myneni VPHN_FLAG_VCPU, smp_processor_id()); 334b22f2d88SHaren Myneni if (rc != H_SUCCESS) { 335b22f2d88SHaren Myneni pr_err("H_HOME_NODE_ASSOCIATIVITY error: %d\n", rc); 336b22f2d88SHaren Myneni goto out; 337b22f2d88SHaren Myneni } 338b22f2d88SHaren Myneni } 339b22f2d88SHaren Myneni 340976410cdSHaren Myneni txwin->pid = mfspr(SPRN_PID); 341976410cdSHaren Myneni 342b22f2d88SHaren Myneni /* 343b22f2d88SHaren Myneni * Allocate / Deallocate window hcalls and setup / free IRQs 344b22f2d88SHaren Myneni * have to be protected with mutex. 345b22f2d88SHaren Myneni * Open VAS window: Allocate window hcall and setup IRQ 346b22f2d88SHaren Myneni * Close VAS window: Deallocate window hcall and free IRQ 347b22f2d88SHaren Myneni * The hypervisor waits until all NX requests are 348b22f2d88SHaren Myneni * completed before closing the window. So expects OS 349b22f2d88SHaren Myneni * to handle NX faults, means IRQ can be freed only 350b22f2d88SHaren Myneni * after the deallocate window hcall is returned. 351b22f2d88SHaren Myneni * So once the window is closed with deallocate hcall before 352b22f2d88SHaren Myneni * the IRQ is freed, it can be assigned to new allocate 353b22f2d88SHaren Myneni * hcall with the same fault IRQ by the hypervisor. It can 354b22f2d88SHaren Myneni * result in setup IRQ fail for the new window since the 355b22f2d88SHaren Myneni * same fault IRQ is not freed by the OS before. 356b22f2d88SHaren Myneni */ 357b22f2d88SHaren Myneni mutex_lock(&vas_pseries_mutex); 358b22f2d88SHaren Myneni rc = allocate_setup_window(txwin, (u64 *)&domain[0], 359b22f2d88SHaren Myneni cop_feat_caps->win_type); 360b22f2d88SHaren Myneni mutex_unlock(&vas_pseries_mutex); 361b22f2d88SHaren Myneni if (rc) 362b22f2d88SHaren Myneni goto out; 363b22f2d88SHaren Myneni 364b22f2d88SHaren Myneni /* 365b22f2d88SHaren Myneni * Modify window and it is ready to use. 366b22f2d88SHaren Myneni */ 367b22f2d88SHaren Myneni rc = h_modify_vas_window(txwin); 368b22f2d88SHaren Myneni if (!rc) 369b22f2d88SHaren Myneni rc = get_vas_user_win_ref(&txwin->vas_win.task_ref); 370b22f2d88SHaren Myneni if (rc) 371b22f2d88SHaren Myneni goto out_free; 372b22f2d88SHaren Myneni 373b22f2d88SHaren Myneni txwin->win_type = cop_feat_caps->win_type; 374b22f2d88SHaren Myneni mutex_lock(&vas_pseries_mutex); 375*8ef7b9e1SHaren Myneni /* 376*8ef7b9e1SHaren Myneni * Possible to lose the acquired credit with DLPAR core 377*8ef7b9e1SHaren Myneni * removal after the window is opened. So if there are any 378*8ef7b9e1SHaren Myneni * closed windows (means with lost credits), do not give new 379*8ef7b9e1SHaren Myneni * window to user space. New windows will be opened only 380*8ef7b9e1SHaren Myneni * after the existing windows are reopened when credits are 381*8ef7b9e1SHaren Myneni * available. 382*8ef7b9e1SHaren Myneni */ 383*8ef7b9e1SHaren Myneni if (!caps->nr_close_wins) { 384b22f2d88SHaren Myneni list_add(&txwin->win_list, &caps->list); 385*8ef7b9e1SHaren Myneni caps->nr_open_windows++; 386*8ef7b9e1SHaren Myneni mutex_unlock(&vas_pseries_mutex); 387*8ef7b9e1SHaren Myneni vas_user_win_add_mm_context(&txwin->vas_win.task_ref); 388*8ef7b9e1SHaren Myneni return &txwin->vas_win; 389*8ef7b9e1SHaren Myneni } 390b22f2d88SHaren Myneni mutex_unlock(&vas_pseries_mutex); 391b22f2d88SHaren Myneni 392*8ef7b9e1SHaren Myneni put_vas_user_win_ref(&txwin->vas_win.task_ref); 393*8ef7b9e1SHaren Myneni rc = -EBUSY; 394*8ef7b9e1SHaren Myneni pr_err("No credit is available to allocate window\n"); 395b22f2d88SHaren Myneni 396b22f2d88SHaren Myneni out_free: 3976d0aaf5eSHaren Myneni /* 3986d0aaf5eSHaren Myneni * Window is not operational. Free IRQ before closing 3996d0aaf5eSHaren Myneni * window so that do not have to hold mutex. 4006d0aaf5eSHaren Myneni */ 4016d0aaf5eSHaren Myneni free_irq_setup(txwin); 402b22f2d88SHaren Myneni h_deallocate_vas_window(txwin->vas_win.winid); 403b22f2d88SHaren Myneni out: 40440562fe4SHaren Myneni atomic_dec(&cop_feat_caps->nr_used_credits); 405b22f2d88SHaren Myneni kfree(txwin); 406b22f2d88SHaren Myneni return ERR_PTR(rc); 407b22f2d88SHaren Myneni } 408b22f2d88SHaren Myneni 409b22f2d88SHaren Myneni static u64 vas_paste_address(struct vas_window *vwin) 410b22f2d88SHaren Myneni { 411b22f2d88SHaren Myneni struct pseries_vas_window *win; 412b22f2d88SHaren Myneni 413b22f2d88SHaren Myneni win = container_of(vwin, struct pseries_vas_window, vas_win); 414b22f2d88SHaren Myneni return win->win_addr; 415b22f2d88SHaren Myneni } 416b22f2d88SHaren Myneni 417b22f2d88SHaren Myneni static int deallocate_free_window(struct pseries_vas_window *win) 418b22f2d88SHaren Myneni { 419b22f2d88SHaren Myneni int rc = 0; 420b22f2d88SHaren Myneni 4216d0aaf5eSHaren Myneni /* 4226d0aaf5eSHaren Myneni * The hypervisor waits for all requests including faults 4236d0aaf5eSHaren Myneni * are processed before closing the window - Means all 4246d0aaf5eSHaren Myneni * credits have to be returned. In the case of fault 4256d0aaf5eSHaren Myneni * request, a credit is returned after OS issues 4266d0aaf5eSHaren Myneni * H_GET_NX_FAULT hcall. 4276d0aaf5eSHaren Myneni * So free IRQ after executing H_DEALLOCATE_VAS_WINDOW 4286d0aaf5eSHaren Myneni * hcall. 4296d0aaf5eSHaren Myneni */ 430b22f2d88SHaren Myneni rc = h_deallocate_vas_window(win->vas_win.winid); 4316d0aaf5eSHaren Myneni if (!rc) 4326d0aaf5eSHaren Myneni free_irq_setup(win); 433b22f2d88SHaren Myneni 434b22f2d88SHaren Myneni return rc; 435b22f2d88SHaren Myneni } 436b22f2d88SHaren Myneni 437b22f2d88SHaren Myneni static int vas_deallocate_window(struct vas_window *vwin) 438b22f2d88SHaren Myneni { 439b22f2d88SHaren Myneni struct pseries_vas_window *win; 440b22f2d88SHaren Myneni struct vas_cop_feat_caps *caps; 441b22f2d88SHaren Myneni int rc = 0; 442b22f2d88SHaren Myneni 443b22f2d88SHaren Myneni if (!vwin) 444b22f2d88SHaren Myneni return -EINVAL; 445b22f2d88SHaren Myneni 446b22f2d88SHaren Myneni win = container_of(vwin, struct pseries_vas_window, vas_win); 447b22f2d88SHaren Myneni 448b22f2d88SHaren Myneni /* Should not happen */ 449b22f2d88SHaren Myneni if (win->win_type >= VAS_MAX_FEAT_TYPE) { 450b22f2d88SHaren Myneni pr_err("Window (%u): Invalid window type %u\n", 451b22f2d88SHaren Myneni vwin->winid, win->win_type); 452b22f2d88SHaren Myneni return -EINVAL; 453b22f2d88SHaren Myneni } 454b22f2d88SHaren Myneni 455b22f2d88SHaren Myneni caps = &vascaps[win->win_type].caps; 456b22f2d88SHaren Myneni mutex_lock(&vas_pseries_mutex); 457*8ef7b9e1SHaren Myneni /* 458*8ef7b9e1SHaren Myneni * VAS window is already closed in the hypervisor when 459*8ef7b9e1SHaren Myneni * lost the credit. So just remove the entry from 460*8ef7b9e1SHaren Myneni * the list, remove task references and free vas_window 461*8ef7b9e1SHaren Myneni * struct. 462*8ef7b9e1SHaren Myneni */ 463*8ef7b9e1SHaren Myneni if (win->vas_win.status & VAS_WIN_NO_CRED_CLOSE) { 464b22f2d88SHaren Myneni rc = deallocate_free_window(win); 465b22f2d88SHaren Myneni if (rc) { 466b22f2d88SHaren Myneni mutex_unlock(&vas_pseries_mutex); 467b22f2d88SHaren Myneni return rc; 468b22f2d88SHaren Myneni } 469*8ef7b9e1SHaren Myneni } else 470*8ef7b9e1SHaren Myneni vascaps[win->win_type].nr_close_wins--; 471b22f2d88SHaren Myneni 472b22f2d88SHaren Myneni list_del(&win->win_list); 47340562fe4SHaren Myneni atomic_dec(&caps->nr_used_credits); 474*8ef7b9e1SHaren Myneni vascaps[win->win_type].nr_open_windows--; 475b22f2d88SHaren Myneni mutex_unlock(&vas_pseries_mutex); 476b22f2d88SHaren Myneni 477b22f2d88SHaren Myneni put_vas_user_win_ref(&vwin->task_ref); 478b22f2d88SHaren Myneni mm_context_remove_vas_window(vwin->task_ref.mm); 479b22f2d88SHaren Myneni 480b22f2d88SHaren Myneni kfree(win); 481b22f2d88SHaren Myneni return 0; 482b22f2d88SHaren Myneni } 483b22f2d88SHaren Myneni 484b22f2d88SHaren Myneni static const struct vas_user_win_ops vops_pseries = { 485b22f2d88SHaren Myneni .open_win = vas_allocate_window, /* Open and configure window */ 486b22f2d88SHaren Myneni .paste_addr = vas_paste_address, /* To do copy/paste */ 487b22f2d88SHaren Myneni .close_win = vas_deallocate_window, /* Close window */ 488b22f2d88SHaren Myneni }; 489b22f2d88SHaren Myneni 490b22f2d88SHaren Myneni /* 491b22f2d88SHaren Myneni * Supporting only nx-gzip coprocessor type now, but this API code 492b22f2d88SHaren Myneni * extended to other coprocessor types later. 493b22f2d88SHaren Myneni */ 494b22f2d88SHaren Myneni int vas_register_api_pseries(struct module *mod, enum vas_cop_type cop_type, 495b22f2d88SHaren Myneni const char *name) 496b22f2d88SHaren Myneni { 497b22f2d88SHaren Myneni int rc; 498b22f2d88SHaren Myneni 499b22f2d88SHaren Myneni if (!copypaste_feat) 500b22f2d88SHaren Myneni return -ENOTSUPP; 501b22f2d88SHaren Myneni 502b22f2d88SHaren Myneni rc = vas_register_coproc_api(mod, cop_type, name, &vops_pseries); 503b22f2d88SHaren Myneni 504b22f2d88SHaren Myneni return rc; 505b22f2d88SHaren Myneni } 506b22f2d88SHaren Myneni EXPORT_SYMBOL_GPL(vas_register_api_pseries); 507b22f2d88SHaren Myneni 508b22f2d88SHaren Myneni void vas_unregister_api_pseries(void) 509b22f2d88SHaren Myneni { 510b22f2d88SHaren Myneni vas_unregister_coproc_api(); 511b22f2d88SHaren Myneni } 512b22f2d88SHaren Myneni EXPORT_SYMBOL_GPL(vas_unregister_api_pseries); 513ca77d488SHaren Myneni 514ca77d488SHaren Myneni /* 515ca77d488SHaren Myneni * Get the specific capabilities based on the feature type. 516ca77d488SHaren Myneni * Right now supports GZIP default and GZIP QoS capabilities. 517ca77d488SHaren Myneni */ 518e14ff96dSNick Child static int __init get_vas_capabilities(u8 feat, enum vas_cop_feat_type type, 519ca77d488SHaren Myneni struct hv_vas_cop_feat_caps *hv_caps) 520ca77d488SHaren Myneni { 521ca77d488SHaren Myneni struct vas_cop_feat_caps *caps; 522ca77d488SHaren Myneni struct vas_caps *vcaps; 523ca77d488SHaren Myneni int rc = 0; 524ca77d488SHaren Myneni 525ca77d488SHaren Myneni vcaps = &vascaps[type]; 526ca77d488SHaren Myneni memset(vcaps, 0, sizeof(*vcaps)); 527ca77d488SHaren Myneni INIT_LIST_HEAD(&vcaps->list); 528ca77d488SHaren Myneni 529*8ef7b9e1SHaren Myneni vcaps->feat = feat; 530ca77d488SHaren Myneni caps = &vcaps->caps; 531ca77d488SHaren Myneni 532ca77d488SHaren Myneni rc = h_query_vas_capabilities(H_QUERY_VAS_CAPABILITIES, feat, 533ca77d488SHaren Myneni (u64)virt_to_phys(hv_caps)); 534ca77d488SHaren Myneni if (rc) 535ca77d488SHaren Myneni return rc; 536ca77d488SHaren Myneni 537ca77d488SHaren Myneni caps->user_mode = hv_caps->user_mode; 538ca77d488SHaren Myneni if (!(caps->user_mode & VAS_COPY_PASTE_USER_MODE)) { 539ca77d488SHaren Myneni pr_err("User space COPY/PASTE is not supported\n"); 540ca77d488SHaren Myneni return -ENOTSUPP; 541ca77d488SHaren Myneni } 542ca77d488SHaren Myneni 543ca77d488SHaren Myneni caps->descriptor = be64_to_cpu(hv_caps->descriptor); 544ca77d488SHaren Myneni caps->win_type = hv_caps->win_type; 545ca77d488SHaren Myneni if (caps->win_type >= VAS_MAX_FEAT_TYPE) { 546ca77d488SHaren Myneni pr_err("Unsupported window type %u\n", caps->win_type); 547ca77d488SHaren Myneni return -EINVAL; 548ca77d488SHaren Myneni } 549ca77d488SHaren Myneni caps->max_lpar_creds = be16_to_cpu(hv_caps->max_lpar_creds); 550ca77d488SHaren Myneni caps->max_win_creds = be16_to_cpu(hv_caps->max_win_creds); 55140562fe4SHaren Myneni atomic_set(&caps->nr_total_credits, 552ca77d488SHaren Myneni be16_to_cpu(hv_caps->target_lpar_creds)); 553ca77d488SHaren Myneni if (feat == VAS_GZIP_DEF_FEAT) { 554ca77d488SHaren Myneni caps->def_lpar_creds = be16_to_cpu(hv_caps->def_lpar_creds); 555ca77d488SHaren Myneni 556ca77d488SHaren Myneni if (caps->max_win_creds < DEF_WIN_CREDS) { 557ca77d488SHaren Myneni pr_err("Window creds(%u) > max allowed window creds(%u)\n", 558ca77d488SHaren Myneni DEF_WIN_CREDS, caps->max_win_creds); 559ca77d488SHaren Myneni return -EINVAL; 560ca77d488SHaren Myneni } 561ca77d488SHaren Myneni } 562ca77d488SHaren Myneni 563ca77d488SHaren Myneni copypaste_feat = true; 564ca77d488SHaren Myneni 565ca77d488SHaren Myneni return 0; 566ca77d488SHaren Myneni } 567ca77d488SHaren Myneni 568*8ef7b9e1SHaren Myneni /* 569*8ef7b9e1SHaren Myneni * The hypervisor reduces the available credits if the LPAR lost core. It 570*8ef7b9e1SHaren Myneni * means the excessive windows should not be active and the user space 571*8ef7b9e1SHaren Myneni * should not be using these windows to send compression requests to NX. 572*8ef7b9e1SHaren Myneni * So the kernel closes the excessive windows and unmap the paste address 573*8ef7b9e1SHaren Myneni * such that the user space receives paste instruction failure. Then up to 574*8ef7b9e1SHaren Myneni * the user space to fall back to SW compression and manage with the 575*8ef7b9e1SHaren Myneni * existing windows. 576*8ef7b9e1SHaren Myneni */ 577*8ef7b9e1SHaren Myneni static int reconfig_close_windows(struct vas_caps *vcap, int excess_creds) 578*8ef7b9e1SHaren Myneni { 579*8ef7b9e1SHaren Myneni struct pseries_vas_window *win, *tmp; 580*8ef7b9e1SHaren Myneni struct vas_user_win_ref *task_ref; 581*8ef7b9e1SHaren Myneni struct vm_area_struct *vma; 582*8ef7b9e1SHaren Myneni int rc = 0; 583*8ef7b9e1SHaren Myneni 584*8ef7b9e1SHaren Myneni list_for_each_entry_safe(win, tmp, &vcap->list, win_list) { 585*8ef7b9e1SHaren Myneni /* 586*8ef7b9e1SHaren Myneni * This window is already closed due to lost credit 587*8ef7b9e1SHaren Myneni * before. Go for next window. 588*8ef7b9e1SHaren Myneni */ 589*8ef7b9e1SHaren Myneni if (win->vas_win.status & VAS_WIN_NO_CRED_CLOSE) 590*8ef7b9e1SHaren Myneni continue; 591*8ef7b9e1SHaren Myneni 592*8ef7b9e1SHaren Myneni task_ref = &win->vas_win.task_ref; 593*8ef7b9e1SHaren Myneni mutex_lock(&task_ref->mmap_mutex); 594*8ef7b9e1SHaren Myneni vma = task_ref->vma; 595*8ef7b9e1SHaren Myneni /* 596*8ef7b9e1SHaren Myneni * Number of available credits are reduced, So select 597*8ef7b9e1SHaren Myneni * and close windows. 598*8ef7b9e1SHaren Myneni */ 599*8ef7b9e1SHaren Myneni win->vas_win.status |= VAS_WIN_NO_CRED_CLOSE; 600*8ef7b9e1SHaren Myneni 601*8ef7b9e1SHaren Myneni mmap_write_lock(task_ref->mm); 602*8ef7b9e1SHaren Myneni /* 603*8ef7b9e1SHaren Myneni * vma is set in the original mapping. But this mapping 604*8ef7b9e1SHaren Myneni * is done with mmap() after the window is opened with ioctl. 605*8ef7b9e1SHaren Myneni * so we may not see the original mapping if the core remove 606*8ef7b9e1SHaren Myneni * is done before the original mmap() and after the ioctl. 607*8ef7b9e1SHaren Myneni */ 608*8ef7b9e1SHaren Myneni if (vma) 609*8ef7b9e1SHaren Myneni zap_page_range(vma, vma->vm_start, 610*8ef7b9e1SHaren Myneni vma->vm_end - vma->vm_start); 611*8ef7b9e1SHaren Myneni 612*8ef7b9e1SHaren Myneni mmap_write_unlock(task_ref->mm); 613*8ef7b9e1SHaren Myneni mutex_unlock(&task_ref->mmap_mutex); 614*8ef7b9e1SHaren Myneni /* 615*8ef7b9e1SHaren Myneni * Close VAS window in the hypervisor, but do not 616*8ef7b9e1SHaren Myneni * free vas_window struct since it may be reused 617*8ef7b9e1SHaren Myneni * when the credit is available later (DLPAR with 618*8ef7b9e1SHaren Myneni * adding cores). This struct will be used 619*8ef7b9e1SHaren Myneni * later when the process issued with close(FD). 620*8ef7b9e1SHaren Myneni */ 621*8ef7b9e1SHaren Myneni rc = deallocate_free_window(win); 622*8ef7b9e1SHaren Myneni if (rc) 623*8ef7b9e1SHaren Myneni return rc; 624*8ef7b9e1SHaren Myneni 625*8ef7b9e1SHaren Myneni vcap->nr_close_wins++; 626*8ef7b9e1SHaren Myneni 627*8ef7b9e1SHaren Myneni if (!--excess_creds) 628*8ef7b9e1SHaren Myneni break; 629*8ef7b9e1SHaren Myneni } 630*8ef7b9e1SHaren Myneni 631*8ef7b9e1SHaren Myneni return 0; 632*8ef7b9e1SHaren Myneni } 633*8ef7b9e1SHaren Myneni 634*8ef7b9e1SHaren Myneni /* 635*8ef7b9e1SHaren Myneni * Get new VAS capabilities when the core add/removal configuration 636*8ef7b9e1SHaren Myneni * changes. Reconfig window configurations based on the credits 637*8ef7b9e1SHaren Myneni * availability from this new capabilities. 638*8ef7b9e1SHaren Myneni */ 639*8ef7b9e1SHaren Myneni static int vas_reconfig_capabilties(u8 type) 640*8ef7b9e1SHaren Myneni { 641*8ef7b9e1SHaren Myneni struct hv_vas_cop_feat_caps *hv_caps; 642*8ef7b9e1SHaren Myneni struct vas_cop_feat_caps *caps; 643*8ef7b9e1SHaren Myneni int old_nr_creds, new_nr_creds; 644*8ef7b9e1SHaren Myneni struct vas_caps *vcaps; 645*8ef7b9e1SHaren Myneni int rc = 0, nr_active_wins; 646*8ef7b9e1SHaren Myneni 647*8ef7b9e1SHaren Myneni if (type >= VAS_MAX_FEAT_TYPE) { 648*8ef7b9e1SHaren Myneni pr_err("Invalid credit type %d\n", type); 649*8ef7b9e1SHaren Myneni return -EINVAL; 650*8ef7b9e1SHaren Myneni } 651*8ef7b9e1SHaren Myneni 652*8ef7b9e1SHaren Myneni vcaps = &vascaps[type]; 653*8ef7b9e1SHaren Myneni caps = &vcaps->caps; 654*8ef7b9e1SHaren Myneni 655*8ef7b9e1SHaren Myneni hv_caps = kmalloc(sizeof(*hv_caps), GFP_KERNEL); 656*8ef7b9e1SHaren Myneni if (!hv_caps) 657*8ef7b9e1SHaren Myneni return -ENOMEM; 658*8ef7b9e1SHaren Myneni 659*8ef7b9e1SHaren Myneni mutex_lock(&vas_pseries_mutex); 660*8ef7b9e1SHaren Myneni rc = h_query_vas_capabilities(H_QUERY_VAS_CAPABILITIES, vcaps->feat, 661*8ef7b9e1SHaren Myneni (u64)virt_to_phys(hv_caps)); 662*8ef7b9e1SHaren Myneni if (rc) 663*8ef7b9e1SHaren Myneni goto out; 664*8ef7b9e1SHaren Myneni 665*8ef7b9e1SHaren Myneni new_nr_creds = be16_to_cpu(hv_caps->target_lpar_creds); 666*8ef7b9e1SHaren Myneni 667*8ef7b9e1SHaren Myneni old_nr_creds = atomic_read(&caps->nr_total_credits); 668*8ef7b9e1SHaren Myneni 669*8ef7b9e1SHaren Myneni atomic_set(&caps->nr_total_credits, new_nr_creds); 670*8ef7b9e1SHaren Myneni /* 671*8ef7b9e1SHaren Myneni * The total number of available credits may be decreased or 672*8ef7b9e1SHaren Myneni * inceased with DLPAR operation. Means some windows have to be 673*8ef7b9e1SHaren Myneni * closed / reopened. Hold the vas_pseries_mutex so that the 674*8ef7b9e1SHaren Myneni * the user space can not open new windows. 675*8ef7b9e1SHaren Myneni */ 676*8ef7b9e1SHaren Myneni if (old_nr_creds > new_nr_creds) { 677*8ef7b9e1SHaren Myneni /* 678*8ef7b9e1SHaren Myneni * # active windows is more than new LPAR available 679*8ef7b9e1SHaren Myneni * credits. So close the excessive windows. 680*8ef7b9e1SHaren Myneni * On pseries, each window will have 1 credit. 681*8ef7b9e1SHaren Myneni */ 682*8ef7b9e1SHaren Myneni nr_active_wins = vcaps->nr_open_windows - vcaps->nr_close_wins; 683*8ef7b9e1SHaren Myneni if (nr_active_wins > new_nr_creds) 684*8ef7b9e1SHaren Myneni rc = reconfig_close_windows(vcaps, 685*8ef7b9e1SHaren Myneni nr_active_wins - new_nr_creds); 686*8ef7b9e1SHaren Myneni } 687*8ef7b9e1SHaren Myneni 688*8ef7b9e1SHaren Myneni out: 689*8ef7b9e1SHaren Myneni mutex_unlock(&vas_pseries_mutex); 690*8ef7b9e1SHaren Myneni kfree(hv_caps); 691*8ef7b9e1SHaren Myneni return rc; 692*8ef7b9e1SHaren Myneni } 693*8ef7b9e1SHaren Myneni /* 694*8ef7b9e1SHaren Myneni * Total number of default credits available (target_credits) 695*8ef7b9e1SHaren Myneni * in LPAR depends on number of cores configured. It varies based on 696*8ef7b9e1SHaren Myneni * whether processors are in shared mode or dedicated mode. 697*8ef7b9e1SHaren Myneni * Get the notifier when CPU configuration is changed with DLPAR 698*8ef7b9e1SHaren Myneni * operation so that get the new target_credits (vas default capabilities) 699*8ef7b9e1SHaren Myneni * and then update the existing windows usage if needed. 700*8ef7b9e1SHaren Myneni */ 701*8ef7b9e1SHaren Myneni static int pseries_vas_notifier(struct notifier_block *nb, 702*8ef7b9e1SHaren Myneni unsigned long action, void *data) 703*8ef7b9e1SHaren Myneni { 704*8ef7b9e1SHaren Myneni struct of_reconfig_data *rd = data; 705*8ef7b9e1SHaren Myneni struct device_node *dn = rd->dn; 706*8ef7b9e1SHaren Myneni const __be32 *intserv = NULL; 707*8ef7b9e1SHaren Myneni int len, rc = 0; 708*8ef7b9e1SHaren Myneni 709*8ef7b9e1SHaren Myneni if ((action == OF_RECONFIG_ATTACH_NODE) || 710*8ef7b9e1SHaren Myneni (action == OF_RECONFIG_DETACH_NODE)) 711*8ef7b9e1SHaren Myneni intserv = of_get_property(dn, "ibm,ppc-interrupt-server#s", 712*8ef7b9e1SHaren Myneni &len); 713*8ef7b9e1SHaren Myneni /* 714*8ef7b9e1SHaren Myneni * Processor config is not changed 715*8ef7b9e1SHaren Myneni */ 716*8ef7b9e1SHaren Myneni if (!intserv) 717*8ef7b9e1SHaren Myneni return NOTIFY_OK; 718*8ef7b9e1SHaren Myneni 719*8ef7b9e1SHaren Myneni rc = vas_reconfig_capabilties(VAS_GZIP_DEF_FEAT_TYPE); 720*8ef7b9e1SHaren Myneni if (rc) 721*8ef7b9e1SHaren Myneni pr_err("Failed reconfig VAS capabilities with DLPAR\n"); 722*8ef7b9e1SHaren Myneni 723*8ef7b9e1SHaren Myneni return rc; 724*8ef7b9e1SHaren Myneni } 725*8ef7b9e1SHaren Myneni 726*8ef7b9e1SHaren Myneni static struct notifier_block pseries_vas_nb = { 727*8ef7b9e1SHaren Myneni .notifier_call = pseries_vas_notifier, 728*8ef7b9e1SHaren Myneni }; 729*8ef7b9e1SHaren Myneni 730ca77d488SHaren Myneni static int __init pseries_vas_init(void) 731ca77d488SHaren Myneni { 732ca77d488SHaren Myneni struct hv_vas_cop_feat_caps *hv_cop_caps; 733ca77d488SHaren Myneni struct hv_vas_all_caps *hv_caps; 734ca77d488SHaren Myneni int rc; 735ca77d488SHaren Myneni 736ca77d488SHaren Myneni /* 737ca77d488SHaren Myneni * Linux supports user space COPY/PASTE only with Radix 738ca77d488SHaren Myneni */ 739ca77d488SHaren Myneni if (!radix_enabled()) { 740ca77d488SHaren Myneni pr_err("API is supported only with radix page tables\n"); 741ca77d488SHaren Myneni return -ENOTSUPP; 742ca77d488SHaren Myneni } 743ca77d488SHaren Myneni 744ca77d488SHaren Myneni hv_caps = kmalloc(sizeof(*hv_caps), GFP_KERNEL); 745ca77d488SHaren Myneni if (!hv_caps) 746ca77d488SHaren Myneni return -ENOMEM; 747ca77d488SHaren Myneni /* 748ca77d488SHaren Myneni * Get VAS overall capabilities by passing 0 to feature type. 749ca77d488SHaren Myneni */ 750ca77d488SHaren Myneni rc = h_query_vas_capabilities(H_QUERY_VAS_CAPABILITIES, 0, 751ca77d488SHaren Myneni (u64)virt_to_phys(hv_caps)); 752ca77d488SHaren Myneni if (rc) 753ca77d488SHaren Myneni goto out; 754ca77d488SHaren Myneni 755ca77d488SHaren Myneni caps_all.descriptor = be64_to_cpu(hv_caps->descriptor); 756ca77d488SHaren Myneni caps_all.feat_type = be64_to_cpu(hv_caps->feat_type); 757ca77d488SHaren Myneni 758ca77d488SHaren Myneni hv_cop_caps = kmalloc(sizeof(*hv_cop_caps), GFP_KERNEL); 759ca77d488SHaren Myneni if (!hv_cop_caps) { 760ca77d488SHaren Myneni rc = -ENOMEM; 761ca77d488SHaren Myneni goto out; 762ca77d488SHaren Myneni } 763ca77d488SHaren Myneni /* 764ca77d488SHaren Myneni * QOS capabilities available 765ca77d488SHaren Myneni */ 766ca77d488SHaren Myneni if (caps_all.feat_type & VAS_GZIP_QOS_FEAT_BIT) { 767ca77d488SHaren Myneni rc = get_vas_capabilities(VAS_GZIP_QOS_FEAT, 768ca77d488SHaren Myneni VAS_GZIP_QOS_FEAT_TYPE, hv_cop_caps); 769ca77d488SHaren Myneni 770ca77d488SHaren Myneni if (rc) 771ca77d488SHaren Myneni goto out_cop; 772ca77d488SHaren Myneni } 773ca77d488SHaren Myneni /* 774ca77d488SHaren Myneni * Default capabilities available 775ca77d488SHaren Myneni */ 776ca77d488SHaren Myneni if (caps_all.feat_type & VAS_GZIP_DEF_FEAT_BIT) { 777ca77d488SHaren Myneni rc = get_vas_capabilities(VAS_GZIP_DEF_FEAT, 778ca77d488SHaren Myneni VAS_GZIP_DEF_FEAT_TYPE, hv_cop_caps); 779ca77d488SHaren Myneni if (rc) 780ca77d488SHaren Myneni goto out_cop; 781ca77d488SHaren Myneni } 782ca77d488SHaren Myneni 783*8ef7b9e1SHaren Myneni if (copypaste_feat && firmware_has_feature(FW_FEATURE_LPAR)) 784*8ef7b9e1SHaren Myneni of_reconfig_notifier_register(&pseries_vas_nb); 785*8ef7b9e1SHaren Myneni 786ca77d488SHaren Myneni pr_info("GZIP feature is available\n"); 787ca77d488SHaren Myneni 788ca77d488SHaren Myneni out_cop: 789ca77d488SHaren Myneni kfree(hv_cop_caps); 790ca77d488SHaren Myneni out: 791ca77d488SHaren Myneni kfree(hv_caps); 792ca77d488SHaren Myneni return rc; 793ca77d488SHaren Myneni } 794ca77d488SHaren Myneni machine_device_initcall(pseries, pseries_vas_init); 795