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         case PM_HIBERNATION_PREPARE:
 183         case PM_RESTORE_PREPARE:
 184                 DSSDBG("suspending displays\n");
 185                 return dss_suspend_all_devices();
 186
 187         case PM_POST_SUSPEND:
 188         case PM_POST_HIBERNATION:
 189         case PM_POST_RESTORE:
 190                 DSSDBG("resuming displays\n");
 191                 return dss_resume_all_devices();
 192
 193         default:
 194                 return 0;
 195         }
 196 }
 197
 198 static struct notifier_block omap_dss_pm_notif_block = {
 199         .notifier_call = omap_dss_pm_notif,
 200 };
 201
 202 static int __init omap_dss_probe(struct platform_device *pdev)
 203 {
 204         struct omap_dss_board_info *pdata = pdev->dev.platform_data;
 205         int r;
 206
 207         core.pdev = pdev;
 208
 209         dss_features_init(omapdss_get_version());
 210
 211         r = dss_initialize_debugfs();
 212         if (r)
 213                 goto err_debugfs;
 214
 215         if (def_disp_name)
 216                 core.default_display_name = def_disp_name;
 217         else if (pdata->default_display_name)
 218                 core.default_display_name = pdata->default_display_name;
 219         else if (pdata->default_device)
 220                 core.default_display_name = pdata->default_device->name;
 221
 222         register_pm_notifier(&omap_dss_pm_notif_block);
 223
 224         return 0;
 225
 226 err_debugfs:
 227
 228         return r;
 229 }
 230
 231 static int omap_dss_remove(struct platform_device *pdev)
 232 {
 233         unregister_pm_notifier(&omap_dss_pm_notif_block);
 234
 235         dss_uninitialize_debugfs();
 236
 237         return 0;
 238 }
 239
 240 static void omap_dss_shutdown(struct platform_device *pdev)
 241 {
 242         DSSDBG("shutdown\n");
 243         dss_disable_all_devices();
 244 }
 245
 246 static struct platform_driver omap_dss_driver = {
 247         .remove         = omap_dss_remove,
 248         .shutdown       = omap_dss_shutdown,
 249         .driver         = {
 250                 .name   = "omapdss",
 251         },
 252 };
 253
 254 /* INIT */
 255 static int (*dss_output_drv_reg_funcs[])(void) __initdata = {
 256 #ifdef CONFIG_OMAP2_DSS_DSI
 257         dsi_init_platform_driver,
 258 #endif
 259 #ifdef CONFIG_OMAP2_DSS_DPI
 260         dpi_init_platform_driver,
 261 #endif
 262 #ifdef CONFIG_OMAP2_DSS_SDI
 263         sdi_init_platform_driver,
 264 #endif
 265 #ifdef CONFIG_OMAP2_DSS_RFBI
 266         rfbi_init_platform_driver,
 267 #endif
 268 #ifdef CONFIG_OMAP2_DSS_VENC
 269         venc_init_platform_driver,
 270 #endif
 271 #ifdef CONFIG_OMAP4_DSS_HDMI
 272         hdmi4_init_platform_driver,
 273 #endif
 274 #ifdef CONFIG_OMAP5_DSS_HDMI
 275         hdmi5_init_platform_driver,
 276 #endif
 277 };
 278
 279 static void (*dss_output_drv_unreg_funcs[])(void) __exitdata = {
 280 #ifdef CONFIG_OMAP2_DSS_DSI
 281         dsi_uninit_platform_driver,
 282 #endif
 283 #ifdef CONFIG_OMAP2_DSS_DPI
 284         dpi_uninit_platform_driver,
 285 #endif
 286 #ifdef CONFIG_OMAP2_DSS_SDI
 287         sdi_uninit_platform_driver,
 288 #endif
 289 #ifdef CONFIG_OMAP2_DSS_RFBI
 290         rfbi_uninit_platform_driver,
 291 #endif
 292 #ifdef CONFIG_OMAP2_DSS_VENC
 293         venc_uninit_platform_driver,
 294 #endif
 295 #ifdef CONFIG_OMAP4_DSS_HDMI
 296         hdmi4_uninit_platform_driver,
 297 #endif
 298 #ifdef CONFIG_OMAP5_DSS_HDMI
 299         hdmi5_uninit_platform_driver,
 300 #endif
 301 };
 302
 303 static bool dss_output_drv_loaded[ARRAY_SIZE(dss_output_drv_reg_funcs)];
 304
 305 static int __init omap_dss_init(void)
 306 {
 307         int r;
 308         int i;
 309
 310         r = platform_driver_probe(&omap_dss_driver, omap_dss_probe);
 311         if (r)
 312                 return r;
 313
 314         r = dss_init_platform_driver();
 315         if (r) {
 316                 DSSERR("Failed to initialize DSS platform driver\n");
 317                 goto err_dss;
 318         }
 319
 320         r = dispc_init_platform_driver();
 321         if (r) {
 322                 DSSERR("Failed to initialize dispc platform driver\n");
 323                 goto err_dispc;
 324         }
 325
 326         /*
 327          * It's ok if the output-driver register fails. It happens, for example,
 328          * when there is no output-device (e.g. SDI for OMAP4).
 329          */
 330         for (i = 0; i < ARRAY_SIZE(dss_output_drv_reg_funcs); ++i) {
 331                 r = dss_output_drv_reg_funcs[i]();
 332                 if (r == 0)
 333                         dss_output_drv_loaded[i] = true;
 334         }
 335
 336         dss_initialized = true;
 337
 338         return 0;
 339
 340 err_dispc:
 341         dss_uninit_platform_driver();
 342 err_dss:
 343         platform_driver_unregister(&omap_dss_driver);
 344
 345         return r;
 346 }
 347
 348 static void __exit omap_dss_exit(void)
 349 {
 350         int i;
 351
 352         for (i = 0; i < ARRAY_SIZE(dss_output_drv_unreg_funcs); ++i) {
 353                 if (dss_output_drv_loaded[i])
 354                         dss_output_drv_unreg_funcs[i]();
 355         }
 356
 357         dispc_uninit_platform_driver();
 358         dss_uninit_platform_driver();
 359
 360         platform_driver_unregister(&omap_dss_driver);
 361 }
 362
 363 module_init(omap_dss_init);
 364 module_exit(omap_dss_exit);
 365
 366 MODULE_AUTHOR("Tomi Valkeinen <tomi.valkeinen@nokia.com>");
 367 MODULE_DESCRIPTION("OMAP2/3 Display Subsystem");
 368 MODULE_LICENSE("GPL v2");
 369