Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-or-later
2 : : /*
3 : : * ec.c - ACPI Embedded Controller Driver (v3)
4 : : *
5 : : * Copyright (C) 2001-2015 Intel Corporation
6 : : * Author: 2014, 2015 Lv Zheng <lv.zheng@intel.com>
7 : : * 2006, 2007 Alexey Starikovskiy <alexey.y.starikovskiy@intel.com>
8 : : * 2006 Denis Sadykov <denis.m.sadykov@intel.com>
9 : : * 2004 Luming Yu <luming.yu@intel.com>
10 : : * 2001, 2002 Andy Grover <andrew.grover@intel.com>
11 : : * 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
12 : : * Copyright (C) 2008 Alexey Starikovskiy <astarikovskiy@suse.de>
13 : : */
14 : :
15 : : /* Uncomment next line to get verbose printout */
16 : : /* #define DEBUG */
17 : : #define pr_fmt(fmt) "ACPI: EC: " fmt
18 : :
19 : : #include <linux/kernel.h>
20 : : #include <linux/module.h>
21 : : #include <linux/init.h>
22 : : #include <linux/types.h>
23 : : #include <linux/delay.h>
24 : : #include <linux/interrupt.h>
25 : : #include <linux/list.h>
26 : : #include <linux/spinlock.h>
27 : : #include <linux/slab.h>
28 : : #include <linux/suspend.h>
29 : : #include <linux/acpi.h>
30 : : #include <linux/dmi.h>
31 : : #include <asm/io.h>
32 : :
33 : : #include "internal.h"
34 : :
35 : : #define ACPI_EC_CLASS "embedded_controller"
36 : : #define ACPI_EC_DEVICE_NAME "Embedded Controller"
37 : : #define ACPI_EC_FILE_INFO "info"
38 : :
39 : : /* EC status register */
40 : : #define ACPI_EC_FLAG_OBF 0x01 /* Output buffer full */
41 : : #define ACPI_EC_FLAG_IBF 0x02 /* Input buffer full */
42 : : #define ACPI_EC_FLAG_CMD 0x08 /* Input buffer contains a command */
43 : : #define ACPI_EC_FLAG_BURST 0x10 /* burst mode */
44 : : #define ACPI_EC_FLAG_SCI 0x20 /* EC-SCI occurred */
45 : :
46 : : /*
47 : : * The SCI_EVT clearing timing is not defined by the ACPI specification.
48 : : * This leads to lots of practical timing issues for the host EC driver.
49 : : * The following variations are defined (from the target EC firmware's
50 : : * perspective):
51 : : * STATUS: After indicating SCI_EVT edge triggered IRQ to the host, the
52 : : * target can clear SCI_EVT at any time so long as the host can see
53 : : * the indication by reading the status register (EC_SC). So the
54 : : * host should re-check SCI_EVT after the first time the SCI_EVT
55 : : * indication is seen, which is the same time the query request
56 : : * (QR_EC) is written to the command register (EC_CMD). SCI_EVT set
57 : : * at any later time could indicate another event. Normally such
58 : : * kind of EC firmware has implemented an event queue and will
59 : : * return 0x00 to indicate "no outstanding event".
60 : : * QUERY: After seeing the query request (QR_EC) written to the command
61 : : * register (EC_CMD) by the host and having prepared the responding
62 : : * event value in the data register (EC_DATA), the target can safely
63 : : * clear SCI_EVT because the target can confirm that the current
64 : : * event is being handled by the host. The host then should check
65 : : * SCI_EVT right after reading the event response from the data
66 : : * register (EC_DATA).
67 : : * EVENT: After seeing the event response read from the data register
68 : : * (EC_DATA) by the host, the target can clear SCI_EVT. As the
69 : : * target requires time to notice the change in the data register
70 : : * (EC_DATA), the host may be required to wait additional guarding
71 : : * time before checking the SCI_EVT again. Such guarding may not be
72 : : * necessary if the host is notified via another IRQ.
73 : : */
74 : : #define ACPI_EC_EVT_TIMING_STATUS 0x00
75 : : #define ACPI_EC_EVT_TIMING_QUERY 0x01
76 : : #define ACPI_EC_EVT_TIMING_EVENT 0x02
77 : :
78 : : /* EC commands */
79 : : enum ec_command {
80 : : ACPI_EC_COMMAND_READ = 0x80,
81 : : ACPI_EC_COMMAND_WRITE = 0x81,
82 : : ACPI_EC_BURST_ENABLE = 0x82,
83 : : ACPI_EC_BURST_DISABLE = 0x83,
84 : : ACPI_EC_COMMAND_QUERY = 0x84,
85 : : };
86 : :
87 : : #define ACPI_EC_DELAY 500 /* Wait 500ms max. during EC ops */
88 : : #define ACPI_EC_UDELAY_GLK 1000 /* Wait 1ms max. to get global lock */
89 : : #define ACPI_EC_UDELAY_POLL 550 /* Wait 1ms for EC transaction polling */
90 : : #define ACPI_EC_CLEAR_MAX 100 /* Maximum number of events to query
91 : : * when trying to clear the EC */
92 : : #define ACPI_EC_MAX_QUERIES 16 /* Maximum number of parallel queries */
93 : :
94 : : enum {
95 : : EC_FLAGS_QUERY_ENABLED, /* Query is enabled */
96 : : EC_FLAGS_QUERY_PENDING, /* Query is pending */
97 : : EC_FLAGS_QUERY_GUARDING, /* Guard for SCI_EVT check */
98 : : EC_FLAGS_EVENT_HANDLER_INSTALLED, /* Event handler installed */
99 : : EC_FLAGS_EC_HANDLER_INSTALLED, /* OpReg handler installed */
100 : : EC_FLAGS_QUERY_METHODS_INSTALLED, /* _Qxx handlers installed */
101 : : EC_FLAGS_STARTED, /* Driver is started */
102 : : EC_FLAGS_STOPPED, /* Driver is stopped */
103 : : EC_FLAGS_EVENTS_MASKED, /* Events masked */
104 : : };
105 : :
106 : : #define ACPI_EC_COMMAND_POLL 0x01 /* Available for command byte */
107 : : #define ACPI_EC_COMMAND_COMPLETE 0x02 /* Completed last byte */
108 : :
109 : : /* ec.c is compiled in acpi namespace so this shows up as acpi.ec_delay param */
110 : : static unsigned int ec_delay __read_mostly = ACPI_EC_DELAY;
111 : : module_param(ec_delay, uint, 0644);
112 : : MODULE_PARM_DESC(ec_delay, "Timeout(ms) waited until an EC command completes");
113 : :
114 : : static unsigned int ec_max_queries __read_mostly = ACPI_EC_MAX_QUERIES;
115 : : module_param(ec_max_queries, uint, 0644);
116 : : MODULE_PARM_DESC(ec_max_queries, "Maximum parallel _Qxx evaluations");
117 : :
118 : : static bool ec_busy_polling __read_mostly;
119 : : module_param(ec_busy_polling, bool, 0644);
120 : : MODULE_PARM_DESC(ec_busy_polling, "Use busy polling to advance EC transaction");
121 : :
122 : : static unsigned int ec_polling_guard __read_mostly = ACPI_EC_UDELAY_POLL;
123 : : module_param(ec_polling_guard, uint, 0644);
124 : : MODULE_PARM_DESC(ec_polling_guard, "Guard time(us) between EC accesses in polling modes");
125 : :
126 : : static unsigned int ec_event_clearing __read_mostly = ACPI_EC_EVT_TIMING_QUERY;
127 : :
128 : : /*
129 : : * If the number of false interrupts per one transaction exceeds
130 : : * this threshold, will think there is a GPE storm happened and
131 : : * will disable the GPE for normal transaction.
132 : : */
133 : : static unsigned int ec_storm_threshold __read_mostly = 8;
134 : : module_param(ec_storm_threshold, uint, 0644);
135 : : MODULE_PARM_DESC(ec_storm_threshold, "Maxim false GPE numbers not considered as GPE storm");
136 : :
137 : : static bool ec_freeze_events __read_mostly = false;
138 : : module_param(ec_freeze_events, bool, 0644);
139 : : MODULE_PARM_DESC(ec_freeze_events, "Disabling event handling during suspend/resume");
140 : :
141 : : static bool ec_no_wakeup __read_mostly;
142 : : module_param(ec_no_wakeup, bool, 0644);
143 : : MODULE_PARM_DESC(ec_no_wakeup, "Do not wake up from suspend-to-idle");
144 : :
145 : : struct acpi_ec_query_handler {
146 : : struct list_head node;
147 : : acpi_ec_query_func func;
148 : : acpi_handle handle;
149 : : void *data;
150 : : u8 query_bit;
151 : : struct kref kref;
152 : : };
153 : :
154 : : struct transaction {
155 : : const u8 *wdata;
156 : : u8 *rdata;
157 : : unsigned short irq_count;
158 : : u8 command;
159 : : u8 wi;
160 : : u8 ri;
161 : : u8 wlen;
162 : : u8 rlen;
163 : : u8 flags;
164 : : };
165 : :
166 : : struct acpi_ec_query {
167 : : struct transaction transaction;
168 : : struct work_struct work;
169 : : struct acpi_ec_query_handler *handler;
170 : : };
171 : :
172 : : static int acpi_ec_query(struct acpi_ec *ec, u8 *data);
173 : : static void advance_transaction(struct acpi_ec *ec);
174 : : static void acpi_ec_event_handler(struct work_struct *work);
175 : : static void acpi_ec_event_processor(struct work_struct *work);
176 : :
177 : : struct acpi_ec *first_ec;
178 : : EXPORT_SYMBOL(first_ec);
179 : :
180 : : static struct acpi_ec *boot_ec;
181 : : static bool boot_ec_is_ecdt = false;
182 : : static struct workqueue_struct *ec_wq;
183 : : static struct workqueue_struct *ec_query_wq;
184 : :
185 : : static int EC_FLAGS_QUERY_HANDSHAKE; /* Needs QR_EC issued when SCI_EVT set */
186 : : static int EC_FLAGS_CORRECT_ECDT; /* Needs ECDT port address correction */
187 : : static int EC_FLAGS_IGNORE_DSDT_GPE; /* Needs ECDT GPE as correction setting */
188 : : static int EC_FLAGS_CLEAR_ON_RESUME; /* Needs acpi_ec_clear() on boot/resume */
189 : :
190 : : /* --------------------------------------------------------------------------
191 : : * Logging/Debugging
192 : : * -------------------------------------------------------------------------- */
193 : :
194 : : /*
195 : : * Splitters used by the developers to track the boundary of the EC
196 : : * handling processes.
197 : : */
198 : : #ifdef DEBUG
199 : : #define EC_DBG_SEP " "
200 : : #define EC_DBG_DRV "+++++"
201 : : #define EC_DBG_STM "====="
202 : : #define EC_DBG_REQ "*****"
203 : : #define EC_DBG_EVT "#####"
204 : : #else
205 : : #define EC_DBG_SEP ""
206 : : #define EC_DBG_DRV
207 : : #define EC_DBG_STM
208 : : #define EC_DBG_REQ
209 : : #define EC_DBG_EVT
210 : : #endif
211 : :
212 : : #define ec_log_raw(fmt, ...) \
213 : : pr_info(fmt "\n", ##__VA_ARGS__)
214 : : #define ec_dbg_raw(fmt, ...) \
215 : : pr_debug(fmt "\n", ##__VA_ARGS__)
216 : : #define ec_log(filter, fmt, ...) \
217 : : ec_log_raw(filter EC_DBG_SEP fmt EC_DBG_SEP filter, ##__VA_ARGS__)
218 : : #define ec_dbg(filter, fmt, ...) \
219 : : ec_dbg_raw(filter EC_DBG_SEP fmt EC_DBG_SEP filter, ##__VA_ARGS__)
220 : :
221 : : #define ec_log_drv(fmt, ...) \
222 : : ec_log(EC_DBG_DRV, fmt, ##__VA_ARGS__)
223 : : #define ec_dbg_drv(fmt, ...) \
224 : : ec_dbg(EC_DBG_DRV, fmt, ##__VA_ARGS__)
225 : : #define ec_dbg_stm(fmt, ...) \
226 : : ec_dbg(EC_DBG_STM, fmt, ##__VA_ARGS__)
227 : : #define ec_dbg_req(fmt, ...) \
228 : : ec_dbg(EC_DBG_REQ, fmt, ##__VA_ARGS__)
229 : : #define ec_dbg_evt(fmt, ...) \
230 : : ec_dbg(EC_DBG_EVT, fmt, ##__VA_ARGS__)
231 : : #define ec_dbg_ref(ec, fmt, ...) \
232 : : ec_dbg_raw("%lu: " fmt, ec->reference_count, ## __VA_ARGS__)
233 : :
234 : : /* --------------------------------------------------------------------------
235 : : * Device Flags
236 : : * -------------------------------------------------------------------------- */
237 : :
238 : 0 : static bool acpi_ec_started(struct acpi_ec *ec)
239 : : {
240 [ # # # # ]: 0 : return test_bit(EC_FLAGS_STARTED, &ec->flags) &&
241 : : !test_bit(EC_FLAGS_STOPPED, &ec->flags);
242 : : }
243 : :
244 : 0 : static bool acpi_ec_event_enabled(struct acpi_ec *ec)
245 : : {
246 : : /*
247 : : * There is an OSPM early stage logic. During the early stages
248 : : * (boot/resume), OSPMs shouldn't enable the event handling, only
249 : : * the EC transactions are allowed to be performed.
250 : : */
251 [ # # ]: 0 : if (!test_bit(EC_FLAGS_QUERY_ENABLED, &ec->flags))
252 : : return false;
253 : : /*
254 : : * However, disabling the event handling is experimental for late
255 : : * stage (suspend), and is controlled by the boot parameter of
256 : : * "ec_freeze_events":
257 : : * 1. true: The EC event handling is disabled before entering
258 : : * the noirq stage.
259 : : * 2. false: The EC event handling is automatically disabled as
260 : : * soon as the EC driver is stopped.
261 : : */
262 [ # # ]: 0 : if (ec_freeze_events)
263 : 0 : return acpi_ec_started(ec);
264 : : else
265 : 0 : return test_bit(EC_FLAGS_STARTED, &ec->flags);
266 : : }
267 : :
268 : 0 : static bool acpi_ec_flushed(struct acpi_ec *ec)
269 : : {
270 : 0 : return ec->reference_count == 1;
271 : : }
272 : :
273 : : /* --------------------------------------------------------------------------
274 : : * EC Registers
275 : : * -------------------------------------------------------------------------- */
276 : :
277 : 0 : static inline u8 acpi_ec_read_status(struct acpi_ec *ec)
278 : : {
279 : 0 : u8 x = inb(ec->command_addr);
280 : :
281 : 0 : ec_dbg_raw("EC_SC(R) = 0x%2.2x "
282 : : "SCI_EVT=%d BURST=%d CMD=%d IBF=%d OBF=%d",
283 : : x,
284 : : !!(x & ACPI_EC_FLAG_SCI),
285 : : !!(x & ACPI_EC_FLAG_BURST),
286 : : !!(x & ACPI_EC_FLAG_CMD),
287 : : !!(x & ACPI_EC_FLAG_IBF),
288 : : !!(x & ACPI_EC_FLAG_OBF));
289 : 0 : return x;
290 : : }
291 : :
292 : 0 : static inline u8 acpi_ec_read_data(struct acpi_ec *ec)
293 : : {
294 : 0 : u8 x = inb(ec->data_addr);
295 : :
296 : 0 : ec->timestamp = jiffies;
297 : 0 : ec_dbg_raw("EC_DATA(R) = 0x%2.2x", x);
298 : 0 : return x;
299 : : }
300 : :
301 : 0 : static inline void acpi_ec_write_cmd(struct acpi_ec *ec, u8 command)
302 : : {
303 : 0 : ec_dbg_raw("EC_SC(W) = 0x%2.2x", command);
304 : 0 : outb(command, ec->command_addr);
305 : 0 : ec->timestamp = jiffies;
306 : : }
307 : :
308 : 0 : static inline void acpi_ec_write_data(struct acpi_ec *ec, u8 data)
309 : : {
310 : 0 : ec_dbg_raw("EC_DATA(W) = 0x%2.2x", data);
311 : 0 : outb(data, ec->data_addr);
312 : 0 : ec->timestamp = jiffies;
313 : 0 : }
314 : :
315 : : #if defined(DEBUG) || defined(CONFIG_DYNAMIC_DEBUG)
316 : : static const char *acpi_ec_cmd_string(u8 cmd)
317 : : {
318 : : switch (cmd) {
319 : : case 0x80:
320 : : return "RD_EC";
321 : : case 0x81:
322 : : return "WR_EC";
323 : : case 0x82:
324 : : return "BE_EC";
325 : : case 0x83:
326 : : return "BD_EC";
327 : : case 0x84:
328 : : return "QR_EC";
329 : : }
330 : : return "UNKNOWN";
331 : : }
332 : : #else
333 : : #define acpi_ec_cmd_string(cmd) "UNDEF"
334 : : #endif
335 : :
336 : : /* --------------------------------------------------------------------------
337 : : * GPE Registers
338 : : * -------------------------------------------------------------------------- */
339 : :
340 : 0 : static inline bool acpi_ec_is_gpe_raised(struct acpi_ec *ec)
341 : : {
342 : 0 : acpi_event_status gpe_status = 0;
343 : :
344 : 0 : (void)acpi_get_gpe_status(NULL, ec->gpe, &gpe_status);
345 : 0 : return (gpe_status & ACPI_EVENT_FLAG_STATUS_SET) ? true : false;
346 : : }
347 : :
348 : 0 : static inline void acpi_ec_enable_gpe(struct acpi_ec *ec, bool open)
349 : : {
350 [ # # ]: 0 : if (open)
351 : 0 : acpi_enable_gpe(NULL, ec->gpe);
352 : : else {
353 [ # # ]: 0 : BUG_ON(ec->reference_count < 1);
354 : 0 : acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_ENABLE);
355 : : }
356 [ # # ]: 0 : if (acpi_ec_is_gpe_raised(ec)) {
357 : : /*
358 : : * On some platforms, EN=1 writes cannot trigger GPE. So
359 : : * software need to manually trigger a pseudo GPE event on
360 : : * EN=1 writes.
361 : : */
362 : 0 : ec_dbg_raw("Polling quirk");
363 : 0 : advance_transaction(ec);
364 : : }
365 : 0 : }
366 : :
367 : 0 : static inline void acpi_ec_disable_gpe(struct acpi_ec *ec, bool close)
368 : : {
369 [ # # ]: 0 : if (close)
370 : 0 : acpi_disable_gpe(NULL, ec->gpe);
371 : : else {
372 [ # # ]: 0 : BUG_ON(ec->reference_count < 1);
373 : 0 : acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_DISABLE);
374 : : }
375 : 0 : }
376 : :
377 : 0 : static inline void acpi_ec_clear_gpe(struct acpi_ec *ec)
378 : : {
379 : : /*
380 : : * GPE STS is a W1C register, which means:
381 : : * 1. Software can clear it without worrying about clearing other
382 : : * GPEs' STS bits when the hardware sets them in parallel.
383 : : * 2. As long as software can ensure only clearing it when it is
384 : : * set, hardware won't set it in parallel.
385 : : * So software can clear GPE in any contexts.
386 : : * Warning: do not move the check into advance_transaction() as the
387 : : * EC commands will be sent without GPE raised.
388 : : */
389 [ # # ]: 0 : if (!acpi_ec_is_gpe_raised(ec))
390 : : return;
391 : 0 : acpi_clear_gpe(NULL, ec->gpe);
392 : : }
393 : :
394 : : /* --------------------------------------------------------------------------
395 : : * Transaction Management
396 : : * -------------------------------------------------------------------------- */
397 : :
398 : 0 : static void acpi_ec_submit_request(struct acpi_ec *ec)
399 : : {
400 : 0 : ec->reference_count++;
401 [ # # ]: 0 : if (test_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags) &&
402 [ # # # # ]: 0 : ec->gpe >= 0 && ec->reference_count == 1)
403 : 0 : acpi_ec_enable_gpe(ec, true);
404 : 0 : }
405 : :
406 : 0 : static void acpi_ec_complete_request(struct acpi_ec *ec)
407 : : {
408 : 0 : bool flushed = false;
409 : :
410 : 0 : ec->reference_count--;
411 [ # # ]: 0 : if (test_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags) &&
412 [ # # # # ]: 0 : ec->gpe >= 0 && ec->reference_count == 0)
413 : 0 : acpi_ec_disable_gpe(ec, true);
414 : 0 : flushed = acpi_ec_flushed(ec);
415 [ # # ]: 0 : if (flushed)
416 : 0 : wake_up(&ec->wait);
417 : 0 : }
418 : :
419 : 0 : static void acpi_ec_mask_events(struct acpi_ec *ec)
420 : : {
421 [ # # ]: 0 : if (!test_bit(EC_FLAGS_EVENTS_MASKED, &ec->flags)) {
422 [ # # ]: 0 : if (ec->gpe >= 0)
423 : 0 : acpi_ec_disable_gpe(ec, false);
424 : : else
425 : 0 : disable_irq_nosync(ec->irq);
426 : :
427 : 0 : ec_dbg_drv("Polling enabled");
428 : 0 : set_bit(EC_FLAGS_EVENTS_MASKED, &ec->flags);
429 : : }
430 : 0 : }
431 : :
432 : 0 : static void acpi_ec_unmask_events(struct acpi_ec *ec)
433 : : {
434 [ # # ]: 0 : if (test_bit(EC_FLAGS_EVENTS_MASKED, &ec->flags)) {
435 : 0 : clear_bit(EC_FLAGS_EVENTS_MASKED, &ec->flags);
436 [ # # ]: 0 : if (ec->gpe >= 0)
437 : 0 : acpi_ec_enable_gpe(ec, false);
438 : : else
439 : 0 : enable_irq(ec->irq);
440 : :
441 : : ec_dbg_drv("Polling disabled");
442 : : }
443 : 0 : }
444 : :
445 : : /*
446 : : * acpi_ec_submit_flushable_request() - Increase the reference count unless
447 : : * the flush operation is not in
448 : : * progress
449 : : * @ec: the EC device
450 : : *
451 : : * This function must be used before taking a new action that should hold
452 : : * the reference count. If this function returns false, then the action
453 : : * must be discarded or it will prevent the flush operation from being
454 : : * completed.
455 : : */
456 : 0 : static bool acpi_ec_submit_flushable_request(struct acpi_ec *ec)
457 : : {
458 [ # # ]: 0 : if (!acpi_ec_started(ec))
459 : : return false;
460 : 0 : acpi_ec_submit_request(ec);
461 : 0 : return true;
462 : : }
463 : :
464 : 0 : static void acpi_ec_submit_query(struct acpi_ec *ec)
465 : : {
466 : 0 : acpi_ec_mask_events(ec);
467 [ # # ]: 0 : if (!acpi_ec_event_enabled(ec))
468 : : return;
469 [ # # ]: 0 : if (!test_and_set_bit(EC_FLAGS_QUERY_PENDING, &ec->flags)) {
470 : 0 : ec_dbg_evt("Command(%s) submitted/blocked",
471 : : acpi_ec_cmd_string(ACPI_EC_COMMAND_QUERY));
472 : 0 : ec->nr_pending_queries++;
473 : 0 : queue_work(ec_wq, &ec->work);
474 : : }
475 : : }
476 : :
477 : 0 : static void acpi_ec_complete_query(struct acpi_ec *ec)
478 : : {
479 : 0 : if (test_and_clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags))
480 : : ec_dbg_evt("Command(%s) unblocked",
481 : : acpi_ec_cmd_string(ACPI_EC_COMMAND_QUERY));
482 : 0 : acpi_ec_unmask_events(ec);
483 : 0 : }
484 : :
485 : 0 : static inline void __acpi_ec_enable_event(struct acpi_ec *ec)
486 : : {
487 [ # # ]: 0 : if (!test_and_set_bit(EC_FLAGS_QUERY_ENABLED, &ec->flags))
488 : 0 : ec_log_drv("event unblocked");
489 : : /*
490 : : * Unconditionally invoke this once after enabling the event
491 : : * handling mechanism to detect the pending events.
492 : : */
493 : 0 : advance_transaction(ec);
494 : 0 : }
495 : :
496 : 0 : static inline void __acpi_ec_disable_event(struct acpi_ec *ec)
497 : : {
498 [ # # ]: 0 : if (test_and_clear_bit(EC_FLAGS_QUERY_ENABLED, &ec->flags))
499 : 0 : ec_log_drv("event blocked");
500 : 0 : }
501 : :
502 : : /*
503 : : * Process _Q events that might have accumulated in the EC.
504 : : * Run with locked ec mutex.
505 : : */
506 : 0 : static void acpi_ec_clear(struct acpi_ec *ec)
507 : : {
508 : 0 : int i, status;
509 : 0 : u8 value = 0;
510 : :
511 [ # # ]: 0 : for (i = 0; i < ACPI_EC_CLEAR_MAX; i++) {
512 : 0 : status = acpi_ec_query(ec, &value);
513 [ # # # # ]: 0 : if (status || !value)
514 : : break;
515 : : }
516 [ # # ]: 0 : if (unlikely(i == ACPI_EC_CLEAR_MAX))
517 : 0 : pr_warn("Warning: Maximum of %d stale EC events cleared\n", i);
518 : : else
519 : 0 : pr_info("%d stale EC events cleared\n", i);
520 : 0 : }
521 : :
522 : 0 : static void acpi_ec_enable_event(struct acpi_ec *ec)
523 : : {
524 : 0 : unsigned long flags;
525 : :
526 : 0 : spin_lock_irqsave(&ec->lock, flags);
527 [ # # ]: 0 : if (acpi_ec_started(ec))
528 : 0 : __acpi_ec_enable_event(ec);
529 : 0 : spin_unlock_irqrestore(&ec->lock, flags);
530 : :
531 : : /* Drain additional events if hardware requires that */
532 [ # # ]: 0 : if (EC_FLAGS_CLEAR_ON_RESUME)
533 : 0 : acpi_ec_clear(ec);
534 : 0 : }
535 : :
536 : : #ifdef CONFIG_PM_SLEEP
537 : 0 : static void __acpi_ec_flush_work(void)
538 : : {
539 : 0 : drain_workqueue(ec_wq); /* flush ec->work */
540 : 0 : flush_workqueue(ec_query_wq); /* flush queries */
541 : 0 : }
542 : :
543 : 0 : static void acpi_ec_disable_event(struct acpi_ec *ec)
544 : : {
545 : 0 : unsigned long flags;
546 : :
547 : 0 : spin_lock_irqsave(&ec->lock, flags);
548 : 0 : __acpi_ec_disable_event(ec);
549 : 0 : spin_unlock_irqrestore(&ec->lock, flags);
550 : :
551 : : /*
552 : : * When ec_freeze_events is true, we need to flush events in
553 : : * the proper position before entering the noirq stage.
554 : : */
555 : 0 : __acpi_ec_flush_work();
556 : 0 : }
557 : :
558 : 0 : void acpi_ec_flush_work(void)
559 : : {
560 : : /* Without ec_wq there is nothing to flush. */
561 [ # # ]: 0 : if (!ec_wq)
562 : : return;
563 : :
564 : 0 : __acpi_ec_flush_work();
565 : : }
566 : : #endif /* CONFIG_PM_SLEEP */
567 : :
568 : 0 : static bool acpi_ec_guard_event(struct acpi_ec *ec)
569 : : {
570 : 0 : bool guarded = true;
571 : 0 : unsigned long flags;
572 : :
573 : 0 : spin_lock_irqsave(&ec->lock, flags);
574 : : /*
575 : : * If firmware SCI_EVT clearing timing is "event", we actually
576 : : * don't know when the SCI_EVT will be cleared by firmware after
577 : : * evaluating _Qxx, so we need to re-check SCI_EVT after waiting an
578 : : * acceptable period.
579 : : *
580 : : * The guarding period begins when EC_FLAGS_QUERY_PENDING is
581 : : * flagged, which means SCI_EVT check has just been performed.
582 : : * But if the current transaction is ACPI_EC_COMMAND_QUERY, the
583 : : * guarding should have already been performed (via
584 : : * EC_FLAGS_QUERY_GUARDING) and should not be applied so that the
585 : : * ACPI_EC_COMMAND_QUERY transaction can be transitioned into
586 : : * ACPI_EC_COMMAND_POLL state immediately.
587 : : */
588 [ # # ]: 0 : if (ec_event_clearing == ACPI_EC_EVT_TIMING_STATUS ||
589 [ # # ]: 0 : ec_event_clearing == ACPI_EC_EVT_TIMING_QUERY ||
590 : 0 : !test_bit(EC_FLAGS_QUERY_PENDING, &ec->flags) ||
591 [ # # # # ]: 0 : (ec->curr && ec->curr->command == ACPI_EC_COMMAND_QUERY))
592 : : guarded = false;
593 : 0 : spin_unlock_irqrestore(&ec->lock, flags);
594 : 0 : return guarded;
595 : : }
596 : :
597 : 0 : static int ec_transaction_polled(struct acpi_ec *ec)
598 : : {
599 : 0 : unsigned long flags;
600 : 0 : int ret = 0;
601 : :
602 : 0 : spin_lock_irqsave(&ec->lock, flags);
603 [ # # ]: 0 : if (ec->curr && (ec->curr->flags & ACPI_EC_COMMAND_POLL))
604 : : ret = 1;
605 : 0 : spin_unlock_irqrestore(&ec->lock, flags);
606 : 0 : return ret;
607 : : }
608 : :
609 : 0 : static int ec_transaction_completed(struct acpi_ec *ec)
610 : : {
611 : 0 : unsigned long flags;
612 : 0 : int ret = 0;
613 : :
614 : 0 : spin_lock_irqsave(&ec->lock, flags);
615 [ # # # # ]: 0 : if (ec->curr && (ec->curr->flags & ACPI_EC_COMMAND_COMPLETE))
616 : 0 : ret = 1;
617 : 0 : spin_unlock_irqrestore(&ec->lock, flags);
618 : 0 : return ret;
619 : : }
620 : :
621 : 0 : static inline void ec_transaction_transition(struct acpi_ec *ec, unsigned long flag)
622 : : {
623 : 0 : ec->curr->flags |= flag;
624 [ # # ]: 0 : if (ec->curr->command == ACPI_EC_COMMAND_QUERY) {
625 [ # # # # ]: 0 : if (ec_event_clearing == ACPI_EC_EVT_TIMING_STATUS &&
626 : : flag == ACPI_EC_COMMAND_POLL)
627 : 0 : acpi_ec_complete_query(ec);
628 [ # # # # ]: 0 : if (ec_event_clearing == ACPI_EC_EVT_TIMING_QUERY &&
629 : : flag == ACPI_EC_COMMAND_COMPLETE)
630 : 0 : acpi_ec_complete_query(ec);
631 [ # # # # ]: 0 : if (ec_event_clearing == ACPI_EC_EVT_TIMING_EVENT &&
632 : : flag == ACPI_EC_COMMAND_COMPLETE)
633 : 0 : set_bit(EC_FLAGS_QUERY_GUARDING, &ec->flags);
634 : : }
635 : 0 : }
636 : :
637 : 0 : static void advance_transaction(struct acpi_ec *ec)
638 : : {
639 : 0 : struct transaction *t;
640 : 0 : u8 status;
641 : 0 : bool wakeup = false;
642 : :
643 : 0 : ec_dbg_stm("%s (%d)", in_interrupt() ? "IRQ" : "TASK",
644 : : smp_processor_id());
645 : : /*
646 : : * By always clearing STS before handling all indications, we can
647 : : * ensure a hardware STS 0->1 change after this clearing can always
648 : : * trigger a GPE interrupt.
649 : : */
650 [ # # ]: 0 : if (ec->gpe >= 0)
651 : 0 : acpi_ec_clear_gpe(ec);
652 : :
653 : 0 : status = acpi_ec_read_status(ec);
654 : 0 : t = ec->curr;
655 : : /*
656 : : * Another IRQ or a guarded polling mode advancement is detected,
657 : : * the next QR_EC submission is then allowed.
658 : : */
659 [ # # # # ]: 0 : if (!t || !(t->flags & ACPI_EC_COMMAND_POLL)) {
660 [ # # ]: 0 : if (ec_event_clearing == ACPI_EC_EVT_TIMING_EVENT &&
661 [ # # # # ]: 0 : (!ec->nr_pending_queries ||
662 : 0 : test_bit(EC_FLAGS_QUERY_GUARDING, &ec->flags))) {
663 : 0 : clear_bit(EC_FLAGS_QUERY_GUARDING, &ec->flags);
664 : 0 : acpi_ec_complete_query(ec);
665 : : }
666 : : }
667 [ # # ]: 0 : if (!t)
668 : 0 : goto err;
669 [ # # ]: 0 : if (t->flags & ACPI_EC_COMMAND_POLL) {
670 [ # # ]: 0 : if (t->wlen > t->wi) {
671 [ # # ]: 0 : if ((status & ACPI_EC_FLAG_IBF) == 0)
672 : 0 : acpi_ec_write_data(ec, t->wdata[t->wi++]);
673 : : else
674 : 0 : goto err;
675 [ # # ]: 0 : } else if (t->rlen > t->ri) {
676 [ # # ]: 0 : if ((status & ACPI_EC_FLAG_OBF) == 1) {
677 : 0 : t->rdata[t->ri++] = acpi_ec_read_data(ec);
678 [ # # ]: 0 : if (t->rlen == t->ri) {
679 : 0 : ec_transaction_transition(ec, ACPI_EC_COMMAND_COMPLETE);
680 : 0 : if (t->command == ACPI_EC_COMMAND_QUERY)
681 : : ec_dbg_evt("Command(%s) completed by hardware",
682 : : acpi_ec_cmd_string(ACPI_EC_COMMAND_QUERY));
683 : : wakeup = true;
684 : : }
685 : : } else
686 : 0 : goto err;
687 [ # # # # ]: 0 : } else if (t->wlen == t->wi &&
688 : : (status & ACPI_EC_FLAG_IBF) == 0) {
689 : 0 : ec_transaction_transition(ec, ACPI_EC_COMMAND_COMPLETE);
690 : 0 : wakeup = true;
691 : : }
692 : 0 : goto out;
693 : : } else {
694 [ # # # # ]: 0 : if (EC_FLAGS_QUERY_HANDSHAKE &&
695 : 0 : !(status & ACPI_EC_FLAG_SCI) &&
696 [ # # ]: 0 : (t->command == ACPI_EC_COMMAND_QUERY)) {
697 : 0 : ec_transaction_transition(ec, ACPI_EC_COMMAND_POLL);
698 : 0 : t->rdata[t->ri++] = 0x00;
699 : 0 : ec_transaction_transition(ec, ACPI_EC_COMMAND_COMPLETE);
700 : 0 : ec_dbg_evt("Command(%s) completed by software",
701 : : acpi_ec_cmd_string(ACPI_EC_COMMAND_QUERY));
702 : 0 : wakeup = true;
703 [ # # ]: 0 : } else if ((status & ACPI_EC_FLAG_IBF) == 0) {
704 : 0 : acpi_ec_write_cmd(ec, t->command);
705 : 0 : ec_transaction_transition(ec, ACPI_EC_COMMAND_POLL);
706 : : } else
707 : 0 : goto err;
708 : 0 : goto out;
709 : : }
710 : 0 : err:
711 : : /*
712 : : * If SCI bit is set, then don't think it's a false IRQ
713 : : * otherwise will take a not handled IRQ as a false one.
714 : : */
715 [ # # ]: 0 : if (!(status & ACPI_EC_FLAG_SCI)) {
716 [ # # # # ]: 0 : if (in_interrupt() && t) {
717 [ # # ]: 0 : if (t->irq_count < ec_storm_threshold)
718 : 0 : ++t->irq_count;
719 : : /* Allow triggering on 0 threshold */
720 [ # # ]: 0 : if (t->irq_count == ec_storm_threshold)
721 : 0 : acpi_ec_mask_events(ec);
722 : : }
723 : : }
724 : 0 : out:
725 [ # # ]: 0 : if (status & ACPI_EC_FLAG_SCI)
726 : 0 : acpi_ec_submit_query(ec);
727 [ # # # # ]: 0 : if (wakeup && in_interrupt())
728 : 0 : wake_up(&ec->wait);
729 : 0 : }
730 : :
731 : 0 : static void start_transaction(struct acpi_ec *ec)
732 : : {
733 : 0 : ec->curr->irq_count = ec->curr->wi = ec->curr->ri = 0;
734 : 0 : ec->curr->flags = 0;
735 : : }
736 : :
737 : 0 : static int ec_guard(struct acpi_ec *ec)
738 : : {
739 [ # # ]: 0 : unsigned long guard = usecs_to_jiffies(ec->polling_guard);
740 : 0 : unsigned long timeout = ec->timestamp + guard;
741 : :
742 : : /* Ensure guarding period before polling EC status */
743 : 0 : do {
744 [ # # ]: 0 : if (ec->busy_polling) {
745 : : /* Perform busy polling */
746 [ # # ]: 0 : if (ec_transaction_completed(ec))
747 : : return 0;
748 : 0 : udelay(jiffies_to_usecs(guard));
749 : : } else {
750 : : /*
751 : : * Perform wait polling
752 : : * 1. Wait the transaction to be completed by the
753 : : * GPE handler after the transaction enters
754 : : * ACPI_EC_COMMAND_POLL state.
755 : : * 2. A special guarding logic is also required
756 : : * for event clearing mode "event" before the
757 : : * transaction enters ACPI_EC_COMMAND_POLL
758 : : * state.
759 : : */
760 [ # # # # ]: 0 : if (!ec_transaction_polled(ec) &&
761 : 0 : !acpi_ec_guard_event(ec))
762 : : break;
763 [ # # # # : 0 : if (wait_event_timeout(ec->wait,
# # # # #
# ]
764 : : ec_transaction_completed(ec),
765 : : guard))
766 : : return 0;
767 : : }
768 [ # # ]: 0 : } while (time_before(jiffies, timeout));
769 : : return -ETIME;
770 : : }
771 : :
772 : 0 : static int ec_poll(struct acpi_ec *ec)
773 : : {
774 : 0 : unsigned long flags;
775 : 0 : int repeat = 5; /* number of command restarts */
776 : :
777 [ # # ]: 0 : while (repeat--) {
778 : 0 : unsigned long delay = jiffies +
779 [ # # ]: 0 : msecs_to_jiffies(ec_delay);
780 : 0 : do {
781 [ # # ]: 0 : if (!ec_guard(ec))
782 : : return 0;
783 : 0 : spin_lock_irqsave(&ec->lock, flags);
784 : 0 : advance_transaction(ec);
785 : 0 : spin_unlock_irqrestore(&ec->lock, flags);
786 [ # # ]: 0 : } while (time_before(jiffies, delay));
787 : 0 : pr_debug("controller reset, restart transaction\n");
788 : 0 : spin_lock_irqsave(&ec->lock, flags);
789 : 0 : start_transaction(ec);
790 : 0 : spin_unlock_irqrestore(&ec->lock, flags);
791 : : }
792 : : return -ETIME;
793 : : }
794 : :
795 : 0 : static int acpi_ec_transaction_unlocked(struct acpi_ec *ec,
796 : : struct transaction *t)
797 : : {
798 : 0 : unsigned long tmp;
799 : 0 : int ret = 0;
800 : :
801 : : /* start transaction */
802 : 0 : spin_lock_irqsave(&ec->lock, tmp);
803 : : /* Enable GPE for command processing (IBF=0/OBF=1) */
804 : 0 : if (!acpi_ec_submit_flushable_request(ec)) {
805 : 0 : ret = -EINVAL;
806 : 0 : goto unlock;
807 : : }
808 : 0 : ec_dbg_ref(ec, "Increase command");
809 : : /* following two actions should be kept atomic */
810 : 0 : ec->curr = t;
811 : 0 : ec_dbg_req("Command(%s) started", acpi_ec_cmd_string(t->command));
812 : 0 : start_transaction(ec);
813 : 0 : spin_unlock_irqrestore(&ec->lock, tmp);
814 : :
815 : 0 : ret = ec_poll(ec);
816 : :
817 : 0 : spin_lock_irqsave(&ec->lock, tmp);
818 [ # # ]: 0 : if (t->irq_count == ec_storm_threshold)
819 : 0 : acpi_ec_unmask_events(ec);
820 : 0 : ec_dbg_req("Command(%s) stopped", acpi_ec_cmd_string(t->command));
821 : 0 : ec->curr = NULL;
822 : : /* Disable GPE for command processing (IBF=0/OBF=1) */
823 : 0 : acpi_ec_complete_request(ec);
824 : 0 : ec_dbg_ref(ec, "Decrease command");
825 : 0 : unlock:
826 : 0 : spin_unlock_irqrestore(&ec->lock, tmp);
827 : 0 : return ret;
828 : : }
829 : :
830 : 0 : static int acpi_ec_transaction(struct acpi_ec *ec, struct transaction *t)
831 : : {
832 : 0 : int status;
833 : 0 : u32 glk;
834 : :
835 [ # # # # : 0 : if (!ec || (!t) || (t->wlen && !t->wdata) || (t->rlen && !t->rdata))
# # # # #
# ]
836 : : return -EINVAL;
837 [ # # ]: 0 : if (t->rdata)
838 : 0 : memset(t->rdata, 0, t->rlen);
839 : :
840 : 0 : mutex_lock(&ec->mutex);
841 [ # # ]: 0 : if (ec->global_lock) {
842 : 0 : status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
843 [ # # ]: 0 : if (ACPI_FAILURE(status)) {
844 : 0 : status = -ENODEV;
845 : 0 : goto unlock;
846 : : }
847 : : }
848 : :
849 : 0 : status = acpi_ec_transaction_unlocked(ec, t);
850 : :
851 [ # # ]: 0 : if (ec->global_lock)
852 : 0 : acpi_release_global_lock(glk);
853 : 0 : unlock:
854 : 0 : mutex_unlock(&ec->mutex);
855 : 0 : return status;
856 : : }
857 : :
858 : 0 : static int acpi_ec_burst_enable(struct acpi_ec *ec)
859 : : {
860 : 0 : u8 d;
861 : 0 : struct transaction t = {.command = ACPI_EC_BURST_ENABLE,
862 : : .wdata = NULL, .rdata = &d,
863 : : .wlen = 0, .rlen = 1};
864 : :
865 : 0 : return acpi_ec_transaction(ec, &t);
866 : : }
867 : :
868 : 0 : static int acpi_ec_burst_disable(struct acpi_ec *ec)
869 : : {
870 : 0 : struct transaction t = {.command = ACPI_EC_BURST_DISABLE,
871 : : .wdata = NULL, .rdata = NULL,
872 : : .wlen = 0, .rlen = 0};
873 : :
874 : 0 : return (acpi_ec_read_status(ec) & ACPI_EC_FLAG_BURST) ?
875 [ # # ]: 0 : acpi_ec_transaction(ec, &t) : 0;
876 : : }
877 : :
878 : 0 : static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 *data)
879 : : {
880 : 0 : int result;
881 : 0 : u8 d;
882 : 0 : struct transaction t = {.command = ACPI_EC_COMMAND_READ,
883 : : .wdata = &address, .rdata = &d,
884 : : .wlen = 1, .rlen = 1};
885 : :
886 : 0 : result = acpi_ec_transaction(ec, &t);
887 : 0 : *data = d;
888 : 0 : return result;
889 : : }
890 : :
891 : 0 : static int acpi_ec_write(struct acpi_ec *ec, u8 address, u8 data)
892 : : {
893 : 0 : u8 wdata[2] = { address, data };
894 : 0 : struct transaction t = {.command = ACPI_EC_COMMAND_WRITE,
895 : : .wdata = wdata, .rdata = NULL,
896 : : .wlen = 2, .rlen = 0};
897 : :
898 : 0 : return acpi_ec_transaction(ec, &t);
899 : : }
900 : :
901 : 0 : int ec_read(u8 addr, u8 *val)
902 : : {
903 : 0 : int err;
904 : 0 : u8 temp_data;
905 : :
906 [ # # ]: 0 : if (!first_ec)
907 : : return -ENODEV;
908 : :
909 : 0 : err = acpi_ec_read(first_ec, addr, &temp_data);
910 : :
911 [ # # ]: 0 : if (!err) {
912 : 0 : *val = temp_data;
913 : 0 : return 0;
914 : : }
915 : : return err;
916 : : }
917 : : EXPORT_SYMBOL(ec_read);
918 : :
919 : 0 : int ec_write(u8 addr, u8 val)
920 : : {
921 : 0 : int err;
922 : :
923 [ # # ]: 0 : if (!first_ec)
924 : : return -ENODEV;
925 : :
926 : 0 : err = acpi_ec_write(first_ec, addr, val);
927 : :
928 : 0 : return err;
929 : : }
930 : : EXPORT_SYMBOL(ec_write);
931 : :
932 : 0 : int ec_transaction(u8 command,
933 : : const u8 *wdata, unsigned wdata_len,
934 : : u8 *rdata, unsigned rdata_len)
935 : : {
936 : 0 : struct transaction t = {.command = command,
937 : : .wdata = wdata, .rdata = rdata,
938 : : .wlen = wdata_len, .rlen = rdata_len};
939 : :
940 [ # # ]: 0 : if (!first_ec)
941 : : return -ENODEV;
942 : :
943 : 0 : return acpi_ec_transaction(first_ec, &t);
944 : : }
945 : : EXPORT_SYMBOL(ec_transaction);
946 : :
947 : : /* Get the handle to the EC device */
948 : 0 : acpi_handle ec_get_handle(void)
949 : : {
950 [ # # ]: 0 : if (!first_ec)
951 : : return NULL;
952 : 0 : return first_ec->handle;
953 : : }
954 : : EXPORT_SYMBOL(ec_get_handle);
955 : :
956 : 0 : static void acpi_ec_start(struct acpi_ec *ec, bool resuming)
957 : : {
958 : 0 : unsigned long flags;
959 : :
960 : 0 : spin_lock_irqsave(&ec->lock, flags);
961 [ # # ]: 0 : if (!test_and_set_bit(EC_FLAGS_STARTED, &ec->flags)) {
962 : 0 : ec_dbg_drv("Starting EC");
963 : : /* Enable GPE for event processing (SCI_EVT=1) */
964 [ # # ]: 0 : if (!resuming) {
965 : 0 : acpi_ec_submit_request(ec);
966 : 0 : ec_dbg_ref(ec, "Increase driver");
967 : : }
968 : 0 : ec_log_drv("EC started");
969 : : }
970 : 0 : spin_unlock_irqrestore(&ec->lock, flags);
971 : 0 : }
972 : :
973 : 0 : static bool acpi_ec_stopped(struct acpi_ec *ec)
974 : : {
975 : 0 : unsigned long flags;
976 : 0 : bool flushed;
977 : :
978 : 0 : spin_lock_irqsave(&ec->lock, flags);
979 : 0 : flushed = acpi_ec_flushed(ec);
980 : 0 : spin_unlock_irqrestore(&ec->lock, flags);
981 : 0 : return flushed;
982 : : }
983 : :
984 : 0 : static void acpi_ec_stop(struct acpi_ec *ec, bool suspending)
985 : : {
986 : 0 : unsigned long flags;
987 : :
988 : 0 : spin_lock_irqsave(&ec->lock, flags);
989 [ # # ]: 0 : if (acpi_ec_started(ec)) {
990 : 0 : ec_dbg_drv("Stopping EC");
991 : 0 : set_bit(EC_FLAGS_STOPPED, &ec->flags);
992 : 0 : spin_unlock_irqrestore(&ec->lock, flags);
993 [ # # # # ]: 0 : wait_event(ec->wait, acpi_ec_stopped(ec));
994 : 0 : spin_lock_irqsave(&ec->lock, flags);
995 : : /* Disable GPE for event processing (SCI_EVT=1) */
996 [ # # ]: 0 : if (!suspending) {
997 : 0 : acpi_ec_complete_request(ec);
998 : 0 : ec_dbg_ref(ec, "Decrease driver");
999 [ # # ]: 0 : } else if (!ec_freeze_events)
1000 : 0 : __acpi_ec_disable_event(ec);
1001 : 0 : clear_bit(EC_FLAGS_STARTED, &ec->flags);
1002 : 0 : clear_bit(EC_FLAGS_STOPPED, &ec->flags);
1003 : 0 : ec_log_drv("EC stopped");
1004 : : }
1005 : 0 : spin_unlock_irqrestore(&ec->lock, flags);
1006 : 0 : }
1007 : :
1008 : 0 : static void acpi_ec_enter_noirq(struct acpi_ec *ec)
1009 : : {
1010 : 0 : unsigned long flags;
1011 : :
1012 : 0 : spin_lock_irqsave(&ec->lock, flags);
1013 : 0 : ec->busy_polling = true;
1014 : 0 : ec->polling_guard = 0;
1015 : 0 : ec_log_drv("interrupt blocked");
1016 : 0 : spin_unlock_irqrestore(&ec->lock, flags);
1017 : 0 : }
1018 : :
1019 : 0 : static void acpi_ec_leave_noirq(struct acpi_ec *ec)
1020 : : {
1021 : 0 : unsigned long flags;
1022 : :
1023 : 0 : spin_lock_irqsave(&ec->lock, flags);
1024 : 0 : ec->busy_polling = ec_busy_polling;
1025 : 0 : ec->polling_guard = ec_polling_guard;
1026 : 0 : ec_log_drv("interrupt unblocked");
1027 : 0 : spin_unlock_irqrestore(&ec->lock, flags);
1028 : 0 : }
1029 : :
1030 : 0 : void acpi_ec_block_transactions(void)
1031 : : {
1032 : 0 : struct acpi_ec *ec = first_ec;
1033 : :
1034 [ # # ]: 0 : if (!ec)
1035 : : return;
1036 : :
1037 : 0 : mutex_lock(&ec->mutex);
1038 : : /* Prevent transactions from being carried out */
1039 : 0 : acpi_ec_stop(ec, true);
1040 : 0 : mutex_unlock(&ec->mutex);
1041 : : }
1042 : :
1043 : 0 : void acpi_ec_unblock_transactions(void)
1044 : : {
1045 : : /*
1046 : : * Allow transactions to happen again (this function is called from
1047 : : * atomic context during wakeup, so we don't need to acquire the mutex).
1048 : : */
1049 [ # # ]: 0 : if (first_ec)
1050 : 0 : acpi_ec_start(first_ec, true);
1051 : 0 : }
1052 : :
1053 : : /* --------------------------------------------------------------------------
1054 : : Event Management
1055 : : -------------------------------------------------------------------------- */
1056 : : static struct acpi_ec_query_handler *
1057 : 0 : acpi_ec_get_query_handler_by_value(struct acpi_ec *ec, u8 value)
1058 : : {
1059 : 0 : struct acpi_ec_query_handler *handler;
1060 : :
1061 : 0 : mutex_lock(&ec->mutex);
1062 [ # # ]: 0 : list_for_each_entry(handler, &ec->list, node) {
1063 [ # # ]: 0 : if (value == handler->query_bit) {
1064 : 0 : kref_get(&handler->kref);
1065 : 0 : mutex_unlock(&ec->mutex);
1066 : 0 : return handler;
1067 : : }
1068 : : }
1069 : 0 : mutex_unlock(&ec->mutex);
1070 : 0 : return NULL;
1071 : : }
1072 : :
1073 : 0 : static void acpi_ec_query_handler_release(struct kref *kref)
1074 : : {
1075 : 0 : struct acpi_ec_query_handler *handler =
1076 : 0 : container_of(kref, struct acpi_ec_query_handler, kref);
1077 : :
1078 : 0 : kfree(handler);
1079 : 0 : }
1080 : :
1081 : 0 : static void acpi_ec_put_query_handler(struct acpi_ec_query_handler *handler)
1082 : : {
1083 : 0 : kref_put(&handler->kref, acpi_ec_query_handler_release);
1084 : 0 : }
1085 : :
1086 : 0 : int acpi_ec_add_query_handler(struct acpi_ec *ec, u8 query_bit,
1087 : : acpi_handle handle, acpi_ec_query_func func,
1088 : : void *data)
1089 : : {
1090 : 0 : struct acpi_ec_query_handler *handler =
1091 : : kzalloc(sizeof(struct acpi_ec_query_handler), GFP_KERNEL);
1092 : :
1093 [ # # ]: 0 : if (!handler)
1094 : : return -ENOMEM;
1095 : :
1096 : 0 : handler->query_bit = query_bit;
1097 : 0 : handler->handle = handle;
1098 : 0 : handler->func = func;
1099 : 0 : handler->data = data;
1100 : 0 : mutex_lock(&ec->mutex);
1101 : 0 : kref_init(&handler->kref);
1102 : 0 : list_add(&handler->node, &ec->list);
1103 : 0 : mutex_unlock(&ec->mutex);
1104 : 0 : return 0;
1105 : : }
1106 : : EXPORT_SYMBOL_GPL(acpi_ec_add_query_handler);
1107 : :
1108 : 0 : static void acpi_ec_remove_query_handlers(struct acpi_ec *ec,
1109 : : bool remove_all, u8 query_bit)
1110 : : {
1111 : 0 : struct acpi_ec_query_handler *handler, *tmp;
1112 : 0 : LIST_HEAD(free_list);
1113 : :
1114 : 0 : mutex_lock(&ec->mutex);
1115 [ # # ]: 0 : list_for_each_entry_safe(handler, tmp, &ec->list, node) {
1116 [ # # # # ]: 0 : if (remove_all || query_bit == handler->query_bit) {
1117 : 0 : list_del_init(&handler->node);
1118 : 0 : list_add(&handler->node, &free_list);
1119 : : }
1120 : : }
1121 : 0 : mutex_unlock(&ec->mutex);
1122 [ # # ]: 0 : list_for_each_entry_safe(handler, tmp, &free_list, node)
1123 : 0 : acpi_ec_put_query_handler(handler);
1124 : 0 : }
1125 : :
1126 : 0 : void acpi_ec_remove_query_handler(struct acpi_ec *ec, u8 query_bit)
1127 : : {
1128 : 0 : acpi_ec_remove_query_handlers(ec, false, query_bit);
1129 : 0 : }
1130 : : EXPORT_SYMBOL_GPL(acpi_ec_remove_query_handler);
1131 : :
1132 : 0 : static struct acpi_ec_query *acpi_ec_create_query(u8 *pval)
1133 : : {
1134 : 0 : struct acpi_ec_query *q;
1135 : 0 : struct transaction *t;
1136 : :
1137 : 0 : q = kzalloc(sizeof (struct acpi_ec_query), GFP_KERNEL);
1138 [ # # ]: 0 : if (!q)
1139 : : return NULL;
1140 : 0 : INIT_WORK(&q->work, acpi_ec_event_processor);
1141 : 0 : t = &q->transaction;
1142 : 0 : t->command = ACPI_EC_COMMAND_QUERY;
1143 : 0 : t->rdata = pval;
1144 : 0 : t->rlen = 1;
1145 : 0 : return q;
1146 : : }
1147 : :
1148 : 0 : static void acpi_ec_delete_query(struct acpi_ec_query *q)
1149 : : {
1150 [ # # ]: 0 : if (q) {
1151 [ # # ]: 0 : if (q->handler)
1152 : 0 : acpi_ec_put_query_handler(q->handler);
1153 : 0 : kfree(q);
1154 : : }
1155 : 0 : }
1156 : :
1157 : 0 : static void acpi_ec_event_processor(struct work_struct *work)
1158 : : {
1159 : 0 : struct acpi_ec_query *q = container_of(work, struct acpi_ec_query, work);
1160 : 0 : struct acpi_ec_query_handler *handler = q->handler;
1161 : :
1162 : 0 : ec_dbg_evt("Query(0x%02x) started", handler->query_bit);
1163 [ # # ]: 0 : if (handler->func)
1164 : 0 : handler->func(handler->data);
1165 [ # # ]: 0 : else if (handler->handle)
1166 : 0 : acpi_evaluate_object(handler->handle, NULL, NULL, NULL);
1167 : 0 : ec_dbg_evt("Query(0x%02x) stopped", handler->query_bit);
1168 : 0 : acpi_ec_delete_query(q);
1169 : 0 : }
1170 : :
1171 : 0 : static int acpi_ec_query(struct acpi_ec *ec, u8 *data)
1172 : : {
1173 : 0 : u8 value = 0;
1174 : 0 : int result;
1175 : 0 : struct acpi_ec_query *q;
1176 : :
1177 : 0 : q = acpi_ec_create_query(&value);
1178 [ # # ]: 0 : if (!q)
1179 : : return -ENOMEM;
1180 : :
1181 : : /*
1182 : : * Query the EC to find out which _Qxx method we need to evaluate.
1183 : : * Note that successful completion of the query causes the ACPI_EC_SCI
1184 : : * bit to be cleared (and thus clearing the interrupt source).
1185 : : */
1186 : 0 : result = acpi_ec_transaction(ec, &q->transaction);
1187 [ # # ]: 0 : if (!value)
1188 : : result = -ENODATA;
1189 [ # # ]: 0 : if (result)
1190 : 0 : goto err_exit;
1191 : :
1192 : 0 : q->handler = acpi_ec_get_query_handler_by_value(ec, value);
1193 [ # # ]: 0 : if (!q->handler) {
1194 : 0 : result = -ENODATA;
1195 : 0 : goto err_exit;
1196 : : }
1197 : :
1198 : : /*
1199 : : * It is reported that _Qxx are evaluated in a parallel way on
1200 : : * Windows:
1201 : : * https://bugzilla.kernel.org/show_bug.cgi?id=94411
1202 : : *
1203 : : * Put this log entry before schedule_work() in order to make
1204 : : * it appearing before any other log entries occurred during the
1205 : : * work queue execution.
1206 : : */
1207 : 0 : ec_dbg_evt("Query(0x%02x) scheduled", value);
1208 [ # # ]: 0 : if (!queue_work(ec_query_wq, &q->work)) {
1209 : : ec_dbg_evt("Query(0x%02x) overlapped", value);
1210 : : result = -EBUSY;
1211 : : }
1212 : :
1213 : 0 : err_exit:
1214 [ # # ]: 0 : if (result)
1215 : 0 : acpi_ec_delete_query(q);
1216 [ # # ]: 0 : if (data)
1217 : 0 : *data = value;
1218 : : return result;
1219 : : }
1220 : :
1221 : 0 : static void acpi_ec_check_event(struct acpi_ec *ec)
1222 : : {
1223 : 0 : unsigned long flags;
1224 : :
1225 [ # # ]: 0 : if (ec_event_clearing == ACPI_EC_EVT_TIMING_EVENT) {
1226 [ # # ]: 0 : if (ec_guard(ec)) {
1227 : 0 : spin_lock_irqsave(&ec->lock, flags);
1228 : : /*
1229 : : * Take care of the SCI_EVT unless no one else is
1230 : : * taking care of it.
1231 : : */
1232 [ # # ]: 0 : if (!ec->curr)
1233 : 0 : advance_transaction(ec);
1234 : 0 : spin_unlock_irqrestore(&ec->lock, flags);
1235 : : }
1236 : : }
1237 : 0 : }
1238 : :
1239 : 0 : static void acpi_ec_event_handler(struct work_struct *work)
1240 : : {
1241 : 0 : unsigned long flags;
1242 : 0 : struct acpi_ec *ec = container_of(work, struct acpi_ec, work);
1243 : :
1244 : 0 : ec_dbg_evt("Event started");
1245 : :
1246 : 0 : spin_lock_irqsave(&ec->lock, flags);
1247 [ # # ]: 0 : while (ec->nr_pending_queries) {
1248 : 0 : spin_unlock_irqrestore(&ec->lock, flags);
1249 : 0 : (void)acpi_ec_query(ec, NULL);
1250 : 0 : spin_lock_irqsave(&ec->lock, flags);
1251 : 0 : ec->nr_pending_queries--;
1252 : : /*
1253 : : * Before exit, make sure that this work item can be
1254 : : * scheduled again. There might be QR_EC failures, leaving
1255 : : * EC_FLAGS_QUERY_PENDING uncleared and preventing this work
1256 : : * item from being scheduled again.
1257 : : */
1258 [ # # ]: 0 : if (!ec->nr_pending_queries) {
1259 [ # # ]: 0 : if (ec_event_clearing == ACPI_EC_EVT_TIMING_STATUS ||
1260 : : ec_event_clearing == ACPI_EC_EVT_TIMING_QUERY)
1261 : 0 : acpi_ec_complete_query(ec);
1262 : : }
1263 : : }
1264 : 0 : spin_unlock_irqrestore(&ec->lock, flags);
1265 : :
1266 : 0 : ec_dbg_evt("Event stopped");
1267 : :
1268 : 0 : acpi_ec_check_event(ec);
1269 : 0 : }
1270 : :
1271 : 0 : static void acpi_ec_handle_interrupt(struct acpi_ec *ec)
1272 : : {
1273 : 0 : unsigned long flags;
1274 : :
1275 : 0 : spin_lock_irqsave(&ec->lock, flags);
1276 : 0 : advance_transaction(ec);
1277 : 0 : spin_unlock_irqrestore(&ec->lock, flags);
1278 : 0 : }
1279 : :
1280 : 0 : static u32 acpi_ec_gpe_handler(acpi_handle gpe_device,
1281 : : u32 gpe_number, void *data)
1282 : : {
1283 : 0 : acpi_ec_handle_interrupt(data);
1284 : 0 : return ACPI_INTERRUPT_HANDLED;
1285 : : }
1286 : :
1287 : : static irqreturn_t acpi_ec_irq_handler(int irq, void *data)
1288 : : {
1289 : : acpi_ec_handle_interrupt(data);
1290 : : return IRQ_HANDLED;
1291 : : }
1292 : :
1293 : : /* --------------------------------------------------------------------------
1294 : : * Address Space Management
1295 : : * -------------------------------------------------------------------------- */
1296 : :
1297 : : static acpi_status
1298 : 0 : acpi_ec_space_handler(u32 function, acpi_physical_address address,
1299 : : u32 bits, u64 *value64,
1300 : : void *handler_context, void *region_context)
1301 : : {
1302 : 0 : struct acpi_ec *ec = handler_context;
1303 : 0 : int result = 0, i, bytes = bits / 8;
1304 : 0 : u8 *value = (u8 *)value64;
1305 : :
1306 [ # # # # ]: 0 : if ((address > 0xFF) || !value || !handler_context)
1307 : : return AE_BAD_PARAMETER;
1308 : :
1309 [ # # ]: 0 : if (function != ACPI_READ && function != ACPI_WRITE)
1310 : : return AE_BAD_PARAMETER;
1311 : :
1312 [ # # # # ]: 0 : if (ec->busy_polling || bits > 8)
1313 : 0 : acpi_ec_burst_enable(ec);
1314 : :
1315 [ # # ]: 0 : for (i = 0; i < bytes; ++i, ++address, ++value)
1316 : 0 : result = (function == ACPI_READ) ?
1317 [ # # ]: 0 : acpi_ec_read(ec, address, value) :
1318 : 0 : acpi_ec_write(ec, address, *value);
1319 : :
1320 [ # # # # ]: 0 : if (ec->busy_polling || bits > 8)
1321 : 0 : acpi_ec_burst_disable(ec);
1322 : :
1323 [ # # # # ]: 0 : switch (result) {
1324 : : case -EINVAL:
1325 : : return AE_BAD_PARAMETER;
1326 : 0 : case -ENODEV:
1327 : 0 : return AE_NOT_FOUND;
1328 : 0 : case -ETIME:
1329 : 0 : return AE_TIME;
1330 : 0 : default:
1331 : 0 : return AE_OK;
1332 : : }
1333 : : }
1334 : :
1335 : : /* --------------------------------------------------------------------------
1336 : : * Driver Interface
1337 : : * -------------------------------------------------------------------------- */
1338 : :
1339 : : static acpi_status
1340 : : ec_parse_io_ports(struct acpi_resource *resource, void *context);
1341 : :
1342 : 28 : static void acpi_ec_free(struct acpi_ec *ec)
1343 : : {
1344 [ - + ]: 28 : if (first_ec == ec)
1345 : 0 : first_ec = NULL;
1346 [ - + ]: 28 : if (boot_ec == ec)
1347 : 0 : boot_ec = NULL;
1348 : 28 : kfree(ec);
1349 : 28 : }
1350 : :
1351 : 28 : static struct acpi_ec *acpi_ec_alloc(void)
1352 : : {
1353 : 28 : struct acpi_ec *ec = kzalloc(sizeof(struct acpi_ec), GFP_KERNEL);
1354 : :
1355 [ + - ]: 28 : if (!ec)
1356 : : return NULL;
1357 : 28 : mutex_init(&ec->mutex);
1358 : 28 : init_waitqueue_head(&ec->wait);
1359 : 28 : INIT_LIST_HEAD(&ec->list);
1360 : 28 : spin_lock_init(&ec->lock);
1361 : 28 : INIT_WORK(&ec->work, acpi_ec_event_handler);
1362 : 28 : ec->timestamp = jiffies;
1363 : 28 : ec->busy_polling = true;
1364 : 28 : ec->polling_guard = 0;
1365 : 28 : ec->gpe = -1;
1366 : 28 : ec->irq = -1;
1367 : 28 : return ec;
1368 : : }
1369 : :
1370 : : static acpi_status
1371 : 0 : acpi_ec_register_query_methods(acpi_handle handle, u32 level,
1372 : : void *context, void **return_value)
1373 : : {
1374 : 0 : char node_name[5];
1375 : 0 : struct acpi_buffer buffer = { sizeof(node_name), node_name };
1376 : 0 : struct acpi_ec *ec = context;
1377 : 0 : int value = 0;
1378 : 0 : acpi_status status;
1379 : :
1380 : 0 : status = acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer);
1381 : :
1382 [ # # # # ]: 0 : if (ACPI_SUCCESS(status) && sscanf(node_name, "_Q%x", &value) == 1)
1383 : 0 : acpi_ec_add_query_handler(ec, value, handle, NULL, NULL);
1384 : 0 : return AE_OK;
1385 : : }
1386 : :
1387 : : static acpi_status
1388 : 0 : ec_parse_device(acpi_handle handle, u32 Level, void *context, void **retval)
1389 : : {
1390 : 0 : acpi_status status;
1391 : 0 : unsigned long long tmp = 0;
1392 : 0 : struct acpi_ec *ec = context;
1393 : :
1394 : : /* clear addr values, ec_parse_io_ports depend on it */
1395 : 0 : ec->command_addr = ec->data_addr = 0;
1396 : :
1397 : 0 : status = acpi_walk_resources(handle, METHOD_NAME__CRS,
1398 : : ec_parse_io_ports, ec);
1399 [ # # ]: 0 : if (ACPI_FAILURE(status))
1400 : : return status;
1401 [ # # # # ]: 0 : if (ec->data_addr == 0 || ec->command_addr == 0)
1402 : : return AE_OK;
1403 : :
1404 [ # # # # : 0 : if (boot_ec && boot_ec_is_ecdt && EC_FLAGS_IGNORE_DSDT_GPE) {
# # ]
1405 : : /*
1406 : : * Always inherit the GPE number setting from the ECDT
1407 : : * EC.
1408 : : */
1409 : 0 : ec->gpe = boot_ec->gpe;
1410 : : } else {
1411 : : /* Get GPE bit assignment (EC events). */
1412 : : /* TODO: Add support for _GPE returning a package */
1413 : 0 : status = acpi_evaluate_integer(handle, "_GPE", NULL, &tmp);
1414 [ # # ]: 0 : if (ACPI_SUCCESS(status))
1415 : 0 : ec->gpe = tmp;
1416 : :
1417 : : /*
1418 : : * Errors are non-fatal, allowing for ACPI Reduced Hardware
1419 : : * platforms which use GpioInt instead of GPE.
1420 : : */
1421 : : }
1422 : : /* Use the global lock for all EC transactions? */
1423 : 0 : tmp = 0;
1424 : 0 : acpi_evaluate_integer(handle, "_GLK", NULL, &tmp);
1425 : 0 : ec->global_lock = tmp;
1426 : 0 : ec->handle = handle;
1427 : 0 : return AE_CTRL_TERMINATE;
1428 : : }
1429 : :
1430 : 0 : static void install_gpe_event_handler(struct acpi_ec *ec)
1431 : : {
1432 : 0 : acpi_status status =
1433 : 0 : acpi_install_gpe_raw_handler(NULL, ec->gpe,
1434 : : ACPI_GPE_EDGE_TRIGGERED,
1435 : : &acpi_ec_gpe_handler,
1436 : : ec);
1437 [ # # ]: 0 : if (ACPI_SUCCESS(status)) {
1438 : : /* This is not fatal as we can poll EC events */
1439 : 0 : set_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags);
1440 : 0 : acpi_ec_leave_noirq(ec);
1441 [ # # ]: 0 : if (test_bit(EC_FLAGS_STARTED, &ec->flags) &&
1442 [ # # ]: 0 : ec->reference_count >= 1)
1443 : 0 : acpi_ec_enable_gpe(ec, true);
1444 : : }
1445 : 0 : }
1446 : :
1447 : : /* ACPI reduced hardware platforms use a GpioInt specified in _CRS. */
1448 : : static int install_gpio_irq_event_handler(struct acpi_ec *ec,
1449 : : struct acpi_device *device)
1450 : : {
1451 : : int irq = acpi_dev_gpio_irq_get(device, 0);
1452 : : int ret;
1453 : :
1454 : : if (irq < 0)
1455 : : return irq;
1456 : :
1457 : : ret = request_irq(irq, acpi_ec_irq_handler, IRQF_SHARED,
1458 : : "ACPI EC", ec);
1459 : :
1460 : : /*
1461 : : * Unlike the GPE case, we treat errors here as fatal, we'll only
1462 : : * implement GPIO polling if we find a case that needs it.
1463 : : */
1464 : : if (ret < 0)
1465 : : return ret;
1466 : :
1467 : : ec->irq = irq;
1468 : : set_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags);
1469 : : acpi_ec_leave_noirq(ec);
1470 : :
1471 : : return 0;
1472 : : }
1473 : :
1474 : : /*
1475 : : * Note: This function returns an error code only when the address space
1476 : : * handler is not installed, which means "not able to handle
1477 : : * transactions".
1478 : : */
1479 : 0 : static int ec_install_handlers(struct acpi_ec *ec, struct acpi_device *device,
1480 : : bool handle_events)
1481 : : {
1482 : 0 : acpi_status status;
1483 : :
1484 : 0 : acpi_ec_start(ec, false);
1485 : :
1486 [ # # ]: 0 : if (!test_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags)) {
1487 : 0 : acpi_ec_enter_noirq(ec);
1488 : 0 : status = acpi_install_address_space_handler(ec->handle,
1489 : : ACPI_ADR_SPACE_EC,
1490 : : &acpi_ec_space_handler,
1491 : : NULL, ec);
1492 [ # # ]: 0 : if (ACPI_FAILURE(status)) {
1493 [ # # ]: 0 : if (status == AE_NOT_FOUND) {
1494 : : /*
1495 : : * Maybe OS fails in evaluating the _REG
1496 : : * object. The AE_NOT_FOUND error will be
1497 : : * ignored and OS * continue to initialize
1498 : : * EC.
1499 : : */
1500 : 0 : pr_err("Fail in evaluating the _REG object"
1501 : : " of EC device. Broken bios is suspected.\n");
1502 : : } else {
1503 : 0 : acpi_ec_stop(ec, false);
1504 : 0 : return -ENODEV;
1505 : : }
1506 : : }
1507 : 0 : set_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags);
1508 : : }
1509 : :
1510 [ # # ]: 0 : if (!handle_events)
1511 : : return 0;
1512 : :
1513 [ # # ]: 0 : if (!test_bit(EC_FLAGS_QUERY_METHODS_INSTALLED, &ec->flags)) {
1514 : : /* Find and register all query methods */
1515 : 0 : acpi_walk_namespace(ACPI_TYPE_METHOD, ec->handle, 1,
1516 : : acpi_ec_register_query_methods,
1517 : : NULL, ec, NULL);
1518 : 0 : set_bit(EC_FLAGS_QUERY_METHODS_INSTALLED, &ec->flags);
1519 : : }
1520 [ # # ]: 0 : if (!test_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags)) {
1521 [ # # ]: 0 : if (ec->gpe >= 0) {
1522 : 0 : install_gpe_event_handler(ec);
1523 [ # # ]: 0 : } else if (device) {
1524 : : int ret = install_gpio_irq_event_handler(ec, device);
1525 : :
1526 : : if (ret)
1527 : : return ret;
1528 : : } else { /* No GPE and no GpioInt? */
1529 : 0 : return -ENODEV;
1530 : : }
1531 : : }
1532 : : /* EC is fully operational, allow queries */
1533 : 0 : acpi_ec_enable_event(ec);
1534 : :
1535 : 0 : return 0;
1536 : : }
1537 : :
1538 : 0 : static void ec_remove_handlers(struct acpi_ec *ec)
1539 : : {
1540 [ # # ]: 0 : if (test_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags)) {
1541 [ # # ]: 0 : if (ACPI_FAILURE(acpi_remove_address_space_handler(ec->handle,
1542 : : ACPI_ADR_SPACE_EC, &acpi_ec_space_handler)))
1543 : 0 : pr_err("failed to remove space handler\n");
1544 : 0 : clear_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags);
1545 : : }
1546 : :
1547 : : /*
1548 : : * Stops handling the EC transactions after removing the operation
1549 : : * region handler. This is required because _REG(DISCONNECT)
1550 : : * invoked during the removal can result in new EC transactions.
1551 : : *
1552 : : * Flushes the EC requests and thus disables the GPE before
1553 : : * removing the GPE handler. This is required by the current ACPICA
1554 : : * GPE core. ACPICA GPE core will automatically disable a GPE when
1555 : : * it is indicated but there is no way to handle it. So the drivers
1556 : : * must disable the GPEs prior to removing the GPE handlers.
1557 : : */
1558 : 0 : acpi_ec_stop(ec, false);
1559 : :
1560 [ # # ]: 0 : if (test_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags)) {
1561 [ # # # # ]: 0 : if (ec->gpe >= 0 &&
1562 : 0 : ACPI_FAILURE(acpi_remove_gpe_handler(NULL, ec->gpe,
1563 : : &acpi_ec_gpe_handler)))
1564 : 0 : pr_err("failed to remove gpe handler\n");
1565 : :
1566 [ # # ]: 0 : if (ec->irq >= 0)
1567 : 0 : free_irq(ec->irq, ec);
1568 : :
1569 : 0 : clear_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags);
1570 : : }
1571 [ # # ]: 0 : if (test_bit(EC_FLAGS_QUERY_METHODS_INSTALLED, &ec->flags)) {
1572 : 0 : acpi_ec_remove_query_handlers(ec, true, 0);
1573 : 0 : clear_bit(EC_FLAGS_QUERY_METHODS_INSTALLED, &ec->flags);
1574 : : }
1575 : 0 : }
1576 : :
1577 : 0 : static int acpi_ec_setup(struct acpi_ec *ec, struct acpi_device *device,
1578 : : bool handle_events)
1579 : : {
1580 : 0 : int ret;
1581 : :
1582 : 0 : ret = ec_install_handlers(ec, device, handle_events);
1583 [ # # ]: 0 : if (ret)
1584 : : return ret;
1585 : :
1586 : : /* First EC capable of handling transactions */
1587 [ # # ]: 0 : if (!first_ec) {
1588 : 0 : first_ec = ec;
1589 : 0 : acpi_handle_info(first_ec->handle, "Used as first EC\n");
1590 : : }
1591 : :
1592 : 0 : acpi_handle_info(ec->handle,
1593 : : "GPE=0x%x, IRQ=%d, EC_CMD/EC_SC=0x%lx, EC_DATA=0x%lx\n",
1594 : : ec->gpe, ec->irq, ec->command_addr, ec->data_addr);
1595 : 0 : return ret;
1596 : : }
1597 : :
1598 : 0 : static bool acpi_ec_ecdt_get_handle(acpi_handle *phandle)
1599 : : {
1600 : 0 : struct acpi_table_ecdt *ecdt_ptr;
1601 : 0 : acpi_status status;
1602 : 0 : acpi_handle handle;
1603 : :
1604 : 0 : status = acpi_get_table(ACPI_SIG_ECDT, 1,
1605 : : (struct acpi_table_header **)&ecdt_ptr);
1606 [ # # ]: 0 : if (ACPI_FAILURE(status))
1607 : : return false;
1608 : :
1609 : 0 : status = acpi_get_handle(NULL, ecdt_ptr->id, &handle);
1610 [ # # ]: 0 : if (ACPI_FAILURE(status))
1611 : : return false;
1612 : :
1613 : 0 : *phandle = handle;
1614 : 0 : return true;
1615 : : }
1616 : :
1617 : 0 : static int acpi_ec_add(struct acpi_device *device)
1618 : : {
1619 : 0 : struct acpi_ec *ec = NULL;
1620 : 0 : bool dep_update = true;
1621 : 0 : acpi_status status;
1622 : 0 : int ret;
1623 : :
1624 : 0 : strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
1625 : 0 : strcpy(acpi_device_class(device), ACPI_EC_CLASS);
1626 : :
1627 [ # # ]: 0 : if (!strcmp(acpi_device_hid(device), ACPI_ECDT_HID)) {
1628 : 0 : boot_ec_is_ecdt = true;
1629 : 0 : ec = boot_ec;
1630 : 0 : dep_update = false;
1631 : : } else {
1632 : 0 : ec = acpi_ec_alloc();
1633 [ # # ]: 0 : if (!ec)
1634 : : return -ENOMEM;
1635 : :
1636 : 0 : status = ec_parse_device(device->handle, 0, ec, NULL);
1637 [ # # ]: 0 : if (status != AE_CTRL_TERMINATE) {
1638 : 0 : ret = -EINVAL;
1639 : 0 : goto err_alloc;
1640 : : }
1641 : :
1642 [ # # # # ]: 0 : if (boot_ec && ec->command_addr == boot_ec->command_addr &&
1643 [ # # ]: 0 : ec->data_addr == boot_ec->data_addr) {
1644 : 0 : boot_ec_is_ecdt = false;
1645 : : /*
1646 : : * Trust PNP0C09 namespace location rather than
1647 : : * ECDT ID. But trust ECDT GPE rather than _GPE
1648 : : * because of ASUS quirks, so do not change
1649 : : * boot_ec->gpe to ec->gpe.
1650 : : */
1651 : 0 : boot_ec->handle = ec->handle;
1652 : 0 : acpi_handle_debug(ec->handle, "duplicated.\n");
1653 : 0 : acpi_ec_free(ec);
1654 : 0 : ec = boot_ec;
1655 : : }
1656 : : }
1657 : :
1658 : 0 : ret = acpi_ec_setup(ec, device, true);
1659 [ # # ]: 0 : if (ret)
1660 : 0 : goto err_query;
1661 : :
1662 [ # # ]: 0 : if (ec == boot_ec)
1663 [ # # ]: 0 : acpi_handle_info(boot_ec->handle,
1664 : : "Boot %s EC used to handle transactions and events\n",
1665 : : boot_ec_is_ecdt ? "ECDT" : "DSDT");
1666 : :
1667 : 0 : device->driver_data = ec;
1668 : :
1669 : 0 : ret = !!request_region(ec->data_addr, 1, "EC data");
1670 [ # # ]: 0 : WARN(!ret, "Could not request EC data io port 0x%lx", ec->data_addr);
1671 : 0 : ret = !!request_region(ec->command_addr, 1, "EC cmd");
1672 [ # # ]: 0 : WARN(!ret, "Could not request EC cmd io port 0x%lx", ec->command_addr);
1673 : :
1674 [ # # ]: 0 : if (dep_update) {
1675 : : /* Reprobe devices depending on the EC */
1676 : 0 : acpi_walk_dep_device_list(ec->handle);
1677 : : }
1678 : : acpi_handle_debug(ec->handle, "enumerated.\n");
1679 : : return 0;
1680 : :
1681 : : err_query:
1682 [ # # ]: 0 : if (ec != boot_ec)
1683 : 0 : acpi_ec_remove_query_handlers(ec, true, 0);
1684 : 0 : err_alloc:
1685 [ # # ]: 0 : if (ec != boot_ec)
1686 : 0 : acpi_ec_free(ec);
1687 : : return ret;
1688 : : }
1689 : :
1690 : 0 : static int acpi_ec_remove(struct acpi_device *device)
1691 : : {
1692 : 0 : struct acpi_ec *ec;
1693 : :
1694 [ # # ]: 0 : if (!device)
1695 : : return -EINVAL;
1696 : :
1697 : 0 : ec = acpi_driver_data(device);
1698 : 0 : release_region(ec->data_addr, 1);
1699 : 0 : release_region(ec->command_addr, 1);
1700 : 0 : device->driver_data = NULL;
1701 [ # # ]: 0 : if (ec != boot_ec) {
1702 : 0 : ec_remove_handlers(ec);
1703 : 0 : acpi_ec_free(ec);
1704 : : }
1705 : : return 0;
1706 : : }
1707 : :
1708 : : static acpi_status
1709 : 0 : ec_parse_io_ports(struct acpi_resource *resource, void *context)
1710 : : {
1711 : 0 : struct acpi_ec *ec = context;
1712 : :
1713 [ # # ]: 0 : if (resource->type != ACPI_RESOURCE_TYPE_IO)
1714 : : return AE_OK;
1715 : :
1716 : : /*
1717 : : * The first address region returned is the data port, and
1718 : : * the second address region returned is the status/command
1719 : : * port.
1720 : : */
1721 [ # # ]: 0 : if (ec->data_addr == 0)
1722 : 0 : ec->data_addr = resource->data.io.minimum;
1723 [ # # ]: 0 : else if (ec->command_addr == 0)
1724 : 0 : ec->command_addr = resource->data.io.minimum;
1725 : : else
1726 : : return AE_CTRL_TERMINATE;
1727 : :
1728 : : return AE_OK;
1729 : : }
1730 : :
1731 : : static const struct acpi_device_id ec_device_ids[] = {
1732 : : {"PNP0C09", 0},
1733 : : {ACPI_ECDT_HID, 0},
1734 : : {"", 0},
1735 : : };
1736 : :
1737 : : /*
1738 : : * This function is not Windows-compatible as Windows never enumerates the
1739 : : * namespace EC before the main ACPI device enumeration process. It is
1740 : : * retained for historical reason and will be deprecated in the future.
1741 : : */
1742 : 28 : void __init acpi_ec_dsdt_probe(void)
1743 : : {
1744 : 28 : struct acpi_ec *ec;
1745 : 28 : acpi_status status;
1746 : 28 : int ret;
1747 : :
1748 : : /*
1749 : : * If a platform has ECDT, there is no need to proceed as the
1750 : : * following probe is not a part of the ACPI device enumeration,
1751 : : * executing _STA is not safe, and thus this probe may risk of
1752 : : * picking up an invalid EC device.
1753 : : */
1754 [ + - ]: 28 : if (boot_ec)
1755 : : return;
1756 : :
1757 : 28 : ec = acpi_ec_alloc();
1758 [ + - ]: 28 : if (!ec)
1759 : : return;
1760 : :
1761 : : /*
1762 : : * At this point, the namespace is initialized, so start to find
1763 : : * the namespace objects.
1764 : : */
1765 : 28 : status = acpi_get_devices(ec_device_ids[0].id, ec_parse_device, ec, NULL);
1766 [ + - + - ]: 28 : if (ACPI_FAILURE(status) || !ec->handle) {
1767 : 28 : acpi_ec_free(ec);
1768 : 28 : return;
1769 : : }
1770 : :
1771 : : /*
1772 : : * When the DSDT EC is available, always re-configure boot EC to
1773 : : * have _REG evaluated. _REG can only be evaluated after the
1774 : : * namespace initialization.
1775 : : * At this point, the GPE is not fully initialized, so do not to
1776 : : * handle the events.
1777 : : */
1778 : 0 : ret = acpi_ec_setup(ec, NULL, false);
1779 [ # # ]: 0 : if (ret) {
1780 : 0 : acpi_ec_free(ec);
1781 : 0 : return;
1782 : : }
1783 : :
1784 : 0 : boot_ec = ec;
1785 : :
1786 : 0 : acpi_handle_info(ec->handle,
1787 : : "Boot DSDT EC used to handle transactions\n");
1788 : : }
1789 : :
1790 : : /*
1791 : : * If the DSDT EC is not functioning, we still need to prepare a fully
1792 : : * functioning ECDT EC first in order to handle the events.
1793 : : * https://bugzilla.kernel.org/show_bug.cgi?id=115021
1794 : : */
1795 : 28 : static int __init acpi_ec_ecdt_start(void)
1796 : : {
1797 : 28 : acpi_handle handle;
1798 : :
1799 [ - + ]: 28 : if (!boot_ec)
1800 : : return -ENODEV;
1801 : : /* In case acpi_ec_ecdt_start() is called after acpi_ec_add() */
1802 [ # # ]: 0 : if (!boot_ec_is_ecdt)
1803 : : return -ENODEV;
1804 : :
1805 : : /*
1806 : : * At this point, the namespace and the GPE is initialized, so
1807 : : * start to find the namespace objects and handle the events.
1808 : : *
1809 : : * Note: ec->handle can be valid if this function is called after
1810 : : * acpi_ec_add(), hence the fast path.
1811 : : */
1812 [ # # ]: 0 : if (boot_ec->handle == ACPI_ROOT_OBJECT) {
1813 [ # # ]: 0 : if (!acpi_ec_ecdt_get_handle(&handle))
1814 : : return -ENODEV;
1815 : 0 : boot_ec->handle = handle;
1816 : : }
1817 : :
1818 : : /* Register to ACPI bus with PM ops attached */
1819 : 0 : return acpi_bus_register_early_device(ACPI_BUS_TYPE_ECDT_EC);
1820 : : }
1821 : :
1822 : : #if 0
1823 : : /*
1824 : : * Some EC firmware variations refuses to respond QR_EC when SCI_EVT is not
1825 : : * set, for which case, we complete the QR_EC without issuing it to the
1826 : : * firmware.
1827 : : * https://bugzilla.kernel.org/show_bug.cgi?id=82611
1828 : : * https://bugzilla.kernel.org/show_bug.cgi?id=97381
1829 : : */
1830 : : static int ec_flag_query_handshake(const struct dmi_system_id *id)
1831 : : {
1832 : : pr_debug("Detected the EC firmware requiring QR_EC issued when SCI_EVT set\n");
1833 : : EC_FLAGS_QUERY_HANDSHAKE = 1;
1834 : : return 0;
1835 : : }
1836 : : #endif
1837 : :
1838 : : /*
1839 : : * On some hardware it is necessary to clear events accumulated by the EC during
1840 : : * sleep. These ECs stop reporting GPEs until they are manually polled, if too
1841 : : * many events are accumulated. (e.g. Samsung Series 5/9 notebooks)
1842 : : *
1843 : : * https://bugzilla.kernel.org/show_bug.cgi?id=44161
1844 : : *
1845 : : * Ideally, the EC should also be instructed NOT to accumulate events during
1846 : : * sleep (which Windows seems to do somehow), but the interface to control this
1847 : : * behaviour is not known at this time.
1848 : : *
1849 : : * Models known to be affected are Samsung 530Uxx/535Uxx/540Uxx/550Pxx/900Xxx,
1850 : : * however it is very likely that other Samsung models are affected.
1851 : : *
1852 : : * On systems which don't accumulate _Q events during sleep, this extra check
1853 : : * should be harmless.
1854 : : */
1855 : 0 : static int ec_clear_on_resume(const struct dmi_system_id *id)
1856 : : {
1857 : 0 : pr_debug("Detected system needing EC poll on resume.\n");
1858 : 0 : EC_FLAGS_CLEAR_ON_RESUME = 1;
1859 : 0 : ec_event_clearing = ACPI_EC_EVT_TIMING_STATUS;
1860 : 0 : return 0;
1861 : : }
1862 : :
1863 : : /*
1864 : : * Some ECDTs contain wrong register addresses.
1865 : : * MSI MS-171F
1866 : : * https://bugzilla.kernel.org/show_bug.cgi?id=12461
1867 : : */
1868 : 0 : static int ec_correct_ecdt(const struct dmi_system_id *id)
1869 : : {
1870 : 0 : pr_debug("Detected system needing ECDT address correction.\n");
1871 : 0 : EC_FLAGS_CORRECT_ECDT = 1;
1872 : 0 : return 0;
1873 : : }
1874 : :
1875 : : /*
1876 : : * Some DSDTs contain wrong GPE setting.
1877 : : * Asus FX502VD/VE, GL702VMK, X550VXK, X580VD
1878 : : * https://bugzilla.kernel.org/show_bug.cgi?id=195651
1879 : : */
1880 : 0 : static int ec_honor_ecdt_gpe(const struct dmi_system_id *id)
1881 : : {
1882 : 0 : pr_debug("Detected system needing ignore DSDT GPE setting.\n");
1883 : 0 : EC_FLAGS_IGNORE_DSDT_GPE = 1;
1884 : 0 : return 0;
1885 : : }
1886 : :
1887 : : static const struct dmi_system_id ec_dmi_table[] __initconst = {
1888 : : {
1889 : : ec_correct_ecdt, "MSI MS-171F", {
1890 : : DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star"),
1891 : : DMI_MATCH(DMI_PRODUCT_NAME, "MS-171F"),}, NULL},
1892 : : {
1893 : : ec_honor_ecdt_gpe, "ASUS FX502VD", {
1894 : : DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
1895 : : DMI_MATCH(DMI_PRODUCT_NAME, "FX502VD"),}, NULL},
1896 : : {
1897 : : ec_honor_ecdt_gpe, "ASUS FX502VE", {
1898 : : DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
1899 : : DMI_MATCH(DMI_PRODUCT_NAME, "FX502VE"),}, NULL},
1900 : : {
1901 : : ec_honor_ecdt_gpe, "ASUS GL702VMK", {
1902 : : DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
1903 : : DMI_MATCH(DMI_PRODUCT_NAME, "GL702VMK"),}, NULL},
1904 : : {
1905 : : ec_honor_ecdt_gpe, "ASUS X550VXK", {
1906 : : DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
1907 : : DMI_MATCH(DMI_PRODUCT_NAME, "X550VXK"),}, NULL},
1908 : : {
1909 : : ec_honor_ecdt_gpe, "ASUS X580VD", {
1910 : : DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
1911 : : DMI_MATCH(DMI_PRODUCT_NAME, "X580VD"),}, NULL},
1912 : : {
1913 : : ec_clear_on_resume, "Samsung hardware", {
1914 : : DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD.")}, NULL},
1915 : : {},
1916 : : };
1917 : :
1918 : 28 : void __init acpi_ec_ecdt_probe(void)
1919 : : {
1920 : 28 : struct acpi_table_ecdt *ecdt_ptr;
1921 : 28 : struct acpi_ec *ec;
1922 : 28 : acpi_status status;
1923 : 28 : int ret;
1924 : :
1925 : : /* Generate a boot ec context. */
1926 : 28 : dmi_check_system(ec_dmi_table);
1927 : 28 : status = acpi_get_table(ACPI_SIG_ECDT, 1,
1928 : : (struct acpi_table_header **)&ecdt_ptr);
1929 [ - + ]: 28 : if (ACPI_FAILURE(status))
1930 : 28 : return;
1931 : :
1932 [ # # # # ]: 0 : if (!ecdt_ptr->control.address || !ecdt_ptr->data.address) {
1933 : : /*
1934 : : * Asus X50GL:
1935 : : * https://bugzilla.kernel.org/show_bug.cgi?id=11880
1936 : : */
1937 : : return;
1938 : : }
1939 : :
1940 : 0 : ec = acpi_ec_alloc();
1941 [ # # ]: 0 : if (!ec)
1942 : : return;
1943 : :
1944 [ # # ]: 0 : if (EC_FLAGS_CORRECT_ECDT) {
1945 : 0 : ec->command_addr = ecdt_ptr->data.address;
1946 : 0 : ec->data_addr = ecdt_ptr->control.address;
1947 : : } else {
1948 : 0 : ec->command_addr = ecdt_ptr->control.address;
1949 : 0 : ec->data_addr = ecdt_ptr->data.address;
1950 : : }
1951 : :
1952 : : /*
1953 : : * Ignore the GPE value on Reduced Hardware platforms.
1954 : : * Some products have this set to an erroneous value.
1955 : : */
1956 [ # # ]: 0 : if (!acpi_gbl_reduced_hardware)
1957 : 0 : ec->gpe = ecdt_ptr->gpe;
1958 : :
1959 : 0 : ec->handle = ACPI_ROOT_OBJECT;
1960 : :
1961 : : /*
1962 : : * At this point, the namespace is not initialized, so do not find
1963 : : * the namespace objects, or handle the events.
1964 : : */
1965 : 0 : ret = acpi_ec_setup(ec, NULL, false);
1966 [ # # ]: 0 : if (ret) {
1967 : 0 : acpi_ec_free(ec);
1968 : 0 : return;
1969 : : }
1970 : :
1971 : 0 : boot_ec = ec;
1972 : 0 : boot_ec_is_ecdt = true;
1973 : :
1974 : 0 : pr_info("Boot ECDT EC used to handle transactions\n");
1975 : : }
1976 : :
1977 : : #ifdef CONFIG_PM_SLEEP
1978 : 0 : static int acpi_ec_suspend(struct device *dev)
1979 : : {
1980 : 0 : struct acpi_ec *ec =
1981 [ # # ]: 0 : acpi_driver_data(to_acpi_device(dev));
1982 : :
1983 [ # # # # ]: 0 : if (!pm_suspend_no_platform() && ec_freeze_events)
1984 : 0 : acpi_ec_disable_event(ec);
1985 : 0 : return 0;
1986 : : }
1987 : :
1988 : 0 : static int acpi_ec_suspend_noirq(struct device *dev)
1989 : : {
1990 [ # # ]: 0 : struct acpi_ec *ec = acpi_driver_data(to_acpi_device(dev));
1991 : :
1992 : : /*
1993 : : * The SCI handler doesn't run at this point, so the GPE can be
1994 : : * masked at the low level without side effects.
1995 : : */
1996 [ # # # # ]: 0 : if (ec_no_wakeup && test_bit(EC_FLAGS_STARTED, &ec->flags) &&
1997 [ # # # # ]: 0 : ec->gpe >= 0 && ec->reference_count >= 1)
1998 : 0 : acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_DISABLE);
1999 : :
2000 : 0 : acpi_ec_enter_noirq(ec);
2001 : :
2002 : 0 : return 0;
2003 : : }
2004 : :
2005 : 0 : static int acpi_ec_resume_noirq(struct device *dev)
2006 : : {
2007 : 0 : struct acpi_ec *ec = acpi_driver_data(to_acpi_device(dev));
2008 : :
2009 : 0 : acpi_ec_leave_noirq(ec);
2010 : :
2011 [ # # # # ]: 0 : if (ec_no_wakeup && test_bit(EC_FLAGS_STARTED, &ec->flags) &&
2012 [ # # # # ]: 0 : ec->gpe >= 0 && ec->reference_count >= 1)
2013 : 0 : acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_ENABLE);
2014 : :
2015 : 0 : return 0;
2016 : : }
2017 : :
2018 : 0 : static int acpi_ec_resume(struct device *dev)
2019 : : {
2020 : 0 : struct acpi_ec *ec =
2021 : 0 : acpi_driver_data(to_acpi_device(dev));
2022 : :
2023 : 0 : acpi_ec_enable_event(ec);
2024 : 0 : return 0;
2025 : : }
2026 : :
2027 : 0 : void acpi_ec_mark_gpe_for_wake(void)
2028 : : {
2029 [ # # # # ]: 0 : if (first_ec && !ec_no_wakeup)
2030 : 0 : acpi_mark_gpe_for_wake(NULL, first_ec->gpe);
2031 : 0 : }
2032 : : EXPORT_SYMBOL_GPL(acpi_ec_mark_gpe_for_wake);
2033 : :
2034 : 0 : void acpi_ec_set_gpe_wake_mask(u8 action)
2035 : : {
2036 [ # # # # : 0 : if (pm_suspend_no_platform() && first_ec && !ec_no_wakeup)
# # ]
2037 : 0 : acpi_set_gpe_wake_mask(NULL, first_ec->gpe, action);
2038 : 0 : }
2039 : :
2040 : 0 : bool acpi_ec_dispatch_gpe(void)
2041 : : {
2042 : 0 : u32 ret;
2043 : :
2044 [ # # ]: 0 : if (!first_ec)
2045 : : return false;
2046 : :
2047 : 0 : ret = acpi_dispatch_gpe(NULL, first_ec->gpe);
2048 [ # # ]: 0 : if (ret == ACPI_INTERRUPT_HANDLED) {
2049 : 0 : pm_pr_dbg("EC GPE dispatched\n");
2050 : 0 : return true;
2051 : : }
2052 : : return false;
2053 : : }
2054 : : #endif /* CONFIG_PM_SLEEP */
2055 : :
2056 : : static const struct dev_pm_ops acpi_ec_pm = {
2057 : : SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(acpi_ec_suspend_noirq, acpi_ec_resume_noirq)
2058 : : SET_SYSTEM_SLEEP_PM_OPS(acpi_ec_suspend, acpi_ec_resume)
2059 : : };
2060 : :
2061 : 0 : static int param_set_event_clearing(const char *val,
2062 : : const struct kernel_param *kp)
2063 : : {
2064 : 0 : int result = 0;
2065 : :
2066 [ # # ]: 0 : if (!strncmp(val, "status", sizeof("status") - 1)) {
2067 : 0 : ec_event_clearing = ACPI_EC_EVT_TIMING_STATUS;
2068 : 0 : pr_info("Assuming SCI_EVT clearing on EC_SC accesses\n");
2069 [ # # ]: 0 : } else if (!strncmp(val, "query", sizeof("query") - 1)) {
2070 : 0 : ec_event_clearing = ACPI_EC_EVT_TIMING_QUERY;
2071 : 0 : pr_info("Assuming SCI_EVT clearing on QR_EC writes\n");
2072 [ # # ]: 0 : } else if (!strncmp(val, "event", sizeof("event") - 1)) {
2073 : 0 : ec_event_clearing = ACPI_EC_EVT_TIMING_EVENT;
2074 : 0 : pr_info("Assuming SCI_EVT clearing on event reads\n");
2075 : : } else
2076 : : result = -EINVAL;
2077 : 0 : return result;
2078 : : }
2079 : :
2080 : 0 : static int param_get_event_clearing(char *buffer,
2081 : : const struct kernel_param *kp)
2082 : : {
2083 [ # # # # ]: 0 : switch (ec_event_clearing) {
2084 : 0 : case ACPI_EC_EVT_TIMING_STATUS:
2085 : 0 : return sprintf(buffer, "status");
2086 : 0 : case ACPI_EC_EVT_TIMING_QUERY:
2087 : 0 : return sprintf(buffer, "query");
2088 : 0 : case ACPI_EC_EVT_TIMING_EVENT:
2089 : 0 : return sprintf(buffer, "event");
2090 : 0 : default:
2091 : 0 : return sprintf(buffer, "invalid");
2092 : : }
2093 : : return 0;
2094 : : }
2095 : :
2096 : : module_param_call(ec_event_clearing, param_set_event_clearing, param_get_event_clearing,
2097 : : NULL, 0644);
2098 : : MODULE_PARM_DESC(ec_event_clearing, "Assumed SCI_EVT clearing timing");
2099 : :
2100 : : static struct acpi_driver acpi_ec_driver = {
2101 : : .name = "ec",
2102 : : .class = ACPI_EC_CLASS,
2103 : : .ids = ec_device_ids,
2104 : : .ops = {
2105 : : .add = acpi_ec_add,
2106 : : .remove = acpi_ec_remove,
2107 : : },
2108 : : .drv.pm = &acpi_ec_pm,
2109 : : };
2110 : :
2111 : 0 : static void acpi_ec_destroy_workqueues(void)
2112 : : {
2113 [ # # ]: 0 : if (ec_wq) {
2114 : 0 : destroy_workqueue(ec_wq);
2115 : 0 : ec_wq = NULL;
2116 : : }
2117 [ # # ]: 0 : if (ec_query_wq) {
2118 : 0 : destroy_workqueue(ec_query_wq);
2119 : 0 : ec_query_wq = NULL;
2120 : : }
2121 : 0 : }
2122 : :
2123 : 28 : static int acpi_ec_init_workqueues(void)
2124 : : {
2125 [ + - ]: 28 : if (!ec_wq)
2126 : 28 : ec_wq = alloc_ordered_workqueue("kec", 0);
2127 : :
2128 [ + - ]: 28 : if (!ec_query_wq)
2129 : 28 : ec_query_wq = alloc_workqueue("kec_query", 0, ec_max_queries);
2130 : :
2131 [ + - - + ]: 28 : if (!ec_wq || !ec_query_wq) {
2132 : 0 : acpi_ec_destroy_workqueues();
2133 : 0 : return -ENODEV;
2134 : : }
2135 : : return 0;
2136 : : }
2137 : :
2138 : : static const struct dmi_system_id acpi_ec_no_wakeup[] = {
2139 : : {
2140 : : .ident = "Thinkpad X1 Carbon 6th",
2141 : : .matches = {
2142 : : DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
2143 : : DMI_MATCH(DMI_PRODUCT_FAMILY, "Thinkpad X1 Carbon 6th"),
2144 : : },
2145 : : },
2146 : : {
2147 : : .ident = "ThinkPad X1 Carbon 6th",
2148 : : .matches = {
2149 : : DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
2150 : : DMI_MATCH(DMI_PRODUCT_FAMILY, "ThinkPad X1 Carbon 6th"),
2151 : : },
2152 : : },
2153 : : {
2154 : : .ident = "ThinkPad X1 Yoga 3rd",
2155 : : .matches = {
2156 : : DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
2157 : : DMI_MATCH(DMI_PRODUCT_FAMILY, "ThinkPad X1 Yoga 3rd"),
2158 : : },
2159 : : },
2160 : : { },
2161 : : };
2162 : :
2163 : 28 : int __init acpi_ec_init(void)
2164 : : {
2165 : 28 : int result;
2166 : 28 : int ecdt_fail, dsdt_fail;
2167 : :
2168 : 28 : result = acpi_ec_init_workqueues();
2169 [ + - ]: 28 : if (result)
2170 : : return result;
2171 : :
2172 : : /*
2173 : : * Disable EC wakeup on following systems to prevent periodic
2174 : : * wakeup from EC GPE.
2175 : : */
2176 [ - + ]: 28 : if (dmi_check_system(acpi_ec_no_wakeup)) {
2177 : 0 : ec_no_wakeup = true;
2178 : 0 : pr_debug("Disabling EC wakeup on suspend-to-idle\n");
2179 : : }
2180 : :
2181 : : /* Drivers must be started after acpi_ec_query_init() */
2182 : 28 : dsdt_fail = acpi_bus_register_driver(&acpi_ec_driver);
2183 : : /*
2184 : : * Register ECDT to ACPI bus only when PNP0C09 probe fails. This is
2185 : : * useful for platforms (confirmed on ASUS X550ZE) with valid ECDT
2186 : : * settings but invalid DSDT settings.
2187 : : * https://bugzilla.kernel.org/show_bug.cgi?id=196847
2188 : : */
2189 : 28 : ecdt_fail = acpi_ec_ecdt_start();
2190 [ + - ]: 28 : return ecdt_fail && dsdt_fail ? -ENODEV : 0;
2191 : : }
2192 : :
2193 : : /* EC driver currently not unloadable */
2194 : : #if 0
2195 : : static void __exit acpi_ec_exit(void)
2196 : : {
2197 : :
2198 : : acpi_bus_unregister_driver(&acpi_ec_driver);
2199 : : acpi_ec_destroy_workqueues();
2200 : : }
2201 : : #endif /* 0 */
|
