root/dev/ic/aic79xx_openbsd.c

DEFINITIONS

1. ahd_attach
2. ahd_platform_intr
3. ahd_done
4. ahd_minphys
5. ahd_action
6. ahd_execute_scb
7. ahd_poll
8. ahd_setup_data
9. ahd_platform_set_tags
10. ahd_platform_alloc
11. ahd_platform_free
12. ahd_softc_comp
13. ahd_detach
14. ahd_adapter_req_set_xfer_mode
15. aic_timer_reset
16. aic_scb_timer_reset
17. ahd_flush_device_writes
18. aic_platform_scb_free
19. ahd_print_path
20. ahd_platform_dump_card_state
21. ahd_platform_flushwork

    1 /*      $OpenBSD: aic79xx_openbsd.c,v 1.26 2006/11/28 23:59:45 dlg Exp $        */
    3 /*
    4  * Copyright (c) 2004 Milos Urbanek, Kenneth R. Westerback & Marco Peereboom
    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 AUTHORS 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 AUTHORS OR CONTRIBUTORS BE LIABLE FOR
   20  * 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  */
   30 /*
   31  * Bus independent OpenBSD shim for the aic79xx based Adaptec SCSI controllers
   32  *
   33  * Copyright (c) 1994-2002 Justin T. Gibbs.
   34  * Copyright (c) 2001-2002 Adaptec Inc.
   35  * All rights reserved.
   36  *
   37  * Redistribution and use in source and binary forms, with or without
   38  * modification, are permitted provided that the following conditions
   39  * are met:
   40  * 1. Redistributions of source code must retain the above copyright
   41  *    notice, this list of conditions, and the following disclaimer,
   42  *    without modification.
   43  * 2. The name of the author may not be used to endorse or promote products
   44  *    derived from this software without specific prior written permission.
   45  *
   46  * Alternatively, this software may be distributed under the terms of the
   47  * GNU Public License ("GPL").
   48  *
   49  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   50  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   51  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   52  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
   53  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   54  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   55  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   56  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   57  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   58  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   59  * SUCH DAMAGE.
   60  *
   61  */
   63 #include <sys/cdefs.h>
   64 /*
   65 __FBSDID("$FreeBSD: src/sys/dev/aic7xxx/aic79xx_osm.c,v 1.16 2003/12/17 00:02:09 gibbs Exp $");
   66 */
   68 #include <dev/ic/aic79xx_openbsd.h>
   69 #include <dev/ic/aic79xx_inline.h>
   70 #include <dev/ic/aic79xx.h>
   72 #ifndef AHD_TMODE_ENABLE
   73 #define AHD_TMODE_ENABLE 0
   74 #endif
   76 /* XXX milos add ahd_ioctl */
   77 int     ahd_action(struct scsi_xfer *);
   78 int     ahd_execute_scb(void *, bus_dma_segment_t *, int);
   79 int     ahd_poll(struct ahd_softc *, int);
   80 int     ahd_setup_data(struct ahd_softc *, struct scsi_xfer *, 
   81                     struct scb *);
   83 void    ahd_adapter_req_set_xfer_mode(struct ahd_softc *, struct scb *);
   84 void    ahd_minphys(struct buf *);
   86 struct cfdriver ahd_cd = {
NULL, "ahd", DV_DULL
   88 };
   90 static struct scsi_adapter ahd_switch =
   91 {
ahd_action,
ahd_minphys,
   94         0,
   95         0,
   96 };
   98 /* the below structure is so we have a default dev struct for our link struct */
   99 static struct scsi_device ahd_dev =
  100 {
NULL, /* Use default error handler */
NULL, /* have a queue, served by this */
NULL, /* have no async handler */
NULL, /* Use default 'done' routine */
  105 };
  107 /*
  108  * Attach all the sub-devices we can find
  109  */
  110 int
ahd_attach(struct ahd_softc *ahd)
  112 {
  113         struct scsibus_attach_args saa;
  114         char   ahd_info[256];
  115         int     s;
ahd_controller_info(ahd, ahd_info, sizeof ahd_info);
printf("%s\n", ahd_info);
ahd_lock(ahd, &s);
  121         /*
  122          * fill in the prototype scsi_links.
  123          */
ahd->sc_channel.adapter_target = ahd->our_id;
  125         if (ahd->features & AHD_WIDE)
ahd->sc_channel.adapter_buswidth = 16;
ahd->sc_channel.adapter_softc = ahd;
ahd->sc_channel.adapter = &ahd_switch;
ahd->sc_channel.openings = 16;
ahd->sc_channel.device = &ahd_dev;
  132         if (bootverbose) {
ahd_controller_info(ahd, ahd_info, sizeof ahd_info);
printf("%s: %s\n", ahd->sc_dev.dv_xname, ahd_info);
  135         }
ahd_intr_enable(ahd, TRUE);
  139         if (ahd->flags & AHD_RESET_BUS_A)
ahd_reset_channel(ahd, 'A', TRUE);
bzero(&saa, sizeof(saa));
saa.saa_sc_link = &ahd->sc_channel;
ahd->sc_child = config_found((void *)&ahd->sc_dev, &saa, scsiprint);
ahd_unlock(ahd, &s);
  149         return (1);
  151 }
  153 /*
  154  * Catch an interrupt from the adapter
  155  */
  156 int
ahd_platform_intr(void *arg)
  158 {
  159         struct  ahd_softc *ahd;
  161         /* XXX in ahc there is some bus_dmamap_sync(PREREAD|PREWRITE); */
ahd = (struct ahd_softc *)arg; 
  164         return ahd_intr(ahd);
  165 }
  167 /*
  168  * We have an scb which has been processed by the
  169  * adaptor, now we look to see how the operation
  170  * went.
  171  */
  172 void
ahd_done(struct ahd_softc *ahd, struct scb *scb)
  174 {
  175         struct scsi_xfer *xs = scb->xs;
  176         int s;
  178         /* XXX in ahc there is some bus_dmamap_sync(PREREAD|PREWRITE); */
LIST_REMOVE(scb, pending_links);
timeout_del(&xs->stimeout);
  184         if (xs->datalen) {
  185                 int op;
  187                 if ((xs->flags & SCSI_DATA_IN) != 0)
op = BUS_DMASYNC_POSTREAD;
  189                 else
op = BUS_DMASYNC_POSTWRITE;
bus_dmamap_sync(ahd->parent_dmat, scb->dmamap, 0,
scb->dmamap->dm_mapsize, op);
bus_dmamap_unload(ahd->parent_dmat, scb->dmamap);
  194         }
  196         /* Translate the CAM status code to a SCSI error code. */
  197         switch (xs->error) {
  198         case CAM_SCSI_STATUS_ERROR:
  199         case CAM_REQ_INPROG:
  200         case CAM_REQ_CMP:
  201                 switch (xs->status) {
  202                 case SCSI_TASKSET_FULL:
  203                         /* SCSI Layer won't requeue, so we force infinite
  204                          * retries until queue space is available. XS_BUSY
  205                          * is dangerous because if the NOSLEEP flag is set
  206                          * it can cause the I/O to return EIO. XS_BUSY code
  207                          * falls through to XS_TIMEOUT anyway.
  208                          */ 
xs->error = XS_TIMEOUT;
xs->retries++;
  211                         break;
  212                 case SCSI_BUSY:
xs->error = XS_BUSY;
  214                         break;
  215                 case SCSI_CHECK:
  216                 case SCSI_TERMINATED:
  217                         if ((scb->flags & SCB_SENSE) == 0) {
  218                                 /* CHECK on CHECK? */
xs->error = XS_DRIVER_STUFFUP;
  220                         } else
xs->error = XS_NOERROR;
  222                         break;
  223                 default:
xs->error = XS_NOERROR;
  225                         break;
  226                 }
  227                 break;
  228         case CAM_BUSY:
xs->error = XS_BUSY;
  230                 break;
  231         case CAM_CMD_TIMEOUT:
xs->error = XS_TIMEOUT;
  233                 break;
  234         case CAM_BDR_SENT:
  235         case CAM_SCSI_BUS_RESET:
xs->error = XS_RESET;
  237                 break;
  238         case CAM_REQUEUE_REQ:
xs->error = XS_TIMEOUT;
xs->retries++;
  241                 break;
  242         case CAM_SEL_TIMEOUT:
xs->error = XS_SELTIMEOUT;
  244                 break;
  245         default:
xs->error = XS_DRIVER_STUFFUP;
  247                 break;
  248         }
  250         if (xs->error != XS_NOERROR) {
  251                 /* Don't clobber any existing error state */
  252         } else if ((scb->flags & SCB_SENSE) != 0) {
  253                 /*
  254                  * We performed autosense retrieval.
  255                  *
  256                  * Zero any sense not transferred by the
  257                  * device.  The SCSI spec mandates that any
  258                  * untransfered data should be assumed to be
  259                  * zero.  Complete the 'bounce' of sense information
  260                  * through buffers accessible via bus-space by
  261                  * copying it into the clients csio.
  262                  */
memset(&xs->sense, 0, sizeof(struct scsi_sense_data));
memcpy(&xs->sense, ahd_get_sense_buf(ahd, scb),
  265                     sizeof(struct scsi_sense_data));
xs->error = XS_SENSE;
  267         } else if ((scb->flags & SCB_PKT_SENSE) != 0) {
  268                 struct scsi_status_iu_header *siu;
u_int32_t len;
siu = (struct scsi_status_iu_header *)scb->sense_data;
len = SIU_SENSE_LENGTH(siu);
memset(&xs->sense, 0, sizeof(xs->sense));
memcpy(&xs->sense, SIU_SENSE_DATA(siu),
ulmin(len, sizeof(xs->sense)));
xs->error = XS_SENSE;
  277         }
ahd_lock(ahd, &s);
ahd_free_scb(ahd, scb);
ahd_unlock(ahd, &s);
xs->flags |= ITSDONE;
scsi_done(xs);
  285 }
  287 void
ahd_minphys(struct buf *bp)
  289 {
  290         /*
  291          * Even though the card can transfer up to 16megs per command
  292          * we are limited by the number of segments in the dma segment
  293          * list that we can hold.  The worst case is that all pages are
  294          * discontinuous physically, hence the "page per segment" limit
  295          * enforced here.
  296          */
  297         if (bp->b_bcount > ((AHD_NSEG - 1) * PAGE_SIZE)) {
bp->b_bcount = ((AHD_NSEG - 1) * PAGE_SIZE);
  299         }
minphys(bp);
  301 }
int32_t
ahd_action(struct scsi_xfer *xs)
  305 {
  306         struct  ahd_softc *ahd;
  307         struct scb *scb;
  308         struct hardware_scb *hscb;
u_int   target_id;
u_int   our_id;
  311         int     s;
  312         int     dontqueue = 0;
  313         struct  ahd_initiator_tinfo *tinfo;
  314         struct  ahd_tmode_tstate *tstate;
u_int   col_idx;
u_int16_t quirks;
SC_DEBUG(xs->sc_link, SDEV_DB3, ("ahd_action\n"));
ahd = (struct ahd_softc *)xs->sc_link->adapter_softc;
  321         /* determine safety of software queueing */
dontqueue = xs->flags & SCSI_POLL;
target_id = xs->sc_link->target;
our_id = SCSI_SCSI_ID(ahd, xs->sc_link);
  327         if ((ahd->flags & AHD_INITIATORROLE) == 0) {
xs->error = XS_DRIVER_STUFFUP;
xs->flags |= ITSDONE;
scsi_done(xs);
  331                 return (COMPLETE);
  332                 /* return       ccb->ccb_h.status = CAM_PROVIDE_FAIL; */
  333         }
  334         /*
  335          * get an scb to use.
  336          */
ahd_lock(ahd, &s);
tinfo = ahd_fetch_transinfo(ahd, 'A', our_id, target_id, &tstate);
quirks = xs->sc_link->quirks;
  342         if ((quirks & SDEV_NOTAGS) != 0 || 
  343             (tinfo->curr.ppr_options & MSG_EXT_PPR_PROT_IUS) != 0)
col_idx = AHD_NEVER_COL_IDX;
  345         else
col_idx = AHD_BUILD_COL_IDX(target_id, xs->sc_link->lun);
  348         if ((scb = ahd_get_scb(ahd, col_idx)) == NULL) {
ahd->flags |= AHD_RESOURCE_SHORTAGE;
ahd_unlock(ahd, &s);
  351                 return (TRY_AGAIN_LATER);
  352         }
ahd_unlock(ahd, &s);
hscb = scb->hscb;
SC_DEBUG(xs->sc_link, SDEV_DB3, ("start scb(%p)\n", scb));
scb->xs = xs;
timeout_set(&xs->stimeout, ahd_timeout, scb);
  362         /*
  363          * Put all the arguments for the xfer in the scb
  364          */
hscb->control = 0;
hscb->scsiid = BUILD_SCSIID(ahd, xs->sc_link, target_id, our_id);
hscb->lun = xs->sc_link->lun;
  368         if (xs->xs_control & XS_CTL_RESET) {
hscb->cdb_len = 0;
scb->flags |= SCB_DEVICE_RESET;
hscb->control |= MK_MESSAGE;
hscb->task_management = SIU_TASKMGMT_LUN_RESET;
  373                 return (ahd_execute_scb(scb, NULL, 0));
  374         } else {
hscb->task_management = 0;
  376                 return (ahd_setup_data(ahd, xs, scb));
  377         }
  378 }
  380 int
ahd_execute_scb(void *arg, bus_dma_segment_t *dm_segs, int nsegments)
  382 {
  383         struct  scb *scb;
  384         struct  scsi_xfer *xs;
  385         struct  ahd_softc *ahd;
  386         struct  ahd_initiator_tinfo *tinfo;
  387         struct  ahd_tmode_tstate *tstate;
u_int   mask;
  389         int     s;
scb = (struct scb *)arg;
xs = scb->xs;
xs->error = CAM_REQ_INPROG;
xs->status = 0;
ahd = (struct ahd_softc *)xs->sc_link->adapter_softc;
  397         if (nsegments != 0) {
  398                 void *sg;
  399                 int op;
u_int i;
ahd_setup_data_scb(ahd, scb);
  404                 /* Copy the segments into our SG list */
  405                 for (i = nsegments, sg = scb->sg_list; i > 0; i--) {
sg = ahd_sg_setup(ahd, scb, sg, dm_segs->ds_addr,
dm_segs->ds_len,
  409                                           /*last*/i == 1);
dm_segs++;
  411                 }
  413                 if ((xs->flags & SCSI_DATA_IN) != 0)
op = BUS_DMASYNC_PREREAD;
  415                 else
op = BUS_DMASYNC_PREWRITE;
bus_dmamap_sync(ahd->parent_dmat, scb->dmamap, 0,
scb->dmamap->dm_mapsize, op);
  421         }
ahd_lock(ahd, &s);
  425         /*
  426          * Last time we need to check if this SCB needs to
  427          * be aborted.
  428          */
  429         if (xs->flags & ITSDONE) {
  430                 if (nsegments != 0)
bus_dmamap_unload(ahd->parent_dmat,
scb->dmamap);
ahd_free_scb(ahd, scb);
ahd_unlock(ahd, &s);
  435                 return (COMPLETE);
  436         }
tinfo = ahd_fetch_transinfo(ahd, SCSIID_CHANNEL(ahd, scb->hscb->scsiid),
SCSIID_OUR_ID(scb->hscb->scsiid),
SCSIID_TARGET(ahd, scb->hscb->scsiid),
  441                                     &tstate);
mask = SCB_GET_TARGET_MASK(ahd, scb);
  445         if ((tstate->discenable & mask) != 0)
scb->hscb->control |= DISCENB;
  448         if ((tstate->tagenable & mask) != 0)
scb->hscb->control |= TAG_ENB;
  451         if ((tinfo->curr.ppr_options & MSG_EXT_PPR_PROT_IUS) != 0) {
scb->flags |= SCB_PACKETIZED;
  453                 if (scb->hscb->task_management != 0)
scb->hscb->control &= ~MK_MESSAGE;
  455         }
  457         if ((tstate->auto_negotiate & mask) != 0) {
scb->flags |= SCB_AUTO_NEGOTIATE;
scb->hscb->control |= MK_MESSAGE;
  460         }
  462         /* XXX with ahc there was some bus_dmamap_sync(PREREAD|PREWRITE); */
LIST_INSERT_HEAD(&ahd->pending_scbs, scb, pending_links);
  466         if (!(xs->flags & SCSI_POLL))
timeout_add(&xs->stimeout, (xs->timeout * hz) / 1000);
scb->flags |= SCB_ACTIVE;
  471         if ((scb->flags & SCB_TARGET_IMMEDIATE) != 0) {
  472                 /* Define a mapping from our tag to the SCB. */
ahd->scb_data.scbindex[SCB_GET_TAG(scb)] = scb;
ahd_pause(ahd);
ahd_set_scbptr(ahd, SCB_GET_TAG(scb));
ahd_outb(ahd, RETURN_1, CONT_MSG_LOOP_TARG);
ahd_unpause(ahd);
  478         } else {
ahd_queue_scb(ahd, scb);
  480         }
  482         if (!(xs->flags & SCSI_POLL)) {
  483                 int target = xs->sc_link->target;
  484                 int lun = SCB_GET_LUN(scb);
  486                 if (ahd->inited_target[target] == 0) {
  487                         struct  ahd_devinfo devinfo;
ahd_adapter_req_set_xfer_mode(ahd, scb);
ahd_compile_devinfo(&devinfo, ahd->our_id, target, lun,
  491                             'A', /*XXX milos*/ROLE_UNKNOWN);
ahd_scb_devinfo(ahd, &devinfo, scb);
ahd_update_neg_request(ahd, &devinfo, tstate, tinfo,
AHD_NEG_IF_NON_ASYNC);
ahd->inited_target[target] = 1;
  496                 }
ahd_unlock(ahd, &s);
  499                 return (SUCCESSFULLY_QUEUED);
  500         }
  502         /*
  503          * If we can't use interrupts, poll for completion
  504          */
SC_DEBUG(xs->sc_link, SDEV_DB3, ("cmd_poll\n"));
  507         do {
  508                 if (ahd_poll(ahd, xs->timeout)) {
  509                         if (!(xs->flags & SCSI_SILENT))
printf("cmd fail\n");
ahd_timeout(scb);
  512                         break;
  513                 }
  514         } while (!(xs->flags & ITSDONE));
ahd_unlock(ahd, &s);
  517         return (COMPLETE);
  518 }
  520 int
ahd_poll(struct ahd_softc *ahd, int wait)
  522 {
  523         while (--wait) {
DELAY(1000);
  525                 if (ahd_inb(ahd, INTSTAT) & INT_PEND)
  526                         break;
  527         }
  529         if (wait == 0) {
printf("%s: board is not responding\n", ahd_name(ahd));
  531                 return (EIO);
  532         }
ahd_intr((void *)ahd);
  535         return (0);
  536 }
  538 int
ahd_setup_data(struct ahd_softc *ahd, struct scsi_xfer *xs,
  540                struct scb *scb)
  541 {
  542         struct hardware_scb *hscb;
  543         int s;
hscb = scb->hscb;
xs->resid = xs->status = 0;
xs->error = CAM_REQ_INPROG;
hscb->cdb_len = xs->cmdlen;
  550         if (hscb->cdb_len > MAX_CDB_LEN) {
ahd_lock(ahd, &s);
ahd_free_scb(ahd, scb);
ahd_unlock(ahd, &s);
xs->error = XS_DRIVER_STUFFUP;
xs->flags |= ITSDONE;
scsi_done(xs);
  557                 return (COMPLETE);
  558         }
memcpy(hscb->shared_data.idata.cdb, xs->cmd, hscb->cdb_len);
  562         /* Only use S/G if there is a transfer */
  563         if (xs->datalen) {
  564                 int error;
error = bus_dmamap_load(ahd->parent_dmat,
scb->dmamap, xs->data,
xs->datalen, NULL,
  569                                         ((xs->flags & SCSI_NOSLEEP) ?
BUS_DMA_NOWAIT : BUS_DMA_WAITOK) |
BUS_DMA_STREAMING |
  572                                         ((xs->flags & XS_CTL_DATA_IN) ?
BUS_DMA_READ : BUS_DMA_WRITE));
  574                 if (error) {
  575 #ifdef AHD_DEBUG
printf("%s: in ahd_setup_data(): bus_dmamap_load() "
  577                             "= %d\n", ahd_name(ahd), error);
  578 #endif
ahd_lock(ahd, &s);
ahd_free_scb(ahd, scb);
ahd_unlock(ahd, &s);
  582                         return (TRY_AGAIN_LATER);       /* XXX fvdl */
  583                 }
error = ahd_execute_scb(scb, scb->dmamap->dm_segs,
scb->dmamap->dm_nsegs);
  586                 return error;
  587         } else {
  588                 return ahd_execute_scb(scb, NULL, 0);
  589         }
  590 }
  592 void
ahd_platform_set_tags(struct ahd_softc *ahd, struct ahd_devinfo *devinfo,
ahd_queue_alg alg)
  595 {
  596         struct ahd_tmode_tstate *tstate;
ahd_fetch_transinfo(ahd, devinfo->channel, devinfo->our_scsiid,
devinfo->target, &tstate);
  601         if (alg != AHD_QUEUE_NONE) 
tstate->tagenable |= devinfo->target_mask;
  603         else
tstate->tagenable &= ~devinfo->target_mask;
  605 }
  607 int
ahd_platform_alloc(struct ahd_softc *ahd, void *platform_arg)
  609 {
  610         if (sizeof(struct ahd_platform_data) > 0) {
ahd->platform_data = malloc(sizeof(struct ahd_platform_data),
M_DEVBUF, M_NOWAIT);
  613                 if (ahd->platform_data == NULL)
  614                         return (ENOMEM);
bzero(ahd->platform_data, sizeof(struct ahd_platform_data));
  616         }       
  618         return (0);
  619 }
  621 void
ahd_platform_free(struct ahd_softc *ahd)
  623 {
  624         if (sizeof(struct ahd_platform_data) > 0)
free(ahd->platform_data, M_DEVBUF);
  626 }
  628 int
ahd_softc_comp(struct ahd_softc *lahd, struct ahd_softc *rahd)
  630 {
  631         /* We don't sort softcs under OpenBSD so report equal always */
  632         return (0);
  633 }
  635 int
ahd_detach(struct device *self, int flags)
  637 {
  638         int rv = 0;
  640         struct ahd_softc *ahd = (struct ahd_softc*)self;
  642         if (ahd->sc_child != NULL)
rv = config_detach((void *)ahd->sc_child, flags);
  645         if (ahd->shutdown_hook != NULL)
shutdownhook_disestablish(ahd->shutdown_hook);
ahd_free(ahd);
  650         return rv;
  651 }
  653 void
ahd_adapter_req_set_xfer_mode(struct ahd_softc *ahd, struct scb *scb)
  655 {
  656         struct ahd_initiator_tinfo *tinfo;
  657         struct ahd_tmode_tstate *tstate;
  658         int target_id, our_id;
  659         struct ahd_devinfo devinfo;
u_int16_t quirks;
u_int width, ppr_options, period, offset;
  662         int s;
target_id = scb->xs->sc_link->target;
our_id = SCSI_SCSI_ID(ahd, scb->xs->sc_link);
s = splbio();
quirks = scb->xs->sc_link->quirks;
tinfo = ahd_fetch_transinfo(ahd, 'A', our_id, target_id, &tstate);
ahd_compile_devinfo(&devinfo, our_id, target_id, 0, 'A',
ROLE_INITIATOR);
tstate->discenable |= (ahd->user_discenable & devinfo.target_mask);
  676         if (quirks & SDEV_NOTAGS)
tstate->tagenable &= ~devinfo.target_mask;
  678         else if (ahd->user_tagenable & devinfo.target_mask)
tstate->tagenable |= devinfo.target_mask;
  681         if (quirks & SDEV_NOWIDE)
width = MSG_EXT_WDTR_BUS_8_BIT;
  683         else
width = MSG_EXT_WDTR_BUS_16_BIT;
ahd_validate_width(ahd, NULL, &width, ROLE_UNKNOWN);
  687         if (width > tinfo->user.width)
width = tinfo->user.width;
ahd_set_width(ahd, &devinfo, width, AHD_TRANS_GOAL, FALSE);
  691         if (quirks & SDEV_NOSYNC) {
period = 0;
offset = 0;
  694         } else {
period = tinfo->user.period;
offset = tinfo->user.offset;
  697         }
  699         /* XXX Look at saved INQUIRY flags for PPR capabilities XXX */
ppr_options = tinfo->user.ppr_options;
  701         /* XXX Other reasons to avoid ppr? XXX */
  702         if (width < MSG_EXT_WDTR_BUS_16_BIT)
ppr_options = 0;
  705         if ((tstate->discenable & devinfo.target_mask) == 0 ||
  706             (tstate->tagenable & devinfo.target_mask) == 0)
ppr_options &= ~MSG_EXT_PPR_PROT_IUS;
ahd_find_syncrate(ahd, &period, &ppr_options, AHD_SYNCRATE_MAX);
ahd_validate_offset(ahd, NULL, period, &offset, width, ROLE_UNKNOWN);
  712         if (offset == 0) {
period = 0;
ppr_options = 0;
  715         }
  717         if (ppr_options != 0 && tinfo->user.transport_version >= 3) {
tinfo->goal.transport_version = tinfo->user.transport_version;
tinfo->curr.transport_version = tinfo->user.transport_version;
  720         }
ahd_set_syncrate(ahd, &devinfo, period, offset, ppr_options,
AHD_TRANS_GOAL, FALSE);
splx(s);
  726 }
  728 void
aic_timer_reset(aic_timer_t *timer, u_int msec, ahd_callback_t *func,
  730     void *arg)
  731 {
uint64_t ticks;
ticks = msec;
ticks *= hz;
ticks /= 1000;
callout_reset(timer, ticks, func, arg);
  738 }
  740 void
aic_scb_timer_reset(struct scb *scb, u_int msec)
  742 {
uint64_t ticks;
ticks = msec;
ticks *= hz;
ticks /= 1000;
  748         if (!(scb->xs->xs_control & XS_CTL_POLL))
callout_reset(&scb->xs->xs_callout, ticks, ahd_timeout, scb);
  750 }
  752 void
ahd_flush_device_writes(struct ahd_softc *ahd)
  754 {
  755         /* XXX Is this sufficient for all architectures??? */
ahd_inb(ahd, INTSTAT);
  757 }
  759 void
aic_platform_scb_free(struct ahd_softc *ahd, struct scb *scb)
  761 {
  762         int s;
ahd_lock(ahd, &s);
  766         if ((ahd->flags & AHD_RESOURCE_SHORTAGE) != 0) {
ahd->flags &= ~AHD_RESOURCE_SHORTAGE;
  768         }
  770         if (!cold) {
  771                 /* we are no longer in autoconf */
timeout_del(&scb->xs->stimeout);
  773         }
ahd_unlock(ahd, &s);
  776 }
  778 void
ahd_print_path(struct ahd_softc *ahd, struct scb *scb)
  780 {
sc_print_addr(scb->xs->sc_link);
  782 }
  784 void
ahd_platform_dump_card_state(struct ahd_softc *ahd)
  786 {
  787         /* Nothing to do here for OpenBSD */
printf("FEATURES = 0x%x, FLAGS = 0x%x, CHIP = 0x%x BUGS =0x%x\n",
ahd->features, ahd->flags, ahd->chip, ahd->bugs);
  790 }
  792 void
ahd_platform_flushwork(struct ahd_softc *ahd)
  794 {
  795 }