MFC r311734, r311735, r311951, r314071:

  Add new helper routines for sdhci bridge drivers that use gpio pins for
  card presence and write protect switch detection.

  Use the new sdhci_fdt_gpio helper functions to add full support for FDT
  gpio pins for detecting card insert/remove and write protect for ti_sdhci.

  Include sys/systm.h for use of bootverbose.

  Revert to ti_sdhci driver's historic behavior: assume an sd card is
  writable if the fdt data doesn't provide a gpio pin for reading the write
  protect switch and also doesn't contain a "wp-disable" property.

4 files changed, 359 insertions, 26 deletions

diff --git a/sys/arm/ti/ti_sdhci.c b/sys/arm/ti/ti_sdhci.c
index ed7f1e7..379edc7 100644
--- a/sys/arm/ti/ti_sdhci.c
+++ b/sys/arm/ti/ti_sdhci.c
@@ -52,6 +52,7 @@ __FBSDID("$FreeBSD$");
 #include <dev/mmc/mmcbrvar.h>
 
 #include <dev/sdhci/sdhci.h>
+#include <dev/sdhci/sdhci_fdt_gpio.h>
 #include "sdhci_if.h"
 
 #include <arm/ti/ti_cpuid.h>
@@ -61,7 +62,7 @@ __FBSDID("$FreeBSD$");
 
 struct ti_sdhci_softc {
 	device_t		dev;
-	device_t		gpio_dev;
+	struct sdhci_fdt_gpio * gpio;
 	struct resource *	mem_res;
 	struct resource *	irq_res;
 	void *			intr_cookie;
@@ -75,6 +76,7 @@ struct ti_sdhci_softc {
 	uint32_t		sdhci_clkdiv;
 	boolean_t		disable_highspeed;
 	boolean_t		force_card_present;
+	boolean_t		disable_readonly;
 };
 
 /*
@@ -362,20 +364,27 @@ static int
 ti_sdhci_get_ro(device_t brdev, device_t reqdev)
 {
 	struct ti_sdhci_softc *sc = device_get_softc(brdev);
-	unsigned int readonly = 0;
 
-	/* If a gpio pin is configured, read it. */
-	if (sc->gpio_dev != NULL) {
-		GPIO_PIN_GET(sc->gpio_dev, sc->wp_gpio_pin, &readonly);
-	}
+	if (sc->disable_readonly)
+		return (0);
 
-	return (readonly);
+	return (sdhci_fdt_gpio_get_readonly(sc->gpio));
+}
+
+static bool
+ti_sdhci_get_card_present(device_t dev, struct sdhci_slot *slot)
+{
+	struct ti_sdhci_softc *sc = device_get_softc(dev);
+
+	return (sdhci_fdt_gpio_get_present(sc->gpio));
 }
 
 static int
 ti_sdhci_detach(device_t dev)
 {
 
+	/* sdhci_fdt_gpio_teardown(sc->gpio); */
+
 	return (EBUSY);
 }
 
@@ -502,25 +511,6 @@ ti_sdhci_attach(device_t dev)
 	}
 
 	/*
-	 * See if we've got a GPIO-based write detect pin.  This is not the
-	 * standard documented property for this, we added it in freebsd.
-	 */
-	if ((OF_getencprop(node, "mmchs-wp-gpio-pin", &prop, sizeof(prop))) <= 0)
-		sc->wp_gpio_pin = 0xffffffff;
-	else
-		sc->wp_gpio_pin = prop;
-
-	if (sc->wp_gpio_pin != 0xffffffff) {
-		sc->gpio_dev = devclass_get_device(devclass_find("gpio"), 0);
-		if (sc->gpio_dev == NULL) 
-			device_printf(dev, "Error: No GPIO device, "
-			    "Write Protect pin will not function\n");
-		else
-			GPIO_PIN_SETFLAGS(sc->gpio_dev, sc->wp_gpio_pin,
-			                  GPIO_PIN_INPUT);
-	}
-
-	/*
 	 * Set the offset from the device's memory start to the MMCHS registers.
 	 * Also for OMAP4 disable high speed mode due to erratum ID i626.
 	 */
@@ -572,6 +562,21 @@ ti_sdhci_attach(device_t dev)
 		goto fail;
 	}
 
+	/*
+	 * Set up handling of card-detect and write-protect gpio lines.
+	 *
+	 * If there is no write protect info in the fdt data, fall back to the
+	 * historical practice of assuming that the card is writable.  This
+	 * works around bad fdt data from the upstream source.  The alternative
+	 * would be to trust the sdhci controller's PRESENT_STATE register WP
+	 * bit, but it may say write protect is in effect when it's not if the
+	 * pinmux setup doesn't route the WP signal into the sdchi block.
+	 */
+	sc->gpio = sdhci_fdt_gpio_setup(sc->dev, &sc->slot);
+
+	if (!OF_hasprop(node, "wp-gpios") && !OF_hasprop(node, "wp-disable"))
+		sc->disable_readonly = true;
+
 	/* Initialise the MMCHS hardware. */
 	ti_sdhci_hw_init(dev);
 
@@ -706,6 +711,7 @@ static device_method_t ti_sdhci_methods[] = {
 	DEVMETHOD(sdhci_write_2,	ti_sdhci_write_2),
 	DEVMETHOD(sdhci_write_4,	ti_sdhci_write_4),
 	DEVMETHOD(sdhci_write_multi_4,	ti_sdhci_write_multi_4),
+	DEVMETHOD(sdhci_get_card_present, ti_sdhci_get_card_present),
 
 	DEVMETHOD_END
 };
diff --git a/sys/conf/files b/sys/conf/files
index ae4f87d..52cb263 100644
--- a/sys/conf/files
+++ b/sys/conf/files
@@ -2556,6 +2556,7 @@ dev/scc/scc_dev_z8530.c		optional scc
 dev/scd/scd.c			optional scd isa
 dev/scd/scd_isa.c		optional scd isa
 dev/sdhci/sdhci.c		optional sdhci
+dev/sdhci/sdhci_fdt_gpio.c	optional sdhci fdt gpio
 dev/sdhci/sdhci_if.m		optional sdhci
 dev/sdhci/sdhci_acpi.c		optional sdhci acpi
 dev/sdhci/sdhci_pci.c		optional sdhci pci
diff --git a/sys/dev/sdhci/sdhci_fdt_gpio.c b/sys/dev/sdhci/sdhci_fdt_gpio.c
new file mode 100644
index 0000000..9935f17
--- /dev/null
+++ b/sys/dev/sdhci/sdhci_fdt_gpio.c
@@ -0,0 +1,257 @@
+/*-
+ * Copyright (c) 2017 Ian Lepore <ian@freebsd.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * Support routines usable by any SoC sdhci bridge driver that uses gpio pins
+ * for card detect and write protect, and uses FDT data to describe those pins.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <sys/param.h>
+#include <sys/bus.h>
+#include <sys/gpio.h>
+#include <sys/sysctl.h>
+#include <sys/systm.h>
+#include <sys/taskqueue.h>
+
+#include <dev/gpio/gpiobusvar.h>
+#include <dev/mmc/bridge.h>
+#include <dev/ofw/ofw_bus.h>
+#include <dev/ofw/ofw_bus_subr.h>
+#include <dev/sdhci/sdhci.h>
+#include <dev/sdhci/sdhci_fdt_gpio.h>
+
+struct sdhci_fdt_gpio {
+	device_t		dev;
+	struct sdhci_slot *	slot;
+	gpio_pin_t		wp_pin;
+	gpio_pin_t		cd_pin;
+	void *			cd_ihandler;
+	struct resource *	cd_ires;
+	int			cd_irid;
+	bool			wp_disabled;
+	bool			wp_inverted;
+	bool			cd_disabled;
+	bool			cd_inverted;
+};
+
+/*
+ * Card detect interrupt handler.
+ */
+static void
+cd_intr(void *arg)
+{
+	struct sdhci_fdt_gpio *gpio = arg;
+
+	sdhci_handle_card_present(gpio->slot, sdhci_fdt_gpio_get_present(gpio));
+}
+
+/*
+ * Card detect setup.
+ */
+static void
+cd_setup(struct sdhci_fdt_gpio *gpio, phandle_t node)
+{
+	int pincaps;
+	device_t dev;
+	const char *cd_mode_str;
+
+	dev = gpio->dev;
+
+	/*
+	 * If the device is flagged as non-removable, set that slot option, and
+	 * set a flag to make sdhci_fdt_gpio_get_present() always return true.
+	 */
+	if (OF_hasprop(node, "non-removable")) {
+		gpio->slot->opt |= SDHCI_NON_REMOVABLE;
+		gpio->cd_disabled = true;
+		if (bootverbose)
+			device_printf(dev, "Non-removable media");
+		return;
+	}
+
+	/*
+	 * If there is no cd-gpios property, then presumably the hardware
+	 * PRESENT_STATE register and interrupts will reflect card state
+	 * properly, and there's nothing more for us to do.  Our get_present()
+	 * will return sdhci_generic_get_card_present() because cd_pin is NULL.
+	 *
+	 * If there is a property, make sure we can read the pin.
+	 */
+	if (gpio_pin_get_by_ofw_property(dev, node, "cd-gpios", &gpio->cd_pin))
+		return;
+
+	if (gpio_pin_getcaps(gpio->cd_pin, &pincaps) != 0 ||
+	    !(pincaps & GPIO_PIN_INPUT)) {
+		device_printf(dev, "Cannot read card-detect gpio pin; "
+		    "setting card-always-present flag.\n");
+		gpio->cd_disabled = true;
+		return;
+	}
+
+	if (OF_hasprop(node, "cd-inverted"))
+		gpio->cd_inverted = true;
+
+	/*
+	 * If the pin can trigger an interrupt on both rising and falling edges,
+	 * we can use it to detect card presence changes.  If not, we'll request
+	 * card presence polling instead of using interrupts.
+	 */
+	if (!(pincaps & GPIO_INTR_EDGE_BOTH)) {
+		if (bootverbose)
+			device_printf(dev, "Cannot configure "
+			    "GPIO_INTR_EDGE_BOTH for card detect\n");
+		goto without_interrupts;
+	}
+
+	/*
+	 * Create an interrupt resource from the pin and set up the interrupt.
+	 */
+	if ((gpio->cd_ires = gpio_alloc_intr_resource(dev, &gpio->cd_irid,
+	    RF_ACTIVE, gpio->cd_pin, GPIO_INTR_EDGE_BOTH)) == NULL) {
+		if (bootverbose)
+			device_printf(dev, "Cannot allocate an IRQ for card "
+			    "detect GPIO\n");
+		goto without_interrupts;
+	}
+
+	if (bus_setup_intr(dev, gpio->cd_ires, INTR_TYPE_BIO | INTR_MPSAFE,
+	    NULL, cd_intr, gpio, &gpio->cd_ihandler) != 0) {
+		device_printf(dev, "Unable to setup card-detect irq handler\n");
+		gpio->cd_ihandler = NULL;
+		goto without_interrupts;
+	}
+
+without_interrupts:
+
+	/*
+	 * If we have a readable gpio pin, but didn't successfully configure
+	 * gpio interrupts, ask the sdhci driver to poll from a callout.
+	 */
+	if (gpio->cd_ihandler == NULL) {
+		cd_mode_str = "polling";
+		gpio->slot->quirks |= SDHCI_QUIRK_POLL_CARD_PRESENT;
+	} else {
+		cd_mode_str = "interrupts";
+	}
+
+	if (bootverbose) {
+		device_printf(dev, "Card presence detect on %s pin %u, "
+		    "configured for %s.\n",
+		    device_get_nameunit(gpio->cd_pin->dev), gpio->cd_pin->pin,
+		    cd_mode_str);
+	}
+}
+
+/*
+ * Write protect setup.
+ */
+static void
+wp_setup(struct sdhci_fdt_gpio *gpio, phandle_t node)
+{
+	device_t dev;
+
+	dev = gpio->dev;
+
+	if (OF_hasprop(node, "wp-disable"))
+		return;
+
+	if (gpio_pin_get_by_ofw_property(dev, node, "wp-gpios", &gpio->wp_pin))
+		return;
+
+	if (OF_hasprop(node, "wp-inverted"))
+		gpio->wp_inverted = true;
+
+	if (bootverbose)
+		device_printf(dev, "Write protect switch on %s pin %u\n",
+		    device_get_nameunit(gpio->cd_pin->dev), gpio->cd_pin->pin);
+}
+
+struct sdhci_fdt_gpio *
+sdhci_fdt_gpio_setup(device_t dev, struct sdhci_slot *slot)
+{
+	phandle_t node;
+	struct sdhci_fdt_gpio *gpio;
+
+	gpio = malloc(sizeof(*gpio), M_DEVBUF, M_ZERO | M_WAITOK);
+	gpio->dev  = dev;
+	gpio->slot = slot;
+
+	node = ofw_bus_get_node(dev);
+
+	wp_setup(gpio, node);
+	cd_setup(gpio, node);
+
+	return (gpio);
+}
+
+void
+sdhci_fdt_gpio_teardown(struct sdhci_fdt_gpio *gpio)
+{
+
+	if (gpio == NULL)
+		return;
+
+	if (gpio->cd_ihandler != NULL) {
+		bus_teardown_intr(gpio->dev, gpio->cd_ires, gpio->cd_ihandler);
+	}
+
+	free(gpio, M_DEVBUF);
+}
+
+bool
+sdhci_fdt_gpio_get_present(struct sdhci_fdt_gpio *gpio)
+{
+	bool pinstate;
+
+	if (gpio->cd_disabled)
+		return (true);
+
+	if (gpio->cd_pin == NULL)
+		return (sdhci_generic_get_card_present(gpio->slot->bus,
+		    gpio->slot));
+
+	gpio_pin_is_active(gpio->cd_pin, &pinstate);
+
+	return (pinstate ^ gpio->cd_inverted);
+}
+
+int
+sdhci_fdt_gpio_get_readonly(struct sdhci_fdt_gpio *gpio)
+{
+	bool pinstate;
+
+	if (gpio->wp_disabled)
+		return (false);
+
+	if (gpio->wp_pin == NULL)
+		return (sdhci_generic_get_ro(gpio->slot->bus, gpio->slot->dev));
+
+	gpio_pin_is_active(gpio->wp_pin, &pinstate);
+
+	return (pinstate ^ gpio->wp_inverted);
+}
diff --git a/sys/dev/sdhci/sdhci_fdt_gpio.h b/sys/dev/sdhci/sdhci_fdt_gpio.h
new file mode 100644
index 0000000..6d51737
--- /dev/null
+++ b/sys/dev/sdhci/sdhci_fdt_gpio.h
@@ -0,0 +1,69 @@
+/*-
+ * Copyright (c) 2017 Ian Lepore <ian@freebsd.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/*
+ * Support routines usable by any SoC sdhci bridge driver that uses gpio pins
+ * for card detect and/or write protect, and uses FDT data to describe those
+ * pins.  A bridge driver need only supply a couple 2-line forwarding functions
+ * to connect the get_present and get_readonly accessors to the corresponding
+ * driver interface functions, and add setup/teardown calls to its attach and
+ * detach functions.
+ */
+
+#ifndef	_SDHCI_FDT_GPIO_H_
+#define	_SDHCI_FDT_GPIO_H_
+
+struct sdhci_slot;
+struct sdhci_fdt_gpio;
+
+/*
+ * sdhci_fdt_gpio_setup()
+ * sdhci_fdt_gpio_teardown()
+ *
+ * Process FDT properties that use gpio pins and set up interrupt handling (if
+ * supported by hardware) and accessor functions to read the pins.
+ *
+ * Setup cannot fail.  If the properties are not present, the accessors will
+ * return the values from standard sdhci registers.  If the gpio controller
+ * can't trigger interrupts on both edges, it configures the slot to use polling
+ * for card presence detection.  If it can't access the gpio pin at all it sets
+ * up the get_present() accessor to always return true.  Likewise the
+ * get_readonly() accessor always returns false if its pin can't be accessed.
+ */
+struct sdhci_fdt_gpio *sdhci_fdt_gpio_setup(device_t dev, struct sdhci_slot *slot);
+void sdhci_fdt_gpio_teardown(struct sdhci_fdt_gpio *gpio);
+
+/*
+ * sdhci_fdt_gpio_get_present()
+ * sdhci_fdt_gpio_get_readonly()
+ *
+ * Gpio pin state accessor functions.
+ */
+bool sdhci_fdt_gpio_get_present(struct sdhci_fdt_gpio *gpio);
+int  sdhci_fdt_gpio_get_readonly(struct sdhci_fdt_gpio *gpio);
+
+#endif