mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-23 17:30:02 +00:00
![Daniel Vetter](/assets/img/avatar_default.png)
-----BEGIN PGP SIGNATURE----- iQFSBAABCAA8FiEEq68RxlopcLEwq+PEeb4+QwBBGIYFAmPW7E8eHHRvcnZhbGRz QGxpbnV4LWZvdW5kYXRpb24ub3JnAAoJEHm+PkMAQRiGf7MIAI0JnHN9WvtEukSZ E6j6+cEGWxsvD6q0g3GPolaKOCw7hlv0pWcFJFcUAt0jebspMdxV2oUGJ8RYW7Lg nCcHvEVswGKLAQtQSWw52qotW6fUfMPsNYYB5l31sm1sKH4Cgss0W7l2HxO/1LvG TSeNHX53vNAZ8pVnFYEWCSXC9bzrmU/VALF2EV00cdICmfvjlgkELGXoLKJJWzUp s63fBHYGGURSgwIWOKStoO6HNo0j/F/wcSMx8leY8qDUtVKHj4v24EvSgxUSDBER ch3LiSQ6qf4sw/z7pqruKFthKOrlNmcc0phjiES0xwwGiNhLv0z3rAhc4OM2cgYh SDc/Y/c= =zpaD -----END PGP SIGNATURE----- Merge v6.2-rc6 into drm-next Due to holidays we started -next with more -fixes in-flight than usual, and people have been asking where they are. Backmerge to get things better in sync. Conflicts: - Tiny conflict in drm_fbdev_generic.c between variable rename and missing error handling that got added. - Conflict in drm_fb_helper.c between the added call to vgaswitcheroo in drm_fb_helper_single_fb_probe and a refactor patch that extracted lots of helpers and incidentally removed the dev local variable. Readd it to make things compile. Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
461 lines
12 KiB
C
461 lines
12 KiB
C
// SPDX-License-Identifier: MIT
|
|
|
|
#include <linux/moduleparam.h>
|
|
#include <linux/vmalloc.h>
|
|
|
|
#include <drm/drm_crtc_helper.h>
|
|
#include <drm/drm_drv.h>
|
|
#include <drm/drm_fb_helper.h>
|
|
#include <drm/drm_framebuffer.h>
|
|
#include <drm/drm_print.h>
|
|
|
|
#include <drm/drm_fbdev_generic.h>
|
|
|
|
static bool drm_fbdev_use_shadow_fb(struct drm_fb_helper *fb_helper)
|
|
{
|
|
struct drm_device *dev = fb_helper->dev;
|
|
struct drm_framebuffer *fb = fb_helper->fb;
|
|
|
|
return dev->mode_config.prefer_shadow_fbdev ||
|
|
dev->mode_config.prefer_shadow ||
|
|
fb->funcs->dirty;
|
|
}
|
|
|
|
/* @user: 1=userspace, 0=fbcon */
|
|
static int drm_fbdev_fb_open(struct fb_info *info, int user)
|
|
{
|
|
struct drm_fb_helper *fb_helper = info->par;
|
|
|
|
/* No need to take a ref for fbcon because it unbinds on unregister */
|
|
if (user && !try_module_get(fb_helper->dev->driver->fops->owner))
|
|
return -ENODEV;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int drm_fbdev_fb_release(struct fb_info *info, int user)
|
|
{
|
|
struct drm_fb_helper *fb_helper = info->par;
|
|
|
|
if (user)
|
|
module_put(fb_helper->dev->driver->fops->owner);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void drm_fbdev_fb_destroy(struct fb_info *info)
|
|
{
|
|
struct drm_fb_helper *fb_helper = info->par;
|
|
void *shadow = NULL;
|
|
|
|
if (!fb_helper->dev)
|
|
return;
|
|
|
|
if (info->fbdefio)
|
|
fb_deferred_io_cleanup(info);
|
|
if (drm_fbdev_use_shadow_fb(fb_helper))
|
|
shadow = info->screen_buffer;
|
|
|
|
drm_fb_helper_fini(fb_helper);
|
|
|
|
if (shadow)
|
|
vfree(shadow);
|
|
else if (fb_helper->buffer)
|
|
drm_client_buffer_vunmap(fb_helper->buffer);
|
|
|
|
drm_client_framebuffer_delete(fb_helper->buffer);
|
|
drm_client_release(&fb_helper->client);
|
|
kfree(fb_helper);
|
|
}
|
|
|
|
static int drm_fbdev_fb_mmap(struct fb_info *info, struct vm_area_struct *vma)
|
|
{
|
|
struct drm_fb_helper *fb_helper = info->par;
|
|
|
|
if (drm_fbdev_use_shadow_fb(fb_helper))
|
|
return fb_deferred_io_mmap(info, vma);
|
|
else if (fb_helper->dev->driver->gem_prime_mmap)
|
|
return fb_helper->dev->driver->gem_prime_mmap(fb_helper->buffer->gem, vma);
|
|
else
|
|
return -ENODEV;
|
|
}
|
|
|
|
static bool drm_fbdev_use_iomem(struct fb_info *info)
|
|
{
|
|
struct drm_fb_helper *fb_helper = info->par;
|
|
struct drm_client_buffer *buffer = fb_helper->buffer;
|
|
|
|
return !drm_fbdev_use_shadow_fb(fb_helper) && buffer->map.is_iomem;
|
|
}
|
|
|
|
static ssize_t drm_fbdev_fb_read(struct fb_info *info, char __user *buf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
ssize_t ret;
|
|
|
|
if (drm_fbdev_use_iomem(info))
|
|
ret = drm_fb_helper_cfb_read(info, buf, count, ppos);
|
|
else
|
|
ret = drm_fb_helper_sys_read(info, buf, count, ppos);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static ssize_t drm_fbdev_fb_write(struct fb_info *info, const char __user *buf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
ssize_t ret;
|
|
|
|
if (drm_fbdev_use_iomem(info))
|
|
ret = drm_fb_helper_cfb_write(info, buf, count, ppos);
|
|
else
|
|
ret = drm_fb_helper_sys_write(info, buf, count, ppos);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void drm_fbdev_fb_fillrect(struct fb_info *info,
|
|
const struct fb_fillrect *rect)
|
|
{
|
|
if (drm_fbdev_use_iomem(info))
|
|
drm_fb_helper_cfb_fillrect(info, rect);
|
|
else
|
|
drm_fb_helper_sys_fillrect(info, rect);
|
|
}
|
|
|
|
static void drm_fbdev_fb_copyarea(struct fb_info *info,
|
|
const struct fb_copyarea *area)
|
|
{
|
|
if (drm_fbdev_use_iomem(info))
|
|
drm_fb_helper_cfb_copyarea(info, area);
|
|
else
|
|
drm_fb_helper_sys_copyarea(info, area);
|
|
}
|
|
|
|
static void drm_fbdev_fb_imageblit(struct fb_info *info,
|
|
const struct fb_image *image)
|
|
{
|
|
if (drm_fbdev_use_iomem(info))
|
|
drm_fb_helper_cfb_imageblit(info, image);
|
|
else
|
|
drm_fb_helper_sys_imageblit(info, image);
|
|
}
|
|
|
|
static const struct fb_ops drm_fbdev_fb_ops = {
|
|
.owner = THIS_MODULE,
|
|
DRM_FB_HELPER_DEFAULT_OPS,
|
|
.fb_open = drm_fbdev_fb_open,
|
|
.fb_release = drm_fbdev_fb_release,
|
|
.fb_destroy = drm_fbdev_fb_destroy,
|
|
.fb_mmap = drm_fbdev_fb_mmap,
|
|
.fb_read = drm_fbdev_fb_read,
|
|
.fb_write = drm_fbdev_fb_write,
|
|
.fb_fillrect = drm_fbdev_fb_fillrect,
|
|
.fb_copyarea = drm_fbdev_fb_copyarea,
|
|
.fb_imageblit = drm_fbdev_fb_imageblit,
|
|
};
|
|
|
|
/*
|
|
* This function uses the client API to create a framebuffer backed by a dumb buffer.
|
|
*/
|
|
static int drm_fbdev_fb_probe(struct drm_fb_helper *fb_helper,
|
|
struct drm_fb_helper_surface_size *sizes)
|
|
{
|
|
struct drm_client_dev *client = &fb_helper->client;
|
|
struct drm_device *dev = fb_helper->dev;
|
|
struct drm_client_buffer *buffer;
|
|
struct drm_framebuffer *fb;
|
|
struct fb_info *info;
|
|
u32 format;
|
|
struct iosys_map map;
|
|
int ret;
|
|
|
|
drm_dbg_kms(dev, "surface width(%d), height(%d) and bpp(%d)\n",
|
|
sizes->surface_width, sizes->surface_height,
|
|
sizes->surface_bpp);
|
|
|
|
format = drm_mode_legacy_fb_format(sizes->surface_bpp, sizes->surface_depth);
|
|
buffer = drm_client_framebuffer_create(client, sizes->surface_width,
|
|
sizes->surface_height, format);
|
|
if (IS_ERR(buffer))
|
|
return PTR_ERR(buffer);
|
|
|
|
fb_helper->buffer = buffer;
|
|
fb_helper->fb = buffer->fb;
|
|
fb = buffer->fb;
|
|
|
|
info = drm_fb_helper_alloc_info(fb_helper);
|
|
if (IS_ERR(info))
|
|
return PTR_ERR(info);
|
|
|
|
info->fbops = &drm_fbdev_fb_ops;
|
|
info->screen_size = sizes->surface_height * fb->pitches[0];
|
|
info->fix.smem_len = info->screen_size;
|
|
info->flags = FBINFO_DEFAULT;
|
|
|
|
drm_fb_helper_fill_info(info, fb_helper, sizes);
|
|
|
|
if (drm_fbdev_use_shadow_fb(fb_helper)) {
|
|
info->screen_buffer = vzalloc(info->screen_size);
|
|
if (!info->screen_buffer)
|
|
return -ENOMEM;
|
|
info->flags |= FBINFO_VIRTFB | FBINFO_READS_FAST;
|
|
|
|
/* Set a default deferred I/O handler */
|
|
fb_helper->fbdefio.delay = HZ / 20;
|
|
fb_helper->fbdefio.deferred_io = drm_fb_helper_deferred_io;
|
|
|
|
info->fbdefio = &fb_helper->fbdefio;
|
|
ret = fb_deferred_io_init(info);
|
|
if (ret)
|
|
return ret;
|
|
} else {
|
|
/* buffer is mapped for HW framebuffer */
|
|
ret = drm_client_buffer_vmap(fb_helper->buffer, &map);
|
|
if (ret)
|
|
return ret;
|
|
if (map.is_iomem) {
|
|
info->screen_base = map.vaddr_iomem;
|
|
} else {
|
|
info->screen_buffer = map.vaddr;
|
|
info->flags |= FBINFO_VIRTFB;
|
|
}
|
|
|
|
/*
|
|
* Shamelessly leak the physical address to user-space. As
|
|
* page_to_phys() is undefined for I/O memory, warn in this
|
|
* case.
|
|
*/
|
|
#if IS_ENABLED(CONFIG_DRM_FBDEV_LEAK_PHYS_SMEM)
|
|
if (fb_helper->hint_leak_smem_start && info->fix.smem_start == 0 &&
|
|
!drm_WARN_ON_ONCE(dev, map.is_iomem))
|
|
info->fix.smem_start =
|
|
page_to_phys(virt_to_page(info->screen_buffer));
|
|
#endif
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void drm_fbdev_damage_blit_real(struct drm_fb_helper *fb_helper,
|
|
struct drm_clip_rect *clip,
|
|
struct iosys_map *dst)
|
|
{
|
|
struct drm_framebuffer *fb = fb_helper->fb;
|
|
size_t offset = clip->y1 * fb->pitches[0];
|
|
size_t len = clip->x2 - clip->x1;
|
|
unsigned int y;
|
|
void *src;
|
|
|
|
switch (drm_format_info_bpp(fb->format, 0)) {
|
|
case 1:
|
|
offset += clip->x1 / 8;
|
|
len = DIV_ROUND_UP(len + clip->x1 % 8, 8);
|
|
break;
|
|
case 2:
|
|
offset += clip->x1 / 4;
|
|
len = DIV_ROUND_UP(len + clip->x1 % 4, 4);
|
|
break;
|
|
case 4:
|
|
offset += clip->x1 / 2;
|
|
len = DIV_ROUND_UP(len + clip->x1 % 2, 2);
|
|
break;
|
|
default:
|
|
offset += clip->x1 * fb->format->cpp[0];
|
|
len *= fb->format->cpp[0];
|
|
break;
|
|
}
|
|
|
|
src = fb_helper->info->screen_buffer + offset;
|
|
iosys_map_incr(dst, offset); /* go to first pixel within clip rect */
|
|
|
|
for (y = clip->y1; y < clip->y2; y++) {
|
|
iosys_map_memcpy_to(dst, 0, src, len);
|
|
iosys_map_incr(dst, fb->pitches[0]);
|
|
src += fb->pitches[0];
|
|
}
|
|
}
|
|
|
|
static int drm_fbdev_damage_blit(struct drm_fb_helper *fb_helper,
|
|
struct drm_clip_rect *clip)
|
|
{
|
|
struct drm_client_buffer *buffer = fb_helper->buffer;
|
|
struct iosys_map map, dst;
|
|
int ret;
|
|
|
|
/*
|
|
* We have to pin the client buffer to its current location while
|
|
* flushing the shadow buffer. In the general case, concurrent
|
|
* modesetting operations could try to move the buffer and would
|
|
* fail. The modeset has to be serialized by acquiring the reservation
|
|
* object of the underlying BO here.
|
|
*
|
|
* For fbdev emulation, we only have to protect against fbdev modeset
|
|
* operations. Nothing else will involve the client buffer's BO. So it
|
|
* is sufficient to acquire struct drm_fb_helper.lock here.
|
|
*/
|
|
mutex_lock(&fb_helper->lock);
|
|
|
|
ret = drm_client_buffer_vmap(buffer, &map);
|
|
if (ret)
|
|
goto out;
|
|
|
|
dst = map;
|
|
drm_fbdev_damage_blit_real(fb_helper, clip, &dst);
|
|
|
|
drm_client_buffer_vunmap(buffer);
|
|
|
|
out:
|
|
mutex_unlock(&fb_helper->lock);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int drm_fbdev_fb_dirty(struct drm_fb_helper *helper, struct drm_clip_rect *clip)
|
|
{
|
|
struct drm_device *dev = helper->dev;
|
|
int ret;
|
|
|
|
if (!drm_fbdev_use_shadow_fb(helper))
|
|
return 0;
|
|
|
|
/* Call damage handlers only if necessary */
|
|
if (!(clip->x1 < clip->x2 && clip->y1 < clip->y2))
|
|
return 0;
|
|
|
|
if (helper->buffer) {
|
|
ret = drm_fbdev_damage_blit(helper, clip);
|
|
if (drm_WARN_ONCE(dev, ret, "Damage blitter failed: ret=%d\n", ret))
|
|
return ret;
|
|
}
|
|
|
|
if (helper->fb->funcs->dirty) {
|
|
ret = helper->fb->funcs->dirty(helper->fb, NULL, 0, 0, clip, 1);
|
|
if (drm_WARN_ONCE(dev, ret, "Dirty helper failed: ret=%d\n", ret))
|
|
return ret;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct drm_fb_helper_funcs drm_fb_helper_generic_funcs = {
|
|
.fb_probe = drm_fbdev_fb_probe,
|
|
.fb_dirty = drm_fbdev_fb_dirty,
|
|
};
|
|
|
|
static void drm_fbdev_client_unregister(struct drm_client_dev *client)
|
|
{
|
|
struct drm_fb_helper *fb_helper = drm_fb_helper_from_client(client);
|
|
|
|
if (fb_helper->info) {
|
|
drm_fb_helper_unregister_info(fb_helper);
|
|
} else {
|
|
drm_client_release(&fb_helper->client);
|
|
drm_fb_helper_unprepare(fb_helper);
|
|
kfree(fb_helper);
|
|
}
|
|
}
|
|
|
|
static int drm_fbdev_client_restore(struct drm_client_dev *client)
|
|
{
|
|
drm_fb_helper_lastclose(client->dev);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int drm_fbdev_client_hotplug(struct drm_client_dev *client)
|
|
{
|
|
struct drm_fb_helper *fb_helper = drm_fb_helper_from_client(client);
|
|
struct drm_device *dev = client->dev;
|
|
int ret;
|
|
|
|
if (dev->fb_helper)
|
|
return drm_fb_helper_hotplug_event(dev->fb_helper);
|
|
|
|
ret = drm_fb_helper_init(dev, fb_helper);
|
|
if (ret)
|
|
goto err_drm_err;
|
|
|
|
if (!drm_drv_uses_atomic_modeset(dev))
|
|
drm_helper_disable_unused_functions(dev);
|
|
|
|
ret = drm_fb_helper_initial_config(fb_helper);
|
|
if (ret)
|
|
goto err_drm_fb_helper_fini;
|
|
|
|
return 0;
|
|
|
|
err_drm_fb_helper_fini:
|
|
drm_fb_helper_fini(fb_helper);
|
|
err_drm_err:
|
|
drm_err(dev, "fbdev: Failed to setup generic emulation (ret=%d)\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
static const struct drm_client_funcs drm_fbdev_client_funcs = {
|
|
.owner = THIS_MODULE,
|
|
.unregister = drm_fbdev_client_unregister,
|
|
.restore = drm_fbdev_client_restore,
|
|
.hotplug = drm_fbdev_client_hotplug,
|
|
};
|
|
|
|
/**
|
|
* drm_fbdev_generic_setup() - Setup generic fbdev emulation
|
|
* @dev: DRM device
|
|
* @preferred_bpp: Preferred bits per pixel for the device.
|
|
*
|
|
* This function sets up generic fbdev emulation for drivers that supports
|
|
* dumb buffers with a virtual address and that can be mmap'ed.
|
|
* drm_fbdev_generic_setup() shall be called after the DRM driver registered
|
|
* the new DRM device with drm_dev_register().
|
|
*
|
|
* Restore, hotplug events and teardown are all taken care of. Drivers that do
|
|
* suspend/resume need to call drm_fb_helper_set_suspend_unlocked() themselves.
|
|
* Simple drivers might use drm_mode_config_helper_suspend().
|
|
*
|
|
* Drivers that set the dirty callback on their framebuffer will get a shadow
|
|
* fbdev buffer that is blitted onto the real buffer. This is done in order to
|
|
* make deferred I/O work with all kinds of buffers. A shadow buffer can be
|
|
* requested explicitly by setting struct drm_mode_config.prefer_shadow or
|
|
* struct drm_mode_config.prefer_shadow_fbdev to true beforehand. This is
|
|
* required to use generic fbdev emulation with SHMEM helpers.
|
|
*
|
|
* This function is safe to call even when there are no connectors present.
|
|
* Setup will be retried on the next hotplug event.
|
|
*
|
|
* The fbdev is destroyed by drm_dev_unregister().
|
|
*/
|
|
void drm_fbdev_generic_setup(struct drm_device *dev,
|
|
unsigned int preferred_bpp)
|
|
{
|
|
struct drm_fb_helper *fb_helper;
|
|
int ret;
|
|
|
|
drm_WARN(dev, !dev->registered, "Device has not been registered.\n");
|
|
drm_WARN(dev, dev->fb_helper, "fb_helper is already set!\n");
|
|
|
|
fb_helper = kzalloc(sizeof(*fb_helper), GFP_KERNEL);
|
|
if (!fb_helper)
|
|
return;
|
|
drm_fb_helper_prepare(dev, fb_helper, preferred_bpp, &drm_fb_helper_generic_funcs);
|
|
|
|
ret = drm_client_init(dev, &fb_helper->client, "fbdev", &drm_fbdev_client_funcs);
|
|
if (ret) {
|
|
drm_err(dev, "Failed to register client: %d\n", ret);
|
|
goto err_drm_client_init;
|
|
}
|
|
|
|
ret = drm_fbdev_client_hotplug(&fb_helper->client);
|
|
if (ret)
|
|
drm_dbg_kms(dev, "client hotplug ret=%d\n", ret);
|
|
|
|
drm_client_register(&fb_helper->client);
|
|
|
|
return;
|
|
|
|
err_drm_client_init:
|
|
drm_fb_helper_unprepare(fb_helper);
|
|
kfree(fb_helper);
|
|
return;
|
|
}
|
|
EXPORT_SYMBOL(drm_fbdev_generic_setup);
|