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