isp.c (b05f17a12fc58914e0a5b17f90331627b600432d) isp.c (b760d2eca9862883f6e9094c5e28e65d1e925d9a)
1/*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 2009-2020 Alexander Motin <mav@FreeBSD.org>
5 * Copyright (c) 1997-2009 by Matthew Jacob
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without

--- 50 unchanged lines hidden (view full) ---

59#ifdef __linux__
60#include "isp_linux.h"
61#endif
62#ifdef __svr4__
63#include "isp_solaris.h"
64#endif
65
66/*
1/*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 2009-2020 Alexander Motin <mav@FreeBSD.org>
5 * Copyright (c) 1997-2009 by Matthew Jacob
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without

--- 50 unchanged lines hidden (view full) ---

59#ifdef __linux__
60#include "isp_linux.h"
61#endif
62#ifdef __svr4__
63#include "isp_solaris.h"
64#endif
65
66/*
67 * General defines
68 */
69#define MBOX_DELAY_COUNT 1000000 / 100
70
71/*
72 * Local static data
73 */
74static const char notresp[] = "Unknown IOCB in RESPONSE Queue (type 0x%x) @ idx %d (next %d)";
75static const char bun[] = "bad underrun (count %d, resid %d, status %s)";
76static const char lipd[] = "Chan %d LIP destroyed %d active commands";
77static const char sacq[] = "unable to acquire scratch area";
78
79static const uint8_t alpa_map[] = {

--- 14 unchanged lines hidden (view full) ---

94 0x25, 0x23, 0x1f, 0x1e, 0x1d, 0x1b, 0x18, 0x17,
95 0x10, 0x0f, 0x08, 0x04, 0x02, 0x01, 0x00
96};
97
98/*
99 * Local function prototypes.
100 */
101static int isp_handle_other_response(ispsoftc_t *, int, isphdr_t *, uint32_t *, uint16_t);
67 * Local static data
68 */
69static const char notresp[] = "Unknown IOCB in RESPONSE Queue (type 0x%x) @ idx %d (next %d)";
70static const char bun[] = "bad underrun (count %d, resid %d, status %s)";
71static const char lipd[] = "Chan %d LIP destroyed %d active commands";
72static const char sacq[] = "unable to acquire scratch area";
73
74static const uint8_t alpa_map[] = {

--- 14 unchanged lines hidden (view full) ---

89 0x25, 0x23, 0x1f, 0x1e, 0x1d, 0x1b, 0x18, 0x17,
90 0x10, 0x0f, 0x08, 0x04, 0x02, 0x01, 0x00
91};
92
93/*
94 * Local function prototypes.
95 */
96static int isp_handle_other_response(ispsoftc_t *, int, isphdr_t *, uint32_t *, uint16_t);
102static void isp_parse_status_24xx(ispsoftc_t *, isp24xx_statusreq_t *, XS_T *, uint32_t *);
97static void isp_parse_status_24xx(ispsoftc_t *, isp24xx_statusreq_t *, XS_T *);
103static void isp_clear_portdb(ispsoftc_t *, int);
104static void isp_mark_portdb(ispsoftc_t *, int);
105static int isp_plogx(ispsoftc_t *, int, uint16_t, uint32_t, int);
106static int isp_getpdb(ispsoftc_t *, int, uint16_t, isp_pdb_t *);
107static int isp_gethandles(ispsoftc_t *, int, uint16_t *, int *, int);
108static void isp_dump_chip_portdb(ispsoftc_t *, int);
109static uint64_t isp_get_wwn(ispsoftc_t *, int, int, int);
110static int isp_fclink_test(ispsoftc_t *, int, int);

--- 39 unchanged lines hidden (view full) ---

150
151void
152isp_reset(ispsoftc_t *isp, int do_load_defaults)
153{
154 mbreg_t mbs;
155 char *buf;
156 uint64_t fwt;
157 uint32_t code_org, val;
98static void isp_clear_portdb(ispsoftc_t *, int);
99static void isp_mark_portdb(ispsoftc_t *, int);
100static int isp_plogx(ispsoftc_t *, int, uint16_t, uint32_t, int);
101static int isp_getpdb(ispsoftc_t *, int, uint16_t, isp_pdb_t *);
102static int isp_gethandles(ispsoftc_t *, int, uint16_t *, int *, int);
103static void isp_dump_chip_portdb(ispsoftc_t *, int);
104static uint64_t isp_get_wwn(ispsoftc_t *, int, int, int);
105static int isp_fclink_test(ispsoftc_t *, int, int);

--- 39 unchanged lines hidden (view full) ---

145
146void
147isp_reset(ispsoftc_t *isp, int do_load_defaults)
148{
149 mbreg_t mbs;
150 char *buf;
151 uint64_t fwt;
152 uint32_t code_org, val;
158 int loops, i, dodnld = 1;
153 int loaded_fw, loops, i, dodnld = 1;
159 const char *btype = "????";
160 static const char dcrc[] = "Downloaded RISC Code Checksum Failure";
161
162 isp->isp_state = ISP_NILSTATE;
163 ISP_DISABLE_INTS(isp);
164
165 /*
166 * Put the board into PAUSE mode (so we can read the SXP registers

--- 16 unchanged lines hidden (view full) ---

183 case ISP_HA_FC_2700:
184 btype = "2700";
185 break;
186 default:
187 break;
188 }
189
190 /*
154 const char *btype = "????";
155 static const char dcrc[] = "Downloaded RISC Code Checksum Failure";
156
157 isp->isp_state = ISP_NILSTATE;
158 ISP_DISABLE_INTS(isp);
159
160 /*
161 * Put the board into PAUSE mode (so we can read the SXP registers

--- 16 unchanged lines hidden (view full) ---

178 case ISP_HA_FC_2700:
179 btype = "2700";
180 break;
181 default:
182 break;
183 }
184
185 /*
191 * Hit the chip over the head with hammer,
192 * and give it a chance to recover.
193 */
194
195 /*
196 * Stop DMA and wait for it to stop.
197 */
198 ISP_WRITE(isp, BIU2400_CSR, BIU2400_DMA_STOP|(3 << 4));
186 * Stop DMA and wait for it to stop.
187 */
188 ISP_WRITE(isp, BIU2400_CSR, BIU2400_DMA_STOP|(3 << 4));
199 for (val = loops = 0; loops < 30000; loops++) {
189 for (loops = 0; loops < 100000; loops++) {
200 ISP_DELAY(10);
201 val = ISP_READ(isp, BIU2400_CSR);
202 if ((val & BIU2400_DMA_ACTIVE) == 0) {
203 break;
204 }
205 }
190 ISP_DELAY(10);
191 val = ISP_READ(isp, BIU2400_CSR);
192 if ((val & BIU2400_DMA_ACTIVE) == 0) {
193 break;
194 }
195 }
206 if (val & BIU2400_DMA_ACTIVE) {
196 if (val & BIU2400_DMA_ACTIVE)
207 isp_prt(isp, ISP_LOGERR, "DMA Failed to Stop on Reset");
197 isp_prt(isp, ISP_LOGERR, "DMA Failed to Stop on Reset");
208 return;
209 }
198
210 /*
211 * Hold it in SOFT_RESET and STOP state for 100us.
212 */
213 ISP_WRITE(isp, BIU2400_CSR, BIU2400_SOFT_RESET|BIU2400_DMA_STOP|(3 << 4));
214 ISP_DELAY(100);
215 for (loops = 0; loops < 10000; loops++) {
216 ISP_DELAY(5);
217 val = ISP_READ(isp, OUTMAILBOX0);
199 /*
200 * Hold it in SOFT_RESET and STOP state for 100us.
201 */
202 ISP_WRITE(isp, BIU2400_CSR, BIU2400_SOFT_RESET|BIU2400_DMA_STOP|(3 << 4));
203 ISP_DELAY(100);
204 for (loops = 0; loops < 10000; loops++) {
205 ISP_DELAY(5);
206 val = ISP_READ(isp, OUTMAILBOX0);
218 }
219 for (val = loops = 0; loops < 500000; loops ++) {
220 val = ISP_READ(isp, BIU2400_CSR);
221 if ((val & BIU2400_SOFT_RESET) == 0) {
207 if (val != 0x4)
222 break;
208 break;
223 }
224 }
209 }
225 if (val & BIU2400_SOFT_RESET) {
226 isp_prt(isp, ISP_LOGERR, "Failed to come out of reset");
210 switch (val) {
211 case 0x0:
212 break;
213 case 0x4:
214 isp_prt(isp, ISP_LOGERR, "The ROM code is busy after 50ms.");
227 return;
215 return;
216 case 0xf:
217 isp_prt(isp, ISP_LOGERR, "Board configuration error.");
218 return;
219 default:
220 isp_prt(isp, ISP_LOGERR, "Unknown RISC Status Code 0x%x.", val);
221 return;
228 }
229
230 /*
222 }
223
224 /*
231 * Wait for ISP to be ready to go...
232 */
233 loops = MBOX_DELAY_COUNT;
234 for (;;) {
235 if (ISP_READ(isp, OUTMAILBOX0) == 0)
236 break;
237 ISP_DELAY(100);
238 if (--loops < 0) {
239 ISP_DUMPREGS(isp, "chip reset timed out");
240 return;
241 }
242 }
243
244 /*
245 * Reset RISC Processor
246 */
247 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_RESET);
248 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_RELEASE);
249 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RESET);
250
251 /*
252 * Post-RISC Reset stuff.
253 */
225 * Reset RISC Processor
226 */
227 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_RESET);
228 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_RELEASE);
229 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RESET);
230
231 /*
232 * Post-RISC Reset stuff.
233 */
254 for (val = loops = 0; loops < 5000000; loops++) {
234 for (loops = 0; loops < 10000; loops++) {
255 ISP_DELAY(5);
256 val = ISP_READ(isp, OUTMAILBOX0);
235 ISP_DELAY(5);
236 val = ISP_READ(isp, OUTMAILBOX0);
257 if (val == 0) {
237 if (val != 0x4)
258 break;
238 break;
259 }
260 }
239 }
261 if (val != 0) {
262 isp_prt(isp, ISP_LOGERR, "reset didn't clear");
240 switch (val) {
241 case 0x0:
242 break;
243 case 0x4:
244 isp_prt(isp, ISP_LOGERR, "The ROM code is busy after 50ms.");
263 return;
245 return;
246 case 0xf:
247 isp_prt(isp, ISP_LOGERR, "Board configuration error.");
248 return;
249 default:
250 isp_prt(isp, ISP_LOGERR, "Unknown RISC Status Code 0x%x.", val);
251 return;
264 }
265
266 isp->isp_reqidx = isp->isp_reqodx = 0;
267 isp->isp_resodx = 0;
268 isp->isp_atioodx = 0;
269 ISP_WRITE(isp, BIU2400_REQINP, 0);
270 ISP_WRITE(isp, BIU2400_REQOUTP, 0);
271 ISP_WRITE(isp, BIU2400_RSPINP, 0);
272 ISP_WRITE(isp, BIU2400_RSPOUTP, 0);
273 if (!IS_26XX(isp)) {
274 ISP_WRITE(isp, BIU2400_PRI_REQINP, 0);
275 ISP_WRITE(isp, BIU2400_PRI_REQOUTP, 0);
276 }
277 ISP_WRITE(isp, BIU2400_ATIO_RSPINP, 0);
278 ISP_WRITE(isp, BIU2400_ATIO_RSPOUTP, 0);
279
280 /*
252 }
253
254 isp->isp_reqidx = isp->isp_reqodx = 0;
255 isp->isp_resodx = 0;
256 isp->isp_atioodx = 0;
257 ISP_WRITE(isp, BIU2400_REQINP, 0);
258 ISP_WRITE(isp, BIU2400_REQOUTP, 0);
259 ISP_WRITE(isp, BIU2400_RSPINP, 0);
260 ISP_WRITE(isp, BIU2400_RSPOUTP, 0);
261 if (!IS_26XX(isp)) {
262 ISP_WRITE(isp, BIU2400_PRI_REQINP, 0);
263 ISP_WRITE(isp, BIU2400_PRI_REQOUTP, 0);
264 }
265 ISP_WRITE(isp, BIU2400_ATIO_RSPINP, 0);
266 ISP_WRITE(isp, BIU2400_ATIO_RSPOUTP, 0);
267
268 /*
281 * Wait for everything to finish firing up.
282 */
283 loops = MBOX_DELAY_COUNT;
284 while (ISP_READ(isp, OUTMAILBOX0) == MBOX_BUSY) {
285 ISP_DELAY(100);
286 if (--loops < 0) {
287 isp_prt(isp, ISP_LOGERR, "MBOX_BUSY never cleared on reset");
288 return;
289 }
290 }
291
292 /*
293 * Up until this point we've done everything by just reading or
294 * setting registers. From this point on we rely on at least *some*
295 * kind of firmware running in the card.
296 */
297
298 /*
299 * Do some sanity checking by running a NOP command.
300 * If it succeeds, the ROM firmware is now running.

--- 56 unchanged lines hidden (view full) ---

357 */
358 if (ISP_MBOXDMASETUP(isp) != 0) {
359 isp_prt(isp, ISP_LOGERR, "Cannot setup DMA");
360 return;
361 }
362 }
363
364 code_org = ISP_CODE_ORG_2400;
269 * Up until this point we've done everything by just reading or
270 * setting registers. From this point on we rely on at least *some*
271 * kind of firmware running in the card.
272 */
273
274 /*
275 * Do some sanity checking by running a NOP command.
276 * If it succeeds, the ROM firmware is now running.

--- 56 unchanged lines hidden (view full) ---

333 */
334 if (ISP_MBOXDMASETUP(isp) != 0) {
335 isp_prt(isp, ISP_LOGERR, "Cannot setup DMA");
336 return;
337 }
338 }
339
340 code_org = ISP_CODE_ORG_2400;
365 isp->isp_loaded_fw = 0;
341 loaded_fw = 0;
366 if (dodnld) {
367 const uint32_t *ptr = isp->isp_mdvec->dv_ispfw;
368 uint32_t la, wi, wl;
369
370 /*
371 * Keep loading until we run out of f/w.
372 */
373 code_org = ptr[2]; /* 1st load address is our start addr */

--- 32 unchanged lines hidden (view full) ---

406 wl -= nw;
407 }
408
409 if (ptr[1] == 0) {
410 break;
411 }
412 ptr += ptr[3];
413 }
342 if (dodnld) {
343 const uint32_t *ptr = isp->isp_mdvec->dv_ispfw;
344 uint32_t la, wi, wl;
345
346 /*
347 * Keep loading until we run out of f/w.
348 */
349 code_org = ptr[2]; /* 1st load address is our start addr */

--- 32 unchanged lines hidden (view full) ---

382 wl -= nw;
383 }
384
385 if (ptr[1] == 0) {
386 break;
387 }
388 ptr += ptr[3];
389 }
414 isp->isp_loaded_fw = 1;
390 loaded_fw = 1;
415 } else if (IS_26XX(isp)) {
416 isp_prt(isp, ISP_LOGDEBUG1, "loading firmware from flash");
417 MBSINIT(&mbs, MBOX_LOAD_FLASH_FIRMWARE, MBLOGALL, 5000000);
418 mbs.ibitm = 0x01;
419 mbs.obitm = 0x07;
420 isp_mboxcmd(isp, &mbs);
421 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
422 isp_prt(isp, ISP_LOGERR, "Flash F/W load failed");
423 return;
424 }
425 } else {
426 isp_prt(isp, ISP_LOGDEBUG2, "skipping f/w download");
427 }
428
429 /*
430 * If we loaded firmware, verify its checksum
431 */
391 } else if (IS_26XX(isp)) {
392 isp_prt(isp, ISP_LOGDEBUG1, "loading firmware from flash");
393 MBSINIT(&mbs, MBOX_LOAD_FLASH_FIRMWARE, MBLOGALL, 5000000);
394 mbs.ibitm = 0x01;
395 mbs.obitm = 0x07;
396 isp_mboxcmd(isp, &mbs);
397 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
398 isp_prt(isp, ISP_LOGERR, "Flash F/W load failed");
399 return;
400 }
401 } else {
402 isp_prt(isp, ISP_LOGDEBUG2, "skipping f/w download");
403 }
404
405 /*
406 * If we loaded firmware, verify its checksum
407 */
432 if (isp->isp_loaded_fw) {
408 if (loaded_fw) {
433 MBSINIT(&mbs, MBOX_VERIFY_CHECKSUM, MBLOGNONE, 0);
434 mbs.param[1] = code_org >> 16;
435 mbs.param[2] = code_org;
436 isp_mboxcmd(isp, &mbs);
437 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
438 isp_prt(isp, ISP_LOGERR, dcrc);
439 return;
440 }
441 }
442
443 /*
444 * Now start it rolling.
445 *
446 * If we didn't actually download f/w,
447 * we still need to (re)start it.
448 */
449 MBSINIT(&mbs, MBOX_EXEC_FIRMWARE, MBLOGALL, 5000000);
409 MBSINIT(&mbs, MBOX_VERIFY_CHECKSUM, MBLOGNONE, 0);
410 mbs.param[1] = code_org >> 16;
411 mbs.param[2] = code_org;
412 isp_mboxcmd(isp, &mbs);
413 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
414 isp_prt(isp, ISP_LOGERR, dcrc);
415 return;
416 }
417 }
418
419 /*
420 * Now start it rolling.
421 *
422 * If we didn't actually download f/w,
423 * we still need to (re)start it.
424 */
425 MBSINIT(&mbs, MBOX_EXEC_FIRMWARE, MBLOGALL, 5000000);
450 if (IS_26XX(isp)) {
451 mbs.param[1] = code_org >> 16;
452 mbs.param[2] = code_org;
453 } else {
454 mbs.param[1] = code_org >> 16;
455 mbs.param[2] = code_org;
456 if (isp->isp_loaded_fw)
457 mbs.param[3] = 0;
458 else
459 mbs.param[3] = 1;
460 }
426 mbs.param[1] = code_org >> 16;
427 mbs.param[2] = code_org;
428 if (!IS_26XX(isp))
429 mbs.param[3] = loaded_fw ? 0 : 1;
461 isp_mboxcmd(isp, &mbs);
462 if (mbs.param[0] != MBOX_COMMAND_COMPLETE)
463 return;
464
465 /*
466 * Ask the chip for the current firmware version.
467 * This should prove that the new firmware is working.
468 */

--- 2753 unchanged lines hidden (view full) ---

3222void
3223isp_intr_respq(ispsoftc_t *isp)
3224{
3225 XS_T *xs, *cont_xs;
3226 uint8_t qe[QENTRY_LEN];
3227 isp24xx_statusreq_t *sp = (isp24xx_statusreq_t *)qe;
3228 ispstatus_cont_t *scp = (ispstatus_cont_t *)qe;
3229 isphdr_t *hp;
430 isp_mboxcmd(isp, &mbs);
431 if (mbs.param[0] != MBOX_COMMAND_COMPLETE)
432 return;
433
434 /*
435 * Ask the chip for the current firmware version.
436 * This should prove that the new firmware is working.
437 */

--- 2753 unchanged lines hidden (view full) ---

3191void
3192isp_intr_respq(ispsoftc_t *isp)
3193{
3194 XS_T *xs, *cont_xs;
3195 uint8_t qe[QENTRY_LEN];
3196 isp24xx_statusreq_t *sp = (isp24xx_statusreq_t *)qe;
3197 ispstatus_cont_t *scp = (ispstatus_cont_t *)qe;
3198 isphdr_t *hp;
3230 uint8_t *resp, *snsp;
3231 int buddaboom, completion_status, cont = 0, etype, i;
3232 int req_status_flags, req_state_flags, scsi_status;
3233 uint32_t iptr, cptr, optr, rlen, slen, sptr, totslen, resid;
3199 uint8_t *resp, *snsp, etype;
3200 uint16_t scsi_status;
3201 uint32_t iptr, cont = 0, cptr, optr, rlen, slen, sptr, totslen;
3234
3235 /*
3236 * We can't be getting this now.
3237 */
3238 if (isp->isp_state != ISP_RUNSTATE) {
3239 isp_prt(isp, ISP_LOGINFO, "respq interrupt when not ready");
3240 return;
3241 }

--- 7 unchanged lines hidden (view full) ---

3249
3250 /*
3251 * Synchronize our view of this response queue entry.
3252 */
3253 MEMORYBARRIER(isp, SYNC_RESULT, cptr, QENTRY_LEN, -1);
3254 if (isp->isp_dblev & ISP_LOGDEBUG1)
3255 isp_print_qentry(isp, "Response Queue Entry", cptr, hp);
3256 isp_get_hdr(isp, hp, &sp->req_header);
3202
3203 /*
3204 * We can't be getting this now.
3205 */
3206 if (isp->isp_state != ISP_RUNSTATE) {
3207 isp_prt(isp, ISP_LOGINFO, "respq interrupt when not ready");
3208 return;
3209 }

--- 7 unchanged lines hidden (view full) ---

3217
3218 /*
3219 * Synchronize our view of this response queue entry.
3220 */
3221 MEMORYBARRIER(isp, SYNC_RESULT, cptr, QENTRY_LEN, -1);
3222 if (isp->isp_dblev & ISP_LOGDEBUG1)
3223 isp_print_qentry(isp, "Response Queue Entry", cptr, hp);
3224 isp_get_hdr(isp, hp, &sp->req_header);
3225
3226 /*
3227 * Log IOCBs rejected by the firmware. We can't really do
3228 * much more about them, since it just should not happen.
3229 */
3230 if (sp->req_header.rqs_flags & RQSFLAG_BADTYPE) {
3231 isp_print_qentry(isp, "invalid entry type", cptr, hp);
3232 continue;
3233 }
3234 if (sp->req_header.rqs_flags & RQSFLAG_BADPARAM) {
3235 isp_print_qentry(isp, "invalid entry parameter", cptr, hp);
3236 continue;
3237 }
3238 if (sp->req_header.rqs_flags & RQSFLAG_BADCOUNT) {
3239 isp_print_qentry(isp, "invalid entry count", cptr, hp);
3240 continue;
3241 }
3242 if (sp->req_header.rqs_flags & RQSFLAG_BADORDER) {
3243 isp_print_qentry(isp, "invalid entry order", cptr, hp);
3244 continue;
3245 }
3246
3257 etype = sp->req_header.rqs_entry_type;
3258
3259 /* We expected Status Continuation, but got different IOCB. */
3260 if (cont > 0 && etype != RQSTYPE_STATUS_CONT) {
3261 cont = 0;
3262 isp_done(cont_xs);
3263 }
3264
3265 if (etype == RQSTYPE_RESPONSE) {
3266 isp_get_24xx_response(isp, (isp24xx_statusreq_t *)hp, sp);
3247 etype = sp->req_header.rqs_entry_type;
3248
3249 /* We expected Status Continuation, but got different IOCB. */
3250 if (cont > 0 && etype != RQSTYPE_STATUS_CONT) {
3251 cont = 0;
3252 isp_done(cont_xs);
3253 }
3254
3255 if (etype == RQSTYPE_RESPONSE) {
3256 isp_get_24xx_response(isp, (isp24xx_statusreq_t *)hp, sp);
3267 scsi_status = sp->req_scsi_status;
3268 completion_status = sp->req_completion_status;
3269 req_status_flags = 0;
3270 if ((scsi_status & 0xff) != 0)
3271 req_state_flags = RQSF_GOT_STATUS;
3272 else
3273 req_state_flags = 0;
3274 resid = sp->req_resid;
3257 /* FALLTHROUGH */
3275 } else if (etype == RQSTYPE_STATUS_CONT) {
3276 isp_get_cont_response(isp, (ispstatus_cont_t *)hp, scp);
3277 if (cont > 0) {
3258 } else if (etype == RQSTYPE_STATUS_CONT) {
3259 isp_get_cont_response(isp, (ispstatus_cont_t *)hp, scp);
3260 if (cont > 0) {
3278 i = min(cont, sizeof(scp->req_sense_data));
3279 XS_SENSE_APPEND(cont_xs, scp->req_sense_data, i);
3280 cont -= i;
3261 slen = min(cont, sizeof(scp->req_sense_data));
3262 XS_SENSE_APPEND(cont_xs, scp->req_sense_data, slen);
3263 cont -= slen;
3281 if (cont == 0) {
3282 isp_done(cont_xs);
3283 } else {
3284 isp_prt(isp, ISP_LOGDEBUG0|ISP_LOG_CWARN,
3285 "Expecting Status Continuations for %u bytes",
3286 cont);
3287 }
3288 } else {

--- 14 unchanged lines hidden (view full) ---

3303 continue;
3304 } else {
3305 /* We don't know what was this -- log and skip. */
3306 isp_prt(isp, ISP_LOGERR, notresp, etype, cptr, optr);
3307 ISP_MEMZERO(hp, QENTRY_LEN); /* PERF */
3308 continue;
3309 }
3310
3264 if (cont == 0) {
3265 isp_done(cont_xs);
3266 } else {
3267 isp_prt(isp, ISP_LOGDEBUG0|ISP_LOG_CWARN,
3268 "Expecting Status Continuations for %u bytes",
3269 cont);
3270 }
3271 } else {

--- 14 unchanged lines hidden (view full) ---

3286 continue;
3287 } else {
3288 /* We don't know what was this -- log and skip. */
3289 isp_prt(isp, ISP_LOGERR, notresp, etype, cptr, optr);
3290 ISP_MEMZERO(hp, QENTRY_LEN); /* PERF */
3291 continue;
3292 }
3293
3311 buddaboom = 0;
3312 if (sp->req_header.rqs_flags & RQSFLAG_MASK) {
3313 if (sp->req_header.rqs_flags & RQSFLAG_BADTYPE) {
3314 isp_print_qentry(isp, "invalid entry type",
3315 cptr, hp);
3316 buddaboom++;
3317 }
3318 if (sp->req_header.rqs_flags & RQSFLAG_BADPARAM) {
3319 isp_print_qentry(isp, "invalid entry parameter",
3320 cptr, hp);
3321 buddaboom++;
3322 }
3323 if (sp->req_header.rqs_flags & RQSFLAG_BADCOUNT) {
3324 isp_print_qentry(isp, "invalid entry count",
3325 cptr, hp);
3326 buddaboom++;
3327 }
3328 if (sp->req_header.rqs_flags & RQSFLAG_BADORDER) {
3329 isp_print_qentry(isp, "invalid entry order",
3330 cptr, hp);
3331 continue;
3332 }
3333 }
3334
3335 xs = isp_find_xs(isp, sp->req_handle);
3336 if (xs == NULL) {
3294 xs = isp_find_xs(isp, sp->req_handle);
3295 if (xs == NULL) {
3337 uint8_t ts = completion_status & 0xff;
3338 /*
3339 * Only whine if this isn't the expected fallout of
3340 * aborting the command or resetting the target.
3341 */
3296 /*
3297 * Only whine if this isn't the expected fallout of
3298 * aborting the command or resetting the target.
3299 */
3342 if (etype != RQSTYPE_RESPONSE) {
3343 isp_prt(isp, ISP_LOGERR, "cannot find handle 0x%x (type 0x%x)", sp->req_handle, etype);
3344 } else if (ts != RQCS_ABORTED && ts != RQCS_RESET_OCCURRED) {
3345 isp_prt(isp, ISP_LOGERR, "cannot find handle 0x%x (status 0x%x)", sp->req_handle, ts);
3346 }
3300 if (sp->req_completion_status != RQCS_ABORTED &&
3301 sp->req_completion_status != RQCS_RESET_OCCURRED)
3302 isp_prt(isp, ISP_LOGERR, "cannot find handle 0x%x (status 0x%x)",
3303 sp->req_handle, sp->req_completion_status);
3347 ISP_MEMZERO(hp, QENTRY_LEN); /* PERF */
3348 continue;
3349 }
3304 ISP_MEMZERO(hp, QENTRY_LEN); /* PERF */
3305 continue;
3306 }
3350 if (req_status_flags & RQSTF_BUS_RESET) {
3351 isp_prt(isp, ISP_LOG_WARN1, "%d.%d.%jx bus was reset",
3352 XS_CHANNEL(xs), XS_TGT(xs), (uintmax_t)XS_LUN(xs));
3353 XS_SETERR(xs, HBA_BUSRESET);
3354 ISP_SET_SENDMARKER(isp, XS_CHANNEL(xs), 1);
3355 }
3356 if (buddaboom) {
3357 isp_prt(isp, ISP_LOG_WARN1, "%d.%d.%jx buddaboom",
3358 XS_CHANNEL(xs), XS_TGT(xs), (uintmax_t)XS_LUN(xs));
3359 XS_SETERR(xs, HBA_BOTCH);
3360 }
3361
3307
3362 resp = snsp = NULL;
3308 resp = snsp = sp->req_rsp_sense;
3363 rlen = slen = totslen = 0;
3309 rlen = slen = totslen = 0;
3364 if ((scsi_status & (RQCS_RV|RQCS_SV)) != 0) {
3365 resp = sp->req_rsp_sense;
3310 scsi_status = sp->req_scsi_status;
3311 if (scsi_status & RQCS_RV) {
3366 rlen = sp->req_response_len;
3312 rlen = sp->req_response_len;
3313 snsp += rlen;
3367 }
3314 }
3368 if ((scsi_status & RQCS_SV) != 0) {
3369 /*
3370 * Fibre Channel F/W doesn't say we got status
3371 * if there's Sense Data instead. I guess they
3372 * think it goes w/o saying.
3373 */
3374 req_state_flags |= RQSF_GOT_STATUS|RQSF_GOT_SENSE;
3375 snsp = sp->req_rsp_sense + rlen;
3315 if (scsi_status & RQCS_SV) {
3376 totslen = sp->req_sense_len;
3316 totslen = sp->req_sense_len;
3377 slen = sizeof(sp->req_rsp_sense) - rlen;
3317 slen = MIN(totslen, sizeof(sp->req_rsp_sense) - rlen);
3378 }
3318 }
3379 if (slen > totslen)
3380 slen = totslen;
3381 if (req_state_flags & RQSF_GOT_STATUS)
3382 *XS_STSP(xs) = scsi_status & 0xff;
3319 *XS_STSP(xs) = scsi_status & 0xff;
3320 if (scsi_status & RQCS_RESID)
3321 XS_SET_RESID(xs, sp->req_fcp_residual);
3322 else
3323 XS_SET_RESID(xs, 0);
3383
3384 if (rlen >= 4 && resp[FCP_RSPNS_CODE_OFFSET] != 0) {
3385 const char *ptr;
3386 char lb[64];
3387 const char *rnames[10] = {
3388 "Task Management function complete",
3389 "FCP_DATA length different than FCP_BURST_LEN",
3390 "FCP_CMND fields invalid",
3391 "FCP_DATA parameter mismatch with FCP_DATA_RO",
3392 "Task Management function rejected",
3393 "Task Management function failed",
3394 NULL,
3395 NULL,
3396 "Task Management function succeeded",
3397 "Task Management function incorrect logical unit number",
3398 };
3399 uint8_t code = resp[FCP_RSPNS_CODE_OFFSET];
3324
3325 if (rlen >= 4 && resp[FCP_RSPNS_CODE_OFFSET] != 0) {
3326 const char *ptr;
3327 char lb[64];
3328 const char *rnames[10] = {
3329 "Task Management function complete",
3330 "FCP_DATA length different than FCP_BURST_LEN",
3331 "FCP_CMND fields invalid",
3332 "FCP_DATA parameter mismatch with FCP_DATA_RO",
3333 "Task Management function rejected",
3334 "Task Management function failed",
3335 NULL,
3336 NULL,
3337 "Task Management function succeeded",
3338 "Task Management function incorrect logical unit number",
3339 };
3340 uint8_t code = resp[FCP_RSPNS_CODE_OFFSET];
3400 if (code >= 10 || rnames[code] == NULL) {
3341 if (code >= nitems(rnames) || rnames[code] == NULL) {
3401 ISP_SNPRINTF(lb, sizeof(lb),
3402 "Unknown FCP Response Code 0x%x", code);
3403 ptr = lb;
3404 } else {
3405 ptr = rnames[code];
3406 }
3407 isp_xs_prt(isp, xs, ISP_LOGWARN,
3408 "FCP RESPONSE, LENGTH %u: %s CDB0=0x%02x",
3409 rlen, ptr, XS_CDBP(xs)[0] & 0xff);
3342 ISP_SNPRINTF(lb, sizeof(lb),
3343 "Unknown FCP Response Code 0x%x", code);
3344 ptr = lb;
3345 } else {
3346 ptr = rnames[code];
3347 }
3348 isp_xs_prt(isp, xs, ISP_LOGWARN,
3349 "FCP RESPONSE, LENGTH %u: %s CDB0=0x%02x",
3350 rlen, ptr, XS_CDBP(xs)[0] & 0xff);
3410 if (code != 0 && code != 8)
3351 if (code != FCP_RSPNS_TMF_DONE &&
3352 code != FCP_RSPNS_TMF_SUCCEEDED)
3411 XS_SETERR(xs, HBA_BOTCH);
3412 }
3353 XS_SETERR(xs, HBA_BOTCH);
3354 }
3413 isp_parse_status_24xx(isp, sp, xs, &resid);
3414 if ((XS_NOERR(xs) || XS_ERR(xs) == HBA_NOERROR) &&
3415 (*XS_STSP(xs) == SCSI_BUSY))
3416 XS_SETERR(xs, HBA_TGTBSY);
3417 if (req_status_flags & RQSF_XFER_COMPLETE) {
3418 XS_SET_RESID(xs, 0);
3419 } else if (scsi_status & RQCS_RESID) {
3420 XS_SET_RESID(xs, resid);
3421 } else {
3422 XS_SET_RESID(xs, 0);
3423 }
3355 isp_parse_status_24xx(isp, sp, xs);
3424 if (slen > 0) {
3425 XS_SAVE_SENSE(xs, snsp, slen);
3426 if (totslen > slen) {
3427 cont = totslen - slen;
3428 cont_xs = xs;
3429 isp_prt(isp, ISP_LOGDEBUG0|ISP_LOG_CWARN,
3430 "Expecting Status Continuations for %u bytes",
3431 cont);
3432 }
3433 }
3356 if (slen > 0) {
3357 XS_SAVE_SENSE(xs, snsp, slen);
3358 if (totslen > slen) {
3359 cont = totslen - slen;
3360 cont_xs = xs;
3361 isp_prt(isp, ISP_LOGDEBUG0|ISP_LOG_CWARN,
3362 "Expecting Status Continuations for %u bytes",
3363 cont);
3364 }
3365 }
3434 isp_prt(isp, ISP_LOGDEBUG2, "asked for %lu got raw resid %lu settled for %lu",
3435 (u_long)XS_XFRLEN(xs), (u_long)resid, (u_long)XS_GET_RESID(xs));
3436
3437 ISP_DMAFREE(isp, xs);
3438 isp_destroy_handle(isp, sp->req_handle);
3366
3367 ISP_DMAFREE(isp, xs);
3368 isp_destroy_handle(isp, sp->req_handle);
3439
3440 ISP_MEMZERO(hp, QENTRY_LEN); /* PERF */
3441
3442 /* Complete command if we expect no Status Continuations. */
3443 if (cont == 0)
3444 isp_done(xs);
3445 }
3446
3447 /* We haven't received all Status Continuations, but that is it. */

--- 355 unchanged lines hidden (view full) ---

3803#endif
3804 /* FALLTHROUGH */
3805 default:
3806 return (0);
3807 }
3808}
3809
3810static void
3369 ISP_MEMZERO(hp, QENTRY_LEN); /* PERF */
3370
3371 /* Complete command if we expect no Status Continuations. */
3372 if (cont == 0)
3373 isp_done(xs);
3374 }
3375
3376 /* We haven't received all Status Continuations, but that is it. */

--- 355 unchanged lines hidden (view full) ---

3732#endif
3733 /* FALLTHROUGH */
3734 default:
3735 return (0);
3736 }
3737}
3738
3739static void
3811isp_parse_status_24xx(ispsoftc_t *isp, isp24xx_statusreq_t *sp, XS_T *xs, uint32_t *rp)
3740isp_parse_status_24xx(ispsoftc_t *isp, isp24xx_statusreq_t *sp, XS_T *xs)
3812{
3813 int ru_marked, sv_marked;
3814 int chan = XS_CHANNEL(xs);
3815
3816 switch (sp->req_completion_status) {
3817 case RQCS_COMPLETE:
3741{
3742 int ru_marked, sv_marked;
3743 int chan = XS_CHANNEL(xs);
3744
3745 switch (sp->req_completion_status) {
3746 case RQCS_COMPLETE:
3818 if (XS_NOERR(xs)) {
3819 XS_SETERR(xs, HBA_NOERROR);
3820 }
3821 return;
3822
3823 case RQCS_DMA_ERROR:
3824 isp_xs_prt(isp, xs, ISP_LOGERR, "DMA error");
3747 return;
3748
3749 case RQCS_DMA_ERROR:
3750 isp_xs_prt(isp, xs, ISP_LOGERR, "DMA error");
3751 if (XS_NOERR(xs))
3752 XS_SETERR(xs, HBA_BOTCH);
3825 break;
3826
3827 case RQCS_TRANSPORT_ERROR:
3828 isp_xs_prt(isp, xs, ISP_LOGERR, "Transport Error");
3753 break;
3754
3755 case RQCS_TRANSPORT_ERROR:
3756 isp_xs_prt(isp, xs, ISP_LOGERR, "Transport Error");
3757 if (XS_NOERR(xs))
3758 XS_SETERR(xs, HBA_BOTCH);
3829 break;
3830
3831 case RQCS_RESET_OCCURRED:
3832 isp_xs_prt(isp, xs, ISP_LOGWARN, "reset destroyed command");
3833 FCPARAM(isp, chan)->sendmarker = 1;
3759 break;
3760
3761 case RQCS_RESET_OCCURRED:
3762 isp_xs_prt(isp, xs, ISP_LOGWARN, "reset destroyed command");
3763 FCPARAM(isp, chan)->sendmarker = 1;
3834 if (XS_NOERR(xs)) {
3764 if (XS_NOERR(xs))
3835 XS_SETERR(xs, HBA_BUSRESET);
3765 XS_SETERR(xs, HBA_BUSRESET);
3836 }
3837 return;
3838
3839 case RQCS_ABORTED:
3840 isp_xs_prt(isp, xs, ISP_LOGERR, "Command Aborted");
3841 FCPARAM(isp, chan)->sendmarker = 1;
3766 return;
3767
3768 case RQCS_ABORTED:
3769 isp_xs_prt(isp, xs, ISP_LOGERR, "Command Aborted");
3770 FCPARAM(isp, chan)->sendmarker = 1;
3842 if (XS_NOERR(xs)) {
3771 if (XS_NOERR(xs))
3843 XS_SETERR(xs, HBA_ABORTED);
3772 XS_SETERR(xs, HBA_ABORTED);
3844 }
3845 return;
3846
3847 case RQCS_TIMEOUT:
3848 isp_xs_prt(isp, xs, ISP_LOGWARN, "Command Timed Out");
3773 return;
3774
3775 case RQCS_TIMEOUT:
3776 isp_xs_prt(isp, xs, ISP_LOGWARN, "Command Timed Out");
3849 if (XS_NOERR(xs)) {
3777 if (XS_NOERR(xs))
3850 XS_SETERR(xs, HBA_CMDTIMEOUT);
3778 XS_SETERR(xs, HBA_CMDTIMEOUT);
3851 }
3852 return;
3853
3854 case RQCS_DATA_OVERRUN:
3855 XS_SET_RESID(xs, sp->req_resid);
3856 isp_xs_prt(isp, xs, ISP_LOGERR, "Data Overrun");
3779 return;
3780
3781 case RQCS_DATA_OVERRUN:
3782 XS_SET_RESID(xs, sp->req_resid);
3783 isp_xs_prt(isp, xs, ISP_LOGERR, "Data Overrun");
3857 if (XS_NOERR(xs)) {
3784 if (XS_NOERR(xs))
3858 XS_SETERR(xs, HBA_DATAOVR);
3785 XS_SETERR(xs, HBA_DATAOVR);
3859 }
3860 return;
3861
3786 return;
3787
3862 case RQCS_24XX_DRE: /* data reassembly error */
3788 case RQCS_DRE: /* data reassembly error */
3863 isp_prt(isp, ISP_LOGERR, "Chan %d data reassembly error for target %d", chan, XS_TGT(xs));
3789 isp_prt(isp, ISP_LOGERR, "Chan %d data reassembly error for target %d", chan, XS_TGT(xs));
3864 if (XS_NOERR(xs)) {
3865 XS_SETERR(xs, HBA_ABORTED);
3866 }
3867 *rp = XS_XFRLEN(xs);
3790 if (XS_NOERR(xs))
3791 XS_SETERR(xs, HBA_BOTCH);
3868 return;
3869
3792 return;
3793
3870 case RQCS_24XX_TABORT: /* aborted by target */
3794 case RQCS_TABORT: /* aborted by target */
3871 isp_prt(isp, ISP_LOGERR, "Chan %d target %d sent ABTS", chan, XS_TGT(xs));
3795 isp_prt(isp, ISP_LOGERR, "Chan %d target %d sent ABTS", chan, XS_TGT(xs));
3872 if (XS_NOERR(xs)) {
3796 if (XS_NOERR(xs))
3873 XS_SETERR(xs, HBA_ABORTED);
3797 XS_SETERR(xs, HBA_ABORTED);
3874 }
3875 return;
3876
3877 case RQCS_DATA_UNDERRUN:
3878 ru_marked = (sp->req_scsi_status & RQCS_RU) != 0;
3879 /*
3880 * We can get an underrun w/o things being marked
3881 * if we got a non-zero status.
3882 */
3883 sv_marked = (sp->req_scsi_status & (RQCS_SV|RQCS_RV)) != 0;
3884 if ((ru_marked == 0 && sv_marked == 0) ||
3885 (sp->req_resid > XS_XFRLEN(xs))) {
3886 isp_xs_prt(isp, xs, ISP_LOGWARN, bun, XS_XFRLEN(xs), sp->req_resid, (ru_marked)? "marked" : "not marked");
3798 return;
3799
3800 case RQCS_DATA_UNDERRUN:
3801 ru_marked = (sp->req_scsi_status & RQCS_RU) != 0;
3802 /*
3803 * We can get an underrun w/o things being marked
3804 * if we got a non-zero status.
3805 */
3806 sv_marked = (sp->req_scsi_status & (RQCS_SV|RQCS_RV)) != 0;
3807 if ((ru_marked == 0 && sv_marked == 0) ||
3808 (sp->req_resid > XS_XFRLEN(xs))) {
3809 isp_xs_prt(isp, xs, ISP_LOGWARN, bun, XS_XFRLEN(xs), sp->req_resid, (ru_marked)? "marked" : "not marked");
3887 if (XS_NOERR(xs)) {
3810 if (XS_NOERR(xs))
3888 XS_SETERR(xs, HBA_BOTCH);
3811 XS_SETERR(xs, HBA_BOTCH);
3889 }
3890 return;
3891 }
3892 XS_SET_RESID(xs, sp->req_resid);
3893 isp_xs_prt(isp, xs, ISP_LOG_WARN1, "Data Underrun (%d) for command 0x%x", sp->req_resid, XS_CDBP(xs)[0] & 0xff);
3812 return;
3813 }
3814 XS_SET_RESID(xs, sp->req_resid);
3815 isp_xs_prt(isp, xs, ISP_LOG_WARN1, "Data Underrun (%d) for command 0x%x", sp->req_resid, XS_CDBP(xs)[0] & 0xff);
3894 if (XS_NOERR(xs)) {
3895 XS_SETERR(xs, HBA_NOERROR);
3896 }
3897 return;
3898
3899 case RQCS_PORT_UNAVAILABLE:
3900 /*
3901 * No such port on the loop. Moral equivalent of SELTIMEO
3902 */
3903 case RQCS_PORT_LOGGED_OUT:
3904 {

--- 29 unchanged lines hidden (view full) ---

3934 case RQCS_PORT_CHANGED:
3935 isp_prt(isp, ISP_LOGWARN, "port changed for target %d chan %d", XS_TGT(xs), chan);
3936 if (XS_NOERR(xs)) {
3937 *XS_STSP(xs) = SCSI_BUSY;
3938 XS_SETERR(xs, HBA_TGTBSY);
3939 }
3940 return;
3941
3816 return;
3817
3818 case RQCS_PORT_UNAVAILABLE:
3819 /*
3820 * No such port on the loop. Moral equivalent of SELTIMEO
3821 */
3822 case RQCS_PORT_LOGGED_OUT:
3823 {

--- 29 unchanged lines hidden (view full) ---

3853 case RQCS_PORT_CHANGED:
3854 isp_prt(isp, ISP_LOGWARN, "port changed for target %d chan %d", XS_TGT(xs), chan);
3855 if (XS_NOERR(xs)) {
3856 *XS_STSP(xs) = SCSI_BUSY;
3857 XS_SETERR(xs, HBA_TGTBSY);
3858 }
3859 return;
3860
3942 case RQCS_24XX_ENOMEM: /* f/w resource unavailable */
3861 case RQCS_ENOMEM: /* f/w resource unavailable */
3943 isp_prt(isp, ISP_LOGWARN, "f/w resource unavailable for target %d chan %d", XS_TGT(xs), chan);
3944 if (XS_NOERR(xs)) {
3945 *XS_STSP(xs) = SCSI_BUSY;
3946 XS_SETERR(xs, HBA_TGTBSY);
3947 }
3948 return;
3949
3862 isp_prt(isp, ISP_LOGWARN, "f/w resource unavailable for target %d chan %d", XS_TGT(xs), chan);
3863 if (XS_NOERR(xs)) {
3864 *XS_STSP(xs) = SCSI_BUSY;
3865 XS_SETERR(xs, HBA_TGTBSY);
3866 }
3867 return;
3868
3950 case RQCS_24XX_TMO: /* task management overrun */
3869 case RQCS_TMO: /* task management overrun */
3951 isp_prt(isp, ISP_LOGWARN, "command for target %d overlapped task management for chan %d", XS_TGT(xs), chan);
3952 if (XS_NOERR(xs)) {
3953 *XS_STSP(xs) = SCSI_BUSY;
3954 XS_SETERR(xs, HBA_TGTBSY);
3955 }
3956 return;
3957
3958 default:
3959 isp_prt(isp, ISP_LOGERR, "Unknown Completion Status 0x%x on chan %d", sp->req_completion_status, chan);
3960 break;
3961 }
3870 isp_prt(isp, ISP_LOGWARN, "command for target %d overlapped task management for chan %d", XS_TGT(xs), chan);
3871 if (XS_NOERR(xs)) {
3872 *XS_STSP(xs) = SCSI_BUSY;
3873 XS_SETERR(xs, HBA_TGTBSY);
3874 }
3875 return;
3876
3877 default:
3878 isp_prt(isp, ISP_LOGERR, "Unknown Completion Status 0x%x on chan %d", sp->req_completion_status, chan);
3879 break;
3880 }
3962 if (XS_NOERR(xs)) {
3881 if (XS_NOERR(xs))
3963 XS_SETERR(xs, HBA_BOTCH);
3882 XS_SETERR(xs, HBA_BOTCH);
3964 }
3965}
3966
3967#define ISP_FC_IBITS(op) ((mbpfc[((op)<<3) + 0] << 24) | (mbpfc[((op)<<3) + 1] << 16) | (mbpfc[((op)<<3) + 2] << 8) | (mbpfc[((op)<<3) + 3]))
3968#define ISP_FC_OBITS(op) ((mbpfc[((op)<<3) + 4] << 24) | (mbpfc[((op)<<3) + 5] << 16) | (mbpfc[((op)<<3) + 6] << 8) | (mbpfc[((op)<<3) + 7]))
3969
3970#define ISP_FC_OPMAP(in0, out0) 0, 0, 0, in0, 0, 0, 0, out0
3971#define ISP_FC_OPMAP_HALF(in1, in0, out1, out0) 0, 0, in1, in0, 0, 0, out1, out0
3972#define ISP_FC_OPMAP_FULL(in3, in2, in1, in0, out3, out2, out1, out0) in3, in2, in1, in0, out3, out2, out1, out0

--- 311 unchanged lines hidden (view full) ---

4284 if (ibits & (1 << box)) {
4285 isp_prt(isp, ISP_LOGDEBUG3, "IN mbox %d = 0x%04x", box,
4286 mbp->param[box]);
4287 ISP_WRITE(isp, MBOX_OFF(box), mbp->param[box]);
4288 }
4289 isp->isp_mboxtmp[box] = mbp->param[box] = 0;
4290 }
4291
3883}
3884
3885#define ISP_FC_IBITS(op) ((mbpfc[((op)<<3) + 0] << 24) | (mbpfc[((op)<<3) + 1] << 16) | (mbpfc[((op)<<3) + 2] << 8) | (mbpfc[((op)<<3) + 3]))
3886#define ISP_FC_OBITS(op) ((mbpfc[((op)<<3) + 4] << 24) | (mbpfc[((op)<<3) + 5] << 16) | (mbpfc[((op)<<3) + 6] << 8) | (mbpfc[((op)<<3) + 7]))
3887
3888#define ISP_FC_OPMAP(in0, out0) 0, 0, 0, in0, 0, 0, 0, out0
3889#define ISP_FC_OPMAP_HALF(in1, in0, out1, out0) 0, 0, in1, in0, 0, 0, out1, out0
3890#define ISP_FC_OPMAP_FULL(in3, in2, in1, in0, out3, out2, out1, out0) in3, in2, in1, in0, out3, out2, out1, out0

--- 311 unchanged lines hidden (view full) ---

4202 if (ibits & (1 << box)) {
4203 isp_prt(isp, ISP_LOGDEBUG3, "IN mbox %d = 0x%04x", box,
4204 mbp->param[box]);
4205 ISP_WRITE(isp, MBOX_OFF(box), mbp->param[box]);
4206 }
4207 isp->isp_mboxtmp[box] = mbp->param[box] = 0;
4208 }
4209
4292 isp->isp_lastmbxcmd = opcode;
4293 isp->isp_obits = obits;
4294 isp->isp_mboxbsy = 1;
4295
4296 /*
4297 * Set Host Interrupt condition so that RISC will pick up mailbox regs.
4298 */
4299 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_SET_HOST_INT);
4300

--- 11 unchanged lines hidden (view full) ---

4312 }
4313
4314 /*
4315 * Did the command time out?
4316 */
4317 if (isp->isp_mboxbsy) {
4318 isp->isp_mboxbsy = 0;
4319 isp_prt(isp, ISP_LOGWARN, "Mailbox Command (0x%x) Timeout (%uus) (%s:%d)",
4210 isp->isp_obits = obits;
4211 isp->isp_mboxbsy = 1;
4212
4213 /*
4214 * Set Host Interrupt condition so that RISC will pick up mailbox regs.
4215 */
4216 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_SET_HOST_INT);
4217

--- 11 unchanged lines hidden (view full) ---

4229 }
4230
4231 /*
4232 * Did the command time out?
4233 */
4234 if (isp->isp_mboxbsy) {
4235 isp->isp_mboxbsy = 0;
4236 isp_prt(isp, ISP_LOGWARN, "Mailbox Command (0x%x) Timeout (%uus) (%s:%d)",
4320 isp->isp_lastmbxcmd, to, mbp->func, mbp->lineno);
4237 opcode, to, mbp->func, mbp->lineno);
4321 mbp->param[0] = MBOX_TIMEOUT;
4322 goto out;
4323 }
4324
4325 /*
4326 * Copy back output registers.
4327 */
4328 for (box = 0; box < ISP_NMBOX(isp); box++) {

--- 305 unchanged lines hidden --- 		4238 mbp->param[0] = MBOX_TIMEOUT;
4239 goto out;
4240 }
4241
4242 /*
4243 * Copy back output registers.
4244 */
4245 for (box = 0; box < ISP_NMBOX(isp); box++) {

--- 305 unchanged lines hidden ---