/*      $OpenBSD: astfb.c,v 1.5 2022/07/15 17:57:26 kettenis Exp $      */

/*
 * Copyright (c) 2020 Mark Kettenis.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/param.h>
#include <sys/device.h>
#include <sys/systm.h>

#include <machine/bus.h>
#include <machine/fdt.h>

#include <dev/ofw/openfirm.h>

#include <dev/pci/pcireg.h>
#include <dev/pci/pcivar.h>
#include <dev/pci/pcidevs.h>

#include <dev/wscons/wsconsio.h>
#include <dev/wscons/wsdisplayvar.h>

#include <dev/rasops/rasops.h>

#define ASTFB_PCI_FB    0x10

struct astfb_softc {
        struct device           sc_dev;
        bus_space_tag_t         sc_iot;
        bus_space_handle_t      sc_ioh;

        bus_addr_t              sc_fbaddr;
        bus_size_t              sc_fbsize;

        struct rasops_info      sc_ri;
        struct wsscreen_descr   sc_wsd;
        struct wsscreen_list    sc_wsl;
        struct wsscreen_descr   *sc_scrlist[1];
};

int     astfb_wsioctl(void *, u_long, caddr_t, int, struct proc *);
paddr_t astfb_wsmmap(void *, off_t, int);
int     astfb_alloc_screen(void *, const struct wsscreen_descr *,
            void **, int *, int *, uint32_t *);

struct wsdisplay_accessops astfb_accessops = {
        .ioctl = astfb_wsioctl,
        .mmap = astfb_wsmmap,
        .alloc_screen = astfb_alloc_screen,
        .free_screen = rasops_free_screen,
        .show_screen = rasops_show_screen,
        .getchar = rasops_getchar,
        .load_font = rasops_load_font,
        .list_font = rasops_list_font,
        .scrollback = rasops_scrollback
};

int     astfb_match(struct device *, void *, void *);
void    astfb_attach(struct device *, struct device *, void *);

const struct cfattach astfb_ca = {
        sizeof(struct astfb_softc), astfb_match, astfb_attach
};

struct cfdriver astfb_cd = {
        NULL, "astfb", DV_DULL
};

int
astfb_match(struct device *parent, void *cf, void *aux)
{
        struct pci_attach_args *pa = aux;

        if (PCI_VENDOR(pa->pa_id) == PCI_VENDOR_ASPEED &&
            PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_ASPEED_AST2000 &&
            PCITAG_NODE(pa->pa_tag) != 0)
                return 1;

        return 0;
}

void
astfb_attach(struct device *parent, struct device *self, void *aux)
{
        struct astfb_softc *sc = (struct astfb_softc *)self;
        struct pci_attach_args *pa = aux;
        struct rasops_info *ri = &sc->sc_ri;
        struct wsemuldisplaydev_attach_args waa;
        int node = PCITAG_NODE(pa->pa_tag);
        uint32_t addr[5];
        int console = 0;
        uint32_t defattr;

        if (OF_getpropintarray(node, "assigned-addresses", addr,
            sizeof(addr)) < sizeof(addr)) {
                printf(": no framebuffer\n");
                return;
        }

        if (node == stdout_node)
                console = 1;

        sc->sc_fbaddr = (bus_addr_t)addr[1] << 32 | addr[2];
        sc->sc_fbsize = (bus_size_t)addr[3] << 32 | addr[4];

        sc->sc_iot = pa->pa_memt;
        if (bus_space_map(sc->sc_iot, sc->sc_fbaddr, sc->sc_fbsize,
            BUS_SPACE_MAP_LINEAR, &sc->sc_ioh)) {
                printf(": can't map framebuffer\n");
                return;
        }

        printf("\n");

        ri->ri_bits = bus_space_vaddr(sc->sc_iot, sc->sc_ioh);
        ri->ri_hw = sc;

        ri->ri_width = OF_getpropint(node, "width", 0);
        ri->ri_height = OF_getpropint(node, "height", 0);
        ri->ri_depth = OF_getpropint(node, "depth", 0);
        ri->ri_stride = ri->ri_width * ((ri->ri_depth + 7) / 8);
        ri->ri_flg = RI_CENTER | RI_CLEAR | RI_FULLCLEAR | RI_WRONLY;

        switch (ri->ri_depth) {
        case 32:
                ri->ri_rnum = 8;
                ri->ri_rpos = 8;
                ri->ri_gnum = 8;
                ri->ri_gpos = 16;
                ri->ri_bnum = 8;
                ri->ri_bpos = 24;
                break;
        case 16:
                ri->ri_rnum = 5;
                ri->ri_rpos = 0;
                ri->ri_gnum = 6;
                ri->ri_gpos = 6;
                ri->ri_bnum = 5;
                ri->ri_bpos = 11;
                break;
        }

        printf("%s: %dx%d, %dbpp\n", sc->sc_dev.dv_xname,
            ri->ri_width, ri->ri_height, ri->ri_depth);

        ri->ri_flg |= RI_VCONS;
        rasops_init(ri, 160, 160);

        strlcpy(sc->sc_wsd.name, "std", sizeof(sc->sc_wsd.name));
        sc->sc_wsd.capabilities = ri->ri_caps;
        sc->sc_wsd.nrows = ri->ri_rows;
        sc->sc_wsd.ncols = ri->ri_cols;
        sc->sc_wsd.textops = &ri->ri_ops;
        sc->sc_wsd.fontwidth = ri->ri_font->fontwidth;
        sc->sc_wsd.fontheight = ri->ri_font->fontheight;

        sc->sc_scrlist[0] = &sc->sc_wsd;
        sc->sc_wsl.nscreens = 1;
        sc->sc_wsl.screens = (const struct wsscreen_descr **)sc->sc_scrlist;

        if (console) {
                ri->ri_ops.pack_attr(ri->ri_active, 0, 0, 0, &defattr);
                wsdisplay_cnattach(&sc->sc_wsd, ri->ri_active,
                    0, 0, defattr);
        }

        memset(&waa, 0, sizeof(waa));
        waa.scrdata = &sc->sc_wsl;
        waa.accessops = &astfb_accessops;
        waa.accesscookie = ri;
        waa.console = console;

        config_found_sm(self, &waa, wsemuldisplaydevprint,
            wsemuldisplaydevsubmatch);
}

int
astfb_wsioctl(void *v, u_long cmd, caddr_t data, int flags, struct proc *p)
{
        struct rasops_info *ri = v;
        struct wsdisplay_fbinfo *wdf;

        switch (cmd) {
        case WSDISPLAYIO_GTYPE:
                *(u_int *)data = WSDISPLAY_TYPE_ASTFB;
                break;
        case WSDISPLAYIO_GINFO:
                wdf = (void *)data;
                wdf->width = ri->ri_width;
                wdf->height = ri->ri_height;
                wdf->depth = ri->ri_depth;
                wdf->stride = ri->ri_stride;
                wdf->offset = 0;
                wdf->cmsize = 0;        /* color map is unavailable */
                break;
        case WSDISPLAYIO_LINEBYTES:
                *(u_int *)data = ri->ri_stride;
                break;
        case WSDISPLAYIO_SMODE:
                break;
        case WSDISPLAYIO_GETSUPPORTEDDEPTH:
                switch (ri->ri_depth) {
                case 32:
                        *(u_int *)data = WSDISPLAYIO_DEPTH_24_32;
                        break;
                case 16:
                        *(u_int *)data = WSDISPLAYIO_DEPTH_16;
                        break;
                default:
                        return -1;
                }
                break;
        default:
                return -1;
        }

        return 0;
}

paddr_t
astfb_wsmmap(void *v, off_t off, int prot)
{
        struct rasops_info *ri = v;
        struct astfb_softc *sc = ri->ri_hw;

        if (off < 0 || off >= sc->sc_fbaddr)
                return -1;
        
        return (bus_space_mmap(sc->sc_iot, sc->sc_fbaddr,
            off, prot, BUS_SPACE_MAP_LINEAR));
}

int
astfb_alloc_screen(void *v, const struct wsscreen_descr *type,
    void **cookiep, int *curxp, int *curyp, uint32_t *attrp)
{
        return rasops_alloc_screen(v, cookiep, curxp, curyp, attrp);
}