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; 1006 int error; 1007 1008 if (!rfkill) 1009 return -EINVAL; 1010 1011 dev = &rfkill->dev; 1012 1013 mutex_lock(&rfkill_global_mutex); 1014 1015 if (rfkill->registered) { 1016 error = -EALREADY; 1017 goto unlock; 1018 } 1019 1020 rfkill->idx = rfkill_no; 1021 dev_set_name(dev, "rfkill%lu", rfkill_no); 1022 rfkill_no++; 1023 1024 list_add_tail(&rfkill->node, &rfkill_list); 1025 1026 error = device_add(dev); 1027 if (error) 1028 goto remove; 1029 1030 error = rfkill_led_trigger_register(rfkill); 1031 if (error) 1032 goto devdel; 1033 1034 rfkill->registered = true; 1035 1036 INIT_DELAYED_WORK(&rfkill->poll_work, rfkill_poll); 1037 INIT_WORK(&rfkill->uevent_work, rfkill_uevent_work); 1038 INIT_WORK(&rfkill->sync_work, rfkill_sync_work); 1039 1040 if (rfkill->ops->poll) 1041 queue_delayed_work(system_power_efficient_wq, 1042 &rfkill->poll_work, 1043 round_jiffies_relative(POLL_INTERVAL)); 1044 1045 if (!rfkill->persistent || rfkill_epo_lock_active) { 1046 schedule_work(&rfkill->sync_work); 1047 } else { 1048 #ifdef CONFIG_RFKILL_INPUT 1049 bool soft_blocked = !!(rfkill->state & RFKILL_BLOCK_SW); 1050 1051 if (!atomic_read(&rfkill_input_disabled)) 1052 __rfkill_switch_all(rfkill->type, soft_blocked); 1053 #endif 1054 } 1055 1056 rfkill_global_led_trigger_event(); 1057 rfkill_send_events(rfkill, RFKILL_OP_ADD); 1058 1059 mutex_unlock(&rfkill_global_mutex); 1060 return 0; 1061 1062 devdel: 1063 device_del(&rfkill->dev); 1064 remove: 1065 list_del_init(&rfkill->node); 1066 unlock: 1067 mutex_unlock(&rfkill_global_mutex); 1068 return error; 1069 } 1070 EXPORT_SYMBOL(rfkill_register); 1071 1072 void rfkill_unregister(struct rfkill *rfkill) 1073 { 1074 BUG_ON(!rfkill); 1075 1076 if (rfkill->ops->poll) 1077 cancel_delayed_work_sync(&rfkill->poll_work); 1078 1079 cancel_work_sync(&rfkill->uevent_work); 1080 cancel_work_sync(&rfkill->sync_work); 1081 1082 rfkill->registered = false; 1083 1084 device_del(&rfkill->dev); 1085 1086 mutex_lock(&rfkill_global_mutex); 1087 rfkill_send_events(rfkill, RFKILL_OP_DEL); 1088 list_del_init(&rfkill->node); 1089 rfkill_global_led_trigger_event(); 1090 mutex_unlock(&rfkill_global_mutex); 1091 1092 rfkill_led_trigger_unregister(rfkill); 1093 } 1094 EXPORT_SYMBOL(rfkill_unregister); 1095 1096 void rfkill_destroy(struct rfkill *rfkill) 1097 { 1098 if (rfkill) 1099 put_device(&rfkill->dev); 1100 } 1101 EXPORT_SYMBOL(rfkill_destroy); 1102 1103 static int rfkill_fop_open(struct inode *inode, struct file *file) 1104 { 1105 struct rfkill_data *data; 1106 struct rfkill *rfkill; 1107 struct rfkill_int_event *ev, *tmp; 1108 1109 data = kzalloc(sizeof(*data), GFP_KERNEL); 1110 if (!data) 1111 return -ENOMEM; 1112 1113 INIT_LIST_HEAD(&data->events); 1114 mutex_init(&data->mtx); 1115 init_waitqueue_head(&data->read_wait); 1116 1117 mutex_lock(&rfkill_global_mutex); 1118 mutex_lock(&data->mtx); 1119 /* 1120 * start getting events from elsewhere but hold mtx to get 1121 * startup events added first 1122 */ 1123 1124 list_for_each_entry(rfkill, &rfkill_list, node) { 1125 ev = kzalloc(sizeof(*ev), GFP_KERNEL); 1126 if (!ev) 1127 goto free; 1128 rfkill_fill_event(&ev->ev, rfkill, RFKILL_OP_ADD); 1129 list_add_tail(&ev->list, &data->events); 1130 } 1131 list_add(&data->list, &rfkill_fds); 1132 mutex_unlock(&data->mtx); 1133 mutex_unlock(&rfkill_global_mutex); 1134 1135 file->private_data = data; 1136 1137 return stream_open(inode, file); 1138 1139 free: 1140 mutex_unlock(&data->mtx); 1141 mutex_unlock(&rfkill_global_mutex); 1142 mutex_destroy(&data->mtx); 1143 list_for_each_entry_safe(ev, tmp, &data->events, list) 1144 kfree(ev); 1145 kfree(data); 1146 return -ENOMEM; 1147 } 1148 1149 static __poll_t rfkill_fop_poll(struct file *file, poll_table *wait) 1150 { 1151 struct rfkill_data *data = file->private_data; 1152 __poll_t res = EPOLLOUT | EPOLLWRNORM; 1153 1154 poll_wait(file, &data->read_wait, wait); 1155 1156 mutex_lock(&data->mtx); 1157 if (!list_empty(&data->events)) 1158 res = EPOLLIN | EPOLLRDNORM; 1159 mutex_unlock(&data->mtx); 1160 1161 return res; 1162 } 1163 1164 static ssize_t rfkill_fop_read(struct file *file, char __user *buf, 1165 size_t count, loff_t *pos) 1166 { 1167 struct rfkill_data *data = file->private_data; 1168 struct rfkill_int_event *ev; 1169 unsigned long sz; 1170 int ret; 1171 1172 mutex_lock(&data->mtx); 1173 1174 while (list_empty(&data->events)) { 1175 if (file->f_flags & O_NONBLOCK) { 1176 ret = -EAGAIN; 1177 goto out; 1178 } 1179 mutex_unlock(&data->mtx); 1180 /* since we re-check and it just compares pointers, 1181 * using !list_empty() without locking isn't a problem 1182 */ 1183 ret = wait_event_interruptible(data->read_wait, 1184 !list_empty(&data->events)); 1185 mutex_lock(&data->mtx); 1186 1187 if (ret) 1188 goto out; 1189 } 1190 1191 ev = list_first_entry(&data->events, struct rfkill_int_event, 1192 list); 1193 1194 sz = min_t(unsigned long, sizeof(ev->ev), count); 1195 ret = sz; 1196 if (copy_to_user(buf, &ev->ev, sz)) 1197 ret = -EFAULT; 1198 1199 list_del(&ev->list); 1200 kfree(ev); 1201 out: 1202 mutex_unlock(&data->mtx); 1203 return ret; 1204 } 1205 1206 static ssize_t rfkill_fop_write(struct file *file, const char __user *buf, 1207 size_t count, loff_t *pos) 1208 { 1209 struct rfkill *rfkill; 1210 struct rfkill_event ev; 1211 int ret; 1212 1213 /* we don't need the 'hard' variable but accept it */ 1214 if (count < RFKILL_EVENT_SIZE_V1 - 1) 1215 return -EINVAL; 1216 1217 /* 1218 * Copy as much data as we can accept into our 'ev' buffer, 1219 * but tell userspace how much we've copied so it can determine 1220 * our API version even in a write() call, if it cares. 1221 */ 1222 count = min(count, sizeof(ev)); 1223 if (copy_from_user(&ev, buf, count)) 1224 return -EFAULT; 1225 1226 if (ev.type >= NUM_RFKILL_TYPES) 1227 return -EINVAL; 1228 1229 mutex_lock(&rfkill_global_mutex); 1230 1231 switch (ev.op) { 1232 case RFKILL_OP_CHANGE_ALL: 1233 rfkill_update_global_state(ev.type, ev.soft); 1234 list_for_each_entry(rfkill, &rfkill_list, node) 1235 if (rfkill->type == ev.type || 1236 ev.type == RFKILL_TYPE_ALL) 1237 rfkill_set_block(rfkill, ev.soft); 1238 ret = 0; 1239 break; 1240 case RFKILL_OP_CHANGE: 1241 list_for_each_entry(rfkill, &rfkill_list, node) 1242 if (rfkill->idx == ev.idx && 1243 (rfkill->type == ev.type || 1244 ev.type == RFKILL_TYPE_ALL)) 1245 rfkill_set_block(rfkill, ev.soft); 1246 ret = 0; 1247 break; 1248 default: 1249 ret = -EINVAL; 1250 break; 1251 } 1252 1253 mutex_unlock(&rfkill_global_mutex); 1254 1255 return ret ?: count; 1256 } 1257 1258 static int rfkill_fop_release(struct inode *inode, struct file *file) 1259 { 1260 struct rfkill_data *data = file->private_data; 1261 struct rfkill_int_event *ev, *tmp; 1262 1263 mutex_lock(&rfkill_global_mutex); 1264 list_del(&data->list); 1265 mutex_unlock(&rfkill_global_mutex); 1266 1267 mutex_destroy(&data->mtx); 1268 list_for_each_entry_safe(ev, tmp, &data->events, list) 1269 kfree(ev); 1270 1271 #ifdef CONFIG_RFKILL_INPUT 1272 if (data->input_handler) 1273 if (atomic_dec_return(&rfkill_input_disabled) == 0) 1274 printk(KERN_DEBUG "rfkill: input handler enabled\n"); 1275 #endif 1276 1277 kfree(data); 1278 1279 return 0; 1280 } 1281 1282 #ifdef CONFIG_RFKILL_INPUT 1283 static long rfkill_fop_ioctl(struct file *file, unsigned int cmd, 1284 unsigned long arg) 1285 { 1286 struct rfkill_data *data = file->private_data; 1287 1288 if (_IOC_TYPE(cmd) != RFKILL_IOC_MAGIC) 1289 return -ENOSYS; 1290 1291 if (_IOC_NR(cmd) != RFKILL_IOC_NOINPUT) 1292 return -ENOSYS; 1293 1294 mutex_lock(&data->mtx); 1295 1296 if (!data->input_handler) { 1297 if (atomic_inc_return(&rfkill_input_disabled) == 1) 1298 printk(KERN_DEBUG "rfkill: input handler disabled\n"); 1299 data->input_handler = true; 1300 } 1301 1302 mutex_unlock(&data->mtx); 1303 1304 return 0; 1305 } 1306 #endif 1307 1308 static const struct file_operations rfkill_fops = { 1309 .owner = THIS_MODULE, 1310 .open = rfkill_fop_open, 1311 .read = rfkill_fop_read, 1312 .write = rfkill_fop_write, 1313 .poll = rfkill_fop_poll, 1314 .release = rfkill_fop_release, 1315 #ifdef CONFIG_RFKILL_INPUT 1316 .unlocked_ioctl = rfkill_fop_ioctl, 1317 .compat_ioctl = compat_ptr_ioctl, 1318 #endif 1319 .llseek = no_llseek, 1320 }; 1321 1322 #define RFKILL_NAME "rfkill" 1323 1324 static struct miscdevice rfkill_miscdev = { 1325 .fops = &rfkill_fops, 1326 .name = RFKILL_NAME, 1327 .minor = RFKILL_MINOR, 1328 }; 1329 1330 static int __init rfkill_init(void) 1331 { 1332 int error; 1333 1334 rfkill_update_global_state(RFKILL_TYPE_ALL, !rfkill_default_state); 1335 1336 error = class_register(&rfkill_class); 1337 if (error) 1338 goto error_class; 1339 1340 error = misc_register(&rfkill_miscdev); 1341 if (error) 1342 goto error_misc; 1343 1344 error = rfkill_global_led_trigger_register(); 1345 if (error) 1346 goto error_led_trigger; 1347 1348 #ifdef CONFIG_RFKILL_INPUT 1349 error = rfkill_handler_init(); 1350 if (error) 1351 goto error_input; 1352 #endif 1353 1354 return 0; 1355 1356 #ifdef CONFIG_RFKILL_INPUT 1357 error_input: 1358 rfkill_global_led_trigger_unregister(); 1359 #endif 1360 error_led_trigger: 1361 misc_deregister(&rfkill_miscdev); 1362 error_misc: 1363 class_unregister(&rfkill_class); 1364 error_class: 1365 return error; 1366 } 1367 subsys_initcall(rfkill_init); 1368 1369 static void __exit rfkill_exit(void) 1370 { 1371 #ifdef CONFIG_RFKILL_INPUT 1372 rfkill_handler_exit(); 1373 #endif 1374 rfkill_global_led_trigger_unregister(); 1375 misc_deregister(&rfkill_miscdev); 1376 class_unregister(&rfkill_class); 1377 } 1378 module_exit(rfkill_exit); 1379 1380 MODULE_ALIAS_MISCDEV(RFKILL_MINOR); 1381 MODULE_ALIAS("devname:" RFKILL_NAME); 1382