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 * For not wake-able HW runtime pm framework 142 * can't be used on pci device level. 143 * Use domain runtime pm callbacks instead. 144 */ 145 if (!pci_dev_run_wake(pdev)) 146 mei_txe_set_pm_domain(dev); 147 148 pm_runtime_put_noidle(&pdev->dev); 149 150 return 0; 151 152 stop: 153 mei_stop(dev); 154 release_irq: 155 mei_cancel_work(dev); 156 mei_disable_interrupts(dev); 157 free_irq(pdev->irq, dev); 158 end: 159 dev_err(&pdev->dev, "initialization failed.\n"); 160 return err; 161 } 162 163 /** 164 * mei_txe_remove - Device Shutdown Routine 165 * 166 * @pdev: PCI device structure 167 * 168 * mei_txe_shutdown is called from the reboot notifier 169 * it's a simplified version of remove so we go down 170 * faster. 171 */ 172 static void mei_txe_shutdown(struct pci_dev *pdev) 173 { 174 struct mei_device *dev; 175 176 dev = pci_get_drvdata(pdev); 177 if (!dev) 178 return; 179 180 dev_dbg(&pdev->dev, "shutdown\n"); 181 mei_stop(dev); 182 183 if (!pci_dev_run_wake(pdev)) 184 mei_txe_unset_pm_domain(dev); 185 186 mei_disable_interrupts(dev); 187 free_irq(pdev->irq, dev); 188 } 189 190 /** 191 * mei_txe_remove - Device Removal Routine 192 * 193 * @pdev: PCI device structure 194 * 195 * mei_remove is called by the PCI subsystem to alert the driver 196 * that it should release a PCI device. 197 */ 198 static void mei_txe_remove(struct pci_dev *pdev) 199 { 200 struct mei_device *dev; 201 202 dev = pci_get_drvdata(pdev); 203 if (!dev) { 204 dev_err(&pdev->dev, "mei: dev == NULL\n"); 205 return; 206 } 207 208 pm_runtime_get_noresume(&pdev->dev); 209 210 mei_stop(dev); 211 212 if (!pci_dev_run_wake(pdev)) 213 mei_txe_unset_pm_domain(dev); 214 215 mei_disable_interrupts(dev); 216 free_irq(pdev->irq, dev); 217 218 mei_deregister(dev); 219 } 220 221 222 #ifdef CONFIG_PM_SLEEP 223 static int mei_txe_pci_suspend(struct device *device) 224 { 225 struct pci_dev *pdev = to_pci_dev(device); 226 struct mei_device *dev = pci_get_drvdata(pdev); 227 228 if (!dev) 229 return -ENODEV; 230 231 dev_dbg(&pdev->dev, "suspend\n"); 232 233 mei_stop(dev); 234 235 mei_disable_interrupts(dev); 236 237 free_irq(pdev->irq, dev); 238 pci_disable_msi(pdev); 239 240 return 0; 241 } 242 243 static int mei_txe_pci_resume(struct device *device) 244 { 245 struct pci_dev *pdev = to_pci_dev(device); 246 struct mei_device *dev; 247 int err; 248 249 dev = pci_get_drvdata(pdev); 250 if (!dev) 251 return -ENODEV; 252 253 pci_enable_msi(pdev); 254 255 mei_clear_interrupts(dev); 256 257 /* request and enable interrupt */ 258 if (pci_dev_msi_enabled(pdev)) 259 err = request_threaded_irq(pdev->irq, 260 NULL, 261 mei_txe_irq_thread_handler, 262 IRQF_ONESHOT, KBUILD_MODNAME, dev); 263 else 264 err = request_threaded_irq(pdev->irq, 265 mei_txe_irq_quick_handler, 266 mei_txe_irq_thread_handler, 267 IRQF_SHARED, KBUILD_MODNAME, dev); 268 if (err) { 269 dev_err(&pdev->dev, "request_threaded_irq failed: irq = %d.\n", 270 pdev->irq); 271 return err; 272 } 273 274 err = mei_restart(dev); 275 276 return err; 277 } 278 #endif /* CONFIG_PM_SLEEP */ 279 280 #ifdef CONFIG_PM 281 static int mei_txe_pm_runtime_idle(struct device *device) 282 { 283 struct pci_dev *pdev = to_pci_dev(device); 284 struct mei_device *dev; 285 286 dev_dbg(&pdev->dev, "rpm: txe: runtime_idle\n"); 287 288 dev = pci_get_drvdata(pdev); 289 if (!dev) 290 return -ENODEV; 291 if (mei_write_is_idle(dev)) 292 pm_runtime_autosuspend(device); 293 294 return -EBUSY; 295 } 296 static int mei_txe_pm_runtime_suspend(struct device *device) 297 { 298 struct pci_dev *pdev = to_pci_dev(device); 299 struct mei_device *dev; 300 int ret; 301 302 dev_dbg(&pdev->dev, "rpm: txe: runtime suspend\n"); 303 304 dev = pci_get_drvdata(pdev); 305 if (!dev) 306 return -ENODEV; 307 308 mutex_lock(&dev->device_lock); 309 310 if (mei_write_is_idle(dev)) 311 ret = mei_txe_aliveness_set_sync(dev, 0); 312 else 313 ret = -EAGAIN; 314 315 /* 316 * If everything is okay we're about to enter PCI low 317 * power state (D3) therefor we need to disable the 318 * interrupts towards host. 319 * However if device is not wakeable we do not enter 320 * D-low state and we need to keep the interrupt kicking 321 */ 322 if (!ret && pci_dev_run_wake(pdev)) 323 mei_disable_interrupts(dev); 324 325 dev_dbg(&pdev->dev, "rpm: txe: runtime suspend ret=%d\n", ret); 326 327 mutex_unlock(&dev->device_lock); 328 329 if (ret && ret != -EAGAIN) 330 schedule_work(&dev->reset_work); 331 332 return ret; 333 } 334 335 static int mei_txe_pm_runtime_resume(struct device *device) 336 { 337 struct pci_dev *pdev = to_pci_dev(device); 338 struct mei_device *dev; 339 int ret; 340 341 dev_dbg(&pdev->dev, "rpm: txe: runtime resume\n"); 342 343 dev = pci_get_drvdata(pdev); 344 if (!dev) 345 return -ENODEV; 346 347 mutex_lock(&dev->device_lock); 348 349 mei_enable_interrupts(dev); 350 351 ret = mei_txe_aliveness_set_sync(dev, 1); 352 353 mutex_unlock(&dev->device_lock); 354 355 dev_dbg(&pdev->dev, "rpm: txe: runtime resume ret = %d\n", ret); 356 357 if (ret) 358 schedule_work(&dev->reset_work); 359 360 return ret; 361 } 362 363 /** 364 * mei_txe_set_pm_domain - fill and set pm domain structure for device 365 * 366 * @dev: mei_device 367 */ 368 static inline void mei_txe_set_pm_domain(struct mei_device *dev) 369 { 370 struct pci_dev *pdev = to_pci_dev(dev->dev); 371 372 if (pdev->dev.bus && pdev->dev.bus->pm) { 373 dev->pg_domain.ops = *pdev->dev.bus->pm; 374 375 dev->pg_domain.ops.runtime_suspend = mei_txe_pm_runtime_suspend; 376 dev->pg_domain.ops.runtime_resume = mei_txe_pm_runtime_resume; 377 dev->pg_domain.ops.runtime_idle = mei_txe_pm_runtime_idle; 378 379 dev_pm_domain_set(&pdev->dev, &dev->pg_domain); 380 } 381 } 382 383 /** 384 * mei_txe_unset_pm_domain - clean pm domain structure for device 385 * 386 * @dev: mei_device 387 */ 388 static inline void mei_txe_unset_pm_domain(struct mei_device *dev) 389 { 390 /* stop using pm callbacks if any */ 391 dev_pm_domain_set(dev->dev, NULL); 392 } 393 394 static const struct dev_pm_ops mei_txe_pm_ops = { 395 SET_SYSTEM_SLEEP_PM_OPS(mei_txe_pci_suspend, 396 mei_txe_pci_resume) 397 SET_RUNTIME_PM_OPS( 398 mei_txe_pm_runtime_suspend, 399 mei_txe_pm_runtime_resume, 400 mei_txe_pm_runtime_idle) 401 }; 402 403 #define MEI_TXE_PM_OPS (&mei_txe_pm_ops) 404 #else 405 #define MEI_TXE_PM_OPS NULL 406 #endif /* CONFIG_PM */ 407 408 /* 409 * PCI driver structure 410 */ 411 static struct pci_driver mei_txe_driver = { 412 .name = KBUILD_MODNAME, 413 .id_table = mei_txe_pci_tbl, 414 .probe = mei_txe_probe, 415 .remove = mei_txe_remove, 416 .shutdown = mei_txe_shutdown, 417 .driver.pm = MEI_TXE_PM_OPS, 418 }; 419 420 module_pci_driver(mei_txe_driver); 421 422 MODULE_AUTHOR("Intel Corporation"); 423 MODULE_DESCRIPTION("Intel(R) Trusted Execution Environment Interface"); 424 MODULE_LICENSE("GPL v2"); 425