/*      $NetBSD: fb_sbdio.c,v 1.20 2021/08/07 16:18:53 thorpej Exp $    */

/*-
 * Copyright (c) 2004, 2005 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by UCHIYAMA Yasushi.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#define WIRED_FB_TLB

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: fb_sbdio.c,v 1.20 2021/08/07 16:18:53 thorpej Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kmem.h>
#include <dev/cons.h>

#include <uvm/uvm_extern.h>     /* pmap function to remap FB */

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

#include <mips/locore.h>
#include <mips/pte.h>

#include <machine/sbdiovar.h>

#include <machine/gareg.h>
#include <machine/gavar.h>

#include <machine/vmparam.h>
#include <machine/wired_map.h>


struct fb_softc {
        device_t sc_dev;
        struct rasops_info *sc_ri;
        struct ga *sc_ga;
        int sc_nscreens;
};

int fb_sbdio_match(device_t, cfdata_t, void *);
void fb_sbdio_attach(device_t, device_t, void *);

CFATTACH_DECL_NEW(fb_sbdio, sizeof(struct fb_softc),
    fb_sbdio_match, fb_sbdio_attach, NULL, NULL);

int _fb_ioctl(void *, void *, u_long, void *, int, struct lwp *);
paddr_t _fb_mmap(void *, void *, off_t, int);
int _fb_alloc_screen(void *, const struct wsscreen_descr *, void **,
    int *, int *, long *);
void _fb_free_screen(void *, void *);
int _fb_show_screen(void *, void *, int, void (*)(void *, int, int), void *);
void _fb_pollc(void *, int);
void fb_common_init(struct rasops_info *, struct ga *);
int fb_sbdio_cnattach(uint32_t, uint32_t, int);
void fb_pmap_enter(paddr_t, paddr_t, vaddr_t *, vaddr_t *);

struct wsscreen_descr _fb_std_screen = {
        "std", 0, 0,
        0, /* textops */
        0, 0,
        0
};

const struct wsscreen_descr *_fb_screen_table[] = {
        &_fb_std_screen,
};

struct wsscreen_list _fb_screen_list = {
        .nscreens       =
            sizeof(_fb_screen_table) / sizeof(_fb_screen_table[0]),
        .screens        = _fb_screen_table
};

struct wsdisplay_accessops _fb_accessops = {
        .ioctl          = _fb_ioctl,
        .mmap           = _fb_mmap,
        .alloc_screen   = _fb_alloc_screen,
        .free_screen    = _fb_free_screen,
        .show_screen    = _fb_show_screen,
        .load_font      = 0,
        .pollc          = _fb_pollc
};

/* console stuff */
static struct rasops_info fb_console_ri;
static struct ga fb_console_ga;
static paddr_t fb_consaddr;


int
fb_sbdio_match(device_t parent, cfdata_t cf, void *aux)
{
        struct sbdio_attach_args *sa = aux;

        return strcmp(sa->sa_name, "fb") ? 0 : 1;
}

void
fb_sbdio_attach(device_t parent, device_t self, void *aux)
{
        struct fb_softc *sc = device_private(self);
        struct sbdio_attach_args *sa = aux;
        struct wsemuldisplaydev_attach_args wa;
        struct rasops_info *ri;
        struct ga *ga;
        vaddr_t memva, regva;
        int console;

        sc->sc_dev = self;
        aprint_normal("\n");

        console = (sa->sa_addr1 == fb_consaddr);
        if (console) {
                /* already initialized in fb_cnattach() */
                sc->sc_ri = ri = &fb_console_ri;
                ri->ri_flg &= ~RI_NO_AUTO;
                sc->sc_ga = &fb_console_ga;
                sc->sc_nscreens = 1;
        } else {
                ri = kmem_zalloc(sizeof(struct rasops_info), KM_SLEEP);
                ga = kmem_zalloc(sizeof(struct ga), KM_SLEEP);
                ga->reg_paddr = sa->sa_addr2;
                ga->flags = sa->sa_flags;
                fb_pmap_enter(sa->sa_addr1, sa->sa_addr2,
                    &memva, &regva);
                ri->ri_bits = (void *)memva;
                ga->reg_addr = regva;
                fb_common_init(ri, ga);
                sc->sc_ri = ri;
                sc->sc_ga = ga;
        }

        wa.console = console;
        wa.scrdata = &_fb_screen_list;
        wa.accessops = &_fb_accessops;
        wa.accesscookie = (void *)sc;

        config_found(self, &wa, wsdisplaydevprint, CFARGS_NONE);
}

void
fb_common_init(struct rasops_info *ri, struct ga *ga)
{
        int ga_active, cookie;

        /* XXX */
        ga_active = 0;
        if (ga->flags == 0x0000 || ga->flags == 0x0001)
                ga_active = ga_init(ga);

        /*
         * TR2 IPL CLUT.
         * 0     black
         * 1     red
         * 2     green
         * 4     blue
         * 8     yellow
         * 16    cyan
         * 32    magenta
         * 64    light gray
         * 128   dark gray
         * 255   white
         * other black
         * When CLUT isn't initialized for NetBSD, use black-red pair.
         */
        ri->ri_flg = RI_CENTER | RI_CLEAR;
        if (!ga_active)
                ri->ri_flg |= RI_FORCEMONO;
        if (ri == &fb_console_ri)
                ri->ri_flg |= RI_NO_AUTO;

        ri->ri_depth = 8;
        ri->ri_width = 1280;
        ri->ri_height = 1024;
        ri->ri_stride = 2048;
        ri->ri_hw = (void *)ga;

        wsfont_init();
        /* prefer 12 pixel wide font */
        cookie = wsfont_find(NULL, 12, 0, 0, 0, 0, WSFONT_FIND_BITMAP);
        if (cookie <= 0)
                cookie = wsfont_find(NULL, 0, 0, 0, 0, 0, WSFONT_FIND_BITMAP);
        if (cookie <= 0) {
                printf("sfb: font table is empty\n");
                return;
        }

        if (wsfont_lock(cookie, &ri->ri_font)) {
                printf("fb: can't lock font\n");
                return;
        }
        ri->ri_wsfcookie = cookie;

        rasops_init(ri, 34, 80);

#if 0
        /* XXX no accelarated functions yet */
        ri->ri_ops.putchar = xxx_putchar;
        ri->ri_ops.erasecols = xxx_erasecols;
        ri->ri_ops.copyrows = xxx_copyrows;
        ri->ri_ops.eraserows = xxx_eraserows;
        ir->ri_do_cursor = xxx_do_cursor;
#endif

        /* XXX shouldn't be global */
        _fb_std_screen.nrows = ri->ri_rows;
        _fb_std_screen.ncols = ri->ri_cols;
        _fb_std_screen.textops = &ri->ri_ops;
        _fb_std_screen.capabilities = ri->ri_caps;
}

int
fb_sbdio_cnattach(uint32_t mem, uint32_t reg, int flags)
{
        struct rasops_info *ri;
        struct ga *ga;
        vaddr_t memva, regva;
        long defattr;

        ri = &fb_console_ri;
        ga = &fb_console_ga;

        ga->reg_paddr = reg;
        ga->flags = flags;
        fb_pmap_enter((paddr_t)mem, (paddr_t)reg, &memva, &regva);
        ri->ri_bits = (void *)memva;
        ga->reg_addr = regva;

        fb_common_init(ri, ga);

        (*ri->ri_ops.allocattr)(ri, 0, 0, 0, &defattr);
        wsdisplay_cnattach(&_fb_std_screen, ri, 0, 0, defattr);
        fb_consaddr = mem;

        return 0;
}

int
_fb_ioctl(void *v, void *vs, u_long cmd, void *data, int flag, struct lwp *l)
{
        struct fb_softc *sc = v;
        struct wsdisplay_fbinfo *fbinfo = (void *)data;
        struct wsdisplay_cmap *cmap = (void *)data;
        struct rasops_info *ri = sc->sc_ri;
        struct ga *ga = sc->sc_ga;
        int i;

        switch (cmd) {
        case WSDISPLAYIO_GTYPE:
                *(uint32_t *)data = WSDISPLAY_TYPE_UNKNOWN;
                return 0;

        case WSDISPLAYIO_GINFO:
                fbinfo->height = ri->ri_height;
                fbinfo->width  = ri->ri_width;
                fbinfo->depth  = ri->ri_depth;
                fbinfo->cmsize = 256;
                return 0;

        case WSDISPLAYIO_LINEBYTES:
                *(u_int *)data = ri->ri_stride;
                return 0;

        case WSDISPLAYIO_GETCMAP:
                if (ri->ri_flg == RI_FORCEMONO)
                        break;
                ga_clut_get(ga);
                if (cmap->index >= 256 || cmap->count > 256 - cmap->index)
                        return (EINVAL);
                for (i = 0; i < cmap->count; i++) {
                        cmap->red[i] = ga->clut[cmap->index + i][0];
                        cmap->green[i] = ga->clut[cmap->index + i][1];
                        cmap->blue[i] = ga->clut[cmap->index + i][2];
                }
                return 0;

        case WSDISPLAYIO_PUTCMAP:
                if (ri->ri_flg == RI_FORCEMONO)
                        break;
                if (cmap->index >= 256 || cmap->count > 256 - cmap->index)
                        return (EINVAL);
                for (i = 0; i < cmap->count; i++) {
                        ga->clut[cmap->index + i][0] = cmap->red[i];
                        ga->clut[cmap->index + i][1] = cmap->green[i];
                        ga->clut[cmap->index + i][2] = cmap->blue[i];
                }
                ga_clut_set(ga);
                return 0;
        }

        return EPASSTHROUGH;
}

paddr_t
_fb_mmap(void *v, void *vs, off_t offset, int prot)
{

        if (offset < 0 || offset >= GA_FRB_SIZE)
                return -1;

        return mips_btop(GA_FRB_ADDR + offset);
}

int
_fb_alloc_screen(void *v, const struct wsscreen_descr *type, void **cookie,
    int *curx, int *cury, long *attr)
{
        struct fb_softc *sc = v;
        struct rasops_info *ri = sc->sc_ri;
        long defattr;

#if 0
        if (sc->sc_nscreens > 0)
                return ENOMEM;
#endif

        *cookie = ri;
        *curx = *cury = 0;
        ri->ri_ops.allocattr(ri, 0, 0, 0, &defattr);
        *attr = defattr;
        sc->sc_nscreens++;

        return 0;
}

void
_fb_free_screen(void *v, void *cookie)
{
        struct fb_softc *sc = v;

        sc->sc_nscreens--;
}

int
_fb_show_screen(void *v, void *cookie, int waitok,
    void (*cb)(void *, int, int), void *cbarg)
{

        return 0;
}

void
_fb_pollc(void *v, int on)
{

        /* no interrupt used. */
}

void
fb_pmap_enter(paddr_t fb_paddr, paddr_t reg_paddr,
    vaddr_t *fb_vaddr, vaddr_t *reg_vaddr)
{
#ifdef WIRED_FB_TLB     /* Make wired 16MPage for frame buffer */
        vaddr_t va;
        vsize_t fb_off, reg_off, pgsize;

        pgsize = MIPS3_WIRED_SIZE;
        fb_off  = fb_paddr  & MIPS3_WIRED_OFFMASK;
        reg_off = reg_paddr & MIPS3_WIRED_OFFMASK;
        fb_paddr  = fb_paddr  & ~MIPS3_WIRED_OFFMASK;
        reg_paddr = reg_paddr & ~MIPS3_WIRED_OFFMASK;
        va = GA_FRB_ADDR;

        if (mips3_wired_enter_page(va, fb_paddr, pgsize) == false) {
                printf("cannot allocate fb memory\n");
                return;
        }

        if (mips3_wired_enter_page(va + pgsize, reg_paddr, pgsize) == false) {
                printf("cannot allocate fb register\n");
                return;
        }

        *fb_vaddr  = va + fb_off;
        *reg_vaddr = va + pgsize + reg_off;
#else /* WIRED_FB_TLB */
        paddr_t pa, epa;
        vaddr_t va, tva;

        pa = addr;
        epa = pa + size;

        va = uvm_km_alloc(kernel_map, epa - pa, 0, UVM_KMF_VAONLY);
        if (va == 0)
                for (;;)
                        ROM_MONITOR();

        for (tva = va; pa < epa; pa += PAGE_SIZE, tva += PAGE_SIZE)
                pmap_kenter_pa(tva, pa, VM_PROT_READ | VM_PROT_WRITE, 0);

        pmap_update(pmap_kernel());

        *fb_vaddr  = va;
#endif /* WIRED_FB_TLB */
}