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 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 69 struct rfkill_int_event { 70 struct list_head list; 71 struct rfkill_event ev; 72 }; 73 74 struct 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 83 MODULE_AUTHOR("Ivo van Doorn <IvDoorn@gmail.com>"); 84 MODULE_AUTHOR("Johannes Berg <johannes@sipsolutions.net>"); 85 MODULE_DESCRIPTION("RF switch support"); 86 MODULE_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 */ 100 static LIST_HEAD(rfkill_list); /* list of registered rf switches */ 101 static DEFINE_MUTEX(rfkill_global_mutex); 102 static LIST_HEAD(rfkill_fds); /* list of open fds of /dev/rfkill */ 103 104 static unsigned int rfkill_default_state = 1; 105 module_param_named(default_state, rfkill_default_state, uint, 0444); 106 MODULE_PARM_DESC(default_state, 107 "Default initial state for all radio types, 0 = radio off"); 108 109 static struct { 110 bool cur, sav; 111 } rfkill_global_states[NUM_RFKILL_TYPES]; 112 113 static bool rfkill_epo_lock_active; 114 115 116 #ifdef CONFIG_RFKILL_LEDS 117 static 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 132 static 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 143 const char *rfkill_get_led_trigger_name(struct rfkill *rfkill) 144 { 145 return rfkill->led_trigger.name; 146 } 147 EXPORT_SYMBOL(rfkill_get_led_trigger_name); 148 149 void rfkill_set_led_trigger_name(struct rfkill *rfkill, const char *name) 150 { 151 BUG_ON(!rfkill); 152 153 rfkill->ledtrigname = name; 154 } 155 EXPORT_SYMBOL(rfkill_set_led_trigger_name); 156 157 static 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 165 static void rfkill_led_trigger_unregister(struct rfkill *rfkill) 166 { 167 led_trigger_unregister(&rfkill->led_trigger); 168 } 169 170 static struct led_trigger rfkill_any_led_trigger; 171 static struct led_trigger rfkill_none_led_trigger; 172 static struct work_struct rfkill_global_led_trigger_work; 173 174 static 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 193 static void rfkill_global_led_trigger_event(void) 194 { 195 schedule_work(&rfkill_global_led_trigger_work); 196 } 197 198 static 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 221 static 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 228 static void rfkill_led_trigger_event(struct rfkill *rfkill) 229 { 230 } 231 232 static inline int rfkill_led_trigger_register(struct rfkill *rfkill) 233 { 234 return 0; 235 } 236 237 static inline void rfkill_led_trigger_unregister(struct rfkill *rfkill) 238 { 239 } 240 241 static void rfkill_global_led_trigger_event(void) 242 { 243 } 244 245 static int rfkill_global_led_trigger_register(void) 246 { 247 return 0; 248 } 249 250 static void rfkill_global_led_trigger_unregister(void) 251 { 252 } 253 #endif /* CONFIG_RFKILL_LEDS */ 254 255 static 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 271 static 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 288 static 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 */ 308 static 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 367 static 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 381 static 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 */ 393 static 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 */ 416 void 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 */ 438 void 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 */ 467 void 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 */ 488 void 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 */ 507 bool 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 */ 519 bool rfkill_get_global_sw_state(const enum rfkill_type type) 520 { 521 return rfkill_global_states[type].cur; 522 } 523 #endif 524 525 bool 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 } 549 EXPORT_SYMBOL(rfkill_set_hw_state); 550 551 static 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 565 bool 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 } 590 EXPORT_SYMBOL(rfkill_set_sw_state); 591 592 void 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 } 604 EXPORT_SYMBOL(rfkill_init_sw_state); 605 606 void 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 } 639 EXPORT_SYMBOL(rfkill_set_states); 640 641 static 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 653 enum 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 } 667 EXPORT_SYMBOL(rfkill_find_type); 668 669 static 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 } 676 static DEVICE_ATTR_RO(name); 677 678 static 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 } 685 static DEVICE_ATTR_RO(type); 686 687 static 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 } 694 static DEVICE_ATTR_RO(index); 695 696 static 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 } 703 static DEVICE_ATTR_RO(persistent); 704 705 static 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 } 712 static DEVICE_ATTR_RO(hard); 713 714 static 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 722 static 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 } 745 static DEVICE_ATTR_RW(soft); 746 747 static 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 757 static 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 765 static 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 } 789 static DEVICE_ATTR_RW(state); 790 791 static 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 }; 801 ATTRIBUTE_GROUPS(rfkill_dev); 802 803 static void rfkill_release(struct device *dev) 804 { 805 struct rfkill *rfkill = to_rfkill(dev); 806 807 kfree(rfkill); 808 } 809 810 static 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 832 void 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 } 842 EXPORT_SYMBOL(rfkill_pause_polling); 843 844 void 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 } 859 EXPORT_SYMBOL(rfkill_resume_polling); 860 861 #ifdef CONFIG_PM_SLEEP 862 static 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 872 static 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->persistent) { 880 cur = !!(rfkill->state & RFKILL_BLOCK_SW); 881 rfkill_set_block(rfkill, cur); 882 } 883 884 if (rfkill->ops->poll && !rfkill->polling_paused) 885 queue_delayed_work(system_power_efficient_wq, 886 &rfkill->poll_work, 0); 887 888 return 0; 889 } 890 891 static SIMPLE_DEV_PM_OPS(rfkill_pm_ops, rfkill_suspend, rfkill_resume); 892 #define RFKILL_PM_OPS (&rfkill_pm_ops) 893 #else 894 #define RFKILL_PM_OPS NULL 895 #endif 896 897 static struct class rfkill_class = { 898 .name = "rfkill", 899 .dev_release = rfkill_release, 900 .dev_groups = rfkill_dev_groups, 901 .dev_uevent = rfkill_dev_uevent, 902 .pm = RFKILL_PM_OPS, 903 }; 904 905 bool rfkill_blocked(struct rfkill *rfkill) 906 { 907 unsigned long flags; 908 u32 state; 909 910 spin_lock_irqsave(&rfkill->lock, flags); 911 state = rfkill->state; 912 spin_unlock_irqrestore(&rfkill->lock, flags); 913 914 return !!(state & RFKILL_BLOCK_ANY); 915 } 916 EXPORT_SYMBOL(rfkill_blocked); 917 918 919 struct rfkill * __must_check rfkill_alloc(const char *name, 920 struct device *parent, 921 const enum rfkill_type type, 922 const struct rfkill_ops *ops, 923 void *ops_data) 924 { 925 struct rfkill *rfkill; 926 struct device *dev; 927 928 if (WARN_ON(!ops)) 929 return NULL; 930 931 if (WARN_ON(!ops->set_block)) 932 return NULL; 933 934 if (WARN_ON(!name)) 935 return NULL; 936 937 if (WARN_ON(type == RFKILL_TYPE_ALL || type >= NUM_RFKILL_TYPES)) 938 return NULL; 939 940 rfkill = kzalloc(sizeof(*rfkill) + strlen(name) + 1, GFP_KERNEL); 941 if (!rfkill) 942 return NULL; 943 944 spin_lock_init(&rfkill->lock); 945 INIT_LIST_HEAD(&rfkill->node); 946 rfkill->type = type; 947 strcpy(rfkill->name, name); 948 rfkill->ops = ops; 949 rfkill->data = ops_data; 950 951 dev = &rfkill->dev; 952 dev->class = &rfkill_class; 953 dev->parent = parent; 954 device_initialize(dev); 955 956 return rfkill; 957 } 958 EXPORT_SYMBOL(rfkill_alloc); 959 960 static void rfkill_poll(struct work_struct *work) 961 { 962 struct rfkill *rfkill; 963 964 rfkill = container_of(work, struct rfkill, poll_work.work); 965 966 /* 967 * Poll hardware state -- driver will use one of the 968 * rfkill_set{,_hw,_sw}_state functions and use its 969 * return value to update the current status. 970 */ 971 rfkill->ops->poll(rfkill, rfkill->data); 972 973 queue_delayed_work(system_power_efficient_wq, 974 &rfkill->poll_work, 975 round_jiffies_relative(POLL_INTERVAL)); 976 } 977 978 static void rfkill_uevent_work(struct work_struct *work) 979 { 980 struct rfkill *rfkill; 981 982 rfkill = container_of(work, struct rfkill, uevent_work); 983 984 mutex_lock(&rfkill_global_mutex); 985 rfkill_event(rfkill); 986 mutex_unlock(&rfkill_global_mutex); 987 } 988 989 static void rfkill_sync_work(struct work_struct *work) 990 { 991 struct rfkill *rfkill; 992 bool cur; 993 994 rfkill = container_of(work, struct rfkill, sync_work); 995 996 mutex_lock(&rfkill_global_mutex); 997 cur = rfkill_global_states[rfkill->type].cur; 998 rfkill_set_block(rfkill, cur); 999 mutex_unlock(&rfkill_global_mutex); 1000 } 1001 1002 int __must_check rfkill_register(struct rfkill *rfkill) 1003 { 1004 static unsigned long rfkill_no; 1005 struct device *dev = &rfkill->dev; 1006 int error; 1007 1008 BUG_ON(!rfkill); 1009 1010 mutex_lock(&rfkill_global_mutex); 1011 1012 if (rfkill->registered) { 1013 error = -EALREADY; 1014 goto unlock; 1015 } 1016 1017 rfkill->idx = rfkill_no; 1018 dev_set_name(dev, "rfkill%lu", rfkill_no); 1019 rfkill_no++; 1020 1021 list_add_tail(&rfkill->node, &rfkill_list); 1022 1023 error = device_add(dev); 1024 if (error) 1025 goto remove; 1026 1027 error = rfkill_led_trigger_register(rfkill); 1028 if (error) 1029 goto devdel; 1030 1031 rfkill->registered = true; 1032 1033 INIT_DELAYED_WORK(&rfkill->poll_work, rfkill_poll); 1034 INIT_WORK(&rfkill->uevent_work, rfkill_uevent_work); 1035 INIT_WORK(&rfkill->sync_work, rfkill_sync_work); 1036 1037 if (rfkill->ops->poll) 1038 queue_delayed_work(system_power_efficient_wq, 1039 &rfkill->poll_work, 1040 round_jiffies_relative(POLL_INTERVAL)); 1041 1042 if (!rfkill->persistent || rfkill_epo_lock_active) { 1043 schedule_work(&rfkill->sync_work); 1044 } else { 1045 #ifdef CONFIG_RFKILL_INPUT 1046 bool soft_blocked = !!(rfkill->state & RFKILL_BLOCK_SW); 1047 1048 if (!atomic_read(&rfkill_input_disabled)) 1049 __rfkill_switch_all(rfkill->type, soft_blocked); 1050 #endif 1051 } 1052 1053 rfkill_global_led_trigger_event(); 1054 rfkill_send_events(rfkill, RFKILL_OP_ADD); 1055 1056 mutex_unlock(&rfkill_global_mutex); 1057 return 0; 1058 1059 devdel: 1060 device_del(&rfkill->dev); 1061 remove: 1062 list_del_init(&rfkill->node); 1063 unlock: 1064 mutex_unlock(&rfkill_global_mutex); 1065 return error; 1066 } 1067 EXPORT_SYMBOL(rfkill_register); 1068 1069 void rfkill_unregister(struct rfkill *rfkill) 1070 { 1071 BUG_ON(!rfkill); 1072 1073 if (rfkill->ops->poll) 1074 cancel_delayed_work_sync(&rfkill->poll_work); 1075 1076 cancel_work_sync(&rfkill->uevent_work); 1077 cancel_work_sync(&rfkill->sync_work); 1078 1079 rfkill->registered = false; 1080 1081 device_del(&rfkill->dev); 1082 1083 mutex_lock(&rfkill_global_mutex); 1084 rfkill_send_events(rfkill, RFKILL_OP_DEL); 1085 list_del_init(&rfkill->node); 1086 rfkill_global_led_trigger_event(); 1087 mutex_unlock(&rfkill_global_mutex); 1088 1089 rfkill_led_trigger_unregister(rfkill); 1090 } 1091 EXPORT_SYMBOL(rfkill_unregister); 1092 1093 void rfkill_destroy(struct rfkill *rfkill) 1094 { 1095 if (rfkill) 1096 put_device(&rfkill->dev); 1097 } 1098 EXPORT_SYMBOL(rfkill_destroy); 1099 1100 static int rfkill_fop_open(struct inode *inode, struct file *file) 1101 { 1102 struct rfkill_data *data; 1103 struct rfkill *rfkill; 1104 struct rfkill_int_event *ev, *tmp; 1105 1106 data = kzalloc(sizeof(*data), GFP_KERNEL); 1107 if (!data) 1108 return -ENOMEM; 1109 1110 INIT_LIST_HEAD(&data->events); 1111 mutex_init(&data->mtx); 1112 init_waitqueue_head(&data->read_wait); 1113 1114 mutex_lock(&rfkill_global_mutex); 1115 mutex_lock(&data->mtx); 1116 /* 1117 * start getting events from elsewhere but hold mtx to get 1118 * startup events added first 1119 */ 1120 1121 list_for_each_entry(rfkill, &rfkill_list, node) { 1122 ev = kzalloc(sizeof(*ev), GFP_KERNEL); 1123 if (!ev) 1124 goto free; 1125 rfkill_fill_event(&ev->ev, rfkill, RFKILL_OP_ADD); 1126 list_add_tail(&ev->list, &data->events); 1127 } 1128 list_add(&data->list, &rfkill_fds); 1129 mutex_unlock(&data->mtx); 1130 mutex_unlock(&rfkill_global_mutex); 1131 1132 file->private_data = data; 1133 1134 return stream_open(inode, file); 1135 1136 free: 1137 mutex_unlock(&data->mtx); 1138 mutex_unlock(&rfkill_global_mutex); 1139 mutex_destroy(&data->mtx); 1140 list_for_each_entry_safe(ev, tmp, &data->events, list) 1141 kfree(ev); 1142 kfree(data); 1143 return -ENOMEM; 1144 } 1145 1146 static __poll_t rfkill_fop_poll(struct file *file, poll_table *wait) 1147 { 1148 struct rfkill_data *data = file->private_data; 1149 __poll_t res = EPOLLOUT | EPOLLWRNORM; 1150 1151 poll_wait(file, &data->read_wait, wait); 1152 1153 mutex_lock(&data->mtx); 1154 if (!list_empty(&data->events)) 1155 res = EPOLLIN | EPOLLRDNORM; 1156 mutex_unlock(&data->mtx); 1157 1158 return res; 1159 } 1160 1161 static ssize_t rfkill_fop_read(struct file *file, char __user *buf, 1162 size_t count, loff_t *pos) 1163 { 1164 struct rfkill_data *data = file->private_data; 1165 struct rfkill_int_event *ev; 1166 unsigned long sz; 1167 int ret; 1168 1169 mutex_lock(&data->mtx); 1170 1171 while (list_empty(&data->events)) { 1172 if (file->f_flags & O_NONBLOCK) { 1173 ret = -EAGAIN; 1174 goto out; 1175 } 1176 mutex_unlock(&data->mtx); 1177 /* since we re-check and it just compares pointers, 1178 * using !list_empty() without locking isn't a problem 1179 */ 1180 ret = wait_event_interruptible(data->read_wait, 1181 !list_empty(&data->events)); 1182 mutex_lock(&data->mtx); 1183 1184 if (ret) 1185 goto out; 1186 } 1187 1188 ev = list_first_entry(&data->events, struct rfkill_int_event, 1189 list); 1190 1191 sz = min_t(unsigned long, sizeof(ev->ev), count); 1192 ret = sz; 1193 if (copy_to_user(buf, &ev->ev, sz)) 1194 ret = -EFAULT; 1195 1196 list_del(&ev->list); 1197 kfree(ev); 1198 out: 1199 mutex_unlock(&data->mtx); 1200 return ret; 1201 } 1202 1203 static ssize_t rfkill_fop_write(struct file *file, const char __user *buf, 1204 size_t count, loff_t *pos) 1205 { 1206 struct rfkill *rfkill; 1207 struct rfkill_event ev; 1208 int ret; 1209 1210 /* we don't need the 'hard' variable but accept it */ 1211 if (count < RFKILL_EVENT_SIZE_V1 - 1) 1212 return -EINVAL; 1213 1214 /* 1215 * Copy as much data as we can accept into our 'ev' buffer, 1216 * but tell userspace how much we've copied so it can determine 1217 * our API version even in a write() call, if it cares. 1218 */ 1219 count = min(count, sizeof(ev)); 1220 if (copy_from_user(&ev, buf, count)) 1221 return -EFAULT; 1222 1223 if (ev.type >= NUM_RFKILL_TYPES) 1224 return -EINVAL; 1225 1226 mutex_lock(&rfkill_global_mutex); 1227 1228 switch (ev.op) { 1229 case RFKILL_OP_CHANGE_ALL: 1230 rfkill_update_global_state(ev.type, ev.soft); 1231 list_for_each_entry(rfkill, &rfkill_list, node) 1232 if (rfkill->type == ev.type || 1233 ev.type == RFKILL_TYPE_ALL) 1234 rfkill_set_block(rfkill, ev.soft); 1235 ret = 0; 1236 break; 1237 case RFKILL_OP_CHANGE: 1238 list_for_each_entry(rfkill, &rfkill_list, node) 1239 if (rfkill->idx == ev.idx && 1240 (rfkill->type == ev.type || 1241 ev.type == RFKILL_TYPE_ALL)) 1242 rfkill_set_block(rfkill, ev.soft); 1243 ret = 0; 1244 break; 1245 default: 1246 ret = -EINVAL; 1247 break; 1248 } 1249 1250 mutex_unlock(&rfkill_global_mutex); 1251 1252 return ret ?: count; 1253 } 1254 1255 static int rfkill_fop_release(struct inode *inode, struct file *file) 1256 { 1257 struct rfkill_data *data = file->private_data; 1258 struct rfkill_int_event *ev, *tmp; 1259 1260 mutex_lock(&rfkill_global_mutex); 1261 list_del(&data->list); 1262 mutex_unlock(&rfkill_global_mutex); 1263 1264 mutex_destroy(&data->mtx); 1265 list_for_each_entry_safe(ev, tmp, &data->events, list) 1266 kfree(ev); 1267 1268 #ifdef CONFIG_RFKILL_INPUT 1269 if (data->input_handler) 1270 if (atomic_dec_return(&rfkill_input_disabled) == 0) 1271 printk(KERN_DEBUG "rfkill: input handler enabled\n"); 1272 #endif 1273 1274 kfree(data); 1275 1276 return 0; 1277 } 1278 1279 #ifdef CONFIG_RFKILL_INPUT 1280 static long rfkill_fop_ioctl(struct file *file, unsigned int cmd, 1281 unsigned long arg) 1282 { 1283 struct rfkill_data *data = file->private_data; 1284 1285 if (_IOC_TYPE(cmd) != RFKILL_IOC_MAGIC) 1286 return -ENOSYS; 1287 1288 if (_IOC_NR(cmd) != RFKILL_IOC_NOINPUT) 1289 return -ENOSYS; 1290 1291 mutex_lock(&data->mtx); 1292 1293 if (!data->input_handler) { 1294 if (atomic_inc_return(&rfkill_input_disabled) == 1) 1295 printk(KERN_DEBUG "rfkill: input handler disabled\n"); 1296 data->input_handler = true; 1297 } 1298 1299 mutex_unlock(&data->mtx); 1300 1301 return 0; 1302 } 1303 #endif 1304 1305 static const struct file_operations rfkill_fops = { 1306 .owner = THIS_MODULE, 1307 .open = rfkill_fop_open, 1308 .read = rfkill_fop_read, 1309 .write = rfkill_fop_write, 1310 .poll = rfkill_fop_poll, 1311 .release = rfkill_fop_release, 1312 #ifdef CONFIG_RFKILL_INPUT 1313 .unlocked_ioctl = rfkill_fop_ioctl, 1314 .compat_ioctl = rfkill_fop_ioctl, 1315 #endif 1316 .llseek = no_llseek, 1317 }; 1318 1319 static struct miscdevice rfkill_miscdev = { 1320 .name = "rfkill", 1321 .fops = &rfkill_fops, 1322 .minor = MISC_DYNAMIC_MINOR, 1323 }; 1324 1325 static int __init rfkill_init(void) 1326 { 1327 int error; 1328 1329 rfkill_update_global_state(RFKILL_TYPE_ALL, !rfkill_default_state); 1330 1331 error = class_register(&rfkill_class); 1332 if (error) 1333 goto error_class; 1334 1335 error = misc_register(&rfkill_miscdev); 1336 if (error) 1337 goto error_misc; 1338 1339 error = rfkill_global_led_trigger_register(); 1340 if (error) 1341 goto error_led_trigger; 1342 1343 #ifdef CONFIG_RFKILL_INPUT 1344 error = rfkill_handler_init(); 1345 if (error) 1346 goto error_input; 1347 #endif 1348 1349 return 0; 1350 1351 #ifdef CONFIG_RFKILL_INPUT 1352 error_input: 1353 rfkill_global_led_trigger_unregister(); 1354 #endif 1355 error_led_trigger: 1356 misc_deregister(&rfkill_miscdev); 1357 error_misc: 1358 class_unregister(&rfkill_class); 1359 error_class: 1360 return error; 1361 } 1362 subsys_initcall(rfkill_init); 1363 1364 static void __exit rfkill_exit(void) 1365 { 1366 #ifdef CONFIG_RFKILL_INPUT 1367 rfkill_handler_exit(); 1368 #endif 1369 rfkill_global_led_trigger_unregister(); 1370 misc_deregister(&rfkill_miscdev); 1371 class_unregister(&rfkill_class); 1372 } 1373 module_exit(rfkill_exit); 1374