1 #!/bin/env python3
2 # SPDX-License-Identifier: GPL-2.0
3 # -*- coding: utf-8 -*-
4 #
5 # Copyright (c) 2020 Benjamin Tissoires <benjamin.tissoires@gmail.com>
6 # Copyright (c) 2020 Red Hat, Inc.
7 #
8
9 from .base import application_matches
10 from .test_gamepad import BaseTest
11 from hidtools.device.sony_gamepad import (
12 PS3Controller,
13 PS4ControllerBluetooth,
14 PS4ControllerUSB,
15 PS5ControllerBluetooth,
16 PS5ControllerUSB,
17 PSTouchPoint,
18 )
19 from hidtools.util import BusType
20
21 import libevdev
22 import logging
23 import pytest
24
25 logger = logging.getLogger("hidtools.test.sony")
26
27 PS3_MODULE = ("sony", "hid_sony")
28 PS4_MODULE = ("playstation", "hid_playstation")
29 PS5_MODULE = ("playstation", "hid_playstation")
30
31
32 class SonyBaseTest:
33 class SonyTest(BaseTest.TestGamepad):
34 pass
35
36 class SonyPS4ControllerTest(SonyTest):
37 kernel_modules = [PS4_MODULE]
38
39 def test_accelerometer(self):
40 uhdev = self.uhdev
41 evdev = uhdev.get_evdev("Accelerometer")
42
43 for x in range(-32000, 32000, 4000):
44 r = uhdev.event(accel=(x, None, None))
45 events = uhdev.next_sync_events("Accelerometer")
46 self.debug_reports(r, uhdev, events)
47
48 assert libevdev.InputEvent(libevdev.EV_ABS.ABS_X) in events
49 value = evdev.value[libevdev.EV_ABS.ABS_X]
50 # Check against range due to small loss in precision due
51 # to inverse calibration, followed by calibration by hid-sony.
52 assert x - 1 <= value <= x + 1
53
54 for y in range(-32000, 32000, 4000):
55 r = uhdev.event(accel=(None, y, None))
56 events = uhdev.next_sync_events("Accelerometer")
57 self.debug_reports(r, uhdev, events)
58
59 assert libevdev.InputEvent(libevdev.EV_ABS.ABS_Y) in events
60 value = evdev.value[libevdev.EV_ABS.ABS_Y]
61 assert y - 1 <= value <= y + 1
62
63 for z in range(-32000, 32000, 4000):
64 r = uhdev.event(accel=(None, None, z))
65 events = uhdev.next_sync_events("Accelerometer")
66 self.debug_reports(r, uhdev, events)
67
68 assert libevdev.InputEvent(libevdev.EV_ABS.ABS_Z) in events
69 value = evdev.value[libevdev.EV_ABS.ABS_Z]
70 assert z - 1 <= value <= z + 1
71
72 def test_gyroscope(self):
73 uhdev = self.uhdev
74 evdev = uhdev.get_evdev("Accelerometer")
75
76 for rx in range(-2000000, 2000000, 200000):
77 r = uhdev.event(gyro=(rx, None, None))
78 events = uhdev.next_sync_events("Accelerometer")
79 self.debug_reports(r, uhdev, events)
80
81 assert libevdev.InputEvent(libevdev.EV_ABS.ABS_RX) in events
82 value = evdev.value[libevdev.EV_ABS.ABS_RX]
83 # Sensor internal value is 16-bit, but calibrated is 22-bit, so
84 # 6-bit (64) difference, so allow a range of +/- 64.
85 assert rx - 64 <= value <= rx + 64
86
87 for ry in range(-2000000, 2000000, 200000):
88 r = uhdev.event(gyro=(None, ry, None))
89 events = uhdev.next_sync_events("Accelerometer")
90 self.debug_reports(r, uhdev, events)
91
92 assert libevdev.InputEvent(libevdev.EV_ABS.ABS_RY) in events
93 value = evdev.value[libevdev.EV_ABS.ABS_RY]
94 assert ry - 64 <= value <= ry + 64
95
96 for rz in range(-2000000, 2000000, 200000):
97 r = uhdev.event(gyro=(None, None, rz))
98 events = uhdev.next_sync_events("Accelerometer")
99 self.debug_reports(r, uhdev, events)
100
101 assert libevdev.InputEvent(libevdev.EV_ABS.ABS_RZ) in events
102 value = evdev.value[libevdev.EV_ABS.ABS_RZ]
103 assert rz - 64 <= value <= rz + 64
104
105 def test_battery(self):
106 uhdev = self.uhdev
107
108 assert uhdev.power_supply_class is not None
109
110 # DS4 capacity levels are in increments of 10.
111 # Battery is never below 5%.
112 for i in range(5, 105, 10):
113 uhdev.battery.capacity = i
114 uhdev.event()
115 assert uhdev.power_supply_class.capacity == i
116
117 # Discharging tests only make sense for BlueTooth.
118 if uhdev.bus == BusType.BLUETOOTH:
119 uhdev.battery.cable_connected = False
120 uhdev.battery.capacity = 45
121 uhdev.event()
122 assert uhdev.power_supply_class.status == "Discharging"
123
124 uhdev.battery.cable_connected = True
125 uhdev.battery.capacity = 5
126 uhdev.event()
127 assert uhdev.power_supply_class.status == "Charging"
128
129 uhdev.battery.capacity = 100
130 uhdev.event()
131 assert uhdev.power_supply_class.status == "Charging"
132
133 uhdev.battery.full = True
134 uhdev.event()
135 assert uhdev.power_supply_class.status == "Full"
136
137 def test_mt_single_touch(self):
138 """send a single touch in the first slot of the device,
139 and release it."""
140 uhdev = self.uhdev
141 evdev = uhdev.get_evdev("Touch Pad")
142
143 t0 = PSTouchPoint(1, 50, 100)
144 r = uhdev.event(touch=[t0])
145 events = uhdev.next_sync_events("Touch Pad")
146 self.debug_reports(r, uhdev, events)
147
148 assert libevdev.InputEvent(libevdev.EV_KEY.BTN_TOUCH, 1) in events
149 assert evdev.slots[0][libevdev.EV_ABS.ABS_MT_TRACKING_ID] == 0
150 assert evdev.slots[0][libevdev.EV_ABS.ABS_MT_POSITION_X] == 50
151 assert evdev.slots[0][libevdev.EV_ABS.ABS_MT_POSITION_Y] == 100
152
153 t0.tipswitch = False
154 r = uhdev.event(touch=[t0])
155 events = uhdev.next_sync_events("Touch Pad")
156 self.debug_reports(r, uhdev, events)
157 assert libevdev.InputEvent(libevdev.EV_KEY.BTN_TOUCH, 0) in events
158 assert evdev.slots[0][libevdev.EV_ABS.ABS_MT_TRACKING_ID] == -1
159
160 def test_mt_dual_touch(self):
161 """Send 2 touches in the first 2 slots.
162 Make sure the kernel sees this as a dual touch.
163 Release and check
164
165 Note: PTP will send here BTN_DOUBLETAP emulation"""
166 uhdev = self.uhdev
167 evdev = uhdev.get_evdev("Touch Pad")
168
169 t0 = PSTouchPoint(1, 50, 100)
170 t1 = PSTouchPoint(2, 150, 200)
171
172 r = uhdev.event(touch=[t0])
173 events = uhdev.next_sync_events("Touch Pad")
174 self.debug_reports(r, uhdev, events)
175
176 assert libevdev.InputEvent(libevdev.EV_KEY.BTN_TOUCH, 1) in events
177 assert evdev.value[libevdev.EV_KEY.BTN_TOUCH] == 1
178 assert evdev.slots[0][libevdev.EV_ABS.ABS_MT_TRACKING_ID] == 0
179 assert evdev.slots[0][libevdev.EV_ABS.ABS_MT_POSITION_X] == 50
180 assert evdev.slots[0][libevdev.EV_ABS.ABS_MT_POSITION_Y] == 100
181 assert evdev.slots[1][libevdev.EV_ABS.ABS_MT_TRACKING_ID] == -1
182
183 r = uhdev.event(touch=[t0, t1])
184 events = uhdev.next_sync_events("Touch Pad")
185 self.debug_reports(r, uhdev, events)
186 assert libevdev.InputEvent(libevdev.EV_KEY.BTN_TOUCH) not in events
187 assert evdev.value[libevdev.EV_KEY.BTN_TOUCH] == 1
188 assert (
189 libevdev.InputEvent(libevdev.EV_ABS.ABS_MT_POSITION_X, 5) not in events
190 )
191 assert (
192 libevdev.InputEvent(libevdev.EV_ABS.ABS_MT_POSITION_Y, 10) not in events
193 )
194 assert evdev.slots[0][libevdev.EV_ABS.ABS_MT_TRACKING_ID] == 0
195 assert evdev.slots[0][libevdev.EV_ABS.ABS_MT_POSITION_X] == 50
196 assert evdev.slots[0][libevdev.EV_ABS.ABS_MT_POSITION_Y] == 100
197 assert evdev.slots[1][libevdev.EV_ABS.ABS_MT_TRACKING_ID] == 1
198 assert evdev.slots[1][libevdev.EV_ABS.ABS_MT_POSITION_X] == 150
199 assert evdev.slots[1][libevdev.EV_ABS.ABS_MT_POSITION_Y] == 200
200
201 t0.tipswitch = False
202 r = uhdev.event(touch=[t0, t1])
203 events = uhdev.next_sync_events("Touch Pad")
204 self.debug_reports(r, uhdev, events)
205 assert evdev.slots[0][libevdev.EV_ABS.ABS_MT_TRACKING_ID] == -1
206 assert evdev.slots[1][libevdev.EV_ABS.ABS_MT_TRACKING_ID] == 1
207 assert libevdev.InputEvent(libevdev.EV_ABS.ABS_MT_POSITION_X) not in events
208 assert libevdev.InputEvent(libevdev.EV_ABS.ABS_MT_POSITION_Y) not in events
209
210 t1.tipswitch = False
211 r = uhdev.event(touch=[t1])
212
213 events = uhdev.next_sync_events("Touch Pad")
214 self.debug_reports(r, uhdev, events)
215 assert evdev.slots[0][libevdev.EV_ABS.ABS_MT_TRACKING_ID] == -1
216 assert evdev.slots[1][libevdev.EV_ABS.ABS_MT_TRACKING_ID] == -1
217
218
219 class TestPS3Controller(SonyBaseTest.SonyTest):
220 kernel_modules = [PS3_MODULE]
221
222 def create_device(self):
223 controller = PS3Controller()
224 controller.application_matches = application_matches
225 return controller
226
227 @pytest.fixture(autouse=True)
228 def start_controller(self):
229 # emulate a 'PS' button press to tell the kernel we are ready to accept events
230 self.assert_button(17)
231
232 # drain any remaining udev events
233 while self.uhdev.dispatch(10):
234 pass
235
236 def test_led(self):
237 for k, v in self.uhdev.led_classes.items():
238 # the kernel might have set a LED for us
239 logger.info(f"{k}: {v.brightness}")
240
241 idx = int(k[-1]) - 1
242 assert self.uhdev.hw_leds.get_led(idx)[0] == bool(v.brightness)
243
244 v.brightness = 0
245 self.uhdev.dispatch(10)
246 assert self.uhdev.hw_leds.get_led(idx)[0] is False
247
248 v.brightness = v.max_brightness
249 self.uhdev.dispatch(10)
250 assert self.uhdev.hw_leds.get_led(idx)[0]
251
252
253 class CalibratedPS4Controller(object):
254 # DS4 reports uncalibrated sensor data. Calibration coefficients
255 # can be retrieved using a feature report (0x2 USB / 0x5 BT).
256 # The values below are the processed calibration values for the
257 # DS4s matching the feature reports of PS4ControllerBluetooth/USB
258 # as dumped from hid-sony 'ds4_get_calibration_data'.
259 #
260 # Note we duplicate those values here in case the kernel changes them
261 # so we can have tests passing even if hid-tools doesn't have the
262 # correct values.
263 accelerometer_calibration_data = {
264 "x": {"bias": -73, "numer": 16384, "denom": 16472},
265 "y": {"bias": -352, "numer": 16384, "denom": 16344},
266 "z": {"bias": 81, "numer": 16384, "denom": 16319},
267 }
268 gyroscope_calibration_data = {
269 "x": {"bias": 0, "numer": 1105920, "denom": 17827},
270 "y": {"bias": 0, "numer": 1105920, "denom": 17777},
271 "z": {"bias": 0, "numer": 1105920, "denom": 17748},
272 }
273
274
275 class CalibratedPS4ControllerBluetooth(CalibratedPS4Controller, PS4ControllerBluetooth):
276 pass
277
278
279 class TestPS4ControllerBluetooth(SonyBaseTest.SonyPS4ControllerTest):
280 def create_device(self):
281 controller = CalibratedPS4ControllerBluetooth()
282 controller.application_matches = application_matches
283 return controller
284
285
286 class CalibratedPS4ControllerUSB(CalibratedPS4Controller, PS4ControllerUSB):
287 pass
288
289
290 class TestPS4ControllerUSB(SonyBaseTest.SonyPS4ControllerTest):
291 def create_device(self):
292 controller = CalibratedPS4ControllerUSB()
293 controller.application_matches = application_matches
294 return controller
295
296
297 class CalibratedPS5Controller(object):
298 # DualSense reports uncalibrated sensor data. Calibration coefficients
299 # can be retrieved using feature report 0x09.
300 # The values below are the processed calibration values for the
301 # DualSene matching the feature reports of PS5ControllerBluetooth/USB
302 # as dumped from hid-playstation 'dualsense_get_calibration_data'.
303 #
304 # Note we duplicate those values here in case the kernel changes them
305 # so we can have tests passing even if hid-tools doesn't have the
306 # correct values.
307 accelerometer_calibration_data = {
308 "x": {"bias": 0, "numer": 16384, "denom": 16374},
309 "y": {"bias": -114, "numer": 16384, "denom": 16362},
310 "z": {"bias": 2, "numer": 16384, "denom": 16395},
311 }
312 gyroscope_calibration_data = {
313 "x": {"bias": 0, "numer": 1105920, "denom": 17727},
314 "y": {"bias": 0, "numer": 1105920, "denom": 17728},
315 "z": {"bias": 0, "numer": 1105920, "denom": 17769},
316 }
317
318
319 class CalibratedPS5ControllerBluetooth(CalibratedPS5Controller, PS5ControllerBluetooth):
320 pass
321
322
323 class TestPS5ControllerBluetooth(SonyBaseTest.SonyPS4ControllerTest):
324 kernel_modules = [PS5_MODULE]
325
326 def create_device(self):
327 controller = CalibratedPS5ControllerBluetooth()
328 controller.application_matches = application_matches
329 return controller
330
331
332 class CalibratedPS5ControllerUSB(CalibratedPS5Controller, PS5ControllerUSB):
333 pass
334
335
336 class TestPS5ControllerUSB(SonyBaseTest.SonyPS4ControllerTest):
337 kernel_modules = [PS5_MODULE]
338
339 def create_device(self):
340 controller = CalibratedPS5ControllerUSB()
341 controller.application_matches = application_matches
342 return controller
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.