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 37 struct 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 71 struct rfkill_int_event { 72 struct list_head list; 73 struct rfkill_event_ext ev; 74 }; 75 76 struct 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 86 MODULE_AUTHOR("Ivo van Doorn <IvDoorn@gmail.com>"); 87 MODULE_AUTHOR("Johannes Berg <johannes@sipsolutions.net>"); 88 MODULE_DESCRIPTION("RF switch support"); 89 MODULE_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 */ 103 static LIST_HEAD(rfkill_list); /* list of registered rf switches */ 104 static DEFINE_MUTEX(rfkill_global_mutex); 105 static LIST_HEAD(rfkill_fds); /* list of open fds of /dev/rfkill */ 106 107 static unsigned int rfkill_default_state = 1; 108 module_param_named(default_state, rfkill_default_state, uint, 0444); 109 MODULE_PARM_DESC(default_state, 110 "Default initial state for all radio types, 0 = radio off"); 111 112 static struct { 113 bool cur, sav; 114 } rfkill_global_states[NUM_RFKILL_TYPES]; 115 116 static bool rfkill_epo_lock_active; 117 118 119 #ifdef CONFIG_RFKILL_LEDS 120 static 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 135 static 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 146 const char *rfkill_get_led_trigger_name(struct rfkill *rfkill) 147 { 148 return rfkill->led_trigger.name; 149 } 150 EXPORT_SYMBOL(rfkill_get_led_trigger_name); 151 152 void rfkill_set_led_trigger_name(struct rfkill *rfkill, const char *name) 153 { 154 BUG_ON(!rfkill); 155 156 rfkill->ledtrigname = name; 157 } 158 EXPORT_SYMBOL(rfkill_set_led_trigger_name); 159 160 static 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 168 static void rfkill_led_trigger_unregister(struct rfkill *rfkill) 169 { 170 led_trigger_unregister(&rfkill->led_trigger); 171 } 172 173 static struct led_trigger rfkill_any_led_trigger; 174 static struct led_trigger rfkill_none_led_trigger; 175 static struct work_struct rfkill_global_led_trigger_work; 176 177 static 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 196 static void rfkill_global_led_trigger_event(void) 197 { 198 schedule_work(&rfkill_global_led_trigger_work); 199 } 200 201 static 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 224 static 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 231 static void rfkill_led_trigger_event(struct rfkill *rfkill) 232 { 233 } 234 235 static inline int rfkill_led_trigger_register(struct rfkill *rfkill) 236 { 237 return 0; 238 } 239 240 static inline void rfkill_led_trigger_unregister(struct rfkill *rfkill) 241 { 242 } 243 244 static void rfkill_global_led_trigger_event(void) 245 { 246 } 247 248 static int rfkill_global_led_trigger_register(void) 249 { 250 return 0; 251 } 252 253 static void rfkill_global_led_trigger_unregister(void) 254 { 255 } 256 #endif /* CONFIG_RFKILL_LEDS */ 257 258 static 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 276 static 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 293 static 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 */ 313 static 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 372 static 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 383 static 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 397 static 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 */ 409 static 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 */ 432 void 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 */ 454 void 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 */ 483 void 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 */ 504 void 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 */ 523 bool 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 */ 535 bool rfkill_get_global_sw_state(const enum rfkill_type type) 536 { 537 return rfkill_global_states[type].cur; 538 } 539 #endif 540 541 bool rfkill_set_hw_state_reason(struct rfkill *rfkill, 542 bool blocked, 543 enum rfkill_hard_block_reasons reason) 544 { 545 unsigned long flags; 546 bool ret, prev; 547 548 BUG_ON(!rfkill); 549 550 spin_lock_irqsave(&rfkill->lock, flags); 551 prev = !!(rfkill->hard_block_reasons & reason); 552 if (blocked) { 553 rfkill->state |= RFKILL_BLOCK_HW; 554 rfkill->hard_block_reasons |= reason; 555 } else { 556 rfkill->hard_block_reasons &= ~reason; 557 if (!rfkill->hard_block_reasons) 558 rfkill->state &= ~RFKILL_BLOCK_HW; 559 } 560 ret = !!(rfkill->state & RFKILL_BLOCK_ANY); 561 spin_unlock_irqrestore(&rfkill->lock, flags); 562 563 rfkill_led_trigger_event(rfkill); 564 rfkill_global_led_trigger_event(); 565 566 if (rfkill->registered && prev != blocked) 567 schedule_work(&rfkill->uevent_work); 568 569 return ret; 570 } 571 EXPORT_SYMBOL(rfkill_set_hw_state_reason); 572 573 static void __rfkill_set_sw_state(struct rfkill *rfkill, bool blocked) 574 { 575 u32 bit = RFKILL_BLOCK_SW; 576 577 /* if in a ops->set_block right now, use other bit */ 578 if (rfkill->state & RFKILL_BLOCK_SW_SETCALL) 579 bit = RFKILL_BLOCK_SW_PREV; 580 581 if (blocked) 582 rfkill->state |= bit; 583 else 584 rfkill->state &= ~bit; 585 } 586 587 bool rfkill_set_sw_state(struct rfkill *rfkill, bool blocked) 588 { 589 unsigned long flags; 590 bool prev, hwblock; 591 592 BUG_ON(!rfkill); 593 594 spin_lock_irqsave(&rfkill->lock, flags); 595 prev = !!(rfkill->state & RFKILL_BLOCK_SW); 596 __rfkill_set_sw_state(rfkill, blocked); 597 hwblock = !!(rfkill->state & RFKILL_BLOCK_HW); 598 blocked = blocked || hwblock; 599 spin_unlock_irqrestore(&rfkill->lock, flags); 600 601 if (!rfkill->registered) 602 return blocked; 603 604 if (prev != blocked && !hwblock) 605 schedule_work(&rfkill->uevent_work); 606 607 rfkill_led_trigger_event(rfkill); 608 rfkill_global_led_trigger_event(); 609 610 return blocked; 611 } 612 EXPORT_SYMBOL(rfkill_set_sw_state); 613 614 void rfkill_init_sw_state(struct rfkill *rfkill, bool blocked) 615 { 616 unsigned long flags; 617 618 BUG_ON(!rfkill); 619 BUG_ON(rfkill->registered); 620 621 spin_lock_irqsave(&rfkill->lock, flags); 622 __rfkill_set_sw_state(rfkill, blocked); 623 rfkill->persistent = true; 624 spin_unlock_irqrestore(&rfkill->lock, flags); 625 } 626 EXPORT_SYMBOL(rfkill_init_sw_state); 627 628 void rfkill_set_states(struct rfkill *rfkill, bool sw, bool hw) 629 { 630 unsigned long flags; 631 bool swprev, hwprev; 632 633 BUG_ON(!rfkill); 634 635 spin_lock_irqsave(&rfkill->lock, flags); 636 637 /* 638 * No need to care about prev/setblock ... this is for uevent only 639 * and that will get triggered by rfkill_set_block anyway. 640 */ 641 swprev = !!(rfkill->state & RFKILL_BLOCK_SW); 642 hwprev = !!(rfkill->state & RFKILL_BLOCK_HW); 643 __rfkill_set_sw_state(rfkill, sw); 644 if (hw) 645 rfkill->state |= RFKILL_BLOCK_HW; 646 else 647 rfkill->state &= ~RFKILL_BLOCK_HW; 648 649 spin_unlock_irqrestore(&rfkill->lock, flags); 650 651 if (!rfkill->registered) { 652 rfkill->persistent = true; 653 } else { 654 if (swprev != sw || hwprev != hw) 655 schedule_work(&rfkill->uevent_work); 656 657 rfkill_led_trigger_event(rfkill); 658 rfkill_global_led_trigger_event(); 659 } 660 } 661 EXPORT_SYMBOL(rfkill_set_states); 662 663 static const char * const rfkill_types[] = { 664 NULL, /* RFKILL_TYPE_ALL */ 665 "wlan", 666 "bluetooth", 667 "ultrawideband", 668 "wimax", 669 "wwan", 670 "gps", 671 "fm", 672 "nfc", 673 }; 674 675 enum rfkill_type rfkill_find_type(const char *name) 676 { 677 int i; 678 679 BUILD_BUG_ON(ARRAY_SIZE(rfkill_types) != NUM_RFKILL_TYPES); 680 681 if (!name) 682 return RFKILL_TYPE_ALL; 683 684 for (i = 1; i < NUM_RFKILL_TYPES; i++) 685 if (!strcmp(name, rfkill_types[i])) 686 return i; 687 return RFKILL_TYPE_ALL; 688 } 689 EXPORT_SYMBOL(rfkill_find_type); 690 691 static ssize_t name_show(struct device *dev, struct device_attribute *attr, 692 char *buf) 693 { 694 struct rfkill *rfkill = to_rfkill(dev); 695 696 return sysfs_emit(buf, "%s\n", rfkill->name); 697 } 698 static DEVICE_ATTR_RO(name); 699 700 static ssize_t type_show(struct device *dev, struct device_attribute *attr, 701 char *buf) 702 { 703 struct rfkill *rfkill = to_rfkill(dev); 704 705 return sysfs_emit(buf, "%s\n", rfkill_types[rfkill->type]); 706 } 707 static DEVICE_ATTR_RO(type); 708 709 static ssize_t index_show(struct device *dev, struct device_attribute *attr, 710 char *buf) 711 { 712 struct rfkill *rfkill = to_rfkill(dev); 713 714 return sysfs_emit(buf, "%d\n", rfkill->idx); 715 } 716 static DEVICE_ATTR_RO(index); 717 718 static ssize_t persistent_show(struct device *dev, 719 struct device_attribute *attr, char *buf) 720 { 721 struct rfkill *rfkill = to_rfkill(dev); 722 723 return sysfs_emit(buf, "%d\n", rfkill->persistent); 724 } 725 static DEVICE_ATTR_RO(persistent); 726 727 static ssize_t hard_show(struct device *dev, struct device_attribute *attr, 728 char *buf) 729 { 730 struct rfkill *rfkill = to_rfkill(dev); 731 732 return sysfs_emit(buf, "%d\n", (rfkill->state & RFKILL_BLOCK_HW) ? 1 : 0); 733 } 734 static DEVICE_ATTR_RO(hard); 735 736 static ssize_t soft_show(struct device *dev, struct device_attribute *attr, 737 char *buf) 738 { 739 struct rfkill *rfkill = to_rfkill(dev); 740 741 mutex_lock(&rfkill_global_mutex); 742 rfkill_sync(rfkill); 743 mutex_unlock(&rfkill_global_mutex); 744 745 return sysfs_emit(buf, "%d\n", (rfkill->state & RFKILL_BLOCK_SW) ? 1 : 0); 746 } 747 748 static ssize_t soft_store(struct device *dev, struct device_attribute *attr, 749 const char *buf, size_t count) 750 { 751 struct rfkill *rfkill = to_rfkill(dev); 752 unsigned long state; 753 int err; 754 755 if (!capable(CAP_NET_ADMIN)) 756 return -EPERM; 757 758 err = kstrtoul(buf, 0, &state); 759 if (err) 760 return err; 761 762 if (state > 1 ) 763 return -EINVAL; 764 765 mutex_lock(&rfkill_global_mutex); 766 rfkill_sync(rfkill); 767 rfkill_set_block(rfkill, state); 768 mutex_unlock(&rfkill_global_mutex); 769 770 return count; 771 } 772 static DEVICE_ATTR_RW(soft); 773 774 static ssize_t hard_block_reasons_show(struct device *dev, 775 struct device_attribute *attr, 776 char *buf) 777 { 778 struct rfkill *rfkill = to_rfkill(dev); 779 780 return sysfs_emit(buf, "0x%lx\n", rfkill->hard_block_reasons); 781 } 782 static DEVICE_ATTR_RO(hard_block_reasons); 783 784 static u8 user_state_from_blocked(unsigned long state) 785 { 786 if (state & RFKILL_BLOCK_HW) 787 return RFKILL_USER_STATE_HARD_BLOCKED; 788 if (state & RFKILL_BLOCK_SW) 789 return RFKILL_USER_STATE_SOFT_BLOCKED; 790 791 return RFKILL_USER_STATE_UNBLOCKED; 792 } 793 794 static ssize_t state_show(struct device *dev, struct device_attribute *attr, 795 char *buf) 796 { 797 struct rfkill *rfkill = to_rfkill(dev); 798 799 mutex_lock(&rfkill_global_mutex); 800 rfkill_sync(rfkill); 801 mutex_unlock(&rfkill_global_mutex); 802 803 return sysfs_emit(buf, "%d\n", user_state_from_blocked(rfkill->state)); 804 } 805 806 static ssize_t state_store(struct device *dev, struct device_attribute *attr, 807 const char *buf, size_t count) 808 { 809 struct rfkill *rfkill = to_rfkill(dev); 810 unsigned long state; 811 int err; 812 813 if (!capable(CAP_NET_ADMIN)) 814 return -EPERM; 815 816 err = kstrtoul(buf, 0, &state); 817 if (err) 818 return err; 819 820 if (state != RFKILL_USER_STATE_SOFT_BLOCKED && 821 state != RFKILL_USER_STATE_UNBLOCKED) 822 return -EINVAL; 823 824 mutex_lock(&rfkill_global_mutex); 825 rfkill_sync(rfkill); 826 rfkill_set_block(rfkill, state == RFKILL_USER_STATE_SOFT_BLOCKED); 827 mutex_unlock(&rfkill_global_mutex); 828 829 return count; 830 } 831 static DEVICE_ATTR_RW(state); 832 833 static struct attribute *rfkill_dev_attrs[] = { 834 &dev_attr_name.attr, 835 &dev_attr_type.attr, 836 &dev_attr_index.attr, 837 &dev_attr_persistent.attr, 838 &dev_attr_state.attr, 839 &dev_attr_soft.attr, 840 &dev_attr_hard.attr, 841 &dev_attr_hard_block_reasons.attr, 842 NULL, 843 }; 844 ATTRIBUTE_GROUPS(rfkill_dev); 845 846 static void rfkill_release(struct device *dev) 847 { 848 struct rfkill *rfkill = to_rfkill(dev); 849 850 kfree(rfkill); 851 } 852 853 static int rfkill_dev_uevent(const struct device *dev, struct kobj_uevent_env *env) 854 { 855 struct rfkill *rfkill = to_rfkill(dev); 856 unsigned long flags; 857 unsigned long reasons; 858 u32 state; 859 int error; 860 861 error = add_uevent_var(env, "RFKILL_NAME=%s", rfkill->name); 862 if (error) 863 return error; 864 error = add_uevent_var(env, "RFKILL_TYPE=%s", 865 rfkill_types[rfkill->type]); 866 if (error) 867 return error; 868 spin_lock_irqsave(&rfkill->lock, flags); 869 state = rfkill->state; 870 reasons = rfkill->hard_block_reasons; 871 spin_unlock_irqrestore(&rfkill->lock, flags); 872 error = add_uevent_var(env, "RFKILL_STATE=%d", 873 user_state_from_blocked(state)); 874 if (error) 875 return error; 876 return add_uevent_var(env, "RFKILL_HW_BLOCK_REASON=0x%lx", reasons); 877 } 878 879 void rfkill_pause_polling(struct rfkill *rfkill) 880 { 881 BUG_ON(!rfkill); 882 883 if (!rfkill->ops->poll) 884 return; 885 886 rfkill->polling_paused = true; 887 cancel_delayed_work_sync(&rfkill->poll_work); 888 } 889 EXPORT_SYMBOL(rfkill_pause_polling); 890 891 void rfkill_resume_polling(struct rfkill *rfkill) 892 { 893 BUG_ON(!rfkill); 894 895 if (!rfkill->ops->poll) 896 return; 897 898 rfkill->polling_paused = false; 899 900 if (rfkill->suspended) 901 return; 902 903 queue_delayed_work(system_power_efficient_wq, 904 &rfkill->poll_work, 0); 905 } 906 EXPORT_SYMBOL(rfkill_resume_polling); 907 908 #ifdef CONFIG_PM_SLEEP 909 static int rfkill_suspend(struct device *dev) 910 { 911 struct rfkill *rfkill = to_rfkill(dev); 912 913 rfkill->suspended = true; 914 cancel_delayed_work_sync(&rfkill->poll_work); 915 916 return 0; 917 } 918 919 static int rfkill_resume(struct device *dev) 920 { 921 struct rfkill *rfkill = to_rfkill(dev); 922 bool cur; 923 924 rfkill->suspended = false; 925 926 if (!rfkill->registered) 927 return 0; 928 929 if (!rfkill->persistent) { 930 cur = !!(rfkill->state & RFKILL_BLOCK_SW); 931 rfkill_set_block(rfkill, cur); 932 } 933 934 if (rfkill->ops->poll && !rfkill->polling_paused) 935 queue_delayed_work(system_power_efficient_wq, 936 &rfkill->poll_work, 0); 937 938 return 0; 939 } 940 941 static SIMPLE_DEV_PM_OPS(rfkill_pm_ops, rfkill_suspend, rfkill_resume); 942 #define RFKILL_PM_OPS (&rfkill_pm_ops) 943 #else 944 #define RFKILL_PM_OPS NULL 945 #endif 946 947 static struct class rfkill_class = { 948 .name = "rfkill", 949 .dev_release = rfkill_release, 950 .dev_groups = rfkill_dev_groups, 951 .dev_uevent = rfkill_dev_uevent, 952 .pm = RFKILL_PM_OPS, 953 }; 954 955 bool rfkill_blocked(struct rfkill *rfkill) 956 { 957 unsigned long flags; 958 u32 state; 959 960 spin_lock_irqsave(&rfkill->lock, flags); 961 state = rfkill->state; 962 spin_unlock_irqrestore(&rfkill->lock, flags); 963 964 return !!(state & RFKILL_BLOCK_ANY); 965 } 966 EXPORT_SYMBOL(rfkill_blocked); 967 968 bool rfkill_soft_blocked(struct rfkill *rfkill) 969 { 970 unsigned long flags; 971 u32 state; 972 973 spin_lock_irqsave(&rfkill->lock, flags); 974 state = rfkill->state; 975 spin_unlock_irqrestore(&rfkill->lock, flags); 976 977 return !!(state & RFKILL_BLOCK_SW); 978 } 979 EXPORT_SYMBOL(rfkill_soft_blocked); 980 981 struct rfkill * __must_check rfkill_alloc(const char *name, 982 struct device *parent, 983 const enum rfkill_type type, 984 const struct rfkill_ops *ops, 985 void *ops_data) 986 { 987 struct rfkill *rfkill; 988 struct device *dev; 989 990 if (WARN_ON(!ops)) 991 return NULL; 992 993 if (WARN_ON(!ops->set_block)) 994 return NULL; 995 996 if (WARN_ON(!name)) 997 return NULL; 998 999 if (WARN_ON(type == RFKILL_TYPE_ALL || type >= NUM_RFKILL_TYPES)) 1000 return NULL; 1001 1002 rfkill = kzalloc(sizeof(*rfkill) + strlen(name) + 1, GFP_KERNEL); 1003 if (!rfkill) 1004 return NULL; 1005 1006 spin_lock_init(&rfkill->lock); 1007 INIT_LIST_HEAD(&rfkill->node); 1008 rfkill->type = type; 1009 strcpy(rfkill->name, name); 1010 rfkill->ops = ops; 1011 rfkill->data = ops_data; 1012 1013 dev = &rfkill->dev; 1014 dev->class = &rfkill_class; 1015 dev->parent = parent; 1016 device_initialize(dev); 1017 1018 return rfkill; 1019 } 1020 EXPORT_SYMBOL(rfkill_alloc); 1021 1022 static void rfkill_poll(struct work_struct *work) 1023 { 1024 struct rfkill *rfkill; 1025 1026 rfkill = container_of(work, struct rfkill, poll_work.work); 1027 1028 /* 1029 * Poll hardware state -- driver will use one of the 1030 * rfkill_set{,_hw,_sw}_state functions and use its 1031 * return value to update the current status. 1032 */ 1033 rfkill->ops->poll(rfkill, rfkill->data); 1034 1035 queue_delayed_work(system_power_efficient_wq, 1036 &rfkill->poll_work, 1037 round_jiffies_relative(POLL_INTERVAL)); 1038 } 1039 1040 static void rfkill_uevent_work(struct work_struct *work) 1041 { 1042 struct rfkill *rfkill; 1043 1044 rfkill = container_of(work, struct rfkill, uevent_work); 1045 1046 mutex_lock(&rfkill_global_mutex); 1047 rfkill_event(rfkill); 1048 mutex_unlock(&rfkill_global_mutex); 1049 } 1050 1051 static void rfkill_sync_work(struct work_struct *work) 1052 { 1053 struct rfkill *rfkill = container_of(work, struct rfkill, sync_work); 1054 1055 mutex_lock(&rfkill_global_mutex); 1056 rfkill_sync(rfkill); 1057 mutex_unlock(&rfkill_global_mutex); 1058 } 1059 1060 int __must_check rfkill_register(struct rfkill *rfkill) 1061 { 1062 static unsigned long rfkill_no; 1063 struct device *dev; 1064 int error; 1065 1066 if (!rfkill) 1067 return -EINVAL; 1068 1069 dev = &rfkill->dev; 1070 1071 mutex_lock(&rfkill_global_mutex); 1072 1073 if (rfkill->registered) { 1074 error = -EALREADY; 1075 goto unlock; 1076 } 1077 1078 rfkill->idx = rfkill_no; 1079 dev_set_name(dev, "rfkill%lu", rfkill_no); 1080 rfkill_no++; 1081 1082 list_add_tail(&rfkill->node, &rfkill_list); 1083 1084 error = device_add(dev); 1085 if (error) 1086 goto remove; 1087 1088 error = rfkill_led_trigger_register(rfkill); 1089 if (error) 1090 goto devdel; 1091 1092 rfkill->registered = true; 1093 1094 INIT_DELAYED_WORK(&rfkill->poll_work, rfkill_poll); 1095 INIT_WORK(&rfkill->uevent_work, rfkill_uevent_work); 1096 INIT_WORK(&rfkill->sync_work, rfkill_sync_work); 1097 1098 if (rfkill->ops->poll) 1099 queue_delayed_work(system_power_efficient_wq, 1100 &rfkill->poll_work, 1101 round_jiffies_relative(POLL_INTERVAL)); 1102 1103 if (!rfkill->persistent || rfkill_epo_lock_active) { 1104 rfkill->need_sync = true; 1105 schedule_work(&rfkill->sync_work); 1106 } else { 1107 #ifdef CONFIG_RFKILL_INPUT 1108 bool soft_blocked = !!(rfkill->state & RFKILL_BLOCK_SW); 1109 1110 if (!atomic_read(&rfkill_input_disabled)) 1111 __rfkill_switch_all(rfkill->type, soft_blocked); 1112 #endif 1113 } 1114 1115 rfkill_global_led_trigger_event(); 1116 rfkill_send_events(rfkill, RFKILL_OP_ADD); 1117 1118 mutex_unlock(&rfkill_global_mutex); 1119 return 0; 1120 1121 devdel: 1122 device_del(&rfkill->dev); 1123 remove: 1124 list_del_init(&rfkill->node); 1125 unlock: 1126 mutex_unlock(&rfkill_global_mutex); 1127 return error; 1128 } 1129 EXPORT_SYMBOL(rfkill_register); 1130 1131 void rfkill_unregister(struct rfkill *rfkill) 1132 { 1133 BUG_ON(!rfkill); 1134 1135 if (rfkill->ops->poll) 1136 cancel_delayed_work_sync(&rfkill->poll_work); 1137 1138 cancel_work_sync(&rfkill->uevent_work); 1139 cancel_work_sync(&rfkill->sync_work); 1140 1141 rfkill->registered = false; 1142 1143 device_del(&rfkill->dev); 1144 1145 mutex_lock(&rfkill_global_mutex); 1146 rfkill_send_events(rfkill, RFKILL_OP_DEL); 1147 list_del_init(&rfkill->node); 1148 rfkill_global_led_trigger_event(); 1149 mutex_unlock(&rfkill_global_mutex); 1150 1151 rfkill_led_trigger_unregister(rfkill); 1152 } 1153 EXPORT_SYMBOL(rfkill_unregister); 1154 1155 void rfkill_destroy(struct rfkill *rfkill) 1156 { 1157 if (rfkill) 1158 put_device(&rfkill->dev); 1159 } 1160 EXPORT_SYMBOL(rfkill_destroy); 1161 1162 static int rfkill_fop_open(struct inode *inode, struct file *file) 1163 { 1164 struct rfkill_data *data; 1165 struct rfkill *rfkill; 1166 struct rfkill_int_event *ev, *tmp; 1167 1168 data = kzalloc(sizeof(*data), GFP_KERNEL); 1169 if (!data) 1170 return -ENOMEM; 1171 1172 data->max_size = RFKILL_EVENT_SIZE_V1; 1173 1174 INIT_LIST_HEAD(&data->events); 1175 mutex_init(&data->mtx); 1176 init_waitqueue_head(&data->read_wait); 1177 1178 mutex_lock(&rfkill_global_mutex); 1179 /* 1180 * start getting events from elsewhere but hold mtx to get 1181 * startup events added first 1182 */ 1183 1184 list_for_each_entry(rfkill, &rfkill_list, node) { 1185 ev = kzalloc(sizeof(*ev), GFP_KERNEL); 1186 if (!ev) 1187 goto free; 1188 rfkill_sync(rfkill); 1189 rfkill_fill_event(&ev->ev, rfkill, RFKILL_OP_ADD); 1190 mutex_lock(&data->mtx); 1191 list_add_tail(&ev->list, &data->events); 1192 mutex_unlock(&data->mtx); 1193 } 1194 list_add(&data->list, &rfkill_fds); 1195 mutex_unlock(&rfkill_global_mutex); 1196 1197 file->private_data = data; 1198 1199 return stream_open(inode, file); 1200 1201 free: 1202 mutex_unlock(&rfkill_global_mutex); 1203 mutex_destroy(&data->mtx); 1204 list_for_each_entry_safe(ev, tmp, &data->events, list) 1205 kfree(ev); 1206 kfree(data); 1207 return -ENOMEM; 1208 } 1209 1210 static __poll_t rfkill_fop_poll(struct file *file, poll_table *wait) 1211 { 1212 struct rfkill_data *data = file->private_data; 1213 __poll_t res = EPOLLOUT | EPOLLWRNORM; 1214 1215 poll_wait(file, &data->read_wait, wait); 1216 1217 mutex_lock(&data->mtx); 1218 if (!list_empty(&data->events)) 1219 res = EPOLLIN | EPOLLRDNORM; 1220 mutex_unlock(&data->mtx); 1221 1222 return res; 1223 } 1224 1225 static ssize_t rfkill_fop_read(struct file *file, char __user *buf, 1226 size_t count, loff_t *pos) 1227 { 1228 struct rfkill_data *data = file->private_data; 1229 struct rfkill_int_event *ev; 1230 unsigned long sz; 1231 int ret; 1232 1233 mutex_lock(&data->mtx); 1234 1235 while (list_empty(&data->events)) { 1236 if (file->f_flags & O_NONBLOCK) { 1237 ret = -EAGAIN; 1238 goto out; 1239 } 1240 mutex_unlock(&data->mtx); 1241 /* since we re-check and it just compares pointers, 1242 * using !list_empty() without locking isn't a problem 1243 */ 1244 ret = wait_event_interruptible(data->read_wait, 1245 !list_empty(&data->events)); 1246 mutex_lock(&data->mtx); 1247 1248 if (ret) 1249 goto out; 1250 } 1251 1252 ev = list_first_entry(&data->events, struct rfkill_int_event, 1253 list); 1254 1255 sz = min_t(unsigned long, sizeof(ev->ev), count); 1256 sz = min_t(unsigned long, sz, data->max_size); 1257 ret = sz; 1258 if (copy_to_user(buf, &ev->ev, sz)) 1259 ret = -EFAULT; 1260 1261 list_del(&ev->list); 1262 kfree(ev); 1263 out: 1264 mutex_unlock(&data->mtx); 1265 return ret; 1266 } 1267 1268 static ssize_t rfkill_fop_write(struct file *file, const char __user *buf, 1269 size_t count, loff_t *pos) 1270 { 1271 struct rfkill_data *data = file->private_data; 1272 struct rfkill *rfkill; 1273 struct rfkill_event_ext ev; 1274 int ret; 1275 1276 /* we don't need the 'hard' variable but accept it */ 1277 if (count < RFKILL_EVENT_SIZE_V1 - 1) 1278 return -EINVAL; 1279 1280 /* 1281 * Copy as much data as we can accept into our 'ev' buffer, 1282 * but tell userspace how much we've copied so it can determine 1283 * our API version even in a write() call, if it cares. 1284 */ 1285 count = min(count, sizeof(ev)); 1286 count = min_t(size_t, count, data->max_size); 1287 if (copy_from_user(&ev, buf, count)) 1288 return -EFAULT; 1289 1290 if (ev.type >= NUM_RFKILL_TYPES) 1291 return -EINVAL; 1292 1293 mutex_lock(&rfkill_global_mutex); 1294 1295 switch (ev.op) { 1296 case RFKILL_OP_CHANGE_ALL: 1297 rfkill_update_global_state(ev.type, ev.soft); 1298 list_for_each_entry(rfkill, &rfkill_list, node) 1299 if (rfkill->type == ev.type || 1300 ev.type == RFKILL_TYPE_ALL) 1301 rfkill_set_block(rfkill, ev.soft); 1302 ret = 0; 1303 break; 1304 case RFKILL_OP_CHANGE: 1305 list_for_each_entry(rfkill, &rfkill_list, node) 1306 if (rfkill->idx == ev.idx && 1307 (rfkill->type == ev.type || 1308 ev.type == RFKILL_TYPE_ALL)) 1309 rfkill_set_block(rfkill, ev.soft); 1310 ret = 0; 1311 break; 1312 default: 1313 ret = -EINVAL; 1314 break; 1315 } 1316 1317 mutex_unlock(&rfkill_global_mutex); 1318 1319 return ret ?: count; 1320 } 1321 1322 static int rfkill_fop_release(struct inode *inode, struct file *file) 1323 { 1324 struct rfkill_data *data = file->private_data; 1325 struct rfkill_int_event *ev, *tmp; 1326 1327 mutex_lock(&rfkill_global_mutex); 1328 list_del(&data->list); 1329 mutex_unlock(&rfkill_global_mutex); 1330 1331 mutex_destroy(&data->mtx); 1332 list_for_each_entry_safe(ev, tmp, &data->events, list) 1333 kfree(ev); 1334 1335 #ifdef CONFIG_RFKILL_INPUT 1336 if (data->input_handler) 1337 if (atomic_dec_return(&rfkill_input_disabled) == 0) 1338 printk(KERN_DEBUG "rfkill: input handler enabled\n"); 1339 #endif 1340 1341 kfree(data); 1342 1343 return 0; 1344 } 1345 1346 static long rfkill_fop_ioctl(struct file *file, unsigned int cmd, 1347 unsigned long arg) 1348 { 1349 struct rfkill_data *data = file->private_data; 1350 int ret = -ENOTTY; 1351 u32 size; 1352 1353 if (_IOC_TYPE(cmd) != RFKILL_IOC_MAGIC) 1354 return -ENOTTY; 1355 1356 mutex_lock(&data->mtx); 1357 switch (_IOC_NR(cmd)) { 1358 #ifdef CONFIG_RFKILL_INPUT 1359 case RFKILL_IOC_NOINPUT: 1360 if (!data->input_handler) { 1361 if (atomic_inc_return(&rfkill_input_disabled) == 1) 1362 printk(KERN_DEBUG "rfkill: input handler disabled\n"); 1363 data->input_handler = true; 1364 } 1365 ret = 0; 1366 break; 1367 #endif 1368 case RFKILL_IOC_MAX_SIZE: 1369 if (get_user(size, (__u32 __user *)arg)) { 1370 ret = -EFAULT; 1371 break; 1372 } 1373 if (size < RFKILL_EVENT_SIZE_V1 || size > U8_MAX) { 1374 ret = -EINVAL; 1375 break; 1376 } 1377 data->max_size = size; 1378 ret = 0; 1379 break; 1380 default: 1381 break; 1382 } 1383 mutex_unlock(&data->mtx); 1384 1385 return ret; 1386 } 1387 1388 static const struct file_operations rfkill_fops = { 1389 .owner = THIS_MODULE, 1390 .open = rfkill_fop_open, 1391 .read = rfkill_fop_read, 1392 .write = rfkill_fop_write, 1393 .poll = rfkill_fop_poll, 1394 .release = rfkill_fop_release, 1395 .unlocked_ioctl = rfkill_fop_ioctl, 1396 .compat_ioctl = compat_ptr_ioctl, 1397 }; 1398 1399 #define RFKILL_NAME "rfkill" 1400 1401 static struct miscdevice rfkill_miscdev = { 1402 .fops = &rfkill_fops, 1403 .name = RFKILL_NAME, 1404 .minor = RFKILL_MINOR, 1405 }; 1406 1407 static int __init rfkill_init(void) 1408 { 1409 int error; 1410 1411 rfkill_update_global_state(RFKILL_TYPE_ALL, !rfkill_default_state); 1412 1413 error = class_register(&rfkill_class); 1414 if (error) 1415 goto error_class; 1416 1417 error = misc_register(&rfkill_miscdev); 1418 if (error) 1419 goto error_misc; 1420 1421 error = rfkill_global_led_trigger_register(); 1422 if (error) 1423 goto error_led_trigger; 1424 1425 #ifdef CONFIG_RFKILL_INPUT 1426 error = rfkill_handler_init(); 1427 if (error) 1428 goto error_input; 1429 #endif 1430 1431 return 0; 1432 1433 #ifdef CONFIG_RFKILL_INPUT 1434 error_input: 1435 rfkill_global_led_trigger_unregister(); 1436 #endif 1437 error_led_trigger: 1438 misc_deregister(&rfkill_miscdev); 1439 error_misc: 1440 class_unregister(&rfkill_class); 1441 error_class: 1442 return error; 1443 } 1444 subsys_initcall(rfkill_init); 1445 1446 static void __exit rfkill_exit(void) 1447 { 1448 #ifdef CONFIG_RFKILL_INPUT 1449 rfkill_handler_exit(); 1450 #endif 1451 rfkill_global_led_trigger_unregister(); 1452 misc_deregister(&rfkill_miscdev); 1453 class_unregister(&rfkill_class); 1454 } 1455 module_exit(rfkill_exit); 1456 1457 MODULE_ALIAS_MISCDEV(RFKILL_MINOR); 1458 MODULE_ALIAS("devname:" RFKILL_NAME); 1459