diff --git a/bes2600/bes2600_sdio.c b/bes2600/bes2600_sdio.c index 13d4ff1..8552b12 100644 --- a/bes2600/bes2600_sdio.c +++ b/bes2600/bes2600_sdio.c @@ -16,6 +16,7 @@ #include #include #include +#include #include #include #include @@ -1756,6 +1757,33 @@ static void bes2600_sdio_halt_device(struct sbus_priv *self) sdio_work_debug(self); } +/* + * Trigger an SDIO bus reset via mmc_hw_reset(). + * + * With multiple SDIO functions probed (PineTab2 binds func 1 for WLAN and + * func 2 for the BT-companion path) mmc_sdio_hw_reset() takes the + * remove-and-rescan path: it marks the card removed and schedules + * mmc_rescan, which tears down the bound function drivers and re-detects + * the card on the next sweep, in turn reinvoking bes2600_sdio_probe(). + * + * With a single function probed it instead invokes mmc_power_cycle() + * directly, which on PineTab2 toggles the wifi-reset GPIO via sdio_pwrseq. + * + * In both cases the chip ends up in a freshly reset state, which is the + * goal of the recovery path. + * + * mmc_hw_reset() must be called without holding the SDIO host claim -- + * the multi-func remove-and-rescan path acquires the host claim via the + * mmc workqueue. + */ +static int bes2600_sdio_bus_reset(struct sbus_priv *self) +{ + if (!self || !self->func || !self->func->card) + return -EINVAL; + + return mmc_hw_reset(self->func->card); +} + static bool bes2600_sdio_wakeup_source(struct sbus_priv *self) { struct bes2600_platform_data_sdio *pdata = bes2600_get_platform_data(); @@ -1794,6 +1822,7 @@ static struct sbus_ops bes2600_sdio_sbus_ops = { .gpio_sleep = bes2600_gpio_allow_mcu_sleep, .halt_device = bes2600_sdio_halt_device, .wakeup_source = bes2600_sdio_wakeup_source, + .bus_reset = bes2600_sdio_bus_reset, }; static void bes2600_sdio_en_lp_cb(struct bes2600_common *hw_priv) diff --git a/bes2600/bes_chardev.c b/bes2600/bes_chardev.c index f89dcb8..a74bf60 100644 --- a/bes2600/bes_chardev.c +++ b/bes2600/bes_chardev.c @@ -1078,6 +1078,48 @@ int bes2600_chrdev_do_system_close(const struct sbus_ops *sbus_ops, struct sbus_ return ret; } +/* + * Hard-reset the bus and wait for the bus core to remove the chip. + * + * Used by the firmware-wedge recovery path on platforms where the normal + * power_switch(0) sequence has no effective chip-reset signal. The bus + * implementation triggers an asynchronous re-detect; this helper waits for + * the resulting remove() callback to clear bes2600_cdev.sbus_priv so that a + * subsequent bes2600_switch_wifi(true) sees a clean state and can wait on + * the fresh probe. + */ +int bes2600_chrdev_do_bus_reset(const struct sbus_ops *sbus_ops, struct sbus_priv *priv) +{ + int ret; + long status; + + if (!sbus_ops || !priv) + return -EINVAL; + + if (!sbus_ops->bus_reset) + return -EOPNOTSUPP; + + bes_info("trigger bus reset to recover wedged firmware.\n"); + + ret = sbus_ops->bus_reset(priv); + if (ret) { + bes_err("bus_reset failed: %d\n", ret); + return ret; + } + + /* + * The bus reset is asynchronous: the bus core schedules a rescan + * which removes the bound function drivers and then re-detects the + * chip. Wait for the remove callback to clear sbus_priv. Do not + * dereference 'priv' after this point -- it may already be freed. + */ + status = wait_event_timeout(bes2600_cdev.probe_done_wq, + !bes2600_cdev.sbus_priv, HZ * 3); + WARN_ON(status <= 0); + + return 0; +} + bool bes2600_chrdev_is_wifi_opened(void) { bool wifi_opened = false; @@ -1184,8 +1226,21 @@ static void bes2600_chrdev_wifi_force_close_work(struct work_struct *work) /* unregister wifi */ bes2600_switch_wifi(0); - /* power down device if wifi is only opened */ - if (bes2600_chrdev_check_system_close()) { + /* + * Hard exception with a bus_reset implementation: tear the + * bus down via mmc_hw_reset() (or equivalent) so the next + * bringup probes a freshly reset chip. On PineTab2 this is + * the only effective recovery path -- the existing + * power_switch(0)/(1) sequence has no chip-reset signal of + * its own (sdio_pwrseq owns wifi_reset). + * + * Soft close, or hard close on a board without bus_reset: + * fall back to the legacy power_switch(0) sequence. + */ + if (bes2600_cdev.halt_dev && bes2600_cdev.sbus_ops->bus_reset) { + bes2600_chrdev_do_bus_reset(bes2600_cdev.sbus_ops, + bes2600_cdev.sbus_priv); + } else if (bes2600_chrdev_check_system_close()) { bes2600_chrdev_do_system_close(bes2600_cdev.sbus_ops, bes2600_cdev.sbus_priv); } diff --git a/bes2600/bes_chardev.h b/bes2600/bes_chardev.h index c627bb7..ca8419e 100644 --- a/bes2600/bes_chardev.h +++ b/bes2600/bes_chardev.h @@ -60,6 +60,7 @@ struct sbus_priv *bes2600_chrdev_get_sbus_priv_data(void); /* used to control device power down */ int bes2600_chrdev_check_system_close(void); int bes2600_chrdev_do_system_close(const struct sbus_ops *sbus_ops, struct sbus_priv *priv); +int bes2600_chrdev_do_bus_reset(const struct sbus_ops *sbus_ops, struct sbus_priv *priv); void bes2600_chrdev_wakeup_bt(void); void bes2600_chrdev_wifi_force_close(struct bes2600_common *hw_priv, bool halt_dev); void bes2600_chrdev_usb_remove(struct bes2600_common *hw_priv); diff --git a/bes2600/sbus.h b/bes2600/sbus.h index 1f2c0cd..cb90890 100644 --- a/bes2600/sbus.h +++ b/bes2600/sbus.h @@ -75,6 +75,14 @@ struct sbus_ops { void (*halt_device)(struct sbus_priv *self); bool (*wakeup_source)(struct sbus_priv *self); int (*reboot)(struct sbus_priv *self); + /* + * Force the host bus to re-detect and re-probe the chip. Called + * from the firmware-wedge recovery path when power_switch() has no + * effective chip-reset signal of its own (e.g. PineTab2, where the + * wifi-reset GPIO is owned by sdio_pwrseq, not the bes2600 node). + * Returns 0 on success or a negative errno. + */ + int (*bus_reset)(struct sbus_priv *self); }; void bes2600_irq_handler(struct bes2600_common *priv);