sys/dev/ic/adv.c

   1 /*      $NetBSD: adv.c,v 1.43 2009/03/14 15:36:17 dsl Exp $     */
   2
   3 /*
   4  * Generic driver for the Advanced Systems Inc. Narrow SCSI controllers
   5  *
   6  * Copyright (c) 1998 The NetBSD Foundation, Inc.
   7  * All rights reserved.
   8  *
   9  * Author: Baldassare Dante Profeta <dante@mclink.it>
  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  * 3. All advertising materials mentioning features or use of this software
  20  *    must display the following acknowledgement:
  21  *        This product includes software developed by the NetBSD
  22  *        Foundation, Inc. and its contributors.
  23  * 4. Neither the name of The NetBSD Foundation nor the names of its
  24  *    contributors may be used to endorse or promote products derived
  25  *    from this software without specific prior written permission.
  26  *
  27  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  28  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  29  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  30  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  31  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  32  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  33  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  34  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  35  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  36  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  37  * POSSIBILITY OF SUCH DAMAGE.
  38  */
  39
  40 #include <sys/cdefs.h>
  41 __KERNEL_RCSID(0, "$NetBSD: adv.c,v 1.43 2009/03/14 15:36:17 dsl Exp $");
  42
  43 #include <sys/param.h>
  44 #include <sys/systm.h>
  45 #include <sys/callout.h>
  46 #include <sys/kernel.h>
  47 #include <sys/errno.h>
  48 #include <sys/ioctl.h>
  49 #include <sys/device.h>
  50 #include <sys/malloc.h>
  51 #include <sys/buf.h>
  52 #include <sys/proc.h>
  53
  54 #include <sys/bus.h>
  55 #include <sys/intr.h>
  56
  57 #include <uvm/uvm_extern.h>
  58
  59 #include <dev/scsipi/scsi_all.h>
  60 #include <dev/scsipi/scsipi_all.h>
  61 #include <dev/scsipi/scsiconf.h>
  62
  63 #include <dev/ic/advlib.h>
  64 #include <dev/ic/adv.h>
  65
  66 #ifndef DDB
  67 #define Debugger()      panic("should call debugger here (adv.c)")
  68 #endif /* ! DDB */
  69
  70
  71 /* #define ASC_DEBUG */
  72
  73 /******************************************************************************/
  74
  75
  76 static int adv_alloc_control_data(ASC_SOFTC *);
  77 static void adv_free_control_data(ASC_SOFTC *);
  78 static int adv_create_ccbs(ASC_SOFTC *, ADV_CCB *, int);
  79 static void adv_free_ccb(ASC_SOFTC *, ADV_CCB *);
  80 static void adv_reset_ccb(ADV_CCB *);
  81 static int adv_init_ccb(ASC_SOFTC *, ADV_CCB *);
  82 static ADV_CCB *adv_get_ccb(ASC_SOFTC *);
  83 static void adv_queue_ccb(ASC_SOFTC *, ADV_CCB *);
  84 static void adv_start_ccbs(ASC_SOFTC *);
  85
  86
  87 static void adv_scsipi_request(struct scsipi_channel *,
  88         scsipi_adapter_req_t, void *);
  89 static void advminphys(struct buf *);
  90 static void adv_narrow_isr_callback(ASC_SOFTC *, ASC_QDONE_INFO *);
  91
  92 static int adv_poll(ASC_SOFTC *, struct scsipi_xfer *, int);
  93 static void adv_timeout(void *);
  94 static void adv_watchdog(void *);
  95
  96
  97 /******************************************************************************/
  98
  99 #define ADV_ABORT_TIMEOUT       2000    /* time to wait for abort (mSec) */
 100 #define ADV_WATCH_TIMEOUT       1000    /* time to wait for watchdog (mSec) */
 101
 102 /******************************************************************************/
 103 /*                             Control Blocks routines                        */
 104 /******************************************************************************/
 105
 106
 107 static int
 108 adv_alloc_control_data(ASC_SOFTC *sc)
 109 {
 110         int error;
 111
 112         /*
 113         * Allocate the control blocks.
 114          */
 115         if ((error = bus_dmamem_alloc(sc->sc_dmat, sizeof(struct adv_control),
 116                            PAGE_SIZE, 0, &sc->sc_control_seg, 1,
 117                            &sc->sc_control_nsegs, BUS_DMA_NOWAIT)) != 0) {
 118                 aprint_error_dev(&sc->sc_dev, "unable to allocate control structures,"
 119                        " error = %d\n", error);
 120                 return (error);
 121         }
 122         if ((error = bus_dmamem_map(sc->sc_dmat, &sc->sc_control_seg,
 123                            sc->sc_control_nsegs, sizeof(struct adv_control),
 124                            (void **) & sc->sc_control,
 125                            BUS_DMA_NOWAIT | BUS_DMA_COHERENT)) != 0) {
 126                 aprint_error_dev(&sc->sc_dev, "unable to map control structures, error = %d\n",
 127                        error);
 128                 return (error);
 129         }
 130         /*
 131          * Create and load the DMA map used for the control blocks.
 132          */
 133         if ((error = bus_dmamap_create(sc->sc_dmat, sizeof(struct adv_control),
 134                            1, sizeof(struct adv_control), 0, BUS_DMA_NOWAIT,
 135                                        &sc->sc_dmamap_control)) != 0) {
 136                 aprint_error_dev(&sc->sc_dev, "unable to create control DMA map, error = %d\n",
 137                        error);
 138                 return (error);
 139         }
 140         if ((error = bus_dmamap_load(sc->sc_dmat, sc->sc_dmamap_control,
 141                            sc->sc_control, sizeof(struct adv_control), NULL,
 142                                      BUS_DMA_NOWAIT)) != 0) {
 143                 aprint_error_dev(&sc->sc_dev, "unable to load control DMA map, error = %d\n",
 144                        error);
 145                 return (error);
 146         }
 147
 148         /*
 149          * Initialize the overrun_buf address.
 150          */
 151         sc->overrun_buf = sc->sc_dmamap_control->dm_segs[0].ds_addr +
 152             offsetof(struct adv_control, overrun_buf);
 153
 154         return (0);
 155 }
 156
 157 static void
 158 adv_free_control_data(ASC_SOFTC *sc)
 159 {
 160
 161         bus_dmamap_unload(sc->sc_dmat, sc->sc_dmamap_control);
 162         bus_dmamap_destroy(sc->sc_dmat, sc->sc_dmamap_control);
 163         sc->sc_dmamap_control = NULL;
 164
 165         bus_dmamem_unmap(sc->sc_dmat, (void *) sc->sc_control,
 166             sizeof(struct adv_control));
 167         bus_dmamem_free(sc->sc_dmat, &sc->sc_control_seg,
 168             sc->sc_control_nsegs);
 169 }
 170
 171 /*
 172  * Create a set of ccbs and add them to the free list.  Called once
 173  * by adv_init().  We return the number of CCBs successfully created.
 174  */
 175 static int
 176 adv_create_ccbs(ASC_SOFTC *sc, ADV_CCB *ccbstore, int count)
 177 {
 178         ADV_CCB        *ccb;
 179         int             i, error;
 180
 181         memset(ccbstore, 0, sizeof(ADV_CCB) * count);
 182         for (i = 0; i < count; i++) {
 183                 ccb = &ccbstore[i];
 184                 if ((error = adv_init_ccb(sc, ccb)) != 0) {
 185                         aprint_error_dev(&sc->sc_dev, "unable to initialize ccb, error = %d\n",
 186                                error);
 187                         return (i);
 188                 }
 189                 TAILQ_INSERT_TAIL(&sc->sc_free_ccb, ccb, chain);
 190         }
 191
 192         return (i);
 193 }
 194
 195
 196 /*
 197  * A ccb is put onto the free list.
 198  */
 199 static void
 200 adv_free_ccb(ASC_SOFTC *sc, ADV_CCB *ccb)
 201 {
 202         int             s;
 203
 204         s = splbio();
 205         adv_reset_ccb(ccb);
 206         TAILQ_INSERT_HEAD(&sc->sc_free_ccb, ccb, chain);
 207         splx(s);
 208 }
 209
 210
 211 static void
 212 adv_reset_ccb(ADV_CCB *ccb)
 213 {
 214
 215         ccb->flags = 0;
 216 }
 217
 218
 219 static int
 220 adv_init_ccb(ASC_SOFTC *sc, ADV_CCB *ccb)
 221 {
 222         int     hashnum, error;
 223
 224         callout_init(&ccb->ccb_watchdog, 0);
 225
 226         /*
 227          * Create the DMA map for this CCB.
 228          */
 229         error = bus_dmamap_create(sc->sc_dmat,
 230                                   (ASC_MAX_SG_LIST - 1) * PAGE_SIZE,
 231                          ASC_MAX_SG_LIST, (ASC_MAX_SG_LIST - 1) * PAGE_SIZE,
 232                    0, BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, &ccb->dmamap_xfer);
 233         if (error) {
 234                 aprint_error_dev(&sc->sc_dev, "unable to create DMA map, error = %d\n",
 235                        error);
 236                 return (error);
 237         }
 238
 239         /*
 240          * put in the phystokv hash table
 241          * Never gets taken out.
 242          */
 243         ccb->hashkey = sc->sc_dmamap_control->dm_segs[0].ds_addr +
 244             ADV_CCB_OFF(ccb);
 245         hashnum = CCB_HASH(ccb->hashkey);
 246         ccb->nexthash = sc->sc_ccbhash[hashnum];
 247         sc->sc_ccbhash[hashnum] = ccb;
 248
 249         adv_reset_ccb(ccb);
 250         return (0);
 251 }
 252
 253
 254 /*
 255  * Get a free ccb
 256  *
 257  * If there are none, see if we can allocate a new one
 258  */
 259 static ADV_CCB *
 260 adv_get_ccb(ASC_SOFTC *sc)
 261 {
 262         ADV_CCB        *ccb = 0;
 263         int             s;
 264
 265         s = splbio();
 266         ccb = TAILQ_FIRST(&sc->sc_free_ccb);
 267         if (ccb != NULL) {
 268                 TAILQ_REMOVE(&sc->sc_free_ccb, ccb, chain);
 269                 ccb->flags |= CCB_ALLOC;
 270         }
 271         splx(s);
 272         return (ccb);
 273 }
 274
 275
 276 /*
 277  * Given a physical address, find the ccb that it corresponds to.
 278  */
 279 ADV_CCB *
 280 adv_ccb_phys_kv(ASC_SOFTC *sc, u_long ccb_phys)
 281 {
 282         int hashnum = CCB_HASH(ccb_phys);
 283         ADV_CCB *ccb = sc->sc_ccbhash[hashnum];
 284
 285         while (ccb) {
 286                 if (ccb->hashkey == ccb_phys)
 287                         break;
 288                 ccb = ccb->nexthash;
 289         }
 290         return (ccb);
 291 }
 292
 293
 294 /*
 295  * Queue a CCB to be sent to the controller, and send it if possible.
 296  */
 297 static void
 298 adv_queue_ccb(ASC_SOFTC *sc, ADV_CCB *ccb)
 299 {
 300
 301         TAILQ_INSERT_TAIL(&sc->sc_waiting_ccb, ccb, chain);
 302
 303         adv_start_ccbs(sc);
 304 }
 305
 306
 307 static void
 308 adv_start_ccbs(ASC_SOFTC *sc)
 309 {
 310         ADV_CCB        *ccb;
 311
 312         while ((ccb = sc->sc_waiting_ccb.tqh_first) != NULL) {
 313                 if (ccb->flags & CCB_WATCHDOG)
 314                         callout_stop(&ccb->ccb_watchdog);
 315
 316                 if (AscExeScsiQueue(sc, &ccb->scsiq) == ASC_BUSY) {
 317                         ccb->flags |= CCB_WATCHDOG;
 318                         callout_reset(&ccb->ccb_watchdog,
 319                             (ADV_WATCH_TIMEOUT * hz) / 1000,
 320                             adv_watchdog, ccb);
 321                         break;
 322                 }
 323                 TAILQ_REMOVE(&sc->sc_waiting_ccb, ccb, chain);
 324
 325                 if ((ccb->xs->xs_control & XS_CTL_POLL) == 0)
 326                         callout_reset(&ccb->xs->xs_callout,
 327                             mstohz(ccb->timeout), adv_timeout, ccb);
 328         }
 329 }
 330
 331
 332 /******************************************************************************/
 333 /*                         SCSI layer interfacing routines                    */
 334 /******************************************************************************/
 335
 336
 337 int
 338 adv_init(ASC_SOFTC *sc)
 339 {
 340         int             warn;
 341
 342         if (!AscFindSignature(sc->sc_iot, sc->sc_ioh)) {
 343                 aprint_error("adv_init: failed to find signature\n");
 344                 return (1);
 345         }
 346
 347         /*
 348          * Read the board configuration
 349          */
 350         AscInitASC_SOFTC(sc);
 351         warn = AscInitFromEEP(sc);
 352         if (warn) {
 353                 aprint_error_dev(&sc->sc_dev, "-get: ");
 354                 switch (warn) {
 355                 case -1:
 356                         aprint_normal("Chip is not halted\n");
 357                         break;
 358
 359                 case -2:
 360                         aprint_normal("Couldn't get MicroCode Start"
 361                                " address\n");
 362                         break;
 363
 364                 case ASC_WARN_IO_PORT_ROTATE:
 365                         aprint_normal("I/O port address modified\n");
 366                         break;
 367
 368                 case ASC_WARN_AUTO_CONFIG:
 369                         aprint_normal("I/O port increment switch enabled\n");
 370                         break;
 371
 372                 case ASC_WARN_EEPROM_CHKSUM:
 373                         aprint_normal("EEPROM checksum error\n");
 374                         break;
 375
 376                 case ASC_WARN_IRQ_MODIFIED:
 377                         aprint_normal("IRQ modified\n");
 378                         break;
 379
 380                 case ASC_WARN_CMD_QNG_CONFLICT:
 381                         aprint_normal("tag queuing enabled w/o disconnects\n");
 382                         break;
 383
 384                 default:
 385                         aprint_normal("unknown warning %d\n", warn);
 386                 }
 387         }
 388         if (sc->scsi_reset_wait > ASC_MAX_SCSI_RESET_WAIT)
 389                 sc->scsi_reset_wait = ASC_MAX_SCSI_RESET_WAIT;
 390
 391         /*
 392          * Modify the board configuration
 393          */
 394         warn = AscInitFromASC_SOFTC(sc);
 395         if (warn) {
 396                 aprint_error_dev(&sc->sc_dev, "-set: ");
 397                 switch (warn) {
 398                 case ASC_WARN_CMD_QNG_CONFLICT:
 399                         aprint_normal("tag queuing enabled w/o disconnects\n");
 400                         break;
 401
 402                 case ASC_WARN_AUTO_CONFIG:
 403                         aprint_normal("I/O port increment switch enabled\n");
 404                         break;
 405
 406                 default:
 407                         aprint_normal("unknown warning %d\n", warn);
 408                 }
 409         }
 410         sc->isr_callback = (ASC_CALLBACK) adv_narrow_isr_callback;
 411
 412         return (0);
 413 }
 414
 415
 416 void
 417 adv_attach(ASC_SOFTC *sc)
 418 {
 419         struct scsipi_adapter *adapt = &sc->sc_adapter;
 420         struct scsipi_channel *chan = &sc->sc_channel;
 421         int             i, error;
 422
 423         /*
 424          * Initialize board RISC chip and enable interrupts.
 425          */
 426         switch (AscInitDriver(sc)) {
 427         case 0:
 428                 /* AllOK */
 429                 break;
 430
 431         case 1:
 432                 panic("%s: bad signature", device_xname(&sc->sc_dev));
 433                 break;
 434
 435         case 2:
 436                 panic("%s: unable to load MicroCode",
 437                       device_xname(&sc->sc_dev));
 438                 break;
 439
 440         case 3:
 441                 panic("%s: unable to initialize MicroCode",
 442                       device_xname(&sc->sc_dev));
 443                 break;
 444
 445         default:
 446                 panic("%s: unable to initialize board RISC chip",
 447                       device_xname(&sc->sc_dev));
 448         }
 449
 450         /*
 451          * Fill in the scsipi_adapter.
 452          */
 453         memset(adapt, 0, sizeof(*adapt));
 454         adapt->adapt_dev = &sc->sc_dev;
 455         adapt->adapt_nchannels = 1;
 456         /* adapt_openings initialized below */
 457         /* adapt_max_periph initialized below */
 458         adapt->adapt_request = adv_scsipi_request;
 459         adapt->adapt_minphys = advminphys;
 460
 461         /*
 462          * Fill in the scsipi_channel.
 463          */
 464         memset(chan, 0, sizeof(*chan));
 465         chan->chan_adapter = adapt;
 466         chan->chan_bustype = &scsi_bustype;
 467         chan->chan_channel = 0;
 468         chan->chan_ntargets = 8;
 469         chan->chan_nluns = 8;
 470         chan->chan_id = sc->chip_scsi_id;
 471
 472         TAILQ_INIT(&sc->sc_free_ccb);
 473         TAILQ_INIT(&sc->sc_waiting_ccb);
 474
 475         /*
 476          * Allocate the Control Blocks and the overrun buffer.
 477          */
 478         error = adv_alloc_control_data(sc);
 479         if (error)
 480                 return; /* (error) */
 481
 482         /*
 483          * Create and initialize the Control Blocks.
 484          */
 485         i = adv_create_ccbs(sc, sc->sc_control->ccbs, ADV_MAX_CCB);
 486         if (i == 0) {
 487                 aprint_error_dev(&sc->sc_dev, "unable to create control blocks\n");
 488                 return; /* (ENOMEM) */ ;
 489         } else if (i != ADV_MAX_CCB) {
 490                 aprint_error_dev(&sc->sc_dev,
 491                     "WARNING: only %d of %d control blocks created\n",
 492                     i, ADV_MAX_CCB);
 493         }
 494
 495         adapt->adapt_openings = i;
 496         adapt->adapt_max_periph = adapt->adapt_openings;
 497
 498         sc->sc_child = config_found(&sc->sc_dev, chan, scsiprint);
 499 }
 500
 501 int
 502 adv_detach(ASC_SOFTC *sc, int flags)
 503 {
 504         int rv = 0;
 505
 506         if (sc->sc_child != NULL)
 507                 rv = config_detach(sc->sc_child, flags);
 508
 509         adv_free_control_data(sc);
 510
 511         return (rv);
 512 }
 513
 514 static void
 515 advminphys(struct buf *bp)
 516 {
 517
 518         if (bp->b_bcount > ((ASC_MAX_SG_LIST - 1) * PAGE_SIZE))
 519                 bp->b_bcount = ((ASC_MAX_SG_LIST - 1) * PAGE_SIZE);
 520         minphys(bp);
 521 }
 522
 523
 524 /*
 525  * start a scsi operation given the command and the data address.  Also needs
 526  * the unit, target and lu.
 527  */
 528
 529 static void
 530 adv_scsipi_request(struct scsipi_channel *chan, scsipi_adapter_req_t req, void *arg)
 531 {
 532         struct scsipi_xfer *xs;
 533         struct scsipi_periph *periph;
 534         ASC_SOFTC      *sc = (void *)chan->chan_adapter->adapt_dev;
 535         bus_dma_tag_t   dmat = sc->sc_dmat;
 536         ADV_CCB        *ccb;
 537         int             s, flags, error, nsegs;
 538
 539         switch (req) {
 540         case ADAPTER_REQ_RUN_XFER:
 541                 xs = arg;
 542                 periph = xs->xs_periph;
 543                 flags = xs->xs_control;
 544
 545                 /*
 546                  * Get a CCB to use.
 547                  */
 548                 ccb = adv_get_ccb(sc);
 549 #ifdef DIAGNOSTIC
 550                 /*
 551                  * This should never happen as we track the resources
 552                  * in the mid-layer.
 553                  */
 554                 if (ccb == NULL) {
 555                         scsipi_printaddr(periph);
 556                         printf("unable to allocate ccb\n");
 557                         panic("adv_scsipi_request");
 558                 }
 559 #endif
 560
 561                 ccb->xs = xs;
 562                 ccb->timeout = xs->timeout;
 563
 564                 /*
 565                  * Build up the request
 566                  */
 567                 memset(&ccb->scsiq, 0, sizeof(ASC_SCSI_Q));
 568
 569                 ccb->scsiq.q2.ccb_ptr =
 570                     sc->sc_dmamap_control->dm_segs[0].ds_addr +
 571                     ADV_CCB_OFF(ccb);
 572
 573                 ccb->scsiq.cdbptr = &xs->cmd->opcode;
 574                 ccb->scsiq.q2.cdb_len = xs->cmdlen;
 575                 ccb->scsiq.q1.target_id =
 576                     ASC_TID_TO_TARGET_ID(periph->periph_target);
 577                 ccb->scsiq.q1.target_lun = periph->periph_lun;
 578                 ccb->scsiq.q2.target_ix =
 579                     ASC_TIDLUN_TO_IX(periph->periph_target,
 580                     periph->periph_lun);
 581                 ccb->scsiq.q1.sense_addr =
 582                     sc->sc_dmamap_control->dm_segs[0].ds_addr +
 583                     ADV_CCB_OFF(ccb) + offsetof(struct adv_ccb, scsi_sense);
 584                 ccb->scsiq.q1.sense_len = sizeof(struct scsi_sense_data);
 585
 586                 /*
 587                  * If there are any outstanding requests for the current
 588                  * target, then every 255th request send an ORDERED request.
 589                  * This heuristic tries to retain the benefit of request
 590                  * sorting while preventing request starvation. 255 is the
 591                  * max number of tags or pending commands a device may have
 592                  * outstanding.
 593                  */
 594                 sc->reqcnt[periph->periph_target]++;
 595                 if (((sc->reqcnt[periph->periph_target] > 0) &&
 596                     (sc->reqcnt[periph->periph_target] % 255) == 0) ||
 597                     xs->bp == NULL || (xs->bp->b_flags & B_ASYNC) == 0) {
 598                         ccb->scsiq.q2.tag_code = M2_QTAG_MSG_ORDERED;
 599                 } else {
 600                         ccb->scsiq.q2.tag_code = M2_QTAG_MSG_SIMPLE;
 601                 }
 602
 603                 if (xs->datalen) {
 604                         /*
 605                          * Map the DMA transfer.
 606                          */
 607 #ifdef TFS
 608                         if (flags & SCSI_DATA_UIO) {
 609                                 error = bus_dmamap_load_uio(dmat,
 610                                     ccb->dmamap_xfer, (struct uio *) xs->data,
 611                                     ((flags & XS_CTL_NOSLEEP) ? BUS_DMA_NOWAIT :
 612                                      BUS_DMA_WAITOK) | BUS_DMA_STREAMING |
 613                                      ((flags & XS_CTL_DATA_IN) ? BUS_DMA_READ :
 614                                       BUS_DMA_WRITE));
 615                         } else
 616 #endif /* TFS */
 617                         {
 618                                 error = bus_dmamap_load(dmat, ccb->dmamap_xfer,
 619                                     xs->data, xs->datalen, NULL,
 620                                     ((flags & XS_CTL_NOSLEEP) ? BUS_DMA_NOWAIT :
 621                                      BUS_DMA_WAITOK) | BUS_DMA_STREAMING |
 622                                      ((flags & XS_CTL_DATA_IN) ? BUS_DMA_READ :
 623                                       BUS_DMA_WRITE));
 624                         }
 625
 626                         switch (error) {
 627                         case 0:
 628                                 break;
 629
 630
 631                         case ENOMEM:
 632                         case EAGAIN:
 633                                 xs->error = XS_RESOURCE_SHORTAGE;
 634                                 goto out_bad;
 635
 636                         default:
 637                                 xs->error = XS_DRIVER_STUFFUP;
 638                                 if (error == EFBIG) {
 639                                         aprint_error_dev(&sc->sc_dev, "adv_scsi_cmd, more than %d"
 640                                             " DMA segments\n",
 641                                             ASC_MAX_SG_LIST);
 642                                 } else {
 643                                         aprint_error_dev(&sc->sc_dev, "adv_scsi_cmd, error %d"
 644                                             " loading DMA map\n",
 645                                             error);
 646                                 }
 647
 648 out_bad:
 649                                 adv_free_ccb(sc, ccb);
 650                                 scsipi_done(xs);
 651                                 return;
 652                         }
 653                         bus_dmamap_sync(dmat, ccb->dmamap_xfer, 0,
 654                             ccb->dmamap_xfer->dm_mapsize,
 655                             (flags & XS_CTL_DATA_IN) ?
 656                              BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE);
 657
 658                         memset(&ccb->sghead, 0, sizeof(ASC_SG_HEAD));
 659
 660                         for (nsegs = 0;
 661                              nsegs < ccb->dmamap_xfer->dm_nsegs; nsegs++) {
 662                                 ccb->sghead.sg_list[nsegs].addr =
 663                                     ccb->dmamap_xfer->dm_segs[nsegs].ds_addr;
 664                                 ccb->sghead.sg_list[nsegs].bytes =
 665                                     ccb->dmamap_xfer->dm_segs[nsegs].ds_len;
 666                         }
 667
 668                         ccb->sghead.entry_cnt = ccb->scsiq.q1.sg_queue_cnt =
 669                             ccb->dmamap_xfer->dm_nsegs;
 670
 671                         ccb->scsiq.q1.cntl |= ASC_QC_SG_HEAD;
 672                         ccb->scsiq.sg_head = &ccb->sghead;
 673                         ccb->scsiq.q1.data_addr = 0;
 674                         ccb->scsiq.q1.data_cnt = 0;
 675                 } else {
 676                         /*
 677                          * No data xfer, use non S/G values.
 678                          */
 679                         ccb->scsiq.q1.data_addr = 0;
 680                         ccb->scsiq.q1.data_cnt = 0;
 681                 }
 682
 683 #ifdef ASC_DEBUG
 684                 printf("id = %d, lun = %d, cmd = %d, ccb = 0x%lX\n",
 685                     periph->periph_target,
 686                     periph->periph_lun, xs->cmd->opcode,
 687                     (unsigned long)ccb);
 688 #endif
 689                 s = splbio();
 690                 adv_queue_ccb(sc, ccb);
 691                 splx(s);
 692
 693                 if ((flags & XS_CTL_POLL) == 0)
 694                         return;
 695
 696                 /* Not allowed to use interrupts, poll for completion. */
 697                 if (adv_poll(sc, xs, ccb->timeout)) {
 698                         adv_timeout(ccb);
 699                         if (adv_poll(sc, xs, ccb->timeout))
 700                                 adv_timeout(ccb);
 701                 }
 702                 return;
 703
 704         case ADAPTER_REQ_GROW_RESOURCES:
 705                 /* XXX Not supported. */
 706                 return;
 707
 708         case ADAPTER_REQ_SET_XFER_MODE:
 709             {
 710                 /*
 711                  * We can't really set the mode, but we know how to
 712                  * query what the firmware negotiated.
 713                  */
 714                 struct scsipi_xfer_mode *xm = arg;
 715                 u_int8_t sdtr_data;
 716                 ASC_SCSI_BIT_ID_TYPE tid_bit;
 717
 718                 tid_bit = ASC_TIX_TO_TARGET_ID(xm->xm_target);
 719
 720                 xm->xm_mode = 0;
 721                 xm->xm_period = 0;
 722                 xm->xm_offset = 0;
 723
 724                 if (sc->init_sdtr & tid_bit) {
 725                         xm->xm_mode |= PERIPH_CAP_SYNC;
 726                         sdtr_data = sc->sdtr_data[xm->xm_target];
 727                         xm->xm_period =
 728                             sc->sdtr_period_tbl[(sdtr_data >> 4) &
 729                             (sc->max_sdtr_index - 1)];
 730                         xm->xm_offset = sdtr_data & ASC_SYN_MAX_OFFSET;
 731                 }
 732
 733                 if (sc->use_tagged_qng & tid_bit)
 734                         xm->xm_mode |= PERIPH_CAP_TQING;
 735
 736                 scsipi_async_event(chan, ASYNC_EVENT_XFER_MODE, xm);
 737                 return;
 738             }
 739         }
 740 }
 741
 742 int
 743 adv_intr(void *arg)
 744 {
 745         ASC_SOFTC      *sc = arg;
 746
 747 #ifdef ASC_DEBUG
 748         int int_pend = FALSE;
 749
 750         if(ASC_IS_INT_PENDING(sc->sc_iot, sc->sc_ioh))
 751         {
 752                 int_pend = TRUE;
 753                 printf("ISR - ");
 754         }
 755 #endif
 756         AscISR(sc);
 757 #ifdef ASC_DEBUG
 758         if(int_pend)
 759                 printf("\n");
 760 #endif
 761
 762         return (1);
 763 }
 764
 765
 766 /*
 767  * Poll a particular unit, looking for a particular xs
 768  */
 769 static int
 770 adv_poll(ASC_SOFTC *sc, struct scsipi_xfer *xs, int count)
 771 {
 772
 773         /* timeouts are in msec, so we loop in 1000 usec cycles */
 774         while (count) {
 775                 adv_intr(sc);
 776                 if (xs->xs_status & XS_STS_DONE)
 777                         return (0);
 778                 delay(1000);    /* only happens in boot so ok */
 779                 count--;
 780         }
 781         return (1);
 782 }
 783
 784
 785 static void
 786 adv_timeout(void *arg)
 787 {
 788         ADV_CCB        *ccb = arg;
 789         struct scsipi_xfer *xs = ccb->xs;
 790         struct scsipi_periph *periph = xs->xs_periph;
 791         ASC_SOFTC      *sc =
 792             (void *)periph->periph_channel->chan_adapter->adapt_dev;
 793         int             s;
 794
 795         scsipi_printaddr(periph);
 796         printf("timed out");
 797
 798         s = splbio();
 799
 800         /*
 801          * If it has been through before, then a previous abort has failed,
 802          * don't try abort again, reset the bus instead.
 803          */
 804         if (ccb->flags & CCB_ABORT) {
 805                 /* abort timed out */
 806                 printf(" AGAIN. Resetting Bus\n");
 807                 /* Lets try resetting the bus! */
 808                 if (AscResetBus(sc) == ASC_ERROR) {
 809                         ccb->timeout = sc->scsi_reset_wait;
 810                         adv_queue_ccb(sc, ccb);
 811                 }
 812         } else {
 813                 /* abort the operation that has timed out */
 814                 printf("\n");
 815                 AscAbortCCB(sc, ccb);
 816                 ccb->xs->error = XS_TIMEOUT;
 817                 ccb->timeout = ADV_ABORT_TIMEOUT;
 818                 ccb->flags |= CCB_ABORT;
 819                 adv_queue_ccb(sc, ccb);
 820         }
 821
 822         splx(s);
 823 }
 824
 825
 826 static void
 827 adv_watchdog(void *arg)
 828 {
 829         ADV_CCB        *ccb = arg;
 830         struct scsipi_xfer *xs = ccb->xs;
 831         struct scsipi_periph *periph = xs->xs_periph;
 832         ASC_SOFTC      *sc =
 833             (void *)periph->periph_channel->chan_adapter->adapt_dev;
 834         int             s;
 835
 836         s = splbio();
 837
 838         ccb->flags &= ~CCB_WATCHDOG;
 839         adv_start_ccbs(sc);
 840
 841         splx(s);
 842 }
 843
 844
 845 /******************************************************************************/
 846 /*                      NARROW boards Interrupt callbacks                     */
 847 /******************************************************************************/
 848
 849
 850 /*
 851  * adv_narrow_isr_callback() - Second Level Interrupt Handler called by AscISR()
 852  *
 853  * Interrupt callback function for the Narrow SCSI Asc Library.
 854  */
 855 static void
 856 adv_narrow_isr_callback(ASC_SOFTC *sc, ASC_QDONE_INFO *qdonep)
 857 {
 858         bus_dma_tag_t   dmat = sc->sc_dmat;
 859         ADV_CCB        *ccb;
 860         struct scsipi_xfer *xs;
 861         struct scsi_sense_data *s1, *s2;
 862
 863
 864         ccb = adv_ccb_phys_kv(sc, qdonep->d2.ccb_ptr);
 865         xs = ccb->xs;
 866
 867 #ifdef ASC_DEBUG
 868         printf(" - ccb=0x%lx, id=%d, lun=%d, cmd=%d, ",
 869                         (unsigned long)ccb,
 870                         xs->xs_periph->periph_target,
 871                         xs->xs_periph->periph_lun, xs->cmd->opcode);
 872 #endif
 873         callout_stop(&ccb->xs->xs_callout);
 874
 875         /*
 876          * If we were a data transfer, unload the map that described
 877          * the data buffer.
 878          */
 879         if (xs->datalen) {
 880                 bus_dmamap_sync(dmat, ccb->dmamap_xfer, 0,
 881                                 ccb->dmamap_xfer->dm_mapsize,
 882                          (xs->xs_control & XS_CTL_DATA_IN) ?
 883                          BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE);
 884                 bus_dmamap_unload(dmat, ccb->dmamap_xfer);
 885         }
 886         if ((ccb->flags & CCB_ALLOC) == 0) {
 887                 aprint_error_dev(&sc->sc_dev, "exiting ccb not allocated!\n");
 888                 Debugger();
 889                 return;
 890         }
 891         /*
 892          * 'qdonep' contains the command's ending status.
 893          */
 894 #ifdef ASC_DEBUG
 895         printf("d_s=%d, h_s=%d", qdonep->d3.done_stat, qdonep->d3.host_stat);
 896 #endif
 897         switch (qdonep->d3.done_stat) {
 898         case ASC_QD_NO_ERROR:
 899                 switch (qdonep->d3.host_stat) {
 900                 case ASC_QHSTA_NO_ERROR:
 901                         xs->error = XS_NOERROR;
 902                         xs->resid = 0;
 903                         break;
 904
 905                 default:
 906                         /* QHSTA error occurred */
 907                         xs->error = XS_DRIVER_STUFFUP;
 908                         break;
 909                 }
 910
 911                 /*
 912                  * If an INQUIRY command completed successfully, then call
 913                  * the AscInquiryHandling() function to patch bugged boards.
 914                  */
 915                 if ((xs->cmd->opcode == SCSICMD_Inquiry) &&
 916                     (xs->xs_periph->periph_lun == 0) &&
 917                     (xs->datalen - qdonep->remain_bytes) >= 8) {
 918                         AscInquiryHandling(sc,
 919                                       xs->xs_periph->periph_target & 0x7,
 920                                            (ASC_SCSI_INQUIRY *) xs->data);
 921                 }
 922                 break;
 923
 924         case ASC_QD_WITH_ERROR:
 925                 switch (qdonep->d3.host_stat) {
 926                 case ASC_QHSTA_NO_ERROR:
 927                         if (qdonep->d3.scsi_stat == SS_CHK_CONDITION) {
 928                                 s1 = &ccb->scsi_sense;
 929                                 s2 = &xs->sense.scsi_sense;
 930                                 *s2 = *s1;
 931                                 xs->error = XS_SENSE;
 932                         } else {
 933                                 xs->error = XS_DRIVER_STUFFUP;
 934                         }
 935                         break;
 936
 937                 case ASC_QHSTA_M_SEL_TIMEOUT:
 938                         xs->error = XS_SELTIMEOUT;
 939                         break;
 940
 941                 default:
 942                         /* QHSTA error occurred */
 943                         xs->error = XS_DRIVER_STUFFUP;
 944                         break;
 945                 }
 946                 break;
 947
 948         case ASC_QD_ABORTED_BY_HOST:
 949         default:
 950                 xs->error = XS_DRIVER_STUFFUP;
 951                 break;
 952         }
 953
 954
 955         adv_free_ccb(sc, ccb);
 956         scsipi_done(xs);
 957 }