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