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
  17 #include "mei_dev.h"
  18 #include "hw-me.h"
  19 #include "hw-me-regs.h"
  20
  21 #include "mei-trace.h"
  22
  23 #define MEI_GSC_RPM_TIMEOUT 500
  24
  25 static int mei_gsc_read_hfs(const struct mei_device *dev, int where, u32 *val)
  26 {
  27         struct mei_me_hw *hw = to_me_hw(dev);
  28
  29         *val = ioread32(hw->mem_addr + where + 0xC00);
  30
  31         return 0;
  32 }
  33
  34 static int mei_gsc_probe(struct auxiliary_device *aux_dev,
  35                          const struct auxiliary_device_id *aux_dev_id)
  36 {
  37         struct mei_aux_device *adev = auxiliary_dev_to_mei_aux_dev(aux_dev);
  38         struct mei_device *dev;
  39         struct mei_me_hw *hw;
  40         struct device *device;
  41         const struct mei_cfg *cfg;
  42         int ret;
  43
  44         cfg = mei_me_get_cfg(aux_dev_id->driver_data);
  45         if (!cfg)
  46                 return -ENODEV;
  47
  48         device = &aux_dev->dev;
  49
  50         dev = mei_me_dev_init(device, cfg);
  51         if (!dev) {
  52                 ret = -ENOMEM;
  53                 goto err;
  54         }
  55
  56         hw = to_me_hw(dev);
  57         hw->mem_addr = devm_ioremap_resource(device, &adev->bar);
  58         if (IS_ERR(hw->mem_addr)) {
  59                 dev_err(device, "mmio not mapped\n");
  60                 ret = PTR_ERR(hw->mem_addr);
  61                 goto err;
  62         }
  63
  64         hw->irq = adev->irq;
  65         hw->read_fws = mei_gsc_read_hfs;
  66
  67         dev_set_drvdata(device, dev);
  68
  69         ret = devm_request_threaded_irq(device, hw->irq,
  70                                         mei_me_irq_quick_handler,
  71                                         mei_me_irq_thread_handler,
  72                                         IRQF_ONESHOT, KBUILD_MODNAME, dev);
  73         if (ret) {
  74                 dev_err(device, "irq register failed %d\n", ret);
  75                 goto err;
  76         }
  77
  78         pm_runtime_get_noresume(device);
  79         pm_runtime_set_active(device);
  80         pm_runtime_enable(device);
  81
  82         /* Continue to char device setup in spite of firmware handshake failure.
  83          * In order to provide access to the firmware status registers to the user
  84          * space via sysfs.
  85          */
  86         if (mei_start(dev))
  87                 dev_warn(device, "init hw failure.\n");
  88
  89         pm_runtime_set_autosuspend_delay(device, MEI_GSC_RPM_TIMEOUT);
  90         pm_runtime_use_autosuspend(device);
  91
  92         ret = mei_register(dev, device);
  93         if (ret)
  94                 goto register_err;
  95
  96         pm_runtime_put_noidle(device);
  97         return 0;
  98
  99 register_err:
 100         mei_stop(dev);
 101         devm_free_irq(device, hw->irq, dev);
 102
 103 err:
 104         dev_err(device, "probe failed: %d\n", ret);
 105         dev_set_drvdata(device, NULL);
 106         return ret;
 107 }
 108
 109 static void mei_gsc_remove(struct auxiliary_device *aux_dev)
 110 {
 111         struct mei_device *dev;
 112         struct mei_me_hw *hw;
 113
 114         dev = dev_get_drvdata(&aux_dev->dev);
 115         if (!dev)
 116                 return;
 117
 118         hw = to_me_hw(dev);
 119
 120         mei_stop(dev);
 121
 122         mei_deregister(dev);
 123
 124         pm_runtime_disable(&aux_dev->dev);
 125
 126         mei_disable_interrupts(dev);
 127         devm_free_irq(&aux_dev->dev, hw->irq, dev);
 128 }
 129
 130 static int __maybe_unused mei_gsc_pm_suspend(struct device *device)
 131 {
 132         struct mei_device *dev = dev_get_drvdata(device);
 133
 134         if (!dev)
 135                 return -ENODEV;
 136
 137         mei_stop(dev);
 138
 139         mei_disable_interrupts(dev);
 140
 141         return 0;
 142 }
 143
 144 static int __maybe_unused mei_gsc_pm_resume(struct device *device)
 145 {
 146         struct mei_device *dev = dev_get_drvdata(device);
 147         int err;
 148
 149         if (!dev)
 150                 return -ENODEV;
 151
 152         err = mei_restart(dev);
 153         if (err)
 154                 return err;
 155
 156         /* Start timer if stopped in suspend */
 157         schedule_delayed_work(&dev->timer_work, HZ);
 158
 159         return 0;
 160 }
 161
 162 static int __maybe_unused mei_gsc_pm_runtime_idle(struct device *device)
 163 {
 164         struct mei_device *dev = dev_get_drvdata(device);
 165
 166         if (!dev)
 167                 return -ENODEV;
 168         if (mei_write_is_idle(dev))
 169                 pm_runtime_autosuspend(device);
 170
 171         return -EBUSY;
 172 }
 173
 174 static int  __maybe_unused mei_gsc_pm_runtime_suspend(struct device *device)
 175 {
 176         struct mei_device *dev = dev_get_drvdata(device);
 177         struct mei_me_hw *hw;
 178         int ret;
 179
 180         if (!dev)
 181                 return -ENODEV;
 182
 183         mutex_lock(&dev->device_lock);
 184
 185         if (mei_write_is_idle(dev)) {
 186                 hw = to_me_hw(dev);
 187                 hw->pg_state = MEI_PG_ON;
 188                 ret = 0;
 189         } else {
 190                 ret = -EAGAIN;
 191         }
 192
 193         mutex_unlock(&dev->device_lock);
 194
 195         return ret;
 196 }
 197
 198 static int __maybe_unused mei_gsc_pm_runtime_resume(struct device *device)
 199 {
 200         struct mei_device *dev = dev_get_drvdata(device);
 201         struct mei_me_hw *hw;
 202         irqreturn_t irq_ret;
 203
 204         if (!dev)
 205                 return -ENODEV;
 206
 207         mutex_lock(&dev->device_lock);
 208
 209         hw = to_me_hw(dev);
 210         hw->pg_state = MEI_PG_OFF;
 211
 212         mutex_unlock(&dev->device_lock);
 213
 214         irq_ret = mei_me_irq_thread_handler(1, dev);
 215         if (irq_ret != IRQ_HANDLED)
 216                 dev_err(dev->dev, "thread handler fail %d\n", irq_ret);
 217
 218         return 0;
 219 }
 220
 221 static const struct dev_pm_ops mei_gsc_pm_ops = {
 222         SET_SYSTEM_SLEEP_PM_OPS(mei_gsc_pm_suspend,
 223                                 mei_gsc_pm_resume)
 224         SET_RUNTIME_PM_OPS(mei_gsc_pm_runtime_suspend,
 225                            mei_gsc_pm_runtime_resume,
 226                            mei_gsc_pm_runtime_idle)
 227 };
 228
 229 static const struct auxiliary_device_id mei_gsc_id_table[] = {
 230         {
 231                 .name = "i915.mei-gsc",
 232                 .driver_data = MEI_ME_GSC_CFG,
 233
 234         },
 235         {
 236                 .name = "i915.mei-gscfi",
 237                 .driver_data = MEI_ME_GSCFI_CFG,
 238         },
 239         {
 240                 /* sentinel */
 241         }
 242 };
 243 MODULE_DEVICE_TABLE(auxiliary, mei_gsc_id_table);
 244
 245 static struct auxiliary_driver mei_gsc_driver = {
 246         .probe  = mei_gsc_probe,
 247         .remove = mei_gsc_remove,
 248         .driver = {
 249                 /* auxiliary_driver_register() sets .name to be the modname */
 250                 .pm = &mei_gsc_pm_ops,
 251         },
 252         .id_table = mei_gsc_id_table
 253 };
 254 module_auxiliary_driver(mei_gsc_driver);
 255
 256 MODULE_AUTHOR("Intel Corporation");
 257 MODULE_ALIAS("auxiliary:i915.mei-gsc");
 258 MODULE_ALIAS("auxiliary:i915.mei-gscfi");
 259 MODULE_LICENSE("GPL");