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