linux/net/rfkill/core.c
<<
>>
Prefs
   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
  51struct 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
  81struct rfkill_int_event {
  82        struct list_head        list;
  83        struct rfkill_event     ev;
  84};
  85
  86struct 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
  95MODULE_AUTHOR("Ivo van Doorn <IvDoorn@gmail.com>");
  96MODULE_AUTHOR("Johannes Berg <johannes@sipsolutions.net>");
  97MODULE_DESCRIPTION("RF switch support");
  98MODULE_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 */
 112static LIST_HEAD(rfkill_list);  /* list of registered rf switches */
 113static DEFINE_MUTEX(rfkill_global_mutex);
 114static LIST_HEAD(rfkill_fds);   /* list of open fds of /dev/rfkill */
 115
 116static unsigned int rfkill_default_state = 1;
 117module_param_named(default_state, rfkill_default_state, uint, 0444);
 118MODULE_PARM_DESC(default_state,
 119                 "Default initial state for all radio types, 0 = radio off");
 120
 121static struct {
 122        bool cur, sav;
 123} rfkill_global_states[NUM_RFKILL_TYPES];
 124
 125static bool rfkill_epo_lock_active;
 126
 127
 128#ifdef CONFIG_RFKILL_LEDS
 129static 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
 144static 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
 153static 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
 161static void rfkill_led_trigger_unregister(struct rfkill *rfkill)
 162{
 163        led_trigger_unregister(&rfkill->led_trigger);
 164}
 165#else
 166static void rfkill_led_trigger_event(struct rfkill *rfkill)
 167{
 168}
 169
 170static inline int rfkill_led_trigger_register(struct rfkill *rfkill)
 171{
 172        return 0;
 173}
 174
 175static inline void rfkill_led_trigger_unregister(struct rfkill *rfkill)
 176{
 177}
 178#endif /* CONFIG_RFKILL_LEDS */
 179
 180static 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
 196static 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
 213static 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
 224static 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 */
 256static 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
 309static 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 */
 322static 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 */
 345void 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 */
 367void 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 */
 396void 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 */
 417void 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 */
 436bool 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 */
 448bool rfkill_get_global_sw_state(const enum rfkill_type type)
 449{
 450        return rfkill_global_states[type].cur;
 451}
 452#endif
 453
 454
 455bool 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}
 469EXPORT_SYMBOL(rfkill_set_hw_state);
 470
 471static 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
 485bool 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}
 509EXPORT_SYMBOL(rfkill_set_sw_state);
 510
 511void 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}
 523EXPORT_SYMBOL(rfkill_init_sw_state);
 524
 525void 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}
 557EXPORT_SYMBOL(rfkill_set_states);
 558
 559static 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
 568static 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
 592static 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
 601static 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
 610static 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
 619static 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
 628static 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
 637static 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
 662static 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
 672static 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
 681static 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
 707static 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
 714static 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
 721static 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
 733static void rfkill_release(struct device *dev)
 734{
 735        struct rfkill *rfkill = to_rfkill(dev);
 736
 737        kfree(rfkill);
 738}
 739
 740static 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
 762void 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}
 771EXPORT_SYMBOL(rfkill_pause_polling);
 772
 773void 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}
 782EXPORT_SYMBOL(rfkill_resume_polling);
 783
 784static 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
 793static 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
 808static 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
 817bool 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}
 828EXPORT_SYMBOL(rfkill_blocked);
 829
 830
 831struct 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}
 870EXPORT_SYMBOL(rfkill_alloc);
 871
 872static 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
 889static 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
 900static 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
 913int __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}
 976EXPORT_SYMBOL(rfkill_register);
 977
 978void 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}
 999EXPORT_SYMBOL(rfkill_unregister);
1000
1001void rfkill_destroy(struct rfkill *rfkill)
1002{
1003        if (rfkill)
1004                put_device(&rfkill->dev);
1005}
1006EXPORT_SYMBOL(rfkill_destroy);
1007
1008static 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
1054static 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
1069static 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
1080static 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
1119static 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
1170static 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
1195static 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
1220static 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
1234static struct miscdevice rfkill_miscdev = {
1235        .name   = "rfkill",
1236        .fops   = &rfkill_fops,
1237        .minor  = MISC_DYNAMIC_MINOR,
1238};
1239
1240static 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}
1270subsys_initcall(rfkill_init);
1271
1272static 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}
1280module_exit(rfkill_exit);
1281
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.