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