net/rfkill/core.c

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