1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (c) 2020-2021, The Linux Foundation. All rights reserved.
4  */
5 
6 #define pr_fmt(fmt)	"[drm:%s:%d] " fmt, __func__, __LINE__
7 
8 #include "msm_disp_snapshot.h"
9 
10 static ssize_t __maybe_unused disp_devcoredump_read(char *buffer, loff_t offset,
11 		size_t count, void *data, size_t datalen)
12 {
13 	struct drm_print_iterator iter;
14 	struct drm_printer p;
15 	struct msm_disp_state *disp_state;
16 
17 	disp_state = data;
18 
19 	iter.data = buffer;
20 	iter.offset = 0;
21 	iter.start = offset;
22 	iter.remain = count;
23 
24 	p = drm_coredump_printer(&iter);
25 
26 	msm_disp_state_print(disp_state, &p);
27 
28 	return count - iter.remain;
29 }
30 
31 struct msm_disp_state *
32 msm_disp_snapshot_state_sync(struct msm_kms *kms)
33 {
34 	struct drm_device *drm_dev = kms->dev;
35 	struct msm_disp_state *disp_state;
36 
37 	WARN_ON(!mutex_is_locked(&kms->dump_mutex));
38 
39 	disp_state = kzalloc(sizeof(struct msm_disp_state), GFP_KERNEL);
40 	if (!disp_state)
41 		return ERR_PTR(-ENOMEM);
42 
43 	disp_state->dev = drm_dev->dev;
44 	disp_state->drm_dev = drm_dev;
45 
46 	INIT_LIST_HEAD(&disp_state->blocks);
47 
48 	msm_disp_snapshot_capture_state(disp_state);
49 
50 	return disp_state;
51 }
52 
53 static void _msm_disp_snapshot_work(struct kthread_work *work)
54 {
55 	struct msm_kms *kms = container_of(work, struct msm_kms, dump_work);
56 	struct msm_disp_state *disp_state;
57 	struct drm_printer p;
58 
59 	/* Serialize dumping here */
60 	mutex_lock(&kms->dump_mutex);
61 	disp_state = msm_disp_snapshot_state_sync(kms);
62 	mutex_unlock(&kms->dump_mutex);
63 
64 	if (IS_ERR(disp_state))
65 		return;
66 
67 	if (MSM_DISP_SNAPSHOT_DUMP_IN_CONSOLE) {
68 		p = drm_info_printer(disp_state->drm_dev->dev);
69 		msm_disp_state_print(disp_state, &p);
70 	}
71 
72 	/*
73 	 * If COREDUMP is disabled, the stub will call the free function.
74 	 * If there is a codedump pending for the device, the dev_coredumpm()
75 	 * will also free new coredump state.
76 	 */
77 	dev_coredumpm(disp_state->dev, THIS_MODULE, disp_state, 0, GFP_KERNEL,
78 			disp_devcoredump_read, msm_disp_state_free);
79 }
80 
81 void msm_disp_snapshot_state(struct drm_device *drm_dev)
82 {
83 	struct msm_drm_private *priv;
84 	struct msm_kms *kms;
85 
86 	if (!drm_dev) {
87 		DRM_ERROR("invalid params\n");
88 		return;
89 	}
90 
91 	priv = drm_dev->dev_private;
92 	kms = priv->kms;
93 
94 	kthread_queue_work(kms->dump_worker, &kms->dump_work);
95 }
96 
97 int msm_disp_snapshot_init(struct drm_device *drm_dev)
98 {
99 	struct msm_drm_private *priv;
100 	struct msm_kms *kms;
101 
102 	if (!drm_dev) {
103 		DRM_ERROR("invalid params\n");
104 		return -EINVAL;
105 	}
106 
107 	priv = drm_dev->dev_private;
108 	kms = priv->kms;
109 
110 	mutex_init(&kms->dump_mutex);
111 
112 	kms->dump_worker = kthread_create_worker(0, "%s", "disp_snapshot");
113 	if (IS_ERR(kms->dump_worker))
114 		DRM_ERROR("failed to create disp state task\n");
115 
116 	kthread_init_work(&kms->dump_work, _msm_disp_snapshot_work);
117 
118 	return 0;
119 }
120 
121 void msm_disp_snapshot_destroy(struct drm_device *drm_dev)
122 {
123 	struct msm_kms *kms;
124 	struct msm_drm_private *priv;
125 
126 	if (!drm_dev) {
127 		DRM_ERROR("invalid params\n");
128 		return;
129 	}
130 
131 	priv = drm_dev->dev_private;
132 	if (!priv->kms)
133 		return;
134 
135 	kms = priv->kms;
136 
137 	if (kms->dump_worker)
138 		kthread_destroy_worker(kms->dump_worker);
139 
140 	mutex_destroy(&kms->dump_mutex);
141 }
142