Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 1 | /* |
| 2 | * |
| 3 | * Intel Management Engine Interface (Intel MEI) Linux driver |
| 4 | * Copyright (c) 2003-2012, 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 | */ |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 16 | #include <linux/module.h> |
| 17 | #include <linux/moduleparam.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/fcntl.h> |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 24 | #include <linux/pci.h> |
| 25 | #include <linux/poll.h> |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 26 | #include <linux/ioctl.h> |
| 27 | #include <linux/cdev.h> |
| 28 | #include <linux/sched.h> |
| 29 | #include <linux/uuid.h> |
| 30 | #include <linux/compat.h> |
| 31 | #include <linux/jiffies.h> |
| 32 | #include <linux/interrupt.h> |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 33 | |
Tomeu Vizoso | 989561d | 2016-01-07 16:46:13 +0100 | [diff] [blame] | 34 | #include <linux/pm_domain.h> |
Tomas Winkler | 180ea05 | 2014-03-18 22:52:02 +0200 | [diff] [blame] | 35 | #include <linux/pm_runtime.h> |
| 36 | |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 37 | #include <linux/mei.h> |
| 38 | |
| 39 | #include "mei_dev.h" |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 40 | #include "client.h" |
Tomas Winkler | 6e4cd27 | 2014-03-11 14:49:23 +0200 | [diff] [blame] | 41 | #include "hw-me-regs.h" |
| 42 | #include "hw-me.h" |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 43 | |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 44 | /* mei_pci_tbl - PCI Device ID Table */ |
Tomas Winkler | a05f8f8 | 2014-03-16 14:35:58 +0200 | [diff] [blame] | 45 | static const struct pci_device_id mei_me_pci_tbl[] = { |
Alexander Usyskin | 8d929d4 | 2014-05-13 01:30:53 +0300 | [diff] [blame] | 46 | {MEI_PCI_DEVICE(MEI_DEV_ID_82946GZ, mei_me_legacy_cfg)}, |
| 47 | {MEI_PCI_DEVICE(MEI_DEV_ID_82G35, mei_me_legacy_cfg)}, |
| 48 | {MEI_PCI_DEVICE(MEI_DEV_ID_82Q965, mei_me_legacy_cfg)}, |
| 49 | {MEI_PCI_DEVICE(MEI_DEV_ID_82G965, mei_me_legacy_cfg)}, |
| 50 | {MEI_PCI_DEVICE(MEI_DEV_ID_82GM965, mei_me_legacy_cfg)}, |
| 51 | {MEI_PCI_DEVICE(MEI_DEV_ID_82GME965, mei_me_legacy_cfg)}, |
| 52 | {MEI_PCI_DEVICE(MEI_DEV_ID_ICH9_82Q35, mei_me_legacy_cfg)}, |
| 53 | {MEI_PCI_DEVICE(MEI_DEV_ID_ICH9_82G33, mei_me_legacy_cfg)}, |
| 54 | {MEI_PCI_DEVICE(MEI_DEV_ID_ICH9_82Q33, mei_me_legacy_cfg)}, |
| 55 | {MEI_PCI_DEVICE(MEI_DEV_ID_ICH9_82X38, mei_me_legacy_cfg)}, |
| 56 | {MEI_PCI_DEVICE(MEI_DEV_ID_ICH9_3200, mei_me_legacy_cfg)}, |
| 57 | |
| 58 | {MEI_PCI_DEVICE(MEI_DEV_ID_ICH9_6, mei_me_legacy_cfg)}, |
| 59 | {MEI_PCI_DEVICE(MEI_DEV_ID_ICH9_7, mei_me_legacy_cfg)}, |
| 60 | {MEI_PCI_DEVICE(MEI_DEV_ID_ICH9_8, mei_me_legacy_cfg)}, |
| 61 | {MEI_PCI_DEVICE(MEI_DEV_ID_ICH9_9, mei_me_legacy_cfg)}, |
| 62 | {MEI_PCI_DEVICE(MEI_DEV_ID_ICH9_10, mei_me_legacy_cfg)}, |
| 63 | {MEI_PCI_DEVICE(MEI_DEV_ID_ICH9M_1, mei_me_legacy_cfg)}, |
| 64 | {MEI_PCI_DEVICE(MEI_DEV_ID_ICH9M_2, mei_me_legacy_cfg)}, |
| 65 | {MEI_PCI_DEVICE(MEI_DEV_ID_ICH9M_3, mei_me_legacy_cfg)}, |
| 66 | {MEI_PCI_DEVICE(MEI_DEV_ID_ICH9M_4, mei_me_legacy_cfg)}, |
| 67 | {MEI_PCI_DEVICE(MEI_DEV_ID_ICH10_1, mei_me_ich_cfg)}, |
| 68 | {MEI_PCI_DEVICE(MEI_DEV_ID_ICH10_2, mei_me_ich_cfg)}, |
| 69 | {MEI_PCI_DEVICE(MEI_DEV_ID_ICH10_3, mei_me_ich_cfg)}, |
| 70 | {MEI_PCI_DEVICE(MEI_DEV_ID_ICH10_4, mei_me_ich_cfg)}, |
| 71 | |
| 72 | {MEI_PCI_DEVICE(MEI_DEV_ID_IBXPK_1, mei_me_pch_cfg)}, |
| 73 | {MEI_PCI_DEVICE(MEI_DEV_ID_IBXPK_2, mei_me_pch_cfg)}, |
Tomas Winkler | c919951 | 2014-05-13 01:30:54 +0300 | [diff] [blame] | 74 | {MEI_PCI_DEVICE(MEI_DEV_ID_CPT_1, mei_me_pch_cpt_pbg_cfg)}, |
| 75 | {MEI_PCI_DEVICE(MEI_DEV_ID_PBG_1, mei_me_pch_cpt_pbg_cfg)}, |
Alexander Usyskin | 8d929d4 | 2014-05-13 01:30:53 +0300 | [diff] [blame] | 76 | {MEI_PCI_DEVICE(MEI_DEV_ID_PPT_1, mei_me_pch_cfg)}, |
| 77 | {MEI_PCI_DEVICE(MEI_DEV_ID_PPT_2, mei_me_pch_cfg)}, |
| 78 | {MEI_PCI_DEVICE(MEI_DEV_ID_PPT_3, mei_me_pch_cfg)}, |
Alexander Usyskin | edca5ea | 2014-11-19 17:01:38 +0200 | [diff] [blame] | 79 | {MEI_PCI_DEVICE(MEI_DEV_ID_LPT_H, mei_me_pch8_sps_cfg)}, |
| 80 | {MEI_PCI_DEVICE(MEI_DEV_ID_LPT_W, mei_me_pch8_sps_cfg)}, |
| 81 | {MEI_PCI_DEVICE(MEI_DEV_ID_LPT_LP, mei_me_pch8_cfg)}, |
| 82 | {MEI_PCI_DEVICE(MEI_DEV_ID_LPT_HR, mei_me_pch8_sps_cfg)}, |
| 83 | {MEI_PCI_DEVICE(MEI_DEV_ID_WPT_LP, mei_me_pch8_cfg)}, |
| 84 | {MEI_PCI_DEVICE(MEI_DEV_ID_WPT_LP_2, mei_me_pch8_cfg)}, |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 85 | |
Tomas Winkler | 1625c7e | 2015-08-02 22:20:57 +0300 | [diff] [blame] | 86 | {MEI_PCI_DEVICE(MEI_DEV_ID_SPT, mei_me_pch8_cfg)}, |
| 87 | {MEI_PCI_DEVICE(MEI_DEV_ID_SPT_2, mei_me_pch8_cfg)}, |
| 88 | {MEI_PCI_DEVICE(MEI_DEV_ID_SPT_H, mei_me_pch8_cfg)}, |
| 89 | {MEI_PCI_DEVICE(MEI_DEV_ID_SPT_H_2, mei_me_pch8_cfg)}, |
| 90 | |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 91 | /* required last entry */ |
| 92 | {0, } |
| 93 | }; |
| 94 | |
Tomas Winkler | b68301e | 2013-03-27 16:58:29 +0200 | [diff] [blame] | 95 | MODULE_DEVICE_TABLE(pci, mei_me_pci_tbl); |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 96 | |
Rafael J. Wysocki | bbd6d05 | 2014-12-04 22:43:07 +0100 | [diff] [blame] | 97 | #ifdef CONFIG_PM |
Tomas Winkler | e13fa90 | 2014-03-18 22:52:05 +0200 | [diff] [blame] | 98 | static inline void mei_me_set_pm_domain(struct mei_device *dev); |
| 99 | static inline void mei_me_unset_pm_domain(struct mei_device *dev); |
| 100 | #else |
| 101 | static inline void mei_me_set_pm_domain(struct mei_device *dev) {} |
| 102 | static inline void mei_me_unset_pm_domain(struct mei_device *dev) {} |
Rafael J. Wysocki | bbd6d05 | 2014-12-04 22:43:07 +0100 | [diff] [blame] | 103 | #endif /* CONFIG_PM */ |
Tomas Winkler | e13fa90 | 2014-03-18 22:52:05 +0200 | [diff] [blame] | 104 | |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 105 | /** |
Alexander Usyskin | ce23139 | 2014-09-29 16:31:50 +0300 | [diff] [blame] | 106 | * mei_me_quirk_probe - probe for devices that doesn't valid ME interface |
Masanari Iida | 393b148 | 2013-04-05 01:05:05 +0900 | [diff] [blame] | 107 | * |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 108 | * @pdev: PCI device structure |
Tomas Winkler | c919951 | 2014-05-13 01:30:54 +0300 | [diff] [blame] | 109 | * @cfg: per generation config |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 110 | * |
Alexander Usyskin | a8605ea | 2014-09-29 16:31:49 +0300 | [diff] [blame] | 111 | * Return: true if ME Interface is valid, false otherwise |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 112 | */ |
Tomas Winkler | b68301e | 2013-03-27 16:58:29 +0200 | [diff] [blame] | 113 | static bool mei_me_quirk_probe(struct pci_dev *pdev, |
Tomas Winkler | c919951 | 2014-05-13 01:30:54 +0300 | [diff] [blame] | 114 | const struct mei_cfg *cfg) |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 115 | { |
Tomas Winkler | c919951 | 2014-05-13 01:30:54 +0300 | [diff] [blame] | 116 | if (cfg->quirk_probe && cfg->quirk_probe(pdev)) { |
| 117 | dev_info(&pdev->dev, "Device doesn't have valid ME Interface\n"); |
| 118 | return false; |
Tomas Winkler | 5e6533a | 2014-03-25 21:25:18 +0200 | [diff] [blame] | 119 | } |
| 120 | |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 121 | return true; |
| 122 | } |
Tomas Winkler | c919951 | 2014-05-13 01:30:54 +0300 | [diff] [blame] | 123 | |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 124 | /** |
Alexander Usyskin | ce23139 | 2014-09-29 16:31:50 +0300 | [diff] [blame] | 125 | * mei_me_probe - Device Initialization Routine |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 126 | * |
| 127 | * @pdev: PCI device structure |
| 128 | * @ent: entry in kcs_pci_tbl |
| 129 | * |
Alexander Usyskin | a8605ea | 2014-09-29 16:31:49 +0300 | [diff] [blame] | 130 | * Return: 0 on success, <0 on failure. |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 131 | */ |
Tomas Winkler | b68301e | 2013-03-27 16:58:29 +0200 | [diff] [blame] | 132 | static int mei_me_probe(struct pci_dev *pdev, const struct pci_device_id *ent) |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 133 | { |
Alexander Usyskin | 8d929d4 | 2014-05-13 01:30:53 +0300 | [diff] [blame] | 134 | const struct mei_cfg *cfg = (struct mei_cfg *)(ent->driver_data); |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 135 | struct mei_device *dev; |
Tomas Winkler | 52c3456 | 2013-02-06 14:06:40 +0200 | [diff] [blame] | 136 | struct mei_me_hw *hw; |
Alexander Usyskin | 1fa55b4 | 2015-08-02 22:20:52 +0300 | [diff] [blame] | 137 | unsigned int irqflags; |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 138 | int err; |
| 139 | |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 140 | |
Tomas Winkler | c919951 | 2014-05-13 01:30:54 +0300 | [diff] [blame] | 141 | if (!mei_me_quirk_probe(pdev, cfg)) |
| 142 | return -ENODEV; |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 143 | |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 144 | /* enable pci dev */ |
| 145 | err = pci_enable_device(pdev); |
| 146 | if (err) { |
| 147 | dev_err(&pdev->dev, "failed to enable pci device.\n"); |
| 148 | goto end; |
| 149 | } |
| 150 | /* set PCI host mastering */ |
| 151 | pci_set_master(pdev); |
| 152 | /* pci request regions for mei driver */ |
| 153 | err = pci_request_regions(pdev, KBUILD_MODNAME); |
| 154 | if (err) { |
| 155 | dev_err(&pdev->dev, "failed to get pci regions.\n"); |
| 156 | goto disable_device; |
| 157 | } |
Tomas Winkler | 3ecfb16 | 2013-12-17 15:56:57 +0200 | [diff] [blame] | 158 | |
| 159 | if (dma_set_mask(&pdev->dev, DMA_BIT_MASK(64)) || |
| 160 | dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(64))) { |
| 161 | |
| 162 | err = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32)); |
| 163 | if (err) |
| 164 | err = dma_set_coherent_mask(&pdev->dev, |
| 165 | DMA_BIT_MASK(32)); |
| 166 | } |
| 167 | if (err) { |
| 168 | dev_err(&pdev->dev, "No usable DMA configuration, aborting\n"); |
| 169 | goto release_regions; |
| 170 | } |
| 171 | |
| 172 | |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 173 | /* allocates and initializes the mei dev structure */ |
Alexander Usyskin | 8d929d4 | 2014-05-13 01:30:53 +0300 | [diff] [blame] | 174 | dev = mei_me_dev_init(pdev, cfg); |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 175 | if (!dev) { |
| 176 | err = -ENOMEM; |
| 177 | goto release_regions; |
| 178 | } |
Tomas Winkler | 52c3456 | 2013-02-06 14:06:40 +0200 | [diff] [blame] | 179 | hw = to_me_hw(dev); |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 180 | /* mapping IO device memory */ |
Tomas Winkler | 52c3456 | 2013-02-06 14:06:40 +0200 | [diff] [blame] | 181 | hw->mem_addr = pci_iomap(pdev, 0, 0); |
| 182 | if (!hw->mem_addr) { |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 183 | dev_err(&pdev->dev, "mapping I/O device memory failure.\n"); |
| 184 | err = -ENOMEM; |
| 185 | goto free_device; |
| 186 | } |
| 187 | pci_enable_msi(pdev); |
| 188 | |
| 189 | /* request and enable interrupt */ |
Alexander Usyskin | 1fa55b4 | 2015-08-02 22:20:52 +0300 | [diff] [blame] | 190 | irqflags = pci_dev_msi_enabled(pdev) ? IRQF_ONESHOT : IRQF_SHARED; |
| 191 | |
| 192 | err = request_threaded_irq(pdev->irq, |
Tomas Winkler | 06ecd64 | 2013-02-06 14:06:42 +0200 | [diff] [blame] | 193 | mei_me_irq_quick_handler, |
| 194 | mei_me_irq_thread_handler, |
Alexander Usyskin | 1fa55b4 | 2015-08-02 22:20:52 +0300 | [diff] [blame] | 195 | irqflags, KBUILD_MODNAME, dev); |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 196 | if (err) { |
| 197 | dev_err(&pdev->dev, "request_threaded_irq failure. irq = %d\n", |
| 198 | pdev->irq); |
| 199 | goto disable_msi; |
| 200 | } |
| 201 | |
Tomas Winkler | c4d589b | 2013-03-27 16:58:28 +0200 | [diff] [blame] | 202 | if (mei_start(dev)) { |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 203 | dev_err(&pdev->dev, "init hw failure.\n"); |
| 204 | err = -ENODEV; |
| 205 | goto release_irq; |
| 206 | } |
| 207 | |
Tomas Winkler | 180ea05 | 2014-03-18 22:52:02 +0200 | [diff] [blame] | 208 | pm_runtime_set_autosuspend_delay(&pdev->dev, MEI_ME_RPM_TIMEOUT); |
| 209 | pm_runtime_use_autosuspend(&pdev->dev); |
| 210 | |
Alexander Usyskin | f3d8e87 | 2014-06-23 15:10:35 +0300 | [diff] [blame] | 211 | err = mei_register(dev, &pdev->dev); |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 212 | if (err) |
Alexander Usyskin | 1f7e489 | 2016-02-07 23:35:20 +0200 | [diff] [blame^] | 213 | goto stop; |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 214 | |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 215 | pci_set_drvdata(pdev, dev); |
| 216 | |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 217 | schedule_delayed_work(&dev->timer_work, HZ); |
| 218 | |
Tomas Winkler | e13fa90 | 2014-03-18 22:52:05 +0200 | [diff] [blame] | 219 | /* |
| 220 | * For not wake-able HW runtime pm framework |
| 221 | * can't be used on pci device level. |
| 222 | * Use domain runtime pm callbacks instead. |
| 223 | */ |
| 224 | if (!pci_dev_run_wake(pdev)) |
| 225 | mei_me_set_pm_domain(dev); |
| 226 | |
Tomas Winkler | 180ea05 | 2014-03-18 22:52:02 +0200 | [diff] [blame] | 227 | if (mei_pg_is_enabled(dev)) |
| 228 | pm_runtime_put_noidle(&pdev->dev); |
| 229 | |
Alexander Usyskin | c4e87b5 | 2013-10-21 22:05:42 +0300 | [diff] [blame] | 230 | dev_dbg(&pdev->dev, "initialization successful.\n"); |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 231 | |
| 232 | return 0; |
| 233 | |
Alexander Usyskin | 1f7e489 | 2016-02-07 23:35:20 +0200 | [diff] [blame^] | 234 | stop: |
| 235 | mei_stop(dev); |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 236 | release_irq: |
Tomas Winkler | dc844b0 | 2013-11-11 13:26:06 +0200 | [diff] [blame] | 237 | mei_cancel_work(dev); |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 238 | mei_disable_interrupts(dev); |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 239 | free_irq(pdev->irq, dev); |
| 240 | disable_msi: |
| 241 | pci_disable_msi(pdev); |
Tomas Winkler | 52c3456 | 2013-02-06 14:06:40 +0200 | [diff] [blame] | 242 | pci_iounmap(pdev, hw->mem_addr); |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 243 | free_device: |
| 244 | kfree(dev); |
| 245 | release_regions: |
| 246 | pci_release_regions(pdev); |
| 247 | disable_device: |
| 248 | pci_disable_device(pdev); |
| 249 | end: |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 250 | dev_err(&pdev->dev, "initialization failed.\n"); |
| 251 | return err; |
| 252 | } |
| 253 | |
| 254 | /** |
Alexander Usyskin | ce23139 | 2014-09-29 16:31:50 +0300 | [diff] [blame] | 255 | * mei_me_remove - Device Removal Routine |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 256 | * |
| 257 | * @pdev: PCI device structure |
| 258 | * |
| 259 | * mei_remove is called by the PCI subsystem to alert the driver |
| 260 | * that it should release a PCI device. |
| 261 | */ |
Tomas Winkler | b68301e | 2013-03-27 16:58:29 +0200 | [diff] [blame] | 262 | static void mei_me_remove(struct pci_dev *pdev) |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 263 | { |
| 264 | struct mei_device *dev; |
Tomas Winkler | 52c3456 | 2013-02-06 14:06:40 +0200 | [diff] [blame] | 265 | struct mei_me_hw *hw; |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 266 | |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 267 | dev = pci_get_drvdata(pdev); |
| 268 | if (!dev) |
| 269 | return; |
| 270 | |
Tomas Winkler | 180ea05 | 2014-03-18 22:52:02 +0200 | [diff] [blame] | 271 | if (mei_pg_is_enabled(dev)) |
| 272 | pm_runtime_get_noresume(&pdev->dev); |
| 273 | |
Tomas Winkler | 52c3456 | 2013-02-06 14:06:40 +0200 | [diff] [blame] | 274 | hw = to_me_hw(dev); |
| 275 | |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 276 | |
Paul Bolle | ed6f7ac | 2013-10-17 13:52:10 +0300 | [diff] [blame] | 277 | dev_dbg(&pdev->dev, "stop\n"); |
Tomas Winkler | 7cb035d | 2013-03-10 13:56:08 +0200 | [diff] [blame] | 278 | mei_stop(dev); |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 279 | |
Tomas Winkler | e13fa90 | 2014-03-18 22:52:05 +0200 | [diff] [blame] | 280 | if (!pci_dev_run_wake(pdev)) |
| 281 | mei_me_unset_pm_domain(dev); |
| 282 | |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 283 | /* disable interrupts */ |
| 284 | mei_disable_interrupts(dev); |
| 285 | |
| 286 | free_irq(pdev->irq, dev); |
| 287 | pci_disable_msi(pdev); |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 288 | |
Tomas Winkler | 52c3456 | 2013-02-06 14:06:40 +0200 | [diff] [blame] | 289 | if (hw->mem_addr) |
| 290 | pci_iounmap(pdev, hw->mem_addr); |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 291 | |
Tomas Winkler | 30e53bb | 2013-04-05 22:10:34 +0300 | [diff] [blame] | 292 | mei_deregister(dev); |
| 293 | |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 294 | kfree(dev); |
| 295 | |
| 296 | pci_release_regions(pdev); |
| 297 | pci_disable_device(pdev); |
| 298 | |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 299 | |
| 300 | } |
Alexander Usyskin | 1683325 | 2014-02-18 14:31:08 +0200 | [diff] [blame] | 301 | #ifdef CONFIG_PM_SLEEP |
Tomas Winkler | b68301e | 2013-03-27 16:58:29 +0200 | [diff] [blame] | 302 | static int mei_me_pci_suspend(struct device *device) |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 303 | { |
| 304 | struct pci_dev *pdev = to_pci_dev(device); |
| 305 | struct mei_device *dev = pci_get_drvdata(pdev); |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 306 | |
| 307 | if (!dev) |
| 308 | return -ENODEV; |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 309 | |
Paul Bolle | ed6f7ac | 2013-10-17 13:52:10 +0300 | [diff] [blame] | 310 | dev_dbg(&pdev->dev, "suspend\n"); |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 311 | |
Tomas Winkler | 7cb035d | 2013-03-10 13:56:08 +0200 | [diff] [blame] | 312 | mei_stop(dev); |
| 313 | |
| 314 | mei_disable_interrupts(dev); |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 315 | |
| 316 | free_irq(pdev->irq, dev); |
| 317 | pci_disable_msi(pdev); |
| 318 | |
Tomas Winkler | 7cb035d | 2013-03-10 13:56:08 +0200 | [diff] [blame] | 319 | return 0; |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 320 | } |
| 321 | |
Tomas Winkler | b68301e | 2013-03-27 16:58:29 +0200 | [diff] [blame] | 322 | static int mei_me_pci_resume(struct device *device) |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 323 | { |
| 324 | struct pci_dev *pdev = to_pci_dev(device); |
| 325 | struct mei_device *dev; |
Alexander Usyskin | 1fa55b4 | 2015-08-02 22:20:52 +0300 | [diff] [blame] | 326 | unsigned int irqflags; |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 327 | int err; |
| 328 | |
| 329 | dev = pci_get_drvdata(pdev); |
| 330 | if (!dev) |
| 331 | return -ENODEV; |
| 332 | |
| 333 | pci_enable_msi(pdev); |
| 334 | |
Alexander Usyskin | 1fa55b4 | 2015-08-02 22:20:52 +0300 | [diff] [blame] | 335 | irqflags = pci_dev_msi_enabled(pdev) ? IRQF_ONESHOT : IRQF_SHARED; |
| 336 | |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 337 | /* request and enable interrupt */ |
Alexander Usyskin | 1fa55b4 | 2015-08-02 22:20:52 +0300 | [diff] [blame] | 338 | err = request_threaded_irq(pdev->irq, |
Tomas Winkler | 06ecd64 | 2013-02-06 14:06:42 +0200 | [diff] [blame] | 339 | mei_me_irq_quick_handler, |
| 340 | mei_me_irq_thread_handler, |
Alexander Usyskin | 1fa55b4 | 2015-08-02 22:20:52 +0300 | [diff] [blame] | 341 | irqflags, KBUILD_MODNAME, dev); |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 342 | |
| 343 | if (err) { |
| 344 | dev_err(&pdev->dev, "request_threaded_irq failed: irq = %d.\n", |
| 345 | pdev->irq); |
| 346 | return err; |
| 347 | } |
| 348 | |
Tomas Winkler | 33ec082 | 2014-01-12 00:36:09 +0200 | [diff] [blame] | 349 | err = mei_restart(dev); |
| 350 | if (err) |
| 351 | return err; |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 352 | |
| 353 | /* Start timer if stopped in suspend */ |
| 354 | schedule_delayed_work(&dev->timer_work, HZ); |
| 355 | |
Tomas Winkler | 33ec082 | 2014-01-12 00:36:09 +0200 | [diff] [blame] | 356 | return 0; |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 357 | } |
Tomas Winkler | 180ea05 | 2014-03-18 22:52:02 +0200 | [diff] [blame] | 358 | #endif /* CONFIG_PM_SLEEP */ |
Alexander Usyskin | 1683325 | 2014-02-18 14:31:08 +0200 | [diff] [blame] | 359 | |
Rafael J. Wysocki | bbd6d05 | 2014-12-04 22:43:07 +0100 | [diff] [blame] | 360 | #ifdef CONFIG_PM |
Tomas Winkler | 180ea05 | 2014-03-18 22:52:02 +0200 | [diff] [blame] | 361 | static int mei_me_pm_runtime_idle(struct device *device) |
| 362 | { |
| 363 | struct pci_dev *pdev = to_pci_dev(device); |
| 364 | struct mei_device *dev; |
| 365 | |
| 366 | dev_dbg(&pdev->dev, "rpm: me: runtime_idle\n"); |
| 367 | |
| 368 | dev = pci_get_drvdata(pdev); |
| 369 | if (!dev) |
| 370 | return -ENODEV; |
| 371 | if (mei_write_is_idle(dev)) |
Alexander Usyskin | d5d83f8 | 2014-07-17 10:53:36 +0300 | [diff] [blame] | 372 | pm_runtime_autosuspend(device); |
Tomas Winkler | 180ea05 | 2014-03-18 22:52:02 +0200 | [diff] [blame] | 373 | |
| 374 | return -EBUSY; |
| 375 | } |
| 376 | |
| 377 | static int mei_me_pm_runtime_suspend(struct device *device) |
| 378 | { |
| 379 | struct pci_dev *pdev = to_pci_dev(device); |
| 380 | struct mei_device *dev; |
| 381 | int ret; |
| 382 | |
| 383 | dev_dbg(&pdev->dev, "rpm: me: runtime suspend\n"); |
| 384 | |
| 385 | dev = pci_get_drvdata(pdev); |
| 386 | if (!dev) |
| 387 | return -ENODEV; |
| 388 | |
| 389 | mutex_lock(&dev->device_lock); |
| 390 | |
| 391 | if (mei_write_is_idle(dev)) |
Alexander Usyskin | 2d1995f | 2015-02-10 10:39:34 +0200 | [diff] [blame] | 392 | ret = mei_me_pg_enter_sync(dev); |
Tomas Winkler | 180ea05 | 2014-03-18 22:52:02 +0200 | [diff] [blame] | 393 | else |
| 394 | ret = -EAGAIN; |
| 395 | |
| 396 | mutex_unlock(&dev->device_lock); |
| 397 | |
| 398 | dev_dbg(&pdev->dev, "rpm: me: runtime suspend ret=%d\n", ret); |
| 399 | |
| 400 | return ret; |
| 401 | } |
| 402 | |
| 403 | static int mei_me_pm_runtime_resume(struct device *device) |
| 404 | { |
| 405 | struct pci_dev *pdev = to_pci_dev(device); |
| 406 | struct mei_device *dev; |
| 407 | int ret; |
| 408 | |
| 409 | dev_dbg(&pdev->dev, "rpm: me: runtime resume\n"); |
| 410 | |
| 411 | dev = pci_get_drvdata(pdev); |
| 412 | if (!dev) |
| 413 | return -ENODEV; |
| 414 | |
| 415 | mutex_lock(&dev->device_lock); |
| 416 | |
Alexander Usyskin | 2d1995f | 2015-02-10 10:39:34 +0200 | [diff] [blame] | 417 | ret = mei_me_pg_exit_sync(dev); |
Tomas Winkler | 180ea05 | 2014-03-18 22:52:02 +0200 | [diff] [blame] | 418 | |
| 419 | mutex_unlock(&dev->device_lock); |
| 420 | |
| 421 | dev_dbg(&pdev->dev, "rpm: me: runtime resume ret = %d\n", ret); |
| 422 | |
| 423 | return ret; |
| 424 | } |
Tomas Winkler | e13fa90 | 2014-03-18 22:52:05 +0200 | [diff] [blame] | 425 | |
| 426 | /** |
Geert Uytterhoeven | 7efceb5 | 2014-09-16 22:00:47 +0200 | [diff] [blame] | 427 | * mei_me_set_pm_domain - fill and set pm domain structure for device |
Tomas Winkler | e13fa90 | 2014-03-18 22:52:05 +0200 | [diff] [blame] | 428 | * |
| 429 | * @dev: mei_device |
| 430 | */ |
| 431 | static inline void mei_me_set_pm_domain(struct mei_device *dev) |
| 432 | { |
Tomas Winkler | d08b8fc | 2014-09-29 16:31:44 +0300 | [diff] [blame] | 433 | struct pci_dev *pdev = to_pci_dev(dev->dev); |
Tomas Winkler | e13fa90 | 2014-03-18 22:52:05 +0200 | [diff] [blame] | 434 | |
| 435 | if (pdev->dev.bus && pdev->dev.bus->pm) { |
| 436 | dev->pg_domain.ops = *pdev->dev.bus->pm; |
| 437 | |
| 438 | dev->pg_domain.ops.runtime_suspend = mei_me_pm_runtime_suspend; |
| 439 | dev->pg_domain.ops.runtime_resume = mei_me_pm_runtime_resume; |
| 440 | dev->pg_domain.ops.runtime_idle = mei_me_pm_runtime_idle; |
| 441 | |
Tomeu Vizoso | 989561d | 2016-01-07 16:46:13 +0100 | [diff] [blame] | 442 | dev_pm_domain_set(&pdev->dev, &dev->pg_domain); |
Tomas Winkler | e13fa90 | 2014-03-18 22:52:05 +0200 | [diff] [blame] | 443 | } |
| 444 | } |
| 445 | |
| 446 | /** |
Geert Uytterhoeven | 7efceb5 | 2014-09-16 22:00:47 +0200 | [diff] [blame] | 447 | * mei_me_unset_pm_domain - clean pm domain structure for device |
Tomas Winkler | e13fa90 | 2014-03-18 22:52:05 +0200 | [diff] [blame] | 448 | * |
| 449 | * @dev: mei_device |
| 450 | */ |
| 451 | static inline void mei_me_unset_pm_domain(struct mei_device *dev) |
| 452 | { |
| 453 | /* stop using pm callbacks if any */ |
Tomeu Vizoso | 989561d | 2016-01-07 16:46:13 +0100 | [diff] [blame] | 454 | dev_pm_domain_set(dev->dev, NULL); |
Tomas Winkler | e13fa90 | 2014-03-18 22:52:05 +0200 | [diff] [blame] | 455 | } |
Tomas Winkler | 180ea05 | 2014-03-18 22:52:02 +0200 | [diff] [blame] | 456 | |
Tomas Winkler | 180ea05 | 2014-03-18 22:52:02 +0200 | [diff] [blame] | 457 | static const struct dev_pm_ops mei_me_pm_ops = { |
| 458 | SET_SYSTEM_SLEEP_PM_OPS(mei_me_pci_suspend, |
| 459 | mei_me_pci_resume) |
| 460 | SET_RUNTIME_PM_OPS( |
| 461 | mei_me_pm_runtime_suspend, |
| 462 | mei_me_pm_runtime_resume, |
| 463 | mei_me_pm_runtime_idle) |
| 464 | }; |
| 465 | |
Tomas Winkler | b68301e | 2013-03-27 16:58:29 +0200 | [diff] [blame] | 466 | #define MEI_ME_PM_OPS (&mei_me_pm_ops) |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 467 | #else |
Tomas Winkler | b68301e | 2013-03-27 16:58:29 +0200 | [diff] [blame] | 468 | #define MEI_ME_PM_OPS NULL |
Tomas Winkler | 180ea05 | 2014-03-18 22:52:02 +0200 | [diff] [blame] | 469 | #endif /* CONFIG_PM */ |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 470 | /* |
| 471 | * PCI driver structure |
| 472 | */ |
Tomas Winkler | b68301e | 2013-03-27 16:58:29 +0200 | [diff] [blame] | 473 | static struct pci_driver mei_me_driver = { |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 474 | .name = KBUILD_MODNAME, |
Tomas Winkler | b68301e | 2013-03-27 16:58:29 +0200 | [diff] [blame] | 475 | .id_table = mei_me_pci_tbl, |
| 476 | .probe = mei_me_probe, |
| 477 | .remove = mei_me_remove, |
| 478 | .shutdown = mei_me_remove, |
| 479 | .driver.pm = MEI_ME_PM_OPS, |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 480 | }; |
| 481 | |
Tomas Winkler | b68301e | 2013-03-27 16:58:29 +0200 | [diff] [blame] | 482 | module_pci_driver(mei_me_driver); |
Tomas Winkler | 2703d4b | 2013-02-06 14:06:39 +0200 | [diff] [blame] | 483 | |
| 484 | MODULE_AUTHOR("Intel Corporation"); |
| 485 | MODULE_DESCRIPTION("Intel(R) Management Engine Interface"); |
| 486 | MODULE_LICENSE("GPL v2"); |