/**
 * 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);
}
Exemple #2
0
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;
}
Exemple #3
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);
}
Exemple #4
0
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;
}
Exemple #5
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;
}
Exemple #6
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);
}
Exemple #7
0
/*
 *  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;
}
Exemple #9
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;
}
Exemple #11
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;
	}

}
Exemple #12
0
Fichier : fb.c Projet : 3null/linux
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);
}
Exemple #13
0
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);
}
Exemple #15
0
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);
}
Exemple #16
0
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;
}
Exemple #17
0
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);
}
Exemple #20
0
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);
	}
}
Exemple #24
0
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;
}
Exemple #28
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;
}
Exemple #29
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;
}