Hardware Projects » E1/T1 Hardware Interface (including icE1usb)

/*

 * xhci-bw-override.c

 *

 * Small utility that scans for xHCI controller, check if they're compatible

 * and overwrite the FS isochronous bandwidth limit register

 *

 * Copyright (C) 2022  Sylvain Munaut <tnt@246tNt.com>

 * SPDX-License-Identifier: GPL-3.0-or-later

 */

#include <dirent.h>

#include <inttypes.h>

#include <fcntl.h>

#include <stdio.h>

#include <stdint.h>

#include <string.h>

#include <unistd.h>

#include <sys/mman.h>

struct pci_dev {

	uint16_t vendor;

	uint16_t device;

	uint32_t class;

	char path[PATH_MAX];

};

typedef void (*pci_dev_cb_t)(struct pci_dev *dev);

static int

read_sysfs_hex(const char *filename, uint32_t *val)

{

	FILE *f = fopen(filename, "r");

	if (!f)

		return -1;

	if (fscanf(f, "0x%x\n", val) != 1)

		return -1;

	fclose(f);

	return 0;

}

static int

fill_pci_dev(struct pci_dev *dev, const char *path)

{

	char fname[512];

	uint32_t v;

	strncpy(dev->path, path, sizeof(fname));

	snprintf(fname, sizeof(fname), "%s/vendor", path);

	if (read_sysfs_hex(fname, &v))

		return -1;

	dev->vendor = v;

	snprintf(fname, sizeof(fname), "%s/device", path);

	if (read_sysfs_hex(fname, &v))

		return -1;

	dev->device = v;

	snprintf(fname, sizeof(fname), "%s/class", path);

	if (read_sysfs_hex(fname, &v))

		return -1;

	dev->class = v;

	return 0;

}

static void

scan_pci_devices(pci_dev_cb_t cb)

{

	DIR *dd_root, *dd_bus;

	struct dirent *de_root, *de_bus;

	char fname[PATH_MAX];

	dd_root = opendir("/sys/devices/");

	if (!dd_root) {

		fprintf(stderr, "[!] Failed to open '/sys/devices/'\n");

		perror("opendir");

		return;

	}

	while (1) {

		de_root = readdir(dd_root);

		if (!de_root)

			break;

		if (strncmp(de_root->d_name, "pci", 3))

			continue;

		snprintf(fname, sizeof(fname), "/sys/devices/%s", de_root->d_name);

		dd_bus = opendir(fname);

		if (!dd_bus) {

			fprintf(stderr, "[!] Failed to open '%s', skipping\n", fname);

			perror("opendir");

			continue;

		}

		while (1) {

			struct pci_dev dev;

			de_bus = readdir(dd_bus);

			if (!de_bus)

				break;

			if (de_bus->d_type != DT_DIR)

				continue;

			if ((de_bus->d_name[0] < '0') || (de_bus->d_name[1] > '9'))

				continue;

			snprintf(fname, sizeof(fname), "/sys/devices/%s/%s", de_root->d_name, de_bus->d_name);

			if (fill_pci_dev(&dev, fname)) {

				fprintf(stderr, "[w] Failed to read info about '%s', skipping\n", fname);

				continue;

			}

			cb(&dev);

		}

		closedir(dd_bus);

	}

	closedir(dd_root);

}

static int

patch_device(struct pci_dev *dev)

{

	char fname[PATH_MAX];

	int fd;

	void *mem;

	snprintf(fname, sizeof(fname), "%s/resource0", dev->path);

	fd = open(fname, O_RDWR);

	if (fd < 0) {

		fprintf(stderr, "[!] Failed to open resource '%s'\n", fname);

		perror("open");

		return -1;

	}

	mem = mmap(NULL, 0x10000, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);

	if (!mem) {

		fprintf(stderr, "[!] Failed to mmmap\n");

		perror("mmap");

		close(fd);

		return -1;

	}

	volatile uint64_t *HOST_CTRL_BW_MAX_REG = (uint64_t *)(mem + 0x8128);

	uint64_t v;

	v = *HOST_CTRL_BW_MAX_REG;

	printf("[.] Previous HOST_CTRL_BW_MAX_REG value: %016" PRIx64 "\n", v);

	v &= 0xfffffff000ffffff;

	v |= 0x00000005b0000000;	/* Patched value */

	// v |= 0x0000000505000000;	/* Default value */

	printf("[.] Updated  HOST_CTRL_BW_MAX_REG value: %016" PRIx64 "\n", v);

	*HOST_CTRL_BW_MAX_REG = v;

     	close(fd);

	return 0;

}

static void

scan_cb(struct pci_dev *dev)

{

	if ((dev->vendor != 0x8086) || (dev->class != 0x0c0330))

		return;

	fprintf(stderr, "[+] Found Intel xHCI controller at '%s'\n", dev->path);

	patch_device(dev);

}

int main(int argc, char *argv[])

{

	if (geteuid() != 0) {

		fprintf(stderr, "[!] Please run as root\n");

		return -1;

	}

	if (argc == 1) {

		/* No arguments, scan all */

		scan_pci_devices(scan_cb);

	} else {

		struct pci_dev dev;

		if (fill_pci_dev(&dev, argv[1])) {

			fprintf(stderr, "[!] Failed to read info about '%s'\n", argv[1]);

			return -1;

		}

		if ((dev.vendor != 0x8086) || (dev.class != 0x0c0330)) {

			fprintf(stderr, "[!] Not an intel xHCI controller\n");

			return -1;

		}

		patch_device(&dev);

	}

}