net/rfkill/rfkill.c

   1 /*
   2  * Copyright (C) 2006 - 2007 Ivo van Doorn
   3  * Copyright (C) 2007 Dmitry Torokhov
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the
  17  * Free Software Foundation, Inc.,
  18  * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include <linux/kernel.h>
  22 #include <linux/module.h>
  23 #include <linux/init.h>
  24 #include <linux/workqueue.h>
  25 #include <linux/capability.h>
  26 #include <linux/list.h>
  27 #include <linux/mutex.h>
  28 #include <linux/rfkill.h>
  29
  30 /* Get declaration of rfkill_switch_all() to shut up sparse. */
  31 #include "rfkill-input.h"
  32
  33
  34 MODULE_AUTHOR("Ivo van Doorn <IvDoorn@gmail.com>");
  35 MODULE_VERSION("1.0");
  36 MODULE_DESCRIPTION("RF switch support");
  37 MODULE_LICENSE("GPL");
  38
  39 static LIST_HEAD(rfkill_list);  /* list of registered rf switches */
  40 static DEFINE_MUTEX(rfkill_global_mutex);
  41
  42 static unsigned int rfkill_default_state = RFKILL_STATE_UNBLOCKED;
  43 module_param_named(default_state, rfkill_default_state, uint, 0444);
  44 MODULE_PARM_DESC(default_state,
  45                  "Default initial state for all radio types, 0 = radio off");
  46
  47 struct rfkill_gsw_state {
  48         enum rfkill_state current_state;
  49         enum rfkill_state default_state;
  50 };
  51
  52 static struct rfkill_gsw_state rfkill_global_states[RFKILL_TYPE_MAX];
  53 static unsigned long rfkill_states_lockdflt[BITS_TO_LONGS(RFKILL_TYPE_MAX)];
  54 static bool rfkill_epo_lock_active;
  55
  56
  57 #ifdef CONFIG_RFKILL_LEDS
  58 static void rfkill_led_trigger(struct rfkill *rfkill,
  59                                enum rfkill_state state)
  60 {
  61         struct led_trigger *led = &rfkill->led_trigger;
  62
  63         if (!led->name)
  64                 return;
  65         if (state != RFKILL_STATE_UNBLOCKED)
  66                 led_trigger_event(led, LED_OFF);
  67         else
  68                 led_trigger_event(led, LED_FULL);
  69 }
  70
  71 static void rfkill_led_trigger_activate(struct led_classdev *led)
  72 {
  73         struct rfkill *rfkill = container_of(led->trigger,
  74                         struct rfkill, led_trigger);
  75
  76         rfkill_led_trigger(rfkill, rfkill->state);
  77 }
  78 #endif /* CONFIG_RFKILL_LEDS */
  79
  80 static void rfkill_uevent(struct rfkill *rfkill)
  81 {
  82         kobject_uevent(&rfkill->dev.kobj, KOBJ_CHANGE);
  83 }
  84
  85 static void update_rfkill_state(struct rfkill *rfkill)
  86 {
  87         enum rfkill_state newstate, oldstate;
  88
  89         if (rfkill->get_state) {
  90                 mutex_lock(&rfkill->mutex);
  91                 if (!rfkill->get_state(rfkill->data, &newstate)) {
  92                         oldstate = rfkill->state;
  93                         rfkill->state = newstate;
  94                         if (oldstate != newstate)
  95                                 rfkill_uevent(rfkill);
  96                 }
  97                 mutex_unlock(&rfkill->mutex);
  98         }
  99 }
 100
 101 /**
 102  * rfkill_toggle_radio - wrapper for toggle_radio hook
 103  * @rfkill: the rfkill struct to use
 104  * @force: calls toggle_radio even if cache says it is not needed,
 105  *      and also makes sure notifications of the state will be
 106  *      sent even if it didn't change
 107  * @state: the new state to call toggle_radio() with
 108  *
 109  * Calls rfkill->toggle_radio, enforcing the API for toggle_radio
 110  * calls and handling all the red tape such as issuing notifications
 111  * if the call is successful.
 112  *
 113  * Suspended devices are not touched at all, and -EAGAIN is returned.
 114  *
 115  * Note that the @force parameter cannot override a (possibly cached)
 116  * state of RFKILL_STATE_HARD_BLOCKED.  Any device making use of
 117  * RFKILL_STATE_HARD_BLOCKED implements either get_state() or
 118  * rfkill_force_state(), so the cache either is bypassed or valid.
 119  *
 120  * Note that we do call toggle_radio for RFKILL_STATE_SOFT_BLOCKED
 121  * even if the radio is in RFKILL_STATE_HARD_BLOCKED state, so as to
 122  * give the driver a hint that it should double-BLOCK the transmitter.
 123  *
 124  * Caller must have acquired rfkill->mutex.
 125  */
 126 static int rfkill_toggle_radio(struct rfkill *rfkill,
 127                                 enum rfkill_state state,
 128                                 int force)
 129 {
 130         int retval = 0;
 131         enum rfkill_state oldstate, newstate;
 132
 133         if (unlikely(rfkill->dev.power.power_state.event & PM_EVENT_SLEEP))
 134                 return -EBUSY;
 135
 136         oldstate = rfkill->state;
 137
 138         if (rfkill->get_state && !force &&
 139             !rfkill->get_state(rfkill->data, &newstate))
 140                 rfkill->state = newstate;
 141
 142         switch (state) {
 143         case RFKILL_STATE_HARD_BLOCKED:
 144                 /* typically happens when refreshing hardware state,
 145                  * such as on resume */
 146                 state = RFKILL_STATE_SOFT_BLOCKED;
 147                 break;
 148         case RFKILL_STATE_UNBLOCKED:
 149                 /* force can't override this, only rfkill_force_state() can */
 150                 if (rfkill->state == RFKILL_STATE_HARD_BLOCKED)
 151                         return -EPERM;
 152                 break;
 153         case RFKILL_STATE_SOFT_BLOCKED:
 154                 /* nothing to do, we want to give drivers the hint to double
 155                  * BLOCK even a transmitter that is already in state
 156                  * RFKILL_STATE_HARD_BLOCKED */
 157                 break;
 158         default:
 159                 WARN(1, KERN_WARNING
 160                         "rfkill: illegal state %d passed as parameter "
 161                         "to rfkill_toggle_radio\n", state);
 162                 return -EINVAL;
 163         }
 164
 165         if (force || state != rfkill->state) {
 166                 retval = rfkill->toggle_radio(rfkill->data, state);
 167                 /* never allow a HARD->SOFT downgrade! */
 168                 if (!retval && rfkill->state != RFKILL_STATE_HARD_BLOCKED)
 169                         rfkill->state = state;
 170         }
 171
 172         if (force || rfkill->state != oldstate)
 173                 rfkill_uevent(rfkill);
 174
 175         return retval;
 176 }
 177
 178 /**
 179  * __rfkill_switch_all - Toggle state of all switches of given type
 180  * @type: type of interfaces to be affected
 181  * @state: the new state
 182  *
 183  * This function toggles the state of all switches of given type,
 184  * unless a specific switch is claimed by userspace (in which case,
 185  * that switch is left alone) or suspended.
 186  *
 187  * Caller must have acquired rfkill_global_mutex.
 188  */
 189 static void __rfkill_switch_all(const enum rfkill_type type,
 190                                 const enum rfkill_state state)
 191 {
 192         struct rfkill *rfkill;
 193
 194         if (WARN((state >= RFKILL_STATE_MAX || type >= RFKILL_TYPE_MAX),
 195                         KERN_WARNING
 196                         "rfkill: illegal state %d or type %d "
 197                         "passed as parameter to __rfkill_switch_all\n",
 198                         state, type))
 199                 return;
 200
 201         rfkill_global_states[type].current_state = state;
 202         list_for_each_entry(rfkill, &rfkill_list, node) {
 203                 if (rfkill->type == type) {
 204                         mutex_lock(&rfkill->mutex);
 205                         rfkill_toggle_radio(rfkill, state, 0);
 206                         mutex_unlock(&rfkill->mutex);
 207                 }
 208         }
 209 }
 210
 211 /**
 212  * rfkill_switch_all - Toggle state of all switches of given type
 213  * @type: type of interfaces to be affected
 214  * @state: the new state
 215  *
 216  * Acquires rfkill_global_mutex and calls __rfkill_switch_all(@type, @state).
 217  * Please refer to __rfkill_switch_all() for details.
 218  *
 219  * Does nothing if the EPO lock is active.
 220  */
 221 void rfkill_switch_all(enum rfkill_type type, enum rfkill_state state)
 222 {
 223         mutex_lock(&rfkill_global_mutex);
 224         if (!rfkill_epo_lock_active)
 225                 __rfkill_switch_all(type, state);
 226         mutex_unlock(&rfkill_global_mutex);
 227 }
 228 EXPORT_SYMBOL(rfkill_switch_all);
 229
 230 /**
 231  * rfkill_epo - emergency power off all transmitters
 232  *
 233  * This kicks all non-suspended rfkill devices to RFKILL_STATE_SOFT_BLOCKED,
 234  * ignoring everything in its path but rfkill_global_mutex and rfkill->mutex.
 235  *
 236  * The global state before the EPO is saved and can be restored later
 237  * using rfkill_restore_states().
 238  */
 239 void rfkill_epo(void)
 240 {
 241         struct rfkill *rfkill;
 242         int i;
 243
 244         mutex_lock(&rfkill_global_mutex);
 245
 246         rfkill_epo_lock_active = true;
 247         list_for_each_entry(rfkill, &rfkill_list, node) {
 248                 mutex_lock(&rfkill->mutex);
 249                 rfkill_toggle_radio(rfkill, RFKILL_STATE_SOFT_BLOCKED, 1);
 250                 mutex_unlock(&rfkill->mutex);
 251         }
 252         for (i = 0; i < RFKILL_TYPE_MAX; i++) {
 253                 rfkill_global_states[i].default_state =
 254                                 rfkill_global_states[i].current_state;
 255                 rfkill_global_states[i].current_state =
 256                                 RFKILL_STATE_SOFT_BLOCKED;
 257         }
 258         mutex_unlock(&rfkill_global_mutex);
 259 }
 260 EXPORT_SYMBOL_GPL(rfkill_epo);
 261
 262 /**
 263  * rfkill_restore_states - restore global states
 264  *
 265  * Restore (and sync switches to) the global state from the
 266  * states in rfkill_default_states.  This can undo the effects of
 267  * a call to rfkill_epo().
 268  */
 269 void rfkill_restore_states(void)
 270 {
 271         int i;
 272
 273         mutex_lock(&rfkill_global_mutex);
 274
 275         rfkill_epo_lock_active = false;
 276         for (i = 0; i < RFKILL_TYPE_MAX; i++)
 277                 __rfkill_switch_all(i, rfkill_global_states[i].default_state);
 278         mutex_unlock(&rfkill_global_mutex);
 279 }
 280 EXPORT_SYMBOL_GPL(rfkill_restore_states);
 281
 282 /**
 283  * rfkill_remove_epo_lock - unlock state changes
 284  *
 285  * Used by rfkill-input manually unlock state changes, when
 286  * the EPO switch is deactivated.
 287  */
 288 void rfkill_remove_epo_lock(void)
 289 {
 290         mutex_lock(&rfkill_global_mutex);
 291         rfkill_epo_lock_active = false;
 292         mutex_unlock(&rfkill_global_mutex);
 293 }
 294 EXPORT_SYMBOL_GPL(rfkill_remove_epo_lock);
 295
 296 /**
 297  * rfkill_is_epo_lock_active - returns true EPO is active
 298  *
 299  * Returns 0 (false) if there is NOT an active EPO contidion,
 300  * and 1 (true) if there is an active EPO contition, which
 301  * locks all radios in one of the BLOCKED states.
 302  *
 303  * Can be called in atomic context.
 304  */
 305 bool rfkill_is_epo_lock_active(void)
 306 {
 307         return rfkill_epo_lock_active;
 308 }
 309 EXPORT_SYMBOL_GPL(rfkill_is_epo_lock_active);
 310
 311 /**
 312  * rfkill_get_global_state - returns global state for a type
 313  * @type: the type to get the global state of
 314  *
 315  * Returns the current global state for a given wireless
 316  * device type.
 317  */
 318 enum rfkill_state rfkill_get_global_state(const enum rfkill_type type)
 319 {
 320         return rfkill_global_states[type].current_state;
 321 }
 322 EXPORT_SYMBOL_GPL(rfkill_get_global_state);
 323
 324 /**
 325  * rfkill_force_state - Force the internal rfkill radio state
 326  * @rfkill: pointer to the rfkill class to modify.
 327  * @state: the current radio state the class should be forced to.
 328  *
 329  * This function updates the internal state of the radio cached
 330  * by the rfkill class.  It should be used when the driver gets
 331  * a notification by the firmware/hardware of the current *real*
 332  * state of the radio rfkill switch.
 333  *
 334  * Devices which are subject to external changes on their rfkill
 335  * state (such as those caused by a hardware rfkill line) MUST
 336  * have their driver arrange to call rfkill_force_state() as soon
 337  * as possible after such a change.
 338  *
 339  * This function may not be called from an atomic context.
 340  */
 341 int rfkill_force_state(struct rfkill *rfkill, enum rfkill_state state)
 342 {
 343         enum rfkill_state oldstate;
 344
 345         BUG_ON(!rfkill);
 346         if (WARN((state >= RFKILL_STATE_MAX),
 347                         KERN_WARNING
 348                         "rfkill: illegal state %d passed as parameter "
 349                         "to rfkill_force_state\n", state))
 350                 return -EINVAL;
 351
 352         mutex_lock(&rfkill->mutex);
 353
 354         oldstate = rfkill->state;
 355         rfkill->state = state;
 356
 357         if (state != oldstate)
 358                 rfkill_uevent(rfkill);
 359
 360         mutex_unlock(&rfkill->mutex);
 361
 362         return 0;
 363 }
 364 EXPORT_SYMBOL(rfkill_force_state);
 365
 366 static ssize_t rfkill_name_show(struct device *dev,
 367                                 struct device_attribute *attr,
 368                                 char *buf)
 369 {
 370         struct rfkill *rfkill = to_rfkill(dev);
 371
 372         return sprintf(buf, "%s\n", rfkill->name);
 373 }
 374
 375 static const char *rfkill_get_type_str(enum rfkill_type type)
 376 {
 377         switch (type) {
 378         case RFKILL_TYPE_WLAN:
 379                 return "wlan";
 380         case RFKILL_TYPE_BLUETOOTH:
 381                 return "bluetooth";
 382         case RFKILL_TYPE_UWB:
 383                 return "ultrawideband";
 384         case RFKILL_TYPE_WIMAX:
 385                 return "wimax";
 386         case RFKILL_TYPE_WWAN:
 387                 return "wwan";
 388         default:
 389                 BUG();
 390         }
 391 }
 392
 393 static ssize_t rfkill_type_show(struct device *dev,
 394                                 struct device_attribute *attr,
 395                                 char *buf)
 396 {
 397         struct rfkill *rfkill = to_rfkill(dev);
 398
 399         return sprintf(buf, "%s\n", rfkill_get_type_str(rfkill->type));
 400 }
 401
 402 static ssize_t rfkill_state_show(struct device *dev,
 403                                  struct device_attribute *attr,
 404                                  char *buf)
 405 {
 406         struct rfkill *rfkill = to_rfkill(dev);
 407
 408         update_rfkill_state(rfkill);
 409         return sprintf(buf, "%d\n", rfkill->state);
 410 }
 411
 412 static ssize_t rfkill_state_store(struct device *dev,
 413                                   struct device_attribute *attr,
 414                                   const char *buf, size_t count)
 415 {
 416         struct rfkill *rfkill = to_rfkill(dev);
 417         unsigned long state;
 418         int error;
 419
 420         if (!capable(CAP_NET_ADMIN))
 421                 return -EPERM;
 422
 423         error = strict_strtoul(buf, 0, &state);
 424         if (error)
 425                 return error;
 426
 427         /* RFKILL_STATE_HARD_BLOCKED is illegal here... */
 428         if (state != RFKILL_STATE_UNBLOCKED &&
 429             state != RFKILL_STATE_SOFT_BLOCKED)
 430                 return -EINVAL;
 431
 432         error = mutex_lock_killable(&rfkill->mutex);
 433         if (error)
 434                 return error;
 435
 436         if (!rfkill_epo_lock_active)
 437                 error = rfkill_toggle_radio(rfkill, state, 0);
 438         else
 439                 error = -EPERM;
 440
 441         mutex_unlock(&rfkill->mutex);
 442
 443         return error ? error : count;
 444 }
 445
 446 static ssize_t rfkill_claim_show(struct device *dev,
 447                                  struct device_attribute *attr,
 448                                  char *buf)
 449 {
 450         return sprintf(buf, "%d\n", 0);
 451 }
 452
 453 static ssize_t rfkill_claim_store(struct device *dev,
 454                                   struct device_attribute *attr,
 455                                   const char *buf, size_t count)
 456 {
 457         return -EOPNOTSUPP;
 458 }
 459
 460 static struct device_attribute rfkill_dev_attrs[] = {
 461         __ATTR(name, S_IRUGO, rfkill_name_show, NULL),
 462         __ATTR(type, S_IRUGO, rfkill_type_show, NULL),
 463         __ATTR(state, S_IRUGO|S_IWUSR, rfkill_state_show, rfkill_state_store),
 464         __ATTR(claim, S_IRUGO|S_IWUSR, rfkill_claim_show, rfkill_claim_store),
 465         __ATTR_NULL
 466 };
 467
 468 static void rfkill_release(struct device *dev)
 469 {
 470         struct rfkill *rfkill = to_rfkill(dev);
 471
 472         kfree(rfkill);
 473         module_put(THIS_MODULE);
 474 }
 475
 476 #ifdef CONFIG_PM
 477 static int rfkill_suspend(struct device *dev, pm_message_t state)
 478 {
 479         struct rfkill *rfkill = to_rfkill(dev);
 480
 481         /* mark class device as suspended */
 482         if (dev->power.power_state.event != state.event)
 483                 dev->power.power_state = state;
 484
 485         /* store state for the resume handler */
 486         rfkill->state_for_resume = rfkill->state;
 487
 488         return 0;
 489 }
 490
 491 static int rfkill_resume(struct device *dev)
 492 {
 493         struct rfkill *rfkill = to_rfkill(dev);
 494         enum rfkill_state newstate;
 495
 496         if (dev->power.power_state.event != PM_EVENT_ON) {
 497                 mutex_lock(&rfkill->mutex);
 498
 499                 dev->power.power_state.event = PM_EVENT_ON;
 500
 501                 /*
 502                  * rfkill->state could have been modified before we got
 503                  * called, and won't be updated by rfkill_toggle_radio()
 504                  * in force mode.  Sync it FIRST.
 505                  */
 506                 if (rfkill->get_state &&
 507                     !rfkill->get_state(rfkill->data, &newstate))
 508                         rfkill->state = newstate;
 509
 510                 /*
 511                  * If we are under EPO, kick transmitter offline,
 512                  * otherwise restore to pre-suspend state.
 513                  *
 514                  * Issue a notification in any case
 515                  */
 516                 rfkill_toggle_radio(rfkill,
 517                                 rfkill_epo_lock_active ?
 518                                         RFKILL_STATE_SOFT_BLOCKED :
 519                                         rfkill->state_for_resume,
 520                                 1);
 521
 522                 mutex_unlock(&rfkill->mutex);
 523         }
 524
 525         return 0;
 526 }
 527 #else
 528 #define rfkill_suspend NULL
 529 #define rfkill_resume NULL
 530 #endif
 531
 532 static int rfkill_dev_uevent(struct device *dev, struct kobj_uevent_env *env)
 533 {
 534         struct rfkill *rfkill = to_rfkill(dev);
 535         int error;
 536
 537         error = add_uevent_var(env, "RFKILL_NAME=%s", rfkill->name);
 538         if (error)
 539                 return error;
 540         error = add_uevent_var(env, "RFKILL_TYPE=%s",
 541                                 rfkill_get_type_str(rfkill->type));
 542         if (error)
 543                 return error;
 544         error = add_uevent_var(env, "RFKILL_STATE=%d", rfkill->state);
 545         return error;
 546 }
 547
 548 static struct class rfkill_class = {
 549         .name           = "rfkill",
 550         .dev_release    = rfkill_release,
 551         .dev_attrs      = rfkill_dev_attrs,
 552         .suspend        = rfkill_suspend,
 553         .resume         = rfkill_resume,
 554         .dev_uevent     = rfkill_dev_uevent,
 555 };
 556
 557 static int rfkill_check_duplicity(const struct rfkill *rfkill)
 558 {
 559         struct rfkill *p;
 560         unsigned long seen[BITS_TO_LONGS(RFKILL_TYPE_MAX)];
 561
 562         memset(seen, 0, sizeof(seen));
 563
 564         list_for_each_entry(p, &rfkill_list, node) {
 565                 if (WARN((p == rfkill), KERN_WARNING
 566                                 "rfkill: illegal attempt to register "
 567                                 "an already registered rfkill struct\n"))
 568                         return -EEXIST;
 569                 set_bit(p->type, seen);
 570         }
 571
 572         /* 0: first switch of its kind */
 573         return (test_bit(rfkill->type, seen)) ? 1 : 0;
 574 }
 575
 576 static int rfkill_add_switch(struct rfkill *rfkill)
 577 {
 578         int error;
 579
 580         mutex_lock(&rfkill_global_mutex);
 581
 582         error = rfkill_check_duplicity(rfkill);
 583         if (error < 0)
 584                 goto unlock_out;
 585
 586         if (!error) {
 587                 /* lock default after first use */
 588                 set_bit(rfkill->type, rfkill_states_lockdflt);
 589                 rfkill_global_states[rfkill->type].current_state =
 590                         rfkill_global_states[rfkill->type].default_state;
 591         }
 592
 593         rfkill_toggle_radio(rfkill,
 594                             rfkill_global_states[rfkill->type].current_state,
 595                             0);
 596
 597         list_add_tail(&rfkill->node, &rfkill_list);
 598
 599         error = 0;
 600 unlock_out:
 601         mutex_unlock(&rfkill_global_mutex);
 602
 603         return error;
 604 }
 605
 606 static void rfkill_remove_switch(struct rfkill *rfkill)
 607 {
 608         mutex_lock(&rfkill_global_mutex);
 609         list_del_init(&rfkill->node);
 610         mutex_unlock(&rfkill_global_mutex);
 611
 612         mutex_lock(&rfkill->mutex);
 613         rfkill_toggle_radio(rfkill, RFKILL_STATE_SOFT_BLOCKED, 1);
 614         mutex_unlock(&rfkill->mutex);
 615 }
 616
 617 /**
 618  * rfkill_allocate - allocate memory for rfkill structure.
 619  * @parent: device that has rf switch on it
 620  * @type: type of the switch (RFKILL_TYPE_*)
 621  *
 622  * This function should be called by the network driver when it needs
 623  * rfkill structure.  Once the structure is allocated the driver should
 624  * finish its initialization by setting the name, private data, enable_radio
 625  * and disable_radio methods and then register it with rfkill_register().
 626  *
 627  * NOTE: If registration fails the structure shoudl be freed by calling
 628  * rfkill_free() otherwise rfkill_unregister() should be used.
 629  */
 630 struct rfkill * __must_check rfkill_allocate(struct device *parent,
 631                                              enum rfkill_type type)
 632 {
 633         struct rfkill *rfkill;
 634         struct device *dev;
 635
 636         if (WARN((type >= RFKILL_TYPE_MAX),
 637                         KERN_WARNING
 638                         "rfkill: illegal type %d passed as parameter "
 639                         "to rfkill_allocate\n", type))
 640                 return NULL;
 641
 642         rfkill = kzalloc(sizeof(struct rfkill), GFP_KERNEL);
 643         if (!rfkill)
 644                 return NULL;
 645
 646         mutex_init(&rfkill->mutex);
 647         INIT_LIST_HEAD(&rfkill->node);
 648         rfkill->type = type;
 649
 650         dev = &rfkill->dev;
 651         dev->class = &rfkill_class;
 652         dev->parent = parent;
 653         device_initialize(dev);
 654
 655         __module_get(THIS_MODULE);
 656
 657         return rfkill;
 658 }
 659 EXPORT_SYMBOL(rfkill_allocate);
 660
 661 /**
 662  * rfkill_free - Mark rfkill structure for deletion
 663  * @rfkill: rfkill structure to be destroyed
 664  *
 665  * Decrements reference count of the rfkill structure so it is destroyed.
 666  * Note that rfkill_free() should _not_ be called after rfkill_unregister().
 667  */
 668 void rfkill_free(struct rfkill *rfkill)
 669 {
 670         if (rfkill)
 671                 put_device(&rfkill->dev);
 672 }
 673 EXPORT_SYMBOL(rfkill_free);
 674
 675 static void rfkill_led_trigger_register(struct rfkill *rfkill)
 676 {
 677 #ifdef CONFIG_RFKILL_LEDS
 678         int error;
 679
 680         if (!rfkill->led_trigger.name)
 681                 rfkill->led_trigger.name = dev_name(&rfkill->dev);
 682         if (!rfkill->led_trigger.activate)
 683                 rfkill->led_trigger.activate = rfkill_led_trigger_activate;
 684         error = led_trigger_register(&rfkill->led_trigger);
 685         if (error)
 686                 rfkill->led_trigger.name = NULL;
 687 #endif /* CONFIG_RFKILL_LEDS */
 688 }
 689
 690 static void rfkill_led_trigger_unregister(struct rfkill *rfkill)
 691 {
 692 #ifdef CONFIG_RFKILL_LEDS
 693         if (rfkill->led_trigger.name) {
 694                 led_trigger_unregister(&rfkill->led_trigger);
 695                 rfkill->led_trigger.name = NULL;
 696         }
 697 #endif
 698 }
 699
 700 /**
 701  * rfkill_register - Register a rfkill structure.
 702  * @rfkill: rfkill structure to be registered
 703  *
 704  * This function should be called by the network driver when the rfkill
 705  * structure needs to be registered. Immediately from registration the
 706  * switch driver should be able to service calls to toggle_radio.
 707  */
 708 int __must_check rfkill_register(struct rfkill *rfkill)
 709 {
 710         static atomic_t rfkill_no = ATOMIC_INIT(0);
 711         struct device *dev = &rfkill->dev;
 712         int error;
 713
 714         if (WARN((!rfkill || !rfkill->toggle_radio ||
 715                         rfkill->type >= RFKILL_TYPE_MAX ||
 716                         rfkill->state >= RFKILL_STATE_MAX),
 717                         KERN_WARNING
 718                         "rfkill: attempt to register a "
 719                         "badly initialized rfkill struct\n"))
 720                 return -EINVAL;
 721
 722         dev_set_name(dev, "rfkill%ld", (long)atomic_inc_return(&rfkill_no) - 1);
 723
 724         rfkill_led_trigger_register(rfkill);
 725
 726         error = rfkill_add_switch(rfkill);
 727         if (error) {
 728                 rfkill_led_trigger_unregister(rfkill);
 729                 return error;
 730         }
 731
 732         error = device_add(dev);
 733         if (error) {
 734                 rfkill_remove_switch(rfkill);
 735                 rfkill_led_trigger_unregister(rfkill);
 736                 return error;
 737         }
 738
 739         return 0;
 740 }
 741 EXPORT_SYMBOL(rfkill_register);
 742
 743 /**
 744  * rfkill_unregister - Unregister a rfkill structure.
 745  * @rfkill: rfkill structure to be unregistered
 746  *
 747  * This function should be called by the network driver during device
 748  * teardown to destroy rfkill structure. Note that rfkill_free() should
 749  * _not_ be called after rfkill_unregister().
 750  */
 751 void rfkill_unregister(struct rfkill *rfkill)
 752 {
 753         BUG_ON(!rfkill);
 754         device_del(&rfkill->dev);
 755         rfkill_remove_switch(rfkill);
 756         rfkill_led_trigger_unregister(rfkill);
 757         put_device(&rfkill->dev);
 758 }
 759 EXPORT_SYMBOL(rfkill_unregister);
 760
 761 /**
 762  * rfkill_set_default - set initial value for a switch type
 763  * @type - the type of switch to set the default state of
 764  * @state - the new default state for that group of switches
 765  *
 766  * Sets the initial state rfkill should use for a given type.
 767  * The following initial states are allowed: RFKILL_STATE_SOFT_BLOCKED
 768  * and RFKILL_STATE_UNBLOCKED.
 769  *
 770  * This function is meant to be used by platform drivers for platforms
 771  * that can save switch state across power down/reboot.
 772  *
 773  * The default state for each switch type can be changed exactly once.
 774  * After a switch of that type is registered, the default state cannot
 775  * be changed anymore.  This guards against multiple drivers it the
 776  * same platform trying to set the initial switch default state, which
 777  * is not allowed.
 778  *
 779  * Returns -EPERM if the state has already been set once or is in use,
 780  * so drivers likely want to either ignore or at most printk(KERN_NOTICE)
 781  * if this function returns -EPERM.
 782  *
 783  * Returns 0 if the new default state was set, or an error if it
 784  * could not be set.
 785  */
 786 int rfkill_set_default(enum rfkill_type type, enum rfkill_state state)
 787 {
 788         int error;
 789
 790         if (WARN((type >= RFKILL_TYPE_MAX ||
 791                         (state != RFKILL_STATE_SOFT_BLOCKED &&
 792                          state != RFKILL_STATE_UNBLOCKED)),
 793                         KERN_WARNING
 794                         "rfkill: illegal state %d or type %d passed as "
 795                         "parameter to rfkill_set_default\n", state, type))
 796                 return -EINVAL;
 797
 798         mutex_lock(&rfkill_global_mutex);
 799
 800         if (!test_and_set_bit(type, rfkill_states_lockdflt)) {
 801                 rfkill_global_states[type].default_state = state;
 802                 rfkill_global_states[type].current_state = state;
 803                 error = 0;
 804         } else
 805                 error = -EPERM;
 806
 807         mutex_unlock(&rfkill_global_mutex);
 808         return error;
 809 }
 810 EXPORT_SYMBOL_GPL(rfkill_set_default);
 811
 812 /*
 813  * Rfkill module initialization/deinitialization.
 814  */
 815 static int __init rfkill_init(void)
 816 {
 817         int error;
 818         int i;
 819
 820         /* RFKILL_STATE_HARD_BLOCKED is illegal here... */
 821         if (rfkill_default_state != RFKILL_STATE_SOFT_BLOCKED &&
 822             rfkill_default_state != RFKILL_STATE_UNBLOCKED)
 823                 return -EINVAL;
 824
 825         for (i = 0; i < RFKILL_TYPE_MAX; i++)
 826                 rfkill_global_states[i].default_state = rfkill_default_state;
 827
 828         error = class_register(&rfkill_class);
 829         if (error) {
 830                 printk(KERN_ERR "rfkill: unable to register rfkill class\n");
 831                 return error;
 832         }
 833
 834         return 0;
 835 }
 836
 837 static void __exit rfkill_exit(void)
 838 {
 839         class_unregister(&rfkill_class);
 840 }
 841
 842 subsys_initcall(rfkill_init);
 843 module_exit(rfkill_exit);