drivers/platform/olpc/olpc-ec.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Generic driver for the OLPC Embedded Controller.
   4  *
   5  * Author: Andres Salomon <dilinger@queued.net>
   6  *
   7  * Copyright (C) 2011-2012 One Laptop per Child Foundation.
   8  */
   9 #include <linux/completion.h>
  10 #include <linux/debugfs.h>
  11 #include <linux/spinlock.h>
  12 #include <linux/mutex.h>
  13 #include <linux/platform_device.h>
  14 #include <linux/slab.h>
  15 #include <linux/workqueue.h>
  16 #include <linux/init.h>
  17 #include <linux/list.h>
  18 #include <linux/regulator/driver.h>
  19 #include <linux/olpc-ec.h>
  20
  21 struct ec_cmd_desc {
  22         u8 cmd;
  23         u8 *inbuf, *outbuf;
  24         size_t inlen, outlen;
  25
  26         int err;
  27         struct completion finished;
  28         struct list_head node;
  29
  30         void *priv;
  31 };
  32
  33 struct olpc_ec_priv {
  34         struct olpc_ec_driver *drv;
  35         u8 version;
  36         struct work_struct worker;
  37         struct mutex cmd_lock;
  38
  39         /* DCON regulator */
  40         bool dcon_enabled;
  41
  42         /* Pending EC commands */
  43         struct list_head cmd_q;
  44         spinlock_t cmd_q_lock;
  45
  46         struct dentry *dbgfs_dir;
  47
  48         /*
  49          * EC event mask to be applied during suspend (defining wakeup
  50          * sources).
  51          */
  52         u16 ec_wakeup_mask;
  53
  54         /*
  55          * Running an EC command while suspending means we don't always finish
  56          * the command before the machine suspends.  This means that the EC
  57          * is expecting the command protocol to finish, but we after a period
  58          * of time (while the OS is asleep) the EC times out and restarts its
  59          * idle loop.  Meanwhile, the OS wakes up, thinks it's still in the
  60          * middle of the command protocol, starts throwing random things at
  61          * the EC... and everyone's uphappy.
  62          */
  63         bool suspended;
  64 };
  65
  66 static struct olpc_ec_driver *ec_driver;
  67 static struct olpc_ec_priv *ec_priv;
  68 static void *ec_cb_arg;
  69
  70 void olpc_ec_driver_register(struct olpc_ec_driver *drv, void *arg)
  71 {
  72         ec_driver = drv;
  73         ec_cb_arg = arg;
  74 }
  75 EXPORT_SYMBOL_GPL(olpc_ec_driver_register);
  76
  77 static void olpc_ec_worker(struct work_struct *w)
  78 {
  79         struct olpc_ec_priv *ec = container_of(w, struct olpc_ec_priv, worker);
  80         struct ec_cmd_desc *desc = NULL;
  81         unsigned long flags;
  82
  83         /* Grab the first pending command from the queue */
  84         spin_lock_irqsave(&ec->cmd_q_lock, flags);
  85         if (!list_empty(&ec->cmd_q)) {
  86                 desc = list_first_entry(&ec->cmd_q, struct ec_cmd_desc, node);
  87                 list_del(&desc->node);
  88         }
  89         spin_unlock_irqrestore(&ec->cmd_q_lock, flags);
  90
  91         /* Do we actually have anything to do? */
  92         if (!desc)
  93                 return;
  94
  95         /* Protect the EC hw with a mutex; only run one cmd at a time */
  96         mutex_lock(&ec->cmd_lock);
  97         desc->err = ec_driver->ec_cmd(desc->cmd, desc->inbuf, desc->inlen,
  98                         desc->outbuf, desc->outlen, ec_cb_arg);
  99         mutex_unlock(&ec->cmd_lock);
 100
 101         /* Finished, wake up olpc_ec_cmd() */
 102         complete(&desc->finished);
 103
 104         /* Run the worker thread again in case there are more cmds pending */
 105         schedule_work(&ec->worker);
 106 }
 107
 108 /*
 109  * Throw a cmd descripter onto the list.  We now have SMP OLPC machines, so
 110  * locking is pretty critical.
 111  */
 112 static void queue_ec_descriptor(struct ec_cmd_desc *desc,
 113                 struct olpc_ec_priv *ec)
 114 {
 115         unsigned long flags;
 116
 117         INIT_LIST_HEAD(&desc->node);
 118
 119         spin_lock_irqsave(&ec->cmd_q_lock, flags);
 120         list_add_tail(&desc->node, &ec->cmd_q);
 121         spin_unlock_irqrestore(&ec->cmd_q_lock, flags);
 122
 123         schedule_work(&ec->worker);
 124 }
 125
 126 int olpc_ec_cmd(u8 cmd, u8 *inbuf, size_t inlen, u8 *outbuf, size_t outlen)
 127 {
 128         struct olpc_ec_priv *ec = ec_priv;
 129         struct ec_cmd_desc desc;
 130
 131         /* Driver not yet registered. */
 132         if (!ec_driver)
 133                 return -EPROBE_DEFER;
 134
 135         if (WARN_ON(!ec_driver->ec_cmd))
 136                 return -ENODEV;
 137
 138         if (!ec)
 139                 return -ENOMEM;
 140
 141         /* Suspending in the middle of a command hoses things really badly */
 142         if (WARN_ON(ec->suspended))
 143                 return -EBUSY;
 144
 145         might_sleep();
 146
 147         desc.cmd = cmd;
 148         desc.inbuf = inbuf;
 149         desc.outbuf = outbuf;
 150         desc.inlen = inlen;
 151         desc.outlen = outlen;
 152         desc.err = 0;
 153         init_completion(&desc.finished);
 154
 155         queue_ec_descriptor(&desc, ec);
 156
 157         /* Timeouts must be handled in the platform-specific EC hook */
 158         wait_for_completion(&desc.finished);
 159
 160         /* The worker thread dequeues the cmd; no need to do anything here */
 161         return desc.err;
 162 }
 163 EXPORT_SYMBOL_GPL(olpc_ec_cmd);
 164
 165 void olpc_ec_wakeup_set(u16 value)
 166 {
 167         struct olpc_ec_priv *ec = ec_priv;
 168
 169         if (WARN_ON(!ec))
 170                 return;
 171
 172         ec->ec_wakeup_mask |= value;
 173 }
 174 EXPORT_SYMBOL_GPL(olpc_ec_wakeup_set);
 175
 176 void olpc_ec_wakeup_clear(u16 value)
 177 {
 178         struct olpc_ec_priv *ec = ec_priv;
 179
 180         if (WARN_ON(!ec))
 181                 return;
 182
 183         ec->ec_wakeup_mask &= ~value;
 184 }
 185 EXPORT_SYMBOL_GPL(olpc_ec_wakeup_clear);
 186
 187 int olpc_ec_mask_write(u16 bits)
 188 {
 189         struct olpc_ec_priv *ec = ec_priv;
 190
 191         if (WARN_ON(!ec))
 192                 return -ENODEV;
 193
 194         /* EC version 0x5f adds support for wide SCI mask */
 195         if (ec->version >= 0x5f) {
 196                 __be16 ec_word = cpu_to_be16(bits);
 197
 198                 return olpc_ec_cmd(EC_WRITE_EXT_SCI_MASK, (void *)&ec_word, 2, NULL, 0);
 199         } else {
 200                 u8 ec_byte = bits & 0xff;
 201
 202                 return olpc_ec_cmd(EC_WRITE_SCI_MASK, &ec_byte, 1, NULL, 0);
 203         }
 204 }
 205 EXPORT_SYMBOL_GPL(olpc_ec_mask_write);
 206
 207 /*
 208  * Returns true if the compile and runtime configurations allow for EC events
 209  * to wake the system.
 210  */
 211 bool olpc_ec_wakeup_available(void)
 212 {
 213         if (WARN_ON(!ec_driver))
 214                 return false;
 215
 216         return ec_driver->wakeup_available;
 217 }
 218 EXPORT_SYMBOL_GPL(olpc_ec_wakeup_available);
 219
 220 int olpc_ec_sci_query(u16 *sci_value)
 221 {
 222         struct olpc_ec_priv *ec = ec_priv;
 223         int ret;
 224
 225         if (WARN_ON(!ec))
 226                 return -ENODEV;
 227
 228         /* EC version 0x5f adds support for wide SCI mask */
 229         if (ec->version >= 0x5f) {
 230                 __be16 ec_word;
 231
 232                 ret = olpc_ec_cmd(EC_EXT_SCI_QUERY, NULL, 0, (void *)&ec_word, 2);
 233                 if (ret == 0)
 234                         *sci_value = be16_to_cpu(ec_word);
 235         } else {
 236                 u8 ec_byte;
 237
 238                 ret = olpc_ec_cmd(EC_SCI_QUERY, NULL, 0, &ec_byte, 1);
 239                 if (ret == 0)
 240                         *sci_value = ec_byte;
 241         }
 242
 243         return ret;
 244 }
 245 EXPORT_SYMBOL_GPL(olpc_ec_sci_query);
 246
 247 #ifdef CONFIG_DEBUG_FS
 248
 249 /*
 250  * debugfs support for "generic commands", to allow sending
 251  * arbitrary EC commands from userspace.
 252  */
 253
 254 #define EC_MAX_CMD_ARGS (5 + 1)         /* cmd byte + 5 args */
 255 #define EC_MAX_CMD_REPLY (8)
 256
 257 static DEFINE_MUTEX(ec_dbgfs_lock);
 258 static unsigned char ec_dbgfs_resp[EC_MAX_CMD_REPLY];
 259 static unsigned int ec_dbgfs_resp_bytes;
 260
 261 static ssize_t ec_dbgfs_cmd_write(struct file *file, const char __user *buf,
 262                 size_t size, loff_t *ppos)
 263 {
 264         int i, m;
 265         unsigned char ec_cmd[EC_MAX_CMD_ARGS];
 266         unsigned int ec_cmd_int[EC_MAX_CMD_ARGS];
 267         char cmdbuf[64];
 268         int ec_cmd_bytes;
 269
 270         mutex_lock(&ec_dbgfs_lock);
 271
 272         size = simple_write_to_buffer(cmdbuf, sizeof(cmdbuf), ppos, buf, size);
 273
 274         m = sscanf(cmdbuf, "%x:%u %x %x %x %x %x", &ec_cmd_int[0],
 275                         &ec_dbgfs_resp_bytes, &ec_cmd_int[1], &ec_cmd_int[2],
 276                         &ec_cmd_int[3], &ec_cmd_int[4], &ec_cmd_int[5]);
 277         if (m < 2 || ec_dbgfs_resp_bytes > EC_MAX_CMD_REPLY) {
 278                 /* reset to prevent overflow on read */
 279                 ec_dbgfs_resp_bytes = 0;
 280
 281                 pr_debug("olpc-ec: bad ec cmd:  cmd:response-count [arg1 [arg2 ...]]\n");
 282                 size = -EINVAL;
 283                 goto out;
 284         }
 285
 286         /* convert scanf'd ints to char */
 287         ec_cmd_bytes = m - 2;
 288         for (i = 0; i <= ec_cmd_bytes; i++)
 289                 ec_cmd[i] = ec_cmd_int[i];
 290
 291         pr_debug("olpc-ec: debugfs cmd 0x%02x with %d args %5ph, want %d returns\n",
 292                         ec_cmd[0], ec_cmd_bytes, ec_cmd + 1,
 293                         ec_dbgfs_resp_bytes);
 294
 295         olpc_ec_cmd(ec_cmd[0], (ec_cmd_bytes == 0) ? NULL : &ec_cmd[1],
 296                         ec_cmd_bytes, ec_dbgfs_resp, ec_dbgfs_resp_bytes);
 297
 298         pr_debug("olpc-ec: response %8ph (%d bytes expected)\n",
 299                         ec_dbgfs_resp, ec_dbgfs_resp_bytes);
 300
 301 out:
 302         mutex_unlock(&ec_dbgfs_lock);
 303         return size;
 304 }
 305
 306 static ssize_t ec_dbgfs_cmd_read(struct file *file, char __user *buf,
 307                 size_t size, loff_t *ppos)
 308 {
 309         unsigned int i, r;
 310         char *rp;
 311         char respbuf[64];
 312
 313         mutex_lock(&ec_dbgfs_lock);
 314         rp = respbuf;
 315         rp += sprintf(rp, "%02x", ec_dbgfs_resp[0]);
 316         for (i = 1; i < ec_dbgfs_resp_bytes; i++)
 317                 rp += sprintf(rp, ", %02x", ec_dbgfs_resp[i]);
 318         mutex_unlock(&ec_dbgfs_lock);
 319         rp += sprintf(rp, "\n");
 320
 321         r = rp - respbuf;
 322         return simple_read_from_buffer(buf, size, ppos, respbuf, r);
 323 }
 324
 325 static const struct file_operations ec_dbgfs_ops = {
 326         .write = ec_dbgfs_cmd_write,
 327         .read = ec_dbgfs_cmd_read,
 328 };
 329
 330 static struct dentry *olpc_ec_setup_debugfs(void)
 331 {
 332         struct dentry *dbgfs_dir;
 333
 334         dbgfs_dir = debugfs_create_dir("olpc-ec", NULL);
 335         if (IS_ERR_OR_NULL(dbgfs_dir))
 336                 return NULL;
 337
 338         debugfs_create_file("cmd", 0600, dbgfs_dir, NULL, &ec_dbgfs_ops);
 339
 340         return dbgfs_dir;
 341 }
 342
 343 #else
 344
 345 static struct dentry *olpc_ec_setup_debugfs(void)
 346 {
 347         return NULL;
 348 }
 349
 350 #endif /* CONFIG_DEBUG_FS */
 351
 352 static int olpc_ec_set_dcon_power(struct olpc_ec_priv *ec, bool state)
 353 {
 354         unsigned char ec_byte = state;
 355         int ret;
 356
 357         if (ec->dcon_enabled == state)
 358                 return 0;
 359
 360         ret = olpc_ec_cmd(EC_DCON_POWER_MODE, &ec_byte, 1, NULL, 0);
 361         if (ret)
 362                 return ret;
 363
 364         ec->dcon_enabled = state;
 365         return 0;
 366 }
 367
 368 static int dcon_regulator_enable(struct regulator_dev *rdev)
 369 {
 370         struct olpc_ec_priv *ec = rdev_get_drvdata(rdev);
 371
 372         return olpc_ec_set_dcon_power(ec, true);
 373 }
 374
 375 static int dcon_regulator_disable(struct regulator_dev *rdev)
 376 {
 377         struct olpc_ec_priv *ec = rdev_get_drvdata(rdev);
 378
 379         return olpc_ec_set_dcon_power(ec, false);
 380 }
 381
 382 static int dcon_regulator_is_enabled(struct regulator_dev *rdev)
 383 {
 384         struct olpc_ec_priv *ec = rdev_get_drvdata(rdev);
 385
 386         return ec->dcon_enabled ? 1 : 0;
 387 }
 388
 389 static const struct regulator_ops dcon_regulator_ops = {
 390         .enable         = dcon_regulator_enable,
 391         .disable        = dcon_regulator_disable,
 392         .is_enabled     = dcon_regulator_is_enabled,
 393 };
 394
 395 static const struct regulator_desc dcon_desc = {
 396         .name           = "dcon",
 397         .id             = 0,
 398         .ops            = &dcon_regulator_ops,
 399         .type           = REGULATOR_VOLTAGE,
 400         .owner          = THIS_MODULE,
 401         .enable_time    = 25000,
 402 };
 403
 404 static int olpc_ec_probe(struct platform_device *pdev)
 405 {
 406         struct olpc_ec_priv *ec;
 407         struct regulator_config config = { };
 408         struct regulator_dev *regulator;
 409         int err;
 410
 411         if (!ec_driver)
 412                 return -ENODEV;
 413
 414         ec = kzalloc(sizeof(*ec), GFP_KERNEL);
 415         if (!ec)
 416                 return -ENOMEM;
 417
 418         ec->drv = ec_driver;
 419         INIT_WORK(&ec->worker, olpc_ec_worker);
 420         mutex_init(&ec->cmd_lock);
 421
 422         INIT_LIST_HEAD(&ec->cmd_q);
 423         spin_lock_init(&ec->cmd_q_lock);
 424
 425         ec_priv = ec;
 426         platform_set_drvdata(pdev, ec);
 427
 428         /* get the EC revision */
 429         err = olpc_ec_cmd(EC_FIRMWARE_REV, NULL, 0, &ec->version, 1);
 430         if (err)
 431                 goto error;
 432
 433         config.dev = pdev->dev.parent;
 434         config.driver_data = ec;
 435         ec->dcon_enabled = true;
 436         regulator = devm_regulator_register(&pdev->dev, &dcon_desc, &config);
 437         if (IS_ERR(regulator)) {
 438                 dev_err(&pdev->dev, "failed to register DCON regulator\n");
 439                 err = PTR_ERR(regulator);
 440                 goto error;
 441         }
 442
 443         ec->dbgfs_dir = olpc_ec_setup_debugfs();
 444
 445         return 0;
 446
 447 error:
 448         ec_priv = NULL;
 449         kfree(ec);
 450         return err;
 451 }
 452
 453 static int olpc_ec_suspend(struct device *dev)
 454 {
 455         struct platform_device *pdev = to_platform_device(dev);
 456         struct olpc_ec_priv *ec = platform_get_drvdata(pdev);
 457         int err = 0;
 458
 459         olpc_ec_mask_write(ec->ec_wakeup_mask);
 460
 461         if (ec_driver->suspend)
 462                 err = ec_driver->suspend(pdev);
 463         if (!err)
 464                 ec->suspended = true;
 465
 466         return err;
 467 }
 468
 469 static int olpc_ec_resume(struct device *dev)
 470 {
 471         struct platform_device *pdev = to_platform_device(dev);
 472         struct olpc_ec_priv *ec = platform_get_drvdata(pdev);
 473
 474         ec->suspended = false;
 475         return ec_driver->resume ? ec_driver->resume(pdev) : 0;
 476 }
 477
 478 static const struct dev_pm_ops olpc_ec_pm_ops = {
 479         .suspend_late = olpc_ec_suspend,
 480         .resume_early = olpc_ec_resume,
 481 };
 482
 483 static struct platform_driver olpc_ec_plat_driver = {
 484         .probe = olpc_ec_probe,
 485         .driver = {
 486                 .name = "olpc-ec",
 487                 .pm = &olpc_ec_pm_ops,
 488         },
 489 };
 490
 491 static int __init olpc_ec_init_module(void)
 492 {
 493         return platform_driver_register(&olpc_ec_plat_driver);
 494 }
 495 arch_initcall(olpc_ec_init_module);