linux/drivers/video/fbdev/omap2/dss/core.c
<<
>>
Prefs
   1/*
   2 * linux/drivers/video/omap2/dss/core.c
   3 *
   4 * Copyright (C) 2009 Nokia Corporation
   5 * Author: Tomi Valkeinen <tomi.valkeinen@nokia.com>
   6 *
   7 * Some code and ideas taken from drivers/video/omap/ driver
   8 * by Imre Deak.
   9 *
  10 * This program is free software; you can redistribute it and/or modify it
  11 * under the terms of the GNU General Public License version 2 as published by
  12 * the Free Software Foundation.
  13 *
  14 * This program is distributed in the hope that it will be useful, but WITHOUT
  15 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  17 * more details.
  18 *
  19 * You should have received a copy of the GNU General Public License along with
  20 * this program.  If not, see <http://www.gnu.org/licenses/>.
  21 */
  22
  23#define DSS_SUBSYS_NAME "CORE"
  24
  25#include <linux/kernel.h>
  26#include <linux/module.h>
  27#include <linux/clk.h>
  28#include <linux/err.h>
  29#include <linux/platform_device.h>
  30#include <linux/seq_file.h>
  31#include <linux/debugfs.h>
  32#include <linux/io.h>
  33#include <linux/device.h>
  34#include <linux/regulator/consumer.h>
  35#include <linux/suspend.h>
  36#include <linux/slab.h>
  37
  38#include <video/omapdss.h>
  39
  40#include "dss.h"
  41#include "dss_features.h"
  42
  43static struct {
  44        struct platform_device *pdev;
  45
  46        const char *default_display_name;
  47} core;
  48
  49static char *def_disp_name;
  50module_param_named(def_disp, def_disp_name, charp, 0);
  51MODULE_PARM_DESC(def_disp, "default display name");
  52
  53static bool dss_initialized;
  54
  55const char *omapdss_get_default_display_name(void)
  56{
  57        return core.default_display_name;
  58}
  59EXPORT_SYMBOL(omapdss_get_default_display_name);
  60
  61enum omapdss_version omapdss_get_version(void)
  62{
  63        struct omap_dss_board_info *pdata = core.pdev->dev.platform_data;
  64        return pdata->version;
  65}
  66EXPORT_SYMBOL(omapdss_get_version);
  67
  68bool omapdss_is_initialized(void)
  69{
  70        return dss_initialized;
  71}
  72EXPORT_SYMBOL(omapdss_is_initialized);
  73
  74struct platform_device *dss_get_core_pdev(void)
  75{
  76        return core.pdev;
  77}
  78
  79int dss_dsi_enable_pads(int dsi_id, unsigned lane_mask)
  80{
  81        struct omap_dss_board_info *board_data = core.pdev->dev.platform_data;
  82
  83        if (!board_data->dsi_enable_pads)
  84                return -ENOENT;
  85
  86        return board_data->dsi_enable_pads(dsi_id, lane_mask);
  87}
  88
  89void dss_dsi_disable_pads(int dsi_id, unsigned lane_mask)
  90{
  91        struct omap_dss_board_info *board_data = core.pdev->dev.platform_data;
  92
  93        if (!board_data->dsi_disable_pads)
  94                return;
  95
  96        return board_data->dsi_disable_pads(dsi_id, lane_mask);
  97}
  98
  99int dss_set_min_bus_tput(struct device *dev, unsigned long tput)
 100{
 101        struct omap_dss_board_info *pdata = core.pdev->dev.platform_data;
 102
 103        if (pdata->set_min_bus_tput)
 104                return pdata->set_min_bus_tput(dev, tput);
 105        else
 106                return 0;
 107}
 108
 109#if defined(CONFIG_OMAP2_DSS_DEBUGFS)
 110static int dss_debug_show(struct seq_file *s, void *unused)
 111{
 112        void (*func)(struct seq_file *) = s->private;
 113        func(s);
 114        return 0;
 115}
 116
 117static int dss_debug_open(struct inode *inode, struct file *file)
 118{
 119        return single_open(file, dss_debug_show, inode->i_private);
 120}
 121
 122static const struct file_operations dss_debug_fops = {
 123        .open           = dss_debug_open,
 124        .read           = seq_read,
 125        .llseek         = seq_lseek,
 126        .release        = single_release,
 127};
 128
 129static struct dentry *dss_debugfs_dir;
 130
 131static int dss_initialize_debugfs(void)
 132{
 133        dss_debugfs_dir = debugfs_create_dir("omapdss", NULL);
 134        if (IS_ERR(dss_debugfs_dir)) {
 135                int err = PTR_ERR(dss_debugfs_dir);
 136                dss_debugfs_dir = NULL;
 137                return err;
 138        }
 139
 140        debugfs_create_file("clk", S_IRUGO, dss_debugfs_dir,
 141                        &dss_debug_dump_clocks, &dss_debug_fops);
 142
 143        return 0;
 144}
 145
 146static void dss_uninitialize_debugfs(void)
 147{
 148        if (dss_debugfs_dir)
 149                debugfs_remove_recursive(dss_debugfs_dir);
 150}
 151
 152int dss_debugfs_create_file(const char *name, void (*write)(struct seq_file *))
 153{
 154        struct dentry *d;
 155
 156        d = debugfs_create_file(name, S_IRUGO, dss_debugfs_dir,
 157                        write, &dss_debug_fops);
 158
 159        return PTR_ERR_OR_ZERO(d);
 160}
 161#else /* CONFIG_OMAP2_DSS_DEBUGFS */
 162static inline int dss_initialize_debugfs(void)
 163{
 164        return 0;
 165}
 166static inline void dss_uninitialize_debugfs(void)
 167{
 168}
 169int dss_debugfs_create_file(const char *name, void (*write)(struct seq_file *))
 170{
 171        return 0;
 172}
 173#endif /* CONFIG_OMAP2_DSS_DEBUGFS */
 174
 175/* PLATFORM DEVICE */
 176static int omap_dss_pm_notif(struct notifier_block *b, unsigned long v, void *d)
 177{
 178        DSSDBG("pm notif %lu\n", v);
 179
 180        switch (v) {
 181        case PM_SUSPEND_PREPARE:
 182                DSSDBG("suspending displays\n");
 183                return dss_suspend_all_devices();
 184
 185        case PM_POST_SUSPEND:
 186                DSSDBG("resuming displays\n");
 187                return dss_resume_all_devices();
 188
 189        default:
 190                return 0;
 191        }
 192}
 193
 194static struct notifier_block omap_dss_pm_notif_block = {
 195        .notifier_call = omap_dss_pm_notif,
 196};
 197
 198static int __init omap_dss_probe(struct platform_device *pdev)
 199{
 200        struct omap_dss_board_info *pdata = pdev->dev.platform_data;
 201        int r;
 202
 203        core.pdev = pdev;
 204
 205        dss_features_init(omapdss_get_version());
 206
 207        r = dss_initialize_debugfs();
 208        if (r)
 209                goto err_debugfs;
 210
 211        if (def_disp_name)
 212                core.default_display_name = def_disp_name;
 213        else if (pdata->default_display_name)
 214                core.default_display_name = pdata->default_display_name;
 215        else if (pdata->default_device)
 216                core.default_display_name = pdata->default_device->name;
 217
 218        register_pm_notifier(&omap_dss_pm_notif_block);
 219
 220        return 0;
 221
 222err_debugfs:
 223
 224        return r;
 225}
 226
 227static int omap_dss_remove(struct platform_device *pdev)
 228{
 229        unregister_pm_notifier(&omap_dss_pm_notif_block);
 230
 231        dss_uninitialize_debugfs();
 232
 233        return 0;
 234}
 235
 236static void omap_dss_shutdown(struct platform_device *pdev)
 237{
 238        DSSDBG("shutdown\n");
 239        dss_disable_all_devices();
 240}
 241
 242static struct platform_driver omap_dss_driver = {
 243        .remove         = omap_dss_remove,
 244        .shutdown       = omap_dss_shutdown,
 245        .driver         = {
 246                .name   = "omapdss",
 247        },
 248};
 249
 250/* INIT */
 251static int (*dss_output_drv_reg_funcs[])(void) __initdata = {
 252#ifdef CONFIG_OMAP2_DSS_DSI
 253        dsi_init_platform_driver,
 254#endif
 255#ifdef CONFIG_OMAP2_DSS_DPI
 256        dpi_init_platform_driver,
 257#endif
 258#ifdef CONFIG_OMAP2_DSS_SDI
 259        sdi_init_platform_driver,
 260#endif
 261#ifdef CONFIG_OMAP2_DSS_RFBI
 262        rfbi_init_platform_driver,
 263#endif
 264#ifdef CONFIG_OMAP2_DSS_VENC
 265        venc_init_platform_driver,
 266#endif
 267#ifdef CONFIG_OMAP4_DSS_HDMI
 268        hdmi4_init_platform_driver,
 269#endif
 270#ifdef CONFIG_OMAP5_DSS_HDMI
 271        hdmi5_init_platform_driver,
 272#endif
 273};
 274
 275static void (*dss_output_drv_unreg_funcs[])(void) __exitdata = {
 276#ifdef CONFIG_OMAP2_DSS_DSI
 277        dsi_uninit_platform_driver,
 278#endif
 279#ifdef CONFIG_OMAP2_DSS_DPI
 280        dpi_uninit_platform_driver,
 281#endif
 282#ifdef CONFIG_OMAP2_DSS_SDI
 283        sdi_uninit_platform_driver,
 284#endif
 285#ifdef CONFIG_OMAP2_DSS_RFBI
 286        rfbi_uninit_platform_driver,
 287#endif
 288#ifdef CONFIG_OMAP2_DSS_VENC
 289        venc_uninit_platform_driver,
 290#endif
 291#ifdef CONFIG_OMAP4_DSS_HDMI
 292        hdmi4_uninit_platform_driver,
 293#endif
 294#ifdef CONFIG_OMAP5_DSS_HDMI
 295        hdmi5_uninit_platform_driver,
 296#endif
 297};
 298
 299static bool dss_output_drv_loaded[ARRAY_SIZE(dss_output_drv_reg_funcs)];
 300
 301static int __init omap_dss_init(void)
 302{
 303        int r;
 304        int i;
 305
 306        r = platform_driver_probe(&omap_dss_driver, omap_dss_probe);
 307        if (r)
 308                return r;
 309
 310        r = dss_init_platform_driver();
 311        if (r) {
 312                DSSERR("Failed to initialize DSS platform driver\n");
 313                goto err_dss;
 314        }
 315
 316        r = dispc_init_platform_driver();
 317        if (r) {
 318                DSSERR("Failed to initialize dispc platform driver\n");
 319                goto err_dispc;
 320        }
 321
 322        /*
 323         * It's ok if the output-driver register fails. It happens, for example,
 324         * when there is no output-device (e.g. SDI for OMAP4).
 325         */
 326        for (i = 0; i < ARRAY_SIZE(dss_output_drv_reg_funcs); ++i) {
 327                r = dss_output_drv_reg_funcs[i]();
 328                if (r == 0)
 329                        dss_output_drv_loaded[i] = true;
 330        }
 331
 332        dss_initialized = true;
 333
 334        return 0;
 335
 336err_dispc:
 337        dss_uninit_platform_driver();
 338err_dss:
 339        platform_driver_unregister(&omap_dss_driver);
 340
 341        return r;
 342}
 343
 344static void __exit omap_dss_exit(void)
 345{
 346        int i;
 347
 348        for (i = 0; i < ARRAY_SIZE(dss_output_drv_unreg_funcs); ++i) {
 349                if (dss_output_drv_loaded[i])
 350                        dss_output_drv_unreg_funcs[i]();
 351        }
 352
 353        dispc_uninit_platform_driver();
 354        dss_uninit_platform_driver();
 355
 356        platform_driver_unregister(&omap_dss_driver);
 357}
 358
 359module_init(omap_dss_init);
 360module_exit(omap_dss_exit);
 361
 362MODULE_AUTHOR("Tomi Valkeinen <tomi.valkeinen@nokia.com>");
 363MODULE_DESCRIPTION("OMAP2/3 Display Subsystem");
 364MODULE_LICENSE("GPL v2");
 365
 366
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.