LCOV - code coverage report
Current view: top level - net/rfkill - core.c (source / functions) Hit Total Coverage
Test: Real Lines: 64 447 14.3 %
Date: 2020-10-17 15:46:16 Functions: 0 53 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

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

Generated by: LCOV version 1.14