1 /*
2 * Device driver for the SYMBIOS/LSILOGIC 53C8XX and 53C1010 family
3 * of PCI-SCSI IO processors.
4 *
5 * Copyright (C) 1999-2001 Gerard Roudier <groudier@free.fr>
6 *
7 * This driver is derived from the Linux sym53c8xx driver.
8 * Copyright (C) 1998-2000 Gerard Roudier
9 *
10 * The sym53c8xx driver is derived from the ncr53c8xx driver that had been
11 * a port of the FreeBSD ncr driver to Linux-1.2.13.
12 *
13 * The original ncr driver has been written for 386bsd and FreeBSD by
14 * Wolfgang Stanglmeier <wolf@cologne.de>
15 * Stefan Esser <se@mi.Uni-Koeln.de>
16 * Copyright (C) 1994 Wolfgang Stanglmeier
17 *
18 * Other major contributions:
19 *
20 * NVRAM detection and reading.
21 * Copyright (C) 1997 Richard Waltham <dormouse@farsrobt.demon.co.uk>
22 *
23 *-----------------------------------------------------------------------------
24 *
25 * Redistribution and use in source and binary forms, with or without
26 * modification, are permitted provided that the following conditions
27 * are met:
28 * 1. Redistributions of source code must retain the above copyright
29 * notice, this list of conditions and the following disclaimer.
30 * 2. The name of the author may not be used to endorse or promote products
31 * derived from this software without specific prior written permission.
32 *
33 * Where this Software is combined with software released under the terms of
34 * the GNU Public License ("GPL") and the terms of the GPL would require the
35 * combined work to also be released under the terms of the GPL, the terms
36 * and conditions of this License will apply in addition to those of the
37 * GPL with the exception of any terms or conditions of this License that
38 * conflict with, or are expressly prohibited by, the GPL.
39 *
40 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
41 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
43 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
44 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
45 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
46 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
48 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
49 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
50 * SUCH DAMAGE.
51 */
52
53 #ifdef __FreeBSD__
54 #include <dev/sym/sym_glue.h>
55 #else
56 #include "sym_glue.h"
57 #endif
58
59 #ifdef SYM_OPT_HANDLE_IO_TIMEOUT
60 /*
61 * Optional CCB timeout handling.
62 *
63 * This code is useful for O/Ses that allow or expect
64 * SIMs (low-level drivers) to handle SCSI IO timeouts.
65 * It uses a power-of-two based algorithm of my own:)
66 * that avoids scanning of lists, provided that:
67 *
68 * - The IO does complete in less than half the associated
69 * timeout value.
70 * - The greatest delay between the queuing of the IO and
71 * its completion is less than
72 * (1<<(SYM_CONF_TIMEOUT_ORDER_MAX-1))/2 ticks.
73 *
74 * For example, if tick is 1 second and the max order is 8,
75 * any IO that is completed within less than 64 seconds will
76 * just be put into some list at queuing and be removed
77 * at completion without any additionnal overhead.
78 */
79
80 /*
81 * Set a timeout condition on a CCB.
82 */
sym_timeout_ccb(hcb_p np,ccb_p cp,u_int ticks)83 void sym_timeout_ccb(hcb_p np, ccb_p cp, u_int ticks)
84 {
85 sym_remque(&cp->tmo_linkq);
86 cp->tmo_clock = np->tmo_clock + ticks;
87 if (!ticks) {
88 sym_insque_head(&cp->tmo_linkq, &np->tmo0_ccbq);
89 }
90 else {
91 int i = SYM_CONF_TIMEOUT_ORDER_MAX - 1;
92 while (i > 0) {
93 if (ticks >= (1<<(i+1)))
94 break;
95 --i;
96 }
97 if (!(np->tmo_actq & (1<<i)))
98 i += SYM_CONF_TIMEOUT_ORDER_MAX;
99 sym_insque_head(&cp->tmo_linkq, &np->tmo_ccbq[i]);
100 }
101 }
102
103 /*
104 * Walk a list of CCB and handle timeout conditions.
105 * Should never be called in normal situations.
106 */
sym_walk_ccb_tmo_list(hcb_p np,SYM_QUEHEAD * tmoq)107 static void sym_walk_ccb_tmo_list(hcb_p np, SYM_QUEHEAD *tmoq)
108 {
109 SYM_QUEHEAD qtmp, *qp;
110 ccb_p cp;
111
112 sym_que_move(tmoq, &qtmp);
113 while ((qp = sym_remque_head(&qtmp)) != 0) {
114 sym_insque_head(qp, &np->tmo0_ccbq);
115 cp = sym_que_entry(qp, struct sym_ccb, tmo_linkq);
116 if (cp->tmo_clock != np->tmo_clock &&
117 cp->tmo_clock + 1 != np->tmo_clock)
118 sym_timeout_ccb(np, cp, cp->tmo_clock - np->tmo_clock);
119 else
120 sym_abort_ccb(np, cp, 1);
121 }
122 }
123
124 /*
125 * Our clock handler called from the O/S specific side.
126 */
sym_clock(hcb_p np)127 void sym_clock(hcb_p np)
128 {
129 int i, j;
130 u_int tmp;
131
132 tmp = np->tmo_clock;
133 tmp ^= (++np->tmo_clock);
134
135 for (i = 0; i < SYM_CONF_TIMEOUT_ORDER_MAX; i++, tmp >>= 1) {
136 if (!(tmp & 1))
137 continue;
138 j = i;
139 if (np->tmo_actq & (1<<i))
140 j += SYM_CONF_TIMEOUT_ORDER_MAX;
141
142 if (!sym_que_empty(&np->tmo_ccbq[j])) {
143 sym_walk_ccb_tmo_list(np, &np->tmo_ccbq[j]);
144 }
145 np->tmo_actq ^= (1<<i);
146 }
147 }
148 #endif /* SYM_OPT_HANDLE_IO_TIMEOUT */
149
150
151 #ifdef SYM_OPT_ANNOUNCE_TRANSFER_RATE
152 /*
153 * Announce transfer rate if anything changed since last announcement.
154 */
sym_announce_transfer_rate(hcb_p np,int target)155 void sym_announce_transfer_rate(hcb_p np, int target)
156 {
157 tcb_p tp = &np->target[target];
158
159 #define __tprev tp->tinfo.prev
160 #define __tcurr tp->tinfo.curr
161
162 if (__tprev.options == __tcurr.options &&
163 __tprev.width == __tcurr.width &&
164 __tprev.offset == __tcurr.offset &&
165 !(__tprev.offset && __tprev.period != __tcurr.period))
166 return;
167
168 __tprev.options = __tcurr.options;
169 __tprev.width = __tcurr.width;
170 __tprev.offset = __tcurr.offset;
171 __tprev.period = __tcurr.period;
172
173 if (__tcurr.offset && __tcurr.period) {
174 u_int period, f10, mb10;
175 char *scsi;
176
177 period = f10 = mb10 = 0;
178 scsi = "FAST-5";
179
180 if (__tcurr.period <= 9) {
181 scsi = "FAST-80";
182 period = 125;
183 mb10 = 1600;
184 }
185 else {
186 if (__tcurr.period <= 11) {
187 scsi = "FAST-40";
188 period = 250;
189 if (__tcurr.period == 11)
190 period = 303;
191 }
192 else if (__tcurr.period < 25) {
193 scsi = "FAST-20";
194 if (__tcurr.period == 12)
195 period = 500;
196 }
197 else if (__tcurr.period <= 50) {
198 scsi = "FAST-10";
199 }
200 if (!period)
201 period = 40 * __tcurr.period;
202 f10 = 100000 << (__tcurr.width ? 1 : 0);
203 mb10 = (f10 + period/2) / period;
204 }
205 printf_info (
206 "%s:%d: %s %sSCSI %d.%d MB/s %s (%d.%d ns, offset %d)\n",
207 sym_name(np), target, scsi, __tcurr.width? "WIDE " : "",
208 mb10/10, mb10%10,
209 (__tcurr.options & PPR_OPT_DT) ? "DT" : "ST",
210 period/10, period%10, __tcurr.offset);
211 }
212 else
213 printf_info ("%s:%d: %sasynchronous.\n",
214 sym_name(np), target, __tcurr.width? "wide " : "");
215 }
216 #undef __tprev
217 #undef __tcurr
218 #endif /* SYM_OPT_ANNOUNCE_TRANSFER_RATE */
219
220
221 #ifdef SYM_OPT_SNIFF_INQUIRY
222 /*
223 * Update transfer settings according to user settings
224 * and bits sniffed out from INQUIRY response.
225 */
sym_update_trans_settings(hcb_p np,tcb_p tp)226 void sym_update_trans_settings(hcb_p np, tcb_p tp)
227 {
228 bcopy(&tp->tinfo.user, &tp->tinfo.goal, sizeof(tp->tinfo.goal));
229
230 if (tp->inq_version >= 4) {
231 switch(tp->inq_byte56 & INQ56_CLOCKING) {
232 case INQ56_ST_ONLY:
233 tp->tinfo.goal.options = 0;
234 break;
235 case INQ56_DT_ONLY:
236 case INQ56_ST_DT:
237 default:
238 break;
239 }
240 }
241
242 if (!((tp->inq_byte7 & tp->inq_byte7_valid) & INQ7_WIDE16)) {
243 tp->tinfo.goal.width = 0;
244 tp->tinfo.goal.options = 0;
245 }
246
247 if (!((tp->inq_byte7 & tp->inq_byte7_valid) & INQ7_SYNC)) {
248 tp->tinfo.goal.offset = 0;
249 tp->tinfo.goal.options = 0;
250 }
251
252 if (tp->tinfo.goal.options & PPR_OPT_DT) {
253 if (tp->tinfo.goal.offset > np->maxoffs_dt)
254 tp->tinfo.goal.offset = np->maxoffs_dt;
255 }
256 else {
257 if (tp->tinfo.goal.offset > np->maxoffs)
258 tp->tinfo.goal.offset = np->maxoffs;
259 }
260 }
261
262 /*
263 * Snoop target capabilities from INQUIRY response.
264 * We only believe device versions >= SCSI-2 that use
265 * appropriate response data format (2). But it seems
266 * that some CCS devices also support SYNC (?).
267 */
268 int
__sym_sniff_inquiry(hcb_p np,u_char tn,u_char ln,u_char * inq_data,int inq_len)269 __sym_sniff_inquiry(hcb_p np, u_char tn, u_char ln,
270 u_char *inq_data, int inq_len)
271 {
272 tcb_p tp = &np->target[tn];
273 u_char inq_version;
274 u_char inq_byte7;
275 u_char inq_byte56;
276
277 if (!inq_data || inq_len < 2)
278 return -1;
279
280 /*
281 * Check device type and qualifier.
282 */
283 if ((inq_data[0] & 0xe0) == 0x60)
284 return -1;
285
286 /*
287 * Get SPC version.
288 */
289 if (inq_len <= 2)
290 return -1;
291 inq_version = inq_data[2] & 0x7;
292
293 /*
294 * Get SYNC/WIDE16 capabilities.
295 */
296 inq_byte7 = tp->inq_byte7;
297 if (inq_version >= 2 && (inq_data[3] & 0xf) == 2) {
298 if (inq_len > 7)
299 inq_byte7 = inq_data[7];
300 }
301 else if (inq_version == 1 && (inq_data[3] & 0xf) == 1)
302 inq_byte7 = INQ7_SYNC;
303
304 /*
305 * Get Tagged Command Queuing capability.
306 */
307 if (inq_byte7 & INQ7_CMDQ)
308 sym_set_bit(tp->cmdq_map, ln);
309 else
310 sym_clr_bit(tp->cmdq_map, ln);
311 inq_byte7 &= ~INQ7_CMDQ;
312
313 /*
314 * Get CLOCKING capability.
315 */
316 inq_byte56 = tp->inq_byte56;
317 if (inq_version >= 4 && inq_len > 56)
318 inq_byte56 = inq_data[56];
319 #if 0
320 printf("XXXXXX [%d] inq_version=%x inq_byte7=%x inq_byte56=%x XXXXX\n",
321 inq_len, inq_version, inq_byte7, inq_byte56);
322 #endif
323 /*
324 * Trigger a negotiation if needed.
325 */
326 if (tp->inq_version != inq_version ||
327 tp->inq_byte7 != inq_byte7 ||
328 tp->inq_byte56 != inq_byte56) {
329 tp->inq_version = inq_version;
330 tp->inq_byte7 = inq_byte7;
331 tp->inq_byte56 = inq_byte56;
332 return 1;
333 }
334 return 0;
335 }
336 #endif /* SYM_OPT_SNIFF_INQUIRY */
337