Add untested and very experimental razer support #57

src/Makefile.am

@@ -1,5 +1,5 @@
 bin_PROGRAMS   = light
-light_SOURCES  = main.c light.c light.h helpers.c helpers.h impl/sysfs.c impl/sysfs.h impl/util.h impl/util.c
+light_SOURCES  = main.c light.c light.h helpers.c helpers.h impl/sysfs.c impl/sysfs.h impl/util.h impl/util.c impl/razer.h impl/razer.c
 light_CPPFLAGS = -I../include -D_GNU_SOURCE
 light_CFLAGS   = -W -Wall -Wextra -std=gnu18 -Wno-type-limits -Wno-format-truncation -Wno-unused-parameter
 

src/helpers.c

@@ -3,6 +3,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <unistd.h> // access
 #include <sys/types.h>
 #include <dirent.h>
 #include <errno.h> // errno
@@ -56,6 +57,11 @@ bool light_file_write_uint64(char const *filename, uint64_t val)
     return true;
 }
 
+bool light_file_exists (char const *filename)
+{
+    return access( filename, F_OK ) != -1;
+}
+
 /* Returns true if file is writable, false otherwise */
 bool light_file_is_writable(char const *filename)
 {

src/helpers.h

@@ -43,6 +43,7 @@ light_loglevel_t light_loglevel;
 bool light_file_write_uint64   (char const *filename, uint64_t val);
 bool light_file_read_uint64    (char const *filename, uint64_t *val);
 
+bool light_file_exists (char const *filename);
 bool light_file_is_writable (char const *filename);
 bool light_file_is_readable (char const *filename);
 

src/impl/razer.c

@@ -1 +1,121 @@
+
+#include "impl/razer.h"
+#include "light.h"
+#include "helpers.h"
+
+#include <stdio.h> //snprintf
+#include <stdlib.h> // malloc, free
+#include <dirent.h> // opendir, readdir
+
+static void _impl_razer_add_target(light_device_t *device, char const *name, char const *filename, uint64_t max_brightness)
+{
+    impl_razer_data_t *target_data = malloc(sizeof(impl_razer_data_t));
+    snprintf(target_data->brightness, sizeof(target_data->brightness), "/sys/bus/hid/drivers/razerkbd/%s/%s", device->name, filename);
+    target_data->max_brightness = max_brightness;
+    
+    // Only add targets that actually exist, as we aren't fully sure exactly what targets exist for a given device
+    if(light_file_exists(target_data->brightness))
+    {
+        light_create_device_target(device, name, impl_razer_set, impl_razer_get, impl_razer_getmax, impl_razer_command, target_data);
+    }
+    else 
+    {
+        LIGHT_WARN("razer: couldn't add target %s to device %s, the file %s doesn't exist", name, device->name, filename);
+        // target_data will not be freed automatically if we dont add a device target with it as userdata, so free it here
+        free(target_data);
+    }
+}
+
+static void _impl_razer_add_device(light_device_enumerator_t *enumerator, char const *device_id)
+{
+    // Create a new razer device
+    light_device_t *new_device = light_create_device(enumerator, device_id, NULL);
+
+    // Setup a target to backlight
+    _impl_razer_add_target(new_device, "backlight", "matrix_brightness", 255);
+    
+    // Setup targets to different possible leds
+    _impl_razer_add_target(new_device, "game_led", "game_led_state", 1);
+    _impl_razer_add_target(new_device, "macro_led", "macro_led_state", 1);
+    _impl_razer_add_target(new_device, "logo_led", "logo_led_state", 1);
+    _impl_razer_add_target(new_device, "profile_led_r", "profile_led_red", 1);
+    _impl_razer_add_target(new_device, "profile_led_g", "profile_led_green", 1);
+    _impl_razer_add_target(new_device, "profile_led_b", "profile_led_blue", 1);
+}
+
+bool impl_razer_init(light_device_enumerator_t *enumerator)
+{
+    // Iterate through the led controllers and create a device_target for each controller 
+    DIR *razer_dir;
+    struct dirent *curr_entry;
+    
+    if((razer_dir = opendir("/sys/bus/hid/drivers/razerkbd/")) == NULL)
+    {
+        // Razer driver isnt properly installed, so we cant add devices in this enumerator 
+        return true;
+    }
+    
+    while((curr_entry = readdir(razer_dir)) != NULL)
+    {
+        // Skip dot entries
+        if(curr_entry->d_name[0] == '.')
+        {
+            continue;
+        }
  
+        _impl_razer_add_device(enumerator, curr_entry->d_name);
+    }
+    
+    closedir(razer_dir);
+    
+    return true;
+}
+
+bool impl_razer_free(light_device_enumerator_t *enumerator)
+{
+    return true;
+}
+
+bool impl_razer_set(light_device_target_t *target, uint64_t in_value)
+{
+    impl_razer_data_t *data = (impl_razer_data_t*)target->device_target_data;
+
+    if(!light_file_write_uint64(data->brightness, in_value))
+    {
+        LIGHT_ERR("failed to write to razer device");
+        return false;
+    }
+    
+    return true;
+}
+
+bool impl_razer_get(light_device_target_t *target, uint64_t *out_value)
+{
+    impl_razer_data_t *data = (impl_razer_data_t*)target->device_target_data;
+
+    if(!light_file_read_uint64(data->brightness, out_value))
+    {
+        LIGHT_ERR("failed to read from razer device");
+        return false;
+    }
+    
+    return true;
+}
+
+bool impl_razer_getmax(light_device_target_t *target, uint64_t *out_value)
+{
+    impl_razer_data_t *data = (impl_razer_data_t*)target->device_target_data;
+
+    *out_value = data->max_brightness;
+    
+    return true;
+}
+
+bool impl_razer_command(light_device_target_t *target, char const *command_string)
+{
+    // No current need for custom commands in sysfs enumerator
+    // To implement support, simply parse the command string to your liking, and return false on invalid input or results!
+    return true;
+}
+
+

src/impl/razer.h

@@ -1 +1,24 @@
- 
+
+#pragma once 
+
+#include "light.h"
+
+// Implementation of the razer enumerator
+// Enumerates devices for the openrazer driver https://github.com/openrazer/openrazer
+
+// Device target data 
+struct _impl_razer_data_t
+{
+    char brightness[NAME_MAX];
+    uint64_t max_brightness;
+};
+
+typedef struct _impl_razer_data_t impl_razer_data_t;
+
+bool impl_razer_init(light_device_enumerator_t *enumerator);
+bool impl_razer_free(light_device_enumerator_t *enumerator);
+
+bool impl_razer_set(light_device_target_t *target, uint64_t in_value);
+bool impl_razer_get(light_device_target_t *target, uint64_t *out_value);
+bool impl_razer_getmax(light_device_target_t *target, uint64_t *out_value);
+bool impl_razer_command(light_device_target_t *target, char const *command_string);

src/light.c

@@ -5,7 +5,7 @@
 // The different device implementations
 #include "impl/sysfs.h"
 #include "impl/util.h"
-//#include "impl/razer.h"
+#include "impl/razer.h"
 
 #include <stdlib.h> // malloc, free
 #include <string.h> // strstr
@@ -433,7 +433,7 @@ light_context_t* light_initialize(int argc, char **argv)
     // Create the built-in enumerators
     light_create_enumerator(new_ctx, "sysfs", &impl_sysfs_init, &impl_sysfs_free);
     light_create_enumerator(new_ctx, "util", &impl_util_init, &impl_util_free);
-    //light_create_enumerator(new_ctx, "razer", &impl_razer_init, &impl_razer_free);
+    light_create_enumerator(new_ctx, "razer", &impl_razer_init, &impl_razer_free);
 
     // This is where we would create enumerators from plugins as well
     // 1. Run the plugins get_name() function to get its name