| /* |
| * linux/drivers/mmc/core/host.c |
| * |
| * Copyright (C) 2003 Russell King, All Rights Reserved. |
| * Copyright (C) 2007-2008 Pierre Ossman |
| * Copyright (C) 2010 Linus Walleij |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License version 2 as |
| * published by the Free Software Foundation. |
| * |
| * MMC host class device management |
| */ |
| |
| #include <linux/device.h> |
| #include <linux/err.h> |
| #include <linux/idr.h> |
| #include <linux/pagemap.h> |
| #include <linux/export.h> |
| #include <linux/leds.h> |
| #include <linux/slab.h> |
| #include <linux/suspend.h> |
| |
| #include <linux/mmc/host.h> |
| #include <linux/mmc/card.h> |
| |
| #include "core.h" |
| #include "host.h" |
| |
| #define cls_dev_to_mmc_host(d) container_of(d, struct mmc_host, class_dev) |
| |
| static void mmc_host_classdev_release(struct device *dev) |
| { |
| struct mmc_host *host = cls_dev_to_mmc_host(dev); |
| mutex_destroy(&host->slot.lock); |
| kfree(host); |
| } |
| |
| static struct class mmc_host_class = { |
| .name = "mmc_host", |
| .dev_release = mmc_host_classdev_release, |
| }; |
| |
| int mmc_register_host_class(void) |
| { |
| return class_register(&mmc_host_class); |
| } |
| |
| void mmc_unregister_host_class(void) |
| { |
| class_unregister(&mmc_host_class); |
| } |
| |
| static DEFINE_IDR(mmc_host_idr); |
| static DEFINE_SPINLOCK(mmc_host_lock); |
| |
| #ifdef CONFIG_MMC_CLKGATE |
| static ssize_t clkgate_delay_show(struct device *dev, |
| struct device_attribute *attr, char *buf) |
| { |
| struct mmc_host *host = cls_dev_to_mmc_host(dev); |
| return snprintf(buf, PAGE_SIZE, "%lu\n", host->clkgate_delay); |
| } |
| |
| static ssize_t clkgate_delay_store(struct device *dev, |
| struct device_attribute *attr, const char *buf, size_t count) |
| { |
| struct mmc_host *host = cls_dev_to_mmc_host(dev); |
| unsigned long flags, value; |
| |
| if (kstrtoul(buf, 0, &value)) |
| return -EINVAL; |
| |
| spin_lock_irqsave(&host->clk_lock, flags); |
| host->clkgate_delay = value; |
| spin_unlock_irqrestore(&host->clk_lock, flags); |
| return count; |
| } |
| |
| /* |
| * Enabling clock gating will make the core call out to the host |
| * once up and once down when it performs a request or card operation |
| * intermingled in any fashion. The driver will see this through |
| * set_ios() operations with ios.clock field set to 0 to gate (disable) |
| * the block clock, and to the old frequency to enable it again. |
| */ |
| static void mmc_host_clk_gate_delayed(struct mmc_host *host) |
| { |
| unsigned long tick_ns; |
| unsigned long freq = host->ios.clock; |
| unsigned long flags; |
| |
| if (!freq) { |
| pr_debug("%s: frequency set to 0 in disable function, " |
| "this means the clock is already disabled.\n", |
| mmc_hostname(host)); |
| return; |
| } |
| /* |
| * New requests may have appeared while we were scheduling, |
| * then there is no reason to delay the check before |
| * clk_disable(). |
| */ |
| spin_lock_irqsave(&host->clk_lock, flags); |
| |
| /* |
| * Delay n bus cycles (at least 8 from MMC spec) before attempting |
| * to disable the MCI block clock. The reference count may have |
| * gone up again after this delay due to rescheduling! |
| */ |
| if (!host->clk_requests) { |
| spin_unlock_irqrestore(&host->clk_lock, flags); |
| tick_ns = DIV_ROUND_UP(1000000000, freq); |
| ndelay(host->clk_delay * tick_ns); |
| } else { |
| /* New users appeared while waiting for this work */ |
| spin_unlock_irqrestore(&host->clk_lock, flags); |
| return; |
| } |
| mutex_lock(&host->clk_gate_mutex); |
| spin_lock_irqsave(&host->clk_lock, flags); |
| if (!host->clk_requests) { |
| spin_unlock_irqrestore(&host->clk_lock, flags); |
| /* This will set host->ios.clock to 0 */ |
| mmc_gate_clock(host); |
| spin_lock_irqsave(&host->clk_lock, flags); |
| pr_debug("%s: gated MCI clock\n", mmc_hostname(host)); |
| } |
| spin_unlock_irqrestore(&host->clk_lock, flags); |
| mutex_unlock(&host->clk_gate_mutex); |
| } |
| |
| /* |
| * Internal work. Work to disable the clock at some later point. |
| */ |
| static void mmc_host_clk_gate_work(struct work_struct *work) |
| { |
| struct mmc_host *host = container_of(work, struct mmc_host, |
| clk_gate_work.work); |
| |
| mmc_host_clk_gate_delayed(host); |
| } |
| |
| /** |
| * mmc_host_clk_hold - ungate hardware MCI clocks |
| * @host: host to ungate. |
| * |
| * Makes sure the host ios.clock is restored to a non-zero value |
| * past this call. Increase clock reference count and ungate clock |
| * if we're the first user. |
| */ |
| void mmc_host_clk_hold(struct mmc_host *host) |
| { |
| unsigned long flags; |
| |
| /* cancel any clock gating work scheduled by mmc_host_clk_release() */ |
| cancel_delayed_work_sync(&host->clk_gate_work); |
| mutex_lock(&host->clk_gate_mutex); |
| spin_lock_irqsave(&host->clk_lock, flags); |
| if (host->clk_gated) { |
| spin_unlock_irqrestore(&host->clk_lock, flags); |
| mmc_ungate_clock(host); |
| spin_lock_irqsave(&host->clk_lock, flags); |
| pr_debug("%s: ungated MCI clock\n", mmc_hostname(host)); |
| } |
| host->clk_requests++; |
| spin_unlock_irqrestore(&host->clk_lock, flags); |
| mutex_unlock(&host->clk_gate_mutex); |
| } |
| |
| /** |
| * mmc_host_may_gate_card - check if this card may be gated |
| * @card: card to check. |
| */ |
| static bool mmc_host_may_gate_card(struct mmc_card *card) |
| { |
| /* If there is no card we may gate it */ |
| if (!card) |
| return true; |
| /* |
| * Don't gate SDIO cards! These need to be clocked at all times |
| * since they may be independent systems generating interrupts |
| * and other events. The clock requests counter from the core will |
| * go down to zero since the core does not need it, but we will not |
| * gate the clock, because there is somebody out there that may still |
| * be using it. |
| */ |
| return !(card->quirks & MMC_QUIRK_BROKEN_CLK_GATING); |
| } |
| |
| /** |
| * mmc_host_clk_release - gate off hardware MCI clocks |
| * @host: host to gate. |
| * |
| * Calls the host driver with ios.clock set to zero as often as possible |
| * in order to gate off hardware MCI clocks. Decrease clock reference |
| * count and schedule disabling of clock. |
| */ |
| void mmc_host_clk_release(struct mmc_host *host) |
| { |
| unsigned long flags; |
| |
| spin_lock_irqsave(&host->clk_lock, flags); |
| host->clk_requests--; |
| if (mmc_host_may_gate_card(host->card) && |
| !host->clk_requests) |
| queue_delayed_work(system_nrt_wq, &host->clk_gate_work, |
| msecs_to_jiffies(host->clkgate_delay)); |
| spin_unlock_irqrestore(&host->clk_lock, flags); |
| } |
| |
| /** |
| * mmc_host_clk_rate - get current clock frequency setting |
| * @host: host to get the clock frequency for. |
| * |
| * Returns current clock frequency regardless of gating. |
| */ |
| unsigned int mmc_host_clk_rate(struct mmc_host *host) |
| { |
| unsigned long freq; |
| unsigned long flags; |
| |
| spin_lock_irqsave(&host->clk_lock, flags); |
| if (host->clk_gated) |
| freq = host->clk_old; |
| else |
| freq = host->ios.clock; |
| spin_unlock_irqrestore(&host->clk_lock, flags); |
| return freq; |
| } |
| |
| /** |
| * mmc_host_clk_init - set up clock gating code |
| * @host: host with potential clock to control |
| */ |
| static inline void mmc_host_clk_init(struct mmc_host *host) |
| { |
| host->clk_requests = 0; |
| /* Hold MCI clock for 8 cycles by default */ |
| host->clk_delay = 8; |
| /* |
| * Default clock gating delay is 0ms to avoid wasting power. |
| * This value can be tuned by writing into sysfs entry. |
| */ |
| host->clkgate_delay = 0; |
| host->clk_gated = false; |
| INIT_DELAYED_WORK(&host->clk_gate_work, mmc_host_clk_gate_work); |
| spin_lock_init(&host->clk_lock); |
| mutex_init(&host->clk_gate_mutex); |
| } |
| |
| /** |
| * mmc_host_clk_exit - shut down clock gating code |
| * @host: host with potential clock to control |
| */ |
| static inline void mmc_host_clk_exit(struct mmc_host *host) |
| { |
| /* |
| * Wait for any outstanding gate and then make sure we're |
| * ungated before exiting. |
| */ |
| if (cancel_delayed_work_sync(&host->clk_gate_work)) |
| mmc_host_clk_gate_delayed(host); |
| if (host->clk_gated) |
| mmc_host_clk_hold(host); |
| /* There should be only one user now */ |
| WARN_ON(host->clk_requests > 1); |
| } |
| |
| static inline void mmc_host_clk_sysfs_init(struct mmc_host *host) |
| { |
| host->clkgate_delay_attr.show = clkgate_delay_show; |
| host->clkgate_delay_attr.store = clkgate_delay_store; |
| sysfs_attr_init(&host->clkgate_delay_attr.attr); |
| host->clkgate_delay_attr.attr.name = "clkgate_delay"; |
| host->clkgate_delay_attr.attr.mode = S_IRUGO | S_IWUSR; |
| if (device_create_file(&host->class_dev, &host->clkgate_delay_attr)) |
| pr_err("%s: Failed to create clkgate_delay sysfs entry\n", |
| mmc_hostname(host)); |
| } |
| #else |
| |
| static inline void mmc_host_clk_init(struct mmc_host *host) |
| { |
| } |
| |
| static inline void mmc_host_clk_exit(struct mmc_host *host) |
| { |
| } |
| |
| static inline void mmc_host_clk_sysfs_init(struct mmc_host *host) |
| { |
| } |
| |
| #endif |
| |
| /** |
| * mmc_alloc_host - initialise the per-host structure. |
| * @extra: sizeof private data structure |
| * @dev: pointer to host device model structure |
| * |
| * Initialise the per-host structure. |
| */ |
| struct mmc_host *mmc_alloc_host(int extra, struct device *dev) |
| { |
| int err; |
| struct mmc_host *host; |
| |
| if (!idr_pre_get(&mmc_host_idr, GFP_KERNEL)) |
| return NULL; |
| |
| host = kzalloc(sizeof(struct mmc_host) + extra, GFP_KERNEL); |
| if (!host) |
| return NULL; |
| |
| /* scanning will be enabled when we're ready */ |
| host->rescan_disable = 1; |
| spin_lock(&mmc_host_lock); |
| err = idr_get_new(&mmc_host_idr, host, &host->index); |
| spin_unlock(&mmc_host_lock); |
| if (err) |
| goto free; |
| |
| dev_set_name(&host->class_dev, "mmc%d", host->index); |
| |
| host->parent = dev; |
| host->class_dev.parent = dev; |
| host->class_dev.class = &mmc_host_class; |
| device_initialize(&host->class_dev); |
| |
| mmc_host_clk_init(host); |
| |
| mutex_init(&host->slot.lock); |
| host->slot.cd_irq = -EINVAL; |
| |
| spin_lock_init(&host->lock); |
| init_waitqueue_head(&host->wq); |
| INIT_DELAYED_WORK(&host->detect, mmc_rescan); |
| #ifdef CONFIG_PM |
| host->pm_notify.notifier_call = mmc_pm_notify; |
| #endif |
| |
| /* |
| * By default, hosts do not support SGIO or large requests. |
| * They have to set these according to their abilities. |
| */ |
| host->max_segs = 1; |
| host->max_seg_size = PAGE_CACHE_SIZE; |
| |
| host->max_req_size = PAGE_CACHE_SIZE; |
| host->max_blk_size = 512; |
| host->max_blk_count = PAGE_CACHE_SIZE / 512; |
| |
| return host; |
| |
| free: |
| kfree(host); |
| return NULL; |
| } |
| |
| EXPORT_SYMBOL(mmc_alloc_host); |
| |
| /** |
| * mmc_add_host - initialise host hardware |
| * @host: mmc host |
| * |
| * Register the host with the driver model. The host must be |
| * prepared to start servicing requests before this function |
| * completes. |
| */ |
| int mmc_add_host(struct mmc_host *host) |
| { |
| int err; |
| |
| WARN_ON((host->caps & MMC_CAP_SDIO_IRQ) && |
| !host->ops->enable_sdio_irq); |
| |
| err = device_add(&host->class_dev); |
| if (err) |
| return err; |
| |
| led_trigger_register_simple(dev_name(&host->class_dev), &host->led); |
| |
| #ifdef CONFIG_DEBUG_FS |
| mmc_add_host_debugfs(host); |
| #endif |
| mmc_host_clk_sysfs_init(host); |
| |
| mmc_start_host(host); |
| register_pm_notifier(&host->pm_notify); |
| |
| return 0; |
| } |
| |
| EXPORT_SYMBOL(mmc_add_host); |
| |
| /** |
| * mmc_remove_host - remove host hardware |
| * @host: mmc host |
| * |
| * Unregister and remove all cards associated with this host, |
| * and power down the MMC bus. No new requests will be issued |
| * after this function has returned. |
| */ |
| void mmc_remove_host(struct mmc_host *host) |
| { |
| unregister_pm_notifier(&host->pm_notify); |
| mmc_stop_host(host); |
| |
| #ifdef CONFIG_DEBUG_FS |
| mmc_remove_host_debugfs(host); |
| #endif |
| |
| device_del(&host->class_dev); |
| |
| led_trigger_unregister_simple(host->led); |
| |
| mmc_host_clk_exit(host); |
| } |
| |
| EXPORT_SYMBOL(mmc_remove_host); |
| |
| /** |
| * mmc_free_host - free the host structure |
| * @host: mmc host |
| * |
| * Free the host once all references to it have been dropped. |
| */ |
| void mmc_free_host(struct mmc_host *host) |
| { |
| spin_lock(&mmc_host_lock); |
| idr_remove(&mmc_host_idr, host->index); |
| spin_unlock(&mmc_host_lock); |
| |
| put_device(&host->class_dev); |
| } |
| |
| EXPORT_SYMBOL(mmc_free_host); |