1 /* 2 * sysfs.c - sysfs support 3 * 4 * (C) 2006-2007 Shaohua Li <shaohua.li@intel.com> 5 * 6 * This code is licenced under the GPL. 7 */ 8 9 #include <linux/kernel.h> 10 #include <linux/cpuidle.h> 11 #include <linux/sysfs.h> 12 #include <linux/slab.h> 13 #include <linux/cpu.h> 14 #include <linux/capability.h> 15 16 #include "cpuidle.h" 17 18 static unsigned int sysfs_switch; 19 static int __init cpuidle_sysfs_setup(char *unused) 20 { 21 sysfs_switch = 1; 22 return 1; 23 } 24 __setup("cpuidle_sysfs_switch", cpuidle_sysfs_setup); 25 26 static ssize_t show_available_governors(struct device *dev, 27 struct device_attribute *attr, 28 char *buf) 29 { 30 ssize_t i = 0; 31 struct cpuidle_governor *tmp; 32 33 mutex_lock(&cpuidle_lock); 34 list_for_each_entry(tmp, &cpuidle_governors, governor_list) { 35 if (i >= (ssize_t) ((PAGE_SIZE/sizeof(char)) - CPUIDLE_NAME_LEN - 2)) 36 goto out; 37 i += scnprintf(&buf[i], CPUIDLE_NAME_LEN, "%s ", tmp->name); 38 } 39 40 out: 41 i+= sprintf(&buf[i], "\n"); 42 mutex_unlock(&cpuidle_lock); 43 return i; 44 } 45 46 static ssize_t show_current_driver(struct device *dev, 47 struct device_attribute *attr, 48 char *buf) 49 { 50 ssize_t ret; 51 struct cpuidle_driver *cpuidle_driver = cpuidle_get_driver(); 52 53 spin_lock(&cpuidle_driver_lock); 54 if (cpuidle_driver) 55 ret = sprintf(buf, "%s\n", cpuidle_driver->name); 56 else 57 ret = sprintf(buf, "none\n"); 58 spin_unlock(&cpuidle_driver_lock); 59 60 return ret; 61 } 62 63 static ssize_t show_current_governor(struct device *dev, 64 struct device_attribute *attr, 65 char *buf) 66 { 67 ssize_t ret; 68 69 mutex_lock(&cpuidle_lock); 70 if (cpuidle_curr_governor) 71 ret = sprintf(buf, "%s\n", cpuidle_curr_governor->name); 72 else 73 ret = sprintf(buf, "none\n"); 74 mutex_unlock(&cpuidle_lock); 75 76 return ret; 77 } 78 79 static ssize_t store_current_governor(struct device *dev, 80 struct device_attribute *attr, 81 const char *buf, size_t count) 82 { 83 char gov_name[CPUIDLE_NAME_LEN]; 84 int ret = -EINVAL; 85 size_t len = count; 86 struct cpuidle_governor *gov; 87 88 if (!len || len >= sizeof(gov_name)) 89 return -EINVAL; 90 91 memcpy(gov_name, buf, len); 92 gov_name[len] = '\0'; 93 if (gov_name[len - 1] == '\n') 94 gov_name[--len] = '\0'; 95 96 mutex_lock(&cpuidle_lock); 97 98 list_for_each_entry(gov, &cpuidle_governors, governor_list) { 99 if (strlen(gov->name) == len && !strcmp(gov->name, gov_name)) { 100 ret = cpuidle_switch_governor(gov); 101 break; 102 } 103 } 104 105 mutex_unlock(&cpuidle_lock); 106 107 if (ret) 108 return ret; 109 else 110 return count; 111 } 112 113 static DEVICE_ATTR(current_driver, 0444, show_current_driver, NULL); 114 static DEVICE_ATTR(current_governor_ro, 0444, show_current_governor, NULL); 115 116 static struct attribute *cpuidle_default_attrs[] = { 117 &dev_attr_current_driver.attr, 118 &dev_attr_current_governor_ro.attr, 119 NULL 120 }; 121 122 static DEVICE_ATTR(available_governors, 0444, show_available_governors, NULL); 123 static DEVICE_ATTR(current_governor, 0644, show_current_governor, 124 store_current_governor); 125 126 static struct attribute *cpuidle_switch_attrs[] = { 127 &dev_attr_available_governors.attr, 128 &dev_attr_current_driver.attr, 129 &dev_attr_current_governor.attr, 130 NULL 131 }; 132 133 static struct attribute_group cpuidle_attr_group = { 134 .attrs = cpuidle_default_attrs, 135 .name = "cpuidle", 136 }; 137 138 /** 139 * cpuidle_add_interface - add CPU global sysfs attributes 140 */ 141 int cpuidle_add_interface(struct device *dev) 142 { 143 if (sysfs_switch) 144 cpuidle_attr_group.attrs = cpuidle_switch_attrs; 145 146 return sysfs_create_group(&dev->kobj, &cpuidle_attr_group); 147 } 148 149 /** 150 * cpuidle_remove_interface - remove CPU global sysfs attributes 151 */ 152 void cpuidle_remove_interface(struct device *dev) 153 { 154 sysfs_remove_group(&dev->kobj, &cpuidle_attr_group); 155 } 156 157 struct cpuidle_attr { 158 struct attribute attr; 159 ssize_t (*show)(struct cpuidle_device *, char *); 160 ssize_t (*store)(struct cpuidle_device *, const char *, size_t count); 161 }; 162 163 #define define_one_ro(_name, show) \ 164 static struct cpuidle_attr attr_##_name = __ATTR(_name, 0444, show, NULL) 165 #define define_one_rw(_name, show, store) \ 166 static struct cpuidle_attr attr_##_name = __ATTR(_name, 0644, show, store) 167 168 #define kobj_to_cpuidledev(k) container_of(k, struct cpuidle_device, kobj) 169 #define attr_to_cpuidleattr(a) container_of(a, struct cpuidle_attr, attr) 170 static ssize_t cpuidle_show(struct kobject * kobj, struct attribute * attr ,char * buf) 171 { 172 int ret = -EIO; 173 struct cpuidle_device *dev = kobj_to_cpuidledev(kobj); 174 struct cpuidle_attr * cattr = attr_to_cpuidleattr(attr); 175 176 if (cattr->show) { 177 mutex_lock(&cpuidle_lock); 178 ret = cattr->show(dev, buf); 179 mutex_unlock(&cpuidle_lock); 180 } 181 return ret; 182 } 183 184 static ssize_t cpuidle_store(struct kobject * kobj, struct attribute * attr, 185 const char * buf, size_t count) 186 { 187 int ret = -EIO; 188 struct cpuidle_device *dev = kobj_to_cpuidledev(kobj); 189 struct cpuidle_attr * cattr = attr_to_cpuidleattr(attr); 190 191 if (cattr->store) { 192 mutex_lock(&cpuidle_lock); 193 ret = cattr->store(dev, buf, count); 194 mutex_unlock(&cpuidle_lock); 195 } 196 return ret; 197 } 198 199 static const struct sysfs_ops cpuidle_sysfs_ops = { 200 .show = cpuidle_show, 201 .store = cpuidle_store, 202 }; 203 204 static void cpuidle_sysfs_release(struct kobject *kobj) 205 { 206 struct cpuidle_device *dev = kobj_to_cpuidledev(kobj); 207 208 complete(&dev->kobj_unregister); 209 } 210 211 static struct kobj_type ktype_cpuidle = { 212 .sysfs_ops = &cpuidle_sysfs_ops, 213 .release = cpuidle_sysfs_release, 214 }; 215 216 struct cpuidle_state_attr { 217 struct attribute attr; 218 ssize_t (*show)(struct cpuidle_state *, \ 219 struct cpuidle_state_usage *, char *); 220 ssize_t (*store)(struct cpuidle_state *, const char *, size_t); 221 }; 222 223 #define define_one_state_ro(_name, show) \ 224 static struct cpuidle_state_attr attr_##_name = __ATTR(_name, 0444, show, NULL) 225 226 #define define_one_state_rw(_name, show, store) \ 227 static struct cpuidle_state_attr attr_##_name = __ATTR(_name, 0644, show, store) 228 229 #define define_show_state_function(_name) \ 230 static ssize_t show_state_##_name(struct cpuidle_state *state, \ 231 struct cpuidle_state_usage *state_usage, char *buf) \ 232 { \ 233 return sprintf(buf, "%u\n", state->_name);\ 234 } 235 236 #define define_store_state_function(_name) \ 237 static ssize_t store_state_##_name(struct cpuidle_state *state, \ 238 const char *buf, size_t size) \ 239 { \ 240 long value; \ 241 int err; \ 242 if (!capable(CAP_SYS_ADMIN)) \ 243 return -EPERM; \ 244 err = kstrtol(buf, 0, &value); \ 245 if (err) \ 246 return err; \ 247 if (value) \ 248 state->disable = 1; \ 249 else \ 250 state->disable = 0; \ 251 return size; \ 252 } 253 254 #define define_show_state_ull_function(_name) \ 255 static ssize_t show_state_##_name(struct cpuidle_state *state, \ 256 struct cpuidle_state_usage *state_usage, char *buf) \ 257 { \ 258 return sprintf(buf, "%llu\n", state_usage->_name);\ 259 } 260 261 #define define_show_state_str_function(_name) \ 262 static ssize_t show_state_##_name(struct cpuidle_state *state, \ 263 struct cpuidle_state_usage *state_usage, char *buf) \ 264 { \ 265 if (state->_name[0] == '\0')\ 266 return sprintf(buf, "<null>\n");\ 267 return sprintf(buf, "%s\n", state->_name);\ 268 } 269 270 define_show_state_function(exit_latency) 271 define_show_state_function(power_usage) 272 define_show_state_ull_function(usage) 273 define_show_state_ull_function(time) 274 define_show_state_str_function(name) 275 define_show_state_str_function(desc) 276 define_show_state_function(disable) 277 define_store_state_function(disable) 278 279 define_one_state_ro(name, show_state_name); 280 define_one_state_ro(desc, show_state_desc); 281 define_one_state_ro(latency, show_state_exit_latency); 282 define_one_state_ro(power, show_state_power_usage); 283 define_one_state_ro(usage, show_state_usage); 284 define_one_state_ro(time, show_state_time); 285 define_one_state_rw(disable, show_state_disable, store_state_disable); 286 287 static struct attribute *cpuidle_state_default_attrs[] = { 288 &attr_name.attr, 289 &attr_desc.attr, 290 &attr_latency.attr, 291 &attr_power.attr, 292 &attr_usage.attr, 293 &attr_time.attr, 294 &attr_disable.attr, 295 NULL 296 }; 297 298 #define kobj_to_state_obj(k) container_of(k, struct cpuidle_state_kobj, kobj) 299 #define kobj_to_state(k) (kobj_to_state_obj(k)->state) 300 #define kobj_to_state_usage(k) (kobj_to_state_obj(k)->state_usage) 301 #define attr_to_stateattr(a) container_of(a, struct cpuidle_state_attr, attr) 302 static ssize_t cpuidle_state_show(struct kobject * kobj, 303 struct attribute * attr ,char * buf) 304 { 305 int ret = -EIO; 306 struct cpuidle_state *state = kobj_to_state(kobj); 307 struct cpuidle_state_usage *state_usage = kobj_to_state_usage(kobj); 308 struct cpuidle_state_attr * cattr = attr_to_stateattr(attr); 309 310 if (cattr->show) 311 ret = cattr->show(state, state_usage, buf); 312 313 return ret; 314 } 315 316 static ssize_t cpuidle_state_store(struct kobject *kobj, 317 struct attribute *attr, const char *buf, size_t size) 318 { 319 int ret = -EIO; 320 struct cpuidle_state *state = kobj_to_state(kobj); 321 struct cpuidle_state_attr *cattr = attr_to_stateattr(attr); 322 323 if (cattr->store) 324 ret = cattr->store(state, buf, size); 325 326 return ret; 327 } 328 329 static const struct sysfs_ops cpuidle_state_sysfs_ops = { 330 .show = cpuidle_state_show, 331 .store = cpuidle_state_store, 332 }; 333 334 static void cpuidle_state_sysfs_release(struct kobject *kobj) 335 { 336 struct cpuidle_state_kobj *state_obj = kobj_to_state_obj(kobj); 337 338 complete(&state_obj->kobj_unregister); 339 } 340 341 static struct kobj_type ktype_state_cpuidle = { 342 .sysfs_ops = &cpuidle_state_sysfs_ops, 343 .default_attrs = cpuidle_state_default_attrs, 344 .release = cpuidle_state_sysfs_release, 345 }; 346 347 static inline void cpuidle_free_state_kobj(struct cpuidle_device *device, int i) 348 { 349 kobject_put(&device->kobjs[i]->kobj); 350 wait_for_completion(&device->kobjs[i]->kobj_unregister); 351 kfree(device->kobjs[i]); 352 device->kobjs[i] = NULL; 353 } 354 355 /** 356 * cpuidle_add_driver_sysfs - adds driver-specific sysfs attributes 357 * @device: the target device 358 */ 359 int cpuidle_add_state_sysfs(struct cpuidle_device *device) 360 { 361 int i, ret = -ENOMEM; 362 struct cpuidle_state_kobj *kobj; 363 struct cpuidle_driver *drv = cpuidle_get_driver(); 364 365 /* state statistics */ 366 for (i = 0; i < device->state_count; i++) { 367 kobj = kzalloc(sizeof(struct cpuidle_state_kobj), GFP_KERNEL); 368 if (!kobj) 369 goto error_state; 370 kobj->state = &drv->states[i]; 371 kobj->state_usage = &device->states_usage[i]; 372 init_completion(&kobj->kobj_unregister); 373 374 ret = kobject_init_and_add(&kobj->kobj, &ktype_state_cpuidle, &device->kobj, 375 "state%d", i); 376 if (ret) { 377 kfree(kobj); 378 goto error_state; 379 } 380 kobject_uevent(&kobj->kobj, KOBJ_ADD); 381 device->kobjs[i] = kobj; 382 } 383 384 return 0; 385 386 error_state: 387 for (i = i - 1; i >= 0; i--) 388 cpuidle_free_state_kobj(device, i); 389 return ret; 390 } 391 392 /** 393 * cpuidle_remove_driver_sysfs - removes driver-specific sysfs attributes 394 * @device: the target device 395 */ 396 void cpuidle_remove_state_sysfs(struct cpuidle_device *device) 397 { 398 int i; 399 400 for (i = 0; i < device->state_count; i++) 401 cpuidle_free_state_kobj(device, i); 402 } 403 404 /** 405 * cpuidle_add_sysfs - creates a sysfs instance for the target device 406 * @dev: the target device 407 */ 408 int cpuidle_add_sysfs(struct device *cpu_dev) 409 { 410 int cpu = cpu_dev->id; 411 struct cpuidle_device *dev; 412 int error; 413 414 dev = per_cpu(cpuidle_devices, cpu); 415 error = kobject_init_and_add(&dev->kobj, &ktype_cpuidle, &cpu_dev->kobj, 416 "cpuidle"); 417 if (!error) 418 kobject_uevent(&dev->kobj, KOBJ_ADD); 419 return error; 420 } 421 422 /** 423 * cpuidle_remove_sysfs - deletes a sysfs instance on the target device 424 * @dev: the target device 425 */ 426 void cpuidle_remove_sysfs(struct device *cpu_dev) 427 { 428 int cpu = cpu_dev->id; 429 struct cpuidle_device *dev; 430 431 dev = per_cpu(cpuidle_devices, cpu); 432 kobject_put(&dev->kobj); 433 } 434