drivers/acpi/fan.c

   1 /*
   2  *  acpi_fan.c - ACPI Fan Driver ($Revision: 29 $)
   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/compatmac.h>
  31 #include <linux/proc_fs.h>
  32 #include "acpi_bus.h"
  33 #include "acpi_drivers.h"
  34
  35
  36 #define ACPI_FAN_COMPONENT              0x00200000
  37 #define ACPI_FAN_CLASS                  "fan"
  38 #define ACPI_FAN_HID                    "PNP0C0B"
  39 #define ACPI_FAN_DRIVER_NAME            "ACPI Fan Driver"
  40 #define ACPI_FAN_DEVICE_NAME            "Fan"
  41 #define ACPI_FAN_FILE_STATE             "state"
  42 #define ACPI_FAN_NOTIFY_STATUS          0x80
  43
  44 #define _COMPONENT              ACPI_FAN_COMPONENT
  45 ACPI_MODULE_NAME                ("acpi_fan")
  46
  47 MODULE_AUTHOR("Paul Diefenbaugh");
  48 MODULE_DESCRIPTION(ACPI_FAN_DRIVER_NAME);
  49 MODULE_LICENSE("GPL");
  50
  51 int acpi_fan_add (struct acpi_device *device);
  52 int acpi_fan_remove (struct acpi_device *device, int type);
  53
  54 static struct acpi_driver acpi_fan_driver = {
  55         .name =         ACPI_FAN_DRIVER_NAME,
  56         .class =        ACPI_FAN_CLASS,
  57         .ids =          ACPI_FAN_HID,
  58         .ops =          {
  59                                 .add =          acpi_fan_add,
  60                                 .remove =       acpi_fan_remove,
  61                         },
  62 };
  63
  64 struct acpi_fan {
  65         acpi_handle             handle;
  66 };
  67
  68
  69 /* --------------------------------------------------------------------------
  70                               FS Interface (/proc)
  71    -------------------------------------------------------------------------- */
  72
  73 struct proc_dir_entry           *acpi_fan_dir = NULL;
  74
  75
  76 static int
  77 acpi_fan_read_state (
  78         char                    *page,
  79         char                    **start,
  80         off_t                   off,
  81         int                     count,
  82         int                     *eof,
  83         void                    *data)
  84 {
  85         struct acpi_fan         *fan = (struct acpi_fan *) data;
  86         char                    *p = page;
  87         int                     len = 0;
  88         int                     state = 0;
  89
  90         ACPI_FUNCTION_TRACE("acpi_fan_read_state");
  91
  92         if (!fan || (off != 0))
  93                 goto end;
  94
  95         if (acpi_bus_get_power(fan->handle, &state))
  96                 goto end;
  97
  98         p += sprintf(p, "status:                  %s\n",
  99                 !state?"on":"off");
 100
 101 end:
 102         len = (p - page);
 103         if (len <= off+count) *eof = 1;
 104         *start = page + off;
 105         len -= off;
 106         if (len>count) len = count;
 107         if (len<0) len = 0;
 108
 109         return_VALUE(len);
 110 }
 111
 112
 113 static int
 114 acpi_fan_write_state (
 115         struct file             *file,
 116         const char              *buffer,
 117         unsigned long           count,
 118         void                    *data)
 119 {
 120         int                     result = 0;
 121         struct acpi_fan         *fan = (struct acpi_fan *) data;
 122         char                    state_string[12] = {'\0'};
 123
 124         ACPI_FUNCTION_TRACE("acpi_fan_write_state");
 125
 126         if (!fan || (count > sizeof(state_string) - 1))
 127                 return_VALUE(-EINVAL);
 128
 129         if (copy_from_user(state_string, buffer, count))
 130                 return_VALUE(-EFAULT);
 131
 132         state_string[count] = '\0';
 133
 134         result = acpi_bus_set_power(fan->handle,
 135                 simple_strtoul(state_string, NULL, 0));
 136         if (result)
 137                 return_VALUE(result);
 138
 139         return_VALUE(count);
 140 }
 141
 142
 143 static int
 144 acpi_fan_add_fs (
 145         struct acpi_device      *device)
 146 {
 147         struct proc_dir_entry   *entry = NULL;
 148
 149         ACPI_FUNCTION_TRACE("acpi_fan_add_fs");
 150
 151         if (!device)
 152                 return_VALUE(-EINVAL);
 153
 154         if (!acpi_device_dir(device)) {
 155                 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
 156                         acpi_fan_dir);
 157                 if (!acpi_device_dir(device))
 158                         return_VALUE(-ENODEV);
 159         }
 160
 161         /* 'status' [R/W] */
 162         entry = create_proc_entry(ACPI_FAN_FILE_STATE,
 163                 S_IFREG|S_IRUGO|S_IWUSR, acpi_device_dir(device));
 164         if (!entry)
 165                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 166                         "Unable to create '%s' fs entry\n",
 167                         ACPI_FAN_FILE_STATE));
 168         else {
 169                 entry->read_proc = acpi_fan_read_state;
 170                 entry->write_proc = acpi_fan_write_state;
 171                 entry->data = acpi_driver_data(device);
 172         }
 173
 174         return_VALUE(0);
 175 }
 176
 177
 178 static int
 179 acpi_fan_remove_fs (
 180         struct acpi_device      *device)
 181 {
 182         ACPI_FUNCTION_TRACE("acpi_fan_remove_fs");
 183
 184         if (acpi_device_dir(device))
 185                 remove_proc_entry(acpi_device_bid(device), acpi_fan_dir);
 186
 187         return_VALUE(0);
 188 }
 189
 190
 191 /* --------------------------------------------------------------------------
 192                                  Driver Interface
 193    -------------------------------------------------------------------------- */
 194
 195 int
 196 acpi_fan_add (
 197         struct acpi_device      *device)
 198 {
 199         int                     result = 0;
 200         struct acpi_fan         *fan = NULL;
 201         int                     state = 0;
 202
 203         ACPI_FUNCTION_TRACE("acpi_fan_add");
 204
 205         if (!device)
 206                 return_VALUE(-EINVAL);
 207
 208         fan = kmalloc(sizeof(struct acpi_fan), GFP_KERNEL);
 209         if (!fan)
 210                 return_VALUE(-ENOMEM);
 211         memset(fan, 0, sizeof(struct acpi_fan));
 212
 213         fan->handle = device->handle;
 214         sprintf(acpi_device_name(device), "%s", ACPI_FAN_DEVICE_NAME);
 215         sprintf(acpi_device_class(device), "%s", ACPI_FAN_CLASS);
 216         acpi_driver_data(device) = fan;
 217
 218         result = acpi_bus_get_power(fan->handle, &state);
 219         if (result) {
 220                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 221                         "Error reading power state\n"));
 222                 goto end;
 223         }
 224
 225         result = acpi_fan_add_fs(device);
 226         if (result)
 227                 goto end;
 228
 229         printk(KERN_INFO PREFIX "%s [%s] (%s)\n",
 230                 acpi_device_name(device), acpi_device_bid(device),
 231                 !device->power.state?"on":"off");
 232
 233 end:
 234         if (result)
 235                 kfree(fan);
 236
 237         return_VALUE(result);
 238 }
 239
 240
 241 int
 242 acpi_fan_remove (
 243         struct acpi_device      *device,
 244         int                     type)
 245 {
 246         struct acpi_fan         *fan = NULL;
 247
 248         ACPI_FUNCTION_TRACE("acpi_fan_remove");
 249
 250         if (!device || !acpi_driver_data(device))
 251                 return_VALUE(-EINVAL);
 252
 253         fan = (struct acpi_fan *) acpi_driver_data(device);
 254
 255         acpi_fan_remove_fs(device);
 256
 257         kfree(fan);
 258
 259         return_VALUE(0);
 260 }
 261
 262
 263 int __init
 264 acpi_fan_init (void)
 265 {
 266         int                     result = 0;
 267
 268         ACPI_FUNCTION_TRACE("acpi_fan_init");
 269
 270         acpi_fan_dir = proc_mkdir(ACPI_FAN_CLASS, acpi_root_dir);
 271         if (!acpi_fan_dir)
 272                 return_VALUE(-ENODEV);
 273
 274         result = acpi_bus_register_driver(&acpi_fan_driver);
 275         if (result < 0) {
 276                 remove_proc_entry(ACPI_FAN_CLASS, acpi_root_dir);
 277                 return_VALUE(-ENODEV);
 278         }
 279
 280         return_VALUE(0);
 281 }
 282
 283
 284 void __exit
 285 acpi_fan_exit (void)
 286 {
 287         ACPI_FUNCTION_TRACE("acpi_fan_exit");
 288
 289         acpi_bus_unregister_driver(&acpi_fan_driver);
 290
 291         remove_proc_entry(ACPI_FAN_CLASS, acpi_root_dir);
 292
 293         return_VOID;
 294 }
 295
 296
 297 module_init(acpi_fan_init);
 298 module_exit(acpi_fan_exit);
 299