drivers/misc/mei/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
  26 static 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
  35 static 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
  46 static 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         pm_runtime_get_noresume(device);
 110         pm_runtime_set_active(device);
 111         pm_runtime_enable(device);
 112
 113         /* Continue to char device setup in spite of firmware handshake failure.
 114          * In order to provide access to the firmware status registers to the user
 115          * space via sysfs.
 116          */
 117         if (mei_start(dev))
 118                 dev_warn(device, "init hw failure.\n");
 119
 120         pm_runtime_set_autosuspend_delay(device, MEI_GSC_RPM_TIMEOUT);
 121         pm_runtime_use_autosuspend(device);
 122
 123         ret = mei_register(dev, device);
 124         if (ret)
 125                 goto register_err;
 126
 127         pm_runtime_put_noidle(device);
 128         return 0;
 129
 130 register_err:
 131         mei_stop(dev);
 132         if (!mei_me_hw_use_polling(hw))
 133                 devm_free_irq(device, hw->irq, dev);
 134
 135 err:
 136         dev_err(device, "probe failed: %d\n", ret);
 137         dev_set_drvdata(device, NULL);
 138         return ret;
 139 }
 140
 141 static void mei_gsc_remove(struct auxiliary_device *aux_dev)
 142 {
 143         struct mei_device *dev;
 144         struct mei_me_hw *hw;
 145
 146         dev = dev_get_drvdata(&aux_dev->dev);
 147         if (!dev)
 148                 return;
 149
 150         hw = to_me_hw(dev);
 151
 152         mei_stop(dev);
 153
 154         hw = to_me_hw(dev);
 155         if (mei_me_hw_use_polling(hw))
 156                 kthread_stop(hw->polling_thread);
 157
 158         mei_deregister(dev);
 159
 160         pm_runtime_disable(&aux_dev->dev);
 161
 162         mei_disable_interrupts(dev);
 163         if (!mei_me_hw_use_polling(hw))
 164                 devm_free_irq(&aux_dev->dev, hw->irq, dev);
 165 }
 166
 167 static int __maybe_unused mei_gsc_pm_suspend(struct device *device)
 168 {
 169         struct mei_device *dev = dev_get_drvdata(device);
 170
 171         if (!dev)
 172                 return -ENODEV;
 173
 174         mei_stop(dev);
 175
 176         mei_disable_interrupts(dev);
 177
 178         return 0;
 179 }
 180
 181 static int __maybe_unused mei_gsc_pm_resume(struct device *device)
 182 {
 183         struct mei_device *dev = dev_get_drvdata(device);
 184         struct auxiliary_device *aux_dev;
 185         struct mei_aux_device *adev;
 186         int err;
 187         struct mei_me_hw *hw;
 188
 189         if (!dev)
 190                 return -ENODEV;
 191
 192         hw = to_me_hw(dev);
 193         aux_dev = to_auxiliary_dev(device);
 194         adev = auxiliary_dev_to_mei_aux_dev(aux_dev);
 195         if (adev->ext_op_mem.start) {
 196                 mei_gsc_set_ext_op_mem(hw, &adev->ext_op_mem);
 197                 dev->pxp_mode = MEI_DEV_PXP_INIT;
 198         }
 199
 200         err = mei_restart(dev);
 201         if (err)
 202                 return err;
 203
 204         /* Start timer if stopped in suspend */
 205         schedule_delayed_work(&dev->timer_work, HZ);
 206
 207         return 0;
 208 }
 209
 210 static int __maybe_unused mei_gsc_pm_runtime_idle(struct device *device)
 211 {
 212         struct mei_device *dev = dev_get_drvdata(device);
 213
 214         if (!dev)
 215                 return -ENODEV;
 216         if (mei_write_is_idle(dev))
 217                 pm_runtime_autosuspend(device);
 218
 219         return -EBUSY;
 220 }
 221
 222 static int  __maybe_unused mei_gsc_pm_runtime_suspend(struct device *device)
 223 {
 224         struct mei_device *dev = dev_get_drvdata(device);
 225         struct mei_me_hw *hw;
 226         int ret;
 227
 228         if (!dev)
 229                 return -ENODEV;
 230
 231         mutex_lock(&dev->device_lock);
 232
 233         if (mei_write_is_idle(dev)) {
 234                 hw = to_me_hw(dev);
 235                 hw->pg_state = MEI_PG_ON;
 236
 237                 if (mei_me_hw_use_polling(hw))
 238                         hw->is_active = false;
 239                 ret = 0;
 240         } else {
 241                 ret = -EAGAIN;
 242         }
 243
 244         mutex_unlock(&dev->device_lock);
 245
 246         return ret;
 247 }
 248
 249 static int __maybe_unused mei_gsc_pm_runtime_resume(struct device *device)
 250 {
 251         struct mei_device *dev = dev_get_drvdata(device);
 252         struct mei_me_hw *hw;
 253         irqreturn_t irq_ret;
 254
 255         if (!dev)
 256                 return -ENODEV;
 257
 258         mutex_lock(&dev->device_lock);
 259
 260         hw = to_me_hw(dev);
 261         hw->pg_state = MEI_PG_OFF;
 262
 263         if (mei_me_hw_use_polling(hw)) {
 264                 hw->is_active = true;
 265                 wake_up(&hw->wait_active);
 266         }
 267
 268         mutex_unlock(&dev->device_lock);
 269
 270         irq_ret = mei_me_irq_thread_handler(1, dev);
 271         if (irq_ret != IRQ_HANDLED)
 272                 dev_err(dev->dev, "thread handler fail %d\n", irq_ret);
 273
 274         return 0;
 275 }
 276
 277 static const struct dev_pm_ops mei_gsc_pm_ops = {
 278         SET_SYSTEM_SLEEP_PM_OPS(mei_gsc_pm_suspend,
 279                                 mei_gsc_pm_resume)
 280         SET_RUNTIME_PM_OPS(mei_gsc_pm_runtime_suspend,
 281                            mei_gsc_pm_runtime_resume,
 282                            mei_gsc_pm_runtime_idle)
 283 };
 284
 285 static const struct auxiliary_device_id mei_gsc_id_table[] = {
 286         {
 287                 .name = "i915.mei-gsc",
 288                 .driver_data = MEI_ME_GSC_CFG,
 289
 290         },
 291         {
 292                 .name = "i915.mei-gscfi",
 293                 .driver_data = MEI_ME_GSCFI_CFG,
 294         },
 295         {
 296                 /* sentinel */
 297         }
 298 };
 299 MODULE_DEVICE_TABLE(auxiliary, mei_gsc_id_table);
 300
 301 static struct auxiliary_driver mei_gsc_driver = {
 302         .probe  = mei_gsc_probe,
 303         .remove = mei_gsc_remove,
 304         .driver = {
 305                 /* auxiliary_driver_register() sets .name to be the modname */
 306                 .pm = &mei_gsc_pm_ops,
 307         },
 308         .id_table = mei_gsc_id_table
 309 };
 310 module_auxiliary_driver(mei_gsc_driver);
 311
 312 MODULE_AUTHOR("Intel Corporation");
 313 MODULE_ALIAS("auxiliary:i915.mei-gsc");
 314 MODULE_ALIAS("auxiliary:i915.mei-gscfi");
 315 MODULE_LICENSE("GPL");