X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=xf86drm.c;h=dbb7c14bf6af5c547631cdf0aa8db10ae58db2ae;hb=c7ed900d0188d72084fe30a57d111872d12462ad;hp=60fbc49b3d35d19f803b78d209239cc349e68389;hpb=9b28c5aea3a37dc6382a61fb65c97a9db6eeeac0;p=platform%2Fupstream%2Flibdrm.git diff --git a/xf86drm.c b/xf86drm.c index 60fbc49..dbb7c14 100644 --- a/xf86drm.c +++ b/xf86drm.c @@ -57,8 +57,16 @@ #ifdef MAJOR_IN_SYSMACROS #include #endif +#if HAVE_SYS_SYSCTL_H +#include +#endif #include +#if defined(__FreeBSD__) +#include +#include +#endif + #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0])) /* Not all systems have MAP_FAILED defined */ @@ -71,17 +79,7 @@ #include "util_math.h" -#ifdef __OpenBSD__ -#define DRM_PRIMARY_MINOR_NAME "drm" -#define DRM_CONTROL_MINOR_NAME "drmC" -#define DRM_RENDER_MINOR_NAME "drmR" -#else -#define DRM_PRIMARY_MINOR_NAME "card" -#define DRM_CONTROL_MINOR_NAME "controlD" -#define DRM_RENDER_MINOR_NAME "renderD" -#endif - -#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__) +#ifdef __DragonFly__ #define DRM_MAJOR 145 #endif @@ -101,7 +99,7 @@ #define DRM_MAJOR 226 /* Linux */ #endif -#ifdef __OpenBSD__ +#if defined(__OpenBSD__) || defined(__DragonFly__) struct drm_pciinfo { uint16_t domain; uint8_t bus; @@ -123,6 +121,25 @@ struct drm_pciinfo { static drmServerInfoPtr drm_server_info; +static bool drmNodeIsDRM(int maj, int min); +static char *drmGetMinorNameForFD(int fd, int type); + +static unsigned log2_int(unsigned x) +{ + unsigned l; + + if (x < 2) { + return 0; + } + for (l = 2; ; l++) { + if ((unsigned)(1 << l) > x) { + return l - 1; + } + } + return 0; +} + + drm_public void drmSetServerInfo(drmServerInfoPtr info) { drm_server_info = info; @@ -179,7 +196,7 @@ drm_public void drmFree(void *pt) } /** - * Call ioctl, restarting if it is interupted + * Call ioctl, restarting if it is interrupted */ drm_public int drmIoctl(int fd, unsigned long request, void *arg) @@ -289,7 +306,7 @@ static int drmMatchBusID(const char *id1, const char *id2, int pci_domain_ok) * * \internal * Checks for failure. If failure was caused by signal call chown again. - * If any other failure happened then it will output error mesage using + * If any other failure happened then it will output error message using * drmMsg() call. */ #if !UDEV @@ -310,6 +327,19 @@ static int chown_check_return(const char *path, uid_t owner, gid_t group) } #endif +static const char *drmGetDeviceName(int type) +{ + switch (type) { + case DRM_NODE_PRIMARY: + return DRM_DEV_NAME; + case DRM_NODE_CONTROL: + return DRM_CONTROL_DEV_NAME; + case DRM_NODE_RENDER: + return DRM_RENDER_DEV_NAME; + } + return NULL; +} + /** * Open the DRM device, creating it if necessary. * @@ -326,8 +356,8 @@ static int chown_check_return(const char *path, uid_t owner, gid_t group) static int drmOpenDevice(dev_t dev, int minor, int type) { stat_t st; - const char *dev_name; - char buf[64]; + const char *dev_name = drmGetDeviceName(type); + char buf[DRM_NODE_NAME_MAX]; int fd; mode_t devmode = DRM_DEV_MODE, serv_mode; gid_t serv_group; @@ -337,19 +367,8 @@ static int drmOpenDevice(dev_t dev, int minor, int type) gid_t group = DRM_DEV_GID; #endif - switch (type) { - case DRM_NODE_PRIMARY: - dev_name = DRM_DEV_NAME; - break; - case DRM_NODE_CONTROL: - dev_name = DRM_CONTROL_DEV_NAME; - break; - case DRM_NODE_RENDER: - dev_name = DRM_RENDER_DEV_NAME; - break; - default: + if (!dev_name) return -EINVAL; - }; sprintf(buf, dev_name, DRM_DIR_NAME, minor); drmMsg("drmOpenDevice: node name is %s\n", buf); @@ -455,25 +474,14 @@ wait_for_udev: static int drmOpenMinor(int minor, int create, int type) { int fd; - char buf[64]; - const char *dev_name; + char buf[DRM_NODE_NAME_MAX]; + const char *dev_name = drmGetDeviceName(type); if (create) return drmOpenDevice(makedev(DRM_MAJOR, minor), minor, type); - switch (type) { - case DRM_NODE_PRIMARY: - dev_name = DRM_DEV_NAME; - break; - case DRM_NODE_CONTROL: - dev_name = DRM_CONTROL_DEV_NAME; - break; - case DRM_NODE_RENDER: - dev_name = DRM_RENDER_DEV_NAME; - break; - default: + if (!dev_name) return -EINVAL; - }; sprintf(buf, dev_name, DRM_DIR_NAME, minor); if ((fd = open(buf, O_RDWR | O_CLOEXEC, 0)) >= 0) @@ -530,8 +538,28 @@ static int drmGetMinorBase(int type) }; } -static int drmGetMinorType(int minor) +static int drmGetMinorType(int major, int minor) { +#ifdef __FreeBSD__ + char name[SPECNAMELEN]; + int id; + + if (!devname_r(makedev(major, minor), S_IFCHR, name, sizeof(name))) + return -1; + + if (sscanf(name, "drm/%d", &id) != 1) { + // If not in /dev/drm/ we have the type in the name + if (sscanf(name, "dri/card%d\n", &id) >= 1) + return DRM_NODE_PRIMARY; + else if (sscanf(name, "dri/control%d\n", &id) >= 1) + return DRM_NODE_CONTROL; + else if (sscanf(name, "dri/renderD%d\n", &id) >= 1) + return DRM_NODE_RENDER; + return -1; + } + + minor = id; +#endif int type = minor >> 6; if (minor < 0) @@ -684,7 +712,7 @@ static int drmOpenByName(const char *name, int type) int retcode; sprintf(proc_name, "/proc/dri/%d/name", i); - if ((fd = open(proc_name, 0, 0)) >= 0) { + if ((fd = open(proc_name, O_RDONLY, 0)) >= 0) { retcode = read(fd, buf, sizeof(buf)-1); close(fd); if (retcode) { @@ -750,8 +778,8 @@ drm_public int drmOpen(const char *name, const char *busid) */ drm_public int drmOpenWithType(const char *name, const char *busid, int type) { - if (!drmAvailable() && name != NULL && drm_server_info && - drm_server_info->load_module) { + if (name != NULL && drm_server_info && + drm_server_info->load_module && !drmAvailable()) { /* try to load the kernel module */ if (!drm_server_info->load_module(name)) { drmMsg("[drm] failed to load kernel module \"%s\"\n", name); @@ -1458,7 +1486,7 @@ drm_public int drmDMA(int fd, drmDMAReqPtr request) * * \param fd file descriptor. * \param context context. - * \param flags flags that determine the sate of the hardware when the function + * \param flags flags that determine the state of the hardware when the function * returns. * * \return always zero. @@ -2743,8 +2771,39 @@ drm_public int drmDropMaster(int fd) return drmIoctl(fd, DRM_IOCTL_DROP_MASTER, NULL); } +drm_public int drmIsMaster(int fd) +{ + /* Detect master by attempting something that requires master. + * + * Authenticating magic tokens requires master and 0 is an + * internal kernel detail which we could use. Attempting this on + * a master fd would fail therefore fail with EINVAL because 0 + * is invalid. + * + * A non-master fd will fail with EACCES, as the kernel checks + * for master before attempting to do anything else. + * + * Since we don't want to leak implementation details, use + * EACCES. + */ + return drmAuthMagic(fd, 0) != -EACCES; +} + drm_public char *drmGetDeviceNameFromFd(int fd) { +#ifdef __FreeBSD__ + struct stat sbuf; + int maj, min; + int nodetype; + + if (fstat(fd, &sbuf)) + return NULL; + + maj = major(sbuf.st_rdev); + min = minor(sbuf.st_rdev); + nodetype = drmGetMinorType(maj, min); + return drmGetMinorNameForFD(fd, nodetype); +#else char name[128]; struct stat sbuf; dev_t d; @@ -2767,6 +2826,7 @@ drm_public char *drmGetDeviceNameFromFd(int fd) return NULL; return strdup(name); +#endif } static bool drmNodeIsDRM(int maj, int min) @@ -2778,6 +2838,16 @@ static bool drmNodeIsDRM(int maj, int min) snprintf(path, sizeof(path), "/sys/dev/char/%d:%d/device/drm", maj, min); return stat(path, &sbuf) == 0; +#elif defined(__FreeBSD__) + char name[SPECNAMELEN]; + + if (!devname_r(makedev(maj, min), S_IFCHR, name, sizeof(name))) + return 0; + /* Handle drm/ and dri/ as both are present in different FreeBSD version + * FreeBSD on amd64/i386/powerpc external kernel modules create node in + * in /dev/drm/ and links in /dev/dri while a WIP in kernel driver creates + * only device nodes in /dev/dri/ */ + return (!strncmp(name, "drm/", 4) || !strncmp(name, "dri/", 4)); #else return maj == DRM_MAJOR; #endif @@ -2799,7 +2869,7 @@ drm_public int drmGetNodeTypeFromFd(int fd) return -1; } - type = drmGetMinorType(min); + type = drmGetMinorType(maj, min); if (type == -1) errno = ENODEV; return type; @@ -2881,12 +2951,55 @@ static char *drmGetMinorNameForFD(int fd, int type) closedir(sysdir); return NULL; +#elif defined(__FreeBSD__) + struct stat sbuf; + char dname[SPECNAMELEN]; + const char *mname; + char name[SPECNAMELEN]; + int id, maj, min, nodetype, i; + + if (fstat(fd, &sbuf)) + return NULL; + + maj = major(sbuf.st_rdev); + min = minor(sbuf.st_rdev); + + if (!drmNodeIsDRM(maj, min) || !S_ISCHR(sbuf.st_mode)) + return NULL; + + if (!devname_r(sbuf.st_rdev, S_IFCHR, dname, sizeof(dname))) + return NULL; + + /* Handle both /dev/drm and /dev/dri + * FreeBSD on amd64/i386/powerpc external kernel modules create node in + * in /dev/drm/ and links in /dev/dri while a WIP in kernel driver creates + * only device nodes in /dev/dri/ */ + + /* Get the node type represented by fd so we can deduce the target name */ + nodetype = drmGetMinorType(maj, min); + if (nodetype == -1) + return (NULL); + mname = drmGetMinorName(type); + + for (i = 0; i < SPECNAMELEN; i++) { + if (isalpha(dname[i]) == 0 && dname[i] != '/') + break; + } + if (dname[i] == '\0') + return (NULL); + + id = (int)strtol(&dname[i], NULL, 10); + id -= drmGetMinorBase(nodetype); + snprintf(name, sizeof(name), DRM_DIR_NAME "/%s%d", mname, + id + drmGetMinorBase(type)); + + return strdup(name); #else struct stat sbuf; char buf[PATH_MAX + 1]; - const char *dev_name; + const char *dev_name = drmGetDeviceName(type); unsigned int maj, min; - int n, base; + int n; if (fstat(fd, &sbuf)) return NULL; @@ -2897,25 +3010,10 @@ static char *drmGetMinorNameForFD(int fd, int type) if (!drmNodeIsDRM(maj, min) || !S_ISCHR(sbuf.st_mode)) return NULL; - switch (type) { - case DRM_NODE_PRIMARY: - dev_name = DRM_DEV_NAME; - break; - case DRM_NODE_CONTROL: - dev_name = DRM_CONTROL_DEV_NAME; - break; - case DRM_NODE_RENDER: - dev_name = DRM_RENDER_DEV_NAME; - break; - default: + if (!dev_name) return NULL; - }; - base = drmGetMinorBase(type); - if (base < 0) - return NULL; - - n = snprintf(buf, sizeof(buf), dev_name, DRM_DIR_NAME, min - base); + n = snprintf(buf, sizeof(buf), dev_name, DRM_DIR_NAME, min); if (n == -1 || n >= sizeof(buf)) return NULL; @@ -2980,10 +3078,10 @@ sysfs_uevent_get(const char *path, const char *fmt, ...) /* Little white lie to avoid major rework of the existing code */ #define DRM_BUS_VIRTIO 0x10 -static int drmParseSubsystemType(int maj, int min) -{ #ifdef __linux__ - char path[PATH_MAX + 1]; +static int get_subsystem_type(const char *device_path) +{ + char path[PATH_MAX + 1] = ""; char link[PATH_MAX + 1] = ""; char *name; struct { @@ -2993,12 +3091,13 @@ static int drmParseSubsystemType(int maj, int min) { "/pci", DRM_BUS_PCI }, { "/usb", DRM_BUS_USB }, { "/platform", DRM_BUS_PLATFORM }, + { "/spi", DRM_BUS_PLATFORM }, { "/host1x", DRM_BUS_HOST1X }, { "/virtio", DRM_BUS_VIRTIO }, }; - snprintf(path, PATH_MAX, "/sys/dev/char/%d:%d/device/subsystem", - maj, min); + strncpy(path, device_path, PATH_MAX); + strncat(path, "/subsystem", PATH_MAX); if (readlink(path, link, PATH_MAX) < 0) return -errno; @@ -3013,7 +3112,31 @@ static int drmParseSubsystemType(int maj, int min) } return -EINVAL; -#elif defined(__OpenBSD__) +} +#endif + +static int drmParseSubsystemType(int maj, int min) +{ +#ifdef __linux__ + char path[PATH_MAX + 1] = ""; + char real_path[PATH_MAX + 1] = ""; + int subsystem_type; + + snprintf(path, sizeof(path), "/sys/dev/char/%d:%d/device", maj, min); + + subsystem_type = get_subsystem_type(path); + /* Try to get the parent (underlying) device type */ + if (subsystem_type == DRM_BUS_VIRTIO) { + /* Assume virtio-pci on error */ + if (!realpath(path, real_path)) + return DRM_BUS_VIRTIO; + strncat(path, "/..", PATH_MAX); + subsystem_type = get_subsystem_type(path); + if (subsystem_type < 0) + return DRM_BUS_VIRTIO; + } + return subsystem_type; +#elif defined(__OpenBSD__) || defined(__DragonFly__) || defined(__FreeBSD__) return DRM_BUS_PCI; #else #warning "Missing implementation of drmParseSubsystemType" @@ -3021,6 +3144,7 @@ static int drmParseSubsystemType(int maj, int min) #endif } +#ifdef __linux__ static void get_pci_path(int maj, int min, char *pci_path) { @@ -3036,6 +3160,67 @@ get_pci_path(int maj, int min, char *pci_path) if (term && strncmp(term, "/virtio", 7) == 0) *term = 0; } +#endif + +#ifdef __FreeBSD__ +static int get_sysctl_pci_bus_info(int maj, int min, drmPciBusInfoPtr info) +{ + char dname[SPECNAMELEN]; + char sysctl_name[16]; + char sysctl_val[256]; + size_t sysctl_len; + int id, type, nelem; + unsigned int rdev, majmin, domain, bus, dev, func; + + rdev = makedev(maj, min); + if (!devname_r(rdev, S_IFCHR, dname, sizeof(dname))) + return -EINVAL; + + if (sscanf(dname, "drm/%d\n", &id) != 1) + return -EINVAL; + type = drmGetMinorType(maj, min); + if (type == -1) + return -EINVAL; + + /* BUG: This above section is iffy, since it mandates that a driver will + * create both card and render node. + * If it does not, the next DRM device will create card#X and + * renderD#(128+X)-1. + * This is a possibility in FreeBSD but for now there is no good way for + * obtaining the info. + */ + switch (type) { + case DRM_NODE_PRIMARY: + break; + case DRM_NODE_CONTROL: + id -= 64; + break; + case DRM_NODE_RENDER: + id -= 128; + break; + } + if (id < 0) + return -EINVAL; + + if (snprintf(sysctl_name, sizeof(sysctl_name), "hw.dri.%d.busid", id) <= 0) + return -EINVAL; + sysctl_len = sizeof(sysctl_val); + if (sysctlbyname(sysctl_name, sysctl_val, &sysctl_len, NULL, 0)) + return -EINVAL; + + #define bus_fmt "pci:%04x:%02x:%02x.%u" + + nelem = sscanf(sysctl_val, bus_fmt, &domain, &bus, &dev, &func); + if (nelem != 4) + return -EINVAL; + info->domain = domain; + info->bus = bus; + info->dev = dev; + info->func = func; + + return 0; +} +#endif static int drmParsePciBusInfo(int maj, int min, drmPciBusInfoPtr info) { @@ -3062,11 +3247,11 @@ static int drmParsePciBusInfo(int maj, int min, drmPciBusInfoPtr info) info->func = func; return 0; -#elif defined(__OpenBSD__) +#elif defined(__OpenBSD__) || defined(__DragonFly__) struct drm_pciinfo pinfo; int fd, type; - type = drmGetMinorType(min); + type = drmGetMinorType(maj, min); if (type == -1) return -ENODEV; @@ -3086,6 +3271,8 @@ static int drmParsePciBusInfo(int maj, int min, drmPciBusInfoPtr info) info->func = pinfo.func; return 0; +#elif defined(__FreeBSD__) + return get_sysctl_pci_bus_info(maj, min, info); #else #warning "Missing implementation of drmParsePciBusInfo" return -EINVAL; @@ -3122,10 +3309,6 @@ drm_public int drmDevicesEqual(drmDevicePtr a, drmDevicePtr b) static int drmGetNodeType(const char *name) { - if (strncmp(name, DRM_PRIMARY_MINOR_NAME, - sizeof(DRM_PRIMARY_MINOR_NAME) - 1) == 0) - return DRM_NODE_PRIMARY; - if (strncmp(name, DRM_CONTROL_MINOR_NAME, sizeof(DRM_CONTROL_MINOR_NAME ) - 1) == 0) return DRM_NODE_CONTROL; @@ -3134,6 +3317,10 @@ static int drmGetNodeType(const char *name) sizeof(DRM_RENDER_MINOR_NAME) - 1) == 0) return DRM_NODE_RENDER; + if (strncmp(name, DRM_PRIMARY_MINOR_NAME, + sizeof(DRM_PRIMARY_MINOR_NAME) - 1) == 0) + return DRM_NODE_PRIMARY; + return -EINVAL; } @@ -3228,11 +3415,11 @@ static int drmParsePciDeviceInfo(int maj, int min, return parse_config_sysfs_file(maj, min, device); return 0; -#elif defined(__OpenBSD__) +#elif defined(__OpenBSD__) || defined(__DragonFly__) struct drm_pciinfo pinfo; int fd, type; - type = drmGetMinorType(min); + type = drmGetMinorType(maj, min); if (type == -1) return -ENODEV; @@ -3253,6 +3440,48 @@ static int drmParsePciDeviceInfo(int maj, int min, device->subdevice_id = pinfo.subdevice_id; return 0; +#elif defined(__FreeBSD__) + drmPciBusInfo info; + struct pci_conf_io pc; + struct pci_match_conf patterns[1]; + struct pci_conf results[1]; + int fd, error; + + if (get_sysctl_pci_bus_info(maj, min, &info) != 0) + return -EINVAL; + + fd = open("/dev/pci", O_RDONLY, 0); + if (fd < 0) + return -errno; + + bzero(&patterns, sizeof(patterns)); + patterns[0].pc_sel.pc_domain = info.domain; + patterns[0].pc_sel.pc_bus = info.bus; + patterns[0].pc_sel.pc_dev = info.dev; + patterns[0].pc_sel.pc_func = info.func; + patterns[0].flags = PCI_GETCONF_MATCH_DOMAIN | PCI_GETCONF_MATCH_BUS + | PCI_GETCONF_MATCH_DEV | PCI_GETCONF_MATCH_FUNC; + bzero(&pc, sizeof(struct pci_conf_io)); + pc.num_patterns = 1; + pc.pat_buf_len = sizeof(patterns); + pc.patterns = patterns; + pc.match_buf_len = sizeof(results); + pc.matches = results; + + if (ioctl(fd, PCIOCGETCONF, &pc) || pc.status == PCI_GETCONF_ERROR) { + error = errno; + close(fd); + return -error; + } + close(fd); + + device->vendor_id = results[0].pc_vendor; + device->device_id = results[0].pc_device; + device->subvendor_id = results[0].pc_subvendor; + device->subdevice_id = results[0].pc_subdevice; + device->revision_id = results[0].pc_revid; + + return 0; #else #warning "Missing implementation of drmParsePciDeviceInfo" return -EINVAL; @@ -3402,6 +3631,46 @@ free_device: return ret; } +#ifdef __linux__ +static int drm_usb_dev_path(int maj, int min, char *path, size_t len) +{ + char *value, *tmp_path, *slash; + + snprintf(path, len, "/sys/dev/char/%d:%d/device", maj, min); + + value = sysfs_uevent_get(path, "DEVTYPE"); + if (!value) + return -ENOENT; + + if (strcmp(value, "usb_device") == 0) + return 0; + if (strcmp(value, "usb_interface") != 0) + return -ENOTSUP; + + /* The parent of a usb_interface is a usb_device */ + + tmp_path = realpath(path, NULL); + if (!tmp_path) + return -errno; + + slash = strrchr(tmp_path, '/'); + if (!slash) { + free(tmp_path); + return -EINVAL; + } + + *slash = '\0'; + + if (snprintf(path, len, "%s", tmp_path) >= (int)len) { + free(tmp_path); + return -EINVAL; + } + + free(tmp_path); + return 0; +} +#endif + static int drmParseUsbBusInfo(int maj, int min, drmUsbBusInfoPtr info) { #ifdef __linux__ @@ -3409,7 +3678,9 @@ static int drmParseUsbBusInfo(int maj, int min, drmUsbBusInfoPtr info) unsigned int bus, dev; int ret; - snprintf(path, sizeof(path), "/sys/dev/char/%d:%d/device", maj, min); + ret = drm_usb_dev_path(maj, min, path, sizeof(path)); + if (ret < 0) + return ret; value = sysfs_uevent_get(path, "BUSNUM"); if (!value) @@ -3448,7 +3719,9 @@ static int drmParseUsbDeviceInfo(int maj, int min, drmUsbDeviceInfoPtr info) unsigned int vendor, product; int ret; - snprintf(path, sizeof(path), "/sys/dev/char/%d:%d/device", maj, min); + ret = drm_usb_dev_path(maj, min, path, sizeof(path)); + if (ret < 0) + return ret; value = sysfs_uevent_get(path, "PRODUCT"); if (!value) @@ -3509,69 +3782,97 @@ free_device: return ret; } -static int drmParsePlatformBusInfo(int maj, int min, drmPlatformBusInfoPtr info) +static int drmParseOFBusInfo(int maj, int min, char *fullname) { #ifdef __linux__ - char path[PATH_MAX + 1], *name; + char path[PATH_MAX + 1], *name, *tmp_name; snprintf(path, sizeof(path), "/sys/dev/char/%d:%d/device", maj, min); name = sysfs_uevent_get(path, "OF_FULLNAME"); - if (!name) - return -ENOENT; + tmp_name = name; + if (!name) { + /* If the device lacks OF data, pick the MODALIAS info */ + name = sysfs_uevent_get(path, "MODALIAS"); + if (!name) + return -ENOENT; + + /* .. and strip the MODALIAS=[platform,usb...]: part. */ + tmp_name = strrchr(name, ':'); + if (!tmp_name) { + free(name); + return -ENOENT; + } + tmp_name++; + } - strncpy(info->fullname, name, DRM_PLATFORM_DEVICE_NAME_LEN); - info->fullname[DRM_PLATFORM_DEVICE_NAME_LEN - 1] = '\0'; + strncpy(fullname, tmp_name, DRM_PLATFORM_DEVICE_NAME_LEN); + fullname[DRM_PLATFORM_DEVICE_NAME_LEN - 1] = '\0'; free(name); return 0; #else -#warning "Missing implementation of drmParsePlatformBusInfo" +#warning "Missing implementation of drmParseOFBusInfo" return -EINVAL; #endif } -static int drmParsePlatformDeviceInfo(int maj, int min, - drmPlatformDeviceInfoPtr info) +static int drmParseOFDeviceInfo(int maj, int min, char ***compatible) { #ifdef __linux__ - char path[PATH_MAX + 1], *value; + char path[PATH_MAX + 1], *value, *tmp_name; unsigned int count, i; int err; snprintf(path, sizeof(path), "/sys/dev/char/%d:%d/device", maj, min); value = sysfs_uevent_get(path, "OF_COMPATIBLE_N"); - if (!value) - return -ENOENT; - - sscanf(value, "%u", &count); - free(value); + if (value) { + sscanf(value, "%u", &count); + free(value); + } else { + /* Assume one entry if the device lack OF data */ + count = 1; + } - info->compatible = calloc(count + 1, sizeof(*info->compatible)); - if (!info->compatible) + *compatible = calloc(count + 1, sizeof(char *)); + if (!*compatible) return -ENOMEM; for (i = 0; i < count; i++) { value = sysfs_uevent_get(path, "OF_COMPATIBLE_%u", i); + tmp_name = value; if (!value) { - err = -ENOENT; - goto free; + /* If the device lacks OF data, pick the MODALIAS info */ + value = sysfs_uevent_get(path, "MODALIAS"); + if (!value) { + err = -ENOENT; + goto free; + } + + /* .. and strip the MODALIAS=[platform,usb...]: part. */ + tmp_name = strrchr(value, ':'); + if (!tmp_name) { + free(value); + return -ENOENT; + } + tmp_name = strdup(tmp_name + 1); + free(value); } - info->compatible[i] = value; + (*compatible)[i] = tmp_name; } return 0; free: while (i--) - free(info->compatible[i]); + free((*compatible)[i]); - free(info->compatible); + free(*compatible); return err; #else -#warning "Missing implementation of drmParsePlatformDeviceInfo" +#warning "Missing implementation of drmParseOFDeviceInfo" return -EINVAL; #endif } @@ -3594,7 +3895,7 @@ static int drmProcessPlatformDevice(drmDevicePtr *device, dev->businfo.platform = (drmPlatformBusInfoPtr)ptr; - ret = drmParsePlatformBusInfo(maj, min, dev->businfo.platform); + ret = drmParseOFBusInfo(maj, min, dev->businfo.platform->fullname); if (ret < 0) goto free_device; @@ -3602,7 +3903,7 @@ static int drmProcessPlatformDevice(drmDevicePtr *device, ptr += sizeof(drmPlatformBusInfo); dev->deviceinfo.platform = (drmPlatformDeviceInfoPtr)ptr; - ret = drmParsePlatformDeviceInfo(maj, min, dev->deviceinfo.platform); + ret = drmParseOFDeviceInfo(maj, min, &dev->deviceinfo.platform->compatible); if (ret < 0) goto free_device; } @@ -3616,73 +3917,6 @@ free_device: return ret; } -static int drmParseHost1xBusInfo(int maj, int min, drmHost1xBusInfoPtr info) -{ -#ifdef __linux__ - char path[PATH_MAX + 1], *name; - - snprintf(path, sizeof(path), "/sys/dev/char/%d:%d/device", maj, min); - - name = sysfs_uevent_get(path, "OF_FULLNAME"); - if (!name) - return -ENOENT; - - strncpy(info->fullname, name, DRM_HOST1X_DEVICE_NAME_LEN); - info->fullname[DRM_HOST1X_DEVICE_NAME_LEN - 1] = '\0'; - free(name); - - return 0; -#else -#warning "Missing implementation of drmParseHost1xBusInfo" - return -EINVAL; -#endif -} - -static int drmParseHost1xDeviceInfo(int maj, int min, - drmHost1xDeviceInfoPtr info) -{ -#ifdef __linux__ - char path[PATH_MAX + 1], *value; - unsigned int count, i; - int err; - - snprintf(path, sizeof(path), "/sys/dev/char/%d:%d/device", maj, min); - - value = sysfs_uevent_get(path, "OF_COMPATIBLE_N"); - if (!value) - return -ENOENT; - - sscanf(value, "%u", &count); - free(value); - - info->compatible = calloc(count + 1, sizeof(*info->compatible)); - if (!info->compatible) - return -ENOMEM; - - for (i = 0; i < count; i++) { - value = sysfs_uevent_get(path, "OF_COMPATIBLE_%u", i); - if (!value) { - err = -ENOENT; - goto free; - } - - info->compatible[i] = value; - } - - return 0; - -free: - while (i--) - free(info->compatible[i]); - - free(info->compatible); - return err; -#else -#warning "Missing implementation of drmParseHost1xDeviceInfo" - return -EINVAL; -#endif -} - static int drmProcessHost1xDevice(drmDevicePtr *device, const char *node, int node_type, int maj, int min, bool fetch_deviceinfo, @@ -3701,7 +3935,7 @@ static int drmProcessHost1xDevice(drmDevicePtr *device, dev->businfo.host1x = (drmHost1xBusInfoPtr)ptr; - ret = drmParseHost1xBusInfo(maj, min, dev->businfo.host1x); + ret = drmParseOFBusInfo(maj, min, dev->businfo.host1x->fullname); if (ret < 0) goto free_device; @@ -3709,7 +3943,7 @@ static int drmProcessHost1xDevice(drmDevicePtr *device, ptr += sizeof(drmHost1xBusInfo); dev->deviceinfo.host1x = (drmHost1xDeviceInfoPtr)ptr; - ret = drmParseHost1xDeviceInfo(maj, min, dev->deviceinfo.host1x); + ret = drmParseOFDeviceInfo(maj, min, &dev->deviceinfo.host1x->compatible); if (ret < 0) goto free_device; } @@ -3783,7 +4017,7 @@ static void drmFoldDuplicatedDevices(drmDevicePtr local_devices[], int count) for (j = i + 1; j < count; j++) { if (drmDevicesEqual(local_devices[i], local_devices[j])) { local_devices[i]->available_nodes |= local_devices[j]->available_nodes; - node_type = log2(local_devices[j]->available_nodes); + node_type = log2_int(local_devices[j]->available_nodes); memcpy(local_devices[i]->nodes[node_type], local_devices[j]->nodes[node_type], drmGetMaxNodeName()); drmFreeDevice(&local_devices[j]); @@ -3847,7 +4081,7 @@ drm_public int drmGetDevice2(int fd, uint32_t flags, drmDevicePtr *device) char node[PATH_MAX + 1]; const char *dev_name; int node_type, subsystem_type; - int maj, min, n, ret, base; + int maj, min, n, ret; if (fd == -1 || device == NULL) return -EINVAL; @@ -3861,29 +4095,15 @@ drm_public int drmGetDevice2(int fd, uint32_t flags, drmDevicePtr *device) if (!drmNodeIsDRM(maj, min) || !S_ISCHR(sbuf.st_mode)) return -EINVAL; - node_type = drmGetMinorType(min); + node_type = drmGetMinorType(maj, min); if (node_type == -1) return -ENODEV; - switch (node_type) { - case DRM_NODE_PRIMARY: - dev_name = DRM_DEV_NAME; - break; - case DRM_NODE_CONTROL: - dev_name = DRM_CONTROL_DEV_NAME; - break; - case DRM_NODE_RENDER: - dev_name = DRM_RENDER_DEV_NAME; - break; - default: + dev_name = drmGetDeviceName(node_type); + if (!dev_name) return -EINVAL; - }; - base = drmGetMinorBase(node_type); - if (base < 0) - return -EINVAL; - - n = snprintf(node, PATH_MAX, dev_name, DRM_DIR_NAME, min - base); + n = snprintf(node, PATH_MAX, dev_name, DRM_DIR_NAME, min); if (n == -1 || n >= PATH_MAX) return -errno; if (stat(node, &sbuf)) @@ -4098,12 +4318,14 @@ drm_public char *drmGetDeviceNameFromFd2(int fd) free(value); return strdup(path); +#elif defined(__FreeBSD__) + return drmGetDeviceNameFromFd(fd); #else struct stat sbuf; char node[PATH_MAX + 1]; const char *dev_name; int node_type; - int maj, min, n, base; + int maj, min, n; if (fstat(fd, &sbuf)) return NULL; @@ -4114,29 +4336,15 @@ drm_public char *drmGetDeviceNameFromFd2(int fd) if (!drmNodeIsDRM(maj, min) || !S_ISCHR(sbuf.st_mode)) return NULL; - node_type = drmGetMinorType(min); + node_type = drmGetMinorType(maj, min); if (node_type == -1) return NULL; - switch (node_type) { - case DRM_NODE_PRIMARY: - dev_name = DRM_DEV_NAME; - break; - case DRM_NODE_CONTROL: - dev_name = DRM_CONTROL_DEV_NAME; - break; - case DRM_NODE_RENDER: - dev_name = DRM_RENDER_DEV_NAME; - break; - default: - return NULL; - }; - - base = drmGetMinorBase(node_type); - if (base < 0) + dev_name = drmGetDeviceName(node_type); + if (!dev_name) return NULL; - n = snprintf(node, PATH_MAX, dev_name, DRM_DIR_NAME, min - base); + n = snprintf(node, PATH_MAX, dev_name, DRM_DIR_NAME, min); if (n == -1 || n >= PATH_MAX) return NULL; @@ -4276,3 +4484,95 @@ drm_public int drmSyncobjSignal(int fd, const uint32_t *handles, ret = drmIoctl(fd, DRM_IOCTL_SYNCOBJ_SIGNAL, &args); return ret; } + +drm_public int drmSyncobjTimelineSignal(int fd, const uint32_t *handles, + uint64_t *points, uint32_t handle_count) +{ + struct drm_syncobj_timeline_array args; + int ret; + + memclear(args); + args.handles = (uintptr_t)handles; + args.points = (uintptr_t)points; + args.count_handles = handle_count; + + ret = drmIoctl(fd, DRM_IOCTL_SYNCOBJ_TIMELINE_SIGNAL, &args); + return ret; +} + +drm_public int drmSyncobjTimelineWait(int fd, uint32_t *handles, uint64_t *points, + unsigned num_handles, + int64_t timeout_nsec, unsigned flags, + uint32_t *first_signaled) +{ + struct drm_syncobj_timeline_wait args; + int ret; + + memclear(args); + args.handles = (uintptr_t)handles; + args.points = (uintptr_t)points; + args.timeout_nsec = timeout_nsec; + args.count_handles = num_handles; + args.flags = flags; + + ret = drmIoctl(fd, DRM_IOCTL_SYNCOBJ_TIMELINE_WAIT, &args); + if (ret < 0) + return -errno; + + if (first_signaled) + *first_signaled = args.first_signaled; + return ret; +} + + +drm_public int drmSyncobjQuery(int fd, uint32_t *handles, uint64_t *points, + uint32_t handle_count) +{ + struct drm_syncobj_timeline_array args; + int ret; + + memclear(args); + args.handles = (uintptr_t)handles; + args.points = (uintptr_t)points; + args.count_handles = handle_count; + + ret = drmIoctl(fd, DRM_IOCTL_SYNCOBJ_QUERY, &args); + if (ret) + return ret; + return 0; +} + +drm_public int drmSyncobjQuery2(int fd, uint32_t *handles, uint64_t *points, + uint32_t handle_count, uint32_t flags) +{ + struct drm_syncobj_timeline_array args; + + memclear(args); + args.handles = (uintptr_t)handles; + args.points = (uintptr_t)points; + args.count_handles = handle_count; + args.flags = flags; + + return drmIoctl(fd, DRM_IOCTL_SYNCOBJ_QUERY, &args); +} + + +drm_public int drmSyncobjTransfer(int fd, + uint32_t dst_handle, uint64_t dst_point, + uint32_t src_handle, uint64_t src_point, + uint32_t flags) +{ + struct drm_syncobj_transfer args; + int ret; + + memclear(args); + args.src_handle = src_handle; + args.dst_handle = dst_handle; + args.src_point = src_point; + args.dst_point = dst_point; + args.flags = flags; + + ret = drmIoctl(fd, DRM_IOCTL_SYNCOBJ_TRANSFER, &args); + + return ret; +}