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