/*      $NetBSD: igsfb_pci.c,v 1.25 2019/11/10 21:16:36 chs Exp $ */

/*
 * Copyright (c) 2002, 2003 Valeriy E. Ushakov
 * All rights reserved.
 *
 * 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.
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
 */

/*
 * Integraphics Systems IGA 168x and CyberPro series.
 */
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: igsfb_pci.c,v 1.25 2019/11/10 21:16:36 chs Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/device.h>
#include <sys/malloc.h>
#include <sys/buf.h>

#ifdef __sparc__  /* XXX: this doesn't belong here */
#include <machine/autoconf.h>
#endif
#include <sys/bus.h>
#include <sys/intr.h>

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

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

#include <dev/ic/igsfbreg.h>
#include <dev/ic/igsfbvar.h>
#include <dev/pci/igsfb_pcivar.h>


static int      igsfb_pci_match_by_id(pcireg_t);
static int      igsfb_pci_map_regs(struct igsfb_devconfig *,
                                   bus_space_tag_t, bus_space_tag_t,
                                   pci_chipset_tag_t,
                                   pcitag_t, pci_product_id_t);
static int      igsfb_pci_is_console(pci_chipset_tag_t, pcitag_t);

static int igsfb_pci_console = 0;
static pcitag_t igsfb_pci_constag;



static int      igsfb_pci_match(device_t, cfdata_t, void *);
static void     igsfb_pci_attach(device_t, device_t, void *);

CFATTACH_DECL_NEW(igsfb_pci, sizeof(struct igsfb_softc),
    igsfb_pci_match, igsfb_pci_attach, NULL, NULL);


static int
igsfb_pci_match_by_id(pcireg_t id)
{

        if (PCI_VENDOR(id) != PCI_VENDOR_INTEGRAPHICS)
                return 0;

        switch (PCI_PRODUCT(id)) {
        case PCI_PRODUCT_INTEGRAPHICS_IGA1682:          /* FALLTHROUGH */
        case PCI_PRODUCT_INTEGRAPHICS_CYBERPRO2000:     /* FALLTHROUGH */
        case PCI_PRODUCT_INTEGRAPHICS_CYBERPRO2010:
                return 1;
        default:
                return 0;
        }
}


int
igsfb_pci_cnattach(bus_space_tag_t iot, bus_space_tag_t memt,
                   pci_chipset_tag_t pc,
                   int bus, int device, int function)
{
        struct igsfb_devconfig *dc;
        pcitag_t tag;
        pcireg_t id;
        int ret;

        tag = pci_make_tag(pc, bus, device, function);
        id = pci_conf_read(pc, tag, PCI_ID_REG);

        if (igsfb_pci_match_by_id(id) == 0)
                return 1;

        dc = &igsfb_console_dc;
        if (igsfb_pci_map_regs(dc, iot, memt, pc, tag, PCI_PRODUCT(id)) != 0)
                return 1;

        ret = igsfb_enable(dc->dc_iot, dc->dc_iobase, dc->dc_ioflags);
        if (ret)
                return ret;

        ret = igsfb_cnattach_subr(dc);
        if (ret)
                return ret;

        igsfb_pci_console = 1;
        igsfb_pci_constag = tag;

        return 0;
}


static int
igsfb_pci_is_console(pci_chipset_tag_t pc, pcitag_t tag)
{

        return igsfb_pci_console &&
            !memcmp(&tag, &igsfb_pci_constag, sizeof tag);
}


static int
igsfb_pci_match(device_t parent, cfdata_t match, void *aux)
{
        struct pci_attach_args *pa = aux;

        return igsfb_pci_match_by_id(pa->pa_id);
}


static void
igsfb_pci_attach(device_t parent, device_t self, void *aux)
{
        struct igsfb_softc *sc = device_private(self);
        struct pci_attach_args *pa = aux;
        int isconsole;

        sc->sc_dev = self;

        pci_aprint_devinfo(pa, NULL);

#if defined(__sparc__) && !defined(KRUPS_FORCE_SERIAL_CONSOLE)
        /* XXX: this doesn't belong here */
        if (PCITAG_NODE(pa->pa_tag) == prom_instance_to_package(prom_stdout()))
        {
                int b, d, f;

                pci_decompose_tag(pa->pa_pc, pa->pa_tag, &b, &d, &f);
                igsfb_pci_cnattach(pa->pa_iot, pa->pa_memt, pa->pa_pc, b,d,f);
        }
#endif

        isconsole = 0;
        if (igsfb_pci_is_console(pa->pa_pc, pa->pa_tag)) {
                sc->sc_dc = &igsfb_console_dc;
                isconsole = 1;
        } else {
                sc->sc_dc = malloc(sizeof(struct igsfb_devconfig),
                                   M_DEVBUF, M_WAITOK | M_ZERO);
                if (igsfb_pci_map_regs(sc->sc_dc,
                            pa->pa_iot, pa->pa_memt, pa->pa_pc,
                            pa->pa_tag, PCI_PRODUCT(pa->pa_id)) != 0)
                {
                        aprint_error("unable to map device registers\n");
                        free(sc->sc_dc, M_DEVBUF);
                        sc->sc_dc = NULL;
                        return;
                }

                igsfb_enable(sc->sc_dc->dc_iot, sc->sc_dc->dc_iobase,
                             sc->sc_dc->dc_ioflags);
        }

        igsfb_attach_subr(sc, isconsole);
}


/*
 * Init memory and i/o bus space tags.  Map device registers.
 * Use memory space mapped i/o space access for i/o registers
 * for CyberPro cards.
 */
static int
igsfb_pci_map_regs(struct igsfb_devconfig *dc,
                   bus_space_tag_t iot, bus_space_tag_t memt,
                   pci_chipset_tag_t pc, pcitag_t tag,
                   pci_product_id_t id)
{

        dc->dc_id = id;

        /*
         * Configure memory space first since for CyberPro we use
         * memory-mapped i/o access.  Note that we are NOT mapping any
         * of it yet.  (XXX: search for memory BAR?)
         */
#define IGS_MEM_MAPREG (PCI_MAPREG_START + 0)

        dc->dc_memt = memt;
        if (pci_mapreg_info(pc, tag,
                IGS_MEM_MAPREG, PCI_MAPREG_TYPE_MEM,
                &dc->dc_memaddr, &dc->dc_memsz, &dc->dc_memflags) != 0)
        {
                printf("unable to configure memory space\n");
                return 1;
        }

        /*
         * Configure I/O space.  On CyberPro use MMIO.  IGS 168x doesn't
         * have a BAR for its i/o space, so we have to hardcode it.
         */
        if (id >= PCI_PRODUCT_INTEGRAPHICS_CYBERPRO2000) {
                dc->dc_iot = dc->dc_memt;
                dc->dc_iobase = dc->dc_memaddr | IGS_MEM_MMIO_SELECT;
                dc->dc_ioflags = dc->dc_memflags;
        } else {
                dc->dc_iot = iot;
                dc->dc_iobase = 0;
                dc->dc_ioflags = 0;
        }

        /*
         * Map I/O registers.  This is done in bus glue, not in common
         * code because on e.g. ISA bus we'd need to access registers
         * to obtain/program linear memory location.
         */
        if (bus_space_map(dc->dc_iot,
                          dc->dc_iobase + IGS_REG_BASE, IGS_REG_SIZE,
                          dc->dc_ioflags,
                          &dc->dc_ioh) != 0)
        {
                printf("unable to map I/O registers\n");
                return 1;
        }

        return 0;
}