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 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the 20 * Free Software Foundation, Inc., 21 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 22 */ 23 24 #include <linux/types.h> 25 #include <linux/kernel.h> 26 #include <linux/list.h> 27 #include <linux/mutex.h> 28 #include <linux/device.h> 29 #include <linux/leds.h> 30 31 /** 32 * enum rfkill_type - type of rfkill switch. 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 */ 39 enum rfkill_type { 40 RFKILL_TYPE_WLAN , 41 RFKILL_TYPE_BLUETOOTH, 42 RFKILL_TYPE_UWB, 43 RFKILL_TYPE_WIMAX, 44 RFKILL_TYPE_WWAN, 45 RFKILL_TYPE_MAX, 46 }; 47 48 enum rfkill_state { 49 RFKILL_STATE_SOFT_BLOCKED = 0, /* Radio output blocked */ 50 RFKILL_STATE_UNBLOCKED = 1, /* Radio output allowed */ 51 RFKILL_STATE_HARD_BLOCKED = 2, /* Output blocked, non-overrideable */ 52 }; 53 54 /* 55 * These are DEPRECATED, drivers using them should be verified to 56 * comply with the rfkill usage guidelines in Documentation/rfkill.txt 57 * and then converted to use the new names for rfkill_state 58 */ 59 #define RFKILL_STATE_OFF RFKILL_STATE_SOFT_BLOCKED 60 #define RFKILL_STATE_ON RFKILL_STATE_UNBLOCKED 61 62 /** 63 * struct rfkill - rfkill control structure. 64 * @name: Name of the switch. 65 * @type: Radio type which the button controls, the value stored 66 * here should be a value from enum rfkill_type. 67 * @state: State of the switch, "UNBLOCKED" means radio can operate. 68 * @user_claim_unsupported: Whether the hardware supports exclusive 69 * RF-kill control by userspace. Set this before registering. 70 * @user_claim: Set when the switch is controlled exlusively by userspace. 71 * @mutex: Guards switch state transitions 72 * @data: Pointer to the RF button drivers private data which will be 73 * passed along when toggling radio state. 74 * @toggle_radio(): Mandatory handler to control state of the radio. 75 * only RFKILL_STATE_SOFT_BLOCKED and RFKILL_STATE_UNBLOCKED are 76 * valid parameters. 77 * @get_state(): handler to read current radio state from hardware, 78 * may be called from atomic context, should return 0 on success. 79 * Either this handler OR judicious use of rfkill_force_state() is 80 * MANDATORY for any driver capable of RFKILL_STATE_HARD_BLOCKED. 81 * @led_trigger: A LED trigger for this button's LED. 82 * @dev: Device structure integrating the switch into device tree. 83 * @node: Used to place switch into list of all switches known to the 84 * the system. 85 * 86 * This structure represents a RF switch located on a network device. 87 */ 88 struct rfkill { 89 const char *name; 90 enum rfkill_type type; 91 92 enum rfkill_state state; 93 bool user_claim_unsupported; 94 bool user_claim; 95 96 struct mutex mutex; 97 98 void *data; 99 int (*toggle_radio)(void *data, enum rfkill_state state); 100 int (*get_state)(void *data, enum rfkill_state *state); 101 102 #ifdef CONFIG_RFKILL_LEDS 103 struct led_trigger led_trigger; 104 #endif 105 106 struct device dev; 107 struct list_head node; 108 }; 109 #define to_rfkill(d) container_of(d, struct rfkill, dev) 110 111 struct rfkill *rfkill_allocate(struct device *parent, enum rfkill_type type); 112 void rfkill_free(struct rfkill *rfkill); 113 int rfkill_register(struct rfkill *rfkill); 114 void rfkill_unregister(struct rfkill *rfkill); 115 116 int rfkill_force_state(struct rfkill *rfkill, enum rfkill_state state); 117 118 /** 119 * rfkill_state_complement - return complementar state 120 * @state: state to return the complement of 121 * 122 * Returns RFKILL_STATE_SOFT_BLOCKED if @state is RFKILL_STATE_UNBLOCKED, 123 * returns RFKILL_STATE_UNBLOCKED otherwise. 124 */ 125 static inline enum rfkill_state rfkill_state_complement(enum rfkill_state state) 126 { 127 return (state == RFKILL_STATE_UNBLOCKED) ? 128 RFKILL_STATE_SOFT_BLOCKED : RFKILL_STATE_UNBLOCKED; 129 } 130 131 /** 132 * rfkill_get_led_name - Get the LED trigger name for the button's LED. 133 * This function might return a NULL pointer if registering of the 134 * LED trigger failed. 135 * Use this as "default_trigger" for the LED. 136 */ 137 static inline char *rfkill_get_led_name(struct rfkill *rfkill) 138 { 139 #ifdef CONFIG_RFKILL_LEDS 140 return (char *)(rfkill->led_trigger.name); 141 #else 142 return NULL; 143 #endif 144 } 145 146 /* rfkill notification chain */ 147 #define RFKILL_STATE_CHANGED 0x0001 /* state of a normal rfkill 148 switch has changed */ 149 150 int register_rfkill_notifier(struct notifier_block *nb); 151 int unregister_rfkill_notifier(struct notifier_block *nb); 152 153 #endif /* RFKILL_H */ 154