blob: 9f7b85bf6ada3e3cdf43508ab9b3589daf14325a [file] [log] [blame]
Jonathan Camerone58537c2010-10-08 12:14:14 +01001/* Industrialio buffer test code.
2 *
3 * Copyright (c) 2008 Jonathan Cameron
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 as published by
7 * the Free Software Foundation.
8 *
9 * This program is primarily intended as an example application.
10 * Reads the current buffer setup from sysfs and starts a short capture
11 * from the specified device, pretty printing the result after appropriate
12 * conversion.
13 *
14 * Command line parameters
15 * generic_buffer -n <device_name> -t <trigger_name>
16 * If trigger name is not specified the program assumes you want a dataready
17 * trigger associated with the device and goes looking for it.
18 *
19 */
20
21#include <unistd.h>
Roberta Dobrescubdcb31d2015-02-26 10:49:24 +020022#include <stdlib.h>
Jonathan Camerone58537c2010-10-08 12:14:14 +010023#include <dirent.h>
24#include <fcntl.h>
25#include <stdio.h>
26#include <errno.h>
27#include <sys/stat.h>
28#include <sys/dir.h>
29#include <linux/types.h>
Jonathan Cameron30268a32011-02-11 13:09:12 +000030#include <string.h>
Jonathan Cameron52615d42011-05-18 14:41:19 +010031#include <poll.h>
Jonathan Cameron117cf8b2011-12-04 19:10:59 +000032#include <endian.h>
Peter Meerwaldbb233782012-06-25 23:12:17 +020033#include <getopt.h>
Peter Meerwald1bcdfbc2012-06-25 23:12:16 +020034#include <inttypes.h>
Jonathan Camerone58537c2010-10-08 12:14:14 +010035#include "iio_utils.h"
36
Jonathan Camerone58537c2010-10-08 12:14:14 +010037/**
38 * size_from_channelarray() - calculate the storage size of a scan
Peter Meerwaldd8da0ee2012-06-25 23:12:14 +020039 * @channels: the channel info array
40 * @num_channels: number of channels
Jonathan Camerone58537c2010-10-08 12:14:14 +010041 *
42 * Has the side effect of filling the channels[i].location values used
43 * in processing the buffer output.
44 **/
45int size_from_channelarray(struct iio_channel_info *channels, int num_channels)
46{
47 int bytes = 0;
48 int i = 0;
Melike Yurtogluff39a252014-10-03 23:34:50 +030049
Jonathan Camerone58537c2010-10-08 12:14:14 +010050 while (i < num_channels) {
51 if (bytes % channels[i].bytes == 0)
52 channels[i].location = bytes;
53 else
Hartmut Knaack7663a4a2015-06-10 21:51:20 +020054 channels[i].location = bytes - bytes % channels[i].bytes
55 + channels[i].bytes;
56
Jonathan Camerone58537c2010-10-08 12:14:14 +010057 bytes = channels[i].location + channels[i].bytes;
58 i++;
59 }
Hartmut Knaack7663a4a2015-06-10 21:51:20 +020060
Jonathan Camerone58537c2010-10-08 12:14:14 +010061 return bytes;
62}
63
Tiberiu Breanae8d09272015-07-03 12:57:36 +030064void print1byte(uint8_t input, struct iio_channel_info *info)
65{
66 /*
67 * Shift before conversion to avoid sign extension
68 * of left aligned data
69 */
70 input >>= info->shift;
71 input &= info->mask;
72 if (info->is_signed) {
73 int8_t val = (int8_t)(input << (8 - info->bits_used)) >>
74 (8 - info->bits_used);
75 printf("%05f ", ((float)val + info->offset) * info->scale);
76 } else {
77 printf("%05f ", ((float)input + info->offset) * info->scale);
78 }
79}
80
Hartmut Knaack8e926132015-05-31 14:39:58 +020081void print2byte(uint16_t input, struct iio_channel_info *info)
Jonathan Cameron52615d42011-05-18 14:41:19 +010082{
Jonathan Cameron117cf8b2011-12-04 19:10:59 +000083 /* First swap if incorrect endian */
Jonathan Cameron117cf8b2011-12-04 19:10:59 +000084 if (info->be)
Hartmut Knaack8e926132015-05-31 14:39:58 +020085 input = be16toh(input);
Jonathan Cameron117cf8b2011-12-04 19:10:59 +000086 else
Hartmut Knaack8e926132015-05-31 14:39:58 +020087 input = le16toh(input);
Jonathan Cameron117cf8b2011-12-04 19:10:59 +000088
Peter Meerwaldd8da0ee2012-06-25 23:12:14 +020089 /*
90 * Shift before conversion to avoid sign extension
91 * of left aligned data
92 */
Aya Mahfouz1525ecf2015-02-26 11:45:26 +020093 input >>= info->shift;
Hartmut Knaack8e926132015-05-31 14:39:58 +020094 input &= info->mask;
Jonathan Cameron52615d42011-05-18 14:41:19 +010095 if (info->is_signed) {
Hartmut Knaack8e926132015-05-31 14:39:58 +020096 int16_t val = (int16_t)(input << (16 - info->bits_used)) >>
97 (16 - info->bits_used);
98 printf("%05f ", ((float)val + info->offset) * info->scale);
Jonathan Cameron52615d42011-05-18 14:41:19 +010099 } else {
Hartmut Knaack8e926132015-05-31 14:39:58 +0200100 printf("%05f ", ((float)input + info->offset) * info->scale);
Jonathan Cameron52615d42011-05-18 14:41:19 +0100101 }
102}
Hartmut Knaack8e926132015-05-31 14:39:58 +0200103
104void print4byte(uint32_t input, struct iio_channel_info *info)
105{
106 /* First swap if incorrect endian */
107 if (info->be)
108 input = be32toh(input);
109 else
110 input = le32toh(input);
111
112 /*
113 * Shift before conversion to avoid sign extension
114 * of left aligned data
115 */
116 input >>= info->shift;
117 input &= info->mask;
118 if (info->is_signed) {
119 int32_t val = (int32_t)(input << (32 - info->bits_used)) >>
120 (32 - info->bits_used);
121 printf("%05f ", ((float)val + info->offset) * info->scale);
122 } else {
123 printf("%05f ", ((float)input + info->offset) * info->scale);
124 }
125}
126
127void print8byte(uint64_t input, struct iio_channel_info *info)
128{
129 /* First swap if incorrect endian */
130 if (info->be)
131 input = be64toh(input);
132 else
133 input = le64toh(input);
134
135 /*
136 * Shift before conversion to avoid sign extension
137 * of left aligned data
138 */
139 input >>= info->shift;
140 input &= info->mask;
141 if (info->is_signed) {
142 int64_t val = (int64_t)(input << (64 - info->bits_used)) >>
143 (64 - info->bits_used);
144 /* special case for timestamp */
145 if (info->scale == 1.0f && info->offset == 0.0f)
146 printf("%" PRId64 " ", val);
147 else
148 printf("%05f ",
149 ((float)val + info->offset) * info->scale);
150 } else {
151 printf("%05f ", ((float)input + info->offset) * info->scale);
152 }
153}
154
Jonathan Camerone58537c2010-10-08 12:14:14 +0100155/**
156 * process_scan() - print out the values in SI units
157 * @data: pointer to the start of the scan
Hartmut Knaack7663a4a2015-06-10 21:51:20 +0200158 * @channels: information about the channels.
159 * Note: size_from_channelarray must have been called first
160 * to fill the location offsets.
Peter Meerwaldd8da0ee2012-06-25 23:12:14 +0200161 * @num_channels: number of channels
Jonathan Camerone58537c2010-10-08 12:14:14 +0100162 **/
163void process_scan(char *data,
Peter Meerwaldd8da0ee2012-06-25 23:12:14 +0200164 struct iio_channel_info *channels,
Jonathan Camerone58537c2010-10-08 12:14:14 +0100165 int num_channels)
166{
167 int k;
Melike Yurtogluff39a252014-10-03 23:34:50 +0300168
Jonathan Camerone58537c2010-10-08 12:14:14 +0100169 for (k = 0; k < num_channels; k++)
Peter Meerwaldd8da0ee2012-06-25 23:12:14 +0200170 switch (channels[k].bytes) {
Jonathan Camerone58537c2010-10-08 12:14:14 +0100171 /* only a few cases implemented so far */
Tiberiu Breanae8d09272015-07-03 12:57:36 +0300172 case 1:
173 print1byte(*(uint8_t *)(data + channels[k].location),
174 &channels[k]);
175 break;
Jonathan Camerone58537c2010-10-08 12:14:14 +0100176 case 2:
Peter Meerwaldd8da0ee2012-06-25 23:12:14 +0200177 print2byte(*(uint16_t *)(data + channels[k].location),
178 &channels[k]);
Jonathan Camerone58537c2010-10-08 12:14:14 +0100179 break;
Marek Vasut6cffc1f2012-08-12 16:21:00 +0100180 case 4:
Hartmut Knaack8e926132015-05-31 14:39:58 +0200181 print4byte(*(uint32_t *)(data + channels[k].location),
182 &channels[k]);
Marek Vasut6cffc1f2012-08-12 16:21:00 +0100183 break;
Jonathan Camerone58537c2010-10-08 12:14:14 +0100184 case 8:
Hartmut Knaack8e926132015-05-31 14:39:58 +0200185 print8byte(*(uint64_t *)(data + channels[k].location),
186 &channels[k]);
Jonathan Camerone58537c2010-10-08 12:14:14 +0100187 break;
188 default:
189 break;
190 }
191 printf("\n");
192}
193
Hartmut Knaacke06e3d72015-05-31 14:40:22 +0200194void print_usage(void)
195{
Cristina Opriceanad9abc612015-07-17 18:43:42 +0300196 fprintf(stderr, "Usage: generic_buffer [options]...\n"
197 "Capture, convert and output data from IIO device buffer\n"
198 " -c <n> Do n conversions\n"
199 " -e Disable wait for event (new data)\n"
200 " -g Use trigger-less mode\n"
201 " -l <n> Set buffer length to n samples\n"
202 " -n <name> Set device name (mandatory)\n"
203 " -t <name> Set trigger name\n"
204 " -w <n> Set delay between reads in us (event-less mode)\n");
Hartmut Knaacke06e3d72015-05-31 14:40:22 +0200205}
206
Jonathan Camerone58537c2010-10-08 12:14:14 +0100207int main(int argc, char **argv)
208{
Jonathan Cameron96df9792011-02-11 13:09:13 +0000209 unsigned long num_loops = 2;
210 unsigned long timedelay = 1000000;
211 unsigned long buf_len = 128;
212
Jonathan Camerone58537c2010-10-08 12:14:14 +0100213 int ret, c, i, j, toread;
Jonathan Camerone58537c2010-10-08 12:14:14 +0100214 int fp;
215
216 int num_channels;
217 char *trigger_name = NULL, *device_name = NULL;
218 char *dev_dir_name, *buf_dir_name;
219
220 int datardytrigger = 1;
221 char *data;
Jonathan Cameronc77b3812011-04-15 18:56:00 +0100222 ssize_t read_size;
Jonathan Camerone58537c2010-10-08 12:14:14 +0100223 int dev_num, trig_num;
Jonathan Cameron52615d42011-05-18 14:41:19 +0100224 char *buffer_access;
Jonathan Camerone58537c2010-10-08 12:14:14 +0100225 int scan_size;
Jonathan Cameron30268a32011-02-11 13:09:12 +0000226 int noevents = 0;
Karol Wronab6d5be572014-11-04 15:29:39 +0100227 int notrigger = 0;
Jonathan Cameron96df9792011-02-11 13:09:13 +0000228 char *dummy;
Jonathan Camerone58537c2010-10-08 12:14:14 +0100229
Peter Meerwaldd8da0ee2012-06-25 23:12:14 +0200230 struct iio_channel_info *channels;
Jonathan Camerone58537c2010-10-08 12:14:14 +0100231
Hartmut Knaacke06e3d72015-05-31 14:40:22 +0200232 while ((c = getopt(argc, argv, "c:egl:n:t:w:")) != -1) {
Jonathan Camerone58537c2010-10-08 12:14:14 +0100233 switch (c) {
Jonathan Cameron96df9792011-02-11 13:09:13 +0000234 case 'c':
Hartmut Knaackc8ce9902015-05-31 14:40:03 +0200235 errno = 0;
Jonathan Cameron96df9792011-02-11 13:09:13 +0000236 num_loops = strtoul(optarg, &dummy, 10);
Hartmut Knaackc8ce9902015-05-31 14:40:03 +0200237 if (errno)
238 return -errno;
Hartmut Knaack7663a4a2015-06-10 21:51:20 +0200239
Jonathan Cameron96df9792011-02-11 13:09:13 +0000240 break;
Hartmut Knaacke06e3d72015-05-31 14:40:22 +0200241 case 'e':
242 noevents = 1;
243 break;
244 case 'g':
245 notrigger = 1;
Jonathan Cameron96df9792011-02-11 13:09:13 +0000246 break;
247 case 'l':
Hartmut Knaackc8ce9902015-05-31 14:40:03 +0200248 errno = 0;
Jonathan Cameron96df9792011-02-11 13:09:13 +0000249 buf_len = strtoul(optarg, &dummy, 10);
Hartmut Knaackc8ce9902015-05-31 14:40:03 +0200250 if (errno)
251 return -errno;
Hartmut Knaack7663a4a2015-06-10 21:51:20 +0200252
Jonathan Cameron96df9792011-02-11 13:09:13 +0000253 break;
Hartmut Knaacke06e3d72015-05-31 14:40:22 +0200254 case 'n':
255 device_name = optarg;
256 break;
257 case 't':
258 trigger_name = optarg;
259 datardytrigger = 0;
260 break;
261 case 'w':
262 errno = 0;
263 timedelay = strtoul(optarg, &dummy, 10);
264 if (errno)
265 return -errno;
Karol Wronab6d5be572014-11-04 15:29:39 +0100266 break;
Jonathan Camerone58537c2010-10-08 12:14:14 +0100267 case '?':
Hartmut Knaacke06e3d72015-05-31 14:40:22 +0200268 print_usage();
Jonathan Camerone58537c2010-10-08 12:14:14 +0100269 return -1;
270 }
271 }
272
Cristina Opriceanaff1ac632015-07-13 16:15:56 +0300273 if (!device_name) {
Cristina Opriceanad9abc612015-07-17 18:43:42 +0300274 fprintf(stderr, "Device name not set\n");
Hartmut Knaacke06e3d72015-05-31 14:40:22 +0200275 print_usage();
Michael Hennerich065896e2011-02-24 16:34:50 +0100276 return -1;
Hartmut Knaacke06e3d72015-05-31 14:40:22 +0200277 }
Michael Hennerich065896e2011-02-24 16:34:50 +0100278
Jonathan Camerone58537c2010-10-08 12:14:14 +0100279 /* Find the device requested */
Jonathan Cameron1aa04272011-08-30 12:32:47 +0100280 dev_num = find_type_by_name(device_name, "iio:device");
Jonathan Camerone58537c2010-10-08 12:14:14 +0100281 if (dev_num < 0) {
Cristina Opriceanad9abc612015-07-17 18:43:42 +0300282 fprintf(stderr, "Failed to find the %s\n", device_name);
Hartmut Knaack0e799872015-05-31 14:40:17 +0200283 return dev_num;
Jonathan Camerone58537c2010-10-08 12:14:14 +0100284 }
Hartmut Knaack7663a4a2015-06-10 21:51:20 +0200285
Jonathan Camerone58537c2010-10-08 12:14:14 +0100286 printf("iio device number being used is %d\n", dev_num);
287
Hartmut Knaacke9e45b42015-05-31 14:40:02 +0200288 ret = asprintf(&dev_dir_name, "%siio:device%d", iio_dir, dev_num);
289 if (ret < 0)
290 return -ENOMEM;
Jonathan Camerone58537c2010-10-08 12:14:14 +0100291
Karol Wronab6d5be572014-11-04 15:29:39 +0100292 if (!notrigger) {
Cristina Opriceanaff1ac632015-07-13 16:15:56 +0300293 if (!trigger_name) {
Karol Wronab6d5be572014-11-04 15:29:39 +0100294 /*
295 * Build the trigger name. If it is device associated
296 * its name is <device_name>_dev[n] where n matches
297 * the device number found above.
298 */
299 ret = asprintf(&trigger_name,
300 "%s-dev%d", device_name, dev_num);
301 if (ret < 0) {
302 ret = -ENOMEM;
Hartmut Knaackd3ccfc42015-05-31 14:39:42 +0200303 goto error_free_dev_dir_name;
Karol Wronab6d5be572014-11-04 15:29:39 +0100304 }
305 }
306
307 /* Verify the trigger exists */
308 trig_num = find_type_by_name(trigger_name, "trigger");
309 if (trig_num < 0) {
Cristina Opriceanad9abc612015-07-17 18:43:42 +0300310 fprintf(stderr, "Failed to find the trigger %s\n",
311 trigger_name);
Hartmut Knaacke83a47c2015-05-31 14:39:57 +0200312 ret = trig_num;
Karol Wronab6d5be572014-11-04 15:29:39 +0100313 goto error_free_triggername;
314 }
Hartmut Knaack7663a4a2015-06-10 21:51:20 +0200315
Karol Wronab6d5be572014-11-04 15:29:39 +0100316 printf("iio trigger number being used is %d\n", trig_num);
Hartmut Knaack7663a4a2015-06-10 21:51:20 +0200317 } else {
Karol Wronab6d5be572014-11-04 15:29:39 +0100318 printf("trigger-less mode selected\n");
Hartmut Knaack7663a4a2015-06-10 21:51:20 +0200319 }
Jonathan Camerone58537c2010-10-08 12:14:14 +0100320
321 /*
322 * Parse the files in scan_elements to identify what channels are
323 * present
324 */
Peter Meerwaldd8da0ee2012-06-25 23:12:14 +0200325 ret = build_channel_array(dev_dir_name, &channels, &num_channels);
Jonathan Camerone58537c2010-10-08 12:14:14 +0100326 if (ret) {
Cristina Opriceanad9abc612015-07-17 18:43:42 +0300327 fprintf(stderr, "Problem reading scan element information\n"
328 "diag %s\n", dev_dir_name);
Jonathan Camerone58537c2010-10-08 12:14:14 +0100329 goto error_free_triggername;
330 }
331
332 /*
333 * Construct the directory name for the associated buffer.
334 * As we know that the lis3l02dq has only one buffer this may
335 * be built rather than found.
336 */
Jonathan Cameron1aa04272011-08-30 12:32:47 +0100337 ret = asprintf(&buf_dir_name,
338 "%siio:device%d/buffer", iio_dir, dev_num);
Jonathan Camerone58537c2010-10-08 12:14:14 +0100339 if (ret < 0) {
340 ret = -ENOMEM;
Hartmut Knaack63f05c82015-05-31 14:39:44 +0200341 goto error_free_channels;
Jonathan Camerone58537c2010-10-08 12:14:14 +0100342 }
Karol Wronab6d5be572014-11-04 15:29:39 +0100343
344 if (!notrigger) {
345 printf("%s %s\n", dev_dir_name, trigger_name);
Hartmut Knaack7663a4a2015-06-10 21:51:20 +0200346 /*
347 * Set the device trigger to be the data ready trigger found
348 * above
349 */
Karol Wronab6d5be572014-11-04 15:29:39 +0100350 ret = write_sysfs_string_and_verify("trigger/current_trigger",
351 dev_dir_name,
352 trigger_name);
353 if (ret < 0) {
Cristina Opriceanad9abc612015-07-17 18:43:42 +0300354 fprintf(stderr,
355 "Failed to write current_trigger file\n");
Karol Wronab6d5be572014-11-04 15:29:39 +0100356 goto error_free_buf_dir_name;
357 }
Jonathan Camerone58537c2010-10-08 12:14:14 +0100358 }
359
360 /* Setup ring buffer parameters */
361 ret = write_sysfs_int("length", buf_dir_name, buf_len);
362 if (ret < 0)
363 goto error_free_buf_dir_name;
364
365 /* Enable the buffer */
366 ret = write_sysfs_int("enable", buf_dir_name, 1);
Irina Tirdeae7231492015-07-24 16:28:06 +0300367 if (ret < 0) {
368 fprintf(stderr,
369 "Failed to enable buffer: %s\n", strerror(-ret));
Jonathan Camerone58537c2010-10-08 12:14:14 +0100370 goto error_free_buf_dir_name;
Irina Tirdeae7231492015-07-24 16:28:06 +0300371 }
Hartmut Knaack7663a4a2015-06-10 21:51:20 +0200372
Peter Meerwaldd8da0ee2012-06-25 23:12:14 +0200373 scan_size = size_from_channelarray(channels, num_channels);
Hartmut Knaack7663a4a2015-06-10 21:51:20 +0200374 data = malloc(scan_size * buf_len);
Jonathan Camerone58537c2010-10-08 12:14:14 +0100375 if (!data) {
376 ret = -ENOMEM;
377 goto error_free_buf_dir_name;
378 }
379
Jonathan Cameron1aa04272011-08-30 12:32:47 +0100380 ret = asprintf(&buffer_access, "/dev/iio:device%d", dev_num);
Jonathan Camerone58537c2010-10-08 12:14:14 +0100381 if (ret < 0) {
382 ret = -ENOMEM;
383 goto error_free_data;
384 }
385
Jonathan Camerone58537c2010-10-08 12:14:14 +0100386 /* Attempt to open non blocking the access dev */
387 fp = open(buffer_access, O_RDONLY | O_NONBLOCK);
Hartmut Knaack7663a4a2015-06-10 21:51:20 +0200388 if (fp == -1) { /* TODO: If it isn't there make the node */
Jonathan Camerone58537c2010-10-08 12:14:14 +0100389 ret = -errno;
Cristina Opriceanad9abc612015-07-17 18:43:42 +0300390 fprintf(stderr, "Failed to open %s\n", buffer_access);
Jonathan Cameron52615d42011-05-18 14:41:19 +0100391 goto error_free_buffer_access;
Jonathan Camerone58537c2010-10-08 12:14:14 +0100392 }
393
Jonathan Camerone58537c2010-10-08 12:14:14 +0100394 for (j = 0; j < num_loops; j++) {
Jonathan Cameron30268a32011-02-11 13:09:12 +0000395 if (!noevents) {
Jonathan Cameron52615d42011-05-18 14:41:19 +0100396 struct pollfd pfd = {
397 .fd = fp,
398 .events = POLLIN,
399 };
400
Hartmut Knaack6bb7cac2015-05-31 14:40:04 +0200401 ret = poll(&pfd, 1, -1);
402 if (ret < 0) {
403 ret = -errno;
404 goto error_close_buffer_access;
405 } else if (ret == 0) {
406 continue;
407 }
408
Jonathan Cameron52615d42011-05-18 14:41:19 +0100409 toread = buf_len;
Jonathan Cameron30268a32011-02-11 13:09:12 +0000410 } else {
Jonathan Cameron96df9792011-02-11 13:09:13 +0000411 usleep(timedelay);
Jonathan Cameron30268a32011-02-11 13:09:12 +0000412 toread = 64;
Jonathan Camerone58537c2010-10-08 12:14:14 +0100413 }
Jonathan Cameron30268a32011-02-11 13:09:12 +0000414
Hartmut Knaack7663a4a2015-06-10 21:51:20 +0200415 read_size = read(fp, data, toread * scan_size);
Peter Meerwald97b603a2014-12-06 06:00:00 +0000416 if (read_size < 0) {
Hartmut Knaack87499482015-05-31 14:39:56 +0200417 if (errno == EAGAIN) {
Cristina Opriceanad9abc612015-07-17 18:43:42 +0300418 fprintf(stderr, "nothing available\n");
Peter Meerwald97b603a2014-12-06 06:00:00 +0000419 continue;
Hartmut Knaack7663a4a2015-06-10 21:51:20 +0200420 } else {
Peter Meerwald97b603a2014-12-06 06:00:00 +0000421 break;
Hartmut Knaack7663a4a2015-06-10 21:51:20 +0200422 }
Jonathan Camerone58537c2010-10-08 12:14:14 +0100423 }
Hartmut Knaack7663a4a2015-06-10 21:51:20 +0200424 for (i = 0; i < read_size / scan_size; i++)
425 process_scan(data + scan_size * i, channels,
Jonathan Camerone58537c2010-10-08 12:14:14 +0100426 num_channels);
427 }
428
Peter Meerwaldd8da0ee2012-06-25 23:12:14 +0200429 /* Stop the buffer */
Jonathan Camerone58537c2010-10-08 12:14:14 +0100430 ret = write_sysfs_int("enable", buf_dir_name, 0);
431 if (ret < 0)
Jonathan Cameron52615d42011-05-18 14:41:19 +0100432 goto error_close_buffer_access;
Jonathan Camerone58537c2010-10-08 12:14:14 +0100433
Karol Wronab6d5be572014-11-04 15:29:39 +0100434 if (!notrigger)
435 /* Disconnect the trigger - just write a dummy name. */
Hartmut Knaack6bb7cac2015-05-31 14:40:04 +0200436 ret = write_sysfs_string("trigger/current_trigger",
437 dev_dir_name, "NULL");
438 if (ret < 0)
Cristina Opriceanad9abc612015-07-17 18:43:42 +0300439 fprintf(stderr, "Failed to write to %s\n",
440 dev_dir_name);
Jonathan Camerone58537c2010-10-08 12:14:14 +0100441
Jonathan Camerone58537c2010-10-08 12:14:14 +0100442error_close_buffer_access:
Hartmut Knaack6bb7cac2015-05-31 14:40:04 +0200443 if (close(fp) == -1)
444 perror("Failed to close buffer");
Hartmut Knaack7663a4a2015-06-10 21:51:20 +0200445
Jonathan Camerone58537c2010-10-08 12:14:14 +0100446error_free_buffer_access:
447 free(buffer_access);
Hartmut Knaacka71bfb42015-05-31 14:39:41 +0200448error_free_data:
449 free(data);
Jonathan Camerone58537c2010-10-08 12:14:14 +0100450error_free_buf_dir_name:
451 free(buf_dir_name);
Hartmut Knaack63f05c82015-05-31 14:39:44 +0200452error_free_channels:
453 for (i = num_channels - 1; i >= 0; i--) {
454 free(channels[i].name);
455 free(channels[i].generic_name);
456 }
457 free(channels);
Jonathan Camerone58537c2010-10-08 12:14:14 +0100458error_free_triggername:
459 if (datardytrigger)
460 free(trigger_name);
Hartmut Knaack7663a4a2015-06-10 21:51:20 +0200461
Hartmut Knaackd3ccfc42015-05-31 14:39:42 +0200462error_free_dev_dir_name:
463 free(dev_dir_name);
Hartmut Knaack0e799872015-05-31 14:40:17 +0200464
Jonathan Camerone58537c2010-10-08 12:14:14 +0100465 return ret;
466}