Branch data     Line data    Source code

       1                 :            : // SPDX-License-Identifier: GPL-2.0-only
       2                 :            : /*
       3                 :            :  *  Copyright (C) 2014 Linaro Ltd
       4                 :            :  *
       5                 :            :  * Author: Ulf Hansson <ulf.hansson@linaro.org>
       6                 :            :  *
       7                 :            :  *  MMC power sequence management
       8                 :            :  */
       9                 :            : #include <linux/kernel.h>
      10                 :            : #include <linux/err.h>
      11                 :            : #include <linux/module.h>
      12                 :            : #include <linux/of.h>
      13                 :            : 
      14                 :            : #include <linux/mmc/host.h>
      15                 :            : 
      16                 :            : #include "pwrseq.h"
      17                 :            : 
      18                 :            : static DEFINE_MUTEX(pwrseq_list_mutex);
      19                 :            : static LIST_HEAD(pwrseq_list);
      20                 :            : 
      21                 :          3 : int mmc_pwrseq_alloc(struct mmc_host *host)
      22                 :            : {
      23                 :            :         struct device_node *np;
      24                 :            :         struct mmc_pwrseq *p;
      25                 :            : 
      26                 :          3 :         np = of_parse_phandle(host->parent->of_node, "mmc-pwrseq", 0);
      27                 :          3 :         if (!np)
      28                 :            :                 return 0;
      29                 :            : 
      30                 :          0 :         mutex_lock(&pwrseq_list_mutex);
      31                 :          0 :         list_for_each_entry(p, &pwrseq_list, pwrseq_node) {
      32                 :          0 :                 if (p->dev->of_node == np) {
      33                 :          0 :                         if (!try_module_get(p->owner))
      34                 :          0 :                                 dev_err(host->parent,
      35                 :            :                                         "increasing module refcount failed\n");
      36                 :            :                         else
      37                 :          0 :                                 host->pwrseq = p;
      38                 :            : 
      39                 :            :                         break;
      40                 :            :                 }
      41                 :            :         }
      42                 :            : 
      43                 :          0 :         of_node_put(np);
      44                 :          0 :         mutex_unlock(&pwrseq_list_mutex);
      45                 :            : 
      46                 :          0 :         if (!host->pwrseq)
      47                 :            :                 return -EPROBE_DEFER;
      48                 :            : 
      49                 :          0 :         dev_info(host->parent, "allocated mmc-pwrseq\n");
      50                 :            : 
      51                 :          0 :         return 0;
      52                 :            : }
      53                 :            : 
      54                 :          3 : void mmc_pwrseq_pre_power_on(struct mmc_host *host)
      55                 :            : {
      56                 :          3 :         struct mmc_pwrseq *pwrseq = host->pwrseq;
      57                 :            : 
      58                 :          3 :         if (pwrseq && pwrseq->ops->pre_power_on)
      59                 :          0 :                 pwrseq->ops->pre_power_on(host);
      60                 :          3 : }
      61                 :            : 
      62                 :          3 : void mmc_pwrseq_post_power_on(struct mmc_host *host)
      63                 :            : {
      64                 :          3 :         struct mmc_pwrseq *pwrseq = host->pwrseq;
      65                 :            : 
      66                 :          3 :         if (pwrseq && pwrseq->ops->post_power_on)
      67                 :          0 :                 pwrseq->ops->post_power_on(host);
      68                 :          3 : }
      69                 :            : 
      70                 :          0 : void mmc_pwrseq_power_off(struct mmc_host *host)
      71                 :            : {
      72                 :          0 :         struct mmc_pwrseq *pwrseq = host->pwrseq;
      73                 :            : 
      74                 :          0 :         if (pwrseq && pwrseq->ops->power_off)
      75                 :          0 :                 pwrseq->ops->power_off(host);
      76                 :          0 : }
      77                 :            : 
      78                 :          3 : void mmc_pwrseq_reset(struct mmc_host *host)
      79                 :            : {
      80                 :          3 :         struct mmc_pwrseq *pwrseq = host->pwrseq;
      81                 :            : 
      82                 :          3 :         if (pwrseq && pwrseq->ops->reset)
      83                 :          0 :                 pwrseq->ops->reset(host);
      84                 :          3 : }
      85                 :            : 
      86                 :          3 : void mmc_pwrseq_free(struct mmc_host *host)
      87                 :            : {
      88                 :          3 :         struct mmc_pwrseq *pwrseq = host->pwrseq;
      89                 :            : 
      90                 :          3 :         if (pwrseq) {
      91                 :          0 :                 module_put(pwrseq->owner);
      92                 :          0 :                 host->pwrseq = NULL;
      93                 :            :         }
      94                 :          3 : }
      95                 :            : 
      96                 :          0 : int mmc_pwrseq_register(struct mmc_pwrseq *pwrseq)
      97                 :            : {
      98                 :          0 :         if (!pwrseq || !pwrseq->ops || !pwrseq->dev)
      99                 :            :                 return -EINVAL;
     100                 :            : 
     101                 :          0 :         mutex_lock(&pwrseq_list_mutex);
     102                 :          0 :         list_add(&pwrseq->pwrseq_node, &pwrseq_list);
     103                 :          0 :         mutex_unlock(&pwrseq_list_mutex);
     104                 :            : 
     105                 :          0 :         return 0;
     106                 :            : }
     107                 :            : EXPORT_SYMBOL_GPL(mmc_pwrseq_register);
     108                 :            : 
     109                 :          0 : void mmc_pwrseq_unregister(struct mmc_pwrseq *pwrseq)
     110                 :            : {
     111                 :          0 :         if (pwrseq) {
     112                 :          0 :                 mutex_lock(&pwrseq_list_mutex);
     113                 :            :                 list_del(&pwrseq->pwrseq_node);
     114                 :          0 :                 mutex_unlock(&pwrseq_list_mutex);
     115                 :            :         }
     116                 :          0 : }
     117                 :            : EXPORT_SYMBOL_GPL(mmc_pwrseq_unregister);