main.c

//     File: main.c
// Abstract: source code for HID LED test tool
//  Version: 1.3
// 
// Disclaimer: IMPORTANT:  This Apple software is supplied to you by Apple
// Inc. ("Apple") in consideration of your agreement to the following
// terms, and your use, installation, modification or redistribution of
// this Apple software constitutes acceptance of these terms.  If you do
// not agree with these terms, please do not use, install, modify or
// redistribute this Apple software.
// 
// In consideration of your agreement to abide by the following terms, and
// subject to these terms, Apple grants you a personal, non-exclusive
// license, under Apple's copyrights in this original Apple software (the
// "Apple Software"), to use, reproduce, modify and redistribute the Apple
// Software, with or without modifications, in source and/or binary forms;
// provided that if you redistribute the Apple Software in its entirety and
// without modifications, you must retain this notice and the following
// text and disclaimers in all such redistributions of the Apple Software.
// Neither the name, trademarks, service marks or logos of Apple Inc. may
// be used to endorse or promote products derived from the Apple Software
// without specific prior written permission from Apple.  Except as
// expressly stated in this notice, no other rights or licenses, express or
// implied, are granted by Apple herein, including but not limited to any
// patent rights that may be infringed by your derivative works or by other
// works in which the Apple Software may be incorporated.
// 
// The Apple Software is provided by Apple on an "AS IS" basis.  APPLE
// MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION
// THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND
// OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS.
// 
// IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL
// OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION,
// MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED
// AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE),
// STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
// 
// Copyright (C) 2015 Apple Inc. All Rights Reserved.
// 
// ****************************************************
#pragma mark -
#pragma mark * complation directives *
// ----------------------------------------------------

#ifndef FALSE
#define FALSE 0
#define TRUE !FALSE
#endif

// ****************************************************
#pragma mark -
#pragma mark * includes & imports *
// ----------------------------------------------------

#include <CoreFoundation/CoreFoundation.h>
#include <Carbon/Carbon.h>
#include <IOKit/hid/IOHIDLib.h>
#include <libgen.h>

// ****************************************************
#pragma mark -
#pragma mark * typedef's, struct's, enums, defines, etc. *

#define require(value, location) if (value == 0) goto location;
#define require_noerr(value, location) if (value != 0) goto location;

// ----------------------------------------------------
// function to create a matching dictionary for usage page & usage
static CFMutableDictionaryRef hu_CreateMatchingDictionaryUsagePageUsage(Boolean isDeviceNotElement,
                                                                        UInt32 inUsagePage,
                                                                        UInt32 inUsage) {
    // create a dictionary to add usage page / usages to
    CFMutableDictionaryRef result = CFDictionaryCreateMutable(kCFAllocatorDefault,
                                                              0,
                                                              &kCFTypeDictionaryKeyCallBacks,
                                                              &kCFTypeDictionaryValueCallBacks);
    
    if (result) {
        if (inUsagePage) {
            // Add key for device type to refine the matching dictionary.
            CFNumberRef pageCFNumberRef = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &inUsagePage);
            
            if (pageCFNumberRef) {
                if (isDeviceNotElement) {
                    CFDictionarySetValue(result, CFSTR(kIOHIDDeviceUsagePageKey), pageCFNumberRef);
                } else {
                    CFDictionarySetValue(result, CFSTR(kIOHIDElementUsagePageKey), pageCFNumberRef);
                }
                CFRelease(pageCFNumberRef);
                
                // note: the usage is only valid if the usage page is also defined
                if (inUsage) {
                    CFNumberRef usageCFNumberRef = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &inUsage);
                    
                    if (usageCFNumberRef) {
                        if (isDeviceNotElement) {
                            CFDictionarySetValue(result, CFSTR(kIOHIDDeviceUsageKey), usageCFNumberRef);
                        } else {
                            CFDictionarySetValue(result, CFSTR(kIOHIDElementUsageKey), usageCFNumberRef);
                        }
                        CFRelease(usageCFNumberRef);
                    } else {
                        fprintf(stderr, "%s: CFNumberCreate( usage ) failed.", __PRETTY_FUNCTION__);
                    }
                }
            } else {
                fprintf(stderr, "%s: CFNumberCreate( usage page ) failed.", __PRETTY_FUNCTION__);
            }
        }
    } else {
        fprintf(stderr, "%s: CFDictionaryCreateMutable failed.", __PRETTY_FUNCTION__);
    }
    return result;
}    // hu_CreateMatchingDictionaryUsagePageUsage

int main(int argc, const char *argv[]) {
#pragma unused ( argc, argv )
    IOHIDDeviceRef *tIOHIDDeviceRefs = nil;
    char *path = dirname(argv[0]);
    char config_path[1024];
    sprintf(config_path, "%s/led-backlight-cmstorm.cfg", path);
    // create a IO HID Manager reference
    IOHIDManagerRef tIOHIDManagerRef = IOHIDManagerCreate(kCFAllocatorDefault, kIOHIDOptionsTypeNone);
    require(tIOHIDManagerRef, Oops);
    
    // Create a device matching dictionary
    CFDictionaryRef matchingCFDictRef = hu_CreateMatchingDictionaryUsagePageUsage(TRUE,
                                                                                  kHIDPage_GenericDesktop,
                                                                                  kHIDUsage_GD_Keyboard);
    require(matchingCFDictRef, Oops);
    
    // set the HID device matching dictionary
    IOHIDManagerSetDeviceMatching(tIOHIDManagerRef, matchingCFDictRef);
    
    if (matchingCFDictRef) {
        CFRelease(matchingCFDictRef);
    }
    
    // Now open the IO HID Manager reference
    IOReturn tIOReturn = IOHIDManagerOpen(tIOHIDManagerRef, kIOHIDOptionsTypeNone);
    require_noerr(tIOReturn, Oops);
    
    // and copy out its devices
    CFSetRef deviceCFSetRef = IOHIDManagerCopyDevices(tIOHIDManagerRef);
    require(deviceCFSetRef, Oops);
    
    // how many devices in the set?
    CFIndex deviceIndex, deviceCount = CFSetGetCount(deviceCFSetRef);
    printf("found %ld devices\n", deviceCount);
    
    // allocate a block of memory to extact the device ref's from the set into
    tIOHIDDeviceRefs = malloc(sizeof(IOHIDDeviceRef) * deviceCount);
    if (!tIOHIDDeviceRefs) {
        CFRelease(deviceCFSetRef);
        deviceCFSetRef = NULL;
        goto Oops;
    }
    
    // now extract the device ref's from the set
    CFSetGetValues(deviceCFSetRef, (const void **) tIOHIDDeviceRefs);
    CFRelease(deviceCFSetRef);
    deviceCFSetRef = NULL;
    
    // before we get into the device loop we'll setup our element matching dictionary
    matchingCFDictRef = hu_CreateMatchingDictionaryUsagePageUsage(FALSE, kHIDPage_LEDs, 0);
    require(matchingCFDictRef, Oops);
    
    
    
    int pass;    // do 256 passes
    int start = 0;
    int end = 256;
    bool fromFile = false;
    char buffer[256];
    
    
    
    FILE *fp = fopen(config_path, "r");
    if (fp) {
        char *line = NULL;
        size_t len;
        ssize_t read = getline(&line, &len, fp);
        if (read) {
            fromFile = true;
            int goodpass = atoi(line);
            start = goodpass;
            end = goodpass + 1;
            printf("Using config at path: %s\n", config_path);
        }
        fclose(fp);
    } else {
        printf("%s not found. Cycling through possible values.\n", config_path);
    }
    
    
    for (pass = start; pass < end; pass++) {
        Boolean delayFlag = FALSE;    // if we find an LED element we'll set this to TRUE
        
        printf("pass = %d.\n", pass);
        for (deviceIndex = 0; deviceIndex < deviceCount; deviceIndex++) {
            
            // if this isn't a keyboard device...
            if (!IOHIDDeviceConformsTo(tIOHIDDeviceRefs[deviceIndex], kHIDPage_GenericDesktop, kHIDUsage_GD_Keyboard)) {
                continue;    // ...skip it
            }
            
            //            printf("	 device = %p.\n", tIOHIDDeviceRefs[deviceIndex]);
            
            // copy all the elements
            CFArrayRef elementCFArrayRef = IOHIDDeviceCopyMatchingElements(tIOHIDDeviceRefs[deviceIndex],
                                                                           matchingCFDictRef,
                                                                           kIOHIDOptionsTypeNone);
            if (!elementCFArrayRef) {
                continue;
            }
            
            // for each device on the system these values are divided by the value ranges of all LED elements found
            // for example, if the first four LED element have a range of 0-1 then the four least significant bits of
            // this value will be sent to these first four LED elements, etc.
            int device_value = pass;
            
            // iterate over all the elements
            CFIndex elementIndex, elementCount = CFArrayGetCount(elementCFArrayRef);
            if (elementCount == 3) { // because the mac internal keyboard has 5 and the CM Storm has 3
                for (elementIndex = 0; elementIndex < elementCount; elementIndex++) {
                    IOHIDElementRef tIOHIDElementRef = (IOHIDElementRef) CFArrayGetValueAtIndex(elementCFArrayRef, elementIndex);
                    if (!tIOHIDElementRef) {
                        continue;
                    }
                    
                    uint32_t usagePage = IOHIDElementGetUsagePage(tIOHIDElementRef);
                    
                    // if this isn't an LED element...
                    if (kHIDPage_LEDs != usagePage) {
                        continue;    // ...skip it
                    }
                    
                    //                    uint32_t usage = IOHIDElementGetUsage(tIOHIDElementRef);
                    //                    IOHIDElementType tIOHIDElementType = IOHIDElementGetType(tIOHIDElementRef);
                    
                    //                    printf("		 element = %p (page: %d, usage: %d, type: %d ).\n",
                    //                           tIOHIDElementRef, usagePage, usage, tIOHIDElementType);
                    
                    // get the logical mix/max for this LED element
                    CFIndex minCFIndex = IOHIDElementGetLogicalMin(tIOHIDElementRef);
                    CFIndex maxCFIndex = IOHIDElementGetLogicalMax(tIOHIDElementRef);
                    
                    // calculate the range
                    CFIndex modCFIndex = maxCFIndex - minCFIndex + 1;
                    
                    // compute the value for this LED element
                    CFIndex tCFIndex = minCFIndex + (device_value % modCFIndex);
                    device_value /= modCFIndex;
                    
                    //                    printf("			 value = 0x%08lX.\n", tCFIndex);
                    
                    uint64_t timestamp = 0; // create the IO HID Value to be sent to this LED element
                    IOHIDValueRef tIOHIDValueRef = IOHIDValueCreateWithIntegerValue(kCFAllocatorDefault, tIOHIDElementRef, timestamp, tCFIndex);
                    if (tIOHIDValueRef) {
                        // now set it on the device
                        tIOReturn = IOHIDDeviceSetValue(tIOHIDDeviceRefs[deviceIndex], tIOHIDElementRef, tIOHIDValueRef);
                        CFRelease(tIOHIDValueRef);
                        require_noerr(tIOReturn, next_element);
                        delayFlag = TRUE;    // set this TRUE so we'll delay before changing our LED values agai
                        
                    }
                next_element:;
                    continue;
                }
            }
            CFRelease(elementCFArrayRef);
            continue;
        }
        
        if (!fromFile){
            printf("is this value good? (y/n)\n");
            fgets(buffer, sizeof(buffer), stdin);
            //            printf("buffer=`%s`\n", buffer);
            if (buffer[0] == 'y') {
                printf("saving configuration\n");
                fp = fopen(config_path, "w");
                fprintf(fp, "%d\n", pass);
                fclose(fp);
                break;
            }
        }
        
        // if we found an LED we'll delay before continuing
        //        if (delayFlag) {
        //            usleep(500000); // sleep one half second
        //        }
        
        // if the mouse is down…
        if (GetCurrentButtonState()) {
            break;    // abort pass loop
        }
    }                          // next pass
    
    if (matchingCFDictRef) {
        CFRelease(matchingCFDictRef);
    }
Oops:;
    if (tIOHIDDeviceRefs) {
        free(tIOHIDDeviceRefs);
    }
    
    if (tIOHIDManagerRef) {
        CFRelease(tIOHIDManagerRef);
    }
    return 0;
} /* main */