LCOV - code coverage report
Current view: top level - drivers/mmc/core - host.c (source / functions) Hit Total Coverage
Test: Real Lines: 121 222 54.5 %
Date: 2020-10-17 15:46:16 Functions: 0 18 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-only
       2                 :            : /*
       3                 :            :  *  linux/drivers/mmc/core/host.c
       4                 :            :  *
       5                 :            :  *  Copyright (C) 2003 Russell King, All Rights Reserved.
       6                 :            :  *  Copyright (C) 2007-2008 Pierre Ossman
       7                 :            :  *  Copyright (C) 2010 Linus Walleij
       8                 :            :  *
       9                 :            :  *  MMC host class device management
      10                 :            :  */
      11                 :            : 
      12                 :            : #include <linux/device.h>
      13                 :            : #include <linux/err.h>
      14                 :            : #include <linux/idr.h>
      15                 :            : #include <linux/of.h>
      16                 :            : #include <linux/of_gpio.h>
      17                 :            : #include <linux/pagemap.h>
      18                 :            : #include <linux/export.h>
      19                 :            : #include <linux/leds.h>
      20                 :            : #include <linux/slab.h>
      21                 :            : 
      22                 :            : #include <linux/mmc/host.h>
      23                 :            : #include <linux/mmc/card.h>
      24                 :            : #include <linux/mmc/slot-gpio.h>
      25                 :            : 
      26                 :            : #include "core.h"
      27                 :            : #include "host.h"
      28                 :            : #include "slot-gpio.h"
      29                 :            : #include "pwrseq.h"
      30                 :            : #include "sdio_ops.h"
      31                 :            : 
      32                 :            : #define cls_dev_to_mmc_host(d)  container_of(d, struct mmc_host, class_dev)
      33                 :            : 
      34                 :            : static DEFINE_IDA(mmc_host_ida);
      35                 :            : 
      36                 :          3 : static void mmc_host_classdev_release(struct device *dev)
      37                 :            : {
      38                 :          3 :         struct mmc_host *host = cls_dev_to_mmc_host(dev);
      39                 :          3 :         ida_simple_remove(&mmc_host_ida, host->index);
      40                 :          3 :         kfree(host);
      41                 :          3 : }
      42                 :            : 
      43                 :            : static struct class mmc_host_class = {
      44                 :            :         .name           = "mmc_host",
      45                 :            :         .dev_release    = mmc_host_classdev_release,
      46                 :            : };
      47                 :            : 
      48                 :          3 : int mmc_register_host_class(void)
      49                 :            : {
      50                 :          3 :         return class_register(&mmc_host_class);
      51                 :            : }
      52                 :            : 
      53                 :          0 : void mmc_unregister_host_class(void)
      54                 :            : {
      55                 :          0 :         class_unregister(&mmc_host_class);
      56                 :          0 : }
      57                 :            : 
      58                 :          0 : void mmc_retune_enable(struct mmc_host *host)
      59                 :            : {
      60                 :          0 :         host->can_retune = 1;
      61                 :          0 :         if (host->retune_period)
      62                 :          0 :                 mod_timer(&host->retune_timer,
      63                 :          0 :                           jiffies + host->retune_period * HZ);
      64                 :          0 : }
      65                 :            : 
      66                 :            : /*
      67                 :            :  * Pause re-tuning for a small set of operations.  The pause begins after the
      68                 :            :  * next command and after first doing re-tuning.
      69                 :            :  */
      70                 :          0 : void mmc_retune_pause(struct mmc_host *host)
      71                 :            : {
      72                 :          0 :         if (!host->retune_paused) {
      73                 :          0 :                 host->retune_paused = 1;
      74                 :            :                 mmc_retune_needed(host);
      75                 :            :                 mmc_retune_hold(host);
      76                 :            :         }
      77                 :          0 : }
      78                 :            : EXPORT_SYMBOL(mmc_retune_pause);
      79                 :            : 
      80                 :          0 : void mmc_retune_unpause(struct mmc_host *host)
      81                 :            : {
      82                 :          3 :         if (host->retune_paused) {
      83                 :          0 :                 host->retune_paused = 0;
      84                 :          0 :                 mmc_retune_release(host);
      85                 :            :         }
      86                 :          0 : }
      87                 :            : EXPORT_SYMBOL(mmc_retune_unpause);
      88                 :            : 
      89                 :          3 : void mmc_retune_disable(struct mmc_host *host)
      90                 :            : {
      91                 :            :         mmc_retune_unpause(host);
      92                 :          3 :         host->can_retune = 0;
      93                 :          3 :         del_timer_sync(&host->retune_timer);
      94                 :          3 :         host->retune_now = 0;
      95                 :          3 :         host->need_retune = 0;
      96                 :          3 : }
      97                 :            : 
      98                 :          0 : void mmc_retune_timer_stop(struct mmc_host *host)
      99                 :            : {
     100                 :          0 :         del_timer_sync(&host->retune_timer);
     101                 :          0 : }
     102                 :            : EXPORT_SYMBOL(mmc_retune_timer_stop);
     103                 :            : 
     104                 :          3 : void mmc_retune_hold(struct mmc_host *host)
     105                 :            : {
     106                 :          3 :         if (!host->hold_retune)
     107                 :          3 :                 host->retune_now = 1;
     108                 :          3 :         host->hold_retune += 1;
     109                 :          3 : }
     110                 :            : 
     111                 :          3 : void mmc_retune_release(struct mmc_host *host)
     112                 :            : {
     113                 :          3 :         if (host->hold_retune)
     114                 :          3 :                 host->hold_retune -= 1;
     115                 :            :         else
     116                 :          0 :                 WARN_ON(1);
     117                 :          3 : }
     118                 :            : EXPORT_SYMBOL(mmc_retune_release);
     119                 :            : 
     120                 :          3 : int mmc_retune(struct mmc_host *host)
     121                 :            : {
     122                 :            :         bool return_to_hs400 = false;
     123                 :            :         int err;
     124                 :            : 
     125                 :          3 :         if (host->retune_now)
     126                 :          3 :                 host->retune_now = 0;
     127                 :            :         else
     128                 :            :                 return 0;
     129                 :            : 
     130                 :          3 :         if (!host->need_retune || host->doing_retune || !host->card)
     131                 :            :                 return 0;
     132                 :            : 
     133                 :          0 :         host->need_retune = 0;
     134                 :            : 
     135                 :          0 :         host->doing_retune = 1;
     136                 :            : 
     137                 :          0 :         if (host->ios.timing == MMC_TIMING_MMC_HS400) {
     138                 :          0 :                 err = mmc_hs400_to_hs200(host->card);
     139                 :          0 :                 if (err)
     140                 :            :                         goto out;
     141                 :            : 
     142                 :            :                 return_to_hs400 = true;
     143                 :            :         }
     144                 :            : 
     145                 :          0 :         err = mmc_execute_tuning(host->card);
     146                 :          0 :         if (err)
     147                 :            :                 goto out;
     148                 :            : 
     149                 :          0 :         if (return_to_hs400)
     150                 :          0 :                 err = mmc_hs200_to_hs400(host->card);
     151                 :            : out:
     152                 :          0 :         host->doing_retune = 0;
     153                 :            : 
     154                 :          0 :         return err;
     155                 :            : }
     156                 :            : 
     157                 :          0 : static void mmc_retune_timer(struct timer_list *t)
     158                 :            : {
     159                 :            :         struct mmc_host *host = from_timer(host, t, retune_timer);
     160                 :            : 
     161                 :            :         mmc_retune_needed(host);
     162                 :          0 : }
     163                 :            : 
     164                 :            : /**
     165                 :            :  *      mmc_of_parse() - parse host's device-tree node
     166                 :            :  *      @host: host whose node should be parsed.
     167                 :            :  *
     168                 :            :  * To keep the rest of the MMC subsystem unaware of whether DT has been
     169                 :            :  * used to to instantiate and configure this host instance or not, we
     170                 :            :  * parse the properties and set respective generic mmc-host flags and
     171                 :            :  * parameters.
     172                 :            :  */
     173                 :          3 : int mmc_of_parse(struct mmc_host *host)
     174                 :            : {
     175                 :          3 :         struct device *dev = host->parent;
     176                 :            :         u32 bus_width, drv_type, cd_debounce_delay_ms;
     177                 :            :         int ret;
     178                 :          3 :         bool cd_cap_invert, cd_gpio_invert = false;
     179                 :            : 
     180                 :          3 :         if (!dev || !dev_fwnode(dev))
     181                 :            :                 return 0;
     182                 :            : 
     183                 :            :         /* "bus-width" is translated to MMC_CAP_*_BIT_DATA flags */
     184                 :          3 :         if (device_property_read_u32(dev, "bus-width", &bus_width) < 0) {
     185                 :            :                 dev_dbg(host->parent,
     186                 :            :                         "\"bus-width\" property is missing, assuming 1 bit.\n");
     187                 :          0 :                 bus_width = 1;
     188                 :            :         }
     189                 :            : 
     190                 :          3 :         switch (bus_width) {
     191                 :            :         case 8:
     192                 :          0 :                 host->caps |= MMC_CAP_8_BIT_DATA;
     193                 :            :                 /* fall through - Hosts capable of 8-bit can also do 4 bits */
     194                 :            :         case 4:
     195                 :          3 :                 host->caps |= MMC_CAP_4_BIT_DATA;
     196                 :          3 :                 break;
     197                 :            :         case 1:
     198                 :            :                 break;
     199                 :            :         default:
     200                 :          0 :                 dev_err(host->parent,
     201                 :            :                         "Invalid \"bus-width\" value %u!\n", bus_width);
     202                 :          0 :                 return -EINVAL;
     203                 :            :         }
     204                 :            : 
     205                 :            :         /* f_max is obtained from the optional "max-frequency" property */
     206                 :          3 :         device_property_read_u32(dev, "max-frequency", &host->f_max);
     207                 :            : 
     208                 :            :         /*
     209                 :            :          * Configure CD and WP pins. They are both by default active low to
     210                 :            :          * match the SDHCI spec. If GPIOs are provided for CD and / or WP, the
     211                 :            :          * mmc-gpio helpers are used to attach, configure and use them. If
     212                 :            :          * polarity inversion is specified in DT, one of MMC_CAP2_CD_ACTIVE_HIGH
     213                 :            :          * and MMC_CAP2_RO_ACTIVE_HIGH capability-2 flags is set. If the
     214                 :            :          * "broken-cd" property is provided, the MMC_CAP_NEEDS_POLL capability
     215                 :            :          * is set. If the "non-removable" property is found, the
     216                 :            :          * MMC_CAP_NONREMOVABLE capability is set and no card-detection
     217                 :            :          * configuration is performed.
     218                 :            :          */
     219                 :            : 
     220                 :            :         /* Parse Card Detection */
     221                 :          3 :         if (device_property_read_bool(dev, "non-removable")) {
     222                 :          0 :                 host->caps |= MMC_CAP_NONREMOVABLE;
     223                 :            :         } else {
     224                 :            :                 cd_cap_invert = device_property_read_bool(dev, "cd-inverted");
     225                 :            : 
     226                 :          3 :                 if (device_property_read_u32(dev, "cd-debounce-delay-ms",
     227                 :            :                                              &cd_debounce_delay_ms))
     228                 :          3 :                         cd_debounce_delay_ms = 200;
     229                 :            : 
     230                 :          3 :                 if (device_property_read_bool(dev, "broken-cd"))
     231                 :          0 :                         host->caps |= MMC_CAP_NEEDS_POLL;
     232                 :            : 
     233                 :          3 :                 ret = mmc_gpiod_request_cd(host, "cd", 0, false,
     234                 :            :                                            cd_debounce_delay_ms * 1000,
     235                 :            :                                            &cd_gpio_invert);
     236                 :          3 :                 if (!ret)
     237                 :          0 :                         dev_info(host->parent, "Got CD GPIO\n");
     238                 :          3 :                 else if (ret != -ENOENT && ret != -ENOSYS)
     239                 :            :                         return ret;
     240                 :            : 
     241                 :            :                 /*
     242                 :            :                  * There are two ways to flag that the CD line is inverted:
     243                 :            :                  * through the cd-inverted flag and by the GPIO line itself
     244                 :            :                  * being inverted from the GPIO subsystem. This is a leftover
     245                 :            :                  * from the times when the GPIO subsystem did not make it
     246                 :            :                  * possible to flag a line as inverted.
     247                 :            :                  *
     248                 :            :                  * If the capability on the host AND the GPIO line are
     249                 :            :                  * both inverted, the end result is that the CD line is
     250                 :            :                  * not inverted.
     251                 :            :                  */
     252                 :          3 :                 if (cd_cap_invert ^ cd_gpio_invert)
     253                 :          0 :                         host->caps2 |= MMC_CAP2_CD_ACTIVE_HIGH;
     254                 :            :         }
     255                 :            : 
     256                 :            :         /* Parse Write Protection */
     257                 :            : 
     258                 :          3 :         if (device_property_read_bool(dev, "wp-inverted"))
     259                 :          0 :                 host->caps2 |= MMC_CAP2_RO_ACTIVE_HIGH;
     260                 :            : 
     261                 :          3 :         ret = mmc_gpiod_request_ro(host, "wp", 0, 0, NULL);
     262                 :          3 :         if (!ret)
     263                 :          0 :                 dev_info(host->parent, "Got WP GPIO\n");
     264                 :          3 :         else if (ret != -ENOENT && ret != -ENOSYS)
     265                 :            :                 return ret;
     266                 :            : 
     267                 :          3 :         if (device_property_read_bool(dev, "disable-wp"))
     268                 :          0 :                 host->caps2 |= MMC_CAP2_NO_WRITE_PROTECT;
     269                 :            : 
     270                 :          3 :         if (device_property_read_bool(dev, "cap-sd-highspeed"))
     271                 :          0 :                 host->caps |= MMC_CAP_SD_HIGHSPEED;
     272                 :          3 :         if (device_property_read_bool(dev, "cap-mmc-highspeed"))
     273                 :          0 :                 host->caps |= MMC_CAP_MMC_HIGHSPEED;
     274                 :          3 :         if (device_property_read_bool(dev, "sd-uhs-sdr12"))
     275                 :          0 :                 host->caps |= MMC_CAP_UHS_SDR12;
     276                 :          3 :         if (device_property_read_bool(dev, "sd-uhs-sdr25"))
     277                 :          0 :                 host->caps |= MMC_CAP_UHS_SDR25;
     278                 :          3 :         if (device_property_read_bool(dev, "sd-uhs-sdr50"))
     279                 :          0 :                 host->caps |= MMC_CAP_UHS_SDR50;
     280                 :          3 :         if (device_property_read_bool(dev, "sd-uhs-sdr104"))
     281                 :          0 :                 host->caps |= MMC_CAP_UHS_SDR104;
     282                 :          3 :         if (device_property_read_bool(dev, "sd-uhs-ddr50"))
     283                 :          0 :                 host->caps |= MMC_CAP_UHS_DDR50;
     284                 :          3 :         if (device_property_read_bool(dev, "cap-power-off-card"))
     285                 :          0 :                 host->caps |= MMC_CAP_POWER_OFF_CARD;
     286                 :          3 :         if (device_property_read_bool(dev, "cap-mmc-hw-reset"))
     287                 :          0 :                 host->caps |= MMC_CAP_HW_RESET;
     288                 :          3 :         if (device_property_read_bool(dev, "cap-sdio-irq"))
     289                 :          0 :                 host->caps |= MMC_CAP_SDIO_IRQ;
     290                 :          3 :         if (device_property_read_bool(dev, "full-pwr-cycle"))
     291                 :          0 :                 host->caps2 |= MMC_CAP2_FULL_PWR_CYCLE;
     292                 :          3 :         if (device_property_read_bool(dev, "keep-power-in-suspend"))
     293                 :          0 :                 host->pm_caps |= MMC_PM_KEEP_POWER;
     294                 :          3 :         if (device_property_read_bool(dev, "wakeup-source") ||
     295                 :            :             device_property_read_bool(dev, "enable-sdio-wakeup")) /* legacy */
     296                 :          0 :                 host->pm_caps |= MMC_PM_WAKE_SDIO_IRQ;
     297                 :          3 :         if (device_property_read_bool(dev, "mmc-ddr-3_3v"))
     298                 :          0 :                 host->caps |= MMC_CAP_3_3V_DDR;
     299                 :          3 :         if (device_property_read_bool(dev, "mmc-ddr-1_8v"))
     300                 :          0 :                 host->caps |= MMC_CAP_1_8V_DDR;
     301                 :          3 :         if (device_property_read_bool(dev, "mmc-ddr-1_2v"))
     302                 :          0 :                 host->caps |= MMC_CAP_1_2V_DDR;
     303                 :          3 :         if (device_property_read_bool(dev, "mmc-hs200-1_8v"))
     304                 :          0 :                 host->caps2 |= MMC_CAP2_HS200_1_8V_SDR;
     305                 :          3 :         if (device_property_read_bool(dev, "mmc-hs200-1_2v"))
     306                 :          0 :                 host->caps2 |= MMC_CAP2_HS200_1_2V_SDR;
     307                 :          3 :         if (device_property_read_bool(dev, "mmc-hs400-1_8v"))
     308                 :          0 :                 host->caps2 |= MMC_CAP2_HS400_1_8V | MMC_CAP2_HS200_1_8V_SDR;
     309                 :          3 :         if (device_property_read_bool(dev, "mmc-hs400-1_2v"))
     310                 :          0 :                 host->caps2 |= MMC_CAP2_HS400_1_2V | MMC_CAP2_HS200_1_2V_SDR;
     311                 :          3 :         if (device_property_read_bool(dev, "mmc-hs400-enhanced-strobe"))
     312                 :          0 :                 host->caps2 |= MMC_CAP2_HS400_ES;
     313                 :          3 :         if (device_property_read_bool(dev, "no-sdio"))
     314                 :          0 :                 host->caps2 |= MMC_CAP2_NO_SDIO;
     315                 :          3 :         if (device_property_read_bool(dev, "no-sd"))
     316                 :          0 :                 host->caps2 |= MMC_CAP2_NO_SD;
     317                 :          3 :         if (device_property_read_bool(dev, "no-mmc"))
     318                 :          0 :                 host->caps2 |= MMC_CAP2_NO_MMC;
     319                 :            : 
     320                 :            :         /* Must be after "non-removable" check */
     321                 :          3 :         if (device_property_read_u32(dev, "fixed-emmc-driver-type", &drv_type) == 0) {
     322                 :          0 :                 if (host->caps & MMC_CAP_NONREMOVABLE)
     323                 :          0 :                         host->fixed_drv_type = drv_type;
     324                 :            :                 else
     325                 :          0 :                         dev_err(host->parent,
     326                 :            :                                 "can't use fixed driver type, media is removable\n");
     327                 :            :         }
     328                 :            : 
     329                 :          3 :         host->dsr_req = !device_property_read_u32(dev, "dsr", &host->dsr);
     330                 :          3 :         if (host->dsr_req && (host->dsr & ~0xffff)) {
     331                 :          0 :                 dev_err(host->parent,
     332                 :            :                         "device tree specified broken value for DSR: 0x%x, ignoring\n",
     333                 :            :                         host->dsr);
     334                 :          0 :                 host->dsr_req = 0;
     335                 :            :         }
     336                 :            : 
     337                 :            :         device_property_read_u32(dev, "post-power-on-delay-ms",
     338                 :          3 :                                  &host->ios.power_delay_ms);
     339                 :            : 
     340                 :          3 :         return mmc_pwrseq_alloc(host);
     341                 :            : }
     342                 :            : 
     343                 :            : EXPORT_SYMBOL(mmc_of_parse);
     344                 :            : 
     345                 :            : /**
     346                 :            :  * mmc_of_parse_voltage - return mask of supported voltages
     347                 :            :  * @np: The device node need to be parsed.
     348                 :            :  * @mask: mask of voltages available for MMC/SD/SDIO
     349                 :            :  *
     350                 :            :  * Parse the "voltage-ranges" DT property, returning zero if it is not
     351                 :            :  * found, negative errno if the voltage-range specification is invalid,
     352                 :            :  * or one if the voltage-range is specified and successfully parsed.
     353                 :            :  */
     354                 :          0 : int mmc_of_parse_voltage(struct device_node *np, u32 *mask)
     355                 :            : {
     356                 :            :         const u32 *voltage_ranges;
     357                 :            :         int num_ranges, i;
     358                 :            : 
     359                 :          0 :         voltage_ranges = of_get_property(np, "voltage-ranges", &num_ranges);
     360                 :          0 :         if (!voltage_ranges) {
     361                 :            :                 pr_debug("%pOF: voltage-ranges unspecified\n", np);
     362                 :            :                 return 0;
     363                 :            :         }
     364                 :          0 :         num_ranges = num_ranges / sizeof(*voltage_ranges) / 2;
     365                 :          0 :         if (!num_ranges) {
     366                 :          0 :                 pr_err("%pOF: voltage-ranges empty\n", np);
     367                 :          0 :                 return -EINVAL;
     368                 :            :         }
     369                 :            : 
     370                 :          0 :         for (i = 0; i < num_ranges; i++) {
     371                 :          0 :                 const int j = i * 2;
     372                 :            :                 u32 ocr_mask;
     373                 :            : 
     374                 :          0 :                 ocr_mask = mmc_vddrange_to_ocrmask(
     375                 :          0 :                                 be32_to_cpu(voltage_ranges[j]),
     376                 :          0 :                                 be32_to_cpu(voltage_ranges[j + 1]));
     377                 :          0 :                 if (!ocr_mask) {
     378                 :          0 :                         pr_err("%pOF: voltage-range #%d is invalid\n",
     379                 :            :                                 np, i);
     380                 :          0 :                         return -EINVAL;
     381                 :            :                 }
     382                 :          0 :                 *mask |= ocr_mask;
     383                 :            :         }
     384                 :            : 
     385                 :            :         return 1;
     386                 :            : }
     387                 :            : EXPORT_SYMBOL(mmc_of_parse_voltage);
     388                 :            : 
     389                 :            : /**
     390                 :            :  *      mmc_alloc_host - initialise the per-host structure.
     391                 :            :  *      @extra: sizeof private data structure
     392                 :            :  *      @dev: pointer to host device model structure
     393                 :            :  *
     394                 :            :  *      Initialise the per-host structure.
     395                 :            :  */
     396                 :          3 : struct mmc_host *mmc_alloc_host(int extra, struct device *dev)
     397                 :            : {
     398                 :            :         int err;
     399                 :            :         struct mmc_host *host;
     400                 :            :         int id;
     401                 :            : 
     402                 :          3 :         host = kzalloc(sizeof(struct mmc_host) + extra, GFP_KERNEL);
     403                 :          3 :         if (!host)
     404                 :            :                 return NULL;
     405                 :            : 
     406                 :            :         /* If OF aliases exist, start dynamic assignment after highest */
     407                 :          3 :         id = of_alias_get_highest_id("mmc");
     408                 :          3 :         id = (id < 0) ? 0 : id + 1;
     409                 :            : 
     410                 :            :         /* If this devices has OF node, maybe it has an alias */
     411                 :          3 :         if (dev->of_node) {
     412                 :          3 :                 int of_id = of_alias_get_id(dev->of_node, "mmc");
     413                 :            : 
     414                 :          3 :                 if (of_id < 0)
     415                 :          0 :                         dev_warn(dev, "/aliases ID not available\n");
     416                 :            :                 else
     417                 :            :                         id = of_id;
     418                 :            :         }
     419                 :            : 
     420                 :            :         /* scanning will be enabled when we're ready */
     421                 :          3 :         host->rescan_disable = 1;
     422                 :            : 
     423                 :          3 :         err = ida_simple_get(&mmc_host_ida, id, 0, GFP_KERNEL);
     424                 :          3 :         if (err < 0) {
     425                 :          0 :                 kfree(host);
     426                 :          0 :                 return NULL;
     427                 :            :         }
     428                 :            : 
     429                 :          3 :         host->index = err;
     430                 :            : 
     431                 :          3 :         dev_set_name(&host->class_dev, "mmc%d", host->index);
     432                 :            : 
     433                 :          3 :         host->parent = dev;
     434                 :          3 :         host->class_dev.parent = dev;
     435                 :          3 :         host->class_dev.class = &mmc_host_class;
     436                 :          3 :         device_initialize(&host->class_dev);
     437                 :            :         device_enable_async_suspend(&host->class_dev);
     438                 :            : 
     439                 :          3 :         if (mmc_gpio_alloc(host)) {
     440                 :          0 :                 put_device(&host->class_dev);
     441                 :          0 :                 return NULL;
     442                 :            :         }
     443                 :            : 
     444                 :          3 :         spin_lock_init(&host->lock);
     445                 :          3 :         init_waitqueue_head(&host->wq);
     446                 :          3 :         INIT_DELAYED_WORK(&host->detect, mmc_rescan);
     447                 :          3 :         INIT_DELAYED_WORK(&host->sdio_irq_work, sdio_irq_work);
     448                 :          3 :         timer_setup(&host->retune_timer, mmc_retune_timer, 0);
     449                 :            : 
     450                 :            :         /*
     451                 :            :          * By default, hosts do not support SGIO or large requests.
     452                 :            :          * They have to set these according to their abilities.
     453                 :            :          */
     454                 :          3 :         host->max_segs = 1;
     455                 :          3 :         host->max_seg_size = PAGE_SIZE;
     456                 :            : 
     457                 :          3 :         host->max_req_size = PAGE_SIZE;
     458                 :          3 :         host->max_blk_size = 512;
     459                 :          3 :         host->max_blk_count = PAGE_SIZE / 512;
     460                 :            : 
     461                 :          3 :         host->fixed_drv_type = -EINVAL;
     462                 :          3 :         host->ios.power_delay_ms = 10;
     463                 :            : 
     464                 :          3 :         return host;
     465                 :            : }
     466                 :            : 
     467                 :            : EXPORT_SYMBOL(mmc_alloc_host);
     468                 :            : 
     469                 :            : /**
     470                 :            :  *      mmc_add_host - initialise host hardware
     471                 :            :  *      @host: mmc host
     472                 :            :  *
     473                 :            :  *      Register the host with the driver model. The host must be
     474                 :            :  *      prepared to start servicing requests before this function
     475                 :            :  *      completes.
     476                 :            :  */
     477                 :          3 : int mmc_add_host(struct mmc_host *host)
     478                 :            : {
     479                 :            :         int err;
     480                 :            : 
     481                 :          3 :         WARN_ON((host->caps & MMC_CAP_SDIO_IRQ) &&
     482                 :            :                 !host->ops->enable_sdio_irq);
     483                 :            : 
     484                 :          3 :         err = device_add(&host->class_dev);
     485                 :          3 :         if (err)
     486                 :            :                 return err;
     487                 :            : 
     488                 :          3 :         led_trigger_register_simple(dev_name(&host->class_dev), &host->led);
     489                 :            : 
     490                 :            : #ifdef CONFIG_DEBUG_FS
     491                 :          3 :         mmc_add_host_debugfs(host);
     492                 :            : #endif
     493                 :            : 
     494                 :          3 :         mmc_start_host(host);
     495                 :            :         mmc_register_pm_notifier(host);
     496                 :            : 
     497                 :          3 :         return 0;
     498                 :            : }
     499                 :            : 
     500                 :            : EXPORT_SYMBOL(mmc_add_host);
     501                 :            : 
     502                 :            : /**
     503                 :            :  *      mmc_remove_host - remove host hardware
     504                 :            :  *      @host: mmc host
     505                 :            :  *
     506                 :            :  *      Unregister and remove all cards associated with this host,
     507                 :            :  *      and power down the MMC bus. No new requests will be issued
     508                 :            :  *      after this function has returned.
     509                 :            :  */
     510                 :          0 : void mmc_remove_host(struct mmc_host *host)
     511                 :            : {
     512                 :            :         mmc_unregister_pm_notifier(host);
     513                 :          0 :         mmc_stop_host(host);
     514                 :            : 
     515                 :            : #ifdef CONFIG_DEBUG_FS
     516                 :          0 :         mmc_remove_host_debugfs(host);
     517                 :            : #endif
     518                 :            : 
     519                 :          0 :         device_del(&host->class_dev);
     520                 :            : 
     521                 :          0 :         led_trigger_unregister_simple(host->led);
     522                 :          0 : }
     523                 :            : 
     524                 :            : EXPORT_SYMBOL(mmc_remove_host);
     525                 :            : 
     526                 :            : /**
     527                 :            :  *      mmc_free_host - free the host structure
     528                 :            :  *      @host: mmc host
     529                 :            :  *
     530                 :            :  *      Free the host once all references to it have been dropped.
     531                 :            :  */
     532                 :          3 : void mmc_free_host(struct mmc_host *host)
     533                 :            : {
     534                 :          3 :         mmc_pwrseq_free(host);
     535                 :          3 :         put_device(&host->class_dev);
     536                 :          3 : }
     537                 :            : 
     538                 :            : EXPORT_SYMBOL(mmc_free_host);
    

Generated by: LCOV version 1.14