mirror of
https://github.com/CalcProgrammer1/OpenRGB.git
synced 2025-12-25 16:27:50 -05:00
309 lines
12 KiB
C++
309 lines
12 KiB
C++
/*-----------------------------------------*\
|
|
| ASRockPolychromeV1SMBusController.cpp |
|
|
| |
|
|
| Driver for for ASRock ASR LED and |
|
|
| Polychrome RGB lighting controller |
|
|
| |
|
|
| Adam Honse (CalcProgrammer1) 12/14/2019 |
|
|
\*-----------------------------------------*/
|
|
|
|
#include "ASRockPolychromeV1SMBusController.h"
|
|
#include <cstring>
|
|
#include "dependencies/dmiinfo.h"
|
|
#include "LogManager.h"
|
|
|
|
#define ASROCK_ZONE_LED_COUNT_MESSAGE_EN "[%s] Zone %i LED count: %02d"
|
|
|
|
using namespace std::chrono_literals;
|
|
|
|
ASRockPolychromeV1SMBusController::ASRockPolychromeV1SMBusController(i2c_smbus_interface* bus, polychrome_dev_id dev)
|
|
{
|
|
this->bus = bus;
|
|
this->dev = dev;
|
|
|
|
DMIInfo dmi;
|
|
device_name = "ASRock " + dmi.getMainboard();
|
|
|
|
ReadLEDConfiguration();
|
|
}
|
|
|
|
ASRockPolychromeV1SMBusController::~ASRockPolychromeV1SMBusController()
|
|
{
|
|
|
|
}
|
|
|
|
std::string ASRockPolychromeV1SMBusController::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);
|
|
}
|
|
|
|
std::string ASRockPolychromeV1SMBusController::GetDeviceName()
|
|
{
|
|
return(device_name);
|
|
}
|
|
|
|
std::string ASRockPolychromeV1SMBusController::GetFirmwareVersion()
|
|
{
|
|
uint8_t major_version = fw_version >> 8;
|
|
uint8_t minor_version = fw_version & 0xFF;
|
|
|
|
return(std::to_string(major_version) + "." + std::to_string(minor_version));
|
|
}
|
|
|
|
void ASRockPolychromeV1SMBusController::ReadLEDConfiguration()
|
|
{
|
|
/*---------------------------------------------------------------------------------*\
|
|
| The LED configuration register holds 6 bytes, so the first read should return 6 |
|
|
| If not, set all zone sizes to zero |
|
|
\*---------------------------------------------------------------------------------*/
|
|
LOG_DEBUG("[%s] Reading Zone sizes from controller", device_name.c_str());
|
|
uint8_t asrock_zone_count[I2C_SMBUS_BLOCK_MAX] = { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 };
|
|
if (bus->i2c_smbus_read_block_data(dev, POLYCHROME_V1_REG_ZONE_SIZE, asrock_zone_count) == 0x06)
|
|
{
|
|
zone_led_count[POLYCHROME_V1_ZONE_1] = asrock_zone_count[0];
|
|
zone_led_count[POLYCHROME_V1_ZONE_2] = asrock_zone_count[1];
|
|
zone_led_count[POLYCHROME_V1_ZONE_3] = asrock_zone_count[2];
|
|
zone_led_count[POLYCHROME_V1_ZONE_4] = asrock_zone_count[3];
|
|
zone_led_count[POLYCHROME_V1_ZONE_5] = asrock_zone_count[4];
|
|
zone_led_count[POLYCHROME_V1_ZONE_ADDRESSABLE] = asrock_zone_count[5];
|
|
LOG_DEBUG(ASROCK_ZONE_LED_COUNT_MESSAGE_EN, device_name.c_str(), POLYCHROME_V1_ZONE_1, zone_led_count[POLYCHROME_V1_ZONE_1]);
|
|
LOG_DEBUG(ASROCK_ZONE_LED_COUNT_MESSAGE_EN, device_name.c_str(), POLYCHROME_V1_ZONE_2, zone_led_count[POLYCHROME_V1_ZONE_2]);
|
|
LOG_DEBUG(ASROCK_ZONE_LED_COUNT_MESSAGE_EN, device_name.c_str(), POLYCHROME_V1_ZONE_3, zone_led_count[POLYCHROME_V1_ZONE_3]);
|
|
LOG_DEBUG(ASROCK_ZONE_LED_COUNT_MESSAGE_EN, device_name.c_str(), POLYCHROME_V1_ZONE_4, zone_led_count[POLYCHROME_V1_ZONE_4]);
|
|
LOG_DEBUG(ASROCK_ZONE_LED_COUNT_MESSAGE_EN, device_name.c_str(), POLYCHROME_V1_ZONE_5, zone_led_count[POLYCHROME_V1_ZONE_5]);
|
|
LOG_DEBUG("[%s] Addressable Zone LED count: %02d", device_name.c_str(), zone_led_count[POLYCHROME_V1_ZONE_ADDRESSABLE]);
|
|
}
|
|
else
|
|
{
|
|
LOG_WARNING("[%s] LED config read failed", device_name.c_str());
|
|
memset(zone_led_count, 0, sizeof(zone_led_count));
|
|
}
|
|
}
|
|
|
|
uint8_t ASRockPolychromeV1SMBusController::GetARGBColorOrder()
|
|
{
|
|
uint8_t temp[1] = { 0x00 };
|
|
LOG_TRACE("[%s] Reading ARGB color order config from the controller", device_name.c_str());
|
|
|
|
//Read the data
|
|
if(bus->i2c_smbus_read_block_data(dev, POLYCHROME_V1_REG_ARGB_GRB, temp) == 0x01)
|
|
{
|
|
if(temp[0] == 1)
|
|
{
|
|
LOG_DEBUG("[%s] Color order is GRB for the ARGB header", device_name.c_str());
|
|
}
|
|
else
|
|
{
|
|
LOG_DEBUG("[%s] Color order is RGB for the ARGB header", device_name.c_str());
|
|
}
|
|
return temp[0];
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
RGBColor ASRockPolychromeV1SMBusController::GetZoneColor(uint8_t zone)
|
|
{
|
|
LOG_TRACE("[%s] Reading color from zone %02d", device_name.c_str(), zone);
|
|
return zone_config[zone].color;
|
|
}
|
|
|
|
uint8_t ASRockPolychromeV1SMBusController::GetZoneMode(uint8_t zone)
|
|
{
|
|
LOG_TRACE("[%s] Retreving mode %02X from zone_modes for zone %02d", device_name.c_str(), zone_config[zone].mode, zone);
|
|
return(zone_config[zone].mode);
|
|
}
|
|
|
|
void ASRockPolychromeV1SMBusController::LoadZoneConfig()
|
|
{
|
|
uint8_t zone[1] = { 0x00 };
|
|
uint8_t mode[1] = { 0xFF };
|
|
uint8_t color_speed_pkt[4] = { 0, 0, 0, 0 };
|
|
|
|
LOG_TRACE("[%s] Reading modes from all zones", device_name.c_str());
|
|
//Polychrome v1 supports per zone modes so we need to set the zone before we can read the mode.
|
|
//Write the zone index.
|
|
|
|
for(uint8_t zone_idx = 0 ; zone_idx < POLYCHROME_V1_ZONE_COUNT; zone_idx ++)
|
|
{
|
|
if(zone_led_count[zone_idx] > 0)
|
|
{
|
|
zone[0] = zone_idx;
|
|
bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_ZONE_SELECT, 1, zone);
|
|
|
|
//Read the data back.
|
|
if(bus->i2c_smbus_read_block_data(dev, POLYCHROME_V1_REG_ZONE_SELECT, zone) == 0x01)
|
|
{
|
|
//Validate that we changed correctly.
|
|
if(zone[0] == zone_idx)
|
|
{
|
|
//Read the mode for the zone.
|
|
if(bus->i2c_smbus_read_block_data(dev, POLYCHROME_V1_REG_MODE, mode) == 0x01)
|
|
{
|
|
LOG_DEBUG("[%s] Mode 0x%02x for zone %02d", device_name.c_str(), mode[0], zone_idx);
|
|
zone_config[zone_idx].mode = mode[0];
|
|
|
|
bus->i2c_smbus_read_block_data(dev, zone_config[zone_idx].mode, color_speed_pkt);
|
|
|
|
zone_config[zone_idx].color = color_speed_pkt[0] << 16 | color_speed_pkt[1] << 8 | color_speed_pkt[2];
|
|
zone_config[zone_idx].speed = color_speed_pkt [3];
|
|
|
|
LOG_TRACE("[%s] Mode config: %06X, %02X", device_name.c_str(), zone_config[zone_idx].color, zone_config[zone_idx].speed );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOG_WARNING("[%s] Zone mode register failed to change!", device_name.c_str() );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
zone_config[zone_idx].mode = 0;
|
|
zone_config[zone_idx].color = 0;
|
|
zone_config[zone_idx].speed = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
void ASRockPolychromeV1SMBusController::SetARGBColorOrder(bool value)
|
|
{
|
|
uint8_t temp[1] = { 0x00 };
|
|
|
|
LOG_TRACE("[%s] Setting ARGB color order config to the controller", device_name.c_str());
|
|
|
|
temp[0] = (value) ? 0x01 : 0x00;
|
|
bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_ARGB_GRB, 1, temp);
|
|
GetARGBColorOrder();
|
|
}
|
|
|
|
bool ASRockPolychromeV1SMBusController::SetARGBSize(uint8_t new_size)
|
|
{
|
|
LOG_DEBUG("[%s] Setting ARGB header to %02d.", device_name.c_str(), new_size);
|
|
|
|
uint8_t asrock_zone_count[6] = { 0x0 };
|
|
uint8_t new_asrock_zone_count[6] = { 0x0 };
|
|
|
|
//memcpy(new_asrock_zone_count, zone_led_count, sizeof(new_asrock_zone_count - 1));
|
|
new_asrock_zone_count[POLYCHROME_V1_ZONE_1] = zone_led_count[POLYCHROME_V1_ZONE_1];
|
|
new_asrock_zone_count[POLYCHROME_V1_ZONE_2] = zone_led_count[POLYCHROME_V1_ZONE_2];
|
|
new_asrock_zone_count[POLYCHROME_V1_ZONE_3] = zone_led_count[POLYCHROME_V1_ZONE_3];
|
|
new_asrock_zone_count[POLYCHROME_V1_ZONE_4] = zone_led_count[POLYCHROME_V1_ZONE_4];
|
|
new_asrock_zone_count[POLYCHROME_V1_ZONE_5] = zone_led_count[POLYCHROME_V1_ZONE_5];
|
|
new_asrock_zone_count[POLYCHROME_V1_ZONE_ADDRESSABLE] = new_size;
|
|
|
|
//Write the new config to the register
|
|
bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_ZONE_SIZE, 6, new_asrock_zone_count);
|
|
|
|
//Validate the write
|
|
if (bus->i2c_smbus_read_block_data(dev, POLYCHROME_V1_REG_ZONE_SIZE, asrock_zone_count) == 0x06)
|
|
{
|
|
for (uint8_t i = 0; i < 6; i++)
|
|
{
|
|
if (new_asrock_zone_count[i] != asrock_zone_count[i])
|
|
{
|
|
LOG_WARNING("[%s] Failed to validate zone %02d size!", device_name.c_str(), i);
|
|
return false;
|
|
}
|
|
}
|
|
LOG_DEBUG("[%s] Zone configuration validation completed.", device_name.c_str());
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void ASRockPolychromeV1SMBusController::SetColorsAndSpeed(uint8_t zone, uint8_t red, uint8_t green, uint8_t blue)
|
|
{
|
|
LOG_TRACE("[%s] Updating color and speed for zone %02d: 0x%06X", device_name.c_str(), zone, (red << 16 | green << 8 | blue));
|
|
uint8_t color_speed_pkt[4] = { red, green, blue, zone_config[zone].speed };
|
|
uint8_t select_zone_pkt[1] = { zone };
|
|
|
|
/*-----------------------------------------------------*\
|
|
| Select Zone |
|
|
\*-----------------------------------------------------*/
|
|
if(zone_config[zone].mode != POLYCHROME_V1_MODE_OFF)
|
|
{
|
|
bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_ZONE_SELECT, 1, select_zone_pkt);
|
|
std::this_thread::sleep_for(1ms);
|
|
}
|
|
|
|
switch(zone_config[zone].mode)
|
|
{
|
|
/*-----------------------------------------------------*\
|
|
| These modes take 4 bytes in R/G/B/S order |
|
|
\*-----------------------------------------------------*/
|
|
case POLYCHROME_V1_MODE_BREATHING:
|
|
case POLYCHROME_V1_MODE_STROBE:
|
|
case POLYCHROME_V1_MODE_SPECTRUM_CYCLE:
|
|
case POLYCHROME_V1_MODE_SPRING:
|
|
case POLYCHROME_V1_MODE_METEOR:
|
|
case POLYCHROME_V1_MODE_STACK:
|
|
case POLYCHROME_V1_MODE_CRAM:
|
|
case POLYCHROME_V1_MODE_SCAN:
|
|
case POLYCHROME_V1_MODE_NEON:
|
|
case POLYCHROME_V1_MODE_WATER:
|
|
|
|
bus->i2c_smbus_write_block_data(dev, zone_config[zone].mode, 4, color_speed_pkt);
|
|
break;
|
|
|
|
/*-----------------------------------------------------*\
|
|
| These modes take 3 bytes in R/G/B order |
|
|
\*-----------------------------------------------------*/
|
|
default:
|
|
case POLYCHROME_V1_MODE_STATIC:
|
|
case POLYCHROME_V1_MODE_MUSIC:
|
|
bus->i2c_smbus_write_block_data(dev, zone_config[zone].mode, 3, color_speed_pkt);
|
|
break;
|
|
|
|
/*-----------------------------------------------------*\
|
|
| These modes take 1 byte - speed |
|
|
\*-----------------------------------------------------*/
|
|
case POLYCHROME_V1_MODE_RANDOM:
|
|
case POLYCHROME_V1_MODE_WAVE:
|
|
case POLYCHROME_V1_MODE_RAINBOW:
|
|
bus->i2c_smbus_write_block_data(dev, zone_config[zone].mode, 1, &zone_config[zone].speed);
|
|
break;
|
|
|
|
/*-----------------------------------------------------*\
|
|
| These modes take no bytes |
|
|
\*-----------------------------------------------------*/
|
|
case POLYCHROME_V1_MODE_OFF:
|
|
break;
|
|
}
|
|
std::this_thread::sleep_for(1ms);
|
|
|
|
}
|
|
|
|
void ASRockPolychromeV1SMBusController::SetMode(uint8_t zone, uint8_t mode, uint8_t speed)
|
|
{
|
|
LOG_TRACE("[%s] Updating mode for zone %02d, Mode 0x%02X, Speed 0x%02X", device_name.c_str(), zone, mode, speed);
|
|
uint8_t led_count_pkt[1] = { 0x00 };
|
|
zone_config[zone].mode = mode;
|
|
zone_config[zone].speed = speed;
|
|
|
|
/*-----------------------------------------------------*\
|
|
| Make sure set all register is set to 0 |
|
|
\*-----------------------------------------------------*/
|
|
bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_SET_ALL, 1, led_count_pkt);
|
|
std::this_thread::sleep_for(1ms);
|
|
|
|
/*-----------------------------------------------------*\
|
|
| Set the zone we are working on |
|
|
\*-----------------------------------------------------*/
|
|
bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_ZONE_SELECT, 1, &zone);
|
|
std::this_thread::sleep_for(1ms);
|
|
|
|
/*-----------------------------------------------------*\
|
|
| Write the mode |
|
|
\*-----------------------------------------------------*/
|
|
bus->i2c_smbus_write_block_data(dev, POLYCHROME_V1_REG_MODE, 1, &zone_config[zone].mode);
|
|
std::this_thread::sleep_for(1ms);
|
|
}
|