tee-if.c

  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * AMD Platform Management Framework Driver - TEE Interface
  4 *
  5 * Copyright (c) 2023, Advanced Micro Devices, Inc.
  6 * All Rights Reserved.
  7 *
  8 * Author: Shyam Sundar S K <Shyam-sundar.S-k@amd.com>
  9 */
 10
 11#include <linux/debugfs.h>
 12#include <linux/tee_drv.h>
 13#include <linux/uuid.h>
 14#include "pmf.h"
 15
 16#define MAX_TEE_PARAM	4
 17
 18/* Policy binary actions sampling frequency (in ms) */
 19static int pb_actions_ms = MSEC_PER_SEC;
 20/* Sideload policy binaries to debug policy failures */
 21static bool pb_side_load;
 22
 23#ifdef CONFIG_AMD_PMF_DEBUG
 24module_param(pb_actions_ms, int, 0644);
 25MODULE_PARM_DESC(pb_actions_ms, "Policy binary actions sampling frequency (default = 1000ms)");
 26module_param(pb_side_load, bool, 0444);
 27MODULE_PARM_DESC(pb_side_load, "Sideload policy binaries debug policy failures");
 28#endif
 29
 30static const char *amd_pmf_uevent_as_str(unsigned int state)
 31{
 32	switch (state) {
 33	case SYSTEM_STATE_S0i3:
 34		return "S0i3";
 35	case SYSTEM_STATE_S4:
 36		return "S4";
 37	case SYSTEM_STATE_SCREEN_LOCK:
 38		return "SCREEN_LOCK";
 39	default:
 40		return "Unknown Smart PC event";
 41	}
 42}
 43
 44static void amd_pmf_prepare_args(struct amd_pmf_dev *dev, int cmd,
 45				 struct tee_ioctl_invoke_arg *arg,
 46				 struct tee_param *param)
 47{
 48	memset(arg, 0, sizeof(*arg));
 49	memset(param, 0, MAX_TEE_PARAM * sizeof(*param));
 50
 51	arg->func = cmd;
 52	arg->session = dev->session_id;
 53	arg->num_params = MAX_TEE_PARAM;
 54
 55	/* Fill invoke cmd params */
 56	param[0].u.memref.size = sizeof(struct ta_pmf_shared_memory);
 57	param[0].attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INOUT;
 58	param[0].u.memref.shm = dev->fw_shm_pool;
 59	param[0].u.memref.shm_offs = 0;
 60}
 61
 62static void amd_pmf_update_uevents(struct amd_pmf_dev *dev, u16 event)
 63{
 64	input_report_key(dev->pmf_idev, event, 1); /* key press */
 65	input_sync(dev->pmf_idev);
 66	input_report_key(dev->pmf_idev, event, 0); /* key release */
 67	input_sync(dev->pmf_idev);
 68}
 69
 70static int amd_pmf_get_bios_output_idx(u32 action_idx)
 71{
 72	switch (action_idx) {
 73	case PMF_POLICY_BIOS_OUTPUT_1:
 74		return 0;
 75	case PMF_POLICY_BIOS_OUTPUT_2:
 76		return 1;
 77	case PMF_POLICY_BIOS_OUTPUT_3:
 78		return 2;
 79	case PMF_POLICY_BIOS_OUTPUT_4:
 80		return 3;
 81	case PMF_POLICY_BIOS_OUTPUT_5:
 82		return 4;
 83	case PMF_POLICY_BIOS_OUTPUT_6:
 84		return 5;
 85	case PMF_POLICY_BIOS_OUTPUT_7:
 86		return 6;
 87	case PMF_POLICY_BIOS_OUTPUT_8:
 88		return 7;
 89	case PMF_POLICY_BIOS_OUTPUT_9:
 90		return 8;
 91	case PMF_POLICY_BIOS_OUTPUT_10:
 92		return 9;
 93	default:
 94		return -EINVAL;
 95	}
 96}
 97
 98static void amd_pmf_update_bios_output(struct amd_pmf_dev *pdev, struct ta_pmf_action *action)
 99{
100	u32 bios_idx;
101
102	bios_idx = amd_pmf_get_bios_output_idx(action->action_index);
103
104	amd_pmf_smartpc_apply_bios_output(pdev, action->value, BIT(bios_idx), bios_idx);
105}
106
107static void amd_pmf_apply_policies(struct amd_pmf_dev *dev, struct ta_pmf_enact_result *out)
108{
109	struct ta_pmf_action *action;
110	u32 val;
111	int idx;
112
113	for (idx = 0; idx < out->actions_count; idx++) {
114		action = &out->actions_list[idx];
115		val = action->value;
116		switch (action->action_index) {
117		case PMF_POLICY_SPL:
118			if (dev->prev_data->spl != val) {
119				amd_pmf_send_cmd(dev, SET_SPL, SET_CMD, val, NULL);
120				dev_dbg(dev->dev, "update SPL: %u\n", val);
121				dev->prev_data->spl = val;
122			}
123			break;
124
125		case PMF_POLICY_SPPT:
126			if (dev->prev_data->sppt != val) {
127				amd_pmf_send_cmd(dev, SET_SPPT, SET_CMD, val, NULL);
128				dev_dbg(dev->dev, "update SPPT: %u\n", val);
129				dev->prev_data->sppt = val;
130			}
131			break;
132
133		case PMF_POLICY_FPPT:
134			if (dev->prev_data->fppt != val) {
135				amd_pmf_send_cmd(dev, SET_FPPT, SET_CMD, val, NULL);
136				dev_dbg(dev->dev, "update FPPT: %u\n", val);
137				dev->prev_data->fppt = val;
138			}
139			break;
140
141		case PMF_POLICY_SPPT_APU_ONLY:
142			if (dev->prev_data->sppt_apuonly != val) {
143				amd_pmf_send_cmd(dev, SET_SPPT_APU_ONLY, SET_CMD, val, NULL);
144				dev_dbg(dev->dev, "update SPPT_APU_ONLY: %u\n", val);
145				dev->prev_data->sppt_apuonly = val;
146			}
147			break;
148
149		case PMF_POLICY_STT_MIN:
150			if (dev->prev_data->stt_minlimit != val) {
151				amd_pmf_send_cmd(dev, SET_STT_MIN_LIMIT, SET_CMD, val, NULL);
152				dev_dbg(dev->dev, "update STT_MIN: %u\n", val);
153				dev->prev_data->stt_minlimit = val;
154			}
155			break;
156
157		case PMF_POLICY_STT_SKINTEMP_APU:
158			if (dev->prev_data->stt_skintemp_apu != val) {
159				amd_pmf_send_cmd(dev, SET_STT_LIMIT_APU, SET_CMD,
160						 fixp_q88_fromint(val), NULL);
161				dev_dbg(dev->dev, "update STT_SKINTEMP_APU: %u\n", val);
162				dev->prev_data->stt_skintemp_apu = val;
163			}
164			break;
165
166		case PMF_POLICY_STT_SKINTEMP_HS2:
167			if (dev->prev_data->stt_skintemp_hs2 != val) {
168				amd_pmf_send_cmd(dev, SET_STT_LIMIT_HS2, SET_CMD,
169						 fixp_q88_fromint(val), NULL);
170				dev_dbg(dev->dev, "update STT_SKINTEMP_HS2: %u\n", val);
171				dev->prev_data->stt_skintemp_hs2 = val;
172			}
173			break;
174
175		case PMF_POLICY_P3T:
176			if (dev->prev_data->p3t_limit != val) {
177				amd_pmf_send_cmd(dev, SET_P3T, SET_CMD, val, NULL);
178				dev_dbg(dev->dev, "update P3T: %u\n", val);
179				dev->prev_data->p3t_limit = val;
180			}
181			break;
182
183		case PMF_POLICY_PMF_PPT:
184			if (dev->prev_data->pmf_ppt != val) {
185				amd_pmf_send_cmd(dev, SET_PMF_PPT, SET_CMD, val, NULL);
186				dev_dbg(dev->dev, "update PMF PPT: %u\n", val);
187				dev->prev_data->pmf_ppt = val;
188			}
189			break;
190
191		case PMF_POLICY_PMF_PPT_APU_ONLY:
192			if (dev->prev_data->pmf_ppt_apu_only != val) {
193				amd_pmf_send_cmd(dev, SET_PMF_PPT_APU_ONLY, SET_CMD, val, NULL);
194				dev_dbg(dev->dev, "update PMF PPT APU ONLY: %u\n", val);
195				dev->prev_data->pmf_ppt_apu_only = val;
196			}
197			break;
198
199		case PMF_POLICY_SYSTEM_STATE:
200			switch (val) {
201			case 0:
202				amd_pmf_update_uevents(dev, KEY_SLEEP);
203				break;
204			case 1:
205				amd_pmf_update_uevents(dev, KEY_SUSPEND);
206				break;
207			case 2:
208				amd_pmf_update_uevents(dev, KEY_SCREENLOCK);
209				break;
210			default:
211				dev_err(dev->dev, "Invalid PMF policy system state: %d\n", val);
212			}
213
214			dev_dbg(dev->dev, "update SYSTEM_STATE: %s\n",
215				amd_pmf_uevent_as_str(val));
216			break;
217
218		case PMF_POLICY_BIOS_OUTPUT_1:
219		case PMF_POLICY_BIOS_OUTPUT_2:
220		case PMF_POLICY_BIOS_OUTPUT_3:
221		case PMF_POLICY_BIOS_OUTPUT_4:
222		case PMF_POLICY_BIOS_OUTPUT_5:
223		case PMF_POLICY_BIOS_OUTPUT_6:
224		case PMF_POLICY_BIOS_OUTPUT_7:
225		case PMF_POLICY_BIOS_OUTPUT_8:
226		case PMF_POLICY_BIOS_OUTPUT_9:
227		case PMF_POLICY_BIOS_OUTPUT_10:
228			amd_pmf_update_bios_output(dev, action);
229			break;
230		}
231	}
232}
233
234int amd_pmf_invoke_cmd_enact(struct amd_pmf_dev *dev)
235{
236	struct ta_pmf_shared_memory *ta_sm = NULL;
237	struct ta_pmf_enact_result *out = NULL;
238	struct ta_pmf_enact_table *in = NULL;
239	struct tee_param param[MAX_TEE_PARAM];
240	struct tee_ioctl_invoke_arg arg;
241	int ret = 0;
242
243	if (!dev->tee_ctx)
244		return -ENODEV;
245
246	memset(dev->shbuf, 0, dev->policy_sz);
247	ta_sm = dev->shbuf;
248	out = &ta_sm->pmf_output.policy_apply_table;
249	in = &ta_sm->pmf_input.enact_table;
250
251	memset(ta_sm, 0, sizeof(*ta_sm));
252	ta_sm->command_id = TA_PMF_COMMAND_POLICY_BUILDER_ENACT_POLICIES;
253	ta_sm->if_version = PMF_TA_IF_VERSION_MAJOR;
254
255	amd_pmf_populate_ta_inputs(dev, in);
256	amd_pmf_prepare_args(dev, TA_PMF_COMMAND_POLICY_BUILDER_ENACT_POLICIES, &arg, param);
257
258	ret = tee_client_invoke_func(dev->tee_ctx, &arg, param);
259	if (ret < 0 || arg.ret != 0) {
260		dev_err(dev->dev, "TEE enact cmd failed. err: %x, ret:%d\n", arg.ret, ret);
261		return ret;
262	}
263
264	if (ta_sm->pmf_result == TA_PMF_TYPE_SUCCESS && out->actions_count) {
265		amd_pmf_dump_ta_inputs(dev, in);
266		dev_dbg(dev->dev, "action count:%u result:%x\n", out->actions_count,
267			ta_sm->pmf_result);
268		amd_pmf_apply_policies(dev, out);
269	}
270
271	return 0;
272}
273
274static int amd_pmf_invoke_cmd_init(struct amd_pmf_dev *dev)
275{
276	struct ta_pmf_shared_memory *ta_sm = NULL;
277	struct tee_param param[MAX_TEE_PARAM];
278	struct ta_pmf_init_table *in = NULL;
279	struct tee_ioctl_invoke_arg arg;
280	int ret = 0;
281
282	if (!dev->tee_ctx) {
283		dev_err(dev->dev, "Failed to get TEE context\n");
284		return -ENODEV;
285	}
286
287	dev_dbg(dev->dev, "Policy Binary size: %llu bytes\n", (unsigned long long)dev->policy_sz);
288	memset(dev->shbuf, 0, dev->policy_sz);
289	ta_sm = dev->shbuf;
290	in = &ta_sm->pmf_input.init_table;
291
292	ta_sm->command_id = TA_PMF_COMMAND_POLICY_BUILDER_INITIALIZE;
293	ta_sm->if_version = PMF_TA_IF_VERSION_MAJOR;
294
295	in->metadata_macrocheck = false;
296	in->sku_check = false;
297	in->validate = true;
298	in->frequency = pb_actions_ms;
299	in->policies_table.table_size = dev->policy_sz;
300
301	memcpy(in->policies_table.table, dev->policy_buf, dev->policy_sz);
302	amd_pmf_prepare_args(dev, TA_PMF_COMMAND_POLICY_BUILDER_INITIALIZE, &arg, param);
303
304	ret = tee_client_invoke_func(dev->tee_ctx, &arg, param);
305	if (ret < 0 || arg.ret != 0) {
306		dev_err(dev->dev, "Failed to invoke TEE init cmd. err: %x, ret:%d\n", arg.ret, ret);
307		return ret;
308	}
309
310	return ta_sm->pmf_result;
311}
312
313static void amd_pmf_invoke_cmd(struct work_struct *work)
314{
315	struct amd_pmf_dev *dev = container_of(work, struct amd_pmf_dev, pb_work.work);
316
317	amd_pmf_invoke_cmd_enact(dev);
318	schedule_delayed_work(&dev->pb_work, msecs_to_jiffies(pb_actions_ms));
319}
320
321int amd_pmf_start_policy_engine(struct amd_pmf_dev *dev)
322{
323	struct cookie_header *header;
324	int res;
325
326	if (dev->policy_sz < POLICY_COOKIE_OFFSET + sizeof(*header))
327		return -EINVAL;
328
329	header = (struct cookie_header *)(dev->policy_buf + POLICY_COOKIE_OFFSET);
330
331	if (header->sign != POLICY_SIGN_COOKIE || !header->length) {
332		dev_dbg(dev->dev, "cookie doesn't match\n");
333		return -EINVAL;
334	}
335
336	if (dev->policy_sz < header->length + 512)
337		return -EINVAL;
338
339	/* Update the actual length */
340	dev->policy_sz = header->length + 512;
341	res = amd_pmf_invoke_cmd_init(dev);
342	if (res == TA_PMF_TYPE_SUCCESS) {
343		/* Now its safe to announce that smart pc is enabled */
344		dev->smart_pc_enabled = true;
345		/*
346		 * Start collecting the data from TA FW after a small delay
347		 * or else, we might end up getting stale values.
348		 */
349		schedule_delayed_work(&dev->pb_work, msecs_to_jiffies(pb_actions_ms * 3));
350	} else {
351		dev_dbg(dev->dev, "ta invoke cmd init failed err: %x\n", res);
352		dev->smart_pc_enabled = false;
353		return res;
354	}
355
356	return 0;
357}
358
359static inline bool amd_pmf_pb_valid(struct amd_pmf_dev *dev)
360{
361	return memchr_inv(dev->policy_buf, 0xff, dev->policy_sz);
362}
363
364#ifdef CONFIG_AMD_PMF_DEBUG
365static void amd_pmf_hex_dump_pb(struct amd_pmf_dev *dev)
366{
367	print_hex_dump_debug("(pb):  ", DUMP_PREFIX_OFFSET, 16, 1, dev->policy_buf,
368			     dev->policy_sz, false);
369}
370
371static ssize_t amd_pmf_get_pb_data(struct file *filp, const char __user *buf,
372				   size_t length, loff_t *pos)
373{
374	struct amd_pmf_dev *dev = filp->private_data;
375	unsigned char *new_policy_buf;
376	int ret;
377
378	/* Policy binary size cannot exceed POLICY_BUF_MAX_SZ */
379	if (length > POLICY_BUF_MAX_SZ || length == 0)
380		return -EINVAL;
381
382	/* re-alloc to the new buffer length of the policy binary */
383	new_policy_buf = devm_kzalloc(dev->dev, length, GFP_KERNEL);
384	if (!new_policy_buf)
385		return -ENOMEM;
386
387	if (copy_from_user(new_policy_buf, buf, length)) {
388		devm_kfree(dev->dev, new_policy_buf);
389		return -EFAULT;
390	}
391
392	devm_kfree(dev->dev, dev->policy_buf);
393	dev->policy_buf = new_policy_buf;
394	dev->policy_sz = length;
395
396	if (!amd_pmf_pb_valid(dev))
397		return -EINVAL;
398
399	amd_pmf_hex_dump_pb(dev);
400	ret = amd_pmf_start_policy_engine(dev);
401	if (ret < 0)
402		return ret;
403
404	return length;
405}
406
407static const struct file_operations pb_fops = {
408	.write = amd_pmf_get_pb_data,
409	.open = simple_open,
410};
411
412static void amd_pmf_open_pb(struct amd_pmf_dev *dev, struct dentry *debugfs_root)
413{
414	dev->esbin = debugfs_create_dir("pb", debugfs_root);
415	debugfs_create_file("update_policy", 0644, dev->esbin, dev, &pb_fops);
416}
417
418static void amd_pmf_remove_pb(struct amd_pmf_dev *dev)
419{
420	debugfs_remove_recursive(dev->esbin);
421}
422#else
423static void amd_pmf_open_pb(struct amd_pmf_dev *dev, struct dentry *debugfs_root) {}
424static void amd_pmf_remove_pb(struct amd_pmf_dev *dev) {}
425static void amd_pmf_hex_dump_pb(struct amd_pmf_dev *dev) {}
426#endif
427
428static int amd_pmf_amdtee_ta_match(struct tee_ioctl_version_data *ver, const void *data)
429{
430	return ver->impl_id == TEE_IMPL_ID_AMDTEE;
431}
432
433static int amd_pmf_ta_open_session(struct tee_context *ctx, u32 *id, const uuid_t *uuid)
434{
435	struct tee_ioctl_open_session_arg sess_arg = {};
436	int rc;
437
438	export_uuid(sess_arg.uuid, uuid);
439	sess_arg.clnt_login = TEE_IOCTL_LOGIN_PUBLIC;
440	sess_arg.num_params = 0;
441
442	rc = tee_client_open_session(ctx, &sess_arg, NULL);
443	if (rc < 0 || sess_arg.ret != 0) {
444		pr_err("Failed to open TEE session err:%#x, rc:%d\n", sess_arg.ret, rc);
445		return rc ?: -EINVAL;
446	}
447
448	*id = sess_arg.session;
449
450	return 0;
451}
452
453static int amd_pmf_register_input_device(struct amd_pmf_dev *dev)
454{
455	int err;
456
457	dev->pmf_idev = devm_input_allocate_device(dev->dev);
458	if (!dev->pmf_idev)
459		return -ENOMEM;
460
461	dev->pmf_idev->name = "PMF-TA output events";
462	dev->pmf_idev->phys = "amd-pmf/input0";
463
464	input_set_capability(dev->pmf_idev, EV_KEY, KEY_SLEEP);
465	input_set_capability(dev->pmf_idev, EV_KEY, KEY_SCREENLOCK);
466	input_set_capability(dev->pmf_idev, EV_KEY, KEY_SUSPEND);
467
468	err = input_register_device(dev->pmf_idev);
469	if (err) {
470		dev_err(dev->dev, "Failed to register input device: %d\n", err);
471		return err;
472	}
473
474	return 0;
475}
476
477int amd_pmf_tee_init(struct amd_pmf_dev *dev, const uuid_t *uuid)
478{
479	u32 size;
480	int ret;
481
482	dev->tee_ctx = tee_client_open_context(NULL, amd_pmf_amdtee_ta_match, NULL, NULL);
483	if (IS_ERR(dev->tee_ctx)) {
484		dev_err(dev->dev, "Failed to open TEE context\n");
485		ret = PTR_ERR(dev->tee_ctx);
486		dev->tee_ctx = NULL;
487		return ret;
488	}
489
490	ret = amd_pmf_ta_open_session(dev->tee_ctx, &dev->session_id, uuid);
491	if (ret) {
492		dev_err(dev->dev, "Failed to open TA session (%d)\n", ret);
493		ret = -EINVAL;
494		goto out_ctx;
495	}
496
497	size = sizeof(struct ta_pmf_shared_memory) + dev->policy_sz;
498	dev->fw_shm_pool = tee_shm_alloc_kernel_buf(dev->tee_ctx, size);
499	if (IS_ERR(dev->fw_shm_pool)) {
500		dev_err(dev->dev, "Failed to alloc TEE shared memory\n");
501		ret = PTR_ERR(dev->fw_shm_pool);
502		goto out_sess;
503	}
504
505	dev->shbuf = tee_shm_get_va(dev->fw_shm_pool, 0);
506	if (IS_ERR(dev->shbuf)) {
507		dev_err(dev->dev, "Failed to get TEE virtual address\n");
508		ret = PTR_ERR(dev->shbuf);
509		goto out_shm;
510	}
511	dev_dbg(dev->dev, "TEE init done\n");
512
513	return 0;
514
515out_shm:
516	tee_shm_free(dev->fw_shm_pool);
517out_sess:
518	tee_client_close_session(dev->tee_ctx, dev->session_id);
519out_ctx:
520	tee_client_close_context(dev->tee_ctx);
521
522	return ret;
523}
524
525void amd_pmf_tee_deinit(struct amd_pmf_dev *dev)
526{
527	if (!dev->tee_ctx)
528		return;
529	tee_shm_free(dev->fw_shm_pool);
530	tee_client_close_session(dev->tee_ctx, dev->session_id);
531	tee_client_close_context(dev->tee_ctx);
532	dev->tee_ctx = NULL;
533}
534
535int amd_pmf_init_smart_pc(struct amd_pmf_dev *dev)
536{
537	bool status;
538	int ret, i;
539
540	ret = apmf_check_smart_pc(dev);
541	if (ret) {
542		/*
543		 * Lets not return from here if Smart PC bit is not advertised in
544		 * the BIOS. This way, there will be some amount of power savings
545		 * to the user with static slider (if enabled).
546		 */
547		dev_info(dev->dev, "PMF Smart PC not advertised in BIOS!:%d\n", ret);
548		return -ENODEV;
549	}
550
551	INIT_DELAYED_WORK(&dev->pb_work, amd_pmf_invoke_cmd);
552
553	ret = amd_pmf_set_dram_addr(dev, true);
554	if (ret)
555		return ret;
556
557	dev->policy_base = devm_ioremap_resource(dev->dev, dev->res);
558	if (IS_ERR(dev->policy_base))
559		return PTR_ERR(dev->policy_base);
560
561	dev->policy_buf = devm_kzalloc(dev->dev, dev->policy_sz, GFP_KERNEL);
562	if (!dev->policy_buf)
563		return -ENOMEM;
564
565	memcpy_fromio(dev->policy_buf, dev->policy_base, dev->policy_sz);
566
567	if (!amd_pmf_pb_valid(dev)) {
568		dev_info(dev->dev, "No Smart PC policy present\n");
569		return -EINVAL;
570	}
571
572	amd_pmf_hex_dump_pb(dev);
573
574	dev->prev_data = devm_kzalloc(dev->dev, sizeof(*dev->prev_data), GFP_KERNEL);
575	if (!dev->prev_data)
576		return -ENOMEM;
577
578	for (i = 0; i < ARRAY_SIZE(amd_pmf_ta_uuid); i++) {
579		ret = amd_pmf_tee_init(dev, &amd_pmf_ta_uuid[i]);
580		if (ret)
581			return ret;
582
583		ret = amd_pmf_start_policy_engine(dev);
584		dev_dbg(dev->dev, "start policy engine ret: %d\n", ret);
585		status = ret == TA_PMF_TYPE_SUCCESS;
586		if (status) {
587			dev->cb_flag = true;
588			break;
589		}
590		amd_pmf_tee_deinit(dev);
591	}
592
593	if (!status && !pb_side_load) {
594		ret = -EINVAL;
595		goto err;
596	}
597
598	if (pb_side_load)
599		amd_pmf_open_pb(dev, dev->dbgfs_dir);
600
601	ret = amd_pmf_register_input_device(dev);
602	if (ret)
603		goto err;
604
605	return 0;
606
607err:
608	amd_pmf_deinit_smart_pc(dev);
609
610	return ret;
611}
612
613void amd_pmf_deinit_smart_pc(struct amd_pmf_dev *dev)
614{
615	if (dev->pmf_idev)
616		input_unregister_device(dev->pmf_idev);
617
618	if (pb_side_load && dev->esbin)
619		amd_pmf_remove_pb(dev);
620
621	cancel_delayed_work_sync(&dev->pb_work);
622	amd_pmf_tee_deinit(dev);
623}