pinctrl-tegra.c 17.5 KB
Newer Older
1 2 3
/*
 * Driver for the NVIDIA Tegra pinmux
 *
4
 * Copyright (c) 2011-2012, NVIDIA CORPORATION.  All rights reserved.
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
 *
 * Derived from code:
 * Copyright (C) 2010 Google, Inc.
 * Copyright (C) 2010 NVIDIA Corporation
 * Copyright (C) 2009-2011 ST-Ericsson AB
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 */

#include <linux/err.h>
#include <linux/init.h>
#include <linux/io.h>
#include <linux/module.h>
25 26
#include <linux/of.h>
#include <linux/platform_device.h>
27
#include <linux/pinctrl/machine.h>
28 29 30
#include <linux/pinctrl/pinctrl.h>
#include <linux/pinctrl/pinmux.h>
#include <linux/pinctrl/pinconf.h>
31
#include <linux/slab.h>
32

33
#include "core.h"
34
#include "pinctrl-tegra.h"
35
#include "pinctrl-utils.h"
36 37 38 39 40 41

struct tegra_pmx {
	struct device *dev;
	struct pinctrl_dev *pctl;

	const struct tegra_pinctrl_soc_data *soc;
42
	const char **group_pins;
43 44 45 46 47 48 49 50 51 52 53 54 55 56 57

	int nbanks;
	void __iomem **regs;
};

static inline u32 pmx_readl(struct tegra_pmx *pmx, u32 bank, u32 reg)
{
	return readl(pmx->regs[bank] + reg);
}

static inline void pmx_writel(struct tegra_pmx *pmx, u32 val, u32 bank, u32 reg)
{
	writel(val, pmx->regs[bank] + reg);
}

58
static int tegra_pinctrl_get_groups_count(struct pinctrl_dev *pctldev)
59 60 61
{
	struct tegra_pmx *pmx = pinctrl_dev_get_drvdata(pctldev);

62
	return pmx->soc->ngroups;
63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85
}

static const char *tegra_pinctrl_get_group_name(struct pinctrl_dev *pctldev,
						unsigned group)
{
	struct tegra_pmx *pmx = pinctrl_dev_get_drvdata(pctldev);

	return pmx->soc->groups[group].name;
}

static int tegra_pinctrl_get_group_pins(struct pinctrl_dev *pctldev,
					unsigned group,
					const unsigned **pins,
					unsigned *num_pins)
{
	struct tegra_pmx *pmx = pinctrl_dev_get_drvdata(pctldev);

	*pins = pmx->soc->groups[group].pins;
	*num_pins = pmx->soc->groups[group].npins;

	return 0;
}

86
#ifdef CONFIG_DEBUG_FS
87 88 89 90
static void tegra_pinctrl_pin_dbg_show(struct pinctrl_dev *pctldev,
				       struct seq_file *s,
				       unsigned offset)
{
91
	seq_printf(s, " %s", dev_name(pctldev->dev));
92
}
93
#endif
94

95 96 97 98 99 100 101 102 103 104
static const struct cfg_param {
	const char *property;
	enum tegra_pinconf_param param;
} cfg_params[] = {
	{"nvidia,pull",			TEGRA_PINCONF_PARAM_PULL},
	{"nvidia,tristate",		TEGRA_PINCONF_PARAM_TRISTATE},
	{"nvidia,enable-input",		TEGRA_PINCONF_PARAM_ENABLE_INPUT},
	{"nvidia,open-drain",		TEGRA_PINCONF_PARAM_OPEN_DRAIN},
	{"nvidia,lock",			TEGRA_PINCONF_PARAM_LOCK},
	{"nvidia,io-reset",		TEGRA_PINCONF_PARAM_IORESET},
105
	{"nvidia,rcv-sel",		TEGRA_PINCONF_PARAM_RCV_SEL},
106
	{"nvidia,io-hv",		TEGRA_PINCONF_PARAM_RCV_SEL},
107 108 109 110 111 112 113
	{"nvidia,high-speed-mode",	TEGRA_PINCONF_PARAM_HIGH_SPEED_MODE},
	{"nvidia,schmitt",		TEGRA_PINCONF_PARAM_SCHMITT},
	{"nvidia,low-power-mode",	TEGRA_PINCONF_PARAM_LOW_POWER_MODE},
	{"nvidia,pull-down-strength",	TEGRA_PINCONF_PARAM_DRIVE_DOWN_STRENGTH},
	{"nvidia,pull-up-strength",	TEGRA_PINCONF_PARAM_DRIVE_UP_STRENGTH},
	{"nvidia,slew-rate-falling",	TEGRA_PINCONF_PARAM_SLEW_RATE_FALLING},
	{"nvidia,slew-rate-rising",	TEGRA_PINCONF_PARAM_SLEW_RATE_RISING},
114
	{"nvidia,drive-type",		TEGRA_PINCONF_PARAM_DRIVE_TYPE},
115 116
};

117
static int tegra_pinctrl_dt_subnode_to_map(struct pinctrl_dev *pctldev,
118 119 120 121
					   struct device_node *np,
					   struct pinctrl_map **map,
					   unsigned *reserved_maps,
					   unsigned *num_maps)
122
{
123
	struct device *dev = pctldev->dev;
124 125 126 127 128 129 130 131 132 133 134
	int ret, i;
	const char *function;
	u32 val;
	unsigned long config;
	unsigned long *configs = NULL;
	unsigned num_configs = 0;
	unsigned reserve;
	struct property *prop;
	const char *group;

	ret = of_property_read_string(np, "nvidia,function", &function);
135 136 137 138 139
	if (ret < 0) {
		/* EINVAL=missing, which is fine since it's optional */
		if (ret != -EINVAL)
			dev_err(dev,
				"could not parse property nvidia,function\n");
140
		function = NULL;
141
	}
142 143 144 145 146

	for (i = 0; i < ARRAY_SIZE(cfg_params); i++) {
		ret = of_property_read_u32(np, cfg_params[i].property, &val);
		if (!ret) {
			config = TEGRA_PINCONF_PACK(cfg_params[i].param, val);
147 148
			ret = pinctrl_utils_add_config(pctldev, &configs,
					&num_configs, config);
149 150
			if (ret < 0)
				goto exit;
151 152 153 154
		/* EINVAL=missing, which is fine since it's optional */
		} else if (ret != -EINVAL) {
			dev_err(dev, "could not parse property %s\n",
				cfg_params[i].property);
155 156 157 158 159 160 161 162 163
		}
	}

	reserve = 0;
	if (function != NULL)
		reserve++;
	if (num_configs)
		reserve++;
	ret = of_property_count_strings(np, "nvidia,pins");
164 165
	if (ret < 0) {
		dev_err(dev, "could not parse property nvidia,pins\n");
166
		goto exit;
167
	}
168 169
	reserve *= ret;

170 171
	ret = pinctrl_utils_reserve_map(pctldev, map, reserved_maps,
					num_maps, reserve);
172 173 174 175 176
	if (ret < 0)
		goto exit;

	of_property_for_each_string(np, "nvidia,pins", prop, group) {
		if (function) {
177 178 179
			ret = pinctrl_utils_add_map_mux(pctldev, map,
					reserved_maps, num_maps, group,
					function);
180 181 182 183 184
			if (ret < 0)
				goto exit;
		}

		if (num_configs) {
185 186 187 188
			ret = pinctrl_utils_add_map_configs(pctldev, map,
					reserved_maps, num_maps, group,
					configs, num_configs,
					PIN_MAP_TYPE_CONFIGS_GROUP);
189 190 191 192 193 194 195 196 197 198 199 200
			if (ret < 0)
				goto exit;
		}
	}

	ret = 0;

exit:
	kfree(configs);
	return ret;
}

201 202 203 204
static int tegra_pinctrl_dt_node_to_map(struct pinctrl_dev *pctldev,
					struct device_node *np_config,
					struct pinctrl_map **map,
					unsigned *num_maps)
205 206 207 208 209 210 211 212 213 214
{
	unsigned reserved_maps;
	struct device_node *np;
	int ret;

	reserved_maps = 0;
	*map = NULL;
	*num_maps = 0;

	for_each_child_of_node(np_config, np) {
215
		ret = tegra_pinctrl_dt_subnode_to_map(pctldev, np, map,
216
						      &reserved_maps, num_maps);
217
		if (ret < 0) {
218 219
			pinctrl_utils_dt_free_map(pctldev, *map,
				*num_maps);
220 221 222 223 224 225 226
			return ret;
		}
	}

	return 0;
}

227
static const struct pinctrl_ops tegra_pinctrl_ops = {
228
	.get_groups_count = tegra_pinctrl_get_groups_count,
229 230
	.get_group_name = tegra_pinctrl_get_group_name,
	.get_group_pins = tegra_pinctrl_get_group_pins,
231
#ifdef CONFIG_DEBUG_FS
232
	.pin_dbg_show = tegra_pinctrl_pin_dbg_show,
233
#endif
234
	.dt_node_to_map = tegra_pinctrl_dt_node_to_map,
235
	.dt_free_map = pinctrl_utils_dt_free_map,
236 237
};

238
static int tegra_pinctrl_get_funcs_count(struct pinctrl_dev *pctldev)
239 240 241
{
	struct tegra_pmx *pmx = pinctrl_dev_get_drvdata(pctldev);

242
	return pmx->soc->nfunctions;
243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265
}

static const char *tegra_pinctrl_get_func_name(struct pinctrl_dev *pctldev,
					       unsigned function)
{
	struct tegra_pmx *pmx = pinctrl_dev_get_drvdata(pctldev);

	return pmx->soc->functions[function].name;
}

static int tegra_pinctrl_get_func_groups(struct pinctrl_dev *pctldev,
					 unsigned function,
					 const char * const **groups,
					 unsigned * const num_groups)
{
	struct tegra_pmx *pmx = pinctrl_dev_get_drvdata(pctldev);

	*groups = pmx->soc->functions[function].groups;
	*num_groups = pmx->soc->functions[function].ngroups;

	return 0;
}

266 267 268
static int tegra_pinctrl_set_mux(struct pinctrl_dev *pctldev,
				 unsigned function,
				 unsigned group)
269 270 271 272 273 274 275 276
{
	struct tegra_pmx *pmx = pinctrl_dev_get_drvdata(pctldev);
	const struct tegra_pingroup *g;
	int i;
	u32 val;

	g = &pmx->soc->groups[group];

277
	if (WARN_ON(g->mux_reg < 0))
278 279 280 281 282 283
		return -EINVAL;

	for (i = 0; i < ARRAY_SIZE(g->funcs); i++) {
		if (g->funcs[i] == function)
			break;
	}
284
	if (WARN_ON(i == ARRAY_SIZE(g->funcs)))
285 286 287 288 289 290 291 292 293 294
		return -EINVAL;

	val = pmx_readl(pmx, g->mux_bank, g->mux_reg);
	val &= ~(0x3 << g->mux_bit);
	val |= i << g->mux_bit;
	pmx_writel(pmx, val, g->mux_bank, g->mux_reg);

	return 0;
}

295
static const struct pinmux_ops tegra_pinmux_ops = {
296
	.get_functions_count = tegra_pinctrl_get_funcs_count,
297 298
	.get_function_name = tegra_pinctrl_get_func_name,
	.get_function_groups = tegra_pinctrl_get_func_groups,
299
	.set_mux = tegra_pinctrl_set_mux,
300 301 302 303 304
};

static int tegra_pinconf_reg(struct tegra_pmx *pmx,
			     const struct tegra_pingroup *g,
			     enum tegra_pinconf_param param,
305
			     bool report_err,
306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321
			     s8 *bank, s16 *reg, s8 *bit, s8 *width)
{
	switch (param) {
	case TEGRA_PINCONF_PARAM_PULL:
		*bank = g->pupd_bank;
		*reg = g->pupd_reg;
		*bit = g->pupd_bit;
		*width = 2;
		break;
	case TEGRA_PINCONF_PARAM_TRISTATE:
		*bank = g->tri_bank;
		*reg = g->tri_reg;
		*bit = g->tri_bit;
		*width = 1;
		break;
	case TEGRA_PINCONF_PARAM_ENABLE_INPUT:
322 323
		*bank = g->mux_bank;
		*reg = g->mux_reg;
324 325 326 327
		*bit = g->einput_bit;
		*width = 1;
		break;
	case TEGRA_PINCONF_PARAM_OPEN_DRAIN:
328 329
		*bank = g->mux_bank;
		*reg = g->mux_reg;
330 331 332 333
		*bit = g->odrain_bit;
		*width = 1;
		break;
	case TEGRA_PINCONF_PARAM_LOCK:
334 335
		*bank = g->mux_bank;
		*reg = g->mux_reg;
336 337 338 339
		*bit = g->lock_bit;
		*width = 1;
		break;
	case TEGRA_PINCONF_PARAM_IORESET:
340 341
		*bank = g->mux_bank;
		*reg = g->mux_reg;
342 343 344
		*bit = g->ioreset_bit;
		*width = 1;
		break;
345
	case TEGRA_PINCONF_PARAM_RCV_SEL:
346 347
		*bank = g->mux_bank;
		*reg = g->mux_reg;
348 349 350
		*bit = g->rcv_sel_bit;
		*width = 1;
		break;
351
	case TEGRA_PINCONF_PARAM_HIGH_SPEED_MODE:
352 353 354 355 356 357 358
		if (pmx->soc->hsm_in_mux) {
			*bank = g->mux_bank;
			*reg = g->mux_reg;
		} else {
			*bank = g->drv_bank;
			*reg = g->drv_reg;
		}
359 360 361 362
		*bit = g->hsm_bit;
		*width = 1;
		break;
	case TEGRA_PINCONF_PARAM_SCHMITT:
363 364 365 366 367 368 369
		if (pmx->soc->schmitt_in_mux) {
			*bank = g->mux_bank;
			*reg = g->mux_reg;
		} else {
			*bank = g->drv_bank;
			*reg = g->drv_reg;
		}
370 371 372 373 374 375 376
		*bit = g->schmitt_bit;
		*width = 1;
		break;
	case TEGRA_PINCONF_PARAM_LOW_POWER_MODE:
		*bank = g->drv_bank;
		*reg = g->drv_reg;
		*bit = g->lpmd_bit;
377
		*width = 2;
378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402
		break;
	case TEGRA_PINCONF_PARAM_DRIVE_DOWN_STRENGTH:
		*bank = g->drv_bank;
		*reg = g->drv_reg;
		*bit = g->drvdn_bit;
		*width = g->drvdn_width;
		break;
	case TEGRA_PINCONF_PARAM_DRIVE_UP_STRENGTH:
		*bank = g->drv_bank;
		*reg = g->drv_reg;
		*bit = g->drvup_bit;
		*width = g->drvup_width;
		break;
	case TEGRA_PINCONF_PARAM_SLEW_RATE_FALLING:
		*bank = g->drv_bank;
		*reg = g->drv_reg;
		*bit = g->slwf_bit;
		*width = g->slwf_width;
		break;
	case TEGRA_PINCONF_PARAM_SLEW_RATE_RISING:
		*bank = g->drv_bank;
		*reg = g->drv_reg;
		*bit = g->slwr_bit;
		*width = g->slwr_width;
		break;
403
	case TEGRA_PINCONF_PARAM_DRIVE_TYPE:
404 405 406 407 408 409 410
		if (pmx->soc->drvtype_in_mux) {
			*bank = g->mux_bank;
			*reg = g->mux_reg;
		} else {
			*bank = g->drv_bank;
			*reg = g->drv_reg;
		}
411 412 413
		*bit = g->drvtype_bit;
		*width = 2;
		break;
414 415 416 417 418
	default:
		dev_err(pmx->dev, "Invalid config param %04x\n", param);
		return -ENOTSUPP;
	}

419
	if (*reg < 0 || *bit > 31) {
420 421 422 423 424 425 426 427 428 429 430
		if (report_err) {
			const char *prop = "unknown";
			int i;

			for (i = 0; i < ARRAY_SIZE(cfg_params); i++) {
				if (cfg_params[i].param == param) {
					prop = cfg_params[i].property;
					break;
				}
			}

431
			dev_err(pmx->dev,
432 433 434
				"Config param %04x (%s) not supported on group %s\n",
				param, prop, g->name);
		}
435 436 437 438 439 440 441 442 443
		return -ENOTSUPP;
	}

	return 0;
}

static int tegra_pinconf_get(struct pinctrl_dev *pctldev,
			     unsigned pin, unsigned long *config)
{
444
	dev_err(pctldev->dev, "pin_config_get op not supported\n");
445 446 447 448
	return -ENOTSUPP;
}

static int tegra_pinconf_set(struct pinctrl_dev *pctldev,
449 450
			     unsigned pin, unsigned long *configs,
			     unsigned num_configs)
451
{
452
	dev_err(pctldev->dev, "pin_config_set op not supported\n");
453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469
	return -ENOTSUPP;
}

static int tegra_pinconf_group_get(struct pinctrl_dev *pctldev,
				   unsigned group, unsigned long *config)
{
	struct tegra_pmx *pmx = pinctrl_dev_get_drvdata(pctldev);
	enum tegra_pinconf_param param = TEGRA_PINCONF_UNPACK_PARAM(*config);
	u16 arg;
	const struct tegra_pingroup *g;
	int ret;
	s8 bank, bit, width;
	s16 reg;
	u32 val, mask;

	g = &pmx->soc->groups[group];

470 471
	ret = tegra_pinconf_reg(pmx, g, param, true, &bank, &reg, &bit,
				&width);
472 473 474 475 476 477 478 479 480 481 482 483 484
	if (ret < 0)
		return ret;

	val = pmx_readl(pmx, bank, reg);
	mask = (1 << width) - 1;
	arg = (val >> bit) & mask;

	*config = TEGRA_PINCONF_PACK(param, arg);

	return 0;
}

static int tegra_pinconf_group_set(struct pinctrl_dev *pctldev,
485 486
				   unsigned group, unsigned long *configs,
				   unsigned num_configs)
487 488
{
	struct tegra_pmx *pmx = pinctrl_dev_get_drvdata(pctldev);
489 490
	enum tegra_pinconf_param param;
	u16 arg;
491
	const struct tegra_pingroup *g;
492
	int ret, i;
493 494 495 496 497 498
	s8 bank, bit, width;
	s16 reg;
	u32 val, mask;

	g = &pmx->soc->groups[group];

499 500 501
	for (i = 0; i < num_configs; i++) {
		param = TEGRA_PINCONF_UNPACK_PARAM(configs[i]);
		arg = TEGRA_PINCONF_UNPACK_ARG(configs[i]);
502

503 504 505 506
		ret = tegra_pinconf_reg(pmx, g, param, true, &bank, &reg, &bit,
					&width);
		if (ret < 0)
			return ret;
507

508 509 510 511 512 513 514 515
		val = pmx_readl(pmx, bank, reg);

		/* LOCK can't be cleared */
		if (param == TEGRA_PINCONF_PARAM_LOCK) {
			if ((val & BIT(bit)) && !arg) {
				dev_err(pctldev->dev, "LOCK bit cannot be cleared\n");
				return -EINVAL;
			}
516
		}
517

518 519 520
		/* Special-case Boolean values; allow any non-zero as true */
		if (width == 1)
			arg = !!arg;
521

522 523 524 525 526 527 528 529
		/* Range-check user-supplied value */
		mask = (1 << width) - 1;
		if (arg & ~mask) {
			dev_err(pctldev->dev,
				"config %lx: %x too big for %d bit register\n",
				configs[i], arg, width);
			return -EINVAL;
		}
530

531 532 533 534 535
		/* Update register */
		val &= ~(mask << bit);
		val |= arg << bit;
		pmx_writel(pmx, val, bank, reg);
	} /* for each config */
536 537 538 539

	return 0;
}

540
#ifdef CONFIG_DEBUG_FS
541 542 543 544 545
static void tegra_pinconf_dbg_show(struct pinctrl_dev *pctldev,
				   struct seq_file *s, unsigned offset)
{
}

546 547 548 549 550 551 552 553 554
static const char *strip_prefix(const char *s)
{
	const char *comma = strchr(s, ',');
	if (!comma)
		return s;

	return comma + 1;
}

555
static void tegra_pinconf_group_dbg_show(struct pinctrl_dev *pctldev,
556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584
					 struct seq_file *s, unsigned group)
{
	struct tegra_pmx *pmx = pinctrl_dev_get_drvdata(pctldev);
	const struct tegra_pingroup *g;
	int i, ret;
	s8 bank, bit, width;
	s16 reg;
	u32 val;

	g = &pmx->soc->groups[group];

	for (i = 0; i < ARRAY_SIZE(cfg_params); i++) {
		ret = tegra_pinconf_reg(pmx, g, cfg_params[i].param, false,
					&bank, &reg, &bit, &width);
		if (ret < 0)
			continue;

		val = pmx_readl(pmx, bank, reg);
		val >>= bit;
		val &= (1 << width) - 1;

		seq_printf(s, "\n\t%s=%u",
			   strip_prefix(cfg_params[i].property), val);
	}
}

static void tegra_pinconf_config_dbg_show(struct pinctrl_dev *pctldev,
					  struct seq_file *s,
					  unsigned long config)
585
{
586 587 588 589 590 591 592 593 594 595 596 597 598
	enum tegra_pinconf_param param = TEGRA_PINCONF_UNPACK_PARAM(config);
	u16 arg = TEGRA_PINCONF_UNPACK_ARG(config);
	const char *pname = "unknown";
	int i;

	for (i = 0; i < ARRAY_SIZE(cfg_params); i++) {
		if (cfg_params[i].param == param) {
			pname = cfg_params[i].property;
			break;
		}
	}

	seq_printf(s, "%s=%d", strip_prefix(pname), arg);
599
}
600
#endif
601

602
static const struct pinconf_ops tegra_pinconf_ops = {
603 604 605 606
	.pin_config_get = tegra_pinconf_get,
	.pin_config_set = tegra_pinconf_set,
	.pin_config_group_get = tegra_pinconf_group_get,
	.pin_config_group_set = tegra_pinconf_group_set,
607
#ifdef CONFIG_DEBUG_FS
608 609
	.pin_config_dbg_show = tegra_pinconf_dbg_show,
	.pin_config_group_dbg_show = tegra_pinconf_group_dbg_show,
610 611
	.pin_config_config_dbg_show = tegra_pinconf_config_dbg_show,
#endif
612 613 614 615 616 617 618 619 620 621 622 623 624 625 626
};

static struct pinctrl_gpio_range tegra_pinctrl_gpio_range = {
	.name = "Tegra GPIOs",
	.id = 0,
	.base = 0,
};

static struct pinctrl_desc tegra_pinctrl_desc = {
	.pctlops = &tegra_pinctrl_ops,
	.pmxops = &tegra_pinmux_ops,
	.confops = &tegra_pinconf_ops,
	.owner = THIS_MODULE,
};

627
int tegra_pinctrl_probe(struct platform_device *pdev,
628
			const struct tegra_pinctrl_soc_data *soc_data)
629 630 631 632
{
	struct tegra_pmx *pmx;
	struct resource *res;
	int i;
633 634
	const char **group_pins;
	int fn, gn, gfn;
635 636 637 638 639 640 641

	pmx = devm_kzalloc(&pdev->dev, sizeof(*pmx), GFP_KERNEL);
	if (!pmx) {
		dev_err(&pdev->dev, "Can't alloc tegra_pmx\n");
		return -ENOMEM;
	}
	pmx->dev = &pdev->dev;
642
	pmx->soc = soc_data;
643

644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678
	/*
	 * Each mux group will appear in 4 functions' list of groups.
	 * This over-allocates slightly, since not all groups are mux groups.
	 */
	pmx->group_pins = devm_kzalloc(&pdev->dev,
		soc_data->ngroups * 4 * sizeof(*pmx->group_pins),
		GFP_KERNEL);
	if (!pmx->group_pins)
		return -ENOMEM;

	group_pins = pmx->group_pins;
	for (fn = 0; fn < soc_data->nfunctions; fn++) {
		struct tegra_function *func = &soc_data->functions[fn];

		func->groups = group_pins;

		for (gn = 0; gn < soc_data->ngroups; gn++) {
			const struct tegra_pingroup *g = &soc_data->groups[gn];

			if (g->mux_reg == -1)
				continue;

			for (gfn = 0; gfn < 4; gfn++)
				if (g->funcs[gfn] == fn)
					break;
			if (gfn == 4)
				continue;

			BUG_ON(group_pins - pmx->group_pins >=
				soc_data->ngroups * 4);
			*group_pins++ = g->name;
			func->ngroups++;
		}
	}

679
	tegra_pinctrl_gpio_range.npins = pmx->soc->ngpios;
680
	tegra_pinctrl_desc.name = dev_name(&pdev->dev);
681 682 683 684 685 686 687 688 689 690 691 692 693 694
	tegra_pinctrl_desc.pins = pmx->soc->pins;
	tegra_pinctrl_desc.npins = pmx->soc->npins;

	for (i = 0; ; i++) {
		res = platform_get_resource(pdev, IORESOURCE_MEM, i);
		if (!res)
			break;
	}
	pmx->nbanks = i;

	pmx->regs = devm_kzalloc(&pdev->dev, pmx->nbanks * sizeof(*pmx->regs),
				 GFP_KERNEL);
	if (!pmx->regs) {
		dev_err(&pdev->dev, "Can't alloc regs pointer\n");
695
		return -ENOMEM;
696 697 698 699
	}

	for (i = 0; i < pmx->nbanks; i++) {
		res = platform_get_resource(pdev, IORESOURCE_MEM, i);
700 701 702
		pmx->regs[i] = devm_ioremap_resource(&pdev->dev, res);
		if (IS_ERR(pmx->regs[i]))
			return PTR_ERR(pmx->regs[i]);
703 704 705
	}

	pmx->pctl = pinctrl_register(&tegra_pinctrl_desc, &pdev->dev, pmx);
706
	if (!pmx->pctl) {
707
		dev_err(&pdev->dev, "Couldn't register pinctrl driver\n");
708
		return -ENODEV;
709 710 711 712 713 714 715 716 717 718
	}

	pinctrl_add_gpio_range(pmx->pctl, &tegra_pinctrl_gpio_range);

	platform_set_drvdata(pdev, pmx);

	dev_dbg(&pdev->dev, "Probed Tegra pinctrl driver\n");

	return 0;
}
719
EXPORT_SYMBOL_GPL(tegra_pinctrl_probe);
720

B
Bill Pemberton 已提交
721
int tegra_pinctrl_remove(struct platform_device *pdev)
722 723 724 725 726 727 728
{
	struct tegra_pmx *pmx = platform_get_drvdata(pdev);

	pinctrl_unregister(pmx->pctl);

	return 0;
}
729
EXPORT_SYMBOL_GPL(tegra_pinctrl_remove);