// SPDX-License-Identifier: GPL-2.0-only

#include <linux/aperture.h>
#include <linux/coreboot.h>
#include <linux/minmax.h>
#include <linux/platform_device.h>
#include <linux/pm.h>

#include <drm/clients/drm_client_setup.h>
#include <drm/drm_atomic.h>
#include <drm/drm_atomic_state_helper.h>
#include <drm/drm_connector.h>
#include <drm/drm_damage_helper.h>
#include <drm/drm_device.h>
#include <drm/drm_drv.h>
#include <drm/drm_fbdev_shmem.h>
#include <drm/drm_framebuffer.h>
#include <drm/drm_gem_atomic_helper.h>
#include <drm/drm_gem_framebuffer_helper.h>
#include <drm/drm_gem_shmem_helper.h>
#include <drm/drm_managed.h>
#include <drm/drm_modeset_helper.h>
#include <drm/drm_modeset_helper_vtables.h>
#include <drm/drm_print.h>
#include <drm/drm_probe_helper.h>

#include "drm_sysfb_helper.h"

#define DRIVER_NAME     "corebootdrm"
#define DRIVER_DESC     "DRM driver for Coreboot framebuffers"
#define DRIVER_MAJOR    1
#define DRIVER_MINOR    0

static const struct drm_format_info *
corebootdrm_get_format_fb(struct drm_device *dev, const struct lb_framebuffer *fb)
{
        static const struct drm_sysfb_format formats[] = {
                { PIXEL_FORMAT_XRGB1555, DRM_FORMAT_XRGB1555, },
                { PIXEL_FORMAT_RGB565, DRM_FORMAT_RGB565, },
                { PIXEL_FORMAT_RGB888, DRM_FORMAT_RGB888, },
                { PIXEL_FORMAT_XRGB8888, DRM_FORMAT_XRGB8888, },
                { PIXEL_FORMAT_XBGR8888, DRM_FORMAT_XBGR8888, },
                { PIXEL_FORMAT_XRGB2101010, DRM_FORMAT_XRGB2101010, },
        };
        const struct pixel_format pixel = {
                .bits_per_pixel = fb->bits_per_pixel,
                .indexed  = false,
                .alpha = {
                        .offset = 0,
                        .length = 0,
                },
                .red = {
                        .offset = fb->red_mask_pos,
                        .length = fb->red_mask_size,
                },
                .green = {
                        .offset = fb->green_mask_pos,
                        .length = fb->green_mask_size,
                },
                .blue = {
                        .offset = fb->blue_mask_pos,
                        .length = fb->blue_mask_size,
                },
        };

        return drm_sysfb_get_format(dev, formats, ARRAY_SIZE(formats), &pixel);
}

static int corebootdrm_get_width_fb(struct drm_device *dev, const struct lb_framebuffer *fb)
{
        return drm_sysfb_get_validated_int0(dev, "width", fb->x_resolution, INT_MAX);
}

static int corebootdrm_get_height_fb(struct drm_device *dev, const struct lb_framebuffer *fb)
{
        return drm_sysfb_get_validated_int0(dev, "height", fb->y_resolution, INT_MAX);
}

static int corebootdrm_get_pitch_fb(struct drm_device *dev, const struct drm_format_info *format,
                                    unsigned int width, const struct lb_framebuffer *fb)
{
        u64 bytes_per_line = fb->bytes_per_line;

        if (!bytes_per_line)
                bytes_per_line = drm_format_info_min_pitch(format, 0, width);

        return drm_sysfb_get_validated_int0(dev, "pitch", bytes_per_line, INT_MAX);
}

static resource_size_t corebootdrm_get_size_fb(struct drm_device *dev, unsigned int height,
                                               unsigned int pitch,
                                               const struct lb_framebuffer *fb)
{
        resource_size_t size;

        if (check_mul_overflow(height, pitch, &size))
                return 0;

        return size;
}

static phys_addr_t corebootdrm_get_address_fb(struct drm_device *dev, resource_size_t size,
                                              const struct lb_framebuffer *fb)
{
        if (size > PHYS_ADDR_MAX)
                return 0;
        if (!fb->physical_address)
                return 0;
        if (fb->physical_address > (PHYS_ADDR_MAX - size))
                return 0;

        return fb->physical_address;
}

static enum drm_panel_orientation corebootdrm_get_orientation_fb(struct drm_device *dev,
                                                                 const struct lb_framebuffer *fb)
{
        if (!LB_FRAMEBUFFER_HAS_ORIENTATION(fb))
                return DRM_MODE_PANEL_ORIENTATION_UNKNOWN;

        switch (fb->orientation) {
        case LB_FRAMEBUFFER_ORIENTATION_NORMAL:
                return DRM_MODE_PANEL_ORIENTATION_NORMAL;
        case LB_FRAMEBUFFER_ORIENTATION_BOTTOM_UP:
                return DRM_MODE_PANEL_ORIENTATION_BOTTOM_UP;
        case LB_FRAMEBUFFER_ORIENTATION_LEFT_UP:
                return DRM_MODE_PANEL_ORIENTATION_LEFT_UP;
        case LB_FRAMEBUFFER_ORIENTATION_RIGHT_UP:
                return DRM_MODE_PANEL_ORIENTATION_RIGHT_UP;
        }

        return DRM_MODE_PANEL_ORIENTATION_UNKNOWN;
}

/*
 * Simple Framebuffer device
 */

struct corebootdrm_device {
        struct drm_sysfb_device sysfb;

        /* modesetting */
        u32 formats[DRM_SYSFB_PLANE_NFORMATS(1)];
        struct drm_plane primary_plane;
        struct drm_crtc crtc;
        struct drm_encoder encoder;
        struct drm_connector connector;
};

/*
 * Modesetting
 */

static const u64 corebootdrm_primary_plane_format_modifiers[] = {
        DRM_SYSFB_PLANE_FORMAT_MODIFIERS,
};

static const struct drm_plane_helper_funcs corebootdrm_primary_plane_helper_funcs = {
        DRM_SYSFB_PLANE_HELPER_FUNCS,
};

static const struct drm_plane_funcs corebootdrm_primary_plane_funcs = {
        DRM_SYSFB_PLANE_FUNCS,
        .destroy = drm_plane_cleanup,
};

static const struct drm_crtc_helper_funcs corebootdrm_crtc_helper_funcs = {
        DRM_SYSFB_CRTC_HELPER_FUNCS,
};

static const struct drm_crtc_funcs corebootdrm_crtc_funcs = {
        DRM_SYSFB_CRTC_FUNCS,
        .destroy = drm_crtc_cleanup,
};

static const struct drm_encoder_funcs corebootdrm_encoder_funcs = {
        .destroy = drm_encoder_cleanup,
};

static const struct drm_connector_helper_funcs corebootdrm_connector_helper_funcs = {
        DRM_SYSFB_CONNECTOR_HELPER_FUNCS,
};

static const struct drm_connector_funcs corebootdrm_connector_funcs = {
        DRM_SYSFB_CONNECTOR_FUNCS,
        .destroy = drm_connector_cleanup,
};

static const struct drm_mode_config_funcs corebootdrm_mode_config_funcs = {
        DRM_SYSFB_MODE_CONFIG_FUNCS,
};

static int corebootdrm_mode_config_init(struct corebootdrm_device *cdev,
                                        enum drm_panel_orientation orientation)
{
        struct drm_sysfb_device *sysfb = &cdev->sysfb;
        struct drm_device *dev = &sysfb->dev;
        const struct drm_format_info *format = sysfb->fb_format;
        unsigned int width = sysfb->fb_mode.hdisplay;
        unsigned int height = sysfb->fb_mode.vdisplay;
        struct drm_plane *primary_plane;
        struct drm_crtc *crtc;
        struct drm_encoder *encoder;
        struct drm_connector *connector;
        size_t nformats;
        int ret;

        ret = drmm_mode_config_init(dev);
        if (ret)
                return ret;

        dev->mode_config.min_width = width;
        dev->mode_config.max_width = max_t(unsigned int, width, DRM_SHADOW_PLANE_MAX_WIDTH);
        dev->mode_config.min_height = height;
        dev->mode_config.max_height = max_t(unsigned int, height, DRM_SHADOW_PLANE_MAX_HEIGHT);
        dev->mode_config.funcs = &corebootdrm_mode_config_funcs;
        dev->mode_config.preferred_depth = format->depth;

        /* Primary plane */

        nformats = drm_sysfb_build_fourcc_list(dev, &format->format, 1,
                                               cdev->formats, ARRAY_SIZE(cdev->formats));

        primary_plane = &cdev->primary_plane;
        ret = drm_universal_plane_init(dev, primary_plane, 0, &corebootdrm_primary_plane_funcs,
                                       cdev->formats, nformats,
                                       corebootdrm_primary_plane_format_modifiers,
                                       DRM_PLANE_TYPE_PRIMARY, NULL);
        if (ret)
                return ret;
        drm_plane_helper_add(primary_plane, &corebootdrm_primary_plane_helper_funcs);
        drm_plane_enable_fb_damage_clips(primary_plane);

        /* CRTC */

        crtc = &cdev->crtc;
        ret = drm_crtc_init_with_planes(dev, crtc, primary_plane, NULL,
                                        &corebootdrm_crtc_funcs, NULL);
        if (ret)
                return ret;
        drm_crtc_helper_add(crtc, &corebootdrm_crtc_helper_funcs);

        /* Encoder */

        encoder = &cdev->encoder;
        ret = drm_encoder_init(dev, encoder, &corebootdrm_encoder_funcs,
                               DRM_MODE_ENCODER_NONE, NULL);
        if (ret)
                return ret;
        encoder->possible_crtcs = drm_crtc_mask(crtc);

        /* Connector */

        connector = &cdev->connector;
        ret = drm_connector_init(dev, connector, &corebootdrm_connector_funcs,
                                 DRM_MODE_CONNECTOR_Unknown);
        if (ret)
                return ret;
        drm_connector_helper_add(connector, &corebootdrm_connector_helper_funcs);
        drm_connector_set_panel_orientation_with_quirk(connector, orientation,
                                                       width, height);

        ret = drm_connector_attach_encoder(connector, encoder);
        if (ret)
                return ret;

        return 0;
}

/*
 * DRM driver
 */

DEFINE_DRM_GEM_FOPS(corebootdrm_fops);

static struct drm_driver corebootdrm_drm_driver = {
        DRM_GEM_SHMEM_DRIVER_OPS,
        DRM_FBDEV_SHMEM_DRIVER_OPS,
        .name                   = DRIVER_NAME,
        .desc                   = DRIVER_DESC,
        .major                  = DRIVER_MAJOR,
        .minor                  = DRIVER_MINOR,
        .driver_features        = DRIVER_ATOMIC | DRIVER_GEM | DRIVER_MODESET,
        .fops                   = &corebootdrm_fops,
};

/*
 * Coreboot driver
 */

static int corebootdrm_pm_suspend(struct device *dev)
{
        struct corebootdrm_device *cdev = dev_get_drvdata(dev);
        struct drm_device *drm = &cdev->sysfb.dev;

        return drm_mode_config_helper_suspend(drm);
}

static int corebootdrm_pm_resume(struct device *dev)
{
        struct corebootdrm_device *cdev = dev_get_drvdata(dev);
        struct drm_device *drm = &cdev->sysfb.dev;

        return drm_mode_config_helper_resume(drm);
}

static DEFINE_SIMPLE_DEV_PM_OPS(corebootdrm_pm_ops, corebootdrm_pm_suspend, corebootdrm_pm_resume);

static int corebootdrm_probe(struct platform_device *pdev)
{
        const struct lb_framebuffer *fb = dev_get_platdata(&pdev->dev);
        struct corebootdrm_device *cdev;
        struct drm_sysfb_device *sysfb;
        struct drm_device *dev;
        const struct drm_format_info *format;
        int width, height, pitch;
        resource_size_t size;
        phys_addr_t address;
        enum drm_panel_orientation orientation;
        struct resource *res, *mem = NULL;
        struct resource aperture;
        void __iomem *screen_base;
        int ret;

        cdev = devm_drm_dev_alloc(&pdev->dev, &corebootdrm_drm_driver,
                                  struct corebootdrm_device, sysfb.dev);
        if (IS_ERR(cdev))
                return PTR_ERR(cdev);
        platform_set_drvdata(pdev, cdev);

        sysfb = &cdev->sysfb;
        dev = &sysfb->dev;

        if (!fb) {
                drm_err(dev, "coreboot framebuffer not found\n");
                return -EINVAL;
        } else if (!LB_FRAMEBUFFER_HAS_LFB(fb)) {
                drm_err(dev, "coreboot framebuffer entry too small\n");
                return -EINVAL;
        }

        /*
         * Hardware settings
         */

        format = corebootdrm_get_format_fb(dev, fb);
        if (!format)
                return -EINVAL;
        width = corebootdrm_get_width_fb(dev, fb);
        if (width < 0)
                return width;
        height = corebootdrm_get_height_fb(dev, fb);
        if (height < 0)
                return height;
        pitch = corebootdrm_get_pitch_fb(dev, format, width, fb);
        if (pitch < 0)
                return pitch;
        size = corebootdrm_get_size_fb(dev, height, pitch, fb);
        if (!size)
                return -EINVAL;
        address = corebootdrm_get_address_fb(dev, size, fb);
        if (!address)
                return -EINVAL;
        orientation = corebootdrm_get_orientation_fb(dev, fb);

        sysfb->fb_mode = drm_sysfb_mode(width, height, 0, 0);
        sysfb->fb_format = format;
        sysfb->fb_pitch = pitch;

        drm_dbg(dev, "display mode={" DRM_MODE_FMT "}\n", DRM_MODE_ARG(&sysfb->fb_mode));
        drm_dbg(dev, "framebuffer format=%p4cc, size=%dx%d, pitch=%d byte\n",
                &format->format, width, height, pitch);

        /*
         * Memory management
         */

        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        if (!res) {
                drm_err(dev, "memory resource not found\n");
                return -EINVAL;
        }

        mem = devm_request_mem_region(&pdev->dev, res->start, resource_size(res),
                                      dev->driver->name);
        if (!mem) {
                drm_warn(dev, "could not acquire memory resource at %pr\n", res);
                /*
                 * We cannot make this fatal. Sometimes this comes from magic
                 * spaces our resource handlers simply don't know about. Use
                 * the memory resource as-is and try to map that instead.
                 */
                mem = res;
        }

        drm_dbg(dev, "using memory resource at %pr\n", mem);

        aperture = DEFINE_RES_MEM(address, size);
        if (!resource_contains(mem, &aperture)) {
                drm_err(dev, "framebuffer aperture at invalid memory range %pr\n", &aperture);
                return -EINVAL;
        }

        ret = devm_aperture_acquire_for_platform_device(pdev, address, size);
        if (ret) {
                drm_err(dev, "could not acquire framebuffer aperture: %d\n", ret);
                return ret;
        }

        screen_base = devm_ioremap_wc(&pdev->dev, address, size);
        if (!screen_base)
                return -ENOMEM;

        iosys_map_set_vaddr_iomem(&sysfb->fb_addr, screen_base);

        /*
         * DRM mode setting and registration
         */

        ret = corebootdrm_mode_config_init(cdev, orientation);
        if (ret)
                return ret;

        drm_mode_config_reset(dev);

        ret = drm_dev_register(dev, 0);
        if (ret)
                return ret;

        drm_client_setup(dev, sysfb->fb_format);

        return 0;
}

static void corebootdrm_remove(struct platform_device *pdev)
{
        struct corebootdrm_device *cdev = platform_get_drvdata(pdev);
        struct drm_device *dev = &cdev->sysfb.dev;

        drm_dev_unplug(dev);
}

static struct platform_driver corebootdrm_platform_driver = {
        .driver = {
                .name = "coreboot-framebuffer",
                .pm = pm_sleep_ptr(&corebootdrm_pm_ops),
        },
        .probe = corebootdrm_probe,
        .remove = corebootdrm_remove,
};

module_platform_driver(corebootdrm_platform_driver);

MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE("GPL");