1/*
2 * Copyright (c) 2006, Cisco 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 *
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. Neither the name of Cisco Systems, Inc. nor the names of its contributors
15 * may be used to endorse or promote products derived from this software
16 * without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
19 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
22 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
23 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
24 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
25 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
26 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
27 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
28 * POSSIBILITY OF SUCH DAMAGE.
29 */
30
31#include <sys/cdefs.h>
32__FBSDID("$FreeBSD: stable/10/sys/dev/xen/pcifront/pcifront.c 227843 2011-11-22 21:28:20Z marius $");
33
34#include <sys/param.h>
35#include <sys/module.h>
36#include <sys/systm.h>
37#include <sys/mbuf.h>
38#include <sys/malloc.h>
39#include <sys/kernel.h>
40#include <sys/socket.h>
41#include <sys/queue.h>
42
43#include <machine/vmparam.h>
44#include <vm/vm.h>
45#include <vm/pmap.h>
46
47#include <machine/bus.h>
48#include <machine/resource.h>
49#include <machine/frame.h>
50
51#include <sys/bus.h>
52#include <sys/rman.h>
53
54#include <machine/intr_machdep.h>
55
56#include <machine/xen-os.h>
57#include <machine/hypervisor.h>
58#include <machine/hypervisor-ifs.h>
59#include <machine/xen_intr.h>
60#include <machine/evtchn.h>
61#include <machine/xenbus.h>
62#include <machine/gnttab.h>
63#include <machine/xen-public/memory.h>
64#include <machine/xen-public/io/pciif.h>
65
66#include <sys/pciio.h>
67#include <dev/pci/pcivar.h>
68#include "pcib_if.h"
69
70#ifdef XEN_PCIDEV_FE_DEBUG
71#define DPRINTF(fmt, args...) \
72 printf("pcifront (%s:%d): " fmt, __FUNCTION__, __LINE__, ##args)
73#else
74#define DPRINTF(fmt, args...) ((void)0)
75#endif
76#define WPRINTF(fmt, args...) \
77 printf("pcifront (%s:%d): " fmt, __FUNCTION__, __LINE__, ##args)
78
79#define INVALID_GRANT_REF (0)
80#define INVALID_EVTCHN (-1)
81#define virt_to_mfn(x) (vtomach(x) >> PAGE_SHIFT)
82
83struct pcifront_device {
84 STAILQ_ENTRY(pcifront_device) next;
85
86 struct xenbus_device *xdev;
87
88 int unit;
89 int evtchn;
90 int gnt_ref;
91
92 /* Lock this when doing any operations in sh_info */
93 struct mtx sh_info_lock;
94 struct xen_pci_sharedinfo *sh_info;
95
96 device_t ndev;
97
98 int ref_cnt;
99};
100
101static STAILQ_HEAD(pcifront_dlist, pcifront_device) pdev_list = STAILQ_HEAD_INITIALIZER(pdev_list);
102
103struct xpcib_softc {
104 int domain;
105 int bus;
106 struct pcifront_device *pdev;
107};
108
109/* Allocate a PCI device structure */
110static struct pcifront_device *
111alloc_pdev(struct xenbus_device *xdev)
112{
113 struct pcifront_device *pdev = NULL;
114 int err, unit;
115
116 err = sscanf(xdev->nodename, "device/pci/%d", &unit);
117 if (err != 1) {
118 if (err == 0)
119 err = -EINVAL;
120 xenbus_dev_fatal(pdev->xdev, err, "Error scanning pci device instance number");
121 goto out;
122 }
123
124 pdev = (struct pcifront_device *)malloc(sizeof(struct pcifront_device), M_DEVBUF, M_NOWAIT);
125 if (pdev == NULL) {
126 err = -ENOMEM;
127 xenbus_dev_fatal(xdev, err, "Error allocating pcifront_device struct");
128 goto out;
129 }
130 pdev->unit = unit;
131 pdev->xdev = xdev;
132 pdev->ref_cnt = 1;
133
134 pdev->sh_info = (struct xen_pci_sharedinfo *)malloc(PAGE_SIZE, M_DEVBUF, M_NOWAIT);
135 if (pdev->sh_info == NULL) {
136 free(pdev, M_DEVBUF);
137 pdev = NULL;
138 err = -ENOMEM;
139 xenbus_dev_fatal(xdev, err, "Error allocating sh_info struct");
140 goto out;
141 }
142 pdev->sh_info->flags = 0;
143
144 xdev->data = pdev;
145
146 mtx_init(&pdev->sh_info_lock, "info_lock", "pci shared dev info lock", MTX_DEF);
147
148 pdev->evtchn = INVALID_EVTCHN;
149 pdev->gnt_ref = INVALID_GRANT_REF;
150
151 STAILQ_INSERT_TAIL(&pdev_list, pdev, next);
152
153 DPRINTF("Allocated pdev @ 0x%p (unit=%d)\n", pdev, unit);
154
155 out:
156 return pdev;
157}
158
159/* Hold a reference to a pcifront device */
160static void
161get_pdev(struct pcifront_device *pdev)
162{
163 pdev->ref_cnt++;
164}
165
166/* Release a reference to a pcifront device */
167static void
168put_pdev(struct pcifront_device *pdev)
169{
170 if (--pdev->ref_cnt > 0)
171 return;
172
173 DPRINTF("freeing pdev @ 0x%p (ref_cnt=%d)\n", pdev, pdev->ref_cnt);
174
175 if (pdev->evtchn != INVALID_EVTCHN)
176 xenbus_free_evtchn(pdev->xdev, pdev->evtchn);
177
178 if (pdev->gnt_ref != INVALID_GRANT_REF)
179 gnttab_end_foreign_access(pdev->gnt_ref, 0, (void *)pdev->sh_info);
180
181 pdev->xdev->data = NULL;
182
183 free(pdev, M_DEVBUF);
184}
185
186
187/* Write to the xenbus info needed by backend */
188static int
189pcifront_publish_info(struct pcifront_device *pdev)
190{
191 int err = 0;
192 struct xenbus_transaction *trans;
193
194 err = xenbus_grant_ring(pdev->xdev, virt_to_mfn(pdev->sh_info));
195 if (err < 0) {
196 WPRINTF("error granting access to ring page\n");
197 goto out;
198 }
199
200 pdev->gnt_ref = err;
201
202 err = xenbus_alloc_evtchn(pdev->xdev, &pdev->evtchn);
203 if (err)
204 goto out;
205
206 do_publish:
207 trans = xenbus_transaction_start();
208 if (IS_ERR(trans)) {
209 xenbus_dev_fatal(pdev->xdev, err,
210 "Error writing configuration for backend "
211 "(start transaction)");
212 goto out;
213 }
214
215 err = xenbus_printf(trans, pdev->xdev->nodename,
216 "pci-op-ref", "%u", pdev->gnt_ref);
217 if (!err)
218 err = xenbus_printf(trans, pdev->xdev->nodename,
219 "event-channel", "%u", pdev->evtchn);
220 if (!err)
221 err = xenbus_printf(trans, pdev->xdev->nodename,
222 "magic", XEN_PCI_MAGIC);
223 if (!err)
224 err = xenbus_switch_state(pdev->xdev, trans,
225 XenbusStateInitialised);
226
227 if (err) {
228 xenbus_transaction_end(trans, 1);
229 xenbus_dev_fatal(pdev->xdev, err,
230 "Error writing configuration for backend");
231 goto out;
232 } else {
233 err = xenbus_transaction_end(trans, 0);
234 if (err == -EAGAIN)
235 goto do_publish;
236 else if (err) {
237 xenbus_dev_fatal(pdev->xdev, err,
238 "Error completing transaction for backend");
239 goto out;
240 }
241 }
242
243 out:
244 return err;
245}
246
247/* The backend is now connected so complete the connection process on our side */
248static int
249pcifront_connect(struct pcifront_device *pdev)
250{
251 device_t nexus;
252 devclass_t nexus_devclass;
253
254 /* We will add our device as a child of the nexus0 device */
255 if (!(nexus_devclass = devclass_find("nexus")) ||
256 !(nexus = devclass_get_device(nexus_devclass, 0))) {
257 WPRINTF("could not find nexus0!\n");
258 return -1;
259 }
260
261 /* Create a newbus device representing this frontend instance */
262 pdev->ndev = BUS_ADD_CHILD(nexus, 0, "xpcife", pdev->unit);
263 if (!pdev->ndev) {
264 WPRINTF("could not create xpcife%d!\n", pdev->unit);
265 return -EFAULT;
266 }
267 get_pdev(pdev);
268 device_set_ivars(pdev->ndev, pdev);
269
270 /* Good to go connected now */
271 xenbus_switch_state(pdev->xdev, NULL, XenbusStateConnected);
272
273 printf("pcifront: connected to %s\n", pdev->xdev->nodename);
274
275 mtx_lock(&Giant);
276 device_probe_and_attach(pdev->ndev);
277 mtx_unlock(&Giant);
278
279 return 0;
280}
281
282/* The backend is closing so process a disconnect */
283static int
284pcifront_disconnect(struct pcifront_device *pdev)
285{
286 int err = 0;
287 XenbusState prev_state;
288
289 prev_state = xenbus_read_driver_state(pdev->xdev->nodename);
290
291 if (prev_state < XenbusStateClosing) {
292 err = xenbus_switch_state(pdev->xdev, NULL, XenbusStateClosing);
293 if (!err && prev_state == XenbusStateConnected) {
294 /* TODO - need to detach the newbus devices */
295 }
296 }
297
298 return err;
299}
300
301/* Process a probe from the xenbus */
302static int
303pcifront_probe(struct xenbus_device *xdev,
304 const struct xenbus_device_id *id)
305{
306 int err = 0;
307 struct pcifront_device *pdev;
308
309 DPRINTF("xenbus probing\n");
310
311 if ((pdev = alloc_pdev(xdev)) == NULL)
312 goto out;
313
314 err = pcifront_publish_info(pdev);
315
316 out:
317 if (err)
318 put_pdev(pdev);
319 return err;
320}
321
322/* Remove the xenbus PCI device */
323static int
324pcifront_remove(struct xenbus_device *xdev)
325{
326 DPRINTF("removing xenbus device node (%s)\n", xdev->nodename);
327 if (xdev->data)
328 put_pdev(xdev->data);
329 return 0;
330}
331
332/* Called by xenbus when our backend node changes state */
333static void
334pcifront_backend_changed(struct xenbus_device *xdev,
335 XenbusState be_state)
336{
337 struct pcifront_device *pdev = xdev->data;
338
339 switch (be_state) {
340 case XenbusStateClosing:
341 DPRINTF("backend closing (%s)\n", xdev->nodename);
342 pcifront_disconnect(pdev);
343 break;
344
345 case XenbusStateClosed:
346 DPRINTF("backend closed (%s)\n", xdev->nodename);
347 pcifront_disconnect(pdev);
348 break;
349
350 case XenbusStateConnected:
351 DPRINTF("backend connected (%s)\n", xdev->nodename);
352 pcifront_connect(pdev);
353 break;
354
355 default:
356 break;
357 }
358}
359
360/* Process PCI operation */
361static int
362do_pci_op(struct pcifront_device *pdev, struct xen_pci_op *op)
363{
364 int err = 0;
365 struct xen_pci_op *active_op = &pdev->sh_info->op;
366 evtchn_port_t port = pdev->evtchn;
367 time_t timeout;
368
369 mtx_lock(&pdev->sh_info_lock);
370
371 memcpy(active_op, op, sizeof(struct xen_pci_op));
372
373 /* Go */
374 wmb();
375 set_bit(_XEN_PCIF_active, (unsigned long *)&pdev->sh_info->flags);
376 notify_remote_via_evtchn(port);
377
378 timeout = time_uptime + 2;
379
380 clear_evtchn(port);
381
382 /* Spin while waiting for the answer */
383 while (test_bit
384 (_XEN_PCIF_active, (unsigned long *)&pdev->sh_info->flags)) {
385 int err = HYPERVISOR_poll(&port, 1, 3 * hz);
386 if (err)
387 panic("Failed HYPERVISOR_poll: err=%d", err);
388 clear_evtchn(port);
389 if (time_uptime > timeout) {
390 WPRINTF("pciback not responding!!!\n");
391 clear_bit(_XEN_PCIF_active,
392 (unsigned long *)&pdev->sh_info->flags);
393 err = XEN_PCI_ERR_dev_not_found;
394 goto out;
395 }
396 }
397
398 memcpy(op, active_op, sizeof(struct xen_pci_op));
399
400 err = op->err;
401 out:
402 mtx_unlock(&pdev->sh_info_lock);
403 return err;
404}
405
406/* ** XenBus Driver registration ** */
407
408static struct xenbus_device_id pcifront_ids[] = {
409 { "pci" },
410 { "" }
411};
412
413static struct xenbus_driver pcifront = {
414 .name = "pcifront",
415 .ids = pcifront_ids,
416 .probe = pcifront_probe,
417 .remove = pcifront_remove,
418 .otherend_changed = pcifront_backend_changed,
419};
420
421/* Register the driver with xenbus during sys init */
422static void
423pcifront_init(void *unused)
424{
425 if ((xen_start_info->flags & SIF_INITDOMAIN))
426 return;
427
428 DPRINTF("xenbus registering\n");
429
430 xenbus_register_frontend(&pcifront);
431}
432
433SYSINIT(pciif, SI_SUB_PSEUDO, SI_ORDER_ANY, pcifront_init, NULL)
434
435
436/* Newbus xpcife device driver probe */
437static int
438xpcife_probe(device_t dev)
439{
440#ifdef XEN_PCIDEV_FE_DEBUG
441 struct pcifront_device *pdev = (struct pcifront_device *)device_get_ivars(dev);
442 DPRINTF("xpcife probe (unit=%d)\n", pdev->unit);
443#endif
444 return 0;
445}
446
447/* Newbus xpcife device driver attach */
448static int
449xpcife_attach(device_t dev)
450{
451 struct pcifront_device *pdev = (struct pcifront_device *)device_get_ivars(dev);
452 int i, num_roots, len, err;
453 char str[64];
454 unsigned int domain, bus;
455
456 DPRINTF("xpcife attach (unit=%d)\n", pdev->unit);
457
458 err = xenbus_scanf(NULL, pdev->xdev->otherend,
459 "root_num", "%d", &num_roots);
460 if (err != 1) {
461 if (err == 0)
462 err = -EINVAL;
463 xenbus_dev_fatal(pdev->xdev, err,
464 "Error reading number of PCI roots");
465 goto out;
466 }
467
468 /* Add a pcib device for each root */
469 for (i = 0; i < num_roots; i++) {
470 device_t child;
471
472 len = snprintf(str, sizeof(str), "root-%d", i);
473 if (unlikely(len >= (sizeof(str) - 1))) {
474 err = -ENOMEM;
475 goto out;
476 }
477
478 err = xenbus_scanf(NULL, pdev->xdev->otherend, str,
479 "%x:%x", &domain, &bus);
480 if (err != 2) {
481 if (err >= 0)
482 err = -EINVAL;
483 xenbus_dev_fatal(pdev->xdev, err,
484 "Error reading PCI root %d", i);
485 goto out;
486 }
487 err = 0;
488 if (domain != pdev->xdev->otherend_id) {
489 err = -EINVAL;
490 xenbus_dev_fatal(pdev->xdev, err,
491 "Domain mismatch %d != %d", domain, pdev->xdev->otherend_id);
492 goto out;
493 }
494
495 child = device_add_child(dev, "pcib", bus);
496 if (!child) {
497 err = -ENOMEM;
498 xenbus_dev_fatal(pdev->xdev, err,
499 "Unable to create pcib%d", bus);
500 goto out;
501 }
502 }
503
504 out:
505 return bus_generic_attach(dev);
506}
507
508static devclass_t xpcife_devclass;
509
510static device_method_t xpcife_methods[] = {
511 /* Device interface */
512 DEVMETHOD(device_probe, xpcife_probe),
513 DEVMETHOD(device_attach, xpcife_attach),
514 DEVMETHOD(device_detach, bus_generic_detach),
515 DEVMETHOD(device_shutdown, bus_generic_shutdown),
516 DEVMETHOD(device_suspend, bus_generic_suspend),
517 DEVMETHOD(device_resume, bus_generic_resume),
518 /* Bus interface */
519 DEVMETHOD(bus_alloc_resource, bus_generic_alloc_resource),
520 DEVMETHOD(bus_release_resource, bus_generic_release_resource),
521 DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
522 DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
523 DEVMETHOD(bus_setup_intr, bus_generic_setup_intr),
524 DEVMETHOD(bus_teardown_intr, bus_generic_teardown_intr),
525
526 DEVMETHOD_END
527};
528
529static driver_t xpcife_driver = {
530 "xpcife",
531 xpcife_methods,
532 0,
533};
534
535DRIVER_MODULE(xpcife, nexus, xpcife_driver, xpcife_devclass, 0, 0);
536
537
538/* Newbus xen pcib device driver probe */
539static int
540xpcib_probe(device_t dev)
541{
542 struct xpcib_softc *sc = (struct xpcib_softc *)device_get_softc(dev);
543 struct pcifront_device *pdev = (struct pcifront_device *)device_get_ivars(device_get_parent(dev));
544
545 DPRINTF("xpcib probe (bus=%d)\n", device_get_unit(dev));
546
547 sc->domain = pdev->xdev->otherend_id;
548 sc->bus = device_get_unit(dev);
549 sc->pdev = pdev;
550
551 return 0;
552}
553
554/* Newbus xen pcib device driver attach */
555static int
556xpcib_attach(device_t dev)
557{
558 struct xpcib_softc *sc = (struct xpcib_softc *)device_get_softc(dev);
559
560 DPRINTF("xpcib attach (bus=%d)\n", sc->bus);
561
562 device_add_child(dev, "pci", sc->bus);
563 return bus_generic_attach(dev);
564}
565
566static int
567xpcib_read_ivar(device_t dev, device_t child, int which, uintptr_t *result)
568{
569 struct xpcib_softc *sc = (struct xpcib_softc *)device_get_softc(dev);
570 switch (which) {
571 case PCIB_IVAR_BUS:
572 *result = sc->bus;
573 return 0;
574 }
575 return ENOENT;
576}
577
578/* Return the number of slots supported */
579static int
580xpcib_maxslots(device_t dev)
581{
582 return 31;
583}
584
585#define PCI_DEVFN(slot,func) ((((slot) & 0x1f) << 3) | ((func) & 0x07))
586
587/* Read configuration space register */
588static u_int32_t
589xpcib_read_config(device_t dev, int bus, int slot, int func,
590 int reg, int bytes)
591{
592 struct xpcib_softc *sc = (struct xpcib_softc *)device_get_softc(dev);
593 struct xen_pci_op op = {
594 .cmd = XEN_PCI_OP_conf_read,
595 .domain = sc->domain,
596 .bus = sc->bus,
597 .devfn = PCI_DEVFN(slot, func),
598 .offset = reg,
599 .size = bytes,
600 };
601 int err;
602
603 err = do_pci_op(sc->pdev, &op);
604
605 DPRINTF("read config (b=%d, s=%d, f=%d, reg=%d, len=%d, val=%x, err=%d)\n",
606 bus, slot, func, reg, bytes, op.value, err);
607
608 if (err)
609 op.value = ~0;
610
611 return op.value;
612}
613
614/* Write configuration space register */
615static void
616xpcib_write_config(device_t dev, int bus, int slot, int func,
617 int reg, u_int32_t data, int bytes)
618{
619 struct xpcib_softc *sc = (struct xpcib_softc *)device_get_softc(dev);
620 struct xen_pci_op op = {
621 .cmd = XEN_PCI_OP_conf_write,
622 .domain = sc->domain,
623 .bus = sc->bus,
624 .devfn = PCI_DEVFN(slot, func),
625 .offset = reg,
626 .size = bytes,
627 .value = data,
628 };
629 int err;
630
631 err = do_pci_op(sc->pdev, &op);
632
633 DPRINTF("write config (b=%d, s=%d, f=%d, reg=%d, len=%d, val=%x, err=%d)\n",
634 bus, slot, func, reg, bytes, data, err);
635}
636
637static int
638xpcib_route_interrupt(device_t pcib, device_t dev, int pin)
639{
640 struct pci_devinfo *dinfo = device_get_ivars(dev);
641 pcicfgregs *cfg = &dinfo->cfg;
642
643 DPRINTF("route intr (pin=%d, line=%d)\n", pin, cfg->intline);
644
645 return cfg->intline;
646}
647
648static device_method_t xpcib_methods[] = {
649 /* Device interface */
650 DEVMETHOD(device_probe, xpcib_probe),
651 DEVMETHOD(device_attach, xpcib_attach),
652 DEVMETHOD(device_detach, bus_generic_detach),
653 DEVMETHOD(device_shutdown, bus_generic_shutdown),
654 DEVMETHOD(device_suspend, bus_generic_suspend),
655 DEVMETHOD(device_resume, bus_generic_resume),
656
657 /* Bus interface */
658 DEVMETHOD(bus_read_ivar, xpcib_read_ivar),
659 DEVMETHOD(bus_alloc_resource, bus_generic_alloc_resource),
660 DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
661 DEVMETHOD(bus_release_resource, bus_generic_release_resource),
662 DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
663 DEVMETHOD(bus_setup_intr, bus_generic_setup_intr),
664 DEVMETHOD(bus_teardown_intr, bus_generic_teardown_intr),
665
666 /* pcib interface */
667 DEVMETHOD(pcib_maxslots, xpcib_maxslots),
668 DEVMETHOD(pcib_read_config, xpcib_read_config),
669 DEVMETHOD(pcib_write_config, xpcib_write_config),
670 DEVMETHOD(pcib_route_interrupt, xpcib_route_interrupt),
671
672 DEVMETHOD_END
673};
674
675static devclass_t xpcib_devclass;
676
677DEFINE_CLASS_0(pcib, xpcib_driver, xpcib_methods, sizeof(struct xpcib_softc));
678DRIVER_MODULE(pcib, xpcife, xpcib_driver, xpcib_devclass, 0, 0);
679
680/*
681 * Local variables:
682 * mode: C
683 * c-set-style: "BSD"
684 * c-basic-offset: 4
685 * tab-width: 4
686 * indent-tabs-mode: t
687 * End:
688 */
2 * Copyright (c) 2006, Cisco 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 *
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. Neither the name of Cisco Systems, Inc. nor the names of its contributors
15 * may be used to endorse or promote products derived from this software
16 * without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
19 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
22 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
23 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
24 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
25 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
26 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
27 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
28 * POSSIBILITY OF SUCH DAMAGE.
29 */
30
31#include <sys/cdefs.h>
32__FBSDID("$FreeBSD: stable/10/sys/dev/xen/pcifront/pcifront.c 227843 2011-11-22 21:28:20Z marius $");
33
34#include <sys/param.h>
35#include <sys/module.h>
36#include <sys/systm.h>
37#include <sys/mbuf.h>
38#include <sys/malloc.h>
39#include <sys/kernel.h>
40#include <sys/socket.h>
41#include <sys/queue.h>
42
43#include <machine/vmparam.h>
44#include <vm/vm.h>
45#include <vm/pmap.h>
46
47#include <machine/bus.h>
48#include <machine/resource.h>
49#include <machine/frame.h>
50
51#include <sys/bus.h>
52#include <sys/rman.h>
53
54#include <machine/intr_machdep.h>
55
56#include <machine/xen-os.h>
57#include <machine/hypervisor.h>
58#include <machine/hypervisor-ifs.h>
59#include <machine/xen_intr.h>
60#include <machine/evtchn.h>
61#include <machine/xenbus.h>
62#include <machine/gnttab.h>
63#include <machine/xen-public/memory.h>
64#include <machine/xen-public/io/pciif.h>
65
66#include <sys/pciio.h>
67#include <dev/pci/pcivar.h>
68#include "pcib_if.h"
69
70#ifdef XEN_PCIDEV_FE_DEBUG
71#define DPRINTF(fmt, args...) \
72 printf("pcifront (%s:%d): " fmt, __FUNCTION__, __LINE__, ##args)
73#else
74#define DPRINTF(fmt, args...) ((void)0)
75#endif
76#define WPRINTF(fmt, args...) \
77 printf("pcifront (%s:%d): " fmt, __FUNCTION__, __LINE__, ##args)
78
79#define INVALID_GRANT_REF (0)
80#define INVALID_EVTCHN (-1)
81#define virt_to_mfn(x) (vtomach(x) >> PAGE_SHIFT)
82
83struct pcifront_device {
84 STAILQ_ENTRY(pcifront_device) next;
85
86 struct xenbus_device *xdev;
87
88 int unit;
89 int evtchn;
90 int gnt_ref;
91
92 /* Lock this when doing any operations in sh_info */
93 struct mtx sh_info_lock;
94 struct xen_pci_sharedinfo *sh_info;
95
96 device_t ndev;
97
98 int ref_cnt;
99};
100
101static STAILQ_HEAD(pcifront_dlist, pcifront_device) pdev_list = STAILQ_HEAD_INITIALIZER(pdev_list);
102
103struct xpcib_softc {
104 int domain;
105 int bus;
106 struct pcifront_device *pdev;
107};
108
109/* Allocate a PCI device structure */
110static struct pcifront_device *
111alloc_pdev(struct xenbus_device *xdev)
112{
113 struct pcifront_device *pdev = NULL;
114 int err, unit;
115
116 err = sscanf(xdev->nodename, "device/pci/%d", &unit);
117 if (err != 1) {
118 if (err == 0)
119 err = -EINVAL;
120 xenbus_dev_fatal(pdev->xdev, err, "Error scanning pci device instance number");
121 goto out;
122 }
123
124 pdev = (struct pcifront_device *)malloc(sizeof(struct pcifront_device), M_DEVBUF, M_NOWAIT);
125 if (pdev == NULL) {
126 err = -ENOMEM;
127 xenbus_dev_fatal(xdev, err, "Error allocating pcifront_device struct");
128 goto out;
129 }
130 pdev->unit = unit;
131 pdev->xdev = xdev;
132 pdev->ref_cnt = 1;
133
134 pdev->sh_info = (struct xen_pci_sharedinfo *)malloc(PAGE_SIZE, M_DEVBUF, M_NOWAIT);
135 if (pdev->sh_info == NULL) {
136 free(pdev, M_DEVBUF);
137 pdev = NULL;
138 err = -ENOMEM;
139 xenbus_dev_fatal(xdev, err, "Error allocating sh_info struct");
140 goto out;
141 }
142 pdev->sh_info->flags = 0;
143
144 xdev->data = pdev;
145
146 mtx_init(&pdev->sh_info_lock, "info_lock", "pci shared dev info lock", MTX_DEF);
147
148 pdev->evtchn = INVALID_EVTCHN;
149 pdev->gnt_ref = INVALID_GRANT_REF;
150
151 STAILQ_INSERT_TAIL(&pdev_list, pdev, next);
152
153 DPRINTF("Allocated pdev @ 0x%p (unit=%d)\n", pdev, unit);
154
155 out:
156 return pdev;
157}
158
159/* Hold a reference to a pcifront device */
160static void
161get_pdev(struct pcifront_device *pdev)
162{
163 pdev->ref_cnt++;
164}
165
166/* Release a reference to a pcifront device */
167static void
168put_pdev(struct pcifront_device *pdev)
169{
170 if (--pdev->ref_cnt > 0)
171 return;
172
173 DPRINTF("freeing pdev @ 0x%p (ref_cnt=%d)\n", pdev, pdev->ref_cnt);
174
175 if (pdev->evtchn != INVALID_EVTCHN)
176 xenbus_free_evtchn(pdev->xdev, pdev->evtchn);
177
178 if (pdev->gnt_ref != INVALID_GRANT_REF)
179 gnttab_end_foreign_access(pdev->gnt_ref, 0, (void *)pdev->sh_info);
180
181 pdev->xdev->data = NULL;
182
183 free(pdev, M_DEVBUF);
184}
185
186
187/* Write to the xenbus info needed by backend */
188static int
189pcifront_publish_info(struct pcifront_device *pdev)
190{
191 int err = 0;
192 struct xenbus_transaction *trans;
193
194 err = xenbus_grant_ring(pdev->xdev, virt_to_mfn(pdev->sh_info));
195 if (err < 0) {
196 WPRINTF("error granting access to ring page\n");
197 goto out;
198 }
199
200 pdev->gnt_ref = err;
201
202 err = xenbus_alloc_evtchn(pdev->xdev, &pdev->evtchn);
203 if (err)
204 goto out;
205
206 do_publish:
207 trans = xenbus_transaction_start();
208 if (IS_ERR(trans)) {
209 xenbus_dev_fatal(pdev->xdev, err,
210 "Error writing configuration for backend "
211 "(start transaction)");
212 goto out;
213 }
214
215 err = xenbus_printf(trans, pdev->xdev->nodename,
216 "pci-op-ref", "%u", pdev->gnt_ref);
217 if (!err)
218 err = xenbus_printf(trans, pdev->xdev->nodename,
219 "event-channel", "%u", pdev->evtchn);
220 if (!err)
221 err = xenbus_printf(trans, pdev->xdev->nodename,
222 "magic", XEN_PCI_MAGIC);
223 if (!err)
224 err = xenbus_switch_state(pdev->xdev, trans,
225 XenbusStateInitialised);
226
227 if (err) {
228 xenbus_transaction_end(trans, 1);
229 xenbus_dev_fatal(pdev->xdev, err,
230 "Error writing configuration for backend");
231 goto out;
232 } else {
233 err = xenbus_transaction_end(trans, 0);
234 if (err == -EAGAIN)
235 goto do_publish;
236 else if (err) {
237 xenbus_dev_fatal(pdev->xdev, err,
238 "Error completing transaction for backend");
239 goto out;
240 }
241 }
242
243 out:
244 return err;
245}
246
247/* The backend is now connected so complete the connection process on our side */
248static int
249pcifront_connect(struct pcifront_device *pdev)
250{
251 device_t nexus;
252 devclass_t nexus_devclass;
253
254 /* We will add our device as a child of the nexus0 device */
255 if (!(nexus_devclass = devclass_find("nexus")) ||
256 !(nexus = devclass_get_device(nexus_devclass, 0))) {
257 WPRINTF("could not find nexus0!\n");
258 return -1;
259 }
260
261 /* Create a newbus device representing this frontend instance */
262 pdev->ndev = BUS_ADD_CHILD(nexus, 0, "xpcife", pdev->unit);
263 if (!pdev->ndev) {
264 WPRINTF("could not create xpcife%d!\n", pdev->unit);
265 return -EFAULT;
266 }
267 get_pdev(pdev);
268 device_set_ivars(pdev->ndev, pdev);
269
270 /* Good to go connected now */
271 xenbus_switch_state(pdev->xdev, NULL, XenbusStateConnected);
272
273 printf("pcifront: connected to %s\n", pdev->xdev->nodename);
274
275 mtx_lock(&Giant);
276 device_probe_and_attach(pdev->ndev);
277 mtx_unlock(&Giant);
278
279 return 0;
280}
281
282/* The backend is closing so process a disconnect */
283static int
284pcifront_disconnect(struct pcifront_device *pdev)
285{
286 int err = 0;
287 XenbusState prev_state;
288
289 prev_state = xenbus_read_driver_state(pdev->xdev->nodename);
290
291 if (prev_state < XenbusStateClosing) {
292 err = xenbus_switch_state(pdev->xdev, NULL, XenbusStateClosing);
293 if (!err && prev_state == XenbusStateConnected) {
294 /* TODO - need to detach the newbus devices */
295 }
296 }
297
298 return err;
299}
300
301/* Process a probe from the xenbus */
302static int
303pcifront_probe(struct xenbus_device *xdev,
304 const struct xenbus_device_id *id)
305{
306 int err = 0;
307 struct pcifront_device *pdev;
308
309 DPRINTF("xenbus probing\n");
310
311 if ((pdev = alloc_pdev(xdev)) == NULL)
312 goto out;
313
314 err = pcifront_publish_info(pdev);
315
316 out:
317 if (err)
318 put_pdev(pdev);
319 return err;
320}
321
322/* Remove the xenbus PCI device */
323static int
324pcifront_remove(struct xenbus_device *xdev)
325{
326 DPRINTF("removing xenbus device node (%s)\n", xdev->nodename);
327 if (xdev->data)
328 put_pdev(xdev->data);
329 return 0;
330}
331
332/* Called by xenbus when our backend node changes state */
333static void
334pcifront_backend_changed(struct xenbus_device *xdev,
335 XenbusState be_state)
336{
337 struct pcifront_device *pdev = xdev->data;
338
339 switch (be_state) {
340 case XenbusStateClosing:
341 DPRINTF("backend closing (%s)\n", xdev->nodename);
342 pcifront_disconnect(pdev);
343 break;
344
345 case XenbusStateClosed:
346 DPRINTF("backend closed (%s)\n", xdev->nodename);
347 pcifront_disconnect(pdev);
348 break;
349
350 case XenbusStateConnected:
351 DPRINTF("backend connected (%s)\n", xdev->nodename);
352 pcifront_connect(pdev);
353 break;
354
355 default:
356 break;
357 }
358}
359
360/* Process PCI operation */
361static int
362do_pci_op(struct pcifront_device *pdev, struct xen_pci_op *op)
363{
364 int err = 0;
365 struct xen_pci_op *active_op = &pdev->sh_info->op;
366 evtchn_port_t port = pdev->evtchn;
367 time_t timeout;
368
369 mtx_lock(&pdev->sh_info_lock);
370
371 memcpy(active_op, op, sizeof(struct xen_pci_op));
372
373 /* Go */
374 wmb();
375 set_bit(_XEN_PCIF_active, (unsigned long *)&pdev->sh_info->flags);
376 notify_remote_via_evtchn(port);
377
378 timeout = time_uptime + 2;
379
380 clear_evtchn(port);
381
382 /* Spin while waiting for the answer */
383 while (test_bit
384 (_XEN_PCIF_active, (unsigned long *)&pdev->sh_info->flags)) {
385 int err = HYPERVISOR_poll(&port, 1, 3 * hz);
386 if (err)
387 panic("Failed HYPERVISOR_poll: err=%d", err);
388 clear_evtchn(port);
389 if (time_uptime > timeout) {
390 WPRINTF("pciback not responding!!!\n");
391 clear_bit(_XEN_PCIF_active,
392 (unsigned long *)&pdev->sh_info->flags);
393 err = XEN_PCI_ERR_dev_not_found;
394 goto out;
395 }
396 }
397
398 memcpy(op, active_op, sizeof(struct xen_pci_op));
399
400 err = op->err;
401 out:
402 mtx_unlock(&pdev->sh_info_lock);
403 return err;
404}
405
406/* ** XenBus Driver registration ** */
407
408static struct xenbus_device_id pcifront_ids[] = {
409 { "pci" },
410 { "" }
411};
412
413static struct xenbus_driver pcifront = {
414 .name = "pcifront",
415 .ids = pcifront_ids,
416 .probe = pcifront_probe,
417 .remove = pcifront_remove,
418 .otherend_changed = pcifront_backend_changed,
419};
420
421/* Register the driver with xenbus during sys init */
422static void
423pcifront_init(void *unused)
424{
425 if ((xen_start_info->flags & SIF_INITDOMAIN))
426 return;
427
428 DPRINTF("xenbus registering\n");
429
430 xenbus_register_frontend(&pcifront);
431}
432
433SYSINIT(pciif, SI_SUB_PSEUDO, SI_ORDER_ANY, pcifront_init, NULL)
434
435
436/* Newbus xpcife device driver probe */
437static int
438xpcife_probe(device_t dev)
439{
440#ifdef XEN_PCIDEV_FE_DEBUG
441 struct pcifront_device *pdev = (struct pcifront_device *)device_get_ivars(dev);
442 DPRINTF("xpcife probe (unit=%d)\n", pdev->unit);
443#endif
444 return 0;
445}
446
447/* Newbus xpcife device driver attach */
448static int
449xpcife_attach(device_t dev)
450{
451 struct pcifront_device *pdev = (struct pcifront_device *)device_get_ivars(dev);
452 int i, num_roots, len, err;
453 char str[64];
454 unsigned int domain, bus;
455
456 DPRINTF("xpcife attach (unit=%d)\n", pdev->unit);
457
458 err = xenbus_scanf(NULL, pdev->xdev->otherend,
459 "root_num", "%d", &num_roots);
460 if (err != 1) {
461 if (err == 0)
462 err = -EINVAL;
463 xenbus_dev_fatal(pdev->xdev, err,
464 "Error reading number of PCI roots");
465 goto out;
466 }
467
468 /* Add a pcib device for each root */
469 for (i = 0; i < num_roots; i++) {
470 device_t child;
471
472 len = snprintf(str, sizeof(str), "root-%d", i);
473 if (unlikely(len >= (sizeof(str) - 1))) {
474 err = -ENOMEM;
475 goto out;
476 }
477
478 err = xenbus_scanf(NULL, pdev->xdev->otherend, str,
479 "%x:%x", &domain, &bus);
480 if (err != 2) {
481 if (err >= 0)
482 err = -EINVAL;
483 xenbus_dev_fatal(pdev->xdev, err,
484 "Error reading PCI root %d", i);
485 goto out;
486 }
487 err = 0;
488 if (domain != pdev->xdev->otherend_id) {
489 err = -EINVAL;
490 xenbus_dev_fatal(pdev->xdev, err,
491 "Domain mismatch %d != %d", domain, pdev->xdev->otherend_id);
492 goto out;
493 }
494
495 child = device_add_child(dev, "pcib", bus);
496 if (!child) {
497 err = -ENOMEM;
498 xenbus_dev_fatal(pdev->xdev, err,
499 "Unable to create pcib%d", bus);
500 goto out;
501 }
502 }
503
504 out:
505 return bus_generic_attach(dev);
506}
507
508static devclass_t xpcife_devclass;
509
510static device_method_t xpcife_methods[] = {
511 /* Device interface */
512 DEVMETHOD(device_probe, xpcife_probe),
513 DEVMETHOD(device_attach, xpcife_attach),
514 DEVMETHOD(device_detach, bus_generic_detach),
515 DEVMETHOD(device_shutdown, bus_generic_shutdown),
516 DEVMETHOD(device_suspend, bus_generic_suspend),
517 DEVMETHOD(device_resume, bus_generic_resume),
518 /* Bus interface */
519 DEVMETHOD(bus_alloc_resource, bus_generic_alloc_resource),
520 DEVMETHOD(bus_release_resource, bus_generic_release_resource),
521 DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
522 DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
523 DEVMETHOD(bus_setup_intr, bus_generic_setup_intr),
524 DEVMETHOD(bus_teardown_intr, bus_generic_teardown_intr),
525
526 DEVMETHOD_END
527};
528
529static driver_t xpcife_driver = {
530 "xpcife",
531 xpcife_methods,
532 0,
533};
534
535DRIVER_MODULE(xpcife, nexus, xpcife_driver, xpcife_devclass, 0, 0);
536
537
538/* Newbus xen pcib device driver probe */
539static int
540xpcib_probe(device_t dev)
541{
542 struct xpcib_softc *sc = (struct xpcib_softc *)device_get_softc(dev);
543 struct pcifront_device *pdev = (struct pcifront_device *)device_get_ivars(device_get_parent(dev));
544
545 DPRINTF("xpcib probe (bus=%d)\n", device_get_unit(dev));
546
547 sc->domain = pdev->xdev->otherend_id;
548 sc->bus = device_get_unit(dev);
549 sc->pdev = pdev;
550
551 return 0;
552}
553
554/* Newbus xen pcib device driver attach */
555static int
556xpcib_attach(device_t dev)
557{
558 struct xpcib_softc *sc = (struct xpcib_softc *)device_get_softc(dev);
559
560 DPRINTF("xpcib attach (bus=%d)\n", sc->bus);
561
562 device_add_child(dev, "pci", sc->bus);
563 return bus_generic_attach(dev);
564}
565
566static int
567xpcib_read_ivar(device_t dev, device_t child, int which, uintptr_t *result)
568{
569 struct xpcib_softc *sc = (struct xpcib_softc *)device_get_softc(dev);
570 switch (which) {
571 case PCIB_IVAR_BUS:
572 *result = sc->bus;
573 return 0;
574 }
575 return ENOENT;
576}
577
578/* Return the number of slots supported */
579static int
580xpcib_maxslots(device_t dev)
581{
582 return 31;
583}
584
585#define PCI_DEVFN(slot,func) ((((slot) & 0x1f) << 3) | ((func) & 0x07))
586
587/* Read configuration space register */
588static u_int32_t
589xpcib_read_config(device_t dev, int bus, int slot, int func,
590 int reg, int bytes)
591{
592 struct xpcib_softc *sc = (struct xpcib_softc *)device_get_softc(dev);
593 struct xen_pci_op op = {
594 .cmd = XEN_PCI_OP_conf_read,
595 .domain = sc->domain,
596 .bus = sc->bus,
597 .devfn = PCI_DEVFN(slot, func),
598 .offset = reg,
599 .size = bytes,
600 };
601 int err;
602
603 err = do_pci_op(sc->pdev, &op);
604
605 DPRINTF("read config (b=%d, s=%d, f=%d, reg=%d, len=%d, val=%x, err=%d)\n",
606 bus, slot, func, reg, bytes, op.value, err);
607
608 if (err)
609 op.value = ~0;
610
611 return op.value;
612}
613
614/* Write configuration space register */
615static void
616xpcib_write_config(device_t dev, int bus, int slot, int func,
617 int reg, u_int32_t data, int bytes)
618{
619 struct xpcib_softc *sc = (struct xpcib_softc *)device_get_softc(dev);
620 struct xen_pci_op op = {
621 .cmd = XEN_PCI_OP_conf_write,
622 .domain = sc->domain,
623 .bus = sc->bus,
624 .devfn = PCI_DEVFN(slot, func),
625 .offset = reg,
626 .size = bytes,
627 .value = data,
628 };
629 int err;
630
631 err = do_pci_op(sc->pdev, &op);
632
633 DPRINTF("write config (b=%d, s=%d, f=%d, reg=%d, len=%d, val=%x, err=%d)\n",
634 bus, slot, func, reg, bytes, data, err);
635}
636
637static int
638xpcib_route_interrupt(device_t pcib, device_t dev, int pin)
639{
640 struct pci_devinfo *dinfo = device_get_ivars(dev);
641 pcicfgregs *cfg = &dinfo->cfg;
642
643 DPRINTF("route intr (pin=%d, line=%d)\n", pin, cfg->intline);
644
645 return cfg->intline;
646}
647
648static device_method_t xpcib_methods[] = {
649 /* Device interface */
650 DEVMETHOD(device_probe, xpcib_probe),
651 DEVMETHOD(device_attach, xpcib_attach),
652 DEVMETHOD(device_detach, bus_generic_detach),
653 DEVMETHOD(device_shutdown, bus_generic_shutdown),
654 DEVMETHOD(device_suspend, bus_generic_suspend),
655 DEVMETHOD(device_resume, bus_generic_resume),
656
657 /* Bus interface */
658 DEVMETHOD(bus_read_ivar, xpcib_read_ivar),
659 DEVMETHOD(bus_alloc_resource, bus_generic_alloc_resource),
660 DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
661 DEVMETHOD(bus_release_resource, bus_generic_release_resource),
662 DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
663 DEVMETHOD(bus_setup_intr, bus_generic_setup_intr),
664 DEVMETHOD(bus_teardown_intr, bus_generic_teardown_intr),
665
666 /* pcib interface */
667 DEVMETHOD(pcib_maxslots, xpcib_maxslots),
668 DEVMETHOD(pcib_read_config, xpcib_read_config),
669 DEVMETHOD(pcib_write_config, xpcib_write_config),
670 DEVMETHOD(pcib_route_interrupt, xpcib_route_interrupt),
671
672 DEVMETHOD_END
673};
674
675static devclass_t xpcib_devclass;
676
677DEFINE_CLASS_0(pcib, xpcib_driver, xpcib_methods, sizeof(struct xpcib_softc));
678DRIVER_MODULE(pcib, xpcife, xpcib_driver, xpcib_devclass, 0, 0);
679
680/*
681 * Local variables:
682 * mode: C
683 * c-set-style: "BSD"
684 * c-basic-offset: 4
685 * tab-width: 4
686 * indent-tabs-mode: t
687 * End:
688 */