Debian Codegraph @

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

raw
1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
2 *
3 * Copyright (C) 2013-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 <string.h>
28
29 #include "../src/cd-sensor.h"
30
31 #include "dtp94-enum.h"
32 #include "dtp94-device.h"
33
34 typedef struct
35 {
36 GUsbDevice *device;
37 } CdSensorDtp94Private;
38
39 #define DTP94_CONTROL_MESSAGE_TIMEOUT 50000 /* ms */
40
41 static CdSensorDtp94Private *
42 cd_sensor_dtp94_get_private (CdSensor *sensor)
43 {
44 return g_object_get_data (G_OBJECT (sensor), "priv");
45 }
46
47 static void
48 cd_sensor_dtp94_sample_thread_cb (GTask *task,
49 gpointer source_object,
50 gpointer task_data,
51 GCancellable *cancellable)
52 {
53 CdSensor *sensor = CD_SENSOR (source_object);
54 CdSensorCap cap = GPOINTER_TO_UINT (task_data);
55 CdSensorDtp94Private *priv = cd_sensor_dtp94_get_private (sensor);
56 CdColorXYZ *sample;
57 g_autoptr(GError) error = NULL;
58
59 /* take a measurement from the sensor */
60 cd_sensor_set_state_in_idle (sensor, CD_SENSOR_STATE_MEASURING);
61 sample = dtp94_device_take_sample (priv->device, cap, &error);
62 if (sample == NULL) {
63 g_task_return_new_error (task,
64 CD_SENSOR_ERROR,
65 CD_SENSOR_ERROR_NO_DATA,
66 "%s", error->message);
67 return;
68 }
69 g_task_return_pointer (task, sample, NULL);
70 }
71
72 void
73 cd_sensor_get_sample_async (CdSensor *sensor,
74 CdSensorCap cap,
75 GCancellable *cancellable,
76 GAsyncReadyCallback callback,
77 gpointer user_data)
78 {
79 g_autoptr(GTask) task = NULL;
80 g_return_if_fail (CD_IS_SENSOR (sensor));
81 task = g_task_new (sensor, cancellable, callback, user_data);
82 g_task_set_task_data (task, GUINT_TO_POINTER (cap), NULL);
83 g_task_run_in_thread (task, cd_sensor_dtp94_sample_thread_cb);
84 }
85
86 CdColorXYZ *
87 cd_sensor_get_sample_finish (CdSensor *sensor, GAsyncResult *res, GError **error)
88 {
89 g_return_val_if_fail (g_task_is_valid (res, sensor), NULL);
90 return g_task_propagate_pointer (G_TASK (res), error);
91 }
92
93 static void
94 cd_sensor_dtp94_lock_thread_cb (GTask *task,
95 gpointer source_object,
96 gpointer task_data,
97 GCancellable *cancellable)
98 {
99 CdSensor *sensor = CD_SENSOR (source_object);
100 CdSensorDtp94Private *priv = cd_sensor_dtp94_get_private (sensor);
101 g_autoptr(GError) error = NULL;
102 g_autofree gchar *serial = NULL;
103
104 /* try to find the USB device */
105 priv->device = cd_sensor_open_usb_device (sensor,
106 0x01, /* config */
107 0x00, /* interface */
108 &error);
109 if (priv->device == NULL) {
110 g_task_return_new_error (task,
111 CD_SENSOR_ERROR,
112 CD_SENSOR_ERROR_INTERNAL,
113 "%s", error->message);
114 return;
115 }
116
117 /* set state */
118 cd_sensor_set_state_in_idle (sensor, CD_SENSOR_STATE_STARTING);
119
120 /* do startup sequence */
121 if (!dtp94_device_setup (priv->device, &error)) {
122 g_task_return_new_error (task,
123 CD_SENSOR_ERROR,
124 CD_SENSOR_ERROR_INTERNAL,
125 "%s", error->message);
126 return;
127 }
128
129 /* get serial */
130 serial = dtp94_device_get_serial (priv->device, &error);
131 if (serial == NULL) {
132 g_task_return_new_error (task,
133 CD_SENSOR_ERROR,
134 CD_SENSOR_ERROR_NO_DATA,
135 "%s", error->message);
136 return;
137 }
138 cd_sensor_set_serial (sensor, serial);
139
140 /* success */
141 g_task_return_boolean (task, TRUE);
142 }
143
144 void
145 cd_sensor_lock_async (CdSensor *sensor,
146 GCancellable *cancellable,
147 GAsyncReadyCallback callback,
148 gpointer user_data)
149 {
150 g_autoptr(GTask) task = NULL;
151 g_return_if_fail (CD_IS_SENSOR (sensor));
152 task = g_task_new (sensor, cancellable, callback, user_data);
153 g_task_run_in_thread (task, cd_sensor_dtp94_lock_thread_cb);
154 }
155
156 gboolean
157 cd_sensor_lock_finish (CdSensor *sensor, GAsyncResult *res, GError **error)
158 {
159 g_return_val_if_fail (g_task_is_valid (res, sensor), FALSE);
160 return g_task_propagate_boolean (G_TASK (res), error);
161 }
162
163 static void
164 cd_sensor_unlock_thread_cb (GTask *task,
165 gpointer source_object,
166 gpointer task_data,
167 GCancellable *cancellable)
168 {
169 CdSensor *sensor = CD_SENSOR (source_object);
170 CdSensorDtp94Private *priv = cd_sensor_dtp94_get_private (sensor);
171 g_autoptr(GError) error = NULL;
172
173 /* close */
174 if (priv->device != NULL) {
175 if (!g_usb_device_close (priv->device, &error)) {
176 g_task_return_new_error (task,
177 CD_SENSOR_ERROR,
178 CD_SENSOR_ERROR_INTERNAL,
179 "%s", error->message);
180 return;
181 }
182 g_clear_object (&priv->device);
183 }
184
185 /* success */
186 g_task_return_boolean (task, TRUE);
187 }
188
189 void
190 cd_sensor_unlock_async (CdSensor *sensor,
191 GCancellable *cancellable,
192 GAsyncReadyCallback callback,
193 gpointer user_data)
194 {
195 g_autoptr(GTask) task = NULL;
196 g_return_if_fail (CD_IS_SENSOR (sensor));
197 task = g_task_new (sensor, cancellable, callback, user_data);
198 g_task_run_in_thread (task, cd_sensor_unlock_thread_cb);
199 }
200
201 gboolean
202 cd_sensor_unlock_finish (CdSensor *sensor, GAsyncResult *res, GError **error)
203 {
204 g_return_val_if_fail (g_task_is_valid (res, sensor), FALSE);
205 return g_task_propagate_boolean (G_TASK (res), error);
206 }
207
208 gboolean
209 cd_sensor_dump_device (CdSensor *sensor, GString *data, GError **error)
210 {
211 g_string_append_printf (data, "dtp94-dump-version:%i\n", 1);
212 return TRUE;
213 }
214
215 static void
216 cd_sensor_unref_private (CdSensorDtp94Private *priv)
217 {
218 if (priv->device != NULL)
219 g_object_unref (priv->device);
220 g_free (priv);
221 }
222
223 gboolean
224 cd_sensor_coldplug (CdSensor *sensor, GError **error)
225 {
226 CdSensorDtp94Private *priv;
227 guint64 caps = cd_bitfield_from_enums (CD_SENSOR_CAP_LCD,
228 CD_SENSOR_CAP_CRT, -1);
229 g_object_set (sensor,
230 "native", TRUE,
231 "kind", CD_SENSOR_KIND_DTP94,
232 "caps", caps,
233 NULL);
234 /* create private data */
235 priv = g_new0 (CdSensorDtp94Private, 1);
236 g_object_set_data_full (G_OBJECT (sensor), "priv", priv,
237 (GDestroyNotify) cd_sensor_unref_private);
238 return TRUE;
239 }