From e88fafcacd2318ad74a2021158551c03cea88847 Mon Sep 17 00:00:00 2001 From: Adam Honse Date: Sun, 14 Nov 2021 00:26:02 -0600 Subject: [PATCH] Rename AsusAuraSMBusController to ENESMBusController --- .../AsusAuraSMBusController.cpp | 295 --------------- .../AsusAuraSMBusController.h | 114 ------ .../ENESMBusController/ENESMBusController.cpp | 298 +++++++++++++++ .../ENESMBusController/ENESMBusController.h | 117 ++++++ .../ENESMBusControllerDetect.cpp} | 135 +++---- .../RGBController_ENESMBus.cpp} | 343 +++++++++--------- .../RGBController_ENESMBus.h} | 15 +- OpenRGB.pro | 12 +- 8 files changed, 679 insertions(+), 650 deletions(-) delete mode 100644 Controllers/AsusAuraSMBusController/AsusAuraSMBusController.cpp delete mode 100644 Controllers/AsusAuraSMBusController/AsusAuraSMBusController.h create mode 100644 Controllers/ENESMBusController/ENESMBusController.cpp create mode 100644 Controllers/ENESMBusController/ENESMBusController.h rename Controllers/{AsusAuraSMBusController/AsusAuraSMBusControllerDetect.cpp => ENESMBusController/ENESMBusControllerDetect.cpp} (54%) rename Controllers/{AsusAuraSMBusController/RGBController_AsusAuraSMBus.cpp => ENESMBusController/RGBController_ENESMBus.cpp} (61%) rename Controllers/{AsusAuraSMBusController/RGBController_AsusAuraSMBus.h => ENESMBusController/RGBController_ENESMBus.h} (63%) diff --git a/Controllers/AsusAuraSMBusController/AsusAuraSMBusController.cpp b/Controllers/AsusAuraSMBusController/AsusAuraSMBusController.cpp deleted file mode 100644 index 1b6ef979f..000000000 --- a/Controllers/AsusAuraSMBusController/AsusAuraSMBusController.cpp +++ /dev/null @@ -1,295 +0,0 @@ -/*-----------------------------------------*\ -| AsusAuraSMBusController.cpp | -| | -| Driver for ASUS Aura RGB lighting | -| controller | -| | -| Adam Honse (CalcProgrammer1) 8/19/2018 | -\*-----------------------------------------*/ - -#include "AsusAuraSMBusController.h" -#include - -static const char* aura_channels[] = /* Aura channel strings */ -{ - "Audio", - "Backplate", - "Back I/O", - "Center", - "Center", - "DRAM", - "PCIe", - "RGB Header", - "RGB Header 2", - "RGB Header", - "Unknown", -}; - -AuraSMBusController::AuraSMBusController(i2c_smbus_interface* bus, aura_dev_id dev) -{ - this->bus = bus; - this->dev = dev; - - AuraUpdateDeviceName(); - - // Read the device configuration table - for (int i = 0; i < 64; i++) - { - config_table[i] = AuraRegisterRead(AURA_REG_CONFIG_TABLE + i); - } - - // Read LED count from configuration table - led_count = config_table[AURA_CONFIG_LED_COUNT]; - - // LED-0116 - First generation motherboard controller - if (strcmp(device_name, "LED-0116") == 0) - { - direct_reg = AURA_REG_COLORS_DIRECT; - effect_reg = AURA_REG_COLORS_EFFECT; - channel_cfg = AURA_CONFIG_CHANNEL_V1; - } - // DIMM_LED-0102 - First generation DRAM controller (Trident Z RGB) - else if (strcmp(device_name, "DIMM_LED-0102") == 0) - { - direct_reg = AURA_REG_COLORS_DIRECT; - effect_reg = AURA_REG_COLORS_EFFECT; - channel_cfg = AURA_CONFIG_CHANNEL_V1; - } - // AUDA0-E6K5-0101 - Second generation DRAM controller (Geil Super Luce) - else if (strcmp(device_name, "AUDA0-E6K5-0101") == 0) - { - direct_reg = AURA_REG_COLORS_DIRECT_V2; - effect_reg = AURA_REG_COLORS_EFFECT_V2; - channel_cfg = AURA_CONFIG_CHANNEL_V1; - } - // AUMA0-E6K5-0106 - Second generation motherboard controller - else if (strcmp(device_name, "AUMA0-E6K5-0106") == 0) - { - direct_reg = AURA_REG_COLORS_DIRECT_V2; - effect_reg = AURA_REG_COLORS_EFFECT_V2; - channel_cfg = AURA_CONFIG_CHANNEL_V2; - } - // AUMA0-E6K5-0105 - Second generation motherboard controller - else if (strcmp(device_name, "AUMA0-E6K5-0105") == 0) - { - direct_reg = AURA_REG_COLORS_DIRECT_V2; - effect_reg = AURA_REG_COLORS_EFFECT_V2; - channel_cfg = AURA_CONFIG_CHANNEL_V2; - } - // AUMA0-E6K5-0104 - Second generation motherboard controller - else if (strcmp(device_name, "AUMA0-E6K5-0104") == 0) - { - direct_reg = AURA_REG_COLORS_DIRECT_V2; - effect_reg = AURA_REG_COLORS_EFFECT_V2; - channel_cfg = AURA_CONFIG_CHANNEL_V2; - } - // AUMA0-E8K4-0101 - First generation motherboard controller - else if (strcmp(device_name, "AUMA0-E8K4-0101") == 0) - { - direct_reg = AURA_REG_COLORS_DIRECT; - effect_reg = AURA_REG_COLORS_EFFECT; - channel_cfg = AURA_CONFIG_CHANNEL_V1; - } - // Assume first generation controller if string does not match - else - { - direct_reg = AURA_REG_COLORS_DIRECT; - effect_reg = AURA_REG_COLORS_EFFECT; - channel_cfg = AURA_CONFIG_CHANNEL_V1; - } -} - -AuraSMBusController::~AuraSMBusController() -{ - -} - -std::string AuraSMBusController::GetDeviceName() -{ - return(device_name); -} - -std::string AuraSMBusController::GetDeviceLocation() -{ - std::string return_string(bus->device_name); - char addr[5]; - snprintf(addr, 5, "0x%02X", dev); - return_string.append(", address "); - return_string.append(addr); - return("I2C: " + return_string); -} - -unsigned char AuraSMBusController::GetChannel(unsigned int led) -{ - return(config_table[channel_cfg + led]); -} - -const char * AuraSMBusController::GetChannelName(unsigned int led) -{ - switch (config_table[channel_cfg + led]) - { - case (unsigned char)AURA_LED_CHANNEL_AUDIO: - return(aura_channels[0]); - break; - - case (unsigned char)AURA_LED_CHANNEL_BACKPLATE: - return(aura_channels[1]); - break; - - case (unsigned char)AURA_LED_CHANNEL_BACK_IO: - return(aura_channels[2]); - break; - - case (unsigned char)AURA_LED_CHANNEL_CENTER: - return(aura_channels[3]); - break; - - case (unsigned char)AURA_LED_CHANNEL_CENTER_START: - return(aura_channels[4]); - break; - - case (unsigned char)AURA_LED_CHANNEL_DRAM: - return(aura_channels[5]); - break; - - case (unsigned char)AURA_LED_CHANNEL_PCIE: - return(aura_channels[6]); - break; - - case (unsigned char)AURA_LED_CHANNEL_RGB_HEADER: - return(aura_channels[7]); - break; - - case (unsigned char)AURA_LED_CHANNEL_RGB_HEADER_2: - return(aura_channels[8]); - break; - - case (unsigned char)AURA_LED_CHANNEL_RGB_HEADER_3: - return(aura_channels[9]); - break; - - default: - return(aura_channels[10]); - break; - } -} - -unsigned int AuraSMBusController::GetLEDCount() -{ - return(led_count); -} - -unsigned char AuraSMBusController::GetLEDRed(unsigned int led) -{ - return(AuraRegisterRead(direct_reg + ( 3 * led ))); -} - -unsigned char AuraSMBusController::GetLEDGreen(unsigned int led) -{ - return(AuraRegisterRead(direct_reg + ( 3 * led ) + 2)); -} - -unsigned char AuraSMBusController::GetLEDBlue(unsigned int led) -{ - return(AuraRegisterRead(direct_reg + ( 3 * led ) + 1)); -} - -void AuraSMBusController::SetAllColorsDirect(unsigned char red, unsigned char green, unsigned char blue) -{ - unsigned char* colors = new unsigned char[led_count * 3]; - - for (unsigned int i = 0; i < (led_count * 3); i += 3) - { - colors[i + 0] = red; - colors[i + 1] = blue; - colors[i + 2] = green; - } - - AuraRegisterWriteBlock(direct_reg, colors, led_count * 3); - - delete[] colors; -} - -void AuraSMBusController::SetAllColorsEffect(unsigned char red, unsigned char green, unsigned char blue) -{ - unsigned char* colors = new unsigned char[led_count * 3]; - - for (unsigned int i = 0; i < (led_count * 3); i += 3) - { - colors[i + 0] = red; - colors[i + 1] = blue; - colors[i + 2] = green; - } - - AuraRegisterWriteBlock(effect_reg, colors, led_count * 3); - - AuraRegisterWrite(AURA_REG_APPLY, AURA_APPLY_VAL); - - delete[] colors; -} - -void AuraSMBusController::SetDirect(unsigned char direct) -{ - AuraRegisterWrite(AURA_REG_DIRECT, direct); - AuraRegisterWrite(AURA_REG_APPLY, AURA_APPLY_VAL); -} - -void AuraSMBusController::SetLEDColorDirect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue) -{ - unsigned char colors[3] = { red, blue, green }; - - AuraRegisterWriteBlock(direct_reg + ( 3 * led ), colors, 3); -} - -void AuraSMBusController::SetLEDColorEffect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue) -{ - unsigned char colors[3] = { red, blue, green }; - - AuraRegisterWriteBlock(effect_reg + (3 * led), colors, 3); - - AuraRegisterWrite(AURA_REG_APPLY, AURA_APPLY_VAL); -} - -void AuraSMBusController::SetMode(unsigned char mode) -{ - AuraRegisterWrite(AURA_REG_MODE, mode); - AuraRegisterWrite(AURA_REG_APPLY, AURA_APPLY_VAL); -} - -void AuraSMBusController::AuraUpdateDeviceName() -{ - for (int i = 0; i < 16; i++) - { - device_name[i] = AuraRegisterRead(AURA_REG_DEVICE_NAME + i); - } -} - -unsigned char AuraSMBusController::AuraRegisterRead(aura_register reg) -{ - //Write Aura register - bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF)); - - //Read Aura value - return(bus->i2c_smbus_read_byte_data(dev, 0x81)); - -} - -void AuraSMBusController::AuraRegisterWrite(aura_register reg, unsigned char val) -{ - //Write Aura register - bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF)); - - //Write Aura value - bus->i2c_smbus_write_byte_data(dev, 0x01, val); - -} - -void AuraSMBusController::AuraRegisterWriteBlock(aura_register reg, unsigned char * data, unsigned char sz) -{ - //Write Aura register - bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF)); - - //Write Aura block data - bus->i2c_smbus_write_block_data(dev, 0x03, sz, data); - -} diff --git a/Controllers/AsusAuraSMBusController/AsusAuraSMBusController.h b/Controllers/AsusAuraSMBusController/AsusAuraSMBusController.h deleted file mode 100644 index fb0d1ffdb..000000000 --- a/Controllers/AsusAuraSMBusController/AsusAuraSMBusController.h +++ /dev/null @@ -1,114 +0,0 @@ -/*-----------------------------------------*\ -| AsusAuraSMBusController.h | -| | -| Definitions and types for ASUS Aura RGB | -| lighting controller | -| | -| Adam Honse (CalcProgrammer1) 8/19/2018 | -\*-----------------------------------------*/ - -#include -#include "i2c_smbus.h" - -#pragma once - -typedef unsigned char aura_dev_id; -typedef unsigned short aura_register; - -#define AURA_APPLY_VAL 0x01 /* Value for Apply Changes Register */ - -enum -{ - AURA_REG_DEVICE_NAME = 0x1000, /* Device String 16 bytes */ - AURA_REG_MICRON_CHECK = 0x1030, /* If "Micron" appears here, skip */ - AURA_REG_CONFIG_TABLE = 0x1C00, /* Start of LED configuration bytes */ - AURA_REG_COLORS_DIRECT = 0x8000, /* Colors for Direct Mode 15 bytes */ - AURA_REG_COLORS_EFFECT = 0x8010, /* Colors for Internal Effects 15 bytes */ - AURA_REG_DIRECT = 0x8020, /* "Direct Access" Selection Register */ - AURA_REG_MODE = 0x8021, /* AURA Mode Selection Register */ - AURA_REG_APPLY = 0x80A0, /* AURA Apply Changes Register */ - AURA_REG_SLOT_INDEX = 0x80F8, /* AURA Slot Index Register (RAM only) */ - AURA_REG_I2C_ADDRESS = 0x80F9, /* AURA I2C Address Register (RAM only) */ - AURA_REG_COLORS_DIRECT_V2 = 0x8100, /* Direct Colors (v2) 30 bytes */ - AURA_REG_COLORS_EFFECT_V2 = 0x8160, /* Internal Colors (v2) 30 bytes */ -}; - -enum -{ - AURA_MODE_OFF = 0, /* OFF mode */ - AURA_MODE_STATIC = 1, /* Static color mode */ - AURA_MODE_BREATHING = 2, /* Breathing effect mode */ - AURA_MODE_FLASHING = 3, /* Flashing effect mode */ - AURA_MODE_SPECTRUM_CYCLE = 4, /* Spectrum Cycle mode */ - AURA_MODE_RAINBOW = 5, /* Rainbow effect mode */ - AURA_MODE_SPECTRUM_CYCLE_BREATHING = 6, /* Rainbow Breathing effect mode */ - AURA_MODE_CHASE_FADE = 7, /* Chase with Fade effect mode */ - AURA_MODE_SPECTRUM_CYCLE_CHASE_FADE = 8, /* Chase with Fade, Rainbow effect mode */ - AURA_MODE_CHASE = 9, /* Chase effect mode */ - AURA_MODE_SPECTRUM_CYCLE_CHASE = 10, /* Chase with Rainbow effect mode */ - AURA_MODE_SPECTRUM_CYCLE_WAVE = 11, /* Wave effect mode */ - AURA_MODE_CHASE_RAINBOW_PULSE = 12, /* Chase with Rainbow Pulse effect mode*/ - AURA_MODE_RANDOM_FLICKER = 13, /* Random flicker effect mode */ - AURA_NUMBER_MODES /* Number of Aura modes */ -}; - -enum -{ - AURA_LED_CHANNEL_DRAM_2 = 0x05, /* DRAM LED channel */ - AURA_LED_CHANNEL_CENTER_START = 0x82, /* Center zone first LED channel */ - AURA_LED_CHANNEL_CENTER = 0x83, /* Center zone LED channel */ - AURA_LED_CHANNEL_AUDIO = 0x84, /* Audio zone LED channel */ - AURA_LED_CHANNEL_BACK_IO = 0x85, /* Back I/O zone LED channel */ - AURA_LED_CHANNEL_RGB_HEADER = 0x86, /* RGB Header LED channel */ - AURA_LED_CHANNEL_RGB_HEADER_2 = 0x87, /* RGB Header 2 LED channel */ - AURA_LED_CHANNEL_BACKPLATE = 0x88, /* Backplate zone LED channel */ - AURA_LED_CHANNEL_DRAM = 0x8A, /* DRAM LED channel */ - AURA_LED_CHANNEL_PCIE = 0x8B, /* PCIe zone LED channel */ - AURA_LED_CHANNEL_RGB_HEADER_3 = 0x91, /* RGB Header 3 LED channel */ -}; - -enum -{ - AURA_CONFIG_LED_COUNT = 0x02, /* LED Count configuration offset */ - AURA_CONFIG_CHANNEL_V1 = 0x13, /* LED Channel configuration offset */ - AURA_CONFIG_CHANNEL_V2 = 0x1B, /* LED Channel V2 configuration offset */ -}; - -class AuraSMBusController -{ -public: - AuraSMBusController(i2c_smbus_interface* bus, aura_dev_id dev); - ~AuraSMBusController(); - - std::string GetDeviceName(); - std::string GetDeviceLocation(); - unsigned char GetChannel(unsigned int led); - const char* GetChannelName(unsigned int led); - unsigned int GetLEDCount(); - unsigned char GetLEDRed(unsigned int led); - unsigned char GetLEDGreen(unsigned int led); - unsigned char GetLEDBlue(unsigned int led); - void SetAllColorsDirect(unsigned char red, unsigned char green, unsigned char blue); - void SetAllColorsEffect(unsigned char red, unsigned char green, unsigned char blue); - void SetDirect(unsigned char direct); - void SetLEDColorDirect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue); - void SetLEDColorEffect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue); - void SetMode(unsigned char mode); - - void AuraUpdateDeviceName(); - - unsigned char AuraRegisterRead(aura_register reg); - void AuraRegisterWrite(aura_register reg, unsigned char val); - void AuraRegisterWriteBlock(aura_register reg, unsigned char * data, unsigned char sz); - -private: - char device_name[16]; - unsigned char config_table[64]; - unsigned int led_count; - aura_register direct_reg; - aura_register effect_reg; - unsigned char channel_cfg; - i2c_smbus_interface * bus; - aura_dev_id dev; - -}; diff --git a/Controllers/ENESMBusController/ENESMBusController.cpp b/Controllers/ENESMBusController/ENESMBusController.cpp new file mode 100644 index 000000000..7ed96b269 --- /dev/null +++ b/Controllers/ENESMBusController/ENESMBusController.cpp @@ -0,0 +1,298 @@ +/*-----------------------------------------*\ +| ENESMBusController.cpp | +| | +| Driver for ENE SMBus RGB lighting | +| controller | +| | +| Formerly known as ASUS Aura SMBus. ASUS | +| AURA chips are rebranded ENE controllers | +| | +| Adam Honse (CalcProgrammer1) 8/19/2018 | +\*-----------------------------------------*/ + +#include "ENESMBusController.h" +#include + +static const char* ene_channels[] = /* ENE channel strings */ +{ + "Audio", + "Backplate", + "Back I/O", + "Center", + "Center", + "DRAM", + "PCIe", + "RGB Header", + "RGB Header 2", + "RGB Header", + "Unknown", +}; + +ENESMBusController::ENESMBusController(i2c_smbus_interface* bus, ene_dev_id dev) +{ + this->bus = bus; + this->dev = dev; + + UpdateDeviceName(); + + // Read the device configuration table + for (int i = 0; i < 64; i++) + { + config_table[i] = ENERegisterRead(ENE_REG_CONFIG_TABLE + i); + } + + // Read LED count from configuration table + led_count = config_table[ENE_CONFIG_LED_COUNT]; + + // LED-0116 - First generation motherboard controller + if (strcmp(device_name, "LED-0116") == 0) + { + direct_reg = ENE_REG_COLORS_DIRECT; + effect_reg = ENE_REG_COLORS_EFFECT; + channel_cfg = ENE_CONFIG_CHANNEL_V1; + } + // DIMM_LED-0102 - First generation DRAM controller (Trident Z RGB) + else if (strcmp(device_name, "DIMM_LED-0102") == 0) + { + direct_reg = ENE_REG_COLORS_DIRECT; + effect_reg = ENE_REG_COLORS_EFFECT; + channel_cfg = ENE_CONFIG_CHANNEL_V1; + } + // AUDA0-E6K5-0101 - Second generation DRAM controller (Geil Super Luce) + else if (strcmp(device_name, "AUDA0-E6K5-0101") == 0) + { + direct_reg = ENE_REG_COLORS_DIRECT_V2; + effect_reg = ENE_REG_COLORS_EFFECT_V2; + channel_cfg = ENE_CONFIG_CHANNEL_V1; + } + // AUMA0-E6K5-0106 - Second generation motherboard controller + else if (strcmp(device_name, "AUMA0-E6K5-0106") == 0) + { + direct_reg = ENE_REG_COLORS_DIRECT_V2; + effect_reg = ENE_REG_COLORS_EFFECT_V2; + channel_cfg = ENE_CONFIG_CHANNEL_V2; + } + // AUMA0-E6K5-0105 - Second generation motherboard controller + else if (strcmp(device_name, "AUMA0-E6K5-0105") == 0) + { + direct_reg = ENE_REG_COLORS_DIRECT_V2; + effect_reg = ENE_REG_COLORS_EFFECT_V2; + channel_cfg = ENE_CONFIG_CHANNEL_V2; + } + // AUMA0-E6K5-0104 - Second generation motherboard controller + else if (strcmp(device_name, "AUMA0-E6K5-0104") == 0) + { + direct_reg = ENE_REG_COLORS_DIRECT_V2; + effect_reg = ENE_REG_COLORS_EFFECT_V2; + channel_cfg = ENE_CONFIG_CHANNEL_V2; + } + // AUMA0-E8K4-0101 - First generation motherboard controller + else if (strcmp(device_name, "AUMA0-E8K4-0101") == 0) + { + direct_reg = ENE_REG_COLORS_DIRECT; + effect_reg = ENE_REG_COLORS_EFFECT; + channel_cfg = ENE_CONFIG_CHANNEL_V1; + } + // Assume first generation controller if string does not match + else + { + direct_reg = ENE_REG_COLORS_DIRECT; + effect_reg = ENE_REG_COLORS_EFFECT; + channel_cfg = ENE_CONFIG_CHANNEL_V1; + } +} + +ENESMBusController::~ENESMBusController() +{ + +} + +std::string ENESMBusController::GetDeviceName() +{ + return(device_name); +} + +std::string ENESMBusController::GetDeviceLocation() +{ + std::string return_string(bus->device_name); + char addr[5]; + snprintf(addr, 5, "0x%02X", dev); + return_string.append(", address "); + return_string.append(addr); + return("I2C: " + return_string); +} + +unsigned char ENESMBusController::GetChannel(unsigned int led) +{ + return(config_table[channel_cfg + led]); +} + +const char * ENESMBusController::GetChannelName(unsigned int led) +{ + switch (config_table[channel_cfg + led]) + { + case (unsigned char)ENE_LED_CHANNEL_AUDIO: + return(ene_channels[0]); + break; + + case (unsigned char)ENE_LED_CHANNEL_BACKPLATE: + return(ene_channels[1]); + break; + + case (unsigned char)ENE_LED_CHANNEL_BACK_IO: + return(ene_channels[2]); + break; + + case (unsigned char)ENE_LED_CHANNEL_CENTER: + return(ene_channels[3]); + break; + + case (unsigned char)ENE_LED_CHANNEL_CENTER_START: + return(ene_channels[4]); + break; + + case (unsigned char)ENE_LED_CHANNEL_DRAM: + return(ene_channels[5]); + break; + + case (unsigned char)ENE_LED_CHANNEL_PCIE: + return(ene_channels[6]); + break; + + case (unsigned char)ENE_LED_CHANNEL_RGB_HEADER: + return(ene_channels[7]); + break; + + case (unsigned char)ENE_LED_CHANNEL_RGB_HEADER_2: + return(ene_channels[8]); + break; + + case (unsigned char)ENE_LED_CHANNEL_RGB_HEADER_3: + return(ene_channels[9]); + break; + + default: + return(ene_channels[10]); + break; + } +} + +unsigned int ENESMBusController::GetLEDCount() +{ + return(led_count); +} + +unsigned char ENESMBusController::GetLEDRed(unsigned int led) +{ + return(ENERegisterRead(direct_reg + ( 3 * led ))); +} + +unsigned char ENESMBusController::GetLEDGreen(unsigned int led) +{ + return(ENERegisterRead(direct_reg + ( 3 * led ) + 2)); +} + +unsigned char ENESMBusController::GetLEDBlue(unsigned int led) +{ + return(ENERegisterRead(direct_reg + ( 3 * led ) + 1)); +} + +void ENESMBusController::SetAllColorsDirect(unsigned char red, unsigned char green, unsigned char blue) +{ + unsigned char* colors = new unsigned char[led_count * 3]; + + for (unsigned int i = 0; i < (led_count * 3); i += 3) + { + colors[i + 0] = red; + colors[i + 1] = blue; + colors[i + 2] = green; + } + + ENERegisterWriteBlock(direct_reg, colors, led_count * 3); + + delete[] colors; +} + +void ENESMBusController::SetAllColorsEffect(unsigned char red, unsigned char green, unsigned char blue) +{ + unsigned char* colors = new unsigned char[led_count * 3]; + + for (unsigned int i = 0; i < (led_count * 3); i += 3) + { + colors[i + 0] = red; + colors[i + 1] = blue; + colors[i + 2] = green; + } + + ENERegisterWriteBlock(effect_reg, colors, led_count * 3); + + ENERegisterWrite(ENE_REG_APPLY, ENE_APPLY_VAL); + + delete[] colors; +} + +void ENESMBusController::SetDirect(unsigned char direct) +{ + ENERegisterWrite(ENE_REG_DIRECT, direct); + ENERegisterWrite(ENE_REG_APPLY, ENE_APPLY_VAL); +} + +void ENESMBusController::SetLEDColorDirect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue) +{ + unsigned char colors[3] = { red, blue, green }; + + ENERegisterWriteBlock(direct_reg + ( 3 * led ), colors, 3); +} + +void ENESMBusController::SetLEDColorEffect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue) +{ + unsigned char colors[3] = { red, blue, green }; + + ENERegisterWriteBlock(effect_reg + (3 * led), colors, 3); + + ENERegisterWrite(ENE_REG_APPLY, ENE_APPLY_VAL); +} + +void ENESMBusController::SetMode(unsigned char mode) +{ + ENERegisterWrite(ENE_REG_MODE, mode); + ENERegisterWrite(ENE_REG_APPLY, ENE_APPLY_VAL); +} + +void ENESMBusController::UpdateDeviceName() +{ + for (int i = 0; i < 16; i++) + { + device_name[i] = ENERegisterRead(ENE_REG_DEVICE_NAME + i); + } +} + +unsigned char ENESMBusController::ENERegisterRead(ene_register reg) +{ + //Write ENE register + bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF)); + + //Read ENE value + return(bus->i2c_smbus_read_byte_data(dev, 0x81)); + +} + +void ENESMBusController::ENERegisterWrite(ene_register reg, unsigned char val) +{ + //Write ENE register + bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF)); + + //Write ENE value + bus->i2c_smbus_write_byte_data(dev, 0x01, val); + +} + +void ENESMBusController::ENERegisterWriteBlock(ene_register reg, unsigned char * data, unsigned char sz) +{ + //Write ENE register + bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF)); + + //Write ENE block data + bus->i2c_smbus_write_block_data(dev, 0x03, sz, data); + +} diff --git a/Controllers/ENESMBusController/ENESMBusController.h b/Controllers/ENESMBusController/ENESMBusController.h new file mode 100644 index 000000000..62b5ecb07 --- /dev/null +++ b/Controllers/ENESMBusController/ENESMBusController.h @@ -0,0 +1,117 @@ +/*-----------------------------------------*\ +| ENESMBusController.h | +| | +| Definitions and types for ENE SMBus RGB | +| lighting controller | +| | +| Formerly known as ASUS Aura SMBus. ASUS | +| AURA chips are rebranded ENE controllers | +| | +| Adam Honse (CalcProgrammer1) 8/19/2018 | +\*-----------------------------------------*/ + +#include +#include "i2c_smbus.h" + +#pragma once + +typedef unsigned char ene_dev_id; +typedef unsigned short ene_register; + +#define ENE_APPLY_VAL 0x01 /* Value for Apply Changes Register */ + +enum +{ + ENE_REG_DEVICE_NAME = 0x1000, /* Device String 16 bytes */ + ENE_REG_MICRON_CHECK = 0x1030, /* If "Micron" appears here, skip */ + ENE_REG_CONFIG_TABLE = 0x1C00, /* Start of LED configuration bytes */ + ENE_REG_COLORS_DIRECT = 0x8000, /* Colors for Direct Mode 15 bytes */ + ENE_REG_COLORS_EFFECT = 0x8010, /* Colors for Internal Effects 15 bytes */ + ENE_REG_DIRECT = 0x8020, /* "Direct Access" Selection Register */ + ENE_REG_MODE = 0x8021, /* AURA Mode Selection Register */ + ENE_REG_APPLY = 0x80A0, /* AURA Apply Changes Register */ + ENE_REG_SLOT_INDEX = 0x80F8, /* AURA Slot Index Register (RAM only) */ + ENE_REG_I2C_ADDRESS = 0x80F9, /* AURA I2C Address Register (RAM only) */ + ENE_REG_COLORS_DIRECT_V2 = 0x8100, /* Direct Colors (v2) 30 bytes */ + ENE_REG_COLORS_EFFECT_V2 = 0x8160, /* Internal Colors (v2) 30 bytes */ +}; + +enum +{ + ENE_MODE_OFF = 0, /* OFF mode */ + ENE_MODE_STATIC = 1, /* Static color mode */ + ENE_MODE_BREATHING = 2, /* Breathing effect mode */ + ENE_MODE_FLASHING = 3, /* Flashing effect mode */ + ENE_MODE_SPECTRUM_CYCLE = 4, /* Spectrum Cycle mode */ + ENE_MODE_RAINBOW = 5, /* Rainbow effect mode */ + ENE_MODE_SPECTRUM_CYCLE_BREATHING = 6, /* Rainbow Breathing effect mode */ + ENE_MODE_CHASE_FADE = 7, /* Chase with Fade effect mode */ + ENE_MODE_SPECTRUM_CYCLE_CHASE_FADE = 8, /* Chase with Fade, Rainbow effect mode */ + ENE_MODE_CHASE = 9, /* Chase effect mode */ + ENE_MODE_SPECTRUM_CYCLE_CHASE = 10, /* Chase with Rainbow effect mode */ + ENE_MODE_SPECTRUM_CYCLE_WAVE = 11, /* Wave effect mode */ + ENE_MODE_CHASE_RAINBOW_PULSE = 12, /* Chase with Rainbow Pulse effect mode*/ + ENE_MODE_RANDOM_FLICKER = 13, /* Random flicker effect mode */ + ENE_NUMBER_MODES /* Number of Aura modes */ +}; + +enum +{ + ENE_LED_CHANNEL_DRAM_2 = 0x05, /* DRAM LED channel */ + ENE_LED_CHANNEL_CENTER_START = 0x82, /* Center zone first LED channel */ + ENE_LED_CHANNEL_CENTER = 0x83, /* Center zone LED channel */ + ENE_LED_CHANNEL_AUDIO = 0x84, /* Audio zone LED channel */ + ENE_LED_CHANNEL_BACK_IO = 0x85, /* Back I/O zone LED channel */ + ENE_LED_CHANNEL_RGB_HEADER = 0x86, /* RGB Header LED channel */ + ENE_LED_CHANNEL_RGB_HEADER_2 = 0x87, /* RGB Header 2 LED channel */ + ENE_LED_CHANNEL_BACKPLATE = 0x88, /* Backplate zone LED channel */ + ENE_LED_CHANNEL_DRAM = 0x8A, /* DRAM LED channel */ + ENE_LED_CHANNEL_PCIE = 0x8B, /* PCIe zone LED channel */ + ENE_LED_CHANNEL_RGB_HEADER_3 = 0x91, /* RGB Header 3 LED channel */ +}; + +enum +{ + ENE_CONFIG_LED_COUNT = 0x02, /* LED Count configuration offset */ + ENE_CONFIG_CHANNEL_V1 = 0x13, /* LED Channel configuration offset */ + ENE_CONFIG_CHANNEL_V2 = 0x1B, /* LED Channel V2 configuration offset */ +}; + +class ENESMBusController +{ +public: + ENESMBusController(i2c_smbus_interface* bus, ene_dev_id dev); + ~ENESMBusController(); + + std::string GetDeviceName(); + std::string GetDeviceLocation(); + unsigned char GetChannel(unsigned int led); + const char* GetChannelName(unsigned int led); + unsigned int GetLEDCount(); + unsigned char GetLEDRed(unsigned int led); + unsigned char GetLEDGreen(unsigned int led); + unsigned char GetLEDBlue(unsigned int led); + void SetAllColorsDirect(unsigned char red, unsigned char green, unsigned char blue); + void SetAllColorsEffect(unsigned char red, unsigned char green, unsigned char blue); + void SetDirect(unsigned char direct); + void SetLEDColorDirect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue); + void SetLEDColorEffect(unsigned int led, unsigned char red, unsigned char green, unsigned char blue); + void SetMode(unsigned char mode); + + void UpdateDeviceName(); + + unsigned char ENERegisterRead(ene_register reg); + void ENERegisterWrite(ene_register reg, unsigned char val); + void ENERegisterWriteBlock(ene_register reg, unsigned char * data, unsigned char sz); + +private: + char device_name[16]; + unsigned char config_table[64]; + unsigned int led_count; + ene_register direct_reg; + ene_register effect_reg; + unsigned char channel_cfg; + i2c_smbus_interface * bus; + ene_dev_id dev; + +}; diff --git a/Controllers/AsusAuraSMBusController/AsusAuraSMBusControllerDetect.cpp b/Controllers/ENESMBusController/ENESMBusControllerDetect.cpp similarity index 54% rename from Controllers/AsusAuraSMBusController/AsusAuraSMBusControllerDetect.cpp rename to Controllers/ENESMBusController/ENESMBusControllerDetect.cpp index 3ac0b975a..269bad7a4 100644 --- a/Controllers/AsusAuraSMBusController/AsusAuraSMBusControllerDetect.cpp +++ b/Controllers/ENESMBusController/ENESMBusControllerDetect.cpp @@ -1,8 +1,8 @@ #include "Detector.h" -#include "AsusAuraSMBusController.h" +#include "ENESMBusController.h" #include "LogManager.h" #include "RGBController.h" -#include "RGBController_AsusAuraSMBus.h" +#include "RGBController_ENESMBus.h" #include "i2c_smbus.h" #include "pci_ids.h" #include @@ -10,17 +10,17 @@ #include #include "dependencies/dmiinfo.h" -#define DETECTOR_NAME "ASUS Aura SMBus Controller" -#define VENDOR_NAME "ASUS" //This should match the Vendor name from DMI +#define DETECTOR_NAME "ENE (ASUS Aura) SMBus Controller" +#define VENDOR_NAME "ASUS" //This should match the Vendor name from DMI using namespace std::chrono_literals; /*----------------------------------------------------------------------*\ -| This list contains the available SMBus addresses for mapping Aura RAM | +| This list contains the available SMBus addresses for mapping ENE RAM | \*----------------------------------------------------------------------*/ -#define AURA_RAM_ADDRESS_COUNT 23 +#define ENE_RAM_ADDRESS_COUNT 23 -static const unsigned char aura_ram_addresses[] = +static const unsigned char ene_ram_addresses[] = { 0x70, 0x71, @@ -61,57 +61,61 @@ static const unsigned char aura_mobo_addresses[] = /******************************************************************************************\ * * -* AuraRegisterRead * +* ENERegisterRead * * * -* A standalone version of the AuraSMBusController::AuraRegisterRead function for * -* access to Aura devices without instancing the AuraSMBusController class or reading * +* A standalone version of the ENESMBusController::ENERegisterRead function for * +* access to ENE devices without instancing the ENESMBusController class or reading * * the config table from the device. * * * \******************************************************************************************/ -unsigned char AuraRegisterRead(i2c_smbus_interface* bus, aura_dev_id dev, aura_register reg) +unsigned char ENERegisterRead(i2c_smbus_interface* bus, ene_dev_id dev, ene_register reg) { - //Write Aura register + //Write ENE register bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF)); - //Read Aura value + //Read ENE value return(bus->i2c_smbus_read_byte_data(dev, 0x81)); } /******************************************************************************************\ * * -* AuraRegisterWrite * +* ENERegisterWrite * * * -* A standalone version of the AuraSMBusController::AuraRegisterWrite function for * -* access to Aura devices without instancing the AuraSMBusController class or reading * +* A standalone version of the ENESMBusController::ENERegisterWrite function for * +* access to ENE devices without instancing the ENESMBusController class or reading * * the config table from the device. * * * \******************************************************************************************/ -void AsusAuraRegisterWrite(i2c_smbus_interface* bus, aura_dev_id dev, aura_register reg, unsigned char val) +void ENERegisterWrite(i2c_smbus_interface* bus, ene_dev_id dev, ene_register reg, unsigned char val) { - //Write Aura register + //Write ENE register bus->i2c_smbus_write_word_data(dev, 0x00, ((reg << 8) & 0xFF00) | ((reg >> 8) & 0x00FF)); - //Write Aura value + //Write ENE value bus->i2c_smbus_write_byte_data(dev, 0x01, val); } /******************************************************************************************\ * * -* TestForAuraSMBusController * +* TestForENESMBusController * * * -* Tests the given address to see if an Aura controller exists there. First does a * +* Tests the given address to see if an ENE controller exists there. First does a * * quick write to test for a response, and if so does a simple read at 0xA0 to test * * for incrementing values 0...F which was observed at this location during data dump * * * +* Also tests for the string "Micron" in the ENE register space. Crucial (Micron) * +* DRAM modules use an ENE controller with custom, incompatible firmware and must * +* be excluded from this controller. * +* * \******************************************************************************************/ -bool TestForAsusAuraSMBusController(i2c_smbus_interface* bus, unsigned char address) +bool TestForENESMBusController(i2c_smbus_interface* bus, unsigned char address) { bool pass = false; - LOG_DEBUG("[Aura SMBus] looking for devices at 0x%02X...", address); + LOG_DEBUG("[ENE SMBus] looking for devices at 0x%02X...", address); int res = bus->i2c_smbus_write_quick(address, I2C_SMBUS_WRITE); @@ -119,7 +123,7 @@ bool TestForAsusAuraSMBusController(i2c_smbus_interface* bus, unsigned char addr { pass = true; - LOG_DEBUG("[Aura SMBus] Detected an I2C device at address %02X, testing register range", address); + LOG_DEBUG("[ENE SMBus] Detected an I2C device at address %02X, testing register range", address); for (int i = 0xA0; i < 0xB0; i++) { @@ -127,7 +131,7 @@ bool TestForAsusAuraSMBusController(i2c_smbus_interface* bus, unsigned char addr if (res != (i - 0xA0)) { - LOG_VERBOSE("[Aura SMBus] Detection failed testing register %02X. Expected %02X, got %02X.", i, (i - 0xA0), res); + LOG_VERBOSE("[ENE SMBus] Detection failed testing register %02X. Expected %02X, got %02X.", i, (i - 0xA0), res); pass = false; } @@ -135,45 +139,42 @@ bool TestForAsusAuraSMBusController(i2c_smbus_interface* bus, unsigned char addr if(pass) { - LOG_DEBUG("[Aura SMBus] Checking for Micron string"); + LOG_DEBUG("[ENE SMBus] Checking for Micron string"); char buf[16]; for(int i = 0; i < 16; i++) { - buf[i] = AuraRegisterRead(bus, address, AURA_REG_MICRON_CHECK + i); + buf[i] = ENERegisterRead(bus, address, ENE_REG_MICRON_CHECK + i); } if(strcmp(buf, "Micron") == 0) { - LOG_DEBUG("[Aura SMBus] Device %02X is a Micron device, skipping", address); + LOG_DEBUG("[ENE SMBus] Device %02X is a Micron device, skipping", address); pass = false; } else { - LOG_VERBOSE("[Aura SMBus] Detection successful, address %02X", address); + LOG_VERBOSE("[ENE SMBus] Detection successful, address %02X", address); } } } return(pass); -} /* TestForAuraSMBusController() */ +} /* TestForENESMBusController() */ /******************************************************************************************\ * * -* DetectAuraSMBusControllers * +* DetectENESMBusDRAMControllers * * * -* Detect Aura controllers on the enumerated I2C busses. Searches for Aura-enabled * -* RAM at 0x77 and tries to initialize their slot addresses, then searches for them * -* at their correct initialized addresses. Also looks for motherboard controller at * -* address 0x4E. * +* Detects ENE SMBus controllers on DRAM devices * * * -* bus - pointer to i2c_smbus_interface where Aura device is connected * -* dev - I2C address of Aura device * +* bus - pointer to i2c_smbus_interface where device is connected * +* dev - I2C address of device * * * \******************************************************************************************/ -void DetectAsusAuraSMBusDRAMControllers(std::vector &busses) +void DetectENESMBusDRAMControllers(std::vector &busses) { for (unsigned int bus = 0; bus < busses.size(); bus++) { @@ -181,7 +182,7 @@ void DetectAsusAuraSMBusDRAMControllers(std::vector &busse IF_DRAM_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device) { - LOG_DEBUG("[ASUS Aura SMBus DRAM] Remapping Aura SMBus RAM modules on 0x77"); + LOG_DEBUG("[ENE SMBus DRAM] Remapping ENE SMBus RAM modules on 0x77"); for (unsigned int slot = 0; slot < 8; slot++) { @@ -189,7 +190,7 @@ void DetectAsusAuraSMBusDRAMControllers(std::vector &busse if (res < 0) { - LOG_DEBUG("[ASUS Aura SMBus DRAM] No device detected at 0x77, aborting remap"); + LOG_DEBUG("[ENE SMBus DRAM] No device detected at 0x77, aborting remap"); break; } @@ -198,11 +199,11 @@ void DetectAsusAuraSMBusDRAMControllers(std::vector &busse { address_list_idx++; - if(address_list_idx < AURA_RAM_ADDRESS_COUNT) + if(address_list_idx < ENE_RAM_ADDRESS_COUNT) { - LOG_DEBUG("[ASUS Aura SMBus DRAM] Testing address %02X to see if there is a device there", aura_ram_addresses[address_list_idx]); + LOG_DEBUG("[ENE SMBus DRAM] Testing address %02X to see if there is a device there", ene_ram_addresses[address_list_idx]); - res = busses[bus]->i2c_smbus_write_quick(aura_ram_addresses[address_list_idx], I2C_SMBUS_WRITE); + res = busses[bus]->i2c_smbus_write_quick(ene_ram_addresses[address_list_idx], I2C_SMBUS_WRITE); } else { @@ -210,22 +211,22 @@ void DetectAsusAuraSMBusDRAMControllers(std::vector &busse } } while (res >= 0); - if(address_list_idx < AURA_RAM_ADDRESS_COUNT) + if(address_list_idx < ENE_RAM_ADDRESS_COUNT) { - LOG_DEBUG("[ASUS Aura SMBus DRAM] Remapping slot %d to address %02X", slot, aura_ram_addresses[address_list_idx]); + LOG_DEBUG("[ENE SMBus DRAM] Remapping slot %d to address %02X", slot, ene_ram_addresses[address_list_idx]); - AsusAuraRegisterWrite(busses[bus], 0x77, AURA_REG_SLOT_INDEX, slot); - AsusAuraRegisterWrite(busses[bus], 0x77, AURA_REG_I2C_ADDRESS, (aura_ram_addresses[address_list_idx] << 1)); + ENERegisterWrite(busses[bus], 0x77, ENE_REG_SLOT_INDEX, slot); + ENERegisterWrite(busses[bus], 0x77, ENE_REG_I2C_ADDRESS, (ene_ram_addresses[address_list_idx] << 1)); } } - // Add Aura-enabled controllers at their remapped addresses - for (unsigned int address_list_idx = 0; address_list_idx < AURA_RAM_ADDRESS_COUNT; address_list_idx++) + // Add ENE controllers at their remapped addresses + for (unsigned int address_list_idx = 0; address_list_idx < ENE_RAM_ADDRESS_COUNT; address_list_idx++) { - if (TestForAsusAuraSMBusController(busses[bus], aura_ram_addresses[address_list_idx])) + if (TestForENESMBusController(busses[bus], ene_ram_addresses[address_list_idx])) { - AuraSMBusController* controller = new AuraSMBusController(busses[bus], aura_ram_addresses[address_list_idx]); - RGBController_AuraSMBus* rgb_controller = new RGBController_AuraSMBus(controller); + ENESMBusController* controller = new ENESMBusController(busses[bus], ene_ram_addresses[address_list_idx]); + RGBController_ENESMBus* rgb_controller = new RGBController_ENESMBus(controller); ResourceManager::get()->RegisterRGBController(rgb_controller); } @@ -233,13 +234,24 @@ void DetectAsusAuraSMBusDRAMControllers(std::vector &busse } } } -} /* DetectAuraSMBusDRAMControllers() */ +} /* DetectENESMBusDRAMControllers() */ -void DetectAsusAuraSMBusMotherboardControllers(std::vector &busses) +/******************************************************************************************\ +* * +* DetectENESMBusMotherboardControllers * +* * +* Detects ENE (ASUS Aura) SMBus controllers on ASUS motherboard devices * +* * +* bus - pointer to i2c_smbus_interface where Aura device is connected * +* dev - I2C address of Aura device * +* * +\******************************************************************************************/ + +void DetectENESMBusMotherboardControllers(std::vector &busses) { for (unsigned int bus = 0; bus < busses.size(); bus++) { - // Add Aura-enabled motherboard controllers + // Add ENE (ASUS Aura) motherboard controllers IF_MOBO_SMBUS(busses[bus]->pci_vendor, busses[bus]->pci_device) { if(busses[bus]->pci_subsystem_vendor == ASUS_SUB_VEN || busses[bus]->pci_subsystem_vendor == 0) @@ -247,11 +259,12 @@ void DetectAsusAuraSMBusMotherboardControllers(std::vector for (unsigned int address_list_idx = 0; address_list_idx < AURA_MOBO_ADDRESS_COUNT; address_list_idx++) { LOG_DEBUG(SMBUS_CHECK_DEVICE_MESSAGE_EN, DETECTOR_NAME, bus, VENDOR_NAME, aura_mobo_addresses[address_list_idx]); - if (TestForAsusAuraSMBusController(busses[bus], aura_mobo_addresses[address_list_idx])) + + if (TestForENESMBusController(busses[bus], aura_mobo_addresses[address_list_idx])) { DMIInfo dmi; - AuraSMBusController* controller = new AuraSMBusController(busses[bus], aura_mobo_addresses[address_list_idx]); - RGBController_AuraSMBus* rgb_controller = new RGBController_AuraSMBus(controller); + ENESMBusController* controller = new ENESMBusController(busses[bus], aura_mobo_addresses[address_list_idx]); + RGBController_ENESMBus* rgb_controller = new RGBController_ENESMBus(controller); rgb_controller->name = "ASUS " + dmi.getMainboard(); ResourceManager::get()->RegisterRGBController(rgb_controller); } @@ -265,7 +278,7 @@ void DetectAsusAuraSMBusMotherboardControllers(std::vector } } } -} /* DetectAuraSMBusMotherboardControllers() */ +} /* DetectENESMBusMotherboardControllers() */ -REGISTER_I2C_DETECTOR("ASUS Aura SMBus DRAM", DetectAsusAuraSMBusDRAMControllers); -REGISTER_I2C_DETECTOR("ASUS Aura SMBus Motherboard", DetectAsusAuraSMBusMotherboardControllers); +REGISTER_I2C_DETECTOR("ENE SMBus DRAM", DetectENESMBusDRAMControllers); +REGISTER_I2C_DETECTOR("ASUS Aura SMBus Motherboard", DetectENESMBusMotherboardControllers); diff --git a/Controllers/AsusAuraSMBusController/RGBController_AsusAuraSMBus.cpp b/Controllers/ENESMBusController/RGBController_ENESMBus.cpp similarity index 61% rename from Controllers/AsusAuraSMBusController/RGBController_AsusAuraSMBus.cpp rename to Controllers/ENESMBusController/RGBController_ENESMBus.cpp index a3a0d0a4c..5511f1b14 100644 --- a/Controllers/AsusAuraSMBusController/RGBController_AsusAuraSMBus.cpp +++ b/Controllers/ENESMBusController/RGBController_ENESMBus.cpp @@ -1,47 +1,158 @@ /*-----------------------------------------*\ -| RGBController_AsusAuraSMBus.cpp | +| RGBController_ENESMBus.cpp | | | -| Generic RGB Interface for OpenAuraSDK | -| Asus Aura SMBus driver | +| Generic RGB Interface for ENE SMBus | | | | Adam Honse (CalcProgrammer1) 6/13/2019 | \*-----------------------------------------*/ -#include "RGBController_AsusAuraSMBus.h" +#include "RGBController_ENESMBus.h" -int RGBController_AuraSMBus::GetDeviceMode() +RGBController_ENESMBus::RGBController_ENESMBus(ENESMBusController * controller_ptr) { - int dev_mode = aura->AuraRegisterRead(AURA_REG_MODE); - int color_mode = MODE_COLORS_PER_LED; + controller = controller_ptr; - if (aura->AuraRegisterRead(AURA_REG_DIRECT)) + /*---------------------------------------------------------*\ + | Determine name and type (DRAM or Motherboard) by checking | + | the ENE controller's version string | + \*---------------------------------------------------------*/ + version = controller->GetDeviceName(); + + if((version.find("DIMM_LED") != std::string::npos) || (version.find("AUDA") != std::string::npos) ) + { + type = DEVICE_TYPE_DRAM; + name = "ENE DRAM"; + vendor = "ENE"; + } + else + { + type = DEVICE_TYPE_MOTHERBOARD; + name = "ASUS Aura Motherboard"; + vendor = "ASUS"; + } + + location = controller->GetDeviceLocation(); + description = "ENE SMBus Device"; + + mode Direct; + Direct.name = "Direct"; + Direct.value = 0xFFFF; + Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR; + Direct.color_mode = MODE_COLORS_PER_LED; + modes.push_back(Direct); + + mode Off; + Off.name = "Off"; + Off.value = ENE_MODE_OFF; + Off.flags = 0; + Off.color_mode = MODE_COLORS_NONE; + modes.push_back(Off); + + mode Static; + Static.name = "Static"; + Static.value = ENE_MODE_STATIC; + Static.flags = MODE_FLAG_HAS_PER_LED_COLOR; + Static.color_mode = MODE_COLORS_PER_LED; + modes.push_back(Static); + + mode Breathing; + Breathing.name = "Breathing"; + Breathing.value = ENE_MODE_BREATHING; + Breathing.flags = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_PER_LED_COLOR; + Breathing.color_mode = MODE_COLORS_PER_LED; + modes.push_back(Breathing); + + mode Flashing; + Flashing.name = "Flashing"; + Flashing.value = ENE_MODE_FLASHING; + Flashing.flags = MODE_FLAG_HAS_PER_LED_COLOR; + Flashing.color_mode = MODE_COLORS_PER_LED; + modes.push_back(Flashing); + + mode SpectrumCycle; + SpectrumCycle.name = "Spectrum Cycle"; + SpectrumCycle.value = ENE_MODE_SPECTRUM_CYCLE; + SpectrumCycle.flags = 0; + SpectrumCycle.color_mode = MODE_COLORS_NONE; + modes.push_back(SpectrumCycle); + + mode Rainbow; + Rainbow.name = "Rainbow"; + Rainbow.value = ENE_MODE_RAINBOW; + Rainbow.flags = 0; + Rainbow.color_mode = MODE_COLORS_NONE; + modes.push_back(Rainbow); + + mode ChaseFade; + ChaseFade.name = "Chase Fade"; + ChaseFade.value = ENE_MODE_CHASE_FADE; + ChaseFade.flags = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_PER_LED_COLOR; + ChaseFade.color_mode = MODE_COLORS_PER_LED; + modes.push_back(ChaseFade); + + mode Chase; + Chase.name = "Chase"; + Chase.value = ENE_MODE_CHASE; + Chase.flags = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_PER_LED_COLOR; + Chase.color_mode = MODE_COLORS_PER_LED; + modes.push_back(Chase); + + mode RandomFlicker; + RandomFlicker.name = "Random Flicker"; + RandomFlicker.value = ENE_MODE_RANDOM_FLICKER; + RandomFlicker.flags = 0; + RandomFlicker.color_mode = MODE_COLORS_NONE; + modes.push_back(RandomFlicker); + + SetupZones(); + + /*-------------------------------------------------*\ + | Initialize active mode | + \*-------------------------------------------------*/ + active_mode = GetDeviceMode(); +} + +RGBController_ENESMBus::~RGBController_ENESMBus() +{ + delete controller; +} + +int RGBController_ENESMBus::GetDeviceMode() +{ + /*-----------------------------------------------------------------*\ + | Determine starting mode by reading the mode and direct registers | + \*-----------------------------------------------------------------*/ + int dev_mode = controller->ENERegisterRead(ENE_REG_MODE); + int color_mode = MODE_COLORS_PER_LED; + + if(controller->ENERegisterRead(ENE_REG_DIRECT)) { dev_mode = 0xFFFF; } switch(dev_mode) { - case AURA_MODE_OFF: - case AURA_MODE_RAINBOW: - case AURA_MODE_SPECTRUM_CYCLE: - case AURA_MODE_RANDOM_FLICKER: - color_mode = MODE_COLORS_NONE; - break; + case ENE_MODE_OFF: + case ENE_MODE_RAINBOW: + case ENE_MODE_SPECTRUM_CYCLE: + case ENE_MODE_RANDOM_FLICKER: + color_mode = MODE_COLORS_NONE; + break; - case AURA_MODE_SPECTRUM_CYCLE_CHASE: - dev_mode = AURA_MODE_CHASE; - color_mode = MODE_COLORS_RANDOM; - break; + case ENE_MODE_SPECTRUM_CYCLE_CHASE: + dev_mode = ENE_MODE_CHASE; + color_mode = MODE_COLORS_RANDOM; + break; - case AURA_MODE_SPECTRUM_CYCLE_BREATHING: - dev_mode = AURA_MODE_BREATHING; - color_mode = MODE_COLORS_RANDOM; - break; + case ENE_MODE_SPECTRUM_CYCLE_BREATHING: + dev_mode = ENE_MODE_BREATHING; + color_mode = MODE_COLORS_RANDOM; + break; - case AURA_MODE_SPECTRUM_CYCLE_CHASE_FADE: - dev_mode = AURA_MODE_CHASE_FADE; - color_mode = MODE_COLORS_RANDOM; - break; + case ENE_MODE_SPECTRUM_CYCLE_CHASE_FADE: + dev_mode = ENE_MODE_CHASE_FADE; + color_mode = MODE_COLORS_RANDOM; + break; } for(std::size_t mode = 0; mode < modes.size(); mode++) @@ -56,7 +167,7 @@ int RGBController_AuraSMBus::GetDeviceMode() return(active_mode); } -void RGBController_AuraSMBus::DeviceUpdateLEDs() +void RGBController_ENESMBus::DeviceUpdateLEDs() { for(std::size_t led = 0; led < colors.size(); led++) { @@ -64,20 +175,20 @@ void RGBController_AuraSMBus::DeviceUpdateLEDs() unsigned char grn = RGBGetGValue(colors[led]); unsigned char blu = RGBGetBValue(colors[led]); - if (GetMode() == 0) + if(GetMode() == 0) { - aura->SetLEDColorDirect(led, red, grn, blu); + controller->SetLEDColorDirect(led, red, grn, blu); } else { - aura->SetLEDColorEffect(led, red, grn, blu); + controller->SetLEDColorEffect(led, red, grn, blu); } } } -void RGBController_AuraSMBus::UpdateZoneLEDs(int zone) +void RGBController_ENESMBus::UpdateZoneLEDs(int zone) { - for (std::size_t led_idx = 0; led_idx < zones[zone].leds_count; led_idx++) + for(std::size_t led_idx = 0; led_idx < zones[zone].leds_count; led_idx++) { int led = zones[zone].leds[led_idx].value; RGBColor color = colors[led]; @@ -85,143 +196,43 @@ void RGBController_AuraSMBus::UpdateZoneLEDs(int zone) unsigned char grn = RGBGetGValue(color); unsigned char blu = RGBGetBValue(color); - if (GetMode() == 0) + if(GetMode() == 0) { - aura->SetLEDColorDirect(led, red, grn, blu); + controller->SetLEDColorDirect(led, red, grn, blu); } else { - aura->SetLEDColorEffect(led, red, grn, blu); + controller->SetLEDColorEffect(led, red, grn, blu); } } } -void RGBController_AuraSMBus::UpdateSingleLED(int led) +void RGBController_ENESMBus::UpdateSingleLED(int led) { RGBColor color = colors[led]; unsigned char red = RGBGetRValue(color); unsigned char grn = RGBGetGValue(color); unsigned char blu = RGBGetBValue(color); - if (GetMode() == 0) + if(GetMode() == 0) { - aura->SetLEDColorDirect(led, red, grn, blu); + controller->SetLEDColorDirect(led, red, grn, blu); } else { - aura->SetLEDColorEffect(led, red, grn, blu); + controller->SetLEDColorEffect(led, red, grn, blu); } } -RGBController_AuraSMBus::RGBController_AuraSMBus(AuraSMBusController * aura_ptr) +void RGBController_ENESMBus::SetupZones() { - aura = aura_ptr; - - version = aura->GetDeviceName(); - location = aura->GetDeviceLocation(); - if((version.find("DIMM_LED") != std::string::npos) || (version.find("AUDA") != std::string::npos) ) - { - type = DEVICE_TYPE_DRAM; - name = "ASUS Aura DRAM"; - } - else - { - type = DEVICE_TYPE_MOTHERBOARD; - name = "ASUS Aura Motherboard"; - } - vendor = "ASUS"; - description = "ASUS Aura SMBus Device"; - - mode Direct; - Direct.name = "Direct"; - Direct.value = 0xFFFF; - Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR; - Direct.color_mode = MODE_COLORS_PER_LED; - modes.push_back(Direct); - - mode Off; - Off.name = "Off"; - Off.value = AURA_MODE_OFF; - Off.flags = 0; - Off.color_mode = MODE_COLORS_NONE; - modes.push_back(Off); - - mode Static; - Static.name = "Static"; - Static.value = AURA_MODE_STATIC; - Static.flags = MODE_FLAG_HAS_PER_LED_COLOR; - Static.color_mode = MODE_COLORS_PER_LED; - modes.push_back(Static); - - mode Breathing; - Breathing.name = "Breathing"; - Breathing.value = AURA_MODE_BREATHING; - Breathing.flags = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_PER_LED_COLOR; - Breathing.color_mode = MODE_COLORS_PER_LED; - modes.push_back(Breathing); - - mode Flashing; - Flashing.name = "Flashing"; - Flashing.value = AURA_MODE_FLASHING; - Flashing.flags = MODE_FLAG_HAS_PER_LED_COLOR; - Flashing.color_mode = MODE_COLORS_PER_LED; - modes.push_back(Flashing); - - mode SpectrumCycle; - SpectrumCycle.name = "Spectrum Cycle"; - SpectrumCycle.value = AURA_MODE_SPECTRUM_CYCLE; - SpectrumCycle.flags = 0; - SpectrumCycle.color_mode = MODE_COLORS_NONE; - modes.push_back(SpectrumCycle); - - mode Rainbow; - Rainbow.name = "Rainbow"; - Rainbow.value = AURA_MODE_RAINBOW; - Rainbow.flags = 0; - Rainbow.color_mode = MODE_COLORS_NONE; - modes.push_back(Rainbow); - - mode ChaseFade; - ChaseFade.name = "Chase Fade"; - ChaseFade.value = AURA_MODE_CHASE_FADE; - ChaseFade.flags = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_PER_LED_COLOR; - ChaseFade.color_mode = MODE_COLORS_PER_LED; - modes.push_back(ChaseFade); - - mode Chase; - Chase.name = "Chase"; - Chase.value = AURA_MODE_CHASE; - Chase.flags = MODE_FLAG_HAS_RANDOM_COLOR | MODE_FLAG_HAS_PER_LED_COLOR; - Chase.color_mode = MODE_COLORS_PER_LED; - modes.push_back(Chase); - - mode RandomFlicker; - RandomFlicker.name = "Random Flicker"; - RandomFlicker.value = AURA_MODE_RANDOM_FLICKER; - RandomFlicker.flags = 0; - RandomFlicker.color_mode = MODE_COLORS_NONE; - modes.push_back(RandomFlicker); - - SetupZones(); - - // Initialize active mode - active_mode = GetDeviceMode(); -} - -RGBController_AuraSMBus::~RGBController_AuraSMBus() -{ - delete aura; -} - -void RGBController_AuraSMBus::SetupZones() -{ - std::vector aura_led_map; + std::vector led_map; /*---------------------------------------------------------*\ | Search through all LEDs and create zones for each channel | | type | \*---------------------------------------------------------*/ - for (std::size_t led_idx = 0; led_idx < aura->GetLEDCount(); led_idx++) + for(std::size_t led_idx = 0; led_idx < controller->GetLEDCount(); led_idx++) { bool matched = false; @@ -229,9 +240,9 @@ void RGBController_AuraSMBus::SetupZones() | Search through existing zones to make sure we don't | | create a duplicate zone | \*---------------------------------------------------------*/ - for (std::size_t existing_zone_idx = 0; existing_zone_idx < zones.size(); existing_zone_idx++) + for(std::size_t existing_zone_idx = 0; existing_zone_idx < zones.size(); existing_zone_idx++) { - if (aura->GetChannelName(led_idx) == zones[existing_zone_idx].name) + if(controller->GetChannelName(led_idx) == zones[existing_zone_idx].name) { matched = true; } @@ -240,31 +251,31 @@ void RGBController_AuraSMBus::SetupZones() /*---------------------------------------------------------*\ | If zone does not already exist, create it | \*---------------------------------------------------------*/ - if (matched == false) + if(matched == false) { zone* new_zone = new zone(); /*---------------------------------------------------------*\ | Set zone name to channel name | \*---------------------------------------------------------*/ - new_zone->name = aura->GetChannelName(led_idx); + new_zone->name = controller->GetChannelName(led_idx); new_zone->leds_count = 0; /*---------------------------------------------------------*\ | Find all LEDs with this channel type and add them to zone | \*---------------------------------------------------------*/ - for (std::size_t zone_led_idx = 0; zone_led_idx < aura->GetLEDCount(); zone_led_idx++) + for(std::size_t zone_led_idx = 0; zone_led_idx < controller->GetLEDCount(); zone_led_idx++) { - if (aura->GetChannelName(zone_led_idx) == new_zone->name) + if(controller->GetChannelName(zone_led_idx) == new_zone->name) { new_zone->leds_count++; - aura_led_map.push_back(zone_led_idx); + led_map.push_back(zone_led_idx); } } /*---------------------------------------------------------*\ - | Aura zones have fixed size, so set min and max to count | + | Zones have fixed size, so set min and max to count | \*---------------------------------------------------------*/ new_zone->leds_min = new_zone->leds_count; new_zone->leds_max = new_zone->leds_count; @@ -302,7 +313,7 @@ void RGBController_AuraSMBus::SetupZones() new_led->name = zones[zone_idx].name + " LED "; new_led->name.append(std::to_string(led_idx + 1)); - new_led->value = aura_led_map[led_idx]; + new_led->value = led_map[led_idx]; leds.push_back(*new_led); } @@ -316,31 +327,31 @@ void RGBController_AuraSMBus::SetupZones() for(std::size_t led_idx = 0; led_idx < leds.size(); led_idx++) { unsigned int led = leds[led_idx].value; - unsigned char red = aura->GetLEDRed(led); - unsigned char grn = aura->GetLEDGreen(led); - unsigned char blu = aura->GetLEDBlue(led); + unsigned char red = controller->GetLEDRed(led); + unsigned char grn = controller->GetLEDGreen(led); + unsigned char blu = controller->GetLEDBlue(led); colors[led_idx] = ToRGBColor(red, grn, blu); } } -void RGBController_AuraSMBus::ResizeZone(int /*zone*/, int /*new_size*/) +void RGBController_ENESMBus::ResizeZone(int /*zone*/, int /*new_size*/) { /*---------------------------------------------------------*\ | This device does not support resizing zones | \*---------------------------------------------------------*/ } -void RGBController_AuraSMBus::SetCustomMode() +void RGBController_ENESMBus::SetCustomMode() { active_mode = 0; } -void RGBController_AuraSMBus::DeviceUpdateMode() +void RGBController_ENESMBus::DeviceUpdateMode() { if (modes[active_mode].value == 0xFFFF) { - aura->SetDirect(true); + controller->SetDirect(true); } else { @@ -350,19 +361,19 @@ void RGBController_AuraSMBus::DeviceUpdateMode() { switch(new_mode) { - case AURA_MODE_CHASE: - new_mode = AURA_MODE_SPECTRUM_CYCLE_CHASE; + case ENE_MODE_CHASE: + new_mode = ENE_MODE_SPECTRUM_CYCLE_CHASE; break; - case AURA_MODE_BREATHING: - new_mode = AURA_MODE_SPECTRUM_CYCLE_BREATHING; + case ENE_MODE_BREATHING: + new_mode = ENE_MODE_SPECTRUM_CYCLE_BREATHING; break; - case AURA_MODE_CHASE_FADE: - new_mode = AURA_MODE_SPECTRUM_CYCLE_CHASE_FADE; + case ENE_MODE_CHASE_FADE: + new_mode = ENE_MODE_SPECTRUM_CYCLE_CHASE_FADE; break; } } - aura->SetMode(new_mode); - aura->SetDirect(false); + controller->SetMode(new_mode); + controller->SetDirect(false); } } diff --git a/Controllers/AsusAuraSMBusController/RGBController_AsusAuraSMBus.h b/Controllers/ENESMBusController/RGBController_ENESMBus.h similarity index 63% rename from Controllers/AsusAuraSMBusController/RGBController_AsusAuraSMBus.h rename to Controllers/ENESMBusController/RGBController_ENESMBus.h index 1ee181bad..e65edf212 100644 --- a/Controllers/AsusAuraSMBusController/RGBController_AsusAuraSMBus.h +++ b/Controllers/ENESMBusController/RGBController_ENESMBus.h @@ -1,8 +1,7 @@ /*-----------------------------------------*\ -| RGBController_AsusAuraSMBus.h | +| RGBController_ENESMBus.h | | | -| Generic RGB Interface for OpenAuraSDK | -| Asus Aura SMBus driver | +| Generic RGB Interface for ENE SMBus | | | | Adam Honse (CalcProgrammer1) 6/13/2019 | \*-----------------------------------------*/ @@ -10,13 +9,13 @@ #pragma once #include "RGBController.h" -#include "AsusAuraSMBusController.h" +#include "ENESMBusController.h" -class RGBController_AuraSMBus : public RGBController +class RGBController_ENESMBus : public RGBController { public: - RGBController_AuraSMBus(AuraSMBusController* aura_ptr); - ~RGBController_AuraSMBus(); + RGBController_ENESMBus(ENESMBusController* controller_ptr); + ~RGBController_ENESMBus(); void SetupZones(); @@ -30,7 +29,7 @@ public: void DeviceUpdateMode(); private: - AuraSMBusController* aura; + ENESMBusController* controller; int GetDeviceMode(); }; diff --git a/OpenRGB.pro b/OpenRGB.pro index e1f3a4e20..c02179f06 100644 --- a/OpenRGB.pro +++ b/OpenRGB.pro @@ -78,7 +78,6 @@ INCLUDEPATH += Controllers/ASRockPolychromeUSBController/ \ Controllers/AsusAuraCoreController/ \ Controllers/AsusAuraGPUController/ \ - Controllers/AsusAuraSMBusController/ \ Controllers/AsusAuraUSBController/ \ Controllers/CoolerMasterController/ \ Controllers/CorsairCommanderCoreController/ \ @@ -97,6 +96,7 @@ INCLUDEPATH += Controllers/DuckyKeyboardController/ \ Controllers/E131Controller/ \ Controllers/EKController/ \ + Controllers/ENESMBusController/ \ Controllers/EspurnaController/ \ Controllers/EVGAGPUController/ \ Controllers/EVisionKeyboardController/ \ @@ -222,8 +222,6 @@ HEADERS += Controllers/AsusAuraCoreController/RGBController_AsusAuraCore.h \ Controllers/AsusAuraGPUController/AsusAuraGPUController.h \ Controllers/AsusAuraGPUController/RGBController_AsusAuraGPU.h \ - Controllers/AsusAuraSMBusController/AsusAuraSMBusController.h \ - Controllers/AsusAuraSMBusController/RGBController_AsusAuraSMBus.h \ Controllers/AsusAuraUSBController/AsusAuraUSBController.h \ Controllers/AsusAuraUSBController/AsusAuraAddressableController.h \ Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController.h \ @@ -285,6 +283,8 @@ HEADERS += Controllers/E131Controller/RGBController_E131.h \ Controllers/EKController/EKController.h \ Controllers/EKController/RGBController_EKController.h \ + Controllers/ENESMBusController/ENESMBusController.h \ + Controllers/ENESMBusController/RGBController_ENESMBus.h \ Controllers/EspurnaController/EspurnaController.h \ Controllers/EspurnaController/RGBController_Espurna.h \ Controllers/EVGAGPUController/EVGAGPUCommon.h \ @@ -577,9 +577,6 @@ SOURCES += Controllers/AsusAuraGPUController/AsusAuraGPUController.cpp \ Controllers/AsusAuraGPUController/AsusAuraGPUControllerDetect.cpp \ Controllers/AsusAuraGPUController/RGBController_AsusAuraGPU.cpp \ - Controllers/AsusAuraSMBusController/AsusAuraSMBusController.cpp \ - Controllers/AsusAuraSMBusController/AsusAuraSMBusControllerDetect.cpp \ - Controllers/AsusAuraSMBusController/RGBController_AsusAuraSMBus.cpp \ Controllers/AsusAuraUSBController/AsusAuraUSBController.cpp \ Controllers/AsusAuraUSBController/AsusAuraAddressableController.cpp \ Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController.cpp \ @@ -659,6 +656,9 @@ SOURCES += Controllers/EKController/EKControllerDetect.cpp \ Controllers/EKController/EKController.cpp \ Controllers/EKController/RGBController_EKController.cpp \ + Controllers/ENESMBusController/ENESMBusController.cpp \ + Controllers/ENESMBusController/ENESMBusControllerDetect.cpp \ + Controllers/ENESMBusController/RGBController_ENESMBus.cpp \ Controllers/EspurnaController/EspurnaController.cpp \ Controllers/EspurnaController/EspurnaControllerDetect.cpp \ Controllers/EspurnaController/RGBController_Espurna.cpp \