1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * ACPI AML interfacing support 4 * 5 * Copyright (C) 2015, Intel Corporation 6 * Authors: Lv Zheng <lv.zheng@intel.com> 7 */ 8 9 /* #define DEBUG */ 10 #define pr_fmt(fmt) "ACPI: AML: " fmt 11 12 #include <linux/kernel.h> 13 #include <linux/module.h> 14 #include <linux/wait.h> 15 #include <linux/poll.h> 16 #include <linux/sched.h> 17 #include <linux/kthread.h> 18 #include <linux/proc_fs.h> 19 #include <linux/debugfs.h> 20 #include <linux/circ_buf.h> 21 #include <linux/acpi.h> 22 #include "internal.h" 23 24 #define ACPI_AML_BUF_ALIGN (sizeof (acpi_size)) 25 #define ACPI_AML_BUF_SIZE PAGE_SIZE 26 27 #define circ_count(circ) \ 28 (CIRC_CNT((circ)->head, (circ)->tail, ACPI_AML_BUF_SIZE)) 29 #define circ_count_to_end(circ) \ 30 (CIRC_CNT_TO_END((circ)->head, (circ)->tail, ACPI_AML_BUF_SIZE)) 31 #define circ_space(circ) \ 32 (CIRC_SPACE((circ)->head, (circ)->tail, ACPI_AML_BUF_SIZE)) 33 #define circ_space_to_end(circ) \ 34 (CIRC_SPACE_TO_END((circ)->head, (circ)->tail, ACPI_AML_BUF_SIZE)) 35 36 #define ACPI_AML_OPENED 0x0001 37 #define ACPI_AML_CLOSED 0x0002 38 #define ACPI_AML_IN_USER 0x0004 /* user space is writing cmd */ 39 #define ACPI_AML_IN_KERN 0x0008 /* kernel space is reading cmd */ 40 #define ACPI_AML_OUT_USER 0x0010 /* user space is reading log */ 41 #define ACPI_AML_OUT_KERN 0x0020 /* kernel space is writing log */ 42 #define ACPI_AML_USER (ACPI_AML_IN_USER | ACPI_AML_OUT_USER) 43 #define ACPI_AML_KERN (ACPI_AML_IN_KERN | ACPI_AML_OUT_KERN) 44 #define ACPI_AML_BUSY (ACPI_AML_USER | ACPI_AML_KERN) 45 #define ACPI_AML_OPEN (ACPI_AML_OPENED | ACPI_AML_CLOSED) 46 47 struct acpi_aml_io { 48 wait_queue_head_t wait; 49 unsigned long flags; 50 unsigned long users; 51 struct mutex lock; 52 struct task_struct *thread; 53 char out_buf[ACPI_AML_BUF_SIZE] __aligned(ACPI_AML_BUF_ALIGN); 54 struct circ_buf out_crc; 55 char in_buf[ACPI_AML_BUF_SIZE] __aligned(ACPI_AML_BUF_ALIGN); 56 struct circ_buf in_crc; 57 acpi_osd_exec_callback function; 58 void *context; 59 unsigned long usages; 60 }; 61 62 static struct acpi_aml_io acpi_aml_io; 63 static bool acpi_aml_initialized; 64 static struct file *acpi_aml_active_reader; 65 static struct dentry *acpi_aml_dentry; 66 67 static inline bool __acpi_aml_running(void) 68 { 69 return acpi_aml_io.thread ? true : false; 70 } 71 72 static inline bool __acpi_aml_access_ok(unsigned long flag) 73 { 74 /* 75 * The debugger interface is in opened state (OPENED && !CLOSED), 76 * then it is allowed to access the debugger buffers from either 77 * user space or the kernel space. 78 * In addition, for the kernel space, only the debugger thread 79 * (thread ID matched) is allowed to access. 80 */ 81 if (!(acpi_aml_io.flags & ACPI_AML_OPENED) || 82 (acpi_aml_io.flags & ACPI_AML_CLOSED) || 83 !__acpi_aml_running()) 84 return false; 85 if ((flag & ACPI_AML_KERN) && 86 current != acpi_aml_io.thread) 87 return false; 88 return true; 89 } 90 91 static inline bool __acpi_aml_readable(struct circ_buf *circ, unsigned long flag) 92 { 93 /* 94 * Another read is not in progress and there is data in buffer 95 * available for read. 96 */ 97 if (!(acpi_aml_io.flags & flag) && circ_count(circ)) 98 return true; 99 return false; 100 } 101 102 static inline bool __acpi_aml_writable(struct circ_buf *circ, unsigned long flag) 103 { 104 /* 105 * Another write is not in progress and there is buffer space 106 * available for write. 107 */ 108 if (!(acpi_aml_io.flags & flag) && circ_space(circ)) 109 return true; 110 return false; 111 } 112 113 static inline bool __acpi_aml_busy(void) 114 { 115 if (acpi_aml_io.flags & ACPI_AML_BUSY) 116 return true; 117 return false; 118 } 119 120 static inline bool __acpi_aml_used(void) 121 { 122 return acpi_aml_io.usages ? true : false; 123 } 124 125 static inline bool acpi_aml_running(void) 126 { 127 bool ret; 128 129 mutex_lock(&acpi_aml_io.lock); 130 ret = __acpi_aml_running(); 131 mutex_unlock(&acpi_aml_io.lock); 132 return ret; 133 } 134 135 static bool acpi_aml_busy(void) 136 { 137 bool ret; 138 139 mutex_lock(&acpi_aml_io.lock); 140 ret = __acpi_aml_busy(); 141 mutex_unlock(&acpi_aml_io.lock); 142 return ret; 143 } 144 145 static bool acpi_aml_used(void) 146 { 147 bool ret; 148 149 /* 150 * The usage count is prepared to avoid race conditions between the 151 * starts and the stops of the debugger thread. 152 */ 153 mutex_lock(&acpi_aml_io.lock); 154 ret = __acpi_aml_used(); 155 mutex_unlock(&acpi_aml_io.lock); 156 return ret; 157 } 158 159 static bool acpi_aml_kern_readable(void) 160 { 161 bool ret; 162 163 mutex_lock(&acpi_aml_io.lock); 164 ret = !__acpi_aml_access_ok(ACPI_AML_IN_KERN) || 165 __acpi_aml_readable(&acpi_aml_io.in_crc, ACPI_AML_IN_KERN); 166 mutex_unlock(&acpi_aml_io.lock); 167 return ret; 168 } 169 170 static bool acpi_aml_kern_writable(void) 171 { 172 bool ret; 173 174 mutex_lock(&acpi_aml_io.lock); 175 ret = !__acpi_aml_access_ok(ACPI_AML_OUT_KERN) || 176 __acpi_aml_writable(&acpi_aml_io.out_crc, ACPI_AML_OUT_KERN); 177 mutex_unlock(&acpi_aml_io.lock); 178 return ret; 179 } 180 181 static bool acpi_aml_user_readable(void) 182 { 183 bool ret; 184 185 mutex_lock(&acpi_aml_io.lock); 186 ret = !__acpi_aml_access_ok(ACPI_AML_OUT_USER) || 187 __acpi_aml_readable(&acpi_aml_io.out_crc, ACPI_AML_OUT_USER); 188 mutex_unlock(&acpi_aml_io.lock); 189 return ret; 190 } 191 192 static bool acpi_aml_user_writable(void) 193 { 194 bool ret; 195 196 mutex_lock(&acpi_aml_io.lock); 197 ret = !__acpi_aml_access_ok(ACPI_AML_IN_USER) || 198 __acpi_aml_writable(&acpi_aml_io.in_crc, ACPI_AML_IN_USER); 199 mutex_unlock(&acpi_aml_io.lock); 200 return ret; 201 } 202 203 static int acpi_aml_lock_write(struct circ_buf *circ, unsigned long flag) 204 { 205 int ret = 0; 206 207 mutex_lock(&acpi_aml_io.lock); 208 if (!__acpi_aml_access_ok(flag)) { 209 ret = -EFAULT; 210 goto out; 211 } 212 if (!__acpi_aml_writable(circ, flag)) { 213 ret = -EAGAIN; 214 goto out; 215 } 216 acpi_aml_io.flags |= flag; 217 out: 218 mutex_unlock(&acpi_aml_io.lock); 219 return ret; 220 } 221 222 static int acpi_aml_lock_read(struct circ_buf *circ, unsigned long flag) 223 { 224 int ret = 0; 225 226 mutex_lock(&acpi_aml_io.lock); 227 if (!__acpi_aml_access_ok(flag)) { 228 ret = -EFAULT; 229 goto out; 230 } 231 if (!__acpi_aml_readable(circ, flag)) { 232 ret = -EAGAIN; 233 goto out; 234 } 235 acpi_aml_io.flags |= flag; 236 out: 237 mutex_unlock(&acpi_aml_io.lock); 238 return ret; 239 } 240 241 static void acpi_aml_unlock_fifo(unsigned long flag, bool wakeup) 242 { 243 mutex_lock(&acpi_aml_io.lock); 244 acpi_aml_io.flags &= ~flag; 245 if (wakeup) 246 wake_up_interruptible(&acpi_aml_io.wait); 247 mutex_unlock(&acpi_aml_io.lock); 248 } 249 250 static int acpi_aml_write_kern(const char *buf, int len) 251 { 252 int ret; 253 struct circ_buf *crc = &acpi_aml_io.out_crc; 254 int n; 255 char *p; 256 257 ret = acpi_aml_lock_write(crc, ACPI_AML_OUT_KERN); 258 if (ret < 0) 259 return ret; 260 /* sync tail before inserting logs */ 261 smp_mb(); 262 p = &crc->buf[crc->head]; 263 n = min(len, circ_space_to_end(crc)); 264 memcpy(p, buf, n); 265 /* sync head after inserting logs */ 266 smp_wmb(); 267 crc->head = (crc->head + n) & (ACPI_AML_BUF_SIZE - 1); 268 acpi_aml_unlock_fifo(ACPI_AML_OUT_KERN, true); 269 return n; 270 } 271 272 static int acpi_aml_readb_kern(void) 273 { 274 int ret; 275 struct circ_buf *crc = &acpi_aml_io.in_crc; 276 char *p; 277 278 ret = acpi_aml_lock_read(crc, ACPI_AML_IN_KERN); 279 if (ret < 0) 280 return ret; 281 /* sync head before removing cmds */ 282 smp_rmb(); 283 p = &crc->buf[crc->tail]; 284 ret = (int)*p; 285 /* sync tail before inserting cmds */ 286 smp_mb(); 287 crc->tail = (crc->tail + 1) & (ACPI_AML_BUF_SIZE - 1); 288 acpi_aml_unlock_fifo(ACPI_AML_IN_KERN, true); 289 return ret; 290 } 291 292 /* 293 * acpi_aml_write_log() - Capture debugger output 294 * @msg: the debugger output 295 * 296 * This function should be used to implement acpi_os_printf() to filter out 297 * the debugger output and store the output into the debugger interface 298 * buffer. Return the size of stored logs or errno. 299 */ 300 static ssize_t acpi_aml_write_log(const char *msg) 301 { 302 int ret = 0; 303 int count = 0, size = 0; 304 305 if (!acpi_aml_initialized) 306 return -ENODEV; 307 if (msg) 308 count = strlen(msg); 309 while (count > 0) { 310 again: 311 ret = acpi_aml_write_kern(msg + size, count); 312 if (ret == -EAGAIN) { 313 ret = wait_event_interruptible(acpi_aml_io.wait, 314 acpi_aml_kern_writable()); 315 /* 316 * We need to retry when the condition 317 * becomes true. 318 */ 319 if (ret == 0) 320 goto again; 321 break; 322 } 323 if (ret < 0) 324 break; 325 size += ret; 326 count -= ret; 327 } 328 return size > 0 ? size : ret; 329 } 330 331 /* 332 * acpi_aml_read_cmd() - Capture debugger input 333 * @msg: the debugger input 334 * @size: the size of the debugger input 335 * 336 * This function should be used to implement acpi_os_get_line() to capture 337 * the debugger input commands and store the input commands into the 338 * debugger interface buffer. Return the size of stored commands or errno. 339 */ 340 static ssize_t acpi_aml_read_cmd(char *msg, size_t count) 341 { 342 int ret = 0; 343 int size = 0; 344 345 /* 346 * This is ensured by the running fact of the debugger thread 347 * unless a bug is introduced. 348 */ 349 BUG_ON(!acpi_aml_initialized); 350 while (count > 0) { 351 again: 352 /* 353 * Check each input byte to find the end of the command. 354 */ 355 ret = acpi_aml_readb_kern(); 356 if (ret == -EAGAIN) { 357 ret = wait_event_interruptible(acpi_aml_io.wait, 358 acpi_aml_kern_readable()); 359 /* 360 * We need to retry when the condition becomes 361 * true. 362 */ 363 if (ret == 0) 364 goto again; 365 } 366 if (ret < 0) 367 break; 368 *(msg + size) = (char)ret; 369 size++; 370 count--; 371 if (ret == '\n') { 372 /* 373 * acpi_os_get_line() requires a zero terminated command 374 * string. 375 */ 376 *(msg + size - 1) = '\0'; 377 break; 378 } 379 } 380 return size > 0 ? size : ret; 381 } 382 383 static int acpi_aml_thread(void *unused) 384 { 385 acpi_osd_exec_callback function = NULL; 386 void *context; 387 388 mutex_lock(&acpi_aml_io.lock); 389 if (acpi_aml_io.function) { 390 acpi_aml_io.usages++; 391 function = acpi_aml_io.function; 392 context = acpi_aml_io.context; 393 } 394 mutex_unlock(&acpi_aml_io.lock); 395 396 if (function) 397 function(context); 398 399 mutex_lock(&acpi_aml_io.lock); 400 acpi_aml_io.usages--; 401 if (!__acpi_aml_used()) { 402 acpi_aml_io.thread = NULL; 403 wake_up(&acpi_aml_io.wait); 404 } 405 mutex_unlock(&acpi_aml_io.lock); 406 407 return 0; 408 } 409 410 /* 411 * acpi_aml_create_thread() - Create AML debugger thread 412 * @function: the debugger thread callback 413 * @context: the context to be passed to the debugger thread 414 * 415 * This function should be used to implement acpi_os_execute() which is 416 * used by the ACPICA debugger to create the debugger thread. 417 */ 418 static int acpi_aml_create_thread(acpi_osd_exec_callback function, void *context) 419 { 420 struct task_struct *t; 421 422 mutex_lock(&acpi_aml_io.lock); 423 acpi_aml_io.function = function; 424 acpi_aml_io.context = context; 425 mutex_unlock(&acpi_aml_io.lock); 426 427 t = kthread_create(acpi_aml_thread, NULL, "aml"); 428 if (IS_ERR(t)) { 429 pr_err("Failed to create AML debugger thread.\n"); 430 return PTR_ERR(t); 431 } 432 433 mutex_lock(&acpi_aml_io.lock); 434 acpi_aml_io.thread = t; 435 acpi_set_debugger_thread_id((acpi_thread_id)(unsigned long)t); 436 wake_up_process(t); 437 mutex_unlock(&acpi_aml_io.lock); 438 return 0; 439 } 440 441 static int acpi_aml_wait_command_ready(bool single_step, 442 char *buffer, size_t length) 443 { 444 acpi_status status; 445 446 if (single_step) 447 acpi_os_printf("\n%1c ", ACPI_DEBUGGER_EXECUTE_PROMPT); 448 else 449 acpi_os_printf("\n%1c ", ACPI_DEBUGGER_COMMAND_PROMPT); 450 451 status = acpi_os_get_line(buffer, length, NULL); 452 if (ACPI_FAILURE(status)) 453 return -EINVAL; 454 return 0; 455 } 456 457 static int acpi_aml_notify_command_complete(void) 458 { 459 return 0; 460 } 461 462 static int acpi_aml_open(struct inode *inode, struct file *file) 463 { 464 int ret = 0; 465 acpi_status status; 466 467 mutex_lock(&acpi_aml_io.lock); 468 /* 469 * The debugger interface is being closed, no new user is allowed 470 * during this period. 471 */ 472 if (acpi_aml_io.flags & ACPI_AML_CLOSED) { 473 ret = -EBUSY; 474 goto err_lock; 475 } 476 if ((file->f_flags & O_ACCMODE) != O_WRONLY) { 477 /* 478 * Only one reader is allowed to initiate the debugger 479 * thread. 480 */ 481 if (acpi_aml_active_reader) { 482 ret = -EBUSY; 483 goto err_lock; 484 } else { 485 pr_debug("Opening debugger reader.\n"); 486 acpi_aml_active_reader = file; 487 } 488 } else { 489 /* 490 * No writer is allowed unless the debugger thread is 491 * ready. 492 */ 493 if (!(acpi_aml_io.flags & ACPI_AML_OPENED)) { 494 ret = -ENODEV; 495 goto err_lock; 496 } 497 } 498 if (acpi_aml_active_reader == file) { 499 pr_debug("Opening debugger interface.\n"); 500 mutex_unlock(&acpi_aml_io.lock); 501 502 pr_debug("Initializing debugger thread.\n"); 503 status = acpi_initialize_debugger(); 504 if (ACPI_FAILURE(status)) { 505 pr_err("Failed to initialize debugger.\n"); 506 ret = -EINVAL; 507 goto err_exit; 508 } 509 pr_debug("Debugger thread initialized.\n"); 510 511 mutex_lock(&acpi_aml_io.lock); 512 acpi_aml_io.flags |= ACPI_AML_OPENED; 513 acpi_aml_io.out_crc.head = acpi_aml_io.out_crc.tail = 0; 514 acpi_aml_io.in_crc.head = acpi_aml_io.in_crc.tail = 0; 515 pr_debug("Debugger interface opened.\n"); 516 } 517 acpi_aml_io.users++; 518 err_lock: 519 if (ret < 0) { 520 if (acpi_aml_active_reader == file) 521 acpi_aml_active_reader = NULL; 522 } 523 mutex_unlock(&acpi_aml_io.lock); 524 err_exit: 525 return ret; 526 } 527 528 static int acpi_aml_release(struct inode *inode, struct file *file) 529 { 530 mutex_lock(&acpi_aml_io.lock); 531 acpi_aml_io.users--; 532 if (file == acpi_aml_active_reader) { 533 pr_debug("Closing debugger reader.\n"); 534 acpi_aml_active_reader = NULL; 535 536 pr_debug("Closing debugger interface.\n"); 537 acpi_aml_io.flags |= ACPI_AML_CLOSED; 538 539 /* 540 * Wake up all user space/kernel space blocked 541 * readers/writers. 542 */ 543 wake_up_interruptible(&acpi_aml_io.wait); 544 mutex_unlock(&acpi_aml_io.lock); 545 /* 546 * Wait all user space/kernel space readers/writers to 547 * stop so that ACPICA command loop of the debugger thread 548 * should fail all its command line reads after this point. 549 */ 550 wait_event(acpi_aml_io.wait, !acpi_aml_busy()); 551 552 /* 553 * Then we try to terminate the debugger thread if it is 554 * not terminated. 555 */ 556 pr_debug("Terminating debugger thread.\n"); 557 acpi_terminate_debugger(); 558 wait_event(acpi_aml_io.wait, !acpi_aml_used()); 559 pr_debug("Debugger thread terminated.\n"); 560 561 mutex_lock(&acpi_aml_io.lock); 562 acpi_aml_io.flags &= ~ACPI_AML_OPENED; 563 } 564 if (acpi_aml_io.users == 0) { 565 pr_debug("Debugger interface closed.\n"); 566 acpi_aml_io.flags &= ~ACPI_AML_CLOSED; 567 } 568 mutex_unlock(&acpi_aml_io.lock); 569 return 0; 570 } 571 572 static int acpi_aml_read_user(char __user *buf, int len) 573 { 574 int ret; 575 struct circ_buf *crc = &acpi_aml_io.out_crc; 576 int n; 577 char *p; 578 579 ret = acpi_aml_lock_read(crc, ACPI_AML_OUT_USER); 580 if (ret < 0) 581 return ret; 582 /* sync head before removing logs */ 583 smp_rmb(); 584 p = &crc->buf[crc->tail]; 585 n = min(len, circ_count_to_end(crc)); 586 if (copy_to_user(buf, p, n)) { 587 ret = -EFAULT; 588 goto out; 589 } 590 /* sync tail after removing logs */ 591 smp_mb(); 592 crc->tail = (crc->tail + n) & (ACPI_AML_BUF_SIZE - 1); 593 ret = n; 594 out: 595 acpi_aml_unlock_fifo(ACPI_AML_OUT_USER, ret >= 0); 596 return ret; 597 } 598 599 static ssize_t acpi_aml_read(struct file *file, char __user *buf, 600 size_t count, loff_t *ppos) 601 { 602 int ret = 0; 603 int size = 0; 604 605 if (!count) 606 return 0; 607 if (!access_ok(buf, count)) 608 return -EFAULT; 609 610 while (count > 0) { 611 again: 612 ret = acpi_aml_read_user(buf + size, count); 613 if (ret == -EAGAIN) { 614 if (file->f_flags & O_NONBLOCK) 615 break; 616 else { 617 ret = wait_event_interruptible(acpi_aml_io.wait, 618 acpi_aml_user_readable()); 619 /* 620 * We need to retry when the condition 621 * becomes true. 622 */ 623 if (ret == 0) 624 goto again; 625 } 626 } 627 if (ret < 0) { 628 if (!acpi_aml_running()) 629 ret = 0; 630 break; 631 } 632 if (ret) { 633 size += ret; 634 count -= ret; 635 *ppos += ret; 636 break; 637 } 638 } 639 return size > 0 ? size : ret; 640 } 641 642 static int acpi_aml_write_user(const char __user *buf, int len) 643 { 644 int ret; 645 struct circ_buf *crc = &acpi_aml_io.in_crc; 646 int n; 647 char *p; 648 649 ret = acpi_aml_lock_write(crc, ACPI_AML_IN_USER); 650 if (ret < 0) 651 return ret; 652 /* sync tail before inserting cmds */ 653 smp_mb(); 654 p = &crc->buf[crc->head]; 655 n = min(len, circ_space_to_end(crc)); 656 if (copy_from_user(p, buf, n)) { 657 ret = -EFAULT; 658 goto out; 659 } 660 /* sync head after inserting cmds */ 661 smp_wmb(); 662 crc->head = (crc->head + n) & (ACPI_AML_BUF_SIZE - 1); 663 ret = n; 664 out: 665 acpi_aml_unlock_fifo(ACPI_AML_IN_USER, ret >= 0); 666 return n; 667 } 668 669 static ssize_t acpi_aml_write(struct file *file, const char __user *buf, 670 size_t count, loff_t *ppos) 671 { 672 int ret = 0; 673 int size = 0; 674 675 if (!count) 676 return 0; 677 if (!access_ok(buf, count)) 678 return -EFAULT; 679 680 while (count > 0) { 681 again: 682 ret = acpi_aml_write_user(buf + size, count); 683 if (ret == -EAGAIN) { 684 if (file->f_flags & O_NONBLOCK) 685 break; 686 else { 687 ret = wait_event_interruptible(acpi_aml_io.wait, 688 acpi_aml_user_writable()); 689 /* 690 * We need to retry when the condition 691 * becomes true. 692 */ 693 if (ret == 0) 694 goto again; 695 } 696 } 697 if (ret < 0) { 698 if (!acpi_aml_running()) 699 ret = 0; 700 break; 701 } 702 if (ret) { 703 size += ret; 704 count -= ret; 705 *ppos += ret; 706 } 707 } 708 return size > 0 ? size : ret; 709 } 710 711 static __poll_t acpi_aml_poll(struct file *file, poll_table *wait) 712 { 713 __poll_t masks = 0; 714 715 poll_wait(file, &acpi_aml_io.wait, wait); 716 if (acpi_aml_user_readable()) 717 masks |= EPOLLIN | EPOLLRDNORM; 718 if (acpi_aml_user_writable()) 719 masks |= EPOLLOUT | EPOLLWRNORM; 720 721 return masks; 722 } 723 724 static const struct file_operations acpi_aml_operations = { 725 .read = acpi_aml_read, 726 .write = acpi_aml_write, 727 .poll = acpi_aml_poll, 728 .open = acpi_aml_open, 729 .release = acpi_aml_release, 730 .llseek = generic_file_llseek, 731 }; 732 733 static const struct acpi_debugger_ops acpi_aml_debugger = { 734 .create_thread = acpi_aml_create_thread, 735 .read_cmd = acpi_aml_read_cmd, 736 .write_log = acpi_aml_write_log, 737 .wait_command_ready = acpi_aml_wait_command_ready, 738 .notify_command_complete = acpi_aml_notify_command_complete, 739 }; 740 741 static int __init acpi_aml_init(void) 742 { 743 int ret; 744 745 if (acpi_disabled) 746 return -ENODEV; 747 748 /* Initialize AML IO interface */ 749 mutex_init(&acpi_aml_io.lock); 750 init_waitqueue_head(&acpi_aml_io.wait); 751 acpi_aml_io.out_crc.buf = acpi_aml_io.out_buf; 752 acpi_aml_io.in_crc.buf = acpi_aml_io.in_buf; 753 754 acpi_aml_dentry = debugfs_create_file("acpidbg", 755 S_IFREG | S_IRUGO | S_IWUSR, 756 acpi_debugfs_dir, NULL, 757 &acpi_aml_operations); 758 759 ret = acpi_register_debugger(THIS_MODULE, &acpi_aml_debugger); 760 if (ret) { 761 debugfs_remove(acpi_aml_dentry); 762 acpi_aml_dentry = NULL; 763 return ret; 764 } 765 766 acpi_aml_initialized = true; 767 return 0; 768 } 769 770 static void __exit acpi_aml_exit(void) 771 { 772 if (acpi_aml_initialized) { 773 acpi_unregister_debugger(&acpi_aml_debugger); 774 debugfs_remove(acpi_aml_dentry); 775 acpi_aml_dentry = NULL; 776 acpi_aml_initialized = false; 777 } 778 } 779 780 module_init(acpi_aml_init); 781 module_exit(acpi_aml_exit); 782 783 MODULE_AUTHOR("Lv Zheng"); 784 MODULE_DESCRIPTION("ACPI debugger userspace IO driver"); 785 MODULE_LICENSE("GPL"); 786