2 * Copyright (C) 2013-2014 Red Hat
3 * Author: Rob Clark <robdclark@gmail.com>
5 * Copyright (c) 2014,2017 The Linux Foundation. All rights reserved.
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License version 2 as published by
9 * the Free Software Foundation.
11 * This program is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
16 * You should have received a copy of the GNU General Public License along with
17 * this program. If not, see <http://www.gnu.org/licenses/>.
20 #include <linux/pm_opp.h>
21 #include "adreno_gpu.h"
25 bool hang_debug
= false;
26 MODULE_PARM_DESC(hang_debug
, "Dump registers when hang is detected (can be slow!)");
27 module_param_named(hang_debug
, hang_debug
, bool, 0600);
29 static const struct adreno_info gpulist
[] = {
31 .rev
= ADRENO_REV(3, 0, 5, ANY_ID
),
34 .pm4fw
= "a300_pm4.fw",
35 .pfpfw
= "a300_pfp.fw",
37 .init
= a3xx_gpu_init
,
39 .rev
= ADRENO_REV(3, 0, 6, 0),
40 .revn
= 307, /* because a305c is revn==306 */
42 .pm4fw
= "a300_pm4.fw",
43 .pfpfw
= "a300_pfp.fw",
45 .init
= a3xx_gpu_init
,
47 .rev
= ADRENO_REV(3, 2, ANY_ID
, ANY_ID
),
50 .pm4fw
= "a300_pm4.fw",
51 .pfpfw
= "a300_pfp.fw",
53 .init
= a3xx_gpu_init
,
55 .rev
= ADRENO_REV(3, 3, 0, ANY_ID
),
58 .pm4fw
= "a330_pm4.fw",
59 .pfpfw
= "a330_pfp.fw",
61 .init
= a3xx_gpu_init
,
63 .rev
= ADRENO_REV(4, 2, 0, ANY_ID
),
66 .pm4fw
= "a420_pm4.fw",
67 .pfpfw
= "a420_pfp.fw",
68 .gmem
= (SZ_1M
+ SZ_512K
),
69 .init
= a4xx_gpu_init
,
71 .rev
= ADRENO_REV(4, 3, 0, ANY_ID
),
74 .pm4fw
= "a420_pm4.fw",
75 .pfpfw
= "a420_pfp.fw",
76 .gmem
= (SZ_1M
+ SZ_512K
),
77 .init
= a4xx_gpu_init
,
79 .rev
= ADRENO_REV(5, 3, 0, 2),
82 .pm4fw
= "a530_pm4.fw",
83 .pfpfw
= "a530_pfp.fw",
85 .quirks
= ADRENO_QUIRK_TWO_PASS_USE_WFI
|
86 ADRENO_QUIRK_FAULT_DETECT_MASK
,
87 .init
= a5xx_gpu_init
,
88 .gpmufw
= "a530v3_gpmu.fw2",
89 .zapfw
= "a530_zap.mdt",
93 MODULE_FIRMWARE("a300_pm4.fw");
94 MODULE_FIRMWARE("a300_pfp.fw");
95 MODULE_FIRMWARE("a330_pm4.fw");
96 MODULE_FIRMWARE("a330_pfp.fw");
97 MODULE_FIRMWARE("a420_pm4.fw");
98 MODULE_FIRMWARE("a420_pfp.fw");
99 MODULE_FIRMWARE("a530_fm4.fw");
100 MODULE_FIRMWARE("a530_pfp.fw");
102 static inline bool _rev_match(uint8_t entry
, uint8_t id
)
104 return (entry
== ANY_ID
) || (entry
== id
);
107 const struct adreno_info
*adreno_info(struct adreno_rev rev
)
112 for (i
= 0; i
< ARRAY_SIZE(gpulist
); i
++) {
113 const struct adreno_info
*info
= &gpulist
[i
];
114 if (_rev_match(info
->rev
.core
, rev
.core
) &&
115 _rev_match(info
->rev
.major
, rev
.major
) &&
116 _rev_match(info
->rev
.minor
, rev
.minor
) &&
117 _rev_match(info
->rev
.patchid
, rev
.patchid
))
124 struct msm_gpu
*adreno_load_gpu(struct drm_device
*dev
)
126 struct msm_drm_private
*priv
= dev
->dev_private
;
127 struct platform_device
*pdev
= priv
->gpu_pdev
;
128 struct msm_gpu
*gpu
= NULL
;
132 gpu
= platform_get_drvdata(pdev
);
135 dev_err_once(dev
->dev
, "no GPU device was found\n");
139 pm_runtime_get_sync(&pdev
->dev
);
140 mutex_lock(&dev
->struct_mutex
);
141 ret
= msm_gpu_hw_init(gpu
);
142 mutex_unlock(&dev
->struct_mutex
);
143 pm_runtime_put_sync(&pdev
->dev
);
145 dev_err(dev
->dev
, "gpu hw init failed: %d\n", ret
);
152 static void set_gpu_pdev(struct drm_device
*dev
,
153 struct platform_device
*pdev
)
155 struct msm_drm_private
*priv
= dev
->dev_private
;
156 priv
->gpu_pdev
= pdev
;
159 static int find_chipid(struct device
*dev
, u32
*chipid
)
161 struct device_node
*node
= dev
->of_node
;
165 /* first search the compat strings for qcom,adreno-XYZ.W: */
166 ret
= of_property_read_string_index(node
, "compatible", 0, &compat
);
170 if (sscanf(compat
, "qcom,adreno-%u.%u", &rev
, &patch
) == 2) {
172 *chipid
|= (rev
/ 100) << 24; /* core */
174 *chipid
|= (rev
/ 10) << 16; /* major */
176 *chipid
|= rev
<< 8; /* minor */
183 /* and if that fails, fall back to legacy "qcom,chipid" property: */
184 ret
= of_property_read_u32(node
, "qcom,chipid", chipid
);
188 dev_warn(dev
, "Using legacy qcom,chipid binding!\n");
189 dev_warn(dev
, "Use compatible qcom,adreno-%u%u%u.%u instead.\n",
190 (*chipid
>> 24) & 0xff, (*chipid
>> 16) & 0xff,
191 (*chipid
>> 8) & 0xff, *chipid
& 0xff);
196 /* Get legacy powerlevels from qcom,gpu-pwrlevels and populate the opp table */
197 static int adreno_get_legacy_pwrlevels(struct device
*dev
)
199 struct device_node
*child
, *node
;
202 node
= of_get_compatible_child(dev
->of_node
, "qcom,gpu-pwrlevels");
204 dev_err(dev
, "Could not find the GPU powerlevels\n");
208 for_each_child_of_node(node
, child
) {
211 ret
= of_property_read_u32(child
, "qcom,gpu-freq", &val
);
216 * Skip the intentionally bogus clock value found at the bottom
217 * of most legacy frequency tables
220 dev_pm_opp_add(dev
, val
, 0);
228 static int adreno_get_pwrlevels(struct device
*dev
,
229 struct adreno_platform_config
*config
)
231 unsigned long freq
= ULONG_MAX
;
232 struct dev_pm_opp
*opp
;
235 /* You down with OPP? */
236 if (!of_find_property(dev
->of_node
, "operating-points-v2", NULL
))
237 ret
= adreno_get_legacy_pwrlevels(dev
);
239 ret
= dev_pm_opp_of_add_table(dev
);
244 /* Find the fastest defined rate */
245 opp
= dev_pm_opp_find_freq_floor(dev
, &freq
);
247 config
->fast_rate
= dev_pm_opp_get_freq(opp
);
249 if (!config
->fast_rate
) {
251 "Could not find clock rate. Using default\n");
252 /* Pick a suitably safe clock speed for any target */
253 config
->fast_rate
= 200000000;
259 static int adreno_bind(struct device
*dev
, struct device
*master
, void *data
)
261 static struct adreno_platform_config config
= {};
262 const struct adreno_info
*info
;
263 struct drm_device
*drm
= dev_get_drvdata(master
);
268 ret
= find_chipid(dev
, &val
);
270 dev_err(dev
, "could not find chipid: %d\n", ret
);
274 config
.rev
= ADRENO_REV((val
>> 24) & 0xff,
275 (val
>> 16) & 0xff, (val
>> 8) & 0xff, val
& 0xff);
277 /* find clock rates: */
278 config
.fast_rate
= 0;
280 ret
= adreno_get_pwrlevels(dev
, &config
);
284 dev
->platform_data
= &config
;
285 set_gpu_pdev(drm
, to_platform_device(dev
));
287 info
= adreno_info(config
.rev
);
290 dev_warn(drm
->dev
, "Unknown GPU revision: %u.%u.%u.%u\n",
291 config
.rev
.core
, config
.rev
.major
,
292 config
.rev
.minor
, config
.rev
.patchid
);
296 DBG("Found GPU: %u.%u.%u.%u", config
.rev
.core
, config
.rev
.major
,
297 config
.rev
.minor
, config
.rev
.patchid
);
299 gpu
= info
->init(drm
);
301 dev_warn(drm
->dev
, "failed to load adreno gpu\n");
305 dev_set_drvdata(dev
, gpu
);
310 static void adreno_unbind(struct device
*dev
, struct device
*master
,
313 struct msm_gpu
*gpu
= dev_get_drvdata(dev
);
315 gpu
->funcs
->pm_suspend(gpu
);
316 gpu
->funcs
->destroy(gpu
);
318 set_gpu_pdev(dev_get_drvdata(master
), NULL
);
321 static const struct component_ops a3xx_ops
= {
323 .unbind
= adreno_unbind
,
326 static int adreno_probe(struct platform_device
*pdev
)
328 return component_add(&pdev
->dev
, &a3xx_ops
);
331 static int adreno_remove(struct platform_device
*pdev
)
333 component_del(&pdev
->dev
, &a3xx_ops
);
337 static const struct of_device_id dt_match
[] = {
338 { .compatible
= "qcom,adreno" },
339 { .compatible
= "qcom,adreno-3xx" },
340 /* for backwards compat w/ downstream kgsl DT files: */
341 { .compatible
= "qcom,kgsl-3d0" },
346 static int adreno_resume(struct device
*dev
)
348 struct platform_device
*pdev
= to_platform_device(dev
);
349 struct msm_gpu
*gpu
= platform_get_drvdata(pdev
);
351 return gpu
->funcs
->pm_resume(gpu
);
354 static int adreno_suspend(struct device
*dev
)
356 struct platform_device
*pdev
= to_platform_device(dev
);
357 struct msm_gpu
*gpu
= platform_get_drvdata(pdev
);
359 return gpu
->funcs
->pm_suspend(gpu
);
363 static const struct dev_pm_ops adreno_pm_ops
= {
364 SET_RUNTIME_PM_OPS(adreno_suspend
, adreno_resume
, NULL
)
367 static struct platform_driver adreno_driver
= {
368 .probe
= adreno_probe
,
369 .remove
= adreno_remove
,
372 .of_match_table
= dt_match
,
373 .pm
= &adreno_pm_ops
,
377 void __init
adreno_register(void)
379 platform_driver_register(&adreno_driver
);
382 void __exit
adreno_unregister(void)
384 platform_driver_unregister(&adreno_driver
);