1 /* 2 * 3 * Intel Management Engine Interface (Intel MEI) Linux driver 4 * Copyright (c) 2013-2014, Intel Corporation. 5 * 6 * This program is free software; you can redistribute it and/or modify it 7 * under the terms and conditions of the GNU General Public License, 8 * version 2, as published by the Free Software Foundation. 9 * 10 * This program is distributed in the hope it will be useful, but WITHOUT 11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 13 * more details. 14 * 15 */ 16 17 #include <linux/module.h> 18 #include <linux/kernel.h> 19 #include <linux/device.h> 20 #include <linux/fs.h> 21 #include <linux/errno.h> 22 #include <linux/types.h> 23 #include <linux/pci.h> 24 #include <linux/init.h> 25 #include <linux/sched.h> 26 #include <linux/uuid.h> 27 #include <linux/jiffies.h> 28 #include <linux/interrupt.h> 29 #include <linux/workqueue.h> 30 #include <linux/pm_domain.h> 31 #include <linux/pm_runtime.h> 32 33 #include <linux/mei.h> 34 35 36 #include "mei_dev.h" 37 #include "hw-txe.h" 38 39 static const struct pci_device_id mei_txe_pci_tbl[] = { 40 {PCI_VDEVICE(INTEL, 0x0F18)}, /* Baytrail */ 41 {PCI_VDEVICE(INTEL, 0x2298)}, /* Cherrytrail */ 42 43 {0, } 44 }; 45 MODULE_DEVICE_TABLE(pci, mei_txe_pci_tbl); 46 47 #ifdef CONFIG_PM 48 static inline void mei_txe_set_pm_domain(struct mei_device *dev); 49 static inline void mei_txe_unset_pm_domain(struct mei_device *dev); 50 #else 51 static inline void mei_txe_set_pm_domain(struct mei_device *dev) {} 52 static inline void mei_txe_unset_pm_domain(struct mei_device *dev) {} 53 #endif /* CONFIG_PM */ 54 55 /** 56 * mei_txe_probe - Device Initialization Routine 57 * 58 * @pdev: PCI device structure 59 * @ent: entry in mei_txe_pci_tbl 60 * 61 * Return: 0 on success, <0 on failure. 62 */ 63 static int mei_txe_probe(struct pci_dev *pdev, const struct pci_device_id *ent) 64 { 65 struct mei_device *dev; 66 struct mei_txe_hw *hw; 67 const int mask = BIT(SEC_BAR) | BIT(BRIDGE_BAR); 68 int err; 69 70 /* enable pci dev */ 71 err = pcim_enable_device(pdev); 72 if (err) { 73 dev_err(&pdev->dev, "failed to enable pci device.\n"); 74 goto end; 75 } 76 /* set PCI host mastering */ 77 pci_set_master(pdev); 78 /* pci request regions and mapping IO device memory for mei driver */ 79 err = pcim_iomap_regions(pdev, mask, KBUILD_MODNAME); 80 if (err) { 81 dev_err(&pdev->dev, "failed to get pci regions.\n"); 82 goto end; 83 } 84 85 err = pci_set_dma_mask(pdev, DMA_BIT_MASK(36)); 86 if (err) { 87 err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32)); 88 if (err) { 89 dev_err(&pdev->dev, "No suitable DMA available.\n"); 90 goto end; 91 } 92 } 93 94 /* allocates and initializes the mei dev structure */ 95 dev = mei_txe_dev_init(pdev); 96 if (!dev) { 97 err = -ENOMEM; 98 goto end; 99 } 100 hw = to_txe_hw(dev); 101 hw->mem_addr = pcim_iomap_table(pdev); 102 103 pci_enable_msi(pdev); 104 105 /* clear spurious interrupts */ 106 mei_clear_interrupts(dev); 107 108 /* request and enable interrupt */ 109 if (pci_dev_msi_enabled(pdev)) 110 err = request_threaded_irq(pdev->irq, 111 NULL, 112 mei_txe_irq_thread_handler, 113 IRQF_ONESHOT, KBUILD_MODNAME, dev); 114 else 115 err = request_threaded_irq(pdev->irq, 116 mei_txe_irq_quick_handler, 117 mei_txe_irq_thread_handler, 118 IRQF_SHARED, KBUILD_MODNAME, dev); 119 if (err) { 120 dev_err(&pdev->dev, "mei: request_threaded_irq failure. irq = %d\n", 121 pdev->irq); 122 goto end; 123 } 124 125 if (mei_start(dev)) { 126 dev_err(&pdev->dev, "init hw failure.\n"); 127 err = -ENODEV; 128 goto release_irq; 129 } 130 131 pm_runtime_set_autosuspend_delay(&pdev->dev, MEI_TXI_RPM_TIMEOUT); 132 pm_runtime_use_autosuspend(&pdev->dev); 133 134 err = mei_register(dev, &pdev->dev); 135 if (err) 136 goto stop; 137 138 pci_set_drvdata(pdev, dev); 139 140 /* 141 * MEI requires to resume from runtime suspend mode 142 * in order to perform link reset flow upon system suspend. 143 */ 144 pdev->dev_flags |= PCI_DEV_FLAGS_NEEDS_RESUME; 145 146 /* 147 * TXE maps runtime suspend/resume to own power gating states, 148 * hence we need to go around native PCI runtime service which 149 * eventually brings the device into D3cold/hot state. 150 * But the TXE device cannot wake up from D3 unlike from own 151 * power gating. To get around PCI device native runtime pm, 152 * TXE uses runtime pm domain handlers which take precedence. 153 */ 154 mei_txe_set_pm_domain(dev); 155 156 pm_runtime_put_noidle(&pdev->dev); 157 158 return 0; 159 160 stop: 161 mei_stop(dev); 162 release_irq: 163 mei_cancel_work(dev); 164 mei_disable_interrupts(dev); 165 free_irq(pdev->irq, dev); 166 end: 167 dev_err(&pdev->dev, "initialization failed.\n"); 168 return err; 169 } 170 171 /** 172 * mei_txe_remove - Device Shutdown Routine 173 * 174 * @pdev: PCI device structure 175 * 176 * mei_txe_shutdown is called from the reboot notifier 177 * it's a simplified version of remove so we go down 178 * faster. 179 */ 180 static void mei_txe_shutdown(struct pci_dev *pdev) 181 { 182 struct mei_device *dev; 183 184 dev = pci_get_drvdata(pdev); 185 if (!dev) 186 return; 187 188 dev_dbg(&pdev->dev, "shutdown\n"); 189 mei_stop(dev); 190 191 mei_txe_unset_pm_domain(dev); 192 193 mei_disable_interrupts(dev); 194 free_irq(pdev->irq, dev); 195 } 196 197 /** 198 * mei_txe_remove - Device Removal Routine 199 * 200 * @pdev: PCI device structure 201 * 202 * mei_remove is called by the PCI subsystem to alert the driver 203 * that it should release a PCI device. 204 */ 205 static void mei_txe_remove(struct pci_dev *pdev) 206 { 207 struct mei_device *dev; 208 209 dev = pci_get_drvdata(pdev); 210 if (!dev) { 211 dev_err(&pdev->dev, "mei: dev == NULL\n"); 212 return; 213 } 214 215 pm_runtime_get_noresume(&pdev->dev); 216 217 mei_stop(dev); 218 219 mei_txe_unset_pm_domain(dev); 220 221 mei_disable_interrupts(dev); 222 free_irq(pdev->irq, dev); 223 224 mei_deregister(dev); 225 } 226 227 228 #ifdef CONFIG_PM_SLEEP 229 static int mei_txe_pci_suspend(struct device *device) 230 { 231 struct pci_dev *pdev = to_pci_dev(device); 232 struct mei_device *dev = pci_get_drvdata(pdev); 233 234 if (!dev) 235 return -ENODEV; 236 237 dev_dbg(&pdev->dev, "suspend\n"); 238 239 mei_stop(dev); 240 241 mei_disable_interrupts(dev); 242 243 free_irq(pdev->irq, dev); 244 pci_disable_msi(pdev); 245 246 return 0; 247 } 248 249 static int mei_txe_pci_resume(struct device *device) 250 { 251 struct pci_dev *pdev = to_pci_dev(device); 252 struct mei_device *dev; 253 int err; 254 255 dev = pci_get_drvdata(pdev); 256 if (!dev) 257 return -ENODEV; 258 259 pci_enable_msi(pdev); 260 261 mei_clear_interrupts(dev); 262 263 /* request and enable interrupt */ 264 if (pci_dev_msi_enabled(pdev)) 265 err = request_threaded_irq(pdev->irq, 266 NULL, 267 mei_txe_irq_thread_handler, 268 IRQF_ONESHOT, KBUILD_MODNAME, dev); 269 else 270 err = request_threaded_irq(pdev->irq, 271 mei_txe_irq_quick_handler, 272 mei_txe_irq_thread_handler, 273 IRQF_SHARED, KBUILD_MODNAME, dev); 274 if (err) { 275 dev_err(&pdev->dev, "request_threaded_irq failed: irq = %d.\n", 276 pdev->irq); 277 return err; 278 } 279 280 err = mei_restart(dev); 281 282 return err; 283 } 284 #endif /* CONFIG_PM_SLEEP */ 285 286 #ifdef CONFIG_PM 287 static int mei_txe_pm_runtime_idle(struct device *device) 288 { 289 struct pci_dev *pdev = to_pci_dev(device); 290 struct mei_device *dev; 291 292 dev_dbg(&pdev->dev, "rpm: txe: runtime_idle\n"); 293 294 dev = pci_get_drvdata(pdev); 295 if (!dev) 296 return -ENODEV; 297 if (mei_write_is_idle(dev)) 298 pm_runtime_autosuspend(device); 299 300 return -EBUSY; 301 } 302 static int mei_txe_pm_runtime_suspend(struct device *device) 303 { 304 struct pci_dev *pdev = to_pci_dev(device); 305 struct mei_device *dev; 306 int ret; 307 308 dev_dbg(&pdev->dev, "rpm: txe: runtime suspend\n"); 309 310 dev = pci_get_drvdata(pdev); 311 if (!dev) 312 return -ENODEV; 313 314 mutex_lock(&dev->device_lock); 315 316 if (mei_write_is_idle(dev)) 317 ret = mei_txe_aliveness_set_sync(dev, 0); 318 else 319 ret = -EAGAIN; 320 321 /* keep irq on we are staying in D0 */ 322 323 dev_dbg(&pdev->dev, "rpm: txe: runtime suspend ret=%d\n", ret); 324 325 mutex_unlock(&dev->device_lock); 326 327 if (ret && ret != -EAGAIN) 328 schedule_work(&dev->reset_work); 329 330 return ret; 331 } 332 333 static int mei_txe_pm_runtime_resume(struct device *device) 334 { 335 struct pci_dev *pdev = to_pci_dev(device); 336 struct mei_device *dev; 337 int ret; 338 339 dev_dbg(&pdev->dev, "rpm: txe: runtime resume\n"); 340 341 dev = pci_get_drvdata(pdev); 342 if (!dev) 343 return -ENODEV; 344 345 mutex_lock(&dev->device_lock); 346 347 mei_enable_interrupts(dev); 348 349 ret = mei_txe_aliveness_set_sync(dev, 1); 350 351 mutex_unlock(&dev->device_lock); 352 353 dev_dbg(&pdev->dev, "rpm: txe: runtime resume ret = %d\n", ret); 354 355 if (ret) 356 schedule_work(&dev->reset_work); 357 358 return ret; 359 } 360 361 /** 362 * mei_txe_set_pm_domain - fill and set pm domain structure for device 363 * 364 * @dev: mei_device 365 */ 366 static inline void mei_txe_set_pm_domain(struct mei_device *dev) 367 { 368 struct pci_dev *pdev = to_pci_dev(dev->dev); 369 370 if (pdev->dev.bus && pdev->dev.bus->pm) { 371 dev->pg_domain.ops = *pdev->dev.bus->pm; 372 373 dev->pg_domain.ops.runtime_suspend = mei_txe_pm_runtime_suspend; 374 dev->pg_domain.ops.runtime_resume = mei_txe_pm_runtime_resume; 375 dev->pg_domain.ops.runtime_idle = mei_txe_pm_runtime_idle; 376 377 dev_pm_domain_set(&pdev->dev, &dev->pg_domain); 378 } 379 } 380 381 /** 382 * mei_txe_unset_pm_domain - clean pm domain structure for device 383 * 384 * @dev: mei_device 385 */ 386 static inline void mei_txe_unset_pm_domain(struct mei_device *dev) 387 { 388 /* stop using pm callbacks if any */ 389 dev_pm_domain_set(dev->dev, NULL); 390 } 391 392 static const struct dev_pm_ops mei_txe_pm_ops = { 393 SET_SYSTEM_SLEEP_PM_OPS(mei_txe_pci_suspend, 394 mei_txe_pci_resume) 395 SET_RUNTIME_PM_OPS( 396 mei_txe_pm_runtime_suspend, 397 mei_txe_pm_runtime_resume, 398 mei_txe_pm_runtime_idle) 399 }; 400 401 #define MEI_TXE_PM_OPS (&mei_txe_pm_ops) 402 #else 403 #define MEI_TXE_PM_OPS NULL 404 #endif /* CONFIG_PM */ 405 406 /* 407 * PCI driver structure 408 */ 409 static struct pci_driver mei_txe_driver = { 410 .name = KBUILD_MODNAME, 411 .id_table = mei_txe_pci_tbl, 412 .probe = mei_txe_probe, 413 .remove = mei_txe_remove, 414 .shutdown = mei_txe_shutdown, 415 .driver.pm = MEI_TXE_PM_OPS, 416 }; 417 418 module_pci_driver(mei_txe_driver); 419 420 MODULE_AUTHOR("Intel Corporation"); 421 MODULE_DESCRIPTION("Intel(R) Trusted Execution Environment Interface"); 422 MODULE_LICENSE("GPL v2"); 423