static int fsl_dcu_drm_pm_suspend(struct device *dev) { struct fsl_dcu_drm_device *fsl_dev = dev_get_drvdata(dev); if (!fsl_dev) return 0; disable_irq(fsl_dev->irq); drm_kms_helper_poll_disable(fsl_dev->drm); console_lock(); drm_fbdev_cma_set_suspend(fsl_dev->fbdev, 1); console_unlock(); fsl_dev->state = drm_atomic_helper_suspend(fsl_dev->drm); if (IS_ERR(fsl_dev->state)) { console_lock(); drm_fbdev_cma_set_suspend(fsl_dev->fbdev, 0); console_unlock(); drm_kms_helper_poll_enable(fsl_dev->drm); enable_irq(fsl_dev->irq); return PTR_ERR(fsl_dev->state); } clk_disable_unprepare(fsl_dev->pix_clk); clk_disable_unprepare(fsl_dev->clk); return 0; }
static int console_get_poll_status(struct file *f) { /* Writing is always ready */ struct console_file *console_file = (struct console_file *) f; if (console->input_buffer_head != console->input_buffer_tail) return LINUX_POLLIN | LINUX_POLLOUT; console_lock(); INPUT_RECORD ir; DWORD num_read; while (PeekConsoleInputW(console->in, &ir, 1, &num_read) && num_read > 0) { /* Test if the event will be discarded */ if (ir.EventType == KEY_EVENT && ir.Event.KeyEvent.bKeyDown) { console_unlock(); return LINUX_POLLIN | LINUX_POLLOUT; } /* Discard the event */ ReadConsoleInputW(console->in, &ir, 1, &num_read); } /* We don't find any readable events */ console_unlock(); return LINUX_POLLOUT; }
static int mxc_elcdif_fb_suspend(struct platform_device *pdev, pm_message_t state) { struct fb_info *fbi = platform_get_drvdata(pdev); struct mxc_elcdif_fb_data *data = (struct mxc_elcdif_fb_data *)fbi->par; int saved_blank; console_lock(); fb_set_suspend(fbi, 1); saved_blank = data->cur_blank; mxc_elcdif_fb_blank(FB_BLANK_POWERDOWN, fbi); data->next_blank = saved_blank; if (!g_elcdif_pix_clk_enable) { clk_enable(g_elcdif_pix_clk); g_elcdif_pix_clk_enable = true; } mxc_elcdif_stop(); mxc_elcdif_dma_release(); if (g_elcdif_pix_clk_enable) { clk_disable(g_elcdif_pix_clk); g_elcdif_pix_clk_enable = false; } if (g_elcdif_axi_clk_enable) { clk_disable(g_elcdif_axi_clk); g_elcdif_axi_clk_enable = false; } console_unlock(); return 0; }
static int fsl_dcu_drm_pm_resume(struct device *dev) { struct fsl_dcu_drm_device *fsl_dev = dev_get_drvdata(dev); int ret; if (!fsl_dev) return 0; ret = clk_prepare_enable(fsl_dev->clk); if (ret < 0) { dev_err(dev, "failed to enable dcu clk\n"); return ret; } if (fsl_dev->tcon) fsl_tcon_bypass_enable(fsl_dev->tcon); fsl_dcu_drm_init_planes(fsl_dev->drm); drm_atomic_helper_resume(fsl_dev->drm, fsl_dev->state); console_lock(); drm_fbdev_cma_set_suspend(fsl_dev->fbdev, 0); console_unlock(); drm_kms_helper_poll_enable(fsl_dev->drm); enable_irq(fsl_dev->irq); return 0; }
static int xylonfb_adv7511_update(struct fb_info *fbi) { struct xylonfb_layer_data *ld = fbi->par; struct xylonfb_misc_data *misc_data = ld->xylonfb_cd->xylonfb_misc; int ret; driver_devel("%s\n", __func__); fbi->monspecs = *(misc_data->monspecs); console_lock(); misc_data->var_screeninfo->xres_virtual = fbi->var.xres_virtual; misc_data->var_screeninfo->yres_virtual = fbi->var.yres_virtual; misc_data->var_screeninfo->xoffset = fbi->var.xoffset; misc_data->var_screeninfo->yoffset = fbi->var.yoffset; misc_data->var_screeninfo->bits_per_pixel = fbi->var.bits_per_pixel; fbi->flags |= FBINFO_MISC_USEREVENT; misc_data->var_screeninfo->activate |= FB_ACTIVATE_ALL; ret = fb_set_var(fbi, misc_data->var_screeninfo); misc_data->var_screeninfo->activate &= ~FB_ACTIVATE_ALL; console_unlock(); return ret; }
void __init locate_and_init_vga(void *(*sel_func)(void *, void *)) { struct pci_controller *hose = NULL; struct pci_dev *dev = NULL; /* Default the select function */ if (!sel_func) sel_func = (void *)default_vga_hose_select; /* Find the console VGA device */ for(dev=NULL; (dev=pci_get_class(PCI_CLASS_DISPLAY_VGA << 8, dev));) { if (!hose) hose = dev->sysdata; else hose = sel_func(hose, dev->sysdata); } /* Did we already initialize the correct one? Is there one? */ if (!hose || (conswitchp == &vga_con && pci_vga_hose == hose)) return; /* Create a new VGA ioport resource WRT the hose it is on. */ alpha_vga.start += hose->io_space->start; alpha_vga.end += hose->io_space->start; request_resource(hose->io_space, &alpha_vga); /* Set the VGA hose and init the new console. */ pci_vga_hose = hose; console_lock(); do_take_over_console(&vga_con, 0, MAX_NR_CONSOLES-1, 1); console_unlock(); }
static void OMAPLFBDeInitFBDev(OMAPLFB_DEVINFO *psDevInfo) { struct fb_info *psLINFBInfo = psDevInfo->psLINFBInfo; struct module *psLINFBOwner; #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,38)) console_lock(); #else acquire_console_sem(); #endif psLINFBOwner = psLINFBInfo->fbops->owner; if (psLINFBInfo->fbops->fb_release != NULL) { (void) psLINFBInfo->fbops->fb_release(psLINFBInfo, 0); } module_put(psLINFBOwner); #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,38)) console_unlock(); #else release_console_sem(); #endif }
static int i915_drm_freeze(struct drm_device *dev) { struct drm_i915_private *dev_priv = dev->dev_private; struct drm_crtc *crtc; intel_runtime_pm_get(dev_priv); /* ignore lid events during suspend */ mutex_lock(&dev_priv->modeset_restore_lock); dev_priv->modeset_restore = MODESET_SUSPENDED; mutex_unlock(&dev_priv->modeset_restore_lock); /* We do a lot of poking in a lot of registers, make sure they work * properly. */ hsw_disable_package_c8(dev_priv); intel_display_set_init_power(dev, true); drm_kms_helper_poll_disable(dev); pci_save_state(dev->pdev); /* If KMS is active, we do the leavevt stuff here */ if (drm_core_check_feature(dev, DRIVER_MODESET)) { int error; error = i915_gem_suspend(dev); if (error) { dev_err(&dev->pdev->dev, "GEM idle failed, resume might fail\n"); return error; } cancel_delayed_work_sync(&dev_priv->rps.delayed_resume_work); drm_irq_uninstall(dev); dev_priv->enable_hotplug_processing = false; /* * Disable CRTCs directly since we want to preserve sw state * for _thaw. */ mutex_lock(&dev->mode_config.mutex); list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) dev_priv->display.crtc_disable(crtc); mutex_unlock(&dev->mode_config.mutex); intel_modeset_suspend_hw(dev); } i915_gem_suspend_gtt_mappings(dev); i915_save_state(dev); intel_opregion_fini(dev); console_lock(); intel_fbdev_set_suspend(dev, FBINFO_STATE_SUSPENDED); console_unlock(); return 0; }
static int i915_drm_freeze(struct drm_device *dev) { struct drm_i915_private *dev_priv = dev->dev_private; drm_kms_helper_poll_disable(dev); pci_save_state(dev->pdev); /* If KMS is active, we do the leavevt stuff here */ if (drm_core_check_feature(dev, DRIVER_MODESET)) { int error = i915_gem_idle(dev); if (error) { dev_err(&dev->pdev->dev, "GEM idle failed, resume might fail\n"); return error; } drm_irq_uninstall(dev); } i915_save_state(dev); intel_opregion_fini(dev); /* Modeset on resume, not lid events */ dev_priv->modeset_on_lid = 0; console_lock(); intel_fbdev_set_suspend(dev, 1); console_unlock(); return 0; }
void arm_machine_flush_console(void) { printk("\n"); pr_emerg("Restarting %s\n", linux_banner); if (console_trylock()) { console_unlock(); return; } mdelay(50); local_irq_disable(); if (!console_trylock()) pr_emerg("arm_restart: Console was locked! Busting\n"); else pr_emerg("arm_restart: Console was locked!\n"); console_unlock(); }
static void blank_framebuffer(int getref) { struct device *fbdev = NULL; struct fb_info *fb_info; struct s3c_fb_win *win; struct s3c_fb *sfb; struct s3c_fb_platdata *pd; fbdev = get_fb_dev(); if (!fbdev) return; fb_info = get_fb_info(fbdev); if (!fb_info) return; /* * hold a reference to the dsim device, to prevent it from going into * power management during tui session */ win = fb_info->par; sfb = win->parent; pd = sfb->pdata; /* Re-enable the clocks */ //enable_clocks(fbdev->parent, // disp_clock_name, ARRAY_SIZE(disp_clock_name), 1); //enable_clocks(NULL, other_clock_name, ARRAY_SIZE(other_clock_name), 1); #if defined(CONFIG_SOC_EXYNOS5420) pm_runtime_get_sync(pd->dsim1_device); #endif if (getref) pm_runtime_get_sync(sfb->dev); /* blank the framebuffer */ lock_fb_info(fb_info); console_lock(); fb_info->flags |= FBINFO_MISC_USEREVENT; fb_blank(fb_info, FB_BLANK_POWERDOWN); fb_info->flags &= ~FBINFO_MISC_USEREVENT; console_unlock(); unlock_fb_info(fb_info); #if defined(CONFIG_SOC_EXYNOS5420) /* * part of the init of dsim device is not done in the TEE. So do it * here */ gpio_request_one(EXYNOS5420_GPF1(6), GPIOF_OUT_INIT_HIGH, "GPIO_MIPI_18V_EN"); usleep_range(5000, 6000); gpio_free(EXYNOS5420_GPF1(6)); #endif }
void tegra_drm_fb_resume(struct drm_device *drm) { #ifdef CONFIG_DRM_FBDEV_EMULATION struct tegra_drm *tegra = drm->dev_private; console_lock(); drm_fb_helper_set_suspend(&tegra->fbdev->base, 0); console_unlock(); #endif }
int __init mda_console_init(void) { int err; if (mda_first_vc > mda_last_vc) return 1; console_lock(); err = do_take_over_console(&mda_con, mda_first_vc-1, mda_last_vc-1, 0); console_unlock(); return err; }
static int ast_drm_freeze(struct drm_device *dev) { drm_kms_helper_poll_disable(dev); pci_save_state(dev->pdev); console_lock(); ast_fbdev_set_suspend(dev, 1); console_unlock(); return 0; }
static int __init pdc_console_tty_driver_init(void) { int err; struct tty_driver *drv; /* Check if the console driver is still registered. * It is unregistered if the pdc console was not selected as the * primary console. */ struct console *tmp; console_lock(); for_each_console(tmp) if (tmp == &pdc_cons) break; console_unlock(); if (!tmp) { printk(KERN_INFO "PDC console driver not registered anymore, not creating %s\n", pdc_cons.name); return -ENODEV; } printk(KERN_INFO "The PDC console driver is still registered, removing CON_BOOT flag\n"); pdc_cons.flags &= ~CON_BOOT; drv = alloc_tty_driver(1); if (!drv) return -ENOMEM; drv->driver_name = "pdc_cons"; drv->name = "ttyB"; drv->major = MUX_MAJOR; drv->minor_start = 0; drv->type = TTY_DRIVER_TYPE_SYSTEM; drv->init_termios = tty_std_termios; drv->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_RESET_TERMIOS; tty_set_operations(drv, &pdc_console_tty_ops); err = tty_register_driver(drv); if (err) { printk(KERN_ERR "Unable to register the PDC console TTY driver\n"); return err; } pdc_console_tty_driver = drv; /* No need to initialize the pdc_console_timer if tty isn't allocated */ init_timer(&pdc_console_timer); pdc_console_timer.function = pdc_console_poll; return 0; }
void nouveau_fbcon_set_suspend(struct drm_device *dev, int state) { struct drm_nouveau_private *dev_priv = dev->dev_private; console_lock(); if (state == 0) nouveau_fbcon_save_disable_accel(dev); fb_set_suspend(dev_priv->nfbdev->helper.fbdev, state); if (state == 1) nouveau_fbcon_restore_accel(dev); console_unlock(); }
void intel_console_resume(struct work_struct *work) { struct drm_i915_private *dev_priv = container_of(work, struct drm_i915_private, console_resume_work); struct drm_device *dev = dev_priv->dev; console_lock(); intel_fbdev_set_suspend(dev, FBINFO_STATE_RUNNING); console_unlock(); }
static int vbox_drm_thaw(struct drm_device *dev) { int error = 0; drm_mode_config_reset(dev); drm_helper_resume_force_mode(dev); console_lock(); vbox_fbdev_set_suspend(dev, 0); console_unlock(); return error; }
static int mxc_elcdif_fb_resume(struct platform_device *pdev) { struct fb_info *fbi = platform_get_drvdata(pdev); struct mxc_elcdif_fb_data *data = (struct mxc_elcdif_fb_data *)fbi->par; console_lock(); mxc_elcdif_fb_blank(data->next_blank, fbi); fb_set_suspend(fbi, 0); console_unlock(); return 0; }
static int chipsfb_pci_resume(struct pci_dev *pdev) { struct fb_info *p = pci_get_drvdata(pdev); console_lock(); fb_set_suspend(p, 0); chipsfb_blank(0, p); console_unlock(); pdev->dev.power.power_state = PMSG_ON; return 0; }
static void tegra_pm_flush_console(void) { if (console_flushed) return; console_flushed = true; pr_emerg("Restarting %s\n", linux_banner); if (console_trylock()) { console_unlock(); return; } mdelay(50); local_irq_disable(); if (!console_trylock()) pr_emerg("%s: Console was locked! Busting\n", __func__); else pr_emerg("%s: Console was locked!\n", __func__); console_unlock(); }
static int __i915_drm_thaw(struct drm_device *dev) { struct drm_i915_private *dev_priv = dev->dev_private; int error = 0; i915_restore_state(dev); intel_opregion_setup(dev); /* KMS EnterVT equivalent */ if (drm_core_check_feature(dev, DRIVER_MODESET)) { intel_init_pch_refclk(dev); mutex_lock(&dev->struct_mutex); dev_priv->mm.suspended = 0; error = i915_gem_init_hw(dev); mutex_unlock(&dev->struct_mutex); /* We need working interrupts for modeset enabling ... */ drm_irq_install(dev); intel_modeset_init_hw(dev); intel_modeset_setup_hw_state(dev, false); /* * ... but also need to make sure that hotplug processing * doesn't cause havoc. Like in the driver load code we don't * bother with the tiny race here where we might loose hotplug * notifications. * */ intel_hpd_init(dev); dev_priv->enable_hotplug_processing = true; } intel_opregion_init(dev); /* * The console lock can be pretty contented on resume due * to all the printk activity. Try to keep it out of the hot * path of resume if possible. */ if (console_trylock()) { intel_fbdev_set_suspend(dev, 0); console_unlock(); } else { schedule_work(&dev_priv->console_resume_work); } mutex_lock(&dev_priv->modeset_restore_lock); dev_priv->modeset_restore = MODESET_DONE; mutex_unlock(&dev_priv->modeset_restore_lock); return error; }
void intel_console_resume(struct work_struct *work) { #ifndef __NetBSD__ /* XXX fb */ struct drm_i915_private *dev_priv = container_of(work, struct drm_i915_private, console_resume_work); struct drm_device *dev = dev_priv->dev; console_lock(); intel_fbdev_set_suspend(dev, 0); console_unlock(); #endif }
static int __init pdc_console_tty_driver_init(void) { int err; /* Check if the console driver is still registered. * It is unregistered if the pdc console was not selected as the * primary console. */ struct console *tmp; console_lock(); for_each_console(tmp) if (tmp == &pdc_cons) break; console_unlock(); if (!tmp) { printk(KERN_INFO "PDC console driver not registered anymore, not creating %s\n", pdc_cons.name); return -ENODEV; } printk(KERN_INFO "The PDC console driver is still registered, removing CON_BOOT flag\n"); pdc_cons.flags &= ~CON_BOOT; tty_port_init(&tty_port); pdc_console_tty_driver = alloc_tty_driver(1); if (!pdc_console_tty_driver) return -ENOMEM; pdc_console_tty_driver->driver_name = "pdc_cons"; pdc_console_tty_driver->name = "ttyB"; pdc_console_tty_driver->major = MUX_MAJOR; pdc_console_tty_driver->minor_start = 0; pdc_console_tty_driver->type = TTY_DRIVER_TYPE_SYSTEM; pdc_console_tty_driver->init_termios = tty_std_termios; pdc_console_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_RESET_TERMIOS; tty_set_operations(pdc_console_tty_driver, &pdc_console_tty_ops); tty_port_link_device(&tty_port, pdc_console_tty_driver, 0); err = tty_register_driver(pdc_console_tty_driver); if (err) { printk(KERN_ERR "Unable to register the PDC console TTY driver\n"); return err; } return 0; }
static int bochs_pm_suspend(struct device *dev) { struct pci_dev *pdev = to_pci_dev(dev); struct drm_device *drm_dev = pci_get_drvdata(pdev); struct bochs_device *bochs = drm_dev->dev_private; drm_kms_helper_poll_disable(drm_dev); if (bochs->fb.initialized) { console_lock(); drm_fb_helper_set_suspend(&bochs->fb.helper, 1); console_unlock(); } return 0; }
static int cirrus_pm_suspend(struct device *dev) { struct pci_dev *pdev = to_pci_dev(dev); struct drm_device *drm_dev = pci_get_drvdata(pdev); struct cirrus_device *cdev = drm_dev->dev_private; drm_kms_helper_poll_disable(drm_dev); if (cdev->mode_info.gfbdev) { console_lock(); fb_set_suspend(cdev->mode_info.gfbdev->helper.fbdev, 1); console_unlock(); } return 0; }
static int ast_drm_thaw(struct drm_device *dev) { int error = 0; ast_post_gpu(dev); drm_mode_config_reset(dev); drm_modeset_lock_all(dev); drm_helper_resume_force_mode(dev); drm_modeset_unlock_all(dev); console_lock(); ast_fbdev_set_suspend(dev, 0); console_unlock(); return error; }
static int i915_drm_freeze(struct drm_device *dev) { struct drm_i915_private *dev_priv = dev->dev_private; drm_kms_helper_poll_disable(dev); #ifndef __NetBSD__ /* pmf handles this for us. */ pci_save_state(dev->pdev); #endif /* If KMS is active, we do the leavevt stuff here */ if (drm_core_check_feature(dev, DRIVER_MODESET)) { int error = i915_gem_idle(dev); if (error) { #ifdef __NetBSD__ dev_err(pci_dev_dev(dev->pdev), "GEM idle failed, resume might fail\n"); #else dev_err(&dev->pdev->dev, "GEM idle failed, resume might fail\n"); #endif return error; } cancel_delayed_work_sync(&dev_priv->rps.delayed_resume_work); intel_modeset_disable(dev); drm_irq_uninstall(dev); } i915_save_state(dev); intel_opregion_fini(dev); /* Modeset on resume, not lid events */ dev_priv->modeset_on_lid = 0; #ifndef __NetBSD__ /* XXX fb */ console_lock(); intel_fbdev_set_suspend(dev, 1); console_unlock(); #endif return 0; }
static int chipsfb_pci_suspend(struct pci_dev *pdev, pm_message_t state) { struct fb_info *p = pci_get_drvdata(pdev); if (state.event == pdev->dev.power.power_state.event) return 0; if (!(state.event & PM_EVENT_SLEEP)) goto done; console_lock(); chipsfb_blank(1, p); fb_set_suspend(p, 1); console_unlock(); done: pdev->dev.power.power_state = state; return 0; }
static int i915_drm_thaw(struct drm_device *dev) { struct drm_i915_private *dev_priv = dev->dev_private; int error = 0; if (drm_core_check_feature(dev, DRIVER_MODESET)) { mutex_lock(&dev->struct_mutex); i915_gem_restore_gtt_mappings(dev); mutex_unlock(&dev->struct_mutex); } i915_restore_state(dev); intel_opregion_setup(dev); /* KMS EnterVT equivalent */ if (drm_core_check_feature(dev, DRIVER_MODESET)) { mutex_lock(&dev->struct_mutex); dev_priv->mm.suspended = 0; error = i915_gem_init_hw(dev); mutex_unlock(&dev->struct_mutex); if (HAS_PCH_SPLIT(dev)) ironlake_init_pch_refclk(dev); drm_mode_config_reset(dev); drm_irq_install(dev); /* Resume the modeset for every activated CRTC */ mutex_lock(&dev->mode_config.mutex); drm_helper_resume_force_mode(dev); mutex_unlock(&dev->mode_config.mutex); if (IS_IRONLAKE_M(dev)) ironlake_enable_rc6(dev); } intel_opregion_init(dev); dev_priv->modeset_on_lid = 0; console_lock(); intel_fbdev_set_suspend(dev, 0); console_unlock(); return error; }