| /* Copyright (c) 2015-2017, The Linux Foundation. All rights reserved. |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License version 2 and |
| * only version 2 as published by the Free Software Foundation. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| */ |
| |
| #define pr_fmt(fmt) "[drm:%s:%d] " fmt, __func__, __LINE__ |
| #include <linux/debugfs.h> |
| #include <linux/seq_file.h> |
| |
| #include "msm_drv.h" |
| #include "sde_kms.h" |
| #include "drm_crtc.h" |
| #include "drm_crtc_helper.h" |
| |
| #include "sde_hwio.h" |
| #include "sde_hw_catalog.h" |
| #include "sde_hw_intf.h" |
| #include "sde_hw_ctl.h" |
| #include "sde_formats.h" |
| #include "sde_encoder_phys.h" |
| #include "sde_color_processing.h" |
| |
| #define SDE_DEBUG_ENC(e, fmt, ...) SDE_DEBUG("enc%d " fmt,\ |
| (e) ? (e)->base.base.id : -1, ##__VA_ARGS__) |
| |
| #define SDE_ERROR_ENC(e, fmt, ...) SDE_ERROR("enc%d " fmt,\ |
| (e) ? (e)->base.base.id : -1, ##__VA_ARGS__) |
| |
| /* |
| * Two to anticipate panels that can do cmd/vid dynamic switching |
| * plan is to create all possible physical encoder types, and switch between |
| * them at runtime |
| */ |
| #define NUM_PHYS_ENCODER_TYPES 2 |
| |
| #define MAX_PHYS_ENCODERS_PER_VIRTUAL \ |
| (MAX_H_TILES_PER_DISPLAY * NUM_PHYS_ENCODER_TYPES) |
| |
| /* Wait timeout sized on worst case of 4 60fps frames ~= 67ms */ |
| #define WAIT_TIMEOUT_MSEC 67 |
| |
| /** |
| * struct sde_encoder_virt - virtual encoder. Container of one or more physical |
| * encoders. Virtual encoder manages one "logical" display. Physical |
| * encoders manage one intf block, tied to a specific panel/sub-panel. |
| * Virtual encoder defers as much as possible to the physical encoders. |
| * Virtual encoder registers itself with the DRM Framework as the encoder. |
| * @base: drm_encoder base class for registration with DRM |
| * @spin_lock: Lock for IRQ purposes |
| * @bus_scaling_client: Client handle to the bus scaling interface |
| * @num_phys_encs: Actual number of physical encoders contained. |
| * @phys_encs: Container of physical encoders managed. |
| * @cur_master: Pointer to the current master in this mode. Optimization |
| * Only valid after enable. Cleared as disable. |
| * @crtc_vblank_cb: Callback into the upper layer / CRTC for |
| * notification of the VBLANK |
| * @crtc_vblank_cb_data: Data from upper layer for VBLANK notification |
| * @pending_kickoff_mask: Bitmask used to track which physical encoders |
| * still have pending transmissions before we can |
| * trigger the next kickoff. Bitmask tracks the |
| * index of the phys_enc table. Protect since |
| * shared between irq and commit thread |
| * @crtc_kickoff_cb: Callback into CRTC that will flush & start |
| * all CTL paths |
| * @crtc_kickoff_cb_data: Opaque user data given to crtc_kickoff_cb |
| * @pending_kickoff_mask: Bitmask tracking which phys_enc we are still |
| * waiting on before we can trigger the next |
| * kickoff. Bit0 = phys_encs[0] etc. |
| * @pending_kickoff_wq: Wait queue commit thread to wait on phys_encs |
| * become ready for kickoff in IRQ contexts |
| * @debugfs_root: Debug file system root file node |
| * @enc_lock: Lock around physical encoder create/destroy and |
| access. |
| */ |
| struct sde_encoder_virt { |
| struct drm_encoder base; |
| spinlock_t spin_lock; |
| uint32_t bus_scaling_client; |
| |
| uint32_t display_num_of_h_tiles; |
| |
| unsigned int num_phys_encs; |
| struct sde_encoder_phys *phys_encs[MAX_PHYS_ENCODERS_PER_VIRTUAL]; |
| struct sde_encoder_phys *cur_master; |
| |
| void (*crtc_vblank_cb)(void *); |
| void *crtc_vblank_cb_data; |
| |
| unsigned int pending_kickoff_mask; |
| wait_queue_head_t pending_kickoff_wq; |
| |
| struct dentry *debugfs_root; |
| struct mutex enc_lock; |
| }; |
| |
| #define to_sde_encoder_virt(x) container_of(x, struct sde_encoder_virt, base) |
| |
| #ifdef CONFIG_QCOM_BUS_SCALING |
| #include <linux/msm-bus.h> |
| #include <linux/msm-bus-board.h> |
| #define MDP_BUS_VECTOR_ENTRY(ab_val, ib_val) \ |
| { \ |
| .src = MSM_BUS_MASTER_MDP_PORT0, \ |
| .dst = MSM_BUS_SLAVE_EBI_CH0, \ |
| .ab = (ab_val), \ |
| .ib = (ib_val), \ |
| } |
| |
| static struct msm_bus_vectors mdp_bus_vectors[] = { |
| MDP_BUS_VECTOR_ENTRY(0, 0), |
| MDP_BUS_VECTOR_ENTRY(8000000000, 8000000000), |
| }; |
| |
| static struct msm_bus_paths mdp_bus_usecases[] = { { |
| .num_paths = 1, |
| .vectors = |
| &mdp_bus_vectors[0], |
| }, { |
| .num_paths = 1, |
| .vectors = |
| &mdp_bus_vectors[1], |
| } |
| }; |
| |
| static struct msm_bus_scale_pdata mdp_bus_scale_table = { |
| .usecase = mdp_bus_usecases, |
| .num_usecases = ARRAY_SIZE(mdp_bus_usecases), |
| .name = "mdss_mdp", |
| }; |
| |
| static void bs_init(struct sde_encoder_virt *sde_enc) |
| { |
| if (!sde_enc) { |
| SDE_ERROR("invalid encoder\n"); |
| return; |
| } |
| |
| sde_enc->bus_scaling_client = |
| msm_bus_scale_register_client(&mdp_bus_scale_table); |
| SDE_DEBUG_ENC(sde_enc, "bus scale client %08x\n", |
| sde_enc->bus_scaling_client); |
| } |
| |
| static void bs_fini(struct sde_encoder_virt *sde_enc) |
| { |
| if (!sde_enc) { |
| SDE_ERROR("invalid encoder\n"); |
| return; |
| } |
| |
| if (sde_enc->bus_scaling_client) { |
| msm_bus_scale_unregister_client(sde_enc->bus_scaling_client); |
| sde_enc->bus_scaling_client = 0; |
| } |
| } |
| |
| static void bs_set(struct sde_encoder_virt *sde_enc, int idx) |
| { |
| if (!sde_enc) { |
| SDE_ERROR("invalid encoder\n"); |
| return; |
| } |
| |
| if (sde_enc->bus_scaling_client) { |
| SDE_DEBUG_ENC(sde_enc, "set bus scaling to %d\n", idx); |
| idx = 1; |
| msm_bus_scale_client_update_request(sde_enc->bus_scaling_client, |
| idx); |
| } |
| } |
| #else |
| static void bs_init(struct sde_encoder_virt *sde_enc) |
| { |
| } |
| |
| static void bs_fini(struct sde_encoder_virt *sde_enc) |
| { |
| } |
| |
| static void bs_set(struct sde_encoder_virt *sde_enc, int idx) |
| { |
| } |
| #endif |
| |
| void sde_encoder_get_hw_resources(struct drm_encoder *drm_enc, |
| struct sde_encoder_hw_resources *hw_res, |
| struct drm_connector_state *conn_state) |
| { |
| struct sde_encoder_virt *sde_enc = NULL; |
| int i = 0; |
| |
| if (!hw_res || !drm_enc || !conn_state) { |
| SDE_ERROR("invalid argument(s), drm_enc %d, res %d, state %d\n", |
| drm_enc != 0, hw_res != 0, conn_state != 0); |
| return; |
| } |
| |
| sde_enc = to_sde_encoder_virt(drm_enc); |
| SDE_DEBUG_ENC(sde_enc, "\n"); |
| |
| /* Query resources used by phys encs, expected to be without overlap */ |
| memset(hw_res, 0, sizeof(*hw_res)); |
| hw_res->display_num_of_h_tiles = sde_enc->display_num_of_h_tiles; |
| |
| for (i = 0; i < sde_enc->num_phys_encs; i++) { |
| struct sde_encoder_phys *phys = sde_enc->phys_encs[i]; |
| |
| if (phys && phys->ops.get_hw_resources) |
| phys->ops.get_hw_resources(phys, hw_res, conn_state); |
| } |
| } |
| |
| void sde_encoder_destroy(struct drm_encoder *drm_enc) |
| { |
| struct sde_encoder_virt *sde_enc = NULL; |
| int i = 0; |
| |
| if (!drm_enc) { |
| SDE_ERROR("invalid encoder\n"); |
| return; |
| } |
| |
| sde_enc = to_sde_encoder_virt(drm_enc); |
| SDE_DEBUG_ENC(sde_enc, "\n"); |
| |
| mutex_lock(&sde_enc->enc_lock); |
| for (i = 0; i < sde_enc->num_phys_encs; i++) { |
| struct sde_encoder_phys *phys = sde_enc->phys_encs[i]; |
| |
| if (phys && phys->ops.destroy) { |
| phys->ops.destroy(phys); |
| --sde_enc->num_phys_encs; |
| sde_enc->phys_encs[i] = NULL; |
| } |
| } |
| |
| if (sde_enc->num_phys_encs) |
| SDE_ERROR_ENC(sde_enc, "expected 0 num_phys_encs not %d\n", |
| sde_enc->num_phys_encs); |
| sde_enc->num_phys_encs = 0; |
| mutex_unlock(&sde_enc->enc_lock); |
| |
| drm_encoder_cleanup(drm_enc); |
| bs_fini(sde_enc); |
| debugfs_remove_recursive(sde_enc->debugfs_root); |
| mutex_destroy(&sde_enc->enc_lock); |
| |
| kfree(sde_enc); |
| } |
| |
| static int sde_encoder_virt_atomic_check( |
| struct drm_encoder *drm_enc, |
| struct drm_crtc_state *crtc_state, |
| struct drm_connector_state *conn_state) |
| { |
| struct sde_encoder_virt *sde_enc; |
| struct msm_drm_private *priv; |
| struct sde_kms *sde_kms; |
| const struct drm_display_mode *mode; |
| struct drm_display_mode *adj_mode; |
| int i = 0; |
| int ret = 0; |
| |
| if (!drm_enc || !crtc_state || !conn_state) { |
| SDE_ERROR("invalid arg(s), drm_enc %d, crtc/conn state %d/%d\n", |
| drm_enc != 0, crtc_state != 0, conn_state != 0); |
| return -EINVAL; |
| } |
| |
| sde_enc = to_sde_encoder_virt(drm_enc); |
| SDE_DEBUG_ENC(sde_enc, "\n"); |
| |
| priv = drm_enc->dev->dev_private; |
| sde_kms = to_sde_kms(priv->kms); |
| mode = &crtc_state->mode; |
| adj_mode = &crtc_state->adjusted_mode; |
| MSM_EVT(drm_enc->dev, 0, 0); |
| |
| /* perform atomic check on the first physical encoder (master) */ |
| for (i = 0; i < sde_enc->num_phys_encs; i++) { |
| struct sde_encoder_phys *phys = sde_enc->phys_encs[i]; |
| |
| if (phys && phys->ops.atomic_check) |
| ret = phys->ops.atomic_check(phys, crtc_state, |
| conn_state); |
| else if (phys && phys->ops.mode_fixup) |
| if (!phys->ops.mode_fixup(phys, mode, adj_mode)) |
| ret = -EINVAL; |
| |
| if (ret) { |
| SDE_ERROR_ENC(sde_enc, |
| "mode unsupported, phys idx %d\n", i); |
| break; |
| } |
| } |
| |
| /* Reserve dynamic resources now. Indicating AtomicTest phase */ |
| if (!ret) |
| ret = sde_rm_reserve(&sde_kms->rm, drm_enc, crtc_state, |
| conn_state, true); |
| |
| if (!ret) { |
| sde_cp_crtc_install_properties(drm_enc->crtc); |
| /* populate mode->crtc* information required by framework */ |
| drm_mode_set_crtcinfo(adj_mode, 0); |
| } |
| |
| MSM_EVT(drm_enc->dev, adj_mode->flags, adj_mode->private_flags); |
| |
| return ret; |
| } |
| |
| static void sde_encoder_virt_mode_set(struct drm_encoder *drm_enc, |
| struct drm_display_mode *mode, |
| struct drm_display_mode *adj_mode) |
| { |
| struct sde_encoder_virt *sde_enc; |
| struct msm_drm_private *priv; |
| struct sde_kms *sde_kms; |
| struct list_head *connector_list; |
| struct drm_connector *conn = NULL, *conn_iter; |
| int i = 0, ret; |
| |
| if (!drm_enc) { |
| SDE_ERROR("invalid encoder\n"); |
| return; |
| } |
| |
| sde_enc = to_sde_encoder_virt(drm_enc); |
| SDE_DEBUG_ENC(sde_enc, "\n"); |
| |
| priv = drm_enc->dev->dev_private; |
| sde_kms = to_sde_kms(priv->kms); |
| connector_list = &sde_kms->dev->mode_config.connector_list; |
| |
| MSM_EVT(drm_enc->dev, 0, 0); |
| |
| list_for_each_entry(conn_iter, connector_list, head) |
| if (conn_iter->encoder == drm_enc) |
| conn = conn_iter; |
| |
| if (!conn) { |
| SDE_ERROR_ENC(sde_enc, "failed to find attached connector\n"); |
| return; |
| } else if (!conn->state) { |
| SDE_ERROR_ENC(sde_enc, "invalid connector state\n"); |
| return; |
| } |
| |
| /* Reserve dynamic resources now. Indicating non-AtomicTest phase */ |
| ret = sde_rm_reserve(&sde_kms->rm, drm_enc, drm_enc->crtc->state, |
| conn->state, false); |
| if (ret) { |
| SDE_ERROR_ENC(sde_enc, |
| "failed to reserve hw resources, %d\n", ret); |
| return; |
| } |
| |
| for (i = 0; i < sde_enc->num_phys_encs; i++) { |
| struct sde_encoder_phys *phys = sde_enc->phys_encs[i]; |
| |
| if (phys) { |
| phys->connector = conn->state->connector; |
| if (phys->ops.mode_set) |
| phys->ops.mode_set(phys, mode, adj_mode); |
| } |
| } |
| } |
| |
| static void sde_encoder_virt_enable(struct drm_encoder *drm_enc) |
| { |
| struct sde_encoder_virt *sde_enc = NULL; |
| struct msm_drm_private *priv; |
| struct sde_kms *sde_kms; |
| int i = 0; |
| |
| if (!drm_enc) { |
| SDE_ERROR("invalid encoder\n"); |
| return; |
| } else if (!drm_enc->dev) { |
| SDE_ERROR("invalid dev\n"); |
| return; |
| } else if (!drm_enc->dev->dev_private) { |
| SDE_ERROR("invalid dev_private\n"); |
| return; |
| } |
| |
| sde_enc = to_sde_encoder_virt(drm_enc); |
| priv = drm_enc->dev->dev_private; |
| sde_kms = to_sde_kms(priv->kms); |
| |
| SDE_DEBUG_ENC(sde_enc, "\n"); |
| |
| MSM_EVT(drm_enc->dev, 0, 0); |
| |
| sde_power_resource_enable(&priv->phandle, sde_kms->core_client, true); |
| |
| bs_set(sde_enc, 1); |
| |
| for (i = 0; i < sde_enc->num_phys_encs; i++) { |
| struct sde_encoder_phys *phys = sde_enc->phys_encs[i]; |
| |
| if (phys) { |
| atomic_set(&phys->vsync_cnt, 0); |
| atomic_set(&phys->underrun_cnt, 0); |
| |
| if (phys->ops.enable) |
| phys->ops.enable(phys); |
| |
| /* |
| * Master can switch at enable time. |
| * It is based on the current mode (CMD/VID) and |
| * the encoder role found at panel probe time |
| */ |
| if (phys->ops.is_master && phys->ops.is_master(phys)) { |
| SDE_DEBUG_ENC(sde_enc, |
| "master is now idx %d\n", i); |
| sde_enc->cur_master = phys; |
| } |
| } |
| } |
| } |
| |
| static void sde_encoder_virt_disable(struct drm_encoder *drm_enc) |
| { |
| struct sde_encoder_virt *sde_enc = NULL; |
| struct msm_drm_private *priv; |
| struct sde_kms *sde_kms; |
| int i = 0; |
| |
| if (!drm_enc) { |
| SDE_ERROR("invalid encoder\n"); |
| return; |
| } else if (!drm_enc->dev) { |
| SDE_ERROR("invalid dev\n"); |
| return; |
| } else if (!drm_enc->dev->dev_private) { |
| SDE_ERROR("invalid dev_private\n"); |
| return; |
| } |
| |
| sde_enc = to_sde_encoder_virt(drm_enc); |
| SDE_DEBUG_ENC(sde_enc, "\n"); |
| |
| priv = drm_enc->dev->dev_private; |
| sde_kms = to_sde_kms(priv->kms); |
| |
| MSM_EVT(drm_enc->dev, 0, 0); |
| |
| for (i = 0; i < sde_enc->num_phys_encs; i++) { |
| struct sde_encoder_phys *phys = sde_enc->phys_encs[i]; |
| |
| if (phys) { |
| if (phys->ops.disable && !phys->ops.is_master(phys)) |
| phys->ops.disable(phys); |
| phys->connector = NULL; |
| } |
| } |
| |
| if (sde_enc->cur_master && sde_enc->cur_master->ops.disable) |
| sde_enc->cur_master->ops.disable(sde_enc->cur_master); |
| |
| sde_enc->cur_master = NULL; |
| SDE_DEBUG_ENC(sde_enc, "cleared master\n"); |
| |
| bs_set(sde_enc, 0); |
| sde_cp_crtc_destroy_properties(drm_enc->crtc); |
| |
| sde_rm_release(&sde_kms->rm, drm_enc); |
| |
| sde_power_resource_enable(&priv->phandle, sde_kms->core_client, false); |
| } |
| |
| static const struct drm_encoder_helper_funcs sde_encoder_helper_funcs = { |
| .mode_set = sde_encoder_virt_mode_set, |
| .disable = sde_encoder_virt_disable, |
| .enable = sde_encoder_virt_enable, |
| .atomic_check = sde_encoder_virt_atomic_check, |
| }; |
| |
| static const struct drm_encoder_funcs sde_encoder_funcs = { |
| .destroy = sde_encoder_destroy, |
| }; |
| |
| static enum sde_intf sde_encoder_get_intf(struct sde_mdss_cfg *catalog, |
| enum sde_intf_type type, u32 controller_id) |
| { |
| int i = 0; |
| |
| for (i = 0; i < catalog->intf_count; i++) { |
| if (catalog->intf[i].type == type |
| && catalog->intf[i].controller_id == controller_id) { |
| return catalog->intf[i].id; |
| } |
| } |
| |
| return INTF_MAX; |
| } |
| |
| static enum sde_wb sde_encoder_get_wb(struct sde_mdss_cfg *catalog, |
| enum sde_intf_type type, u32 controller_id) |
| { |
| if (controller_id < catalog->wb_count) |
| return catalog->wb[controller_id].id; |
| |
| return WB_MAX; |
| } |
| |
| static void sde_encoder_vblank_callback(struct drm_encoder *drm_enc, |
| struct sde_encoder_phys *phy_enc) |
| { |
| struct sde_encoder_virt *sde_enc = NULL; |
| unsigned long lock_flags; |
| |
| if (!drm_enc || !phy_enc) |
| return; |
| |
| sde_enc = to_sde_encoder_virt(drm_enc); |
| |
| spin_lock_irqsave(&sde_enc->spin_lock, lock_flags); |
| if (sde_enc->crtc_vblank_cb) |
| sde_enc->crtc_vblank_cb(sde_enc->crtc_vblank_cb_data); |
| spin_unlock_irqrestore(&sde_enc->spin_lock, lock_flags); |
| |
| atomic_inc(&phy_enc->vsync_cnt); |
| } |
| |
| static void sde_encoder_underrun_callback(struct drm_encoder *drm_enc, |
| struct sde_encoder_phys *phy_enc) |
| { |
| if (!phy_enc) |
| return; |
| |
| atomic_inc(&phy_enc->underrun_cnt); |
| } |
| |
| void sde_encoder_register_vblank_callback(struct drm_encoder *drm_enc, |
| void (*vbl_cb)(void *), void *vbl_data) |
| { |
| struct sde_encoder_virt *sde_enc = to_sde_encoder_virt(drm_enc); |
| unsigned long lock_flags; |
| bool enable; |
| int i; |
| |
| enable = vbl_cb ? true : false; |
| |
| if (!drm_enc) { |
| SDE_ERROR("invalid encoder\n"); |
| return; |
| } |
| SDE_DEBUG_ENC(sde_enc, "\n"); |
| MSM_EVT(drm_enc->dev, enable, 0); |
| |
| spin_lock_irqsave(&sde_enc->spin_lock, lock_flags); |
| sde_enc->crtc_vblank_cb = vbl_cb; |
| sde_enc->crtc_vblank_cb_data = vbl_data; |
| spin_unlock_irqrestore(&sde_enc->spin_lock, lock_flags); |
| |
| for (i = 0; i < sde_enc->num_phys_encs; i++) { |
| struct sde_encoder_phys *phys = sde_enc->phys_encs[i]; |
| |
| if (phys && phys->ops.control_vblank_irq) |
| phys->ops.control_vblank_irq(phys, enable); |
| } |
| } |
| |
| static void sde_encoder_handle_phys_enc_ready_for_kickoff( |
| struct drm_encoder *drm_enc, |
| struct sde_encoder_phys *ready_phys) |
| { |
| struct sde_encoder_virt *sde_enc = to_sde_encoder_virt(drm_enc); |
| unsigned long lock_flags; |
| unsigned int i, mask; |
| |
| /* One of the physical encoders has become ready for kickoff */ |
| for (i = 0; i < sde_enc->num_phys_encs; i++) { |
| if (sde_enc->phys_encs[i] == ready_phys) { |
| spin_lock_irqsave(&sde_enc->spin_lock, lock_flags); |
| sde_enc->pending_kickoff_mask &= ~(1 << i); |
| mask = sde_enc->pending_kickoff_mask; |
| spin_unlock_irqrestore(&sde_enc->spin_lock, lock_flags); |
| MSM_EVT(drm_enc->dev, i, mask); |
| } |
| } |
| |
| /* Wake the commit thread to check if they all ready for kickoff */ |
| wake_up_all(&sde_enc->pending_kickoff_wq); |
| } |
| |
| /** |
| * _sde_encoder_trigger_flush - trigger flush for a physical encoder |
| * drm_enc: Pointer to drm encoder structure |
| * phys: Pointer to physical encoder structure |
| * extra_flush_bits: Additional bit mask to include in flush trigger |
| */ |
| static inline void _sde_encoder_trigger_flush(struct drm_encoder *drm_enc, |
| struct sde_encoder_phys *phys, uint32_t extra_flush_bits) |
| { |
| struct sde_hw_ctl *ctl; |
| |
| if (!drm_enc || !phys) { |
| SDE_ERROR("invalid argument(s), drm_enc %d, phys_enc %d\n", |
| drm_enc != 0, phys != 0); |
| return; |
| } |
| |
| ctl = phys->hw_ctl; |
| if (!ctl || !ctl->ops.trigger_flush) { |
| SDE_ERROR("missing trigger cb\n"); |
| return; |
| } |
| |
| if (extra_flush_bits && ctl->ops.update_pending_flush) |
| ctl->ops.update_pending_flush(ctl, extra_flush_bits); |
| |
| ctl->ops.trigger_flush(ctl); |
| MSM_EVT(drm_enc->dev, drm_enc->base.id, ctl->idx); |
| } |
| |
| /** |
| * _sde_encoder_trigger_start - trigger start for a physical encoder |
| * phys: Pointer to physical encoder structure |
| */ |
| static inline void _sde_encoder_trigger_start(struct sde_encoder_phys *phys) |
| { |
| if (!phys) { |
| SDE_ERROR("invalid encoder\n"); |
| return; |
| } |
| |
| if (phys->ops.trigger_start && phys->enable_state != SDE_ENC_DISABLED) |
| phys->ops.trigger_start(phys); |
| } |
| |
| void sde_encoder_helper_trigger_start(struct sde_encoder_phys *phys_enc) |
| { |
| struct sde_hw_ctl *ctl; |
| int ctl_idx = -1; |
| |
| if (!phys_enc) { |
| SDE_ERROR("invalid encoder\n"); |
| return; |
| } |
| |
| ctl = phys_enc->hw_ctl; |
| if (ctl && ctl->ops.trigger_start) { |
| ctl->ops.trigger_start(ctl); |
| ctl_idx = ctl->idx; |
| } |
| |
| if (phys_enc && phys_enc->parent) |
| MSM_EVT(phys_enc->parent->dev, |
| phys_enc->parent->base.id, |
| ctl_idx); |
| } |
| |
| /** |
| * _sde_encoder_kickoff_phys - handle physical encoder kickoff |
| * Iterate through the physical encoders and perform consolidated flush |
| * and/or control start triggering as needed. This is done in the virtual |
| * encoder rather than the individual physical ones in order to handle |
| * use cases that require visibility into multiple physical encoders at |
| * a time. |
| * sde_enc: Pointer to virtual encoder structure |
| */ |
| static void _sde_encoder_kickoff_phys(struct sde_encoder_virt *sde_enc) |
| { |
| struct sde_hw_ctl *ctl; |
| uint32_t i, pending_flush; |
| |
| if (!sde_enc) { |
| SDE_ERROR("invalid encoder\n"); |
| return; |
| } |
| |
| pending_flush = 0x0; |
| |
| /* don't perform flush/start operations for slave encoders */ |
| for (i = 0; i < sde_enc->num_phys_encs; i++) { |
| struct sde_encoder_phys *phys = sde_enc->phys_encs[i]; |
| |
| ctl = phys->hw_ctl; |
| if (!ctl || phys->enable_state == SDE_ENC_DISABLED) |
| continue; |
| |
| if (!phys->ops.needs_split_flush || |
| !phys->ops.needs_split_flush(phys)) |
| _sde_encoder_trigger_flush(&sde_enc->base, phys, 0x0); |
| else if (ctl->ops.get_pending_flush) |
| pending_flush |= ctl->ops.get_pending_flush(ctl); |
| } |
| |
| /* for split flush, combine pending flush masks and send to master */ |
| if (pending_flush && sde_enc->cur_master) { |
| _sde_encoder_trigger_flush( |
| &sde_enc->base, |
| sde_enc->cur_master, |
| pending_flush); |
| } |
| |
| _sde_encoder_trigger_start(sde_enc->cur_master); |
| } |
| |
| void sde_encoder_schedule_kickoff(struct drm_encoder *drm_enc) |
| { |
| struct sde_encoder_virt *sde_enc; |
| struct sde_encoder_phys *phys; |
| unsigned long lock_flags; |
| bool need_to_wait; |
| unsigned int i; |
| int ret; |
| |
| if (!drm_enc) { |
| SDE_ERROR("invalid encoder\n"); |
| return; |
| } |
| sde_enc = to_sde_encoder_virt(drm_enc); |
| |
| SDE_DEBUG_ENC(sde_enc, "\n"); |
| MSM_EVT(drm_enc->dev, 0, 0); |
| |
| spin_lock_irqsave(&sde_enc->spin_lock, lock_flags); |
| sde_enc->pending_kickoff_mask = 0; |
| spin_unlock_irqrestore(&sde_enc->spin_lock, lock_flags); |
| |
| for (i = 0; i < sde_enc->num_phys_encs; i++) { |
| need_to_wait = false; |
| phys = sde_enc->phys_encs[i]; |
| |
| if (phys && phys->ops.prepare_for_kickoff) |
| phys->ops.prepare_for_kickoff(phys, &need_to_wait); |
| |
| if (need_to_wait) { |
| spin_lock_irqsave(&sde_enc->spin_lock, lock_flags); |
| sde_enc->pending_kickoff_mask |= 1 << i; |
| spin_unlock_irqrestore(&sde_enc->spin_lock, lock_flags); |
| } |
| } |
| |
| spin_lock_irqsave(&sde_enc->spin_lock, lock_flags); |
| MSM_EVT(drm_enc->dev, sde_enc->pending_kickoff_mask, 0); |
| spin_unlock_irqrestore(&sde_enc->spin_lock, lock_flags); |
| |
| /* Wait for the busy phys encs to be ready */ |
| ret = -ERESTARTSYS; |
| while (ret == -ERESTARTSYS) { |
| spin_lock_irqsave(&sde_enc->spin_lock, lock_flags); |
| ret = wait_event_interruptible_lock_irq_timeout( |
| sde_enc->pending_kickoff_wq, |
| sde_enc->pending_kickoff_mask == 0, |
| sde_enc->spin_lock, |
| msecs_to_jiffies(WAIT_TIMEOUT_MSEC)); |
| spin_unlock_irqrestore(&sde_enc->spin_lock, lock_flags); |
| if (!ret) |
| SDE_DEBUG_ENC(sde_enc, "wait %ums timed out\n", |
| WAIT_TIMEOUT_MSEC); |
| } |
| |
| /* All phys encs are ready to go, trigger the kickoff */ |
| _sde_encoder_kickoff_phys(sde_enc); |
| |
| /* Allow phys encs to handle any post-kickoff business */ |
| for (i = 0; i < sde_enc->num_phys_encs; i++) { |
| struct sde_encoder_phys *phys = sde_enc->phys_encs[i]; |
| |
| if (phys && phys->ops.handle_post_kickoff) |
| phys->ops.handle_post_kickoff(phys); |
| } |
| } |
| |
| static int _sde_encoder_status_show(struct seq_file *s, void *data) |
| { |
| struct sde_encoder_virt *sde_enc; |
| int i; |
| |
| if (!s || !s->private) |
| return -EINVAL; |
| |
| sde_enc = s->private; |
| |
| mutex_lock(&sde_enc->enc_lock); |
| for (i = 0; i < sde_enc->num_phys_encs; i++) { |
| struct sde_encoder_phys *phys = sde_enc->phys_encs[i]; |
| |
| if (!phys) |
| continue; |
| |
| seq_printf(s, "intf:%d vsync:%8d underrun:%8d ", |
| phys->intf_idx - INTF_0, |
| atomic_read(&phys->vsync_cnt), |
| atomic_read(&phys->underrun_cnt)); |
| |
| switch (phys->intf_mode) { |
| case INTF_MODE_VIDEO: |
| seq_puts(s, "mode: video\n"); |
| break; |
| case INTF_MODE_CMD: |
| seq_puts(s, "mode: command\n"); |
| break; |
| case INTF_MODE_WB_BLOCK: |
| seq_puts(s, "mode: wb block\n"); |
| break; |
| case INTF_MODE_WB_LINE: |
| seq_puts(s, "mode: wb line\n"); |
| break; |
| default: |
| seq_puts(s, "mode: ???\n"); |
| break; |
| } |
| } |
| mutex_unlock(&sde_enc->enc_lock); |
| |
| return 0; |
| } |
| |
| static int _sde_encoder_debugfs_status_open(struct inode *inode, |
| struct file *file) |
| { |
| return single_open(file, _sde_encoder_status_show, inode->i_private); |
| } |
| |
| static void _sde_encoder_init_debugfs(struct drm_encoder *drm_enc, |
| struct sde_encoder_virt *sde_enc, struct sde_kms *sde_kms) |
| { |
| static const struct file_operations debugfs_status_fops = { |
| .open = _sde_encoder_debugfs_status_open, |
| .read = seq_read, |
| .llseek = seq_lseek, |
| .release = single_release, |
| }; |
| char name[SDE_NAME_SIZE]; |
| |
| if (!drm_enc || !sde_enc || !sde_kms) { |
| SDE_ERROR("invalid encoder or kms\n"); |
| return; |
| } |
| |
| snprintf(name, SDE_NAME_SIZE, "encoder%u", drm_enc->base.id); |
| |
| /* create overall sub-directory for the encoder */ |
| sde_enc->debugfs_root = debugfs_create_dir(name, |
| sde_debugfs_get_root(sde_kms)); |
| if (sde_enc->debugfs_root) { |
| /* don't error check these */ |
| debugfs_create_file("status", 0644, |
| sde_enc->debugfs_root, sde_enc, &debugfs_status_fops); |
| } |
| } |
| |
| static int sde_encoder_virt_add_phys_encs( |
| u32 display_caps, |
| struct sde_encoder_virt *sde_enc, |
| struct sde_enc_phys_init_params *params) |
| { |
| struct sde_encoder_phys *enc = NULL; |
| |
| SDE_DEBUG_ENC(sde_enc, "\n"); |
| |
| /* |
| * We may create up to NUM_PHYS_ENCODER_TYPES physical encoder types |
| * in this function, check up-front. |
| */ |
| if (sde_enc->num_phys_encs + NUM_PHYS_ENCODER_TYPES >= |
| ARRAY_SIZE(sde_enc->phys_encs)) { |
| SDE_ERROR_ENC(sde_enc, "too many physical encoders %d\n", |
| sde_enc->num_phys_encs); |
| return -EINVAL; |
| } |
| |
| if (display_caps & MSM_DISPLAY_CAP_VID_MODE) { |
| enc = sde_encoder_phys_vid_init(params); |
| |
| if (IS_ERR_OR_NULL(enc)) { |
| SDE_ERROR_ENC(sde_enc, "failed to init vid enc: %ld\n", |
| PTR_ERR(enc)); |
| return enc == 0 ? -EINVAL : PTR_ERR(enc); |
| } |
| |
| sde_enc->phys_encs[sde_enc->num_phys_encs] = enc; |
| ++sde_enc->num_phys_encs; |
| } |
| |
| if (display_caps & MSM_DISPLAY_CAP_CMD_MODE) { |
| enc = sde_encoder_phys_cmd_init(params); |
| |
| if (IS_ERR_OR_NULL(enc)) { |
| SDE_ERROR_ENC(sde_enc, "failed to init cmd enc: %ld\n", |
| PTR_ERR(enc)); |
| return enc == 0 ? -EINVAL : PTR_ERR(enc); |
| } |
| |
| sde_enc->phys_encs[sde_enc->num_phys_encs] = enc; |
| ++sde_enc->num_phys_encs; |
| } |
| |
| return 0; |
| } |
| |
| static int sde_encoder_virt_add_phys_enc_wb(struct sde_encoder_virt *sde_enc, |
| struct sde_enc_phys_init_params *params) |
| { |
| struct sde_encoder_phys *enc = NULL; |
| |
| if (!sde_enc) { |
| SDE_ERROR("invalid encoder\n"); |
| return -EINVAL; |
| } |
| |
| SDE_DEBUG_ENC(sde_enc, "\n"); |
| |
| if (sde_enc->num_phys_encs + 1 >= ARRAY_SIZE(sde_enc->phys_encs)) { |
| SDE_ERROR_ENC(sde_enc, "too many physical encoders %d\n", |
| sde_enc->num_phys_encs); |
| return -EINVAL; |
| } |
| |
| enc = sde_encoder_phys_wb_init(params); |
| |
| if (IS_ERR_OR_NULL(enc)) { |
| SDE_ERROR_ENC(sde_enc, "failed to init wb enc: %ld\n", |
| PTR_ERR(enc)); |
| return enc == 0 ? -EINVAL : PTR_ERR(enc); |
| } |
| |
| sde_enc->phys_encs[sde_enc->num_phys_encs] = enc; |
| ++sde_enc->num_phys_encs; |
| |
| return 0; |
| } |
| |
| static int sde_encoder_setup_display(struct sde_encoder_virt *sde_enc, |
| struct sde_kms *sde_kms, |
| struct msm_display_info *disp_info, |
| int *drm_enc_mode) |
| { |
| int ret = 0; |
| int i = 0; |
| enum sde_intf_type intf_type; |
| struct sde_encoder_virt_ops parent_ops = { |
| sde_encoder_vblank_callback, |
| sde_encoder_underrun_callback, |
| sde_encoder_handle_phys_enc_ready_for_kickoff |
| }; |
| struct sde_enc_phys_init_params phys_params; |
| |
| if (!sde_enc || !sde_kms) { |
| SDE_ERROR("invalid arg(s), enc %d kms %d\n", |
| sde_enc != 0, sde_kms != 0); |
| return -EINVAL; |
| } |
| |
| memset(&phys_params, 0, sizeof(phys_params)); |
| phys_params.sde_kms = sde_kms; |
| phys_params.parent = &sde_enc->base; |
| phys_params.parent_ops = parent_ops; |
| |
| SDE_DEBUG("\n"); |
| |
| if (disp_info->intf_type == DRM_MODE_CONNECTOR_DSI) { |
| *drm_enc_mode = DRM_MODE_ENCODER_DSI; |
| intf_type = INTF_DSI; |
| } else if (disp_info->intf_type == DRM_MODE_CONNECTOR_HDMIA) { |
| *drm_enc_mode = DRM_MODE_ENCODER_TMDS; |
| intf_type = INTF_HDMI; |
| } else if (disp_info->intf_type == DRM_MODE_CONNECTOR_VIRTUAL) { |
| *drm_enc_mode = DRM_MODE_ENCODER_VIRTUAL; |
| intf_type = INTF_WB; |
| } else { |
| SDE_ERROR_ENC(sde_enc, "unsupported display interface type\n"); |
| return -EINVAL; |
| } |
| |
| WARN_ON(disp_info->num_of_h_tiles < 1); |
| |
| sde_enc->display_num_of_h_tiles = disp_info->num_of_h_tiles; |
| |
| SDE_DEBUG("dsi_info->num_of_h_tiles %d\n", disp_info->num_of_h_tiles); |
| |
| mutex_lock(&sde_enc->enc_lock); |
| for (i = 0; i < disp_info->num_of_h_tiles && !ret; i++) { |
| /* |
| * Left-most tile is at index 0, content is controller id |
| * h_tile_instance_ids[2] = {0, 1}; DSI0 = left, DSI1 = right |
| * h_tile_instance_ids[2] = {1, 0}; DSI1 = left, DSI0 = right |
| */ |
| u32 controller_id = disp_info->h_tile_instance[i]; |
| |
| if (disp_info->num_of_h_tiles > 1) { |
| if (i == 0) |
| phys_params.split_role = ENC_ROLE_MASTER; |
| else |
| phys_params.split_role = ENC_ROLE_SLAVE; |
| } else { |
| phys_params.split_role = ENC_ROLE_SOLO; |
| } |
| |
| SDE_DEBUG("h_tile_instance %d = %d, split_role %d\n", |
| i, controller_id, phys_params.split_role); |
| |
| if (intf_type == INTF_WB) { |
| phys_params.intf_idx = INTF_MAX; |
| phys_params.wb_idx = sde_encoder_get_wb( |
| sde_kms->catalog, |
| intf_type, controller_id); |
| if (phys_params.wb_idx == WB_MAX) { |
| SDE_ERROR_ENC(sde_enc, |
| "could not get wb: type %d, id %d\n", |
| intf_type, controller_id); |
| ret = -EINVAL; |
| } |
| } else { |
| phys_params.wb_idx = WB_MAX; |
| phys_params.intf_idx = sde_encoder_get_intf( |
| sde_kms->catalog, intf_type, |
| controller_id); |
| if (phys_params.intf_idx == INTF_MAX) { |
| SDE_ERROR_ENC(sde_enc, |
| "could not get wb: type %d, id %d\n", |
| intf_type, controller_id); |
| ret = -EINVAL; |
| } |
| } |
| |
| if (!ret) { |
| if (intf_type == INTF_WB) |
| ret = sde_encoder_virt_add_phys_enc_wb(sde_enc, |
| &phys_params); |
| else |
| ret = sde_encoder_virt_add_phys_encs( |
| disp_info->capabilities, |
| sde_enc, |
| &phys_params); |
| if (ret) |
| SDE_ERROR_ENC(sde_enc, |
| "failed to add phys encs\n"); |
| } |
| } |
| mutex_unlock(&sde_enc->enc_lock); |
| |
| |
| return ret; |
| } |
| |
| struct drm_encoder *sde_encoder_init( |
| struct drm_device *dev, |
| struct msm_display_info *disp_info) |
| { |
| struct msm_drm_private *priv = dev->dev_private; |
| struct sde_kms *sde_kms = to_sde_kms(priv->kms); |
| struct drm_encoder *drm_enc = NULL; |
| struct sde_encoder_virt *sde_enc = NULL; |
| int drm_enc_mode = DRM_MODE_ENCODER_NONE; |
| int ret = 0; |
| |
| sde_enc = kzalloc(sizeof(*sde_enc), GFP_KERNEL); |
| if (!sde_enc) { |
| ret = -ENOMEM; |
| goto fail; |
| } |
| |
| mutex_init(&sde_enc->enc_lock); |
| ret = sde_encoder_setup_display(sde_enc, sde_kms, disp_info, |
| &drm_enc_mode); |
| if (ret) |
| goto fail; |
| |
| sde_enc->cur_master = NULL; |
| spin_lock_init(&sde_enc->spin_lock); |
| drm_enc = &sde_enc->base; |
| drm_encoder_init(dev, drm_enc, &sde_encoder_funcs, drm_enc_mode); |
| drm_encoder_helper_add(drm_enc, &sde_encoder_helper_funcs); |
| bs_init(sde_enc); |
| sde_enc->pending_kickoff_mask = 0; |
| init_waitqueue_head(&sde_enc->pending_kickoff_wq); |
| |
| _sde_encoder_init_debugfs(drm_enc, sde_enc, sde_kms); |
| |
| SDE_DEBUG_ENC(sde_enc, "created\n"); |
| |
| return drm_enc; |
| |
| fail: |
| SDE_ERROR("failed to create encoder\n"); |
| if (drm_enc) |
| sde_encoder_destroy(drm_enc); |
| |
| return ERR_PTR(ret); |
| } |
| |
| int sde_encoder_wait_for_commit_done(struct drm_encoder *drm_enc) |
| { |
| struct sde_encoder_virt *sde_enc = NULL; |
| int i, ret = 0; |
| |
| if (!drm_enc) { |
| SDE_ERROR("invalid encoder\n"); |
| return -EINVAL; |
| } |
| sde_enc = to_sde_encoder_virt(drm_enc); |
| SDE_DEBUG_ENC(sde_enc, "\n"); |
| |
| for (i = 0; i < sde_enc->num_phys_encs; i++) { |
| struct sde_encoder_phys *phys = sde_enc->phys_encs[i]; |
| |
| if (phys && phys->ops.wait_for_commit_done) { |
| ret = phys->ops.wait_for_commit_done(phys); |
| if (ret) |
| return ret; |
| } |
| } |
| |
| return ret; |
| } |
| |