sys/arch/hpcmips/dev/com_hpcio.c

   1 /*      $NetBSD: com_hpcio.c,v 1.10 2006/07/13 22:56:01 gdamore Exp $   */
   2
   3 /*-
   4  * Copyright (c) 2002 TAKEMRUA Shin. 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  * 3. Neither the name of the project nor the names of its contributors
  15  *    may be used to endorse or promote products derived from this software
  16  *    without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  *
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __KERNEL_RCSID(0, "$NetBSD: com_hpcio.c,v 1.10 2006/07/13 22:56:01 gdamore Exp $");
  34
  35 #include "opt_kgdb.h"
  36
  37 #include <sys/param.h>
  38 #include <sys/systm.h>
  39 #include <sys/device.h>
  40 #include <sys/reboot.h>
  41 #include <sys/termios.h>
  42
  43 #include <machine/intr.h>
  44 #include <machine/bus.h>
  45 #include <machine/platid.h>
  46 #include <machine/platid_mask.h>
  47
  48 #include <hpcmips/dev/com_hpciovar.h>
  49
  50 #include <dev/hpc/hpciovar.h>
  51 #include <dev/ic/comvar.h>
  52 #include <dev/ic/comreg.h>
  53
  54 #include "locators.h"
  55
  56 #define COM_HPCIODEBUG
  57 #ifdef COM_HPCIODEBUG
  58 int     com_hpcio_debug = 0;
  59 #define DPRINTF(arg...) do { if (com_hpcio_debug) printf(arg); } while (0)
  60 #else
  61 #define DPRINTF(arg...) do {} while (0)
  62 #endif
  63
  64 /*
  65  * XXX: NOTE: With the new com(4) COM_REGMAP support, the custom bus_space
  66  * in this file could/should probably be removed and replaced with a custom
  67  * map.  Resulting in smaller/cleaner code.  An hpcmips hacker should fix
  68  * this, since I don't have h/w to test with -- I'm taking the route of least
  69  * risk.        - gdamore
  70  */
  71
  72 #define COM_HPCIO_BYTE_ALIGNMENT        0
  73 #define COM_HPCIO_HALFWORD_ALIGNMENT    1
  74
  75 struct com_hpcio_softc {
  76         struct com_softc        hsc_com;
  77         struct bus_space_tag    hsc_iot;
  78         struct hpcio_chip       *hsc_hc;
  79 };
  80 static struct bus_space_tag com_hpcio_cniotx;
  81 static bus_space_tag_t com_hpcio_cniot = &com_hpcio_cniotx;
  82 static int com_hpcio_cniobase;
  83
  84 static int com_hpcio_probe(device_t, cfdata_t , void *);
  85 static void com_hpcio_attach(device_t, device_t, void *);
  86 static int com_hpcio_common_probe(bus_space_tag_t, int, int *);
  87 void com_hpcio_iot_init(bus_space_tag_t iot, bus_space_tag_t base);
  88 bus_space_protos(bs_notimpl);
  89 bus_space_protos(bs_through);
  90 bus_space_protos(com_hpcio);
  91
  92 CFATTACH_DECL_NEW(com_hpcio, sizeof(struct com_hpcio_softc),
  93     com_hpcio_probe, com_hpcio_attach, NULL, NULL);
  94
  95 struct bus_space_ops com_hpcio_bs_ops = {
  96         /* mapping/unmapping */
  97         bs_through_bs_map,
  98         bs_through_bs_unmap,
  99         bs_through_bs_subregion,
 100
 101         /* allocation/deallocation */
 102         bs_through_bs_alloc,
 103         bs_through_bs_free,
 104
 105         /* get kernel virtual address */
 106         bs_through_bs_vaddr, /* there is no linear mapping */
 107
 108         /* Mmap bus space for user */
 109         bs_through_bs_mmap,
 110
 111         /* barrier */
 112         bs_through_bs_barrier,
 113
 114         /* probe */
 115         bs_through_bs_peek,
 116         bs_through_bs_poke,
 117
 118         /* read (single) */
 119         com_hpcio_bs_r_1,
 120         bs_notimpl_bs_r_2,
 121         bs_notimpl_bs_r_4,
 122         bs_notimpl_bs_r_8,
 123
 124         /* read multiple */
 125         bs_notimpl_bs_rm_1,
 126         bs_notimpl_bs_rm_2,
 127         bs_notimpl_bs_rm_4,
 128         bs_notimpl_bs_rm_8,
 129
 130         /* read region */
 131         bs_notimpl_bs_rr_1,
 132         bs_notimpl_bs_rr_2,
 133         bs_notimpl_bs_rr_4,
 134         bs_notimpl_bs_rr_8,
 135
 136         /* write (single) */
 137         com_hpcio_bs_w_1,
 138         bs_notimpl_bs_w_2,
 139         bs_notimpl_bs_w_4,
 140         bs_notimpl_bs_w_8,
 141
 142         /* write multiple */
 143         com_hpcio_bs_wm_1,
 144         bs_notimpl_bs_wm_2,
 145         bs_notimpl_bs_wm_4,
 146         bs_notimpl_bs_wm_8,
 147
 148         /* write region */
 149         bs_notimpl_bs_wr_1,
 150         bs_notimpl_bs_wr_2,
 151         bs_notimpl_bs_wr_4,
 152         bs_notimpl_bs_wr_8,
 153
 154 #ifdef BUS_SPACE_HAS_REAL_STREAM_METHODS
 155         /* read stream (single) */
 156         bs_notimpl_bs_rs_1,
 157         bs_notimpl_bs_rs_2,
 158         bs_notimpl_bs_rs_4,
 159         bs_notimpl_bs_rs_8,
 160
 161         /* read multiple stream */
 162         bs_notimpl_bs_rms_1,
 163         bs_notimpl_bs_rms_2,
 164         bs_notimpl_bs_rms_4,
 165         bs_notimpl_bs_rms_8,
 166
 167         /* read region stream */
 168         bs_notimpl_bs_rrs_1,
 169         bs_notimpl_bs_rrs_2,
 170         bs_notimpl_bs_rrs_4,
 171         bs_notimpl_bs_rrs_8,
 172
 173         /* write stream (single) */
 174         bs_notimpl_bs_ws_1,
 175         bs_notimpl_bs_ws_2,
 176         bs_notimpl_bs_ws_4,
 177         bs_notimpl_bs_ws_8,
 178
 179         /* write multiple stream */
 180         bs_notimpl_bs_wms_1,
 181         bs_notimpl_bs_wms_2,
 182         bs_notimpl_bs_wms_4,
 183         bs_notimpl_bs_wms_8,
 184
 185         /* write region stream */
 186         bs_notimpl_bs_wrs_1,
 187         bs_notimpl_bs_wrs_2,
 188         bs_notimpl_bs_wrs_4,
 189         bs_notimpl_bs_wrs_8,
 190 #endif /* BUS_SPACE_HAS_REAL_STREAM_METHODS */
 191
 192         /* set multi */
 193         bs_notimpl_bs_sm_1,
 194         bs_notimpl_bs_sm_2,
 195         bs_notimpl_bs_sm_4,
 196         bs_notimpl_bs_sm_8,
 197
 198         /* set region */
 199         bs_notimpl_bs_sr_1,
 200         bs_notimpl_bs_sr_2,
 201         bs_notimpl_bs_sr_4,
 202         bs_notimpl_bs_sr_8,
 203
 204         /* copy */
 205         bs_notimpl_bs_c_1,
 206         bs_notimpl_bs_c_2,
 207         bs_notimpl_bs_c_4,
 208         bs_notimpl_bs_c_8,
 209 };
 210
 211 int
 212 com_hpcio_cndb_attach(bus_space_tag_t iot, int iobase, int rate,
 213     int frequency, tcflag_t cflag, int kgdb)
 214 {
 215         int alignment;
 216
 217         DPRINTF("com_hpcio_cndb_attach()\n");
 218         if (!com_hpcio_common_probe(iot, iobase, &alignment)) {
 219                 DPRINTF("com_hpcio_cndb_attach(): probe failed\n");
 220                 return (ENOTTY);
 221         }
 222         if (alignment == COM_HPCIO_HALFWORD_ALIGNMENT) {
 223                 DPRINTF("com_hpcio_cndb_attach(): half word aligned\n");
 224                 com_hpcio_iot_init(&com_hpcio_cniotx, iot);
 225                 com_hpcio_cniot = &com_hpcio_cniotx;
 226         } else {
 227                 com_hpcio_cniot = iot;
 228         }
 229         com_hpcio_cniobase = iobase;
 230         DPRINTF("com_hpcio_cndb_attach(): probe succeeded\n");
 231 #ifdef KGDB
 232         if (kgdb)
 233                 return (com_kgdb_attach(com_hpcio_cniot, iobase, rate,
 234                     frequency, COM_TYPE_NORMAL, cflag));
 235         else
 236 #endif
 237                 return (comcnattach(com_hpcio_cniot, iobase, rate,
 238                     frequency, COM_TYPE_NORMAL, cflag));
 239 }
 240
 241 static int
 242 com_hpcio_common_probe(bus_space_tag_t iot, int iobase, int *alignment)
 243 {
 244         bus_space_handle_t ioh;
 245         static struct bus_space_tag tmpiot;
 246         int rv;
 247
 248         /*
 249          * try byte aligned register
 250          */
 251         *alignment = COM_HPCIO_BYTE_ALIGNMENT;
 252         if (bus_space_map(iot, iobase, 1, 0, &ioh))
 253                 return 0;
 254         rv = comprobe1(iot, ioh);
 255         bus_space_unmap(iot, ioh, 1);
 256
 257         if (rv != 0)
 258                 return (rv);
 259
 260         /*
 261          * try half word aligned register
 262          */
 263         *alignment = COM_HPCIO_HALFWORD_ALIGNMENT;
 264         com_hpcio_iot_init(&tmpiot, iot);
 265         if (bus_space_map(&tmpiot, iobase, 1, 0, &ioh))
 266                 return 0;
 267         rv = comprobe1(&tmpiot, ioh);
 268         bus_space_unmap(&tmpiot, ioh, 1);
 269
 270         return (rv);
 271 }
 272
 273 static int
 274 com_hpcio_probe(device_t parent, cfdata_t cf, void *aux)
 275 {
 276         struct hpcio_attach_args *haa = aux;
 277         bus_space_tag_t iot = haa->haa_iot;
 278         int addr, alignment;
 279
 280         if (cf->cf_loc[HPCIOIFCF_PLATFORM] != HPCIOIFCF_PLATFORM_DEFAULT) {
 281                 platid_mask_t mask;
 282
 283                 mask = PLATID_DEREF(cf->cf_loc[HPCIOIFCF_PLATFORM]);
 284                 if (!platid_match(&platid, &mask))
 285                         return (0); /* platform id didn't match */
 286         }
 287
 288         if ((addr = cf->cf_loc[HPCIOIFCF_ADDR]) == HPCIOIFCF_ADDR_DEFAULT)
 289                 return (0); /* address wasn't specified */
 290
 291         return com_hpcio_common_probe(iot, addr, &alignment);
 292 }
 293
 294
 295 static void
 296 com_hpcio_attach(device_t parent, device_t self, void *aux)
 297 {
 298         struct com_hpcio_softc *hsc = device_private(self);
 299         struct com_softc *sc = &hsc->hsc_com;
 300         struct hpcio_attach_args *haa = aux;
 301         bus_space_tag_t iot;
 302         bus_space_handle_t ioh;
 303         int addr, port, mode, alignment, *loc;
 304
 305         sc->sc_dev = self;
 306         loc = device_cfdata(sc->sc_dev)->cf_loc;
 307         addr = loc[HPCIOIFCF_ADDR];
 308         aprint_normal(" addr %x", addr);
 309         if ((com_hpcio_cniot == haa->haa_iot ||
 310             com_hpcio_cniot->bs_base == haa->haa_iot) &&
 311             com_hpcio_cniobase == addr &&
 312             com_is_console(com_hpcio_cniot, addr, 0)) {
 313                 iot = com_hpcio_cniot;
 314                 if (com_hpcio_cniot->bs_base == haa->haa_iot)
 315                         aprint_normal(", half word aligned");
 316         } else {
 317                 com_hpcio_common_probe(haa->haa_iot, addr, &alignment);
 318                 if (alignment == COM_HPCIO_HALFWORD_ALIGNMENT) {
 319                         aprint_normal(", half word aligned");
 320                         iot = &hsc->hsc_iot;
 321                         com_hpcio_iot_init(iot, haa->haa_iot);
 322                 } else {
 323                         iot = haa->haa_iot;
 324                 }
 325         }
 326         if (bus_space_map(iot, addr, 1, 0, &ioh)) {
 327                 aprint_error(": can't map bus space\n");
 328                 return;
 329         }
 330         COM_INIT_REGS(sc->sc_regs, iot, ioh, addr);
 331
 332         sc->enable = NULL;
 333         sc->disable = NULL;
 334
 335         sc->sc_frequency = COM_FREQ;
 336         com_attach_subr(sc);
 337
 338         hsc->hsc_hc = (*haa->haa_getchip)(haa->haa_sc, loc[HPCIOIFCF_IOCHIP]);
 339         port = loc[HPCIOIFCF_PORT];
 340         mode = HPCIO_INTR_LEVEL | HPCIO_INTR_HIGH;
 341         hpcio_intr_establish(hsc->hsc_hc, port, mode, comintr, sc);
 342 }
 343
 344 /*
 345  * bus stuff (registershalf word aligned)
 346  */
 347 void
 348 com_hpcio_iot_init(bus_space_tag_t iot, bus_space_tag_t base)
 349 {
 350
 351         iot->bs_base = base;
 352         iot->bs_ops = com_hpcio_bs_ops; /* structure assignment */
 353         iot->bs_ops.bs_r_1 = com_hpcio_bs_r_1;
 354         iot->bs_ops.bs_w_1 = com_hpcio_bs_w_1;
 355         iot->bs_ops.bs_wm_1 = com_hpcio_bs_wm_1;
 356 }
 357
 358 u_int8_t
 359 com_hpcio_bs_r_1(bus_space_tag_t t, bus_space_handle_t bsh,
 360     bus_size_t offset)
 361 {
 362         return bus_space_read_1(t->bs_base, bsh, offset * 2);
 363 }
 364
 365 void
 366 com_hpcio_bs_w_1(bus_space_tag_t t, bus_space_handle_t bsh,
 367     bus_size_t offset, u_int8_t value)
 368 {
 369         bus_space_write_1(t->bs_base, bsh, offset * 2, value);
 370 }
 371
 372 void
 373 com_hpcio_bs_wm_1(bus_space_tag_t t, bus_space_handle_t bsh,
 374     bus_size_t offset, const u_int8_t *addr, bus_size_t count)
 375 {
 376         bus_space_write_multi_1(t->bs_base, bsh, offset * 2, addr, count);
 377 }