gilles/asusctl
1
0
Fork 0
mirror of https://gitlab.com/asus-linux/asusctl.git synced 2026-02-06 00:15:04 +01:00
Code Issues Packages Projects Releases Wiki Activity

Bright go up. Bright go down.

Browse Source
This commit is contained in:
Luke
2020-04-17 15:21:26 +12:00
parent e49799e4d2
commit 1616633abf
9 changed files with 130 additions and 33 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Cargo.lock generated
View File

@@ -170,7 +170,6 @@ dependencies = [
"rog-lib",
"serde",
"serde_derive",
"toml",
]
[[package]]
@@ -181,6 +180,7 @@ dependencies = [
"rusb",
"serde",
"serde_derive",
"toml",
]
[[package]]

2
rog-core/Cargo.toml
View File

@@ -9,5 +9,5 @@ gumdrop = "0.8"
dbus = "0.7.1"
serde = "1.0"
serde_derive = "1.0"
toml = "0.5"
rog-lib = { path = "../rog-lib" }

30
rog-core/src/daemon.rs
View File

@@ -1,15 +1,17 @@
use crate::{config::Config, DBUS_IFACE, DBUS_PATH};
use crate::{DBUS_IFACE, DBUS_PATH};
use dbus::{
blocking::Connection,
tree::{Factory, MethodErr},
};
use rog_lib::core::RogCore;
use rog_lib::hotkeys::*;
use rog_lib::{config::Config, core::RogCore};
use std::error::Error;
use std::time::Duration;
use std::{cell::RefCell, rc::Rc};
pub struct Daemon {
rogcore: RogCore,
hotkeys: Box<dyn Laptop>,
config: Config,
}
@@ -17,6 +19,7 @@ impl Daemon {
pub fn new() -> Self {
Daemon {
rogcore: RogCore::new().expect("Could not start RogCore"),
hotkeys: Box::new(LaptopGX502GW::new()),
config: Config::default().read(),
}
}
@@ -83,17 +86,14 @@ impl Daemon {
// We add the tree to the connection so that incoming method calls will be handled.
tree.start_receive(&connection);
let mut key_buf = [0u8; 32];
loop {
connection.process(Duration::from_millis(5))?;
connection.process(Duration::from_millis(1))?;
// READ KEYBOARD
// TODO: this needs to move to a thread
match daemon.borrow_mut().rogcore.poll_keyboard() {
Ok(buf) => {
// [5d, 1, 0, 0, 52, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] up
// [5d, 1, 0, 0, 51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] down
// [5d, 1, 0, 0, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] left
// [5d, 1, 0, 0, 4f, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] right
// TODO: this needs to move to a thread, but there is unsafety
match daemon.borrow_mut().rogcore.poll_keyboard(&mut key_buf) {
Ok(read) => {
// [5a, c4, ; 32 bytes long] fn+up
// [5a, c5, ; 32 bytes long] fn+down
// [5a, b2, ; 32 bytes long] fn+left
@@ -103,7 +103,15 @@ impl Daemon {
// read config + inc/dec brightness byte
// write to aura
// write config
println!("{:x?}", buf);
let hotkeys = unsafe { &mut (*daemon.as_ptr()).hotkeys };
let mut rogcore = unsafe { &mut (*daemon.as_ptr()).rogcore };
let mut config = unsafe { &mut (*daemon.as_ptr()).config };
if let Some(_count) = read {
if key_buf[0] == hotkeys.hotkey_group_byte() {
hotkeys.do_hotkey_action(&mut rogcore, &mut config, key_buf[1]);
}
}
}
Err(err) => println!("{:?}", err),
}

2
rog-core/src/main.rs
View File

@@ -1,5 +1,4 @@
// TODO: use /sys/class/dmi/id/board_name to detect model
mod config;
mod daemon;
use crate::daemon::*;
@@ -12,7 +11,6 @@ use rog_lib::core::{LedBrightness, RogCore, LED_MSG_LEN};
pub static DBUS_NAME: &'static str = "org.rogcore.Daemon";
pub static DBUS_PATH: &'static str = "/org/rogcore/Daemon";
pub static DBUS_IFACE: &'static str = "org.rogcore.Daemon";
pub static CONFIG_PATH: &'static str = "/etc/rogcore.conf";
#[derive(Debug, Options)]
struct CLIStart {

1
rog-lib/Cargo.toml
View File

@@ -9,3 +9,4 @@ rusb = "0.5"
gumdrop = "0.8"
serde = "1.0"
serde_derive = "1.0"
toml = "0.5"

7
rog-core/src/config.rs → rog-lib/src/config.rs
View File

@@ -1,11 +1,12 @@
use crate::CONFIG_PATH;
use rog_lib::{aura::SetAuraBuiltin, core::LED_MSG_LEN};
use crate::{aura::SetAuraBuiltin, core::LED_MSG_LEN};
use serde_derive::{Deserialize, Serialize};
use std::fs::{File, OpenOptions};
use std::io::{Read, Write};
pub static CONFIG_PATH: &'static str = "/etc/rogcore.conf";
#[derive(Default, Deserialize, Serialize)]
pub(crate) struct Config {
pub struct Config {
pub brightness: u8,
pub builtin: Vec<u8>,
}

25
rog-lib/src/core.rs
View File

@@ -55,38 +55,34 @@ pub struct RogCore {
handle: DeviceHandle<rusb::GlobalContext>,
initialised: bool,
led_interface_num: u8,
keys_interface_num: u8,
}
impl RogCore {
pub fn new() -> Result<RogCore, Error> {
// TODO: make this more configurable
let mut handle = RogCore::get_device(0x0B05, 0x1866)?;
handle.set_active_configuration(0).unwrap_or(());
let config = handle.device().config_descriptor(0).unwrap();
// Interface with outputs
let mut keys_interface_num = 0;
let mut led_interface_num = 0;
for iface in config.interfaces() {
for desc in iface.descriptors() {
for endpoint in desc.endpoint_descriptors() {
if endpoint.address() == 0x83 {
keys_interface_num = desc.interface_number();
} else if endpoint.address() == 0x81 {
if endpoint.address() == 0x81 {
led_interface_num = desc.interface_number();
break;
}
}
}
}
handle.set_auto_detach_kernel_driver(true).unwrap();
handle.set_auto_detach_kernel_driver(true).unwrap();
Ok(RogCore {
handle,
initialised: false,
led_interface_num,
keys_interface_num,
})
}
@@ -144,22 +140,21 @@ impl RogCore {
self.aura_write_messages(&messages)
}
pub fn poll_keyboard(&mut self) -> Result<[u8; 32], Error> {
self.handle.claim_interface(self.keys_interface_num)?;
let mut buf = [0; 32];
pub fn poll_keyboard(&mut self, buf: &mut [u8; 32]) -> Result<Option<usize>, Error> {
match self
.handle
.read_interrupt(0x83, &mut buf, Duration::from_micros(10))
.read_interrupt(0x83, buf, Duration::from_micros(10))
{
Ok(_) => {
self.handle.release_interface(self.keys_interface_num)?;
Ok(buf)
Ok(o) => {
if buf[0] == 0x5a {
return Ok(Some(o));
}
}
Err(err) => match err {
//Error::Timeout => {}
_ => return Err(err),
},
}
Ok(None)
}
}

92
rog-lib/src/hotkeys.rs Normal file
View File

@@ -0,0 +1,92 @@
use crate::config::Config;
use crate::core::RogCore;
pub trait Laptop {
fn do_hotkey_action(&self, core: &mut RogCore, config: &mut Config, key_byte: u8);
fn hotkey_group_byte(&self) -> u8;
}
pub struct LaptopGX502GW {
hotkey_group_byte: u8,
min_bright: u8,
max_bright: u8,
}
impl LaptopGX502GW {
pub fn new() -> Self {
LaptopGX502GW {
hotkey_group_byte: 0x5a,
min_bright: 0x00,
max_bright: 0x03,
}
}
}
impl Laptop for LaptopGX502GW {
fn do_hotkey_action(&self, core: &mut RogCore, config: &mut Config, key_byte: u8) {
match GX502GWKeys::from(key_byte) {
GX502GWKeys::Rog => {
println!("ROG!");
}
GX502GWKeys::LedBrightUp => {
let mut bright = config.brightness;
if bright < self.max_bright {
bright += 1;
config.brightness = bright;
}
let bytes = RogCore::aura_brightness_bytes(bright).unwrap();
core.aura_set_mode(&bytes).unwrap();
config.write();
}
GX502GWKeys::LedBrightDown => {
let mut bright = config.brightness;
if bright > self.min_bright {
bright -= 1;
config.brightness = bright;
}
let bytes = RogCore::aura_brightness_bytes(bright).unwrap();
core.aura_set_mode(&bytes).unwrap();
config.write();
}
_ => println!("{:X?}", key_byte),
}
}
fn hotkey_group_byte(&self) -> u8 {
self.hotkey_group_byte
}
}
pub enum GX502GWKeys {
Rog = 0x38,
MicToggle = 0x7C,
Fan = 0xAE,
ScreenToggle = 0x35,
ScreenBrightDown = 0x10,
ScreenBrightUp = 0x20,
TouchPadToggle = 0x6b,
Sleep = 0x6C,
AirplaneMode = 0x88,
LedBrightUp = 0xC4,
LedBrightDown = 0xC5,
AuraPrevious = 0xB2,
AuraNext = 0xB3,
None,
}
impl From<u8> for GX502GWKeys {
fn from(byte: u8) -> Self {
match byte {
0x38 => GX502GWKeys::Rog,
0x7C => GX502GWKeys::MicToggle,
0xAE => GX502GWKeys::Fan,
0x35 => GX502GWKeys::ScreenToggle,
0x10 => GX502GWKeys::ScreenBrightDown,
0x20 => GX502GWKeys::ScreenBrightUp,
0x6b => GX502GWKeys::TouchPadToggle,
0x6C => GX502GWKeys::Sleep,
0x88 => GX502GWKeys::AirplaneMode,
0xC4 => GX502GWKeys::LedBrightUp,
0xC5 => GX502GWKeys::LedBrightDown,
0xB2 => GX502GWKeys::AuraPrevious,
0xB3 => GX502GWKeys::AuraNext,
_ => GX502GWKeys::None,
}
}
}

2
rog-lib/src/lib.rs
View File

@@ -1,3 +1,5 @@
pub mod aura;
pub mod config;
pub mod core;
mod error;
pub mod hotkeys;