1 /* 2 * Copyright (c) 2008 Citrix Systems, Inc. 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27 #include <sys/cdefs.h> 28 __FBSDID("$FreeBSD$"); 29 30 #include <sys/param.h> 31 #include <sys/bus.h> 32 #include <sys/kernel.h> 33 #include <sys/malloc.h> 34 #include <sys/module.h> 35 36 #include <machine/bus.h> 37 #include <machine/resource.h> 38 #include <sys/rman.h> 39 40 #include <machine/stdarg.h> 41 42 #include <xen/xen-os.h> 43 #include <xen/features.h> 44 #include <xen/hypervisor.h> 45 #include <xen/hvm.h> 46 #include <xen/xen_intr.h> 47 48 #include <dev/pci/pcireg.h> 49 #include <dev/pci/pcivar.h> 50 51 #include <dev/xen/xenpci/xenpcivar.h> 52 53 /* 54 * This is used to find our platform device instance. 55 */ 56 static devclass_t xenpci_devclass; 57 58 static int 59 xenpci_intr_filter(void *trap_frame) 60 { 61 xen_intr_handle_upcall(trap_frame); 62 return (FILTER_HANDLED); 63 } 64 65 static int 66 xenpci_irq_init(device_t device, struct xenpci_softc *scp) 67 { 68 int error; 69 70 error = BUS_SETUP_INTR(device_get_parent(device), device, 71 scp->res_irq, INTR_MPSAFE|INTR_TYPE_MISC, 72 xenpci_intr_filter, NULL, /*trap_frame*/NULL, 73 &scp->intr_cookie); 74 if (error) 75 return error; 76 77 #ifdef SMP 78 /* 79 * When using the PCI event delivery callback we cannot assign 80 * events to specific vCPUs, so all events are delivered to vCPU#0 by 81 * Xen. Since the PCI interrupt can fire on any CPU by default, we 82 * need to bind it to vCPU#0 in order to ensure that 83 * xen_intr_handle_upcall always gets called on vCPU#0. 84 */ 85 error = BUS_BIND_INTR(device_get_parent(device), device, 86 scp->res_irq, 0); 87 if (error) 88 return error; 89 #endif 90 91 xen_hvm_set_callback(device); 92 return (0); 93 } 94 95 /* 96 * Deallocate anything allocated by xenpci_allocate_resources. 97 */ 98 static int 99 xenpci_deallocate_resources(device_t dev) 100 { 101 struct xenpci_softc *scp = device_get_softc(dev); 102 103 if (scp->res_irq != 0) { 104 bus_deactivate_resource(dev, SYS_RES_IRQ, 105 scp->rid_irq, scp->res_irq); 106 bus_release_resource(dev, SYS_RES_IRQ, 107 scp->rid_irq, scp->res_irq); 108 scp->res_irq = 0; 109 } 110 111 return (0); 112 } 113 114 /* 115 * Allocate irq and memory resources. 116 */ 117 static int 118 xenpci_allocate_resources(device_t dev) 119 { 120 struct xenpci_softc *scp = device_get_softc(dev); 121 122 scp->res_irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, 123 &scp->rid_irq, RF_SHAREABLE|RF_ACTIVE); 124 if (scp->res_irq == NULL) { 125 printf("xenpci Could not allocate irq.\n"); 126 goto errexit; 127 } 128 129 return (0); 130 131 errexit: 132 /* Cleanup anything we may have assigned. */ 133 xenpci_deallocate_resources(dev); 134 return (ENXIO); /* For want of a better idea. */ 135 } 136 137 /* 138 * Probe - just check device ID. 139 */ 140 static int 141 xenpci_probe(device_t dev) 142 { 143 144 if (pci_get_devid(dev) != 0x00015853) 145 return (ENXIO); 146 147 device_set_desc(dev, "Xen Platform Device"); 148 return (BUS_PROBE_DEFAULT); 149 } 150 151 /* 152 * Attach - find resources and talk to Xen. 153 */ 154 static int 155 xenpci_attach(device_t dev) 156 { 157 struct xenpci_softc *scp = device_get_softc(dev); 158 int error; 159 160 error = xenpci_allocate_resources(dev); 161 if (error) { 162 device_printf(dev, "xenpci_allocate_resources failed(%d).\n", 163 error); 164 goto errexit; 165 } 166 167 /* 168 * Hook the irq up to evtchn 169 */ 170 error = xenpci_irq_init(dev, scp); 171 if (error) { 172 device_printf(dev, "xenpci_irq_init failed(%d).\n", 173 error); 174 goto errexit; 175 } 176 177 return (0); 178 179 errexit: 180 /* 181 * Undo anything we may have done. 182 */ 183 xenpci_deallocate_resources(dev); 184 return (error); 185 } 186 187 /* 188 * Detach - reverse anything done by attach. 189 */ 190 static int 191 xenpci_detach(device_t dev) 192 { 193 struct xenpci_softc *scp = device_get_softc(dev); 194 device_t parent = device_get_parent(dev); 195 196 /* 197 * Take our interrupt handler out of the list of handlers 198 * that can handle this irq. 199 */ 200 if (scp->intr_cookie != NULL) { 201 if (BUS_TEARDOWN_INTR(parent, dev, 202 scp->res_irq, scp->intr_cookie) != 0) 203 device_printf(dev, 204 "intr teardown failed.. continuing\n"); 205 scp->intr_cookie = NULL; 206 } 207 208 /* 209 * Deallocate any system resources we may have 210 * allocated on behalf of this driver. 211 */ 212 return (xenpci_deallocate_resources(dev)); 213 } 214 215 static int 216 xenpci_resume(device_t dev) 217 { 218 xen_hvm_set_callback(dev); 219 return (0); 220 } 221 222 static device_method_t xenpci_methods[] = { 223 /* Device interface */ 224 DEVMETHOD(device_probe, xenpci_probe), 225 DEVMETHOD(device_attach, xenpci_attach), 226 DEVMETHOD(device_detach, xenpci_detach), 227 DEVMETHOD(device_resume, xenpci_resume), 228 229 { 0, 0 } 230 }; 231 232 static driver_t xenpci_driver = { 233 "xenpci", 234 xenpci_methods, 235 sizeof(struct xenpci_softc), 236 }; 237 238 DRIVER_MODULE(xenpci, pci, xenpci_driver, xenpci_devclass, 0, 0); 239