Tomas Winkler | 795536a | 2014-01-16 00:58:35 +0200 | [diff] [blame] | 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> |
Alexander Usyskin | cfe5ab8 | 2014-03-18 22:52:03 +0200 | [diff] [blame] | 30 | #include <linux/pm_runtime.h> |
Tomas Winkler | 795536a | 2014-01-16 00:58:35 +0200 | [diff] [blame] | 31 | |
| 32 | #include <linux/mei.h> |
| 33 | |
| 34 | |
| 35 | #include "mei_dev.h" |
| 36 | #include "hw-txe.h" |
| 37 | |
Tomas Winkler | a05f8f8 | 2014-03-16 14:35:58 +0200 | [diff] [blame] | 38 | static const struct pci_device_id mei_txe_pci_tbl[] = { |
Alexander Usyskin | 8d929d4 | 2014-05-13 01:30:53 +0300 | [diff] [blame] | 39 | {MEI_PCI_DEVICE(0x0F18, mei_txe_cfg)}, /* Baytrail */ |
Tomas Winkler | 795536a | 2014-01-16 00:58:35 +0200 | [diff] [blame] | 40 | {0, } |
| 41 | }; |
| 42 | MODULE_DEVICE_TABLE(pci, mei_txe_pci_tbl); |
| 43 | |
Alexander Usyskin | d2d56fa | 2014-03-18 22:52:06 +0200 | [diff] [blame] | 44 | #ifdef CONFIG_PM_RUNTIME |
| 45 | static inline void mei_txe_set_pm_domain(struct mei_device *dev); |
| 46 | static inline void mei_txe_unset_pm_domain(struct mei_device *dev); |
| 47 | #else |
| 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 | #endif /* CONFIG_PM_RUNTIME */ |
Tomas Winkler | 795536a | 2014-01-16 00:58:35 +0200 | [diff] [blame] | 51 | |
| 52 | static void mei_txe_pci_iounmap(struct pci_dev *pdev, struct mei_txe_hw *hw) |
| 53 | { |
| 54 | int i; |
| 55 | for (i = SEC_BAR; i < NUM_OF_MEM_BARS; i++) { |
| 56 | if (hw->mem_addr[i]) { |
| 57 | pci_iounmap(pdev, hw->mem_addr[i]); |
| 58 | hw->mem_addr[i] = NULL; |
| 59 | } |
| 60 | } |
| 61 | } |
| 62 | /** |
| 63 | * mei_probe - Device Initialization Routine |
| 64 | * |
| 65 | * @pdev: PCI device structure |
| 66 | * @ent: entry in mei_txe_pci_tbl |
| 67 | * |
| 68 | * returns 0 on success, <0 on failure. |
| 69 | */ |
| 70 | static int mei_txe_probe(struct pci_dev *pdev, const struct pci_device_id *ent) |
| 71 | { |
Alexander Usyskin | 8d929d4 | 2014-05-13 01:30:53 +0300 | [diff] [blame] | 72 | const struct mei_cfg *cfg = (struct mei_cfg *)(ent->driver_data); |
Tomas Winkler | 795536a | 2014-01-16 00:58:35 +0200 | [diff] [blame] | 73 | struct mei_device *dev; |
| 74 | struct mei_txe_hw *hw; |
| 75 | int err; |
| 76 | int i; |
| 77 | |
| 78 | /* enable pci dev */ |
| 79 | err = pci_enable_device(pdev); |
| 80 | if (err) { |
| 81 | dev_err(&pdev->dev, "failed to enable pci device.\n"); |
| 82 | goto end; |
| 83 | } |
| 84 | /* set PCI host mastering */ |
| 85 | pci_set_master(pdev); |
| 86 | /* pci request regions for mei driver */ |
| 87 | err = pci_request_regions(pdev, KBUILD_MODNAME); |
| 88 | if (err) { |
| 89 | dev_err(&pdev->dev, "failed to get pci regions.\n"); |
| 90 | goto disable_device; |
| 91 | } |
| 92 | |
| 93 | err = pci_set_dma_mask(pdev, DMA_BIT_MASK(36)); |
| 94 | if (err) { |
| 95 | err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32)); |
| 96 | if (err) { |
| 97 | dev_err(&pdev->dev, "No suitable DMA available.\n"); |
| 98 | goto release_regions; |
| 99 | } |
| 100 | } |
| 101 | |
| 102 | /* allocates and initializes the mei dev structure */ |
Alexander Usyskin | 8d929d4 | 2014-05-13 01:30:53 +0300 | [diff] [blame] | 103 | dev = mei_txe_dev_init(pdev, cfg); |
Tomas Winkler | 795536a | 2014-01-16 00:58:35 +0200 | [diff] [blame] | 104 | if (!dev) { |
| 105 | err = -ENOMEM; |
| 106 | goto release_regions; |
| 107 | } |
| 108 | hw = to_txe_hw(dev); |
| 109 | |
| 110 | /* mapping IO device memory */ |
| 111 | for (i = SEC_BAR; i < NUM_OF_MEM_BARS; i++) { |
| 112 | hw->mem_addr[i] = pci_iomap(pdev, i, 0); |
| 113 | if (!hw->mem_addr[i]) { |
| 114 | dev_err(&pdev->dev, "mapping I/O device memory failure.\n"); |
| 115 | err = -ENOMEM; |
| 116 | goto free_device; |
| 117 | } |
| 118 | } |
| 119 | |
| 120 | |
| 121 | pci_enable_msi(pdev); |
| 122 | |
| 123 | /* clear spurious interrupts */ |
| 124 | mei_clear_interrupts(dev); |
| 125 | |
| 126 | /* request and enable interrupt */ |
| 127 | if (pci_dev_msi_enabled(pdev)) |
| 128 | err = request_threaded_irq(pdev->irq, |
| 129 | NULL, |
| 130 | mei_txe_irq_thread_handler, |
| 131 | IRQF_ONESHOT, KBUILD_MODNAME, dev); |
| 132 | else |
| 133 | err = request_threaded_irq(pdev->irq, |
| 134 | mei_txe_irq_quick_handler, |
| 135 | mei_txe_irq_thread_handler, |
| 136 | IRQF_SHARED, KBUILD_MODNAME, dev); |
| 137 | if (err) { |
| 138 | dev_err(&pdev->dev, "mei: request_threaded_irq failure. irq = %d\n", |
| 139 | pdev->irq); |
| 140 | goto free_device; |
| 141 | } |
| 142 | |
| 143 | if (mei_start(dev)) { |
| 144 | dev_err(&pdev->dev, "init hw failure.\n"); |
| 145 | err = -ENODEV; |
| 146 | goto release_irq; |
| 147 | } |
| 148 | |
Alexander Usyskin | cfe5ab8 | 2014-03-18 22:52:03 +0200 | [diff] [blame] | 149 | pm_runtime_set_autosuspend_delay(&pdev->dev, MEI_TXI_RPM_TIMEOUT); |
| 150 | pm_runtime_use_autosuspend(&pdev->dev); |
| 151 | |
Alexander Usyskin | f3d8e87 | 2014-06-23 15:10:35 +0300 | [diff] [blame] | 152 | err = mei_register(dev, &pdev->dev); |
Tomas Winkler | 795536a | 2014-01-16 00:58:35 +0200 | [diff] [blame] | 153 | if (err) |
| 154 | goto release_irq; |
| 155 | |
| 156 | pci_set_drvdata(pdev, dev); |
| 157 | |
Alexander Usyskin | d2d56fa | 2014-03-18 22:52:06 +0200 | [diff] [blame] | 158 | /* |
| 159 | * For not wake-able HW runtime pm framework |
| 160 | * can't be used on pci device level. |
| 161 | * Use domain runtime pm callbacks instead. |
| 162 | */ |
| 163 | if (!pci_dev_run_wake(pdev)) |
| 164 | mei_txe_set_pm_domain(dev); |
| 165 | |
Alexander Usyskin | cfe5ab8 | 2014-03-18 22:52:03 +0200 | [diff] [blame] | 166 | pm_runtime_put_noidle(&pdev->dev); |
| 167 | |
Tomas Winkler | 795536a | 2014-01-16 00:58:35 +0200 | [diff] [blame] | 168 | return 0; |
| 169 | |
| 170 | release_irq: |
| 171 | |
| 172 | mei_cancel_work(dev); |
| 173 | |
| 174 | /* disable interrupts */ |
| 175 | mei_disable_interrupts(dev); |
| 176 | |
| 177 | free_irq(pdev->irq, dev); |
| 178 | pci_disable_msi(pdev); |
| 179 | |
| 180 | free_device: |
| 181 | mei_txe_pci_iounmap(pdev, hw); |
| 182 | |
| 183 | kfree(dev); |
| 184 | release_regions: |
| 185 | pci_release_regions(pdev); |
| 186 | disable_device: |
| 187 | pci_disable_device(pdev); |
| 188 | end: |
| 189 | dev_err(&pdev->dev, "initialization failed.\n"); |
| 190 | return err; |
| 191 | } |
| 192 | |
| 193 | /** |
| 194 | * mei_remove - Device Removal Routine |
| 195 | * |
| 196 | * @pdev: PCI device structure |
| 197 | * |
| 198 | * mei_remove is called by the PCI subsystem to alert the driver |
| 199 | * that it should release a PCI device. |
| 200 | */ |
| 201 | static void mei_txe_remove(struct pci_dev *pdev) |
| 202 | { |
| 203 | struct mei_device *dev; |
| 204 | struct mei_txe_hw *hw; |
| 205 | |
| 206 | dev = pci_get_drvdata(pdev); |
| 207 | if (!dev) { |
| 208 | dev_err(&pdev->dev, "mei: dev =NULL\n"); |
| 209 | return; |
| 210 | } |
| 211 | |
Alexander Usyskin | cfe5ab8 | 2014-03-18 22:52:03 +0200 | [diff] [blame] | 212 | pm_runtime_get_noresume(&pdev->dev); |
| 213 | |
Tomas Winkler | 795536a | 2014-01-16 00:58:35 +0200 | [diff] [blame] | 214 | hw = to_txe_hw(dev); |
| 215 | |
| 216 | mei_stop(dev); |
| 217 | |
Alexander Usyskin | d2d56fa | 2014-03-18 22:52:06 +0200 | [diff] [blame] | 218 | if (!pci_dev_run_wake(pdev)) |
| 219 | mei_txe_unset_pm_domain(dev); |
| 220 | |
Tomas Winkler | 795536a | 2014-01-16 00:58:35 +0200 | [diff] [blame] | 221 | /* disable interrupts */ |
| 222 | mei_disable_interrupts(dev); |
| 223 | free_irq(pdev->irq, dev); |
| 224 | pci_disable_msi(pdev); |
| 225 | |
| 226 | pci_set_drvdata(pdev, NULL); |
| 227 | |
| 228 | mei_txe_pci_iounmap(pdev, hw); |
| 229 | |
| 230 | mei_deregister(dev); |
| 231 | |
| 232 | kfree(dev); |
| 233 | |
| 234 | pci_release_regions(pdev); |
| 235 | pci_disable_device(pdev); |
| 236 | } |
| 237 | |
| 238 | |
Tomas Winkler | e0270ad | 2014-02-18 14:31:09 +0200 | [diff] [blame] | 239 | #ifdef CONFIG_PM_SLEEP |
Tomas Winkler | 795536a | 2014-01-16 00:58:35 +0200 | [diff] [blame] | 240 | static int mei_txe_pci_suspend(struct device *device) |
| 241 | { |
| 242 | struct pci_dev *pdev = to_pci_dev(device); |
| 243 | struct mei_device *dev = pci_get_drvdata(pdev); |
| 244 | |
| 245 | if (!dev) |
| 246 | return -ENODEV; |
| 247 | |
| 248 | dev_dbg(&pdev->dev, "suspend\n"); |
| 249 | |
| 250 | mei_stop(dev); |
| 251 | |
| 252 | mei_disable_interrupts(dev); |
| 253 | |
| 254 | free_irq(pdev->irq, dev); |
| 255 | pci_disable_msi(pdev); |
| 256 | |
| 257 | return 0; |
| 258 | } |
| 259 | |
| 260 | static int mei_txe_pci_resume(struct device *device) |
| 261 | { |
| 262 | struct pci_dev *pdev = to_pci_dev(device); |
| 263 | struct mei_device *dev; |
| 264 | int err; |
| 265 | |
| 266 | dev = pci_get_drvdata(pdev); |
| 267 | if (!dev) |
| 268 | return -ENODEV; |
| 269 | |
| 270 | pci_enable_msi(pdev); |
| 271 | |
| 272 | mei_clear_interrupts(dev); |
| 273 | |
| 274 | /* request and enable interrupt */ |
| 275 | if (pci_dev_msi_enabled(pdev)) |
| 276 | err = request_threaded_irq(pdev->irq, |
| 277 | NULL, |
| 278 | mei_txe_irq_thread_handler, |
| 279 | IRQF_ONESHOT, KBUILD_MODNAME, dev); |
| 280 | else |
| 281 | err = request_threaded_irq(pdev->irq, |
| 282 | mei_txe_irq_quick_handler, |
| 283 | mei_txe_irq_thread_handler, |
| 284 | IRQF_SHARED, KBUILD_MODNAME, dev); |
| 285 | if (err) { |
| 286 | dev_err(&pdev->dev, "request_threaded_irq failed: irq = %d.\n", |
| 287 | pdev->irq); |
| 288 | return err; |
| 289 | } |
| 290 | |
| 291 | err = mei_restart(dev); |
| 292 | |
| 293 | return err; |
| 294 | } |
Alexander Usyskin | cfe5ab8 | 2014-03-18 22:52:03 +0200 | [diff] [blame] | 295 | #endif /* CONFIG_PM_SLEEP */ |
Tomas Winkler | 795536a | 2014-01-16 00:58:35 +0200 | [diff] [blame] | 296 | |
Alexander Usyskin | cfe5ab8 | 2014-03-18 22:52:03 +0200 | [diff] [blame] | 297 | #ifdef CONFIG_PM_RUNTIME |
| 298 | static int mei_txe_pm_runtime_idle(struct device *device) |
| 299 | { |
| 300 | struct pci_dev *pdev = to_pci_dev(device); |
| 301 | struct mei_device *dev; |
| 302 | |
| 303 | dev_dbg(&pdev->dev, "rpm: txe: runtime_idle\n"); |
| 304 | |
| 305 | dev = pci_get_drvdata(pdev); |
| 306 | if (!dev) |
| 307 | return -ENODEV; |
| 308 | if (mei_write_is_idle(dev)) |
Alexander Usyskin | d5d83f8 | 2014-07-17 10:53:36 +0300 | [diff] [blame] | 309 | pm_runtime_autosuspend(device); |
Alexander Usyskin | cfe5ab8 | 2014-03-18 22:52:03 +0200 | [diff] [blame] | 310 | |
| 311 | return -EBUSY; |
| 312 | } |
| 313 | static int mei_txe_pm_runtime_suspend(struct device *device) |
| 314 | { |
| 315 | struct pci_dev *pdev = to_pci_dev(device); |
| 316 | struct mei_device *dev; |
| 317 | int ret; |
| 318 | |
| 319 | dev_dbg(&pdev->dev, "rpm: txe: runtime suspend\n"); |
| 320 | |
| 321 | dev = pci_get_drvdata(pdev); |
| 322 | if (!dev) |
| 323 | return -ENODEV; |
| 324 | |
| 325 | mutex_lock(&dev->device_lock); |
| 326 | |
| 327 | if (mei_write_is_idle(dev)) |
| 328 | ret = mei_txe_aliveness_set_sync(dev, 0); |
| 329 | else |
| 330 | ret = -EAGAIN; |
| 331 | |
| 332 | /* |
| 333 | * If everything is okay we're about to enter PCI low |
| 334 | * power state (D3) therefor we need to disable the |
| 335 | * interrupts towards host. |
| 336 | * However if device is not wakeable we do not enter |
| 337 | * D-low state and we need to keep the interrupt kicking |
| 338 | */ |
| 339 | if (!ret && pci_dev_run_wake(pdev)) |
| 340 | mei_disable_interrupts(dev); |
| 341 | |
| 342 | dev_dbg(&pdev->dev, "rpm: txe: runtime suspend ret=%d\n", ret); |
| 343 | |
| 344 | mutex_unlock(&dev->device_lock); |
| 345 | return ret; |
| 346 | } |
| 347 | |
| 348 | static int mei_txe_pm_runtime_resume(struct device *device) |
| 349 | { |
| 350 | struct pci_dev *pdev = to_pci_dev(device); |
| 351 | struct mei_device *dev; |
| 352 | int ret; |
| 353 | |
| 354 | dev_dbg(&pdev->dev, "rpm: txe: runtime resume\n"); |
| 355 | |
| 356 | dev = pci_get_drvdata(pdev); |
| 357 | if (!dev) |
| 358 | return -ENODEV; |
| 359 | |
| 360 | mutex_lock(&dev->device_lock); |
| 361 | |
| 362 | mei_enable_interrupts(dev); |
| 363 | |
| 364 | ret = mei_txe_aliveness_set_sync(dev, 1); |
| 365 | |
| 366 | mutex_unlock(&dev->device_lock); |
| 367 | |
| 368 | dev_dbg(&pdev->dev, "rpm: txe: runtime resume ret = %d\n", ret); |
| 369 | |
| 370 | return ret; |
| 371 | } |
Alexander Usyskin | d2d56fa | 2014-03-18 22:52:06 +0200 | [diff] [blame] | 372 | |
| 373 | /** |
| 374 | * mei_txe_set_pm_domain - fill and set pm domian stucture for device |
| 375 | * |
| 376 | * @dev: mei_device |
| 377 | */ |
| 378 | static inline void mei_txe_set_pm_domain(struct mei_device *dev) |
| 379 | { |
| 380 | struct pci_dev *pdev = dev->pdev; |
| 381 | |
| 382 | if (pdev->dev.bus && pdev->dev.bus->pm) { |
| 383 | dev->pg_domain.ops = *pdev->dev.bus->pm; |
| 384 | |
| 385 | dev->pg_domain.ops.runtime_suspend = mei_txe_pm_runtime_suspend; |
| 386 | dev->pg_domain.ops.runtime_resume = mei_txe_pm_runtime_resume; |
| 387 | dev->pg_domain.ops.runtime_idle = mei_txe_pm_runtime_idle; |
| 388 | |
| 389 | pdev->dev.pm_domain = &dev->pg_domain; |
| 390 | } |
| 391 | } |
| 392 | |
| 393 | /** |
| 394 | * mei_txe_unset_pm_domain - clean pm domian stucture for device |
| 395 | * |
| 396 | * @dev: mei_device |
| 397 | */ |
| 398 | static inline void mei_txe_unset_pm_domain(struct mei_device *dev) |
| 399 | { |
| 400 | /* stop using pm callbacks if any */ |
| 401 | dev->pdev->dev.pm_domain = NULL; |
| 402 | } |
Alexander Usyskin | cfe5ab8 | 2014-03-18 22:52:03 +0200 | [diff] [blame] | 403 | #endif /* CONFIG_PM_RUNTIME */ |
| 404 | |
| 405 | #ifdef CONFIG_PM |
| 406 | static const struct dev_pm_ops mei_txe_pm_ops = { |
| 407 | SET_SYSTEM_SLEEP_PM_OPS(mei_txe_pci_suspend, |
| 408 | mei_txe_pci_resume) |
| 409 | SET_RUNTIME_PM_OPS( |
| 410 | mei_txe_pm_runtime_suspend, |
| 411 | mei_txe_pm_runtime_resume, |
| 412 | mei_txe_pm_runtime_idle) |
| 413 | }; |
Tomas Winkler | 795536a | 2014-01-16 00:58:35 +0200 | [diff] [blame] | 414 | |
| 415 | #define MEI_TXE_PM_OPS (&mei_txe_pm_ops) |
| 416 | #else |
| 417 | #define MEI_TXE_PM_OPS NULL |
Alexander Usyskin | cfe5ab8 | 2014-03-18 22:52:03 +0200 | [diff] [blame] | 418 | #endif /* CONFIG_PM */ |
| 419 | |
Tomas Winkler | 795536a | 2014-01-16 00:58:35 +0200 | [diff] [blame] | 420 | /* |
| 421 | * PCI driver structure |
| 422 | */ |
| 423 | static struct pci_driver mei_txe_driver = { |
| 424 | .name = KBUILD_MODNAME, |
| 425 | .id_table = mei_txe_pci_tbl, |
| 426 | .probe = mei_txe_probe, |
| 427 | .remove = mei_txe_remove, |
| 428 | .shutdown = mei_txe_remove, |
| 429 | .driver.pm = MEI_TXE_PM_OPS, |
| 430 | }; |
| 431 | |
| 432 | module_pci_driver(mei_txe_driver); |
| 433 | |
| 434 | MODULE_AUTHOR("Intel Corporation"); |
| 435 | MODULE_DESCRIPTION("Intel(R) Trusted Execution Environment Interface"); |
| 436 | MODULE_LICENSE("GPL v2"); |