int evdi_fbdev_init(struct drm_device *dev)
{
struct evdi_device *evdi = dev->dev_private;
struct evdi_fbdev *ufbdev;
int ret;
ufbdev = kzalloc(sizeof(struct evdi_fbdev), GFP_KERNEL);
if (!ufbdev) {
return -ENOMEM;
}
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,17,0)
drm_fb_helper_prepare(dev, &ufbdev->helper, &evdi_fb_helper_funcs);
#else
evdi->fbdev = ufbdev;
ufbdev->helper.funcs = &evdi_fb_helper_funcs;
#endif
ret = drm_fb_helper_init(dev, &ufbdev->helper, 1, 1);
if (ret) {
kfree(ufbdev);
return ret;
}
drm_fb_helper_single_add_all_connectors(&ufbdev->helper);
/* disable all the possible outputs/crtcs before entering KMS mode */
drm_helper_disable_unused_functions(dev);
drm_fb_helper_initial_config(&ufbdev->helper, 32);
return 0;
}
int bochs_fbdev_init(struct bochs_device *bochs)
{
int ret;
drm_fb_helper_prepare(bochs->dev, &bochs->fb.helper,
&bochs_fb_helper_funcs);
ret = drm_fb_helper_init(bochs->dev, &bochs->fb.helper,
1, 1);
if (ret)
return ret;
ret = drm_fb_helper_single_add_all_connectors(&bochs->fb.helper);
if (ret)
goto fini;
drm_helper_disable_unused_functions(bochs->dev);
ret = drm_fb_helper_initial_config(&bochs->fb.helper, 32);
if (ret)
goto fini;
bochs->fb.initialized = true;
return 0;
fini:
drm_fb_helper_fini(&bochs->fb.helper);
return ret;
}
static struct hisi_drm_fbdev *hisi_drm_fbdev_create(struct drm_device *dev,
unsigned int preferred_bpp, unsigned int num_crtc,
unsigned int max_conn_count)
{
struct hisi_drm_fbdev *fbdev;
struct drm_fb_helper *helper;
int ret;
DRM_DEBUG_DRIVER("enter, dev=%p, preferred_bpp=%d, num_crtc=%d .\n",
dev, preferred_bpp, num_crtc);
fbdev = kzalloc(sizeof(*fbdev), GFP_KERNEL);
if (!fbdev) {
dev_err(dev->dev, "Failed to allocate drm fbdev.\n");
return ERR_PTR(-ENOMEM);
}
helper = &fbdev->fb_helper;
drm_fb_helper_prepare(dev, helper, &hisi_fb_helper_funcs);
ret = drm_fb_helper_init(dev, helper, num_crtc, max_conn_count);
if (ret < 0) {
dev_err(dev->dev, "Failed to initialize drm fb helper.\n");
goto err_free;
}
ret = drm_fb_helper_single_add_all_connectors(helper);
if (ret < 0) {
dev_err(dev->dev, "Failed to add connectors.\n");
goto err_drm_fb_helper_fini;
}
/* disable all the possible outputs/crtcs before entering KMS mode */
drm_helper_disable_unused_functions(dev);
ret = drm_fb_helper_initial_config(helper, preferred_bpp);
if (ret < 0) {
dev_err(dev->dev, "Failed to set initial hw configuration.\n");
goto err_drm_fb_helper_fini;
}
DRM_DEBUG_DRIVER("exit successfully.\n");
return fbdev;
err_drm_fb_helper_fini:
drm_fb_helper_fini(helper);
err_free:
kfree(fbdev);
return ERR_PTR(ret);
}
int radeon_fbdev_init(struct radeon_device *rdev)
{
struct radeon_fbdev *rfbdev;
int bpp_sel = 32;
int ret;
/* don't enable fbdev if no connectors */
if (list_empty(&rdev->ddev->mode_config.connector_list))
return 0;
/* select 8 bpp console on 8MB cards, or 16 bpp on RN50 or 32MB */
if (rdev->mc.real_vram_size <= (8*1024*1024))
bpp_sel = 8;
else if (ASIC_IS_RN50(rdev) ||
rdev->mc.real_vram_size <= (32*1024*1024))
bpp_sel = 16;
rfbdev = kzalloc(sizeof(struct radeon_fbdev), GFP_KERNEL);
if (!rfbdev)
return -ENOMEM;
rfbdev->rdev = rdev;
rdev->mode_info.rfbdev = rfbdev;
drm_fb_helper_prepare(rdev->ddev, &rfbdev->helper,
&radeon_fb_helper_funcs);
ret = drm_fb_helper_init(rdev->ddev, &rfbdev->helper,
RADEONFB_CONN_LIMIT);
if (ret)
goto free;
ret = drm_fb_helper_single_add_all_connectors(&rfbdev->helper);
if (ret)
goto fini;
/* disable all the possible outputs/crtcs before entering KMS mode */
drm_helper_disable_unused_functions(rdev->ddev);
ret = drm_fb_helper_initial_config(&rfbdev->helper, bpp_sel);
if (ret)
goto fini;
return 0;
fini:
drm_fb_helper_fini(&rfbdev->helper);
free:
kfree(rfbdev);
return ret;
}
int amdgpu_fbdev_init(struct amdgpu_device *adev)
{
struct amdgpu_fbdev *rfbdev;
int bpp_sel = 32;
int ret;
/* don't init fbdev on hw without DCE */
if (!adev->mode_info.mode_config_initialized)
return 0;
/* don't init fbdev if there are no connectors */
if (list_empty(&adev->ddev->mode_config.connector_list))
return 0;
/* select 8 bpp console on low vram cards */
if (adev->gmc.real_vram_size <= (32*1024*1024))
bpp_sel = 8;
rfbdev = kzalloc(sizeof(struct amdgpu_fbdev), GFP_KERNEL);
if (!rfbdev)
return -ENOMEM;
rfbdev->adev = adev;
adev->mode_info.rfbdev = rfbdev;
drm_fb_helper_prepare(adev->ddev, &rfbdev->helper,
&amdgpu_fb_helper_funcs);
ret = drm_fb_helper_init(adev->ddev, &rfbdev->helper,
AMDGPUFB_CONN_LIMIT);
if (ret) {
kfree(rfbdev);
return ret;
}
drm_fb_helper_single_add_all_connectors(&rfbdev->helper);
/* disable all the possible outputs/crtcs before entering KMS mode */
if (!amdgpu_device_has_dc_support(adev))
drm_helper_disable_unused_functions(adev->ddev);
drm_fb_helper_initial_config(&rfbdev->helper, bpp_sel);
return 0;
}
int shmob_drm_modeset_init(struct shmob_drm_device *sdev)
{
drm_mode_config_init(sdev->ddev);
shmob_drm_crtc_create(sdev);
shmob_drm_encoder_create(sdev);
shmob_drm_connector_create(sdev, &sdev->encoder.encoder);
drm_kms_helper_poll_init(sdev->ddev);
sdev->ddev->mode_config.min_width = 0;
sdev->ddev->mode_config.min_height = 0;
sdev->ddev->mode_config.max_width = 4095;
sdev->ddev->mode_config.max_height = 4095;
sdev->ddev->mode_config.funcs = &shmob_drm_mode_config_funcs;
drm_helper_disable_unused_functions(sdev->ddev);
return 0;
}
int udl_fbdev_init(struct drm_device *dev)
{
struct udl_device *udl = dev->dev_private;
int bpp_sel = fb_bpp;
struct udl_fbdev *ufbdev;
int ret;
ufbdev = kzalloc(sizeof(struct udl_fbdev), GFP_KERNEL);
if (!ufbdev)
return -ENOMEM;
udl->fbdev = ufbdev;
drm_fb_helper_prepare(dev, &ufbdev->helper, &udl_fb_helper_funcs);
ret = drm_fb_helper_init(dev, &ufbdev->helper,
1, 1);
if (ret)
goto free;
ret = drm_fb_helper_single_add_all_connectors(&ufbdev->helper);
if (ret)
goto fini;
/* disable all the possible outputs/crtcs before entering KMS mode */
drm_helper_disable_unused_functions(dev);
ret = drm_fb_helper_initial_config(&ufbdev->helper, bpp_sel);
if (ret)
goto fini;
return 0;
fini:
drm_fb_helper_fini(&ufbdev->helper);
free:
kfree(ufbdev);
return ret;
}
int radeon_fbdev_init(struct radeon_device *rdev)
{
struct radeon_fbdev *rfbdev;
int bpp_sel = 32;
int ret;
/* select 8 bpp console on RN50 or 16MB cards */
if (ASIC_IS_RN50(rdev) || rdev->mc.real_vram_size <= (32*1024*1024))
bpp_sel = 8;
rfbdev = kzalloc(sizeof(struct radeon_fbdev), GFP_KERNEL);
if (!rfbdev)
return -ENOMEM;
rfbdev->rdev = rdev;
rdev->mode_info.rfbdev = rfbdev;
drm_fb_helper_prepare(rdev->ddev, &rfbdev->helper,
&radeon_fb_helper_funcs);
ret = drm_fb_helper_init(rdev->ddev, &rfbdev->helper,
rdev->num_crtc,
RADEONFB_CONN_LIMIT);
if (ret) {
kfree(rfbdev);
return ret;
}
drm_fb_helper_single_add_all_connectors(&rfbdev->helper);
/* disable all the possible outputs/crtcs before entering KMS mode */
drm_helper_disable_unused_functions(rdev->ddev);
drm_fb_helper_initial_config(&rfbdev->helper, bpp_sel);
return 0;
}
static int xylon_drm_load(struct drm_device *dev, unsigned long flags)
{
struct platform_device *pdev = dev->platformdev;
struct xylon_drm_device *xdev;
unsigned int bpp;
int ret;
xdev = devm_kzalloc(dev->dev, sizeof(*xdev), GFP_KERNEL);
if (!xdev)
return -ENOMEM;
xdev->dev = dev;
dev->dev_private = xdev;
drm_mode_config_init(dev);
drm_kms_helper_poll_init(dev);
xdev->crtc = xylon_drm_crtc_create(dev);
if (IS_ERR(xdev->crtc)) {
DRM_ERROR("failed create xylon crtc\n");
ret = PTR_ERR(xdev->crtc);
goto err_out;
}
xylon_drm_mode_config_init(dev);
xdev->encoder = xylon_drm_encoder_create(dev);
if (IS_ERR(xdev->encoder)) {
DRM_ERROR("failed create xylon encoder\n");
ret = PTR_ERR(xdev->encoder);
goto err_out;
}
xdev->connector = xylon_drm_connector_create(dev, xdev->encoder);
if (IS_ERR(xdev->connector)) {
DRM_ERROR("failed create xylon connector\n");
ret = PTR_ERR(xdev->connector);
goto err_out;
}
ret = drm_vblank_init(dev, 1);
if (ret) {
DRM_ERROR("failed initialize vblank\n");
goto err_out;
}
dev->vblank_disable_allowed = 1;
ret = xylon_drm_irq_install(dev);
if (ret < 0) {
DRM_ERROR("failed install irq\n");
goto err_irq;
}
ret = xylon_drm_crtc_get_param(xdev->crtc, &bpp,
XYLON_DRM_CRTC_BUFF_BPP);
if (ret) {
DRM_ERROR("failed get bpp\n");
goto err_fbdev;
}
xdev->fbdev = xylon_drm_fbdev_init(dev, bpp, 1, 1);
if (IS_ERR(xdev->fbdev)) {
DRM_ERROR("failed initialize fbdev\n");
ret = PTR_ERR(xdev->fbdev);
goto err_fbdev;
}
drm_helper_disable_unused_functions(dev);
platform_set_drvdata(pdev, xdev);
return 0;
err_fbdev:
xylon_drm_irq_uninstall(dev);
err_irq:
drm_vblank_cleanup(dev);
err_out:
drm_mode_config_cleanup(dev);
if (ret == -EPROBE_DEFER)
DRM_INFO("driver load deferred, will be called again\n");
return ret;
}