linux/include/linux/rfkill.h
<<
>>
Prefs
   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 */
  42enum 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 */
  61enum 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 */
  79struct 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 */
 108enum 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
 123struct device;
 124/* this is opaque */
 125struct 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 */
 145struct 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 */
 163struct 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 */
 184int __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 */
 193void 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 */
 202void 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 */
 213void 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 */
 221void 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 */
 242bool 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 */
 264bool 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 */
 280void 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 */
 291void 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 */
 298bool rfkill_blocked(struct rfkill *rfkill);
 299#else /* !RFKILL */
 300static inline struct rfkill * __must_check
 301rfkill_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
 310static inline int __must_check rfkill_register(struct rfkill *rfkill)
 311{
 312        if (rfkill == ERR_PTR(-ENODEV))
 313                return 0;
 314        return -EINVAL;
 315}
 316
 317static inline void rfkill_pause_polling(struct rfkill *rfkill)
 318{
 319}
 320
 321static inline void rfkill_resume_polling(struct rfkill *rfkill)
 322{
 323}
 324
 325static inline void rfkill_unregister(struct rfkill *rfkill)
 326{
 327}
 328
 329static inline void rfkill_destroy(struct rfkill *rfkill)
 330{
 331}
 332
 333static inline bool rfkill_set_hw_state(struct rfkill *rfkill, bool blocked)
 334{
 335        return blocked;
 336}
 337
 338static inline bool rfkill_set_sw_state(struct rfkill *rfkill, bool blocked)
 339{
 340        return blocked;
 341}
 342
 343static inline void rfkill_init_sw_state(struct rfkill *rfkill, bool blocked)
 344{
 345}
 346
 347static inline void rfkill_set_states(struct rfkill *rfkill, bool sw, bool hw)
 348{
 349}
 350
 351static 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 */
 360
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.