Commit d740795d authored by Yauhen Kharuzhy's avatar Yauhen Kharuzhy Committed by Andy Shevchenko
Browse files

platform/x86: intel_cht_int33fe: Split code to Micro-B and Type-C 



Existing intel_cht_int33fe ACPI pseudo-device driver assumes that
hardware has Type-C connector and register related devices described as
I2C connections in the _CRS resource.

There is at least one hardware (Lenovo Yoga Book YB1-91L/F) with Micro-B
USB connector exists. It has INT33FE device in the DSDT table but
there are only two I2C connection described: PMIC and BQ27452 battery
fuel gauge.

Splitting existing INT33FE driver allow to maintain code for USB Micro-B
(or AB) connector variant separately and make it simpler.

Split driver to intel_cht_int33fe_common.c and
intel_cht_int33fe_{microb,typec}.c. Compile all this sources to one .ko
module to make user experience easier.

Signed-off-by: default avatarYauhen Kharuzhy <jekhor@gmail.com>
Signed-off-by: default avatarAndy Shevchenko <andriy.shevchenko@linux.intel.com>
parent c656829f

drivers/platform/x86/Kconfig

+8 −2
Original line number Diff line number Diff line
@@ -927,14 +927,20 @@ config INTEL_CHT_INT33FE 
	  This driver add support for the INT33FE ACPI device found on

	  some Intel Cherry Trail devices.



	  There are two kinds of INT33FE ACPI device possible: for hardware

	  with USB Type-C and Micro-B connectors. This driver supports both.



	  The INT33FE ACPI device has a CRS table with I2cSerialBusV2

	  resources for 3 devices: Maxim MAX17047 Fuel Gauge Controller,

	  resources for Fuel Gauge Controller and (in the Type-C variant)

	  FUSB302 USB Type-C Controller and PI3USB30532 USB switch.

	  This driver instantiates i2c-clients for these, so that standard

	  i2c drivers for these chips can bind to the them.



	  If you enable this driver it is advised to also select

	  CONFIG_TYPEC_FUSB302=m and CONFIG_BATTERY_MAX17042=m.

	  CONFIG_BATTERY_BQ27XXX=m or CONFIG_BATTERY_BQ27XXX_I2C=m for Micro-B

	  device and CONFIG_TYPEC_FUSB302=m and CONFIG_BATTERY_MAX17042=m

	  for Type-C device.





config INTEL_INT0002_VGPIO

	tristate "Intel ACPI INT0002 Virtual GPIO driver"

drivers/platform/x86/Makefile

+4 −0
Original line number Diff line number Diff line
@@ -61,6 +61,10 @@ obj-$(CONFIG_TOSHIBA_BT_RFKILL) += toshiba_bluetooth.o 
obj-$(CONFIG_TOSHIBA_HAPS)	+= toshiba_haps.o

obj-$(CONFIG_TOSHIBA_WMI)	+= toshiba-wmi.o

obj-$(CONFIG_INTEL_CHT_INT33FE)	+= intel_cht_int33fe.o

intel_cht_int33fe-objs		:= intel_cht_int33fe_common.o \

				   intel_cht_int33fe_typec.o \

				   intel_cht_int33fe_microb.o



obj-$(CONFIG_INTEL_INT0002_VGPIO) += intel_int0002_vgpio.o

obj-$(CONFIG_INTEL_HID_EVENT)	+= intel-hid.o

obj-$(CONFIG_INTEL_VBTN)	+= intel-vbtn.o

drivers/platform/x86/intel_cht_int33fe_common.c

0 → 100644
+147 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/*

 * Common code for Intel Cherry Trail ACPI INT33FE pseudo device drivers

 * (USB Micro-B and Type-C connector variants).

 *

 * Copyright (c) 2019 Yauhen Kharuzhy <jekhor@gmail.com>

 */



#include <linux/acpi.h>

#include <linux/i2c.h>

#include <linux/module.h>

#include <linux/platform_device.h>

#include <linux/slab.h>



#include "intel_cht_int33fe_common.h"



#define EXPECTED_PTYPE		4



static int cht_int33fe_i2c_res_filter(struct acpi_resource *ares, void *data)

{

	struct acpi_resource_i2c_serialbus *sb;

	int *count = data;



	if (i2c_acpi_get_i2c_resource(ares, &sb))

		(*count)++;



	return 1;

}



static int cht_int33fe_count_i2c_clients(struct device *dev)

{

	struct acpi_device *adev;

	LIST_HEAD(resource_list);

	int count = 0;



	adev = ACPI_COMPANION(dev);

	if (!adev)

		return -EINVAL;



	acpi_dev_get_resources(adev, &resource_list,

			       cht_int33fe_i2c_res_filter, &count);



	acpi_dev_free_resource_list(&resource_list);



	return count;

}



static int cht_int33fe_check_hw_type(struct device *dev)

{

	unsigned long long ptyp;

	acpi_status status;

	int ret;



	status = acpi_evaluate_integer(ACPI_HANDLE(dev), "PTYP", NULL, &ptyp);

	if (ACPI_FAILURE(status)) {

		dev_err(dev, "Error getting PTYPE\n");

		return -ENODEV;

	}



	/*

	 * The same ACPI HID is used for different configurations check PTYP

	 * to ensure that we are dealing with the expected config.

	 */

	if (ptyp != EXPECTED_PTYPE)

		return -ENODEV;



	/* Check presence of INT34D3 (hardware-rev 3) expected for ptype == 4 */

	if (!acpi_dev_present("INT34D3", "1", 3)) {

		dev_err(dev, "Error PTYPE == %d, but no INT34D3 device\n",

			EXPECTED_PTYPE);

		return -ENODEV;

	}



	ret = cht_int33fe_count_i2c_clients(dev);

	if (ret < 0)

		return ret;



	switch (ret) {

	case 2:

		return INT33FE_HW_MICROB;

	case 4:

		return INT33FE_HW_TYPEC;

	default:

		return -ENODEV;

	}

}



static int cht_int33fe_probe(struct platform_device *pdev)

{

	struct cht_int33fe_data *data;

	struct device *dev = &pdev->dev;

	int ret;



	ret = cht_int33fe_check_hw_type(dev);

	if (ret < 0)

		return ret;



	data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);

	if (!data)

		return -ENOMEM;



	data->dev = dev;



	switch (ret) {

	case INT33FE_HW_MICROB:

		data->probe = cht_int33fe_microb_probe;

		data->remove = cht_int33fe_microb_remove;

		break;



	case INT33FE_HW_TYPEC:

		data->probe = cht_int33fe_typec_probe;

		data->remove = cht_int33fe_typec_remove;

		break;

	}



	platform_set_drvdata(pdev, data);



	return data->probe(data);

}



static int cht_int33fe_remove(struct platform_device *pdev)

{

	struct cht_int33fe_data *data = platform_get_drvdata(pdev);



	return data->remove(data);

}



static const struct acpi_device_id cht_int33fe_acpi_ids[] = {

	{ "INT33FE", },

	{ }

};

MODULE_DEVICE_TABLE(acpi, cht_int33fe_acpi_ids);



static struct platform_driver cht_int33fe_driver = {

	.driver	= {

		.name = "Intel Cherry Trail ACPI INT33FE driver",

		.acpi_match_table = ACPI_PTR(cht_int33fe_acpi_ids),

	},

	.probe = cht_int33fe_probe,

	.remove = cht_int33fe_remove,

};



module_platform_driver(cht_int33fe_driver);



MODULE_DESCRIPTION("Intel Cherry Trail ACPI INT33FE pseudo device driver");

MODULE_AUTHOR("Yauhen Kharuzhy <jekhor@gmail.com>");

MODULE_LICENSE("GPL v2");

drivers/platform/x86/intel_cht_int33fe_common.h

0 → 100644
+41 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0 */

/*

 * Common code for Intel Cherry Trail ACPI INT33FE pseudo device drivers

 * (USB Micro-B and Type-C connector variants), header file

 *

 * Copyright (c) 2019 Yauhen Kharuzhy <jekhor@gmail.com>

 */



#ifndef _INTEL_CHT_INT33FE_COMMON_H

#define _INTEL_CHT_INT33FE_COMMON_H



#include <linux/device.h>

#include <linux/fwnode.h>

#include <linux/i2c.h>



enum int33fe_hw_type {

	INT33FE_HW_MICROB,

	INT33FE_HW_TYPEC,

};



struct cht_int33fe_data {

	struct device *dev;



	int (*probe)(struct cht_int33fe_data *data);

	int (*remove)(struct cht_int33fe_data *data);



	struct i2c_client *battery_fg;



	/* Type-C only */

	struct i2c_client *fusb302;

	struct i2c_client *pi3usb30532;



	struct fwnode_handle *dp;

};



int cht_int33fe_microb_probe(struct cht_int33fe_data *data);

int cht_int33fe_microb_remove(struct cht_int33fe_data *data);

int cht_int33fe_typec_probe(struct cht_int33fe_data *data);

int cht_int33fe_typec_remove(struct cht_int33fe_data *data);



#endif /* _INTEL_CHT_INT33FE_COMMON_H */

drivers/platform/x86/intel_cht_int33fe_microb.c

0 → 100644
+57 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/*

 * Intel Cherry Trail ACPI INT33FE pseudo device driver for devices with

 * USB Micro-B connector (e.g. without of FUSB302 USB Type-C controller)

 *

 * Copyright (C) 2019 Yauhen Kharuzhy <jekhor@gmail.com>

 *

 * At least one Intel Cherry Trail based device which ship with Windows 10

 * (Lenovo YogaBook YB1-X91L/F tablet), have this weird INT33FE ACPI device

 * with a CRS table with 2 I2cSerialBusV2 resources, for 2 different chips

 * attached to various i2c busses:

 * 1. The Whiskey Cove PMIC, which is also described by the INT34D3 ACPI device

 * 2. TI BQ27542 Fuel Gauge Controller

 *

 * So this driver is a stub / pseudo driver whose only purpose is to

 * instantiate i2c-client for battery fuel gauge, so that standard i2c driver

 * for these chip can bind to the it.

 */



#include <linux/acpi.h>

#include <linux/i2c.h>

#include <linux/module.h>

#include <linux/pci.h>

#include <linux/platform_device.h>

#include <linux/regulator/consumer.h>

#include <linux/slab.h>

#include <linux/usb/pd.h>



#include "intel_cht_int33fe_common.h"



static const char * const bq27xxx_suppliers[] = { "bq25890-charger" };



static const struct property_entry bq27xxx_props[] = {

	PROPERTY_ENTRY_STRING_ARRAY("supplied-from", bq27xxx_suppliers),

	{ }

};



int cht_int33fe_microb_probe(struct cht_int33fe_data *data)

{

	struct device *dev = data->dev;

	struct i2c_board_info board_info;



	memset(&board_info, 0, sizeof(board_info));

	strscpy(board_info.type, "bq27542", ARRAY_SIZE(board_info.type));

	board_info.dev_name = "bq27542";

	board_info.properties = bq27xxx_props;

	data->battery_fg = i2c_acpi_new_device(dev, 1, &board_info);



	return PTR_ERR_OR_ZERO(data->battery_fg);

}



int cht_int33fe_microb_remove(struct cht_int33fe_data *data)

{

	i2c_unregister_device(data->battery_fg);



	return 0;

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE