sdiodev->txglomsz = sdiodev->settings->bus.sdio.txglomsz;
 }
 
-#ifdef CONFIG_PM_SLEEP
 static int brcmf_sdiod_freezer_attach(struct brcmf_sdio_dev *sdiodev)
 {
+       if (!IS_ENABLED(CONFIG_PM_SLEEP))
+               return 0;
+
        sdiodev->freezer = kzalloc(sizeof(*sdiodev->freezer), GFP_KERNEL);
        if (!sdiodev->freezer)
                return -ENOMEM;
 
 bool brcmf_sdiod_freezing(struct brcmf_sdio_dev *sdiodev)
 {
-       return atomic_read(&sdiodev->freezer->freezing);
+       return IS_ENABLED(CONFIG_PM_SLEEP) &&
+               atomic_read(&sdiodev->freezer->freezing);
 }
 
 void brcmf_sdiod_try_freeze(struct brcmf_sdio_dev *sdiodev)
 
 void brcmf_sdiod_freezer_count(struct brcmf_sdio_dev *sdiodev)
 {
-       atomic_inc(&sdiodev->freezer->thread_count);
+       if (IS_ENABLED(CONFIG_PM_SLEEP))
+               atomic_inc(&sdiodev->freezer->thread_count);
 }
 
 void brcmf_sdiod_freezer_uncount(struct brcmf_sdio_dev *sdiodev)
 {
-       atomic_dec(&sdiodev->freezer->thread_count);
-}
-#else
-static int brcmf_sdiod_freezer_attach(struct brcmf_sdio_dev *sdiodev)
-{
-       return 0;
+       if (IS_ENABLED(CONFIG_PM_SLEEP))
+               atomic_dec(&sdiodev->freezer->thread_count);
 }
 
-static void brcmf_sdiod_freezer_detach(struct brcmf_sdio_dev *sdiodev)
-{
-}
-#endif /* CONFIG_PM_SLEEP */
-
 int brcmf_sdiod_remove(struct brcmf_sdio_dev *sdiodev)
 {
        sdiodev->state = BRCMF_SDIOD_DOWN;
        brcmf_dbg(SDIO, "WOWL not supported\n");
 }
 
-#ifdef CONFIG_PM_SLEEP
 static int brcmf_ops_sdio_suspend(struct device *dev)
 {
        struct sdio_func *func;
        return ret;
 }
 
-static const struct dev_pm_ops brcmf_sdio_pm_ops = {
-       .suspend        = brcmf_ops_sdio_suspend,
-       .resume         = brcmf_ops_sdio_resume,
-};
-#endif /* CONFIG_PM_SLEEP */
+static DEFINE_SIMPLE_DEV_PM_OPS(brcmf_sdio_pm_ops,
+                               brcmf_ops_sdio_suspend,
+                               brcmf_ops_sdio_resume);
 
 static struct sdio_driver brcmf_sdmmc_driver = {
        .probe = brcmf_ops_sdio_probe,
        .id_table = brcmf_sdmmc_ids,
        .drv = {
                .owner = THIS_MODULE,
-#ifdef CONFIG_PM_SLEEP
-               .pm = &brcmf_sdio_pm_ops,
-#endif /* CONFIG_PM_SLEEP */
+               .pm = pm_sleep_ptr(&brcmf_sdio_pm_ops),
                .coredump = brcmf_dev_coredump,
        },
 };
 
         */
        brcmf_sdiod_sgtable_alloc(sdiodev);
 
-#ifdef CONFIG_PM_SLEEP
        /* wowl can be supported when KEEP_POWER is true and (WAKE_SDIO_IRQ
         * is true or when platform data OOB irq is true).
         */
-       if ((sdio_get_host_pm_caps(sdiodev->func1) & MMC_PM_KEEP_POWER) &&
+       if (IS_ENABLED(CONFIG_PM_SLEEP) &&
+           (sdio_get_host_pm_caps(sdiodev->func1) & MMC_PM_KEEP_POWER) &&
            ((sdio_get_host_pm_caps(sdiodev->func1) & MMC_PM_WAKE_SDIO_IRQ) ||
             (sdiodev->settings->bus.sdio.oob_irq_supported)))
                sdiodev->bus_if->wowl_supported = true;
-#endif
 
        if (brcmf_sdio_kso_init(bus)) {
                brcmf_err("error enabling KSO\n");
 
 void brcmf_sdiod_sgtable_alloc(struct brcmf_sdio_dev *sdiodev);
 void brcmf_sdiod_change_state(struct brcmf_sdio_dev *sdiodev,
                              enum brcmf_sdiod_state state);
-#ifdef CONFIG_PM_SLEEP
 bool brcmf_sdiod_freezing(struct brcmf_sdio_dev *sdiodev);
 void brcmf_sdiod_try_freeze(struct brcmf_sdio_dev *sdiodev);
 void brcmf_sdiod_freezer_count(struct brcmf_sdio_dev *sdiodev);
 void brcmf_sdiod_freezer_uncount(struct brcmf_sdio_dev *sdiodev);
-#else
-static inline bool brcmf_sdiod_freezing(struct brcmf_sdio_dev *sdiodev)
-{
-       return false;
-}
-static inline void brcmf_sdiod_try_freeze(struct brcmf_sdio_dev *sdiodev)
-{
-}
-static inline void brcmf_sdiod_freezer_count(struct brcmf_sdio_dev *sdiodev)
-{
-}
-static inline void brcmf_sdiod_freezer_uncount(struct brcmf_sdio_dev *sdiodev)
-{
-}
-#endif /* CONFIG_PM_SLEEP */
 
 int brcmf_sdiod_probe(struct brcmf_sdio_dev *sdiodev);
 int brcmf_sdiod_remove(struct brcmf_sdio_dev *sdiodev);