Merge tag 'staging-4.2-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging

Pull staging driver updates from Greg KH:
 "Here's the big, really big, staging tree patches for 4.2-rc1.

  Loads of stuff in here, almost all just coding style fixes / churn,
  and a few new drivers as well, one of which I just disabled from the
  build a few minutes ago due to way too many build warnings.

  Other than the one "disable this driver" patch, all of these have been
  in linux-next for quite a while with no reported issues"

* tag 'staging-4.2-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging: (1163 commits)
  staging: wilc1000: disable driver due to build warnings
  Staging: rts5208: fix CHANGE_LINK_STATE value
  Staging: sm750fb: ddk750_swi2c.c: Insert spaces before parenthesis
  Staging: sm750fb: ddk750_swi2c.c: Place braces on correct lines
  Staging: sm750fb: ddk750_swi2c.c: Insert spaces around operators
  Staging: sm750fb: ddk750_swi2c.c: Replace spaces with tabs
  Staging: sm750fb: ddk750_swi2c.h: Shorten lines to under 80 characters
  Staging: sm750fb: ddk750_swi2c.h: Replace spaces with tabs
  Staging: sm750fb: modedb.h: Shorten lines to under 80 characters
  Staging: sm750fb: modedb.h: Replace spaces with tabs
  staging: comedi: addi_apci_3120: rename 'this_board' variables
  staging: comedi: addi_apci_1516: rename 'this_board' variables
  staging: comedi: ni_atmio: cleanup ni_getboardtype()
  staging: comedi: vmk80xx: sanity check context used to get the boardinfo
  staging: comedi: vmk80xx: rename 'boardinfo' variables
  staging: comedi: dt3000: rename 'this_board' variables
  staging: comedi: adv_pci_dio: rename 'this_board' variables
  staging: comedi: cb_pcidas64: rename 'thisboard' variables
  staging: comedi: cb_pcidas: rename 'thisboard' variables
  staging: comedi: me4000: rename 'thisboard' variables
  ...

7 files changed, 610 insertions, 204 deletions

diff --git a/tools/Makefile b/tools/Makefile
index b113078fb7ad..d6f307dfb1a3 100644
--- a/tools/Makefile
+++ b/tools/Makefile
@@ -13,6 +13,7 @@ help:
         @echo '  cpupower   - a tool for all things x86 CPU power'
         @echo '  firewire   - the userspace part of nosy, an IEEE-1394 traffic sniffer'
         @echo '  hv         - tools used when in Hyper-V clients'
+        @echo '  iio        - IIO tools'
         @echo '  lguest     - a minimal 32-bit x86 hypervisor'
         @echo '  perf       - Linux performance measurement and analysis tool'
         @echo '  selftests  - various kernel selftests'
@@ -47,7 +48,7 @@ acpi: FORCE
 cpupower: FORCE
         $(call descend,power/$@)
 
-cgroup firewire hv guest usb virtio vm net: FORCE
+cgroup firewire hv guest usb virtio vm net iio: FORCE
         $(call descend,$@)
 
 liblockdep: FORCE
@@ -108,7 +109,7 @@ acpi_clean:
 cpupower_clean:
         $(call descend,power/cpupower,clean)
 
-cgroup_clean hv_clean firewire_clean lguest_clean usb_clean virtio_clean vm_clean net_clean:
+cgroup_clean hv_clean firewire_clean lguest_clean usb_clean virtio_clean vm_clean net_clean iio_clean:
         $(call descend,$(@:_clean=),clean)
 
 liblockdep_clean:
@@ -134,6 +135,7 @@ freefall_clean:
 
 clean: acpi_clean cgroup_clean cpupower_clean hv_clean firewire_clean lguest_clean \
                 perf_clean selftests_clean turbostat_clean usb_clean virtio_clean \
-                vm_clean net_clean x86_energy_perf_policy_clean tmon_clean freefall_clean
+                vm_clean net_clean iio_clean x86_energy_perf_policy_clean tmon_clean \
+                freefall_clean
 
 .PHONY: FORCE
diff --git a/tools/iio/Makefile b/tools/iio/Makefile
index bf7ae6d6612a..3a7a54f59713 100644
--- a/tools/iio/Makefile
+++ b/tools/iio/Makefile
@@ -1,5 +1,5 @@
-CC = gcc
-CFLAGS = -Wall -g -D_GNU_SOURCE
+CC = $(CROSS_COMPILE)gcc
+CFLAGS += -Wall -g -D_GNU_SOURCE
 
 all: iio_event_monitor lsiio generic_buffer
 
diff --git a/tools/iio/generic_buffer.c b/tools/iio/generic_buffer.c
index f805493be3eb..4eebb6616e5c 100644
--- a/tools/iio/generic_buffer.c
+++ b/tools/iio/generic_buffer.c
@@ -59,33 +59,80 @@ int size_from_channelarray(struct iio_channel_info *channels, int num_channels)
         return bytes;
 }
 
-void print2byte(int input, struct iio_channel_info *info)
+void print2byte(uint16_t input, struct iio_channel_info *info)
 {
         /* First swap if incorrect endian */
         if (info->be)
-                input = be16toh((uint16_t)input);
+                input = be16toh(input);
         else
-                input = le16toh((uint16_t)input);
+                input = le16toh(input);
 
         /*
          * Shift before conversion to avoid sign extension
          * of left aligned data
          */
         input >>= info->shift;
+        input &= info->mask;
         if (info->is_signed) {
-                int16_t val = input;
+                int16_t val = (int16_t)(input << (16 - info->bits_used)) >>
+                              (16 - info->bits_used);
+                printf("%05f ", ((float)val + info->offset) * info->scale);
+        } else {
+                printf("%05f ", ((float)input + info->offset) * info->scale);
+        }
+}
+
+void print4byte(uint32_t input, struct iio_channel_info *info)
+{
+        /* First swap if incorrect endian */
+        if (info->be)
+                input = be32toh(input);
+        else
+                input = le32toh(input);
 
-                val &= (1 << info->bits_used) - 1;
-                val = (int16_t)(val << (16 - info->bits_used)) >>
-                        (16 - info->bits_used);
-                printf("%05f ", ((float)val + info->offset)*info->scale);
+        /*
+         * Shift before conversion to avoid sign extension
+         * of left aligned data
+         */
+        input >>= info->shift;
+        input &= info->mask;
+        if (info->is_signed) {
+                int32_t val = (int32_t)(input << (32 - info->bits_used)) >>
+                              (32 - info->bits_used);
+                printf("%05f ", ((float)val + info->offset) * info->scale);
         } else {
-                uint16_t val = input;
+                printf("%05f ", ((float)input + info->offset) * info->scale);
+        }
+}
 
-                val &= (1 << info->bits_used) - 1;
-                printf("%05f ", ((float)val + info->offset)*info->scale);
+void print8byte(uint64_t input, struct iio_channel_info *info)
+{
+        /* First swap if incorrect endian */
+        if (info->be)
+                input = be64toh(input);
+        else
+                input = le64toh(input);
+
+        /*
+         * Shift before conversion to avoid sign extension
+         * of left aligned data
+         */
+        input >>= info->shift;
+        input &= info->mask;
+        if (info->is_signed) {
+                int64_t val = (int64_t)(input << (64 - info->bits_used)) >>
+                              (64 - info->bits_used);
+                /* special case for timestamp */
+                if (info->scale == 1.0f && info->offset == 0.0f)
+                        printf("%" PRId64 " ", val);
+                else
+                        printf("%05f ",
+                               ((float)val + info->offset) * info->scale);
+        } else {
+                printf("%05f ", ((float)input + info->offset) * info->scale);
         }
 }
+
 /**
  * process_scan() - print out the values in SI units
  * @data:               pointer to the start of the scan
@@ -108,32 +155,12 @@ void process_scan(char *data,
                                    &channels[k]);
                         break;
                 case 4:
-                        if (!channels[k].is_signed) {
-                                uint32_t val = *(uint32_t *)
-                                        (data + channels[k].location);
-                                printf("%05f ", ((float)val +
-                                                 channels[k].offset)*
-                                       channels[k].scale);
-
-                        }
+                        print4byte(*(uint32_t *)(data + channels[k].location),
+                                   &channels[k]);
                         break;
                 case 8:
-                        if (channels[k].is_signed) {
-                                int64_t val = *(int64_t *)
-                                        (data +
-                                         channels[k].location);
-                                if ((val >> channels[k].bits_used) & 1)
-                                        val = (val & channels[k].mask) |
-                                                ~channels[k].mask;
-                                /* special case for timestamp */
-                                if (channels[k].scale == 1.0f &&
-                                    channels[k].offset == 0.0f)
-                                        printf("%" PRId64 " ", val);
-                                else
-                                        printf("%05f ", ((float)val +
-                                                         channels[k].offset)*
-                                               channels[k].scale);
-                        }
+                        print8byte(*(uint64_t *)(data + channels[k].location),
+                                   &channels[k]);
                         break;
                 default:
                         break;
@@ -141,6 +168,19 @@ void process_scan(char *data,
         printf("\n");
 }
 
+void print_usage(void)
+{
+        printf("Usage: generic_buffer [options]...\n"
+               "Capture, convert and output data from IIO device buffer\n"
+               "  -c <n>     Do n conversions\n"
+               "  -e         Disable wait for event (new data)\n"
+               "  -g         Use trigger-less mode\n"
+               "  -l <n>     Set buffer length to n samples\n"
+               "  -n <name>  Set device name (mandatory)\n"
+               "  -t <name>  Set trigger name\n"
+               "  -w <n>     Set delay between reads in us (event-less mode)\n");
+}
+
 int main(int argc, char **argv)
 {
         unsigned long num_loops = 2;
@@ -166,8 +206,26 @@ int main(int argc, char **argv)
 
         struct iio_channel_info *channels;
 
-        while ((c = getopt(argc, argv, "l:w:c:et:n:g")) != -1) {
+        while ((c = getopt(argc, argv, "c:egl:n:t:w:")) != -1) {
                 switch (c) {
+                case 'c':
+                        errno = 0;
+                        num_loops = strtoul(optarg, &dummy, 10);
+                        if (errno)
+                                return -errno;
+                        break;
+                case 'e':
+                        noevents = 1;
+                        break;
+                case 'g':
+                        notrigger = 1;
+                        break;
+                case 'l':
+                        errno = 0;
+                        buf_len = strtoul(optarg, &dummy, 10);
+                        if (errno)
+                                return -errno;
+                        break;
                 case 'n':
                         device_name = optarg;
                         break;
@@ -175,39 +233,35 @@ int main(int argc, char **argv)
                         trigger_name = optarg;
                         datardytrigger = 0;
                         break;
-                case 'e':
-                        noevents = 1;
-                        break;
-                case 'c':
-                        num_loops = strtoul(optarg, &dummy, 10);
-                        break;
                 case 'w':
+                        errno = 0;
                         timedelay = strtoul(optarg, &dummy, 10);
-                        break;
-                case 'l':
-                        buf_len = strtoul(optarg, &dummy, 10);
-                        break;
-                case 'g':
-                        notrigger = 1;
+                        if (errno)
+                                return -errno;
                         break;
                 case '?':
+                        print_usage();
                         return -1;
                 }
         }
 
-        if (device_name == NULL)
+        if (device_name == NULL) {
+                printf("Device name not set\n");
+                print_usage();
                 return -1;
+        }
 
         /* Find the device requested */
         dev_num = find_type_by_name(device_name, "iio:device");
         if (dev_num < 0) {
                 printf("Failed to find the %s\n", device_name);
-                ret = -ENODEV;
-                goto error_ret;
+                return dev_num;
         }
         printf("iio device number being used is %d\n", dev_num);
 
-        asprintf(&dev_dir_name, "%siio:device%d", iio_dir, dev_num);
+        ret = asprintf(&dev_dir_name, "%siio:device%d", iio_dir, dev_num);
+        if (ret < 0)
+                return -ENOMEM;
 
         if (!notrigger) {
                 if (trigger_name == NULL) {
@@ -220,7 +274,7 @@ int main(int argc, char **argv)
                                        "%s-dev%d", device_name, dev_num);
                         if (ret < 0) {
                                 ret = -ENOMEM;
-                                goto error_ret;
+                                goto error_free_dev_dir_name;
                         }
                 }
 
@@ -228,7 +282,7 @@ int main(int argc, char **argv)
                 trig_num = find_type_by_name(trigger_name, "trigger");
                 if (trig_num < 0) {
                         printf("Failed to find the trigger %s\n", trigger_name);
-                        ret = -ENODEV;
+                        ret = trig_num;
                         goto error_free_triggername;
                 }
                 printf("iio trigger number being used is %d\n", trig_num);
@@ -255,7 +309,7 @@ int main(int argc, char **argv)
                        "%siio:device%d/buffer", iio_dir, dev_num);
         if (ret < 0) {
                 ret = -ENOMEM;
-                goto error_free_triggername;
+                goto error_free_channels;
         }
 
         if (!notrigger) {
@@ -296,8 +350,8 @@ int main(int argc, char **argv)
         /* Attempt to open non blocking the access dev */
         fp = open(buffer_access, O_RDONLY | O_NONBLOCK);
         if (fp == -1) { /* If it isn't there make the node */
-                printf("Failed to open %s\n", buffer_access);
                 ret = -errno;
+                printf("Failed to open %s\n", buffer_access);
                 goto error_free_buffer_access;
         }
 
@@ -309,7 +363,14 @@ int main(int argc, char **argv)
                                 .events = POLLIN,
                         };
 
-                        poll(&pfd, 1, -1);
+                        ret = poll(&pfd, 1, -1);
+                        if (ret < 0) {
+                                ret = -errno;
+                                goto error_close_buffer_access;
+                        } else if (ret == 0) {
+                                continue;
+                        }
+
                         toread = buf_len;
 
                 } else {
@@ -321,7 +382,7 @@ int main(int argc, char **argv)
                                  data,
                                  toread*scan_size);
                 if (read_size < 0) {
-                        if (errno == -EAGAIN) {
+                        if (errno == EAGAIN) {
                                 printf("nothing available\n");
                                 continue;
                         } else
@@ -340,20 +401,31 @@ int main(int argc, char **argv)
 
         if (!notrigger)
                 /* Disconnect the trigger - just write a dummy name. */
-                write_sysfs_string("trigger/current_trigger",
-                                   dev_dir_name, "NULL");
+                ret = write_sysfs_string("trigger/current_trigger",
+                                         dev_dir_name, "NULL");
+                if (ret < 0)
+                        printf("Failed to write to %s\n", dev_dir_name);
 
 error_close_buffer_access:
-        close(fp);
-error_free_data:
-        free(data);
+        if (close(fp) == -1)
+                perror("Failed to close buffer");
 error_free_buffer_access:
         free(buffer_access);
+error_free_data:
+        free(data);
 error_free_buf_dir_name:
         free(buf_dir_name);
+error_free_channels:
+        for (i = num_channels - 1; i >= 0; i--) {
+                free(channels[i].name);
+                free(channels[i].generic_name);
+        }
+        free(channels);
 error_free_triggername:
         if (datardytrigger)
                 free(trigger_name);
-error_ret:
+error_free_dev_dir_name:
+        free(dev_dir_name);
+
         return ret;
 }
diff --git a/tools/iio/iio_event_monitor.c b/tools/iio/iio_event_monitor.c
index 427c271ac0d6..016760e769c0 100644
--- a/tools/iio/iio_event_monitor.c
+++ b/tools/iio/iio_event_monitor.c
@@ -213,23 +213,19 @@ static void print_event(struct iio_event_data *event)
                 return;
         }
 
-        printf("Event: time: %lld, ", event->timestamp);
+        printf("Event: time: %lld, type: %s", event->timestamp,
+               iio_chan_type_name_spec[type]);
 
-        if (mod != IIO_NO_MOD) {
-                printf("type: %s(%s), ",
-                        iio_chan_type_name_spec[type],
-                        iio_modifier_names[mod]);
-        } else {
-                printf("type: %s, ",
-                        iio_chan_type_name_spec[type]);
-        }
+        if (mod != IIO_NO_MOD)
+                printf("(%s)", iio_modifier_names[mod]);
 
-        if (diff && chan >= 0 && chan2 >= 0)
-                printf("channel: %d-%d, ", chan, chan2);
-        else if (chan >= 0)
-                printf("channel: %d, ", chan);
+        if (chan >= 0) {
+                printf(", channel: %d", chan);
+                if (diff && chan2 >= 0)
+                        printf("-%d", chan2);
+        }
 
-        printf("evtype: %s", iio_ev_type_text[ev_type]);
+        printf(", evtype: %s", iio_ev_type_text[ev_type]);
 
         if (dir != IIO_EV_DIR_NONE)
                 printf(", direction: %s", iio_ev_dir_text[dir]);
@@ -258,28 +254,34 @@ int main(int argc, char **argv)
                         device_name, dev_num);
                 ret = asprintf(&chrdev_name, "/dev/iio:device%d", dev_num);
                 if (ret < 0) {
-                        ret = -ENOMEM;
-                        goto error_ret;
+                        return -ENOMEM;
                 }
         } else {
                 /* If we can't find a IIO device by name assume device_name is a
                    IIO chrdev */
                 chrdev_name = strdup(device_name);
+                if (!chrdev_name)
+                        return -ENOMEM;
         }
 
         fd = open(chrdev_name, 0);
         if (fd == -1) {
-                fprintf(stdout, "Failed to open %s\n", chrdev_name);
                 ret = -errno;
+                fprintf(stdout, "Failed to open %s\n", chrdev_name);
                 goto error_free_chrdev_name;
         }
 
         ret = ioctl(fd, IIO_GET_EVENT_FD_IOCTL, &event_fd);
-
-        close(fd);
-
         if (ret == -1 || event_fd == -1) {
+                ret = -errno;
                 fprintf(stdout, "Failed to retrieve event fd\n");
+                if (close(fd) == -1)
+                        perror("Failed to close character device file");
+
+                goto error_free_chrdev_name;
+        }
+
+        if (close(fd) == -1)  {
                 ret = -errno;
                 goto error_free_chrdev_name;
         }
@@ -291,8 +293,8 @@ int main(int argc, char **argv)
                                 printf("nothing available\n");
                                 continue;
                         } else {
-                                perror("Failed to read event from device");
                                 ret = -errno;
+                                perror("Failed to read event from device");
                                 break;
                         }
                 }
@@ -300,9 +302,11 @@ int main(int argc, char **argv)
                 print_event(&event);
         }
 
-        close(event_fd);
+        if (close(event_fd) == -1)
+                perror("Failed to close event file");
+
 error_free_chrdev_name:
         free(chrdev_name);
-error_ret:
+
         return ret;
 }
diff --git a/tools/iio/iio_utils.c b/tools/iio/iio_utils.c
index 6f6452167b67..ec9ab7f9ae4c 100644
--- a/tools/iio/iio_utils.c
+++ b/tools/iio/iio_utils.c
@@ -29,6 +29,8 @@ static char * const iio_direction[] = {
  * iioutils_break_up_name() - extract generic name from full channel name
  * @full_name: the full channel name
  * @generic_name: the output generic channel name
+ *
+ * Returns 0 on success, or a negative error code if string extraction failed.
  **/
 int iioutils_break_up_name(const char *full_name,
                                   char **generic_name)
@@ -36,7 +38,7 @@ int iioutils_break_up_name(const char *full_name,
         char *current;
         char *w, *r;
         char *working, *prefix = "";
-        int i;
+        int i, ret;
 
         for (i = 0; i < sizeof(iio_direction) / sizeof(iio_direction[0]); i++)
                 if (!strncmp(full_name, iio_direction[i],
@@ -46,7 +48,14 @@ int iioutils_break_up_name(const char *full_name,
                 }
 
         current = strdup(full_name + strlen(prefix) + 1);
+        if (!current)
+                return -ENOMEM;
+
         working = strtok(current, "_\0");
+        if (!working) {
+                free(current);
+                return -EINVAL;
+        }
 
         w = working;
         r = working;
@@ -59,21 +68,25 @@ int iioutils_break_up_name(const char *full_name,
                 r++;
         }
         *w = '\0';
-        asprintf(generic_name, "%s_%s", prefix, working);
+        ret = asprintf(generic_name, "%s_%s", prefix, working);
         free(current);
 
-        return 0;
+        return (ret == -1) ? -ENOMEM : 0;
 }
 
 /**
  * iioutils_get_type() - find and process _type attribute data
  * @is_signed: output whether channel is signed
  * @bytes: output how many bytes the channel storage occupies
+ * @bits_used: output number of valid bits of data
+ * @shift: output amount of bits to shift right data before applying bit mask
  * @mask: output a bit mask for the raw data
- * @be: big endian
- * @device_dir: the iio device directory
+ * @be: output if data in big endian
+ * @device_dir: the IIO device directory
  * @name: the channel name
  * @generic_name: the channel type name
+ *
+ * Returns a value >= 0 on success, otherwise a negative error code.
  **/
 int iioutils_get_type(unsigned *is_signed,
                              unsigned *bytes,
@@ -94,10 +107,9 @@ int iioutils_get_type(unsigned *is_signed,
         const struct dirent *ent;
 
         ret = asprintf(&scan_el_dir, FORMAT_SCAN_ELEMENTS_DIR, device_dir);
-        if (ret < 0) {
-                ret = -ENOMEM;
-                goto error_ret;
-        }
+        if (ret < 0)
+                return -ENOMEM;
+
         ret = asprintf(&builtname, FORMAT_TYPE_FILE, name);
         if (ret < 0) {
                 ret = -ENOMEM;
@@ -114,6 +126,7 @@ int iioutils_get_type(unsigned *is_signed,
                 ret = -errno;
                 goto error_free_builtname_generic;
         }
+        ret = -ENOENT;
         while (ent = readdir(dp), ent != NULL)
                 /*
                  * Do we allow devices to override a generic name with
@@ -129,8 +142,8 @@ int iioutils_get_type(unsigned *is_signed,
                         }
                         sysfsfp = fopen(filename, "r");
                         if (sysfsfp == NULL) {
-                                printf("failed to open %s\n", filename);
                                 ret = -errno;
+                                printf("failed to open %s\n", filename);
                                 goto error_free_filename;
                         }
 
@@ -141,8 +154,12 @@ int iioutils_get_type(unsigned *is_signed,
                                      bits_used,
                                      &padint, shift);
                         if (ret < 0) {
-                                printf("failed to pass scan type description\n");
                                 ret = -errno;
+                                printf("failed to pass scan type description\n");
+                                goto error_close_sysfsfp;
+                        } else if (ret != 5) {
+                                ret = -EIO;
+                                printf("scan type description didn't match\n");
                                 goto error_close_sysfsfp;
                         }
                         *be = (endianchar == 'b');
@@ -151,34 +168,50 @@ int iioutils_get_type(unsigned *is_signed,
                                 *mask = ~0;
                         else
                                 *mask = (1 << *bits_used) - 1;
-                        if (signchar == 's')
-                                *is_signed = 1;
-                        else
-                                *is_signed = 0;
-                        fclose(sysfsfp);
+                        *is_signed = (signchar == 's');
+                        if (fclose(sysfsfp)) {
+                                ret = -errno;
+                                printf("Failed to close %s\n", filename);
+                                goto error_free_filename;
+                        }
+
+                        sysfsfp = 0;
                         free(filename);
 
                         filename = 0;
-                        sysfsfp = 0;
                 }
 error_close_sysfsfp:
         if (sysfsfp)
-                fclose(sysfsfp);
+                if (fclose(sysfsfp))
+                        perror("iioutils_get_type(): Failed to close file");
+
 error_free_filename:
         if (filename)
                 free(filename);
 error_closedir:
-        closedir(dp);
+        if (closedir(dp) == -1)
+                perror("iioutils_get_type(): Failed to close directory");
+
 error_free_builtname_generic:
         free(builtname_generic);
 error_free_builtname:
         free(builtname);
 error_free_scan_el_dir:
         free(scan_el_dir);
-error_ret:
+
         return ret;
 }
 
+/**
+ * iioutils_get_param_float() - read a float value from a channel parameter
+ * @output: output the float value
+ * @param_name: the parameter name to read
+ * @device_dir: the IIO device directory in sysfs
+ * @name: the channel name
+ * @generic_name: the channel type name
+ *
+ * Returns a value >= 0 on success, otherwise a negative error code.
+ **/
 int iioutils_get_param_float(float *output,
                                     const char *param_name,
                                     const char *device_dir,
@@ -193,10 +226,9 @@ int iioutils_get_param_float(float *output,
         const struct dirent *ent;
 
         ret = asprintf(&builtname, "%s_%s", name, param_name);
-        if (ret < 0) {
-                ret = -ENOMEM;
-                goto error_ret;
-        }
+        if (ret < 0)
+                return -ENOMEM;
+
         ret = asprintf(&builtname_generic,
                        "%s_%s", generic_name, param_name);
         if (ret < 0) {
@@ -208,6 +240,7 @@ int iioutils_get_param_float(float *output,
                 ret = -errno;
                 goto error_free_builtname_generic;
         }
+        ret = -ENOENT;
         while (ent = readdir(dp), ent != NULL)
                 if ((strcmp(builtname, ent->d_name) == 0) ||
                     (strcmp(builtname_generic, ent->d_name) == 0)) {
@@ -222,25 +255,31 @@ int iioutils_get_param_float(float *output,
                                 ret = -errno;
                                 goto error_free_filename;
                         }
-                        fscanf(sysfsfp, "%f", output);
+                        errno = 0;
+                        if (fscanf(sysfsfp, "%f", output) != 1)
+                                ret = errno ? -errno : -ENODATA;
+
                         break;
                 }
 error_free_filename:
         if (filename)
                 free(filename);
 error_closedir:
-        closedir(dp);
+        if (closedir(dp) == -1)
+                perror("iioutils_get_param_float(): Failed to close directory");
+
 error_free_builtname_generic:
         free(builtname_generic);
 error_free_builtname:
         free(builtname);
-error_ret:
+
         return ret;
 }
 
 /**
- * bsort_channel_array_by_index() - reorder so that the array is in index order
- *
+ * bsort_channel_array_by_index() - sort the array in index order
+ * @ci_array: the iio_channel_info array to be sorted
+ * @cnt: the amount of array elements
  **/
 
 void bsort_channel_array_by_index(struct iio_channel_info **ci_array,
@@ -262,7 +301,10 @@ void bsort_channel_array_by_index(struct iio_channel_info **ci_array,
 /**
  * build_channel_array() - function to figure out what channels are present
  * @device_dir: the IIO device directory in sysfs
- * @
+ * @ci_array: output the resulting array of iio_channel_info
+ * @counter: output the amount of array elements
+ *
+ * Returns 0 on success, otherwise a negative error code.
  **/
 int build_channel_array(const char *device_dir,
                               struct iio_channel_info **ci_array,
@@ -270,7 +312,7 @@ int build_channel_array(const char *device_dir,
 {
         DIR *dp;
         FILE *sysfsfp;
-        int count, i;
+        int count = 0, i;
         struct iio_channel_info *current;
         int ret;
         const struct dirent *ent;
@@ -279,10 +321,9 @@ int build_channel_array(const char *device_dir,
 
         *counter = 0;
         ret = asprintf(&scan_el_dir, FORMAT_SCAN_ELEMENTS_DIR, device_dir);
-        if (ret < 0) {
-                ret = -ENOMEM;
-                goto error_ret;
-        }
+        if (ret < 0)
+                return -ENOMEM;
+
         dp = opendir(scan_el_dir);
         if (dp == NULL) {
                 ret = -errno;
@@ -303,10 +344,24 @@ int build_channel_array(const char *device_dir,
                                 free(filename);
                                 goto error_close_dir;
                         }
-                        fscanf(sysfsfp, "%i", &ret);
+                        errno = 0;
+                        if (fscanf(sysfsfp, "%i", &ret) != 1) {
+                                ret = errno ? -errno : -ENODATA;
+                                if (fclose(sysfsfp))
+                                        perror("build_channel_array(): Failed to close file");
+
+                                free(filename);
+                                goto error_close_dir;
+                        }
+
                         if (ret == 1)
                                 (*counter)++;
-                        fclose(sysfsfp);
+                        if (fclose(sysfsfp)) {
+                                ret = -errno;
+                                free(filename);
+                                goto error_close_dir;
+                        }
+
                         free(filename);
                 }
         *ci_array = malloc(sizeof(**ci_array) * (*counter));
@@ -315,7 +370,6 @@ int build_channel_array(const char *device_dir,
                 goto error_close_dir;
         }
         seekdir(dp, 0);
-        count = 0;
         while (ent = readdir(dp), ent != NULL) {
                 if (strcmp(ent->d_name + strlen(ent->d_name) - strlen("_en"),
                            "_en") == 0) {
@@ -332,12 +386,25 @@ int build_channel_array(const char *device_dir,
                         }
                         sysfsfp = fopen(filename, "r");
                         if (sysfsfp == NULL) {
+                                ret = -errno;
                                 free(filename);
+                                count--;
+                                goto error_cleanup_array;
+                        }
+                        errno = 0;
+                        if (fscanf(sysfsfp, "%i", &current_enabled) != 1) {
+                                ret = errno ? -errno : -ENODATA;
+                                free(filename);
+                                count--;
+                                goto error_cleanup_array;
+                        }
+
+                        if (fclose(sysfsfp)) {
                                 ret = -errno;
+                                free(filename);
+                                count--;
                                 goto error_cleanup_array;
                         }
-                        fscanf(sysfsfp, "%i", &current_enabled);
-                        fclose(sysfsfp);
 
                         if (!current_enabled) {
                                 free(filename);
@@ -353,6 +420,7 @@ int build_channel_array(const char *device_dir,
                         if (current->name == NULL) {
                                 free(filename);
                                 ret = -ENOMEM;
+                                count--;
                                 goto error_cleanup_array;
                         }
                         /* Get the generic and specific name elements */
@@ -360,6 +428,8 @@ int build_channel_array(const char *device_dir,
                                                      &current->generic_name);
                         if (ret) {
                                 free(filename);
+                                free(current->name);
+                                count--;
                                 goto error_cleanup_array;
                         }
                         ret = asprintf(&filename,
@@ -372,8 +442,29 @@ int build_channel_array(const char *device_dir,
                                 goto error_cleanup_array;
                         }
                         sysfsfp = fopen(filename, "r");
-                        fscanf(sysfsfp, "%u", &current->index);
-                        fclose(sysfsfp);
+                        if (sysfsfp == NULL) {
+                                ret = -errno;
+                                printf("failed to open %s\n", filename);
+                                free(filename);
+                                goto error_cleanup_array;
+                        }
+
+                        errno = 0;
+                        if (fscanf(sysfsfp, "%u", &current->index) != 1) {
+                                ret = errno ? -errno : -ENODATA;
+                                if (fclose(sysfsfp))
+                                        perror("build_channel_array(): Failed to close file");
+
+                                free(filename);
+                                goto error_cleanup_array;
+                        }
+
+                        if (fclose(sysfsfp)) {
+                                ret = -errno;
+                                free(filename);
+                                goto error_cleanup_array;
+                        }
+
                         free(filename);
                         /* Find the scale */
                         ret = iioutils_get_param_float(&current->scale,
@@ -399,38 +490,64 @@ int build_channel_array(const char *device_dir,
                                                 device_dir,
                                                 current->name,
                                                 current->generic_name);
+                        if (ret < 0)
+                                goto error_cleanup_array;
                 }
         }
 
-        closedir(dp);
+        if (closedir(dp) == -1) {
+                ret = -errno;
+                goto error_cleanup_array;
+        }
+
+        free(scan_el_dir);
         /* reorder so that the array is in index order */
         bsort_channel_array_by_index(ci_array, *counter);
 
         return 0;
 
 error_cleanup_array:
-        for (i = count - 1;  i >= 0; i--)
+        for (i = count - 1;  i >= 0; i--) {
                 free((*ci_array)[i].name);
+                free((*ci_array)[i].generic_name);
+        }
         free(*ci_array);
 error_close_dir:
-        closedir(dp);
+        if (dp)
+                if (closedir(dp) == -1)
+                        perror("build_channel_array(): Failed to close dir");
+
 error_free_name:
         free(scan_el_dir);
-error_ret:
+
         return ret;
 }
 
+int calc_digits(int num)
+{
+        int count = 0;
+
+        while (num != 0) {
+                num /= 10;
+                count++;
+        }
+
+        return count;
+}
+
 /**
  * find_type_by_name() - function to match top level types by name
  * @name: top level type instance name
- * @type: the type of top level instance being sort
+ * @type: the type of top level instance being searched
  *
+ * Returns the device number of a matched IIO device on success, otherwise a
+ * negative error code.
  * Typical types this is used for are device and trigger.
  **/
 int find_type_by_name(const char *name, const char *type)
 {
         const struct dirent *ent;
-        int number, numstrlen;
+        int number, numstrlen, ret;
 
         FILE *nameFile;
         DIR *dp;
@@ -448,9 +565,19 @@ int find_type_by_name(const char *name, const char *type)
                         strcmp(ent->d_name, "..") != 0 &&
                         strlen(ent->d_name) > strlen(type) &&
                         strncmp(ent->d_name, type, strlen(type)) == 0) {
-                        numstrlen = sscanf(ent->d_name + strlen(type),
-                                           "%d",
-                                           &number);
+                        errno = 0;
+                        ret = sscanf(ent->d_name + strlen(type), "%d", &number);
+                        if (ret < 0) {
+                                ret = -errno;
+                                printf("failed to read element number\n");
+                                goto error_close_dir;
+                        } else if (ret != 1) {
+                                ret = -EIO;
+                                printf("failed to match element number\n");
+                                goto error_close_dir;
+                        }
+
+                        numstrlen = calc_digits(number);
                         /* verify the next character is not a colon */
                         if (strncmp(ent->d_name + strlen(type) + numstrlen,
                                         ":",
@@ -460,33 +587,55 @@ int find_type_by_name(const char *name, const char *type)
                                                 + numstrlen
                                                 + 6);
                                 if (filename == NULL) {
-                                        closedir(dp);
-                                        return -ENOMEM;
+                                        ret = -ENOMEM;
+                                        goto error_close_dir;
                                 }
-                                sprintf(filename, "%s%s%d/name",
-                                        iio_dir,
-                                        type,
-                                        number);
+
+                                ret = sprintf(filename, "%s%s%d/name", iio_dir,
+                                              type, number);
+                                if (ret < 0) {
+                                        free(filename);
+                                        goto error_close_dir;
+                                }
+
                                 nameFile = fopen(filename, "r");
                                 if (!nameFile) {
                                         free(filename);
                                         continue;
                                 }
                                 free(filename);
-                                fscanf(nameFile, "%s", thisname);
-                                fclose(nameFile);
+                                errno = 0;
+                                if (fscanf(nameFile, "%s", thisname) != 1) {
+                                        ret = errno ? -errno : -ENODATA;
+                                        goto error_close_dir;
+                                }
+
+                                if (fclose(nameFile)) {
+                                        ret = -errno;
+                                        goto error_close_dir;
+                                }
+
                                 if (strcmp(name, thisname) == 0) {
-                                        closedir(dp);
+                                        if (closedir(dp) == -1)
+                                                return -errno;
                                         return number;
                                 }
                         }
                 }
         }
-        closedir(dp);
+        if (closedir(dp) == -1)
+                return -errno;
+
         return -ENODEV;
+
+error_close_dir:
+        if (closedir(dp) == -1)
+                perror("find_type_by_name(): Failed to close directory");
+        return ret;
 }
 
-int _write_sysfs_int(char *filename, char *basedir, int val, int verify)
+static int _write_sysfs_int(const char *filename, const char *basedir, int val,
+                            int verify)
 {
         int ret = 0;
         FILE *sysfsfp;
@@ -495,24 +644,49 @@ int _write_sysfs_int(char *filename, char *basedir, int val, int verify)
 
         if (temp == NULL)
                 return -ENOMEM;
-        sprintf(temp, "%s/%s", basedir, filename);
+        ret = sprintf(temp, "%s/%s", basedir, filename);
+        if (ret < 0)
+                goto error_free;
+
         sysfsfp = fopen(temp, "w");
         if (sysfsfp == NULL) {
+                ret = -errno;
                 printf("failed to open %s\n", temp);
+                goto error_free;
+        }
+        ret = fprintf(sysfsfp, "%d", val);
+        if (ret < 0) {
+                if (fclose(sysfsfp))
+                        perror("_write_sysfs_int(): Failed to close dir");
+
+                goto error_free;
+        }
+
+        if (fclose(sysfsfp)) {
                 ret = -errno;
                 goto error_free;
         }
-        fprintf(sysfsfp, "%d", val);
-        fclose(sysfsfp);
+
         if (verify) {
                 sysfsfp = fopen(temp, "r");
                 if (sysfsfp == NULL) {
+                        ret = -errno;
                         printf("failed to open %s\n", temp);
+                        goto error_free;
+                }
+                if (fscanf(sysfsfp, "%d", &test) != 1) {
+                        ret = errno ? -errno : -ENODATA;
+                        if (fclose(sysfsfp))
+                                perror("_write_sysfs_int(): Failed to close dir");
+
+                        goto error_free;
+                }
+
+                if (fclose(sysfsfp)) {
                         ret = -errno;
                         goto error_free;
                 }
-                fscanf(sysfsfp, "%d", &test);
-                fclose(sysfsfp);
+
                 if (test != val) {
                         printf("Possible failure in int write %d to %s%s\n",
                                 val,
@@ -526,17 +700,36 @@ error_free:
         return ret;
 }
 
-int write_sysfs_int(char *filename, char *basedir, int val)
+/**
+ * write_sysfs_int() - write an integer value to a sysfs file
+ * @filename: name of the file to write to
+ * @basedir: the sysfs directory in which the file is to be found
+ * @val: integer value to write to file
+ *
+ * Returns a value >= 0 on success, otherwise a negative error code.
+ **/
+int write_sysfs_int(const char *filename, const char *basedir, int val)
 {
         return _write_sysfs_int(filename, basedir, val, 0);
 }
 
-int write_sysfs_int_and_verify(char *filename, char *basedir, int val)
+/**
+ * write_sysfs_int_and_verify() - write an integer value to a sysfs file
+ *                                and verify
+ * @filename: name of the file to write to
+ * @basedir: the sysfs directory in which the file is to be found
+ * @val: integer value to write to file
+ *
+ * Returns a value >= 0 on success, otherwise a negative error code.
+ **/
+int write_sysfs_int_and_verify(const char *filename, const char *basedir,
+                               int val)
 {
         return _write_sysfs_int(filename, basedir, val, 1);
 }
 
-int _write_sysfs_string(char *filename, char *basedir, char *val, int verify)
+static int _write_sysfs_string(const char *filename, const char *basedir,
+                               const char *val, int verify)
 {
         int ret = 0;
         FILE  *sysfsfp;
@@ -546,24 +739,49 @@ int _write_sysfs_string(char *filename, char *basedir, char *val, int verify)
                 printf("Memory allocation failed\n");
                 return -ENOMEM;
         }
-        sprintf(temp, "%s/%s", basedir, filename);
+        ret = sprintf(temp, "%s/%s", basedir, filename);
+        if (ret < 0)
+                goto error_free;
+
         sysfsfp = fopen(temp, "w");
         if (sysfsfp == NULL) {
+                ret = -errno;
                 printf("Could not open %s\n", temp);
+                goto error_free;
+        }
+        ret = fprintf(sysfsfp, "%s", val);
+        if (ret < 0) {
+                if (fclose(sysfsfp))
+                        perror("_write_sysfs_string(): Failed to close dir");
+
+                goto error_free;
+        }
+
+        if (fclose(sysfsfp)) {
                 ret = -errno;
                 goto error_free;
         }
-        fprintf(sysfsfp, "%s", val);
-        fclose(sysfsfp);
+
         if (verify) {
                 sysfsfp = fopen(temp, "r");
                 if (sysfsfp == NULL) {
+                        ret = -errno;
                         printf("could not open file to verify\n");
+                        goto error_free;
+                }
+                if (fscanf(sysfsfp, "%s", temp) != 1) {
+                        ret = errno ? -errno : -ENODATA;
+                        if (fclose(sysfsfp))
+                                perror("_write_sysfs_string(): Failed to close dir");
+
+                        goto error_free;
+                }
+
+                if (fclose(sysfsfp)) {
                         ret = -errno;
                         goto error_free;
                 }
-                fscanf(sysfsfp, "%s", temp);
-                fclose(sysfsfp);
+
                 if (strcmp(temp, val) != 0) {
                         printf("Possible failure in string write of %s "
                                 "Should be %s "
@@ -586,18 +804,38 @@ error_free:
  * @filename: name of file to write to
  * @basedir: the sysfs directory in which the file is to be found
  * @val: the string to write
+ *
+ * Returns a value >= 0 on success, otherwise a negative error code.
  **/
-int write_sysfs_string_and_verify(char *filename, char *basedir, char *val)
+int write_sysfs_string_and_verify(const char *filename, const char *basedir,
+                                  const char *val)
 {
         return _write_sysfs_string(filename, basedir, val, 1);
 }
 
-int write_sysfs_string(char *filename, char *basedir, char *val)
+/**
+ * write_sysfs_string() - write string to a sysfs file
+ * @filename: name of file to write to
+ * @basedir: the sysfs directory in which the file is to be found
+ * @val: the string to write
+ *
+ * Returns a value >= 0 on success, otherwise a negative error code.
+ **/
+int write_sysfs_string(const char *filename, const char *basedir,
+                       const char *val)
 {
         return _write_sysfs_string(filename, basedir, val, 0);
 }
 
-int read_sysfs_posint(char *filename, char *basedir)
+/**
+ * read_sysfs_posint() - read an integer value from file
+ * @filename: name of file to read from
+ * @basedir: the sysfs directory in which the file is to be found
+ *
+ * Returns the read integer value >= 0 on success, otherwise a negative error
+ * code.
+ **/
+int read_sysfs_posint(const char *filename, const char *basedir)
 {
         int ret;
         FILE  *sysfsfp;
@@ -607,20 +845,41 @@ int read_sysfs_posint(char *filename, char *basedir)
                 printf("Memory allocation failed");
                 return -ENOMEM;
         }
-        sprintf(temp, "%s/%s", basedir, filename);
+        ret = sprintf(temp, "%s/%s", basedir, filename);
+        if (ret < 0)
+                goto error_free;
+
         sysfsfp = fopen(temp, "r");
         if (sysfsfp == NULL) {
                 ret = -errno;
                 goto error_free;
         }
-        fscanf(sysfsfp, "%d\n", &ret);
-        fclose(sysfsfp);
+        errno = 0;
+        if (fscanf(sysfsfp, "%d\n", &ret) != 1) {
+                ret = errno ? -errno : -ENODATA;
+                if (fclose(sysfsfp))
+                        perror("read_sysfs_posint(): Failed to close dir");
+
+                goto error_free;
+        }
+
+        if (fclose(sysfsfp))
+                ret = -errno;
+
 error_free:
         free(temp);
         return ret;
 }
 
-int read_sysfs_float(char *filename, char *basedir, float *val)
+/**
+ * read_sysfs_float() - read a float value from file
+ * @filename: name of file to read from
+ * @basedir: the sysfs directory in which the file is to be found
+ * @val: output the read float value
+ *
+ * Returns a value >= 0 on success, otherwise a negative error code.
+ **/
+int read_sysfs_float(const char *filename, const char *basedir, float *val)
 {
         int ret = 0;
         FILE  *sysfsfp;
@@ -630,19 +889,40 @@ int read_sysfs_float(char *filename, char *basedir, float *val)
                 printf("Memory allocation failed");
                 return -ENOMEM;
         }
-        sprintf(temp, "%s/%s", basedir, filename);
+        ret = sprintf(temp, "%s/%s", basedir, filename);
+        if (ret < 0)
+                goto error_free;
+
         sysfsfp = fopen(temp, "r");
         if (sysfsfp == NULL) {
                 ret = -errno;
                 goto error_free;
         }
-        fscanf(sysfsfp, "%f\n", val);
-        fclose(sysfsfp);
+        errno = 0;
+        if (fscanf(sysfsfp, "%f\n", val) != 1) {
+                ret = errno ? -errno : -ENODATA;
+                if (fclose(sysfsfp))
+                        perror("read_sysfs_float(): Failed to close dir");
+
+                goto error_free;
+        }
+
+        if (fclose(sysfsfp))
+                ret = -errno;
+
 error_free:
         free(temp);
         return ret;
 }
 
+/**
+ * read_sysfs_string() - read a string from file
+ * @filename: name of file to read from
+ * @basedir: the sysfs directory in which the file is to be found
+ * @str: output the read string
+ *
+ * Returns a value >= 0 on success, otherwise a negative error code.
+ **/
 int read_sysfs_string(const char *filename, const char *basedir, char *str)
 {
         int ret = 0;
@@ -653,14 +933,27 @@ int read_sysfs_string(const char *filename, const char *basedir, char *str)
                 printf("Memory allocation failed");
                 return -ENOMEM;
         }
-        sprintf(temp, "%s/%s", basedir, filename);
+        ret = sprintf(temp, "%s/%s", basedir, filename);
+        if (ret < 0)
+                goto error_free;
+
         sysfsfp = fopen(temp, "r");
         if (sysfsfp == NULL) {
                 ret = -errno;
                 goto error_free;
         }
-        fscanf(sysfsfp, "%s\n", str);
-        fclose(sysfsfp);
+        errno = 0;
+        if (fscanf(sysfsfp, "%s\n", str) != 1) {
+                ret = errno ? -errno : -ENODATA;
+                if (fclose(sysfsfp))
+                        perror("read_sysfs_string(): Failed to close dir");
+
+                goto error_free;
+        }
+
+        if (fclose(sysfsfp))
+                ret = -errno;
+
 error_free:
         free(temp);
         return ret;
diff --git a/tools/iio/iio_utils.h b/tools/iio/iio_utils.h
index 1bc837b2d769..379eed9deaea 100644
--- a/tools/iio/iio_utils.h
+++ b/tools/iio/iio_utils.h
@@ -28,9 +28,12 @@ extern const char *iio_dir;
  * @offset: offset to be applied for conversion to si units
  * @index: the channel index in the buffer output
  * @bytes: number of bytes occupied in buffer output
+ * @bits_used: number of valid bits of data
+ * @shift: amount of bits to shift right data before applying bit mask
  * @mask: a bit mask for the raw output
+ * @be: flag if data is big endian
  * @is_signed: is the raw value stored signed
- * @enabled: is this channel enabled
+ * @location: data offset for this channel inside the buffer (in bytes)
  **/
 struct iio_channel_info {
         char *name;
@@ -60,12 +63,15 @@ void bsort_channel_array_by_index(struct iio_channel_info **ci_array, int cnt);
 int build_channel_array(const char *device_dir,
                                                 struct iio_channel_info **ci_array, int *counter);
 int find_type_by_name(const char *name, const char *type);
-int write_sysfs_int(char *filename, char *basedir, int val);
-int write_sysfs_int_and_verify(char *filename, char *basedir, int val);
-int write_sysfs_string_and_verify(char *filename, char *basedir, char *val);
-int write_sysfs_string(char *filename, char *basedir, char *val);
-int read_sysfs_posint(char *filename, char *basedir);
-int read_sysfs_float(char *filename, char *basedir, float *val);
+int write_sysfs_int(const char *filename, const char *basedir, int val);
+int write_sysfs_int_and_verify(const char *filename, const char *basedir,
+                               int val);
+int write_sysfs_string_and_verify(const char *filename, const char *basedir,
+                                  const char *val);
+int write_sysfs_string(const char *filename, const char *basedir,
+                       const char *val);
+int read_sysfs_posint(const char *filename, const char *basedir);
+int read_sysfs_float(const char *filename, const char *basedir, float *val);
 int read_sysfs_string(const char *filename, const char *basedir, char *str);
 
 #endif /* _IIO_UTILS_H_ */
diff --git a/tools/iio/lsiio.c b/tools/iio/lsiio.c
index c585440f864e..b59ee1733924 100644
--- a/tools/iio/lsiio.c
+++ b/tools/iio/lsiio.c
@@ -56,7 +56,7 @@ static int dump_channels(const char *dev_dir_name)
                         printf("   %-10s\n", ent->d_name);
                 }
 
-        return 0;
+        return (closedir(dp) == -1) ? -errno : 0;
 }
 
 static int dump_one_device(const char *dev_dir_name)
@@ -69,7 +69,10 @@ static int dump_one_device(const char *dev_dir_name)
                         "%i", &dev_idx);
         if (retval != 1)
                 return -EINVAL;
-        read_sysfs_string("name", dev_dir_name, name);
+        retval = read_sysfs_string("name", dev_dir_name, name);
+        if (retval)
+                return retval;
+
         printf("Device %03d: %s\n", dev_idx, name);
 
         if (verblevel >= VERBLEVEL_SENSORS)
@@ -87,28 +90,42 @@ static int dump_one_trigger(const char *dev_dir_name)
                         "%i", &dev_idx);
         if (retval != 1)
                 return -EINVAL;
-        read_sysfs_string("name", dev_dir_name, name);
+        retval = read_sysfs_string("name", dev_dir_name, name);
+        if (retval)
+                return retval;
+
         printf("Trigger %03d: %s\n", dev_idx, name);
         return 0;
 }
 
-static void dump_devices(void)
+static int dump_devices(void)
 {
         const struct dirent *ent;
+        int ret;
         DIR *dp;
 
         dp = opendir(iio_dir);
         if (dp == NULL) {
                 printf("No industrial I/O devices available\n");
-                return;
+                return -ENODEV;
         }
 
         while (ent = readdir(dp), ent != NULL) {
                 if (check_prefix(ent->d_name, type_device)) {
                         char *dev_dir_name;
 
-                        asprintf(&dev_dir_name, "%s%s", iio_dir, ent->d_name);
-                        dump_one_device(dev_dir_name);
+                        if (asprintf(&dev_dir_name, "%s%s", iio_dir,
+                                     ent->d_name) < 0) {
+                                ret = -ENOMEM;
+                                goto error_close_dir;
+                        }
+
+                        ret = dump_one_device(dev_dir_name);
+                        if (ret) {
+                                free(dev_dir_name);
+                                goto error_close_dir;
+                        }
+
                         free(dev_dir_name);
                         if (verblevel >= VERBLEVEL_SENSORS)
                                 printf("\n");
@@ -119,19 +136,35 @@ static void dump_devices(void)
                 if (check_prefix(ent->d_name, type_trigger)) {
                         char *dev_dir_name;
 
-                        asprintf(&dev_dir_name, "%s%s", iio_dir, ent->d_name);
-                        dump_one_trigger(dev_dir_name);
+                        if (asprintf(&dev_dir_name, "%s%s", iio_dir,
+                                     ent->d_name) < 0) {
+                                ret = -ENOMEM;
+                                goto error_close_dir;
+                        }
+
+                        ret = dump_one_trigger(dev_dir_name);
+                        if (ret) {
+                                free(dev_dir_name);
+                                goto error_close_dir;
+                        }
+
                         free(dev_dir_name);
                 }
         }
-        closedir(dp);
+        return (closedir(dp) == -1) ? -errno : 0;
+
+error_close_dir:
+        if (closedir(dp) == -1)
+                perror("dump_devices(): Failed to close directory");
+
+        return ret;
 }
 
 int main(int argc, char **argv)
 {
         int c, err = 0;
 
-        while ((c = getopt(argc, argv, "d:D:v")) != EOF) {
+        while ((c = getopt(argc, argv, "v")) != EOF) {
                 switch (c) {
                 case 'v':
                         verblevel++;
@@ -146,13 +179,9 @@ int main(int argc, char **argv)
         if (err || argc > optind) {
                 fprintf(stderr, "Usage: lsiio [options]...\n"
                         "List industrial I/O devices\n"
-                        "  -v, --verbose\n"
-                        "      Increase verbosity (may be given multiple times)\n"
-                        );
+                        "  -v  Increase verbosity (may be given multiple times)\n");
                 exit(1);
         }
 
-        dump_devices();
-
-        return 0;
+        return dump_devices();
 }