sys/dev/aic/aic_isa.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 1999 Luoqi Chen.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 #include <sys/param.h>
  33 #include <sys/callout.h>
  34 #include <sys/kernel.h>
  35 #include <sys/lock.h>
  36 #include <sys/module.h>
  37 #include <sys/mutex.h>
  38 #include <sys/bus.h>
  39
  40 #include <machine/bus.h>
  41 #include <machine/resource.h>
  42 #include <sys/rman.h>
  43
  44 #include <isa/isavar.h>
  45 #include <dev/aic/aic6360reg.h>
  46 #include <dev/aic/aicvar.h>
  47
  48 struct aic_isa_softc {
  49         struct  aic_softc sc_aic;
  50         struct  resource *sc_port;
  51         struct  resource *sc_irq;
  52         struct  resource *sc_drq;
  53         void    *sc_ih;
  54 };
  55
  56 static int aic_isa_alloc_resources(device_t);
  57 static void aic_isa_release_resources(device_t);
  58 static int aic_isa_probe(device_t);
  59 static int aic_isa_attach(device_t);
  60
  61 static u_int aic_isa_ports[] = { 0x340, 0x140 };
  62
  63 #define AIC_ISA_NUMPORTS nitems(aic_isa_ports)
  64 #define AIC_ISA_PORTSIZE 0x20
  65
  66 static struct isa_pnp_id aic_ids[] = {
  67         { 0x15309004, "Adaptec AHA-1530P" },
  68         { 0x15209004, "Adaptec AHA-1520P" },
  69         { 0 }
  70 };
  71
  72 static int
  73 aic_isa_alloc_resources(device_t dev)
  74 {
  75         struct aic_isa_softc *sc = device_get_softc(dev);
  76         int rid;
  77
  78         sc->sc_port = sc->sc_irq = sc->sc_drq = NULL;
  79
  80         rid = 0;
  81         sc->sc_port = bus_alloc_resource_anywhere(dev, SYS_RES_IOPORT, &rid,
  82                                                 AIC_ISA_PORTSIZE, RF_ACTIVE);
  83         if (!sc->sc_port) {
  84                 device_printf(dev, "I/O port allocation failed\n");
  85                 return (ENOMEM);
  86         }
  87
  88         if (isa_get_irq(dev) != -1) {
  89                 rid = 0;
  90                 sc->sc_irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
  91                                                     RF_ACTIVE);
  92                 if (!sc->sc_irq) {
  93                         device_printf(dev, "IRQ allocation failed\n");
  94                         aic_isa_release_resources(dev);
  95                         return (ENOMEM);
  96                 }
  97         }
  98
  99         if (isa_get_drq(dev) != -1) {
 100                 rid = 0;
 101                 sc->sc_drq = bus_alloc_resource_any(dev, SYS_RES_DRQ, &rid,
 102                                                     RF_ACTIVE);
 103                 if (!sc->sc_drq) {
 104                         device_printf(dev, "DRQ allocation failed\n");
 105                         aic_isa_release_resources(dev);
 106                         return (ENOMEM);
 107                 }
 108         }
 109
 110         sc->sc_aic.dev = dev;
 111         sc->sc_aic.res = sc->sc_port;
 112         mtx_init(&sc->sc_aic.lock, "aic", NULL, MTX_DEF);
 113         return (0);
 114 }
 115
 116 static void
 117 aic_isa_release_resources(device_t dev)
 118 {
 119         struct aic_isa_softc *sc = device_get_softc(dev);
 120
 121         if (sc->sc_port)
 122                 bus_release_resource(dev, SYS_RES_IOPORT, 0, sc->sc_port);
 123         if (sc->sc_irq)
 124                 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->sc_irq);
 125         if (sc->sc_drq)
 126                 bus_release_resource(dev, SYS_RES_DRQ, 0, sc->sc_drq);
 127         sc->sc_port = sc->sc_irq = sc->sc_drq = NULL;
 128         mtx_destroy(&sc->sc_aic.lock);
 129 }
 130
 131 static int
 132 aic_isa_probe(device_t dev)
 133 {
 134         struct aic_isa_softc *sc = device_get_softc(dev);
 135         struct aic_softc *aic = &sc->sc_aic;
 136         int numports, i;
 137         u_int port, *ports;
 138         u_int8_t porta;
 139
 140         if (ISA_PNP_PROBE(device_get_parent(dev), dev, aic_ids) == ENXIO)
 141                 return (ENXIO);
 142
 143         port = isa_get_port(dev);
 144         if (port != -1) {
 145                 ports = &port;
 146                 numports = 1;
 147         } else {
 148                 ports = aic_isa_ports;
 149                 numports = AIC_ISA_NUMPORTS;
 150         }
 151
 152         for (i = 0; i < numports; i++) {
 153                 if (bus_set_resource(dev, SYS_RES_IOPORT, 0, ports[i],
 154                                      AIC_ISA_PORTSIZE))
 155                         continue;
 156                 if (aic_isa_alloc_resources(dev))
 157                         continue;
 158                 if (aic_probe(aic) == 0)
 159                         break;
 160                 aic_isa_release_resources(dev);
 161         }
 162
 163         if (i == numports)
 164                 return (ENXIO);
 165
 166         porta = aic_inb(aic, PORTA);
 167         aic_isa_release_resources(dev);
 168         if (isa_get_irq(dev) == -1)
 169                 bus_set_resource(dev, SYS_RES_IRQ, 0, PORTA_IRQ(porta), 1);
 170         if ((aic->flags & AIC_DMA_ENABLE) && isa_get_drq(dev) == -1)
 171                 bus_set_resource(dev, SYS_RES_DRQ, 0, PORTA_DRQ(porta), 1);
 172         device_set_desc(dev, "Adaptec 6260/6360 SCSI controller");
 173         return (0);
 174 }
 175
 176 static int
 177 aic_isa_attach(device_t dev)
 178 {
 179         struct aic_isa_softc *sc = device_get_softc(dev);
 180         struct aic_softc *aic = &sc->sc_aic;
 181         int error;
 182
 183         error = aic_isa_alloc_resources(dev);
 184         if (error) {
 185                 device_printf(dev, "resource allocation failed\n");
 186                 return (error);
 187         }
 188
 189         error = aic_attach(aic);
 190         if (error) {
 191                 device_printf(dev, "attach failed\n");
 192                 aic_isa_release_resources(dev);
 193                 return (error);
 194         }
 195
 196         error = bus_setup_intr(dev, sc->sc_irq, INTR_TYPE_CAM | INTR_ENTROPY |
 197             INTR_MPSAFE, NULL, aic_intr, aic, &sc->sc_ih);
 198         if (error) {
 199                 device_printf(dev, "failed to register interrupt handler\n");
 200                 aic_isa_release_resources(dev);
 201                 return (error);
 202         }
 203         return (0);
 204 }
 205
 206 static int
 207 aic_isa_detach(device_t dev)
 208 {
 209         struct aic_isa_softc *sc = device_get_softc(dev);
 210         struct aic_softc *aic = &sc->sc_aic;
 211         int error;
 212
 213         error = aic_detach(aic);
 214         if (error) {
 215                 device_printf(dev, "detach failed\n");
 216                 return (error);
 217         }
 218
 219         error = bus_teardown_intr(dev, sc->sc_irq, sc->sc_ih);
 220         if (error) {
 221                 device_printf(dev, "failed to unregister interrupt handler\n");
 222         }
 223
 224         aic_isa_release_resources(dev);
 225         return (0);
 226 }
 227
 228 static device_method_t aic_isa_methods[] = {
 229         /* Device interface */
 230         DEVMETHOD(device_probe,         aic_isa_probe),
 231         DEVMETHOD(device_attach,        aic_isa_attach),
 232         DEVMETHOD(device_detach,        aic_isa_detach),
 233         { 0, 0 }
 234 };
 235
 236 static driver_t aic_isa_driver = {
 237         "aic",
 238         aic_isa_methods, sizeof(struct aic_isa_softc),
 239 };
 240
 241 extern devclass_t aic_devclass;
 242
 243 MODULE_DEPEND(aic, cam, 1,1,1);
 244 DRIVER_MODULE(aic, isa, aic_isa_driver, aic_devclass, 0, 0);
 245 ISA_PNP_INFO(aic_ids);