/* Hotplug interrupt occurred, read EDID */ static void edid_work_fn(struct work_struct *work) { struct sh_hdmi *hdmi = container_of(work, struct sh_hdmi, edid_work.work); struct sh_mobile_hdmi_info *pdata = hdmi->dev->platform_data; pr_debug("%s(%p): begin, hotplug status %d\n", __func__, pdata->lcd_dev, hdmi->hp_state); if (!pdata->lcd_dev) return; if (hdmi->hp_state == HDMI_HOTPLUG_EDID_DONE) { pm_runtime_get_sync(hdmi->dev); /* A device has been plugged in */ sh_hdmi_read_edid(hdmi); msleep(10); sh_hdmi_configure(hdmi); /* Switched to another (d) power-save mode */ msleep(10); if (!hdmi->info) return; acquire_console_sem(); /* HDMI plug in */ hdmi->info->var = hdmi->var; if (hdmi->info->state != FBINFO_STATE_RUNNING) fb_set_suspend(hdmi->info, 0); else hdmi_display_on(hdmi, hdmi->info); release_console_sem(); } else { if (!hdmi->info) return; acquire_console_sem(); /* HDMI disconnect */ fb_set_suspend(hdmi->info, 1); release_console_sem(); pm_runtime_put(hdmi->dev); } pr_debug("%s(%p): end\n", __func__, pdata->lcd_dev); }
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; }
void intel_fbdev_set_suspend(struct drm_device *dev, int state) { drm_i915_private_t *dev_priv = dev->dev_private; if (!dev_priv->fbdev) return; fb_set_suspend(dev_priv->fbdev->helper.fbdev, state); }
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(); }
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; }
int radeonfb_pci_suspend(struct pci_dev *pdev, u32 state) { struct fb_info *info = pci_get_drvdata(pdev); struct radeonfb_info *rinfo = info->par; /* We don't do anything but D2, for now we return 0, but * we may want to change that. How do we know if the BIOS * can properly take care of D3 ? Also, with swsusp, we * know we'll be rebooted, ... */ printk(KERN_DEBUG "radeonfb: suspending to state: %d...\n", state); acquire_console_sem(); /* Userland should do this but doesn't... bridge gets suspended * too late. Unfortunately, that works only when AGP is built-in, * not for a module. */ #ifdef CONFIG_AGP agp_enable(0); #endif fb_set_suspend(info, 1); if (!radeon_accel_disabled()) { /* Make sure engine is reset */ radeon_engine_idle(); radeonfb_engine_reset(rinfo); radeon_engine_idle(); } /* Blank display and LCD */ radeonfb_blank(VESA_POWERDOWN+1, info); /* Sleep */ rinfo->asleep = 1; rinfo->lock_blank = 1; /* Suspend the chip to D2 state when supported */ #ifdef CONFIG_RADEON_HAS_D2 if (radeon_suspend_to_d2(rinfo, state)) radeon_set_suspend(rinfo, 1); #endif /* CONFIG_RADEON_HAS_D2 */ release_console_sem(); pdev->dev.power_state = state; return 0; }
static void sprdfb_early_suspend (struct early_suspend* es) { struct sprdfb_device *dev = container_of(es, struct sprdfb_device, early_suspend); struct fb_info *fb = dev->fb; printk("sprdfb: [%s]\n",__FUNCTION__); fb_set_suspend(fb, FBINFO_STATE_SUSPENDED); if (!lock_fb_info(fb)) { return ; } dev->ctrl->suspend(dev); unlock_fb_info(fb); }
static void sprdfb_late_resume (struct early_suspend* es) { struct sprdfb_device *dev = container_of(es, struct sprdfb_device, early_suspend); struct fb_info *fb = dev->fb; pr_debug("sprdfb: [%s]\n",__FUNCTION__); if (!lock_fb_info(fb)) { return ; } dev->ctrl->resume(dev); unlock_fb_info(fb); fb_set_suspend(fb, FBINFO_STATE_RUNNING); }
static int sprdfb_power(struct sprdfb_device *dev, int on) { static DEFINE_MUTEX(lock); struct fb_info *fb = dev->fb; mutex_lock(&lock); if (dev->enable == !!on) { pr_info("[LCD] %s, already %s\n", __func__, dev->enable ? "on" : "off"); mutex_unlock(&lock); return 0; } if (on) { dev->ctrl->resume(dev); fb_set_suspend(fb, FBINFO_STATE_RUNNING); } else { fb_set_suspend(fb, FBINFO_STATE_SUSPENDED); dev->ctrl->suspend(dev); } mutex_unlock(&lock); 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(); fb_set_suspend(bochs->fb.helper.fbdev, 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 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 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_SUSPEND_MEM) goto done; acquire_console_sem(); chipsfb_blank(1, p); fb_set_suspend(p, 1); release_console_sem(); done: pdev->dev.power.power_state = state; return 0; }
void intel_fbdev_set_suspend(struct drm_device *dev, int state) { struct drm_i915_private *dev_priv = dev->dev_private; struct intel_fbdev *ifbdev = dev_priv->fbdev; struct fb_info *info; if (!ifbdev) return; info = ifbdev->helper.fbdev; /* On resume from hibernation: If the object is shmemfs backed, it has * been restored from swap. If the object is stolen however, it will be * full of whatever garbage was left in there. */ if (state == FBINFO_STATE_RUNNING && ifbdev->ifb.obj->stolen) memset_io(info->screen_base, 0, info->screen_size); fb_set_suspend(info, state); }
static int stmfb_resume(struct platform_device *pdev) { struct stmfb_info *i = (struct stmfb_info *)platform_get_drvdata(pdev); DPRINTK("\n"); if(!i) return 0; if(pdev->dev.power.power_state.event == PM_EVENT_ON) return 0; acquire_console_sem(); if(down_interruptible(&i->framebufferLock)) { release_console_sem(); return -EINTR; } if(i->pFBMainOutput) stm_display_output_resume(i->pFBMainOutput); if(i->pFBDVO) stm_display_output_resume(i->pFBDVO); up(&i->framebufferLock); /* * Now the hardware is back, kick the framebuffer into life */ fb_pan_display(&i->info, &i->info.var); fb_set_cmap(&i->info.cmap, &i->info); fb_set_suspend(&i->info, 0); release_console_sem(); DPRINTK("resumed\n"); return 0; }
int radeonfb_pci_resume(struct pci_dev *pdev) { struct fb_info *info = pci_get_drvdata(pdev); struct radeonfb_info *rinfo = info->par; if (pdev->dev.power_state == 0) return 0; acquire_console_sem(); /* Wakeup chip */ #ifdef CONFIG_RADEON_HAS_D2 if (radeon_suspend_to_d2(rinfo, 0)) radeon_set_suspend(rinfo, 0); #endif /* CONFIG_RADEON_HAS_D2 */ rinfo->asleep = 0; /* Restore display & engine */ radeonfb_set_par(info); fb_pan_display(info, &info->var); fb_set_cmap(&info->cmap, 1, info); /* Refresh */ fb_set_suspend(info, 0); /* Unblank */ rinfo->lock_blank = 0; radeonfb_blank(0, info); release_console_sem(); pdev->dev.power_state = 0; printk(KERN_DEBUG "radeonfb: resumed !\n"); return 0; }
static int stmfb_suspend(struct platform_device *pdev, pm_message_t state) { struct stmfb_info *i = (struct stmfb_info *)platform_get_drvdata(pdev); DPRINTK("\n"); if(!i) return 0; if (state.event == pdev->dev.power.power_state.event) return 0; acquire_console_sem(); if(down_interruptible(&i->framebufferLock)) { release_console_sem(); return -EINTR; } if(i->pBlitter) { if(stm_display_blitter_sync(i->pBlitter)<0) { release_console_sem(); up(&i->framebufferLock); return -EINTR; } } /* * Suspend the main output first (there must be one!) which will stop the * timing generator, hence any more vsync interrupts. */ if(i->pFBMainOutput) stm_display_output_suspend(i->pFBMainOutput); if(i->pFBDVO) stm_display_output_suspend(i->pFBDVO); /* * HDMI is different, we need to stop it completely, which will force * the display state to NEEDS_RESTART. Once we resume the main output and * get a new VSYNC interrupt the ISR will spot this state change and signal * the HDMI thread which will look to see if the connected device has changed * (i.e. someone plugged in a different TV) while we were suspended and bring * the HDMI output back up again (if required at all) in the correct state. */ if(i->hdmi) stm_display_output_stop(i->hdmi->hdmi_output); /* * We release the framebuffer lock here as the fb_set_suspend callbacks * might call back into the driver. */ up(&i->framebufferLock); fb_set_suspend(&i->info, 1); release_console_sem(); DPRINTK("finished suspending\n"); return 0; }
void nouveau_fbcon_set_suspend(struct drm_device *dev, int state) { struct drm_nouveau_private *dev_priv = dev->dev_private; fb_set_suspend(dev_priv->nfbdev->helper.fbdev, state); }
void radeon_fbdev_set_suspend(struct radeon_device *rdev, int state) { fb_set_suspend(rdev->mode_info.rfbdev->helper.fbdev, state); }