int main(int argc, char **argv) { int r; UHCI_DEBUG("starting\n"); // UHCI_DEBUG("connecting to the SKB...\n"); // skb_client_connect(); // UHCI_DEBUG("connected to SKB\n"); UHCI_DEBUG("connecting to PCI...\n"); r = pci_client_connect(); assert(err_is_ok(r)); UHCI_DEBUG("connected to PCI\n"); r = pci_register_legacy_driver_irq(uhci_legacy_init, UHCI_PORTBASE, UHCI_PORTEND, UHCI_IRQ, uhci_interrupt_handler, NULL ); if (err_is_ok(r)) { UHCI_DEBUG("uhci[legacy]: found controller."); goto finish; } int i; for( i=0; device_ids[i] != 0; i++) { r = pci_register_driver_irq(uhci_init, // Init. fn PCI_CLASS_SERIAL, // Class PCI_SUB_USB, // Subclass PCI_IF_USB_UHCI, // Prog. if PCI_VENDOR_INTEL, // Vendor ID device_ids[i], // Device ID PCI_DONT_CARE, // Bus PCI_DONT_CARE, // Dev PCI_DONT_CARE, // Fun uhci_interrupt_handler, // IRQ handler NULL // IRQ argument ); if (err_is_ok(r)) { UHCI_DEBUG("uhci: found controller %" PRIx16 ":%" PRIx16 ".\n", PCI_VENDOR_INTEL, device_ids[i]); goto finish; } printf("uhci: no device ID %" PRIx16 " found.\n", device_ids[i]); } printf("uhci: no devices recognized; giving up."); return 1; finish: UHCI_DEBUG("registered driver: retval=%d; now polling...\n", r); errval_t err; struct waitset *ws = get_default_waitset(); while (1) { err = event_dispatch(ws); if (err_is_fail(err)) { DEBUG_ERR(err, "in event_dispatch"); break; } } }
errval_t ioat_device_discovery(struct pci_addr addr, enum device_type devtype, uint8_t is_dev_mgr) { errval_t err; uint16_t *dev_ids = NULL; uint16_t dev_cnt = 0; err = pci_client_connect(); if (err_is_fail(err)) { return err; } switch (devtype) { case IOAT_DEVICE_IVB: DEV_DEBUG("Doing device discovery: Ivy Bridge\n"); if (addr.device != 4) { /* the IOAT DMA engine should be on device 4 on Ivy Bridge */ return DMA_ERR_PCI_ADDRESS; } dev_ids = calloc(PCI_DEVICE_IOAT_IVB_CNT, sizeof(uint16_t)); if (dev_ids == NULL) { return LIB_ERR_MALLOC_FAIL; } dev_ids[0] = PCI_DEVICE_IOAT_IVB0; dev_ids[1] = PCI_DEVICE_IOAT_IVB1; dev_ids[2] = PCI_DEVICE_IOAT_IVB2; dev_ids[3] = PCI_DEVICE_IOAT_IVB3; dev_ids[4] = PCI_DEVICE_IOAT_IVB4; dev_ids[5] = PCI_DEVICE_IOAT_IVB5; dev_ids[6] = PCI_DEVICE_IOAT_IVB6; dev_ids[7] = PCI_DEVICE_IOAT_IVB7; dev_ids[8] = PCI_DEVICE_IOAT_IVB8; dev_ids[9] = PCI_DEVICE_IOAT_IVB9; dev_cnt = PCI_DEVICE_IOAT_IVB_CNT; addr.function = 0; break; case IOAT_DEVICE_HSW: DEV_DEBUG("Doing device discovery: Haswell\n"); if (addr.device != 4) { /* the IOAT DMA engine should be on device 4 on Haswell */ return DMA_ERR_PCI_ADDRESS; } dev_ids = calloc(PCI_DEVICE_IOAT_HSW_CNT, sizeof(uint16_t)); if (dev_ids == NULL) { return LIB_ERR_MALLOC_FAIL; } dev_ids[0] = PCI_DEVICE_IOAT_HSW0; dev_ids[1] = PCI_DEVICE_IOAT_HSW1; dev_ids[2] = PCI_DEVICE_IOAT_HSW2; dev_ids[3] = PCI_DEVICE_IOAT_HSW3; dev_ids[4] = PCI_DEVICE_IOAT_HSW4; dev_ids[5] = PCI_DEVICE_IOAT_HSW5; dev_ids[6] = PCI_DEVICE_IOAT_HSW6; dev_ids[7] = PCI_DEVICE_IOAT_HSW7; dev_ids[8] = PCI_DEVICE_IOAT_HSW8; dev_ids[9] = PCI_DEVICE_IOAT_HSW9; dev_cnt = PCI_DEVICE_IOAT_HSW_CNT; addr.function = 0; break; break; default: return DMA_ERR_DEVICE_UNSUPPORTED; break; } devices = calloc(dev_cnt, sizeof(struct ioat_dma_device *)); if (devices == NULL) { free(dev_ids); return LIB_ERR_MALLOC_FAIL; } if (is_dev_mgr == IOAT_DMA_OPERATION_LIBRARY) { err = ioat_mgr_svc_init(); if (err_is_fail(err)) { return err; } } /** * enumerating all the devices * * The devices on Haswell and Ivy Bridge are located on * Bus x, Device 4, Function 0..7 */ for (uint8_t i = 0; i < dev_cnt; ++i) { if (is_dev_mgr == IOAT_DMA_OPERATION_LIBRARY) { /* * discover devices as manager i.e. don't initialize them as they * are handed over to the domains upon request */ err = pci_register_driver_noirq(pci_dev_init_manager, PCI_DONT_CARE, PCI_DONT_CARE, PCI_DONT_CARE, PCI_VENDOR_INTEL, dev_ids[i], addr.bus, addr.device, addr.function + i); } else { /* * discover devices as a service i.e. initialize and map devices */ err = pci_register_driver_irq(pci_dev_init_service, PCI_DONT_CARE, PCI_DONT_CARE, PCI_DONT_CARE, PCI_VENDOR_INTEL, dev_ids[i], addr.bus, addr.device, addr.function + i, handle_device_interrupt, devices[i]); } if (err_is_fail(err)) { if (i == 0) { /* XXX: if a system does not implement all devices listed above, * the registration will fail which is ok. However if it * happens on the first device this is an error. */ return err; } } } DEV_DEBUG("Device discovery done: got %u devices.\n", device_count); free(dev_ids); return SYS_ERR_OK; }