Commit 427eb785 authored by Sebastian Reichel's avatar Sebastian Reichel
Browse files

Merge tag 'platform-drivers-x86-ib-lenovo-c630-v6.11-2' 



Immutable branch between pdx86 lenovo c630 branch, power/supply and USB
subsystems due for the v6.11 merge window, which is required for the
Lenovo C630 battery driver.

Signed-off-by: default avatarSebastian Reichel <sebastian.reichel@collabora.com>
parents f8b6c1eb 13bbe1c8

Documentation/devicetree/bindings/platform/lenovo,yoga-c630-ec.yaml

0 → 100644
+83 −0
Original line number Diff line number Diff line 
# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)

%YAML 1.2

---

$id: http://devicetree.org/schemas/platform/lenovo,yoga-c630-ec.yaml#

$schema: http://devicetree.org/meta-schemas/core.yaml#



title: Lenovo Yoga C630 Embedded Controller.



maintainers:

  - Bjorn Andersson <andersson@kernel.org>



description:

  The Qualcomm Snapdragon-based Lenovo Yoga C630 has an Embedded Controller

  (EC) which handles things such as battery and USB Type-C. This binding

  describes the interface, on an I2C bus, to this EC.



properties:

  compatible:

    const: lenovo,yoga-c630-ec



  reg:

    const: 0x70



  '#address-cells':

    const: 1



  '#size-cells':

    const: 0



  interrupts:

    maxItems: 1



patternProperties:

  '^connector@[01]$':

    $ref: /schemas/connector/usb-connector.yaml#



    properties:

      reg:

        maxItems: 1



    unevaluatedProperties: false



required:

  - compatible

  - reg

  - interrupts



additionalProperties: false



examples:

  - |+

    #include <dt-bindings/interrupt-controller/irq.h>

    i2c1 {

        clock-frequency = <400000>;



        #address-cells = <1>;

        #size-cells = <0>;



        embedded-controller@70 {

            compatible = "lenovo,yoga-c630-ec";

            reg = <0x70>;



            interrupts-extended = <&tlmm 20 IRQ_TYPE_LEVEL_HIGH>;



            #address-cells = <1>;

            #size-cells = <0>;



            connector@0 {

                compatible = "usb-c-connector";

                reg = <0>;

                power-role = "source";

                data-role = "host";

            };



            connector@1 {

                compatible = "usb-c-connector";

                reg = <1>;

                power-role = "source";

                data-role = "host";

            };

        };

    };

...

drivers/platform/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -11,4 +11,4 @@ obj-$(CONFIG_OLPC_EC) += olpc/ 
obj-$(CONFIG_GOLDFISH)		+= goldfish/

obj-$(CONFIG_CHROME_PLATFORMS)	+= chrome/

obj-$(CONFIG_SURFACE_PLATFORMS)	+= surface/

obj-$(CONFIG_ARM64)		+= arm64/
 
obj-$(CONFIG_ARM64_PLATFORM_DEVICES)	+= arm64/

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");