OMAP: control: move plat-omap/control.h to mach-omap2/control.h
[linux-2.6.git] / arch / arm / mach-omap2 / mux.c
1 /*
2  * linux/arch/arm/mach-omap2/mux.c
3  *
4  * OMAP2 and OMAP3 pin multiplexing configurations
5  *
6  * Copyright (C) 2004 - 2008 Texas Instruments Inc.
7  * Copyright (C) 2003 - 2008 Nokia Corporation
8  *
9  * Written by Tony Lindgren
10  *
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.
15  *
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.
20  *
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
24  *
25  */
26 #include <linux/kernel.h>
27 #include <linux/init.h>
28 #include <linux/io.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
36 #include <asm/system.h>
37
38 #include "control.h"
39 #include "mux.h"
40
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)
44
45 struct omap_mux_entry {
46         struct omap_mux         mux;
47         struct list_head        node;
48 };
49
50 static unsigned long mux_phys;
51 static void __iomem *mux_base;
52 static u8 omap_mux_flags;
53
54 u16 omap_mux_read(u16 reg)
55 {
56         if (cpu_is_omap24xx())
57                 return __raw_readb(mux_base + reg);
58         else
59                 return __raw_readw(mux_base + reg);
60 }
61
62 void omap_mux_write(u16 val, u16 reg)
63 {
64         if (cpu_is_omap24xx())
65                 __raw_writeb(val, mux_base + reg);
66         else
67                 __raw_writew(val, mux_base + reg);
68 }
69
70 void omap_mux_write_array(struct omap_board_mux *board_mux)
71 {
72         while (board_mux->reg_offset !=  OMAP_MUX_TERMINATOR) {
73                 omap_mux_write(board_mux->value, board_mux->reg_offset);
74                 board_mux++;
75         }
76 }
77
78 static LIST_HEAD(muxmodes);
79 static DEFINE_MUTEX(muxmode_mutex);
80
81 #ifdef CONFIG_OMAP_MUX
82
83 static char *omap_mux_options;
84
85 int __init omap_mux_init_gpio(int gpio, int val)
86 {
87         struct omap_mux_entry *e;
88         struct omap_mux *gpio_mux = NULL;
89         u16 old_mode;
90         u16 mux_mode;
91         int found = 0;
92
93         if (!gpio)
94                 return -EINVAL;
95
96         list_for_each_entry(e, &muxmodes, node) {
97                 struct omap_mux *m = &e->mux;
98                 if (gpio == m->gpio) {
99                         gpio_mux = m;
100                         found++;
101                 }
102         }
103
104         if (found == 0) {
105                 printk(KERN_ERR "mux: Could not set gpio%i\n", gpio);
106                 return -ENODEV;
107         }
108
109         if (found > 1) {
110                 printk(KERN_INFO "mux: Multiple gpio paths (%d) for gpio%i\n",
111                                 found, gpio);
112                 return -EINVAL;
113         }
114
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;
119         else
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);
124
125         return 0;
126 }
127
128 int __init omap_mux_init_signal(const char *muxname, int val)
129 {
130         struct omap_mux_entry *e;
131         const char *mode_name;
132         int found = 0, mode0_len = 0;
133
134         mode_name = strchr(muxname, '.');
135         if (mode_name) {
136                 mode0_len = strlen(muxname) - strlen(mode_name);
137                 mode_name++;
138         } else {
139                 mode_name = muxname;
140         }
141
142         list_for_each_entry(e, &muxmodes, node) {
143                 struct omap_mux *m = &e->mux;
144                 char *m0_entry = m->muxnames[0];
145                 int i;
146
147                 /* First check for full name in mode0.muxmode format */
148                 if (mode0_len && strncmp(muxname, m0_entry, mode0_len))
149                         continue;
150
151                 /* Then check for muxmode only */
152                 for (i = 0; i < OMAP_MUX_NR_MODES; i++) {
153                         char *mode_cur = m->muxnames[i];
154
155                         if (!mode_cur)
156                                 continue;
157
158                         if (!strcmp(mode_name, mode_cur)) {
159                                 u16 old_mode;
160                                 u16 mux_mode;
161
162                                 old_mode = omap_mux_read(m->reg_offset);
163                                 mux_mode = val | i;
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);
168                                 found++;
169                         }
170                 }
171         }
172
173         if (found == 1)
174                 return 0;
175
176         if (found > 1) {
177                 printk(KERN_ERR "mux: Multiple signal paths (%i) for %s\n",
178                                 found, muxname);
179                 return -EINVAL;
180         }
181
182         printk(KERN_ERR "mux: Could not set signal %s\n", muxname);
183
184         return -ENODEV;
185 }
186
187 #ifdef CONFIG_DEBUG_FS
188
189 #define OMAP_MUX_MAX_NR_FLAGS   10
190 #define OMAP_MUX_TEST_FLAG(val, mask)                           \
191         if (((val) & (mask)) == (mask)) {                       \
192                 i++;                                            \
193                 flags[i] =  #mask;                              \
194         }
195
196 /* REVISIT: Add checking for non-optimal mux settings */
197 static inline void omap_mux_decode(struct seq_file *s, u16 val)
198 {
199         char *flags[OMAP_MUX_MAX_NR_FLAGS];
200         char mode[sizeof("OMAP_MUX_MODE") + 1];
201         int i = -1;
202
203         sprintf(mode, "OMAP_MUX_MODE%d", val & 0x7);
204         i++;
205         flags[i] = mode;
206
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);
213                         } else {
214                                 OMAP_MUX_TEST_FLAG(val,
215                                         OMAP_PIN_OFF_INPUT_PULLUP);
216                         }
217                 } else {
218                         if (!(val & OMAP_OFFOUT_VAL)) {
219                                 OMAP_MUX_TEST_FLAG(val,
220                                         OMAP_PIN_OFF_OUTPUT_LOW);
221                         } else {
222                                 OMAP_MUX_TEST_FLAG(val,
223                                         OMAP_PIN_OFF_OUTPUT_HIGH);
224                         }
225                 }
226         }
227
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);
233                         } else {
234                                 OMAP_MUX_TEST_FLAG(val, OMAP_PIN_INPUT_PULLUP);
235                         }
236                 } else {
237                         OMAP_MUX_TEST_FLAG(val, OMAP_PIN_INPUT);
238                 }
239         } else {
240                 i++;
241                 flags[i] = "OMAP_PIN_OUTPUT";
242         }
243
244         do {
245                 seq_printf(s, "%s", flags[i]);
246                 if (i > 0)
247                         seq_printf(s, " | ");
248         } while (i-- > 0);
249 }
250
251 #define OMAP_MUX_DEFNAME_LEN    16
252
253 static int omap_mux_dbg_board_show(struct seq_file *s, void *unused)
254 {
255         struct omap_mux_entry *e;
256
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];
261                 u16 val;
262                 int i, mode;
263
264                 if (!m0_name)
265                         continue;
266
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];
271                                 break;
272                         }
273                         m0_def[i] = toupper(m0_name[i]);
274                 }
275                 val = omap_mux_read(m->reg_offset);
276                 mode = val & OMAP_MUX_MODE7;
277
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");
282         }
283
284         return 0;
285 }
286
287 static int omap_mux_dbg_board_open(struct inode *inode, struct file *file)
288 {
289         return single_open(file, omap_mux_dbg_board_show, &inode->i_private);
290 }
291
292 static const struct file_operations omap_mux_dbg_board_fops = {
293         .open           = omap_mux_dbg_board_open,
294         .read           = seq_read,
295         .llseek         = seq_lseek,
296         .release        = single_release,
297 };
298
299 static int omap_mux_dbg_signal_show(struct seq_file *s, void *unused)
300 {
301         struct omap_mux *m = s->private;
302         const char *none = "NA";
303         u16 val;
304         int mode;
305
306         val = omap_mux_read(m->reg_offset);
307         mode = val & OMAP_MUX_MODE7;
308
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);
316         seq_printf(s, "\n");
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);
326
327         return 0;
328 }
329
330 #define OMAP_MUX_MAX_ARG_CHAR  7
331
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)
335 {
336         char buf[OMAP_MUX_MAX_ARG_CHAR];
337         struct seq_file *seqf;
338         struct omap_mux *m;
339         unsigned long val;
340         int buf_size, ret;
341
342         if (count > OMAP_MUX_MAX_ARG_CHAR)
343                 return -EINVAL;
344
345         memset(buf, 0, sizeof(buf));
346         buf_size = min(count, sizeof(buf) - 1);
347
348         if (copy_from_user(buf, user_buf, buf_size))
349                 return -EFAULT;
350
351         ret = strict_strtoul(buf, 0x10, &val);
352         if (ret < 0)
353                 return ret;
354
355         if (val > 0xffff)
356                 return -EINVAL;
357
358         seqf = file->private_data;
359         m = seqf->private;
360
361         omap_mux_write((u16)val, m->reg_offset);
362         *ppos += count;
363
364         return count;
365 }
366
367 static int omap_mux_dbg_signal_open(struct inode *inode, struct file *file)
368 {
369         return single_open(file, omap_mux_dbg_signal_show, inode->i_private);
370 }
371
372 static const struct file_operations omap_mux_dbg_signal_fops = {
373         .open           = omap_mux_dbg_signal_open,
374         .read           = seq_read,
375         .write          = omap_mux_dbg_signal_write,
376         .llseek         = seq_lseek,
377         .release        = single_release,
378 };
379
380 static struct dentry *mux_dbg_dir;
381
382 static void __init omap_mux_dbg_init(void)
383 {
384         struct omap_mux_entry *e;
385
386         mux_dbg_dir = debugfs_create_dir("omap_mux", NULL);
387         if (!mux_dbg_dir)
388                 return;
389
390         (void)debugfs_create_file("board", S_IRUGO, mux_dbg_dir,
391                                         NULL, &omap_mux_dbg_board_fops);
392
393         list_for_each_entry(e, &muxmodes, node) {
394                 struct omap_mux *m = &e->mux;
395
396                 (void)debugfs_create_file(m->muxnames[0], S_IWUGO, mux_dbg_dir,
397                                         m, &omap_mux_dbg_signal_fops);
398         }
399 }
400
401 #else
402 static inline void omap_mux_dbg_init(void)
403 {
404 }
405 #endif  /* CONFIG_DEBUG_FS */
406
407 static void __init omap_mux_free_names(struct omap_mux *m)
408 {
409         int i;
410
411         for (i = 0; i < OMAP_MUX_NR_MODES; i++)
412                 kfree(m->muxnames[i]);
413
414 #ifdef CONFIG_DEBUG_FS
415         for (i = 0; i < OMAP_MUX_NR_SIDES; i++)
416                 kfree(m->balls[i]);
417 #endif
418
419 }
420
421 /* Free all data except for GPIO pins unless CONFIG_DEBUG_FS is set */
422 static int __init omap_mux_late_init(void)
423 {
424         struct omap_mux_entry *e, *tmp;
425
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);
429
430                 if (OMAP_MODE_GPIO(mode))
431                         continue;
432
433 #ifndef CONFIG_DEBUG_FS
434                 mutex_lock(&muxmode_mutex);
435                 list_del(&e->node);
436                 mutex_unlock(&muxmode_mutex);
437                 omap_mux_free_names(m);
438                 kfree(m);
439 #endif
440
441         }
442
443         omap_mux_dbg_init();
444
445         return 0;
446 }
447 late_initcall(omap_mux_late_init);
448
449 static void __init omap_mux_package_fixup(struct omap_mux *p,
450                                         struct omap_mux *superset)
451 {
452         while (p->reg_offset !=  OMAP_MUX_TERMINATOR) {
453                 struct omap_mux *s = superset;
454                 int found = 0;
455
456                 while (s->reg_offset != OMAP_MUX_TERMINATOR) {
457                         if (s->reg_offset == p->reg_offset) {
458                                 *s = *p;
459                                 found++;
460                                 break;
461                         }
462                         s++;
463                 }
464                 if (!found)
465                         printk(KERN_ERR "mux: Unknown entry offset 0x%x\n",
466                                         p->reg_offset);
467                 p++;
468         }
469 }
470
471 #ifdef CONFIG_DEBUG_FS
472
473 static void __init omap_mux_package_init_balls(struct omap_ball *b,
474                                 struct omap_mux *superset)
475 {
476         while (b->reg_offset != OMAP_MUX_TERMINATOR) {
477                 struct omap_mux *s = superset;
478                 int found = 0;
479
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];
484                                 found++;
485                                 break;
486                         }
487                         s++;
488                 }
489                 if (!found)
490                         printk(KERN_ERR "mux: Unknown ball offset 0x%x\n",
491                                         b->reg_offset);
492                 b++;
493         }
494 }
495
496 #else   /* CONFIG_DEBUG_FS */
497
498 static inline void omap_mux_package_init_balls(struct omap_ball *b,
499                                         struct omap_mux *superset)
500 {
501 }
502
503 #endif  /* CONFIG_DEBUG_FS */
504
505 static int __init omap_mux_setup(char *options)
506 {
507         if (!options)
508                 return 0;
509
510         omap_mux_options = options;
511
512         return 1;
513 }
514 __setup("omap_mux=", omap_mux_setup);
515
516 /*
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.
521  */
522 static void __init omap_mux_set_cmdline_signals(void)
523 {
524         char *options, *next_opt, *token;
525
526         if (!omap_mux_options)
527                 return;
528
529         options = kmalloc(strlen(omap_mux_options) + 1, GFP_KERNEL);
530         if (!options)
531                 return;
532
533         strcpy(options, omap_mux_options);
534         next_opt = options;
535
536         while ((token = strsep(&next_opt, ",")) != NULL) {
537                 char *keyval, *name;
538                 unsigned long val;
539
540                 keyval = token;
541                 name = strsep(&keyval, "=");
542                 if (name) {
543                         int res;
544
545                         res = strict_strtoul(keyval, 0x10, &val);
546                         if (res < 0)
547                                 continue;
548
549                         omap_mux_init_signal(name, (u16)val);
550                 }
551         }
552
553         kfree(options);
554 }
555
556 static int __init omap_mux_copy_names(struct omap_mux *src,
557                                         struct omap_mux *dst)
558 {
559         int i;
560
561         for (i = 0; i < OMAP_MUX_NR_MODES; i++) {
562                 if (src->muxnames[i]) {
563                         dst->muxnames[i] =
564                                 kmalloc(strlen(src->muxnames[i]) + 1,
565                                         GFP_KERNEL);
566                         if (!dst->muxnames[i])
567                                 goto free;
568                         strcpy(dst->muxnames[i], src->muxnames[i]);
569                 }
570         }
571
572 #ifdef CONFIG_DEBUG_FS
573         for (i = 0; i < OMAP_MUX_NR_SIDES; i++) {
574                 if (src->balls[i]) {
575                         dst->balls[i] =
576                                 kmalloc(strlen(src->balls[i]) + 1,
577                                         GFP_KERNEL);
578                         if (!dst->balls[i])
579                                 goto free;
580                         strcpy(dst->balls[i], src->balls[i]);
581                 }
582         }
583 #endif
584
585         return 0;
586
587 free:
588         omap_mux_free_names(dst);
589         return -ENOMEM;
590
591 }
592
593 #endif  /* CONFIG_OMAP_MUX */
594
595 static u16 omap_mux_get_by_gpio(int gpio)
596 {
597         struct omap_mux_entry *e;
598         u16 offset = OMAP_MUX_TERMINATOR;
599
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;
604                         break;
605                 }
606         }
607
608         return offset;
609 }
610
611 /* Needed for dynamic muxing of GPIO pins for off-idle */
612 u16 omap_mux_get_gpio(int gpio)
613 {
614         u16 offset;
615
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);
619                 return offset;
620         }
621
622         return omap_mux_read(offset);
623 }
624
625 /* Needed for dynamic muxing of GPIO pins for off-idle */
626 void omap_mux_set_gpio(u16 val, int gpio)
627 {
628         u16 offset;
629
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);
633                 return;
634         }
635
636         omap_mux_write(val, offset);
637 }
638
639 static struct omap_mux * __init omap_mux_list_add(struct omap_mux *src)
640 {
641         struct omap_mux_entry *entry;
642         struct omap_mux *m;
643
644         entry = kzalloc(sizeof(struct omap_mux_entry), GFP_KERNEL);
645         if (!entry)
646                 return NULL;
647
648         m = &entry->mux;
649         memcpy(m, src, sizeof(struct omap_mux_entry));
650
651 #ifdef CONFIG_OMAP_MUX
652         if (omap_mux_copy_names(src, m)) {
653                 kfree(entry);
654                 return NULL;
655         }
656 #endif
657
658         mutex_lock(&muxmode_mutex);
659         list_add_tail(&entry->node, &muxmodes);
660         mutex_unlock(&muxmode_mutex);
661
662         return m;
663 }
664
665 /*
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.
669  */
670 static void __init omap_mux_init_list(struct omap_mux *superset)
671 {
672         while (superset->reg_offset !=  OMAP_MUX_TERMINATOR) {
673                 struct omap_mux *entry;
674
675 #ifdef CONFIG_OMAP_MUX
676                 if (!superset->muxnames || !superset->muxnames[0]) {
677                         superset++;
678                         continue;
679                 }
680 #else
681                 /* Skip pins that are not muxed as GPIO by bootloader */
682                 if (!OMAP_MODE_GPIO(omap_mux_read(superset->reg_offset))) {
683                         superset++;
684                         continue;
685                 }
686 #endif
687
688                 entry = omap_mux_list_add(superset);
689                 if (!entry) {
690                         printk(KERN_ERR "mux: Could not add entry\n");
691                         return;
692                 }
693                 superset++;
694         }
695 }
696
697 #ifdef CONFIG_OMAP_MUX
698
699 static void omap_mux_init_package(struct omap_mux *superset,
700                                   struct omap_mux *package_subset,
701                                   struct omap_ball *package_balls)
702 {
703         if (package_subset)
704                 omap_mux_package_fixup(package_subset, superset);
705         if (package_balls)
706                 omap_mux_package_init_balls(package_balls, superset);
707 }
708
709 static void omap_mux_init_signals(struct omap_board_mux *board_mux)
710 {
711         omap_mux_set_cmdline_signals();
712         omap_mux_write_array(board_mux);
713 }
714
715 #else
716
717 static void omap_mux_init_package(struct omap_mux *superset,
718                                   struct omap_mux *package_subset,
719                                   struct omap_ball *package_balls)
720 {
721 }
722
723 static void omap_mux_init_signals(struct omap_board_mux *board_mux)
724 {
725 }
726
727 #endif
728
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)
734 {
735         if (mux_base)
736                 return -EBUSY;
737
738         mux_phys = mux_pbase;
739         mux_base = ioremap(mux_pbase, mux_size);
740         if (!mux_base) {
741                 printk(KERN_ERR "mux: Could not ioremap\n");
742                 return -ENODEV;
743         }
744
745         if (cpu_is_omap24xx())
746                 omap_mux_flags = MUXABLE_GPIO_MODE3;
747
748         omap_mux_init_package(superset, package_subset, package_balls);
749         omap_mux_init_list(superset);
750         omap_mux_init_signals(board_mux);
751
752         return 0;
753 }
754