arch/arm/mach-at91/pm.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * arch/arm/mach-at91/pm.c
   4  * AT91 Power Management
   5  *
   6  * Copyright (C) 2005 David Brownell
   7  */
   8
   9 #include <linux/genalloc.h>
  10 #include <linux/io.h>
  11 #include <linux/of_address.h>
  12 #include <linux/of.h>
  13 #include <linux/of_fdt.h>
  14 #include <linux/of_platform.h>
  15 #include <linux/platform_device.h>
  16 #include <linux/parser.h>
  17 #include <linux/suspend.h>
  18
  19 #include <linux/clk.h>
  20 #include <linux/clk/at91_pmc.h>
  21 #include <linux/platform_data/atmel.h>
  22
  23 #include <asm/cacheflush.h>
  24 #include <asm/fncpy.h>
  25 #include <asm/system_misc.h>
  26 #include <asm/suspend.h>
  27
  28 #include "generic.h"
  29 #include "pm.h"
  30 #include "sam_secure.h"
  31
  32 #define BACKUP_DDR_PHY_CALIBRATION      (9)
  33
  34 /**
  35  * struct at91_pm_bu - AT91 power management backup unit data structure
  36  * @suspended: true if suspended to backup mode
  37  * @reserved: reserved
  38  * @canary: canary data for memory checking after exit from backup mode
  39  * @resume: resume API
  40  * @ddr_phy_calibration: DDR PHY calibration data: ZQ0CR0, first 8 words
  41  * of the memory
  42  */
  43 struct at91_pm_bu {
  44         int suspended;
  45         unsigned long reserved;
  46         phys_addr_t canary;
  47         phys_addr_t resume;
  48         unsigned long ddr_phy_calibration[BACKUP_DDR_PHY_CALIBRATION];
  49 };
  50
  51 /**
  52  * struct at91_pm_sfrbu_regs - registers mapping for SFRBU
  53  * @pswbu: power switch BU control registers
  54  */
  55 struct at91_pm_sfrbu_regs {
  56         struct {
  57                 u32 key;
  58                 u32 ctrl;
  59                 u32 state;
  60                 u32 softsw;
  61         } pswbu;
  62 };
  63
  64 /**
  65  * enum at91_pm_eth_clk - Ethernet clock indexes
  66  * @AT91_PM_ETH_PCLK: pclk index
  67  * @AT91_PM_ETH_HCLK: hclk index
  68  * @AT91_PM_ETH_MAX_CLK: max index
  69  */
  70 enum at91_pm_eth_clk {
  71         AT91_PM_ETH_PCLK,
  72         AT91_PM_ETH_HCLK,
  73         AT91_PM_ETH_MAX_CLK,
  74 };
  75
  76 /**
  77  * enum at91_pm_eth - Ethernet controller indexes
  78  * @AT91_PM_G_ETH: gigabit Ethernet controller index
  79  * @AT91_PM_E_ETH: megabit Ethernet controller index
  80  * @AT91_PM_MAX_ETH: max index
  81  */
  82 enum at91_pm_eth {
  83         AT91_PM_G_ETH,
  84         AT91_PM_E_ETH,
  85         AT91_PM_MAX_ETH,
  86 };
  87
  88 /**
  89  * struct at91_pm_quirk_eth - AT91 PM Ethernet quirks
  90  * @dev: Ethernet device
  91  * @np: Ethernet device node
  92  * @clks: Ethernet clocks
  93  * @modes: power management mode that this quirk applies to
  94  * @dns_modes: do not suspend modes: stop suspending if Ethernet is configured
  95  *             as wakeup source but buggy and no other wakeup source is
  96  *             available
  97  */
  98 struct at91_pm_quirk_eth {
  99         struct device *dev;
 100         struct device_node *np;
 101         struct clk_bulk_data clks[AT91_PM_ETH_MAX_CLK];
 102         u32 modes;
 103         u32 dns_modes;
 104 };
 105
 106 /**
 107  * struct at91_pm_quirks - AT91 PM quirks
 108  * @eth: Ethernet quirks
 109  */
 110 struct at91_pm_quirks {
 111         struct at91_pm_quirk_eth eth[AT91_PM_MAX_ETH];
 112 };
 113
 114 /**
 115  * struct at91_soc_pm - AT91 SoC power management data structure
 116  * @config_shdwc_ws: wakeup sources configuration function for SHDWC
 117  * @config_pmc_ws: wakeup srouces configuration function for PMC
 118  * @ws_ids: wakup sources of_device_id array
 119  * @bu: backup unit mapped data (for backup mode)
 120  * @quirks: PM quirks
 121  * @data: PM data to be used on last phase of suspend
 122  * @sfrbu_regs: SFRBU registers mapping
 123  * @memcs: memory chip select
 124  */
 125 struct at91_soc_pm {
 126         int (*config_shdwc_ws)(void __iomem *shdwc, u32 *mode, u32 *polarity);
 127         int (*config_pmc_ws)(void __iomem *pmc, u32 mode, u32 polarity);
 128         const struct of_device_id *ws_ids;
 129         struct at91_pm_bu *bu;
 130         struct at91_pm_quirks quirks;
 131         struct at91_pm_data data;
 132         struct at91_pm_sfrbu_regs sfrbu_regs;
 133         void *memcs;
 134 };
 135
 136 /**
 137  * enum at91_pm_iomaps - IOs that needs to be mapped for different PM modes
 138  * @AT91_PM_IOMAP_SHDWC:        SHDWC controller
 139  * @AT91_PM_IOMAP_SFRBU:        SFRBU controller
 140  * @AT91_PM_IOMAP_ETHC:         Ethernet controller
 141  */
 142 enum at91_pm_iomaps {
 143         AT91_PM_IOMAP_SHDWC,
 144         AT91_PM_IOMAP_SFRBU,
 145         AT91_PM_IOMAP_ETHC,
 146 };
 147
 148 #define AT91_PM_IOMAP(name)     BIT(AT91_PM_IOMAP_##name)
 149
 150 static struct at91_soc_pm soc_pm = {
 151         .data = {
 152                 .standby_mode = AT91_PM_STANDBY,
 153                 .suspend_mode = AT91_PM_ULP0,
 154         },
 155 };
 156
 157 static const match_table_t pm_modes __initconst = {
 158         { AT91_PM_STANDBY,      "standby" },
 159         { AT91_PM_ULP0,         "ulp0" },
 160         { AT91_PM_ULP0_FAST,    "ulp0-fast" },
 161         { AT91_PM_ULP1,         "ulp1" },
 162         { AT91_PM_BACKUP,       "backup" },
 163         { -1, NULL },
 164 };
 165
 166 #define at91_ramc_read(id, field) \
 167         __raw_readl(soc_pm.data.ramc[id] + field)
 168
 169 #define at91_ramc_write(id, field, value) \
 170         __raw_writel(value, soc_pm.data.ramc[id] + field)
 171
 172 static int at91_pm_valid_state(suspend_state_t state)
 173 {
 174         switch (state) {
 175                 case PM_SUSPEND_ON:
 176                 case PM_SUSPEND_STANDBY:
 177                 case PM_SUSPEND_MEM:
 178                         return 1;
 179
 180                 default:
 181                         return 0;
 182         }
 183 }
 184
 185 static int canary = 0xA5A5A5A5;
 186
 187 struct wakeup_source_info {
 188         unsigned int pmc_fsmr_bit;
 189         unsigned int shdwc_mr_bit;
 190         bool set_polarity;
 191 };
 192
 193 static const struct wakeup_source_info ws_info[] = {
 194         { .pmc_fsmr_bit = AT91_PMC_FSTT(10),    .set_polarity = true },
 195         { .pmc_fsmr_bit = AT91_PMC_RTCAL,       .shdwc_mr_bit = BIT(17) },
 196         { .pmc_fsmr_bit = AT91_PMC_USBAL },
 197         { .pmc_fsmr_bit = AT91_PMC_SDMMC_CD },
 198         { .pmc_fsmr_bit = AT91_PMC_RTTAL },
 199         { .pmc_fsmr_bit = AT91_PMC_RXLP_MCE },
 200 };
 201
 202 static const struct of_device_id sama5d2_ws_ids[] = {
 203         { .compatible = "atmel,sama5d2-gem",            .data = &ws_info[0] },
 204         { .compatible = "atmel,sama5d2-rtc",            .data = &ws_info[1] },
 205         { .compatible = "atmel,sama5d3-udc",            .data = &ws_info[2] },
 206         { .compatible = "atmel,at91rm9200-ohci",        .data = &ws_info[2] },
 207         { .compatible = "usb-ohci",                     .data = &ws_info[2] },
 208         { .compatible = "atmel,at91sam9g45-ehci",       .data = &ws_info[2] },
 209         { .compatible = "usb-ehci",                     .data = &ws_info[2] },
 210         { .compatible = "atmel,sama5d2-sdhci",          .data = &ws_info[3] },
 211         { /* sentinel */ }
 212 };
 213
 214 static const struct of_device_id sam9x60_ws_ids[] = {
 215         { .compatible = "microchip,sam9x60-rtc",        .data = &ws_info[1] },
 216         { .compatible = "atmel,at91rm9200-ohci",        .data = &ws_info[2] },
 217         { .compatible = "usb-ohci",                     .data = &ws_info[2] },
 218         { .compatible = "atmel,at91sam9g45-ehci",       .data = &ws_info[2] },
 219         { .compatible = "usb-ehci",                     .data = &ws_info[2] },
 220         { .compatible = "microchip,sam9x60-rtt",        .data = &ws_info[4] },
 221         { .compatible = "cdns,sam9x60-macb",            .data = &ws_info[5] },
 222         { /* sentinel */ }
 223 };
 224
 225 static const struct of_device_id sama7g5_ws_ids[] = {
 226         { .compatible = "microchip,sama7g5-rtc",        .data = &ws_info[1] },
 227         { .compatible = "microchip,sama7g5-ohci",       .data = &ws_info[2] },
 228         { .compatible = "usb-ohci",                     .data = &ws_info[2] },
 229         { .compatible = "atmel,at91sam9g45-ehci",       .data = &ws_info[2] },
 230         { .compatible = "usb-ehci",                     .data = &ws_info[2] },
 231         { .compatible = "microchip,sama7g5-sdhci",      .data = &ws_info[3] },
 232         { .compatible = "microchip,sama7g5-rtt",        .data = &ws_info[4] },
 233         { /* sentinel */ }
 234 };
 235
 236 static const struct of_device_id sam9x7_ws_ids[] = {
 237         { .compatible = "microchip,sam9x7-rtc",         .data = &ws_info[1] },
 238         { .compatible = "microchip,sam9x7-rtt",         .data = &ws_info[4] },
 239         { .compatible = "microchip,sam9x7-gem",         .data = &ws_info[5] },
 240         { /* sentinel */ }
 241 };
 242
 243 static int at91_pm_config_ws(unsigned int pm_mode, bool set)
 244 {
 245         const struct wakeup_source_info *wsi;
 246         const struct of_device_id *match;
 247         struct platform_device *pdev;
 248         struct device_node *np;
 249         unsigned int mode = 0, polarity = 0, val = 0;
 250
 251         if (pm_mode != AT91_PM_ULP1)
 252                 return 0;
 253
 254         if (!soc_pm.data.pmc || !soc_pm.data.shdwc || !soc_pm.ws_ids)
 255                 return -EPERM;
 256
 257         if (!set) {
 258                 writel(mode, soc_pm.data.pmc + AT91_PMC_FSMR);
 259                 return 0;
 260         }
 261
 262         if (soc_pm.config_shdwc_ws)
 263                 soc_pm.config_shdwc_ws(soc_pm.data.shdwc, &mode, &polarity);
 264
 265         /* SHDWC.MR */
 266         val = readl(soc_pm.data.shdwc + 0x04);
 267
 268         /* Loop through defined wakeup sources. */
 269         for_each_matching_node_and_match(np, soc_pm.ws_ids, &match) {
 270                 pdev = of_find_device_by_node(np);
 271                 if (!pdev)
 272                         continue;
 273
 274                 if (device_may_wakeup(&pdev->dev)) {
 275                         wsi = match->data;
 276
 277                         /* Check if enabled on SHDWC. */
 278                         if (wsi->shdwc_mr_bit && !(val & wsi->shdwc_mr_bit))
 279                                 goto put_device;
 280
 281                         mode |= wsi->pmc_fsmr_bit;
 282                         if (wsi->set_polarity)
 283                                 polarity |= wsi->pmc_fsmr_bit;
 284                 }
 285
 286 put_device:
 287                 put_device(&pdev->dev);
 288         }
 289
 290         if (mode) {
 291                 if (soc_pm.config_pmc_ws)
 292                         soc_pm.config_pmc_ws(soc_pm.data.pmc, mode, polarity);
 293         } else {
 294                 pr_err("AT91: PM: no ULP1 wakeup sources found!");
 295         }
 296
 297         return mode ? 0 : -EPERM;
 298 }
 299
 300 static int at91_sama5d2_config_shdwc_ws(void __iomem *shdwc, u32 *mode,
 301                                         u32 *polarity)
 302 {
 303         u32 val;
 304
 305         /* SHDWC.WUIR */
 306         val = readl(shdwc + 0x0c);
 307         *mode |= (val & 0x3ff);
 308         *polarity |= ((val >> 16) & 0x3ff);
 309
 310         return 0;
 311 }
 312
 313 static int at91_sama5d2_config_pmc_ws(void __iomem *pmc, u32 mode, u32 polarity)
 314 {
 315         writel(mode, pmc + AT91_PMC_FSMR);
 316         writel(polarity, pmc + AT91_PMC_FSPR);
 317
 318         return 0;
 319 }
 320
 321 static int at91_sam9x60_config_pmc_ws(void __iomem *pmc, u32 mode, u32 polarity)
 322 {
 323         writel(mode, pmc + AT91_PMC_FSMR);
 324
 325         return 0;
 326 }
 327
 328 static bool at91_pm_eth_quirk_is_valid(struct at91_pm_quirk_eth *eth)
 329 {
 330         struct platform_device *pdev;
 331
 332         /* Interface NA in DT. */
 333         if (!eth->np)
 334                 return false;
 335
 336         /* No quirks for this interface and current suspend mode. */
 337         if (!(eth->modes & BIT(soc_pm.data.mode)))
 338                 return false;
 339
 340         if (!eth->dev) {
 341                 /* Driver not probed. */
 342                 pdev = of_find_device_by_node(eth->np);
 343                 if (!pdev)
 344                         return false;
 345                 /* put_device(eth->dev) is called at the end of suspend. */
 346                 eth->dev = &pdev->dev;
 347         }
 348
 349         /* No quirks if device isn't a wakeup source. */
 350         if (!device_may_wakeup(eth->dev))
 351                 return false;
 352
 353         return true;
 354 }
 355
 356 static int at91_pm_config_quirks(bool suspend)
 357 {
 358         struct at91_pm_quirk_eth *eth;
 359         int i, j, ret, tmp;
 360
 361         /*
 362          * Ethernet IPs who's device_node pointers are stored into
 363          * soc_pm.quirks.eth[].np cannot handle WoL packets while in ULP0, ULP1
 364          * or both due to a hardware bug. If they receive WoL packets while in
 365          * ULP0 or ULP1 IPs could stop working or the whole system could stop
 366          * working. We cannot handle this scenario in the ethernet driver itself
 367          * as the driver is common to multiple vendors and also we only know
 368          * here, in this file, if we suspend to ULP0 or ULP1 mode. Thus handle
 369          * these scenarios here, as quirks.
 370          */
 371         for (i = 0; i < AT91_PM_MAX_ETH; i++) {
 372                 eth = &soc_pm.quirks.eth[i];
 373
 374                 if (!at91_pm_eth_quirk_is_valid(eth))
 375                         continue;
 376
 377                 /*
 378                  * For modes in dns_modes mask the system blocks if quirk is not
 379                  * applied but if applied the interface doesn't act at WoL
 380                  * events. Thus take care to avoid suspending if this interface
 381                  * is the only configured wakeup source.
 382                  */
 383                 if (suspend && eth->dns_modes & BIT(soc_pm.data.mode)) {
 384                         int ws_count = 0;
 385 #ifdef CONFIG_PM_SLEEP
 386                         struct wakeup_source *ws;
 387
 388                         for_each_wakeup_source(ws) {
 389                                 if (ws->dev == eth->dev)
 390                                         continue;
 391
 392                                 ws_count++;
 393                                 break;
 394                         }
 395 #endif
 396
 397                         /*
 398                          * Checking !ws is good for all platforms with issues
 399                          * even when both G_ETH and E_ETH are available as dns_modes
 400                          * is populated only on G_ETH interface.
 401                          */
 402                         if (!ws_count) {
 403                                 pr_err("AT91: PM: Ethernet cannot resume from WoL!");
 404                                 ret = -EPERM;
 405                                 put_device(eth->dev);
 406                                 eth->dev = NULL;
 407                                 /* No need to revert clock settings for this eth. */
 408                                 i--;
 409                                 goto clk_unconfigure;
 410                         }
 411                 }
 412
 413                 if (suspend) {
 414                         clk_bulk_disable_unprepare(AT91_PM_ETH_MAX_CLK, eth->clks);
 415                 } else {
 416                         ret = clk_bulk_prepare_enable(AT91_PM_ETH_MAX_CLK,
 417                                                       eth->clks);
 418                         if (ret)
 419                                 goto clk_unconfigure;
 420                         /*
 421                          * Release the reference to eth->dev taken in
 422                          * at91_pm_eth_quirk_is_valid().
 423                          */
 424                         put_device(eth->dev);
 425                         eth->dev = NULL;
 426                 }
 427         }
 428
 429         return 0;
 430
 431 clk_unconfigure:
 432         /*
 433          * In case of resume we reach this point if clk_prepare_enable() failed.
 434          * we don't want to revert the previous clk_prepare_enable() for the
 435          * other IP.
 436          */
 437         for (j = i; j >= 0; j--) {
 438                 eth = &soc_pm.quirks.eth[j];
 439                 if (suspend) {
 440                         if (!at91_pm_eth_quirk_is_valid(eth))
 441                                 continue;
 442
 443                         tmp = clk_bulk_prepare_enable(AT91_PM_ETH_MAX_CLK, eth->clks);
 444                         if (tmp) {
 445                                 pr_err("AT91: PM: failed to enable %s clocks\n",
 446                                        j == AT91_PM_G_ETH ? "geth" : "eth");
 447                         }
 448                 }
 449
 450                 /*
 451                  * Release the reference to eth->dev taken in
 452                  * at91_pm_eth_quirk_is_valid().
 453                  */
 454                 put_device(eth->dev);
 455                 eth->dev = NULL;
 456         }
 457
 458         return ret;
 459 }
 460
 461 /*
 462  * Called after processes are frozen, but before we shutdown devices.
 463  */
 464 static int at91_pm_begin(suspend_state_t state)
 465 {
 466         int ret;
 467
 468         switch (state) {
 469         case PM_SUSPEND_MEM:
 470                 soc_pm.data.mode = soc_pm.data.suspend_mode;
 471                 break;
 472
 473         case PM_SUSPEND_STANDBY:
 474                 soc_pm.data.mode = soc_pm.data.standby_mode;
 475                 break;
 476
 477         default:
 478                 soc_pm.data.mode = -1;
 479         }
 480
 481         ret = at91_pm_config_ws(soc_pm.data.mode, true);
 482         if (ret)
 483                 return ret;
 484
 485         if (soc_pm.data.mode == AT91_PM_BACKUP)
 486                 soc_pm.bu->suspended = 1;
 487         else if (soc_pm.bu)
 488                 soc_pm.bu->suspended = 0;
 489
 490         return 0;
 491 }
 492
 493 /*
 494  * Verify that all the clocks are correct before entering
 495  * slow-clock mode.
 496  */
 497 static int at91_pm_verify_clocks(void)
 498 {
 499         unsigned long scsr;
 500         int i;
 501
 502         scsr = readl(soc_pm.data.pmc + AT91_PMC_SCSR);
 503
 504         /* USB must not be using PLLB */
 505         if ((scsr & soc_pm.data.uhp_udp_mask) != 0) {
 506                 pr_err("AT91: PM - Suspend-to-RAM with USB still active\n");
 507                 return 0;
 508         }
 509
 510         /* PCK0..PCK3 must be disabled, or configured to use clk32k */
 511         for (i = 0; i < 4; i++) {
 512                 u32 css;
 513
 514                 if ((scsr & (AT91_PMC_PCK0 << i)) == 0)
 515                         continue;
 516                 css = readl(soc_pm.data.pmc + AT91_PMC_PCKR(i)) & AT91_PMC_CSS;
 517                 if (css != AT91_PMC_CSS_SLOW) {
 518                         pr_err("AT91: PM - Suspend-to-RAM with PCK%d src %d\n", i, css);
 519                         return 0;
 520                 }
 521         }
 522
 523         return 1;
 524 }
 525
 526 /*
 527  * Call this from platform driver suspend() to see how deeply to suspend.
 528  * For example, some controllers (like OHCI) need one of the PLL clocks
 529  * in order to act as a wakeup source, and those are not available when
 530  * going into slow clock mode.
 531  *
 532  * REVISIT: generalize as clk_will_be_available(clk)?  Other platforms have
 533  * the very same problem (but not using at91 main_clk), and it'd be better
 534  * to add one generic API rather than lots of platform-specific ones.
 535  */
 536 int at91_suspend_entering_slow_clock(void)
 537 {
 538         return (soc_pm.data.mode >= AT91_PM_ULP0);
 539 }
 540 EXPORT_SYMBOL(at91_suspend_entering_slow_clock);
 541
 542 static void (*at91_suspend_sram_fn)(struct at91_pm_data *);
 543 extern void at91_pm_suspend_in_sram(struct at91_pm_data *pm_data);
 544 extern u32 at91_pm_suspend_in_sram_sz;
 545
 546 static int at91_suspend_finish(unsigned long val)
 547 {
 548         unsigned char modified_gray_code[] = {
 549                 0x00, 0x01, 0x02, 0x03, 0x06, 0x07, 0x04, 0x05, 0x0c, 0x0d,
 550                 0x0e, 0x0f, 0x0a, 0x0b, 0x08, 0x09, 0x18, 0x19, 0x1a, 0x1b,
 551                 0x1e, 0x1f, 0x1c, 0x1d, 0x14, 0x15, 0x16, 0x17, 0x12, 0x13,
 552                 0x10, 0x11,
 553         };
 554         unsigned int tmp, index;
 555         int i;
 556
 557         if (soc_pm.data.mode == AT91_PM_BACKUP && soc_pm.data.ramc_phy) {
 558                 /*
 559                  * Bootloader will perform DDR recalibration and will try to
 560                  * restore the ZQ0SR0 with the value saved here. But the
 561                  * calibration is buggy and restoring some values from ZQ0SR0
 562                  * is forbidden and risky thus we need to provide processed
 563                  * values for these (modified gray code values).
 564                  */
 565                 tmp = readl(soc_pm.data.ramc_phy + DDR3PHY_ZQ0SR0);
 566
 567                 /* Store pull-down output impedance select. */
 568                 index = (tmp >> DDR3PHY_ZQ0SR0_PDO_OFF) & 0x1f;
 569                 soc_pm.bu->ddr_phy_calibration[0] = modified_gray_code[index];
 570
 571                 /* Store pull-up output impedance select. */
 572                 index = (tmp >> DDR3PHY_ZQ0SR0_PUO_OFF) & 0x1f;
 573                 soc_pm.bu->ddr_phy_calibration[0] |= modified_gray_code[index];
 574
 575                 /* Store pull-down on-die termination impedance select. */
 576                 index = (tmp >> DDR3PHY_ZQ0SR0_PDODT_OFF) & 0x1f;
 577                 soc_pm.bu->ddr_phy_calibration[0] |= modified_gray_code[index];
 578
 579                 /* Store pull-up on-die termination impedance select. */
 580                 index = (tmp >> DDR3PHY_ZQ0SRO_PUODT_OFF) & 0x1f;
 581                 soc_pm.bu->ddr_phy_calibration[0] |= modified_gray_code[index];
 582
 583                 /*
 584                  * The 1st 8 words of memory might get corrupted in the process
 585                  * of DDR PHY recalibration; it is saved here in securam and it
 586                  * will be restored later, after recalibration, by bootloader
 587                  */
 588                 for (i = 1; i < BACKUP_DDR_PHY_CALIBRATION; i++)
 589                         soc_pm.bu->ddr_phy_calibration[i] =
 590                                 *((unsigned int *)soc_pm.memcs + (i - 1));
 591         }
 592
 593         flush_cache_all();
 594         outer_disable();
 595
 596         at91_suspend_sram_fn(&soc_pm.data);
 597
 598         return 0;
 599 }
 600
 601 /**
 602  * at91_pm_switch_ba_to_auto() - Configure Backup Unit Power Switch
 603  * to automatic/hardware mode.
 604  *
 605  * The Backup Unit Power Switch can be managed either by software or hardware.
 606  * Enabling hardware mode allows the automatic transition of power between
 607  * VDDANA (or VDDIN33) and VDDBU (or VBAT, respectively), based on the
 608  * availability of these power sources.
 609  *
 610  * If the Backup Unit Power Switch is already in automatic mode, no action is
 611  * required. If it is in software-controlled mode, it is switched to automatic
 612  * mode to enhance safety and eliminate the need for toggling between power
 613  * sources.
 614  */
 615 static void at91_pm_switch_ba_to_auto(void)
 616 {
 617         unsigned int offset = offsetof(struct at91_pm_sfrbu_regs, pswbu);
 618         unsigned int val;
 619
 620         /* Just for safety. */
 621         if (!soc_pm.data.sfrbu)
 622                 return;
 623
 624         val = readl(soc_pm.data.sfrbu + offset);
 625
 626         /* Already on auto/hardware. */
 627         if (!(val & soc_pm.sfrbu_regs.pswbu.ctrl))
 628                 return;
 629
 630         val &= ~soc_pm.sfrbu_regs.pswbu.ctrl;
 631         val |= soc_pm.sfrbu_regs.pswbu.key;
 632         writel(val, soc_pm.data.sfrbu + offset);
 633 }
 634
 635 static void at91_pm_suspend(suspend_state_t state)
 636 {
 637         if (soc_pm.data.mode == AT91_PM_BACKUP) {
 638                 at91_pm_switch_ba_to_auto();
 639
 640                 cpu_suspend(0, at91_suspend_finish);
 641
 642                 /* The SRAM is lost between suspend cycles */
 643                 at91_suspend_sram_fn = fncpy(at91_suspend_sram_fn,
 644                                              &at91_pm_suspend_in_sram,
 645                                              at91_pm_suspend_in_sram_sz);
 646         } else {
 647                 at91_suspend_finish(0);
 648         }
 649
 650         outer_resume();
 651 }
 652
 653 /*
 654  * STANDBY mode has *all* drivers suspended; ignores irqs not marked as 'wakeup'
 655  * event sources; and reduces DRAM power.  But otherwise it's identical to
 656  * PM_SUSPEND_ON: cpu idle, and nothing fancy done with main or cpu clocks.
 657  *
 658  * AT91_PM_ULP0 is like STANDBY plus slow clock mode, so drivers must
 659  * suspend more deeply, the master clock switches to the clk32k and turns off
 660  * the main oscillator
 661  *
 662  * AT91_PM_BACKUP turns off the whole SoC after placing the DDR in self refresh
 663  */
 664 static int at91_pm_enter(suspend_state_t state)
 665 {
 666         int ret;
 667
 668         ret = at91_pm_config_quirks(true);
 669         if (ret)
 670                 return ret;
 671
 672         switch (state) {
 673         case PM_SUSPEND_MEM:
 674         case PM_SUSPEND_STANDBY:
 675                 /*
 676                  * Ensure that clocks are in a valid state.
 677                  */
 678                 if (soc_pm.data.mode >= AT91_PM_ULP0 &&
 679                     !at91_pm_verify_clocks())
 680                         goto error;
 681
 682                 at91_pm_suspend(state);
 683
 684                 break;
 685
 686         case PM_SUSPEND_ON:
 687                 cpu_do_idle();
 688                 break;
 689
 690         default:
 691                 pr_debug("AT91: PM - bogus suspend state %d\n", state);
 692                 goto error;
 693         }
 694
 695 error:
 696         at91_pm_config_quirks(false);
 697         return 0;
 698 }
 699
 700 /*
 701  * Called right prior to thawing processes.
 702  */
 703 static void at91_pm_end(void)
 704 {
 705         at91_pm_config_ws(soc_pm.data.mode, false);
 706 }
 707
 708
 709 static const struct platform_suspend_ops at91_pm_ops = {
 710         .valid  = at91_pm_valid_state,
 711         .begin  = at91_pm_begin,
 712         .enter  = at91_pm_enter,
 713         .end    = at91_pm_end,
 714 };
 715
 716 static struct platform_device at91_cpuidle_device = {
 717         .name = "cpuidle-at91",
 718 };
 719
 720 /*
 721  * The AT91RM9200 goes into self-refresh mode with this command, and will
 722  * terminate self-refresh automatically on the next SDRAM access.
 723  *
 724  * Self-refresh mode is exited as soon as a memory access is made, but we don't
 725  * know for sure when that happens. However, we need to restore the low-power
 726  * mode if it was enabled before going idle. Restoring low-power mode while
 727  * still in self-refresh is "not recommended", but seems to work.
 728  */
 729 static void at91rm9200_standby(void)
 730 {
 731         asm volatile(
 732                 "b    1f\n\t"
 733                 ".align    5\n\t"
 734                 "1:  mcr    p15, 0, %0, c7, c10, 4\n\t"
 735                 "    str    %2, [%1, %3]\n\t"
 736                 "    mcr    p15, 0, %0, c7, c0, 4\n\t"
 737                 :
 738                 : "r" (0), "r" (soc_pm.data.ramc[0]),
 739                   "r" (1), "r" (AT91_MC_SDRAMC_SRR));
 740 }
 741
 742 /* We manage both DDRAM/SDRAM controllers, we need more than one value to
 743  * remember.
 744  */
 745 static void at91_ddr_standby(void)
 746 {
 747         /* Those two values allow us to delay self-refresh activation
 748          * to the maximum. */
 749         u32 lpr0, lpr1 = 0;
 750         u32 mdr, saved_mdr0, saved_mdr1 = 0;
 751         u32 saved_lpr0, saved_lpr1 = 0;
 752
 753         /* LPDDR1 --> force DDR2 mode during self-refresh */
 754         saved_mdr0 = at91_ramc_read(0, AT91_DDRSDRC_MDR);
 755         if ((saved_mdr0 & AT91_DDRSDRC_MD) == AT91_DDRSDRC_MD_LOW_POWER_DDR) {
 756                 mdr = saved_mdr0 & ~AT91_DDRSDRC_MD;
 757                 mdr |= AT91_DDRSDRC_MD_DDR2;
 758                 at91_ramc_write(0, AT91_DDRSDRC_MDR, mdr);
 759         }
 760
 761         if (soc_pm.data.ramc[1]) {
 762                 saved_lpr1 = at91_ramc_read(1, AT91_DDRSDRC_LPR);
 763                 lpr1 = saved_lpr1 & ~AT91_DDRSDRC_LPCB;
 764                 lpr1 |= AT91_DDRSDRC_LPCB_SELF_REFRESH;
 765                 saved_mdr1 = at91_ramc_read(1, AT91_DDRSDRC_MDR);
 766                 if ((saved_mdr1 & AT91_DDRSDRC_MD) == AT91_DDRSDRC_MD_LOW_POWER_DDR) {
 767                         mdr = saved_mdr1 & ~AT91_DDRSDRC_MD;
 768                         mdr |= AT91_DDRSDRC_MD_DDR2;
 769                         at91_ramc_write(1, AT91_DDRSDRC_MDR, mdr);
 770                 }
 771         }
 772
 773         saved_lpr0 = at91_ramc_read(0, AT91_DDRSDRC_LPR);
 774         lpr0 = saved_lpr0 & ~AT91_DDRSDRC_LPCB;
 775         lpr0 |= AT91_DDRSDRC_LPCB_SELF_REFRESH;
 776
 777         /* self-refresh mode now */
 778         at91_ramc_write(0, AT91_DDRSDRC_LPR, lpr0);
 779         if (soc_pm.data.ramc[1])
 780                 at91_ramc_write(1, AT91_DDRSDRC_LPR, lpr1);
 781
 782         cpu_do_idle();
 783
 784         at91_ramc_write(0, AT91_DDRSDRC_MDR, saved_mdr0);
 785         at91_ramc_write(0, AT91_DDRSDRC_LPR, saved_lpr0);
 786         if (soc_pm.data.ramc[1]) {
 787                 at91_ramc_write(0, AT91_DDRSDRC_MDR, saved_mdr1);
 788                 at91_ramc_write(1, AT91_DDRSDRC_LPR, saved_lpr1);
 789         }
 790 }
 791
 792 static void sama5d3_ddr_standby(void)
 793 {
 794         u32 lpr0;
 795         u32 saved_lpr0;
 796
 797         saved_lpr0 = at91_ramc_read(0, AT91_DDRSDRC_LPR);
 798         lpr0 = saved_lpr0 & ~AT91_DDRSDRC_LPCB;
 799         lpr0 |= AT91_DDRSDRC_LPCB_POWER_DOWN;
 800
 801         at91_ramc_write(0, AT91_DDRSDRC_LPR, lpr0);
 802
 803         cpu_do_idle();
 804
 805         at91_ramc_write(0, AT91_DDRSDRC_LPR, saved_lpr0);
 806 }
 807
 808 /* We manage both DDRAM/SDRAM controllers, we need more than one value to
 809  * remember.
 810  */
 811 static void at91sam9_sdram_standby(void)
 812 {
 813         u32 lpr0, lpr1 = 0;
 814         u32 saved_lpr0, saved_lpr1 = 0;
 815
 816         if (soc_pm.data.ramc[1]) {
 817                 saved_lpr1 = at91_ramc_read(1, AT91_SDRAMC_LPR);
 818                 lpr1 = saved_lpr1 & ~AT91_SDRAMC_LPCB;
 819                 lpr1 |= AT91_SDRAMC_LPCB_SELF_REFRESH;
 820         }
 821
 822         saved_lpr0 = at91_ramc_read(0, AT91_SDRAMC_LPR);
 823         lpr0 = saved_lpr0 & ~AT91_SDRAMC_LPCB;
 824         lpr0 |= AT91_SDRAMC_LPCB_SELF_REFRESH;
 825
 826         /* self-refresh mode now */
 827         at91_ramc_write(0, AT91_SDRAMC_LPR, lpr0);
 828         if (soc_pm.data.ramc[1])
 829                 at91_ramc_write(1, AT91_SDRAMC_LPR, lpr1);
 830
 831         cpu_do_idle();
 832
 833         at91_ramc_write(0, AT91_SDRAMC_LPR, saved_lpr0);
 834         if (soc_pm.data.ramc[1])
 835                 at91_ramc_write(1, AT91_SDRAMC_LPR, saved_lpr1);
 836 }
 837
 838 static void sama7g5_standby(void)
 839 {
 840         int pwrtmg, ratio;
 841
 842         pwrtmg = readl(soc_pm.data.ramc[0] + UDDRC_PWRCTL);
 843         ratio = readl(soc_pm.data.pmc + AT91_PMC_RATIO);
 844
 845         /*
 846          * Place RAM into self-refresh after a maximum idle clocks. The maximum
 847          * idle clocks is configured by bootloader in
 848          * UDDRC_PWRMGT.SELFREF_TO_X32.
 849          */
 850         writel(pwrtmg | UDDRC_PWRCTL_SELFREF_EN,
 851                soc_pm.data.ramc[0] + UDDRC_PWRCTL);
 852         /* Divide CPU clock by 16. */
 853         writel(ratio & ~AT91_PMC_RATIO_RATIO, soc_pm.data.pmc + AT91_PMC_RATIO);
 854
 855         cpu_do_idle();
 856
 857         /* Restore previous configuration. */
 858         writel(ratio, soc_pm.data.pmc + AT91_PMC_RATIO);
 859         writel(pwrtmg, soc_pm.data.ramc[0] + UDDRC_PWRCTL);
 860 }
 861
 862 struct ramc_info {
 863         void (*idle)(void);
 864         unsigned int memctrl;
 865 };
 866
 867 static const struct ramc_info ramc_infos[] __initconst = {
 868         { .idle = at91rm9200_standby, .memctrl = AT91_MEMCTRL_MC},
 869         { .idle = at91sam9_sdram_standby, .memctrl = AT91_MEMCTRL_SDRAMC},
 870         { .idle = at91_ddr_standby, .memctrl = AT91_MEMCTRL_DDRSDR},
 871         { .idle = sama5d3_ddr_standby, .memctrl = AT91_MEMCTRL_DDRSDR},
 872         { .idle = sama7g5_standby, },
 873 };
 874
 875 static const struct of_device_id ramc_ids[] __initconst = {
 876         { .compatible = "atmel,at91rm9200-sdramc", .data = &ramc_infos[0] },
 877         { .compatible = "atmel,at91sam9260-sdramc", .data = &ramc_infos[1] },
 878         { .compatible = "atmel,at91sam9g45-ddramc", .data = &ramc_infos[2] },
 879         { .compatible = "atmel,sama5d3-ddramc", .data = &ramc_infos[3] },
 880         { .compatible = "microchip,sama7g5-uddrc", .data = &ramc_infos[4], },
 881         { /*sentinel*/ }
 882 };
 883
 884 static const struct of_device_id ramc_phy_ids[] __initconst = {
 885         { .compatible = "microchip,sama7g5-ddr3phy", },
 886         { /* Sentinel. */ },
 887 };
 888
 889 static __init int at91_dt_ramc(bool phy_mandatory)
 890 {
 891         struct device_node *np;
 892         const struct of_device_id *of_id;
 893         int idx = 0;
 894         void *standby = NULL;
 895         const struct ramc_info *ramc;
 896         int ret;
 897
 898         for_each_matching_node_and_match(np, ramc_ids, &of_id) {
 899                 soc_pm.data.ramc[idx] = of_iomap(np, 0);
 900                 if (!soc_pm.data.ramc[idx]) {
 901                         pr_err("unable to map ramc[%d] cpu registers\n", idx);
 902                         ret = -ENOMEM;
 903                         of_node_put(np);
 904                         goto unmap_ramc;
 905                 }
 906
 907                 ramc = of_id->data;
 908                 if (ramc) {
 909                         if (!standby)
 910                                 standby = ramc->idle;
 911                         soc_pm.data.memctrl = ramc->memctrl;
 912                 }
 913
 914                 idx++;
 915         }
 916
 917         if (!idx) {
 918                 pr_err("unable to find compatible ram controller node in dtb\n");
 919                 ret = -ENODEV;
 920                 goto unmap_ramc;
 921         }
 922
 923         /* Lookup for DDR PHY node, if any. */
 924         for_each_matching_node_and_match(np, ramc_phy_ids, &of_id) {
 925                 soc_pm.data.ramc_phy = of_iomap(np, 0);
 926                 if (!soc_pm.data.ramc_phy) {
 927                         pr_err("unable to map ramc phy cpu registers\n");
 928                         ret = -ENOMEM;
 929                         of_node_put(np);
 930                         goto unmap_ramc;
 931                 }
 932         }
 933
 934         if (phy_mandatory && !soc_pm.data.ramc_phy) {
 935                 pr_err("DDR PHY is mandatory!\n");
 936                 ret = -ENODEV;
 937                 goto unmap_ramc;
 938         }
 939
 940         if (!standby) {
 941                 pr_warn("ramc no standby function available\n");
 942                 return 0;
 943         }
 944
 945         at91_cpuidle_device.dev.platform_data = standby;
 946
 947         return 0;
 948
 949 unmap_ramc:
 950         while (idx)
 951                 iounmap(soc_pm.data.ramc[--idx]);
 952
 953         return ret;
 954 }
 955
 956 static void at91rm9200_idle(void)
 957 {
 958         /*
 959          * Disable the processor clock.  The processor will be automatically
 960          * re-enabled by an interrupt or by a reset.
 961          */
 962         writel(AT91_PMC_PCK, soc_pm.data.pmc + AT91_PMC_SCDR);
 963 }
 964
 965 static void at91sam9_idle(void)
 966 {
 967         writel(AT91_PMC_PCK, soc_pm.data.pmc + AT91_PMC_SCDR);
 968         cpu_do_idle();
 969 }
 970
 971 static void __init at91_pm_sram_init(void)
 972 {
 973         struct gen_pool *sram_pool;
 974         phys_addr_t sram_pbase;
 975         unsigned long sram_base;
 976         struct device_node *node;
 977         struct platform_device *pdev = NULL;
 978
 979         for_each_compatible_node(node, NULL, "mmio-sram") {
 980                 pdev = of_find_device_by_node(node);
 981                 if (pdev) {
 982                         of_node_put(node);
 983                         break;
 984                 }
 985         }
 986
 987         if (!pdev) {
 988                 pr_warn("%s: failed to find sram device!\n", __func__);
 989                 return;
 990         }
 991
 992         sram_pool = gen_pool_get(&pdev->dev, NULL);
 993         if (!sram_pool) {
 994                 pr_warn("%s: sram pool unavailable!\n", __func__);
 995                 goto out_put_device;
 996         }
 997
 998         sram_base = gen_pool_alloc(sram_pool, at91_pm_suspend_in_sram_sz);
 999         if (!sram_base) {
1000                 pr_warn("%s: unable to alloc sram!\n", __func__);
1001                 goto out_put_device;
1002         }
1003
1004         sram_pbase = gen_pool_virt_to_phys(sram_pool, sram_base);
1005         at91_suspend_sram_fn = __arm_ioremap_exec(sram_pbase,
1006                                         at91_pm_suspend_in_sram_sz, false);
1007         if (!at91_suspend_sram_fn) {
1008                 pr_warn("SRAM: Could not map\n");
1009                 goto out_put_device;
1010         }
1011
1012         /* Copy the pm suspend handler to SRAM */
1013         at91_suspend_sram_fn = fncpy(at91_suspend_sram_fn,
1014                         &at91_pm_suspend_in_sram, at91_pm_suspend_in_sram_sz);
1015         return;
1016
1017 out_put_device:
1018         put_device(&pdev->dev);
1019         return;
1020 }
1021
1022 static bool __init at91_is_pm_mode_active(int pm_mode)
1023 {
1024         return (soc_pm.data.standby_mode == pm_mode ||
1025                 soc_pm.data.suspend_mode == pm_mode);
1026 }
1027
1028 static int __init at91_pm_backup_scan_memcs(unsigned long node,
1029                                             const char *uname, int depth,
1030                                             void *data)
1031 {
1032         const char *type;
1033         const __be32 *reg;
1034         int *located = data;
1035         int size;
1036
1037         /* Memory node already located. */
1038         if (*located)
1039                 return 0;
1040
1041         type = of_get_flat_dt_prop(node, "device_type", NULL);
1042
1043         /* We are scanning "memory" nodes only. */
1044         if (!type || strcmp(type, "memory"))
1045                 return 0;
1046
1047         reg = of_get_flat_dt_prop(node, "reg", &size);
1048         if (reg) {
1049                 soc_pm.memcs = __va((phys_addr_t)be32_to_cpu(*reg));
1050                 *located = 1;
1051         }
1052
1053         return 0;
1054 }
1055
1056 static int __init at91_pm_backup_init(void)
1057 {
1058         struct gen_pool *sram_pool;
1059         struct device_node *np;
1060         struct platform_device *pdev;
1061         int ret = -ENODEV, located = 0;
1062
1063         if (!IS_ENABLED(CONFIG_SOC_SAMA5D2) &&
1064             !IS_ENABLED(CONFIG_SOC_SAMA7G5))
1065                 return -EPERM;
1066
1067         if (!at91_is_pm_mode_active(AT91_PM_BACKUP))
1068                 return 0;
1069
1070         np = of_find_compatible_node(NULL, NULL, "atmel,sama5d2-securam");
1071         if (!np)
1072                 return ret;
1073
1074         pdev = of_find_device_by_node(np);
1075         of_node_put(np);
1076         if (!pdev) {
1077                 pr_warn("%s: failed to find securam device!\n", __func__);
1078                 return ret;
1079         }
1080
1081         sram_pool = gen_pool_get(&pdev->dev, NULL);
1082         if (!sram_pool) {
1083                 pr_warn("%s: securam pool unavailable!\n", __func__);
1084                 goto securam_fail;
1085         }
1086
1087         soc_pm.bu = (void *)gen_pool_alloc(sram_pool, sizeof(struct at91_pm_bu));
1088         if (!soc_pm.bu) {
1089                 pr_warn("%s: unable to alloc securam!\n", __func__);
1090                 ret = -ENOMEM;
1091                 goto securam_fail;
1092         }
1093
1094         soc_pm.bu->suspended = 0;
1095         soc_pm.bu->canary = __pa_symbol(&canary);
1096         soc_pm.bu->resume = __pa_symbol(cpu_resume);
1097         if (soc_pm.data.ramc_phy) {
1098                 of_scan_flat_dt(at91_pm_backup_scan_memcs, &located);
1099                 if (!located)
1100                         goto securam_fail;
1101         }
1102
1103         return 0;
1104
1105 securam_fail:
1106         put_device(&pdev->dev);
1107         return ret;
1108 }
1109
1110 static void __init at91_pm_secure_init(void)
1111 {
1112         int suspend_mode;
1113         struct arm_smccc_res res;
1114
1115         suspend_mode = soc_pm.data.suspend_mode;
1116
1117         res = sam_smccc_call(SAMA5_SMC_SIP_SET_SUSPEND_MODE,
1118                              suspend_mode, 0);
1119         if (res.a0 == 0) {
1120                 pr_info("AT91: Secure PM: suspend mode set to %s\n",
1121                         pm_modes[suspend_mode].pattern);
1122                 soc_pm.data.mode = suspend_mode;
1123                 return;
1124         }
1125
1126         pr_warn("AT91: Secure PM: %s mode not supported !\n",
1127                 pm_modes[suspend_mode].pattern);
1128
1129         res = sam_smccc_call(SAMA5_SMC_SIP_GET_SUSPEND_MODE, 0, 0);
1130         if (res.a0 == 0) {
1131                 pr_warn("AT91: Secure PM: failed to get default mode\n");
1132                 soc_pm.data.mode = -1;
1133                 return;
1134         }
1135
1136         pr_info("AT91: Secure PM: using default suspend mode %s\n",
1137                 pm_modes[suspend_mode].pattern);
1138
1139         soc_pm.data.suspend_mode = res.a1;
1140         soc_pm.data.mode = soc_pm.data.suspend_mode;
1141 }
1142 static const struct of_device_id atmel_shdwc_ids[] = {
1143         { .compatible = "atmel,sama5d2-shdwc" },
1144         { .compatible = "microchip,sam9x60-shdwc" },
1145         { .compatible = "microchip,sama7g5-shdwc" },
1146         { /* sentinel. */ }
1147 };
1148
1149 static const struct of_device_id gmac_ids[] __initconst = {
1150         { .compatible = "atmel,sama5d3-gem" },
1151         { .compatible = "atmel,sama5d2-gem" },
1152         { .compatible = "atmel,sama5d29-gem" },
1153         { .compatible = "microchip,sama7g5-gem" },
1154         { },
1155 };
1156
1157 static const struct of_device_id emac_ids[] __initconst = {
1158         { .compatible = "atmel,sama5d3-macb" },
1159         { .compatible = "microchip,sama7g5-emac" },
1160         { },
1161 };
1162
1163 /*
1164  * Replaces _mode_to_replace with a supported mode that doesn't depend
1165  * on controller pointed by _map_bitmask
1166  * @_maps: u32 array containing AT91_PM_IOMAP() flags and indexed by AT91
1167  * PM mode
1168  * @_map_bitmask: AT91_PM_IOMAP() bitmask; if _mode_to_replace depends on
1169  * controller represented by _map_bitmask, _mode_to_replace needs to be
1170  * updated
1171  * @_mode_to_replace: standby_mode or suspend_mode that need to be
1172  * updated
1173  * @_mode_to_check: standby_mode or suspend_mode; this is needed here
1174  * to avoid having standby_mode and suspend_mode set with the same AT91
1175  * PM mode
1176  */
1177 #define AT91_PM_REPLACE_MODE(_maps, _map_bitmask, _mode_to_replace,     \
1178                              _mode_to_check)                            \
1179         do {                                                            \
1180                 if (((_maps)[(_mode_to_replace)]) & (_map_bitmask)) {   \
1181                         int _mode_to_use, _mode_complementary;          \
1182                         /* Use ULP0 if it doesn't need _map_bitmask. */ \
1183                         if (!((_maps)[AT91_PM_ULP0] & (_map_bitmask))) {\
1184                                 _mode_to_use = AT91_PM_ULP0;            \
1185                                 _mode_complementary = AT91_PM_STANDBY;  \
1186                         } else {                                        \
1187                                 _mode_to_use = AT91_PM_STANDBY;         \
1188                                 _mode_complementary = AT91_PM_STANDBY;  \
1189                         }                                               \
1190                                                                         \
1191                         if ((_mode_to_check) != _mode_to_use)           \
1192                                 (_mode_to_replace) = _mode_to_use;      \
1193                         else                                            \
1194                                 (_mode_to_replace) = _mode_complementary;\
1195                 }                                                       \
1196         } while (0)
1197
1198 /*
1199  * Replaces standby and suspend modes with default supported modes:
1200  * ULP0 and STANDBY.
1201  * @_maps: u32 array indexed by AT91 PM mode containing AT91_PM_IOMAP()
1202  * flags
1203  * @_map: controller specific name; standby and suspend mode need to be
1204  * replaced in order to not depend on this controller
1205  */
1206 #define AT91_PM_REPLACE_MODES(_maps, _map)                              \
1207         do {                                                            \
1208                 AT91_PM_REPLACE_MODE((_maps), BIT(AT91_PM_IOMAP_##_map),\
1209                                      (soc_pm.data.standby_mode),        \
1210                                      (soc_pm.data.suspend_mode));       \
1211                 AT91_PM_REPLACE_MODE((_maps), BIT(AT91_PM_IOMAP_##_map),\
1212                                      (soc_pm.data.suspend_mode),        \
1213                                      (soc_pm.data.standby_mode));       \
1214         } while (0)
1215
1216 static int __init at91_pm_get_eth_clks(struct device_node *np,
1217                                        struct clk_bulk_data *clks)
1218 {
1219         clks[AT91_PM_ETH_PCLK].clk = of_clk_get_by_name(np, "pclk");
1220         if (IS_ERR(clks[AT91_PM_ETH_PCLK].clk))
1221                 return PTR_ERR(clks[AT91_PM_ETH_PCLK].clk);
1222
1223         clks[AT91_PM_ETH_HCLK].clk = of_clk_get_by_name(np, "hclk");
1224         if (IS_ERR(clks[AT91_PM_ETH_HCLK].clk))
1225                 return PTR_ERR(clks[AT91_PM_ETH_HCLK].clk);
1226
1227         return 0;
1228 }
1229
1230 static int __init at91_pm_eth_clks_empty(struct clk_bulk_data *clks)
1231 {
1232         return IS_ERR(clks[AT91_PM_ETH_PCLK].clk) ||
1233                IS_ERR(clks[AT91_PM_ETH_HCLK].clk);
1234 }
1235
1236 static void __init at91_pm_modes_init(const u32 *maps, int len)
1237 {
1238         struct at91_pm_quirk_eth *gmac = &soc_pm.quirks.eth[AT91_PM_G_ETH];
1239         struct at91_pm_quirk_eth *emac = &soc_pm.quirks.eth[AT91_PM_E_ETH];
1240         struct device_node *np;
1241         int ret;
1242
1243         ret = at91_pm_backup_init();
1244         if (ret) {
1245                 if (soc_pm.data.standby_mode == AT91_PM_BACKUP)
1246                         soc_pm.data.standby_mode = AT91_PM_ULP0;
1247                 if (soc_pm.data.suspend_mode == AT91_PM_BACKUP)
1248                         soc_pm.data.suspend_mode = AT91_PM_ULP0;
1249         }
1250
1251         if (maps[soc_pm.data.standby_mode] & AT91_PM_IOMAP(SHDWC) ||
1252             maps[soc_pm.data.suspend_mode] & AT91_PM_IOMAP(SHDWC)) {
1253                 np = of_find_matching_node(NULL, atmel_shdwc_ids);
1254                 if (!np) {
1255                         pr_warn("%s: failed to find shdwc!\n", __func__);
1256                         AT91_PM_REPLACE_MODES(maps, SHDWC);
1257                 } else {
1258                         soc_pm.data.shdwc = of_iomap(np, 0);
1259                         of_node_put(np);
1260                 }
1261         }
1262
1263         if (maps[soc_pm.data.standby_mode] & AT91_PM_IOMAP(SFRBU) ||
1264             maps[soc_pm.data.suspend_mode] & AT91_PM_IOMAP(SFRBU)) {
1265                 np = of_find_compatible_node(NULL, NULL, "atmel,sama5d2-sfrbu");
1266                 if (!np) {
1267                         pr_warn("%s: failed to find sfrbu!\n", __func__);
1268                         AT91_PM_REPLACE_MODES(maps, SFRBU);
1269                 } else {
1270                         soc_pm.data.sfrbu = of_iomap(np, 0);
1271                         of_node_put(np);
1272                 }
1273         }
1274
1275         if ((at91_is_pm_mode_active(AT91_PM_ULP1) ||
1276              at91_is_pm_mode_active(AT91_PM_ULP0) ||
1277              at91_is_pm_mode_active(AT91_PM_ULP0_FAST)) &&
1278             (maps[soc_pm.data.standby_mode] & AT91_PM_IOMAP(ETHC) ||
1279              maps[soc_pm.data.suspend_mode] & AT91_PM_IOMAP(ETHC))) {
1280                 np = of_find_matching_node(NULL, gmac_ids);
1281                 if (!np) {
1282                         np = of_find_matching_node(NULL, emac_ids);
1283                         if (np)
1284                                 goto get_emac_clks;
1285                         AT91_PM_REPLACE_MODES(maps, ETHC);
1286                         goto unmap_unused_nodes;
1287                 } else {
1288                         gmac->np = np;
1289                         at91_pm_get_eth_clks(np, gmac->clks);
1290                 }
1291
1292                 np = of_find_matching_node(NULL, emac_ids);
1293                 if (!np) {
1294                         if (at91_pm_eth_clks_empty(gmac->clks))
1295                                 AT91_PM_REPLACE_MODES(maps, ETHC);
1296                 } else {
1297 get_emac_clks:
1298                         emac->np = np;
1299                         ret = at91_pm_get_eth_clks(np, emac->clks);
1300                         if (ret && at91_pm_eth_clks_empty(gmac->clks)) {
1301                                 of_node_put(gmac->np);
1302                                 of_node_put(emac->np);
1303                                 gmac->np = NULL;
1304                                 emac->np = NULL;
1305                         }
1306                 }
1307         }
1308
1309 unmap_unused_nodes:
1310         /* Unmap all unnecessary. */
1311         if (soc_pm.data.shdwc &&
1312             !(maps[soc_pm.data.standby_mode] & AT91_PM_IOMAP(SHDWC) ||
1313               maps[soc_pm.data.suspend_mode] & AT91_PM_IOMAP(SHDWC))) {
1314                 iounmap(soc_pm.data.shdwc);
1315                 soc_pm.data.shdwc = NULL;
1316         }
1317
1318         if (soc_pm.data.sfrbu &&
1319             !(maps[soc_pm.data.standby_mode] & AT91_PM_IOMAP(SFRBU) ||
1320               maps[soc_pm.data.suspend_mode] & AT91_PM_IOMAP(SFRBU))) {
1321                 iounmap(soc_pm.data.sfrbu);
1322                 soc_pm.data.sfrbu = NULL;
1323         }
1324
1325         return;
1326 }
1327
1328 struct pmc_info {
1329         unsigned long uhp_udp_mask;
1330         unsigned long mckr;
1331         unsigned long version;
1332 };
1333
1334 static const struct pmc_info pmc_infos[] __initconst = {
1335         {
1336                 .uhp_udp_mask = AT91RM9200_PMC_UHP | AT91RM9200_PMC_UDP,
1337                 .mckr = 0x30,
1338                 .version = AT91_PMC_V1,
1339         },
1340
1341         {
1342                 .uhp_udp_mask = AT91SAM926x_PMC_UHP | AT91SAM926x_PMC_UDP,
1343                 .mckr = 0x30,
1344                 .version = AT91_PMC_V1,
1345         },
1346         {
1347                 .uhp_udp_mask = AT91SAM926x_PMC_UHP,
1348                 .mckr = 0x30,
1349                 .version = AT91_PMC_V1,
1350         },
1351         {       .uhp_udp_mask = 0,
1352                 .mckr = 0x30,
1353                 .version = AT91_PMC_V1,
1354         },
1355         {
1356                 .uhp_udp_mask = AT91SAM926x_PMC_UHP | AT91SAM926x_PMC_UDP,
1357                 .mckr = 0x28,
1358                 .version = AT91_PMC_V2,
1359         },
1360         {
1361                 .mckr = 0x28,
1362                 .version = AT91_PMC_V2,
1363         },
1364
1365 };
1366
1367 static const struct of_device_id atmel_pmc_ids[] __initconst = {
1368         { .compatible = "atmel,at91rm9200-pmc", .data = &pmc_infos[0] },
1369         { .compatible = "atmel,at91sam9260-pmc", .data = &pmc_infos[1] },
1370         { .compatible = "atmel,at91sam9261-pmc", .data = &pmc_infos[1] },
1371         { .compatible = "atmel,at91sam9263-pmc", .data = &pmc_infos[1] },
1372         { .compatible = "atmel,at91sam9g45-pmc", .data = &pmc_infos[2] },
1373         { .compatible = "atmel,at91sam9n12-pmc", .data = &pmc_infos[1] },
1374         { .compatible = "atmel,at91sam9rl-pmc", .data = &pmc_infos[3] },
1375         { .compatible = "atmel,at91sam9x5-pmc", .data = &pmc_infos[1] },
1376         { .compatible = "atmel,sama5d3-pmc", .data = &pmc_infos[1] },
1377         { .compatible = "atmel,sama5d4-pmc", .data = &pmc_infos[1] },
1378         { .compatible = "atmel,sama5d2-pmc", .data = &pmc_infos[1] },
1379         { .compatible = "microchip,sam9x60-pmc", .data = &pmc_infos[4] },
1380         { .compatible = "microchip,sam9x7-pmc", .data = &pmc_infos[4] },
1381         { .compatible = "microchip,sama7g5-pmc", .data = &pmc_infos[5] },
1382         { /* sentinel */ },
1383 };
1384
1385 static void __init at91_pm_modes_validate(const int *modes, int len)
1386 {
1387         u8 i, standby = 0, suspend = 0;
1388         int mode;
1389
1390         for (i = 0; i < len; i++) {
1391                 if (standby && suspend)
1392                         break;
1393
1394                 if (modes[i] == soc_pm.data.standby_mode && !standby) {
1395                         standby = 1;
1396                         continue;
1397                 }
1398
1399                 if (modes[i] == soc_pm.data.suspend_mode && !suspend) {
1400                         suspend = 1;
1401                         continue;
1402                 }
1403         }
1404
1405         if (!standby) {
1406                 if (soc_pm.data.suspend_mode == AT91_PM_STANDBY)
1407                         mode = AT91_PM_ULP0;
1408                 else
1409                         mode = AT91_PM_STANDBY;
1410
1411                 pr_warn("AT91: PM: %s mode not supported! Using %s.\n",
1412                         pm_modes[soc_pm.data.standby_mode].pattern,
1413                         pm_modes[mode].pattern);
1414                 soc_pm.data.standby_mode = mode;
1415         }
1416
1417         if (!suspend) {
1418                 if (soc_pm.data.standby_mode == AT91_PM_ULP0)
1419                         mode = AT91_PM_STANDBY;
1420                 else
1421                         mode = AT91_PM_ULP0;
1422
1423                 pr_warn("AT91: PM: %s mode not supported! Using %s.\n",
1424                         pm_modes[soc_pm.data.suspend_mode].pattern,
1425                         pm_modes[mode].pattern);
1426                 soc_pm.data.suspend_mode = mode;
1427         }
1428 }
1429
1430 static void __init at91_pm_init(void (*pm_idle)(void))
1431 {
1432         struct device_node *pmc_np;
1433         const struct of_device_id *of_id;
1434         const struct pmc_info *pmc;
1435
1436         if (at91_cpuidle_device.dev.platform_data)
1437                 platform_device_register(&at91_cpuidle_device);
1438
1439         pmc_np = of_find_matching_node_and_match(NULL, atmel_pmc_ids, &of_id);
1440         soc_pm.data.pmc = of_iomap(pmc_np, 0);
1441         of_node_put(pmc_np);
1442         if (!soc_pm.data.pmc) {
1443                 pr_err("AT91: PM not supported, PMC not found\n");
1444                 return;
1445         }
1446
1447         pmc = of_id->data;
1448         soc_pm.data.uhp_udp_mask = pmc->uhp_udp_mask;
1449         soc_pm.data.pmc_mckr_offset = pmc->mckr;
1450         soc_pm.data.pmc_version = pmc->version;
1451
1452         if (pm_idle)
1453                 arm_pm_idle = pm_idle;
1454
1455         at91_pm_sram_init();
1456
1457         if (at91_suspend_sram_fn) {
1458                 suspend_set_ops(&at91_pm_ops);
1459                 pr_info("AT91: PM: standby: %s, suspend: %s\n",
1460                         pm_modes[soc_pm.data.standby_mode].pattern,
1461                         pm_modes[soc_pm.data.suspend_mode].pattern);
1462         } else {
1463                 pr_info("AT91: PM not supported, due to no SRAM allocated\n");
1464         }
1465 }
1466
1467 void __init at91rm9200_pm_init(void)
1468 {
1469         int ret;
1470
1471         if (!IS_ENABLED(CONFIG_SOC_AT91RM9200))
1472                 return;
1473
1474         /*
1475          * Force STANDBY and ULP0 mode to avoid calling
1476          * at91_pm_modes_validate() which may increase booting time.
1477          * Platform supports anyway only STANDBY and ULP0 modes.
1478          */
1479         soc_pm.data.standby_mode = AT91_PM_STANDBY;
1480         soc_pm.data.suspend_mode = AT91_PM_ULP0;
1481
1482         ret = at91_dt_ramc(false);
1483         if (ret)
1484                 return;
1485
1486         /*
1487          * AT91RM9200 SDRAM low-power mode cannot be used with self-refresh.
1488          */
1489         at91_ramc_write(0, AT91_MC_SDRAMC_LPR, 0);
1490
1491         at91_pm_init(at91rm9200_idle);
1492 }
1493
1494 void __init sam9x60_pm_init(void)
1495 {
1496         static const int modes[] __initconst = {
1497                 AT91_PM_STANDBY, AT91_PM_ULP0, AT91_PM_ULP0_FAST, AT91_PM_ULP1,
1498         };
1499         static const int iomaps[] __initconst = {
1500                 [AT91_PM_ULP1]          = AT91_PM_IOMAP(SHDWC),
1501         };
1502         int ret;
1503
1504         if (!IS_ENABLED(CONFIG_SOC_SAM9X60))
1505                 return;
1506
1507         at91_pm_modes_validate(modes, ARRAY_SIZE(modes));
1508         at91_pm_modes_init(iomaps, ARRAY_SIZE(iomaps));
1509         ret = at91_dt_ramc(false);
1510         if (ret)
1511                 return;
1512
1513         at91_pm_init(NULL);
1514
1515         soc_pm.ws_ids = sam9x60_ws_ids;
1516         soc_pm.config_pmc_ws = at91_sam9x60_config_pmc_ws;
1517 }
1518
1519 void __init sam9x7_pm_init(void)
1520 {
1521         static const int modes[] __initconst = {
1522                 AT91_PM_STANDBY, AT91_PM_ULP0,
1523         };
1524         int ret;
1525
1526         if (!IS_ENABLED(CONFIG_SOC_SAM9X7))
1527                 return;
1528
1529         at91_pm_modes_validate(modes, ARRAY_SIZE(modes));
1530         ret = at91_dt_ramc(false);
1531         if (ret)
1532                 return;
1533
1534         at91_pm_init(NULL);
1535
1536         soc_pm.ws_ids = sam9x7_ws_ids;
1537         soc_pm.config_pmc_ws = at91_sam9x60_config_pmc_ws;
1538 }
1539
1540 void __init at91sam9_pm_init(void)
1541 {
1542         int ret;
1543
1544         if (!IS_ENABLED(CONFIG_SOC_AT91SAM9))
1545                 return;
1546
1547         /*
1548          * Force STANDBY and ULP0 mode to avoid calling
1549          * at91_pm_modes_validate() which may increase booting time.
1550          * Platform supports anyway only STANDBY and ULP0 modes.
1551          */
1552         soc_pm.data.standby_mode = AT91_PM_STANDBY;
1553         soc_pm.data.suspend_mode = AT91_PM_ULP0;
1554
1555         ret = at91_dt_ramc(false);
1556         if (ret)
1557                 return;
1558
1559         at91_pm_init(at91sam9_idle);
1560 }
1561
1562 void __init sama5_pm_init(void)
1563 {
1564         static const int modes[] __initconst = {
1565                 AT91_PM_STANDBY, AT91_PM_ULP0, AT91_PM_ULP0_FAST,
1566         };
1567         static const u32 iomaps[] __initconst = {
1568                 [AT91_PM_ULP0]          = AT91_PM_IOMAP(ETHC),
1569                 [AT91_PM_ULP0_FAST]     = AT91_PM_IOMAP(ETHC),
1570         };
1571         int ret;
1572
1573         if (!IS_ENABLED(CONFIG_SOC_SAMA5))
1574                 return;
1575
1576         at91_pm_modes_validate(modes, ARRAY_SIZE(modes));
1577         at91_pm_modes_init(iomaps, ARRAY_SIZE(iomaps));
1578         ret = at91_dt_ramc(false);
1579         if (ret)
1580                 return;
1581
1582         at91_pm_init(NULL);
1583
1584         /* Quirks applies to ULP0, ULP0 fast and ULP1 modes. */
1585         soc_pm.quirks.eth[AT91_PM_G_ETH].modes = BIT(AT91_PM_ULP0) |
1586                                                  BIT(AT91_PM_ULP0_FAST) |
1587                                                  BIT(AT91_PM_ULP1);
1588         /* Do not suspend in ULP0, ULP0 fast if GETH is the only wakeup source. */
1589         soc_pm.quirks.eth[AT91_PM_G_ETH].dns_modes = BIT(AT91_PM_ULP0) |
1590                                                      BIT(AT91_PM_ULP0_FAST);
1591 }
1592
1593 void __init sama5d2_pm_init(void)
1594 {
1595         static const int modes[] __initconst = {
1596                 AT91_PM_STANDBY, AT91_PM_ULP0, AT91_PM_ULP0_FAST, AT91_PM_ULP1,
1597                 AT91_PM_BACKUP,
1598         };
1599         static const u32 iomaps[] __initconst = {
1600                 [AT91_PM_ULP0]          = AT91_PM_IOMAP(ETHC),
1601                 [AT91_PM_ULP0_FAST]     = AT91_PM_IOMAP(ETHC),
1602                 [AT91_PM_ULP1]          = AT91_PM_IOMAP(SHDWC) |
1603                                           AT91_PM_IOMAP(ETHC),
1604                 [AT91_PM_BACKUP]        = AT91_PM_IOMAP(SHDWC) |
1605                                           AT91_PM_IOMAP(SFRBU),
1606         };
1607         int ret;
1608
1609         if (!IS_ENABLED(CONFIG_SOC_SAMA5D2))
1610                 return;
1611
1612         if (IS_ENABLED(CONFIG_ATMEL_SECURE_PM)) {
1613                 pr_warn("AT91: Secure PM: ignoring standby mode\n");
1614                 at91_pm_secure_init();
1615                 return;
1616         }
1617
1618         at91_pm_modes_validate(modes, ARRAY_SIZE(modes));
1619         at91_pm_modes_init(iomaps, ARRAY_SIZE(iomaps));
1620         ret = at91_dt_ramc(false);
1621         if (ret)
1622                 return;
1623
1624         at91_pm_init(NULL);
1625
1626         soc_pm.ws_ids = sama5d2_ws_ids;
1627         soc_pm.config_shdwc_ws = at91_sama5d2_config_shdwc_ws;
1628         soc_pm.config_pmc_ws = at91_sama5d2_config_pmc_ws;
1629
1630         soc_pm.sfrbu_regs.pswbu.key = (0x4BD20C << 8);
1631         soc_pm.sfrbu_regs.pswbu.ctrl = BIT(0);
1632         soc_pm.sfrbu_regs.pswbu.softsw = BIT(1);
1633         soc_pm.sfrbu_regs.pswbu.state = BIT(3);
1634
1635         /* Quirk applies to ULP0, ULP0 fast and ULP1 modes. */
1636         soc_pm.quirks.eth[AT91_PM_G_ETH].modes = BIT(AT91_PM_ULP0) |
1637                                                  BIT(AT91_PM_ULP0_FAST) |
1638                                                  BIT(AT91_PM_ULP1);
1639         /*
1640          * Do not suspend in ULP0, ULP0 fast if GETH is the only wakeup
1641          * source.
1642          */
1643         soc_pm.quirks.eth[AT91_PM_G_ETH].dns_modes = BIT(AT91_PM_ULP0) |
1644                                                      BIT(AT91_PM_ULP0_FAST);
1645 }
1646
1647 void __init sama7_pm_init(void)
1648 {
1649         static const int modes[] __initconst = {
1650                 AT91_PM_STANDBY, AT91_PM_ULP0, AT91_PM_ULP1, AT91_PM_BACKUP,
1651         };
1652         static const u32 iomaps[] __initconst = {
1653                 [AT91_PM_ULP0]          = AT91_PM_IOMAP(SFRBU),
1654                 [AT91_PM_ULP1]          = AT91_PM_IOMAP(SFRBU) |
1655                                           AT91_PM_IOMAP(SHDWC) |
1656                                           AT91_PM_IOMAP(ETHC),
1657                 [AT91_PM_BACKUP]        = AT91_PM_IOMAP(SFRBU) |
1658                                           AT91_PM_IOMAP(SHDWC),
1659         };
1660         int ret;
1661
1662         if (!IS_ENABLED(CONFIG_SOC_SAMA7))
1663                 return;
1664
1665         at91_pm_modes_validate(modes, ARRAY_SIZE(modes));
1666
1667         ret = at91_dt_ramc(true);
1668         if (ret)
1669                 return;
1670
1671         at91_pm_modes_init(iomaps, ARRAY_SIZE(iomaps));
1672         at91_pm_init(NULL);
1673
1674         soc_pm.ws_ids = sama7g5_ws_ids;
1675         soc_pm.config_pmc_ws = at91_sam9x60_config_pmc_ws;
1676
1677         soc_pm.sfrbu_regs.pswbu.key = (0x4BD20C << 8);
1678         soc_pm.sfrbu_regs.pswbu.ctrl = BIT(0);
1679         soc_pm.sfrbu_regs.pswbu.softsw = BIT(1);
1680         soc_pm.sfrbu_regs.pswbu.state = BIT(2);
1681
1682         /* Quirks applies to ULP1 for both Ethernet interfaces. */
1683         soc_pm.quirks.eth[AT91_PM_E_ETH].modes = BIT(AT91_PM_ULP1);
1684         soc_pm.quirks.eth[AT91_PM_G_ETH].modes = BIT(AT91_PM_ULP1);
1685 }
1686
1687 static int __init at91_pm_modes_select(char *str)
1688 {
1689         char *s;
1690         substring_t args[MAX_OPT_ARGS];
1691         int standby, suspend;
1692
1693         if (!str)
1694                 return 0;
1695
1696         s = strsep(&str, ",");
1697         standby = match_token(s, pm_modes, args);
1698         if (standby < 0)
1699                 return 0;
1700
1701         suspend = match_token(str, pm_modes, args);
1702         if (suspend < 0)
1703                 return 0;
1704
1705         soc_pm.data.standby_mode = standby;
1706         soc_pm.data.suspend_mode = suspend;
1707
1708         return 0;
1709 }
1710 early_param("atmel.pm_modes", at91_pm_modes_select);