staging: wilc1000: handle power sequence when pins are not in DT

In case pins are not present in DT bindings for WILC devices the
driver had some default pins: GPIO_NUM_RESET, GPIO_NUM_CHIP_EN.
In case power pins were not located in device tree on WILC node
the driver tried to request the default pins. But these pins were
general and valid only on SAMA5D4 Xplained board. The patch changed
this approach as follows:
1/ driver is checking if power seqeunce driver is used: if yes then
  it will not request DT pins and power up/down would be handled by
  MMC subsystem via pwrseq driver, using pm_runtime_* calls in
  wilc_sdio_init(), wilc_sdio_deinit() functions. In case power
  sequence driver is not used the wilc_wlan_power() is called.
2/ if power sequence driver is not present the driver will scan
  for power pins in device tree on its node. If it doens't locate
  any new pins and it is running on SAMA5D4 Xplained the SAMA5D4
  Xplained specific pins are used. This is necessary for backward
  compatibility with old DTs that doesn't provide these pins.
3/ If none of the above are true the driver probe will fail.

The code in netdev.c under KERNEL_VERSION(3, 13, 0) should not be
necessary anymore as the replacements done in wilc_of_parse_power_pins()
and wilc_wlan_power() should guarantee backward compatibility.

Author: claudiubeznea

drivers/staging/wilc1000/Makefile

@@ -3,7 +3,7 @@ ccflags-y += -I$(src)/ -DWILC_ASIC_A0 -DWILC_DEBUGFS
 
 wilc-objs := cfg80211.o netdev.o mon.o \
 			hif.o wlan_cfg.o debugfs.o \
-			wlan.o sysfs.o bt.o
+			wlan.o sysfs.o bt.o power.o
 
 obj-$(CONFIG_WILC_SDIO) += wilc-sdio.o
 wilc-sdio-objs += $(wilc-objs)

drivers/staging/wilc1000/bt.c

@@ -322,7 +322,9 @@ int wilc_bt_power_down(struct wilc *wilc, int source)
 		pr_warn("Another device is preventing power down. request source is %s\n",
 			(source == DEV_WIFI ? "Wifi" : "BT"));
 	} else {
-		ret = wilc_wlan_power_off_sequence(wilc);
+		acquire_bus(wilc, WILC_BUS_ACQUIRE_ONLY, source);
+		ret = wilc->hif_func->hif_deinit(wilc);
+		release_bus(wilc, WILC_BUS_RELEASE_ONLY, source);
 		if (ret) {
 			mutex_unlock(&wilc->cs);
 			return ret;

drivers/staging/wilc1000/hif.h

@@ -236,4 +236,6 @@ void wilc_gnrl_async_info_received(struct wilc *wilc, u8 *buffer, u32 length);
 void *wilc_parse_join_bss_param(struct cfg80211_bss *bss,
 				struct cfg80211_crypto_settings *crypto);
 void handle_connect_cancel(struct wilc_vif *vif);
+int wilc_of_parse_power_pins(struct wilc *wilc);
+void wilc_wlan_power(struct wilc *wilc, bool on);
 #endif

drivers/staging/wilc1000/netdev.c

@@ -1347,152 +1347,4 @@ struct wilc_vif *wilc_netdev_ifc_init(struct wilc *wl, const char *name,
 	return vif;
 }
 
-#if KERNEL_VERSION(3, 13, 0) < LINUX_VERSION_CODE
-static int wilc_wlan_power(struct wilc *wilc, int power)
-{
-	struct gpio_desc *gpio_reset;
-	struct gpio_desc *gpio_chip_en;
-	int ret = 0;
-
-	pr_info("wifi_pm : %d\n", power);
-
-	gpio_reset = gpiod_get(wilc->dt_dev, "reset", GPIOD_ASIS);
-	if (IS_ERR(gpio_reset)) {
-		dev_warn(wilc->dev, "failed to get Reset GPIO, try default\r\n");
-		gpio_reset = gpio_to_desc(GPIO_NUM_RESET);
-		if (!gpio_reset) {
-			dev_warn(wilc->dev,
-				 "failed to get default Reset GPIO\r\n");
-			return -EIO;
-		}
-	} else {
-		dev_info(wilc->dev, "succesfully got gpio_reset\r\n");
-	}
-
-	gpio_chip_en = gpiod_get(wilc->dt_dev, "chip_en", GPIOD_ASIS);
-	if (IS_ERR(gpio_chip_en)) {
-		gpio_chip_en = gpio_to_desc(GPIO_NUM_CHIP_EN);
-		if (!gpio_chip_en) {
-			dev_warn(wilc->dev,
-				 "failed to get default chip_en GPIO\r\n");
-			gpiod_put(gpio_reset);
-			return -EIO;
-		}
-	} else {
-		dev_info(wilc->dev, "succesfully got gpio_chip_en\r\n");
-	}
-
-	if (power) {
-		ret = gpiod_direction_output(gpio_chip_en, 1);
-		if (ret < 0) {
-			dev_warn(wilc->dev,
-				 "failed to set chip_en GPIO direction\r\n");
-			goto out;
-			ret = -EIO;
-		}
-		mdelay(5);
-		ret = gpiod_direction_output(gpio_reset, 1);
-		if (ret) {
-			dev_warn(wilc->dev,
-				 "failed to set reset GPIO direction\r\n");
-			goto out;
-			ret = -EIO;
-		}
-	} else {
-		ret = gpiod_direction_output(gpio_reset, 0);
-		if (ret) {
-			dev_warn(wilc->dev,
-				 "failed to set chip_en GPIO direction\r\n");
-			goto out;
-			ret = -EIO;
-		}
-		ret = gpiod_direction_output(gpio_chip_en, 0);
-		if (ret) {
-			dev_warn(wilc->dev,
-				 "failed to set reset GPIO direction\r\n");
-			goto out;
-			ret = -EIO;
-		}
-	}
-
-out:
-	gpiod_put(gpio_chip_en);
-	gpiod_put(gpio_reset);
-
-	return ret;
-}
-#else
-static int wilc_wlan_power(struct wilc *wilc, int power)
-{
-	int gpio_reset;
-	int gpio_chip_en;
-	struct device_node *of_node = wilc->dt_dev->of_node;
-
-	pr_info("wifi_pm : %d\n", power);
-
-	gpio_reset = of_get_named_gpio_flags(of_node, "reset-gpios", 0, NULL);
-
-	if (gpio_reset < 0) {
-		gpio_reset = GPIO_NUM_RESET;
-		pr_info("wifi_pm : load default reset GPIO %d\n", gpio_reset);
-	}
-
-	gpio_chip_en = of_get_named_gpio_flags(of_node, "chip_en-gpios", 0,
-					       NULL);
-
-	if (gpio_chip_en < 0) {
-		gpio_chip_en = GPIO_NUM_CHIP_EN;
-		pr_info("wifi_pm : load default chip_en GPIO %d\n",
-			gpio_chip_en);
-	}
-
-	if (gpio_request(gpio_chip_en, "CHIP_EN") == 0 &&
-	    gpio_request(gpio_reset, "RESET") == 0) {
-		gpio_direction_output(gpio_chip_en, 0);
-		gpio_direction_output(gpio_reset, 0);
-		if (power) {
-			gpio_set_value(gpio_chip_en, 1);
-			mdelay(5);
-			gpio_set_value(gpio_reset, 1);
-		} else {
-			gpio_set_value(gpio_reset, 0);
-			gpio_set_value(gpio_chip_en, 0);
-		}
-		gpio_free(gpio_chip_en);
-		gpio_free(gpio_reset);
-	} else {
-		dev_err(wilc->dev,
-			"Error requesting GPIOs for CHIP_EN and RESET");
-		return -EIO;
-	}
-
-	return 0;
-}
-#endif
-
-int wilc_wlan_power_on_sequence(struct wilc *wilc)
-{
-	int ret;
-
-	ret = wilc_wlan_power(wilc, 0);
-	if (ret)
-		return ret;
-	ret = wilc_wlan_power(wilc, 1);
-	if (ret)
-		return ret;
-
-	return 0;
-}
-
-int wilc_wlan_power_off_sequence(struct wilc *wilc)
-{
-	int ret;
-
-	ret = wilc_wlan_power(wilc, 0);
-	if (ret)
-		return ret;
-
-	return 0;
-}
-
 MODULE_LICENSE("GPL");

drivers/staging/wilc1000/netdev.h

@@ -13,12 +13,6 @@
 #include <net/ieee80211_radiotap.h>
 #include <linux/if_arp.h>
 #include <linux/version.h>
-#if KERNEL_VERSION(3, 13, 0) < LINUX_VERSION_CODE
-#include <linux/gpio/consumer.h>
-#else
-#include <linux/of_gpio.h>
-#include <linux/gpio.h>
-#endif
 
 #include "hif.h"
 #include "wlan.h"
@@ -372,7 +366,13 @@ struct wilc_vif {
 	struct cfg80211_bss *bss;
 };
 
+struct wilc_power_gpios {
+	int reset;
+	int chip_en;
+};
+
 struct wilc_power {
+	struct wilc_power_gpios gpios;
 	u8 status[DEV_MAX];
 };
 

drivers/staging/wilc1000/power.c

@@ -0,0 +1,103 @@
+#include <linux/delay.h>
+#include <linux/of.h>
+#include <linux/version.h>
+#include <linux/of_gpio.h>
+#include <linux/gpio.h>
+
+#include "netdev.h"
+
+/**
+ * wilc_of_parse_power_pins() - parse power sequence pins; to keep backward
+ *		compatibility with old device trees that doesn't provide
+ *		power sequence pins we check for default pins on proper boards
+ *
+ * @wilc:	wilc data structure
+ *
+ * Returns:	 0 on success, negative error number on failures.
+ */
+int wilc_of_parse_power_pins(struct wilc *wilc)
+{
+	static const struct wilc_power_gpios default_gpios[] = {
+		{ .reset = GPIO_NUM_RESET,	.chip_en = GPIO_NUM_CHIP_EN, },
+	};
+
+	static const struct of_device_id wilc_default_pins_ids[] = {
+		{
+			.compatible = "atmel,sama5d4-xplained",
+			.data = &default_gpios[0],
+		},
+		{ /* Sentinel. */ }
+	};
+
+	struct device_node *of = wilc->dt_dev->of_node;
+	struct wilc_power *power = &wilc->power;
+	const struct wilc_power_gpios *gpios;
+	const struct of_device_id *of_id;
+	struct device_node *np;
+	int ret = 0;
+
+	/*
+	 * The maching here is to keep backward compatibility with old DT that
+	 * doesn't provide reset-gpios and chip_en.
+	 */
+	np = of_find_matching_node_and_match(NULL, wilc_default_pins_ids,
+					     &of_id);
+	if (np)
+		gpios = of_id->data;
+
+	power->gpios.reset = of_get_named_gpio_flags(of, "reset-gpios", 0,
+						     NULL);
+	if (!gpio_is_valid(power->gpios.reset) && np)
+		power->gpios.reset = gpios->reset;
+	else
+		goto put_node;
+
+	power->gpios.chip_en = of_get_named_gpio_flags(of, "chip_en-gpios", 0,
+						       NULL);
+	if (!gpio_is_valid(power->gpios.chip_en) && np)
+		power->gpios.chip_en = gpios->chip_en;
+	else
+		goto put_node;
+
+	ret = devm_gpio_request(wilc->dev, power->gpios.chip_en, "CHIP_EN");
+	if (ret)
+		goto put_node;
+
+	ret = devm_gpio_request(wilc->dev, power->gpios.reset, "RESET");
+	if (ret)
+		goto put_node;
+
+	return 0;
+
+put_node:
+	of_node_put(np);
+	return ret;
+}
+
+/**
+ * wilc_wlan_power() - handle power on/off commands
+ *
+ * @wilc:	wilc data structure
+ * @on:		requested power status
+ *
+ * Returns:	none
+ */
+void wilc_wlan_power(struct wilc *wilc, bool on)
+{
+	if (!gpio_is_valid(wilc->power.gpios.chip_en) ||
+	    !gpio_is_valid(wilc->power.gpios.reset)) {
+		/* In case SDIO power sequence driver is used to power this
+		 * device then the powering sequence is handled by the bus
+		 * via pm_runtime_* functions. */
+		return;
+	}
+
+	if (on) {
+		gpio_direction_output(wilc->power.gpios.chip_en, 1);
+		mdelay(5);
+		gpio_direction_output(wilc->power.gpios.reset, 1);
+	} else {
+		gpio_direction_output(wilc->power.gpios.chip_en, 0);
+		gpio_direction_output(wilc->power.gpios.reset, 0);
+	}
+}

drivers/staging/wilc1000/sdio.c

@@ -149,6 +149,7 @@ static int wilc_sdio_probe(struct sdio_func *func,
 	int ret, io_type;
 	static bool init_power;
 	struct wilc_sdio *sdio_priv;
+	struct device_node *np;
 	int irq_num;
 
 	sdio_priv = kzalloc(sizeof(*sdio_priv), GFP_KERNEL);
@@ -183,17 +184,40 @@ static int wilc_sdio_probe(struct sdio_func *func,
 		clk_prepare_enable(wilc->rtc_clk);
 	}
 
-	if (!init_power) {
-		ret = wilc_wlan_power_on_sequence(wilc);
+	/*
+	 * Some WILC SDIO setups needs a SD power sequence driver to be able
+	 * to power the WILC devices before reaching this function. For those
+	 * devices the power sequence driver already provides reset-gpios
+	 * and chip_en-gpios.
+	 */
+	np = of_parse_phandle(func->card->host->parent->of_node, "mmc-pwrseq",
+			      0);
+	if (!np) {
+		ret = wilc_of_parse_power_pins(wilc);
 		if (ret)
-			goto dispose_irq;
+			goto disable_rtc_clk;
+	} else {
+		init_power = 1;
+		of_node_put(np);
+	}
+
+
+	if (!init_power) {
+		/* This could be removed and let hif_init do its job. Also
+		 * doing insert/remove module for many times should lead
+		 * to calling this only the 1st time. */
+		wilc_wlan_power(wilc, true);
 		init_power = 1;
 	}
 
 	wilc_bt_init(wilc);
 
 	dev_info(&func->dev, "Driver Initializing success\n");
 	return 0;
+
+disable_rtc_clk:
+	if (!IS_ERR(wilc->rtc_clk))
+		clk_disable_unprepare(wilc->rtc_clk);
 dispose_irq:
 	irq_dispose_mapping(wilc->dev_irq_num);
 	wilc_netdev_cleanup(wilc);
@@ -635,10 +659,14 @@ static int wilc_sdio_read(struct wilc *wilc, u32 addr, u8 *buf, u32 size)
 
 static int wilc_sdio_deinit(struct wilc *wilc)
 {
+	struct sdio_func *func = dev_to_sdio_func(wilc->dev);
 	struct wilc_sdio *sdio_priv = wilc->bus_data;
 
 	sdio_priv->is_init = false;
 
+	pm_runtime_put_sync_autosuspend(mmc_dev(func->card->host));
+	wilc_wlan_power(wilc, false);
+
 	return 0;
 }