1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
|
/*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "gpio_impl.h"
#include <android-base/unique_fd.h>
#include <binder/Status.h>
#include "peripheralmanager/constants.h"
#include "peripheralmanager/gpio.h"
using android::binder::Status;
using android::os::IPeripheralManagerClient;
using android::GpioActiveType;
using android::GpioDirection;
using android::GpioEdgeType;
bool ActiveTypeFromInt(int type, GpioActiveType* out) {
if (type == ACTIVE_LOW) {
*out = android::kActiveLow;
return true;
} else if (type == ACTIVE_HIGH) {
*out = android::kActiveHigh;
return true;
}
return false;
}
bool DirectionFromInt(int direction, android::GpioDirection* out) {
switch (direction) {
case DIRECTION_IN:
*out = android::kDirectionIn;
return true;
case DIRECTION_OUT_INITIALLY_HIGH:
*out = android::kDirectionOutInitiallyHigh;
return true;
case DIRECTION_OUT_INITIALLY_LOW:
*out = android::kDirectionOutInitiallyLow;
return true;
}
return false;
}
bool EdgeTypeFromInt(int type, android::GpioEdgeType* out) {
switch (type) {
case NONE_EDGE:
*out = android::kEdgeNone;
return true;
case RISING_EDGE:
*out = android::kEdgeRising;
return true;
case FALLING_EDGE:
*out = android::kEdgeFalling;
return true;
case BOTH_EDGE:
*out = android::kEdgeBoth;
return true;
}
return false;
}
GpioImpl::GpioImpl(const std::string name,
android::sp<IPeripheralManagerClient> client)
: name_(name), client_(client) {}
GpioImpl::~GpioImpl() {
client_->ReleaseGpio(name_);
}
int GpioImpl::SetDirection(GpioDirection direction) {
return client_->SetGpioDirection(name_, direction).serviceSpecificErrorCode();
}
int GpioImpl::SetEdgeTriggerType(GpioEdgeType type) {
return client_->SetGpioEdge(name_, type).serviceSpecificErrorCode();
}
int GpioImpl::SetActiveType(GpioActiveType type) {
return client_->SetGpioActiveType(name_, type).serviceSpecificErrorCode();
}
int GpioImpl::SetValue(int value) {
return client_->SetGpioValue(name_, value != 0).serviceSpecificErrorCode();
}
int GpioImpl::GetValue(int* value) {
bool val = true;
Status ret = client_->GetGpioValue(name_, &val);
if (ret.isOk()) {
*value = val ? 1 : 0;
}
return ret.serviceSpecificErrorCode();
}
int GpioImpl::GetPollingFd(int* fd) {
android::base::unique_fd scoped_fd;
Status ret = client_->GetGpioPollingFd(name_, &scoped_fd);
if (ret.isOk()) {
uint8_t buf[2];
read(scoped_fd.get(), buf, 2);
lseek(scoped_fd.get(), 0, SEEK_SET);
*fd = scoped_fd.release();
}
return ret.serviceSpecificErrorCode();
}
|
