1// SPDX-License-Identifier: GPL-2.0-only
  2/* Copyright (c) 2023 Intel Corporation. */
  3#define dev_fmt(fmt) "Telemetry: " fmt
  4
  5#include <asm/errno.h>
  6#include <linux/atomic.h>
  7#include <linux/device.h>
  8#include <linux/dev_printk.h>
  9#include <linux/dma-mapping.h>
 10#include <linux/jiffies.h>
 11#include <linux/kernel.h>
 12#include <linux/mutex.h>
 13#include <linux/slab.h>
 14#include <linux/string.h>
 15#include <linux/workqueue.h>
 16
 17#include "adf_admin.h"
 18#include "adf_accel_devices.h"
 19#include "adf_common_drv.h"
 20#include "adf_telemetry.h"
 21
 22#define TL_IS_ZERO(input)	((input) == 0)
 23
 24static bool is_tl_supported(struct adf_accel_dev *accel_dev)
 25{
 26	u16 fw_caps =  GET_HW_DATA(accel_dev)->fw_capabilities;
 27
 28	return fw_caps & TL_CAPABILITY_BIT;
 29}
 30
 31static int validate_tl_data(struct adf_tl_hw_data *tl_data)
 32{
 33	if (!tl_data->dev_counters ||
 34	    TL_IS_ZERO(tl_data->num_dev_counters) ||
 35	    !tl_data->sl_util_counters ||
 36	    !tl_data->sl_exec_counters ||
 37	    !tl_data->rp_counters ||
 38	    TL_IS_ZERO(tl_data->num_rp_counters))
 39		return -EOPNOTSUPP;
 40
 41	return 0;
 42}
 43
 44static int adf_tl_alloc_mem(struct adf_accel_dev *accel_dev)
 45{
 46	struct adf_tl_hw_data *tl_data = &GET_TL_DATA(accel_dev);
 47	struct device *dev = &GET_DEV(accel_dev);
 48	size_t regs_sz = tl_data->layout_sz;
 49	struct adf_telemetry *telemetry;
 50	int node = dev_to_node(dev);
 51	void *tl_data_regs;
 52	unsigned int i;
 53
 54	telemetry = kzalloc_node(sizeof(*telemetry), GFP_KERNEL, node);
 55	if (!telemetry)
 56		return -ENOMEM;
 57
 58	telemetry->rp_num_indexes = kmalloc_array(tl_data->max_rp,
 59						  sizeof(*telemetry->rp_num_indexes),
 60						  GFP_KERNEL);
 61	if (!telemetry->rp_num_indexes)
 62		goto err_free_tl;
 63
 64	telemetry->regs_hist_buff = kmalloc_array(tl_data->num_hbuff,
 65						  sizeof(*telemetry->regs_hist_buff),
 66						  GFP_KERNEL);
 67	if (!telemetry->regs_hist_buff)
 68		goto err_free_rp_indexes;
 69
 70	telemetry->regs_data = dma_alloc_coherent(dev, regs_sz,
 71						  &telemetry->regs_data_p,
 72						  GFP_KERNEL);
 73	if (!telemetry->regs_data)
 74		goto err_free_regs_hist_buff;
 75
 76	for (i = 0; i < tl_data->num_hbuff; i++) {
 77		tl_data_regs = kzalloc_node(regs_sz, GFP_KERNEL, node);
 78		if (!tl_data_regs)
 79			goto err_free_dma;
 80
 81		telemetry->regs_hist_buff[i] = tl_data_regs;
 82	}
 83
 84	accel_dev->telemetry = telemetry;
 85
 86	return 0;
 87
 88err_free_dma:
 89	dma_free_coherent(dev, regs_sz, telemetry->regs_data,
 90			  telemetry->regs_data_p);
 91
 92	while (i--)
 93		kfree(telemetry->regs_hist_buff[i]);
 94
 95err_free_regs_hist_buff:
 96	kfree(telemetry->regs_hist_buff);
 97err_free_rp_indexes:
 98	kfree(telemetry->rp_num_indexes);
 99err_free_tl:
100	kfree(telemetry);
101
102	return -ENOMEM;
103}
104
105static void adf_tl_free_mem(struct adf_accel_dev *accel_dev)
106{
107	struct adf_tl_hw_data *tl_data = &GET_TL_DATA(accel_dev);
108	struct adf_telemetry *telemetry = accel_dev->telemetry;
109	struct device *dev = &GET_DEV(accel_dev);
110	size_t regs_sz = tl_data->layout_sz;
111	unsigned int i;
112
113	for (i = 0; i < tl_data->num_hbuff; i++)
114		kfree(telemetry->regs_hist_buff[i]);
115
116	dma_free_coherent(dev, regs_sz, telemetry->regs_data,
117			  telemetry->regs_data_p);
118
119	kfree(telemetry->regs_hist_buff);
120	kfree(telemetry->rp_num_indexes);
121	kfree(telemetry);
122	accel_dev->telemetry = NULL;
123}
124
125static unsigned long get_next_timeout(void)
126{
127	return msecs_to_jiffies(ADF_TL_TIMER_INT_MS);
128}
129
130static void snapshot_regs(struct adf_telemetry *telemetry, size_t size)
131{
132	void *dst = telemetry->regs_hist_buff[telemetry->hb_num];
133	void *src = telemetry->regs_data;
134
135	memcpy(dst, src, size);
136}
137
138static void tl_work_handler(struct work_struct *work)
139{
140	struct delayed_work *delayed_work;
141	struct adf_telemetry *telemetry;
142	struct adf_tl_hw_data *tl_data;
143	u32 msg_cnt, old_msg_cnt;
144	size_t layout_sz;
145	u32 *regs_data;
146	size_t id;
147
148	delayed_work = to_delayed_work(work);
149	telemetry = container_of(delayed_work, struct adf_telemetry, work_ctx);
150	tl_data = &GET_TL_DATA(telemetry->accel_dev);
151	regs_data = telemetry->regs_data;
152
153	id = tl_data->msg_cnt_off / sizeof(*regs_data);
154	layout_sz = tl_data->layout_sz;
155
156	if (!atomic_read(&telemetry->state)) {
157		cancel_delayed_work_sync(&telemetry->work_ctx);
158		return;
159	}
160
161	msg_cnt = regs_data[id];
162	old_msg_cnt = msg_cnt;
163	if (msg_cnt == telemetry->msg_cnt)
164		goto out;
165
166	mutex_lock(&telemetry->regs_hist_lock);
167
168	snapshot_regs(telemetry, layout_sz);
169
170	/* Check if data changed while updating it */
171	msg_cnt = regs_data[id];
172	if (old_msg_cnt != msg_cnt)
173		snapshot_regs(telemetry, layout_sz);
174
175	telemetry->msg_cnt = msg_cnt;
176	telemetry->hb_num++;
177	telemetry->hb_num %= telemetry->hbuffs;
178
179	mutex_unlock(&telemetry->regs_hist_lock);
180
181out:
182	adf_misc_wq_queue_delayed_work(&telemetry->work_ctx, get_next_timeout());
183}
184
185int adf_tl_halt(struct adf_accel_dev *accel_dev)
186{
187	struct adf_telemetry *telemetry = accel_dev->telemetry;
188	struct device *dev = &GET_DEV(accel_dev);
189	int ret;
190
191	cancel_delayed_work_sync(&telemetry->work_ctx);
192	atomic_set(&telemetry->state, 0);
193
194	ret = adf_send_admin_tl_stop(accel_dev);
195	if (ret)
196		dev_err(dev, "failed to stop telemetry\n");
197
198	return ret;
199}
200
201int adf_tl_run(struct adf_accel_dev *accel_dev, int state)
202{
203	struct adf_tl_hw_data *tl_data = &GET_TL_DATA(accel_dev);
204	struct adf_telemetry *telemetry = accel_dev->telemetry;
205	struct device *dev = &GET_DEV(accel_dev);
206	size_t layout_sz = tl_data->layout_sz;
207	int ret;
208
209	ret = adf_send_admin_tl_start(accel_dev, telemetry->regs_data_p,
210				      layout_sz, telemetry->rp_num_indexes,
211				      &telemetry->slice_cnt);
212	if (ret) {
213		dev_err(dev, "failed to start telemetry\n");
214		return ret;
215	}
216
217	telemetry->hbuffs = state;
218	atomic_set(&telemetry->state, state);
219
220	adf_misc_wq_queue_delayed_work(&telemetry->work_ctx, get_next_timeout());
221
222	return 0;
223}
224
225int adf_tl_init(struct adf_accel_dev *accel_dev)
226{
227	struct adf_tl_hw_data *tl_data = &GET_TL_DATA(accel_dev);
228	u8 max_rp = GET_TL_DATA(accel_dev).max_rp;
229	struct device *dev = &GET_DEV(accel_dev);
230	struct adf_telemetry *telemetry;
231	unsigned int i;
232	int ret;
233
234	ret = validate_tl_data(tl_data);
235	if (ret)
236		return ret;
237
238	ret = adf_tl_alloc_mem(accel_dev);
239	if (ret) {
240		dev_err(dev, "failed to initialize: %d\n", ret);
241		return ret;
242	}
243
244	telemetry = accel_dev->telemetry;
245	telemetry->accel_dev = accel_dev;
246
247	mutex_init(&telemetry->wr_lock);
248	mutex_init(&telemetry->regs_hist_lock);
249	INIT_DELAYED_WORK(&telemetry->work_ctx, tl_work_handler);
250
251	for (i = 0; i < max_rp; i++)
252		telemetry->rp_num_indexes[i] = ADF_TL_RP_REGS_DISABLED;
253
254	return 0;
255}
256
257int adf_tl_start(struct adf_accel_dev *accel_dev)
258{
259	struct device *dev = &GET_DEV(accel_dev);
260
261	if (!accel_dev->telemetry)
262		return -EOPNOTSUPP;
263
264	if (!is_tl_supported(accel_dev)) {
265		dev_info(dev, "feature not supported by FW\n");
266		adf_tl_free_mem(accel_dev);
267		return -EOPNOTSUPP;
268	}
269
270	return 0;
271}
272
273void adf_tl_stop(struct adf_accel_dev *accel_dev)
274{
275	if (!accel_dev->telemetry)
276		return;
277
278	if (atomic_read(&accel_dev->telemetry->state))
279		adf_tl_halt(accel_dev);
280}
281
282void adf_tl_shutdown(struct adf_accel_dev *accel_dev)
283{
284	if (!accel_dev->telemetry)
285		return;
286
287	adf_tl_free_mem(accel_dev);
288}