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

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (c) 2022-2024, Linaro Ltd
   4  * Authors:
   5  *    Bjorn Andersson
   6  *    Dmitry Baryshkov
   7  */
   8 #include <linux/auxiliary_bus.h>
   9 #include <linux/cleanup.h>
  10 #include <linux/device.h>
  11 #include <linux/err.h>
  12 #include <linux/i2c.h>
  13 #include <linux/irqreturn.h>
  14 #include <linux/lockdep.h>
  15 #include <linux/module.h>
  16 #include <linux/mutex.h>
  17 #include <linux/notifier.h>
  18 #include <linux/slab.h>
  19 #include <linux/platform_data/lenovo-yoga-c630.h>
  20
  21 #define LENOVO_EC_RESPONSE_REG          0x01
  22 #define LENOVO_EC_REQUEST_REG           0x02
  23
  24 #define LENOVO_EC_UCSI_WRITE            0x20
  25 #define LENOVO_EC_UCSI_READ             0x21
  26
  27 #define LENOVO_EC_READ_REG              0xb0
  28 #define LENOVO_EC_REQUEST_NEXT_EVENT    0x84
  29
  30 #define LENOVO_EC_UCSI_VERSION          0x20
  31
  32 struct yoga_c630_ec {
  33         struct i2c_client *client;
  34         struct mutex lock;
  35         struct blocking_notifier_head notifier_list;
  36 };
  37
  38 static int yoga_c630_ec_request(struct yoga_c630_ec *ec, u8 *req, size_t req_len,
  39                                 u8 *resp, size_t resp_len)
  40 {
  41         int ret;
  42
  43         lockdep_assert_held(&ec->lock);
  44
  45         ret = i2c_smbus_write_i2c_block_data(ec->client, LENOVO_EC_REQUEST_REG,
  46                                              req_len, req);
  47         if (ret < 0)
  48                 return ret;
  49
  50         return i2c_smbus_read_i2c_block_data(ec->client, LENOVO_EC_RESPONSE_REG,
  51                                              resp_len, resp);
  52 }
  53
  54 int yoga_c630_ec_read8(struct yoga_c630_ec *ec, u8 addr)
  55 {
  56         u8 req[2] = { LENOVO_EC_READ_REG, };
  57         int ret;
  58         u8 val;
  59
  60         guard(mutex)(&ec->lock);
  61
  62         req[1] = addr;
  63         ret = yoga_c630_ec_request(ec, req, sizeof(req), &val, 1);
  64         if (ret < 0)
  65                 return ret;
  66
  67         return val;
  68 }
  69 EXPORT_SYMBOL_GPL(yoga_c630_ec_read8);
  70
  71 int yoga_c630_ec_read16(struct yoga_c630_ec *ec, u8 addr)
  72 {
  73         u8 req[2] = { LENOVO_EC_READ_REG, };
  74         int ret;
  75         u8 msb;
  76         u8 lsb;
  77
  78         /* don't overflow the address */
  79         if (addr == 0xff)
  80                 return -EINVAL;
  81
  82         guard(mutex)(&ec->lock);
  83
  84         req[1] = addr;
  85         ret = yoga_c630_ec_request(ec, req, sizeof(req), &lsb, 1);
  86         if (ret < 0)
  87                 return ret;
  88
  89         req[1] = addr + 1;
  90         ret = yoga_c630_ec_request(ec, req, sizeof(req), &msb, 1);
  91         if (ret < 0)
  92                 return ret;
  93
  94         return msb << 8 | lsb;
  95 }
  96 EXPORT_SYMBOL_GPL(yoga_c630_ec_read16);
  97
  98 u16 yoga_c630_ec_ucsi_get_version(struct yoga_c630_ec *ec)
  99 {
 100         u8 req[3] = { 0xb3, 0xf2, };
 101         int ret;
 102         u8 msb;
 103         u8 lsb;
 104
 105         guard(mutex)(&ec->lock);
 106
 107         req[2] = LENOVO_EC_UCSI_VERSION;
 108         ret = yoga_c630_ec_request(ec, req, sizeof(req), &lsb, 1);
 109         if (ret < 0)
 110                 return ret;
 111
 112         req[2] = LENOVO_EC_UCSI_VERSION + 1;
 113         ret = yoga_c630_ec_request(ec, req, sizeof(req), &msb, 1);
 114         if (ret < 0)
 115                 return ret;
 116
 117         return msb << 8 | lsb;
 118 }
 119 EXPORT_SYMBOL_GPL(yoga_c630_ec_ucsi_get_version);
 120
 121 int yoga_c630_ec_ucsi_write(struct yoga_c630_ec *ec,
 122                             const u8 req[YOGA_C630_UCSI_WRITE_SIZE])
 123 {
 124         int ret;
 125
 126         mutex_lock(&ec->lock);
 127         ret = i2c_smbus_write_i2c_block_data(ec->client, LENOVO_EC_UCSI_WRITE,
 128                                              YOGA_C630_UCSI_WRITE_SIZE, req);
 129         mutex_unlock(&ec->lock);
 130
 131         return ret < 0 ? ret : 0;
 132 }
 133 EXPORT_SYMBOL_GPL(yoga_c630_ec_ucsi_write);
 134
 135 int yoga_c630_ec_ucsi_read(struct yoga_c630_ec *ec,
 136                            u8 resp[YOGA_C630_UCSI_READ_SIZE])
 137 {
 138         int ret;
 139
 140         mutex_lock(&ec->lock);
 141         ret = i2c_smbus_read_i2c_block_data(ec->client, LENOVO_EC_UCSI_READ,
 142                                             YOGA_C630_UCSI_READ_SIZE, resp);
 143         mutex_unlock(&ec->lock);
 144
 145         return ret < 0 ? ret : 0;
 146 }
 147 EXPORT_SYMBOL_GPL(yoga_c630_ec_ucsi_read);
 148
 149 static irqreturn_t yoga_c630_ec_thread_intr(int irq, void *data)
 150 {
 151         u8 req[] = { LENOVO_EC_REQUEST_NEXT_EVENT };
 152         struct yoga_c630_ec *ec = data;
 153         u8 event;
 154         int ret;
 155
 156         mutex_lock(&ec->lock);
 157         ret = yoga_c630_ec_request(ec, req, sizeof(req), &event, 1);
 158         mutex_unlock(&ec->lock);
 159         if (ret < 0)
 160                 return IRQ_HANDLED;
 161
 162         blocking_notifier_call_chain(&ec->notifier_list, event, ec);
 163
 164         return IRQ_HANDLED;
 165 }
 166
 167 /**
 168  * yoga_c630_ec_register_notify - Register a notifier callback for EC events.
 169  * @ec: Yoga C630 EC
 170  * @nb: Notifier block pointer to register
 171  *
 172  * Return: 0 on success or negative error code.
 173  */
 174 int yoga_c630_ec_register_notify(struct yoga_c630_ec *ec, struct notifier_block *nb)
 175 {
 176         return blocking_notifier_chain_register(&ec->notifier_list, nb);
 177 }
 178 EXPORT_SYMBOL_GPL(yoga_c630_ec_register_notify);
 179
 180 /**
 181  * yoga_c630_ec_unregister_notify - Unregister notifier callback for EC events.
 182  * @ec: Yoga C630 EC
 183  * @nb: Notifier block pointer to unregister
 184  *
 185  * Unregister a notifier callback that was previously registered with
 186  * yoga_c630_ec_register_notify().
 187  */
 188 void yoga_c630_ec_unregister_notify(struct yoga_c630_ec *ec, struct notifier_block *nb)
 189 {
 190         blocking_notifier_chain_unregister(&ec->notifier_list, nb);
 191 }
 192 EXPORT_SYMBOL_GPL(yoga_c630_ec_unregister_notify);
 193
 194 static void yoga_c630_aux_release(struct device *dev)
 195 {
 196         struct auxiliary_device *adev = to_auxiliary_dev(dev);
 197
 198         kfree(adev);
 199 }
 200
 201 static void yoga_c630_aux_remove(void *data)
 202 {
 203         struct auxiliary_device *adev = data;
 204
 205         auxiliary_device_delete(adev);
 206         auxiliary_device_uninit(adev);
 207 }
 208
 209 static int yoga_c630_aux_init(struct device *parent, const char *name,
 210                               struct yoga_c630_ec *ec)
 211 {
 212         struct auxiliary_device *adev;
 213         int ret;
 214
 215         adev = kzalloc(sizeof(*adev), GFP_KERNEL);
 216         if (!adev)
 217                 return -ENOMEM;
 218
 219         adev->name = name;
 220         adev->id = 0;
 221         adev->dev.parent = parent;
 222         adev->dev.release = yoga_c630_aux_release;
 223         adev->dev.platform_data = ec;
 224
 225         ret = auxiliary_device_init(adev);
 226         if (ret) {
 227                 kfree(adev);
 228                 return ret;
 229         }
 230
 231         ret = auxiliary_device_add(adev);
 232         if (ret) {
 233                 auxiliary_device_uninit(adev);
 234                 return ret;
 235         }
 236
 237         return devm_add_action_or_reset(parent, yoga_c630_aux_remove, adev);
 238 }
 239
 240 static int yoga_c630_ec_probe(struct i2c_client *client)
 241 {
 242         struct device *dev = &client->dev;
 243         struct yoga_c630_ec *ec;
 244         int ret;
 245
 246         ec = devm_kzalloc(dev, sizeof(*ec), GFP_KERNEL);
 247         if (!ec)
 248                 return -ENOMEM;
 249
 250         mutex_init(&ec->lock);
 251         ec->client = client;
 252         BLOCKING_INIT_NOTIFIER_HEAD(&ec->notifier_list);
 253
 254         ret = devm_request_threaded_irq(dev, client->irq,
 255                                         NULL, yoga_c630_ec_thread_intr,
 256                                         IRQF_ONESHOT, "yoga_c630_ec", ec);
 257         if (ret < 0)
 258                 return dev_err_probe(dev, ret, "unable to request irq\n");
 259
 260         ret = yoga_c630_aux_init(dev, YOGA_C630_DEV_PSY, ec);
 261         if (ret)
 262                 return ret;
 263
 264         return yoga_c630_aux_init(dev, YOGA_C630_DEV_UCSI, ec);
 265 }
 266
 267
 268 static const struct of_device_id yoga_c630_ec_of_match[] = {
 269         { .compatible = "lenovo,yoga-c630-ec" },
 270         {}
 271 };
 272 MODULE_DEVICE_TABLE(of, yoga_c630_ec_of_match);
 273
 274 static const struct i2c_device_id yoga_c630_ec_i2c_id_table[] = {
 275         { "yoga-c630-ec", },
 276         {}
 277 };
 278 MODULE_DEVICE_TABLE(i2c, yoga_c630_ec_i2c_id_table);
 279
 280 static struct i2c_driver yoga_c630_ec_i2c_driver = {
 281         .driver = {
 282                 .name = "yoga-c630-ec",
 283                 .of_match_table = yoga_c630_ec_of_match
 284         },
 285         .probe = yoga_c630_ec_probe,
 286         .id_table = yoga_c630_ec_i2c_id_table,
 287 };
 288 module_i2c_driver(yoga_c630_ec_i2c_driver);
 289
 290 MODULE_DESCRIPTION("Lenovo Yoga C630 Embedded Controller");
 291 MODULE_LICENSE("GPL");