1685a6bf8SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only 21f166439SGeorge Zhang /* 31f166439SGeorge Zhang * VMware VMCI Driver 41f166439SGeorge Zhang * 51f166439SGeorge Zhang * Copyright (C) 2012 VMware, Inc. All rights reserved. 61f166439SGeorge Zhang */ 71f166439SGeorge Zhang 81f166439SGeorge Zhang #include <linux/vmw_vmci_defs.h> 91f166439SGeorge Zhang #include <linux/vmw_vmci_api.h> 101f166439SGeorge Zhang #include <linux/moduleparam.h> 111f166439SGeorge Zhang #include <linux/interrupt.h> 121f166439SGeorge Zhang #include <linux/highmem.h> 131f166439SGeorge Zhang #include <linux/kernel.h> 14ea8a83a4SDmitry Torokhov #include <linux/mm.h> 151f166439SGeorge Zhang #include <linux/module.h> 161f166439SGeorge Zhang #include <linux/sched.h> 17ea8a83a4SDmitry Torokhov #include <linux/slab.h> 181f166439SGeorge Zhang #include <linux/init.h> 191f166439SGeorge Zhang #include <linux/pci.h> 201f166439SGeorge Zhang #include <linux/smp.h> 211f166439SGeorge Zhang #include <linux/io.h> 22ea8a83a4SDmitry Torokhov #include <linux/vmalloc.h> 231f166439SGeorge Zhang 241f166439SGeorge Zhang #include "vmci_datagram.h" 251f166439SGeorge Zhang #include "vmci_doorbell.h" 261f166439SGeorge Zhang #include "vmci_context.h" 271f166439SGeorge Zhang #include "vmci_driver.h" 281f166439SGeorge Zhang #include "vmci_event.h" 291f166439SGeorge Zhang 301f166439SGeorge Zhang #define PCI_DEVICE_ID_VMWARE_VMCI 0x0740 311f166439SGeorge Zhang 321f166439SGeorge Zhang #define VMCI_UTIL_NUM_RESOURCES 1 331f166439SGeorge Zhang 341f166439SGeorge Zhang static bool vmci_disable_msi; 351f166439SGeorge Zhang module_param_named(disable_msi, vmci_disable_msi, bool, 0); 361f166439SGeorge Zhang MODULE_PARM_DESC(disable_msi, "Disable MSI use in driver - (default=0)"); 371f166439SGeorge Zhang 381f166439SGeorge Zhang static bool vmci_disable_msix; 391f166439SGeorge Zhang module_param_named(disable_msix, vmci_disable_msix, bool, 0); 401f166439SGeorge Zhang MODULE_PARM_DESC(disable_msix, "Disable MSI-X use in driver - (default=0)"); 411f166439SGeorge Zhang 421f166439SGeorge Zhang static u32 ctx_update_sub_id = VMCI_INVALID_ID; 431f166439SGeorge Zhang static u32 vm_context_id = VMCI_INVALID_ID; 441f166439SGeorge Zhang 451f166439SGeorge Zhang struct vmci_guest_device { 461f166439SGeorge Zhang struct device *dev; /* PCI device we are attached to */ 471f166439SGeorge Zhang void __iomem *iobase; 48*e283a0e8SJorgen Hansen void __iomem *mmio_base; 491f166439SGeorge Zhang 501f166439SGeorge Zhang bool exclusive_vectors; 511f166439SGeorge Zhang 521f166439SGeorge Zhang struct tasklet_struct datagram_tasklet; 531f166439SGeorge Zhang struct tasklet_struct bm_tasklet; 541f166439SGeorge Zhang 551f166439SGeorge Zhang void *data_buffer; 561f166439SGeorge Zhang void *notification_bitmap; 576d6dfb4fSAndy King dma_addr_t notification_base; 581f166439SGeorge Zhang }; 591f166439SGeorge Zhang 60f2db7361SVishnu DASA static bool use_ppn64; 61f2db7361SVishnu DASA 62f2db7361SVishnu DASA bool vmci_use_ppn64(void) 63f2db7361SVishnu DASA { 64f2db7361SVishnu DASA return use_ppn64; 65f2db7361SVishnu DASA } 66f2db7361SVishnu DASA 671f166439SGeorge Zhang /* vmci_dev singleton device and supporting data*/ 686d6dfb4fSAndy King struct pci_dev *vmci_pdev; 691f166439SGeorge Zhang static struct vmci_guest_device *vmci_dev_g; 701f166439SGeorge Zhang static DEFINE_SPINLOCK(vmci_dev_spinlock); 711f166439SGeorge Zhang 721f166439SGeorge Zhang static atomic_t vmci_num_guest_devices = ATOMIC_INIT(0); 731f166439SGeorge Zhang 741f166439SGeorge Zhang bool vmci_guest_code_active(void) 751f166439SGeorge Zhang { 761f166439SGeorge Zhang return atomic_read(&vmci_num_guest_devices) != 0; 771f166439SGeorge Zhang } 781f166439SGeorge Zhang 791f166439SGeorge Zhang u32 vmci_get_vm_context_id(void) 801f166439SGeorge Zhang { 811f166439SGeorge Zhang if (vm_context_id == VMCI_INVALID_ID) { 821f166439SGeorge Zhang struct vmci_datagram get_cid_msg; 831f166439SGeorge Zhang get_cid_msg.dst = 841f166439SGeorge Zhang vmci_make_handle(VMCI_HYPERVISOR_CONTEXT_ID, 851f166439SGeorge Zhang VMCI_GET_CONTEXT_ID); 861f166439SGeorge Zhang get_cid_msg.src = VMCI_ANON_SRC_HANDLE; 871f166439SGeorge Zhang get_cid_msg.payload_size = 0; 885a19b789SAndy King vm_context_id = vmci_send_datagram(&get_cid_msg); 891f166439SGeorge Zhang } 901f166439SGeorge Zhang return vm_context_id; 911f166439SGeorge Zhang } 921f166439SGeorge Zhang 93*e283a0e8SJorgen Hansen static unsigned int vmci_read_reg(struct vmci_guest_device *dev, u32 reg) 94*e283a0e8SJorgen Hansen { 95*e283a0e8SJorgen Hansen if (dev->mmio_base != NULL) 96*e283a0e8SJorgen Hansen return readl(dev->mmio_base + reg); 97*e283a0e8SJorgen Hansen return ioread32(dev->iobase + reg); 98*e283a0e8SJorgen Hansen } 99*e283a0e8SJorgen Hansen 100*e283a0e8SJorgen Hansen static void vmci_write_reg(struct vmci_guest_device *dev, u32 val, u32 reg) 101*e283a0e8SJorgen Hansen { 102*e283a0e8SJorgen Hansen if (dev->mmio_base != NULL) 103*e283a0e8SJorgen Hansen writel(val, dev->mmio_base + reg); 104*e283a0e8SJorgen Hansen else 105*e283a0e8SJorgen Hansen iowrite32(val, dev->iobase + reg); 106*e283a0e8SJorgen Hansen } 107*e283a0e8SJorgen Hansen 1081f166439SGeorge Zhang /* 1091f166439SGeorge Zhang * VM to hypervisor call mechanism. We use the standard VMware naming 1101f166439SGeorge Zhang * convention since shared code is calling this function as well. 1111f166439SGeorge Zhang */ 1121f166439SGeorge Zhang int vmci_send_datagram(struct vmci_datagram *dg) 1131f166439SGeorge Zhang { 1141f166439SGeorge Zhang unsigned long flags; 1151f166439SGeorge Zhang int result; 1161f166439SGeorge Zhang 1171f166439SGeorge Zhang /* Check args. */ 1181f166439SGeorge Zhang if (dg == NULL) 1191f166439SGeorge Zhang return VMCI_ERROR_INVALID_ARGS; 1201f166439SGeorge Zhang 1211f166439SGeorge Zhang /* 1221f166439SGeorge Zhang * Need to acquire spinlock on the device because the datagram 1231f166439SGeorge Zhang * data may be spread over multiple pages and the monitor may 1241f166439SGeorge Zhang * interleave device user rpc calls from multiple 1251f166439SGeorge Zhang * VCPUs. Acquiring the spinlock precludes that 1261f166439SGeorge Zhang * possibility. Disabling interrupts to avoid incoming 1271f166439SGeorge Zhang * datagrams during a "rep out" and possibly landing up in 1281f166439SGeorge Zhang * this function. 1291f166439SGeorge Zhang */ 1301f166439SGeorge Zhang spin_lock_irqsave(&vmci_dev_spinlock, flags); 1311f166439SGeorge Zhang 1321f166439SGeorge Zhang if (vmci_dev_g) { 1331f166439SGeorge Zhang iowrite8_rep(vmci_dev_g->iobase + VMCI_DATA_OUT_ADDR, 1341f166439SGeorge Zhang dg, VMCI_DG_SIZE(dg)); 135*e283a0e8SJorgen Hansen result = vmci_read_reg(vmci_dev_g, VMCI_RESULT_LOW_ADDR); 1361f166439SGeorge Zhang } else { 1371f166439SGeorge Zhang result = VMCI_ERROR_UNAVAILABLE; 1381f166439SGeorge Zhang } 1391f166439SGeorge Zhang 1401f166439SGeorge Zhang spin_unlock_irqrestore(&vmci_dev_spinlock, flags); 1411f166439SGeorge Zhang 1421f166439SGeorge Zhang return result; 1431f166439SGeorge Zhang } 1441f166439SGeorge Zhang EXPORT_SYMBOL_GPL(vmci_send_datagram); 1451f166439SGeorge Zhang 1461f166439SGeorge Zhang /* 1471f166439SGeorge Zhang * Gets called with the new context id if updated or resumed. 1481f166439SGeorge Zhang * Context id. 1491f166439SGeorge Zhang */ 1501f166439SGeorge Zhang static void vmci_guest_cid_update(u32 sub_id, 1511f166439SGeorge Zhang const struct vmci_event_data *event_data, 1521f166439SGeorge Zhang void *client_data) 1531f166439SGeorge Zhang { 1541f166439SGeorge Zhang const struct vmci_event_payld_ctx *ev_payload = 1551f166439SGeorge Zhang vmci_event_data_const_payload(event_data); 1561f166439SGeorge Zhang 1571f166439SGeorge Zhang if (sub_id != ctx_update_sub_id) { 1581f166439SGeorge Zhang pr_devel("Invalid subscriber (ID=0x%x)\n", sub_id); 1591f166439SGeorge Zhang return; 1601f166439SGeorge Zhang } 1611f166439SGeorge Zhang 1621f166439SGeorge Zhang if (!event_data || ev_payload->context_id == VMCI_INVALID_ID) { 1631f166439SGeorge Zhang pr_devel("Invalid event data\n"); 1641f166439SGeorge Zhang return; 1651f166439SGeorge Zhang } 1661f166439SGeorge Zhang 1671f166439SGeorge Zhang pr_devel("Updating context from (ID=0x%x) to (ID=0x%x) on event (type=%d)\n", 1681f166439SGeorge Zhang vm_context_id, ev_payload->context_id, event_data->event); 1691f166439SGeorge Zhang 1701f166439SGeorge Zhang vm_context_id = ev_payload->context_id; 1711f166439SGeorge Zhang } 1721f166439SGeorge Zhang 1731f166439SGeorge Zhang /* 1741f166439SGeorge Zhang * Verify that the host supports the hypercalls we need. If it does not, 1751f166439SGeorge Zhang * try to find fallback hypercalls and use those instead. Returns 1761f166439SGeorge Zhang * true if required hypercalls (or fallback hypercalls) are 1771f166439SGeorge Zhang * supported by the host, false otherwise. 1781f166439SGeorge Zhang */ 179782f2445SDmitry Torokhov static int vmci_check_host_caps(struct pci_dev *pdev) 1801f166439SGeorge Zhang { 1811f166439SGeorge Zhang bool result; 1821f166439SGeorge Zhang struct vmci_resource_query_msg *msg; 1831f166439SGeorge Zhang u32 msg_size = sizeof(struct vmci_resource_query_hdr) + 1841f166439SGeorge Zhang VMCI_UTIL_NUM_RESOURCES * sizeof(u32); 1851f166439SGeorge Zhang struct vmci_datagram *check_msg; 1861f166439SGeorge Zhang 187b2192cfeSTetsuo Handa check_msg = kzalloc(msg_size, GFP_KERNEL); 1881f166439SGeorge Zhang if (!check_msg) { 1891f166439SGeorge Zhang dev_err(&pdev->dev, "%s: Insufficient memory\n", __func__); 190782f2445SDmitry Torokhov return -ENOMEM; 1911f166439SGeorge Zhang } 1921f166439SGeorge Zhang 1931f166439SGeorge Zhang check_msg->dst = vmci_make_handle(VMCI_HYPERVISOR_CONTEXT_ID, 1941f166439SGeorge Zhang VMCI_RESOURCES_QUERY); 1951f166439SGeorge Zhang check_msg->src = VMCI_ANON_SRC_HANDLE; 1961f166439SGeorge Zhang check_msg->payload_size = msg_size - VMCI_DG_HEADERSIZE; 1971f166439SGeorge Zhang msg = (struct vmci_resource_query_msg *)VMCI_DG_PAYLOAD(check_msg); 1981f166439SGeorge Zhang 1991f166439SGeorge Zhang msg->num_resources = VMCI_UTIL_NUM_RESOURCES; 2001f166439SGeorge Zhang msg->resources[0] = VMCI_GET_CONTEXT_ID; 2011f166439SGeorge Zhang 2021f166439SGeorge Zhang /* Checks that hyper calls are supported */ 2031f166439SGeorge Zhang result = vmci_send_datagram(check_msg) == 0x01; 2041f166439SGeorge Zhang kfree(check_msg); 2051f166439SGeorge Zhang 2061f166439SGeorge Zhang dev_dbg(&pdev->dev, "%s: Host capability check: %s\n", 2071f166439SGeorge Zhang __func__, result ? "PASSED" : "FAILED"); 2081f166439SGeorge Zhang 2091f166439SGeorge Zhang /* We need the vector. There are no fallbacks. */ 210782f2445SDmitry Torokhov return result ? 0 : -ENXIO; 2111f166439SGeorge Zhang } 2121f166439SGeorge Zhang 2131f166439SGeorge Zhang /* 2141f166439SGeorge Zhang * Reads datagrams from the data in port and dispatches them. We 2151f166439SGeorge Zhang * always start reading datagrams into only the first page of the 2161f166439SGeorge Zhang * datagram buffer. If the datagrams don't fit into one page, we 2171f166439SGeorge Zhang * use the maximum datagram buffer size for the remainder of the 2181f166439SGeorge Zhang * invocation. This is a simple heuristic for not penalizing 2191f166439SGeorge Zhang * small datagrams. 2201f166439SGeorge Zhang * 2211f166439SGeorge Zhang * This function assumes that it has exclusive access to the data 2221f166439SGeorge Zhang * in port for the duration of the call. 2231f166439SGeorge Zhang */ 2241f166439SGeorge Zhang static void vmci_dispatch_dgs(unsigned long data) 2251f166439SGeorge Zhang { 2261f166439SGeorge Zhang struct vmci_guest_device *vmci_dev = (struct vmci_guest_device *)data; 2271f166439SGeorge Zhang u8 *dg_in_buffer = vmci_dev->data_buffer; 2281f166439SGeorge Zhang struct vmci_datagram *dg; 2291f166439SGeorge Zhang size_t dg_in_buffer_size = VMCI_MAX_DG_SIZE; 2301f166439SGeorge Zhang size_t current_dg_in_buffer_size = PAGE_SIZE; 2311f166439SGeorge Zhang size_t remaining_bytes; 2321f166439SGeorge Zhang 2331f166439SGeorge Zhang BUILD_BUG_ON(VMCI_MAX_DG_SIZE < PAGE_SIZE); 2341f166439SGeorge Zhang 2351f166439SGeorge Zhang ioread8_rep(vmci_dev->iobase + VMCI_DATA_IN_ADDR, 2361f166439SGeorge Zhang vmci_dev->data_buffer, current_dg_in_buffer_size); 2371f166439SGeorge Zhang dg = (struct vmci_datagram *)dg_in_buffer; 2381f166439SGeorge Zhang remaining_bytes = current_dg_in_buffer_size; 2391f166439SGeorge Zhang 2401f166439SGeorge Zhang while (dg->dst.resource != VMCI_INVALID_ID || 2411f166439SGeorge Zhang remaining_bytes > PAGE_SIZE) { 2421f166439SGeorge Zhang unsigned dg_in_size; 2431f166439SGeorge Zhang 2441f166439SGeorge Zhang /* 2451f166439SGeorge Zhang * When the input buffer spans multiple pages, a datagram can 2461f166439SGeorge Zhang * start on any page boundary in the buffer. 2471f166439SGeorge Zhang */ 2481f166439SGeorge Zhang if (dg->dst.resource == VMCI_INVALID_ID) { 2491f166439SGeorge Zhang dg = (struct vmci_datagram *)roundup( 2501f166439SGeorge Zhang (uintptr_t)dg + 1, PAGE_SIZE); 2511f166439SGeorge Zhang remaining_bytes = 2521f166439SGeorge Zhang (size_t)(dg_in_buffer + 2531f166439SGeorge Zhang current_dg_in_buffer_size - 2541f166439SGeorge Zhang (u8 *)dg); 2551f166439SGeorge Zhang continue; 2561f166439SGeorge Zhang } 2571f166439SGeorge Zhang 2581f166439SGeorge Zhang dg_in_size = VMCI_DG_SIZE_ALIGNED(dg); 2591f166439SGeorge Zhang 2601f166439SGeorge Zhang if (dg_in_size <= dg_in_buffer_size) { 2611f166439SGeorge Zhang int result; 2621f166439SGeorge Zhang 2631f166439SGeorge Zhang /* 2641f166439SGeorge Zhang * If the remaining bytes in the datagram 2651f166439SGeorge Zhang * buffer doesn't contain the complete 2661f166439SGeorge Zhang * datagram, we first make sure we have enough 2671f166439SGeorge Zhang * room for it and then we read the reminder 2681f166439SGeorge Zhang * of the datagram and possibly any following 2691f166439SGeorge Zhang * datagrams. 2701f166439SGeorge Zhang */ 2711f166439SGeorge Zhang if (dg_in_size > remaining_bytes) { 2721f166439SGeorge Zhang if (remaining_bytes != 2731f166439SGeorge Zhang current_dg_in_buffer_size) { 2741f166439SGeorge Zhang 2751f166439SGeorge Zhang /* 2761f166439SGeorge Zhang * We move the partial 2771f166439SGeorge Zhang * datagram to the front and 2781f166439SGeorge Zhang * read the reminder of the 2791f166439SGeorge Zhang * datagram and possibly 2801f166439SGeorge Zhang * following calls into the 2811f166439SGeorge Zhang * following bytes. 2821f166439SGeorge Zhang */ 2831f166439SGeorge Zhang memmove(dg_in_buffer, dg_in_buffer + 2841f166439SGeorge Zhang current_dg_in_buffer_size - 2851f166439SGeorge Zhang remaining_bytes, 2861f166439SGeorge Zhang remaining_bytes); 2871f166439SGeorge Zhang dg = (struct vmci_datagram *) 2881f166439SGeorge Zhang dg_in_buffer; 2891f166439SGeorge Zhang } 2901f166439SGeorge Zhang 2911f166439SGeorge Zhang if (current_dg_in_buffer_size != 2921f166439SGeorge Zhang dg_in_buffer_size) 2931f166439SGeorge Zhang current_dg_in_buffer_size = 2941f166439SGeorge Zhang dg_in_buffer_size; 2951f166439SGeorge Zhang 2961f166439SGeorge Zhang ioread8_rep(vmci_dev->iobase + 2971f166439SGeorge Zhang VMCI_DATA_IN_ADDR, 2981f166439SGeorge Zhang vmci_dev->data_buffer + 2991f166439SGeorge Zhang remaining_bytes, 3001f166439SGeorge Zhang current_dg_in_buffer_size - 3011f166439SGeorge Zhang remaining_bytes); 3021f166439SGeorge Zhang } 3031f166439SGeorge Zhang 3041f166439SGeorge Zhang /* 3051f166439SGeorge Zhang * We special case event datagrams from the 3061f166439SGeorge Zhang * hypervisor. 3071f166439SGeorge Zhang */ 3081f166439SGeorge Zhang if (dg->src.context == VMCI_HYPERVISOR_CONTEXT_ID && 3091f166439SGeorge Zhang dg->dst.resource == VMCI_EVENT_HANDLER) { 3101f166439SGeorge Zhang result = vmci_event_dispatch(dg); 3111f166439SGeorge Zhang } else { 3121f166439SGeorge Zhang result = vmci_datagram_invoke_guest_handler(dg); 3131f166439SGeorge Zhang } 3141f166439SGeorge Zhang if (result < VMCI_SUCCESS) 3151f166439SGeorge Zhang dev_dbg(vmci_dev->dev, 3161f166439SGeorge Zhang "Datagram with resource (ID=0x%x) failed (err=%d)\n", 3171f166439SGeorge Zhang dg->dst.resource, result); 3181f166439SGeorge Zhang 3191f166439SGeorge Zhang /* On to the next datagram. */ 3201f166439SGeorge Zhang dg = (struct vmci_datagram *)((u8 *)dg + 3211f166439SGeorge Zhang dg_in_size); 3221f166439SGeorge Zhang } else { 3231f166439SGeorge Zhang size_t bytes_to_skip; 3241f166439SGeorge Zhang 3251f166439SGeorge Zhang /* 3261f166439SGeorge Zhang * Datagram doesn't fit in datagram buffer of maximal 3271f166439SGeorge Zhang * size. We drop it. 3281f166439SGeorge Zhang */ 3291f166439SGeorge Zhang dev_dbg(vmci_dev->dev, 3301f166439SGeorge Zhang "Failed to receive datagram (size=%u bytes)\n", 3311f166439SGeorge Zhang dg_in_size); 3321f166439SGeorge Zhang 3331f166439SGeorge Zhang bytes_to_skip = dg_in_size - remaining_bytes; 3341f166439SGeorge Zhang if (current_dg_in_buffer_size != dg_in_buffer_size) 3351f166439SGeorge Zhang current_dg_in_buffer_size = dg_in_buffer_size; 3361f166439SGeorge Zhang 3371f166439SGeorge Zhang for (;;) { 3381f166439SGeorge Zhang ioread8_rep(vmci_dev->iobase + 3391f166439SGeorge Zhang VMCI_DATA_IN_ADDR, 3401f166439SGeorge Zhang vmci_dev->data_buffer, 3411f166439SGeorge Zhang current_dg_in_buffer_size); 3421f166439SGeorge Zhang if (bytes_to_skip <= current_dg_in_buffer_size) 3431f166439SGeorge Zhang break; 3441f166439SGeorge Zhang 3451f166439SGeorge Zhang bytes_to_skip -= current_dg_in_buffer_size; 3461f166439SGeorge Zhang } 3471f166439SGeorge Zhang dg = (struct vmci_datagram *)(dg_in_buffer + 3481f166439SGeorge Zhang bytes_to_skip); 3491f166439SGeorge Zhang } 3501f166439SGeorge Zhang 3511f166439SGeorge Zhang remaining_bytes = 3521f166439SGeorge Zhang (size_t) (dg_in_buffer + current_dg_in_buffer_size - 3531f166439SGeorge Zhang (u8 *)dg); 3541f166439SGeorge Zhang 3551f166439SGeorge Zhang if (remaining_bytes < VMCI_DG_HEADERSIZE) { 3561f166439SGeorge Zhang /* Get the next batch of datagrams. */ 3571f166439SGeorge Zhang 3581f166439SGeorge Zhang ioread8_rep(vmci_dev->iobase + VMCI_DATA_IN_ADDR, 3591f166439SGeorge Zhang vmci_dev->data_buffer, 3601f166439SGeorge Zhang current_dg_in_buffer_size); 3611f166439SGeorge Zhang dg = (struct vmci_datagram *)dg_in_buffer; 3621f166439SGeorge Zhang remaining_bytes = current_dg_in_buffer_size; 3631f166439SGeorge Zhang } 3641f166439SGeorge Zhang } 3651f166439SGeorge Zhang } 3661f166439SGeorge Zhang 3671f166439SGeorge Zhang /* 3681f166439SGeorge Zhang * Scans the notification bitmap for raised flags, clears them 3691f166439SGeorge Zhang * and handles the notifications. 3701f166439SGeorge Zhang */ 3711f166439SGeorge Zhang static void vmci_process_bitmap(unsigned long data) 3721f166439SGeorge Zhang { 3731f166439SGeorge Zhang struct vmci_guest_device *dev = (struct vmci_guest_device *)data; 3741f166439SGeorge Zhang 3751f166439SGeorge Zhang if (!dev->notification_bitmap) { 3761f166439SGeorge Zhang dev_dbg(dev->dev, "No bitmap present in %s\n", __func__); 3771f166439SGeorge Zhang return; 3781f166439SGeorge Zhang } 3791f166439SGeorge Zhang 3801f166439SGeorge Zhang vmci_dbell_scan_notification_entries(dev->notification_bitmap); 3811f166439SGeorge Zhang } 3821f166439SGeorge Zhang 3831f166439SGeorge Zhang /* 3841f166439SGeorge Zhang * Interrupt handler for legacy or MSI interrupt, or for first MSI-X 3851f166439SGeorge Zhang * interrupt (vector VMCI_INTR_DATAGRAM). 3861f166439SGeorge Zhang */ 3871f166439SGeorge Zhang static irqreturn_t vmci_interrupt(int irq, void *_dev) 3881f166439SGeorge Zhang { 3891f166439SGeorge Zhang struct vmci_guest_device *dev = _dev; 3901f166439SGeorge Zhang 3911f166439SGeorge Zhang /* 3921f166439SGeorge Zhang * If we are using MSI-X with exclusive vectors then we simply schedule 3931f166439SGeorge Zhang * the datagram tasklet, since we know the interrupt was meant for us. 3941f166439SGeorge Zhang * Otherwise we must read the ICR to determine what to do. 3951f166439SGeorge Zhang */ 3961f166439SGeorge Zhang 3973bb434cdSChristoph Hellwig if (dev->exclusive_vectors) { 3981f166439SGeorge Zhang tasklet_schedule(&dev->datagram_tasklet); 3991f166439SGeorge Zhang } else { 4001f166439SGeorge Zhang unsigned int icr; 4011f166439SGeorge Zhang 4021f166439SGeorge Zhang /* Acknowledge interrupt and determine what needs doing. */ 403*e283a0e8SJorgen Hansen icr = vmci_read_reg(dev, VMCI_ICR_ADDR); 4041f166439SGeorge Zhang if (icr == 0 || icr == ~0) 4051f166439SGeorge Zhang return IRQ_NONE; 4061f166439SGeorge Zhang 4071f166439SGeorge Zhang if (icr & VMCI_ICR_DATAGRAM) { 4081f166439SGeorge Zhang tasklet_schedule(&dev->datagram_tasklet); 4091f166439SGeorge Zhang icr &= ~VMCI_ICR_DATAGRAM; 4101f166439SGeorge Zhang } 4111f166439SGeorge Zhang 4121f166439SGeorge Zhang if (icr & VMCI_ICR_NOTIFICATION) { 4131f166439SGeorge Zhang tasklet_schedule(&dev->bm_tasklet); 4141f166439SGeorge Zhang icr &= ~VMCI_ICR_NOTIFICATION; 4151f166439SGeorge Zhang } 4161f166439SGeorge Zhang 4171f166439SGeorge Zhang if (icr != 0) 4181f166439SGeorge Zhang dev_warn(dev->dev, 4191f166439SGeorge Zhang "Ignoring unknown interrupt cause (%d)\n", 4201f166439SGeorge Zhang icr); 4211f166439SGeorge Zhang } 4221f166439SGeorge Zhang 4231f166439SGeorge Zhang return IRQ_HANDLED; 4241f166439SGeorge Zhang } 4251f166439SGeorge Zhang 4261f166439SGeorge Zhang /* 4271f166439SGeorge Zhang * Interrupt handler for MSI-X interrupt vector VMCI_INTR_NOTIFICATION, 4281f166439SGeorge Zhang * which is for the notification bitmap. Will only get called if we are 4291f166439SGeorge Zhang * using MSI-X with exclusive vectors. 4301f166439SGeorge Zhang */ 4311f166439SGeorge Zhang static irqreturn_t vmci_interrupt_bm(int irq, void *_dev) 4321f166439SGeorge Zhang { 4331f166439SGeorge Zhang struct vmci_guest_device *dev = _dev; 4341f166439SGeorge Zhang 4351f166439SGeorge Zhang /* For MSI-X we can just assume it was meant for us. */ 4361f166439SGeorge Zhang tasklet_schedule(&dev->bm_tasklet); 4371f166439SGeorge Zhang 4381f166439SGeorge Zhang return IRQ_HANDLED; 4391f166439SGeorge Zhang } 4401f166439SGeorge Zhang 4411f166439SGeorge Zhang /* 4421f166439SGeorge Zhang * Most of the initialization at module load time is done here. 4431f166439SGeorge Zhang */ 4441f166439SGeorge Zhang static int vmci_guest_probe_device(struct pci_dev *pdev, 4451f166439SGeorge Zhang const struct pci_device_id *id) 4461f166439SGeorge Zhang { 4471f166439SGeorge Zhang struct vmci_guest_device *vmci_dev; 448*e283a0e8SJorgen Hansen void __iomem *iobase = NULL; 449*e283a0e8SJorgen Hansen void __iomem *mmio_base = NULL; 4501f166439SGeorge Zhang unsigned int capabilities; 451f2db7361SVishnu DASA unsigned int caps_in_use; 4521f166439SGeorge Zhang unsigned long cmd; 4531f166439SGeorge Zhang int vmci_err; 4541f166439SGeorge Zhang int error; 4551f166439SGeorge Zhang 4561f166439SGeorge Zhang dev_dbg(&pdev->dev, "Probing for vmci/PCI guest device\n"); 4571f166439SGeorge Zhang 4581f166439SGeorge Zhang error = pcim_enable_device(pdev); 4591f166439SGeorge Zhang if (error) { 4601f166439SGeorge Zhang dev_err(&pdev->dev, 4611f166439SGeorge Zhang "Failed to enable VMCI device: %d\n", error); 4621f166439SGeorge Zhang return error; 4631f166439SGeorge Zhang } 4641f166439SGeorge Zhang 465*e283a0e8SJorgen Hansen /* 466*e283a0e8SJorgen Hansen * The VMCI device with mmio access to registers requests 256KB 467*e283a0e8SJorgen Hansen * for BAR1. If present, driver will use new VMCI device 468*e283a0e8SJorgen Hansen * functionality for register access and datagram send/recv. 469*e283a0e8SJorgen Hansen */ 470*e283a0e8SJorgen Hansen 471*e283a0e8SJorgen Hansen if (pci_resource_len(pdev, 1) == VMCI_WITH_MMIO_ACCESS_BAR_SIZE) { 472*e283a0e8SJorgen Hansen dev_info(&pdev->dev, "MMIO register access is available\n"); 473*e283a0e8SJorgen Hansen mmio_base = pci_iomap_range(pdev, 1, VMCI_MMIO_ACCESS_OFFSET, 474*e283a0e8SJorgen Hansen VMCI_MMIO_ACCESS_SIZE); 475*e283a0e8SJorgen Hansen /* If the map fails, we fall back to IOIO access. */ 476*e283a0e8SJorgen Hansen if (!mmio_base) 477*e283a0e8SJorgen Hansen dev_warn(&pdev->dev, "Failed to map MMIO register access\n"); 478*e283a0e8SJorgen Hansen } 479*e283a0e8SJorgen Hansen 480*e283a0e8SJorgen Hansen if (!mmio_base) { 481*e283a0e8SJorgen Hansen error = pcim_iomap_regions(pdev, BIT(0), KBUILD_MODNAME); 4821f166439SGeorge Zhang if (error) { 4831f166439SGeorge Zhang dev_err(&pdev->dev, "Failed to reserve/map IO regions\n"); 4841f166439SGeorge Zhang return error; 4851f166439SGeorge Zhang } 4861f166439SGeorge Zhang iobase = pcim_iomap_table(pdev)[0]; 487*e283a0e8SJorgen Hansen } 4881f166439SGeorge Zhang 4891f166439SGeorge Zhang vmci_dev = devm_kzalloc(&pdev->dev, sizeof(*vmci_dev), GFP_KERNEL); 4901f166439SGeorge Zhang if (!vmci_dev) { 4911f166439SGeorge Zhang dev_err(&pdev->dev, 4921f166439SGeorge Zhang "Can't allocate memory for VMCI device\n"); 4931f166439SGeorge Zhang return -ENOMEM; 4941f166439SGeorge Zhang } 4951f166439SGeorge Zhang 4961f166439SGeorge Zhang vmci_dev->dev = &pdev->dev; 4971f166439SGeorge Zhang vmci_dev->exclusive_vectors = false; 4981f166439SGeorge Zhang vmci_dev->iobase = iobase; 499*e283a0e8SJorgen Hansen vmci_dev->mmio_base = mmio_base; 5001f166439SGeorge Zhang 5011f166439SGeorge Zhang tasklet_init(&vmci_dev->datagram_tasklet, 5021f166439SGeorge Zhang vmci_dispatch_dgs, (unsigned long)vmci_dev); 5031f166439SGeorge Zhang tasklet_init(&vmci_dev->bm_tasklet, 5041f166439SGeorge Zhang vmci_process_bitmap, (unsigned long)vmci_dev); 5051f166439SGeorge Zhang 5061f166439SGeorge Zhang vmci_dev->data_buffer = vmalloc(VMCI_MAX_DG_SIZE); 5071f166439SGeorge Zhang if (!vmci_dev->data_buffer) { 5081f166439SGeorge Zhang dev_err(&pdev->dev, 5091f166439SGeorge Zhang "Can't allocate memory for datagram buffer\n"); 5101f166439SGeorge Zhang return -ENOMEM; 5111f166439SGeorge Zhang } 5121f166439SGeorge Zhang 5131f166439SGeorge Zhang pci_set_master(pdev); /* To enable queue_pair functionality. */ 5141f166439SGeorge Zhang 5151f166439SGeorge Zhang /* 5161f166439SGeorge Zhang * Verify that the VMCI Device supports the capabilities that 5171f166439SGeorge Zhang * we need. If the device is missing capabilities that we would 5181f166439SGeorge Zhang * like to use, check for fallback capabilities and use those 5191f166439SGeorge Zhang * instead (so we can run a new VM on old hosts). Fail the load if 5201f166439SGeorge Zhang * a required capability is missing and there is no fallback. 5211f166439SGeorge Zhang * 5221f166439SGeorge Zhang * Right now, we need datagrams. There are no fallbacks. 5231f166439SGeorge Zhang */ 524*e283a0e8SJorgen Hansen capabilities = vmci_read_reg(vmci_dev, VMCI_CAPS_ADDR); 5251f166439SGeorge Zhang if (!(capabilities & VMCI_CAPS_DATAGRAM)) { 5261f166439SGeorge Zhang dev_err(&pdev->dev, "Device does not support datagrams\n"); 5271f166439SGeorge Zhang error = -ENXIO; 5281f166439SGeorge Zhang goto err_free_data_buffer; 5291f166439SGeorge Zhang } 530f2db7361SVishnu DASA caps_in_use = VMCI_CAPS_DATAGRAM; 531f2db7361SVishnu DASA 532f2db7361SVishnu DASA /* 533f2db7361SVishnu DASA * Use 64-bit PPNs if the device supports. 534f2db7361SVishnu DASA * 535f2db7361SVishnu DASA * There is no check for the return value of dma_set_mask_and_coherent 536f2db7361SVishnu DASA * since this driver can handle the default mask values if 537f2db7361SVishnu DASA * dma_set_mask_and_coherent fails. 538f2db7361SVishnu DASA */ 539f2db7361SVishnu DASA if (capabilities & VMCI_CAPS_PPN64) { 540f2db7361SVishnu DASA dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64)); 541f2db7361SVishnu DASA use_ppn64 = true; 542f2db7361SVishnu DASA caps_in_use |= VMCI_CAPS_PPN64; 543f2db7361SVishnu DASA } else { 544f2db7361SVishnu DASA dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(44)); 545f2db7361SVishnu DASA use_ppn64 = false; 546f2db7361SVishnu DASA } 5471f166439SGeorge Zhang 5481f166439SGeorge Zhang /* 5491f166439SGeorge Zhang * If the hardware supports notifications, we will use that as 5501f166439SGeorge Zhang * well. 5511f166439SGeorge Zhang */ 5521f166439SGeorge Zhang if (capabilities & VMCI_CAPS_NOTIFICATIONS) { 5536d6dfb4fSAndy King vmci_dev->notification_bitmap = dma_alloc_coherent( 5546d6dfb4fSAndy King &pdev->dev, PAGE_SIZE, &vmci_dev->notification_base, 5556d6dfb4fSAndy King GFP_KERNEL); 5561f166439SGeorge Zhang if (!vmci_dev->notification_bitmap) { 5571f166439SGeorge Zhang dev_warn(&pdev->dev, 5581f166439SGeorge Zhang "Unable to allocate notification bitmap\n"); 5591f166439SGeorge Zhang } else { 5601f166439SGeorge Zhang memset(vmci_dev->notification_bitmap, 0, PAGE_SIZE); 561f2db7361SVishnu DASA caps_in_use |= VMCI_CAPS_NOTIFICATIONS; 5621f166439SGeorge Zhang } 5631f166439SGeorge Zhang } 5641f166439SGeorge Zhang 565f2db7361SVishnu DASA dev_info(&pdev->dev, "Using capabilities 0x%x\n", caps_in_use); 5661f166439SGeorge Zhang 5671f166439SGeorge Zhang /* Let the host know which capabilities we intend to use. */ 568*e283a0e8SJorgen Hansen vmci_write_reg(vmci_dev, caps_in_use, VMCI_CAPS_ADDR); 5691f166439SGeorge Zhang 5701f166439SGeorge Zhang /* Set up global device so that we can start sending datagrams */ 5711f166439SGeorge Zhang spin_lock_irq(&vmci_dev_spinlock); 5721f166439SGeorge Zhang vmci_dev_g = vmci_dev; 5736d6dfb4fSAndy King vmci_pdev = pdev; 5741f166439SGeorge Zhang spin_unlock_irq(&vmci_dev_spinlock); 5751f166439SGeorge Zhang 5761f166439SGeorge Zhang /* 5771f166439SGeorge Zhang * Register notification bitmap with device if that capability is 5781f166439SGeorge Zhang * used. 5791f166439SGeorge Zhang */ 580f2db7361SVishnu DASA if (caps_in_use & VMCI_CAPS_NOTIFICATIONS) { 5816d6dfb4fSAndy King unsigned long bitmap_ppn = 5826d6dfb4fSAndy King vmci_dev->notification_base >> PAGE_SHIFT; 5831f166439SGeorge Zhang if (!vmci_dbell_register_notification_bitmap(bitmap_ppn)) { 5841f166439SGeorge Zhang dev_warn(&pdev->dev, 585f2db7361SVishnu DASA "VMCI device unable to register notification bitmap with PPN 0x%lx\n", 586f2db7361SVishnu DASA bitmap_ppn); 587782f2445SDmitry Torokhov error = -ENXIO; 5881f166439SGeorge Zhang goto err_remove_vmci_dev_g; 5891f166439SGeorge Zhang } 5901f166439SGeorge Zhang } 5911f166439SGeorge Zhang 5921f166439SGeorge Zhang /* Check host capabilities. */ 593782f2445SDmitry Torokhov error = vmci_check_host_caps(pdev); 594782f2445SDmitry Torokhov if (error) 5951f166439SGeorge Zhang goto err_remove_bitmap; 5961f166439SGeorge Zhang 5971f166439SGeorge Zhang /* Enable device. */ 5981f166439SGeorge Zhang 5991f166439SGeorge Zhang /* 6001f166439SGeorge Zhang * We subscribe to the VMCI_EVENT_CTX_ID_UPDATE here so we can 6011f166439SGeorge Zhang * update the internal context id when needed. 6021f166439SGeorge Zhang */ 6031f166439SGeorge Zhang vmci_err = vmci_event_subscribe(VMCI_EVENT_CTX_ID_UPDATE, 6041f166439SGeorge Zhang vmci_guest_cid_update, NULL, 6051f166439SGeorge Zhang &ctx_update_sub_id); 6061f166439SGeorge Zhang if (vmci_err < VMCI_SUCCESS) 6071f166439SGeorge Zhang dev_warn(&pdev->dev, 6081f166439SGeorge Zhang "Failed to subscribe to event (type=%d): %d\n", 6091f166439SGeorge Zhang VMCI_EVENT_CTX_ID_UPDATE, vmci_err); 6101f166439SGeorge Zhang 6111f166439SGeorge Zhang /* 6121f166439SGeorge Zhang * Enable interrupts. Try MSI-X first, then MSI, and then fallback on 6131f166439SGeorge Zhang * legacy interrupts. 6141f166439SGeorge Zhang */ 6153bb434cdSChristoph Hellwig error = pci_alloc_irq_vectors(pdev, VMCI_MAX_INTRS, VMCI_MAX_INTRS, 6163bb434cdSChristoph Hellwig PCI_IRQ_MSIX); 617c3423563SChristoph Hellwig if (error < 0) { 6183bb434cdSChristoph Hellwig error = pci_alloc_irq_vectors(pdev, 1, 1, 6193bb434cdSChristoph Hellwig PCI_IRQ_MSIX | PCI_IRQ_MSI | PCI_IRQ_LEGACY); 620c3423563SChristoph Hellwig if (error < 0) 6213bb434cdSChristoph Hellwig goto err_remove_bitmap; 6221f166439SGeorge Zhang } else { 6233bb434cdSChristoph Hellwig vmci_dev->exclusive_vectors = true; 6241f166439SGeorge Zhang } 6251f166439SGeorge Zhang 6261f166439SGeorge Zhang /* 6271f166439SGeorge Zhang * Request IRQ for legacy or MSI interrupts, or for first 6281f166439SGeorge Zhang * MSI-X vector. 6291f166439SGeorge Zhang */ 6303bb434cdSChristoph Hellwig error = request_irq(pci_irq_vector(pdev, 0), vmci_interrupt, 6313bb434cdSChristoph Hellwig IRQF_SHARED, KBUILD_MODNAME, vmci_dev); 6321f166439SGeorge Zhang if (error) { 6331f166439SGeorge Zhang dev_err(&pdev->dev, "Irq %u in use: %d\n", 6343bb434cdSChristoph Hellwig pci_irq_vector(pdev, 0), error); 6351f166439SGeorge Zhang goto err_disable_msi; 6361f166439SGeorge Zhang } 6371f166439SGeorge Zhang 6381f166439SGeorge Zhang /* 6391f166439SGeorge Zhang * For MSI-X with exclusive vectors we need to request an 6401f166439SGeorge Zhang * interrupt for each vector so that we get a separate 6411f166439SGeorge Zhang * interrupt handler routine. This allows us to distinguish 6421f166439SGeorge Zhang * between the vectors. 6431f166439SGeorge Zhang */ 6441f166439SGeorge Zhang if (vmci_dev->exclusive_vectors) { 6453bb434cdSChristoph Hellwig error = request_irq(pci_irq_vector(pdev, 1), 6461f166439SGeorge Zhang vmci_interrupt_bm, 0, KBUILD_MODNAME, 6471f166439SGeorge Zhang vmci_dev); 6481f166439SGeorge Zhang if (error) { 6491f166439SGeorge Zhang dev_err(&pdev->dev, 6501f166439SGeorge Zhang "Failed to allocate irq %u: %d\n", 6513bb434cdSChristoph Hellwig pci_irq_vector(pdev, 1), error); 6521f166439SGeorge Zhang goto err_free_irq; 6531f166439SGeorge Zhang } 6541f166439SGeorge Zhang } 6551f166439SGeorge Zhang 6561f166439SGeorge Zhang dev_dbg(&pdev->dev, "Registered device\n"); 6571f166439SGeorge Zhang 6581f166439SGeorge Zhang atomic_inc(&vmci_num_guest_devices); 6591f166439SGeorge Zhang 6601f166439SGeorge Zhang /* Enable specific interrupt bits. */ 6611f166439SGeorge Zhang cmd = VMCI_IMR_DATAGRAM; 662f2db7361SVishnu DASA if (caps_in_use & VMCI_CAPS_NOTIFICATIONS) 6631f166439SGeorge Zhang cmd |= VMCI_IMR_NOTIFICATION; 664*e283a0e8SJorgen Hansen vmci_write_reg(vmci_dev, cmd, VMCI_IMR_ADDR); 6651f166439SGeorge Zhang 6661f166439SGeorge Zhang /* Enable interrupts. */ 667*e283a0e8SJorgen Hansen vmci_write_reg(vmci_dev, VMCI_CONTROL_INT_ENABLE, VMCI_CONTROL_ADDR); 6681f166439SGeorge Zhang 6691f166439SGeorge Zhang pci_set_drvdata(pdev, vmci_dev); 670b1bba80aSStefano Garzarella 671b1bba80aSStefano Garzarella vmci_call_vsock_callback(false); 6721f166439SGeorge Zhang return 0; 6731f166439SGeorge Zhang 6741f166439SGeorge Zhang err_free_irq: 6753bb434cdSChristoph Hellwig free_irq(pci_irq_vector(pdev, 0), vmci_dev); 6761f166439SGeorge Zhang tasklet_kill(&vmci_dev->datagram_tasklet); 6771f166439SGeorge Zhang tasklet_kill(&vmci_dev->bm_tasklet); 6781f166439SGeorge Zhang 6791f166439SGeorge Zhang err_disable_msi: 6803bb434cdSChristoph Hellwig pci_free_irq_vectors(pdev); 6811f166439SGeorge Zhang 6821f166439SGeorge Zhang vmci_err = vmci_event_unsubscribe(ctx_update_sub_id); 6831f166439SGeorge Zhang if (vmci_err < VMCI_SUCCESS) 6841f166439SGeorge Zhang dev_warn(&pdev->dev, 6851f166439SGeorge Zhang "Failed to unsubscribe from event (type=%d) with subscriber (ID=0x%x): %d\n", 6861f166439SGeorge Zhang VMCI_EVENT_CTX_ID_UPDATE, ctx_update_sub_id, vmci_err); 6871f166439SGeorge Zhang 6881f166439SGeorge Zhang err_remove_bitmap: 6891f166439SGeorge Zhang if (vmci_dev->notification_bitmap) { 690*e283a0e8SJorgen Hansen vmci_write_reg(vmci_dev, VMCI_CONTROL_RESET, VMCI_CONTROL_ADDR); 6916d6dfb4fSAndy King dma_free_coherent(&pdev->dev, PAGE_SIZE, 6926d6dfb4fSAndy King vmci_dev->notification_bitmap, 6936d6dfb4fSAndy King vmci_dev->notification_base); 6941f166439SGeorge Zhang } 6951f166439SGeorge Zhang 6961f166439SGeorge Zhang err_remove_vmci_dev_g: 6971f166439SGeorge Zhang spin_lock_irq(&vmci_dev_spinlock); 6986d6dfb4fSAndy King vmci_pdev = NULL; 6991f166439SGeorge Zhang vmci_dev_g = NULL; 7001f166439SGeorge Zhang spin_unlock_irq(&vmci_dev_spinlock); 7011f166439SGeorge Zhang 7021f166439SGeorge Zhang err_free_data_buffer: 7031f166439SGeorge Zhang vfree(vmci_dev->data_buffer); 7041f166439SGeorge Zhang 7051f166439SGeorge Zhang /* The rest are managed resources and will be freed by PCI core */ 7061f166439SGeorge Zhang return error; 7071f166439SGeorge Zhang } 7081f166439SGeorge Zhang 7091f166439SGeorge Zhang static void vmci_guest_remove_device(struct pci_dev *pdev) 7101f166439SGeorge Zhang { 7111f166439SGeorge Zhang struct vmci_guest_device *vmci_dev = pci_get_drvdata(pdev); 7121f166439SGeorge Zhang int vmci_err; 7131f166439SGeorge Zhang 7141f166439SGeorge Zhang dev_dbg(&pdev->dev, "Removing device\n"); 7151f166439SGeorge Zhang 7161f166439SGeorge Zhang atomic_dec(&vmci_num_guest_devices); 7171f166439SGeorge Zhang 7181f166439SGeorge Zhang vmci_qp_guest_endpoints_exit(); 7191f166439SGeorge Zhang 7201f166439SGeorge Zhang vmci_err = vmci_event_unsubscribe(ctx_update_sub_id); 7211f166439SGeorge Zhang if (vmci_err < VMCI_SUCCESS) 7221f166439SGeorge Zhang dev_warn(&pdev->dev, 7231f166439SGeorge Zhang "Failed to unsubscribe from event (type=%d) with subscriber (ID=0x%x): %d\n", 7241f166439SGeorge Zhang VMCI_EVENT_CTX_ID_UPDATE, ctx_update_sub_id, vmci_err); 7251f166439SGeorge Zhang 7261f166439SGeorge Zhang spin_lock_irq(&vmci_dev_spinlock); 7271f166439SGeorge Zhang vmci_dev_g = NULL; 7286d6dfb4fSAndy King vmci_pdev = NULL; 7291f166439SGeorge Zhang spin_unlock_irq(&vmci_dev_spinlock); 7301f166439SGeorge Zhang 7311f166439SGeorge Zhang dev_dbg(&pdev->dev, "Resetting vmci device\n"); 732*e283a0e8SJorgen Hansen vmci_write_reg(vmci_dev, VMCI_CONTROL_RESET, VMCI_CONTROL_ADDR); 7331f166439SGeorge Zhang 7341f166439SGeorge Zhang /* 7351f166439SGeorge Zhang * Free IRQ and then disable MSI/MSI-X as appropriate. For 7361f166439SGeorge Zhang * MSI-X, we might have multiple vectors, each with their own 7371f166439SGeorge Zhang * IRQ, which we must free too. 7381f166439SGeorge Zhang */ 7391f166439SGeorge Zhang if (vmci_dev->exclusive_vectors) 7403bb434cdSChristoph Hellwig free_irq(pci_irq_vector(pdev, 1), vmci_dev); 7413bb434cdSChristoph Hellwig free_irq(pci_irq_vector(pdev, 0), vmci_dev); 7423bb434cdSChristoph Hellwig pci_free_irq_vectors(pdev); 7431f166439SGeorge Zhang 7441f166439SGeorge Zhang tasklet_kill(&vmci_dev->datagram_tasklet); 7451f166439SGeorge Zhang tasklet_kill(&vmci_dev->bm_tasklet); 7461f166439SGeorge Zhang 7471f166439SGeorge Zhang if (vmci_dev->notification_bitmap) { 7481f166439SGeorge Zhang /* 7491f166439SGeorge Zhang * The device reset above cleared the bitmap state of the 7501f166439SGeorge Zhang * device, so we can safely free it here. 7511f166439SGeorge Zhang */ 7521f166439SGeorge Zhang 7536d6dfb4fSAndy King dma_free_coherent(&pdev->dev, PAGE_SIZE, 7546d6dfb4fSAndy King vmci_dev->notification_bitmap, 7556d6dfb4fSAndy King vmci_dev->notification_base); 7561f166439SGeorge Zhang } 7571f166439SGeorge Zhang 7581f166439SGeorge Zhang vfree(vmci_dev->data_buffer); 7591f166439SGeorge Zhang 7601f166439SGeorge Zhang /* The rest are managed resources and will be freed by PCI core */ 7611f166439SGeorge Zhang } 7621f166439SGeorge Zhang 76332182cd3SGreg Kroah-Hartman static const struct pci_device_id vmci_ids[] = { 7641f166439SGeorge Zhang { PCI_DEVICE(PCI_VENDOR_ID_VMWARE, PCI_DEVICE_ID_VMWARE_VMCI), }, 7651f166439SGeorge Zhang { 0 }, 7661f166439SGeorge Zhang }; 7671f166439SGeorge Zhang MODULE_DEVICE_TABLE(pci, vmci_ids); 7681f166439SGeorge Zhang 7691f166439SGeorge Zhang static struct pci_driver vmci_guest_driver = { 7701f166439SGeorge Zhang .name = KBUILD_MODNAME, 7711f166439SGeorge Zhang .id_table = vmci_ids, 7721f166439SGeorge Zhang .probe = vmci_guest_probe_device, 7731f166439SGeorge Zhang .remove = vmci_guest_remove_device, 7741f166439SGeorge Zhang }; 7751f166439SGeorge Zhang 7761f166439SGeorge Zhang int __init vmci_guest_init(void) 7771f166439SGeorge Zhang { 7781f166439SGeorge Zhang return pci_register_driver(&vmci_guest_driver); 7791f166439SGeorge Zhang } 7801f166439SGeorge Zhang 7811f166439SGeorge Zhang void __exit vmci_guest_exit(void) 7821f166439SGeorge Zhang { 7831f166439SGeorge Zhang pci_unregister_driver(&vmci_guest_driver); 7841f166439SGeorge Zhang } 785