← Back to branch summary

~ubuntu-branches/ubuntu/utopic/xen/utopic

« back to all changes in this revision

Viewing changes to xen/drivers/scsi/sym53c8xx_2/sym_misc.c

  • Committer: Bazaar Package Importer
  • Author(s): Bastian Blank
  • Date: 2010-05-06 15:47:38 UTC
  • mto: (1.3.1) (15.1.1 sid) (4.1.1 experimental)
  • mto: This revision was merged to the branch mainline in revision 3.
  • Revision ID: james.westby@ubuntu.com-20100506154738-agoz0rlafrh1fnq7
Tags: upstream-4.0.0
Import upstream version 4.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
xen/drivers/scsi/sym53c8xx_2/sym_misc.c
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
 
 */ 
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
 
 */
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
 
 */
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
 
 */
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
 
 */
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 
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
 
                tp->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 */