blob: 65c33911341fcf589b1e4372e9f5adbbada62d21 [file] [log] [blame]
Tony Lindgren1dbae812005-11-10 14:26:51 +00001/*
2 * linux/arch/arm/mach-omap2/mux.c
3 *
Benoit Cousson112485e2010-08-16 10:55:35 +02004 * OMAP2, OMAP3 and OMAP4 pin multiplexing configurations
Tony Lindgren1dbae812005-11-10 14:26:51 +00005 *
Benoit Cousson112485e2010-08-16 10:55:35 +02006 * Copyright (C) 2004 - 2010 Texas Instruments Inc.
Tony Lindgren93308992008-01-24 17:24:15 -08007 * Copyright (C) 2003 - 2008 Nokia Corporation
Tony Lindgren1dbae812005-11-10 14:26:51 +00008 *
Tony Lindgren93308992008-01-24 17:24:15 -08009 * Written by Tony Lindgren
Tony Lindgren1dbae812005-11-10 14:26:51 +000010 *
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 */
Paul Walmsley4814ced2010-10-08 11:40:20 -060026#include <linux/kernel.h>
Tony Lindgren1dbae812005-11-10 14:26:51 +000027#include <linux/init.h>
Russell Kingfced80c2008-09-06 12:10:45 +010028#include <linux/io.h>
Tony Lindgren15ac7af2009-12-11 16:16:32 -080029#include <linux/list.h>
Paul Walmsley4814ced2010-10-08 11:40:20 -060030#include <linux/slab.h>
Tony Lindgren4b715ef2009-12-11 16:16:32 -080031#include <linux/ctype.h>
32#include <linux/debugfs.h>
33#include <linux/seq_file.h>
34#include <linux/uaccess.h>
Tero Kristo13a3fe52011-12-16 14:36:59 -070035#include <linux/irq.h>
36#include <linux/interrupt.h>
Tony Lindgren1dbae812005-11-10 14:26:51 +000037
Russell Kingfced80c2008-09-06 12:10:45 +010038
Tony Lindgren9796b322010-12-22 18:42:35 -080039#include <plat/omap_hwmod.h>
40
Paul Walmsley4814ced2010-10-08 11:40:20 -060041#include "control.h"
Tony Lindgren15ac7af2009-12-11 16:16:32 -080042#include "mux.h"
Tero Kristo13a3fe52011-12-16 14:36:59 -070043#include "prm.h"
Tony Lindgren1dbae812005-11-10 14:26:51 +000044
Mike Rapoport92c9f502009-12-11 16:16:31 -080045#define OMAP_MUX_BASE_OFFSET 0x30 /* Offset from CTRL_BASE */
46#define OMAP_MUX_BASE_SZ 0x5ca
47
Tony Lindgren15ac7af2009-12-11 16:16:32 -080048struct omap_mux_entry {
49 struct omap_mux mux;
50 struct list_head node;
51};
52
Benoit Cousson112485e2010-08-16 10:55:35 +020053static LIST_HEAD(mux_partitions);
54static DEFINE_MUTEX(muxmode_mutex);
Mike Rapoport92c9f502009-12-11 16:16:31 -080055
Benoit Cousson112485e2010-08-16 10:55:35 +020056struct omap_mux_partition *omap_mux_get(const char *name)
Mike Rapoport92c9f502009-12-11 16:16:31 -080057{
Benoit Cousson112485e2010-08-16 10:55:35 +020058 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;
Mike Rapoport92c9f502009-12-11 16:16:31 -080066}
67
Benoit Cousson112485e2010-08-16 10:55:35 +020068u16 omap_mux_read(struct omap_mux_partition *partition, u16 reg)
Mike Rapoport92c9f502009-12-11 16:16:31 -080069{
Benoit Cousson112485e2010-08-16 10:55:35 +020070 if (partition->flags & OMAP_MUX_REG_8BIT)
71 return __raw_readb(partition->base + reg);
Mike Rapoport92c9f502009-12-11 16:16:31 -080072 else
Benoit Cousson112485e2010-08-16 10:55:35 +020073 return __raw_readw(partition->base + reg);
Mike Rapoport92c9f502009-12-11 16:16:31 -080074}
Tony Lindgren7d7f6652008-01-25 00:42:48 -080075
Benoit Cousson112485e2010-08-16 10:55:35 +020076void omap_mux_write(struct omap_mux_partition *partition, u16 val,
77 u16 reg)
Tony Lindgrend4bb72e2010-01-19 15:15:24 -080078{
Benoit Cousson112485e2010-08-16 10:55:35 +020079 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
85void omap_mux_write_array(struct omap_mux_partition *partition,
86 struct omap_board_mux *board_mux)
87{
Colin Crossd4ff6122011-05-31 12:00:09 -070088 if (!board_mux)
89 return;
90
Benoit Cousson112485e2010-08-16 10:55:35 +020091 while (board_mux->reg_offset != OMAP_MUX_TERMINATOR) {
92 omap_mux_write(partition, board_mux->value,
93 board_mux->reg_offset);
Tony Lindgrend4bb72e2010-01-19 15:15:24 -080094 board_mux++;
95 }
96}
97
Tony Lindgren15ac7af2009-12-11 16:16:32 -080098#ifdef CONFIG_OMAP_MUX
99
100static char *omap_mux_options;
101
Tony Lindgrend1589f02012-02-20 09:43:30 -0800102static int __init _omap_mux_init_gpio(struct omap_mux_partition *partition,
103 int gpio, int val)
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800104{
105 struct omap_mux_entry *e;
Sanjeev Premica828762010-09-23 18:27:18 -0700106 struct omap_mux *gpio_mux = NULL;
Grazvydas Ignotas8a6f7e12010-08-02 13:18:28 +0300107 u16 old_mode;
108 u16 mux_mode;
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800109 int found = 0;
Benoit Cousson112485e2010-08-16 10:55:35 +0200110 struct list_head *muxmodes = &partition->muxmodes;
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800111
112 if (!gpio)
113 return -EINVAL;
114
Benoit Cousson112485e2010-08-16 10:55:35 +0200115 list_for_each_entry(e, muxmodes, node) {
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800116 struct omap_mux *m = &e->mux;
117 if (gpio == m->gpio) {
Grazvydas Ignotas8a6f7e12010-08-02 13:18:28 +0300118 gpio_mux = m;
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800119 found++;
120 }
121 }
122
Grazvydas Ignotas8a6f7e12010-08-02 13:18:28 +0300123 if (found == 0) {
Dan Murphy032a6422010-11-15 09:50:50 -0600124 pr_err("%s: Could not set gpio%i\n", __func__, gpio);
Grazvydas Ignotas8a6f7e12010-08-02 13:18:28 +0300125 return -ENODEV;
126 }
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800127
128 if (found > 1) {
Dan Murphy032a6422010-11-15 09:50:50 -0600129 pr_info("%s: Multiple gpio paths (%d) for gpio%i\n", __func__,
Benoit Cousson1cbb3a92010-08-10 17:33:01 +0200130 found, gpio);
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800131 return -EINVAL;
132 }
133
Benoit Cousson112485e2010-08-16 10:55:35 +0200134 old_mode = omap_mux_read(partition, gpio_mux->reg_offset);
Grazvydas Ignotas8a6f7e12010-08-02 13:18:28 +0300135 mux_mode = val & ~(OMAP_MUX_NR_MODES - 1);
Benoit Cousson112485e2010-08-16 10:55:35 +0200136 if (partition->flags & OMAP_MUX_GPIO_IN_MODE3)
Grazvydas Ignotas8a6f7e12010-08-02 13:18:28 +0300137 mux_mode |= OMAP_MUX_MODE3;
138 else
139 mux_mode |= OMAP_MUX_MODE4;
Dan Murphy032a6422010-11-15 09:50:50 -0600140 pr_debug("%s: Setting signal %s.gpio%i 0x%04x -> 0x%04x\n", __func__,
Benoit Cousson1cbb3a92010-08-10 17:33:01 +0200141 gpio_mux->muxnames[0], gpio, old_mode, mux_mode);
Benoit Cousson112485e2010-08-16 10:55:35 +0200142 omap_mux_write(partition, mux_mode, gpio_mux->reg_offset);
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800143
Grazvydas Ignotas8a6f7e12010-08-02 13:18:28 +0300144 return 0;
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800145}
146
Tony Lindgrend1589f02012-02-20 09:43:30 -0800147int __init omap_mux_init_gpio(int gpio, int val)
Benoit Cousson112485e2010-08-16 10:55:35 +0200148{
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
Tony Lindgrend1589f02012-02-20 09:43:30 -0800161static int __init _omap_mux_get_by_name(struct omap_mux_partition *partition,
162 const char *muxname,
163 struct omap_mux **found_mux)
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800164{
Tony Lindgren8419fdb2010-12-22 18:42:35 -0800165 struct omap_mux *mux = NULL;
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800166 struct omap_mux_entry *e;
Tony Lindgren5a3b2f72010-10-01 16:35:24 -0700167 const char *mode_name;
Felipe Balbiafb7d702011-01-17 06:31:18 +0200168 int found = 0, found_mode = 0, mode0_len = 0;
Benoit Cousson112485e2010-08-16 10:55:35 +0200169 struct list_head *muxmodes = &partition->muxmodes;
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800170
171 mode_name = strchr(muxname, '.');
172 if (mode_name) {
Tony Lindgren5a3b2f72010-10-01 16:35:24 -0700173 mode0_len = strlen(muxname) - strlen(mode_name);
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800174 mode_name++;
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800175 } else {
176 mode_name = muxname;
177 }
178
Benoit Cousson112485e2010-08-16 10:55:35 +0200179 list_for_each_entry(e, muxmodes, node) {
Tony Lindgren8419fdb2010-12-22 18:42:35 -0800180 char *m0_entry;
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800181 int i;
182
Tony Lindgren8419fdb2010-12-22 18:42:35 -0800183 mux = &e->mux;
184 m0_entry = mux->muxnames[0];
185
Tony Lindgren5a3b2f72010-10-01 16:35:24 -0700186 /* First check for full name in mode0.muxmode format */
187 if (mode0_len && strncmp(muxname, m0_entry, mode0_len))
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800188 continue;
189
Tony Lindgren5a3b2f72010-10-01 16:35:24 -0700190 /* Then check for muxmode only */
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800191 for (i = 0; i < OMAP_MUX_NR_MODES; i++) {
Tony Lindgren8419fdb2010-12-22 18:42:35 -0800192 char *mode_cur = mux->muxnames[i];
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800193
194 if (!mode_cur)
195 continue;
196
197 if (!strcmp(mode_name, mode_cur)) {
Tony Lindgren8419fdb2010-12-22 18:42:35 -0800198 *found_mux = mux;
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800199 found++;
Tony Lindgren8419fdb2010-12-22 18:42:35 -0800200 found_mode = i;
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800201 }
202 }
203 }
204
Tony Lindgren8419fdb2010-12-22 18:42:35 -0800205 if (found == 1) {
206 return found_mode;
207 }
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800208
209 if (found > 1) {
Dan Murphy032a6422010-11-15 09:50:50 -0600210 pr_err("%s: Multiple signal paths (%i) for %s\n", __func__,
Benoit Cousson1cbb3a92010-08-10 17:33:01 +0200211 found, muxname);
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800212 return -EINVAL;
213 }
214
Tony Lindgren8419fdb2010-12-22 18:42:35 -0800215 pr_err("%s: Could not find signal %s\n", __func__, muxname);
216
217 return -ENODEV;
218}
219
Tony Lindgrend1589f02012-02-20 09:43:30 -0800220static int __init
Tony Lindgren8419fdb2010-12-22 18:42:35 -0800221omap_mux_get_by_name(const char *muxname,
222 struct omap_mux_partition **found_partition,
223 struct omap_mux **found_mux)
224{
225 struct omap_mux_partition *partition;
226
227 list_for_each_entry(partition, &mux_partitions, node) {
228 struct omap_mux *mux = NULL;
229 int mux_mode = _omap_mux_get_by_name(partition, muxname, &mux);
230 if (mux_mode < 0)
231 continue;
232
233 *found_partition = partition;
234 *found_mux = mux;
235
236 return mux_mode;
237 }
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800238
239 return -ENODEV;
240}
241
Tony Lindgrend1589f02012-02-20 09:43:30 -0800242int __init omap_mux_init_signal(const char *muxname, int val)
Benoit Cousson112485e2010-08-16 10:55:35 +0200243{
Tony Lindgren8419fdb2010-12-22 18:42:35 -0800244 struct omap_mux_partition *partition = NULL;
245 struct omap_mux *mux = NULL;
246 u16 old_mode;
247 int mux_mode;
Benoit Cousson112485e2010-08-16 10:55:35 +0200248
Tony Lindgren8419fdb2010-12-22 18:42:35 -0800249 mux_mode = omap_mux_get_by_name(muxname, &partition, &mux);
250 if (mux_mode < 0)
251 return mux_mode;
Benoit Cousson112485e2010-08-16 10:55:35 +0200252
Tony Lindgren8419fdb2010-12-22 18:42:35 -0800253 old_mode = omap_mux_read(partition, mux->reg_offset);
254 mux_mode |= val;
255 pr_debug("%s: Setting signal %s 0x%04x -> 0x%04x\n",
256 __func__, muxname, old_mode, mux_mode);
257 omap_mux_write(partition, mux_mode, mux->reg_offset);
Benoit Cousson112485e2010-08-16 10:55:35 +0200258
Tony Lindgren8419fdb2010-12-22 18:42:35 -0800259 return 0;
Benoit Cousson112485e2010-08-16 10:55:35 +0200260}
261
Tony Lindgren9796b322010-12-22 18:42:35 -0800262struct omap_hwmod_mux_info * __init
263omap_hwmod_mux_init(struct omap_device_pad *bpads, int nr_pads)
264{
265 struct omap_hwmod_mux_info *hmux;
Tony Lindgren029268e2011-03-11 11:32:25 -0800266 int i, nr_pads_dynamic = 0;
Tony Lindgren9796b322010-12-22 18:42:35 -0800267
268 if (!bpads || nr_pads < 1)
269 return NULL;
270
271 hmux = kzalloc(sizeof(struct omap_hwmod_mux_info), GFP_KERNEL);
272 if (!hmux)
273 goto err1;
274
275 hmux->nr_pads = nr_pads;
276
277 hmux->pads = kzalloc(sizeof(struct omap_device_pad) *
278 nr_pads, GFP_KERNEL);
279 if (!hmux->pads)
280 goto err2;
281
282 for (i = 0; i < hmux->nr_pads; i++) {
283 struct omap_mux_partition *partition;
284 struct omap_device_pad *bpad = &bpads[i], *pad = &hmux->pads[i];
285 struct omap_mux *mux;
286 int mux_mode;
287
288 mux_mode = omap_mux_get_by_name(bpad->name, &partition, &mux);
289 if (mux_mode < 0)
290 goto err3;
291 if (!pad->partition)
292 pad->partition = partition;
293 if (!pad->mux)
294 pad->mux = mux;
295
296 pad->name = kzalloc(strlen(bpad->name) + 1, GFP_KERNEL);
297 if (!pad->name) {
298 int j;
299
300 for (j = i - 1; j >= 0; j--)
301 kfree(hmux->pads[j].name);
302 goto err3;
303 }
304 strcpy(pad->name, bpad->name);
305
306 pad->flags = bpad->flags;
307 pad->enable = bpad->enable;
308 pad->idle = bpad->idle;
309 pad->off = bpad->off;
Tony Lindgren029268e2011-03-11 11:32:25 -0800310
Paul Walmsley96dc19f2011-12-16 14:36:57 -0700311 if (pad->flags &
312 (OMAP_DEVICE_PAD_REMUX | OMAP_DEVICE_PAD_WAKEUP))
Tony Lindgren029268e2011-03-11 11:32:25 -0800313 nr_pads_dynamic++;
314
Tony Lindgren9796b322010-12-22 18:42:35 -0800315 pr_debug("%s: Initialized %s\n", __func__, pad->name);
316 }
317
Tony Lindgren029268e2011-03-11 11:32:25 -0800318 if (!nr_pads_dynamic)
319 return hmux;
320
321 /*
322 * Add pads that need dynamic muxing into a separate list
323 */
324
325 hmux->nr_pads_dynamic = nr_pads_dynamic;
326 hmux->pads_dynamic = kzalloc(sizeof(struct omap_device_pad *) *
327 nr_pads_dynamic, GFP_KERNEL);
328 if (!hmux->pads_dynamic) {
329 pr_err("%s: Could not allocate dynamic pads\n", __func__);
330 return hmux;
331 }
332
333 nr_pads_dynamic = 0;
334 for (i = 0; i < hmux->nr_pads; i++) {
335 struct omap_device_pad *pad = &hmux->pads[i];
336
Paul Walmsley96dc19f2011-12-16 14:36:57 -0700337 if (pad->flags &
338 (OMAP_DEVICE_PAD_REMUX | OMAP_DEVICE_PAD_WAKEUP)) {
Tony Lindgren029268e2011-03-11 11:32:25 -0800339 pr_debug("%s: pad %s tagged dynamic\n",
340 __func__, pad->name);
341 hmux->pads_dynamic[nr_pads_dynamic] = pad;
342 nr_pads_dynamic++;
343 }
344 }
345
Tony Lindgren9796b322010-12-22 18:42:35 -0800346 return hmux;
347
348err3:
349 kfree(hmux->pads);
350err2:
351 kfree(hmux);
352err1:
353 pr_err("%s: Could not allocate device mux entry\n", __func__);
354
355 return NULL;
356}
357
Tero Kristo13a3fe52011-12-16 14:36:59 -0700358/**
359 * omap_hwmod_mux_scan_wakeups - omap hwmod scan wakeup pads
360 * @hmux: Pads for a hwmod
361 * @mpu_irqs: MPU irq array for a hwmod
362 *
363 * Scans the wakeup status of pads for a single hwmod. If an irq
364 * array is defined for this mux, the parser will call the registered
365 * ISRs for corresponding pads, otherwise the parser will stop at the
366 * first wakeup active pad and return. Returns true if there is a
367 * pending and non-served wakeup event for the mux, otherwise false.
368 */
369static bool omap_hwmod_mux_scan_wakeups(struct omap_hwmod_mux_info *hmux,
370 struct omap_hwmod_irq_info *mpu_irqs)
371{
372 int i, irq;
373 unsigned int val;
374 u32 handled_irqs = 0;
375
376 for (i = 0; i < hmux->nr_pads_dynamic; i++) {
377 struct omap_device_pad *pad = hmux->pads_dynamic[i];
378
379 if (!(pad->flags & OMAP_DEVICE_PAD_WAKEUP) ||
380 !(pad->idle & OMAP_WAKEUP_EN))
381 continue;
382
383 val = omap_mux_read(pad->partition, pad->mux->reg_offset);
384 if (!(val & OMAP_WAKEUP_EVENT))
385 continue;
386
387 if (!hmux->irqs)
388 return true;
389
390 irq = hmux->irqs[i];
391 /* make sure we only handle each irq once */
392 if (handled_irqs & 1 << irq)
393 continue;
394
395 handled_irqs |= 1 << irq;
396
397 generic_handle_irq(mpu_irqs[irq].irq);
398 }
399
400 return false;
401}
402
403/**
404 * _omap_hwmod_mux_handle_irq - Process wakeup events for a single hwmod
405 *
406 * Checks a single hwmod for every wakeup capable pad to see if there is an
407 * active wakeup event. If this is the case, call the corresponding ISR.
408 */
409static int _omap_hwmod_mux_handle_irq(struct omap_hwmod *oh, void *data)
410{
411 if (!oh->mux || !oh->mux->enabled)
412 return 0;
413 if (omap_hwmod_mux_scan_wakeups(oh->mux, oh->mpu_irqs))
414 generic_handle_irq(oh->mpu_irqs[0].irq);
415 return 0;
416}
417
418/**
419 * omap_hwmod_mux_handle_irq - Process pad wakeup irqs.
420 *
421 * Calls a function for each registered omap_hwmod to check
422 * pad wakeup statuses.
423 */
424static irqreturn_t omap_hwmod_mux_handle_irq(int irq, void *unused)
425{
426 omap_hwmod_for_each(_omap_hwmod_mux_handle_irq, NULL);
427 return IRQ_HANDLED;
428}
429
Tony Lindgren8d9af882010-12-22 18:42:35 -0800430/* Assumes the calling function takes care of locking */
431void omap_hwmod_mux(struct omap_hwmod_mux_info *hmux, u8 state)
432{
433 int i;
434
Tony Lindgren029268e2011-03-11 11:32:25 -0800435 /* Runtime idling of dynamic pads */
436 if (state == _HWMOD_STATE_IDLE && hmux->enabled) {
437 for (i = 0; i < hmux->nr_pads_dynamic; i++) {
438 struct omap_device_pad *pad = hmux->pads_dynamic[i];
439 int val = -EINVAL;
440
Tony Lindgren029268e2011-03-11 11:32:25 -0800441 val = pad->idle;
442 omap_mux_write(pad->partition, val,
443 pad->mux->reg_offset);
444 }
445
446 return;
447 }
448
449 /* Runtime enabling of dynamic pads */
R Sricharan86c79bf2011-03-11 11:32:25 -0800450 if ((state == _HWMOD_STATE_ENABLED) && hmux->pads_dynamic
451 && hmux->enabled) {
Tony Lindgren029268e2011-03-11 11:32:25 -0800452 for (i = 0; i < hmux->nr_pads_dynamic; i++) {
453 struct omap_device_pad *pad = hmux->pads_dynamic[i];
454 int val = -EINVAL;
455
Tony Lindgren029268e2011-03-11 11:32:25 -0800456 val = pad->enable;
457 omap_mux_write(pad->partition, val,
458 pad->mux->reg_offset);
Tony Lindgren029268e2011-03-11 11:32:25 -0800459 }
460
R Sricharan86c79bf2011-03-11 11:32:25 -0800461 return;
Tony Lindgren029268e2011-03-11 11:32:25 -0800462 }
463
464 /* Enabling or disabling of all pads */
Tony Lindgren8d9af882010-12-22 18:42:35 -0800465 for (i = 0; i < hmux->nr_pads; i++) {
466 struct omap_device_pad *pad = &hmux->pads[i];
467 int flags, val = -EINVAL;
468
469 flags = pad->flags;
470
471 switch (state) {
472 case _HWMOD_STATE_ENABLED:
Tony Lindgren8d9af882010-12-22 18:42:35 -0800473 val = pad->enable;
474 pr_debug("%s: Enabling %s %x\n", __func__,
475 pad->name, val);
476 break;
Tony Lindgren8d9af882010-12-22 18:42:35 -0800477 case _HWMOD_STATE_DISABLED:
Tony Lindgren8d9af882010-12-22 18:42:35 -0800478 /* Use safe mode unless OMAP_DEVICE_PAD_REMUX */
479 if (flags & OMAP_DEVICE_PAD_REMUX)
480 val = pad->off;
481 else
482 val = OMAP_MUX_MODE7;
Tony Lindgren8d9af882010-12-22 18:42:35 -0800483 pr_debug("%s: Disabling %s %x\n", __func__,
484 pad->name, val);
R Sricharan86c79bf2011-03-11 11:32:25 -0800485 break;
486 default:
487 /* Nothing to be done */
488 break;
Tony Lindgren8d9af882010-12-22 18:42:35 -0800489 };
490
491 if (val >= 0) {
492 omap_mux_write(pad->partition, val,
493 pad->mux->reg_offset);
494 pad->flags = flags;
495 }
496 }
Tony Lindgren029268e2011-03-11 11:32:25 -0800497
498 if (state == _HWMOD_STATE_ENABLED)
499 hmux->enabled = true;
500 else
501 hmux->enabled = false;
Tony Lindgren8d9af882010-12-22 18:42:35 -0800502}
503
Tony Lindgren4b715ef2009-12-11 16:16:32 -0800504#ifdef CONFIG_DEBUG_FS
505
506#define OMAP_MUX_MAX_NR_FLAGS 10
507#define OMAP_MUX_TEST_FLAG(val, mask) \
508 if (((val) & (mask)) == (mask)) { \
509 i++; \
510 flags[i] = #mask; \
511 }
512
513/* REVISIT: Add checking for non-optimal mux settings */
514static inline void omap_mux_decode(struct seq_file *s, u16 val)
515{
516 char *flags[OMAP_MUX_MAX_NR_FLAGS];
Tony Lindgren78737ae2010-02-01 13:03:42 -0800517 char mode[sizeof("OMAP_MUX_MODE") + 1];
Tony Lindgren4b715ef2009-12-11 16:16:32 -0800518 int i = -1;
519
520 sprintf(mode, "OMAP_MUX_MODE%d", val & 0x7);
521 i++;
522 flags[i] = mode;
523
524 OMAP_MUX_TEST_FLAG(val, OMAP_PIN_OFF_WAKEUPENABLE);
525 if (val & OMAP_OFF_EN) {
526 if (!(val & OMAP_OFFOUT_EN)) {
527 if (!(val & OMAP_OFF_PULL_UP)) {
528 OMAP_MUX_TEST_FLAG(val,
529 OMAP_PIN_OFF_INPUT_PULLDOWN);
530 } else {
531 OMAP_MUX_TEST_FLAG(val,
532 OMAP_PIN_OFF_INPUT_PULLUP);
533 }
534 } else {
535 if (!(val & OMAP_OFFOUT_VAL)) {
536 OMAP_MUX_TEST_FLAG(val,
537 OMAP_PIN_OFF_OUTPUT_LOW);
538 } else {
539 OMAP_MUX_TEST_FLAG(val,
540 OMAP_PIN_OFF_OUTPUT_HIGH);
541 }
542 }
543 }
544
545 if (val & OMAP_INPUT_EN) {
546 if (val & OMAP_PULL_ENA) {
547 if (!(val & OMAP_PULL_UP)) {
548 OMAP_MUX_TEST_FLAG(val,
549 OMAP_PIN_INPUT_PULLDOWN);
550 } else {
551 OMAP_MUX_TEST_FLAG(val, OMAP_PIN_INPUT_PULLUP);
552 }
553 } else {
554 OMAP_MUX_TEST_FLAG(val, OMAP_PIN_INPUT);
555 }
556 } else {
557 i++;
558 flags[i] = "OMAP_PIN_OUTPUT";
559 }
560
561 do {
562 seq_printf(s, "%s", flags[i]);
563 if (i > 0)
564 seq_printf(s, " | ");
565 } while (i-- > 0);
566}
567
Benoit Cousson112485e2010-08-16 10:55:35 +0200568#define OMAP_MUX_DEFNAME_LEN 32
Tony Lindgren4b715ef2009-12-11 16:16:32 -0800569
570static int omap_mux_dbg_board_show(struct seq_file *s, void *unused)
571{
Benoit Cousson112485e2010-08-16 10:55:35 +0200572 struct omap_mux_partition *partition = s->private;
Tony Lindgren4b715ef2009-12-11 16:16:32 -0800573 struct omap_mux_entry *e;
Benoit Cousson112485e2010-08-16 10:55:35 +0200574 u8 omap_gen = omap_rev() >> 28;
Tony Lindgren4b715ef2009-12-11 16:16:32 -0800575
Benoit Cousson112485e2010-08-16 10:55:35 +0200576 list_for_each_entry(e, &partition->muxmodes, node) {
Tony Lindgren4b715ef2009-12-11 16:16:32 -0800577 struct omap_mux *m = &e->mux;
578 char m0_def[OMAP_MUX_DEFNAME_LEN];
579 char *m0_name = m->muxnames[0];
580 u16 val;
581 int i, mode;
582
583 if (!m0_name)
584 continue;
585
Tony Lindgren78737ae2010-02-01 13:03:42 -0800586 /* REVISIT: Needs to be updated if mode0 names get longer */
Tony Lindgren4b715ef2009-12-11 16:16:32 -0800587 for (i = 0; i < OMAP_MUX_DEFNAME_LEN; i++) {
588 if (m0_name[i] == '\0') {
589 m0_def[i] = m0_name[i];
590 break;
591 }
592 m0_def[i] = toupper(m0_name[i]);
593 }
Benoit Cousson112485e2010-08-16 10:55:35 +0200594 val = omap_mux_read(partition, m->reg_offset);
Tony Lindgren4b715ef2009-12-11 16:16:32 -0800595 mode = val & OMAP_MUX_MODE7;
Benoit Cousson112485e2010-08-16 10:55:35 +0200596 if (mode != 0)
597 seq_printf(s, "/* %s */\n", m->muxnames[mode]);
Tony Lindgren4b715ef2009-12-11 16:16:32 -0800598
Benoit Cousson112485e2010-08-16 10:55:35 +0200599 /*
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300600 * XXX: Might be revisited to support differences across
Benoit Cousson112485e2010-08-16 10:55:35 +0200601 * same OMAP generation.
602 */
603 seq_printf(s, "OMAP%d_MUX(%s, ", omap_gen, m0_def);
Tony Lindgren4b715ef2009-12-11 16:16:32 -0800604 omap_mux_decode(s, val);
605 seq_printf(s, "),\n");
606 }
607
608 return 0;
609}
610
611static int omap_mux_dbg_board_open(struct inode *inode, struct file *file)
612{
Benoit Cousson112485e2010-08-16 10:55:35 +0200613 return single_open(file, omap_mux_dbg_board_show, inode->i_private);
Tony Lindgren4b715ef2009-12-11 16:16:32 -0800614}
615
616static const struct file_operations omap_mux_dbg_board_fops = {
617 .open = omap_mux_dbg_board_open,
618 .read = seq_read,
619 .llseek = seq_lseek,
620 .release = single_release,
621};
622
Benoit Cousson112485e2010-08-16 10:55:35 +0200623static struct omap_mux_partition *omap_mux_get_partition(struct omap_mux *mux)
624{
625 struct omap_mux_partition *partition;
626
627 list_for_each_entry(partition, &mux_partitions, node) {
628 struct list_head *muxmodes = &partition->muxmodes;
629 struct omap_mux_entry *e;
630
631 list_for_each_entry(e, muxmodes, node) {
632 struct omap_mux *m = &e->mux;
633
634 if (m == mux)
635 return partition;
636 }
637 }
638
639 return NULL;
640}
641
Tony Lindgren4b715ef2009-12-11 16:16:32 -0800642static int omap_mux_dbg_signal_show(struct seq_file *s, void *unused)
643{
644 struct omap_mux *m = s->private;
Benoit Cousson112485e2010-08-16 10:55:35 +0200645 struct omap_mux_partition *partition;
Tony Lindgren4b715ef2009-12-11 16:16:32 -0800646 const char *none = "NA";
647 u16 val;
648 int mode;
649
Benoit Cousson112485e2010-08-16 10:55:35 +0200650 partition = omap_mux_get_partition(m);
651 if (!partition)
652 return 0;
653
654 val = omap_mux_read(partition, m->reg_offset);
Tony Lindgren4b715ef2009-12-11 16:16:32 -0800655 mode = val & OMAP_MUX_MODE7;
656
Benoit Cousson112485e2010-08-16 10:55:35 +0200657 seq_printf(s, "name: %s.%s (0x%08x/0x%03x = 0x%04x), b %s, t %s\n",
Tony Lindgren4b715ef2009-12-11 16:16:32 -0800658 m->muxnames[0], m->muxnames[mode],
Benoit Cousson112485e2010-08-16 10:55:35 +0200659 partition->phys + m->reg_offset, m->reg_offset, val,
Tony Lindgren4b715ef2009-12-11 16:16:32 -0800660 m->balls[0] ? m->balls[0] : none,
661 m->balls[1] ? m->balls[1] : none);
662 seq_printf(s, "mode: ");
663 omap_mux_decode(s, val);
664 seq_printf(s, "\n");
665 seq_printf(s, "signals: %s | %s | %s | %s | %s | %s | %s | %s\n",
666 m->muxnames[0] ? m->muxnames[0] : none,
667 m->muxnames[1] ? m->muxnames[1] : none,
668 m->muxnames[2] ? m->muxnames[2] : none,
669 m->muxnames[3] ? m->muxnames[3] : none,
670 m->muxnames[4] ? m->muxnames[4] : none,
671 m->muxnames[5] ? m->muxnames[5] : none,
672 m->muxnames[6] ? m->muxnames[6] : none,
673 m->muxnames[7] ? m->muxnames[7] : none);
674
675 return 0;
676}
677
678#define OMAP_MUX_MAX_ARG_CHAR 7
679
680static ssize_t omap_mux_dbg_signal_write(struct file *file,
Benoit Cousson112485e2010-08-16 10:55:35 +0200681 const char __user *user_buf,
682 size_t count, loff_t *ppos)
Tony Lindgren4b715ef2009-12-11 16:16:32 -0800683{
684 char buf[OMAP_MUX_MAX_ARG_CHAR];
685 struct seq_file *seqf;
686 struct omap_mux *m;
687 unsigned long val;
688 int buf_size, ret;
Benoit Cousson112485e2010-08-16 10:55:35 +0200689 struct omap_mux_partition *partition;
Tony Lindgren4b715ef2009-12-11 16:16:32 -0800690
691 if (count > OMAP_MUX_MAX_ARG_CHAR)
692 return -EINVAL;
693
694 memset(buf, 0, sizeof(buf));
695 buf_size = min(count, sizeof(buf) - 1);
696
697 if (copy_from_user(buf, user_buf, buf_size))
698 return -EFAULT;
699
700 ret = strict_strtoul(buf, 0x10, &val);
701 if (ret < 0)
702 return ret;
703
704 if (val > 0xffff)
705 return -EINVAL;
706
707 seqf = file->private_data;
708 m = seqf->private;
709
Benoit Cousson112485e2010-08-16 10:55:35 +0200710 partition = omap_mux_get_partition(m);
711 if (!partition)
712 return -ENODEV;
713
714 omap_mux_write(partition, (u16)val, m->reg_offset);
Tony Lindgren4b715ef2009-12-11 16:16:32 -0800715 *ppos += count;
716
717 return count;
718}
719
720static int omap_mux_dbg_signal_open(struct inode *inode, struct file *file)
721{
722 return single_open(file, omap_mux_dbg_signal_show, inode->i_private);
723}
724
725static const struct file_operations omap_mux_dbg_signal_fops = {
726 .open = omap_mux_dbg_signal_open,
727 .read = seq_read,
728 .write = omap_mux_dbg_signal_write,
729 .llseek = seq_lseek,
730 .release = single_release,
731};
732
733static struct dentry *mux_dbg_dir;
734
Benoit Cousson112485e2010-08-16 10:55:35 +0200735static void __init omap_mux_dbg_create_entry(
736 struct omap_mux_partition *partition,
737 struct dentry *mux_dbg_dir)
Tony Lindgren4b715ef2009-12-11 16:16:32 -0800738{
739 struct omap_mux_entry *e;
740
Benoit Cousson112485e2010-08-16 10:55:35 +0200741 list_for_each_entry(e, &partition->muxmodes, node) {
742 struct omap_mux *m = &e->mux;
743
Vasiliy Kulikov9b127712011-02-04 12:23:13 +0000744 (void)debugfs_create_file(m->muxnames[0], S_IWUSR, mux_dbg_dir,
Benoit Cousson112485e2010-08-16 10:55:35 +0200745 m, &omap_mux_dbg_signal_fops);
746 }
747}
748
749static void __init omap_mux_dbg_init(void)
750{
751 struct omap_mux_partition *partition;
752 static struct dentry *mux_dbg_board_dir;
753
Tony Lindgren4b715ef2009-12-11 16:16:32 -0800754 mux_dbg_dir = debugfs_create_dir("omap_mux", NULL);
755 if (!mux_dbg_dir)
756 return;
757
Benoit Cousson112485e2010-08-16 10:55:35 +0200758 mux_dbg_board_dir = debugfs_create_dir("board", mux_dbg_dir);
759 if (!mux_dbg_board_dir)
760 return;
Tony Lindgren4b715ef2009-12-11 16:16:32 -0800761
Benoit Cousson112485e2010-08-16 10:55:35 +0200762 list_for_each_entry(partition, &mux_partitions, node) {
763 omap_mux_dbg_create_entry(partition, mux_dbg_dir);
764 (void)debugfs_create_file(partition->name, S_IRUGO,
765 mux_dbg_board_dir, partition,
766 &omap_mux_dbg_board_fops);
Tony Lindgren4b715ef2009-12-11 16:16:32 -0800767 }
768}
769
770#else
771static inline void omap_mux_dbg_init(void)
772{
773}
774#endif /* CONFIG_DEBUG_FS */
775
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800776static void __init omap_mux_free_names(struct omap_mux *m)
777{
778 int i;
779
780 for (i = 0; i < OMAP_MUX_NR_MODES; i++)
781 kfree(m->muxnames[i]);
782
783#ifdef CONFIG_DEBUG_FS
784 for (i = 0; i < OMAP_MUX_NR_SIDES; i++)
785 kfree(m->balls[i]);
Tony Lindgren1dbae812005-11-10 14:26:51 +0000786#endif
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800787
788}
789
790/* Free all data except for GPIO pins unless CONFIG_DEBUG_FS is set */
791static int __init omap_mux_late_init(void)
792{
Benoit Cousson112485e2010-08-16 10:55:35 +0200793 struct omap_mux_partition *partition;
Tero Kristo13a3fe52011-12-16 14:36:59 -0700794 int ret;
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800795
Benoit Cousson112485e2010-08-16 10:55:35 +0200796 list_for_each_entry(partition, &mux_partitions, node) {
797 struct omap_mux_entry *e, *tmp;
798 list_for_each_entry_safe(e, tmp, &partition->muxmodes, node) {
799 struct omap_mux *m = &e->mux;
800 u16 mode = omap_mux_read(partition, m->reg_offset);
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800801
Benoit Cousson112485e2010-08-16 10:55:35 +0200802 if (OMAP_MODE_GPIO(mode))
803 continue;
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800804
805#ifndef CONFIG_DEBUG_FS
Benoit Cousson112485e2010-08-16 10:55:35 +0200806 mutex_lock(&muxmode_mutex);
807 list_del(&e->node);
808 mutex_unlock(&muxmode_mutex);
809 omap_mux_free_names(m);
810 kfree(m);
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800811#endif
Benoit Cousson112485e2010-08-16 10:55:35 +0200812 }
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800813 }
814
Tero Kristo13a3fe52011-12-16 14:36:59 -0700815 ret = request_irq(omap_prcm_event_to_irq("io"),
816 omap_hwmod_mux_handle_irq, IRQF_SHARED | IRQF_NO_SUSPEND,
817 "hwmod_io", omap_mux_late_init);
818
819 if (ret)
820 pr_warning("mux: Failed to setup hwmod io irq %d\n", ret);
821
Tony Lindgren4b715ef2009-12-11 16:16:32 -0800822 omap_mux_dbg_init();
823
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800824 return 0;
825}
826late_initcall(omap_mux_late_init);
827
828static void __init omap_mux_package_fixup(struct omap_mux *p,
829 struct omap_mux *superset)
830{
831 while (p->reg_offset != OMAP_MUX_TERMINATOR) {
832 struct omap_mux *s = superset;
833 int found = 0;
834
835 while (s->reg_offset != OMAP_MUX_TERMINATOR) {
836 if (s->reg_offset == p->reg_offset) {
837 *s = *p;
838 found++;
839 break;
840 }
841 s++;
842 }
843 if (!found)
Dan Murphy032a6422010-11-15 09:50:50 -0600844 pr_err("%s: Unknown entry offset 0x%x\n", __func__,
Benoit Cousson1cbb3a92010-08-10 17:33:01 +0200845 p->reg_offset);
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800846 p++;
847 }
848}
849
850#ifdef CONFIG_DEBUG_FS
851
852static void __init omap_mux_package_init_balls(struct omap_ball *b,
853 struct omap_mux *superset)
854{
855 while (b->reg_offset != OMAP_MUX_TERMINATOR) {
856 struct omap_mux *s = superset;
857 int found = 0;
858
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];
863 found++;
864 break;
865 }
866 s++;
867 }
868 if (!found)
Dan Murphy032a6422010-11-15 09:50:50 -0600869 pr_err("%s: Unknown ball offset 0x%x\n", __func__,
Benoit Cousson1cbb3a92010-08-10 17:33:01 +0200870 b->reg_offset);
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800871 b++;
872 }
873}
874
875#else /* CONFIG_DEBUG_FS */
876
877static inline void omap_mux_package_init_balls(struct omap_ball *b,
878 struct omap_mux *superset)
879{
880}
881
882#endif /* CONFIG_DEBUG_FS */
883
884static int __init omap_mux_setup(char *options)
885{
886 if (!options)
887 return 0;
888
889 omap_mux_options = options;
890
891 return 1;
892}
893__setup("omap_mux=", omap_mux_setup);
894
895/*
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.
900 */
901static void __init omap_mux_set_cmdline_signals(void)
902{
903 char *options, *next_opt, *token;
904
905 if (!omap_mux_options)
906 return;
907
Thomas Meyerdccb3b02011-08-06 09:29:10 +0000908 options = kstrdup(omap_mux_options, GFP_KERNEL);
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800909 if (!options)
910 return;
911
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800912 next_opt = options;
913
914 while ((token = strsep(&next_opt, ",")) != NULL) {
915 char *keyval, *name;
916 unsigned long val;
917
918 keyval = token;
919 name = strsep(&keyval, "=");
920 if (name) {
921 int res;
922
923 res = strict_strtoul(keyval, 0x10, &val);
924 if (res < 0)
925 continue;
926
927 omap_mux_init_signal(name, (u16)val);
928 }
929 }
930
931 kfree(options);
932}
933
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800934static int __init omap_mux_copy_names(struct omap_mux *src,
Benoit Cousson112485e2010-08-16 10:55:35 +0200935 struct omap_mux *dst)
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800936{
937 int i;
938
939 for (i = 0; i < OMAP_MUX_NR_MODES; i++) {
940 if (src->muxnames[i]) {
Thomas Meyerdccb3b02011-08-06 09:29:10 +0000941 dst->muxnames[i] = kstrdup(src->muxnames[i],
942 GFP_KERNEL);
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800943 if (!dst->muxnames[i])
944 goto free;
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800945 }
946 }
947
948#ifdef CONFIG_DEBUG_FS
949 for (i = 0; i < OMAP_MUX_NR_SIDES; i++) {
950 if (src->balls[i]) {
Thomas Meyerdccb3b02011-08-06 09:29:10 +0000951 dst->balls[i] = kstrdup(src->balls[i], GFP_KERNEL);
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800952 if (!dst->balls[i])
953 goto free;
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800954 }
955 }
956#endif
957
958 return 0;
959
960free:
961 omap_mux_free_names(dst);
962 return -ENOMEM;
963
964}
965
966#endif /* CONFIG_OMAP_MUX */
967
Benoit Cousson112485e2010-08-16 10:55:35 +0200968static struct omap_mux *omap_mux_get_by_gpio(
969 struct omap_mux_partition *partition,
970 int gpio)
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800971{
972 struct omap_mux_entry *e;
Benoit Cousson112485e2010-08-16 10:55:35 +0200973 struct omap_mux *ret = NULL;
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800974
Benoit Cousson112485e2010-08-16 10:55:35 +0200975 list_for_each_entry(e, &partition->muxmodes, node) {
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800976 struct omap_mux *m = &e->mux;
977 if (m->gpio == gpio) {
Benoit Cousson112485e2010-08-16 10:55:35 +0200978 ret = m;
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800979 break;
980 }
981 }
982
Benoit Cousson112485e2010-08-16 10:55:35 +0200983 return ret;
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800984}
985
986/* Needed for dynamic muxing of GPIO pins for off-idle */
987u16 omap_mux_get_gpio(int gpio)
988{
Benoit Cousson112485e2010-08-16 10:55:35 +0200989 struct omap_mux_partition *partition;
Govindraj.R30ebad92011-06-01 11:28:56 +0530990 struct omap_mux *m = NULL;
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800991
Benoit Cousson112485e2010-08-16 10:55:35 +0200992 list_for_each_entry(partition, &mux_partitions, node) {
993 m = omap_mux_get_by_gpio(partition, gpio);
994 if (m)
995 return omap_mux_read(partition, m->reg_offset);
Tony Lindgren15ac7af2009-12-11 16:16:32 -0800996 }
997
Benoit Cousson112485e2010-08-16 10:55:35 +0200998 if (!m || m->reg_offset == OMAP_MUX_TERMINATOR)
Dan Murphy032a6422010-11-15 09:50:50 -0600999 pr_err("%s: Could not get gpio%i\n", __func__, gpio);
Benoit Cousson112485e2010-08-16 10:55:35 +02001000
1001 return OMAP_MUX_TERMINATOR;
Tony Lindgren15ac7af2009-12-11 16:16:32 -08001002}
1003
1004/* Needed for dynamic muxing of GPIO pins for off-idle */
1005void omap_mux_set_gpio(u16 val, int gpio)
1006{
Benoit Cousson112485e2010-08-16 10:55:35 +02001007 struct omap_mux_partition *partition;
1008 struct omap_mux *m = NULL;
Tony Lindgren15ac7af2009-12-11 16:16:32 -08001009
Benoit Cousson112485e2010-08-16 10:55:35 +02001010 list_for_each_entry(partition, &mux_partitions, node) {
1011 m = omap_mux_get_by_gpio(partition, gpio);
1012 if (m) {
1013 omap_mux_write(partition, val, m->reg_offset);
1014 return;
1015 }
Tony Lindgren15ac7af2009-12-11 16:16:32 -08001016 }
1017
Benoit Cousson112485e2010-08-16 10:55:35 +02001018 if (!m || m->reg_offset == OMAP_MUX_TERMINATOR)
Dan Murphy032a6422010-11-15 09:50:50 -06001019 pr_err("%s: Could not set gpio%i\n", __func__, gpio);
Tony Lindgren15ac7af2009-12-11 16:16:32 -08001020}
1021
Benoit Cousson112485e2010-08-16 10:55:35 +02001022static struct omap_mux * __init omap_mux_list_add(
1023 struct omap_mux_partition *partition,
1024 struct omap_mux *src)
Tony Lindgren15ac7af2009-12-11 16:16:32 -08001025{
1026 struct omap_mux_entry *entry;
1027 struct omap_mux *m;
1028
1029 entry = kzalloc(sizeof(struct omap_mux_entry), GFP_KERNEL);
1030 if (!entry)
1031 return NULL;
1032
1033 m = &entry->mux;
Aaro Koskinen30833142011-01-06 19:49:28 -08001034 entry->mux = *src;
Tony Lindgren15ac7af2009-12-11 16:16:32 -08001035
1036#ifdef CONFIG_OMAP_MUX
1037 if (omap_mux_copy_names(src, m)) {
1038 kfree(entry);
1039 return NULL;
1040 }
1041#endif
1042
1043 mutex_lock(&muxmode_mutex);
Benoit Cousson112485e2010-08-16 10:55:35 +02001044 list_add_tail(&entry->node, &partition->muxmodes);
Tony Lindgren15ac7af2009-12-11 16:16:32 -08001045 mutex_unlock(&muxmode_mutex);
1046
1047 return m;
1048}
1049
1050/*
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.
1054 */
Benoit Cousson112485e2010-08-16 10:55:35 +02001055static void __init omap_mux_init_list(struct omap_mux_partition *partition,
1056 struct omap_mux *superset)
Tony Lindgren15ac7af2009-12-11 16:16:32 -08001057{
1058 while (superset->reg_offset != OMAP_MUX_TERMINATOR) {
1059 struct omap_mux *entry;
1060
Ranjith Lohithakshanb72c7d52010-02-17 17:17:01 +00001061#ifdef CONFIG_OMAP_MUX
1062 if (!superset->muxnames || !superset->muxnames[0]) {
Tony Lindgren15ac7af2009-12-11 16:16:32 -08001063 superset++;
1064 continue;
1065 }
Ranjith Lohithakshanb72c7d52010-02-17 17:17:01 +00001066#else
1067 /* Skip pins that are not muxed as GPIO by bootloader */
Benoit Cousson112485e2010-08-16 10:55:35 +02001068 if (!OMAP_MODE_GPIO(omap_mux_read(partition,
1069 superset->reg_offset))) {
Tony Lindgren9ecef432010-02-01 11:22:54 -08001070 superset++;
1071 continue;
1072 }
1073#endif
1074
Benoit Cousson112485e2010-08-16 10:55:35 +02001075 entry = omap_mux_list_add(partition, superset);
Tony Lindgren15ac7af2009-12-11 16:16:32 -08001076 if (!entry) {
Dan Murphy032a6422010-11-15 09:50:50 -06001077 pr_err("%s: Could not add entry\n", __func__);
Tony Lindgren15ac7af2009-12-11 16:16:32 -08001078 return;
1079 }
1080 superset++;
1081 }
1082}
1083
Tony Lindgren321cfc82010-02-15 10:03:35 -08001084#ifdef CONFIG_OMAP_MUX
1085
1086static void omap_mux_init_package(struct omap_mux *superset,
1087 struct omap_mux *package_subset,
1088 struct omap_ball *package_balls)
1089{
1090 if (package_subset)
1091 omap_mux_package_fixup(package_subset, superset);
1092 if (package_balls)
1093 omap_mux_package_init_balls(package_balls, superset);
1094}
1095
Russell King27d8d3b2012-02-07 10:18:34 +00001096static void __init omap_mux_init_signals(struct omap_mux_partition *partition,
1097 struct omap_board_mux *board_mux)
Tony Lindgren321cfc82010-02-15 10:03:35 -08001098{
1099 omap_mux_set_cmdline_signals();
Benoit Cousson112485e2010-08-16 10:55:35 +02001100 omap_mux_write_array(partition, board_mux);
Tony Lindgren321cfc82010-02-15 10:03:35 -08001101}
1102
1103#else
1104
1105static void omap_mux_init_package(struct omap_mux *superset,
1106 struct omap_mux *package_subset,
1107 struct omap_ball *package_balls)
1108{
1109}
1110
Russell King27d8d3b2012-02-07 10:18:34 +00001111static void __init omap_mux_init_signals(struct omap_mux_partition *partition,
1112 struct omap_board_mux *board_mux)
Tony Lindgren321cfc82010-02-15 10:03:35 -08001113{
1114}
1115
1116#endif
1117
Benoit Cousson112485e2010-08-16 10:55:35 +02001118static u32 mux_partitions_cnt;
Tony Lindgren15ac7af2009-12-11 16:16:32 -08001119
Benoit Cousson112485e2010-08-16 10:55:35 +02001120int __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)
1126{
1127 struct omap_mux_partition *partition;
1128
1129 partition = kzalloc(sizeof(struct omap_mux_partition), GFP_KERNEL);
1130 if (!partition)
1131 return -ENOMEM;
1132
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) {
Dan Murphy032a6422010-11-15 09:50:50 -06001139 pr_err("%s: Could not ioremap mux partition at 0x%08x\n",
1140 __func__, partition->phys);
Aaro Koskinen9d47e302011-01-28 14:50:55 +00001141 kfree(partition);
Tony Lindgren15ac7af2009-12-11 16:16:32 -08001142 return -ENODEV;
1143 }
1144
Benoit Cousson112485e2010-08-16 10:55:35 +02001145 INIT_LIST_HEAD(&partition->muxmodes);
1146
1147 list_add_tail(&partition->node, &mux_partitions);
1148 mux_partitions_cnt++;
Dan Murphy032a6422010-11-15 09:50:50 -06001149 pr_info("%s: Add partition: #%d: %s, flags: %x\n", __func__,
Benoit Cousson112485e2010-08-16 10:55:35 +02001150 mux_partitions_cnt, partition->name, partition->flags);
Tony Lindgrend5425be2010-07-05 16:31:35 +03001151
Tony Lindgren321cfc82010-02-15 10:03:35 -08001152 omap_mux_init_package(superset, package_subset, package_balls);
Benoit Cousson112485e2010-08-16 10:55:35 +02001153 omap_mux_init_list(partition, superset);
1154 omap_mux_init_signals(partition, board_mux);
Tony Lindgren2cb0c542010-01-19 18:17:07 -08001155
Tony Lindgren15ac7af2009-12-11 16:16:32 -08001156 return 0;
1157}
1158