// SPDX-License-Identifier: GPL-2.0-only /* * Copyright (C) 2009 Nokia Corporation * Author: Tomi Valkeinen <[email protected]> */ #define DSS_SUBSYS_NAME … #include <linux/kernel.h> #include <linux/mfd/syscon.h> #include <linux/regmap.h> #include <linux/io.h> #include <linux/clk.h> #include <linux/device.h> #include <linux/err.h> #include <linux/interrupt.h> #include <linux/irq.h> #include <linux/delay.h> #include <linux/gpio/consumer.h> #include <linux/mutex.h> #include <linux/module.h> #include <linux/semaphore.h> #include <linux/seq_file.h> #include <linux/platform_device.h> #include <linux/regulator/consumer.h> #include <linux/wait.h> #include <linux/workqueue.h> #include <linux/sched.h> #include <linux/slab.h> #include <linux/debugfs.h> #include <linux/pm_runtime.h> #include <linux/of.h> #include <linux/of_graph.h> #include <linux/of_platform.h> #include <linux/component.h> #include <linux/sys_soc.h> #include <drm/drm_bridge.h> #include <drm/drm_mipi_dsi.h> #include <drm/drm_panel.h> #include <video/mipi_display.h> #include "omapdss.h" #include "dss.h" #define DSI_CATCH_MISSING_TE #include "dsi.h" #define REG_GET(dsi, idx, start, end) … #define REG_FLD_MOD(dsi, idx, val, start, end) … static int dsi_init_dispc(struct dsi_data *dsi); static void dsi_uninit_dispc(struct dsi_data *dsi); static int dsi_vc_send_null(struct dsi_data *dsi, int vc, int channel); static ssize_t _omap_dsi_host_transfer(struct dsi_data *dsi, int vc, const struct mipi_dsi_msg *msg); #ifdef DSI_PERF_MEASURE static bool dsi_perf; module_param(dsi_perf, bool, 0644); #endif /* Note: for some reason video mode seems to work only if VC_VIDEO is 0 */ #define VC_VIDEO … #define VC_CMD … #define drm_bridge_to_dsi(bridge) … static inline struct dsi_data *to_dsi_data(struct omap_dss_device *dssdev) { … } static inline struct dsi_data *host_to_omap(struct mipi_dsi_host *host) { … } static inline void dsi_write_reg(struct dsi_data *dsi, const struct dsi_reg idx, u32 val) { … } static inline u32 dsi_read_reg(struct dsi_data *dsi, const struct dsi_reg idx) { … } static void dsi_bus_lock(struct dsi_data *dsi) { … } static void dsi_bus_unlock(struct dsi_data *dsi) { … } static bool dsi_bus_is_locked(struct dsi_data *dsi) { … } static void dsi_completion_handler(void *data, u32 mask) { … } static inline bool wait_for_bit_change(struct dsi_data *dsi, const struct dsi_reg idx, int bitnum, int value) { … } #ifdef DSI_PERF_MEASURE static void dsi_perf_mark_setup(struct dsi_data *dsi) { dsi->perf_setup_time = ktime_get(); } static void dsi_perf_mark_start(struct dsi_data *dsi) { dsi->perf_start_time = ktime_get(); } static void dsi_perf_show(struct dsi_data *dsi, const char *name) { ktime_t t, setup_time, trans_time; u32 total_bytes; u32 setup_us, trans_us, total_us; if (!dsi_perf) return; t = ktime_get(); setup_time = ktime_sub(dsi->perf_start_time, dsi->perf_setup_time); setup_us = (u32)ktime_to_us(setup_time); if (setup_us == 0) setup_us = 1; trans_time = ktime_sub(t, dsi->perf_start_time); trans_us = (u32)ktime_to_us(trans_time); if (trans_us == 0) trans_us = 1; total_us = setup_us + trans_us; total_bytes = dsi->update_bytes; pr_info("DSI(%s): %u us + %u us = %u us (%uHz), %u bytes, %u kbytes/sec\n", name, setup_us, trans_us, total_us, 1000 * 1000 / total_us, total_bytes, total_bytes * 1000 / total_us); } #else static inline void dsi_perf_mark_setup(struct dsi_data *dsi) { … } static inline void dsi_perf_mark_start(struct dsi_data *dsi) { … } static inline void dsi_perf_show(struct dsi_data *dsi, const char *name) { … } #endif static int verbose_irq; static void print_irq_status(u32 status) { … } static void print_irq_status_vc(int vc, u32 status) { … } static void print_irq_status_cio(u32 status) { … } #ifdef CONFIG_OMAP2_DSS_COLLECT_IRQ_STATS static void dsi_collect_irq_stats(struct dsi_data *dsi, u32 irqstatus, u32 *vcstatus, u32 ciostatus) { … } #else #define dsi_collect_irq_stats … #endif static int debug_irq; static void dsi_handle_irq_errors(struct dsi_data *dsi, u32 irqstatus, u32 *vcstatus, u32 ciostatus) { … } static void dsi_call_isrs(struct dsi_isr_data *isr_array, unsigned int isr_array_size, u32 irqstatus) { … } static void dsi_handle_isrs(struct dsi_isr_tables *isr_tables, u32 irqstatus, u32 *vcstatus, u32 ciostatus) { … } static irqreturn_t omap_dsi_irq_handler(int irq, void *arg) { … } /* dsi->irq_lock has to be locked by the caller */ static void _omap_dsi_configure_irqs(struct dsi_data *dsi, struct dsi_isr_data *isr_array, unsigned int isr_array_size, u32 default_mask, const struct dsi_reg enable_reg, const struct dsi_reg status_reg) { … } /* dsi->irq_lock has to be locked by the caller */ static void _omap_dsi_set_irqs(struct dsi_data *dsi) { … } /* dsi->irq_lock has to be locked by the caller */ static void _omap_dsi_set_irqs_vc(struct dsi_data *dsi, int vc) { … } /* dsi->irq_lock has to be locked by the caller */ static void _omap_dsi_set_irqs_cio(struct dsi_data *dsi) { … } static void _dsi_initialize_irq(struct dsi_data *dsi) { … } static int _dsi_register_isr(omap_dsi_isr_t isr, void *arg, u32 mask, struct dsi_isr_data *isr_array, unsigned int isr_array_size) { … } static int _dsi_unregister_isr(omap_dsi_isr_t isr, void *arg, u32 mask, struct dsi_isr_data *isr_array, unsigned int isr_array_size) { … } static int dsi_register_isr(struct dsi_data *dsi, omap_dsi_isr_t isr, void *arg, u32 mask) { … } static int dsi_unregister_isr(struct dsi_data *dsi, omap_dsi_isr_t isr, void *arg, u32 mask) { … } static int dsi_register_isr_vc(struct dsi_data *dsi, int vc, omap_dsi_isr_t isr, void *arg, u32 mask) { … } static int dsi_unregister_isr_vc(struct dsi_data *dsi, int vc, omap_dsi_isr_t isr, void *arg, u32 mask) { … } static u32 dsi_get_errors(struct dsi_data *dsi) { … } static int dsi_runtime_get(struct dsi_data *dsi) { … } static void dsi_runtime_put(struct dsi_data *dsi) { … } static void _dsi_print_reset_status(struct dsi_data *dsi) { … } static inline int dsi_if_enable(struct dsi_data *dsi, bool enable) { … } static unsigned long dsi_get_pll_hsdiv_dispc_rate(struct dsi_data *dsi) { … } static unsigned long dsi_get_pll_hsdiv_dsi_rate(struct dsi_data *dsi) { … } static unsigned long dsi_get_txbyteclkhs(struct dsi_data *dsi) { … } static unsigned long dsi_fclk_rate(struct dsi_data *dsi) { … } static int dsi_lp_clock_calc(unsigned long dsi_fclk, unsigned long lp_clk_min, unsigned long lp_clk_max, struct dsi_lp_clock_info *lp_cinfo) { … } static int dsi_set_lp_clk_divisor(struct dsi_data *dsi) { … } static void dsi_enable_scp_clk(struct dsi_data *dsi) { … } static void dsi_disable_scp_clk(struct dsi_data *dsi) { … } enum dsi_pll_power_state { … }; static int dsi_pll_power(struct dsi_data *dsi, enum dsi_pll_power_state state) { … } static void dsi_pll_calc_dsi_fck(struct dsi_data *dsi, struct dss_pll_clock_info *cinfo) { … } static int dsi_pll_enable(struct dss_pll *pll) { … } static void dsi_pll_disable(struct dss_pll *pll) { … } static int dsi_dump_dsi_clocks(struct seq_file *s, void *p) { … } #ifdef CONFIG_OMAP2_DSS_COLLECT_IRQ_STATS static int dsi_dump_dsi_irqs(struct seq_file *s, void *p) { … } #endif static int dsi_dump_dsi_regs(struct seq_file *s, void *p) { … } enum dsi_cio_power_state { … }; static int dsi_cio_power(struct dsi_data *dsi, enum dsi_cio_power_state state) { … } static unsigned int dsi_get_line_buf_size(struct dsi_data *dsi) { … } static int dsi_set_lane_config(struct dsi_data *dsi) { … } static inline unsigned int ns2ddr(struct dsi_data *dsi, unsigned int ns) { … } static inline unsigned int ddr2ns(struct dsi_data *dsi, unsigned int ddr) { … } static void dsi_cio_timings(struct dsi_data *dsi) { … } static int dsi_cio_wait_tx_clk_esc_reset(struct dsi_data *dsi) { … } /* return bitmask of enabled lanes, lane0 being the lsb */ static unsigned int dsi_get_lane_mask(struct dsi_data *dsi) { … } /* OMAP4 CONTROL_DSIPHY */ #define OMAP4_DSIPHY_SYSCON_OFFSET … #define OMAP4_DSI2_LANEENABLE_SHIFT … #define OMAP4_DSI2_LANEENABLE_MASK … #define OMAP4_DSI1_LANEENABLE_SHIFT … #define OMAP4_DSI1_LANEENABLE_MASK … #define OMAP4_DSI1_PIPD_SHIFT … #define OMAP4_DSI1_PIPD_MASK … #define OMAP4_DSI2_PIPD_SHIFT … #define OMAP4_DSI2_PIPD_MASK … static int dsi_omap4_mux_pads(struct dsi_data *dsi, unsigned int lanes) { … } /* OMAP5 CONTROL_DSIPHY */ #define OMAP5_DSIPHY_SYSCON_OFFSET … #define OMAP5_DSI1_LANEENABLE_SHIFT … #define OMAP5_DSI2_LANEENABLE_SHIFT … #define OMAP5_DSI_LANEENABLE_MASK … static int dsi_omap5_mux_pads(struct dsi_data *dsi, unsigned int lanes) { … } static int dsi_enable_pads(struct dsi_data *dsi, unsigned int lane_mask) { … } static void dsi_disable_pads(struct dsi_data *dsi) { … } static int dsi_cio_init(struct dsi_data *dsi) { … } static void dsi_cio_uninit(struct dsi_data *dsi) { … } static void dsi_config_tx_fifo(struct dsi_data *dsi, enum fifo_size size1, enum fifo_size size2, enum fifo_size size3, enum fifo_size size4) { … } static void dsi_config_rx_fifo(struct dsi_data *dsi, enum fifo_size size1, enum fifo_size size2, enum fifo_size size3, enum fifo_size size4) { … } static int dsi_force_tx_stop_mode_io(struct dsi_data *dsi) { … } static bool dsi_vc_is_enabled(struct dsi_data *dsi, int vc) { … } static void dsi_packet_sent_handler_vp(void *data, u32 mask) { … } static int dsi_sync_vc_vp(struct dsi_data *dsi, int vc) { … } static void dsi_packet_sent_handler_l4(void *data, u32 mask) { … } static int dsi_sync_vc_l4(struct dsi_data *dsi, int vc) { … } static int dsi_sync_vc(struct dsi_data *dsi, int vc) { … } static int dsi_vc_enable(struct dsi_data *dsi, int vc, bool enable) { … } static void dsi_vc_initial_config(struct dsi_data *dsi, int vc) { … } static void dsi_vc_enable_hs(struct omap_dss_device *dssdev, int vc, bool enable) { … } static void dsi_vc_flush_long_data(struct dsi_data *dsi, int vc) { … } static void dsi_show_rx_ack_with_err(u16 err) { … } static u16 dsi_vc_flush_receive_data(struct dsi_data *dsi, int vc) { … } static int dsi_vc_send_bta(struct dsi_data *dsi, int vc) { … } static int dsi_vc_send_bta_sync(struct omap_dss_device *dssdev, int vc) { … } static inline void dsi_vc_write_long_header(struct dsi_data *dsi, int vc, int channel, u8 data_type, u16 len, u8 ecc) { … } static inline void dsi_vc_write_long_payload(struct dsi_data *dsi, int vc, u8 b1, u8 b2, u8 b3, u8 b4) { … } static int dsi_vc_send_long(struct dsi_data *dsi, int vc, const struct mipi_dsi_msg *msg) { … } static int dsi_vc_send_short(struct dsi_data *dsi, int vc, const struct mipi_dsi_msg *msg) { … } static int dsi_vc_send_null(struct dsi_data *dsi, int vc, int channel) { … } static int dsi_vc_write_common(struct omap_dss_device *dssdev, int vc, const struct mipi_dsi_msg *msg) { … } static int dsi_vc_read_rx_fifo(struct dsi_data *dsi, int vc, u8 *buf, int buflen, enum dss_dsi_content_type type) { … } static int dsi_vc_dcs_read(struct omap_dss_device *dssdev, int vc, const struct mipi_dsi_msg *msg) { … } static int dsi_vc_generic_read(struct omap_dss_device *dssdev, int vc, const struct mipi_dsi_msg *msg) { … } static void dsi_set_lp_rx_timeout(struct dsi_data *dsi, unsigned int ticks, bool x4, bool x16) { … } static void dsi_set_ta_timeout(struct dsi_data *dsi, unsigned int ticks, bool x8, bool x16) { … } static void dsi_set_stop_state_counter(struct dsi_data *dsi, unsigned int ticks, bool x4, bool x16) { … } static void dsi_set_hs_tx_timeout(struct dsi_data *dsi, unsigned int ticks, bool x4, bool x16) { … } static void dsi_config_vp_num_line_buffers(struct dsi_data *dsi) { … } static void dsi_config_vp_sync_events(struct dsi_data *dsi) { … } static void dsi_config_blanking_modes(struct dsi_data *dsi) { … } /* * According to section 'HS Command Mode Interleaving' in OMAP TRM, Scenario 3 * results in maximum transition time for data and clock lanes to enter and * exit HS mode. Hence, this is the scenario where the least amount of command * mode data can be interleaved. We program the minimum amount of TXBYTECLKHS * clock cycles that can be used to interleave command mode data in HS so that * all scenarios are satisfied. */ static int dsi_compute_interleave_hs(int blank, bool ddr_alwon, int enter_hs, int exit_hs, int exiths_clk, int ddr_pre, int ddr_post) { … } /* * According to section 'LP Command Mode Interleaving' in OMAP TRM, Scenario 1 * results in maximum transition time for data lanes to enter and exit LP mode. * Hence, this is the scenario where the least amount of command mode data can * be interleaved. We program the minimum amount of bytes that can be * interleaved in LP so that all scenarios are satisfied. */ static int dsi_compute_interleave_lp(int blank, int enter_hs, int exit_hs, int lp_clk_div, int tdsi_fclk) { … } static void dsi_config_cmd_mode_interleaving(struct dsi_data *dsi) { … } static int dsi_proto_config(struct dsi_data *dsi) { … } static void dsi_proto_timings(struct dsi_data *dsi) { … } static int dsi_configure_pins(struct dsi_data *dsi, int num_pins, const u32 *pins) { … } static int dsi_enable_video_mode(struct dsi_data *dsi, int vc) { … } static void dsi_disable_video_mode(struct dsi_data *dsi, int vc) { … } static void dsi_enable_video_output(struct omap_dss_device *dssdev, int vc) { … } static void dsi_disable_video_output(struct omap_dss_device *dssdev, int vc) { … } static void dsi_update_screen_dispc(struct dsi_data *dsi) { … } #ifdef DSI_CATCH_MISSING_TE static void dsi_te_timeout(struct timer_list *unused) { … } #endif static void dsi_handle_framedone(struct dsi_data *dsi, int error) { … } static void dsi_framedone_timeout_work_callback(struct work_struct *work) { … } static void dsi_framedone_irq_callback(void *data) { … } static int _dsi_update(struct dsi_data *dsi) { … } static int _dsi_send_nop(struct dsi_data *dsi, int vc, int channel) { … } static int dsi_update_channel(struct omap_dss_device *dssdev, int vc) { … } static int dsi_update_all(struct omap_dss_device *dssdev) { … } /* Display funcs */ static int dsi_configure_dispc_clocks(struct dsi_data *dsi) { … } static int dsi_init_dispc(struct dsi_data *dsi) { … } static void dsi_uninit_dispc(struct dsi_data *dsi) { … } static int dsi_configure_dsi_clocks(struct dsi_data *dsi) { … } static void dsi_setup_dsi_vcs(struct dsi_data *dsi) { … } static int dsi_init_dsi(struct dsi_data *dsi) { … } static void dsi_uninit_dsi(struct dsi_data *dsi) { … } static void dsi_enable(struct dsi_data *dsi) { … } static void dsi_disable(struct dsi_data *dsi) { … } static int dsi_enable_te(struct dsi_data *dsi, bool enable) { … } #ifdef PRINT_VERBOSE_VM_TIMINGS static void print_dsi_vm(const char *str, const struct omap_dss_dsi_videomode_timings *t) { unsigned long byteclk = t->hsclk / 4; int bl, wc, pps, tot; wc = DIV_ROUND_UP(t->hact * t->bitspp, 8); pps = DIV_ROUND_UP(wc + 6, t->ndl); /* pixel packet size */ bl = t->hss + t->hsa + t->hse + t->hbp + t->hfp; tot = bl + pps; #define TO_DSI_T … pr_debug("%s bck %lu, %u/%u/%u/%u/%u/%u = %u+%u = %u, " "%u/%u/%u/%u/%u/%u = %u + %u = %u\n", str, byteclk, t->hss, t->hsa, t->hse, t->hbp, pps, t->hfp, bl, pps, tot, TO_DSI_T(t->hss), TO_DSI_T(t->hsa), TO_DSI_T(t->hse), TO_DSI_T(t->hbp), TO_DSI_T(pps), TO_DSI_T(t->hfp), TO_DSI_T(bl), TO_DSI_T(pps), TO_DSI_T(tot)); #undef TO_DSI_T } static void print_dispc_vm(const char *str, const struct videomode *vm) { unsigned long pck = vm->pixelclock; int hact, bl, tot; hact = vm->hactive; bl = vm->hsync_len + vm->hback_porch + vm->hfront_porch; tot = hact + bl; #define TO_DISPC_T … pr_debug("%s pck %lu, %u/%u/%u/%u = %u+%u = %u, " "%u/%u/%u/%u = %u + %u = %u\n", str, pck, vm->hsync_len, vm->hback_porch, hact, vm->hfront_porch, bl, hact, tot, TO_DISPC_T(vm->hsync_len), TO_DISPC_T(vm->hback_porch), TO_DISPC_T(hact), TO_DISPC_T(vm->hfront_porch), TO_DISPC_T(bl), TO_DISPC_T(hact), TO_DISPC_T(tot)); #undef TO_DISPC_T } /* note: this is not quite accurate */ static void print_dsi_dispc_vm(const char *str, const struct omap_dss_dsi_videomode_timings *t) { struct videomode vm = { 0 }; unsigned long byteclk = t->hsclk / 4; unsigned long pck; u64 dsi_tput; int dsi_hact, dsi_htot; dsi_tput = (u64)byteclk * t->ndl * 8; pck = (u32)div64_u64(dsi_tput, t->bitspp); dsi_hact = DIV_ROUND_UP(DIV_ROUND_UP(t->hact * t->bitspp, 8) + 6, t->ndl); dsi_htot = t->hss + t->hsa + t->hse + t->hbp + dsi_hact + t->hfp; vm.pixelclock = pck; vm.hsync_len = div64_u64((u64)(t->hsa + t->hse) * pck, byteclk); vm.hback_porch = div64_u64((u64)t->hbp * pck, byteclk); vm.hfront_porch = div64_u64((u64)t->hfp * pck, byteclk); vm.hactive = t->hact; print_dispc_vm(str, &vm); } #endif /* PRINT_VERBOSE_VM_TIMINGS */ static bool dsi_cm_calc_dispc_cb(int lckd, int pckd, unsigned long lck, unsigned long pck, void *data) { … } static bool dsi_cm_calc_hsdiv_cb(int m_dispc, unsigned long dispc, void *data) { … } static bool dsi_cm_calc_pll_cb(int n, int m, unsigned long fint, unsigned long clkdco, void *data) { … } static bool dsi_cm_calc(struct dsi_data *dsi, const struct omap_dss_dsi_config *cfg, struct dsi_clk_calc_ctx *ctx) { … } static bool dsi_vm_calc_blanking(struct dsi_clk_calc_ctx *ctx) { … } static bool dsi_vm_calc_dispc_cb(int lckd, int pckd, unsigned long lck, unsigned long pck, void *data) { … } static bool dsi_vm_calc_hsdiv_cb(int m_dispc, unsigned long dispc, void *data) { … } static bool dsi_vm_calc_pll_cb(int n, int m, unsigned long fint, unsigned long clkdco, void *data) { … } static bool dsi_vm_calc(struct dsi_data *dsi, const struct omap_dss_dsi_config *cfg, struct dsi_clk_calc_ctx *ctx) { … } static bool dsi_is_video_mode(struct omap_dss_device *dssdev) { … } static int __dsi_calc_config(struct dsi_data *dsi, const struct drm_display_mode *mode, struct dsi_clk_calc_ctx *ctx) { … } static int dsi_set_config(struct omap_dss_device *dssdev, const struct drm_display_mode *mode) { … } /* * Return a hardcoded dispc channel for the DSI output. This should work for * current use cases, but this can be later expanded to either resolve * the channel in some more dynamic manner, or get the channel as a user * parameter. */ static enum omap_channel dsi_get_dispc_channel(struct dsi_data *dsi) { … } static ssize_t _omap_dsi_host_transfer(struct dsi_data *dsi, int vc, const struct mipi_dsi_msg *msg) { … } static ssize_t omap_dsi_host_transfer(struct mipi_dsi_host *host, const struct mipi_dsi_msg *msg) { … } static int dsi_get_clocks(struct dsi_data *dsi) { … } static const struct omapdss_dsi_ops dsi_ops = …; static irqreturn_t omap_dsi_te_irq_handler(int irq, void *dev_id) { … } static void omap_dsi_te_timeout_work_callback(struct work_struct *work) { … } static int omap_dsi_register_te_irq(struct dsi_data *dsi, struct mipi_dsi_device *client) { … } static void omap_dsi_unregister_te_irq(struct dsi_data *dsi) { … } static int omap_dsi_host_attach(struct mipi_dsi_host *host, struct mipi_dsi_device *client) { … } static int omap_dsi_host_detach(struct mipi_dsi_host *host, struct mipi_dsi_device *client) { … } static const struct mipi_dsi_host_ops omap_dsi_host_ops = …; /* ----------------------------------------------------------------------------- * PLL */ static const struct dss_pll_ops dsi_pll_ops = …; static const struct dss_pll_hw dss_omap3_dsi_pll_hw = …; static const struct dss_pll_hw dss_omap4_dsi_pll_hw = …; static const struct dss_pll_hw dss_omap5_dsi_pll_hw = …; static int dsi_init_pll_data(struct dss_device *dss, struct dsi_data *dsi) { … } /* ----------------------------------------------------------------------------- * Component Bind & Unbind */ static int dsi_bind(struct device *dev, struct device *master, void *data) { … } static void dsi_unbind(struct device *dev, struct device *master, void *data) { … } static const struct component_ops dsi_component_ops = …; /* ----------------------------------------------------------------------------- * DRM Bridge Operations */ static int dsi_bridge_attach(struct drm_bridge *bridge, enum drm_bridge_attach_flags flags) { … } static enum drm_mode_status dsi_bridge_mode_valid(struct drm_bridge *bridge, const struct drm_display_info *info, const struct drm_display_mode *mode) { … } static void dsi_bridge_mode_set(struct drm_bridge *bridge, const struct drm_display_mode *mode, const struct drm_display_mode *adjusted_mode) { … } static void dsi_bridge_enable(struct drm_bridge *bridge) { … } static void dsi_bridge_disable(struct drm_bridge *bridge) { … } static const struct drm_bridge_funcs dsi_bridge_funcs = …; static void dsi_bridge_init(struct dsi_data *dsi) { … } static void dsi_bridge_cleanup(struct dsi_data *dsi) { … } /* ----------------------------------------------------------------------------- * Probe & Remove, Suspend & Resume */ static int dsi_init_output(struct dsi_data *dsi) { … } static void dsi_uninit_output(struct dsi_data *dsi) { … } static int dsi_probe_of(struct dsi_data *dsi) { … } static const struct dsi_of_data dsi_of_data_omap34xx = …; static const struct dsi_of_data dsi_of_data_omap36xx = …; static const struct dsi_of_data dsi_of_data_omap4 = …; static const struct dsi_of_data dsi_of_data_omap5 = …; static const struct of_device_id dsi_of_match[] = …; static const struct soc_device_attribute dsi_soc_devices[] = …; static void omap_dsi_disable_work_callback(struct work_struct *work) { … } static int dsi_probe(struct platform_device *pdev) { … } static void dsi_remove(struct platform_device *pdev) { … } static __maybe_unused int dsi_runtime_suspend(struct device *dev) { … } static __maybe_unused int dsi_runtime_resume(struct device *dev) { … } static const struct dev_pm_ops dsi_pm_ops = …; struct platform_driver omap_dsihw_driver = …;
Codebase Browser
linux