rfkill: remove set_global_sw_state

rfkill_set_global_sw_state() (previously rfkill_set_default()) will no longer be exported by the rewritten rfkill core. Instead, platform drivers which can provide persistent soft-rfkill state across power-down/reboot should indicate their initial state by calling rfkill_set_sw_state() before registration. Otherwise, they will be initialized to a default value during registration by a set_block call. We remove existing calls to rfkill_set_sw_state() which happen before registration, since these had no effect in the old model. If these drivers do have persistent state, the calls can be put back (subject to testing :-). This affects hp-wmi and acer-wmi. Drivers with persistent state will affect the global state only if rfkill-input is enabled. This is required, otherwise booting with wireless soft-blocked and pressing the wireless-toggle key once would have no apparent effect. This special case will be removed in future along with rfkill-input, in favour of a more flexible userspace daemon (see Documentation/feature-removal-schedule.txt). Now rfkill_global_states[n].def is only used to preserve global states over EPO, it is renamed to ".sav". Signed-off-by: Alan Jenkins <alan-jenkins@tuffmail.co.uk> Acked-by: Henrique de Moraes Holschuh <hmh@hmh.eng.br> Signed-off-by: John W. Linville <linville@tuxdriver.com>

rfkill: remove set_global_sw_state
rfkill_set_global_sw_state() (previously rfkill_set_default()) will no longer be exported by the rewritten rfkill core. Instead, platform drivers which can provide persistent soft-rfkill state across power-down/reboot should indicate their initial state by calling rfkill_set_sw_state() before registration. Otherwise, they will be initialized to a default value during registration by a set_block call. We remove existing calls to rfkill_set_sw_state() which happen before registration, since these had no effect in the old model. If these drivers do have persistent state, the calls can be put back (subject to testing :-). This affects hp-wmi and acer-wmi. Drivers with persistent state will affect the global state only if rfkill-input is enabled. This is required, otherwise booting with wireless soft-blocked and pressing the wireless-toggle key once would have no apparent effect. This special case will be removed in future along with rfkill-input, in favour of a more flexible userspace daemon (see Documentation/feature-removal-schedule.txt). Now rfkill_global_states[n].def is only used to preserve global states over EPO, it is renamed to ".sav". Signed-off-by: Alan Jenkins <alan-jenkins@tuffmail.co.uk> Acked-by: Henrique de Moraes Holschuh <hmh@hmh.eng.br> Signed-off-by: John W. Linville <linville@tuxdriver.com>
Alan Jenkins · John W. Linville
1 parent 8f77f3849c
Showing 6 changed files with 56 additions and 99 deletions Side-by-side Diff
drivers/platform/x86/acer-wmi.c
drivers/platform/x86/eeepc-laptop.c
drivers/platform/x86/hp-wmi.c
drivers/platform/x86/thinkpad_acpi.c
include/linux/rfkill.h
net/rfkill/core.c
@@ -988,7 +988,6 @@
 					   char *name, u32 cap)
 {
 	int err;
-	u32 state;
 	struct rfkill *rfkill_dev;
  
 	rfkill_dev = rfkill_alloc(name, dev, type,
@@ -996,8 +995,6 @@
 				  (void *)(unsigned long)cap);
 	if (!rfkill_dev)
 		return ERR_PTR(-ENOMEM);
-	get_u32(&state, cap);
-	rfkill_set_sw_state(rfkill_dev, !state);
  
 	err = rfkill_register(rfkill_dev);
 	if (err) {
@@ -675,8 +675,8 @@
 		if (!ehotk->eeepc_wlan_rfkill)
 			goto wlan_fail;
  
-		rfkill_set_global_sw_state(RFKILL_TYPE_WLAN,
-					   get_acpi(CM_ASL_WLAN) != 1);
+		rfkill_set_sw_state(ehotk->eeepc_wlan_rfkill,
+				    get_acpi(CM_ASL_WLAN) != 1);
 		result = rfkill_register(ehotk->eeepc_wlan_rfkill);
 		if (result)
 			goto wlan_fail;
@@ -693,8 +693,8 @@
 		if (!ehotk->eeepc_bluetooth_rfkill)
 			goto bluetooth_fail;
  
-		rfkill_set_global_sw_state(RFKILL_TYPE_BLUETOOTH,
-					   get_acpi(CM_ASL_BLUETOOTH) != 1);
+		rfkill_set_sw_state(ehotk->eeepc_bluetooth_rfkill,
+				    get_acpi(CM_ASL_BLUETOOTH) != 1);
 		result = rfkill_register(ehotk->eeepc_bluetooth_rfkill);
 		if (result)
 			goto bluetooth_fail;
@@ -422,7 +422,6 @@
 					   RFKILL_TYPE_WLAN,
 					   &hp_wmi_rfkill_ops,
 					   (void *) 0);
-		rfkill_set_sw_state(wifi_rfkill, hp_wmi_wifi_state());
 		err = rfkill_register(wifi_rfkill);
 		if (err)
 			goto register_wifi_error;
@@ -433,8 +432,6 @@
 						RFKILL_TYPE_BLUETOOTH,
 						&hp_wmi_rfkill_ops,
 						(void *) 1);
-		rfkill_set_sw_state(bluetooth_rfkill,
-				    hp_wmi_bluetooth_state());
 		err = rfkill_register(bluetooth_rfkill);
 		if (err)
 			goto register_bluetooth_error;
@@ -445,7 +442,6 @@
 					   RFKILL_TYPE_WWAN,
 					   &hp_wmi_rfkill_ops,
 					   (void *) 2);
-		rfkill_set_sw_state(wwan_rfkill, hp_wmi_wwan_state());
 		err = rfkill_register(wwan_rfkill);
 		if (err)
 			goto register_wwan_err;
@@ -1168,21 +1168,6 @@
  
 	BUG_ON(id >= TPACPI_RFK_SW_MAX || tpacpi_rfkill_switches[id]);
  
-	initial_sw_status = (tp_rfkops->get_status)();
-	if (initial_sw_status < 0) {
-		printk(TPACPI_ERR
-			"failed to read initial state for %s, error %d; "
-			"will turn radio off\n", name, initial_sw_status);
-	} else {
-		initial_sw_state = (initial_sw_status == TPACPI_RFK_RADIO_OFF);
-		if (set_default) {
-			/* try to set the initial state as the default for the
-			 * rfkill type, since we ask the firmware to preserve
-			 * it across S5 in NVRAM */
-			rfkill_set_global_sw_state(rfktype, initial_sw_state);
-		}
-	}
-
 	atp_rfk = kzalloc(sizeof(struct tpacpi_rfk), GFP_KERNEL);
 	if (atp_rfk)
 		atp_rfk->rfkill = rfkill_alloc(name,
@@ -1200,8 +1185,20 @@
 	atp_rfk->id = id;
 	atp_rfk->ops = tp_rfkops;
  
-	rfkill_set_states(atp_rfk->rfkill, initial_sw_state,
-				tpacpi_rfk_check_hwblock_state());
+	initial_sw_status = (tp_rfkops->get_status)();
+	if (initial_sw_status < 0) {
+		printk(TPACPI_ERR
+			"failed to read initial state for %s, error %d\n",
+			name, initial_sw_status);
+	} else {
+		initial_sw_state = (initial_sw_status == TPACPI_RFK_RADIO_OFF);
+		if (set_default) {
+			/* try to keep the initial state, since we ask the
+			 * firmware to preserve it across S5 in NVRAM */
+			rfkill_set_sw_state(atp_rfk->rfkill, initial_sw_state);
+		}
+	}
+	rfkill_set_hw_state(atp_rfk->rfkill, tpacpi_rfk_check_hwblock_state());
  
 	res = rfkill_register(atp_rfk->rfkill);
 	if (res < 0) {
@@ -157,8 +157,14 @@
  * @rfkill: rfkill structure to be registered
  *
  * This function should be called by the transmitter driver to register
- * the rfkill structure needs to be registered. Before calling this function
- * the driver needs to be ready to service method calls from rfkill.
+ * the rfkill structure. Before calling this function the driver needs
+ * to be ready to service method calls from rfkill.
+ *
+ * If the software blocked state is not set before registration,
+ * set_block will be called to initialize it to a default value.
+ *
+ * If the hardware blocked state is not set before registration,
+ * it is assumed to be unblocked.
  */
 int __must_check rfkill_register(struct rfkill *rfkill);
  
@@ -251,19 +257,6 @@
 void rfkill_set_states(struct rfkill *rfkill, bool sw, bool hw);
  
 /**
- * rfkill_set_global_sw_state - set global sw block default
- * @type: rfkill type to set default for
- * @blocked: default to set
- *
- * This function sets the global default -- use at boot if your platform has
- * an rfkill switch. If not early enough this call may be ignored.
- *
- * XXX: instead of ignoring -- how about just updating all currently
- *	registered drivers?
- */
-void rfkill_set_global_sw_state(const enum rfkill_type type, bool blocked);
-
-/**
  * rfkill_blocked - query rfkill block
  *
  * @rfkill: rfkill struct to query
@@ -314,11 +307,6 @@
 }
  
 static inline void rfkill_set_states(struct rfkill *rfkill, bool sw, bool hw)
-{
-}
-
-static inline void rfkill_set_global_sw_state(const enum rfkill_type type,
-					      bool blocked)
 {
 }
  
@@ -57,6 +57,7 @@
  
 	bool			registered;
 	bool			suspended;
+	bool			persistent;
  
 	const struct rfkill_ops	*ops;
 	void			*data;
  
@@ -116,11 +117,9 @@
 		 "Default initial state for all radio types, 0 = radio off");
  
 static struct {
-	bool cur, def;
+	bool cur, sav;
 } rfkill_global_states[NUM_RFKILL_TYPES];
  
-static unsigned long rfkill_states_default_locked;
-
 static bool rfkill_epo_lock_active;
  
  
@@ -392,7 +391,7 @@
 		rfkill_set_block(rfkill, true);
  
 	for (i = 0; i < NUM_RFKILL_TYPES; i++) {
-		rfkill_global_states[i].def = rfkill_global_states[i].cur;
+		rfkill_global_states[i].sav = rfkill_global_states[i].cur;
 		rfkill_global_states[i].cur = true;
 	}
  
@@ -417,7 +416,7 @@
  
 	rfkill_epo_lock_active = false;
 	for (i = 0; i < NUM_RFKILL_TYPES; i++)
-		__rfkill_switch_all(i, rfkill_global_states[i].def);
+		__rfkill_switch_all(i, rfkill_global_states[i].sav);
 	mutex_unlock(&rfkill_global_mutex);
 }
  
  
@@ -464,30 +463,7 @@
 }
 #endif
  
-void rfkill_set_global_sw_state(const enum rfkill_type type, bool blocked)
-{
-	BUG_ON(type == RFKILL_TYPE_ALL);
  
-	mutex_lock(&rfkill_global_mutex);
-
-	/* don't allow unblock when epo */
-	if (rfkill_epo_lock_active && !blocked)
-		goto out;
-
-	/* too late */
-	if (rfkill_states_default_locked & BIT(type))
-		goto out;
-
-	rfkill_states_default_locked |= BIT(type);
-
-	rfkill_global_states[type].cur = blocked;
-	rfkill_global_states[type].def = blocked;
- out:
-	mutex_unlock(&rfkill_global_mutex);
-}
-EXPORT_SYMBOL(rfkill_set_global_sw_state);
-
-
 bool rfkill_set_hw_state(struct rfkill *rfkill, bool blocked)
 {
 	bool ret, change;
  
  
@@ -532,14 +508,15 @@
 	blocked = blocked || hwblock;
 	spin_unlock_irqrestore(&rfkill->lock, flags);
  
-	if (!rfkill->registered)
-		return blocked;
+	if (!rfkill->registered) {
+		rfkill->persistent = true;
+	} else {
+		if (prev != blocked && !hwblock)
+			schedule_work(&rfkill->uevent_work);
  
-	if (prev != blocked && !hwblock)
-		schedule_work(&rfkill->uevent_work);
+		rfkill_led_trigger_event(rfkill);
+	}
  
-	rfkill_led_trigger_event(rfkill);
-
 	return blocked;
 }
 EXPORT_SYMBOL(rfkill_set_sw_state);
  
@@ -563,13 +540,14 @@
  
 	spin_unlock_irqrestore(&rfkill->lock, flags);
  
-	if (!rfkill->registered)
-		return;
+	if (!rfkill->registered) {
+		rfkill->persistent = true;
+	} else {
+		if (swprev != sw || hwprev != hw)
+			schedule_work(&rfkill->uevent_work);
  
-	if (swprev != sw || hwprev != hw)
-		schedule_work(&rfkill->uevent_work);
-
-	rfkill_led_trigger_event(rfkill);
+		rfkill_led_trigger_event(rfkill);
+	}
 }
 EXPORT_SYMBOL(rfkill_set_states);
  
@@ -888,15 +866,6 @@
 	dev_set_name(dev, "rfkill%lu", rfkill_no);
 	rfkill_no++;
  
-	if (!(rfkill_states_default_locked & BIT(rfkill->type))) {
-		/* first of its kind */
-		BUILD_BUG_ON(NUM_RFKILL_TYPES >
-			sizeof(rfkill_states_default_locked) * 8);
-		rfkill_states_default_locked |= BIT(rfkill->type);
-		rfkill_global_states[rfkill->type].cur =
-			rfkill_global_states[rfkill->type].def;
-	}
-
 	list_add_tail(&rfkill->node, &rfkill_list);
  
 	error = device_add(dev);
  
@@ -916,8 +885,18 @@
 	if (rfkill->ops->poll)
 		schedule_delayed_work(&rfkill->poll_work,
 			round_jiffies_relative(POLL_INTERVAL));
-	schedule_work(&rfkill->sync_work);
  
+	if (!rfkill->persistent || rfkill_epo_lock_active) {
+		schedule_work(&rfkill->sync_work);
+	} else {
+#ifdef CONFIG_RFKILL_INPUT
+		bool soft_blocked = !!(rfkill->state & RFKILL_BLOCK_SW);
+
+		if (!atomic_read(&rfkill_input_disabled))
+			__rfkill_switch_all(rfkill->type, soft_blocked);
+#endif
+	}
+
 	rfkill_send_events(rfkill, RFKILL_OP_ADD);
  
 	mutex_unlock(&rfkill_global_mutex);
@@ -1193,7 +1172,7 @@
 	int i;
  
 	for (i = 0; i < NUM_RFKILL_TYPES; i++)
-		rfkill_global_states[i].def = !rfkill_default_state;
+		rfkill_global_states[i].cur = !rfkill_default_state;
  
 	error = class_register(&rfkill_class);
 	if (error)
...	...	@@ -988,7 +988,6 @@
988	988	char *name, u32 cap)
989	989	{
990	990	int err;
991		- u32 state;
992	991	struct rfkill *rfkill_dev;
993	992
994	993	rfkill_dev = rfkill_alloc(name, dev, type,
...	...	@@ -996,8 +995,6 @@
996	995	(void *)(unsigned long)cap);
997	996	if (!rfkill_dev)
998	997	return ERR_PTR(-ENOMEM);
999		- get_u32(&state, cap);
1000		- rfkill_set_sw_state(rfkill_dev, !state);
1001	998
1002	999	err = rfkill_register(rfkill_dev);
1003	1000	if (err) {
...	...	@@ -675,8 +675,8 @@
675	675	if (!ehotk->eeepc_wlan_rfkill)
676	676	goto wlan_fail;
677	677
678		- rfkill_set_global_sw_state(RFKILL_TYPE_WLAN,
679		- get_acpi(CM_ASL_WLAN) != 1);
	678	+ rfkill_set_sw_state(ehotk->eeepc_wlan_rfkill,
	679	+ get_acpi(CM_ASL_WLAN) != 1);
680	680	result = rfkill_register(ehotk->eeepc_wlan_rfkill);
681	681	if (result)
682	682	goto wlan_fail;
...	...	@@ -693,8 +693,8 @@
693	693	if (!ehotk->eeepc_bluetooth_rfkill)
694	694	goto bluetooth_fail;
695	695
696		- rfkill_set_global_sw_state(RFKILL_TYPE_BLUETOOTH,
697		- get_acpi(CM_ASL_BLUETOOTH) != 1);
	696	+ rfkill_set_sw_state(ehotk->eeepc_bluetooth_rfkill,
	697	+ get_acpi(CM_ASL_BLUETOOTH) != 1);
698	698	result = rfkill_register(ehotk->eeepc_bluetooth_rfkill);
699	699	if (result)
700	700	goto bluetooth_fail;
...	...	@@ -422,7 +422,6 @@
422	422	RFKILL_TYPE_WLAN,
423	423	&hp_wmi_rfkill_ops,
424	424	(void *) 0);
425		- rfkill_set_sw_state(wifi_rfkill, hp_wmi_wifi_state());
426	425	err = rfkill_register(wifi_rfkill);
427	426	if (err)
428	427	goto register_wifi_error;
...	...	@@ -433,8 +432,6 @@
433	432	RFKILL_TYPE_BLUETOOTH,
434	433	&hp_wmi_rfkill_ops,
435	434	(void *) 1);
436		- rfkill_set_sw_state(bluetooth_rfkill,
437		- hp_wmi_bluetooth_state());
438	435	err = rfkill_register(bluetooth_rfkill);
439	436	if (err)
440	437	goto register_bluetooth_error;
...	...	@@ -445,7 +442,6 @@
445	442	RFKILL_TYPE_WWAN,
446	443	&hp_wmi_rfkill_ops,
447	444	(void *) 2);
448		- rfkill_set_sw_state(wwan_rfkill, hp_wmi_wwan_state());
449	445	err = rfkill_register(wwan_rfkill);
450	446	if (err)
451	447	goto register_wwan_err;
...	...	@@ -1168,21 +1168,6 @@
1168	1168
1169	1169	BUG_ON(id >= TPACPI_RFK_SW_MAX \|\| tpacpi_rfkill_switches[id]);
1170	1170
1171		- initial_sw_status = (tp_rfkops->get_status)();
1172		- if (initial_sw_status < 0) {
1173		- printk(TPACPI_ERR
1174		- "failed to read initial state for %s, error %d; "
1175		- "will turn radio off\n", name, initial_sw_status);
1176		- } else {
1177		- initial_sw_state = (initial_sw_status == TPACPI_RFK_RADIO_OFF);
1178		- if (set_default) {
1179		- /* try to set the initial state as the default for the
1180		- * rfkill type, since we ask the firmware to preserve
1181		- * it across S5 in NVRAM */
1182		- rfkill_set_global_sw_state(rfktype, initial_sw_state);
1183		- }
1184		- }
1185		-
1186	1171	atp_rfk = kzalloc(sizeof(struct tpacpi_rfk), GFP_KERNEL);
1187	1172	if (atp_rfk)
1188	1173	atp_rfk->rfkill = rfkill_alloc(name,
...	...	@@ -1200,8 +1185,20 @@
1200	1185	atp_rfk->id = id;
1201	1186	atp_rfk->ops = tp_rfkops;
1202	1187
1203		- rfkill_set_states(atp_rfk->rfkill, initial_sw_state,
1204		- tpacpi_rfk_check_hwblock_state());
	1188	+ initial_sw_status = (tp_rfkops->get_status)();
	1189	+ if (initial_sw_status < 0) {
	1190	+ printk(TPACPI_ERR
	1191	+ "failed to read initial state for %s, error %d\n",
	1192	+ name, initial_sw_status);
	1193	+ } else {
	1194	+ initial_sw_state = (initial_sw_status == TPACPI_RFK_RADIO_OFF);
	1195	+ if (set_default) {
	1196	+ /* try to keep the initial state, since we ask the
	1197	+ * firmware to preserve it across S5 in NVRAM */
	1198	+ rfkill_set_sw_state(atp_rfk->rfkill, initial_sw_state);
	1199	+ }
	1200	+ }
	1201	+ rfkill_set_hw_state(atp_rfk->rfkill, tpacpi_rfk_check_hwblock_state());
1205	1202
1206	1203	res = rfkill_register(atp_rfk->rfkill);
1207	1204	if (res < 0) {
...	...	@@ -157,8 +157,14 @@
157	157	* @rfkill: rfkill structure to be registered
158	158	*
159	159	* This function should be called by the transmitter driver to register
160		- * the rfkill structure needs to be registered. Before calling this function
161		- * the driver needs to be ready to service method calls from rfkill.
	160	+ * the rfkill structure. Before calling this function the driver needs
	161	+ * to be ready to service method calls from rfkill.
	162	+ *
	163	+ * If the software blocked state is not set before registration,
	164	+ * set_block will be called to initialize it to a default value.
	165	+ *
	166	+ * If the hardware blocked state is not set before registration,
	167	+ * it is assumed to be unblocked.
162	168	*/
163	169	int __must_check rfkill_register(struct rfkill *rfkill);
164	170
...	...	@@ -251,19 +257,6 @@
251	257	void rfkill_set_states(struct rfkill *rfkill, bool sw, bool hw);
252	258
253	259	/**
254		- * rfkill_set_global_sw_state - set global sw block default
255		- * @type: rfkill type to set default for
256		- * @blocked: default to set
257		- *
258		- * This function sets the global default -- use at boot if your platform has
259		- * an rfkill switch. If not early enough this call may be ignored.
260		- *
261		- * XXX: instead of ignoring -- how about just updating all currently
262		- * registered drivers?
263		- */
264		-void rfkill_set_global_sw_state(const enum rfkill_type type, bool blocked);
265		-
266		-/**
267	260	* rfkill_blocked - query rfkill block
268	261	*
269	262	* @rfkill: rfkill struct to query
...	...	@@ -314,11 +307,6 @@
314	307	}
315	308
316	309	static inline void rfkill_set_states(struct rfkill *rfkill, bool sw, bool hw)
317		-{
318		-}
319		-
320		-static inline void rfkill_set_global_sw_state(const enum rfkill_type type,
321		- bool blocked)
322	310	{
323	311	}
324	312
...	...	@@ -57,6 +57,7 @@
57	57
58	58	bool registered;
59	59	bool suspended;
	60	+ bool persistent;
60	61
61	62	const struct rfkill_ops *ops;
62	63	void *data;
63	64
...	...	@@ -116,11 +117,9 @@
116	117	"Default initial state for all radio types, 0 = radio off");
117	118
118	119	static struct {
119		- bool cur, def;
	120	+ bool cur, sav;
120	121	} rfkill_global_states[NUM_RFKILL_TYPES];
121	122
122		-static unsigned long rfkill_states_default_locked;
123		-
124	123	static bool rfkill_epo_lock_active;
125	124
126	125
...	...	@@ -392,7 +391,7 @@
392	391	rfkill_set_block(rfkill, true);
393	392
394	393	for (i = 0; i < NUM_RFKILL_TYPES; i++) {
395		- rfkill_global_states[i].def = rfkill_global_states[i].cur;
	394	+ rfkill_global_states[i].sav = rfkill_global_states[i].cur;
396	395	rfkill_global_states[i].cur = true;
397	396	}
398	397
...	...	@@ -417,7 +416,7 @@
417	416
418	417	rfkill_epo_lock_active = false;
419	418	for (i = 0; i < NUM_RFKILL_TYPES; i++)
420		- __rfkill_switch_all(i, rfkill_global_states[i].def);
	419	+ __rfkill_switch_all(i, rfkill_global_states[i].sav);
421	420	mutex_unlock(&rfkill_global_mutex);
422	421	}
423	422
424	423
...	...	@@ -464,30 +463,7 @@
464	463	}
465	464	#endif
466	465
467		-void rfkill_set_global_sw_state(const enum rfkill_type type, bool blocked)
468		-{
469		- BUG_ON(type == RFKILL_TYPE_ALL);
470	466
471		- mutex_lock(&rfkill_global_mutex);
472		-
473		- /* don't allow unblock when epo */
474		- if (rfkill_epo_lock_active && !blocked)
475		- goto out;
476		-
477		- /* too late */
478		- if (rfkill_states_default_locked & BIT(type))
479		- goto out;
480		-
481		- rfkill_states_default_locked \|= BIT(type);
482		-
483		- rfkill_global_states[type].cur = blocked;
484		- rfkill_global_states[type].def = blocked;
485		- out:
486		- mutex_unlock(&rfkill_global_mutex);
487		-}
488		-EXPORT_SYMBOL(rfkill_set_global_sw_state);
489		-
490		-
491	467	bool rfkill_set_hw_state(struct rfkill *rfkill, bool blocked)
492	468	{
493	469	bool ret, change;
494	470
495	471
...	...	@@ -532,14 +508,15 @@
532	508	blocked = blocked \|\| hwblock;
533	509	spin_unlock_irqrestore(&rfkill->lock, flags);
534	510
535		- if (!rfkill->registered)
536		- return blocked;
	511	+ if (!rfkill->registered) {
	512	+ rfkill->persistent = true;
	513	+ } else {
	514	+ if (prev != blocked && !hwblock)
	515	+ schedule_work(&rfkill->uevent_work);
537	516
538		- if (prev != blocked && !hwblock)
539		- schedule_work(&rfkill->uevent_work);
	517	+ rfkill_led_trigger_event(rfkill);
	518	+ }
540	519
541		- rfkill_led_trigger_event(rfkill);
542		-
543	520	return blocked;
544	521	}
545	522	EXPORT_SYMBOL(rfkill_set_sw_state);
546	523
...	...	@@ -563,13 +540,14 @@
563	540
564	541	spin_unlock_irqrestore(&rfkill->lock, flags);
565	542
566		- if (!rfkill->registered)
567		- return;
	543	+ if (!rfkill->registered) {
	544	+ rfkill->persistent = true;
	545	+ } else {
	546	+ if (swprev != sw \|\| hwprev != hw)
	547	+ schedule_work(&rfkill->uevent_work);
568	548
569		- if (swprev != sw \|\| hwprev != hw)
570		- schedule_work(&rfkill->uevent_work);
571		-
572		- rfkill_led_trigger_event(rfkill);
	549	+ rfkill_led_trigger_event(rfkill);
	550	+ }
573	551	}
574	552	EXPORT_SYMBOL(rfkill_set_states);
575	553
...	...	@@ -888,15 +866,6 @@
888	866	dev_set_name(dev, "rfkill%lu", rfkill_no);
889	867	rfkill_no++;
890	868
891		- if (!(rfkill_states_default_locked & BIT(rfkill->type))) {
892		- /* first of its kind */
893		- BUILD_BUG_ON(NUM_RFKILL_TYPES >
894		- sizeof(rfkill_states_default_locked) * 8);
895		- rfkill_states_default_locked \|= BIT(rfkill->type);
896		- rfkill_global_states[rfkill->type].cur =
897		- rfkill_global_states[rfkill->type].def;
898		- }
899		-
900	869	list_add_tail(&rfkill->node, &rfkill_list);
901	870
902	871	error = device_add(dev);
903	872
...	...	@@ -916,8 +885,18 @@
916	885	if (rfkill->ops->poll)
917	886	schedule_delayed_work(&rfkill->poll_work,
918	887	round_jiffies_relative(POLL_INTERVAL));
919		- schedule_work(&rfkill->sync_work);
920	888
	889	+ if (!rfkill->persistent \|\| rfkill_epo_lock_active) {
	890	+ schedule_work(&rfkill->sync_work);
	891	+ } else {
	892	+#ifdef CONFIG_RFKILL_INPUT
	893	+ bool soft_blocked = !!(rfkill->state & RFKILL_BLOCK_SW);
	894	+
	895	+ if (!atomic_read(&rfkill_input_disabled))
	896	+ __rfkill_switch_all(rfkill->type, soft_blocked);
	897	+#endif
	898	+ }
	899	+
921	900	rfkill_send_events(rfkill, RFKILL_OP_ADD);
922	901
923	902	mutex_unlock(&rfkill_global_mutex);
...	...	@@ -1193,7 +1172,7 @@
1193	1172	int i;
1194	1173
1195	1174	for (i = 0; i < NUM_RFKILL_TYPES; i++)
1196		- rfkill_global_states[i].def = !rfkill_default_state;
	1175	+ rfkill_global_states[i].cur = !rfkill_default_state;
1197	1176
1198	1177	error = class_register(&rfkill_class);
1199	1178	if (error)