Create a flag category only for backlight/kbd

Now we can save, restore, get [max] brightness etc. for both screen
and keyboard controllers

include/light.h

 #define LIGHT_YEAR 2014
 #define LIGHT_AUTHOR "Fredrik Haikarainen"
 
-#define ASSERT_OPSET() \
-  if(opSet)\
+#define ASSERT_SET(t,v) \
+  if(v)\
   {\
-    printf("Operation arguments can not be used in conjunction.\n");\
+    printf(t" arguments can not be used in conjunction.\n");\
     return FALSE;\
   }\
-  opSet = TRUE;
+  v = TRUE;
 
-#define ASSERT_TARGETSET() \
-  if(targetSet)\
-  {\
-    printf("Target arguments can not be used in conjunction.\n");\
-    return FALSE;\
-  }\
-  targetSet = TRUE;
-
-#define ASSERT_CTRLSET()\
-  if(ctrlSet)\
-  {\
-    printf("Controller arguments can not be used in conjunction.\n");\
-    return FALSE;\
-  }\
-  ctrlSet = TRUE;
+#define ASSERT_OPSET() ASSERT_SET("Operation", opSet)
+#define ASSERT_TARGETSET() ASSERT_SET("Target", targetSet)
+#define ASSERT_FIELDSET() ASSERT_SET("Field", fieldSet)
+#define ASSERT_CTRLSET() ASSERT_SET("Controller", ctrlSet)
+#define ASSERT_VALSET() ASSERT_SET("Value", valSet)
 
-#define ASSERT_VALSET()\
-  if(valSet)\
-  {\
-    printf("Value arguments can not be used in conjunction.\n");\
-    return FALSE;\
-  }\
-  valSet = TRUE;
-
-
-typedef enum LIGHT_TARGET {
+typedef enum LIGHT_FIELD {
   LIGHT_BRIGHTNESS = 0,
   LIGHT_MAX_BRIGHTNESS,
   LIGHT_MIN_CAP,
-  LIGHT_SAVERESTORE,
-  LIGHT_KEYBOARD,
-  LIGHT_KEYBOARD_MAX_BRIGHTNESS
+  LIGHT_SAVERESTORE
+} LIGHT_FIELD;
+
+typedef enum LIGHT_TARGET {
+  LIGHT_BACKLIGHT = 0,
+  LIGHT_KEYBOARD
 } LIGHT_TARGET;
 
 typedef enum LIGHT_CTRL_MODE {
   unsigned long   specifiedValueRaw; /* The specified value in raw mode */
   double          specifiedValuePercent; /* The specified value in percent */
 
-  LIGHT_TARGET    target;
+  LIGHT_TARGET   target;
+  LIGHT_FIELD    field;
 
   /* Cache data */
   LIGHT_BOOL      hasCachedMaxBrightness;
 
 /* WARNING: `buffer` HAS to be freed by the user if not null once returned!
  * Size is always 256 */
-LIGHT_BOOL light_genPath(char const *controller, LIGHT_TARGET type, char **buffer);
+LIGHT_BOOL light_genPath(char const *controller, LIGHT_TARGET target, LIGHT_FIELD type, char **buffer);
 
 LIGHT_BOOL light_getBrightness(char const *controller, unsigned long *v);
 

src/light.c

   light_Configuration.valueMode              = LIGHT_PERCENT;
   light_Configuration.specifiedValueRaw      = 0;
   light_Configuration.specifiedValuePercent  = 0.0;
-  light_Configuration.target                 = LIGHT_BRIGHTNESS;
+  light_Configuration.target                 = LIGHT_BACKLIGHT;
+  light_Configuration.field                  = LIGHT_BRIGHTNESS;
   light_Configuration.hasCachedMaxBrightness = FALSE;
   light_Configuration.cachedMaxBrightness    = 0;
   light_verbosity                            = 0;
 
   LIGHT_BOOL opSet = FALSE;
   LIGHT_BOOL targetSet = FALSE;
+  LIGHT_BOOL fieldSet = FALSE;
   LIGHT_BOOL ctrlSet = FALSE;
   LIGHT_BOOL valSet = FALSE;
 
   unsigned long specLen = 0;
 
-  while((currFlag = getopt(argc, argv, "HhVGSAULIObmckas:prv:")) != -1)
+  while((currFlag = getopt(argc, argv, "HhVGSAULIObmclkas:prv:")) != -1)
   {
     switch(currFlag)
     {
         break;
 
       /* -- Targets -- */
-      case 'b':
+      case 'l':
         ASSERT_TARGETSET();
-        light_Configuration.target = LIGHT_BRIGHTNESS;
+        light_Configuration.target = LIGHT_BACKLIGHT;
         break;
-      case 'm':
+      case 'k':
         ASSERT_TARGETSET();
-        light_Configuration.target = LIGHT_MAX_BRIGHTNESS;
+        light_Configuration.target = LIGHT_KEYBOARD;
+        break;
+
+      /* -- Fields -- */
+      case 'b':
+        ASSERT_FIELDSET();
+        light_Configuration.field = LIGHT_BRIGHTNESS;
+        break;
+      case 'm':
+        ASSERT_FIELDSET();
+        light_Configuration.field = LIGHT_MAX_BRIGHTNESS;
         break;
       case 'c':
-        ASSERT_TARGETSET();
-        light_Configuration.target = LIGHT_MIN_CAP;
+        ASSERT_FIELDSET();
+        light_Configuration.field = LIGHT_MIN_CAP;
         break;
-      case 'k':
-	      ASSERT_TARGETSET();
-	      light_Configuration.target = LIGHT_KEYBOARD;
 
       /* -- Controller selection -- */
       case 'a':
   printf("  -O:\t\tSave brightness\n\n");
 
   printf("Targets (can not be used in conjunction):\n");
+  printf("  -l:\t\tAct on screen backlight (default)\n");
+  printf("  -k:\t\tAct on keyboard backlight\n\n");
+
+  printf("Fields (can not be used in conjunction):\n");
   printf("  -b:\t\tBrightness (default)\n  \t\tUsed with [GSAU]\n\n");
   printf("  -m:\t\tMaximum brightness\n  \t\tUsed with [G]\n\n");
   printf("  -c:\t\tMinimum cap\n  \t\tUsed with [GS]\n");
-  printf("  -k:\t\tSet keyboard brightness instead of display brightness \n \t\tUsed with [GSAU]");
   printf("  \t\tG returns null if no minimum cap is set.\n\n");
 
   printf("Controller selection (can not be used in conjunction):\n");
   }
 
   if(mode == LIGHT_SAVE ||
-     (mode == LIGHT_SET && light_Configuration.target == LIGHT_MIN_CAP))
+     (mode == LIGHT_SET && light_Configuration.field == LIGHT_MIN_CAP))
   {
     /* Make sure we have a valid /etc/light directory, as well as mincap and save */
-    char const * const dirs[3] = {"/etc/light", "/etc/light/mincap", "/etc/light/save"};
+    char const * const dirs[5] = {"/etc/light", "/etc/light/mincap", "/etc/light/save", "/etc/light/mincap/kbd", "/etc/light/save/kbd"};
     char const * const *dir = dirs;
     char const * const direrr = "'%s' does not exist and could not be created, make sure this application is run as root.";
 
-    while (dir < dirs + 3)
+    while (dir < dirs + 5)
     {
       mkdirVal = mkdir(*dir, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
       if(mkdirVal != 0 && errno != EEXIST)
   }
 
   /* No need to go further if targetting mincap */
-  if(light_Configuration.target == LIGHT_MIN_CAP)
+  if(light_Configuration.field == LIGHT_MIN_CAP)
   {
     return TRUE;
   }
   /* Handle get operations */
   if(light_Configuration.operationMode == LIGHT_GET)
   {
-    switch(light_Configuration.target){
+    switch(light_Configuration.field){
       case LIGHT_BRIGHTNESS:
         (valueMode == LIGHT_RAW) ? printf("%lu\n", rawCurr) : printf("%.2f\n", percentCurr);
         break;
      light_Configuration.operationMode == LIGHT_ADD ||
      light_Configuration.operationMode == LIGHT_SUB)
   {
-    if(light_Configuration.target == LIGHT_MIN_CAP)
+    if(light_Configuration.field == LIGHT_MIN_CAP)
     {
       /* Handle minimum cap files */
       writeVal = valueMode == LIGHT_RAW ?
       /* All good? Return true. */
       return TRUE;
 
-    }else if(light_Configuration.target == LIGHT_BRIGHTNESS || light_Configuration.target == LIGHT_KEYBOARD){
+    }else if(light_Configuration.field == LIGHT_BRIGHTNESS){
       /* Handle brightness writing */
 
       switch(light_Configuration.operationMode)
       return TRUE;
 
     }else{
-      /* If we didn't provide a valid target for write operations, fail. */
+      /* If we didn't provide a valid field for write operations, fail. */
       fprintf(stderr, "set/add/subtract operations are only available for brightness and minimum cap files.\n");
       return FALSE;
     }
     return TRUE;
   }
 
-  fprintf(stderr, "Controller: %s\nValueRaw: %lu\nValuePercent: %.2f\nOpMode: %u\nValMode: %u\nTarget: %u\n\n", light_Configuration.specifiedController, light_Configuration.specifiedValueRaw, light_Configuration.specifiedValuePercent, light_Configuration.operationMode, light_Configuration.valueMode, light_Configuration.target);
+  fprintf(stderr, "Controller: %s\nValueRaw: %lu\nValuePercent: %.2f\nOpMode: %u\nValMode: %u\nField: %u\n\n", light_Configuration.specifiedController, light_Configuration.specifiedValueRaw, light_Configuration.specifiedValuePercent, light_Configuration.operationMode, valueMode, light_Configuration.field);
 
   fprintf(stderr, "You did not specify a valid combination of commandline arguments. Have some help: \n");
   light_printHelp();
 
 }
 
-LIGHT_BOOL light_genPath(char const *controller, LIGHT_TARGET type, char **buffer)
+LIGHT_BOOL light_genPath(char const *controller, LIGHT_TARGET target, LIGHT_FIELD type, char **buffer)
 {
   char* returner = malloc(256);
   int spfVal = -1;
   }
 
   memset(returner, '\0', 256);
-
-  switch(type)
-  {
-    case LIGHT_BRIGHTNESS:
-      spfVal = sprintf(returner, "/sys/class/backlight/%s/brightness", controller);
-      break;
-    case LIGHT_MAX_BRIGHTNESS:
-      spfVal = sprintf(returner, "/sys/class/backlight/%s/max_brightness", controller);
-      break;
-    case LIGHT_MIN_CAP:
-      spfVal = sprintf(returner, "/etc/light/mincap/%s", controller);
-      break;
-    case LIGHT_SAVERESTORE:
-      spfVal = sprintf(returner, "/etc/light/save/%s", controller);
-      break;
-    case LIGHT_KEYBOARD:
-      spfVal = sprintf(returner, "/sys/class/leds/%s/brightness", controller);
-      break;
-    case LIGHT_KEYBOARD_MAX_BRIGHTNESS:
-      spfVal = sprintf(returner, "/sys/class/leds/%s/max_brightness", controller);
-      break;
+  if(target == LIGHT_BACKLIGHT)
+  {
+    switch(type)
+    {
+      case LIGHT_BRIGHTNESS:
+        spfVal = sprintf(returner, "/sys/class/backlight/%s/brightness", controller);
+        break;
+      case LIGHT_MAX_BRIGHTNESS:
+        spfVal = sprintf(returner, "/sys/class/backlight/%s/max_brightness", controller);
+        break;
+      case LIGHT_MIN_CAP:
+        spfVal = sprintf(returner, "/etc/light/mincap/%s", controller);
+        break;
+      case LIGHT_SAVERESTORE:
+        spfVal = sprintf(returner, "/etc/light/save/%s", controller);
+        break;
+    }
+  }else{
+    switch(type)
+    {
+      case LIGHT_BRIGHTNESS:
+        spfVal = sprintf(returner, "/sys/class/leds/%s/brightness", controller);
+        break;
+      case LIGHT_MAX_BRIGHTNESS:
+        spfVal = sprintf(returner, "/sys/class/leds/%s/max_brightness", controller);
+        break;
+      case LIGHT_MIN_CAP:
+        spfVal = sprintf(returner, "/etc/light/mincap/kbd/%s", controller);
+        break;
+      case LIGHT_SAVERESTORE:
+        spfVal = sprintf(returner, "/etc/light/save/kbd/%s", controller);
+        break;
+    }
   }
-
   if(spfVal < 0)
   {
     LIGHT_ERR("sprintf failed");
   }
 
   *buffer = returner;
-
   return TRUE;
 }
 
 LIGHT_BOOL light_getBrightnessPath(char const *controller, char **path)
 {
-  LIGHT_TARGET target;
-
-  if(light_Configuration.target == LIGHT_MIN_CAP)
-  {
-    target = LIGHT_BRIGHTNESS;
-  }
-  else
-  {
-    target = light_Configuration.target;
-  }
-
-  if(!light_genPath(controller, target, path))
+  if(!light_genPath(controller, light_Configuration.target, LIGHT_BRIGHTNESS, path))
   {
     LIGHT_ERR("could not generate path to brightness file");
     return FALSE;
     LIGHT_ERR("could not read value from brightness file");
     return FALSE;
   }
-
   return TRUE;
 }
 
 LIGHT_BOOL light_getMaxBrightnessPath(char const *controller, char **path)
 {
-  LIGHT_TARGET target;
-
-  if(light_Configuration.target == LIGHT_KEYBOARD)
-  {
-    target = LIGHT_KEYBOARD_MAX_BRIGHTNESS;
-  }
-  else
-  {
-    target = LIGHT_MAX_BRIGHTNESS;
-  }
-
-  if(!light_genPath(controller, target, path))
+  if(!light_genPath(controller, light_Configuration.target, LIGHT_MAX_BRIGHTNESS, path))
   {
     LIGHT_ERR("could not generate path to maximum brightness file");
     return FALSE;
   char *brightnessPath = NULL;
   LIGHT_BOOL writeVal = FALSE;
 
-  if(!light_genPath(controller, light_Configuration.target, &brightnessPath))
+  if(!light_genPath(controller, light_Configuration.target, light_Configuration.field, &brightnessPath))
   {
     LIGHT_ERR("could not generate path to brightness file");
     return FALSE;
   /* On auto mode, we need to check if we can read the max brightness value
      of the controller for later computation */
   if(light_Configuration.controllerMode == LIGHT_AUTO ||
-     light_Configuration.target == LIGHT_MAX_BRIGHTNESS)
+     light_Configuration.field == LIGHT_MAX_BRIGHTNESS)
   {
     if(!light_getMaxBrightnessPath(controller, &brightnessPath))
     {
   }
 
   if(light_Configuration.operationMode != LIGHT_GET &&
-     light_Configuration.target != LIGHT_MIN_CAP &&
+     light_Configuration.field != LIGHT_MIN_CAP &&
      !light_isWritable(brightnessPath))
   {
     LIGHT_WARN("could not open controller brightness file for writing, so controller is not accessible");
 {
  char * mincapPath = NULL;
 
- if(!light_genPath(controller, LIGHT_MIN_CAP, &mincapPath))
+ if(!light_genPath(controller, light_Configuration.target, LIGHT_MIN_CAP, &mincapPath))
  {
     LIGHT_ERR("could not generate path to minimum cap file");
     return FALSE;
 LIGHT_BOOL light_setMinCap(char const * controller, unsigned long v)
 {
   char * mincapPath = NULL;
-  if(!light_genPath(controller, LIGHT_MIN_CAP, &mincapPath))
+  if(!light_genPath(controller, light_Configuration.target, LIGHT_MIN_CAP, &mincapPath))
   {
     LIGHT_ERR("could not generate path to minimum cap file");
     return FALSE;
 
 LIGHT_BOOL light_saveBrightness(char const *controller, unsigned long v){
   char *savePath = NULL;
-  if(!light_genPath(controller, LIGHT_SAVERESTORE, &savePath))
+  if(!light_genPath(controller, light_Configuration.target, LIGHT_SAVERESTORE, &savePath))
   {
     LIGHT_ERR("could not generate path to save/restore file");
     return FALSE;
   char *restorePath = NULL;
   unsigned long v = 0;
 
-  if(!light_genPath(controller, LIGHT_SAVERESTORE, &restorePath))
+  if(!light_genPath(controller, light_Configuration.target, LIGHT_SAVERESTORE, &restorePath))
   {
     LIGHT_ERR("could not generate path to save/restore file");
     return FALSE;