int
main(int argc, char **argv)
{
int blight, connector_id;
const char *path;
struct udev *udev;
struct udev_enumerate *e;
struct udev_list_entry *entry;
struct udev_device *drm_device;
if (argc < 3) {
printf("Please add connector_id and brightness values from 0-255\n");
return 1;
}
connector_id = atoi(argv[1]);
blight = atoi(argv[2]);
udev = udev_new();
if (udev == NULL) {
printf("failed to initialize udev context\n");
return 1;
}
e = udev_enumerate_new(udev);
udev_enumerate_add_match_subsystem(e, "drm");
udev_enumerate_add_match_sysname(e, "card[0-9]*");
udev_enumerate_scan_devices(e);
drm_device = NULL;
udev_list_entry_foreach(entry, udev_enumerate_get_list_entry(e)) {
path = udev_list_entry_get_name(entry);
drm_device = udev_device_new_from_syspath(udev, path);
break;
}
int
wgbm_get_default_fd_for_pattern(const char *pattern)
{
struct udev *ud;
struct udev_enumerate *en;
struct udev_list_entry *devices, *entry;
const char *path, *filename;
struct udev_device *device;
int fd;
ud = udev_new();
en = udev_enumerate_new(ud);
udev_enumerate_add_match_subsystem(en, "drm");
udev_enumerate_add_match_sysname(en, pattern);
udev_enumerate_scan_devices(en);
devices = udev_enumerate_get_list_entry(en);
udev_list_entry_foreach(entry, devices) {
path = udev_list_entry_get_name(entry);
device = udev_device_new_from_syspath(ud, path);
filename = udev_device_get_devnode(device);
fd = open(filename, O_RDWR | O_CLOEXEC);
udev_device_unref(device);
if (fd >= 0) {
udev_enumerate_unref(en);
udev_unref(ud);
return fd;
}
}
static int loopback_list_get(MountPoint **head) {
_cleanup_udev_enumerate_unref_ struct udev_enumerate *e = NULL;
struct udev_list_entry *item = NULL, *first = NULL;
_cleanup_udev_unref_ struct udev *udev = NULL;
int r;
assert(head);
udev = udev_new();
if (!udev)
return -ENOMEM;
e = udev_enumerate_new(udev);
if (!e)
return -ENOMEM;
r = udev_enumerate_add_match_subsystem(e, "block");
if (r < 0)
return r;
r = udev_enumerate_add_match_sysname(e, "loop*");
if (r < 0)
return r;
r = udev_enumerate_add_match_sysattr(e, "loop/backing_file", NULL);
if (r < 0)
return r;
r = udev_enumerate_scan_devices(e);
if (r < 0)
return r;
first = udev_enumerate_get_list_entry(e);
udev_list_entry_foreach(item, first) {
MountPoint *lb;
_cleanup_udev_device_unref_ struct udev_device *d;
char *loop;
const char *dn;
d = udev_device_new_from_syspath(udev, udev_list_entry_get_name(item));
if (!d)
return -ENOMEM;
dn = udev_device_get_devnode(d);
if (!dn)
continue;
loop = strdup(dn);
if (!loop)
return -ENOMEM;
lb = new0(MountPoint, 1);
if (!lb) {
free(loop);
return -ENOMEM;
}
lb->path = loop;
LIST_PREPEND(mount_point, *head, lb);
}
static char *
get_render_node_from_id_path_tag(struct udev *udev,
char *id_path_tag,
char another_tag)
{
struct udev_device *device;
struct udev_enumerate *e;
struct udev_list_entry *entry;
const char *path, *id_path_tag_tmp;
char *path_res;
char found = 0;
UDEV_SYMBOL(struct udev_enumerate *, udev_enumerate_new,
(struct udev *));
UDEV_SYMBOL(int, udev_enumerate_add_match_subsystem,
(struct udev_enumerate *, const char *));
UDEV_SYMBOL(int, udev_enumerate_add_match_sysname,
(struct udev_enumerate *, const char *));
UDEV_SYMBOL(int, udev_enumerate_scan_devices,
(struct udev_enumerate *));
UDEV_SYMBOL(struct udev_list_entry *, udev_enumerate_get_list_entry,
(struct udev_enumerate *));
UDEV_SYMBOL(struct udev_list_entry *, udev_list_entry_get_next,
(struct udev_list_entry *));
UDEV_SYMBOL(const char *, udev_list_entry_get_name,
(struct udev_list_entry *));
UDEV_SYMBOL(struct udev_device *, udev_device_new_from_syspath,
(struct udev *, const char *));
UDEV_SYMBOL(const char *, udev_device_get_property_value,
(struct udev_device *, const char *));
UDEV_SYMBOL(const char *, udev_device_get_devnode,
(struct udev_device *));
UDEV_SYMBOL(struct udev_device *, udev_device_unref,
(struct udev_device *));
e = udev_enumerate_new(udev);
udev_enumerate_add_match_subsystem(e, "drm");
udev_enumerate_add_match_sysname(e, "render*");
udev_enumerate_scan_devices(e);
udev_list_entry_foreach(entry, udev_enumerate_get_list_entry(e)) {
path = udev_list_entry_get_name(entry);
device = udev_device_new_from_syspath(udev, path);
if (!device)
continue;
id_path_tag_tmp = udev_device_get_property_value(device, "ID_PATH_TAG");
if (id_path_tag_tmp) {
if ((!another_tag && !strcmp(id_path_tag, id_path_tag_tmp)) ||
(another_tag && strcmp(id_path_tag, id_path_tag_tmp))) {
found = 1;
break;
}
}
udev_device_unref(device);
}
/**
* @brief Create a new net object
* @param name The name of the underlying device (eth0, br1, etc)
* @return A newly allocated net object, or NULL on failure
*
* This function creates a new net object based on @p name.
* Only the most minimal lookups are performed at creation in order
* to save memory.
*/
Eeze_Net *
eeze_net_new(const char *name)
{
const char *syspath = NULL;
const char *idx;
_udev_enumerate *en;
_udev_list_entry *devs, *cur;
_udev_device *device = NULL;
Eeze_Net *net;
net = eina_hash_find(eeze_nets, name);
if (net)
{
EINA_REFCOUNT_REF(net);
return net;
}
en = udev_enumerate_new(udev);
udev_enumerate_add_match_sysname(en, name);
udev_enumerate_add_match_subsystem(en, "net");
udev_enumerate_scan_devices(en);
devs = udev_enumerate_get_list_entry(en);
udev_list_entry_foreach(cur, devs)
{
const char *devname, *test;
devname = udev_list_entry_get_name(cur);
test = strrchr(devname, '/');
if (strcmp(++test, name)) continue;
device = _new_device(devname);
syspath = eina_stringshare_add(name);
break;
}
if (!device) return NULL;
net = calloc(1, sizeof(Eeze_Net));
if (!net) return NULL;
EINA_REFCOUNT_INIT(net);
net->device = device;
net->syspath = syspath;
net->name = eina_stringshare_add(name);
idx = udev_device_get_sysattr_value(net->device, "ifindex");
net->index = atoi(idx);
eina_hash_add(eeze_nets, name, net);
udev_enumerate_unref(en);
return net;
}
int read_fpga_status() {
struct udev *udev;
struct udev_enumerate *enumerate;
struct udev_list_entry *device;
struct udev_device *dev;
const char *path;
long prog_done = 0;
udev = udev_new();
if (!udev) {
fprintf(stderr, "ERROR: udev_new() failed\n");
return -1;
}
// Enumerate devcfg
enumerate = udev_enumerate_new(udev);
udev_enumerate_add_match_sysname(enumerate, XDEV_CFG_NAME);
udev_enumerate_scan_devices(enumerate);
device = udev_enumerate_get_list_entry(enumerate);
// Did not find a device, lets try a different name
if (!device)
{
fprintf(stderr, "ERROR: Could not find FPGA configuration device!\n");
return -1;
}
// List should have only one entry
if (udev_list_entry_get_next(device) != 0)
{
fprintf(stderr, "ERROR: Found more than one FPGA configuration device!\n");
return -1;
}
// Create udev device
path = udev_list_entry_get_name(device);
dev = udev_device_new_from_syspath(udev, path);
prog_done = (int)atol(udev_device_get_sysattr_value(dev, "prog_done"));
udev_enumerate_unref(enumerate);
udev_unref(udev);
return(prog_done);
}
int
rw_netlink_get_pci_addr(const char *ifname, rw_pci_address_t *pci_addr)
{
struct udev *udev = NULL;
struct udev_enumerate *enumerate = NULL;
struct udev_list_entry *devices, *dev_list_entry;
int ret = -1;
udev = udev_new();
if (!udev) {
ret = -1;
goto ret;
}
enumerate = udev_enumerate_new(udev);
udev_enumerate_add_match_subsystem(enumerate, "net");
udev_enumerate_add_match_sysname(enumerate, ifname);
udev_enumerate_scan_devices(enumerate);
devices = udev_enumerate_get_list_entry(enumerate);
udev_list_entry_foreach(dev_list_entry, devices) {
const char *path;
path = udev_list_entry_get_name(dev_list_entry);
ret = rw_sys_populate_pci_from_path(path, pci_addr);
if (!ret){
break;
}
}
ret:
if (enumerate){
udev_enumerate_unref(enumerate);
}
if (udev){
udev_unref(udev);
}
return ret;
}
static int get_js_number(struct udev_device *udevice)
{
struct udev_list_entry *devices, *dev_list_entry;
struct udev_enumerate *enumerate;
struct udev_device *hid_parent;
const char *hidraw_node;
const char *hid_id;
int number = 0;
hid_parent = udev_device_get_parent_with_subsystem_devtype(udevice,
"hid", NULL);
/*
* Look for HID_UNIQ first for the correct behavior via BT, if
* HID_UNIQ is not available it means the USB bus is being used and we
* can rely on HID_PHYS.
*/
hid_id = udev_device_get_property_value(hid_parent, "HID_UNIQ");
if (!hid_id)
hid_id = udev_device_get_property_value(hid_parent,
"HID_PHYS");
hidraw_node = udev_device_get_devnode(udevice);
if (!hid_id || !hidraw_node)
return 0;
enumerate = udev_enumerate_new(udev_device_get_udev(udevice));
udev_enumerate_add_match_sysname(enumerate, "js*");
udev_enumerate_scan_devices(enumerate);
devices = udev_enumerate_get_list_entry(enumerate);
udev_list_entry_foreach(dev_list_entry, devices) {
struct udev_device *input_parent;
struct udev_device *js_dev;
const char *input_id;
const char *devname;
devname = udev_list_entry_get_name(dev_list_entry);
js_dev = udev_device_new_from_syspath(
udev_device_get_udev(udevice),
devname);
input_parent = udev_device_get_parent_with_subsystem_devtype(
js_dev, "input", NULL);
if (!input_parent)
goto next;
/* check if this is the joystick relative to the hidraw device
* above */
input_id = udev_device_get_sysattr_value(input_parent, "uniq");
/*
* A strlen() check is needed because input device over USB
* have the UNIQ attribute defined but with an empty value.
*/
if (!input_id || strlen(input_id) == 0)
input_id = udev_device_get_sysattr_value(input_parent,
"phys");
if (!input_id)
goto next;
if (!strcmp(input_id, hid_id)) {
number = atoi(udev_device_get_sysnum(js_dev));
/* joystick numbers start from 0, leds from 1 */
number++;
udev_device_unref(js_dev);
break;
}
next:
udev_device_unref(js_dev);
}
udev_enumerate_unref(enumerate);
return number;
}
static int get_js_number(struct udev_device *udevice)
{
struct udev_list_entry *devices, *dev_list_entry;
struct udev_enumerate *enumerate;
struct udev_device *hid_parent;
const char *hidraw_node;
const char *hid_phys;
int number = 0;
hid_parent = udev_device_get_parent_with_subsystem_devtype(udevice,
"hid", NULL);
hid_phys = udev_device_get_property_value(hid_parent, "HID_PHYS");
hidraw_node = udev_device_get_devnode(udevice);
if (!hid_phys || !hidraw_node)
return 0;
enumerate = udev_enumerate_new(udev_device_get_udev(udevice));
udev_enumerate_add_match_sysname(enumerate, "js*");
udev_enumerate_scan_devices(enumerate);
devices = udev_enumerate_get_list_entry(enumerate);
udev_list_entry_foreach(dev_list_entry, devices) {
struct udev_device *input_parent;
struct udev_device *js_dev;
const char *input_phys;
const char *devname;
devname = udev_list_entry_get_name(dev_list_entry);
js_dev = udev_device_new_from_syspath(
udev_device_get_udev(udevice),
devname);
input_parent = udev_device_get_parent_with_subsystem_devtype(
js_dev, "input", NULL);
if (!input_parent)
goto next;
/* check if this is the joystick relative to the hidraw device
* above */
input_phys = udev_device_get_sysattr_value(input_parent,
"phys");
if (!input_phys)
goto next;
if (!strcmp(input_phys, hid_phys)) {
number = atoi(udev_device_get_sysnum(js_dev));
/* joystick numbers start from 0, leds from 1 */
number++;
udev_device_unref(js_dev);
break;
}
next:
udev_device_unref(js_dev);
}
udev_enumerate_unref(enumerate);
return number;
}