| 
									
										
										
										
											2019-06-01 10:08:37 +02:00
										 |  |  | // SPDX-License-Identifier: GPL-2.0-only
 | 
					
						
							| 
									
										
										
										
											2013-06-10 11:27:13 -04:00
										 |  |  | /*
 | 
					
						
							|  |  |  |  * 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/of.h>
 | 
					
						
							| 
									
										
										
										
											2020-11-06 17:02:17 +01:00
										 |  |  | #include <linux/dma-map-ops.h>
 | 
					
						
							| 
									
										
										
										
											2013-06-10 11:27:13 -04:00
										 |  |  | #include <linux/init.h>
 | 
					
						
							|  |  |  | #include <linux/of_platform.h>
 | 
					
						
							|  |  |  | #include <linux/of_address.h>
 | 
					
						
							| 
									
										
										
										
											2014-06-05 15:22:52 -04:00
										 |  |  | #include <linux/memblock.h>
 | 
					
						
							| 
									
										
										
										
											2013-06-10 11:27:13 -04:00
										 |  |  | 
 | 
					
						
							|  |  |  | #include <asm/setup.h>
 | 
					
						
							|  |  |  | #include <asm/mach/map.h>
 | 
					
						
							|  |  |  | #include <asm/mach/arch.h>
 | 
					
						
							|  |  |  | #include <asm/mach/time.h>
 | 
					
						
							| 
									
										
										
										
											2013-06-10 12:20:17 -04:00
										 |  |  | #include <asm/smp_plat.h>
 | 
					
						
							| 
									
										
										
										
											2013-06-13 19:24:39 -04:00
										 |  |  | #include <asm/memory.h>
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | #include "memory.h"
 | 
					
						
							| 
									
										
										
										
											2013-06-10 12:20:17 -04:00
										 |  |  | 
 | 
					
						
							|  |  |  | #include "keystone.h"
 | 
					
						
							| 
									
										
										
										
											2013-06-10 11:27:13 -04:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2020-09-08 19:24:00 +02:00
										 |  |  | #ifdef CONFIG_ARM_LPAE
 | 
					
						
							| 
									
										
										
										
											2014-02-24 17:32:59 +02:00
										 |  |  | 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) { | 
					
						
							| 
									
										
										
										
											2020-09-17 18:43:40 +02:00
										 |  |  | 		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" : ""); | 
					
						
							| 
									
										
										
										
											2014-02-24 17:32:59 +02:00
										 |  |  | 	} | 
					
						
							|  |  |  | 	return NOTIFY_OK; | 
					
						
							|  |  |  | } | 
					
						
							| 
									
										
										
										
											2013-06-10 11:27:13 -04:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2015-04-04 11:30:04 +01:00
										 |  |  | static struct notifier_block platform_nb = { | 
					
						
							|  |  |  | 	.notifier_call = keystone_platform_notifier, | 
					
						
							|  |  |  | }; | 
					
						
							| 
									
										
										
										
											2020-09-08 19:24:00 +02:00
										 |  |  | #endif /* CONFIG_ARM_LPAE */
 | 
					
						
							| 
									
										
										
										
											2015-04-04 11:30:04 +01:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2013-06-10 11:27:13 -04:00
										 |  |  | static void __init keystone_init(void) | 
					
						
							|  |  |  | { | 
					
						
							| 
									
										
										
										
											2020-09-08 19:24:00 +02:00
										 |  |  | #ifdef CONFIG_ARM_LPAE
 | 
					
						
							| 
									
										
										
										
											2020-09-17 18:43:40 +02:00
										 |  |  | 	if (PHYS_OFFSET >= KEYSTONE_HIGH_PHYS_START) | 
					
						
							| 
									
										
										
										
											2014-02-24 17:32:59 +02:00
										 |  |  | 		bus_register_notifier(&platform_bus_type, &platform_nb); | 
					
						
							| 
									
										
										
										
											2020-09-08 19:24:00 +02:00
										 |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2015-04-04 11:30:04 +01:00
										 |  |  | 	keystone_pm_runtime_init(); | 
					
						
							| 
									
										
										
										
											2013-06-10 11:27:13 -04:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2015-04-04 10:01:10 +01:00
										 |  |  | static long long __init keystone_pv_fixup(void) | 
					
						
							| 
									
										
										
										
											2013-06-13 19:24:39 -04:00
										 |  |  | { | 
					
						
							| 
									
										
										
										
											2015-04-04 09:53:38 +01:00
										 |  |  | 	long long offset; | 
					
						
							| 
									
										
										
										
											2021-03-23 14:18:05 +01:00
										 |  |  | 	u64 mem_start, mem_end; | 
					
						
							| 
									
										
										
										
											2013-06-13 19:24:39 -04:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2014-06-05 15:22:52 -04:00
										 |  |  | 	mem_start = memblock_start_of_DRAM(); | 
					
						
							|  |  |  | 	mem_end = memblock_end_of_DRAM(); | 
					
						
							| 
									
										
										
										
											2013-06-13 19:24:39 -04:00
										 |  |  | 
 | 
					
						
							|  |  |  | 	/* 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) | 
					
						
							| 
									
										
										
										
											2015-04-04 09:53:38 +01:00
										 |  |  | 		return 0; | 
					
						
							| 
									
										
										
										
											2013-06-13 19:24:39 -04:00
										 |  |  | 
 | 
					
						
							|  |  |  | 	if (mem_start < KEYSTONE_HIGH_PHYS_START || | 
					
						
							|  |  |  | 	    mem_end   > KEYSTONE_HIGH_PHYS_END) { | 
					
						
							|  |  |  | 		pr_crit("Invalid address space for memory (%08llx-%08llx)\n", | 
					
						
							| 
									
										
										
										
											2021-03-23 14:18:05 +01:00
										 |  |  | 		        mem_start, mem_end); | 
					
						
							| 
									
										
										
										
											2015-04-04 09:53:38 +01:00
										 |  |  | 		return 0; | 
					
						
							| 
									
										
										
										
											2013-06-13 19:24:39 -04:00
										 |  |  | 	} | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2015-04-04 09:53:38 +01:00
										 |  |  | 	offset = KEYSTONE_HIGH_PHYS_START - KEYSTONE_LOW_PHYS_START; | 
					
						
							| 
									
										
										
										
											2013-06-13 19:24:39 -04:00
										 |  |  | 
 | 
					
						
							|  |  |  | 	/* Populate the arch idmap hook */ | 
					
						
							| 
									
										
										
										
											2016-03-15 14:55:03 +00:00
										 |  |  | 	arch_phys_to_idmap_offset = -offset; | 
					
						
							| 
									
										
										
										
											2013-06-13 19:24:39 -04:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2015-04-04 09:53:38 +01:00
										 |  |  | 	return offset; | 
					
						
							| 
									
										
										
										
											2013-06-13 19:24:39 -04:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2015-02-18 21:01:45 +01:00
										 |  |  | static const char *const keystone_match[] __initconst = { | 
					
						
							| 
									
										
										
										
											2015-10-03 17:02:56 -07:00
										 |  |  | 	"ti,k2hk", | 
					
						
							|  |  |  | 	"ti,k2e", | 
					
						
							|  |  |  | 	"ti,k2l", | 
					
						
							| 
									
										
										
										
											2016-02-05 10:37:17 -08:00
										 |  |  | 	"ti,k2g", | 
					
						
							| 
									
										
										
										
											2014-03-20 17:00:27 -04:00
										 |  |  | 	"ti,keystone", | 
					
						
							| 
									
										
										
										
											2013-06-10 11:27:13 -04:00
										 |  |  | 	NULL, | 
					
						
							|  |  |  | }; | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | DT_MACHINE_START(KEYSTONE, "Keystone") | 
					
						
							| 
									
										
										
										
											2013-11-23 16:58:03 -05:00
										 |  |  | #if defined(CONFIG_ZONE_DMA) && defined(CONFIG_ARM_LPAE)
 | 
					
						
							|  |  |  | 	.dma_zone_size	= SZ_2G, | 
					
						
							|  |  |  | #endif
 | 
					
						
							| 
									
										
										
										
											2013-06-10 12:20:17 -04:00
										 |  |  | 	.smp		= smp_ops(keystone_smp_ops), | 
					
						
							| 
									
										
										
										
											2013-06-10 11:27:13 -04:00
										 |  |  | 	.init_machine	= keystone_init, | 
					
						
							|  |  |  | 	.dt_compat	= keystone_match, | 
					
						
							| 
									
										
										
										
											2015-04-04 10:01:10 +01:00
										 |  |  | 	.pv_fixup	= keystone_pv_fixup, | 
					
						
							| 
									
										
										
										
											2013-06-10 11:27:13 -04:00
										 |  |  | MACHINE_END |