1 // SPDX-License-Identifier: GPL-2.0
2 
3 /*
4  * Copyright 2016-2022 HabanaLabs, Ltd.
5  * All Rights Reserved.
6  */
7 
8 #include "goyaP.h"
9 
10 void goya_set_pll_profile(struct hl_device *hdev, enum hl_pll_frequency freq)
11 {
12 	struct goya_device *goya = hdev->asic_specific;
13 
14 	if (!hdev->pdev)
15 		return;
16 
17 	switch (freq) {
18 	case PLL_HIGH:
19 		hl_fw_set_frequency(hdev, HL_GOYA_MME_PLL, hdev->high_pll);
20 		hl_fw_set_frequency(hdev, HL_GOYA_TPC_PLL, hdev->high_pll);
21 		hl_fw_set_frequency(hdev, HL_GOYA_IC_PLL, hdev->high_pll);
22 		break;
23 	case PLL_LOW:
24 		hl_fw_set_frequency(hdev, HL_GOYA_MME_PLL, GOYA_PLL_FREQ_LOW);
25 		hl_fw_set_frequency(hdev, HL_GOYA_TPC_PLL, GOYA_PLL_FREQ_LOW);
26 		hl_fw_set_frequency(hdev, HL_GOYA_IC_PLL, GOYA_PLL_FREQ_LOW);
27 		break;
28 	case PLL_LAST:
29 		hl_fw_set_frequency(hdev, HL_GOYA_MME_PLL, goya->mme_clk);
30 		hl_fw_set_frequency(hdev, HL_GOYA_TPC_PLL, goya->tpc_clk);
31 		hl_fw_set_frequency(hdev, HL_GOYA_IC_PLL, goya->ic_clk);
32 		break;
33 	default:
34 		dev_err(hdev->dev, "unknown frequency setting\n");
35 	}
36 }
37 
38 static ssize_t mme_clk_show(struct device *dev, struct device_attribute *attr,
39 				char *buf)
40 {
41 	struct hl_device *hdev = dev_get_drvdata(dev);
42 	long value;
43 
44 	if (!hl_device_operational(hdev, NULL))
45 		return -ENODEV;
46 
47 	value = hl_fw_get_frequency(hdev, HL_GOYA_MME_PLL, false);
48 
49 	if (value < 0)
50 		return value;
51 
52 	return sprintf(buf, "%lu\n", value);
53 }
54 
55 static ssize_t mme_clk_store(struct device *dev, struct device_attribute *attr,
56 				const char *buf, size_t count)
57 {
58 	struct hl_device *hdev = dev_get_drvdata(dev);
59 	struct goya_device *goya = hdev->asic_specific;
60 	int rc;
61 	long value;
62 
63 	if (!hl_device_operational(hdev, NULL)) {
64 		count = -ENODEV;
65 		goto fail;
66 	}
67 
68 	if (goya->pm_mng_profile == PM_AUTO) {
69 		count = -EPERM;
70 		goto fail;
71 	}
72 
73 	rc = kstrtoul(buf, 0, &value);
74 
75 	if (rc) {
76 		count = -EINVAL;
77 		goto fail;
78 	}
79 
80 	hl_fw_set_frequency(hdev, HL_GOYA_MME_PLL, value);
81 	goya->mme_clk = value;
82 
83 fail:
84 	return count;
85 }
86 
87 static ssize_t tpc_clk_show(struct device *dev, struct device_attribute *attr,
88 				char *buf)
89 {
90 	struct hl_device *hdev = dev_get_drvdata(dev);
91 	long value;
92 
93 	if (!hl_device_operational(hdev, NULL))
94 		return -ENODEV;
95 
96 	value = hl_fw_get_frequency(hdev, HL_GOYA_TPC_PLL, false);
97 
98 	if (value < 0)
99 		return value;
100 
101 	return sprintf(buf, "%lu\n", value);
102 }
103 
104 static ssize_t tpc_clk_store(struct device *dev, struct device_attribute *attr,
105 				const char *buf, size_t count)
106 {
107 	struct hl_device *hdev = dev_get_drvdata(dev);
108 	struct goya_device *goya = hdev->asic_specific;
109 	int rc;
110 	long value;
111 
112 	if (!hl_device_operational(hdev, NULL)) {
113 		count = -ENODEV;
114 		goto fail;
115 	}
116 
117 	if (goya->pm_mng_profile == PM_AUTO) {
118 		count = -EPERM;
119 		goto fail;
120 	}
121 
122 	rc = kstrtoul(buf, 0, &value);
123 
124 	if (rc) {
125 		count = -EINVAL;
126 		goto fail;
127 	}
128 
129 	hl_fw_set_frequency(hdev, HL_GOYA_TPC_PLL, value);
130 	goya->tpc_clk = value;
131 
132 fail:
133 	return count;
134 }
135 
136 static ssize_t ic_clk_show(struct device *dev, struct device_attribute *attr,
137 				char *buf)
138 {
139 	struct hl_device *hdev = dev_get_drvdata(dev);
140 	long value;
141 
142 	if (!hl_device_operational(hdev, NULL))
143 		return -ENODEV;
144 
145 	value = hl_fw_get_frequency(hdev, HL_GOYA_IC_PLL, false);
146 
147 	if (value < 0)
148 		return value;
149 
150 	return sprintf(buf, "%lu\n", value);
151 }
152 
153 static ssize_t ic_clk_store(struct device *dev, struct device_attribute *attr,
154 				const char *buf, size_t count)
155 {
156 	struct hl_device *hdev = dev_get_drvdata(dev);
157 	struct goya_device *goya = hdev->asic_specific;
158 	int rc;
159 	long value;
160 
161 	if (!hl_device_operational(hdev, NULL)) {
162 		count = -ENODEV;
163 		goto fail;
164 	}
165 
166 	if (goya->pm_mng_profile == PM_AUTO) {
167 		count = -EPERM;
168 		goto fail;
169 	}
170 
171 	rc = kstrtoul(buf, 0, &value);
172 
173 	if (rc) {
174 		count = -EINVAL;
175 		goto fail;
176 	}
177 
178 	hl_fw_set_frequency(hdev, HL_GOYA_IC_PLL, value);
179 	goya->ic_clk = value;
180 
181 fail:
182 	return count;
183 }
184 
185 static ssize_t mme_clk_curr_show(struct device *dev,
186 				struct device_attribute *attr, char *buf)
187 {
188 	struct hl_device *hdev = dev_get_drvdata(dev);
189 	long value;
190 
191 	if (!hl_device_operational(hdev, NULL))
192 		return -ENODEV;
193 
194 	value = hl_fw_get_frequency(hdev, HL_GOYA_MME_PLL, true);
195 
196 	if (value < 0)
197 		return value;
198 
199 	return sprintf(buf, "%lu\n", value);
200 }
201 
202 static ssize_t tpc_clk_curr_show(struct device *dev,
203 				struct device_attribute *attr, char *buf)
204 {
205 	struct hl_device *hdev = dev_get_drvdata(dev);
206 	long value;
207 
208 	if (!hl_device_operational(hdev, NULL))
209 		return -ENODEV;
210 
211 	value = hl_fw_get_frequency(hdev, HL_GOYA_TPC_PLL, true);
212 
213 	if (value < 0)
214 		return value;
215 
216 	return sprintf(buf, "%lu\n", value);
217 }
218 
219 static ssize_t ic_clk_curr_show(struct device *dev,
220 				struct device_attribute *attr, char *buf)
221 {
222 	struct hl_device *hdev = dev_get_drvdata(dev);
223 	long value;
224 
225 	if (!hl_device_operational(hdev, NULL))
226 		return -ENODEV;
227 
228 	value = hl_fw_get_frequency(hdev, HL_GOYA_IC_PLL, true);
229 
230 	if (value < 0)
231 		return value;
232 
233 	return sprintf(buf, "%lu\n", value);
234 }
235 
236 static ssize_t pm_mng_profile_show(struct device *dev,
237 				struct device_attribute *attr, char *buf)
238 {
239 	struct hl_device *hdev = dev_get_drvdata(dev);
240 	struct goya_device *goya = hdev->asic_specific;
241 
242 	if (!hl_device_operational(hdev, NULL))
243 		return -ENODEV;
244 
245 	return sprintf(buf, "%s\n",
246 			(goya->pm_mng_profile == PM_AUTO) ? "auto" :
247 			(goya->pm_mng_profile == PM_MANUAL) ? "manual" :
248 			"unknown");
249 }
250 
251 static ssize_t pm_mng_profile_store(struct device *dev,
252 		struct device_attribute *attr, const char *buf, size_t count)
253 {
254 	struct hl_device *hdev = dev_get_drvdata(dev);
255 	struct goya_device *goya = hdev->asic_specific;
256 
257 	if (!hl_device_operational(hdev, NULL)) {
258 		count = -ENODEV;
259 		goto out;
260 	}
261 
262 	mutex_lock(&hdev->fpriv_list_lock);
263 
264 	if (hdev->is_compute_ctx_active) {
265 		dev_err(hdev->dev,
266 			"Can't change PM profile while compute context is opened on the device\n");
267 		count = -EPERM;
268 		goto unlock_mutex;
269 	}
270 
271 	if (strncmp("auto", buf, strlen("auto")) == 0) {
272 		/* Make sure we are in LOW PLL when changing modes */
273 		if (goya->pm_mng_profile == PM_MANUAL) {
274 			goya->curr_pll_profile = PLL_HIGH;
275 			goya->pm_mng_profile = PM_AUTO;
276 			goya_set_frequency(hdev, PLL_LOW);
277 		}
278 	} else if (strncmp("manual", buf, strlen("manual")) == 0) {
279 		if (goya->pm_mng_profile == PM_AUTO) {
280 			/* Must release the lock because the work thread also
281 			 * takes this lock. But before we release it, set
282 			 * the mode to manual so nothing will change if a user
283 			 * suddenly opens the device
284 			 */
285 			goya->pm_mng_profile = PM_MANUAL;
286 
287 			mutex_unlock(&hdev->fpriv_list_lock);
288 
289 			/* Flush the current work so we can return to the user
290 			 * knowing that he is the only one changing frequencies
291 			 */
292 			if (goya->goya_work)
293 				flush_delayed_work(&goya->goya_work->work_freq);
294 
295 			return count;
296 		}
297 	} else {
298 		dev_err(hdev->dev, "value should be auto or manual\n");
299 		count = -EINVAL;
300 	}
301 
302 unlock_mutex:
303 	mutex_unlock(&hdev->fpriv_list_lock);
304 out:
305 	return count;
306 }
307 
308 static ssize_t high_pll_show(struct device *dev, struct device_attribute *attr,
309 				char *buf)
310 {
311 	struct hl_device *hdev = dev_get_drvdata(dev);
312 
313 	if (!hl_device_operational(hdev, NULL))
314 		return -ENODEV;
315 
316 	return sprintf(buf, "%u\n", hdev->high_pll);
317 }
318 
319 static ssize_t high_pll_store(struct device *dev, struct device_attribute *attr,
320 				const char *buf, size_t count)
321 {
322 	struct hl_device *hdev = dev_get_drvdata(dev);
323 	long value;
324 	int rc;
325 
326 	if (!hl_device_operational(hdev, NULL)) {
327 		count = -ENODEV;
328 		goto out;
329 	}
330 
331 	rc = kstrtoul(buf, 0, &value);
332 
333 	if (rc) {
334 		count = -EINVAL;
335 		goto out;
336 	}
337 
338 	hdev->high_pll = value;
339 
340 out:
341 	return count;
342 }
343 
344 static DEVICE_ATTR_RW(high_pll);
345 static DEVICE_ATTR_RW(ic_clk);
346 static DEVICE_ATTR_RO(ic_clk_curr);
347 static DEVICE_ATTR_RW(mme_clk);
348 static DEVICE_ATTR_RO(mme_clk_curr);
349 static DEVICE_ATTR_RW(pm_mng_profile);
350 static DEVICE_ATTR_RW(tpc_clk);
351 static DEVICE_ATTR_RO(tpc_clk_curr);
352 
353 static struct attribute *goya_clk_dev_attrs[] = {
354 	&dev_attr_high_pll.attr,
355 	&dev_attr_ic_clk.attr,
356 	&dev_attr_ic_clk_curr.attr,
357 	&dev_attr_mme_clk.attr,
358 	&dev_attr_mme_clk_curr.attr,
359 	&dev_attr_pm_mng_profile.attr,
360 	&dev_attr_tpc_clk.attr,
361 	&dev_attr_tpc_clk_curr.attr,
362 	NULL,
363 };
364 
365 static ssize_t infineon_ver_show(struct device *dev, struct device_attribute *attr, char *buf)
366 {
367 	struct hl_device *hdev = dev_get_drvdata(dev);
368 	struct cpucp_info *cpucp_info;
369 
370 	cpucp_info = &hdev->asic_prop.cpucp_info;
371 
372 	return sprintf(buf, "%#04x\n", le32_to_cpu(cpucp_info->infineon_version));
373 }
374 
375 static DEVICE_ATTR_RO(infineon_ver);
376 
377 static struct attribute *goya_vrm_dev_attrs[] = {
378 	&dev_attr_infineon_ver.attr,
379 	NULL,
380 };
381 
382 void goya_add_device_attr(struct hl_device *hdev, struct attribute_group *dev_clk_attr_grp,
383 				struct attribute_group *dev_vrm_attr_grp)
384 {
385 	dev_clk_attr_grp->attrs = goya_clk_dev_attrs;
386 	dev_vrm_attr_grp->attrs = goya_vrm_dev_attrs;
387 }
388