projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'fixes' of git://git.infradead.org/users/vkoul/slave-dma
[deliverable/linux.git] / arch / arm / mach-omap2 / mux.c
1 /*
2 * linux/arch/arm/mach-omap2/mux.c
3 *
4 * OMAP2, OMAP3 and OMAP4 pin multiplexing configurations
5 *
6 * Copyright (C) 2004 - 2010 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 #include <linux/irq.h>
36 #include <linux/interrupt.h>
37
38
39 #include <plat/omap_hwmod.h>
40
41 #include "control.h"
42 #include "mux.h"
43 #include "prm.h"
44
45 #define OMAP_MUX_BASE_OFFSET 0x30 /* Offset from CTRL_BASE */
46 #define OMAP_MUX_BASE_SZ 0x5ca
47
48 struct omap_mux_entry {
49 struct omap_mux mux;
50 struct list_head node;
51 };
52
53 static LIST_HEAD(mux_partitions);
54 static DEFINE_MUTEX(muxmode_mutex);
55
56 struct omap_mux_partition *omap_mux_get(const char *name)
57 {
58 struct omap_mux_partition *partition;
59
60 list_for_each_entry(partition, &mux_partitions, node) {
61 if (!strcmp(name, partition->name))
62 return partition;
63 }
64
65 return NULL;
66 }
67
68 u16 omap_mux_read(struct omap_mux_partition *partition, u16 reg)
69 {
70 if (partition->flags & OMAP_MUX_REG_8BIT)
71 return __raw_readb(partition->base + reg);
72 else
73 return __raw_readw(partition->base + reg);
74 }
75
76 void omap_mux_write(struct omap_mux_partition *partition, u16 val,
77 u16 reg)
78 {
79 if (partition->flags & OMAP_MUX_REG_8BIT)
80 __raw_writeb(val, partition->base + reg);
81 else
82 __raw_writew(val, partition->base + reg);
83 }
84
85 void omap_mux_write_array(struct omap_mux_partition *partition,
86 struct omap_board_mux *board_mux)
87 {
88 if (!board_mux)
89 return;
90
91 while (board_mux->reg_offset != OMAP_MUX_TERMINATOR) {
92 omap_mux_write(partition, board_mux->value,
93 board_mux->reg_offset);
94 board_mux++;
95 }
96 }
97
98 #ifdef CONFIG_OMAP_MUX
99
100 static char *omap_mux_options;
101
102 static int __init _omap_mux_init_gpio(struct omap_mux_partition *partition,
103 int gpio, int val)
104 {
105 struct omap_mux_entry *e;
106 struct omap_mux *gpio_mux = NULL;
107 u16 old_mode;
108 u16 mux_mode;
109 int found = 0;
110 struct list_head *muxmodes = &partition->muxmodes;
111
112 if (!gpio)
113 return -EINVAL;
114
115 list_for_each_entry(e, muxmodes, node) {
116 struct omap_mux *m = &e->mux;
117 if (gpio == m->gpio) {
118 gpio_mux = m;
119 found++;
120 }
121 }
122
123 if (found == 0) {
124 pr_err("%s: Could not set gpio%i\n", __func__, gpio);
125 return -ENODEV;
126 }
127
128 if (found > 1) {
129 pr_info("%s: Multiple gpio paths (%d) for gpio%i\n", __func__,
130 found, gpio);
131 return -EINVAL;
132 }
133
134 old_mode = omap_mux_read(partition, gpio_mux->reg_offset);
135 mux_mode = val & ~(OMAP_MUX_NR_MODES - 1);
136 if (partition->flags & OMAP_MUX_GPIO_IN_MODE3)
137 mux_mode |= OMAP_MUX_MODE3;
138 else
139 mux_mode |= OMAP_MUX_MODE4;
140 pr_debug("%s: Setting signal %s.gpio%i 0x%04x -> 0x%04x\n", __func__,
141 gpio_mux->muxnames[0], gpio, old_mode, mux_mode);
142 omap_mux_write(partition, mux_mode, gpio_mux->reg_offset);
143
144 return 0;
145 }
146
147 int __init omap_mux_init_gpio(int gpio, int val)
148 {
149 struct omap_mux_partition *partition;
150 int ret;
151
152 list_for_each_entry(partition, &mux_partitions, node) {
153 ret = _omap_mux_init_gpio(partition, gpio, val);
154 if (!ret)
155 return ret;
156 }
157
158 return -ENODEV;
159 }
160
161 static int __init _omap_mux_get_by_name(struct omap_mux_partition *partition,
162 const char *muxname,
163 struct omap_mux **found_mux)
164 {
165 struct omap_mux *mux = NULL;
166 struct omap_mux_entry *e;
167 const char *mode_name;
168 int found = 0, found_mode = 0, mode0_len = 0;
169 struct list_head *muxmodes = &partition->muxmodes;
170
171 mode_name = strchr(muxname, '.');
172 if (mode_name) {
173 mode0_len = strlen(muxname) - strlen(mode_name);
174 mode_name++;
175 } else {
176 mode_name = muxname;
177 }
178
179 list_for_each_entry(e, muxmodes, node) {
180 char *m0_entry;
181 int i;
182
183 mux = &e->mux;
184 m0_entry = mux->muxnames[0];
185
186 /* First check for full name in mode0.muxmode format */
187 if (mode0_len && strncmp(muxname, m0_entry, mode0_len))
188 continue;
189
190 /* Then check for muxmode only */
191 for (i = 0; i < OMAP_MUX_NR_MODES; i++) {
192 char *mode_cur = mux->muxnames[i];
193
194 if (!mode_cur)
195 continue;
196
197 if (!strcmp(mode_name, mode_cur)) {
198 *found_mux = mux;
199 found++;
200 found_mode = i;
201 }
202 }
203 }
204
205 if (found == 1) {
206 return found_mode;
207 }
208
209 if (found > 1) {
210 pr_err("%s: Multiple signal paths (%i) for %s\n", __func__,
211 found, muxname);
212 return -EINVAL;
213 }
214
215 pr_err("%s: Could not find signal %s\n", __func__, muxname);
216
217 return -ENODEV;
218 }
219
220 int __init omap_mux_get_by_name(const char *muxname,
221 struct omap_mux_partition **found_partition,
222 struct omap_mux **found_mux)
223 {
224 struct omap_mux_partition *partition;
225
226 list_for_each_entry(partition, &mux_partitions, node) {
227 struct omap_mux *mux = NULL;
228 int mux_mode = _omap_mux_get_by_name(partition, muxname, &mux);
229 if (mux_mode < 0)
230 continue;
231
232 *found_partition = partition;
233 *found_mux = mux;
234
235 return mux_mode;
236 }
237
238 return -ENODEV;
239 }
240
241 int __init omap_mux_init_signal(const char *muxname, int val)
242 {
243 struct omap_mux_partition *partition = NULL;
244 struct omap_mux *mux = NULL;
245 u16 old_mode;
246 int mux_mode;
247
248 mux_mode = omap_mux_get_by_name(muxname, &partition, &mux);
249 if (mux_mode < 0 || !mux)
250 return mux_mode;
251
252 old_mode = omap_mux_read(partition, mux->reg_offset);
253 mux_mode |= val;
254 pr_debug("%s: Setting signal %s 0x%04x -> 0x%04x\n",
255 __func__, muxname, old_mode, mux_mode);
256 omap_mux_write(partition, mux_mode, mux->reg_offset);
257
258 return 0;
259 }
260
261 struct omap_hwmod_mux_info * __init
262 omap_hwmod_mux_init(struct omap_device_pad *bpads, int nr_pads)
263 {
264 struct omap_hwmod_mux_info *hmux;
265 int i, nr_pads_dynamic = 0;
266
267 if (!bpads || nr_pads < 1)
268 return NULL;
269
270 hmux = kzalloc(sizeof(struct omap_hwmod_mux_info), GFP_KERNEL);
271 if (!hmux)
272 goto err1;
273
274 hmux->nr_pads = nr_pads;
275
276 hmux->pads = kzalloc(sizeof(struct omap_device_pad) *
277 nr_pads, GFP_KERNEL);
278 if (!hmux->pads)
279 goto err2;
280
281 for (i = 0; i < hmux->nr_pads; i++) {
282 struct omap_mux_partition *partition;
283 struct omap_device_pad *bpad = &bpads[i], *pad = &hmux->pads[i];
284 struct omap_mux *mux;
285 int mux_mode;
286
287 mux_mode = omap_mux_get_by_name(bpad->name, &partition, &mux);
288 if (mux_mode < 0)
289 goto err3;
290 if (!pad->partition)
291 pad->partition = partition;
292 if (!pad->mux)
293 pad->mux = mux;
294
295 pad->name = kzalloc(strlen(bpad->name) + 1, GFP_KERNEL);
296 if (!pad->name) {
297 int j;
298
299 for (j = i - 1; j >= 0; j--)
300 kfree(hmux->pads[j].name);
301 goto err3;
302 }
303 strcpy(pad->name, bpad->name);
304
305 pad->flags = bpad->flags;
306 pad->enable = bpad->enable;
307 pad->idle = bpad->idle;
308 pad->off = bpad->off;
309
310 if (pad->flags &
311 (OMAP_DEVICE_PAD_REMUX | OMAP_DEVICE_PAD_WAKEUP))
312 nr_pads_dynamic++;
313
314 pr_debug("%s: Initialized %s\n", __func__, pad->name);
315 }
316
317 if (!nr_pads_dynamic)
318 return hmux;
319
320 /*
321 * Add pads that need dynamic muxing into a separate list
322 */
323
324 hmux->nr_pads_dynamic = nr_pads_dynamic;
325 hmux->pads_dynamic = kzalloc(sizeof(struct omap_device_pad *) *
326 nr_pads_dynamic, GFP_KERNEL);
327 if (!hmux->pads_dynamic) {
328 pr_err("%s: Could not allocate dynamic pads\n", __func__);
329 return hmux;
330 }
331
332 nr_pads_dynamic = 0;
333 for (i = 0; i < hmux->nr_pads; i++) {
334 struct omap_device_pad *pad = &hmux->pads[i];
335
336 if (pad->flags &
337 (OMAP_DEVICE_PAD_REMUX | OMAP_DEVICE_PAD_WAKEUP)) {
338 pr_debug("%s: pad %s tagged dynamic\n",
339 __func__, pad->name);
340 hmux->pads_dynamic[nr_pads_dynamic] = pad;
341 nr_pads_dynamic++;
342 }
343 }
344
345 return hmux;
346
347 err3:
348 kfree(hmux->pads);
349 err2:
350 kfree(hmux);
351 err1:
352 pr_err("%s: Could not allocate device mux entry\n", __func__);
353
354 return NULL;
355 }
356
357 /**
358 * omap_hwmod_mux_scan_wakeups - omap hwmod scan wakeup pads
359 * @hmux: Pads for a hwmod
360 * @mpu_irqs: MPU irq array for a hwmod
361 *
362 * Scans the wakeup status of pads for a single hwmod. If an irq
363 * array is defined for this mux, the parser will call the registered
364 * ISRs for corresponding pads, otherwise the parser will stop at the
365 * first wakeup active pad and return. Returns true if there is a
366 * pending and non-served wakeup event for the mux, otherwise false.
367 */
368 static bool omap_hwmod_mux_scan_wakeups(struct omap_hwmod_mux_info *hmux,
369 struct omap_hwmod_irq_info *mpu_irqs)
370 {
371 int i, irq;
372 unsigned int val;
373 u32 handled_irqs = 0;
374
375 for (i = 0; i < hmux->nr_pads_dynamic; i++) {
376 struct omap_device_pad *pad = hmux->pads_dynamic[i];
377
378 if (!(pad->flags & OMAP_DEVICE_PAD_WAKEUP) ||
379 !(pad->idle & OMAP_WAKEUP_EN))
380 continue;
381
382 val = omap_mux_read(pad->partition, pad->mux->reg_offset);
383 if (!(val & OMAP_WAKEUP_EVENT))
384 continue;
385
386 if (!hmux->irqs)
387 return true;
388
389 irq = hmux->irqs[i];
390 /* make sure we only handle each irq once */
391 if (handled_irqs & 1 << irq)
392 continue;
393
394 handled_irqs |= 1 << irq;
395
396 generic_handle_irq(mpu_irqs[irq].irq);
397 }
398
399 return false;
400 }
401
402 /**
403 * _omap_hwmod_mux_handle_irq - Process wakeup events for a single hwmod
404 *
405 * Checks a single hwmod for every wakeup capable pad to see if there is an
406 * active wakeup event. If this is the case, call the corresponding ISR.
407 */
408 static int _omap_hwmod_mux_handle_irq(struct omap_hwmod *oh, void *data)
409 {
410 if (!oh->mux || !oh->mux->enabled)
411 return 0;
412 if (omap_hwmod_mux_scan_wakeups(oh->mux, oh->mpu_irqs))
413 generic_handle_irq(oh->mpu_irqs[0].irq);
414 return 0;
415 }
416
417 /**
418 * omap_hwmod_mux_handle_irq - Process pad wakeup irqs.
419 *
420 * Calls a function for each registered omap_hwmod to check
421 * pad wakeup statuses.
422 */
423 static irqreturn_t omap_hwmod_mux_handle_irq(int irq, void *unused)
424 {
425 omap_hwmod_for_each(_omap_hwmod_mux_handle_irq, NULL);
426 return IRQ_HANDLED;
427 }
428
429 /* Assumes the calling function takes care of locking */
430 void omap_hwmod_mux(struct omap_hwmod_mux_info *hmux, u8 state)
431 {
432 int i;
433
434 /* Runtime idling of dynamic pads */
435 if (state == _HWMOD_STATE_IDLE && hmux->enabled) {
436 for (i = 0; i < hmux->nr_pads_dynamic; i++) {
437 struct omap_device_pad *pad = hmux->pads_dynamic[i];
438 int val = -EINVAL;
439
440 val = pad->idle;
441 omap_mux_write(pad->partition, val,
442 pad->mux->reg_offset);
443 }
444
445 return;
446 }
447
448 /* Runtime enabling of dynamic pads */
449 if ((state == _HWMOD_STATE_ENABLED) && hmux->pads_dynamic
450 && hmux->enabled) {
451 for (i = 0; i < hmux->nr_pads_dynamic; i++) {
452 struct omap_device_pad *pad = hmux->pads_dynamic[i];
453 int val = -EINVAL;
454
455 val = pad->enable;
456 omap_mux_write(pad->partition, val,
457 pad->mux->reg_offset);
458 }
459
460 return;
461 }
462
463 /* Enabling or disabling of all pads */
464 for (i = 0; i < hmux->nr_pads; i++) {
465 struct omap_device_pad *pad = &hmux->pads[i];
466 int flags, val = -EINVAL;
467
468 flags = pad->flags;
469
470 switch (state) {
471 case _HWMOD_STATE_ENABLED:
472 val = pad->enable;
473 pr_debug("%s: Enabling %s %x\n", __func__,
474 pad->name, val);
475 break;
476 case _HWMOD_STATE_DISABLED:
477 /* Use safe mode unless OMAP_DEVICE_PAD_REMUX */
478 if (flags & OMAP_DEVICE_PAD_REMUX)
479 val = pad->off;
480 else
481 val = OMAP_MUX_MODE7;
482 pr_debug("%s: Disabling %s %x\n", __func__,
483 pad->name, val);
484 break;
485 default:
486 /* Nothing to be done */
487 break;
488 };
489
490 if (val >= 0) {
491 omap_mux_write(pad->partition, val,
492 pad->mux->reg_offset);
493 pad->flags = flags;
494 }
495 }
496
497 if (state == _HWMOD_STATE_ENABLED)
498 hmux->enabled = true;
499 else
500 hmux->enabled = false;
501 }
502
503 #ifdef CONFIG_DEBUG_FS
504
505 #define OMAP_MUX_MAX_NR_FLAGS 10
506 #define OMAP_MUX_TEST_FLAG(val, mask) \
507 if (((val) & (mask)) == (mask)) { \
508 i++; \
509 flags[i] = #mask; \
510 }
511
512 /* REVISIT: Add checking for non-optimal mux settings */
513 static inline void omap_mux_decode(struct seq_file *s, u16 val)
514 {
515 char *flags[OMAP_MUX_MAX_NR_FLAGS];
516 char mode[sizeof("OMAP_MUX_MODE") + 1];
517 int i = -1;
518
519 sprintf(mode, "OMAP_MUX_MODE%d", val & 0x7);
520 i++;
521 flags[i] = mode;
522
523 OMAP_MUX_TEST_FLAG(val, OMAP_PIN_OFF_WAKEUPENABLE);
524 if (val & OMAP_OFF_EN) {
525 if (!(val & OMAP_OFFOUT_EN)) {
526 if (!(val & OMAP_OFF_PULL_UP)) {
527 OMAP_MUX_TEST_FLAG(val,
528 OMAP_PIN_OFF_INPUT_PULLDOWN);
529 } else {
530 OMAP_MUX_TEST_FLAG(val,
531 OMAP_PIN_OFF_INPUT_PULLUP);
532 }
533 } else {
534 if (!(val & OMAP_OFFOUT_VAL)) {
535 OMAP_MUX_TEST_FLAG(val,
536 OMAP_PIN_OFF_OUTPUT_LOW);
537 } else {
538 OMAP_MUX_TEST_FLAG(val,
539 OMAP_PIN_OFF_OUTPUT_HIGH);
540 }
541 }
542 }
543
544 if (val & OMAP_INPUT_EN) {
545 if (val & OMAP_PULL_ENA) {
546 if (!(val & OMAP_PULL_UP)) {
547 OMAP_MUX_TEST_FLAG(val,
548 OMAP_PIN_INPUT_PULLDOWN);
549 } else {
550 OMAP_MUX_TEST_FLAG(val, OMAP_PIN_INPUT_PULLUP);
551 }
552 } else {
553 OMAP_MUX_TEST_FLAG(val, OMAP_PIN_INPUT);
554 }
555 } else {
556 i++;
557 flags[i] = "OMAP_PIN_OUTPUT";
558 }
559
560 do {
561 seq_printf(s, "%s", flags[i]);
562 if (i > 0)
563 seq_printf(s, " | ");
564 } while (i-- > 0);
565 }
566
567 #define OMAP_MUX_DEFNAME_LEN 32
568
569 static int omap_mux_dbg_board_show(struct seq_file *s, void *unused)
570 {
571 struct omap_mux_partition *partition = s->private;
572 struct omap_mux_entry *e;
573 u8 omap_gen = omap_rev() >> 28;
574
575 list_for_each_entry(e, &partition->muxmodes, node) {
576 struct omap_mux *m = &e->mux;
577 char m0_def[OMAP_MUX_DEFNAME_LEN];
578 char *m0_name = m->muxnames[0];
579 u16 val;
580 int i, mode;
581
582 if (!m0_name)
583 continue;
584
585 /* REVISIT: Needs to be updated if mode0 names get longer */
586 for (i = 0; i < OMAP_MUX_DEFNAME_LEN; i++) {
587 if (m0_name[i] == '\0') {
588 m0_def[i] = m0_name[i];
589 break;
590 }
591 m0_def[i] = toupper(m0_name[i]);
592 }
593 val = omap_mux_read(partition, m->reg_offset);
594 mode = val & OMAP_MUX_MODE7;
595 if (mode != 0)
596 seq_printf(s, "/* %s */\n", m->muxnames[mode]);
597
598 /*
599 * XXX: Might be revisited to support differences across
600 * same OMAP generation.
601 */
602 seq_printf(s, "OMAP%d_MUX(%s, ", omap_gen, m0_def);
603 omap_mux_decode(s, val);
604 seq_printf(s, "),\n");
605 }
606
607 return 0;
608 }
609
610 static int omap_mux_dbg_board_open(struct inode *inode, struct file *file)
611 {
612 return single_open(file, omap_mux_dbg_board_show, inode->i_private);
613 }
614
615 static const struct file_operations omap_mux_dbg_board_fops = {
616 .open = omap_mux_dbg_board_open,
617 .read = seq_read,
618 .llseek = seq_lseek,
619 .release = single_release,
620 };
621
622 static struct omap_mux_partition *omap_mux_get_partition(struct omap_mux *mux)
623 {
624 struct omap_mux_partition *partition;
625
626 list_for_each_entry(partition, &mux_partitions, node) {
627 struct list_head *muxmodes = &partition->muxmodes;
628 struct omap_mux_entry *e;
629
630 list_for_each_entry(e, muxmodes, node) {
631 struct omap_mux *m = &e->mux;
632
633 if (m == mux)
634 return partition;
635 }
636 }
637
638 return NULL;
639 }
640
641 static int omap_mux_dbg_signal_show(struct seq_file *s, void *unused)
642 {
643 struct omap_mux *m = s->private;
644 struct omap_mux_partition *partition;
645 const char *none = "NA";
646 u16 val;
647 int mode;
648
649 partition = omap_mux_get_partition(m);
650 if (!partition)
651 return 0;
652
653 val = omap_mux_read(partition, m->reg_offset);
654 mode = val & OMAP_MUX_MODE7;
655
656 seq_printf(s, "name: %s.%s (0x%08x/0x%03x = 0x%04x), b %s, t %s\n",
657 m->muxnames[0], m->muxnames[mode],
658 partition->phys + m->reg_offset, m->reg_offset, val,
659 m->balls[0] ? m->balls[0] : none,
660 m->balls[1] ? m->balls[1] : none);
661 seq_printf(s, "mode: ");
662 omap_mux_decode(s, val);
663 seq_printf(s, "\n");
664 seq_printf(s, "signals: %s | %s | %s | %s | %s | %s | %s | %s\n",
665 m->muxnames[0] ? m->muxnames[0] : none,
666 m->muxnames[1] ? m->muxnames[1] : none,
667 m->muxnames[2] ? m->muxnames[2] : none,
668 m->muxnames[3] ? m->muxnames[3] : none,
669 m->muxnames[4] ? m->muxnames[4] : none,
670 m->muxnames[5] ? m->muxnames[5] : none,
671 m->muxnames[6] ? m->muxnames[6] : none,
672 m->muxnames[7] ? m->muxnames[7] : none);
673
674 return 0;
675 }
676
677 #define OMAP_MUX_MAX_ARG_CHAR 7
678
679 static ssize_t omap_mux_dbg_signal_write(struct file *file,
680 const char __user *user_buf,
681 size_t count, loff_t *ppos)
682 {
683 char buf[OMAP_MUX_MAX_ARG_CHAR];
684 struct seq_file *seqf;
685 struct omap_mux *m;
686 unsigned long val;
687 int buf_size, ret;
688 struct omap_mux_partition *partition;
689
690 if (count > OMAP_MUX_MAX_ARG_CHAR)
691 return -EINVAL;
692
693 memset(buf, 0, sizeof(buf));
694 buf_size = min(count, sizeof(buf) - 1);
695
696 if (copy_from_user(buf, user_buf, buf_size))
697 return -EFAULT;
698
699 ret = strict_strtoul(buf, 0x10, &val);
700 if (ret < 0)
701 return ret;
702
703 if (val > 0xffff)
704 return -EINVAL;
705
706 seqf = file->private_data;
707 m = seqf->private;
708
709 partition = omap_mux_get_partition(m);
710 if (!partition)
711 return -ENODEV;
712
713 omap_mux_write(partition, (u16)val, m->reg_offset);
714 *ppos += count;
715
716 return count;
717 }
718
719 static int omap_mux_dbg_signal_open(struct inode *inode, struct file *file)
720 {
721 return single_open(file, omap_mux_dbg_signal_show, inode->i_private);
722 }
723
724 static const struct file_operations omap_mux_dbg_signal_fops = {
725 .open = omap_mux_dbg_signal_open,
726 .read = seq_read,
727 .write = omap_mux_dbg_signal_write,
728 .llseek = seq_lseek,
729 .release = single_release,
730 };
731
732 static struct dentry *mux_dbg_dir;
733
734 static void __init omap_mux_dbg_create_entry(
735 struct omap_mux_partition *partition,
736 struct dentry *mux_dbg_dir)
737 {
738 struct omap_mux_entry *e;
739
740 list_for_each_entry(e, &partition->muxmodes, node) {
741 struct omap_mux *m = &e->mux;
742
743 (void)debugfs_create_file(m->muxnames[0], S_IWUSR, mux_dbg_dir,
744 m, &omap_mux_dbg_signal_fops);
745 }
746 }
747
748 static void __init omap_mux_dbg_init(void)
749 {
750 struct omap_mux_partition *partition;
751 static struct dentry *mux_dbg_board_dir;
752
753 mux_dbg_dir = debugfs_create_dir("omap_mux", NULL);
754 if (!mux_dbg_dir)
755 return;
756
757 mux_dbg_board_dir = debugfs_create_dir("board", mux_dbg_dir);
758 if (!mux_dbg_board_dir)
759 return;
760
761 list_for_each_entry(partition, &mux_partitions, node) {
762 omap_mux_dbg_create_entry(partition, mux_dbg_dir);
763 (void)debugfs_create_file(partition->name, S_IRUGO,
764 mux_dbg_board_dir, partition,
765 &omap_mux_dbg_board_fops);
766 }
767 }
768
769 #else
770 static inline void omap_mux_dbg_init(void)
771 {
772 }
773 #endif /* CONFIG_DEBUG_FS */
774
775 static void __init omap_mux_free_names(struct omap_mux *m)
776 {
777 int i;
778
779 for (i = 0; i < OMAP_MUX_NR_MODES; i++)
780 kfree(m->muxnames[i]);
781
782 #ifdef CONFIG_DEBUG_FS
783 for (i = 0; i < OMAP_MUX_NR_SIDES; i++)
784 kfree(m->balls[i]);
785 #endif
786
787 }
788
789 /* Free all data except for GPIO pins unless CONFIG_DEBUG_FS is set */
790 int __init omap_mux_late_init(void)
791 {
792 struct omap_mux_partition *partition;
793 int ret;
794
795 list_for_each_entry(partition, &mux_partitions, node) {
796 struct omap_mux_entry *e, *tmp;
797 list_for_each_entry_safe(e, tmp, &partition->muxmodes, node) {
798 struct omap_mux *m = &e->mux;
799 u16 mode = omap_mux_read(partition, m->reg_offset);
800
801 if (OMAP_MODE_GPIO(mode))
802 continue;
803
804 #ifndef CONFIG_DEBUG_FS
805 mutex_lock(&muxmode_mutex);
806 list_del(&e->node);
807 mutex_unlock(&muxmode_mutex);
808 omap_mux_free_names(m);
809 kfree(m);
810 #endif
811 }
812 }
813
814 ret = request_irq(omap_prcm_event_to_irq("io"),
815 omap_hwmod_mux_handle_irq, IRQF_SHARED | IRQF_NO_SUSPEND,
816 "hwmod_io", omap_mux_late_init);
817
818 if (ret)
819 pr_warning("mux: Failed to setup hwmod io irq %d\n", ret);
820
821 omap_mux_dbg_init();
822
823 return 0;
824 }
825
826 static void __init omap_mux_package_fixup(struct omap_mux *p,
827 struct omap_mux *superset)
828 {
829 while (p->reg_offset != OMAP_MUX_TERMINATOR) {
830 struct omap_mux *s = superset;
831 int found = 0;
832
833 while (s->reg_offset != OMAP_MUX_TERMINATOR) {
834 if (s->reg_offset == p->reg_offset) {
835 *s = *p;
836 found++;
837 break;
838 }
839 s++;
840 }
841 if (!found)
842 pr_err("%s: Unknown entry offset 0x%x\n", __func__,
843 p->reg_offset);
844 p++;
845 }
846 }
847
848 #ifdef CONFIG_DEBUG_FS
849
850 static void __init omap_mux_package_init_balls(struct omap_ball *b,
851 struct omap_mux *superset)
852 {
853 while (b->reg_offset != OMAP_MUX_TERMINATOR) {
854 struct omap_mux *s = superset;
855 int found = 0;
856
857 while (s->reg_offset != OMAP_MUX_TERMINATOR) {
858 if (s->reg_offset == b->reg_offset) {
859 s->balls[0] = b->balls[0];
860 s->balls[1] = b->balls[1];
861 found++;
862 break;
863 }
864 s++;
865 }
866 if (!found)
867 pr_err("%s: Unknown ball offset 0x%x\n", __func__,
868 b->reg_offset);
869 b++;
870 }
871 }
872
873 #else /* CONFIG_DEBUG_FS */
874
875 static inline void omap_mux_package_init_balls(struct omap_ball *b,
876 struct omap_mux *superset)
877 {
878 }
879
880 #endif /* CONFIG_DEBUG_FS */
881
882 static int __init omap_mux_setup(char *options)
883 {
884 if (!options)
885 return 0;
886
887 omap_mux_options = options;
888
889 return 1;
890 }
891 __setup("omap_mux=", omap_mux_setup);
892
893 /*
894 * Note that the omap_mux=some.signal1=0x1234,some.signal2=0x1234
895 * cmdline options only override the bootloader values.
896 * During development, please enable CONFIG_DEBUG_FS, and use the
897 * signal specific entries under debugfs.
898 */
899 static void __init omap_mux_set_cmdline_signals(void)
900 {
901 char *options, *next_opt, *token;
902
903 if (!omap_mux_options)
904 return;
905
906 options = kstrdup(omap_mux_options, GFP_KERNEL);
907 if (!options)
908 return;
909
910 next_opt = options;
911
912 while ((token = strsep(&next_opt, ",")) != NULL) {
913 char *keyval, *name;
914 unsigned long val;
915
916 keyval = token;
917 name = strsep(&keyval, "=");
918 if (name) {
919 int res;
920
921 res = strict_strtoul(keyval, 0x10, &val);
922 if (res < 0)
923 continue;
924
925 omap_mux_init_signal(name, (u16)val);
926 }
927 }
928
929 kfree(options);
930 }
931
932 static int __init omap_mux_copy_names(struct omap_mux *src,
933 struct omap_mux *dst)
934 {
935 int i;
936
937 for (i = 0; i < OMAP_MUX_NR_MODES; i++) {
938 if (src->muxnames[i]) {
939 dst->muxnames[i] = kstrdup(src->muxnames[i],
940 GFP_KERNEL);
941 if (!dst->muxnames[i])
942 goto free;
943 }
944 }
945
946 #ifdef CONFIG_DEBUG_FS
947 for (i = 0; i < OMAP_MUX_NR_SIDES; i++) {
948 if (src->balls[i]) {
949 dst->balls[i] = kstrdup(src->balls[i], GFP_KERNEL);
950 if (!dst->balls[i])
951 goto free;
952 }
953 }
954 #endif
955
956 return 0;
957
958 free:
959 omap_mux_free_names(dst);
960 return -ENOMEM;
961
962 }
963
964 #endif /* CONFIG_OMAP_MUX */
965
966 static struct omap_mux *omap_mux_get_by_gpio(
967 struct omap_mux_partition *partition,
968 int gpio)
969 {
970 struct omap_mux_entry *e;
971 struct omap_mux *ret = NULL;
972
973 list_for_each_entry(e, &partition->muxmodes, node) {
974 struct omap_mux *m = &e->mux;
975 if (m->gpio == gpio) {
976 ret = m;
977 break;
978 }
979 }
980
981 return ret;
982 }
983
984 /* Needed for dynamic muxing of GPIO pins for off-idle */
985 u16 omap_mux_get_gpio(int gpio)
986 {
987 struct omap_mux_partition *partition;
988 struct omap_mux *m = NULL;
989
990 list_for_each_entry(partition, &mux_partitions, node) {
991 m = omap_mux_get_by_gpio(partition, gpio);
992 if (m)
993 return omap_mux_read(partition, m->reg_offset);
994 }
995
996 if (!m || m->reg_offset == OMAP_MUX_TERMINATOR)
997 pr_err("%s: Could not get gpio%i\n", __func__, gpio);
998
999 return OMAP_MUX_TERMINATOR;
1000 }
1001
1002 /* Needed for dynamic muxing of GPIO pins for off-idle */
1003 void omap_mux_set_gpio(u16 val, int gpio)
1004 {
1005 struct omap_mux_partition *partition;
1006 struct omap_mux *m = NULL;
1007
1008 list_for_each_entry(partition, &mux_partitions, node) {
1009 m = omap_mux_get_by_gpio(partition, gpio);
1010 if (m) {
1011 omap_mux_write(partition, val, m->reg_offset);
1012 return;
1013 }
1014 }
1015
1016 if (!m || m->reg_offset == OMAP_MUX_TERMINATOR)
1017 pr_err("%s: Could not set gpio%i\n", __func__, gpio);
1018 }
1019
1020 static struct omap_mux * __init omap_mux_list_add(
1021 struct omap_mux_partition *partition,
1022 struct omap_mux *src)
1023 {
1024 struct omap_mux_entry *entry;
1025 struct omap_mux *m;
1026
1027 entry = kzalloc(sizeof(struct omap_mux_entry), GFP_KERNEL);
1028 if (!entry)
1029 return NULL;
1030
1031 m = &entry->mux;
1032 entry->mux = *src;
1033
1034 #ifdef CONFIG_OMAP_MUX
1035 if (omap_mux_copy_names(src, m)) {
1036 kfree(entry);
1037 return NULL;
1038 }
1039 #endif
1040
1041 mutex_lock(&muxmode_mutex);
1042 list_add_tail(&entry->node, &partition->muxmodes);
1043 mutex_unlock(&muxmode_mutex);
1044
1045 return m;
1046 }
1047
1048 /*
1049 * Note if CONFIG_OMAP_MUX is not selected, we will only initialize
1050 * the GPIO to mux offset mapping that is needed for dynamic muxing
1051 * of GPIO pins for off-idle.
1052 */
1053 static void __init omap_mux_init_list(struct omap_mux_partition *partition,
1054 struct omap_mux *superset)
1055 {
1056 while (superset->reg_offset != OMAP_MUX_TERMINATOR) {
1057 struct omap_mux *entry;
1058
1059 #ifdef CONFIG_OMAP_MUX
1060 if (!superset->muxnames || !superset->muxnames[0]) {
1061 superset++;
1062 continue;
1063 }
1064 #else
1065 /* Skip pins that are not muxed as GPIO by bootloader */
1066 if (!OMAP_MODE_GPIO(omap_mux_read(partition,
1067 superset->reg_offset))) {
1068 superset++;
1069 continue;
1070 }
1071 #endif
1072
1073 entry = omap_mux_list_add(partition, superset);
1074 if (!entry) {
1075 pr_err("%s: Could not add entry\n", __func__);
1076 return;
1077 }
1078 superset++;
1079 }
1080 }
1081
1082 #ifdef CONFIG_OMAP_MUX
1083
1084 static void omap_mux_init_package(struct omap_mux *superset,
1085 struct omap_mux *package_subset,
1086 struct omap_ball *package_balls)
1087 {
1088 if (package_subset)
1089 omap_mux_package_fixup(package_subset, superset);
1090 if (package_balls)
1091 omap_mux_package_init_balls(package_balls, superset);
1092 }
1093
1094 static void __init omap_mux_init_signals(struct omap_mux_partition *partition,
1095 struct omap_board_mux *board_mux)
1096 {
1097 omap_mux_set_cmdline_signals();
1098 omap_mux_write_array(partition, board_mux);
1099 }
1100
1101 #else
1102
1103 static void omap_mux_init_package(struct omap_mux *superset,
1104 struct omap_mux *package_subset,
1105 struct omap_ball *package_balls)
1106 {
1107 }
1108
1109 static void __init omap_mux_init_signals(struct omap_mux_partition *partition,
1110 struct omap_board_mux *board_mux)
1111 {
1112 }
1113
1114 #endif
1115
1116 static u32 mux_partitions_cnt;
1117
1118 int __init omap_mux_init(const char *name, u32 flags,
1119 u32 mux_pbase, u32 mux_size,
1120 struct omap_mux *superset,
1121 struct omap_mux *package_subset,
1122 struct omap_board_mux *board_mux,
1123 struct omap_ball *package_balls)
1124 {
1125 struct omap_mux_partition *partition;
1126
1127 partition = kzalloc(sizeof(struct omap_mux_partition), GFP_KERNEL);
1128 if (!partition)
1129 return -ENOMEM;
1130
1131 partition->name = name;
1132 partition->flags = flags;
1133 partition->size = mux_size;
1134 partition->phys = mux_pbase;
1135 partition->base = ioremap(mux_pbase, mux_size);
1136 if (!partition->base) {
1137 pr_err("%s: Could not ioremap mux partition at 0x%08x\n",
1138 __func__, partition->phys);
1139 kfree(partition);
1140 return -ENODEV;
1141 }
1142
1143 INIT_LIST_HEAD(&partition->muxmodes);
1144
1145 list_add_tail(&partition->node, &mux_partitions);
1146 mux_partitions_cnt++;
1147 pr_info("%s: Add partition: #%d: %s, flags: %x\n", __func__,
1148 mux_partitions_cnt, partition->name, partition->flags);
1149
1150 omap_mux_init_package(superset, package_subset, package_balls);
1151 omap_mux_init_list(partition, superset);
1152 omap_mux_init_signals(partition, board_mux);
1153
1154 return 0;
1155 }
1156
Linux kernel - Deliverables
This page took 0.056781 seconds and 6 git commands to generate.