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