1 /* 2 * Copyright (C) 2017 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 #define LOG_TAG "android.hardware.vibrator (at) 1.1-service.wahoo" 17 18 #include <android/hardware/vibrator/1.1/IVibrator.h> 19 #include <hidl/HidlSupport.h> 20 #include <hidl/HidlTransportSupport.h> 21 #include <utils/Errors.h> 22 #include <utils/StrongPointer.h> 23 24 #include "Vibrator.h" 25 26 using android::hardware::configureRpcThreadpool; 27 using android::hardware::joinRpcThreadpool; 28 using android::hardware::vibrator::V1_1::IVibrator; 29 using android::hardware::vibrator::V1_1::implementation::Vibrator; 30 using namespace android; 31 32 // Refer to Documentation/ABI/testing/sysfs-class-led-driver-drv2624 33 // kernel documentation on the detail usages for ABIs below 34 static constexpr char ACTIVATE_PATH[] = "/sys/class/leds/vibrator/activate"; 35 static constexpr char DURATION_PATH[] = "/sys/class/leds/vibrator/duration"; 36 static constexpr char STATE_PATH[] = "/sys/class/leds/vibrator/state"; 37 static constexpr char RTP_INPUT_PATH[] = "/sys/class/leds/vibrator/device/rtp_input"; 38 static constexpr char MODE_PATH[] = "/sys/class/leds/vibrator/device/mode"; 39 static constexpr char SEQUENCER_PATH[] = "/sys/class/leds/vibrator/device/set_sequencer"; 40 static constexpr char SCALE_PATH[] = "/sys/class/leds/vibrator/device/scale"; 41 static constexpr char CTRL_LOOP_PATH[] = "/sys/class/leds/vibrator/device/ctrl_loop"; 42 static constexpr char LP_TRIGGER_PATH[] = "/sys/class/leds/vibrator/device/lp_trigger_effect"; 43 44 // File path to the calibration file 45 static constexpr char CALIBRATION_FILEPATH[] = "/persist/haptics/drv2624.cal"; 46 47 // Kernel ABIs for updating the calibration data 48 static constexpr char AUTOCAL_CONFIG[] = "autocal"; 49 static constexpr char LRA_PERIOD_CONFIG[] = "lra_period"; 50 static constexpr char AUTOCAL_FILEPATH[] = "/sys/class/leds/vibrator/device/autocal"; 51 static constexpr char OL_LRA_PERIOD_FILEPATH[] = "/sys/class/leds/vibrator/device/ol_lra_period"; 52 53 static std::string trim(const std::string& str, 54 const std::string& whitespace = " \t") { 55 const auto str_begin = str.find_first_not_of(whitespace); 56 if (str_begin == std::string::npos) { 57 return ""; 58 } 59 60 const auto str_end = str.find_last_not_of(whitespace); 61 const auto str_range = str_end - str_begin + 1; 62 63 return str.substr(str_begin, str_range); 64 } 65 66 static bool loadCalibrationData() { 67 std::map<std::string, std::string> config_data; 68 69 std::ofstream autocal{AUTOCAL_FILEPATH}; 70 if (!autocal) { 71 int error = errno; 72 ALOGE("Failed to open %s (%d): %s", AUTOCAL_FILEPATH, error, 73 strerror(error)); 74 return false; 75 } 76 77 std::ofstream ol_lra_period{OL_LRA_PERIOD_FILEPATH}; 78 if (!ol_lra_period) { 79 int error = errno; 80 ALOGE("Failed to open %s (%d): %s", OL_LRA_PERIOD_FILEPATH, error, 81 strerror(error)); 82 return false; 83 } 84 85 std::ifstream cal_data{CALIBRATION_FILEPATH}; 86 if (!cal_data) { 87 int error = errno; 88 ALOGE("Failed to open %s (%d): %s", CALIBRATION_FILEPATH, error, 89 strerror(error)); 90 return false; 91 } 92 93 std::string line; 94 95 while (std::getline(cal_data, line)) { 96 if (line.empty() || line[0] == '#') { 97 continue; 98 } 99 std::istringstream is_line(line); 100 std::string key; 101 if (std::getline(is_line, key, ':')) { 102 std::string value; 103 104 if (std::getline(is_line, value)) { 105 config_data[trim(key)] = trim(value); 106 } 107 } 108 } 109 110 if(config_data.find(AUTOCAL_CONFIG) != config_data.end()) { 111 autocal << config_data[AUTOCAL_CONFIG] << std::endl; 112 } 113 114 if(config_data.find(LRA_PERIOD_CONFIG) != config_data.end()) { 115 ol_lra_period << config_data[LRA_PERIOD_CONFIG] << std::endl; 116 } 117 118 return true; 119 } 120 121 status_t registerVibratorService() { 122 // ostreams below are required 123 std::ofstream activate{ACTIVATE_PATH}; 124 if (!activate) { 125 int error = errno; 126 ALOGE("Failed to open %s (%d): %s", ACTIVATE_PATH, error, strerror(error)); 127 return -error; 128 } 129 130 std::ofstream duration{DURATION_PATH}; 131 if (!duration) { 132 int error = errno; 133 ALOGE("Failed to open %s (%d): %s", DURATION_PATH, error, strerror(error)); 134 return -error; 135 } 136 137 std::ofstream state{STATE_PATH}; 138 if (!state) { 139 int error = errno; 140 ALOGE("Failed to open %s (%d): %s", STATE_PATH, error, strerror(error)); 141 return -error; 142 } 143 144 state << 1 << std::endl; 145 if (!state) { 146 int error = errno; 147 ALOGE("Failed to set state (%d): %s", errno, strerror(errno)); 148 return -error; 149 } 150 151 // ostreams below are optional 152 std::ofstream rtpinput{RTP_INPUT_PATH}; 153 if (!rtpinput) { 154 int error = errno; 155 ALOGW("Failed to open %s (%d): %s", RTP_INPUT_PATH, error, strerror(error)); 156 } 157 158 std::ofstream mode{MODE_PATH}; 159 if (!mode) { 160 int error = errno; 161 ALOGW("Failed to open %s (%d): %s", MODE_PATH, error, strerror(error)); 162 } 163 164 std::ofstream sequencer{SEQUENCER_PATH}; 165 if (!sequencer) { 166 int error = errno; 167 ALOGW("Failed to open %s (%d): %s", SEQUENCER_PATH, error, strerror(error)); 168 } 169 170 std::ofstream scale{SCALE_PATH}; 171 if (!scale) { 172 int error = errno; 173 ALOGW("Failed to open %s (%d): %s", SCALE_PATH, error, strerror(error)); 174 } 175 176 std::ofstream ctrlloop{CTRL_LOOP_PATH}; 177 if (!ctrlloop) { 178 int error = errno; 179 ALOGW("Failed to open %s (%d): %s", CTRL_LOOP_PATH, error, strerror(error)); 180 } 181 182 std::ofstream lptrigger{LP_TRIGGER_PATH}; 183 if (!lptrigger) { 184 int error = errno; 185 ALOGW("Failed to open %s (%d): %s", LP_TRIGGER_PATH, error, strerror(error)); 186 } 187 188 if (!loadCalibrationData()) { 189 ALOGW("Failed load calibration data"); 190 } 191 192 sp<IVibrator> vibrator = new Vibrator(std::move(activate), std::move(duration), 193 std::move(state), std::move(rtpinput), std::move(mode), 194 std::move(sequencer), std::move(scale), std::move(ctrlloop), std::move(lptrigger)); 195 196 vibrator->registerAsService(); 197 198 return OK; 199 } 200 201 int main() { 202 configureRpcThreadpool(1, true); 203 status_t status = registerVibratorService(); 204 205 if (status != OK) { 206 return status; 207 } 208 209 joinRpcThreadpool(); 210 } 211
