Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
torvalds
GitHub Repository: torvalds/linux
 Path: blob/master/arch/mips/ralink/of.c
26442 views
1
// SPDX-License-Identifier: GPL-2.0-only

2
/*

3
 *

4
 * Copyright (C) 2008 Imre Kaloz <[email protected]>

5
 * Copyright (C) 2008-2009 Gabor Juhos <[email protected]>

6
 * Copyright (C) 2013 John Crispin <[email protected]>

7
 */

8


9
#include <linux/io.h>

10
#include <linux/clk.h>

11
#include <linux/export.h>

12
#include <linux/init.h>

13
#include <linux/sizes.h>

14
#include <linux/of_fdt.h>

15
#include <linux/kernel.h>

16
#include <linux/memblock.h>

17
#include <linux/of.h>

18
#include <linux/of_address.h>

19


20
#include <asm/reboot.h>

21
#include <asm/bootinfo.h>

22
#include <asm/addrspace.h>

23
#include <asm/prom.h>

24
#include <asm/mach-ralink/ralink_regs.h>

25


26
#include "common.h"

27


28
__iomem void *rt_sysc_membase;

29
__iomem void *rt_memc_membase;

30
EXPORT_SYMBOL_GPL(rt_sysc_membase);

31


32
static const struct of_device_id mtmips_memc_match[] = {

33
	{ .compatible = "mediatek,mt7621-memc" },

34
	{ .compatible = "ralink,mt7620a-memc" },

35
	{ .compatible = "ralink,rt2880-memc" },

36
	{ .compatible = "ralink,rt3050-memc" },

37
	{ .compatible = "ralink,rt3883-memc" },

38
	{}

39
};

40


41
static const struct of_device_id mtmips_sysc_match[] = {

42
	{ .compatible = "mediatek,mt7621-sysc" },

43
	{ .compatible = "ralink,mt7620-sysc" },

44
	{ .compatible = "ralink,mt7628-sysc" },

45
	{ .compatible = "ralink,mt7688-sysc" },

46
	{ .compatible = "ralink,rt2880-sysc" },

47
	{ .compatible = "ralink,rt3050-sysc" },

48
	{ .compatible = "ralink,rt3052-sysc" },

49
	{ .compatible = "ralink,rt3352-sysc" },

50
	{ .compatible = "ralink,rt3883-sysc" },

51
	{ .compatible = "ralink,rt5350-sysc" },

52
	{}

53
};

54


55
static __iomem void *

56
mtmips_of_remap_node(const struct of_device_id *match, const char *type)

57
{

58
	struct resource res;

59
	struct device_node *np;

60


61
	np = of_find_matching_node(NULL, match);

62
	if (!np)

63
		panic("Failed to find %s controller node", type);

64


65
	if (of_address_to_resource(np, 0, &res))

66
		panic("Failed to get resource for %s node", np->name);

67


68
	if (!request_mem_region(res.start,

69
				resource_size(&res),

70
				res.name))

71
		panic("Failed to request resources for %s node", np->name);

72


73
	of_node_put(np);

74


75
	return ioremap(res.start, resource_size(&res));

76
}

77


78
void __init ralink_of_remap(void)

79
{

80
	rt_sysc_membase = mtmips_of_remap_node(mtmips_sysc_match, "system");

81
	rt_memc_membase = mtmips_of_remap_node(mtmips_memc_match, "memory");

82


83
	if (!rt_sysc_membase || !rt_memc_membase)

84
		panic("Failed to remap core resources");

85
}

86


87
void __init plat_mem_setup(void)

88
{

89
	void *dtb;

90


91
	set_io_port_base(KSEG1);

92


93
	/*

94
	 * Load the builtin devicetree. This causes the chosen node to be

95
	 * parsed resulting in our memory appearing.

96
	 */

97
	dtb = get_fdt();

98
	__dt_setup_arch(dtb);

99


100
	if (early_init_dt_scan_memory())

101
		return;

102


103
	if (soc_info.mem_detect)

104
		soc_info.mem_detect();

105
	else if (soc_info.mem_size)

106
		memblock_add(soc_info.mem_base, soc_info.mem_size * SZ_1M);

107
	else

108
		detect_memory_region(soc_info.mem_base,

109
				     soc_info.mem_size_min * SZ_1M,

110
				     soc_info.mem_size_max * SZ_1M);

111
}

112


113
static int __init plat_of_setup(void)

114
{

115
	__dt_register_buses(soc_info.compatible, "palmbus");

116


117
	return 0;

118
}

119


120
arch_initcall(plat_of_setup);

121


122