sys/dev/cardbus/ahc_cardbus.c

   1 /*      $NetBSD: ahc_cardbus.c,v 1.28 2009/05/16 06:44:05 tsutsui Exp $ */
   2
   3 /*-
   4  * Copyright (c) 2000, 2005 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
   9  * NASA Ames Research Center.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  21  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  22  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  23  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  24  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30  * POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 /*
  34  * CardBus front-end for the Adaptec AIC-7xxx family of SCSI controllers.
  35  *
  36  * TODO:
  37  *      - power management
  38  */
  39
  40 #include <sys/cdefs.h>
  41 __KERNEL_RCSID(0, "$NetBSD: ahc_cardbus.c,v 1.28 2009/05/16 06:44:05 tsutsui Exp $");
  42
  43 #include "opt_ahc_cardbus.h"
  44
  45 #include <sys/param.h>
  46 #include <sys/systm.h>
  47 #include <sys/malloc.h>
  48 #include <sys/kernel.h>
  49 #include <sys/queue.h>
  50 #include <sys/device.h>
  51
  52 #include <sys/bus.h>
  53 #include <sys/intr.h>
  54
  55 #include <dev/scsipi/scsi_all.h>
  56 #include <dev/scsipi/scsipi_all.h>
  57 #include <dev/scsipi/scsiconf.h>
  58
  59 #include <dev/pci/pcireg.h>
  60
  61 #include <dev/cardbus/cardbusvar.h>
  62 #include <dev/pci/pcidevs.h>
  63
  64 #include <dev/ic/aic7xxx_osm.h>
  65 #include <dev/ic/aic7xxx_inline.h>
  66
  67
  68 #ifndef AHC_CARDBUS_DEFAULT_SCSI_ID
  69 #define AHC_CARDBUS_DEFAULT_SCSI_ID     0x7
  70 #endif
  71
  72 #define AHC_CARDBUS_IOBA        0x10
  73 #define AHC_CARDBUS_MMBA        0x14
  74
  75 struct ahc_cardbus_softc {
  76         struct ahc_softc sc_ahc;        /* real AHC */
  77
  78         /* CardBus-specific goo. */
  79         cardbus_devfunc_t sc_ct;        /* our CardBus devfuncs */
  80         cardbus_intr_line_t sc_intrline; /* our interrupt line */
  81         cardbustag_t sc_tag;
  82
  83         int     sc_cbenable;            /* what CardBus access type to enable */
  84         int     sc_csr;                 /* CSR bits */
  85         bus_size_t sc_size;
  86 };
  87
  88 int     ahc_cardbus_match(device_t, cfdata_t, void *);
  89 void    ahc_cardbus_attach(device_t, device_t, void *);
  90 int     ahc_cardbus_detach(device_t, int);
  91
  92 CFATTACH_DECL_NEW(ahc_cardbus, sizeof(struct ahc_cardbus_softc),
  93     ahc_cardbus_match, ahc_cardbus_attach, ahc_cardbus_detach, NULL);
  94
  95 int
  96 ahc_cardbus_match(device_t parent, cfdata_t match, void *aux)
  97 {
  98         struct cardbus_attach_args *ca = aux;
  99
 100         if (CARDBUS_VENDOR(ca->ca_id) == PCI_VENDOR_ADP &&
 101             CARDBUS_PRODUCT(ca->ca_id) == PCI_PRODUCT_ADP_APA1480)
 102                 return (1);
 103
 104         return (0);
 105 }
 106
 107 void
 108 ahc_cardbus_attach(device_t parent, device_t self, void *aux)
 109 {
 110         struct cardbus_attach_args *ca = aux;
 111         struct ahc_cardbus_softc *csc = device_private(self);
 112         struct ahc_softc *ahc = &csc->sc_ahc;
 113         cardbus_devfunc_t ct = ca->ca_ct;
 114         cardbus_chipset_tag_t cc = ct->ct_cc;
 115         cardbus_function_tag_t cf = ct->ct_cf;
 116         bus_space_tag_t bst;
 117         bus_space_handle_t bsh;
 118         pcireg_t reg;
 119         u_int sxfrctl1 = 0;
 120         u_char sblkctl;
 121
 122
 123         ahc->sc_dev = self;
 124         csc->sc_ct = ct;
 125         csc->sc_tag = ca->ca_tag;
 126         csc->sc_intrline = ca->ca_intrline;
 127
 128         printf(": Adaptec ADP-1480 SCSI\n");
 129
 130         /*
 131          * Map the device.
 132          */
 133         csc->sc_csr = PCI_COMMAND_MASTER_ENABLE;
 134         if (Cardbus_mapreg_map(csc->sc_ct, AHC_CARDBUS_MMBA,
 135             PCI_MAPREG_TYPE_MEM|PCI_MAPREG_MEM_TYPE_32BIT, 0,
 136             &bst, &bsh, NULL, &csc->sc_size) == 0) {
 137                 csc->sc_cbenable = CARDBUS_MEM_ENABLE;
 138                 csc->sc_csr |= PCI_COMMAND_MEM_ENABLE;
 139         } else if (Cardbus_mapreg_map(csc->sc_ct, AHC_CARDBUS_IOBA,
 140             PCI_MAPREG_TYPE_IO, 0, &bst, &bsh, NULL, &csc->sc_size) == 0) {
 141                 csc->sc_cbenable = CARDBUS_IO_ENABLE;
 142                 csc->sc_csr |= PCI_COMMAND_IO_ENABLE;
 143         } else {
 144                 printf("%s: unable to map device registers\n",
 145                     ahc_name(ahc));
 146                 return;
 147         }
 148
 149         /* Make sure the right access type is on the CardBus bridge. */
 150         (*ct->ct_cf->cardbus_ctrl)(cc, csc->sc_cbenable);
 151         (*ct->ct_cf->cardbus_ctrl)(cc, CARDBUS_BM_ENABLE);
 152
 153         /* Enable the appropriate bits in the PCI CSR. */
 154         reg = cardbus_conf_read(cc, cf, ca->ca_tag, PCI_COMMAND_STATUS_REG);
 155         reg &= ~(PCI_COMMAND_IO_ENABLE|PCI_COMMAND_MEM_ENABLE);
 156         reg |= csc->sc_csr;
 157         cardbus_conf_write(cc, cf, ca->ca_tag, PCI_COMMAND_STATUS_REG, reg);
 158
 159         /*
 160          * Make sure the latency timer is set to some reasonable
 161          * value.
 162          */
 163         reg = cardbus_conf_read(cc, cf, ca->ca_tag, PCI_BHLC_REG);
 164         if (PCI_LATTIMER(reg) < 0x20) {
 165                 reg &= ~(PCI_LATTIMER_MASK << PCI_LATTIMER_SHIFT);
 166                 reg |= (0x20 << PCI_LATTIMER_SHIFT);
 167                 cardbus_conf_write(cc, cf, ca->ca_tag, PCI_BHLC_REG, reg);
 168         }
 169
 170         ahc_set_name(ahc, device_xname(ahc->sc_dev));
 171
 172         ahc->parent_dmat = ca->ca_dmat;
 173         ahc->tag = bst;
 174         ahc->bsh = bsh;
 175
 176         /*
 177          * ADP-1480 is always an AIC-7860.
 178          */
 179         ahc->chip = AHC_AIC7860 | AHC_PCI;
 180         ahc->features = AHC_AIC7860_FE|AHC_REMOVABLE;
 181         ahc->bugs |= AHC_TMODE_WIDEODD_BUG|AHC_CACHETHEN_BUG|AHC_PCI_MWI_BUG;
 182         if (PCI_REVISION(ca->ca_class) >= 1)
 183                 ahc->bugs |= AHC_PCI_2_1_RETRY_BUG;
 184
 185         if (ahc_softc_init(ahc) != 0)
 186                 return;
 187
 188         /*
 189          * On all CardBus adapters, we allow SCB paging.
 190          */
 191         ahc->flags = AHC_PAGESCBS;
 192
 193         ahc->channel = 'A';
 194
 195         ahc_intr_enable(ahc, FALSE);
 196
 197         ahc_reset(ahc);
 198
 199         /*
 200          * Establish the interrupt.
 201          */
 202         ahc->ih = cardbus_intr_establish(cc, cf, ca->ca_intrline, IPL_BIO,
 203             ahc_intr, ahc);
 204         if (ahc->ih == NULL) {
 205                 printf("%s: unable to establish interrupt\n",
 206                     ahc_name(ahc));
 207                 return;
 208         }
 209
 210         ahc->seep_config = malloc(sizeof(*ahc->seep_config),
 211                                   M_DEVBUF, M_NOWAIT);
 212         if (ahc->seep_config == NULL)
 213                 return;
 214
 215         ahc_check_extport(ahc, &sxfrctl1);
 216         /*
 217          * Take the LED out of diagnostic mode.
 218          */
 219         sblkctl = ahc_inb(ahc, SBLKCTL);
 220         ahc_outb(ahc, SBLKCTL, (sblkctl & ~(DIAGLEDEN|DIAGLEDON)));
 221
 222         /*
 223          * I don't know where this is set in the SEEPROM or by the
 224          * BIOS, so we default to 100%.
 225          */
 226         ahc_outb(ahc, DSPCISTATUS, DFTHRSH_100);
 227
 228         if (ahc->flags & AHC_USEDEFAULTS) {
 229                 int our_id;
 230                 /*
 231                  * Assume only one connector and always turn
 232                  * on termination.
 233                  */
 234                 our_id = AHC_CARDBUS_DEFAULT_SCSI_ID;
 235                 sxfrctl1 = STPWEN;
 236                 ahc_outb(ahc, SCSICONF, our_id | ENSPCHK | RESET_SCSI);
 237                 ahc->our_id = our_id;
 238         }
 239
 240         printf("%s: aic7860", ahc_name(ahc));
 241
 242         /*
 243          * Record our termination setting for the
 244          * generic initialization routine.
 245          */
 246         if ((sxfrctl1 & STPWEN) != 0)
 247                 ahc->flags |= AHC_TERM_ENB_A;
 248
 249         if (ahc_init(ahc)) {
 250                 ahc_free(ahc);
 251                 return;
 252         }
 253
 254         ahc_attach(ahc);
 255 }
 256
 257 int
 258 ahc_cardbus_detach(device_t self, int flags)
 259 {
 260         struct ahc_cardbus_softc *csc = device_private(self);
 261         struct ahc_softc *ahc = &csc->sc_ahc;
 262
 263         int rv;
 264
 265         rv = ahc_detach(ahc, flags);
 266         if (rv)
 267                 return rv;
 268
 269         if (ahc->ih) {
 270                 cardbus_intr_disestablish(csc->sc_ct->ct_cc,
 271                                           csc->sc_ct->ct_cf, ahc->ih);
 272                 ahc->ih = 0;
 273         }
 274
 275         if (csc->sc_cbenable) {
 276                 if (csc->sc_cbenable == CARDBUS_MEM_ENABLE)
 277                         Cardbus_mapreg_unmap(csc->sc_ct, AHC_CARDBUS_MMBA,
 278                                 ahc->tag, ahc->bsh, csc->sc_size);
 279                 else if (csc->sc_cbenable == CARDBUS_IO_ENABLE)
 280                         Cardbus_mapreg_unmap(csc->sc_ct, AHC_CARDBUS_IOBA,
 281                                 ahc->tag, ahc->bsh, csc->sc_size);
 282         csc->sc_cbenable = 0;
 283         }
 284
 285         return (0);
 286 }