rfkill: export global states to rfkill-input
[linux-2.6.git] / net / rfkill / rfkill.c
index 5c24f36..fdf87d2 100644 (file)
@@ -37,14 +37,20 @@ MODULE_DESCRIPTION("RF switch support");
 MODULE_LICENSE("GPL");
 
 static LIST_HEAD(rfkill_list); /* list of registered rf switches */
-static DEFINE_MUTEX(rfkill_mutex);
+static DEFINE_MUTEX(rfkill_global_mutex);
 
 static unsigned int rfkill_default_state = RFKILL_STATE_UNBLOCKED;
 module_param_named(default_state, rfkill_default_state, uint, 0444);
 MODULE_PARM_DESC(default_state,
                 "Default initial state for all radio types, 0 = radio off");
 
-static enum rfkill_state rfkill_states[RFKILL_TYPE_MAX];
+struct rfkill_gsw_state {
+       enum rfkill_state current_state;
+       enum rfkill_state default_state;
+};
+
+static struct rfkill_gsw_state rfkill_global_states[RFKILL_TYPE_MAX];
+static unsigned long rfkill_states_lockdflt[BITS_TO_LONGS(RFKILL_TYPE_MAX)];
 
 static BLOCKING_NOTIFIER_HEAD(rfkill_notifier_list);
 
@@ -70,6 +76,7 @@ static BLOCKING_NOTIFIER_HEAD(rfkill_notifier_list);
  */
 int register_rfkill_notifier(struct notifier_block *nb)
 {
+       BUG_ON(!nb);
        return blocking_notifier_chain_register(&rfkill_notifier_list, nb);
 }
 EXPORT_SYMBOL_GPL(register_rfkill_notifier);
@@ -85,6 +92,7 @@ EXPORT_SYMBOL_GPL(register_rfkill_notifier);
  */
 int unregister_rfkill_notifier(struct notifier_block *nb)
 {
+       BUG_ON(!nb);
        return blocking_notifier_chain_unregister(&rfkill_notifier_list, nb);
 }
 EXPORT_SYMBOL_GPL(unregister_rfkill_notifier);
@@ -105,8 +113,19 @@ static void rfkill_led_trigger(struct rfkill *rfkill,
 #endif /* CONFIG_RFKILL_LEDS */
 }
 
+#ifdef CONFIG_RFKILL_LEDS
+static void rfkill_led_trigger_activate(struct led_classdev *led)
+{
+       struct rfkill *rfkill = container_of(led->trigger,
+                       struct rfkill, led_trigger);
+
+       rfkill_led_trigger(rfkill, rfkill->state);
+}
+#endif /* CONFIG_RFKILL_LEDS */
+
 static void notify_rfkill_state_change(struct rfkill *rfkill)
 {
+       rfkill_led_trigger(rfkill, rfkill->state);
        blocking_notifier_call_chain(&rfkill_notifier_list,
                        RFKILL_STATE_CHANGED,
                        rfkill);
@@ -140,6 +159,8 @@ static void update_rfkill_state(struct rfkill *rfkill)
  * calls and handling all the red tape such as issuing notifications
  * if the call is successful.
  *
+ * Suspended devices are not touched at all, and -EAGAIN is returned.
+ *
  * Note that the @force parameter cannot override a (possibly cached)
  * state of RFKILL_STATE_HARD_BLOCKED.  Any device making use of
  * RFKILL_STATE_HARD_BLOCKED implements either get_state() or
@@ -158,6 +179,9 @@ static int rfkill_toggle_radio(struct rfkill *rfkill,
        int retval = 0;
        enum rfkill_state oldstate, newstate;
 
+       if (unlikely(rfkill->dev.power.power_state.event & PM_EVENT_SLEEP))
+               return -EBUSY;
+
        oldstate = rfkill->state;
 
        if (rfkill->get_state && !force &&
@@ -180,6 +204,11 @@ static int rfkill_toggle_radio(struct rfkill *rfkill,
                 * BLOCK even a transmitter that is already in state
                 * RFKILL_STATE_HARD_BLOCKED */
                break;
+       default:
+               WARN(1, KERN_WARNING
+                       "rfkill: illegal state %d passed as parameter "
+                       "to rfkill_toggle_radio\n", state);
+               return -EINVAL;
        }
 
        if (force || state != rfkill->state) {
@@ -189,31 +218,36 @@ static int rfkill_toggle_radio(struct rfkill *rfkill,
                        rfkill->state = state;
        }
 
-       if (force || rfkill->state != oldstate) {
-               rfkill_led_trigger(rfkill, rfkill->state);
+       if (force || rfkill->state != oldstate)
                notify_rfkill_state_change(rfkill);
-       }
 
        return retval;
 }
 
 /**
- * rfkill_switch_all - Toggle state of all switches of given type
+ * __rfkill_switch_all - Toggle state of all switches of given type
  * @type: type of interfaces to be affected
  * @state: the new state
  *
  * This function toggles the state of all switches of given type,
  * unless a specific switch is claimed by userspace (in which case,
- * that switch is left alone).
+ * that switch is left alone) or suspended.
+ *
+ * Caller must have acquired rfkill_global_mutex.
  */
-void rfkill_switch_all(enum rfkill_type type, enum rfkill_state state)
+static void __rfkill_switch_all(const enum rfkill_type type,
+                               const enum rfkill_state state)
 {
        struct rfkill *rfkill;
 
-       mutex_lock(&rfkill_mutex);
-
-       rfkill_states[type] = state;
+       if (WARN((state >= RFKILL_STATE_MAX || type >= RFKILL_TYPE_MAX),
+                       KERN_WARNING
+                       "rfkill: illegal state %d or type %d "
+                       "passed as parameter to __rfkill_switch_all\n",
+                       state, type))
+               return;
 
+       rfkill_global_states[type].current_state = state;
        list_for_each_entry(rfkill, &rfkill_list, node) {
                if ((!rfkill->user_claim) && (rfkill->type == type)) {
                        mutex_lock(&rfkill->mutex);
@@ -221,32 +255,88 @@ void rfkill_switch_all(enum rfkill_type type, enum rfkill_state state)
                        mutex_unlock(&rfkill->mutex);
                }
        }
+}
 
-       mutex_unlock(&rfkill_mutex);
+/**
+ * rfkill_switch_all - Toggle state of all switches of given type
+ * @type: type of interfaces to be affected
+ * @state: the new state
+ *
+ * Acquires rfkill_global_mutex and calls __rfkill_switch_all(@type, @state).
+ * Please refer to __rfkill_switch_all() for details.
+ */
+void rfkill_switch_all(enum rfkill_type type, enum rfkill_state state)
+{
+       mutex_lock(&rfkill_global_mutex);
+       __rfkill_switch_all(type, state);
+       mutex_unlock(&rfkill_global_mutex);
 }
 EXPORT_SYMBOL(rfkill_switch_all);
 
 /**
  * rfkill_epo - emergency power off all transmitters
  *
- * This kicks all rfkill devices to RFKILL_STATE_SOFT_BLOCKED, ignoring
- * everything in its path but rfkill_mutex and rfkill->mutex.
+ * This kicks all non-suspended rfkill devices to RFKILL_STATE_SOFT_BLOCKED,
+ * ignoring everything in its path but rfkill_global_mutex and rfkill->mutex.
+ *
+ * The global state before the EPO is saved and can be restored later
+ * using rfkill_restore_states().
  */
 void rfkill_epo(void)
 {
        struct rfkill *rfkill;
+       int i;
+
+       mutex_lock(&rfkill_global_mutex);
 
-       mutex_lock(&rfkill_mutex);
        list_for_each_entry(rfkill, &rfkill_list, node) {
                mutex_lock(&rfkill->mutex);
                rfkill_toggle_radio(rfkill, RFKILL_STATE_SOFT_BLOCKED, 1);
                mutex_unlock(&rfkill->mutex);
        }
-       mutex_unlock(&rfkill_mutex);
+       for (i = 0; i < RFKILL_TYPE_MAX; i++) {
+               rfkill_global_states[i].default_state =
+                               rfkill_global_states[i].current_state;
+               rfkill_global_states[i].current_state =
+                               RFKILL_STATE_SOFT_BLOCKED;
+       }
+       mutex_unlock(&rfkill_global_mutex);
 }
 EXPORT_SYMBOL_GPL(rfkill_epo);
 
 /**
+ * rfkill_restore_states - restore global states
+ *
+ * Restore (and sync switches to) the global state from the
+ * states in rfkill_default_states.  This can undo the effects of
+ * a call to rfkill_epo().
+ */
+void rfkill_restore_states(void)
+{
+       int i;
+
+       mutex_lock(&rfkill_global_mutex);
+
+       for (i = 0; i < RFKILL_TYPE_MAX; i++)
+               __rfkill_switch_all(i, rfkill_global_states[i].default_state);
+       mutex_unlock(&rfkill_global_mutex);
+}
+EXPORT_SYMBOL_GPL(rfkill_restore_states);
+
+/**
+ * rfkill_get_global_state - returns global state for a type
+ * @type: the type to get the global state of
+ *
+ * Returns the current global state for a given wireless
+ * device type.
+ */
+enum rfkill_state rfkill_get_global_state(const enum rfkill_type type)
+{
+       return rfkill_global_states[type].current_state;
+}
+EXPORT_SYMBOL_GPL(rfkill_get_global_state);
+
+/**
  * rfkill_force_state - Force the internal rfkill radio state
  * @rfkill: pointer to the rfkill class to modify.
  * @state: the current radio state the class should be forced to.
@@ -267,9 +357,11 @@ int rfkill_force_state(struct rfkill *rfkill, enum rfkill_state state)
 {
        enum rfkill_state oldstate;
 
-       if (state != RFKILL_STATE_SOFT_BLOCKED &&
-           state != RFKILL_STATE_UNBLOCKED &&
-           state != RFKILL_STATE_HARD_BLOCKED)
+       BUG_ON(!rfkill);
+       if (WARN((state >= RFKILL_STATE_MAX),
+                       KERN_WARNING
+                       "rfkill: illegal state %d passed as parameter "
+                       "to rfkill_force_state\n", state))
                return -EINVAL;
 
        mutex_lock(&rfkill->mutex);
@@ -337,19 +429,24 @@ static ssize_t rfkill_state_store(struct device *dev,
                                  const char *buf, size_t count)
 {
        struct rfkill *rfkill = to_rfkill(dev);
-       unsigned int state = simple_strtoul(buf, NULL, 0);
+       unsigned long state;
        int error;
 
        if (!capable(CAP_NET_ADMIN))
                return -EPERM;
 
+       error = strict_strtoul(buf, 0, &state);
+       if (error)
+               return error;
+
        /* RFKILL_STATE_HARD_BLOCKED is illegal here... */
        if (state != RFKILL_STATE_UNBLOCKED &&
            state != RFKILL_STATE_SOFT_BLOCKED)
                return -EINVAL;
 
-       if (mutex_lock_interruptible(&rfkill->mutex))
-               return -ERESTARTSYS;
+       error = mutex_lock_killable(&rfkill->mutex);
+       if (error)
+               return error;
        error = rfkill_toggle_radio(rfkill, state, 0);
        mutex_unlock(&rfkill->mutex);
 
@@ -362,7 +459,7 @@ static ssize_t rfkill_claim_show(struct device *dev,
 {
        struct rfkill *rfkill = to_rfkill(dev);
 
-       return sprintf(buf, "%d", rfkill->user_claim);
+       return sprintf(buf, "%d\n", rfkill->user_claim);
 }
 
 static ssize_t rfkill_claim_store(struct device *dev,
@@ -370,7 +467,8 @@ static ssize_t rfkill_claim_store(struct device *dev,
                                  const char *buf, size_t count)
 {
        struct rfkill *rfkill = to_rfkill(dev);
-       bool claim = !!simple_strtoul(buf, NULL, 0);
+       unsigned long claim_tmp;
+       bool claim;
        int error;
 
        if (!capable(CAP_NET_ADMIN))
@@ -379,11 +477,16 @@ static ssize_t rfkill_claim_store(struct device *dev,
        if (rfkill->user_claim_unsupported)
                return -EOPNOTSUPP;
 
+       error = strict_strtoul(buf, 0, &claim_tmp);
+       if (error)
+               return error;
+       claim = !!claim_tmp;
+
        /*
         * Take the global lock to make sure the kernel is not in
         * the middle of rfkill_switch_all
         */
-       error = mutex_lock_interruptible(&rfkill_mutex);
+       error = mutex_lock_killable(&rfkill_global_mutex);
        if (error)
                return error;
 
@@ -391,14 +494,14 @@ static ssize_t rfkill_claim_store(struct device *dev,
                if (!claim) {
                        mutex_lock(&rfkill->mutex);
                        rfkill_toggle_radio(rfkill,
-                                           rfkill_states[rfkill->type],
-                                           0);
+                                       rfkill_global_states[rfkill->type].current_state,
+                                       0);
                        mutex_unlock(&rfkill->mutex);
                }
                rfkill->user_claim = claim;
        }
 
-       mutex_unlock(&rfkill_mutex);
+       mutex_unlock(&rfkill_global_mutex);
 
        return error ? error : count;
 }
@@ -422,21 +525,9 @@ static void rfkill_release(struct device *dev)
 #ifdef CONFIG_PM
 static int rfkill_suspend(struct device *dev, pm_message_t state)
 {
-       struct rfkill *rfkill = to_rfkill(dev);
-
-       if (dev->power.power_state.event != state.event) {
-               if (state.event & PM_EVENT_SLEEP) {
-                       /* Stop transmitter, keep state, no notifies */
-                       update_rfkill_state(rfkill);
-
-                       mutex_lock(&rfkill->mutex);
-                       rfkill->toggle_radio(rfkill->data,
-                                               RFKILL_STATE_SOFT_BLOCKED);
-                       mutex_unlock(&rfkill->mutex);
-               }
-
+       /* mark class device as suspended */
+       if (dev->power.power_state.event != state.event)
                dev->power.power_state = state;
-       }
 
        return 0;
 }
@@ -448,13 +539,14 @@ static int rfkill_resume(struct device *dev)
        if (dev->power.power_state.event != PM_EVENT_ON) {
                mutex_lock(&rfkill->mutex);
 
+               dev->power.power_state.event = PM_EVENT_ON;
+
                /* restore radio state AND notify everybody */
                rfkill_toggle_radio(rfkill, rfkill->state, 1);
 
                mutex_unlock(&rfkill->mutex);
        }
 
-       dev->power.power_state = PMSG_ON;
        return 0;
 }
 #else
@@ -509,24 +601,60 @@ static struct class rfkill_class = {
        .dev_uevent     = rfkill_dev_uevent,
 };
 
+static int rfkill_check_duplicity(const struct rfkill *rfkill)
+{
+       struct rfkill *p;
+       unsigned long seen[BITS_TO_LONGS(RFKILL_TYPE_MAX)];
+
+       memset(seen, 0, sizeof(seen));
+
+       list_for_each_entry(p, &rfkill_list, node) {
+               if (WARN((p == rfkill), KERN_WARNING
+                               "rfkill: illegal attempt to register "
+                               "an already registered rfkill struct\n"))
+                       return -EEXIST;
+               set_bit(p->type, seen);
+       }
+
+       /* 0: first switch of its kind */
+       return test_bit(rfkill->type, seen);
+}
+
 static int rfkill_add_switch(struct rfkill *rfkill)
 {
-       mutex_lock(&rfkill_mutex);
+       int error;
+
+       mutex_lock(&rfkill_global_mutex);
+
+       error = rfkill_check_duplicity(rfkill);
+       if (error < 0)
+               goto unlock_out;
 
-       rfkill_toggle_radio(rfkill, rfkill_states[rfkill->type], 0);
+       if (!error) {
+               /* lock default after first use */
+               set_bit(rfkill->type, rfkill_states_lockdflt);
+               rfkill_global_states[rfkill->type].current_state =
+                       rfkill_global_states[rfkill->type].default_state;
+       }
+
+       rfkill_toggle_radio(rfkill,
+                           rfkill_global_states[rfkill->type].current_state,
+                           0);
 
        list_add_tail(&rfkill->node, &rfkill_list);
 
-       mutex_unlock(&rfkill_mutex);
+       error = 0;
+unlock_out:
+       mutex_unlock(&rfkill_global_mutex);
 
-       return 0;
+       return error;
 }
 
 static void rfkill_remove_switch(struct rfkill *rfkill)
 {
-       mutex_lock(&rfkill_mutex);
+       mutex_lock(&rfkill_global_mutex);
        list_del_init(&rfkill->node);
-       mutex_unlock(&rfkill_mutex);
+       mutex_unlock(&rfkill_global_mutex);
 
        mutex_lock(&rfkill->mutex);
        rfkill_toggle_radio(rfkill, RFKILL_STATE_SOFT_BLOCKED, 1);
@@ -546,11 +674,18 @@ static void rfkill_remove_switch(struct rfkill *rfkill)
  * NOTE: If registration fails the structure shoudl be freed by calling
  * rfkill_free() otherwise rfkill_unregister() should be used.
  */
-struct rfkill *rfkill_allocate(struct device *parent, enum rfkill_type type)
+struct rfkill * __must_check rfkill_allocate(struct device *parent,
+                                            enum rfkill_type type)
 {
        struct rfkill *rfkill;
        struct device *dev;
 
+       if (WARN((type >= RFKILL_TYPE_MAX),
+                       KERN_WARNING
+                       "rfkill: illegal type %d passed as parameter "
+                       "to rfkill_allocate\n", type))
+               return NULL;
+
        rfkill = kzalloc(sizeof(struct rfkill), GFP_KERNEL);
        if (!rfkill)
                return NULL;
@@ -591,6 +726,8 @@ static void rfkill_led_trigger_register(struct rfkill *rfkill)
 
        if (!rfkill->led_trigger.name)
                rfkill->led_trigger.name = rfkill->dev.bus_id;
+       if (!rfkill->led_trigger.activate)
+               rfkill->led_trigger.activate = rfkill_led_trigger_activate;
        error = led_trigger_register(&rfkill->led_trigger);
        if (error)
                rfkill->led_trigger.name = NULL;
@@ -615,15 +752,18 @@ static void rfkill_led_trigger_unregister(struct rfkill *rfkill)
  * structure needs to be registered. Immediately from registration the
  * switch driver should be able to service calls to toggle_radio.
  */
-int rfkill_register(struct rfkill *rfkill)
+int __must_check rfkill_register(struct rfkill *rfkill)
 {
        static atomic_t rfkill_no = ATOMIC_INIT(0);
        struct device *dev = &rfkill->dev;
        int error;
 
-       if (!rfkill->toggle_radio)
-               return -EINVAL;
-       if (rfkill->type >= RFKILL_TYPE_MAX)
+       if (WARN((!rfkill || !rfkill->toggle_radio ||
+                       rfkill->type >= RFKILL_TYPE_MAX ||
+                       rfkill->state >= RFKILL_STATE_MAX),
+                       KERN_WARNING
+                       "rfkill: attempt to register a "
+                       "badly initialized rfkill struct\n"))
                return -EINVAL;
 
        snprintf(dev->bus_id, sizeof(dev->bus_id),
@@ -658,6 +798,7 @@ EXPORT_SYMBOL(rfkill_register);
  */
 void rfkill_unregister(struct rfkill *rfkill)
 {
+       BUG_ON(!rfkill);
        device_del(&rfkill->dev);
        rfkill_remove_switch(rfkill);
        rfkill_led_trigger_unregister(rfkill);
@@ -665,6 +806,57 @@ void rfkill_unregister(struct rfkill *rfkill)
 }
 EXPORT_SYMBOL(rfkill_unregister);
 
+/**
+ * rfkill_set_default - set initial value for a switch type
+ * @type - the type of switch to set the default state of
+ * @state - the new default state for that group of switches
+ *
+ * Sets the initial state rfkill should use for a given type.
+ * The following initial states are allowed: RFKILL_STATE_SOFT_BLOCKED
+ * and RFKILL_STATE_UNBLOCKED.
+ *
+ * This function is meant to be used by platform drivers for platforms
+ * that can save switch state across power down/reboot.
+ *
+ * The default state for each switch type can be changed exactly once.
+ * After a switch of that type is registered, the default state cannot
+ * be changed anymore.  This guards against multiple drivers it the
+ * same platform trying to set the initial switch default state, which
+ * is not allowed.
+ *
+ * Returns -EPERM if the state has already been set once or is in use,
+ * so drivers likely want to either ignore or at most printk(KERN_NOTICE)
+ * if this function returns -EPERM.
+ *
+ * Returns 0 if the new default state was set, or an error if it
+ * could not be set.
+ */
+int rfkill_set_default(enum rfkill_type type, enum rfkill_state state)
+{
+       int error;
+
+       if (WARN((type >= RFKILL_TYPE_MAX ||
+                       (state != RFKILL_STATE_SOFT_BLOCKED &&
+                        state != RFKILL_STATE_UNBLOCKED)),
+                       KERN_WARNING
+                       "rfkill: illegal state %d or type %d passed as "
+                       "parameter to rfkill_set_default\n", state, type))
+               return -EINVAL;
+
+       mutex_lock(&rfkill_global_mutex);
+
+       if (!test_and_set_bit(type, rfkill_states_lockdflt)) {
+               rfkill_global_states[type].default_state = state;
+               rfkill_global_states[type].current_state = state;
+               error = 0;
+       } else
+               error = -EPERM;
+
+       mutex_unlock(&rfkill_global_mutex);
+       return error;
+}
+EXPORT_SYMBOL_GPL(rfkill_set_default);
+
 /*
  * Rfkill module initialization/deinitialization.
  */
@@ -678,8 +870,8 @@ static int __init rfkill_init(void)
            rfkill_default_state != RFKILL_STATE_UNBLOCKED)
                return -EINVAL;
 
-       for (i = 0; i < ARRAY_SIZE(rfkill_states); i++)
-               rfkill_states[i] = rfkill_default_state;
+       for (i = 0; i < RFKILL_TYPE_MAX; i++)
+               rfkill_global_states[i].default_state = rfkill_default_state;
 
        error = class_register(&rfkill_class);
        if (error) {