The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/dev/iir/iir.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*
    2  *       Copyright (c) 2000-04 ICP vortex GmbH
    3  *       Copyright (c) 2002-04 Intel Corporation
    4  *       Copyright (c) 2003-04 Adaptec Inc.
    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  *    without modification, immediately at the beginning of the file.
   13  * 2. Redistributions in binary form must reproduce the above copyright
   14  *    notice, this list of conditions and the following disclaimer in the
   15  *    documentation and/or other materials provided with the distribution.
   16  * 3. The name of the author may not be used to endorse or promote products
   17  *    derived from this software without specific prior written permission.
   18  *
   19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   22  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
   23  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   29  * SUCH DAMAGE.
   30  */
   31 
   32 /*
   33  * iir.c: SCSI dependant code for the Intel Integrated RAID Controller driver
   34  *
   35  * Written by: Achim Leubner <achim_leubner@adaptec.com>
   36  * Fixes/Additions: Boji Tony Kannanthanam <boji.t.kannanthanam@intel.com>
   37  *
   38  * credits:     Niklas Hallqvist;       OpenBSD driver for the ICP Controllers.
   39  *              Mike Smith;             Some driver source code.
   40  *              FreeBSD.ORG;            Great O/S to work on and for.
   41  *
   42  * $Id: iir.c 1.5 2004/03/30 10:17:53 achim Exp $"
   43  */
   44 
   45 #include <sys/cdefs.h>
   46 __FBSDID("$FreeBSD: releng/5.3/sys/dev/iir/iir.c 134963 2004-09-08 19:54:36Z scottl $");
   47 
   48 #define _IIR_C_
   49 
   50 /* #include "opt_iir.h" */
   51 #include <sys/param.h>
   52 #include <sys/systm.h>
   53 #include <sys/endian.h>
   54 #include <sys/eventhandler.h>
   55 #include <sys/malloc.h>
   56 #include <sys/kernel.h>
   57 #include <sys/bus.h>
   58 
   59 #include <machine/bus_memio.h>
   60 #include <machine/bus_pio.h>
   61 #include <machine/bus.h>
   62 #include <machine/clock.h>
   63 #include <machine/stdarg.h>
   64 
   65 #include <cam/cam.h>
   66 #include <cam/cam_ccb.h>
   67 #include <cam/cam_sim.h>
   68 #include <cam/cam_xpt_sim.h>
   69 #include <cam/cam_debug.h>
   70 #include <cam/scsi/scsi_all.h>
   71 #include <cam/scsi/scsi_message.h>
   72 
   73 #include <vm/vm.h>
   74 #include <vm/pmap.h>
   75 
   76 #include <dev/iir/iir.h>
   77 
   78 struct gdt_softc *gdt_wait_gdt;
   79 int     gdt_wait_index;
   80 
   81 #ifdef GDT_DEBUG
   82 int     gdt_debug = GDT_DEBUG;
   83 #ifdef __SERIAL__
   84 #define MAX_SERBUF 160
   85 static void ser_init(void);
   86 static void ser_puts(char *str);
   87 static void ser_putc(int c);
   88 static char strbuf[MAX_SERBUF+1];
   89 #ifdef __COM2__
   90 #define COM_BASE 0x2f8
   91 #else
   92 #define COM_BASE 0x3f8
   93 #endif
   94 static void ser_init()
   95 {
   96     unsigned port=COM_BASE;
   97 
   98     outb(port+3, 0x80);
   99     outb(port+1, 0);
  100     /* 19200 Baud, if 9600: outb(12,port) */
  101     outb(port, 6);
  102     outb(port+3, 3);
  103     outb(port+1, 0);
  104 }
  105 
  106 static void ser_puts(char *str)
  107 {
  108     char *ptr;
  109 
  110     ser_init();
  111     for (ptr=str;*ptr;++ptr)
  112         ser_putc((int)(*ptr));
  113 }
  114 
  115 static void ser_putc(int c)
  116 {
  117     unsigned port=COM_BASE;
  118 
  119     while ((inb(port+5) & 0x20)==0);
  120     outb(port, c);
  121     if (c==0x0a)
  122     {
  123         while ((inb(port+5) & 0x20)==0);
  124         outb(port, 0x0d);
  125     }
  126 }
  127 
  128 int ser_printf(const char *fmt, ...)
  129 {
  130     va_list args;
  131     int i;
  132 
  133     va_start(args,fmt);
  134     i = vsprintf(strbuf,fmt,args);
  135     ser_puts(strbuf);
  136     va_end(args);
  137     return i;
  138 }
  139 #endif
  140 #endif
  141 
  142 /* The linked list of softc structures */
  143 struct gdt_softc_list gdt_softcs = TAILQ_HEAD_INITIALIZER(gdt_softcs);
  144 /* controller cnt. */
  145 int gdt_cnt = 0;
  146 /* event buffer */
  147 static gdt_evt_str ebuffer[GDT_MAX_EVENTS];
  148 static int elastidx, eoldidx;
  149 /* statistics */
  150 gdt_statist_t gdt_stat;
  151 
  152 /* Definitions for our use of the SIM private CCB area */
  153 #define ccb_sim_ptr     spriv_ptr0
  154 #define ccb_priority    spriv_field1
  155 
  156 static void     iir_action(struct cam_sim *sim, union ccb *ccb);
  157 static void     iir_poll(struct cam_sim *sim);
  158 static void     iir_shutdown(void *arg, int howto);
  159 static void     iir_timeout(void *arg);
  160 static void     iir_watchdog(void *arg);
  161 
  162 static void     gdt_eval_mapping(u_int32_t size, int *cyls, int *heads, 
  163                                  int *secs);
  164 static int      gdt_internal_cmd(struct gdt_softc *gdt, struct gdt_ccb *gccb, 
  165                                  u_int8_t service, u_int16_t opcode, 
  166                                  u_int32_t arg1, u_int32_t arg2, u_int32_t arg3);
  167 static int      gdt_wait(struct gdt_softc *gdt, struct gdt_ccb *ccb, 
  168                          int timeout);
  169 
  170 static struct gdt_ccb *gdt_get_ccb(struct gdt_softc *gdt);
  171 static u_int32_t gdt_ccb_vtop(struct gdt_softc *gdt, 
  172                               struct gdt_ccb *gccb);
  173 
  174 static int      gdt_sync_event(struct gdt_softc *gdt, int service, 
  175                                u_int8_t index, struct gdt_ccb *gccb);
  176 static int      gdt_async_event(struct gdt_softc *gdt, int service);
  177 static struct gdt_ccb *gdt_raw_cmd(struct gdt_softc *gdt, 
  178                                    union ccb *ccb, int *lock);
  179 static struct gdt_ccb *gdt_cache_cmd(struct gdt_softc *gdt, 
  180                                      union ccb *ccb, int *lock);
  181 static struct gdt_ccb *gdt_ioctl_cmd(struct gdt_softc *gdt, 
  182                                      gdt_ucmd_t *ucmd, int *lock);
  183 static void     gdt_internal_cache_cmd(struct gdt_softc *gdt,union ccb *ccb);
  184 
  185 static void     gdtmapmem(void *arg, bus_dma_segment_t *dm_segs,
  186                           int nseg, int error);
  187 static void     gdtexecuteccb(void *arg, bus_dma_segment_t *dm_segs,
  188                               int nseg, int error);
  189 
  190 int
  191 iir_init(struct gdt_softc *gdt)
  192 {
  193     u_int16_t cdev_cnt;
  194     int i, id, drv_cyls, drv_hds, drv_secs;
  195     struct gdt_ccb *gccb;
  196 
  197     GDT_DPRINTF(GDT_D_DEBUG, ("iir_init()\n"));
  198 
  199     gdt->sc_state = GDT_POLLING;
  200     gdt_clear_events(); 
  201     bzero(&gdt_stat, sizeof(gdt_statist_t));
  202 
  203     SLIST_INIT(&gdt->sc_free_gccb);
  204     SLIST_INIT(&gdt->sc_pending_gccb);
  205     TAILQ_INIT(&gdt->sc_ccb_queue);
  206     TAILQ_INIT(&gdt->sc_ucmd_queue);
  207     TAILQ_INSERT_TAIL(&gdt_softcs, gdt, links);
  208 
  209     /* DMA tag for mapping buffers into device visible space. */
  210     if (bus_dma_tag_create(gdt->sc_parent_dmat, /*alignment*/1, /*boundary*/0,
  211                            /*lowaddr*/BUS_SPACE_MAXADDR_32BIT,
  212                            /*highaddr*/BUS_SPACE_MAXADDR,
  213                            /*filter*/NULL, /*filterarg*/NULL,
  214                            /*maxsize*/MAXBSIZE, /*nsegments*/GDT_MAXSG,
  215                            /*maxsegsz*/BUS_SPACE_MAXSIZE_32BIT,
  216                            /*flags*/BUS_DMA_ALLOCNOW,
  217                            /*lockfunc*/busdma_lock_mutex, /*lockarg*/&Giant,
  218                            &gdt->sc_buffer_dmat) != 0) {
  219         printf("iir%d: bus_dma_tag_create(...,gdt->sc_buffer_dmat) failed\n",
  220                gdt->sc_hanum);
  221         return (1);
  222     }
  223     gdt->sc_init_level++;
  224 
  225     /* DMA tag for our ccb structures */
  226     if (bus_dma_tag_create(gdt->sc_parent_dmat,
  227                            /*alignment*/1,
  228                            /*boundary*/0,
  229                            /*lowaddr*/BUS_SPACE_MAXADDR_32BIT,
  230                            /*highaddr*/BUS_SPACE_MAXADDR,
  231                            /*filter*/NULL,
  232                            /*filterarg*/NULL,
  233                            GDT_MAXCMDS * sizeof(struct gdt_ccb), /* maxsize */
  234                            /*nsegments*/1,
  235                            /*maxsegsz*/BUS_SPACE_MAXSIZE_32BIT,
  236                            /*flags*/0, /*lockfunc*/busdma_lock_mutex,
  237                            /*lockarg*/&Giant, &gdt->sc_gccb_dmat) != 0) {
  238         printf("iir%d: bus_dma_tag_create(...,gdt->sc_gccb_dmat) failed\n",
  239                gdt->sc_hanum);
  240         return (1);
  241     }
  242     gdt->sc_init_level++;
  243 
  244     /* Allocation for our ccbs */
  245     if (bus_dmamem_alloc(gdt->sc_gccb_dmat, (void **)&gdt->sc_gccbs,
  246                          BUS_DMA_NOWAIT, &gdt->sc_gccb_dmamap) != 0) {
  247         printf("iir%d: bus_dmamem_alloc(...,&gdt->sc_gccbs,...) failed\n",
  248                gdt->sc_hanum);
  249         return (1);
  250     }
  251     gdt->sc_init_level++;
  252 
  253     /* And permanently map them */
  254     bus_dmamap_load(gdt->sc_gccb_dmat, gdt->sc_gccb_dmamap,
  255                     gdt->sc_gccbs, GDT_MAXCMDS * sizeof(struct gdt_ccb),
  256                     gdtmapmem, &gdt->sc_gccb_busbase, /*flags*/0);
  257     gdt->sc_init_level++;
  258 
  259     /* Clear them out. */
  260     bzero(gdt->sc_gccbs, GDT_MAXCMDS * sizeof(struct gdt_ccb));
  261 
  262     /* Initialize the ccbs */
  263     for (i = GDT_MAXCMDS-1; i >= 0; i--) {
  264         gdt->sc_gccbs[i].gc_cmd_index = i + 2;
  265         gdt->sc_gccbs[i].gc_flags = GDT_GCF_UNUSED;
  266         gdt->sc_gccbs[i].gc_map_flag = FALSE;
  267         if (bus_dmamap_create(gdt->sc_buffer_dmat, /*flags*/0,
  268                               &gdt->sc_gccbs[i].gc_dmamap) != 0)
  269             return(1);
  270         gdt->sc_gccbs[i].gc_map_flag = TRUE;
  271         SLIST_INSERT_HEAD(&gdt->sc_free_gccb, &gdt->sc_gccbs[i], sle);
  272     }
  273     gdt->sc_init_level++;
  274 
  275     /* create the control device */
  276     gdt->sc_dev = gdt_make_dev(gdt->sc_hanum);
  277 
  278     /* allocate ccb for gdt_internal_cmd() */
  279     gccb = gdt_get_ccb(gdt);
  280     if (gccb == NULL) {
  281         printf("iir%d: No free command index found\n",
  282                gdt->sc_hanum);
  283         return (1);
  284     }
  285 
  286     if (!gdt_internal_cmd(gdt, gccb, GDT_SCREENSERVICE, GDT_INIT, 
  287                           0, 0, 0)) {
  288         printf("iir%d: Screen service initialization error %d\n",
  289                gdt->sc_hanum, gdt->sc_status);
  290         gdt_free_ccb(gdt, gccb);
  291         return (1);
  292     }
  293 
  294     gdt_internal_cmd(gdt, gccb, GDT_CACHESERVICE, GDT_UNFREEZE_IO,
  295                      0, 0, 0);
  296 
  297     if (!gdt_internal_cmd(gdt, gccb, GDT_CACHESERVICE, GDT_INIT, 
  298                           GDT_LINUX_OS, 0, 0)) {
  299         printf("iir%d: Cache service initialization error %d\n",
  300                gdt->sc_hanum, gdt->sc_status);
  301         gdt_free_ccb(gdt, gccb);
  302         return (1);
  303     }
  304     cdev_cnt = (u_int16_t)gdt->sc_info;
  305     gdt->sc_fw_vers = gdt->sc_service;
  306 
  307     /* Detect number of buses */
  308     gdt_enc32(gccb->gc_scratch + GDT_IOC_VERSION, GDT_IOC_NEWEST);
  309     gccb->gc_scratch[GDT_IOC_LIST_ENTRIES] = GDT_MAXBUS;
  310     gccb->gc_scratch[GDT_IOC_FIRST_CHAN] = 0;
  311     gccb->gc_scratch[GDT_IOC_LAST_CHAN] = GDT_MAXBUS - 1;
  312     gdt_enc32(gccb->gc_scratch + GDT_IOC_LIST_OFFSET, GDT_IOC_HDR_SZ);
  313     if (gdt_internal_cmd(gdt, gccb, GDT_CACHESERVICE, GDT_IOCTL,
  314                          GDT_IOCHAN_RAW_DESC, GDT_INVALID_CHANNEL,
  315                          GDT_IOC_HDR_SZ + GDT_MAXBUS * GDT_RAWIOC_SZ)) {
  316         gdt->sc_bus_cnt = gccb->gc_scratch[GDT_IOC_CHAN_COUNT];
  317         for (i = 0; i < gdt->sc_bus_cnt; i++) {
  318             id = gccb->gc_scratch[GDT_IOC_HDR_SZ +
  319                                  i * GDT_RAWIOC_SZ + GDT_RAWIOC_PROC_ID];
  320             gdt->sc_bus_id[i] = id < GDT_MAXID_FC ? id : 0xff;
  321         }
  322     } else {
  323         /* New method failed, use fallback. */
  324         for (i = 0; i < GDT_MAXBUS; i++) {
  325             gdt_enc32(gccb->gc_scratch + GDT_GETCH_CHANNEL_NO, i);
  326             if (!gdt_internal_cmd(gdt, gccb, GDT_CACHESERVICE, GDT_IOCTL,
  327                                   GDT_SCSI_CHAN_CNT | GDT_L_CTRL_PATTERN,
  328                                   GDT_IO_CHANNEL | GDT_INVALID_CHANNEL,
  329                                   GDT_GETCH_SZ)) {
  330                 if (i == 0) {
  331                     printf("iir%d: Cannot get channel count, "
  332                            "error %d\n", gdt->sc_hanum, gdt->sc_status);
  333                     gdt_free_ccb(gdt, gccb);
  334                     return (1);
  335                 }
  336                 break;
  337             }
  338             gdt->sc_bus_id[i] =
  339                 (gccb->gc_scratch[GDT_GETCH_SIOP_ID] < GDT_MAXID_FC) ?
  340                 gccb->gc_scratch[GDT_GETCH_SIOP_ID] : 0xff;
  341         }
  342         gdt->sc_bus_cnt = i;
  343     }
  344     /* add one "virtual" channel for the host drives */
  345     gdt->sc_virt_bus = gdt->sc_bus_cnt;
  346     gdt->sc_bus_cnt++;
  347 
  348     if (!gdt_internal_cmd(gdt, gccb, GDT_SCSIRAWSERVICE, GDT_INIT, 
  349                           0, 0, 0)) {
  350             printf("iir%d: Raw service initialization error %d\n",
  351                    gdt->sc_hanum, gdt->sc_status);
  352             gdt_free_ccb(gdt, gccb);
  353             return (1);
  354     }
  355 
  356     /* Set/get features raw service (scatter/gather) */
  357     gdt->sc_raw_feat = 0;
  358     if (gdt_internal_cmd(gdt, gccb, GDT_SCSIRAWSERVICE, GDT_SET_FEAT,
  359                          GDT_SCATTER_GATHER, 0, 0)) {
  360         if (gdt_internal_cmd(gdt, gccb, GDT_SCSIRAWSERVICE, GDT_GET_FEAT, 
  361                              0, 0, 0)) {
  362             gdt->sc_raw_feat = gdt->sc_info;
  363             if (!(gdt->sc_info & GDT_SCATTER_GATHER)) {
  364                 panic("iir%d: Scatter/Gather Raw Service "
  365                       "required but not supported!\n", gdt->sc_hanum);
  366                 gdt_free_ccb(gdt, gccb);
  367                 return (1);
  368             }
  369         }
  370     }
  371 
  372     /* Set/get features cache service (scatter/gather) */
  373     gdt->sc_cache_feat = 0;
  374     if (gdt_internal_cmd(gdt, gccb, GDT_CACHESERVICE, GDT_SET_FEAT, 
  375                          0, GDT_SCATTER_GATHER, 0)) {
  376         if (gdt_internal_cmd(gdt, gccb, GDT_CACHESERVICE, GDT_GET_FEAT, 
  377                              0, 0, 0)) {
  378             gdt->sc_cache_feat = gdt->sc_info;
  379             if (!(gdt->sc_info & GDT_SCATTER_GATHER)) {
  380                 panic("iir%d: Scatter/Gather Cache Service "
  381                   "required but not supported!\n", gdt->sc_hanum);
  382                 gdt_free_ccb(gdt, gccb);
  383                 return (1);
  384             }
  385         }
  386     }
  387 
  388     /* OEM */
  389     gdt_enc32(gccb->gc_scratch + GDT_OEM_VERSION, 0x01);
  390     gdt_enc32(gccb->gc_scratch + GDT_OEM_BUFSIZE, sizeof(gdt_oem_record_t));
  391     if (gdt_internal_cmd(gdt, gccb, GDT_CACHESERVICE, GDT_IOCTL,
  392                          GDT_OEM_STR_RECORD, GDT_INVALID_CHANNEL,
  393                          sizeof(gdt_oem_str_record_t))) {
  394             strncpy(gdt->oem_name, ((gdt_oem_str_record_t *)
  395             gccb->gc_scratch)->text.scsi_host_drive_inquiry_vendor_id, 7);
  396                 gdt->oem_name[7]='\0';
  397         } else {
  398                 /* Old method, based on PCI ID */
  399                 if (gdt->sc_vendor == INTEL_VENDOR_ID)
  400             strcpy(gdt->oem_name,"Intel  ");
  401         else 
  402             strcpy(gdt->oem_name,"ICP    ");
  403     }
  404 
  405     /* Scan for cache devices */
  406     for (i = 0; i < cdev_cnt && i < GDT_MAX_HDRIVES; i++) {
  407         if (gdt_internal_cmd(gdt, gccb, GDT_CACHESERVICE, GDT_INFO, 
  408                              i, 0, 0)) {
  409             gdt->sc_hdr[i].hd_present = 1;
  410             gdt->sc_hdr[i].hd_size = gdt->sc_info;
  411             
  412             /*
  413              * Evaluate mapping (sectors per head, heads per cyl)
  414              */
  415             gdt->sc_hdr[i].hd_size &= ~GDT_SECS32;
  416             if (gdt->sc_info2 == 0)
  417                 gdt_eval_mapping(gdt->sc_hdr[i].hd_size,
  418                                  &drv_cyls, &drv_hds, &drv_secs);
  419             else {
  420                 drv_hds = gdt->sc_info2 & 0xff;
  421                 drv_secs = (gdt->sc_info2 >> 8) & 0xff;
  422                 drv_cyls = gdt->sc_hdr[i].hd_size / drv_hds /
  423                     drv_secs;
  424             }
  425             gdt->sc_hdr[i].hd_heads = drv_hds;
  426             gdt->sc_hdr[i].hd_secs = drv_secs;
  427             /* Round the size */
  428             gdt->sc_hdr[i].hd_size = drv_cyls * drv_hds * drv_secs;
  429             
  430             if (gdt_internal_cmd(gdt, gccb, GDT_CACHESERVICE,
  431                                  GDT_DEVTYPE, i, 0, 0))
  432                 gdt->sc_hdr[i].hd_devtype = gdt->sc_info;
  433         }
  434     }
  435     
  436     GDT_DPRINTF(GDT_D_INIT, ("dpmem %x %d-bus %d cache device%s\n", 
  437                              gdt->sc_dpmembase,
  438                              gdt->sc_bus_cnt, cdev_cnt, 
  439                              cdev_cnt == 1 ? "" : "s"));
  440     gdt_free_ccb(gdt, gccb);
  441 
  442     gdt_cnt++;
  443     return (0);
  444 }
  445 
  446 void
  447 iir_free(struct gdt_softc *gdt)
  448 {
  449     int i;
  450 
  451     GDT_DPRINTF(GDT_D_INIT, ("iir_free()\n"));
  452 
  453     switch (gdt->sc_init_level) {
  454       default:
  455         gdt_destroy_dev(gdt->sc_dev);
  456       case 5:
  457         for (i = GDT_MAXCMDS-1; i >= 0; i--) 
  458             if (gdt->sc_gccbs[i].gc_map_flag)
  459                 bus_dmamap_destroy(gdt->sc_buffer_dmat,
  460                                    gdt->sc_gccbs[i].gc_dmamap);
  461         bus_dmamap_unload(gdt->sc_gccb_dmat, gdt->sc_gccb_dmamap);
  462       case 4:
  463         bus_dmamem_free(gdt->sc_gccb_dmat, gdt->sc_gccbs, gdt->sc_gccb_dmamap);
  464       case 3:
  465         bus_dma_tag_destroy(gdt->sc_gccb_dmat);
  466       case 2:
  467         bus_dma_tag_destroy(gdt->sc_buffer_dmat);
  468       case 1:
  469         bus_dma_tag_destroy(gdt->sc_parent_dmat);
  470       case 0:
  471         break;
  472     }
  473     TAILQ_REMOVE(&gdt_softcs, gdt, links);
  474 }
  475 
  476 void
  477 iir_attach(struct gdt_softc *gdt)
  478 {
  479     struct cam_devq *devq;
  480     int i;
  481 
  482     GDT_DPRINTF(GDT_D_INIT, ("iir_attach()\n"));
  483 
  484     /*
  485      * Create the device queue for our SIM.
  486      */
  487     devq = cam_simq_alloc(GDT_MAXCMDS);
  488     if (devq == NULL)
  489         return;
  490 
  491     for (i = 0; i < gdt->sc_bus_cnt; i++) {
  492         /*
  493          * Construct our SIM entry
  494          */
  495         gdt->sims[i] = cam_sim_alloc(iir_action, iir_poll, "iir",
  496                                      gdt, gdt->sc_hanum, /*untagged*/2,
  497                                      /*tagged*/GDT_MAXCMDS, devq);
  498         if (xpt_bus_register(gdt->sims[i], i) != CAM_SUCCESS) {
  499             cam_sim_free(gdt->sims[i], /*free_devq*/i == 0);
  500             break;
  501         }
  502 
  503         if (xpt_create_path(&gdt->paths[i], /*periph*/NULL,
  504                             cam_sim_path(gdt->sims[i]),
  505                             CAM_TARGET_WILDCARD,
  506                             CAM_LUN_WILDCARD) != CAM_REQ_CMP) {
  507             xpt_bus_deregister(cam_sim_path(gdt->sims[i]));
  508             cam_sim_free(gdt->sims[i], /*free_devq*/i == 0);
  509             break;
  510         }
  511     }
  512     if (i > 0)
  513         EVENTHANDLER_REGISTER(shutdown_final, iir_shutdown,
  514                               gdt, SHUTDOWN_PRI_DEFAULT);
  515     /* iir_watchdog(gdt); */
  516     gdt->sc_state = GDT_NORMAL;
  517 }
  518 
  519 static void
  520 gdt_eval_mapping(u_int32_t size, int *cyls, int *heads, int *secs)
  521 {
  522     *cyls = size / GDT_HEADS / GDT_SECS;
  523     if (*cyls < GDT_MAXCYLS) {
  524         *heads = GDT_HEADS;
  525         *secs = GDT_SECS;
  526     } else {
  527         /* Too high for 64 * 32 */
  528         *cyls = size / GDT_MEDHEADS / GDT_MEDSECS;
  529         if (*cyls < GDT_MAXCYLS) {
  530             *heads = GDT_MEDHEADS;
  531             *secs = GDT_MEDSECS;
  532         } else {
  533             /* Too high for 127 * 63 */
  534             *cyls = size / GDT_BIGHEADS / GDT_BIGSECS;
  535             *heads = GDT_BIGHEADS;
  536             *secs = GDT_BIGSECS;
  537         }
  538     }
  539 }
  540 
  541 static int
  542 gdt_wait(struct gdt_softc *gdt, struct gdt_ccb *gccb, 
  543          int timeout)
  544 {
  545     int rv = 0;
  546 
  547     GDT_DPRINTF(GDT_D_INIT,
  548                 ("gdt_wait(%p, %p, %d)\n", gdt, gccb, timeout));
  549 
  550     gdt->sc_state |= GDT_POLL_WAIT;
  551     do {
  552         iir_intr(gdt);
  553         if (gdt == gdt_wait_gdt &&
  554             gccb->gc_cmd_index == gdt_wait_index) {
  555             rv = 1;
  556             break;
  557         }
  558         DELAY(1);
  559     } while (--timeout);
  560     gdt->sc_state &= ~GDT_POLL_WAIT;
  561     
  562     while (gdt->sc_test_busy(gdt))
  563         DELAY(1);               /* XXX correct? */
  564 
  565     return (rv);
  566 }
  567 
  568 static int
  569 gdt_internal_cmd(struct gdt_softc *gdt, struct gdt_ccb *gccb,
  570                  u_int8_t service, u_int16_t opcode, 
  571                  u_int32_t arg1, u_int32_t arg2, u_int32_t arg3)
  572 {
  573     int retries;
  574     
  575     GDT_DPRINTF(GDT_D_CMD, ("gdt_internal_cmd(%p, %d, %d, %d, %d, %d)\n",
  576                             gdt, service, opcode, arg1, arg2, arg3));
  577 
  578     bzero(gdt->sc_cmd, GDT_CMD_SZ);
  579 
  580     for (retries = GDT_RETRIES; ; ) {
  581         gccb->gc_service = service;
  582         gccb->gc_flags = GDT_GCF_INTERNAL;
  583         
  584         gdt->sc_set_sema0(gdt);
  585         gdt_enc32(gdt->sc_cmd + GDT_CMD_COMMANDINDEX,
  586                   gccb->gc_cmd_index);
  587         gdt_enc16(gdt->sc_cmd + GDT_CMD_OPCODE, opcode);
  588 
  589         switch (service) {
  590           case GDT_CACHESERVICE:
  591             if (opcode == GDT_IOCTL) {
  592                 gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION +
  593                           GDT_IOCTL_SUBFUNC, arg1);
  594                 gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION +
  595                           GDT_IOCTL_CHANNEL, arg2);
  596                 gdt_enc16(gdt->sc_cmd + GDT_CMD_UNION +
  597                           GDT_IOCTL_PARAM_SIZE, (u_int16_t)arg3);
  598                 gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_IOCTL_P_PARAM,
  599                           gdt_ccb_vtop(gdt, gccb) + 
  600                           offsetof(struct gdt_ccb, gc_scratch[0]));
  601             } else {
  602                 gdt_enc16(gdt->sc_cmd + GDT_CMD_UNION +
  603                           GDT_CACHE_DEVICENO, (u_int16_t)arg1);
  604                 gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION +
  605                           GDT_CACHE_BLOCKNO, arg2);
  606             }
  607             break;
  608 
  609           case GDT_SCSIRAWSERVICE:
  610             gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION +
  611                       GDT_RAW_DIRECTION, arg1);
  612             gdt->sc_cmd[GDT_CMD_UNION + GDT_RAW_BUS] =
  613                 (u_int8_t)arg2;
  614             gdt->sc_cmd[GDT_CMD_UNION + GDT_RAW_TARGET] =
  615                 (u_int8_t)arg3;
  616             gdt->sc_cmd[GDT_CMD_UNION + GDT_RAW_LUN] =
  617                 (u_int8_t)(arg3 >> 8);
  618         }
  619 
  620         gdt->sc_cmd_len = GDT_CMD_SZ;
  621         gdt->sc_cmd_off = 0;
  622         gdt->sc_cmd_cnt = 0;
  623         gdt->sc_copy_cmd(gdt, gccb);
  624         gdt->sc_release_event(gdt);
  625         DELAY(20);
  626         if (!gdt_wait(gdt, gccb, GDT_POLL_TIMEOUT))
  627             return (0);
  628         if (gdt->sc_status != GDT_S_BSY || --retries == 0)
  629             break;
  630         DELAY(1);
  631     }
  632     return (gdt->sc_status == GDT_S_OK);
  633 }
  634 
  635 static struct gdt_ccb *
  636 gdt_get_ccb(struct gdt_softc *gdt)
  637 {
  638     struct gdt_ccb *gccb;
  639     int lock;
  640     
  641     GDT_DPRINTF(GDT_D_QUEUE, ("gdt_get_ccb(%p)\n", gdt));
  642 
  643     lock = splcam();
  644     gccb = SLIST_FIRST(&gdt->sc_free_gccb);
  645     if (gccb != NULL) {
  646         SLIST_REMOVE_HEAD(&gdt->sc_free_gccb, sle);
  647         SLIST_INSERT_HEAD(&gdt->sc_pending_gccb, gccb, sle);
  648         ++gdt_stat.cmd_index_act;
  649         if (gdt_stat.cmd_index_act > gdt_stat.cmd_index_max)
  650             gdt_stat.cmd_index_max = gdt_stat.cmd_index_act;
  651     }
  652     splx(lock);
  653     return (gccb);
  654 }
  655 
  656 void
  657 gdt_free_ccb(struct gdt_softc *gdt, struct gdt_ccb *gccb)
  658 {
  659     int lock;
  660 
  661     GDT_DPRINTF(GDT_D_QUEUE, ("gdt_free_ccb(%p, %p)\n", gdt, gccb));
  662     
  663     lock = splcam();
  664     gccb->gc_flags = GDT_GCF_UNUSED;
  665     SLIST_REMOVE(&gdt->sc_pending_gccb, gccb, gdt_ccb, sle);
  666     SLIST_INSERT_HEAD(&gdt->sc_free_gccb, gccb, sle);
  667     --gdt_stat.cmd_index_act;
  668     splx(lock);
  669     if (gdt->sc_state & GDT_SHUTDOWN)
  670         wakeup(gccb);
  671 }
  672 
  673 static u_int32_t
  674 gdt_ccb_vtop(struct gdt_softc *gdt, struct gdt_ccb *gccb)
  675 {
  676     return (gdt->sc_gccb_busbase
  677             + (u_int32_t)((caddr_t)gccb - (caddr_t)gdt->sc_gccbs));
  678 }
  679 
  680 void    
  681 gdt_next(struct gdt_softc *gdt)
  682 {
  683     int lock;
  684     union ccb *ccb;
  685     gdt_ucmd_t *ucmd;
  686     struct cam_sim *sim;
  687     int bus, target, lun;
  688     int next_cmd;
  689 
  690     struct ccb_scsiio *csio;
  691     struct ccb_hdr *ccbh;
  692     struct gdt_ccb *gccb = NULL;
  693     u_int8_t cmd;
  694 
  695     GDT_DPRINTF(GDT_D_QUEUE, ("gdt_next(%p)\n", gdt));
  696 
  697     lock = splcam();
  698     if (gdt->sc_test_busy(gdt)) {
  699         if (!(gdt->sc_state & GDT_POLLING)) {
  700             splx(lock);
  701             return;
  702         }
  703         while (gdt->sc_test_busy(gdt))
  704             DELAY(1);
  705     }
  706 
  707     gdt->sc_cmd_cnt = gdt->sc_cmd_off = 0;
  708     next_cmd = TRUE;
  709     for (;;) {
  710         /* I/Os in queue? controller ready? */
  711         if (!TAILQ_FIRST(&gdt->sc_ucmd_queue) &&
  712             !TAILQ_FIRST(&gdt->sc_ccb_queue))
  713             break;
  714 
  715         /* 1.: I/Os without ccb (IOCTLs) */
  716         ucmd = TAILQ_FIRST(&gdt->sc_ucmd_queue);
  717         if (ucmd != NULL) {
  718             TAILQ_REMOVE(&gdt->sc_ucmd_queue, ucmd, links);
  719             if ((gccb = gdt_ioctl_cmd(gdt, ucmd, &lock)) == NULL) {
  720                 TAILQ_INSERT_HEAD(&gdt->sc_ucmd_queue, ucmd, links);
  721                 break;
  722             }
  723             break;      
  724             /* wenn mehrere Kdos. zulassen: if (!gdt_polling) continue; */
  725         }
  726 
  727         /* 2.: I/Os with ccb */
  728         ccb = (union ccb *)TAILQ_FIRST(&gdt->sc_ccb_queue); 
  729         /* ist dann immer != NULL, da oben getestet */
  730         sim = (struct cam_sim *)ccb->ccb_h.ccb_sim_ptr;
  731         bus = cam_sim_bus(sim);
  732         target = ccb->ccb_h.target_id;
  733         lun = ccb->ccb_h.target_lun;
  734     
  735         TAILQ_REMOVE(&gdt->sc_ccb_queue, &ccb->ccb_h, sim_links.tqe);
  736         --gdt_stat.req_queue_act;
  737         /* ccb->ccb_h.func_code is XPT_SCSI_IO */
  738         GDT_DPRINTF(GDT_D_QUEUE, ("XPT_SCSI_IO flags 0x%x)\n", 
  739                                   ccb->ccb_h.flags));
  740         csio = &ccb->csio;
  741         ccbh = &ccb->ccb_h;
  742         cmd  = csio->cdb_io.cdb_bytes[0];
  743         /* Max CDB length is 12 bytes */
  744         if (csio->cdb_len > 12) { 
  745             ccbh->status = CAM_REQ_INVALID;
  746             --gdt_stat.io_count_act;
  747             xpt_done(ccb);
  748         } else if (bus != gdt->sc_virt_bus) {
  749             /* raw service command */
  750             if ((gccb = gdt_raw_cmd(gdt, ccb, &lock)) == NULL) {
  751                 TAILQ_INSERT_HEAD(&gdt->sc_ccb_queue, &ccb->ccb_h, 
  752                                   sim_links.tqe);
  753                 ++gdt_stat.req_queue_act;
  754                 if (gdt_stat.req_queue_act > gdt_stat.req_queue_max)
  755                     gdt_stat.req_queue_max = gdt_stat.req_queue_act;
  756                 next_cmd = FALSE;
  757             }
  758         } else if (target >= GDT_MAX_HDRIVES || 
  759                    !gdt->sc_hdr[target].hd_present || lun != 0) {
  760             ccbh->status = CAM_DEV_NOT_THERE;
  761             --gdt_stat.io_count_act;
  762             xpt_done(ccb);
  763         } else {
  764             /* cache service command */
  765             if (cmd == READ_6  || cmd == WRITE_6 ||
  766                 cmd == READ_10 || cmd == WRITE_10) {
  767                 if ((gccb = gdt_cache_cmd(gdt, ccb, &lock)) == NULL) {
  768                     TAILQ_INSERT_HEAD(&gdt->sc_ccb_queue, &ccb->ccb_h, 
  769                                       sim_links.tqe);
  770                     ++gdt_stat.req_queue_act;
  771                     if (gdt_stat.req_queue_act > gdt_stat.req_queue_max)
  772                         gdt_stat.req_queue_max = gdt_stat.req_queue_act;
  773                     next_cmd = FALSE;
  774                 }
  775             } else {
  776                 splx(lock);
  777                 gdt_internal_cache_cmd(gdt, ccb);
  778                 lock = splcam();
  779             }
  780         }           
  781         if ((gdt->sc_state & GDT_POLLING) || !next_cmd)
  782             break;
  783     }
  784     if (gdt->sc_cmd_cnt > 0)
  785         gdt->sc_release_event(gdt);
  786 
  787     splx(lock);
  788 
  789     if ((gdt->sc_state & GDT_POLLING) && gdt->sc_cmd_cnt > 0) {
  790         gdt_wait(gdt, gccb, GDT_POLL_TIMEOUT);
  791     }
  792 }
  793 
  794 static struct gdt_ccb *
  795 gdt_raw_cmd(struct gdt_softc *gdt, union ccb *ccb, int *lock)
  796 {
  797     struct gdt_ccb *gccb;
  798     struct cam_sim *sim;
  799 
  800     GDT_DPRINTF(GDT_D_CMD, ("gdt_raw_cmd(%p, %p)\n", gdt, ccb));
  801 
  802     if (roundup(GDT_CMD_UNION + GDT_RAW_SZ, sizeof(u_int32_t)) +
  803         gdt->sc_cmd_off + GDT_DPMEM_COMMAND_OFFSET >
  804         gdt->sc_ic_all_size) {
  805         GDT_DPRINTF(GDT_D_INVALID, ("iir%d: gdt_raw_cmd(): DPMEM overflow\n", 
  806                                     gdt->sc_hanum));
  807         return (NULL);
  808     }
  809 
  810     bzero(gdt->sc_cmd, GDT_CMD_SZ);
  811 
  812     gccb = gdt_get_ccb(gdt);
  813     if (gccb == NULL) {
  814         GDT_DPRINTF(GDT_D_INVALID, ("iir%d: No free command index found\n",
  815                                     gdt->sc_hanum));
  816         return (gccb);
  817     }
  818     sim = (struct cam_sim *)ccb->ccb_h.ccb_sim_ptr;
  819     gccb->gc_ccb = ccb;
  820     gccb->gc_service = GDT_SCSIRAWSERVICE;
  821     gccb->gc_flags = GDT_GCF_SCSI;
  822         
  823     if (gdt->sc_cmd_cnt == 0)
  824         gdt->sc_set_sema0(gdt);
  825     splx(*lock);
  826     gdt_enc32(gdt->sc_cmd + GDT_CMD_COMMANDINDEX,
  827               gccb->gc_cmd_index);
  828     gdt_enc16(gdt->sc_cmd + GDT_CMD_OPCODE, GDT_WRITE);
  829 
  830     gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_RAW_DIRECTION,
  831               (ccb->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN ?
  832               GDT_DATA_IN : GDT_DATA_OUT);
  833     gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_RAW_SDLEN,
  834               ccb->csio.dxfer_len);
  835     gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_RAW_CLEN,
  836               ccb->csio.cdb_len);
  837     bcopy(ccb->csio.cdb_io.cdb_bytes, gdt->sc_cmd + GDT_CMD_UNION + GDT_RAW_CMD,
  838           ccb->csio.cdb_len);
  839     gdt->sc_cmd[GDT_CMD_UNION + GDT_RAW_TARGET] = 
  840         ccb->ccb_h.target_id;
  841     gdt->sc_cmd[GDT_CMD_UNION + GDT_RAW_LUN] = 
  842         ccb->ccb_h.target_lun;
  843     gdt->sc_cmd[GDT_CMD_UNION + GDT_RAW_BUS] = 
  844         cam_sim_bus(sim);
  845     gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_RAW_SENSE_LEN,
  846               sizeof(struct scsi_sense_data));
  847     gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_RAW_SENSE_DATA,
  848               gdt_ccb_vtop(gdt, gccb) + 
  849               offsetof(struct gdt_ccb, gc_scratch[0]));
  850  
  851     /*
  852      * If we have any data to send with this command,
  853      * map it into bus space.
  854      */
  855     /* Only use S/G if there is a transfer */
  856     if ((ccb->ccb_h.flags & CAM_DIR_MASK) != CAM_DIR_NONE) {
  857         if ((ccb->ccb_h.flags & CAM_SCATTER_VALID) == 0) { 
  858             if ((ccb->ccb_h.flags & CAM_DATA_PHYS) == 0) {
  859                 int s;
  860                 int error;
  861             
  862                 /* vorher unlock von splcam() ??? */
  863                 s = splsoftvm();
  864                 error =
  865                     bus_dmamap_load(gdt->sc_buffer_dmat,
  866                                     gccb->gc_dmamap,
  867                                     ccb->csio.data_ptr,
  868                                     ccb->csio.dxfer_len,
  869                                     gdtexecuteccb,
  870                                     gccb, /*flags*/0);
  871                 if (error == EINPROGRESS) {
  872                     xpt_freeze_simq(sim, 1);
  873                     gccb->gc_state |= CAM_RELEASE_SIMQ;
  874                 }
  875                 splx(s);
  876             } else {
  877                 panic("iir: CAM_DATA_PHYS not supported");
  878             }
  879         } else {
  880             struct bus_dma_segment *segs;
  881 
  882             if ((ccb->ccb_h.flags & CAM_DATA_PHYS) != 0)
  883                 panic("iir%d: iir_action - Physical "
  884                       "segment pointers unsupported", gdt->sc_hanum);
  885 
  886             if ((ccb->ccb_h.flags & CAM_SG_LIST_PHYS)==0)
  887                 panic("iir%d: iir_action - Virtual "
  888                       "segment addresses unsupported", gdt->sc_hanum);
  889 
  890             /* Just use the segments provided */
  891             segs = (struct bus_dma_segment *)ccb->csio.data_ptr;
  892             gdtexecuteccb(gccb, segs, ccb->csio.sglist_cnt, 0);
  893         }
  894     } else {
  895         gdtexecuteccb(gccb, NULL, 0, 0);
  896     }
  897 
  898     *lock = splcam();
  899     return (gccb);
  900 }
  901 
  902 static struct gdt_ccb *
  903 gdt_cache_cmd(struct gdt_softc *gdt, union ccb *ccb, int *lock)
  904 {
  905     struct gdt_ccb *gccb;
  906     struct cam_sim *sim;
  907     u_int8_t *cmdp;
  908     u_int16_t opcode;
  909     u_int32_t blockno, blockcnt;
  910 
  911     GDT_DPRINTF(GDT_D_CMD, ("gdt_cache_cmd(%p, %p)\n", gdt, ccb));
  912 
  913     if (roundup(GDT_CMD_UNION + GDT_CACHE_SZ, sizeof(u_int32_t)) +
  914         gdt->sc_cmd_off + GDT_DPMEM_COMMAND_OFFSET >
  915         gdt->sc_ic_all_size) {
  916         GDT_DPRINTF(GDT_D_INVALID, ("iir%d: gdt_cache_cmd(): DPMEM overflow\n", 
  917                                     gdt->sc_hanum));
  918         return (NULL);
  919     }
  920 
  921     bzero(gdt->sc_cmd, GDT_CMD_SZ);
  922 
  923     gccb = gdt_get_ccb(gdt);
  924     if (gccb == NULL) {
  925         GDT_DPRINTF(GDT_D_DEBUG, ("iir%d: No free command index found\n",
  926                                   gdt->sc_hanum));
  927         return (gccb);
  928     }
  929     sim = (struct cam_sim *)ccb->ccb_h.ccb_sim_ptr;
  930     gccb->gc_ccb = ccb;
  931     gccb->gc_service = GDT_CACHESERVICE;
  932     gccb->gc_flags = GDT_GCF_SCSI;
  933         
  934     if (gdt->sc_cmd_cnt == 0)
  935         gdt->sc_set_sema0(gdt);
  936     splx(*lock);
  937     gdt_enc32(gdt->sc_cmd + GDT_CMD_COMMANDINDEX,
  938               gccb->gc_cmd_index);
  939     cmdp = ccb->csio.cdb_io.cdb_bytes;
  940     opcode = (*cmdp == WRITE_6 || *cmdp == WRITE_10) ? GDT_WRITE : GDT_READ;
  941     if ((gdt->sc_state & GDT_SHUTDOWN) && opcode == GDT_WRITE)
  942         opcode = GDT_WRITE_THR;
  943     gdt_enc16(gdt->sc_cmd + GDT_CMD_OPCODE, opcode);
  944  
  945     gdt_enc16(gdt->sc_cmd + GDT_CMD_UNION + GDT_CACHE_DEVICENO,
  946               ccb->ccb_h.target_id);
  947     if (ccb->csio.cdb_len == 6) {
  948         struct scsi_rw_6 *rw = (struct scsi_rw_6 *)cmdp;
  949         blockno = scsi_3btoul(rw->addr) & ((SRW_TOPADDR<<16) | 0xffff);
  950         blockcnt = rw->length ? rw->length : 0x100;
  951     } else {
  952         struct scsi_rw_10 *rw = (struct scsi_rw_10 *)cmdp;
  953         blockno = scsi_4btoul(rw->addr);
  954         blockcnt = scsi_2btoul(rw->length);
  955     }
  956     gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_CACHE_BLOCKNO,
  957               blockno);
  958     gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_CACHE_BLOCKCNT,
  959               blockcnt);
  960 
  961     /*
  962      * If we have any data to send with this command,
  963      * map it into bus space.
  964      */
  965     /* Only use S/G if there is a transfer */
  966     if ((ccb->ccb_h.flags & CAM_SCATTER_VALID) == 0) { 
  967         if ((ccb->ccb_h.flags & CAM_DATA_PHYS) == 0) {
  968             int s;
  969             int error;
  970             
  971             /* vorher unlock von splcam() ??? */
  972             s = splsoftvm();
  973             error =
  974                 bus_dmamap_load(gdt->sc_buffer_dmat,
  975                                 gccb->gc_dmamap,
  976                                 ccb->csio.data_ptr,
  977                                 ccb->csio.dxfer_len,
  978                                 gdtexecuteccb,
  979                                 gccb, /*flags*/0);
  980             if (error == EINPROGRESS) {
  981                 xpt_freeze_simq(sim, 1);
  982                 gccb->gc_state |= CAM_RELEASE_SIMQ;
  983             }
  984             splx(s);
  985         } else {
  986             panic("iir: CAM_DATA_PHYS not supported");
  987         }
  988     } else {
  989         struct bus_dma_segment *segs;
  990 
  991         if ((ccb->ccb_h.flags & CAM_DATA_PHYS) != 0)
  992             panic("iir%d: iir_action - Physical "
  993                   "segment pointers unsupported", gdt->sc_hanum);
  994 
  995         if ((ccb->ccb_h.flags & CAM_SG_LIST_PHYS)==0)
  996             panic("iir%d: iir_action - Virtual "
  997                   "segment addresses unsupported", gdt->sc_hanum);
  998 
  999         /* Just use the segments provided */
 1000         segs = (struct bus_dma_segment *)ccb->csio.data_ptr;
 1001         gdtexecuteccb(gccb, segs, ccb->csio.sglist_cnt, 0);
 1002     }
 1003 
 1004     *lock = splcam();
 1005     return (gccb);
 1006 }
 1007 
 1008 static struct gdt_ccb *
 1009 gdt_ioctl_cmd(struct gdt_softc *gdt, gdt_ucmd_t *ucmd, int *lock)
 1010 {
 1011     struct gdt_ccb *gccb;
 1012     u_int32_t cnt;
 1013 
 1014     GDT_DPRINTF(GDT_D_DEBUG, ("gdt_ioctl_cmd(%p, %p)\n", gdt, ucmd));
 1015 
 1016     bzero(gdt->sc_cmd, GDT_CMD_SZ);
 1017 
 1018     gccb = gdt_get_ccb(gdt);
 1019     if (gccb == NULL) {
 1020         GDT_DPRINTF(GDT_D_DEBUG, ("iir%d: No free command index found\n",
 1021                                   gdt->sc_hanum));
 1022         return (gccb);
 1023     }
 1024     gccb->gc_ucmd = ucmd;
 1025     gccb->gc_service = ucmd->service;
 1026     gccb->gc_flags = GDT_GCF_IOCTL;
 1027         
 1028     /* check DPMEM space, copy data buffer from user space */
 1029     if (ucmd->service == GDT_CACHESERVICE) {
 1030         if (ucmd->OpCode == GDT_IOCTL) {
 1031             gdt->sc_cmd_len = roundup(GDT_CMD_UNION + GDT_IOCTL_SZ,
 1032                                       sizeof(u_int32_t));
 1033             cnt = ucmd->u.ioctl.param_size;
 1034             if (cnt > GDT_SCRATCH_SZ) {
 1035                 printf("iir%d: Scratch buffer too small (%d/%d)\n", 
 1036                        gdt->sc_hanum, GDT_SCRATCH_SZ, cnt);
 1037                 gdt_free_ccb(gdt, gccb);
 1038                 return (NULL);
 1039             }
 1040         } else {
 1041             gdt->sc_cmd_len = roundup(GDT_CMD_UNION + GDT_CACHE_SG_LST +
 1042                                       GDT_SG_SZ, sizeof(u_int32_t));
 1043             cnt = ucmd->u.cache.BlockCnt * GDT_SECTOR_SIZE;
 1044             if (cnt > GDT_SCRATCH_SZ) {
 1045                 printf("iir%d: Scratch buffer too small (%d/%d)\n", 
 1046                        gdt->sc_hanum, GDT_SCRATCH_SZ, cnt);
 1047                 gdt_free_ccb(gdt, gccb);
 1048                 return (NULL);
 1049             }
 1050         }
 1051     } else {
 1052         gdt->sc_cmd_len = roundup(GDT_CMD_UNION + GDT_RAW_SG_LST +
 1053                                   GDT_SG_SZ, sizeof(u_int32_t));
 1054         cnt = ucmd->u.raw.sdlen;
 1055         if (cnt + ucmd->u.raw.sense_len > GDT_SCRATCH_SZ) {
 1056             printf("iir%d: Scratch buffer too small (%d/%d)\n", 
 1057                    gdt->sc_hanum, GDT_SCRATCH_SZ, cnt + ucmd->u.raw.sense_len);
 1058             gdt_free_ccb(gdt, gccb);
 1059             return (NULL);
 1060         }
 1061     }
 1062     if (cnt != 0) 
 1063         bcopy(ucmd->data, gccb->gc_scratch, cnt);
 1064 
 1065     if (gdt->sc_cmd_off + gdt->sc_cmd_len + GDT_DPMEM_COMMAND_OFFSET >
 1066         gdt->sc_ic_all_size) {
 1067         GDT_DPRINTF(GDT_D_INVALID, ("iir%d: gdt_ioctl_cmd(): DPMEM overflow\n", 
 1068                                     gdt->sc_hanum));
 1069         gdt_free_ccb(gdt, gccb);
 1070         return (NULL);
 1071     }
 1072 
 1073     if (gdt->sc_cmd_cnt == 0)
 1074         gdt->sc_set_sema0(gdt);
 1075     splx(*lock);
 1076 
 1077     /* fill cmd structure */
 1078     gdt_enc32(gdt->sc_cmd + GDT_CMD_COMMANDINDEX,
 1079               gccb->gc_cmd_index);
 1080     gdt_enc16(gdt->sc_cmd + GDT_CMD_OPCODE, 
 1081               ucmd->OpCode);
 1082 
 1083     if (ucmd->service == GDT_CACHESERVICE) {
 1084         if (ucmd->OpCode == GDT_IOCTL) {
 1085             /* IOCTL */
 1086             gdt_enc16(gdt->sc_cmd + GDT_CMD_UNION + GDT_IOCTL_PARAM_SIZE,
 1087                       ucmd->u.ioctl.param_size);
 1088             gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_IOCTL_SUBFUNC,
 1089                       ucmd->u.ioctl.subfunc);
 1090             gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_IOCTL_CHANNEL,
 1091                       ucmd->u.ioctl.channel);
 1092             gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_IOCTL_P_PARAM,
 1093                       gdt_ccb_vtop(gdt, gccb) + 
 1094                       offsetof(struct gdt_ccb, gc_scratch[0]));
 1095         } else {
 1096             /* cache service command */
 1097             gdt_enc16(gdt->sc_cmd + GDT_CMD_UNION + GDT_CACHE_DEVICENO,
 1098                       ucmd->u.cache.DeviceNo);
 1099             gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_CACHE_BLOCKNO,
 1100                       ucmd->u.cache.BlockNo);
 1101             gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_CACHE_BLOCKCNT,
 1102                       ucmd->u.cache.BlockCnt);
 1103             gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_CACHE_DESTADDR,
 1104                       0xffffffffUL);
 1105             gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_CACHE_SG_CANZ,
 1106                       1);
 1107             gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_CACHE_SG_LST + 
 1108                       GDT_SG_PTR, gdt_ccb_vtop(gdt, gccb) + 
 1109                       offsetof(struct gdt_ccb, gc_scratch[0]));
 1110             gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_CACHE_SG_LST +
 1111                       GDT_SG_LEN, ucmd->u.cache.BlockCnt * GDT_SECTOR_SIZE);
 1112         }
 1113     } else {
 1114         /* raw service command */
 1115         gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_RAW_DIRECTION,
 1116                   ucmd->u.raw.direction);
 1117         gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_RAW_SDATA,
 1118                   0xffffffffUL);
 1119         gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_RAW_SDLEN,
 1120                   ucmd->u.raw.sdlen);
 1121         gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_RAW_CLEN,
 1122                   ucmd->u.raw.clen);
 1123         bcopy(ucmd->u.raw.cmd, gdt->sc_cmd + GDT_CMD_UNION + GDT_RAW_CMD,
 1124               12);
 1125         gdt->sc_cmd[GDT_CMD_UNION + GDT_RAW_TARGET] = 
 1126             ucmd->u.raw.target;
 1127         gdt->sc_cmd[GDT_CMD_UNION + GDT_RAW_LUN] = 
 1128             ucmd->u.raw.lun;
 1129         gdt->sc_cmd[GDT_CMD_UNION + GDT_RAW_BUS] = 
 1130             ucmd->u.raw.bus;
 1131         gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_RAW_SENSE_LEN,
 1132                   ucmd->u.raw.sense_len);
 1133         gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_RAW_SENSE_DATA,
 1134                   gdt_ccb_vtop(gdt, gccb) + 
 1135                   offsetof(struct gdt_ccb, gc_scratch[ucmd->u.raw.sdlen]));
 1136         gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_RAW_SG_RANZ,
 1137                   1);
 1138         gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_RAW_SG_LST + 
 1139                   GDT_SG_PTR, gdt_ccb_vtop(gdt, gccb) + 
 1140                   offsetof(struct gdt_ccb, gc_scratch[0]));
 1141         gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_RAW_SG_LST +
 1142                   GDT_SG_LEN, ucmd->u.raw.sdlen);
 1143     }
 1144 
 1145     *lock = splcam();
 1146     gdt_stat.sg_count_act = 1;
 1147     gdt->sc_copy_cmd(gdt, gccb);
 1148     return (gccb);
 1149 }
 1150 
 1151 static void 
 1152 gdt_internal_cache_cmd(struct gdt_softc *gdt,union ccb *ccb)
 1153 {
 1154     int t;
 1155 
 1156     t = ccb->ccb_h.target_id;
 1157     GDT_DPRINTF(GDT_D_CMD, ("gdt_internal_cache_cmd(%p, %p, 0x%x, %d)\n", 
 1158         gdt, ccb, ccb->csio.cdb_io.cdb_bytes[0], t));
 1159 
 1160     switch (ccb->csio.cdb_io.cdb_bytes[0]) {
 1161       case TEST_UNIT_READY:
 1162       case START_STOP:
 1163         break;
 1164       case REQUEST_SENSE:
 1165         GDT_DPRINTF(GDT_D_MISC, ("REQUEST_SENSE\n"));
 1166         break;
 1167       case INQUIRY:
 1168         {
 1169             struct scsi_inquiry_data *inq;
 1170 
 1171             inq = (struct scsi_inquiry_data *)ccb->csio.data_ptr;       
 1172             bzero(inq, sizeof(struct scsi_inquiry_data));
 1173             inq->device = (gdt->sc_hdr[t].hd_devtype & 4) ?
 1174                 T_CDROM : T_DIRECT;
 1175             inq->dev_qual2 = (gdt->sc_hdr[t].hd_devtype & 1) ? 0x80 : 0;
 1176             inq->version = SCSI_REV_2;
 1177             inq->response_format = 2; 
 1178             inq->additional_length = 32; 
 1179             inq->flags = SID_CmdQue | SID_Sync; 
 1180             strcpy(inq->vendor, gdt->oem_name);
 1181             sprintf(inq->product, "Host Drive   #%02d", t);
 1182             strcpy(inq->revision, "   ");
 1183             break;
 1184         }
 1185       case MODE_SENSE_6:
 1186         {
 1187             struct mpd_data {
 1188                 struct scsi_mode_hdr_6 hd;
 1189                 struct scsi_mode_block_descr bd;
 1190                 struct scsi_control_page cp;
 1191             } *mpd;
 1192             u_int8_t page;
 1193 
 1194             mpd = (struct mpd_data *)ccb->csio.data_ptr;        
 1195             bzero(mpd, sizeof(struct mpd_data));
 1196             mpd->hd.datalen = sizeof(struct scsi_mode_hdr_6) +
 1197                 sizeof(struct scsi_mode_block_descr);
 1198             mpd->hd.dev_specific = (gdt->sc_hdr[t].hd_devtype & 2) ? 0x80 : 0;
 1199             mpd->hd.block_descr_len = sizeof(struct scsi_mode_block_descr);
 1200             mpd->bd.block_len[0] = (GDT_SECTOR_SIZE & 0x00ff0000) >> 16;
 1201             mpd->bd.block_len[1] = (GDT_SECTOR_SIZE & 0x0000ff00) >> 8;
 1202             mpd->bd.block_len[2] = (GDT_SECTOR_SIZE & 0x000000ff);
 1203             page=((struct scsi_mode_sense_6 *)ccb->csio.cdb_io.cdb_bytes)->page;
 1204             switch (page) {
 1205               default:
 1206                 GDT_DPRINTF(GDT_D_MISC, ("MODE_SENSE_6: page 0x%x\n", page));
 1207                 break;
 1208             }
 1209             break;
 1210         }
 1211       case READ_CAPACITY:
 1212         {
 1213             struct scsi_read_capacity_data *rcd;
 1214               
 1215             rcd = (struct scsi_read_capacity_data *)ccb->csio.data_ptr; 
 1216             bzero(rcd, sizeof(struct scsi_read_capacity_data));
 1217             scsi_ulto4b(gdt->sc_hdr[t].hd_size - 1, rcd->addr);
 1218             scsi_ulto4b(GDT_SECTOR_SIZE, rcd->length);
 1219             break;
 1220         }
 1221       default:
 1222         GDT_DPRINTF(GDT_D_MISC, ("gdt_internal_cache_cmd(%d) unknown\n", 
 1223                                     ccb->csio.cdb_io.cdb_bytes[0]));
 1224         break;
 1225     }
 1226     ccb->ccb_h.status = CAM_REQ_CMP;
 1227     --gdt_stat.io_count_act;
 1228     xpt_done(ccb);
 1229 }
 1230 
 1231 static void     
 1232 gdtmapmem(void *arg, bus_dma_segment_t *dm_segs, int nseg, int error)
 1233 {
 1234     bus_addr_t *busaddrp;
 1235     
 1236     busaddrp = (bus_addr_t *)arg;
 1237     *busaddrp = dm_segs->ds_addr;
 1238 }
 1239 
 1240 static void     
 1241 gdtexecuteccb(void *arg, bus_dma_segment_t *dm_segs, int nseg, int error)
 1242 {
 1243     struct gdt_ccb *gccb;
 1244     union ccb *ccb;
 1245     struct gdt_softc *gdt;
 1246     int i, lock;
 1247 
 1248     lock = splcam();
 1249 
 1250     gccb = (struct gdt_ccb *)arg;
 1251     ccb = gccb->gc_ccb;
 1252     gdt = cam_sim_softc((struct cam_sim *)ccb->ccb_h.ccb_sim_ptr);
 1253 
 1254     GDT_DPRINTF(GDT_D_CMD, ("gdtexecuteccb(%p, %p, %p, %d, %d)\n", 
 1255                             gdt, gccb, dm_segs, nseg, error));
 1256     gdt_stat.sg_count_act = nseg;
 1257     if (nseg > gdt_stat.sg_count_max)
 1258         gdt_stat.sg_count_max = nseg;
 1259 
 1260     /* Copy the segments into our SG list */
 1261     if (gccb->gc_service == GDT_CACHESERVICE) {
 1262         for (i = 0; i < nseg; ++i) {
 1263             gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_CACHE_SG_LST +
 1264                       i * GDT_SG_SZ + GDT_SG_PTR, dm_segs->ds_addr);
 1265             gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_CACHE_SG_LST +
 1266                       i * GDT_SG_SZ + GDT_SG_LEN, dm_segs->ds_len);
 1267             dm_segs++;
 1268         }
 1269         gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_CACHE_SG_CANZ,      
 1270                   nseg);
 1271         gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_CACHE_DESTADDR, 
 1272                   0xffffffffUL);
 1273 
 1274         gdt->sc_cmd_len = roundup(GDT_CMD_UNION + GDT_CACHE_SG_LST +
 1275                                   nseg * GDT_SG_SZ, sizeof(u_int32_t));
 1276     } else {
 1277         for (i = 0; i < nseg; ++i) {
 1278             gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_RAW_SG_LST +
 1279                       i * GDT_SG_SZ + GDT_SG_PTR, dm_segs->ds_addr);
 1280             gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_RAW_SG_LST +
 1281                       i * GDT_SG_SZ + GDT_SG_LEN, dm_segs->ds_len);
 1282             dm_segs++;
 1283         }
 1284         gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_RAW_SG_RANZ,        
 1285                   nseg);
 1286         gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_RAW_SDATA, 
 1287                   0xffffffffUL);
 1288 
 1289         gdt->sc_cmd_len = roundup(GDT_CMD_UNION + GDT_RAW_SG_LST +
 1290                                   nseg * GDT_SG_SZ, sizeof(u_int32_t));
 1291     }
 1292 
 1293     if (nseg != 0) {
 1294         bus_dmamap_sync(gdt->sc_buffer_dmat, gccb->gc_dmamap, 
 1295             (ccb->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN ?
 1296             BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE);
 1297     }
 1298     
 1299     /* We must NOT abort the command here if CAM_REQ_INPROG is not set,
 1300      * because command semaphore is already set!
 1301      */
 1302     
 1303     ccb->ccb_h.status |= CAM_SIM_QUEUED;
 1304     /* timeout handling */
 1305     ccb->ccb_h.timeout_ch =
 1306         timeout(iir_timeout, (caddr_t)gccb,
 1307                 (ccb->ccb_h.timeout * hz) / 1000);
 1308 
 1309     gdt->sc_copy_cmd(gdt, gccb);
 1310     splx(lock);
 1311 }
 1312 
 1313 
 1314 static void     
 1315 iir_action( struct cam_sim *sim, union ccb *ccb )
 1316 {
 1317     struct gdt_softc *gdt;
 1318     int lock, bus, target, lun;
 1319 
 1320     gdt = (struct gdt_softc *)cam_sim_softc( sim );
 1321     ccb->ccb_h.ccb_sim_ptr = sim;
 1322     bus = cam_sim_bus(sim);
 1323     target = ccb->ccb_h.target_id;
 1324     lun = ccb->ccb_h.target_lun;
 1325     GDT_DPRINTF(GDT_D_CMD, 
 1326                 ("iir_action(%p) func 0x%x cmd 0x%x bus %d target %d lun %d\n", 
 1327                  gdt, ccb->ccb_h.func_code, ccb->csio.cdb_io.cdb_bytes[0], 
 1328                  bus, target, lun)); 
 1329     ++gdt_stat.io_count_act;
 1330     if (gdt_stat.io_count_act > gdt_stat.io_count_max)
 1331         gdt_stat.io_count_max = gdt_stat.io_count_act;
 1332 
 1333     switch (ccb->ccb_h.func_code) {
 1334       case XPT_SCSI_IO:
 1335         lock = splcam();
 1336         TAILQ_INSERT_TAIL(&gdt->sc_ccb_queue, &ccb->ccb_h, sim_links.tqe);
 1337         ++gdt_stat.req_queue_act;
 1338         if (gdt_stat.req_queue_act > gdt_stat.req_queue_max)
 1339             gdt_stat.req_queue_max = gdt_stat.req_queue_act;
 1340         splx(lock);
 1341         gdt_next(gdt);
 1342         break;
 1343       case XPT_RESET_DEV:   /* Bus Device Reset the specified SCSI device */
 1344       case XPT_ABORT:                       /* Abort the specified CCB */
 1345         /* XXX Implement */
 1346         ccb->ccb_h.status = CAM_REQ_INVALID;
 1347         --gdt_stat.io_count_act;
 1348         xpt_done(ccb);
 1349         break;
 1350       case XPT_SET_TRAN_SETTINGS:
 1351         ccb->ccb_h.status = CAM_FUNC_NOTAVAIL;
 1352         --gdt_stat.io_count_act;
 1353         xpt_done(ccb);  
 1354         break;
 1355       case XPT_GET_TRAN_SETTINGS:
 1356         /* Get default/user set transfer settings for the target */
 1357           {
 1358               struct        ccb_trans_settings *cts;
 1359               u_int target_mask;
 1360               
 1361               cts = &ccb->cts;
 1362               target_mask = 0x01 << target;
 1363               if ((cts->flags & CCB_TRANS_USER_SETTINGS) != 0) { 
 1364                   cts->flags = CCB_TRANS_DISC_ENB|CCB_TRANS_TAG_ENB;
 1365                   cts->bus_width = MSG_EXT_WDTR_BUS_16_BIT;
 1366                   cts->sync_period = 25; /* 10MHz */
 1367                   if (cts->sync_period != 0)
 1368                       cts->sync_offset = 15;
 1369                   
 1370                   cts->valid = CCB_TRANS_SYNC_RATE_VALID
 1371                       | CCB_TRANS_SYNC_OFFSET_VALID
 1372                       | CCB_TRANS_BUS_WIDTH_VALID
 1373                       | CCB_TRANS_DISC_VALID
 1374                       | CCB_TRANS_TQ_VALID;
 1375                   ccb->ccb_h.status = CAM_REQ_CMP;
 1376               } else {
 1377                   ccb->ccb_h.status = CAM_FUNC_NOTAVAIL;
 1378               }
 1379               --gdt_stat.io_count_act;
 1380               xpt_done(ccb);
 1381               break;
 1382           }
 1383       case XPT_CALC_GEOMETRY:
 1384           {
 1385               struct ccb_calc_geometry *ccg;
 1386               u_int32_t secs_per_cylinder;
 1387 
 1388               ccg = &ccb->ccg;
 1389               ccg->heads = gdt->sc_hdr[target].hd_heads;
 1390               ccg->secs_per_track = gdt->sc_hdr[target].hd_secs;
 1391               secs_per_cylinder = ccg->heads * ccg->secs_per_track;
 1392               ccg->cylinders = ccg->volume_size / secs_per_cylinder;
 1393               ccb->ccb_h.status = CAM_REQ_CMP;
 1394               --gdt_stat.io_count_act;
 1395               xpt_done(ccb);
 1396               break;
 1397           }
 1398       case XPT_RESET_BUS:           /* Reset the specified SCSI bus */
 1399           {
 1400               /* XXX Implement */
 1401               ccb->ccb_h.status = CAM_REQ_CMP;
 1402               --gdt_stat.io_count_act;
 1403               xpt_done(ccb);
 1404               break;
 1405           }
 1406       case XPT_TERM_IO:             /* Terminate the I/O process */
 1407         /* XXX Implement */
 1408         ccb->ccb_h.status = CAM_REQ_INVALID;
 1409         --gdt_stat.io_count_act;
 1410         xpt_done(ccb);
 1411         break;
 1412       case XPT_PATH_INQ:            /* Path routing inquiry */
 1413           {
 1414               struct ccb_pathinq *cpi = &ccb->cpi;
 1415               
 1416               cpi->version_num = 1;
 1417               cpi->hba_inquiry = PI_SDTR_ABLE|PI_TAG_ABLE;
 1418               cpi->hba_inquiry |= PI_WIDE_16;
 1419               cpi->target_sprt = 1;
 1420               cpi->hba_misc = 0;
 1421               cpi->hba_eng_cnt = 0;
 1422               if (bus == gdt->sc_virt_bus)
 1423                   cpi->max_target = GDT_MAX_HDRIVES - 1;
 1424               else if (gdt->sc_class & GDT_FC)
 1425                   cpi->max_target = GDT_MAXID_FC - 1;
 1426               else
 1427                   cpi->max_target = GDT_MAXID - 1;
 1428               cpi->max_lun = 7;
 1429               cpi->unit_number = cam_sim_unit(sim);
 1430               cpi->bus_id = bus;
 1431               cpi->initiator_id = 
 1432                   (bus == gdt->sc_virt_bus ? 127 : gdt->sc_bus_id[bus]);
 1433               cpi->base_transfer_speed = 3300;
 1434               strncpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN);
 1435               if (gdt->sc_vendor == INTEL_VENDOR_ID)
 1436                   strncpy(cpi->hba_vid, "Intel Corp.", HBA_IDLEN);
 1437               else
 1438                   strncpy(cpi->hba_vid, "ICP vortex ", HBA_IDLEN);
 1439               strncpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN);
 1440               cpi->ccb_h.status = CAM_REQ_CMP;
 1441               --gdt_stat.io_count_act;
 1442               xpt_done(ccb);
 1443               break;
 1444           }
 1445       default:
 1446         GDT_DPRINTF(GDT_D_INVALID, ("gdt_next(%p) cmd 0x%x invalid\n", 
 1447                                     gdt, ccb->ccb_h.func_code));
 1448         ccb->ccb_h.status = CAM_REQ_INVALID;
 1449         --gdt_stat.io_count_act;
 1450         xpt_done(ccb);
 1451         break;
 1452     }
 1453 }
 1454 
 1455 static void     
 1456 iir_poll( struct cam_sim *sim )
 1457 {
 1458     struct gdt_softc *gdt;
 1459 
 1460     gdt = (struct gdt_softc *)cam_sim_softc( sim );
 1461     GDT_DPRINTF(GDT_D_CMD, ("iir_poll sim %p gdt %p\n", sim, gdt));
 1462     iir_intr(gdt);
 1463 }
 1464 
 1465 static void     
 1466 iir_timeout(void *arg)
 1467 {
 1468     GDT_DPRINTF(GDT_D_TIMEOUT, ("iir_timeout(%p)\n", arg));
 1469 }
 1470 
 1471 static void
 1472 iir_watchdog(void *arg)
 1473 {
 1474     struct gdt_softc *gdt;
 1475 
 1476     gdt = (struct gdt_softc *)arg;
 1477     GDT_DPRINTF(GDT_D_DEBUG, ("iir_watchdog(%p)\n", gdt));
 1478 
 1479     {
 1480         int ccbs = 0, ucmds = 0, frees = 0, pends = 0;
 1481         struct gdt_ccb *p;
 1482         struct ccb_hdr *h;
 1483         struct gdt_ucmd *u;
 1484 
 1485         for (h = TAILQ_FIRST(&gdt->sc_ccb_queue); h != NULL; 
 1486              h = TAILQ_NEXT(h, sim_links.tqe))
 1487             ccbs++;
 1488         for (u = TAILQ_FIRST(&gdt->sc_ucmd_queue); u != NULL; 
 1489              u = TAILQ_NEXT(u, links))
 1490             ucmds++;
 1491         for (p = SLIST_FIRST(&gdt->sc_free_gccb); p != NULL; 
 1492              p = SLIST_NEXT(p, sle))
 1493             frees++;
 1494         for (p = SLIST_FIRST(&gdt->sc_pending_gccb); p != NULL; 
 1495              p = SLIST_NEXT(p, sle))
 1496             pends++;
 1497 
 1498         GDT_DPRINTF(GDT_D_TIMEOUT, ("ccbs %d ucmds %d frees %d pends %d\n",
 1499                                     ccbs, ucmds, frees, pends));
 1500     }
 1501 
 1502     timeout(iir_watchdog, (caddr_t)gdt, hz * 15);
 1503 }
 1504 
 1505 static void     
 1506 iir_shutdown( void *arg, int howto )
 1507 {
 1508     struct gdt_softc *gdt;
 1509     struct gdt_ccb *gccb;
 1510     gdt_ucmd_t *ucmd;
 1511     int lock, i;
 1512 
 1513     gdt = (struct gdt_softc *)arg;
 1514     GDT_DPRINTF(GDT_D_CMD, ("iir_shutdown(%p, %d)\n", gdt, howto));
 1515 
 1516     printf("iir%d: Flushing all Host Drives. Please wait ...  ",
 1517            gdt->sc_hanum);
 1518 
 1519     /* allocate ucmd buffer */
 1520     ucmd = malloc(sizeof(gdt_ucmd_t), M_DEVBUF, M_NOWAIT);
 1521     if (ucmd == NULL) {
 1522         printf("iir%d: iir_shutdown(): Cannot allocate resource\n",
 1523                gdt->sc_hanum);
 1524         return;
 1525     }
 1526     bzero(ucmd, sizeof(gdt_ucmd_t));
 1527 
 1528     /* wait for pending IOs */
 1529     lock = splcam();
 1530     gdt->sc_state = GDT_SHUTDOWN;
 1531     splx(lock);
 1532     if ((gccb = SLIST_FIRST(&gdt->sc_pending_gccb)) != NULL)
 1533         (void) tsleep((void *)gccb, PCATCH | PRIBIO, "iirshw", 100 * hz);
 1534 
 1535     /* flush */
 1536     for (i = 0; i < GDT_MAX_HDRIVES; ++i) {
 1537         if (gdt->sc_hdr[i].hd_present) {
 1538             ucmd->service = GDT_CACHESERVICE;
 1539             ucmd->OpCode = GDT_FLUSH;
 1540             ucmd->u.cache.DeviceNo = i;
 1541             lock = splcam();
 1542             TAILQ_INSERT_TAIL(&gdt->sc_ucmd_queue, ucmd, links);
 1543             ucmd->complete_flag = FALSE;
 1544             splx(lock);
 1545             gdt_next(gdt);
 1546             if (!ucmd->complete_flag)
 1547                 (void) tsleep((void *)ucmd, PCATCH|PRIBIO, "iirshw", 10*hz);
 1548         }
 1549     }
 1550 
 1551     free(ucmd, M_DEVBUF);
 1552     printf("Done.\n");
 1553 }
 1554 
 1555 void
 1556 iir_intr(void *arg)
 1557 {
 1558     struct gdt_softc *gdt = arg;
 1559     struct gdt_intr_ctx ctx;
 1560     int lock = 0;
 1561     struct gdt_ccb *gccb;
 1562     gdt_ucmd_t *ucmd;
 1563     u_int32_t cnt;
 1564 
 1565     GDT_DPRINTF(GDT_D_INTR, ("gdt_intr(%p)\n", gdt));
 1566 
 1567     /* If polling and we were not called from gdt_wait, just return */
 1568     if ((gdt->sc_state & GDT_POLLING) &&
 1569         !(gdt->sc_state & GDT_POLL_WAIT))
 1570         return;
 1571 
 1572     if (!(gdt->sc_state & GDT_POLLING)) 
 1573         lock = splcam();
 1574     gdt_wait_index = 0;
 1575 
 1576     ctx.istatus = gdt->sc_get_status(gdt);
 1577     if (!ctx.istatus) {
 1578         if (!(gdt->sc_state & GDT_POLLING)) 
 1579             splx(lock);
 1580         gdt->sc_status = GDT_S_NO_STATUS;
 1581         return;
 1582     }
 1583 
 1584     gdt->sc_intr(gdt, &ctx);
 1585 
 1586     gdt->sc_status = ctx.cmd_status;
 1587     gdt->sc_service = ctx.service;
 1588     gdt->sc_info = ctx.info;
 1589     gdt->sc_info2 = ctx.info2;
 1590 
 1591     if (gdt->sc_state & GDT_POLL_WAIT) { 
 1592         gdt_wait_gdt = gdt;
 1593         gdt_wait_index = ctx.istatus;
 1594     }
 1595 
 1596     if (ctx.istatus == GDT_ASYNCINDEX) {
 1597         gdt_async_event(gdt, ctx.service);
 1598         if (!(gdt->sc_state & GDT_POLLING)) 
 1599             splx(lock);
 1600         return;
 1601     }
 1602     if (ctx.istatus == GDT_SPEZINDEX) {
 1603         GDT_DPRINTF(GDT_D_INVALID, 
 1604                     ("iir%d: Service unknown or not initialized!\n", 
 1605                      gdt->sc_hanum));   
 1606         gdt->sc_dvr.size = sizeof(gdt->sc_dvr.eu.driver);
 1607         gdt->sc_dvr.eu.driver.ionode = gdt->sc_hanum;
 1608         gdt_store_event(GDT_ES_DRIVER, 4, &gdt->sc_dvr);
 1609         if (!(gdt->sc_state & GDT_POLLING)) 
 1610             splx(lock);
 1611         return;
 1612     }
 1613 
 1614     gccb = &gdt->sc_gccbs[ctx.istatus - 2];
 1615     ctx.service = gccb->gc_service;
 1616 
 1617     switch (gccb->gc_flags) {
 1618       case GDT_GCF_UNUSED:
 1619         GDT_DPRINTF(GDT_D_INVALID, ("iir%d: Index (%d) to unused command!\n",
 1620                     gdt->sc_hanum, ctx.istatus));
 1621         gdt->sc_dvr.size = sizeof(gdt->sc_dvr.eu.driver);
 1622         gdt->sc_dvr.eu.driver.ionode = gdt->sc_hanum;
 1623         gdt->sc_dvr.eu.driver.index = ctx.istatus;
 1624         gdt_store_event(GDT_ES_DRIVER, 1, &gdt->sc_dvr);
 1625         gdt_free_ccb(gdt, gccb);
 1626         /* fallthrough */
 1627 
 1628       case GDT_GCF_INTERNAL:
 1629         if (!(gdt->sc_state & GDT_POLLING)) 
 1630             splx(lock);
 1631         break;
 1632 
 1633       case GDT_GCF_IOCTL:
 1634         ucmd = gccb->gc_ucmd; 
 1635         if (gdt->sc_status == GDT_S_BSY) {
 1636             GDT_DPRINTF(GDT_D_DEBUG, ("iir_intr(%p) ioctl: gccb %p busy\n", 
 1637                                       gdt, gccb));
 1638             TAILQ_INSERT_HEAD(&gdt->sc_ucmd_queue, ucmd, links);
 1639             if (!(gdt->sc_state & GDT_POLLING)) 
 1640                 splx(lock);
 1641         } else {
 1642             ucmd->status = gdt->sc_status;
 1643             ucmd->info = gdt->sc_info;
 1644             ucmd->complete_flag = TRUE;
 1645             if (ucmd->service == GDT_CACHESERVICE) {
 1646                 if (ucmd->OpCode == GDT_IOCTL) {
 1647                     cnt = ucmd->u.ioctl.param_size;
 1648                     if (cnt != 0)
 1649                         bcopy(gccb->gc_scratch, ucmd->data, cnt);
 1650                 } else {
 1651                     cnt = ucmd->u.cache.BlockCnt * GDT_SECTOR_SIZE;
 1652                     if (cnt != 0)
 1653                         bcopy(gccb->gc_scratch, ucmd->data, cnt);
 1654                 }
 1655             } else {
 1656                 cnt = ucmd->u.raw.sdlen;
 1657                 if (cnt != 0)
 1658                     bcopy(gccb->gc_scratch, ucmd->data, cnt);
 1659                 if (ucmd->u.raw.sense_len != 0) 
 1660                     bcopy(gccb->gc_scratch, ucmd->data, cnt);
 1661             }
 1662             gdt_free_ccb(gdt, gccb);
 1663             if (!(gdt->sc_state & GDT_POLLING)) 
 1664                 splx(lock);
 1665             /* wakeup */
 1666             wakeup(ucmd);
 1667         }
 1668         gdt_next(gdt); 
 1669         break;
 1670 
 1671       default:
 1672         gdt_free_ccb(gdt, gccb);
 1673         gdt_sync_event(gdt, ctx.service, ctx.istatus, gccb);
 1674         if (!(gdt->sc_state & GDT_POLLING)) 
 1675             splx(lock);
 1676         gdt_next(gdt); 
 1677         break;
 1678     }
 1679 }
 1680 
 1681 int
 1682 gdt_async_event(struct gdt_softc *gdt, int service)
 1683 {
 1684     struct gdt_ccb *gccb;
 1685 
 1686     GDT_DPRINTF(GDT_D_INTR, ("gdt_async_event(%p, %d)\n", gdt, service));
 1687 
 1688     if (service == GDT_SCREENSERVICE) {
 1689         if (gdt->sc_status == GDT_MSG_REQUEST) {
 1690             while (gdt->sc_test_busy(gdt))
 1691                 DELAY(1);
 1692             bzero(gdt->sc_cmd, GDT_CMD_SZ);
 1693             gccb = gdt_get_ccb(gdt);
 1694             if (gccb == NULL) {
 1695                 printf("iir%d: No free command index found\n",
 1696                        gdt->sc_hanum);
 1697                 return (1);
 1698             }
 1699             gccb->gc_service = service;
 1700             gccb->gc_flags = GDT_GCF_SCREEN;
 1701             gdt->sc_set_sema0(gdt);
 1702             gdt_enc32(gdt->sc_cmd + GDT_CMD_COMMANDINDEX,
 1703                       gccb->gc_cmd_index);
 1704             gdt_enc16(gdt->sc_cmd + GDT_CMD_OPCODE, GDT_READ);
 1705             gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_SCREEN_MSG_HANDLE,
 1706                       GDT_MSG_INV_HANDLE);
 1707             gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_SCREEN_MSG_ADDR,
 1708                       gdt_ccb_vtop(gdt, gccb) + 
 1709                       offsetof(struct gdt_ccb, gc_scratch[0]));
 1710             gdt->sc_cmd_off = 0;
 1711             gdt->sc_cmd_len = roundup(GDT_CMD_UNION + GDT_SCREEN_SZ, 
 1712                                       sizeof(u_int32_t));
 1713             gdt->sc_cmd_cnt = 0;
 1714             gdt->sc_copy_cmd(gdt, gccb);
 1715             printf("iir%d: [PCI %d/%d] ",
 1716                 gdt->sc_hanum,gdt->sc_bus,gdt->sc_slot);
 1717             gdt->sc_release_event(gdt);
 1718         }
 1719 
 1720     } else {
 1721         if ((gdt->sc_fw_vers & 0xff) >= 0x1a) {
 1722             gdt->sc_dvr.size = 0;
 1723             gdt->sc_dvr.eu.async.ionode = gdt->sc_hanum;
 1724             gdt->sc_dvr.eu.async.status  = gdt->sc_status;
 1725             /* severity and event_string already set! */
 1726         } else {        
 1727             gdt->sc_dvr.size = sizeof(gdt->sc_dvr.eu.async);
 1728             gdt->sc_dvr.eu.async.ionode   = gdt->sc_hanum;
 1729             gdt->sc_dvr.eu.async.service = service;
 1730             gdt->sc_dvr.eu.async.status  = gdt->sc_status;
 1731             gdt->sc_dvr.eu.async.info    = gdt->sc_info;
 1732             *(u_int32_t *)gdt->sc_dvr.eu.async.scsi_coord  = gdt->sc_info2;
 1733         }
 1734         gdt_store_event(GDT_ES_ASYNC, service, &gdt->sc_dvr);
 1735         printf("iir%d: %s\n", gdt->sc_hanum, gdt->sc_dvr.event_string);
 1736     }
 1737     
 1738     return (0);
 1739 }
 1740 
 1741 int
 1742 gdt_sync_event(struct gdt_softc *gdt, int service, 
 1743                u_int8_t index, struct gdt_ccb *gccb)
 1744 {
 1745     union ccb *ccb;
 1746 
 1747     GDT_DPRINTF(GDT_D_INTR,
 1748                 ("gdt_sync_event(%p, %d, %d, %p)\n", gdt,service,index,gccb));
 1749 
 1750     ccb = gccb->gc_ccb;
 1751 
 1752     if (service == GDT_SCREENSERVICE) {
 1753         u_int32_t msg_len;
 1754 
 1755         msg_len = gdt_dec32(gccb->gc_scratch + GDT_SCR_MSG_LEN);
 1756         if (msg_len)
 1757             if (!(gccb->gc_scratch[GDT_SCR_MSG_ANSWER] && 
 1758                   gccb->gc_scratch[GDT_SCR_MSG_EXT])) {
 1759                 gccb->gc_scratch[GDT_SCR_MSG_TEXT + msg_len] = '\0';
 1760                 printf("%s",&gccb->gc_scratch[GDT_SCR_MSG_TEXT]);
 1761             }
 1762 
 1763         if (gccb->gc_scratch[GDT_SCR_MSG_EXT] && 
 1764             !gccb->gc_scratch[GDT_SCR_MSG_ANSWER]) {
 1765             while (gdt->sc_test_busy(gdt))
 1766                 DELAY(1);
 1767             bzero(gdt->sc_cmd, GDT_CMD_SZ);
 1768             gccb = gdt_get_ccb(gdt);
 1769             if (gccb == NULL) {
 1770                 printf("iir%d: No free command index found\n",
 1771                        gdt->sc_hanum);
 1772                 return (1);
 1773             }
 1774             gccb->gc_service = service;
 1775             gccb->gc_flags = GDT_GCF_SCREEN;
 1776             gdt->sc_set_sema0(gdt);
 1777             gdt_enc32(gdt->sc_cmd + GDT_CMD_COMMANDINDEX,
 1778                       gccb->gc_cmd_index);
 1779             gdt_enc16(gdt->sc_cmd + GDT_CMD_OPCODE, GDT_READ);
 1780             gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_SCREEN_MSG_HANDLE,
 1781                       gccb->gc_scratch[GDT_SCR_MSG_HANDLE]);
 1782             gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_SCREEN_MSG_ADDR,
 1783                       gdt_ccb_vtop(gdt, gccb) + 
 1784                       offsetof(struct gdt_ccb, gc_scratch[0]));
 1785             gdt->sc_cmd_off = 0;
 1786             gdt->sc_cmd_len = roundup(GDT_CMD_UNION + GDT_SCREEN_SZ, 
 1787                                       sizeof(u_int32_t));
 1788             gdt->sc_cmd_cnt = 0;
 1789             gdt->sc_copy_cmd(gdt, gccb);
 1790             gdt->sc_release_event(gdt);
 1791             return (0);
 1792         }
 1793 
 1794         if (gccb->gc_scratch[GDT_SCR_MSG_ANSWER] && 
 1795             gdt_dec32(gccb->gc_scratch + GDT_SCR_MSG_ALEN)) {
 1796             /* default answers (getchar() not possible) */
 1797             if (gdt_dec32(gccb->gc_scratch + GDT_SCR_MSG_ALEN) == 1) {
 1798                 gdt_enc32(gccb->gc_scratch + GDT_SCR_MSG_ALEN, 0);
 1799                 gdt_enc32(gccb->gc_scratch + GDT_SCR_MSG_LEN, 1);
 1800                 gccb->gc_scratch[GDT_SCR_MSG_TEXT] = 0;
 1801             } else {
 1802                 gdt_enc32(gccb->gc_scratch + GDT_SCR_MSG_ALEN, 
 1803                           gdt_dec32(gccb->gc_scratch + GDT_SCR_MSG_ALEN) - 2);
 1804                 gdt_enc32(gccb->gc_scratch + GDT_SCR_MSG_LEN, 2);
 1805                 gccb->gc_scratch[GDT_SCR_MSG_TEXT] = 1;
 1806                 gccb->gc_scratch[GDT_SCR_MSG_TEXT + 1] = 0;
 1807             }
 1808             gccb->gc_scratch[GDT_SCR_MSG_EXT] = 0;
 1809             gccb->gc_scratch[GDT_SCR_MSG_ANSWER] = 0;
 1810             while (gdt->sc_test_busy(gdt))
 1811                 DELAY(1);
 1812             bzero(gdt->sc_cmd, GDT_CMD_SZ);
 1813             gccb = gdt_get_ccb(gdt);
 1814             if (gccb == NULL) {
 1815                 printf("iir%d: No free command index found\n",
 1816                        gdt->sc_hanum);
 1817                 return (1);
 1818             }
 1819             gccb->gc_service = service;
 1820             gccb->gc_flags = GDT_GCF_SCREEN;
 1821             gdt->sc_set_sema0(gdt);
 1822             gdt_enc32(gdt->sc_cmd + GDT_CMD_COMMANDINDEX,
 1823                       gccb->gc_cmd_index);
 1824             gdt_enc16(gdt->sc_cmd + GDT_CMD_OPCODE, GDT_WRITE);
 1825             gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_SCREEN_MSG_HANDLE,
 1826                       gccb->gc_scratch[GDT_SCR_MSG_HANDLE]);
 1827             gdt_enc32(gdt->sc_cmd + GDT_CMD_UNION + GDT_SCREEN_MSG_ADDR,
 1828                       gdt_ccb_vtop(gdt, gccb) + 
 1829                       offsetof(struct gdt_ccb, gc_scratch[0]));
 1830             gdt->sc_cmd_off = 0;
 1831             gdt->sc_cmd_len = roundup(GDT_CMD_UNION + GDT_SCREEN_SZ, 
 1832                                       sizeof(u_int32_t));
 1833             gdt->sc_cmd_cnt = 0;
 1834             gdt->sc_copy_cmd(gdt, gccb);
 1835             gdt->sc_release_event(gdt);
 1836             return (0);
 1837         }
 1838         printf("\n");
 1839         return (0);
 1840     } else {
 1841         untimeout(iir_timeout, gccb, ccb->ccb_h.timeout_ch);
 1842         if (gdt->sc_status == GDT_S_BSY) {
 1843             GDT_DPRINTF(GDT_D_DEBUG, ("gdt_sync_event(%p) gccb %p busy\n", 
 1844                                       gdt, gccb));
 1845             TAILQ_INSERT_HEAD(&gdt->sc_ccb_queue, &ccb->ccb_h, sim_links.tqe);
 1846             ++gdt_stat.req_queue_act;
 1847             if (gdt_stat.req_queue_act > gdt_stat.req_queue_max)
 1848                 gdt_stat.req_queue_max = gdt_stat.req_queue_act;
 1849             return (2);
 1850         }
 1851 
 1852         bus_dmamap_sync(gdt->sc_buffer_dmat, gccb->gc_dmamap, 
 1853             (ccb->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN ?
 1854             BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE);
 1855 
 1856         ccb->csio.resid = 0;
 1857         if (gdt->sc_status == GDT_S_OK) {
 1858             ccb->ccb_h.status = CAM_REQ_CMP;
 1859         } else {
 1860             /* error */
 1861             if (gccb->gc_service == GDT_CACHESERVICE) {
 1862                 ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR | CAM_AUTOSNS_VALID;
 1863                 ccb->csio.scsi_status = SCSI_STATUS_CHECK_COND;
 1864                 bzero(&ccb->csio.sense_data, ccb->csio.sense_len);
 1865                 ccb->csio.sense_data.error_code =
 1866                     SSD_CURRENT_ERROR | SSD_ERRCODE_VALID;
 1867                 ccb->csio.sense_data.flags = SSD_KEY_NOT_READY;
 1868 
 1869                 gdt->sc_dvr.size = sizeof(gdt->sc_dvr.eu.sync);
 1870                 gdt->sc_dvr.eu.sync.ionode  = gdt->sc_hanum;
 1871                 gdt->sc_dvr.eu.sync.service = service;
 1872                 gdt->sc_dvr.eu.sync.status  = gdt->sc_status;
 1873                 gdt->sc_dvr.eu.sync.info    = gdt->sc_info;
 1874                 gdt->sc_dvr.eu.sync.hostdrive = ccb->ccb_h.target_id;
 1875                 if (gdt->sc_status >= 0x8000)
 1876                     gdt_store_event(GDT_ES_SYNC, 0, &gdt->sc_dvr);
 1877                 else
 1878                     gdt_store_event(GDT_ES_SYNC, service, &gdt->sc_dvr);
 1879             } else {
 1880                 /* raw service */
 1881                 if (gdt->sc_status != GDT_S_RAW_SCSI || gdt->sc_info >= 0x100) {
 1882                     ccb->ccb_h.status = CAM_DEV_NOT_THERE;
 1883                 } else {
 1884                     ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR|CAM_AUTOSNS_VALID;
 1885                     ccb->csio.scsi_status = gdt->sc_info;
 1886                     bcopy(gccb->gc_scratch, &ccb->csio.sense_data,
 1887                           ccb->csio.sense_len);
 1888                 }
 1889             }
 1890         }
 1891         --gdt_stat.io_count_act;
 1892         xpt_done(ccb);
 1893     }
 1894     return (0);
 1895 }
 1896 
 1897 /* Controller event handling functions */
 1898 gdt_evt_str *gdt_store_event(u_int16_t source, u_int16_t idx,
 1899                              gdt_evt_data *evt)
 1900 {
 1901     gdt_evt_str *e;
 1902     struct timeval tv;
 1903 
 1904     GDT_DPRINTF(GDT_D_MISC, ("gdt_store_event(%d, %d)\n", source, idx));
 1905     if (source == 0)                        /* no source -> no event */
 1906         return 0;
 1907 
 1908     if (ebuffer[elastidx].event_source == source &&
 1909         ebuffer[elastidx].event_idx == idx &&
 1910         ((evt->size != 0 && ebuffer[elastidx].event_data.size != 0 &&
 1911           !memcmp((char *)&ebuffer[elastidx].event_data.eu,
 1912                   (char *)&evt->eu, evt->size)) ||
 1913          (evt->size == 0 && ebuffer[elastidx].event_data.size == 0 &&
 1914           !strcmp((char *)&ebuffer[elastidx].event_data.event_string,
 1915                   (char *)&evt->event_string)))) { 
 1916         e = &ebuffer[elastidx];
 1917         getmicrotime(&tv);
 1918         e->last_stamp = tv.tv_sec;
 1919         ++e->same_count;
 1920     } else {
 1921         if (ebuffer[elastidx].event_source != 0) {  /* entry not free ? */
 1922             ++elastidx;
 1923             if (elastidx == GDT_MAX_EVENTS)
 1924                 elastidx = 0;
 1925             if (elastidx == eoldidx) {              /* reached mark ? */
 1926                 ++eoldidx;
 1927                 if (eoldidx == GDT_MAX_EVENTS)
 1928                     eoldidx = 0;
 1929             }
 1930         }
 1931         e = &ebuffer[elastidx];
 1932         e->event_source = source;
 1933         e->event_idx = idx;
 1934         getmicrotime(&tv);
 1935         e->first_stamp = e->last_stamp = tv.tv_sec;
 1936         e->same_count = 1;
 1937         e->event_data = *evt;
 1938         e->application = 0;
 1939     }
 1940     return e;
 1941 }
 1942 
 1943 int gdt_read_event(int handle, gdt_evt_str *estr)
 1944 {
 1945     gdt_evt_str *e;
 1946     int eindex, lock;
 1947     
 1948     GDT_DPRINTF(GDT_D_MISC, ("gdt_read_event(%d)\n", handle));
 1949     lock = splcam();
 1950     if (handle == -1)
 1951         eindex = eoldidx;
 1952     else
 1953         eindex = handle;
 1954     estr->event_source = 0;
 1955 
 1956     if (eindex >= GDT_MAX_EVENTS) {
 1957         splx(lock);
 1958         return eindex;
 1959     }
 1960     e = &ebuffer[eindex];
 1961     if (e->event_source != 0) {
 1962         if (eindex != elastidx) {
 1963             if (++eindex == GDT_MAX_EVENTS)
 1964                 eindex = 0;
 1965         } else {
 1966             eindex = -1;
 1967         }
 1968         memcpy(estr, e, sizeof(gdt_evt_str));
 1969     }
 1970     splx(lock);
 1971     return eindex;
 1972 }
 1973 
 1974 void gdt_readapp_event(u_int8_t application, gdt_evt_str *estr)
 1975 {
 1976     gdt_evt_str *e;
 1977     int found = FALSE;
 1978     int eindex, lock;
 1979     
 1980     GDT_DPRINTF(GDT_D_MISC, ("gdt_readapp_event(%d)\n", application));
 1981     lock = splcam();
 1982     eindex = eoldidx;
 1983     for (;;) {
 1984         e = &ebuffer[eindex];
 1985         if (e->event_source == 0)
 1986             break;
 1987         if ((e->application & application) == 0) {
 1988             e->application |= application;
 1989             found = TRUE;
 1990             break;
 1991         }
 1992         if (eindex == elastidx)
 1993             break;
 1994         if (++eindex == GDT_MAX_EVENTS)
 1995             eindex = 0;
 1996     }
 1997     if (found)
 1998         memcpy(estr, e, sizeof(gdt_evt_str));
 1999     else
 2000         estr->event_source = 0;
 2001     splx(lock);
 2002 }
 2003 
 2004 void gdt_clear_events()
 2005 {
 2006     GDT_DPRINTF(GDT_D_MISC, ("gdt_clear_events\n"));
 2007 
 2008     eoldidx = elastidx = 0;
 2009     ebuffer[0].event_source = 0;
 2010 }

Cache object: 855e098f9ba69fae6ed5959323df3e13


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.