1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * Intel MIC Platform Software Stack (MPSS)
  4 *
  5 * Copyright(c) 2015 Intel Corporation.
  6 *
  7 * Intel MIC Coprocessor State Management (COSM) Driver
  8 */
  9
 10#include <linux/module.h>
 11#include <linux/delay.h>
 12#include <linux/idr.h>
 13#include <linux/slab.h>
 14#include <linux/cred.h>
 15#include "cosm_main.h"
 16
 17static const char cosm_driver_name[] = "mic";
 18
 19/* COSM ID allocator */
 20static struct ida g_cosm_ida;
 21/* Class of MIC devices for sysfs accessibility. */
 22static struct class *g_cosm_class;
 23/* Number of MIC devices */
 24static atomic_t g_num_dev;
 25
 26/**
 27 * cosm_hw_reset - Issue a HW reset for the MIC device
 28 * @cdev: pointer to cosm_device instance
 29 * @force: force a MIC to reset even if it is already reset and ready
 30 */
 31static void cosm_hw_reset(struct cosm_device *cdev, bool force)
 32{
 33	int i;
 34
 35#define MIC_RESET_TO (45)
 36	if (force && cdev->hw_ops->force_reset)
 37		cdev->hw_ops->force_reset(cdev);
 38	else
 39		cdev->hw_ops->reset(cdev);
 40
 41	for (i = 0; i < MIC_RESET_TO; i++) {
 42		if (cdev->hw_ops->ready(cdev)) {
 43			cosm_set_state(cdev, MIC_READY);
 44			return;
 45		}
 46		/*
 47		 * Resets typically take 10s of seconds to complete.
 48		 * Since an MMIO read is required to check if the
 49		 * firmware is ready or not, a 1 second delay works nicely.
 50		 */
 51		msleep(1000);
 52	}
 53	cosm_set_state(cdev, MIC_RESET_FAILED);
 54}
 55
 56/**
 57 * cosm_start - Start the MIC
 58 * @cdev: pointer to cosm_device instance
 59 *
 60 * This function prepares an MIC for boot and initiates boot.
 61 * RETURNS: An appropriate -ERRNO error value on error, or 0 for success.
 62 */
 63int cosm_start(struct cosm_device *cdev)
 64{
 65	const struct cred *orig_cred;
 66	struct cred *override_cred;
 67	int rc;
 68
 69	mutex_lock(&cdev->cosm_mutex);
 70	if (!cdev->bootmode) {
 71		dev_err(&cdev->dev, "%s %d bootmode not set\n",
 72			__func__, __LINE__);
 73		rc = -EINVAL;
 74		goto unlock_ret;
 75	}
 76retry:
 77	if (cdev->state != MIC_READY) {
 78		dev_err(&cdev->dev, "%s %d MIC state not READY\n",
 79			__func__, __LINE__);
 80		rc = -EINVAL;
 81		goto unlock_ret;
 82	}
 83	if (!cdev->hw_ops->ready(cdev)) {
 84		cosm_hw_reset(cdev, false);
 85		/*
 86		 * The state will either be MIC_READY if the reset succeeded
 87		 * or MIC_RESET_FAILED if the firmware reset failed.
 88		 */
 89		goto retry;
 90	}
 91
 92	/*
 93	 * Set credentials to root to allow non-root user to download initramsfs
 94	 * with 600 permissions
 95	 */
 96	override_cred = prepare_creds();
 97	if (!override_cred) {
 98		dev_err(&cdev->dev, "%s %d prepare_creds failed\n",
 99			__func__, __LINE__);
100		rc = -ENOMEM;
101		goto unlock_ret;
102	}
103	override_cred->fsuid = GLOBAL_ROOT_UID;
104	orig_cred = override_creds(override_cred);
105
106	rc = cdev->hw_ops->start(cdev, cdev->index);
107
108	revert_creds(orig_cred);
109	put_cred(override_cred);
110	if (rc)
111		goto unlock_ret;
112
113	/*
114	 * If linux is being booted, card is treated 'online' only
115	 * when the scif interface in the card is up. If anything else
116	 * is booted, we set card to 'online' immediately.
117	 */
118	if (!strcmp(cdev->bootmode, "linux"))
119		cosm_set_state(cdev, MIC_BOOTING);
120	else
121		cosm_set_state(cdev, MIC_ONLINE);
122unlock_ret:
123	mutex_unlock(&cdev->cosm_mutex);
124	if (rc)
125		dev_err(&cdev->dev, "cosm_start failed rc %d\n", rc);
126	return rc;
127}
128
129/**
130 * cosm_stop - Prepare the MIC for reset and trigger reset
131 * @cdev: pointer to cosm_device instance
132 * @force: force a MIC to reset even if it is already reset and ready.
133 *
134 * RETURNS: None
135 */
136void cosm_stop(struct cosm_device *cdev, bool force)
137{
138	mutex_lock(&cdev->cosm_mutex);
139	if (cdev->state != MIC_READY || force) {
140		/*
141		 * Don't call hw_ops if they have been called previously.
142		 * stop(..) calls device_unregister and will crash the system if
143		 * called multiple times.
144		 */
145		u8 state = cdev->state == MIC_RESETTING ?
146					cdev->prev_state : cdev->state;
147		bool call_hw_ops = state != MIC_RESET_FAILED &&
148					state != MIC_READY;
149
150		if (cdev->state != MIC_RESETTING)
151			cosm_set_state(cdev, MIC_RESETTING);
152		cdev->heartbeat_watchdog_enable = false;
153		if (call_hw_ops)
154			cdev->hw_ops->stop(cdev, force);
155		cosm_hw_reset(cdev, force);
156		cosm_set_shutdown_status(cdev, MIC_NOP);
157		if (call_hw_ops && cdev->hw_ops->post_reset)
158			cdev->hw_ops->post_reset(cdev, cdev->state);
159	}
160	mutex_unlock(&cdev->cosm_mutex);
161	flush_work(&cdev->scif_work);
162}
163
164/**
165 * cosm_reset_trigger_work - Trigger MIC reset
166 * @work: The work structure
167 *
168 * This work is scheduled whenever the host wants to reset the MIC.
169 */
170static void cosm_reset_trigger_work(struct work_struct *work)
171{
172	struct cosm_device *cdev = container_of(work, struct cosm_device,
173						reset_trigger_work);
174	cosm_stop(cdev, false);
175}
176
177/**
178 * cosm_reset - Schedule MIC reset
179 * @cdev: pointer to cosm_device instance
180 *
181 * RETURNS: An -EINVAL if the card is already READY or 0 for success.
182 */
183int cosm_reset(struct cosm_device *cdev)
184{
185	int rc = 0;
186
187	mutex_lock(&cdev->cosm_mutex);
188	if (cdev->state != MIC_READY) {
189		if (cdev->state != MIC_RESETTING) {
190			cdev->prev_state = cdev->state;
191			cosm_set_state(cdev, MIC_RESETTING);
192			schedule_work(&cdev->reset_trigger_work);
193		}
194	} else {
195		dev_err(&cdev->dev, "%s %d MIC is READY\n", __func__, __LINE__);
196		rc = -EINVAL;
197	}
198	mutex_unlock(&cdev->cosm_mutex);
199	return rc;
200}
201
202/**
203 * cosm_shutdown - Initiate MIC shutdown.
204 * @cdev: pointer to cosm_device instance
205 *
206 * RETURNS: None
207 */
208int cosm_shutdown(struct cosm_device *cdev)
209{
210	struct cosm_msg msg = { .id = COSM_MSG_SHUTDOWN };
211	int rc = 0;
212
213	mutex_lock(&cdev->cosm_mutex);
214	if (cdev->state != MIC_ONLINE) {
215		rc = -EINVAL;
216		dev_err(&cdev->dev, "%s %d skipping shutdown in state: %s\n",
217			__func__, __LINE__, cosm_state_string[cdev->state]);
218		goto err;
219	}
220
221	if (!cdev->epd) {
222		rc = -ENOTCONN;
223		dev_err(&cdev->dev, "%s %d scif endpoint not connected rc %d\n",
224			__func__, __LINE__, rc);
225		goto err;
226	}
227
228	rc = scif_send(cdev->epd, &msg, sizeof(msg), SCIF_SEND_BLOCK);
229	if (rc < 0) {
230		dev_err(&cdev->dev, "%s %d scif_send failed rc %d\n",
231			__func__, __LINE__, rc);
232		goto err;
233	}
234	cdev->heartbeat_watchdog_enable = false;
235	cosm_set_state(cdev, MIC_SHUTTING_DOWN);
236	rc = 0;
237err:
238	mutex_unlock(&cdev->cosm_mutex);
239	return rc;
240}
241
242static int cosm_driver_probe(struct cosm_device *cdev)
243{
244	int rc;
245
246	/* Initialize SCIF server at first probe */
247	if (atomic_add_return(1, &g_num_dev) == 1) {
248		rc = cosm_scif_init();
249		if (rc)
250			goto scif_exit;
251	}
252	mutex_init(&cdev->cosm_mutex);
253	INIT_WORK(&cdev->reset_trigger_work, cosm_reset_trigger_work);
254	INIT_WORK(&cdev->scif_work, cosm_scif_work);
255	cdev->sysfs_heartbeat_enable = true;
256	cosm_sysfs_init(cdev);
257	cdev->sdev = device_create_with_groups(g_cosm_class, cdev->dev.parent,
258			       MKDEV(0, cdev->index), cdev, cdev->attr_group,
259			       "mic%d", cdev->index);
260	if (IS_ERR(cdev->sdev)) {
261		rc = PTR_ERR(cdev->sdev);
262		dev_err(&cdev->dev, "device_create_with_groups failed rc %d\n",
263			rc);
264		goto scif_exit;
265	}
266
267	cdev->state_sysfs = sysfs_get_dirent(cdev->sdev->kobj.sd,
268		"state");
269	if (!cdev->state_sysfs) {
270		rc = -ENODEV;
271		dev_err(&cdev->dev, "sysfs_get_dirent failed rc %d\n", rc);
272		goto destroy_device;
273	}
274	cosm_create_debug_dir(cdev);
275	return 0;
276destroy_device:
277	device_destroy(g_cosm_class, MKDEV(0, cdev->index));
278scif_exit:
279	if (atomic_dec_and_test(&g_num_dev))
280		cosm_scif_exit();
281	return rc;
282}
283
284static void cosm_driver_remove(struct cosm_device *cdev)
285{
286	cosm_delete_debug_dir(cdev);
287	sysfs_put(cdev->state_sysfs);
288	device_destroy(g_cosm_class, MKDEV(0, cdev->index));
289	flush_work(&cdev->reset_trigger_work);
290	cosm_stop(cdev, false);
291	if (atomic_dec_and_test(&g_num_dev))
292		cosm_scif_exit();
293
294	/* These sysfs entries might have allocated */
295	kfree(cdev->cmdline);
296	kfree(cdev->firmware);
297	kfree(cdev->ramdisk);
298	kfree(cdev->bootmode);
299}
300
301static int cosm_suspend(struct device *dev)
302{
303	struct cosm_device *cdev = dev_to_cosm(dev);
304
305	mutex_lock(&cdev->cosm_mutex);
306	switch (cdev->state) {
307	/**
308	 * Suspend/freeze hooks in userspace have already shutdown the card.
309	 * Card should be 'ready' in most cases. It is however possible that
310	 * some userspace application initiated a boot. In those cases, we
311	 * simply reset the card.
312	 */
313	case MIC_ONLINE:
314	case MIC_BOOTING:
315	case MIC_SHUTTING_DOWN:
316		mutex_unlock(&cdev->cosm_mutex);
317		cosm_stop(cdev, false);
318		break;
319	default:
320		mutex_unlock(&cdev->cosm_mutex);
321		break;
322	}
323	return 0;
324}
325
326static const struct dev_pm_ops cosm_pm_ops = {
327	.suspend = cosm_suspend,
328	.freeze = cosm_suspend
329};
330
331static struct cosm_driver cosm_driver = {
332	.driver = {
333		.name =  KBUILD_MODNAME,
334		.owner = THIS_MODULE,
335		.pm = &cosm_pm_ops,
336	},
337	.probe = cosm_driver_probe,
338	.remove = cosm_driver_remove
339};
340
341static int __init cosm_init(void)
342{
343	int ret;
344
345	cosm_init_debugfs();
346
347	g_cosm_class = class_create(THIS_MODULE, cosm_driver_name);
348	if (IS_ERR(g_cosm_class)) {
349		ret = PTR_ERR(g_cosm_class);
350		pr_err("class_create failed ret %d\n", ret);
351		goto cleanup_debugfs;
352	}
353
354	ida_init(&g_cosm_ida);
355	ret = cosm_register_driver(&cosm_driver);
356	if (ret) {
357		pr_err("cosm_register_driver failed ret %d\n", ret);
358		goto ida_destroy;
359	}
360	return 0;
361ida_destroy:
362	ida_destroy(&g_cosm_ida);
363	class_destroy(g_cosm_class);
364cleanup_debugfs:
365	cosm_exit_debugfs();
366	return ret;
367}
368
369static void __exit cosm_exit(void)
370{
371	cosm_unregister_driver(&cosm_driver);
372	ida_destroy(&g_cosm_ida);
373	class_destroy(g_cosm_class);
374	cosm_exit_debugfs();
375}
376
377module_init(cosm_init);
378module_exit(cosm_exit);
379
380MODULE_AUTHOR("Intel Corporation");
381MODULE_DESCRIPTION("Intel(R) MIC Coprocessor State Management (COSM) Driver");
382MODULE_LICENSE("GPL v2");