1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * PCI glue for ISHTP provider device (ISH) driver 4 * 5 * Copyright (c) 2014-2016, Intel Corporation. 6 */ 7 8 #include <linux/acpi.h> 9 #include <linux/module.h> 10 #include <linux/moduleparam.h> 11 #include <linux/kernel.h> 12 #include <linux/device.h> 13 #include <linux/fs.h> 14 #include <linux/errno.h> 15 #include <linux/types.h> 16 #include <linux/pci.h> 17 #include <linux/sched.h> 18 #include <linux/suspend.h> 19 #include <linux/interrupt.h> 20 #include <linux/workqueue.h> 21 #define CREATE_TRACE_POINTS 22 #include <trace/events/intel_ish.h> 23 #include "ishtp-dev.h" 24 #include "hw-ish.h" 25 26 static const struct pci_device_id ish_pci_tbl[] = { 27 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, CHV_DEVICE_ID)}, 28 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, BXT_Ax_DEVICE_ID)}, 29 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, BXT_Bx_DEVICE_ID)}, 30 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, APL_Ax_DEVICE_ID)}, 31 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, SPT_Ax_DEVICE_ID)}, 32 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, CNL_Ax_DEVICE_ID)}, 33 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, GLK_Ax_DEVICE_ID)}, 34 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, CNL_H_DEVICE_ID)}, 35 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, ICL_MOBILE_DEVICE_ID)}, 36 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, SPT_H_DEVICE_ID)}, 37 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, CML_LP_DEVICE_ID)}, 38 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, CMP_H_DEVICE_ID)}, 39 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, EHL_Ax_DEVICE_ID)}, 40 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, TGL_LP_DEVICE_ID)}, 41 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, TGL_H_DEVICE_ID)}, 42 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, ADL_S_DEVICE_ID)}, 43 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, ADL_P_DEVICE_ID)}, 44 {0, } 45 }; 46 MODULE_DEVICE_TABLE(pci, ish_pci_tbl); 47 48 /** 49 * ish_event_tracer() - Callback function to dump trace messages 50 * @dev: ishtp device 51 * @format: printf style format 52 * 53 * Callback to direct log messages to Linux trace buffers 54 */ 55 static __printf(2, 3) 56 void ish_event_tracer(struct ishtp_device *dev, const char *format, ...) 57 { 58 if (trace_ishtp_dump_enabled()) { 59 va_list args; 60 char tmp_buf[100]; 61 62 va_start(args, format); 63 vsnprintf(tmp_buf, sizeof(tmp_buf), format, args); 64 va_end(args); 65 66 trace_ishtp_dump(tmp_buf); 67 } 68 } 69 70 /** 71 * ish_init() - Init function 72 * @dev: ishtp device 73 * 74 * This function initialize wait queues for suspend/resume and call 75 * calls hadware initialization function. This will initiate 76 * startup sequence 77 * 78 * Return: 0 for success or error code for failure 79 */ 80 static int ish_init(struct ishtp_device *dev) 81 { 82 int ret; 83 84 /* Set the state of ISH HW to start */ 85 ret = ish_hw_start(dev); 86 if (ret) { 87 dev_err(dev->devc, "ISH: hw start failed.\n"); 88 return ret; 89 } 90 91 /* Start the inter process communication to ISH processor */ 92 ret = ishtp_start(dev); 93 if (ret) { 94 dev_err(dev->devc, "ISHTP: Protocol init failed.\n"); 95 return ret; 96 } 97 98 return 0; 99 } 100 101 static const struct pci_device_id ish_invalid_pci_ids[] = { 102 /* Mehlow platform special pci ids */ 103 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0xA309)}, 104 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0xA30A)}, 105 {} 106 }; 107 108 static inline bool ish_should_enter_d0i3(struct pci_dev *pdev) 109 { 110 return !pm_suspend_via_firmware() || pdev->device == CHV_DEVICE_ID; 111 } 112 113 static inline bool ish_should_leave_d0i3(struct pci_dev *pdev) 114 { 115 return !pm_resume_via_firmware() || pdev->device == CHV_DEVICE_ID; 116 } 117 118 static int enable_gpe(struct device *dev) 119 { 120 #ifdef CONFIG_ACPI 121 acpi_status acpi_sts; 122 struct acpi_device *adev; 123 struct acpi_device_wakeup *wakeup; 124 125 adev = ACPI_COMPANION(dev); 126 if (!adev) { 127 dev_err(dev, "get acpi handle failed\n"); 128 return -ENODEV; 129 } 130 wakeup = &adev->wakeup; 131 132 acpi_sts = acpi_enable_gpe(wakeup->gpe_device, wakeup->gpe_number); 133 if (ACPI_FAILURE(acpi_sts)) { 134 dev_err(dev, "enable ose_gpe failed\n"); 135 return -EIO; 136 } 137 138 return 0; 139 #else 140 return -ENODEV; 141 #endif 142 } 143 144 static void enable_pme_wake(struct pci_dev *pdev) 145 { 146 if ((pci_pme_capable(pdev, PCI_D0) || 147 pci_pme_capable(pdev, PCI_D3hot) || 148 pci_pme_capable(pdev, PCI_D3cold)) && !enable_gpe(&pdev->dev)) { 149 pci_pme_active(pdev, true); 150 dev_dbg(&pdev->dev, "ish ipc driver pme wake enabled\n"); 151 } 152 } 153 154 /** 155 * ish_probe() - PCI driver probe callback 156 * @pdev: pci device 157 * @ent: pci device id 158 * 159 * Initialize PCI function, setup interrupt and call for ISH initialization 160 * 161 * Return: 0 for success or error code for failure 162 */ 163 static int ish_probe(struct pci_dev *pdev, const struct pci_device_id *ent) 164 { 165 int ret; 166 struct ish_hw *hw; 167 unsigned long irq_flag = 0; 168 struct ishtp_device *ishtp; 169 struct device *dev = &pdev->dev; 170 171 /* Check for invalid platforms for ISH support */ 172 if (pci_dev_present(ish_invalid_pci_ids)) 173 return -ENODEV; 174 175 /* enable pci dev */ 176 ret = pcim_enable_device(pdev); 177 if (ret) { 178 dev_err(dev, "ISH: Failed to enable PCI device\n"); 179 return ret; 180 } 181 182 /* set PCI host mastering */ 183 pci_set_master(pdev); 184 185 /* pci request regions for ISH driver */ 186 ret = pcim_iomap_regions(pdev, 1 << 0, KBUILD_MODNAME); 187 if (ret) { 188 dev_err(dev, "ISH: Failed to get PCI regions\n"); 189 return ret; 190 } 191 192 /* allocates and initializes the ISH dev structure */ 193 ishtp = ish_dev_init(pdev); 194 if (!ishtp) { 195 ret = -ENOMEM; 196 return ret; 197 } 198 hw = to_ish_hw(ishtp); 199 ishtp->print_log = ish_event_tracer; 200 201 /* mapping IO device memory */ 202 hw->mem_addr = pcim_iomap_table(pdev)[0]; 203 ishtp->pdev = pdev; 204 205 /* request and enable interrupt */ 206 ret = pci_alloc_irq_vectors(pdev, 1, 1, PCI_IRQ_ALL_TYPES); 207 if (!pdev->msi_enabled && !pdev->msix_enabled) 208 irq_flag = IRQF_SHARED; 209 210 ret = devm_request_irq(dev, pdev->irq, ish_irq_handler, 211 irq_flag, KBUILD_MODNAME, ishtp); 212 if (ret) { 213 dev_err(dev, "ISH: request IRQ %d failed\n", pdev->irq); 214 return ret; 215 } 216 217 dev_set_drvdata(ishtp->devc, ishtp); 218 219 init_waitqueue_head(&ishtp->suspend_wait); 220 init_waitqueue_head(&ishtp->resume_wait); 221 222 /* Enable PME for EHL */ 223 if (pdev->device == EHL_Ax_DEVICE_ID) 224 enable_pme_wake(pdev); 225 226 ret = ish_init(ishtp); 227 if (ret) 228 return ret; 229 230 return 0; 231 } 232 233 /** 234 * ish_remove() - PCI driver remove callback 235 * @pdev: pci device 236 * 237 * This function does cleanup of ISH on pci remove callback 238 */ 239 static void ish_remove(struct pci_dev *pdev) 240 { 241 struct ishtp_device *ishtp_dev = pci_get_drvdata(pdev); 242 243 ishtp_bus_remove_all_clients(ishtp_dev, false); 244 ish_device_disable(ishtp_dev); 245 } 246 247 static struct device __maybe_unused *ish_resume_device; 248 249 /* 50ms to get resume response */ 250 #define WAIT_FOR_RESUME_ACK_MS 50 251 252 /** 253 * ish_resume_handler() - Work function to complete resume 254 * @work: work struct 255 * 256 * The resume work function to complete resume function asynchronously. 257 * There are two resume paths, one where ISH is not powered off, 258 * in that case a simple resume message is enough, others we need 259 * a reset sequence. 260 */ 261 static void __maybe_unused ish_resume_handler(struct work_struct *work) 262 { 263 struct pci_dev *pdev = to_pci_dev(ish_resume_device); 264 struct ishtp_device *dev = pci_get_drvdata(pdev); 265 uint32_t fwsts = dev->ops->get_fw_status(dev); 266 267 if (ish_should_leave_d0i3(pdev) && !dev->suspend_flag 268 && IPC_IS_ISH_ILUP(fwsts)) { 269 if (device_may_wakeup(&pdev->dev)) 270 disable_irq_wake(pdev->irq); 271 272 ish_set_host_ready(dev); 273 274 ishtp_send_resume(dev); 275 276 /* Waiting to get resume response */ 277 if (dev->resume_flag) 278 wait_event_interruptible_timeout(dev->resume_wait, 279 !dev->resume_flag, 280 msecs_to_jiffies(WAIT_FOR_RESUME_ACK_MS)); 281 282 /* 283 * If the flag is not cleared, something is wrong with ISH FW. 284 * So on resume, need to go through init sequence again. 285 */ 286 if (dev->resume_flag) 287 ish_init(dev); 288 } else { 289 /* 290 * Resume from the D3, full reboot of ISH processor will happen, 291 * so need to go through init sequence again. 292 */ 293 ish_init(dev); 294 } 295 } 296 297 /** 298 * ish_suspend() - ISH suspend callback 299 * @device: device pointer 300 * 301 * ISH suspend callback 302 * 303 * Return: 0 to the pm core 304 */ 305 static int __maybe_unused ish_suspend(struct device *device) 306 { 307 struct pci_dev *pdev = to_pci_dev(device); 308 struct ishtp_device *dev = pci_get_drvdata(pdev); 309 310 if (ish_should_enter_d0i3(pdev)) { 311 /* 312 * If previous suspend hasn't been asnwered then ISH is likely 313 * dead, don't attempt nested notification 314 */ 315 if (dev->suspend_flag) 316 return 0; 317 318 dev->resume_flag = 0; 319 dev->suspend_flag = 1; 320 ishtp_send_suspend(dev); 321 322 /* 25 ms should be enough for live ISH to flush all IPC buf */ 323 if (dev->suspend_flag) 324 wait_event_interruptible_timeout(dev->suspend_wait, 325 !dev->suspend_flag, 326 msecs_to_jiffies(25)); 327 328 if (dev->suspend_flag) { 329 /* 330 * It looks like FW halt, clear the DMA bit, and put 331 * ISH into D3, and FW would reset on resume. 332 */ 333 ish_disable_dma(dev); 334 } else { 335 /* 336 * Save state so PCI core will keep the device at D0, 337 * the ISH would enter D0i3 338 */ 339 pci_save_state(pdev); 340 341 if (device_may_wakeup(&pdev->dev)) 342 enable_irq_wake(pdev->irq); 343 } 344 } else { 345 /* 346 * Clear the DMA bit before putting ISH into D3, 347 * or ISH FW would reset automatically. 348 */ 349 ish_disable_dma(dev); 350 } 351 352 return 0; 353 } 354 355 static __maybe_unused DECLARE_WORK(resume_work, ish_resume_handler); 356 /** 357 * ish_resume() - ISH resume callback 358 * @device: device pointer 359 * 360 * ISH resume callback 361 * 362 * Return: 0 to the pm core 363 */ 364 static int __maybe_unused ish_resume(struct device *device) 365 { 366 struct pci_dev *pdev = to_pci_dev(device); 367 struct ishtp_device *dev = pci_get_drvdata(pdev); 368 369 /* add this to finish power flow for EHL */ 370 if (dev->pdev->device == EHL_Ax_DEVICE_ID) { 371 pci_set_power_state(pdev, PCI_D0); 372 enable_pme_wake(pdev); 373 dev_dbg(dev->devc, "set power state to D0 for ehl\n"); 374 } 375 376 ish_resume_device = device; 377 dev->resume_flag = 1; 378 379 schedule_work(&resume_work); 380 381 return 0; 382 } 383 384 static SIMPLE_DEV_PM_OPS(ish_pm_ops, ish_suspend, ish_resume); 385 386 static struct pci_driver ish_driver = { 387 .name = KBUILD_MODNAME, 388 .id_table = ish_pci_tbl, 389 .probe = ish_probe, 390 .remove = ish_remove, 391 .driver.pm = &ish_pm_ops, 392 }; 393 394 module_pci_driver(ish_driver); 395 396 /* Original author */ 397 MODULE_AUTHOR("Daniel Drubin <daniel.drubin@intel.com>"); 398 /* Adoption to upstream Linux kernel */ 399 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>"); 400 401 MODULE_DESCRIPTION("Intel(R) Integrated Sensor Hub PCI Device Driver"); 402 MODULE_LICENSE("GPL"); 403