gpiolib-of.c 11.9 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13
/*
 * OF helpers for the GPIO API
 *
 * Copyright (c) 2007-2008  MontaVista Software, Inc.
 *
 * Author: Anton Vorontsov <avorontsov@ru.mvista.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */

Grant Likely's avatar
Grant Likely committed
14
#include <linux/device.h>
15
#include <linux/err.h>
16
#include <linux/errno.h>
Grant Likely's avatar
Grant Likely committed
17
#include <linux/module.h>
18
#include <linux/io.h>
19
#include <linux/gpio/consumer.h>
20
#include <linux/of.h>
Grant Likely's avatar
Grant Likely committed
21
#include <linux/of_address.h>
22
#include <linux/of_gpio.h>
23
#include <linux/pinctrl/pinctrl.h>
Grant Likely's avatar
Grant Likely committed
24
#include <linux/slab.h>
25
#include <linux/gpio/machine.h>
26

27
#include "gpiolib.h"
28

29
static int of_gpiochip_match_node(struct gpio_chip *chip, void *data)
30
{
31 32
	return chip->gpiodev->dev.of_node == data;
}
33

34 35 36
static struct gpio_chip *of_find_gpiochip_by_node(struct device_node *np)
{
	return gpiochip_find(np, of_gpiochip_match_node);
37 38
}

39 40 41
static struct gpio_desc *of_xlate_and_get_gpiod_flags(struct gpio_chip *chip,
					struct of_phandle_args *gpiospec,
					enum of_gpio_flags *flags)
42 43 44
{
	int ret;

45 46 47 48 49 50 51 52
	if (chip->of_gpio_n_cells != gpiospec->args_count)
		return ERR_PTR(-EINVAL);

	ret = chip->of_xlate(chip, gpiospec, flags);
	if (ret < 0)
		return ERR_PTR(ret);

	return gpiochip_get_desc(chip, ret);
53 54
}

55
/**
56
 * of_get_named_gpiod_flags() - Get a GPIO descriptor and flags for GPIO API
57
 * @np:		device node to get GPIO from
58
 * @propname:	property name containing gpio specifier(s)
59
 * @index:	index of the GPIO
60
 * @flags:	a flags pointer to fill in
61
 *
62
 * Returns GPIO descriptor to use with Linux GPIO API, or one of the errno
63 64
 * value on the error condition. If @flags is not NULL the function also fills
 * in flags for the GPIO.
65
 */
66 67
struct gpio_desc *of_get_named_gpiod_flags(struct device_node *np,
		     const char *propname, int index, enum of_gpio_flags *flags)
68
{
69 70 71
	struct of_phandle_args gpiospec;
	struct gpio_chip *chip;
	struct gpio_desc *desc;
72
	int ret;
73

74
	ret = of_parse_phandle_with_args(np, propname, "#gpio-cells", index,
75
					 &gpiospec);
76
	if (ret) {
77 78
		pr_debug("%s: can't parse '%s' property of node '%s[%d]'\n",
			__func__, propname, np->full_name, index);
79
		return ERR_PTR(ret);
80 81
	}

82 83 84 85 86 87
	chip = of_find_gpiochip_by_node(gpiospec.np);
	if (!chip) {
		desc = ERR_PTR(-EPROBE_DEFER);
		goto out;
	}

88
	desc = of_xlate_and_get_gpiod_flags(chip, &gpiospec, flags);
89 90
	if (IS_ERR(desc))
		goto out;
91

92 93
	pr_debug("%s: parsed '%s' property of node '%s[%d]' - status (%d)\n",
		 __func__, propname, np->full_name, index,
94 95 96 97 98 99
		 PTR_ERR_OR_ZERO(desc));

out:
	of_node_put(gpiospec.np);

	return desc;
100 101
}

102 103 104 105 106 107 108 109 110 111 112 113 114 115
int of_get_named_gpio_flags(struct device_node *np, const char *list_name,
			    int index, enum of_gpio_flags *flags)
{
	struct gpio_desc *desc;

	desc = of_get_named_gpiod_flags(np, list_name, index, flags);

	if (IS_ERR(desc))
		return PTR_ERR(desc);
	else
		return desc_to_gpio(desc);
}
EXPORT_SYMBOL(of_get_named_gpio_flags);

116
/**
117
 * of_parse_own_gpio() - Get a GPIO hog descriptor, names and flags for GPIO API
118
 * @np:		device node to get GPIO from
119
 * @chip:	GPIO chip whose hog is parsed
120 121
 * @name:	GPIO line name
 * @lflags:	gpio_lookup_flags - returned from of_find_gpio() or
122
 *		of_parse_own_gpio()
123 124 125 126 127
 * @dflags:	gpiod_flags - optional GPIO initialization flags
 *
 * Returns GPIO descriptor to use with Linux GPIO API, or one of the errno
 * value on the error condition.
 */
128
static struct gpio_desc *of_parse_own_gpio(struct device_node *np,
129
					   struct gpio_chip *chip,
130 131 132
					   const char **name,
					   enum gpio_lookup_flags *lflags,
					   enum gpiod_flags *dflags)
133 134 135
{
	struct device_node *chip_np;
	enum of_gpio_flags xlate_flags;
136 137
	struct of_phandle_args gpiospec;
	struct gpio_desc *desc;
138
	u32 tmp;
139
	int ret;
140

141
	chip_np = chip->of_node;
142 143 144 145 146 147 148 149 150 151 152
	if (!chip_np)
		return ERR_PTR(-EINVAL);

	xlate_flags = 0;
	*lflags = 0;
	*dflags = 0;

	ret = of_property_read_u32(chip_np, "#gpio-cells", &tmp);
	if (ret)
		return ERR_PTR(ret);

153 154
	gpiospec.np = chip_np;
	gpiospec.args_count = tmp;
155

156
	ret = of_property_read_u32_array(np, "gpios", gpiospec.args, tmp);
157 158
	if (ret)
		return ERR_PTR(ret);
159

160
	desc = of_xlate_and_get_gpiod_flags(chip, &gpiospec, &xlate_flags);
161 162
	if (IS_ERR(desc))
		return desc;
163 164 165 166 167 168 169 170 171 172 173 174

	if (xlate_flags & OF_GPIO_ACTIVE_LOW)
		*lflags |= GPIO_ACTIVE_LOW;

	if (of_property_read_bool(np, "input"))
		*dflags |= GPIOD_IN;
	else if (of_property_read_bool(np, "output-low"))
		*dflags |= GPIOD_OUT_LOW;
	else if (of_property_read_bool(np, "output-high"))
		*dflags |= GPIOD_OUT_HIGH;
	else {
		pr_warn("GPIO line %d (%s): no hogging state specified, bailing out\n",
175
			desc_to_gpio(desc), np->name);
176 177 178 179 180 181
		return ERR_PTR(-EINVAL);
	}

	if (name && of_property_read_string(np, "line-name", name))
		*name = np->name;

182
	return desc;
183 184
}

185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229
/**
 * of_gpiochip_set_names() - set up the names of the lines
 * @chip: GPIO chip whose lines should be named, if possible
 */
static void of_gpiochip_set_names(struct gpio_chip *gc)
{
	struct gpio_device *gdev = gc->gpiodev;
	struct device_node *np = gc->of_node;
	int i;
	int nstrings;

	nstrings = of_property_count_strings(np, "gpio-line-names");
	if (nstrings <= 0)
		/* Lines names not present */
		return;

	/* This is normally not what you want */
	if (gdev->ngpio != nstrings)
		dev_info(&gdev->dev, "gpio-line-names specifies %d line "
			 "names but there are %d lines on the chip\n",
			 nstrings, gdev->ngpio);

	/*
	 * Make sure to not index beyond the end of the number of descriptors
	 * of the GPIO device.
	 */
	for (i = 0; i < gdev->ngpio; i++) {
		const char *name;
		int ret;

		ret = of_property_read_string_index(np,
						    "gpio-line-names",
						    i,
						    &name);
		if (ret) {
			if (ret != -ENODATA)
                                dev_err(&gdev->dev,
                                        "unable to name line %d: %d\n",
                                        i, ret);
			break;
		}
		gdev->descs[i].name = name;
	}
}

230
/**
231
 * of_gpiochip_scan_gpios - Scan gpio-controller for gpio definitions
232 233 234 235
 * @chip:	gpio chip to act on
 *
 * This is only used by of_gpiochip_add to request/set GPIO initial
 * configuration.
236
 * It retures error if it fails otherwise 0 on success.
237
 */
238
static int of_gpiochip_scan_gpios(struct gpio_chip *chip)
239 240 241 242 243 244
{
	struct gpio_desc *desc = NULL;
	struct device_node *np;
	const char *name;
	enum gpio_lookup_flags lflags;
	enum gpiod_flags dflags;
245
	int ret;
246

247
	for_each_available_child_of_node(chip->of_node, np) {
248 249 250
		if (!of_property_read_bool(np, "gpio-hog"))
			continue;

251
		desc = of_parse_own_gpio(np, chip, &name, &lflags, &dflags);
252 253 254
		if (IS_ERR(desc))
			continue;

255 256 257
		ret = gpiod_hog(desc, name, lflags, dflags);
		if (ret < 0)
			return ret;
258
	}
259 260

	return 0;
261 262
}

263
/**
264
 * of_gpio_simple_xlate - translate gpio_spec to the GPIO number and flags
265
 * @gc:		pointer to the gpio_chip structure
266 267
 * @np:		device node of the GPIO chip
 * @gpio_spec:	gpio specifier as found in the device tree
268
 * @flags:	a flags pointer to fill in
269 270 271 272 273
 *
 * This is simple translation function, suitable for the most 1:1 mapped
 * gpio chips. This function performs only one sanity check: whether gpio
 * is less than ngpios (that is specified in the gpio_chip).
 */
274 275
int of_gpio_simple_xlate(struct gpio_chip *gc,
			 const struct of_phandle_args *gpiospec, u32 *flags)
276
{
277 278
	/*
	 * We're discouraging gpio_cells < 2, since that way you'll have to
279
	 * write your own xlate function (that will have to retrieve the GPIO
280 281 282
	 * number and the flags from a single gpio cell -- this is possible,
	 * but not recommended).
	 */
283
	if (gc->of_gpio_n_cells < 2) {
284 285 286 287
		WARN_ON(1);
		return -EINVAL;
	}

288 289 290
	if (WARN_ON(gpiospec->args_count < gc->of_gpio_n_cells))
		return -EINVAL;

291
	if (gpiospec->args[0] >= gc->ngpio)
292 293
		return -EINVAL;

294
	if (flags)
295
		*flags = gpiospec->args[1];
296

297
	return gpiospec->args[0];
298
}
299
EXPORT_SYMBOL(of_gpio_simple_xlate);
300 301

/**
302
 * of_mm_gpiochip_add_data - Add memory mapped GPIO chip (bank)
303 304
 * @np:		device node of the GPIO chip
 * @mm_gc:	pointer to the of_mm_gpio_chip allocated structure
305
 * @data:	driver data to store in the struct gpio_chip
306 307 308 309 310
 *
 * To use this function you should allocate and fill mm_gc with:
 *
 * 1) In the gpio_chip structure:
 *    - all the callbacks
311 312
 *    - of_gpio_n_cells
 *    - of_xlate callback (optional)
313 314 315 316 317 318 319 320
 *
 * 3) In the of_mm_gpio_chip structure:
 *    - save_regs callback (optional)
 *
 * If succeeded, this function will map bank's memory and will
 * do all necessary work for you. Then you'll able to use .regs
 * to manage GPIOs from the callbacks.
 */
321 322 323
int of_mm_gpiochip_add_data(struct device_node *np,
			    struct of_mm_gpio_chip *mm_gc,
			    void *data)
324 325
{
	int ret = -ENOMEM;
326
	struct gpio_chip *gc = &mm_gc->gc;
327 328 329 330 331 332 333 334 335

	gc->label = kstrdup(np->full_name, GFP_KERNEL);
	if (!gc->label)
		goto err0;

	mm_gc->regs = of_iomap(np, 0);
	if (!mm_gc->regs)
		goto err1;

336
	gc->base = -1;
337 338 339 340

	if (mm_gc->save_regs)
		mm_gc->save_regs(mm_gc);

341
	mm_gc->gc.of_node = np;
342

343
	ret = gpiochip_add_data(gc, data);
344 345 346 347 348 349 350 351 352 353 354 355 356
	if (ret)
		goto err2;

	return 0;
err2:
	iounmap(mm_gc->regs);
err1:
	kfree(gc->label);
err0:
	pr_err("%s: GPIO chip registration failed with status %d\n",
	       np->full_name, ret);
	return ret;
}
357
EXPORT_SYMBOL(of_mm_gpiochip_add_data);
358

359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375
/**
 * of_mm_gpiochip_remove - Remove memory mapped GPIO chip (bank)
 * @mm_gc:	pointer to the of_mm_gpio_chip allocated structure
 */
void of_mm_gpiochip_remove(struct of_mm_gpio_chip *mm_gc)
{
	struct gpio_chip *gc = &mm_gc->gc;

	if (!mm_gc)
		return;

	gpiochip_remove(gc);
	iounmap(mm_gc->regs);
	kfree(gc->label);
}
EXPORT_SYMBOL(of_mm_gpiochip_remove);

376
#ifdef CONFIG_PINCTRL
377
static int of_gpiochip_add_pin_range(struct gpio_chip *chip)
378 379 380
{
	struct device_node *np = chip->of_node;
	struct of_phandle_args pinspec;
381
	struct pinctrl_dev *pctldev;
382
	int index = 0, ret;
383 384 385
	const char *name;
	static const char group_names_propname[] = "gpio-ranges-group-names";
	struct property *group_names;
386 387

	if (!np)
388
		return 0;
389

390 391
	group_names = of_find_property(np, group_names_propname, NULL);

392
	for (;; index++) {
393 394
		ret = of_parse_phandle_with_fixed_args(np, "gpio-ranges", 3,
				index, &pinspec);
395 396 397
		if (ret)
			break;

398
		pctldev = of_pinctrl_get(pinspec.np);
399
		of_node_put(pinspec.np);
400
		if (!pctldev)
401
			return -EPROBE_DEFER;
402

403 404
		if (pinspec.args[2]) {
			if (group_names) {
405
				of_property_read_string_index(np,
406 407 408 409 410 411 412 413 414 415 416 417 418 419 420
						group_names_propname,
						index, &name);
				if (strlen(name)) {
					pr_err("%s: Group name of numeric GPIO ranges must be the empty string.\n",
						np->full_name);
					break;
				}
			}
			/* npins != 0: linear range */
			ret = gpiochip_add_pin_range(chip,
					pinctrl_dev_get_devname(pctldev),
					pinspec.args[0],
					pinspec.args[1],
					pinspec.args[2]);
			if (ret)
421
				return ret;
422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450
		} else {
			/* npins == 0: special range */
			if (pinspec.args[1]) {
				pr_err("%s: Illegal gpio-range format.\n",
					np->full_name);
				break;
			}

			if (!group_names) {
				pr_err("%s: GPIO group range requested but no %s property.\n",
					np->full_name, group_names_propname);
				break;
			}

			ret = of_property_read_string_index(np,
						group_names_propname,
						index, &name);
			if (ret)
				break;

			if (!strlen(name)) {
				pr_err("%s: Group name of GPIO group range cannot be the empty string.\n",
				np->full_name);
				break;
			}

			ret = gpiochip_add_pingroup_range(chip, pctldev,
						pinspec.args[0], name);
			if (ret)
451
				return ret;
452
		}
453
	}
454 455

	return 0;
456 457 458
}

#else
459
static int of_gpiochip_add_pin_range(struct gpio_chip *chip) { return 0; }
460 461
#endif

462
int of_gpiochip_add(struct gpio_chip *chip)
463
{
464 465
	int status;

466 467
	if ((!chip->of_node) && (chip->parent))
		chip->of_node = chip->parent->of_node;
468 469

	if (!chip->of_node)
470
		return 0;
471 472 473 474 475 476

	if (!chip->of_xlate) {
		chip->of_gpio_n_cells = 2;
		chip->of_xlate = of_gpio_simple_xlate;
	}

477 478 479
	if (chip->of_gpio_n_cells > MAX_PHANDLE_ARGS)
		return -EINVAL;

480 481 482 483
	status = of_gpiochip_add_pin_range(chip);
	if (status)
		return status;

484 485 486 487
	/* If the chip defines names itself, these take precedence */
	if (!chip->names)
		of_gpiochip_set_names(chip);

488
	of_node_get(chip->of_node);
489

490
	return of_gpiochip_scan_gpios(chip);
491 492 493 494
}

void of_gpiochip_remove(struct gpio_chip *chip)
{
495
	gpiochip_remove_pin_ranges(chip);
496
	of_node_put(chip->of_node);
497
}