Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *  ec.c - ACPI Embedded Controller Driver (v3)
0004  *
0005  *  Copyright (C) 2001-2015 Intel Corporation
0006  *    Author: 2014, 2015 Lv Zheng <lv.zheng@intel.com>
0007  *            2006, 2007 Alexey Starikovskiy <alexey.y.starikovskiy@intel.com>
0008  *            2006       Denis Sadykov <denis.m.sadykov@intel.com>
0009  *            2004       Luming Yu <luming.yu@intel.com>
0010  *            2001, 2002 Andy Grover <andrew.grover@intel.com>
0011  *            2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
0012  *  Copyright (C) 2008      Alexey Starikovskiy <astarikovskiy@suse.de>
0013  */
0014 
0015 /* Uncomment next line to get verbose printout */
0016 /* #define DEBUG */
0017 #define pr_fmt(fmt) "ACPI: EC: " fmt
0018 
0019 #include <linux/kernel.h>
0020 #include <linux/module.h>
0021 #include <linux/init.h>
0022 #include <linux/types.h>
0023 #include <linux/delay.h>
0024 #include <linux/interrupt.h>
0025 #include <linux/list.h>
0026 #include <linux/spinlock.h>
0027 #include <linux/slab.h>
0028 #include <linux/suspend.h>
0029 #include <linux/acpi.h>
0030 #include <linux/dmi.h>
0031 #include <asm/io.h>
0032 
0033 #include "internal.h"
0034 
0035 #define ACPI_EC_CLASS           "embedded_controller"
0036 #define ACPI_EC_DEVICE_NAME     "Embedded Controller"
0037 
0038 /* EC status register */
0039 #define ACPI_EC_FLAG_OBF    0x01    /* Output buffer full */
0040 #define ACPI_EC_FLAG_IBF    0x02    /* Input buffer full */
0041 #define ACPI_EC_FLAG_CMD    0x08    /* Input buffer contains a command */
0042 #define ACPI_EC_FLAG_BURST  0x10    /* burst mode */
0043 #define ACPI_EC_FLAG_SCI    0x20    /* EC-SCI occurred */
0044 
0045 /*
0046  * The SCI_EVT clearing timing is not defined by the ACPI specification.
0047  * This leads to lots of practical timing issues for the host EC driver.
0048  * The following variations are defined (from the target EC firmware's
0049  * perspective):
0050  * STATUS: After indicating SCI_EVT edge triggered IRQ to the host, the
0051  *         target can clear SCI_EVT at any time so long as the host can see
0052  *         the indication by reading the status register (EC_SC). So the
0053  *         host should re-check SCI_EVT after the first time the SCI_EVT
0054  *         indication is seen, which is the same time the query request
0055  *         (QR_EC) is written to the command register (EC_CMD). SCI_EVT set
0056  *         at any later time could indicate another event. Normally such
0057  *         kind of EC firmware has implemented an event queue and will
0058  *         return 0x00 to indicate "no outstanding event".
0059  * QUERY: After seeing the query request (QR_EC) written to the command
0060  *        register (EC_CMD) by the host and having prepared the responding
0061  *        event value in the data register (EC_DATA), the target can safely
0062  *        clear SCI_EVT because the target can confirm that the current
0063  *        event is being handled by the host. The host then should check
0064  *        SCI_EVT right after reading the event response from the data
0065  *        register (EC_DATA).
0066  * EVENT: After seeing the event response read from the data register
0067  *        (EC_DATA) by the host, the target can clear SCI_EVT. As the
0068  *        target requires time to notice the change in the data register
0069  *        (EC_DATA), the host may be required to wait additional guarding
0070  *        time before checking the SCI_EVT again. Such guarding may not be
0071  *        necessary if the host is notified via another IRQ.
0072  */
0073 #define ACPI_EC_EVT_TIMING_STATUS   0x00
0074 #define ACPI_EC_EVT_TIMING_QUERY    0x01
0075 #define ACPI_EC_EVT_TIMING_EVENT    0x02
0076 
0077 /* EC commands */
0078 enum ec_command {
0079     ACPI_EC_COMMAND_READ = 0x80,
0080     ACPI_EC_COMMAND_WRITE = 0x81,
0081     ACPI_EC_BURST_ENABLE = 0x82,
0082     ACPI_EC_BURST_DISABLE = 0x83,
0083     ACPI_EC_COMMAND_QUERY = 0x84,
0084 };
0085 
0086 #define ACPI_EC_DELAY       500 /* Wait 500ms max. during EC ops */
0087 #define ACPI_EC_UDELAY_GLK  1000    /* Wait 1ms max. to get global lock */
0088 #define ACPI_EC_UDELAY_POLL 550 /* Wait 1ms for EC transaction polling */
0089 #define ACPI_EC_CLEAR_MAX   100 /* Maximum number of events to query
0090                      * when trying to clear the EC */
0091 #define ACPI_EC_MAX_QUERIES 16  /* Maximum number of parallel queries */
0092 
0093 enum {
0094     EC_FLAGS_QUERY_ENABLED,     /* Query is enabled */
0095     EC_FLAGS_EVENT_HANDLER_INSTALLED,   /* Event handler installed */
0096     EC_FLAGS_EC_HANDLER_INSTALLED,  /* OpReg handler installed */
0097     EC_FLAGS_QUERY_METHODS_INSTALLED, /* _Qxx handlers installed */
0098     EC_FLAGS_STARTED,       /* Driver is started */
0099     EC_FLAGS_STOPPED,       /* Driver is stopped */
0100     EC_FLAGS_EVENTS_MASKED,     /* Events masked */
0101 };
0102 
0103 #define ACPI_EC_COMMAND_POLL        0x01 /* Available for command byte */
0104 #define ACPI_EC_COMMAND_COMPLETE    0x02 /* Completed last byte */
0105 
0106 /* ec.c is compiled in acpi namespace so this shows up as acpi.ec_delay param */
0107 static unsigned int ec_delay __read_mostly = ACPI_EC_DELAY;
0108 module_param(ec_delay, uint, 0644);
0109 MODULE_PARM_DESC(ec_delay, "Timeout(ms) waited until an EC command completes");
0110 
0111 static unsigned int ec_max_queries __read_mostly = ACPI_EC_MAX_QUERIES;
0112 module_param(ec_max_queries, uint, 0644);
0113 MODULE_PARM_DESC(ec_max_queries, "Maximum parallel _Qxx evaluations");
0114 
0115 static bool ec_busy_polling __read_mostly;
0116 module_param(ec_busy_polling, bool, 0644);
0117 MODULE_PARM_DESC(ec_busy_polling, "Use busy polling to advance EC transaction");
0118 
0119 static unsigned int ec_polling_guard __read_mostly = ACPI_EC_UDELAY_POLL;
0120 module_param(ec_polling_guard, uint, 0644);
0121 MODULE_PARM_DESC(ec_polling_guard, "Guard time(us) between EC accesses in polling modes");
0122 
0123 static unsigned int ec_event_clearing __read_mostly = ACPI_EC_EVT_TIMING_QUERY;
0124 
0125 /*
0126  * If the number of false interrupts per one transaction exceeds
0127  * this threshold, will think there is a GPE storm happened and
0128  * will disable the GPE for normal transaction.
0129  */
0130 static unsigned int ec_storm_threshold  __read_mostly = 8;
0131 module_param(ec_storm_threshold, uint, 0644);
0132 MODULE_PARM_DESC(ec_storm_threshold, "Maxim false GPE numbers not considered as GPE storm");
0133 
0134 static bool ec_freeze_events __read_mostly;
0135 module_param(ec_freeze_events, bool, 0644);
0136 MODULE_PARM_DESC(ec_freeze_events, "Disabling event handling during suspend/resume");
0137 
0138 static bool ec_no_wakeup __read_mostly;
0139 module_param(ec_no_wakeup, bool, 0644);
0140 MODULE_PARM_DESC(ec_no_wakeup, "Do not wake up from suspend-to-idle");
0141 
0142 struct acpi_ec_query_handler {
0143     struct list_head node;
0144     acpi_ec_query_func func;
0145     acpi_handle handle;
0146     void *data;
0147     u8 query_bit;
0148     struct kref kref;
0149 };
0150 
0151 struct transaction {
0152     const u8 *wdata;
0153     u8 *rdata;
0154     unsigned short irq_count;
0155     u8 command;
0156     u8 wi;
0157     u8 ri;
0158     u8 wlen;
0159     u8 rlen;
0160     u8 flags;
0161 };
0162 
0163 struct acpi_ec_query {
0164     struct transaction transaction;
0165     struct work_struct work;
0166     struct acpi_ec_query_handler *handler;
0167     struct acpi_ec *ec;
0168 };
0169 
0170 static int acpi_ec_submit_query(struct acpi_ec *ec);
0171 static void advance_transaction(struct acpi_ec *ec, bool interrupt);
0172 static void acpi_ec_event_handler(struct work_struct *work);
0173 
0174 struct acpi_ec *first_ec;
0175 EXPORT_SYMBOL(first_ec);
0176 
0177 static struct acpi_ec *boot_ec;
0178 static bool boot_ec_is_ecdt;
0179 static struct workqueue_struct *ec_wq;
0180 static struct workqueue_struct *ec_query_wq;
0181 
0182 static int EC_FLAGS_CORRECT_ECDT; /* Needs ECDT port address correction */
0183 static int EC_FLAGS_TRUST_DSDT_GPE; /* Needs DSDT GPE as correction setting */
0184 static int EC_FLAGS_CLEAR_ON_RESUME; /* Needs acpi_ec_clear() on boot/resume */
0185 
0186 /* --------------------------------------------------------------------------
0187  *                           Logging/Debugging
0188  * -------------------------------------------------------------------------- */
0189 
0190 /*
0191  * Splitters used by the developers to track the boundary of the EC
0192  * handling processes.
0193  */
0194 #ifdef DEBUG
0195 #define EC_DBG_SEP  " "
0196 #define EC_DBG_DRV  "+++++"
0197 #define EC_DBG_STM  "====="
0198 #define EC_DBG_REQ  "*****"
0199 #define EC_DBG_EVT  "#####"
0200 #else
0201 #define EC_DBG_SEP  ""
0202 #define EC_DBG_DRV
0203 #define EC_DBG_STM
0204 #define EC_DBG_REQ
0205 #define EC_DBG_EVT
0206 #endif
0207 
0208 #define ec_log_raw(fmt, ...) \
0209     pr_info(fmt "\n", ##__VA_ARGS__)
0210 #define ec_dbg_raw(fmt, ...) \
0211     pr_debug(fmt "\n", ##__VA_ARGS__)
0212 #define ec_log(filter, fmt, ...) \
0213     ec_log_raw(filter EC_DBG_SEP fmt EC_DBG_SEP filter, ##__VA_ARGS__)
0214 #define ec_dbg(filter, fmt, ...) \
0215     ec_dbg_raw(filter EC_DBG_SEP fmt EC_DBG_SEP filter, ##__VA_ARGS__)
0216 
0217 #define ec_log_drv(fmt, ...) \
0218     ec_log(EC_DBG_DRV, fmt, ##__VA_ARGS__)
0219 #define ec_dbg_drv(fmt, ...) \
0220     ec_dbg(EC_DBG_DRV, fmt, ##__VA_ARGS__)
0221 #define ec_dbg_stm(fmt, ...) \
0222     ec_dbg(EC_DBG_STM, fmt, ##__VA_ARGS__)
0223 #define ec_dbg_req(fmt, ...) \
0224     ec_dbg(EC_DBG_REQ, fmt, ##__VA_ARGS__)
0225 #define ec_dbg_evt(fmt, ...) \
0226     ec_dbg(EC_DBG_EVT, fmt, ##__VA_ARGS__)
0227 #define ec_dbg_ref(ec, fmt, ...) \
0228     ec_dbg_raw("%lu: " fmt, ec->reference_count, ## __VA_ARGS__)
0229 
0230 /* --------------------------------------------------------------------------
0231  *                           Device Flags
0232  * -------------------------------------------------------------------------- */
0233 
0234 static bool acpi_ec_started(struct acpi_ec *ec)
0235 {
0236     return test_bit(EC_FLAGS_STARTED, &ec->flags) &&
0237            !test_bit(EC_FLAGS_STOPPED, &ec->flags);
0238 }
0239 
0240 static bool acpi_ec_event_enabled(struct acpi_ec *ec)
0241 {
0242     /*
0243      * There is an OSPM early stage logic. During the early stages
0244      * (boot/resume), OSPMs shouldn't enable the event handling, only
0245      * the EC transactions are allowed to be performed.
0246      */
0247     if (!test_bit(EC_FLAGS_QUERY_ENABLED, &ec->flags))
0248         return false;
0249     /*
0250      * However, disabling the event handling is experimental for late
0251      * stage (suspend), and is controlled by the boot parameter of
0252      * "ec_freeze_events":
0253      * 1. true:  The EC event handling is disabled before entering
0254      *           the noirq stage.
0255      * 2. false: The EC event handling is automatically disabled as
0256      *           soon as the EC driver is stopped.
0257      */
0258     if (ec_freeze_events)
0259         return acpi_ec_started(ec);
0260     else
0261         return test_bit(EC_FLAGS_STARTED, &ec->flags);
0262 }
0263 
0264 static bool acpi_ec_flushed(struct acpi_ec *ec)
0265 {
0266     return ec->reference_count == 1;
0267 }
0268 
0269 /* --------------------------------------------------------------------------
0270  *                           EC Registers
0271  * -------------------------------------------------------------------------- */
0272 
0273 static inline u8 acpi_ec_read_status(struct acpi_ec *ec)
0274 {
0275     u8 x = inb(ec->command_addr);
0276 
0277     ec_dbg_raw("EC_SC(R) = 0x%2.2x "
0278            "SCI_EVT=%d BURST=%d CMD=%d IBF=%d OBF=%d",
0279            x,
0280            !!(x & ACPI_EC_FLAG_SCI),
0281            !!(x & ACPI_EC_FLAG_BURST),
0282            !!(x & ACPI_EC_FLAG_CMD),
0283            !!(x & ACPI_EC_FLAG_IBF),
0284            !!(x & ACPI_EC_FLAG_OBF));
0285     return x;
0286 }
0287 
0288 static inline u8 acpi_ec_read_data(struct acpi_ec *ec)
0289 {
0290     u8 x = inb(ec->data_addr);
0291 
0292     ec->timestamp = jiffies;
0293     ec_dbg_raw("EC_DATA(R) = 0x%2.2x", x);
0294     return x;
0295 }
0296 
0297 static inline void acpi_ec_write_cmd(struct acpi_ec *ec, u8 command)
0298 {
0299     ec_dbg_raw("EC_SC(W) = 0x%2.2x", command);
0300     outb(command, ec->command_addr);
0301     ec->timestamp = jiffies;
0302 }
0303 
0304 static inline void acpi_ec_write_data(struct acpi_ec *ec, u8 data)
0305 {
0306     ec_dbg_raw("EC_DATA(W) = 0x%2.2x", data);
0307     outb(data, ec->data_addr);
0308     ec->timestamp = jiffies;
0309 }
0310 
0311 #if defined(DEBUG) || defined(CONFIG_DYNAMIC_DEBUG)
0312 static const char *acpi_ec_cmd_string(u8 cmd)
0313 {
0314     switch (cmd) {
0315     case 0x80:
0316         return "RD_EC";
0317     case 0x81:
0318         return "WR_EC";
0319     case 0x82:
0320         return "BE_EC";
0321     case 0x83:
0322         return "BD_EC";
0323     case 0x84:
0324         return "QR_EC";
0325     }
0326     return "UNKNOWN";
0327 }
0328 #else
0329 #define acpi_ec_cmd_string(cmd)     "UNDEF"
0330 #endif
0331 
0332 /* --------------------------------------------------------------------------
0333  *                           GPE Registers
0334  * -------------------------------------------------------------------------- */
0335 
0336 static inline bool acpi_ec_gpe_status_set(struct acpi_ec *ec)
0337 {
0338     acpi_event_status gpe_status = 0;
0339 
0340     (void)acpi_get_gpe_status(NULL, ec->gpe, &gpe_status);
0341     return !!(gpe_status & ACPI_EVENT_FLAG_STATUS_SET);
0342 }
0343 
0344 static inline void acpi_ec_enable_gpe(struct acpi_ec *ec, bool open)
0345 {
0346     if (open)
0347         acpi_enable_gpe(NULL, ec->gpe);
0348     else {
0349         BUG_ON(ec->reference_count < 1);
0350         acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_ENABLE);
0351     }
0352     if (acpi_ec_gpe_status_set(ec)) {
0353         /*
0354          * On some platforms, EN=1 writes cannot trigger GPE. So
0355          * software need to manually trigger a pseudo GPE event on
0356          * EN=1 writes.
0357          */
0358         ec_dbg_raw("Polling quirk");
0359         advance_transaction(ec, false);
0360     }
0361 }
0362 
0363 static inline void acpi_ec_disable_gpe(struct acpi_ec *ec, bool close)
0364 {
0365     if (close)
0366         acpi_disable_gpe(NULL, ec->gpe);
0367     else {
0368         BUG_ON(ec->reference_count < 1);
0369         acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_DISABLE);
0370     }
0371 }
0372 
0373 /* --------------------------------------------------------------------------
0374  *                           Transaction Management
0375  * -------------------------------------------------------------------------- */
0376 
0377 static void acpi_ec_submit_request(struct acpi_ec *ec)
0378 {
0379     ec->reference_count++;
0380     if (test_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags) &&
0381         ec->gpe >= 0 && ec->reference_count == 1)
0382         acpi_ec_enable_gpe(ec, true);
0383 }
0384 
0385 static void acpi_ec_complete_request(struct acpi_ec *ec)
0386 {
0387     bool flushed = false;
0388 
0389     ec->reference_count--;
0390     if (test_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags) &&
0391         ec->gpe >= 0 && ec->reference_count == 0)
0392         acpi_ec_disable_gpe(ec, true);
0393     flushed = acpi_ec_flushed(ec);
0394     if (flushed)
0395         wake_up(&ec->wait);
0396 }
0397 
0398 static void acpi_ec_mask_events(struct acpi_ec *ec)
0399 {
0400     if (!test_bit(EC_FLAGS_EVENTS_MASKED, &ec->flags)) {
0401         if (ec->gpe >= 0)
0402             acpi_ec_disable_gpe(ec, false);
0403         else
0404             disable_irq_nosync(ec->irq);
0405 
0406         ec_dbg_drv("Polling enabled");
0407         set_bit(EC_FLAGS_EVENTS_MASKED, &ec->flags);
0408     }
0409 }
0410 
0411 static void acpi_ec_unmask_events(struct acpi_ec *ec)
0412 {
0413     if (test_bit(EC_FLAGS_EVENTS_MASKED, &ec->flags)) {
0414         clear_bit(EC_FLAGS_EVENTS_MASKED, &ec->flags);
0415         if (ec->gpe >= 0)
0416             acpi_ec_enable_gpe(ec, false);
0417         else
0418             enable_irq(ec->irq);
0419 
0420         ec_dbg_drv("Polling disabled");
0421     }
0422 }
0423 
0424 /*
0425  * acpi_ec_submit_flushable_request() - Increase the reference count unless
0426  *                                      the flush operation is not in
0427  *                                      progress
0428  * @ec: the EC device
0429  *
0430  * This function must be used before taking a new action that should hold
0431  * the reference count.  If this function returns false, then the action
0432  * must be discarded or it will prevent the flush operation from being
0433  * completed.
0434  */
0435 static bool acpi_ec_submit_flushable_request(struct acpi_ec *ec)
0436 {
0437     if (!acpi_ec_started(ec))
0438         return false;
0439     acpi_ec_submit_request(ec);
0440     return true;
0441 }
0442 
0443 static void acpi_ec_submit_event(struct acpi_ec *ec)
0444 {
0445     /*
0446      * It is safe to mask the events here, because acpi_ec_close_event()
0447      * will run at least once after this.
0448      */
0449     acpi_ec_mask_events(ec);
0450     if (!acpi_ec_event_enabled(ec))
0451         return;
0452 
0453     if (ec->event_state != EC_EVENT_READY)
0454         return;
0455 
0456     ec_dbg_evt("Command(%s) submitted/blocked",
0457            acpi_ec_cmd_string(ACPI_EC_COMMAND_QUERY));
0458 
0459     ec->event_state = EC_EVENT_IN_PROGRESS;
0460     /*
0461      * If events_to_process is greater than 0 at this point, the while ()
0462      * loop in acpi_ec_event_handler() is still running and incrementing
0463      * events_to_process will cause it to invoke acpi_ec_submit_query() once
0464      * more, so it is not necessary to queue up the event work to start the
0465      * same loop again.
0466      */
0467     if (ec->events_to_process++ > 0)
0468         return;
0469 
0470     ec->events_in_progress++;
0471     queue_work(ec_wq, &ec->work);
0472 }
0473 
0474 static void acpi_ec_complete_event(struct acpi_ec *ec)
0475 {
0476     if (ec->event_state == EC_EVENT_IN_PROGRESS)
0477         ec->event_state = EC_EVENT_COMPLETE;
0478 }
0479 
0480 static void acpi_ec_close_event(struct acpi_ec *ec)
0481 {
0482     if (ec->event_state != EC_EVENT_READY)
0483         ec_dbg_evt("Command(%s) unblocked",
0484                acpi_ec_cmd_string(ACPI_EC_COMMAND_QUERY));
0485 
0486     ec->event_state = EC_EVENT_READY;
0487     acpi_ec_unmask_events(ec);
0488 }
0489 
0490 static inline void __acpi_ec_enable_event(struct acpi_ec *ec)
0491 {
0492     if (!test_and_set_bit(EC_FLAGS_QUERY_ENABLED, &ec->flags))
0493         ec_log_drv("event unblocked");
0494     /*
0495      * Unconditionally invoke this once after enabling the event
0496      * handling mechanism to detect the pending events.
0497      */
0498     advance_transaction(ec, false);
0499 }
0500 
0501 static inline void __acpi_ec_disable_event(struct acpi_ec *ec)
0502 {
0503     if (test_and_clear_bit(EC_FLAGS_QUERY_ENABLED, &ec->flags))
0504         ec_log_drv("event blocked");
0505 }
0506 
0507 /*
0508  * Process _Q events that might have accumulated in the EC.
0509  * Run with locked ec mutex.
0510  */
0511 static void acpi_ec_clear(struct acpi_ec *ec)
0512 {
0513     int i;
0514 
0515     for (i = 0; i < ACPI_EC_CLEAR_MAX; i++) {
0516         if (acpi_ec_submit_query(ec))
0517             break;
0518     }
0519     if (unlikely(i == ACPI_EC_CLEAR_MAX))
0520         pr_warn("Warning: Maximum of %d stale EC events cleared\n", i);
0521     else
0522         pr_info("%d stale EC events cleared\n", i);
0523 }
0524 
0525 static void acpi_ec_enable_event(struct acpi_ec *ec)
0526 {
0527     unsigned long flags;
0528 
0529     spin_lock_irqsave(&ec->lock, flags);
0530     if (acpi_ec_started(ec))
0531         __acpi_ec_enable_event(ec);
0532     spin_unlock_irqrestore(&ec->lock, flags);
0533 
0534     /* Drain additional events if hardware requires that */
0535     if (EC_FLAGS_CLEAR_ON_RESUME)
0536         acpi_ec_clear(ec);
0537 }
0538 
0539 #ifdef CONFIG_PM_SLEEP
0540 static void __acpi_ec_flush_work(void)
0541 {
0542     flush_workqueue(ec_wq); /* flush ec->work */
0543     flush_workqueue(ec_query_wq); /* flush queries */
0544 }
0545 
0546 static void acpi_ec_disable_event(struct acpi_ec *ec)
0547 {
0548     unsigned long flags;
0549 
0550     spin_lock_irqsave(&ec->lock, flags);
0551     __acpi_ec_disable_event(ec);
0552     spin_unlock_irqrestore(&ec->lock, flags);
0553 
0554     /*
0555      * When ec_freeze_events is true, we need to flush events in
0556      * the proper position before entering the noirq stage.
0557      */
0558     __acpi_ec_flush_work();
0559 }
0560 
0561 void acpi_ec_flush_work(void)
0562 {
0563     /* Without ec_wq there is nothing to flush. */
0564     if (!ec_wq)
0565         return;
0566 
0567     __acpi_ec_flush_work();
0568 }
0569 #endif /* CONFIG_PM_SLEEP */
0570 
0571 static bool acpi_ec_guard_event(struct acpi_ec *ec)
0572 {
0573     unsigned long flags;
0574     bool guarded;
0575 
0576     spin_lock_irqsave(&ec->lock, flags);
0577     /*
0578      * If firmware SCI_EVT clearing timing is "event", we actually
0579      * don't know when the SCI_EVT will be cleared by firmware after
0580      * evaluating _Qxx, so we need to re-check SCI_EVT after waiting an
0581      * acceptable period.
0582      *
0583      * The guarding period is applicable if the event state is not
0584      * EC_EVENT_READY, but otherwise if the current transaction is of the
0585      * ACPI_EC_COMMAND_QUERY type, the guarding should have elapsed already
0586      * and it should not be applied to let the transaction transition into
0587      * the ACPI_EC_COMMAND_POLL state immediately.
0588      */
0589     guarded = ec_event_clearing == ACPI_EC_EVT_TIMING_EVENT &&
0590         ec->event_state != EC_EVENT_READY &&
0591         (!ec->curr || ec->curr->command != ACPI_EC_COMMAND_QUERY);
0592     spin_unlock_irqrestore(&ec->lock, flags);
0593     return guarded;
0594 }
0595 
0596 static int ec_transaction_polled(struct acpi_ec *ec)
0597 {
0598     unsigned long flags;
0599     int ret = 0;
0600 
0601     spin_lock_irqsave(&ec->lock, flags);
0602     if (ec->curr && (ec->curr->flags & ACPI_EC_COMMAND_POLL))
0603         ret = 1;
0604     spin_unlock_irqrestore(&ec->lock, flags);
0605     return ret;
0606 }
0607 
0608 static int ec_transaction_completed(struct acpi_ec *ec)
0609 {
0610     unsigned long flags;
0611     int ret = 0;
0612 
0613     spin_lock_irqsave(&ec->lock, flags);
0614     if (ec->curr && (ec->curr->flags & ACPI_EC_COMMAND_COMPLETE))
0615         ret = 1;
0616     spin_unlock_irqrestore(&ec->lock, flags);
0617     return ret;
0618 }
0619 
0620 static inline void ec_transaction_transition(struct acpi_ec *ec, unsigned long flag)
0621 {
0622     ec->curr->flags |= flag;
0623 
0624     if (ec->curr->command != ACPI_EC_COMMAND_QUERY)
0625         return;
0626 
0627     switch (ec_event_clearing) {
0628     case ACPI_EC_EVT_TIMING_STATUS:
0629         if (flag == ACPI_EC_COMMAND_POLL)
0630             acpi_ec_close_event(ec);
0631 
0632         return;
0633 
0634     case ACPI_EC_EVT_TIMING_QUERY:
0635         if (flag == ACPI_EC_COMMAND_COMPLETE)
0636             acpi_ec_close_event(ec);
0637 
0638         return;
0639 
0640     case ACPI_EC_EVT_TIMING_EVENT:
0641         if (flag == ACPI_EC_COMMAND_COMPLETE)
0642             acpi_ec_complete_event(ec);
0643     }
0644 }
0645 
0646 static void acpi_ec_spurious_interrupt(struct acpi_ec *ec, struct transaction *t)
0647 {
0648     if (t->irq_count < ec_storm_threshold)
0649         ++t->irq_count;
0650 
0651     /* Trigger if the threshold is 0 too. */
0652     if (t->irq_count == ec_storm_threshold)
0653         acpi_ec_mask_events(ec);
0654 }
0655 
0656 static void advance_transaction(struct acpi_ec *ec, bool interrupt)
0657 {
0658     struct transaction *t = ec->curr;
0659     bool wakeup = false;
0660     u8 status;
0661 
0662     ec_dbg_stm("%s (%d)", interrupt ? "IRQ" : "TASK", smp_processor_id());
0663 
0664     /*
0665      * Clear GPE_STS upfront to allow subsequent hardware GPE_STS 0->1
0666      * changes to always trigger a GPE interrupt.
0667      *
0668      * GPE STS is a W1C register, which means:
0669      *
0670      * 1. Software can clear it without worrying about clearing the other
0671      *    GPEs' STS bits when the hardware sets them in parallel.
0672      *
0673      * 2. As long as software can ensure only clearing it when it is set,
0674      *    hardware won't set it in parallel.
0675      */
0676     if (ec->gpe >= 0 && acpi_ec_gpe_status_set(ec))
0677         acpi_clear_gpe(NULL, ec->gpe);
0678 
0679     status = acpi_ec_read_status(ec);
0680 
0681     /*
0682      * Another IRQ or a guarded polling mode advancement is detected,
0683      * the next QR_EC submission is then allowed.
0684      */
0685     if (!t || !(t->flags & ACPI_EC_COMMAND_POLL)) {
0686         if (ec_event_clearing == ACPI_EC_EVT_TIMING_EVENT &&
0687             ec->event_state == EC_EVENT_COMPLETE)
0688             acpi_ec_close_event(ec);
0689 
0690         if (!t)
0691             goto out;
0692     }
0693 
0694     if (t->flags & ACPI_EC_COMMAND_POLL) {
0695         if (t->wlen > t->wi) {
0696             if (!(status & ACPI_EC_FLAG_IBF))
0697                 acpi_ec_write_data(ec, t->wdata[t->wi++]);
0698             else if (interrupt && !(status & ACPI_EC_FLAG_SCI))
0699                 acpi_ec_spurious_interrupt(ec, t);
0700         } else if (t->rlen > t->ri) {
0701             if (status & ACPI_EC_FLAG_OBF) {
0702                 t->rdata[t->ri++] = acpi_ec_read_data(ec);
0703                 if (t->rlen == t->ri) {
0704                     ec_transaction_transition(ec, ACPI_EC_COMMAND_COMPLETE);
0705                     wakeup = true;
0706                     if (t->command == ACPI_EC_COMMAND_QUERY)
0707                         ec_dbg_evt("Command(%s) completed by hardware",
0708                                acpi_ec_cmd_string(ACPI_EC_COMMAND_QUERY));
0709                 }
0710             } else if (interrupt && !(status & ACPI_EC_FLAG_SCI)) {
0711                 acpi_ec_spurious_interrupt(ec, t);
0712             }
0713         } else if (t->wlen == t->wi && !(status & ACPI_EC_FLAG_IBF)) {
0714             ec_transaction_transition(ec, ACPI_EC_COMMAND_COMPLETE);
0715             wakeup = true;
0716         }
0717     } else if (!(status & ACPI_EC_FLAG_IBF)) {
0718         acpi_ec_write_cmd(ec, t->command);
0719         ec_transaction_transition(ec, ACPI_EC_COMMAND_POLL);
0720     }
0721 
0722 out:
0723     if (status & ACPI_EC_FLAG_SCI)
0724         acpi_ec_submit_event(ec);
0725 
0726     if (wakeup && interrupt)
0727         wake_up(&ec->wait);
0728 }
0729 
0730 static void start_transaction(struct acpi_ec *ec)
0731 {
0732     ec->curr->irq_count = ec->curr->wi = ec->curr->ri = 0;
0733     ec->curr->flags = 0;
0734 }
0735 
0736 static int ec_guard(struct acpi_ec *ec)
0737 {
0738     unsigned long guard = usecs_to_jiffies(ec->polling_guard);
0739     unsigned long timeout = ec->timestamp + guard;
0740 
0741     /* Ensure guarding period before polling EC status */
0742     do {
0743         if (ec->busy_polling) {
0744             /* Perform busy polling */
0745             if (ec_transaction_completed(ec))
0746                 return 0;
0747             udelay(jiffies_to_usecs(guard));
0748         } else {
0749             /*
0750              * Perform wait polling
0751              * 1. Wait the transaction to be completed by the
0752              *    GPE handler after the transaction enters
0753              *    ACPI_EC_COMMAND_POLL state.
0754              * 2. A special guarding logic is also required
0755              *    for event clearing mode "event" before the
0756              *    transaction enters ACPI_EC_COMMAND_POLL
0757              *    state.
0758              */
0759             if (!ec_transaction_polled(ec) &&
0760                 !acpi_ec_guard_event(ec))
0761                 break;
0762             if (wait_event_timeout(ec->wait,
0763                            ec_transaction_completed(ec),
0764                            guard))
0765                 return 0;
0766         }
0767     } while (time_before(jiffies, timeout));
0768     return -ETIME;
0769 }
0770 
0771 static int ec_poll(struct acpi_ec *ec)
0772 {
0773     unsigned long flags;
0774     int repeat = 5; /* number of command restarts */
0775 
0776     while (repeat--) {
0777         unsigned long delay = jiffies +
0778             msecs_to_jiffies(ec_delay);
0779         do {
0780             if (!ec_guard(ec))
0781                 return 0;
0782             spin_lock_irqsave(&ec->lock, flags);
0783             advance_transaction(ec, false);
0784             spin_unlock_irqrestore(&ec->lock, flags);
0785         } while (time_before(jiffies, delay));
0786         pr_debug("controller reset, restart transaction\n");
0787         spin_lock_irqsave(&ec->lock, flags);
0788         start_transaction(ec);
0789         spin_unlock_irqrestore(&ec->lock, flags);
0790     }
0791     return -ETIME;
0792 }
0793 
0794 static int acpi_ec_transaction_unlocked(struct acpi_ec *ec,
0795                     struct transaction *t)
0796 {
0797     unsigned long tmp;
0798     int ret = 0;
0799 
0800     /* start transaction */
0801     spin_lock_irqsave(&ec->lock, tmp);
0802     /* Enable GPE for command processing (IBF=0/OBF=1) */
0803     if (!acpi_ec_submit_flushable_request(ec)) {
0804         ret = -EINVAL;
0805         goto unlock;
0806     }
0807     ec_dbg_ref(ec, "Increase command");
0808     /* following two actions should be kept atomic */
0809     ec->curr = t;
0810     ec_dbg_req("Command(%s) started", acpi_ec_cmd_string(t->command));
0811     start_transaction(ec);
0812     spin_unlock_irqrestore(&ec->lock, tmp);
0813 
0814     ret = ec_poll(ec);
0815 
0816     spin_lock_irqsave(&ec->lock, tmp);
0817     if (t->irq_count == ec_storm_threshold)
0818         acpi_ec_unmask_events(ec);
0819     ec_dbg_req("Command(%s) stopped", acpi_ec_cmd_string(t->command));
0820     ec->curr = NULL;
0821     /* Disable GPE for command processing (IBF=0/OBF=1) */
0822     acpi_ec_complete_request(ec);
0823     ec_dbg_ref(ec, "Decrease command");
0824 unlock:
0825     spin_unlock_irqrestore(&ec->lock, tmp);
0826     return ret;
0827 }
0828 
0829 static int acpi_ec_transaction(struct acpi_ec *ec, struct transaction *t)
0830 {
0831     int status;
0832     u32 glk;
0833 
0834     if (!ec || (!t) || (t->wlen && !t->wdata) || (t->rlen && !t->rdata))
0835         return -EINVAL;
0836     if (t->rdata)
0837         memset(t->rdata, 0, t->rlen);
0838 
0839     mutex_lock(&ec->mutex);
0840     if (ec->global_lock) {
0841         status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
0842         if (ACPI_FAILURE(status)) {
0843             status = -ENODEV;
0844             goto unlock;
0845         }
0846     }
0847 
0848     status = acpi_ec_transaction_unlocked(ec, t);
0849 
0850     if (ec->global_lock)
0851         acpi_release_global_lock(glk);
0852 unlock:
0853     mutex_unlock(&ec->mutex);
0854     return status;
0855 }
0856 
0857 static int acpi_ec_burst_enable(struct acpi_ec *ec)
0858 {
0859     u8 d;
0860     struct transaction t = {.command = ACPI_EC_BURST_ENABLE,
0861                 .wdata = NULL, .rdata = &d,
0862                 .wlen = 0, .rlen = 1};
0863 
0864     return acpi_ec_transaction(ec, &t);
0865 }
0866 
0867 static int acpi_ec_burst_disable(struct acpi_ec *ec)
0868 {
0869     struct transaction t = {.command = ACPI_EC_BURST_DISABLE,
0870                 .wdata = NULL, .rdata = NULL,
0871                 .wlen = 0, .rlen = 0};
0872 
0873     return (acpi_ec_read_status(ec) & ACPI_EC_FLAG_BURST) ?
0874                 acpi_ec_transaction(ec, &t) : 0;
0875 }
0876 
0877 static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 *data)
0878 {
0879     int result;
0880     u8 d;
0881     struct transaction t = {.command = ACPI_EC_COMMAND_READ,
0882                 .wdata = &address, .rdata = &d,
0883                 .wlen = 1, .rlen = 1};
0884 
0885     result = acpi_ec_transaction(ec, &t);
0886     *data = d;
0887     return result;
0888 }
0889 
0890 static int acpi_ec_write(struct acpi_ec *ec, u8 address, u8 data)
0891 {
0892     u8 wdata[2] = { address, data };
0893     struct transaction t = {.command = ACPI_EC_COMMAND_WRITE,
0894                 .wdata = wdata, .rdata = NULL,
0895                 .wlen = 2, .rlen = 0};
0896 
0897     return acpi_ec_transaction(ec, &t);
0898 }
0899 
0900 int ec_read(u8 addr, u8 *val)
0901 {
0902     int err;
0903     u8 temp_data;
0904 
0905     if (!first_ec)
0906         return -ENODEV;
0907 
0908     err = acpi_ec_read(first_ec, addr, &temp_data);
0909 
0910     if (!err) {
0911         *val = temp_data;
0912         return 0;
0913     }
0914     return err;
0915 }
0916 EXPORT_SYMBOL(ec_read);
0917 
0918 int ec_write(u8 addr, u8 val)
0919 {
0920     int err;
0921 
0922     if (!first_ec)
0923         return -ENODEV;
0924 
0925     err = acpi_ec_write(first_ec, addr, val);
0926 
0927     return err;
0928 }
0929 EXPORT_SYMBOL(ec_write);
0930 
0931 int ec_transaction(u8 command,
0932            const u8 *wdata, unsigned wdata_len,
0933            u8 *rdata, unsigned rdata_len)
0934 {
0935     struct transaction t = {.command = command,
0936                 .wdata = wdata, .rdata = rdata,
0937                 .wlen = wdata_len, .rlen = rdata_len};
0938 
0939     if (!first_ec)
0940         return -ENODEV;
0941 
0942     return acpi_ec_transaction(first_ec, &t);
0943 }
0944 EXPORT_SYMBOL(ec_transaction);
0945 
0946 /* Get the handle to the EC device */
0947 acpi_handle ec_get_handle(void)
0948 {
0949     if (!first_ec)
0950         return NULL;
0951     return first_ec->handle;
0952 }
0953 EXPORT_SYMBOL(ec_get_handle);
0954 
0955 static void acpi_ec_start(struct acpi_ec *ec, bool resuming)
0956 {
0957     unsigned long flags;
0958 
0959     spin_lock_irqsave(&ec->lock, flags);
0960     if (!test_and_set_bit(EC_FLAGS_STARTED, &ec->flags)) {
0961         ec_dbg_drv("Starting EC");
0962         /* Enable GPE for event processing (SCI_EVT=1) */
0963         if (!resuming) {
0964             acpi_ec_submit_request(ec);
0965             ec_dbg_ref(ec, "Increase driver");
0966         }
0967         ec_log_drv("EC started");
0968     }
0969     spin_unlock_irqrestore(&ec->lock, flags);
0970 }
0971 
0972 static bool acpi_ec_stopped(struct acpi_ec *ec)
0973 {
0974     unsigned long flags;
0975     bool flushed;
0976 
0977     spin_lock_irqsave(&ec->lock, flags);
0978     flushed = acpi_ec_flushed(ec);
0979     spin_unlock_irqrestore(&ec->lock, flags);
0980     return flushed;
0981 }
0982 
0983 static void acpi_ec_stop(struct acpi_ec *ec, bool suspending)
0984 {
0985     unsigned long flags;
0986 
0987     spin_lock_irqsave(&ec->lock, flags);
0988     if (acpi_ec_started(ec)) {
0989         ec_dbg_drv("Stopping EC");
0990         set_bit(EC_FLAGS_STOPPED, &ec->flags);
0991         spin_unlock_irqrestore(&ec->lock, flags);
0992         wait_event(ec->wait, acpi_ec_stopped(ec));
0993         spin_lock_irqsave(&ec->lock, flags);
0994         /* Disable GPE for event processing (SCI_EVT=1) */
0995         if (!suspending) {
0996             acpi_ec_complete_request(ec);
0997             ec_dbg_ref(ec, "Decrease driver");
0998         } else if (!ec_freeze_events)
0999             __acpi_ec_disable_event(ec);
1000         clear_bit(EC_FLAGS_STARTED, &ec->flags);
1001         clear_bit(EC_FLAGS_STOPPED, &ec->flags);
1002         ec_log_drv("EC stopped");
1003     }
1004     spin_unlock_irqrestore(&ec->lock, flags);
1005 }
1006 
1007 static void acpi_ec_enter_noirq(struct acpi_ec *ec)
1008 {
1009     unsigned long flags;
1010 
1011     spin_lock_irqsave(&ec->lock, flags);
1012     ec->busy_polling = true;
1013     ec->polling_guard = 0;
1014     ec_log_drv("interrupt blocked");
1015     spin_unlock_irqrestore(&ec->lock, flags);
1016 }
1017 
1018 static void acpi_ec_leave_noirq(struct acpi_ec *ec)
1019 {
1020     unsigned long flags;
1021 
1022     spin_lock_irqsave(&ec->lock, flags);
1023     ec->busy_polling = ec_busy_polling;
1024     ec->polling_guard = ec_polling_guard;
1025     ec_log_drv("interrupt unblocked");
1026     spin_unlock_irqrestore(&ec->lock, flags);
1027 }
1028 
1029 void acpi_ec_block_transactions(void)
1030 {
1031     struct acpi_ec *ec = first_ec;
1032 
1033     if (!ec)
1034         return;
1035 
1036     mutex_lock(&ec->mutex);
1037     /* Prevent transactions from being carried out */
1038     acpi_ec_stop(ec, true);
1039     mutex_unlock(&ec->mutex);
1040 }
1041 
1042 void acpi_ec_unblock_transactions(void)
1043 {
1044     /*
1045      * Allow transactions to happen again (this function is called from
1046      * atomic context during wakeup, so we don't need to acquire the mutex).
1047      */
1048     if (first_ec)
1049         acpi_ec_start(first_ec, true);
1050 }
1051 
1052 /* --------------------------------------------------------------------------
1053                                 Event Management
1054    -------------------------------------------------------------------------- */
1055 static struct acpi_ec_query_handler *
1056 acpi_ec_get_query_handler_by_value(struct acpi_ec *ec, u8 value)
1057 {
1058     struct acpi_ec_query_handler *handler;
1059 
1060     mutex_lock(&ec->mutex);
1061     list_for_each_entry(handler, &ec->list, node) {
1062         if (value == handler->query_bit) {
1063             kref_get(&handler->kref);
1064             mutex_unlock(&ec->mutex);
1065             return handler;
1066         }
1067     }
1068     mutex_unlock(&ec->mutex);
1069     return NULL;
1070 }
1071 
1072 static void acpi_ec_query_handler_release(struct kref *kref)
1073 {
1074     struct acpi_ec_query_handler *handler =
1075         container_of(kref, struct acpi_ec_query_handler, kref);
1076 
1077     kfree(handler);
1078 }
1079 
1080 static void acpi_ec_put_query_handler(struct acpi_ec_query_handler *handler)
1081 {
1082     kref_put(&handler->kref, acpi_ec_query_handler_release);
1083 }
1084 
1085 int acpi_ec_add_query_handler(struct acpi_ec *ec, u8 query_bit,
1086                   acpi_handle handle, acpi_ec_query_func func,
1087                   void *data)
1088 {
1089     struct acpi_ec_query_handler *handler =
1090         kzalloc(sizeof(struct acpi_ec_query_handler), GFP_KERNEL);
1091 
1092     if (!handler)
1093         return -ENOMEM;
1094 
1095     handler->query_bit = query_bit;
1096     handler->handle = handle;
1097     handler->func = func;
1098     handler->data = data;
1099     mutex_lock(&ec->mutex);
1100     kref_init(&handler->kref);
1101     list_add(&handler->node, &ec->list);
1102     mutex_unlock(&ec->mutex);
1103     return 0;
1104 }
1105 EXPORT_SYMBOL_GPL(acpi_ec_add_query_handler);
1106 
1107 static void acpi_ec_remove_query_handlers(struct acpi_ec *ec,
1108                       bool remove_all, u8 query_bit)
1109 {
1110     struct acpi_ec_query_handler *handler, *tmp;
1111     LIST_HEAD(free_list);
1112 
1113     mutex_lock(&ec->mutex);
1114     list_for_each_entry_safe(handler, tmp, &ec->list, node) {
1115         if (remove_all || query_bit == handler->query_bit) {
1116             list_del_init(&handler->node);
1117             list_add(&handler->node, &free_list);
1118         }
1119     }
1120     mutex_unlock(&ec->mutex);
1121     list_for_each_entry_safe(handler, tmp, &free_list, node)
1122         acpi_ec_put_query_handler(handler);
1123 }
1124 
1125 void acpi_ec_remove_query_handler(struct acpi_ec *ec, u8 query_bit)
1126 {
1127     acpi_ec_remove_query_handlers(ec, false, query_bit);
1128 }
1129 EXPORT_SYMBOL_GPL(acpi_ec_remove_query_handler);
1130 
1131 static void acpi_ec_event_processor(struct work_struct *work)
1132 {
1133     struct acpi_ec_query *q = container_of(work, struct acpi_ec_query, work);
1134     struct acpi_ec_query_handler *handler = q->handler;
1135     struct acpi_ec *ec = q->ec;
1136 
1137     ec_dbg_evt("Query(0x%02x) started", handler->query_bit);
1138 
1139     if (handler->func)
1140         handler->func(handler->data);
1141     else if (handler->handle)
1142         acpi_evaluate_object(handler->handle, NULL, NULL, NULL);
1143 
1144     ec_dbg_evt("Query(0x%02x) stopped", handler->query_bit);
1145 
1146     spin_lock_irq(&ec->lock);
1147     ec->queries_in_progress--;
1148     spin_unlock_irq(&ec->lock);
1149 
1150     acpi_ec_put_query_handler(handler);
1151     kfree(q);
1152 }
1153 
1154 static struct acpi_ec_query *acpi_ec_create_query(struct acpi_ec *ec, u8 *pval)
1155 {
1156     struct acpi_ec_query *q;
1157     struct transaction *t;
1158 
1159     q = kzalloc(sizeof (struct acpi_ec_query), GFP_KERNEL);
1160     if (!q)
1161         return NULL;
1162 
1163     INIT_WORK(&q->work, acpi_ec_event_processor);
1164     t = &q->transaction;
1165     t->command = ACPI_EC_COMMAND_QUERY;
1166     t->rdata = pval;
1167     t->rlen = 1;
1168     q->ec = ec;
1169     return q;
1170 }
1171 
1172 static int acpi_ec_submit_query(struct acpi_ec *ec)
1173 {
1174     struct acpi_ec_query *q;
1175     u8 value = 0;
1176     int result;
1177 
1178     q = acpi_ec_create_query(ec, &value);
1179     if (!q)
1180         return -ENOMEM;
1181 
1182     /*
1183      * Query the EC to find out which _Qxx method we need to evaluate.
1184      * Note that successful completion of the query causes the ACPI_EC_SCI
1185      * bit to be cleared (and thus clearing the interrupt source).
1186      */
1187     result = acpi_ec_transaction(ec, &q->transaction);
1188     if (result)
1189         goto err_exit;
1190 
1191     if (!value) {
1192         result = -ENODATA;
1193         goto err_exit;
1194     }
1195 
1196     q->handler = acpi_ec_get_query_handler_by_value(ec, value);
1197     if (!q->handler) {
1198         result = -ENODATA;
1199         goto err_exit;
1200     }
1201 
1202     /*
1203      * It is reported that _Qxx are evaluated in a parallel way on Windows:
1204      * https://bugzilla.kernel.org/show_bug.cgi?id=94411
1205      *
1206      * Put this log entry before queue_work() to make it appear in the log
1207      * before any other messages emitted during workqueue handling.
1208      */
1209     ec_dbg_evt("Query(0x%02x) scheduled", value);
1210 
1211     spin_lock_irq(&ec->lock);
1212 
1213     ec->queries_in_progress++;
1214     queue_work(ec_query_wq, &q->work);
1215 
1216     spin_unlock_irq(&ec->lock);
1217 
1218     return 0;
1219 
1220 err_exit:
1221     kfree(q);
1222 
1223     return result;
1224 }
1225 
1226 static void acpi_ec_event_handler(struct work_struct *work)
1227 {
1228     struct acpi_ec *ec = container_of(work, struct acpi_ec, work);
1229 
1230     ec_dbg_evt("Event started");
1231 
1232     spin_lock_irq(&ec->lock);
1233 
1234     while (ec->events_to_process) {
1235         spin_unlock_irq(&ec->lock);
1236 
1237         acpi_ec_submit_query(ec);
1238 
1239         spin_lock_irq(&ec->lock);
1240 
1241         ec->events_to_process--;
1242     }
1243 
1244     /*
1245      * Before exit, make sure that the it will be possible to queue up the
1246      * event handling work again regardless of whether or not the query
1247      * queued up above is processed successfully.
1248      */
1249     if (ec_event_clearing == ACPI_EC_EVT_TIMING_EVENT) {
1250         bool guard_timeout;
1251 
1252         acpi_ec_complete_event(ec);
1253 
1254         ec_dbg_evt("Event stopped");
1255 
1256         spin_unlock_irq(&ec->lock);
1257 
1258         guard_timeout = !!ec_guard(ec);
1259 
1260         spin_lock_irq(&ec->lock);
1261 
1262         /* Take care of SCI_EVT unless someone else is doing that. */
1263         if (guard_timeout && !ec->curr)
1264             advance_transaction(ec, false);
1265     } else {
1266         acpi_ec_close_event(ec);
1267 
1268         ec_dbg_evt("Event stopped");
1269     }
1270 
1271     ec->events_in_progress--;
1272 
1273     spin_unlock_irq(&ec->lock);
1274 }
1275 
1276 static void acpi_ec_handle_interrupt(struct acpi_ec *ec)
1277 {
1278     unsigned long flags;
1279 
1280     spin_lock_irqsave(&ec->lock, flags);
1281     advance_transaction(ec, true);
1282     spin_unlock_irqrestore(&ec->lock, flags);
1283 }
1284 
1285 static u32 acpi_ec_gpe_handler(acpi_handle gpe_device,
1286                    u32 gpe_number, void *data)
1287 {
1288     acpi_ec_handle_interrupt(data);
1289     return ACPI_INTERRUPT_HANDLED;
1290 }
1291 
1292 static irqreturn_t acpi_ec_irq_handler(int irq, void *data)
1293 {
1294     acpi_ec_handle_interrupt(data);
1295     return IRQ_HANDLED;
1296 }
1297 
1298 /* --------------------------------------------------------------------------
1299  *                           Address Space Management
1300  * -------------------------------------------------------------------------- */
1301 
1302 static acpi_status
1303 acpi_ec_space_handler(u32 function, acpi_physical_address address,
1304               u32 bits, u64 *value64,
1305               void *handler_context, void *region_context)
1306 {
1307     struct acpi_ec *ec = handler_context;
1308     int result = 0, i, bytes = bits / 8;
1309     u8 *value = (u8 *)value64;
1310 
1311     if ((address > 0xFF) || !value || !handler_context)
1312         return AE_BAD_PARAMETER;
1313 
1314     if (function != ACPI_READ && function != ACPI_WRITE)
1315         return AE_BAD_PARAMETER;
1316 
1317     if (ec->busy_polling || bits > 8)
1318         acpi_ec_burst_enable(ec);
1319 
1320     for (i = 0; i < bytes; ++i, ++address, ++value)
1321         result = (function == ACPI_READ) ?
1322             acpi_ec_read(ec, address, value) :
1323             acpi_ec_write(ec, address, *value);
1324 
1325     if (ec->busy_polling || bits > 8)
1326         acpi_ec_burst_disable(ec);
1327 
1328     switch (result) {
1329     case -EINVAL:
1330         return AE_BAD_PARAMETER;
1331     case -ENODEV:
1332         return AE_NOT_FOUND;
1333     case -ETIME:
1334         return AE_TIME;
1335     default:
1336         return AE_OK;
1337     }
1338 }
1339 
1340 /* --------------------------------------------------------------------------
1341  *                             Driver Interface
1342  * -------------------------------------------------------------------------- */
1343 
1344 static acpi_status
1345 ec_parse_io_ports(struct acpi_resource *resource, void *context);
1346 
1347 static void acpi_ec_free(struct acpi_ec *ec)
1348 {
1349     if (first_ec == ec)
1350         first_ec = NULL;
1351     if (boot_ec == ec)
1352         boot_ec = NULL;
1353     kfree(ec);
1354 }
1355 
1356 static struct acpi_ec *acpi_ec_alloc(void)
1357 {
1358     struct acpi_ec *ec = kzalloc(sizeof(struct acpi_ec), GFP_KERNEL);
1359 
1360     if (!ec)
1361         return NULL;
1362     mutex_init(&ec->mutex);
1363     init_waitqueue_head(&ec->wait);
1364     INIT_LIST_HEAD(&ec->list);
1365     spin_lock_init(&ec->lock);
1366     INIT_WORK(&ec->work, acpi_ec_event_handler);
1367     ec->timestamp = jiffies;
1368     ec->busy_polling = true;
1369     ec->polling_guard = 0;
1370     ec->gpe = -1;
1371     ec->irq = -1;
1372     return ec;
1373 }
1374 
1375 static acpi_status
1376 acpi_ec_register_query_methods(acpi_handle handle, u32 level,
1377                    void *context, void **return_value)
1378 {
1379     char node_name[5];
1380     struct acpi_buffer buffer = { sizeof(node_name), node_name };
1381     struct acpi_ec *ec = context;
1382     int value = 0;
1383     acpi_status status;
1384 
1385     status = acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer);
1386 
1387     if (ACPI_SUCCESS(status) && sscanf(node_name, "_Q%x", &value) == 1)
1388         acpi_ec_add_query_handler(ec, value, handle, NULL, NULL);
1389     return AE_OK;
1390 }
1391 
1392 static acpi_status
1393 ec_parse_device(acpi_handle handle, u32 Level, void *context, void **retval)
1394 {
1395     acpi_status status;
1396     unsigned long long tmp = 0;
1397     struct acpi_ec *ec = context;
1398 
1399     /* clear addr values, ec_parse_io_ports depend on it */
1400     ec->command_addr = ec->data_addr = 0;
1401 
1402     status = acpi_walk_resources(handle, METHOD_NAME__CRS,
1403                      ec_parse_io_ports, ec);
1404     if (ACPI_FAILURE(status))
1405         return status;
1406     if (ec->data_addr == 0 || ec->command_addr == 0)
1407         return AE_OK;
1408 
1409     /* Get GPE bit assignment (EC events). */
1410     /* TODO: Add support for _GPE returning a package */
1411     status = acpi_evaluate_integer(handle, "_GPE", NULL, &tmp);
1412     if (ACPI_SUCCESS(status))
1413         ec->gpe = tmp;
1414     /*
1415      * Errors are non-fatal, allowing for ACPI Reduced Hardware
1416      * platforms which use GpioInt instead of GPE.
1417      */
1418 
1419     /* Use the global lock for all EC transactions? */
1420     tmp = 0;
1421     acpi_evaluate_integer(handle, "_GLK", NULL, &tmp);
1422     ec->global_lock = tmp;
1423     ec->handle = handle;
1424     return AE_CTRL_TERMINATE;
1425 }
1426 
1427 static bool install_gpe_event_handler(struct acpi_ec *ec)
1428 {
1429     acpi_status status;
1430 
1431     status = acpi_install_gpe_raw_handler(NULL, ec->gpe,
1432                           ACPI_GPE_EDGE_TRIGGERED,
1433                           &acpi_ec_gpe_handler, ec);
1434     if (ACPI_FAILURE(status))
1435         return false;
1436 
1437     if (test_bit(EC_FLAGS_STARTED, &ec->flags) && ec->reference_count >= 1)
1438         acpi_ec_enable_gpe(ec, true);
1439 
1440     return true;
1441 }
1442 
1443 static bool install_gpio_irq_event_handler(struct acpi_ec *ec)
1444 {
1445     return request_irq(ec->irq, acpi_ec_irq_handler, IRQF_SHARED,
1446                "ACPI EC", ec) >= 0;
1447 }
1448 
1449 /**
1450  * ec_install_handlers - Install service callbacks and register query methods.
1451  * @ec: Target EC.
1452  * @device: ACPI device object corresponding to @ec.
1453  *
1454  * Install a handler for the EC address space type unless it has been installed
1455  * already.  If @device is not NULL, also look for EC query methods in the
1456  * namespace and register them, and install an event (either GPE or GPIO IRQ)
1457  * handler for the EC, if possible.
1458  *
1459  * Return:
1460  * -ENODEV if the address space handler cannot be installed, which means
1461  *  "unable to handle transactions",
1462  * -EPROBE_DEFER if GPIO IRQ acquisition needs to be deferred,
1463  * or 0 (success) otherwise.
1464  */
1465 static int ec_install_handlers(struct acpi_ec *ec, struct acpi_device *device)
1466 {
1467     acpi_status status;
1468 
1469     acpi_ec_start(ec, false);
1470 
1471     if (!test_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags)) {
1472         acpi_ec_enter_noirq(ec);
1473         status = acpi_install_address_space_handler(ec->handle,
1474                                 ACPI_ADR_SPACE_EC,
1475                                 &acpi_ec_space_handler,
1476                                 NULL, ec);
1477         if (ACPI_FAILURE(status)) {
1478             acpi_ec_stop(ec, false);
1479             return -ENODEV;
1480         }
1481         set_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags);
1482     }
1483 
1484     if (!device)
1485         return 0;
1486 
1487     if (ec->gpe < 0) {
1488         /* ACPI reduced hardware platforms use a GpioInt from _CRS. */
1489         int irq = acpi_dev_gpio_irq_get(device, 0);
1490         /*
1491          * Bail out right away for deferred probing or complete the
1492          * initialization regardless of any other errors.
1493          */
1494         if (irq == -EPROBE_DEFER)
1495             return -EPROBE_DEFER;
1496         else if (irq >= 0)
1497             ec->irq = irq;
1498     }
1499 
1500     if (!test_bit(EC_FLAGS_QUERY_METHODS_INSTALLED, &ec->flags)) {
1501         /* Find and register all query methods */
1502         acpi_walk_namespace(ACPI_TYPE_METHOD, ec->handle, 1,
1503                     acpi_ec_register_query_methods,
1504                     NULL, ec, NULL);
1505         set_bit(EC_FLAGS_QUERY_METHODS_INSTALLED, &ec->flags);
1506     }
1507     if (!test_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags)) {
1508         bool ready = false;
1509 
1510         if (ec->gpe >= 0)
1511             ready = install_gpe_event_handler(ec);
1512         else if (ec->irq >= 0)
1513             ready = install_gpio_irq_event_handler(ec);
1514 
1515         if (ready) {
1516             set_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags);
1517             acpi_ec_leave_noirq(ec);
1518         }
1519         /*
1520          * Failures to install an event handler are not fatal, because
1521          * the EC can be polled for events.
1522          */
1523     }
1524     /* EC is fully operational, allow queries */
1525     acpi_ec_enable_event(ec);
1526 
1527     return 0;
1528 }
1529 
1530 static void ec_remove_handlers(struct acpi_ec *ec)
1531 {
1532     if (test_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags)) {
1533         if (ACPI_FAILURE(acpi_remove_address_space_handler(ec->handle,
1534                     ACPI_ADR_SPACE_EC, &acpi_ec_space_handler)))
1535             pr_err("failed to remove space handler\n");
1536         clear_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags);
1537     }
1538 
1539     /*
1540      * Stops handling the EC transactions after removing the operation
1541      * region handler. This is required because _REG(DISCONNECT)
1542      * invoked during the removal can result in new EC transactions.
1543      *
1544      * Flushes the EC requests and thus disables the GPE before
1545      * removing the GPE handler. This is required by the current ACPICA
1546      * GPE core. ACPICA GPE core will automatically disable a GPE when
1547      * it is indicated but there is no way to handle it. So the drivers
1548      * must disable the GPEs prior to removing the GPE handlers.
1549      */
1550     acpi_ec_stop(ec, false);
1551 
1552     if (test_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags)) {
1553         if (ec->gpe >= 0 &&
1554             ACPI_FAILURE(acpi_remove_gpe_handler(NULL, ec->gpe,
1555                  &acpi_ec_gpe_handler)))
1556             pr_err("failed to remove gpe handler\n");
1557 
1558         if (ec->irq >= 0)
1559             free_irq(ec->irq, ec);
1560 
1561         clear_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags);
1562     }
1563     if (test_bit(EC_FLAGS_QUERY_METHODS_INSTALLED, &ec->flags)) {
1564         acpi_ec_remove_query_handlers(ec, true, 0);
1565         clear_bit(EC_FLAGS_QUERY_METHODS_INSTALLED, &ec->flags);
1566     }
1567 }
1568 
1569 static int acpi_ec_setup(struct acpi_ec *ec, struct acpi_device *device)
1570 {
1571     int ret;
1572 
1573     ret = ec_install_handlers(ec, device);
1574     if (ret)
1575         return ret;
1576 
1577     /* First EC capable of handling transactions */
1578     if (!first_ec)
1579         first_ec = ec;
1580 
1581     pr_info("EC_CMD/EC_SC=0x%lx, EC_DATA=0x%lx\n", ec->command_addr,
1582         ec->data_addr);
1583 
1584     if (test_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags)) {
1585         if (ec->gpe >= 0)
1586             pr_info("GPE=0x%x\n", ec->gpe);
1587         else
1588             pr_info("IRQ=%d\n", ec->irq);
1589     }
1590 
1591     return ret;
1592 }
1593 
1594 static int acpi_ec_add(struct acpi_device *device)
1595 {
1596     struct acpi_ec *ec;
1597     int ret;
1598 
1599     strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
1600     strcpy(acpi_device_class(device), ACPI_EC_CLASS);
1601 
1602     if (boot_ec && (boot_ec->handle == device->handle ||
1603         !strcmp(acpi_device_hid(device), ACPI_ECDT_HID))) {
1604         /* Fast path: this device corresponds to the boot EC. */
1605         ec = boot_ec;
1606     } else {
1607         acpi_status status;
1608 
1609         ec = acpi_ec_alloc();
1610         if (!ec)
1611             return -ENOMEM;
1612 
1613         status = ec_parse_device(device->handle, 0, ec, NULL);
1614         if (status != AE_CTRL_TERMINATE) {
1615             ret = -EINVAL;
1616             goto err;
1617         }
1618 
1619         if (boot_ec && ec->command_addr == boot_ec->command_addr &&
1620             ec->data_addr == boot_ec->data_addr) {
1621             /*
1622              * Trust PNP0C09 namespace location rather than ECDT ID.
1623              * But trust ECDT GPE rather than _GPE because of ASUS
1624              * quirks. So do not change boot_ec->gpe to ec->gpe,
1625              * except when the TRUST_DSDT_GPE quirk is set.
1626              */
1627             boot_ec->handle = ec->handle;
1628 
1629             if (EC_FLAGS_TRUST_DSDT_GPE)
1630                 boot_ec->gpe = ec->gpe;
1631 
1632             acpi_handle_debug(ec->handle, "duplicated.\n");
1633             acpi_ec_free(ec);
1634             ec = boot_ec;
1635         }
1636     }
1637 
1638     ret = acpi_ec_setup(ec, device);
1639     if (ret)
1640         goto err;
1641 
1642     if (ec == boot_ec)
1643         acpi_handle_info(boot_ec->handle,
1644                  "Boot %s EC initialization complete\n",
1645                  boot_ec_is_ecdt ? "ECDT" : "DSDT");
1646 
1647     acpi_handle_info(ec->handle,
1648              "EC: Used to handle transactions and events\n");
1649 
1650     device->driver_data = ec;
1651 
1652     ret = !!request_region(ec->data_addr, 1, "EC data");
1653     WARN(!ret, "Could not request EC data io port 0x%lx", ec->data_addr);
1654     ret = !!request_region(ec->command_addr, 1, "EC cmd");
1655     WARN(!ret, "Could not request EC cmd io port 0x%lx", ec->command_addr);
1656 
1657     /* Reprobe devices depending on the EC */
1658     acpi_dev_clear_dependencies(device);
1659 
1660     acpi_handle_debug(ec->handle, "enumerated.\n");
1661     return 0;
1662 
1663 err:
1664     if (ec != boot_ec)
1665         acpi_ec_free(ec);
1666 
1667     return ret;
1668 }
1669 
1670 static int acpi_ec_remove(struct acpi_device *device)
1671 {
1672     struct acpi_ec *ec;
1673 
1674     if (!device)
1675         return -EINVAL;
1676 
1677     ec = acpi_driver_data(device);
1678     release_region(ec->data_addr, 1);
1679     release_region(ec->command_addr, 1);
1680     device->driver_data = NULL;
1681     if (ec != boot_ec) {
1682         ec_remove_handlers(ec);
1683         acpi_ec_free(ec);
1684     }
1685     return 0;
1686 }
1687 
1688 static acpi_status
1689 ec_parse_io_ports(struct acpi_resource *resource, void *context)
1690 {
1691     struct acpi_ec *ec = context;
1692 
1693     if (resource->type != ACPI_RESOURCE_TYPE_IO)
1694         return AE_OK;
1695 
1696     /*
1697      * The first address region returned is the data port, and
1698      * the second address region returned is the status/command
1699      * port.
1700      */
1701     if (ec->data_addr == 0)
1702         ec->data_addr = resource->data.io.minimum;
1703     else if (ec->command_addr == 0)
1704         ec->command_addr = resource->data.io.minimum;
1705     else
1706         return AE_CTRL_TERMINATE;
1707 
1708     return AE_OK;
1709 }
1710 
1711 static const struct acpi_device_id ec_device_ids[] = {
1712     {"PNP0C09", 0},
1713     {ACPI_ECDT_HID, 0},
1714     {"", 0},
1715 };
1716 
1717 /*
1718  * This function is not Windows-compatible as Windows never enumerates the
1719  * namespace EC before the main ACPI device enumeration process. It is
1720  * retained for historical reason and will be deprecated in the future.
1721  */
1722 void __init acpi_ec_dsdt_probe(void)
1723 {
1724     struct acpi_ec *ec;
1725     acpi_status status;
1726     int ret;
1727 
1728     /*
1729      * If a platform has ECDT, there is no need to proceed as the
1730      * following probe is not a part of the ACPI device enumeration,
1731      * executing _STA is not safe, and thus this probe may risk of
1732      * picking up an invalid EC device.
1733      */
1734     if (boot_ec)
1735         return;
1736 
1737     ec = acpi_ec_alloc();
1738     if (!ec)
1739         return;
1740 
1741     /*
1742      * At this point, the namespace is initialized, so start to find
1743      * the namespace objects.
1744      */
1745     status = acpi_get_devices(ec_device_ids[0].id, ec_parse_device, ec, NULL);
1746     if (ACPI_FAILURE(status) || !ec->handle) {
1747         acpi_ec_free(ec);
1748         return;
1749     }
1750 
1751     /*
1752      * When the DSDT EC is available, always re-configure boot EC to
1753      * have _REG evaluated. _REG can only be evaluated after the
1754      * namespace initialization.
1755      * At this point, the GPE is not fully initialized, so do not to
1756      * handle the events.
1757      */
1758     ret = acpi_ec_setup(ec, NULL);
1759     if (ret) {
1760         acpi_ec_free(ec);
1761         return;
1762     }
1763 
1764     boot_ec = ec;
1765 
1766     acpi_handle_info(ec->handle,
1767              "Boot DSDT EC used to handle transactions\n");
1768 }
1769 
1770 /*
1771  * acpi_ec_ecdt_start - Finalize the boot ECDT EC initialization.
1772  *
1773  * First, look for an ACPI handle for the boot ECDT EC if acpi_ec_add() has not
1774  * found a matching object in the namespace.
1775  *
1776  * Next, in case the DSDT EC is not functioning, it is still necessary to
1777  * provide a functional ECDT EC to handle events, so add an extra device object
1778  * to represent it (see https://bugzilla.kernel.org/show_bug.cgi?id=115021).
1779  *
1780  * This is useful on platforms with valid ECDT and invalid DSDT EC settings,
1781  * like ASUS X550ZE (see https://bugzilla.kernel.org/show_bug.cgi?id=196847).
1782  */
1783 static void __init acpi_ec_ecdt_start(void)
1784 {
1785     struct acpi_table_ecdt *ecdt_ptr;
1786     acpi_handle handle;
1787     acpi_status status;
1788 
1789     /* Bail out if a matching EC has been found in the namespace. */
1790     if (!boot_ec || boot_ec->handle != ACPI_ROOT_OBJECT)
1791         return;
1792 
1793     /* Look up the object pointed to from the ECDT in the namespace. */
1794     status = acpi_get_table(ACPI_SIG_ECDT, 1,
1795                 (struct acpi_table_header **)&ecdt_ptr);
1796     if (ACPI_FAILURE(status))
1797         return;
1798 
1799     status = acpi_get_handle(NULL, ecdt_ptr->id, &handle);
1800     if (ACPI_SUCCESS(status)) {
1801         boot_ec->handle = handle;
1802 
1803         /* Add a special ACPI device object to represent the boot EC. */
1804         acpi_bus_register_early_device(ACPI_BUS_TYPE_ECDT_EC);
1805     }
1806 
1807     acpi_put_table((struct acpi_table_header *)ecdt_ptr);
1808 }
1809 
1810 /*
1811  * On some hardware it is necessary to clear events accumulated by the EC during
1812  * sleep. These ECs stop reporting GPEs until they are manually polled, if too
1813  * many events are accumulated. (e.g. Samsung Series 5/9 notebooks)
1814  *
1815  * https://bugzilla.kernel.org/show_bug.cgi?id=44161
1816  *
1817  * Ideally, the EC should also be instructed NOT to accumulate events during
1818  * sleep (which Windows seems to do somehow), but the interface to control this
1819  * behaviour is not known at this time.
1820  *
1821  * Models known to be affected are Samsung 530Uxx/535Uxx/540Uxx/550Pxx/900Xxx,
1822  * however it is very likely that other Samsung models are affected.
1823  *
1824  * On systems which don't accumulate _Q events during sleep, this extra check
1825  * should be harmless.
1826  */
1827 static int ec_clear_on_resume(const struct dmi_system_id *id)
1828 {
1829     pr_debug("Detected system needing EC poll on resume.\n");
1830     EC_FLAGS_CLEAR_ON_RESUME = 1;
1831     ec_event_clearing = ACPI_EC_EVT_TIMING_STATUS;
1832     return 0;
1833 }
1834 
1835 /*
1836  * Some ECDTs contain wrong register addresses.
1837  * MSI MS-171F
1838  * https://bugzilla.kernel.org/show_bug.cgi?id=12461
1839  */
1840 static int ec_correct_ecdt(const struct dmi_system_id *id)
1841 {
1842     pr_debug("Detected system needing ECDT address correction.\n");
1843     EC_FLAGS_CORRECT_ECDT = 1;
1844     return 0;
1845 }
1846 
1847 /*
1848  * Some ECDTs contain wrong GPE setting, but they share the same port addresses
1849  * with DSDT EC, don't duplicate the DSDT EC with ECDT EC in this case.
1850  * https://bugzilla.kernel.org/show_bug.cgi?id=209989
1851  */
1852 static int ec_honor_dsdt_gpe(const struct dmi_system_id *id)
1853 {
1854     pr_debug("Detected system needing DSDT GPE setting.\n");
1855     EC_FLAGS_TRUST_DSDT_GPE = 1;
1856     return 0;
1857 }
1858 
1859 static const struct dmi_system_id ec_dmi_table[] __initconst = {
1860     {
1861         /*
1862          * MSI MS-171F
1863          * https://bugzilla.kernel.org/show_bug.cgi?id=12461
1864          */
1865         .callback = ec_correct_ecdt,
1866         .matches = {
1867             DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star"),
1868             DMI_MATCH(DMI_PRODUCT_NAME, "MS-171F"),
1869         },
1870     },
1871     {
1872         /*
1873          * HP Pavilion Gaming Laptop 15-cx0xxx
1874          * https://bugzilla.kernel.org/show_bug.cgi?id=209989
1875          */
1876         .callback = ec_honor_dsdt_gpe,
1877         .matches = {
1878             DMI_MATCH(DMI_SYS_VENDOR, "HP"),
1879             DMI_MATCH(DMI_PRODUCT_NAME, "HP Pavilion Gaming Laptop 15-cx0xxx"),
1880         },
1881     },
1882     {
1883         /*
1884          * Samsung hardware
1885          * https://bugzilla.kernel.org/show_bug.cgi?id=44161
1886          */
1887         .callback = ec_clear_on_resume,
1888         .matches = {
1889             DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
1890         },
1891     },
1892     {}
1893 };
1894 
1895 void __init acpi_ec_ecdt_probe(void)
1896 {
1897     struct acpi_table_ecdt *ecdt_ptr;
1898     struct acpi_ec *ec;
1899     acpi_status status;
1900     int ret;
1901 
1902     /* Generate a boot ec context. */
1903     dmi_check_system(ec_dmi_table);
1904     status = acpi_get_table(ACPI_SIG_ECDT, 1,
1905                 (struct acpi_table_header **)&ecdt_ptr);
1906     if (ACPI_FAILURE(status))
1907         return;
1908 
1909     if (!ecdt_ptr->control.address || !ecdt_ptr->data.address) {
1910         /*
1911          * Asus X50GL:
1912          * https://bugzilla.kernel.org/show_bug.cgi?id=11880
1913          */
1914         goto out;
1915     }
1916 
1917     ec = acpi_ec_alloc();
1918     if (!ec)
1919         goto out;
1920 
1921     if (EC_FLAGS_CORRECT_ECDT) {
1922         ec->command_addr = ecdt_ptr->data.address;
1923         ec->data_addr = ecdt_ptr->control.address;
1924     } else {
1925         ec->command_addr = ecdt_ptr->control.address;
1926         ec->data_addr = ecdt_ptr->data.address;
1927     }
1928 
1929     /*
1930      * Ignore the GPE value on Reduced Hardware platforms.
1931      * Some products have this set to an erroneous value.
1932      */
1933     if (!acpi_gbl_reduced_hardware)
1934         ec->gpe = ecdt_ptr->gpe;
1935 
1936     ec->handle = ACPI_ROOT_OBJECT;
1937 
1938     /*
1939      * At this point, the namespace is not initialized, so do not find
1940      * the namespace objects, or handle the events.
1941      */
1942     ret = acpi_ec_setup(ec, NULL);
1943     if (ret) {
1944         acpi_ec_free(ec);
1945         goto out;
1946     }
1947 
1948     boot_ec = ec;
1949     boot_ec_is_ecdt = true;
1950 
1951     pr_info("Boot ECDT EC used to handle transactions\n");
1952 
1953 out:
1954     acpi_put_table((struct acpi_table_header *)ecdt_ptr);
1955 }
1956 
1957 #ifdef CONFIG_PM_SLEEP
1958 static int acpi_ec_suspend(struct device *dev)
1959 {
1960     struct acpi_ec *ec =
1961         acpi_driver_data(to_acpi_device(dev));
1962 
1963     if (!pm_suspend_no_platform() && ec_freeze_events)
1964         acpi_ec_disable_event(ec);
1965     return 0;
1966 }
1967 
1968 static int acpi_ec_suspend_noirq(struct device *dev)
1969 {
1970     struct acpi_ec *ec = acpi_driver_data(to_acpi_device(dev));
1971 
1972     /*
1973      * The SCI handler doesn't run at this point, so the GPE can be
1974      * masked at the low level without side effects.
1975      */
1976     if (ec_no_wakeup && test_bit(EC_FLAGS_STARTED, &ec->flags) &&
1977         ec->gpe >= 0 && ec->reference_count >= 1)
1978         acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_DISABLE);
1979 
1980     acpi_ec_enter_noirq(ec);
1981 
1982     return 0;
1983 }
1984 
1985 static int acpi_ec_resume_noirq(struct device *dev)
1986 {
1987     struct acpi_ec *ec = acpi_driver_data(to_acpi_device(dev));
1988 
1989     acpi_ec_leave_noirq(ec);
1990 
1991     if (ec_no_wakeup && test_bit(EC_FLAGS_STARTED, &ec->flags) &&
1992         ec->gpe >= 0 && ec->reference_count >= 1)
1993         acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_ENABLE);
1994 
1995     return 0;
1996 }
1997 
1998 static int acpi_ec_resume(struct device *dev)
1999 {
2000     struct acpi_ec *ec =
2001         acpi_driver_data(to_acpi_device(dev));
2002 
2003     acpi_ec_enable_event(ec);
2004     return 0;
2005 }
2006 
2007 void acpi_ec_mark_gpe_for_wake(void)
2008 {
2009     if (first_ec && !ec_no_wakeup)
2010         acpi_mark_gpe_for_wake(NULL, first_ec->gpe);
2011 }
2012 EXPORT_SYMBOL_GPL(acpi_ec_mark_gpe_for_wake);
2013 
2014 void acpi_ec_set_gpe_wake_mask(u8 action)
2015 {
2016     if (pm_suspend_no_platform() && first_ec && !ec_no_wakeup)
2017         acpi_set_gpe_wake_mask(NULL, first_ec->gpe, action);
2018 }
2019 
2020 static bool acpi_ec_work_in_progress(struct acpi_ec *ec)
2021 {
2022     return ec->events_in_progress + ec->queries_in_progress > 0;
2023 }
2024 
2025 bool acpi_ec_dispatch_gpe(void)
2026 {
2027     bool work_in_progress = false;
2028 
2029     if (!first_ec)
2030         return acpi_any_gpe_status_set(U32_MAX);
2031 
2032     /*
2033      * Report wakeup if the status bit is set for any enabled GPE other
2034      * than the EC one.
2035      */
2036     if (acpi_any_gpe_status_set(first_ec->gpe))
2037         return true;
2038 
2039     /*
2040      * Cancel the SCI wakeup and process all pending events in case there
2041      * are any wakeup ones in there.
2042      *
2043      * Note that if any non-EC GPEs are active at this point, the SCI will
2044      * retrigger after the rearming in acpi_s2idle_wake(), so no events
2045      * should be missed by canceling the wakeup here.
2046      */
2047     pm_system_cancel_wakeup();
2048 
2049     /*
2050      * Dispatch the EC GPE in-band, but do not report wakeup in any case
2051      * to allow the caller to process events properly after that.
2052      */
2053     spin_lock_irq(&first_ec->lock);
2054 
2055     if (acpi_ec_gpe_status_set(first_ec)) {
2056         pm_pr_dbg("ACPI EC GPE status set\n");
2057 
2058         advance_transaction(first_ec, false);
2059         work_in_progress = acpi_ec_work_in_progress(first_ec);
2060     }
2061 
2062     spin_unlock_irq(&first_ec->lock);
2063 
2064     if (!work_in_progress)
2065         return false;
2066 
2067     pm_pr_dbg("ACPI EC GPE dispatched\n");
2068 
2069     /* Drain EC work. */
2070     do {
2071         acpi_ec_flush_work();
2072 
2073         pm_pr_dbg("ACPI EC work flushed\n");
2074 
2075         spin_lock_irq(&first_ec->lock);
2076 
2077         work_in_progress = acpi_ec_work_in_progress(first_ec);
2078 
2079         spin_unlock_irq(&first_ec->lock);
2080     } while (work_in_progress && !pm_wakeup_pending());
2081 
2082     return false;
2083 }
2084 #endif /* CONFIG_PM_SLEEP */
2085 
2086 static const struct dev_pm_ops acpi_ec_pm = {
2087     SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(acpi_ec_suspend_noirq, acpi_ec_resume_noirq)
2088     SET_SYSTEM_SLEEP_PM_OPS(acpi_ec_suspend, acpi_ec_resume)
2089 };
2090 
2091 static int param_set_event_clearing(const char *val,
2092                     const struct kernel_param *kp)
2093 {
2094     int result = 0;
2095 
2096     if (!strncmp(val, "status", sizeof("status") - 1)) {
2097         ec_event_clearing = ACPI_EC_EVT_TIMING_STATUS;
2098         pr_info("Assuming SCI_EVT clearing on EC_SC accesses\n");
2099     } else if (!strncmp(val, "query", sizeof("query") - 1)) {
2100         ec_event_clearing = ACPI_EC_EVT_TIMING_QUERY;
2101         pr_info("Assuming SCI_EVT clearing on QR_EC writes\n");
2102     } else if (!strncmp(val, "event", sizeof("event") - 1)) {
2103         ec_event_clearing = ACPI_EC_EVT_TIMING_EVENT;
2104         pr_info("Assuming SCI_EVT clearing on event reads\n");
2105     } else
2106         result = -EINVAL;
2107     return result;
2108 }
2109 
2110 static int param_get_event_clearing(char *buffer,
2111                     const struct kernel_param *kp)
2112 {
2113     switch (ec_event_clearing) {
2114     case ACPI_EC_EVT_TIMING_STATUS:
2115         return sprintf(buffer, "status\n");
2116     case ACPI_EC_EVT_TIMING_QUERY:
2117         return sprintf(buffer, "query\n");
2118     case ACPI_EC_EVT_TIMING_EVENT:
2119         return sprintf(buffer, "event\n");
2120     default:
2121         return sprintf(buffer, "invalid\n");
2122     }
2123     return 0;
2124 }
2125 
2126 module_param_call(ec_event_clearing, param_set_event_clearing, param_get_event_clearing,
2127           NULL, 0644);
2128 MODULE_PARM_DESC(ec_event_clearing, "Assumed SCI_EVT clearing timing");
2129 
2130 static struct acpi_driver acpi_ec_driver = {
2131     .name = "ec",
2132     .class = ACPI_EC_CLASS,
2133     .ids = ec_device_ids,
2134     .ops = {
2135         .add = acpi_ec_add,
2136         .remove = acpi_ec_remove,
2137         },
2138     .drv.pm = &acpi_ec_pm,
2139 };
2140 
2141 static void acpi_ec_destroy_workqueues(void)
2142 {
2143     if (ec_wq) {
2144         destroy_workqueue(ec_wq);
2145         ec_wq = NULL;
2146     }
2147     if (ec_query_wq) {
2148         destroy_workqueue(ec_query_wq);
2149         ec_query_wq = NULL;
2150     }
2151 }
2152 
2153 static int acpi_ec_init_workqueues(void)
2154 {
2155     if (!ec_wq)
2156         ec_wq = alloc_ordered_workqueue("kec", 0);
2157 
2158     if (!ec_query_wq)
2159         ec_query_wq = alloc_workqueue("kec_query", 0, ec_max_queries);
2160 
2161     if (!ec_wq || !ec_query_wq) {
2162         acpi_ec_destroy_workqueues();
2163         return -ENODEV;
2164     }
2165     return 0;
2166 }
2167 
2168 static const struct dmi_system_id acpi_ec_no_wakeup[] = {
2169     {
2170         .matches = {
2171             DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
2172             DMI_MATCH(DMI_PRODUCT_FAMILY, "Thinkpad X1 Carbon 6th"),
2173         },
2174     },
2175     {
2176         .matches = {
2177             DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
2178             DMI_MATCH(DMI_PRODUCT_FAMILY, "ThinkPad X1 Yoga 3rd"),
2179         },
2180     },
2181     {
2182         .matches = {
2183             DMI_MATCH(DMI_SYS_VENDOR, "HP"),
2184             DMI_MATCH(DMI_PRODUCT_FAMILY, "103C_5336AN HP ZHAN 66 Pro"),
2185         },
2186     },
2187     { },
2188 };
2189 
2190 void __init acpi_ec_init(void)
2191 {
2192     int result;
2193 
2194     result = acpi_ec_init_workqueues();
2195     if (result)
2196         return;
2197 
2198     /*
2199      * Disable EC wakeup on following systems to prevent periodic
2200      * wakeup from EC GPE.
2201      */
2202     if (dmi_check_system(acpi_ec_no_wakeup)) {
2203         ec_no_wakeup = true;
2204         pr_debug("Disabling EC wakeup on suspend-to-idle\n");
2205     }
2206 
2207     /* Driver must be registered after acpi_ec_init_workqueues(). */
2208     acpi_bus_register_driver(&acpi_ec_driver);
2209 
2210     acpi_ec_ecdt_start();
2211 }
2212 
2213 /* EC driver currently not unloadable */
2214 #if 0
2215 static void __exit acpi_ec_exit(void)
2216 {
2217 
2218     acpi_bus_unregister_driver(&acpi_ec_driver);
2219     acpi_ec_destroy_workqueues();
2220 }
2221 #endif  /* 0 */
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!