]> sigrok.org Git - libsigrok.git/blob - hardware/tondaj-sl-814/api.c
Get rid of obsolete SR_DI_NUM_PROBES and SR_DI_PROBE_NAMES.
[libsigrok.git] / hardware / tondaj-sl-814 / api.c
1 /*
2  * This file is part of the sigrok project.
3  *
4  * Copyright (C) 2012 Uwe Hermann <uwe@hermann-uwe.de>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
19  */
20
21 #include <fcntl.h>
22 #include <glib.h>
23 #include "libsigrok.h"
24 #include "libsigrok-internal.h"
25 #include "protocol.h"
26
27 #define SERIALCOMM "9600/8e1"
28
29 static const int hwopts[] = {
30         SR_HWOPT_CONN,
31         SR_HWOPT_SERIALCOMM,
32         0,
33 };
34
35 static const int hwcaps[] = {
36         SR_HWCAP_SOUNDLEVELMETER,
37         SR_HWCAP_LIMIT_SAMPLES,
38         SR_HWCAP_CONTINUOUS,
39         0,
40 };
41
42 SR_PRIV struct sr_dev_driver tondaj_sl_814_driver_info;
43 static struct sr_dev_driver *di = &tondaj_sl_814_driver_info;
44
45 /* Properly close and free all devices. */
46 static int clear_instances(void)
47 {
48         struct sr_dev_inst *sdi;
49         struct drv_context *drvc;
50         struct dev_context *devc;
51         GSList *l;
52
53         if (!(drvc = di->priv))
54                 return SR_OK;
55
56         for (l = drvc->instances; l; l = l->next) {
57                 if (!(sdi = l->data))
58                         continue;
59                 if (!(devc = sdi->priv))
60                         continue;
61                 sr_serial_dev_inst_free(devc->serial);
62                 sr_dev_inst_free(sdi);
63         }
64
65         g_slist_free(drvc->instances);
66         drvc->instances = NULL;
67
68         return SR_OK;
69 }
70
71 static int hw_init(struct sr_context *sr_ctx)
72 {
73         struct drv_context *drvc;
74
75         if (!(drvc = g_try_malloc0(sizeof(struct drv_context)))) {
76                 sr_err("Driver context malloc failed.");
77                 return SR_ERR_MALLOC;
78         }
79
80         drvc->sr_ctx = sr_ctx;
81         di->priv = drvc;
82
83         return SR_OK;
84 }
85
86 static GSList *hw_scan(GSList *options)
87 {
88         struct drv_context *drvc;
89         struct dev_context *devc;
90         struct sr_dev_inst *sdi;
91         struct sr_hwopt *opt;
92         struct sr_probe *probe;
93         GSList *devices, *l;
94         const char *conn, *serialcomm;
95
96         devices = NULL;
97         drvc = di->priv;
98         drvc->instances = NULL;
99
100         conn = serialcomm = NULL;
101         for (l = options; l; l = l->next) {
102                 if (!(opt = l->data)) {
103                         sr_err("Invalid option data, skipping.");
104                         continue;
105                 }
106                 switch (opt->hwopt) {
107                 case SR_HWOPT_CONN:
108                         conn = opt->value;
109                         break;
110                 case SR_HWOPT_SERIALCOMM:
111                         serialcomm = opt->value;
112                         break;
113                 default:
114                         sr_err("Unknown option %d, skipping.", opt->hwopt);
115                         break;
116                 }
117         }
118         if (!conn)
119                 return NULL;
120         if (!serialcomm)
121                 serialcomm = SERIALCOMM;
122
123         if (!(sdi = sr_dev_inst_new(0, SR_ST_INACTIVE, "Tondaj",
124                                     "SL-814", NULL))) {
125                 sr_err("Failed to create device instance.");
126                 return NULL;
127         }
128
129         if (!(devc = g_try_malloc0(sizeof(struct dev_context)))) {
130                 sr_err("Device context malloc failed.");
131                 return NULL;
132         }
133
134         if (!(devc->serial = sr_serial_dev_inst_new(conn, serialcomm)))
135                 return NULL;
136
137         if (serial_open(devc->serial, SERIAL_RDWR | SERIAL_NONBLOCK) != SR_OK)
138                 return NULL;
139
140         sdi->priv = devc;
141         sdi->driver = di;
142         probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P1");
143         if (!probe) {
144                 sr_err("Failed to create probe.");
145                 return NULL;
146         }
147         sdi->probes = g_slist_append(sdi->probes, probe);
148         drvc->instances = g_slist_append(drvc->instances, sdi);
149         devices = g_slist_append(devices, sdi);
150
151         return devices;
152 }
153
154 static GSList *hw_dev_list(void)
155 {
156         struct drv_context *drvc;
157
158         drvc = di->priv;
159
160         return drvc->instances;
161 }
162
163 static int hw_dev_open(struct sr_dev_inst *sdi)
164 {
165         struct dev_context *devc;
166
167         devc = sdi->priv;
168
169         if (serial_open(devc->serial, SERIAL_RDWR | SERIAL_NONBLOCK) != SR_OK)
170                 return SR_ERR;
171
172         sdi->status = SR_ST_ACTIVE;
173
174         return SR_OK;
175 }
176
177 static int hw_dev_close(struct sr_dev_inst *sdi)
178 {
179         struct dev_context *devc;
180
181         devc = sdi->priv;
182
183         if (devc->serial && devc->serial->fd != -1) {
184                 serial_close(devc->serial);
185                 sdi->status = SR_ST_INACTIVE;
186         }
187
188         return SR_OK;
189 }
190
191 static int hw_cleanup(void)
192 {
193         clear_instances();
194
195         return SR_OK;
196 }
197
198 static int hw_info_get(int info_id, const void **data,
199                        const struct sr_dev_inst *sdi)
200 {
201         (void)sdi;
202
203         switch (info_id) {
204         case SR_DI_HWOPTS:
205                 *data = hwopts;
206                 break;
207         case SR_DI_HWCAPS:
208                 *data = hwcaps;
209                 break;
210         default:
211                 sr_err("Unknown info_id: %d.", info_id);
212                 return SR_ERR_ARG;
213         }
214
215         return SR_OK;
216 }
217
218 static int hw_dev_config_set(const struct sr_dev_inst *sdi, int hwcap,
219                              const void *value)
220 {
221         struct dev_context *devc;
222
223         if (sdi->status != SR_ST_ACTIVE) {
224                 sr_err("Device inactive, can't set config options.");
225                 return SR_ERR;
226         }
227
228         devc = sdi->priv;
229
230         switch (hwcap) {
231         case SR_HWCAP_LIMIT_SAMPLES:
232                 devc->limit_samples = *(const uint64_t *)value;
233                 sr_dbg("Setting sample limit to %" PRIu64 ".",
234                        devc->limit_samples);
235                 break;
236         default:
237                 sr_err("Unknown hardware capability: %d.", hwcap);
238                 return SR_ERR_ARG;
239         }
240
241         return SR_OK;
242 }
243
244 static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi,
245                                     void *cb_data)
246 {
247         struct sr_datafeed_packet packet;
248         struct sr_datafeed_header header;
249         struct sr_datafeed_meta_analog meta;
250         struct dev_context *devc;
251
252         devc = sdi->priv;
253         devc->cb_data = cb_data;
254
255         /* Send header packet to the session bus. */
256         sr_dbg("Sending SR_DF_HEADER.");
257         packet.type = SR_DF_HEADER;
258         packet.payload = (uint8_t *)&header;
259         header.feed_version = 1;
260         gettimeofday(&header.starttime, NULL);
261         sr_session_send(devc->cb_data, &packet);
262
263         /* Send metadata about the SR_DF_ANALOG packets to come. */
264         sr_dbg("Sending SR_DF_META_ANALOG.");
265         packet.type = SR_DF_META_ANALOG;
266         packet.payload = &meta;
267         meta.num_probes = 1;
268         sr_session_send(devc->cb_data, &packet);
269
270         /* Poll every 500ms, or whenever some data comes in. */
271         sr_source_add(devc->serial->fd, G_IO_IN, 500,
272                       tondaj_sl_814_receive_data, (void *)sdi);
273
274         return SR_OK;
275 }
276
277 static int hw_dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
278 {
279         int ret, final_ret;
280         struct sr_datafeed_packet packet;
281         struct dev_context *devc;
282
283         final_ret = SR_OK;
284
285         if (sdi->status != SR_ST_ACTIVE) {
286                 sr_err("Device inactive, can't stop acquisition.");
287                 return SR_ERR;
288         }
289
290         devc = sdi->priv;
291
292         if ((ret = sr_source_remove(devc->serial->fd)) < 0) {
293                 sr_err("Error removing source: %d.", ret);
294                 final_ret = SR_ERR;
295         }
296         
297         if ((ret = hw_dev_close(sdi)) < 0) {
298                 sr_err("Error closing device: %d.", ret);
299                 final_ret = SR_ERR;
300         }
301
302         /* Send end packet to the session bus. */
303         sr_dbg("Sending SR_DF_END.");
304         packet.type = SR_DF_END;
305         sr_session_send(cb_data, &packet);
306
307         return final_ret;
308 }
309
310 SR_PRIV struct sr_dev_driver tondaj_sl_814_driver_info = {
311         .name = "tondaj-sl-814",
312         .longname = "Tondaj SL-814",
313         .api_version = 1,
314         .init = hw_init,
315         .cleanup = hw_cleanup,
316         .scan = hw_scan,
317         .dev_list = hw_dev_list,
318         .dev_clear = clear_instances,
319         .dev_open = hw_dev_open,
320         .dev_close = hw_dev_close,
321         .info_get = hw_info_get,
322         .dev_config_set = hw_dev_config_set,
323         .dev_acquisition_start = hw_dev_acquisition_start,
324         .dev_acquisition_stop = hw_dev_acquisition_stop,
325         .priv = NULL,
326 };