Debian Codegraph @

src/sensors/munki/cd-sensor-munki.c

raw
1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
2 *
3 * Copyright (C) 2010-2015 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
23 #include "config.h"
24
25 #include <glib-object.h>
26 #include <gusb.h>
27 #include <munki/munki.h>
28
29 #include "cd-buffer.h"
30 #include "cd-sensor.h"
31
32 #include "munki-enum.h"
33
34 typedef struct
35 {
36 gboolean done_startup;
37 GUsbDevice *device;
38 struct libusb_transfer *transfer_interrupt;
39 struct libusb_transfer *transfer_state;
40 gchar *version_string;
41 gchar *chip_id;
42 gchar *firmware_revision;
43 guint32 tick_duration;
44 guint32 min_int;
45 guint32 eeprom_blocks;
46 guint32 eeprom_blocksize;
47 } CdSensorMunkiPrivate;
48
49 #define CD_SENSOR_MUNKI_VENDOR_ID 0x0971
50 #define CD_SENSOR_MUNKI_PRODUCT_ID 0x2007
51
52 static void
53 cd_sensor_munki_submit_transfer (CdSensor *sensor);
54
55 static CdSensorMunkiPrivate *
56 cd_sensor_munki_get_private (CdSensor *sensor)
57 {
58 return g_object_get_data (G_OBJECT (sensor), "priv");
59 }
60
61 static void
62 cd_sensor_munki_refresh_state_transfer_cb (struct libusb_transfer *transfer)
63 {
64 CdSensor *sensor = CD_SENSOR (transfer->user_data);
65 guint8 *reply = transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE;
66
67 if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
68 g_warning ("did not succeed");
69 goto out;
70 }
71
72 /* sensor position and button task */
73 switch (reply[0]) {
74 case MUNKI_DIAL_POSITION_PROJECTOR:
75 cd_sensor_set_mode (sensor, CD_SENSOR_CAP_PROJECTOR);
76 break;
77 case MUNKI_DIAL_POSITION_SURFACE:
78 cd_sensor_set_mode (sensor, CD_SENSOR_CAP_PRINTER);
79 break;
80 case MUNKI_DIAL_POSITION_CALIBRATION:
81 cd_sensor_set_mode (sensor, CD_SENSOR_CAP_CALIBRATION);
82 break;
83 case MUNKI_DIAL_POSITION_AMBIENT:
84 cd_sensor_set_mode (sensor, CD_SENSOR_CAP_AMBIENT);
85 break;
86 case MUNKI_DIAL_POSITION_UNKNOWN:
87 cd_sensor_set_mode (sensor, CD_SENSOR_CAP_UNKNOWN);
88 break;
89 default:
90 break;
91 }
92
93 g_debug ("dial now %s, button now %s",
94 cd_sensor_cap_to_string (cd_sensor_get_mode (sensor)),
95 munki_button_state_to_string (reply[1]));
96
97 cd_sensor_debug_data (CD_SENSOR_DEBUG_MODE_RESPONSE,
98 transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE,
99 transfer->actual_length);
100 out:
101 g_free (transfer->buffer);
102 }
103
104 static gboolean
105 cd_sensor_munki_refresh_state (CdSensor *sensor, GError **error)
106 {
107 gint retval;
108 gboolean ret = FALSE;
109 static guint8 *request;
110 libusb_device_handle *handle;
111 CdSensorMunkiPrivate *priv = cd_sensor_munki_get_private (sensor);
112
113 /* do sync request */
114 handle = cd_usb_get_device_handle (priv->usb);
115
116 /* request new button task */
117 request = g_new0 (guint8, LIBUSB_CONTROL_SETUP_SIZE + 2);
118 libusb_fill_control_setup (request,
119 LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE,
120 MUNKI_REQUEST_GET_STATUS,
121 0x00, 0, 2);
122 libusb_fill_control_transfer (priv->transfer_state, handle, request,
123 &cd_sensor_munki_refresh_state_transfer_cb,
124 sensor, 2000);
125
126 /* submit transfer */
127 retval = libusb_submit_transfer (priv->transfer_state);
128 if (retval < 0) {
129 g_set_error (error, 1, 0,
130 "failed to submit transfer: %s",
131 libusb_strerror (retval));
132 goto out;
133 }
134
135 /* success */
136 ret = TRUE;
137 out:
138 return ret;
139 }
140
141 static void
142 cd_sensor_munki_transfer_cb (struct libusb_transfer *transfer)
143 {
144 guint32 timestamp;
145 CdSensor *sensor = CD_SENSOR (transfer->user_data);
146 guint8 *reply = transfer->buffer;
147
148 if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
149 g_warning ("did not succeed");
150 return;
151 }
152
153 cd_sensor_debug_data (CD_SENSOR_DEBUG_MODE_RESPONSE,
154 transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE,
155 transfer->actual_length);
156 timestamp = (reply[7] << 24) + (reply[6] << 16) + (reply[5] << 8) + (reply[4] << 0);
157 /* we only care when the button is pressed */
158 if (reply[0] == MUNKI_COMMAND_BUTTON_RELEASED) {
159 g_debug ("ignoring button released");
160 goto out;
161 }
162
163 if (reply[0] == MUNKI_COMMAND_DIAL_ROTATE) {
164 g_warning ("dial rotate at %ims", timestamp);
165 } else if (reply[0] == MUNKI_COMMAND_BUTTON_PRESSED) {
166 g_debug ("button pressed at %ims", timestamp);
167 cd_sensor_button_pressed (sensor);
168 }
169
170 /* get the device task */
171 cd_sensor_munki_refresh_state (sensor, NULL);
172
173 out:
174 /* get the next bit of data */
175 g_free (transfer->buffer);
176 cd_sensor_munki_submit_transfer (sensor);
177 }
178
179 static void
180 cd_sensor_munki_submit_transfer (CdSensor *sensor)
181 {
182 gint retval;
183 guint8 *reply;
184 libusb_device_handle *handle;
185 CdSensorMunkiPrivate *priv = cd_sensor_munki_get_private (sensor);
186
187 reply = g_new0 (guint8, 8);
188 handle = cd_usb_get_device_handle (priv->usb);
189 libusb_fill_interrupt_transfer (priv->transfer_interrupt, handle,
190 MUNKI_REQUEST_INTERRUPT,
191 reply, 8,
192 cd_sensor_munki_transfer_cb,
193 sensor, -1);
194
195 g_debug ("submitting transfer");
196 retval = libusb_submit_transfer (priv->transfer_interrupt);
197 if (retval < 0)
198 g_warning ("failed to submit transfer: %s", libusb_strerror (retval));
199 }
200
201 static gboolean
202 cd_sensor_munki_get_eeprom_data (CdSensor *sensor,
203 guint32 address, guint8 *data,
204 guint32 size, GError **error)
205 {
206 gint retval;
207 libusb_device_handle *handle;
208 guint8 request[8];
209 gsize reply_read = 0;
210 gboolean ret = FALSE;
211 CdSensorMunkiPrivate *priv = cd_sensor_munki_get_private (sensor);
212
213 /* do EEPROM request */
214 g_debug ("get EEPROM at 0x%04x for %i", address, size);
215 cd_buffer_write_uint32_le (request, address);
216 cd_buffer_write_uint32_le (request + 4, size);
217 cd_sensor_debug_data (CD_SENSOR_DEBUG_MODE_REQUEST,
218 request, 8);
219 handle = cd_usb_get_device_handle (priv->usb);
220 retval = libusb_control_transfer (handle,
221 LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE,
222 MUNKI_REQUEST_EEPROM_DATA,
223 0, 0, request, 8, 2000);
224 if (retval < 0) {
225 g_set_error (error, CD_SENSOR_ERROR,
226 CD_SENSOR_ERROR_NO_SUPPORT,
227 "failed to request eeprom: %s",
228 libusb_strerror (retval));
229 goto out;
230 }
231
232 /* read EEPROM */
233 retval = libusb_bulk_transfer (handle,
234 MUNKI_REQUEST_EEPROM_DATA,
235 data, (gint) size, (gint*)&reply_read,
236 5000);
237 if (retval < 0) {
238 g_set_error (error, CD_SENSOR_ERROR,
239 CD_SENSOR_ERROR_NO_SUPPORT,
240 "failed to get eeprom data: %s",
241 libusb_strerror (retval));
242 goto out;
243 }
244 if (reply_read != size) {
245 g_set_error_literal (error, CD_SENSOR_ERROR,
246 CD_SENSOR_ERROR_NO_SUPPORT,
247 "did not get the correct number of bytes");
248 goto out;
249 }
250 cd_sensor_debug_data (CD_SENSOR_DEBUG_MODE_RESPONSE,
251 data, size);
252
253 /* success */
254 ret = TRUE;
255 out:
256 return ret;
257 }
258
259 static gboolean
260 cd_sensor_munki_random (CdSensor *sensor, GError **error)
261 {
262 gboolean ret = FALSE;
263 // CdSensorMunkiPrivate *priv = cd_sensor_munki_get_private (sensor);
264
265 g_debug ("submit transfer");
266 cd_sensor_munki_submit_transfer (sensor);
267 ret = cd_sensor_munki_refresh_state (sensor, error);
268 if (!ret)
269 goto out;
270 out:
271 return ret;
272 }
273
274 static void
275 g_task_return_error (GTask *task,
276 const GError *error)
277 {
278 /* set result to temp memory location */
279 if (task->ret) {
280 g_simple_async_result_set_op_res_gpointer (task->res,
281 task->sample,
282 (GDestroyNotify) cd_color_xyz_free);
283 } else {
284 g_simple_async_result_set_from_error (task->res, error);
285 }
286
287 /* deallocate */
288 if (g_task_get_cancellable (task) != NULL) {
289 g_cancellable_disconnect (g_task_get_cancellable (task), g_task_get_cancellable (task)_id);
290 g_object_unref (g_task_get_cancellable (task));
291 }
292
293 g_object_unref (task->res);
294 g_object_unref (sensor);
295 g_slice_free (CdSensorTaskData, task);
296 }
297
298 static void
299 cd_sensor_munki_cancellable_cancel_cb (GCancellable *cancellable,
300 GTask *task)
301 {
302 g_warning ("cancelled munki");
303 }
304
305 static void
306 cd_sensor_munki_get_ambient_thread_cb (GSimpleAsyncResult *res,
307 GObject *object,
308 GCancellable *cancellable)
309 {
310 CdSensor *sensor = CD_SENSOR (object);
311 g_autoptr(GError) error = NULL;
312 // CdSensorMunkiPrivate *priv = cd_sensor_munki_get_private (sensor);
313
314 /* no hardware support */
315 if (cd_sensor_get_mode (sensor) != CD_SENSOR_CAP_AMBIENT) {
316 g_set_error_literal (&error, CD_SENSOR_ERROR,
317 CD_SENSOR_ERROR_NO_SUPPORT,
318 "Cannot measure ambient light in this mode (turn dial!)");
319 g_task_return_new_error (task,
320 CD_SENSOR_ERROR,
321 CD_SENSOR_ERROR_INTERNAL,
322 "%s", error->message);
323 goto out;
324 }
325
326 /*
327 * ioctl(3, USBDEVFS_SUBMITURB or USBDEVFS_SUBMITURB32, {type=3, endpoint=129, status=0, flags=0, buffer_length=1096, actual_length=0, start_frame=0, number_of_packets=0, error_count=0, signr=0, usercontext=(nil), buffer=00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ) = 0
328 * ioctl(3, USBDEVFS_CONTROL or USBDEVFS_CONTROL32, {requesttype=64, request=128, value=0, index=0, length=12, timeout=2000, data=00 00 01 00 b7 3e 00 00 02 00 00 00 ) = 12
329 *
330 * ioctl(3, USBDEVFS_SUBMITURB or USBDEVFS_SUBMITURB32, {type=3, endpoint=129, status=0, flags=0, buffer_length=548, actual_length=0, start_frame=0, number_of_packets=0, error_count=0, signr=0, usercontext=(nil), buffer=d0 a3 9d 00 d0 a3 9d 00 00 00 00 00 00 00 00 00 00 d0 86 40 bf c6 fa 21 a4 4b 61 40 0b 24 0c d6 7a 29 04 40 91 3a 0e c7 f9 28 04 40 c0 b1 55 bc 9b 28 04 40 b9 d3 41 53 86 6a 07 40 df 23 db 4d 0c e3 06 40 20 5c bf 4d b2 53 05 40 5f 28 38 74 26 44 07 40 e9 45 b7 e4 2f a5 08 40 bb a2 87 d7 8c db 07 40 34 90 30 b1 f3 a1 06 40 b0 8f fa 63 84 98 05 40 35 1f 09 07 97 47 04 40 53 ac 8a be ) = 0
331 *
332 * ioctl(3, USBDEVFS_REAPURBNDELAY or USBDEVFS_REAPURBNDELAY32, {type=3, endpoint=129, status=0, flags=0, buffer_length=548, actual_length=548, start_frame=0, number_of_packets=0, error_count=0, signr=0, usercontext=(nil), buffer=de 07 da 07 d6 07 d8 07 d6 07 16 08 29 0b 79 0d 22 12 f2 17 b4 1c 31 20 4b 22 e2 22 7b 22 a8 21 93 20 eb 1e 2d 1d fe 1b 1c 1b e5 19 69 19 c8 19 b5 19 8a 18 16 17 a4 15 86 14 ac 13 e8 12 22 12 20 12 bf 12 8e 13 d2 13 de 13 ea 13 fb 13 39 14 89 14 bd 14 ec 14 8b 15 78 16 69 17 99 18 ca 19 97 1a 14 1b 6f 1b b5 1b 7f 1c 98 1d 59 1e a9 1e af 1e 71 1e d2 1d db 1c c1 1b d4 1a 50 1a 46 1a }) = 0
333 * write(1, " Result is XYZ: 126.685284 136.9"..., 91 Result is XYZ: 126.685284 136.946975 206.789116, D50 Lab: 112.817679 -7.615524 -49.589593
334 ) = 91
335 * write(1, " Ambient = 430.2 Lux, CCT = 1115"..., 54 Ambient = 430.2 Lux, CCT = 11152K (Delta E 9.399372)
336 */
337
338 /* set state */
339 cd_sensor_set_state_in_idle (sensor, CD_SENSOR_STATE_MEASURING);
340
341 /* save result */
342 g_task_return_error (task, NULL);
343 out:
344 /* set state */
345 cd_sensor_set_state_in_idle (sensor, CD_SENSOR_STATE_IDLE);
346 }
347
348 static void
349 cd_sensor_munki_sample_thread_cb (GSimpleAsyncResult *res,
350 GObject *object,
351 GCancellable *cancellable)
352 {
353 g_autoptr(GError) error = NULL;
354 CdSensor *sensor = CD_SENSOR (object);
355 // CdSensorMunkiPrivate *priv = cd_sensor_munki_get_private (sensor);
356
357 /* no hardware support */
358 if (task->current_cap == CD_SENSOR_CAP_PROJECTOR) {
359 g_set_error_literal (&error, CD_SENSOR_ERROR,
360 CD_SENSOR_ERROR_NO_SUPPORT,
361 "MUNKI cannot measure in projector mode");
362 g_task_return_new_error (task,
363 CD_SENSOR_ERROR,
364 CD_SENSOR_ERROR_INTERNAL,
365 "%s", error->message);
366 goto out;
367 }
368
369 /* set state */
370 cd_sensor_set_state_in_idle (sensor, CD_SENSOR_STATE_MEASURING);
371
372 /* save result */
373 task->sample = cd_color_xyz_new ();
374 g_task_return_error (task, NULL);
375 out:
376 /* set state */
377 cd_sensor_set_state_in_idle (sensor, CD_SENSOR_STATE_IDLE);
378 }
379
380 void
381 cd_sensor_get_sample_async (CdSensor *sensor,
382 CdSensorCap cap,
383 GCancellable *cancellable,
384 GAsyncReadyCallback callback,
385 gpointer user_data)
386 {
387 g_autoptr(GTask) task = NULL;
388 g_return_if_fail (CD_IS_SENSOR (sensor));
389 task = g_task_new (sensor, cancellable, callback, user_data);
390 if (cap == CD_SENSOR_CAP_AMBIENT) {
391 g_task_run_in_thread (task, cd_sensor_munki_get_ambient_thread_cb);
392 } else if (cap == CD_SENSOR_CAP_LCD ||
393 cap == CD_SENSOR_CAP_LED ||
394 cap == CD_SENSOR_CAP_CRT) {
395 g_task_run_in_thread (task, cd_sensor_munki_sample_thread_cb);
396 }
397 }
398
399 CdColorXYZ *
400 cd_sensor_get_sample_finish (CdSensor *sensor, GAsyncResult *res, GError **error)
401 {
402 g_return_val_if_fail (g_task_is_valid (res, sensor), NULL);
403 return g_task_propagate_pointer (G_TASK (res), error);
404 }
405
406 static void
407 cd_sensor_munki_lock_thread_cb (GSimpleAsyncResult *res,
408 GObject *object,
409 GCancellable *cancellable)
410 {
411 CdSensor *sensor = CD_SENSOR (object);
412 CdSensorMunkiPrivate *priv = cd_sensor_munki_get_private (sensor);
413 gboolean ret = FALSE;
414 g_autoptr(GError) error = NULL;
415 gint retval;
416 guint8 buffer[36];
417 libusb_device_handle *handle;
418
419 /* try to find the USB device */
420 priv->device = cd_sensor_open_usb_device (sensor,
421 0x01, /* config */
422 0x00, /* interface */
423 &error);
424 if (priv->device == NULL) {
425 g_task_return_new_error (task,
426 CD_SENSOR_ERROR,
427 CD_SENSOR_ERROR_INTERNAL,
428 "%s", error->message);
429 goto out;
430 }
431
432 /* attach to the default mainloop */
433 ret = cd_usb_attach_to_context (priv->usb, NULL, &error);
434 if (!ret) {
435 g_task_return_new_error (task, CD_SENSOR_ERROR,
436 CD_SENSOR_ERROR_NO_SUPPORT,
437 "failed to attach to mainloop: %s",
438 error->message);
439 goto out;
440 }
441
442 /* get firmware parameters */
443 handle = cd_usb_get_device_handle (priv->usb);
444 retval = libusb_control_transfer (handle,
445 LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE,
446 MUNKI_REQUEST_FIRMWARE_PARAMS,
447 0, 0, buffer, 24, 2000);
448 if (retval < 0) {
449 g_task_return_new_error (task, CD_SENSOR_ERROR,
450 CD_SENSOR_ERROR_NO_SUPPORT,
451 "failed to get firmware parameters: %s",
452 libusb_strerror (retval));
453 goto out;
454 }
455 priv->firmware_revision = g_strdup_printf ("%i.%i",
456 cd_buffer_read_uint32_le (buffer),
457 cd_buffer_read_uint32_le (buffer+4));
458 priv->tick_duration = cd_buffer_read_uint32_le (buffer+8);
459 priv->min_int = cd_buffer_read_uint32_le (buffer+0x0c);
460 priv->eeprom_blocks = cd_buffer_read_uint32_le (buffer+0x10);
461 priv->eeprom_blocksize = cd_buffer_read_uint32_le (buffer+0x14);
462
463 /* get chip ID */
464 retval = libusb_control_transfer (handle,
465 LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE,
466 MUNKI_REQUEST_CHIP_ID,
467 0, 0, buffer, 8, 2000);
468 if (retval < 0) {
469 g_task_return_new_error (task, CD_SENSOR_ERROR,
470 CD_SENSOR_ERROR_NO_SUPPORT,
471 "failed to get chip id parameters: %s",
472 libusb_strerror (retval));
473 goto out;
474 }
475 priv->chip_id = g_strdup_printf ("%02x-%02x%02x%02x%02x%02x%02x%02x",
476 buffer[0], buffer[1], buffer[2], buffer[3],
477 buffer[4], buffer[5], buffer[6], buffer[7]);
478
479 /* get version string */
480 priv->version_string = g_new0 (gchar, 36);
481 retval = libusb_control_transfer (handle,
482 LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE,
483 MUNKI_REQUEST_VERSION_STRING,
484 0, 0, (guint8*) priv->version_string, 36, 2000);
485 if (retval < 0) {
486 g_task_return_new_error (task, CD_SENSOR_ERROR,
487 CD_SENSOR_ERROR_NO_SUPPORT,
488 "failed to get version string: %s",
489 libusb_strerror (retval));
490 goto out;
491 }
492
493 /* get serial number */
494 ret = cd_sensor_munki_get_eeprom_data (sensor,
495 COLORMUNKI_EEPROM_OFFSET_SERIAL_NUMBER,
496 buffer, 10, &error);
497 if (!ret) {
498 g_task_return_new_error (task,
499 CD_SENSOR_ERROR,
500 CD_SENSOR_ERROR_INTERNAL,
501 "%s", error->message);
502 goto out;
503 }
504 cd_sensor_set_serial (sensor, (const gchar*) buffer);
505
506 /* print details */
507 g_debug ("Chip ID\t%s", priv->chip_id);
508 g_debug ("Serial number\t%s", buffer);
509 g_debug ("Version\t%s", priv->version_string);
510 g_debug ("Firmware\tfirmware_revision=%s, tick_duration=%i, min_int=%i, eeprom_blocks=%i, eeprom_blocksize=%i",
511 priv->firmware_revision, priv->tick_duration, priv->min_int, priv->eeprom_blocks, priv->eeprom_blocksize);
512
513 /* do unknown cool stuff */
514 ret = cd_sensor_munki_random (sensor, &error);
515 if (!ret) {
516 g_assert (error != NULL);
517 g_task_return_new_error (task,
518 CD_SENSOR_ERROR,
519 CD_SENSOR_ERROR_INTERNAL,
520 "%s", error->message);
521 goto out;
522 }
523 out:
524 /* set state */
525 cd_sensor_set_state_in_idle (sensor, CD_SENSOR_STATE_IDLE);
526 }
527
528 void
529 cd_sensor_lock_async (CdSensor *sensor,
530 GCancellable *cancellable,
531 GAsyncReadyCallback callback,
532 gpointer user_data)
533 {
534 g_autoptr(GTask) task = NULL;
535 g_return_if_fail (CD_IS_SENSOR (sensor));
536 task = g_task_new (sensor, cancellable, callback, user_data);
537 g_task_run_in_thread (task, cd_sensor_munki_lock_thread_cb);
538 }
539
540 gboolean
541 cd_sensor_lock_finish (CdSensor *sensor,
542 GAsyncResult *res,
543 GError **error)
544 {
545 GSimpleAsyncResult *simple;
546 gboolean ret = TRUE;
547
548 g_return_val_if_fail (CD_IS_SENSOR (sensor), FALSE);
549 g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (res), FALSE);
550 g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
551
552 simple = G_SIMPLE_ASYNC_RESULT (res);
553 if (g_simple_async_result_propagate_error (simple, error)) {
554 ret = FALSE;
555 goto out;
556 }
557 out:
558 return ret;
559 }
560
561 static void
562 cd_sensor_unlock_thread_cb (GTask *task,
563 gpointer source_object,
564 gpointer task_data,
565 GCancellable *cancellable)
566 {
567 CdSensor *sensor = CD_SENSOR (object);
568 CdSensorMunkiPrivate *priv = cd_sensor_munki_get_private (sensor);
569 gboolean ret = FALSE;
570 g_autoptr(GError) error = NULL;
571
572 /* stop watching the dial */
573 libusb_cancel_transfer (priv->transfer_interrupt);
574 libusb_cancel_transfer (priv->transfer_state);
575
576 /* close */
577 if (priv->device != NULL) {
578 if (!g_usb_device_close (priv->device, &error)) {
579 g_task_return_new_error (task,
580 CD_SENSOR_ERROR,
581 CD_SENSOR_ERROR_INTERNAL,
582 "%s", error->message);
583 return;
584 }
585 g_clear_object (&priv->device);
586 }
587
588 /* success */
589 g_task_return_boolean (task, TRUE);
590 }
591
592 void
593 cd_sensor_unlock_async (CdSensor *sensor,
594 GCancellable *cancellable,
595 GAsyncReadyCallback callback,
596 gpointer user_data)
597 {
598 g_autoptr(GTask) task = NULL;
599 g_return_if_fail (CD_IS_SENSOR (sensor));
600 task = g_task_new (sensor, cancellable, callback, user_data);
601 g_task_run_in_thread (task, cd_sensor_unlock_thread_cb);
602 }
603
604 gboolean
605 cd_sensor_unlock_finish (CdSensor *sensor, GAsyncResult *res, GError **error)
606 {
607 GSimpleAsyncResult *simple;
608 gboolean ret = TRUE;
609
610 g_return_val_if_fail (CD_IS_SENSOR (sensor), FALSE);
611 g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (res), FALSE);
612 g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
613
614 simple = G_SIMPLE_ASYNC_RESULT (res);
615 if (g_simple_async_result_propagate_error (simple, error)) {
616 ret = FALSE;
617 goto out;
618 }
619 out:
620 return ret;
621 }
622
623 gboolean
624 cd_sensor_dump_device (CdSensor *sensor, GString *data, GError **error)
625 {
626 guint8 *buffer;
627 guint i, j;
628 gboolean ret = TRUE;
629 CdSensorMunkiPrivate *priv = cd_sensor_munki_get_private (sensor);
630
631 /* dump the unlock string */
632 g_string_append_printf (data, "colormunki-dump-version: %i\n", 1);
633 g_string_append_printf (data, "chip-id:%s\n", priv->chip_id);
634 g_string_append_printf (data, "version:%s\n", priv->version_string);
635 g_string_append_printf (data, "firmware-revision:%s\n", priv->firmware_revision);
636 g_string_append_printf (data, "tick-duration:%i\n", priv->tick_duration);
637 g_string_append_printf (data, "min-int:%i\n", priv->min_int);
638 g_string_append_printf (data, "eeprom-blocks:%i\n", priv->eeprom_blocks);
639 g_string_append_printf (data, "eeprom-blocksize:%i\n", priv->eeprom_blocksize);
640
641 /* allocate a big chunk o' memory */
642 buffer = g_new0 (guint8, priv->eeprom_blocksize);
643
644 /* get all banks of EEPROM */
645 for (i = 0; i < priv->eeprom_blocks; i++) {
646 ret = cd_sensor_munki_get_eeprom_data (sensor,
647 i*priv->eeprom_blocksize,
648 buffer, priv->eeprom_blocksize,
649 error);
650 if (!ret)
651 goto out;
652
653 /* write details */
654 for (j = 0; j < priv->eeprom_blocksize; j++)
655 g_string_append_printf (data, "eeprom[0x%04x]:0x%02x\n", (i*priv->eeprom_blocksize) + j, buffer[j]);
656 }
657 out:
658 g_free (buffer);
659 return ret;
660 }
661
662 static void
663 cd_sensor_unref_private (CdSensorMunkiPrivate *priv)
664 {
665 /* FIXME: cancel transfers if in progress */
666
667 /* detach from the main loop */
668 if (priv->device != NULL)
669 g_object_unref (priv->device);
670
671 /* free transfers */
672 libusb_free_transfer (priv->transfer_interrupt);
673 libusb_free_transfer (priv->transfer_state);
674 g_free (priv->version_string);
675 g_free (priv->chip_id);
676 g_free (priv->firmware_revision);
677
678 g_free (priv);
679 }
680
681 gboolean
682 cd_sensor_coldplug (CdSensor *sensor, GError **error)
683 {
684 CdSensorMunkiPrivate *priv;
685 guint64 caps = CD_SENSOR_CAP_LCD |
686 CD_SENSOR_CAP_CRT |
687 CD_SENSOR_CAP_AMBIENT;
688 g_object_set (sensor,
689 "native", TRUE,
690 "kind", CD_SENSOR_KIND_COLOR_MUNKI_PHOTO,
691 "caps", caps,
692 NULL);
693 /* create private data */
694 priv = g_new0 (CdSensorMunkiPrivate, 1);
695 g_object_set_data_full (G_OBJECT (sensor), "priv", priv,
696 (GDestroyNotify) cd_sensor_unref_private);
697 priv->transfer_interrupt = libusb_alloc_transfer (0);
698 priv->transfer_state = libusb_alloc_transfer (0);
699 return TRUE;
700 }
701