UdfpsHandler.cpp 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325
  1. /*
  2. * Copyright (C) 2022 The LineageOS Project
  3. *
  4. * SPDX-License-Identifier: Apache-2.0
  5. */
  6. #define LOG_TAG "UdfpsHandler.xiaomi_sm8450"
  7. #include <android-base/logging.h>
  8. #include <android-base/properties.h>
  9. #include <android-base/unique_fd.h>
  10. #include <poll.h>
  11. #include <sys/ioctl.h>
  12. #include <fstream>
  13. #include <thread>
  14. #include <display/drm/mi_disp.h>
  15. #include "UdfpsHandler.h"
  16. #include "xiaomi_touch.h"
  17. #define COMMAND_NIT 10
  18. #define TARGET_BRIGHTNESS_OFF 0
  19. #define TARGET_BRIGHTNESS_1000NIT 1
  20. #define TARGET_BRIGHTNESS_110NIT 6
  21. #define LOW_BRIGHTNESS_THRESHHOLD 100
  22. #define COMMAND_FOD_PRESS_STATUS 1
  23. #define COMMAND_FOD_PRESS_X 2
  24. #define COMMAND_FOD_PRESS_Y 3
  25. #define PARAM_FOD_PRESSED 1
  26. #define PARAM_FOD_RELEASED 0
  27. #define FOD_STATUS_OFF 0
  28. #define FOD_STATUS_ON 1
  29. #define FOD_STATUS_OFF_UNTIL_SUSPEND 3
  30. #define TOUCH_DEV_PATH "/dev/xiaomi-touch"
  31. #define TOUCH_MAGIC 'T'
  32. #define TOUCH_IOC_SET_CUR_VALUE _IO(TOUCH_MAGIC, SET_CUR_VALUE)
  33. #define TOUCH_IOC_GET_CUR_VALUE _IO(TOUCH_MAGIC, GET_CUR_VALUE)
  34. #define DISP_FEATURE_PATH "/dev/mi_display/disp_feature"
  35. #define FOD_PRESS_STATUS_PATH "/sys/class/touch/touch_dev/fod_press_status"
  36. namespace {
  37. static bool readBool(int fd) {
  38. char c;
  39. int rc;
  40. rc = lseek(fd, 0, SEEK_SET);
  41. if (rc) {
  42. LOG(ERROR) << "failed to seek fd, err: " << rc;
  43. return false;
  44. }
  45. rc = read(fd, &c, sizeof(char));
  46. if (rc != 1) {
  47. LOG(ERROR) << "failed to read bool from fd, err: " << rc;
  48. return false;
  49. }
  50. return c != '0';
  51. }
  52. static disp_event_resp* parseDispEvent(int fd) {
  53. disp_event header;
  54. ssize_t headerSize = read(fd, &header, sizeof(header));
  55. if (headerSize < sizeof(header)) {
  56. LOG(ERROR) << "unexpected display event header size: " << headerSize;
  57. return nullptr;
  58. }
  59. struct disp_event_resp* response =
  60. reinterpret_cast<struct disp_event_resp*>(malloc(header.length));
  61. response->base = header;
  62. int dataLength = response->base.length - sizeof(response->base);
  63. if (dataLength < 0) {
  64. LOG(ERROR) << "invalid data length: " << response->base.length;
  65. return nullptr;
  66. }
  67. ssize_t dataSize = read(fd, &response->data, dataLength);
  68. if (dataSize < dataLength) {
  69. LOG(ERROR) << "unexpected display event data size: " << dataSize;
  70. return nullptr;
  71. }
  72. return response;
  73. }
  74. } // anonymous namespace
  75. class XiaomiSm8450UdfpsHander : public UdfpsHandler {
  76. public:
  77. void init(fingerprint_device_t* device) {
  78. mDevice = device;
  79. touch_fd_ = android::base::unique_fd(open(TOUCH_DEV_PATH, O_RDWR));
  80. disp_fd_ = android::base::unique_fd(open(DISP_FEATURE_PATH, O_RDWR));
  81. std::string fpVendor = android::base::GetProperty("persist.vendor.sys.fp.vendor", "none");
  82. LOG(DEBUG) << __func__ << "fingerprint vendor is: " << fpVendor;
  83. isFpcFod = fpVendor == "fpc_fod";
  84. // Thread to notify fingeprint hwmodule about fod presses
  85. std::thread([this]() {
  86. int fd = open(FOD_PRESS_STATUS_PATH, O_RDONLY);
  87. if (fd < 0) {
  88. LOG(ERROR) << "failed to open " << FOD_PRESS_STATUS_PATH << " , err: " << fd;
  89. return;
  90. }
  91. struct pollfd fodPressStatusPoll = {
  92. .fd = fd,
  93. .events = POLLERR | POLLPRI,
  94. .revents = 0,
  95. };
  96. while (true) {
  97. int rc = poll(&fodPressStatusPoll, 1, -1);
  98. if (rc < 0) {
  99. LOG(ERROR) << "failed to poll " << FOD_PRESS_STATUS_PATH << ", err: " << rc;
  100. continue;
  101. }
  102. bool pressed = readBool(fd);
  103. mDevice->extCmd(mDevice, COMMAND_FOD_PRESS_X, pressed ? lastPressX : 0);
  104. mDevice->extCmd(mDevice, COMMAND_FOD_PRESS_Y, pressed ? lastPressY : 0);
  105. mDevice->extCmd(mDevice, COMMAND_FOD_PRESS_STATUS,
  106. pressed ? PARAM_FOD_PRESSED : PARAM_FOD_RELEASED);
  107. // Get brightness
  108. struct disp_brightness_req brightness_req;
  109. int brightness = LOW_BRIGHTNESS_THRESHHOLD;
  110. brightness_req.base.flag = 0;
  111. brightness_req.base.disp_id = MI_DISP_PRIMARY;
  112. rc = ioctl(disp_fd_.get(), MI_DISP_IOCTL_GET_BRIGHTNESS, &brightness_req);
  113. if (rc) {
  114. LOG(ERROR) << "failed to get brightness, err: " << rc;
  115. } else if (brightness_req.brightness > 0) {
  116. brightness = brightness_req.brightness;
  117. }
  118. LOG(DEBUG) << "brightness is: " << (int)brightness_req.brightness;
  119. bool requestLowBrightness = !enrolling && brightness < LOW_BRIGHTNESS_THRESHHOLD;
  120. // Request HBM
  121. disp_local_hbm_req req;
  122. req.base.flag = 0;
  123. req.base.disp_id = MI_DISP_PRIMARY;
  124. req.local_hbm_value =
  125. pressed ? (requestLowBrightness ? LHBM_TARGET_BRIGHTNESS_WHITE_110NIT
  126. : LHBM_TARGET_BRIGHTNESS_WHITE_1000NIT)
  127. : LHBM_TARGET_BRIGHTNESS_OFF_FINGER_UP;
  128. ioctl(disp_fd_.get(), MI_DISP_IOCTL_SET_LOCAL_HBM, &req);
  129. }
  130. }).detach();
  131. // Thread to listen for fod ui changes
  132. std::thread([this]() {
  133. int fd = open(DISP_FEATURE_PATH, O_RDWR);
  134. if (fd < 0) {
  135. LOG(ERROR) << "failed to open " << DISP_FEATURE_PATH << " , err: " << fd;
  136. return;
  137. }
  138. // Register for FOD events
  139. disp_event_req req;
  140. req.base.flag = 0;
  141. req.base.disp_id = MI_DISP_PRIMARY;
  142. req.type = MI_DISP_EVENT_FOD;
  143. ioctl(fd, MI_DISP_IOCTL_REGISTER_EVENT, &req);
  144. struct pollfd dispEventPoll = {
  145. .fd = fd,
  146. .events = POLLIN,
  147. .revents = 0,
  148. };
  149. while (true) {
  150. int rc = poll(&dispEventPoll, 1, -1);
  151. if (rc < 0) {
  152. LOG(ERROR) << "failed to poll " << DISP_FEATURE_PATH << ", err: " << rc;
  153. continue;
  154. }
  155. struct disp_event_resp* response = parseDispEvent(fd);
  156. if (response == nullptr) {
  157. continue;
  158. }
  159. if (response->base.type != MI_DISP_EVENT_FOD) {
  160. LOG(ERROR) << "unexpected display event: " << response->base.type;
  161. continue;
  162. }
  163. int value = response->data[0];
  164. LOG(DEBUG) << "received data: " << std::bitset<8>(value);
  165. bool localHbmUiReady = value & LOCAL_HBM_UI_READY;
  166. bool requestLowBrightnessCapture = value & FOD_LOW_BRIGHTNESS_CAPTURE;
  167. mDevice->extCmd(mDevice, COMMAND_NIT,
  168. localHbmUiReady
  169. ? (requestLowBrightnessCapture ? TARGET_BRIGHTNESS_110NIT
  170. : TARGET_BRIGHTNESS_1000NIT)
  171. : TARGET_BRIGHTNESS_OFF);
  172. }
  173. }).detach();
  174. }
  175. void onFingerDown(uint32_t x, uint32_t y, float /*minor*/, float /*major*/) {
  176. LOG(DEBUG) << __func__ << "x: " << x << ", y: " << y;
  177. // Track x and y coordinates
  178. lastPressX = x;
  179. lastPressY = y;
  180. /*
  181. * On fpc_fod devices, the waiting for finger message is not reliably sent...
  182. * The finger down message is only reliably sent when the screen is turned off, so enable
  183. * fod_status better late than never.
  184. */
  185. if (isFpcFod) {
  186. setFodStatus(FOD_STATUS_ON);
  187. }
  188. // Ensure touchscreen is aware of the press state, ideally this is not needed
  189. setFingerDown(true);
  190. }
  191. void onFingerUp() {
  192. LOG(DEBUG) << __func__;
  193. // Ensure touchscreen is aware of the press state, ideally this is not needed
  194. setFingerDown(false);
  195. }
  196. void onAcquired(int32_t result, int32_t vendorCode) {
  197. LOG(DEBUG) << __func__ << " result: " << result << " vendorCode: " << vendorCode;
  198. if (result == FINGERPRINT_ACQUIRED_GOOD) {
  199. // Request to disable HBM already, even if the finger is still pressed
  200. disp_local_hbm_req req;
  201. req.base.flag = 0;
  202. req.base.disp_id = MI_DISP_PRIMARY;
  203. req.local_hbm_value = LHBM_TARGET_BRIGHTNESS_OFF_FINGER_UP;
  204. ioctl(disp_fd_.get(), MI_DISP_IOCTL_SET_LOCAL_HBM, &req);
  205. if (!enrolling) {
  206. setFodStatus(FOD_STATUS_OFF_UNTIL_SUSPEND);
  207. }
  208. }
  209. /* vendorCode for goodix_fod devices:
  210. * 21: waiting for finger
  211. * 22: finger down
  212. * 23: finger up
  213. * On fpc_fod devices, the waiting for finger message is not reliably sent...
  214. * The finger down message is only reliably sent when the screen is turned off, so enable
  215. * fod_status better late than never.
  216. */
  217. if (!isFpcFod && vendorCode == 21) {
  218. setFodStatus(FOD_STATUS_ON);
  219. } else if (isFpcFod && vendorCode == 22) {
  220. setFodStatus(FOD_STATUS_ON);
  221. }
  222. }
  223. void cancel() {
  224. LOG(DEBUG) << __func__;
  225. enrolling = false;
  226. setFodStatus(FOD_STATUS_OFF_UNTIL_SUSPEND);
  227. }
  228. void preEnroll() {
  229. LOG(DEBUG) << __func__;
  230. enrolling = true;
  231. }
  232. void enroll() {
  233. LOG(DEBUG) << __func__;
  234. enrolling = true;
  235. }
  236. void postEnroll() {
  237. LOG(DEBUG) << __func__;
  238. enrolling = false;
  239. setFodStatus(FOD_STATUS_OFF_UNTIL_SUSPEND);
  240. }
  241. private:
  242. fingerprint_device_t* mDevice;
  243. android::base::unique_fd touch_fd_;
  244. android::base::unique_fd disp_fd_;
  245. bool isFpcFod;
  246. bool enrolling = false;
  247. uint32_t lastPressX, lastPressY;
  248. void setFodStatus(int value) {
  249. int buf[MAX_BUF_SIZE] = {MI_DISP_PRIMARY, Touch_Fod_Enable, value};
  250. ioctl(touch_fd_.get(), TOUCH_IOC_SET_CUR_VALUE, &buf);
  251. }
  252. void setFingerDown(bool pressed) {
  253. int buf[MAX_BUF_SIZE] = {MI_DISP_PRIMARY, THP_FOD_DOWNUP_CTL, pressed ? 1 : 0};
  254. ioctl(touch_fd_.get(), TOUCH_IOC_SET_CUR_VALUE, &buf);
  255. }
  256. };
  257. static UdfpsHandler* create() {
  258. return new XiaomiSm8450UdfpsHander();
  259. }
  260. static void destroy(UdfpsHandler* handler) {
  261. delete handler;
  262. }
  263. extern "C" UdfpsHandlerFactory UDFPS_HANDLER_FACTORY = {
  264. .create = create,
  265. .destroy = destroy,
  266. };