drivers/video/fbdev/omap2/dss/core.c

   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
  43 static struct {
  44         struct platform_device *pdev;
  45
  46         const char *default_display_name;
  47 } core;
  48
  49 static char *def_disp_name;
  50 module_param_named(def_disp, def_disp_name, charp, 0);
  51 MODULE_PARM_DESC(def_disp, "default display name");
  52
  53 static bool dss_initialized;
  54
  55 const char *omapdss_get_default_display_name(void)
  56 {
  57         return core.default_display_name;
  58 }
  59 EXPORT_SYMBOL(omapdss_get_default_display_name);
  60
  61 enum omapdss_version omapdss_get_version(void)
  62 {
  63         struct omap_dss_board_info *pdata = core.pdev->dev.platform_data;
  64         return pdata->version;
  65 }
  66 EXPORT_SYMBOL(omapdss_get_version);
  67
  68 bool omapdss_is_initialized(void)
  69 {
  70         return dss_initialized;
  71 }
  72 EXPORT_SYMBOL(omapdss_is_initialized);
  73
  74 struct platform_device *dss_get_core_pdev(void)
  75 {
  76         return core.pdev;
  77 }
  78
  79 int 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
  89 void 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
  99 int 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)
 110 static 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
 117 static int dss_debug_open(struct inode *inode, struct file *file)
 118 {
 119         return single_open(file, dss_debug_show, inode->i_private);
 120 }
 121
 122 static 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
 129 static struct dentry *dss_debugfs_dir;
 130
 131 static 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
 146 static void dss_uninitialize_debugfs(void)
 147 {
 148         if (dss_debugfs_dir)
 149                 debugfs_remove_recursive(dss_debugfs_dir);
 150 }
 151
 152 int 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 */
 162 static inline int dss_initialize_debugfs(void)
 163 {
 164         return 0;
 165 }
 166 static inline void dss_uninitialize_debugfs(void)
 167 {
 168 }
 169 int 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 */
 176 static 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
 194 static struct notifier_block omap_dss_pm_notif_block = {
 195         .notifier_call = omap_dss_pm_notif,
 196 };
 197
 198 static 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
 222 err_debugfs:
 223
 224         return r;
 225 }
 226
 227 static 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
 236 static void omap_dss_shutdown(struct platform_device *pdev)
 237 {
 238         DSSDBG("shutdown\n");
 239         dss_disable_all_devices();
 240 }
 241
 242 static struct platform_driver omap_dss_driver = {
 243         .remove         = omap_dss_remove,
 244         .shutdown       = omap_dss_shutdown,
 245         .driver         = {
 246                 .name   = "omapdss",
 247                 .owner  = THIS_MODULE,
 248         },
 249 };
 250
 251 /* INIT */
 252 static int (*dss_output_drv_reg_funcs[])(void) __initdata = {
 253 #ifdef CONFIG_OMAP2_DSS_DSI
 254         dsi_init_platform_driver,
 255 #endif
 256 #ifdef CONFIG_OMAP2_DSS_DPI
 257         dpi_init_platform_driver,
 258 #endif
 259 #ifdef CONFIG_OMAP2_DSS_SDI
 260         sdi_init_platform_driver,
 261 #endif
 262 #ifdef CONFIG_OMAP2_DSS_RFBI
 263         rfbi_init_platform_driver,
 264 #endif
 265 #ifdef CONFIG_OMAP2_DSS_VENC
 266         venc_init_platform_driver,
 267 #endif
 268 #ifdef CONFIG_OMAP4_DSS_HDMI
 269         hdmi4_init_platform_driver,
 270 #endif
 271 #ifdef CONFIG_OMAP5_DSS_HDMI
 272         hdmi5_init_platform_driver,
 273 #endif
 274 };
 275
 276 static void (*dss_output_drv_unreg_funcs[])(void) __exitdata = {
 277 #ifdef CONFIG_OMAP2_DSS_DSI
 278         dsi_uninit_platform_driver,
 279 #endif
 280 #ifdef CONFIG_OMAP2_DSS_DPI
 281         dpi_uninit_platform_driver,
 282 #endif
 283 #ifdef CONFIG_OMAP2_DSS_SDI
 284         sdi_uninit_platform_driver,
 285 #endif
 286 #ifdef CONFIG_OMAP2_DSS_RFBI
 287         rfbi_uninit_platform_driver,
 288 #endif
 289 #ifdef CONFIG_OMAP2_DSS_VENC
 290         venc_uninit_platform_driver,
 291 #endif
 292 #ifdef CONFIG_OMAP4_DSS_HDMI
 293         hdmi4_uninit_platform_driver,
 294 #endif
 295 #ifdef CONFIG_OMAP5_DSS_HDMI
 296         hdmi5_uninit_platform_driver,
 297 #endif
 298 };
 299
 300 static bool dss_output_drv_loaded[ARRAY_SIZE(dss_output_drv_reg_funcs)];
 301
 302 static int __init omap_dss_init(void)
 303 {
 304         int r;
 305         int i;
 306
 307         r = platform_driver_probe(&omap_dss_driver, omap_dss_probe);
 308         if (r)
 309                 return r;
 310
 311         r = dss_init_platform_driver();
 312         if (r) {
 313                 DSSERR("Failed to initialize DSS platform driver\n");
 314                 goto err_dss;
 315         }
 316
 317         r = dispc_init_platform_driver();
 318         if (r) {
 319                 DSSERR("Failed to initialize dispc platform driver\n");
 320                 goto err_dispc;
 321         }
 322
 323         /*
 324          * It's ok if the output-driver register fails. It happens, for example,
 325          * when there is no output-device (e.g. SDI for OMAP4).
 326          */
 327         for (i = 0; i < ARRAY_SIZE(dss_output_drv_reg_funcs); ++i) {
 328                 r = dss_output_drv_reg_funcs[i]();
 329                 if (r == 0)
 330                         dss_output_drv_loaded[i] = true;
 331         }
 332
 333         dss_initialized = true;
 334
 335         return 0;
 336
 337 err_dispc:
 338         dss_uninit_platform_driver();
 339 err_dss:
 340         platform_driver_unregister(&omap_dss_driver);
 341
 342         return r;
 343 }
 344
 345 static void __exit omap_dss_exit(void)
 346 {
 347         int i;
 348
 349         for (i = 0; i < ARRAY_SIZE(dss_output_drv_unreg_funcs); ++i) {
 350                 if (dss_output_drv_loaded[i])
 351                         dss_output_drv_unreg_funcs[i]();
 352         }
 353
 354         dispc_uninit_platform_driver();
 355         dss_uninit_platform_driver();
 356
 357         platform_driver_unregister(&omap_dss_driver);
 358 }
 359
 360 module_init(omap_dss_init);
 361 module_exit(omap_dss_exit);
 362
 363 MODULE_AUTHOR("Tomi Valkeinen <tomi.valkeinen@nokia.com>");
 364 MODULE_DESCRIPTION("OMAP2/3 Display Subsystem");
 365 MODULE_LICENSE("GPL v2");
 366