evie/android_kernel_oneplus_msm8998
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge branch 'x86-platform-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip

Browse source 
Pull x86 core platform updates from Ingo Molnar:
 "The main changes are:

   - Intel Atom platform updates.  (Andy Shevchenko)

   - modularity fixlets.  (Paul Gortmaker)

   - x86 platform clockevents driver updates for lguest, uv and Xen.
     (Viresh Kumar)

   - Microsoft Hyper-V TSC fixlet.  (Vitaly Kuznetsov)"

* 'x86-platform-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip:
  x86/platform: Make atom/pmc_atom.c explicitly non-modular
  x86/hyperv: Mark the Hyper-V TSC as unstable
  x86/xen/time: Migrate to new set-state interface
  x86/uv/time: Migrate to new set-state interface
  x86/lguest/timer: Migrate to new set-state interface
  x86/pci/intel_mid_pci: Use proper constants for irq polarity
  x86/pci/intel_mid_pci: Make intel_mid_pci_ops static
  x86/pci/intel_mid_pci: Propagate actual return code
  x86/pci/intel_mid_pci: Work around for IRQ0 assignment
  x86/platform/iosf_mbi: Add Intel Tangier PCI id
  x86/platform/iosf_mbi: Source cleanup
  x86/platform/iosf_mbi: Remove NULL pointer checks for pci_dev_put()
  x86/platform/iosf_mbi: Check return value of debugfs_create properly
  x86/platform/iosf_mbi: Move to dedicated folder
  x86/platform/intel/pmc_atom: Move the PMC-Atom code to arch/x86/platform/atom
  x86/platform/intel/pmc_atom: Add Cherrytrail PMC interface
  x86/platform/intel/pmc_atom: Supply register mappings via PMC object
  x86/platform/intel/pmc_atom: Print index of device in loop
  x86/platform/intel/pmc_atom: Export accessors to PMC registers
This commit is contained in:
Linus Torvalds 2015-09-01 10:33:31 -07:00
commit 361f7d1757
13 changed files with 337 additions and 237 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

29
arch/x86/include/asm/pmc_atom.h
View file

@ -18,6 +18,8 @@
/* ValleyView Power Control Unit PCI Device ID */ /* ValleyView Power Control Unit PCI Device ID */
#define PCI_DEVICE_ID_VLV_PMC 0x0F1C #define PCI_DEVICE_ID_VLV_PMC 0x0F1C
/* CherryTrail Power Control Unit PCI Device ID */
#define PCI_DEVICE_ID_CHT_PMC 0x229C
/* PMC Memory mapped IO registers */ /* PMC Memory mapped IO registers */
#define PMC_BASE_ADDR_OFFSET 0x44 #define PMC_BASE_ADDR_OFFSET 0x44
@ -29,6 +31,10 @@
#define PMC_FUNC_DIS 0x34 #define PMC_FUNC_DIS 0x34
#define PMC_FUNC_DIS_2 0x38 #define PMC_FUNC_DIS_2 0x38
/* CHT specific bits in FUNC_DIS2 register */
#define BIT_FD_GMM BIT(3)
#define BIT_FD_ISH BIT(4)
/* S0ix wake event control */ /* S0ix wake event control */
#define PMC_S0IX_WAKE_EN 0x3C #define PMC_S0IX_WAKE_EN 0x3C
@ -75,6 +81,21 @@
#define PMC_PSS_BIT_USB BIT(16) #define PMC_PSS_BIT_USB BIT(16)
#define PMC_PSS_BIT_USB_SUS BIT(17) #define PMC_PSS_BIT_USB_SUS BIT(17)
/* CHT specific bits in PSS register */
#define PMC_PSS_BIT_CHT_UFS BIT(7)
#define PMC_PSS_BIT_CHT_UXD BIT(11)
#define PMC_PSS_BIT_CHT_UXD_FD BIT(12)
#define PMC_PSS_BIT_CHT_UX_ENG BIT(15)
#define PMC_PSS_BIT_CHT_USB_SUS BIT(16)
#define PMC_PSS_BIT_CHT_GMM BIT(17)
#define PMC_PSS_BIT_CHT_ISH BIT(18)
#define PMC_PSS_BIT_CHT_DFX_MASTER BIT(26)
#define PMC_PSS_BIT_CHT_DFX_CLUSTER1 BIT(27)
#define PMC_PSS_BIT_CHT_DFX_CLUSTER2 BIT(28)
#define PMC_PSS_BIT_CHT_DFX_CLUSTER3 BIT(29)
#define PMC_PSS_BIT_CHT_DFX_CLUSTER4 BIT(30)
#define PMC_PSS_BIT_CHT_DFX_CLUSTER5 BIT(31)
/* These registers reflect D3 status of functions */ /* These registers reflect D3 status of functions */
#define PMC_D3_STS_0 0xA0 #define PMC_D3_STS_0 0xA0
@ -117,6 +138,10 @@
#define BIT_USH_SS_PHY BIT(2) #define BIT_USH_SS_PHY BIT(2)
#define BIT_DFX BIT(3) #define BIT_DFX BIT(3)
/* CHT specific bits in PMC_D3_STS_1 register */
#define BIT_STS_GMM BIT(1)
#define BIT_STS_ISH BIT(2)
/* PMC I/O Registers */ /* PMC I/O Registers */
#define ACPI_BASE_ADDR_OFFSET 0x40 #define ACPI_BASE_ADDR_OFFSET 0x40
#define ACPI_BASE_ADDR_MASK 0xFFFFFE00 #define ACPI_BASE_ADDR_MASK 0xFFFFFE00
@ -126,4 +151,8 @@
#define SLEEP_TYPE_MASK 0xFFFFECFF #define SLEEP_TYPE_MASK 0xFFFFECFF
#define SLEEP_TYPE_S5 0x1C00 #define SLEEP_TYPE_S5 0x1C00
#define SLEEP_ENABLE 0x2000 #define SLEEP_ENABLE 0x2000
extern int pmc_atom_read(int offset, u32 *value);
extern int pmc_atom_write(int offset, u32 value);
#endif /* PMC_ATOM_H */ #endif /* PMC_ATOM_H */

2
arch/x86/kernel/Makefile
View file

@ -109,8 +109,6 @@ obj-$(CONFIG_EFI) += sysfb_efi.o
obj-$(CONFIG_PERF_EVENTS) += perf_regs.o obj-$(CONFIG_PERF_EVENTS) += perf_regs.o
obj-$(CONFIG_TRACING) += tracepoint.o obj-$(CONFIG_TRACING) += tracepoint.o
obj-$(CONFIG_IOSF_MBI) += iosf_mbi.o
obj-$(CONFIG_PMC_ATOM) += pmc_atom.o
### ###
# 64 bit specific files # 64 bit specific files

1
arch/x86/kernel/cpu/mshyperv.c
View file

@ -188,6 +188,7 @@ static void __init ms_hyperv_init_platform(void)
machine_ops.shutdown = hv_machine_shutdown; machine_ops.shutdown = hv_machine_shutdown;
machine_ops.crash_shutdown = hv_machine_crash_shutdown; machine_ops.crash_shutdown = hv_machine_crash_shutdown;
mark_tsc_unstable("running on Hyper-V");
} }
const __refconst struct hypervisor_x86 x86_hyper_ms_hyperv = { const __refconst struct hypervisor_x86 x86_hyper_ms_hyperv = {

18
arch/x86/lguest/boot.c
View file

@ -985,23 +985,11 @@ static int lguest_clockevent_set_next_event(unsigned long delta,
return 0; return 0;
} }
static void lguest_clockevent_set_mode(enum clock_event_mode mode, static int lguest_clockevent_shutdown(struct clock_event_device *evt)
struct clock_event_device *evt)
{ {
switch (mode) {
case CLOCK_EVT_MODE_UNUSED:
case CLOCK_EVT_MODE_SHUTDOWN:
/* A 0 argument shuts the clock down. */ /* A 0 argument shuts the clock down. */
hcall(LHCALL_SET_CLOCKEVENT, 0, 0, 0, 0); hcall(LHCALL_SET_CLOCKEVENT, 0, 0, 0, 0);
break; return 0;
case CLOCK_EVT_MODE_ONESHOT:
/* This is what we expect. */
break;
case CLOCK_EVT_MODE_PERIODIC:
BUG();
case CLOCK_EVT_MODE_RESUME:
break;
}
} }
/* This describes our primitive timer chip. */ /* This describes our primitive timer chip. */
@ -1009,7 +997,7 @@ static struct clock_event_device lguest_clockevent = {
.name = "lguest", .name = "lguest",
.features = CLOCK_EVT_FEAT_ONESHOT, .features = CLOCK_EVT_FEAT_ONESHOT,
.set_next_event = lguest_clockevent_set_next_event, .set_next_event = lguest_clockevent_set_next_event,
.set_mode = lguest_clockevent_set_mode, .set_state_shutdown = lguest_clockevent_shutdown,
.rating = INT_MAX, .rating = INT_MAX,
.mult = 1, .mult = 1,
.shift = 0, .shift = 0,

36
arch/x86/pci/intel_mid_pci.c
View file

@ -35,6 +35,9 @@
#define PCIE_CAP_OFFSET 0x100 #define PCIE_CAP_OFFSET 0x100
/* Quirks for the listed devices */
#define PCI_DEVICE_ID_INTEL_MRFL_MMC 0x1190
/* Fixed BAR fields */ /* Fixed BAR fields */
#define PCIE_VNDR_CAP_ID_FIXED_BAR 0x00 /* Fixed BAR (TBD) */ #define PCIE_VNDR_CAP_ID_FIXED_BAR 0x00 /* Fixed BAR (TBD) */
#define PCI_FIXED_BAR_0_SIZE 0x04 #define PCI_FIXED_BAR_0_SIZE 0x04
@ -210,22 +213,41 @@ static int intel_mid_pci_irq_enable(struct pci_dev *dev)
{ {
struct irq_alloc_info info; struct irq_alloc_info info;
int polarity; int polarity;
int ret;
if (pci_has_managed_irq(dev)) if (pci_has_managed_irq(dev))
return 0; return 0;
if (intel_mid_identify_cpu() == INTEL_MID_CPU_CHIP_TANGIER) switch (intel_mid_identify_cpu()) {
polarity = 0; /* active high */ case INTEL_MID_CPU_CHIP_TANGIER:
else polarity = IOAPIC_POL_HIGH;
polarity = 1; /* active low */
/* Special treatment for IRQ0 */
if (dev->irq == 0) {
/*
* TNG has IRQ0 assigned to eMMC controller. But there
* are also other devices with bogus PCI configuration
* that have IRQ0 assigned. This check ensures that
* eMMC gets it.
*/
if (dev->device != PCI_DEVICE_ID_INTEL_MRFL_MMC)
return -EBUSY;
}
break;
default:
polarity = IOAPIC_POL_LOW;
break;
}
ioapic_set_alloc_attr(&info, dev_to_node(&dev->dev), 1, polarity); ioapic_set_alloc_attr(&info, dev_to_node(&dev->dev), 1, polarity);
/* /*
* MRST only have IOAPIC, the PCI irq lines are 1:1 mapped to * MRST only have IOAPIC, the PCI irq lines are 1:1 mapped to
* IOAPIC RTE entries, so we just enable RTE for the device. * IOAPIC RTE entries, so we just enable RTE for the device.
*/ */
if (mp_map_gsi_to_irq(dev->irq, IOAPIC_MAP_ALLOC, &info) < 0) ret = mp_map_gsi_to_irq(dev->irq, IOAPIC_MAP_ALLOC, &info);
return -EBUSY; if (ret < 0)
return ret;
dev->irq_managed = 1; dev->irq_managed = 1;
@ -244,7 +266,7 @@ static void intel_mid_pci_irq_disable(struct pci_dev *dev)
} }
} }
struct pci_ops intel_mid_pci_ops = { static struct pci_ops intel_mid_pci_ops = {
.read = pci_read, .read = pci_read,
.write = pci_write, .write = pci_write,
}; };

1
arch/x86/platform/Makefile
View file

@ -5,6 +5,7 @@ obj-y += efi/
obj-y += geode/ obj-y += geode/
obj-y += goldfish/ obj-y += goldfish/
obj-y += iris/ obj-y += iris/
obj-y += intel/
obj-y += intel-mid/ obj-y += intel-mid/
obj-y += intel-quark/ obj-y += intel-quark/
obj-y += olpc/ obj-y += olpc/

1
arch/x86/platform/atom/Makefile
View file

@ -1 +1,2 @@
obj-$(CONFIG_PMC_ATOM) += pmc_atom.o
obj-$(CONFIG_PUNIT_ATOM_DEBUG) += punit_atom_debug.o obj-$(CONFIG_PUNIT_ATOM_DEBUG) += punit_atom_debug.o

327
arch/x86/kernel/pmc_atom.c → arch/x86/platform/atom/pmc_atom.c
View file

@ -15,7 +15,6 @@
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
#include <linux/module.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/pci.h> #include <linux/pci.h>
#include <linux/device.h> #include <linux/device.h>
@ -25,80 +24,149 @@
#include <asm/pmc_atom.h> #include <asm/pmc_atom.h>
struct pmc_dev {
u32 base_addr;
void __iomem *regmap;
#ifdef CONFIG_DEBUG_FS
struct dentry *dbgfs_dir;
#endif /* CONFIG_DEBUG_FS */
};
static struct pmc_dev pmc_device;
static u32 acpi_base_addr;
struct pmc_bit_map { struct pmc_bit_map {
const char *name; const char *name;
u32 bit_mask; u32 bit_mask;
}; };
static const struct pmc_bit_map dev_map[] = { struct pmc_reg_map {
{"0 - LPSS1_F0_DMA", BIT_LPSS1_F0_DMA}, const struct pmc_bit_map *d3_sts_0;
{"1 - LPSS1_F1_PWM1", BIT_LPSS1_F1_PWM1}, const struct pmc_bit_map *d3_sts_1;
{"2 - LPSS1_F2_PWM2", BIT_LPSS1_F2_PWM2}, const struct pmc_bit_map *func_dis;
{"3 - LPSS1_F3_HSUART1", BIT_LPSS1_F3_HSUART1}, const struct pmc_bit_map *func_dis_2;
{"4 - LPSS1_F4_HSUART2", BIT_LPSS1_F4_HSUART2}, const struct pmc_bit_map *pss;
{"5 - LPSS1_F5_SPI", BIT_LPSS1_F5_SPI},
{"6 - LPSS1_F6_Reserved", BIT_LPSS1_F6_XXX},
{"7 - LPSS1_F7_Reserved", BIT_LPSS1_F7_XXX},
{"8 - SCC_EMMC", BIT_SCC_EMMC},
{"9 - SCC_SDIO", BIT_SCC_SDIO},
{"10 - SCC_SDCARD", BIT_SCC_SDCARD},
{"11 - SCC_MIPI", BIT_SCC_MIPI},
{"12 - HDA", BIT_HDA},
{"13 - LPE", BIT_LPE},
{"14 - OTG", BIT_OTG},
{"15 - USH", BIT_USH},
{"16 - GBE", BIT_GBE},
{"17 - SATA", BIT_SATA},
{"18 - USB_EHCI", BIT_USB_EHCI},
{"19 - SEC", BIT_SEC},
{"20 - PCIE_PORT0", BIT_PCIE_PORT0},
{"21 - PCIE_PORT1", BIT_PCIE_PORT1},
{"22 - PCIE_PORT2", BIT_PCIE_PORT2},
{"23 - PCIE_PORT3", BIT_PCIE_PORT3},
{"24 - LPSS2_F0_DMA", BIT_LPSS2_F0_DMA},
{"25 - LPSS2_F1_I2C1", BIT_LPSS2_F1_I2C1},
{"26 - LPSS2_F2_I2C2", BIT_LPSS2_F2_I2C2},
{"27 - LPSS2_F3_I2C3", BIT_LPSS2_F3_I2C3},
{"28 - LPSS2_F3_I2C4", BIT_LPSS2_F4_I2C4},
{"29 - LPSS2_F5_I2C5", BIT_LPSS2_F5_I2C5},
{"30 - LPSS2_F6_I2C6", BIT_LPSS2_F6_I2C6},
{"31 - LPSS2_F7_I2C7", BIT_LPSS2_F7_I2C7},
{"32 - SMB", BIT_SMB},
{"33 - OTG_SS_PHY", BIT_OTG_SS_PHY},
{"34 - USH_SS_PHY", BIT_USH_SS_PHY},
{"35 - DFX", BIT_DFX},
}; };
static const struct pmc_bit_map pss_map[] = { struct pmc_dev {
{"0 - GBE", PMC_PSS_BIT_GBE}, u32 base_addr;
{"1 - SATA", PMC_PSS_BIT_SATA}, void __iomem *regmap;
{"2 - HDA", PMC_PSS_BIT_HDA}, const struct pmc_reg_map *map;
{"3 - SEC", PMC_PSS_BIT_SEC}, #ifdef CONFIG_DEBUG_FS
{"4 - PCIE", PMC_PSS_BIT_PCIE}, struct dentry *dbgfs_dir;
{"5 - LPSS", PMC_PSS_BIT_LPSS}, #endif /* CONFIG_DEBUG_FS */
{"6 - LPE", PMC_PSS_BIT_LPE}, bool init;
{"7 - DFX", PMC_PSS_BIT_DFX}, };
{"8 - USH_CTRL", PMC_PSS_BIT_USH_CTRL},
{"9 - USH_SUS", PMC_PSS_BIT_USH_SUS}, static struct pmc_dev pmc_device;
{"10 - USH_VCCS", PMC_PSS_BIT_USH_VCCS}, static u32 acpi_base_addr;
{"11 - USH_VCCA", PMC_PSS_BIT_USH_VCCA},
{"12 - OTG_CTRL", PMC_PSS_BIT_OTG_CTRL}, static const struct pmc_bit_map d3_sts_0_map[] = {
{"13 - OTG_VCCS", PMC_PSS_BIT_OTG_VCCS}, {"LPSS1_F0_DMA", BIT_LPSS1_F0_DMA},
{"14 - OTG_VCCA_CLK", PMC_PSS_BIT_OTG_VCCA_CLK}, {"LPSS1_F1_PWM1", BIT_LPSS1_F1_PWM1},
{"15 - OTG_VCCA", PMC_PSS_BIT_OTG_VCCA}, {"LPSS1_F2_PWM2", BIT_LPSS1_F2_PWM2},
{"16 - USB", PMC_PSS_BIT_USB}, {"LPSS1_F3_HSUART1", BIT_LPSS1_F3_HSUART1},
{"17 - USB_SUS", PMC_PSS_BIT_USB_SUS}, {"LPSS1_F4_HSUART2", BIT_LPSS1_F4_HSUART2},
{"LPSS1_F5_SPI", BIT_LPSS1_F5_SPI},
{"LPSS1_F6_Reserved", BIT_LPSS1_F6_XXX},
{"LPSS1_F7_Reserved", BIT_LPSS1_F7_XXX},
{"SCC_EMMC", BIT_SCC_EMMC},
{"SCC_SDIO", BIT_SCC_SDIO},
{"SCC_SDCARD", BIT_SCC_SDCARD},
{"SCC_MIPI", BIT_SCC_MIPI},
{"HDA", BIT_HDA},
{"LPE", BIT_LPE},
{"OTG", BIT_OTG},
{"USH", BIT_USH},
{"GBE", BIT_GBE},
{"SATA", BIT_SATA},
{"USB_EHCI", BIT_USB_EHCI},
{"SEC", BIT_SEC},
{"PCIE_PORT0", BIT_PCIE_PORT0},
{"PCIE_PORT1", BIT_PCIE_PORT1},
{"PCIE_PORT2", BIT_PCIE_PORT2},
{"PCIE_PORT3", BIT_PCIE_PORT3},
{"LPSS2_F0_DMA", BIT_LPSS2_F0_DMA},
{"LPSS2_F1_I2C1", BIT_LPSS2_F1_I2C1},
{"LPSS2_F2_I2C2", BIT_LPSS2_F2_I2C2},
{"LPSS2_F3_I2C3", BIT_LPSS2_F3_I2C3},
{"LPSS2_F3_I2C4", BIT_LPSS2_F4_I2C4},
{"LPSS2_F5_I2C5", BIT_LPSS2_F5_I2C5},
{"LPSS2_F6_I2C6", BIT_LPSS2_F6_I2C6},
{"LPSS2_F7_I2C7", BIT_LPSS2_F7_I2C7},
{},
};
static struct pmc_bit_map byt_d3_sts_1_map[] = {
{"SMB", BIT_SMB},
{"OTG_SS_PHY", BIT_OTG_SS_PHY},
{"USH_SS_PHY", BIT_USH_SS_PHY},
{"DFX", BIT_DFX},
{},
};
static struct pmc_bit_map cht_d3_sts_1_map[] = {
{"SMB", BIT_SMB},
{"GMM", BIT_STS_GMM},
{"ISH", BIT_STS_ISH},
{},
};
static struct pmc_bit_map cht_func_dis_2_map[] = {
{"SMB", BIT_SMB},
{"GMM", BIT_FD_GMM},
{"ISH", BIT_FD_ISH},
{},
};
static const struct pmc_bit_map byt_pss_map[] = {
{"GBE", PMC_PSS_BIT_GBE},
{"SATA", PMC_PSS_BIT_SATA},
{"HDA", PMC_PSS_BIT_HDA},
{"SEC", PMC_PSS_BIT_SEC},
{"PCIE", PMC_PSS_BIT_PCIE},
{"LPSS", PMC_PSS_BIT_LPSS},
{"LPE", PMC_PSS_BIT_LPE},
{"DFX", PMC_PSS_BIT_DFX},
{"USH_CTRL", PMC_PSS_BIT_USH_CTRL},
{"USH_SUS", PMC_PSS_BIT_USH_SUS},
{"USH_VCCS", PMC_PSS_BIT_USH_VCCS},
{"USH_VCCA", PMC_PSS_BIT_USH_VCCA},
{"OTG_CTRL", PMC_PSS_BIT_OTG_CTRL},
{"OTG_VCCS", PMC_PSS_BIT_OTG_VCCS},
{"OTG_VCCA_CLK", PMC_PSS_BIT_OTG_VCCA_CLK},
{"OTG_VCCA", PMC_PSS_BIT_OTG_VCCA},
{"USB", PMC_PSS_BIT_USB},
{"USB_SUS", PMC_PSS_BIT_USB_SUS},
{},
};
static const struct pmc_bit_map cht_pss_map[] = {
{"SATA", PMC_PSS_BIT_SATA},
{"HDA", PMC_PSS_BIT_HDA},
{"SEC", PMC_PSS_BIT_SEC},
{"PCIE", PMC_PSS_BIT_PCIE},
{"LPSS", PMC_PSS_BIT_LPSS},
{"LPE", PMC_PSS_BIT_LPE},
{"UFS", PMC_PSS_BIT_CHT_UFS},
{"UXD", PMC_PSS_BIT_CHT_UXD},
{"UXD_FD", PMC_PSS_BIT_CHT_UXD_FD},
{"UX_ENG", PMC_PSS_BIT_CHT_UX_ENG},
{"USB_SUS", PMC_PSS_BIT_CHT_USB_SUS},
{"GMM", PMC_PSS_BIT_CHT_GMM},
{"ISH", PMC_PSS_BIT_CHT_ISH},
{"DFX_MASTER", PMC_PSS_BIT_CHT_DFX_MASTER},
{"DFX_CLUSTER1", PMC_PSS_BIT_CHT_DFX_CLUSTER1},
{"DFX_CLUSTER2", PMC_PSS_BIT_CHT_DFX_CLUSTER2},
{"DFX_CLUSTER3", PMC_PSS_BIT_CHT_DFX_CLUSTER3},
{"DFX_CLUSTER4", PMC_PSS_BIT_CHT_DFX_CLUSTER4},
{"DFX_CLUSTER5", PMC_PSS_BIT_CHT_DFX_CLUSTER5},
{},
};
static const struct pmc_reg_map byt_reg_map = {
.d3_sts_0 = d3_sts_0_map,
.d3_sts_1 = byt_d3_sts_1_map,
.func_dis = d3_sts_0_map,
.func_dis_2 = byt_d3_sts_1_map,
.pss = byt_pss_map,
};
static const struct pmc_reg_map cht_reg_map = {
.d3_sts_0 = d3_sts_0_map,
.d3_sts_1 = cht_d3_sts_1_map,
.func_dis = d3_sts_0_map,
.func_dis_2 = cht_func_dis_2_map,
.pss = cht_pss_map,
}; };
static inline u32 pmc_reg_read(struct pmc_dev *pmc, int reg_offset) static inline u32 pmc_reg_read(struct pmc_dev *pmc, int reg_offset)
@ -111,6 +179,30 @@ static inline void pmc_reg_write(struct pmc_dev *pmc, int reg_offset, u32 val)
writel(val, pmc->regmap + reg_offset); writel(val, pmc->regmap + reg_offset);
} }
int pmc_atom_read(int offset, u32 *value)
{
struct pmc_dev *pmc = &pmc_device;
if (!pmc->init)
return -ENODEV;
*value = pmc_reg_read(pmc, offset);
return 0;
}
EXPORT_SYMBOL_GPL(pmc_atom_read);
int pmc_atom_write(int offset, u32 value)
{
struct pmc_dev *pmc = &pmc_device;
if (!pmc->init)
return -ENODEV;
pmc_reg_write(pmc, offset, value);
return 0;
}
EXPORT_SYMBOL_GPL(pmc_atom_write);
static void pmc_power_off(void) static void pmc_power_off(void)
{ {
u16 pm1_cnt_port; u16 pm1_cnt_port;
@ -142,37 +234,39 @@ static void pmc_hw_reg_setup(struct pmc_dev *pmc)
} }
#ifdef CONFIG_DEBUG_FS #ifdef CONFIG_DEBUG_FS
static void pmc_dev_state_print(struct seq_file *s, int reg_index,
u32 sts, const struct pmc_bit_map *sts_map,
u32 fd, const struct pmc_bit_map *fd_map)
{
int offset = PMC_REG_BIT_WIDTH * reg_index;
int index;
for (index = 0; sts_map[index].name; index++) {
seq_printf(s, "Dev: %-2d - %-32s\tState: %s [%s]\n",
offset + index, sts_map[index].name,
fd_map[index].bit_mask & fd ? "Disabled" : "Enabled ",
sts_map[index].bit_mask & sts ? "D3" : "D0");
}
}
static int pmc_dev_state_show(struct seq_file *s, void *unused) static int pmc_dev_state_show(struct seq_file *s, void *unused)
{ {
struct pmc_dev *pmc = s->private; struct pmc_dev *pmc = s->private;
u32 func_dis, func_dis_2, func_dis_index; const struct pmc_reg_map *m = pmc->map;
u32 d3_sts_0, d3_sts_1, d3_sts_index; u32 func_dis, func_dis_2;
int dev_num, dev_index, reg_index; u32 d3_sts_0, d3_sts_1;
func_dis = pmc_reg_read(pmc, PMC_FUNC_DIS); func_dis = pmc_reg_read(pmc, PMC_FUNC_DIS);
func_dis_2 = pmc_reg_read(pmc, PMC_FUNC_DIS_2); func_dis_2 = pmc_reg_read(pmc, PMC_FUNC_DIS_2);
d3_sts_0 = pmc_reg_read(pmc, PMC_D3_STS_0); d3_sts_0 = pmc_reg_read(pmc, PMC_D3_STS_0);
d3_sts_1 = pmc_reg_read(pmc, PMC_D3_STS_1); d3_sts_1 = pmc_reg_read(pmc, PMC_D3_STS_1);
dev_num = ARRAY_SIZE(dev_map); /* Low part */
pmc_dev_state_print(s, 0, d3_sts_0, m->d3_sts_0, func_dis, m->func_dis);
for (dev_index = 0; dev_index < dev_num; dev_index++) { /* High part */
reg_index = dev_index / PMC_REG_BIT_WIDTH; pmc_dev_state_print(s, 1, d3_sts_1, m->d3_sts_1, func_dis_2, m->func_dis_2);
if (reg_index) {
func_dis_index = func_dis_2;
d3_sts_index = d3_sts_1;
} else {
func_dis_index = func_dis;
d3_sts_index = d3_sts_0;
}
seq_printf(s, "Dev: %-32s\tState: %s [%s]\n",
dev_map[dev_index].name,
dev_map[dev_index].bit_mask & func_dis_index ?
"Disabled" : "Enabled ",
dev_map[dev_index].bit_mask & d3_sts_index ?
"D3" : "D0");
}
return 0; return 0;
} }
@ -191,13 +285,14 @@ static const struct file_operations pmc_dev_state_ops = {
static int pmc_pss_state_show(struct seq_file *s, void *unused) static int pmc_pss_state_show(struct seq_file *s, void *unused)
{ {
struct pmc_dev *pmc = s->private; struct pmc_dev *pmc = s->private;
const struct pmc_bit_map *map = pmc->map->pss;
u32 pss = pmc_reg_read(pmc, PMC_PSS); u32 pss = pmc_reg_read(pmc, PMC_PSS);
int pss_index; int index;
for (pss_index = 0; pss_index < ARRAY_SIZE(pss_map); pss_index++) { for (index = 0; map[index].name; index++) {
seq_printf(s, "Island: %-32s\tState: %s\n", seq_printf(s, "Island: %-2d - %-32s\tState: %s\n",
pss_map[pss_index].name, index, map[index].name,
pss_map[pss_index].bit_mask & pss ? "Off" : "On"); map[index].bit_mask & pss ? "Off" : "On");
} }
return 0; return 0;
} }
@ -250,7 +345,7 @@ static void pmc_dbgfs_unregister(struct pmc_dev *pmc)
debugfs_remove_recursive(pmc->dbgfs_dir); debugfs_remove_recursive(pmc->dbgfs_dir);
} }
static int pmc_dbgfs_register(struct pmc_dev *pmc, struct pci_dev *pdev) static int pmc_dbgfs_register(struct pmc_dev *pmc)
{ {
struct dentry *dir, *f; struct dentry *dir, *f;
@ -262,24 +357,18 @@ static int pmc_dbgfs_register(struct pmc_dev *pmc, struct pci_dev *pdev)
f = debugfs_create_file("dev_state", S_IFREG | S_IRUGO, f = debugfs_create_file("dev_state", S_IFREG | S_IRUGO,
dir, pmc, &pmc_dev_state_ops); dir, pmc, &pmc_dev_state_ops);
if (!f) { if (!f)
dev_err(&pdev->dev, "dev_state register failed\n");
goto err; goto err;
}
f = debugfs_create_file("pss_state", S_IFREG | S_IRUGO, f = debugfs_create_file("pss_state", S_IFREG | S_IRUGO,
dir, pmc, &pmc_pss_state_ops); dir, pmc, &pmc_pss_state_ops);
if (!f) { if (!f)
dev_err(&pdev->dev, "pss_state register failed\n");
goto err; goto err;
}
f = debugfs_create_file("sleep_state", S_IFREG | S_IRUGO, f = debugfs_create_file("sleep_state", S_IFREG | S_IRUGO,
dir, pmc, &pmc_sleep_tmr_ops); dir, pmc, &pmc_sleep_tmr_ops);
if (!f) { if (!f)
dev_err(&pdev->dev, "sleep_state register failed\n");
goto err; goto err;
}
return 0; return 0;
err: err:
@ -287,15 +376,16 @@ err:
return -ENODEV; return -ENODEV;
} }
#else #else
static int pmc_dbgfs_register(struct pmc_dev *pmc, struct pci_dev *pdev) static int pmc_dbgfs_register(struct pmc_dev *pmc)
{ {
return 0; return 0;
} }
#endif /* CONFIG_DEBUG_FS */ #endif /* CONFIG_DEBUG_FS */
static int pmc_setup_dev(struct pci_dev *pdev) static int pmc_setup_dev(struct pci_dev *pdev, const struct pci_device_id *ent)
{ {
struct pmc_dev *pmc = &pmc_device; struct pmc_dev *pmc = &pmc_device;
const struct pmc_reg_map *map = (struct pmc_reg_map *)ent->driver_data;
int ret; int ret;
/* Obtain ACPI base address */ /* Obtain ACPI base address */
@ -315,32 +405,30 @@ static int pmc_setup_dev(struct pci_dev *pdev)
return -ENOMEM; return -ENOMEM;
} }
pmc->map = map;
/* PMC hardware registers setup */ /* PMC hardware registers setup */
pmc_hw_reg_setup(pmc); pmc_hw_reg_setup(pmc);
ret = pmc_dbgfs_register(pmc, pdev); ret = pmc_dbgfs_register(pmc);
if (ret) { if (ret)
iounmap(pmc->regmap); dev_warn(&pdev->dev, "debugfs register failed\n");
}
pmc->init = true;
return ret; return ret;
} }
/* /*
* Data for PCI driver interface * Data for PCI driver interface
* *
* This data only exists for exporting the supported * used by pci_match_id() call below.
* PCI ids via MODULE_DEVICE_TABLE. We do not actually
* register a pci_driver, because lpc_ich will register
* a driver on the same PCI id.
*/ */
static const struct pci_device_id pmc_pci_ids[] = { static const struct pci_device_id pmc_pci_ids[] = {
{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_VLV_PMC) }, { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_VLV_PMC), (kernel_ulong_t)&byt_reg_map },
{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_CHT_PMC), (kernel_ulong_t)&cht_reg_map },
{ 0, }, { 0, },
}; };
MODULE_DEVICE_TABLE(pci, pmc_pci_ids);
static int __init pmc_atom_init(void) static int __init pmc_atom_init(void)
{ {
struct pci_dev *pdev = NULL; struct pci_dev *pdev = NULL;
@ -357,15 +445,16 @@ static int __init pmc_atom_init(void)
for_each_pci_dev(pdev) { for_each_pci_dev(pdev) {
ent = pci_match_id(pmc_pci_ids, pdev); ent = pci_match_id(pmc_pci_ids, pdev);
if (ent) if (ent)
return pmc_setup_dev(pdev); return pmc_setup_dev(pdev, ent);
} }
/* Device not found. */ /* Device not found. */
return -ENODEV; return -ENODEV;
} }
module_init(pmc_atom_init); device_initcall(pmc_atom_init);
/* no module_exit, this driver shouldn't be unloaded */
/*
MODULE_AUTHOR("Aubrey Li <aubrey.li@linux.intel.com>"); MODULE_AUTHOR("Aubrey Li <aubrey.li@linux.intel.com>");
MODULE_DESCRIPTION("Intel Atom SOC Power Management Controller Interface"); MODULE_DESCRIPTION("Intel Atom SOC Power Management Controller Interface");
MODULE_LICENSE("GPL v2"); MODULE_LICENSE("GPL v2");
*/

1
arch/x86/platform/intel/Makefile Normal file
View file

@ -0,0 +1 @@
obj-$(CONFIG_IOSF_MBI) += iosf_mbi.o

17
arch/x86/kernel/iosf_mbi.c → arch/x86/platform/intel/iosf_mbi.c
View file

@ -30,7 +30,9 @@
#define PCI_DEVICE_ID_BAYTRAIL 0x0F00 #define PCI_DEVICE_ID_BAYTRAIL 0x0F00
#define PCI_DEVICE_ID_BRASWELL 0x2280 #define PCI_DEVICE_ID_BRASWELL 0x2280
#define PCI_DEVICE_ID_QUARK_X1000 0x0958 #define PCI_DEVICE_ID_QUARK_X1000 0x0958
#define PCI_DEVICE_ID_TANGIER 0x1170
static struct pci_dev *mbi_pdev;
static DEFINE_SPINLOCK(iosf_mbi_lock); static DEFINE_SPINLOCK(iosf_mbi_lock);
static inline u32 iosf_mbi_form_mcr(u8 op, u8 port, u8 offset) static inline u32 iosf_mbi_form_mcr(u8 op, u8 port, u8 offset)
@ -38,8 +40,6 @@ static inline u32 iosf_mbi_form_mcr(u8 op, u8 port, u8 offset)
return (op << 24) | (port << 16) | (offset << 8) | MBI_ENABLE; return (op << 24) | (port << 16) | (offset << 8) | MBI_ENABLE;
} }
static struct pci_dev *mbi_pdev; /* one mbi device */
static int iosf_mbi_pci_read_mdr(u32 mcrx, u32 mcr, u32 *mdr) static int iosf_mbi_pci_read_mdr(u32 mcrx, u32 mcr, u32 *mdr)
{ {
int result; int result;
@ -240,17 +240,17 @@ static void iosf_sideband_debug_init(void)
/* mdr */ /* mdr */
d = debugfs_create_x32("mdr", 0660, iosf_dbg, &dbg_mdr); d = debugfs_create_x32("mdr", 0660, iosf_dbg, &dbg_mdr);
if (IS_ERR_OR_NULL(d)) if (!d)
goto cleanup; goto cleanup;
/* mcrx */ /* mcrx */
debugfs_create_x32("mcrx", 0660, iosf_dbg, &dbg_mcrx); d = debugfs_create_x32("mcrx", 0660, iosf_dbg, &dbg_mcrx);
if (IS_ERR_OR_NULL(d)) if (!d)
goto cleanup; goto cleanup;
/* mcr - initiates mailbox tranaction */ /* mcr - initiates mailbox tranaction */
debugfs_create_file("mcr", 0660, iosf_dbg, &dbg_mcr, &iosf_mcr_fops); d = debugfs_create_file("mcr", 0660, iosf_dbg, &dbg_mcr, &iosf_mcr_fops);
if (IS_ERR_OR_NULL(d)) if (!d)
goto cleanup; goto cleanup;
return; return;
@ -292,6 +292,7 @@ static const struct pci_device_id iosf_mbi_pci_ids[] = {
{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_BAYTRAIL) }, { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_BAYTRAIL) },
{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_BRASWELL) }, { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_BRASWELL) },
{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_QUARK_X1000) }, { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_QUARK_X1000) },
{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_TANGIER) },
{ 0, }, { 0, },
}; };
MODULE_DEVICE_TABLE(pci, iosf_mbi_pci_ids); MODULE_DEVICE_TABLE(pci, iosf_mbi_pci_ids);
@ -314,11 +315,9 @@ static void __exit iosf_mbi_exit(void)
iosf_debugfs_remove(); iosf_debugfs_remove();
pci_unregister_driver(&iosf_mbi_pci_driver); pci_unregister_driver(&iosf_mbi_pci_driver);
if (mbi_pdev) {
pci_dev_put(mbi_pdev); pci_dev_put(mbi_pdev);
mbi_pdev = NULL; mbi_pdev = NULL;
} }
}
module_init(iosf_mbi_init); module_init(iosf_mbi_init);
module_exit(iosf_mbi_exit); module_exit(iosf_mbi_exit);

21
arch/x86/platform/uv/uv_time.c
View file

@ -32,8 +32,7 @@
static cycle_t uv_read_rtc(struct clocksource *cs); static cycle_t uv_read_rtc(struct clocksource *cs);
static int uv_rtc_next_event(unsigned long, struct clock_event_device *); static int uv_rtc_next_event(unsigned long, struct clock_event_device *);
static void uv_rtc_timer_setup(enum clock_event_mode, static int uv_rtc_shutdown(struct clock_event_device *evt);
struct clock_event_device *);
static struct clocksource clocksource_uv = { static struct clocksource clocksource_uv = {
.name = RTC_NAME, .name = RTC_NAME,
@ -50,7 +49,7 @@ static struct clock_event_device clock_event_device_uv = {
.rating = 400, .rating = 400,
.irq = -1, .irq = -1,
.set_next_event = uv_rtc_next_event, .set_next_event = uv_rtc_next_event,
.set_mode = uv_rtc_timer_setup, .set_state_shutdown = uv_rtc_shutdown,
.event_handler = NULL, .event_handler = NULL,
}; };
@ -321,24 +320,14 @@ static int uv_rtc_next_event(unsigned long delta,
} }
/* /*
* Setup the RTC timer in oneshot mode * Shutdown the RTC timer
*/ */
static void uv_rtc_timer_setup(enum clock_event_mode mode, static int uv_rtc_shutdown(struct clock_event_device *evt)
struct clock_event_device *evt)
{ {
int ced_cpu = cpumask_first(evt->cpumask); int ced_cpu = cpumask_first(evt->cpumask);
switch (mode) {
case CLOCK_EVT_MODE_PERIODIC:
case CLOCK_EVT_MODE_ONESHOT:
case CLOCK_EVT_MODE_RESUME:
/* Nothing to do here yet */
break;
case CLOCK_EVT_MODE_UNUSED:
case CLOCK_EVT_MODE_SHUTDOWN:
uv_rtc_unset_timer(ced_cpu, 1); uv_rtc_unset_timer(ced_cpu, 1);
break; return 0;
}
} }
static void uv_rtc_interrupt(void) static void uv_rtc_interrupt(void)

60
arch/x86/xen/time.c
View file

@ -274,30 +274,18 @@ static s64 get_abs_timeout(unsigned long delta)
return xen_clocksource_read() + delta; return xen_clocksource_read() + delta;
} }
static void xen_timerop_set_mode(enum clock_event_mode mode, static int xen_timerop_shutdown(struct clock_event_device *evt)
struct clock_event_device *evt)
{ {
switch (mode) { /* cancel timeout */
case CLOCK_EVT_MODE_PERIODIC: HYPERVISOR_set_timer_op(0);
/* unsupported */
WARN_ON(1);
break;
case CLOCK_EVT_MODE_ONESHOT: return 0;
case CLOCK_EVT_MODE_RESUME:
break;
case CLOCK_EVT_MODE_UNUSED:
case CLOCK_EVT_MODE_SHUTDOWN:
HYPERVISOR_set_timer_op(0); /* cancel timeout */
break;
}
} }
static int xen_timerop_set_next_event(unsigned long delta, static int xen_timerop_set_next_event(unsigned long delta,
struct clock_event_device *evt) struct clock_event_device *evt)
{ {
WARN_ON(evt->mode != CLOCK_EVT_MODE_ONESHOT); WARN_ON(!clockevent_state_oneshot(evt));
if (HYPERVISOR_set_timer_op(get_abs_timeout(delta)) < 0) if (HYPERVISOR_set_timer_op(get_abs_timeout(delta)) < 0)
BUG(); BUG();
@ -320,36 +308,29 @@ static const struct clock_event_device xen_timerop_clockevent = {
.shift = 0, .shift = 0,
.rating = 500, .rating = 500,
.set_mode = xen_timerop_set_mode, .set_state_shutdown = xen_timerop_shutdown,
.set_next_event = xen_timerop_set_next_event, .set_next_event = xen_timerop_set_next_event,
}; };
static int xen_vcpuop_shutdown(struct clock_event_device *evt)
static void xen_vcpuop_set_mode(enum clock_event_mode mode,
struct clock_event_device *evt)
{ {
int cpu = smp_processor_id(); int cpu = smp_processor_id();
switch (mode) {
case CLOCK_EVT_MODE_PERIODIC:
WARN_ON(1); /* unsupported */
break;
case CLOCK_EVT_MODE_ONESHOT:
if (HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer, cpu, NULL))
BUG();
break;
case CLOCK_EVT_MODE_UNUSED:
case CLOCK_EVT_MODE_SHUTDOWN:
if (HYPERVISOR_vcpu_op(VCPUOP_stop_singleshot_timer, cpu, NULL) || if (HYPERVISOR_vcpu_op(VCPUOP_stop_singleshot_timer, cpu, NULL) ||
HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer, cpu, NULL)) HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer, cpu, NULL))
BUG(); BUG();
break;
case CLOCK_EVT_MODE_RESUME: return 0;
break;
} }
static int xen_vcpuop_set_oneshot(struct clock_event_device *evt)
{
int cpu = smp_processor_id();
if (HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer, cpu, NULL))
BUG();
return 0;
} }
static int xen_vcpuop_set_next_event(unsigned long delta, static int xen_vcpuop_set_next_event(unsigned long delta,
@ -359,7 +340,7 @@ static int xen_vcpuop_set_next_event(unsigned long delta,
struct vcpu_set_singleshot_timer single; struct vcpu_set_singleshot_timer single;
int ret; int ret;
WARN_ON(evt->mode != CLOCK_EVT_MODE_ONESHOT); WARN_ON(!clockevent_state_oneshot(evt));
single.timeout_abs_ns = get_abs_timeout(delta); single.timeout_abs_ns = get_abs_timeout(delta);
single.flags = VCPU_SSHOTTMR_future; single.flags = VCPU_SSHOTTMR_future;
@ -382,7 +363,8 @@ static const struct clock_event_device xen_vcpuop_clockevent = {
.shift = 0, .shift = 0,
.rating = 500, .rating = 500,
.set_mode = xen_vcpuop_set_mode, .set_state_shutdown = xen_vcpuop_shutdown,
.set_state_oneshot = xen_vcpuop_set_oneshot,
.set_next_event = xen_vcpuop_set_next_event, .set_next_event = xen_vcpuop_set_next_event,
}; };