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