drivers/platform/chrome/cros_ec.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * ChromeOS EC multi-function device
   4  *
   5  * Copyright (C) 2012 Google, Inc
   6  *
   7  * The ChromeOS EC multi function device is used to mux all the requests
   8  * to the EC device for its multiple features: keyboard controller,
   9  * battery charging and regulator control, firmware update.
  10  */
  11
  12 #include <linux/interrupt.h>
  13 #include <linux/module.h>
  14 #include <linux/of_platform.h>
  15 #include <linux/platform_device.h>
  16 #include <linux/platform_data/cros_ec_commands.h>
  17 #include <linux/platform_data/cros_ec_proto.h>
  18 #include <linux/slab.h>
  19 #include <linux/suspend.h>
  20
  21 #include "cros_ec.h"
  22
  23 static struct cros_ec_platform ec_p = {
  24         .ec_name = CROS_EC_DEV_NAME,
  25         .cmd_offset = EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_EC_INDEX),
  26 };
  27
  28 static struct cros_ec_platform pd_p = {
  29         .ec_name = CROS_EC_DEV_PD_NAME,
  30         .cmd_offset = EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX),
  31 };
  32
  33 /**
  34  * cros_ec_irq_handler() - top half part of the interrupt handler
  35  * @irq: IRQ id
  36  * @data: (ec_dev) Device with events to process.
  37  *
  38  * Return: Wakeup the bottom half
  39  */
  40 static irqreturn_t cros_ec_irq_handler(int irq, void *data)
  41 {
  42         struct cros_ec_device *ec_dev = data;
  43
  44         ec_dev->last_event_time = cros_ec_get_time_ns();
  45
  46         return IRQ_WAKE_THREAD;
  47 }
  48
  49 /**
  50  * cros_ec_handle_event() - process and forward pending events on EC
  51  * @ec_dev: Device with events to process.
  52  *
  53  * Call this function in a loop when the kernel is notified that the EC has
  54  * pending events.
  55  *
  56  * Return: true if more events are still pending and this function should be
  57  * called again.
  58  */
  59 static bool cros_ec_handle_event(struct cros_ec_device *ec_dev)
  60 {
  61         bool wake_event;
  62         bool ec_has_more_events;
  63         int ret;
  64
  65         ret = cros_ec_get_next_event(ec_dev, &wake_event, &ec_has_more_events);
  66
  67         /*
  68          * Signal only if wake host events or any interrupt if
  69          * cros_ec_get_next_event() returned an error (default value for
  70          * wake_event is true)
  71          */
  72         if (wake_event && device_may_wakeup(ec_dev->dev))
  73                 pm_wakeup_event(ec_dev->dev, 0);
  74
  75         if (ret > 0)
  76                 blocking_notifier_call_chain(&ec_dev->event_notifier,
  77                                              0, ec_dev);
  78
  79         return ec_has_more_events;
  80 }
  81
  82 /**
  83  * cros_ec_irq_thread() - bottom half part of the interrupt handler
  84  * @irq: IRQ id
  85  * @data: (ec_dev) Device with events to process.
  86  *
  87  * Return: Interrupt handled.
  88  */
  89 irqreturn_t cros_ec_irq_thread(int irq, void *data)
  90 {
  91         struct cros_ec_device *ec_dev = data;
  92         bool ec_has_more_events;
  93
  94         do {
  95                 ec_has_more_events = cros_ec_handle_event(ec_dev);
  96         } while (ec_has_more_events);
  97
  98         return IRQ_HANDLED;
  99 }
 100 EXPORT_SYMBOL(cros_ec_irq_thread);
 101
 102 static int cros_ec_sleep_event(struct cros_ec_device *ec_dev, u8 sleep_event)
 103 {
 104         int ret;
 105         struct {
 106                 struct cros_ec_command msg;
 107                 union {
 108                         struct ec_params_host_sleep_event req0;
 109                         struct ec_params_host_sleep_event_v1 req1;
 110                         struct ec_response_host_sleep_event_v1 resp1;
 111                 } u;
 112         } __packed buf;
 113
 114         memset(&buf, 0, sizeof(buf));
 115
 116         if (ec_dev->host_sleep_v1) {
 117                 buf.u.req1.sleep_event = sleep_event;
 118                 buf.u.req1.suspend_params.sleep_timeout_ms =
 119                                 ec_dev->suspend_timeout_ms;
 120
 121                 buf.msg.outsize = sizeof(buf.u.req1);
 122                 if ((sleep_event == HOST_SLEEP_EVENT_S3_RESUME) ||
 123                     (sleep_event == HOST_SLEEP_EVENT_S0IX_RESUME))
 124                         buf.msg.insize = sizeof(buf.u.resp1);
 125
 126                 buf.msg.version = 1;
 127
 128         } else {
 129                 buf.u.req0.sleep_event = sleep_event;
 130                 buf.msg.outsize = sizeof(buf.u.req0);
 131         }
 132
 133         buf.msg.command = EC_CMD_HOST_SLEEP_EVENT;
 134
 135         ret = cros_ec_cmd_xfer_status(ec_dev, &buf.msg);
 136         /* Report failure to transition to system wide suspend with a warning. */
 137         if (ret >= 0 && ec_dev->host_sleep_v1 &&
 138             (sleep_event == HOST_SLEEP_EVENT_S0IX_RESUME ||
 139              sleep_event == HOST_SLEEP_EVENT_S3_RESUME)) {
 140                 ec_dev->last_resume_result =
 141                         buf.u.resp1.resume_response.sleep_transitions;
 142
 143                 WARN_ONCE(buf.u.resp1.resume_response.sleep_transitions &
 144                           EC_HOST_RESUME_SLEEP_TIMEOUT,
 145                           "EC detected sleep transition timeout. Total sleep transitions: %d",
 146                           buf.u.resp1.resume_response.sleep_transitions &
 147                           EC_HOST_RESUME_SLEEP_TRANSITIONS_MASK);
 148         }
 149
 150         return ret;
 151 }
 152
 153 static int cros_ec_ready_event(struct notifier_block *nb,
 154                                unsigned long queued_during_suspend,
 155                                void *_notify)
 156 {
 157         struct cros_ec_device *ec_dev = container_of(nb, struct cros_ec_device,
 158                                                      notifier_ready);
 159         u32 host_event = cros_ec_get_host_event(ec_dev);
 160
 161         if (host_event & EC_HOST_EVENT_MASK(EC_HOST_EVENT_INTERFACE_READY)) {
 162                 mutex_lock(&ec_dev->lock);
 163                 cros_ec_query_all(ec_dev);
 164                 mutex_unlock(&ec_dev->lock);
 165                 return NOTIFY_OK;
 166         }
 167
 168         return NOTIFY_DONE;
 169 }
 170
 171 /**
 172  * cros_ec_register() - Register a new ChromeOS EC, using the provided info.
 173  * @ec_dev: Device to register.
 174  *
 175  * Before calling this, allocate a pointer to a new device and then fill
 176  * in all the fields up to the --private-- marker.
 177  *
 178  * Return: 0 on success or negative error code.
 179  */
 180 int cros_ec_register(struct cros_ec_device *ec_dev)
 181 {
 182         struct device *dev = ec_dev->dev;
 183         int err = 0;
 184
 185         BLOCKING_INIT_NOTIFIER_HEAD(&ec_dev->event_notifier);
 186         BLOCKING_INIT_NOTIFIER_HEAD(&ec_dev->panic_notifier);
 187
 188         ec_dev->max_request = sizeof(struct ec_params_hello);
 189         ec_dev->max_response = sizeof(struct ec_response_get_protocol_info);
 190         ec_dev->max_passthru = 0;
 191         ec_dev->ec = NULL;
 192         ec_dev->pd = NULL;
 193         ec_dev->suspend_timeout_ms = EC_HOST_SLEEP_TIMEOUT_DEFAULT;
 194
 195         ec_dev->din = devm_kzalloc(dev, ec_dev->din_size, GFP_KERNEL);
 196         if (!ec_dev->din)
 197                 return -ENOMEM;
 198
 199         ec_dev->dout = devm_kzalloc(dev, ec_dev->dout_size, GFP_KERNEL);
 200         if (!ec_dev->dout)
 201                 return -ENOMEM;
 202
 203         lockdep_register_key(&ec_dev->lockdep_key);
 204         mutex_init(&ec_dev->lock);
 205         lockdep_set_class(&ec_dev->lock, &ec_dev->lockdep_key);
 206
 207         err = cros_ec_query_all(ec_dev);
 208         if (err) {
 209                 dev_err(dev, "Cannot identify the EC: error %d\n", err);
 210                 goto exit;
 211         }
 212
 213         if (ec_dev->irq > 0) {
 214                 err = devm_request_threaded_irq(dev, ec_dev->irq,
 215                                                 cros_ec_irq_handler,
 216                                                 cros_ec_irq_thread,
 217                                                 IRQF_TRIGGER_LOW | IRQF_ONESHOT,
 218                                                 "chromeos-ec", ec_dev);
 219                 if (err) {
 220                         dev_err(dev, "Failed to request IRQ %d: %d\n",
 221                                 ec_dev->irq, err);
 222                         goto exit;
 223                 }
 224         }
 225
 226         /* Register a platform device for the main EC instance */
 227         ec_dev->ec = platform_device_register_data(ec_dev->dev, "cros-ec-dev",
 228                                         PLATFORM_DEVID_AUTO, &ec_p,
 229                                         sizeof(struct cros_ec_platform));
 230         if (IS_ERR(ec_dev->ec)) {
 231                 dev_err(ec_dev->dev,
 232                         "Failed to create CrOS EC platform device\n");
 233                 err = PTR_ERR(ec_dev->ec);
 234                 goto exit;
 235         }
 236
 237         if (ec_dev->max_passthru) {
 238                 /*
 239                  * Register a platform device for the PD behind the main EC.
 240                  * We make the following assumptions:
 241                  * - behind an EC, we have a pd
 242                  * - only one device added.
 243                  * - the EC is responsive at init time (it is not true for a
 244                  *   sensor hub).
 245                  */
 246                 ec_dev->pd = platform_device_register_data(ec_dev->dev,
 247                                         "cros-ec-dev",
 248                                         PLATFORM_DEVID_AUTO, &pd_p,
 249                                         sizeof(struct cros_ec_platform));
 250                 if (IS_ERR(ec_dev->pd)) {
 251                         dev_err(ec_dev->dev,
 252                                 "Failed to create CrOS PD platform device\n");
 253                         err = PTR_ERR(ec_dev->pd);
 254                         goto exit;
 255                 }
 256         }
 257
 258         if (IS_ENABLED(CONFIG_OF) && dev->of_node) {
 259                 err = devm_of_platform_populate(dev);
 260                 if (err) {
 261                         dev_err(dev, "Failed to register sub-devices\n");
 262                         goto exit;
 263                 }
 264         }
 265
 266         /*
 267          * Clear sleep event - this will fail harmlessly on platforms that
 268          * don't implement the sleep event host command.
 269          */
 270         err = cros_ec_sleep_event(ec_dev, 0);
 271         if (err < 0)
 272                 dev_dbg(ec_dev->dev, "Error %d clearing sleep event to ec\n",
 273                         err);
 274
 275         if (ec_dev->mkbp_event_supported) {
 276                 /*
 277                  * Register the notifier for EC_HOST_EVENT_INTERFACE_READY
 278                  * event.
 279                  */
 280                 ec_dev->notifier_ready.notifier_call = cros_ec_ready_event;
 281                 err = blocking_notifier_chain_register(&ec_dev->event_notifier,
 282                                                       &ec_dev->notifier_ready);
 283                 if (err)
 284                         goto exit;
 285         }
 286
 287         dev_info(dev, "Chrome EC device registered\n");
 288
 289         /*
 290          * Unlock EC that may be waiting for AP to process MKBP events.
 291          * If the AP takes to long to answer, the EC would stop sending events.
 292          */
 293         if (ec_dev->mkbp_event_supported)
 294                 cros_ec_irq_thread(0, ec_dev);
 295
 296         return 0;
 297 exit:
 298         platform_device_unregister(ec_dev->ec);
 299         platform_device_unregister(ec_dev->pd);
 300         mutex_destroy(&ec_dev->lock);
 301         lockdep_unregister_key(&ec_dev->lockdep_key);
 302         return err;
 303 }
 304 EXPORT_SYMBOL(cros_ec_register);
 305
 306 /**
 307  * cros_ec_unregister() - Remove a ChromeOS EC.
 308  * @ec_dev: Device to unregister.
 309  *
 310  * Call this to deregister a ChromeOS EC, then clean up any private data.
 311  *
 312  * Return: 0 on success or negative error code.
 313  */
 314 void cros_ec_unregister(struct cros_ec_device *ec_dev)
 315 {
 316         platform_device_unregister(ec_dev->pd);
 317         platform_device_unregister(ec_dev->ec);
 318         mutex_destroy(&ec_dev->lock);
 319         lockdep_unregister_key(&ec_dev->lockdep_key);
 320 }
 321 EXPORT_SYMBOL(cros_ec_unregister);
 322
 323 #ifdef CONFIG_PM_SLEEP
 324 static void cros_ec_send_suspend_event(struct cros_ec_device *ec_dev)
 325 {
 326         int ret;
 327         u8 sleep_event;
 328
 329         sleep_event = (!IS_ENABLED(CONFIG_ACPI) || pm_suspend_via_firmware()) ?
 330                       HOST_SLEEP_EVENT_S3_SUSPEND :
 331                       HOST_SLEEP_EVENT_S0IX_SUSPEND;
 332
 333         ret = cros_ec_sleep_event(ec_dev, sleep_event);
 334         if (ret < 0)
 335                 dev_dbg(ec_dev->dev, "Error %d sending suspend event to ec\n",
 336                         ret);
 337 }
 338
 339 /**
 340  * cros_ec_suspend_prepare() - Handle a suspend prepare operation for the ChromeOS EC device.
 341  * @ec_dev: Device to suspend.
 342  *
 343  * This can be called by drivers to handle a suspend prepare stage of suspend.
 344  *
 345  * Return: 0 always.
 346  */
 347 int cros_ec_suspend_prepare(struct cros_ec_device *ec_dev)
 348 {
 349         cros_ec_send_suspend_event(ec_dev);
 350         return 0;
 351 }
 352 EXPORT_SYMBOL(cros_ec_suspend_prepare);
 353
 354 static void cros_ec_disable_irq(struct cros_ec_device *ec_dev)
 355 {
 356         struct device *dev = ec_dev->dev;
 357         if (device_may_wakeup(dev))
 358                 ec_dev->wake_enabled = !enable_irq_wake(ec_dev->irq);
 359         else
 360                 ec_dev->wake_enabled = false;
 361
 362         disable_irq(ec_dev->irq);
 363         ec_dev->suspended = true;
 364 }
 365
 366 /**
 367  * cros_ec_suspend_late() - Handle a suspend late operation for the ChromeOS EC device.
 368  * @ec_dev: Device to suspend.
 369  *
 370  * This can be called by drivers to handle a suspend late stage of suspend.
 371  *
 372  * Return: 0 always.
 373  */
 374 int cros_ec_suspend_late(struct cros_ec_device *ec_dev)
 375 {
 376         cros_ec_disable_irq(ec_dev);
 377         return 0;
 378 }
 379 EXPORT_SYMBOL(cros_ec_suspend_late);
 380
 381 /**
 382  * cros_ec_suspend() - Handle a suspend operation for the ChromeOS EC device.
 383  * @ec_dev: Device to suspend.
 384  *
 385  * This can be called by drivers to handle a suspend event.
 386  *
 387  * Return: 0 always.
 388  */
 389 int cros_ec_suspend(struct cros_ec_device *ec_dev)
 390 {
 391         cros_ec_suspend_prepare(ec_dev);
 392         cros_ec_suspend_late(ec_dev);
 393         return 0;
 394 }
 395 EXPORT_SYMBOL(cros_ec_suspend);
 396
 397 static void cros_ec_report_events_during_suspend(struct cros_ec_device *ec_dev)
 398 {
 399         bool wake_event;
 400
 401         while (ec_dev->mkbp_event_supported &&
 402                cros_ec_get_next_event(ec_dev, &wake_event, NULL) > 0) {
 403                 blocking_notifier_call_chain(&ec_dev->event_notifier,
 404                                              1, ec_dev);
 405
 406                 if (wake_event && device_may_wakeup(ec_dev->dev))
 407                         pm_wakeup_event(ec_dev->dev, 0);
 408         }
 409 }
 410
 411 static void cros_ec_send_resume_event(struct cros_ec_device *ec_dev)
 412 {
 413         int ret;
 414         u8 sleep_event;
 415
 416         sleep_event = (!IS_ENABLED(CONFIG_ACPI) || pm_suspend_via_firmware()) ?
 417                       HOST_SLEEP_EVENT_S3_RESUME :
 418                       HOST_SLEEP_EVENT_S0IX_RESUME;
 419
 420         ret = cros_ec_sleep_event(ec_dev, sleep_event);
 421         if (ret < 0)
 422                 dev_dbg(ec_dev->dev, "Error %d sending resume event to ec\n",
 423                         ret);
 424 }
 425
 426 /**
 427  * cros_ec_resume_complete() - Handle a resume complete operation for the ChromeOS EC device.
 428  * @ec_dev: Device to resume.
 429  *
 430  * This can be called by drivers to handle a resume complete stage of resume.
 431  */
 432 void cros_ec_resume_complete(struct cros_ec_device *ec_dev)
 433 {
 434         cros_ec_send_resume_event(ec_dev);
 435
 436         /*
 437          * Let the mfd devices know about events that occur during
 438          * suspend. This way the clients know what to do with them.
 439          */
 440         cros_ec_report_events_during_suspend(ec_dev);
 441 }
 442 EXPORT_SYMBOL(cros_ec_resume_complete);
 443
 444 static void cros_ec_enable_irq(struct cros_ec_device *ec_dev)
 445 {
 446         ec_dev->suspended = false;
 447         enable_irq(ec_dev->irq);
 448
 449         if (ec_dev->wake_enabled)
 450                 disable_irq_wake(ec_dev->irq);
 451 }
 452
 453 /**
 454  * cros_ec_resume_early() - Handle a resume early operation for the ChromeOS EC device.
 455  * @ec_dev: Device to resume.
 456  *
 457  * This can be called by drivers to handle a resume early stage of resume.
 458  *
 459  * Return: 0 always.
 460  */
 461 int cros_ec_resume_early(struct cros_ec_device *ec_dev)
 462 {
 463         cros_ec_enable_irq(ec_dev);
 464         return 0;
 465 }
 466 EXPORT_SYMBOL(cros_ec_resume_early);
 467
 468 /**
 469  * cros_ec_resume() - Handle a resume operation for the ChromeOS EC device.
 470  * @ec_dev: Device to resume.
 471  *
 472  * This can be called by drivers to handle a resume event.
 473  *
 474  * Return: 0 always.
 475  */
 476 int cros_ec_resume(struct cros_ec_device *ec_dev)
 477 {
 478         cros_ec_resume_early(ec_dev);
 479         cros_ec_resume_complete(ec_dev);
 480         return 0;
 481 }
 482 EXPORT_SYMBOL(cros_ec_resume);
 483
 484 #endif
 485
 486 MODULE_LICENSE("GPL");
 487 MODULE_DESCRIPTION("ChromeOS EC core driver");