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 * For not wake-able HW runtime pm framework 148 * can't be used on pci device level. 149 * Use domain runtime pm callbacks instead. 150 */ 151 if (!pci_dev_run_wake(pdev)) 152 mei_txe_set_pm_domain(dev); 153 154 pm_runtime_put_noidle(&pdev->dev); 155 156 return 0; 157 158 stop: 159 mei_stop(dev); 160 release_irq: 161 mei_cancel_work(dev); 162 mei_disable_interrupts(dev); 163 free_irq(pdev->irq, dev); 164 end: 165 dev_err(&pdev->dev, "initialization failed.\n"); 166 return err; 167 } 168 169 /** 170 * mei_txe_remove - Device Shutdown Routine 171 * 172 * @pdev: PCI device structure 173 * 174 * mei_txe_shutdown is called from the reboot notifier 175 * it's a simplified version of remove so we go down 176 * faster. 177 */ 178 static void mei_txe_shutdown(struct pci_dev *pdev) 179 { 180 struct mei_device *dev; 181 182 dev = pci_get_drvdata(pdev); 183 if (!dev) 184 return; 185 186 dev_dbg(&pdev->dev, "shutdown\n"); 187 mei_stop(dev); 188 189 if (!pci_dev_run_wake(pdev)) 190 mei_txe_unset_pm_domain(dev); 191 192 mei_disable_interrupts(dev); 193 free_irq(pdev->irq, dev); 194 } 195 196 /** 197 * mei_txe_remove - Device Removal Routine 198 * 199 * @pdev: PCI device structure 200 * 201 * mei_remove is called by the PCI subsystem to alert the driver 202 * that it should release a PCI device. 203 */ 204 static void mei_txe_remove(struct pci_dev *pdev) 205 { 206 struct mei_device *dev; 207 208 dev = pci_get_drvdata(pdev); 209 if (!dev) { 210 dev_err(&pdev->dev, "mei: dev == NULL\n"); 211 return; 212 } 213 214 pm_runtime_get_noresume(&pdev->dev); 215 216 mei_stop(dev); 217 218 if (!pci_dev_run_wake(pdev)) 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 /* 322 * If everything is okay we're about to enter PCI low 323 * power state (D3) therefor we need to disable the 324 * interrupts towards host. 325 * However if device is not wakeable we do not enter 326 * D-low state and we need to keep the interrupt kicking 327 */ 328 if (!ret && pci_dev_run_wake(pdev)) 329 mei_disable_interrupts(dev); 330 331 dev_dbg(&pdev->dev, "rpm: txe: runtime suspend ret=%d\n", ret); 332 333 mutex_unlock(&dev->device_lock); 334 335 if (ret && ret != -EAGAIN) 336 schedule_work(&dev->reset_work); 337 338 return ret; 339 } 340 341 static int mei_txe_pm_runtime_resume(struct device *device) 342 { 343 struct pci_dev *pdev = to_pci_dev(device); 344 struct mei_device *dev; 345 int ret; 346 347 dev_dbg(&pdev->dev, "rpm: txe: runtime resume\n"); 348 349 dev = pci_get_drvdata(pdev); 350 if (!dev) 351 return -ENODEV; 352 353 mutex_lock(&dev->device_lock); 354 355 mei_enable_interrupts(dev); 356 357 ret = mei_txe_aliveness_set_sync(dev, 1); 358 359 mutex_unlock(&dev->device_lock); 360 361 dev_dbg(&pdev->dev, "rpm: txe: runtime resume ret = %d\n", ret); 362 363 if (ret) 364 schedule_work(&dev->reset_work); 365 366 return ret; 367 } 368 369 /** 370 * mei_txe_set_pm_domain - fill and set pm domain structure for device 371 * 372 * @dev: mei_device 373 */ 374 static inline void mei_txe_set_pm_domain(struct mei_device *dev) 375 { 376 struct pci_dev *pdev = to_pci_dev(dev->dev); 377 378 if (pdev->dev.bus && pdev->dev.bus->pm) { 379 dev->pg_domain.ops = *pdev->dev.bus->pm; 380 381 dev->pg_domain.ops.runtime_suspend = mei_txe_pm_runtime_suspend; 382 dev->pg_domain.ops.runtime_resume = mei_txe_pm_runtime_resume; 383 dev->pg_domain.ops.runtime_idle = mei_txe_pm_runtime_idle; 384 385 dev_pm_domain_set(&pdev->dev, &dev->pg_domain); 386 } 387 } 388 389 /** 390 * mei_txe_unset_pm_domain - clean pm domain structure for device 391 * 392 * @dev: mei_device 393 */ 394 static inline void mei_txe_unset_pm_domain(struct mei_device *dev) 395 { 396 /* stop using pm callbacks if any */ 397 dev_pm_domain_set(dev->dev, NULL); 398 } 399 400 static const struct dev_pm_ops mei_txe_pm_ops = { 401 SET_SYSTEM_SLEEP_PM_OPS(mei_txe_pci_suspend, 402 mei_txe_pci_resume) 403 SET_RUNTIME_PM_OPS( 404 mei_txe_pm_runtime_suspend, 405 mei_txe_pm_runtime_resume, 406 mei_txe_pm_runtime_idle) 407 }; 408 409 #define MEI_TXE_PM_OPS (&mei_txe_pm_ops) 410 #else 411 #define MEI_TXE_PM_OPS NULL 412 #endif /* CONFIG_PM */ 413 414 /* 415 * PCI driver structure 416 */ 417 static struct pci_driver mei_txe_driver = { 418 .name = KBUILD_MODNAME, 419 .id_table = mei_txe_pci_tbl, 420 .probe = mei_txe_probe, 421 .remove = mei_txe_remove, 422 .shutdown = mei_txe_shutdown, 423 .driver.pm = MEI_TXE_PM_OPS, 424 }; 425 426 module_pci_driver(mei_txe_driver); 427 428 MODULE_AUTHOR("Intel Corporation"); 429 MODULE_DESCRIPTION("Intel(R) Trusted Execution Environment Interface"); 430 MODULE_LICENSE("GPL v2"); 431