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 <[email protected]> 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/device.h> 121 #include <linux/leds.h> 122 #include <linux/err.h> 123 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 */ 360