diff --git a/Controllers/RtkArgbController/RGBController_RtkArgb.cpp b/Controllers/RtkArgbController/RGBController_RtkArgb.cpp new file mode 100644 index 000000000..f16e03dc0 --- /dev/null +++ b/Controllers/RtkArgbController/RGBController_RtkArgb.cpp @@ -0,0 +1,376 @@ +/*---------------------------------------------------------*\ +| RGBController_RtkArgb.cpp | +| | +| RGBController for Realtek Argb ICs | +| | +| | +| This file is part of the OpenRGB project | +| SPDX-License-Identifier: GPL-2.0-only | +\*---------------------------------------------------------*/ +#ifndef __FreeBSD__ + +#include "RGBController_RtkArgb.h" + +/**------------------------------------------------------------------*\ + @name Realtek Argb Device + @category Keyboard,LEDStrip + @type USB + @save :x: + @direct :rotating_light: + @effects :white_check_mark: + @detectors DetectRtkArgbControllers + @comment +\*-------------------------------------------------------------------*/ + +RGBController_RtkArgb::RGBController_RtkArgb(RtkArgbWrapper *_wrapper) +{ + this->wrapper = _wrapper; + + name = wrapper->get_dev_name(); + vendor = wrapper->get_manu_name(); + location = wrapper->get_dev_loc(); + serial = wrapper->get_sn(); + version = wrapper->get_fw_ver(); + description = vendor + "Argb Device"; + type = DEVICE_TYPE_LEDSTRIP; + + SetupStrip(); + SetupZones(); +} + +void RGBController_RtkArgb::SetupStrip() +{ + int brightness = wrapper->get_argb_brightness(0) >> 8; + + mode Direct; + Direct.name = "Direct"; + Direct.value = EFF_NULL; + Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS; + Direct.color_mode = MODE_COLORS_PER_LED; + Direct.brightness_min = 0; + Direct.brightness_max = 255; + Direct.brightness = brightness; + modes.push_back(Direct); + + mode Static; + Static.name = "Static"; + Static.value = EFF_ALWAYS_ON; + Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS; + Static.colors_min = 1; + Static.colors_max = 1; + Static.color_mode = MODE_COLORS_MODE_SPECIFIC; + Static.colors.resize(1); + Static.brightness_min = 0; + Static.brightness_max = 255; + Static.brightness = brightness; + modes.push_back(Static); + + mode Blink; + Blink.name = "Blink"; + Blink.value = EFF_BLINK; + Blink.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED; + Blink.speed_min = RTK_ARGB_SPEED_MIN; + Blink.speed_max = RTK_ARGB_SPEED_MAX; + Blink.speed = RTK_ARGB_SPEED_NORMAL; + Blink.colors_min = 1; + Blink.colors_max = 2; + Blink.color_mode = MODE_COLORS_MODE_SPECIFIC; + Blink.colors.resize(2); + Blink.brightness_min = 0; + Blink.brightness_max = 255; + Blink.brightness = brightness; + modes.push_back(Blink); + + mode Breathing; + Breathing.name = "Breathing"; + Breathing.value = EFF_BREATH; + Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED; + Breathing.speed_min = RTK_ARGB_SPEED_MIN; + Breathing.speed_max = RTK_ARGB_SPEED_MAX; + Breathing.speed = RTK_ARGB_SPEED_NORMAL; + Breathing.colors_min = 1; + Breathing.colors_max = 2; + Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC; + Breathing.colors.resize(2); + Breathing.brightness_min = 0; + Breathing.brightness_max = 255; + Breathing.brightness = brightness; + modes.push_back(Breathing); + + mode Spectrum; + Spectrum.name = "Spectrum"; + Spectrum.value = EFF_SPECTRUM; + Spectrum.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED; + Spectrum.speed_min = RTK_ARGB_SPEED_MIN; + Spectrum.speed_max = RTK_ARGB_SPEED_MAX; + Spectrum.speed = RTK_ARGB_SPEED_NORMAL; + Spectrum.color_mode = MODE_COLORS_NONE; + Spectrum.brightness_min = 0; + Spectrum.brightness_max = 255; + Spectrum.brightness = brightness; + modes.push_back(Spectrum); + + mode Scroll; + Scroll.name = "Scroll"; + Scroll.value = EFF_SCROLL; + Scroll.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED; + Scroll.speed_min = RTK_ARGB_SPEED_MIN; + Scroll.speed_max = RTK_ARGB_SPEED_MAX; + Scroll.speed = RTK_ARGB_SPEED_NORMAL; + Scroll.colors_min = 1; + Scroll.colors_max = 2; + Scroll.color_mode = MODE_COLORS_MODE_SPECIFIC; + Scroll.colors.resize(2); + Scroll.brightness_min = 0; + Scroll.brightness_max = 255; + Scroll.brightness = brightness; + modes.push_back(Scroll); + + mode RainbowScroll; + RainbowScroll.name = "RainbowScroll"; + RainbowScroll.value = EFF_RAINBOW_SCROLL; + RainbowScroll.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED; + RainbowScroll.speed_min = RTK_ARGB_SPEED_MIN; + RainbowScroll.speed_max = RTK_ARGB_SPEED_MAX; + RainbowScroll.speed = RTK_ARGB_SPEED_NORMAL; + RainbowScroll.color_mode = MODE_COLORS_NONE; + RainbowScroll.brightness_min = 0; + RainbowScroll.brightness_max = 255; + RainbowScroll.brightness = brightness; + modes.push_back(RainbowScroll); + + mode RunningWater; + RunningWater.name = "RunningWater"; + RunningWater.value = EFF_RUNNING_WATER; + RunningWater.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED; + RunningWater.speed_min = RTK_ARGB_SPEED_MIN; + RunningWater.speed_max = RTK_ARGB_SPEED_MAX; + RunningWater.speed = RTK_ARGB_SPEED_NORMAL; + RunningWater.colors_min = 1; + RunningWater.colors_max = 2; + RunningWater.color_mode = MODE_COLORS_MODE_SPECIFIC; + RunningWater.colors.resize(2); + RunningWater.brightness_min = 0; + RunningWater.brightness_max = 255; + RunningWater.brightness = brightness; + modes.push_back(RunningWater); + + mode Sliding; + Sliding.name = "Sliding"; + Sliding.value = EFF_SLIDING; + Sliding.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED; + Sliding.speed_min = RTK_ARGB_SPEED_MIN; + Sliding.speed_max = RTK_ARGB_SPEED_MAX; + Sliding.speed = RTK_ARGB_SPEED_NORMAL; + Sliding.colors_min = 1; + Sliding.colors_max = 2; + Sliding.color_mode = MODE_COLORS_MODE_SPECIFIC; + Sliding.colors.resize(2); + Sliding.brightness_min = 0; + Sliding.brightness_max = 255; + Sliding.brightness = brightness; + modes.push_back(Sliding); + + mode NewtonCradle; + NewtonCradle.name = "NewtonCradle"; + NewtonCradle.value = EFF_NEWTON_CRADLE; + NewtonCradle.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED; + NewtonCradle.speed_min = RTK_ARGB_SPEED_MIN; + NewtonCradle.speed_max = RTK_ARGB_SPEED_MAX; + NewtonCradle.speed = RTK_ARGB_SPEED_NORMAL; + NewtonCradle.colors_min = 1; + NewtonCradle.colors_max = 2; + NewtonCradle.color_mode = MODE_COLORS_MODE_SPECIFIC; + NewtonCradle.colors.resize(2); + NewtonCradle.brightness_min = 0; + NewtonCradle.brightness_max = 255; + NewtonCradle.brightness = brightness; + modes.push_back(NewtonCradle); + + mode Meteor; + Meteor.name = "Meteor"; + Meteor.value = EFF_METEOR; + Meteor.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED; + Meteor.speed_min = RTK_ARGB_SPEED_MIN; + Meteor.speed_max = RTK_ARGB_SPEED_MAX; + Meteor.speed = RTK_ARGB_SPEED_NORMAL; + Meteor.colors_min = 1; + Meteor.colors_max = 2; + Meteor.color_mode = MODE_COLORS_MODE_SPECIFIC; + Meteor.colors.resize(2); + Meteor.brightness_min = 0; + Meteor.brightness_max = 255; + Meteor.brightness = brightness; + modes.push_back(Meteor); +} + +RGBController_RtkArgb::~RGBController_RtkArgb() +{ + delete wrapper; +} + +void RGBController_RtkArgb::SetupZones() +{ + uint16_t idx = 0, argb_num = 0; + int fix_grps = 0, num_fixgrp = 0, argb_num_fixgrp = 0; + + leds.clear(); + colors.clear(); + zones.clear(); + valid_grp.clear(); + fix_grps = wrapper->get_fix_grps(); + + for (int grp_num = 0; grp_num < NUM_ARGB_GRP; grp_num++) + { + if (wrapper->get_argb_num(grp_num) > 0) + { + valid_grp.push_back(grp_num); + if (fix_grps & (0x1 << grp_num)) + { + num_fixgrp++; + argb_num_fixgrp += wrapper->get_argb_num(grp_num); + } + } + } + + zones.resize(valid_grp.size()); + for (int grp_num : valid_grp) + { + argb_num = wrapper->get_argb_num(grp_num); + if (argb_num <= 0) + continue; + + zones[idx].leds_count = argb_num; + zones[idx].name = "strip " + std::to_string(idx + 1); + zones[idx].type = ZONE_TYPE_LINEAR; + if (fix_grps & (0x1 << grp_num)) + { + zones[idx].leds_min = argb_num; + zones[idx].leds_max = argb_num; + } + else + { + zones[idx].leds_min = 1; + zones[idx].leds_max = (ARGBCTL_ARGB_MAX - argb_num_fixgrp) / (valid_grp.size() - num_fixgrp); + } + zones[idx].matrix_map = NULL; + + for(unsigned int led_idx = 0; led_idx < zones[idx].leds_count; led_idx++) + { + led myled; + myled.name = zones[idx].name + " led_"; + myled.name.append(std::to_string(led_idx + 1)); + leds.push_back(myled); + } + idx++; + } + SetupColors(); +} + +void RGBController_RtkArgb::ResizeZone(int zone, int new_size) +{ + if((size_t) zone >= zones.size()) + { + return; + } + + if(((unsigned int)new_size >= zones[zone].leds_min) && ((unsigned int)new_size <= zones[zone].leds_max)) + { + uint16_t orig_num = wrapper->get_argb_num(valid_grp[zone]); + std::vector rtk_colors(orig_num, 0); + uint16_t total_argb_num = 0; + for (int grp_num = 0; grp_num < NUM_ARGB_GRP; grp_num++) + { + if (grp_num == valid_grp[zone]) + total_argb_num += new_size; + else + total_argb_num += wrapper->get_argb_num(grp_num); + } + if (total_argb_num > ARGBCTL_ARGB_MAX) + return; + + wrapper->set_argb_direct(valid_grp[zone], rtk_colors, 0xFF); + wrapper->set_argb_num(valid_grp[zone], new_size); + wrapper->argb_reinit(); + + SetupZones(); + } +} + +void RGBController_RtkArgb::DeviceUpdateLEDs() +{ + for(std::size_t zone_idx = 0; zone_idx < zones.size(); zone_idx++) + { + if(zones[zone_idx].leds_count > 0) + { + UpdateZoneLEDs(zone_idx); + } + } +} + +void RGBController_RtkArgb::UpdateZoneLEDs(int zone) +{ + unsigned short brightness = 0xFF; + mode& curr_mode = modes[active_mode]; + std::vector color_buf; + + if(curr_mode.color_mode == MODE_COLORS_PER_LED && + curr_mode.value == EFF_NULL) //direct mode + { + if (curr_mode.flags & MODE_FLAG_HAS_BRIGHTNESS) + brightness = curr_mode.brightness; + + color_buf.resize(zones[zone].leds_count); + for (int i = 0; i < zones[zone].leds_count; i++) + color_buf[i] = zones[zone].colors[i]; + wrapper->set_argb_direct(valid_grp[zone], color_buf, brightness); + } + else + UpdateSingleLED(zone); +} + +void RGBController_RtkArgb::UpdateSingleLED(int zone) +{ + unsigned char speed = RTK_ARGB_SPEED_NORMAL; + unsigned char dir = 0; + unsigned short brightness = 0xFF; + mode& curr_mode = modes[active_mode]; + std::vector rtk_colors = curr_mode.colors; + + if(curr_mode.flags & MODE_FLAG_HAS_SPEED) + { + speed = curr_mode.speed; + } + if (curr_mode.flags & MODE_FLAG_HAS_BRIGHTNESS) + { + brightness = curr_mode.brightness; + } + if(curr_mode.flags & MODE_FLAG_HAS_DIRECTION_LR) + { + if(curr_mode.direction == MODE_DIRECTION_RIGHT) + { + dir = 1; + } + } + + if (curr_mode.color_mode == MODE_COLORS_PER_LED) + { + rtk_colors = colors; + } + else if(curr_mode.color_mode == MODE_COLORS_NONE) + { + rtk_colors.clear(); + } + + wrapper->set_argb_effect(valid_grp[zone], curr_mode.value, rtk_colors, speed, brightness); +} + +void RGBController_RtkArgb::DeviceUpdateMode() +{ + if(modes[active_mode].value != EFF_NULL) + { + DeviceUpdateLEDs(); + } +} + +#endif diff --git a/Controllers/RtkArgbController/RGBController_RtkArgb.h b/Controllers/RtkArgbController/RGBController_RtkArgb.h new file mode 100644 index 000000000..9d1dac84d --- /dev/null +++ b/Controllers/RtkArgbController/RGBController_RtkArgb.h @@ -0,0 +1,24 @@ +#pragma once + +#include "RGBController.h" +#include "RtkArgbWrapper.h" + +class RGBController_RtkArgb : public RGBController +{ +public: + RGBController_RtkArgb(RtkArgbWrapper *_wrapper); + ~RGBController_RtkArgb(); + + void SetupStrip(); + + void SetupZones(); + void ResizeZone(int zone, int new_size); + void DeviceUpdateLEDs(); + void UpdateZoneLEDs(int zone); + void UpdateSingleLED(int zone); + void DeviceUpdateMode(); + +private: + RtkArgbWrapper *wrapper; + std::vector valid_grp; +}; diff --git a/Controllers/RtkArgbController/RtkArgbControllerDetect.cpp b/Controllers/RtkArgbController/RtkArgbControllerDetect.cpp new file mode 100644 index 000000000..9f13925b2 --- /dev/null +++ b/Controllers/RtkArgbController/RtkArgbControllerDetect.cpp @@ -0,0 +1,67 @@ +#ifndef __FreeBSD__ + +#include "Detector.h" +#include "RGBController.h" +#include "RGBController_RtkArgb.h" + +#define RTK_HID2SCSI_PG 0xFF00 +#define RTK_HID2SCSI_USAGE 0x0001 + +/******************************************************************************************\ +* * +* DetectRtkArgbControllers * +* * +* Tests the USB address to see if an Realtek Argb controller exists there * +* * +\******************************************************************************************/ +void DetectRtkArgbControllers(hid_device_info *info, const std::string &name) +{ + RGBController_RtkArgb *controller = NULL; + RtkArgbWrapper *wrapper = NULL; + static struct argb_device *dev = NULL; + argbCtl *argb_ctl = NULL; + int ret = -1; + + dev = argb_path_open(info->path, BRINTF_TYPE_HID, NULL); + if (!dev) { + goto exit; + } + + if (!led_argb_get_ic_support_sync_light(dev, SYNC_METHOD_OPENRGB)) { + goto exit; + } + + if (bridge_write_unlock(dev)) { + goto exit; + } + + argb_ctl = (argbCtl*)malloc(sizeof(argbCtl)); + if (!argb_ctl) { + goto exit; + } + + memset(argb_ctl, 0, sizeof(argbCtl)); + if (led_argb_init(dev, argb_ctl)) { + free(argb_ctl); + goto exit; + } + argb_ctl->sync_method = SYNC_METHOD_OPENRGB; + + wrapper = new RtkArgbWrapper(dev, argb_ctl, info); + controller = new RGBController_RtkArgb(wrapper); + if(controller->type != DEVICE_TYPE_UNKNOWN) + { + ResourceManager::get()->RegisterRGBController(controller); + } + else + { + delete wrapper; + delete controller; + } +exit: + return; +} + +REGISTER_HID_DETECTOR_PU ("RTL9209", DetectRtkArgbControllers, RTK_ARGB_VID, RTK_ARGB_PID, RTK_HID2SCSI_PG, RTK_HID2SCSI_USAGE); + +#endif diff --git a/Controllers/RtkArgbController/RtkArgbWrapper.cpp b/Controllers/RtkArgbController/RtkArgbWrapper.cpp new file mode 100644 index 000000000..06356be65 --- /dev/null +++ b/Controllers/RtkArgbController/RtkArgbWrapper.cpp @@ -0,0 +1,386 @@ +#ifndef __FreeBSD__ + +#include "RtkArgbWrapper.h" + +static struct usb_id id[] = { + {RTK_ARGB_VID, RTK_ARGB_PID}, + }; + +RtkArgbWrapper::RtkArgbWrapper(struct argb_device *dev, argbCtl *argbctl, hid_device_info *info) +{ + this->adev = dev; + this->argb_ctl = argbctl; + this->hidinfo = info; + for (int i = 0; i < NUM_ARGB_GRP; i++) + { + appctl[i] = LED_CTL_FW; + led_argb_set_appctl(adev, i, appctl[i]); + } +} + +RtkArgbWrapper::~RtkArgbWrapper() +{ + if (adev) + { + for (int i = 0; i < NUM_ARGB_GRP; i++) + { + appctl[i] = LED_CTL_LAMP; + led_argb_set_appctl(adev, i, appctl[i]); + } + argb_dev_close(adev); + adev = NULL; + } + + if (argb_ctl) + { + led_argb_deinit(argb_ctl); + free(argb_ctl); + argb_ctl = NULL; + } +} + +void RtkArgbWrapper::argb_reinit() +{ + struct argb_dev_info *devs = NULL; + std::lock_guard lock(my_mutex); + int retry_num = 3; + +retry: + if (retry_num == 0) + goto exit; + if (devs) + argb_dev_free_scan(devs); + + if (argb_ctl) + { + if (adev) + { + bridge_disconnect(adev, 1); + argb_dev_close(adev); + adev = NULL; + } + QThread::msleep(1000); + + devs = argb_dev_scan(id, ARRAY_SIZE(id)); +opendev: + if (!devs) { + retry_num--; + goto retry; + } + + adev = argb_path_open(devs->path, BRINTF_TYPE_HID, NULL); + if (!adev) { + devs = devs->next; + goto opendev; + } + + if (!led_argb_get_ic_support_sync_light(adev, SYNC_METHOD_OPENRGB)) { + devs = devs->next; + goto opendev; + } + + if (bridge_write_unlock(adev)) { + devs = devs->next; + goto opendev; + } + + if (led_argb_init(adev, argb_ctl)) { + devs = devs->next; + goto opendev; + } + + argb_ctl->sync_method = SYNC_METHOD_OPENRGB; + for (int i = 0; i < NUM_ARGB_GRP; i++) + { + appctl[i] = LED_CTL_FW; + led_argb_set_appctl(adev, i, appctl[i]); + } + } +exit: + if (devs) + argb_dev_free_scan(devs); + return; +} + +static std::string int_to_hex_str(uint32_t value) +{ + char hex_str[20] = {0}; + snprintf(hex_str, sizeof(hex_str), "%X", value); + return std::string(hex_str); +} + +std::string RtkArgbWrapper::get_manu_name() +{ + return wcharToString(hidinfo->manufacturer_string); +} + +std::string RtkArgbWrapper::get_product_name() +{ + return wcharToString(hidinfo->product_string); +} + +std::string RtkArgbWrapper::get_sn() +{ + return wcharToString(hidinfo->serial_number); +} + +std::string RtkArgbWrapper::get_dev_loc() +{ + return hidinfo->path; +} + +std::string RtkArgbWrapper::get_fw_ver() +{ + struct bridge_fw_version fw_ver; + std::string ver = ""; + bridge_get_fw_ver(adev, &fw_ver); + 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 RtkArgbWrapper::get_ic_uuid() +{ + uint32_t uuid = 0; + std::string uuid_str = ""; + + if (bridge_get_uuid(adev, (uint8_t *)&uuid)) + goto exit; + + uuid_str = int_to_hex_str(uuid); +exit: + return uuid_str; +} + +std::string RtkArgbWrapper::get_dev_name() +{ + PGINFO info = { 0 }; + std::string devname = get_product_name(); + + if (!pg_read(adev, &info)) + { + if (info.customized_led[5] == CUST_DEVNAME_MANU_UUID) + { + devname = get_manu_name() + get_ic_uuid(); + } + } + return devname; +} + +int RtkArgbWrapper::get_fix_grps() +{ + int fix_grps = 0; + PGINFO info = { 0 }; + + if (!pg_read(adev, &info)) + { + fix_grps = info.customized_led[4]; + } + return fix_grps; +} + +int RtkArgbWrapper::get_argb_num(int grp_num) +{ + int ret = -1; + uint16_t num_rgb = 0; + ret = led_argb_get_rgb_num(adev, argb_ctl, grp_num, &num_rgb); + if (ret) + { + num_rgb = 0; + goto exit; + } +exit: + return num_rgb; +} + +int RtkArgbWrapper::get_argb_brightness(int grp_num) +{ + int ret = -1; + uint16_t bright = 0; + ret = led_argb_get_bright(adev, argb_ctl, grp_num, &bright); + if (ret) + { + bright = 0; + goto exit; + } +exit: + return bright; +} + +int RtkArgbWrapper::set_argb_num(int grp_num, int new_num) +{ + int group, ret = 0; + uint16_t i, argb_num = new_num; + LampPosition *poses = NULL; + struct LampArrayAttributesReport laar; + struct LampAttributesResponseReport larr; + std::lock_guard lock(my_mutex); + + for (group = 0; group < NUM_ARGB_GRP; group++) + { + if (group == grp_num) + argb_num = new_num; + else + led_argb_get_rgb_num(adev, argb_ctl, group, &argb_num); + + if (led_argb_set_rgb_num(adev, argb_ctl, group, argb_num, false)) + continue; + + if (poses) + { + free(poses); + poses = NULL; + } + poses = (LampPosition*)malloc(sizeof(LampPosition) * argb_num); + memset(poses, 0, sizeof(LampPosition) * argb_num); + memcpy(&laar, argb_ctl->mdl[group].laar, sizeof(laar)); + memcpy(&larr, argb_ctl->mdl[group].larr, sizeof(larr)); + laar.LampCount = argb_num; + for (i = 0; i < argb_num; i++) + { + poses[i].XInMicrometers = i + argb_ctl->mdl[group].poses[0].XInMicrometers; + poses[i].YInMicrometers = argb_ctl->mdl[group].poses[0].YInMicrometers; + poses[i].ZInMicrometers = argb_ctl->mdl[group].poses[0].ZInMicrometers; + } + + if (led_argb_set_id1(adev, argb_ctl, group, &laar, false)) + continue; + + if (led_argb_set_id3(adev, argb_ctl, group, &larr, false)) + continue; + + if (led_argb_set_pos(adev, argb_ctl, group, poses, true)) + continue; + } + + if (poses) + { + free(poses); + poses = NULL; + } + + return ret; +} + +int RtkArgbWrapper::set_argb_direct(int grp_num, std::vector color_buf, unsigned short brightness) +{ + int ret = -1; + size_t color_num = color_buf.size(); + int buf_len = color_num * ARGB_COLOR_DEPTH; + static unsigned short prev_bright = 0xFFFF; + uint8_t *buf; + std::lock_guard lock(my_mutex); + + if (color_num == 0) + goto exit; + + if (appctl[grp_num] != LED_CTL_APP) + { + appctl[grp_num] = LED_CTL_APP; + ret = led_argb_set_appctl(adev, grp_num, appctl[grp_num]); + if (ret) + goto exit; + } + + if (prev_bright != brightness) + { + prev_bright = brightness; + ret = led_argb_set_bright(adev, argb_ctl, grp_num, brightness << 8, true); + 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 * ARGB_COLOR_DEPTH + 0] = RGBGetRValue(color_buf[i]); + buf[i * ARGB_COLOR_DEPTH + 1] = RGBGetGValue(color_buf[i]); + buf[i * ARGB_COLOR_DEPTH + 2] = RGBGetBValue(color_buf[i]); + } + ret = led_argb_write_rgb_direct(adev, argb_ctl, buf, color_num, grp_num); + free(buf); + if (ret) + goto exit; +exit: + return ret; +} + +int RtkArgbWrapper::set_argb_effect(int grp_num, uint8_t mode, std::vector color_buf, int speed, unsigned short brightness) +{ + int ret = -1; + int cycle = interpolate(RTK_ARGB_CYCLE_MAX, RTK_ARGB_CYCLE_MIN, speed, RTK_ARGB_SPEED_MAX + 1); + std::lock_guard lock(my_mutex); + + if (mode == EFF_ALWAYS_ON) + cycle = 0; + + ret = led_argb_set_eff_id(adev, argb_ctl, grp_num, mode, false); + if (ret) + goto exit; + + if (color_buf.size() >= 1) + { + ret = led_argb_set_p_color(adev, argb_ctl, grp_num, color_buf[0], false); + if (ret) + goto exit; + } + if (color_buf.size() >= 2) + { + ret = led_argb_set_s_color(adev, argb_ctl, grp_num, color_buf[1], false); + if (ret) + goto exit; + } + + ret = led_argb_set_cycle(adev, argb_ctl, grp_num, cycle, false); + if (ret) + goto exit; + + ret = led_argb_set_ramp(adev, argb_ctl, grp_num, 0, false); + if (ret) + goto exit; + + ret = led_argb_set_stable(adev, argb_ctl, grp_num, 0, false); + if (ret) + goto exit; + + ret = led_argb_set_bright(adev, argb_ctl, grp_num, brightness << 8, true); + if (ret) + goto exit; + + appctl[grp_num] = LED_CTL_FW; + ret = led_argb_set_appctl(adev, grp_num, appctl[grp_num]); + if (ret) + goto exit; +exit: + return ret; +} + +int RtkArgbWrapper::interpolate(int vStart, int vEnd, int pos, int pos_num) +{ + if (vStart != vEnd) + return (int)round((vStart * (pos_num - 1 - pos) + vEnd * pos) / (double)(pos_num - 1)); + else + return vStart; +} + +std::string RtkArgbWrapper::wcharToString(const wchar_t *wstr) +{ +#ifdef _WIN32 + int size_needed = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, nullptr, 0, nullptr, nullptr); +#else + int size_needed = wcstombs(nullptr, wstr, 0); +#endif + std::string str(size_needed, 0); + +#ifdef _WIN32 + WideCharToMultiByte(CP_UTF8, 0, wstr, -1, &str[0], size_needed, nullptr, nullptr); +#else + wcstombs(&str[0], wstr, size_needed); +#endif + return str; +} + +#endif diff --git a/Controllers/RtkArgbController/RtkArgbWrapper.h b/Controllers/RtkArgbController/RtkArgbWrapper.h new file mode 100644 index 000000000..011c75e29 --- /dev/null +++ b/Controllers/RtkArgbController/RtkArgbWrapper.h @@ -0,0 +1,77 @@ +#pragma once + +#define CONFIG_HID +#define CONFIG_HID_ALL +#define CONFIG_ARGB_DEV + +#include +#include +#include +#include +#include +#include + +#include "RGBController.h" +#include +#include +#include "platform.h" +#include "bridge_func.h" +#include "argb_dev.h" +#include "argb_ctl.h" +#include "fwupdate.h" + +#define RTK_ARGB_VID 0x0BDA +#define RTK_ARGB_PID 0x9209 + +enum RTK_ARGB_SPEED +{ + RTK_ARGB_SPEED_MIN = 1, + RTK_ARGB_SPEED_NORMAL = 50, + RTK_ARGB_SPEED_MAX = 100, +}; + +enum RTK_ARGB_CYCLE_MS +{ + RTK_ARGB_CYCLE_MIN = 200, + RTK_ARGB_CYCLE_NORMAL = 2000, + RTK_ARGB_CYCLE_MAX = 10000, +}; + +enum RTK_ARGB_CUST_DEVNAME +{ + CUST_DEVNAME_NULL = 0x0, + CUST_DEVNAME_MANU_UUID = 0x1, +}; + +class RtkArgbWrapper +{ +public: + RtkArgbWrapper(struct argb_device *dev, argbCtl *argbctl, hid_device_info *info); + ~RtkArgbWrapper(); + + void argb_reinit(); + std::string get_manu_name(); + std::string get_product_name(); + std::string get_sn(); + std::string get_dev_loc(); + std::string get_fw_ver(); + std::string get_ic_uuid(); + std::string get_dev_name(); + int get_fix_grps(); + int get_argb_num(int grp_num); + int get_argb_brightness(int grp_num); + + int set_argb_num(int grp_num, int new_num); + int set_argb_direct(int grp_num, std::vector color_buf, unsigned short brightness); + int set_argb_effect(int grp_num, uint8_t mode, std::vector color_buf, int speed, unsigned short brightness); + + argbCtl *argb_ctl = NULL; +private: + struct argb_device *adev; + std::mutex my_mutex; + hid_device_info *hidinfo = NULL; + int appctl[NUM_ARGB_GRP] = {LED_CTL_FW}; + + int interpolate(int vStart, int vEnd, int pos, int pos_num); + std::string wcharToString(const wchar_t *wstr); +}; diff --git a/Controllers/RtkArgbController/rtk_argb_lib/include/api_ver.h b/Controllers/RtkArgbController/rtk_argb_lib/include/api_ver.h new file mode 100644 index 000000000..750bf49e6 --- /dev/null +++ b/Controllers/RtkArgbController/rtk_argb_lib/include/api_ver.h @@ -0,0 +1,46 @@ +/* + * BSD-3-Clause + * + * Copyright (c) 2022 - 2025, Realtek Semiconductor Corp. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * * Neither the name of the Realtek nor the names of its contributors may + * be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#pragma once + +#define UTHSB_API_VER_MAIN1 1 +#define UTHSB_API_VER_MAIN2 2 +#define UTHSB_API_VER_SUB1 8 +#define UTHSB_API_VER_SUB2 50919 + + +// version number (string) +#define TOSTRING2(arg) #arg +#define TOSTRING(arg) TOSTRING2(arg) +#define RELEASE_VER_STR TOSTRING(UTHSB_API_VER_MAIN1) "." TOSTRING(UTHSB_API_VER_MAIN2) "." TOSTRING(UTHSB_API_VER_SUB1) "." TOSTRING(UTHSB_API_VER_SUB2) + +#pragma once diff --git a/Controllers/RtkArgbController/rtk_argb_lib/include/argb_ctl.h b/Controllers/RtkArgbController/rtk_argb_lib/include/argb_ctl.h new file mode 100644 index 000000000..d0a316ca3 --- /dev/null +++ b/Controllers/RtkArgbController/rtk_argb_lib/include/argb_ctl.h @@ -0,0 +1,336 @@ +/* + * BSD-3-Clause + * + * Copyright (c) 2022 - 2024, Realtek Semiconductor Corp. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * * Neither the name of the Realtek nor the names of its contributors may + * be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +#ifndef _ARGB_CTL_H_ +#define _ARGB_CTL_H_ + +#pragma pack(1) + +#define ARGBCTL_SIG 0x41524742 +#define ARGBCTL_VER 0x3 + +#define ARGBCTL_EFF_MAX_NUM 5 +#define ARGBCTL_ARGB_MAX 400 + +#define ARGB_COLOR_DEPTH 3 + +#define LED_SUBCMD_APPCTL 0x01 +#define LED_SUBCMD_RWMEM 0x02 +#define LED_SUBCMD_RGB_DRT 0x03 +#define LED_SUBCMD_SUP_SYNC 0x04 +#define LED_SUBCMD_SUP_ARGB 0x05 +#define LED_SUBCMD_SUP_TP 0x06 +#define LED_SUBCMD_SUP_DP 0x07 +#define LED_SUBCMD_ARGB_CTRL_NUM 0x08 +#define LED_SUBCMD_RGB_DRT_AIO 0x09 + +#ifdef __cplusplus +extern "C" { +#endif + +enum ARGB_EFFECT_ID { + EFF_NULL = 0x0000, + EFF_ALWAYS_ON = 0x0001, + EFF_BLINK = 0x0002, + EFF_BREATH = 0x0003, + EFF_SPECTRUM = 0x0004, + EFF_SCROLL = 0x0005, + EFF_RAINBOW_SCROLL = 0x0006, + EFF_RUNNING_WATER = 0x0007, + EFF_SLIDING = 0x0008, + EFF_NEWTON_CRADLE = 0x0009, + EFF_METEOR = 0x000A, +}; + +enum ARGB_GROUP { + ARGB_GRP_0, + ARGB_GRP_1, + ARGB_GRP_2, + ARGB_GRP_3, + ARGB_GRP_4, + NUM_ARGB_GRP, + ARGB_GRP_NULL, +}; + +enum SYNC_METHOD +{ + SYNC_METHOD_ALL, + SYNC_METHOD_AURA, + SYNC_METHOD_MYSTIC, + SYNC_METHOD_RTKLED, + SYNC_METHOD_GBT, + SYNC_METHOD_ROG_AURA, // only for Asus ROG project + SYNC_METHOD_OPENRGB, + NUM_OF_SYNC_METHOD, +}; + +/***************************************************************** +App ctl parameters +*****************************************************************/ +enum LED_CTL +{ + LED_CTL_FW = 0, + LED_CTL_APP, + LED_CTL_LAMP, +}; + +/** + * @brief argb ctl header + */ +typedef struct argbCtlHeader { + uint32_t signature; + uint32_t version; + uint32_t header_addr; + uint32_t header_size; + uint32_t data_addr; + uint16_t data_size; + uint16_t single_data_size; + uint32_t mdl_addr; + uint32_t mdl_size; + uint16_t rgb_num[NUM_ARGB_GRP]; + uint16_t bright[NUM_ARGB_GRP]; + uint8_t reserved[28]; +} argbCtlHeader; + +/** + * @brief argb ctl effect data + */ +typedef struct argbCtlEffn { + uint16_t eff_id; + uint16_t cycle; + uint8_t hi_ramp; + uint8_t lo_ramp; + uint8_t hi_stable; + uint8_t lo_stable; + uint32_t prime_color; + uint32_t sec_color; + uint32_t sub_cmd; + uint8_t *reserved; +} argbCtlEffn; + +/** + * @brief argb ctl MDL attributes + */ +typedef struct __LampPosition +{ + uint32_t XInMicrometers; + uint32_t YInMicrometers; + uint32_t ZInMicrometers; +} LampPosition; +typedef struct __LampAttributes +{ + uint16_t LampId; + LampPosition pos; + uint32_t UpdateLatencyInMicroseconds; + uint32_t LampPurposes; + uint8_t RedLevelCount; + uint8_t GreenLevelCount; + uint8_t BlueLevelCount; + uint8_t IntensityLevelCount; + uint8_t IsProgrammable; + uint8_t LampKey; +} LampAttributes; +struct LampArrayAttributesReport +{ + uint8_t ReportId; + uint16_t LampCount; + uint32_t BoundingBoxWidthInMicrometers; + uint32_t BoundingBoxHeightInMicrometers; + uint32_t BoundingBoxDepthInMicrometers; + uint32_t LampArrayKind; + uint32_t MinUpdateIntervalInMicroseconds; +}; +struct LampAttributesResponseReport +{ + uint8_t ReportId; + LampAttributes Attributes; +}; + +typedef struct argbCtlMDL { + struct LampArrayAttributesReport *laar; + struct LampAttributesResponseReport *larr; + LampPosition *poses; +} argbCtlMDL; + +/** + * @brief argb parameters stored in memory + */ +typedef struct argbCtl { + argbCtlHeader *header; + argbCtlEffn *data[ARGBCTL_EFF_MAX_NUM]; + argbCtlMDL mdl[NUM_ARGB_GRP]; + uint8_t app_ctl[NUM_ARGB_GRP]; + uint8_t app_eff_done[NUM_ARGB_GRP]; + uint8_t *colors; + uint8_t sync_method; + uint32_t buf_size; +} argbCtl; + +int led_argb_set_appctl(dHandle fd, uint8_t grp_num, uint8_t ctl); +int led_argb_get_appctl(dHandle fd, uint8_t grp_num, uint8_t *ctl); + +int led_argb_write(dHandle fd, + argbCtl *argb_ctl); +int led_argb_read(dHandle fd, + argbCtl *argb_ctl); +int led_argb_write_rgb_direct(dHandle fd, + argbCtl *argb_ctl, + uint8_t *colors, + uint16_t numberOfColors, + uint8_t grp); +int led_argb_write_rgb_direct_aio(dHandle fd, + argbCtl *argb_ctl, + uint8_t group_mask, + uint8_t *colors, + uint16_t TotalRGBNum); + +int led_argb_init(dHandle fd, + argbCtl *argb_ctl); +void led_argb_deinit(argbCtl *argb_ctl); +bool led_argb_check_alive(argbCtl *argb_ctl); + +int led_argb_set_rgb_num(dHandle fd, + argbCtl *argb_ctl, + uint8_t grp, + uint16_t num_argb, + bool submit); +int led_argb_get_rgb_num(dHandle fd, + argbCtl *argb_ctl, + uint8_t grp, + uint16_t *num_argb); + +int led_argb_get_ic_support_sync_light(dHandle fd, uint8_t sync_method); +int led_argb_get_ic_support_argb(dHandle fd); + +int led_argb_set_bright(dHandle fd, + argbCtl *argb_ctl, + uint8_t grp, + uint16_t bright, + bool submit); +int led_argb_get_bright(dHandle fd, + argbCtl *argb_ctl, + uint8_t grp, + uint16_t *bright); +int led_argb_set_eff_id(dHandle fd, + argbCtl *argb_ctl, + uint8_t eff_i, + uint16_t id, + bool submit); +int led_argb_get_eff_id(dHandle fd, + argbCtl *argb_ctl, + uint8_t eff_i, + uint16_t *id); +int led_argb_set_cycle(dHandle fd, + argbCtl *argb_ctl, + uint8_t eff_i, + uint16_t cycle, + bool submit); +int led_argb_get_cycle(dHandle fd, + argbCtl *argb_ctl, + uint8_t eff_i, + uint16_t *cycle); +int led_argb_set_ramp(dHandle fd, + argbCtl *argb_ctl, + uint8_t eff_i, + uint16_t ramp, + bool submit); +int led_argb_get_ramp(dHandle fd, + argbCtl *argb_ctl, + uint8_t eff_i, + uint16_t *ramp); +int led_argb_set_stable(dHandle fd, + argbCtl *argb_ctl, + uint8_t eff_i, + uint16_t stable, + bool submit); +int led_argb_get_stable(dHandle fd, + argbCtl *argb_ctl, + uint8_t eff_i, + uint16_t *stable); +int led_argb_set_p_color(dHandle fd, + argbCtl *argb_ctl, + uint8_t eff_i, + uint32_t p_color, + bool submit); +int led_argb_get_p_color(dHandle fd, + argbCtl *argb_ctl, + uint8_t eff_i, + uint32_t *p_color); +int led_argb_set_s_color(dHandle fd, + argbCtl *argb_ctl, + uint8_t eff_i, + uint32_t s_color, + bool submit); +int led_argb_get_s_color(dHandle fd, + argbCtl *argb_ctl, + uint8_t eff_i, + uint32_t *s_color); +int led_argb_set_subcmd(dHandle fd, + argbCtl *argb_ctl, + uint8_t eff_i, + uint32_t subcmd, + bool submit); +int led_argb_get_subcmd(dHandle fd, + argbCtl *argb_ctl, + uint8_t eff_i, + uint32_t *subcmd); + +int led_argb_set_ex(dHandle fd, + argbCtl *argb_ctl, + uint8_t eff_i, + argbCtlEffn *cmd, + bool submit); + +int led_argb_set_id1(dHandle fd, + argbCtl *argb_ctl, + uint8_t grp, + struct LampArrayAttributesReport *laar, + bool submit); + +int led_argb_set_id3(dHandle fd, + argbCtl *argb_ctl, + uint8_t grp, + struct LampAttributesResponseReport *larr, + bool submit); + +int led_argb_set_pos(dHandle fd, + argbCtl *argb_ctl, + uint8_t grp, + void *pos, + bool submit); + +#ifdef __cplusplus +} +#endif + +#pragma pack() + +#endif /* _ARGB_CTL_H_ */ diff --git a/Controllers/RtkArgbController/rtk_argb_lib/include/argb_dev.h b/Controllers/RtkArgbController/rtk_argb_lib/include/argb_dev.h new file mode 100644 index 000000000..ed2316afe --- /dev/null +++ b/Controllers/RtkArgbController/rtk_argb_lib/include/argb_dev.h @@ -0,0 +1,77 @@ +/* + * BSD-3-Clause + * + * Copyright (c) 2022 - 2024, Realtek Semiconductor Corp. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * * Neither the name of the Realtek nor the names of its contributors may + * be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef _ARGB_DEV_H_ +#define _ARGB_DEV_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include "bridge_dev.h" +#define argb_device bridge_device + +//enum { +// ARGB_DEV_HID = 0, +// ARGB_DEV_SCSI, +// ARGB_DEV_USB +//}; + +struct argb_dev_info { + char *name; + char *path; + int intf_type; + struct argb_dev_info *next; +}; + +//struct argb_device { +// void *hdl; +// int type; +// struct bridge_hid_ch *chs; +//}; + +struct argb_dev_info *argb_dev_scan(struct usb_id *id, int id_num); + +void argb_dev_free_scan(struct argb_dev_info *devs); + +struct argb_device* argb_path_open(char* path, int type, struct bridge_hid_ch *extchs); + +struct argb_device *argb_dev_open(struct argb_dev_info *devs, const char *name, struct bridge_hid_ch *extchs); + +void argb_dev_close(struct argb_device *dev); + +void *argb_dev_get_handle(struct argb_device *dev); +#ifdef __cplusplus +} +#endif + +#endif /* _ARGB_DEV_H_ */ diff --git a/Controllers/RtkArgbController/rtk_argb_lib/include/ata.h b/Controllers/RtkArgbController/rtk_argb_lib/include/ata.h new file mode 100644 index 000000000..6689efb0b --- /dev/null +++ b/Controllers/RtkArgbController/rtk_argb_lib/include/ata.h @@ -0,0 +1,108 @@ +/* + * BSD-3-Clause + * + * Copyright (c) 2022, Realtek Semiconductor Corp. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * * Neither the name of the Realtek nor the names of its contributors may + * be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef _ATA_H_ +#define _ATA_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +enum { + /* SCSI command */ + ATA_12 = 0xA1, /*!< 0xA1 */ + ATA_16 = 0x85, /*!< 0x85 */ + + /* ATA protocol */ + ATA_PROTO_NON_DATA = 3 << 1, /*!< 3 << 1 */ + ATA_PROTO_PIO_IN = 4 << 1, /*!< 4 << 1 */ + ATA_PROTO_PIO_OUT = 5 << 1, /*!< 5 << 1 */ + + /* ATA command */ + ATA_CMD_IDENTIFY = 0xEC, /*!< 0xEC */ + ATA_CMD_SET_FEATURES = 0xEF, /*!< 0xEF */ + ATA_CMD_SEC_SET_PWD = 0xF1, /*!< 0xF1 */ + ATA_CMD_SEC_UNLOCK = 0xF2, /*!< 0xF2 */ + ATA_CMD_SEC_ERASE_PREPARE = 0xF3, /*!< 0xF3 */ + ATA_CMD_SEC_ERASE_UNIT = 0xF4, /*!< 0xF4 */ + ATA_CMD_SEC_FREEZE_LOCK = 0xF5, /*!< 0xF5 */ + ATA_CMD_SEC_DISABLE_PWD = 0xF6, /*!< 0xF6 */ + ATA_CMD_SEC_LOCK = 0xF7, /*!< 0xF7 */ + + /* ATA identify offset */ + ATA_ID_SERNO = 10, /*!< 10 */ + ATA_ID_FW_REV = 23, /*!< 23 */ + ATA_ID_PROD = 27, /*!< 27 */ + ATA_ID_NORMAL_SEC_ERASE_TIME = 89, /*!< 89 */ + ATA_ID_ENHANCED_SEC_ERASE_TIME = 90, /*!< 90 */ + ATA_ID_MASTER_PWD_ID = 92, /*!< 92 */ + ATA_ID_DLF = 128, /*!< 128 */ + + /* bits in identify security status */ + ATA_SEC_SUPPORTED = (1 << 0), /*!< 1 << 0 */ + ATA_SEC_ENABLED = (1 << 1), /*!< 1 << 1 */ + ATA_SEC_LOCKED = (1 << 2), /*!< 1 << 2 */ + ATA_SEC_FROZEN = (1 << 3), /*!< 1 << 3 */ + ATA_SEC_CNT_EXPIRED = (1 << 4), /*!< 1 << 4 */ + ATA_SEC_ENH_ERASE_SUPP = (1 << 5), /*!< 1 << 5 */ + ATA_SEC_MASTER_PWD_CAP = (1 << 8), /*!< 1 << 8 */ + + ATA_SEC_ERASE_TIME_FORMAT = (1 << 15), /*!< 1 << 15 */ +}; + +PACK ( +struct ata_smart_entry { + uint8_t id; + uint8_t flag[2]; + uint8_t current_value; + uint8_t worst_value; + uint8_t data[4]; + uint8_t attr_specific[2]; + uint8_t threshold; +}); + +struct ata_smart_log { + uint8_t version[2]; + struct ata_smart_entry entry[30]; +}; + +int ata_identify(dHandle fd, uint8_t *id, int len); +int ata_get_disk_info(dHandle fd, struct identify_info *disk); +int ata_get_smart_log(dHandle fd, uint8_t *log, uint32_t len); +int ata_parse_smart_log(uint8_t *buf); +int ata_set_feature(dHandle fd, uint8_t subcmd_lba, uint8_t subcmd_cnt); + +#ifdef __cplusplus +} +#endif + +#endif /* _ATA_H_ */ diff --git a/Controllers/RtkArgbController/rtk_argb_lib/include/bridge_dev.h b/Controllers/RtkArgbController/rtk_argb_lib/include/bridge_dev.h new file mode 100644 index 000000000..6e21da860 --- /dev/null +++ b/Controllers/RtkArgbController/rtk_argb_lib/include/bridge_dev.h @@ -0,0 +1,186 @@ +/* + * BSD-3-Clause + * + * Copyright (c) 2022 - 2024, Realtek Semiconductor Corp. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * * Neither the name of the Realtek nor the names of its contributors may + * be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef _BRIDGE_DEV_H_ +#define _BRIDGE_DEV_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#define NAME_STR_LEN 512 +#define MAX_BLK_SIZE 4096 + +enum BRDEV_TYPE { + BRDEV_TYPE_BRIDGE, + BRDEV_TYPE_ARGB, + NUM_BRDEV_TYPE, +}; + +enum BRINTF_TYPE { + BRINTF_TYPE_SCSI, + BRINTF_TYPE_HID, + BRINTF_TYPE_MS, + NUM_BRINTF_TYPE, +}; + +struct identify_info { + // IDENTIFY information + uint8_t serial_num[20]; + uint8_t null0; // make sn a cstring + uint8_t fw_rev[8]; + uint8_t null1; // make firmware rev a cstring + uint8_t model_num[40]; + uint8_t null2; // make model number a cstring +}; + +struct discovery_info { + uint8_t tper : 1; + uint8_t locking : 1; + uint8_t geometry : 1; + uint8_t single_user_mode : 1; + uint8_t opalv10 : 1; + uint8_t opalv20 : 1; + uint8_t pyritev100 : 1; + uint8_t pyritev200 : 1; + uint8_t blocksid : 1; + uint8_t tper_ack_nack : 1; + uint8_t tper_async : 1; + uint8_t tper_buffer_mgt : 1; + uint8_t tper_comid_mgt : 1; + uint8_t tper_streaming : 1; + uint8_t tper_sync : 1; + uint8_t locking_locked : 1; + uint8_t locking_locking_enabled : 1; + uint8_t locking_locking_supported : 1; + uint8_t locking_mbr_not_supported : 1; + uint8_t locking_mbr_done : 1; + uint8_t locking_mbr_enabled : 1; + uint8_t locking_media_encrypt : 1; + uint8_t geometry_align : 1; + uint8_t blocksid_sid_value : 1; + uint8_t blocksid_sid_block : 1; + uint8_t blocksid_hw_reset : 1; + uint8_t single_user_mode_any : 1; + uint8_t single_user_mode_all : 1; + uint8_t single_user_mode_policy : 1; + uint8_t ruby100 : 1; + uint8_t reserved0 : 2; + uint32_t reserved1; + uint64_t geometry_alignment_granularity; + uint32_t geometry_logical_blocksize; + uint16_t enc_mode; + uint16_t reserved2; + uint64_t geometry_lowest_aligned_lba; + uint32_t single_user_mode_locking_objects; + uint16_t opalv10_base_comid; + uint16_t opalv10_num_comids; + uint16_t base_comid; + uint16_t num_comids; + uint8_t initial_pin; + uint8_t reverted_pin; + uint16_t num_admins; + uint16_t num_users; + uint8_t range_crossing : 1; + uint8_t reserved3 : 7; + uint8_t reserved4; + uint16_t pyritev100_base_comid; + uint16_t pyritev100_num_comids; + uint16_t pyritev100_initial_pin; + uint16_t pyritev100_reverted_pin; + uint16_t pyritev200_base_comid; + uint16_t pyritev200_num_comids; + uint16_t pyritev200_initial_pin; + uint16_t pyritev200_reverted_pin; + uint32_t reserved5; +}; + +/* ata security info */ +struct ata_sec_info { + uint16_t supported : 1; + uint16_t enabled : 1; + uint16_t locked : 1; + uint16_t frozen : 1; + uint16_t expired : 1; + uint16_t enh_sec_erase_supported : 1; + uint16_t reserved00 : 2; + uint16_t master_pwd_cap : 1; + uint16_t reserved01 : 7; + uint16_t master_pwd_id; + uint16_t normal_sec_erase_time; + uint16_t enhanced_sec_erase_time; +}; + +/** structure to store Disk information. */ +struct ssd_info { + struct identify_info identify; + struct discovery_info discovery; + struct ata_sec_info ata_sec; +}; + +struct scan_result { + char name[NAME_STR_LEN]; + char br_name[NAME_STR_LEN]; + struct ssd_info ssdinfo; +#if defined(__APPLE__) + char bsd_name[NAME_STR_LEN]; +#endif + uint8_t dev_type; + struct scan_result *next; +}; + +struct br_priv; + +struct bridge_device { + void *hdl; + uint32_t blk_size; + uint8_t lun; + uint8_t dev_type; + uint8_t intf_type; + struct bridge_hid_ch *chs; + struct br_priv *priv; +}; + +struct bridge_device *bridge_open_handle(char *dev_path); +int bridge_close_handle(struct bridge_device *fd); +void bridge_exit(); +struct scan_result *bridge_disk_scan(struct usb_id *id, int id_num); +struct scan_result *bridge_dev_scan(struct usb_id *id, int id_num); +void bridge_free_scan(struct scan_result *result); +void* bridge_dev_get_handle(struct bridge_device *dev); +void bridge_dev_set_disk_blk_size(struct bridge_device *dev, uint32_t blk_size); + +#ifdef __cplusplus +} +#endif + +#endif /* _BRIDGE_DEV_H_ */ diff --git a/Controllers/RtkArgbController/rtk_argb_lib/include/bridge_disk.h b/Controllers/RtkArgbController/rtk_argb_lib/include/bridge_disk.h new file mode 100644 index 000000000..23314755a --- /dev/null +++ b/Controllers/RtkArgbController/rtk_argb_lib/include/bridge_disk.h @@ -0,0 +1,88 @@ +/* + * BSD-3-Clause + * + * Copyright (c) 2022 - 2025, Realtek Semiconductor Corp. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * * Neither the name of the Realtek nor the names of its contributors may + * be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef _BRIDGE_DISK_H_ +#define _BRIDGE_DISK_H_ + +enum bridge_disk_type { + DISK_NVME = 0x0, + DISK_SATA = 0x1, +}; + +enum bridge_port_type { + PORT_PCIE = 0x1, + PORT_SATA = 0x2, +}; + +enum bridge_disk_state { + DISK_STATE_NO_LINK = 0x0, + DISK_STATE_NORMAL = 0x1, + DISK_STATE_UNCONFIG = 0x2, + DISK_STATE_LOCK = 0x3, +}; + +/** + * disk_type: NVMe or SATA + * disk_state + */ +struct bridge_disk_status { + uint32_t disk_type; + uint32_t disk_state; + uint32_t port_type; + uint32_t reserved01; +}; + +int bridge_get_disk_status(dHandle fd, struct bridge_disk_status *disk_status); + +bool bridge_check_cdrom(dHandle fd); + +int bridge_get_hw_dma_mode(dHandle fd, bool *hw_dma_mode); + +int bridge_set_hw_dma_mode(dHandle fd, bool hw_dma_mode); + +int bridge_get_ips_threshold(dHandle fd, uint32_t *ips_threshold); + +int bridge_set_disk_speed(dHandle fd, uint8_t speed); + +int bridge_get_disk_speed(dHandle fd, uint8_t *speed); + +int bridge_set_bridge_rw_md(dHandle fd, uint8_t mode); + +int bridge_get_bridge_rw_md(dHandle fd, uint8_t *mode); + +int bridge_disable_cdrom(dHandle fd); + +int bridge_disable_disk_hotplug(dHandle fd); + +int bridge_read_capacity(dHandle fd, uint64_t *sectors, uint32_t *blk_size); + +#endif /* _BRIDGE_DISK_H_ */ diff --git a/Controllers/RtkArgbController/rtk_argb_lib/include/bridge_func.h b/Controllers/RtkArgbController/rtk_argb_lib/include/bridge_func.h new file mode 100644 index 000000000..c2f005a5d --- /dev/null +++ b/Controllers/RtkArgbController/rtk_argb_lib/include/bridge_func.h @@ -0,0 +1,96 @@ +/* + * BSD-3-Clause + * + * Copyright (c) 2022 - 2024, Realtek Semiconductor Corp. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * * Neither the name of the Realtek nor the names of its contributors may + * be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef _BRIDGE_FUNC_H_ +#define _BRIDGE_FUNC_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef ARRAY_SIZE +#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof(arr[0])) +#endif + +#define MAX_DISKS 10 +#define MAX_NUM_HID_CHS 10 + +#define USBID_ANY 0xFFFF + +struct bridge_fw_version { + uint32_t fw_major_ver; + uint32_t fw_minor_ver; + uint32_t fw_extra_ver; + uint32_t fw_build_ver; + uint32_t fw_build_date; +}; + +struct bridge_hid_ch { + uint8_t report_id; + uint16_t ch_len; +}; + +int bridge_check_vid_pid(uint16_t vid, + uint16_t pid, + struct usb_id *id, + int id_num); +int bridge_write_unlock(dHandle fd); +int bridge_disconnect(dHandle fd, int type); +bool bridge_check_target(dHandle fd); +int bridge_get_uuid(dHandle fd, uint8_t *uuid); +int bridge_get_cust_page(dHandle fd, uint8_t *cust_page); +int bridge_set_cust_page(dHandle fd, uint8_t *cust_page); +int bridge_get_fw_ver(dHandle fd, struct bridge_fw_version *fw_ver); +int bridge_get_buf_size(dHandle fd, uint32_t *buf_size); +int bridge_get_usb_speed(dHandle fd, uint32_t *speed); +int bridge_get_hid_ch(dHandle fd, struct bridge_hid_ch *chs); +void bridge_get_api_ver(uint32_t *ver_main1, + uint32_t *ver_main2, + uint32_t *ver_sub1, + uint32_t *ver_sub2); +int bridge_inquiry(dHandle fd, uint8_t *buf, uint32_t buflen); +int bridge_get_name(dHandle fd, char *name, uint32_t len); +int bridge_get_vendor_name(dHandle fd, char *name, uint32_t len); +int bridge_get_product_name(dHandle fd, char *name, uint32_t len); + +int bridge_get_debug_level(const char *debug, int *lvl); +int bridge_set_debug_level(int lvl); + +int bridge_report_luns(dHandle fd, + uint8_t *lun, + uint32_t *total_luns); + +#ifdef __cplusplus +} +#endif + +#endif /* _BRIDGE_FUNC_H_ */ diff --git a/Controllers/RtkArgbController/rtk_argb_lib/include/fwupdate.h b/Controllers/RtkArgbController/rtk_argb_lib/include/fwupdate.h new file mode 100644 index 000000000..4755bf512 --- /dev/null +++ b/Controllers/RtkArgbController/rtk_argb_lib/include/fwupdate.h @@ -0,0 +1,128 @@ +/* + * BSD-3-Clause + * + * Copyright (c) 2022 - 2024, Realtek Semiconductor Corp. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * * Neither the name of the Realtek nor the names of its contributors may + * be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef _PG_H_ +#define _PG_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +enum { + PG_ERR_DEV_PATH = 1, /*!< 1 */ + PG_ERR_INTERNAL_FAILURE = 2, /*!< 2 */ + PG_ERR_IO = 3, /*!< 3 */ + PG_ERR_REBOOT = 4, /*!< 4 */ + PG_ERR_UUID = 5, /*!< 5 */ + PG_ERR_WRONG_FW = 6, /*!< 6 */ + PG_ERR_WRONG_RSQ_FW = 7, /*!< 7 */ + PG_ERR_WRONG_LIGHT_BIN = 8, /*!< 8 */ + PG_ERR_WRONG_CONF = 9, /*!< 9 */ + PG_ERR_UPDATE_FW = 10, /*!< 10 */ + PG_ERR_UPDATE_RSQ = 11, /*!< 11 */ + PG_ERR_UPDATE_LIGHT = 12, /*!< 12 */ + PG_ERR_UPDATE_CONF = 13, /*!< 13 */ + PG_ERR_BOOT_RSQ_FW = 14, /*!< 14 */ + PG_ERR_BOOT_NORMAL_FW = 15, /*!< 15 */ + PG_ERR_NO_DEV = 16, /*!< 16 */ +}; + +/** \brief pg info structure. */ +typedef struct _PGINFO +{ + uint16_t vid; + uint16_t pid; + + char product[62 + 2]; //+2 for end '\0' + char manufacture[30 + 2]; //+2 for end '\0' + char serial[62 + 2]; //+2 for end '\0' + + char scsi_vendor[8 + 1]; //+1 for end '\0' + char scsi_product[16 + 1]; //+1 for end '\0' + + uint8_t aspmdis; + uint8_t dis_ips_thres; + uint8_t led; + uint32_t hw_led_cfg; + uint8_t customized_led[15]; + uint8_t suspend_led_off; + uint8_t dbg_pin; + uint8_t disk_hotplug; + uint8_t sd_mmc_type; + uint8_t usb_self_pwr; + uint64_t customized_feature; + uint32_t support_hid; + uint32_t raid_cfg; + uint32_t force_usb_quirk; + uint32_t rw_mode; + uint16_t bcddevice; + uint8_t scsi_wp_pin; +} PGINFO; + +//// Fwupdate APIs //// +int fwupdate_all(const char *devpath, + const char *bin, + const char *rescuebin, + const char *conf, + const char *ledbin, + uint8_t dev_type); +uint32_t fwupdate_get_progress(); +void fwupdate_reset_progess(); +int fwupdate_get_last_error(); +int fwupdate_write_light_bin(dHandle fd, const char *bin); +int fwupdate_flash_dump(dHandle fd, char *file_name, uint16_t flash_size); + +#ifdef CONFIG_ARGB_DEV +int fwupdate_write_light_arr(dHandle fd, void *ctl); +#endif + +int pg_write(dHandle fd, const char *conf); +int pg_read(dHandle fd, PGINFO *info); +void pg_print_pginfo(PGINFO* info); +int pg_get_force_usb_speed(dHandle fd, uint8_t *speed); +int pg_set_force_usb_speed(dHandle fd, uint8_t speed); +int pg_get_serial_num(dHandle fd, char *sn, uint32_t len); +int pg_set_serial_num(dHandle fd, char *sn, uint32_t len); +int pg_get_manufacturer_name(dHandle fd, char *manu, uint32_t len); +int pg_get_product_name(dHandle fd, char *pdname, uint32_t len); +int pg_get_vid(dHandle fd, uint16_t *vid); +int pg_set_vid(dHandle fd, uint16_t vid); +int pg_get_pid(dHandle fd, uint16_t *pid); +int pg_set_pid(dHandle fd, uint16_t pid); +int pg_get_rw_mode(dHandle fd, uint32_t *mode); +int pg_set_rw_mode(dHandle fd, uint32_t mode); + +#ifdef __cplusplus +} +#endif + +#endif // _PG_H_ diff --git a/Controllers/RtkArgbController/rtk_argb_lib/include/hid_dev_spti.h b/Controllers/RtkArgbController/rtk_argb_lib/include/hid_dev_spti.h new file mode 100644 index 000000000..c6e4a6c56 --- /dev/null +++ b/Controllers/RtkArgbController/rtk_argb_lib/include/hid_dev_spti.h @@ -0,0 +1,55 @@ +/* + * BSD-3-Clause + * + * Copyright (c) 2022 - 2024, Realtek Semiconductor Corp. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * * Neither the name of the Realtek nor the names of its contributors may + * be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __HID_DEV_SPTI_H__ +#define __HID_DEV_SPTI_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef CONFIG_HID +#define DEFAULT_DATA_LEN 4096 +#define DEFAULT_DATA_ID 0x57 + +int hid_dev_spti(hid_device *fd, uint8_t lun, uint8_t *cdb, + uint8_t *buf, int buflen, + uint8_t is_in, int timeout, + struct bridge_hid_ch *chs, uint8_t *sense); + +int hid_write_unlock(hid_device *fd); +#endif + +#ifdef __cplusplus +} +#endif +#endif /* __HID_DEV_SPTI_H__ */ diff --git a/Controllers/RtkArgbController/rtk_argb_lib/include/led.h b/Controllers/RtkArgbController/rtk_argb_lib/include/led.h new file mode 100644 index 000000000..ba235bde1 --- /dev/null +++ b/Controllers/RtkArgbController/rtk_argb_lib/include/led.h @@ -0,0 +1,344 @@ +/* + * BSD-3-Clause + * + * Copyright (c) 2022 - 2024, Realtek Semiconductor Corp. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * * Neither the name of the Realtek nor the names of its contributors may + * be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef _LED_H_ +#define _LED_H_ +#pragma pack(1) + +#define LED_SUBCMD_APPCTL 0x01 +#define LED_SUBCMD_RWMEM 0x02 +#define LED_SUBCMD_RGB_DRT 0x03 +#define LED_SUBCMD_SUP_SYNC 0x04 +#define LED_SUBCMD_SUP_ARGB 0x05 +#define LED_SUBCMD_SUP_TP 0x06 +#define LED_SUBCMD_SUP_DP 0x07 + +#define MAX_ARGB_NUM 20 +#define MAX_APPCTL_ROW 43 +#define LED_MEM_NUM_OF_STATE 5 +#define LED_MEM_BUF_SIZE 16384 +#define LED_INFO_SIZE 32 + +/* Throughput */ +#define MAX_THROUGHPUT_SPEED 2000 // 2000 MB/s +#define MAX_THROUGHPUT_CYCLE_PCT 100 // +100% of each speed decline +#define MAX_THROUGHPUT_EQ_PARTS 100 // 2000 MB/s divide to n parts + +#define BREATH_DELAY 100 + +#ifdef __cplusplus +extern "C" { +#endif + +struct led_ex_cmd { + uint8_t mode; + uint8_t row_num; + uint16_t cycle; + uint8_t hi_ramp; + uint8_t low_ramp; + uint8_t hi_stable; + uint8_t low_stable; + uint8_t effect_id; + uint16_t latency; + uint8_t *color; + uint16_t len; +}; + +struct led_mem_info { + uint8_t mode; + uint8_t row_num; + uint16_t cycle; + uint8_t hi_ramp; // 1 unit = 100ms + uint8_t lo_ramp; // 1 unit = 100ms + uint8_t hi_stable; // 1 unit = 100ms + uint8_t lo_stable; // 1 unit = 100ms + + /* effect_id + * for tool usage + * bit7: single / multi color + * bit[0:6]: id of effect combobox + */ + uint8_t effect_id; + uint16_t latency; + + uint8_t reserved[21]; + uint8_t ctbl[MAX_APPCTL_ROW * 3]; +}; + +struct led_mem_rgbn { + struct led_mem_info *rgb[MAX_ARGB_NUM]; +}; + +struct led_mem_header { + uint32_t signature; + uint32_t version; + uint32_t header_addr; + uint32_t header_size; + uint32_t data_addr; + uint32_t data_size; + uint32_t rgb_num; + uint16_t bright; + uint32_t argb_port_sel[2]; + + /* Thoughput settings */ + uint16_t max_speed; // throughput max speed. + uint16_t cycle_pct; // n% cycle percentages for throughput variety. + uint8_t equal_parts; // divide max_speed to n parts. + + uint8_t reserved[21]; +}; + +/** + * @brief led parameters stored in memory + */ +struct led_mem { + struct led_mem_header *header; + struct led_mem_rgbn *data[LED_MEM_NUM_OF_STATE]; + uint8_t info_size; + uint8_t max_row; + uint8_t sync_method; + uint32_t buf_size; +}; + +typedef enum LED_MEM_STATE +{ + LED_MEM_IDLE_STATE, + LED_MEM_RW_STATE, + LED_MEM_IPS_STATE, + LED_MEM_SLEEP_STATE, + LED_MEM_ERROR_STATE, +} LED_MEM_STATE; + +enum SYNC_METHOD +{ + SYNC_METHOD_ALL, + SYNC_METHOD_AURA, + SYNC_METHOD_MYSTIC, + SYNC_METHOD_RTKLED, + SYNC_METHOD_GBT, + SYNC_METHOD_ROG_AURA, // only for Asus ROG project + SYNC_METHOD_OPENRGB, + NUM_OF_SYNC_METHOD, +}; + +int led_set_appctl(dHandle fd, + bool en); + +int led_get_appctl(dHandle fd, + uint8_t *sts); + +int led_mem_write(dHandle fd, + struct led_mem *led_mem_dev); + +int led_mem_read(dHandle fd, + struct led_mem *led_mem_dev); + +int led_mem_write_rgb_direct(dHandle fd, + struct led_mem *led_mem_dev, + uint8_t *colors, + uint16_t numberOfColors); + +int led_get_ic_support_sync_light(dHandle fd, uint8_t sync_method); +int led_get_ic_support_argb(dHandle fd); +int led_get_ic_support_throughput(dHandle fd); +int led_get_ic_support_dualport(dHandle fd); + +int led_mem_init(dHandle fd, + struct led_mem *led_mem_dev); + +void led_mem_deinit(struct led_mem *led_mem_dev); + +bool led_mem_check_alive(struct led_mem *led_mem_dev); + +int led_mem_write_params(dHandle fd, + struct led_mem *led_mem_dev); + +int led_mem_set_mode(dHandle fd, + struct led_mem *led_mem_dev, + uint16_t led_state, + uint8_t idx, + uint8_t mode, + bool submit); + +int led_mem_get_mode(dHandle fd, + struct led_mem *led_mem_dev, + uint16_t led_state, + uint8_t idx, + uint8_t *mode); + +int led_mem_set_row(dHandle fd, + struct led_mem *led_mem_dev, + uint16_t led_state, + uint8_t idx, + uint8_t row_num, + bool submit); + +int led_mem_get_row(dHandle fd, + struct led_mem *led_mem_dev, + uint16_t led_state, + uint8_t idx, + uint8_t *row_num); + +int led_mem_set_cycle(dHandle fd, + struct led_mem *led_mem_dev, + uint16_t led_state, + uint8_t idx, + uint16_t cycle, + bool submit); + +int led_mem_get_cycle(dHandle fd, + struct led_mem *led_mem_dev, + uint16_t led_state, + uint8_t idx, + uint16_t *cycle); + +int led_mem_set_ramp(dHandle fd, + struct led_mem *led_mem_dev, + uint16_t led_state, + uint8_t idx, + uint16_t ramp_factor, + bool submit); + +int led_mem_get_ramp(dHandle fd, + struct led_mem *led_mem_dev, + uint16_t led_state, + uint8_t idx, + uint16_t *ramp_factor); + +int led_mem_set_stable(dHandle fd, + struct led_mem *led_mem_dev, + uint16_t led_state, + uint8_t idx, + uint16_t stable_factor, + bool submit); + +int led_mem_get_stable(dHandle fd, + struct led_mem *led_mem_dev, + uint16_t led_state, + uint8_t idx, + uint16_t *stable_factor); + +int led_mem_set_latency(dHandle fd, + struct led_mem *led_mem_dev, + uint16_t led_state, + uint8_t idx, + uint16_t latency, + bool submit); + +int led_mem_get_latency(dHandle fd, + struct led_mem *led_mem_dev, + uint16_t led_state, + uint8_t idx, + uint16_t *latency); + +int led_mem_set_eff_id(dHandle fd, + struct led_mem *led_mem_dev, + uint16_t led_state, + uint8_t idx, + uint8_t eff_id, + bool submit); + +int led_mem_get_eff_id(dHandle fd, + struct led_mem *led_mem_dev, + uint16_t led_state, + uint8_t idx, + uint8_t *eff_id); + +int led_mem_set_bright(dHandle fd, + struct led_mem *led_mem_dev, + uint16_t bright, + bool submit); + +int led_mem_get_bright(dHandle fd, + struct led_mem *led_mem_dev, + uint16_t *bright); + +int led_mem_set_color(dHandle fd, + struct led_mem *led_mem_dev, + uint16_t led_state, + uint8_t idx, + uint8_t row, + uint8_t *val, + uint8_t len, + bool submit); + +int led_mem_get_color(dHandle fd, + struct led_mem *led_mem_dev, + uint16_t led_state, + uint8_t idx, + uint8_t row, + uint8_t *val, + uint8_t len); + +int led_mem_set_rgb_num(dHandle fd, + struct led_mem *led_mem_dev, + int rgb_num, + bool submit); + +int led_mem_get_rgb_num(struct led_mem *led_mem_dev, + int *rgb_num); + +int led_mem_set_ex(dHandle fd, + struct led_mem *led_mem_dev, + struct led_ex_cmd *cmd, + uint8_t led_state, + uint32_t argb_sel, + bool is_dual_port, + bool submit); + +int led_mem_set_tp_mspd(dHandle fd, + struct led_mem *led_mem_dev, + int mspd, + bool submit); + +int led_mem_set_tp_cycle_pct(dHandle fd, + struct led_mem *led_mem_dev, + int cycle_pct, + bool submit); + +int led_mem_set_tp_eq_parts(dHandle fd, + struct led_mem *led_mem_dev, + int eq_parts, + bool submit); + +int led_mem_set_argb_sel(dHandle fd, + struct led_mem *led_mem_dev, + uint32_t *argb_sel, + bool submit); + +#ifdef __cplusplus +} +#endif + +#pragma pack() + +#endif /* _LED_H_ */ diff --git a/Controllers/RtkArgbController/rtk_argb_lib/include/led_effect.h b/Controllers/RtkArgbController/rtk_argb_lib/include/led_effect.h new file mode 100644 index 000000000..190a07ee9 --- /dev/null +++ b/Controllers/RtkArgbController/rtk_argb_lib/include/led_effect.h @@ -0,0 +1,130 @@ +/* + * BSD-3-Clause + * + * Copyright (c) 2022, Realtek Semiconductor Corp. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * * Neither the name of the Realtek nor the names of its contributors may + * be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef _LED_EFFECT_H_ +#define _LED_EFFECT_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#if !defined(_WIN32) +typedef struct tagRGBQUAD { + unsigned char rgbBlue; + unsigned char rgbGreen; + unsigned char rgbRed; + unsigned char rgbReserved; +} RGBQUAD; +#endif + +typedef enum LED_MODE +{ + NONE, + COLOR_ALWAYS, //single always + COLOR_CYCLE, //row take turns + COLOR_BLINK, //each row represents a blink color + COLOR_BREATHE, + FORCE_SHUTDOWN, + PANEL_DISPLAY, + PANEL_TEMP_MONITOR, + NUMBER_OF_MODE, +} LED_MODE; + +enum LED_EFF +{ + LED_EFF_NONE, + LED_EFF_ALWAYS, + LED_EFF_BLINK, + LED_EFF_BREATHE, + LED_EFF_SPECTRUM, + LED_EFF_SCROLL, + LED_EFF_RAINBOW_SCROLL, + LED_EFF_RUNNING_WATER, + LED_EFF_SLIDING, + LED_EFF_NEWTON_CRADLE, + LED_EFF_METEOR, + NUMBER_OF_LED_EFF_MODE, +}; + +int HSV2RGB(float hue, float sat, float value); + +int led_eff_set_always_on(dHandle fd, + struct led_mem *led_mem_dev, + RGBQUAD rgb); + +int led_eff_set_blink(dHandle fd, + struct led_mem *led_mem_dev, + RGBQUAD rgb, + uint16_t cycle); + +int led_eff_set_breathe(dHandle fd, + struct led_mem *led_mem_dev, + RGBQUAD rgb, + uint16_t cycle); + +int led_eff_set_spectrum(dHandle fd, + struct led_mem *led_mem_dev, + uint16_t cycle); + +int led_eff_set_scroll(dHandle fd, + struct led_mem *led_mem_dev, + RGBQUAD rgb, + uint16_t cycle); + +int led_eff_set_rainbow_scroll(dHandle fd, + struct led_mem *led_mem_dev, + uint16_t cycle); + +int led_eff_set_running_water(dHandle fd, + struct led_mem *led_mem_dev, + RGBQUAD rgb, + uint16_t cycle); + +int led_eff_set_sliding(dHandle fd, + struct led_mem *led_mem_dev, + uint16_t cycle); + +int led_eff_set_newton_cradle(dHandle fd, + struct led_mem *led_mem_dev, + uint16_t cycle); + +int led_eff_set_meteor(dHandle fd, + struct led_mem *led_mem_dev, + RGBQUAD rgb, + uint16_t cycle); + +#ifdef __cplusplus +} +#endif + + +#endif /* _LED_EFFECT_H_ */ diff --git a/Controllers/RtkArgbController/rtk_argb_lib/include/platform.h b/Controllers/RtkArgbController/rtk_argb_lib/include/platform.h new file mode 100644 index 000000000..bf84535a2 --- /dev/null +++ b/Controllers/RtkArgbController/rtk_argb_lib/include/platform.h @@ -0,0 +1,124 @@ +/* + * BSD-3-Clause + * + * Copyright (c) 2022 - 2024, Realtek Semiconductor Corp. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * * Neither the name of the Realtek nor the names of its contributors may + * be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef _PLATFORM_H_ +#define _PLATFORM_H_ + +#ifdef _WIN32 +#include +#endif + +#ifdef CONFIG_HID +#include "hidapi.h" +#endif + +#ifdef CONFIG_MS +#include "mass_storage.h" +#endif + +struct usb_id { + uint16_t vid; + uint16_t pid; +}; + +#include "bridge_dev.h" +#ifdef CONFIG_ARGB_DEV +#include "argb_dev.h" +#endif + +typedef struct bridge_device *dHandle; + +#ifndef INVALID_DHANDLE +#if defined(CONFIG_MS) +#ifdef __cplusplus +#define INVALID_DHANDLE(fd) ((reinterpret_cast(fd) <= 0) ? true : false) +#else +#define INVALID_DHANDLE(fd) (((long int *)(fd) <= 0) ? true : false) +#endif +#else +#ifdef _WIN32 +#ifdef __cplusplus +#define INVALID_DHANDLE(fd) ((reinterpret_cast(fd) <= 0) ? true : false) +#else +#define INVALID_DHANDLE(fd) (((LONGLONG)(fd) <= 0) ? true : false) +#endif +#elif defined(__APPLE__) || defined(__linux__) +#define INVALID_DHANDLE(fd) (((long long)fd <= 0) ? true : false) +#endif // _WIN32 +#endif +#endif // !INVALID_DHANDLE + +#ifndef NULL_DHANDLE +#ifdef _WIN32 +#define NULL_DHANDLE NULL +#elif defined(__APPLE__) || defined(__linux__) +#define NULL_DHANDLE 0 +#endif // _WIN32 +#endif // !NULL_DHANDLE + +#ifdef WIN32 +#define _Align(n) __declspec(align(n)) +#else +#define _Align(n) __attribute__((aligned(n))) +#endif // WIN32 + +#ifdef _WIN32 +#define PACK( __Declaration__ ) __pragma( pack(push, 1) ) __Declaration__ __pragma( pack(pop)) +#else +#define PACK( __Declaration__ ) __Declaration__ __attribute__((__packed__)) +#endif // WIN32 + +#ifndef _WIN32 +#ifndef MIN +#define MIN(x, y) \ + ({ \ + __typeof__(x) _x = (x); \ + __typeof__(y) _y = (y); \ + (void)(&_x == &_y); \ + _x < _y ? _x : _y; \ + }) +#endif +#define min MIN + +#ifndef MAX +#define MAX(x, y) \ + ({ \ + __typeof__(x) _x = (x); \ + __typeof__(y) _y = (y); \ + (void)(&_x == &_y); \ + _x > _y ? _x : _y; \ + }) +#endif +#define max MAX +#endif // WIN32 + +#endif diff --git a/Controllers/RtkArgbController/rtk_argb_lib/include/scsi.h b/Controllers/RtkArgbController/rtk_argb_lib/include/scsi.h new file mode 100644 index 000000000..ede98dbfe --- /dev/null +++ b/Controllers/RtkArgbController/rtk_argb_lib/include/scsi.h @@ -0,0 +1,106 @@ +/* + * BSD-3-Clause + * + * Copyright (c) 2022, Realtek Semiconductor Corp. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * * Neither the name of the Realtek nor the names of its contributors may + * be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef _SCSI_H_ +#define _SCSI_H_ + +#define RTK_READ_CMD 0xE2 +#define RTK_WRITE_CMD 0xE3 +#define RTK_NVME_READ_CMD 0xE4 +#define RTK_NVME_WRITE_CMD 0xE5 + +#define SCSI_REQUEST_SENSE 0x03 +#define SCSI_STD_INQUIRY 0x12 +#define SCSI_REPORT_LUNS 0xa0 + +#define SCSI_SENSE_LEN 18 + +#define RTK_RCMD 0x80 +#define RTK_FWU_START 0x01 +#define RTK_FWU_WADDR 0x10 +#define RTK_FWU_WDATA 0x11 +#define RTK_FWU_RDATA (0x12 | RTK_RCMD) +#define RTK_RD_EFUSE (0x16 | RTK_RCMD) +#define RTK_RD_MEM (0x22 | RTK_RCMD) +#define RTK_WT_MEM 0x23 +#define RTK_GET_FW_VER (0x25 | RTK_RCMD) +#define FWU_GET_FLASHBOOT (0x26 | RTK_RCMD) +#define RTK_OPAL_SET 0x27 +#define RTK_OPAL_GET (0x28 | RTK_RCMD) +#define RTK_FW_RESTART 0x30 +#define RTK_WR_PCIE_CONF 0x33 +#define RTK_RD_PCIE_CONF (0x33 | RTK_RCMD) +#define RTK_WR_PCIE_MEM 0x34 +#define RTK_RD_PCIE_MEM (0x34 | RTK_RCMD) +#define RTK_DUMP_FW_VARIABLES (0x35 | RTK_RCMD) +#define RTK_READ_UART_STR (0x38 | RTK_RCMD) +#define RTK_WRITE_UART_STR (0x38) +#define RTK_CLEAR_UART_BUFFER (0x3a) +#define RTK_GET_UART_RX_COUNT (0x3a | RTK_RCMD) +#define RTK_GET_DISK_STATUS (0x3b | RTK_RCMD) +#define RTK_I2C_READ (0x3c | RTK_RCMD) +#define RTK_I2C_WRITE (0x3d) +#define RTK_I2C_SET_ADDR (0x3e) +#define RTK_I2C_INIT (0x3f) +#define RTK_GPIO_MUX_SEL (0x41) +#define RTK_GET_IC_UUID (0x43 | RTK_RCMD) +#define RTK_SET_CUST_PAGE (0x44) +#define RTK_GET_CUST_PAGE (0x44 | RTK_RCMD) +#define RTK_GPIO_SET_VAL (0x45) +#define RTK_GPIO_GET_VAL (0x45 | RTK_RCMD) +#define RTK_GPIO_SET_DIR (0x46) +#define RTK_GET_BUF_SIZE (0x4a | RTK_RCMD) +#define RTK_SET_HW_DMA_MODE (0x4b) +#define RTK_GET_HW_DMA_MODE (0x4b | RTK_RCMD) +#define RTK_LED_SET_INFO (0x4c) +#define RTK_LED_GET_INFO (0x4c | RTK_RCMD) +#define RTK_SET_DISK_SPEED (0x4d) +#define RTK_GET_DISK_SPEED (0x4d | RTK_RCMD) +#define RTK_UART_INIT (0x4e) +#define RTK_SET_BRIDGE_RW_MD (0x4f) +#define RTK_GET_BRIDGE_RW_MD (0x4f | RTK_RCMD) +#define RTK_GET_LUN (0x50 | RTK_RCMD) + +#define RTK_WR_RAID_MODE (0x52) +#define RTK_RD_RAID_MODE (0x52 | RTK_RCMD) + +#define RTK_GET_HID_CH (0x5A | RTK_RCMD) + +#define INQ_LEN 512 +#define INQ_VENDOR_OFFSET 8 +#define INQ_VENDOR_LEN 8 +#define INQ_PRODUCT_OFFSET 16 +#define INQ_PRODUCT_LEN 16 + +#define SCSI_TIMEOUT_DEFAULT 10 + +#endif diff --git a/Controllers/RtkArgbController/rtk_argb_lib/include/spti.h b/Controllers/RtkArgbController/rtk_argb_lib/include/spti.h new file mode 100644 index 000000000..5435273cd --- /dev/null +++ b/Controllers/RtkArgbController/rtk_argb_lib/include/spti.h @@ -0,0 +1,137 @@ +/* + * BSD-3-Clause + * + * Copyright (c) 2022 - 2024, Realtek Semiconductor Corp. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * * Neither the name of the Realtek nor the names of its contributors may + * be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef _SPTI_H_ +#define _SPTI_H_ + +#include "scsi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#include "scsi.h" + +#define MAX_SPTI_RETRY 5 + +#define SPT_CDB_LENGTH 32 +#define SPT_SENSE_LENGTH 32 +#define SPTWB_DATA_LENGTH 4096 + + +#ifdef _WIN32 + +#include +#include + +typedef struct _SCSI_PASS_THROUGH_WITH_BUFFERS { + SCSI_PASS_THROUGH spt; + ULONG Filler; // realign buffers to double word boundary + UCHAR ucSenseBuf[SPT_SENSE_LENGTH]; + UCHAR ucDataBuf[SPTWB_DATA_LENGTH]; +} SCSI_PASS_THROUGH_WITH_BUFFERS, *PSCSI_PASS_THROUGH_WITH_BUFFERS; + +typedef struct _SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER { + SCSI_PASS_THROUGH_DIRECT sptd; + ULONG Filler; // realign buffer to double word boundary + UCHAR ucSenseBuf[SPT_SENSE_LENGTH]; +} SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER, *PSCSI_PASS_THROUGH_DIRECT_WITH_BUFFER; + +#else + +#define IOCTL_SCSI_PASS_THROUGH _IOWR('F', 1, SCSI_PASS_THROUGH_WITH_BUFFERS) +#define SCSI_IOCTL_DATA_OUT 0 +#define SCSI_IOCTL_DATA_IN 1 + +typedef struct _SCSI_PASS_THROUGH +{ + unsigned short Length; + unsigned char ScsiStatus; + unsigned char PathId; + unsigned char TargetId; + unsigned char Lun; + unsigned char CdbLength; + unsigned char SenseInfoLength; + unsigned char DataIn; + int DataTransferLength; + int TimeOutValue; + int DataBufferOffset; + int SenseInfoOffset; + unsigned char Cdb[16]; +} SCSI_PASS_THROUGH, *PSCSI_PASS_THROUGH; + +typedef struct _SCSI_PASS_THROUGH_DIRECT { + unsigned short Length; + unsigned char ScsiStatus; + unsigned char PathId; + unsigned char TargetId; + unsigned char Lun; + unsigned char CdbLength; + unsigned char SenseInfoLength; + unsigned char DataIn; + unsigned long DataTransferLength; + unsigned long TimeOutValue; + void *DataBuffer; + unsigned long SenseInfoOffset; + unsigned char Cdb[16]; +} SCSI_PASS_THROUGH_DIRECT, *PSCSI_PASS_THROUGH_DIRECT; + +typedef struct _S_SCSI_PASS_THROUGH_WITH_BUFFERS +{ + SCSI_PASS_THROUGH spt; + unsigned int Filler; // realign buffers to double word boundary + unsigned char ucSenseBuf[SPT_SENSE_LENGTH]; + unsigned char ucDataBuf[SPTWB_DATA_LENGTH]; +} SCSI_PASS_THROUGH_WITH_BUFFERS, *PSCSI_PASS_THROUGH_WITH_BUFFERS; + +typedef struct _SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER { + SCSI_PASS_THROUGH_DIRECT sptd; + unsigned long Filler; // realign buffer to double word boundary + unsigned char ucSenseBuf[SPT_SENSE_LENGTH]; +} SCSI_PASS_THROUGH_DIRECT_WITH_BUFFER, *PSCSI_PASS_THROUGH_DIRECT_WITH_BUFFER; + +#endif + +int scsi_pass_thru_intf(dHandle fd, + uint8_t *cdb, + uint8_t *buf, + int buflen, + uint8_t is_in, + int timeout, + uint8_t *sense); + +#ifdef __cplusplus +} +#endif + +#endif /* _SPTI_H_ */ + diff --git a/Controllers/RtkArgbController/rtk_argb_lib/include/swlib.h b/Controllers/RtkArgbController/rtk_argb_lib/include/swlib.h new file mode 100644 index 000000000..99c562fa2 --- /dev/null +++ b/Controllers/RtkArgbController/rtk_argb_lib/include/swlib.h @@ -0,0 +1,52 @@ +/* + * BSD-3-Clause + * + * Copyright (c) 2022 - 2025, Realtek Semiconductor Corp. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * * Neither the name of the Realtek nor the names of its contributors may + * be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef _SWLIB_H_ +#define _SWLIB_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +// Struct to hold value + original index +typedef struct { + int value; + int originalIndex; +} qSortItem; + +void quick_sort(qSortItem arr[], int low, int high); + +#ifdef __cplusplus +} +#endif + +#endif /* _SWLIB_H_ */ diff --git a/Controllers/RtkArgbController/rtk_argb_lib/lib/linux/hidraw/lib_rtk_argbaarch64.a b/Controllers/RtkArgbController/rtk_argb_lib/lib/linux/hidraw/lib_rtk_argbaarch64.a new file mode 100644 index 000000000..572f33325 Binary files /dev/null and b/Controllers/RtkArgbController/rtk_argb_lib/lib/linux/hidraw/lib_rtk_argbaarch64.a differ diff --git a/Controllers/RtkArgbController/rtk_argb_lib/lib/linux/hidraw/lib_rtk_argbx86_64.a b/Controllers/RtkArgbController/rtk_argb_lib/lib/linux/hidraw/lib_rtk_argbx86_64.a new file mode 100644 index 000000000..fdecb3ed6 Binary files /dev/null and b/Controllers/RtkArgbController/rtk_argb_lib/lib/linux/hidraw/lib_rtk_argbx86_64.a differ diff --git a/Controllers/RtkArgbController/rtk_argb_lib/lib/linux/libusb/lib_rtk_argbaarch64.a b/Controllers/RtkArgbController/rtk_argb_lib/lib/linux/libusb/lib_rtk_argbaarch64.a new file mode 100644 index 000000000..572f33325 Binary files /dev/null and b/Controllers/RtkArgbController/rtk_argb_lib/lib/linux/libusb/lib_rtk_argbaarch64.a differ diff --git a/Controllers/RtkArgbController/rtk_argb_lib/lib/linux/libusb/lib_rtk_argbx86_64.a b/Controllers/RtkArgbController/rtk_argb_lib/lib/linux/libusb/lib_rtk_argbx86_64.a new file mode 100644 index 000000000..fdecb3ed6 Binary files /dev/null and b/Controllers/RtkArgbController/rtk_argb_lib/lib/linux/libusb/lib_rtk_argbx86_64.a differ diff --git a/Controllers/RtkArgbController/rtk_argb_lib/lib/mac/arm64/lib_rtk_argbarm64.a b/Controllers/RtkArgbController/rtk_argb_lib/lib/mac/arm64/lib_rtk_argbarm64.a new file mode 100644 index 000000000..8fb1fab60 Binary files /dev/null and b/Controllers/RtkArgbController/rtk_argb_lib/lib/mac/arm64/lib_rtk_argbarm64.a differ diff --git a/Controllers/RtkArgbController/rtk_argb_lib/lib/mac/x86_64/lib_rtk_argbx86_64.a b/Controllers/RtkArgbController/rtk_argb_lib/lib/mac/x86_64/lib_rtk_argbx86_64.a new file mode 100644 index 000000000..49edaa3f7 Binary files /dev/null and b/Controllers/RtkArgbController/rtk_argb_lib/lib/mac/x86_64/lib_rtk_argbx86_64.a differ diff --git a/Controllers/RtkArgbController/rtk_argb_lib/lib/windows/x64/rtk_argb_libx64.lib b/Controllers/RtkArgbController/rtk_argb_lib/lib/windows/x64/rtk_argb_libx64.lib new file mode 100644 index 000000000..d63cd5ce6 Binary files /dev/null and b/Controllers/RtkArgbController/rtk_argb_lib/lib/windows/x64/rtk_argb_libx64.lib differ diff --git a/Controllers/RtkArgbController/rtk_argb_lib/lib/windows/x86/rtk_argb_libx86.lib b/Controllers/RtkArgbController/rtk_argb_lib/lib/windows/x86/rtk_argb_libx86.lib new file mode 100644 index 000000000..d91445199 Binary files /dev/null and b/Controllers/RtkArgbController/rtk_argb_lib/lib/windows/x86/rtk_argb_libx86.lib differ diff --git a/Controllers/RtkBridgeController/RGBController_RtkBridge.cpp b/Controllers/RtkBridgeController/RGBController_RtkBridge.cpp new file mode 100644 index 000000000..06818d29f --- /dev/null +++ b/Controllers/RtkBridgeController/RGBController_RtkBridge.cpp @@ -0,0 +1,294 @@ +#ifndef __FreeBSD__ + +#include "RGBController_RtkBridge.h" + +/**------------------------------------------------------------------*\ + @name Realtek Bridge Device + @category Keyboard,LEDStrip + @type USB + @save :x: + @direct :rotating_light: + @effects :white_check_mark: + @detectors DetectRtkBridgeControllers + @comment +\*-------------------------------------------------------------------*/ + +RGBController_RtkBridge::RGBController_RtkBridge(RtkBridgeWrapper *_wrapper) +{ + this->wrapper = _wrapper; + + name = wrapper->get_product_name(); + vendor = wrapper->get_manu_name(); + location = wrapper->get_dev_loc(); + serial = wrapper->get_sn(); + version = wrapper->get_fw_ver(); + description = vendor + "Storage Device"; + type = DEVICE_TYPE_STORAGE; + + SetupStrip(); + SetupZones(); +} + +void RGBController_RtkBridge::SetupStrip() +{ + int brightness = wrapper->get_argb_brightness() >> 8; + + mode Direct; + Direct.name = "Direct"; + Direct.value = LED_EFF_NONE; + Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS; + Direct.color_mode = MODE_COLORS_PER_LED; + Direct.brightness_min = 0; + Direct.brightness_max = 255; + Direct.brightness = brightness; + modes.push_back(Direct); + + mode Static; + Static.name = "Static"; + Static.value = LED_EFF_ALWAYS; + Static.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS; + Static.colors_min = 1; + Static.colors_max = 1; + Static.color_mode = MODE_COLORS_MODE_SPECIFIC; + Static.colors.resize(1); + Static.brightness_min = 0; + Static.brightness_max = 255; + Static.brightness = brightness; + modes.push_back(Static); + + mode Blink; + Blink.name = "Blink"; + Blink.value = LED_EFF_BLINK; + Blink.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED; + Blink.speed_min = RTK_BRIDGE_SPEED_MIN; + Blink.speed_max = RTK_BRIDGE_SPEED_MAX; + Blink.speed = RTK_BRIDGE_SPEED_NORMAL; + Blink.colors_min = 1; + Blink.colors_max = 1; + Blink.color_mode = MODE_COLORS_MODE_SPECIFIC; + Blink.colors.resize(1); + Blink.brightness_min = 0; + Blink.brightness_max = 255; + Blink.brightness = brightness; + modes.push_back(Blink); + + mode Breathing; + Breathing.name = "Breathing"; + Breathing.value = LED_EFF_BREATHE; + Breathing.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED; + Breathing.speed_min = RTK_BRIDGE_SPEED_MIN; + Breathing.speed_max = RTK_BRIDGE_SPEED_MAX; + Breathing.speed = RTK_BRIDGE_SPEED_NORMAL; + Breathing.colors_min = 1; + Breathing.colors_max = 1; + Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC; + Breathing.colors.resize(1); + Breathing.brightness_min = 0; + Breathing.brightness_max = 255; + Breathing.brightness = brightness; + modes.push_back(Breathing); + + mode Spectrum; + Spectrum.name = "Spectrum"; + Spectrum.value = LED_EFF_SPECTRUM; + Spectrum.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED; + Spectrum.speed_min = RTK_BRIDGE_SPEED_MIN; + Spectrum.speed_max = RTK_BRIDGE_SPEED_MAX; + Spectrum.speed = RTK_BRIDGE_SPEED_NORMAL; + Spectrum.color_mode = MODE_COLORS_NONE; + Spectrum.brightness_min = 0; + Spectrum.brightness_max = 255; + Spectrum.brightness = brightness; + modes.push_back(Spectrum); + + mode Scroll; + Scroll.name = "Scroll"; + Scroll.value = LED_EFF_SCROLL; + Scroll.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED; + Scroll.speed_min = RTK_BRIDGE_SPEED_MIN; + Scroll.speed_max = RTK_BRIDGE_SPEED_MAX; + Scroll.speed = RTK_BRIDGE_SPEED_NORMAL; + Scroll.colors_min = 1; + Scroll.colors_max = 1; + Scroll.color_mode = MODE_COLORS_MODE_SPECIFIC; + Scroll.colors.resize(1); + Scroll.brightness_min = 0; + Scroll.brightness_max = 255; + Scroll.brightness = brightness; + modes.push_back(Scroll); + + mode RainbowScroll; + RainbowScroll.name = "RainbowScroll"; + RainbowScroll.value = LED_EFF_RAINBOW_SCROLL; + RainbowScroll.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED; + RainbowScroll.speed_min = RTK_BRIDGE_SPEED_MIN; + RainbowScroll.speed_max = RTK_BRIDGE_SPEED_MAX; + RainbowScroll.speed = RTK_BRIDGE_SPEED_NORMAL; + RainbowScroll.color_mode = MODE_COLORS_NONE; + RainbowScroll.brightness_min = 0; + RainbowScroll.brightness_max = 255; + RainbowScroll.brightness = brightness; + modes.push_back(RainbowScroll); + + mode RunningWater; + RunningWater.name = "RunningWater"; + RunningWater.value = LED_EFF_RUNNING_WATER; + RunningWater.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED; + RunningWater.speed_min = RTK_BRIDGE_SPEED_MIN; + RunningWater.speed_max = RTK_BRIDGE_SPEED_MAX; + RunningWater.speed = RTK_BRIDGE_SPEED_NORMAL; + RunningWater.colors_min = 1; + RunningWater.colors_max = 1; + RunningWater.color_mode = MODE_COLORS_MODE_SPECIFIC; + RunningWater.colors.resize(1); + RunningWater.brightness_min = 0; + RunningWater.brightness_max = 255; + RunningWater.brightness = brightness; + modes.push_back(RunningWater); + + mode Sliding; + Sliding.name = "Sliding"; + Sliding.value = LED_EFF_SLIDING; + Sliding.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED; + Sliding.speed_min = RTK_BRIDGE_SPEED_MIN; + Sliding.speed_max = RTK_BRIDGE_SPEED_MAX; + Sliding.speed = RTK_BRIDGE_SPEED_NORMAL; + Sliding.color_mode = MODE_COLORS_NONE; + Sliding.brightness_min = 0; + Sliding.brightness_max = 255; + Sliding.brightness = brightness; + modes.push_back(Sliding); + + mode NewtonCradle; + NewtonCradle.name = "NewtonCradle"; + NewtonCradle.value = LED_EFF_NEWTON_CRADLE; + NewtonCradle.flags = MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED; + NewtonCradle.speed_min = RTK_BRIDGE_SPEED_MIN; + NewtonCradle.speed_max = RTK_BRIDGE_SPEED_MAX; + NewtonCradle.speed = RTK_BRIDGE_SPEED_NORMAL; + NewtonCradle.color_mode = MODE_COLORS_NONE; + NewtonCradle.brightness_min = 0; + NewtonCradle.brightness_max = 255; + NewtonCradle.brightness = brightness; + modes.push_back(NewtonCradle); + + mode Meteor; + Meteor.name = "Meteor"; + Meteor.value = LED_EFF_METEOR; + Meteor.flags = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR | MODE_FLAG_HAS_BRIGHTNESS | MODE_FLAG_HAS_SPEED; + Meteor.speed_min = RTK_BRIDGE_SPEED_MIN; + Meteor.speed_max = RTK_BRIDGE_SPEED_MAX; + Meteor.speed = RTK_BRIDGE_SPEED_NORMAL; + Meteor.colors_min = 1; + Meteor.colors_max = 1; + Meteor.color_mode = MODE_COLORS_MODE_SPECIFIC; + Meteor.colors.resize(1); + Meteor.brightness_min = 0; + Meteor.brightness_max = 255; + Meteor.brightness = brightness; + modes.push_back(Meteor); +} + +RGBController_RtkBridge::~RGBController_RtkBridge() +{ + delete wrapper; +} + +void RGBController_RtkBridge::SetupZones() +{ + zone argb_zone; + + argb_zone.name = "strip"; + argb_zone.type = ZONE_TYPE_LINEAR; + argb_zone.leds_min = wrapper->get_argb_num(); + argb_zone.leds_max = wrapper->get_argb_num(); + argb_zone.leds_count = wrapper->get_argb_num(); + argb_zone.matrix_map = NULL; + + zones.push_back(argb_zone); + + for(unsigned int led_idx = 0; led_idx < argb_zone.leds_count; led_idx++) + { + led StripLED; + StripLED.name = argb_zone.name + " "; + StripLED.name.append(std::to_string(led_idx + 1)); + leds.push_back(StripLED); + } + + SetupColors(); +} + +void RGBController_RtkBridge::ResizeZone(int /*zone*/, int /*new_size*/) +{ + /*---------------------------------------------------------*\ + | This device does not support resizing zones | + \*---------------------------------------------------------*/ +} + +void RGBController_RtkBridge::DeviceUpdateLEDs() +{ + UpdateZoneLEDs(0); +} + +void RGBController_RtkBridge::UpdateZoneLEDs(int /*zone*/) +{ + unsigned short brightness = 0xFF; + mode& curr_mode = modes[active_mode]; + + if(curr_mode.color_mode == MODE_COLORS_PER_LED && + curr_mode.value == LED_EFF_NONE) //direct mode + { + if (curr_mode.flags & MODE_FLAG_HAS_BRIGHTNESS) + brightness = curr_mode.brightness; + + wrapper->set_argb_direct(colors, brightness); + } + else + UpdateSingleLED(0); +} + +void RGBController_RtkBridge::UpdateSingleLED(int led) +{ + unsigned char speed = RTK_BRIDGE_SPEED_NORMAL; + unsigned char dir = 0; + unsigned short brightness = 0xFF; + mode& curr_mode = modes[active_mode]; + std::vector rtk_colors = curr_mode.colors; + + if(curr_mode.flags & MODE_FLAG_HAS_SPEED) + { + speed = curr_mode.speed; + } + if (curr_mode.flags & MODE_FLAG_HAS_BRIGHTNESS) + { + brightness = curr_mode.brightness; + } + if(curr_mode.flags & MODE_FLAG_HAS_DIRECTION_LR) + { + if(curr_mode.direction == MODE_DIRECTION_RIGHT) + { + dir = 1; + } + } + + if (curr_mode.color_mode == MODE_COLORS_PER_LED) + { + rtk_colors = colors; + } + else if(curr_mode.color_mode == MODE_COLORS_NONE) + { + rtk_colors.clear(); + } + + wrapper->set_argb_effect(curr_mode.value, rtk_colors, speed, brightness); +} + +void RGBController_RtkBridge::DeviceUpdateMode() +{ + if(modes[active_mode].value != LED_EFF_NONE) + { + DeviceUpdateLEDs(); + } +} + +#endif diff --git a/Controllers/RtkBridgeController/RGBController_RtkBridge.h b/Controllers/RtkBridgeController/RGBController_RtkBridge.h new file mode 100644 index 000000000..522067db8 --- /dev/null +++ b/Controllers/RtkBridgeController/RGBController_RtkBridge.h @@ -0,0 +1,23 @@ +#pragma once + +#include "RGBController.h" +#include "RtkBridgeWrapper.h" + +class RGBController_RtkBridge : public RGBController +{ +public: + RGBController_RtkBridge(RtkBridgeWrapper *_wrapper); + ~RGBController_RtkBridge(); + + void SetupStrip(); + + void SetupZones(); + void ResizeZone(int zone, int new_size); + void DeviceUpdateLEDs(); + void UpdateZoneLEDs(int zone); + void UpdateSingleLED(int led); + void DeviceUpdateMode(); + +private: + RtkBridgeWrapper *wrapper; +}; diff --git a/Controllers/RtkBridgeController/RtkBridgeControllerDetect.cpp b/Controllers/RtkBridgeController/RtkBridgeControllerDetect.cpp new file mode 100644 index 000000000..6f451046d --- /dev/null +++ b/Controllers/RtkBridgeController/RtkBridgeControllerDetect.cpp @@ -0,0 +1,82 @@ +#ifndef __FreeBSD__ + +#include "Detector.h" +#include "RGBController_RtkBridge.h" + +#define RTK_BRIDGE_VID 0x0BDA +#define RTK_BRIDGE_PID0 0x9220 +#define RTK_BRIDGE_PID1 0x9201 + +#define RTK_HID2SCSI_PG 0xFF00 +#define RTK_HID2SCSI_USAGE 0x0001 + +static struct usb_id id[] = { + {RTK_BRIDGE_VID, RTK_BRIDGE_PID0}, + {RTK_BRIDGE_VID, RTK_BRIDGE_PID1}, + }; + +/******************************************************************************************\ +* * +* DetectRtkBridgeControllers * +* * +* Tests the USB address to see if an Realtek Bridge controller exists there * +* * +\******************************************************************************************/ +void DetectRtkBridgeControllers(hid_device_info *info, const std::string &name) +{ + RtkBridgeWrapper *wrapper = NULL; + RGBController_RtkBridge *controller = NULL; + dHandle fd = NULL_DHANDLE; + struct led_mem *led_mem_dev = NULL; + char path[256] = {0}; + + sprintf(path, "%s:%d", info->path, 0); + fd = bridge_open_handle(path); + if (INVALID_DHANDLE(fd)) { + goto exit; + } + + if (!led_get_ic_support_sync_light(fd, SYNC_METHOD_OPENRGB)) { + goto exit; + } + + if (!bridge_check_target(fd)) { + goto exit; + } + + if (bridge_write_unlock(fd)) { + goto exit; + } + + led_mem_dev = (struct led_mem *)malloc(sizeof(struct led_mem)); + if (!led_mem_dev) { + goto exit; + } + + memset(led_mem_dev, 0, sizeof(struct led_mem)); + if (led_mem_init(fd, led_mem_dev)) { + free(led_mem_dev); + goto exit; + } + led_mem_dev->sync_method = SYNC_METHOD_OPENRGB; + + wrapper = new RtkBridgeWrapper(fd, led_mem_dev, info); + controller = new RGBController_RtkBridge(wrapper); + if(controller->type != DEVICE_TYPE_UNKNOWN) + { + ResourceManager::get()->RegisterRGBController(controller); + } + else + { + delete wrapper; + delete controller; + } + +exit: + return; +} + +REGISTER_HID_DETECTOR_PU ("RTL9220", DetectRtkBridgeControllers, RTK_BRIDGE_VID, RTK_BRIDGE_PID0, RTK_HID2SCSI_PG, RTK_HID2SCSI_USAGE); +REGISTER_HID_DETECTOR_PU ("RTL9201", DetectRtkBridgeControllers, RTK_BRIDGE_VID, RTK_BRIDGE_PID1, RTK_HID2SCSI_PG, RTK_HID2SCSI_USAGE); + +#endif diff --git a/Controllers/RtkBridgeController/RtkBridgeWrapper.cpp b/Controllers/RtkBridgeController/RtkBridgeWrapper.cpp new file mode 100644 index 000000000..fa90bdb54 --- /dev/null +++ b/Controllers/RtkBridgeController/RtkBridgeWrapper.cpp @@ -0,0 +1,217 @@ +#ifndef __FreeBSD__ + +#include "RtkBridgeWrapper.h" + + +RtkBridgeWrapper::RtkBridgeWrapper(dHandle fd, struct led_mem *led_mem_dev, hid_device_info *info) +{ + this->fd = fd; + this->led_mem_dev = led_mem_dev; + this->hidinfo = info; + + led_set_appctl(fd, true); +} + +RtkBridgeWrapper::~RtkBridgeWrapper() +{ + led_set_appctl(fd, false); + + if (!INVALID_DHANDLE(fd)) + bridge_close_handle(fd); + + if (led_mem_dev) { + led_mem_deinit(led_mem_dev); + free(led_mem_dev); + led_mem_dev = NULL; + } +} + +std::string RtkBridgeWrapper::get_manu_name() +{ + return wcharToString(hidinfo->manufacturer_string); +} + +std::string RtkBridgeWrapper::get_product_name() +{ + return wcharToString(hidinfo->product_string); +} + +std::string RtkBridgeWrapper::get_sn() +{ + return wcharToString(hidinfo->serial_number); +} + +std::string RtkBridgeWrapper::get_dev_loc() +{ + return hidinfo->path; +} + +std::string RtkBridgeWrapper::get_fw_ver() +{ + struct bridge_fw_version fw_ver; + std::string ver = ""; + + bridge_get_fw_ver(fd, &fw_ver); + 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; +} + +int RtkBridgeWrapper::get_argb_num() +{ + int ret = -1; + int num_rgb = 0; + + ret = led_mem_get_rgb_num(led_mem_dev, &num_rgb); + if (ret) + { + num_rgb = 0; + goto exit; + } +exit: + return num_rgb; +} + +int RtkBridgeWrapper::get_argb_brightness() +{ + int ret = -1; + uint16_t bright = 0; + + ret = led_mem_get_bright(fd, led_mem_dev, &bright); + if (ret) + { + bright = 0; + goto exit; + } +exit: + return bright; +} + +int RtkBridgeWrapper::set_argb_direct(std::vector color_buf, unsigned short brightness) +{ + int ret = -1; + int color_num = color_buf.size(); + int buf_len = color_num * 3; + static unsigned short prev_bright = 0xFFFF; + uint8_t *buf; + + if (color_num <= 0) + goto exit; + + ret = led_set_appctl(fd, true); + if (ret) + goto exit; + + if (prev_bright != brightness) + { + prev_bright = brightness; + ret = led_mem_set_bright(fd, led_mem_dev, brightness << 8, true); + if (ret) + goto exit; + } + + buf = (uint8_t*)malloc(buf_len); + memset(buf, 0, buf_len); + for (int i = 0; i < color_num; i++) + { + buf[i * 3 + 0] = RGBGetRValue(color_buf[i]); + buf[i * 3 + 1] = RGBGetGValue(color_buf[i]); + buf[i * 3 + 2] = RGBGetBValue(color_buf[i]); + } + ret = led_mem_write_rgb_direct(fd, led_mem_dev, buf, color_num); + free(buf); + if (ret) + goto exit; +exit: + return ret; +} + +int RtkBridgeWrapper::set_argb_effect(uint8_t mode, std::vector color_buf, int speed, unsigned short brightness) +{ + int ret = -1; + int cycle = interpolate(RTK_BRIDGE_CYCLE_MAX, RTK_BRIDGE_CYCLE_MIN, speed, RTK_BRIDGE_SPEED_MAX + 1); + RGBQUAD rgb = { 0, 0, 0, 0 }; + static unsigned short prev_bright = 0xFFFF; + + if (color_buf.size() >= 1) + { + rgb.rgbRed = color_buf[0] & 0xFF; + rgb.rgbGreen = (color_buf[0] & 0xFF00) >> 8; + rgb.rgbBlue = (color_buf[0] & 0xFF0000) >> 16; + } + + if (prev_bright != brightness) + { + prev_bright = brightness; + ret = led_mem_set_bright(fd, led_mem_dev, brightness << 8, false); + if (ret) + goto exit; + } + + switch (mode) + { + case LED_EFF_ALWAYS: + ret = led_eff_set_always_on(fd, led_mem_dev, rgb); + break; + case LED_EFF_BLINK: + ret = led_eff_set_blink(fd, led_mem_dev, rgb, cycle); + break; + case LED_EFF_BREATHE: + ret = led_eff_set_breathe(fd, led_mem_dev, rgb, cycle); + break; + case LED_EFF_SPECTRUM: + ret = led_eff_set_spectrum(fd, led_mem_dev, cycle); + break; + case LED_EFF_SCROLL: + ret = led_eff_set_scroll(fd, led_mem_dev, rgb, cycle); + break; + case LED_EFF_RAINBOW_SCROLL: + ret = led_eff_set_rainbow_scroll(fd, led_mem_dev, cycle); + break; + case LED_EFF_RUNNING_WATER: + ret = led_eff_set_running_water(fd, led_mem_dev, rgb, cycle); + break; + case LED_EFF_SLIDING: + ret = led_eff_set_sliding(fd, led_mem_dev, cycle); + break; + case LED_EFF_NEWTON_CRADLE: + ret = led_eff_set_newton_cradle(fd, led_mem_dev, cycle); + break; + case LED_EFF_METEOR: + ret = led_eff_set_meteor(fd, led_mem_dev, rgb, cycle); + break; + default: + break; + } +exit: + return ret; +} + +int RtkBridgeWrapper::interpolate(int vStart, int vEnd, int pos, int pos_num) +{ + if (vStart != vEnd) + return (int)round((vStart * (pos_num - 1 - pos) + vEnd * pos) / (double)(pos_num - 1)); + else + return vStart; +} + +std::string RtkBridgeWrapper::wcharToString(const wchar_t *wstr) +{ +#ifdef _WIN32 + int size_needed = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, nullptr, 0, nullptr, nullptr); +#else + int size_needed = wcstombs(nullptr, wstr, 0); +#endif + std::string str(size_needed, 0); + +#ifdef _WIN32 + WideCharToMultiByte(CP_UTF8, 0, wstr, -1, &str[0], size_needed, nullptr, nullptr); +#else + wcstombs(&str[0], wstr, size_needed); +#endif + return str; +} + +#endif diff --git a/Controllers/RtkBridgeController/RtkBridgeWrapper.h b/Controllers/RtkBridgeController/RtkBridgeWrapper.h new file mode 100644 index 000000000..3f80cec1b --- /dev/null +++ b/Controllers/RtkBridgeController/RtkBridgeWrapper.h @@ -0,0 +1,59 @@ +#pragma once + +#define CONFIG_HID +#define CONFIG_HID_ALL + +#include +#include +#include +#include +#include + +#include "RGBController.h" +#include +#include "platform.h" +#include "bridge_dev.h" +#include "bridge_func.h" +#include "led.h" +#include "led_effect.h" + + +enum RTK_BRIDGE_SPEED +{ + RTK_BRIDGE_SPEED_MIN = 1, + RTK_BRIDGE_SPEED_NORMAL = 50, + RTK_BRIDGE_SPEED_MAX = 100, +}; + +enum RTK_BRIDGE_CYCLE_MS +{ + RTK_BRIDGE_CYCLE_MIN = 200, + RTK_BRIDGE_CYCLE_NORMAL = 2000, + RTK_BRIDGE_CYCLE_MAX = 10000, +}; + +class RtkBridgeWrapper +{ +public: + RtkBridgeWrapper(dHandle fd, struct led_mem *led_mem_dev, hid_device_info *info); + ~RtkBridgeWrapper(); + + std::string get_manu_name(); + std::string get_product_name(); + std::string get_sn(); + std::string get_dev_loc(); + std::string get_fw_ver(); + int get_argb_num(); + int get_argb_brightness(); + + int set_argb_direct(std::vector color_buf, unsigned short brightness); + int set_argb_effect(uint8_t mode, std::vector color_buf, int speed, unsigned short brightness); + +private: + dHandle fd = NULL_DHANDLE; + struct led_mem *led_mem_dev = NULL; + hid_device_info *hidinfo = NULL; + + int interpolate(int vStart, int vEnd, int pos, int pos_num); + std::string wcharToString(const wchar_t *wstr); +}; diff --git a/OpenRGB.pro b/OpenRGB.pro index 8e68a856a..f31ce3107 100644 --- a/OpenRGB.pro +++ b/OpenRGB.pro @@ -377,6 +377,7 @@ win32:contains(QMAKE_TARGET.arch, x86_64) { -L"$$PWD/dependencies/hidapi-win/x64/" -lhidapi \ -L"$$PWD/dependencies/mbedtls-3.2.1/lib/x64/" -lmbedcrypto -lmbedtls -lmbedx509 \ -L"$$PWD/dependencies/PawnIO/" -lPawnIOLib \ + -L"$$PWD/Controllers/RtkArgbController/rtk_argb_lib/lib/windows/x64/" -lrtk_argb_libx64 \ } win32:contains(QMAKE_TARGET.arch, x86) { @@ -389,6 +390,7 @@ win32:contains(QMAKE_TARGET.arch, x86) { -L"$$PWD/dependencies/libusb-1.0.27/VS2019/MS32/dll" -llibusb-1.0 \ -L"$$PWD/dependencies/hidapi-win/x86/" -lhidapi \ -L"$$PWD/dependencies/mbedtls-3.2.1/lib/x86/" -lmbedcrypto -lmbedtls -lmbedx509 \ + -L"$$PWD/Controllers/RtkArgbController/rtk_argb_lib/lib/windows/x86/" -lrtk_argb_libx86 \ } win32:DEFINES -= \ @@ -504,6 +506,16 @@ contains(QMAKE_PLATFORM, linux) { packagesExist(hidapi-hidraw) { PKGCONFIG += hidapi-hidraw + contains(QMAKE_HOST.arch, x86_64) { + LIBS += \ + -L$$PWD/Controllers/RtkArgbController/rtk_argb_lib/lib/linux/hidraw/ -l_rtk_argbx86_64 \ + } + + contains(QMAKE_HOST.arch, aarch64) { + LIBS += \ + -L$$PWD/Controllers/RtkArgbController/rtk_argb_lib/lib/linux/hidraw/ -l_rtk_argbaarch64 \ + } + #---------------------------------------------------------------------------------------# # hidapi-hidraw >= 0.10.1 supports USAGE/USAGE_PAGE # # Define USE_HID_USAGE if hidapi-hidraw supports it # @@ -515,8 +527,27 @@ contains(QMAKE_PLATFORM, linux) { } else { packagesExist(hidapi-libusb) { PKGCONFIG += hidapi-libusb + + contains(QMAKE_HOST.arch, x86_64) { + LIBS += \ + -L$$PWD/Controllers/RtkArgbController/rtk_argb_lib/lib/linux/libusb/ -l_rtk_argbx86_64 \ + } + + contains(QMAKE_HOST.arch, aarch64) { + LIBS += \ + -L$$PWD/Controllers/RtkArgbController/rtk_argb_lib/lib/linux/libusb/ -l_rtk_argbaarch64 \ + } } else { PKGCONFIG += hidapi + contains(QMAKE_HOST.arch, x86_64) { + LIBS += \ + -L$$PWD/Controllers/RtkArgbController/rtk_argb_lib/lib/linux/libusb/ -l_rtk_argbx86_64 \ + } + + contains(QMAKE_HOST.arch, aarch64) { + LIBS += \ + -L$$PWD/Controllers/RtkArgbController/rtk_argb_lib/lib/linux/libusb/ -l_rtk_argbaarch64 \ + } } } @@ -771,6 +802,7 @@ macx:contains(QMAKE_HOST.arch, arm64) { LIBS += \ -L/opt/homebrew/lib \ + -L$$PWD/Controllers/RtkArgbController/rtk_argb_lib/lib/mac/arm64/ -l_rtk_argbarm64 \ } #-----------------------------------------------------------------------------------------------# @@ -800,6 +832,7 @@ macx:contains(QMAKE_HOST.arch, x86_64) { LIBS += \ -L/usr/local/lib \ -L/usr/local/homebrew/lib \ + -L$$PWD/Controllers/RtkArgbController/rtk_argb_lib/lib/mac/x86_64/ -l_rtk_argbx86_64 \ DEFINES += \ _MACOSX_X86_X64 \