1 /* $NetBSD: isp_netbsd.h,v 1.76 2019/09/20 14:20:45 christos Exp $ */
2 /*
3 * NetBSD Specific definitions for the Qlogic ISP Host Adapter
4 */
5 /*
6 * Copyright (C) 1997, 1998, 1999 National Aeronautics & Space Administration
7 * All rights reserved.
8 *
9 * Additional Copyright (C) 2000-2007 by Matthew Jacob
10 * All rights reserved.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions and the following disclaimer.
17 * 2. Redistributions in binary form must reproduce the above copyright
18 * notice, this list of conditions and the following disclaimer in the
19 * documentation and/or other materials provided with the distribution.
20 * 3. The name of the author may not be used to endorse or promote products
21 * derived from this software without specific prior written permission
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
24 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
25 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
26 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
27 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
28 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
32 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 */
34 #ifndef _ISP_NETBSD_H
35 #define _ISP_NETBSD_H
36
37 #include <sys/types.h>
38 #include <sys/param.h>
39 #include <sys/systm.h>
40 #include <sys/kernel.h>
41 #include <sys/errno.h>
42 #include <sys/ioctl.h>
43 #include <sys/device.h>
44 #include <sys/malloc.h>
45 #include <sys/buf.h>
46 #include <sys/proc.h>
47 #include <sys/kthread.h>
48
49 #include <sys/bus.h>
50
51 #include <dev/scsipi/scsi_all.h>
52 #include <dev/scsipi/scsipi_all.h>
53 #include <dev/scsipi/scsiconf.h>
54
55 #include <dev/scsipi/scsi_message.h>
56 #include <dev/scsipi/scsipi_debug.h>
57
58 #include "opt_isp.h"
59
60 /*
61 * Efficiency- get rid of SBus code && tests unless we need them.
62 */
63 #if defined(__sparcv9__ ) || defined(__sparc__)
64 #define ISP_SBUS_SUPPORTED 1
65 #else
66 #define ISP_SBUS_SUPPORTED 0
67 #endif
68
69 #define ISP_PLATFORM_VERSION_MAJOR 5
70 #define ISP_PLATFORM_VERSION_MINOR 0
71
72 struct isposinfo {
73 device_t dev;
74 struct scsipi_adapter adapter;
75 struct scsipi_channel * chan;
76 bus_dma_tag_t dmatag;
77 bus_dmamap_t rqdmap;
78 bus_dmamap_t rsdmap;
79 bus_dmamap_t scdmap; /* FC only */
80 uint64_t wwns[256]; /* FC only */
81 int splsaved;
82 int mboxwaiting;
83 uint32_t islocked;
84 uint32_t onintstack;
85 uint32_t loop_down_time;
86 uint32_t loop_down_limit;
87 uint32_t gone_device_time;
88 unsigned int : 16,
89 : 8,
90 gdt_running : 1,
91 loop_checked : 1,
92 mbox_sleeping : 1,
93 mbox_sleep_ok : 1,
94 mboxcmd_done : 1,
95 mboxbsy : 1,
96 paused : 1,
97 blocked : 1;
98 struct callout ldt; /* loop down timer */
99 struct callout gdt; /* gone device timer */
100 uint64_t wwn;
101 uint16_t framesize;
102 uint16_t exec_throttle;
103 struct lwp * thread;
104 };
105 #define isp_dmatag isp_osinfo.dmatag
106 #define isp_rqdmap isp_osinfo.rqdmap
107 #define isp_rsdmap isp_osinfo.rsdmap
108 #define isp_scdmap isp_osinfo.scdmap
109
110 #define ISP_MUSTPOLL(isp) \
111 (isp->isp_osinfo.onintstack || isp->isp_osinfo.mbox_sleep_ok == 0)
112
113 /*
114 * Required Macros/Defines
115 */
116
117 #define ISP_FC_SCRLEN 0x1000
118
119 #define ISP_MEMZERO(dst, a) memset((dst), 0, (a))
120 #define ISP_MEMCPY(dst, src, a) memcpy((dst), (src), (a))
121 #define ISP_SNPRINTF snprintf
122 #define ISP_DELAY DELAY
123 #define ISP_SLEEP(isp, x) \
124 if (!ISP_MUSTPOLL(isp)) \
125 ISP_UNLOCK(isp); \
126 DELAY(x); \
127 if (!ISP_MUSTPOLL(isp)) \
128 ISP_LOCK(isp)
129
130 #define ISP_MIN imin
131 #define ISP_INLINE
132
133 #define NANOTIME_T struct timeval
134 #define GET_NANOTIME microtime
135 #define GET_NANOSEC(x) (((x)->tv_sec * 1000000 + (x)->tv_usec) * 1000)
136 #define NANOTIME_SUB isp_microtime_sub
137
138 #define MAXISPREQUEST(isp) 256
139
140
141 #define MEMORYBARRIER(isp, type, offset, size, c) \
142 switch (type) { \
143 case SYNC_REQUEST: \
144 { \
145 off_t off = (off_t) offset * QENTRY_LEN; \
146 bus_dmamap_sync(isp->isp_dmatag, isp->isp_rqdmap, \
147 off, size, BUS_DMASYNC_PREWRITE); \
148 break; \
149 } \
150 case SYNC_RESULT: \
151 { \
152 off_t off = (off_t) offset * QENTRY_LEN; \
153 bus_dmamap_sync(isp->isp_dmatag, isp->isp_rsdmap, \
154 off, size, BUS_DMASYNC_POSTREAD); \
155 break; \
156 } \
157 case SYNC_SFORDEV: \
158 { \
159 off_t off = (off_t) offset; \
160 bus_dmamap_sync(isp->isp_dmatag, isp->isp_scdmap, \
161 off, size, BUS_DMASYNC_PREWRITE); \
162 break; \
163 } \
164 case SYNC_SFORCPU: \
165 { \
166 off_t off = (off_t) offset; \
167 bus_dmamap_sync(isp->isp_dmatag, isp->isp_scdmap, \
168 off, size, BUS_DMASYNC_POSTREAD); \
169 break; \
170 } \
171 default: \
172 break; \
173 }
174
175 #define MBOX_ACQUIRE isp_mbox_acquire
176 #define MBOX_WAIT_COMPLETE isp_mbox_wait_complete
177 #define MBOX_NOTIFY_COMPLETE isp_mbox_notify_done
178 #define MBOX_RELEASE isp_mbox_release
179
180 #define FC_SCRATCH_ACQUIRE(isp, chan) 0
181 #define FC_SCRATCH_RELEASE(isp, chan) do { } while (0)
182
183 #ifndef SCSI_GOOD
184 #define SCSI_GOOD 0x0
185 #endif
186 #ifndef SCSI_CHECK
187 #define SCSI_CHECK 0x2
188 #endif
189 #ifndef SCSI_BUSY
190 #define SCSI_BUSY 0x8
191 #endif
192 #ifndef SCSI_QFULL
193 #define SCSI_QFULL 0x28
194 #endif
195
196 #define XS_T struct scsipi_xfer
197 #define XS_DMA_ADDR_T bus_addr_t
198 #define XS_DMA_ADDR_T bus_addr_t
199 #define XS_GET_DMA64_SEG(a, b, c) \
200 { \
201 ispds64_t *d = a; \
202 bus_dma_segment_t *e = b; \
203 uint32_t f = c; \
204 e += f; \
205 d->ds_base = DMA_LO32(e->ds_addr); \
206 d->ds_basehi = DMA_HI32(e->ds_addr); \
207 d->ds_count = e->ds_len; \
208 }
209 #define XS_GET_DMA_SEG(a, b, c) \
210 { \
211 ispds_t *d = a; \
212 bus_dma_segment_t *e = b; \
213 uint32_t f = c; \
214 e += f; \
215 d->ds_base = DMA_LO32(e->ds_addr); \
216 d->ds_count = e->ds_len; \
217 }
218 #define XS_CHANNEL(xs) \
219 ((int) (xs)->xs_periph->periph_channel->chan_channel)
220 #define XS_ISP(xs) \
221 device_private((xs)->xs_periph->periph_channel->chan_adapter->adapt_dev)
222 #define XS_LUN(xs) ((int) (xs)->xs_periph->periph_lun)
223 #define XS_TGT(xs) ((int) (xs)->xs_periph->periph_target)
224 #define XS_CDBP(xs) ((uint8_t *) (xs)->cmd)
225 #define XS_CDBLEN(xs) (xs)->cmdlen
226 #define XS_XFRLEN(xs) (xs)->datalen
227 #define XS_TIME(xs) (xs)->timeout
228 #define XS_GET_RESID(xs) (xs)->resid
229 #define XS_SET_RESID(xs, r) (xs)->resid = r
230 #define XS_STSP(xs) (&(xs)->status)
231 #define XS_SNSP(xs) (&(xs)->sense.scsi_sense)
232 #define XS_SNSLEN(xs) (sizeof (xs)->sense)
233 #define XS_SNSKEY(xs) SSD_SENSE_KEY((xs)->sense.scsi_sense.flags)
234 #define XS_SNSASC(xs) ((xs)->sense.scsi_sense.asc)
235 #define XS_SNSASCQ(xs) ((xs)->sense.scsi_sense.ascq)
236 /* PORTING NOTES: check to see if there's a better way of checking for tagged */
237 #define XS_TAG_P(ccb) (((xs)->xs_control & XS_CTL_POLL) != 0)
238 /* PORTING NOTES: We elimited OTAG option for performance */
239 #define XS_TAG_TYPE(xs) \
240 (((xs)->xs_control & XS_CTL_URGENT) ? REQFLAG_HTAG : REQFLAG_STAG)
241
242 #define XS_SETERR(xs, v) (xs)->error = v
243
244 # define HBA_NOERROR XS_NOERROR
245 # define HBA_BOTCH XS_DRIVER_STUFFUP
246 # define HBA_CMDTIMEOUT XS_TIMEOUT
247 # define HBA_SELTIMEOUT XS_SELTIMEOUT
248 # define HBA_TGTBSY XS_BUSY
249 # define HBA_BUSRESET XS_RESET
250 # define HBA_ABORTED XS_DRIVER_STUFFUP
251 # define HBA_DATAOVR XS_DRIVER_STUFFUP
252 # define HBA_ARQFAIL XS_DRIVER_STUFFUP
253
254 #define XS_ERR(xs) (xs)->error
255 #define XS_NOERR(xs) ((xs)->error == XS_NOERROR)
256 #define XS_INITERR(xs) (xs)->error = 0, XS_CMD_S_CLEAR(xs)
257
258 #define XS_SAVE_SENSE(xs, ptr, len) \
259 if (xs->error == XS_NOERROR) { \
260 xs->error = XS_SENSE; \
261 } \
262 memcpy(&(xs)->sense, ptr, imin(XS_SNSLEN(xs), len))
263
264 #define XS_SENSE_VALID(xs) (xs)->error == XS_SENSE
265
266 #define DEFAULT_FRAMESIZE(isp) (isp)->isp_osinfo.framesize
267 #define DEFAULT_EXEC_THROTTLE(isp) (isp)->isp_osinfo.exec_throttle
268 #define GET_DEFAULT_ROLE(isp, chan) ISP_ROLE_INITIATOR
269 #define SET_DEFAULT_ROLE(isp, chan) do { } while (0)
270 #define DEFAULT_IID(x, chan) 7
271 #define DEFAULT_LOOPID(x, chan) 108
272 #define DEFAULT_NODEWWN(isp, chan) (isp)->isp_osinfo.wwn
273 #define DEFAULT_PORTWWN(isp, chan) (isp)->isp_osinfo.wwn
274 #define ACTIVE_NODEWWN(isp, chan) \
275 ((isp)->isp_osinfo.wwn? (isp)->isp_osinfo.wwn : \
276 (FCPARAM(isp, chan)->isp_wwnn_nvram? \
277 FCPARAM(isp, chan)->isp_wwnn_nvram : 0x400000007F000008ull))
278 #define ACTIVE_PORTWWN(isp, chan) \
279 ((isp)->isp_osinfo.wwn? (isp)->isp_osinfo.wwn : \
280 (FCPARAM(isp, chan)->isp_wwpn_nvram? \
281 FCPARAM(isp, chan)->isp_wwpn_nvram : 0x400000007F000008ull))
282
283 #if _BYTE_ORDER == _BIG_ENDIAN
284 #ifdef ISP_SBUS_SUPPORTED
285 #define ISP_IOXPUT_8(isp, s, d) *(d) = s
286 #define ISP_IOXPUT_16(isp, s, d) \
287 *(d) = (isp->isp_bustype == ISP_BT_SBUS)? s : bswap16(s)
288 #define ISP_IOXPUT_32(isp, s, d) \
289 *(d) = (isp->isp_bustype == ISP_BT_SBUS)? s : bswap32(s)
290
291 #define ISP_IOXGET_8(isp, s, d) d = (*((uint8_t *)s))
292 #define ISP_IOXGET_16(isp, s, d) \
293 d = (isp->isp_bustype == ISP_BT_SBUS)? \
294 *((uint16_t *)s) : bswap16(*((uint16_t *)s))
295 #define ISP_IOXGET_32(isp, s, d) \
296 d = (isp->isp_bustype == ISP_BT_SBUS)? \
297 *((uint32_t *)s) : bswap32(*((uint32_t *)s))
298
299 #else /* ISP_SBUS_SUPPORTED */
300 #define ISP_IOXPUT_8(isp, s, d) *(d) = s
301 #define ISP_IOXPUT_16(isp, s, d) *(d) = bswap16(s)
302 #define ISP_IOXPUT_32(isp, s, d) *(d) = bswap32(s)
303 #define ISP_IOXGET_8(isp, s, d) d = (*((uint8_t *)s))
304 #define ISP_IOXGET_16(isp, s, d) d = bswap16(*((uint16_t *)s))
305 #define ISP_IOXGET_32(isp, s, d) d = bswap32(*((uint32_t *)s))
306 #endif /* ISP_SBUS_SUPPORTED */
307 #define ISP_SWIZZLE_NVRAM_WORD(isp, rp) *rp = bswap16(*rp)
308 #define ISP_SWIZZLE_NVRAM_LONG(isp, rp) *rp = bswap32(*rp)
309
310 #define ISP_IOZGET_8(isp, s, d) d = (*((uint8_t *)s))
311 #define ISP_IOZGET_16(isp, s, d) d = (*((uint16_t *)s))
312 #define ISP_IOZGET_32(isp, s, d) d = (*((uint32_t *)s))
313 #define ISP_IOZPUT_8(isp, s, d) *(d) = s
314 #define ISP_IOZPUT_16(isp, s, d) *(d) = s
315 #define ISP_IOZPUT_32(isp, s, d) *(d) = s
316
317 #else
318 #define ISP_IOXPUT_8(isp, s, d) *(d) = s
319 #define ISP_IOXPUT_16(isp, s, d) *(d) = s
320 #define ISP_IOXPUT_32(isp, s, d) *(d) = s
321 #define ISP_IOXGET_8(isp, s, d) d = *(s)
322 #define ISP_IOXGET_16(isp, s, d) d = *(s)
323 #define ISP_IOXGET_32(isp, s, d) d = *(s)
324 #define ISP_SWIZZLE_NVRAM_WORD(isp, rp)
325 #define ISP_SWIZZLE_NVRAM_LONG(isp, rp)
326
327 #define ISP_IOZPUT_8(isp, s, d) *(d) = s
328 #define ISP_IOZPUT_16(isp, s, d) *(d) = bswap16(s)
329 #define ISP_IOZPUT_32(isp, s, d) *(d) = bswap32(s)
330
331 #define ISP_IOZGET_8(isp, s, d) d = (*((uint8_t *)(s)))
332 #define ISP_IOZGET_16(isp, s, d) d = bswap16(*((uint16_t *)(s)))
333 #define ISP_IOZGET_32(isp, s, d) d = bswap32(*((uint32_t *)(s)))
334
335 #endif
336
337 #define ISP_SWAP16(isp, x) bswap16(x)
338 #define ISP_SWAP32(isp, x) bswap32(x)
339
340 /*
341 * Includes of common header files
342 */
343
344 #include <dev/ic/ispreg.h>
345 #include <dev/ic/ispvar.h>
346 #include <dev/ic/ispmbox.h>
347
348 /*
349 * isp_osinfo definitions, extensions and shorthand.
350 */
351 #define isp_unit device_unit(isp_osinfo.dev)
352
353
354 /*
355 * Driver prototypes..
356 */
357 void isp_attach(ispsoftc_t *);
358 void isp_uninit(ispsoftc_t *);
359
360 /*
361 * Driver wide data...
362 */
363
364 /*
365 * Locking macros...
366 */
367 #define ISP_LOCK isp_lock
368 #define ISP_UNLOCK isp_unlock
369 #define ISP_ILOCK(x) isp_lock(x); isp->isp_osinfo.onintstack++
370 #define ISP_IUNLOCK(x) isp->isp_osinfo.onintstack--; isp_unlock(x)
371
372 /*
373 * Platform private flags
374 */
375
376 #define XS_PSTS_INWDOG 0x10000000
377 #define XS_PSTS_GRACE 0x20000000
378 #define XS_PSTS_ALL 0x30000000
379
380 #define XS_CMD_S_WDOG(xs) (xs)->xs_status |= XS_PSTS_INWDOG
381 #define XS_CMD_C_WDOG(xs) (xs)->xs_status &= ~XS_PSTS_INWDOG
382 #define XS_CMD_WDOG_P(xs) (((xs)->xs_status & XS_PSTS_INWDOG) != 0)
383
384 #define XS_CMD_S_GRACE(xs) (xs)->xs_status |= XS_PSTS_GRACE
385 #define XS_CMD_C_GRACE(xs) (xs)->xs_status &= ~XS_PSTS_GRACE
386 #define XS_CMD_GRACE_P(xs) (((xs)->xs_status & XS_PSTS_GRACE) != 0)
387
388 #define XS_CMD_S_DONE(xs) (xs)->xs_status |= XS_STS_DONE
389 #define XS_CMD_C_DONE(xs) (xs)->xs_status &= ~XS_STS_DONE
390 #define XS_CMD_DONE_P(xs) (((xs)->xs_status & XS_STS_DONE) != 0)
391
392 #define XS_CMD_S_CLEAR(xs) (xs)->xs_status &= ~XS_PSTS_ALL
393
394 /*
395 * Platform Library Functionw
396 */
397 void isp_prt(ispsoftc_t *, int level, const char *, ...) __printflike(3, 4);
398 void isp_xs_prt(ispsoftc_t *, XS_T *, int level, const char *, ...)
399 __printflike(4, 5);
400 void isp_lock(ispsoftc_t *);
401 void isp_unlock(ispsoftc_t *);
402 uint64_t isp_microtime_sub(struct timeval *, struct timeval *);
403 int isp_mbox_acquire(ispsoftc_t *);
404 void isp_mbox_wait_complete(ispsoftc_t *, mbreg_t *);
405 void isp_mbox_notify_done(ispsoftc_t *);
406 void isp_mbox_release(ispsoftc_t *);
407
408 /*
409 * Common Library functions
410 */
411 #include <dev/ic/isp_library.h>
412
413 #if !defined(ISP_DISABLE_FW) && !defined(ISP_COMPILE_FW)
414 #define ISP_COMPILE_FW 1
415 #endif
416 #endif /* _ISP_NETBSD_H */
Cache object: 255cb7e90d8cc4de6a78144ec12d032a
|