Publish LumaOps source
This commit is contained in:
LumaOps release export
@@ -0,0 +1,715 @@
|
||||
/*---------------------------------------------------------*\
|
||||
| RealtekARGBController.cpp |
|
||||
| |
|
||||
| Controller for Realtek USB ARGB ICs |
|
||||
| |
|
||||
| Jerry Fan (JerryFan0612) 13 Mar 2026 |
|
||||
| |
|
||||
| This file is part of the OpenRGB project |
|
||||
| SPDX-License-Identifier: GPL-2.0-or-later |
|
||||
\*---------------------------------------------------------*/
|
||||
|
||||
#include "RealtekARGBController.h"
|
||||
#include "MathUtils.h"
|
||||
#include "StringUtils.h"
|
||||
|
||||
using namespace std::chrono_literals;
|
||||
|
||||
static const unsigned char hid_set_packet[] =
|
||||
{
|
||||
0x56, 0x53, 0x42, 0x43, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0xE3,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
};
|
||||
static const unsigned char hid_get_packet[] =
|
||||
{
|
||||
0x56, 0x53, 0x42, 0x43, 0x78, 0x56, 0x34, 0x12, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x10, 0xE2,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
};
|
||||
static const unsigned char hid_end_packet[] =
|
||||
{
|
||||
0x58, 0x53, 0x42, 0x53, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
};
|
||||
|
||||
RealtekARGBController::RealtekARGBController(hid_device* dev, hid_device_info* info)
|
||||
{
|
||||
hdev = dev;
|
||||
hidinfo = info;
|
||||
for(int i = 0; i < REALTEK_ARGB_NUM_ARGB_GRP; i++)
|
||||
{
|
||||
argbctl_data[i] = (unsigned char*)calloc(REALTEK_ARGB_CTL_DATA_SIZE, 1);
|
||||
memset(argbctl_data[i], 0, REALTEK_ARGB_CTL_DATA_SIZE);
|
||||
prev_bright[i] = 0xFFFF;
|
||||
}
|
||||
device_init();
|
||||
|
||||
keepalive_thread_run = false;
|
||||
keepalive_thread = NULL;
|
||||
}
|
||||
|
||||
RealtekARGBController::~RealtekARGBController()
|
||||
{
|
||||
/*-----------------------------------------------------*\
|
||||
| Close keepalive thread |
|
||||
\*-----------------------------------------------------*/
|
||||
if(keepalive_thread != NULL)
|
||||
{
|
||||
keepalive_thread_run = false;
|
||||
keepalive_thread->join();
|
||||
delete keepalive_thread;
|
||||
}
|
||||
|
||||
if(hdev)
|
||||
{
|
||||
for(int i = 0; i < REALTEK_ARGB_NUM_ARGB_GRP; i++)
|
||||
{
|
||||
int ret = set_appctl(i, REALTEK_ARGB_LED_CTL_FW);
|
||||
if(!ret)
|
||||
{
|
||||
appctl[i] = REALTEK_ARGB_LED_CTL_FW;
|
||||
}
|
||||
}
|
||||
hid_close(hdev);
|
||||
hdev = NULL;
|
||||
}
|
||||
memset(argbctl_hdr, 0, REALTEK_ARGB_CTL_HDR_SIZE);
|
||||
for(int i = 0; i < REALTEK_ARGB_NUM_ARGB_GRP; i++)
|
||||
free(argbctl_data[i]);
|
||||
}
|
||||
|
||||
void RealtekARGBController::KeepaliveThreadFunction()
|
||||
{
|
||||
/*-----------------------------------------------------------------*\
|
||||
| One shot thread to rescan device |
|
||||
\*-----------------------------------------------------------------*/
|
||||
while(keepalive_thread_run.load())
|
||||
{
|
||||
std::this_thread::sleep_for(2s);
|
||||
device_rescan();
|
||||
keepalive_thread_run = false;
|
||||
}
|
||||
}
|
||||
|
||||
int RealtekARGBController::usb_hid_ioctl(unsigned char* usb_buf, unsigned char* data, int data_len,
|
||||
unsigned int offset, unsigned char is_in)
|
||||
{
|
||||
int id;
|
||||
int ret = 0;
|
||||
int buf_len = usb_hid_get_report(data_len, &id);
|
||||
|
||||
if(hdev == NULL)
|
||||
{
|
||||
free(usb_buf);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if(!is_in && data_len)
|
||||
{
|
||||
usb_buf[0x04] = data[0];
|
||||
}
|
||||
memcpy(&usb_buf[0x08], &data_len, sizeof(data_len));
|
||||
memcpy(&usb_buf[0x1B], &data_len, sizeof(data_len));
|
||||
ret = hid_send_feature_report(hdev, usb_buf, sizeof(hid_get_packet));
|
||||
|
||||
memset(usb_buf, 0x00, buf_len);
|
||||
memcpy(usb_buf, data, data_len);
|
||||
usb_buf[0x00] = id;
|
||||
if(is_in)
|
||||
{
|
||||
ret = hid_get_feature_report(hdev, usb_buf, buf_len);
|
||||
memcpy(data, usb_buf + offset, data_len);
|
||||
}
|
||||
else
|
||||
{
|
||||
ret = hid_send_feature_report(hdev, usb_buf, buf_len);
|
||||
}
|
||||
|
||||
memset(usb_buf, 0x00, buf_len);
|
||||
memcpy(usb_buf, hid_end_packet, sizeof(hid_end_packet));
|
||||
ret = hid_get_feature_report(hdev, usb_buf, sizeof(hid_end_packet));
|
||||
free(usb_buf);
|
||||
return (ret > 0) ? 0 : ret;
|
||||
}
|
||||
|
||||
int RealtekARGBController::usb_hid_get_report(int data_len, int* id)
|
||||
{
|
||||
int retlen = 0;
|
||||
|
||||
if(data_len <= REALTEK_ARGB_HID_DATALEN_CH2)
|
||||
{
|
||||
*id = REALTEK_ARGB_HID_ID_DATA_CH2;
|
||||
retlen = REALTEK_ARGB_HID_DATALEN_CH2;
|
||||
}
|
||||
else if(data_len <= REALTEK_ARGB_HID_DATALEN_CH3)
|
||||
{
|
||||
*id = REALTEK_ARGB_HID_ID_DATA_CH3;
|
||||
retlen = REALTEK_ARGB_HID_DATALEN_CH3;
|
||||
}
|
||||
else if(data_len <= REALTEK_ARGB_HID_DATALEN_CH4)
|
||||
{
|
||||
*id = REALTEK_ARGB_HID_ID_DATA_CH4;
|
||||
retlen = REALTEK_ARGB_HID_DATALEN_CH4;
|
||||
}
|
||||
else if(data_len <= REALTEK_ARGB_HID_DATALEN_CH5)
|
||||
{
|
||||
*id = REALTEK_ARGB_HID_ID_DATA_CH5;
|
||||
retlen = REALTEK_ARGB_HID_DATALEN_CH5;
|
||||
}
|
||||
else
|
||||
{
|
||||
*id = REALTEK_ARGB_HID_ID_DATA_CH1;
|
||||
retlen = REALTEK_ARGB_HID_DATALEN_CH1;
|
||||
}
|
||||
return retlen;
|
||||
}
|
||||
|
||||
void RealtekARGBController::device_init()
|
||||
{
|
||||
set_write_unlock();
|
||||
get_argbctl_hdr();
|
||||
get_argbctl_data();
|
||||
for(int i = 0; i < REALTEK_ARGB_NUM_ARGB_GRP; i++)
|
||||
{
|
||||
int ret = set_appctl(i, REALTEK_ARGB_LED_CTL_FW);
|
||||
if(!ret)
|
||||
{
|
||||
appctl[i] = REALTEK_ARGB_LED_CTL_FW;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int RealtekARGBController::set_write_unlock()
|
||||
{
|
||||
int ret = 0;
|
||||
int buf_len = REALTEK_ARGB_HID_DATALEN_CH1;
|
||||
int data_len = 96;
|
||||
unsigned int addr = 0xAC004000;
|
||||
unsigned char* data = (unsigned char*)calloc(data_len, 1);
|
||||
unsigned char* usb_buf = (unsigned char*)calloc(buf_len, 1);// will release in usb_hid_ioctl function
|
||||
|
||||
memset(usb_buf, 0x00, buf_len);
|
||||
memcpy(usb_buf, hid_get_packet, sizeof(hid_get_packet));
|
||||
usb_buf[0x13] = 0x92;
|
||||
memcpy(&usb_buf[0x17], &addr, sizeof(addr));
|
||||
ret = usb_hid_ioctl(usb_buf, data, data_len, 0, true);
|
||||
free(data);
|
||||
return ret;
|
||||
}
|
||||
|
||||
unsigned char RealtekARGBController::get_support_openrgb()
|
||||
{
|
||||
int buf_len = REALTEK_ARGB_HID_DATALEN_CH1;
|
||||
unsigned char is_support = 0;
|
||||
unsigned char* usb_buf = (unsigned char*)calloc(buf_len, 1);// will release in usb_hid_ioctl function
|
||||
|
||||
memset(usb_buf, 0x00, buf_len);
|
||||
memcpy(usb_buf, hid_get_packet, sizeof(hid_get_packet));
|
||||
usb_buf[0x13] = 0xCC;
|
||||
usb_buf[0x14] = 0x04;
|
||||
usb_buf[0x15] = REALTEK_ARGB_SYNC_METHOD_OPENRGB;
|
||||
if(usb_hid_ioctl(usb_buf, &is_support, sizeof(is_support), 0, true))
|
||||
{
|
||||
is_support = 0;
|
||||
}
|
||||
return is_support;
|
||||
}
|
||||
|
||||
std::string RealtekARGBController::get_manu_name()
|
||||
{
|
||||
return StringUtils::wchar_to_char(hidinfo->manufacturer_string);
|
||||
}
|
||||
|
||||
std::string RealtekARGBController::get_product_name()
|
||||
{
|
||||
return StringUtils::wchar_to_char(hidinfo->product_string);
|
||||
}
|
||||
|
||||
std::string RealtekARGBController::get_sn()
|
||||
{
|
||||
return StringUtils::wchar_to_char(hidinfo->serial_number);
|
||||
}
|
||||
|
||||
std::string RealtekARGBController::get_dev_loc()
|
||||
{
|
||||
return hidinfo->path;
|
||||
}
|
||||
|
||||
std::string RealtekARGBController::get_fw_ver()
|
||||
{
|
||||
std::string ver = "";
|
||||
struct RealtekARGBControllerFWVersion fw_ver;
|
||||
int buf_len = REALTEK_ARGB_HID_DATALEN_CH1;
|
||||
unsigned char* usb_buf = (unsigned char*)calloc(buf_len, 1);// will release in usb_hid_ioctl function
|
||||
|
||||
memset(usb_buf, 0x00, buf_len);
|
||||
memcpy(usb_buf, hid_get_packet, sizeof(hid_get_packet));
|
||||
usb_buf[0x13] = 0xA5;
|
||||
if(!usb_hid_ioctl(usb_buf, (unsigned char*)&fw_ver, sizeof(fw_ver), 0, true))
|
||||
{
|
||||
ver += std::to_string(fw_ver.fw_major_ver) + "." +
|
||||
std::to_string(fw_ver.fw_minor_ver) + "." +
|
||||
std::to_string(fw_ver.fw_extra_ver) + "." +
|
||||
std::to_string(fw_ver.fw_build_date);
|
||||
}
|
||||
return ver;
|
||||
}
|
||||
|
||||
std::string RealtekARGBController::get_ic_uuid()
|
||||
{
|
||||
unsigned int uuid = 0;
|
||||
int buf_len = REALTEK_ARGB_HID_DATALEN_CH1;
|
||||
unsigned char* usb_buf = (unsigned char*)calloc(buf_len, 1);// will release in usb_hid_ioctl function
|
||||
|
||||
memset(usb_buf, 0x00, buf_len);
|
||||
memcpy(usb_buf, hid_get_packet, sizeof(hid_get_packet));
|
||||
usb_buf[0x13] = 0xC3;
|
||||
usb_hid_ioctl(usb_buf, (unsigned char*)&uuid, sizeof(uuid), 0, true);
|
||||
|
||||
return StringUtils::u32int_to_hexString(uuid);
|
||||
}
|
||||
|
||||
std::string RealtekARGBController::get_dev_name()
|
||||
{
|
||||
bool got_custled = false;
|
||||
std::string devname = get_product_name();
|
||||
|
||||
if(custled[0])
|
||||
{
|
||||
got_custled = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(!get_custled(custled, sizeof(custled)))
|
||||
{
|
||||
got_custled = true;
|
||||
}
|
||||
}
|
||||
|
||||
if(got_custled)
|
||||
{
|
||||
if(custled[6] == REALTEK_ARGB_CUST_DEVNAME_MANU_UUID)
|
||||
{
|
||||
devname = get_manu_name() + get_ic_uuid();
|
||||
}
|
||||
}
|
||||
return devname;
|
||||
}
|
||||
|
||||
int RealtekARGBController::get_fix_grps()
|
||||
{
|
||||
bool got_custled = false;
|
||||
static int fix_grps = 0;
|
||||
|
||||
if(custled[0])
|
||||
{
|
||||
got_custled = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(!get_custled(custled, sizeof(custled)))
|
||||
{
|
||||
got_custled = true;
|
||||
}
|
||||
}
|
||||
|
||||
if(got_custled)
|
||||
{
|
||||
fix_grps = custled[4];
|
||||
}
|
||||
return fix_grps;
|
||||
}
|
||||
|
||||
bool RealtekARGBController::get_zone_enable(int grp_num)
|
||||
{
|
||||
bool got_custled = false;
|
||||
bool en = false;
|
||||
|
||||
if(custled[0])
|
||||
{
|
||||
got_custled = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(!get_custled(custled, sizeof(custled)))
|
||||
{
|
||||
got_custled = true;
|
||||
}
|
||||
}
|
||||
|
||||
if(got_custled)
|
||||
{
|
||||
en = (custled[5] & (0x1 << grp_num)) ? true : false;
|
||||
}
|
||||
return en;
|
||||
}
|
||||
|
||||
int RealtekARGBController::get_argb_num(int grp_num)
|
||||
{
|
||||
int num_rgb = 0;
|
||||
memcpy(&num_rgb, &argbctl_hdr[32 + grp_num * 2], 2);
|
||||
|
||||
return num_rgb;
|
||||
}
|
||||
|
||||
int RealtekARGBController::get_argb_brightness(int grp_num)
|
||||
{
|
||||
int bright = 0;
|
||||
memcpy(&bright, &argbctl_hdr[42 + grp_num * 2], 2);
|
||||
|
||||
return bright;
|
||||
}
|
||||
|
||||
int RealtekARGBController::set_argb_brightness(int grp_num, unsigned short bright)
|
||||
{
|
||||
memcpy(&argbctl_hdr[42 + grp_num * sizeof(bright)], &bright, sizeof(bright));
|
||||
set_argbctl_hdr();
|
||||
return 0;
|
||||
}
|
||||
|
||||
int RealtekARGBController::set_appctl(unsigned char grp_num, unsigned char ctl_sts)
|
||||
{
|
||||
int buf_len = REALTEK_ARGB_HID_DATALEN_CH1;
|
||||
unsigned char* usb_buf = (unsigned char*)calloc(buf_len, 1);// will release in usb_hid_ioctl function
|
||||
|
||||
memset(usb_buf, 0x00, buf_len);
|
||||
memcpy(usb_buf, hid_set_packet, sizeof(hid_set_packet));
|
||||
usb_buf[0x13] = 0x4C;
|
||||
usb_buf[0x14] = 0x01;
|
||||
usb_buf[0x15] = ctl_sts;
|
||||
usb_buf[0x16] = grp_num;
|
||||
return usb_hid_ioctl(usb_buf, &ctl_sts, sizeof(ctl_sts), 0, false);
|
||||
}
|
||||
|
||||
int RealtekARGBController::get_custled(unsigned char* cust, unsigned int cust_len)
|
||||
{
|
||||
int ret = 0;
|
||||
int buf_len = REALTEK_ARGB_HID_DATALEN_CH1;
|
||||
unsigned int addr = 0xAC004000;
|
||||
unsigned int offset = 0x800;
|
||||
unsigned char* usb_buf = (unsigned char*)calloc(buf_len + offset, 1);// will release in usb_hid_ioctl function
|
||||
unsigned char* data = (unsigned char*)calloc(buf_len, 1);
|
||||
|
||||
memset(data, 0x00, buf_len);
|
||||
memset(usb_buf, 0x00, buf_len + offset);
|
||||
memcpy(usb_buf, hid_get_packet, sizeof(hid_get_packet));
|
||||
usb_buf[0x13] = 0x92;
|
||||
memcpy(&usb_buf[0x17], &addr, sizeof(addr));
|
||||
ret = usb_hid_ioctl(usb_buf, data, buf_len, offset, true);
|
||||
if(!ret)
|
||||
{
|
||||
memcpy(cust, &data[70], cust_len);
|
||||
}
|
||||
free(data);
|
||||
return ret;
|
||||
}
|
||||
|
||||
int RealtekARGBController::get_argbctl_hdr()
|
||||
{
|
||||
int buf_len = REALTEK_ARGB_HID_DATALEN_CH1;
|
||||
unsigned char* usb_buf = (unsigned char*)calloc(buf_len, 1);// will release in usb_hid_ioctl function
|
||||
|
||||
memset(usb_buf, 0x00, buf_len);
|
||||
memcpy(usb_buf, hid_get_packet, sizeof(hid_get_packet));
|
||||
usb_buf[0x13] = 0xCC;
|
||||
usb_buf[0x14] = 0x02;
|
||||
return usb_hid_ioctl(usb_buf, argbctl_hdr, REALTEK_ARGB_CTL_HDR_SIZE, 0, true);
|
||||
}
|
||||
|
||||
int RealtekARGBController::set_argbctl_hdr()
|
||||
{
|
||||
int buf_len = REALTEK_ARGB_HID_DATALEN_CH1;
|
||||
unsigned char* usb_buf = (unsigned char*)calloc(buf_len, 1);// will release in usb_hid_send/usb_hid_get function
|
||||
|
||||
memset(usb_buf, 0x00, buf_len);
|
||||
memcpy(usb_buf, hid_set_packet, sizeof(hid_set_packet));
|
||||
usb_buf[0x13] = 0x4C;
|
||||
usb_buf[0x14] = 0x02;
|
||||
return usb_hid_ioctl(usb_buf, argbctl_hdr, REALTEK_ARGB_CTL_HDR_SIZE, 0, false);
|
||||
}
|
||||
|
||||
int RealtekARGBController::get_argbctl_data()
|
||||
{
|
||||
int ret = 0;
|
||||
int buf_len = REALTEK_ARGB_HID_DATALEN_CH1;
|
||||
int offset = REALTEK_ARGB_CTL_HDR_SIZE;
|
||||
unsigned char* usb_buf;
|
||||
|
||||
for(int i = 0; i < REALTEK_ARGB_NUM_ARGB_GRP; i++)
|
||||
{
|
||||
usb_buf = (unsigned char*)calloc(buf_len, 1);// will release in usb_hid_send/usb_hid_get function
|
||||
memset(usb_buf, 0x00, buf_len);
|
||||
memcpy(usb_buf, hid_get_packet, sizeof(hid_get_packet));
|
||||
usb_buf[0x13] = 0xCC;
|
||||
usb_buf[0x14] = 0x02;
|
||||
memcpy(&usb_buf[0x17], &offset, sizeof(offset));
|
||||
ret = usb_hid_ioctl(usb_buf, argbctl_data[i], REALTEK_ARGB_CTL_DATA_SIZE, 0, true);
|
||||
offset += REALTEK_ARGB_CTL_DATA_SIZE;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
int RealtekARGBController::set_argbctl_data(unsigned char grp_num)
|
||||
{
|
||||
int buf_len = REALTEK_ARGB_HID_DATALEN_CH1;
|
||||
int offset = REALTEK_ARGB_CTL_HDR_SIZE + REALTEK_ARGB_CTL_DATA_SIZE * grp_num;
|
||||
unsigned char* usb_buf;
|
||||
|
||||
usb_buf = (unsigned char*)calloc(buf_len, 1);// will release in usb_hid_send/usb_hid_get function
|
||||
memset(usb_buf, 0x00, buf_len);
|
||||
memcpy(usb_buf, hid_set_packet, sizeof(hid_set_packet));
|
||||
usb_buf[0x13] = 0x4C;
|
||||
usb_buf[0x14] = 0x02;
|
||||
memcpy(&usb_buf[0x17], &offset, sizeof(offset));
|
||||
return usb_hid_ioctl(usb_buf, argbctl_data[grp_num], REALTEK_ARGB_CTL_DATA_SIZE, 0, false);
|
||||
}
|
||||
|
||||
int RealtekARGBController::set_eff_id(unsigned char grp_num, unsigned short effid)
|
||||
{
|
||||
memcpy(argbctl_data[grp_num], &effid, sizeof(effid));
|
||||
return 0;
|
||||
}
|
||||
|
||||
int RealtekARGBController::set_p_color(unsigned char grp_num, RGBColor color)
|
||||
{
|
||||
memcpy(argbctl_data[grp_num] + 8, &color, sizeof(color));
|
||||
return 0;
|
||||
}
|
||||
|
||||
int RealtekARGBController::set_s_color(unsigned char grp_num, RGBColor color)
|
||||
{
|
||||
memcpy(argbctl_data[grp_num] + 12, &color, sizeof(color));
|
||||
return 0;
|
||||
}
|
||||
|
||||
int RealtekARGBController::set_cycle(unsigned char grp_num, unsigned short cycle)
|
||||
{
|
||||
memcpy(argbctl_data[grp_num] + 2, &cycle, sizeof(cycle));
|
||||
return 0;
|
||||
}
|
||||
|
||||
int RealtekARGBController::set_ramp(unsigned char grp_num, unsigned short ramp)
|
||||
{
|
||||
memcpy(argbctl_data[grp_num] + 4, &ramp, sizeof(ramp));
|
||||
return 0;
|
||||
}
|
||||
|
||||
int RealtekARGBController::set_stable(unsigned char grp_num, unsigned short stable)
|
||||
{
|
||||
memcpy(argbctl_data[grp_num] + 6, &stable, sizeof(stable));
|
||||
return 0;
|
||||
}
|
||||
|
||||
int RealtekARGBController::set_subcmd(unsigned char grp_num, int subcmd)
|
||||
{
|
||||
memcpy(argbctl_data[grp_num] + 16, &subcmd, sizeof(subcmd));
|
||||
return 0;
|
||||
}
|
||||
|
||||
int RealtekARGBController::set_direct(unsigned char* color, int color_num, unsigned char grp_num)
|
||||
{
|
||||
int buf_len = REALTEK_ARGB_HID_DATALEN_CH1;
|
||||
int data_len = color_num * REALTEK_ARGB_COLOR_DEPTH;
|
||||
unsigned char* usb_buf = (unsigned char*)calloc(buf_len, 1);// will release in usb_hid_ioctl function
|
||||
|
||||
memset(usb_buf, 0x00, buf_len);
|
||||
memcpy(usb_buf, hid_set_packet, sizeof(hid_set_packet));
|
||||
usb_buf[0x13] = 0x4C;
|
||||
usb_buf[0x14] = 0x03;
|
||||
usb_buf[0x15] = REALTEK_ARGB_SYNC_METHOD_OPENRGB;
|
||||
usb_buf[0x16] = grp_num;
|
||||
memcpy(&usb_buf[0x17], &color_num, sizeof(color_num));
|
||||
return usb_hid_ioctl(usb_buf, color, data_len, 0, false);
|
||||
}
|
||||
|
||||
int RealtekARGBController::get_flash_argbctl_hdr(unsigned char* data)
|
||||
{
|
||||
int buf_len = REALTEK_ARGB_HID_DATALEN_CH1;
|
||||
unsigned int addr = 0xAC000000;
|
||||
unsigned char* usb_buf = (unsigned char*)calloc(buf_len, 1);// will release in usb_hid_send/usb_hid_get function
|
||||
|
||||
memset(usb_buf, 0x00, buf_len);
|
||||
memcpy(usb_buf, hid_get_packet, sizeof(hid_get_packet));
|
||||
usb_buf[0x13] = 0x92;
|
||||
memcpy(&usb_buf[0x17], &addr, sizeof(addr));
|
||||
return usb_hid_ioctl(usb_buf, data, buf_len, 0, true);
|
||||
}
|
||||
|
||||
int RealtekARGBController::set_flash_argbctl_hdr(unsigned int offset, unsigned int data_len)
|
||||
{
|
||||
int ret = 0;
|
||||
int buf_len = REALTEK_ARGB_HID_DATALEN_CH1;
|
||||
unsigned int addr = 0xAC000000;
|
||||
unsigned char* usb_buf = (unsigned char*)calloc(buf_len, 1);// will release in usb_hid_send/usb_hid_get function
|
||||
unsigned char* data = (unsigned char*)calloc(buf_len, 1);
|
||||
memset(data, 0, buf_len);
|
||||
|
||||
ret = get_flash_argbctl_hdr(data);
|
||||
if(!ret)
|
||||
{
|
||||
memset(usb_buf, 0x00, buf_len);
|
||||
memcpy(usb_buf, hid_set_packet, sizeof(hid_set_packet));
|
||||
usb_buf[0x13] = 0x10;
|
||||
memcpy(&usb_buf[0x17], &addr, sizeof(addr));
|
||||
ret = usb_hid_ioctl(usb_buf, (unsigned char*)&addr, sizeof(addr), 0, false);
|
||||
|
||||
usb_buf = (unsigned char*)calloc(buf_len, 1);// will release in usb_hid_send/usb_hid_get function
|
||||
memset(usb_buf, 0x00, buf_len);
|
||||
memcpy(usb_buf, hid_set_packet, sizeof(hid_set_packet));
|
||||
usb_buf[0x13] = 0x11;
|
||||
memcpy(data + offset, argbctl_hdr + offset, data_len);
|
||||
ret = usb_hid_ioctl(usb_buf, data, buf_len, 0, false);
|
||||
}
|
||||
free(data);
|
||||
return ret;
|
||||
}
|
||||
|
||||
int RealtekARGBController::set_argb_direct(int grp_num, std::vector<RGBColor> color_buf, unsigned short brightness)
|
||||
{
|
||||
int ret = -1;
|
||||
size_t color_num = color_buf.size();
|
||||
size_t buf_len = color_num * REALTEK_ARGB_COLOR_DEPTH;
|
||||
unsigned char* buf;
|
||||
std::lock_guard<std::mutex> lock(my_mutex);
|
||||
|
||||
if(color_num == 0)
|
||||
{
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if(appctl[grp_num] != REALTEK_ARGB_LED_CTL_APP)
|
||||
{
|
||||
ret = set_appctl(grp_num, REALTEK_ARGB_LED_CTL_APP);
|
||||
if(ret)
|
||||
{
|
||||
goto exit;
|
||||
}
|
||||
else
|
||||
{
|
||||
appctl[grp_num] = REALTEK_ARGB_LED_CTL_APP;
|
||||
}
|
||||
}
|
||||
|
||||
if(prev_bright[grp_num] != brightness)
|
||||
{
|
||||
prev_bright[grp_num] = brightness;
|
||||
ret = set_argb_brightness(grp_num, brightness << 8);
|
||||
if(ret)
|
||||
{
|
||||
goto exit;
|
||||
}
|
||||
}
|
||||
|
||||
buf = (uint8_t*)malloc(buf_len);
|
||||
memset(buf, 0, buf_len);
|
||||
for(size_t i = 0; i < color_num; i++)
|
||||
{
|
||||
buf[i * REALTEK_ARGB_COLOR_DEPTH + 0] = RGBGetRValue(color_buf[i]);
|
||||
buf[i * REALTEK_ARGB_COLOR_DEPTH + 1] = RGBGetGValue(color_buf[i]);
|
||||
buf[i * REALTEK_ARGB_COLOR_DEPTH + 2] = RGBGetBValue(color_buf[i]);
|
||||
}
|
||||
ret = set_direct(buf, (int)color_num, grp_num);
|
||||
free(buf);
|
||||
exit:
|
||||
return ret;
|
||||
}
|
||||
|
||||
int RealtekARGBController::set_argb_effect(int grp_num, uint8_t mode, std::vector<RGBColor> color_buf, struct RealtekARGBControllerSetEffParam* param)
|
||||
{
|
||||
int ret = -1;
|
||||
int cycle = MathUtils::IntInterpolate(REALTEK_ARGB_CYCLE_MAX, REALTEK_ARGB_CYCLE_MIN, 0, REALTEK_ARGB_SPEED_MAX, param->speed);
|
||||
std::lock_guard<std::mutex> lock(my_mutex);
|
||||
|
||||
if(mode == REALTEK_ARGB_EFF_ALWAYS_ON || mode == REALTEK_ARGB_EFF_STACK)
|
||||
{
|
||||
cycle = 0;
|
||||
}
|
||||
|
||||
if(color_buf.size() >= 1)
|
||||
{
|
||||
set_p_color(grp_num, color_buf[0]);
|
||||
}
|
||||
if(color_buf.size() >= 2)
|
||||
{
|
||||
set_s_color(grp_num, color_buf[1]);
|
||||
}
|
||||
|
||||
set_eff_id(grp_num, mode);
|
||||
set_cycle(grp_num, cycle);
|
||||
set_ramp(grp_num, 0);
|
||||
set_stable(grp_num, 0);
|
||||
set_subcmd(grp_num, (param->dir || param->random_color) ? 0x1 : 0x0);
|
||||
set_argb_brightness(grp_num, param->brightness << 8);
|
||||
set_argbctl_data(grp_num);
|
||||
|
||||
ret = set_appctl(grp_num, REALTEK_ARGB_LED_CTL_FW);
|
||||
if(!ret)
|
||||
{
|
||||
appctl[grp_num] = REALTEK_ARGB_LED_CTL_FW;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int RealtekARGBController::set_argb_num(int grp_num, unsigned short new_num)
|
||||
{
|
||||
memcpy(&argbctl_hdr[32 + grp_num * sizeof(new_num)], &new_num, sizeof(new_num));
|
||||
set_flash_argbctl_hdr(32 + grp_num * sizeof(new_num), sizeof(new_num));
|
||||
return 0;
|
||||
}
|
||||
|
||||
int RealtekARGBController::device_reboot()
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(my_mutex);
|
||||
int ret = 0;
|
||||
int buf_len = REALTEK_ARGB_HID_DATALEN_CH1;
|
||||
int reboot_type = 1;
|
||||
unsigned char* usb_buf = (unsigned char*)calloc(buf_len, 1);// will release in usb_hid_send/usb_hid_get function
|
||||
|
||||
memset(usb_buf, 0x00, buf_len);
|
||||
memcpy(usb_buf, hid_set_packet, sizeof(hid_set_packet));
|
||||
usb_buf[0x13] = 0x30;
|
||||
usb_buf[0x14] = reboot_type;
|
||||
ret = usb_hid_ioctl(usb_buf, (unsigned char*)&reboot_type, sizeof(reboot_type), 0, false);
|
||||
|
||||
hid_close(hdev);
|
||||
hdev = NULL;
|
||||
return ret;
|
||||
}
|
||||
|
||||
void RealtekARGBController::device_rescan_trigger()
|
||||
{
|
||||
keepalive_thread_run = true;
|
||||
keepalive_thread = new std::thread(&RealtekARGBController::KeepaliveThreadFunction, this);
|
||||
}
|
||||
|
||||
void RealtekARGBController::device_rescan()
|
||||
{
|
||||
hid_device_info* info_full = hid_enumerate(REALTEK_ARGB_VID, REALTEK_ARGB_PID);
|
||||
hid_device_info* info_temp = info_full;
|
||||
|
||||
while(info_temp)
|
||||
{
|
||||
if(info_temp->vendor_id == REALTEK_ARGB_VID &&
|
||||
info_temp->product_id == REALTEK_ARGB_PID &&
|
||||
info_temp->usage == REALTEK_ARGB_HID2SCSI_USAGE &&
|
||||
info_temp->usage_page == REALTEK_ARGB_HID2SCSI_PG)
|
||||
{
|
||||
hid_device* dev_temp = hid_open_path(info_temp->path);
|
||||
if(dev_temp)
|
||||
{
|
||||
hdev = dev_temp;
|
||||
if(get_support_openrgb())
|
||||
{
|
||||
device_init();
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
hid_close(hdev);
|
||||
hdev = NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
info_temp = info_temp->next;
|
||||
}
|
||||
hid_free_enumeration(info_full);
|
||||
}
|
||||
Reference in New Issue
Block a user