tools/testing/selftests/gpio/gpio-mockup-chardev.c

   1 /*
   2  * GPIO chardev test helper
   3  *
   4  * Copyright (C) 2016 Bamvor Jian Zhang
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License version 2 as published by
   8  * the Free Software Foundation.
   9  */
  10
  11 #define _GNU_SOURCE
  12 #include <unistd.h>
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <stdio.h>
  16 #include <errno.h>
  17 #include <string.h>
  18 #include <fcntl.h>
  19 #include <getopt.h>
  20 #include <sys/ioctl.h>
  21 #include <libmount.h>
  22 #include <err.h>
  23 #include <dirent.h>
  24 #include <linux/gpio.h>
  25 #include "../../../gpio/gpio-utils.h"
  26
  27 #define CONSUMER        "gpio-selftest"
  28 #define GC_NUM          10
  29 enum direction {
  30         OUT,
  31         IN
  32 };
  33
  34 static int get_debugfs(char **path)
  35 {
  36         struct libmnt_context *cxt;
  37         struct libmnt_table *tb;
  38         struct libmnt_iter *itr = NULL;
  39         struct libmnt_fs *fs;
  40         int found = 0;
  41
  42         cxt = mnt_new_context();
  43         if (!cxt)
  44                 err(EXIT_FAILURE, "libmount context allocation failed");
  45
  46         itr = mnt_new_iter(MNT_ITER_FORWARD);
  47         if (!itr)
  48                 err(EXIT_FAILURE, "failed to initialize libmount iterator");
  49
  50         if (mnt_context_get_mtab(cxt, &tb))
  51                 err(EXIT_FAILURE, "failed to read mtab");
  52
  53         while (mnt_table_next_fs(tb, itr, &fs) == 0) {
  54                 const char *type = mnt_fs_get_fstype(fs);
  55
  56                 if (!strcmp(type, "debugfs")) {
  57                         found = 1;
  58                         break;
  59                 }
  60         }
  61         if (found)
  62                 asprintf(path, "%s/gpio", mnt_fs_get_target(fs));
  63
  64         mnt_free_iter(itr);
  65         mnt_free_context(cxt);
  66
  67         if (!found)
  68                 return -1;
  69
  70         return 0;
  71 }
  72
  73 static int gpio_debugfs_get(const char *consumer, int *dir, int *value)
  74 {
  75         char *debugfs;
  76         FILE *f;
  77         char *line = NULL;
  78         size_t len = 0;
  79         char *cur;
  80         int found = 0;
  81
  82         if (get_debugfs(&debugfs) != 0)
  83                 err(EXIT_FAILURE, "debugfs is not mounted");
  84
  85         f = fopen(debugfs, "r");
  86         if (!f)
  87                 err(EXIT_FAILURE, "read from gpio debugfs failed");
  88
  89         /*
  90          * gpio-2   (                    |gpio-selftest               ) in  lo
  91          */
  92         while (getline(&line, &len, f) != -1) {
  93                 cur = strstr(line, consumer);
  94                 if (cur == NULL)
  95                         continue;
  96
  97                 cur = strchr(line, ')');
  98                 if (!cur)
  99                         continue;
 100
 101                 cur += 2;
 102                 if (!strncmp(cur, "out", 3)) {
 103                         *dir = OUT;
 104                         cur += 4;
 105                 } else if (!strncmp(cur, "in", 2)) {
 106                         *dir = IN;
 107                         cur += 4;
 108                 }
 109
 110                 if (!strncmp(cur, "hi", 2))
 111                         *value = 1;
 112                 else if (!strncmp(cur, "lo", 2))
 113                         *value = 0;
 114
 115                 found = 1;
 116                 break;
 117         }
 118         free(debugfs);
 119         fclose(f);
 120         free(line);
 121
 122         if (!found)
 123                 return -1;
 124
 125         return 0;
 126 }
 127
 128 static struct gpiochip_info *list_gpiochip(const char *gpiochip_name, int *ret)
 129 {
 130         struct gpiochip_info *cinfo;
 131         struct gpiochip_info *current;
 132         const struct dirent *ent;
 133         DIR *dp;
 134         char *chrdev_name;
 135         int fd;
 136         int i = 0;
 137
 138         cinfo = calloc(sizeof(struct gpiochip_info) * 4, GC_NUM + 1);
 139         if (!cinfo)
 140                 err(EXIT_FAILURE, "gpiochip_info allocation failed");
 141
 142         current = cinfo;
 143         dp = opendir("/dev");
 144         if (!dp) {
 145                 *ret = -errno;
 146                 goto error_out;
 147         } else {
 148                 *ret = 0;
 149         }
 150
 151         while (ent = readdir(dp), ent) {
 152                 if (check_prefix(ent->d_name, "gpiochip")) {
 153                         *ret = asprintf(&chrdev_name, "/dev/%s", ent->d_name);
 154                         if (*ret < 0)
 155                                 goto error_out;
 156
 157                         fd = open(chrdev_name, 0);
 158                         if (fd == -1) {
 159                                 *ret = -errno;
 160                                 fprintf(stderr, "Failed to open %s\n",
 161                                         chrdev_name);
 162                                 goto error_close_dir;
 163                         }
 164                         *ret = ioctl(fd, GPIO_GET_CHIPINFO_IOCTL, current);
 165                         if (*ret == -1) {
 166                                 perror("Failed to issue CHIPINFO IOCTL\n");
 167                                 goto error_close_dir;
 168                         }
 169                         close(fd);
 170                         if (strcmp(current->label, gpiochip_name) == 0
 171                             || check_prefix(current->label, gpiochip_name)) {
 172                                 *ret = 0;
 173                                 current++;
 174                                 i++;
 175                         }
 176                 }
 177         }
 178
 179         if ((!*ret && i == 0) || *ret < 0) {
 180                 free(cinfo);
 181                 cinfo = NULL;
 182         }
 183         if (!*ret && i > 0) {
 184                 cinfo = realloc(cinfo, sizeof(struct gpiochip_info) * 4 * i);
 185                 *ret = i;
 186         }
 187
 188 error_close_dir:
 189         closedir(dp);
 190 error_out:
 191         if (*ret < 0)
 192                 err(EXIT_FAILURE, "list gpiochip failed: %s", strerror(*ret));
 193
 194         return cinfo;
 195 }
 196
 197 int gpio_pin_test(struct gpiochip_info *cinfo, int line, int flag, int value)
 198 {
 199         struct gpiohandle_data data;
 200         unsigned int lines[] = {line};
 201         int fd;
 202         int debugfs_dir = IN;
 203         int debugfs_value = 0;
 204         int ret;
 205
 206         data.values[0] = value;
 207         ret = gpiotools_request_linehandle(cinfo->name, lines, 1, flag, &data,
 208                                            CONSUMER);
 209         if (ret < 0)
 210                 goto fail_out;
 211         else
 212                 fd = ret;
 213
 214         ret = gpio_debugfs_get(CONSUMER, &debugfs_dir, &debugfs_value);
 215         if (ret) {
 216                 ret = -EINVAL;
 217                 goto fail_out;
 218         }
 219         if (flag & GPIOHANDLE_REQUEST_INPUT) {
 220                 if (debugfs_dir != IN) {
 221                         errno = -EINVAL;
 222                         ret = -errno;
 223                 }
 224         } else if (flag & GPIOHANDLE_REQUEST_OUTPUT) {
 225                 if (flag & GPIOHANDLE_REQUEST_ACTIVE_LOW)
 226                         debugfs_value = !debugfs_value;
 227
 228                 if (!(debugfs_dir == OUT && value == debugfs_value))
 229                         errno = -EINVAL;
 230                 ret = -errno;
 231
 232         }
 233         gpiotools_release_linehandle(fd);
 234
 235 fail_out:
 236         if (ret)
 237                 err(EXIT_FAILURE, "gpio<%s> line<%d> test flag<0x%x> value<%d>",
 238                     cinfo->name, line, flag, value);
 239
 240         return ret;
 241 }
 242
 243 void gpio_pin_tests(struct gpiochip_info *cinfo, unsigned int line)
 244 {
 245         printf("line<%d>", line);
 246         gpio_pin_test(cinfo, line, GPIOHANDLE_REQUEST_OUTPUT, 0);
 247         printf(".");
 248         gpio_pin_test(cinfo, line, GPIOHANDLE_REQUEST_OUTPUT, 1);
 249         printf(".");
 250         gpio_pin_test(cinfo, line,
 251                       GPIOHANDLE_REQUEST_OUTPUT | GPIOHANDLE_REQUEST_ACTIVE_LOW,
 252                       0);
 253         printf(".");
 254         gpio_pin_test(cinfo, line,
 255                       GPIOHANDLE_REQUEST_OUTPUT | GPIOHANDLE_REQUEST_ACTIVE_LOW,
 256                       1);
 257         printf(".");
 258         gpio_pin_test(cinfo, line, GPIOHANDLE_REQUEST_INPUT, 0);
 259         printf(".");
 260 }
 261
 262 /*
 263  * ./gpio-mockup-chardev gpio_chip_name_prefix is_valid_gpio_chip
 264  * Return 0 if successful or exit with EXIT_FAILURE if test failed.
 265  * gpio_chip_name_prefix: The prefix of gpiochip you want to test. E.g.
 266  *                        gpio-mockup
 267  * is_valid_gpio_chip:    Whether the gpio_chip is valid. 1 means valid,
 268  *                        0 means invalid which could not be found by
 269  *                        list_gpiochip.
 270  */
 271 int main(int argc, char *argv[])
 272 {
 273         char *prefix;
 274         int valid;
 275         struct gpiochip_info *cinfo;
 276         struct gpiochip_info *current;
 277         int i;
 278         int ret;
 279
 280         if (argc < 3) {
 281                 printf("Usage: %s prefix is_valid", argv[0]);
 282                 exit(EXIT_FAILURE);
 283         }
 284
 285         prefix = argv[1];
 286         valid = strcmp(argv[2], "true") == 0 ? 1 : 0;
 287
 288         printf("Test gpiochip %s: ", prefix);
 289         cinfo = list_gpiochip(prefix, &ret);
 290         if (!cinfo) {
 291                 if (!valid && ret == 0) {
 292                         printf("Invalid test successful\n");
 293                         ret = 0;
 294                         goto out;
 295                 } else {
 296                         ret = -EINVAL;
 297                         goto out;
 298                 }
 299         } else if (cinfo && !valid) {
 300                 ret = -EINVAL;
 301                 goto out;
 302         }
 303         current = cinfo;
 304         for (i = 0; i < ret; i++) {
 305                 gpio_pin_tests(current, 0);
 306                 gpio_pin_tests(current, current->lines - 1);
 307                 gpio_pin_tests(current, random() % current->lines);
 308                 current++;
 309         }
 310         ret = 0;
 311         printf("successful\n");
 312
 313 out:
 314         if (ret)
 315                 fprintf(stderr, "gpio<%s> test failed\n", prefix);
 316
 317         if (cinfo)
 318                 free(cinfo);
 319
 320         if (ret)
 321                 exit(EXIT_FAILURE);
 322
 323         return ret;
 324 }