1/* 2 * Copyright (C) 2006 - 2007 Ivo van Doorn 3 * Copyright (C) 2007 Dmitry Torokhov 4 * Copyright 2009 Johannes Berg <johannes@sipsolutions.net> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, see <http://www.gnu.org/licenses/>. 18 */ 19 20#include <linux/kernel.h> 21#include <linux/module.h> 22#include <linux/init.h> 23#include <linux/workqueue.h> 24#include <linux/capability.h> 25#include <linux/list.h> 26#include <linux/mutex.h> 27#include <linux/rfkill.h> 28#include <linux/sched.h> 29#include <linux/spinlock.h> 30#include <linux/device.h> 31#include <linux/miscdevice.h> 32#include <linux/wait.h> 33#include <linux/poll.h> 34#include <linux/fs.h> 35#include <linux/slab.h> 36 37#include "rfkill.h" 38 39#define POLL_INTERVAL (5 * HZ) 40 41#define RFKILL_BLOCK_HW BIT(0) 42#define RFKILL_BLOCK_SW BIT(1) 43#define RFKILL_BLOCK_SW_PREV BIT(2) 44#define RFKILL_BLOCK_ANY (RFKILL_BLOCK_HW |\ 45 RFKILL_BLOCK_SW |\ 46 RFKILL_BLOCK_SW_PREV) 47#define RFKILL_BLOCK_SW_SETCALL BIT(31) 48 49struct rfkill { 50 spinlock_t lock; 51 52 enum rfkill_type type; 53 54 unsigned long state; 55 56 u32 idx; 57 58 bool registered; 59 bool persistent; 60 61 const struct rfkill_ops *ops; 62 void *data; 63 64#ifdef CONFIG_RFKILL_LEDS 65 struct led_trigger led_trigger; 66 const char *ledtrigname; 67#endif 68 69 struct device dev; 70 struct list_head node; 71 72 struct delayed_work poll_work; 73 struct work_struct uevent_work; 74 struct work_struct sync_work; 75 char name[]; 76}; 77#define to_rfkill(d) container_of(d, struct rfkill, dev) 78 79struct rfkill_int_event { 80 struct list_head list; 81 struct rfkill_event ev; 82}; 83 84struct rfkill_data { 85 struct list_head list; 86 struct list_head events; 87 struct mutex mtx; 88 wait_queue_head_t read_wait; 89 bool input_handler; 90}; 91 92 93MODULE_AUTHOR("Ivo van Doorn <IvDoorn@gmail.com>"); 94MODULE_AUTHOR("Johannes Berg <johannes@sipsolutions.net>"); 95MODULE_DESCRIPTION("RF switch support"); 96MODULE_LICENSE("GPL"); 97 98 99/* 100 * The locking here should be made much smarter, we currently have 101 * a bit of a stupid situation because drivers might want to register 102 * the rfkill struct under their own lock, and take this lock during 103 * rfkill method calls -- which will cause an AB-BA deadlock situation. 104 * 105 * To fix that, we need to rework this code here to be mostly lock-free 106 * and only use the mutex for list manipulations, not to protect the 107 * various other global variables. Then we can avoid holding the mutex 108 * around driver operations, and all is happy. 109 */ 110static LIST_HEAD(rfkill_list); /* list of registered rf switches */ 111static DEFINE_MUTEX(rfkill_global_mutex); 112static LIST_HEAD(rfkill_fds); /* list of open fds of /dev/rfkill */ 113 114static unsigned int rfkill_default_state = 1; 115module_param_named(default_state, rfkill_default_state, uint, 0444); 116MODULE_PARM_DESC(default_state, 117 "Default initial state for all radio types, 0 = radio off"); 118 119static struct { 120 bool cur, sav; 121} rfkill_global_states[NUM_RFKILL_TYPES]; 122 123static bool rfkill_epo_lock_active; 124 125 126#ifdef CONFIG_RFKILL_LEDS 127static void rfkill_led_trigger_event(struct rfkill *rfkill) 128{ 129 struct led_trigger *trigger; 130 131 if (!rfkill->registered) 132 return; 133 134 trigger = &rfkill->led_trigger; 135 136 if (rfkill->state & RFKILL_BLOCK_ANY) 137 led_trigger_event(trigger, LED_OFF); 138 else 139 led_trigger_event(trigger, LED_FULL); 140} 141 142static void rfkill_led_trigger_activate(struct led_classdev *led) 143{ 144 struct rfkill *rfkill; 145 146 rfkill = container_of(led->trigger, struct rfkill, led_trigger); 147 148 rfkill_led_trigger_event(rfkill); 149} 150 151const char *rfkill_get_led_trigger_name(struct rfkill *rfkill) 152{ 153 return rfkill->led_trigger.name; 154} 155EXPORT_SYMBOL(rfkill_get_led_trigger_name); 156 157void rfkill_set_led_trigger_name(struct rfkill *rfkill, const char *name) 158{ 159 BUG_ON(!rfkill); 160 161 rfkill->ledtrigname = name; 162} 163EXPORT_SYMBOL(rfkill_set_led_trigger_name); 164 165static int rfkill_led_trigger_register(struct rfkill *rfkill) 166{ 167 rfkill->led_trigger.name = rfkill->ledtrigname 168 ? : dev_name(&rfkill->dev); 169 rfkill->led_trigger.activate = rfkill_led_trigger_activate; 170 return led_trigger_register(&rfkill->led_trigger); 171} 172 173static void rfkill_led_trigger_unregister(struct rfkill *rfkill) 174{ 175 led_trigger_unregister(&rfkill->led_trigger); 176} 177#else 178static void rfkill_led_trigger_event(struct rfkill *rfkill) 179{ 180} 181 182static inline int rfkill_led_trigger_register(struct rfkill *rfkill) 183{ 184 return 0; 185} 186 187static inline void rfkill_led_trigger_unregister(struct rfkill *rfkill) 188{ 189} 190#endif /* CONFIG_RFKILL_LEDS */ 191 192static void rfkill_fill_event(struct rfkill_event *ev, struct rfkill *rfkill, 193 enum rfkill_operation op) 194{ 195 unsigned long flags; 196 197 ev->idx = rfkill->idx; 198 ev->type = rfkill->type; 199 ev->op = op; 200 201 spin_lock_irqsave(&rfkill->lock, flags); 202 ev->hard = !!(rfkill->state & RFKILL_BLOCK_HW); 203 ev->soft = !!(rfkill->state & (RFKILL_BLOCK_SW | 204 RFKILL_BLOCK_SW_PREV)); 205 spin_unlock_irqrestore(&rfkill->lock, flags); 206} 207 208static void rfkill_send_events(struct rfkill *rfkill, enum rfkill_operation op) 209{ 210 struct rfkill_data *data; 211 struct rfkill_int_event *ev; 212 213 list_for_each_entry(data, &rfkill_fds, list) { 214 ev = kzalloc(sizeof(*ev), GFP_KERNEL); 215 if (!ev) 216 continue; 217 rfkill_fill_event(&ev->ev, rfkill, op); 218 mutex_lock(&data->mtx); 219 list_add_tail(&ev->list, &data->events); 220 mutex_unlock(&data->mtx); 221 wake_up_interruptible(&data->read_wait); 222 } 223} 224 225static void rfkill_event(struct rfkill *rfkill) 226{ 227 if (!rfkill->registered) 228 return; 229 230 kobject_uevent(&rfkill->dev.kobj, KOBJ_CHANGE); 231 232 /* also send event to /dev/rfkill */ 233 rfkill_send_events(rfkill, RFKILL_OP_CHANGE); 234} 235 236static bool __rfkill_set_hw_state(struct rfkill *rfkill, 237 bool blocked, bool *change) 238{ 239 unsigned long flags; 240 bool prev, any; 241 242 BUG_ON(!rfkill); 243 244 spin_lock_irqsave(&rfkill->lock, flags); 245 prev = !!(rfkill->state & RFKILL_BLOCK_HW); 246 if (blocked) 247 rfkill->state |= RFKILL_BLOCK_HW; 248 else 249 rfkill->state &= ~RFKILL_BLOCK_HW; 250 *change = prev != blocked; 251 any = !!(rfkill->state & RFKILL_BLOCK_ANY); 252 spin_unlock_irqrestore(&rfkill->lock, flags); 253 254 rfkill_led_trigger_event(rfkill); 255 256 return any; 257} 258 259/** 260 * rfkill_set_block - wrapper for set_block method 261 * 262 * @rfkill: the rfkill struct to use 263 * @blocked: the new software state 264 * 265 * Calls the set_block method (when applicable) and handles notifications 266 * etc. as well. 267 */ 268static void rfkill_set_block(struct rfkill *rfkill, bool blocked) 269{ 270 unsigned long flags; 271 bool prev, curr; 272 int err; 273 274 if (unlikely(rfkill->dev.power.power_state.event & PM_EVENT_SLEEP)) 275 return; 276 277 /* 278 * Some platforms (...!) generate input events which affect the 279 * _hard_ kill state -- whenever something tries to change the 280 * current software state query the hardware state too. 281 */ 282 if (rfkill->ops->query) 283 rfkill->ops->query(rfkill, rfkill->data); 284 285 spin_lock_irqsave(&rfkill->lock, flags); 286 prev = rfkill->state & RFKILL_BLOCK_SW; 287 288 if (rfkill->state & RFKILL_BLOCK_SW) 289 rfkill->state |= RFKILL_BLOCK_SW_PREV; 290 else 291 rfkill->state &= ~RFKILL_BLOCK_SW_PREV; 292 293 if (blocked) 294 rfkill->state |= RFKILL_BLOCK_SW; 295 else 296 rfkill->state &= ~RFKILL_BLOCK_SW; 297 298 rfkill->state |= RFKILL_BLOCK_SW_SETCALL; 299 spin_unlock_irqrestore(&rfkill->lock, flags); 300 301 err = rfkill->ops->set_block(rfkill->data, blocked); 302 303 spin_lock_irqsave(&rfkill->lock, flags); 304 if (err) { 305 /* 306 * Failed -- reset status to _prev, this may be different 307 * from what set set _PREV to earlier in this function 308 * if rfkill_set_sw_state was invoked. 309 */ 310 if (rfkill->state & RFKILL_BLOCK_SW_PREV) 311 rfkill->state |= RFKILL_BLOCK_SW; 312 else 313 rfkill->state &= ~RFKILL_BLOCK_SW; 314 } 315 rfkill->state &= ~RFKILL_BLOCK_SW_SETCALL; 316 rfkill->state &= ~RFKILL_BLOCK_SW_PREV; 317 curr = rfkill->state & RFKILL_BLOCK_SW; 318 spin_unlock_irqrestore(&rfkill->lock, flags); 319 320 rfkill_led_trigger_event(rfkill); 321 322 if (prev != curr) 323 rfkill_event(rfkill); 324} 325 326#ifdef CONFIG_RFKILL_INPUT 327static atomic_t rfkill_input_disabled = ATOMIC_INIT(0); 328 329/** 330 * __rfkill_switch_all - Toggle state of all switches of given type 331 * @type: type of interfaces to be affected 332 * @blocked: the new state 333 * 334 * This function sets the state of all switches of given type, 335 * unless a specific switch is claimed by userspace (in which case, 336 * that switch is left alone) or suspended. 337 * 338 * Caller must have acquired rfkill_global_mutex. 339 */ 340static void __rfkill_switch_all(const enum rfkill_type type, bool blocked) 341{ 342 struct rfkill *rfkill; 343 344 if (type == RFKILL_TYPE_ALL) { 345 int i; 346 347 for (i = 0; i < NUM_RFKILL_TYPES; i++) 348 rfkill_global_states[i].cur = blocked; 349 } else { 350 rfkill_global_states[type].cur = blocked; 351 } 352 353 list_for_each_entry(rfkill, &rfkill_list, node) { 354 if (rfkill->type != type && type != RFKILL_TYPE_ALL) 355 continue; 356 357 rfkill_set_block(rfkill, blocked); 358 } 359} 360 361/** 362 * rfkill_switch_all - Toggle state of all switches of given type 363 * @type: type of interfaces to be affected 364 * @blocked: the new state 365 * 366 * Acquires rfkill_global_mutex and calls __rfkill_switch_all(@type, @state). 367 * Please refer to __rfkill_switch_all() for details. 368 * 369 * Does nothing if the EPO lock is active. 370 */ 371void rfkill_switch_all(enum rfkill_type type, bool blocked) 372{ 373 if (atomic_read(&rfkill_input_disabled)) 374 return; 375 376 mutex_lock(&rfkill_global_mutex); 377 378 if (!rfkill_epo_lock_active) 379 __rfkill_switch_all(type, blocked); 380 381 mutex_unlock(&rfkill_global_mutex); 382} 383 384/** 385 * rfkill_epo - emergency power off all transmitters 386 * 387 * This kicks all non-suspended rfkill devices to RFKILL_STATE_SOFT_BLOCKED, 388 * ignoring everything in its path but rfkill_global_mutex and rfkill->mutex. 389 * 390 * The global state before the EPO is saved and can be restored later 391 * using rfkill_restore_states(). 392 */ 393void rfkill_epo(void) 394{ 395 struct rfkill *rfkill; 396 int i; 397 398 if (atomic_read(&rfkill_input_disabled)) 399 return; 400 401 mutex_lock(&rfkill_global_mutex); 402 403 rfkill_epo_lock_active = true; 404 list_for_each_entry(rfkill, &rfkill_list, node) 405 rfkill_set_block(rfkill, true); 406 407 for (i = 0; i < NUM_RFKILL_TYPES; i++) { 408 rfkill_global_states[i].sav = rfkill_global_states[i].cur; 409 rfkill_global_states[i].cur = true; 410 } 411 412 mutex_unlock(&rfkill_global_mutex); 413} 414 415/** 416 * rfkill_restore_states - restore global states 417 * 418 * Restore (and sync switches to) the global state from the 419 * states in rfkill_default_states. This can undo the effects of 420 * a call to rfkill_epo(). 421 */ 422void rfkill_restore_states(void) 423{ 424 int i; 425 426 if (atomic_read(&rfkill_input_disabled)) 427 return; 428 429 mutex_lock(&rfkill_global_mutex); 430 431 rfkill_epo_lock_active = false; 432 for (i = 0; i < NUM_RFKILL_TYPES; i++) 433 __rfkill_switch_all(i, rfkill_global_states[i].sav); 434 mutex_unlock(&rfkill_global_mutex); 435} 436 437/** 438 * rfkill_remove_epo_lock - unlock state changes 439 * 440 * Used by rfkill-input manually unlock state changes, when 441 * the EPO switch is deactivated. 442 */ 443void rfkill_remove_epo_lock(void) 444{ 445 if (atomic_read(&rfkill_input_disabled)) 446 return; 447 448 mutex_lock(&rfkill_global_mutex); 449 rfkill_epo_lock_active = false; 450 mutex_unlock(&rfkill_global_mutex); 451} 452 453/** 454 * rfkill_is_epo_lock_active - returns true EPO is active 455 * 456 * Returns 0 (false) if there is NOT an active EPO contidion, 457 * and 1 (true) if there is an active EPO contition, which 458 * locks all radios in one of the BLOCKED states. 459 * 460 * Can be called in atomic context. 461 */ 462bool rfkill_is_epo_lock_active(void) 463{ 464 return rfkill_epo_lock_active; 465} 466 467/** 468 * rfkill_get_global_sw_state - returns global state for a type 469 * @type: the type to get the global state of 470 * 471 * Returns the current global state for a given wireless 472 * device type. 473 */ 474bool rfkill_get_global_sw_state(const enum rfkill_type type) 475{ 476 return rfkill_global_states[type].cur; 477} 478#endif 479 480 481bool rfkill_set_hw_state(struct rfkill *rfkill, bool blocked) 482{ 483 bool ret, change; 484 485 ret = __rfkill_set_hw_state(rfkill, blocked, &change); 486 487 if (!rfkill->registered) 488 return ret; 489 490 if (change) 491 schedule_work(&rfkill->uevent_work); 492 493 return ret; 494} 495EXPORT_SYMBOL(rfkill_set_hw_state); 496 497static void __rfkill_set_sw_state(struct rfkill *rfkill, bool blocked) 498{ 499 u32 bit = RFKILL_BLOCK_SW; 500 501 /* if in a ops->set_block right now, use other bit */ 502 if (rfkill->state & RFKILL_BLOCK_SW_SETCALL) 503 bit = RFKILL_BLOCK_SW_PREV; 504 505 if (blocked) 506 rfkill->state |= bit; 507 else 508 rfkill->state &= ~bit; 509} 510 511bool rfkill_set_sw_state(struct rfkill *rfkill, bool blocked) 512{ 513 unsigned long flags; 514 bool prev, hwblock; 515 516 BUG_ON(!rfkill); 517 518 spin_lock_irqsave(&rfkill->lock, flags); 519 prev = !!(rfkill->state & RFKILL_BLOCK_SW); 520 __rfkill_set_sw_state(rfkill, blocked); 521 hwblock = !!(rfkill->state & RFKILL_BLOCK_HW); 522 blocked = blocked || hwblock; 523 spin_unlock_irqrestore(&rfkill->lock, flags); 524 525 if (!rfkill->registered) 526 return blocked; 527 528 if (prev != blocked && !hwblock) 529 schedule_work(&rfkill->uevent_work); 530 531 rfkill_led_trigger_event(rfkill); 532 533 return blocked; 534} 535EXPORT_SYMBOL(rfkill_set_sw_state); 536 537void rfkill_init_sw_state(struct rfkill *rfkill, bool blocked) 538{ 539 unsigned long flags; 540 541 BUG_ON(!rfkill); 542 BUG_ON(rfkill->registered); 543 544 spin_lock_irqsave(&rfkill->lock, flags); 545 __rfkill_set_sw_state(rfkill, blocked); 546 rfkill->persistent = true; 547 spin_unlock_irqrestore(&rfkill->lock, flags); 548} 549EXPORT_SYMBOL(rfkill_init_sw_state); 550 551void rfkill_set_states(struct rfkill *rfkill, bool sw, bool hw) 552{ 553 unsigned long flags; 554 bool swprev, hwprev; 555 556 BUG_ON(!rfkill); 557 558 spin_lock_irqsave(&rfkill->lock, flags); 559 560 /* 561 * No need to care about prev/setblock ... this is for uevent only 562 * and that will get triggered by rfkill_set_block anyway. 563 */ 564 swprev = !!(rfkill->state & RFKILL_BLOCK_SW); 565 hwprev = !!(rfkill->state & RFKILL_BLOCK_HW); 566 __rfkill_set_sw_state(rfkill, sw); 567 if (hw) 568 rfkill->state |= RFKILL_BLOCK_HW; 569 else 570 rfkill->state &= ~RFKILL_BLOCK_HW; 571 572 spin_unlock_irqrestore(&rfkill->lock, flags); 573 574 if (!rfkill->registered) { 575 rfkill->persistent = true; 576 } else { 577 if (swprev != sw || hwprev != hw) 578 schedule_work(&rfkill->uevent_work); 579 580 rfkill_led_trigger_event(rfkill); 581 } 582} 583EXPORT_SYMBOL(rfkill_set_states); 584 585static ssize_t name_show(struct device *dev, struct device_attribute *attr, 586 char *buf) 587{ 588 struct rfkill *rfkill = to_rfkill(dev); 589 590 return sprintf(buf, "%s\n", rfkill->name); 591} 592static DEVICE_ATTR_RO(name); 593 594static const char *rfkill_get_type_str(enum rfkill_type type) 595{ 596 BUILD_BUG_ON(NUM_RFKILL_TYPES != RFKILL_TYPE_NFC + 1); 597 598 switch (type) { 599 case RFKILL_TYPE_WLAN: 600 return "wlan"; 601 case RFKILL_TYPE_BLUETOOTH: 602 return "bluetooth"; 603 case RFKILL_TYPE_UWB: 604 return "ultrawideband"; 605 case RFKILL_TYPE_WIMAX: 606 return "wimax"; 607 case RFKILL_TYPE_WWAN: 608 return "wwan"; 609 case RFKILL_TYPE_GPS: 610 return "gps"; 611 case RFKILL_TYPE_FM: 612 return "fm"; 613 case RFKILL_TYPE_NFC: 614 return "nfc"; 615 default: 616 BUG(); 617 } 618} 619 620static ssize_t type_show(struct device *dev, struct device_attribute *attr, 621 char *buf) 622{ 623 struct rfkill *rfkill = to_rfkill(dev); 624 625 return sprintf(buf, "%s\n", rfkill_get_type_str(rfkill->type)); 626} 627static DEVICE_ATTR_RO(type); 628 629static ssize_t index_show(struct device *dev, struct device_attribute *attr, 630 char *buf) 631{ 632 struct rfkill *rfkill = to_rfkill(dev); 633 634 return sprintf(buf, "%d\n", rfkill->idx); 635} 636static DEVICE_ATTR_RO(index); 637 638static ssize_t persistent_show(struct device *dev, 639 struct device_attribute *attr, char *buf) 640{ 641 struct rfkill *rfkill = to_rfkill(dev); 642 643 return sprintf(buf, "%d\n", rfkill->persistent); 644} 645static DEVICE_ATTR_RO(persistent); 646 647static ssize_t hard_show(struct device *dev, struct device_attribute *attr, 648 char *buf) 649{ 650 struct rfkill *rfkill = to_rfkill(dev); 651 652 return sprintf(buf, "%d\n", (rfkill->state & RFKILL_BLOCK_HW) ? 1 : 0 ); 653} 654static DEVICE_ATTR_RO(hard); 655 656static ssize_t soft_show(struct device *dev, struct device_attribute *attr, 657 char *buf) 658{ 659 struct rfkill *rfkill = to_rfkill(dev); 660 661 return sprintf(buf, "%d\n", (rfkill->state & RFKILL_BLOCK_SW) ? 1 : 0 ); 662} 663 664static ssize_t soft_store(struct device *dev, struct device_attribute *attr, 665 const char *buf, size_t count) 666{ 667 struct rfkill *rfkill = to_rfkill(dev); 668 unsigned long state; 669 int err; 670 671 if (!capable(CAP_NET_ADMIN)) 672 return -EPERM; 673 674 err = kstrtoul(buf, 0, &state); 675 if (err) 676 return err; 677 678 if (state > 1 ) 679 return -EINVAL; 680 681 mutex_lock(&rfkill_global_mutex); 682 rfkill_set_block(rfkill, state); 683 mutex_unlock(&rfkill_global_mutex); 684 685 return count; 686} 687static DEVICE_ATTR_RW(soft); 688 689static u8 user_state_from_blocked(unsigned long state) 690{ 691 if (state & RFKILL_BLOCK_HW) 692 return RFKILL_USER_STATE_HARD_BLOCKED; 693 if (state & RFKILL_BLOCK_SW) 694 return RFKILL_USER_STATE_SOFT_BLOCKED; 695 696 return RFKILL_USER_STATE_UNBLOCKED; 697} 698 699static ssize_t state_show(struct device *dev, struct device_attribute *attr, 700 char *buf) 701{ 702 struct rfkill *rfkill = to_rfkill(dev); 703 704 return sprintf(buf, "%d\n", user_state_from_blocked(rfkill->state)); 705} 706 707static ssize_t state_store(struct device *dev, struct device_attribute *attr, 708 const char *buf, size_t count) 709{ 710 struct rfkill *rfkill = to_rfkill(dev); 711 unsigned long state; 712 int err; 713 714 if (!capable(CAP_NET_ADMIN)) 715 return -EPERM; 716 717 err = kstrtoul(buf, 0, &state); 718 if (err) 719 return err; 720 721 if (state != RFKILL_USER_STATE_SOFT_BLOCKED && 722 state != RFKILL_USER_STATE_UNBLOCKED) 723 return -EINVAL; 724 725 mutex_lock(&rfkill_global_mutex); 726 rfkill_set_block(rfkill, state == RFKILL_USER_STATE_SOFT_BLOCKED); 727 mutex_unlock(&rfkill_global_mutex); 728 729 return count; 730} 731static DEVICE_ATTR_RW(state); 732 733static ssize_t claim_show(struct device *dev, struct device_attribute *attr, 734 char *buf) 735{ 736 return sprintf(buf, "%d\n", 0); 737} 738static DEVICE_ATTR_RO(claim); 739 740static struct attribute *rfkill_dev_attrs[] = { 741 &dev_attr_name.attr, 742 &dev_attr_type.attr, 743 &dev_attr_index.attr, 744 &dev_attr_persistent.attr, 745 &dev_attr_state.attr, 746 &dev_attr_claim.attr, 747 &dev_attr_soft.attr, 748 &dev_attr_hard.attr, 749 NULL, 750}; 751ATTRIBUTE_GROUPS(rfkill_dev); 752 753static void rfkill_release(struct device *dev) 754{ 755 struct rfkill *rfkill = to_rfkill(dev); 756 757 kfree(rfkill); 758} 759 760static int rfkill_dev_uevent(struct device *dev, struct kobj_uevent_env *env) 761{ 762 struct rfkill *rfkill = to_rfkill(dev); 763 unsigned long flags; 764 u32 state; 765 int error; 766 767 error = add_uevent_var(env, "RFKILL_NAME=%s", rfkill->name); 768 if (error) 769 return error; 770 error = add_uevent_var(env, "RFKILL_TYPE=%s", 771 rfkill_get_type_str(rfkill->type)); 772 if (error) 773 return error; 774 spin_lock_irqsave(&rfkill->lock, flags); 775 state = rfkill->state; 776 spin_unlock_irqrestore(&rfkill->lock, flags); 777 error = add_uevent_var(env, "RFKILL_STATE=%d", 778 user_state_from_blocked(state)); 779 return error; 780} 781 782void rfkill_pause_polling(struct rfkill *rfkill) 783{ 784 BUG_ON(!rfkill); 785 786 if (!rfkill->ops->poll) 787 return; 788 789 cancel_delayed_work_sync(&rfkill->poll_work); 790} 791EXPORT_SYMBOL(rfkill_pause_polling); 792 793void rfkill_resume_polling(struct rfkill *rfkill) 794{ 795 BUG_ON(!rfkill); 796 797 if (!rfkill->ops->poll) 798 return; 799 800 queue_delayed_work(system_power_efficient_wq, 801 &rfkill->poll_work, 0); 802} 803EXPORT_SYMBOL(rfkill_resume_polling); 804 805#ifdef CONFIG_PM_SLEEP 806static int rfkill_suspend(struct device *dev) 807{ 808 struct rfkill *rfkill = to_rfkill(dev); 809 810 rfkill_pause_polling(rfkill); 811 812 return 0; 813} 814 815static int rfkill_resume(struct device *dev) 816{ 817 struct rfkill *rfkill = to_rfkill(dev); 818 bool cur; 819 820 if (!rfkill->persistent) { 821 cur = !!(rfkill->state & RFKILL_BLOCK_SW); 822 rfkill_set_block(rfkill, cur); 823 } 824 825 rfkill_resume_polling(rfkill); 826 827 return 0; 828} 829 830static SIMPLE_DEV_PM_OPS(rfkill_pm_ops, rfkill_suspend, rfkill_resume); 831#define RFKILL_PM_OPS (&rfkill_pm_ops) 832#else 833#define RFKILL_PM_OPS NULL 834#endif 835 836static struct class rfkill_class = { 837 .name = "rfkill", 838 .dev_release = rfkill_release, 839 .dev_groups = rfkill_dev_groups, 840 .dev_uevent = rfkill_dev_uevent, 841 .pm = RFKILL_PM_OPS, 842}; 843 844bool rfkill_blocked(struct rfkill *rfkill) 845{ 846 unsigned long flags; 847 u32 state; 848 849 spin_lock_irqsave(&rfkill->lock, flags); 850 state = rfkill->state; 851 spin_unlock_irqrestore(&rfkill->lock, flags); 852 853 return !!(state & RFKILL_BLOCK_ANY); 854} 855EXPORT_SYMBOL(rfkill_blocked); 856 857 858struct rfkill * __must_check rfkill_alloc(const char *name, 859 struct device *parent, 860 const enum rfkill_type type, 861 const struct rfkill_ops *ops, 862 void *ops_data) 863{ 864 struct rfkill *rfkill; 865 struct device *dev; 866 867 if (WARN_ON(!ops)) 868 return NULL; 869 870 if (WARN_ON(!ops->set_block)) 871 return NULL; 872 873 if (WARN_ON(!name)) 874 return NULL; 875 876 if (WARN_ON(type == RFKILL_TYPE_ALL || type >= NUM_RFKILL_TYPES)) 877 return NULL; 878 879 rfkill = kzalloc(sizeof(*rfkill) + strlen(name) + 1, GFP_KERNEL); 880 if (!rfkill) 881 return NULL; 882 883 spin_lock_init(&rfkill->lock); 884 INIT_LIST_HEAD(&rfkill->node); 885 rfkill->type = type; 886 strcpy(rfkill->name, name); 887 rfkill->ops = ops; 888 rfkill->data = ops_data; 889 890 dev = &rfkill->dev; 891 dev->class = &rfkill_class; 892 dev->parent = parent; 893 device_initialize(dev); 894 895 return rfkill; 896} 897EXPORT_SYMBOL(rfkill_alloc); 898 899static void rfkill_poll(struct work_struct *work) 900{ 901 struct rfkill *rfkill; 902 903 rfkill = container_of(work, struct rfkill, poll_work.work); 904 905 /* 906 * Poll hardware state -- driver will use one of the 907 * rfkill_set{,_hw,_sw}_state functions and use its 908 * return value to update the current status. 909 */ 910 rfkill->ops->poll(rfkill, rfkill->data); 911 912 queue_delayed_work(system_power_efficient_wq, 913 &rfkill->poll_work, 914 round_jiffies_relative(POLL_INTERVAL)); 915} 916 917static void rfkill_uevent_work(struct work_struct *work) 918{ 919 struct rfkill *rfkill; 920 921 rfkill = container_of(work, struct rfkill, uevent_work); 922 923 mutex_lock(&rfkill_global_mutex); 924 rfkill_event(rfkill); 925 mutex_unlock(&rfkill_global_mutex); 926} 927 928static void rfkill_sync_work(struct work_struct *work) 929{ 930 struct rfkill *rfkill; 931 bool cur; 932 933 rfkill = container_of(work, struct rfkill, sync_work); 934 935 mutex_lock(&rfkill_global_mutex); 936 cur = rfkill_global_states[rfkill->type].cur; 937 rfkill_set_block(rfkill, cur); 938 mutex_unlock(&rfkill_global_mutex); 939} 940 941int __must_check rfkill_register(struct rfkill *rfkill) 942{ 943 static unsigned long rfkill_no; 944 struct device *dev = &rfkill->dev; 945 int error; 946 947 BUG_ON(!rfkill); 948 949 mutex_lock(&rfkill_global_mutex); 950 951 if (rfkill->registered) { 952 error = -EALREADY; 953 goto unlock; 954 } 955 956 rfkill->idx = rfkill_no; 957 dev_set_name(dev, "rfkill%lu", rfkill_no); 958 rfkill_no++; 959 960 list_add_tail(&rfkill->node, &rfkill_list); 961 962 error = device_add(dev); 963 if (error) 964 goto remove; 965 966 error = rfkill_led_trigger_register(rfkill); 967 if (error) 968 goto devdel; 969 970 rfkill->registered = true; 971 972 INIT_DELAYED_WORK(&rfkill->poll_work, rfkill_poll); 973 INIT_WORK(&rfkill->uevent_work, rfkill_uevent_work); 974 INIT_WORK(&rfkill->sync_work, rfkill_sync_work); 975 976 if (rfkill->ops->poll) 977 queue_delayed_work(system_power_efficient_wq, 978 &rfkill->poll_work, 979 round_jiffies_relative(POLL_INTERVAL)); 980 981 if (!rfkill->persistent || rfkill_epo_lock_active) { 982 schedule_work(&rfkill->sync_work); 983 } else { 984#ifdef CONFIG_RFKILL_INPUT 985 bool soft_blocked = !!(rfkill->state & RFKILL_BLOCK_SW); 986 987 if (!atomic_read(&rfkill_input_disabled)) 988 __rfkill_switch_all(rfkill->type, soft_blocked); 989#endif 990 } 991 992 rfkill_send_events(rfkill, RFKILL_OP_ADD); 993 994 mutex_unlock(&rfkill_global_mutex); 995 return 0; 996 997 devdel: 998 device_del(&rfkill->dev); 999 remove: 1000 list_del_init(&rfkill->node); 1001 unlock: 1002 mutex_unlock(&rfkill_global_mutex); 1003 return error; 1004} 1005EXPORT_SYMBOL(rfkill_register); 1006 1007void rfkill_unregister(struct rfkill *rfkill) 1008{ 1009 BUG_ON(!rfkill); 1010 1011 if (rfkill->ops->poll) 1012 cancel_delayed_work_sync(&rfkill->poll_work); 1013 1014 cancel_work_sync(&rfkill->uevent_work); 1015 cancel_work_sync(&rfkill->sync_work); 1016 1017 rfkill->registered = false; 1018 1019 device_del(&rfkill->dev); 1020 1021 mutex_lock(&rfkill_global_mutex); 1022 rfkill_send_events(rfkill, RFKILL_OP_DEL); 1023 list_del_init(&rfkill->node); 1024 mutex_unlock(&rfkill_global_mutex); 1025 1026 rfkill_led_trigger_unregister(rfkill); 1027} 1028EXPORT_SYMBOL(rfkill_unregister); 1029 1030void rfkill_destroy(struct rfkill *rfkill) 1031{ 1032 if (rfkill) 1033 put_device(&rfkill->dev); 1034} 1035EXPORT_SYMBOL(rfkill_destroy); 1036 1037static int rfkill_fop_open(struct inode *inode, struct file *file) 1038{ 1039 struct rfkill_data *data; 1040 struct rfkill *rfkill; 1041 struct rfkill_int_event *ev, *tmp; 1042 1043 data = kzalloc(sizeof(*data), GFP_KERNEL); 1044 if (!data) 1045 return -ENOMEM; 1046 1047 INIT_LIST_HEAD(&data->events); 1048 mutex_init(&data->mtx); 1049 init_waitqueue_head(&data->read_wait); 1050 1051 mutex_lock(&rfkill_global_mutex); 1052 mutex_lock(&data->mtx); 1053 /* 1054 * start getting events from elsewhere but hold mtx to get 1055 * startup events added first 1056 */ 1057 1058 list_for_each_entry(rfkill, &rfkill_list, node) { 1059 ev = kzalloc(sizeof(*ev), GFP_KERNEL); 1060 if (!ev) 1061 goto free; 1062 rfkill_fill_event(&ev->ev, rfkill, RFKILL_OP_ADD); 1063 list_add_tail(&ev->list, &data->events); 1064 } 1065 list_add(&data->list, &rfkill_fds); 1066 mutex_unlock(&data->mtx); 1067 mutex_unlock(&rfkill_global_mutex); 1068 1069 file->private_data = data; 1070 1071 return nonseekable_open(inode, file); 1072 1073 free: 1074 mutex_unlock(&data->mtx); 1075 mutex_unlock(&rfkill_global_mutex); 1076 mutex_destroy(&data->mtx); 1077 list_for_each_entry_safe(ev, tmp, &data->events, list) 1078 kfree(ev); 1079 kfree(data); 1080 return -ENOMEM; 1081} 1082 1083static unsigned int rfkill_fop_poll(struct file *file, poll_table *wait) 1084{ 1085 struct rfkill_data *data = file->private_data; 1086 unsigned int res = POLLOUT | POLLWRNORM; 1087 1088 poll_wait(file, &data->read_wait, wait); 1089 1090 mutex_lock(&data->mtx); 1091 if (!list_empty(&data->events)) 1092 res = POLLIN | POLLRDNORM; 1093 mutex_unlock(&data->mtx); 1094 1095 return res; 1096} 1097 1098static ssize_t rfkill_fop_read(struct file *file, char __user *buf, 1099 size_t count, loff_t *pos) 1100{ 1101 struct rfkill_data *data = file->private_data; 1102 struct rfkill_int_event *ev; 1103 unsigned long sz; 1104 int ret; 1105 1106 mutex_lock(&data->mtx); 1107 1108 while (list_empty(&data->events)) { 1109 if (file->f_flags & O_NONBLOCK) { 1110 ret = -EAGAIN; 1111 goto out; 1112 } 1113 mutex_unlock(&data->mtx); 1114 /* since we re-check and it just compares pointers, 1115 * using !list_empty() without locking isn't a problem 1116 */ 1117 ret = wait_event_interruptible(data->read_wait, 1118 !list_empty(&data->events)); 1119 mutex_lock(&data->mtx); 1120 1121 if (ret) 1122 goto out; 1123 } 1124 1125 ev = list_first_entry(&data->events, struct rfkill_int_event, 1126 list); 1127 1128 sz = min_t(unsigned long, sizeof(ev->ev), count); 1129 ret = sz; 1130 if (copy_to_user(buf, &ev->ev, sz)) 1131 ret = -EFAULT; 1132 1133 list_del(&ev->list); 1134 kfree(ev); 1135 out: 1136 mutex_unlock(&data->mtx); 1137 return ret; 1138} 1139 1140static ssize_t rfkill_fop_write(struct file *file, const char __user *buf, 1141 size_t count, loff_t *pos) 1142{ 1143 struct rfkill *rfkill; 1144 struct rfkill_event ev; 1145 1146 /* we don't need the 'hard' variable but accept it */ 1147 if (count < RFKILL_EVENT_SIZE_V1 - 1) 1148 return -EINVAL; 1149 1150 /* 1151 * Copy as much data as we can accept into our 'ev' buffer, 1152 * but tell userspace how much we've copied so it can determine 1153 * our API version even in a write() call, if it cares. 1154 */ 1155 count = min(count, sizeof(ev)); 1156 if (copy_from_user(&ev, buf, count)) 1157 return -EFAULT; 1158 1159 if (ev.op != RFKILL_OP_CHANGE && ev.op != RFKILL_OP_CHANGE_ALL) 1160 return -EINVAL; 1161 1162 if (ev.type >= NUM_RFKILL_TYPES) 1163 return -EINVAL; 1164 1165 mutex_lock(&rfkill_global_mutex); 1166 1167 if (ev.op == RFKILL_OP_CHANGE_ALL) { 1168 if (ev.type == RFKILL_TYPE_ALL) { 1169 enum rfkill_type i; 1170 for (i = 0; i < NUM_RFKILL_TYPES; i++) 1171 rfkill_global_states[i].cur = ev.soft; 1172 } else { 1173 rfkill_global_states[ev.type].cur = ev.soft; 1174 } 1175 } 1176 1177 list_for_each_entry(rfkill, &rfkill_list, node) { 1178 if (rfkill->idx != ev.idx && ev.op != RFKILL_OP_CHANGE_ALL) 1179 continue; 1180 1181 if (rfkill->type != ev.type && ev.type != RFKILL_TYPE_ALL) 1182 continue; 1183 1184 rfkill_set_block(rfkill, ev.soft); 1185 } 1186 mutex_unlock(&rfkill_global_mutex); 1187 1188 return count; 1189} 1190 1191static int rfkill_fop_release(struct inode *inode, struct file *file) 1192{ 1193 struct rfkill_data *data = file->private_data; 1194 struct rfkill_int_event *ev, *tmp; 1195 1196 mutex_lock(&rfkill_global_mutex); 1197 list_del(&data->list); 1198 mutex_unlock(&rfkill_global_mutex); 1199 1200 mutex_destroy(&data->mtx); 1201 list_for_each_entry_safe(ev, tmp, &data->events, list) 1202 kfree(ev); 1203 1204#ifdef CONFIG_RFKILL_INPUT 1205 if (data->input_handler) 1206 if (atomic_dec_return(&rfkill_input_disabled) == 0) 1207 printk(KERN_DEBUG "rfkill: input handler enabled\n"); 1208#endif 1209 1210 kfree(data); 1211 1212 return 0; 1213} 1214 1215#ifdef CONFIG_RFKILL_INPUT 1216static long rfkill_fop_ioctl(struct file *file, unsigned int cmd, 1217 unsigned long arg) 1218{ 1219 struct rfkill_data *data = file->private_data; 1220 1221 if (_IOC_TYPE(cmd) != RFKILL_IOC_MAGIC) 1222 return -ENOSYS; 1223 1224 if (_IOC_NR(cmd) != RFKILL_IOC_NOINPUT) 1225 return -ENOSYS; 1226 1227 mutex_lock(&data->mtx); 1228 1229 if (!data->input_handler) { 1230 if (atomic_inc_return(&rfkill_input_disabled) == 1) 1231 printk(KERN_DEBUG "rfkill: input handler disabled\n"); 1232 data->input_handler = true; 1233 } 1234 1235 mutex_unlock(&data->mtx); 1236 1237 return 0; 1238} 1239#endif 1240 1241static const struct file_operations rfkill_fops = { 1242 .owner = THIS_MODULE, 1243 .open = rfkill_fop_open, 1244 .read = rfkill_fop_read, 1245 .write = rfkill_fop_write, 1246 .poll = rfkill_fop_poll, 1247 .release = rfkill_fop_release, 1248#ifdef CONFIG_RFKILL_INPUT 1249 .unlocked_ioctl = rfkill_fop_ioctl, 1250 .compat_ioctl = rfkill_fop_ioctl, 1251#endif 1252 .llseek = no_llseek, 1253}; 1254 1255static struct miscdevice rfkill_miscdev = { 1256 .name = "rfkill", 1257 .fops = &rfkill_fops, 1258 .minor = MISC_DYNAMIC_MINOR, 1259}; 1260 1261static int __init rfkill_init(void) 1262{ 1263 int error; 1264 int i; 1265 1266 for (i = 0; i < NUM_RFKILL_TYPES; i++) 1267 rfkill_global_states[i].cur = !rfkill_default_state; 1268 1269 error = class_register(&rfkill_class); 1270 if (error) 1271 goto out; 1272 1273 error = misc_register(&rfkill_miscdev); 1274 if (error) { 1275 class_unregister(&rfkill_class); 1276 goto out; 1277 } 1278 1279#ifdef CONFIG_RFKILL_INPUT 1280 error = rfkill_handler_init(); 1281 if (error) { 1282 misc_deregister(&rfkill_miscdev); 1283 class_unregister(&rfkill_class); 1284 goto out; 1285 } 1286#endif 1287 1288 out: 1289 return error; 1290} 1291subsys_initcall(rfkill_init); 1292 1293static void __exit rfkill_exit(void) 1294{ 1295#ifdef CONFIG_RFKILL_INPUT 1296 rfkill_handler_exit(); 1297#endif 1298 misc_deregister(&rfkill_miscdev); 1299 class_unregister(&rfkill_class); 1300} 1301module_exit(rfkill_exit); 1302