1 /* $NetBSD: scsiconf.h,v 1.36 1997/07/07 22:45:37 cgd Exp $ */ 2 3 /* 4 * Copyright (c) 1993, 1994, 1995 Charles Hannum. All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 3. All advertising materials mentioning features or use of this software 15 * must display the following acknowledgement: 16 * This product includes software developed by Charles Hannum. 17 * 4. The name of the author may not be used to endorse or promote products 18 * derived from this software without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 21 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 22 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 23 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 24 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 25 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 29 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 /* 33 * Originally written by Julian Elischer (julian@tfs.com) 34 * for TRW Financial Systems for use under the MACH(2.5) operating system. 35 * 36 * TRW Financial Systems, in accordance with their agreement with Carnegie 37 * Mellon University, makes this software available to CMU to distribute 38 * or use in any manner that they see fit as long as this message is kept with 39 * the software. For this reason TFS also grants any other persons or 40 * organisations permission to use or modify this software. 41 * 42 * TFS supplies this software to be publicly redistributed 43 * on the understanding that TFS is not responsible for the correct 44 * functioning of this software in any circumstances. 45 * 46 * Ported to run under 386BSD by Julian Elischer (julian@tfs.com) Sept 1992 47 */ 48 49 #ifndef SCSI_SCSICONF_H 50 #define SCSI_SCSICONF_H 1 51 52 typedef int boolean; 53 54 #include <sys/queue.h> 55 #include <machine/cpu.h> 56 #include <scsi/scsi_debug.h> 57 58 /* 59 * The following documentation tries to describe the relationship between the 60 * various structures defined in this file: 61 * 62 * each adapter type has a scsi_adapter struct. This describes the adapter and 63 * identifies routines that can be called to use the adapter. 64 * each device type has a scsi_device struct. This describes the device and 65 * identifies routines that can be called to use the device. 66 * each existing device position (scsibus + target + lun) 67 * can be described by a scsi_link struct. 68 * Only scsi positions that actually have devices, have a scsi_link 69 * structure assigned. so in effect each device has scsi_link struct. 70 * The scsi_link structure contains information identifying both the 71 * device driver and the adapter driver for that position on that scsi bus, 72 * and can be said to 'link' the two. 73 * each individual scsi bus has an array that points to all the scsi_link 74 * structs associated with that scsi bus. Slots with no device have 75 * a NULL pointer. 76 * each individual device also knows the address of it's own scsi_link 77 * structure. 78 * 79 * ------------- 80 * 81 * The key to all this is the scsi_link structure which associates all the 82 * other structures with each other in the correct configuration. The 83 * scsi_link is the connecting information that allows each part of the 84 * scsi system to find the associated other parts. 85 */ 86 87 struct buf; 88 struct scsi_xfer; 89 90 /* 91 * These entrypoints are called by the high-end drivers to get services from 92 * whatever low-end drivers they are attached to each adapter type has one of 93 * these statically allocated. 94 */ 95 struct scsi_adapter { 96 int (*scsi_cmd) __P((struct scsi_xfer *)); 97 void (*scsi_minphys) __P((struct buf *)); 98 int (*open_target_lu) __P((void)); 99 int (*close_target_lu) __P((void)); 100 }; 101 102 /* 103 * return values for scsi_cmd() 104 */ 105 #define SUCCESSFULLY_QUEUED 0 106 #define TRY_AGAIN_LATER 1 107 #define COMPLETE 2 108 #define ESCAPE_NOT_SUPPORTED 3 109 110 /* 111 * These entry points are called by the low-end drivers to get services from 112 * whatever high-end drivers they are attached to. Each device type has one 113 * of these statically allocated. 114 */ 115 struct scsi_device { 116 int (*err_handler) __P((struct scsi_xfer *)); 117 /* returns -1 to say err processing done */ 118 void (*start) __P((void *)); 119 120 int (*async) __P((void)); 121 /* 122 * When called with `0' as the second argument, we expect status 123 * back from the upper-level driver. When called with a `1', 124 * we're simply notifying the upper-level driver that the command 125 * is complete and expect no status back. 126 */ 127 void (*done) __P((struct scsi_xfer *)); 128 }; 129 130 /* 131 * This structure describes the connection between an adapter driver and 132 * a device driver, and is used by each to call services provided by 133 * the other, and to allow generic scsi glue code to call these services 134 * as well. 135 * 136 * XXX Given the way NetBSD's autoconfiguration works, this is ... 137 * XXX nasty. 138 */ 139 struct scsi_link { 140 int channel; /* channel, i.e. bus # on controller */ 141 142 u_int8_t scsi_version; /* SCSI-I, SCSI-II, etc. */ 143 u_int8_t scsibus; /* the Nth scsibus */ 144 u_int8_t target; /* targ of this dev */ 145 u_int8_t lun; /* lun of this dev */ 146 u_int8_t adapter_target; /* what are we on the scsi bus */ 147 u_int8_t openings; /* available operations */ 148 u_int8_t active; /* operations in progress */ 149 u_int8_t flags; /* flags that all devices have */ 150 #define SDEV_REMOVABLE 0x01 /* media is removable */ 151 #define SDEV_MEDIA_LOADED 0x02 /* device figures are still valid */ 152 #define SDEV_WAITING 0x04 /* a process is waiting for this */ 153 #define SDEV_OPEN 0x08 /* at least 1 open session */ 154 #define SDEV_DBX 0xf0 /* debuging flags (scsi_debug.h) */ 155 u_int8_t quirks; /* per-device oddities */ 156 #define SDEV_AUTOSAVE 0x01 /* do implicit SAVEDATAPOINTER on disconnect */ 157 #define SDEV_NOSYNCWIDE 0x02 /* does not grok SDTR or WDTR */ 158 #define SDEV_NOLUNS 0x04 /* does not grok LUNs */ 159 #define SDEV_FORCELUNS 0x08 /* prehistoric drive/ctlr groks LUNs */ 160 #define SDEV_NOMODESENSE 0x10 /* removable media/optical drives */ 161 #define SDEV_NOSTARTUNIT 0x20 /* do not issue start unit requests in sd.c */ 162 struct scsi_device *device; /* device entry points etc. */ 163 void *device_softc; /* needed for call to foo_start */ 164 struct scsi_adapter *adapter; /* adapter entry points etc. */ 165 void *adapter_softc; /* needed for call to foo_scsi_cmd */ 166 int max_target; /* XXX max target supported by 167 adapter */ 168 }; 169 170 /* 171 * Other definitions used by autoconfiguration. 172 */ 173 #define scsicf_channel cf_loc[0] 174 #define SCSI_CHANNEL_UNKNOWN -1 175 176 #define SCSI_CHANNEL_ONLY_ONE -1 /* only one channel on controller */ 177 178 int scsiprint __P((void *, const char *)); 179 180 /* 181 * This describes matching information for scsi_inqmatch(). The more things 182 * match, the higher the configuration priority. 183 */ 184 struct scsi_inquiry_pattern { 185 u_int8_t type; 186 boolean removable; 187 char *vendor; 188 char *product; 189 char *revision; 190 }; 191 192 /* 193 * One of these is allocated and filled in for each scsi bus. 194 * it holds pointers to allow the scsi bus to get to the driver 195 * That is running each LUN on the bus 196 * it also has a template entry which is the prototype struct 197 * supplied by the adapter driver, this is used to initialise 198 * the others, before they have the rest of the fields filled in 199 */ 200 struct scsibus_softc { 201 struct device sc_dev; 202 struct scsi_link *adapter_link; /* prototype supplied by adapter */ 203 struct scsi_link ***sc_link; /* dynamically allocated */ 204 int sc_maxtarget; 205 u_int8_t moreluns; 206 }; 207 208 /* 209 * This is used to pass information from the high-level configuration code 210 * to the device-specific drivers. 211 */ 212 struct scsibus_attach_args { 213 struct scsi_link *sa_sc_link; 214 struct scsi_inquiry_data *sa_inqbuf; 215 }; 216 217 /* 218 * Each scsi transaction is fully described by one of these structures 219 * It includes information about the source of the command and also the 220 * device and adapter for which the command is destined. 221 * (via the scsi_link structure) 222 */ 223 struct scsi_xfer { 224 LIST_ENTRY(scsi_xfer) free_list; 225 int flags; 226 struct scsi_link *sc_link; /* all about our device and adapter */ 227 int retries; /* the number of times to retry */ 228 int timeout; /* in milliseconds */ 229 struct scsi_generic *cmd; /* The scsi command to execute */ 230 int cmdlen; /* how long it is */ 231 u_char *data; /* dma address OR a uio address */ 232 int datalen; /* data len (blank if uio) */ 233 int resid; /* how much buffer was not touched */ 234 int error; /* an error value */ 235 struct buf *bp; /* If we need to associate with a buf */ 236 struct scsi_sense_data sense; /* 32 bytes*/ 237 /* 238 * Believe it or not, Some targets fall on the ground with 239 * anything but a certain sense length. 240 */ 241 int req_sense_length; /* Explicit request sense length */ 242 u_int8_t status; /* SCSI status */ 243 struct scsi_generic cmdstore; /* stash the command in here */ 244 }; 245 246 /* 247 * Per-request Flag values 248 */ 249 #define SCSI_NOSLEEP 0x0001 /* don't sleep */ 250 #define SCSI_POLL 0x0002 /* poll for completion */ 251 #define SCSI_AUTOCONF 0x0003 /* shorthand for SCSI_POLL | SCSI_NOSLEEP */ 252 #define SCSI_USER 0x0004 /* Is a user cmd, call scsi_user_done */ 253 #define ITSDONE 0x0008 /* the transfer is as done as it gets */ 254 #define INUSE 0x0010 /* The scsi_xfer block is in use */ 255 #define SCSI_SILENT 0x0020 /* don't announce NOT READY or MEDIA CHANGE */ 256 #define SCSI_IGNORE_NOT_READY 0x0040 /* ignore NOT READY */ 257 #define SCSI_IGNORE_MEDIA_CHANGE 0x0080 /* ignore MEDIA CHANGE */ 258 #define SCSI_IGNORE_ILLEGAL_REQUEST 0x0100 /* ignore ILLEGAL REQUEST */ 259 #define SCSI_RESET 0x0200 /* Reset the device in question */ 260 #define SCSI_DATA_UIO 0x0400 /* The data address refers to a UIO */ 261 #define SCSI_DATA_IN 0x0800 /* expect data to come INTO memory */ 262 #define SCSI_DATA_OUT 0x1000 /* expect data to flow OUT of memory */ 263 #define SCSI_TARGET 0x2000 /* This defines a TARGET mode op. */ 264 #define SCSI_ESCAPE 0x4000 /* Escape operation */ 265 266 /* 267 * Escape op codes. This provides an extensible setup for operations 268 * that are not scsi commands. They are intended for modal operations. 269 */ 270 271 #define SCSI_OP_TARGET 0x0001 272 #define SCSI_OP_RESET 0x0002 273 #define SCSI_OP_BDINFO 0x0003 274 275 /* 276 * Error values an adapter driver may return 277 */ 278 #define XS_NOERROR 0 /* there is no error, (sense is invalid) */ 279 #define XS_SENSE 1 /* Check the returned sense for the error */ 280 #define XS_DRIVER_STUFFUP 2 /* Driver failed to perform operation */ 281 #define XS_SELTIMEOUT 3 /* The device timed out.. turned off? */ 282 #define XS_TIMEOUT 4 /* The Timeout reported was caught by SW */ 283 #define XS_BUSY 5 /* The device busy, try again later? */ 284 285 caddr_t scsi_inqmatch __P((struct scsi_inquiry_data *, caddr_t, int, int, int *)); 286 287 struct scsi_xfer *scsi_get_xs __P((struct scsi_link *, int)); 288 void scsi_free_xs __P((struct scsi_xfer *, int)); 289 int scsi_execute_xs __P((struct scsi_xfer *)); 290 u_long scsi_size __P((struct scsi_link *, int)); 291 int scsi_test_unit_ready __P((struct scsi_link *, int)); 292 int scsi_change_def __P((struct scsi_link *, int)); 293 int scsi_inquire __P((struct scsi_link *, struct scsi_inquiry_data *, int)); 294 int scsi_prevent __P((struct scsi_link *, int, int)); 295 int scsi_start __P((struct scsi_link *, int, int)); 296 void scsi_done __P((struct scsi_xfer *)); 297 void scsi_user_done __P((struct scsi_xfer *)); 298 int scsi_scsi_cmd __P((struct scsi_link *, struct scsi_generic *, 299 int cmdlen, u_char *data_addr, 300 int datalen, int retries, 301 int timeout, struct buf *bp, 302 int flags)); 303 int scsi_do_ioctl __P((struct scsi_link *, dev_t, u_long, caddr_t, int, struct proc *)); 304 void sc_print_addr __P((struct scsi_link *)); 305 306 void show_scsi_xs __P((struct scsi_xfer *)); 307 void show_scsi_cmd __P((struct scsi_xfer *)); 308 void show_mem __P((u_char *, int)); 309 int scsi_probe_busses __P((int, int, int)); 310 void scsi_strvis __P((u_char *, u_char *, int)); 311 312 static __inline void _lto2b __P((u_int32_t val, u_int8_t *bytes)) 313 __attribute__ ((unused)); 314 static __inline void _lto3b __P((u_int32_t val, u_int8_t *bytes)) 315 __attribute__ ((unused)); 316 static __inline void _lto4b __P((u_int32_t val, u_int8_t *bytes)) 317 __attribute__ ((unused)); 318 static __inline u_int32_t _2btol __P((u_int8_t *bytes)) 319 __attribute__ ((unused)); 320 static __inline u_int32_t _3btol __P((u_int8_t *bytes)) 321 __attribute__ ((unused)); 322 static __inline u_int32_t _4btol __P((u_int8_t *bytes)) 323 __attribute__ ((unused)); 324 325 static __inline void _lto2l __P((u_int32_t val, u_int8_t *bytes)) 326 __attribute__ ((unused)); 327 static __inline void _lto3l __P((u_int32_t val, u_int8_t *bytes)) 328 __attribute__ ((unused)); 329 static __inline void _lto4l __P((u_int32_t val, u_int8_t *bytes)) 330 __attribute__ ((unused)); 331 static __inline u_int32_t _2ltol __P((u_int8_t *bytes)) 332 __attribute__ ((unused)); 333 static __inline u_int32_t _3ltol __P((u_int8_t *bytes)) 334 __attribute__ ((unused)); 335 static __inline u_int32_t _4ltol __P((u_int8_t *bytes)) 336 __attribute__ ((unused)); 337 338 static __inline void 339 _lto2b(val, bytes) 340 u_int32_t val; 341 u_int8_t *bytes; 342 { 343 344 bytes[0] = (val >> 8) & 0xff; 345 bytes[1] = val & 0xff; 346 } 347 348 static __inline void 349 _lto3b(val, bytes) 350 u_int32_t val; 351 u_int8_t *bytes; 352 { 353 354 bytes[0] = (val >> 16) & 0xff; 355 bytes[1] = (val >> 8) & 0xff; 356 bytes[2] = val & 0xff; 357 } 358 359 static __inline void 360 _lto4b(val, bytes) 361 u_int32_t val; 362 u_int8_t *bytes; 363 { 364 365 bytes[0] = (val >> 24) & 0xff; 366 bytes[1] = (val >> 16) & 0xff; 367 bytes[2] = (val >> 8) & 0xff; 368 bytes[3] = val & 0xff; 369 } 370 371 static __inline u_int32_t 372 _2btol(bytes) 373 u_int8_t *bytes; 374 { 375 register u_int32_t rv; 376 377 rv = (bytes[0] << 8) | 378 bytes[1]; 379 return (rv); 380 } 381 382 static __inline u_int32_t 383 _3btol(bytes) 384 u_int8_t *bytes; 385 { 386 register u_int32_t rv; 387 388 rv = (bytes[0] << 16) | 389 (bytes[1] << 8) | 390 bytes[2]; 391 return (rv); 392 } 393 394 static __inline u_int32_t 395 _4btol(bytes) 396 u_int8_t *bytes; 397 { 398 register u_int32_t rv; 399 400 rv = (bytes[0] << 24) | 401 (bytes[1] << 16) | 402 (bytes[2] << 8) | 403 bytes[3]; 404 return (rv); 405 } 406 407 static __inline void 408 _lto2l(val, bytes) 409 u_int32_t val; 410 u_int8_t *bytes; 411 { 412 413 bytes[0] = val & 0xff; 414 bytes[1] = (val >> 8) & 0xff; 415 } 416 417 static __inline void 418 _lto3l(val, bytes) 419 u_int32_t val; 420 u_int8_t *bytes; 421 { 422 423 bytes[0] = val & 0xff; 424 bytes[1] = (val >> 8) & 0xff; 425 bytes[2] = (val >> 16) & 0xff; 426 } 427 428 static __inline void 429 _lto4l(val, bytes) 430 u_int32_t val; 431 u_int8_t *bytes; 432 { 433 434 bytes[0] = val & 0xff; 435 bytes[1] = (val >> 8) & 0xff; 436 bytes[2] = (val >> 16) & 0xff; 437 bytes[3] = (val >> 24) & 0xff; 438 } 439 440 static __inline u_int32_t 441 _2ltol(bytes) 442 u_int8_t *bytes; 443 { 444 register u_int32_t rv; 445 446 rv = bytes[0] | 447 (bytes[1] << 8); 448 return (rv); 449 } 450 451 static __inline u_int32_t 452 _3ltol(bytes) 453 u_int8_t *bytes; 454 { 455 register u_int32_t rv; 456 457 rv = bytes[0] | 458 (bytes[1] << 8) | 459 (bytes[2] << 16); 460 return (rv); 461 } 462 463 static __inline u_int32_t 464 _4ltol(bytes) 465 u_int8_t *bytes; 466 { 467 register u_int32_t rv; 468 469 rv = bytes[0] | 470 (bytes[1] << 8) | 471 (bytes[2] << 16) | 472 (bytes[3] << 24); 473 return (rv); 474 } 475 476 #endif /* SCSI_SCSICONF_H */ 477