include/linux/rfkill.h

   1 #ifndef __RFKILL_H
   2 #define __RFKILL_H
   3
   4 /*
   5  * Copyright (C) 2006 - 2007 Ivo van Doorn
   6  * Copyright (C) 2007 Dmitry Torokhov
   7  * Copyright 2009 Johannes Berg <johannes@sipsolutions.net>
   8  *
   9  * Permission to use, copy, modify, and/or distribute this software for any
  10  * purpose with or without fee is hereby granted, provided that the above
  11  * copyright notice and this permission notice appear in all copies.
  12  *
  13  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  14  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  15  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  16  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  17  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  18  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  19  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  20  */
  21
  22 #include <linux/types.h>
  23
  24 /* define userspace visible states */
  25 #define RFKILL_STATE_SOFT_BLOCKED       0
  26 #define RFKILL_STATE_UNBLOCKED          1
  27 #define RFKILL_STATE_HARD_BLOCKED       2
  28
  29 /**
  30  * enum rfkill_type - type of rfkill switch.
  31  *
  32  * @RFKILL_TYPE_ALL: toggles all switches (requests only - not a switch type)
  33  * @RFKILL_TYPE_WLAN: switch is on a 802.11 wireless network device.
  34  * @RFKILL_TYPE_BLUETOOTH: switch is on a bluetooth device.
  35  * @RFKILL_TYPE_UWB: switch is on a ultra wideband device.
  36  * @RFKILL_TYPE_WIMAX: switch is on a WiMAX device.
  37  * @RFKILL_TYPE_WWAN: switch is on a wireless WAN device.
  38  * @RFKILL_TYPE_GPS: switch is on a GPS device.
  39  * @RFKILL_TYPE_FM: switch is on a FM radio device.
  40  * @NUM_RFKILL_TYPES: number of defined rfkill types
  41  */
  42 enum rfkill_type {
  43         RFKILL_TYPE_ALL = 0,
  44         RFKILL_TYPE_WLAN,
  45         RFKILL_TYPE_BLUETOOTH,
  46         RFKILL_TYPE_UWB,
  47         RFKILL_TYPE_WIMAX,
  48         RFKILL_TYPE_WWAN,
  49         RFKILL_TYPE_GPS,
  50         RFKILL_TYPE_FM,
  51         NUM_RFKILL_TYPES,
  52 };
  53
  54 /**
  55  * enum rfkill_operation - operation types
  56  * @RFKILL_OP_ADD: a device was added
  57  * @RFKILL_OP_DEL: a device was removed
  58  * @RFKILL_OP_CHANGE: a device's state changed -- userspace changes one device
  59  * @RFKILL_OP_CHANGE_ALL: userspace changes all devices (of a type, or all)
  60  */
  61 enum rfkill_operation {
  62         RFKILL_OP_ADD = 0,
  63         RFKILL_OP_DEL,
  64         RFKILL_OP_CHANGE,
  65         RFKILL_OP_CHANGE_ALL,
  66 };
  67
  68 /**
  69  * struct rfkill_event - events for userspace on /dev/rfkill
  70  * @idx: index of dev rfkill
  71  * @type: type of the rfkill struct
  72  * @op: operation code
  73  * @hard: hard state (0/1)
  74  * @soft: soft state (0/1)
  75  *
  76  * Structure used for userspace communication on /dev/rfkill,
  77  * used for events from the kernel and control to the kernel.
  78  */
  79 struct rfkill_event {
  80         __u32 idx;
  81         __u8  type;
  82         __u8  op;
  83         __u8  soft, hard;
  84 } __attribute__((packed));
  85
  86 /*
  87  * We are planning to be backward and forward compatible with changes
  88  * to the event struct, by adding new, optional, members at the end.
  89  * When reading an event (whether the kernel from userspace or vice
  90  * versa) we need to accept anything that's at least as large as the
  91  * version 1 event size, but might be able to accept other sizes in
  92  * the future.
  93  *
  94  * One exception is the kernel -- we already have two event sizes in
  95  * that we've made the 'hard' member optional since our only option
  96  * is to ignore it anyway.
  97  */
  98 #define RFKILL_EVENT_SIZE_V1    8
  99
 100 /* ioctl for turning off rfkill-input (if present) */
 101 #define RFKILL_IOC_MAGIC        'R'
 102 #define RFKILL_IOC_NOINPUT      1
 103 #define RFKILL_IOCTL_NOINPUT    _IO(RFKILL_IOC_MAGIC, RFKILL_IOC_NOINPUT)
 104
 105 /* and that's all userspace gets */
 106 #ifdef __KERNEL__
 107 /* don't allow anyone to use these in the kernel */
 108 enum rfkill_user_states {
 109         RFKILL_USER_STATE_SOFT_BLOCKED  = RFKILL_STATE_SOFT_BLOCKED,
 110         RFKILL_USER_STATE_UNBLOCKED     = RFKILL_STATE_UNBLOCKED,
 111         RFKILL_USER_STATE_HARD_BLOCKED  = RFKILL_STATE_HARD_BLOCKED,
 112 };
 113 #undef RFKILL_STATE_SOFT_BLOCKED
 114 #undef RFKILL_STATE_UNBLOCKED
 115 #undef RFKILL_STATE_HARD_BLOCKED
 116
 117 #include <linux/kernel.h>
 118 #include <linux/list.h>
 119 #include <linux/mutex.h>
 120 #include <linux/leds.h>
 121 #include <linux/err.h>
 122
 123 struct device;
 124 /* this is opaque */
 125 struct rfkill;
 126
 127 /**
 128  * struct rfkill_ops - rfkill driver methods
 129  *
 130  * @poll: poll the rfkill block state(s) -- only assign this method
 131  *      when you need polling. When called, simply call one of the
 132  *      rfkill_set{,_hw,_sw}_state family of functions. If the hw
 133  *      is getting unblocked you need to take into account the return
 134  *      value of those functions to make sure the software block is
 135  *      properly used.
 136  * @query: query the rfkill block state(s) and call exactly one of the
 137  *      rfkill_set{,_hw,_sw}_state family of functions. Assign this
 138  *      method if input events can cause hardware state changes to make
 139  *      the rfkill core query your driver before setting a requested
 140  *      block.
 141  * @set_block: turn the transmitter on (blocked == false) or off
 142  *      (blocked == true) -- ignore and return 0 when hard blocked.
 143  *      This callback must be assigned.
 144  */
 145 struct rfkill_ops {
 146         void    (*poll)(struct rfkill *rfkill, void *data);
 147         void    (*query)(struct rfkill *rfkill, void *data);
 148         int     (*set_block)(void *data, bool blocked);
 149 };
 150
 151 #if defined(CONFIG_RFKILL) || defined(CONFIG_RFKILL_MODULE)
 152 /**
 153  * rfkill_alloc - allocate rfkill structure
 154  * @name: name of the struct -- the string is not copied internally
 155  * @parent: device that has rf switch on it
 156  * @type: type of the switch (RFKILL_TYPE_*)
 157  * @ops: rfkill methods
 158  * @ops_data: data passed to each method
 159  *
 160  * This function should be called by the transmitter driver to allocate an
 161  * rfkill structure. Returns %NULL on failure.
 162  */
 163 struct rfkill * __must_check rfkill_alloc(const char *name,
 164                                           struct device *parent,
 165                                           const enum rfkill_type type,
 166                                           const struct rfkill_ops *ops,
 167                                           void *ops_data);
 168
 169 /**
 170  * rfkill_register - Register a rfkill structure.
 171  * @rfkill: rfkill structure to be registered
 172  *
 173  * This function should be called by the transmitter driver to register
 174  * the rfkill structure. Before calling this function the driver needs
 175  * to be ready to service method calls from rfkill.
 176  *
 177  * If rfkill_init_sw_state() is not called before registration,
 178  * set_block() will be called to initialize the software blocked state
 179  * to a default value.
 180  *
 181  * If the hardware blocked state is not set before registration,
 182  * it is assumed to be unblocked.
 183  */
 184 int __must_check rfkill_register(struct rfkill *rfkill);
 185
 186 /**
 187  * rfkill_pause_polling(struct rfkill *rfkill)
 188  *
 189  * Pause polling -- say transmitter is off for other reasons.
 190  * NOTE: not necessary for suspend/resume -- in that case the
 191  * core stops polling anyway
 192  */
 193 void rfkill_pause_polling(struct rfkill *rfkill);
 194
 195 /**
 196  * rfkill_resume_polling(struct rfkill *rfkill)
 197  *
 198  * Pause polling -- say transmitter is off for other reasons.
 199  * NOTE: not necessary for suspend/resume -- in that case the
 200  * core stops polling anyway
 201  */
 202 void rfkill_resume_polling(struct rfkill *rfkill);
 203
 204
 205 /**
 206  * rfkill_unregister - Unregister a rfkill structure.
 207  * @rfkill: rfkill structure to be unregistered
 208  *
 209  * This function should be called by the network driver during device
 210  * teardown to destroy rfkill structure. Until it returns, the driver
 211  * needs to be able to service method calls.
 212  */
 213 void rfkill_unregister(struct rfkill *rfkill);
 214
 215 /**
 216  * rfkill_destroy - free rfkill structure
 217  * @rfkill: rfkill structure to be destroyed
 218  *
 219  * Destroys the rfkill structure.
 220  */
 221 void rfkill_destroy(struct rfkill *rfkill);
 222
 223 /**
 224  * rfkill_set_hw_state - Set the internal rfkill hardware block state
 225  * @rfkill: pointer to the rfkill class to modify.
 226  * @state: the current hardware block state to set
 227  *
 228  * rfkill drivers that get events when the hard-blocked state changes
 229  * use this function to notify the rfkill core (and through that also
 230  * userspace) of the current state.  They should also use this after
 231  * resume if the state could have changed.
 232  *
 233  * You need not (but may) call this function if poll_state is assigned.
 234  *
 235  * This function can be called in any context, even from within rfkill
 236  * callbacks.
 237  *
 238  * The function returns the combined block state (true if transmitter
 239  * should be blocked) so that drivers need not keep track of the soft
 240  * block state -- which they might not be able to.
 241  */
 242 bool rfkill_set_hw_state(struct rfkill *rfkill, bool blocked);
 243
 244 /**
 245  * rfkill_set_sw_state - Set the internal rfkill software block state
 246  * @rfkill: pointer to the rfkill class to modify.
 247  * @state: the current software block state to set
 248  *
 249  * rfkill drivers that get events when the soft-blocked state changes
 250  * (yes, some platforms directly act on input but allow changing again)
 251  * use this function to notify the rfkill core (and through that also
 252  * userspace) of the current state.
 253  *
 254  * Drivers should also call this function after resume if the state has
 255  * been changed by the user.  This only makes sense for "persistent"
 256  * devices (see rfkill_init_sw_state()).
 257  *
 258  * This function can be called in any context, even from within rfkill
 259  * callbacks.
 260  *
 261  * The function returns the combined block state (true if transmitter
 262  * should be blocked).
 263  */
 264 bool rfkill_set_sw_state(struct rfkill *rfkill, bool blocked);
 265
 266 /**
 267  * rfkill_init_sw_state - Initialize persistent software block state
 268  * @rfkill: pointer to the rfkill class to modify.
 269  * @state: the current software block state to set
 270  *
 271  * rfkill drivers that preserve their software block state over power off
 272  * use this function to notify the rfkill core (and through that also
 273  * userspace) of their initial state.  It should only be used before
 274  * registration.
 275  *
 276  * In addition, it marks the device as "persistent", an attribute which
 277  * can be read by userspace.  Persistent devices are expected to preserve
 278  * their own state when suspended.
 279  */
 280 void rfkill_init_sw_state(struct rfkill *rfkill, bool blocked);
 281
 282 /**
 283  * rfkill_set_states - Set the internal rfkill block states
 284  * @rfkill: pointer to the rfkill class to modify.
 285  * @sw: the current software block state to set
 286  * @hw: the current hardware block state to set
 287  *
 288  * This function can be called in any context, even from within rfkill
 289  * callbacks.
 290  */
 291 void rfkill_set_states(struct rfkill *rfkill, bool sw, bool hw);
 292
 293 /**
 294  * rfkill_blocked - query rfkill block
 295  *
 296  * @rfkill: rfkill struct to query
 297  */
 298 bool rfkill_blocked(struct rfkill *rfkill);
 299 #else /* !RFKILL */
 300 static inline struct rfkill * __must_check
 301 rfkill_alloc(const char *name,
 302              struct device *parent,
 303              const enum rfkill_type type,
 304              const struct rfkill_ops *ops,
 305              void *ops_data)
 306 {
 307         return ERR_PTR(-ENODEV);
 308 }
 309
 310 static inline int __must_check rfkill_register(struct rfkill *rfkill)
 311 {
 312         if (rfkill == ERR_PTR(-ENODEV))
 313                 return 0;
 314         return -EINVAL;
 315 }
 316
 317 static inline void rfkill_pause_polling(struct rfkill *rfkill)
 318 {
 319 }
 320
 321 static inline void rfkill_resume_polling(struct rfkill *rfkill)
 322 {
 323 }
 324
 325 static inline void rfkill_unregister(struct rfkill *rfkill)
 326 {
 327 }
 328
 329 static inline void rfkill_destroy(struct rfkill *rfkill)
 330 {
 331 }
 332
 333 static inline bool rfkill_set_hw_state(struct rfkill *rfkill, bool blocked)
 334 {
 335         return blocked;
 336 }
 337
 338 static inline bool rfkill_set_sw_state(struct rfkill *rfkill, bool blocked)
 339 {
 340         return blocked;
 341 }
 342
 343 static inline void rfkill_init_sw_state(struct rfkill *rfkill, bool blocked)
 344 {
 345 }
 346
 347 static inline void rfkill_set_states(struct rfkill *rfkill, bool sw, bool hw)
 348 {
 349 }
 350
 351 static inline bool rfkill_blocked(struct rfkill *rfkill)
 352 {
 353         return false;
 354 }
 355 #endif /* RFKILL || RFKILL_MODULE */
 356
 357 #endif /* __KERNEL__ */
 358
 359 #endif /* RFKILL_H */