1// SPDX-License-Identifier: GPL-2.0
2/* Copyright 2018 Marty E. Plummer <hanetzer@startmail.com> */
3/* Copyright 2019 Linaro, Ltd, Rob Herring <robh@kernel.org> */
4
5#include <linux/clk.h>
6#include <linux/reset.h>
7#include <linux/platform_device.h>
8#include <linux/pm_domain.h>
9#include <linux/regulator/consumer.h>
10
11#include "panfrost_device.h"
12#include "panfrost_devfreq.h"
13#include "panfrost_features.h"
14#include "panfrost_gpu.h"
15#include "panfrost_job.h"
16#include "panfrost_mmu.h"
17#include "panfrost_perfcnt.h"
18
19static int panfrost_reset_init(struct panfrost_device *pfdev)
20{
21	int err;
22
23	pfdev->rstc = devm_reset_control_array_get(pfdev->dev, false, true);
24	if (IS_ERR(pfdev->rstc)) {
25		dev_err(pfdev->dev, "get reset failed %ld\n", PTR_ERR(pfdev->rstc));
26		return PTR_ERR(pfdev->rstc);
27	}
28
29	err = reset_control_deassert(pfdev->rstc);
30	if (err)
31		return err;
32
33	return 0;
34}
35
36static void panfrost_reset_fini(struct panfrost_device *pfdev)
37{
38	reset_control_assert(pfdev->rstc);
39}
40
41static int panfrost_clk_init(struct panfrost_device *pfdev)
42{
43	int err;
44	unsigned long rate;
45
46	pfdev->clock = devm_clk_get(pfdev->dev, NULL);
47	if (IS_ERR(pfdev->clock)) {
48		dev_err(pfdev->dev, "get clock failed %ld\n", PTR_ERR(pfdev->clock));
49		return PTR_ERR(pfdev->clock);
50	}
51
52	rate = clk_get_rate(pfdev->clock);
53	dev_info(pfdev->dev, "clock rate = %lu\n", rate);
54
55	err = clk_prepare_enable(pfdev->clock);
56	if (err)
57		return err;
58
59	pfdev->bus_clock = devm_clk_get_optional(pfdev->dev, "bus");
60	if (IS_ERR(pfdev->bus_clock)) {
61		dev_err(pfdev->dev, "get bus_clock failed %ld\n",
62			PTR_ERR(pfdev->bus_clock));
63		err = PTR_ERR(pfdev->bus_clock);
64		goto disable_clock;
65	}
66
67	if (pfdev->bus_clock) {
68		rate = clk_get_rate(pfdev->bus_clock);
69		dev_info(pfdev->dev, "bus_clock rate = %lu\n", rate);
70
71		err = clk_prepare_enable(pfdev->bus_clock);
72		if (err)
73			goto disable_clock;
74	}
75
76	return 0;
77
78disable_clock:
79	clk_disable_unprepare(pfdev->clock);
80
81	return err;
82}
83
84static void panfrost_clk_fini(struct panfrost_device *pfdev)
85{
86	clk_disable_unprepare(pfdev->bus_clock);
87	clk_disable_unprepare(pfdev->clock);
88}
89
90static int panfrost_regulator_init(struct panfrost_device *pfdev)
91{
92	int ret, i;
93
94	pfdev->regulators = devm_kcalloc(pfdev->dev, pfdev->comp->num_supplies,
95					 sizeof(*pfdev->regulators),
96					 GFP_KERNEL);
97	if (!pfdev->regulators)
98		return -ENOMEM;
99
100	for (i = 0; i < pfdev->comp->num_supplies; i++)
101		pfdev->regulators[i].supply = pfdev->comp->supply_names[i];
102
103	ret = devm_regulator_bulk_get(pfdev->dev,
104				      pfdev->comp->num_supplies,
105				      pfdev->regulators);
106	if (ret < 0) {
107		if (ret != -EPROBE_DEFER)
108			dev_err(pfdev->dev, "failed to get regulators: %d\n",
109				ret);
110		return ret;
111	}
112
113	ret = regulator_bulk_enable(pfdev->comp->num_supplies,
114				    pfdev->regulators);
115	if (ret < 0) {
116		dev_err(pfdev->dev, "failed to enable regulators: %d\n", ret);
117		return ret;
118	}
119
120	return 0;
121}
122
123static void panfrost_regulator_fini(struct panfrost_device *pfdev)
124{
125	if (!pfdev->regulators)
126		return;
127
128	regulator_bulk_disable(pfdev->comp->num_supplies, pfdev->regulators);
129}
130
131static void panfrost_pm_domain_fini(struct panfrost_device *pfdev)
132{
133	int i;
134
135	for (i = 0; i < ARRAY_SIZE(pfdev->pm_domain_devs); i++) {
136		if (!pfdev->pm_domain_devs[i])
137			break;
138
139		if (pfdev->pm_domain_links[i])
140			device_link_del(pfdev->pm_domain_links[i]);
141
142		dev_pm_domain_detach(pfdev->pm_domain_devs[i], true);
143	}
144}
145
146static int panfrost_pm_domain_init(struct panfrost_device *pfdev)
147{
148	int err;
149	int i, num_domains;
150
151	num_domains = of_count_phandle_with_args(pfdev->dev->of_node,
152						 "power-domains",
153						 "#power-domain-cells");
154
155	/*
156	 * Single domain is handled by the core, and, if only a single power
157	 * the power domain is requested, the property is optional.
158	 */
159	if (num_domains < 2 && pfdev->comp->num_pm_domains < 2)
160		return 0;
161
162	if (num_domains != pfdev->comp->num_pm_domains) {
163		dev_err(pfdev->dev,
164			"Incorrect number of power domains: %d provided, %d needed\n",
165			num_domains, pfdev->comp->num_pm_domains);
166		return -EINVAL;
167	}
168
169	if (WARN(num_domains > ARRAY_SIZE(pfdev->pm_domain_devs),
170			"Too many supplies in compatible structure.\n"))
171		return -EINVAL;
172
173	for (i = 0; i < num_domains; i++) {
174		pfdev->pm_domain_devs[i] =
175			dev_pm_domain_attach_by_name(pfdev->dev,
176					pfdev->comp->pm_domain_names[i]);
177		if (IS_ERR_OR_NULL(pfdev->pm_domain_devs[i])) {
178			err = PTR_ERR(pfdev->pm_domain_devs[i]) ? : -ENODATA;
179			pfdev->pm_domain_devs[i] = NULL;
180			dev_err(pfdev->dev,
181				"failed to get pm-domain %s(%d): %d\n",
182				pfdev->comp->pm_domain_names[i], i, err);
183			goto err;
184		}
185
186		pfdev->pm_domain_links[i] = device_link_add(pfdev->dev,
187				pfdev->pm_domain_devs[i], DL_FLAG_PM_RUNTIME |
188				DL_FLAG_STATELESS | DL_FLAG_RPM_ACTIVE);
189		if (!pfdev->pm_domain_links[i]) {
190			dev_err(pfdev->pm_domain_devs[i],
191				"adding device link failed!\n");
192			err = -ENODEV;
193			goto err;
194		}
195	}
196
197	return 0;
198
199err:
200	panfrost_pm_domain_fini(pfdev);
201	return err;
202}
203
204int panfrost_device_init(struct panfrost_device *pfdev)
205{
206	int err;
207	struct resource *res;
208
209	mutex_init(&pfdev->sched_lock);
210	INIT_LIST_HEAD(&pfdev->scheduled_jobs);
211	INIT_LIST_HEAD(&pfdev->as_lru_list);
212
213	spin_lock_init(&pfdev->as_lock);
214
215	err = panfrost_clk_init(pfdev);
216	if (err) {
217		dev_err(pfdev->dev, "clk init failed %d\n", err);
218		return err;
219	}
220
221	err = panfrost_devfreq_init(pfdev);
222	if (err) {
223		if (err != -EPROBE_DEFER)
224			dev_err(pfdev->dev, "devfreq init failed %d\n", err);
225		goto out_clk;
226	}
227
228	/* OPP will handle regulators */
229	if (!pfdev->pfdevfreq.opp_of_table_added) {
230		err = panfrost_regulator_init(pfdev);
231		if (err)
232			goto out_devfreq;
233	}
234
235	err = panfrost_reset_init(pfdev);
236	if (err) {
237		dev_err(pfdev->dev, "reset init failed %d\n", err);
238		goto out_regulator;
239	}
240
241	err = panfrost_pm_domain_init(pfdev);
242	if (err)
243		goto out_reset;
244
245	res = platform_get_resource(pfdev->pdev, IORESOURCE_MEM, 0);
246	pfdev->iomem = devm_ioremap_resource(pfdev->dev, res);
247	if (IS_ERR(pfdev->iomem)) {
248		dev_err(pfdev->dev, "failed to ioremap iomem\n");
249		err = PTR_ERR(pfdev->iomem);
250		goto out_pm_domain;
251	}
252
253	err = panfrost_gpu_init(pfdev);
254	if (err)
255		goto out_pm_domain;
256
257	err = panfrost_mmu_init(pfdev);
258	if (err)
259		goto out_gpu;
260
261	err = panfrost_job_init(pfdev);
262	if (err)
263		goto out_mmu;
264
265	err = panfrost_perfcnt_init(pfdev);
266	if (err)
267		goto out_job;
268
269	return 0;
270out_job:
271	panfrost_job_fini(pfdev);
272out_mmu:
273	panfrost_mmu_fini(pfdev);
274out_gpu:
275	panfrost_gpu_fini(pfdev);
276out_pm_domain:
277	panfrost_pm_domain_fini(pfdev);
278out_reset:
279	panfrost_reset_fini(pfdev);
280out_regulator:
281	panfrost_regulator_fini(pfdev);
282out_devfreq:
283	panfrost_devfreq_fini(pfdev);
284out_clk:
285	panfrost_clk_fini(pfdev);
286	return err;
287}
288
289void panfrost_device_fini(struct panfrost_device *pfdev)
290{
291	panfrost_perfcnt_fini(pfdev);
292	panfrost_job_fini(pfdev);
293	panfrost_mmu_fini(pfdev);
294	panfrost_gpu_fini(pfdev);
295	panfrost_pm_domain_fini(pfdev);
296	panfrost_reset_fini(pfdev);
297	panfrost_devfreq_fini(pfdev);
298	panfrost_regulator_fini(pfdev);
299	panfrost_clk_fini(pfdev);
300}
301
302const char *panfrost_exception_name(struct panfrost_device *pfdev, u32 exception_code)
303{
304	switch (exception_code) {
305		/* Non-Fault Status code */
306	case 0x00: return "NOT_STARTED/IDLE/OK";
307	case 0x01: return "DONE";
308	case 0x02: return "INTERRUPTED";
309	case 0x03: return "STOPPED";
310	case 0x04: return "TERMINATED";
311	case 0x08: return "ACTIVE";
312		/* Job exceptions */
313	case 0x40: return "JOB_CONFIG_FAULT";
314	case 0x41: return "JOB_POWER_FAULT";
315	case 0x42: return "JOB_READ_FAULT";
316	case 0x43: return "JOB_WRITE_FAULT";
317	case 0x44: return "JOB_AFFINITY_FAULT";
318	case 0x48: return "JOB_BUS_FAULT";
319	case 0x50: return "INSTR_INVALID_PC";
320	case 0x51: return "INSTR_INVALID_ENC";
321	case 0x52: return "INSTR_TYPE_MISMATCH";
322	case 0x53: return "INSTR_OPERAND_FAULT";
323	case 0x54: return "INSTR_TLS_FAULT";
324	case 0x55: return "INSTR_BARRIER_FAULT";
325	case 0x56: return "INSTR_ALIGN_FAULT";
326	case 0x58: return "DATA_INVALID_FAULT";
327	case 0x59: return "TILE_RANGE_FAULT";
328	case 0x5A: return "ADDR_RANGE_FAULT";
329	case 0x60: return "OUT_OF_MEMORY";
330		/* GPU exceptions */
331	case 0x80: return "DELAYED_BUS_FAULT";
332	case 0x88: return "SHAREABILITY_FAULT";
333		/* MMU exceptions */
334	case 0xC1: return "TRANSLATION_FAULT_LEVEL1";
335	case 0xC2: return "TRANSLATION_FAULT_LEVEL2";
336	case 0xC3: return "TRANSLATION_FAULT_LEVEL3";
337	case 0xC4: return "TRANSLATION_FAULT_LEVEL4";
338	case 0xC8: return "PERMISSION_FAULT";
339	case 0xC9 ... 0xCF: return "PERMISSION_FAULT";
340	case 0xD1: return "TRANSTAB_BUS_FAULT_LEVEL1";
341	case 0xD2: return "TRANSTAB_BUS_FAULT_LEVEL2";
342	case 0xD3: return "TRANSTAB_BUS_FAULT_LEVEL3";
343	case 0xD4: return "TRANSTAB_BUS_FAULT_LEVEL4";
344	case 0xD8: return "ACCESS_FLAG";
345	case 0xD9 ... 0xDF: return "ACCESS_FLAG";
346	case 0xE0 ... 0xE7: return "ADDRESS_SIZE_FAULT";
347	case 0xE8 ... 0xEF: return "MEMORY_ATTRIBUTES_FAULT";
348	}
349
350	return "UNKNOWN";
351}
352
353void panfrost_device_reset(struct panfrost_device *pfdev)
354{
355	panfrost_gpu_soft_reset(pfdev);
356
357	panfrost_gpu_power_on(pfdev);
358	panfrost_mmu_reset(pfdev);
359	panfrost_job_enable_interrupts(pfdev);
360}
361
362#ifdef CONFIG_PM
363int panfrost_device_resume(struct device *dev)
364{
365	struct platform_device *pdev = to_platform_device(dev);
366	struct panfrost_device *pfdev = platform_get_drvdata(pdev);
367
368	panfrost_device_reset(pfdev);
369	panfrost_devfreq_resume(pfdev);
370
371	return 0;
372}
373
374int panfrost_device_suspend(struct device *dev)
375{
376	struct platform_device *pdev = to_platform_device(dev);
377	struct panfrost_device *pfdev = platform_get_drvdata(pdev);
378
379	if (!panfrost_job_is_idle(pfdev))
380		return -EBUSY;
381
382	panfrost_devfreq_suspend(pfdev);
383	panfrost_gpu_power_off(pfdev);
384
385	return 0;
386}
387#endif
388