sys/dev/ofisa/wdc_ofisa.c

   1 /*      $NetBSD: wdc_ofisa.c,v 1.29 2007/10/19 12:00:38 ad Exp $        */
   2
   3 /*
   4  * Copyright 1997, 1998
   5  * Digital Equipment Corporation. All rights reserved.
   6  *
   7  * This software is furnished under license and may be used and
   8  * copied only in accordance with the following terms and conditions.
   9  * Subject to these conditions, you may download, copy, install,
  10  * use, modify and distribute this software in source and/or binary
  11  * form. No title or ownership is transferred hereby.
  12  *
  13  * 1) Any source code used, modified or distributed must reproduce
  14  *    and retain this copyright notice and list of conditions as
  15  *    they appear in the source file.
  16  *
  17  * 2) No right is granted to use any trade name, trademark, or logo of
  18  *    Digital Equipment Corporation. Neither the "Digital Equipment
  19  *    Corporation" name nor any trademark or logo of Digital Equipment
  20  *    Corporation may be used to endorse or promote products derived
  21  *    from this software without the prior written permission of
  22  *    Digital Equipment Corporation.
  23  *
  24  * 3) This software is provided "AS-IS" and any express or implied
  25  *    warranties, including but not limited to, any implied warranties
  26  *    of merchantability, fitness for a particular purpose, or
  27  *    non-infringement are disclaimed. In no event shall DIGITAL be
  28  *    liable for any damages whatsoever, and in particular, DIGITAL
  29  *    shall not be liable for special, indirect, consequential, or
  30  *    incidental damages or damages for lost profits, loss of
  31  *    revenue or loss of use, whether such damages arise in contract,
  32  *    negligence, tort, under statute, in equity, at law or otherwise,
  33  *    even if advised of the possibility of such damage.
  34  */
  35
  36 /*
  37  * OFW Attachment for 'wdc' disk controller driver
  38  */
  39
  40 #include <sys/cdefs.h>
  41 __KERNEL_RCSID(0, "$NetBSD: wdc_ofisa.c,v 1.29 2007/10/19 12:00:38 ad Exp $");
  42
  43 #include <sys/param.h>
  44 #include <sys/device.h>
  45 #include <sys/systm.h>
  46 #include <sys/tty.h>
  47 #include <sys/malloc.h>
  48
  49 #include <sys/intr.h>
  50 #include <sys/bus.h>
  51
  52 #include <dev/ofw/openfirm.h>
  53 #include <dev/isa/isavar.h>
  54 #include <dev/ofisa/ofisavar.h>
  55
  56 #include <dev/ic/wdcreg.h>              /* ??? */
  57 #include <dev/ata/atavar.h>
  58 #include <dev/ic/wdcvar.h>
  59
  60 struct wdc_ofisa_softc {
  61         struct wdc_softc sc_wdcdev;
  62         struct ata_channel *sc_chanlist[1];
  63         struct ata_channel sc_channel;
  64         struct ata_queue sc_chqueue;
  65         struct wdc_regs wdc_regs;
  66         void    *sc_ih;
  67 };
  68
  69 static int wdc_ofisa_probe(device_t, cfdata_t, void *);
  70 static void wdc_ofisa_attach(device_t, device_t, void *);
  71
  72 CFATTACH_DECL_NEW(wdc_ofisa, sizeof(struct wdc_ofisa_softc),
  73     wdc_ofisa_probe, wdc_ofisa_attach, NULL, NULL);
  74
  75 static int
  76 wdc_ofisa_probe(device_t parent, cfdata_t cf, void *aux)
  77 {
  78         struct ofisa_attach_args *aa = aux;
  79         static const char *const compatible_strings[] = { "pnpPNP,600", NULL };
  80         int rv = 0;
  81
  82         if (of_compatible(aa->oba.oba_phandle, compatible_strings) != -1)
  83                 rv = 5;
  84 #ifdef _WDC_OFISA_MD_MATCH
  85         if (!rv)
  86                 rv = wdc_ofisa_md_match(parent, cf, aux);
  87 #endif
  88         return (rv);
  89 }
  90
  91 static void
  92 wdc_ofisa_attach(device_t parent, device_t self, void *aux)
  93 {
  94         struct wdc_ofisa_softc *sc = device_private(self);
  95         struct wdc_regs *wdr;
  96         struct ofisa_attach_args *aa = aux;
  97         struct ofisa_reg_desc reg[2];
  98         struct ofisa_intr_desc intr;
  99         int n;
 100         bus_space_handle_t ioh;
 101
 102         /*
 103          * We're living on an ofw.  We have to ask the OFW what our
 104          * registers and interrupts properties look like.
 105          *
 106          * We expect exactly two register regions and one interrupt.
 107          */
 108
 109         sc->sc_wdcdev.sc_atac.atac_dev = self;
 110         sc->sc_wdcdev.regs = wdr = &sc->wdc_regs;
 111
 112         n = ofisa_reg_get(aa->oba.oba_phandle, reg, 2);
 113 #ifdef _WDC_OFISA_MD_REG_FIXUP
 114         n = wdc_ofisa_md_reg_fixup(parent, self, aux, reg, 2, n);
 115 #endif
 116         if (n != 2) {
 117                 aprint_error(": error getting register data\n");
 118                 return;
 119         }
 120         if (reg[0].len != 8 || reg[1].len != 2) {
 121                 aprint_error(": weird register size (%lu/%lu, expected 8/2)\n",
 122                     (unsigned long)reg[0].len, (unsigned long)reg[1].len);
 123                 return;
 124         }
 125
 126         n = ofisa_intr_get(aa->oba.oba_phandle, &intr, 1);
 127 #ifdef _WDC_OFISA_MD_INTR_FIXUP
 128         n = wdc_ofisa_md_intr_fixup(parent, self, aux, &intr, 1, n);
 129 #endif
 130         if (n != 1) {
 131                 aprint_error(": error getting interrupt data\n");
 132                 return;
 133         }
 134
 135         wdr->cmd_iot = (reg[0].type == OFISA_REG_TYPE_IO) ? aa->iot : aa->memt;
 136         wdr->ctl_iot = (reg[1].type == OFISA_REG_TYPE_IO) ? aa->iot : aa->memt;
 137         if (bus_space_map(wdr->cmd_iot, reg[0].addr, 8, 0, &ioh) ||
 138             bus_space_map(wdr->ctl_iot, reg[1].addr, 1, 0,
 139               &wdr->ctl_ioh)) {
 140                 aprint_error(": can't map register spaces\n");
 141                 return;
 142         }
 143         wdr->cmd_baseioh = ioh;
 144
 145         for (n = 0; n < WDC_NREG; n++) {
 146                 if (bus_space_subregion(wdr->cmd_iot, ioh, n,
 147                     n == 0 ? 4 : 1, &wdr->cmd_iohs[n]) != 0) {
 148                         aprint_error(": can't subregion register space\n");
 149                         return;
 150                 }
 151         }
 152
 153         sc->sc_ih = isa_intr_establish(aa->ic, intr.irq, intr.share,
 154             IPL_BIO, wdcintr, &sc->sc_channel);
 155
 156         aprint_normal("\n");
 157         sc->sc_wdcdev.sc_atac.atac_cap |= ATAC_CAP_DATA16;
 158         sc->sc_chanlist[0] = &sc->sc_channel;
 159         sc->sc_wdcdev.sc_atac.atac_channels = sc->sc_chanlist;
 160         sc->sc_wdcdev.sc_atac.atac_nchannels = 1;
 161         sc->sc_channel.ch_channel = 0;
 162         sc->sc_channel.ch_atac = &sc->sc_wdcdev.sc_atac;
 163         sc->sc_channel.ch_queue = &sc->sc_chqueue;
 164         sc->sc_channel.ch_ndrive = 2;
 165
 166         wdc_init_shadow_regs(&sc->sc_channel);
 167
 168         wdcattach(&sc->sc_channel);
 169
 170 #if 0
 171         aprint_verbose_dev(self, "registers: ");
 172         ofisa_reg_print(reg, 2);
 173         aprint_verbose("\n");
 174         aprint_verbose_dev(self, "interrupts: ");
 175         ofisa_intr_print(&intr, 1);
 176         aprint_verbose("\n");
 177 #endif
 178 }