int get_pch_sbreg_addr(struct pci_access *pci, pciaddr_t *sbreg_addr) { MSG("Checking for a Series 10 PCH system"); struct pci_dev *d31f1 = pci_get_dev(pci, 0, 0, 31, 1); pci_fill_info(d31f1, PCI_FILL_IDENT); if(d31f1->vendor_id == 0xffff) { MSG("Cannot find D31:F1, assuming it is hidden by firmware"); uint32_t p2sb_ctrl = pci_read_long(d31f1, REG_P2SB_CTRL); MSG("P2SB_CTRL=%02x", p2sb_ctrl); if(!(p2sb_ctrl & REG_P2SB_CTRL_HIDE)) { ERR("D31:F1 is hidden but P2SB_E1 is not 0xff, bailing out"); } MSG("Unhiding P2SB"); pci_write_long(d31f1, REG_P2SB_CTRL, p2sb_ctrl & ~REG_P2SB_CTRL_HIDE); p2sb_ctrl = pci_read_long(d31f1, REG_P2SB_CTRL); MSG("P2SB_CTRL=%02x", p2sb_ctrl); if(p2sb_ctrl & REG_P2SB_CTRL_HIDE) { ERR("Cannot unhide PS2B"); } pci_fill_info(d31f1, PCI_FILL_RESCAN | PCI_FILL_IDENT); if(d31f1->vendor_id == 0xffff) { ERR("P2SB unhidden but does not enumerate, bailing out"); } } pci_fill_info(d31f1, PCI_FILL_RESCAN | PCI_FILL_IDENT | PCI_FILL_BASES); if(d31f1->vendor_id != 0x8086) { ERR("Vendor of D31:F1 is not Intel"); } else if((uint32_t)d31f1->base_addr[0] == 0xffffffff) { ERR("SBREG_BAR is not implemented in D31:F1"); } *sbreg_addr = d31f1->base_addr[0] &~ 0xf; MSG("SBREG_ADDR=%08lx", *sbreg_addr); MSG("Hiding P2SB again"); uint32_t p2sb_ctrl = pci_read_long(d31f1, REG_P2SB_CTRL); pci_write_long(d31f1, REG_P2SB_CTRL, p2sb_ctrl | REG_P2SB_CTRL_HIDE); pci_fill_info(d31f1, PCI_FILL_RESCAN | PCI_FILL_IDENT); if(d31f1->vendor_id != 0xffff) { ERR("Cannot hide P2SB"); } return 0; }
static struct pci_dev * create_pci_dev(struct pci_access * pci, char * slot) { struct pci_filter filter; pci_filter_init(pci, &filter); if (pci_filter_parse_slot(&filter, slot)) { fprintf(stderr, "Failed to parse device id %s\n", slot); goto pci_filter_parse_failed; } pci_init(pci); struct pci_dev * dev = pci_get_dev(pci, filter.domain, filter.bus, filter.slot, filter.func); if (! dev) { fprintf(stderr, "Failed to allocate dev\n"); goto pci_get_dev_failed; } pci_fill_info(dev, PCI_FILL_IDENT); return dev; pci_get_dev_failed: pci_filter_parse_failed: return NULL; }
/* --- implementations --- */ int detect_pci22(void){ unsigned int c; char counter=0; pacc = pci_alloc(); /* Get the pci_access structure */ pci_init(pacc); /* Initialize the PCI library */ pci_scan_bus(pacc); /* We want to get the list of devices */ /* Iterate over all PCI devices */ for(pci22_dev=pacc->devices; pci22_dev; pci22_dev=pci22_dev->next){ pci_fill_info(pci22_dev, PCI_FILL_IDENT | PCI_FILL_BASES); // Detect the specified device if( (pci22_dev->vendor_id == PCI22_PCI_VENDOR_ID) && (pci22_dev->device_id == PCI22_PCI_DEVICE_ID) ){ break; } } if (pci22_dev==NULL){ printf("\n\nERROR: PCI22 card not detected\n\n\n"); exit(0); } printf("\n\nPCI22 card detected on %02x:%02x.%d\nVendorID=%04x DeviceID=%04x irq=%d\n", pci22_dev->bus,pci22_dev->dev, pci22_dev->func,pci22_dev->vendor_id, pci22_dev->device_id, pci22_dev->irq); printf("\n\n--- Baseaddresses ---\n"); printf("BAR1 %x\n",pci22_dev->base_addr[0]); printf("BAR2 %x\n",pci22_dev->base_addr[1]); printf("BAR3 %x\n",pci22_dev->base_addr[2]); printf("BAR4 %x\n",pci22_dev->base_addr[3]); printf("BAR5 %x\n",pci22_dev->base_addr[4]); printf("BAR6 %x\n",pci22_dev->base_addr[6]); printf("\n"); //printPCIDevice(pci22_dev); /* The baseaddress of the COM20022 is at BAR2 */ //g_pci22dipswitch = pci22_dev->base_addr[1]; //Nonworking g_pci22base = pci22_dev->base_addr[2]; /* Close everything */ pci_cleanup(pacc); return 0; }
static int pci_connect( device_t *igb_dev ) { struct pci_access *pacc; struct pci_dev *dev; int err; char devpath[IGB_BIND_NAMESZ]; memset( igb_dev, 0, sizeof(device_t)); pacc = pci_alloc(); pci_init(pacc); pci_scan_bus(pacc); for (dev=pacc->devices; dev; dev=dev->next) { pci_fill_info(dev, PCI_FILL_IDENT | PCI_FILL_BASES | PCI_FILL_CLASS); igb_dev->pci_vendor_id = dev->vendor_id; igb_dev->pci_device_id = dev->device_id; igb_dev->domain = dev->domain; igb_dev->bus = dev->bus; igb_dev->dev = dev->dev; igb_dev->func = dev->func; snprintf (devpath, IGB_BIND_NAMESZ, "%04x:%02x:%02x.%d", dev->domain, dev->bus, dev->dev, dev->func ); err = igb_probe( igb_dev ); if (err) { continue; } printf ("attaching to %s\n", devpath); err = igb_attach( devpath, igb_dev ); if (err) { printf ("attach failed! (%s)\n", strerror(errno)); continue; } goto out; } pci_cleanup(pacc); return ENXIO; out: pci_cleanup(pacc); return 0; }
int create_pci(int method, struct pci_access **pci_out) { struct pci_access *pci = pci_alloc(); pci->method = method; pci_init(pci); pci_scan_bus(pci); struct pci_dev *d31f0 = pci_find_dev(pci, 0, 31, 0); if(!d31f0) { ERR("Cannot find D31:F0"); } pci_fill_info(d31f0, PCI_FILL_IDENT | PCI_FILL_BASES); if(d31f0->vendor_id != 0x8086) { ERR("Vendor of D31:F0 is not Intel"); } *pci_out = pci; return 0; }
int show_pci(void) { struct pci_access *pacc; struct pci_dev *dev; unsigned int c; pacc = pci_alloc(); /* Get the pci_access structure */ /* Set all options you want -- here we stick with the defaults */ pacc->debugging=1; pci_init(pacc); /* Initialize the PCI library */ pci_scan_bus(pacc); /* We want to get the list of devices */ for(dev=pacc->devices; dev; dev=dev->next) /* Iterate over all devices */ { pci_fill_info(dev, PCI_FILL_IDENT | PCI_FILL_BASES); /* Fill in header info we need */ c = pci_read_word(dev, PCI_CLASS_DEVICE); /* Read config register directly */ printf("%02x:%02x.%d vendor=%04x device=%04x class=%04x irq=%d base0=%lx\n", dev->bus, dev->dev, dev->func, dev->vendor_id, dev->device_id, c, dev->irq, dev->base_addr[0]); } pci_cleanup(pacc); /* Close everything */ return 0; }
nsresult nsSystemInfo::Init() { struct pci_access *pacc; struct pci_dev *p; pciaddr_t ram = 0; char buf[128]; int i, found, v, n; Display *dpy; char *display = NULL; Window root; XVisualInfo *info, templ; XWindowAttributes wts; XPixmapFormatValues *pf; XSetWindowAttributes attr; Window win; mWidth = 0; mHeight = 0; mDepth = 0; pacc = pci_alloc(); pci_init(pacc); pci_scan_bus(pacc); for (p = pacc->devices; p; p=p->next) { pci_fill_info(p, PCI_FILL_IDENT | PCI_FILL_CLASS | PCI_FILL_BASES | PCI_FILL_SIZES); if (p->device_class == PCI_CLASS_DISPLAY_VGA) { pci_lookup_name(pacc, buf, sizeof(buf), PCI_LOOKUP_VENDOR | PCI_LOOKUP_DEVICE, p->vendor_id, p->device_id); mDeviceName.AssignLiteral(buf); sprintf(buf, "0x%04X", p->vendor_id); mVendorID.AssignLiteral(buf); sprintf(buf, "0x%04X", p->device_id); mDeviceID.AssignLiteral(buf); for (i=0; i<6; i++) { pciaddr_t len = (p->known_fields & PCI_FILL_SIZES) ? p->size[i] : 0; if (len > ram) ram = len; } vram = ram / 1024 / 1024; } else { Log("Grafx Bot: No PCI VGA device found"); } } pci_cleanup(pacc); if (NULL != (display = getenv("DISPLAY"))) { if (display[0] != ':') { display = strchr(display, ':'); if (NULL == display) { Log("Grafx Bot: unable to find display"); return NS_OK; } } if (NULL == (dpy = XOpenDisplay(display))) { Log("Grafx Bot: unable to find X display"); return NS_OK; } root = DefaultRootWindow(dpy); XGetWindowAttributes(dpy, root, &wts); mWidth = wts.width; mHeight = wts.height; templ.screen = XDefaultScreen(dpy); info = XGetVisualInfo(dpy, VisualScreenMask, &templ, &found); v = -1; for (i = 0; v == -1 && i < found; i++) { if (info[i].depth >= 15) v = i; } for (i = 0; v == -1 && i < found; i++) { if (info[i].depth == 8) v = i; } if (-1 == v) { Log("Grafx Bot: can't find visual"); return NS_OK; } pf = XListPixmapFormats(dpy, &n); for (i = 0; i < n; i++) { if (pf[i].depth == info[v].depth) { mDepth = pf[i].depth; } } if (gGLXWrap.OpenLibrary("libGL.so.1") && gGLXWrap.Init()) { attr.background_pixel = 0; attr.border_pixel = 0; attr.colormap = XCreateColormap(dpy, root, info[v].visual, AllocNone); attr.event_mask = StructureNotifyMask | ExposureMask; win = XCreateWindow(dpy, root, 0, 0, 100, 100, 0, info[v].depth, InputOutput, info[v].visual, CWBackPixel | CWBorderPixel | CWColormap | CWEventMask, &attr); GLXContext ctx = gGLXWrap.fCreateContext(dpy, info, NULL, true); if (ctx) { if (gGLXWrap.fMakeCurrent(dpy, win, ctx)) { mDriverVersion.AssignLiteral((char*)gGLXWrap.fGetString(LOCAL_GL_VERSION)); mDriver.AssignLiteral((char*)gGLXWrap.fGetString(LOCAL_GL_RENDERER)); mDriver.AppendLiteral(" ("); mDriver.AppendLiteral((char*)gGLXWrap.fGetString(LOCAL_GL_VENDOR)); mDriver.AppendLiteral(")"); } else { Log("Grafx Bot: unable to make current"); } gGLXWrap.fDestroyContext(dpy, ctx); } else { Log("Grafx Bot: unable to create context"); } XDestroyWindow(dpy, win); } else { Log("Grafx Bot: can't init libGL.so.1"); } } return NS_OK; }
int main (int argc, char *argv[]) { off_t address = 0; size_t length = 0; int fd; int state; int retval = 0; struct pci_access *pacc; struct pci_dev *dev; DBusError err; setup_logger (); udi = getenv ("UDI"); HAL_DEBUG (("udi=%s", udi)); if (udi == NULL) { HAL_ERROR (("No device specified")); return -2; } dbus_error_init (&err); if ((halctx = libhal_ctx_init_direct (&err)) == NULL) { HAL_ERROR (("Cannot connect to hald")); retval = -3; goto out; } if (!libhal_device_addon_is_ready (halctx, udi, &err)) { retval = -4; goto out; } conn = libhal_ctx_get_dbus_connection (halctx); dbus_connection_setup_with_g_main (conn, NULL); dbus_connection_set_exit_on_disconnect (conn, 0); dbus_connection_add_filter (conn, filter_function, NULL, NULL); /* Search for the graphics card. */ /* Default values: */ /* address = 0x90300000; */ /* length = 0x20000; */ pacc = pci_alloc(); pci_init(pacc); pci_scan_bus(pacc); for(dev=pacc->devices; dev; dev=dev->next) { /* Iterate over all devices */ pci_fill_info(dev, PCI_FILL_IDENT | PCI_FILL_BASES); if ((dev->vendor_id == 0x1002) && (dev->device_id == 0x71c5)) { // ATI X1600 address = dev->base_addr[2]; length = dev->size[2]; } } pci_cleanup(pacc); HAL_DEBUG (("addr 0x%x len=%d", address, length)); if (!address) { HAL_DEBUG (("Failed to detect ATI X1600, aborting...")); retval = 1; goto out; } fd = open ("/dev/mem", O_RDWR); if (fd < 0) { HAL_DEBUG (("cannot open /dev/mem")); retval = 1; goto out; } memory = mmap (NULL, length, PROT_READ|PROT_WRITE, MAP_SHARED, fd, address); if (memory == MAP_FAILED) { HAL_ERROR (("mmap failed")); retval = 2; goto out; } /* Is it really necessary ? */ OUTREG(0x4dc, 0x00000005); state = INREG(0x7ae4); OUTREG(0x7ae4, state); /* Allow access to porta 0x300 through 0x304 */ if (ioperm (0x300, 5, 1) < 0) { HAL_ERROR (("ioperm failed (you should be root).")); exit(1); } /* this works because we hardcoded the udi's in the <spawn> in the fdi files */ if (!libhal_device_claim_interface (halctx, "/org/freedesktop/Hal/devices/macbook_pro_lcd_panel", "org.freedesktop.Hal.Device.LaptopPanel", " <method name=\"SetBrightness\">\n" " <arg name=\"brightness_value\" direction=\"in\" type=\"i\"/>\n" " <arg name=\"return_code\" direction=\"out\" type=\"i\"/>\n" " </method>\n" " <method name=\"GetBrightness\">\n" " <arg name=\"brightness_value\" direction=\"out\" type=\"i\"/>\n" " </method>\n", &err)) { HAL_ERROR (("Cannot claim interface 'org.freedesktop.Hal.Device.LaptopPanel'")); retval = -4; goto out; } if (!libhal_device_claim_interface (halctx, "/org/freedesktop/Hal/devices/macbook_pro_light_sensor", "org.freedesktop.Hal.Device.LightSensor", " <method name=\"GetBrightness\">\n" " <arg name=\"brightness_value\" direction=\"out\" type=\"ai\"/>\n" " </method>\n", &err)) { HAL_ERROR (("Cannot claim interface 'org.freedesktop.Hal.Device.LightSensor'")); retval = -4; goto out; } if (!libhal_device_claim_interface (halctx, "/org/freedesktop/Hal/devices/macbook_pro_keyboard_backlight", "org.freedesktop.Hal.Device.KeyboardBacklight", " <method name=\"GetBrightness\">\n" " <arg name=\"brightness_value\" direction=\"out\" type=\"i\"/>\n" " </method>\n" " <method name=\"SetBrightness\">\n" " <arg name=\"brightness_value\" direction=\"in\" type=\"i\"/>\n" " </method>\n", &err)) { HAL_ERROR (("Cannot claim interface 'org.freedesktop.Hal.Device.KeyboardBacklight'")); retval = -4; goto out; } main_loop = g_main_loop_new (NULL, FALSE); g_main_loop_run (main_loop); return 0; out: HAL_DEBUG (("An error occured, exiting cleanly")); LIBHAL_FREE_DBUS_ERROR (&err); if (halctx != NULL) { libhal_ctx_shutdown (halctx, &err); LIBHAL_FREE_DBUS_ERROR (&err); libhal_ctx_free (halctx); } return retval; }
static inline PdaDebugReturnCode PciDevice_invoke_libpci ( PciDevice *device, const char *bus_id ) { DEBUG_PRINTF(PDADEBUG_ENTER, ""); if(device == NULL) { RETURN( ERROR( EINVAL, "Invalid pointer!\n") ); } if(bus_id == NULL) { RETURN( ERROR( EINVAL, "Invalid pointer!\n") ); } if ( (strlen(bus_id) != 12) || (bus_id[4] != ':') || (bus_id[7] != ':') || (bus_id[10] != '.') ) { RETURN( ERROR( EINVAL, "Invalid bus ID string!\n") ); } struct pci_access *pci_access_handler = pci_alloc(); pci_init(pci_access_handler); pci_scan_bus(pci_access_handler); for ( struct pci_dev *pci_device = pci_access_handler->devices; pci_device; pci_device = pci_device->next ) { pci_fill_info(pci_device, PCI_FILL_IDENT | PCI_FILL_IRQ | PCI_FILL_BASES | PCI_FILL_ROM_BASE | PCI_FILL_SIZES | PCI_FILL_CLASS | PCI_FILL_CAPS | PCI_FILL_EXT_CAPS | PCI_FILL_PHYS_SLOT ); char device_bus_id[] = "0000:00:00.0"; snprintf(device_bus_id, 13,"%04x:%02x:%02x.%d", pci_device->domain, pci_device->bus, pci_device->dev, pci_device->func); if(strcmp(device_bus_id, bus_id) == 0) { device->domain_id = pci_device->domain; device->bus_id = pci_device->bus; device->device_id = pci_device->dev; device->function_id = pci_device->func; for(uint32_t i = 0; i < PDA_MAX_PCI_32_BARS; i++) { uint32_t bar = pci_device->base_addr[i]; DEBUG_PRINTF(PDADEBUG_VALUE, "bar%d : 0x%x\n", i, bar); uint8_t config[64]; pci_read_block(pci_device, 0, config, 64); uint64_t addr = PCI_BASE_ADDRESS_0 + (4*i); uint32_t virt_flag = (config[addr+0] ) | (config[addr+1] << 8 ) | (config[addr+2] << 16 ) | (config[addr+3] << 24 ) ; if(bar && !virt_flag) { device->bar_types[i] = PCIBARTYPES_NOT_MAPPED; DEBUG_PRINTF(PDADEBUG_CONTROL_FLOW, "bar%u is virtual\n", i); continue; } if(bar == 0x0) { if(device->bar_types[i] != PCIBARTYPES_NOT_MAPPED) { DEBUG_PRINTF(PDADEBUG_CONTROL_FLOW, "Inconsistency detected -> bar%u not classified correctly\n", i); device->bar_types[i] = PCIBARTYPES_NOT_MAPPED; } PciDevice_invoke_libpci_set_barsize(device, i, pci_device->size[i]); continue; } if( (bar & 0x00000001) == 0x1) { if(device->bar_types[i] != PCIBARTYPES_IO) { DEBUG_PRINTF(PDADEBUG_CONTROL_FLOW, "Inconsistency detected -> bar%u not classified correctly\n", i); device->bar_types[i] = PCIBARTYPES_IO; } PciDevice_invoke_libpci_set_barsize(device, i, pci_device->size[i]); continue; } uint32_t width_bit = bar & 0x00000006; if(width_bit == 0x00000000) { if(device->bar_types[i] != PCIBARTYPES_BAR32) { DEBUG_PRINTF(PDADEBUG_CONTROL_FLOW, "Inconsistency detected -> bar%u not classified correctly\n", i); device->bar_types[i] = PCIBARTYPES_BAR32; } PciDevice_invoke_libpci_set_barsize(device, i, pci_device->size[i]); continue; } if(width_bit == 0x00000004) { if(device->bar_types[i] != PCIBARTYPES_BAR64) { DEBUG_PRINTF(PDADEBUG_CONTROL_FLOW, "Inconsistency detected -> bar%u not classified correctly\n", i); device->bar_types[i] = PCIBARTYPES_BAR64; device->bar_types[i + 1] = PCIBARTYPES_NOT_MAPPED; } PciDevice_invoke_libpci_set_barsize(device, i, pci_device->size[i]); continue; } } /** Older versions of libpci leak memory when this function is called. **/ #if PCI_LIB_VERSION >= 0x030301 pci_lookup_name(pci_access_handler, device->description, PDA_STRING_LIMIT, PCI_LOOKUP_DEVICE, pci_device->vendor_id, pci_device->device_id); #else #warning "At least version 3.3.1 of libpci is needed. Otherwise the device description can't be returned." strcpy(device->description, ""); #endif DEBUG_PRINTF(PDADEBUG_VALUE, " (%s) %s\n", device->description, device_bus_id); } } pci_cleanup(pci_access_handler); RETURN(PDA_SUCCESS); }
sbone_err_t sbone_dev_open_pcie (sbone_dev_t* dev, int dom, int bus, int _dev, int fun) { static const size_t nbar = sizeof(dev->bar_addrs) / sizeof(dev->bar_addrs[0]); int mem_fd; size_t i; struct pci_access* pci_access; struct pci_dev* pci_dev; int err = -1; /* zero device */ for (i = 0; i < nbar; ++i) dev->bar_sizes[i] = 0; dev->nid = -1; /* find the pci device */ pci_access = pci_alloc(); if (pci_access == NULL) { PERROR(); goto on_error_0; } pci_init(pci_access); pci_scan_bus(pci_access); pci_dev = pci_get_dev(pci_access, dom, bus, _dev, fun); if (pci_dev == NULL) { PERROR(); goto on_error_1; } pci_fill_info(pci_dev, PCI_FILL_IDENT | PCI_FILL_BASES); /* map bars */ mem_fd = open("/dev/mem", O_RDWR | O_SYNC); if (mem_fd == -1) { PERROR(); goto on_error_2; } for (i = 0; i < nbar; ++i) { #if 1 /* FIXME: pci_dev->size[i] not detected by pci_fill_info ... */ if (pci_dev->base_addr[i] != 0) pci_dev->size[i] = get_bar_size(pci_access, pci_dev, i); #endif /* FIXME */ dev->bar_sizes[i] = pci_dev->size[i]; if (dev->bar_sizes[i] == 0) continue ; dev->bar_addrs[i] = (uintptr_t)mmap ( NULL, pci_dev->size[i], PROT_READ | PROT_WRITE, MAP_SHARED | MAP_NORESERVE, mem_fd, pci_dev->base_addr[i] ); if (dev->bar_addrs[i] == (uintptr_t)MAP_FAILED) { size_t j; for (j = 0; j < i; ++j) munmap((void*)dev->bar_addrs[i], dev->bar_sizes[i]); PERROR(); goto on_error_3; } } if ((dev->fd = open("/dev/sbone", O_RDWR)) == -1) { PERROR(); goto on_error_3; } /* success */ err = 0; on_error_3: close(mem_fd); on_error_2: pci_free_dev(pci_dev); on_error_1: pci_cleanup(pci_access); on_error_0: return err; }
int main (int argc, char *argv[]) { struct pci_access *pacc; struct pci_dev *dev; struct pci_filter filter; char *msg; uint16_t command; int v1_1 = 0, i2c; if (argc != 2 && ((argc != 3) || (!(v1_1 = !strcmp(argv[2], "1.1")) && strcmp(argv[2], "1.0")))) { fprintf(stderr, "VT6307 OHCI mode config\n" "Version 0.9\n" "Copyright (C) 2007 Krzysztof Halasa <*****@*****.**>\n" "\n" "Usage: vt6307ohciver <pci_device> [ 1.0 | 1.1 ]\n"); exit(1); } if (iopl(3)) { fprintf(stderr, "iopl() failed (must be root)\n"); exit(1); } pacc = pci_alloc(); pci_filter_init(pacc, &filter); if ((msg = pci_filter_parse_slot(&filter, argv[1]))) { fprintf(stderr, "Invalid pci_device\n"); exit(1); } filter.vendor = VENDOR_ID; filter.device = DEVICE_ID; pci_init(pacc); pci_scan_bus(pacc); for (dev = pacc->devices; dev; dev = dev->next) if (pci_filter_match(&filter, dev)) break; if (!dev) { fprintf(stderr, "Device %s not found\n", argv[2]); exit(1); } pci_fill_info(dev, PCI_FILL_BASES | PCI_FILL_SIZES); if (dev->size[0] != MEM_SIZE || dev->size[1] != IO_SIZE) { fprintf(stderr, "Unexpected MEM/IO region size, is it" " VT6307 chip?\n"); exit(1); } command = pci_read_word(dev, PCI_COMMAND); if ((command & PCI_COMMAND_IO) == 0) { fprintf(stderr, "Device disabled, trying to enable it\n"); pci_write_word(dev, PCI_COMMAND, command | PCI_COMMAND_IO); } io_ports = dev->base_addr[1] & PCI_BASE_ADDRESS_IO_MASK; i2c = (inl(io_ports + 0x20) & 0x80) ? 0 : 1; fprintf(stderr, "I/O region #1 is at %04X\n", io_ports); fprintf(stderr, "It seems your VT6307 chip is connected to %s " "EEPROM\n", i2c ? "I^2C (24c01 or similar)" : "93c46"); if (argc == 3) { /* enable direct access to pins */ outl_p(inl(io_ports) | 0x80, io_ports); if (i2c) write_i2c(0x22, v1_1 ? 8 : 0); else write_4w(0x11, v1_1 ? 8 : 0); /* disable direct access to pins */ outl_p(0x20, io_ports + 0x20); fprintf(stderr, "Please reboot\n"); } else display(dev->base_addr[0] & PCI_BASE_ADDRESS_MEM_MASK); if ((command & PCI_COMMAND_IO) == 0) { fprintf(stderr, "Disabling device\n"); pci_write_word(dev, PCI_COMMAND, command); } exit(0); }
void pci::probe(void) { pci_scan_bus(_pacc); uint8_t buf[CONFIG_SPACE_SIZE] = {0}; char classbuf[128] = {0}, vendorbuf[128] {0}, devbuf[128] = {0}; for (struct pci_dev *dev = _pacc->devices; dev && _entries.size() < MAX_DEVICES; dev = dev->next) { _entries.push_back(pciEntry()); pciEntry &e = _entries.back(); memset(buf, 0, sizeof(buf)); memset(classbuf, 0, sizeof(classbuf)); memset(vendorbuf, 0, sizeof(vendorbuf)); memset(devbuf, 0, sizeof(devbuf)); pci_setup_cache(dev, buf, CONFIG_SPACE_SIZE); pci_read_block(dev, 0, buf, CONFIG_SPACE_SIZE); pci_fill_info(dev, PCI_FILL_IDENT | PCI_FILL_CLASS | PCI_FILL_CAPS); pci_lookup_name(_pacc, vendorbuf, sizeof(vendorbuf), PCI_LOOKUP_VENDOR, dev->vendor_id, dev->device_id); pci_lookup_name(_pacc, devbuf, sizeof(devbuf), PCI_LOOKUP_DEVICE, dev->vendor_id, dev->device_id); e.text.append(vendorbuf).append("|").append(devbuf); e.class_type += classbuf; e.vendor = dev->vendor_id; e.device = dev->device_id; e.pci_domain = dev->domain; e.bus = dev->bus; e.pciusb_device = dev->dev; e.pci_function = dev->func; e.class_id = dev->device_class; e.subvendor = pci_read_word(dev, PCI_SUBSYSTEM_VENDOR_ID); e.subdevice = pci_read_word(dev, PCI_SUBSYSTEM_ID); e.pci_revision = pci_read_byte(dev, PCI_REVISION_ID); if ((e.subvendor == 0 && e.subdevice == 0) || (e.subvendor == e.vendor && e.subdevice == e.device)) { e.subvendor = 0xffff; e.subdevice = 0xffff; } if (pci_find_cap(dev,PCI_CAP_ID_EXP, PCI_CAP_NORMAL)) e.is_pciexpress = true; /* special case for realtek 8139 that has two drivers */ if (e.vendor == 0x10ec && e.device == 0x8139) { if (e.pci_revision < 0x20) e.module = "8139too"; else e.module = "8139cp"; } } // fake two PCI controllers for xen struct stat sb; if (!stat("/sys/bus/xen", &sb)) { // FIXME: use C++ streams.. FILE *f; if ((f = fopen("/sys/hypervisor/uuid", "r"))) { char buf[38]; fgets(buf, sizeof(buf) - 1, f); fclose(f); if (strncmp(buf, "00000000-0000-0000-0000-000000000000", sizeof(buf))) { // We're now sure to be in a Xen guest: { _entries.push_back(pciEntry()); pciEntry &e = _entries.back(); e.text.append("XenSource, Inc.|Block Frontend"); e.class_id = 0x0106; // STORAGE_SATA e.vendor = 0x1a71; // XenSource e.device = 0xfffa; // fake e.subvendor = 0; e.subdevice = 0; e.class_id = 0x0106; e.module = "xen_blkfront"; } { _entries.push_back(pciEntry()); pciEntry &e = _entries.back(); e.text.append("XenSource, Inc.|Network Frontend"); e.class_id = 0x0200; // NETWORK_ETHERNET e.vendor = 0x1a71; // XenSource e.device = 0xfffb; // fake e.subvendor = 0; e.subdevice = 0; e.class_id = 0x0200; e.module = "xen_netfront"; } } } } findModules("pcitable", false); }