Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 273b5a48 authored by Rafael J. Wysocki's avatar Rafael J. Wysocki
Browse files

Merge branch 'acpi-pmic' 

* acpi-pmic:
  ACPI / PMIC: remove modular references from non-modular code
  ACPI / PMIC: intel: initialize result to 0
  ACPI / PMIC: intel: add REGS operation region support
  ACPI / PMIC: Add opregion driver for Intel BXT WhiskeyCove PMIC
  ACPI / PMIC: modify the pen function signature to take bit field

Conflicts:
	drivers/acpi/Makefile
parents 6149dffc 6d3ef8d8

drivers/acpi/Kconfig

+6 −0
Original line number Diff line number Diff line
@@ -526,6 +526,12 @@ config XPOWER_PMIC_OPREGION 
	help

	  This config adds ACPI operation region support for XPower AXP288 PMIC.



config BXT_WC_PMIC_OPREGION

	bool "ACPI operation region support for BXT WhiskeyCove PMIC"

	depends on INTEL_SOC_PMIC

	help

	  This config adds ACPI operation region support for BXT WhiskeyCove PMIC.



endif



config ACPI_CONFIGFS

drivers/acpi/Makefile

+2 −0
Original line number Diff line number Diff line
@@ -99,6 +99,8 @@ obj-$(CONFIG_ACPI_EXTLOG) += acpi_extlog.o 
obj-$(CONFIG_PMIC_OPREGION)	+= pmic/intel_pmic.o

obj-$(CONFIG_CRC_PMIC_OPREGION) += pmic/intel_pmic_crc.o

obj-$(CONFIG_XPOWER_PMIC_OPREGION) += pmic/intel_pmic_xpower.o

obj-$(CONFIG_BXT_WC_PMIC_OPREGION) += pmic/intel_pmic_bxtwc.o



obj-$(CONFIG_ACPI_CONFIGFS)	+= acpi_configfs.o



video-objs			+= acpi_video.o video_detect.o

drivers/acpi/pmic/intel_pmic.c

+74 −10
Original line number Diff line number Diff line
@@ -13,7 +13,7 @@ 
 * GNU General Public License for more details.

 */



#include <linux/module.h>

#include <linux/export.h>

#include <linux/acpi.h>

#include <linux/regmap.h>

#include <acpi/acpi_lpat.h>
@@ -21,12 +21,19 @@ 


#define PMIC_POWER_OPREGION_ID		0x8d

#define PMIC_THERMAL_OPREGION_ID	0x8c

#define PMIC_REGS_OPREGION_ID		0x8f



struct intel_pmic_regs_handler_ctx {

	unsigned int val;

	u16 addr;

};



struct intel_pmic_opregion {

	struct mutex lock;

	struct acpi_lpat_conversion_table *lpat_table;

	struct regmap *regmap;

	struct intel_pmic_opregion_data *data;

	struct intel_pmic_regs_handler_ctx ctx;

};



static int pmic_get_reg_bit(int address, struct pmic_table *table,
@@ -131,7 +138,7 @@ static int pmic_thermal_aux(struct intel_pmic_opregion *opregion, int reg, 
}



static int pmic_thermal_pen(struct intel_pmic_opregion *opregion, int reg,

			    u32 function, u64 *value)

			    int bit, u32 function, u64 *value)

{

	struct intel_pmic_opregion_data *d = opregion->data;

	struct regmap *regmap = opregion->regmap;
@@ -140,12 +147,12 @@ static int pmic_thermal_pen(struct intel_pmic_opregion *opregion, int reg, 
		return -ENXIO;



	if (function == ACPI_READ)

		return d->get_policy(regmap, reg, value);

		return d->get_policy(regmap, reg, bit, value);



	if (*value != 0 && *value != 1)

		return -EINVAL;



	return d->update_policy(regmap, reg, *value);

	return d->update_policy(regmap, reg, bit, *value);

}



static bool pmic_thermal_is_temp(int address)
@@ -170,13 +177,13 @@ static acpi_status intel_pmic_thermal_handler(u32 function, 
{

	struct intel_pmic_opregion *opregion = region_context;

	struct intel_pmic_opregion_data *d = opregion->data;

	int reg, result;

	int reg, bit, result;



	if (bits != 32 || !value64)

		return AE_BAD_PARAMETER;



	result = pmic_get_reg_bit(address, d->thermal_table,

				  d->thermal_table_count, &reg, NULL);

				  d->thermal_table_count, &reg, &bit);

	if (result == -ENOENT)

		return AE_BAD_PARAMETER;
@@ -187,7 +194,8 @@ static acpi_status intel_pmic_thermal_handler(u32 function, 
	else if (pmic_thermal_is_aux(address))

		result = pmic_thermal_aux(opregion, reg, function, value64);

	else if (pmic_thermal_is_pen(address))

		result = pmic_thermal_pen(opregion, reg, function, value64);

		result = pmic_thermal_pen(opregion, reg, bit,

						function, value64);

	else

		result = -EINVAL;
@@ -203,6 +211,48 @@ static acpi_status intel_pmic_thermal_handler(u32 function, 
	return AE_OK;

}



static acpi_status intel_pmic_regs_handler(u32 function,

		acpi_physical_address address, u32 bits, u64 *value64,

		void *handler_context, void *region_context)

{

	struct intel_pmic_opregion *opregion = region_context;

	int result = 0;



	switch (address) {

	case 0:

		return AE_OK;

	case 1:

		opregion->ctx.addr |= (*value64 & 0xff) << 8;

		return AE_OK;

	case 2:

		opregion->ctx.addr |= *value64 & 0xff;

		return AE_OK;

	case 3:

		opregion->ctx.val = *value64 & 0xff;

		return AE_OK;

	case 4:

		if (*value64) {

			result = regmap_write(opregion->regmap, opregion->ctx.addr,

					      opregion->ctx.val);

		} else {

			result = regmap_read(opregion->regmap, opregion->ctx.addr,

					     &opregion->ctx.val);

			if (result == 0)

				*value64 = opregion->ctx.val;

		}

		memset(&opregion->ctx, 0x00, sizeof(opregion->ctx));

	}



	if (result < 0) {

		if (result == -EINVAL)

			return AE_BAD_PARAMETER;

		else

			return AE_ERROR;

	}



	return AE_OK;

}



int intel_pmic_install_opregion_handler(struct device *dev, acpi_handle handle,

					struct regmap *regmap,

					struct intel_pmic_opregion_data *d)
@@ -242,16 +292,30 @@ int intel_pmic_install_opregion_handler(struct device *dev, acpi_handle handle, 
		acpi_remove_address_space_handler(handle, PMIC_POWER_OPREGION_ID,

						  intel_pmic_power_handler);

		ret = -ENODEV;

		goto out_error;

		goto out_remove_power_handler;

	}



	status = acpi_install_address_space_handler(handle,

			PMIC_REGS_OPREGION_ID, intel_pmic_regs_handler, NULL,

			opregion);

	if (ACPI_FAILURE(status)) {

		ret = -ENODEV;

		goto out_remove_thermal_handler;

	}



	opregion->data = d;

	return 0;



out_remove_thermal_handler:

	acpi_remove_address_space_handler(handle, PMIC_THERMAL_OPREGION_ID,

					  intel_pmic_thermal_handler);



out_remove_power_handler:

	acpi_remove_address_space_handler(handle, PMIC_POWER_OPREGION_ID,

					  intel_pmic_power_handler);



out_error:

	acpi_lpat_free_conversion_table(opregion->lpat_table);

	return ret;

}

EXPORT_SYMBOL_GPL(intel_pmic_install_opregion_handler);
 


MODULE_LICENSE("GPL");

drivers/acpi/pmic/intel_pmic.h

+2 −2
Original line number Diff line number Diff line
@@ -12,8 +12,8 @@ struct intel_pmic_opregion_data { 
	int (*update_power)(struct regmap *r, int reg, int bit, bool on);

	int (*get_raw_temp)(struct regmap *r, int reg);

	int (*update_aux)(struct regmap *r, int reg, int raw_temp);

	int (*get_policy)(struct regmap *r, int reg, u64 *value);

	int (*update_policy)(struct regmap *r, int reg, int enable);

	int (*get_policy)(struct regmap *r, int reg, int bit, u64 *value);

	int (*update_policy)(struct regmap *r, int reg, int bit, int enable);

	struct pmic_table *power_table;

	int power_table_count;

	struct pmic_table *thermal_table;

drivers/acpi/pmic/intel_pmic_bxtwc.c

0 → 100644
+420 −0
Original line number Diff line number Diff line 
/*

 * intel_pmic_bxtwc.c - Intel BXT WhiskeyCove PMIC operation region driver

 *

 * Copyright (C) 2015 Intel Corporation. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License version

 * 2 as published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 */



#include <linux/init.h>

#include <linux/acpi.h>

#include <linux/mfd/intel_soc_pmic.h>

#include <linux/regmap.h>

#include <linux/platform_device.h>

#include "intel_pmic.h"



#define WHISKEY_COVE_ALRT_HIGH_BIT_MASK 0x0F

#define WHISKEY_COVE_ADC_HIGH_BIT(x)	(((x & 0x0F) << 8))

#define WHISKEY_COVE_ADC_CURSRC(x)	(((x & 0xF0) >> 4))

#define VR_MODE_DISABLED        0

#define VR_MODE_AUTO            BIT(0)

#define VR_MODE_NORMAL          BIT(1)

#define VR_MODE_SWITCH          BIT(2)

#define VR_MODE_ECO             (BIT(0)|BIT(1))

#define VSWITCH2_OUTPUT         BIT(5)

#define VSWITCH1_OUTPUT         BIT(4)

#define VUSBPHY_CHARGE          BIT(1)



static struct pmic_table power_table[] = {

	{

		.address = 0x0,

		.reg = 0x63,

		.bit = VR_MODE_AUTO,

	}, /* VDD1 -> VDD1CNT */

	{

		.address = 0x04,

		.reg = 0x65,

		.bit = VR_MODE_AUTO,

	}, /* VDD2 -> VDD2CNT */

	{

		.address = 0x08,

		.reg = 0x67,

		.bit = VR_MODE_AUTO,

	}, /* VDD3 -> VDD3CNT */

	{

		.address = 0x0c,

		.reg = 0x6d,

		.bit = VR_MODE_AUTO,

	}, /* VLFX -> VFLEXCNT */

	{

		.address = 0x10,

		.reg = 0x6f,

		.bit = VR_MODE_NORMAL,

	}, /* VP1A -> VPROG1ACNT */

	{

		.address = 0x14,

		.reg = 0x70,

		.bit = VR_MODE_NORMAL,

	}, /* VP1B -> VPROG1BCNT */

	{

		.address = 0x18,

		.reg = 0x71,

		.bit = VR_MODE_NORMAL,

	}, /* VP1C -> VPROG1CCNT */

	{

		.address = 0x1c,

		.reg = 0x72,

		.bit = VR_MODE_NORMAL,

	}, /* VP1D -> VPROG1DCNT */

	{

		.address = 0x20,

		.reg = 0x73,

		.bit = VR_MODE_NORMAL,

	}, /* VP2A -> VPROG2ACNT */

	{

		.address = 0x24,

		.reg = 0x74,

		.bit = VR_MODE_NORMAL,

	}, /* VP2B -> VPROG2BCNT */

	{

		.address = 0x28,

		.reg = 0x75,

		.bit = VR_MODE_NORMAL,

	}, /* VP2C -> VPROG2CCNT */

	{

		.address = 0x2c,

		.reg = 0x76,

		.bit = VR_MODE_NORMAL,

	}, /* VP3A -> VPROG3ACNT */

	{

		.address = 0x30,

		.reg = 0x77,

		.bit = VR_MODE_NORMAL,

	}, /* VP3B -> VPROG3BCNT */

	{

		.address = 0x34,

		.reg = 0x78,

		.bit = VSWITCH2_OUTPUT,

	}, /* VSW2 -> VLD0CNT Bit 5*/

	{

		.address = 0x38,

		.reg = 0x78,

		.bit = VSWITCH1_OUTPUT,

	}, /* VSW1 -> VLD0CNT Bit 4 */

	{

		.address = 0x3c,

		.reg = 0x78,

		.bit = VUSBPHY_CHARGE,

	}, /* VUPY -> VLDOCNT Bit 1 */

	{

		.address = 0x40,

		.reg = 0x7b,

		.bit = VR_MODE_NORMAL,

	}, /* VRSO -> VREFSOCCNT*/

	{

		.address = 0x44,

		.reg = 0xA0,

		.bit = VR_MODE_NORMAL,

	}, /* VP1E -> VPROG1ECNT */

	{

		.address = 0x48,

		.reg = 0xA1,

		.bit = VR_MODE_NORMAL,

	}, /* VP1F -> VPROG1FCNT */

	{

		.address = 0x4c,

		.reg = 0xA2,

		.bit = VR_MODE_NORMAL,

	}, /* VP2D -> VPROG2DCNT */

	{

		.address = 0x50,

		.reg = 0xA3,

		.bit = VR_MODE_NORMAL,

	}, /* VP4A -> VPROG4ACNT */

	{

		.address = 0x54,

		.reg = 0xA4,

		.bit = VR_MODE_NORMAL,

	}, /* VP4B -> VPROG4BCNT */

	{

		.address = 0x58,

		.reg = 0xA5,

		.bit = VR_MODE_NORMAL,

	}, /* VP4C -> VPROG4CCNT */

	{

		.address = 0x5c,

		.reg = 0xA6,

		.bit = VR_MODE_NORMAL,

	}, /* VP4D -> VPROG4DCNT */

	{

		.address = 0x60,

		.reg = 0xA7,

		.bit = VR_MODE_NORMAL,

	}, /* VP5A -> VPROG5ACNT */

	{

		.address = 0x64,

		.reg = 0xA8,

		.bit = VR_MODE_NORMAL,

	}, /* VP5B -> VPROG5BCNT */

	{

		.address = 0x68,

		.reg = 0xA9,

		.bit = VR_MODE_NORMAL,

	}, /* VP6A -> VPROG6ACNT */

	{

		.address = 0x6c,

		.reg = 0xAA,

		.bit = VR_MODE_NORMAL,

	}, /* VP6B -> VPROG6BCNT */

	{

		.address = 0x70,

		.reg = 0x36,

		.bit = BIT(2),

	}, /* SDWN_N -> MODEMCTRL Bit 2 */

	{

		.address = 0x74,

		.reg = 0x36,

		.bit = BIT(0),

	} /* MOFF -> MODEMCTRL Bit 0 */

};



static struct pmic_table thermal_table[] = {

	{

		.address = 0x00,

		.reg = 0x4F39

	},

	{

		.address = 0x04,

		.reg = 0x4F24

	},

	{

		.address = 0x08,

		.reg = 0x4F26

	},

	{

		.address = 0x0c,

		.reg = 0x4F3B

	},

	{

		.address = 0x10,

		.reg = 0x4F28

	},

	{

		.address = 0x14,

		.reg = 0x4F2A

	},

	{

		.address = 0x18,

		.reg = 0x4F3D

	},

	{

		.address = 0x1c,

		.reg = 0x4F2C

	},

	{

		.address = 0x20,

		.reg = 0x4F2E

	},

	{

		.address = 0x24,

		.reg = 0x4F3F

	},

	{

		.address = 0x28,

		.reg = 0x4F30

	},

	{

		.address = 0x30,

		.reg = 0x4F41

	},

	{

		.address = 0x34,

		.reg = 0x4F32

	},

	{

		.address = 0x3c,

		.reg = 0x4F43

	},

	{

		.address = 0x40,

		.reg = 0x4F34

	},

	{

		.address = 0x48,

		.reg = 0x4F6A,

		.bit = 0,

	},

	{

		.address = 0x4C,

		.reg = 0x4F6A,

		.bit = 1

	},

	{

		.address = 0x50,

		.reg = 0x4F6A,

		.bit = 2

	},

	{

		.address = 0x54,

		.reg = 0x4F6A,

		.bit = 4

	},

	{

		.address = 0x58,

		.reg = 0x4F6A,

		.bit = 5

	},

	{

		.address = 0x5C,

		.reg = 0x4F6A,

		.bit = 3

	},

};



static int intel_bxtwc_pmic_get_power(struct regmap *regmap, int reg,

		int bit, u64 *value)

{

	int data;



	if (regmap_read(regmap, reg, &data))

		return -EIO;



	*value = (data & bit) ? 1 : 0;

	return 0;

}



static int intel_bxtwc_pmic_update_power(struct regmap *regmap, int reg,

		int bit, bool on)

{

	u8 val, mask = bit;



	if (on)

		val = 0xFF;

	else

		val = 0x0;



	return regmap_update_bits(regmap, reg, mask, val);

}



static int intel_bxtwc_pmic_get_raw_temp(struct regmap *regmap, int reg)

{

	unsigned int val, adc_val, reg_val;

	u8 temp_l, temp_h, cursrc;

	unsigned long rlsb;

	static const unsigned long rlsb_array[] = {

		0, 260420, 130210, 65100, 32550, 16280,

		8140, 4070, 2030, 0, 260420, 130210 };



	if (regmap_read(regmap, reg, &val))

		return -EIO;

	temp_l = (u8) val;



	if (regmap_read(regmap, (reg - 1), &val))

		return -EIO;

	temp_h = (u8) val;



	reg_val = temp_l | WHISKEY_COVE_ADC_HIGH_BIT(temp_h);

	cursrc = WHISKEY_COVE_ADC_CURSRC(temp_h);

	rlsb = rlsb_array[cursrc];

	adc_val = reg_val * rlsb / 1000;



	return adc_val;

}



static int

intel_bxtwc_pmic_update_aux(struct regmap *regmap, int reg, int raw)

{

	u32 bsr_num;

	u16 resi_val, count = 0, thrsh = 0;

	u8 alrt_h, alrt_l, cursel = 0;



	bsr_num = raw;

	bsr_num /= (1 << 5);



	count = fls(bsr_num) - 1;



	cursel = clamp_t(s8, (count - 7), 0, 7);

	thrsh = raw / (1 << (4 + cursel));



	resi_val = (cursel << 9) | thrsh;

	alrt_h = (resi_val >> 8) & WHISKEY_COVE_ALRT_HIGH_BIT_MASK;

	if (regmap_update_bits(regmap,

				reg - 1,

				WHISKEY_COVE_ALRT_HIGH_BIT_MASK,

				alrt_h))

		return -EIO;



	alrt_l = (u8)resi_val;

	return regmap_write(regmap, reg, alrt_l);

}



static int

intel_bxtwc_pmic_get_policy(struct regmap *regmap, int reg, int bit, u64 *value)

{

	u8 mask = BIT(bit);

	unsigned int val;



	if (regmap_read(regmap, reg, &val))

		return -EIO;



	*value = (val & mask) >> bit;

	return 0;

}



static int

intel_bxtwc_pmic_update_policy(struct regmap *regmap,

				int reg, int bit, int enable)

{

	u8 mask = BIT(bit), val = enable << bit;



	return regmap_update_bits(regmap, reg, mask, val);

}



static struct intel_pmic_opregion_data intel_bxtwc_pmic_opregion_data = {

	.get_power      = intel_bxtwc_pmic_get_power,

	.update_power   = intel_bxtwc_pmic_update_power,

	.get_raw_temp   = intel_bxtwc_pmic_get_raw_temp,

	.update_aux     = intel_bxtwc_pmic_update_aux,

	.get_policy     = intel_bxtwc_pmic_get_policy,

	.update_policy  = intel_bxtwc_pmic_update_policy,

	.power_table      = power_table,

	.power_table_count = ARRAY_SIZE(power_table),

	.thermal_table     = thermal_table,

	.thermal_table_count = ARRAY_SIZE(thermal_table),

};



static int intel_bxtwc_pmic_opregion_probe(struct platform_device *pdev)

{

	struct intel_soc_pmic *pmic = dev_get_drvdata(pdev->dev.parent);



	return intel_pmic_install_opregion_handler(&pdev->dev,

			ACPI_HANDLE(pdev->dev.parent),

			pmic->regmap,

			&intel_bxtwc_pmic_opregion_data);

}



static struct platform_device_id bxt_wc_opregion_id_table[] = {

	{ .name = "bxt_wcove_region" },

	{},

};



static struct platform_driver intel_bxtwc_pmic_opregion_driver = {

	.probe = intel_bxtwc_pmic_opregion_probe,

	.driver = {

		.name = "bxt_whiskey_cove_pmic",

	},

	.id_table = bxt_wc_opregion_id_table,

};



static int __init intel_bxtwc_pmic_opregion_driver_init(void)

{

	return platform_driver_register(&intel_bxtwc_pmic_opregion_driver);

}

device_initcall(intel_bxtwc_pmic_opregion_driver_init);