/** * adf_fbdev_destroy - destroy helper to wrap ADF device in fbdev API * * @fbdev: the fbdev helper */ void adf_fbdev_destroy(struct adf_fbdev *fbdev) { unregister_framebuffer(fbdev->info); BUG_ON(fbdev->refcount); mutex_destroy(&fbdev->refcount_lock); framebuffer_release(fbdev->info); }
static int memlcd_spi_remove(struct spi_device *spi) { memlcd_priv *priv = dev_get_drvdata(&spi->dev); /* cleanup defio */ fb_deferred_io_cleanup(priv->info); /* remove spi_buf memory */ if(priv->spi_buf) { dev_info(&spi->dev,"Free spi_buf memory"); kfree(priv->spi_buf); } /* remove framebuffer */ if(priv->info) { dev_info(&spi->dev,"Free framebuffer data"); unregister_framebuffer(priv->info); framebuffer_release(priv->info); } /* remove video memory */ if(priv->video_memory) { dev_info(&spi->dev,"Free videomemory"); kfree(priv->video_memory); } /* remove private data */ dev_info(&spi->dev,"Free private data"); kfree(priv); return 0; }
static void s5pv210_lcd_exit(void) { unregister_framebuffer(s5pv210_lcd); dma_free_writecombine(NULL, s5pv210_lcd->fix.smem_len, s5pv210_lcd->screen_base, s5pv210_lcd->fix.smem_start); iounmap(gpf0con); iounmap(gpf1con); iounmap(gpf2con); iounmap(gpf3con); iounmap(gpd0con); iounmap(gpd0dat); iounmap(display_control); iounmap(vidcon0); iounmap(vidcon1); iounmap(vidtcon2); iounmap(wincon0); iounmap(vidosd0a); iounmap(vidosd0b); iounmap(vidosd0c); iounmap(vidw00add0b0); iounmap(vidw00add1b0); iounmap(vidw00add2); iounmap(vidtcon0); iounmap(vidtcon1); iounmap(shadowcon); framebuffer_release(s5pv210_lcd); }
static int bochs_fbdev_destroy(struct bochs_device *bochs) { struct bochs_framebuffer *gfb = &bochs->fb.gfb; struct fb_info *info; DRM_DEBUG_DRIVER("\n"); if (bochs->fb.helper.fbdev) { info = bochs->fb.helper.fbdev; unregister_framebuffer(info); if (info->cmap.len) fb_dealloc_cmap(&info->cmap); framebuffer_release(info); } if (gfb->obj) { drm_gem_object_unreference_unlocked(gfb->obj); gfb->obj = NULL; } drm_fb_helper_fini(&bochs->fb.helper); drm_framebuffer_unregister_private(&gfb->base); drm_framebuffer_cleanup(&gfb->base); return 0; }
static int mxc_elcdif_fb_remove(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; mxc_elcdif_fb_blank(FB_BLANK_POWERDOWN, fbi); mxc_elcdif_stop(); release_dotclk_panel(); mxc_elcdif_dma_release(); if (g_elcdif_axi_clk_enable) { clk_disable(g_elcdif_axi_clk); g_elcdif_axi_clk_enable = false; } if (g_elcdif_pix_clk_enable) { clk_disable(g_elcdif_pix_clk); g_elcdif_pix_clk_enable = false; } clk_put(g_elcdif_axi_clk); clk_put(g_elcdif_pix_clk); free_irq(data->dma_irq, data); mxc_elcdif_fb_unmap_video_memory(fbi); if (&fbi->cmap) fb_dealloc_cmap(&fbi->cmap); unregister_framebuffer(fbi); framebuffer_release(fbi); platform_set_drvdata(pdev, NULL); return 0; }
static void einkfb_remove(struct fb_info *info, einkfb_init_err_t err) { switch ( err ) { case einkfb_init_err_none: BLANK_DONE(); unregister_framebuffer(info); case einkfb_init_err_register_framebuffer: HAL_HW_DONE(einkfb_hw_shutdown_mode); fb_dealloc_cmap(&info->cmap); case einkfb_init_err_fb_alloc_cmap: EINKFB_FREE_HAL(einkfb, einkfb_dma ? &einkfb_phys : NULL); case einkfb_init_err_einkfb_malloc_hal: HAL_SW_DONE(); case einkfb_init_err_hw_sw_init: framebuffer_release(info); default: case einkfb_init_err_framebuffer_alloc: if ( err ) einkfb_print_crit("failed to initialize, err = %d\n", err); break; } boot_milestone_write(EINK_HAL_STOPPED_BOM, EINK_HAL_STOPPED_BOM_SZ); }
/* * Cleanup */ static int nuc900fb_remove(struct platform_device *pdev) { struct fb_info *fbinfo = platform_get_drvdata(pdev); struct nuc900fb_info *fbi = fbinfo->par; int irq; nuc900fb_stop_lcd(fbinfo); msleep(1); unregister_framebuffer(fbinfo); nuc900fb_cpufreq_deregister(fbi); nuc900fb_unmap_video_memory(fbinfo); iounmap(fbi->io); irq = platform_get_irq(pdev, 0); free_irq(irq, fbi); release_resource(fbi->mem); kfree(fbi->mem); platform_set_drvdata(pdev, NULL); framebuffer_release(fbinfo); return 0; }
static int s3cfb_remove(struct platform_device *pdev) { struct s3c_platform_fb *pdata = to_fb_plat(&pdev->dev); struct fb_info *fb; int i; free_irq(ctrl->irq, ctrl); iounmap(ctrl->regs); clk_disable(ctrl->clock); clk_put(ctrl->clock); for (i = 0; i < pdata->nr_wins; i++) { fb = ctrl->fb[i]; /* free if exists */ if (fb) { s3cfb_unmap_video_memory(fb); s3cfb_set_buffer_address(ctrl, i); framebuffer_release(fb); } } kfree(ctrl->fb); kfree(ctrl); return 0; }
static void gfb_free_framebuffer_work(struct work_struct *work) { struct gfb_data *data = container_of(work, struct gfb_data, free_framebuffer_work.work); struct fb_info *info = data->fb_info; /* int node = info->node; */ unregister_framebuffer(info); if (info->cmap.len != 0) fb_dealloc_cmap(&info->cmap); if (info->monspecs.modedb) fb_destroy_modedb(info->monspecs.modedb); if (info->screen_base) vfree(info->screen_base); fb_destroy_modelist(&info->modelist); fb_deferred_io_cleanup(info); usb_free_urb(data->fb_urb); vfree(data->fb_bitmap); kfree(data->fb_vbitmap); framebuffer_release(info); kfree(data); }
static int s3cfb_extdsp_remove(struct platform_device *pdev) { struct s3cfb_extdsp_window *win; struct fb_info *fb; struct s3cfb_extdsp_global *fbdev[2]; int j; fbdev[0] = fbextdsp->fbdev[0]; #ifdef CONFIG_HAS_WAKELOCK #ifdef CONFIG_HAS_EARLYSUSPEND unregister_early_suspend(&fbdev[0]->early_suspend); #endif #endif for (j = 0; j < 1; j++) { fb = fbdev[0]->fb[j]; /* free if exists */ if (fb) { win = fb->par; s3cfb_extdsp_unmap_default_video_memory(fbdev[0], fb); framebuffer_release(fb); } } kfree(fbdev[0]->fb); kfree(fbdev[0]); return 0; }
__s32 Display_Fb_Release(__u32 sel, __s32 hdl) { __s32 fb_id = layer_hdl_to_fb_id(sel, hdl); __msg("Display_Fb_Release call\n"); if(fb_id >= 0) { fb_info_t * fbi = &g_fbi; struct fb_info *fbinfo = fbi->fbinfo[fb_id]; BSP_disp_layer_release(sel, hdl); unregister_framebuffer(fbinfo); Fb_unmap_video_memory(fbinfo); framebuffer_release(fbinfo); fbi->fb_screen_id[fbinfo->node] = -1; fbi->layer_hdl[fb_id] = 0; fbi->fbinfo[fb_id] = NULL; fbi->fb_num--; return DIS_SUCCESS; } else { __wrn("invalid paras (sel:%d,hdl:%d) in Display_Fb_Release\n", sel, hdl); return DIS_FAIL; } }
static void tegra_fbdev_free(struct tegra_fbdev *fbdev) { struct fb_info *info = fbdev->base.fbdev; if (info) { int err; err = unregister_framebuffer(info); if (err < 0) DRM_DEBUG_KMS("failed to unregister framebuffer\n"); if (info->cmap.len) fb_dealloc_cmap(&info->cmap); framebuffer_release(info); } if (fbdev->fb) { drm_framebuffer_unregister_private(&fbdev->fb->base); tegra_fb_destroy(&fbdev->fb->base); } drm_fb_helper_fini(&fbdev->base); kfree(fbdev); }
static void hisi_drm_fbdev_fini(struct hisi_drm_fbdev *fbdev) { if (fbdev->fb_helper.fbdev) { struct fb_info *info; int ret; info = fbdev->fb_helper.fbdev; ret = unregister_framebuffer(info); if (ret < 0) DRM_DEBUG_KMS("failed unregister_framebuffer()\n"); if (info->cmap.len) fb_dealloc_cmap(&info->cmap); framebuffer_release(info); } if (fbdev->fb) { drm_framebuffer_unregister_private(&fbdev->fb->fb); hisi_drm_fb_destroy(&fbdev->fb->fb); } drm_fb_helper_fini(&fbdev->fb_helper); kfree(fbdev); }
/** * adf_fbdev_destroy - destroy helper to wrap ADF device in fbdev API * * @fbdev: the fbdev helper */ void adf_fbdev_destroy(struct adf_fbdev *fbdev) { unregister_framebuffer(fbdev->info); if (WARN_ON(fbdev->open)) adf_fb_destroy(fbdev); framebuffer_release(fbdev->info); }
static void offb_destroy(struct fb_info *info) { if (info->screen_base) iounmap(info->screen_base); release_mem_region(info->apertures->ranges[0].base, info->apertures->ranges[0].size); framebuffer_release(info); }
static int __devinit milkymistfb_probe(struct platform_device *pdev) { struct milkymistfb *milkymistfb; struct fb_info *info; int ret = -ENOMEM; info = framebuffer_alloc(sizeof(*milkymistfb), &pdev->dev); if (!info) return -ENOMEM; info->fbops = &milkymistfb_ops; milkymistfb = info->par; milkymistfb->fb = info; fb_find_mode(&info->var, info, milkymistfb_mode_option, milkymist_modedb, ARRAY_SIZE(milkymist_modedb), NULL, 16); /* milkymistfb->vidmem = dma_alloc_coherent(&pdev->dev, videomemorysize, &milkymistfb->vidmem_phys, GFP_KERNEL);*/ milkymistfb->vidmem = vmalloc(videomemorysize); milkymistfb->vidmem_phys = (unsigned int)milkymistfb->vidmem; if (!milkymistfb->vidmem) { ret = -ENOMEM; goto err_framebuffer_release; } memset(milkymistfb->vidmem, 0, videomemorysize); info->screen_base = milkymistfb->vidmem; info->fix = milkymistfb_fix; info->pseudo_palette = milkymistfb->pseudo_palette; info->flags = FBINFO_FLAG_DEFAULT; info->fix.smem_start = milkymistfb->vidmem_phys; info->fix.smem_len = videomemorysize; ret = fb_alloc_cmap(&info->cmap, 256, 0); if (ret < 0) goto err_dma_free; ret = register_framebuffer(info); if (ret < 0) goto err_dealloc_cmap; platform_set_drvdata(pdev, milkymistfb); dev_info(&pdev->dev, "fb%d: Milkymist frame buffer at %p, size %ld k\n", info->node, milkymistfb->vidmem, videomemorysize >> 10); return 0; err_dealloc_cmap: fb_dealloc_cmap(&info->cmap); err_dma_free: /* dma_free_coherent(&pdev->dev, videomemorysize, milkymistfb->vidmem, milkymistfb->vidmem_phys);*/ vfree(milkymistfb->vidmem); err_framebuffer_release: framebuffer_release(info); return ret; }
static void intel_fbdev_destroy(struct drm_device *dev, struct intel_fbdev *ifbdev) { #if 0 struct fb_info *info; #endif struct intel_framebuffer *ifb = &ifbdev->ifb; #if 0 if (ifbdev->helper.fbdev) { info = ifbdev->helper.fbdev; unregister_framebuffer(info); iounmap(info->screen_base); if (info->cmap.len) fb_dealloc_cmap(&info->cmap); framebuffer_release(info); } #endif drm_fb_helper_fini(&ifbdev->helper); drm_framebuffer_cleanup(&ifb->base); if (ifb->obj) { drm_gem_object_unreference_unlocked(&ifb->obj->base); ifb->obj = NULL; } }
static int __devinit cfag12864bfb_probe(struct platform_device *device) { int ret = -EINVAL; struct fb_info *info = framebuffer_alloc(0, &device->dev); if (!info) goto none; info->screen_base = (char __iomem *) cfag12864b_buffer; info->screen_size = CFAG12864B_SIZE; info->fbops = &cfag12864bfb_ops; info->fix = cfag12864bfb_fix; info->var = cfag12864bfb_var; info->pseudo_palette = NULL; info->par = NULL; info->flags = FBINFO_FLAG_DEFAULT; if (register_framebuffer(info) < 0) goto fballoced; platform_set_drvdata(device, info); printk(KERN_INFO "fb%d: %s frame buffer device\n", info->node, info->fix.id); return 0; fballoced: framebuffer_release(info); none: return ret; }
void mtk_fbdev_destroy(struct drm_device *dev) { struct mtk_drm_private *priv = (struct mtk_drm_private *)dev->dev_private; struct drm_fb_helper *fbdev = priv->fb_helper; struct fb_info *info = priv->fb_helper->fbdev; if (info) { int err; err = unregister_framebuffer(info); if (err < 0) DRM_DEBUG_KMS("failed to unregister framebuffer\n"); if (info->cmap.len) fb_dealloc_cmap(&info->cmap); framebuffer_release(info); } if (fbdev->fb) { drm_framebuffer_unregister_private(fbdev->fb); mtk_drm_fb_destroy(fbdev->fb); } drm_fb_helper_fini(fbdev); kfree(fbdev); }
static int cobalt_lcdfb_probe(struct platform_device *dev) { struct fb_info *info; struct resource *res; int retval; info = framebuffer_alloc(0, &dev->dev); if (!info) return -ENOMEM; res = platform_get_resource(dev, IORESOURCE_MEM, 0); if (!res) { framebuffer_release(info); return -EBUSY; } info->screen_size = resource_size(res); info->screen_base = devm_ioremap(&dev->dev, res->start, info->screen_size); if (!info->screen_base) { framebuffer_release(info); return -ENOMEM; } info->fbops = &cobalt_lcd_fbops; info->fix = cobalt_lcdfb_fix; info->fix.smem_start = res->start; info->fix.smem_len = info->screen_size; info->pseudo_palette = NULL; info->par = NULL; info->flags = FBINFO_DEFAULT; retval = register_framebuffer(info); if (retval < 0) { framebuffer_release(info); return retval; } platform_set_drvdata(dev, info); lcd_clear(info); fb_info(info, "Cobalt server LCD frame buffer device\n"); return 0; }
int s3cfb_alloc_framebuffer(struct s3cfb_global *fbdev, int fimd_id) { struct s3c_platform_fb *pdata = to_fb_plat(fbdev->dev); int ret = 0; int i; fbdev->fb = kmalloc(pdata->nr_wins * sizeof(struct fb_info *), GFP_KERNEL); if (!fbdev->fb) { dev_err(fbdev->dev, "not enough memory\n"); ret = -ENOMEM; goto err_alloc; } for (i = 0; i < pdata->nr_wins; i++) { fbdev->fb[i] = framebuffer_alloc(sizeof(struct s3cfb_window), fbdev->dev); if (!fbdev->fb[i]) { dev_err(fbdev->dev, "not enough memory\n"); ret = -ENOMEM; goto err_alloc_fb; } ret = s3cfb_init_fbinfo(fbdev, i); if (ret) { dev_err(fbdev->dev, "failed to allocate memory for fb%d\n", i); ret = -ENOMEM; goto err_alloc_fb; } if (i == pdata->default_win) if (s3cfb_map_default_video_memory(fbdev, fbdev->fb[i], fimd_id)) { dev_err(fbdev->dev, "failed to map video memory " "for default window (%d)\n", i); ret = -ENOMEM; goto err_alloc_fb; } sec_getlog_supply_fbinfo((void *)fbdev->fb[i]->fix.smem_start, fbdev->fb[i]->var.xres, fbdev->fb[i]->var.yres, fbdev->fb[i]->var.bits_per_pixel, 2); } return 0; err_alloc_fb: for (i = 0; i < pdata->nr_wins; i++) { if (fbdev->fb[i]) framebuffer_release(fbdev->fb[i]); } kfree(fbdev->fb); err_alloc: return ret; }
static int simplefb_remove(struct platform_device *pdev) { struct fb_info *info = platform_get_drvdata(pdev); unregister_framebuffer(info); framebuffer_release(info); return 0; }
/** * s3c_fb_release_win() - release resources for a framebuffer window. * @win: The window to cleanup the resources for. * * Release the resources that where claimed for the hardware window, * such as the framebuffer instance and any memory claimed for it. */ static void s3c_fb_release_win(struct s3c_fb *sfb, struct s3c_fb_win *win) { if (win->fbinfo) { unregister_framebuffer(win->fbinfo); fb_dealloc_cmap(&win->fbinfo->cmap); s3c_fb_free_memory(sfb, win); framebuffer_release(win->fbinfo); } }
static int s3cfb_alloc_framebuffer(void) { struct s3c_platform_fb *pdata = to_fb_plat(fbdev->dev); int ret, i; /* alloc for framebuffers */ fbdev->fb = kmalloc(pdata->nr_wins * sizeof(struct fb_info *), GFP_KERNEL); if (!fbdev->fb) { dev_err(fbdev->dev, "not enough memory\n"); ret = -ENOMEM; goto err_alloc; } /* alloc for each framebuffer */ for (i = 0; i < pdata->nr_wins; i++) { fbdev->fb[i] = framebuffer_alloc(sizeof(struct s3cfb_window), fbdev->dev); if (!fbdev->fb[i]) { dev_err(fbdev->dev, "not enough memory\n"); ret = -ENOMEM; goto err_alloc_fb; } ret = s3cfb_init_fbinfo(i); if (ret) { dev_err(fbdev->dev, "failed to allocate memory for fb%d\n", i); ret = -ENOMEM; goto err_alloc_fb; } if (i == pdata->default_win) { if (s3cfb_map_default_video_memory(fbdev->fb[i])) { dev_err(fbdev->dev, "failed to map video memory " "for default window (%d)\n", i); ret = -ENOMEM; goto err_alloc_fb; } } } return 0; err_alloc_fb: for (i = 0; i < pdata->nr_wins; i++) { if (fbdev->fb[i]) framebuffer_release(fbdev->fb[i]); } kfree(fbdev->fb); err_alloc: return ret; }
int s5ptvfb_free_framebuffer(void) { if (g_s5ptv_status.fb) { #ifndef CONFIG_USER_ALLOC_TVOUT s5ptvfb_unmap_video_memory(g_s5ptv_status.fb); #endif framebuffer_release(g_s5ptv_status.fb); } return 0; }
static int cfag12864bfb_remove(struct platform_device *device) { struct fb_info *info = platform_get_drvdata(device); if (info) { unregister_framebuffer(info); framebuffer_release(info); } return 0; }
static int __init q40fb_probe(struct device *device) { struct platform_device *dev = to_platform_device(device); struct fb_info *info; if (!MACH_IS_Q40) return -ENXIO; /* mapped in q40/config.c */ q40fb_fix.smem_start = Q40_PHYS_SCREEN_ADDR; info = framebuffer_alloc(sizeof(u32) * 256, &dev->dev); if (!info) return -ENOMEM; info->var = q40fb_var; info->fix = q40fb_fix; info->fbops = &q40fb_ops; info->flags = FBINFO_FLAG_DEFAULT; /* not as module for now */ info->pseudo_palette = info->par; info->par = NULL; info->screen_base = (char *) q40fb_fix.smem_start; if (fb_alloc_cmap(&info->cmap, 256, 0) < 0) { framebuffer_release(info); return -ENOMEM; } master_outb(3, DISPLAY_CONTROL_REG); if (register_framebuffer(info) < 0) { printk(KERN_ERR "Unable to register Q40 frame buffer\n"); fb_dealloc_cmap(&info->cmap); framebuffer_release(info); return -EINVAL; } printk(KERN_INFO "fb%d: Q40 frame buffer alive and kicking !\n", info->node); return 0; }
int s5ptvfb_free_framebuffer(void) { #ifndef CONFIG_USER_ALLOC_TVOUT if (s5ptv_status.fb) s5ptvfb_unmap_video_memory(s5ptv_status.fb); #endif if (s5ptv_status.fb) framebuffer_release(s5ptv_status.fb); return 0; }
static int ws_eink_spi_remove(struct spi_device *spi) { struct fb_info *p = spi_get_drvdata(spi); struct ws_eink_fb_par *par = p->par; fb_deferred_io_cleanup(p); unregister_framebuffer(p); vfree(p->screen_base); vfree(par->ssbuf); framebuffer_release(p); return 0; }