]> sigrok.org Git - libsigrok.git/blame - hwdriver.c
sr: add new driver API call info_get()
[libsigrok.git] / hwdriver.c
CommitLineData
a1bb33af
UH
1/*
2 * This file is part of the sigrok project.
3 *
c73d2ea4 4 * Copyright (C) 2010-2012 Bert Vermeulen <bert@biot.com>
a1bb33af
UH
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 3 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, see <http://www.gnu.org/licenses/>.
18 */
19
20#include <stdlib.h>
21#include <stdio.h>
22#include <sys/types.h>
23#include <dirent.h>
24#include <string.h>
25#include <glib.h>
45c59c8b
BV
26#include "libsigrok.h"
27#include "libsigrok-internal.h"
a1bb33af 28
8bfdc8c4
BV
29
30/* Driver scanning options. */
31SR_API struct sr_hwcap_option sr_drvopts[] = {
b159add3
BV
32 {SR_HWOPT_MODEL, SR_T_KEYVALUE, "Model", "model"},
33 {SR_HWOPT_CONN, SR_T_CHAR, "Connection", "conn"},
34 {SR_HWOPT_SERIALCOMM, SR_T_CHAR, "Serial communication", "serialcomm"},
8bfdc8c4
BV
35 {0, 0, NULL, NULL},
36};
37
38/* Device instance options. */
39SR_API struct sr_hwcap_option sr_hwcap_options[] = {
5a2326a7
UH
40 {SR_HWCAP_SAMPLERATE, SR_T_UINT64, "Sample rate", "samplerate"},
41 {SR_HWCAP_CAPTURE_RATIO, SR_T_UINT64, "Pre-trigger capture ratio", "captureratio"},
eb0a3731 42 {SR_HWCAP_PATTERN_MODE, SR_T_CHAR, "Pattern generator mode", "pattern"},
4d436e71 43 {SR_HWCAP_RLE, SR_T_BOOL, "Run Length Encoding", "rle"},
0fe11789
BV
44 {SR_HWCAP_TRIGGER_SLOPE, SR_T_UINT64, "Trigger slope", "triggerslope"},
45 {SR_HWCAP_TRIGGER_SOURCE, SR_T_CHAR, "Trigger source", "triggersource"},
46 {SR_HWCAP_HORIZ_TRIGGERPOS, SR_T_FLOAT, "Horizontal trigger position",
47 "horiz_triggerpos"},
48 {SR_HWCAP_BUFFERSIZE, SR_T_UINT64, "Buffer size", "buffersize"},
c1e48618 49 {SR_HWCAP_TIMEBASE, SR_T_RATIONAL_PERIOD, "Time base", "timebase"},
3c4976c9 50 {SR_HWCAP_FILTER, SR_T_CHAR, "Filter targets", "filter"},
bd8db307 51 {SR_HWCAP_VDIV, SR_T_RATIONAL_VOLT, "Volts/div", "vdiv"},
e1c8b2ab 52 {SR_HWCAP_COUPLING, SR_T_CHAR, "Coupling", "coupling"},
49d0ce50 53 {0, 0, NULL, NULL},
a1bb33af
UH
54};
55
a61b0e6a 56#ifdef HAVE_LA_DEMO
c09f0b57 57extern SR_PRIV struct sr_dev_driver demo_driver_info;
a61b0e6a 58#endif
960a75e4 59#ifdef HAVE_LA_OLS
c09f0b57 60extern SR_PRIV struct sr_dev_driver ols_driver_info;
960a75e4
UH
61#endif
62#ifdef HAVE_LA_ZEROPLUS_LOGIC_CUBE
c09f0b57 63extern SR_PRIV struct sr_dev_driver zeroplus_logic_cube_driver_info;
960a75e4 64#endif
5b907f9b 65#ifdef HAVE_LA_ASIX_SIGMA
c09f0b57 66extern SR_PRIV struct sr_dev_driver asix_sigma_driver_info;
5b907f9b 67#endif
f4314d7e 68#ifdef HAVE_LA_CHRONOVU_LA8
c09f0b57 69extern SR_PRIV struct sr_dev_driver chronovu_la8_driver_info;
f4314d7e 70#endif
bffed4fc 71#ifdef HAVE_LA_LINK_MSO19
c09f0b57 72extern SR_PRIV struct sr_dev_driver link_mso19_driver_info;
bffed4fc 73#endif
6ed4f044 74#ifdef HAVE_LA_ALSA
c09f0b57 75extern SR_PRIV struct sr_dev_driver alsa_driver_info;
6ed4f044 76#endif
f302a082 77#ifdef HAVE_LA_FX2LAFW
c09f0b57 78extern SR_PRIV struct sr_dev_driver fx2lafw_driver_info;
f302a082 79#endif
3b533202 80#ifdef HAVE_HW_HANTEK_DSO
62bb8840 81extern SR_PRIV struct sr_dev_driver hantek_dso_driver_info;
3b533202 82#endif
ca3d84cc
BV
83#ifdef HAVE_HW_GENERICDMM
84extern SR_PRIV struct sr_dev_driver genericdmm_driver_info;
85#endif
6ed4f044 86
c09f0b57 87static struct sr_dev_driver *drivers_list[] = {
a61b0e6a 88#ifdef HAVE_LA_DEMO
c09f0b57 89 &demo_driver_info,
a61b0e6a 90#endif
960a75e4 91#ifdef HAVE_LA_OLS
c09f0b57 92 &ols_driver_info,
960a75e4
UH
93#endif
94#ifdef HAVE_LA_ZEROPLUS_LOGIC_CUBE
c09f0b57 95 &zeroplus_logic_cube_driver_info,
960a75e4 96#endif
5b907f9b 97#ifdef HAVE_LA_ASIX_SIGMA
c09f0b57 98 &asix_sigma_driver_info,
5b907f9b 99#endif
f4314d7e 100#ifdef HAVE_LA_CHRONOVU_LA8
c09f0b57 101 &chronovu_la8_driver_info,
f4314d7e 102#endif
bffed4fc 103#ifdef HAVE_LA_LINK_MSO19
c09f0b57 104 &link_mso19_driver_info,
bffed4fc 105#endif
6ed4f044 106#ifdef HAVE_LA_ALSA
c09f0b57 107 &alsa_driver_info,
f302a082
JH
108#endif
109#ifdef HAVE_LA_FX2LAFW
c09f0b57 110 &fx2lafw_driver_info,
3b533202
BV
111#endif
112#ifdef HAVE_HW_HANTEK_DSO
62bb8840 113 &hantek_dso_driver_info,
6ed4f044 114#endif
ca3d84cc
BV
115#ifdef HAVE_HW_GENERICDMM
116 &genericdmm_driver_info,
eb1f1eb4 117#endif
050e9219
UH
118 NULL,
119};
a1bb33af 120
a1645fcd 121/**
cfe064d8 122 * Return the list of supported hardware drivers.
a1645fcd 123 *
c09f0b57 124 * @return Pointer to the NULL-terminated list of hardware driver pointers.
a1645fcd 125 */
cfe064d8 126SR_API struct sr_dev_driver **sr_driver_list(void)
a1bb33af 127{
80bf0426 128
c09f0b57 129 return drivers_list;
a1bb33af
UH
130}
131
a1645fcd 132/**
c09f0b57 133 * Initialize a hardware driver.
a1645fcd 134 *
c09f0b57 135 * @param driver The driver to initialize.
a1645fcd 136 *
80bf0426 137 * @return SR_OK if all went well, or an error code otherwise.
a1645fcd 138 */
cfe064d8 139SR_API int sr_driver_init(struct sr_dev_driver *driver)
8722c31e 140{
8722c31e 141
80bf0426
BV
142 if (driver->init)
143 return driver->init();
144
145 return SR_OK;
146}
147
148/**
149 * Tell a hardware driver to scan for devices.
150 *
151 * @param driver The driver.
152 * @param options A list of struct sr_hwopt options to pass to the driver's
153 * scanner.
154 *
155 * @return A GSList * of struct sr_dev_inst, or NULL if no devices were found.
156 * This list must be freed by the caller, but without freeing the data
157 * pointed to in the list.
158 */
159SR_API GSList *sr_driver_scan(struct sr_dev_driver *driver, GSList *options)
160{
161
162 if (driver->scan)
163 return driver->scan(options);
164
165 return NULL;
8722c31e
BV
166}
167
93a04e3b 168SR_PRIV void sr_hw_cleanup_all(void)
8722c31e 169{
050e9219 170 int i;
c09f0b57 171 struct sr_dev_driver **drivers;
8722c31e 172
cfe064d8 173 drivers = sr_driver_list();
c09f0b57
UH
174 for (i = 0; drivers[i]; i++) {
175 if (drivers[i]->cleanup)
176 drivers[i]->cleanup();
8722c31e 177 }
8722c31e
BV
178}
179
d68e2d1a 180SR_PRIV struct sr_dev_inst *sr_dev_inst_new(int index, int status,
49d0ce50 181 const char *vendor, const char *model, const char *version)
a1bb33af 182{
d68e2d1a 183 struct sr_dev_inst *sdi;
a1bb33af 184
d68e2d1a 185 if (!(sdi = g_try_malloc(sizeof(struct sr_dev_inst)))) {
c09f0b57 186 sr_err("hwdriver: %s: sdi malloc failed", __func__);
a1bb33af 187 return NULL;
133a37bf 188 }
a1bb33af
UH
189
190 sdi->index = index;
191 sdi->status = status;
1d9a8a5f 192 sdi->inst_type = -1;
8722c31e
BV
193 sdi->vendor = vendor ? g_strdup(vendor) : NULL;
194 sdi->model = model ? g_strdup(model) : NULL;
195 sdi->version = version ? g_strdup(version) : NULL;
47211d65 196 sdi->probes = NULL;
01cf8814 197 sdi->priv = NULL;
a1bb33af
UH
198
199 return sdi;
200}
201
bb7ef793 202SR_PRIV struct sr_dev_inst *sr_dev_inst_get(GSList *dev_insts, int dev_index)
a1bb33af 203{
d68e2d1a 204 struct sr_dev_inst *sdi;
a1bb33af
UH
205 GSList *l;
206
d68e2d1a
UH
207 for (l = dev_insts; l; l = l->next) {
208 sdi = (struct sr_dev_inst *)(l->data);
bb7ef793 209 if (sdi->index == dev_index)
a1bb33af
UH
210 return sdi;
211 }
bb7ef793 212 sr_warn("could not find device index %d instance", dev_index);
a1bb33af
UH
213
214 return NULL;
215}
216
d68e2d1a 217SR_PRIV void sr_dev_inst_free(struct sr_dev_inst *sdi)
a1bb33af 218{
66410a86 219 g_free(sdi->priv);
8722c31e
BV
220 g_free(sdi->vendor);
221 g_free(sdi->model);
222 g_free(sdi->version);
223 g_free(sdi);
a1bb33af
UH
224}
225
47211d65
BV
226SR_PRIV struct sr_probe *sr_probe_new(int index, int type,
227 gboolean enabled, const char *name)
228{
229 struct sr_probe *probe;
230
231 if (!(probe = g_try_malloc0(sizeof(struct sr_probe)))) {
232 sr_err("hwdriver: probe malloc failed");
233 return NULL;
234 }
235
236 probe->index = index;
237 probe->type = type;
238 probe->enabled = enabled;
239 if (name)
240 probe->name = g_strdup(name);
241
242 return probe;
243}
244
22b02383
UH
245#ifdef HAVE_LIBUSB_1_0
246
d68e2d1a 247SR_PRIV struct sr_usb_dev_inst *sr_usb_dev_inst_new(uint8_t bus,
62c82025 248 uint8_t address, struct libusb_device_handle *hdl)
a1bb33af 249{
d68e2d1a 250 struct sr_usb_dev_inst *udi;
a1bb33af 251
d68e2d1a 252 if (!(udi = g_try_malloc(sizeof(struct sr_usb_dev_inst)))) {
c09f0b57 253 sr_err("hwdriver: %s: udi malloc failed", __func__);
a1bb33af 254 return NULL;
133a37bf 255 }
a1bb33af
UH
256
257 udi->bus = bus;
258 udi->address = address;
ca3d84cc 259 udi->devhdl = hdl;
a1bb33af
UH
260
261 return udi;
262}
263
d68e2d1a 264SR_PRIV void sr_usb_dev_inst_free(struct sr_usb_dev_inst *usb)
a1bb33af 265{
17e1afcb 266 /* Avoid compiler warnings. */
cb93f8a9 267 (void)usb;
a1bb33af 268
62c82025 269 /* Nothing to do for this device instance type. */
a1bb33af
UH
270}
271
22b02383
UH
272#endif
273
d68e2d1a
UH
274SR_PRIV struct sr_serial_dev_inst *sr_serial_dev_inst_new(const char *port,
275 int fd)
a1bb33af 276{
d68e2d1a 277 struct sr_serial_dev_inst *serial;
a1bb33af 278
d68e2d1a 279 if (!(serial = g_try_malloc(sizeof(struct sr_serial_dev_inst)))) {
c09f0b57 280 sr_err("hwdriver: %s: serial malloc failed", __func__);
a1bb33af 281 return NULL;
133a37bf 282 }
a1bb33af 283
133a37bf 284 serial->port = g_strdup(port);
a1bb33af
UH
285 serial->fd = fd;
286
287 return serial;
288}
289
d68e2d1a 290SR_PRIV void sr_serial_dev_inst_free(struct sr_serial_dev_inst *serial)
a1bb33af 291{
133a37bf 292 g_free(serial->port);
a1bb33af
UH
293}
294
a1645fcd 295/**
c09f0b57 296 * Find out if a hardware driver has a specific capability.
a1645fcd 297 *
c09f0b57 298 * @param driver The hardware driver in which to search for the capability.
a1645fcd
BV
299 * @param hwcap The capability to find in the list.
300 *
c496ac97
UH
301 * @return TRUE if the specified capability exists in the specified driver,
302 * FALSE otherwise. Also, if 'driver' is NULL or the respective driver
303 * returns an invalid capability list, FALSE is returned.
a1645fcd 304 */
cfe064d8 305SR_API gboolean sr_driver_hwcap_exists(struct sr_dev_driver *driver, int hwcap)
a1bb33af 306{
915f7cc8
JH
307 const int *hwcaps;
308 int i;
a1bb33af 309
c496ac97
UH
310 if (!driver) {
311 sr_err("hwdriver: %s: driver was NULL", __func__);
312 return FALSE;
313 }
314
315 if (!(hwcaps = driver->hwcap_get_all())) {
316 sr_err("hwdriver: %s: hwcap_get_all() returned NULL", __func__);
317 return FALSE;
318 }
319
ffedd0bf
UH
320 for (i = 0; hwcaps[i]; i++) {
321 if (hwcaps[i] == hwcap)
a1bb33af 322 return TRUE;
49d0ce50 323 }
a1bb33af
UH
324
325 return FALSE;
326}
327
8bfdc8c4
BV
328/**
329 * Get a hardware driver option.
330 *
331 * @param hwopt The option to get.
332 *
333 * @return A pointer to a struct with information about the parameter, or NULL
334 * if the option was not found.
335 */
336SR_API const struct sr_hwcap_option *sr_drvopt_get(int hwopt)
337{
338 int i;
339
340 for (i = 0; sr_drvopts[i].hwcap; i++) {
341 if (sr_drvopts[i].hwcap == hwopt)
342 return &sr_drvopts[i];
343 }
344
345 return NULL;
346}
347
a1645fcd 348/**
c09f0b57 349 * Get a hardware driver capability option.
a1645fcd 350 *
93a04e3b 351 * @param hwcap The capability to get.
a1645fcd 352 *
44dae539
UH
353 * @return A pointer to a struct with information about the parameter, or NULL
354 * if the capability was not found.
a1645fcd 355 */
915f7cc8 356SR_API const struct sr_hwcap_option *sr_hw_hwcap_get(int hwcap)
a1bb33af 357{
a1bb33af
UH
358 int i;
359
ffedd0bf
UH
360 for (i = 0; sr_hwcap_options[i].hwcap; i++) {
361 if (sr_hwcap_options[i].hwcap == hwcap)
a65de030 362 return &sr_hwcap_options[i];
a1bb33af
UH
363 }
364
49d0ce50 365 return NULL;
a1bb33af
UH
366}
367
69cfcfc8 368/* Unnecessary level of indirection follows. */
544a4582 369
69cfcfc8 370SR_PRIV int sr_source_remove(int fd)
a1bb33af 371{
69cfcfc8 372 return sr_session_source_remove(fd);
a1bb33af
UH
373}
374
69cfcfc8
UH
375SR_PRIV int sr_source_add(int fd, int events, int timeout,
376 sr_receive_data_callback_t cb, void *cb_data)
a1bb33af 377{
69cfcfc8 378 return sr_session_source_add(fd, events, timeout, cb, cb_data);
a1bb33af 379}