2 * linux/arch/arm/mach-omap2/mux.c
4 * OMAP2 and OMAP3 pin multiplexing configurations
6 * Copyright (C) 2004 - 2008 Texas Instruments Inc.
7 * Copyright (C) 2003 - 2008 Nokia Corporation
9 * Written by Tony Lindgren
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 #include <linux/kernel.h>
27 #include <linux/init.h>
29 #include <linux/list.h>
30 #include <linux/slab.h>
31 #include <linux/ctype.h>
32 #include <linux/debugfs.h>
33 #include <linux/seq_file.h>
34 #include <linux/uaccess.h>
36 #include <asm/system.h>
41 #define OMAP_MUX_BASE_OFFSET 0x30 /* Offset from CTRL_BASE */
42 #define OMAP_MUX_BASE_SZ 0x5ca
43 #define MUXABLE_GPIO_MODE3 BIT(0)
45 struct omap_mux_entry {
47 struct list_head node;
50 static unsigned long mux_phys;
51 static void __iomem *mux_base;
52 static u8 omap_mux_flags;
54 u16 omap_mux_read(u16 reg)
56 if (cpu_is_omap24xx())
57 return __raw_readb(mux_base + reg);
59 return __raw_readw(mux_base + reg);
62 void omap_mux_write(u16 val, u16 reg)
64 if (cpu_is_omap24xx())
65 __raw_writeb(val, mux_base + reg);
67 __raw_writew(val, mux_base + reg);
70 void omap_mux_write_array(struct omap_board_mux *board_mux)
72 while (board_mux->reg_offset != OMAP_MUX_TERMINATOR) {
73 omap_mux_write(board_mux->value, board_mux->reg_offset);
78 static LIST_HEAD(muxmodes);
79 static DEFINE_MUTEX(muxmode_mutex);
81 #ifdef CONFIG_OMAP_MUX
83 static char *omap_mux_options;
85 int __init omap_mux_init_gpio(int gpio, int val)
87 struct omap_mux_entry *e;
88 struct omap_mux *gpio_mux = NULL;
96 list_for_each_entry(e, &muxmodes, node) {
97 struct omap_mux *m = &e->mux;
98 if (gpio == m->gpio) {
105 printk(KERN_ERR "mux: Could not set gpio%i\n", gpio);
110 printk(KERN_INFO "mux: Multiple gpio paths (%d) for gpio%i\n",
115 old_mode = omap_mux_read(gpio_mux->reg_offset);
116 mux_mode = val & ~(OMAP_MUX_NR_MODES - 1);
117 if (omap_mux_flags & MUXABLE_GPIO_MODE3)
118 mux_mode |= OMAP_MUX_MODE3;
120 mux_mode |= OMAP_MUX_MODE4;
121 printk(KERN_DEBUG "mux: Setting signal %s.gpio%i 0x%04x -> 0x%04x\n",
122 gpio_mux->muxnames[0], gpio, old_mode, mux_mode);
123 omap_mux_write(mux_mode, gpio_mux->reg_offset);
128 int __init omap_mux_init_signal(const char *muxname, int val)
130 struct omap_mux_entry *e;
131 const char *mode_name;
132 int found = 0, mode0_len = 0;
134 mode_name = strchr(muxname, '.');
136 mode0_len = strlen(muxname) - strlen(mode_name);
142 list_for_each_entry(e, &muxmodes, node) {
143 struct omap_mux *m = &e->mux;
144 char *m0_entry = m->muxnames[0];
147 /* First check for full name in mode0.muxmode format */
148 if (mode0_len && strncmp(muxname, m0_entry, mode0_len))
151 /* Then check for muxmode only */
152 for (i = 0; i < OMAP_MUX_NR_MODES; i++) {
153 char *mode_cur = m->muxnames[i];
158 if (!strcmp(mode_name, mode_cur)) {
162 old_mode = omap_mux_read(m->reg_offset);
164 printk(KERN_DEBUG "mux: Setting signal "
165 "%s.%s 0x%04x -> 0x%04x\n",
166 m0_entry, muxname, old_mode, mux_mode);
167 omap_mux_write(mux_mode, m->reg_offset);
177 printk(KERN_ERR "mux: Multiple signal paths (%i) for %s\n",
182 printk(KERN_ERR "mux: Could not set signal %s\n", muxname);
187 #ifdef CONFIG_DEBUG_FS
189 #define OMAP_MUX_MAX_NR_FLAGS 10
190 #define OMAP_MUX_TEST_FLAG(val, mask) \
191 if (((val) & (mask)) == (mask)) { \
196 /* REVISIT: Add checking for non-optimal mux settings */
197 static inline void omap_mux_decode(struct seq_file *s, u16 val)
199 char *flags[OMAP_MUX_MAX_NR_FLAGS];
200 char mode[sizeof("OMAP_MUX_MODE") + 1];
203 sprintf(mode, "OMAP_MUX_MODE%d", val & 0x7);
207 OMAP_MUX_TEST_FLAG(val, OMAP_PIN_OFF_WAKEUPENABLE);
208 if (val & OMAP_OFF_EN) {
209 if (!(val & OMAP_OFFOUT_EN)) {
210 if (!(val & OMAP_OFF_PULL_UP)) {
211 OMAP_MUX_TEST_FLAG(val,
212 OMAP_PIN_OFF_INPUT_PULLDOWN);
214 OMAP_MUX_TEST_FLAG(val,
215 OMAP_PIN_OFF_INPUT_PULLUP);
218 if (!(val & OMAP_OFFOUT_VAL)) {
219 OMAP_MUX_TEST_FLAG(val,
220 OMAP_PIN_OFF_OUTPUT_LOW);
222 OMAP_MUX_TEST_FLAG(val,
223 OMAP_PIN_OFF_OUTPUT_HIGH);
228 if (val & OMAP_INPUT_EN) {
229 if (val & OMAP_PULL_ENA) {
230 if (!(val & OMAP_PULL_UP)) {
231 OMAP_MUX_TEST_FLAG(val,
232 OMAP_PIN_INPUT_PULLDOWN);
234 OMAP_MUX_TEST_FLAG(val, OMAP_PIN_INPUT_PULLUP);
237 OMAP_MUX_TEST_FLAG(val, OMAP_PIN_INPUT);
241 flags[i] = "OMAP_PIN_OUTPUT";
245 seq_printf(s, "%s", flags[i]);
247 seq_printf(s, " | ");
251 #define OMAP_MUX_DEFNAME_LEN 16
253 static int omap_mux_dbg_board_show(struct seq_file *s, void *unused)
255 struct omap_mux_entry *e;
257 list_for_each_entry(e, &muxmodes, node) {
258 struct omap_mux *m = &e->mux;
259 char m0_def[OMAP_MUX_DEFNAME_LEN];
260 char *m0_name = m->muxnames[0];
267 /* REVISIT: Needs to be updated if mode0 names get longer */
268 for (i = 0; i < OMAP_MUX_DEFNAME_LEN; i++) {
269 if (m0_name[i] == '\0') {
270 m0_def[i] = m0_name[i];
273 m0_def[i] = toupper(m0_name[i]);
275 val = omap_mux_read(m->reg_offset);
276 mode = val & OMAP_MUX_MODE7;
278 seq_printf(s, "OMAP%i_MUX(%s, ",
279 cpu_is_omap34xx() ? 3 : 0, m0_def);
280 omap_mux_decode(s, val);
281 seq_printf(s, "),\n");
287 static int omap_mux_dbg_board_open(struct inode *inode, struct file *file)
289 return single_open(file, omap_mux_dbg_board_show, &inode->i_private);
292 static const struct file_operations omap_mux_dbg_board_fops = {
293 .open = omap_mux_dbg_board_open,
296 .release = single_release,
299 static int omap_mux_dbg_signal_show(struct seq_file *s, void *unused)
301 struct omap_mux *m = s->private;
302 const char *none = "NA";
306 val = omap_mux_read(m->reg_offset);
307 mode = val & OMAP_MUX_MODE7;
309 seq_printf(s, "name: %s.%s (0x%08lx/0x%03x = 0x%04x), b %s, t %s\n",
310 m->muxnames[0], m->muxnames[mode],
311 mux_phys + m->reg_offset, m->reg_offset, val,
312 m->balls[0] ? m->balls[0] : none,
313 m->balls[1] ? m->balls[1] : none);
314 seq_printf(s, "mode: ");
315 omap_mux_decode(s, val);
317 seq_printf(s, "signals: %s | %s | %s | %s | %s | %s | %s | %s\n",
318 m->muxnames[0] ? m->muxnames[0] : none,
319 m->muxnames[1] ? m->muxnames[1] : none,
320 m->muxnames[2] ? m->muxnames[2] : none,
321 m->muxnames[3] ? m->muxnames[3] : none,
322 m->muxnames[4] ? m->muxnames[4] : none,
323 m->muxnames[5] ? m->muxnames[5] : none,
324 m->muxnames[6] ? m->muxnames[6] : none,
325 m->muxnames[7] ? m->muxnames[7] : none);
330 #define OMAP_MUX_MAX_ARG_CHAR 7
332 static ssize_t omap_mux_dbg_signal_write(struct file *file,
333 const char __user *user_buf,
334 size_t count, loff_t *ppos)
336 char buf[OMAP_MUX_MAX_ARG_CHAR];
337 struct seq_file *seqf;
342 if (count > OMAP_MUX_MAX_ARG_CHAR)
345 memset(buf, 0, sizeof(buf));
346 buf_size = min(count, sizeof(buf) - 1);
348 if (copy_from_user(buf, user_buf, buf_size))
351 ret = strict_strtoul(buf, 0x10, &val);
358 seqf = file->private_data;
361 omap_mux_write((u16)val, m->reg_offset);
367 static int omap_mux_dbg_signal_open(struct inode *inode, struct file *file)
369 return single_open(file, omap_mux_dbg_signal_show, inode->i_private);
372 static const struct file_operations omap_mux_dbg_signal_fops = {
373 .open = omap_mux_dbg_signal_open,
375 .write = omap_mux_dbg_signal_write,
377 .release = single_release,
380 static struct dentry *mux_dbg_dir;
382 static void __init omap_mux_dbg_init(void)
384 struct omap_mux_entry *e;
386 mux_dbg_dir = debugfs_create_dir("omap_mux", NULL);
390 (void)debugfs_create_file("board", S_IRUGO, mux_dbg_dir,
391 NULL, &omap_mux_dbg_board_fops);
393 list_for_each_entry(e, &muxmodes, node) {
394 struct omap_mux *m = &e->mux;
396 (void)debugfs_create_file(m->muxnames[0], S_IWUGO, mux_dbg_dir,
397 m, &omap_mux_dbg_signal_fops);
402 static inline void omap_mux_dbg_init(void)
405 #endif /* CONFIG_DEBUG_FS */
407 static void __init omap_mux_free_names(struct omap_mux *m)
411 for (i = 0; i < OMAP_MUX_NR_MODES; i++)
412 kfree(m->muxnames[i]);
414 #ifdef CONFIG_DEBUG_FS
415 for (i = 0; i < OMAP_MUX_NR_SIDES; i++)
421 /* Free all data except for GPIO pins unless CONFIG_DEBUG_FS is set */
422 static int __init omap_mux_late_init(void)
424 struct omap_mux_entry *e, *tmp;
426 list_for_each_entry_safe(e, tmp, &muxmodes, node) {
427 struct omap_mux *m = &e->mux;
428 u16 mode = omap_mux_read(m->reg_offset);
430 if (OMAP_MODE_GPIO(mode))
433 #ifndef CONFIG_DEBUG_FS
434 mutex_lock(&muxmode_mutex);
436 mutex_unlock(&muxmode_mutex);
437 omap_mux_free_names(m);
447 late_initcall(omap_mux_late_init);
449 static void __init omap_mux_package_fixup(struct omap_mux *p,
450 struct omap_mux *superset)
452 while (p->reg_offset != OMAP_MUX_TERMINATOR) {
453 struct omap_mux *s = superset;
456 while (s->reg_offset != OMAP_MUX_TERMINATOR) {
457 if (s->reg_offset == p->reg_offset) {
465 printk(KERN_ERR "mux: Unknown entry offset 0x%x\n",
471 #ifdef CONFIG_DEBUG_FS
473 static void __init omap_mux_package_init_balls(struct omap_ball *b,
474 struct omap_mux *superset)
476 while (b->reg_offset != OMAP_MUX_TERMINATOR) {
477 struct omap_mux *s = superset;
480 while (s->reg_offset != OMAP_MUX_TERMINATOR) {
481 if (s->reg_offset == b->reg_offset) {
482 s->balls[0] = b->balls[0];
483 s->balls[1] = b->balls[1];
490 printk(KERN_ERR "mux: Unknown ball offset 0x%x\n",
496 #else /* CONFIG_DEBUG_FS */
498 static inline void omap_mux_package_init_balls(struct omap_ball *b,
499 struct omap_mux *superset)
503 #endif /* CONFIG_DEBUG_FS */
505 static int __init omap_mux_setup(char *options)
510 omap_mux_options = options;
514 __setup("omap_mux=", omap_mux_setup);
517 * Note that the omap_mux=some.signal1=0x1234,some.signal2=0x1234
518 * cmdline options only override the bootloader values.
519 * During development, please enable CONFIG_DEBUG_FS, and use the
520 * signal specific entries under debugfs.
522 static void __init omap_mux_set_cmdline_signals(void)
524 char *options, *next_opt, *token;
526 if (!omap_mux_options)
529 options = kmalloc(strlen(omap_mux_options) + 1, GFP_KERNEL);
533 strcpy(options, omap_mux_options);
536 while ((token = strsep(&next_opt, ",")) != NULL) {
541 name = strsep(&keyval, "=");
545 res = strict_strtoul(keyval, 0x10, &val);
549 omap_mux_init_signal(name, (u16)val);
556 static int __init omap_mux_copy_names(struct omap_mux *src,
557 struct omap_mux *dst)
561 for (i = 0; i < OMAP_MUX_NR_MODES; i++) {
562 if (src->muxnames[i]) {
564 kmalloc(strlen(src->muxnames[i]) + 1,
566 if (!dst->muxnames[i])
568 strcpy(dst->muxnames[i], src->muxnames[i]);
572 #ifdef CONFIG_DEBUG_FS
573 for (i = 0; i < OMAP_MUX_NR_SIDES; i++) {
576 kmalloc(strlen(src->balls[i]) + 1,
580 strcpy(dst->balls[i], src->balls[i]);
588 omap_mux_free_names(dst);
593 #endif /* CONFIG_OMAP_MUX */
595 static u16 omap_mux_get_by_gpio(int gpio)
597 struct omap_mux_entry *e;
598 u16 offset = OMAP_MUX_TERMINATOR;
600 list_for_each_entry(e, &muxmodes, node) {
601 struct omap_mux *m = &e->mux;
602 if (m->gpio == gpio) {
603 offset = m->reg_offset;
611 /* Needed for dynamic muxing of GPIO pins for off-idle */
612 u16 omap_mux_get_gpio(int gpio)
616 offset = omap_mux_get_by_gpio(gpio);
617 if (offset == OMAP_MUX_TERMINATOR) {
618 printk(KERN_ERR "mux: Could not get gpio%i\n", gpio);
622 return omap_mux_read(offset);
625 /* Needed for dynamic muxing of GPIO pins for off-idle */
626 void omap_mux_set_gpio(u16 val, int gpio)
630 offset = omap_mux_get_by_gpio(gpio);
631 if (offset == OMAP_MUX_TERMINATOR) {
632 printk(KERN_ERR "mux: Could not set gpio%i\n", gpio);
636 omap_mux_write(val, offset);
639 static struct omap_mux * __init omap_mux_list_add(struct omap_mux *src)
641 struct omap_mux_entry *entry;
644 entry = kzalloc(sizeof(struct omap_mux_entry), GFP_KERNEL);
649 memcpy(m, src, sizeof(struct omap_mux_entry));
651 #ifdef CONFIG_OMAP_MUX
652 if (omap_mux_copy_names(src, m)) {
658 mutex_lock(&muxmode_mutex);
659 list_add_tail(&entry->node, &muxmodes);
660 mutex_unlock(&muxmode_mutex);
666 * Note if CONFIG_OMAP_MUX is not selected, we will only initialize
667 * the GPIO to mux offset mapping that is needed for dynamic muxing
668 * of GPIO pins for off-idle.
670 static void __init omap_mux_init_list(struct omap_mux *superset)
672 while (superset->reg_offset != OMAP_MUX_TERMINATOR) {
673 struct omap_mux *entry;
675 #ifdef CONFIG_OMAP_MUX
676 if (!superset->muxnames || !superset->muxnames[0]) {
681 /* Skip pins that are not muxed as GPIO by bootloader */
682 if (!OMAP_MODE_GPIO(omap_mux_read(superset->reg_offset))) {
688 entry = omap_mux_list_add(superset);
690 printk(KERN_ERR "mux: Could not add entry\n");
697 #ifdef CONFIG_OMAP_MUX
699 static void omap_mux_init_package(struct omap_mux *superset,
700 struct omap_mux *package_subset,
701 struct omap_ball *package_balls)
704 omap_mux_package_fixup(package_subset, superset);
706 omap_mux_package_init_balls(package_balls, superset);
709 static void omap_mux_init_signals(struct omap_board_mux *board_mux)
711 omap_mux_set_cmdline_signals();
712 omap_mux_write_array(board_mux);
717 static void omap_mux_init_package(struct omap_mux *superset,
718 struct omap_mux *package_subset,
719 struct omap_ball *package_balls)
723 static void omap_mux_init_signals(struct omap_board_mux *board_mux)
729 int __init omap_mux_init(u32 mux_pbase, u32 mux_size,
730 struct omap_mux *superset,
731 struct omap_mux *package_subset,
732 struct omap_board_mux *board_mux,
733 struct omap_ball *package_balls)
738 mux_phys = mux_pbase;
739 mux_base = ioremap(mux_pbase, mux_size);
741 printk(KERN_ERR "mux: Could not ioremap\n");
745 if (cpu_is_omap24xx())
746 omap_mux_flags = MUXABLE_GPIO_MODE3;
748 omap_mux_init_package(superset, package_subset, package_balls);
749 omap_mux_init_list(superset);
750 omap_mux_init_signals(board_mux);