Unverified Commit 5e5f2f92 authored by Dmitry Baryshkov's avatar Dmitry Baryshkov Committed by Ilpo Järvinen
Browse files

platform: arm64: add Lenovo Yoga C630 WOS EC driver 



Lenovo Yoga C630 WOS is a laptop using Snapdragon 850 SoC. Like many
laptops it uses an embedded controller (EC) to perform various platform
operations, including, but not limited, to Type-C port control or power
supply handlng.

Add the driver for the EC, that creates devices for UCSI and power
supply devices.

Reviewed-by: default avatarBryan O'Donoghue <bryan.odonoghue@linaro.org>
Signed-off-by: default avatarDmitry Baryshkov <dmitry.baryshkov@linaro.org>
Link: https://lore.kernel.org/r/20240614-yoga-ec-driver-v7-2-9f0b9b40ae76@linaro.org


[ij: added #include <linux/cleanup.h>]
Reviewed-by: default avatarIlpo Järvinen <ilpo.jarvinen@linux.intel.com>
Signed-off-by: default avatarIlpo Järvinen <ilpo.jarvinen@linux.intel.com>
parent 5958448d

drivers/platform/arm64/Kconfig

+14 −0
Original line number Diff line number Diff line
@@ -32,4 +32,18 @@ config EC_ACER_ASPIRE1 
	  laptop where this information is not properly exposed via the

	  standard ACPI devices.



config EC_LENOVO_YOGA_C630

	tristate "Lenovo Yoga C630 Embedded Controller driver"

	depends on I2C

	help

	  Driver for the Embedded Controller in the Qualcomm Snapdragon-based

	  Lenovo Yoga C630, which provides battery and power adapter

	  information.



	  This driver provides battery and AC status support for the mentioned

	  laptop where this information is not properly exposed via the

	  standard ACPI devices.



	  Say M or Y here to include this support.



endif # ARM64_PLATFORM_DEVICES

drivers/platform/arm64/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -6,3 +6,4 @@ 
#



obj-$(CONFIG_EC_ACER_ASPIRE1)	+= acer-aspire1-ec.o

obj-$(CONFIG_EC_LENOVO_YOGA_C630) += lenovo-yoga-c630.o

drivers/platform/arm64/lenovo-yoga-c630.c

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

/*

 * Copyright (c) 2022-2024, Linaro Ltd

 * Authors:

 *    Bjorn Andersson

 *    Dmitry Baryshkov

 */

#include <linux/auxiliary_bus.h>

#include <linux/cleanup.h>

#include <linux/device.h>

#include <linux/err.h>

#include <linux/i2c.h>

#include <linux/irqreturn.h>

#include <linux/lockdep.h>

#include <linux/module.h>

#include <linux/mutex.h>

#include <linux/notifier.h>

#include <linux/slab.h>

#include <linux/platform_data/lenovo-yoga-c630.h>



#define LENOVO_EC_RESPONSE_REG		0x01

#define LENOVO_EC_REQUEST_REG		0x02



#define LENOVO_EC_UCSI_WRITE		0x20

#define LENOVO_EC_UCSI_READ		0x21



#define LENOVO_EC_READ_REG		0xb0

#define LENOVO_EC_REQUEST_NEXT_EVENT	0x84



#define LENOVO_EC_UCSI_VERSION		0x20



struct yoga_c630_ec {

	struct i2c_client *client;

	struct mutex lock;

	struct blocking_notifier_head notifier_list;

};



static int yoga_c630_ec_request(struct yoga_c630_ec *ec, u8 *req, size_t req_len,

				u8 *resp, size_t resp_len)

{

	int ret;



	lockdep_assert_held(&ec->lock);



	ret = i2c_smbus_write_i2c_block_data(ec->client, LENOVO_EC_REQUEST_REG,

					     req_len, req);

	if (ret < 0)

		return ret;



	return i2c_smbus_read_i2c_block_data(ec->client, LENOVO_EC_RESPONSE_REG,

					     resp_len, resp);

}



int yoga_c630_ec_read8(struct yoga_c630_ec *ec, u8 addr)

{

	u8 req[2] = { LENOVO_EC_READ_REG, };

	int ret;

	u8 val;



	guard(mutex)(&ec->lock);



	req[1] = addr;

	ret = yoga_c630_ec_request(ec, req, sizeof(req), &val, 1);

	if (ret < 0)

		return ret;



	return val;

}

EXPORT_SYMBOL_GPL(yoga_c630_ec_read8);



int yoga_c630_ec_read16(struct yoga_c630_ec *ec, u8 addr)

{

	u8 req[2] = { LENOVO_EC_READ_REG, };

	int ret;

	u8 msb;

	u8 lsb;



	/* don't overflow the address */

	if (addr == 0xff)

		return -EINVAL;



	guard(mutex)(&ec->lock);



	req[1] = addr;

	ret = yoga_c630_ec_request(ec, req, sizeof(req), &lsb, 1);

	if (ret < 0)

		return ret;



	req[1] = addr + 1;

	ret = yoga_c630_ec_request(ec, req, sizeof(req), &msb, 1);

	if (ret < 0)

		return ret;



	return msb << 8 | lsb;

}

EXPORT_SYMBOL_GPL(yoga_c630_ec_read16);



u16 yoga_c630_ec_ucsi_get_version(struct yoga_c630_ec *ec)

{

	u8 req[3] = { 0xb3, 0xf2, };

	int ret;

	u8 msb;

	u8 lsb;



	guard(mutex)(&ec->lock);



	req[2] = LENOVO_EC_UCSI_VERSION;

	ret = yoga_c630_ec_request(ec, req, sizeof(req), &lsb, 1);

	if (ret < 0)

		return ret;



	req[2] = LENOVO_EC_UCSI_VERSION + 1;

	ret = yoga_c630_ec_request(ec, req, sizeof(req), &msb, 1);

	if (ret < 0)

		return ret;



	return msb << 8 | lsb;

}

EXPORT_SYMBOL_GPL(yoga_c630_ec_ucsi_get_version);



int yoga_c630_ec_ucsi_write(struct yoga_c630_ec *ec,

			    const u8 req[YOGA_C630_UCSI_WRITE_SIZE])

{

	int ret;



	mutex_lock(&ec->lock);

	ret = i2c_smbus_write_i2c_block_data(ec->client, LENOVO_EC_UCSI_WRITE,

					     YOGA_C630_UCSI_WRITE_SIZE, req);

	mutex_unlock(&ec->lock);



	return ret < 0 ? ret : 0;

}

EXPORT_SYMBOL_GPL(yoga_c630_ec_ucsi_write);



int yoga_c630_ec_ucsi_read(struct yoga_c630_ec *ec,

			   u8 resp[YOGA_C630_UCSI_READ_SIZE])

{

	int ret;



	mutex_lock(&ec->lock);

	ret = i2c_smbus_read_i2c_block_data(ec->client, LENOVO_EC_UCSI_READ,

					    YOGA_C630_UCSI_READ_SIZE, resp);

	mutex_unlock(&ec->lock);



	return ret < 0 ? ret : 0;

}

EXPORT_SYMBOL_GPL(yoga_c630_ec_ucsi_read);



static irqreturn_t yoga_c630_ec_thread_intr(int irq, void *data)

{

	u8 req[] = { LENOVO_EC_REQUEST_NEXT_EVENT };

	struct yoga_c630_ec *ec = data;

	u8 event;

	int ret;



	mutex_lock(&ec->lock);

	ret = yoga_c630_ec_request(ec, req, sizeof(req), &event, 1);

	mutex_unlock(&ec->lock);

	if (ret < 0)

		return IRQ_HANDLED;



	blocking_notifier_call_chain(&ec->notifier_list, event, ec);



	return IRQ_HANDLED;

}



/**

 * yoga_c630_ec_register_notify - Register a notifier callback for EC events.

 * @ec: Yoga C630 EC

 * @nb: Notifier block pointer to register

 *

 * Return: 0 on success or negative error code.

 */

int yoga_c630_ec_register_notify(struct yoga_c630_ec *ec, struct notifier_block *nb)

{

	return blocking_notifier_chain_register(&ec->notifier_list, nb);

}

EXPORT_SYMBOL_GPL(yoga_c630_ec_register_notify);



/**

 * yoga_c630_ec_unregister_notify - Unregister notifier callback for EC events.

 * @ec: Yoga C630 EC

 * @nb: Notifier block pointer to unregister

 *

 * Unregister a notifier callback that was previously registered with

 * yoga_c630_ec_register_notify().

 */

void yoga_c630_ec_unregister_notify(struct yoga_c630_ec *ec, struct notifier_block *nb)

{

	blocking_notifier_chain_unregister(&ec->notifier_list, nb);

}

EXPORT_SYMBOL_GPL(yoga_c630_ec_unregister_notify);



static void yoga_c630_aux_release(struct device *dev)

{

	struct auxiliary_device *adev = to_auxiliary_dev(dev);



	kfree(adev);

}



static void yoga_c630_aux_remove(void *data)

{

	struct auxiliary_device *adev = data;



	auxiliary_device_delete(adev);

	auxiliary_device_uninit(adev);

}



static int yoga_c630_aux_init(struct device *parent, const char *name,

			      struct yoga_c630_ec *ec)

{

	struct auxiliary_device *adev;

	int ret;



	adev = kzalloc(sizeof(*adev), GFP_KERNEL);

	if (!adev)

		return -ENOMEM;



	adev->name = name;

	adev->id = 0;

	adev->dev.parent = parent;

	adev->dev.release = yoga_c630_aux_release;

	adev->dev.platform_data = ec;



	ret = auxiliary_device_init(adev);

	if (ret) {

		kfree(adev);

		return ret;

	}



	ret = auxiliary_device_add(adev);

	if (ret) {

		auxiliary_device_uninit(adev);

		return ret;

	}



	return devm_add_action_or_reset(parent, yoga_c630_aux_remove, adev);

}



static int yoga_c630_ec_probe(struct i2c_client *client)

{

	struct device *dev = &client->dev;

	struct yoga_c630_ec *ec;

	int ret;



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

	if (!ec)

		return -ENOMEM;



	mutex_init(&ec->lock);

	ec->client = client;

	BLOCKING_INIT_NOTIFIER_HEAD(&ec->notifier_list);



	ret = devm_request_threaded_irq(dev, client->irq,

					NULL, yoga_c630_ec_thread_intr,

					IRQF_ONESHOT, "yoga_c630_ec", ec);

	if (ret < 0)

		return dev_err_probe(dev, ret, "unable to request irq\n");



	ret = yoga_c630_aux_init(dev, YOGA_C630_DEV_PSY, ec);

	if (ret)

		return ret;



	return yoga_c630_aux_init(dev, YOGA_C630_DEV_UCSI, ec);

}





static const struct of_device_id yoga_c630_ec_of_match[] = {

	{ .compatible = "lenovo,yoga-c630-ec" },

	{}

};

MODULE_DEVICE_TABLE(of, yoga_c630_ec_of_match);



static const struct i2c_device_id yoga_c630_ec_i2c_id_table[] = {

	{ "yoga-c630-ec", },

	{}

};

MODULE_DEVICE_TABLE(i2c, yoga_c630_ec_i2c_id_table);



static struct i2c_driver yoga_c630_ec_i2c_driver = {

	.driver = {

		.name = "yoga-c630-ec",

		.of_match_table = yoga_c630_ec_of_match

	},

	.probe = yoga_c630_ec_probe,

	.id_table = yoga_c630_ec_i2c_id_table,

};

module_i2c_driver(yoga_c630_ec_i2c_driver);



MODULE_DESCRIPTION("Lenovo Yoga C630 Embedded Controller");

MODULE_LICENSE("GPL");

include/linux/platform_data/lenovo-yoga-c630.h

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

/*

 * Copyright (c) 2022-2024, Linaro Ltd

 * Authors:

 *    Bjorn Andersson

 *    Dmitry Baryshkov

 */



#ifndef _LENOVO_YOGA_C630_DATA_H

#define _LENOVO_YOGA_C630_DATA_H



struct yoga_c630_ec;

struct notifier_block;



#define YOGA_C630_MOD_NAME	"lenovo_yoga_c630"



#define YOGA_C630_DEV_UCSI	"ucsi"

#define YOGA_C630_DEV_PSY	"psy"



int yoga_c630_ec_read8(struct yoga_c630_ec *ec, u8 addr);

int yoga_c630_ec_read16(struct yoga_c630_ec *ec, u8 addr);



int yoga_c630_ec_register_notify(struct yoga_c630_ec *ec, struct notifier_block *nb);

void yoga_c630_ec_unregister_notify(struct yoga_c630_ec *ec, struct notifier_block *nb);



#define YOGA_C630_UCSI_WRITE_SIZE	8

#define YOGA_C630_UCSI_CCI_SIZE		4

#define YOGA_C630_UCSI_DATA_SIZE	16

#define YOGA_C630_UCSI_READ_SIZE	(YOGA_C630_UCSI_CCI_SIZE + YOGA_C630_UCSI_DATA_SIZE)



u16 yoga_c630_ec_ucsi_get_version(struct yoga_c630_ec *ec);

int yoga_c630_ec_ucsi_write(struct yoga_c630_ec *ec,

			    const u8 req[YOGA_C630_UCSI_WRITE_SIZE]);

int yoga_c630_ec_ucsi_read(struct yoga_c630_ec *ec,

			   u8 resp[YOGA_C630_UCSI_READ_SIZE]);



#define LENOVO_EC_EVENT_USB		0x20

#define LENOVO_EC_EVENT_UCSI		0x21

#define LENOVO_EC_EVENT_HPD		0x22

#define LENOVO_EC_EVENT_BAT_STATUS	0x24

#define LENOVO_EC_EVENT_BAT_INFO	0x25

#define LENOVO_EC_EVENT_BAT_ADPT_STATUS	0x37



#endif