root/dev/ic/com_subr.c

DEFINITIONS

1. com_enable_debugport
2. com_attach_subr
3. com_fifo_probe

    1 /*      $OpenBSD: com_subr.c,v 1.10 2007/03/20 17:37:34 deraadt Exp $   */
    3 /*
    4  * Copyright (c) 1997 - 1999, Jason Downs.  All rights reserved.
    5  *
    6  * Redistribution and use in source and binary forms, with or without
    7  * modification, are permitted provided that the following conditions
    8  * are met:
    9  * 1. Redistributions of source code must retain the above copyright
   10  *    notice, this list of conditions and the following disclaimer.
   11  * 2. Redistributions in binary form must reproduce the above copyright
   12  *    notice, this list of conditions and the following disclaimer in the
   13  *    documentation and/or other materials provided with the distribution.
   14  *
   15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS
   16  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
   17  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   18  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT,
   19  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   20  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
   21  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
   22  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   25  * SUCH DAMAGE.
   26  */
   27 /*-
   28  * Copyright (c) 1993, 1994, 1995, 1996
   29  *      Charles M. Hannum.  All rights reserved.
   30  * Copyright (c) 1991 The Regents of the University of California.
   31  * All rights reserved.
   32  *
   33  * Redistribution and use in source and binary forms, with or without
   34  * modification, are permitted provided that the following conditions
   35  * are met:
   36  * 1. Redistributions of source code must retain the above copyright
   37  *    notice, this list of conditions and the following disclaimer.
   38  * 2. Redistributions in binary form must reproduce the above copyright
   39  *    notice, this list of conditions and the following disclaimer in the
   40  *    documentation and/or other materials provided with the distribution.
   41  * 3. Neither the name of the University nor the names of its contributors
   42  *    may be used to endorse or promote products derived from this software
   43  *    without specific prior written permission.
   44  *
   45  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   46  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   47  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   48  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   49  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   50  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   51  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   52  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   53  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   54  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   55  * SUCH DAMAGE.
   56  *
   57  *      @(#)com.c       7.5 (Berkeley) 5/16/91
   58  */
   60 /*
   61  * COM driver, based on HP dca driver
   62  * uses National Semiconductor NS16450/NS16550AF UART
   63  */
   64 #include <sys/param.h>
   65 #include <sys/systm.h>
   66 #include <sys/kernel.h>
   67 #include <sys/device.h>
   68 #include <sys/tty.h>
   70 #include "com.h"
   71 #ifdef i386
   72 #include "pccom.h"
   73 #else
   74 #define NPCCOM  0
   75 #endif
   77 #include <machine/bus.h>
   78 #if defined(__sparc64__) || !defined(__sparc__)
   79 #include <machine/intr.h>
   80 #endif
   82 #if !defined(__sparc__) || defined(__sparc64__)
   83 #define COM_CONSOLE
   84 #include <dev/cons.h>
   85 #endif
   87 #include <dev/ic/comreg.h>
   88 #include <dev/ic/ns16550reg.h>
   89 #define com_lcr com_cfcr
   91 #if NCOM > 0
   92 #include <dev/ic/comvar.h>
   93 #endif
   94 #if NPCCOM > 0
   95 #include <i386/isa/pccomvar.h>
   96 #endif
   98 #ifdef COM_PXA2X0
   99 #define com_isr 8
  100 #define ISR_SEND        (ISR_RXPL | ISR_XMODE | ISR_XMITIR)
  101 #define ISR_RECV        (ISR_RXPL | ISR_XMODE | ISR_RCVEIR)
  102 #endif
  104 #ifdef  COM_CONSOLE
  105 #include <sys/conf.h>
cdev_decl(com);
  107 #endif
  109 void    com_enable_debugport(struct com_softc *);
  110 void    com_fifo_probe(struct com_softc *);
  112 #if defined(COM_CONSOLE) || defined(KGDB)
  113 void
com_enable_debugport(sc)
  115         struct com_softc *sc;
  116 {
  117         int s;
  119         /* Turn on line break interrupt, set carrier. */
s = splhigh();
  121 #ifdef KGDB
SET(sc->sc_ier, IER_ERXRDY);
  123 #ifdef COM_PXA2X0
  124         if (sc->sc_uarttype == COM_UART_PXA2X0)
sc->sc_ier |= IER_EUART | IER_ERXTOUT;
  126 #endif
bus_space_write_1(sc->sc_iot, sc->sc_ioh, com_ier, sc->sc_ier);
  128 #endif
SET(sc->sc_mcr, MCR_DTR | MCR_RTS | MCR_IENABLE);
bus_space_write_1(sc->sc_iot, sc->sc_ioh, com_mcr, sc->sc_mcr);
splx(s);
  133 }
  134 #endif  /* COM_CONSOLED || KGDB */
  136 void
com_attach_subr(sc)
  138         struct com_softc *sc;
  139 {
bus_space_tag_t iot = sc->sc_iot;
bus_space_handle_t ioh = sc->sc_ioh;
u_int8_t lcr;
sc->sc_ier = 0;
  145 #ifdef COM_PXA2X0
  146         if (sc->sc_uarttype == COM_UART_PXA2X0)
sc->sc_ier |= IER_EUART;
  148 #endif
  149         /* disable interrupts */
bus_space_write_1(iot, ioh, com_ier, sc->sc_ier);
  152 #ifdef COM_CONSOLE
  153         if (sc->sc_iobase == comconsaddr) {
comconsattached = 1;
delay(10000);                   /* wait for output to finish */
SET(sc->sc_hwflags, COM_HW_CONSOLE);
SET(sc->sc_swflags, COM_SW_SOFTCAR);
  158         }
  159 #endif
  161         /*
  162          * Probe for all known forms of UART.
  163          */
lcr = bus_space_read_1(iot, ioh, com_lcr);
bus_space_write_1(iot, ioh, com_lcr, LCR_EFR);
bus_space_write_1(iot, ioh, com_efr, 0);
bus_space_write_1(iot, ioh, com_lcr, 0);
bus_space_write_1(iot, ioh, com_fifo, FIFO_ENABLE);
delay(100);
  172         /*
  173          * Skip specific probes if attachment code knows it already.
  174          */
  175         if (sc->sc_uarttype == COM_UART_UNKNOWN)
  176                 switch (bus_space_read_1(iot, ioh, com_iir) >> 6) {
  177                 case 0:
sc->sc_uarttype = COM_UART_16450;
  179                         break;
  180                 case 2:
sc->sc_uarttype = COM_UART_16550;
  182                         break;
  183                 case 3:
sc->sc_uarttype = COM_UART_16550A;
  185                         break;
  186                 default:
sc->sc_uarttype = COM_UART_UNKNOWN;
  188                         break;
  189                 }
  191         if (sc->sc_uarttype == COM_UART_16550A) { /* Probe for ST16650s */
bus_space_write_1(iot, ioh, com_lcr, lcr | LCR_DLAB);
  193                 if (bus_space_read_1(iot, ioh, com_efr) == 0) {
sc->sc_uarttype = COM_UART_ST16650;
  195                 } else {
bus_space_write_1(iot, ioh, com_lcr, LCR_EFR);
  197                         if (bus_space_read_1(iot, ioh, com_efr) == 0)
sc->sc_uarttype = COM_UART_ST16650V2;
  199                 }
  200         }
  202 #if NPCCOM > 0  /* until com works with large FIFOs */
  203         if (sc->sc_uarttype == COM_UART_ST16650V2) { /* Probe for XR16850s */
u_int8_t dlbl, dlbh;
  206                 /* Enable latch access and get the current values. */
bus_space_write_1(iot, ioh, com_lcr, lcr | LCR_DLAB);
dlbl = bus_space_read_1(iot, ioh, com_dlbl);
dlbh = bus_space_read_1(iot, ioh, com_dlbh);
  211                 /* Zero out the latch divisors */
bus_space_write_1(iot, ioh, com_dlbl, 0);
bus_space_write_1(iot, ioh, com_dlbh, 0);
  215                 if (bus_space_read_1(iot, ioh, com_dlbh) == 0x10) {
sc->sc_uarttype = COM_UART_XR16850;
sc->sc_uartrev = bus_space_read_1(iot, ioh, com_dlbl);
  218                 }
  220                 /* Reset to original. */
bus_space_write_1(iot, ioh, com_dlbl, dlbl);
bus_space_write_1(iot, ioh, com_dlbh, dlbh);
  223         }
  224 #endif
  226         if (sc->sc_uarttype == COM_UART_16550A) { /* Probe for TI16750s */
bus_space_write_1(iot, ioh, com_lcr, lcr | LCR_DLAB);
bus_space_write_1(iot, ioh, com_fifo,
FIFO_ENABLE | FIFO_ENABLE_64BYTE);
  230                 if ((bus_space_read_1(iot, ioh, com_iir) >> 5) == 7) {
  231 #if 0
bus_space_write_1(iot, ioh, com_lcr, 0);
  233                         if ((bus_space_read_1(iot, ioh, com_iir) >> 5) == 6)
  234 #endif
sc->sc_uarttype = COM_UART_TI16750;
  236                 }
bus_space_write_1(iot, ioh, com_fifo, FIFO_ENABLE);
  238         }
  240         /* Reset the LCR (latch access is probably enabled). */
bus_space_write_1(iot, ioh, com_lcr, lcr);
  242         if (sc->sc_uarttype == COM_UART_16450) { /* Probe for 8250 */
u_int8_t scr0, scr1, scr2;
scr0 = bus_space_read_1(iot, ioh, com_scratch);
bus_space_write_1(iot, ioh, com_scratch, 0xa5);
scr1 = bus_space_read_1(iot, ioh, com_scratch);
bus_space_write_1(iot, ioh, com_scratch, 0x5a);
scr2 = bus_space_read_1(iot, ioh, com_scratch);
bus_space_write_1(iot, ioh, com_scratch, scr0);
  252                 if ((scr1 != 0xa5) || (scr2 != 0x5a))
sc->sc_uarttype = COM_UART_8250;
  254         }
  256         /*
  257          * Print UART type and initialize ourself.
  258          */
  259         switch (sc->sc_uarttype) {
  260         case COM_UART_UNKNOWN:
printf(": unknown uart\n");
  262                 break;
  263         case COM_UART_8250:
printf(": ns8250, no fifo\n");
  265                 break;
  266         case COM_UART_16450:
printf(": ns16450, no fifo\n");
  268                 break;
  269         case COM_UART_16550:
printf(": ns16550, no working fifo\n");
  271                 break;
  272         case COM_UART_16550A:
  273                 if (sc->sc_fifolen == 0)
sc->sc_fifolen = 16;
printf(": ns16550a, %d byte fifo\n", sc->sc_fifolen);
SET(sc->sc_hwflags, COM_HW_FIFO);
  277                 break;
  278 #ifdef COM_PXA2X0
  279         case COM_UART_PXA2X0:
printf(": pxa2x0, 32 byte fifo");
SET(sc->sc_hwflags, COM_HW_FIFO);
sc->sc_fifolen = 32;
  283                 if (sc->sc_iobase == comsiraddr) {
SET(sc->sc_hwflags, COM_HW_SIR);
printf(" (SIR)");
  286                 }
printf("\n");
  288                 break;
  289 #endif
  290         case COM_UART_ST16650:
printf(": st16650, no working fifo\n");
  292                 break;
  293         case COM_UART_ST16650V2:
  294                 if (sc->sc_fifolen == 0)
sc->sc_fifolen = 32;
printf(": st16650, %d byte fifo\n", sc->sc_fifolen);
SET(sc->sc_hwflags, COM_HW_FIFO);
  298                 break;
  299         case COM_UART_ST16C654:
printf(": st16c654, 64 byte fifo\n");
SET(sc->sc_hwflags, COM_HW_FIFO);
sc->sc_fifolen = 64;
  303                 break;
  304         case COM_UART_TI16750:
printf(": ti16750, 64 byte fifo\n");
SET(sc->sc_hwflags, COM_HW_FIFO);
sc->sc_fifolen = 64;
  308                 break;
  309 #if NPCCOM > 0
  310         case COM_UART_XR16850:
printf(": xr16850 (rev %d), 128 byte fifo\n", sc->sc_uartrev);
SET(sc->sc_hwflags, COM_HW_FIFO);
sc->sc_fifolen = 128;
  314                 break;
  315 #ifdef COM_UART_OX16C950
  316         case COM_UART_OX16C950:
printf(": ox16c950 (rev %d), 128 byte fifo\n", sc->sc_uartrev);
SET(sc->sc_hwflags, COM_HW_FIFO);
sc->sc_fifolen = 128;
  320                 break;
  321 #endif
  322 #endif
  323         default:
panic("comattach: bad fifo type");
  325         }
  327 #ifdef notyet
com_fifo_probe(sc);
  329 #endif
  331         if (sc->sc_fifolen == 0) {
CLR(sc->sc_hwflags, COM_HW_FIFO);
sc->sc_fifolen = 1;
  334         }
  336         /* clear and disable fifo */
bus_space_write_1(iot, ioh, com_fifo, FIFO_RCV_RST | FIFO_XMT_RST);
  338         (void)bus_space_read_1(iot, ioh, com_data);
bus_space_write_1(iot, ioh, com_fifo, 0);
sc->sc_mcr = 0;
bus_space_write_1(iot, ioh, com_mcr, sc->sc_mcr);
  344 #ifdef KGDB
  345         /*
  346          * Allow kgdb to "take over" this port.  If this is
  347          * the kgdb device, it has exclusive use.
  348          */
  350         if (iot == com_kgdb_iot && sc->sc_iobase == com_kgdb_addr &&
  351             !ISSET(sc->sc_hwflags, COM_HW_CONSOLE)) {
printf("%s: kgdb\n", sc->sc_dev.dv_xname);
SET(sc->sc_hwflags, COM_HW_KGDB);
  354         }
  355 #endif /* KGDB */
  357 #ifdef COM_CONSOLE
  358         if (ISSET(sc->sc_hwflags, COM_HW_CONSOLE)) {
  359                 int maj;
  361                 /* locate the major number */
  362                 for (maj = 0; maj < nchrdev; maj++)
  363                         if (cdevsw[maj].d_open == comopen)
  364                                 break;
  366                 if (maj < nchrdev && cn_tab->cn_dev == NODEV)
cn_tab->cn_dev = makedev(maj, sc->sc_dev.dv_unit);
printf("%s: console\n", sc->sc_dev.dv_xname);
  370         }
  371 #endif
timeout_set(&sc->sc_diag_tmo, comdiag, sc);
timeout_set(&sc->sc_dtr_tmo, com_raisedtr, sc);
  375 #if NCOM > 0
  376 #ifdef __HAVE_GENERIC_SOFT_INTERRUPTS
sc->sc_si = softintr_establish(IPL_TTY, comsoft, sc);
  378         if (sc->sc_si == NULL)
panic("%s: can't establish soft interrupt",
sc->sc_dev.dv_xname);
  381 #else
timeout_set(&sc->sc_comsoft_tmo, comsoft, sc);
  383 #endif
  384 #endif  /* NCOM */
  386         /*
  387          * If there are no enable/disable functions, assume the device
  388          * is always enabled.
  389          */
  390         if (!sc->enable)
sc->enabled = 1;
  393 #if defined(COM_CONSOLE) || defined(KGDB)
  394         if (ISSET(sc->sc_hwflags, COM_HW_CONSOLE|COM_HW_KGDB))
com_enable_debugport(sc);
  396 #endif
  397 }
  399 void
com_fifo_probe(struct com_softc *sc)
  401 {
bus_space_handle_t ioh = sc->sc_ioh;
bus_space_tag_t iot = sc->sc_iot;
u_int8_t fifo, ier;
  405         int timo, len;
  407         if (!ISSET(sc->sc_hwflags, COM_HW_FIFO))
  408                 return;
ier = 0;
  411 #ifdef COM_PXA2X0
  412         if (sc->sc_uarttype == COM_UART_PXA2X0)
ier |= IER_EUART;
  414 #endif
bus_space_write_1(iot, ioh, com_ier, ier);
bus_space_write_1(iot, ioh, com_lcr, LCR_DLAB);
bus_space_write_1(iot, ioh, com_dlbl, 3);
bus_space_write_1(iot, ioh, com_dlbh, 0);
bus_space_write_1(iot, ioh, com_lcr, LCR_PNONE | LCR_8BITS);
bus_space_write_1(iot, ioh, com_mcr, MCR_LOOPBACK);
fifo = FIFO_ENABLE | FIFO_RCV_RST | FIFO_XMT_RST;
  423         if (sc->sc_uarttype == COM_UART_TI16750)
fifo |= FIFO_ENABLE_64BYTE;
bus_space_write_1(iot, ioh, com_fifo, fifo);
  428         for (len = 0; len < 256; len++) {
bus_space_write_1(iot, ioh, com_data, (len + 1));
timo = 2000;
  431                 while (!ISSET(bus_space_read_1(iot, ioh, com_lsr),
LSR_TXRDY) && --timo)
delay(1);
  434                 if (!timo)
  435                         break;
  436         }
delay(100);
  440         for (len = 0; len < 256; len++) {
timo = 2000;
  442                 while (!ISSET(bus_space_read_1(iot, ioh, com_lsr),
LSR_RXRDY) && --timo)
delay(1);
  445                 if (!timo || bus_space_read_1(iot, ioh, com_data) != (len + 1))
  446                         break;
  447         }
  449         /* For safety, always use the smaller value. */
  450         if (sc->sc_fifolen > len) {
printf("%s: probed fifo depth: %d bytes\n",
sc->sc_dev.dv_xname, len);
sc->sc_fifolen = len;
  454         }
  455 }