Home | History | Annotate | Line # | Download | only in gpioctl
gpioctl.c revision 1.26 
      1 /* $NetBSD: gpioctl.c,v 1.26 2019/01/27 02:08:51 pgoyette Exp $ */
      2 
      3 /*
      4  * Copyright (c) 2008, 2010, 2011, 2013 Marc Balmer <mbalmer (at) NetBSD.org>
      5  * Copyright (c) 2004 Alexander Yurchenko <grange (at) openbsd.org>
      6  *
      7  * Permission to use, copy, modify, and distribute this software for any
      8  * purpose with or without fee is hereby granted, provided that the above
      9  * copyright notice and this permission notice appear in all copies.
     10  *
     11  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
     12  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
     13  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
     14  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
     15  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
     16  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
     17  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
     18  */
     19 #include <sys/cdefs.h>
     20 __RCSID("$NetBSD: gpioctl.c,v 1.26 2019/01/27 02:08:51 pgoyette Exp $");
     21 
     22 /*
     23  * Program to control GPIO devices.
     24  */
     25 
     26 #include <sys/types.h>
     27 #include <sys/gpio.h>
     28 #include <sys/ioctl.h>
     29 
     30 #include <err.h>
     31 #include <errno.h>
     32 #include <fcntl.h>
     33 #include <limits.h>
     34 #include <paths.h>
     35 #include <stdio.h>
     36 #include <stdlib.h>
     37 #include <time.h>
     38 #include <string.h>
     39 #include <unistd.h>
     40 
     41 static char *dev;
     42 static int devfd = -1;
     43 static int quiet = 0;
     44 static int state = 0;
     45 
     46 static void getinfo(void);
     47 static void gpioread(int, char *);
     48 static void gpiowrite(int, char *, int);
     49 static void gpioset(int pin, char *name, int flags, char *alias);
     50 static void gpiounset(int pin, char *name);
     51 static void devattach(char *, int, uint32_t, uint32_t);
     52 __dead static void usage(void);
     53 
     54 static const struct bitstr {
     55 	unsigned int mask;
     56 	const char *string;
     57 } pinflags[] = {
     58 	{ GPIO_PIN_INPUT, "in" },
     59 	{ GPIO_PIN_OUTPUT, "out" },
     60 	{ GPIO_PIN_INOUT, "inout" },
     61 	{ GPIO_PIN_OPENDRAIN, "od" },
     62 	{ GPIO_PIN_PUSHPULL, "pp" },
     63 	{ GPIO_PIN_TRISTATE, "tri" },
     64 	{ GPIO_PIN_PULLUP, "pu" },
     65 	{ GPIO_PIN_PULLDOWN, "pd" },
     66 	{ GPIO_PIN_INVIN, "iin" },
     67 	{ GPIO_PIN_INVOUT, "iout" },
     68 	{ GPIO_PIN_PULSATE, "pulsate" },
     69 	{ GPIO_PIN_ALT0, "alt0" },
     70 	{ GPIO_PIN_ALT1, "alt1" },
     71 	{ GPIO_PIN_ALT2, "alt2" },
     72 	{ GPIO_PIN_ALT3, "alt3" },
     73 	{ GPIO_PIN_ALT4, "alt4" },
     74 	{ GPIO_PIN_ALT5, "alt5" },
     75 	{ GPIO_PIN_ALT6, "alt6" },
     76 	{ GPIO_PIN_ALT7, "alt7" },
     77 	{ GPIO_PIN_USER, "user" },
     78 	{ 0, NULL },
     79 };
     80 
     81 int
     82 main(int argc, char *argv[])
     83 {
     84 	const struct bitstr *bs;
     85 	int pin, ch, n, fl = 0, value = 0;
     86 	const char *errstr;
     87 	char *ep;
     88 	int ga_offset = -1;
     89 	uint32_t ga_mask = 0;
     90 	uint32_t ga_flags = 0;
     91 	long lval;
     92 	char *nam = NULL;
     93 	char *flags;
     94 	char devn[32];
     95 
     96 	while ((ch = getopt(argc, argv, "qs")) != -1)
     97 		switch (ch) {
     98 		case 'q':
     99 			quiet = 1;
    100 			break;
    101 		case 's':
    102 			quiet = state = 1;
    103 			break;
    104 		default:
    105 			usage();
    106 			/* NOTREACHED */
    107 		}
    108 	argc -= optind;
    109 	argv += optind;
    110 
    111 	if (argc < 1)
    112 		usage();
    113 	dev = argv[0];
    114 
    115 	if (strncmp(_PATH_DEV, dev, sizeof(_PATH_DEV) - 1)) {
    116 		(void)snprintf(devn, sizeof(devn), "%s%s", _PATH_DEV, dev);
    117 		dev = devn;
    118 	}
    119 
    120 	if ((devfd = open(dev, O_RDWR)) == -1)
    121 		err(EXIT_FAILURE, "%s", dev);
    122 
    123 	if (argc == 1) {
    124 		getinfo();
    125 		return EXIT_SUCCESS;
    126 	}
    127 
    128 	if (!strcmp(argv[1], "attach")) {
    129 		char *driver, *offset, *mask;
    130 
    131 		if (argc != 5 && argc != 6)
    132 			usage();
    133 
    134 		driver = argv[2];
    135 		offset = argv[3];
    136 		mask = argv[4];
    137 		flags = argc == 6 ? argv[5] : NULL;
    138 
    139 		ga_offset = strtonum(offset, 0, INT_MAX, &errstr);
    140 		if (errstr)
    141 			errx(EXIT_FAILURE, "offset is %s: %s", errstr, offset);
    142 		lval = strtol(mask, &ep, 0);
    143 		if (*mask == '\0' || *ep != '\0')
    144 			errx(EXIT_FAILURE, "invalid mask (not a number)");
    145 		if ((errno == ERANGE && (lval == LONG_MAX
    146 		    || lval == LONG_MIN)) || (unsigned long)lval > UINT_MAX)
    147 			errx(EXIT_FAILURE, "mask out of range");
    148 		ga_mask = lval;
    149 		if (flags != NULL) {
    150 			lval = strtol(flags, &ep, 0);
    151 			if (*flags == '\0' || *ep != '\0')
    152 				errx(EXIT_FAILURE,
    153 				    "invalid flag locator (not a number)");
    154 			if ((errno == ERANGE && (lval == LONG_MAX
    155 			    || lval == LONG_MIN))
    156 			    || (unsigned long)lval > UINT_MAX)
    157 				errx(EXIT_FAILURE, "flag locator out of range");
    158 
    159 			ga_flags = lval;
    160 		}
    161 		devattach(driver, ga_offset, ga_mask, ga_flags);
    162 		return EXIT_SUCCESS;
    163 	} else {
    164 		char *nm = NULL;
    165 
    166 		/* expecting a pin number or name */
    167 		pin = strtonum(argv[1], 0, INT_MAX, &errstr);
    168 		if (errstr)
    169 			nm = argv[1];	/* try named pin */
    170 		if (argc > 2) {
    171 			if (!strcmp(argv[2], "set")) {
    172 				for (n = 3; n < argc; n++) {
    173 					for (bs = pinflags; bs->string != NULL;
    174 					     bs++) {
    175 						if (!strcmp(argv[n],
    176 						    bs->string)) {
    177 							fl |= bs->mask;
    178 							break;
    179 						}
    180 					}
    181 					if (bs->string == NULL)
    182 						nam = argv[n];
    183 				}
    184 				gpioset(pin, nm, fl, nam);
    185 			} else if (!strcmp(argv[2], "unset"))
    186 				gpiounset(pin, nm);
    187 			else {
    188 				value = strtonum(argv[2], INT_MIN, INT_MAX,
    189 				   &errstr);
    190 				if (errstr) {
    191 					if (!strcmp(argv[2], "on"))
    192 						value = GPIO_PIN_HIGH;
    193 					else if (!strcmp(argv[2], "off"))
    194 						value = GPIO_PIN_LOW;
    195 					else if (!strcmp(argv[2], "toggle"))
    196 						value = 2;
    197 					else
    198 						errx(EXIT_FAILURE,
    199 						    "%s: invalid value",
    200 						    argv[2]);
    201 				}
    202 				gpiowrite(pin, nm, value);
    203 			}
    204 		} else
    205 			gpioread(pin, nm);
    206 	}
    207 	return EXIT_SUCCESS;
    208 }
    209 
    210 static void
    211 getinfo(void)
    212 {
    213 	struct gpio_info info;
    214 
    215 	if (ioctl(devfd, GPIOINFO, &info) == -1)
    216 		err(EXIT_FAILURE, "GPIOINFO");
    217 
    218 	if (state)
    219 		printf("%d\n", info.gpio_npins);
    220 
    221 	if (quiet)
    222 		return;
    223 
    224 	printf("%s: %d pins\n", dev, info.gpio_npins);
    225 }
    226 
    227 static void
    228 gpioread(int pin, char *gp_name)
    229 {
    230 	struct gpio_req req;
    231 
    232 	memset(&req, 0, sizeof(req));
    233 	if (gp_name != NULL)
    234 		strlcpy(req.gp_name, gp_name, sizeof(req.gp_name));
    235 	else
    236 		req.gp_pin = pin;
    237 
    238 	if (ioctl(devfd, GPIOREAD, &req) == -1)
    239 		err(EXIT_FAILURE, "GPIOREAD");
    240 
    241 	if (state)
    242 		printf("%d\n", req.gp_value);
    243 
    244 	if (quiet)
    245 		return;
    246 
    247 	if (gp_name)
    248 		printf("pin %s: state %d\n", gp_name, req.gp_value);
    249 	else
    250 		printf("pin %d: state %d\n", pin, req.gp_value);
    251 }
    252 
    253 static void
    254 gpiowrite(int pin, char *gp_name, int value)
    255 {
    256 	struct gpio_req req;
    257 
    258 	if (value < 0 || value > 2)
    259 		errx(EXIT_FAILURE, "%d: invalid value", value);
    260 
    261 	memset(&req, 0, sizeof(req));
    262 	if (gp_name != NULL)
    263 		strlcpy(req.gp_name, gp_name, sizeof(req.gp_name));
    264 	else
    265 		req.gp_pin = pin;
    266 
    267 	if (value == GPIO_PIN_HIGH || value == GPIO_PIN_LOW) {
    268 		req.gp_value = value;
    269 		if (ioctl(devfd, GPIOWRITE, &req) == -1)
    270 			err(EXIT_FAILURE, "GPIOWRITE");
    271 	} else {
    272 		if (ioctl(devfd, GPIOTOGGLE, &req) == -1)
    273 			err(EXIT_FAILURE, "GPIOTOGGLE");
    274 	}
    275 
    276 	if (state)
    277 		printf("%d\n", value < 2 ? value : 1 - req.gp_value);
    278 
    279 	if (quiet)
    280 		return;
    281 
    282 	if (gp_name)
    283 		printf("pin %s: state %d -> %d\n", gp_name, req.gp_value,
    284 		    (value < 2 ? value : 1 - req.gp_value));
    285 	else
    286 		printf("pin %d: state %d -> %d\n", pin, req.gp_value,
    287 		    (value < 2 ? value : 1 - req.gp_value));
    288 }
    289 
    290 static void
    291 gpioset(int pin, char *name, int fl, char *alias)
    292 {
    293 	struct gpio_set set;
    294 	const struct bitstr *bs;
    295 
    296 	memset(&set, 0, sizeof(set));
    297 	if (name != NULL)
    298 		strlcpy(set.gp_name, name, sizeof(set.gp_name));
    299 	else
    300 		set.gp_pin = pin;
    301 	set.gp_flags = fl;
    302 
    303 	if (alias != NULL)
    304 		strlcpy(set.gp_name2, alias, sizeof(set.gp_name2));
    305 
    306 	if (ioctl(devfd, GPIOSET, &set) == -1)
    307 		err(EXIT_FAILURE, "GPIOSET");
    308 
    309 	if (quiet)
    310 		return;
    311 
    312 	if (name != NULL)
    313 		printf("pin %s: caps:", name);
    314 	else
    315 		printf("pin %d: caps:", pin);
    316 	for (bs = pinflags; bs->string != NULL; bs++)
    317 		if (set.gp_caps & bs->mask)
    318 			printf(" %s", bs->string);
    319 	printf(", flags:");
    320 	for (bs = pinflags; bs->string != NULL; bs++)
    321 		if (set.gp_flags & bs->mask)
    322 			printf(" %s", bs->string);
    323 	if (fl > 0) {
    324 		printf(" ->");
    325 		for (bs = pinflags; bs->string != NULL; bs++)
    326 			if (fl & bs->mask)
    327 				printf(" %s", bs->string);
    328 	}
    329 	printf("\n");
    330 }
    331 
    332 static void
    333 gpiounset(int pin, char *name)
    334 {
    335 	struct gpio_set set;
    336 
    337 	memset(&set, 0, sizeof(set));
    338 	if (name != NULL)
    339 		strlcpy(set.gp_name, name, sizeof(set.gp_name));
    340 	else
    341 		set.gp_pin = pin;
    342 
    343 	if (ioctl(devfd, GPIOUNSET, &set) == -1)
    344 		err(EXIT_FAILURE, "GPIOUNSET");
    345 }
    346 
    347 static void
    348 devattach(char *dvname, int offset, uint32_t mask, uint32_t flags)
    349 {
    350 	struct gpio_attach attach;
    351 
    352 	memset(&attach, 0, sizeof(attach));
    353 	strlcpy(attach.ga_dvname, dvname, sizeof(attach.ga_dvname));
    354 	attach.ga_offset = offset;
    355 	attach.ga_mask = mask;
    356 	attach.ga_flags = flags;
    357 	if (ioctl(devfd, GPIOATTACH, &attach) == -1)
    358 		err(EXIT_FAILURE, "GPIOATTACH");
    359 }
    360 
    361 static void
    362 usage(void)
    363 {
    364 	const char *progname;
    365 
    366 	progname = getprogname();
    367 	fprintf(stderr, "usage: %s [-qs] device [pin] [0 | 1 | 2 | "
    368 	    "on | off | toggle]\n", progname);
    369 	fprintf(stderr, "       %s [-q] device pin set [flags] [name]\n",
    370 	    progname);
    371 	fprintf(stderr, "       %s [-q] device pin unset\n", progname);
    372 	fprintf(stderr, "       %s [-q] device attach device offset mask "
    373 	    "[flag]\n",
    374 	    progname);
    375 
    376 	exit(EXIT_FAILURE);
    377 }
    378