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