1/* 2 * Copyright (c) 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 "mdp5_kms.h" 15 16#include "drm_crtc.h" 17#include "drm_crtc_helper.h" 18 19struct mdp5_cmd_encoder { 20 struct drm_encoder base; 21 struct mdp5_interface intf; 22 bool enabled; 23 uint32_t bsc; 24 25 struct mdp5_ctl *ctl; 26}; 27#define to_mdp5_cmd_encoder(x) container_of(x, struct mdp5_cmd_encoder, base) 28 29static struct mdp5_kms *get_kms(struct drm_encoder *encoder) 30{ 31 struct msm_drm_private *priv = encoder->dev->dev_private; 32 return to_mdp5_kms(to_mdp_kms(priv->kms)); 33} 34 35#ifdef DOWNSTREAM_CONFIG_MSM_BUS_SCALING 36#include <mach/board.h> 37#include <linux/msm-bus.h> 38#include <linux/msm-bus-board.h> 39#define MDP_BUS_VECTOR_ENTRY(ab_val, ib_val) \ 40 { \ 41 .src = MSM_BUS_MASTER_MDP_PORT0, \ 42 .dst = MSM_BUS_SLAVE_EBI_CH0, \ 43 .ab = (ab_val), \ 44 .ib = (ib_val), \ 45 } 46 47static struct msm_bus_vectors mdp_bus_vectors[] = { 48 MDP_BUS_VECTOR_ENTRY(0, 0), 49 MDP_BUS_VECTOR_ENTRY(2000000000, 2000000000), 50}; 51static struct msm_bus_paths mdp_bus_usecases[] = { { 52 .num_paths = 1, 53 .vectors = &mdp_bus_vectors[0], 54}, { 55 .num_paths = 1, 56 .vectors = &mdp_bus_vectors[1], 57} }; 58static struct msm_bus_scale_pdata mdp_bus_scale_table = { 59 .usecase = mdp_bus_usecases, 60 .num_usecases = ARRAY_SIZE(mdp_bus_usecases), 61 .name = "mdss_mdp", 62}; 63 64static void bs_init(struct mdp5_cmd_encoder *mdp5_cmd_enc) 65{ 66 mdp5_cmd_enc->bsc = msm_bus_scale_register_client( 67 &mdp_bus_scale_table); 68 DBG("bus scale client: %08x", mdp5_cmd_enc->bsc); 69} 70 71static void bs_fini(struct mdp5_cmd_encoder *mdp5_cmd_enc) 72{ 73 if (mdp5_cmd_enc->bsc) { 74 msm_bus_scale_unregister_client(mdp5_cmd_enc->bsc); 75 mdp5_cmd_enc->bsc = 0; 76 } 77} 78 79static void bs_set(struct mdp5_cmd_encoder *mdp5_cmd_enc, int idx) 80{ 81 if (mdp5_cmd_enc->bsc) { 82 DBG("set bus scaling: %d", idx); 83 /* HACK: scaling down, and then immediately back up 84 * seems to leave things broken (underflow).. so 85 * never disable: 86 */ 87 idx = 1; 88 msm_bus_scale_client_update_request(mdp5_cmd_enc->bsc, idx); 89 } 90} 91#else 92static void bs_init(struct mdp5_cmd_encoder *mdp5_cmd_enc) {} 93static void bs_fini(struct mdp5_cmd_encoder *mdp5_cmd_enc) {} 94static void bs_set(struct mdp5_cmd_encoder *mdp5_cmd_enc, int idx) {} 95#endif 96 97#define VSYNC_CLK_RATE 19200000 98static int pingpong_tearcheck_setup(struct drm_encoder *encoder, 99 struct drm_display_mode *mode) 100{ 101 struct mdp5_kms *mdp5_kms = get_kms(encoder); 102 struct device *dev = encoder->dev->dev; 103 u32 total_lines_x100, vclks_line, cfg; 104 long vsync_clk_speed; 105 int pp_id = GET_PING_PONG_ID(mdp5_crtc_get_lm(encoder->crtc)); 106 107 if (IS_ERR_OR_NULL(mdp5_kms->vsync_clk)) { 108 dev_err(dev, "vsync_clk is not initialized\n"); 109 return -EINVAL; 110 } 111 112 total_lines_x100 = mode->vtotal * mode->vrefresh; 113 if (!total_lines_x100) { 114 dev_err(dev, "%s: vtotal(%d) or vrefresh(%d) is 0\n", 115 __func__, mode->vtotal, mode->vrefresh); 116 return -EINVAL; 117 } 118 119 vsync_clk_speed = clk_round_rate(mdp5_kms->vsync_clk, VSYNC_CLK_RATE); 120 if (vsync_clk_speed <= 0) { 121 dev_err(dev, "vsync_clk round rate failed %ld\n", 122 vsync_clk_speed); 123 return -EINVAL; 124 } 125 vclks_line = vsync_clk_speed * 100 / total_lines_x100; 126 127 cfg = MDP5_PP_SYNC_CONFIG_VSYNC_COUNTER_EN 128 | MDP5_PP_SYNC_CONFIG_VSYNC_IN_EN; 129 cfg |= MDP5_PP_SYNC_CONFIG_VSYNC_COUNT(vclks_line); 130 131 mdp5_write(mdp5_kms, REG_MDP5_PP_SYNC_CONFIG_VSYNC(pp_id), cfg); 132 mdp5_write(mdp5_kms, 133 REG_MDP5_PP_SYNC_CONFIG_HEIGHT(pp_id), 0xfff0); 134 mdp5_write(mdp5_kms, 135 REG_MDP5_PP_VSYNC_INIT_VAL(pp_id), mode->vdisplay); 136 mdp5_write(mdp5_kms, REG_MDP5_PP_RD_PTR_IRQ(pp_id), mode->vdisplay + 1); 137 mdp5_write(mdp5_kms, REG_MDP5_PP_START_POS(pp_id), mode->vdisplay); 138 mdp5_write(mdp5_kms, REG_MDP5_PP_SYNC_THRESH(pp_id), 139 MDP5_PP_SYNC_THRESH_START(4) | 140 MDP5_PP_SYNC_THRESH_CONTINUE(4)); 141 142 return 0; 143} 144 145static int pingpong_tearcheck_enable(struct drm_encoder *encoder) 146{ 147 struct mdp5_kms *mdp5_kms = get_kms(encoder); 148 int pp_id = GET_PING_PONG_ID(mdp5_crtc_get_lm(encoder->crtc)); 149 int ret; 150 151 ret = clk_set_rate(mdp5_kms->vsync_clk, 152 clk_round_rate(mdp5_kms->vsync_clk, VSYNC_CLK_RATE)); 153 if (ret) { 154 dev_err(encoder->dev->dev, 155 "vsync_clk clk_set_rate failed, %d\n", ret); 156 return ret; 157 } 158 ret = clk_prepare_enable(mdp5_kms->vsync_clk); 159 if (ret) { 160 dev_err(encoder->dev->dev, 161 "vsync_clk clk_prepare_enable failed, %d\n", ret); 162 return ret; 163 } 164 165 mdp5_write(mdp5_kms, REG_MDP5_PP_TEAR_CHECK_EN(pp_id), 1); 166 167 return 0; 168} 169 170static void pingpong_tearcheck_disable(struct drm_encoder *encoder) 171{ 172 struct mdp5_kms *mdp5_kms = get_kms(encoder); 173 int pp_id = GET_PING_PONG_ID(mdp5_crtc_get_lm(encoder->crtc)); 174 175 mdp5_write(mdp5_kms, REG_MDP5_PP_TEAR_CHECK_EN(pp_id), 0); 176 clk_disable_unprepare(mdp5_kms->vsync_clk); 177} 178 179static void mdp5_cmd_encoder_destroy(struct drm_encoder *encoder) 180{ 181 struct mdp5_cmd_encoder *mdp5_cmd_enc = to_mdp5_cmd_encoder(encoder); 182 bs_fini(mdp5_cmd_enc); 183 drm_encoder_cleanup(encoder); 184 kfree(mdp5_cmd_enc); 185} 186 187static const struct drm_encoder_funcs mdp5_cmd_encoder_funcs = { 188 .destroy = mdp5_cmd_encoder_destroy, 189}; 190 191static bool mdp5_cmd_encoder_mode_fixup(struct drm_encoder *encoder, 192 const struct drm_display_mode *mode, 193 struct drm_display_mode *adjusted_mode) 194{ 195 return true; 196} 197 198static void mdp5_cmd_encoder_mode_set(struct drm_encoder *encoder, 199 struct drm_display_mode *mode, 200 struct drm_display_mode *adjusted_mode) 201{ 202 struct mdp5_cmd_encoder *mdp5_cmd_enc = to_mdp5_cmd_encoder(encoder); 203 204 mode = adjusted_mode; 205 206 DBG("set mode: %d:\"%s\" %d %d %d %d %d %d %d %d %d %d 0x%x 0x%x", 207 mode->base.id, mode->name, 208 mode->vrefresh, mode->clock, 209 mode->hdisplay, mode->hsync_start, 210 mode->hsync_end, mode->htotal, 211 mode->vdisplay, mode->vsync_start, 212 mode->vsync_end, mode->vtotal, 213 mode->type, mode->flags); 214 pingpong_tearcheck_setup(encoder, mode); 215 mdp5_crtc_set_pipeline(encoder->crtc, &mdp5_cmd_enc->intf, 216 mdp5_cmd_enc->ctl); 217} 218 219static void mdp5_cmd_encoder_disable(struct drm_encoder *encoder) 220{ 221 struct mdp5_cmd_encoder *mdp5_cmd_enc = to_mdp5_cmd_encoder(encoder); 222 struct mdp5_ctl *ctl = mdp5_cmd_enc->ctl; 223 struct mdp5_interface *intf = &mdp5_cmd_enc->intf; 224 225 if (WARN_ON(!mdp5_cmd_enc->enabled)) 226 return; 227 228 pingpong_tearcheck_disable(encoder); 229 230 mdp5_ctl_set_encoder_state(ctl, false); 231 mdp5_ctl_commit(ctl, mdp_ctl_flush_mask_encoder(intf)); 232 233 bs_set(mdp5_cmd_enc, 0); 234 235 mdp5_cmd_enc->enabled = false; 236} 237 238static void mdp5_cmd_encoder_enable(struct drm_encoder *encoder) 239{ 240 struct mdp5_cmd_encoder *mdp5_cmd_enc = to_mdp5_cmd_encoder(encoder); 241 struct mdp5_ctl *ctl = mdp5_cmd_enc->ctl; 242 struct mdp5_interface *intf = &mdp5_cmd_enc->intf; 243 244 if (WARN_ON(mdp5_cmd_enc->enabled)) 245 return; 246 247 bs_set(mdp5_cmd_enc, 1); 248 if (pingpong_tearcheck_enable(encoder)) 249 return; 250 251 mdp5_ctl_commit(ctl, mdp_ctl_flush_mask_encoder(intf)); 252 253 mdp5_ctl_set_encoder_state(ctl, true); 254 255 mdp5_cmd_enc->enabled = true; 256} 257 258static const struct drm_encoder_helper_funcs mdp5_cmd_encoder_helper_funcs = { 259 .mode_fixup = mdp5_cmd_encoder_mode_fixup, 260 .mode_set = mdp5_cmd_encoder_mode_set, 261 .disable = mdp5_cmd_encoder_disable, 262 .enable = mdp5_cmd_encoder_enable, 263}; 264 265int mdp5_cmd_encoder_set_split_display(struct drm_encoder *encoder, 266 struct drm_encoder *slave_encoder) 267{ 268 struct mdp5_cmd_encoder *mdp5_cmd_enc = to_mdp5_cmd_encoder(encoder); 269 struct mdp5_kms *mdp5_kms; 270 int intf_num; 271 u32 data = 0; 272 273 if (!encoder || !slave_encoder) 274 return -EINVAL; 275 276 mdp5_kms = get_kms(encoder); 277 intf_num = mdp5_cmd_enc->intf.num; 278 279 /* Switch slave encoder's trigger MUX, to use the master's 280 * start signal for the slave encoder 281 */ 282 if (intf_num == 1) 283 data |= MDP5_MDP_SPLIT_DPL_UPPER_INTF2_SW_TRG_MUX; 284 else if (intf_num == 2) 285 data |= MDP5_MDP_SPLIT_DPL_UPPER_INTF1_SW_TRG_MUX; 286 else 287 return -EINVAL; 288 289 /* Smart Panel, Sync mode */ 290 data |= MDP5_MDP_SPLIT_DPL_UPPER_SMART_PANEL; 291 292 /* Make sure clocks are on when connectors calling this function. */ 293 mdp5_enable(mdp5_kms); 294 mdp5_write(mdp5_kms, REG_MDP5_MDP_SPLIT_DPL_UPPER(0), data); 295 296 mdp5_write(mdp5_kms, REG_MDP5_MDP_SPLIT_DPL_LOWER(0), 297 MDP5_MDP_SPLIT_DPL_LOWER_SMART_PANEL); 298 mdp5_write(mdp5_kms, REG_MDP5_MDP_SPLIT_DPL_EN(0), 1); 299 mdp5_disable(mdp5_kms); 300 301 return 0; 302} 303 304/* initialize command mode encoder */ 305struct drm_encoder *mdp5_cmd_encoder_init(struct drm_device *dev, 306 struct mdp5_interface *intf, struct mdp5_ctl *ctl) 307{ 308 struct drm_encoder *encoder = NULL; 309 struct mdp5_cmd_encoder *mdp5_cmd_enc; 310 int ret; 311 312 if (WARN_ON((intf->type != INTF_DSI) && 313 (intf->mode != MDP5_INTF_DSI_MODE_COMMAND))) { 314 ret = -EINVAL; 315 goto fail; 316 } 317 318 mdp5_cmd_enc = kzalloc(sizeof(*mdp5_cmd_enc), GFP_KERNEL); 319 if (!mdp5_cmd_enc) { 320 ret = -ENOMEM; 321 goto fail; 322 } 323 324 memcpy(&mdp5_cmd_enc->intf, intf, sizeof(mdp5_cmd_enc->intf)); 325 encoder = &mdp5_cmd_enc->base; 326 mdp5_cmd_enc->ctl = ctl; 327 328 drm_encoder_init(dev, encoder, &mdp5_cmd_encoder_funcs, 329 DRM_MODE_ENCODER_DSI); 330 331 drm_encoder_helper_add(encoder, &mdp5_cmd_encoder_helper_funcs); 332 333 bs_init(mdp5_cmd_enc); 334 335 return encoder; 336 337fail: 338 if (encoder) 339 mdp5_cmd_encoder_destroy(encoder); 340 341 return ERR_PTR(ret); 342} 343 344