UdfpsHandler.cpp 7.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243
  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 <linux/xiaomi_touch.h>
  16. #include "UdfpsHandler.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 DISP_FEATURE_PATH "/dev/mi_display/disp_feature"
  28. #define TOUCH_DEV_PATH "/dev/xiaomi-touch"
  29. #define FOD_PRESS_STATUS_PATH "/sys/class/touch/touch_dev/fod_press_status"
  30. namespace {
  31. static bool readBool(int fd) {
  32. char c;
  33. int rc;
  34. rc = lseek(fd, 0, SEEK_SET);
  35. if (rc) {
  36. LOG(ERROR) << "failed to seek fd, err: " << rc;
  37. return false;
  38. }
  39. rc = read(fd, &c, sizeof(char));
  40. if (rc != 1) {
  41. LOG(ERROR) << "failed to read bool from fd, err: " << rc;
  42. return false;
  43. }
  44. return c != '0';
  45. }
  46. static disp_event_resp* parseDispEvent(int fd) {
  47. disp_event header;
  48. ssize_t headerSize = read(fd, &header, sizeof(header));
  49. if (headerSize < sizeof(header)) {
  50. LOG(ERROR) << "unexpected display event header size: " << headerSize;
  51. return nullptr;
  52. }
  53. struct disp_event_resp* response =
  54. reinterpret_cast<struct disp_event_resp*>(malloc(header.length));
  55. response->base = header;
  56. int dataLength = response->base.length - sizeof(response->base);
  57. if (dataLength < 0) {
  58. LOG(ERROR) << "invalid data length: " << response->base.length;
  59. return nullptr;
  60. }
  61. ssize_t dataSize = read(fd, &response->data, dataLength);
  62. if (dataSize < dataLength) {
  63. LOG(ERROR) << "unexpected display event data size: " << dataSize;
  64. return nullptr;
  65. }
  66. return response;
  67. }
  68. } // anonymous namespace
  69. class XiaomiSm8450UdfpsHander : public UdfpsHandler {
  70. public:
  71. void init(fingerprint_device_t* device) {
  72. mDevice = device;
  73. touch_fd_ = android::base::unique_fd(open(TOUCH_DEV_PATH, O_RDWR));
  74. disp_fd_ = android::base::unique_fd(open(DISP_FEATURE_PATH, O_RDWR));
  75. std::string fpVendor = android::base::GetProperty("persist.vendor.sys.fp.vendor", "none");
  76. LOG(DEBUG) << __func__ << "fingerprint vendor is: " << fpVendor;
  77. isFpcFod = fpVendor == "fpc_fod";
  78. // Thread to notify fingeprint hwmodule about fod presses
  79. std::thread([this]() {
  80. int fd = open(FOD_PRESS_STATUS_PATH, O_RDONLY);
  81. if (fd < 0) {
  82. LOG(ERROR) << "failed to open " << FOD_PRESS_STATUS_PATH << " , err: " << fd;
  83. return;
  84. }
  85. struct pollfd fodPressStatusPoll = {
  86. .fd = fd,
  87. .events = POLLERR | POLLPRI,
  88. .revents = 0,
  89. };
  90. while (true) {
  91. int rc = poll(&fodPressStatusPoll, 1, -1);
  92. if (rc < 0) {
  93. LOG(ERROR) << "failed to poll " << FOD_PRESS_STATUS_PATH << ", err: " << rc;
  94. continue;
  95. }
  96. bool pressed = readBool(fd);
  97. mDevice->extCmd(mDevice, COMMAND_FOD_PRESS_X, pressed ? lastPressX : 0);
  98. mDevice->extCmd(mDevice, COMMAND_FOD_PRESS_Y, pressed ? lastPressY : 0);
  99. mDevice->extCmd(mDevice, COMMAND_FOD_PRESS_STATUS,
  100. pressed ? PARAM_FOD_PRESSED : PARAM_FOD_RELEASED);
  101. // Request HBM
  102. disp_local_hbm_req req;
  103. req.base.flag = 0;
  104. req.base.disp_id = MI_DISP_PRIMARY;
  105. req.local_hbm_value = pressed ? LHBM_TARGET_BRIGHTNESS_WHITE_1000NIT
  106. : LHBM_TARGET_BRIGHTNESS_OFF_FINGER_UP;
  107. ioctl(disp_fd_.get(), MI_DISP_IOCTL_SET_LOCAL_HBM, &req);
  108. }
  109. }).detach();
  110. // Thread to listen for fod ui changes
  111. std::thread([this]() {
  112. int fd = open(DISP_FEATURE_PATH, O_RDWR);
  113. if (fd < 0) {
  114. LOG(ERROR) << "failed to open " << DISP_FEATURE_PATH << " , err: " << fd;
  115. return;
  116. }
  117. // Register for FOD events
  118. disp_event_req req;
  119. req.base.flag = 0;
  120. req.base.disp_id = MI_DISP_PRIMARY;
  121. req.type = MI_DISP_EVENT_FOD;
  122. ioctl(fd, MI_DISP_IOCTL_REGISTER_EVENT, &req);
  123. struct pollfd dispEventPoll = {
  124. .fd = fd,
  125. .events = POLLIN,
  126. .revents = 0,
  127. };
  128. while (true) {
  129. int rc = poll(&dispEventPoll, 1, -1);
  130. if (rc < 0) {
  131. LOG(ERROR) << "failed to poll " << DISP_FEATURE_PATH << ", err: " << rc;
  132. continue;
  133. }
  134. struct disp_event_resp* response = parseDispEvent(fd);
  135. if (response == nullptr) {
  136. continue;
  137. }
  138. if (response->base.type != MI_DISP_EVENT_FOD) {
  139. LOG(ERROR) << "unexpected display event: " << response->base.type;
  140. continue;
  141. }
  142. int value = response->data[0];
  143. LOG(DEBUG) << "received data: " << std::bitset<8>(value);
  144. bool localHbmUiReady = value & LOCAL_HBM_UI_READY;
  145. bool requestLowBrightnessCapture = value & FOD_LOW_BRIGHTNESS_CAPTURE;
  146. mDevice->extCmd(mDevice, COMMAND_NIT,
  147. localHbmUiReady
  148. ? (requestLowBrightnessCapture ? TARGET_BRIGHTNESS_110NIT
  149. : TARGET_BRIGHTNESS_1000NIT)
  150. : TARGET_BRIGHTNESS_OFF);
  151. }
  152. }).detach();
  153. }
  154. void onFingerDown(uint32_t x, uint32_t y, float /*minor*/, float /*major*/) {
  155. LOG(DEBUG) << __func__ << "x: " << x << ", y: " << y;
  156. // Track x and y coordinates
  157. lastPressX = x;
  158. lastPressY = y;
  159. // Notify touchscreen about press status
  160. setFingerDown(true);
  161. }
  162. void onFingerUp() {
  163. LOG(DEBUG) << __func__;
  164. // Notify touchscreen about press status
  165. setFingerDown(false);
  166. }
  167. void onAcquired(int32_t result, int32_t vendorCode) {
  168. LOG(DEBUG) << __func__ << " result: " << result << " vendorCode: " << vendorCode;
  169. if (result == FINGERPRINT_ACQUIRED_GOOD) {
  170. setFingerDown(false);
  171. }
  172. }
  173. void cancel() {
  174. LOG(DEBUG) << __func__;
  175. }
  176. private:
  177. fingerprint_device_t* mDevice;
  178. android::base::unique_fd touch_fd_;
  179. android::base::unique_fd disp_fd_;
  180. bool isFpcFod;
  181. uint32_t lastPressX, lastPressY;
  182. void setFingerDown(bool pressed) {
  183. int buf[MAX_BUF_SIZE] = {MI_DISP_PRIMARY, THP_FOD_DOWNUP_CTL, pressed ? 1 : 0};
  184. ioctl(touch_fd_.get(), TOUCH_IOC_SET_CUR_VALUE, &buf);
  185. }
  186. };
  187. static UdfpsHandler* create() {
  188. return new XiaomiSm8450UdfpsHander();
  189. }
  190. static void destroy(UdfpsHandler* handler) {
  191. delete handler;
  192. }
  193. extern "C" UdfpsHandlerFactory UDFPS_HANDLER_FACTORY = {
  194. .create = create,
  195. .destroy = destroy,
  196. };