/*      $NetBSD: puccn.c,v 1.14 2014/03/05 05:56:04 msaitoh Exp $ */

/*
 * Derived from  pci.c
 * Copyright (c) 2000 Geocast Networks Systems.  All rights reserved.
 *
 * Copyright (c) 1995, 1996, 1997, 1998
 *     Christopher G. Demetriou.  All rights reserved.
 * Copyright (c) 1994 Charles M. Hannum.  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. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed by Charles M. Hannum.
 * 4. 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.
 */


/*
 * Machine independent support for PCI serial console support.
 *
 * Scan the PCI bus for something which resembles a 16550
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: puccn.c,v 1.14 2014/03/05 05:56:04 msaitoh Exp $");

#include "opt_kgdb.h"

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

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

#include <sys/termios.h>
#include <dev/ic/comreg.h>
#include <dev/ic/comvar.h>

#include <dev/cons.h>

#include <dev/pci/pucvar.h>
#include <dev/pci/puccn.h>

#ifndef CONSPEED
#define CONSPEED        TTYDEF_SPEED
#endif
#ifndef CONMODE
#define CONMODE         ((TTYDEF_CFLAG & ~(CSIZE|CSTOPB|PARENB))|CS8) /* 8N1 */
#endif

cons_decl(com);

static bus_addr_t puccnbase;
static bus_space_tag_t puctag;
static int puccnflags;

#ifdef KGDB
static bus_addr_t pucgdbbase;
#endif

/*
 * Static dev/func variables allow pucprobe to be called multiple times,
 * resuming the search where it left off, never retrying the same adaptor.
 */

static bus_addr_t
pucprobe_doit(struct consdev *cn)
{
        struct pci_attach_args pa;
        int bus;
        static int dev = 0, func = 0;
        int maxdev, nfunctions = 0, i; /* XXX */
        pcireg_t reg, bhlcr, subsys = 0; /* XXX */
        int foundport = 0;
        const struct puc_device_description *desc;
        pcireg_t base;

        /* Fetch our tags */
#if defined(amd64) || defined(i386)
        if (cpu_puc_cnprobe(cn, &pa) != 0)
#endif
                return 0;

        pci_decompose_tag(pa.pa_pc, pa.pa_tag, &bus, &maxdev, NULL);

        /* Scan through devices and find a communication class device. */
        for (; dev <= maxdev ; dev++) {
                pa.pa_tag = pci_make_tag(pa.pa_pc, bus, dev, 0);
                reg = pci_conf_read(pa.pa_pc, pa.pa_tag, PCI_ID_REG);
                if (PCI_VENDOR(reg) == PCI_VENDOR_INVALID
                    || PCI_VENDOR(reg) == 0)
                        continue;
                bhlcr = pci_conf_read(pa.pa_pc, pa.pa_tag, PCI_BHLC_REG);
                if (PCI_HDRTYPE_MULTIFN(bhlcr)) {
                        nfunctions = 8;
                } else {
                        nfunctions = 1;
                }
resume_scan:
                for (; func < nfunctions; func++)  {
                        pa.pa_tag = pci_make_tag(pa.pa_pc, bus, dev, func);
                        reg = pci_conf_read(pa.pa_pc, pa.pa_tag,
                            PCI_CLASS_REG);
                        if (PCI_CLASS(reg)  == PCI_CLASS_COMMUNICATIONS
                            && PCI_SUBCLASS(reg)
                               == PCI_SUBCLASS_COMMUNICATIONS_SERIAL) {
                                pa.pa_id = pci_conf_read(pa.pa_pc, pa.pa_tag,
                                    PCI_ID_REG);
                                subsys = pci_conf_read(pa.pa_pc, pa.pa_tag,
                                    PCI_SUBSYS_ID_REG);
                                foundport = 1;
                                break;
                        }
                }
                if (foundport)
                        break;

                func = 0;
        }

        /*
         * If all devices was scanned and couldn't find any communication
         * device, return with 0.
         */
        if (!foundport)
                return 0;

        /* Clear foundport flag */
        foundport = 0;

        /* Check whether the device is in the puc device table or not */
        desc = puc_find_description(PCI_VENDOR(pa.pa_id),
            PCI_PRODUCT(pa.pa_id), PCI_VENDOR(subsys), PCI_PRODUCT(subsys));

        /* If not, check the next communication device */
        if (desc == NULL) {
                /* Resume from the next function */
                func++;
                goto resume_scan;
        }

        /*
         * We found a device and it's on the puc table. Set the tag and
         * the base address.
         */
        for (i = 0; PUC_PORT_VALID(desc, i); i++) {
                if (desc->ports[i].type != PUC_PORT_TYPE_COM)
                        continue;
                puccnflags = desc->ports[i].flags;
                base = pci_conf_read(pa.pa_pc, pa.pa_tag, desc->ports[i].bar);
                base += desc->ports[i].offset;

                if (PCI_MAPREG_TYPE(base) == PCI_MAPREG_TYPE_IO) {
                        puctag = pa.pa_iot;
                        base = PCI_MAPREG_IO_ADDR(base);
                }
#if 0 /* For MMIO device */
                else {
                        puctag = pa.pa_memt;
                        base = PCI_MAPREG_MEM_ADDR(base);
                }
#endif

                if (com_is_console(puctag, base, NULL))
                        continue;
                foundport = 1;
                break;
        }

        if (foundport == 0) {
                func++;
                goto resume_scan;
        }

#if 0
        cn->cn_pri = CN_REMOTE;
#else
        if (cn)
                cn->cn_pri = CN_REMOTE;
#endif
        return base;
}

#ifdef KGDB
void
puc_gdbprobe(struct consdev *cn)
{

        pucgdbbase = pucprobe_doit(cn);
}

void
puc_gdbinit(struct consdev *cn)
{

        if (pucgdbbase == 0)
                return;

        com_kgdb_attach(puctag, pucgdbbase, CONSPEED, COM_FREQ,
            COM_TYPE_NORMAL, CONMODE);
}
#endif

void
puc_cnprobe(struct consdev *cn)
{

        puccnbase = pucprobe_doit(cn);
}

int
puc_cninit(struct consdev *cn)
{

        if (puccnbase == 0)
                return -1;

        return comcnattach(puctag, puccnbase, CONSPEED,
            puccnflags & PUC_COM_CLOCKMASK, COM_TYPE_NORMAL,
            CONMODE);
}

/* comcngetc, comcnputc, comcnpollc provided by dev/ic/com.c */