/*      $NetBSD: imx_genfb.c,v 1.1 2015/12/21 04:26:28 hkenken Exp $    */

/*
 * Copyright (c) 2015 Genetec Corporation.  All rights reserved.
 * Written by Hashimoto Kenichi for Genetec Corporation.
 *
 * 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 GENETEC CORPORATION ``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 GENETEC CORPORATION
 * 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.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: imx_genfb.c,v 1.1 2015/12/21 04:26:28 hkenken Exp $");

#include "opt_ddb.h"
#include "opt_genfb.h"

#include <sys/param.h>
#include <sys/bus.h>
#include <sys/device.h>
#include <sys/intr.h>
#include <sys/systm.h>
#include <sys/kernel.h>

#include <arm/imx/imx51reg.h>
#include <arm/imx/imx51var.h>
#include <arm/imx/imx51_ipuv3var.h>

#if defined(DDB)
#include <machine/db_machdep.h>
#include <ddb/db_extern.h>
#endif

#include <dev/videomode/videomode.h>
#include <dev/wsfb/genfbvar.h>

struct imx_genfb_softc {
        struct genfb_softc sc_gen;

        bus_dma_tag_t sc_dmat;
        bus_dma_segment_t *sc_dmasegs;
        int sc_ndmasegs;
};

#if defined(DDB)
static void     imx_genfb_ddb_trap_callback(int);
static device_t imx_genfb_consoledev = NULL;
#endif

static int      imx_genfb_match(device_t, cfdata_t, void *);
static void     imx_genfb_attach(device_t, device_t, void *);

static int      imx_genfb_ioctl(void *, void *, u_long, void *, int, lwp_t *);
static paddr_t  imx_genfb_mmap(void *, void *, off_t, int);
static bool     imx_genfb_shutdown(device_t, int);

CFATTACH_DECL_NEW(imx_genfb, sizeof(struct imx_genfb_softc),
        imx_genfb_match, imx_genfb_attach, NULL, NULL);

static int
imx_genfb_match(device_t parent, cfdata_t cf, void *aux)
{
        return 1;
}

static void
imx_genfb_attach(device_t parent, device_t self, void *aux)
{
        struct imx_genfb_softc *sc = device_private(self);
        struct imxfb_attach_args * const ifb = aux;
        prop_dictionary_t cfg = device_properties(self);
        struct genfb_ops ops;

        sc->sc_gen.sc_dev = self;
        sc->sc_dmat = ifb->ifb_dmat;
        sc->sc_dmasegs = ifb->ifb_dmasegs;
        sc->sc_ndmasegs = ifb->ifb_ndmasegs;

        prop_dictionary_set_uint32(cfg, "width", ifb->ifb_width);
        prop_dictionary_set_uint32(cfg, "height", ifb->ifb_height);
        prop_dictionary_set_uint8(cfg, "depth", ifb->ifb_depth);
        prop_dictionary_set_uint16(cfg, "linebytes", ifb->ifb_stride);
        prop_dictionary_set_uint32(cfg, "address", 0);
        prop_dictionary_set_uint32(cfg, "virtual_address",
            (uintptr_t)ifb->ifb_fb);

        genfb_init(&sc->sc_gen);

        if (sc->sc_gen.sc_width == 0 || sc->sc_gen.sc_fbsize == 0) {
                aprint_normal(": disabled\n");
                return;
        }

        pmf_device_register1(self, NULL, NULL, imx_genfb_shutdown);

        memset(&ops, 0, sizeof(ops));
        ops.genfb_ioctl = imx_genfb_ioctl;
        ops.genfb_mmap = imx_genfb_mmap;

        aprint_naive("\n");

        bool is_console = false;
        prop_dictionary_get_bool(cfg, "is_console", &is_console);

        if (is_console)
                aprint_normal(": switching to framebuffer console\n");
        else
                aprint_normal("\n");

        genfb_attach(&sc->sc_gen, &ops);

#if defined(DDB)
        if (is_console) {
                imx_genfb_consoledev = self;
                db_trap_callback = imx_genfb_ddb_trap_callback;
        }
#endif
}

static int
imx_genfb_ioctl(void *v, void *vs, u_long cmd, void *data, int flag, lwp_t *l)
{
        struct wsdisplayio_bus_id *busid;

        switch (cmd) {
        case WSDISPLAYIO_GTYPE:
                *(u_int *)data = WSDISPLAY_TYPE_IMXIPU;
                return 0;
        case WSDISPLAYIO_GET_BUSID:
                busid = data;
                busid->bus_type = WSDISPLAYIO_BUS_SOC;
                return 0;
        default:
                return EPASSTHROUGH;
        }
}

static paddr_t
imx_genfb_mmap(void *v, void *vs, off_t offset, int prot)
{
        struct imx_genfb_softc *sc = v;

        KASSERT(offset >= 0);
        KASSERT(offset < sc->sc_dmasegs[0].ds_len);

        return bus_dmamem_mmap(sc->sc_dmat, sc->sc_dmasegs, sc->sc_ndmasegs,
            offset, prot, BUS_DMA_PREFETCHABLE);
}

static bool
imx_genfb_shutdown(device_t self, int flags)
{
        genfb_enable_polling(self);
        return true;
}

#if defined(DDB)
static void
imx_genfb_ddb_trap_callback(int where)
{
        if (imx_genfb_consoledev == NULL)
                return;

        if (where)
                genfb_enable_polling(imx_genfb_consoledev);
        else
                genfb_disable_polling(imx_genfb_consoledev);
}
#endif

void
imx_genfb_set_videomode(device_t dev, u_int width, u_int height)
{
        struct imx_genfb_softc *sc = device_private(dev);

        if (sc->sc_gen.sc_width != width || sc->sc_gen.sc_height != height) {
                device_printf(sc->sc_gen.sc_dev,
                    "mode switching not yet supported\n");
        }
}