Initial commit

Author: Subsentient

.gitignore

@@ -0,0 +1,2 @@
+**/__pycache__
+**/*.pyc

PPConfig.py

@@ -0,0 +1,53 @@
+#User editable config file. Change triggers here as you see fit.
+
+import PPButtonMon, PPActions
+from PPTypes import *
+import time
+
+XorgUser = 'ben' #User account Xorg is running on
+SoftLockResleepSecs = 5 #Shut the display off again after this amount of time if awoken by an event and NOT the user
+HardLockResleepSecs = 30 #After 30 seconds of a wakeup event, if the user hasn't unlocked us, go back to sleep
+
+def CheckForSoftLock(ButtonStates): #Soft press power
+	if any([ButtonStates[S].IsPressed for S in (ButtonType.VOLDOWN, ButtonType.VOLUP)]) \
+	or not ButtonStates[ButtonType.POWER].IsPressed:
+		return False #Probably a hard lock
+	
+	if PPLockState.Instance.HardLocked or PPLockState.Instance.SoftLocked:
+		PPActions.PerformUnlock()
+	else:
+		PPActions.PerformSoftLock()
+
+	return True
+
+def CheckForHardLock(ButtonStates): #Vol down + power at same time
+	if PPLockState.Instance.HardLocked:
+		return False #Don't re-lock if we're already locked.
+		
+	if not all([ButtonStates[S].IsPressed for S in (ButtonType.VOLDOWN, ButtonType.POWER)]):
+		return False
+	
+	PPActions.PerformHardLock()
+	return True
+	
+def CheckForRotate(ButtonStates):
+	if not all([not ButtonStates[S].IsPressed for S in ButtonStates]):
+		return False #Can't have a button held down to trigger this
+	
+	if not ButtonStates[ButtonType.VOLDOWN].ChangeTime or not ButtonStates[ButtonType.VOLUP].ChangeTime:
+		return False
+		
+	Distance = ButtonStates[ButtonType.VOLDOWN].ChangeTime - ButtonStates[ButtonType.VOLUP].ChangeTime
+	
+	if Distance < 0:
+		Distance = -Distance
+	
+	
+	if Distance > 1500 or Distance > (time.time_ns() // 1000) + 1000: #No longer than 1.5secs distance, and not more than a second ago.
+		return False
+	
+	PPActions.PerformRotate()
+	
+	return True
+
+EventTriggerFuncs = (CheckForSoftLock, CheckForHardLock, CheckForRotate)

components/KernelControl.py

@@ -0,0 +1,17 @@
+import time
+
+def SetCPUPower(CoreID, Online):
+	with open(f'/sys/devices/system/cpu/cpu{CoreID}/online', 'w') as Desc:
+		Desc.write(f'{int(Online)}')
+
+def SetCPUPowersave(CoreID, UsePowersave):
+	with open(f'/sys/devices/system/cpu/cpu{CoreID}/cpufreq/scaling_governor', 'w') as Desc:
+		Desc.write('powersave' if UsePowersave else 'ondemand')
+
+def ActivateSleep():
+	with open('/sys/power/state', 'w') as Desc:
+		Desc.write('mem')
+	
+	time.sleep(0.25) #Give it a moment, though in my experience it's instant
+	
+

components/PPActions.py

@@ -0,0 +1,64 @@
+
+import KernelControl, XorgControl
+from PPTypes import PPLockState, ButtonAction
+import time
+
+def PerformSoftLock():
+	State = PPLockState.Instance
+
+	XorgControl.SetTouchscreenPower(False)
+	
+	for CoreID in range(1, 4):
+		KernelControl.SetCPUPower(CoreID, False)
+		
+	KernelControl.SetCPUPowersave(0, True)
+
+	State.SoftLocked = True
+	
+	print('Soft locked PinePhone')
+	
+def PerformHardLock():
+	PerformSoftLock()
+
+	PPLockState.Instance.HardLocked = True
+
+	print('Performing hard lock')
+
+	KernelControl.ActivateSleep()
+
+	print('Woken from hard lock')
+
+	PPLockState.Instance.LastHardLockWake = int(time.time())
+	
+def PerformUnlock():
+	State = PPLockState.Instance
+
+	State.HardLocked = False
+	State.SoftLocked = False
+
+	for CoreID in range(4):
+		KernelControl.SetCPUPower(CoreID, True)
+		KernelControl.SetCPUPowersave(CoreID, False)
+
+	XorgControl.SetTouchscreenPower(True)
+
+	print('Unlocked PinePhone')
+
+
+def PerformRotate():
+	if PPLockState.Instance.RightRotated:
+		XorgControl.SetNormalRotation()
+		print('Rotated to portrait orientation')
+	else:
+		XorgControl.SetRightRotation()
+		print('Rotated to landscape orientation')
+	
+	PPLockState.Instance.RightRotated = not PPLockState.Instance.RightRotated
+
+ActionMap = {
+				ButtonAction.UNLOCK : PerformUnlock,
+				ButtonAction.SOFTLOCK : PerformSoftLock,
+				ButtonAction.SCREENROTATE : PerformRotate,
+				ButtonAction.HARDLOCK : PerformHardLock,
+			}
+				

components/PPButtonMon.py

@@ -0,0 +1,94 @@
+import threading, struct, queue
+from PPTypes import *
+
+FormatString = '@nnHHi'
+FormatSize = struct.calcsize(FormatString)
+
+class KernelInputEventStruct:
+	Fields = ('tv_sec', 'tv_usec', 'type', 'code', 'value')
+
+	def __init__(self, Input):
+		Blob = struct.unpack(FormatString, Input)
+		assert len(self.Fields) == len(Blob)
+		
+		for Inc, Field in enumerate(self.Fields):
+			setattr(self, Field, Blob[Inc])
+		
+	@property	
+	def MSTime(self):
+		return ((self.tv_sec * 1_000_000) + self.tv_usec) // 1000
+
+class ButtonMonitor:
+	def __init__(self):
+		self.__PowerThread = threading.Thread(target=self.__PowerThreadFunc)
+		self.__VolThread = threading.Thread(target=self.__VolThreadFunc)
+		self.__ShouldDie = False
+		self.__DieLock = threading.Lock()
+		self.__ButtonStates = { ButtonType(S) : ButtonState(S) for S in (ButtonType.POWER, ButtonType.VOLDOWN, ButtonType.VOLUP) }
+		self.__ButtonEvent = queue.Queue()
+		self.__PowerThread.start()
+		self.__VolThread.start()
+
+	@property
+	def ShouldDie(self):
+		with self.__DieLock:
+			return bool(self.__ShouldDie)
+
+	@ShouldDie.setter
+	def ShouldDie(self, Value):
+		with self.__DieLock:
+			self.__ShouldDie = Value
+
+	def WaitForChange(self, Timeout = None):
+		try:
+			return self.__ButtonEvent.get(timeout=Timeout)
+		except queue.Empty:
+			return None
+	
+	def __del__(self):
+		return #Might be blocking on a read(), just forget about it and let Python deal with it.
+		
+		self.__ShouldDie = True
+		self.__PowerThread.join()
+		self.__VolThread.join()
+
+	def __VolThreadFunc(self):
+		with open('/dev/input/event1', 'rb') as Desc:
+			while not self.ShouldDie:
+				Blob = Desc.read(FormatSize)
+				
+				S = KernelInputEventStruct(Blob)
+	
+				if not S.type or not S.code: continue #Filter useless data
+	
+				print(f'Volume button event {S.__dict__}')
+	
+				with self.__ButtonStates[ButtonType(S.code)] as Button:
+					Button.IsPressed = bool(S.value)
+					Button.LastChangeTime = Button.ChangeTime
+					Button.ChangeTime = S.MSTime
+				
+				self.__ButtonEvent.put(self.GetButtonStates())
+	
+		
+	def __PowerThreadFunc(self):
+		with open('/dev/input/event0', 'rb') as Desc:
+			while not self.ShouldDie:
+				Blob = Desc.read(FormatSize)
+					
+				S = KernelInputEventStruct(Blob)
+	
+				if not S.code: continue #Filter useless data
+	
+				print(f'Power button event {S.__dict__}')
+			
+				with self.__ButtonStates[ButtonType.POWER] as Button:
+					Button.IsPressed = bool(S.value)
+					Button.LastChangeTime = Button.ChangeTime
+					Button.ChangeTime = S.MSTime
+
+				self.__ButtonEvent.put(self.GetButtonStates())
+
+	def GetButtonStates(self):
+		return { S : self.__ButtonStates[S].Clone() for S in self.__ButtonStates }
+

components/PPTypes.py

@@ -0,0 +1,60 @@
+import threading
+from enum import IntEnum, auto
+
+class ButtonAction(IntEnum):
+	INVALID = 0
+	SOFTLOCK = 1
+	HARDLOCK = 2
+	UNLOCK = 3
+	SCREENROTATE = 4
+	POWERDOWN = 5
+	MAX = auto()
+	
+class ButtonType(IntEnum):
+	INVALID = 0
+	POWER = 1
+	VOLDOWN = 114
+	VOLUP = 115
+	MAX = auto()
+
+class ButtonState:
+	def __init__(self, Type):
+		self.IsPressed = False
+		self.ChangeTime = 0
+		self.LastChangeTime = 0
+		self.__Type = Type
+		self.Lock = threading.Lock()
+
+	def __enter__(self):
+		self.Lock.acquire()
+		return self
+
+	def __exit__(self, *Discarded):
+		self.Lock.release()
+
+	def Clone(self):
+		B = ButtonState(self.Type)
+
+		with self.Lock:
+			B.IsPressed = self.IsPressed
+			B.ChangeTime = self.ChangeTime
+			B.LastChangeTime = self.LastChangeTime
+		
+		return B
+
+	@property
+	def Type(self):
+		return ButtonType(self.__Type)
+
+class PPLockState:
+	Instance = None
+	
+	def __init__(self):
+		if self.Instance:
+			raise RuntimeError('Class already instantiated')
+
+		self.SoftLocked = False #Screen is off, touch is disabled, cores are in powersave
+		self.HardLocked = False #We're in suspend/standby, waiting for a wake event
+		self.RightRotated = False #Screen is rotated to the right
+		self.LastHardLockWake = 0
+		type(self).Instance = self

components/XorgControl.py

@@ -0,0 +1,92 @@
+import subprocess, re, os, sys, pwd, multiprocessing
+import PPConfig
+
+def RunAsXorgUser(Username, Func, Args = tuple()):
+	Recv, Send = multiprocessing.Pipe()
+	
+	PID = os.fork()
+
+	if PID: #Parent process
+		return Recv.recv()
+
+	User = pwd.getpwnam(Username)
+
+	os.setgid(User.pw_gid)
+	os.setuid(User.pw_uid)
+
+	os.putenv('DISPLAY', ':0')
+	
+	Send.send(Func(*Args))
+
+	os._exit(0) #Child terminates after it's done
+
+	
+def _IsMonitorOnImpl():
+	Stringy = subprocess.run(['xset', '-q'], capture_output=True).stdout.decode('utf-8')
+
+	return bool(re.match('.*Monitor is On.*', Stringy))
+	
+def IsMonitorOn():
+	return RunAsXorgUser(PPConfig.XorgUser, _IsMonitorOnImpl)
+
+def _FindTSIDImpl():
+	Stringy = subprocess.run('xinput', capture_output=True).stdout.decode('utf-8')
+
+	Strings = Stringy.splitlines()
+
+	FoundString = None
+
+	Rx = re.compile('.*Goodix Capacitive TouchScreen.*id\=(\d+).*')
+
+	for Line in Strings:
+		R = Rx.search(Line)
+
+		if not R:
+			continue
+
+		try:
+			if R.group(1).isnumeric():
+				return R.group(1)
+				
+		except:
+			continue
+
+def FindTSID():
+	return RunAsXorgUser(PPConfig.XorgUser, _FindTSIDImpl)
+
+
+def __SetTouchscreenPowerImpl(Online):
+	PowerString = 'on' if Online else 'off'
+	TimeoutString = '0' if Online else '5'
+	TouchString = '-enable' if Online else '-disable'
+
+	Cmds = (f'xset dpms force {PowerString}',
+			f'xset dpms {TimeoutString}',
+			f'xinput {TouchString} {FindTSID()}')
+
+	for Cmd in Cmds:
+		os.system(Cmd)
+
+def SetTouchscreenPower(Online):
+	return RunAsXorgUser(PPConfig.XorgUser, __SetTouchscreenPowerImpl, (Online,))
+	
+def _SetRightRotationImpl():
+	Cmds = ('xrandr --output DSI-1 --rotate right',
+			f'xinput set-prop {FindTSID()} "Coordinate Transformation Matrix" 0 1 0 -1 0 1 0 0 1')
+
+	for Cmd in Cmds:
+		os.system(Cmd)
+
+def SetRightRotation():
+	return RunAsXorgUser(PPConfig.XorgUser, _SetRightRotationImpl)
+
+def _SetNormalRotationImpl():
+	Cmds = ('xrandr --output DSI-1 --rotate normal',
+			f'xinput set-prop {FindTSID()} "Coordinate Transformation Matrix" 1 0 0 0 1 0 0 0 1')
+
+	for Cmd in Cmds:
+		os.system(Cmd)
+
+
+def SetNormalRotation():
+	return RunAsXorgUser(PPConfig.XorgUser, _SetNormalRotationImpl)