drivers/gpu/drm/msm/dsi/pll/dsi_pll.c

   1 /*
   2  * Copyright (c) 2012-2015, The Linux Foundation. All rights reserved.
   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 and
   6  * only version 2 as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  */
  13
  14 #include "dsi_pll.h"
  15
  16 static int dsi_pll_enable(struct msm_dsi_pll *pll)
  17 {
  18         int i, ret = 0;
  19
  20         /*
  21          * Certain PLLs do not allow VCO rate update when it is on.
  22          * Keep track of their status to turn on/off after set rate success.
  23          */
  24         if (unlikely(pll->pll_on))
  25                 return 0;
  26
  27         /* Try all enable sequences until one succeeds */
  28         for (i = 0; i < pll->en_seq_cnt; i++) {
  29                 ret = pll->enable_seqs[i](pll);
  30                 DBG("DSI PLL %s after sequence #%d",
  31                         ret ? "unlocked" : "locked", i + 1);
  32                 if (!ret)
  33                         break;
  34         }
  35
  36         if (ret) {
  37                 DRM_ERROR("DSI PLL failed to lock\n");
  38                 return ret;
  39         }
  40
  41         pll->pll_on = true;
  42
  43         return 0;
  44 }
  45
  46 static void dsi_pll_disable(struct msm_dsi_pll *pll)
  47 {
  48         if (unlikely(!pll->pll_on))
  49                 return;
  50
  51         pll->disable_seq(pll);
  52
  53         pll->pll_on = false;
  54 }
  55
  56 /*
  57  * DSI PLL Helper functions
  58  */
  59 long msm_dsi_pll_helper_clk_round_rate(struct clk_hw *hw,
  60                 unsigned long rate, unsigned long *parent_rate)
  61 {
  62         struct msm_dsi_pll *pll = hw_clk_to_pll(hw);
  63
  64         if      (rate < pll->min_rate)
  65                 return  pll->min_rate;
  66         else if (rate > pll->max_rate)
  67                 return  pll->max_rate;
  68         else
  69                 return rate;
  70 }
  71
  72 int msm_dsi_pll_helper_clk_prepare(struct clk_hw *hw)
  73 {
  74         struct msm_dsi_pll *pll = hw_clk_to_pll(hw);
  75         int ret;
  76
  77         /*
  78          * Certain PLLs need to update the same VCO rate and registers
  79          * after resume in suspend/resume scenario.
  80          */
  81         if (pll->restore_state) {
  82                 ret = pll->restore_state(pll);
  83                 if (ret)
  84                         goto error;
  85         }
  86
  87         ret = dsi_pll_enable(pll);
  88
  89 error:
  90         return ret;
  91 }
  92
  93 void msm_dsi_pll_helper_clk_unprepare(struct clk_hw *hw)
  94 {
  95         struct msm_dsi_pll *pll = hw_clk_to_pll(hw);
  96
  97         if (pll->save_state)
  98                 pll->save_state(pll);
  99
 100         dsi_pll_disable(pll);
 101 }
 102
 103 void msm_dsi_pll_helper_unregister_clks(struct platform_device *pdev,
 104                                         struct clk **clks, u32 num_clks)
 105 {
 106         of_clk_del_provider(pdev->dev.of_node);
 107
 108         if (!num_clks || !clks)
 109                 return;
 110
 111         do {
 112                 clk_unregister(clks[--num_clks]);
 113                 clks[num_clks] = NULL;
 114         } while (num_clks);
 115 }
 116
 117 /*
 118  * DSI PLL API
 119  */
 120 int msm_dsi_pll_get_clk_provider(struct msm_dsi_pll *pll,
 121         struct clk **byte_clk_provider, struct clk **pixel_clk_provider)
 122 {
 123         if (pll->get_provider)
 124                 return pll->get_provider(pll,
 125                                         byte_clk_provider,
 126                                         pixel_clk_provider);
 127
 128         return -EINVAL;
 129 }
 130
 131 void msm_dsi_pll_destroy(struct msm_dsi_pll *pll)
 132 {
 133         if (pll->destroy)
 134                 pll->destroy(pll);
 135 }
 136
 137 struct msm_dsi_pll *msm_dsi_pll_init(struct platform_device *pdev,
 138                         enum msm_dsi_phy_type type, int id)
 139 {
 140         struct device *dev = &pdev->dev;
 141         struct msm_dsi_pll *pll;
 142
 143         switch (type) {
 144         case MSM_DSI_PHY_28NM_HPM:
 145         case MSM_DSI_PHY_28NM_LP:
 146                 pll = msm_dsi_pll_28nm_init(pdev, type, id);
 147                 break;
 148         default:
 149                 pll = ERR_PTR(-ENXIO);
 150                 break;
 151         }
 152
 153         if (IS_ERR(pll)) {
 154                 dev_err(dev, "%s: failed to init DSI PLL\n", __func__);
 155                 return NULL;
 156         }
 157
 158         pll->type = type;
 159
 160         DBG("DSI:%d PLL registered", id);
 161
 162         return pll;
 163 }
 164