static void *c_start(struct seq_file *m, loff_t *pos)
{
struct console *con;
loff_t off = 0;
console_lock();
for_each_console(con)
if (off++ == *pos)
break;
return con;
}
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 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 void ping_recv_callback(void* arg, void *pdata)
{
struct ping_resp *pingresp = pdata;
if(pingresp->seqno == 3 /*LAST PING PACKET*/){
console_printf("total %d, lost %d, %d bytes, %d ms (%d)\n" ,
pingresp->total_count, pingresp->timeout_count, pingresp->total_bytes, pingresp->total_time, pingresp->ping_err);
console_lock(0);
} else {
console_printf("recv %d bytes in %d ms, seq %d (%d)\n" , pingresp->bytes, pingresp->resp_time, pingresp->seqno, pingresp->ping_err);
}
}
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 int do_listen_interrupt()
{
console_printf("BUG: How on earth to properly stop listening???\n");
espconn_disconnect(&esp_conn);
void *p;
bool value = espconn_find_connection(&esp_conn, &p);
console_printf("===>%d \n", value);
espconn_tcp_disconnect(p);
// os_free(linebuffer);
console_lock(0);
}
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 do_ping(int argc, const char* const* argv)
{
struct ping_option *pingopts = os_zalloc(sizeof(struct ping_option));
ip_addr_t ipaddr;
ipaddr.addr = ipaddr_addr(argv[1]);
pingopts->ip = ipaddr.addr;
pingopts->count = 3;
pingopts->recv_function=ping_recv_callback;
pingopts->sent_function=NULL;
ping_start(pingopts);
console_lock(1);
return 0;
}
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 do_listen(int argc, const char* argv[])
{
int port = skip_atoi(&argv[1]);
console_printf("Listening (TCP) on port %d\n", port);
esp_conn.type = ESPCONN_TCP;
esp_conn.state = ESPCONN_NONE;
esp_conn.proto.tcp = &esptcp;
esp_conn.proto.tcp->local_port = port;
espconn_regist_connectcb(&esp_conn, webserver_listen);
espconn_accept(&esp_conn);
linebuffer = os_malloc(LINEBUFFER_SIZE);
lineptr = 0;
console_lock(1);
}
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;
}
/* Unblank the screen */
static DC_SUNXI_ERROR DC_SUNXIUnblankDisplay(DC_SUNXI_DEVINFO *psDevInfo)
{
int res;
console_lock();
res = fb_blank(psDevInfo->psLINFBInfo, 0);
console_unlock();
if (res != 0 && res != -EINVAL)
{
printk(KERN_ERR DRIVER_PREFIX
": %s: Device %u: fb_blank failed (%d)\n", __FUNCTION__, psDevInfo->uiFBDevID, res);
return (DC_SUNXI_ERROR_GENERIC);
}
return (DC_SUNXI_OK);
}
static int bochs_pm_resume(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_helper_resume_force_mode(drm_dev);
if (bochs->fb.initialized) {
console_lock();
fb_set_suspend(bochs->fb.helper.fbdev, 0);
console_unlock();
}
drm_kms_helper_poll_enable(drm_dev);
return 0;
}
static int cirrus_pm_resume(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_helper_resume_force_mode(drm_dev);
if (cdev->mode_info.gfbdev) {
console_lock();
drm_fb_helper_set_suspend(&cdev->mode_info.gfbdev->helper, 0);
console_unlock();
}
drm_kms_helper_poll_enable(drm_dev);
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_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 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;
}
static void __exit DC_FBDEV_exit(void)
{
DC_FBDEV_DEVICE *psDeviceData = gpsDeviceData;
struct fb_info *psLINFBInfo = psDeviceData->psLINFBInfo;
lock_fb_info(psLINFBInfo);
console_lock();
if(psLINFBInfo->fbops->fb_release)
psLINFBInfo->fbops->fb_release(psLINFBInfo, 0);
module_put(psLINFBInfo->fbops->owner);
console_unlock();
unlock_fb_info(psLINFBInfo);
DCUnregisterDevice(psDeviceData->hSrvHandle);
kfree(psDeviceData);
}
static void unblank_framebuffer(int releaseref)
{
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;
/*
* Release the reference we took at the beginning of the TUI session
*/
win = fb_info->par;
sfb = win->parent;
pd = sfb->pdata;
/*
* Unblank the framebuffer
*/
console_lock();
fb_info->flags |= FBINFO_MISC_USEREVENT;
fb_blank(fb_info, FB_BLANK_UNBLANK);
fb_info->flags &= ~FBINFO_MISC_USEREVENT;
console_unlock();
if (releaseref)
pm_runtime_put_sync(sfb->dev);
#if defined(CONFIG_SOC_EXYNOS5420)
pm_runtime_put_sync(pd->dsim1_device);
#endif
/* We longer need the clock to be up */
//enable_clocks(NULL, other_clock_name, ARRAY_SIZE(other_clock_name), 0);
//enable_clocks(fbdev->parent,
//disp_clock_name, ARRAY_SIZE(disp_clock_name), 0);
}
static int i915_drm_freeze(struct drm_device *dev)
{
struct drm_i915_private *dev_priv = dev->dev_private;
/* 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);
intel_set_power_well(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 = i915_gem_idle(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);
intel_modeset_disable(dev);
drm_irq_uninstall(dev);
dev_priv->enable_hotplug_processing = false;
}
i915_save_state(dev);
intel_opregion_fini(dev);
console_lock();
intel_fbdev_set_suspend(dev, 1);
console_unlock();
return 0;
}
/*
* Locking: both .fb_release() and .fb_open() are called with info->lock held if
* user == 1, or with console sem held, if user == 0.
*/
static int sh_mobile_release(struct fb_info *info, int user)
{
struct sh_mobile_lcdc_chan *ch = info->par;
mutex_lock(&ch->open_lock);
dev_dbg(info->dev, "%s(): %d users\n", __func__, ch->use_count);
ch->use_count--;
/* Nothing to reconfigure, when called from fbcon */
if (user) {
console_lock();
sh_mobile_fb_reconfig(info);
console_unlock();
}
mutex_unlock(&ch->open_lock);
return 0;
}
static int i915_kick_out_vgacon(struct drm_i915_private *dev_priv)
{
int ret = 0;
DRM_INFO("Replacing VGA console driver\n");
console_lock();
if (con_is_bound(&vga_con))
ret = do_take_over_console(&dummy_con, 0, MAX_NR_CONSOLES - 1, 1);
if (ret == 0) {
ret = do_unregister_con_driver(&vga_con);
/* Ignore "already unregistered". */
if (ret == -ENODEV)
ret = 0;
}
console_unlock();
return ret;
}
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)) {
if (HAS_PCH_IBX(dev) || HAS_PCH_CPT(dev))
ironlake_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);
intel_modeset_init_hw(dev);
intel_modeset_setup_hw_state(dev, false);
drm_mode_config_reset(dev);
drm_irq_install(dev);
}
intel_opregion_init(dev);
dev_priv->modeset_on_lid = 0;
console_lock();
intel_fbdev_set_suspend(dev, 0);
console_unlock();
return error;
}
static void lcd_init_fb(struct fb_info *info)
{
struct fb_var_screeninfo var;
memset(&var, 0, sizeof(var));
fb_videomode_to_var(&var, &video_modes[0]);
if (machine_is_mx31_3ds()) {
var.upper_margin = 0;
var.left_margin = 0;
}
var.activate = FB_ACTIVATE_ALL;
var.yres_virtual = var.yres * 3;
console_lock();
info->flags |= FBINFO_MISC_USEREVENT;
fb_set_var(info, &var);
info->flags &= ~FBINFO_MISC_USEREVENT;
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;
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;
if (getref)
pm_runtime_get_sync(sfb->dev);
/* blank the framebuffer */
lock_fb_info(fb_info);
console_lock();
fb_info->flags |= FBINFO_MISC_USEREVENT;
pr_info("%s call fb_blank\n", __func__);
fb_blank(fb_info, FB_BLANK_POWERDOWN);
fb_info->flags &= ~FBINFO_MISC_USEREVENT;
console_unlock();
unlock_fb_info(fb_info);
pr_info("%s call s3c_fb_deactivate_vsync\n", __func__);
s3c_fb_deactivate_vsync(sfb);
}
/* Flip display to given buffer */
static void DC_SUNXIFlip(DC_SUNXI_DEVINFO *psDevInfo, DC_SUNXI_BUFFER *psBuffer)
{
struct fb_var_screeninfo sFBVar;
unsigned long ulYResVirtual;
int res;
console_lock();
sFBVar = psDevInfo->psLINFBInfo->var;
sFBVar.xoffset = 0;
sFBVar.yoffset = psBuffer->ulYOffset;
ulYResVirtual = psBuffer->ulYOffset + sFBVar.yres;
res = fb_pan_display(psDevInfo->psLINFBInfo, &sFBVar);
if (res != 0)
{
printk(KERN_ERR DRIVER_PREFIX ": %s: Device %u: fb_pan_display failed (Y Offset: %lu, Error: %d)\n", __FUNCTION__, psDevInfo->uiFBDevID, psBuffer->ulYOffset, res);
}
console_unlock();
}
static void unblank_framebuffer(int releaseref)
{
struct device *fbdev = NULL;
struct fb_info *fb_info;
struct s3c_fb_win *win;
struct s3c_fb *sfb;
fbdev = get_fb_dev();
if (!fbdev)
return;
fb_info = get_fb_info(fbdev);
if (!fb_info)
return;
/*
* Release the reference we took at the beginning of the TUI session
*/
win = fb_info->par;
sfb = win->parent;
pr_info("%s call s3c_fb_activate_vsync\n", __func__);
s3c_fb_activate_vsync(sfb);
/*
* Unblank the framebuffer
*/
console_lock();
fb_info->flags |= FBINFO_MISC_USEREVENT;
fb_blank(fb_info, FB_BLANK_UNBLANK);
fb_info->flags &= ~FBINFO_MISC_USEREVENT;
console_unlock();
if (releaseref)
pm_runtime_put_sync(sfb->dev);
}
static void det_worker(struct work_struct *work)
{
int dat;
char event_string[16];
char *envp[] = { event_string, NULL };
dev_dbg(&sii902x.pdev->dev, "%s\n", __func__);
dat = i2c_smbus_read_byte_data(sii902x.client, 0x3D);
if (dat & 0x1) {
/* cable connection changes */
if (dat & 0x4) {
sii902x.cable_plugin = 1;
dev_dbg(&sii902x.pdev->dev, "EVENT=plugin\n");
sprintf(event_string, "EVENT=plugin");
if (sii902x_read_edid(sii902x.fbi) < 0)
dev_err(&sii902x.client->dev,
"Sii902x: read edid fail\n");
else {
if (sii902x.fbi->monspecs.modedb_len > 0) {
int i;
const struct fb_videomode *mode;
struct fb_videomode m;
fb_destroy_modelist(&sii902x.fbi->modelist);
for (i = 0; i < sii902x.fbi->monspecs.modedb_len; i++) {
/*FIXME now we do not support interlaced mode */
mode = &sii902x.fbi->monspecs.modedb[i];
if (!(mode->vmode & FB_VMODE_INTERLACED)) {
dev_dbg(&sii902x.pdev->dev, "Added mode %d:", i);
dev_dbg(&sii902x.pdev->dev,
"xres = %d, yres = %d, freq = %d, vmode = %d, flag = %d\n",
mode->xres, mode->yres, mode->refresh,
mode->vmode, mode->flag);
fb_add_videomode(mode, &sii902x.fbi->modelist);
}
}
fb_var_to_videomode(&m, &sii902x.fbi->var);
dump_fb_videomode(&m);
mode = fb_find_nearest_mode(&m,
&sii902x.fbi->modelist);
fb_videomode_to_var(&sii902x.fbi->var, mode);
sii902x.fbi->var.activate |= FB_ACTIVATE_FORCE;
console_lock();
sii902x.fbi->flags |= FBINFO_MISC_USEREVENT;
fb_set_var(sii902x.fbi, &sii902x.fbi->var);
sii902x.fbi->flags &= ~FBINFO_MISC_USEREVENT;
console_unlock();
}
/* Power on sii902x */
sii902x_poweron();
}
} else {
sii902x.cable_plugin = 0;
dev_dbg(&sii902x.pdev->dev, "EVENT=plugout\n");
sprintf(event_string, "EVENT=plugout");
/* Power off sii902x */
sii902x_poweroff();
}
kobject_uevent_env(&sii902x.pdev->dev.kobj, KOBJ_CHANGE, envp);
}
i2c_smbus_write_byte_data(sii902x.client, 0x3D, dat);
dev_dbg(&sii902x.pdev->dev, "exit %s\n", __func__);
}
