2 * linux/arch/arm/mach-omap2/mux.c
4 * OMAP2, OMAP3 and OMAP4 pin multiplexing configurations
6 * Copyright (C) 2004 - 2010 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>
35 #include <linux/irq.h>
36 #include <linux/interrupt.h>
39 #include "omap_hwmod.h"
47 #define OMAP_MUX_BASE_OFFSET 0x30 /* Offset from CTRL_BASE */
48 #define OMAP_MUX_BASE_SZ 0x5ca
50 struct omap_mux_entry
{
52 struct list_head node
;
55 static LIST_HEAD(mux_partitions
);
56 static DEFINE_MUTEX(muxmode_mutex
);
58 struct omap_mux_partition
*omap_mux_get(const char *name
)
60 struct omap_mux_partition
*partition
;
62 list_for_each_entry(partition
, &mux_partitions
, node
) {
63 if (!strcmp(name
, partition
->name
))
70 u16
omap_mux_read(struct omap_mux_partition
*partition
, u16 reg
)
72 if (partition
->flags
& OMAP_MUX_REG_8BIT
)
73 return __raw_readb(partition
->base
+ reg
);
75 return __raw_readw(partition
->base
+ reg
);
78 void omap_mux_write(struct omap_mux_partition
*partition
, u16 val
,
81 if (partition
->flags
& OMAP_MUX_REG_8BIT
)
82 __raw_writeb(val
, partition
->base
+ reg
);
84 __raw_writew(val
, partition
->base
+ reg
);
87 void omap_mux_write_array(struct omap_mux_partition
*partition
,
88 struct omap_board_mux
*board_mux
)
93 while (board_mux
->reg_offset
!= OMAP_MUX_TERMINATOR
) {
94 omap_mux_write(partition
, board_mux
->value
,
95 board_mux
->reg_offset
);
100 #ifdef CONFIG_OMAP_MUX
102 static char *omap_mux_options
;
104 static int __init
_omap_mux_init_gpio(struct omap_mux_partition
*partition
,
107 struct omap_mux_entry
*e
;
108 struct omap_mux
*gpio_mux
= NULL
;
112 struct list_head
*muxmodes
= &partition
->muxmodes
;
117 list_for_each_entry(e
, muxmodes
, node
) {
118 struct omap_mux
*m
= &e
->mux
;
119 if (gpio
== m
->gpio
) {
126 pr_err("%s: Could not set gpio%i\n", __func__
, gpio
);
131 pr_info("%s: Multiple gpio paths (%d) for gpio%i\n", __func__
,
136 old_mode
= omap_mux_read(partition
, gpio_mux
->reg_offset
);
137 mux_mode
= val
& ~(OMAP_MUX_NR_MODES
- 1);
138 if (partition
->flags
& OMAP_MUX_GPIO_IN_MODE3
)
139 mux_mode
|= OMAP_MUX_MODE3
;
141 mux_mode
|= OMAP_MUX_MODE4
;
142 pr_debug("%s: Setting signal %s.gpio%i 0x%04x -> 0x%04x\n", __func__
,
143 gpio_mux
->muxnames
[0], gpio
, old_mode
, mux_mode
);
144 omap_mux_write(partition
, mux_mode
, gpio_mux
->reg_offset
);
149 int __init
omap_mux_init_gpio(int gpio
, int val
)
151 struct omap_mux_partition
*partition
;
154 list_for_each_entry(partition
, &mux_partitions
, node
) {
155 ret
= _omap_mux_init_gpio(partition
, gpio
, val
);
163 static int __init
_omap_mux_get_by_name(struct omap_mux_partition
*partition
,
165 struct omap_mux
**found_mux
)
167 struct omap_mux
*mux
= NULL
;
168 struct omap_mux_entry
*e
;
169 const char *mode_name
;
170 int found
= 0, found_mode
= 0, mode0_len
= 0;
171 struct list_head
*muxmodes
= &partition
->muxmodes
;
173 mode_name
= strchr(muxname
, '.');
175 mode0_len
= strlen(muxname
) - strlen(mode_name
);
181 list_for_each_entry(e
, muxmodes
, node
) {
186 m0_entry
= mux
->muxnames
[0];
188 /* First check for full name in mode0.muxmode format */
189 if (mode0_len
&& strncmp(muxname
, m0_entry
, mode0_len
))
192 /* Then check for muxmode only */
193 for (i
= 0; i
< OMAP_MUX_NR_MODES
; i
++) {
194 char *mode_cur
= mux
->muxnames
[i
];
199 if (!strcmp(mode_name
, mode_cur
)) {
212 pr_err("%s: Multiple signal paths (%i) for %s\n", __func__
,
217 pr_err("%s: Could not find signal %s\n", __func__
, muxname
);
222 int __init
omap_mux_get_by_name(const char *muxname
,
223 struct omap_mux_partition
**found_partition
,
224 struct omap_mux
**found_mux
)
226 struct omap_mux_partition
*partition
;
228 list_for_each_entry(partition
, &mux_partitions
, node
) {
229 struct omap_mux
*mux
= NULL
;
230 int mux_mode
= _omap_mux_get_by_name(partition
, muxname
, &mux
);
234 *found_partition
= partition
;
243 int __init
omap_mux_init_signal(const char *muxname
, int val
)
245 struct omap_mux_partition
*partition
= NULL
;
246 struct omap_mux
*mux
= NULL
;
250 mux_mode
= omap_mux_get_by_name(muxname
, &partition
, &mux
);
251 if (mux_mode
< 0 || !mux
)
254 old_mode
= omap_mux_read(partition
, mux
->reg_offset
);
256 pr_debug("%s: Setting signal %s 0x%04x -> 0x%04x\n",
257 __func__
, muxname
, old_mode
, mux_mode
);
258 omap_mux_write(partition
, mux_mode
, mux
->reg_offset
);
263 struct omap_hwmod_mux_info
* __init
264 omap_hwmod_mux_init(struct omap_device_pad
*bpads
, int nr_pads
)
266 struct omap_hwmod_mux_info
*hmux
;
267 int i
, nr_pads_dynamic
= 0;
269 if (!bpads
|| nr_pads
< 1)
272 hmux
= kzalloc(sizeof(struct omap_hwmod_mux_info
), GFP_KERNEL
);
276 hmux
->nr_pads
= nr_pads
;
278 hmux
->pads
= kzalloc(sizeof(struct omap_device_pad
) *
279 nr_pads
, GFP_KERNEL
);
283 for (i
= 0; i
< hmux
->nr_pads
; i
++) {
284 struct omap_mux_partition
*partition
;
285 struct omap_device_pad
*bpad
= &bpads
[i
], *pad
= &hmux
->pads
[i
];
286 struct omap_mux
*mux
;
289 mux_mode
= omap_mux_get_by_name(bpad
->name
, &partition
, &mux
);
293 pad
->partition
= partition
;
297 pad
->name
= kzalloc(strlen(bpad
->name
) + 1, GFP_KERNEL
);
301 for (j
= i
- 1; j
>= 0; j
--)
302 kfree(hmux
->pads
[j
].name
);
305 strcpy(pad
->name
, bpad
->name
);
307 pad
->flags
= bpad
->flags
;
308 pad
->enable
= bpad
->enable
;
309 pad
->idle
= bpad
->idle
;
310 pad
->off
= bpad
->off
;
313 (OMAP_DEVICE_PAD_REMUX
| OMAP_DEVICE_PAD_WAKEUP
))
316 pr_debug("%s: Initialized %s\n", __func__
, pad
->name
);
319 if (!nr_pads_dynamic
)
323 * Add pads that need dynamic muxing into a separate list
326 hmux
->nr_pads_dynamic
= nr_pads_dynamic
;
327 hmux
->pads_dynamic
= kzalloc(sizeof(struct omap_device_pad
*) *
328 nr_pads_dynamic
, GFP_KERNEL
);
329 if (!hmux
->pads_dynamic
) {
330 pr_err("%s: Could not allocate dynamic pads\n", __func__
);
335 for (i
= 0; i
< hmux
->nr_pads
; i
++) {
336 struct omap_device_pad
*pad
= &hmux
->pads
[i
];
339 (OMAP_DEVICE_PAD_REMUX
| OMAP_DEVICE_PAD_WAKEUP
)) {
340 pr_debug("%s: pad %s tagged dynamic\n",
341 __func__
, pad
->name
);
342 hmux
->pads_dynamic
[nr_pads_dynamic
] = pad
;
354 pr_err("%s: Could not allocate device mux entry\n", __func__
);
360 * omap_hwmod_mux_scan_wakeups - omap hwmod scan wakeup pads
361 * @hmux: Pads for a hwmod
362 * @mpu_irqs: MPU irq array for a hwmod
364 * Scans the wakeup status of pads for a single hwmod. If an irq
365 * array is defined for this mux, the parser will call the registered
366 * ISRs for corresponding pads, otherwise the parser will stop at the
367 * first wakeup active pad and return. Returns true if there is a
368 * pending and non-served wakeup event for the mux, otherwise false.
370 static bool omap_hwmod_mux_scan_wakeups(struct omap_hwmod_mux_info
*hmux
,
371 struct omap_hwmod_irq_info
*mpu_irqs
)
375 u32 handled_irqs
= 0;
377 for (i
= 0; i
< hmux
->nr_pads_dynamic
; i
++) {
378 struct omap_device_pad
*pad
= hmux
->pads_dynamic
[i
];
380 if (!(pad
->flags
& OMAP_DEVICE_PAD_WAKEUP
) ||
381 !(pad
->idle
& OMAP_WAKEUP_EN
))
384 val
= omap_mux_read(pad
->partition
, pad
->mux
->reg_offset
);
385 if (!(val
& OMAP_WAKEUP_EVENT
))
392 /* make sure we only handle each irq once */
393 if (handled_irqs
& 1 << irq
)
396 handled_irqs
|= 1 << irq
;
398 generic_handle_irq(mpu_irqs
[irq
].irq
);
405 * _omap_hwmod_mux_handle_irq - Process wakeup events for a single hwmod
407 * Checks a single hwmod for every wakeup capable pad to see if there is an
408 * active wakeup event. If this is the case, call the corresponding ISR.
410 static int _omap_hwmod_mux_handle_irq(struct omap_hwmod
*oh
, void *data
)
412 if (!oh
->mux
|| !oh
->mux
->enabled
)
414 if (omap_hwmod_mux_scan_wakeups(oh
->mux
, oh
->mpu_irqs
))
415 generic_handle_irq(oh
->mpu_irqs
[0].irq
);
420 * omap_hwmod_mux_handle_irq - Process pad wakeup irqs.
422 * Calls a function for each registered omap_hwmod to check
423 * pad wakeup statuses.
425 static irqreturn_t
omap_hwmod_mux_handle_irq(int irq
, void *unused
)
427 omap_hwmod_for_each(_omap_hwmod_mux_handle_irq
, NULL
);
431 /* Assumes the calling function takes care of locking */
432 void omap_hwmod_mux(struct omap_hwmod_mux_info
*hmux
, u8 state
)
436 /* Runtime idling of dynamic pads */
437 if (state
== _HWMOD_STATE_IDLE
&& hmux
->enabled
) {
438 for (i
= 0; i
< hmux
->nr_pads_dynamic
; i
++) {
439 struct omap_device_pad
*pad
= hmux
->pads_dynamic
[i
];
443 omap_mux_write(pad
->partition
, val
,
444 pad
->mux
->reg_offset
);
450 /* Runtime enabling of dynamic pads */
451 if ((state
== _HWMOD_STATE_ENABLED
) && hmux
->pads_dynamic
453 for (i
= 0; i
< hmux
->nr_pads_dynamic
; i
++) {
454 struct omap_device_pad
*pad
= hmux
->pads_dynamic
[i
];
458 omap_mux_write(pad
->partition
, val
,
459 pad
->mux
->reg_offset
);
465 /* Enabling or disabling of all pads */
466 for (i
= 0; i
< hmux
->nr_pads
; i
++) {
467 struct omap_device_pad
*pad
= &hmux
->pads
[i
];
468 int flags
, val
= -EINVAL
;
473 case _HWMOD_STATE_ENABLED
:
475 pr_debug("%s: Enabling %s %x\n", __func__
,
478 case _HWMOD_STATE_DISABLED
:
479 /* Use safe mode unless OMAP_DEVICE_PAD_REMUX */
480 if (flags
& OMAP_DEVICE_PAD_REMUX
)
483 val
= OMAP_MUX_MODE7
;
484 pr_debug("%s: Disabling %s %x\n", __func__
,
488 /* Nothing to be done */
493 omap_mux_write(pad
->partition
, val
,
494 pad
->mux
->reg_offset
);
499 if (state
== _HWMOD_STATE_ENABLED
)
500 hmux
->enabled
= true;
502 hmux
->enabled
= false;
505 #ifdef CONFIG_DEBUG_FS
507 #define OMAP_MUX_MAX_NR_FLAGS 10
508 #define OMAP_MUX_TEST_FLAG(val, mask) \
509 if (((val) & (mask)) == (mask)) { \
514 /* REVISIT: Add checking for non-optimal mux settings */
515 static inline void omap_mux_decode(struct seq_file
*s
, u16 val
)
517 char *flags
[OMAP_MUX_MAX_NR_FLAGS
];
518 char mode
[sizeof("OMAP_MUX_MODE") + 1];
521 sprintf(mode
, "OMAP_MUX_MODE%d", val
& 0x7);
525 OMAP_MUX_TEST_FLAG(val
, OMAP_PIN_OFF_WAKEUPENABLE
);
526 if (val
& OMAP_OFF_EN
) {
527 if (!(val
& OMAP_OFFOUT_EN
)) {
528 if (!(val
& OMAP_OFF_PULL_UP
)) {
529 OMAP_MUX_TEST_FLAG(val
,
530 OMAP_PIN_OFF_INPUT_PULLDOWN
);
532 OMAP_MUX_TEST_FLAG(val
,
533 OMAP_PIN_OFF_INPUT_PULLUP
);
536 if (!(val
& OMAP_OFFOUT_VAL
)) {
537 OMAP_MUX_TEST_FLAG(val
,
538 OMAP_PIN_OFF_OUTPUT_LOW
);
540 OMAP_MUX_TEST_FLAG(val
,
541 OMAP_PIN_OFF_OUTPUT_HIGH
);
546 if (val
& OMAP_INPUT_EN
) {
547 if (val
& OMAP_PULL_ENA
) {
548 if (!(val
& OMAP_PULL_UP
)) {
549 OMAP_MUX_TEST_FLAG(val
,
550 OMAP_PIN_INPUT_PULLDOWN
);
552 OMAP_MUX_TEST_FLAG(val
, OMAP_PIN_INPUT_PULLUP
);
555 OMAP_MUX_TEST_FLAG(val
, OMAP_PIN_INPUT
);
559 flags
[i
] = "OMAP_PIN_OUTPUT";
563 seq_printf(s
, "%s", flags
[i
]);
565 seq_printf(s
, " | ");
569 #define OMAP_MUX_DEFNAME_LEN 32
571 static int omap_mux_dbg_board_show(struct seq_file
*s
, void *unused
)
573 struct omap_mux_partition
*partition
= s
->private;
574 struct omap_mux_entry
*e
;
575 u8 omap_gen
= omap_rev() >> 28;
577 list_for_each_entry(e
, &partition
->muxmodes
, node
) {
578 struct omap_mux
*m
= &e
->mux
;
579 char m0_def
[OMAP_MUX_DEFNAME_LEN
];
580 char *m0_name
= m
->muxnames
[0];
587 /* REVISIT: Needs to be updated if mode0 names get longer */
588 for (i
= 0; i
< OMAP_MUX_DEFNAME_LEN
; i
++) {
589 if (m0_name
[i
] == '\0') {
590 m0_def
[i
] = m0_name
[i
];
593 m0_def
[i
] = toupper(m0_name
[i
]);
595 val
= omap_mux_read(partition
, m
->reg_offset
);
596 mode
= val
& OMAP_MUX_MODE7
;
598 seq_printf(s
, "/* %s */\n", m
->muxnames
[mode
]);
601 * XXX: Might be revisited to support differences across
602 * same OMAP generation.
604 seq_printf(s
, "OMAP%d_MUX(%s, ", omap_gen
, m0_def
);
605 omap_mux_decode(s
, val
);
606 seq_printf(s
, "),\n");
612 static int omap_mux_dbg_board_open(struct inode
*inode
, struct file
*file
)
614 return single_open(file
, omap_mux_dbg_board_show
, inode
->i_private
);
617 static const struct file_operations omap_mux_dbg_board_fops
= {
618 .open
= omap_mux_dbg_board_open
,
621 .release
= single_release
,
624 static struct omap_mux_partition
*omap_mux_get_partition(struct omap_mux
*mux
)
626 struct omap_mux_partition
*partition
;
628 list_for_each_entry(partition
, &mux_partitions
, node
) {
629 struct list_head
*muxmodes
= &partition
->muxmodes
;
630 struct omap_mux_entry
*e
;
632 list_for_each_entry(e
, muxmodes
, node
) {
633 struct omap_mux
*m
= &e
->mux
;
643 static int omap_mux_dbg_signal_show(struct seq_file
*s
, void *unused
)
645 struct omap_mux
*m
= s
->private;
646 struct omap_mux_partition
*partition
;
647 const char *none
= "NA";
651 partition
= omap_mux_get_partition(m
);
655 val
= omap_mux_read(partition
, m
->reg_offset
);
656 mode
= val
& OMAP_MUX_MODE7
;
658 seq_printf(s
, "name: %s.%s (0x%08x/0x%03x = 0x%04x), b %s, t %s\n",
659 m
->muxnames
[0], m
->muxnames
[mode
],
660 partition
->phys
+ m
->reg_offset
, m
->reg_offset
, val
,
661 m
->balls
[0] ? m
->balls
[0] : none
,
662 m
->balls
[1] ? m
->balls
[1] : none
);
663 seq_printf(s
, "mode: ");
664 omap_mux_decode(s
, val
);
666 seq_printf(s
, "signals: %s | %s | %s | %s | %s | %s | %s | %s\n",
667 m
->muxnames
[0] ? m
->muxnames
[0] : none
,
668 m
->muxnames
[1] ? m
->muxnames
[1] : none
,
669 m
->muxnames
[2] ? m
->muxnames
[2] : none
,
670 m
->muxnames
[3] ? m
->muxnames
[3] : none
,
671 m
->muxnames
[4] ? m
->muxnames
[4] : none
,
672 m
->muxnames
[5] ? m
->muxnames
[5] : none
,
673 m
->muxnames
[6] ? m
->muxnames
[6] : none
,
674 m
->muxnames
[7] ? m
->muxnames
[7] : none
);
679 #define OMAP_MUX_MAX_ARG_CHAR 7
681 static ssize_t
omap_mux_dbg_signal_write(struct file
*file
,
682 const char __user
*user_buf
,
683 size_t count
, loff_t
*ppos
)
685 char buf
[OMAP_MUX_MAX_ARG_CHAR
];
686 struct seq_file
*seqf
;
690 struct omap_mux_partition
*partition
;
692 if (count
> OMAP_MUX_MAX_ARG_CHAR
)
695 memset(buf
, 0, sizeof(buf
));
696 buf_size
= min(count
, sizeof(buf
) - 1);
698 if (copy_from_user(buf
, user_buf
, buf_size
))
701 ret
= strict_strtoul(buf
, 0x10, &val
);
708 seqf
= file
->private_data
;
711 partition
= omap_mux_get_partition(m
);
715 omap_mux_write(partition
, (u16
)val
, m
->reg_offset
);
721 static int omap_mux_dbg_signal_open(struct inode
*inode
, struct file
*file
)
723 return single_open(file
, omap_mux_dbg_signal_show
, inode
->i_private
);
726 static const struct file_operations omap_mux_dbg_signal_fops
= {
727 .open
= omap_mux_dbg_signal_open
,
729 .write
= omap_mux_dbg_signal_write
,
731 .release
= single_release
,
734 static struct dentry
*mux_dbg_dir
;
736 static void __init
omap_mux_dbg_create_entry(
737 struct omap_mux_partition
*partition
,
738 struct dentry
*mux_dbg_dir
)
740 struct omap_mux_entry
*e
;
742 list_for_each_entry(e
, &partition
->muxmodes
, node
) {
743 struct omap_mux
*m
= &e
->mux
;
745 (void)debugfs_create_file(m
->muxnames
[0], S_IWUSR
, mux_dbg_dir
,
746 m
, &omap_mux_dbg_signal_fops
);
750 static void __init
omap_mux_dbg_init(void)
752 struct omap_mux_partition
*partition
;
753 static struct dentry
*mux_dbg_board_dir
;
755 mux_dbg_dir
= debugfs_create_dir("omap_mux", NULL
);
759 mux_dbg_board_dir
= debugfs_create_dir("board", mux_dbg_dir
);
760 if (!mux_dbg_board_dir
)
763 list_for_each_entry(partition
, &mux_partitions
, node
) {
764 omap_mux_dbg_create_entry(partition
, mux_dbg_dir
);
765 (void)debugfs_create_file(partition
->name
, S_IRUGO
,
766 mux_dbg_board_dir
, partition
,
767 &omap_mux_dbg_board_fops
);
772 static inline void omap_mux_dbg_init(void)
775 #endif /* CONFIG_DEBUG_FS */
777 static void __init
omap_mux_free_names(struct omap_mux
*m
)
781 for (i
= 0; i
< OMAP_MUX_NR_MODES
; i
++)
782 kfree(m
->muxnames
[i
]);
784 #ifdef CONFIG_DEBUG_FS
785 for (i
= 0; i
< OMAP_MUX_NR_SIDES
; i
++)
791 /* Free all data except for GPIO pins unless CONFIG_DEBUG_FS is set */
792 int __init
omap_mux_late_init(void)
794 struct omap_mux_partition
*partition
;
797 list_for_each_entry(partition
, &mux_partitions
, node
) {
798 struct omap_mux_entry
*e
, *tmp
;
799 list_for_each_entry_safe(e
, tmp
, &partition
->muxmodes
, node
) {
800 struct omap_mux
*m
= &e
->mux
;
801 u16 mode
= omap_mux_read(partition
, m
->reg_offset
);
803 if (OMAP_MODE_GPIO(mode
))
806 #ifndef CONFIG_DEBUG_FS
807 mutex_lock(&muxmode_mutex
);
809 mutex_unlock(&muxmode_mutex
);
810 omap_mux_free_names(m
);
816 ret
= request_irq(omap_prcm_event_to_irq("io"),
817 omap_hwmod_mux_handle_irq
, IRQF_SHARED
| IRQF_NO_SUSPEND
,
818 "hwmod_io", omap_mux_late_init
);
821 pr_warning("mux: Failed to setup hwmod io irq %d\n", ret
);
828 static void __init
omap_mux_package_fixup(struct omap_mux
*p
,
829 struct omap_mux
*superset
)
831 while (p
->reg_offset
!= OMAP_MUX_TERMINATOR
) {
832 struct omap_mux
*s
= superset
;
835 while (s
->reg_offset
!= OMAP_MUX_TERMINATOR
) {
836 if (s
->reg_offset
== p
->reg_offset
) {
844 pr_err("%s: Unknown entry offset 0x%x\n", __func__
,
850 #ifdef CONFIG_DEBUG_FS
852 static void __init
omap_mux_package_init_balls(struct omap_ball
*b
,
853 struct omap_mux
*superset
)
855 while (b
->reg_offset
!= OMAP_MUX_TERMINATOR
) {
856 struct omap_mux
*s
= superset
;
859 while (s
->reg_offset
!= OMAP_MUX_TERMINATOR
) {
860 if (s
->reg_offset
== b
->reg_offset
) {
861 s
->balls
[0] = b
->balls
[0];
862 s
->balls
[1] = b
->balls
[1];
869 pr_err("%s: Unknown ball offset 0x%x\n", __func__
,
875 #else /* CONFIG_DEBUG_FS */
877 static inline void omap_mux_package_init_balls(struct omap_ball
*b
,
878 struct omap_mux
*superset
)
882 #endif /* CONFIG_DEBUG_FS */
884 static int __init
omap_mux_setup(char *options
)
889 omap_mux_options
= options
;
893 __setup("omap_mux=", omap_mux_setup
);
896 * Note that the omap_mux=some.signal1=0x1234,some.signal2=0x1234
897 * cmdline options only override the bootloader values.
898 * During development, please enable CONFIG_DEBUG_FS, and use the
899 * signal specific entries under debugfs.
901 static void __init
omap_mux_set_cmdline_signals(void)
903 char *options
, *next_opt
, *token
;
905 if (!omap_mux_options
)
908 options
= kstrdup(omap_mux_options
, GFP_KERNEL
);
914 while ((token
= strsep(&next_opt
, ",")) != NULL
) {
919 name
= strsep(&keyval
, "=");
923 res
= strict_strtoul(keyval
, 0x10, &val
);
927 omap_mux_init_signal(name
, (u16
)val
);
934 static int __init
omap_mux_copy_names(struct omap_mux
*src
,
935 struct omap_mux
*dst
)
939 for (i
= 0; i
< OMAP_MUX_NR_MODES
; i
++) {
940 if (src
->muxnames
[i
]) {
941 dst
->muxnames
[i
] = kstrdup(src
->muxnames
[i
],
943 if (!dst
->muxnames
[i
])
948 #ifdef CONFIG_DEBUG_FS
949 for (i
= 0; i
< OMAP_MUX_NR_SIDES
; i
++) {
951 dst
->balls
[i
] = kstrdup(src
->balls
[i
], GFP_KERNEL
);
961 omap_mux_free_names(dst
);
966 #endif /* CONFIG_OMAP_MUX */
968 static struct omap_mux
*omap_mux_get_by_gpio(
969 struct omap_mux_partition
*partition
,
972 struct omap_mux_entry
*e
;
973 struct omap_mux
*ret
= NULL
;
975 list_for_each_entry(e
, &partition
->muxmodes
, node
) {
976 struct omap_mux
*m
= &e
->mux
;
977 if (m
->gpio
== gpio
) {
986 /* Needed for dynamic muxing of GPIO pins for off-idle */
987 u16
omap_mux_get_gpio(int gpio
)
989 struct omap_mux_partition
*partition
;
990 struct omap_mux
*m
= NULL
;
992 list_for_each_entry(partition
, &mux_partitions
, node
) {
993 m
= omap_mux_get_by_gpio(partition
, gpio
);
995 return omap_mux_read(partition
, m
->reg_offset
);
998 if (!m
|| m
->reg_offset
== OMAP_MUX_TERMINATOR
)
999 pr_err("%s: Could not get gpio%i\n", __func__
, gpio
);
1001 return OMAP_MUX_TERMINATOR
;
1004 /* Needed for dynamic muxing of GPIO pins for off-idle */
1005 void omap_mux_set_gpio(u16 val
, int gpio
)
1007 struct omap_mux_partition
*partition
;
1008 struct omap_mux
*m
= NULL
;
1010 list_for_each_entry(partition
, &mux_partitions
, node
) {
1011 m
= omap_mux_get_by_gpio(partition
, gpio
);
1013 omap_mux_write(partition
, val
, m
->reg_offset
);
1018 if (!m
|| m
->reg_offset
== OMAP_MUX_TERMINATOR
)
1019 pr_err("%s: Could not set gpio%i\n", __func__
, gpio
);
1022 static struct omap_mux
* __init
omap_mux_list_add(
1023 struct omap_mux_partition
*partition
,
1024 struct omap_mux
*src
)
1026 struct omap_mux_entry
*entry
;
1029 entry
= kzalloc(sizeof(struct omap_mux_entry
), GFP_KERNEL
);
1036 #ifdef CONFIG_OMAP_MUX
1037 if (omap_mux_copy_names(src
, m
)) {
1043 mutex_lock(&muxmode_mutex
);
1044 list_add_tail(&entry
->node
, &partition
->muxmodes
);
1045 mutex_unlock(&muxmode_mutex
);
1051 * Note if CONFIG_OMAP_MUX is not selected, we will only initialize
1052 * the GPIO to mux offset mapping that is needed for dynamic muxing
1053 * of GPIO pins for off-idle.
1055 static void __init
omap_mux_init_list(struct omap_mux_partition
*partition
,
1056 struct omap_mux
*superset
)
1058 while (superset
->reg_offset
!= OMAP_MUX_TERMINATOR
) {
1059 struct omap_mux
*entry
;
1061 #ifdef CONFIG_OMAP_MUX
1062 if (!superset
->muxnames
|| !superset
->muxnames
[0]) {
1067 /* Skip pins that are not muxed as GPIO by bootloader */
1068 if (!OMAP_MODE_GPIO(omap_mux_read(partition
,
1069 superset
->reg_offset
))) {
1075 entry
= omap_mux_list_add(partition
, superset
);
1077 pr_err("%s: Could not add entry\n", __func__
);
1084 #ifdef CONFIG_OMAP_MUX
1086 static void omap_mux_init_package(struct omap_mux
*superset
,
1087 struct omap_mux
*package_subset
,
1088 struct omap_ball
*package_balls
)
1091 omap_mux_package_fixup(package_subset
, superset
);
1093 omap_mux_package_init_balls(package_balls
, superset
);
1096 static void __init
omap_mux_init_signals(struct omap_mux_partition
*partition
,
1097 struct omap_board_mux
*board_mux
)
1099 omap_mux_set_cmdline_signals();
1100 omap_mux_write_array(partition
, board_mux
);
1105 static void omap_mux_init_package(struct omap_mux
*superset
,
1106 struct omap_mux
*package_subset
,
1107 struct omap_ball
*package_balls
)
1111 static void __init
omap_mux_init_signals(struct omap_mux_partition
*partition
,
1112 struct omap_board_mux
*board_mux
)
1118 static u32 mux_partitions_cnt
;
1120 int __init
omap_mux_init(const char *name
, u32 flags
,
1121 u32 mux_pbase
, u32 mux_size
,
1122 struct omap_mux
*superset
,
1123 struct omap_mux
*package_subset
,
1124 struct omap_board_mux
*board_mux
,
1125 struct omap_ball
*package_balls
)
1127 struct omap_mux_partition
*partition
;
1129 partition
= kzalloc(sizeof(struct omap_mux_partition
), GFP_KERNEL
);
1133 partition
->name
= name
;
1134 partition
->flags
= flags
;
1135 partition
->size
= mux_size
;
1136 partition
->phys
= mux_pbase
;
1137 partition
->base
= ioremap(mux_pbase
, mux_size
);
1138 if (!partition
->base
) {
1139 pr_err("%s: Could not ioremap mux partition at 0x%08x\n",
1140 __func__
, partition
->phys
);
1145 INIT_LIST_HEAD(&partition
->muxmodes
);
1147 list_add_tail(&partition
->node
, &mux_partitions
);
1148 mux_partitions_cnt
++;
1149 pr_info("%s: Add partition: #%d: %s, flags: %x\n", __func__
,
1150 mux_partitions_cnt
, partition
->name
, partition
->flags
);
1152 omap_mux_init_package(superset
, package_subset
, package_balls
);
1153 omap_mux_init_list(partition
, superset
);
1154 omap_mux_init_signals(partition
, board_mux
);