static int device_new_ud(sysview_device **out, sysview_seat *seat, unsigned int type, struct udev_device *ud) {
_cleanup_(sysview_device_freep) sysview_device *device = NULL;
int r;
assert_return(seat, -EINVAL);
assert_return(ud, -EINVAL);
r = sysview_device_new(&device, seat, udev_device_get_syspath(ud));
if (r < 0)
return r;
device->type = type;
switch (type) {
case SYSVIEW_DEVICE_EVDEV:
device->evdev.ud = udev_device_ref(ud);
break;
case SYSVIEW_DEVICE_DRM:
device->drm.ud = udev_device_ref(ud);
break;
default:
assert_not_reached("sysview: invalid udev-device type");
}
if (out)
*out = device;
device = NULL;
return 0;
}
UdevDevice::UdevDevice(const UdevDevice& source)
:device(source.device)
{
/* Reference the device: */
if(device!=0)
udev_device_ref(device);
}
struct ratbag_device*
ratbag_device_new(struct ratbag *ratbag, struct udev_device *udev_device,
const char *name, const struct input_id *id)
{
struct ratbag_device *device = NULL;
device = zalloc(sizeof(*device));
device->name = strdup_safe(name);
device->ratbag = ratbag_ref(ratbag);
device->refcount = 1;
device->udev_device = udev_device_ref(udev_device);
device->ids = *id;
device->data = ratbag_device_data_new_for_id(ratbag, id);
list_init(&device->profiles);
list_insert(&ratbag->devices, &device->link);
/* We assume that most devices have this capability, so let's set it
* by default. The few devices that miss this capability should
* unset it instead.
*/
ratbag_device_set_capability(device,
RATBAG_DEVICE_CAP_QUERY_CONFIGURATION);
return device;
}
DevicePrivate::DevicePrivate(struct udev_device *udev_, bool ref)
: udev(udev_)
{
if (ref) {
udev_device_ref(udev);
}
}
UdevDevice UdevDevice::getParent(void)
{
/* Get the parent device: */
udev_device* parent=udev_device_get_parent(device);
/* The parent device is not supposed to be unref'ed, so let's explicitly ref it here so that a later unref won't destroy it: */
if(parent!=0)
udev_device_ref(parent);
return UdevDevice(parent);
}
UdevDevice UdevDevice::getParent(const char* subsystem,const char* deviceType)
{
/* Get the parent device: */
udev_device* parent=udev_device_get_parent_with_subsystem_devtype(device,subsystem,deviceType);
/* The parent device is not supposed to be unref'ed, so let's explicitly ref it here so that a later unref won't hurt: */
if(parent!=0)
udev_device_ref(parent);
return UdevDevice(parent);
}
UdevDevice& UdevDevice::operator=(const UdevDevice& source)
{
if(device!=source.device)
{
if(device!=0)
udev_device_unref(device);
device=source.device;
if(device!=0)
udev_device_ref(device);
}
return *this;
}
/**
* @brief Create a new generic keyboard backlight controller object.
*
*
* @param device The udev device that represents this keyboard backlight
* controller. This device will be referenced internally.
* @param type The type of the keyboard backlight controller.
* @param ctx A context for the specific type of keyboard backlight
* controller. This memory must be externally tracked.
*
* @return A new generic keyboard backlight object initialized with the
* specified input. However, all of the capabilities are not yet initalized.
*/
struct kb_controller *
kb_controller_new(struct udev_device *device,
enum kb_controller_type type, void *ctx)
{
struct kb_controller *kb = calloc(sizeof(struct kb_controller), 1);
assert(kb != NULL);
assert(device != NULL);
udev_device_ref(device);
kb->kbc_device = device;
kb->kbc_type = type;
kb->kbc_ctx = ctx;
return kb;
}
/**
* @brief
*
* @param device
*
* @return
*/
struct usp_pwm_t *
usp_pwm_new(struct udev_device *device, const char *name,
enum usp_pwm_type_e type)
{
struct usp_pwm_t *pwm = NULL;
pwm = calloc(sizeof(struct usp_pwm_t), 1);
assert(pwm != NULL);
udev_device_ref(pwm->uspwm_device);
pwm->uspwm_device = device;
pwm->uspwm_type = type;
pwm->uspwm_name = name;
usp_ref_init(pwm, usp_pwm_delete);
return pwm;
}
DevicePrivate &DevicePrivate::operator=(const DevicePrivate &other)
{
udev_device_unref(udev);
udev = udev_device_ref(other.udev);
return *this;
}
int main(int argc, char **argv)
{
int rc = 1;
struct udev *udev = NULL;
struct udev_device *device = NULL;
const char *syspath,
*phys = NULL;
const char *product;
char group[1024];
char *str;
if (argc != 2)
return 1;
syspath = argv[1];
udev = udev_new();
if (!udev)
goto out;
device = udev_device_new_from_syspath(udev, syspath);
if (!device)
goto out;
/* Find the first parent with ATTRS{phys} set. For tablets that
* value looks like usb-0000:00:14.0-1/input1. Drop the /input1
* bit and use the remainder as device group identifier */
while (device != NULL) {
struct udev_device *parent;
phys = udev_device_get_sysattr_value(device, "phys");
if (phys)
break;
parent = udev_device_get_parent(device);
udev_device_ref(parent);
udev_device_unref(device);
device = parent;
}
if (!phys)
goto out;
/* udev sets PRODUCT on the same device we find PHYS on, let's rely
on that*/
product = udev_device_get_property_value(device, "PRODUCT");
if (!product)
product = "";
snprintf(group, sizeof(group), "%s:%s", product, phys);
str = strstr(group, "/input");
if (str)
*str = '\0';
/* Cintiq 22HD Touch has
usb-0000:00:14.0-6.3.1/input0 for the touch
usb-0000:00:14.0-6.3.0/input0 for the pen
Check if there's a . after the last -, if so, cut off the string
there.
*/
str = strrchr(group, '.');
if (str && str > strrchr(group, '-'))
*str = '\0';
printf("%s\n", group);
rc = 0;
out:
if (device)
udev_device_unref(device);
if (udev)
udev_unref(udev);
return rc;
}
