Release 4.9 arch/arm/mach-omap2/mux.c

/*
 * linux/arch/arm/mach-omap2/mux.c
 *
 * OMAP2, OMAP3 and OMAP4 pin multiplexing configurations
 *
 * Copyright (C) 2004 - 2010 Texas Instruments Inc.
 * Copyright (C) 2003 - 2008 Nokia Corporation
 *
 * Written by Tony Lindgren
 *
 * 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.
 *
 * This program is distributed in the hope that 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
 */
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/io.h>
#include <linux/list.h>
#include <linux/slab.h>
#include <linux/ctype.h>
#include <linux/debugfs.h>
#include <linux/seq_file.h>
#include <linux/uaccess.h>
#include <linux/irq.h>
#include <linux/interrupt.h>


#include "omap_hwmod.h"

#include "soc.h"
#include "control.h"
#include "mux.h"
#include "prm.h"
#include "common.h"


#define OMAP_MUX_BASE_OFFSET		0x30	
/* Offset from CTRL_BASE */

#define OMAP_MUX_BASE_SZ		0x5ca


struct omap_mux_entry {
	
struct omap_mux		mux;
	
struct list_head	node;
};

static LIST_HEAD(mux_partitions);
static DEFINE_MUTEX(muxmode_mutex);



struct omap_mux_partition *omap_mux_get(const char *name)
{
	struct omap_mux_partition *partition;

	list_for_each_entry(partition, &mux_partitions, node) {
		if (!strcmp(name, partition->name))
			return partition;
	}

	return NULL;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
benoit cousson
benoit cousson
43
95.56%
1
33.33%
tony lindgren
tony lindgren
2
4.44%
2
66.67%
Total
45
100.00%
3
100.00%



u16 omap_mux_read(struct omap_mux_partition *partition, u16 reg)
{
	if (partition->flags & OMAP_MUX_REG_8BIT)
		return readb_relaxed(partition->base + reg);
	else
		return readw_relaxed(partition->base + reg);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
tony lindgren
tony lindgren
18
42.86%
2
40.00%
benoit cousson
benoit cousson
16
38.10%
1
20.00%
vikram pandita
vikram pandita
6
14.29%
1
20.00%
victor kamensky
victor kamensky
2
4.76%
1
20.00%
Total
42
100.00%
5
100.00%



void omap_mux_write(struct omap_mux_partition *partition, u16 val,
			   u16 reg)
{
	if (partition->flags & OMAP_MUX_REG_8BIT)
		writeb_relaxed(val, partition->base + reg);
	else
		writew_relaxed(val, partition->base + reg);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
tony lindgren
tony lindgren
19
40.43%
3
50.00%
benoit cousson
benoit cousson
16
34.04%
1
16.67%
mike rapoport
mike rapoport
10
21.28%
1
16.67%
victor kamensky
victor kamensky
2
4.26%
1
16.67%
Total
47
100.00%
6
100.00%



void omap_mux_write_array(struct omap_mux_partition *partition,
				 struct omap_board_mux *board_mux)
{
	if (!board_mux)
		return;

	while (board_mux->reg_offset != OMAP_MUX_TERMINATOR) {
		omap_mux_write(partition, board_mux->value,
			       board_mux->reg_offset);
		board_mux++;
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
tony lindgren
tony lindgren
34
72.34%
3
60.00%
benoit cousson
benoit cousson
7
14.89%
1
20.00%
colin cross
colin cross
6
12.77%
1
20.00%
Total
47
100.00%
5
100.00%

#ifdef CONFIG_OMAP_MUX


static char *omap_mux_options;



static int __init _omap_mux_init_gpio(struct omap_mux_partition *partition,
				      int gpio, int val)
{
	struct omap_mux_entry *e;
	struct omap_mux *gpio_mux = NULL;
	u16 old_mode;
	u16 mux_mode;
	int found = 0;
	struct list_head *muxmodes = &partition->muxmodes;

	if (!gpio)
		return -EINVAL;

	list_for_each_entry(e, muxmodes, node) {
		struct omap_mux *m = &e->mux;
		if (gpio == m->gpio) {
			gpio_mux = m;
			found++;
		}
	}

	if (found == 0) {
		pr_err("%s: Could not set gpio%i\n", __func__, gpio);
		return -ENODEV;
	}

	if (found > 1) {
		pr_info("%s: Multiple gpio paths (%d) for gpio%i\n", __func__,
			found, gpio);
		return -EINVAL;
	}

	old_mode = omap_mux_read(partition, gpio_mux->reg_offset);
	mux_mode = val & ~(OMAP_MUX_NR_MODES - 1);
	mux_mode |= partition->gpio;
	pr_debug("%s: Setting signal %s.gpio%i 0x%04x -> 0x%04x\n", __func__,
		 gpio_mux->muxnames[0], gpio, old_mode, mux_mode);
	omap_mux_write(partition, mux_mode, gpio_mux->reg_offset);

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
tony lindgren
tony lindgren
105
51.72%
3
33.33%
grazvydas ignotas
grazvydas ignotas
59
29.06%
1
11.11%
benoit cousson
benoit cousson
25
12.32%
2
22.22%
dan murphy
dan murphy
9
4.43%
1
11.11%
oleg matcovschi
oleg matcovschi
3
1.48%
1
11.11%
sanjeev premi
sanjeev premi
2
0.99%
1
11.11%
Total
203
100.00%
9
100.00%



int __init omap_mux_init_gpio(int gpio, int val)
{
	struct omap_mux_partition *partition;
	int ret;

	list_for_each_entry(partition, &mux_partitions, node) {
		ret = _omap_mux_init_gpio(partition, gpio, val);
		if (!ret)
			return ret;
	}

	return -ENODEV;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
benoit cousson
benoit cousson
51
96.23%
1
33.33%
tony lindgren
tony lindgren
2
3.77%
2
66.67%
Total
53
100.00%
3
100.00%



static int __init _omap_mux_get_by_name(struct omap_mux_partition *partition,
					const char *muxname,
					struct omap_mux **found_mux)
{
	struct omap_mux *mux = NULL;
	struct omap_mux_entry *e;
	const char *mode_name;
	int found = 0, found_mode = 0, mode0_len = 0;
	struct list_head *muxmodes = &partition->muxmodes;

	mode_name = strchr(muxname, '.');
	if (mode_name) {
		mode0_len = strlen(muxname) - strlen(mode_name);
		mode_name++;
	} else {
		mode_name = muxname;
	}

	list_for_each_entry(e, muxmodes, node) {
		char *m0_entry;
		int i;

		mux = &e->mux;
		m0_entry = mux->muxnames[0];

		/* First check for full name in mode0.muxmode format */
		if (mode0_len)
			if (strncmp(muxname, m0_entry, mode0_len) ||
			    (strlen(m0_entry) != mode0_len))
				continue;

		/* Then check for muxmode only */
		for (i = 0; i < OMAP_MUX_NR_MODES; i++) {
			char *mode_cur = mux->muxnames[i];

			if (!mode_cur)
				continue;

			if (!strcmp(mode_name, mode_cur)) {
				*found_mux = mux;
				found++;
				found_mode = i;
			}
		}
	}

	if (found == 1) {
		return found_mode;
	}

	if (found > 1) {
		pr_err("%s: Multiple signal paths (%i) for %s\n", __func__,
		       found, muxname);
		return -EINVAL;
	}

	return -ENODEV;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
tony lindgren
tony lindgren
218
85.83%
4
44.44%
benoit cousson
benoit cousson
19
7.48%
2
22.22%
david r. piegdon
david r. piegdon
12
4.72%
1
11.11%
dan murphy
dan murphy
3
1.18%
1
11.11%
felipe balbi
felipe balbi
2
0.79%
1
11.11%
Total
254
100.00%
9
100.00%



int __init omap_mux_get_by_name(const char *muxname,
			struct omap_mux_partition **found_partition,
			struct omap_mux **found_mux)
{
	struct omap_mux_partition *partition;

	list_for_each_entry(partition, &mux_partitions, node) {
		struct omap_mux *mux = NULL;
		int mux_mode = _omap_mux_get_by_name(partition, muxname, &mux);
		if (mux_mode < 0)
			continue;

		*found_partition = partition;
		*found_mux = mux;

		return mux_mode;
	}

	pr_err("%s: Could not find signal %s\n", __func__, muxname);

	return -ENODEV;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
tony lindgren
tony lindgren
42
46.15%
2
50.00%
benoit cousson
benoit cousson
40
43.96%
1
25.00%
ruslan bilovol
ruslan bilovol
9
9.89%
1
25.00%
Total
91
100.00%
4
100.00%



int __init omap_mux_init_signal(const char *muxname, int val)
{
	struct omap_mux_partition *partition = NULL;
	struct omap_mux *mux = NULL;
	u16 old_mode;
	int mux_mode;

	mux_mode = omap_mux_get_by_name(muxname, &partition, &mux);
	if (mux_mode < 0 || !mux)
		return mux_mode;

	old_mode = omap_mux_read(partition, mux->reg_offset);
	mux_mode |= val;
	pr_debug("%s: Setting signal %s 0x%04x -> 0x%04x\n",
			 __func__, muxname, old_mode, mux_mode);
	omap_mux_write(partition, mux_mode, mux->reg_offset);

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
tony lindgren
tony lindgren
98
97.03%
2
66.67%
paul walmsley
paul walmsley
3
2.97%
1
33.33%
Total
101
100.00%
3
100.00%


struct omap_hwmod_mux_info * __init

omap_hwmod_mux_init(struct omap_device_pad *bpads, int nr_pads)
{
	struct omap_hwmod_mux_info *hmux;
	int i, nr_pads_dynamic = 0;

	if (!bpads || nr_pads < 1)
		return NULL;

	hmux = kzalloc(sizeof(struct omap_hwmod_mux_info), GFP_KERNEL);
	if (!hmux)
		goto err1;

	hmux->nr_pads = nr_pads;

	hmux->pads = kzalloc(sizeof(struct omap_device_pad) *
				nr_pads, GFP_KERNEL);
	if (!hmux->pads)
		goto err2;

	for (i = 0; i < hmux->nr_pads; i++) {
		struct omap_mux_partition *partition;
		struct omap_device_pad *bpad = &bpads[i], *pad = &hmux->pads[i];
		struct omap_mux *mux;
		int mux_mode;

		mux_mode = omap_mux_get_by_name(bpad->name, &partition, &mux);
		if (mux_mode < 0)
			goto err3;
		if (!pad->partition)
			pad->partition = partition;
		if (!pad->mux)
			pad->mux = mux;

		pad->name = kzalloc(strlen(bpad->name) + 1, GFP_KERNEL);
		if (!pad->name) {
			int j;

			for (j = i - 1; j >= 0; j--)
				kfree(hmux->pads[j].name);
			goto err3;
		}
		strcpy(pad->name, bpad->name);

		pad->flags = bpad->flags;
		pad->enable = bpad->enable;
		pad->idle = bpad->idle;
		pad->off = bpad->off;

		if (pad->flags &
		    (OMAP_DEVICE_PAD_REMUX | OMAP_DEVICE_PAD_WAKEUP))
			nr_pads_dynamic++;

		pr_debug("%s: Initialized %s\n", __func__, pad->name);
	}

	if (!nr_pads_dynamic)
		return hmux;

	/*
         * Add pads that need dynamic muxing into a separate list
         */

	hmux->nr_pads_dynamic = nr_pads_dynamic;
	hmux->pads_dynamic = kzalloc(sizeof(struct omap_device_pad *) *
					nr_pads_dynamic, GFP_KERNEL);
	if (!hmux->pads_dynamic) {
		pr_err("%s: Could not allocate dynamic pads\n", __func__);
		return hmux;
	}

	nr_pads_dynamic = 0;
	for (i = 0; i < hmux->nr_pads; i++) {
		struct omap_device_pad *pad = &hmux->pads[i];

		if (pad->flags &
		    (OMAP_DEVICE_PAD_REMUX | OMAP_DEVICE_PAD_WAKEUP)) {
			pr_debug("%s: pad %s tagged dynamic\n",
					__func__, pad->name);
			hmux->pads_dynamic[nr_pads_dynamic] = pad;
			nr_pads_dynamic++;
		}
	}

	return hmux;

err3:
	kfree(hmux->pads);
err2:
	kfree(hmux);
err1:
	pr_err("%s: Could not allocate device mux entry\n", __func__);

	return NULL;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
tony lindgren
tony lindgren
471
98.33%
2
66.67%
paul walmsley
paul walmsley
8
1.67%
1
33.33%
Total
479
100.00%
3
100.00%

/**
 * omap_hwmod_mux_scan_wakeups - omap hwmod scan wakeup pads
 * @hmux: Pads for a hwmod
 * @mpu_irqs: MPU irq array for a hwmod
 *
 * Scans the wakeup status of pads for a single hwmod.  If an irq
 * array is defined for this mux, the parser will call the registered
 * ISRs for corresponding pads, otherwise the parser will stop at the
 * first wakeup active pad and return.  Returns true if there is a
 * pending and non-served wakeup event for the mux, otherwise false.
 */


static bool omap_hwmod_mux_scan_wakeups(struct omap_hwmod_mux_info *hmux,
		struct omap_hwmod_irq_info *mpu_irqs)
{
	int i, irq;
	unsigned int val;
	u32 handled_irqs = 0;

	for (i = 0; i < hmux->nr_pads_dynamic; i++) {
		struct omap_device_pad *pad = hmux->pads_dynamic[i];

		if (!(pad->flags & OMAP_DEVICE_PAD_WAKEUP) ||
		    !(pad->idle & OMAP_WAKEUP_EN))
			continue;

		val = omap_mux_read(pad->partition, pad->mux->reg_offset);
		if (!(val & OMAP_WAKEUP_EVENT))
			continue;

		if (!hmux->irqs)
			return true;

		irq = hmux->irqs[i];
		/* make sure we only handle each irq once */
		if (handled_irqs & 1 << irq)
			continue;

		handled_irqs |= 1 << irq;

		generic_handle_irq(mpu_irqs[irq].irq);
	}

	return false;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
tero kristo
tero kristo
153
100.00%
1
100.00%
Total
153
100.00%
1
100.00%

/**
 * _omap_hwmod_mux_handle_irq - Process wakeup events for a single hwmod
 *
 * Checks a single hwmod for every wakeup capable pad to see if there is an
 * active wakeup event. If this is the case, call the corresponding ISR.
 */


static int _omap_hwmod_mux_handle_irq(struct omap_hwmod *oh, void *data)
{
	if (!oh->mux || !oh->mux->enabled)
		return 0;
	if (omap_hwmod_mux_scan_wakeups(oh->mux, oh->mpu_irqs))
		generic_handle_irq(oh->mpu_irqs[0].irq);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
tero kristo
tero kristo
60
100.00%
1
100.00%
Total
60
100.00%
1
100.00%

/**
 * omap_hwmod_mux_handle_irq - Process pad wakeup irqs.
 *
 * Calls a function for each registered omap_hwmod to check
 * pad wakeup statuses.
 */


static irqreturn_t omap_hwmod_mux_handle_irq(int irq, void *unused)
{
	omap_hwmod_for_each(_omap_hwmod_mux_handle_irq, NULL);
	return IRQ_HANDLED;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
tero kristo
tero kristo
23
100.00%
1
100.00%
Total
23
100.00%
1
100.00%

/* Assumes the calling function takes care of locking */


void omap_hwmod_mux(struct omap_hwmod_mux_info *hmux, u8 state)
{
	int i;

	/* Runtime idling of dynamic pads */
	if (state == _HWMOD_STATE_IDLE && hmux->enabled) {
		for (i = 0; i < hmux->nr_pads_dynamic; i++) {
			struct omap_device_pad *pad = hmux->pads_dynamic[i];
			int val = -EINVAL;

			val = pad->idle;
			omap_mux_write(pad->partition, val,
					pad->mux->reg_offset);
		}

		return;
	}

	/* Runtime enabling of dynamic pads */
	if ((state == _HWMOD_STATE_ENABLED) && hmux->pads_dynamic
					&& hmux->enabled) {
		for (i = 0; i < hmux->nr_pads_dynamic; i++) {
			struct omap_device_pad *pad = hmux->pads_dynamic[i];
			int val = -EINVAL;

			val = pad->enable;
			omap_mux_write(pad->partition, val,
					pad->mux->reg_offset);
		}

		return;
	}

	/* Enabling or disabling of all pads */
	for (i = 0; i < hmux->nr_pads; i++) {
		struct omap_device_pad *pad = &hmux->pads[i];
		int flags, val = -EINVAL;

		flags = pad->flags;

		switch (state) {
		case _HWMOD_STATE_ENABLED:
			val = pad->enable;
			pr_debug("%s: Enabling %s %x\n", __func__,
					pad->name, val);
			break;
		case _HWMOD_STATE_DISABLED:
			/* Use safe mode unless OMAP_DEVICE_PAD_REMUX */
			if (flags & OMAP_DEVICE_PAD_REMUX)
				val = pad->off;
			else
				val = OMAP_MUX_MODE7;
			pr_debug("%s: Disabling %s %x\n", __func__,
					pad->name, val);
			break;
		default:
			/* Nothing to be done */
			break;
		}

		if (val >= 0) {
			omap_mux_write(pad->partition, val,
					pad->mux->reg_offset);
			pad->flags = flags;
		}
	}

	if (state == _HWMOD_STATE_ENABLED)
		hmux->enabled = true;
	else
		hmux->enabled = false;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
tony lindgren
tony lindgren
314
97.52%
2
66.67%
r sricharan
r sricharan
8
2.48%
1
33.33%
Total
322
100.00%
3
100.00%

#ifdef CONFIG_DEBUG_FS


#define OMAP_MUX_MAX_NR_FLAGS	10

#define OMAP_MUX_TEST_FLAG(val, mask)				\
	if (((val) & (mask)) == (mask)) {                       \
                i++;                                            \
                flags[i] =  #mask;                              \
        }

/* REVISIT: Add checking for non-optimal mux settings */


static inline void omap_mux_decode(struct seq_file *s, u16 val)
{
	char *flags[OMAP_MUX_MAX_NR_FLAGS];
	char mode[sizeof("OMAP_MUX_MODE") + 1];
	int i = -1;

	sprintf(mode, "OMAP_MUX_MODE%d", val & 0x7);
	i++;
	flags[i] = mode;

	OMAP_MUX_TEST_FLAG(val, OMAP_PIN_OFF_WAKEUPENABLE);
	if (val & OMAP_OFF_EN) {
		if (!(val & OMAP_OFFOUT_EN)) {
			if (!(val & OMAP_OFF_PULL_UP)) {
				OMAP_MUX_TEST_FLAG(val,
					OMAP_PIN_OFF_INPUT_PULLDOWN);
			} else {
				OMAP_MUX_TEST_FLAG(val,
					OMAP_PIN_OFF_INPUT_PULLUP);
			}
		} else {
			if (!(val & OMAP_OFFOUT_VAL)) {
				OMAP_MUX_TEST_FLAG(val,
					OMAP_PIN_OFF_OUTPUT_LOW);
			} else {
				OMAP_MUX_TEST_FLAG(val,
					OMAP_PIN_OFF_OUTPUT_HIGH);
			}
		}
	}

	if (val & OMAP_INPUT_EN) {
		if (val & OMAP_PULL_ENA) {
			if (!(val & OMAP_PULL_UP)) {
				OMAP_MUX_TEST_FLAG(val,
					OMAP_PIN_INPUT_PULLDOWN);
			} else {
				OMAP_MUX_TEST_FLAG(val, OMAP_PIN_INPUT_PULLUP);
			}
		} else {
			OMAP_MUX_TEST_FLAG(val, OMAP_PIN_INPUT);
		}
	} else {
		i++;
		flags[i] = "OMAP_PIN_OUTPUT";
	}

	do {
		seq_printf(s, "%s", flags[i]);
		if (i > 0)
			seq_printf(s, " | ");
	} while (i-- > 0);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
tony lindgren
tony lindgren
248
100.00%
3
100.00%
Total
248
100.00%
3
100.00%


#define OMAP_MUX_DEFNAME_LEN	32



static int omap_mux_dbg_board_show(struct seq_file *s, void *unused)
{
	struct omap_mux_partition *partition = s->private;
	struct omap_mux_entry *e;
	u8 omap_gen = omap_rev() >> 28;

	list_for_each_entry(e, &partition->muxmodes, node) {
		struct omap_mux *m = &e->mux;
		char m0_def[OMAP_MUX_DEFNAME_LEN];
		char *m0_name = m->muxnames[0];
		u16 val;
		int i, mode;

		if (!m0_name)
			continue;

		/* REVISIT: Needs to be updated if mode0 names get longer */
		for (i = 0; i < OMAP_MUX_DEFNAME_LEN; i++) {
			if (m0_name[i] == '\0') {
				m0_def[i] = m0_name[i];
				break;
			}
			m0_def[i] = toupper(m0_name[i]);
		}
		val = omap_mux_read(partition, m->reg_offset);
		mode = val & OMAP_MUX_MODE7;
		if (mode != 0)
			seq_printf(s, "/* %s */\n", m->muxnames[mode]);

		/*
                 * XXX: Might be revisited to support differences across
                 * same OMAP generation.
                 */
		seq_printf(s, "OMAP%d_MUX(%s, ", omap_gen, m0_def);
		omap_mux_decode(s, val);
		seq_printf(s, "),\n");
	}

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
tony lindgren
tony lindgren
162
79.02%
2
50.00%
benoit cousson
benoit cousson
42
20.49%
1
25.00%
lucas de marchi
lucas de marchi
1
0.49%
1
25.00%
Total
205
100.00%
4
100.00%



static int omap_mux_dbg_board_open(struct inode *inode, struct file *file)
{
	return single_open(file, omap_mux_dbg_board_show, inode->i_private);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
tony lindgren
tony lindgren
28
100.00%
1
100.00%
Total
28
100.00%
1
100.00%


static const struct file_operations omap_mux_dbg_board_fops = {
	.open		= omap_mux_dbg_board_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
};



static struct omap_mux_partition *omap_mux_get_partition(struct omap_mux *mux)
{
	struct omap_mux_partition *partition;

	list_for_each_entry(partition, &mux_partitions, node) {
		struct list_head *muxmodes = &partition->muxmodes;
		struct omap_mux_entry *e;

		list_for_each_entry(e, muxmodes, node) {
			struct omap_mux *m = &e->mux;

			if (m == mux)
				return partition;
		}
	}

	return NULL;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
benoit cousson
benoit cousson
75
100.00%
1
100.00%
Total
75
100.00%
1
100.00%



static int omap_mux_dbg_signal_show(struct seq_file *s, void *unused)
{
	struct omap_mux *m = s->private;
	struct omap_mux_partition *partition;
	const char *none = "NA";
	u16 val;
	int mode;

	partition = omap_mux_get_partition(m);
	if (!partition)
		return 0;

	val = omap_mux_read(partition, m->reg_offset);
	mode = val & OMAP_MUX_MODE7;

	seq_printf(s, "name: %s.%s (0x%08x/0x%03x = 0x%04x), b %s, t %s\n",
			m->muxnames[0], m->muxnames[mode],
			partition->phys + m->reg_offset, m->reg_offset, val,
			m->balls[0] ? m->balls[0] : none,
			m->balls[1] ? m->balls[1] : none);
	seq_printf(s, "mode: ");
	omap_mux_decode(s, val);
	seq_printf(s, "\n");
	seq_printf(s, "signals: %s | %s | %s | %s | %s | %s | %s | %s\n",
			m->muxnames[0] ? m->muxnames[0] : none,
			m->muxnames[1] ? m->muxnames[1] : none,
			m->muxnames[2] ? m->muxnames[2] : none,
			m->muxnames[3] ? m->muxnames[3] : none,
			m->muxnames[4] ? m->muxnames[4] : none,
			m->muxnames[5] ? m->muxnames[5] : none,
			m->muxnames[6] ? m->muxnames[6] : none,
			m->muxnames[7] ? m->muxnames[7] : none);

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
tony lindgren
tony lindgren
274
91.33%
1
50.00%
benoit cousson
benoit cousson
26
8.67%
1
50.00%
Total
300
100.00%
2
100.00%


#define OMAP_MUX_MAX_ARG_CHAR  7



static ssize_t omap_mux_dbg_signal_write(struct file *file,
					 const char __user *user_buf,
					 size_t count, loff_t *ppos)
{
	struct seq_file *seqf;
	struct omap_mux *m;
	u16 val;
	int ret;
	struct omap_mux_partition *partition;

	if (count > OMAP_MUX_MAX_ARG_CHAR)
		return -EINVAL;

	ret = kstrtou16_from_user(user_buf, count, 0x10, &val);
	if (ret < 0)
		return ret;

	seqf = file->private_data;
	m = seqf->private;

	partition = omap_mux_get_partition(m);
	if (!partition)
		return -ENODEV;

	omap_mux_write(partition, val, m->reg_offset);
	*ppos += count;

	return count;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
tony lindgren
tony lindgren
98
78.40%
1
33.33%
benoit cousson
benoit cousson
23
18.40%
1
33.33%
daniel walter
daniel walter
4
3.20%
1
33.33%
Total
125
100.00%
3
100.00%



static int omap_mux_dbg_signal_open(struct inode *inode, struct file *file)
{
	return single_open(file, omap_mux_dbg_signal_show, inode->i_private);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
tony lindgren
tony lindgren
28
100.00%
1
100.00%
Total
28
100.00%
1
100.00%


static const struct file_operations omap_mux_dbg_signal_fops = {
	.open		= omap_mux_dbg_signal_open,
	.read		= seq_read,
	.write		= omap_mux_dbg_signal_write,
	.llseek		= seq_lseek,
	.release	= single_release,
};


static struct dentry *mux_dbg_dir;



static void __init omap_mux_dbg_create_entry(
				struct omap_mux_partition *partition,
				struct dentry *mux_dbg_dir)
{
	struct omap_mux_entry *e;

	list_for_each_entry(e, &partition->muxmodes, node) {
		struct omap_mux *m = &e->mux;

		(void)debugfs_create_file(m->muxnames[0], S_IWUSR | S_IRUGO,
					  mux_dbg_dir, m,
					  &omap_mux_dbg_signal_fops);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
benoit cousson
benoit cousson
63
95.45%
1
33.33%
felipe balbi
felipe balbi
2
3.03%
1
33.33%
vasiliy kulikov
vasiliy kulikov
1
1.52%
1
33.33%
Total
66
100.00%
3
100.00%



static void __init omap_mux_dbg_init(void)
{
	struct omap_mux_partition *partition;
	static struct dentry *mux_dbg_board_dir;

	mux_dbg_dir = debugfs_create_dir("omap_mux", NULL);
	if (!mux_dbg_dir)
		return;

	mux_dbg_board_dir = debugfs_create_dir("board", mux_dbg_dir);
	if (!mux_dbg_board_dir)
		return;

	list_for_each_entry(partition, &mux_partitions, node) {
		omap_mux_dbg_create_entry(partition, mux_dbg_dir);
		(void)debugfs_create_file(partition->name, S_IRUGO,
					  mux_dbg_board_dir, partition,
					  &omap_mux_dbg_board_fops);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
tony lindgren
tony lindgren
52
60.47%
1
50.00%
benoit cousson
benoit cousson
34
39.53%
1
50.00%
Total
86
100.00%
2
100.00%

#else


static inline void omap_mux_dbg_init(void)
{
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
tony lindgren
tony lindgren
8
100.00%
1
100.00%
Total
8
100.00%
1
100.00%

#endif	/* CONFIG_DEBUG_FS */



static void __init omap_mux_free_names(struct omap_mux *m)
{
	int i;

	for (i = 0; i < OMAP_MUX_NR_MODES; i++)
		kfree(m->muxnames[i]);

#ifdef CONFIG_DEBUG_FS
	for (i = 0; i < OMAP_MUX_NR_SIDES; i++)
		kfree(m->balls[i]);
#endif

}

Contributors
Person
Tokens
Prop
Commits
CommitProp
tony lindgren
tony lindgren
66
100.00%
1
100.00%
Total
66
100.00%
1
100.00%

/* Free all data except for GPIO pins unless CONFIG_DEBUG_FS is set */


int __init omap_mux_late_init(void)
{
	struct omap_mux_partition *partition;
	int ret;

	list_for_each_entry(partition, &mux_partitions, node) {
		struct omap_mux_entry *e, *tmp;
		list_for_each_entry_safe(e, tmp, &partition->muxmodes, node) {
			struct omap_mux *m = &e->mux;
			u16 mode = omap_mux_read(partition, m->reg_offset);

			if (OMAP_MODE_GPIO(partition, mode))
				continue;

#ifndef CONFIG_DEBUG_FS
			mutex_lock(&muxmode_mutex);
			list_del(&e->node);
			mutex_unlock(&muxmode_mutex);
			omap_mux_free_names(m);
			kfree(m);
#endif
		}
	}

	omap_mux_dbg_init();

	/* see pinctrl-single-omap for the wake-up interrupt handling */
	if (of_have_populated_dt())
		return 0;

	ret = request_irq(omap_prcm_event_to_irq("io"),
		omap_hwmod_mux_handle_irq, IRQF_SHARED | IRQF_NO_SUSPEND,
			"hwmod_io", omap_mux_late_init);

	if (ret)
		pr_warn("mux: Failed to setup hwmod io irq %d\n", ret);

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
tony lindgren
tony lindgren
105
66.04%
2
33.33%
tero kristo
tero kristo
33
20.75%
1
16.67%
benoit cousson
benoit cousson
18
11.32%
1
16.67%
oleg matcovschi
oleg matcovschi
2
1.26%
1
16.67%
joe perches
joe perches
1
0.63%
1
16.67%
Total
159
100.00%
6
100.00%



static void __init omap_mux_package_fixup(struct omap_mux *p,
					struct omap_mux *superset)
{
	while (p->reg_offset !=  OMAP_MUX_TERMINATOR) {
		struct omap_mux *s = superset;
		int found = 0;

		while (s->reg_offset != OMAP_MUX_TERMINATOR) {
			if (s->reg_offset == p->reg_offset) {
				*s = *p;
				found++;
				break;
			}
			s++;
		}
		if (!found)
			pr_err("%s: Unknown entry offset 0x%x\n", __func__,
			       p->reg_offset);
		p++;
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
tony lindgren
tony lindgren
89
95.70%
2
50.00%
dan murphy
dan murphy
3
3.23%
1
25.00%
benoit cousson
benoit cousson
1
1.08%
1
25.00%
Total
93
100.00%
4
100.00%

#ifdef CONFIG_DEBUG_FS



static void __init omap_mux_package_init_balls(struct omap_ball *b,
				struct omap_mux *superset)
{
	while (b->reg_offset != OMAP_MUX_TERMINATOR) {
		struct omap_mux *s = superset;
		int found = 0;

		while (s->reg_offset != OMAP_MUX_TERMINATOR) {
			if (s->reg_offset == b->reg_offset) {
				s->balls[0] = b->balls[0];
				s->balls[1] = b->balls[1];
				found++;
				break;
			}
			s++;
		}
		if (!found)
			pr_err("%s: Unknown ball offset 0x%x\n", __func__,
			       b->reg_offset);
		b++;
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
tony lindgren
tony lindgren
111
96.52%
1
33.33%
dan murphy
dan murphy
3
2.61%
1
33.33%
benoit cousson
benoit cousson
1
0.87%
1
33.33%
Total
115
100.00%
3
100.00%

#else	/* CONFIG_DEBUG_FS */



static inline void omap_mux_package_init_balls(struct omap_ball *b,
					struct omap_mux *superset)
{
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
tony lindgren
tony lindgren
16
100.00%
1
100.00%
Total
16
100.00%
1
100.00%

#endif	/* CONFIG_DEBUG_FS */



static int __init omap_mux_setup(char *options)
{
	if (!options)
		return 0;

	omap_mux_options = options;

	return 1;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
tony lindgren
tony lindgren
26
100.00%
1
100.00%
Total
26
100.00%
1
100.00%

__setup("omap_mux=", omap_mux_setup);

/*
 * Note that the omap_mux=some.signal1=0x1234,some.signal2=0x1234
 * cmdline options only override the bootloader values.
 * During development, please enable CONFIG_DEBUG_FS, and use the
 * signal specific entries under debugfs.
 */


static void __init omap_mux_set_cmdline_signals(void)
{
	char *options, *next_opt, *token;

	if (!omap_mux_options)
		return;

	options = kstrdup(omap_mux_options, GFP_KERNEL);
	if (!options)
		return;

	next_opt = options;

	while ((token = strsep(&next_opt, ",")) != NULL) {
		char *keyval, *name;
		u16 val;

		keyval = token;
		name = strsep(&keyval, "=");
		if (name) {
			int res;

			res = kstrtou16(keyval, 0x10, &val);
			if (res < 0)
				continue;

			omap_mux_init_signal(name, (u16)val);
		}
	}

	kfree(options);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
tony lindgren
tony lindgren
126
97.67%
1
33.33%
daniel walter
daniel walter
2
1.55%
1
33.33%
thomas meyer
thomas meyer
1
0.78%
1
33.33%
Total
129
100.00%
3
100.00%



static int __init omap_mux_copy_names(struct omap_mux *src,
				      struct omap_mux *dst)
{
	int i;

	for (i = 0; i < OMAP_MUX_NR_MODES; i++) {
		if (src->muxnames[i]) {
			dst->muxnames[i] = kstrdup(src->muxnames[i],
						   GFP_KERNEL);
			if (!dst->muxnames[i])
				goto free;
		}
	}

#ifdef CONFIG_DEBUG_FS
	for (i = 0; i < OMAP_MUX_NR_SIDES; i++) {
		if (src->balls[i]) {
			dst->balls[i] = kstrdup(src->balls[i], GFP_KERNEL);
			if (!dst->balls[i])
				goto free;
		}
	}
#endif

	return 0;

free:
	omap_mux_free_names(dst);
	return -ENOMEM;

}

Contributors
Person
Tokens
Prop
Commits
CommitProp
tony lindgren
tony lindgren
153
98.71%
1
50.00%
thomas meyer
thomas meyer
2
1.29%
1
50.00%
Total
155
100.00%
2
100.00%

#endif	/* CONFIG_OMAP_MUX */



static struct omap_mux *omap_mux_get_by_gpio(
				struct omap_mux_partition *partition,
				int gpio)
{
	struct omap_mux_entry *e;
	struct omap_mux *ret = NULL;

	list_for_each_entry(e, &partition->muxmodes, node) {
		struct omap_mux *m = &e->mux;
		if (m->gpio == gpio) {
			ret = m;
			break;
		}
	}

	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
tony lindgren
tony lindgren
50
75.76%
1
50.00%
benoit cousson
benoit cousson
16
24.24%
1
50.00%
Total
66
100.00%
2
100.00%

/* Needed for dynamic muxing of GPIO pins for off-idle */


u16 omap_mux_get_gpio(int gpio)
{
	struct omap_mux_partition *partition;
	struct omap_mux *m = NULL;

	list_for_each_entry(partition, &mux_partitions, node) {
		m = omap_mux_get_by_gpio(partition, gpio);
		if (m)
			return omap_mux_read(partition, m->reg_offset);
	}

	if (!m || m->reg_offset == OMAP_MUX_TERMINATOR)
		pr_err("%s: Could not get gpio%i\n", __func__, gpio);

	return OMAP_MUX_TERMINATOR;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
benoit cousson
benoit cousson
44
57.89%
2
40.00%
tony lindgren
tony lindgren
27
35.53%
1
20.00%
dan murphy
dan murphy
3
3.95%
1
20.00%
govindraj raja
govindraj raja
2
2.63%
1
20.00%
Total
76
100.00%
5
100.00%

/* Needed for dynamic muxing of GPIO pins for off-idle */


void omap_mux_set_gpio(u16 val, int gpio)
{
	struct omap_mux_partition *partition;
	struct omap_mux *m = NULL;

	list_for_each_entry(partition, &mux_partitions, node) {
		m = omap_mux_get_by_gpio(partition, gpio);
		if (m) {
			omap_mux_write(partition, val, m->reg_offset);
			return;
		}
	}

	if (!m || m->reg_offset == OMAP_MUX_TERMINATOR)
		pr_err("%s: Could not set gpio%i\n", __func__, gpio);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
benoit cousson
benoit cousson
45
56.25%
1
33.33%
tony lindgren
tony lindgren
32
40.00%
1
33.33%
dan murphy
dan murphy
3
3.75%
1
33.33%
Total
80
100.00%
3
100.00%



static struct omap_mux * __init omap_mux_list_add(
					struct omap_mux_partition *partition,
					struct omap_mux *src)
{
	struct omap_mux_entry *entry;
	struct omap_mux *m;

	entry = kzalloc(sizeof(struct omap_mux_entry), GFP_KERNEL);
	if (!entry)
		return NULL;

	m = &entry->mux;
	entry->mux = *src;

#ifdef CONFIG_OMAP_MUX
	if (omap_mux_copy_names(src, m)) {
		kfree(entry);
		return NULL;
	}
#endif

	mutex_lock(&muxmode_mutex);
	list_add_tail(&entry->node, &partition->muxmodes);
	mutex_unlock(&muxmode_mutex);

	return m;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
tony lindgren
tony lindgren
104
89.66%
1
33.33%
benoit cousson
benoit cousson
7
6.03%
1
33.33%
aaro koskinen
aaro koskinen
5
4.31%
1
33.33%
Total
116
100.00%
3
100.00%

/*
 * Note if CONFIG_OMAP_MUX is not selected, we will only initialize
 * the GPIO to mux offset mapping that is needed for dynamic muxing
 * of GPIO pins for off-idle.
 */


static void __init omap_mux_init_list(struct omap_mux_partition *partition,
				      struct omap_mux *superset)
{
	while (superset->reg_offset !=  OMAP_MUX_TERMINATOR) {
		struct omap_mux *entry;

#ifdef CONFIG_OMAP_MUX
		if (!superset->muxnames[0]) {
			superset++;
			continue;
		}
#else
		/* Skip pins that are not muxed as GPIO by bootloader */
		if (!OMAP_MODE_GPIO(partition, omap_mux_read(partition,
				    superset->reg_offset))) {
			superset++;
			continue;
		}
#endif

		entry = omap_mux_list_add(partition, superset);
		if (!entry) {
			pr_err("%s: Could not add entry\n", __func__);
			return;
		}
		superset++;
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
tony lindgren
tony lindgren
75
70.75%
2
28.57%
ranjith lohithakshan
ranjith lohithakshan
16
15.09%
1
14.29%
benoit cousson
benoit cousson
10
9.43%
2
28.57%
dan murphy
dan murphy
3
2.83%
1
14.29%
oleg matcovschi
oleg matcovschi
2
1.89%
1
14.29%
Total
106
100.00%
7
100.00%

#ifdef CONFIG_OMAP_MUX



static void omap_mux_init_package(struct omap_mux *superset,
				  struct omap_mux *package_subset,
				  struct omap_ball *package_balls)
{
	if (package_subset)
		omap_mux_package_fixup(package_subset, superset);
	if (package_balls)
		omap_mux_package_init_balls(package_balls, superset);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
tony lindgren
tony lindgren
43
100.00%
1
100.00%
Total
43
100.00%
1
100.00%



static void __init omap_mux_init_signals(struct omap_mux_partition *partition,
					 struct omap_board_mux *board_mux)
{
	omap_mux_set_cmdline_signals();
	omap_mux_write_array(partition, board_mux);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
tony lindgren
tony lindgren
19
70.37%
1
33.33%
benoit cousson
benoit cousson
7
25.93%
1
33.33%
russell king
russell king
1
3.70%
1
33.33%
Total
27
100.00%
3
100.00%

#else



static void omap_mux_init_package(struct omap_mux *superset,
				  struct omap_mux *package_subset,
				  struct omap_ball *package_balls)
{
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
tony lindgren
tony lindgren
20
100.00%
1
100.00%
Total
20
100.00%
1
100.00%



static void __init omap_mux_init_signals(struct omap_mux_partition *partition,
					 struct omap_board_mux *board_mux)
{
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
tony lindgren
tony lindgren
10
62.50%
1
33.33%
benoit cousson
benoit cousson
5
31.25%
1
33.33%
russell king
russell king
1
6.25%
1
33.33%
Total
16
100.00%
3
100.00%

#endif


static u32 mux_partitions_cnt;



int __init omap_mux_init(const char *name, u32 flags,
			 u32 mux_pbase, u32 mux_size,
			 struct omap_mux *superset,
			 struct omap_mux *package_subset,
			 struct omap_board_mux *board_mux,
			 struct omap_ball *package_balls)
{
	struct omap_mux_partition *partition;

	partition = kzalloc(sizeof(struct omap_mux_partition), GFP_KERNEL);
	if (!partition)
		return -ENOMEM;

	partition->name = name;
	partition->flags = flags;
	partition->gpio = flags & OMAP_MUX_MODE7;
	partition->size = mux_size;
	partition->phys = mux_pbase;
	partition->base = ioremap(mux_pbase, mux_size);
	if (!partition->base) {
		pr_err("%s: Could not ioremap mux partition at 0x%08x\n",
			__func__, partition->phys);
		kfree(partition);
		return -ENODEV;
	}

	INIT_LIST_HEAD(&partition->muxmodes);

	list_add_tail(&partition->node, &mux_partitions);
	mux_partitions_cnt++;
	pr_info("%s: Add partition: #%d: %s, flags: %x\n", __func__,
		mux_partitions_cnt, partition->name, partition->flags);

	omap_mux_init_package(superset, package_subset, package_balls);
	omap_mux_init_list(partition, superset);
	omap_mux_init_signals(partition, board_mux);

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
benoit cousson
benoit cousson
100
49.02%
2
18.18%
tony lindgren
tony lindgren
85
41.67%
6
54.55%
oleg matcovschi
oleg matcovschi
8
3.92%
1
9.09%
dan murphy
dan murphy
6
2.94%
1
9.09%
aaro koskinen
aaro koskinen
5
2.45%
1
9.09%
Total
204
100.00%
11
100.00%

Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
tony lindgren
tony lindgren
3563
73.72%
21
39.62%
benoit cousson
benoit cousson
750
15.52%
2
3.77%
tero kristo
tero kristo
281
5.81%
1
1.89%
grazvydas ignotas
grazvydas ignotas
59
1.22%
1
1.89%
dan murphy
dan murphy
33
0.68%
1
1.89%
paul walmsley
paul walmsley
20
0.41%
5
9.43%
mike rapoport
mike rapoport
17
0.35%
1
1.89%
ranjith lohithakshan
ranjith lohithakshan
16
0.33%
1
1.89%
oleg matcovschi
oleg matcovschi
15
0.31%
1
1.89%
david r. piegdon
david r. piegdon
12
0.25%
1
1.89%
aaro koskinen
aaro koskinen
10
0.21%
2
3.77%
ruslan bilovol
ruslan bilovol
9
0.19%
1
1.89%
r sricharan
r sricharan
8
0.17%
1
1.89%
vikram pandita
vikram pandita
7
0.14%
1
1.89%
daniel walter
daniel walter
6
0.12%
1
1.89%
colin cross
colin cross
6
0.12%
1
1.89%
victor kamensky
victor kamensky
4
0.08%
1
1.89%
felipe balbi
felipe balbi
4
0.08%
2
3.77%
russell king
russell king
3
0.06%
2
3.77%
thomas meyer
thomas meyer
3
0.06%
1
1.89%
sanjeev premi
sanjeev premi
2
0.04%
1
1.89%
govindraj raja
govindraj raja
2
0.04%
1
1.89%
lucas de marchi
lucas de marchi
1
0.02%
1
1.89%
vasiliy kulikov
vasiliy kulikov
1
0.02%
1
1.89%
joe perches
joe perches
1
0.02%
1
1.89%
Total
4833
100.00%
53
100.00%
  
Directory: arch/arm/mach-omap2