1 /* 2 * (C) Copyright IBM Corporation 2006 3 * All Rights Reserved. 4 * 5 * Permission is hereby granted, free of charge, to any person obtaining a 6 * copy of this software and associated documentation files (the "Software"), 7 * to deal in the Software without restriction, including without limitation 8 * on the rights to use, copy, modify, merge, publish, distribute, sub 9 * license, and/or sell copies of the Software, and to permit persons to whom 10 * the Software is furnished to do so, subject to the following conditions: 11 * 12 * The above copyright notice and this permission notice (including the next 13 * paragraph) shall be included in all copies or substantial portions of the 14 * Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL 19 * IBM AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 22 * DEALINGS IN THE SOFTWARE. 23 */ 24 25 /** 26 * \file linux_sysfs.c 27 * Access PCI subsystem using Linux's sysfs interface. This interface is 28 * available starting somewhere in the late 2.5.x kernel phase, and is the 29 * prefered method on all 2.6.x kernels. 30 * 31 * \author Ian Romanick <[email protected]> 32 */ 33 34 #define _GNU_SOURCE 35 36 #include <stdlib.h> 37 #include <string.h> 38 #include <stdio.h> 39 #include <unistd.h> 40 #include <sys/types.h> 41 #include <sys/stat.h> 42 #include <fcntl.h> 43 #include <sys/mman.h> 44 #include <dirent.h> 45 #include <errno.h> 46 47 #include "config.h" 48 49 #ifdef HAVE_MTRR 50 #include <asm/mtrr.h> 51 #include <sys/ioctl.h> 52 #endif 53 54 #include "pciaccess.h" 55 #include "pciaccess_private.h" 56 #include "linux_devmem.h" 57 58 static void pci_device_linux_sysfs_enable(struct pci_device *dev); 59 60 static int pci_device_linux_sysfs_read_rom( struct pci_device * dev, 61 void * buffer ); 62 63 static int pci_device_linux_sysfs_probe( struct pci_device * dev ); 64 65 static int pci_device_linux_sysfs_map_range(struct pci_device *dev, 66 struct pci_device_mapping *map); 67 68 static int pci_device_linux_sysfs_unmap_range(struct pci_device *dev, 69 struct pci_device_mapping *map); 70 71 static int pci_device_linux_sysfs_read( struct pci_device * dev, void * data, 72 pciaddr_t offset, pciaddr_t size, pciaddr_t * bytes_read ); 73 74 static int pci_device_linux_sysfs_write( struct pci_device * dev, 75 const void * data, pciaddr_t offset, pciaddr_t size, 76 pciaddr_t * bytes_wrtten ); 77 78 static const struct pci_system_methods linux_sysfs_methods = { 79 .destroy = NULL, 80 .destroy_device = NULL, 81 .read_rom = pci_device_linux_sysfs_read_rom, 82 .probe = pci_device_linux_sysfs_probe, 83 .map_range = pci_device_linux_sysfs_map_range, 84 .unmap_range = pci_device_linux_sysfs_unmap_range, 85 86 .read = pci_device_linux_sysfs_read, 87 .write = pci_device_linux_sysfs_write, 88 89 .fill_capabilities = pci_fill_capabilities_generic, 90 .enable = pci_device_linux_sysfs_enable, 91 }; 92 93 #define SYS_BUS_PCI "/sys/bus/pci/devices" 94 95 96 static int populate_entries(struct pci_system * pci_sys); 97 98 99 /** 100 * Attempt to access PCI subsystem using Linux's sysfs interface. 101 */ 102 _pci_hidden int 103 pci_system_linux_sysfs_create( void ) 104 { 105 int err = 0; 106 struct stat st; 107 108 109 /* If the directory "/sys/bus/pci/devices" exists, then the PCI subsystem 110 * can be accessed using this interface. 111 */ 112 113 if ( stat( SYS_BUS_PCI, & st ) == 0 ) { 114 pci_sys = calloc( 1, sizeof( struct pci_system ) ); 115 if ( pci_sys != NULL ) { 116 pci_sys->methods = & linux_sysfs_methods; 117 #ifdef HAVE_MTRR 118 pci_sys->mtrr_fd = open("/proc/mtrr", O_WRONLY); 119 #endif 120 err = populate_entries(pci_sys); 121 } 122 else { 123 err = ENOMEM; 124 } 125 } 126 else { 127 err = errno; 128 } 129 130 return err; 131 } 132 133 134 /** 135 * Filter out the names "." and ".." from the scanned sysfs entries. 136 * 137 * \param d Directory entry being processed by \c scandir. 138 * 139 * \return 140 * Zero if the entry name matches either "." or "..", non-zero otherwise. 141 * 142 * \sa scandir, populate_entries 143 */ 144 static int 145 scan_sys_pci_filter( const struct dirent * d ) 146 { 147 return !((strcmp( d->d_name, "." ) == 0) 148 || (strcmp( d->d_name, ".." ) == 0)); 149 } 150 151 152 int 153 populate_entries( struct pci_system * p ) 154 { 155 struct dirent ** devices; 156 int n; 157 int i; 158 int err = 0; 159 160 161 n = scandir( SYS_BUS_PCI, & devices, scan_sys_pci_filter, alphasort ); 162 if ( n > 0 ) { 163 p->num_devices = n; 164 p->devices = calloc( n, sizeof( struct pci_device_private ) ); 165 166 if (p->devices != NULL) { 167 for (i = 0 ; i < n ; i++) { 168 uint8_t config[48]; 169 pciaddr_t bytes; 170 unsigned dom, bus, dev, func; 171 struct pci_device_private *device = 172 (struct pci_device_private *) &p->devices[i]; 173 174 175 sscanf(devices[i]->d_name, "%04x:%02x:%02x.%1u", 176 & dom, & bus, & dev, & func); 177 178 device->base.domain = dom; 179 device->base.bus = bus; 180 device->base.dev = dev; 181 device->base.func = func; 182 183 184 err = pci_device_linux_sysfs_read(& device->base, config, 0, 185 48, & bytes); 186 if ((bytes == 48) && !err) { 187 device->base.vendor_id = (uint16_t)config[0] 188 + ((uint16_t)config[1] << 8); 189 device->base.device_id = (uint16_t)config[2] 190 + ((uint16_t)config[3] << 8); 191 device->base.device_class = (uint32_t)config[9] 192 + ((uint32_t)config[10] << 8) 193 + ((uint32_t)config[11] << 16); 194 device->base.revision = config[8]; 195 device->base.subvendor_id = (uint16_t)config[44] 196 + ((uint16_t)config[45] << 8); 197 device->base.subdevice_id = (uint16_t)config[46] 198 + ((uint16_t)config[47] << 8); 199 } 200 201 if (err) { 202 break; 203 } 204 } 205 } 206 else { 207 err = ENOMEM; 208 } 209 } 210 211 if (err) { 212 free(p->devices); 213 p->devices = NULL; 214 } 215 216 return err; 217 } 218 219 220 static int 221 pci_device_linux_sysfs_probe( struct pci_device * dev ) 222 { 223 char name[256]; 224 uint8_t config[256]; 225 char resource[512]; 226 int fd; 227 pciaddr_t bytes; 228 unsigned i; 229 int err; 230 231 232 err = pci_device_linux_sysfs_read( dev, config, 0, 256, & bytes ); 233 if ( bytes >= 64 ) { 234 struct pci_device_private *priv = (struct pci_device_private *) dev; 235 236 dev->irq = config[60]; 237 priv->header_type = config[14]; 238 239 240 /* The PCI config registers can be used to obtain information 241 * about the memory and I/O regions for the device. However, 242 * doing so requires some tricky parsing (to correctly handle 243 * 64-bit memory regions) and requires writing to the config 244 * registers. Since we'd like to avoid having to deal with the 245 * parsing issues and non-root users can write to PCI config 246 * registers, we use a different file in the device's sysfs 247 * directory called "resource". 248 * 249 * The resource file contains all of the needed information in 250 * a format that is consistent across all platforms. Each BAR 251 * and the expansion ROM have a single line of data containing 252 * 3, 64-bit hex values: the first address in the region, 253 * the last address in the region, and the region's flags. 254 */ 255 snprintf( name, 255, "%s/%04x:%02x:%02x.%1u/resource", 256 SYS_BUS_PCI, 257 dev->domain, 258 dev->bus, 259 dev->dev, 260 dev->func ); 261 fd = open( name, O_RDONLY ); 262 if ( fd != -1 ) { 263 char * next; 264 pciaddr_t low_addr; 265 pciaddr_t high_addr; 266 pciaddr_t flags; 267 268 269 bytes = read( fd, resource, 512 ); 270 resource[511] = '\0'; 271 272 close( fd ); 273 274 next = resource; 275 for ( i = 0 ; i < 6 ; i++ ) { 276 277 dev->regions[i].base_addr = strtoull( next, & next, 16 ); 278 high_addr = strtoull( next, & next, 16 ); 279 flags = strtoull( next, & next, 16 ); 280 281 if ( dev->regions[i].base_addr != 0 ) { 282 dev->regions[i].size = (high_addr 283 - dev->regions[i].base_addr) + 1; 284 285 dev->regions[i].is_IO = (flags & 0x01); 286 dev->regions[i].is_64 = (flags & 0x04); 287 dev->regions[i].is_prefetchable = (flags & 0x08); 288 } 289 } 290 291 low_addr = strtoull( next, & next, 16 ); 292 high_addr = strtoull( next, & next, 16 ); 293 flags = strtoull( next, & next, 16 ); 294 if ( low_addr != 0 ) { 295 priv->rom_base = low_addr; 296 dev->rom_size = (high_addr - low_addr) + 1; 297 } 298 } 299 } 300 301 return err; 302 } 303 304 305 static int 306 pci_device_linux_sysfs_read_rom( struct pci_device * dev, void * buffer ) 307 { 308 char name[256]; 309 int fd; 310 struct stat st; 311 int err = 0; 312 size_t rom_size; 313 size_t total_bytes; 314 315 316 snprintf( name, 255, "%s/%04x:%02x:%02x.%1u/rom", 317 SYS_BUS_PCI, 318 dev->domain, 319 dev->bus, 320 dev->dev, 321 dev->func ); 322 323 fd = open( name, O_RDWR ); 324 if ( fd == -1 ) { 325 /* If reading the ROM using sysfs fails, fall back to the old 326 * /dev/mem based interface. 327 */ 328 return pci_device_linux_devmem_read_rom(dev, buffer); 329 } 330 331 332 if ( fstat( fd, & st ) == -1 ) { 333 close( fd ); 334 return errno; 335 } 336 337 rom_size = st.st_size; 338 if ( rom_size == 0 ) 339 rom_size = 0x10000; 340 341 /* This is a quirky thing on Linux. Even though the ROM and the file 342 * for the ROM in sysfs are read-only, the string "1" must be written to 343 * the file to enable the ROM. After the data has been read, "0" must be 344 * written to the file to disable the ROM. 345 */ 346 write( fd, "1", 1 ); 347 lseek( fd, 0, SEEK_SET ); 348 349 for ( total_bytes = 0 ; total_bytes < rom_size ; /* empty */ ) { 350 const int bytes = read( fd, (char *) buffer + total_bytes, 351 rom_size - total_bytes ); 352 if ( bytes == -1 ) { 353 err = errno; 354 break; 355 } 356 else if ( bytes == 0 ) { 357 break; 358 } 359 360 total_bytes += bytes; 361 } 362 363 364 lseek( fd, 0, SEEK_SET ); 365 write( fd, "0", 1 ); 366 367 close( fd ); 368 return err; 369 } 370 371 372 static int 373 pci_device_linux_sysfs_read( struct pci_device * dev, void * data, 374 pciaddr_t offset, pciaddr_t size, 375 pciaddr_t * bytes_read ) 376 { 377 char name[256]; 378 pciaddr_t temp_size = size; 379 int err = 0; 380 int fd; 381 char *data_bytes = data; 382 383 if ( bytes_read != NULL ) { 384 *bytes_read = 0; 385 } 386 387 /* Each device has a directory under sysfs. Within that directory there 388 * is a file named "config". This file used to access the PCI config 389 * space. It is used here to obtain most of the information about the 390 * device. 391 */ 392 snprintf( name, 255, "%s/%04x:%02x:%02x.%1u/config", 393 SYS_BUS_PCI, 394 dev->domain, 395 dev->bus, 396 dev->dev, 397 dev->func ); 398 399 fd = open( name, O_RDONLY ); 400 if ( fd == -1 ) { 401 return errno; 402 } 403 404 405 while ( temp_size > 0 ) { 406 const ssize_t bytes = pread64( fd, data_bytes, temp_size, offset ); 407 408 /* If zero bytes were read, then we assume it's the end of the 409 * config file. 410 */ 411 if ( bytes <= 0 ) { 412 err = errno; 413 break; 414 } 415 416 temp_size -= bytes; 417 offset += bytes; 418 data_bytes += bytes; 419 } 420 421 if ( bytes_read != NULL ) { 422 *bytes_read = size - temp_size; 423 } 424 425 close( fd ); 426 return err; 427 } 428 429 430 static int 431 pci_device_linux_sysfs_write( struct pci_device * dev, const void * data, 432 pciaddr_t offset, pciaddr_t size, 433 pciaddr_t * bytes_written ) 434 { 435 char name[256]; 436 pciaddr_t temp_size = size; 437 int err = 0; 438 int fd; 439 const char *data_bytes = data; 440 441 if ( bytes_written != NULL ) { 442 *bytes_written = 0; 443 } 444 445 /* Each device has a directory under sysfs. Within that directory there 446 * is a file named "config". This file used to access the PCI config 447 * space. It is used here to obtain most of the information about the 448 * device. 449 */ 450 snprintf( name, 255, "%s/%04x:%02x:%02x.%1u/config", 451 SYS_BUS_PCI, 452 dev->domain, 453 dev->bus, 454 dev->dev, 455 dev->func ); 456 457 fd = open( name, O_WRONLY ); 458 if ( fd == -1 ) { 459 return errno; 460 } 461 462 463 while ( temp_size > 0 ) { 464 const ssize_t bytes = pwrite64( fd, data_bytes, temp_size, offset ); 465 466 /* If zero bytes were written, then we assume it's the end of the 467 * config file. 468 */ 469 if ( bytes <= 0 ) { 470 err = errno; 471 break; 472 } 473 474 temp_size -= bytes; 475 offset += bytes; 476 data_bytes += bytes; 477 } 478 479 if ( bytes_written != NULL ) { 480 *bytes_written = size - temp_size; 481 } 482 483 close( fd ); 484 return err; 485 } 486 487 488 /** 489 * Map a memory region for a device using the Linux sysfs interface. 490 * 491 * \param dev Device whose memory region is to be mapped. 492 * \param map Parameters of the mapping that is to be created. 493 * 494 * \return 495 * Zero on success or an \c errno value on failure. 496 * 497 * \sa pci_device_map_rrange, pci_device_linux_sysfs_unmap_range 498 * 499 * \todo 500 * Some older 2.6.x kernels don't implement the resourceN files. On those 501 * systems /dev/mem must be used. On these systems it is also possible that 502 * \c mmap64 may need to be used. 503 */ 504 static int 505 pci_device_linux_sysfs_map_range(struct pci_device *dev, 506 struct pci_device_mapping *map) 507 { 508 char name[256]; 509 int fd; 510 int err = 0; 511 const int prot = ((map->flags & PCI_DEV_MAP_FLAG_WRITABLE) != 0) 512 ? (PROT_READ | PROT_WRITE) : PROT_READ; 513 const int open_flags = ((map->flags & PCI_DEV_MAP_FLAG_WRITABLE) != 0) 514 ? O_RDWR : O_RDONLY; 515 const off_t offset = map->base - dev->regions[map->region].base_addr; 516 #ifdef HAVE_MTRR 517 struct mtrr_sentry sentry = { 518 .base = map->base, 519 .size = map->size, 520 .type = MTRR_TYPE_UNCACHABLE 521 }; 522 #endif 523 524 snprintf(name, 255, "%s/%04x:%02x:%02x.%1u/resource%u", 525 SYS_BUS_PCI, 526 dev->domain, 527 dev->bus, 528 dev->dev, 529 dev->func, 530 map->region); 531 532 fd = open(name, open_flags); 533 if (fd == -1) { 534 return errno; 535 } 536 537 538 map->memory = mmap(NULL, map->size, prot, MAP_SHARED, fd, offset); 539 if (map->memory == MAP_FAILED) { 540 err = errno; 541 map->memory = NULL; 542 } 543 544 close(fd); 545 546 #ifdef HAVE_MTRR 547 if ((map->flags & PCI_DEV_MAP_FLAG_CACHABLE) != 0) { 548 sentry.type = MTRR_TYPE_WRBACK; 549 } else if ((map->flags & PCI_DEV_MAP_FLAG_WRITE_COMBINE) != 0) { 550 sentry.type = MTRR_TYPE_WRCOMB; 551 } 552 553 if (pci_sys->mtrr_fd != -1 && sentry.type != MTRR_TYPE_UNCACHABLE) { 554 if (ioctl(pci_sys->mtrr_fd, MTRRIOC_ADD_ENTRY, &sentry) < 0) { 555 /* FIXME: Should we report an error in this case? 556 */ 557 fprintf(stderr, "error setting MTRR " 558 "(base = 0x%08lx, size = 0x%08x, type = %u) %s (%d)\n", 559 sentry.base, sentry.size, sentry.type, 560 strerror(errno), errno); 561 /* err = errno;*/ 562 } 563 /* KLUDGE ALERT -- rewrite the PTEs to turn off the CD and WT bits */ 564 mprotect (map->memory, map->size, PROT_NONE); 565 mprotect (map->memory, map->size, PROT_READ|PROT_WRITE); 566 } 567 #endif 568 569 return err; 570 } 571 572 /** 573 * Unmap a memory region for a device using the Linux sysfs interface. 574 * 575 * \param dev Device whose memory region is to be unmapped. 576 * \param map Parameters of the mapping that is to be destroyed. 577 * 578 * \return 579 * Zero on success or an \c errno value on failure. 580 * 581 * \sa pci_device_map_rrange, pci_device_linux_sysfs_map_range 582 * 583 * \todo 584 * Some older 2.6.x kernels don't implement the resourceN files. On those 585 * systems /dev/mem must be used. On these systems it is also possible that 586 * \c mmap64 may need to be used. 587 */ 588 static int 589 pci_device_linux_sysfs_unmap_range(struct pci_device *dev, 590 struct pci_device_mapping *map) 591 { 592 int err = 0; 593 #ifdef HAVE_MTRR 594 struct mtrr_sentry sentry = { 595 .base = map->base, 596 .size = map->size, 597 .type = MTRR_TYPE_UNCACHABLE 598 }; 599 #endif 600 601 err = pci_device_generic_unmap_range (dev, map); 602 if (err) 603 return err; 604 605 #ifdef HAVE_MTRR 606 if ((map->flags & PCI_DEV_MAP_FLAG_CACHABLE) != 0) { 607 sentry.type = MTRR_TYPE_WRBACK; 608 } else if ((map->flags & PCI_DEV_MAP_FLAG_WRITE_COMBINE) != 0) { 609 sentry.type = MTRR_TYPE_WRCOMB; 610 } 611 612 if (pci_sys->mtrr_fd != -1 && sentry.type != MTRR_TYPE_UNCACHABLE) { 613 if (ioctl(pci_sys->mtrr_fd, MTRRIOC_DEL_ENTRY, &sentry) < 0) { 614 /* FIXME: Should we report an error in this case? 615 */ 616 fprintf(stderr, "error setting MTRR " 617 "(base = 0x%08lx, size = 0x%08x, type = %u) %s (%d)\n", 618 sentry.base, sentry.size, sentry.type, 619 strerror(errno), errno); 620 /* err = errno;*/ 621 } 622 } 623 #endif 624 625 return err; 626 } 627 628 static void pci_device_linux_sysfs_enable(struct pci_device *dev) 629 { 630 char name[256]; 631 int fd; 632 633 snprintf( name, 255, "%s/%04x:%02x:%02x.%1u/enable", 634 SYS_BUS_PCI, 635 dev->domain, 636 dev->bus, 637 dev->dev, 638 dev->func ); 639 640 fd = open( name, O_RDWR ); 641 if (fd == -1) 642 return; 643 644 write( fd, "1", 1 ); 645 close(fd); 646 } 647