gsc-me.c

  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Copyright(c) 2019-2022, Intel Corporation. All rights reserved.
  4 *
  5 * Intel Management Engine Interface (Intel MEI) Linux driver
  6 */
  7
  8#include <linux/module.h>
  9#include <linux/mei_aux.h>
 10#include <linux/device.h>
 11#include <linux/irqreturn.h>
 12#include <linux/jiffies.h>
 13#include <linux/ktime.h>
 14#include <linux/delay.h>
 15#include <linux/pm_runtime.h>
 16#include <linux/kthread.h>
 17
 18#include "mei_dev.h"
 19#include "hw-me.h"
 20#include "hw-me-regs.h"
 21
 22#include "mei-trace.h"
 23
 24#define MEI_GSC_RPM_TIMEOUT 500
 25
 26static int mei_gsc_read_hfs(const struct mei_device *dev, int where, u32 *val)
 27{
 28	struct mei_me_hw *hw = to_me_hw(dev);
 29
 30	*val = ioread32(hw->mem_addr + where + 0xC00);
 31
 32	return 0;
 33}
 34
 35static void mei_gsc_set_ext_op_mem(const struct mei_me_hw *hw, struct resource *mem)
 36{
 37	u32 low = lower_32_bits(mem->start);
 38	u32 hi  = upper_32_bits(mem->start);
 39	u32 limit = (resource_size(mem) / SZ_4K) | GSC_EXT_OP_MEM_VALID;
 40
 41	iowrite32(low, hw->mem_addr + H_GSC_EXT_OP_MEM_BASE_ADDR_LO_REG);
 42	iowrite32(hi, hw->mem_addr + H_GSC_EXT_OP_MEM_BASE_ADDR_HI_REG);
 43	iowrite32(limit, hw->mem_addr + H_GSC_EXT_OP_MEM_LIMIT_REG);
 44}
 45
 46static int mei_gsc_probe(struct auxiliary_device *aux_dev,
 47			 const struct auxiliary_device_id *aux_dev_id)
 48{
 49	struct mei_aux_device *adev = auxiliary_dev_to_mei_aux_dev(aux_dev);
 50	struct mei_device *dev;
 51	struct mei_me_hw *hw;
 52	struct device *device;
 53	const struct mei_cfg *cfg;
 54	int ret;
 55
 56	cfg = mei_me_get_cfg(aux_dev_id->driver_data);
 57	if (!cfg)
 58		return -ENODEV;
 59
 60	device = &aux_dev->dev;
 61
 62	dev = mei_me_dev_init(device, cfg, adev->slow_firmware);
 63	if (!dev) {
 64		ret = -ENOMEM;
 65		goto err;
 66	}
 67
 68	hw = to_me_hw(dev);
 69	hw->mem_addr = devm_ioremap_resource(device, &adev->bar);
 70	if (IS_ERR(hw->mem_addr)) {
 71		ret = PTR_ERR(hw->mem_addr);
 72		goto err;
 73	}
 74
 75	hw->irq = adev->irq;
 76	hw->read_fws = mei_gsc_read_hfs;
 77
 78	dev_set_drvdata(device, dev);
 79
 80	if (adev->ext_op_mem.start) {
 81		mei_gsc_set_ext_op_mem(hw, &adev->ext_op_mem);
 82		dev->pxp_mode = MEI_DEV_PXP_INIT;
 83	}
 84
 85	/* use polling */
 86	if (mei_me_hw_use_polling(hw)) {
 87		mei_disable_interrupts(dev);
 88		mei_clear_interrupts(dev);
 89		init_waitqueue_head(&hw->wait_active);
 90		hw->is_active = true; /* start in active mode for initialization */
 91		hw->polling_thread = kthread_run(mei_me_polling_thread, dev,
 92						 "kmegscirqd/%s", dev_name(device));
 93		if (IS_ERR(hw->polling_thread)) {
 94			ret = PTR_ERR(hw->polling_thread);
 95			dev_err(device, "unable to create kernel thread: %d\n", ret);
 96			goto err;
 97		}
 98	} else {
 99		ret = devm_request_threaded_irq(device, hw->irq,
100						mei_me_irq_quick_handler,
101						mei_me_irq_thread_handler,
102						IRQF_ONESHOT, KBUILD_MODNAME, dev);
103		if (ret) {
104			dev_err(device, "irq register failed %d\n", ret);
105			goto err;
106		}
107	}
108
109	ret = mei_register(dev, device);
110	if (ret)
111		goto deinterrupt;
112
113	pm_runtime_get_noresume(device);
114	pm_runtime_set_active(device);
115	pm_runtime_enable(device);
116
117	/* Continue in spite of firmware handshake failure.
118	 * In order to provide access to the firmware status registers to the user
119	 * space via sysfs.
120	 */
121	if (mei_start(dev))
122		dev_warn(device, "init hw failure.\n");
123
124	pm_runtime_set_autosuspend_delay(device, MEI_GSC_RPM_TIMEOUT);
125	pm_runtime_use_autosuspend(device);
126
127	pm_runtime_put_noidle(device);
128	return 0;
129
130deinterrupt:
131	if (!mei_me_hw_use_polling(hw))
132		devm_free_irq(device, hw->irq, dev);
133err:
134	dev_err(device, "probe failed: %d\n", ret);
135	dev_set_drvdata(device, NULL);
136	return ret;
137}
138
139static void mei_gsc_remove(struct auxiliary_device *aux_dev)
140{
141	struct mei_device *dev;
142	struct mei_me_hw *hw;
143
144	dev = dev_get_drvdata(&aux_dev->dev);
145	hw = to_me_hw(dev);
146
147	mei_stop(dev);
148
149	hw = to_me_hw(dev);
150	if (mei_me_hw_use_polling(hw))
151		kthread_stop(hw->polling_thread);
152
153	pm_runtime_disable(&aux_dev->dev);
154
155	mei_disable_interrupts(dev);
156	if (!mei_me_hw_use_polling(hw))
157		devm_free_irq(&aux_dev->dev, hw->irq, dev);
158
159	mei_deregister(dev);
160}
161
162static int __maybe_unused mei_gsc_pm_suspend(struct device *device)
163{
164	struct mei_device *dev = dev_get_drvdata(device);
165
166	mei_stop(dev);
167
168	mei_disable_interrupts(dev);
169
170	return 0;
171}
172
173static int __maybe_unused mei_gsc_pm_resume(struct device *device)
174{
175	struct mei_device *dev = dev_get_drvdata(device);
176	struct auxiliary_device *aux_dev;
177	struct mei_aux_device *adev;
178	int err;
179	struct mei_me_hw *hw;
180
181	hw = to_me_hw(dev);
182	aux_dev = to_auxiliary_dev(device);
183	adev = auxiliary_dev_to_mei_aux_dev(aux_dev);
184	if (adev->ext_op_mem.start) {
185		mei_gsc_set_ext_op_mem(hw, &adev->ext_op_mem);
186		dev->pxp_mode = MEI_DEV_PXP_INIT;
187	}
188
189	err = mei_restart(dev);
190	if (err)
191		return err;
192
193	/* Start timer if stopped in suspend */
194	schedule_delayed_work(&dev->timer_work, HZ);
195
196	return 0;
197}
198
199static int __maybe_unused mei_gsc_pm_runtime_idle(struct device *device)
200{
201	struct mei_device *dev = dev_get_drvdata(device);
202
203	if (mei_write_is_idle(dev))
204		pm_runtime_autosuspend(device);
205
206	return -EBUSY;
207}
208
209static int  __maybe_unused mei_gsc_pm_runtime_suspend(struct device *device)
210{
211	struct mei_device *dev = dev_get_drvdata(device);
212	struct mei_me_hw *hw;
213	int ret;
214
215	mutex_lock(&dev->device_lock);
216
217	if (mei_write_is_idle(dev)) {
218		hw = to_me_hw(dev);
219		hw->pg_state = MEI_PG_ON;
220
221		if (mei_me_hw_use_polling(hw))
222			hw->is_active = false;
223		ret = 0;
224	} else {
225		ret = -EAGAIN;
226	}
227
228	mutex_unlock(&dev->device_lock);
229
230	return ret;
231}
232
233static int __maybe_unused mei_gsc_pm_runtime_resume(struct device *device)
234{
235	struct mei_device *dev = dev_get_drvdata(device);
236	struct mei_me_hw *hw;
237	irqreturn_t irq_ret;
238
239	mutex_lock(&dev->device_lock);
240
241	hw = to_me_hw(dev);
242	hw->pg_state = MEI_PG_OFF;
243
244	if (mei_me_hw_use_polling(hw)) {
245		hw->is_active = true;
246		wake_up(&hw->wait_active);
247	}
248
249	mutex_unlock(&dev->device_lock);
250
251	irq_ret = mei_me_irq_thread_handler(1, dev);
252	if (irq_ret != IRQ_HANDLED)
253		dev_err(&dev->dev, "thread handler fail %d\n", irq_ret);
254
255	return 0;
256}
257
258static const struct dev_pm_ops mei_gsc_pm_ops = {
259	SET_SYSTEM_SLEEP_PM_OPS(mei_gsc_pm_suspend,
260				mei_gsc_pm_resume)
261	SET_RUNTIME_PM_OPS(mei_gsc_pm_runtime_suspend,
262			   mei_gsc_pm_runtime_resume,
263			   mei_gsc_pm_runtime_idle)
264};
265
266static const struct auxiliary_device_id mei_gsc_id_table[] = {
267	{
268		.name = "i915.mei-gsc",
269		.driver_data = MEI_ME_GSC_CFG,
270
271	},
272	{
273		.name = "i915.mei-gscfi",
274		.driver_data = MEI_ME_GSCFI_CFG,
275	},
276	{
277		.name = "xe.mei-gscfi",
278		.driver_data = MEI_ME_GSCFI_CFG,
279	},
280	{
281		/* sentinel */
282	}
283};
284MODULE_DEVICE_TABLE(auxiliary, mei_gsc_id_table);
285
286static struct auxiliary_driver mei_gsc_driver = {
287	.probe	= mei_gsc_probe,
288	.remove = mei_gsc_remove,
289	.driver = {
290		/* auxiliary_driver_register() sets .name to be the modname */
291		.pm = &mei_gsc_pm_ops,
292	},
293	.id_table = mei_gsc_id_table
294};
295module_auxiliary_driver(mei_gsc_driver);
296
297MODULE_AUTHOR("Intel Corporation");
298MODULE_ALIAS("auxiliary:i915.mei-gsc");
299MODULE_ALIAS("auxiliary:i915.mei-gscfi");
300MODULE_ALIAS("auxiliary:xe.mei-gscfi");
301MODULE_DESCRIPTION("Intel(R) Graphics System Controller");
302MODULE_LICENSE("GPL");