Quelle  keystone.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Keystone2 based boards and SOC related code.
 *
 * Copyright 2013 Texas Instruments, Inc.
 * Cyril Chemparathy <cyril@ti.com>
 * Santosh Shilimkar <santosh.shillimkar@ti.com>
 */

#include <linux/io.h>
#include <linux/dma-map-ops.h>
#include <linux/init.h>
#include <linux/pm_runtime.h>
#include <linux/pm_clock.h>
#include <linux/memblock.h>
#include <linux/of.h>
#include <linux/platform_device.h>

#include <asm/setup.h>
#include <asm/mach/map.h>
#include <asm/mach/arch.h>
#include <asm/mach/time.h>
#include <asm/page.h>

#define KEYSTONE_LOW_PHYS_START  0x80000000ULL
#define KEYSTONE_LOW_PHYS_SIZE  0x80000000ULL /* 2G */
#define KEYSTONE_LOW_PHYS_END  (KEYSTONE_LOW_PHYS_START + \
      KEYSTONE_LOW_PHYS_SIZE - 1)

#define KEYSTONE_HIGH_PHYS_START 0x800000000ULL
#define KEYSTONE_HIGH_PHYS_SIZE  0x400000000ULL /* 16G */
#define KEYSTONE_HIGH_PHYS_END  (KEYSTONE_HIGH_PHYS_START + \
      KEYSTONE_HIGH_PHYS_SIZE - 1)

static struct dev_pm_domain keystone_pm_domain = {
 .ops = {
  USE_PM_CLK_RUNTIME_OPS
  USE_PLATFORM_PM_SLEEP_OPS
 },
};

static struct pm_clk_notifier_block platform_domain_notifier = {
 .pm_domain = &keystone_pm_domain,
 .con_ids = { NULL },
};

static const struct of_device_id of_keystone_table[] = {
 {.compatible = "ti,k2hk"},
 {.compatible = "ti,k2e"},
 {.compatible = "ti,k2l"},
 { /* end of list */ },
};

static int __init keystone_pm_runtime_init(void)
{
 struct device_node *np;

 np = of_find_matching_node(NULL, of_keystone_table);
 if (!np)
  return 0;

 pm_clk_add_notifier(&platform_bus_type, &platform_domain_notifier);

 return 0;
}

#ifdef CONFIG_ARM_LPAE
static int keystone_platform_notifier(struct notifier_block *nb,
          unsigned long event, void *data)
{
 struct device *dev = data;

 if (event != BUS_NOTIFY_ADD_DEVICE)
  return NOTIFY_DONE;

 if (!dev)
  return NOTIFY_BAD;

 if (!dev->of_node) {
  int ret = dma_direct_set_offset(dev, KEYSTONE_HIGH_PHYS_START,
      KEYSTONE_LOW_PHYS_START,
      KEYSTONE_HIGH_PHYS_SIZE);
  dev_err(dev, "set dma_offset%08llx%s\n",
   KEYSTONE_HIGH_PHYS_START - KEYSTONE_LOW_PHYS_START,
   ret ? " failed" : "");
 }
 return NOTIFY_OK;
}

static struct notifier_block platform_nb = {
 .notifier_call = keystone_platform_notifier,
};
#endif /* CONFIG_ARM_LPAE */

static void __init keystone_init(void)
{
#ifdef CONFIG_ARM_LPAE
 if (PHYS_OFFSET >= KEYSTONE_HIGH_PHYS_START)
  bus_register_notifier(&platform_bus_type, &platform_nb);
#endif
 keystone_pm_runtime_init();
}

static long long __init keystone_pv_fixup(void)
{
 long long offset;
 u64 mem_start, mem_end;

 mem_start = memblock_start_of_DRAM();
 mem_end = memblock_end_of_DRAM();

 /* nothing to do if we are running out of the <32-bit space */
 if (mem_start >= KEYSTONE_LOW_PHYS_START &&
     mem_end   <= KEYSTONE_LOW_PHYS_END)
  return 0;

 if (mem_start < KEYSTONE_HIGH_PHYS_START ||
     mem_end   > KEYSTONE_HIGH_PHYS_END) {
  pr_crit("Invalid address space for memory (%08llx-%08llx)\n",
          mem_start, mem_end);
  return 0;
 }

 offset = KEYSTONE_HIGH_PHYS_START - KEYSTONE_LOW_PHYS_START;

 /* Populate the arch idmap hook */
 arch_phys_to_idmap_offset = -offset;

 return offset;
}

static const char *const keystone_match[] __initconst = {
 "ti,k2hk",
 "ti,k2e",
 "ti,k2l",
 "ti,k2g",
 "ti,keystone",
 NULL,
};

DT_MACHINE_START(KEYSTONE, "Keystone")
#if defined(CONFIG_ZONE_DMA) && defined(CONFIG_ARM_LPAE)
 .dma_zone_size = SZ_2G,
#endif
 .init_machine = keystone_init,
 .dt_compat = keystone_match,
 .pv_fixup = keystone_pv_fixup,
MACHINE_END