mirrors/linux-stable
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git synced 2024-10-05 00:20:32 +00:00
Code Issues Releases Wiki Activity

Merge branch 'acpi-lpss' into pm-runtime

Browse source
This commit is contained in:
Rafael J. Wysocki 2014-12-04 00:50:06 +01:00
commit 4bea2b4cd9
2 changed files with 76 additions and 29 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

94
drivers/acpi/acpi_lpss.c
View file

@ -1,7 +1,7 @@
/* /*
* ACPI support for Intel Lynxpoint LPSS. * ACPI support for Intel Lynxpoint LPSS.
* *
* Copyright (C) 2013, Intel Corporation * Copyright (C) 2013, 2014, Intel Corporation
* Authors: Mika Westerberg <mika.westerberg@linux.intel.com> * Authors: Mika Westerberg <mika.westerberg@linux.intel.com>
* Rafael J. Wysocki <rafael.j.wysocki@intel.com> * Rafael J. Wysocki <rafael.j.wysocki@intel.com>
* *
@ -60,6 +60,8 @@ ACPI_MODULE_NAME("acpi_lpss");
#define LPSS_CLK_DIVIDER BIT(2) #define LPSS_CLK_DIVIDER BIT(2)
#define LPSS_LTR BIT(3) #define LPSS_LTR BIT(3)
#define LPSS_SAVE_CTX BIT(4) #define LPSS_SAVE_CTX BIT(4)
#define LPSS_DEV_PROXY BIT(5)
#define LPSS_PROXY_REQ BIT(6)
struct lpss_private_data; struct lpss_private_data;
@ -70,8 +72,10 @@ struct lpss_device_desc {
void (*setup)(struct lpss_private_data *pdata); void (*setup)(struct lpss_private_data *pdata);
}; };
static struct device *proxy_device;
static struct lpss_device_desc lpss_dma_desc = { static struct lpss_device_desc lpss_dma_desc = {
.flags = LPSS_CLK, .flags = LPSS_CLK | LPSS_PROXY_REQ,
}; };
struct lpss_private_data { struct lpss_private_data {
@ -146,22 +150,24 @@ static struct lpss_device_desc byt_pwm_dev_desc = {
}; };
static struct lpss_device_desc byt_uart_dev_desc = { static struct lpss_device_desc byt_uart_dev_desc = {
.flags = LPSS_CLK | LPSS_CLK_GATE | LPSS_CLK_DIVIDER | LPSS_SAVE_CTX, .flags = LPSS_CLK | LPSS_CLK_GATE | LPSS_CLK_DIVIDER | LPSS_SAVE_CTX |
LPSS_DEV_PROXY,
.prv_offset = 0x800, .prv_offset = 0x800,
.setup = lpss_uart_setup, .setup = lpss_uart_setup,
}; };
static struct lpss_device_desc byt_spi_dev_desc = { static struct lpss_device_desc byt_spi_dev_desc = {
.flags = LPSS_CLK | LPSS_CLK_GATE | LPSS_CLK_DIVIDER | LPSS_SAVE_CTX, .flags = LPSS_CLK | LPSS_CLK_GATE | LPSS_CLK_DIVIDER | LPSS_SAVE_CTX |
LPSS_DEV_PROXY,
.prv_offset = 0x400, .prv_offset = 0x400,
}; };
static struct lpss_device_desc byt_sdio_dev_desc = { static struct lpss_device_desc byt_sdio_dev_desc = {
.flags = LPSS_CLK, .flags = LPSS_CLK | LPSS_DEV_PROXY,
}; };
static struct lpss_device_desc byt_i2c_dev_desc = { static struct lpss_device_desc byt_i2c_dev_desc = {
.flags = LPSS_CLK | LPSS_SAVE_CTX, .flags = LPSS_CLK | LPSS_SAVE_CTX | LPSS_DEV_PROXY,
.prv_offset = 0x800, .prv_offset = 0x800,
.setup = byt_i2c_setup, .setup = byt_i2c_setup,
}; };
@ -368,6 +374,8 @@ static int acpi_lpss_create_device(struct acpi_device *adev,
adev->driver_data = pdata; adev->driver_data = pdata;
pdev = acpi_create_platform_device(adev); pdev = acpi_create_platform_device(adev);
if (!IS_ERR_OR_NULL(pdev)) { if (!IS_ERR_OR_NULL(pdev)) {
if (!proxy_device && dev_desc->flags & LPSS_DEV_PROXY)
proxy_device = &pdev->dev;
return 1; return 1;
} }
@ -499,14 +507,15 @@ static void acpi_lpss_set_ltr(struct device *dev, s32 val)
/** /**
* acpi_lpss_save_ctx() - Save the private registers of LPSS device * acpi_lpss_save_ctx() - Save the private registers of LPSS device
* @dev: LPSS device * @dev: LPSS device
* @pdata: pointer to the private data of the LPSS device
* *
* Most LPSS devices have private registers which may loose their context when * Most LPSS devices have private registers which may loose their context when
* the device is powered down. acpi_lpss_save_ctx() saves those registers into * the device is powered down. acpi_lpss_save_ctx() saves those registers into
* prv_reg_ctx array. * prv_reg_ctx array.
*/ */
static void acpi_lpss_save_ctx(struct device *dev) static void acpi_lpss_save_ctx(struct device *dev,
struct lpss_private_data *pdata)
{ {
struct lpss_private_data *pdata = acpi_driver_data(ACPI_COMPANION(dev));
unsigned int i; unsigned int i;
for (i = 0; i < LPSS_PRV_REG_COUNT; i++) { for (i = 0; i < LPSS_PRV_REG_COUNT; i++) {
@ -521,12 +530,13 @@ static void acpi_lpss_save_ctx(struct device *dev)
/** /**
* acpi_lpss_restore_ctx() - Restore the private registers of LPSS device * acpi_lpss_restore_ctx() - Restore the private registers of LPSS device
* @dev: LPSS device * @dev: LPSS device
* @pdata: pointer to the private data of the LPSS device
* *
* Restores the registers that were previously stored with acpi_lpss_save_ctx(). * Restores the registers that were previously stored with acpi_lpss_save_ctx().
*/ */
static void acpi_lpss_restore_ctx(struct device *dev) static void acpi_lpss_restore_ctx(struct device *dev,
struct lpss_private_data *pdata)
{ {
struct lpss_private_data *pdata = acpi_driver_data(ACPI_COMPANION(dev));
unsigned int i; unsigned int i;
/* /*
@ -549,23 +559,31 @@ static void acpi_lpss_restore_ctx(struct device *dev)
#ifdef CONFIG_PM_SLEEP #ifdef CONFIG_PM_SLEEP
static int acpi_lpss_suspend_late(struct device *dev) static int acpi_lpss_suspend_late(struct device *dev)
{ {
int ret = pm_generic_suspend_late(dev); struct lpss_private_data *pdata = acpi_driver_data(ACPI_COMPANION(dev));
int ret;
ret = pm_generic_suspend_late(dev);
if (ret) if (ret)
return ret; return ret;
acpi_lpss_save_ctx(dev); if (pdata->dev_desc->flags & LPSS_SAVE_CTX)
acpi_lpss_save_ctx(dev, pdata);
return acpi_dev_suspend_late(dev); return acpi_dev_suspend_late(dev);
} }
static int acpi_lpss_resume_early(struct device *dev) static int acpi_lpss_resume_early(struct device *dev)
{ {
int ret = acpi_dev_resume_early(dev); struct lpss_private_data *pdata = acpi_driver_data(ACPI_COMPANION(dev));
int ret;
ret = acpi_dev_resume_early(dev);
if (ret) if (ret)
return ret; return ret;
acpi_lpss_restore_ctx(dev); if (pdata->dev_desc->flags & LPSS_SAVE_CTX)
acpi_lpss_restore_ctx(dev, pdata);
return pm_generic_resume_early(dev); return pm_generic_resume_early(dev);
} }
#endif /* CONFIG_PM_SLEEP */ #endif /* CONFIG_PM_SLEEP */
@ -573,23 +591,44 @@ static int acpi_lpss_resume_early(struct device *dev)
#ifdef CONFIG_PM_RUNTIME #ifdef CONFIG_PM_RUNTIME
static int acpi_lpss_runtime_suspend(struct device *dev) static int acpi_lpss_runtime_suspend(struct device *dev)
{ {
int ret = pm_generic_runtime_suspend(dev); struct lpss_private_data *pdata = acpi_driver_data(ACPI_COMPANION(dev));
int ret;
ret = pm_generic_runtime_suspend(dev);
if (ret) if (ret)
return ret; return ret;
acpi_lpss_save_ctx(dev); if (pdata->dev_desc->flags & LPSS_SAVE_CTX)
return acpi_dev_runtime_suspend(dev); acpi_lpss_save_ctx(dev, pdata);
ret = acpi_dev_runtime_suspend(dev);
if (ret)
return ret;
if (pdata->dev_desc->flags & LPSS_PROXY_REQ && proxy_device)
return pm_runtime_put_sync_suspend(proxy_device);
return 0;
} }
static int acpi_lpss_runtime_resume(struct device *dev) static int acpi_lpss_runtime_resume(struct device *dev)
{ {
int ret = acpi_dev_runtime_resume(dev); struct lpss_private_data *pdata = acpi_driver_data(ACPI_COMPANION(dev));
int ret;
if (pdata->dev_desc->flags & LPSS_PROXY_REQ && proxy_device) {
ret = pm_runtime_get_sync(proxy_device);
if (ret)
return ret;
}
ret = acpi_dev_runtime_resume(dev);
if (ret) if (ret)
return ret; return ret;
acpi_lpss_restore_ctx(dev); if (pdata->dev_desc->flags & LPSS_SAVE_CTX)
acpi_lpss_restore_ctx(dev, pdata);
return pm_generic_runtime_resume(dev); return pm_generic_runtime_resume(dev);
} }
#endif /* CONFIG_PM_RUNTIME */ #endif /* CONFIG_PM_RUNTIME */
@ -631,30 +670,27 @@ static int acpi_lpss_platform_notify(struct notifier_block *nb,
return 0; return 0;
pdata = acpi_driver_data(adev); pdata = acpi_driver_data(adev);
if (!pdata || !pdata->mmio_base) if (!pdata)
return 0; return 0;
if (pdata->mmio_size < pdata->dev_desc->prv_offset + LPSS_LTR_SIZE) { if (pdata->mmio_base &&
pdata->mmio_size < pdata->dev_desc->prv_offset + LPSS_LTR_SIZE) {
dev_err(&pdev->dev, "MMIO size insufficient to access LTR\n"); dev_err(&pdev->dev, "MMIO size insufficient to access LTR\n");
return 0; return 0;
} }
switch (action) { switch (action) {
case BUS_NOTIFY_BOUND_DRIVER:
if (pdata->dev_desc->flags & LPSS_SAVE_CTX)
pdev->dev.pm_domain = &acpi_lpss_pm_domain;
break;
case BUS_NOTIFY_UNBOUND_DRIVER:
if (pdata->dev_desc->flags & LPSS_SAVE_CTX)
pdev->dev.pm_domain = NULL;
break;
case BUS_NOTIFY_ADD_DEVICE: case BUS_NOTIFY_ADD_DEVICE:
pdev->dev.pm_domain = &acpi_lpss_pm_domain;
if (pdata->dev_desc->flags & LPSS_LTR) if (pdata->dev_desc->flags & LPSS_LTR)
return sysfs_create_group(&pdev->dev.kobj, return sysfs_create_group(&pdev->dev.kobj,
&lpss_attr_group); &lpss_attr_group);
break;
case BUS_NOTIFY_DEL_DEVICE: case BUS_NOTIFY_DEL_DEVICE:
if (pdata->dev_desc->flags & LPSS_LTR) if (pdata->dev_desc->flags & LPSS_LTR)
sysfs_remove_group(&pdev->dev.kobj, &lpss_attr_group); sysfs_remove_group(&pdev->dev.kobj, &lpss_attr_group);
pdev->dev.pm_domain = NULL;
break;
default: default:
break; break;
} }

11
drivers/dma/dw/core.c
View file

@ -22,6 +22,7 @@
#include <linux/mm.h> #include <linux/mm.h>
#include <linux/module.h> #include <linux/module.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/pm_runtime.h>
#include "../dmaengine.h" #include "../dmaengine.h"
#include "internal.h" #include "internal.h"
@ -1504,6 +1505,9 @@ int dw_dma_probe(struct dw_dma_chip *chip, struct dw_dma_platform_data *pdata)
dw->regs = chip->regs; dw->regs = chip->regs;
chip->dw = dw; chip->dw = dw;
pm_runtime_enable(chip->dev);
pm_runtime_get_sync(chip->dev);
dw_params = dma_read_byaddr(chip->regs, DW_PARAMS); dw_params = dma_read_byaddr(chip->regs, DW_PARAMS);
autocfg = dw_params >> DW_PARAMS_EN & 0x1; autocfg = dw_params >> DW_PARAMS_EN & 0x1;
@ -1667,11 +1671,14 @@ int dw_dma_probe(struct dw_dma_chip *chip, struct dw_dma_platform_data *pdata)
dev_info(chip->dev, "DesignWare DMA Controller, %d channels\n", dev_info(chip->dev, "DesignWare DMA Controller, %d channels\n",
nr_channels); nr_channels);
pm_runtime_put_sync_suspend(chip->dev);
return 0; return 0;
err_dma_register: err_dma_register:
free_irq(chip->irq, dw); free_irq(chip->irq, dw);
err_pdata: err_pdata:
pm_runtime_put_sync_suspend(chip->dev);
return err; return err;
} }
EXPORT_SYMBOL_GPL(dw_dma_probe); EXPORT_SYMBOL_GPL(dw_dma_probe);
@ -1681,6 +1688,8 @@ int dw_dma_remove(struct dw_dma_chip *chip)
struct dw_dma *dw = chip->dw; struct dw_dma *dw = chip->dw;
struct dw_dma_chan *dwc, *_dwc; struct dw_dma_chan *dwc, *_dwc;
pm_runtime_get_sync(chip->dev);
dw_dma_off(dw); dw_dma_off(dw);
dma_async_device_unregister(&dw->dma); dma_async_device_unregister(&dw->dma);
@ -1693,6 +1702,8 @@ int dw_dma_remove(struct dw_dma_chip *chip)
channel_clear_bit(dw, CH_EN, dwc->mask); channel_clear_bit(dw, CH_EN, dwc->mask);
} }
pm_runtime_put_sync_suspend(chip->dev);
pm_runtime_disable(chip->dev);
return 0; return 0;
} }
EXPORT_SYMBOL_GPL(dw_dma_remove); EXPORT_SYMBOL_GPL(dw_dma_remove);