1 /*
2 * Copyright (C) 2008 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
17 #define LOG_TAG "lights"
18
19 #include <cutils/log.h>
20
21 #include <dirent.h>
22 #include <stdint.h>
23 #include <string.h>
24 #include <unistd.h>
25 #include <errno.h>
26 #include <fcntl.h>
27 #include <pthread.h>
28
29 #include <linux/input.h>
30
31 #include <sys/ioctl.h>
32 #include <sys/poll.h>
33 #include <sys/types.h>
34
35 #include <hardware/lights.h>
36
37 #define LIGHT_ATTENTION 1
38 #define LIGHT_NOTIFY 2
39
40 /******************************************************************************/
41
42
43 static struct light_state_t *g_notify;
44 static struct light_state_t *g_attention;
45 static pthread_once_t g_init = PTHREAD_ONCE_INIT;
46 static pthread_mutex_t g_lock = PTHREAD_MUTEX_INITIALIZER;
47
48 /**
49 * device methods
50 */
51
write_int(char const * path,int value)52 static int write_int(char const *path, int value)
53 {
54 int fd;
55 static int already_warned = -1;
56 fd = open(path, O_RDWR);
57 if (fd >= 0) {
58 char buffer[20];
59 int bytes = sprintf(buffer, "%d\n", value);
60 int amt = write(fd, buffer, bytes);
61 close(fd);
62 return amt == -1 ? -errno : 0;
63 } else {
64 if (already_warned == -1) {
65 ALOGE("write_int failed to open %s\n", path);
66 already_warned = 1;
67 }
68 return -errno;
69 }
70 }
71
write_string(char const * path,char const * value)72 static int write_string(char const *path, char const *value)
73 {
74 int fd;
75 static int already_warned = -1;
76 fd = open(path, O_RDWR);
77 if (fd >= 0) {
78 char buffer[20];
79 int bytes = sprintf(buffer, "%s\n", value);
80 int amt = write(fd, buffer, bytes);
81 close(fd);
82 return amt == -1 ? -errno : 0;
83 } else {
84 if (already_warned == -1) {
85 ALOGE("write_int failed to open %s\n", path);
86 already_warned = 1;
87 }
88 return -errno;
89 }
90 }
91
init_globals(void)92 void init_globals(void)
93 {
94 pthread_mutex_init(&g_lock, NULL);
95
96 g_attention = malloc(sizeof(struct light_state_t));
97 memset(g_attention, 0, sizeof(*g_attention));
98 g_notify = malloc(sizeof(struct light_state_t));
99 memset(g_notify, 0, sizeof(*g_notify));
100 }
101
rgb_to_brightness(struct light_state_t const * state)102 static int rgb_to_brightness(struct light_state_t const *state)
103 {
104 /* use max of the RGB components for brightness */
105 int color = state->color & 0x00ffffff;
106 int red = (color >> 16) & 0x000000ff;
107 int green = (color >> 8) & 0x000000ff;
108 int blue = color & 0x000000ff;
109
110 int brightness = red;
111 if (green > brightness)
112 brightness = green;
113 if (blue > brightness)
114 brightness = blue;
115
116 return brightness;
117 }
118
119 static int
set_light_backlight(struct light_device_t * dev,struct light_state_t const * state)120 set_light_backlight(struct light_device_t *dev,
121 struct light_state_t const *state)
122 {
123 int err = 0;
124 int brightness = rgb_to_brightness(state);
125
126 pthread_mutex_lock(&g_lock);
127 err = write_int("/sys/class/leds/lcd-backlight/brightness", brightness);
128 pthread_mutex_unlock(&g_lock);
129
130 return err;
131 }
132
133 static int
set_notification_light(struct light_state_t const * state)134 set_notification_light(struct light_state_t const* state)
135 {
136 unsigned int brightness = rgb_to_brightness(state);
137 int blink = state->flashOnMS;
138
139 ALOGD("set_notification_light colorRGB=%08X, onMS=%d, offMS=%d\n",
140 state->color, state->flashOnMS, state->flashOffMS);
141
142 write_int("/sys/class/leds/notification-led/brightness", brightness);
143 write_int("/sys/class/leds/notification-led/blink", blink);
144
145 return 0;
146 }
147
148 static void
handle_notification_light_locked(int type)149 handle_notification_light_locked(int type)
150 {
151 struct light_state_t *new_state = 0;
152 int attn_mode = 0;
153
154 if (g_attention->flashMode == LIGHT_FLASH_HARDWARE)
155 attn_mode = g_attention->flashOnMS;
156
157 switch (type) {
158 case LIGHT_ATTENTION: {
159 if (attn_mode == 0) {
160 /* go back to notify state */
161 new_state = g_notify;
162 } else {
163 new_state = g_attention;
164 }
165 break;
166 }
167 case LIGHT_NOTIFY: {
168 if (attn_mode != 0) {
169 /* attention takes priority over notify state */
170 new_state = g_attention;
171 } else {
172 new_state = g_notify;
173 }
174 break;
175 }
176 }
177 if (new_state == 0) {
178 ALOGE("%s: unknown type (%d)\n", __func__, type);
179 return;
180 }
181
182 set_notification_light(new_state);
183 }
184
185 static int
set_light_notifications(struct light_device_t * dev,struct light_state_t const * state)186 set_light_notifications(struct light_device_t* dev,
187 struct light_state_t const* state)
188 {
189 pthread_mutex_lock(&g_lock);
190
191 g_notify->color = state->color;
192 if (state->flashMode != LIGHT_FLASH_NONE) {
193 g_notify->flashMode = LIGHT_FLASH_HARDWARE;
194 g_notify->flashOnMS = state->flashOnMS;
195 g_notify->flashOffMS = state->flashOffMS;
196 } else {
197 g_notify->flashOnMS = 0;
198 g_notify->flashOffMS = 0;
199 }
200 handle_notification_light_locked(LIGHT_NOTIFY);
201
202 pthread_mutex_unlock(&g_lock);
203 return 0;
204 }
205
206 static int
set_light_attention(struct light_device_t * dev,struct light_state_t const * state)207 set_light_attention(struct light_device_t* dev,
208 struct light_state_t const* state)
209 {
210 pthread_mutex_lock(&g_lock);
211
212 g_attention->flashMode = state->flashMode;
213 g_attention->flashOnMS = state->flashOnMS;
214 g_attention->color = state->color;
215 g_attention->flashOffMS = 0;
216 handle_notification_light_locked(LIGHT_ATTENTION);
217
218 pthread_mutex_unlock(&g_lock);
219 return 0;
220 }
221
222 /** Close the lights device */
close_lights(struct light_device_t * dev)223 static int close_lights(struct light_device_t *dev)
224 {
225 if (dev)
226 free(dev);
227 return 0;
228 }
229
230 /******************************************************************************/
231
232 /**
233 * module methods
234 */
235
236 /** Open a new instance of a lights device using name */
open_lights(const struct hw_module_t * module,char const * name,struct hw_device_t ** device)237 static int open_lights(const struct hw_module_t *module, char const *name,
238 struct hw_device_t **device)
239 {
240 pthread_t lighting_poll_thread;
241
242 int (*set_light) (struct light_device_t *dev,
243 struct light_state_t const *state);
244
245 if (0 == strcmp(LIGHT_ID_BACKLIGHT, name))
246 set_light = set_light_backlight;
247 else if (0 == strcmp(LIGHT_ID_NOTIFICATIONS, name))
248 set_light = set_light_notifications;
249 else if (0 == strcmp(LIGHT_ID_ATTENTION, name))
250 set_light = set_light_attention;
251 else
252 return -EINVAL;
253
254 pthread_once(&g_init, init_globals);
255
256 struct light_device_t *dev = malloc(sizeof(struct light_device_t));
257 memset(dev, 0, sizeof(*dev));
258
259 dev->common.tag = HARDWARE_DEVICE_TAG;
260 dev->common.version = 0;
261 dev->common.module = (struct hw_module_t *)module;
262 dev->common.close = (int (*)(struct hw_device_t *))close_lights;
263 dev->set_light = set_light;
264
265 *device = (struct hw_device_t *)dev;
266
267 return 0;
268 }
269
270 static struct hw_module_methods_t lights_module_methods = {
271 .open = open_lights,
272 };
273
274 /*
275 * The lights Module
276 */
277 struct hw_module_t HAL_MODULE_INFO_SYM = {
278 .tag = HARDWARE_MODULE_TAG,
279 .version_major = 1,
280 .version_minor = 0,
281 .id = LIGHTS_HARDWARE_MODULE_ID,
282 .name = "Nvidia lights Module",
283 .author = "Motorola, Inc.",
284 .methods = &lights_module_methods,
285 };
286