sys/arch/mips/rmi/rmixl_com.c

   1 /* $Id: rmixl_com.c,v 1.2 2009/12/14 00:46:07 matt Exp $ */
   2 /*-
   3  * Copyright (c) 2006 Urbana-Champaign Independent Media Center.
   4  * Copyright (c) 2006 Garrett D'Amore.
   5  * All rights reserved.
   6  *
   7  * Portions of this code were written by Garrett D'Amore for the
   8  * Champaign-Urbana Community Wireless Network Project.
   9  *
  10  * Redistribution and use in source and binary forms, with or
  11  * without modification, are permitted provided that the following
  12  * conditions are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above
  16  *    copyright notice, this list of conditions and the following
  17  *    disclaimer in the documentation and/or other materials provided
  18  *    with the distribution.
  19  * 3. All advertising materials mentioning features or use of this
  20  *    software must display the following acknowledgements:
  21  *      This product includes software developed by the Urbana-Champaign
  22  *      Independent Media Center.
  23  *      This product includes software developed by Garrett D'Amore.
  24  * 4. Urbana-Champaign Independent Media Center's name and Garrett
  25  *    D'Amore's name may not be used to endorse or promote products
  26  *    derived from this software without specific prior written permission.
  27  *
  28  * THIS SOFTWARE IS PROVIDED BY THE URBANA-CHAMPAIGN INDEPENDENT
  29  * MEDIA CENTER AND GARRETT D'AMORE ``AS IS'' AND ANY EXPRESS OR
  30  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  31  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  32  * ARE DISCLAIMED.  IN NO EVENT SHALL THE URBANA-CHAMPAIGN INDEPENDENT
  33  * MEDIA CENTER OR GARRETT D'AMORE BE LIABLE FOR ANY DIRECT, INDIRECT,
  34  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  35  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  36  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  37  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  38  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  39  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  40  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  41  */
  42
  43 /*-
  44  * Copyright (c) 1998 The NetBSD Foundation, Inc.
  45  * All rights reserved.
  46  *
  47  * This code is derived from software contributed to The NetBSD Foundation
  48  * by Charles M. Hannum.
  49  *
  50  * Redistribution and use in source and binary forms, with or without
  51  * modification, are permitted provided that the following conditions
  52  * are met:
  53  * 1. Redistributions of source code must retain the above copyright
  54  *    notice, this list of conditions and the following disclaimer.
  55  * 2. Redistributions in binary form must reproduce the above copyright
  56  *    notice, this list of conditions and the following disclaimer in the
  57  *    documentation and/or other materials provided with the distribution.
  58  *
  59  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  60  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  61  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  62  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  63  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  64  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  65  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  66  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  67  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  68  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  69  * POSSIBILITY OF SUCH DAMAGE.
  70  */
  71
  72 /*-
  73  * Copyright (c) 1991 The Regents of the University of California.
  74  * All rights reserved.
  75  *
  76  * Redistribution and use in source and binary forms, with or without
  77  * modification, are permitted provided that the following conditions
  78  * are met:
  79  * 1. Redistributions of source code must retain the above copyright
  80  *    notice, this list of conditions and the following disclaimer.
  81  * 2. Redistributions in binary form must reproduce the above copyright
  82  *    notice, this list of conditions and the following disclaimer in the
  83  *    documentation and/or other materials provided with the distribution.
  84  * 3. Neither the name of the University nor the names of its contributors
  85  *    may be used to endorse or promote products derived from this software
  86  *    without specific prior written permission.
  87  *
  88  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  89  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  90  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  91  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  92  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  93  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  94  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  95  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  96  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  97  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  98  * SUCH DAMAGE.
  99  *
 100  *      @(#)com.c       7.5 (Berkeley) 5/16/91
 101  */
 102
 103 #include <sys/cdefs.h>
 104 __KERNEL_RCSID(0, "$NetBSD$");
 105
 106 #include <sys/param.h>
 107 #include <sys/systm.h>
 108 #include <sys/device.h>
 109 #include <sys/kernel.h>
 110 #include <sys/termios.h>
 111 #include <sys/ttydefaults.h>
 112 #include <sys/types.h>
 113
 114 #include <machine/bus.h>
 115
 116 #include <dev/cons.h>
 117 #include <dev/ic/comreg.h>
 118 #include <dev/ic/comvar.h>
 119
 120 #include <mips/cpuregs.h>
 121
 122 #include <mips/rmi/rmixl_obiovar.h>
 123 #include <mips/rmi/rmixl_comvar.h>
 124 #include <mips/rmi/rmixlvar.h>
 125
 126 #include "opt_com.h"
 127
 128 struct rmixl_com_softc {
 129         struct com_softc sc_com;
 130 };
 131
 132 static void rmixl_com_initmap(struct com_regs *);
 133 static int rmixl_com_match(device_t, cfdata_t , void *);
 134 static void rmixl_com_attach(device_t, device_t, void *);
 135
 136 CFATTACH_DECL_NEW(rmixl_com, sizeof(struct rmixl_com_softc),
 137     rmixl_com_match, rmixl_com_attach, NULL, NULL);
 138
 139 #ifndef COM_REGMAP
 140 #error  COM_REGMAP not defined!
 141 #endif
 142
 143 volatile uint32_t *com0addr = (uint32_t *)
 144         MIPS_PHYS_TO_KSEG1(RMIXL_IO_DEV_PBASE + RMIXL_IO_DEV_UART_1);
 145
 146 void
 147 rmixl_putchar_init(uint64_t io_pbase)
 148 {
 149         int rate;
 150         extern int comspeed(long, long, int);
 151
 152         com0addr = (uint32_t *)
 153                 MIPS_PHYS_TO_KSEG1(io_pbase + RMIXL_IO_DEV_UART_1);
 154
 155         if (CONSFREQ != -1) {
 156                 rate = comspeed(CONSPEED, CONSFREQ, COM_TYPE_NORMAL);
 157                 if (rate < 0)
 158                         return;                                 /* XXX */
 159
 160                 com0addr[com_ier] = 0;
 161                 com0addr[com_lctl] = htobe32(LCR_DLAB);
 162                 com0addr[com_dlbl] = htobe32(rate & 0xff);
 163                 com0addr[com_dlbh] = htobe32(rate >> 8);
 164                 com0addr[com_lctl] = htobe32(LCR_8BITS);        /* XXX */
 165                 com0addr[com_mcr]  = htobe32(MCR_DTR|MCR_RTS);
 166                 com0addr[com_fifo] = htobe32(
 167                         FIFO_ENABLE|FIFO_RCV_RST|FIFO_XMT_RST|FIFO_TRIGGER_1);
 168         }
 169 }
 170
 171
 172 void
 173 rmixl_putchar(char c)
 174 {
 175         int timo = 150000;
 176
 177         while ((be32toh(com0addr[com_lsr]) & LSR_TXRDY) == 0)
 178                 if (--timo == 0)
 179                         break;
 180
 181         com0addr[com_data] = htobe32((uint32_t)c);
 182
 183         while ((be32toh(com0addr[com_lsr]) & LSR_TSRE) == 0)
 184                 if (--timo == 0)
 185                         break;
 186 }
 187
 188 void
 189 rmixl_puts(const char *restrict s)
 190 {
 191         char c;
 192
 193         while ((c = *s++) != 0)
 194                 rmixl_putchar(c);
 195 }
 196
 197 static char hexc[] = "0123456789abcdef";
 198
 199 #define RMIXL_PUTHEX                                            \
 200         u_int shift = sizeof(val) * 8;                          \
 201         rmixl_putchar('0');                                     \
 202         rmixl_putchar('x');                                     \
 203         do {                                                    \
 204                 shift -= 4;                                     \
 205                 rmixl_putchar(hexc[(val >> shift) & 0xf]);      \
 206         } while(shift != 0)
 207
 208 void
 209 rmixl_puthex32(uint32_t val)
 210 {
 211         RMIXL_PUTHEX;
 212 }
 213
 214 void
 215 rmixl_puthex64(uint64_t val)
 216 {
 217         RMIXL_PUTHEX;
 218 }
 219
 220 int
 221 rmixl_com_match(device_t parent, cfdata_t cf, void *aux)
 222 {
 223         struct obio_attach_args *obio = aux;
 224         bus_space_tag_t bst;
 225         bus_addr_t addr;
 226         bus_size_t size;
 227         struct com_regs regs;
 228         int rv;
 229
 230         bst = obio->obio_bst;
 231         addr = obio->obio_addr;
 232         size = obio->obio_size;
 233
 234         if (com_is_console(bst, addr, &regs.cr_ioh))
 235                 return 1;
 236
 237         if (bus_space_map(bst, addr, size, 0, &regs.cr_ioh))
 238                 return 0;               /* FAIL */
 239
 240         memset(&regs, 0, sizeof(regs));
 241         regs.cr_iot = bst;
 242         regs.cr_iobase = addr;
 243         regs.cr_nports = size;
 244         rmixl_com_initmap(&regs);
 245
 246         rv = com_probe_subr(&regs);
 247
 248         bus_space_unmap(bst, regs.cr_ioh, size);
 249
 250         return rv;
 251 }
 252
 253 void
 254 rmixl_com_attach(device_t parent, device_t self, void *aux)
 255 {
 256         struct rmixl_com_softc *rsc = device_private(self);
 257         struct com_softc *sc = &rsc->sc_com;
 258         struct obio_attach_args *obio = aux;
 259         bus_space_tag_t bst;
 260         bus_space_handle_t ioh;
 261         bus_addr_t addr;
 262         bus_size_t size;
 263
 264         sc->sc_dev = self;
 265         sc->sc_frequency = CONSFREQ;
 266
 267         bst = obio->obio_bst;
 268         addr = obio->obio_addr;
 269         size = obio->obio_size;
 270
 271         if (!com_is_console(bst, addr, &ioh)
 272         &&  bus_space_map(bst, addr, size, 0, &ioh) != 0) {
 273                 aprint_error(": can't map registers\n");
 274                 return;
 275         }
 276
 277         memset(&sc->sc_regs, 0, sizeof(sc->sc_regs));
 278         COM_INIT_REGS(sc->sc_regs, bst, ioh, addr);
 279         sc->sc_regs.cr_nports = size;
 280         rmixl_com_initmap(&sc->sc_regs);
 281
 282         com_attach_subr(sc);
 283
 284         rmixl_intr_establish(obio->obio_intr, IPL_SERIAL,
 285                 RMIXL_INTR_LEVEL, RMIXL_INTR_HIGH, comintr, sc);
 286
 287 }
 288
 289 void
 290 rmixl_com_initmap(struct com_regs *regsp)
 291 {
 292         int i;
 293         int sz;
 294
 295         /*
 296          * map the 4 byte register stride
 297          */
 298         sz = sizeof(regsp->cr_map) / sizeof(regsp->cr_map[0]);
 299         for (i = 0; i < 16; i++)
 300                 regsp->cr_map[i] = com_std_map[i] * 4;
 301 }
 302
 303 void
 304 rmixl_com_cnattach(bus_addr_t addr, int speed, int freq,
 305         int type, tcflag_t mode)
 306 {
 307         bus_space_tag_t bst;
 308         bus_size_t sz;
 309         struct com_regs regs;
 310
 311         bst = (bus_space_tag_t)&rmixl_configuration.rc_obio_memt;
 312         sz = COM_NPORTS * sizeof(uint32_t);     /* span of UART regs in bytes */
 313
 314         memset(&regs, 0, sizeof(regs));
 315         rmixl_com_initmap(&regs);
 316         regs.cr_iot = bst;
 317         regs.cr_iobase = addr;
 318         regs.cr_nports = sz;
 319
 320         comcnattach1(&regs, speed, freq, type, mode);
 321 }