[MTD] cfi_cmdset_0001: Fix the buggy status check.
[linux-2.6] / drivers / acpi / button.c
1 /*
2  *  acpi_button.c - ACPI Button Driver ($Revision: 30 $)
3  *
4  *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
5  *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
6  *
7  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
8  *
9  *  This program is free software; you can redistribute it and/or modify
10  *  it under the terms of the GNU General Public License as published by
11  *  the Free Software Foundation; either version 2 of the License, or (at
12  *  your option) any later version.
13  *
14  *  This program is distributed in the hope that it will be useful, but
15  *  WITHOUT ANY WARRANTY; without even the implied warranty of
16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  *  General Public License for more details.
18  *
19  *  You should have received a copy of the GNU General Public License along
20  *  with this program; if not, write to the Free Software Foundation, Inc.,
21  *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
22  *
23  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
24  */
25
26 #include <linux/kernel.h>
27 #include <linux/module.h>
28 #include <linux/init.h>
29 #include <linux/types.h>
30 #include <linux/proc_fs.h>
31 #include <linux/seq_file.h>
32 #include <acpi/acpi_bus.h>
33 #include <acpi/acpi_drivers.h>
34
35
36 #define ACPI_BUTTON_COMPONENT           0x00080000
37 #define ACPI_BUTTON_DRIVER_NAME         "ACPI Button Driver"
38 #define ACPI_BUTTON_CLASS               "button"
39 #define ACPI_BUTTON_FILE_INFO           "info"
40 #define ACPI_BUTTON_FILE_STATE          "state"
41 #define ACPI_BUTTON_TYPE_UNKNOWN        0x00
42 #define ACPI_BUTTON_NOTIFY_STATUS       0x80
43
44 #define ACPI_BUTTON_SUBCLASS_POWER      "power"
45 #define ACPI_BUTTON_HID_POWER           "PNP0C0C"       
46 #define ACPI_BUTTON_DEVICE_NAME_POWER   "Power Button (CM)"
47 #define ACPI_BUTTON_DEVICE_NAME_POWERF  "Power Button (FF)"
48 #define ACPI_BUTTON_TYPE_POWER          0x01
49 #define ACPI_BUTTON_TYPE_POWERF         0x02
50
51 #define ACPI_BUTTON_SUBCLASS_SLEEP      "sleep"
52 #define ACPI_BUTTON_HID_SLEEP           "PNP0C0E"
53 #define ACPI_BUTTON_DEVICE_NAME_SLEEP   "Sleep Button (CM)"
54 #define ACPI_BUTTON_DEVICE_NAME_SLEEPF  "Sleep Button (FF)"
55 #define ACPI_BUTTON_TYPE_SLEEP          0x03
56 #define ACPI_BUTTON_TYPE_SLEEPF         0x04
57
58 #define ACPI_BUTTON_SUBCLASS_LID        "lid"
59 #define ACPI_BUTTON_HID_LID             "PNP0C0D"
60 #define ACPI_BUTTON_DEVICE_NAME_LID     "Lid Switch"
61 #define ACPI_BUTTON_TYPE_LID            0x05
62
63 #define _COMPONENT              ACPI_BUTTON_COMPONENT
64 ACPI_MODULE_NAME                ("acpi_button")
65
66 MODULE_AUTHOR("Paul Diefenbaugh");
67 MODULE_DESCRIPTION(ACPI_BUTTON_DRIVER_NAME);
68 MODULE_LICENSE("GPL");
69
70
71 static int acpi_button_add (struct acpi_device *device);
72 static int acpi_button_remove (struct acpi_device *device, int type);
73 static int acpi_button_info_open_fs(struct inode *inode, struct file *file);
74 static int acpi_button_state_open_fs(struct inode *inode, struct file *file);
75
76 static struct acpi_driver acpi_button_driver = {
77         .name =         ACPI_BUTTON_DRIVER_NAME,
78         .class =        ACPI_BUTTON_CLASS,
79         .ids =          "ACPI_FPB,ACPI_FSB,PNP0C0D,PNP0C0C,PNP0C0E",
80         .ops =          {
81                                 .add =          acpi_button_add,
82                                 .remove =       acpi_button_remove,
83                         },
84 };
85
86 struct acpi_button {
87         acpi_handle             handle;
88         struct acpi_device      *device;        /* Fixed button kludge */
89         u8                      type;
90         unsigned long           pushed;
91 };
92
93 static struct file_operations acpi_button_info_fops = {
94         .open           = acpi_button_info_open_fs,
95         .read           = seq_read,
96         .llseek         = seq_lseek,
97         .release        = single_release,
98 };
99
100 static struct file_operations acpi_button_state_fops = {
101         .open           = acpi_button_state_open_fs,
102         .read           = seq_read,
103         .llseek         = seq_lseek,
104         .release        = single_release,
105 };
106 /* --------------------------------------------------------------------------
107                               FS Interface (/proc)
108    -------------------------------------------------------------------------- */
109
110 static struct proc_dir_entry    *acpi_button_dir;
111
112 static int acpi_button_info_seq_show(struct seq_file *seq, void *offset)
113 {
114         struct acpi_button      *button = (struct acpi_button *) seq->private;
115
116         ACPI_FUNCTION_TRACE("acpi_button_info_seq_show");
117
118         if (!button || !button->device)
119                 return_VALUE(0);
120
121         seq_printf(seq, "type:                    %s\n", 
122                 acpi_device_name(button->device));
123
124         return_VALUE(0);
125 }
126
127 static int acpi_button_info_open_fs(struct inode *inode, struct file *file)
128 {
129         return single_open(file, acpi_button_info_seq_show, PDE(inode)->data);
130 }
131         
132 static int acpi_button_state_seq_show(struct seq_file *seq, void *offset)
133 {
134         struct acpi_button      *button = (struct acpi_button *) seq->private;
135         acpi_status             status;
136         unsigned long           state;
137
138         ACPI_FUNCTION_TRACE("acpi_button_state_seq_show");
139
140         if (!button || !button->device)
141                 return_VALUE(0);
142
143         status = acpi_evaluate_integer(button->handle,"_LID",NULL,&state);
144         if (ACPI_FAILURE(status)) {
145                 seq_printf(seq, "state:      unsupported\n");
146         }
147         else{
148                 seq_printf(seq, "state:      %s\n", (state ? "open" : "closed")); 
149         }
150
151         return_VALUE(0);
152 }
153
154 static int acpi_button_state_open_fs(struct inode *inode, struct file *file)
155 {
156         return single_open(file, acpi_button_state_seq_show, PDE(inode)->data);
157 }
158
159 static int
160 acpi_button_add_fs (
161         struct acpi_device      *device)
162 {
163         struct proc_dir_entry   *entry = NULL;
164         struct acpi_button      *button = NULL;
165
166         ACPI_FUNCTION_TRACE("acpi_button_add_fs");
167
168         if (!device || !acpi_driver_data(device))
169                 return_VALUE(-EINVAL);
170
171         button = acpi_driver_data(device);
172
173         switch (button->type) {
174         case ACPI_BUTTON_TYPE_POWER:
175         case ACPI_BUTTON_TYPE_POWERF:
176                         entry = proc_mkdir(ACPI_BUTTON_SUBCLASS_POWER, 
177                                 acpi_button_dir);
178                 break;
179         case ACPI_BUTTON_TYPE_SLEEP:
180         case ACPI_BUTTON_TYPE_SLEEPF:
181                         entry = proc_mkdir(ACPI_BUTTON_SUBCLASS_SLEEP, 
182                                 acpi_button_dir);
183                 break;
184         case ACPI_BUTTON_TYPE_LID:
185                         entry = proc_mkdir(ACPI_BUTTON_SUBCLASS_LID, 
186                                 acpi_button_dir);
187                 break;
188         }
189
190         if (!entry)
191                 return_VALUE(-ENODEV);
192         entry->owner = THIS_MODULE;
193
194         acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device), entry);
195         if (!acpi_device_dir(device))
196                 return_VALUE(-ENODEV);
197         acpi_device_dir(device)->owner = THIS_MODULE;
198
199         /* 'info' [R] */
200         entry = create_proc_entry(ACPI_BUTTON_FILE_INFO,
201                 S_IRUGO, acpi_device_dir(device));
202         if (!entry)
203                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
204                         "Unable to create '%s' fs entry\n",
205                         ACPI_BUTTON_FILE_INFO));
206         else {
207                 entry->proc_fops = &acpi_button_info_fops;
208                 entry->data = acpi_driver_data(device);
209                 entry->owner = THIS_MODULE;
210         }
211
212         /* show lid state [R] */
213         if (button->type == ACPI_BUTTON_TYPE_LID) {
214                 entry = create_proc_entry(ACPI_BUTTON_FILE_STATE,
215                         S_IRUGO, acpi_device_dir(device));
216                 if (!entry)
217                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
218                                 "Unable to create '%s' fs entry\n",
219                                 ACPI_BUTTON_FILE_INFO));
220                 else {
221                         entry->proc_fops = &acpi_button_state_fops;
222                         entry->data = acpi_driver_data(device);
223                         entry->owner = THIS_MODULE;
224                 }
225         }
226
227         return_VALUE(0);
228 }
229
230
231 static int
232 acpi_button_remove_fs (
233         struct acpi_device      *device)
234 {
235         struct acpi_button      *button = NULL;
236
237         ACPI_FUNCTION_TRACE("acpi_button_remove_fs");
238
239         button = acpi_driver_data(device);
240         if (acpi_device_dir(device)) {
241                 if (button->type == ACPI_BUTTON_TYPE_LID)
242                         remove_proc_entry(ACPI_BUTTON_FILE_STATE,
243                                              acpi_device_dir(device));
244                 remove_proc_entry(ACPI_BUTTON_FILE_INFO,
245                                      acpi_device_dir(device));
246
247                 remove_proc_entry(acpi_device_bid(device),
248                                      acpi_device_dir(device)->parent);
249
250
251                 switch (button->type) {
252                         case ACPI_BUTTON_TYPE_POWER:
253                         case ACPI_BUTTON_TYPE_POWERF:
254                                 remove_proc_entry(ACPI_BUTTON_SUBCLASS_POWER, 
255                                         acpi_button_dir);
256                                 break;
257                         case ACPI_BUTTON_TYPE_SLEEP:
258                         case ACPI_BUTTON_TYPE_SLEEPF:
259                                 remove_proc_entry(ACPI_BUTTON_SUBCLASS_SLEEP, 
260                                         acpi_button_dir);
261                                 break;
262                         case ACPI_BUTTON_TYPE_LID:
263                                 remove_proc_entry(ACPI_BUTTON_SUBCLASS_LID, 
264                                         acpi_button_dir);
265                                 break;
266                 }
267                 acpi_device_dir(device) = NULL;
268         }
269
270         return_VALUE(0);
271 }
272
273
274 /* --------------------------------------------------------------------------
275                                 Driver Interface
276    -------------------------------------------------------------------------- */
277
278 static void
279 acpi_button_notify (
280         acpi_handle             handle,
281         u32                     event,
282         void                    *data)
283 {
284         struct acpi_button      *button = (struct acpi_button *) data;
285
286         ACPI_FUNCTION_TRACE("acpi_button_notify");
287
288         if (!button || !button->device)
289                 return_VOID;
290
291         switch (event) {
292         case ACPI_BUTTON_NOTIFY_STATUS:
293                 acpi_bus_generate_event(button->device, event, ++button->pushed);
294                 break;
295         default:
296                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
297                         "Unsupported event [0x%x]\n", event));
298                 break;
299         }
300
301         return_VOID;
302 }
303
304
305 static acpi_status
306 acpi_button_notify_fixed (
307         void                    *data)
308 {
309         struct acpi_button      *button = (struct acpi_button *) data;
310         
311         ACPI_FUNCTION_TRACE("acpi_button_notify_fixed");
312
313         if (!button)
314                 return_ACPI_STATUS(AE_BAD_PARAMETER);
315
316         acpi_button_notify(button->handle, ACPI_BUTTON_NOTIFY_STATUS, button);
317
318         return_ACPI_STATUS(AE_OK);
319 }
320
321
322 static int
323 acpi_button_add (
324         struct acpi_device      *device)
325 {
326         int                     result = 0;
327         acpi_status             status = AE_OK;
328         struct acpi_button      *button = NULL;
329
330         static struct acpi_device *power_button;
331         static struct acpi_device *sleep_button;
332         static struct acpi_device *lid_button;
333
334         ACPI_FUNCTION_TRACE("acpi_button_add");
335
336         if (!device)
337                 return_VALUE(-EINVAL);
338
339         button = kmalloc(sizeof(struct acpi_button), GFP_KERNEL);
340         if (!button)
341                 return_VALUE(-ENOMEM);
342         memset(button, 0, sizeof(struct acpi_button));
343
344         button->device = device;
345         button->handle = device->handle;
346         acpi_driver_data(device) = button;
347
348         /*
349          * Determine the button type (via hid), as fixed-feature buttons
350          * need to be handled a bit differently than generic-space.
351          */
352         if (!strcmp(acpi_device_hid(device), ACPI_BUTTON_HID_POWER)) {
353                 button->type = ACPI_BUTTON_TYPE_POWER;
354                 strcpy(acpi_device_name(device),
355                         ACPI_BUTTON_DEVICE_NAME_POWER);
356                 sprintf(acpi_device_class(device), "%s/%s", 
357                         ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_POWER);
358         }
359         else if (!strcmp(acpi_device_hid(device), ACPI_BUTTON_HID_POWERF)) {
360                 button->type = ACPI_BUTTON_TYPE_POWERF;
361                 strcpy(acpi_device_name(device),
362                         ACPI_BUTTON_DEVICE_NAME_POWERF);
363                 sprintf(acpi_device_class(device), "%s/%s", 
364                         ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_POWER);
365         }
366         else if (!strcmp(acpi_device_hid(device), ACPI_BUTTON_HID_SLEEP)) {
367                 button->type = ACPI_BUTTON_TYPE_SLEEP;
368                 strcpy(acpi_device_name(device),
369                         ACPI_BUTTON_DEVICE_NAME_SLEEP);
370                 sprintf(acpi_device_class(device), "%s/%s", 
371                         ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_SLEEP);
372         }
373         else if (!strcmp(acpi_device_hid(device), ACPI_BUTTON_HID_SLEEPF)) {
374                 button->type = ACPI_BUTTON_TYPE_SLEEPF;
375                 strcpy(acpi_device_name(device),
376                         ACPI_BUTTON_DEVICE_NAME_SLEEPF);
377                 sprintf(acpi_device_class(device), "%s/%s", 
378                         ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_SLEEP);
379         }
380         else if (!strcmp(acpi_device_hid(device), ACPI_BUTTON_HID_LID)) {
381                 button->type = ACPI_BUTTON_TYPE_LID;
382                 strcpy(acpi_device_name(device),
383                         ACPI_BUTTON_DEVICE_NAME_LID);
384                 sprintf(acpi_device_class(device), "%s/%s", 
385                         ACPI_BUTTON_CLASS, ACPI_BUTTON_SUBCLASS_LID);
386         }
387         else {
388                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Unsupported hid [%s]\n",
389                         acpi_device_hid(device)));
390                 result = -ENODEV;
391                 goto end;
392         }
393
394         /*
395          * Ensure only one button of each type is used.
396          */
397         switch (button->type) {
398         case ACPI_BUTTON_TYPE_POWER:
399         case ACPI_BUTTON_TYPE_POWERF:
400                 if (!power_button)
401                         power_button = device;
402                 else {
403                         kfree(button);
404                         return_VALUE(-ENODEV);
405                 }
406                 break;
407         case ACPI_BUTTON_TYPE_SLEEP:
408         case ACPI_BUTTON_TYPE_SLEEPF:
409                 if (!sleep_button)
410                         sleep_button = device;
411                 else {
412                         kfree(button);
413                         return_VALUE(-ENODEV);
414                 }
415                 break;
416         case ACPI_BUTTON_TYPE_LID:
417                 if (!lid_button)
418                         lid_button = device;
419                 else {
420                         kfree(button);
421                         return_VALUE(-ENODEV);
422                 }
423                 break;
424         }
425
426         result = acpi_button_add_fs(device);
427         if (result)
428                 goto end;
429
430         switch (button->type) {
431         case ACPI_BUTTON_TYPE_POWERF:
432                 status = acpi_install_fixed_event_handler (
433                         ACPI_EVENT_POWER_BUTTON,
434                         acpi_button_notify_fixed,
435                         button);
436                 break;
437         case ACPI_BUTTON_TYPE_SLEEPF:
438                 status = acpi_install_fixed_event_handler (
439                         ACPI_EVENT_SLEEP_BUTTON,
440                         acpi_button_notify_fixed,
441                         button);
442                 break;
443         default:
444                 status = acpi_install_notify_handler (
445                         button->handle,
446                         ACPI_DEVICE_NOTIFY,
447                         acpi_button_notify,
448                         button);
449                 break;
450         }
451
452         if (ACPI_FAILURE(status)) {
453                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
454                         "Error installing notify handler\n"));
455                 result = -ENODEV;
456                 goto end;
457         }
458
459         if (device->wakeup.flags.valid) {
460                 /* Button's GPE is run-wake GPE */
461                 acpi_set_gpe_type(device->wakeup.gpe_device, 
462                         device->wakeup.gpe_number, ACPI_GPE_TYPE_WAKE_RUN);
463                 acpi_enable_gpe(device->wakeup.gpe_device, 
464                         device->wakeup.gpe_number, ACPI_NOT_ISR);
465                 device->wakeup.state.enabled = 1;
466         }
467
468         printk(KERN_INFO PREFIX "%s [%s]\n", 
469                 acpi_device_name(device), acpi_device_bid(device));
470
471 end:
472         if (result) {
473                 acpi_button_remove_fs(device);
474                 kfree(button);
475         }
476
477         return_VALUE(result);
478 }
479
480
481 static int
482 acpi_button_remove (struct acpi_device *device, int type)
483 {
484         acpi_status             status = 0;
485         struct acpi_button      *button = NULL;
486
487         ACPI_FUNCTION_TRACE("acpi_button_remove");
488
489         if (!device || !acpi_driver_data(device))
490                 return_VALUE(-EINVAL);
491
492         button = acpi_driver_data(device);
493
494         /* Unregister for device notifications. */
495         switch (button->type) {
496         case ACPI_BUTTON_TYPE_POWERF:
497                 status = acpi_remove_fixed_event_handler(
498                         ACPI_EVENT_POWER_BUTTON, acpi_button_notify_fixed);
499                 break;
500         case ACPI_BUTTON_TYPE_SLEEPF:
501                 status = acpi_remove_fixed_event_handler(
502                         ACPI_EVENT_SLEEP_BUTTON, acpi_button_notify_fixed);
503                 break;
504         default:
505                 status = acpi_remove_notify_handler(button->handle,
506                         ACPI_DEVICE_NOTIFY, acpi_button_notify);
507                 break;
508         }
509
510         if (ACPI_FAILURE(status))
511                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
512                         "Error removing notify handler\n"));
513
514         acpi_button_remove_fs(device);  
515
516         kfree(button);
517
518         return_VALUE(0);
519 }
520
521
522 static int __init
523 acpi_button_init (void)
524 {
525         int                     result = 0;
526
527         ACPI_FUNCTION_TRACE("acpi_button_init");
528
529         acpi_button_dir = proc_mkdir(ACPI_BUTTON_CLASS, acpi_root_dir);
530         if (!acpi_button_dir)
531                 return_VALUE(-ENODEV);
532         acpi_button_dir->owner = THIS_MODULE;
533
534         result = acpi_bus_register_driver(&acpi_button_driver);
535         if (result < 0) {
536                 remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);
537                 return_VALUE(-ENODEV);
538         }
539
540         return_VALUE(0);
541 }
542
543
544 static void __exit
545 acpi_button_exit (void)
546 {
547         ACPI_FUNCTION_TRACE("acpi_button_exit");
548
549         acpi_bus_unregister_driver(&acpi_button_driver);
550
551         remove_proc_entry(ACPI_BUTTON_CLASS, acpi_root_dir);
552
553         return_VOID;
554 }
555
556
557 module_init(acpi_button_init);
558 module_exit(acpi_button_exit);