LCOV - code coverage report
Current view: top level - include/linux/mmc - host.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 2 2 100.0 %
Date: 2017-01-25 Functions: 0 0 -

          Line data    Source code
       1             : /*
       2             :  *  linux/include/linux/mmc/host.h
       3             :  *
       4             :  * This program is free software; you can redistribute it and/or modify
       5             :  * it under the terms of the GNU General Public License version 2 as
       6             :  * published by the Free Software Foundation.
       7             :  *
       8             :  *  Host driver specific definitions.
       9             :  */
      10             : #ifndef LINUX_MMC_HOST_H
      11             : #define LINUX_MMC_HOST_H
      12             : 
      13             : #include <linux/leds.h>
      14             : #include <linux/sched.h>
      15             : 
      16             : #include <linux/mmc/core.h>
      17             : 
      18             : struct mmc_ios {
      19             :         unsigned int    clock;                  /* clock rate */
      20             :         unsigned short  vdd;
      21             : 
      22             : /* vdd stores the bit number of the selected voltage range from below. */
      23             : 
      24             :         unsigned char   bus_mode;               /* command output mode */
      25             : 
      26             : #define MMC_BUSMODE_OPENDRAIN   1
      27             : #define MMC_BUSMODE_PUSHPULL    2
      28             : 
      29             :         unsigned char   chip_select;            /* SPI chip select */
      30             : 
      31             : #define MMC_CS_DONTCARE         0
      32             : #define MMC_CS_HIGH             1
      33             : #define MMC_CS_LOW              2
      34             : 
      35             :         unsigned char   power_mode;             /* power supply mode */
      36             : 
      37             : #define MMC_POWER_OFF           0
      38             : #define MMC_POWER_UP            1
      39             : #define MMC_POWER_ON            2
      40             : 
      41             :         unsigned char   bus_width;              /* data bus width */
      42             : 
      43             : #define MMC_BUS_WIDTH_1         0
      44             : #define MMC_BUS_WIDTH_4         2
      45             : #define MMC_BUS_WIDTH_8         3
      46             : 
      47             :         unsigned char   timing;                 /* timing specification used */
      48             : 
      49           1 : #define MMC_TIMING_LEGACY       0
      50             : #define MMC_TIMING_MMC_HS       1
      51             : #define MMC_TIMING_SD_HS        2
      52             : };
      53             : 
      54             : struct mmc_host_ops {
      55             :         /*
      56             :          * Hosts that support power saving can use the 'enable' and 'disable'
      57             :          * methods to exit and enter power saving states. 'enable' is called
      58             :          * when the host is claimed and 'disable' is called (or scheduled with
      59             :          * a delay) when the host is released. The 'disable' is scheduled if
      60             :          * the disable delay set by 'mmc_set_disable_delay()' is non-zero,
      61             :          * otherwise 'disable' is called immediately. 'disable' may be
      62             :          * scheduled repeatedly, to permit ever greater power saving at the
      63             :          * expense of ever greater latency to re-enable. Rescheduling is
      64             :          * determined by the return value of the 'disable' method. A positive
      65             :          * value gives the delay in milliseconds.
      66             :          *
      67             :          * In the case where a host function (like set_ios) may be called
      68             :          * with or without the host claimed, enabling and disabling can be
      69             :          * done directly and will nest correctly. Call 'mmc_host_enable()' and
      70             :          * 'mmc_host_lazy_disable()' for this purpose, but note that these
      71             :          * functions must be paired.
      72             :          *
      73             :          * Alternatively, 'mmc_host_enable()' may be paired with
      74             :          * 'mmc_host_disable()' which calls 'disable' immediately.  In this
      75             :          * case the 'disable' method will be called with 'lazy' set to 0.
      76             :          * This is mainly useful for error paths.
      77             :          *
      78             :          * Because lazy disable may be called from a work queue, the 'disable'
      79             :          * method must claim the host when 'lazy' != 0, which will work
      80             :          * correctly because recursion is detected and handled.
      81             :          */
      82             :         int (*enable)(struct mmc_host *host);
      83             :         int (*disable)(struct mmc_host *host, int lazy);
      84             :         void    (*request)(struct mmc_host *host, struct mmc_request *req);
      85             :         /*
      86             :          * Avoid calling these three functions too often or in a "fast path",
      87             :          * since underlaying controller might implement them in an expensive
      88             :          * and/or slow way.
      89             :          *
      90             :          * Also note that these functions might sleep, so don't call them
      91             :          * in the atomic contexts!
      92             :          *
      93             :          * Return values for the get_ro callback should be:
      94             :          *   0 for a read/write card
      95             :          *   1 for a read-only card
      96             :          *   -ENOSYS when not supported (equal to NULL callback)
      97             :          *   or a negative errno value when something bad happened
      98             :          *
      99             :          * Return values for the get_cd callback should be:
     100             :          *   0 for a absent card
     101             :          *   1 for a present card
     102             :          *   -ENOSYS when not supported (equal to NULL callback)
     103             :          *   or a negative errno value when something bad happened
     104             :          */
     105             :         void    (*set_ios)(struct mmc_host *host, struct mmc_ios *ios);
     106             :         int     (*get_ro)(struct mmc_host *host);
     107             :         int     (*get_cd)(struct mmc_host *host);
     108             : 
     109             :         void    (*enable_sdio_irq)(struct mmc_host *host, int enable);
     110             : };
     111           2 : 
     112             : struct mmc_card;
     113             : struct device;
     114             : 
     115             : struct mmc_host {
     116             :         struct device           *parent;
     117             :         struct device           class_dev;
     118             :         int                     index;
     119             :         const struct mmc_host_ops *ops;
     120             :         unsigned int            f_min;
     121             :         unsigned int            f_max;
     122             :         u32                     ocr_avail;
     123             : 
     124             : #define MMC_VDD_165_195         0x00000080      /* VDD voltage 1.65 - 1.95 */
     125             : #define MMC_VDD_20_21           0x00000100      /* VDD voltage 2.0 ~ 2.1 */
     126             : #define MMC_VDD_21_22           0x00000200      /* VDD voltage 2.1 ~ 2.2 */
     127             : #define MMC_VDD_22_23           0x00000400      /* VDD voltage 2.2 ~ 2.3 */
     128             : #define MMC_VDD_23_24           0x00000800      /* VDD voltage 2.3 ~ 2.4 */
     129             : #define MMC_VDD_24_25           0x00001000      /* VDD voltage 2.4 ~ 2.5 */
     130             : #define MMC_VDD_25_26           0x00002000      /* VDD voltage 2.5 ~ 2.6 */
     131             : #define MMC_VDD_26_27           0x00004000      /* VDD voltage 2.6 ~ 2.7 */
     132             : #define MMC_VDD_27_28           0x00008000      /* VDD voltage 2.7 ~ 2.8 */
     133             : #define MMC_VDD_28_29           0x00010000      /* VDD voltage 2.8 ~ 2.9 */
     134             : #define MMC_VDD_29_30           0x00020000      /* VDD voltage 2.9 ~ 3.0 */
     135             : #define MMC_VDD_30_31           0x00040000      /* VDD voltage 3.0 ~ 3.1 */
     136             : #define MMC_VDD_31_32           0x00080000      /* VDD voltage 3.1 ~ 3.2 */
     137             : #define MMC_VDD_32_33           0x00100000      /* VDD voltage 3.2 ~ 3.3 */
     138             : #define MMC_VDD_33_34           0x00200000      /* VDD voltage 3.3 ~ 3.4 */
     139             : #define MMC_VDD_34_35           0x00400000      /* VDD voltage 3.4 ~ 3.5 */
     140             : #define MMC_VDD_35_36           0x00800000      /* VDD voltage 3.5 ~ 3.6 */
     141             : 
     142             :         unsigned long           caps;           /* Host capabilities */
     143             : 
     144             : #define MMC_CAP_4_BIT_DATA      (1 << 0)  /* Can the host do 4 bit transfers */
     145             : #define MMC_CAP_MMC_HIGHSPEED   (1 << 1)  /* Can do MMC high-speed timing */
     146             : #define MMC_CAP_SD_HIGHSPEED    (1 << 2)  /* Can do SD high-speed timing */
     147             : #define MMC_CAP_SDIO_IRQ        (1 << 3)  /* Can signal pending SDIO IRQs */
     148             : #define MMC_CAP_SPI             (1 << 4)  /* Talks only SPI protocols */
     149             : #define MMC_CAP_NEEDS_POLL      (1 << 5)  /* Needs polling for card-detection */
     150             : #define MMC_CAP_8_BIT_DATA      (1 << 6)  /* Can the host do 8 bit transfers */
     151             : #define MMC_CAP_DISABLE         (1 << 7)  /* Can the host be disabled */
     152             : #define MMC_CAP_NONREMOVABLE    (1 << 8)  /* Nonremovable e.g. eMMC */
     153             : #define MMC_CAP_WAIT_WHILE_BUSY (1 << 9)  /* Waits while card is busy */
     154             : 
     155             :         /* host specific block data */
     156             :         unsigned int            max_seg_size;   /* see blk_queue_max_segment_size */
     157             :         unsigned short          max_hw_segs;    /* see blk_queue_max_hw_segments */
     158             :         unsigned short          max_phys_segs;  /* see blk_queue_max_phys_segments */
     159             :         unsigned short          unused;
     160             :         unsigned int            max_req_size;   /* maximum number of bytes in one req */
     161             :         unsigned int            max_blk_size;   /* maximum size of one mmc block */
     162             :         unsigned int            max_blk_count;  /* maximum number of blocks in one req */
     163             : 
     164             :         /* private data */
     165             :         spinlock_t              lock;           /* lock for claim and bus ops */
     166             : 
     167             :         struct mmc_ios          ios;            /* current io bus settings */
     168             :         u32                     ocr;            /* the current OCR setting */
     169             : 
     170             :         /* group bitfields together to minimize padding */
     171             :         unsigned int            use_spi_crc:1;
     172             :         unsigned int            claimed:1;      /* host exclusively claimed */
     173             :         unsigned int            bus_dead:1;     /* bus has been released */
     174             : #ifdef CONFIG_MMC_DEBUG
     175             :         unsigned int            removed:1;      /* host is being removed */
     176             : #endif
     177             : 
     178             :         /* Only used with MMC_CAP_DISABLE */
     179             :         int                     enabled;        /* host is enabled */
     180             :         int                     nesting_cnt;    /* "enable" nesting count */
     181             :         int                     en_dis_recurs;  /* detect recursion */
     182             :         unsigned int            disable_delay;  /* disable delay in msecs */
     183             :         struct delayed_work     disable;        /* disabling work */
     184             : 
     185             :         struct mmc_card         *card;          /* device attached to this host */
     186             : 
     187             :         wait_queue_head_t       wq;
     188             :         struct task_struct      *claimer;       /* task that has host claimed */
     189             :         int                     claim_cnt;      /* "claim" nesting count */
     190             : 
     191             :         struct delayed_work     detect;
     192             : 
     193             :         const struct mmc_bus_ops *bus_ops;      /* current bus driver */
     194             :         unsigned int            bus_refs;       /* reference counter */
     195             : 
     196             :         unsigned int            sdio_irqs;
     197             :         struct task_struct      *sdio_irq_thread;
     198             :         atomic_t                sdio_irq_thread_abort;
     199             : 
     200             : #ifdef CONFIG_LEDS_TRIGGERS
     201             :         struct led_trigger      *led;           /* activity led */
     202             : #endif
     203             : 
     204             :         struct dentry           *debugfs_root;
     205             : 
     206             :         unsigned long           private[0] ____cacheline_aligned;
     207             : };
     208             : 
     209             : extern struct mmc_host *mmc_alloc_host(int extra, struct device *);
     210             : extern int mmc_add_host(struct mmc_host *);
     211             : extern void mmc_remove_host(struct mmc_host *);
     212             : extern void mmc_free_host(struct mmc_host *);
     213             : 
     214             : static inline void *mmc_priv(struct mmc_host *host)
     215             : {
     216             :         return (void *)host->private;
     217             : }
     218             : 
     219             : #define mmc_host_is_spi(host)   ((host)->caps & MMC_CAP_SPI)
     220             : 
     221             : #define mmc_dev(x)      ((x)->parent)
     222             : #define mmc_classdev(x) (&(x)->class_dev)
     223             : #define mmc_hostname(x) (dev_name(&(x)->class_dev))
     224             : 
     225             : extern int mmc_suspend_host(struct mmc_host *, pm_message_t);
     226             : extern int mmc_resume_host(struct mmc_host *);
     227             : 
     228             : extern void mmc_power_save_host(struct mmc_host *host);
     229             : extern void mmc_power_restore_host(struct mmc_host *host);
     230             : 
     231             : extern void mmc_detect_change(struct mmc_host *, unsigned long delay);
     232             : extern void mmc_request_done(struct mmc_host *, struct mmc_request *);
     233             : 
     234             : static inline void mmc_signal_sdio_irq(struct mmc_host *host)
     235             : {
     236             :         host->ops->enable_sdio_irq(host, 0);
     237             :         wake_up_process(host->sdio_irq_thread);
     238             : }
     239             : 
     240             : struct regulator;
     241             : 
     242             : int mmc_regulator_get_ocrmask(struct regulator *supply);
     243             : int mmc_regulator_set_ocr(struct regulator *supply, unsigned short vdd_bit);
     244             : 
     245             : int mmc_card_awake(struct mmc_host *host);
     246             : int mmc_card_sleep(struct mmc_host *host);
     247             : int mmc_card_can_sleep(struct mmc_host *host);
     248             : 
     249             : int mmc_host_enable(struct mmc_host *host);
     250             : int mmc_host_disable(struct mmc_host *host);
     251             : int mmc_host_lazy_disable(struct mmc_host *host);
     252             : 
     253             : static inline void mmc_set_disable_delay(struct mmc_host *host,
     254             :                                          unsigned int disable_delay)
     255             : {
     256             :         host->disable_delay = disable_delay;
     257             : }
     258             : 
     259             : #endif
     260             : 

Generated by: LCOV version 1.10