Aravind Venkateswaran | 3111984 | 2015-01-13 14:46:04 -0800 | [diff] [blame] | 1 | /* Copyright (c) 2013-2015, The Linux Foundation. All rights reserved. |
Arpita Banerjee | da0c39a | 2013-05-24 16:12:45 -0700 | [diff] [blame] | 2 | * |
| 3 | * Redistribution and use in source and binary forms, with or without |
| 4 | * modification, are permitted provided that the following conditions |
| 5 | * are met: |
| 6 | * * Redistributions of source code must retain the above copyright |
| 7 | * notice, this list of conditions and the following disclaimer. |
| 8 | * * Redistributions in binary form must reproduce the above copyright |
| 9 | * notice, this list of conditions and the following disclaimer in |
| 10 | * the documentation and/or other materials provided with the |
| 11 | * distribution. |
| 12 | * * Neither the name of The Linux Foundation nor the names of its |
| 13 | * contributors may be used to endorse or promote products derived |
| 14 | * from this software without specific prior written permission. |
| 15 | * |
| 16 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| 17 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| 18 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS |
| 19 | * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE |
| 20 | * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, |
| 21 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, |
| 22 | * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS |
| 23 | * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED |
| 24 | * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
| 25 | * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT |
| 26 | * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| 27 | * SUCH DAMAGE. |
| 28 | */ |
| 29 | |
| 30 | #include <debug.h> |
| 31 | #include <err.h> |
| 32 | #include <smem.h> |
| 33 | #include <msm_panel.h> |
| 34 | #include <mipi_dsi.h> |
| 35 | |
| 36 | #include "gcdb_autopll.h" |
| 37 | |
| 38 | static struct mdss_dsi_pll_config pll_data; |
| 39 | |
Dhaval Patel | d19fcf1 | 2014-08-12 13:16:05 -0700 | [diff] [blame] | 40 | static void calculate_bitclock(struct msm_panel_info *pinfo) |
Arpita Banerjee | da0c39a | 2013-05-24 16:12:45 -0700 | [diff] [blame] | 41 | { |
Arpita Banerjee | da0c39a | 2013-05-24 16:12:45 -0700 | [diff] [blame] | 42 | uint32_t h_period = 0, v_period = 0; |
Dhaval Patel | ee8675a | 2013-10-25 10:07:57 -0700 | [diff] [blame] | 43 | uint32_t width = pinfo->xres; |
Kuogee Hsieh | e0fbc02 | 2015-07-07 10:26:58 -0700 | [diff] [blame^] | 44 | struct dsc_desc *dsc = NULL; |
Arpita Banerjee | da0c39a | 2013-05-24 16:12:45 -0700 | [diff] [blame] | 45 | |
Dhaval Patel | ee8675a | 2013-10-25 10:07:57 -0700 | [diff] [blame] | 46 | if (pinfo->mipi.dual_dsi) |
Siddhartha Agrawal | fe64dcb | 2014-10-07 12:41:01 -0700 | [diff] [blame] | 47 | width /= 2; |
| 48 | |
Kuogee Hsieh | e0fbc02 | 2015-07-07 10:26:58 -0700 | [diff] [blame^] | 49 | if (pinfo->compression_mode == COMPRESSION_DSC) { |
| 50 | dsc = &pinfo->dsc; |
| 51 | width = dsc->pclk_per_line; |
| 52 | } else if (pinfo->compression_mode == COMPRESSION_FBC) { |
| 53 | if (pinfo->fbc.comp_ratio) |
| 54 | width /= pinfo->fbc.comp_ratio; |
| 55 | } |
Dhaval Patel | ee8675a | 2013-10-25 10:07:57 -0700 | [diff] [blame] | 56 | |
| 57 | h_period = width + pinfo->lcdc.h_back_porch + |
Arpita Banerjee | da0c39a | 2013-05-24 16:12:45 -0700 | [diff] [blame] | 58 | pinfo->lcdc.h_front_porch + pinfo->lcdc.h_pulse_width + |
| 59 | pinfo->lcdc.xres_pad; |
| 60 | |
| 61 | v_period = pinfo->yres + pinfo->lcdc.v_back_porch + |
| 62 | pinfo->lcdc.v_front_porch + pinfo->lcdc.v_pulse_width + |
| 63 | pinfo->lcdc.yres_pad; |
| 64 | |
Aravind Venkateswaran | 3111984 | 2015-01-13 14:46:04 -0800 | [diff] [blame] | 65 | /* |
| 66 | * If a bit clock rate is not specified, calculate it based |
| 67 | * on panel parameters |
| 68 | */ |
Arpita Banerjee | da0c39a | 2013-05-24 16:12:45 -0700 | [diff] [blame] | 69 | if (pinfo->mipi.bitclock == 0) |
Aravind Venkateswaran | 3111984 | 2015-01-13 14:46:04 -0800 | [diff] [blame] | 70 | pll_data.bit_clock = (h_period * v_period * |
| 71 | pinfo->mipi.frame_rate * pinfo->bpp) / |
| 72 | pinfo->mipi.num_of_lanes; |
Arpita Banerjee | da0c39a | 2013-05-24 16:12:45 -0700 | [diff] [blame] | 73 | else |
| 74 | pll_data.bit_clock = pinfo->mipi.bitclock; |
| 75 | |
Aravind Venkateswaran | 3111984 | 2015-01-13 14:46:04 -0800 | [diff] [blame] | 76 | pll_data.pixel_clock = (pll_data.bit_clock * pinfo->mipi.num_of_lanes) / |
| 77 | pinfo->bpp; |
| 78 | |
Arpita Banerjee | da0c39a | 2013-05-24 16:12:45 -0700 | [diff] [blame] | 79 | pll_data.byte_clock = pll_data.bit_clock >> 3; |
| 80 | |
| 81 | pll_data.halfbit_clock = pll_data.bit_clock >> 1; |
Arpita Banerjee | da0c39a | 2013-05-24 16:12:45 -0700 | [diff] [blame] | 82 | } |
| 83 | |
| 84 | static uint32_t calculate_div1() |
| 85 | { |
| 86 | uint32_t ret = NO_ERROR; |
| 87 | |
| 88 | /* div1 - there is divide by 2 logic present */ |
| 89 | if (pll_data.halfbit_clock > HALFBIT_CLOCK1) { |
| 90 | pll_data.posdiv1 = 0x0; /*div 1 */ |
| 91 | pll_data.vco_clock = pll_data.halfbit_clock << 1; |
| 92 | } else if (pll_data.halfbit_clock > HALFBIT_CLOCK2) { |
| 93 | pll_data.posdiv1 = 0x1; /*div 2 */ |
| 94 | pll_data.vco_clock = pll_data.halfbit_clock << 2; |
| 95 | } else if (pll_data.halfbit_clock > HALFBIT_CLOCK3) { |
| 96 | pll_data.posdiv1 = 0x3; /*div 4 */ |
| 97 | pll_data.vco_clock = pll_data.halfbit_clock << 3; |
| 98 | } else if (pll_data.halfbit_clock > HALFBIT_CLOCK4) { |
| 99 | pll_data.posdiv1 = 0x4; /*div 5 */ |
| 100 | pll_data.vco_clock = pll_data.halfbit_clock * 10; |
| 101 | } else { |
| 102 | dprintf(CRITICAL, "Not able to calculate posdiv1\n"); |
| 103 | } |
| 104 | |
| 105 | return ret; |
| 106 | } |
| 107 | |
| 108 | static uint32_t calculate_div3(uint8_t bpp, uint8_t num_of_lanes) |
| 109 | { |
Arpita Banerjee | da0c39a | 2013-05-24 16:12:45 -0700 | [diff] [blame] | 110 | pll_data.pclk_m = 0x1; /* M = 1, N= 1 */ |
| 111 | pll_data.pclk_n = 0xFF; /* ~ (N-M) = 0xff */ |
| 112 | pll_data.pclk_d = 0xFF; /* ~N = 0xFF */ |
| 113 | |
| 114 | /* formula is ( vco_clock / pdiv_digital) / mnd = pixel_clock */ |
| 115 | |
| 116 | /* div3 */ |
| 117 | switch (bpp) { |
| 118 | case BITS_18: |
| 119 | if (num_of_lanes == 3) { |
| 120 | pll_data.posdiv3 = pll_data.vco_clock / |
| 121 | pll_data.pixel_clock; |
| 122 | } else { |
| 123 | pll_data.posdiv3 = (pll_data.pixel_clock * 2 / 9) / |
| 124 | pll_data.vco_clock; |
| 125 | pll_data.pclk_m = 0x2; /* M = 2,N = 9 */ |
| 126 | pll_data.pclk_n = 0xF8; |
| 127 | pll_data.pclk_d = 0xF6; |
| 128 | } |
| 129 | break; |
| 130 | case BITS_16: |
| 131 | if (num_of_lanes == 3) { |
| 132 | pll_data.posdiv3 = (pll_data.pixel_clock * 3 / 8) / |
| 133 | pll_data.vco_clock; |
| 134 | pll_data.pclk_m = 0x3; /* M = 3, N = 9 */ |
| 135 | pll_data.pclk_n = 0xFA; |
| 136 | pll_data.pclk_d = 0xF7; |
| 137 | } else { |
| 138 | pll_data.posdiv3 = pll_data.vco_clock / |
| 139 | pll_data.pixel_clock; |
| 140 | } |
| 141 | break; |
| 142 | case BITS_24: |
| 143 | default: |
| 144 | pll_data.posdiv3 = pll_data.vco_clock / |
| 145 | pll_data.pixel_clock; |
| 146 | break; |
| 147 | } |
| 148 | |
| 149 | pll_data.posdiv3--; /* Register needs one value less */ |
Veera Sundaram Sankaran | 824e6fa | 2014-12-09 11:32:58 -0800 | [diff] [blame] | 150 | return NO_ERROR; |
Arpita Banerjee | da0c39a | 2013-05-24 16:12:45 -0700 | [diff] [blame] | 151 | } |
| 152 | |
Dhaval Patel | d19fcf1 | 2014-08-12 13:16:05 -0700 | [diff] [blame] | 153 | static uint32_t calculate_dec_frac_start() |
Arpita Banerjee | da0c39a | 2013-05-24 16:12:45 -0700 | [diff] [blame] | 154 | { |
Dhaval Patel | d19fcf1 | 2014-08-12 13:16:05 -0700 | [diff] [blame] | 155 | uint32_t refclk = 19200000; |
| 156 | uint32_t vco_rate = pll_data.vco_clock; |
Chandan Uddaraju | 058298e | 2015-02-04 14:25:30 -0800 | [diff] [blame] | 157 | uint32_t tmp, mod; |
Dhaval Patel | d19fcf1 | 2014-08-12 13:16:05 -0700 | [diff] [blame] | 158 | |
| 159 | vco_rate /= 2; |
| 160 | pll_data.dec_start = vco_rate / refclk; |
| 161 | tmp = vco_rate % refclk; /* module, fraction */ |
| 162 | tmp /= 192; |
| 163 | tmp *= 1024; |
| 164 | tmp /= 100; |
| 165 | tmp *= 1024; |
| 166 | tmp /= 1000; |
| 167 | pll_data.frac_start = tmp; |
| 168 | |
| 169 | vco_rate *= 2; /* restore */ |
Chandan Uddaraju | 058298e | 2015-02-04 14:25:30 -0800 | [diff] [blame] | 170 | if (pll_data.en_vco_zero_phase) { |
| 171 | tmp = vco_rate / (refclk / 1000);/* div 1000 first */ |
| 172 | tmp *= 1024; |
| 173 | tmp /= 1000; |
| 174 | tmp /= 10; |
| 175 | pll_data.lock_comp = tmp - 1; |
| 176 | } else { |
| 177 | tmp = vco_rate / refclk; |
| 178 | mod = vco_rate % refclk; |
| 179 | tmp *= 127; |
| 180 | mod *= 127; |
| 181 | mod /= refclk; |
| 182 | tmp += mod; |
| 183 | tmp /= 10; |
| 184 | pll_data.lock_comp = tmp; |
| 185 | } |
Dhaval Patel | d19fcf1 | 2014-08-12 13:16:05 -0700 | [diff] [blame] | 186 | |
Chandan Uddaraju | 6751956 | 2014-11-01 17:00:45 -0700 | [diff] [blame] | 187 | dprintf(SPEW, "%s: dec_start=0x%x dec_frac=0x%x lock_comp=0x%x\n", __func__, |
Dhaval Patel | d19fcf1 | 2014-08-12 13:16:05 -0700 | [diff] [blame] | 188 | pll_data.dec_start, pll_data.frac_start, pll_data.lock_comp); |
Veera Sundaram Sankaran | 824e6fa | 2014-12-09 11:32:58 -0800 | [diff] [blame] | 189 | return NO_ERROR; |
Dhaval Patel | d19fcf1 | 2014-08-12 13:16:05 -0700 | [diff] [blame] | 190 | } |
| 191 | |
| 192 | static uint32_t calculate_vco_28nm(uint8_t bpp, uint8_t num_of_lanes) |
| 193 | { |
Arpita Banerjee | da0c39a | 2013-05-24 16:12:45 -0700 | [diff] [blame] | 194 | /* If half bitclock is more than VCO min value */ |
| 195 | if (pll_data.halfbit_clock > VCO_MIN_CLOCK) { |
| 196 | |
| 197 | /* Direct Mode */ |
| 198 | |
| 199 | /* support vco clock to max value only */ |
| 200 | if (pll_data.halfbit_clock > VCO_MAX_CLOCK) |
| 201 | pll_data.vco_clock = VCO_MAX_CLOCK; |
| 202 | else |
| 203 | pll_data.vco_clock = pll_data.halfbit_clock; |
| 204 | pll_data.directpath = 0x0; |
| 205 | pll_data.posdiv1 = 0x0; /*DSI spec says 0 - div 1 */ |
| 206 | /*1 - div 2 */ |
| 207 | /*F - div 16 */ |
| 208 | } else { |
| 209 | /* Indirect Mode */ |
| 210 | |
| 211 | pll_data.directpath = 0x02; /* set bit 1 to enable for |
| 212 | indirect path */ |
| 213 | |
| 214 | calculate_div1(); |
| 215 | } |
| 216 | |
| 217 | /* calculate mnd and div3 for direct and indirect path */ |
| 218 | calculate_div3(bpp, num_of_lanes); |
| 219 | |
Dhaval Patel | d19fcf1 | 2014-08-12 13:16:05 -0700 | [diff] [blame] | 220 | return NO_ERROR; |
| 221 | } |
| 222 | |
Chandan Uddaraju | 058298e | 2015-02-04 14:25:30 -0800 | [diff] [blame] | 223 | #ifndef DISPLAY_EN_20NM_PLL_90_PHASE |
| 224 | static void config_20nm_pll_vco_range(void) |
| 225 | { |
| 226 | pll_data.vco_min = 300000000; |
| 227 | pll_data.vco_max = 1500000000; |
| 228 | pll_data.en_vco_zero_phase = 1; |
| 229 | dprintf(SPEW, "%s: Configured VCO for zero phase\n", __func__); |
| 230 | } |
| 231 | #else |
| 232 | static void config_20nm_pll_vco_range(void) |
| 233 | { |
| 234 | pll_data.vco_min = 1000000000; |
| 235 | pll_data.vco_max = 2000000000; |
| 236 | pll_data.en_vco_zero_phase = 0; |
| 237 | dprintf(SPEW, "%s: Configured VCO for 90 phase\n", __func__); |
| 238 | } |
| 239 | #endif |
| 240 | |
Dhaval Patel | 8b9a582 | 2015-03-16 13:01:26 -0700 | [diff] [blame] | 241 | static uint32_t calculate_vco_thulium() |
| 242 | { |
| 243 | uint32_t rate; |
| 244 | uint32_t mod; |
| 245 | |
| 246 | pll_data.vco_min = MIN_THULIUM_VCO_RATE; |
| 247 | pll_data.vco_max = MAX_THULIUM_VCO_RATE; |
| 248 | |
| 249 | if (pll_data.bit_clock < pll_data.vco_min) |
| 250 | rate = pll_data.vco_min; |
| 251 | else if (pll_data.bit_clock > pll_data.vco_max) |
| 252 | rate = pll_data.vco_max; |
| 253 | else |
| 254 | rate = pll_data.bit_clock; |
| 255 | |
| 256 | pll_data.ndiv = FIX_N_DIV; |
| 257 | if (pll_data.bit_clock) { |
| 258 | pll_data.n1div = rate / pll_data.bit_clock; |
| 259 | } else { |
| 260 | dprintf(ERROR, "%s: bit clock is 0, divider calculation failed\n", |
| 261 | __func__); |
| 262 | return ERROR; |
| 263 | } |
| 264 | |
| 265 | mod = rate % pll_data.bit_clock; |
| 266 | if (mod) |
| 267 | pll_data.n1div++; |
| 268 | |
| 269 | if (pll_data.n1div < MIN_THULIUM_DIV_VAL || |
| 270 | pll_data.n1div > MAX_THULIUM_DIV_VAL) { |
| 271 | dprintf(ERROR, "%s: n1div is out of ranget:%d\n", |
| 272 | __func__, pll_data.n1div); |
| 273 | return ERROR; |
| 274 | } |
| 275 | |
| 276 | rate /= pll_data.n1div; |
| 277 | rate /= FIX_PIXEL_CLOCK_DIV; |
| 278 | |
| 279 | pll_data.n2div = rate / pll_data.pixel_clock; |
| 280 | mod = rate % pll_data.pixel_clock; |
| 281 | if (mod) |
| 282 | pll_data.n2div++; |
| 283 | |
| 284 | if (pll_data.n2div < MIN_THULIUM_DIV_VAL || |
| 285 | pll_data.n2div > MAX_THULIUM_DIV_VAL) { |
| 286 | dprintf(ERROR, "%s: n2div is out of ranget:%d\n", |
| 287 | __func__, pll_data.n2div); |
| 288 | return ERROR; |
| 289 | } |
| 290 | pll_data.vco_clock = pll_data.bit_clock * pll_data.ndiv * pll_data.n1div; |
| 291 | |
| 292 | dprintf(SPEW, "%s: vco:%u n1div:%d n2div:%d bit_clk:%u pixel_clk:%u\n", |
| 293 | __func__, pll_data.vco_clock, pll_data.n1div, pll_data.n2div, |
| 294 | pll_data.bit_clock, pll_data.pixel_clock); |
| 295 | |
| 296 | return NO_ERROR; |
| 297 | } |
| 298 | |
Dhaval Patel | d19fcf1 | 2014-08-12 13:16:05 -0700 | [diff] [blame] | 299 | static uint32_t calculate_vco_20nm(uint8_t bpp, uint8_t lanes) |
| 300 | { |
| 301 | uint32_t vco, dsi_clk; |
| 302 | int mod, ndiv, hr_oclk2, hr_oclk3; |
| 303 | int m = 1; |
| 304 | int n = 1; |
| 305 | int bpp_m = 3; /* bpp = 3 */ |
| 306 | int bpp_n = 1; |
| 307 | |
| 308 | if (bpp == BITS_18) { |
| 309 | bpp_m = 9; /* bpp = 2.25 */ |
| 310 | bpp_n = 4; |
| 311 | |
| 312 | if (lanes == 2) { |
| 313 | m = 2; |
| 314 | n = 9; |
| 315 | } else if (lanes == 4) { |
| 316 | m = 4; |
| 317 | n = 9; |
| 318 | } |
| 319 | } else if (bpp == BITS_16) { |
| 320 | bpp_m = 2; /* bpp = 2 */ |
| 321 | bpp_n = 1; |
| 322 | if (lanes == 3) { |
| 323 | m = 3; |
| 324 | n = 8; |
| 325 | } |
| 326 | } |
| 327 | |
| 328 | hr_oclk2 = 4; |
| 329 | |
| 330 | /* If bitclock is more than VCO min value */ |
Chandan Uddaraju | 058298e | 2015-02-04 14:25:30 -0800 | [diff] [blame] | 331 | if (pll_data.halfbit_clock >= ((pll_data.vco_min) >> 1)) { |
Dhaval Patel | d19fcf1 | 2014-08-12 13:16:05 -0700 | [diff] [blame] | 332 | /* Direct Mode */ |
| 333 | vco = pll_data.halfbit_clock << 1; |
| 334 | /* support vco clock to max value only */ |
Chandan Uddaraju | 058298e | 2015-02-04 14:25:30 -0800 | [diff] [blame] | 335 | if (vco > (pll_data.vco_max)) |
| 336 | vco = (pll_data.vco_max); |
Dhaval Patel | d19fcf1 | 2014-08-12 13:16:05 -0700 | [diff] [blame] | 337 | |
| 338 | pll_data.directpath = 0x0; |
| 339 | pll_data.byte_clock = vco / 2 / hr_oclk2; |
| 340 | pll_data.lp_div_mux = 0x0; |
| 341 | ndiv = 1; |
| 342 | hr_oclk3 = hr_oclk2 * m / n * bpp_m / bpp_n / lanes; |
| 343 | } else { |
| 344 | /* Indirect Mode */ |
Chandan Uddaraju | 058298e | 2015-02-04 14:25:30 -0800 | [diff] [blame] | 345 | mod = (pll_data.vco_min) % (4 * pll_data.halfbit_clock ); |
| 346 | ndiv = (pll_data.vco_min) / (4 * pll_data.halfbit_clock ); |
Dhaval Patel | d19fcf1 | 2014-08-12 13:16:05 -0700 | [diff] [blame] | 347 | if (mod) |
| 348 | ndiv += 1; |
| 349 | |
| 350 | vco = pll_data.halfbit_clock * 4 * ndiv; |
| 351 | pll_data.lp_div_mux = 0x1; |
| 352 | pll_data.directpath = 0x02; /* set bit 1 to enable for |
| 353 | indirect path */ |
| 354 | |
| 355 | pll_data.byte_clock = vco / 4 / hr_oclk2 / ndiv; |
| 356 | hr_oclk3 = hr_oclk2 * m / n * ndiv * 2 * bpp_m / bpp_n / lanes; |
| 357 | } |
| 358 | |
| 359 | pll_data.vco_clock = vco; |
| 360 | dsi_clk = vco / 2 / hr_oclk3; |
| 361 | pll_data.ndiv = ndiv; |
| 362 | pll_data.hr_oclk2 = hr_oclk2 - 1; /* strat from 0 */ |
| 363 | pll_data.hr_oclk3 = hr_oclk3 - 1; /* strat from 0 */ |
| 364 | |
| 365 | pll_data.pclk_m = m; /* M */ |
| 366 | pll_data.pclk_n = ~(n - m); /* ~(N-M) */ |
| 367 | pll_data.pclk_d = ~n; /* ~N */ |
| 368 | |
| 369 | dprintf(SPEW, "%s: oclk2=%d oclk3=%d ndiv=%d vco=%u dsi_clk=%u byte_clk=%u\n", |
| 370 | __func__, hr_oclk2, hr_oclk3, ndiv, vco, dsi_clk, pll_data.byte_clock); |
| 371 | |
| 372 | calculate_dec_frac_start(); |
| 373 | |
| 374 | return NO_ERROR; |
Arpita Banerjee | da0c39a | 2013-05-24 16:12:45 -0700 | [diff] [blame] | 375 | } |
| 376 | |
| 377 | uint32_t calculate_clock_config(struct msm_panel_info *pinfo) |
| 378 | { |
| 379 | uint32_t ret = NO_ERROR; |
| 380 | |
| 381 | calculate_bitclock(pinfo); |
| 382 | |
Dhaval Patel | 8b9a582 | 2015-03-16 13:01:26 -0700 | [diff] [blame] | 383 | switch (pinfo->mipi.mdss_dsi_phy_db->pll_type) { |
| 384 | case DSI_PLL_TYPE_20NM: |
Chandan Uddaraju | 058298e | 2015-02-04 14:25:30 -0800 | [diff] [blame] | 385 | config_20nm_pll_vco_range(); |
Dhaval Patel | d19fcf1 | 2014-08-12 13:16:05 -0700 | [diff] [blame] | 386 | ret = calculate_vco_20nm(pinfo->bpp, pinfo->mipi.num_of_lanes); |
Dhaval Patel | 8b9a582 | 2015-03-16 13:01:26 -0700 | [diff] [blame] | 387 | break; |
| 388 | case DSI_PLL_TYPE_THULIUM: |
| 389 | ret = calculate_vco_thulium(pinfo->bpp, pinfo->mipi.num_of_lanes); |
| 390 | break; |
| 391 | case DSI_PLL_TYPE_28NM: |
| 392 | default: |
Dhaval Patel | d19fcf1 | 2014-08-12 13:16:05 -0700 | [diff] [blame] | 393 | ret = calculate_vco_28nm(pinfo->bpp, pinfo->mipi.num_of_lanes); |
Dhaval Patel | 8b9a582 | 2015-03-16 13:01:26 -0700 | [diff] [blame] | 394 | break; |
| 395 | } |
Arpita Banerjee | da0c39a | 2013-05-24 16:12:45 -0700 | [diff] [blame] | 396 | |
| 397 | pinfo->mipi.dsi_pll_config = &pll_data; |
| 398 | |
| 399 | return ret; |
| 400 | } |