Lines Matching refs:ec
3 * ec.c - ACPI Embedded Controller Driver (v3)
108 /* ec.c is compiled in acpi namespace so this shows up as acpi.ec_delay param */
169 struct acpi_ec *ec;
172 static int acpi_ec_query(struct acpi_ec *ec, u8 *data);
173 static void advance_transaction(struct acpi_ec *ec);
230 #define ec_dbg_ref(ec, fmt, ...) \
231 ec_dbg_raw("%lu: " fmt, ec->reference_count, ## __VA_ARGS__)
237 static bool acpi_ec_started(struct acpi_ec *ec)
239 return test_bit(EC_FLAGS_STARTED, &ec->flags) &&
240 !test_bit(EC_FLAGS_STOPPED, &ec->flags);
243 static bool acpi_ec_event_enabled(struct acpi_ec *ec)
250 if (!test_bit(EC_FLAGS_QUERY_ENABLED, &ec->flags))
262 return acpi_ec_started(ec);
264 return test_bit(EC_FLAGS_STARTED, &ec->flags);
267 static bool acpi_ec_flushed(struct acpi_ec *ec)
269 return ec->reference_count == 1;
276 static inline u8 acpi_ec_read_status(struct acpi_ec *ec)
278 u8 x = inb(ec->command_addr);
291 static inline u8 acpi_ec_read_data(struct acpi_ec *ec)
293 u8 x = inb(ec->data_addr);
295 ec->timestamp = jiffies;
300 static inline void acpi_ec_write_cmd(struct acpi_ec *ec, u8 command)
303 outb(command, ec->command_addr);
304 ec->timestamp = jiffies;
307 static inline void acpi_ec_write_data(struct acpi_ec *ec, u8 data)
310 outb(data, ec->data_addr);
311 ec->timestamp = jiffies;
339 static inline bool acpi_ec_is_gpe_raised(struct acpi_ec *ec)
343 (void)acpi_get_gpe_status(NULL, ec->gpe, &gpe_status);
347 static inline void acpi_ec_enable_gpe(struct acpi_ec *ec, bool open)
350 acpi_enable_gpe(NULL, ec->gpe);
352 BUG_ON(ec->reference_count < 1);
353 acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_ENABLE);
355 if (acpi_ec_is_gpe_raised(ec)) {
362 advance_transaction(ec);
366 static inline void acpi_ec_disable_gpe(struct acpi_ec *ec, bool close)
369 acpi_disable_gpe(NULL, ec->gpe);
371 BUG_ON(ec->reference_count < 1);
372 acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_DISABLE);
376 static inline void acpi_ec_clear_gpe(struct acpi_ec *ec)
388 if (!acpi_ec_is_gpe_raised(ec))
390 acpi_clear_gpe(NULL, ec->gpe);
397 static void acpi_ec_submit_request(struct acpi_ec *ec)
399 ec->reference_count++;
400 if (test_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags) &&
401 ec->gpe >= 0 && ec->reference_count == 1)
402 acpi_ec_enable_gpe(ec, true);
405 static void acpi_ec_complete_request(struct acpi_ec *ec)
409 ec->reference_count--;
410 if (test_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags) &&
411 ec->gpe >= 0 && ec->reference_count == 0)
412 acpi_ec_disable_gpe(ec, true);
413 flushed = acpi_ec_flushed(ec);
415 wake_up(&ec->wait);
418 static void acpi_ec_mask_events(struct acpi_ec *ec)
420 if (!test_bit(EC_FLAGS_EVENTS_MASKED, &ec->flags)) {
421 if (ec->gpe >= 0)
422 acpi_ec_disable_gpe(ec, false);
424 disable_irq_nosync(ec->irq);
427 set_bit(EC_FLAGS_EVENTS_MASKED, &ec->flags);
431 static void acpi_ec_unmask_events(struct acpi_ec *ec)
433 if (test_bit(EC_FLAGS_EVENTS_MASKED, &ec->flags)) {
434 clear_bit(EC_FLAGS_EVENTS_MASKED, &ec->flags);
435 if (ec->gpe >= 0)
436 acpi_ec_enable_gpe(ec, false);
438 enable_irq(ec->irq);
448 * @ec: the EC device
455 static bool acpi_ec_submit_flushable_request(struct acpi_ec *ec)
457 if (!acpi_ec_started(ec))
459 acpi_ec_submit_request(ec);
463 static void acpi_ec_submit_query(struct acpi_ec *ec)
465 acpi_ec_mask_events(ec);
466 if (!acpi_ec_event_enabled(ec))
468 if (!test_and_set_bit(EC_FLAGS_QUERY_PENDING, &ec->flags)) {
471 ec->nr_pending_queries++;
472 ec->events_in_progress++;
473 queue_work(ec_wq, &ec->work);
477 static void acpi_ec_complete_query(struct acpi_ec *ec)
479 if (test_and_clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags))
482 acpi_ec_unmask_events(ec);
485 static inline void __acpi_ec_enable_event(struct acpi_ec *ec)
487 if (!test_and_set_bit(EC_FLAGS_QUERY_ENABLED, &ec->flags))
493 advance_transaction(ec);
496 static inline void __acpi_ec_disable_event(struct acpi_ec *ec)
498 if (test_and_clear_bit(EC_FLAGS_QUERY_ENABLED, &ec->flags))
504 * Run with locked ec mutex.
506 static void acpi_ec_clear(struct acpi_ec *ec)
512 status = acpi_ec_query(ec, &value);
522 static void acpi_ec_enable_event(struct acpi_ec *ec)
526 spin_lock_irqsave(&ec->lock, flags);
527 if (acpi_ec_started(ec))
528 __acpi_ec_enable_event(ec);
529 spin_unlock_irqrestore(&ec->lock, flags);
533 acpi_ec_clear(ec);
539 flush_workqueue(ec_wq); /* flush ec->work */
543 static void acpi_ec_disable_event(struct acpi_ec *ec)
547 spin_lock_irqsave(&ec->lock, flags);
548 __acpi_ec_disable_event(ec);
549 spin_unlock_irqrestore(&ec->lock, flags);
568 static bool acpi_ec_guard_event(struct acpi_ec *ec)
573 spin_lock_irqsave(&ec->lock, flags);
590 !test_bit(EC_FLAGS_QUERY_PENDING, &ec->flags) ||
591 (ec->curr && ec->curr->command == ACPI_EC_COMMAND_QUERY))
593 spin_unlock_irqrestore(&ec->lock, flags);
597 static int ec_transaction_polled(struct acpi_ec *ec)
602 spin_lock_irqsave(&ec->lock, flags);
603 if (ec->curr && (ec->curr->flags & ACPI_EC_COMMAND_POLL))
605 spin_unlock_irqrestore(&ec->lock, flags);
609 static int ec_transaction_completed(struct acpi_ec *ec)
614 spin_lock_irqsave(&ec->lock, flags);
615 if (ec->curr && (ec->curr->flags & ACPI_EC_COMMAND_COMPLETE))
617 spin_unlock_irqrestore(&ec->lock, flags);
621 static inline void ec_transaction_transition(struct acpi_ec *ec, unsigned long flag)
623 ec->curr->flags |= flag;
624 if (ec->curr->command == ACPI_EC_COMMAND_QUERY) {
627 acpi_ec_complete_query(ec);
630 acpi_ec_complete_query(ec);
633 set_bit(EC_FLAGS_QUERY_GUARDING, &ec->flags);
637 static void advance_transaction(struct acpi_ec *ec)
650 if (ec->gpe >= 0)
651 acpi_ec_clear_gpe(ec);
653 status = acpi_ec_read_status(ec);
654 t = ec->curr;
661 (!ec->nr_pending_queries ||
662 test_bit(EC_FLAGS_QUERY_GUARDING, &ec->flags))) {
663 clear_bit(EC_FLAGS_QUERY_GUARDING, &ec->flags);
664 acpi_ec_complete_query(ec);
672 acpi_ec_write_data(ec, t->wdata[t->wi++]);
677 t->rdata[t->ri++] = acpi_ec_read_data(ec);
679 ec_transaction_transition(ec, ACPI_EC_COMMAND_COMPLETE);
689 ec_transaction_transition(ec, ACPI_EC_COMMAND_COMPLETE);
694 acpi_ec_write_cmd(ec, t->command);
695 ec_transaction_transition(ec, ACPI_EC_COMMAND_POLL);
709 acpi_ec_mask_events(ec);
714 acpi_ec_submit_query(ec);
716 wake_up(&ec->wait);
719 static void start_transaction(struct acpi_ec *ec)
721 ec->curr->irq_count = ec->curr->wi = ec->curr->ri = 0;
722 ec->curr->flags = 0;
725 static int ec_guard(struct acpi_ec *ec)
727 unsigned long guard = usecs_to_jiffies(ec->polling_guard);
728 unsigned long timeout = ec->timestamp + guard;
732 if (ec->busy_polling) {
734 if (ec_transaction_completed(ec))
748 if (!ec_transaction_polled(ec) &&
749 !acpi_ec_guard_event(ec))
751 if (wait_event_timeout(ec->wait,
752 ec_transaction_completed(ec),
760 static int ec_poll(struct acpi_ec *ec)
769 if (!ec_guard(ec))
771 spin_lock_irqsave(&ec->lock, flags);
772 advance_transaction(ec);
773 spin_unlock_irqrestore(&ec->lock, flags);
776 spin_lock_irqsave(&ec->lock, flags);
777 start_transaction(ec);
778 spin_unlock_irqrestore(&ec->lock, flags);
783 static int acpi_ec_transaction_unlocked(struct acpi_ec *ec,
790 spin_lock_irqsave(&ec->lock, tmp);
792 if (!acpi_ec_submit_flushable_request(ec)) {
796 ec_dbg_ref(ec, "Increase command");
798 ec->curr = t;
800 start_transaction(ec);
801 spin_unlock_irqrestore(&ec->lock, tmp);
803 ret = ec_poll(ec);
805 spin_lock_irqsave(&ec->lock, tmp);
807 acpi_ec_unmask_events(ec);
809 ec->curr = NULL;
811 acpi_ec_complete_request(ec);
812 ec_dbg_ref(ec, "Decrease command");
814 spin_unlock_irqrestore(&ec->lock, tmp);
818 static int acpi_ec_transaction(struct acpi_ec *ec, struct transaction *t)
823 if (!ec || (!t) || (t->wlen && !t->wdata) || (t->rlen && !t->rdata))
828 mutex_lock(&ec->mutex);
829 if (ec->global_lock) {
837 status = acpi_ec_transaction_unlocked(ec, t);
839 if (ec->global_lock)
842 mutex_unlock(&ec->mutex);
846 static int acpi_ec_burst_enable(struct acpi_ec *ec)
853 return acpi_ec_transaction(ec, &t);
856 static int acpi_ec_burst_disable(struct acpi_ec *ec)
862 return (acpi_ec_read_status(ec) & ACPI_EC_FLAG_BURST) ?
863 acpi_ec_transaction(ec, &t) : 0;
866 static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 *data)
874 result = acpi_ec_transaction(ec, &t);
879 static int acpi_ec_write(struct acpi_ec *ec, u8 address, u8 data)
886 return acpi_ec_transaction(ec, &t);
944 static void acpi_ec_start(struct acpi_ec *ec, bool resuming)
948 spin_lock_irqsave(&ec->lock, flags);
949 if (!test_and_set_bit(EC_FLAGS_STARTED, &ec->flags)) {
953 acpi_ec_submit_request(ec);
954 ec_dbg_ref(ec, "Increase driver");
958 spin_unlock_irqrestore(&ec->lock, flags);
961 static bool acpi_ec_stopped(struct acpi_ec *ec)
966 spin_lock_irqsave(&ec->lock, flags);
967 flushed = acpi_ec_flushed(ec);
968 spin_unlock_irqrestore(&ec->lock, flags);
972 static void acpi_ec_stop(struct acpi_ec *ec, bool suspending)
976 spin_lock_irqsave(&ec->lock, flags);
977 if (acpi_ec_started(ec)) {
979 set_bit(EC_FLAGS_STOPPED, &ec->flags);
980 spin_unlock_irqrestore(&ec->lock, flags);
981 wait_event(ec->wait, acpi_ec_stopped(ec));
982 spin_lock_irqsave(&ec->lock, flags);
985 acpi_ec_complete_request(ec);
986 ec_dbg_ref(ec, "Decrease driver");
988 __acpi_ec_disable_event(ec);
989 clear_bit(EC_FLAGS_STARTED, &ec->flags);
990 clear_bit(EC_FLAGS_STOPPED, &ec->flags);
993 spin_unlock_irqrestore(&ec->lock, flags);
996 static void acpi_ec_enter_noirq(struct acpi_ec *ec)
1000 spin_lock_irqsave(&ec->lock, flags);
1001 ec->busy_polling = true;
1002 ec->polling_guard = 0;
1004 spin_unlock_irqrestore(&ec->lock, flags);
1007 static void acpi_ec_leave_noirq(struct acpi_ec *ec)
1011 spin_lock_irqsave(&ec->lock, flags);
1012 ec->busy_polling = ec_busy_polling;
1013 ec->polling_guard = ec_polling_guard;
1015 spin_unlock_irqrestore(&ec->lock, flags);
1020 struct acpi_ec *ec = first_ec;
1022 if (!ec)
1025 mutex_lock(&ec->mutex);
1027 acpi_ec_stop(ec, true);
1028 mutex_unlock(&ec->mutex);
1045 acpi_ec_get_query_handler_by_value(struct acpi_ec *ec, u8 value)
1049 mutex_lock(&ec->mutex);
1050 list_for_each_entry(handler, &ec->list, node) {
1053 mutex_unlock(&ec->mutex);
1057 mutex_unlock(&ec->mutex);
1074 int acpi_ec_add_query_handler(struct acpi_ec *ec, u8 query_bit,
1088 mutex_lock(&ec->mutex);
1090 list_add(&handler->node, &ec->list);
1091 mutex_unlock(&ec->mutex);
1096 static void acpi_ec_remove_query_handlers(struct acpi_ec *ec,
1102 mutex_lock(&ec->mutex);
1103 list_for_each_entry_safe(handler, tmp, &ec->list, node) {
1109 mutex_unlock(&ec->mutex);
1114 void acpi_ec_remove_query_handler(struct acpi_ec *ec, u8 query_bit)
1116 acpi_ec_remove_query_handlers(ec, false, query_bit);
1121 static struct acpi_ec_query *acpi_ec_create_query(struct acpi_ec *ec, u8 *pval)
1135 q->ec = ec;
1152 struct acpi_ec *ec = q->ec;
1163 spin_lock_irq(&ec->lock);
1164 ec->queries_in_progress--;
1165 spin_unlock_irq(&ec->lock);
1170 static int acpi_ec_query(struct acpi_ec *ec, u8 *data)
1176 q = acpi_ec_create_query(ec, &value);
1185 result = acpi_ec_transaction(ec, &q->transaction);
1191 q->handler = acpi_ec_get_query_handler_by_value(ec, value);
1206 spin_lock_irq(&ec->lock);
1208 ec->queries_in_progress++;
1211 spin_unlock_irq(&ec->lock);
1221 static void acpi_ec_check_event(struct acpi_ec *ec)
1226 if (ec_guard(ec)) {
1227 spin_lock_irqsave(&ec->lock, flags);
1232 if (!ec->curr)
1233 advance_transaction(ec);
1234 spin_unlock_irqrestore(&ec->lock, flags);
1242 struct acpi_ec *ec = container_of(work, struct acpi_ec, work);
1246 spin_lock_irqsave(&ec->lock, flags);
1247 while (ec->nr_pending_queries) {
1248 spin_unlock_irqrestore(&ec->lock, flags);
1249 (void)acpi_ec_query(ec, NULL);
1250 spin_lock_irqsave(&ec->lock, flags);
1251 ec->nr_pending_queries--;
1258 if (!ec->nr_pending_queries) {
1261 acpi_ec_complete_query(ec);
1264 spin_unlock_irqrestore(&ec->lock, flags);
1268 acpi_ec_check_event(ec);
1270 spin_lock_irqsave(&ec->lock, flags);
1271 ec->events_in_progress--;
1272 spin_unlock_irqrestore(&ec->lock, flags);
1275 static void acpi_ec_handle_interrupt(struct acpi_ec *ec)
1279 spin_lock_irqsave(&ec->lock, flags);
1280 advance_transaction(ec);
1281 spin_unlock_irqrestore(&ec->lock, flags);
1306 struct acpi_ec *ec = handler_context;
1316 if (ec->busy_polling || bits > 8)
1317 acpi_ec_burst_enable(ec);
1321 acpi_ec_read(ec, address, value) :
1322 acpi_ec_write(ec, address, *value);
1324 if (ec->busy_polling || bits > 8)
1325 acpi_ec_burst_disable(ec);
1346 static void acpi_ec_free(struct acpi_ec *ec)
1348 if (first_ec == ec)
1350 if (boot_ec == ec)
1352 kfree(ec);
1357 struct acpi_ec *ec = kzalloc(sizeof(struct acpi_ec), GFP_KERNEL);
1359 if (!ec)
1361 mutex_init(&ec->mutex);
1362 init_waitqueue_head(&ec->wait);
1363 INIT_LIST_HEAD(&ec->list);
1364 spin_lock_init(&ec->lock);
1365 INIT_WORK(&ec->work, acpi_ec_event_handler);
1366 ec->timestamp = jiffies;
1367 ec->busy_polling = true;
1368 ec->polling_guard = 0;
1369 ec->gpe = -1;
1370 ec->irq = -1;
1371 return ec;
1380 struct acpi_ec *ec = context;
1387 acpi_ec_add_query_handler(ec, value, handle, NULL, NULL);
1396 struct acpi_ec *ec = context;
1399 ec->command_addr = ec->data_addr = 0;
1402 ec_parse_io_ports, ec);
1405 if (ec->data_addr == 0 || ec->command_addr == 0)
1412 ec->gpe = tmp;
1421 ec->global_lock = tmp;
1422 ec->handle = handle;
1426 static bool install_gpe_event_handler(struct acpi_ec *ec)
1430 status = acpi_install_gpe_raw_handler(NULL, ec->gpe,
1432 &acpi_ec_gpe_handler, ec);
1436 if (test_bit(EC_FLAGS_STARTED, &ec->flags) && ec->reference_count >= 1)
1437 acpi_ec_enable_gpe(ec, true);
1442 static bool install_gpio_irq_event_handler(struct acpi_ec *ec)
1444 return request_irq(ec->irq, acpi_ec_irq_handler, IRQF_SHARED,
1445 "ACPI EC", ec) >= 0;
1450 * @ec: Target EC.
1451 * @device: ACPI device object corresponding to @ec.
1464 static int ec_install_handlers(struct acpi_ec *ec, struct acpi_device *device)
1468 acpi_ec_start(ec, false);
1470 if (!test_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags)) {
1471 acpi_ec_enter_noirq(ec);
1472 status = acpi_install_address_space_handler(ec->handle,
1475 NULL, ec);
1477 acpi_ec_stop(ec, false);
1480 set_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags);
1486 if (ec->gpe < 0) {
1496 ec->irq = irq;
1499 if (!test_bit(EC_FLAGS_QUERY_METHODS_INSTALLED, &ec->flags)) {
1501 acpi_walk_namespace(ACPI_TYPE_METHOD, ec->handle, 1,
1503 NULL, ec, NULL);
1504 set_bit(EC_FLAGS_QUERY_METHODS_INSTALLED, &ec->flags);
1506 if (!test_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags)) {
1509 if (ec->gpe >= 0)
1510 ready = install_gpe_event_handler(ec);
1511 else if (ec->irq >= 0)
1512 ready = install_gpio_irq_event_handler(ec);
1515 set_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags);
1516 acpi_ec_leave_noirq(ec);
1524 acpi_ec_enable_event(ec);
1529 static void ec_remove_handlers(struct acpi_ec *ec)
1531 if (test_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags)) {
1532 if (ACPI_FAILURE(acpi_remove_address_space_handler(ec->handle,
1535 clear_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags);
1549 acpi_ec_stop(ec, false);
1551 if (test_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags)) {
1552 if (ec->gpe >= 0 &&
1553 ACPI_FAILURE(acpi_remove_gpe_handler(NULL, ec->gpe,
1557 if (ec->irq >= 0)
1558 free_irq(ec->irq, ec);
1560 clear_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags);
1562 if (test_bit(EC_FLAGS_QUERY_METHODS_INSTALLED, &ec->flags)) {
1563 acpi_ec_remove_query_handlers(ec, true, 0);
1564 clear_bit(EC_FLAGS_QUERY_METHODS_INSTALLED, &ec->flags);
1568 static int acpi_ec_setup(struct acpi_ec *ec, struct acpi_device *device)
1572 ret = ec_install_handlers(ec, device);
1578 first_ec = ec;
1580 pr_info("EC_CMD/EC_SC=0x%lx, EC_DATA=0x%lx\n", ec->command_addr,
1581 ec->data_addr);
1583 if (test_bit(EC_FLAGS_EVENT_HANDLER_INSTALLED, &ec->flags)) {
1584 if (ec->gpe >= 0)
1585 pr_info("GPE=0x%x\n", ec->gpe);
1587 pr_info("IRQ=%d\n", ec->irq);
1595 struct acpi_ec *ec;
1604 ec = boot_ec;
1608 ec = acpi_ec_alloc();
1609 if (!ec)
1612 status = ec_parse_device(device->handle, 0, ec, NULL);
1618 if (boot_ec && ec->command_addr == boot_ec->command_addr &&
1619 ec->data_addr == boot_ec->data_addr &&
1625 * boot_ec->gpe to ec->gpe.
1627 boot_ec->handle = ec->handle;
1628 acpi_handle_debug(ec->handle, "duplicated.\n");
1629 acpi_ec_free(ec);
1630 ec = boot_ec;
1634 ret = acpi_ec_setup(ec, device);
1638 if (ec == boot_ec)
1643 acpi_handle_info(ec->handle,
1646 device->driver_data = ec;
1648 ret = !!request_region(ec->data_addr, 1, "EC data");
1649 WARN(!ret, "Could not request EC data io port 0x%lx", ec->data_addr);
1650 ret = !!request_region(ec->command_addr, 1, "EC cmd");
1651 WARN(!ret, "Could not request EC cmd io port 0x%lx", ec->command_addr);
1654 acpi_walk_dep_device_list(ec->handle);
1656 acpi_handle_debug(ec->handle, "enumerated.\n");
1660 if (ec != boot_ec)
1661 acpi_ec_free(ec);
1668 struct acpi_ec *ec;
1673 ec = acpi_driver_data(device);
1674 release_region(ec->data_addr, 1);
1675 release_region(ec->command_addr, 1);
1677 if (ec != boot_ec) {
1678 ec_remove_handlers(ec);
1679 acpi_ec_free(ec);
1687 struct acpi_ec *ec = context;
1697 if (ec->data_addr == 0)
1698 ec->data_addr = resource->data.io.minimum;
1699 else if (ec->command_addr == 0)
1700 ec->command_addr = resource->data.io.minimum;
1720 struct acpi_ec *ec;
1733 ec = acpi_ec_alloc();
1734 if (!ec)
1741 status = acpi_get_devices(ec_device_ids[0].id, ec_parse_device, ec, NULL);
1742 if (ACPI_FAILURE(status) || !ec->handle) {
1743 acpi_ec_free(ec);
1754 ret = acpi_ec_setup(ec, NULL);
1756 acpi_ec_free(ec);
1760 boot_ec = ec;
1762 acpi_handle_info(ec->handle,
1874 struct acpi_ec *ec;
1878 /* Generate a boot ec context. */
1893 ec = acpi_ec_alloc();
1894 if (!ec)
1898 ec->command_addr = ecdt_ptr->data.address;
1899 ec->data_addr = ecdt_ptr->control.address;
1901 ec->command_addr = ecdt_ptr->control.address;
1902 ec->data_addr = ecdt_ptr->data.address;
1910 ec->gpe = ecdt_ptr->gpe;
1912 ec->handle = ACPI_ROOT_OBJECT;
1918 ret = acpi_ec_setup(ec, NULL);
1920 acpi_ec_free(ec);
1924 boot_ec = ec;
1936 struct acpi_ec *ec =
1940 acpi_ec_disable_event(ec);
1946 struct acpi_ec *ec = acpi_driver_data(to_acpi_device(dev));
1952 if (ec_no_wakeup && test_bit(EC_FLAGS_STARTED, &ec->flags) &&
1953 ec->gpe >= 0 && ec->reference_count >= 1)
1954 acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_DISABLE);
1956 acpi_ec_enter_noirq(ec);
1963 struct acpi_ec *ec = acpi_driver_data(to_acpi_device(dev));
1965 acpi_ec_leave_noirq(ec);
1967 if (ec_no_wakeup && test_bit(EC_FLAGS_STARTED, &ec->flags) &&
1968 ec->gpe >= 0 && ec->reference_count >= 1)
1969 acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_ENABLE);
1976 struct acpi_ec *ec =
1979 acpi_ec_enable_event(ec);
2082 .name = "ec",