1/*
  2 * GPIO tools - helpers library for the GPIO tools
  3 *
  4 * Copyright (C) 2015 Linus Walleij
  5 * Copyright (C) 2016 Bamvor Jian Zhang
  6 *
  7 * This program is free software; you can redistribute it and/or modify it
  8 * under the terms of the GNU General Public License version 2 as published by
  9 * the Free Software Foundation.
 10 */
 11
 12#include <unistd.h>
 13#include <stdlib.h>
 14#include <stdio.h>
 15#include <errno.h>
 16#include <string.h>
 17#include <fcntl.h>
 18#include <getopt.h>
 19#include <sys/ioctl.h>
 20#include <linux/gpio.h>
 21#include "gpio-utils.h"
 22
 23#define COMSUMER "gpio-utils"
 24
 25/**
 26 * doc: Operation of gpio
 27 *
 28 * Provide the api of gpiochip for chardev interface. There are two
 29 * types of api.  The first one provide as same function as each
 30 * ioctl, including request and release for lines of gpio, read/write
 31 * the value of gpio. If the user want to do lots of read and write of
 32 * lines of gpio, user should use this type of api.
 33 *
 34 * The second one provide the easy to use api for user. Each of the
 35 * following api will request gpio lines, do the operation and then
 36 * release these lines.
 37 */
 38/**
 39 * gpiotools_request_linehandle() - request gpio lines in a gpiochip
 40 * @device_name:	The name of gpiochip without prefix "/dev/",
 41 *			such as "gpiochip0"
 42 * @lines:		An array desired lines, specified by offset
 43 *			index for the associated GPIO device.
 44 * @nline:		The number of lines to request.
 45 * @flag:		The new flag for requsted gpio. Reference
 46 *			"linux/gpio.h" for the meaning of flag.
 47 * @data:		Default value will be set to gpio when flag is
 48 *			GPIOHANDLE_REQUEST_OUTPUT.
 49 * @consumer_label:	The name of consumer, such as "sysfs",
 50 *			"powerkey". This is useful for other users to
 51 *			know who is using.
 52 *
 53 * Request gpio lines through the ioctl provided by chardev. User
 54 * could call gpiotools_set_values() and gpiotools_get_values() to
 55 * read and write respectively through the returned fd. Call
 56 * gpiotools_release_linehandle() to release these lines after that.
 57 *
 58 * Return:		On success return the fd;
 59 *			On failure return the errno.
 60 */
 61int gpiotools_request_linehandle(const char *device_name, unsigned int *lines,
 62				 unsigned int nlines, unsigned int flag,
 63				 struct gpiohandle_data *data,
 64				 const char *consumer_label)
 65{
 66	struct gpiohandle_request req;
 67	char *chrdev_name;
 68	int fd;
 69	int i;
 70	int ret;
 71
 72	ret = asprintf(&chrdev_name, "/dev/%s", device_name);
 73	if (ret < 0)
 74		return -ENOMEM;
 75
 76	fd = open(chrdev_name, 0);
 77	if (fd == -1) {
 78		ret = -errno;
 79		fprintf(stderr, "Failed to open %s\n", chrdev_name);
 80		goto exit_close_error;
 81	}
 82
 83	for (i = 0; i < nlines; i++)
 84		req.lineoffsets[i] = lines[i];
 85
 86	req.flags = flag;
 87	strcpy(req.consumer_label, consumer_label);
 88	req.lines = nlines;
 89	if (flag & GPIOHANDLE_REQUEST_OUTPUT)
 90		memcpy(req.default_values, data, sizeof(req.default_values));
 91
 92	ret = ioctl(fd, GPIO_GET_LINEHANDLE_IOCTL, &req);
 93	if (ret == -1) {
 94		ret = -errno;
 95		fprintf(stderr, "Failed to issue GET LINEHANDLE IOCTL (%d)\n",
 96			ret);
 97	}
 98
 99exit_close_error:
100	if (close(fd) == -1)
101		perror("Failed to close GPIO character device file");
102	free(chrdev_name);
103	return ret < 0 ? ret : req.fd;
104}
105/**
106 * gpiotools_set_values(): Set the value of gpio(s)
107 * @fd:			The fd returned by
108 *			gpiotools_request_linehandle().
109 * @data:		The array of values want to set.
110 *
111 * Return:		On success return 0;
112 *			On failure return the errno.
113 */
114int gpiotools_set_values(const int fd, struct gpiohandle_data *data)
115{
116	int ret;
117
118	ret = ioctl(fd, GPIOHANDLE_SET_LINE_VALUES_IOCTL, data);
119	if (ret == -1) {
120		ret = -errno;
121		fprintf(stderr, "Failed to issue %s (%d)\n",
122			"GPIOHANDLE_SET_LINE_VALUES_IOCTL", ret);
123	}
124
125	return ret;
126}
127
128/**
129 * gpiotools_get_values(): Get the value of gpio(s)
130 * @fd:			The fd returned by
131 *			gpiotools_request_linehandle().
132 * @data:		The array of values get from hardware.
133 *
134 * Return:		On success return 0;
135 *			On failure return the errno.
136 */
137int gpiotools_get_values(const int fd, struct gpiohandle_data *data)
138{
139	int ret;
140
141	ret = ioctl(fd, GPIOHANDLE_GET_LINE_VALUES_IOCTL, data);
142	if (ret == -1) {
143		ret = -errno;
144		fprintf(stderr, "Failed to issue %s (%d)\n",
145			"GPIOHANDLE_GET_LINE_VALUES_IOCTL", ret);
146	}
147
148	return ret;
149}
150
151/**
152 * gpiotools_release_linehandle(): Release the line(s) of gpiochip
153 * @fd:			The fd returned by
154 *			gpiotools_request_linehandle().
155 *
156 * Return:		On success return 0;
157 *			On failure return the errno.
158 */
159int gpiotools_release_linehandle(const int fd)
160{
161	int ret;
162
163	ret = close(fd);
164	if (ret == -1) {
165		perror("Failed to close GPIO LINEHANDLE device file");
166		ret = -errno;
167	}
168
169	return ret;
170}
171
172/**
173 * gpiotools_get(): Get value from specific line
174 * @device_name:	The name of gpiochip without prefix "/dev/",
175 *			such as "gpiochip0"
176 * @line:		number of line, such as 2.
177 *
178 * Return:		On success return 0;
179 *			On failure return the errno.
180 */
181int gpiotools_get(const char *device_name, unsigned int line)
182{
183	struct gpiohandle_data data;
184	unsigned int lines[] = {line};
185
186	gpiotools_gets(device_name, lines, 1, &data);
187	return data.values[0];
188}
189
190
191/**
192 * gpiotools_gets(): Get values from specific lines.
193 * @device_name:	The name of gpiochip without prefix "/dev/",
194 *			such as "gpiochip0".
195 * @lines:		An array desired lines, specified by offset
196 *			index for the associated GPIO device.
197 * @nline:		The number of lines to request.
198 * @data:		The array of values get from gpiochip.
199 *
200 * Return:		On success return 0;
201 *			On failure return the errno.
202 */
203int gpiotools_gets(const char *device_name, unsigned int *lines,
204		   unsigned int nlines, struct gpiohandle_data *data)
205{
206	int fd;
207	int ret;
208	int ret_close;
209
210	ret = gpiotools_request_linehandle(device_name, lines, nlines,
211					   GPIOHANDLE_REQUEST_INPUT, data,
212					   COMSUMER);
213	if (ret < 0)
214		return ret;
215
216	fd = ret;
217	ret = gpiotools_get_values(fd, data);
218	ret_close = gpiotools_release_linehandle(fd);
219	return ret < 0 ? ret : ret_close;
220}
221
222/**
223 * gpiotools_set(): Set value to specific line
224 * @device_name:	The name of gpiochip without prefix "/dev/",
225 *			such as "gpiochip0"
226 * @line:		number of line, such as 2.
227 * @value:		The value of gpio, must be 0(low) or 1(high).
228 *
229 * Return:		On success return 0;
230 *			On failure return the errno.
231 */
232int gpiotools_set(const char *device_name, unsigned int line,
233		  unsigned int value)
234{
235	struct gpiohandle_data data;
236	unsigned int lines[] = {line};
237
238	data.values[0] = value;
239	return gpiotools_sets(device_name, lines, 1, &data);
240}
241
242/**
243 * gpiotools_sets(): Set values to specific lines.
244 * @device_name:	The name of gpiochip without prefix "/dev/",
245 *			such as "gpiochip0".
246 * @lines:		An array desired lines, specified by offset
247 *			index for the associated GPIO device.
248 * @nline:		The number of lines to request.
249 * @data:		The array of values set to gpiochip, must be
250 *			0(low) or 1(high).
251 *
252 * Return:		On success return 0;
253 *			On failure return the errno.
254 */
255int gpiotools_sets(const char *device_name, unsigned int *lines,
256		   unsigned int nlines, struct gpiohandle_data *data)
257{
258	int ret;
259
260	ret = gpiotools_request_linehandle(device_name, lines, nlines,
261					   GPIOHANDLE_REQUEST_OUTPUT, data,
262					   COMSUMER);
263	if (ret < 0)
264		return ret;
265
266	return gpiotools_release_linehandle(ret);
267}