• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1  /*
2   * Copyright (C) 2019 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  #pragma once
17  
18  #include "HardwareBase.h"
19  #include "Vibrator.h"
20  
21  namespace aidl {
22  namespace android {
23  namespace hardware {
24  namespace vibrator {
25  
26  class HwApi : public Vibrator::HwApi, private HwApiBase {
27    public:
HwApi()28      HwApi() {
29          open("device/f0_stored", &mF0);
30          open("device/f0_offset", &mF0Offset);
31          open("device/redc_stored", &mRedc);
32          open("device/q_stored", &mQ);
33          open("activate", &mActivate);
34          open("duration", &mDuration);
35          open("state", &mState);
36          open("device/cp_trigger_duration", &mEffectDuration);
37          open("device/cp_trigger_index", &mEffectIndex);
38          open("device/cp_trigger_queue", &mEffectQueue);
39          open("device/cp_dig_scale", &mEffectScale);
40          open("device/dig_scale", &mGlobalScale);
41          open("device/asp_enable", &mAspEnable);
42          open("device/gpio1_fall_index", &mGpioFallIndex);
43          open("device/gpio1_fall_dig_scale", &mGpioFallScale);
44          open("device/gpio1_rise_index", &mGpioRiseIndex);
45          open("device/gpio1_rise_dig_scale", &mGpioRiseScale);
46          open("device/vibe_state", &mVibeState);
47          open("device/num_waves", &mEffectCount);
48          open("device/clab_enable", &mClabEnable);
49          open("device/available_pwle_segments", &mAvailablePwleSegments);
50          open("device/pwle", &mPwle);
51          open("device/pwle_ramp_down", &mPwleRampDown);
52      }
53  
setF0(uint32_t value)54      bool setF0(uint32_t value) override { return set(value, &mF0); }
setF0Offset(uint32_t value)55      bool setF0Offset(uint32_t value) override { return set(value, &mF0Offset); }
setRedc(uint32_t value)56      bool setRedc(uint32_t value) override { return set(value, &mRedc); }
setQ(uint32_t value)57      bool setQ(uint32_t value) override { return set(value, &mQ); }
setActivate(bool value)58      bool setActivate(bool value) override { return set(value, &mActivate); }
setDuration(uint32_t value)59      bool setDuration(uint32_t value) override { return set(value, &mDuration); }
getEffectCount(uint32_t * value)60      bool getEffectCount(uint32_t *value) override { return get(value, &mEffectCount); }
getEffectDuration(uint32_t * value)61      bool getEffectDuration(uint32_t *value) override { return get(value, &mEffectDuration); }
setEffectIndex(uint32_t value)62      bool setEffectIndex(uint32_t value) override { return set(value, &mEffectIndex); }
setEffectQueue(std::string value)63      bool setEffectQueue(std::string value) override { return set(value, &mEffectQueue); }
hasEffectScale()64      bool hasEffectScale() override { return has(mEffectScale); }
setEffectScale(uint32_t value)65      bool setEffectScale(uint32_t value) override { return set(value, &mEffectScale); }
setGlobalScale(uint32_t value)66      bool setGlobalScale(uint32_t value) override { return set(value, &mGlobalScale); }
setState(bool value)67      bool setState(bool value) override { return set(value, &mState); }
hasAspEnable()68      bool hasAspEnable() override { return has(mAspEnable); }
getAspEnable(bool * value)69      bool getAspEnable(bool *value) override { return get(value, &mAspEnable); }
setAspEnable(bool value)70      bool setAspEnable(bool value) override { return set(value, &mAspEnable); }
setGpioFallIndex(uint32_t value)71      bool setGpioFallIndex(uint32_t value) override { return set(value, &mGpioFallIndex); }
setGpioFallScale(uint32_t value)72      bool setGpioFallScale(uint32_t value) override { return set(value, &mGpioFallScale); }
setGpioRiseIndex(uint32_t value)73      bool setGpioRiseIndex(uint32_t value) override { return set(value, &mGpioRiseIndex); }
setGpioRiseScale(uint32_t value)74      bool setGpioRiseScale(uint32_t value) override { return set(value, &mGpioRiseScale); }
pollVibeState(uint32_t value,int32_t timeoutMs)75      bool pollVibeState(uint32_t value, int32_t timeoutMs) override {
76          return poll(value, &mVibeState, timeoutMs);
77      }
setClabEnable(bool value)78      bool setClabEnable(bool value) override { return set(value, &mClabEnable); }
getAvailablePwleSegments(uint32_t * value)79      bool getAvailablePwleSegments(uint32_t *value) override {
80          return get(value, &mAvailablePwleSegments);
81      }
hasPwle()82      bool hasPwle() override { return has(mPwle); }
setPwle(std::string value)83      bool setPwle(std::string value) override { return set(value, &mPwle); }
setPwleRampDown(uint32_t value)84      bool setPwleRampDown(uint32_t value) override { return set(value, &mPwleRampDown); }
debug(int fd)85      void debug(int fd) override { HwApiBase::debug(fd); }
86  
87    private:
88      std::ofstream mF0;
89      std::ofstream mF0Offset;
90      std::ofstream mRedc;
91      std::ofstream mQ;
92      std::ofstream mActivate;
93      std::ofstream mDuration;
94      std::ifstream mEffectCount;
95      std::ifstream mEffectDuration;
96      std::ofstream mEffectIndex;
97      std::ofstream mEffectQueue;
98      std::ofstream mEffectScale;
99      std::ofstream mGlobalScale;
100      std::ofstream mState;
101      std::fstream mAspEnable;
102      std::ofstream mGpioFallIndex;
103      std::ofstream mGpioFallScale;
104      std::ofstream mGpioRiseIndex;
105      std::ofstream mGpioRiseScale;
106      std::ifstream mVibeState;
107      std::ofstream mClabEnable;
108      std::ifstream mAvailablePwleSegments;
109      std::ofstream mPwle;
110      std::ofstream mPwleRampDown;
111  };
112  
113  class HwCal : public Vibrator::HwCal, private HwCalBase {
114    private:
115      static constexpr char VERSION[] = "version";
116      static constexpr char F0_CONFIG[] = "f0_measured";
117      static constexpr char REDC_CONFIG[] = "redc_measured";
118      static constexpr char Q_CONFIG[] = "q_measured";
119      static constexpr char Q_INDEX[] = "q_index";
120      static constexpr char VOLTAGES_CONFIG[] = "v_levels";
121      static constexpr char TICK_VOLTAGES_CONFIG[] = "v_tick";
122      static constexpr char CLICK_VOLTAGES_CONFIG[] = "v_click";
123      static constexpr char LONG_VOLTAGES_CONFIG[] = "v_long";
124  
125      static constexpr uint32_t Q_FLOAT_TO_FIXED = 1 << 16;
126      static constexpr float Q_INDEX_TO_FLOAT = 1.5f;
127      static constexpr uint32_t Q_INDEX_TO_FIXED = Q_INDEX_TO_FLOAT * Q_FLOAT_TO_FIXED;
128      static constexpr uint32_t Q_INDEX_OFFSET = 2.0f * Q_FLOAT_TO_FIXED;
129  
130      static constexpr uint32_t VERSION_DEFAULT = 1;
131      static constexpr int32_t DEFAULT_FREQUENCY_SHIFT = 0;
132      static constexpr float DEFAULT_DEVICE_MASS = 0.21;
133      static constexpr float DEFAULT_LOC_COEFF = 0.5;
134      static constexpr uint32_t Q_DEFAULT = 15.5 * Q_FLOAT_TO_FIXED;
135      static constexpr std::array<uint32_t, 6> V_LEVELS_DEFAULT = {60, 70, 80, 90, 100, 76};
136      static constexpr std::array<uint32_t, 2> V_TICK_DEFAULT = {10, 70};
137      static constexpr std::array<uint32_t, 2> V_CTICK_DEFAULT = {10, 70};
138      static constexpr std::array<uint32_t, 2> V_LONG_DEFAULT = {10, 70};
139  
140    public:
HwCal()141      HwCal() {}
142  
getVersion(uint32_t * value)143      bool getVersion(uint32_t *value) override {
144          if (getPersist(VERSION, value)) {
145              return true;
146          }
147          *value = VERSION_DEFAULT;
148          return true;
149      }
getLongFrequencyShift(int32_t * value)150      bool getLongFrequencyShift(int32_t *value) override {
151          return getProperty("long.frequency.shift", value, DEFAULT_FREQUENCY_SHIFT);
152      }
getDeviceMass(float * value)153      bool getDeviceMass(float *value) override {
154          return getProperty("device.mass", value, DEFAULT_DEVICE_MASS);
155      }
getLocCoeff(float * value)156      bool getLocCoeff(float *value) override {
157          return getProperty("loc.coeff", value, DEFAULT_LOC_COEFF);
158      }
getF0(uint32_t * value)159      bool getF0(uint32_t *value) override { return getPersist(F0_CONFIG, value); }
getRedc(uint32_t * value)160      bool getRedc(uint32_t *value) override { return getPersist(REDC_CONFIG, value); }
getQ(uint32_t * value)161      bool getQ(uint32_t *value) override {
162          if (getPersist(Q_CONFIG, value)) {
163              return true;
164          }
165          if (getPersist(Q_INDEX, value)) {
166              *value = *value * Q_INDEX_TO_FIXED + Q_INDEX_OFFSET;
167              return true;
168          }
169          *value = Q_DEFAULT;
170          return true;
171      }
getVolLevels(std::array<uint32_t,6> * value)172      bool getVolLevels(std::array<uint32_t, 6> *value) override {
173          if (getPersist(VOLTAGES_CONFIG, value)) {
174              return true;
175          }
176          *value = V_LEVELS_DEFAULT;
177          return true;
178      }
getTickVolLevels(std::array<uint32_t,2> * value)179      bool getTickVolLevels(std::array<uint32_t, 2> *value) override {
180          if (getPersist(TICK_VOLTAGES_CONFIG, value)) {
181              return true;
182          }
183          *value = V_TICK_DEFAULT;
184          return true;
185      }
getClickVolLevels(std::array<uint32_t,2> * value)186      bool getClickVolLevels(std::array<uint32_t, 2> *value) override {
187          if (getPersist(CLICK_VOLTAGES_CONFIG, value)) {
188              return true;
189          }
190          *value = V_CTICK_DEFAULT;
191          return true;
192      }
getLongVolLevels(std::array<uint32_t,2> * value)193      bool getLongVolLevels(std::array<uint32_t, 2> *value) override {
194          if (getPersist(LONG_VOLTAGES_CONFIG, value)) {
195              return true;
196          }
197          *value = V_LONG_DEFAULT;
198          return true;
199      }
isChirpEnabled()200      bool isChirpEnabled() override {
201          return utils::getProperty("persist.vendor.vibrator.hal.chirp.enabled", false);
202      }
debug(int fd)203      void debug(int fd) override { HwCalBase::debug(fd); }
204  };
205  
206  }  // namespace vibrator
207  }  // namespace hardware
208  }  // namespace android
209  }  // namespace aidl
210