Debian Codegraph @

src/sensors/huey/huey-device.c

raw
1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
2 *
3 * Copyright (C) 2013 Richard Hughes <[email protected]>
4 *
5 * Licensed under the GNU General Public License Version 2
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20 */
21
22 #include "config.h"
23
24 #include <glib.h>
25 #include <string.h>
26
27 #include "huey-device.h"
28 #include "huey-enum.h"
29
30 #define HUEY_MAX_READ_RETRIES 5
31 #define HUEY_CONTROL_MESSAGE_TIMEOUT 50000 /* ms */
32
33 /* fudge factor to convert the value of HUEY_CMD_GET_AMBIENT to Lux */
34 #define HUEY_AMBIENT_UNITS_TO_LUX 125.0f
35
36 gboolean
37 huey_device_send_data (GUsbDevice *device,
38 const guint8 *request,
39 gsize request_len,
40 guint8 *reply,
41 gsize reply_len,
42 gsize *reply_read,
43 GError **error)
44 {
45 gboolean ret;
46 guint i;
47
48 g_return_val_if_fail (G_USB_IS_DEVICE (device), FALSE);
49 g_return_val_if_fail (request != NULL, FALSE);
50 g_return_val_if_fail (request_len != 0, FALSE);
51 g_return_val_if_fail (reply != NULL, FALSE);
52 g_return_val_if_fail (reply_len != 0, FALSE);
53 g_return_val_if_fail (reply_read != NULL, FALSE);
54 g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
55
56 /* control transfer */
57 cd_buffer_debug (CD_BUFFER_KIND_REQUEST,
58 request, request_len);
59 ret = g_usb_device_control_transfer (device,
60 G_USB_DEVICE_DIRECTION_HOST_TO_DEVICE,
61 G_USB_DEVICE_REQUEST_TYPE_CLASS,
62 G_USB_DEVICE_RECIPIENT_INTERFACE,
63 0x09,
64 0x0200,
65 0,
66 (guint8 *) request,
67 request_len,
68 NULL,
69 HUEY_CONTROL_MESSAGE_TIMEOUT,
70 NULL,
71 error);
72 if (!ret)
73 return FALSE;
74
75 /* some commands need to retry the read */
76 for (i = 0; i < HUEY_MAX_READ_RETRIES; i++) {
77
78 /* get sync response */
79 ret = g_usb_device_interrupt_transfer (device,
80 0x81,
81 (guint8 *) reply,
82 reply_len,
83 reply_read,
84 HUEY_CONTROL_MESSAGE_TIMEOUT,
85 NULL,
86 error);
87 if (!ret)
88 return FALSE;
89
90 /* the second byte seems to be the command again */
91 cd_buffer_debug (CD_BUFFER_KIND_RESPONSE,
92 reply, *reply_read);
93 if (reply[1] != request[0]) {
94 g_set_error (error,
95 G_IO_ERROR,
96 G_IO_ERROR_FAILED,
97 "wrong command reply, got 0x%02x, "
98 "expected 0x%02x",
99 reply[1],
100 request[0]);
101 return FALSE;
102 }
103
104 /* the first byte is status */
105 if (reply[0] == HUEY_RC_SUCCESS)
106 return TRUE;
107
108 /* failure, the return buffer is set to "Locked" */
109 if (reply[0] == HUEY_RC_LOCKED) {
110 g_set_error_literal (error,
111 G_IO_ERROR,
112 G_IO_ERROR_NOT_INITIALIZED,
113 "the device is locked");
114 return FALSE;
115 }
116
117 /* failure, the return buffer is set to "NoCmd" */
118 if (reply[0] == HUEY_RC_ERROR) {
119 g_set_error (error,
120 G_IO_ERROR,
121 G_IO_ERROR_FAILED,
122 "failed to issue command: %s", &reply[2]);
123 return FALSE;
124 }
125
126 /* we ignore retry */
127 if (reply[0] != HUEY_RC_RETRY) {
128 g_set_error (error,
129 G_IO_ERROR,
130 G_IO_ERROR_FAILED,
131 "return value unknown: 0x%02x", reply[0]);
132 return FALSE;
133 }
134 }
135
136 /* no success */
137 g_set_error (error,
138 G_IO_ERROR,
139 G_IO_ERROR_FAILED,
140 "gave up retrying after %i reads",
141 HUEY_MAX_READ_RETRIES);
142 return FALSE;
143 }
144
145 gchar *
146 huey_device_get_status (GUsbDevice *device, GError **error)
147 {
148 guint8 request[8];
149 guint8 reply[8];
150 gboolean ret;
151 gsize reply_read;
152 g_autoptr(GError) error_local = NULL;
153
154 g_return_val_if_fail (G_USB_IS_DEVICE (device), NULL);
155 g_return_val_if_fail (error == NULL || *error == NULL, NULL);
156
157 memset (request, 0x00, sizeof(request));
158 memset (reply, 0x00, sizeof(reply));
159 request[0] = HUEY_CMD_GET_STATUS;
160 ret = huey_device_send_data (device,
161 request, 8,
162 reply, 8,
163 &reply_read,
164 &error_local);
165 if (!ret) {
166 if (!g_error_matches (error_local, G_IO_ERROR, G_IO_ERROR_NOT_INITIALIZED)) {
167 g_propagate_error (error, error_local);
168 error_local = NULL;
169 return NULL;
170 }
171 }
172
173 /* for error the string is also set */
174 return g_strndup ((gchar *) reply + 2, 6);
175 }
176
177 gboolean
178 huey_device_unlock (GUsbDevice *device, GError **error)
179 {
180 guint8 request[8];
181 guint8 reply[8];
182 gboolean ret;
183 gsize reply_read;
184 g_autofree gchar *status = NULL;
185
186 g_return_val_if_fail (G_USB_IS_DEVICE (device), FALSE);
187 g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
188
189 /* get initial status */
190 status = huey_device_get_status (device, error);
191 if (status == NULL)
192 return FALSE;
193 g_debug ("status is: %s", status);
194
195 /* embedded devices on Lenovo machines use a different unlock code */
196 if (g_usb_device_get_vid (device) == 0x0765 &&
197 g_usb_device_get_pid (device) == 0x5001) {
198 request[0] = HUEY_CMD_UNLOCK;
199 request[1] = 'h';
200 request[2] = 'u';
201 request[3] = 'y';
202 request[4] = 'L';
203 request[5] = '\0';
204 request[6] = '\0';
205 request[7] = '\0';
206 } else {
207 request[0] = HUEY_CMD_UNLOCK;
208 request[1] = 'G';
209 request[2] = 'r';
210 request[3] = 'M';
211 request[4] = 'b';
212 request[5] = '\0';
213 request[6] = '\0';
214 request[7] = '\0';
215 }
216
217 /* no idea why the hardware gets 'locked' */
218 ret = huey_device_send_data (device,
219 request, 8,
220 reply, 8,
221 &reply_read,
222 error);
223 if (!ret)
224 return FALSE;
225 return TRUE;
226 }
227
228 gchar *
229 huey_device_get_serial_number (GUsbDevice *device, GError **error)
230 {
231 gboolean ret;
232 guint32 tmp;
233
234 g_return_val_if_fail (G_USB_IS_DEVICE (device), NULL);
235 g_return_val_if_fail (error == NULL || *error == NULL, NULL);
236
237 ret = huey_device_read_register_word (device,
238 HUEY_EEPROM_ADDR_SERIAL,
239 &tmp,
240 error);
241 if (!ret)
242 return NULL;
243 return g_strdup_printf ("%" G_GUINT32_FORMAT, tmp);
244 }
245
246 gchar *
247 huey_device_get_unlock_string (GUsbDevice *device, GError **error)
248 {
249 gboolean ret;
250 gchar tmp[5];
251
252 g_return_val_if_fail (G_USB_IS_DEVICE (device), NULL);
253 g_return_val_if_fail (error == NULL || *error == NULL, NULL);
254
255 ret = huey_device_read_register_string (device,
256 HUEY_EEPROM_ADDR_UNLOCK,
257 tmp,
258 sizeof (tmp),
259 error);
260 if (!ret)
261 return NULL;
262 return g_strndup (tmp, sizeof (tmp));
263 }
264
265 gboolean
266 huey_device_set_leds (GUsbDevice *device, guint8 value, GError **error)
267 {
268 guint8 reply[8];
269 gsize reply_read;
270 guint8 payload[] = { HUEY_CMD_SET_LEDS,
271 0x00,
272 ~value,
273 0x00,
274 0x00,
275 0x00,
276 0x00,
277 0x00 };
278
279 g_return_val_if_fail (G_USB_IS_DEVICE (device), FALSE);
280 g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
281
282 return huey_device_send_data (device,
283 payload, 8, reply, 8,
284 &reply_read,
285 error);
286 }
287
288 gdouble
289 huey_device_get_ambient (GUsbDevice *device, GError **error)
290 {
291 gboolean ret;
292 gsize reply_read;
293 guint8 reply[8];
294 guint8 request[] = { HUEY_CMD_GET_AMBIENT,
295 0x03,
296 0x00,
297 0x00,
298 0x00,
299 0x00,
300 0x00,
301 0x00 };
302
303 g_return_val_if_fail (G_USB_IS_DEVICE (device), -1);
304 g_return_val_if_fail (error == NULL || *error == NULL, -1);
305
306 /* just use LCD mode */
307 request[2] = 0x00;
308 ret = huey_device_send_data (device,
309 request, 8,
310 reply, 8,
311 &reply_read,
312 error);
313 if (!ret)
314 return -1.f;
315
316 /* parse the value */
317 return (gdouble) cd_buffer_read_uint16_be (reply+5) / HUEY_AMBIENT_UNITS_TO_LUX;
318 }
319
320 gboolean
321 huey_device_read_register_byte (GUsbDevice *device,
322 guint8 addr,
323 guint8 *value,
324 GError **error)
325 {
326 guint8 request[] = { HUEY_CMD_REGISTER_READ,
327 0xff,
328 0x00,
329 0x10,
330 0x3c,
331 0x06,
332 0x00,
333 0x00 };
334 guint8 reply[8];
335 gboolean ret;
336 gsize reply_read;
337
338 g_return_val_if_fail (G_USB_IS_DEVICE (device), FALSE);
339 g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
340
341 /* hit hardware */
342 request[1] = addr;
343 ret = huey_device_send_data (device,
344 request, 8,
345 reply, 8,
346 &reply_read,
347 error);
348 if (!ret)
349 return FALSE;
350 *value = reply[3];
351 return TRUE;
352 }
353
354 gboolean
355 huey_device_read_register_string (GUsbDevice *device,
356 guint8 addr,
357 gchar *value,
358 gsize len,
359 GError **error)
360 {
361 guint8 i;
362 gboolean ret;
363
364 g_return_val_if_fail (G_USB_IS_DEVICE (device), FALSE);
365 g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
366
367 /* get each byte of the string */
368 for (i = 0; i < len; i++) {
369 ret = huey_device_read_register_byte (device,
370 addr+i,
371 (guint8*) &value[i],
372 error);
373 if (!ret)
374 return FALSE;
375 }
376 return TRUE;
377 }
378
379 gboolean
380 huey_device_read_register_word (GUsbDevice *device,
381 guint8 addr,
382 guint32 *value,
383 GError **error)
384 {
385 guint8 i;
386 guint8 tmp[4];
387 gboolean ret;
388
389 g_return_val_if_fail (G_USB_IS_DEVICE (device), FALSE);
390 g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
391
392 /* get each byte of the 32 bit number */
393 for (i = 0; i < 4; i++) {
394 ret = huey_device_read_register_byte (device,
395 addr+i,
396 tmp+i,
397 error);
398 if (!ret)
399 return FALSE;
400 }
401
402 /* convert to a 32 bit integer */
403 *value = cd_buffer_read_uint32_be (tmp);
404 return TRUE;
405 }
406
407 gboolean
408 huey_device_read_register_float (GUsbDevice *device,
409 guint8 addr,
410 gfloat *value,
411 GError **error)
412 {
413 gboolean ret;
414 guint32 tmp = 0;
415
416 g_return_val_if_fail (G_USB_IS_DEVICE (device), FALSE);
417 g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
418
419 /* first read in 32 bit integer */
420 ret = huey_device_read_register_word (device,
421 addr,
422 &tmp,
423 error);
424 if (!ret)
425 return FALSE;
426
427 /* convert to float */
428 *((guint32 *)value) = tmp;
429 return TRUE;
430 }
431
432 gboolean
433 huey_device_read_register_vector (GUsbDevice *device,
434 guint8 addr,
435 CdVec3 *value,
436 GError **error)
437 {
438 gboolean ret;
439 guint i;
440 gfloat tmp = 0.0f;
441 gdouble *vector_data;
442
443 g_return_val_if_fail (G_USB_IS_DEVICE (device), FALSE);
444 g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
445
446 /* get this to avoid casting */
447 vector_data = cd_vec3_get_data (value);
448
449 /* read in vec3 */
450 for (i = 0; i < 3; i++) {
451 ret = huey_device_read_register_float (device,
452 addr + (i*4),
453 &tmp,
454 error);
455 if (!ret)
456 return FALSE;
457
458 /* save in matrix */
459 *(vector_data+i) = tmp;
460 }
461 return TRUE;
462 }
463
464 gboolean
465 huey_device_read_register_matrix (GUsbDevice *device,
466 guint8 addr,
467 CdMat3x3 *value,
468 GError **error)
469 {
470 gboolean ret;
471 guint i;
472 gfloat tmp = 0.0f;
473 gdouble *matrix_data;
474
475 g_return_val_if_fail (G_USB_IS_DEVICE (device), FALSE);
476 g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
477
478 /* get this to avoid casting */
479 matrix_data = cd_mat33_get_data (value);
480
481 /* read in 3d matrix */
482 for (i = 0; i < 9; i++) {
483 ret = huey_device_read_register_float (device,
484 addr + (i*4),
485 &tmp,
486 error);
487 if (!ret)
488 return FALSE;
489
490 /* save in matrix */
491 *(matrix_data+i) = tmp;
492 }
493 return TRUE;
494 }