write in 30M

hc

2024-02-20 ea08eeccae9297f7aabd2ef7f0c2517ac4549acc

 kernel/drivers/irqchip/irq-gic-pm.c
..
..
@@ -1,17 +1,6 @@
1
+// SPDX-License-Identifier: GPL-2.0-only
1
2
 /*
2
3
  * Copyright (C) 2016 NVIDIA CORPORATION, All Rights Reserved.
3
- *
4
- * This program is free software; you can redistribute it and/or modify
5
- * it under the terms of the GNU General Public License version 2 as
6
- * published by the Free Software Foundation.
7
- *
8
- * This program is distributed in the hope that it will be useful,
9
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
10
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
- * GNU General Public License for more details.
12
- *
13
- * You should have received a copy of the GNU General Public License
14
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
15
4
  */
16
5
 #include <linux/module.h>
17
6
 #include <linux/clk.h>
..
..
@@ -19,7 +8,6 @@
19
8
 #include <linux/of_irq.h>
20
9
 #include <linux/irqchip/arm-gic.h>
21
10
 #include <linux/platform_device.h>
22
-#include <linux/pm_clock.h>
23
11
 #include <linux/pm_runtime.h>
24
12
 #include <linux/slab.h>
25
13
 
..
..
@@ -28,17 +16,27 @@
28
16
 	const char *const *clocks;
29
17
 };
30
18
 
19
+struct gic_chip_pm {
20
+	struct gic_chip_data *chip_data;
21
+	const struct gic_clk_data *clk_data;
22
+	struct clk_bulk_data *clks;
23
+};
24
+
31
25
 static int gic_runtime_resume(struct device *dev)
32
26
 {
33
-	struct gic_chip_data *gic = dev_get_drvdata(dev);
27
+	struct gic_chip_pm *chip_pm = dev_get_drvdata(dev);
28
+	struct gic_chip_data *gic = chip_pm->chip_data;
29
+	const struct gic_clk_data *data = chip_pm->clk_data;
34
30
 	int ret;
35
31
 
36
-	ret = pm_clk_resume(dev);
37
-	if (ret)
32
+	ret = clk_bulk_prepare_enable(data->num_clocks, chip_pm->clks);
33
+	if (ret) {
34
+		dev_err(dev, "clk_enable failed: %d\n", ret);
38
35
 		return ret;
36
+	}
39
37
 
40
38
 	/*
41
-	 * On the very first resume, the pointer to the driver data
39
+	 * On the very first resume, the pointer to chip_pm->chip_data
42
40
 	 * will be NULL and this is intentional, because we do not
43
41
 	 * want to restore the GIC on the very first resume. So if
44
42
 	 * the pointer is not valid just return.
..
..
@@ -54,35 +52,14 @@
54
52
 
55
53
 static int gic_runtime_suspend(struct device *dev)
56
54
 {
57
-	struct gic_chip_data *gic = dev_get_drvdata(dev);
55
+	struct gic_chip_pm *chip_pm = dev_get_drvdata(dev);
56
+	struct gic_chip_data *gic = chip_pm->chip_data;
57
+	const struct gic_clk_data *data = chip_pm->clk_data;
58
58
 
59
59
 	gic_dist_save(gic);
60
60
 	gic_cpu_save(gic);
61
61
 
62
-	return pm_clk_suspend(dev);
63
-}
64
-
65
-static int gic_get_clocks(struct device *dev, const struct gic_clk_data *data)
66
-{
67
-	unsigned int i;
68
-	int ret;
69
-
70
-	if (!dev || !data)
71
-		return -EINVAL;
72
-
73
-	ret = pm_clk_create(dev);
74
-	if (ret)
75
-		return ret;
76
-
77
-	for (i = 0; i < data->num_clocks; i++) {
78
-		ret = of_pm_clk_add_clk(dev, data->clocks[i]);
79
-		if (ret) {
80
-			dev_err(dev, "failed to add clock %s\n",
81
-				data->clocks[i]);
82
-			pm_clk_destroy(dev);
83
-			return ret;
84
-		}
85
-	}
62
+	clk_bulk_disable_unprepare(data->num_clocks, chip_pm->clks);
86
63
 
87
64
 	return 0;
88
65
 }
..
..
@@ -91,8 +68,8 @@
91
68
 {
92
69
 	struct device *dev = &pdev->dev;
93
70
 	const struct gic_clk_data *data;
94
-	struct gic_chip_data *gic;
95
-	int ret, irq;
71
+	struct gic_chip_pm *chip_pm;
72
+	int ret, irq, i;
96
73
 
97
74
 	data = of_device_get_match_data(&pdev->dev);
98
75
 	if (!data) {
..
..
@@ -100,27 +77,40 @@
100
77
 		return -ENODEV;
101
78
 	}
102
79
 
80
+	chip_pm = devm_kzalloc(dev, sizeof(*chip_pm), GFP_KERNEL);
81
+	if (!chip_pm)
82
+		return -ENOMEM;
83
+
103
84
 	irq = irq_of_parse_and_map(dev->of_node, 0);
104
85
 	if (!irq) {
105
86
 		dev_err(dev, "no parent interrupt found!\n");
106
87
 		return -EINVAL;
107
88
 	}
108
89
 
109
-	ret = gic_get_clocks(dev, data);
90
+	chip_pm->clks = devm_kcalloc(dev, data->num_clocks,
91
+				     sizeof(*chip_pm->clks), GFP_KERNEL);
92
+	if (!chip_pm->clks)
93
+		return -ENOMEM;
94
+
95
+	for (i = 0; i < data->num_clocks; i++)
96
+		chip_pm->clks[i].id = data->clocks[i];
97
+
98
+	ret = devm_clk_bulk_get(dev, data->num_clocks, chip_pm->clks);
110
99
 	if (ret)
111
100
 		goto irq_dispose;
112
101
 
102
+	chip_pm->clk_data = data;
103
+	dev_set_drvdata(dev, chip_pm);
104
+
113
105
 	pm_runtime_enable(dev);
114
106
 
115
-	ret = pm_runtime_get_sync(dev);
107
+	ret = pm_runtime_resume_and_get(dev);
116
108
 	if (ret < 0)
117
109
 		goto rpm_disable;
118
110
 
119
-	ret = gic_of_init_child(dev, &gic, irq);
111
+	ret = gic_of_init_child(dev, &chip_pm->chip_data, irq);
120
112
 	if (ret)
121
113
 		goto rpm_put;
122
-
123
-	platform_set_drvdata(pdev, gic);
124
114
 
125
115
 	pm_runtime_put(dev);
126
116
 
..
..
@@ -132,7 +122,6 @@
132
122
 	pm_runtime_put_sync(dev);
133
123
 rpm_disable:
134
124
 	pm_runtime_disable(dev);
135
-	pm_clk_destroy(dev);
136
125
 irq_dispose:
137
126
 	irq_dispose_mapping(irq);
138
127
 
..
..
@@ -142,6 +131,8 @@
142
131
 static const struct dev_pm_ops gic_pm_ops = {
143
132
 	SET_RUNTIME_PM_OPS(gic_runtime_suspend,
144
133
 			   gic_runtime_resume, NULL)
134
+	SET_LATE_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
135
+				     pm_runtime_force_resume)
145
136
 };
146
137
 
147
138
 static const char * const gic400_clocks[] = {