arch/arm/mach-omap2/board-n8x0.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * linux/arch/arm/mach-omap2/board-n8x0.c
   4  *
   5  * Copyright (C) 2005-2009 Nokia Corporation
   6  * Author: Juha Yrjola <juha.yrjola@nokia.com>
   7  *
   8  * Modified from mach-omap2/board-generic.c
   9  */
  10
  11 #include <linux/clk.h>
  12 #include <linux/delay.h>
  13 #include <linux/gpio.h>
  14 #include <linux/init.h>
  15 #include <linux/io.h>
  16 #include <linux/irq.h>
  17 #include <linux/stddef.h>
  18 #include <linux/i2c.h>
  19 #include <linux/spi/spi.h>
  20 #include <linux/usb/musb.h>
  21 #include <linux/mmc/host.h>
  22 #include <linux/platform_data/spi-omap2-mcspi.h>
  23 #include <linux/platform_data/mmc-omap.h>
  24 #include <linux/mfd/menelaus.h>
  25 #include <sound/tlv320aic3x.h>
  26
  27 #include <asm/mach/arch.h>
  28 #include <asm/mach-types.h>
  29
  30 #include "common.h"
  31 #include "mmc.h"
  32 #include "soc.h"
  33 #include "common-board-devices.h"
  34
  35 #define TUSB6010_ASYNC_CS       1
  36 #define TUSB6010_SYNC_CS        4
  37 #define TUSB6010_GPIO_INT       58
  38 #define TUSB6010_GPIO_ENABLE    0
  39 #define TUSB6010_DMACHAN        0x3f
  40
  41 #define NOKIA_N810_WIMAX        (1 << 2)
  42 #define NOKIA_N810              (1 << 1)
  43 #define NOKIA_N800              (1 << 0)
  44
  45 static u32 board_caps;
  46
  47 #define board_is_n800()         (board_caps & NOKIA_N800)
  48 #define board_is_n810()         (board_caps & NOKIA_N810)
  49 #define board_is_n810_wimax()   (board_caps & NOKIA_N810_WIMAX)
  50
  51 static void board_check_revision(void)
  52 {
  53         if (of_machine_is_compatible("nokia,n800"))
  54                 board_caps = NOKIA_N800;
  55         else if (of_machine_is_compatible("nokia,n810"))
  56                 board_caps = NOKIA_N810;
  57         else if (of_machine_is_compatible("nokia,n810-wimax"))
  58                 board_caps = NOKIA_N810_WIMAX;
  59
  60         if (!board_caps)
  61                 pr_err("Unknown board\n");
  62 }
  63
  64 #if IS_ENABLED(CONFIG_USB_MUSB_TUSB6010)
  65 /*
  66  * Enable or disable power to TUSB6010. When enabling, turn on 3.3 V and
  67  * 1.5 V voltage regulators of PM companion chip. Companion chip will then
  68  * provide then PGOOD signal to TUSB6010 which will release it from reset.
  69  */
  70 static int tusb_set_power(int state)
  71 {
  72         int i, retval = 0;
  73
  74         if (state) {
  75                 gpio_set_value(TUSB6010_GPIO_ENABLE, 1);
  76                 msleep(1);
  77
  78                 /* Wait until TUSB6010 pulls INT pin down */
  79                 i = 100;
  80                 while (i && gpio_get_value(TUSB6010_GPIO_INT)) {
  81                         msleep(1);
  82                         i--;
  83                 }
  84
  85                 if (!i) {
  86                         printk(KERN_ERR "tusb: powerup failed\n");
  87                         retval = -ENODEV;
  88                 }
  89         } else {
  90                 gpio_set_value(TUSB6010_GPIO_ENABLE, 0);
  91                 msleep(10);
  92         }
  93
  94         return retval;
  95 }
  96
  97 static struct musb_hdrc_config musb_config = {
  98         .multipoint     = 1,
  99         .dyn_fifo       = 1,
 100         .num_eps        = 16,
 101         .ram_bits       = 12,
 102 };
 103
 104 static struct musb_hdrc_platform_data tusb_data = {
 105         .mode           = MUSB_OTG,
 106         .set_power      = tusb_set_power,
 107         .min_power      = 25,   /* x2 = 50 mA drawn from VBUS as peripheral */
 108         .power          = 100,  /* Max 100 mA VBUS for host mode */
 109         .config         = &musb_config,
 110 };
 111
 112 static void __init n8x0_usb_init(void)
 113 {
 114         int ret = 0;
 115         static const char announce[] __initconst = KERN_INFO "TUSB 6010\n";
 116
 117         /* PM companion chip power control pin */
 118         ret = gpio_request_one(TUSB6010_GPIO_ENABLE, GPIOF_OUT_INIT_LOW,
 119                                "TUSB6010 enable");
 120         if (ret != 0) {
 121                 printk(KERN_ERR "Could not get TUSB power GPIO%i\n",
 122                        TUSB6010_GPIO_ENABLE);
 123                 return;
 124         }
 125         tusb_set_power(0);
 126
 127         ret = tusb6010_setup_interface(&tusb_data, TUSB6010_REFCLK_19, 2,
 128                                         TUSB6010_ASYNC_CS, TUSB6010_SYNC_CS,
 129                                         TUSB6010_GPIO_INT, TUSB6010_DMACHAN);
 130         if (ret != 0)
 131                 goto err;
 132
 133         printk(announce);
 134
 135         return;
 136
 137 err:
 138         gpio_free(TUSB6010_GPIO_ENABLE);
 139 }
 140 #else
 141
 142 static void __init n8x0_usb_init(void) {}
 143
 144 #endif /*CONFIG_USB_MUSB_TUSB6010 */
 145
 146
 147 static struct omap2_mcspi_device_config p54spi_mcspi_config = {
 148         .turbo_mode     = 0,
 149 };
 150
 151 static struct spi_board_info n800_spi_board_info[] __initdata = {
 152         {
 153                 .modalias       = "p54spi",
 154                 .bus_num        = 2,
 155                 .chip_select    = 0,
 156                 .max_speed_hz   = 48000000,
 157                 .controller_data = &p54spi_mcspi_config,
 158         },
 159 };
 160
 161 #if defined(CONFIG_MENELAUS) && IS_ENABLED(CONFIG_MMC_OMAP)
 162
 163 /*
 164  * On both N800 and N810, only the first of the two MMC controllers is in use.
 165  * The two MMC slots are multiplexed via Menelaus companion chip over I2C.
 166  * On N800, both slots are powered via Menelaus. On N810, only one of the
 167  * slots is powered via Menelaus. The N810 EMMC is powered via GPIO.
 168  *
 169  * VMMC                         slot 1 on both N800 and N810
 170  * VDCDC3_APE and VMCS2_APE     slot 2 on N800
 171  * GPIO23 and GPIO9             slot 2 EMMC on N810
 172  *
 173  */
 174 #define N8X0_SLOT_SWITCH_GPIO   96
 175 #define N810_EMMC_VSD_GPIO      23
 176 #define N810_EMMC_VIO_GPIO      9
 177
 178 static int slot1_cover_open;
 179 static int slot2_cover_open;
 180 static struct device *mmc_device;
 181
 182 static int n8x0_mmc_switch_slot(struct device *dev, int slot)
 183 {
 184 #ifdef CONFIG_MMC_DEBUG
 185         dev_dbg(dev, "Choose slot %d\n", slot + 1);
 186 #endif
 187         gpio_set_value(N8X0_SLOT_SWITCH_GPIO, slot);
 188         return 0;
 189 }
 190
 191 static int n8x0_mmc_set_power_menelaus(struct device *dev, int slot,
 192                                         int power_on, int vdd)
 193 {
 194         int mV;
 195
 196 #ifdef CONFIG_MMC_DEBUG
 197         dev_dbg(dev, "Set slot %d power: %s (vdd %d)\n", slot + 1,
 198                 power_on ? "on" : "off", vdd);
 199 #endif
 200         if (slot == 0) {
 201                 if (!power_on)
 202                         return menelaus_set_vmmc(0);
 203                 switch (1 << vdd) {
 204                 case MMC_VDD_33_34:
 205                 case MMC_VDD_32_33:
 206                 case MMC_VDD_31_32:
 207                         mV = 3100;
 208                         break;
 209                 case MMC_VDD_30_31:
 210                         mV = 3000;
 211                         break;
 212                 case MMC_VDD_28_29:
 213                         mV = 2800;
 214                         break;
 215                 case MMC_VDD_165_195:
 216                         mV = 1850;
 217                         break;
 218                 default:
 219                         BUG();
 220                 }
 221                 return menelaus_set_vmmc(mV);
 222         } else {
 223                 if (!power_on)
 224                         return menelaus_set_vdcdc(3, 0);
 225                 switch (1 << vdd) {
 226                 case MMC_VDD_33_34:
 227                 case MMC_VDD_32_33:
 228                         mV = 3300;
 229                         break;
 230                 case MMC_VDD_30_31:
 231                 case MMC_VDD_29_30:
 232                         mV = 3000;
 233                         break;
 234                 case MMC_VDD_28_29:
 235                 case MMC_VDD_27_28:
 236                         mV = 2800;
 237                         break;
 238                 case MMC_VDD_24_25:
 239                 case MMC_VDD_23_24:
 240                         mV = 2400;
 241                         break;
 242                 case MMC_VDD_22_23:
 243                 case MMC_VDD_21_22:
 244                         mV = 2200;
 245                         break;
 246                 case MMC_VDD_20_21:
 247                         mV = 2000;
 248                         break;
 249                 case MMC_VDD_165_195:
 250                         mV = 1800;
 251                         break;
 252                 default:
 253                         BUG();
 254                 }
 255                 return menelaus_set_vdcdc(3, mV);
 256         }
 257         return 0;
 258 }
 259
 260 static void n810_set_power_emmc(struct device *dev,
 261                                          int power_on)
 262 {
 263         dev_dbg(dev, "Set EMMC power %s\n", power_on ? "on" : "off");
 264
 265         if (power_on) {
 266                 gpio_set_value(N810_EMMC_VSD_GPIO, 1);
 267                 msleep(1);
 268                 gpio_set_value(N810_EMMC_VIO_GPIO, 1);
 269                 msleep(1);
 270         } else {
 271                 gpio_set_value(N810_EMMC_VIO_GPIO, 0);
 272                 msleep(50);
 273                 gpio_set_value(N810_EMMC_VSD_GPIO, 0);
 274                 msleep(50);
 275         }
 276 }
 277
 278 static int n8x0_mmc_set_power(struct device *dev, int slot, int power_on,
 279                               int vdd)
 280 {
 281         if (board_is_n800() || slot == 0)
 282                 return n8x0_mmc_set_power_menelaus(dev, slot, power_on, vdd);
 283
 284         n810_set_power_emmc(dev, power_on);
 285
 286         return 0;
 287 }
 288
 289 static int n8x0_mmc_set_bus_mode(struct device *dev, int slot, int bus_mode)
 290 {
 291         int r;
 292
 293         dev_dbg(dev, "Set slot %d bus mode %s\n", slot + 1,
 294                 bus_mode == MMC_BUSMODE_OPENDRAIN ? "open-drain" : "push-pull");
 295         BUG_ON(slot != 0 && slot != 1);
 296         slot++;
 297         switch (bus_mode) {
 298         case MMC_BUSMODE_OPENDRAIN:
 299                 r = menelaus_set_mmc_opendrain(slot, 1);
 300                 break;
 301         case MMC_BUSMODE_PUSHPULL:
 302                 r = menelaus_set_mmc_opendrain(slot, 0);
 303                 break;
 304         default:
 305                 BUG();
 306         }
 307         if (r != 0 && printk_ratelimit())
 308                 dev_err(dev, "MMC: unable to set bus mode for slot %d\n",
 309                         slot);
 310         return r;
 311 }
 312
 313 static int n8x0_mmc_get_cover_state(struct device *dev, int slot)
 314 {
 315         slot++;
 316         BUG_ON(slot != 1 && slot != 2);
 317         if (slot == 1)
 318                 return slot1_cover_open;
 319         else
 320                 return slot2_cover_open;
 321 }
 322
 323 static void n8x0_mmc_callback(void *data, u8 card_mask)
 324 {
 325         int bit, *openp, index;
 326
 327         if (board_is_n800()) {
 328                 bit = 1 << 1;
 329                 openp = &slot2_cover_open;
 330                 index = 1;
 331         } else {
 332                 bit = 1;
 333                 openp = &slot1_cover_open;
 334                 index = 0;
 335         }
 336
 337         if (card_mask & bit)
 338                 *openp = 1;
 339         else
 340                 *openp = 0;
 341
 342 #ifdef CONFIG_MMC_OMAP
 343         omap_mmc_notify_cover_event(mmc_device, index, *openp);
 344 #else
 345         pr_warn("MMC: notify cover event not available\n");
 346 #endif
 347 }
 348
 349 static int n8x0_mmc_late_init(struct device *dev)
 350 {
 351         int r, bit, *openp;
 352         int vs2sel;
 353
 354         mmc_device = dev;
 355
 356         r = menelaus_set_slot_sel(1);
 357         if (r < 0)
 358                 return r;
 359
 360         if (board_is_n800())
 361                 vs2sel = 0;
 362         else
 363                 vs2sel = 2;
 364
 365         r = menelaus_set_mmc_slot(2, 0, vs2sel, 1);
 366         if (r < 0)
 367                 return r;
 368
 369         n8x0_mmc_set_power(dev, 0, MMC_POWER_ON, 16); /* MMC_VDD_28_29 */
 370         n8x0_mmc_set_power(dev, 1, MMC_POWER_ON, 16);
 371
 372         r = menelaus_set_mmc_slot(1, 1, 0, 1);
 373         if (r < 0)
 374                 return r;
 375         r = menelaus_set_mmc_slot(2, 1, vs2sel, 1);
 376         if (r < 0)
 377                 return r;
 378
 379         r = menelaus_get_slot_pin_states();
 380         if (r < 0)
 381                 return r;
 382
 383         if (board_is_n800()) {
 384                 bit = 1 << 1;
 385                 openp = &slot2_cover_open;
 386         } else {
 387                 bit = 1;
 388                 openp = &slot1_cover_open;
 389                 slot2_cover_open = 0;
 390         }
 391
 392         /* All slot pin bits seem to be inversed until first switch change */
 393         if (r == 0xf || r == (0xf & ~bit))
 394                 r = ~r;
 395
 396         if (r & bit)
 397                 *openp = 1;
 398         else
 399                 *openp = 0;
 400
 401         r = menelaus_register_mmc_callback(n8x0_mmc_callback, NULL);
 402
 403         return r;
 404 }
 405
 406 static void n8x0_mmc_shutdown(struct device *dev)
 407 {
 408         int vs2sel;
 409
 410         if (board_is_n800())
 411                 vs2sel = 0;
 412         else
 413                 vs2sel = 2;
 414
 415         menelaus_set_mmc_slot(1, 0, 0, 0);
 416         menelaus_set_mmc_slot(2, 0, vs2sel, 0);
 417 }
 418
 419 static void n8x0_mmc_cleanup(struct device *dev)
 420 {
 421         menelaus_unregister_mmc_callback();
 422
 423         gpio_free(N8X0_SLOT_SWITCH_GPIO);
 424
 425         if (board_is_n810()) {
 426                 gpio_free(N810_EMMC_VSD_GPIO);
 427                 gpio_free(N810_EMMC_VIO_GPIO);
 428         }
 429 }
 430
 431 /*
 432  * MMC controller1 has two slots that are multiplexed via I2C.
 433  * MMC controller2 is not in use.
 434  */
 435 static struct omap_mmc_platform_data mmc1_data = {
 436         .nr_slots                       = 0,
 437         .switch_slot                    = n8x0_mmc_switch_slot,
 438         .init                           = n8x0_mmc_late_init,
 439         .cleanup                        = n8x0_mmc_cleanup,
 440         .shutdown                       = n8x0_mmc_shutdown,
 441         .max_freq                       = 24000000,
 442         .slots[0] = {
 443                 .wires                  = 4,
 444                 .set_power              = n8x0_mmc_set_power,
 445                 .set_bus_mode           = n8x0_mmc_set_bus_mode,
 446                 .get_cover_state        = n8x0_mmc_get_cover_state,
 447                 .ocr_mask               = MMC_VDD_165_195 | MMC_VDD_30_31 |
 448                                                 MMC_VDD_32_33   | MMC_VDD_33_34,
 449                 .name                   = "internal",
 450         },
 451         .slots[1] = {
 452                 .set_power              = n8x0_mmc_set_power,
 453                 .set_bus_mode           = n8x0_mmc_set_bus_mode,
 454                 .get_cover_state        = n8x0_mmc_get_cover_state,
 455                 .ocr_mask               = MMC_VDD_165_195 | MMC_VDD_20_21 |
 456                                                 MMC_VDD_21_22 | MMC_VDD_22_23 |
 457                                                 MMC_VDD_23_24 | MMC_VDD_24_25 |
 458                                                 MMC_VDD_27_28 | MMC_VDD_28_29 |
 459                                                 MMC_VDD_29_30 | MMC_VDD_30_31 |
 460                                                 MMC_VDD_32_33 | MMC_VDD_33_34,
 461                 .name                   = "external",
 462         },
 463 };
 464
 465 static struct omap_mmc_platform_data *mmc_data[OMAP24XX_NR_MMC];
 466
 467 static struct gpio n810_emmc_gpios[] __initdata = {
 468         { N810_EMMC_VSD_GPIO, GPIOF_OUT_INIT_LOW,  "MMC slot 2 Vddf" },
 469         { N810_EMMC_VIO_GPIO, GPIOF_OUT_INIT_LOW,  "MMC slot 2 Vdd"  },
 470 };
 471
 472 static void __init n8x0_mmc_init(void)
 473 {
 474         int err;
 475
 476         if (board_is_n810()) {
 477                 mmc1_data.slots[0].name = "external";
 478
 479                 /*
 480                  * Some Samsung Movinand chips do not like open-ended
 481                  * multi-block reads and fall to braind-dead state
 482                  * while doing so. Reducing the number of blocks in
 483                  * the transfer or delays in clock disable do not help
 484                  */
 485                 mmc1_data.slots[1].name = "internal";
 486                 mmc1_data.slots[1].ban_openended = 1;
 487         }
 488
 489         err = gpio_request_one(N8X0_SLOT_SWITCH_GPIO, GPIOF_OUT_INIT_LOW,
 490                                "MMC slot switch");
 491         if (err)
 492                 return;
 493
 494         if (board_is_n810()) {
 495                 err = gpio_request_array(n810_emmc_gpios,
 496                                          ARRAY_SIZE(n810_emmc_gpios));
 497                 if (err) {
 498                         gpio_free(N8X0_SLOT_SWITCH_GPIO);
 499                         return;
 500                 }
 501         }
 502
 503         mmc1_data.nr_slots = 2;
 504         mmc_data[0] = &mmc1_data;
 505 }
 506 #else
 507 static struct omap_mmc_platform_data mmc1_data;
 508 void __init n8x0_mmc_init(void)
 509 {
 510 }
 511 #endif  /* CONFIG_MMC_OMAP */
 512
 513 #ifdef CONFIG_MENELAUS
 514
 515 static int n8x0_auto_sleep_regulators(void)
 516 {
 517         u32 val;
 518         int ret;
 519
 520         val = EN_VPLL_SLEEP | EN_VMMC_SLEEP    \
 521                 | EN_VAUX_SLEEP | EN_VIO_SLEEP \
 522                 | EN_VMEM_SLEEP | EN_DC3_SLEEP \
 523                 | EN_VC_SLEEP | EN_DC2_SLEEP;
 524
 525         ret = menelaus_set_regulator_sleep(1, val);
 526         if (ret < 0) {
 527                 pr_err("Could not set regulators to sleep on menelaus: %u\n",
 528                        ret);
 529                 return ret;
 530         }
 531         return 0;
 532 }
 533
 534 static int n8x0_auto_voltage_scale(void)
 535 {
 536         int ret;
 537
 538         ret = menelaus_set_vcore_hw(1400, 1050);
 539         if (ret < 0) {
 540                 pr_err("Could not set VCORE voltage on menelaus: %u\n", ret);
 541                 return ret;
 542         }
 543         return 0;
 544 }
 545
 546 static int n8x0_menelaus_late_init(struct device *dev)
 547 {
 548         int ret;
 549
 550         ret = n8x0_auto_voltage_scale();
 551         if (ret < 0)
 552                 return ret;
 553         ret = n8x0_auto_sleep_regulators();
 554         if (ret < 0)
 555                 return ret;
 556         return 0;
 557 }
 558
 559 #else
 560 static int n8x0_menelaus_late_init(struct device *dev)
 561 {
 562         return 0;
 563 }
 564 #endif
 565
 566 struct menelaus_platform_data n8x0_menelaus_platform_data = {
 567         .late_init = n8x0_menelaus_late_init,
 568 };
 569
 570 struct aic3x_pdata n810_aic33_data = {
 571         .gpio_reset = 118,
 572 };
 573
 574 static int __init n8x0_late_initcall(void)
 575 {
 576         if (!board_caps)
 577                 return -ENODEV;
 578
 579         n8x0_mmc_init();
 580         n8x0_usb_init();
 581
 582         return 0;
 583 }
 584 omap_late_initcall(n8x0_late_initcall);
 585
 586 /*
 587  * Legacy init pdata init for n8x0. Note that we want to follow the
 588  * I2C bus numbering starting at 0 for device tree like other omaps.
 589  */
 590 void * __init n8x0_legacy_init(void)
 591 {
 592         board_check_revision();
 593         spi_register_board_info(n800_spi_board_info,
 594                                 ARRAY_SIZE(n800_spi_board_info));
 595         return &mmc1_data;
 596 }