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 "omap_hwmod.h"
  40
  41 #include "soc.h"
  42 #include "control.h"
  43 #include "mux.h"
  44 #include "prm.h"
  45 #include "common.h"
  46
  47 #define OMAP_MUX_BASE_OFFSET            0x30    /* Offset from CTRL_BASE */
  48 #define OMAP_MUX_BASE_SZ                0x5ca
  49
  50 struct omap_mux_entry {
  51         struct omap_mux         mux;
  52         struct list_head        node;
  53 };
  54
  55 static LIST_HEAD(mux_partitions);
  56 static DEFINE_MUTEX(muxmode_mutex);
  57
  58 struct omap_mux_partition *omap_mux_get(const char *name)
  59 {
  60         struct omap_mux_partition *partition;
  61
  62         list_for_each_entry(partition, &mux_partitions, node) {
  63                 if (!strcmp(name, partition->name))
  64                         return partition;
  65         }
  66
  67         return NULL;
  68 }
  69
  70 u16 omap_mux_read(struct omap_mux_partition *partition, u16 reg)
  71 {
  72         if (partition->flags & OMAP_MUX_REG_8BIT)
  73                 return readb_relaxed(partition->base + reg);
  74         else
  75                 return readw_relaxed(partition->base + reg);
  76 }
  77
  78 void omap_mux_write(struct omap_mux_partition *partition, u16 val,
  79                            u16 reg)
  80 {
  81         if (partition->flags & OMAP_MUX_REG_8BIT)
  82                 writeb_relaxed(val, partition->base + reg);
  83         else
  84                 writew_relaxed(val, partition->base + reg);
  85 }
  86
  87 void omap_mux_write_array(struct omap_mux_partition *partition,
  88                                  struct omap_board_mux *board_mux)
  89 {
  90         if (!board_mux)
  91                 return;
  92
  93         while (board_mux->reg_offset != OMAP_MUX_TERMINATOR) {
  94                 omap_mux_write(partition, board_mux->value,
  95                                board_mux->reg_offset);
  96                 board_mux++;
  97         }
  98 }
  99
 100 #ifdef CONFIG_OMAP_MUX
 101
 102 static char *omap_mux_options;
 103
 104 static int __init _omap_mux_init_gpio(struct omap_mux_partition *partition,
 105                                       int gpio, int val)
 106 {
 107         struct omap_mux_entry *e;
 108         struct omap_mux *gpio_mux = NULL;
 109         u16 old_mode;
 110         u16 mux_mode;
 111         int found = 0;
 112         struct list_head *muxmodes = &partition->muxmodes;
 113
 114         if (!gpio)
 115                 return -EINVAL;
 116
 117         list_for_each_entry(e, muxmodes, node) {
 118                 struct omap_mux *m = &e->mux;
 119                 if (gpio == m->gpio) {
 120                         gpio_mux = m;
 121                         found++;
 122                 }
 123         }
 124
 125         if (found == 0) {
 126                 pr_err("%s: Could not set gpio%i\n", __func__, gpio);
 127                 return -ENODEV;
 128         }
 129
 130         if (found > 1) {
 131                 pr_info("%s: Multiple gpio paths (%d) for gpio%i\n", __func__,
 132                         found, gpio);
 133                 return -EINVAL;
 134         }
 135
 136         old_mode = omap_mux_read(partition, gpio_mux->reg_offset);
 137         mux_mode = val & ~(OMAP_MUX_NR_MODES - 1);
 138         mux_mode |= partition->gpio;
 139         pr_debug("%s: Setting signal %s.gpio%i 0x%04x -> 0x%04x\n", __func__,
 140                  gpio_mux->muxnames[0], gpio, old_mode, mux_mode);
 141         omap_mux_write(partition, mux_mode, gpio_mux->reg_offset);
 142
 143         return 0;
 144 }
 145
 146 int __init omap_mux_init_gpio(int gpio, int val)
 147 {
 148         struct omap_mux_partition *partition;
 149         int ret;
 150
 151         list_for_each_entry(partition, &mux_partitions, node) {
 152                 ret = _omap_mux_init_gpio(partition, gpio, val);
 153                 if (!ret)
 154                         return ret;
 155         }
 156
 157         return -ENODEV;
 158 }
 159
 160 static int __init _omap_mux_get_by_name(struct omap_mux_partition *partition,
 161                                         const char *muxname,
 162                                         struct omap_mux **found_mux)
 163 {
 164         struct omap_mux *mux = NULL;
 165         struct omap_mux_entry *e;
 166         const char *mode_name;
 167         int found = 0, found_mode = 0, mode0_len = 0;
 168         struct list_head *muxmodes = &partition->muxmodes;
 169
 170         mode_name = strchr(muxname, '.');
 171         if (mode_name) {
 172                 mode0_len = strlen(muxname) - strlen(mode_name);
 173                 mode_name++;
 174         } else {
 175                 mode_name = muxname;
 176         }
 177
 178         list_for_each_entry(e, muxmodes, node) {
 179                 char *m0_entry;
 180                 int i;
 181
 182                 mux = &e->mux;
 183                 m0_entry = mux->muxnames[0];
 184
 185                 /* First check for full name in mode0.muxmode format */
 186                 if (mode0_len)
 187                         if (strncmp(muxname, m0_entry, mode0_len) ||
 188                             (strlen(m0_entry) != mode0_len))
 189                                 continue;
 190
 191                 /* Then check for muxmode only */
 192                 for (i = 0; i < OMAP_MUX_NR_MODES; i++) {
 193                         char *mode_cur = mux->muxnames[i];
 194
 195                         if (!mode_cur)
 196                                 continue;
 197
 198                         if (!strcmp(mode_name, mode_cur)) {
 199                                 *found_mux = mux;
 200                                 found++;
 201                                 found_mode = i;
 202                         }
 203                 }
 204         }
 205
 206         if (found == 1) {
 207                 return found_mode;
 208         }
 209
 210         if (found > 1) {
 211                 pr_err("%s: Multiple signal paths (%i) for %s\n", __func__,
 212                        found, muxname);
 213                 return -EINVAL;
 214         }
 215
 216         return -ENODEV;
 217 }
 218
 219 int __init omap_mux_get_by_name(const char *muxname,
 220                         struct omap_mux_partition **found_partition,
 221                         struct omap_mux **found_mux)
 222 {
 223         struct omap_mux_partition *partition;
 224
 225         list_for_each_entry(partition, &mux_partitions, node) {
 226                 struct omap_mux *mux = NULL;
 227                 int mux_mode = _omap_mux_get_by_name(partition, muxname, &mux);
 228                 if (mux_mode < 0)
 229                         continue;
 230
 231                 *found_partition = partition;
 232                 *found_mux = mux;
 233
 234                 return mux_mode;
 235         }
 236
 237         pr_err("%s: Could not find signal %s\n", __func__, muxname);
 238
 239         return -ENODEV;
 240 }
 241
 242 int __init omap_mux_init_signal(const char *muxname, int val)
 243 {
 244         struct omap_mux_partition *partition = NULL;
 245         struct omap_mux *mux = NULL;
 246         u16 old_mode;
 247         int mux_mode;
 248
 249         mux_mode = omap_mux_get_by_name(muxname, &partition, &mux);
 250         if (mux_mode < 0 || !mux)
 251                 return mux_mode;
 252
 253         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);
 258
 259         return 0;
 260 }
 261
 262 struct omap_hwmod_mux_info * __init
 263 omap_hwmod_mux_init(struct omap_device_pad *bpads, int nr_pads)
 264 {
 265         struct omap_hwmod_mux_info *hmux;
 266         int i, nr_pads_dynamic = 0;
 267
 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;
 310
 311                 if (pad->flags &
 312                     (OMAP_DEVICE_PAD_REMUX | OMAP_DEVICE_PAD_WAKEUP))
 313                         nr_pads_dynamic++;
 314
 315                 pr_debug("%s: Initialized %s\n", __func__, pad->name);
 316         }
 317
 318         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
 337                 if (pad->flags &
 338                     (OMAP_DEVICE_PAD_REMUX | OMAP_DEVICE_PAD_WAKEUP)) {
 339                         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
 346         return hmux;
 347
 348 err3:
 349         kfree(hmux->pads);
 350 err2:
 351         kfree(hmux);
 352 err1:
 353         pr_err("%s: Could not allocate device mux entry\n", __func__);
 354
 355         return NULL;
 356 }
 357
 358 /**
 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  */
 369 static 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  */
 409 static 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  */
 424 static 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
 430 /* Assumes the calling function takes care of locking */
 431 void omap_hwmod_mux(struct omap_hwmod_mux_info *hmux, u8 state)
 432 {
 433         int i;
 434
 435         /* 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
 441                         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 */
 450         if ((state == _HWMOD_STATE_ENABLED) && hmux->pads_dynamic
 451                                         && hmux->enabled) {
 452                 for (i = 0; i < hmux->nr_pads_dynamic; i++) {
 453                         struct omap_device_pad *pad = hmux->pads_dynamic[i];
 454                         int val = -EINVAL;
 455
 456                         val = pad->enable;
 457                         omap_mux_write(pad->partition, val,
 458                                         pad->mux->reg_offset);
 459                 }
 460
 461                 return;
 462         }
 463
 464         /* Enabling or disabling of all pads */
 465         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:
 473                         val = pad->enable;
 474                         pr_debug("%s: Enabling %s %x\n", __func__,
 475                                         pad->name, val);
 476                         break;
 477                 case _HWMOD_STATE_DISABLED:
 478                         /* 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;
 483                         pr_debug("%s: Disabling %s %x\n", __func__,
 484                                         pad->name, val);
 485                         break;
 486                 default:
 487                         /* Nothing to be done */
 488                         break;
 489                 }
 490
 491                 if (val >= 0) {
 492                         omap_mux_write(pad->partition, val,
 493                                         pad->mux->reg_offset);
 494                         pad->flags = flags;
 495                 }
 496         }
 497
 498         if (state == _HWMOD_STATE_ENABLED)
 499                 hmux->enabled = true;
 500         else
 501                 hmux->enabled = false;
 502 }
 503
 504 #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 */
 514 static inline void omap_mux_decode(struct seq_file *s, u16 val)
 515 {
 516         char *flags[OMAP_MUX_MAX_NR_FLAGS];
 517         char mode[sizeof("OMAP_MUX_MODE") + 1];
 518         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
 568 #define OMAP_MUX_DEFNAME_LEN    32
 569
 570 static int omap_mux_dbg_board_show(struct seq_file *s, void *unused)
 571 {
 572         struct omap_mux_partition *partition = s->private;
 573         struct omap_mux_entry *e;
 574         u8 omap_gen = omap_rev() >> 28;
 575
 576         list_for_each_entry(e, &partition->muxmodes, node) {
 577                 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
 586                 /* REVISIT: Needs to be updated if mode0 names get longer */
 587                 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                 }
 594                 val = omap_mux_read(partition, m->reg_offset);
 595                 mode = val & OMAP_MUX_MODE7;
 596                 if (mode != 0)
 597                         seq_printf(s, "/* %s */\n", m->muxnames[mode]);
 598
 599                 /*
 600                  * XXX: Might be revisited to support differences across
 601                  * same OMAP generation.
 602                  */
 603                 seq_printf(s, "OMAP%d_MUX(%s, ", omap_gen, m0_def);
 604                 omap_mux_decode(s, val);
 605                 seq_printf(s, "),\n");
 606         }
 607
 608         return 0;
 609 }
 610
 611 static int omap_mux_dbg_board_open(struct inode *inode, struct file *file)
 612 {
 613         return single_open(file, omap_mux_dbg_board_show, inode->i_private);
 614 }
 615
 616 static 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
 623 static 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
 642 static int omap_mux_dbg_signal_show(struct seq_file *s, void *unused)
 643 {
 644         struct omap_mux *m = s->private;
 645         struct omap_mux_partition *partition;
 646         const char *none = "NA";
 647         u16 val;
 648         int mode;
 649
 650         partition = omap_mux_get_partition(m);
 651         if (!partition)
 652                 return 0;
 653
 654         val = omap_mux_read(partition, m->reg_offset);
 655         mode = val & OMAP_MUX_MODE7;
 656
 657         seq_printf(s, "name: %s.%s (0x%08x/0x%03x = 0x%04x), b %s, t %s\n",
 658                         m->muxnames[0], m->muxnames[mode],
 659                         partition->phys + m->reg_offset, m->reg_offset, val,
 660                         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
 680 static ssize_t omap_mux_dbg_signal_write(struct file *file,
 681                                          const char __user *user_buf,
 682                                          size_t count, loff_t *ppos)
 683 {
 684         struct seq_file *seqf;
 685         struct omap_mux *m;
 686         u16 val;
 687         int ret;
 688         struct omap_mux_partition *partition;
 689
 690         if (count > OMAP_MUX_MAX_ARG_CHAR)
 691                 return -EINVAL;
 692
 693         ret = kstrtou16_from_user(user_buf, count, 0x10, &val);
 694         if (ret < 0)
 695                 return ret;
 696
 697         seqf = file->private_data;
 698         m = seqf->private;
 699
 700         partition = omap_mux_get_partition(m);
 701         if (!partition)
 702                 return -ENODEV;
 703
 704         omap_mux_write(partition, val, m->reg_offset);
 705         *ppos += count;
 706
 707         return count;
 708 }
 709
 710 static int omap_mux_dbg_signal_open(struct inode *inode, struct file *file)
 711 {
 712         return single_open(file, omap_mux_dbg_signal_show, inode->i_private);
 713 }
 714
 715 static const struct file_operations omap_mux_dbg_signal_fops = {
 716         .open           = omap_mux_dbg_signal_open,
 717         .read           = seq_read,
 718         .write          = omap_mux_dbg_signal_write,
 719         .llseek         = seq_lseek,
 720         .release        = single_release,
 721 };
 722
 723 static struct dentry *mux_dbg_dir;
 724
 725 static void __init omap_mux_dbg_create_entry(
 726                                 struct omap_mux_partition *partition,
 727                                 struct dentry *mux_dbg_dir)
 728 {
 729         struct omap_mux_entry *e;
 730
 731         list_for_each_entry(e, &partition->muxmodes, node) {
 732                 struct omap_mux *m = &e->mux;
 733
 734                 (void)debugfs_create_file(m->muxnames[0], S_IWUSR | S_IRUGO,
 735                                           mux_dbg_dir, m,
 736                                           &omap_mux_dbg_signal_fops);
 737         }
 738 }
 739
 740 static void __init omap_mux_dbg_init(void)
 741 {
 742         struct omap_mux_partition *partition;
 743         static struct dentry *mux_dbg_board_dir;
 744
 745         mux_dbg_dir = debugfs_create_dir("omap_mux", NULL);
 746         if (!mux_dbg_dir)
 747                 return;
 748
 749         mux_dbg_board_dir = debugfs_create_dir("board", mux_dbg_dir);
 750         if (!mux_dbg_board_dir)
 751                 return;
 752
 753         list_for_each_entry(partition, &mux_partitions, node) {
 754                 omap_mux_dbg_create_entry(partition, mux_dbg_dir);
 755                 (void)debugfs_create_file(partition->name, S_IRUGO,
 756                                           mux_dbg_board_dir, partition,
 757                                           &omap_mux_dbg_board_fops);
 758         }
 759 }
 760
 761 #else
 762 static inline void omap_mux_dbg_init(void)
 763 {
 764 }
 765 #endif  /* CONFIG_DEBUG_FS */
 766
 767 static void __init omap_mux_free_names(struct omap_mux *m)
 768 {
 769         int i;
 770
 771         for (i = 0; i < OMAP_MUX_NR_MODES; i++)
 772                 kfree(m->muxnames[i]);
 773
 774 #ifdef CONFIG_DEBUG_FS
 775         for (i = 0; i < OMAP_MUX_NR_SIDES; i++)
 776                 kfree(m->balls[i]);
 777 #endif
 778
 779 }
 780
 781 /* Free all data except for GPIO pins unless CONFIG_DEBUG_FS is set */
 782 int __init omap_mux_late_init(void)
 783 {
 784         struct omap_mux_partition *partition;
 785         int ret;
 786
 787         list_for_each_entry(partition, &mux_partitions, node) {
 788                 struct omap_mux_entry *e, *tmp;
 789                 list_for_each_entry_safe(e, tmp, &partition->muxmodes, node) {
 790                         struct omap_mux *m = &e->mux;
 791                         u16 mode = omap_mux_read(partition, m->reg_offset);
 792
 793                         if (OMAP_MODE_GPIO(partition, mode))
 794                                 continue;
 795
 796 #ifndef CONFIG_DEBUG_FS
 797                         mutex_lock(&muxmode_mutex);
 798                         list_del(&e->node);
 799                         mutex_unlock(&muxmode_mutex);
 800                         omap_mux_free_names(m);
 801                         kfree(m);
 802 #endif
 803                 }
 804         }
 805
 806         omap_mux_dbg_init();
 807
 808         /* see pinctrl-single-omap for the wake-up interrupt handling */
 809         if (of_have_populated_dt())
 810                 return 0;
 811
 812         ret = request_irq(omap_prcm_event_to_irq("io"),
 813                 omap_hwmod_mux_handle_irq, IRQF_SHARED | IRQF_NO_SUSPEND,
 814                         "hwmod_io", omap_mux_late_init);
 815
 816         if (ret)
 817                 pr_warn("mux: Failed to setup hwmod io irq %d\n", ret);
 818
 819         return 0;
 820 }
 821
 822 static void __init omap_mux_package_fixup(struct omap_mux *p,
 823                                         struct omap_mux *superset)
 824 {
 825         while (p->reg_offset !=  OMAP_MUX_TERMINATOR) {
 826                 struct omap_mux *s = superset;
 827                 int found = 0;
 828
 829                 while (s->reg_offset != OMAP_MUX_TERMINATOR) {
 830                         if (s->reg_offset == p->reg_offset) {
 831                                 *s = *p;
 832                                 found++;
 833                                 break;
 834                         }
 835                         s++;
 836                 }
 837                 if (!found)
 838                         pr_err("%s: Unknown entry offset 0x%x\n", __func__,
 839                                p->reg_offset);
 840                 p++;
 841         }
 842 }
 843
 844 #ifdef CONFIG_DEBUG_FS
 845
 846 static void __init omap_mux_package_init_balls(struct omap_ball *b,
 847                                 struct omap_mux *superset)
 848 {
 849         while (b->reg_offset != OMAP_MUX_TERMINATOR) {
 850                 struct omap_mux *s = superset;
 851                 int found = 0;
 852
 853                 while (s->reg_offset != OMAP_MUX_TERMINATOR) {
 854                         if (s->reg_offset == b->reg_offset) {
 855                                 s->balls[0] = b->balls[0];
 856                                 s->balls[1] = b->balls[1];
 857                                 found++;
 858                                 break;
 859                         }
 860                         s++;
 861                 }
 862                 if (!found)
 863                         pr_err("%s: Unknown ball offset 0x%x\n", __func__,
 864                                b->reg_offset);
 865                 b++;
 866         }
 867 }
 868
 869 #else   /* CONFIG_DEBUG_FS */
 870
 871 static inline void omap_mux_package_init_balls(struct omap_ball *b,
 872                                         struct omap_mux *superset)
 873 {
 874 }
 875
 876 #endif  /* CONFIG_DEBUG_FS */
 877
 878 static int __init omap_mux_setup(char *options)
 879 {
 880         if (!options)
 881                 return 0;
 882
 883         omap_mux_options = options;
 884
 885         return 1;
 886 }
 887 __setup("omap_mux=", omap_mux_setup);
 888
 889 /*
 890  * Note that the omap_mux=some.signal1=0x1234,some.signal2=0x1234
 891  * cmdline options only override the bootloader values.
 892  * During development, please enable CONFIG_DEBUG_FS, and use the
 893  * signal specific entries under debugfs.
 894  */
 895 static void __init omap_mux_set_cmdline_signals(void)
 896 {
 897         char *options, *next_opt, *token;
 898
 899         if (!omap_mux_options)
 900                 return;
 901
 902         options = kstrdup(omap_mux_options, GFP_KERNEL);
 903         if (!options)
 904                 return;
 905
 906         next_opt = options;
 907
 908         while ((token = strsep(&next_opt, ",")) != NULL) {
 909                 char *keyval, *name;
 910                 u16 val;
 911
 912                 keyval = token;
 913                 name = strsep(&keyval, "=");
 914                 if (name) {
 915                         int res;
 916
 917                         res = kstrtou16(keyval, 0x10, &val);
 918                         if (res < 0)
 919                                 continue;
 920
 921                         omap_mux_init_signal(name, (u16)val);
 922                 }
 923         }
 924
 925         kfree(options);
 926 }
 927
 928 static int __init omap_mux_copy_names(struct omap_mux *src,
 929                                       struct omap_mux *dst)
 930 {
 931         int i;
 932
 933         for (i = 0; i < OMAP_MUX_NR_MODES; i++) {
 934                 if (src->muxnames[i]) {
 935                         dst->muxnames[i] = kstrdup(src->muxnames[i],
 936                                                    GFP_KERNEL);
 937                         if (!dst->muxnames[i])
 938                                 goto free;
 939                 }
 940         }
 941
 942 #ifdef CONFIG_DEBUG_FS
 943         for (i = 0; i < OMAP_MUX_NR_SIDES; i++) {
 944                 if (src->balls[i]) {
 945                         dst->balls[i] = kstrdup(src->balls[i], GFP_KERNEL);
 946                         if (!dst->balls[i])
 947                                 goto free;
 948                 }
 949         }
 950 #endif
 951
 952         return 0;
 953
 954 free:
 955         omap_mux_free_names(dst);
 956         return -ENOMEM;
 957
 958 }
 959
 960 #endif  /* CONFIG_OMAP_MUX */
 961
 962 static struct omap_mux *omap_mux_get_by_gpio(
 963                                 struct omap_mux_partition *partition,
 964                                 int gpio)
 965 {
 966         struct omap_mux_entry *e;
 967         struct omap_mux *ret = NULL;
 968
 969         list_for_each_entry(e, &partition->muxmodes, node) {
 970                 struct omap_mux *m = &e->mux;
 971                 if (m->gpio == gpio) {
 972                         ret = m;
 973                         break;
 974                 }
 975         }
 976
 977         return ret;
 978 }
 979
 980 /* Needed for dynamic muxing of GPIO pins for off-idle */
 981 u16 omap_mux_get_gpio(int gpio)
 982 {
 983         struct omap_mux_partition *partition;
 984         struct omap_mux *m = NULL;
 985
 986         list_for_each_entry(partition, &mux_partitions, node) {
 987                 m = omap_mux_get_by_gpio(partition, gpio);
 988                 if (m)
 989                         return omap_mux_read(partition, m->reg_offset);
 990         }
 991
 992         if (!m || m->reg_offset == OMAP_MUX_TERMINATOR)
 993                 pr_err("%s: Could not get gpio%i\n", __func__, gpio);
 994
 995         return OMAP_MUX_TERMINATOR;
 996 }
 997
 998 /* Needed for dynamic muxing of GPIO pins for off-idle */
 999 void omap_mux_set_gpio(u16 val, int gpio)
1000 {
1001         struct omap_mux_partition *partition;
1002         struct omap_mux *m = NULL;
1003
1004         list_for_each_entry(partition, &mux_partitions, node) {
1005                 m = omap_mux_get_by_gpio(partition, gpio);
1006                 if (m) {
1007                         omap_mux_write(partition, val, m->reg_offset);
1008                         return;
1009                 }
1010         }
1011
1012         if (!m || m->reg_offset == OMAP_MUX_TERMINATOR)
1013                 pr_err("%s: Could not set gpio%i\n", __func__, gpio);
1014 }
1015
1016 static struct omap_mux * __init omap_mux_list_add(
1017                                         struct omap_mux_partition *partition,
1018                                         struct omap_mux *src)
1019 {
1020         struct omap_mux_entry *entry;
1021         struct omap_mux *m;
1022
1023         entry = kzalloc(sizeof(struct omap_mux_entry), GFP_KERNEL);
1024         if (!entry)
1025                 return NULL;
1026
1027         m = &entry->mux;
1028         entry->mux = *src;
1029
1030 #ifdef CONFIG_OMAP_MUX
1031         if (omap_mux_copy_names(src, m)) {
1032                 kfree(entry);
1033                 return NULL;
1034         }
1035 #endif
1036
1037         mutex_lock(&muxmode_mutex);
1038         list_add_tail(&entry->node, &partition->muxmodes);
1039         mutex_unlock(&muxmode_mutex);
1040
1041         return m;
1042 }
1043
1044 /*
1045  * Note if CONFIG_OMAP_MUX is not selected, we will only initialize
1046  * the GPIO to mux offset mapping that is needed for dynamic muxing
1047  * of GPIO pins for off-idle.
1048  */
1049 static void __init omap_mux_init_list(struct omap_mux_partition *partition,
1050                                       struct omap_mux *superset)
1051 {
1052         while (superset->reg_offset !=  OMAP_MUX_TERMINATOR) {
1053                 struct omap_mux *entry;
1054
1055 #ifdef CONFIG_OMAP_MUX
1056                 if (!superset->muxnames || !superset->muxnames[0]) {
1057                         superset++;
1058                         continue;
1059                 }
1060 #else
1061                 /* Skip pins that are not muxed as GPIO by bootloader */
1062                 if (!OMAP_MODE_GPIO(partition, omap_mux_read(partition,
1063                                     superset->reg_offset))) {
1064                         superset++;
1065                         continue;
1066                 }
1067 #endif
1068
1069                 entry = omap_mux_list_add(partition, superset);
1070                 if (!entry) {
1071                         pr_err("%s: Could not add entry\n", __func__);
1072                         return;
1073                 }
1074                 superset++;
1075         }
1076 }
1077
1078 #ifdef CONFIG_OMAP_MUX
1079
1080 static void omap_mux_init_package(struct omap_mux *superset,
1081                                   struct omap_mux *package_subset,
1082                                   struct omap_ball *package_balls)
1083 {
1084         if (package_subset)
1085                 omap_mux_package_fixup(package_subset, superset);
1086         if (package_balls)
1087                 omap_mux_package_init_balls(package_balls, superset);
1088 }
1089
1090 static void __init omap_mux_init_signals(struct omap_mux_partition *partition,
1091                                          struct omap_board_mux *board_mux)
1092 {
1093         omap_mux_set_cmdline_signals();
1094         omap_mux_write_array(partition, board_mux);
1095 }
1096
1097 #else
1098
1099 static void omap_mux_init_package(struct omap_mux *superset,
1100                                   struct omap_mux *package_subset,
1101                                   struct omap_ball *package_balls)
1102 {
1103 }
1104
1105 static void __init omap_mux_init_signals(struct omap_mux_partition *partition,
1106                                          struct omap_board_mux *board_mux)
1107 {
1108 }
1109
1110 #endif
1111
1112 static u32 mux_partitions_cnt;
1113
1114 int __init omap_mux_init(const char *name, u32 flags,
1115                          u32 mux_pbase, u32 mux_size,
1116                          struct omap_mux *superset,
1117                          struct omap_mux *package_subset,
1118                          struct omap_board_mux *board_mux,
1119                          struct omap_ball *package_balls)
1120 {
1121         struct omap_mux_partition *partition;
1122
1123         partition = kzalloc(sizeof(struct omap_mux_partition), GFP_KERNEL);
1124         if (!partition)
1125                 return -ENOMEM;
1126
1127         partition->name = name;
1128         partition->flags = flags;
1129         partition->gpio = flags & OMAP_MUX_MODE7;
1130         partition->size = mux_size;
1131         partition->phys = mux_pbase;
1132         partition->base = ioremap(mux_pbase, mux_size);
1133         if (!partition->base) {
1134                 pr_err("%s: Could not ioremap mux partition at 0x%08x\n",
1135                         __func__, partition->phys);
1136                 kfree(partition);
1137                 return -ENODEV;
1138         }
1139
1140         INIT_LIST_HEAD(&partition->muxmodes);
1141
1142         list_add_tail(&partition->node, &mux_partitions);
1143         mux_partitions_cnt++;
1144         pr_info("%s: Add partition: #%d: %s, flags: %x\n", __func__,
1145                 mux_partitions_cnt, partition->name, partition->flags);
1146
1147         omap_mux_init_package(superset, package_subset, package_balls);
1148         omap_mux_init_list(partition, superset);
1149         omap_mux_init_signals(partition, board_mux);
1150
1151         return 0;
1152 }
1153