sys/dev/eisa/uha_eisa.c

   1 /*      $NetBSD: uha_eisa.c,v 1.32 2009/11/23 02:13:45 rmind Exp $      */
   2
   3 /*-
   4  * Copyright (c) 1998 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Charles M. Hannum.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * 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 copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __KERNEL_RCSID(0, "$NetBSD: uha_eisa.c,v 1.32 2009/11/23 02:13:45 rmind Exp $");
  34
  35 #include "opt_ddb.h"
  36
  37 #include <sys/param.h>
  38 #include <sys/systm.h>
  39 #include <sys/device.h>
  40 #include <sys/kernel.h>
  41 #include <sys/proc.h>
  42
  43 #include <sys/bus.h>
  44 #include <sys/intr.h>
  45
  46 #include <dev/scsipi/scsi_all.h>
  47 #include <dev/scsipi/scsipi_all.h>
  48 #include <dev/scsipi/scsiconf.h>
  49
  50 #include <dev/eisa/eisavar.h>
  51 #include <dev/eisa/eisadevs.h>
  52
  53 #include <dev/ic/uhareg.h>
  54 #include <dev/ic/uhavar.h>
  55
  56 #define UHA_EISA_SLOT_OFFSET    0xc80
  57 #define UHA_EISA_IOSIZE         0x020
  58
  59 static int      uha_eisa_match(device_t, cfdata_t, void *);
  60 static void     uha_eisa_attach(device_t, device_t, void *);
  61
  62 CFATTACH_DECL(uha_eisa, sizeof(struct uha_softc),
  63     uha_eisa_match, uha_eisa_attach, NULL, NULL);
  64
  65 #ifndef DDB
  66 #define Debugger() panic("should call debugger here (uha_eisa.c)")
  67 #endif /* ! DDB */
  68
  69 static int      u24_find(bus_space_tag_t, bus_space_handle_t,
  70                     struct uha_probe_data *);
  71 static void     u24_start_mbox(struct uha_softc *, struct uha_mscp *);
  72 static int      u24_poll(struct uha_softc *, struct scsipi_xfer *, int);
  73 static int      u24_intr(void *);
  74 static void     u24_init(struct uha_softc *);
  75
  76 /*
  77  * Check the slots looking for a board we recognise
  78  * If we find one, note it's address (slot) and call
  79  * the actual probe routine to check it out.
  80  */
  81 static int
  82 uha_eisa_match(device_t parent, cfdata_t match,
  83     void *aux)
  84 {
  85         struct eisa_attach_args *ea = aux;
  86         bus_space_tag_t iot = ea->ea_iot;
  87         bus_space_handle_t ioh;
  88         int rv;
  89
  90         /* must match one of our known ID strings */
  91         if (strncmp(ea->ea_idstring, "USC024", 6))
  92                 return (0);
  93
  94         if (bus_space_map(iot, EISA_SLOT_ADDR(ea->ea_slot) +
  95             UHA_EISA_SLOT_OFFSET, UHA_EISA_IOSIZE, 0, &ioh))
  96                 return (0);
  97
  98         rv = u24_find(iot, ioh, NULL);
  99
 100         bus_space_unmap(iot, ioh, UHA_EISA_IOSIZE);
 101
 102         return (rv);
 103 }
 104
 105 /*
 106  * Attach all the sub-devices we can find
 107  */
 108 static void
 109 uha_eisa_attach(device_t parent, device_t self, void *aux)
 110 {
 111         struct eisa_attach_args *ea = aux;
 112         struct uha_softc *sc = device_private(self);
 113         bus_space_tag_t iot = ea->ea_iot;
 114         bus_dma_tag_t dmat = ea->ea_dmat;
 115         bus_space_handle_t ioh;
 116         struct uha_probe_data upd;
 117         eisa_chipset_tag_t ec = ea->ea_ec;
 118         eisa_intr_handle_t ih;
 119         const char *model, *intrstr;
 120
 121         if (!strncmp(ea->ea_idstring, "USC024", 6))
 122                 model = EISA_PRODUCT_USC0240;
 123         else
 124                 model = "unknown model!";
 125         printf(": %s\n", model);
 126
 127         if (bus_space_map(iot, EISA_SLOT_ADDR(ea->ea_slot) +
 128             UHA_EISA_SLOT_OFFSET, UHA_EISA_IOSIZE, 0, &ioh))
 129                 panic("uha_eisa_attach: could not map I/O addresses");
 130
 131         sc->sc_iot = iot;
 132         sc->sc_ioh = ioh;
 133         sc->sc_dmat = dmat;
 134         if (!u24_find(iot, ioh, &upd))
 135                 panic("uha_eisa_attach: u24_find failed!");
 136
 137         sc->sc_dmaflags = 0;
 138
 139         if (eisa_intr_map(ec, upd.sc_irq, &ih)) {
 140                 aprint_error_dev(&sc->sc_dev, "couldn't map interrupt (%d)\n",
 141                     upd.sc_irq);
 142                 return;
 143         }
 144         intrstr = eisa_intr_string(ec, ih);
 145         sc->sc_ih = eisa_intr_establish(ec, ih, IST_LEVEL, IPL_BIO,
 146             u24_intr, sc);
 147         if (sc->sc_ih == NULL) {
 148                 aprint_error_dev(&sc->sc_dev, "couldn't establish interrupt");
 149                 if (intrstr != NULL)
 150                         aprint_error(" at %s", intrstr);
 151                 aprint_error("\n");
 152                 return;
 153         }
 154         aprint_normal_dev(&sc->sc_dev, "interrupting at %s\n", intrstr);
 155
 156         /* Save function pointers for later use. */
 157         sc->start_mbox = u24_start_mbox;
 158         sc->poll = u24_poll;
 159         sc->init = u24_init;
 160
 161         uha_attach(sc, &upd);
 162 }
 163
 164 static int
 165 u24_find(bus_space_tag_t iot, bus_space_handle_t ioh, struct uha_probe_data *sc)
 166 {
 167         u_int8_t config0, config1, config2;
 168         int irq, drq;
 169         int resetcount = 4000;  /* 4 secs? */
 170
 171         config0 = bus_space_read_1(iot, ioh, U24_CONFIG + 0);
 172         config1 = bus_space_read_1(iot, ioh, U24_CONFIG + 1);
 173         config2 = bus_space_read_1(iot, ioh, U24_CONFIG + 2);
 174         if ((config0 & U24_MAGIC1) == 0 ||
 175             (config1 & U24_MAGIC2) == 0)
 176                 return (0);
 177
 178         drq = -1;
 179
 180         switch (config0 & U24_IRQ_MASK) {
 181         case U24_IRQ10:
 182                 irq = 10;
 183                 break;
 184         case U24_IRQ11:
 185                 irq = 11;
 186                 break;
 187         case U24_IRQ14:
 188                 irq = 14;
 189                 break;
 190         case U24_IRQ15:
 191                 irq = 15;
 192                 break;
 193         default:
 194                 printf("u24_find: illegal irq setting %x\n",
 195                     config0 & U24_IRQ_MASK);
 196                 return (0);
 197         }
 198
 199         bus_space_write_1(iot, ioh, U24_LINT, UHA_ASRST);
 200
 201         while (--resetcount) {
 202                 if (bus_space_read_1(iot, ioh, U24_LINT))
 203                         break;
 204                 delay(1000);    /* 1 mSec per loop */
 205         }
 206         if (!resetcount) {
 207                 printf("u24_find: board timed out during reset\n");
 208                 return (0);
 209         }
 210
 211         /* if we want to fill in softc, do so now */
 212         if (sc) {
 213                 sc->sc_irq = irq;
 214                 sc->sc_drq = drq;
 215                 sc->sc_scsi_dev = config2 & U24_HOSTID_MASK;
 216         }
 217
 218         return (1);
 219 }
 220
 221 static void
 222 u24_start_mbox(struct uha_softc *sc, struct uha_mscp *mscp)
 223 {
 224         bus_space_tag_t iot = sc->sc_iot;
 225         bus_space_handle_t ioh = sc->sc_ioh;
 226         int spincount = 100000; /* 1s should be enough */
 227
 228         while (--spincount) {
 229                 if ((bus_space_read_1(iot, ioh, U24_LINT) & U24_LDIP) == 0)
 230                         break;
 231                 delay(100);
 232         }
 233         if (!spincount) {
 234                 aprint_error_dev(&sc->sc_dev, "uha_start_mbox, board not responding\n");
 235                 Debugger();
 236         }
 237
 238         bus_space_write_4(iot, ioh, U24_OGMPTR,
 239             sc->sc_dmamap_mscp->dm_segs[0].ds_addr + UHA_MSCP_OFF(mscp));
 240         if (mscp->flags & MSCP_ABORT)
 241                 bus_space_write_1(iot, ioh, U24_OGMCMD, 0x80);
 242         else
 243                 bus_space_write_1(iot, ioh, U24_OGMCMD, 0x01);
 244         bus_space_write_1(iot, ioh, U24_LINT, U24_OGMFULL);
 245
 246         if ((mscp->xs->xs_control & XS_CTL_POLL) == 0)
 247                 callout_reset(&mscp->xs->xs_callout,
 248                     mstohz(mscp->timeout), uha_timeout, mscp);
 249 }
 250
 251 static int
 252 u24_poll(struct uha_softc *sc, struct scsipi_xfer *xs, int count)
 253 {
 254         bus_space_tag_t iot = sc->sc_iot;
 255         bus_space_handle_t ioh = sc->sc_ioh;
 256
 257         while (count) {
 258                 /*
 259                  * If we had interrupts enabled, would we
 260                  * have got an interrupt?
 261                  */
 262                 if (bus_space_read_1(iot, ioh, U24_SINT) & U24_SDIP)
 263                         u24_intr(sc);
 264                 if (xs->xs_status & XS_STS_DONE)
 265                         return (0);
 266                 delay(1000);
 267                 count--;
 268         }
 269         return (1);
 270 }
 271
 272 static int
 273 u24_intr(void *arg)
 274 {
 275         struct uha_softc *sc = arg;
 276         bus_space_tag_t iot = sc->sc_iot;
 277         bus_space_handle_t ioh = sc->sc_ioh;
 278         struct uha_mscp *mscp;
 279         u_char uhastat;
 280         u_long mboxval;
 281
 282 #ifdef  UHADEBUG
 283         printf("%s: uhaintr ", device_xname(&sc->sc_dev));
 284 #endif /*UHADEBUG */
 285
 286         if ((bus_space_read_1(iot, ioh, U24_SINT) & U24_SDIP) == 0)
 287                 return (0);
 288
 289         for (;;) {
 290                 /*
 291                  * First get all the information and then
 292                  * acknowledge the interrupt
 293                  */
 294                 uhastat = bus_space_read_1(iot, ioh, U24_SINT);
 295                 mboxval = bus_space_read_4(iot, ioh, U24_ICMPTR);
 296                 bus_space_write_1(iot, ioh, U24_SINT, U24_ICM_ACK);
 297                 bus_space_write_1(iot, ioh, U24_ICMCMD, 0);
 298
 299 #ifdef  UHADEBUG
 300                 printf("status = 0x%x ", uhastat);
 301 #endif /*UHADEBUG*/
 302
 303                 /*
 304                  * Process the completed operation
 305                  */
 306                 mscp = uha_mscp_phys_kv(sc, mboxval);
 307                 if (!mscp) {
 308                         printf("%s: BAD MSCP RETURNED!\n",
 309                             device_xname(&sc->sc_dev));
 310                         continue;       /* whatever it was, it'll timeout */
 311                 }
 312                 callout_stop(&mscp->xs->xs_callout);
 313                 uha_done(sc, mscp);
 314
 315                 if ((bus_space_read_1(iot, ioh, U24_SINT) & U24_SDIP) == 0)
 316                         return (1);
 317         }
 318 }
 319
 320 static void
 321 u24_init(struct uha_softc *sc)
 322 {
 323         bus_space_tag_t iot = sc->sc_iot;
 324         bus_space_handle_t ioh = sc->sc_ioh;
 325
 326         /* free OGM and ICM */
 327         bus_space_write_1(iot, ioh, U24_OGMCMD, 0);
 328         bus_space_write_1(iot, ioh, U24_ICMCMD, 0);
 329         /* make sure interrupts are enabled */
 330 #ifdef UHADEBUG
 331         printf("u24_init: lmask=%02x, smask=%02x\n",
 332             bus_space_read_1(iot, ioh, U24_LMASK),
 333             bus_space_read_1(iot, ioh, U24_SMASK));
 334 #endif
 335         bus_space_write_1(iot, ioh, U24_LMASK, 0xd2);   /* XXX */
 336         bus_space_write_1(iot, ioh, U24_SMASK, 0x92);   /* XXX */
 337 }