1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
// SPDX-License-Identifier: GPL-2.0-only
/*
* Platform device driver for Callisto.
*
* Copyright (C) 2022 Google LLC
*/
#include <linux/device.h>
#include <linux/io.h>
#include <linux/mod_devicetable.h>
#include <linux/platform_device.h>
#include "callisto-platform.h"
#include "gxp-kci.h"
#include "gxp-mcu-fs.h"
#include "gxp-uci.h"
#include "gxp-common-platform.c"
void gxp_iommu_setup_shareability(struct gxp_dev *gxp)
{
void __iomem *addr = gxp->sysreg_shareability;
if (IS_ERR_OR_NULL(addr))
return;
writel_relaxed(SHAREABLE_WRITE | SHAREABLE_READ | INNER_SHAREABLE,
addr + GXP_SYSREG_AUR0_SHAREABILITY);
writel_relaxed(SHAREABLE_WRITE | SHAREABLE_READ | INNER_SHAREABLE,
addr + GXP_SYSREG_AUR1_SHAREABILITY);
}
static int callisto_platform_parse_dt(struct platform_device *pdev,
struct gxp_dev *gxp)
{
struct resource *r;
void *addr;
struct device *dev = gxp->dev;
int ret;
u32 reg;
/*
* Setting BAAW is required for having correct base for CSR accesses.
*
* BAAW is supposed to be set by bootloader. On production we simply
* don't include the register base in DTS to skip this procedure.
*/
r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "baaw");
if (!IS_ERR_OR_NULL(r)) {
addr = devm_ioremap_resource(dev, r);
/* start address */
writel(0x0, addr + 0x0);
/* Window - size */
writel(0x8000000, addr + 0x4);
/* Window - target */
writel(0, addr + 0x8);
/* Window - enable */
writel(0x80000003, addr + 0xc);
}
if (!of_find_property(dev->of_node, "gxp,shareability", NULL)) {
ret = -ENODEV;
goto err;
}
ret = of_property_read_u32_index(dev->of_node,
"gxp,shareability", 0, ®);
if (ret)
goto err;
gxp->sysreg_shareability = devm_ioremap(dev, reg, PAGE_SIZE);
if (!gxp->sysreg_shareability)
ret = -ENOMEM;
err:
if (ret)
dev_warn(dev, "Failed to enable shareability: %d\n", ret);
return 0;
}
static int gxp_platform_probe(struct platform_device *pdev)
{
struct callisto_dev *callisto =
devm_kzalloc(&pdev->dev, sizeof(*callisto), GFP_KERNEL);
struct gxp_mcu_dev *mcu_dev = &callisto->mcu_dev;
struct gxp_dev *gxp = &mcu_dev->gxp;
if (!callisto)
return -ENOMEM;
gxp_mcu_dev_init(mcu_dev);
gxp->parse_dt = callisto_platform_parse_dt;
return gxp_common_platform_probe(pdev, gxp);
}
static int gxp_platform_remove(struct platform_device *pdev)
{
return gxp_common_platform_remove(pdev);
}
static const struct of_device_id gxp_of_match[] = {
{ .compatible = "google,gxp", },
{ .compatible = "google,gxp-zuma", },
{ /* end of list */ },
};
MODULE_DEVICE_TABLE(of, gxp_of_match);
static struct platform_driver gxp_platform_driver = {
.probe = gxp_platform_probe,
.remove = gxp_platform_remove,
.driver = {
.name = GXP_DRIVER_NAME,
.of_match_table = of_match_ptr(gxp_of_match),
#if IS_ENABLED(CONFIG_PM_SLEEP)
.pm = &gxp_pm_ops,
#endif
},
};
static int __init gxp_platform_init(void)
{
int ret;
ret = gxp_common_platform_init();
if (ret)
return ret;
return platform_driver_register(&gxp_platform_driver);
}
static void __exit gxp_platform_exit(void)
{
platform_driver_unregister(&gxp_platform_driver);
gxp_common_platform_exit();
}
MODULE_DESCRIPTION("Google GXP platform driver");
MODULE_LICENSE("GPL v2");
MODULE_INFO(gitinfo, GIT_REPO_TAG);
module_init(gxp_platform_init);
module_exit(gxp_platform_exit);
|
