/*      $NetBSD: dz_ebus.c,v 1.10 2019/12/27 06:52:43 msaitoh Exp $     */

/*-
* Copyright (c) 2010 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code was written by Alessandro Forin and Neil Pittman
* at Microsoft Research and contributed to The NetBSD Foundation
* by Microsoft 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 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.
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: dz_ebus.c,v 1.10 2019/12/27 06:52:43 msaitoh Exp $");

#include "opt_ddb.h"

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/callout.h>
#include <sys/ioctl.h>
#include <sys/tty.h>
#include <sys/proc.h>
#include <sys/buf.h>
#include <sys/conf.h>
#include <sys/file.h>
#include <sys/uio.h>
#include <sys/kernel.h>
#include <sys/syslog.h>
#include <sys/device.h>
#include <sys/kauth.h>

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

#include <dev/cons.h>


#include <emips/ebus/ebusvar.h>
#include <emips/emips/cons.h>
#if 0
#include <emips/emips/machdep.h>
#endif

#include "ioconf.h" /* for dz_cd */

#define DZ_C2I(c)       ((c) << 3)      /* convert controller # to index */
#define DZ_I2C(c)       ((c) >> 3)      /* convert minor to controller # */
#define DZ_PORT(u)      ((u) & 07)      /* extract the port # */

struct  dz_softc {
       device_t        sc_dev;         /* Autoconf blaha */
       struct  evcnt   sc_rintrcnt;    /* receive interrupt counts */
       struct  evcnt   sc_tintrcnt;    /* transmit interrupt counts */
       struct  _Usart  *sc_dr;         /* reg pointers */
       bus_space_tag_t sc_iot;
       bus_space_handle_t sc_ioh;
       int             sc_consline;    /* console line, or -1 */
       int             sc_rxint;       /* Receive interrupt count XXX */
       u_char          sc_brk;         /* Break asserted on some lines */
       u_char          sc_dsr;         /* DSR set bits if no mdm ctrl */
       struct dz_linestate {
               struct  dz_softc *dz_sc;        /* backpointer to softc */
               int             dz_line;        /* channel number */
               struct  tty     *dz_tty;        /* what we work on */
       } sc_dz;
};

void    dzrint(struct dz_softc *, uint32_t);
void    dzxint(struct dz_softc *, uint32_t);

#ifndef TIOCM_BRK
#define TIOCM_BRK               0100000         /* no equivalent */

static void     dzstart(struct tty *);
static int      dzparam(struct tty *, struct termios *);
static unsigned dzmctl(struct dz_softc *sc, int line,
                      int bits, /* one of the TIOCM_xx */
                      int how); /* one of the DMSET/BIS.. */

#include <dev/dec/dzkbdvar.h>
#endif

dev_type_open(dzopen);
dev_type_close(dzclose);
dev_type_read(dzread);
dev_type_write(dzwrite);
dev_type_ioctl(dzioctl);
dev_type_stop(dzstop);
dev_type_tty(dztty);
dev_type_poll(dzpoll);

const struct cdevsw dz_cdevsw = {
       .d_open = dzopen,
       .d_close = dzclose,
       .d_read = dzread,
       .d_write = dzwrite,
       .d_ioctl = dzioctl,
       .d_stop = dzstop,
       .d_tty = dztty,
       .d_poll = dzpoll,
       .d_mmap = nommap,
       .d_kqfilter = ttykqfilter,
       .d_discard = nodiscard,
       .d_flag = D_TTY
};

int
dzopen(dev_t dev, int flag, int mode, struct lwp *l)
{
       struct tty *tp;
       int unit, line;
       struct dz_softc *sc;
       int s, error = 0;

       unit = DZ_I2C(minor(dev));
       sc = device_lookup_private(&dz_cd, unit);
       if (sc == NULL)
               return ENXIO;

       line = DZ_PORT(minor(dev));
       if (line > 0) /* FIXME for more than one line */
               return ENXIO;

       tp = sc->sc_dz.dz_tty;
       if (tp == NULL)
               return ENODEV;
       tp->t_oproc = dzstart;
       tp->t_param = dzparam;
       tp->t_dev   = dev;

       if (kauth_authorize_device_tty(l->l_cred, KAUTH_DEVICE_TTY_OPEN, tp))
               return (EBUSY);

       if ((tp->t_state & TS_ISOPEN) == 0) {
               ttychars(tp);
               if (tp->t_ispeed == 0) {
                       tp->t_iflag = TTYDEF_IFLAG;
                       tp->t_oflag = TTYDEF_OFLAG;
                       tp->t_cflag = TTYDEF_CFLAG;
                       tp->t_lflag = TTYDEF_LFLAG;
                       tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
               }
               (void)dzparam(tp, &tp->t_termios);
               ttsetwater(tp);
       }
       /* we have no modem control but..*/
       if (dzmctl(sc, line, TIOCM_DTR, DMBIS) & TIOCM_CD)
               tp->t_state |= TS_CARR_ON;
       s = spltty();
       while (!(flag & O_NONBLOCK) && !(tp->t_cflag & CLOCAL) &&
           !(tp->t_state & TS_CARR_ON)) {
               tp->t_wopen++;
               error = ttysleep(tp, &tp->t_rawcv, true, 0);
               tp->t_wopen--;
               if (error)
                       break;
       }
       (void)splx(s);
       if (error)
               return error;
       return (*tp->t_linesw->l_open)(dev, tp);
}

int
dzclose(dev_t dev, int flag, int mode, struct lwp *l)
{
       struct dz_softc *sc;
       struct tty *tp;
       int unit, line;

       unit = DZ_I2C(minor(dev));
       sc = device_lookup_private(&dz_cd, unit);
       line = DZ_PORT(minor(dev));

       tp = sc->sc_dz.dz_tty;

       (*tp->t_linesw->l_close)(tp, flag);

       /* Make sure a BREAK state is not left enabled. */
       (void)dzmctl(sc, line, TIOCM_BRK, DMBIC);

       /* Do a hangup if so required. */
       if ((tp->t_cflag & HUPCL) || tp->t_wopen || !(tp->t_state & TS_ISOPEN))
               (void)dzmctl(sc, line, 0, DMSET);

       return ttyclose(tp);
}

int
dzread(dev_t dev, struct uio *uio, int flag)
{
       struct tty *tp;
       struct dz_softc *sc;

       sc = device_lookup_private(&dz_cd, DZ_I2C(minor(dev)));

       tp = sc->sc_dz.dz_tty;
       return (*tp->t_linesw->l_read)(tp, uio, flag);
}

int
dzwrite(dev_t dev, struct uio *uio, int flag)
{
       struct tty *tp;
       struct dz_softc *sc;

       sc = device_lookup_private(&dz_cd, DZ_I2C(minor(dev)));

       tp = sc->sc_dz.dz_tty;
       return (*tp->t_linesw->l_write)(tp, uio, flag);
}

/*ARGSUSED*/
int
dzioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
{
       struct  dz_softc *sc;
       struct tty *tp;
       int unit, line;
       int error;

       unit = DZ_I2C(minor(dev));
       line = 0;
       sc = device_lookup_private(&dz_cd, unit);
       tp = sc->sc_dz.dz_tty;

       error = (*tp->t_linesw->l_ioctl)(tp, cmd, data, flag, l);
       if (error >= 0)
               return error;

       error = ttioctl(tp, cmd, data, flag, l);
       if (error >= 0)
               return error;

       switch (cmd) {

       case TIOCSBRK:
               (void)dzmctl(sc, line, TIOCM_BRK, DMBIS);
               break;

       case TIOCCBRK:
               (void)dzmctl(sc, line, TIOCM_BRK, DMBIC);
               break;

       case TIOCSDTR:
               (void)dzmctl(sc, line, TIOCM_DTR, DMBIS);
               break;

       case TIOCCDTR:
               (void)dzmctl(sc, line, TIOCM_DTR, DMBIC);
               break;

       case TIOCMSET:
               (void)dzmctl(sc, line, *(int *)data, DMSET);
               break;

       case TIOCMBIS:
               (void)dzmctl(sc, line, *(int *)data, DMBIS);
               break;

       case TIOCMBIC:
               (void)dzmctl(sc, line, *(int *)data, DMBIC);
               break;

       case TIOCMGET:
               *(int *)data = dzmctl(sc, line, 0, DMGET) & ~TIOCM_BRK;
               break;

       default:
               return EPASSTHROUGH;
       }
       return 0;
}

/*ARGSUSED*/
void
dzstop(struct tty *tp, int flag)
{

       if (tp->t_state & TS_BUSY)
               if (!(tp->t_state & TS_TTSTOP))
                       tp->t_state |= TS_FLUSH;
}

struct tty *
dztty(dev_t dev)
{
       struct dz_softc *sc;
       struct tty *tp;

       sc = device_lookup_private(&dz_cd, DZ_I2C(minor(dev)));
       tp = sc->sc_dz.dz_tty;

       return tp;
}

int
dzpoll(dev_t dev, int events, struct lwp *l)
{
       struct dz_softc *sc;
       struct tty *tp;

       sc = device_lookup_private(&dz_cd, DZ_I2C(minor(dev)));

       tp = sc->sc_dz.dz_tty;
       return (*tp->t_linesw->l_poll)(tp, events, l);
}

void
dzstart(struct tty *tp)
{
       struct dz_softc *sc;
       struct clist *cl;
       int unit, s;

       unit = DZ_I2C(minor(tp->t_dev));
       sc = device_lookup_private(&dz_cd, unit);

       s = spltty();
       if (tp->t_state & (TS_TIMEOUT|TS_BUSY|TS_TTSTOP)) {
               splx(s);
               return;
       }
       cl = &tp->t_outq;
       ttypull(tp);
       if (cl->c_cc == 0) {
               splx(s);
               return;
       }

       tp->t_state |= TS_BUSY;

       /* was idle, get it started */
       dzxint(sc,USI_TXRDY);
       splx(s);
}

static int rclk = 25000000; /* BUGBUGBUGBUG */

static int
dzdivisor(int baudrate)
{
       int act_baud, divisor, error;

       if (baudrate <= 0)
               return 0;

       divisor = (rclk / 8) / (baudrate);
       divisor = (divisor / 2) + (divisor & 1);

       if (divisor <= 0)
               return -1;
       act_baud = rclk / (divisor * 16);

       /* 10 times error in percent: */
       error = ((act_baud - baudrate) * 2000 / baudrate + 1) >> 1;

       /* 3.0% maximum error tolerance: */
       if (error < -30 || error > 30)
               return -1;

       return divisor;
}

static int
dzparam(struct tty *tp, struct termios *t)
{
       struct  dz_softc *sc;
       int cflag = t->c_cflag;
       int unit, line;
       int speed;
       unsigned lpr;
       int s;
       struct _Usart *dzr;

       unit = DZ_I2C(minor(tp->t_dev));
       line = DZ_PORT(minor(tp->t_dev));
       sc = device_lookup_private(&dz_cd, unit);

       /* check requested parameters */
       if (t->c_ispeed != t->c_ospeed)
               return EINVAL;
       speed = dzdivisor(t->c_ispeed);
       if (speed < 0)
               return EINVAL;

       tp->t_ispeed = t->c_ispeed;
       tp->t_ospeed = t->c_ospeed;
       tp->t_cflag = cflag;

       {
               /* XXX */
               static int didit = 0;
               if (!didit && t->c_ispeed != 38400)
                       printf("dzparam: c_ispeed %d ignored, keeping 38400\n",
                           t->c_ispeed);
               didit = 1;
       }
       speed = dzdivisor(38400);

       if (speed == 0) {
               (void)dzmctl(sc, line, 0, DMSET);       /* hang up line */
               return 0;
       }

       switch (cflag & CSIZE) {
       case CS5:
               lpr = USC_BPC_5;
               break;
       case CS6:
               lpr = USC_BPC_6;
               break;
       case CS7:
               lpr = USC_BPC_7;
               break;
       default:
               lpr = USC_BPC_8;
               break;
       }
       if (cflag & CSTOPB)
               lpr |= USC_2STOP;

       if (cflag & PARENB) {
               if (cflag & PARODD)
                       lpr |= USC_ODD;
               else
                       lpr |= USC_EVEN;
       } else
               lpr |= USC_NONE;

       s = spltty();

       dzr = sc->sc_dr;

       dzr->Baud = speed;
       dzr->Control = USC_CLKDIV_4 | USC_TXEN | USC_RXEN | lpr;
#define USI_INTRS (USI_RXRDY|USI_RXBRK|USI_OVRE|USI_FRAME|USI_PARE)
       dzr->IntrEnable = USI_INTRS;

       (void)splx(s);
       return 0;
}

static unsigned
dzmctl(struct dz_softc *sc, int line, int bits, int how)
{
       unsigned int mbits;
       int s;
       struct _Usart *dzr;

       mbits = 0;

       s = spltty();

       dzr = sc->sc_dr;

       /* we have no modem control bits (CD,RI,DTR,DSR,..) */
       mbits |= TIOCM_CD;
       mbits |= TIOCM_DTR;

       if (dzr->ChannelStatus & USI_RXBRK)
               mbits |= TIOCM_BRK;

       switch (how) {
       case DMSET:
               mbits = bits;
               break;

       case DMBIS:
               mbits |= bits;
               break;

       case DMBIC:
               mbits &= ~bits;
               break;

       case DMGET:
               (void)splx(s);
               return mbits;
       }

       /* BUGBUG work in progress */
       if (mbits & TIOCM_BRK) {
               sc->sc_brk |= (1 << line);
               dzr->Control |= USC_STTBRK;
       } else {
               sc->sc_brk &= ~(1 << line);
               dzr->Control |= USC_STPBRK;
       }

       (void)splx(s);
       return mbits;
}


#if defined(DDB)
int dz_ddb = 0;
#endif

/* Receiver Interrupt */

void
dzrint(struct dz_softc *sc, uint32_t csr)
{
       struct tty *tp;
       int cc;
       struct _Usart *dzr;

       sc->sc_rxint++;
       dzr = sc->sc_dr;

       cc = dzr->RxData;
       tp = sc->sc_dz.dz_tty;

       /* clear errors before we print or bail out */
       if (csr & (USI_OVRE|USI_FRAME|USI_PARE))
               dzr->Control = USC_RSTSTA;

       if (!(tp->t_state & TS_ISOPEN)) {
               wakeup(&tp->t_rawq);
               return;
       }

       if (csr & USI_OVRE) {
               log(LOG_WARNING, "%s: silo overflow, line %d\n",
                   device_xname(sc->sc_dev), 0);
       }

       if (csr & USI_FRAME)
               cc |= TTY_FE;
       if (csr & USI_PARE)
               cc |= TTY_PE;

#if defined(DDB)
       /* ^P drops into DDB */
       if (dz_ddb && (cc == 0x10))
               Debugger();
#endif
       (*tp->t_linesw->l_rint)(cc, tp);
}

/* Transmitter Interrupt */

void
dzxint(struct dz_softc *sc, uint32_t csr)
{
       struct tty *tp;
       struct clist *cl;
       int ch;
       struct _Usart *dzr;

       dzr = sc->sc_dr;

       tp = sc->sc_dz.dz_tty;
       cl = &tp->t_outq;
       tp->t_state &= ~TS_BUSY;

       /* Just send out a char if we have one */
       if (cl->c_cc) {
               tp->t_state |= TS_BUSY;
               ch = getc(cl);
               dzr->TxData = ch;
               dzr->IntrEnable = USI_TXRDY;
               return;
       }

       /* Nothing to send; turn off intr */
       dzr->IntrDisable = USI_TXRDY;

       if (tp->t_state & TS_FLUSH)
               tp->t_state &= ~TS_FLUSH;
       else
               ndflush(&tp->t_outq, cl->c_cc);

       (*tp->t_linesw->l_start)(tp);
}

/*
* Machdep part of the driver
*/
int     dz_ebus_match(device_t, cfdata_t, void *);
void    dz_ebus_attach(device_t, device_t, void *);
int     dz_ebus_intr(void *, void *);

void    dz_ebus_cnsetup(paddr_t);
void    dz_ebus_cninit(struct consdev *);
int     dz_ebus_cngetc(dev_t);
void    dz_ebus_cnputc(dev_t, int);
void    dz_ebus_cnpollc(dev_t, int);

static int      dz_ebus_getmajor(void);

CFATTACH_DECL_NEW(dz_ebus, sizeof(struct dz_softc),
   dz_ebus_match, dz_ebus_attach, NULL, NULL);

struct consdev dz_ebus_consdev = {
       NULL, dz_ebus_cninit, dz_ebus_cngetc, dz_ebus_cnputc,
       dz_ebus_cnpollc, NULL, NULL, NULL, NODEV, CN_NORMAL,
};

/*
* Points to the console regs. Special mapping until VM is turned on.
*/
struct _Usart *dzcn;

int
dz_ebus_match(device_t parent, cfdata_t cf, void *aux)
{
       struct ebus_attach_args *iba;
       struct _Usart *us;

       iba = aux;

       if (strcmp(iba->ia_name, "dz") != 0)
               return 0;

       us = (struct _Usart *)iba->ia_vaddr;
       if ((us == NULL) ||
           (us->Tag != PMTTAG_USART))
               return 0;

       return 1;
}

void
dz_ebus_attach(device_t parent, device_t self, void *aux)
{
       struct ebus_attach_args *iba;
       struct dz_softc *sc;

       sc = device_private(self);
       iba = aux;

       sc->sc_dev = self;
       sc->sc_dr = (struct _Usart *)iba->ia_vaddr;
#if DEBUG
       printf(" virt=%p ", (void *)sc->sc_dr);
#endif

       printf(": neilsart 1 line");
       ebus_intr_establish(parent, (void *)iba->ia_cookie, IPL_TTY,
           dz_ebus_intr, sc);

       sc->sc_rxint = sc->sc_brk = 0;
       sc->sc_consline = 0;

       /* Initialize our softc structure. Should be done in open? */

       sc->sc_dz.dz_sc = sc;
       sc->sc_dz.dz_line = 0;
       sc->sc_dz.dz_tty = tty_alloc();

       evcnt_attach_dynamic(&sc->sc_rintrcnt, EVCNT_TYPE_INTR, NULL,
           device_xname(self), "rintr");
       evcnt_attach_dynamic(&sc->sc_tintrcnt, EVCNT_TYPE_INTR, NULL,
           device_xname(self), "tintr");

       /* Initialize hw regs */
#if 0
       DZ_WRITE_WORD(dr_csr, DZ_CSR_MSE | DZ_CSR_RXIE | DZ_CSR_TXIE);
       DZ_WRITE_BYTE(dr_dtr, 0);
       DZ_WRITE_BYTE(dr_break, 0);
#endif

       /* Switch the console to virtual mode */
       dzcn = sc->sc_dr;
       /* And test it */
       printf("\n");
}

static int
dz_ebus_getmajor(void)
{
       extern const struct cdevsw dz_cdevsw;
       static int cache = -1;

       if (cache != -1)
               return cache;

       return cache = cdevsw_lookup_major(&dz_cdevsw);
}

int
dz_ebus_intr(void *cookie, void *f)
{
       struct dz_softc *sc;
       struct _Usart *dzr;
       uint32_t csr;

       sc = cookie;
       dzr = sc->sc_dr;

#define USI_INTERRUPTS (USI_INTRS|USI_TXRDY)

       for (; ((csr = (dzr->ChannelStatus & dzr->IntrMask)) &
           USI_INTERRUPTS) != 0;) {
               if ((csr & USI_INTRS) != 0)
                       dzrint(sc, csr);
               if ((csr & USI_TXRDY) != 0)
                       dzxint(sc, csr);
       }

       return 0;
}

void
dz_ebus_cnsetup(paddr_t addr)
{

       dzcn = (struct _Usart *)addr;

#if 0
       /*
        * Initialize enough to xmit/recv via polling.
        * Bootloader might or might not have done it.
        */
       dzcn->Control =
           USC_RXEN |
           USC_TXEN |
           USC_BPC_8 |
           USC_NONE |
           USC_1STOP |
           USC_CLKDIV_4;
       dzcn->Baud = 0x29; /* 38400 */
#endif

       /*
        * Point the console at us
        */
       cn_tab = &dz_ebus_consdev;
       cn_tab->cn_pri = CN_NORMAL;/*CN_REMOTE?*/
       cn_tab->cn_dev = makedev(dz_ebus_getmajor(), 0);
}

void
dz_ebus_cninit(struct consdev *cn)
{
}

int
dz_ebus_cngetc(dev_t dev)
{
       int c, s;

       c = 0;
       s = spltty();

       while ((dzcn->ChannelStatus & USI_RXRDY) == 0)
               DELAY(10);
       c = dzcn->RxData;

       splx(s);
       if (c == 13) /* map cr->ln */
               c = 10;
       return c;
}

int dzflipped = 0;
void
dz_ebus_cnputc(dev_t dev, int ch)
{
       int timeout, s;

       /* Don't hang the machine! */
       timeout = 1 << 15;

       s = spltty();

#if 1
       /* Keep wired to hunt for a bug */
       if (dzcn && (dzcn != (struct _Usart *)0xfff90000)) {
               dzcn = (struct _Usart *)0xfff90000;
               dzflipped++;
       }
#endif

       /* Wait until ready */
       while ((dzcn->ChannelStatus & USI_TXRDY) == 0)
               if (--timeout < 0)
                       break;

       /* Put the character */
       dzcn->TxData = ch;

       splx(s);
}

/*
* Called before/after going into poll mode
*/
void
dz_ebus_cnpollc(dev_t dev, int on)
{
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.