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