// SPDX-License-Identifier: GPL-2.0-only
/*
 * linux/drivers/video/omap2/omapfb-sysfs.c
 *
 * Copyright (C) 2008 Nokia Corporation
 * Author: Tomi Valkeinen <tomi.valkeinen@nokia.com>
 *
 * Some code and ideas taken from drivers/video/omap/ driver
 * by Imre Deak.
 */

#include <linux/fb.h>
#include <linux/sysfs.h>
#include <linux/device.h>
#include <linux/uaccess.h>
#include <linux/platform_device.h>
#include <linux/kernel.h>
#include <linux/kstrtox.h>
#include <linux/mm.h>
#include <linux/omapfb.h>

#include <video/omapfb_dss.h>
#include <video/omapvrfb.h>

#include "omapfb.h"

static ssize_t show_rotate_type(struct device *dev,
                struct device_attribute *attr, char *buf)
{
        struct fb_info *fbi = dev_get_drvdata(dev);
        struct omapfb_info *ofbi = FB2OFB(fbi);

        return sysfs_emit(buf, "%d\n", ofbi->rotation_type);
}

static ssize_t store_rotate_type(struct device *dev,
                struct device_attribute *attr,
                const char *buf, size_t count)
{
        struct fb_info *fbi = dev_get_drvdata(dev);
        struct omapfb_info *ofbi = FB2OFB(fbi);
        struct omapfb2_mem_region *rg;
        int rot_type;
        int r;

        r = kstrtoint(buf, 0, &rot_type);
        if (r)
                return r;

        if (rot_type != OMAP_DSS_ROT_DMA && rot_type != OMAP_DSS_ROT_VRFB)
                return -EINVAL;

        lock_fb_info(fbi);

        r = 0;
        if (rot_type == ofbi->rotation_type)
                goto out;

        rg = omapfb_get_mem_region(ofbi->region);

        if (rg->size) {
                r = -EBUSY;
                goto put_region;
        }

        ofbi->rotation_type = rot_type;

        /*
         * Since the VRAM for this FB is not allocated at the moment we don't
         * need to do any further parameter checking at this point.
         */
put_region:
        omapfb_put_mem_region(rg);
out:
        unlock_fb_info(fbi);

        return r ? r : count;
}


static ssize_t show_mirror(struct device *dev,
                struct device_attribute *attr, char *buf)
{
        struct fb_info *fbi = dev_get_drvdata(dev);
        struct omapfb_info *ofbi = FB2OFB(fbi);

        return sysfs_emit(buf, "%d\n", ofbi->mirror);
}

static ssize_t store_mirror(struct device *dev,
                struct device_attribute *attr,
                const char *buf, size_t count)
{
        struct fb_info *fbi = dev_get_drvdata(dev);
        struct omapfb_info *ofbi = FB2OFB(fbi);
        bool mirror;
        int r;
        struct fb_var_screeninfo new_var;

        r = kstrtobool(buf, &mirror);
        if (r)
                return r;

        lock_fb_info(fbi);

        ofbi->mirror = mirror;

        omapfb_get_mem_region(ofbi->region);

        memcpy(&new_var, &fbi->var, sizeof(new_var));
        r = check_fb_var(fbi, &new_var);
        if (r)
                goto out;
        memcpy(&fbi->var, &new_var, sizeof(fbi->var));

        set_fb_fix(fbi);

        r = omapfb_apply_changes(fbi, 0);
        if (r)
                goto out;

        r = count;
out:
        omapfb_put_mem_region(ofbi->region);

        unlock_fb_info(fbi);

        return r;
}

static ssize_t show_overlays(struct device *dev,
                struct device_attribute *attr, char *buf)
{
        struct fb_info *fbi = dev_get_drvdata(dev);
        struct omapfb_info *ofbi = FB2OFB(fbi);
        struct omapfb2_device *fbdev = ofbi->fbdev;
        ssize_t l = 0;
        int t;

        lock_fb_info(fbi);
        omapfb_lock(fbdev);

        for (t = 0; t < ofbi->num_overlays; t++) {
                struct omap_overlay *ovl = ofbi->overlays[t];
                int ovlnum;

                for (ovlnum = 0; ovlnum < fbdev->num_overlays; ++ovlnum)
                        if (ovl == fbdev->overlays[ovlnum])
                                break;

                l += scnprintf(buf + l, PAGE_SIZE - l, "%s%d",
                                t == 0 ? "" : ",", ovlnum);
        }

        l += scnprintf(buf + l, PAGE_SIZE - l, "\n");

        omapfb_unlock(fbdev);
        unlock_fb_info(fbi);

        return l;
}

static struct omapfb_info *get_overlay_fb(struct omapfb2_device *fbdev,
                struct omap_overlay *ovl)
{
        int i, t;

        for (i = 0; i < fbdev->num_fbs; i++) {
                struct omapfb_info *ofbi = FB2OFB(fbdev->fbs[i]);

                for (t = 0; t < ofbi->num_overlays; t++) {
                        if (ofbi->overlays[t] == ovl)
                                return ofbi;
                }
        }

        return NULL;
}

static ssize_t store_overlays(struct device *dev, struct device_attribute *attr,
                const char *buf, size_t count)
{
        struct fb_info *fbi = dev_get_drvdata(dev);
        struct omapfb_info *ofbi = FB2OFB(fbi);
        struct omapfb2_device *fbdev = ofbi->fbdev;
        struct omap_overlay *ovls[OMAPFB_MAX_OVL_PER_FB];
        struct omap_overlay *ovl;
        int num_ovls, r, i;
        int len;
        bool added = false;

        num_ovls = 0;

        len = strlen(buf);
        if (buf[len - 1] == '\n')
                len = len - 1;

        lock_fb_info(fbi);
        omapfb_lock(fbdev);

        if (len > 0) {
                char *p = (char *)buf;
                int ovlnum;

                while (p < buf + len) {
                        int found;
                        if (num_ovls == OMAPFB_MAX_OVL_PER_FB) {
                                r = -EINVAL;
                                goto out;
                        }

                        ovlnum = simple_strtoul(p, &p, 0);
                        if (ovlnum > fbdev->num_overlays) {
                                r = -EINVAL;
                                goto out;
                        }

                        found = 0;
                        for (i = 0; i < num_ovls; ++i) {
                                if (ovls[i] == fbdev->overlays[ovlnum]) {
                                        found = 1;
                                        break;
                                }
                        }

                        if (!found)
                                ovls[num_ovls++] = fbdev->overlays[ovlnum];

                        p++;
                }
        }

        for (i = 0; i < num_ovls; ++i) {
                struct omapfb_info *ofbi2 = get_overlay_fb(fbdev, ovls[i]);
                if (ofbi2 && ofbi2 != ofbi) {
                        dev_err(fbdev->dev, "overlay already in use\n");
                        r = -EINVAL;
                        goto out;
                }
        }

        /* detach unused overlays */
        for (i = 0; i < ofbi->num_overlays; ++i) {
                int t, found;

                ovl = ofbi->overlays[i];

                found = 0;

                for (t = 0; t < num_ovls; ++t) {
                        if (ovl == ovls[t]) {
                                found = 1;
                                break;
                        }
                }

                if (found)
                        continue;

                DBG("detaching %d\n", ofbi->overlays[i]->id);

                omapfb_get_mem_region(ofbi->region);

                omapfb_overlay_enable(ovl, 0);

                if (ovl->manager)
                        ovl->manager->apply(ovl->manager);

                omapfb_put_mem_region(ofbi->region);

                for (t = i + 1; t < ofbi->num_overlays; t++) {
                        ofbi->rotation[t-1] = ofbi->rotation[t];
                        ofbi->overlays[t-1] = ofbi->overlays[t];
                }

                ofbi->num_overlays--;
                i--;
        }

        for (i = 0; i < num_ovls; ++i) {
                int t, found;

                ovl = ovls[i];

                found = 0;

                for (t = 0; t < ofbi->num_overlays; ++t) {
                        if (ovl == ofbi->overlays[t]) {
                                found = 1;
                                break;
                        }
                }

                if (found)
                        continue;
                ofbi->rotation[ofbi->num_overlays] = 0;
                ofbi->overlays[ofbi->num_overlays++] = ovl;

                added = true;
        }

        if (added) {
                omapfb_get_mem_region(ofbi->region);

                r = omapfb_apply_changes(fbi, 0);

                omapfb_put_mem_region(ofbi->region);

                if (r)
                        goto out;
        }

        r = count;
out:
        omapfb_unlock(fbdev);
        unlock_fb_info(fbi);

        return r;
}

static ssize_t show_overlays_rotate(struct device *dev,
                struct device_attribute *attr, char *buf)
{
        struct fb_info *fbi = dev_get_drvdata(dev);
        struct omapfb_info *ofbi = FB2OFB(fbi);
        ssize_t l = 0;
        int t;

        lock_fb_info(fbi);

        for (t = 0; t < ofbi->num_overlays; t++) {
                l += scnprintf(buf + l, PAGE_SIZE - l, "%s%d",
                                t == 0 ? "" : ",", ofbi->rotation[t]);
        }

        l += scnprintf(buf + l, PAGE_SIZE - l, "\n");

        unlock_fb_info(fbi);

        return l;
}

static ssize_t store_overlays_rotate(struct device *dev,
                struct device_attribute *attr, const char *buf, size_t count)
{
        struct fb_info *fbi = dev_get_drvdata(dev);
        struct omapfb_info *ofbi = FB2OFB(fbi);
        int num_ovls = 0, r, i;
        int len;
        bool changed = false;
        u8 rotation[OMAPFB_MAX_OVL_PER_FB];

        len = strlen(buf);
        if (buf[len - 1] == '\n')
                len = len - 1;

        lock_fb_info(fbi);

        if (len > 0) {
                char *p = (char *)buf;

                while (p < buf + len) {
                        int rot;

                        if (num_ovls == ofbi->num_overlays) {
                                r = -EINVAL;
                                goto out;
                        }

                        rot = simple_strtoul(p, &p, 0);
                        if (rot < 0 || rot > 3) {
                                r = -EINVAL;
                                goto out;
                        }

                        if (ofbi->rotation[num_ovls] != rot)
                                changed = true;

                        rotation[num_ovls++] = rot;

                        p++;
                }
        }

        if (num_ovls != ofbi->num_overlays) {
                r = -EINVAL;
                goto out;
        }

        if (changed) {
                for (i = 0; i < num_ovls; ++i)
                        ofbi->rotation[i] = rotation[i];

                omapfb_get_mem_region(ofbi->region);

                r = omapfb_apply_changes(fbi, 0);

                omapfb_put_mem_region(ofbi->region);

                if (r)
                        goto out;

                /* FIXME error handling? */
        }

        r = count;
out:
        unlock_fb_info(fbi);

        return r;
}

static ssize_t show_size(struct device *dev,
                struct device_attribute *attr, char *buf)
{
        struct fb_info *fbi = dev_get_drvdata(dev);
        struct omapfb_info *ofbi = FB2OFB(fbi);

        return sysfs_emit(buf, "%lu\n", ofbi->region->size);
}

static ssize_t store_size(struct device *dev, struct device_attribute *attr,
                const char *buf, size_t count)
{
        struct fb_info *fbi = dev_get_drvdata(dev);
        struct omapfb_info *ofbi = FB2OFB(fbi);
        struct omapfb2_device *fbdev = ofbi->fbdev;
        struct omap_dss_device *display = fb2display(fbi);
        struct omapfb2_mem_region *rg;
        unsigned long size;
        int r;
        int i;

        r = kstrtoul(buf, 0, &size);
        if (r)
                return r;

        size = PAGE_ALIGN(size);

        lock_fb_info(fbi);

        if (display && display->driver->sync)
                display->driver->sync(display);

        rg = ofbi->region;

        down_write_nested(&rg->lock, rg->id);
        atomic_inc(&rg->lock_count);

        if (atomic_read(&rg->map_count)) {
                r = -EBUSY;
                goto out;
        }

        for (i = 0; i < fbdev->num_fbs; i++) {
                struct omapfb_info *ofbi2 = FB2OFB(fbdev->fbs[i]);
                int j;

                if (ofbi2->region != rg)
                        continue;

                for (j = 0; j < ofbi2->num_overlays; j++) {
                        struct omap_overlay *ovl;
                        ovl = ofbi2->overlays[j];
                        if (ovl->is_enabled(ovl)) {
                                r = -EBUSY;
                                goto out;
                        }
                }
        }

        if (size != ofbi->region->size) {
                r = omapfb_realloc_fbmem(fbi, size, ofbi->region->type);
                if (r) {
                        dev_err(dev, "realloc fbmem failed\n");
                        goto out;
                }
        }

        r = count;
out:
        atomic_dec(&rg->lock_count);
        up_write(&rg->lock);

        unlock_fb_info(fbi);

        return r;
}

static ssize_t show_phys(struct device *dev,
                struct device_attribute *attr, char *buf)
{
        struct fb_info *fbi = dev_get_drvdata(dev);
        struct omapfb_info *ofbi = FB2OFB(fbi);

        return sysfs_emit(buf, "%0x\n", ofbi->region->paddr);
}

static ssize_t show_virt(struct device *dev,
                struct device_attribute *attr, char *buf)
{
        struct fb_info *fbi = dev_get_drvdata(dev);
        struct omapfb_info *ofbi = FB2OFB(fbi);

        return sysfs_emit(buf, "%p\n", ofbi->region->vaddr);
}

static ssize_t show_upd_mode(struct device *dev,
                struct device_attribute *attr, char *buf)
{
        struct fb_info *fbi = dev_get_drvdata(dev);
        enum omapfb_update_mode mode;
        int r;

        r = omapfb_get_update_mode(fbi, &mode);

        if (r)
                return r;

        return sysfs_emit(buf, "%u\n", (unsigned int)mode);
}

static ssize_t store_upd_mode(struct device *dev, struct device_attribute *attr,
                const char *buf, size_t count)
{
        struct fb_info *fbi = dev_get_drvdata(dev);
        unsigned mode;
        int r;

        r = kstrtouint(buf, 0, &mode);
        if (r)
                return r;

        r = omapfb_set_update_mode(fbi, mode);
        if (r)
                return r;

        return count;
}

static struct device_attribute omapfb_attrs[] = {
        __ATTR(rotate_type, S_IRUGO | S_IWUSR, show_rotate_type,
                        store_rotate_type),
        __ATTR(mirror, S_IRUGO | S_IWUSR, show_mirror, store_mirror),
        __ATTR(size, S_IRUGO | S_IWUSR, show_size, store_size),
        __ATTR(overlays, S_IRUGO | S_IWUSR, show_overlays, store_overlays),
        __ATTR(overlays_rotate, S_IRUGO | S_IWUSR, show_overlays_rotate,
                        store_overlays_rotate),
        __ATTR(phys_addr, S_IRUGO, show_phys, NULL),
        __ATTR(virt_addr, S_IRUGO, show_virt, NULL),
        __ATTR(update_mode, S_IRUGO | S_IWUSR, show_upd_mode, store_upd_mode),
};

int omapfb_create_sysfs(struct omapfb2_device *fbdev)
{
        int i;
        int r;

        DBG("create sysfs for fbs\n");
        for (i = 0; i < fbdev->num_fbs; i++) {
                struct device *dev;
                int t;

                dev = dev_of_fbinfo(fbdev->fbs[i]);
                if (!dev)
                        continue;

                for (t = 0; t < ARRAY_SIZE(omapfb_attrs); t++) {
                        r = device_create_file(dev, &omapfb_attrs[t]);

                        if (r) {
                                dev_err(fbdev->dev, "failed to create sysfs "
                                                "file\n");
                                return r;
                        }
                }
        }

        return 0;
}

void omapfb_remove_sysfs(struct omapfb2_device *fbdev)
{
        int i, t;

        DBG("remove sysfs for fbs\n");
        for (i = 0; i < fbdev->num_fbs; i++) {
                struct device *dev;

                dev = dev_of_fbinfo(fbdev->fbs[i]);
                if (!dev)
                        continue;

                for (t = 0; t < ARRAY_SIZE(omapfb_attrs); t++)
                        device_remove_file(dev, &omapfb_attrs[t]);
        }
}